diff --git a/.agents/skills/codexbar/SKILL.md b/.agents/skills/codexbar/SKILL.md
new file mode 100644
index 0000000000..abcc6e3b2d
--- /dev/null
+++ b/.agents/skills/codexbar/SKILL.md
@@ -0,0 +1,38 @@
+---
+name: codexbar
+description: "CodexBar read. Provider usage, limits, credits, config health. JSON. No writes."
+---
+
+# CodexBar
+
+Read CodexBar. Never mutate config/auth.
+
+## Run
+
+```bash
+skill="${CODEX_HOME:-$HOME/.codex}/skills/codexbar"
+"$skill/scripts/codexbar" doctor
+"$skill/scripts/codexbar" providers
+"$skill/scripts/codexbar" usage
+"$skill/scripts/codexbar" usage --provider codex
+"$skill/scripts/codexbar" usage --all
+```
+
+All stdout: JSON. Upstream CodexBar shape kept. Less drift, fewer tokens.
+
+## Rules
+
+- Start `doctor` when install/config unknown.
+- `usage` reads enabled providers. Prefer this.
+- `usage --provider ID` reads one provider.
+- `usage --all` expensive; use only when needed.
+- Identities hidden by default. `--include-identities` only when user explicitly needs them.
+- Secrets always hidden.
+- Helper read-only: fixed allowlist only. No config writes, auth repair, enable/disable, key storage.
+- Timeout means upstream stuck. Narrow provider or raise `CODEXBAR_TIMEOUT` (default 120 seconds).
+
+## Binary
+
+Auto-find: `CODEXBAR_BIN`, PATH, app bundle, Homebrew cask. If missing: open CodexBar, Preferences > Advanced > Install CLI; or set `CODEXBAR_BIN`.
+
+Each stdout/stderr stream capped at 1 MiB while fully drained. Timeout kills process group.
diff --git a/.agents/skills/codexbar/scripts/codexbar b/.agents/skills/codexbar/scripts/codexbar
new file mode 100755
index 0000000000..d60c8d45d4
--- /dev/null
+++ b/.agents/skills/codexbar/scripts/codexbar
@@ -0,0 +1,321 @@
+#!/usr/bin/env python3
+"""Read-only, bounded CodexBar CLI bridge."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import shutil
+import signal
+import subprocess
+import sys
+import threading
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Sequence
+
+
+MAX_CAPTURE_BYTES = 1024 * 1024
+DEFAULT_TIMEOUT = 120.0
+BIN_ENV = "CODEXBAR_BIN"
+TIMEOUT_ENV = "CODEXBAR_TIMEOUT"
+SKIP_DISCOVERY_ENV = "CODEXBAR_SKIP_DISCOVERY"
+
+SECRET = "<redacted:secret>"
+IDENTITY = "<redacted:identity>"
+EMAIL = "<redacted:email>"
+
+EMAIL_RE = re.compile(r"\b[A-Z0-9._%+\-]+@[A-Z0-9.\-]+\.[A-Z]{2,}\b", re.I)
+BEARER_RE = re.compile(r"(?i)\bbearer\s+[A-Z0-9._~+/=\-]+")
+JWT_RE = re.compile(r"\beyJ[A-Za-z0-9_\-]+\.[A-Za-z0-9_\-]+\.[A-Za-z0-9_\-]+\b")
+LABELED_SECRET_RE = re.compile(
+    r"(?i)\b(authorization|api[_-]?key|access[_-]?token|refresh[_-]?token|id[_-]?token|"
+    r"session(?:id)?|secret|password|passwd|cookie|set-cookie)(\s*[:=]\s*)([^\s,;]+)"
+)
+WORD_SECRET_RE = re.compile(
+    r"(?i)\b(token|secret|password|passwd|cookie)\s+([A-Z0-9._~+/=\-]{6,})\b"
+)
+SECRET_KEY_RE = re.compile(
+    r"(?i)(authorization|api[_-]?key|access[_-]?token|refresh[_-]?token|id[_-]?token|"
+    r"session(?:id)?|secret|password|passwd|cookie)"
+)
+IDENTITY_KEYS = {
+    "accountemail",
+    "accountorganization",
+    "accountid",
+    "accountname",
+    "email",
+    "organization",
+    "userid",
+    "username",
+}
+# ProviderIdentitySnapshot.providerID is UsageProvider, not an account identifier.
+
+
+@dataclass(frozen=True)
+class Binary:
+    path: str
+    source: str
+
+
+@dataclass(frozen=True)
+class Result:
+    returncode: int
+    stdout: bytes
+    stderr: bytes
+    timed_out: bool
+
+
+def normalized_key(value: str) -> str:
+    return re.sub(r"[^a-z0-9]", "", value.lower())
+
+
+def timeout_seconds() -> float:
+    try:
+        return max(1.0, float(os.environ.get(TIMEOUT_ENV, DEFAULT_TIMEOUT)))
+    except ValueError:
+        return DEFAULT_TIMEOUT
+
+
+def safe_path(path: str) -> str:
+    home = str(Path.home())
+    if path == home:
+        return "~"
+    if path.startswith(home + os.sep):
+        return "~" + path[len(home) :]
+    return re.sub(r"^/Users/[^/]+", "/Users/<redacted>", path)
+
+
+def candidates() -> list[tuple[str, Path]]:
+    found: list[tuple[str, Path]] = []
+    override = os.environ.get(BIN_ENV)
+    if override:
+        found.append(("env", Path(override).expanduser()))
+
+    path_hit = shutil.which("codexbar")
+    if path_hit:
+        found.append(("path", Path(path_hit)))
+
+    if os.environ.get(SKIP_DISCOVERY_ENV) == "1":
+        return found
+
+    home = Path.home()
+    found.extend(
+        [
+            ("homebrew", Path("/opt/homebrew/bin/codexbar")),
+            ("homebrew", Path("/usr/local/bin/codexbar")),
+            ("app", Path("/Applications/CodexBar.app/Contents/Helpers/CodexBarCLI")),
+            ("app", home / "Applications/CodexBar.app/Contents/Helpers/CodexBarCLI"),
+        ]
+    )
+    for root in (Path("/opt/homebrew/Caskroom/codexbar"), Path("/usr/local/Caskroom/codexbar")):
+        found.extend(("cask", app / "Contents/Helpers/CodexBarCLI") for app in sorted(root.glob("*/CodexBar.app")))
+    return found
+
+
+def resolve_binary() -> Binary | None:
+    self_path = Path(__file__).resolve()
+    seen: set[Path] = set()
+    for source, candidate in candidates():
+        try:
+            resolved = candidate.resolve()
+            if resolved in seen or resolved == self_path:
+                continue
+            seen.add(resolved)
+            if resolved.is_file() and os.access(resolved, os.X_OK):
+                return Binary(str(resolved), source)
+        except OSError:
+            continue
+    return None
+
+
+def drain(pipe: Any, target: bytearray) -> None:
+    try:
+        while True:
+            chunk = pipe.read(65536)
+            if not chunk:
+                break
+            room = MAX_CAPTURE_BYTES - len(target)
+            if room > 0:
+                target.extend(chunk[:room])
+    finally:
+        pipe.close()
+
+
+def stop_group(process: subprocess.Popen[bytes], sig: signal.Signals) -> None:
+    try:
+        os.killpg(process.pid, sig)
+    except ProcessLookupError:
+        pass
+
+
+def run_process(argv: Sequence[str]) -> Result:
+    process = subprocess.Popen(
+        list(argv),
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        start_new_session=True,
+    )
+    assert process.stdout is not None
+    assert process.stderr is not None
+    stdout = bytearray()
+    stderr = bytearray()
+    readers = [
+        threading.Thread(target=drain, args=(process.stdout, stdout), daemon=True),
+        threading.Thread(target=drain, args=(process.stderr, stderr), daemon=True),
+    ]
+    for reader in readers:
+        reader.start()
+
+    timed_out = False
+    try:
+        process.wait(timeout=timeout_seconds())
+    except subprocess.TimeoutExpired:
+        timed_out = True
+        stop_group(process, signal.SIGTERM)
+        try:
+            process.wait(timeout=2)
+        except subprocess.TimeoutExpired:
+            stop_group(process, signal.SIGKILL)
+            process.wait()
+
+    for reader in readers:
+        reader.join(timeout=3)
+    return Result(124 if timed_out else process.returncode, bytes(stdout), bytes(stderr), timed_out)
+
+
+def decode(value: bytes) -> str:
+    return value.decode("utf-8", errors="replace")
+
+
+def sanitize_text(value: str, include_identities: bool) -> str:
+    value = JWT_RE.sub(SECRET, value)
+    value = BEARER_RE.sub("Bearer " + SECRET, value)
+    value = LABELED_SECRET_RE.sub(lambda match: match.group(1) + match.group(2) + SECRET, value)
+    value = WORD_SECRET_RE.sub(lambda match: match.group(1) + " " + SECRET, value)
+    if not include_identities:
+        value = EMAIL_RE.sub(EMAIL, value)
+    return value
+
+
+def sanitize(value: Any, include_identities: bool, key: str | None = None) -> Any:
+    if key and SECRET_KEY_RE.search(key):
+        return SECRET
+    if key and normalized_key(key) in IDENTITY_KEYS and not include_identities and value is not None:
+        return EMAIL if "email" in normalized_key(key) else IDENTITY
+    if isinstance(value, dict):
+        return {str(child_key): sanitize(child, include_identities, str(child_key)) for child_key, child in value.items()}
+    if isinstance(value, list):
+        return [sanitize(child, include_identities) for child in value]
+    if isinstance(value, str):
+        return sanitize_text(value, include_identities)
+    return value
+
+
+def print_json(value: Any) -> None:
+    print(json.dumps(value, indent=2, sort_keys=True))
+
+
+def print_error(kind: str, message: str, *, binary: Binary | None = None) -> None:
+    payload: dict[str, Any] = {"error": {"kind": kind, "message": sanitize_text(message, False)}}
+    if binary:
+        payload["binary"] = {"path": safe_path(binary.path), "source": binary.source}
+    print_json(payload)
+
+
+def emit_stderr(result: Result, include_identities: bool) -> None:
+    text = sanitize_text(decode(result.stderr), include_identities).strip()
+    if text:
+        print(text, file=sys.stderr)
+
+
+def read_json(binary: Binary, argv: Sequence[str], include_identities: bool) -> int:
+    result = run_process([binary.path, *argv])
+    emit_stderr(result, include_identities)
+    if result.timed_out:
+        print_error("timeout", f"CodexBar exceeded {timeout_seconds():g}s and was stopped.", binary=binary)
+        return 124
+    try:
+        payload = json.loads(decode(result.stdout))
+    except json.JSONDecodeError as error:
+        preview = sanitize_text(decode(result.stdout[:400]), False)
+        print_error("invalid_json", f"CodexBar JSON failed: {error.msg}. stdout={preview!r}", binary=binary)
+        return result.returncode or 1
+    print_json(sanitize(payload, include_identities))
+    return result.returncode
+
+
+def doctor(binary: Binary, include_identities: bool) -> int:
+    version = run_process([binary.path, "--version"])
+    if version.timed_out:
+        print_error("timeout", f"CodexBar version exceeded {timeout_seconds():g}s.", binary=binary)
+        return 124
+    validation = run_process([binary.path, "config", "validate", "--format", "json", "--json-only"])
+    emit_stderr(version, include_identities)
+    emit_stderr(validation, include_identities)
+    if validation.timed_out:
+        print_error("timeout", f"CodexBar config validation exceeded {timeout_seconds():g}s.", binary=binary)
+        return 124
+    try:
+        issues = json.loads(decode(validation.stdout))
+    except json.JSONDecodeError as error:
+        print_error("invalid_json", f"CodexBar config validation failed: {error.msg}.", binary=binary)
+        return validation.returncode or 1
+    print_json(
+        {
+            "binary": {"path": safe_path(binary.path), "source": binary.source},
+            "configIssues": sanitize(issues, include_identities),
+            "version": sanitize_text((decode(version.stdout) or decode(version.stderr)).strip(), include_identities),
+        }
+    )
+    return version.returncode or validation.returncode
+
+
+def parser() -> argparse.ArgumentParser:
+    root = argparse.ArgumentParser(prog="codexbar", description="CodexBar read. JSON out. No writes.")
+    commands = root.add_subparsers(dest="command", required=True)
+    for name in ("doctor", "providers"):
+        command = commands.add_parser(name)
+        command.add_argument("--include-identities", action="store_true")
+    usage = commands.add_parser("usage")
+    scope = usage.add_mutually_exclusive_group()
+    scope.add_argument("--all", action="store_true")
+    scope.add_argument("--provider")
+    usage.add_argument("--include-identities", action="store_true")
+    return root
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = parser().parse_args(argv)
+    binary = resolve_binary()
+    if not binary:
+        print_error("missing", "CodexBar CLI not found. Install CLI in CodexBar Advanced settings or set CODEXBAR_BIN.")
+        return 1
+    try:
+        if args.command == "doctor":
+            return doctor(binary, args.include_identities)
+        if args.command == "providers":
+            return read_json(
+                binary,
+                ["config", "providers", "--format", "json", "--json-only"],
+                args.include_identities,
+            )
+        usage_args = ["usage", "--format", "json", "--json-only"]
+        if args.all:
+            usage_args.extend(["--provider", "all"])
+        elif args.provider:
+            usage_args.extend(["--provider", args.provider])
+        return read_json(binary, usage_args, args.include_identities)
+    except OSError as error:
+        print_error("launch", str(error), binary=binary)
+        return 1
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(main())
+    except KeyboardInterrupt:
+        print_error("interrupted", "Interrupted.")
+        raise SystemExit(130)
diff --git a/.agents/skills/codexbar/scripts/test_codexbar.py b/.agents/skills/codexbar/scripts/test_codexbar.py
new file mode 100644
index 0000000000..ceb9dc7450
--- /dev/null
+++ b/.agents/skills/codexbar/scripts/test_codexbar.py
@@ -0,0 +1,231 @@
+from __future__ import annotations
+
+import json
+import os
+import runpy
+import subprocess
+import sys
+import tempfile
+import textwrap
+import time
+import unittest
+from pathlib import Path
+
+
+SCRIPT = Path(__file__).with_name("codexbar")
+MODULE = runpy.run_path(str(SCRIPT), run_name="codexbar_skill")
+MAX_CAPTURE_BYTES = MODULE["MAX_CAPTURE_BYTES"]
+run_process = MODULE["run_process"]
+
+FAKE = textwrap.dedent(
+    """\
+    #!/usr/bin/env python3
+    import json
+    import os
+    import subprocess
+    import sys
+    import time
+
+    argv = sys.argv[1:]
+    log = os.environ.get("FAKE_LOG")
+    if log:
+        with open(log, "a", encoding="utf-8") as handle:
+            handle.write(json.dumps(argv) + "\\n")
+
+    if argv == ["--version"]:
+        key = "VERSION"
+    elif argv[:2] == ["config", "validate"]:
+        key = "VALIDATE"
+    elif argv[:2] == ["config", "providers"]:
+        key = "PROVIDERS"
+    elif argv and argv[0] == "usage":
+        key = "USAGE"
+    else:
+        key = "OTHER"
+
+    if os.environ.get("FAKE_SPAWN_CHILD") == "1":
+        marker = os.environ["FAKE_MARKER"]
+        subprocess.Popen([
+            sys.executable,
+            "-c",
+            f"import pathlib,time; time.sleep(2); pathlib.Path({marker!r}).write_text('alive')",
+        ])
+        time.sleep(5)
+
+    delay = os.environ.get(f"FAKE_{key}_DELAY")
+    if delay:
+        time.sleep(float(delay))
+    stdout = os.environ.get(f"FAKE_{key}_STDOUT", "")
+    stderr = os.environ.get(f"FAKE_{key}_STDERR", "")
+    sys.stdout.write(stdout)
+    sys.stderr.write(stderr)
+    raise SystemExit(int(os.environ.get(f"FAKE_{key}_EXIT", "0")))
+    """
+)
+
+
+def make_env(root: Path, *, install: bool = True) -> tuple[dict[str, str], Path]:
+    binary = root / "CodexBar.app" / "Contents" / "Helpers" / "CodexBarCLI"
+    binary.parent.mkdir(parents=True)
+    binary.write_text(FAKE, encoding="utf-8")
+    binary.chmod(0o755)
+    env = os.environ.copy()
+    env["CODEXBAR_SKIP_DISCOVERY"] = "1"
+    env["CODEXBAR_TIMEOUT"] = "3"
+    env["FAKE_LOG"] = str(root / "argv.log")
+    env["FAKE_VERSION_STDOUT"] = "CodexBar 1.2.3\n"
+    env["FAKE_VALIDATE_STDOUT"] = "[]"
+    env["FAKE_PROVIDERS_STDOUT"] = json.dumps(
+        [{"provider": "codex", "displayName": "Codex", "enabled": True}]
+    )
+    env["FAKE_USAGE_STDOUT"] = json.dumps(
+        [
+            {
+                "provider": "codex",
+                "source": "oauth",
+                "usage": {
+                    "accountEmail": "alice@example.com",
+                    "accountOrganization": "Example Org",
+                    "identity": {"providerID": "codex", "accountID": "acct-123"},
+                    "primary": {"usedPercent": 42, "windowMinutes": 300},
+                },
+            }
+        ]
+    )
+    if install:
+        env["CODEXBAR_BIN"] = str(binary)
+    else:
+        env.pop("CODEXBAR_BIN", None)
+        env["PATH"] = "/usr/bin:/bin:/usr/sbin:/sbin"
+    return env, binary
+
+
+def helper(*args: str, env: dict[str, str], cwd: Path | None = None) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        [sys.executable, str(SCRIPT), *args],
+        capture_output=True,
+        text=True,
+        check=False,
+        env=env,
+        cwd=cwd,
+    )
+
+
+class CodexBarSkillTests(unittest.TestCase):
+    def test_help_is_small_and_read_only(self) -> None:
+        result = helper("--help", env=os.environ.copy())
+        self.assertEqual(result.returncode, 0)
+        self.assertIn("CodexBar read. JSON out. No writes.", result.stdout)
+        self.assertNotIn("enable", result.stdout)
+        self.assertNotIn("set-api-key", result.stdout)
+
+    def test_missing_binary_is_json(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            env, _ = make_env(Path(tmp), install=False)
+            result = helper("doctor", env=env)
+        self.assertEqual(result.returncode, 1)
+        self.assertEqual(json.loads(result.stdout)["error"]["kind"], "missing")
+
+    def test_doctor_reports_version_and_raw_validation_shape(self) -> None:
+        with tempfile.TemporaryDirectory(dir=Path.home()) as tmp:
+            env, binary = make_env(Path(tmp))
+            result = helper("doctor", env=env)
+        self.assertEqual(result.returncode, 0)
+        payload = json.loads(result.stdout)
+        self.assertEqual(payload["version"], "CodexBar 1.2.3")
+        self.assertEqual(payload["configIssues"], [])
+        self.assertEqual(payload["binary"]["path"], "~" + str(binary)[len(str(Path.home())) :])
+
+    def test_providers_passes_upstream_json_without_second_schema(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            env, _ = make_env(Path(tmp))
+            result = helper("providers", env=env)
+        self.assertEqual(result.returncode, 0)
+        self.assertEqual(
+            json.loads(result.stdout),
+            [{"provider": "codex", "displayName": "Codex", "enabled": True}],
+        )
+
+    def test_usage_defaults_to_enabled_and_runs_from_any_cwd(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            env, _ = make_env(root)
+            elsewhere = root / "elsewhere"
+            elsewhere.mkdir()
+            result = helper("usage", env=env, cwd=elsewhere)
+            calls = [json.loads(line) for line in (root / "argv.log").read_text().splitlines()]
+        self.assertEqual(result.returncode, 0)
+        self.assertEqual(calls, [["usage", "--format", "json", "--json-only"]])
+
+    def test_usage_scope_maps_to_upstream_cli(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            env, _ = make_env(root)
+            self.assertEqual(helper("usage", "--all", env=env).returncode, 0)
+            self.assertEqual(helper("usage", "--provider", "zai", env=env).returncode, 0)
+            calls = [json.loads(line) for line in (root / "argv.log").read_text().splitlines()]
+        self.assertEqual(calls[0][-2:], ["--provider", "all"])
+        self.assertEqual(calls[1][-2:], ["--provider", "zai"])
+
+    def test_usage_hides_identity_but_preserves_provider_id(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            env, _ = make_env(Path(tmp))
+            env["FAKE_USAGE_STDERR"] = (
+                "Authorization: Bearer secret-token alice@example.com; token sk-live-prose-secret\n"
+            )
+            result = helper("usage", env=env)
+        payload = json.loads(result.stdout)[0]
+        self.assertEqual(payload["provider"], "codex")
+        self.assertEqual(payload["usage"]["identity"]["providerID"], "codex")
+        self.assertEqual(payload["usage"]["accountEmail"], "<redacted:email>")
+        self.assertEqual(payload["usage"]["accountOrganization"], "<redacted:identity>")
+        self.assertEqual(payload["usage"]["identity"]["accountID"], "<redacted:identity>")
+        self.assertNotIn("secret-token", result.stderr)
+        self.assertNotIn("sk-live-prose-secret", result.stderr)
+        self.assertIn("<redacted:secret>", result.stderr)
+
+    def test_include_identities_never_exposes_secret_keys(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            env, _ = make_env(Path(tmp))
+            payload = json.loads(env["FAKE_USAGE_STDOUT"])
+            payload[0]["usage"]["apiKey"] = "super-secret"
+            env["FAKE_USAGE_STDOUT"] = json.dumps(payload)
+            result = helper("usage", "--include-identities", env=env)
+        usage = json.loads(result.stdout)[0]["usage"]
+        self.assertEqual(usage["accountEmail"], "alice@example.com")
+        self.assertEqual(usage["apiKey"], "<redacted:secret>")
+
+    def test_each_stream_is_capped_while_fully_drained(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            writer = root / "writer"
+            writer.write_text(
+                "#!/usr/bin/env python3\n"
+                "import sys\n"
+                "sys.stdout.buffer.write(b'o' * 2000000)\n"
+                "sys.stderr.buffer.write(b'e' * 2000000)\n",
+                encoding="utf-8",
+            )
+            writer.chmod(0o755)
+            result = run_process([str(writer)])
+        self.assertEqual(result.returncode, 0)
+        self.assertEqual(len(result.stdout), MAX_CAPTURE_BYTES)
+        self.assertEqual(len(result.stderr), MAX_CAPTURE_BYTES)
+
+    def test_timeout_kills_process_group(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            env, _ = make_env(root)
+            marker = root / "child-survived"
+            env["CODEXBAR_TIMEOUT"] = "1"
+            env["FAKE_SPAWN_CHILD"] = "1"
+            env["FAKE_MARKER"] = str(marker)
+            result = helper("usage", env=env)
+            time.sleep(2.2)
+        self.assertEqual(result.returncode, 124)
+        self.assertEqual(json.loads(result.stdout)["error"]["kind"], "timeout")
+        self.assertFalse(marker.exists())
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/.agents/skills/qa-test/SKILL.md b/.agents/skills/qa-test/SKILL.md
new file mode 100644
index 0000000000..81c752a165
--- /dev/null
+++ b/.agents/skills/qa-test/SKILL.md
@@ -0,0 +1,118 @@
+---
+name: qa-test
+description: "CodexBar live QA/e2e testing: run provider usage matrix checks, validate real app config, use Peekaboo for menu proof, use Browser Use/official docs for API spec or logged-in dashboard checks, and handle 1Password credentials safely."
+---
+
+# CodexBar Live QA
+
+Use for live provider testing, release smoke tests, menu verification, or debugging “provider works/fails” reports.
+
+## Rules
+
+- Work from the CodexBar repo checkout.
+- Use the packaged CLI first: `CodexBar.app/Contents/Helpers/CodexBarCLI`.
+- Do not use `CodexBar.app/Contents/MacOS/codexbar`; that is the app binary and may appear to hang as a CLI.
+- Never run broad `env`, `set`, or secret regex dumps.
+- Use `$one-password` for secrets: all `op` commands inside one persistent tmux session, service account first, no raw secret output.
+- Treat browser-cookie/keychain flows as prompt-risky. Prefer CLI/API-token checks and `KeychainNoUIQuery`-safe tests unless the user explicitly requested live UI.
+- For current API behavior, browse official provider docs only.
+
+## CLI Matrix
+
+Run the bundled script:
+
+```bash
+.agents/skills/qa-test/scripts/live_provider_matrix.sh --enabled
+```
+
+Useful modes:
+
+```bash
+.agents/skills/qa-test/scripts/live_provider_matrix.sh --provider all
+.agents/skills/qa-test/scripts/live_provider_matrix.sh --providers openai,zai,deepseek
+.agents/skills/qa-test/scripts/live_provider_matrix.sh --default
+```
+
+Interpretation:
+
+- `--enabled` asks `CodexBarCLI config providers` for enabled providers, honoring `CODEXBAR_CONFIG` and default toggles.
+- `--default` runs the app-facing default command with no provider override.
+- `--provider all` forces every registered provider and is expected to fail for providers without sessions/keys.
+- A green app config needs `--enabled` and `--default` clean; `--provider all` is a discovery/triage tool.
+
+## Config QA
+
+Validate config:
+
+```bash
+CodexBar.app/Contents/Helpers/CodexBarCLI config validate
+stat -f '%Lp %N' "$HOME/.codexbar/config.json"
+```
+
+Redact config shape:
+
+```bash
+jq '(.providers // []) |= map(.apiKey = (if .apiKey then "<redacted>" else .apiKey end) |
+  .secretKey = (if .secretKey then "<redacted>" else .secretKey end) |
+  .cookieHeader = (if .cookieHeader then "<redacted>" else .cookieHeader end) |
+  (if .id == "stepfun" and has("region") then .region = "<redacted>" else . end) |
+  .tokenAccounts = (if .tokenAccounts then (.tokenAccounts | .accounts = (.accounts | map(.token = "<redacted>"))) else .tokenAccounts end))' \
+  "$HOME/.codexbar/config.json"
+```
+
+Before editing config, make a backup:
+
+```bash
+cp "$HOME/.codexbar/config.json" "$HOME/.codexbar/config.pre-qa-$(date +%Y%m%d%H%M%S).json"
+chmod 600 "$HOME/.codexbar"/config.pre-qa-*.json
+```
+
+## Live Menu QA
+
+Use Peekaboo after CLI checks:
+
+```bash
+pkill -x CodexBar || pkill -f 'CodexBar.app/Contents/MacOS/CodexBar' || true
+open -n "$PWD/CodexBar.app"
+peekaboo menu list-all --json | rg -i 'codexbar'
+peekaboo menu click-extra --title codexbar-merged --json
+screencapture -x /tmp/codexbar-live-menu.png
+```
+
+Crop top-right menu if needed:
+
+```bash
+sips --cropToHeightWidth 900 340 --cropOffset 20 2650 /tmp/codexbar-live-menu.png \
+  --out /tmp/codexbar-live-menu-crop.png >/dev/null
+```
+
+Verify visually with `view_image`. Confirm provider tabs/rows match enabled config and no failing provider dominates the first screen.
+
+## Browser Use
+
+Use `$browser-use` only when a logged-in dashboard, API key page, or provider docs need browser/profile state.
+
+Existing Chrome path:
+
+```bash
+mcporter call chrome-devtools.list_pages --args '{}' --output text
+mcporter call chrome-devtools.navigate_page --args '{"url":"https://provider.example"}' --output text
+mcporter call chrome-devtools.take_snapshot --args '{}' --output text
+```
+
+If Browser Use is unavailable, say so and use web search for public official docs; do not substitute isolated Playwright for login/profile-dependent pages.
+
+## Fix Triage
+
+- Missing auth/session: configure key/session if available; otherwise leave provider disabled or report blocked auth.
+- Wrong provider API/spec: inspect official docs, then patch fetcher/settings/tests.
+- Provider key exists but live API rejects it: keep key stored if useful, disable provider if the menu would show a persistent error.
+- User-facing behavior changes need `CHANGELOG.md`.
+- Code fixes need focused tests, `make check`, `$autoreview`, and live CLI proof before landing.
+
+## Known CodexBar QA Notes
+
+- OpenAI Admin API key is the useful usage provider key. Project `OPENAI_API_KEY` values can fail legacy credit-balance fallback with 403.
+- Deepgram usage requires a key/project with Management API permissions; transcription-only keys can return 403.
+- Groq usage uses the Prometheus metrics API, not ordinary inference endpoints.
+- MiniMax pay-as-you-go API keys and Token Plan/Coding Plan keys are different; wrong key kind can leave usage unavailable.
diff --git a/.agents/skills/qa-test/agents/openai.yaml b/.agents/skills/qa-test/agents/openai.yaml
new file mode 100644
index 0000000000..3bf7a7b278
--- /dev/null
+++ b/.agents/skills/qa-test/agents/openai.yaml
@@ -0,0 +1,4 @@
+interface:
+  display_name: "CodexBar QA Test"
+  short_description: "Run live CodexBar CLI and menu QA safely."
+  default_prompt: "Run CodexBar live QA with CLI, Peekaboo, browser docs, and 1Password-safe credential checks."
diff --git a/.agents/skills/qa-test/references/api-specs.md b/.agents/skills/qa-test/references/api-specs.md
new file mode 100644
index 0000000000..8bb7298c6f
--- /dev/null
+++ b/.agents/skills/qa-test/references/api-specs.md
@@ -0,0 +1,10 @@
+# API Spec Pointers
+
+Use current official docs for provider API behavior. Prefer these searches/pages before patching fetchers:
+
+- MiniMax: `https://platform.minimax.io/docs/llms.txt`; key types differ between pay-as-you-go API keys and Token Plan/Coding Plan keys.
+- Deepgram: `https://developers.deepgram.com/llms.txt`; usage/project APIs require Management permissions and project-scoped keys.
+- Groq: `https://console.groq.com/docs/prometheus-metrics`; usage metrics use `https://api.groq.com/v1/metrics/prometheus`.
+- LLM Proxy/LiteLLM: `https://docs.litellm.ai/`; CodexBar expects an LLM-API-Key-Proxy compatible `/v1/quota-stats` endpoint plus base URL.
+
+When citing docs in a user-facing answer, browse the current page and include source links.
diff --git a/.agents/skills/qa-test/scripts/live_provider_matrix.sh b/.agents/skills/qa-test/scripts/live_provider_matrix.sh
new file mode 100755
index 0000000000..0c8240ce05
--- /dev/null
+++ b/.agents/skills/qa-test/scripts/live_provider_matrix.sh
@@ -0,0 +1,183 @@
+#!/usr/bin/env bash
+set -u
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../../../.." && pwd)"
+CLI="${CODEXBAR_CLI:-$ROOT/CodexBar.app/Contents/Helpers/CodexBarCLI}"
+TIMEOUT_BIN="${TIMEOUT_BIN:-$(command -v gtimeout || command -v timeout || true)}"
+WEB_TIMEOUT="${CODEXBAR_QA_WEB_TIMEOUT:-12}"
+CASE_TIMEOUT="${CODEXBAR_QA_CASE_TIMEOUT:-60}"
+
+usage() {
+  cat <<'USAGE'
+Usage:
+  live_provider_matrix.sh --enabled
+  live_provider_matrix.sh --default
+  live_provider_matrix.sh --provider all
+  live_provider_matrix.sh --providers openai,zai,deepseek
+
+Environment:
+  CODEXBAR_CLI=/path/to/CodexBarCLI
+  CODEXBAR_CONFIG=/path/to/config.json
+  CODEXBAR_QA_WEB_TIMEOUT=12
+  CODEXBAR_QA_CASE_TIMEOUT=60
+USAGE
+}
+
+if [[ ! -x "$CLI" ]]; then
+  echo "missing CodexBarCLI at $CLI" >&2
+  exit 2
+fi
+if [[ -z "$TIMEOUT_BIN" ]]; then
+  echo "missing timeout command (install coreutils for gtimeout)" >&2
+  exit 2
+fi
+if ! command -v node >/dev/null 2>&1; then
+  echo "missing node" >&2
+  exit 2
+fi
+
+mode="${1:-}"
+shift || true
+
+providers=()
+case "$mode" in
+  --enabled)
+    provider_status="$(mktemp)"
+    provider_err="$(mktemp)"
+    provider_list="$(mktemp)"
+    if ! "$CLI" config providers --format json --json-only >"$provider_status" 2>"$provider_err"; then
+      rm -f "$provider_status" "$provider_err" "$provider_list"
+      echo "failed to list providers via CodexBarCLI config providers" >&2
+      exit 2
+    fi
+    if ! node - "$provider_status" >"$provider_list" <<'NODE'; then
+const fs = require("fs");
+const path = process.argv[2];
+const raw = fs.readFileSync(path, "utf8").trim();
+const payload = JSON.parse(raw);
+if (!Array.isArray(payload)) {
+  throw new Error("config providers output is not an array");
+}
+for (const item of payload) {
+  if (item && item.enabled === true && typeof item.provider === "string" && item.provider) {
+    console.log(item.provider);
+  }
+}
+NODE
+      rm -f "$provider_status" "$provider_err" "$provider_list"
+      echo "failed to parse CodexBarCLI config providers output" >&2
+      exit 2
+    fi
+    while IFS= read -r provider; do
+      [[ -n "$provider" ]] && providers+=("$provider")
+    done <"$provider_list"
+    rm -f "$provider_status" "$provider_err" "$provider_list"
+    if [[ "${#providers[@]}" -eq 0 ]]; then
+      echo "no enabled providers found via CodexBarCLI config providers" >&2
+      exit 2
+    fi
+    ;;
+  --default)
+    providers=("__default__")
+    ;;
+  --provider)
+    if [[ -z "${1:-}" ]]; then
+      echo "missing provider" >&2
+      exit 2
+    fi
+    providers=("${1:-}")
+    ;;
+  --providers)
+    if [[ -z "${1:-}" ]]; then
+      echo "missing providers" >&2
+      exit 2
+    fi
+    IFS=',' read -r -a providers <<< "${1:-}"
+    ;;
+  -h|--help|"")
+    usage
+    exit 0
+    ;;
+  *)
+    echo "unknown mode: $mode" >&2
+    usage >&2
+    exit 2
+    ;;
+esac
+
+redact_node='
+const redact = s => String(s || "")
+  .replace(/[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+/g, "<email>")
+  .replace(/sk-[A-Za-z0-9_-]{12,}/g, "sk-REDACTED")
+  .replace(/gsk_[A-Za-z0-9_-]{12,}/g, "gsk_REDACTED")
+  .replace(/[A-Za-z0-9_-]{32,}/g, m => /[A-Za-z]/.test(m) && /[0-9]/.test(m) ? "<redacted-token>" : m);
+'
+
+run_one() {
+  local name="$1"
+  shift
+  local out err start end elapsed st node_status
+  out="$(mktemp)"
+  err="$(mktemp)"
+  start="$(date +%s)"
+  "$TIMEOUT_BIN" "$CASE_TIMEOUT" "$CLI" usage "$@" --format json --json-only --web-timeout "$WEB_TIMEOUT" >"$out" 2>"$err"
+  st=$?
+  end="$(date +%s)"
+  elapsed=$((end - start))
+  node - "$name" "$st" "$elapsed" "$out" "$err" <<NODE
+const fs = require("fs");
+$redact_node
+const [name, st, elapsed, outPath, errPath] = process.argv.slice(2);
+const raw = fs.readFileSync(outPath, "utf8").trim();
+const err = fs.readFileSync(errPath, "utf8").trim();
+let rows = [];
+let formatterFailed = false;
+try {
+  const payload = raw ? JSON.parse(raw) : [];
+  const arr = Array.isArray(payload) ? payload : [payload];
+  for (const p of arr) {
+    rows.push(
+      \`\${p.provider || name}:\${p.error ? "fail" : "ok"}:source=\${p.source || "unknown"}\` +
+      (p.account ? \`,account=\${redact(p.account)}\` : "") +
+      (p.usage ? ",usage=yes" : "") +
+      (p.credits ? ",credits=yes" : "") +
+      (p.error ? \`,error=\${redact(p.error.message).slice(0, 180)}\` : "")
+    );
+  }
+} catch (error) {
+  formatterFailed = true;
+  rows.push(\`\${name}:parse-fail:error=\${redact(error.message)} stdout=\${redact(raw).slice(0, 200)} stderr=\${redact(err).slice(0, 200)}\`);
+}
+if (!rows.length) {
+  formatterFailed = true;
+  rows.push(\`\${name}:empty:stderr=\${redact(err).slice(0, 200)}\`);
+}
+console.log(\`TEST \${name} exit=\${st} elapsed=\${elapsed}s :: \${rows.join(" | ")}\`);
+if (formatterFailed) process.exit(1);
+NODE
+  node_status=$?
+  rm -f "$out" "$err"
+  if [[ "$node_status" -ne 0 ]]; then
+    return 1
+  fi
+  return "$st"
+}
+
+overall=0
+ran=0
+for provider in "${providers[@]}"; do
+  [[ -z "$provider" ]] && continue
+  ran=$((ran + 1))
+  if [[ "$provider" == "__default__" ]]; then
+    run_one default || overall=1
+  elif [[ "$provider" == "all" ]]; then
+    run_one all --provider all || overall=1
+  else
+    run_one "$provider" --provider "$provider" || overall=1
+  fi
+done
+if [[ "$ran" -eq 0 ]]; then
+  echo "no provider cases ran" >&2
+  exit 2
+fi
+exit "$overall"
diff --git a/.agents/skills/release-codexbar/SKILL.md b/.agents/skills/release-codexbar/SKILL.md
new file mode 100644
index 0000000000..2d823e80df
--- /dev/null
+++ b/.agents/skills/release-codexbar/SKILL.md
@@ -0,0 +1,141 @@
+---
+name: release-codexbar
+description: "CodexBar release: versioning, notarization, appcast, Homebrew, post-release bump."
+---
+
+# CodexBar Release
+
+Use for releasing signed/notarized macOS apps, especially repos with Sparkle appcasts and Homebrew casks.
+
+## Start
+
+1. Work from the app repo unless asked otherwise.
+2. Check repo state, current version, latest tag/release, and release docs/scripts.
+3. Confirm `CHANGELOG.md` is complete, user-facing, deduped, and dated for the release.
+4. Prefer the repo release script; patch small script/test blockers instead of bypassing the release path.
+5. Never print key material. Keep 1Password references and local key paths as references only.
+6. Load `$release-private` if it exists before resolving Peter-owned credential locators.
+
+## Key Material
+
+Use `$one-password` for secret handling. `op` only in tmux/persistent shell; no broad `env`, `set`, `export -p`, or secret scans.
+
+Known App Store Connect shape:
+
+- fields: `private_key_p8`, `key_id`, `issuer_id`
+- keep all three fields from the same 1Password item; do not mix with stale values from `~/.profile`
+- resolve Peter-owned item refs from `$release-private`
+
+Known Sparkle key:
+
+- resolve the private key file from `$release-private`
+- pass as `SPARKLE_PRIVATE_KEY_FILE`
+
+Safe env file pattern:
+
+```text
+APP_STORE_CONNECT_API_KEY_P8=<1Password ref from release-private>
+APP_STORE_CONNECT_KEY_ID=<1Password ref from release-private>
+APP_STORE_CONNECT_ISSUER_ID=<1Password ref from release-private>
+SPARKLE_PRIVATE_KEY_FILE=<path from release-private>
+```
+
+Run with `op run --account my.1password.com --env-file <file> -- <script>`, then delete the temp env file.
+
+## CodexBar
+
+Paths:
+
+- repo: `~/Projects/codexbar`
+- release script: `Scripts/release.sh`
+- signing/notarization: `Scripts/sign-and-notarize.sh`
+- appcast: `Scripts/make_appcast.sh`, `appcast.xml`
+- release assets: `CodexBar-macos-universal-<version>.zip`, `CodexBar-macos-universal-<version>.dSYM.zip`
+- packaged app: `CodexBar.app`
+- version file: `version.env`
+- changelog: `CHANGELOG.md`
+- Homebrew tap: `~/Projects/homebrew-tap`
+- cask: `~/Projects/homebrew-tap/Casks/codexbar.rb`
+- formula: `~/Projects/homebrew-tap/Formula/codexbar.rb`
+- CLI release workflow: `.github/workflows/release-cli.yml`
+
+Normal release:
+
+```bash
+tmux new-session -d -s codexbar-release 'op run --account my.1password.com --env-file /tmp/codexbar-release-op.env -- Scripts/release.sh'
+tmux attach -t codexbar-release
+```
+
+If notarization fails with `401 Unauthenticated`, rerun using all three App Store Connect fields from the 1Password item above. Mismatched `key_id` / `issuer_id` from `~/.profile` can cause this.
+
+If widget metadata generation times out, `CODEXBAR_WIDGET_METADATA_TIMEOUT_SECONDS=600` is a known-good floor.
+
+CodexBar CLI tarballs are not produced by `Scripts/release.sh` itself. The GitHub release event triggers `.github/workflows/release-cli.yml`, which builds and uploads:
+
+- `CodexBarCLI-v<version>-macos-arm64.tar.gz`
+- `CodexBarCLI-v<version>-macos-x86_64.tar.gz`
+- `CodexBarCLI-v<version>-linux-aarch64.tar.gz`
+- `CodexBarCLI-v<version>-linux-x86_64.tar.gz`
+- matching `.sha256` files
+
+If the workflow fails only in `update-homebrew-tap` with GitHub API rate limiting, the CLI assets may already be uploaded. Verify assets live, then update `Formula/codexbar.rb` manually from the tarball checksums.
+
+## Verify
+
+Release is not done until the published chain checks out:
+
+```bash
+gh release view v<VERSION> --json tagName,name,isDraft,isPrerelease,url,assets,body
+Scripts/check-release-assets.sh v<VERSION>
+python3 - <<'PY'
+import xml.etree.ElementTree as ET
+ns={'sparkle':'http://www.andymatuschak.org/xml-namespaces/sparkle'}
+root=ET.parse('appcast.xml').getroot()
+item=root.find('channel').find('item')
+enc=item.find('enclosure')
+print(item.findtext('title'))
+print(item.findtext('sparkle:version', namespaces=ns))
+print(item.findtext('sparkle:shortVersionString', namespaces=ns))
+print(enc.attrib.get('url'))
+print(enc.attrib.get('length'))
+print(bool(enc.attrib.get('{http://www.andymatuschak.org/xml-namespaces/sparkle}edSignature')))
+PY
+codesign --verify --deep --strict --verbose=2 CodexBar.app
+spctl --assess --type execute --verbose CodexBar.app
+```
+
+For Homebrew:
+
+```bash
+shasum -a 256 CodexBar-macos-universal-<VERSION>.zip
+cd /Users/steipete/Projects/homebrew-tap
+python3 .github/scripts/update_formula.py --formula codexbar --tag v<VERSION> --repository steipete/CodexBar --artifact-template 'CodexBarCLI-{tag}-{target}.tar.gz' --target-aliases 'darwin_arm64=macos-arm64,darwin_amd64=macos-x86_64,linux_arm64=linux-aarch64,linux_amd64=linux-x86_64'
+brew fetch --cask --force --retry codexbar
+brew fetch --formula --force --retry steipete/tap/codexbar
+```
+
+Update the cask when app zip assets exist. Update the formula only when standalone CLI tarballs for that version exist.
+
+Tap audit can be noisy from unrelated formulae; keep evidence specific to the app cask.
+
+## Closeout
+
+1. Create/push tag and GitHub release through the release script.
+2. Verify appcast points to the new GitHub release asset with signature and length.
+3. Update/push the Homebrew cask if the app zip changed.
+4. Bump the app repo to next patch `Unreleased`:
+   - `version.env`: next `MARKETING_VERSION`, next `BUILD_NUMBER`
+   - `CHANGELOG.md`: top `## <next> — Unreleased`
+5. Commit, push, then pull `--ff-only`.
+6. Restart the local app from the packaged bundle and verify the running bundle version.
+7. Check no release/notary/op temp sessions or temp env files remain.
+
+CodexBar restart:
+
+```bash
+pkill -x CodexBar || pkill -f CodexBar.app || true
+cd "$(git rev-parse --show-toplevel)"
+open -n CodexBar.app
+/usr/libexec/PlistBuddy -c 'Print :CFBundleShortVersionString' CodexBar.app/Contents/Info.plist
+/usr/libexec/PlistBuddy -c 'Print :CFBundleVersion' CodexBar.app/Contents/Info.plist
+```
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index de2359aca7..d5b485915c 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -2,12 +2,75 @@ name: CI
 
 on:
   push:
-    branches: ["*"]
+    branches: [main]
   pull_request:
 
+concurrency:
+  group: ci-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  SWIFT_VERSION: 6.2.1
+
 jobs:
-  lint-build-test:
-    runs-on: macos-latest
+  changes:
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    outputs:
+      macos-tests: ${{ steps.macos-tests.outputs.macos-tests }}
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
+      - name: Detect macOS test impact
+        id: macos-tests
+        shell: bash
+        run: |
+          set -euo pipefail
+
+          if [[ "${{ github.event_name }}" == "pull_request" ]]; then
+            base_sha="${{ github.event.pull_request.base.sha }}"
+          else
+            base_sha="${{ github.event.before }}"
+          fi
+
+          changed_paths="${RUNNER_TEMP}/changed-paths.txt"
+          if [[ -z "$base_sha" || "$base_sha" =~ ^0+$ ]]; then
+            git ls-files | awk '{ print "A\t" $0 }' > "$changed_paths"
+          elif ! git cat-file -e "${base_sha}^{commit}" 2>/dev/null; then
+            echo "Base commit ${base_sha} is unavailable; running macOS tests conservatively."
+            git ls-files | awk '{ print "A\t" $0 }' > "$changed_paths"
+          else
+            git diff --name-status "$base_sha" "$GITHUB_SHA" > "$changed_paths"
+          fi
+
+          printf 'Changed paths:\n'
+          sed 's/^/- /' "$changed_paths"
+          ./Scripts/ci_macos_test_gate.sh "$changed_paths"
+
+  lint:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Install lint tools
+        run: ./Scripts/install_lint_tools.sh swiftlint
+
+      - name: Lint
+        run: ./Scripts/lint.sh lint-linux
+
+  swift-test-macos:
+    needs: changes
+    if: ${{ needs.changes.outputs.macos-tests == 'true' }}
+    runs-on: macos-15-intel
+    timeout-minutes: 40
+    strategy:
+      fail-fast: false
+      matrix:
+        shard-index: [0, 1, 2, 3]
+        shard-count: [4]
     steps:
       - uses: actions/checkout@v6
 
@@ -29,16 +92,40 @@ jobs:
           swift --version
           swift package --version
 
-      - name: Install lint tools
-        run: ./Scripts/install_lint_tools.sh
-
-      - name: Lint
-        run: ./Scripts/lint.sh lint
+      - name: Check app locales and Swift formatting
+        if: ${{ matrix.shard-index == 0 }}
+        run: ./Scripts/lint.sh lint-macos
 
       - name: Swift Test
-        run: swift test --no-parallel
+        timeout-minutes: 35
+        run: |
+          CODEXBAR_TEST_GROUP_SIZE=1 \
+            CODEXBAR_TEST_SUITE_TIMEOUT=120 \
+            CODEXBAR_TEST_SHARD_INDEX=${{ matrix.shard-index }} \
+            CODEXBAR_TEST_SHARD_COUNT=${{ matrix.shard-count }} \
+            ./Scripts/test.sh
+
+  lint-build-test:
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    needs:
+      - changes
+      - lint
+      - swift-test-macos
+    if: ${{ always() && !cancelled() }}
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Verify lint and macOS test jobs
+        run: |
+          ./Scripts/ci_verify_test_jobs.sh \
+            "${{ needs.lint.result }}" \
+            "${{ needs.changes.result }}" \
+            "${{ needs.changes.outputs.macos-tests }}" \
+            "${{ needs.swift-test-macos.result }}"
 
   build-linux-cli:
+    timeout-minutes: 20
     strategy:
       fail-fast: false
       matrix:
@@ -57,11 +144,53 @@ jobs:
           uname -a
           uname -m
 
-      - name: Setup Swift 6.2.1
-        uses: swift-actions/setup-swift@v3
+      - name: Restore Swift toolchain cache
+        id: swift-toolchain-cache
+        uses: actions/cache@v4
         with:
-          swift-version: "6.2.1"
-          skip-verify-signature: true
+          path: ~/.local/share/swiftly
+          key: swift-${{ runner.os }}-${{ runner.arch }}-${{ env.SWIFT_VERSION }}-v2
+
+      - name: Install Swift ${{ env.SWIFT_VERSION }} via swiftly
+        shell: bash
+        run: |
+          set -euo pipefail
+
+          missing_packages=()
+          for package in ca-certificates gpg libcurl4-openssl-dev; do
+            if ! dpkg-query -W -f='${Status}' "$package" 2>/dev/null | grep -q "install ok installed"; then
+              missing_packages+=("$package")
+            fi
+          done
+          if [[ "${#missing_packages[@]}" -gt 0 ]]; then
+            sudo apt-get update
+            sudo apt-get install -y "${missing_packages[@]}"
+          fi
+
+          SWIFTLY_ARCH="$(uname -m)"
+          SWIFTLY_HOME_DIR="$HOME/.local/share/swiftly"
+          SWIFTLY_BIN_DIR="$HOME/.local/bin"
+          POST_INSTALL_SCRIPT="$(mktemp)"
+
+          mkdir -p "$SWIFTLY_BIN_DIR"
+          echo "Swift toolchain cache hit: ${{ steps.swift-toolchain-cache.outputs.cache-hit }}"
+          curl -fsSL "https://download.swift.org/swiftly/linux/swiftly-${SWIFTLY_ARCH}.tar.gz" -o /tmp/swiftly.tar.gz
+          tar -xzf /tmp/swiftly.tar.gz -C /tmp
+          /tmp/swiftly init --assume-yes --skip-install
+
+          . "$SWIFTLY_HOME_DIR/env.sh"
+          echo "$SWIFTLY_BIN_DIR" >> "$GITHUB_PATH"
+          echo "SWIFTLY_HOME_DIR=$SWIFTLY_HOME_DIR" >> "$GITHUB_ENV"
+          echo "SWIFTLY_BIN_DIR=$SWIFTLY_BIN_DIR" >> "$GITHUB_ENV"
+
+          swiftly install "$SWIFT_VERSION" --use --assume-yes --post-install-file "$POST_INSTALL_SCRIPT"
+          if [[ -s "$POST_INSTALL_SCRIPT" ]]; then
+            sudo apt-get update
+            sudo bash "$POST_INSTALL_SCRIPT"
+          fi
+
+          hash -r
+          swift --version
 
       - name: Build CodexBarCLI (release, static Swift stdlib)
         run: swift build -c release --product CodexBarCLI --static-swift-stdlib
diff --git a/.github/workflows/release-cli.yml b/.github/workflows/release-cli.yml
index 4546fa83ff..4438306ea1 100644
--- a/.github/workflows/release-cli.yml
+++ b/.github/workflows/release-cli.yml
@@ -1,41 +1,353 @@
-name: Release Linux CLI
+name: Release CLI
 
 on:
   release:
     types: [published]
   workflow_dispatch:
+    inputs:
+      tag:
+        description: "Release tag/version to package for manual artifact builds; manual runs do not publish."
+        required: false
+        type: string
 
 permissions:
   contents: write
 
 jobs:
-  build-linux-cli:
+  build-cli:
     strategy:
       fail-fast: false
       matrix:
         include:
           - name: linux-x64
             runs-on: ubuntu-24.04
+            platform: linux
+            asset-platform: linux
+            asset-arch: x86_64
+            build-arch: ""
+            static-swift-stdlib: true
+            swift-sdk: ""
+            swift-sdk-triple: ""
+            swift-sdk-arch: ""
+            file-arch-pattern: x86-64
           - name: linux-arm64
             runs-on: ubuntu-24.04-arm
+            platform: linux
+            asset-platform: linux
+            asset-arch: aarch64
+            build-arch: ""
+            static-swift-stdlib: true
+            swift-sdk: ""
+            swift-sdk-triple: ""
+            swift-sdk-arch: ""
+            file-arch-pattern: aarch64
+          - name: linux-musl-x64
+            runs-on: ubuntu-24.04
+            platform: linux
+            asset-platform: linux-musl
+            asset-arch: x86_64
+            build-arch: ""
+            static-swift-stdlib: false
+            swift-sdk: swift-6.2.1-RELEASE_static-linux-0.0.1
+            swift-sdk-triple: x86_64-swift-linux-musl
+            swift-sdk-arch: x86_64
+            file-arch-pattern: x86-64
+          - name: linux-musl-arm64
+            runs-on: ubuntu-24.04-arm
+            platform: linux
+            asset-platform: linux-musl
+            asset-arch: aarch64
+            build-arch: ""
+            static-swift-stdlib: false
+            swift-sdk: swift-6.2.1-RELEASE_static-linux-0.0.1
+            swift-sdk-triple: aarch64-swift-linux-musl
+            swift-sdk-arch: aarch64
+            file-arch-pattern: aarch64
+          - name: macos-arm64
+            runs-on: macos-15
+            platform: macos
+            asset-platform: macos
+            asset-arch: arm64
+            build-arch: arm64
+            static-swift-stdlib: false
+            swift-sdk: ""
+            swift-sdk-triple: ""
+            swift-sdk-arch: ""
+            file-arch-pattern: ""
+          - name: macos-x86_64
+            runs-on: macos-15-intel
+            platform: macos
+            asset-platform: macos
+            asset-arch: x86_64
+            build-arch: x86_64
+            static-swift-stdlib: false
+            swift-sdk: ""
+            swift-sdk-triple: ""
+            swift-sdk-arch: ""
+            file-arch-pattern: ""
     runs-on: ${{ matrix.runs-on }}
+    env:
+      RELEASE_TAG: ${{ inputs.tag || github.ref_name }}
+      SWIFT_STATIC_LINUX_SDK_URL: https://download.swift.org/swift-6.2.1-release/static-sdk/swift-6.2.1-RELEASE/swift-6.2.1-RELEASE_static-linux-0.0.1.artifactbundle.tar.gz
+      SWIFT_STATIC_LINUX_SDK_CHECKSUM: 08e1939a504e499ec871b36826569173103e4562769e12b9b8c2a50f098374ad
+      SQLITE_AMALGAMATION_VERSION: "3530200"
+      SQLITE_AMALGAMATION_SHA3_256: 81142986038e18f96c4a54e1a72562ae17e502a916f2a7701eff43388cbf1a40
     steps:
       - uses: actions/checkout@v6
 
+      - name: Select Xcode 26.1.1 (if present) or fallback to default
+        if: matrix.platform == 'macos'
+        run: |
+          set -euo pipefail
+          for candidate in /Applications/Xcode_26.1.1.app /Applications/Xcode_26.1.app /Applications/Xcode.app; do
+            if [[ -d "$candidate" ]]; then
+              sudo xcode-select -s "${candidate}/Contents/Developer"
+              echo "DEVELOPER_DIR=${candidate}/Contents/Developer" >> "$GITHUB_ENV"
+              break
+            fi
+          done
+          /usr/bin/xcodebuild -version
+
       - name: Runner info
         run: |
           set -euo pipefail
           uname -a
           uname -m
+          swift --version
 
-      - name: Setup Swift 6.2.1
-        uses: swift-actions/setup-swift@v3
-        with:
-          swift-version: "6.2.1"
-          skip-verify-signature: true
+      - name: Validate release tag
+        if: github.event_name == 'release' || inputs.tag != ''
+        shell: bash
+        run: |
+          set -euo pipefail
+          if [[ -z "$RELEASE_TAG" ]]; then
+            echo "Missing release tag." >&2
+            exit 1
+          fi
+          if [[ ! "$RELEASE_TAG" =~ ^v[0-9A-Za-z._-]+$ ]]; then
+            echo "Invalid release tag: $RELEASE_TAG" >&2
+            exit 1
+          fi
+
+      - name: Install Swift 6.2.1 via swiftly
+        if: matrix.platform == 'linux'
+        shell: bash
+        run: |
+          set -euo pipefail
+
+          if ! command -v gpg >/dev/null 2>&1; then
+            sudo apt-get update
+            sudo apt-get install -y ca-certificates gpg
+          fi
+
+          SWIFTLY_ARCH="$(uname -m)"
+          SWIFTLY_HOME_DIR="$HOME/.local/share/swiftly"
+          SWIFTLY_BIN_DIR="$HOME/.local/bin"
+          POST_INSTALL_SCRIPT="$(mktemp)"
+
+          mkdir -p "$SWIFTLY_BIN_DIR"
+          curl -fsSL "https://download.swift.org/swiftly/linux/swiftly-${SWIFTLY_ARCH}.tar.gz" -o /tmp/swiftly.tar.gz
+          tar -xzf /tmp/swiftly.tar.gz -C /tmp
+          /tmp/swiftly init --assume-yes --skip-install
+
+          . "$SWIFTLY_HOME_DIR/env.sh"
+          echo "$SWIFTLY_BIN_DIR" >> "$GITHUB_PATH"
+          echo "SWIFTLY_HOME_DIR=$SWIFTLY_HOME_DIR" >> "$GITHUB_ENV"
+          echo "SWIFTLY_BIN_DIR=$SWIFTLY_BIN_DIR" >> "$GITHUB_ENV"
+
+          swiftly install 6.2.1 --use --assume-yes --post-install-file "$POST_INSTALL_SCRIPT"
+          if [[ -s "$POST_INSTALL_SCRIPT" ]]; then
+            sudo apt-get update
+            sudo bash "$POST_INSTALL_SCRIPT"
+          fi
+
+          hash -r
+          swift --version
+
+      - name: Install Swift Static Linux SDK
+        if: matrix.swift-sdk != ''
+        shell: bash
+        run: |
+          set -euo pipefail
+          swift sdk install "$SWIFT_STATIC_LINUX_SDK_URL" --checksum "$SWIFT_STATIC_LINUX_SDK_CHECKSUM"
+          swift sdk list | grep -Fx "${{ matrix.swift-sdk }}"
+
+          sdk_root="$(
+            find "$HOME" -type d -path "*/${{ matrix.swift-sdk }}.artifactbundle/${{ matrix.swift-sdk }}/swift-linux-musl" | head -n1
+          )"
+          if [[ -z "$sdk_root" ]]; then
+            echo "Swift SDK root not found." >&2
+            exit 1
+          fi
+
+          python3 - "$sdk_root/swift-sdk.json" "${{ matrix.swift-sdk-triple }}" <<'PY'
+          import json
+          import sys
+
+          sdk_json_path, target_triple = sys.argv[1], sys.argv[2]
+          with open(sdk_json_path, encoding="utf-8") as handle:
+              sdk_json = json.load(handle)
+
+          target_triples = sdk_json.get("targetTriples", {})
+          if target_triple not in target_triples:
+              raise SystemExit(f"Swift SDK target triple not found: {target_triple}")
+
+          sdk_json["targetTriples"] = {target_triple: target_triples[target_triple]}
+          with open(sdk_json_path, "w", encoding="utf-8") as handle:
+              json.dump(sdk_json, handle, indent=2)
+              handle.write("\n")
+          PY
+
+          for sdk_arch in "$sdk_root"/musl-1.2.5.sdk/*; do
+            if [[ "$(basename "$sdk_arch")" != "${{ matrix.swift-sdk-arch }}" ]]; then
+              rm -rf "$sdk_arch"
+            fi
+          done
+
+      - name: Build static SQLite for musl SDK
+        if: matrix.swift-sdk != ''
+        shell: bash
+        run: |
+          set -euo pipefail
+
+          missing_packages=()
+          for tool in clang openssl unzip; do
+            if ! command -v "$tool" >/dev/null 2>&1; then
+              missing_packages+=("$tool")
+            fi
+          done
+          if [[ "${#missing_packages[@]}" -gt 0 ]]; then
+            sudo apt-get update
+            sudo apt-get install -y "${missing_packages[@]}"
+          fi
+
+          sqlite_zip="$RUNNER_TEMP/sqlite-amalgamation-${SQLITE_AMALGAMATION_VERSION}.zip"
+          sqlite_src="$RUNNER_TEMP/sqlite-src"
+          sqlite_out="$RUNNER_TEMP/sqlite-${{ matrix.swift-sdk-triple }}"
+
+          curl -fsSL "https://www.sqlite.org/2026/sqlite-amalgamation-${SQLITE_AMALGAMATION_VERSION}.zip" -o "$sqlite_zip"
+          actual_sha3="$(openssl dgst -sha3-256 "$sqlite_zip" | awk '{print $NF}')"
+          if [[ "$actual_sha3" != "$SQLITE_AMALGAMATION_SHA3_256" ]]; then
+            echo "SQLite amalgamation checksum mismatch: $actual_sha3" >&2
+            exit 1
+          fi
+
+          rm -rf "$sqlite_src" "$sqlite_out"
+          mkdir -p "$sqlite_src" "$sqlite_out/build" "$sqlite_out/lib"
+          unzip -q "$sqlite_zip" -d "$sqlite_src"
+
+          sdk_bundle="$(
+            find "$HOME" -type d -name "${{ matrix.swift-sdk }}.artifactbundle" | head -n1
+          )"
+          if [[ -z "$sdk_bundle" ]]; then
+            echo "Swift SDK artifact bundle not found." >&2
+            exit 1
+          fi
+          sysroot="$sdk_bundle/${{ matrix.swift-sdk }}/swift-linux-musl/musl-1.2.5.sdk/${{ matrix.swift-sdk-arch }}"
+          if [[ ! -d "$sysroot" ]]; then
+            echo "Swift SDK sysroot not found: $sysroot" >&2
+            exit 1
+          fi
+
+          sqlite_amalgamation="$sqlite_src/sqlite-amalgamation-${SQLITE_AMALGAMATION_VERSION}"
+          mkdir -p "$sysroot/usr/include"
+          install -m 0644 "$sqlite_amalgamation/sqlite3.h" "$sysroot/usr/include/sqlite3.h"
+
+          clang \
+            -target "${{ matrix.swift-sdk-triple }}" \
+            --sysroot="$sysroot" \
+            -O2 \
+            -DSQLITE_OMIT_LOAD_EXTENSION=1 \
+            -c "$sqlite_amalgamation/sqlite3.c" \
+            -o "$sqlite_out/build/sqlite3.o"
+          llvm-ar crs "$sqlite_out/lib/libsqlite3.a" "$sqlite_out/build/sqlite3.o"
+
+          echo "CODEXBAR_SQLITE3_LIB_DIR=$sqlite_out/lib" >> "$GITHUB_ENV"
 
       - name: Build CodexBarCLI (release)
-        run: swift build -c release --product CodexBarCLI --static-swift-stdlib
+        id: build
+        shell: bash
+        run: |
+          set -euo pipefail
+
+          BUILD_ARGS=(swift build -c release --product CodexBarCLI)
+          if [[ -n "${{ matrix.swift-sdk }}" ]]; then
+            BUILD_ARGS+=(--swift-sdk "${{ matrix.swift-sdk }}" --triple "${{ matrix.swift-sdk-triple }}")
+          elif [[ -n "${{ matrix.build-arch }}" ]]; then
+            BUILD_ARGS+=(--arch "${{ matrix.build-arch }}")
+          fi
+          if [[ "${{ matrix.static-swift-stdlib }}" == "true" ]]; then
+            BUILD_ARGS+=(--static-swift-stdlib)
+          fi
+          "${BUILD_ARGS[@]}"
+
+          SHOW_BIN_ARGS=(swift build -c release --product CodexBarCLI --show-bin-path)
+          if [[ -n "${{ matrix.swift-sdk }}" ]]; then
+            SHOW_BIN_ARGS+=(--swift-sdk "${{ matrix.swift-sdk }}" --triple "${{ matrix.swift-sdk-triple }}")
+          elif [[ -n "${{ matrix.build-arch }}" ]]; then
+            SHOW_BIN_ARGS+=(--arch "${{ matrix.build-arch }}")
+          fi
+          if [[ "${{ matrix.static-swift-stdlib }}" == "true" ]]; then
+            SHOW_BIN_ARGS+=(--static-swift-stdlib)
+          fi
+
+          echo "bin_dir=$("${SHOW_BIN_ARGS[@]}")" >> "$GITHUB_OUTPUT"
+
+      - name: Smoke test CodexBarCLI
+        timeout-minutes: 5
+        shell: bash
+        run: |
+          set -euo pipefail
+
+          BIN_DIR="${{ steps.build.outputs.bin_dir }}"
+          BIN="$BIN_DIR/CodexBarCLI"
+          run_with_timeout() {
+            local output="$1"
+            shift
+            "$@" > "$output" &
+            local pid=$!
+            local run_status=
+            for _ in {1..20}; do
+              if ! kill -0 "$pid" 2>/dev/null; then
+                set +e
+                wait "$pid"
+                run_status=$?
+                set -e
+                break
+              fi
+              sleep 1
+            done
+            if [[ -z "$run_status" ]]; then
+              kill "$pid" 2>/dev/null || true
+              wait "$pid" 2>/dev/null || true
+              echo "$* timed out." >&2
+              exit 124
+            fi
+            if [[ "$run_status" -ne 0 ]]; then
+              cat "$output" >&2 || true
+              exit "$run_status"
+            fi
+          }
+
+          echo "BIN=$BIN"
+          file "$BIN"
+          if [[ "${{ matrix.platform }}" == "macos" ]]; then
+            lipo -archs "$BIN" | tr ' ' '\n' | grep -Fx "${{ matrix.asset-arch }}"
+            run_with_timeout "$RUNNER_TEMP/codexbar-cli-smoke-${{ matrix.name }}.txt" "$BIN" config validate --format json
+          elif [[ -n "${{ matrix.swift-sdk }}" ]]; then
+            run_with_timeout "$RUNNER_TEMP/codexbar-cli-help-${{ matrix.name }}.txt" "$BIN" --help
+            run_with_timeout "$RUNNER_TEMP/codexbar-cli-config-${{ matrix.name }}.json" "$BIN" config validate --format json
+            file "$BIN" | grep -q "${{ matrix.file-arch-pattern }}"
+            file "$BIN" | grep -q "statically linked"
+          else
+            run_with_timeout "$RUNNER_TEMP/codexbar-cli-help-${{ matrix.name }}.txt" "$BIN" --help
+            file "$BIN" | grep -q "${{ matrix.file-arch-pattern }}"
+          fi
+          printf '%s\n' "${RELEASE_TAG#v}" > "$BIN_DIR/VERSION"
+          VERSION_OUTPUT="$RUNNER_TEMP/codexbar-cli-version-${{ matrix.name }}.txt"
+          run_with_timeout "$VERSION_OUTPUT" "$BIN" --version
+          grep -Fx "CodexBar ${RELEASE_TAG#v}" "$VERSION_OUTPUT"
+          rm "$BIN_DIR/VERSION"
 
       - name: Package
         id: pkg
@@ -43,26 +355,26 @@ jobs:
         run: |
           set -euo pipefail
 
-          TAG="${GITHUB_REF_NAME}"
-          if [[ -z "$TAG" ]]; then
-            echo "Missing tag (GITHUB_REF_NAME)." >&2
+          REF_NAME="${RELEASE_TAG}"
+          if [[ -z "$REF_NAME" ]]; then
+            echo "Missing release tag." >&2
             exit 1
           fi
+          SAFE_REF_NAME="${REF_NAME//\//-}"
 
-          ARCH="$(uname -m)"
-          case "$ARCH" in
-            x86_64) ARCH="x86_64" ;;
-            aarch64|arm64) ARCH="aarch64" ;;
-          esac
-
-          BIN_DIR="$(swift build -c release --product CodexBarCLI --static-swift-stdlib --show-bin-path)"
+          BIN_DIR="${{ steps.build.outputs.bin_dir }}"
           OUT_DIR="$(mktemp -d)"
           install -m 0755 "$BIN_DIR/CodexBarCLI" "$OUT_DIR/CodexBarCLI"
           ln -s "CodexBarCLI" "$OUT_DIR/codexbar"
+          printf '%s\n' "${SAFE_REF_NAME#v}" > "$OUT_DIR/VERSION"
 
-          ASSET="CodexBarCLI-${TAG}-linux-${ARCH}.tar.gz"
-          (cd "$OUT_DIR" && tar czf "$ASSET" CodexBarCLI codexbar)
-          sha256sum "$OUT_DIR/$ASSET" > "$OUT_DIR/$ASSET.sha256"
+          ASSET="CodexBarCLI-${SAFE_REF_NAME}-${{ matrix.asset-platform }}-${{ matrix.asset-arch }}.tar.gz"
+          (cd "$OUT_DIR" && tar czf "$ASSET" CodexBarCLI codexbar VERSION)
+          if command -v sha256sum >/dev/null 2>&1; then
+            sha256sum "$OUT_DIR/$ASSET" > "$OUT_DIR/$ASSET.sha256"
+          else
+            shasum -a 256 "$OUT_DIR/$ASSET" > "$OUT_DIR/$ASSET.sha256"
+          fi
 
           echo "out_dir=$OUT_DIR" >> "$GITHUB_OUTPUT"
           echo "asset=$ASSET" >> "$GITHUB_OUTPUT"
@@ -74,16 +386,95 @@ jobs:
         shell: bash
         run: |
           set -euo pipefail
-          TAG="${GITHUB_REF_NAME}"
+          TAG="${RELEASE_TAG}"
           OUT_DIR="${{ steps.pkg.outputs.out_dir }}"
           ASSET="${{ steps.pkg.outputs.asset }}"
           gh release upload "$TAG" "$OUT_DIR/$ASSET" "$OUT_DIR/$ASSET.sha256" --clobber
 
       - name: Upload workflow artifact (manual runs)
-        if: github.event_name != 'release'
+        if: github.event_name == 'workflow_dispatch'
         uses: actions/upload-artifact@v6
         with:
-          name: codexbar-linux-cli-${{ matrix.name }}
+          name: codexbar-cli-${{ matrix.name }}
           path: |
             ${{ steps.pkg.outputs.out_dir }}/${{ steps.pkg.outputs.asset }}
             ${{ steps.pkg.outputs.out_dir }}/${{ steps.pkg.outputs.asset }}.sha256
+
+  update-homebrew-tap:
+    runs-on: ubuntu-latest
+    needs: build-cli
+    if: github.event_name == 'release'
+    steps:
+      - name: Resolve release tag
+        id: release
+        env:
+          RELEASE_TAG: ${{ github.ref_name }}
+        shell: bash
+        run: |
+          set -euo pipefail
+          tag="${RELEASE_TAG}"
+          if [[ -z "$tag" ]]; then
+            echo "Missing release tag." >&2
+            exit 1
+          fi
+          if [[ ! "$tag" =~ ^v[0-9A-Za-z._-]+$ ]]; then
+            echo "Invalid release tag: $tag" >&2
+            exit 1
+          fi
+          echo "tag=$tag" >> "$GITHUB_OUTPUT"
+          echo "request_id=codexbar-${tag}-${GITHUB_RUN_ID}" >> "$GITHUB_OUTPUT"
+
+      - name: Dispatch tap update
+        env:
+          GH_TOKEN: ${{ secrets.HOMEBREW_TAP_TOKEN }}
+          RELEASE_TAG: ${{ steps.release.outputs.tag }}
+          REQUEST_ID: ${{ steps.release.outputs.request_id }}
+        shell: bash
+        run: |
+          set -euo pipefail
+          test -n "$GH_TOKEN"
+          for attempt in {1..6}; do
+            if gh workflow run update-formula.yml \
+              --repo steipete/homebrew-tap \
+              -f formula=codexbar \
+              -f tag="$RELEASE_TAG" \
+              -f repository=steipete/CodexBar \
+              -f artifact_template='CodexBarCLI-{tag}-{target}.tar.gz' \
+              -f target_aliases='darwin_arm64=macos-arm64,darwin_amd64=macos-x86_64,linux_arm64=linux-aarch64,linux_amd64=linux-x86_64' \
+              -f cask=codexbar \
+              -f cask_artifact='CodexBar-macos-universal-{version}.zip' \
+              -f request_id="$REQUEST_ID"; then
+              exit 0
+            fi
+            if [[ "$attempt" -eq 6 ]]; then
+              echo "Failed to dispatch tap update after ${attempt} attempts." >&2
+              exit 1
+            fi
+            sleep $((attempt * 30))
+          done
+
+      - name: Wait for tap update
+        env:
+          GH_TOKEN: ${{ secrets.HOMEBREW_TAP_TOKEN }}
+          REQUEST_ID: ${{ steps.release.outputs.request_id }}
+        shell: bash
+        run: |
+          set -euo pipefail
+          for _ in {1..20}; do
+            run_id="$(
+              gh run list \
+                --repo steipete/homebrew-tap \
+                --workflow update-formula.yml \
+                --json databaseId,displayTitle \
+                --jq '.[] | select(.displayTitle | contains(env.REQUEST_ID)) | .databaseId' 2>/tmp/codexbar-tap-run-list.err \
+                | head -n1 || true
+            )"
+            if [[ -n "$run_id" ]]; then
+              gh run watch "$run_id" --repo steipete/homebrew-tap --exit-status
+              exit 0
+            fi
+            cat /tmp/codexbar-tap-run-list.err >&2 || true
+            sleep 5
+          done
+          echo "Timed out waiting for tap workflow to appear." >&2
+          exit 1
diff --git a/.github/workflows/upstream-monitor.yml b/.github/workflows/upstream-monitor.yml
index 04140e8d69..3deb7b70d7 100644
--- a/.github/workflows/upstream-monitor.yml
+++ b/.github/workflows/upstream-monitor.yml
@@ -44,21 +44,49 @@ jobs:
       - name: Check for new commits
         id: check
         run: |
+          remote_default_branch() {
+            local remote="$1"
+            local branch=""
+            branch=$(git symbolic-ref -q --short "refs/remotes/${remote}/HEAD" 2>/dev/null | sed "s#^${remote}/##" || true)
+            if [ -z "$branch" ]; then
+              branch=$(git remote show "$remote" 2>/dev/null | awk '/HEAD branch/ {print $NF; exit}' || true)
+            fi
+            if [ -n "$branch" ] && git rev-parse --verify -q "${remote}/${branch}" >/dev/null; then
+              echo "$branch"
+              return 0
+            fi
+            for candidate in main master; do
+              if git rev-parse --verify -q "${remote}/${candidate}" >/dev/null; then
+                echo "$candidate"
+                return 0
+              fi
+            done
+            echo "Could not resolve default branch for ${remote}" >&2
+            exit 1
+          }
+
+          UPSTREAM_BRANCH=$(remote_default_branch upstream)
+          QUOTIO_BRANCH=$(remote_default_branch quotio)
+          UPSTREAM_REF="upstream/${UPSTREAM_BRANCH}"
+          QUOTIO_REF="quotio/${QUOTIO_BRANCH}"
+          echo "upstream_ref=$UPSTREAM_REF" >> $GITHUB_OUTPUT
+          echo "quotio_ref=$QUOTIO_REF" >> $GITHUB_OUTPUT
+
           # Count new commits in upstream
-          UPSTREAM_NEW=$(git log --oneline main..upstream/main --no-merges 2>/dev/null | wc -l | tr -d ' ')
+          UPSTREAM_NEW=$(git log --oneline "main..${UPSTREAM_REF}" --no-merges 2>/dev/null | wc -l | tr -d ' ')
           echo "upstream_commits=$UPSTREAM_NEW" >> $GITHUB_OUTPUT
           
           # Count new commits in quotio (last 7 days)
-          QUOTIO_NEW=$(git log --oneline --all --remotes=quotio/main --since="7 days ago" 2>/dev/null | wc -l | tr -d ' ')
+          QUOTIO_NEW=$(git log --oneline "$QUOTIO_REF" --since="7 days ago" 2>/dev/null | wc -l | tr -d ' ')
           echo "quotio_commits=$QUOTIO_NEW" >> $GITHUB_OUTPUT
           
           # Get commit summaries
           echo "upstream_summary<<EOF" >> $GITHUB_OUTPUT
-          git log --oneline main..upstream/main --no-merges 2>/dev/null | head -10 >> $GITHUB_OUTPUT || echo "No commits" >> $GITHUB_OUTPUT
+          git log --oneline "main..${UPSTREAM_REF}" --no-merges 2>/dev/null | head -10 >> $GITHUB_OUTPUT || echo "No commits" >> $GITHUB_OUTPUT
           echo "EOF" >> $GITHUB_OUTPUT
           
           echo "quotio_summary<<EOF" >> $GITHUB_OUTPUT
-          git log --oneline --remotes=quotio/main --since="7 days ago" 2>/dev/null | head -10 >> $GITHUB_OUTPUT || echo "No commits" >> $GITHUB_OUTPUT
+          git log --oneline "$QUOTIO_REF" --since="7 days ago" 2>/dev/null | head -10 >> $GITHUB_OUTPUT || echo "No commits" >> $GITHUB_OUTPUT
           echo "EOF" >> $GITHUB_OUTPUT
       
       - name: Create or update issue
@@ -68,6 +96,10 @@ jobs:
           script: |
             const upstreamCommits = '${{ steps.check.outputs.upstream_commits }}';
             const quotioCommits = '${{ steps.check.outputs.quotio_commits }}';
+            const upstreamRef = '${{ steps.check.outputs.upstream_ref }}';
+            const quotioRef = '${{ steps.check.outputs.quotio_ref }}';
+            const upstreamBranch = upstreamRef.replace('upstream/', '');
+            const quotioBranch = quotioRef.replace('quotio/', '');
             const upstreamSummary = `${{ steps.check.outputs.upstream_summary }}`;
             const quotioSummary = `${{ steps.check.outputs.quotio_summary }}`;
             
@@ -75,6 +107,7 @@ jobs:
             
             **steipete/CodexBar:** ${upstreamCommits} new commits
             **quotio:** ${quotioCommits} new commits (last 7 days)
+            **Source refs:** ${upstreamRef}, ${quotioRef}
             
             ### steipete/CodexBar Recent Commits
             \`\`\`
@@ -100,13 +133,13 @@ jobs:
             
             **View detailed diffs:**
             \`\`\`bash
-            git diff main..upstream/main
-            git log -p quotio/main --since='7 days ago'
+            git diff main..${upstreamRef}
+            git log -p ${quotioRef} --since='7 days ago'
             \`\`\`
             
             ### 🔗 Links
-            - [steipete commits](https://github.com/steipete/CodexBar/compare/${context.sha}...steipete:CodexBar:main)
-            - [quotio commits](https://github.com/nguyenphutrong/quotio/commits/main)
+            - [steipete commits](https://github.com/steipete/CodexBar/compare/${context.sha}...steipete:CodexBar:${upstreamBranch})
+            - [quotio commits](https://github.com/nguyenphutrong/quotio/commits/${quotioBranch})
             
             ---
             *Auto-generated by upstream-monitor workflow*
@@ -153,4 +186,3 @@ jobs:
           echo "✅ No new upstream changes detected"
           echo "steipete/CodexBar: up to date"
           echo "quotio: no commits in last 7 days"
-
diff --git a/.gitignore b/.gitignore
index d44f986f63..f47250e1f2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -32,6 +32,8 @@ debug_*.swift
 .vscode/
 .codex/environments/
 .swiftpm-cache/
+.tmp-clang/
+__pycache__/
 
 # Debug/analysis docs
 docs/*-analysis.md
diff --git a/.mac-release.env b/.mac-release.env
new file mode 100644
index 0000000000..b0f5ec11ea
--- /dev/null
+++ b/.mac-release.env
@@ -0,0 +1,41 @@
+MAC_RELEASE_APP_NAME=CodexBar
+MAC_RELEASE_REPO=steipete/CodexBar
+MAC_RELEASE_BUNDLE_ID=com.steipete.codexbar
+MAC_RELEASE_VERSION_FILE=version.env
+MAC_RELEASE_APPCAST=appcast.xml
+MAC_RELEASE_SOURCE_FILES='Scripts/release_artifacts.sh'
+MAC_RELEASE_SUPUBLIC_ED_KEY=AGCY8w5vHirVfGGDGc8Szc5iuOqupZSh9pMj/Qs67XI=
+# Older shared AGCY Sparkle key fallback. SPARKLE_PRIVATE_KEY_FILE still wins;
+# Keychain is used when this local file is absent.
+MAC_RELEASE_SIGNING_KEY_FILE='$HOME/Library/CloudStorage/Dropbox/Backup/Sparkle/sparkle-private-key-OBSOLETE-not-for-BlackBar-publickey-AGCY8w5vHirVfGGDGc8Szc5iuOqupZSh9pMj_Qs67XI-2026-05-21.txt'
+
+MAC_RELEASE_APP_ZIP='$(codexbar_app_zip_name "$MARKETING_VERSION" "${ARCHES:-arm64 x86_64}")'
+MAC_RELEASE_DSYM_ZIP='$(codexbar_dsym_zip_name "$MARKETING_VERSION" "${ARCHES:-arm64 x86_64}")'
+MAC_RELEASE_ARTIFACT_PREFIX='CodexBar-macos-[A-Za-z0-9_+-]+-'
+MAC_RELEASE_FEED_URL='https://raw.githubusercontent.com/steipete/CodexBar/main/appcast.xml'
+MAC_RELEASE_DOWNLOAD_URL_PREFIX='https://github.com/steipete/CodexBar/releases/download/v${MARKETING_VERSION}/'
+
+MAC_RELEASE_PRECHECK='swiftformat Sources Tests >/dev/null && swiftlint --strict && swift test --enable-xctest --disable-swift-testing && swift test --enable-swift-testing --disable-xctest --no-parallel'
+MAC_RELEASE_PACKAGE_CMD='Scripts/sign-and-notarize.sh'
+MAC_RELEASE_CODESIGN_IDENTITY='Developer ID Application: Peter Steinberger (Y5PE65HELJ)'
+MAC_RELEASE_CODESIGN_OP_ITEM='Peekaboo Release Keychain'
+MAC_RELEASE_CODESIGN_OP_VAULT=Molty
+MAC_RELEASE_CODESIGN_OP_USE_SERVICE_ACCOUNT=1
+MAC_RELEASE_CODESIGN_KEYCHAIN_MANAGED=1
+MAC_RELEASE_TAG_SIGNED=1
+MAC_RELEASE_TAG_FORCE=1
+MAC_RELEASE_GENERATE_APPCAST_ARGS='--maximum-deltas 0'
+MAC_RELEASE_EXTRA_ASSET_WAIT_SECONDS=3600
+MAC_RELEASE_EXTRA_ASSET_WAIT_INTERVAL=30
+MAC_RELEASE_EXTRA_ASSET_PATTERNS='^CodexBarCLI-v${MARKETING_VERSION}-macos-arm64\.tar\.gz$
+^CodexBarCLI-v${MARKETING_VERSION}-macos-arm64\.tar\.gz\.sha256$
+^CodexBarCLI-v${MARKETING_VERSION}-macos-x86_64\.tar\.gz$
+^CodexBarCLI-v${MARKETING_VERSION}-macos-x86_64\.tar\.gz\.sha256$
+^CodexBarCLI-v${MARKETING_VERSION}-linux-aarch64\.tar\.gz$
+^CodexBarCLI-v${MARKETING_VERSION}-linux-aarch64\.tar\.gz\.sha256$
+^CodexBarCLI-v${MARKETING_VERSION}-linux-x86_64\.tar\.gz$
+^CodexBarCLI-v${MARKETING_VERSION}-linux-x86_64\.tar\.gz\.sha256$
+^CodexBarCLI-v${MARKETING_VERSION}-linux-musl-aarch64\.tar\.gz$
+^CodexBarCLI-v${MARKETING_VERSION}-linux-musl-aarch64\.tar\.gz\.sha256$
+^CodexBarCLI-v${MARKETING_VERSION}-linux-musl-x86_64\.tar\.gz$
+^CodexBarCLI-v${MARKETING_VERSION}-linux-musl-x86_64\.tar\.gz\.sha256$'
diff --git a/AGENTS.md b/AGENTS.md
index b55bb5e75b..fa85f21fe9 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -3,14 +3,14 @@
 ## Project Structure & Modules
 - `Sources/CodexBar`: Swift 6 menu bar app (usage/credits probes, icon renderer, settings). Keep changes small and reuse existing helpers.
 - `Tests/CodexBarTests`: XCTest coverage for usage parsing, status probes, icon patterns; mirror new logic with focused tests.
-- `Scripts`: build/package helpers (`package_app.sh`, `sign-and-notarize.sh`, `make_appcast.sh`, `build_icon.sh`, `compile_and_run.sh`).
+- `Scripts`: build/package helpers (`package_app.sh`, `sign-and-notarize.sh`, `make_appcast.sh`, `build_icon.sh`, `compile_and_run.sh`). Release wrappers call `Scripts/mac-release`, which resolves `MAC_RELEASE_TOOL` or the shared `agent-scripts` checkout.
 - `docs`: release notes and process (`docs/RELEASING.md`, screenshots). Root-level zips/appcast are generated artifacts—avoid editing except during releases.
 
 ## Build, Test, Run
-- Dev loop: `./Scripts/compile_and_run.sh` kills old instances, runs `swift build` + `swift test`, packages, relaunches `CodexBar.app`, and confirms it stays running.
-- Quick build/test: `swift build` (debug) or `swift build -c release`; `swift test` for the full XCTest suite.
+- Dev loop: `./Scripts/compile_and_run.sh` kills old instances, builds, packages, relaunches `CodexBar.app`, and confirms it stays running; add `--test` for the sharded full suite.
+- Quick build/test: `swift build` (debug) or `swift build -c release`; `make test` for the sharded full suite.
 - Package locally: `./Scripts/package_app.sh` to refresh `CodexBar.app`, then restart with `pkill -x CodexBar || pkill -f CodexBar.app || true; cd /Users/steipete/Projects/codexbar && open -n /Users/steipete/Projects/codexbar/CodexBar.app`.
-- Release flow: `./Scripts/sign-and-notarize.sh` (arm64 notarized zip) and `./Scripts/make_appcast.sh <zip> <feed-url>`; follow validation steps in `docs/RELEASING.md`.
+- Release flow: `./Scripts/release.sh`; app metadata lives in `.mac-release.env`, repo build/signing stays in `Scripts/sign-and-notarize.sh`, and validation steps live in `docs/RELEASING.md`.
 
 ## Coding Style & Naming
 - Enforce SwiftFormat/SwiftLint: run `swiftformat Sources Tests` and `swiftlint --strict`. 4-space indent, 120-char lines, explicit `self` is intentional—do not remove.
@@ -18,8 +18,12 @@
 
 ## Testing Guidelines
 - Add/extend XCTest cases under `Tests/CodexBarTests/*Tests.swift` (`FeatureNameTests` with `test_caseDescription` methods).
-- Always run `swift test` (or `./Scripts/compile_and_run.sh`) before handoff; add fixtures for new parsing/formatting scenarios.
-- After any code change, run `pnpm check` and fix all reported format/lint issues before handoff.
+- Model names in tests/code: released models or clearly fictitious names only; never expose unreleased names.
+- Always run `make test` before handoff; add focused `swift test --filter ...` runs for parser/provider fixes when possible.
+- After any code change, run `make check` and fix all reported format/lint issues before handoff.
+- Prefer CLI/focused tests over app-bundle live tests when behavior can be verified without relaunching CodexBar.
+- Never run tests/checks or ad-hoc validation that can display macOS Keychain prompts. Live provider probes, browser-cookie imports, `codexbar usage` against real accounts, and real SecItem reads must be explicitly requested; otherwise use parser tests, stubs, test stores, or `KeychainNoUIQuery`.
+- macOS CI is brittle around headless AppKit status/menu tests. Prefer covering menu behavior through stable state/model seams (`MenuDescriptor`, `ProvidersPane`, `CodexAccountsSectionState`, etc.) instead of constructing live `NSStatusBar`/`NSMenu` flows unless the AppKit wiring itself is the thing under test.
 
 ## Commit & PR Guidelines
 - Commit messages: short imperative clauses (e.g., “Improve usage probe”, “Fix icon dimming”); keep commits scoped.
@@ -27,13 +31,15 @@
 
 ## Agent Notes
 - Use the provided scripts and package manager (SwiftPM); avoid adding dependencies or tooling without confirmation.
-- Validate behavior against the freshly built bundle; restart via the pkill+open command above to avoid running stale binaries.
+- Menu bar automation: capture the target screen first and verify the CodexBar icon is visibly onscreen. Reject `click-extra` success when coordinates fall outside display bounds; hidden menu extras are not click proof.
+- Validate UI/runtime behavior against the freshly built bundle; restart via the pkill+open command above to avoid running stale binaries.
 - To guarantee the right bundle is running after a rebuild, use: `pkill -x CodexBar || pkill -f CodexBar.app || true; cd /Users/steipete/Projects/codexbar && open -n /Users/steipete/Projects/codexbar/CodexBar.app`.
-- After any code change that affects the app, always rebuild with `Scripts/package_app.sh` and restart the app using the command above before validating behavior.
-- If you edited code, run `scripts/compile_and_run.sh` before handoff; it kills old instances, builds, tests, packages, relaunches, and verifies the app stays running.
-- Per user request: after every edit (code or docs), rebuild and restart using `./Scripts/compile_and_run.sh` so the running app reflects the latest changes.
+- For CLI-testable provider/parser/settings behavior, use CLI/focused tests instead of `Scripts/package_app.sh` or `./Scripts/compile_and_run.sh`.
+- Run `./Scripts/compile_and_run.sh` only when UI/runtime behavior needs bundle-level validation; it builds, tests, packages, relaunches, and verifies the app stays running.
+- Widget/Tahoe UI issues: use Parallels macOS VM plus screenshots/clicks for autonomous verification.
 - Release script: keep it in the foreground; do not background it—wait until it finishes.
-- Release keys: find in `~/.profile` if missing (Sparkle + App Store Connect).
+- Sparkle release key: use `.mac-release.env` `MAC_RELEASE_SIGNING_KEY_FILE`, the legacy `AGCY8w5vHirVfGGDGc8Szc5iuOqupZSh9pMj/Qs67XI=` key. Do not use `sparkle-private-key-KEEP-SECURE.txt`; that is VibeTunnel's mismatched key.
+- Swift concurrency: treat sibling `async let` tasks as a review red flag when one child is required and another is optional/best-effort. Prefer sequential awaits or a drained `withThrowingTaskGroup` that surfaces required failures and explicitly contains optional failures; crash stacks mentioning `swift_task_dealloc` or `asyncLet_finish_after_task_completion` should trigger an audit of nearby `async let` usage.
 - Prefer modern SwiftUI/Observation macros: use `@Observable` models with `@State` ownership and `@Bindable` in views; avoid `ObservableObject`, `@ObservedObject`, and `@StateObject`.
 - Favor modern macOS 15+ APIs over legacy/deprecated counterparts when refactoring (Observation, new display link APIs, updated menu item styling, etc.).
 - Keep provider data siloed: when rendering usage or account info for a provider (Claude vs Codex), never display identity/plan fields sourced from a different provider.***
diff --git a/CHANGELOG.md b/CHANGELOG.md
index c5323656d4..33e76f7a93 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,57 +1,892 @@
 # Changelog
 
-## Unreleased
+## 0.37.3 — Unreleased
+
+## 0.37.2 — 2026-06-22
+
+### Added
+- Diagnostics: write redacted provider reports to a file with platform and app-version context. Thanks @Yuxin-Qiao!
+- CLI server: report the startup build version from `/health` so clients can detect stale helper processes after updates. Thanks @enieuwy!
+
+### Fixed
+- Claude: pause background CLI usage probes briefly after rate limiting while keeping manual refresh available. Thanks @kiranmagic7!
+- Codex OAuth: publish refreshed `auth.json` credentials with private file permissions already applied. Thanks @Hinotoi-agent!
+- Provider endpoints: reject unsafe Deepgram, z.ai, and Xiaomi MiMo overrides before attaching credentials. Thanks @Hinotoi-agent!
+- Azure OpenAI: reject unsafe endpoint overrides before attaching API keys while keeping invalid configurations visible with an actionable error. Thanks @Hinotoi-agent!
+
+## 0.37.1 — 2026-06-21
+
+### Fixed
+- MiniMax: recover detailed token-plan windows from the remains API when the coding-plan page only exposes coarse usage. Thanks @Yuxin-Qiao!
+- Cost history: remove the redundant tooltip from submenu-backed Cost rows. Thanks @Zihao-Qi!
+- Menu refresh: keep the menu open and show in-place progress when Refresh is clicked. Thanks @elijahfriedman!
+- Menu: align provider usage-card spacing with the Overview layout. Thanks @Zihao-Qi!
+- Memory pressure: avoid actor-isolation crashes when system callbacks arrive on a utility queue. Thanks @Zihao-Qi!
+- Menu: remove extra separators and spacing around Storage, Cost, and Subscription Utilization rows. Thanks @elijahfriedman!
+- Antigravity: show limits as unavailable when OAuth identifies the account but quota endpoints deny access. Thanks @Yuxin-Qiao!
+
+## 0.37.0 — 2026-06-19
+
+### Added
+- Widgets: add single-window and combined burn-down charts for Codex and Claude session/weekly limits. Thanks @jamesjlopez!
+- AWS Bedrock: show optional rolling 14-day Claude token and request totals from CloudWatch. Thanks @zyaiire!
+- Codex: optionally show both session-window and weekly percentages in the compact menu bar label. Thanks @thepraggyverse!
+- Cursor: show personal on-demand spend alongside the shared team pool. Thanks @yashiels!
+- Documentation: link the community KDE Plasma panel integration. Thanks @tylxr59!
+- Codex: expose explicitly configured profile homes as switchable accounts without copying their credentials. Thanks @kiranmagic7!
+- Codex: show available manual rate-limit reset credits and their next expiry for signed-in OAuth accounts. Thanks @rogdex24!
+- Mistral: add Vibe monthly-plan usage and menu bar metric selection. Thanks @lfmundim!
+- Storage: show a compact segmented provider breakdown with an expandable Other group. Thanks @elijahfriedman!
+- Settings: add an optional enabled-first alphabetical sort for the Providers sidebar without changing custom order. Thanks @elijahfriedman!
+- Linux CLI: publish static musl release tarballs for x86_64 and aarch64. Thanks @Yuxin-Qiao!
+- Documentation: add safe troubleshooting for browser Keychain prompts that persist after uninstall. Thanks @Yuxin-Qiao!
+- Diagnostics: report provider-neutral usage confidence and mark fully decoded Codex OAuth windows exact. Thanks @Yuxin-Qiao!
+- Codex agents: add a read-only `codexbar` skill for bounded, redacted provider usage JSON. Thanks @coygeek!
+- Display: add a Hide critters option for plain menu bar quota capsules. Thanks @elijahfriedman!
+
+### Changed
+- Packaging: strip local symbols from release executables to reduce the installed app and download size. Thanks @jieshu666!
+- Logging: skip message, metadata, and redaction work for filtered or disabled log destinations. Thanks @ProspectOre!
+- Cost history: cache date parsers per thread to reduce repeated report-decoding overhead. Thanks @ProspectOre!
+- Linux CLI: accept an opt-in static SQLite library directory for musl builds. Thanks @Yuxin-Qiao!
+- Linux CLI: add musl source compatibility for static Linux SDK builds. Thanks @Yuxin-Qiao!
+- Cost history: resize the chart details to the hovered day's model breakdown instead of reserving the tallest day. Thanks @elijahfriedman!
+- Antigravity: use current backend quota labels in menus and widgets while preferring a usable quota lane over an exhausted one. Thanks @Yuxin-Qiao!
+- Pi: cache session filename and timestamp parsers to reduce cost-history refresh overhead. Thanks @ProspectOre!
+- Menu bar: reuse the icon-observation signature during provider refreshes instead of computing it twice. Thanks @abe238!
+- LiteLLM: show personal and team spend amounts directly on budget rows while suppressing duplicate budget sections. Thanks @hololee!
+
+### Fixed
+- Menu: align cost and utilization rows with provider content and use native bottom action items. Thanks @elijahfriedman!
+- Charts: keep hover selection on bar widths, preserve single-day details, and remove redundant cost-menu detail lines. Thanks @elijahfriedman!
+- Cost history: keep chart date labels aligned with their bars and visible without clipping. Thanks @elijahfriedman!
+- Claude settings: dim and disable Avoid Keychain prompts while global Keychain access is disabled. Thanks @Zihao-Qi!
+- Linux CLI: read OpenCode Go local SQLite usage in automatic mode and allow Command Code billing with a configured manual cookie.
+- MiniMax diagnostics: include safe per-service usage and boosted quota limits for mismatch reports. Thanks @sagelga!
+- Xiaomi MiMo: retry another imported browser session when a stale session redirects API requests to login. Thanks @Yuxin-Qiao!
+- MiniMax: retry the China API region when the global token endpoint reports a structured invalid-key response.
+- Menu refresh: scope manual refreshes to the visible provider, keep Command-R consistent with mouse refresh, and avoid animated refresh-row compositing. Thanks @jangisaac-dev!
+- Localization: improve Catalan app and website translations. Thanks @pmontp19!
+- Claude web: persist renewed session cookies after successful usage requests so imported sessions stay current. Thanks @ProspectOre!
+- Kiro: keep parsed usage available when the optional account probe times out or fails. Thanks @Yuxin-Qiao!
+- Cursor: ignore an exhausted Auto or API subquota only when another independent quota remains usable, while preserving the overall cap. Thanks @Yuxin-Qiao!
+- Memory: release idle OpenAI WebViews under system pressure without blocking the main thread. Thanks @ProspectOre!
+- Memory: trim rebuildable menu and OpenAI debug caches under system pressure. Thanks @ProspectOre!
+- Provider plans: keep Claude and Kiro plan matching on one rendered line to avoid bogus labels from adjacent usage hints. Thanks @elijahfriedman!
+- Antigravity: use current Gemini 5-hour and weekly quota-summary lanes for the compact menu bar icon and merged highest-usage selection. Thanks @Zihao-Qi!
+- Usage bars: render values rounded to 0% or 100% as fully empty or full. Thanks @Zihao-Qi!
+- Codex web: keep cookie-import deadlines responsive when browser cookie work blocks the shared worker pool.
+- z.ai: open the usage dashboard for the configured global or China API region. Thanks @renbaoshuo!
+- Usage dashboards: tint inline history bars with each provider's branding color. Thanks @elijahfriedman!
+- Command Code: avoid repeated depleted notifications when subscription lookup intermittently fails. Thanks @LPFchan!
+- Codex pace: extrapolate historically exhausted weeks for run-out forecasts and avoid contradictory reset headlines. Thanks @Yuxin-Qiao!
+- Localization: correct the German in-progress refresh label. Thanks @ChrisLauinger77!
+- Localization: correct misleading literal German UI translations. Thanks @madebyjulz!
+- Install docs: describe the official Homebrew cask as universal on Intel and Apple silicon. Thanks @ChrisGVE!
+- Settings: switch tabs immediately before animated window resizing and reduce Providers sidebar work. Thanks @elijahfriedman!
+- Windsurf: import complete Devin sessions from the current app origin before legacy browser storage. Thanks @kiranmagic7!
+- Antigravity: humanize raw model identifiers while preserving server-provided quota labels. Thanks @bcharleson!
+- Menu bar: show provider status markers only for the provider rendered in each icon. Thanks @Zihao-Qi!
+- Codex CLI: make automatic usage reads prefer OAuth and CLI sources instead of blocking on the optional web dashboard.
+- Codex web: apply `--web-timeout` to the full cookie import, account verification, retry, and dashboard fetch path.
+- OpenCode Go: allow configured manual cookies in the Linux CLI while keeping browser-cookie import gated to macOS. Thanks @Yuxin-Qiao!
+- Provider probes: cap captured subprocess output at 1 MiB per stream without dropping valid text at a truncated UTF-8 boundary. Thanks @ProspectOre!
+- Provider switcher: keep Codex quota rows visible when switching away and back during a manual refresh, including menus with usage-history sections. Thanks @Yuxin-Qiao!
+- Bedrock: ignore invalid billing dates when selecting the latest usage values. Thanks @ProspectOre!
+- Usage history: let opted-in providers persist weekly utilization and keep saved charts visible. Thanks @kiranmagic7!
+- Localization: improve Japanese terminology consistency and localize next-day reset times across all 21 app languages. Thanks @tukuyomil032!
+- Menu bar: keep visible quota values stable while a manual refresh is in flight without rewinding background-refresh countdowns. Thanks @Zihao-Qi!
+- Menu bar: stop informational usage-card rows from highlighting like clickable actions. Thanks @elijahfriedman!
+- Localization: validate placeholder integrity across every app language and repair malformed Vietnamese interpolation tokens. Thanks @Yuxin-Qiao!
+
+## 0.36.1 — 2026-06-16
+
+### Added
+- Poe: add current point balance and recent points history from a configured API key (#1191). Thanks @Yuxin-Qiao!
+- Chutes: add subscription, quota-window, and pay-as-you-go usage tracking from a configured API key (#1496). Thanks @mvanhorn!
+- Zed: add plan, edit-prediction quota, billing-cycle, and overdue-invoice tracking from the signed-in editor Keychain session (#1517). Thanks @enesteve0!
+
+### Changed
+- Website: add Poe, Chutes, and Zed to the provider gallery with matching icons and setup documentation.
+
+### Fixed
+- Provider switcher: use a continuous menu background instead of a separate light-mode tinted band. Thanks @Zihao-Qi!
+
+## 0.36.0 — 2026-06-16
+
+- Ollama: replace the bundled provider icon with the cleaner official mark while preserving native template tinting. Thanks @mattab178!
+- Menu bar: avoid a one-time visible menu rebuild after first-open background data arrives.
+- Settings: use high-contrast selected-content colors for provider sidebar text and icons.
+- Localization: align the app and website on the same 21-language catalog, adding Italian (#1248), Indonesian (#1513), Polish (#1253), Arabic, Persian, and Thai as selectable app languages, plus automatic website detection, persistent pickers, and right-to-left layouts for Arabic and Persian. Thanks @Yuxin-Qiao and @StevanusPangau!
+- Website: replace the remaining provider letter tiles with the canonical Devin, LiteLLM, and T3 Chat logos.
+- Website: keep localized mobile navigation, calls to action, package commands, and right-to-left layouts inside narrow viewports.
+
+### Added
+- LiteLLM: add personal and team budget tracking from a configured virtual key and proxy URL (#1542). Thanks @hololee!
+
+### Changed
+- Antigravity: prefer app and `agy` quota summaries, group usage into Gemini and Claude + GPT session/weekly pools, and preserve IDE and OAuth fallbacks. Thanks @Zihao-Qi!
+- Antigravity: show structured quota reset timestamps from the current `resetTime` field (#1553). Thanks @akunzai!
+- Configuration: honor absolute `XDG_CONFIG_HOME` paths while rejecting relative paths, preserving existing standard and legacy config precedence (#1562). Thanks @kiranmagic7!
+
+### Fixed
+- Menu bar: preserve native AppKit image-row alignment when returning to cached provider content in the open merged menu (#1560). Thanks @Zihao-Qi!
+- Menu bar: defer hosted submenu reconstruction until an active refresh finishes so partial provider data cannot replace the visible menu (#1556). Thanks @Yuxin-Qiao!
+- Weekly pace: suppress the “Lasts until reset” label when the projected run-out risk is nonzero (#1561). Thanks @kiranmagic7!
+- Antigravity: retry transient `Text file busy` launch failures while the CLI executable is being replaced.
+- Antigravity: fall back to loopback HTTP for local CLI and language-server probes on Linux, where self-signed localhost TLS cannot be trusted (fixes #1508). Thanks @zodiacfireworks!
+- Codebuff: enforce the optional subscription grace period even when the transport ignores cancellation.
+- Copilot: show the shared quota reset date for limited premium and chat usage windows. Thanks @Zihao-Qi!
+- Codex: keep managed login timeouts bounded while preserving captured output when detached helpers retain stdout or stderr.
+- Claude: keep segmented multi-account menus scoped to the selected account while its refresh is in flight (fixes #1527).
+- Command Code: keep showing available credits after the bounded optional subscription grace, including when the transport ignores cancellation (fixes #1131).
+- DeepSeek: keep balance refreshes responsive when optional usage-summary work ignores cancellation.
+- OpenRouter: keep credit refreshes responsive when optional key-quota enrichment ignores cancellation.
+- Provider probes: stop waiting indefinitely for inherited output pipes after subprocesses or CLI version checks exit (fixes #1531).
+- Menu bar: update visible usage values in place when a manual refresh completes instead of leaving the open provider card stale until the menu is reopened (fixes #1516).
+- Gemini: recognize the current `gemini-api-key` CLI auth setting so API-key sessions show the supported OAuth guidance instead of a misleading not-logged-in error (fixes #1511).
+- Kiro: keep usage refreshes bounded and clean up CLI helpers when they retain output pipes, ignore termination, or are cancelled (fixes #1533). Thanks @kiranmagic7!
+- Gemini: keep fnm package discovery bounded when helper descendants retain output pipes or ignore termination (fixes #1534). Thanks @kiranmagic7!
+- Xiaomi MiMo: cancel optional token-plan requests when the required balance request fails instead of delaying the error for up to 30 seconds.
+- Settings: make the cost history window directly editable by keyboard while preserving the existing stepper and 1–365 day bounds (fixes #1499). Thanks @kiranmagic7!
+- OpenCode Go: show Zen balances for accounts without subscription usage windows, including when the balance request takes longer than optional enrichment (fixes #1476). Thanks @kiranmagic7!
+
+## 0.35.0 — 2026-06-14
+
+### Added
+- Kimi: add usage fetching from the official Code API key flow, with optional compatible HTTPS proxy support (#1424). Thanks @kiranmagic7!
+- Xiaomi MiMo: show paid and granted balance components alongside token-plan usage without requiring a duplicate provider (#1309). Thanks @AdrianSimionov!
+- Xiaomi MiMo: add an opt-in local session-log fallback for token accounting when browser quota authentication is unavailable (#1284). Thanks @LeoLin990405!
+- Weekly pace: use configured work days for standard weekly pace calculations while leaving historical Codex pacing unchanged (#1451, fixes #1356). Thanks @pstanton237!
+
+### Fixed
+- Security: prevent test and infrastructure cookie-import paths from accessing real browser profiles, SQLite stores, or Keychain data unless explicitly enabled (#1491).
+- Menu bar: stop the provider-switcher shortcut monitor from killing the menu's event tracking session. Its event-queue peek re-entered the run loop in tracking mode, which could leave a zombie menu on screen that ignored clicks for tens of seconds (beach ball) — most often right after opening the menu or after rapid Cmd-number provider switching, with Settings… the usual victim. Peeks now run in a barren private run-loop mode, start only once the tracking session is pumping, and no longer touch mouse events. Thanks @ProspectOre!
+- Menu bar: rebuild merged provider content inside AppKit's active tracking run loop so provider switches no longer wait for the menu to close or the default run loop to resume.
+- Menu bar: keep cached provider content visible while switching merged tabs so the open menu no longer flickers through an empty state.
+- Menu bar: restore native macOS positioning for merged provider dropdowns while preparing current content before AppKit lays out the menu.
+- Menu bar: avoid starting a duplicate background provider refresh when the menu closes while its initial missing-data refresh is still in flight.
+- Menu bar: pin the status-item dropdown to the current system appearance so it follows the Light/Dark setting instead of inheriting the menu bar's vibrant appearance, which rendered the menu dark in Light mode whenever a dark or strongly-colored window or wallpaper sat behind the menu bar (#1490). Thanks @npapridonu!
+- Menu bar: handle the global open-menu shortcut synchronously so repeated presses close the tracked menu instead of queueing a delayed reopen (#1470). Thanks @Zihao-Qi!
+- Menu bar: keep the selected quota percentage visible in Pace mode when pace is temporarily unavailable instead of collapsing to an icon-only status item (fixes #1462).
+- Settings: memoize cookie cache lookups behind the "Cached: …" picker labels so opening Settings and switching panes no longer pays a synchronous Keychain read per SwiftUI body evaluation, which froze the Providers pane for seconds (#1471). Thanks @ProspectOre!
+- Settings: keep the native tab toolbar in sync when macOS switches appearance while the window is open (#1484). Thanks @hhh2210!
+- Launch at Login: remove pending registrations when disabled without re-registering entries awaiting user approval (#1469). Thanks @AmrMohamad!
+- Diagnostics: enforce probe timeouts even when an underlying provider operation ignores Swift task cancellation.
+
+## 0.34.0 — 2026-06-12
+
+### Added
+- Copilot: optionally import GitHub billing budget windows, bind them to the active account, and expose budget metrics in cards and menu bar icons (#1273). Thanks @Quicksaver!
+- Localization: add native Korean language support across the app and language picker (#1460). Thanks @soohanpark!
+- Localization: add German as a selectable app language (#1245). Thanks @Yuxin-Qiao!
+- Localization: add Turkish as a selectable app language (#1232). Thanks @ykarateke!
+- Devin: add daily and weekly quota tracking from the signed-in Chrome session or a manual Bearer token (#1264, fixes #800). Thanks @coygeek!
+- Amp: add local `amp usage` support, including account identity and individual and workspace credit balances (fixes #1317). Thanks @3kh0!
+- Menu bar: add an optional reset-time display for the selected quota metric, with percent fallback when reset metadata is unavailable (#1223, fixes #1185). Thanks @Yuxin-Qiao!
+- Cursor: include application data, extensions, settings, and caches in optional local storage tracking (fixes #1403). Thanks @dhruv-anand-aintech!
+- Menu bar: move the highlighted Overview provider with trackpad or mouse-wheel scrolling while preserving native submenu and keyboard behavior (#1436). Thanks @joshuavial!
+
+### Fixed
+- CLI: keep Ollama API credentials scoped to Ollama when deciding whether another provider requires macOS web support (#1466). Thanks @WadydX!
+- Provider switcher: keep localized tab titles visible by tightening outer insets only when equal-width segments would otherwise truncate.
+- OpenAI API: follow Admin usage pagination for costs and completions so multi-page organization usage totals are not undercounted (#1465). Thanks @rohitjavvadi!
+- Settings: slightly increase the window height so standard panes fit without clipping their final controls or helper text.
+- Menu bar: show immediate in-place feedback for manual refreshes, keep tracked-menu geometry stable, and coalesce repeated clicks until the active refresh succeeds or fails (#1458). Thanks @hhh2210!
+- Grok: recover web billing from status-7 credential failures by combining current browser sessions with non-expired CLI auth, accept raw protobuf responses, and render current zero-use periods (#1452). Thanks @bcharleson!
+- Amp: restore usage fetching with access-token authentication for the current balance endpoint and retain browser-cookie settings parsing as a fallback. Thanks @3kh0!
+- Antigravity: detect current hyphenated IDE language-server processes inside Antigravity app bundles so local quota refreshes no longer report the IDE as unavailable (#1405). Thanks @lfmundim!
+- Menu bar: avoid republishing unchanged provider storage footprints so background scans no longer trigger unnecessary menu observation work (#1416). Thanks @soohanpark!
+- Cursor: show capped team Extra usage when no individual cap exists, and honor percent used/remaining menu bar display settings instead of always showing currency spend (#1426). Thanks @lpc-eol!
+- Cursor: derive a first-party web session from the signed-in Cursor.app as a final fallback, preserving account precedence and legacy request quotas (#1295). Thanks @Jackie-Qin!
+- Claude: explain that an unauthorized Web session requires signing in at claude.ai or refreshing imported cookies (#1287). Thanks @LeoLin990405!
+- CLI server: reload provider config for every usage and cost request, invalidate config-dependent cache entries, and prune expired config variants without restarting `codexbar serve`. Thanks @enieuwy!
+- Menu bar: reserve quota-bar space consistently across Overview and provider switcher segments so selection no longer changes segment height (#1445). Thanks @Zihao-Qi!
+- Cost usage: accept normal models.dev catalog churn while retaining prior model prices as fallbacks, so newly priced models appear without requiring a manual cache reset (#1438). Thanks @tom-rigelblu!
+- Menu bar: detect Tahoe Control Center proxy windows parked in the blocked offscreen slot during startup recovery, so hidden icons show the existing guidance without weakening menu-bar-manager safeguards (#1440).
+- AWS Bedrock: treat Cost Explorer's temporary data-unavailable response as zero usage instead of an HTTP 400 error (#1324). Thanks @enesteve0!
+- Provider switcher: inset quota bars inside fixed-height segments so icons, labels, and selected pills remain vertically centered.
+- Doubao: show an unavailable quota state when Ark omits trustworthy request-limit data instead of reporting 100% left.
+- Menu bar: anchor merged provider dropdowns to the status item's trailing edge without marking preserved in-flight refresh content fresh, preventing horizontal drift while keeping deferred updates visible (#1288). Thanks @Yuxin-Qiao!
+- Antigravity: fall back to the CLI usage server when the desktop app is closed, keep helper sessions owned and bounded without hidden sign-in flows, and show model rows with missing usage as unavailable instead of exhausted (#1313). Thanks @enieuwy!
+- Cost usage: replace repeated Foundation metadata/root checks with one portable file-stat pass so expired Codex history refreshes stay responsive on very large session archives (#1392). Thanks @TheAngryPit and @ProspectOre!
+- Cursor: show the Safari Full Disk Access recovery hint before the long browser login list so permission guidance remains visible when menu errors truncate (#1419, fixes #1417). Thanks @hhh2210!
+- Cursor: present legacy request-based plans as one Requests quota with the raw used/limit count instead of unrelated token-based Auto/API bars (#1420, fixes #1418). Thanks @hhh2210!
+- Cost usage: memoize Codex priority-turn trace metadata incrementally so warm refreshes scan only appended rows instead of rescanning large trace databases (#1404). Thanks @ProspectOre!
+- Security: reject insecure or malformed MiniMax and Alibaba endpoint overrides while preserving valid custom HTTPS deployments (#1269). Thanks @Hinotoi-agent!
+- Security: reject insecure or malformed OpenRouter, Codebuff, Groq, and ElevenLabs endpoint overrides before sending provider credentials (#1256). Thanks @Hinotoi-agent!
+
+## 0.33.0 — 2026-06-11
+
+### Added
+- Settings: choose Terminal.app or iTerm for Open Terminal actions, including Vertex AI login commands (#1225, fixes #1147). Thanks @Yuxin-Qiao!
+- Localization: add Japanese as a selectable app language (#1385). Thanks @naoterumaker!
+
+### Fixed
+- Menu bar: keep large dynamic Cost totals inside the fixed-width hosted row so switching providers no longer widens the menu or misaligns submenu arrows.
+- Cost history: keep all per-day model breakdown rows available in a bounded scrolling detail area instead of hiding models after the first four (#1370). Thanks @MoollaMore!
+- Cost usage: run local session-corpus scans and cache decoding on a dedicated serial queue instead of the Swift cooperative thread pool, so multi-minute scans of large archives no longer starve the app's async work or freeze menus (#1387, #1392). Thanks @ProspectOre!
+- Copilot: keep explicitly unlimited chat quotas visible instead of dropping their zero-entitlement payload as unavailable (#1320). Thanks @soumikbhatta!
+- Security: block credentialed provider redirects that leave the original HTTPS origin while preserving same-origin redirects (#1237). Thanks @Hinotoi-agent!
+- Codex: keep local token and cost history visible when remote quota data is unavailable (#1390). Thanks @vaibhavarora14!
+- Doubao: confirm zero-remaining HTTP 200 request limits before falling back, preserving genuine exhaustion and avoiding false 100% usage (#1383). Thanks @LeoLin990405 and @foobra!
+- Menu bar: defer pasteboard writes and copy feedback outside the `NSMenu` tracking callback so in-menu copy buttons no longer beachball on macOS 26 (#1388). Thanks @LeoLin990405!
+- Menu bar: defer merged status-icon redraws until the tracked menu closes while preserving animation lifecycle and quota-warning timing, reducing WindowServer churn during long menu sessions (#1409, fixes #1399). Thanks @kiranmagic7!
+- Provider status: decode status feeds on the concurrent executor and reuse ISO8601 formatters, removing a measured main-thread stall during refreshes (#1406). Thanks @ProspectOre!
+- Menu bar: keep one stable width across merged provider tabs and resize every hosted card row to AppKit's final menu width so provider switching no longer leaves a widened menu with inset submenu arrows (#1410).
+- Menu bar: keep Codex `auth.json` reads, JWT parsing, and fingerprint hashing off the menu-build path by rendering a cached account snapshot and revalidating it asynchronously (#1401). Thanks @ProspectOre!
+- Menu bar: defer Overview-row provider transitions out of AppKit's click callback so opening provider detail no longer performs a full synchronous menu rebuild (#1325).
+- Menu bar: open cached menus immediately after data-only invalidations, then refresh missing or stale provider data asynchronously without queuing redundant work on close (#1398). Thanks @joshuavial!
+- Menu bar: recycle SwiftUI card hosting views across data refreshes and provider switches, and reconcile matching menu rows in place instead of removing and reinserting every row, cutting open-click, switch, and idle rebuild cost (#1394). Thanks @bcssewl!
+- Menu bar: gate the provider-switcher shortcut monitor's event-queue peek behind session event counters so hover-driven menu tracking no longer calls `NSApp.nextEvent` on every run-loop pass (#1397). Thanks @bcssewl!
+- Development: disable Keychain access for unbundled executables to avoid repeated password prompts while preserving packaged app behavior (#1271). Thanks @Yuxin-Qiao!
+- Antigravity: exclude model quotas without a remaining fraction from family summaries so they no longer mask tracked usage in the automatic menu-bar metric (#1369). Thanks @Martin-Hausleitner!
+- Claude: add bundled Fable 5 pricing, account for native 1-hour cache-write usage, and refresh Sonnet 4.6 full-context rates (#1368). Thanks @MoollaMore!
+- Claude: show a direct claude.ai re-login action when a configured web session expires or becomes invalid (#1377). Thanks @LeoLin990405!
+- Menu: reuse unchanged hosted chart submenus and precompute utilization history models to reduce expand and hover stalls (#1379). Thanks @hhh2210!
+- Menu bar: defer data-refresh rebuilds until the tracked menu closes, avoiding multi-second WindowServer stalls with slower providers such as Grok (#1376). Thanks @jangisaac-dev!
+- OpenAI Web: evict cached dashboard WebViews after their idle timeout even when no later cache activity occurs, releasing hidden WebKit helper processes (#1386). Thanks @naoterumaker!
+- Xiaomi MiMo: import automatic session cookies from Safari, Chrome variants, Firefox, and Edge instead of limiting discovery to Chrome (#1304). Thanks @Yuxin-Qiao!
+
+## 0.32.5 — 2026-06-09
+
+### Added
+- Localization: add French as a selectable app language (#1241). Thanks @Yuxin-Qiao!
+- Localization: add Ukrainian as a selectable app language (#1250). Thanks @Yuxin-Qiao!
+- Localization: add Dutch as a selectable app language (#1252). Thanks @Yuxin-Qiao!
+- Localization: add Vietnamese as a selectable app language (#1247). Thanks @Yuxin-Qiao!
+
+### Fixed
+- Menu bar: keep provider switching inside AppKit's menu-tracking transaction and defer structural dropdown rebuilds until mouse-up completes, preventing intermittent hangs when moving between providers and Overview.
+- Localization: cache resolved localized bundles so repeated menu/status text lookups no longer hit disk on the main thread (#1355, fixes #1347). Thanks @Yuxin-Qiao!
+- Menu bar: size hosted chart submenus directly instead of spinning up throwaway SwiftUI hosting controllers during menu layout (#1352). Thanks @Yuxin-Qiao!
+- Menu bar: avoid recomputing expensive readiness signatures on closed-menu store ticks while preserving root-open refresh correctness for deferred observations (#1351). Thanks @Yuxin-Qiao!
+- Menu bar: defer Quit from the status menu until AppKit menu tracking unwinds so shutdown does not wedge Dock autohide state (#1354, fixes #1353). Thanks @jskoiz!
+- Claude: remove transient ClaudeProbe session artifacts after CLI usage polls so background refreshes no longer fill Claude Code project history with CodexBar `/usage` sessions (#1301). Thanks @LPFchan and @matthewod11-stack!
+- Menu bar: keep z.ai overview rows with detail submenus in Overview so hovering quota details no longer recurses into a nested provider menu (#1279, fixes #1246). Thanks @RajvardhanPatil07!
+- Codex: backfill visible-account reset timestamps and missing 5-hour/weekly window metadata from same-workspace plan history so segmented multi-account JSON keeps machine-readable reset data (#1283). Thanks @callmepopo!
+- Antigravity: detect CLI local language-server processes and allow empty CSRF tokens only for explicit CLI matches so Antigravity CLI quota usage renders without weakening IDE CSRF detection (#1341). Thanks @oyaah!
+- Menu bar: skip closed attached-menu rebuilds during stale background data-refresh ticks so closed dropdowns are not pre-warmed while the user is not interacting (#1291). Thanks @Nicolas0315!
+- Cursor: show deficit and run-out pace details for 30-day Total, Auto, and API billing-cycle usage rows (#1336). Thanks @dhruv-anand-aintech!
+- Codex: time out stalled managed `codex login` processes so account switches no longer stay stuck in progress after OAuth completes (#1330). Thanks @dhruv-anand-aintech!
+- Codex Spark: show the same deficit and run-out pace details as the core Codex quota lanes for 5-hour and weekly model limits (#1335). Thanks @dhruv-anand-aintech!
+- Antigravity: make the automatic menu-bar summary choose the most constrained family quota so an exhausted Gemini lane is no longer hidden by a full Claude lane (#1334). Thanks @dhruv-anand-aintech!
+- Performance: memoize models.dev cost catalog load outcomes so large Codex history scans no longer re-read and decode the same cache file per row (#1322, refs #1311). Thanks @turbothad!
+- Menu bar: compute Claude pace/reserve from the selected menu-bar metric window so Primary (Session) no longer pairs the session percentage with the weekly reserve (#1302). Thanks @outfoxer!
+- Menu bar: defer merged-menu close rebuilds and cache repeated menu-card height measurements so dismissing or rapidly switching the merged dropdown avoids rebuilding SwiftUI-backed cards on the main thread (#1274, #1286, #1314). Thanks @hhh2210!
+- Menu bar: keep merged provider tab selection from invalidating broad settings observers so switching providers no longer triggers background refresh and status-icon work.
+- Menu bar: observe a compact icon-state signature so merged status icons no longer redraw for provider snapshot changes that cannot affect the visible icon (#1297). Thanks @hhh2210!
+- Menu bar: keep provider-switcher quota bars from replacing Auto Layout constraints when the visible ratio is unchanged, making tab switches responsive with many providers enabled (#1303, #1315). Thanks @juanjoseluisgarcia!
+- Kiro: retry login-shell PATH capture when CLI discovery races a slow cold shell startup, so `kiro-cli` is no longer stuck as missing for the whole app session (#1316). Thanks @bt-justtrack!
+
+## 0.32.4 — 2026-06-02
+
+### Fixed
+- Menu bar: avoid queuing redundant provider refreshes when opening a fresh merged-menu dropdown, while still retrying missing or stale provider data after menu tracking ends (#1235, #1277). Thanks @hhh2210!
+
+## 0.32.3 — 2026-06-02
+
+### Fixed
+- Menu bar: stop forcing a private preferred-position value for fresh status items; suspicious stored positions are now cleared so AppKit can place CodexBar normally on macOS 26 / 5K displays (#1267). Thanks @AdrianSimionov, @kirocop, and @Yuxin-Qiao!
+- Menu bar: cache provider brand icons so merged-icon status updates no longer repeatedly parse SVG assets on the main thread during hover/open animations (#1235, #1274). Thanks @andradebruno, @xingpz2008, and @Yuxin-Qiao!
+- Copilot: treat GitHub Copilot Business token-billing zero-entitlement quotas as unavailable instead of showing misleading 0% used usage (#1258, #1270). Thanks @devYRPauli!
+- Menu bar: prepare closed menus after refresh and only reuse stale dropdown content for data-refresh invalidations so merged menu opens stay responsive without bypassing privacy or structure changes (#1261). Thanks @ProspectOre!
+- OpenAI Web: stop reloading away from login and Cloudflare blocking states so the dashboard WebView does not loop on route corrections (#1259). Thanks @ProspectOre!
+
+## 0.32.2 — 2026-06-01
+
+### Added
+- QA: document the live CodexBar e2e flow and add a redacted provider-matrix helper for packaged CLI smoke tests.
+
+### Fixed
+- Menu bar: add breathing room to compact Codex account rows so the provider, account, status, and plan labels no longer hug the row edges.
+- Performance: make Codex token-cost scanning faster and more memory-efficient on large local session corpora.
+
+## 0.32.1 — 2026-05-31
+
+### Fixed
+- Claude: keep Claude CLI-owned OAuth refresh tokens delegated to Claude Code when CLI storage is present, preventing CodexBar from consuming rotating refresh tokens and forcing re-login (#1161, #1239). Thanks @RajvardhanPatil07!
+- Menu bar: reuse short-lived Codex account reconciliation snapshots so repeated menu rebuilds do not reread local auth state on every open.
+- Menu bar: defer automatic provider refreshes until after AppKit menu tracking ends so opening the dropdown no longer starts work that can freeze focus and keyboard input.
+- Menu bar: suppress background keychain and OpenAI dashboard work during startup/menu tracking so the dropdown stays clickable without macOS keychain prompts or WebKit memory spikes.
+
+## 0.32.0 — 2026-05-31
+
+### Added
+- Settings: add search to the Providers pane so large provider lists can be filtered by name or id (#1184). Thanks @046081-dotcom!
+
+### Fixed
+- Augment: parse the updated `auggie account status` output format, fall back to browser cookies when CLI parsing fails, and restore session cookie detection (#1224). Thanks @bcharleson!
+- Amp/Ollama: require HTTPS before reattaching imported browser cookies on provider redirects to avoid cleartext cookie exposure (#1226). Thanks @Hinotoi-agent!
+- Antigravity: filter noisy remote OAuth per-model quota rows, keep consumed noisy rows detail-only, and prevent image/lite/autocomplete/internal rows from driving summary bars (#1209). Thanks @guhyun9454!
+- Claude: preserve the last good Claude Web usage snapshot across transient Unauthorized refresh failures while still surfacing repeated auth failures (#1220). Thanks @LeoLin990405!
+- CLI: avoid executing a same-user mutable temporary installer script across the macOS administrator privilege boundary (#1222). Thanks @Hinotoi-agent!
+- Codex: cancel OpenAI WebKit dashboard refreshes promptly and avoid an immediate second background WebView retry after timeouts, reducing launch-time Web Content CPU spikes (#1217).
+- Menu: refresh open Codex menu adjuncts as dashboard, credits, token-cost, and plan-history data become ready after cold start (#1150). Thanks @AmrMohamad!
+- Menu bar: defer background parent-menu rebuilds until AppKit menu tracking ends so late-arriving usage data cannot stall dropdown hover on macOS 26.5 (#1227).
+- Menu bar: give CodexBar status items stable placement identities while preserving existing upgrade placement state (#1216). Thanks @pdurlej!
+- Release: isolate notarization API keys and upload ZIPs in a private per-run temporary directory instead of predictable shared /tmp paths (#1228). Thanks @Hinotoi-agent!
+- Status: retry startup refreshes a few times after transient offline/network failures so provider status can recover after macOS brings the network online (#1211).
+
+## 0.31.0 — 2026-05-28
+
+### Changed
+- Docs: update the Homebrew install command to use the official `codexbar` cask now that it supports Intel Macs (#1189). Thanks @SSakutaro!
+- Tests: document and audit that routine validation must not trigger macOS Keychain prompts.
+- Localization: localize popup panels and provider settings UI across supported languages (#1181). Thanks @jack24254029!
+- Localization: complete Brazilian Portuguese coverage so pt-BR no longer falls back to English for new UI strings (#1188). Thanks @ManuzimFerreira!
+
+### Added
+- AWS Bedrock: support resolving usage and cost-history credentials from a named AWS profile via the AWS CLI (#1190). Thanks @oleksandr-soldatov!
+- Codex: show Codex Spark model-specific usage as an optional extra quota lane (#1195, fixes #1177). Thanks @LeoLin990405!
+- Localization: add Swedish as a selectable app language (#1186). Thanks @yeager!
+
+### Fixed
+- CLI: bound `codexbar serve` requests with a configurable timeout and coalesce concurrent cache misses so hung `/usage` callers no longer stampede provider refreshes (#1208). Thanks @enieuwy!
+- Claude: add Opus 4.8 to the built-in pricing fallback so stale models.dev caches still show token cost (#1214, fixes #1210). Thanks @devYRPauli!
+- Codex: preserve authorized web dashboard credits-only snapshots instead of treating missing usage windows as a failed refresh (#1206, fixes #1204). Thanks @soumikbhatta!
+- Cost history: make token-cost JSONL scans cancellation-aware so quitting, forced refreshes, and account switches can stop stale scans sooner.
+- Codex: show Spark 5-hour and weekly usage as separate quota lanes in Codex breakdowns (#1201).
+- Codex: show captured `codex login` output when managed Add Account fails so users can recover from account-selection or OAuth failures (#1199). Thanks @chapati23!
+- Claude: hide the obsolete Design quota lane now that Claude Design shares the main Claude usage limit (#1197).
+- Menu bar: coalesce visible-menu rebuilds and reduce hover highlight work so the dropdown stays responsive on macOS 26.5 (#1196).
+
+## 0.30.1 — 2026-05-28
+
+### Changed
+- CLI: make `codexbar diagnose` use a generic safe provider diagnostic export for all providers, with MiniMax details attached only as provider-specific metadata.
+
+### Fixed
+- Settings: add trailing breathing room to provider-sidebar controls (#1183). Thanks @Yuxin-Qiao!
+- Claude: treat OAuth usage HTTP 429s as rate limits, preserve cached credentials, and back off background retries while still allowing manual refresh (#1179). Thanks @LeoLin990405!
+- Menu bar: stop repeated display-change status-item recreation from corrupting Control Center or confusing menu bar managers (#1176, fixes #1175). Thanks @diazdesandi!
+
+## 0.30.0 — 2026-05-27
+
+### Added
+- MiniMax: add a redacted diagnostic CLI export for safe issue reports (#1128). Thanks @Yuxin-Qiao!
+- Antigravity: show the complete per-model quota breakdown alongside the existing summary lanes (#1139). Thanks @guhyun9454!
+- Widget: show tertiary usage rows for providers that expose a third quota lane (#1160). Thanks @LeoLin990405!
+- DeepSeek: show optional web-session usage and cost summaries alongside the balance card (#1166). Thanks @Yuxin-Qiao!
+- OpenAI: scope Admin API usage to the configured project and keep token accounts from inheriting stale project filters (#1168). Thanks @mstallone!
+
+### Fixed
+- App shutdown: detach status items, close tracked menus, and cancel menu tasks before quit so Dock autohide stays responsive on macOS 26.5 (#1174). Thanks @jskoiz!
+- Widgets: package the macOS widget as a real Xcode app-extension target so WidgetKit descriptors load on macOS 26.5 (#1095). Thanks @jamesjlopez!
+- Menu: render quota-warning markers as subtle inset ticks instead of full-height bars (#1149).
+- Codex: show sign-in guidance when the Codex CLI is logged out instead of reporting a temporary usage outage (#1171, fixes #1170). Thanks @jskoiz!
+- Menu bar: clear stale hidden macOS status-item visibility defaults once before creating CodexBar items (#1169).
+- StepFun: refresh expired Oasis tokens and persist recovered manual sessions. Thanks @LeoLin990405!
+- Release: prevent manual CLI artifact builds from publishing or clobbering release assets (#1154). Thanks @jskoiz!
+- Cost history: route OpenAI and Mistral API spend through the shared cost-history cards, including OpenAI request counts (#1163). Thanks @LeoLin990405!
+- Menu: keep provider switcher Cmd-number and arrow shortcuts working while the open menu is tracking events (#1157, fixes #1156 and #1144). Thanks @anirudhvee!
+- Codex: prevent fork token replay from overcounting corrected cumulative session totals (#1164). Thanks @xx205!
+- Alibaba Token Plan: update usage refreshes to the Bailian subscription-summary endpoint (#1142). Thanks @YanxinXue!
+- Ollama: show pace projections for documented 5-hour session and 7-day weekly usage windows (#1136). Thanks @bdamokos!
+- Localization: polish Simplified Chinese wording and add notification strings (#1165). Thanks @fanfanci!
+- Localization: improve Traditional Chinese wording and localize notification copy (#1158). Thanks @jack24254029!
+- Localization: improve Simplified Chinese visible menu, dashboard, and usage labels (#1145). Thanks @Yuxin-Qiao!
+
+## 0.29.1 — 2026-05-26
+
+### Added
+- Integrations: list the Noctalia/Quickshell Codex usage plugin in the Linux CLI integrations (#1115). Thanks @rayoplateado!
+- Display: add optional workday markers for weekly progress bars (#1102). Thanks @Yuxin-Qiao!
+- Localization: add Traditional Chinese (`zh-Hant`) app strings. Thanks @ilyaliao!
+
+### Fixed
+- Claude: classify Claude CLI 2.1 subscription-only `/usage` output separately and fall back to direct CLI usage when the PTY panel fails to load (#1121, fixes #1116). Thanks @Yuxin-Qiao!
+- Provider switcher: keep multi-row account/provider controls compact so large menus stay within bounds (#1113). Thanks @Yuxin-Qiao!
+- Grok: label usage bars from the actual reset window instead of the remaining reset distance (#1148). Thanks @kiankyars!
+- Config: keep legacy credentials when migrated config changes fail to save so retry can recover them (#1146). Thanks @RajvardhanPatil07!
+- Codex: avoid overcounting forked sessions when parent logs are missing while still counting incremental usage (#1143). Thanks @jskoiz!
+- Groq: show a distinct Groq provider icon instead of reusing the Grok glyph (#1112). Thanks @kiankyars!
+- Claude: normalize OAuth extra-usage spend limits from minor units so Enterprise spend displays as currency instead of 100x too high (#1114, fixes #1111). Thanks @Yuxin-Qiao!
+- Menu bar: preserve status item identity during display-change recovery so menu bar managers do not treat CodexBar as a new hidden item (#1122, fixes #1109). Thanks @lederniermagicien!
+- OpenAI: retry transient Admin API usage failures once before surfacing an access error (#1117).
+- OpenCode Go: read local usage history before falling back to browser-cookie dashboard fetches (#1021). Thanks @sopenlaz0!
+- Menu bar: show extra-usage spend as currency text for Claude and Cursor when that metric is selected (#1107). Thanks @Yuxin-Qiao!
+- Codex: run regular credits and OpenAI dashboard refreshes in the background while coalescing overlapping refresh work (#1078). Thanks @ptstory!
+
+## 0.29.0 — 2026-05-22
+
+### Added
+- Cost history: show Codex standard and fast spend/token splits in model breakdowns (#1070). Thanks @iam-brain!
+- Alibaba Token Plan: add Bailian token-plan quota tracking via browser or manual cookies (#1098). Thanks @YanxinXue!
+- OpenCode: show workspace renewal dates for OpenCode and OpenCode Go usage windows (#1099). Thanks @Yuxin-Qiao!
+
+### Fixed
+- Localization: improve Simplified Chinese settings and menu translations (#1059). Thanks @narallee!
+- Alibaba Token Plan: reject non-HTTPS endpoint overrides and keep the provider building on Linux (#1104). Thanks @YanxinXue!
+- Settings: avoid crashing when API key or cookie settings contain only a single quote character (#1106). Thanks @m1qaweb!
+- Build scripts: derive the local development signing team ID from the certificate OU before falling back to the CN suffix (#1095).
+- Menu bar: keep retrying display-change recovery when macOS leaves status items detached from the current screen (#1077, #1088).
+- Codex: preserve last successful per-account quota snapshots when later network or DNS refreshes fail (#1097, #1101). Thanks @Yuxin-Qiao!
+
+## 0.28.0 — 2026-05-22
+
+### Added
+- Ollama: add API key authentication as an alternative to browser cookies for validating Cloud access (#1044). Thanks @nandorocker!
+- Azure OpenAI: add deployment-status validation via API key, endpoint, and deployment settings (#1045). Thanks @ZenoRewn!
+- Localizations: add Spanish and Catalan language packs and fill missing localization keys (#1041). Thanks @seifreed!
+- Providers: T3 Chat - add web-session usage tracking, can paste a full browser cURL when cookie-only refreshes hit a 429 challenge (#1091). Thanks @Quicksaver!
+
+### Fixed
+- Menu: restore full-width provider switcher quota bars and refresh them while the menu stays open (#1094). Thanks @bcharleson!
+- Codex: accept the first click in the account switcher inside menu popovers (#1079). Thanks @ptstory!
+- Codex/Claude: terminate PTY child process trees during probe cleanup so wrapper-launched CLI descendants do not linger after sessions finish (#1085). Thanks @mickobizzle!
+- MiniMax: exclude explicitly failed billing-history records from token charts and model/method totals (#1089). Thanks @Yuxin-Qiao!
+- OpenAI: parse Wednesday and Saturday dashboard reset lines so rate-limit reset times are not dropped on those days (#1080). Thanks @m1qaweb!
+- Localization: translate provider-detail labels and empty states when Simplified Chinese is selected (#1051). Thanks @wang93wei!
+- Antigravity: discover OAuth credentials from the bundled extension language server in newer IDE builds so Add Account works again (#1076). Thanks @xARSENICx!
+- Menu bar: suppress redundant icon observer work during refresh cycles, reducing icon update passes without changing rendered state (#1081). Thanks @ptstory!
+- Menu bar: wait for display changes to settle before recovering status items and retry if macOS still leaves the icon detached (#1074). Thanks @yipjunkai!
+- Menu: keep lower action rows stable when Refresh is highlighted or pressed (#1071). Thanks @MadanChaollaPark!
+- Linux CLI: avoid linking JetBrains provider parsing against `libxml2.so.2`, improving compatibility with newer distros that ship libxml2 2.15+ (#1046). Thanks @semsemyonoff!
+- Claude: remove the obsolete peak-hours indicator and setting now that Anthropic no longer applies peak-hour limits (#1023). Thanks @rohitjavvadi!
+- Antigravity: verify cloud model lists that report every quota as full against the user quota endpoint before showing remote OAuth usage (#1063). Thanks @devpras22!
+- Codex: avoid recounting repeated local token snapshots when total usage has not changed (#1062). Thanks @BarryYangi!
+- Antigravity: discover OAuth clients from Antigravity 2 app bundles and binary artifacts so Add Account works again (#1053). Thanks @vyctorbrzezowski!
+- Codex: honor the explicit OAuth credits source and keep automatic credits refresh falling back to CLI when OAuth usage has no credits (#1054). Thanks @soumikbhatta!
+- Codex: show missing-CLI installation guidance in app and CLI errors without dropping cached-refresh context (#1030). Thanks @rohitjavvadi!
+- LLM Proxy: parse fractional-second quota reset timestamps from API responses (#1022). Thanks @rohitjavvadi!
+- ElevenLabs: keep progress text legible in light mode (#1055). Thanks @vyctorbrzezowski!
+- Claude: detect loading-only CLI usage screens and give CLI-only auto refreshes one longer retry instead of stalling or reporting a false missing-session error (#1032, fixes #1031). Thanks @rohitjavvadi!
+- OpenAI: avoid serializing the full dashboard DOM during normal web refreshes, reducing CPU and memory churn while preserving account and plan detection (#1034, fixes #1033). Thanks @jb510!
+- Codex: skip macOS-blocked Codex CLI candidates during automatic binary resolution and let CLI auto mode use OAuth before falling back to `codex app-server` (#1038, fixes #1028). Thanks @m-rokai!
+- Codex: wait for explicit Refresh to finish token-cost history before rebuilding open menus, while keeping automatic/menu-open refreshes non-blocking (#1040). Thanks @zhulijin1991!
+- Antigravity: detect the new 2.0 unsuffixed `language_server` process so local IDE usage probing works again (#1049). Thanks @urbanonymous!
+- Claude: prevent headless CLI usage probes from creating Claude Code URL Handler apps in Launchpad (#1047).
+- Codex: invalidate local cost-history caches from the scanner source hash so parser fixes rebuild stale cached rows automatically (#1042). Thanks @hhh2210!
+- Release: update Homebrew automation so CodexBar releases publish both the CLI formula and app cask from the same workflow.
+
+## 0.27.0 — 2026-05-18
+
+### Added
+- Usage charts: reuse the OpenAI API inline dashboard for local Codex/Claude/Vertex/Bedrock cost history, OpenRouter day/week/month spend, z.ai hourly tokens, and Mistral daily spend.
+- Usage history: let OpenAI Admin API charts and local cost-history scans use a configurable 1–365 day window instead of a fixed 30 days (#83).
+- Grok: add xAI Grok provider support with local identity detection and billing decoding for the Grok CLI integration (#965). Thanks @taibaran!
+- ElevenLabs: add API-key usage tracking for subscription credits, reset time, and voice-slot limits.
+- Deepgram: add API-key usage tracking with project discovery and speech/agent usage breakdowns (#1003, fixes #994). Thanks @czjzpz!
+- GroqCloud: add API-key usage tracking for Enterprise Prometheus metrics with request, token, and cache-hit rate summaries (#993).
+- LLM Proxy: add API-key quota-stats support for aggregate proxy usage, key health, spend, provider breakdowns, and reset windows (#264).
+- Claude: add an Anthropic Admin API source and allow `sk-ant-admin...` keys in Claude token accounts for API spend/token tracking (#966).
+- MiniMax: add web-session billing-history summaries with 30-day token charts and top model/method breakdowns (#1007).
+- OpenCode Go: show the optional Zen pay-as-you-go balance from the workspace dashboard alongside subscription windows (#1006).
+- Kiro: add overage-credit and overage-cost menu bar display modes for exhausted plans (#972). Thanks @raflyazf!
+- CLI: add `codexbar config set-api-key` for safely storing provider API keys from stdin.
+- CLI: add `codexbar config providers`, `enable`, and `disable` for scripting the same provider toggles used by Settings.
+- CLI: let `--all-accounts` and `codexbar serve` export every visible Codex account instead of only the selected account (#1019).
+- Permissions: notify when a provider probe detects a macOS/browser permission prompt waiting for user action (#456).
+- Quota warnings: include the triggering account in notification copy when personal info is visible (#973). Thanks @raflyazf!
+- Website: replace provider-letter tiles with brand logos, add light/dark landing-page themes, and collapse OpenCode/OpenCode Go into one company entry (#989). Thanks @pasangimhana!
+- Providers: route app-owned provider HTTP calls through a shared transport seam for cleaner proxy and test support (#892). Thanks @serezha93!
+
+### Fixed
+- Codex: make local cost-history scans faster and more stable for large session archives while preserving fork attribution, priority pricing, and cached history windows.
+- Codex: collapse near-duplicate session and weekly plan-utilization history windows so charts no longer show repeated tabs (#1027). Thanks @ngutman!
+- Multi-account menus: fetch stacked Codex/token-account usage concurrently so account switchers stay responsive with many accounts (#1011).
+- Codex: keep local cost history attributed to the correct model when long or oversized `turn_context` rows precede model-less token events (#1014, fixes #1013). Thanks @hhh2210!
+- Codex: prefer per-event token usage over divergent total counters when scanning local cost history, preventing large false cost spikes (#968). Thanks @Ifan24!
+- Claude: de-duplicate copied fork/resume transcript history by provider response identity so local cost estimates do not overcount repeated rows (#1002). Thanks @Neverdie-2!
+- Codex: improve multi-account switching with quota-aware ordering, workspace grouping, persisted per-account snapshots, health labels, and auth fingerprint matching.
+- Codex: improve managed account login recovery guidance when macOS blocks or moves a stale `codex` CLI to Trash (#977).
+- Codex: show weekly pace reserve details in the menu even when the caller did not precompute pace data (#1009). Thanks @zhulijin1991!
+- Overview: expose provider chart and storage detail submenus from overview rows instead of requiring a provider-tab switch first.
+- Claude: reset stuck CLI sessions after usage probe timeouts, give slow probes longer to render, and keep stale data visible across transient timeouts.
+- Claude: keep the last successful usage card visible across transient probe timeouts while still clearing stale data after Claude auth changes.
+- Claude: keep Team and Personal Max plan-utilization history separate when the same email appears on multiple Claude accounts (#213).
+- Claude: label Extra usage denominators as the monthly cap so recharge balances are not confused with the maximum spend limit (#975).
+- Claude: wait for the CLI usage panel to finish rendering after the Current session label so slow Claude Code builds do not produce false "Missing Current session" errors (#959).
+- Claude: label five-hour session pace as "Projected empty" so it is not confused with the reset countdown (#960).
+- Claude: show Enterprise spend-limit usage in automatic menu bar metrics and expose the Extra usage metric picker when spend data is available (#964).
+- Grok: retry transient web billing timeouts once and allow slower billing RPCs to finish before showing an error.
+- Grok: fall back to grok.com's billing endpoint when `grok agent stdio` omits the xAI billing method (#984). Thanks @bcharleson!
+- OpenAI: shorten the provider label to "OpenAI" so the menu tab no longer clips.
+- OpenAI: accept numeric-string Admin API cost amounts so usage does not fail when `/v1/organization/costs` returns `"amount": { "value": "12.50" }` (#999, #1000). Thanks @SergeyLavrentev!
+- Menu: keep provider switcher buttons centered by moving quota indicators out of the button layout.
+- Menu: rebuild the selected provider content after switching tabs while an overview chart submenu is open.
+- Menu: keep the persistent Refresh row at a fixed height while highlighted or pressed so nearby items no longer jump (#1001).
+- Menu bar: avoid re-reading provider credentials, Codex account state, Claude terminal probe text, and storage footprints on hot menu paths, reducing idle CPU while providers are still loading.
+- Menu bar: skip unchanged split-provider icon redraws and avoid an extra animation-state scan during blink ticks.
+- Menu bar: recover visible status items after the display hosting the menu bar item is unplugged (#998, fixes #997). Thanks @Llldmiao!
+- Menu bar: recreate status items on startup when macOS reports them visible but never attaches a menu bar button/window (#988).
+- MiniMax: show Coding Plan model-remains quotas as used/limit cards and include weekly text-generation quota windows (#970). Thanks @Yuxin-Qiao!
+- Ollama: let automatic session import fall back from Chrome to Safari, Comet, and the rest of the browser import order when Chrome has no Ollama session (#962).
+- Kimi K2: label the legacy provider as unofficial and remove links that presented the legacy endpoint as an official Kimi account surface (#967, fixes #473). Thanks @mturac!
+- CLI: use explicit provider HTTP timeouts so blocked network connections fail instead of leaving usage commands stuck for days (#1005, fixes #1004). Thanks @msmolkin!
+- CLI: reject non-loopback `Host` headers in `codexbar serve` before serving local usage and cost metadata (#995). Thanks @rohitjavvadi!
+- Packaging: skip slow widget App Intents metadata during dev restarts and preserve the previous app bundle if required metadata generation times out.
+- Localization: fall back to English when a bundled localized string is blank instead of rendering empty menu/settings text (#952). Thanks @xiaoqianWX!
+- Settings: localize the provider storage usage toggle in the Advanced pane (#985, fixes #971). Thanks @tanish19078!
+
+## 0.26.1 — 2026-05-15
+
+### Added
+- OpenAI API: show Admin API usage inline with Today/7d/30d summaries, a 30-day spend graph, and an interactive detail chart for daily spend, tokens, and requests.
+- CLI: add `codexbar serve` for localhost JSON access to usage and cost endpoints (#957). Thanks @ThiagoCAltoe!
+
+### Fixed
+- OpenCode Go: block cross-host redirects when fetching usage so imported cookies cannot follow external redirect targets (#969). Thanks @pavbar!
+- Codex: keep background `/status` probes out of Codex Desktop history by using isolated non-persistent CLI storage (#953).
+- Menu: stabilize the Cost submenu by using a native menu item and deferring open-menu rebuilds while tracking (#954). Thanks @getogrand!
+- Localization: add Brazilian Portuguese quota-warning settings strings (#958). Thanks @ThiagoCAltoe!
+
+## 0.26.0 — 2026-05-15
+
+### Added
+- Codex: add tiered long-context and Fast/Priority pricing to local cost history using local app-server priority traces (#917). Thanks @iam-brain!
+- Kiro: show account/auth details, plan labels, credit and bonus-credit balances, overage state, and Kiro-specific menu bar display options (#933, fixes #934). Thanks @solnikhil!
+- Antigravity: add Google OAuth token-account switching with selected-account refresh persistence (#937, fixes #936). Thanks @hhh2210!
+- OpenRouter: show daily and weekly API key spend from `/api/v1/key` in the menu (#685). Thanks @ThiagoCAltoe!
+- Display: add a setting to hide quota-warning tick marks on usage bars while keeping quota warning notifications active (#918, fixes #916). Thanks @ThiagoCAltoe!
+- Menu: add left/right arrow keyboard navigation for the merged provider switcher (#266).
+- Menu: add an opt-in setting for provider changelog links, starting with Codex, Claude Code, and Gemini CLI (#929, fixes #660). Thanks @ThiagoCAltoe!
+- AWS Bedrock: add Cost Explorer usage and monthly budget tracking (#897). Thanks @afalk42!
+- Kilo: add organization selection, scoped organization fetches, and stacked Kilo usage cards (#920). Thanks @NoeFabris!
+- Moonshot / Kimi API: add API-key balance tracking, CLI support, docs, and menu bar balance copy (#899). Thanks @giuseppebisemi!
+- z.ai: add an hourly per-model token usage chart in the menu (#913). Thanks @n1majne3!
+- Localization: add Brazilian Portuguese translations (#902). Thanks @ThiagoCAltoe!
+- Localization: add Simplified Chinese translations for Claude peak-hour labels (#921). Thanks @whtis!
+
+### Fixed
+- Codex: show authenticated plan/account rows as "Limits not available" instead of a red no-rate-limit error when Codex reports profile data but no rate-limit windows yet.
+- Overview: hide provider rows that only contain an error, and avoid showing a one-item Codex System Account submenu.
+- Menu: disable implicit provider-switcher layer animations and reuse the deferred rebuild path so open menus stay stable under pointer movement (#950).
+- Menu: defer account-switcher menu rebuilds so switching Codex or token accounts does not send the open menu into a flicker loop (#946, fixes #944). Thanks @kubahasek!
+- Menu: avoid rebuilding visible menus during background open-menu refreshes so hover submenus stay responsive (#923, fixes #909). Thanks @AmrMohamad!
+- Codex: scope local cost history to the selected managed account's `CODEX_HOME` and label cost cards as local-log estimates (#910).
+- Cost history: label local log totals as API-rate estimates in menu cards, charts, and CLI output (#926). Thanks @yashiels!
+- Cursor: open Add Account in the user's browser and import the resulting browser session instead of trapping login in an embedded web view (#922).
+- Claude: handle Enterprise and organization spend-limit usage across OAuth/web accounts, including null session quota windows, inline spend-limit usage, `extra_usage`-only responses, and token-account Org ID support (#925, #941, fixes #940). Thanks @clintandrewhall!
+- OpenCode Go: let automatic cookie import scan all supported browser sources instead of Chrome only (#665).
+- Copilot: preserve over-quota usage so paid overage can show above 100% instead of clamping to exhausted (#818).
+- Codex: pause background CLI launches after macOS blocks or quarantines `codex`, avoiding repeated "Malware Blocked" prompts (#942).
+- Claude: clarify that local cost/token estimates include cache read/write tokens and may differ from Claude Code `/status` (#781, #787).
+- Updates: make the restart/apply-update menu action use Sparkle's prepared install callback on the first click (#947). Thanks @velvet-shark!
+- Multi-account menus: keep stacked token-account cards capped to current accounts and ignore stale snapshots from removed accounts (#949).
+- Droid: accept pasted Factory `Authorization: Bearer` headers and bearer tokens for manual sessions when cookies alone are insufficient (#914).
+- Menu bar: detect when macOS Tahoe hides CodexBar behind the new Allow in Menu Bar setting and show recovery guidance (#945, fixes #890). Thanks @pdurlej!
+- CLI: route Claude token-account `--source cli` reads through the selected OAuth/session credential so `--all-accounts` no longer relabels ambient CLI usage (#403).
+- Codex: route menu account refreshes through the resolved live-vs-managed account source so matched accounts keep using the stable `CODEX_HOME` (#932, fixes #931). Thanks @ThiagoCAltoe!
+- Gemini: refresh OAuth credentials when the CLI has a refresh token but no cached access token instead of reporting "not logged in" after authentication (#915).
+- Gemini: label OAuth-backed API fetches as `oauth-api` instead of plain `api` (#930). Thanks @ThiagoCAltoe!
+- Codex: keep session and weekly quota-warning marker thresholds independent so usage bars do not duplicate marker lines (#938, fixes #927). Thanks @iam-brain!
+- Codex: coalesce historical pace reset timestamps into 5-minute buckets so dashboard and live reset jitter do not duplicate weekly history windows (#901). Thanks @zhulijin1991!
+- Menu: middle-truncate long account emails in Codex account controls and keep the Codex account switcher visible during merged-menu refreshes with transient account snapshots.
+- Settings: apply the selected app language from packaged SwiftPM resources instead of falling back to English when the `.lproj` directory casing differs (#908).
+- Settings: let stale managed Codex account records be removed even when their stored home path is outside CodexBar's managed-home directory, and keep CLI known-owner tests from writing fixtures into the live app store.
+- ChatGPT credits: restrict purchase links to real HTTPS `chatgpt.com` settings/usage/billing/credits paths and drop query/fragment data (#903). Thanks @ThiagoCAltoe!
+- z.ai: show the MCP quota bucket as monthly instead of a misleading 1-minute window (#904). Thanks @ThiagoCAltoe!
+- Kimi: rebalance provider icon alignment within its viewBox (#912). Thanks @giuseppebisemi!
+- Release: include macOS platform and architecture in notarized app and dSYM asset names (#164).
+- Upstream tooling: resolve remote default branches and tolerate missing upstream remotes in review scripts (#906).
+
+## 0.25.1 — 2026-05-11
+
+### Fixed
+- Settings: avoid packaged-app crashes from SwiftPM localization bundle lookup when opening Settings or About (#896, fixes #891). Thanks @lederniermagicien!
+- CLI: include a VERSION file in standalone release archives so `--version` reports the release tag outside the app bundle (#898). Thanks @ThiagoCAltoe!
+- Pi: rebuild stale session cost caches after cache-version migrations so refreshed cost history reflects current scanner data.
+- Keychain cache: reduce repeated development prompt churn by trusting the bundled helper when writing CodexBar-owned cache items (#888).
+
+## 0.25 — 2026-05-10
+
+### Highlights
+- Localization: add Simplified Chinese app strings and an in-app language selector (#819). Thanks @markhome1!
+- New providers: Manus, MiMo, Qwen, Doubao, Command Code, StepFun, Crof, Venice, and OpenAI API balance support.
+- MiniMax: add multi-service quota cards for text, speech, image, video, and music coding-plan usage (#605). Thanks @XWind18!
+- Notifications: add opt-in quota warning notifications, warning markers, and provider-level thresholds for session and weekly quota windows (#852). Thanks @Alekstodo!
+- Codex: add stacked multi-account switchers and show official Pro 5x/Pro 20x plan labels (#869, #882). Thanks @ajmccall and @xiaoqianWX!
+- Cost history: use live models.dev pricing metadata, preserve tiered pricing boundaries, and keep large Codex/Claude log scans incremental (#863, #884, #886). Thanks @iam-brain!
+- Menu bar: fix hidden/stale status items, keep manual refreshes open, and improve balance-style menu bar text for providers without useful quota percentages (#845, #853, #861). Thanks @OlimjonovOtabek and @willytop8!
+- Accessibility: add VoiceOver labels for status icons, menu rows, provider switcher buttons, and usage charts (#860, fixes #859). Thanks @WadydX!
+
+### Providers & Usage
+- Manus: add browser-cookie provider support for credit balance, monthly credits, and daily refresh tracking (#700). Thanks @hhh2210!
+- MiMo: add browser-cookie provider support for Xiaomi token-plan usage, plan labels, balance fallback, CLI, widget, and docs (#651). Thanks @debpramanik!
+- Qwen and Doubao: add API-key provider support for Alibaba Qwen and Volcengine Ark request-limit tracking (#498). Thanks @LeoLin990405!
+- MiniMax: add multi-service quota cards for text, speech, image, video, and music coding-plan usage (#605). Thanks @XWind18!
+- Antigravity: add OAuth-backed remote usage fetching so quotas can refresh even when the IDE is closed (#635). Thanks @abnormal749!
+- Venice: add API-key balance provider support with DIEM/USD balance display and token-account CLI wiring (#865). Thanks @clawSean!
+- Crof: add API-key provider support with request quota and credit balance tracking (#872). Thanks @baanish!
+- OpenAI API: add optional platform credit-balance tracking from the billing credit-grants endpoint (#877).
+- Command Code: add browser-cookie provider support for monthly USD billing credits (#857). Thanks @sixhobbits!
+- StepFun: add username/password or Oasis-Token provider support for Step Plan rate-limit tracking (#815). Thanks @tevenfeng!
+- Factory/Droid: add token-rate-limit billing windows, Core fallback buckets, and extra usage balance display (#878). Thanks @dantemoon1!
+- OpenRouter, Mistral, and Kimi K2: show balance/spend metrics in menu bar text when quota percentage is not useful (#853). Thanks @willytop8!
+- Usage pace: show session-level pace indicators for Codex and Claude 5-hour windows, and compute pace for any explicit reset window instead of a provider allowlist (#355, #875). Thanks @johnlarkin1 and @ViperThanks!
+- Cost history: add a models.dev pricing metadata parser/cache pipeline and prefer cached models.dev pricing for Codex and Claude before bundled fallback tables (#863, #884). Thanks @iam-brain!
+- Browser cookies: bump SweetCookieKit to 0.4.1 for Comet and Yandex browser discovery, Safari profile cookie stores, and per-browser Chromium Safe Storage keys.
+
+### Menu & Settings
+- Codex: add a stacked multi-account menu layout for account switchers (#869). Thanks @ajmccall!
+- Notifications: add opt-in quota warning notifications, warning markers, and provider-level thresholds for session and weekly quota windows (#852). Thanks @Alekstodo!
+- Accessibility: add VoiceOver labels for status icons, menu rows, provider switcher buttons, and usage charts (#860, fixes #859). Thanks @WadydX!
+- Menu bar: keep status items visible on launch by avoiding macOS autosaved hidden menu-extra state from v0.24 (#861).
+- Menu bar: remove stale split provider status items instead of hiding them, avoiding leftover second-icon slots on macOS 26.4.
+- Menu: keep the status menu open when manually refreshing usage from the menu (#845). Thanks @OlimjonovOtabek!
+- Menu: route provider switcher tab clicks through the parent view's mouse tracking so a sub-provider tab still responds after switching back from the Overview tab (#867). Thanks @Karl-Dai!
+- Menu: keep long Codex account labels from widening the status menu when switching to the Codex tab.
+- Menu: keep Cost and Subscription Utilization submenus stable by deferring parent card rebuilds while hosted submenus are open (#862).
+- Settings: avoid a crash when opening the display overview provider picker.
+
+### Fixes
+- Startup: avoid blocking menu-bar creation on synchronous defaults migration/default seeding when macOS preferences services stall.
+- Codex: honor the legacy `openAIWebAccess` defaults key when importing OpenAI web extras preferences, so existing terminal workarounds no longer get ignored on launch (#794).
+- Codex: restrict OAuth auto fallback to missing/invalid auth so transient API/decode errors do not spawn `codex app-server` and burn tokens (#876, fixes #874). Thanks @ViperThanks!
+- Codex: show official Pro 5x/Pro 20x plan labels instead of Pro Lite/Pro in menu and CLI output (#882). Thanks @xiaoqianWX!
+- Cost history: keep manual refreshes on the incremental scanner cache and drain per-line JSON parse allocations so large Codex/Claude histories do not trigger full local log rescans and CPU/memory spikes.
+- Cost history: preserve cached models.dev pricing when an upstream catalog only changes a pinned snapshot suffix for the same model family (#883). Thanks @iam-brain!
+- Cost history: preserve per-request tiered pricing boundaries when aggregating Claude/Pi daily reports (#886). Thanks @iam-brain!
+- Keychain cache: trust the bundled CodexBarCLI helper when writing CodexBar-owned cache items, reducing repeated "CodexBar Cache" prompts from CLI usage (#679). Thanks @QuarkAssistant!
+- Locale: keep relative timestamps in hardcoded-English UI labels consistently English on non-English macOS systems (#868, fixes #866). Thanks @Karl-Dai!
+- Droid: send the bearer JWT subject as the usage `userId` when Factory omits `userProfile.id`, avoiding false login failures (#626). Thanks @CrystalChen1017!
+- Droid: fall back to token/allowance math when the Factory API reports a zero ratio despite non-zero usage (#864). Thanks @proxynico!
+- Alibaba: point the International Coding Plan dashboard link at the current `coding_plan` route and clarify unsupported API-key quota errors (#612).
+- Claude: allow web/sessionKey token accounts to specify `organizationId` so linked Anthropic emails can target the intended org (#848).
+- DeepSeek: show a positive CNY balance when the API also returns an empty USD balance (#873).
+- Vertex AI: detect service-account ADC files from `GOOGLE_APPLICATION_CREDENTIALS` and use `gcloud` to fetch access tokens (#871).
+- Gemini: retry direct API requests with curl when URLSession times out on hosts where curl succeeds (#826).
+- Gemini: locate Homebrew-installed CLI bundles and parse bundled OAuth client constants so token refresh works with newer `gemini-cli` installs (#695).
+- OpenRouter: keep the menu bar rendering the usage meter instead of falling back to the provider logo when no key limit is configured (#854). Thanks @willytop8!
+- DeepSeek: show balance as plain text instead of a misleading quota-style progress bar (#856). Thanks @jb381!
+- Augment: report the real 1-minute keepalive check/min-refresh intervals in startup logs and docs (#434). Thanks @guglielmofonda!
+- Website: refresh codex.bar with the current canonical domain, structured background, and updated social preview.
+
+## 0.24 — 2026-05-06
+
+### Providers & Usage
+- Windsurf: add provider support with web-session usage fetching and local SQLite-cache fallback (#583). Thanks @Coooolfan!
+- Codebuff: add provider support with credit balance tracking, weekly rate-limit usage, API-token settings, and `codebuff login` credential import (#837). Thanks @anandghegde!
+- Copilot: add multi-account support with GitHub OAuth sign-in, account switching, and per-account usage cards (#637). Thanks @ajmccall!
+- DeepSeek: add provider support with token-account balance tracking, paid vs. granted credit breakdown, and CLI support (#811). Thanks @willytop8!
+- Storage: add an opt-in menu view for local provider storage usage with background scans and copyable path breakdowns (#829). Thanks @fatiheminoge!
+- OpenRouter and DeepSeek: show remaining account balances in the menu bar, while preserving OpenRouter's API-key limit metric when explicitly selected (#832). Thanks @giuseppebisemi!
+- Claude: add a peak-hours menu-card indicator with countdowns and a provider setting to hide it (#611). Thanks @hello-amed!
+- Cost history: show per-model cost details as a compact vertical list when hovering daily bars (#513). Thanks @iam-brain!
+- Copilot: support GitHub Enterprise hosts for the device-flow login and usage API paths (#827). Thanks @ramzesenok!
+- Alibaba: clarify China-region API-key failures when the console endpoint requires a browser session (#628). Thanks @XWind18!
+
+### Fixes
+- Codex: time out hung `codex app-server` RPC reads and cap loading animation runtime so stalled refreshes no longer keep the menu bar redrawing indefinitely (#842, #844). Thanks @hyspacex!
+- Codex: make OpenAI dashboard refreshes handle non-English pages, lazy-loaded credits history, timeout retries, and unrelated Skillusage rows (#825). Thanks @xiaoqianWX!
+- Cursor: show Enterprise/Team usage from personal caps and shared pools instead of reporting 100% remaining (#813). Thanks @fcamus00!
+- Codex: keep same-workspace managed accounts distinct by matching workspace identity with email, so different OpenAI users in one workspace no longer overwrite each other (#796). Thanks @leezhuuuuu!
+- Claude: enable Claude and switch to OAuth after a successful login, clear stale selected-provider state when Claude is disabled, and tolerate OAuth payloads that omit the five-hour window (#816, #726). Thanks @pdurlej and @Brandawg93!
+- Claude: recognize OAuth `subscriptionType` before `rateLimitTier` so Pro accounts with generic Claude Code tiers
+  open the subscription usage dashboard correctly (#836, fixes #824). Thanks @shixy96!
+- Usage: preserve known reset countdowns when a refresh returns current usage without reset metadata (#427). Thanks @Whoaa512!
+- Menu: refresh open usage cards after live data changes so the “Updated” timestamp advances after manual or cadence refreshes (#715). Thanks @cooper-matt!
+- Menu: make the global open-menu shortcut behave as a true toggle when the menu is already open, avoiding queued reopens after repeated key presses (#218).
+- Menu bar: preserve existing status items and assign stable autosave names so provider icon positions survive provider toggles (#538). Thanks @hxy91819!
+- Settings: make the Preferences window 10% wider and taller so dense provider/settings panes have more breathing room.
+- CLI releases: publish macOS arm64 and x86_64 CLI tarballs alongside Linux artifacts, with release-workflow smoke tests and docs (#457, #839). Thanks @androidshu and @mondary!
+- CLI: query only enabled providers by default when three or more providers are enabled instead of expanding to every registered provider (#830). Thanks @lhoBas!
+- CLI: read MiniMax coding-plan tokens from `MINIMAX_CODING_API_KEY`, accept Alibaba Qwen/DashScope API-key aliases, and avoid duplicate generic JSON error rows after provider failures.
+- CLI discovery: prefer known install paths before interactive shell probing so common Claude installs no longer run shell init hooks during binary detection (#775).
+- CLI lookup: drain login-shell probe output and terminate spawned process groups so interactive shell helpers cannot leak after path detection (#822, fixes #821). Thanks @LPFchan!
+- OpenCode Go: open the workspace-specific usage dashboard when a workspace ID is configured (#667). Thanks @RizaSatya!
+- Augment: use the API-provided credits limit when available instead of reconstructing the limit from consumed plus remaining credits (#338). Thanks @bcharleson!
+- MiniMax: ignore login strings embedded in scripts when checking web-session pages for signed-out state (#508). Thanks @qipihen!
+- Accounts: refresh the selected provider data and open menu after switching token accounts, even while a menu-open refresh is running (#799, fixes #798). Thanks @Zeko369!
+- Codex: prefer session turn-context model metadata when calculating local cost history so GPT-5.4 sessions are not bucketed as GPT-5 (#620). Thanks @betive37!
+- Codex: stop falling back from app-server RPC to bare CLI TUI during automatic usage refreshes, preventing unexpected OpenAI auth browser tabs.
+- Menu/keychain: block delayed test-time menu mutations after teardown and enforce no-UI keychain reads more reliably (#381). Thanks @artuskg!
+- Menu bar: fix invisible status item icon on macOS 26.4 by removing remaining RenderBox-triggering SwiftUI compositing modifiers from `UsageProgressBar` (rewritten as a single Canvas) and eliminating ~28 redundant Keychain reads on every launch after the first-run migration (#805). Thanks @willytop8!
+
+## 0.23 — 2026-04-26
+
+### Highlights
+- Mistral: add provider support with monthly spend tracking, browser-cookie import, manual cookies, and CLI/token-account support (#607). Thanks @welcoMattic!
+- Claude: show Designs and Daily Routines usage bars from live Claude OAuth/Web quota data, and restore the Web-mode Sonnet bar (#740). Thanks @AISupplyGuy!
+- Cursor: add an Extra usage menu bar metric for on-demand budgets (#789). Thanks @huiye98!
+- Usage: add an opt-in confetti celebration when weekly limits reset after active use (#785). Thanks @zats!
+- Codex: add GPT-5.5 and GPT-5.5 Pro pricing so local cost scanning recognizes the new models.
+- Copilot: show a clearer GitHub Device Flow hint in Settings when the copied device code needs to be pasted into GitHub (#369). Thanks @amoranio!
+
+### Fixes
+- Droid: preserve Factory session fallbacks, use the current usage endpoint, and clarify browser-login messaging (#792). Thanks @JosephDoUrden for the original stale-session fix!
+- Widgets: package App Intents metadata for the widget extension and use configuration defaults so configurable widgets load correctly in WidgetKit (#783). Thanks @ngutman and @vincentyangch!
+- Menu: keep merged-menu cards, switcher rows, wrapped status text, and hosted chart submenus aligned with the real AppKit menu width so menus no longer grow oversized or show narrower chart submenus after width changes. Thanks @ngutman!
+- Codex: ignore invalid zero-minute subscription history so the utilization submenu no longer shows duplicate Session tabs.
+- CLI: report the app bundle version correctly when the bundled helper is launched through a symlink.
+- Codex/Claude: clean up cached CLI status probes during app shutdown so `codex -s read-only` workers are not orphaned after restart.
+
+## 0.22 — 2026-04-21
+
+### Highlights
+- Codex: restore OpenAI web dashboard fetching on the new analytics route and tighten hidden WebView reuse/expiry.
+- Synthetic: parse live quota payloads for five-hour, weekly, and search limits, including continuous reset/regeneration details (#732). Thanks @baanish!
+- Antigravity: restore account/quota probing across newer localhost endpoint/token layouts and retry paths (#727). Thanks @icey-zhang!
+- Menu: add standard shortcuts for Refresh, Settings, and Quit while the status menu is open (#737). Thanks @anirudhvee!
+- Widgets: migrate app-group sharing to the Team-ID-prefixed container and carry widget state across the move (#701). Thanks @ngutman!
+
+### Providers & Usage
+- Synthetic: parse live five-hour, weekly, and search quota payloads, including continuous reset/regeneration details (#732). Thanks @baanish!
+- Antigravity: restore localhost probing with async TLS challenge handling, extension-token fallback, and best-effort port selection (#727). Thanks @icey-zhang!
+- Gemini: discover OAuth config in fnm/Homebrew/bundled CLI layouts so expired-token refresh keeps working (#723). Thanks @Leechael!
+- Copilot: open the complete device-login verification URL when available so the browser flow carries the user code (#739). Thanks @skhe!
+- Alibaba: update the China mainland Coding Plan endpoint and browser-cookie domain while keeping older domains as fallbacks (#712). Thanks @hezhongtang!
+- Codex: restore OpenAI web dashboard fetching on the new analytics route and tighten hidden WebView reuse/expiry. @ratulsarna
+
+### Menu & Settings
+- Menu: show and handle standard shortcuts for Refresh (⌘R), Settings (⌘,), and Quit (⌘Q) while the status menu is open (#737). Thanks @anirudhvee!
+- Settings: fix provider-sidebar clipping on macOS Tahoe and resize the Preferences window when switching tabs (#580). Thanks @chadneal!
+
+### Fixes
+- Keychain cache: preserve cached credentials when macOS temporarily denies keychain UI after wake, avoiding repeated prompts (#594). Thanks @josepe98!
+
+## 0.21 — 2026-04-18
+
 ### Highlights
+- Abacus AI: add a new provider for ChatLLM and RouteLLM credit tracking with browser-cookie import, manual-cookie support, and monthly pace rendering. Thanks @ChrisGVE!
+- Codex: recognize the new Pro $100 plan in OAuth, OpenAI web, menu, and CLI rendering, and preserve CLI fallback when partial OAuth payloads lose the 5-hour session lane (#691, #709). Thanks @ImLukeF!
+- Codex: make OpenAI web extras opt-in for fresh installs, preserve working legacy setups on upgrade, add an OpenAI web battery-saver toggle, and keep account-scoped dashboard state aligned during refreshes and account switches (#529). Thanks @cbrane!
+- Codex: fix local cost scanner overcounting and cross-day undercounting across forked sessions, cold-cache refreshes, and sessions-root changes (#698). Thanks @xx205!
+- z.ai: preserve weekly and 5-hour token quotas together, surface the 5-hour lane correctly across the menu/menu bar, and add regression coverage (#662). Thanks to @takumi3488 for the original fix and investigation.
+- Cursor: fix a crash in the usage fetch path and add regression coverage (#663). Thanks @anirudhvee for the report and validation!
+- Antigravity: restore account and quota probing across newer localhost endpoint/token layouts and API-level retry failures (#693, fixes #692). Thanks @anirudhvee!
+- Menu bar: fix missing icons on affected macOS 26 systems by avoiding RenderBox-triggering SwiftUI effects (#677). Thanks @andrzejchm!
+- Battery / refresh: cut menu redraw churn, skip background work for unavailable providers, and reuse cached OpenAI web views more efficiently (#708).
+- Claude: add Opus 4.7 pricing so local cost scanning and cost breakdowns recognize the new model. Thanks @knivram!
+- Codex: add Microsoft Edge as a browser-cookie import option for the Codex provider while preserving the contributor-branch workflow from the original PR (#694). Thanks @Astro-Han!
+
+### Providers & Usage
+- Abacus AI: add provider support for ChatLLM and RouteLLM monthly compute-credit tracking with cookie import, manual cookie headers, timeout/browser-detection threading, optional billing fallback, and hardened cached-session retry behavior. Thanks @ChrisGVE!
+- Codex: render the new Pro $100 plan consistently across OAuth, OpenAI web, menu, and CLI surfaces, tolerate newer Codex OAuth payload variants like `prolite`, and only fall back to the CLI in auto mode when OAuth decode damage actually drops the session lane (#691, #709).
+- Codex: make OpenAI web extras opt-in by default, preserve legacy implicit-auto cookie setups during upgrade inference, add battery-saver gating for non-forced dashboard refreshes, and preserve provider/dashboard state for enabled providers that are temporarily unavailable.
+- Cost: tighten the local Codex cost scanner around fork inheritance, cold-cache discovery, incremental parsing, and sessions-root changes so replayed sessions no longer overcount or slip usage across day boundaries (#698). Thanks @xx205!
+- z.ai: preserve both weekly and 5-hour token quotas, keep the existing 2-limit behavior unchanged, and render the 5-hour quota as a tertiary row in provider snapshots and CLI/menu cards (#662). Credit to @takumi3488 for the original fix and investigation.
+- Cursor: fix the usage fetch path so failed or cancelled requests no longer crash, and add Linux build and regression test coverage fixes (#663).
+- Antigravity: try both language-server and extension-server endpoint/token combinations, retry after API-level errors, scope insecure localhost trust handling to loopback hosts, and restore local quota/account probing on newer Antigravity builds (#693, fixes #692). Thanks @anirudhvee!
+- Antigravity: prefer `userTier.name` over generic plan info when rendering the account plan so Google AI Ultra and similar tiers show their real subscription name, while still falling back cleanly when the tier label is absent or blank (#303). Thanks @zacklavin11!
+- Ollama: recognize `__Secure-session` cookies during manual cookie entry and browser-cookie import so authenticated usage fetching continues to work with the newer cookie name (#707). Thanks @anirudhvee!
+- OpenCode: enable weekly pace visualization for the app and CLI so weekly bars show reserve percentage, expected-usage markers, and "Lasts until reset" details like Codex and Claude (#639). Thanks @Zachary!
+- Refresh pipeline: skip background work for unavailable providers, clear stale cached state, and show explicit unavailable messages (#708).
+- Codex: support Microsoft Edge in browser-cookie import for the Codex provider while keeping the contributor branch untouched in the superseding integration path (#694). Thanks @Astro-Han!
+- OpenCode / OpenCode Go: treat serialized `_server` auth/account-context failures as invalid credentials so cached browser cookies are cleared and retried instead of surfacing a misleading HTTP 500.
+- OpenAI web: keep cached WebViews across same-account refreshes and clean them up only when accounts or providers go stale (#708).
+- Claude: add Opus 4.7 pricing so local cost usage and breakdowns price the new model correctly. Thanks @knivram!
+- Claude: broaden CLI binary lookup to native installer paths (#731). Thanks @dingtang2008!
+
+### Menu & Settings
+- Menu bar: fix missing icons on affected macOS 26 systems by replacing RenderBox-triggering material/offscreen SwiftUI effects in the provider sidebar and highlighted progress bar (#677). Thanks @andrzejchm!
+- z.ai: fix menu bar selection when both weekly and 5-hour quotas are present (#662).
+- Menu bar: avoid redundant merged-icon redraws and make hosted chart submenus load lazily without losing provider context (#708).
+- Merged menu: when Overview is selected, keep the merged menu bar icon aligned with the first Overview provider in configured order, even while that provider is still loading (#724). Thanks @anirudhvee!
+- Codex: add an OpenAI web battery-saver toggle, keep manual refresh available when battery saver is on, and hide OpenAI web submenus when web extras are disabled.
+
+### Development & Tooling
+- CLI / Debug: add user-facing browser-cookie cache clearing, including provider-scoped CLI clearing that removes managed Codex account cookie caches (#592, fixes #591). Thanks @coygeek!
+- Diagnostics: add lightweight battery instrumentation for menu updates and refresh work (#708).
+- Build script: make CodexBar-owned ad-hoc keychain cleanup opt-in with `--clear-adhoc-keychain`, and extend the explicit reset path to clear both `com.steipete.CodexBar` and `com.steipete.codexbar.cache`. Thanks @magnaprog!
+
+## 0.20 — 2026-04-07
+
+### Highlights
+- Codex: switch between system accounts/profiles without manually logging out and back in. @ratulsarna
+- Add Perplexity provider support with recurring, bonus, and purchased-credit tracking, Pro/Max plan detection, browser-cookie auto-import, and manual-cookie fallback (#449). Thanks @BeelixGit!
+- Add OpenCode Go as a separate provider with 5-hour, weekly, and monthly web usage tracking, widget integration, and browser-cookie support.
+- Claude: fix token and cost inflation caused by cross-file double counting of subagent JSONL logs, fix streaming chunk deduplication, and add `claude-sonnet-4-6` pricing. Thanks @enzonaute for the investigation!
+- Cost history: include supported pi session usage in Codex/Claude provider history so provider charts reflect those local runs (#653). Thanks @ngutman!
+
+### Providers & Usage
+- Perplexity: add recurring, bonus, and purchased-credit tracking; plan detection for Pro/Max; browser-cookie auto-import; and manual-cookie fallback (#449). Thanks @BeelixGit!
+- OpenCode Go: add a dedicated provider, parse live authenticated workspace Go usage from the web app, keep monthly optional and honor workspace env overrides.
+- Codex: add workspace attribution for account labels and same-email multi-workspace accounts.
+- Codex: reconcile live-system and managed accounts by canonical identity, preserve account-scoped usage/history/dashboard state, allow OAuth CLI fallback, and tighten OpenAI web ownership gating so quota and credits only attach to the matching account. Thanks @monterrr and @Rag30 for the initial effort and ideas!
+- Codex: normalize weekly-only rate limits across OAuth and CLI/RPC so free-plan accounts render as Weekly instead of a fake Session, preserve unknown single-window payloads in the primary lane, hide the empty Session lane in widgets, and accept weekly-only Codex CLI `/status`/RPC data without failing. @ratulsarna
+- Codex: refactor the provider end to end into clearer components and better division of responsibilities.
+- OpenCode: preserve product separation between Zen and Go, improve null/unsupported usage handling, and harden cookie/domain behavior for authenticated web fetches.
+- Cost history: merge supported pi session usage into Codex/Claude provider history (#653). Thanks @ngutman!
+
+### Menu & Settings
+- Codex: add UI for switching the system-level Codex account and promoting a managed account into the live system slot.
+- Codex: hide display-only OpenAI web extras in widgets and fix buy-credits / credits-only presentation regressions.
+- Claude: enable “Avoid Keychain prompts” by default, remove the experimental label, and preserve user-action cooldown clearing plus startup bootstrap when Security.framework fallback is still needed.
+- Fix alignment of menu chart hover coordinates on macOS. Thanks @cuidong233!
+
+## 0.19.0 — 2026-03-23
+### Highlights
+- Add Alibaba Coding Plan provider with region-aware quota fetching, widget integration, and browser-cookie import defaults (#574).
+- Align Cursor usage with the dashboard's Total/Auto/API lanes. (#587). Thanks @Rag30!
+- Add subscription utilization history chart to the menu with DST-safe data point identification (#589). Thanks @maxceem!
+- Refactor the Claude provider end to end into clearer, better-tested components while preserving behavior (#494). @ratulsarna
+- Add reset time display for Codex code review limits (#581). Thanks @Q1CHENL!
+- Add per-model token counts to cost history (#546). Thanks @iam-brain!
+- Fix Antigravity model selection to use stable model-family matching for Claude, Gemini Pro, and Gemini Flash, and preserve fallback lane visibility in the menu bar and icon (#590). Thanks @skainguyen1412!
+- Add GPT-5.4 mini and nano pricing (#561). Thanks @iam-brain!
+
+### Providers & Usage
+- Alibaba: add Coding Plan provider support with region-aware web/API quota fetching, widget integration, and browser-cookie import defaults (#574).
+- Cursor: trust dashboard percent fields for Total/Auto/API usage, preserve on-demand remaining fallback views, and keep scanning imported browser-cookie candidates until a working Cursor session is found (#587, supersedes #579). Thanks @Rag30!
+- Claude: refactor the provider end to end into clearer components, with baseline docs and expanded tests to lock down behavior (#494).
+- Codex: show reset times for code review limits, including Core review reset parsing support (#581). Thanks @Q1CHENL!
+- Cost history: add per-model token counts so token usage is broken out by model (#546). Thanks @iam-brain!
+- Antigravity: replace label-order guessing with stable model-family selection for Claude, Gemini Pro, and Gemini Flash; fix mapping for Claude thinking models and placeholder model IDs; preserve fallback lane visibility in the menu bar and icon when only fallback lanes exist (#590). Thanks @skainguyen1412!
+- Kimi: tolerate API responses without `resetTime` so usage decoding no longer fails on sparse payloads.
+- Codex: add GPT-5.4 mini and nano pricing (#561). Thanks @iam-brain!
+
+### Menu & Settings
+- Menu: add subscription utilization history chart with DST-safe chart point identifiers and per-provider plan utilization tracking (#589). Thanks @maxceem!
+- Menu bar: in Both display mode, fall back to percent when pace data is unavailable so text stays visible for providers without pace metrics (#527). Thanks @Astro-Han!
+- Settings: persist the resolved refresh cadence default to `UserDefaults` on first launch and repair invalid stored values so the setting stays normalized across relaunches (#519). Thanks @Astro-Han!
+- Menu: wrap long status blurbs and preserve wrapped titles for multiline entries (#543). Thanks @zkforge!
+
+## 0.18.0 — 2026-03-15
+### Highlights
+- Add Kilo provider support with API/CLI source modes, widget integration, and pass/credit handling (#454). Built on work by @coreh.
+- Add Ollama provider, including token-account support in Settings and CLI (#380). Thanks @CryptoSageSnr!
+- Add OpenRouter provider for credit-based usage tracking (#396). Thanks @chountalas!
+- Add Codex historical pace with risk forecasting, backfill, and zero-usage-day handling (#482, supersedes #438). Thanks @tristanmanchester!
 - Add a merged-menu Overview tab with configurable providers and row-to-provider navigation (#416). @ratulsarna
 - Add an experimental option to suppress Claude Keychain prompts (#388).
-- Add OpenRouter provider for credit-based usage tracking (#396). Thanks @chountalas!
-- Add Ollama provider, including token-account support in Settings and CLI (#380). Thanks @CryptoSageSnr!
-- Add Kilo provider support with API/CLI source modes, widget integration, and pass/credit handling (#454). Built on work by @coreh.
 - Reduce CPU/energy regressions and JSONL scanner overhead in Codex/web usage paths (#402, #392). Thanks @bald-ai and @asonawalla!
-- Add Codex historical pace with risk forecasting, backfill, and zero-usage-day handling (#482, supersedes #438). Thanks @tristanmanchester!
 
 ### Providers & Usage
-- Claude: surface rate-limit errors from the CLI `/usage` probe with a user-friendly message, and harden "Failed to load usage data" matching against whitespace-collapsed output.
 - Codex: add historical pace risk forecasting and backfill, gate pace computation by display mode, and handle zero-usage days in historical data (#482, supersedes #438). Thanks @tristanmanchester!
-- OpenRouter: add provider support with credit tracking, key-quota popup support, token-account labels, fallback status icons, and updated icon/color (#396). Thanks @chountalas!
-- Ollama: add provider support with token-account support in app/CLI, Chrome-default auto cookie import, and manual-cookie mode (#380). Thanks @CryptoSageSnr!
 - Kilo: add provider support with source-mode fallback, clearer credential/login guidance, auto top-up activity labeling, zero-balance credit handling, and pass parsing/menu rendering (#454). Thanks @coreh!
-- Browser cookie import: match Gecko `*.default*` profile directories case-insensitively so Firefox/Zen cookie detection works with uppercase `.Default` directories (#422). Thanks @bald-ai!
-- MiniMax: make both Settings "Open Coding Plan" actions region-aware so China mainland selection opens `platform.minimaxi.com` instead of the global domain (#426, fixes #378). Thanks @bald-ai!
+- Ollama: add provider support with token-account support in app/CLI, Chrome-default auto cookie import, and manual-cookie mode (#380). Thanks @CryptoSageSnr!
+- OpenRouter: add provider support with credit tracking, key-quota popup support, token-account labels, fallback status icons, and updated icon/color (#396). Thanks @chountalas!
+- Gemini: show separate Pro, Flash, and Flash Lite meters by splitting Gemini CLI quota buckets for `gemini-2.5-flash` and `gemini-2.5-flash-lite` (#496). Thanks @aladh
 - Codex: in percent display mode with "show remaining," show remaining credits in the menu bar when session or weekly usage is exhausted (#336). Thanks @teron131!
+- Claude: surface rate-limit errors from the CLI `/usage` probe with a user-friendly message, and harden "Failed to load usage data" matching against whitespace-collapsed output.
+- Claude: restore weekly/Sonnet reset parsing from whitespace-collapsed CLI `/usage` output so reset times and pace details still appear after CLI fallback.
 - Claude: fix extra-usage double conversion so OAuth/Web values stay on a single normalization path (#472, supersedes #463). Thanks @Priyans-hu!
+- Claude: remove root-directory mtime short-circuiting in cost scanning so new session logs inside existing `~/.claude/projects/*` folders are discovered reliably (#462, fixes #411). Thanks @Priyans-hu!
 - Copilot: harden free-plan quota parsing and fallback behavior by treating underdetermined values as unknown, preserving missing metadata as nil (#432, supersedes #393). Thanks @emanuelst!
-- Menu: rebuild the merged provider switcher when “Show usage as used” changes so switcher progress updates immediately (#306). Thanks @Flohhhhh!
-- Update Kiro parsing for `kiro-cli` 1.24+ / Q Developer formats and non-managed plan handling (#288). Thanks @kilhyeonjun!
-- Kimi: in automatic metric mode, prioritize the 5-hour rate-limit window for menu bar and merged highest-usage calculations (#390). Thanks @ajaxjiang96!
 - OpenCode: treat explicit `null` subscription responses as missing usage data, skip POST fallback, and return a clearer workspace-specific error (#412).
 - OpenCode: surface clearer HTTP errors. Thanks @SalimBinYousuf1!
+- Codex: preserve exact GPT-5 model IDs in local cost history, add GPT-5.4 pricing, and label zero-cost `gpt-5.3-codex-spark` sessions as "Research Preview" in cost breakdowns (#511). Thanks @iam-brain!
+- Augment: prevent refresh stalls when `auggie account status` hangs by replacing unbounded CLI waits with timed subprocess execution and fallback handling (#481). Thanks @bryant24hao!
+- Update Kiro parsing for `kiro-cli` 1.24+ / Q Developer formats and non-managed plan handling (#288). Thanks @kilhyeonjun!
+- Kimi: in automatic metric mode, prioritize the 5-hour rate-limit window for menu bar and merged highest-usage calculations (#390). Thanks @ajaxjiang96!
+- Browser cookie import: match Gecko `*.default*` profile directories case-insensitively so Firefox/Zen cookie detection works with uppercase `.Default` directories (#422). Thanks @bald-ai!
+- MiniMax: make both Settings "Open Coding Plan" actions region-aware so China mainland selection opens `platform.minimaxi.com` instead of the global domain (#426, fixes #378). Thanks @bald-ai!
+- Menu: rebuild the merged provider switcher when “Show usage as used” changes so switcher progress updates immediately (#306). Thanks @Flohhhhh!
 - Warp: update API key setup guidance.
 - Claude: update the "not installed" help link to the current Claude Code documentation URL (#431). Thanks @skebby11!
 - Fix Claude setup message package name (#376). Thanks @daegwang!
 
 ### Menu & Settings
+- Merged menu: keep Merge Icons, the switcher, and Overview tied to user-enabled providers even when some providers are temporarily unavailable, while defaulting menu content and icon state to an available provider when possible (#525). Thanks @Astro-Han!
 - Merged menu: add an Overview switcher tab that shows up to three provider usage rows in provider order (#416).
 - Settings: add "Overview tab providers" controls to choose/deselect Overview providers, with persisted selection reconciliation as enabled providers change (#416).
 - Menu: hide contextual provider actions while Overview is selected and rebuild switcher state when overview availability changes (#416).
 
 ### Claude OAuth & Keychain
-- Use a `claude-code/<version>` User-Agent for OAuth usage requests instead of a generic identifier.
 - Add an experimental Claude OAuth Security-CLI reader path and option in settings.
 - Apply stored prompt mode and fallback policy to silent/noninteractive keychain probes.
 - Add cooldown for background OAuth keychain retries.
 - Disable experimental toggle when keychain access is disabled.
+- Use a `claude-code/<version>` User-Agent for OAuth usage requests instead of a generic identifier.
 
 ### Performance & Reliability
 - Codex/OpenAI web: reduce CPU and energy overhead by shortening failed CLI probe windows, capping web retry timeouts, and using adaptive idle blink scheduling (#402). Thanks @bald-ai!
 - Cost usage scanner: optimize JSONL chunk parsing to avoid buffer-front removal overhead on large logs (#392). Thanks @asonawalla!
 - TTY runner: fence shutdown registration to avoid launch/shutdown races, isolate process groups before shutdown rejection, and ensure lingering CLI descendants are cleaned up on app termination (#429). Thanks @uraimo!
 
-### Dev & Tests
-- Run provider fetches and Claude debug OAuth probes off `MainActor`.
-- Split Claude OAuth test overrides and isolate coordinator tests.
-- Docs: explain pace tracking terminology in the UI guide, including "deficit", "reserve", and "on pace" meanings (#421). Thanks @bald-ai!
-
 
 ## 0.18.0-beta.3 — 2026-02-13
 ### Highlights
diff --git a/FORK_STATUS.md b/FORK_STATUS.md
deleted file mode 100644
index cb0a07fdf4..0000000000
--- a/FORK_STATUS.md
+++ /dev/null
@@ -1,338 +0,0 @@
-# CodexBar Fork - Current Status
-
-**Last Updated:** January 4, 2026
-**Fork Maintainer:** Brandon Charleson
-**Branch:** `feature/augment-integration`
-
----
-
-## ✅ Completed Work
-
-### Phase 1: Fork Identity & Credits ✓
-
-**Commits:**
-1. `da3d13e` - "feat: establish fork identity with dual attribution"
-2. `745293e` - "docs: add fork roadmap and quick start guide"
-3. `8a87473` - "docs: add fork status tracking document"
-4. `df75ae2` - "feat: comprehensive multi-upstream fork management system"
-
-**Changes:**
-- ✅ Updated About section with dual attribution (original + fork)
-- ✅ Updated PreferencesAboutPane with organized sections
-- ✅ Changed app icon click to open fork repository
-- ✅ Updated README with fork notice and enhancements section
-- ✅ Created comprehensive `docs/augment.md` documentation
-- ✅ Created `docs/FORK_ROADMAP.md` with 5-phase plan
-- ✅ Created `docs/FORK_QUICK_START.md` developer guide
-- ✅ Created `FORK_STATUS.md` tracking document
-- ✅ **Implemented complete multi-upstream management system**
-
-**Build Status:** ✅ App builds and runs successfully
-
-### Multi-Upstream Management System ✓
-
-**Automation Scripts:**
-- ✅ `Scripts/check_upstreams.sh` - Monitor both upstreams
-- ✅ `Scripts/review_upstream.sh` - Create review branches
-- ✅ `Scripts/prepare_upstream_pr.sh` - Prepare upstream PRs
-- ✅ `Scripts/analyze_quotio.sh` - Analyze quotio patterns
-
-**GitHub Actions:**
-- ✅ `.github/workflows/upstream-monitor.yml` - Automated monitoring
-
-**Documentation:**
-- ✅ `docs/UPSTREAM_STRATEGY.md` - Complete management guide
-- ✅ `docs/QUOTIO_ANALYSIS.md` - Pattern analysis framework
-- ✅ `docs/FORK_SETUP.md` - One-time setup guide
-
----
-
-## 🎯 Current State
-
-### What Works
-- ✅ Fork identity clearly established
-- ✅ Dual attribution in place (original + fork)
-- ✅ Comprehensive documentation
-- ✅ Clear development roadmap
-- ✅ App builds without errors
-- ✅ All existing functionality preserved
-- ✅ **Multi-upstream management system operational**
-- ✅ **Automated upstream monitoring configured**
-- ✅ **Quotio analysis framework ready**
-
-### Critical Discovery
-- ⚠️ **Upstream (steipete) has REMOVED Augment provider**
-  - 627 lines deleted from `AugmentStatusProbe.swift`
-  - 88 lines deleted from `AugmentStatusProbeTests.swift`
-  - **This validates our fork strategy!**
-  - We preserve Augment support for our users
-  - We can selectively sync other improvements
-
-### Known Issues
-- ⚠️ Augment cookie disconnection (Phase 2 will address)
-- ⚠️ Debug print statements in AugmentStatusProbe.swift (needs proper logging)
-
-### Uncommitted Changes
-- `Sources/CodexBarCore/Providers/Augment/AugmentStatusProbe.swift` has debug print statements
-  - These should be replaced with proper `CodexBarLog` logging in Phase 2
-  - Currently unstaged to keep commits clean
-
----
-
-## 📋 Next Steps
-
-### URGENT: Upstream Sync Decision
-**Before proceeding with Phase 2, decide on upstream sync strategy:**
-
-1. **Review upstream changes:**
-   ```bash
-   ./Scripts/check_upstreams.sh upstream
-   ./Scripts/review_upstream.sh upstream
-   ```
-
-2. **Decide what to sync:**
-   - ✅ Vertex AI improvements (5 commits)
-   - ✅ SwiftFormat/SwiftLint fixes
-   - ❌ Augment provider removal (SKIP!)
-
-3. **Cherry-pick valuable commits:**
-   ```bash
-   git checkout -b upstream-sync/vertex-improvements
-   git cherry-pick 001019c  # style fixes
-   git cherry-pick e4f1e4c  # vertex token cost
-   git cherry-pick 202efde  # vertex fix
-   git cherry-pick 0c2f888  # vertex docs
-   git cherry-pick 3c4ca30  # vertex tracking
-   # Skip Augment removal commits!
-   ```
-
-### Immediate (Phase 2)
-1. **Replace debug prints with proper logging**
-   - Use `CodexBarLog.logger("augment")` pattern
-   - Add structured metadata
-   - Follow Claude/Cursor provider patterns
-
-2. **Enhanced cookie diagnostics**
-   - Log cookie expiration times
-   - Track refresh attempts
-   - Add domain filtering diagnostics
-
-3. **Session keepalive monitoring**
-   - Add keepalive status to debug pane
-   - Log refresh attempts
-   - Add manual "Force Refresh" button
-
-### Short Term (Phases 3-4)
-- **Analyze Quotio features** using `./Scripts/analyze_quotio.sh`
-- **Regular upstream monitoring** (automated via GitHub Actions)
-- **Weekly sync routine** (Monday: upstream, Thursday: quotio)
-
-### Medium Term (Phase 5)
-- Implement multi-account management (inspired by quotio)
-- Start with Augment provider
-- Extend to other providers
-
----
-
-## 📁 Key Files Modified
-
-### Source Code
-- `Sources/CodexBar/About.swift` - Dual attribution
-- `Sources/CodexBar/PreferencesAboutPane.swift` - Organized sections
-- `Sources/CodexBarCore/Providers/Augment/AugmentStatusProbe.swift` - Debug prints (unstaged)
-
-### Documentation
-- `README.md` - Fork notice and enhancements
-- `docs/augment.md` - Augment provider guide (NEW)
-- `docs/FORK_ROADMAP.md` - Development roadmap (NEW)
-- `docs/FORK_QUICK_START.md` - Quick reference (NEW)
-
----
-
-## 🔄 Git Status
-
-```bash
-# Current branch
-feature/augment-integration
-
-# Commits ahead of main
-4 commits:
-- da3d13e: Fork identity with dual attribution
-- 745293e: Roadmap and quick start guide
-- 8a87473: Fork status tracking
-- df75ae2: Multi-upstream management system
-
-# Uncommitted changes
-M Sources/CodexBarCore/Providers/Augment/AugmentStatusProbe.swift (debug prints)
-
-# Git remotes configured
-origin    git@github.com:topoffunnel/CodexBar.git
-upstream  https://github.com/steipete/CodexBar.git (needs to be added)
-quotio    https://github.com/nguyenphutrong/quotio.git (needs to be added)
-```
-
----
-
-## 🚀 How to Continue
-
-### RECOMMENDED: Setup Multi-Upstream System First
-
-```bash
-# 1. Configure git remotes
-git remote add upstream https://github.com/steipete/CodexBar.git
-git remote add quotio https://github.com/nguyenphutrong/quotio.git
-git fetch --all
-
-# 2. Test automation scripts
-./Scripts/check_upstreams.sh
-
-# 3. Review upstream changes (IMPORTANT!)
-./Scripts/review_upstream.sh upstream
-
-# 4. Decide what to sync
-# See "URGENT: Upstream Sync Decision" section above
-
-# 5. Analyze quotio
-./Scripts/analyze_quotio.sh
-```
-
-### Option 1: Sync Upstream First, Then Phase 2
-```bash
-# Discard debug prints (will redo in Phase 2)
-git checkout Sources/CodexBarCore/Providers/Augment/AugmentStatusProbe.swift
-
-# Sync valuable upstream changes
-git checkout -b upstream-sync/vertex-improvements
-# Cherry-pick commits (see URGENT section)
-
-# Merge to main
-git checkout main
-git merge feature/augment-integration
-git merge upstream-sync/vertex-improvements
-
-# Then start Phase 2
-git checkout -b feature/augment-diagnostics
-```
-
-### Option 2: Phase 2 First, Sync Later
-```bash
-# Keep debug prints and enhance them
-git add Sources/CodexBarCore/Providers/Augment/AugmentStatusProbe.swift
-
-# Continue on current branch
-# Replace print() with CodexBarLog.logger("augment")
-# Complete Phase 2
-# Then sync upstream
-```
-
-### Option 3: Merge Current Work, Setup System
-```bash
-# Discard debug prints
-git checkout Sources/CodexBarCore/Providers/Augment/AugmentStatusProbe.swift
-
-# Merge to main
-git checkout main
-git merge feature/augment-integration
-
-# Setup remotes
-git remote add upstream https://github.com/steipete/CodexBar.git
-git remote add quotio https://github.com/nguyenphutrong/quotio.git
-
-# Start using the system
-./Scripts/check_upstreams.sh
-```
-
----
-
-## 📊 Progress Tracking
-
-### Phase 1: Fork Identity ✅ COMPLETE
-- [x] Dual attribution in About
-- [x] Fork notice in README
-- [x] Augment documentation
-- [x] Development roadmap
-- [x] Quick start guide
-
-### Phase 2: Enhanced Diagnostics 🔄 READY TO START
-- [ ] Replace print() with CodexBarLog
-- [ ] Enhanced cookie diagnostics
-- [ ] Session keepalive monitoring
-- [ ] Debug pane improvements
-
-### Phase 3: Quotio Analysis 📋 PLANNED
-- [ ] Feature comparison matrix
-- [ ] Implementation recommendations
-- [ ] Priority ranking
-
-### Phase 4: Upstream Sync 📋 PLANNED
-- [ ] Sync script
-- [ ] Conflict resolution guide
-- [ ] Automated checks
-
-### Phase 5: Multi-Account 📋 PLANNED
-- [ ] Account management UI
-- [ ] Account storage
-- [ ] Account switching
-- [ ] UI enhancements
-
----
-
-## 🎯 Success Criteria
-
-### Phase 1 (Current) ✅
-- [x] Fork identity clearly established
-- [x] Original author properly credited
-- [x] Comprehensive documentation
-- [x] App builds and runs
-- [x] No regressions
-
-### Phase 2 (Next)
-- [ ] Zero cookie disconnection issues
-- [ ] Proper structured logging
-- [ ] Enhanced debug diagnostics
-- [ ] Manual refresh capability
-- [ ] All tests passing
-
----
-
-## 📞 Questions & Decisions Needed
-
-### Before Starting Phase 2
-1. **Logging approach:** Keep debug prints and enhance, or start fresh?
-2. **Branch strategy:** Continue on `feature/augment-integration` or create new branch?
-3. **Merge timing:** Merge Phase 1 to main first, or continue with all phases?
-
-### For Phase 3
-1. **Quotio access:** Do you have access to Quotio source code?
-2. **Feature priority:** Which Quotio features are most important?
-3. **Timeline:** How much time to allocate for analysis?
-
-### For Phase 5
-1. **Account limit:** How many accounts per provider?
-2. **UI design:** Menu bar dropdown or separate window?
-3. **Storage:** Keychain per account or shared?
-
----
-
-## 🔗 Quick Links
-
-- **Roadmap:** `docs/FORK_ROADMAP.md`
-- **Quick Start:** `docs/FORK_QUICK_START.md`
-- **Augment Docs:** `docs/augment.md`
-- **Original Repo:** https://github.com/steipete/CodexBar
-- **Fork Repo:** https://github.com/topoffunnel/CodexBar
-
----
-
-## 💡 Recommendations
-
-1. **Merge Phase 1 to main** - Establish fork identity as baseline
-2. **Create Phase 2 branch** - `feature/augment-diagnostics`
-3. **Start with logging** - Replace prints with proper CodexBarLog
-4. **Test thoroughly** - Ensure no regressions
-5. **Document as you go** - Update docs with findings
-
----
-
-**Ready to proceed with Phase 2?** See `docs/FORK_ROADMAP.md` for detailed tasks.
-
diff --git a/IMPLEMENTATION_SUMMARY.md b/IMPLEMENTATION_SUMMARY.md
deleted file mode 100644
index f5d3c63b0a..0000000000
--- a/IMPLEMENTATION_SUMMARY.md
+++ /dev/null
@@ -1,298 +0,0 @@
-# CodexBar Fork - Implementation Summary
-
-**Date:** January 4, 2026  
-**Implementer:** Augment AI Assistant  
-**For:** Brandon Charleson (topoffunnel.com)
-
----
-
-## 🎉 What Was Accomplished
-
-### Phase 1: Fork Identity & Credits ✅ COMPLETE
-
-**Objective:** Establish clear fork identity while properly crediting original author
-
-**Deliverables:**
-1. **Dual Attribution System**
-   - Updated `About.swift` with original author + fork maintainer
-   - Updated `PreferencesAboutPane.swift` with organized sections
-   - App icon click now opens fork repository
-   - Clear separation of original vs fork contributions
-
-2. **Documentation Suite**
-   - `docs/augment.md` - Comprehensive Augment provider guide (150+ lines)
-   - `docs/FORK_ROADMAP.md` - 5-phase development plan
-   - `docs/FORK_QUICK_START.md` - Developer quick reference
-   - `FORK_STATUS.md` - Living status tracker
-
-3. **README Updates**
-   - Fork notice at top with link to original
-   - "Fork Enhancements" section documenting improvements
-   - Updated credits with dual attribution
-   - Clear differentiation from original
-
-**Result:** Fork has professional identity, ready for distribution via topoffunnel.com
-
----
-
-### Multi-Upstream Management System ✅ COMPLETE
-
-**Objective:** Monitor and selectively incorporate changes from two upstream repositories
-
-**Deliverables:**
-
-#### 1. Automation Scripts (4 scripts, all executable)
-
-**`Scripts/check_upstreams.sh`**
-- Monitors both upstream and quotio for new commits
-- Shows commit summaries and file changes
-- Color-coded output for easy scanning
-- Usage: `./Scripts/check_upstreams.sh [upstream|quotio|all]`
-
-**`Scripts/review_upstream.sh`**
-- Creates review branch for upstream changes
-- Shows detailed commit log and diffs
-- Generates review log file
-- Usage: `./Scripts/review_upstream.sh [upstream|quotio]`
-
-**`Scripts/prepare_upstream_pr.sh`**
-- Creates clean branch from upstream/main for PR submission
-- Provides guidelines for what to include/exclude
-- Prevents fork branding from going upstream
-- Usage: `./Scripts/prepare_upstream_pr.sh <feature-name>`
-
-**`Scripts/analyze_quotio.sh`**
-- Analyzes quotio repository structure and recent changes
-- Generates analysis report with action items
-- Helps identify patterns to adapt (not copy)
-- Usage: `./Scripts/analyze_quotio.sh [feature-area]`
-
-#### 2. GitHub Actions Workflow
-
-**`.github/workflows/upstream-monitor.yml`**
-- Runs Monday and Thursday at 9 AM UTC
-- Checks both upstreams for new commits
-- Creates/updates GitHub issue with summaries
-- Provides links to review changes
-- Can be triggered manually
-
-#### 3. Comprehensive Documentation (3 guides)
-
-**`docs/UPSTREAM_STRATEGY.md`** (630+ lines)
-- Complete multi-upstream management guide
-- Git repository structure and remote configuration
-- Workflows for monitoring, reviewing, incorporating changes
-- Decision matrix: what to contribute upstream vs keep in fork
-- Commit message strategies and attribution
-- Practical examples and troubleshooting
-- Best practices and success metrics
-
-**`docs/QUOTIO_ANALYSIS.md`** (150+ lines)
-- Framework for learning from quotio patterns
-- Ethical guidelines (adapt patterns, don't copy code)
-- Analysis process and templates
-- Feature comparison matrix
-- Implementation planning
-- Legal and attribution considerations
-
-**`docs/FORK_SETUP.md`** (150+ lines)
-- One-time setup guide for git remotes
-- Script testing and verification
-- Critical discovery documentation
-- Selective sync strategy
-- Regular workflow recommendations
-
----
-
-## 🚨 Critical Discovery
-
-**Upstream (steipete) has REMOVED the Augment provider!**
-
-**Evidence:**
-```
-Files changed in upstream:
- .../Providers/Augment/AugmentStatusProbe.swift     | 627 deletions
- Tests/CodexBarTests/AugmentStatusProbeTests.swift  |  88 deletions
-```
-
-**Impact:**
-- ✅ **Validates fork strategy** - We preserve features important to our users
-- ✅ **Justifies independent development** - Can't rely on upstream for Augment
-- ✅ **Enables selective sync** - Cherry-pick valuable changes, skip Augment removal
-- ✅ **Protects user experience** - Fork users keep Augment functionality
-
-**Action Required:**
-When syncing with upstream, must cherry-pick commits selectively to avoid losing Augment support.
-
----
-
-## 📊 Commits Summary
-
-**Total Commits:** 5
-
-1. `da3d13e` - Fork identity with dual attribution
-2. `745293e` - Roadmap and quick start guide
-3. `8a87473` - Fork status tracking document
-4. `df75ae2` - Multi-upstream management system
-5. `158d00c` - Updated fork status
-
-**Lines Added:** ~2,500+ lines of documentation and automation
-**Files Created:** 11 new files
-**Scripts Created:** 4 executable automation scripts
-**Workflows Created:** 1 GitHub Actions workflow
-
----
-
-## 🎯 Strategic Benefits
-
-### For Fork Development
-1. **Independence** - Can develop features without upstream dependency
-2. **Selective Sync** - Cherry-pick valuable improvements, skip unwanted changes
-3. **Attribution Protection** - Fork-specific commits stay separate
-4. **User Focus** - Preserve features important to your users (Augment)
-
-### For Upstream Relationship
-1. **Contribution Ready** - Clean PR branches for upstream submissions
-2. **Good Citizenship** - Can contribute bug fixes and improvements
-3. **Proper Credit** - Attribution system respects original author
-4. **Flexibility** - Option to contribute or keep changes in fork
-
-### For Learning from Quotio
-1. **Ethical Framework** - Clear guidelines for pattern analysis
-2. **Legal Protection** - Adapt patterns, don't copy code
-3. **Innovation** - Learn from their solutions, implement independently
-4. **Attribution** - Credit inspiration appropriately
-
----
-
-## 📋 Current State
-
-### What's Ready
-- ✅ Fork identity established
-- ✅ Comprehensive documentation
-- ✅ Automation scripts tested and working
-- ✅ GitHub Actions workflow configured
-- ✅ Git remotes documented (need to be added)
-- ✅ Selective sync strategy defined
-- ✅ App builds and runs successfully
-
-### What's Pending
-- ⏳ Git remotes need to be added (one-time setup)
-- ⏳ Upstream sync decision needed (5 new commits available)
-- ⏳ Quotio analysis to be performed
-- ⏳ Phase 2 (Enhanced Augment diagnostics)
-
-### Known Issues
-- ⚠️ Augment cookie disconnection (Phase 2 will address)
-- ⚠️ Debug print statements in AugmentStatusProbe.swift (unstaged)
-
----
-
-## 🚀 Next Steps for You
-
-### Immediate (Before Phase 2)
-
-**1. Setup Git Remotes**
-```bash
-git remote add upstream https://github.com/steipete/CodexBar.git
-git remote add quotio https://github.com/nguyenphutrong/quotio.git
-git fetch --all
-```
-
-**2. Test Automation**
-```bash
-./Scripts/check_upstreams.sh
-./Scripts/review_upstream.sh upstream
-./Scripts/analyze_quotio.sh
-```
-
-**3. Decide on Upstream Sync**
-- Review 5 new upstream commits
-- Cherry-pick valuable changes (Vertex AI improvements)
-- Skip Augment removal commits
-- See `FORK_STATUS.md` for detailed instructions
-
-### Short Term (This Week)
-
-**4. Merge to Main**
-```bash
-git checkout main
-git merge feature/augment-integration
-```
-
-**5. Enable GitHub Actions**
-- Push to your fork
-- Enable Actions in repository settings
-- Verify workflow runs
-
-**6. Start Regular Monitoring**
-- Monday: Check upstream (`./Scripts/check_upstreams.sh upstream`)
-- Thursday: Analyze quotio (`./Scripts/analyze_quotio.sh`)
-
-### Medium Term (Next 2 Weeks)
-
-**7. Complete Phase 2**
-- Enhanced Augment diagnostics
-- Proper logging with CodexBarLog
-- Session keepalive monitoring
-
-**8. Quotio Analysis**
-- Document multi-account patterns
-- Plan implementation
-- Prioritize features
-
----
-
-## 📖 Documentation Index
-
-### Core Documents
-- `README.md` - Main documentation with fork notice
-- `FORK_STATUS.md` - Current status and next steps
-- `IMPLEMENTATION_SUMMARY.md` - This document
-
-### Setup & Strategy
-- `docs/FORK_SETUP.md` - One-time setup guide
-- `docs/FORK_QUICK_START.md` - Developer quick reference
-- `docs/UPSTREAM_STRATEGY.md` - Multi-upstream management
-- `docs/FORK_ROADMAP.md` - 5-phase development plan
-
-### Provider & Analysis
-- `docs/augment.md` - Augment provider guide
-- `docs/QUOTIO_ANALYSIS.md` - Quotio pattern analysis framework
-
-### Scripts
-- `Scripts/check_upstreams.sh` - Monitor upstreams
-- `Scripts/review_upstream.sh` - Review changes
-- `Scripts/prepare_upstream_pr.sh` - Prepare PRs
-- `Scripts/analyze_quotio.sh` - Analyze quotio
-
----
-
-## 💡 Key Insights
-
-1. **Fork Validation** - Upstream removing Augment proves fork was necessary
-2. **Best of Both Worlds** - Can learn from two sources while maintaining independence
-3. **Selective Sync** - Cherry-picking gives control over what changes to adopt
-4. **Attribution Matters** - Separate commits protect your contributions
-5. **Automation Wins** - Scripts and workflows reduce manual effort
-
----
-
-## ✅ Success Criteria Met
-
-- [x] Fork identity clearly established
-- [x] Original author properly credited
-- [x] Comprehensive documentation
-- [x] Multi-upstream monitoring system
-- [x] Automation scripts working
-- [x] GitHub Actions configured
-- [x] Selective sync strategy defined
-- [x] App builds and runs
-- [x] No regressions
-
----
-
-**Status:** Phase 1 COMPLETE + Multi-Upstream System OPERATIONAL  
-**Ready for:** Upstream sync decision + Phase 2 development  
-**Recommendation:** Setup remotes, sync upstream, then proceed to Phase 2
-
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000000..55d28ce76e
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,43 @@
+SHELL := /bin/bash
+
+.PHONY: build check docs-list format lint release restart start start-debug start-release stop test test-live test-tty
+
+start:
+	./Scripts/compile_and_run.sh
+
+start-debug:
+	./Scripts/compile_and_run.sh
+
+start-release:
+	./Scripts/package_app.sh release
+	pkill -x CodexBar || pkill -f CodexBar.app || true
+	cd /Users/steipete/Projects/codexbar && open -n /Users/steipete/Projects/codexbar/CodexBar.app
+
+restart: start
+
+stop:
+	pkill -x CodexBar || pkill -f CodexBar.app || true
+
+check lint:
+	./Scripts/lint.sh lint
+
+format:
+	./Scripts/lint.sh format
+
+docs-list:
+	node Scripts/docs-list.mjs
+
+build:
+	swift build
+
+test:
+	./Scripts/test.sh
+
+test-tty:
+	swift test --filter TTYIntegrationTests
+
+test-live:
+	LIVE_TEST=1 swift test --filter LiveAccountTests
+
+release:
+	./Scripts/package_app.sh release
diff --git a/Package.resolved b/Package.resolved
index f84c0c2172..51cff0b709 100644
--- a/Package.resolved
+++ b/Package.resolved
@@ -1,13 +1,13 @@
 {
-  "originHash" : "74bd6f3ab6e0b0cb0c2cddb00f2167c2ab0a1c00cd54ffc1a2899c7ef8c56367",
+  "originHash" : "43e102e278b77848e0b9968436730835bbb506076e9b371d8f21f262aa5242eb",
   "pins" : [
     {
       "identity" : "commander",
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/steipete/Commander",
       "state" : {
-        "revision" : "9e349575c8e3c6745e81fe19e5bb5efa01b078ce",
-        "version" : "0.2.1"
+        "revision" : "ae2ce746b386ff94b26648cfe5625cfa8d02639b",
+        "version" : "0.2.2"
       }
     },
     {
@@ -24,8 +24,8 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/sparkle-project/Sparkle",
       "state" : {
-        "revision" : "5581748cef2bae787496fe6d61139aebe0a451f6",
-        "version" : "2.8.1"
+        "revision" : "066e75a8b3e99962685d6a90cdd5293ebffd9261",
+        "version" : "2.9.1"
       }
     },
     {
@@ -33,8 +33,26 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/steipete/SweetCookieKit",
       "state" : {
-        "revision" : "4d5b71ffbb296937dc5ee8472f64721bca771cf0",
-        "version" : "0.4.0"
+        "revision" : "21bedea672a3e63ccad24d744051e76cdf0462dd",
+        "version" : "0.4.1"
+      }
+    },
+    {
+      "identity" : "swift-asn1",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/apple/swift-asn1.git",
+      "state" : {
+        "revision" : "eb50cbd14606a9161cbc5d452f18797c90ef0bab",
+        "version" : "1.7.0"
+      }
+    },
+    {
+      "identity" : "swift-crypto",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/apple/swift-crypto",
+      "state" : {
+        "revision" : "95ba0316a9b733e92bb6b071255ff46263bbe7dc",
+        "version" : "3.15.1"
       }
     },
     {
@@ -42,17 +60,16 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/apple/swift-log",
       "state" : {
-        "revision" : "2778fd4e5a12a8aaa30a3ee8285f4ce54c5f3181",
-        "version" : "1.9.1"
+        "revision" : "5073617dac96330a486245e4c0179cb0a6fd2256",
+        "version" : "1.12.0"
       }
     },
     {
-      "identity" : "swift-syntax",
+      "identity" : "vortex",
       "kind" : "remoteSourceControl",
-      "location" : "https://github.com/apple/swift-syntax",
+      "location" : "https://github.com/zats/Vortex",
       "state" : {
-        "revision" : "0687f71944021d616d34d922343dcef086855920",
-        "version" : "600.0.1"
+        "revision" : "ef5392088d4aeb255c4eee83157dbdafcd31bf07"
       }
     }
   ],
diff --git a/Package.swift b/Package.swift
index 83cbfca656..6854e45acd 100644
--- a/Package.swift
+++ b/Package.swift
@@ -1,5 +1,4 @@
 // swift-tools-version: 6.2
-import CompilerPluginSupport
 import Foundation
 import PackageDescription
 
@@ -9,45 +8,69 @@ let useLocalSweetCookieKit =
 let sweetCookieKitDependency: Package.Dependency =
     useLocalSweetCookieKit && FileManager.default.fileExists(atPath: sweetCookieKitPath)
     ? .package(path: sweetCookieKitPath)
-    : .package(url: "https://github.com/steipete/SweetCookieKit", from: "0.4.0")
+    : .package(url: "https://github.com/steipete/SweetCookieKit", from: "0.4.1")
+
+let sqlite3LibDir = ProcessInfo.processInfo.environment["CODEXBAR_SQLITE3_LIB_DIR"]?
+    .trimmingCharacters(in: .whitespacesAndNewlines)
+let sqlite3LinkerSettings: [LinkerSetting] = if let sqlite3LibDir, !sqlite3LibDir.isEmpty {
+    [.unsafeFlags(["-L\(sqlite3LibDir)"], .when(platforms: [.linux]))]
+} else {
+    []
+}
 
 let package = Package(
     name: "CodexBar",
+    defaultLocalization: "en",
     platforms: [
         .macOS(.v14),
     ],
+    products: {
+        var products: [Product] = [
+            .library(name: "CodexBarCore", targets: ["CodexBarCore"]),
+            .executable(name: "CodexBarCLI", targets: ["CodexBarCLI"]),
+        ]
+
+        #if os(macOS)
+        products.append(contentsOf: [
+            .executable(name: "CodexBar", targets: ["CodexBar"]),
+            .executable(name: "CodexBarClaudeWatchdog", targets: ["CodexBarClaudeWatchdog"]),
+            .executable(name: "CodexBarWidget", targets: ["CodexBarWidget"]),
+            .executable(name: "CodexBarClaudeWebProbe", targets: ["CodexBarClaudeWebProbe"]),
+        ])
+        #endif
+
+        return products
+    }(),
     dependencies: [
-        .package(url: "https://github.com/sparkle-project/Sparkle", from: "2.8.1"),
+        .package(url: "https://github.com/sparkle-project/Sparkle", from: "2.9.1"),
         .package(url: "https://github.com/steipete/Commander", from: "0.2.1"),
-        .package(url: "https://github.com/apple/swift-log", from: "1.9.1"),
-        .package(url: "https://github.com/apple/swift-syntax", from: "600.0.1"),
+        .package(url: "https://github.com/apple/swift-crypto.git", from: "3.0.0"),
+        .package(url: "https://github.com/apple/swift-log", from: "1.12.0"),
         .package(url: "https://github.com/sindresorhus/KeyboardShortcuts", from: "2.4.0"),
+        .package(url: "https://github.com/zats/Vortex", revision: "ef5392088d4aeb255c4eee83157dbdafcd31bf07"),
         sweetCookieKitDependency,
     ],
     targets: {
         var targets: [Target] = [
+            // Host pkg-config paths contaminate cross-musl links; the module map supplies sqlite3 linkage.
+            .systemLibrary(
+                name: "CSQLite3",
+                providers: [
+                    .apt(["libsqlite3-dev"]),
+                    .brew(["sqlite3"]),
+                ]),
             .target(
                 name: "CodexBarCore",
                 dependencies: [
-                    "CodexBarMacroSupport",
+                    .target(name: "CSQLite3", condition: .when(platforms: [.linux])),
+                    .product(name: "Crypto", package: "swift-crypto"),
                     .product(name: "Logging", package: "swift-log"),
                     .product(name: "SweetCookieKit", package: "SweetCookieKit"),
                 ],
                 swiftSettings: [
                     .enableUpcomingFeature("StrictConcurrency"),
-                ]),
-            .macro(
-                name: "CodexBarMacros",
-                dependencies: [
-                    .product(name: "SwiftCompilerPlugin", package: "swift-syntax"),
-                    .product(name: "SwiftSyntaxBuilder", package: "swift-syntax"),
-                    .product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
-                ]),
-            .target(
-                name: "CodexBarMacroSupport",
-                dependencies: [
-                    "CodexBarMacros",
-                ]),
+                ],
+                linkerSettings: sqlite3LinkerSettings),
             .executableTarget(
                 name: "CodexBarCLI",
                 dependencies: [
@@ -57,10 +80,15 @@ let package = Package(
                 path: "Sources/CodexBarCLI",
                 swiftSettings: [
                     .enableUpcomingFeature("StrictConcurrency"),
-                ]),
+                ],
+                linkerSettings: sqlite3LinkerSettings),
             .testTarget(
                 name: "CodexBarLinuxTests",
-                dependencies: ["CodexBarCore", "CodexBarCLI"],
+                dependencies: [
+                    "CodexBarCore",
+                    "CodexBarCLI",
+                    .target(name: "CSQLite3", condition: .when(platforms: [.linux])),
+                ],
                 path: "TestsLinux",
                 swiftSettings: [
                     .enableUpcomingFeature("StrictConcurrency"),
@@ -82,7 +110,7 @@ let package = Package(
                 dependencies: [
                     .product(name: "Sparkle", package: "Sparkle"),
                     .product(name: "KeyboardShortcuts", package: "KeyboardShortcuts"),
-                    "CodexBarMacroSupport",
+                    .product(name: "Vortex", package: "Vortex"),
                     "CodexBarCore",
                 ],
                 path: "Sources/CodexBar",
@@ -112,8 +140,11 @@ let package = Package(
 
         targets.append(.testTarget(
             name: "CodexBarTests",
-            dependencies: ["CodexBar", "CodexBarCore", "CodexBarCLI"],
+            dependencies: ["CodexBar", "CodexBarCore", "CodexBarCLI", "CodexBarWidget"],
             path: "Tests",
+            resources: [
+                .copy("CodexBarTests/Fixtures"),
+            ],
             swiftSettings: [
                 .enableUpcomingFeature("StrictConcurrency"),
                 .enableExperimentalFeature("SwiftTesting"),
diff --git a/README.md b/README.md
index 40dd56d2a8..7c18ffb67f 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,26 @@
-# CodexBar 🎚️ - May your tokens never run out.
+# CodexBar 🎚️ — May your tokens never run out.
 
-Tiny macOS 14+ menu bar app that keeps your Codex, Claude, Cursor, Gemini, Antigravity, Droid (Factory), Copilot, z.ai, Kiro, Vertex AI, Augment, Amp, JetBrains AI, and OpenRouter limits visible (session + weekly where available) and shows when each window resets. One status item per provider (or Merge Icons mode with a provider switcher and optional Overview tab); enable what you use from Settings. No Dock icon, minimal UI, dynamic bar icons in the menu bar.
+> Every AI coding limit, in your menu bar.
 
-<img src="codexbar.png" alt="CodexBar menu screenshot" width="520" />
+[![Latest release](https://img.shields.io/github/v/release/steipete/CodexBar?style=flat-square&color=0a0a0c)](https://github.com/steipete/CodexBar/releases/latest)
+[![macOS 14+](https://img.shields.io/badge/macOS-14%2B-0a0a0c?style=flat-square)](https://github.com/steipete/CodexBar/releases/latest)
+[![Homebrew](https://img.shields.io/badge/brew-steipete%2Ftap%2Fcodexbar-orange?style=flat-square)](https://github.com/steipete/homebrew-tap)
+[![AUR](https://img.shields.io/aur/version/codexbar-cli?style=flat-square&color=1793d1)](https://aur.archlinux.org/packages/codexbar-cli)
+[![License: MIT](https://img.shields.io/badge/license-MIT-6e5aff?style=flat-square)](LICENSE)
+[![Site](https://img.shields.io/badge/site-codexbar.app-16d3b4?style=flat-square)](https://codexbar.app)
+
+<a href="https://codexbar.app"><img src="docs/social.png" alt="CodexBar — every AI coding limit in your menu bar. 53 providers." width="100%" /></a>
+
+Tiny macOS 14+ menu bar app that keeps **AI coding-provider limits visible** and shows when each window resets. Codex, OpenAI, Claude, Cursor, Gemini, Copilot, Grok, GroqCloud, ElevenLabs, Deepgram, z.ai, MiniMax, Kiro, Zed, Vertex AI, Augment, OpenRouter, LiteLLM, LLM Proxy, Codebuff, Command Code, AWS Bedrock, and many newer coding providers. One status item per provider, or Merge Icons mode with a provider switcher. No Dock icon, minimal UI, dynamic bar icons.
+
+<img src="codexbar.png" alt="CodexBar menu popover with provider tiles, usage bars, and reset countdowns" width="520" />
+
+## Why
+
+- **Plan around resets.** Per-provider session, weekly, and monthly windows with countdowns to the next reset — stop guessing whether to start that long task.
+- **Credits, spend, and cost scans.** Credit balances, Admin API spend dashboards, provider billing summaries, and local cost scans where the source exposes enough detail.
+- **Live status.** Provider status polling surfaces incident badges in the menu and an indicator overlay on the bar icon.
+- **Privacy-first.** Reuses existing provider sessions — OAuth, device flow, API keys, browser cookies, local files — so no passwords are stored.
 
 ## Install
 
@@ -14,101 +32,176 @@ Download: <https://github.com/steipete/CodexBar/releases>
 
 ### Homebrew
 ```bash
-brew install --cask steipete/tap/codexbar
+brew install --cask codexbar
 ```
 
-### Linux (CLI only)
+### CLI Tarballs (macOS/Linux)
+Homebrew formula (Linux today):
 ```bash
 brew install steipete/tap/codexbar
 ```
-Or download `CodexBarCLI-v<tag>-linux-<arch>.tar.gz` from GitHub Releases.
-Linux support via Omarchy: community Waybar module and TUI, driven by the `codexbar` executable.
+Arch Linux AUR package:
+```bash
+yay -S codexbar-cli
+```
+Or download release tarballs from GitHub Releases:
+- macOS: `CodexBarCLI-v<tag>-macos-arm64.tar.gz`, `CodexBarCLI-v<tag>-macos-x86_64.tar.gz`
+- Linux (glibc): `CodexBarCLI-v<tag>-linux-aarch64.tar.gz`, `CodexBarCLI-v<tag>-linux-x86_64.tar.gz`
+- Linux (static musl): `CodexBarCLI-v<tag>-linux-musl-aarch64.tar.gz`, `CodexBarCLI-v<tag>-linux-musl-x86_64.tar.gz`
 
 ### First run
 - Open Settings → Providers and enable what you use.
-- Install/sign in to the provider sources you rely on (e.g. `codex`, `claude`, `gemini`, browser cookies, or OAuth; Antigravity requires the Antigravity app running).
+- Install/sign in to the provider sources you rely on: CLIs, browser sessions, OAuth/device flow, API keys, local app files, or provider apps depending on the provider.
 - Optional: Settings → Providers → Codex → OpenAI cookies (Automatic or Manual) to add dashboard extras.
 
+### Set API keys from the CLI
+Provider toggles and API keys live in the resolved CodexBar config file. New installs use
+`~/.config/codexbar/config.json`; existing `~/.codexbar/config.json` installs still load from the legacy path. You can
+script the same provider list that Settings → Providers uses:
+
+```bash
+codexbar config providers
+codexbar config enable --provider grok
+codexbar config disable --provider cursor
+```
+
+For API-key providers, store a key without opening Settings:
+
+```bash
+printf '%s' "$ELEVENLABS_API_KEY" | codexbar config set-api-key --provider elevenlabs --stdin
+```
+
+`set-api-key` trims the piped value, stores it with restrictive config-file permissions, and enables the provider by default. Use `--no-enable` to only save the key, or `--api-key <key>` for one-off local scripts where shell history is not a concern.
+See [CLI configuration](docs/cli-configuration.md) for the full flow.
+
 ## Providers
 
-- [Codex](docs/codex.md) — Local Codex CLI RPC (+ PTY fallback) and optional OpenAI web dashboard extras.
-- [Claude](docs/claude.md) — OAuth API or browser cookies (+ CLI PTY fallback); session + weekly usage.
+- [Codex](docs/codex.md) — OAuth API or local Codex CLI, plus optional OpenAI web dashboard extras.
+- [OpenAI](docs/openai.md) — Admin API key usage/cost graphs with legacy credit-balance fallback.
+- [Claude](docs/claude.md) — OAuth API, browser cookies, or CLI PTY fallback; session and weekly usage where available.
 - [Cursor](docs/cursor.md) — Browser session cookies for plan + usage + billing resets.
+- [OpenCode](docs/opencode.md) — Browser cookies for workspace subscription usage.
+- [OpenCode Go](docs/opencode.md) — Browser or local SQLite data for Go usage windows.
+- [Alibaba Coding Plan](docs/alibaba-coding-plan.md) — Web cookies or API key for coding-plan quotas.
+- [Alibaba Token Plan](docs/alibaba-token-plan.md) — Bailian browser/manual cookies for token-plan credits.
 - [Gemini](docs/gemini.md) — OAuth-backed quota API using Gemini CLI credentials (no browser cookies).
 - [Antigravity](docs/antigravity.md) — Local language server probe (experimental); no external auth.
 - [Droid](docs/factory.md) — Browser cookies + WorkOS token flows for Factory usage + billing.
 - [Copilot](docs/copilot.md) — GitHub device flow + Copilot internal usage API.
-- [z.ai](docs/zai.md) — API token (Keychain) for quota + MCP windows.
+- [Devin](docs/devin.md) — Chrome localStorage session or manual Bearer token for daily and weekly quotas.
+- [z.ai](docs/zai.md) — API token for quota + MCP windows.
+- [Manus](docs/manus.md) — Browser `session_id` auth for credit balance, monthly credits, and daily refresh tracking.
+- [MiniMax](docs/minimax.md) — API token, cookie header, or browser cookies for coding-plan usage.
+- [T3 Chat](docs/providers.md#t3-chat) — Browser cookies capture for Base and Overage usage buckets.
 - [Kimi](docs/kimi.md) — Auth token (JWT from `kimi-auth` cookie) for weekly quota + 5‑hour rate limit.
-- [Kimi K2](docs/kimi-k2.md) — API key for credit-based usage totals.
-- [Kiro](docs/kiro.md) — CLI-based usage via `kiro-cli /usage` command; monthly credits + bonus credits.
+- [Kimi K2 (unofficial)](docs/kimi-k2.md) — Legacy API key flow for credit-based usage totals.
+- [Kilo](docs/kilo.md) — API token with CLI-auth fallback for Kilo Pass usage.
+- [Kiro](docs/kiro.md) — CLI-based usage; monthly credits + bonus credits.
 - [Vertex AI](docs/vertexai.md) — Google Cloud gcloud OAuth with token cost tracking from local Claude logs.
-- [Augment](docs/augment.md) — Browser cookie-based authentication with automatic session keepalive; credits tracking and usage monitoring.
+- [Augment](docs/augment.md) — Augment CLI or browser cookies for credits tracking and usage monitoring.
 - [Amp](docs/amp.md) — Browser cookie-based authentication with Amp Free usage tracking.
+- [Ollama](docs/ollama.md) — API key access plus browser cookies for Ollama Cloud usage windows.
 - [JetBrains AI](docs/jetbrains.md) — Local XML-based quota from JetBrains IDE configuration; monthly credits tracking.
+- [Warp](docs/warp.md) — API token for GraphQL request limits and monthly credits.
+- [ElevenLabs](docs/elevenlabs.md) — API key for character credits and voice slot usage.
 - [OpenRouter](docs/openrouter.md) — API token for credit-based usage tracking across multiple AI providers.
+- [Windsurf](docs/windsurf.md) — Browser localStorage session import or local SQLite cache for plan usage.
+- [Zed](docs/zed.md) — Zed editor Keychain session for plan, edit-prediction quota, billing cycle, and overdue invoices.
+- Perplexity — Account usage credits from Perplexity usage data.
+- [Xiaomi MiMo](docs/mimo.md) — Browser cookies for balance and token-plan usage.
+- [Doubao](docs/doubao.md) — API key for Volcengine Ark request-limit probes.
+- [Abacus AI](docs/abacus.md) — Browser cookie auth for ChatLLM/RouteLLM compute credit tracking.
+- Mistral — Browser cookies for monthly spend tracking.
+- [DeepSeek](docs/deepseek.md) — API key for credit balance tracking (paid vs. granted breakdown).
+- [Moonshot / Kimi API](docs/moonshot.md) — API key for Moonshot/Kimi API account balance tracking.
+- [Venice](docs/venice.md) — API key for DIEM or USD balance tracking.
+- [Codebuff](docs/codebuff.md) — API token (or `~/.config/manicode/credentials.json`) for credit balance + weekly rate limit.
+- [Crof](docs/crof.md) — API key for dollar credit balance and request quota tracking.
+- [Command Code](docs/command-code.md) — Browser or manual cookies for monthly USD credits from Command Code billing.
+- [StepFun](docs/stepfun.md) — Username + password login for Step Plan rate limits (5‑hour + weekly windows) and subscription plan name.
+- [AWS Bedrock](docs/bedrock.md) — AWS access keys or a named AWS profile (SSO/assume-role via the AWS CLI) for Cost Explorer spend, monthly budgets, and optional CloudWatch Claude activity.
+- [Grok](docs/grok.md) — Grok CLI billing RPC plus grok.com browser-session fallback.
+- [GroqCloud](docs/groqcloud.md) — API key for Enterprise Prometheus request/token/cache-hit metrics.
+- [LLM Proxy](docs/llm-proxy.md) — API key + base URL for aggregate proxy quota stats and provider breakdowns.
+- [LiteLLM](docs/litellm.md) — Virtual key + proxy URL for personal and team budget/spend tracking.
+- [Deepgram](docs/deepgram.md) — API key usage summaries across speech, agent, token, and TTS metrics.
+- [Poe](docs/poe.md) — API key for current point balance and recent points history.
+- [Chutes](docs/chutes.md) — API key for subscription usage, rolling and monthly quota windows, and pay-as-you-go quotas.
 - Open to new providers: [provider authoring guide](docs/provider.md).
 
 ## Icon & Screenshot
-The menu bar icon is a tiny two-bar meter:
-- Top bar: 5‑hour/session window. If weekly is missing/exhausted and credits are available, it becomes a thicker credits bar.
-- Bottom bar: weekly window (hairline).
-- Errors/stale data dim the icon; status overlays indicate incidents.
+The menu bar icon is a tiny usage meter. Bar meaning is provider-specific, and errors/stale data can dim the icon or
+show an incident indicator.
 
 ## Features
 - Multi-provider menu bar with per-provider toggles (Settings → Providers).
-- Session + weekly meters with reset countdowns.
+- Provider-specific usage meters with reset countdowns.
 - Optional Codex web dashboard enrichments (code review remaining, usage breakdown, credits history).
-- Local cost-usage scan for Codex + Claude (last 30 days).
+- Inline spend and usage charts for API-backed providers such as OpenAI, Claude Admin API, OpenRouter, LiteLLM, z.ai, MiniMax, Mistral, and AWS Bedrock.
+- Configurable cost-usage scans for Codex + Claude, plus reused chart UI for supported provider histories.
 - Provider status polling with incident badges in the menu and icon overlay.
-- Merge Icons mode to combine providers into one status item + switcher, with an optional Overview tab for up to three providers.
+- Merge Icons mode to combine providers into one status item + switcher.
+- Display controls for provider icons, labels, bars, reset-time style, and highest-usage auto-selection.
 - Refresh cadence presets (manual, 1m, 2m, 5m, 15m).
-- Bundled CLI (`codexbar`) for scripts and CI (including `codexbar cost --provider codex|claude` for local cost usage); Linux CLI builds available.
-- WidgetKit widget mirrors the menu card snapshot.
+- Bundled CLI (`codexbar`) for scripts and CI (including `codexbar cost --provider codex`, `claude`, or `both` for local cost usage); macOS and Linux CLI builds available.
+- WidgetKit widgets for supported providers.
+- Localized app and website with a shared 21-language catalog, automatic website detection, persistent pickers, and RTL support.
+- Optional session quota notifications and weekly-reset confetti.
 - Privacy-first: on-device parsing by default; browser cookies are opt-in and reused (no passwords stored).
 
 ## Privacy note
-Wondering if CodexBar scans your disk? It doesn’t crawl your filesystem; it reads a small set of known locations (browser cookies/local storage, local JSONL logs) when the related features are enabled. See the discussion and audit notes in [issue #12](https://github.com/steipete/CodexBar/issues/12).
+Wondering if CodexBar scans your disk? It doesn’t crawl your filesystem; it reads a small set of known locations (browser cookies/local storage, provider config files, local JSONL logs) when the related features are enabled. Provider tokens and token-account settings live in the CodexBar config file with restrictive file permissions. See the discussion and audit notes in [issue #12](https://github.com/steipete/CodexBar/issues/12).
 
 ## macOS permissions (why they’re needed)
-- **Full Disk Access (optional)**: only required to read Safari cookies/local storage for web-based providers (Codex web, Claude web, Cursor, Droid/Factory). If you don’t grant it, use Chrome/Firefox cookies or CLI-only sources instead.
+- **Full Disk Access (optional)**: only required to read Safari cookies/local storage for web-based providers. If you don’t grant it, use another supported browser, manual cookies/API keys, OAuth, or CLI/local sources where that provider supports them.
 - **Keychain access (prompted by macOS)**:
-  - Chrome cookie import needs the “Chrome Safe Storage” key to decrypt cookies.
-  - Claude OAuth credentials (written by the Claude CLI) are read from Keychain when present.
-  - z.ai API token is stored in Keychain from Preferences → Providers; Copilot stores its API token in Keychain during device flow.
+  - Chromium cookie import needs the browser “Safe Storage” key to decrypt cookies.
+  - Claude OAuth bootstrap may read the Claude CLI Keychain item when CodexBar has no usable cached credentials.
+  - CodexBar may use Keychain for browser cookie decryption, cached cookie headers, and OAuth/device-flow credentials where those sources require it.
   - **How do I prevent those keychain alerts?**
-    - Open **Keychain Access.app** → login keychain → search the item (e.g., “Claude Code-credentials”).
+    - Open **Keychain Access.app** → login keychain → search the prompted item (for Claude OAuth, usually “Claude Code-credentials”).
     - Open the item → **Access Control** → add `CodexBar.app` under “Always allow access by these applications”.
     - Prefer adding just CodexBar (avoid “Allow all applications” unless you want it wide open).
     - Relaunch CodexBar after saving.
     - Reference screenshot: ![Keychain access control](docs/keychain-allow.png)
   - **How to do the same for the browser?**
-    - Find the browser’s “Safe Storage” key (e.g., “Chrome Safe Storage”, “Brave Safe Storage”, “Firefox”, “Microsoft Edge Safe Storage”).
+    - Find the browser’s “Safe Storage” key (e.g., “Chrome Safe Storage”, “Brave Safe Storage”, “Microsoft Edge Safe Storage”).
     - Open the item → **Access Control** → add `CodexBar.app` under “Always allow access by these applications”.
     - This removes the prompt when CodexBar decrypts cookies for that browser.
-- **Files & Folders prompts (folder/volume access)**: CodexBar launches provider CLIs (codex/claude/gemini/antigravity). If those CLIs read a project directory or external drive, macOS may ask CodexBar for that folder/volume (e.g., Desktop or an external volume). This is driven by the CLI’s working directory, not background disk scanning.
-- **What we do not request**: no Screen Recording, Accessibility, or Automation permissions; no passwords are stored (browser cookies are reused when you opt in).
+  - **Last resort — stop all Keychain reads entirely**: if "Always Allow" doesn't stick (e.g., macOS resets the ACL after a Chromium update or a `partition_id` reset), open **CodexBar → Settings → Advanced → Keychain access** and enable **Disable Keychain access**. CodexBar will no longer touch the Keychain. Browser-cookie-based providers will be skipped, but Claude/Codex OAuth via the CLI still works (it reads `~/.codex` / `~/.claude` config files, not the Keychain).
+  - **Prompt after uninstall?** Deleting the app prevents a new launch from that bundle, but an already-running CodexBar process can keep requesting Keychain access until it quits. Check for that process, a Login Item, another installed copy, or a prompt that names a different requesting binary/path. See [Keychain prompt troubleshooting](docs/keychain-prompts.md) for safe checks and what to include in a support report without sharing secrets.
+- **Files & Folders prompts (folder/volume access)**: CodexBar launches provider CLIs and local probes for some providers. If those helpers read a project directory or external drive, macOS may ask CodexBar for that folder/volume (e.g., Desktop or an external volume). This is driven by the helper’s working directory, not background disk scanning.
+- **What we do not request in the background**: no Screen Recording or Accessibility permissions; user-triggered helper actions may ask macOS for Automation permission to open Terminal. No passwords are stored (browser cookies are reused when you opt in).
 
 ## Docs
 - Providers overview: [docs/providers.md](docs/providers.md)
 - Provider authoring: [docs/provider.md](docs/provider.md)
+- Issue labeling guide: [docs/ISSUE_LABELING.md](docs/ISSUE_LABELING.md)
 - UI & icon notes: [docs/ui.md](docs/ui.md)
 - CLI reference: [docs/cli.md](docs/cli.md)
+- Configuration: [docs/configuration.md](docs/configuration.md)
+- Keychain prompts: [docs/keychain-prompts.md](docs/keychain-prompts.md)
+- CLI configuration: [docs/cli-configuration.md](docs/cli-configuration.md)
+- Widgets: [docs/widgets.md](docs/widgets.md)
 - Architecture: [docs/architecture.md](docs/architecture.md)
 - Refresh loop: [docs/refresh-loop.md](docs/refresh-loop.md)
 - Status polling: [docs/status.md](docs/status.md)
 - Sparkle updates: [docs/sparkle.md](docs/sparkle.md)
+- Packaging: [docs/packaging.md](docs/packaging.md)
+- Development: [docs/DEVELOPMENT.md](docs/DEVELOPMENT.md)
 - Release checklist: [docs/RELEASING.md](docs/RELEASING.md)
+- Changelog: [CHANGELOG.md](CHANGELOG.md)
 
 ## Getting started (dev)
 - Clone the repo and open it in Xcode or run the scripts directly.
 - Launch once, then toggle providers in Settings → Providers.
-- Install/sign in to provider sources you rely on (CLIs, browser cookies, or OAuth).
+- Install/sign in to provider sources you rely on (CLIs, browser cookies, OAuth/device flow, API keys, or local app/config files).
 - Optional: set OpenAI cookies (Automatic or Manual) for Codex dashboard extras.
 
 ## Build from source
+Requires macOS 14+ and Swift 6.2+.
+
 ```bash
-swift build -c release          # or debug for development
 ./Scripts/package_app.sh        # builds CodexBar.app in-place
 CODEXBAR_SIGNING=adhoc ./Scripts/package_app.sh  # ad-hoc signing (no Apple Developer account)
 open CodexBar.app
@@ -117,6 +210,15 @@ open CodexBar.app
 Dev loop:
 ```bash
 ./Scripts/compile_and_run.sh
+./Scripts/compile_and_run.sh --test  # also run the sharded test suite before packaging/relaunching
+make check                           # SwiftFormat + SwiftLint
+make docs-list                       # list docs with frontmatter summaries
+```
+
+CLI install:
+```bash
+# after installing CodexBar.app in /Applications
+./bin/install-codexbar-cli.sh
 ```
 
 ## Related
@@ -127,6 +229,15 @@ Dev loop:
 ## Looking for a Windows version?
 - [Win-CodexBar](https://github.com/Finesssee/Win-CodexBar)
 
+## Linux desktop integration?
+- [codexbar-waybar](https://github.com/Marouan-chak/codexbar-waybar) — Waybar custom module + GTK4 popover for Hyprland / Sway / other Wayland compositors, built on top of the bundled Linux CLI.
+- [Codexbar GNOME](https://extensions.gnome.org/extension/9841/codexbar/) — GNOME Shell extension that brings CodexBar usage into the desktop panel.
+- [noctalia-codex-usage](https://github.com/rayoplateado/noctalia-codex-usage) — Noctalia/Quickshell plugin that shows Codex 5-hour and weekly usage limits, built on top of the bundled Linux CLI.
+- [KodexBar](https://github.com/tylxr59/KodexBar) — KDE Plasma widget that shows CodexBar usage in the Plasma panel, built on top of the bundled Linux CLI.
+
+## Status bar & terminal integration
+- [showy-quota](https://github.com/enieuwy/showy-quota) — always-on AI plan quota strips for SketchyBar, tmux, and Zellij (standalone WASM plugin), built on `codexbar serve` / the bundled CLI.
+
 ## Credits
 Inspired by [ccusage](https://github.com/ryoppippi/ccusage) (MIT), specifically the cost usage tracking.
 
diff --git a/Scripts/analyze_quotio.sh b/Scripts/analyze_quotio.sh
index e3c6e76a17..2a4186e363 100755
--- a/Scripts/analyze_quotio.sh
+++ b/Scripts/analyze_quotio.sh
@@ -1,8 +1,8 @@
-#!/bin/bash
+#!/usr/bin/env bash
 # Analyze quotio repository for interesting patterns and features
 # Usage: ./Scripts/analyze_quotio.sh [feature-area]
 
-set -e
+set -euo pipefail
 
 AREA=${1:-all}
 
@@ -19,26 +19,53 @@ git fetch quotio 2>/dev/null || {
     git remote add quotio https://github.com/nguyenphutrong/quotio.git
     git fetch quotio
 }
+remote_default_branch() {
+    local remote=$1
+    local branch=""
+    local candidate
+
+    branch=$(git symbolic-ref -q --short "refs/remotes/${remote}/HEAD" 2>/dev/null | sed "s#^${remote}/##" || true)
+    if [ -z "$branch" ]; then
+        branch=$(git remote show "$remote" 2>/dev/null | awk '/HEAD branch/ {print $NF; exit}' || true)
+    fi
+    if [ -n "$branch" ] && git rev-parse --verify -q "${remote}/${branch}" >/dev/null; then
+        echo "$branch"
+        return 0
+    fi
+
+    for candidate in main master; do
+        if git rev-parse --verify -q "${remote}/${candidate}" >/dev/null; then
+            echo "$candidate"
+            return 0
+        fi
+    done
+
+    echo -e "${RED}Error: Could not resolve default branch for remote '$remote'.${NC}" >&2
+    exit 1
+}
+
+QUOTIO_BRANCH=$(remote_default_branch quotio)
+QUOTIO_REF="quotio/${QUOTIO_BRANCH}"
 
 echo ""
-echo -e "${GREEN}==> Quotio Repository Analysis${NC}"
+echo -e "${GREEN}==> Quotio Repository Analysis (${QUOTIO_REF})${NC}"
 echo ""
 
 # Show recent activity
 echo -e "${BLUE}Recent Activity (last 30 days):${NC}"
-git log --oneline --graph --remotes=quotio/main --since="30 days ago" | head -20
+git log --oneline --graph "$QUOTIO_REF" --since="30 days ago" | head -20 || true
 echo ""
 
 # Analyze file structure
 echo -e "${BLUE}File Structure:${NC}"
-git ls-tree -r --name-only quotio/main | grep -E '\.(swift|md)$' | head -30
+git ls-tree -r --name-only "$QUOTIO_REF" | grep -E '\.(swift|md)$' | head -30 || true
 echo ""
 
 # Find interesting patterns based on area
 case $AREA in
     "providers"|"all")
         echo -e "${BLUE}Provider Implementations:${NC}"
-        git ls-tree -r --name-only quotio/main | grep -i provider | head -20
+        git ls-tree -r --name-only "$QUOTIO_REF" | grep -i provider | head -20 || true
         echo ""
         ;;
 esac
@@ -46,7 +73,7 @@ esac
 case $AREA in
     "ui"|"all")
         echo -e "${BLUE}UI Components:${NC}"
-        git ls-tree -r --name-only quotio/main | grep -iE '(view|ui|menu)' | head -20
+        git ls-tree -r --name-only "$QUOTIO_REF" | grep -iE '(view|ui|menu)' | head -20 || true
         echo ""
         ;;
 esac
@@ -54,14 +81,14 @@ esac
 case $AREA in
     "auth"|"all")
         echo -e "${BLUE}Authentication/Session:${NC}"
-        git ls-tree -r --name-only quotio/main | grep -iE '(auth|session|cookie|login)' | head -20
+        git ls-tree -r --name-only "$QUOTIO_REF" | grep -iE '(auth|session|cookie|login)' | head -20 || true
         echo ""
         ;;
 esac
 
 # Show commit messages for pattern analysis
 echo -e "${BLUE}Recent Commit Messages (for pattern analysis):${NC}"
-git log --oneline quotio/main --since="60 days ago" | head -30
+git log --oneline "$QUOTIO_REF" --since="60 days ago" | head -30 || true
 echo ""
 
 # Create analysis report
@@ -70,20 +97,21 @@ cat > "$REPORT_FILE" << EOF
 # Quotio Analysis Report
 **Date:** $(date +%Y-%m-%d)
 **Purpose:** Identify patterns and features for CodexBar fork inspiration
+**Source ref:** \`$QUOTIO_REF\`
 
 ## Recent Activity
 \`\`\`
-$(git log --oneline --graph --remotes=quotio/main --since="30 days ago" | head -20)
+$(git log --oneline --graph "$QUOTIO_REF" --since="30 days ago" | head -20 || true)
 \`\`\`
 
 ## File Structure
 \`\`\`
-$(git ls-tree -r --name-only quotio/main | grep -E '\.(swift|md)$' | head -50)
+$(git ls-tree -r --name-only "$QUOTIO_REF" | grep -E '\.(swift|md)$' | head -50 || true)
 \`\`\`
 
 ## Recent Commits
 \`\`\`
-$(git log --oneline quotio/main --since="60 days ago" | head -30)
+$(git log --oneline "$QUOTIO_REF" --since="60 days ago" | head -30 || true)
 \`\`\`
 
 ## Areas of Interest
@@ -124,16 +152,15 @@ echo ""
 echo -e "${YELLOW}Next steps:${NC}"
 echo ""
 echo "1. View specific files:"
-echo "   ${GREEN}git show quotio/main:path/to/file${NC}"
+echo "   ${GREEN}git show $QUOTIO_REF:path/to/file${NC}"
 echo ""
 echo "2. Compare implementations:"
-echo "   ${GREEN}git diff main quotio/main -- path/to/similar/file${NC}"
+echo "   ${GREEN}git diff main $QUOTIO_REF -- path/to/similar/file${NC}"
 echo ""
 echo "3. Review commit details:"
-echo "   ${GREEN}git log -p quotio/main --since='30 days ago'${NC}"
+echo "   ${GREEN}git log -p $QUOTIO_REF --since='30 days ago'${NC}"
 echo ""
 echo "4. Document patterns in:"
 echo "   ${GREEN}docs/QUOTIO_ANALYSIS.md${NC}"
 echo ""
 echo -e "${BLUE}Remember: Adapt patterns, don't copy code!${NC}"
-
diff --git a/Scripts/changelog-to-html.sh b/Scripts/changelog-to-html.sh
index 412a759dbb..9311e6c3fa 100755
--- a/Scripts/changelog-to-html.sh
+++ b/Scripts/changelog-to-html.sh
@@ -1,89 +1,4 @@
 #!/usr/bin/env bash
 set -euo pipefail
-
-VERSION=${1:-}
-CHANGELOG_FILE=${2:-}
-
-if [[ -z "$VERSION" ]]; then
-  echo "Usage: $0 <version> [changelog_file]" >&2
-  exit 1
-fi
-
 SCRIPT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
-if [[ -z "$CHANGELOG_FILE" ]]; then
-  if [[ -f "$SCRIPT_DIR/../CHANGELOG.md" ]]; then
-    CHANGELOG_FILE="$SCRIPT_DIR/../CHANGELOG.md"
-  elif [[ -f "CHANGELOG.md" ]]; then
-    CHANGELOG_FILE="CHANGELOG.md"
-  elif [[ -f "../CHANGELOG.md" ]]; then
-    CHANGELOG_FILE="../CHANGELOG.md"
-  else
-    echo "Error: Could not find CHANGELOG.md" >&2
-    exit 1
-  fi
-fi
-
-if [[ ! -f "$CHANGELOG_FILE" ]]; then
-  echo "Error: Changelog file '$CHANGELOG_FILE' not found" >&2
-  exit 1
-fi
-
-extract_version_section() {
-  local version=$1
-  local file=$2
-  awk -v version="$version" '
-    BEGIN { found=0 }
-    /^## / {
-      if ($0 ~ "^##[[:space:]]+" version "([[:space:]].*|$)") { found=1; next }
-      if (found) { exit }
-    }
-    found { print }
-  ' "$file"
-}
-
-markdown_to_html() {
-  local text=$1
-  text=$(echo "$text" | sed 's/^### \(.*\)$/<h3>\1<\/h3>/')
-  text=$(echo "$text" | sed 's/^## \(.*\)$/<h2>\1<\/h2>/')
-  text=$(echo "$text" | sed 's/^- \*\*\([^*]*\)\*\*\(.*\)$/<li><strong>\1<\/strong>\2<\/li>/')
-  text=$(echo "$text" | sed 's/^- \([^*].*\)$/<li>\1<\/li>/')
-  text=$(echo "$text" | sed 's/\*\*\([^*]*\)\*\*/<strong>\1<\/strong>/g')
-  text=$(echo "$text" | sed 's/`\([^`]*\)`/<code>\1<\/code>/g')
-  text=$(echo "$text" | sed 's/\[\([^]]*\)\](\([^)]*\))/<a href="\2">\1<\/a>/g')
-  echo "$text"
-}
-
-version_content=$(extract_version_section "$VERSION" "$CHANGELOG_FILE")
-if [[ -z "$version_content" ]]; then
-  echo "<h2>CodexBar $VERSION</h2>"
-  echo "<p>Latest CodexBar update.</p>"
-  echo "<p><a href=\"https://github.com/steipete/CodexBar/blob/main/CHANGELOG.md\">View full changelog</a></p>"
-  exit 0
-fi
-
-echo "<h2>CodexBar $VERSION</h2>"
-
-in_list=false
-while IFS= read -r line; do
-  if [[ "$line" =~ ^- ]]; then
-    if [[ "$in_list" == false ]]; then
-      echo "<ul>"
-      in_list=true
-    fi
-    markdown_to_html "$line"
-  else
-    if [[ "$in_list" == true ]]; then
-      echo "</ul>"
-      in_list=false
-    fi
-    if [[ -n "$line" ]]; then
-      markdown_to_html "$line"
-    fi
-  fi
-done <<< "$version_content"
-
-if [[ "$in_list" == true ]]; then
-  echo "</ul>"
-fi
-
-echo "<p><a href=\"https://github.com/steipete/CodexBar/blob/main/CHANGELOG.md\">View full changelog</a></p>"
+exec "$SCRIPT_DIR/mac-release" changelog-html "$@"
diff --git a/Scripts/check-app-locales.mjs b/Scripts/check-app-locales.mjs
new file mode 100644
index 0000000000..e36b1df3a2
--- /dev/null
+++ b/Scripts/check-app-locales.mjs
@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const resources = path.join(repoRoot, "Sources/CodexBar/Resources");
+const english = readCatalog("en");
+const englishKeys = Object.keys(english).sort();
+const strictLocales = ["ar", "fa", "th"];
+const languageKeys = ["language_arabic", "language_persian", "language_thai"];
+const isTest = process.argv.includes("--test");
+
+function readCatalog(locale) {
+  const file = path.join(resources, `${locale}.lproj/Localizable.strings`);
+  if (!fs.existsSync(file)) return null;
+  const output = execFileSync("plutil", ["-convert", "json", "-o", "-", file], { encoding: "utf8" });
+  return JSON.parse(output);
+}
+
+function tokenSignature(value) {
+  // Exclude explicit `%%`, which does not consume an argument.
+  const withoutEscapedPercents = value.replace(/%%/g, "");
+  const printfRaw = withoutEscapedPercents.match(/%(?:\d+\$)?(?:\.\d+)?(?:@|d|f)/g) ?? [];
+
+  const printf = {};
+  let implicitIndex = 1;
+  for (const token of printfRaw) {
+    const match = token.match(/%(\d+)\$.*?([@df])/);
+    if (match) {
+      printf[Number.parseInt(match[1], 10)] = match[2];
+    } else {
+      printf[implicitIndex] = token.at(-1);
+      implicitIndex += 1;
+    }
+  }
+
+  return { printf, swift: swiftInterpolationTokens(value).sort() };
+}
+
+function formatKeyList(keys, limit = 12) {
+  const shown = keys.slice(0, limit).join(", ");
+  const remaining = keys.length - limit;
+  return remaining > 0 ? `${shown}, ... +${remaining} more` : shown;
+}
+
+function swiftInterpolationTokens(value) {
+  const tokens = [];
+  for (let index = 0; index < value.length - 1; index += 1) {
+    if (value[index] !== "\\" || value[index + 1] !== "(") continue;
+
+    const start = index;
+    let depth = 1;
+    index += 2;
+    while (index < value.length && depth > 0) {
+      if (value[index] === "(") depth += 1;
+      if (value[index] === ")") depth -= 1;
+      index += 1;
+    }
+    tokens.push(value.slice(start, index));
+    index -= 1;
+  }
+  return tokens;
+}
+
+if (isTest) {
+  assertEqual(tokenSignature("%1$@ · %2$d"), tokenSignature("%2$d · %1$@"), "positional reorder");
+  assertNotEqual(tokenSignature("%1$@ · %2$d"), tokenSignature("%1$d · %2$@"), "positional type swap");
+  assertEqual(tokenSignature("%.0f%% used"), tokenSignature("%.0f%% verbraucht"), "escaped percent");
+  assertNotEqual(tokenSignature("\\(name): \\(usage)"), tokenSignature("\\(name): \\(value)"), "Swift tokens");
+  assertEqual(
+    tokenSignature("\\(self.store.metadata(for: self.provider).displayName) failed"),
+    tokenSignature("Fehler: \\(self.store.metadata(for: self.provider).displayName)"),
+    "nested Swift interpolation");
+  assertNotEqual(
+    tokenSignature("\\(self.store.metadata(for: self.provider).displayName) failed"),
+    tokenSignature("\\(self.store.metadata(for: self.provider) failed"),
+    "truncated Swift interpolation");
+  assertEqual(formatKeyList(["alpha", "beta"]), "alpha, beta", "short key list");
+  assertEqual(
+    formatKeyList(["alpha", "beta", "gamma", "delta"], 2),
+    "alpha, beta, ... +2 more",
+    "truncated key list");
+  console.log("app locale checker tests OK");
+  process.exit(0);
+}
+
+let hasErrors = false;
+let checkedCount = 0;
+
+for (const strictLocale of strictLocales) {
+  const dirPath = path.join(resources, `${strictLocale}.lproj`);
+  if (!fs.existsSync(dirPath)) {
+    console.error(`\x1b[31mError: Required strict locale catalog is completely missing: ${strictLocale}.lproj\x1b[0m`);
+    hasErrors = true;
+  }
+}
+
+for (const directory of fs.readdirSync(resources).filter((name) => name.endsWith(".lproj"))) {
+  const locale = directory.replace(/\.lproj$/, "");
+  if (locale === "en" || locale === "Base") continue;
+  
+  const catalog = readCatalog(locale);
+  if (!catalog) continue;
+
+  checkedCount++;
+  const catalogKeys = Object.keys(catalog);
+
+  // 1. Missing keys
+  const missingKeys = englishKeys.filter((key) => !catalogKeys.includes(key));
+  if (missingKeys.length > 0) {
+    const missingKeyList = formatKeyList(missingKeys);
+    if (strictLocales.includes(locale)) {
+      console.error(
+        `\x1b[31m[${locale}] Error: Missing ${missingKeys.length} keys in strict locale: ${missingKeyList}.\x1b[0m`);
+      hasErrors = true;
+    } else {
+      console.warn(`\x1b[33m[${locale}] Warning: Missing ${missingKeys.length} keys: ${missingKeyList}.\x1b[0m`);
+    }
+  }
+
+  const extraKeys = catalogKeys.filter((key) => !englishKeys.includes(key));
+  if (strictLocales.includes(locale) && extraKeys.length > 0) {
+    console.error(`\x1b[31m[${locale}] Error: Found ${extraKeys.length} extra keys in strict locale.\x1b[0m`);
+    hasErrors = true;
+  }
+
+  // Ensure critical language keys are present in ALL locales
+  for (const key of languageKeys) {
+    if (!catalog[key] || !catalog[key].trim()) {
+      console.error(`\x1b[31m[${locale}] Error: Missing critical language key "${key}".\x1b[0m`);
+      hasErrors = true;
+    }
+  }
+
+  // 2. Identical values count
+  let identicalCount = 0;
+
+  for (const key of englishKeys) {
+    if (!catalog[key]?.trim()) {
+      if (strictLocales.includes(locale) && catalogKeys.includes(key)) {
+        console.error(`\x1b[31m[${locale}] Error: Blank value for strict locale key "${key}".\x1b[0m`);
+        hasErrors = true;
+      }
+      continue;
+    }
+
+    if (catalog[key] === english[key]) {
+      identicalCount++;
+    }
+
+    // 3. Format placeholder mismatch
+    const tEn = tokenSignature(english[key]);
+    const tLoc = tokenSignature(catalog[key]);
+    if (JSON.stringify(tEn) !== JSON.stringify(tLoc)) {
+      console.error(`\x1b[31m[${locale}] Error: Token mismatch for key "${key}"\x1b[0m`);
+      console.error(`  en: ${english[key]}  Tokens: ${JSON.stringify(tEn)}`);
+      console.error(`  ${locale}: ${catalog[key]}  Tokens: ${JSON.stringify(tLoc)}`);
+      hasErrors = true;
+    }
+  }
+
+  // Warn if identical translation count exceeds 15% of the total keys (approx > 150 out of 1050)
+  const identicalRatio = identicalCount / englishKeys.length;
+  if (identicalRatio > 0.15) {
+    console.warn(`\x1b[33m[${locale}] Warning: High number of identical translations: ${identicalCount}/${englishKeys.length} (${(identicalRatio * 100).toFixed(1)}%)\x1b[0m`);
+  }
+}
+
+if (hasErrors) {
+  console.error("\n\x1b[31mApp locale checks failed.\x1b[0m");
+  process.exit(1);
+}
+
+console.log(`\n\x1b[32mApp locales OK: Checked ${checkedCount} catalogs against ${englishKeys.length} English keys.\x1b[0m`);
+
+function assertEqual(actual, expected, label) {
+  if (JSON.stringify(actual) !== JSON.stringify(expected)) {
+    throw new Error(`${label}: expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
+  }
+}
+
+function assertNotEqual(actual, expected, label) {
+  if (JSON.stringify(actual) === JSON.stringify(expected)) {
+    throw new Error(`${label}: signatures unexpectedly match`);
+  }
+}
diff --git a/Scripts/check-documentation-links.mjs b/Scripts/check-documentation-links.mjs
new file mode 100644
index 0000000000..3ff61b3727
--- /dev/null
+++ b/Scripts/check-documentation-links.mjs
@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+const readme = readText("README.md");
+const readmeLinks = [
+  ...markdownLinks(readme),
+  ...markdownImageLinks(readme),
+  ...htmlLinks(readme),
+].filter(isRepositoryDocReference);
+
+assert(readmeLinks.length > 0, "README.md has no local documentation links");
+for (const link of readmeLinks) validateLocalDocLink(link);
+
+const providerLinks = inlineCodeDocLinks(readText("docs/providers.md"));
+assert(providerLinks.length > 0, "docs/providers.md has no provider detail links");
+for (const link of providerLinks) validateLocalDocLink(link);
+
+console.log(`documentation links OK: ${readmeLinks.length + providerLinks.length} local links`);
+
+function readText(relativePath) {
+  return fs.readFileSync(path.join(repoRoot, relativePath), "utf8");
+}
+
+function markdownLinks(markdown) {
+  const source = markdownTextOutsideCode(markdown);
+  const links = [];
+  const inlinePattern = /(?<!!)\[(?:\\.|[^\]\\])+\]\(\s*(?:<([^>\n]+)>|([^\s)]+))(?:\s+(?:"[^"\n]*"|'[^'\n]*'|\([^)\n]*\)))?\s*\)/g;
+  for (const match of source.matchAll(inlinePattern)) {
+    links.push(encodeSpaces(match[1] ?? match[2]));
+  }
+
+  const referencePattern = /^\s*\[[^\]\n]+]:\s*(?:<([^>\n]+)>|([^\s]+))/gm;
+  for (const match of source.matchAll(referencePattern)) {
+    links.push(encodeSpaces(match[1] ?? match[2]));
+  }
+  return links;
+}
+
+function markdownImageLinks(markdown) {
+  const source = markdownTextOutsideCode(markdown);
+  const pattern = /!\[(?:\\.|[^\]\\])*\]\(\s*(?:<([^>\n]+)>|([^\s)]+))(?:\s+(?:"[^"\n]*"|'[^'\n]*'|\([^)\n]*\)))?\s*\)/g;
+  return [...source.matchAll(pattern)].map((match) => match[1] ?? match[2]);
+}
+
+function htmlLinks(markdown) {
+  const source = markdownTextOutsideCode(markdown);
+  const pattern = /<\s*(?:a|img)\b[^>]*?\b(?:href|src)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+))/gi;
+  return [...source.matchAll(pattern)].map((match) => match[1] ?? match[2] ?? match[3]);
+}
+
+function inlineCodeDocLinks(markdown) {
+  return markdown.split("\n").flatMap((line) => {
+    const trimmed = line.trim();
+    const prefix = "- Details: `";
+    if (!trimmed.startsWith(prefix)) return [];
+    const rest = trimmed.slice(prefix.length);
+    const end = rest.indexOf("`");
+    return end === -1 ? [] : [rest.slice(0, end)];
+  });
+}
+
+function validateLocalDocLink(rawLink) {
+  const { absolutePath, fragment } = localDocPath(rawLink);
+  assert(fs.existsSync(absolutePath), `missing documentation target: ${rawLink}`);
+
+  if (path.extname(absolutePath).toLowerCase() !== ".md" || !fragment) return;
+  const anchors = markdownHeadingAnchors(readText(path.relative(repoRoot, absolutePath)));
+  assert(anchors.has(fragment), `missing documentation anchor: ${rawLink}`);
+}
+
+function isRepositoryDocReference(rawLink) {
+  const parsed = parseRelativeURL(rawLink);
+  if (!parsed || parsed.protocol || parsed.host) return false;
+  let pathname = parsed.pathname;
+  while (pathname.startsWith("./")) pathname = pathname.slice(2);
+  return pathname === "docs" || pathname.startsWith("docs/");
+}
+
+function localDocPath(rawLink) {
+  const parsed = parseRelativeURL(rawLink);
+  assert(parsed && !parsed.protocol && !parsed.host && parsed.pathname, `invalid documentation URL: ${rawLink}`);
+
+  const decodedPath = decodeURIComponent(parsed.pathname);
+  const absolutePath = path.resolve(repoRoot, decodedPath);
+  const docsRoot = path.resolve(repoRoot, "docs");
+  assert(
+    absolutePath === docsRoot || absolutePath.startsWith(`${docsRoot}${path.sep}`),
+    `documentation link escapes docs root: ${rawLink}`,
+  );
+  return { absolutePath, fragment: parsed.hash ? decodeURIComponent(parsed.hash.slice(1)) : "" };
+}
+
+function parseRelativeURL(rawLink) {
+  try {
+    const parsed = new URL(rawLink, "relative://repo/");
+    const isRelative = parsed.protocol === "relative:" && parsed.host === "repo";
+    return {
+      protocol: isRelative ? "" : parsed.protocol,
+      host: isRelative ? "" : parsed.host,
+      pathname: isRelative ? parsed.pathname.replace(/^\//, "") : parsed.pathname,
+      hash: parsed.hash,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function markdownHeadingAnchors(markdown) {
+  const occurrences = new Map();
+  const anchors = new Set();
+  const source = markdownTextOutsideFencedCode(markdown);
+  for (const line of source.split("\n")) {
+    const trimmed = line.replace(/^[ \t]+/, "");
+    const match = /^(#{1,6})\s+(.+?)\s*$/.exec(trimmed);
+    if (!match) continue;
+    const base = markdownHeadingSlug(match[2]);
+    if (!base) continue;
+    const occurrence = occurrences.get(base) ?? 0;
+    anchors.add(occurrence === 0 ? base : `${base}-${occurrence}`);
+    occurrences.set(base, occurrence + 1);
+  }
+  return anchors;
+}
+
+function markdownHeadingSlug(heading) {
+  const text = removeMarkdownFormatting(heading).toLowerCase();
+  let slug = "";
+  for (const char of text) {
+    if (/[\p{Letter}\p{Number}_-]/u.test(char)) {
+      slug += char;
+    } else if (/\s/u.test(char)) {
+      slug += "-";
+    }
+  }
+  return slug;
+}
+
+function removeMarkdownFormatting(text) {
+  return text
+    .replace(/`([^`]*)`/g, "$1")
+    .replace(/\[([^\]]+)]\([^)]+\)/g, "$1")
+    .replace(/[*_~]/g, "");
+}
+
+function markdownTextOutsideCode(markdown) {
+  return markdownTextOutsideFencedCode(markdown)
+    .split("\n")
+    .map(removeInlineCode)
+    .join("\n");
+}
+
+function markdownTextOutsideFencedCode(markdown) {
+  let fence = null;
+  return markdown.split("\n").map((line) => {
+    if (fence) {
+      if (isClosingFence(line, fence.marker, fence.count)) fence = null;
+      return "";
+    }
+    const openingFence = parseOpeningFence(line);
+    if (openingFence) {
+      fence = openingFence;
+      return "";
+    }
+    return line;
+  }).join("\n");
+}
+
+function parseOpeningFence(line) {
+  const match = /^( {0,3})([`~]{3,})(.*)$/.exec(line);
+  if (!match) return null;
+  const marker = match[2][0];
+  if (marker === "`" && match[3].includes("`")) return null;
+  return { marker, count: match[2].length };
+}
+
+function isClosingFence(line, marker, minimumCount) {
+  const escaped = marker === "`" ? "`" : "~";
+  const pattern = new RegExp(`^ {0,3}${escaped}{${minimumCount},}\\s*$`);
+  return pattern.test(line);
+}
+
+function removeInlineCode(line) {
+  return line.replace(/(?<!`)(`+)(?!`)(.*?)(?<!`)\1(?!`)/g, "");
+}
+
+function encodeSpaces(value) {
+  return value.replaceAll(" ", "%20");
+}
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
diff --git a/Scripts/check-release-assets.sh b/Scripts/check-release-assets.sh
index 4251ef6a2a..ffb2237329 100755
--- a/Scripts/check-release-assets.sh
+++ b/Scripts/check-release-assets.sh
@@ -1,10 +1,4 @@
 #!/usr/bin/env bash
 set -euo pipefail
-
-ROOT=$(cd "$(dirname "$0")/.." && pwd)
-source "$HOME/Projects/agent-scripts/release/sparkle_lib.sh"
-
-TAG=${1:-$(git describe --tags --abbrev=0)}
-ARTIFACT_PREFIX="CodexBar-"
-
-check_assets "$TAG" "$ARTIFACT_PREFIX"
+SCRIPT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+exec "$SCRIPT_DIR/mac-release" check-assets "$@"
diff --git a/Scripts/check-site-locales.mjs b/Scripts/check-site-locales.mjs
new file mode 100644
index 0000000000..0adf7d6e09
--- /dev/null
+++ b/Scripts/check-site-locales.mjs
@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { localeCatalog, localeMessages } from "../docs/site-locales.mjs";
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const indexHtml = fs.readFileSync(path.join(repoRoot, "docs/index.html"), "utf8");
+const expectedCodes = [
+  "en", "zh-CN", "zh-TW", "ja-JP", "es", "pt-BR", "ko", "de", "fr", "ar", "it",
+  "vi", "nl", "tr", "uk", "id", "pl", "fa", "th", "ca", "sv",
+];
+const catalogCodes = localeCatalog.map((locale) => locale.code);
+const appLanguageSource = fs.readFileSync(
+  path.join(repoRoot, "Sources/CodexBar/PreferencesGeneralPane.swift"),
+  "utf8",
+);
+
+assertEqual(catalogCodes, expectedCodes, "locale catalog");
+assertEqual(
+  localeCatalog.filter((locale) => locale.direction === "rtl").map((locale) => locale.code),
+  ["ar", "fa"],
+  "RTL locale catalog");
+const appCatalogCodes = [...appLanguageSource.matchAll(/case \w+ = "([^"]+)"/g)]
+  .map((match) => match[1])
+  .filter(Boolean)
+  .map((code) => ({ "zh-Hans": "zh-CN", "zh-Hant": "zh-TW", ja: "ja-JP" })[code] ?? code);
+assertEqual(appCatalogCodes, expectedCodes, "app language catalog");
+
+const englishKeys = Object.keys(localeMessages.en).sort();
+for (const locale of localeCatalog) {
+  const messages = localeMessages[locale.code];
+  assert(messages, `missing messages for ${locale.code}`);
+  assertEqual(Object.keys(messages).sort(), englishKeys, `${locale.code} message keys`);
+
+  for (const key of englishKeys) {
+    assert(messages[key].trim(), `${locale.code}.${key} is blank`);
+    assertEqual(tokens(messages[key]), tokens(localeMessages.en[key]), `${locale.code}.${key} tokens`);
+  }
+}
+
+const referencedKeys = new Set();
+for (const match of indexHtml.matchAll(/data-i18n(?:-rich|-aria-label|-title|-alt)?="([^"]+)"/g)) {
+  referencedKeys.add(match[1]);
+}
+for (const key of referencedKeys) {
+  assert(englishKeys.includes(key), `index.html references unknown locale key ${key}`);
+}
+
+const optionMatches = [...indexHtml.matchAll(/<option value="([^"]+)">([^<]+)<\/option>/g)];
+assertEqual(optionMatches.map((match) => match[1]), catalogCodes, "language selector locales");
+assertEqual(optionMatches.map((match) => match[2]), localeCatalog.map((locale) => locale.name), "language selector labels");
+
+for (const code of catalogCodes) {
+  assert(indexHtml.includes(`href="https://codexbar.app/?lang=${code}"`), `missing hreflang URL for ${code}`);
+}
+
+const providerCards = [...indexHtml.matchAll(/<a class="provider([^"]*)"[^>]*>([\s\S]*?)<\/a>/g)];
+for (const [, classes, body] of providerCards) {
+  if (!classes.split(/\s+/).includes("add")) {
+    assert(body.includes('class="chip-logo'), "provider cards must use logo assets instead of text placeholders");
+    for (const match of body.matchAll(/(?:src|data-dark-src)="\.\/([^"]+)"/g)) {
+      assert(fs.existsSync(path.join(repoRoot, "docs", match[1])), `missing provider logo asset ${match[1]}`);
+    }
+  }
+}
+
+console.log(`app/site locales OK: ${catalogCodes.length} locales, ${englishKeys.length} site messages`);
+
+function tokens(value) {
+  return [...value.matchAll(/\{([^}]+)\}/g)].map((match) => match[1]).sort();
+}
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+function assertEqual(actual, expected, label) {
+  const actualJSON = JSON.stringify(actual);
+  const expectedJSON = JSON.stringify(expected);
+  if (actualJSON !== expectedJSON) {
+    throw new Error(`${label}: expected ${expectedJSON}, got ${actualJSON}`);
+  }
+}
diff --git a/Scripts/check_upstreams.sh b/Scripts/check_upstreams.sh
index a3ae64ee0c..18dac13546 100755
--- a/Scripts/check_upstreams.sh
+++ b/Scripts/check_upstreams.sh
@@ -1,8 +1,8 @@
-#!/bin/bash
+#!/usr/bin/env bash
 # Check for new changes in upstream repositories
 # Usage: ./Scripts/check_upstreams.sh [upstream|quotio|all]
 
-set -e
+set -euo pipefail
 
 TARGET=${1:-all}
 DAYS=${2:-7}
@@ -33,19 +33,46 @@ fi
 
 echo ""
 
+remote_default_branch() {
+    local remote=$1
+    local branch=""
+    local candidate
+
+    branch=$(git symbolic-ref -q --short "refs/remotes/${remote}/HEAD" 2>/dev/null | sed "s#^${remote}/##" || true)
+    if [ -z "$branch" ]; then
+        branch=$(git remote show "$remote" 2>/dev/null | awk '/HEAD branch/ {print $NF; exit}' || true)
+    fi
+    if [ -n "$branch" ] && git rev-parse --verify -q "${remote}/${branch}" >/dev/null; then
+        echo "$branch"
+        return 0
+    fi
+
+    for candidate in main master; do
+        if git rev-parse --verify -q "${remote}/${candidate}" >/dev/null; then
+            echo "$candidate"
+            return 0
+        fi
+    done
+
+    echo -e "${RED}Error: Could not resolve default branch for remote '$remote'.${NC}" >&2
+    exit 1
+}
+
 # Check upstream (steipete)
 if [ "$TARGET" = "all" ] || [ "$TARGET" = "upstream" ]; then
     echo -e "${BLUE}==> Upstream (steipete/CodexBar) changes:${NC}"
+    UPSTREAM_BRANCH=$(remote_default_branch upstream)
+    UPSTREAM_REF="upstream/${UPSTREAM_BRANCH}"
     
-    UPSTREAM_COUNT=$(git log --oneline main..upstream/main --no-merges 2>/dev/null | wc -l | tr -d ' ')
+    UPSTREAM_COUNT=$(git log --oneline "main..${UPSTREAM_REF}" --no-merges 2>/dev/null | wc -l | tr -d ' ')
     
     if [ "$UPSTREAM_COUNT" -gt 0 ]; then
         echo -e "${GREEN}Found $UPSTREAM_COUNT new commits${NC}"
         echo ""
-        git log --oneline --graph main..upstream/main --no-merges | head -20
+        git log --oneline --graph "main..${UPSTREAM_REF}" --no-merges | head -20 || true
         echo ""
         echo -e "${YELLOW}Files changed:${NC}"
-        git diff --stat main..upstream/main | tail -20
+        git diff --stat "main..${UPSTREAM_REF}" | tail -20 || true
     else
         echo -e "${GREEN}No new commits (up to date)${NC}"
     fi
@@ -55,17 +82,19 @@ fi
 # Check quotio
 if [ "$TARGET" = "all" ] || [ "$TARGET" = "quotio" ]; then
     echo -e "${BLUE}==> Quotio changes (last $DAYS days):${NC}"
+    QUOTIO_BRANCH=$(remote_default_branch quotio)
+    QUOTIO_REF="quotio/${QUOTIO_BRANCH}"
     
-    QUOTIO_COUNT=$(git log --oneline --all --remotes=quotio/main --since="$DAYS days ago" 2>/dev/null | wc -l | tr -d ' ')
+    QUOTIO_COUNT=$(git log --oneline "$QUOTIO_REF" --since="$DAYS days ago" 2>/dev/null | wc -l | tr -d ' ')
     
     if [ "$QUOTIO_COUNT" -gt 0 ]; then
         echo -e "${GREEN}Found $QUOTIO_COUNT commits in last $DAYS days${NC}"
         echo ""
-        git log --oneline --graph --remotes=quotio/main --since="$DAYS days ago" | head -20
+        git log --oneline --graph "$QUOTIO_REF" --since="$DAYS days ago" | head -20 || true
         echo ""
         echo -e "${YELLOW}Recent file changes:${NC}"
         # Show changes from last 10 commits
-        git diff --stat quotio/main~10..quotio/main 2>/dev/null | tail -20 || echo "Unable to show diff"
+        git diff --stat "${QUOTIO_REF}~10..${QUOTIO_REF}" 2>/dev/null | tail -20 || echo "Unable to show diff"
     else
         echo -e "${GREEN}No new commits in last $DAYS days${NC}"
     fi
@@ -85,6 +114,5 @@ echo ""
 echo -e "${YELLOW}Next steps:${NC}"
 echo "  Review upstream: ./Scripts/review_upstream.sh upstream"
 echo "  Review quotio:   ./Scripts/review_upstream.sh quotio"
-echo "  Detailed diff:   git diff main..upstream/main"
-echo "  View quotio:     git log -p quotio/main~10..quotio/main"
-
+echo "  Detailed diff:   git diff main..<resolved-remote>/<default-branch>"
+echo "  View quotio:     ./Scripts/analyze_quotio.sh"
diff --git a/Scripts/ci_macos_test_gate.sh b/Scripts/ci_macos_test_gate.sh
new file mode 100755
index 0000000000..246bcee070
--- /dev/null
+++ b/Scripts/ci_macos_test_gate.sh
@@ -0,0 +1,97 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+changed_paths_file="${1:-}"
+
+if [[ -z "$changed_paths_file" || ! -f "$changed_paths_file" ]]; then
+  printf 'Usage: %s <changed-paths-file>\n' "$(basename "$0")" >&2
+  exit 2
+fi
+
+macos_tests=false
+macos_tests_reason=""
+path_count=0
+
+require_macos_tests() {
+  local path="$1"
+  local reason="$2"
+
+  macos_tests=true
+  if [[ -z "$macos_tests_reason" ]]; then
+    macos_tests_reason="${path}: ${reason}"
+  fi
+}
+
+classify_path() {
+  local path="$1"
+  [[ -z "$path" ]] && return
+
+  path_count=$((path_count + 1))
+
+  case "$path" in
+    AGENTS.md|docs/configuration.md)
+      require_macos_tests "$path" "changes contributor or runtime configuration contracts"
+      ;;
+    *.md)
+      ;;
+    docs/.nojekyll|docs/CNAME|docs/index.html|docs/llms.txt|docs/site-locales.mjs|docs/site.css|docs/site.js|docs/social.html|docs/social.png)
+      ;;
+    docs/*.png|docs/*.jpg|docs/*.jpeg|docs/*.webp|docs/*.ico|docs/*.svg)
+      ;;
+    *)
+      require_macos_tests "$path" "not covered by portable docs/site checks"
+      ;;
+  esac
+}
+
+invalid_row=false
+while IFS=$'\t' read -r status first_path second_path extra_path \
+  || [[ -n "${status:-}${first_path:-}${second_path:-}${extra_path:-}" ]]
+do
+  [[ -z "${status}${first_path:-}${second_path:-}${extra_path:-}" ]] && continue
+
+  case "$status" in
+    R*|C*)
+      if ! [[ "$status" =~ ^[RC][0-9]{1,3}$ ]] \
+        || ((10#${status:1} > 100)) \
+        || [[ -z "${first_path:-}" || -z "${second_path:-}" || -n "${extra_path:-}" ]]
+      then
+        invalid_row=true
+        break
+      fi
+      classify_path "$first_path"
+      classify_path "$second_path"
+      ;;
+    A|D|M|T|U|X|B)
+      if [[ -z "${first_path:-}" || -n "${second_path:-}" || -n "${extra_path:-}" ]]; then
+        invalid_row=true
+        break
+      fi
+      classify_path "$first_path"
+      ;;
+    *)
+      invalid_row=true
+      break
+      ;;
+  esac
+done < "$changed_paths_file"
+
+if [[ "$invalid_row" == true ]]; then
+  printf 'Invalid git name-status row; refusing to skip macOS tests.\n' >&2
+  exit 2
+fi
+
+if [[ "$path_count" -eq 0 ]]; then
+  require_macos_tests '<empty diff>' 'no changed paths were reported'
+fi
+
+if [[ -n "${GITHUB_OUTPUT:-}" ]]; then
+  printf 'macos-tests=%s\n' "$macos_tests" >> "$GITHUB_OUTPUT"
+fi
+
+if [[ "$macos_tests" == true ]]; then
+  printf 'macOS Swift tests required for this change set: %s.\n' "$macos_tests_reason"
+else
+  printf 'Skipping macOS Swift tests for docs/site-only changes covered by portable checks.\n'
+fi
diff --git a/Scripts/ci_swift_test_by_suite.py b/Scripts/ci_swift_test_by_suite.py
new file mode 100755
index 0000000000..5b45156ef7
--- /dev/null
+++ b/Scripts/ci_swift_test_by_suite.py
@@ -0,0 +1,211 @@
+#!/usr/bin/env python3
+"""Run SwiftPM tests in suite shards so CI cannot hang inside one aggregate run."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import re
+import signal
+import subprocess
+import sys
+from collections.abc import Iterable
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class TestSelection:
+    name: str
+    filter_pattern: str
+    suite_name: str | None = None
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--group-size", type=int, default=12)
+    parser.add_argument("--timeout", type=int, default=180)
+    parser.add_argument("--limit-groups", type=int)
+    parser.add_argument("--shard-index", type=int)
+    parser.add_argument("--shard-count", type=int)
+    parser.add_argument("--list-only", action="store_true")
+    parser.add_argument("--swift-command", default="swift")
+    parser.add_argument("--swift-command-arg", action="append", default=[])
+    return parser.parse_args()
+
+
+def run_command(command: list[str], timeout: int | None = None) -> int:
+    print(f"+ {' '.join(command)}", flush=True)
+    process = subprocess.Popen(command, start_new_session=True)
+    try:
+        return process.wait(timeout=timeout)
+    except subprocess.TimeoutExpired:
+        print(f"::warning::Command timed out after {timeout}s: {' '.join(command)}", flush=True)
+        os.killpg(process.pid, signal.SIGTERM)
+        try:
+            process.wait(timeout=10)
+        except subprocess.TimeoutExpired:
+            os.killpg(process.pid, signal.SIGKILL)
+            process.wait()
+        return 124
+
+
+def swift_test_list(swift_command: list[str]) -> list[TestSelection]:
+    command = [*swift_command, "test", "list"]
+    try:
+        result = subprocess.run(command, check=True, capture_output=True, text=True)
+    except subprocess.CalledProcessError as error:
+        print(f"+ {swift_command[0]} test list", flush=True)
+        if error.stdout:
+            print(error.stdout, end="" if error.stdout.endswith("\n") else "\n", flush=True)
+        if error.stderr:
+            print(error.stderr, end="" if error.stderr.endswith("\n") else "\n", file=sys.stderr, flush=True)
+        raise
+    selections: set[TestSelection] = set()
+    unknown: list[str] = []
+    for line in result.stdout.splitlines():
+        top_level = re.fullmatch(r"(?P<module>[^.]+)\.(?:`(?P<display>.+)`|(?P<function>[^()/]+))\(\)", line)
+        if top_level is not None:
+            module = top_level.group("module")
+            test_name = top_level.group("display") or top_level.group("function")
+            selections.add(
+                TestSelection(
+                    name=line,
+                    # SwiftPM matches top-level Swift Testing functions by their display name,
+                    # not the backtick-wrapped identifier printed by `swift test list`.
+                    filter_pattern=rf"{re.escape(module)}\..*{re.escape(test_name)}",
+                )
+            )
+            continue
+
+        if "/" in line:
+            suite = line.split("/", 1)[0]
+            if "." in suite:
+                selections.add(
+                    TestSelection(
+                        name=suite,
+                        filter_pattern=rf"^{re.escape(suite)}/",
+                        suite_name=suite,
+                    )
+                )
+                continue
+
+        unknown.append(line)
+
+    if unknown:
+        rendered = "\n".join(f"- {line}" for line in unknown)
+        raise RuntimeError(f"Unrecognized `swift test list` output:\n{rendered}")
+    return sorted(selections, key=lambda selection: selection.name)
+
+
+def chunks(items: list[TestSelection], size: int) -> Iterable[list[TestSelection]]:
+    for index in range(0, len(items), size):
+        yield items[index : index + size]
+
+
+def shard_groups(groups: list[list[TestSelection]], shard_index: int | None, shard_count: int | None) -> list[list[TestSelection]]:
+    if shard_index is None and shard_count is None:
+        return groups
+    if shard_index is None or shard_count is None:
+        raise ValueError("--shard-index and --shard-count must be passed together")
+    if shard_count < 1:
+        raise ValueError("--shard-count must be positive")
+    if shard_index < 0 or shard_index >= shard_count:
+        raise ValueError("--shard-index must be in the range [0, --shard-count)")
+    return [group for index, group in enumerate(groups) if index % shard_count == shard_index]
+
+
+def prioritized_suites(suites: list[TestSelection]) -> list[TestSelection]:
+    priority = ["CodexBarTests.CLIEntryTests"]
+    ordered = [suite for name in priority for suite in suites if suite.suite_name == name]
+    ordered.extend(suite for suite in suites if suite.suite_name not in priority)
+    return ordered
+
+
+def filtered_suites_for_environment(suites: list[TestSelection]) -> list[TestSelection]:
+    if os.environ.get("GITHUB_ACTIONS") != "true" or sys.platform != "darwin":
+        return suites
+
+    # SwiftPM hangs before suite output for this executable-target suite on the Intel macOS runner.
+    # Linux CI still runs it in the full Swift test lane, and local macOS runs it directly.
+    skipped = {"CodexBarTests.CLIEntryTests"}
+    filtered = [suite for suite in suites if suite.suite_name not in skipped]
+    if len(filtered) != len(suites):
+        print(f"Skipping macOS CI-only suites: {', '.join(sorted(skipped))}", flush=True)
+    return filtered
+
+
+def filter_for(suites: list[TestSelection]) -> str:
+    return rf"({'|'.join(suite.filter_pattern for suite in suites)})"
+
+
+def run_group(suites: list[TestSelection], timeout: int, swift_command: list[str]) -> int:
+    return run_command(
+        [*swift_command, "test", "--no-parallel", "--filter", filter_for(suites)],
+        timeout=timeout,
+    )
+
+
+def main() -> int:
+    args = parse_args()
+    if args.group_size < 1:
+        print("--group-size must be positive", file=sys.stderr)
+        return 2
+
+    swift_command = [args.swift_command, *args.swift_command_arg]
+    suites = prioritized_suites(filtered_suites_for_environment(swift_test_list(swift_command)))
+    suite_groups = list(chunks(suites, args.group_size))
+    try:
+        suite_groups = shard_groups(suite_groups, args.shard_index, args.shard_count)
+    except ValueError as error:
+        print(str(error), file=sys.stderr)
+        return 2
+    if args.limit_groups is not None:
+        suite_groups = suite_groups[: args.limit_groups]
+
+    shard_suffix = ""
+    if args.shard_index is not None and args.shard_count is not None:
+        shard_suffix = f" in shard {args.shard_index + 1}/{args.shard_count}"
+    print(f"Discovered {len(suites)} test selections; running {len(suite_groups)} groups{shard_suffix}", flush=True)
+    if args.list_only:
+        for group in suite_groups:
+            for suite in group:
+                print(suite.name)
+        return 0
+
+    if not suite_groups:
+        print("No test groups selected.", flush=True)
+        return 0
+
+    for group_index, group in enumerate(suite_groups, start=1):
+        print(
+            f"::group::Swift test shard {group_index}/{len(suite_groups)} "
+            f"({len(group)} selections)",
+            flush=True,
+        )
+        result = run_group(group, args.timeout, swift_command)
+        print("::endgroup::", flush=True)
+        if result == 0:
+            continue
+        if len(group) == 1:
+            return result
+
+        if result != 124:
+            print(f"Shard {group_index} failed with exit code {result}; retrying shard once", flush=True)
+            retry_result = run_group(group, args.timeout, swift_command)
+            if retry_result == 0:
+                continue
+            return retry_result
+
+        print(f"Shard {group_index} timed out; retrying suites one at a time", flush=True)
+        for suite in group:
+            print(f"::group::Swift test retry {suite.name}", flush=True)
+            retry_result = run_group([suite], args.timeout, swift_command)
+            print("::endgroup::", flush=True)
+            if retry_result != 0:
+                return retry_result
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/Scripts/ci_verify_test_jobs.sh b/Scripts/ci_verify_test_jobs.sh
new file mode 100755
index 0000000000..753be4f38f
--- /dev/null
+++ b/Scripts/ci_verify_test_jobs.sh
@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+lint_result="${1:-}"
+changes_result="${2:-}"
+macos_tests_required="${3:-}"
+macos_test_result="${4:-}"
+
+if [[ "$lint_result" != "success" ]]; then
+  printf 'lint job finished with %s\n' "${lint_result:-<empty>}" >&2
+  exit 1
+fi
+
+if [[ "$changes_result" != "success" ]]; then
+  printf 'changes job finished with %s\n' "${changes_result:-<empty>}" >&2
+  exit 1
+fi
+
+case "${macos_tests_required}:${macos_test_result}" in
+  true:success)
+    printf 'Lint and macOS Swift test shards passed.\n'
+    ;;
+  false:skipped)
+    printf 'Lint passed; macOS Swift tests skipped for docs/site-only changes.\n'
+    ;;
+  *)
+    printf 'macOS test gate/result mismatch: required=%s result=%s\n' \
+      "${macos_tests_required:-<empty>}" "${macos_test_result:-<empty>}" >&2
+    exit 1
+    ;;
+esac
diff --git a/Scripts/compile_and_run.sh b/Scripts/compile_and_run.sh
index ce6992d453..a0a024de61 100755
--- a/Scripts/compile_and_run.sh
+++ b/Scripts/compile_and_run.sh
@@ -16,10 +16,46 @@ RUN_TESTS=0
 DEBUG_LLDB=0
 RELEASE_ARCHES=""
 SIGNING_MODE="${CODEXBAR_SIGNING:-}"
+CLEAR_ADHOC_KEYCHAIN=0
 
 log()  { printf '%s\n' "$*"; }
 fail() { printf 'ERROR: %s\n' "$*" >&2; exit 1; }
 
+delete_keychain_service_items() {
+  local service="$1"
+  security delete-generic-password -s "${service}" >/dev/null 2>&1 || true
+  while security delete-generic-password -s "${service}" >/dev/null 2>&1; do
+    :
+  done
+}
+
+# Ensure Swift >= 5.5 (required for --arch flag in swift build)
+ensure_swift_version() {
+  local swift_output
+  local swift_ver
+  swift_output=$(swift --version 2>&1 || true)
+  if [[ "$swift_output" =~ (Apple[[:space:]]+)?Swift[[:space:]]+version[[:space:]]+([0-9]+)\.([0-9]+)(\.[0-9]+)? ]]; then
+    swift_ver="${BASH_REMATCH[2]}.${BASH_REMATCH[3]}${BASH_REMATCH[4]}"
+  else
+    fail "Swift >= 5.5 required (found ${swift_output:-none}). Install Xcode or update swiftly."
+  fi
+  local major minor
+  major=$(echo "$swift_ver" | cut -d. -f1)
+  minor=$(echo "$swift_ver" | cut -d. -f2)
+  if [[ "${major:-0}" -ge 6 ]] || { [[ "${major:-0}" -eq 5 ]] && [[ "${minor:-0}" -ge 5 ]]; }; then
+    return 0
+  fi
+  # Try Xcode toolchain
+  local xcrun_swift
+  xcrun_swift=$(xcrun --find swift 2>/dev/null || true)
+  if [[ -n "$xcrun_swift" && -x "$xcrun_swift" ]]; then
+    log "WARN: PATH swift is v${swift_ver}; switching to Xcode toolchain at $(dirname "$xcrun_swift")"
+    export PATH="$(dirname "$xcrun_swift"):$PATH"
+    return 0
+  fi
+  fail "Swift >= 5.5 required (found ${swift_ver:-none}). Install Xcode or update swiftly."
+}
+
 has_signing_identity() {
   local identity="${1:-}"
   if [[ -z "${identity}" ]]; then
@@ -28,13 +64,55 @@ has_signing_identity() {
   security find-identity -p codesigning -v 2>/dev/null | grep -F "${identity}" >/dev/null 2>&1
 }
 
+detect_codesigning_identity() {
+  local preferred_prefixes=(
+    "Developer ID Application:"
+    "Apple Development:"
+    "Apple Distribution:"
+  )
+  local prefix
+  local identities
+  identities="$(security find-identity -p codesigning -v 2>/dev/null || true)"
+  for prefix in "${preferred_prefixes[@]}"; do
+    awk -v prefix="${prefix}" '
+      index($0, "\"" prefix) {
+        sub(/^[^\"]*\"/, "")
+        sub(/\".*$/, "")
+        print
+        exit
+      }
+    ' <<<"${identities}"
+  done | sed -n '1p'
+}
+
+export_team_id_from_identity() {
+  local identity="${1:-}"
+  if [[ -n "${APP_TEAM_ID:-}" || -z "${identity}" ]]; then
+    return
+  fi
+  local subject
+  subject="$(security find-certificate -c "${identity}" -p 2>/dev/null \
+    | openssl x509 -noout -subject -nameopt RFC2253 2>/dev/null || true)"
+  if [[ "${subject}" =~ (^|,)OU=([A-Z0-9]{10})(,|$) ]]; then
+    APP_TEAM_ID="${BASH_REMATCH[2]}"
+    export APP_TEAM_ID
+    return
+  fi
+  if [[ "${identity}" =~ \(([A-Z0-9]{10})\)$ ]]; then
+    APP_TEAM_ID="${BASH_REMATCH[1]}"
+    export APP_TEAM_ID
+  fi
+}
+
 resolve_signing_mode() {
   if [[ -n "${SIGNING_MODE}" ]]; then
+    export_team_id_from_identity "${APP_IDENTITY:-}"
     return
   fi
 
   if [[ -n "${APP_IDENTITY:-}" ]]; then
     if has_signing_identity "${APP_IDENTITY}"; then
+      export_team_id_from_identity "${APP_IDENTITY}"
       SIGNING_MODE="identity"
       return
     fi
@@ -51,11 +129,21 @@ resolve_signing_mode() {
     if has_signing_identity "${candidate}"; then
       APP_IDENTITY="${candidate}"
       export APP_IDENTITY
+      export_team_id_from_identity "${APP_IDENTITY}"
       SIGNING_MODE="identity"
       return
     fi
   done
 
+  candidate="$(detect_codesigning_identity)"
+  if [[ -n "${candidate}" ]]; then
+    APP_IDENTITY="${candidate}"
+    export APP_IDENTITY
+    export_team_id_from_identity "${APP_IDENTITY}"
+    SIGNING_MODE="identity"
+    return
+  fi
+
   SIGNING_MODE="adhoc"
 }
 
@@ -152,10 +240,11 @@ for arg in "$@"; do
     --wait|-w) WAIT_FOR_LOCK=1 ;;
     --test|-t) RUN_TESTS=1 ;;
     --debug-lldb) DEBUG_LLDB=1 ;;
+    --clear-adhoc-keychain) CLEAR_ADHOC_KEYCHAIN=1 ;;
     --release-universal) RELEASE_ARCHES="arm64 x86_64" ;;
     --release-arches=*) RELEASE_ARCHES="${arg#*=}" ;;
     --help|-h)
-      log "Usage: $(basename "$0") [--wait] [--test] [--debug-lldb] [--release-universal] [--release-arches=\"arm64 x86_64\"]"
+      log "Usage: $(basename "$0") [--wait] [--test] [--debug-lldb] [--clear-adhoc-keychain] [--release-universal] [--release-arches=\"arm64 x86_64\"]"
       exit 0
       ;;
     *)
@@ -163,7 +252,11 @@ for arg in "$@"; do
   esac
 done
 
+ensure_swift_version
 resolve_signing_mode
+if [[ "${CLEAR_ADHOC_KEYCHAIN}" == "1" && "${SIGNING_MODE}" != "adhoc" ]]; then
+  fail "--clear-adhoc-keychain is only supported when using adhoc signing."
+fi
 if [[ "${SIGNING_MODE}" == "adhoc" ]]; then
   log "==> Signing: adhoc (set APP_IDENTITY or install a dev cert to avoid keychain prompts)"
 else
@@ -177,20 +270,21 @@ log "==> Killing existing CodexBar instances"
 kill_all_codexbar
 kill_claude_probes
 
-# 2.5) Delete keychain entries to avoid permission prompts with adhoc signing
+# 2.5) Optionally delete keychain entries to avoid permission prompts with adhoc signing
 # (adhoc signature changes on every build, making old keychain entries inaccessible)
-if [[ "${SIGNING_MODE:-adhoc}" == "adhoc" ]]; then
-  log "==> Clearing keychain entries (adhoc signing)"
-  security delete-generic-password -s "com.steipete.CodexBar" 2>/dev/null || true
-  # Clear all keychain items for the app to avoid multiple prompts
-  while security delete-generic-password -s "com.steipete.CodexBar" 2>/dev/null; do
-    :
-  done
+if [[ "${SIGNING_MODE:-adhoc}" == "adhoc" && "${CLEAR_ADHOC_KEYCHAIN}" == "1" ]]; then
+  log "==> Clearing CodexBar keychain entries (adhoc signing)"
+  # Clear both the legacy keychain store and the current cache service when developers explicitly want a clean reset
+  # of CodexBar-owned keychain state for ad-hoc builds.
+  delete_keychain_service_items "com.steipete.CodexBar"
+  delete_keychain_service_items "com.steipete.codexbar.cache"
+elif [[ "${SIGNING_MODE:-adhoc}" == "adhoc" ]]; then
+  log "==> Preserving CodexBar keychain entries (pass --clear-adhoc-keychain to reset adhoc keychain state)"
 fi
 
 # 3) Package (release build happens inside package_app.sh).
 if [[ "${RUN_TESTS}" == "1" ]]; then
-  run_step "swift test" swift test -q
+  run_step "sharded swift tests" "${ROOT_DIR}/Scripts/test.sh"
 fi
 if [[ "${DEBUG_LLDB}" == "1" && -n "${RELEASE_ARCHES}" ]]; then
   fail "--release-arches is only supported for release packaging"
@@ -200,13 +294,16 @@ ARCHES_VALUE="${HOST_ARCH}"
 if [[ -n "${RELEASE_ARCHES}" ]]; then
   ARCHES_VALUE="${RELEASE_ARCHES}"
 fi
+PACKAGE_ENV=(
+  ARCHES="${ARCHES_VALUE}"
+)
 if [[ "${DEBUG_LLDB}" == "1" ]]; then
-  run_step "package app" env CODEXBAR_ALLOW_LLDB=1 ARCHES="${ARCHES_VALUE}" "${ROOT_DIR}/Scripts/package_app.sh" debug
+  run_step "package app" env CODEXBAR_ALLOW_LLDB=1 "${PACKAGE_ENV[@]}" "${ROOT_DIR}/Scripts/package_app.sh" debug
 else
   if [[ -n "${SIGNING_MODE}" ]]; then
-    run_step "package app" env CODEXBAR_SIGNING="${SIGNING_MODE}" ARCHES="${ARCHES_VALUE}" "${ROOT_DIR}/Scripts/package_app.sh"
+    run_step "package app" env CODEXBAR_SIGNING="${SIGNING_MODE}" "${PACKAGE_ENV[@]}" "${ROOT_DIR}/Scripts/package_app.sh"
   else
-    run_step "package app" env ARCHES="${ARCHES_VALUE}" "${ROOT_DIR}/Scripts/package_app.sh"
+    run_step "package app" env "${PACKAGE_ENV[@]}" "${ROOT_DIR}/Scripts/package_app.sh"
   fi
 fi
 
diff --git a/Scripts/cost_jsonl_shape_survey.swift b/Scripts/cost_jsonl_shape_survey.swift
new file mode 100755
index 0000000000..4273601238
--- /dev/null
+++ b/Scripts/cost_jsonl_shape_survey.swift
@@ -0,0 +1,289 @@
+#!/usr/bin/env swift
+
+import Foundation
+
+struct SurveyOptions {
+    var root: URL = FileManager.default.homeDirectoryForCurrentUser
+        .appendingPathComponent(".codex", isDirectory: true)
+        .appendingPathComponent("sessions", isDirectory: true)
+    var days: Double = 30
+}
+
+struct Survey {
+    var files = 0
+    var totalBytes: Int64 = 0
+    var lines = 0
+    var relevantLines = 0
+    var lineLengths: [Int] = []
+    var linesOver32KiB = 0
+    var linesOver256KiB = 0
+    var turnContextLines = 0
+    var turnContextOver32KiB = 0
+    var turnContextOver256KiB = 0
+    var turnContextModelOffsets: [Int] = []
+    var turnContextModelOffsetUnder32KiB = 0
+    var turnContextModelOffsetUnder256KiB = 0
+    var tokenCountLines = 0
+    var tokenCountMissingExplicitModel = 0
+
+    mutating func recordFile(byteCount: Int64) {
+        self.files += 1
+        self.totalBytes += byteCount
+    }
+
+    mutating func recordLine(_ line: Data) {
+        guard !line.isEmpty else { return }
+
+        let length = line.count
+        self.lines += 1
+        self.lineLengths.append(length)
+        if length > 32 * 1024 {
+            self.linesOver32KiB += 1
+        }
+        if length > 256 * 1024 {
+            self.linesOver256KiB += 1
+        }
+
+        let isRelevant = line.contains(Marker.eventMessage)
+            || line.contains(Marker.turnContext)
+            || line.contains(Marker.sessionMetadata)
+        if isRelevant {
+            self.relevantLines += 1
+        }
+
+        if line.contains(Marker.turnContext) {
+            self.turnContextLines += 1
+            if length > 32 * 1024 {
+                self.turnContextOver32KiB += 1
+            }
+            if length > 256 * 1024 {
+                self.turnContextOver256KiB += 1
+            }
+            if let offset = line.firstOffset(of: Marker.modelField)
+                ?? line.firstOffset(of: Marker.modelNameField)
+            {
+                self.turnContextModelOffsets.append(offset)
+                if offset < 32 * 1024 {
+                    self.turnContextModelOffsetUnder32KiB += 1
+                }
+                if offset < 256 * 1024 {
+                    self.turnContextModelOffsetUnder256KiB += 1
+                }
+            }
+        }
+
+        if line.contains(Marker.tokenCount) {
+            self.tokenCountLines += 1
+            if !line.contains(Marker.modelField), !line.contains(Marker.modelNameField) {
+                self.tokenCountMissingExplicitModel += 1
+            }
+        }
+    }
+}
+
+enum Marker {
+    static let eventMessage = Data(#""type":"event_msg""#.utf8)
+    static let turnContext = Data(#""type":"turn_context""#.utf8)
+    static let sessionMetadata = Data(#""type":"session_meta""#.utf8)
+    static let tokenCount = Data(#""token_count""#.utf8)
+    static let modelField = Data(#""model""#.utf8)
+    static let modelNameField = Data(#""model_name""#.utf8)
+}
+
+extension Data {
+    func contains(_ marker: Data) -> Bool {
+        self.range(of: marker) != nil
+    }
+
+    func firstOffset(of marker: Data) -> Int? {
+        guard let range = self.range(of: marker) else { return nil }
+        return self.distance(from: self.startIndex, to: range.lowerBound)
+    }
+}
+
+func parseOptions(arguments: [String]) throws -> SurveyOptions {
+    var options = SurveyOptions()
+    var index = 1
+    while index < arguments.count {
+        switch arguments[index] {
+        case "--root":
+            index += 1
+            guard index < arguments.count else {
+                throw UsageError.message("--root requires a path")
+            }
+            options.root = URL(fileURLWithPath: expandTilde(arguments[index]), isDirectory: true)
+        case "--days":
+            index += 1
+            guard index < arguments.count, let days = Double(arguments[index]) else {
+                throw UsageError.message("--days requires a number")
+            }
+            options.days = days
+        case "--help", "-h":
+            printUsage()
+            Foundation.exit(0)
+        default:
+            throw UsageError.message("unknown argument: \(arguments[index])")
+        }
+        index += 1
+    }
+    return options
+}
+
+func expandTilde(_ path: String) -> String {
+    guard path == "~" || path.hasPrefix("~/") else { return path }
+    let home = FileManager.default.homeDirectoryForCurrentUser.path
+    if path == "~" {
+        return home
+    }
+    return home + String(path.dropFirst())
+}
+
+enum UsageError: Error, CustomStringConvertible {
+    case message(String)
+
+    var description: String {
+        switch self {
+        case let .message(text):
+            text
+        }
+    }
+}
+
+func printUsage() {
+    print(
+        """
+        Usage: Scripts/cost_jsonl_shape_survey.swift [--root PATH] [--days N]
+
+        Scans local Codex JSONL logs and prints aggregate shape only. It does not
+        print prompts, tool payloads, model values, file paths, or raw log lines.
+        """)
+}
+
+func jsonlFiles(root: URL, modifiedSince cutoff: Date) -> [URL] {
+    guard let enumerator = FileManager.default.enumerator(
+        at: root,
+        includingPropertiesForKeys: [.isRegularFileKey, .contentModificationDateKey, .fileSizeKey],
+        options: [.skipsHiddenFiles]) else { return [] }
+
+    var files: [URL] = []
+    for case let fileURL as URL in enumerator {
+        guard fileURL.pathExtension == "jsonl" else { continue }
+        let values = try? fileURL.resourceValues(forKeys: [.isRegularFileKey, .contentModificationDateKey])
+        guard values?.isRegularFile == true else { continue }
+        guard let modifiedAt = values?.contentModificationDate, modifiedAt >= cutoff else { continue }
+        files.append(fileURL)
+    }
+    return files.sorted { $0.path < $1.path }
+}
+
+func validateRoot(_ root: URL) throws {
+    var isDirectory: ObjCBool = false
+    let exists = FileManager.default.fileExists(atPath: root.path, isDirectory: &isDirectory)
+    guard exists, isDirectory.boolValue else {
+        throw UsageError.message("root does not exist or is not a directory")
+    }
+}
+
+func scan(fileURL: URL, into survey: inout Survey) throws {
+    let values = try fileURL.resourceValues(forKeys: [.fileSizeKey])
+    survey.recordFile(byteCount: Int64(values.fileSize ?? 0))
+
+    let handle = try FileHandle(forReadingFrom: fileURL)
+    defer { try? handle.close() }
+
+    var current = Data()
+    current.reserveCapacity(4 * 1024)
+
+    while true {
+        let chunk = try handle.read(upToCount: 256 * 1024) ?? Data()
+        if chunk.isEmpty {
+            survey.recordLine(current)
+            break
+        }
+
+        var segmentStart = chunk.startIndex
+        while let newline = chunk[segmentStart...].firstIndex(of: 0x0A) {
+            current.append(contentsOf: chunk[segmentStart..<newline])
+            survey.recordLine(current)
+            current.removeAll(keepingCapacity: true)
+            segmentStart = chunk.index(after: newline)
+        }
+
+        if segmentStart < chunk.endIndex {
+            current.append(contentsOf: chunk[segmentStart..<chunk.endIndex])
+        }
+    }
+}
+
+func percentile(_ values: [Int], _ percentile: Double) -> Int {
+    guard !values.isEmpty else { return 0 }
+    let sorted = values.sorted()
+    let index = Int((percentile * Double(sorted.count - 1)).rounded())
+    return sorted[max(0, min(index, sorted.count - 1))]
+}
+
+func printSummary(_ survey: Survey, options: SurveyOptions) {
+    print("root: \(redactedRootDescription(options.root))")
+    print("window days: \(Int(options.days))")
+    print("files: \(survey.files)")
+    print("total bytes: \(survey.totalBytes)")
+    print("lines: \(survey.lines)")
+    print("relevant Codex scanner lines: \(survey.relevantLines)")
+    print(
+        "line length p50/p90/p95/p99/max: " +
+            "\(percentile(survey.lineLengths, 0.50)) / " +
+            "\(percentile(survey.lineLengths, 0.90)) / " +
+            "\(percentile(survey.lineLengths, 0.95)) / " +
+            "\(percentile(survey.lineLengths, 0.99)) / " +
+            "\(percentile(survey.lineLengths, 1.00)) bytes")
+    print("lines > 32 KiB: \(survey.linesOver32KiB)")
+    print("lines > 256 KiB: \(survey.linesOver256KiB)")
+    print("turn_context lines: \(survey.turnContextLines)")
+    print("turn_context lines > 32 KiB: \(survey.turnContextOver32KiB)")
+    print("turn_context lines > 256 KiB: \(survey.turnContextOver256KiB)")
+    print(
+        "turn_context model offset p50/p95/max: " +
+            "\(percentile(survey.turnContextModelOffsets, 0.50)) / " +
+            "\(percentile(survey.turnContextModelOffsets, 0.95)) / " +
+            "\(percentile(survey.turnContextModelOffsets, 1.00)) bytes")
+    print(
+        "turn_context model offset < 32 KiB: " +
+            "\(survey.turnContextModelOffsetUnder32KiB) / \(survey.turnContextLines)")
+    print(
+        "turn_context model offset < 256 KiB: " +
+            "\(survey.turnContextModelOffsetUnder256KiB) / \(survey.turnContextLines)")
+    print(
+        "token_count rows missing an explicit model: " +
+            "\(survey.tokenCountMissingExplicitModel) / \(survey.tokenCountLines)")
+}
+
+func redactedRootDescription(_ root: URL) -> String {
+    let defaultRoot = SurveyOptions().root.standardizedFileURL.path
+    let currentRoot = root.standardizedFileURL.path
+    if currentRoot == defaultRoot {
+        return "default Codex sessions"
+    }
+    return "custom root (redacted)"
+}
+
+do {
+    let options = try parseOptions(arguments: CommandLine.arguments)
+    try validateRoot(options.root)
+    let cutoff = Date().addingTimeInterval(-options.days * 24 * 60 * 60)
+    let files = jsonlFiles(root: options.root, modifiedSince: cutoff)
+    guard !files.isEmpty else {
+        throw UsageError.message("no .jsonl files found in the selected time window")
+    }
+    var survey = Survey()
+    for fileURL in files {
+        try scan(fileURL: fileURL, into: &survey)
+    }
+    printSummary(survey, options: options)
+} catch let error as UsageError {
+    fputs("error: \(error.description)\n\n", stderr)
+    printUsage()
+    Foundation.exit(2)
+} catch {
+    fputs("error: \(error.localizedDescription)\n", stderr)
+    Foundation.exit(1)
+}
diff --git a/Scripts/generate-llms.mjs b/Scripts/generate-llms.mjs
new file mode 100755
index 0000000000..947a0d99b3
--- /dev/null
+++ b/Scripts/generate-llms.mjs
@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const docsDir = path.join(repoRoot, "docs");
+const args = process.argv.slice(2);
+const mode = parseMode(args);
+const cname = fs.readFileSync(path.join(docsDir, "CNAME"), "utf8").trim();
+const origin = "https://" + cname;
+const productName = "CodexBar";
+const source = "https://github.com/steipete/CodexBar";
+const outputPath = path.join(docsDir, "llms.txt");
+
+const pages = allHtml(docsDir)
+  .map((file) => {
+    const rel = path.relative(docsDir, file).replaceAll(path.sep, "/");
+    if (rel === "404.html" || rel === "social.html") return null;
+    const html = fs.readFileSync(file, "utf8");
+    return {
+      rel,
+      title: textContent(html.match(/<title[^>]*>([\s\S]*?)<\/title>/i)?.[1]) || titleize(path.basename(rel, ".html")),
+      description: attr(html.match(/<meta\s+name=["']description["']\s+content=["']([^"']*)["'][^>]*>/i)?.[1] || ""),
+    };
+  })
+  .filter(Boolean)
+  .sort((a, b) => (a.rel === "index.html" ? -1 : b.rel === "index.html" ? 1 : a.rel.localeCompare(b.rel)));
+const productDescription =
+  pages.find((page) => page.rel === "index.html")?.description ||
+  "CodexBar shows AI coding-provider usage limits in the macOS menu bar.";
+
+const lines = [
+  "# " + productName,
+  "",
+  productDescription,
+  "",
+  "Canonical documentation:",
+  ...pages.map((page) => "- " + page.title + ": " + pageUrl(page.rel) + (page.description ? " - " + page.description : "")),
+  "",
+  "Source: " + source,
+  "",
+  "Guidance for agents:",
+  "- Prefer the canonical documentation URLs above over README excerpts or package metadata.",
+  "- Fetch only the pages needed for the current task; this is an index, not a full-site corpus.",
+  "",
+];
+const output = lines.join("\n");
+
+if (mode === "check") {
+  const current = fs.existsSync(outputPath) ? fs.readFileSync(outputPath, "utf8") : null;
+  if (current !== output) {
+    console.error(`${path.relative(repoRoot, outputPath)} is out of date; run node Scripts/generate-llms.mjs`);
+    process.exit(1);
+  }
+  console.log("llms index OK: " + path.relative(repoRoot, outputPath));
+} else {
+  fs.writeFileSync(outputPath, output, "utf8");
+  console.log("wrote " + path.relative(repoRoot, outputPath));
+}
+
+function parseMode(values) {
+  if (values.length === 0) return "write";
+  if (values.length === 1 && (values[0] === "write" || values[0] === "--write")) return "write";
+  if (values.length === 1 && (values[0] === "check" || values[0] === "--check")) return "check";
+  console.error("Usage: node Scripts/generate-llms.mjs [write|--write|check|--check]");
+  process.exit(2);
+}
+
+function allHtml(dir) {
+  return fs.readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+    const full = path.join(dir, entry.name);
+    if (entry.name === "node_modules" || entry.name.startsWith(".")) return [];
+    if (entry.isDirectory()) return allHtml(full);
+    return entry.name.endsWith(".html") ? [full] : [];
+  });
+}
+
+function pageUrl(rel) {
+  return rel === "index.html" ? origin + "/" : origin + "/" + rel;
+}
+
+function textContent(value) {
+  return attr(value || "").replace(/<[^>]+>/g, "").replace(/\s+/g, " ").trim();
+}
+
+function attr(value) {
+  return String(value || "")
+    .replace(/&mdash;/g, "-")
+    .replace(/&amp;/g, "&")
+    .replace(/&nbsp;/g, " ")
+    .replace(/&#39;/g, "'")
+    .replace(/&quot;/g, '"')
+    .trim();
+}
+
+function titleize(input) {
+  return input.replaceAll("-", " ").replace(/\b\w/g, (m) => m.toUpperCase());
+}
diff --git a/Scripts/install_lint_tools.sh b/Scripts/install_lint_tools.sh
index f27779cf75..6f1fb1288f 100755
--- a/Scripts/install_lint_tools.sh
+++ b/Scripts/install_lint_tools.sh
@@ -11,10 +11,38 @@ SWIFTLINT_VERSION="0.63.2"
 
 SWIFTFORMAT_SHA256_DARWIN="8b6289b608a44e73cd3851c3589dbd7c553f32cc805aa54b3a496ce2b90febe7"
 SWIFTLINT_SHA256_DARWIN="c59a405c85f95b92ced677a500804e081596a4cae4a6a485af76065557d6ed29"
+SWIFTFORMAT_SHA256_LINUX_X86_64="150d9693570cf234ec91d8a03ba7165bd36a78335c5e40ed91e4c013a492eb54"
+SWIFTLINT_SHA256_LINUX_X86_64="dd1017cfd20a1457f264590bcb5875a6ee06cd75b9a9d4f77cd43a552499143b"
 
 log() { printf '%s\n' "$*"; }
 fail() { printf 'ERROR: %s\n' "$*" >&2; exit 1; }
 
+INSTALL_SWIFTFORMAT=false
+INSTALL_SWIFTLINT=false
+
+if [[ "$#" -eq 0 ]]; then
+  INSTALL_SWIFTFORMAT=true
+  INSTALL_SWIFTLINT=true
+else
+  for tool in "$@"; do
+    case "$tool" in
+      all)
+        INSTALL_SWIFTFORMAT=true
+        INSTALL_SWIFTLINT=true
+        ;;
+      swiftformat)
+        INSTALL_SWIFTFORMAT=true
+        ;;
+      swiftlint)
+        INSTALL_SWIFTLINT=true
+        ;;
+      *)
+        fail "Unknown lint tool '${tool}'. Usage: $(basename "$0") [all|swiftformat|swiftlint]..."
+        ;;
+    esac
+  done
+fi
+
 sha256_value() {
   local path="$1"
   if command -v shasum >/dev/null 2>&1; then
@@ -39,6 +67,7 @@ install_zip_binary() {
   local url="$2"
   local expected_sha="$3"
   local binary_name="$4"
+  local installed_name="${5:-$binary_name}"
 
   local tmp_zip
   tmp_zip="$(mktemp -t "${label}.XXXX")"
@@ -71,7 +100,7 @@ install_zip_binary() {
     fail "${label} binary '${binary_name}' not found in archive"
   fi
 
-  install -m 0755 "$extracted_path" "${BIN_DIR}/${binary_name}"
+  install -m 0755 "$extracted_path" "${BIN_DIR}/${installed_name}"
 
   rm -f "$tmp_zip"
   rm -rf "$tmp_dir"
@@ -79,13 +108,21 @@ install_zip_binary() {
 
 mkdir -p "$BIN_DIR"
 
-if [[ -x "${BIN_DIR}/swiftformat" && -x "${BIN_DIR}/swiftlint" ]]; then
-  if [[ "$("${BIN_DIR}/swiftformat" --version 2>/dev/null || true)" == "${SWIFTFORMAT_VERSION}" ]] \
+swiftformat_installed() {
+  [[ -x "${BIN_DIR}/swiftformat" ]] \
+    && [[ "$("${BIN_DIR}/swiftformat" --version 2>/dev/null || true)" == "${SWIFTFORMAT_VERSION}" ]]
+}
+
+swiftlint_installed() {
+  [[ -x "${BIN_DIR}/swiftlint" ]] \
     && [[ "$("${BIN_DIR}/swiftlint" version 2>/dev/null || true)" == "${SWIFTLINT_VERSION}" ]]
-  then
-    log "==> Lint tools already installed (${SWIFTFORMAT_VERSION}, ${SWIFTLINT_VERSION})"
-    exit 0
-  fi
+}
+
+if { [[ "$INSTALL_SWIFTFORMAT" != true ]] || swiftformat_installed; } \
+  && { [[ "$INSTALL_SWIFTLINT" != true ]] || swiftlint_installed; }
+then
+  log "==> Requested lint tools already installed"
+  exit 0
 fi
 
 OS="$(uname -s)"
@@ -96,29 +133,43 @@ case "$OS" in
     SWIFTFORMAT_URL="https://github.com/nicklockwood/SwiftFormat/releases/download/${SWIFTFORMAT_VERSION}/swiftformat.zip"
     SWIFTLINT_URL="https://github.com/realm/SwiftLint/releases/download/${SWIFTLINT_VERSION}/portable_swiftlint.zip"
 
-    install_zip_binary "SwiftFormat ${SWIFTFORMAT_VERSION}" "$SWIFTFORMAT_URL" "$SWIFTFORMAT_SHA256_DARWIN" "swiftformat"
-    install_zip_binary "SwiftLint ${SWIFTLINT_VERSION}" "$SWIFTLINT_URL" "$SWIFTLINT_SHA256_DARWIN" "swiftlint"
+    if [[ "$INSTALL_SWIFTFORMAT" == true ]] && ! swiftformat_installed; then
+      install_zip_binary "SwiftFormat ${SWIFTFORMAT_VERSION}" "$SWIFTFORMAT_URL" "$SWIFTFORMAT_SHA256_DARWIN" "swiftformat"
+    fi
+    if [[ "$INSTALL_SWIFTLINT" == true ]] && ! swiftlint_installed; then
+      install_zip_binary "SwiftLint ${SWIFTLINT_VERSION}" "$SWIFTLINT_URL" "$SWIFTLINT_SHA256_DARWIN" "swiftlint"
+    fi
     ;;
   Linux)
     case "$ARCH" in
       x86_64)
         SWIFTFORMAT_URL="https://github.com/nicklockwood/SwiftFormat/releases/download/${SWIFTFORMAT_VERSION}/swiftformat_linux.zip"
         SWIFTLINT_URL="https://github.com/realm/SwiftLint/releases/download/${SWIFTLINT_VERSION}/swiftlint_linux_amd64.zip"
+        SWIFTFORMAT_SHA256="$SWIFTFORMAT_SHA256_LINUX_X86_64"
+        SWIFTLINT_SHA256="$SWIFTLINT_SHA256_LINUX_X86_64"
         ;;
       aarch64|arm64)
         SWIFTFORMAT_URL="https://github.com/nicklockwood/SwiftFormat/releases/download/${SWIFTFORMAT_VERSION}/swiftformat_linux_aarch64.zip"
         SWIFTLINT_URL="https://github.com/realm/SwiftLint/releases/download/${SWIFTLINT_VERSION}/swiftlint_linux_arm64.zip"
+        SWIFTFORMAT_SHA256=""
+        SWIFTLINT_SHA256=""
         ;;
       *)
         fail "Unsupported Linux arch: ${ARCH}"
         ;;
     esac
 
-    # SHA256 is intentionally only enforced for the macOS CI path.
-    # If we later run lint on Linux CI, add pinned SHAs here as well.
-    log "WARN: Linux SHA256 verification not configured for ${ARCH}; installing anyway."
-    install_zip_binary "SwiftFormat ${SWIFTFORMAT_VERSION}" "$SWIFTFORMAT_URL" "" "swiftformat"
-    install_zip_binary "SwiftLint ${SWIFTLINT_VERSION}" "$SWIFTLINT_URL" "" "swiftlint"
+    if { [[ "$INSTALL_SWIFTFORMAT" == true ]] && [[ -z "$SWIFTFORMAT_SHA256" ]]; } \
+      || { [[ "$INSTALL_SWIFTLINT" == true ]] && [[ -z "$SWIFTLINT_SHA256" ]]; }
+    then
+      log "WARN: Linux SHA256 verification not configured for ${ARCH}; installing anyway."
+    fi
+    if [[ "$INSTALL_SWIFTFORMAT" == true ]] && ! swiftformat_installed; then
+      install_zip_binary "SwiftFormat ${SWIFTFORMAT_VERSION}" "$SWIFTFORMAT_URL" "$SWIFTFORMAT_SHA256" "swiftformat_linux" "swiftformat"
+    fi
+    if [[ "$INSTALL_SWIFTLINT" == true ]] && ! swiftlint_installed; then
+      install_zip_binary "SwiftLint ${SWIFTLINT_VERSION}" "$SWIFTLINT_URL" "$SWIFTLINT_SHA256" "swiftlint"
+    fi
     ;;
   *)
     fail "Unsupported OS: ${OS}"
@@ -126,5 +177,9 @@ case "$OS" in
 esac
 
 log "==> Installed lint tools to ${BIN_DIR}"
-"${BIN_DIR}/swiftformat" --version
-"${BIN_DIR}/swiftlint" version
+if [[ "$INSTALL_SWIFTFORMAT" == true ]]; then
+  "${BIN_DIR}/swiftformat" --version
+fi
+if [[ "$INSTALL_SWIFTLINT" == true ]]; then
+  "${BIN_DIR}/swiftlint" version
+fi
diff --git a/Scripts/lint.sh b/Scripts/lint.sh
index 748b5517e3..fe60e79831 100755
--- a/Scripts/lint.sh
+++ b/Scripts/lint.sh
@@ -5,26 +5,106 @@ set -euo pipefail
 ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 BIN_DIR="${ROOT_DIR}/.build/lint-tools/bin"
 
-ensure_tools() {
-  # Always delegate to the installer so pinned versions are enforced.
-  # The installer is idempotent and exits early when the expected versions are already present.
-  "${ROOT_DIR}/Scripts/install_lint_tools.sh"
+ensure_swiftformat() {
+  "${ROOT_DIR}/Scripts/install_lint_tools.sh" swiftformat
+}
+
+ensure_swiftlint() {
+  "${ROOT_DIR}/Scripts/install_lint_tools.sh" swiftlint
+}
+
+check_codex_parser_hash() {
+  "${ROOT_DIR}/Scripts/regenerate-codex-parser-hash.sh" --check
+}
+
+check_package_product_paths() {
+  "${ROOT_DIR}/Scripts/test_package_product_paths.sh"
+}
+
+check_package_strip() {
+  "${ROOT_DIR}/Scripts/test_package_strip.sh"
+}
+
+check_release_dsym_paths() {
+  "${ROOT_DIR}/Scripts/test_release_dsym_paths.sh"
+}
+
+check_sparkle_signing_paths() {
+  "${ROOT_DIR}/Scripts/test_sparkle_signing_paths.sh"
+}
+
+check_swift_test_sharding() {
+  "${ROOT_DIR}/Scripts/test_swift_test_sharding.sh"
+}
+
+check_ci_path_gate() {
+  "${ROOT_DIR}/Scripts/test_ci_path_gate.sh"
+}
+
+check_app_locales() {
+  node "${ROOT_DIR}/Scripts/check-app-locales.mjs" --test
+  node "${ROOT_DIR}/Scripts/check-app-locales.mjs"
+}
+
+check_site_locales() {
+  node "${ROOT_DIR}/Scripts/check-site-locales.mjs"
+  node --check "${ROOT_DIR}/docs/site.js"
+}
+
+check_documentation_links() {
+  node "${ROOT_DIR}/Scripts/check-documentation-links.mjs"
+}
+
+check_llms_index() {
+  node "${ROOT_DIR}/Scripts/generate-llms.mjs" --check
+}
+
+run_portable_checks() {
+  check_codex_parser_hash
+  check_package_product_paths
+  check_package_strip
+  check_release_dsym_paths
+  check_sparkle_signing_paths
+  check_swift_test_sharding
+  check_ci_path_gate
+  check_documentation_links
+  check_llms_index
+  check_site_locales
+}
+
+run_swiftformat_lint() {
+  ensure_swiftformat
+  "${BIN_DIR}/swiftformat" Sources Tests --lint
+}
+
+run_swiftlint() {
+  ensure_swiftlint
+  "${BIN_DIR}/swiftlint" --strict
 }
 
 cmd="${1:-lint}"
 
 case "$cmd" in
   lint)
-    ensure_tools
-    "${BIN_DIR}/swiftformat" Sources Tests --lint
-    "${BIN_DIR}/swiftlint" --strict
+    check_app_locales
+    run_portable_checks
+    run_swiftformat_lint
+    run_swiftlint
+    ;;
+  lint-linux)
+    run_portable_checks
+    run_swiftlint
+    ;;
+  lint-macos)
+    check_app_locales
+    run_swiftformat_lint
     ;;
   format)
-    ensure_tools
+    ensure_swiftformat
     "${BIN_DIR}/swiftformat" Sources Tests
     ;;
   *)
-    printf 'Usage: %s [lint|format]\n' "$(basename "$0")" >&2
+    printf 'Usage: %s [lint|lint-linux|lint-macos|format]\n' "$(basename "$0")" >&2
     exit 2
     ;;
 esac
diff --git a/Scripts/mac-release b/Scripts/mac-release
new file mode 100755
index 0000000000..b2a0178e06
--- /dev/null
+++ b/Scripts/mac-release
@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+ROOT=$(cd "$SCRIPT_DIR/.." && pwd)
+cd "$ROOT"
+
+if [[ -n "${MAC_RELEASE_TOOL:-}" ]]; then
+  exec "$MAC_RELEASE_TOOL" "$@"
+fi
+
+for candidate in \
+  "$ROOT/../agent-scripts/skills/release-mac-app/scripts/mac-release" \
+  "$HOME/Projects/agent-scripts/skills/release-mac-app/scripts/mac-release"; do
+  if [[ -x "$candidate" ]]; then
+    exec "$candidate" "$@"
+  fi
+done
+
+cat >&2 <<'EOF'
+Missing mac-release helper.
+Clone agent-scripts next to this repo or set MAC_RELEASE_TOOL=/path/to/mac-release.
+EOF
+exit 127
diff --git a/Scripts/make_appcast.sh b/Scripts/make_appcast.sh
index bcf6c06aca..262ec37292 100755
--- a/Scripts/make_appcast.sh
+++ b/Scripts/make_appcast.sh
@@ -1,108 +1,4 @@
 #!/usr/bin/env bash
 set -euo pipefail
-
-ROOT=$(cd "$(dirname "$0")/.." && pwd)
-ZIP=${1:?
-"Usage: $0 CodexBar-<ver>.zip"}
-FEED_URL=${2:-"https://raw.githubusercontent.com/steipete/CodexBar/main/appcast.xml"}
-PRIVATE_KEY_FILE=${SPARKLE_PRIVATE_KEY_FILE:-}
-SPARKLE_CHANNEL=${SPARKLE_CHANNEL:-}
-if [[ -z "$PRIVATE_KEY_FILE" ]]; then
-  echo "Set SPARKLE_PRIVATE_KEY_FILE to your ed25519 private key (Sparkle)." >&2
-  exit 1
-fi
-if [[ ! -f "$ZIP" ]]; then
-  echo "Zip not found: $ZIP" >&2
-  exit 1
-fi
-
-ZIP_DIR=$(cd "$(dirname "$ZIP")" && pwd)
-ZIP_NAME=$(basename "$ZIP")
-ZIP_BASE="${ZIP_NAME%.zip}"
-VERSION=${SPARKLE_RELEASE_VERSION:-}
-if [[ -z "$VERSION" ]]; then
-  if [[ "$ZIP_NAME" =~ ^CodexBar-([0-9]+(\.[0-9]+){1,2}([-.][^.]*)?)\.zip$ ]]; then
-    VERSION="${BASH_REMATCH[1]}"
-  else
-    echo "Could not infer version from $ZIP_NAME; set SPARKLE_RELEASE_VERSION." >&2
-    exit 1
-  fi
-fi
-
-NOTES_HTML="${ZIP_DIR}/${ZIP_BASE}.html"
-KEEP_NOTES=${KEEP_SPARKLE_NOTES:-0}
-if [[ -x "$ROOT/Scripts/changelog-to-html.sh" ]]; then
-  "$ROOT/Scripts/changelog-to-html.sh" "$VERSION" >"$NOTES_HTML"
-else
-  echo "Missing Scripts/changelog-to-html.sh; cannot generate HTML release notes." >&2
-  exit 1
-fi
-cleanup() {
-  if [[ -n "${WORK_DIR:-}" ]]; then
-    rm -rf "$WORK_DIR"
-  fi
-  if [[ "$KEEP_NOTES" != "1" ]]; then
-    rm -f "$NOTES_HTML"
-  fi
-}
-trap cleanup EXIT
-
-DOWNLOAD_URL_PREFIX=${SPARKLE_DOWNLOAD_URL_PREFIX:-"https://github.com/steipete/CodexBar/releases/download/v${VERSION}/"}
-
-# Sparkle provides generate_appcast; ensure it's on PATH (via SwiftPM build of Sparkle's bin) or Xcode dmg
-if ! command -v generate_appcast >/dev/null; then
-  echo "generate_appcast not found in PATH. Install Sparkle tools (see Sparkle docs)." >&2
-  exit 1
-fi
-
-WORK_DIR=$(mktemp -d /tmp/codexbar-appcast.XXXXXX)
-
-cp "$ROOT/appcast.xml" "$WORK_DIR/appcast.xml"
-cp "$ZIP" "$WORK_DIR/$ZIP_NAME"
-cp "$NOTES_HTML" "$WORK_DIR/$ZIP_BASE.html"
-
-pushd "$WORK_DIR" >/dev/null
-generate_appcast \
-  --ed-key-file "$PRIVATE_KEY_FILE" \
-  --download-url-prefix "$DOWNLOAD_URL_PREFIX" \
-  --embed-release-notes \
-  --link "$FEED_URL" \
-  "$WORK_DIR"
-popd >/dev/null
-
-if [[ -n "$SPARKLE_CHANNEL" ]]; then
-  python3 - "$WORK_DIR/appcast.xml" "$VERSION" "$SPARKLE_CHANNEL" <<'PY'
-import re
-import sys
-
-path, version, channel = sys.argv[1], sys.argv[2], sys.argv[3]
-with open(path, "r", encoding="utf-8") as handle:
-    lines = handle.read().splitlines()
-
-target = f"<sparkle:shortVersionString>{version}</sparkle:shortVersionString>"
-try:
-    index = next(i for i, line in enumerate(lines) if target in line)
-except StopIteration as exc:
-    raise SystemExit(f"Could not find {target} in {path}") from exc
-
-for j in range(index, -1, -1):
-    if "<item" in lines[j]:
-        line = lines[j]
-        if "sparkle:channel" in line:
-            line = re.sub(r'sparkle:channel="[^"]*"', f'sparkle:channel="{channel}"', line)
-        else:
-            line = line.replace("<item", f'<item sparkle:channel="{channel}"', 1)
-        lines[j] = line
-        break
-else:
-    raise SystemExit(f"Could not find <item> for version {version} in {path}")
-
-with open(path, "w", encoding="utf-8") as handle:
-    handle.write("\n".join(lines) + "\n")
-PY
-  echo "Tagged ${VERSION} with sparkle:channel=\"${SPARKLE_CHANNEL}\""
-fi
-
-cp "$WORK_DIR/appcast.xml" "$ROOT/appcast.xml"
-
-echo "Appcast generated (appcast.xml). Upload alongside $ZIP at $FEED_URL"
+SCRIPT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+exec "$SCRIPT_DIR/mac-release" make-appcast "$@"
diff --git a/Scripts/mimo-usage.py b/Scripts/mimo-usage.py
new file mode 100755
index 0000000000..067bc72aa1
--- /dev/null
+++ b/Scripts/mimo-usage.py
@@ -0,0 +1,241 @@
+#!/usr/bin/env python3
+"""
+mimo-usage — local token usage tracker for cc-mimo
+
+Scans ~/.claude-envs/mimo/.claude/projects/**/*.jsonl session files,
+sums input/output/cache tokens per time window (today/week/all),
+writes to ~/.codexbar/mimo-local-usage.json, and prints a human-readable
+summary by default.
+
+Usage:
+  mimo-usage              # show summary (also refreshes cache)
+  mimo-usage --update     # refresh cache only, no output (for LaunchAgent/wrapper)
+  mimo-usage --json       # JSON output
+  mimo-usage --short      # 1-line status (for status line / widget)
+"""
+import json
+import os
+import sys
+from pathlib import Path
+from datetime import datetime, timedelta, timezone
+
+MIMO_HOME = Path(os.environ.get("MIMO_CLAUDE_HOME", Path.home() / ".claude-envs" / "mimo")).expanduser()
+PROJECTS_DIR = MIMO_HOME / ".claude" / "projects"
+CACHE_PATH = Path(
+    os.environ.get("MIMO_LOCAL_USAGE_PATH", Path.home() / ".codexbar" / "mimo-local-usage.json")
+).expanduser()
+
+
+def parse_session_usage(jsonl_path: Path):
+    """Yield (identity, timestamp_iso, usage_dict) for each assistant message with usage."""
+    try:
+        with jsonl_path.open() as f:
+            for line in f:
+                try:
+                    d = json.loads(line)
+                    ts = d.get("timestamp")
+                    msg = d.get("message")
+                    if not isinstance(msg, dict):
+                        continue
+                    usage = msg.get("usage")
+                    if not isinstance(usage, dict):
+                        continue
+                    if not ts:
+                        continue
+                    metadata = d.get("metadata")
+                    message_metadata = msg.get("metadata")
+                    session_id = d.get("sessionId") or d.get("session_id")
+                    if not session_id and isinstance(metadata, dict):
+                        session_id = metadata.get("sessionId")
+                    if not session_id and isinstance(message_metadata, dict):
+                        session_id = message_metadata.get("sessionId")
+                    message_id = msg.get("id")
+                    request_id = d.get("requestId") or d.get("request_id")
+                    identity = None
+                    if all(isinstance(value, str) and value for value in (message_id, request_id)):
+                        identity = ("request", message_id, request_id)
+                    elif (
+                        request_id is None
+                        and isinstance(session_id, str)
+                        and session_id
+                        and isinstance(message_id, str)
+                        and message_id
+                    ):
+                        identity = ("legacy", session_id, message_id)
+                    yield identity, ts, usage
+                except (json.JSONDecodeError, ValueError):
+                    continue
+    except (OSError, IOError):
+        return
+
+
+def aggregate_usage():
+    """Scan all mimo session jsonls and return windowed token sums."""
+    now = datetime.now(timezone.utc)
+    today_start = now.replace(hour=0, minute=0, second=0, microsecond=0)
+    # Week starts on Monday 00:00 UTC
+    week_start = today_start - timedelta(days=today_start.weekday())
+
+    windows = {
+        "today": {"input": 0, "output": 0, "cache_read": 0, "cache_create": 0, "messages": 0},
+        "week": {"input": 0, "output": 0, "cache_read": 0, "cache_create": 0, "messages": 0},
+        "all_time": {"input": 0, "output": 0, "cache_read": 0, "cache_create": 0, "messages": 0},
+    }
+    sessions_scanned = 0
+    last_activity = None
+    keyed_rows = {}
+    unkeyed_rows = []
+
+    if not PROJECTS_DIR.exists():
+        return windows, sessions_scanned, last_activity
+
+    for jsonl in PROJECTS_DIR.rglob("*.jsonl"):
+        sessions_scanned += 1
+        for identity, ts_str, usage in parse_session_usage(jsonl):
+            try:
+                # Parse ISO timestamp (may end with Z)
+                ts = datetime.fromisoformat(ts_str.replace("Z", "+00:00"))
+                if ts.tzinfo is None:
+                    ts = ts.replace(tzinfo=timezone.utc)
+            except (ValueError, TypeError):
+                continue
+
+            row = (ts, usage)
+            if identity is None:
+                unkeyed_rows.append(row)
+            else:
+                previous = keyed_rows.get(identity)
+                if previous is None or ts >= previous[0]:
+                    keyed_rows[identity] = row
+
+    for ts, usage in [*keyed_rows.values(), *unkeyed_rows]:
+        input_t = int(usage.get("input_tokens", 0) or 0)
+        output_t = int(usage.get("output_tokens", 0) or 0)
+        cache_read_t = int(usage.get("cache_read_input_tokens", 0) or 0)
+        cache_create_t = int(usage.get("cache_creation_input_tokens", 0) or 0)
+
+        if last_activity is None or ts > last_activity:
+            last_activity = ts
+
+        # all_time
+        w = windows["all_time"]
+        w["input"] += input_t
+        w["output"] += output_t
+        w["cache_read"] += cache_read_t
+        w["cache_create"] += cache_create_t
+        w["messages"] += 1
+
+        if ts >= week_start:
+            w = windows["week"]
+            w["input"] += input_t
+            w["output"] += output_t
+            w["cache_read"] += cache_read_t
+            w["cache_create"] += cache_create_t
+            w["messages"] += 1
+
+        if ts >= today_start:
+            w = windows["today"]
+            w["input"] += input_t
+            w["output"] += output_t
+            w["cache_read"] += cache_read_t
+            w["cache_create"] += cache_create_t
+            w["messages"] += 1
+
+    return windows, sessions_scanned, last_activity
+
+
+def write_cache(windows, sessions_scanned, last_activity):
+    CACHE_PATH.parent.mkdir(parents=True, exist_ok=True)
+    payload = {
+        "updated_at": datetime.now(timezone.utc).isoformat(),
+        "last_activity": last_activity.isoformat() if last_activity else None,
+        "sessions_scanned": sessions_scanned,
+        "windows": windows,
+        "source": "local-jsonl-scan",
+        "note": "Local token accounting from cc-mimo session jsonl. Not a quota; mimo platform.xiaomimimo.com SSO cookie required for real quota.",
+    }
+    tmp = CACHE_PATH.with_suffix(".json.tmp")
+    tmp.write_text(json.dumps(payload, indent=2))
+    tmp.replace(CACHE_PATH)
+    return payload
+
+
+def fmt_tokens(n: int) -> str:
+    if n >= 1_000_000:
+        return f"{n / 1_000_000:.1f}M"
+    if n >= 1_000:
+        return f"{n / 1_000:.1f}k"
+    return str(n)
+
+
+def short_status(payload):
+    """1-line status line."""
+    w = payload["windows"]["week"]
+    total = w["input"] + w["output"] + w["cache_read"] + w["cache_create"]
+    return f"mimo: {fmt_tokens(total)} tok this week ({w['messages']} msg)"
+
+
+def human_summary(payload):
+    """Multi-line human-readable summary."""
+    last = payload.get("last_activity")
+    if last:
+        try:
+            last_dt = datetime.fromisoformat(last)
+            ago = datetime.now(timezone.utc) - last_dt
+            if ago.total_seconds() < 60:
+                ago_str = "just now"
+            elif ago.total_seconds() < 3600:
+                ago_str = f"{int(ago.total_seconds() / 60)}m ago"
+            elif ago.total_seconds() < 86400:
+                ago_str = f"{int(ago.total_seconds() / 3600)}h ago"
+            else:
+                ago_str = f"{ago.days}d ago"
+        except (ValueError, TypeError):
+            ago_str = last
+    else:
+        ago_str = "never"
+
+    lines = [
+        "== MiMo (local tracker) ==",
+        f"Sessions scanned: {payload['sessions_scanned']}",
+        f"Last activity: {ago_str}",
+        "",
+    ]
+    for window_name, label in [("today", "Today"), ("week", "This week"), ("all_time", "All time")]:
+        w = payload["windows"][window_name]
+        in_t = fmt_tokens(w["input"])
+        out_t = fmt_tokens(w["output"])
+        cr_t = fmt_tokens(w["cache_read"])
+        cc_t = fmt_tokens(w["cache_create"])
+        total = w["input"] + w["output"] + w["cache_read"] + w["cache_create"]
+        lines.append(f"{label:>10}: {fmt_tokens(total):>8} total | in={in_t} out={out_t} cache_r={cr_t} cache_c={cc_t} | msg={w['messages']}")
+    lines.append("")
+    lines.append("Note: this is local accounting from cc-mimo session jsonl.")
+    lines.append("Real platform quota requires Chrome cookie (cookieSource=manual).")
+    return "\n".join(lines)
+
+
+def main():
+    args = sys.argv[1:]
+    quiet = "--update" in args
+    json_out = "--json" in args
+    short = "--short" in args
+
+    windows, sessions_scanned, last_activity = aggregate_usage()
+    payload = write_cache(windows, sessions_scanned, last_activity)
+
+    if quiet:
+        return 0
+    if json_out:
+        print(json.dumps(payload, indent=2))
+        return 0
+    if short:
+        print(short_status(payload))
+        return 0
+
+    print(human_summary(payload))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/Scripts/package_app.sh b/Scripts/package_app.sh
index 08ee481a0e..859811c1b2 100755
--- a/Scripts/package_app.sh
+++ b/Scripts/package_app.sh
@@ -5,9 +5,19 @@ ALLOW_LLDB=${CODEXBAR_ALLOW_LLDB:-0}
 SIGNING_MODE=${CODEXBAR_SIGNING:-}
 ROOT=$(cd "$(dirname "$0")/.." && pwd)
 cd "$ROOT"
+LOWER_CONF=$(printf "%s" "$CONF" | tr '[:upper:]' '[:lower:]')
+case "$LOWER_CONF" in
+  debug|release) ;;
+  *)
+    echo "ERROR: Unsupported build configuration: $CONF (expected debug or release)" >&2
+    exit 1
+    ;;
+esac
 
 # Load version info
 source "$ROOT/version.env"
+source "$ROOT/Scripts/package_product_paths.sh"
+source "$ROOT/Scripts/sparkle_signing_paths.sh"
 
 # Clean build only when explicitly requested (slower).
 if [[ "${CODEXBAR_FORCE_CLEAN:-0}" == "1" ]]; then
@@ -104,12 +114,65 @@ if [[ ! -f "$KEYBOARD_SHORTCUTS_UTIL" ]]; then
 fi
 patch_keyboard_shortcuts
 
+# Resolve SwiftPM's current output path without relying on a fixed build-system layout.
+# The output variable keeps the per-arch cache in this shell instead of losing it to
+# command substitution.
+swiftpm_bin_path() {
+  local arch="$1"
+  local output_var="$2"
+  local cache_var="SWIFTPM_BIN_PATH_${arch//[^A-Za-z0-9]/_}"
+  if [[ -z "${!cache_var+set}" ]]; then
+    local resolved
+    if ! resolved=$(codexbar_swiftpm_bin_path "$CONF" "$arch"); then
+      return 1
+    fi
+    printf -v "$cache_var" '%s' "$resolved"
+  fi
+  printf -v "$output_var" '%s' "${!cache_var}"
+}
+
+binary_has_arch() {
+  local binary="$1"
+  local arch="$2"
+  [[ -f "$binary" ]] && lipo -archs "$binary" 2>/dev/null | tr ' ' '\n' | grep -qx "$arch"
+}
+
+# SwiftBuild can reuse one output directory for sequential per-arch builds. Snapshot
+# each fresh slice before the next build can replace it.
+PRODUCT_STAGE_ROOT="$ROOT/.build/package-products/$LOWER_CONF"
+rm -rf "$PRODUCT_STAGE_ROOT"
+
+stage_build_products() {
+  local arch="$1"
+  local bin_dir stage_dir name product
+  swiftpm_bin_path "$arch" bin_dir
+
+  stage_dir="$PRODUCT_STAGE_ROOT/$arch"
+  mkdir -p "$stage_dir"
+  for name in CodexBar CodexBarCLI CodexBarClaudeWatchdog; do
+    if ! product=$(codexbar_require_product_file "$bin_dir" "$name" "$arch"); then
+      return 1
+    fi
+    if ! binary_has_arch "$product" "$arch"; then
+      echo "ERROR: ${product} does not contain required architecture: ${arch}" >&2
+      return 1
+    fi
+    cp "$product" "$stage_dir/$name"
+  done
+  if [[ -d "$bin_dir/CodexBar.dSYM" ]]; then
+    cp -R "$bin_dir/CodexBar.dSYM" "$stage_dir/"
+  fi
+}
+
 for ARCH in "${ARCH_LIST[@]}"; do
   swift build -c "$CONF" --arch "$ARCH"
+  stage_build_products "$ARCH"
 done
 
-APP="$ROOT/CodexBar.app"
-rm -rf "$APP"
+APP_FINAL="$ROOT/CodexBar.app"
+APP_STAGE="$ROOT/.build/package/CodexBar.app"
+rm -rf "$APP_STAGE"
+APP="$APP_STAGE"
 mkdir -p "$APP/Contents/MacOS" "$APP/Contents/Resources" "$APP/Contents/Frameworks"
 mkdir -p "$APP/Contents/Helpers" "$APP/Contents/PlugIns"
 
@@ -123,7 +186,6 @@ fi
 BUNDLE_ID="com.steipete.codexbar"
 FEED_URL="https://raw.githubusercontent.com/steipete/CodexBar/main/appcast.xml"
 AUTO_CHECKS=true
-LOWER_CONF=$(printf "%s" "$CONF" | tr '[:upper:]' '[:lower:]')
 if [[ "$LOWER_CONF" == "debug" ]]; then
   BUNDLE_ID="com.steipete.codexbar.debug"
   FEED_URL=""
@@ -134,9 +196,10 @@ if [[ "$SIGNING_MODE" == "adhoc" ]]; then
   AUTO_CHECKS=false
 fi
 WIDGET_BUNDLE_ID="${BUNDLE_ID}.widget"
-APP_GROUP_ID="group.com.steipete.codexbar"
+APP_TEAM_ID="${APP_TEAM_ID:-Y5PE65HELJ}"
+APP_GROUP_ID="${APP_TEAM_ID}.com.steipete.codexbar"
 if [[ "$BUNDLE_ID" == *".debug"* ]]; then
-  APP_GROUP_ID="group.com.steipete.codexbar.debug"
+  APP_GROUP_ID="${APP_TEAM_ID}.com.steipete.codexbar.debug"
 fi
 ENTITLEMENTS_DIR="$ROOT/.build/entitlements"
 APP_ENTITLEMENTS="${ENTITLEMENTS_DIR}/CodexBar.entitlements"
@@ -191,38 +254,32 @@ cat > "$APP/Contents/Info.plist" <<PLIST
     <key>LSMinimumSystemVersion</key><string>14.0</string>
     <key>LSUIElement</key><true/>
     <key>CFBundleIconFile</key><string>Icon</string>
-    <key>NSHumanReadableCopyright</key><string>© 2025 Peter Steinberger. MIT License.</string>
+    <key>NSHumanReadableCopyright</key><string>© 2026 Peter Steinberger. MIT License.</string>
     <key>SUFeedURL</key><string>${FEED_URL}</string>
     <key>SUPublicEDKey</key><string>AGCY8w5vHirVfGGDGc8Szc5iuOqupZSh9pMj/Qs67XI=</string>
     <key>SUEnableAutomaticChecks</key><${AUTO_CHECKS}/>
     <key>CodexBuildTimestamp</key><string>${BUILD_TIMESTAMP}</string>
     <key>CodexGitCommit</key><string>${GIT_COMMIT}</string>
+    <key>CodexBarTeamID</key><string>${APP_TEAM_ID}</string>
 </dict>
 </plist>
 PLIST
 
-build_product_path() {
-  local name="$1"
-  local arch="$2"
-  case "$arch" in
-    arm64|x86_64) echo ".build/${arch}-apple-macosx/$CONF/$name" ;;
-    *) echo ".build/$CONF/$name" ;;
-  esac
-}
-
-# Resolve path to built binary; some SwiftPM versions use .build/$CONF/ when building for host only.
+# Resolve a built binary from the fresh per-arch snapshot or SwiftPM's reported directory.
 resolve_binary_path() {
   local name="$1"
   local arch="$2"
-  local candidate
-  candidate=$(build_product_path "$name" "$arch")
-  if [[ -f "$candidate" ]]; then
-    echo "$candidate"
-    return
+  local bin_dir candidate
+  swiftpm_bin_path "$arch" bin_dir
+  if ! candidate=$(codexbar_resolve_staged_or_reported_file \
+    "$PRODUCT_STAGE_ROOT" "$bin_dir" "$name" "$arch"); then
+    return 1
   fi
-  if [[ "$arch" == "arm64" || "$arch" == "x86_64" ]] && [[ -f ".build/$CONF/$name" ]]; then
-    echo ".build/$CONF/$name"
+  if ! binary_has_arch "$candidate" "$arch"; then
+    echo "ERROR: ${candidate} does not contain required architecture: ${arch}" >&2
+    return 1
   fi
+  echo "$candidate"
 }
 
 verify_binary_arches() {
@@ -251,9 +308,7 @@ install_binary() {
   local binaries=()
   for arch in "${ARCH_LIST[@]}"; do
     local src
-    src=$(resolve_binary_path "$name" "$arch")
-    if [[ -z "$src" || ! -f "$src" ]]; then
-      echo "ERROR: Missing ${name} build for ${arch} at $(build_product_path "$name" "$arch")" >&2
+    if ! src=$(resolve_binary_path "$name" "$arch"); then
       exit 1
     fi
     binaries+=("$src")
@@ -267,48 +322,123 @@ install_binary() {
   verify_binary_arches "$dest" "${ARCH_LIST[@]}"
 }
 
+strip_release_binary() {
+  local binary="$1"
+  if [[ "$LOWER_CONF" != "release" ]]; then
+    return 0
+  fi
+  if [[ ! -f "$binary" ]]; then
+    return 0
+  fi
+  xcrun strip -x "$binary"
+}
+
+ensure_widget_extension_project() {
+  local spec="$ROOT/WidgetExtension/project.yml"
+  local project_dir="$ROOT/WidgetExtension/CodexBarWidgetExtension.xcodeproj"
+  if command -v xcodegen >/dev/null 2>&1; then
+    xcodegen generate --spec "$spec" --project "$ROOT/WidgetExtension" --quiet
+  elif [[ ! -f "$project_dir/project.pbxproj" ]]; then
+    echo "ERROR: Missing ${project_dir}; install xcodegen or restore the generated project." >&2
+    exit 1
+  fi
+}
+
+build_widget_extension() {
+  local xcode_conf="Release"
+  if [[ "$LOWER_CONF" == "debug" ]]; then
+    xcode_conf="Debug"
+  fi
+
+  ensure_widget_extension_project
+
+  local derived_dir="$ROOT/.build/xcode-widget-extension-${LOWER_CONF}"
+  local project_dir="$ROOT/WidgetExtension/CodexBarWidgetExtension.xcodeproj"
+  local build_log="$derived_dir/xcodebuild.log"
+  local timeout_seconds="${CODEXBAR_WIDGET_EXTENSION_TIMEOUT_SECONDS:-900}"
+  local archs="${ARCH_LIST[*]}"
+
+  mkdir -p "$derived_dir"
+  echo "Building CodexBarWidget Xcode extension (${xcode_conf}, ${archs})." >&2
+  xcodebuild \
+    -project "$project_dir" \
+    -scheme CodexBarWidgetExtension \
+    -configuration "$xcode_conf" \
+    -destination "generic/platform=macOS" \
+    -derivedDataPath "$derived_dir" \
+    -skipPackageUpdates \
+    -disableAutomaticPackageResolution \
+    -skipMacroValidation \
+    -skipPackagePluginValidation \
+    CODEXBAR_WIDGET_BUNDLE_ID="$WIDGET_BUNDLE_ID" \
+    CODEXBAR_TEAM_ID="$APP_TEAM_ID" \
+    MARKETING_VERSION="$MARKETING_VERSION" \
+    CURRENT_PROJECT_VERSION="$BUILD_NUMBER" \
+    CODE_SIGNING_ALLOWED=NO \
+    ARCHS="$archs" \
+    ONLY_ACTIVE_ARCH=NO \
+    build >"$build_log" 2>&1 &
+
+  local xcodebuild_pid=$!
+  local elapsed=0
+  while kill -0 "$xcodebuild_pid" 2>/dev/null; do
+    if [[ "$elapsed" -ge "$timeout_seconds" ]]; then
+      kill "$xcodebuild_pid" 2>/dev/null || true
+      wait "$xcodebuild_pid" 2>/dev/null || true
+      tail -80 "$build_log" >&2 || true
+      echo "ERROR: Timed out building CodexBarWidget extension after ${timeout_seconds}s" >&2
+      exit 1
+    fi
+    sleep 5
+    elapsed=$((elapsed + 5))
+    if (( elapsed > 0 && elapsed % 60 == 0 )); then
+      echo "Still building CodexBarWidget extension (${elapsed}s)..." >&2
+    fi
+  done
+  if ! wait "$xcodebuild_pid"; then
+    tail -120 "$build_log" >&2 || true
+    echo "ERROR: Failed to build CodexBarWidget extension" >&2
+    exit 1
+  fi
+
+  local appex="$derived_dir/Build/Products/${xcode_conf}/CodexBarWidget.appex"
+  if [[ ! -f "$appex/Contents/MacOS/CodexBarWidget" ]]; then
+    echo "ERROR: Missing Xcode-built CodexBarWidget.appex at ${appex}" >&2
+    exit 1
+  fi
+  echo "$appex"
+}
+
+install_widget_extension() {
+  local src_appex
+  src_appex="$(build_widget_extension)"
+  local widget_app="$APP/Contents/PlugIns/CodexBarWidget.appex"
+  rm -rf "$widget_app"
+  mkdir -p "$APP/Contents/PlugIns"
+  cp -R "$src_appex" "$widget_app"
+  verify_binary_arches "$widget_app/Contents/MacOS/CodexBarWidget" "${ARCH_LIST[@]}"
+}
+
 install_binary "CodexBar" "$APP/Contents/MacOS/CodexBar"
+strip_release_binary "$APP/Contents/MacOS/CodexBar"
 # Ship CodexBarCLI alongside the app for easy symlinking.
-if [[ -n "$(resolve_binary_path "CodexBarCLI" "${ARCH_LIST[0]}")" ]]; then
-  install_binary "CodexBarCLI" "$APP/Contents/Helpers/CodexBarCLI"
-fi
+install_binary "CodexBarCLI" "$APP/Contents/Helpers/CodexBarCLI"
+strip_release_binary "$APP/Contents/Helpers/CodexBarCLI"
 # Watchdog helper: ensures `claude` probes die when CodexBar crashes/gets killed.
-if [[ -n "$(resolve_binary_path "CodexBarClaudeWatchdog" "${ARCH_LIST[0]}")" ]]; then
-  install_binary "CodexBarClaudeWatchdog" "$APP/Contents/Helpers/CodexBarClaudeWatchdog"
-fi
-if [[ -n "$(resolve_binary_path "CodexBarWidget" "${ARCH_LIST[0]}")" ]]; then
-  WIDGET_APP="$APP/Contents/PlugIns/CodexBarWidget.appex"
-  mkdir -p "$WIDGET_APP/Contents/MacOS" "$WIDGET_APP/Contents/Resources"
-  cat > "$WIDGET_APP/Contents/Info.plist" <<PLIST
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-    <key>CFBundleName</key><string>CodexBarWidget</string>
-    <key>CFBundleDisplayName</key><string>CodexBar</string>
-    <key>CFBundleIdentifier</key><string>${WIDGET_BUNDLE_ID}</string>
-    <key>CFBundleExecutable</key><string>CodexBarWidget</string>
-    <key>CFBundlePackageType</key><string>XPC!</string>
-    <key>CFBundleShortVersionString</key><string>${MARKETING_VERSION}</string>
-    <key>CFBundleVersion</key><string>${BUILD_NUMBER}</string>
-    <key>LSMinimumSystemVersion</key><string>14.0</string>
-    <key>NSExtension</key>
-    <dict>
-        <key>NSExtensionPointIdentifier</key><string>com.apple.widgetkit-extension</string>
-        <key>NSExtensionPrincipalClass</key><string>CodexBarWidget.CodexBarWidgetBundle</string>
-    </dict>
-</dict>
-</plist>
-PLIST
-  install_binary "CodexBarWidget" "$WIDGET_APP/Contents/MacOS/CodexBarWidget"
-fi
+install_binary "CodexBarClaudeWatchdog" "$APP/Contents/Helpers/CodexBarClaudeWatchdog"
+strip_release_binary "$APP/Contents/Helpers/CodexBarClaudeWatchdog"
+install_widget_extension
+strip_release_binary "$APP/Contents/PlugIns/CodexBarWidget.appex/Contents/MacOS/CodexBarWidget"
+
+swiftpm_bin_path "${ARCH_LIST[0]}" PREFERRED_BUILD_DIR
+
 # Embed Sparkle.framework
-if [[ -d ".build/$CONF/Sparkle.framework" ]]; then
-  cp -R ".build/$CONF/Sparkle.framework" "$APP/Contents/Frameworks/"
-  chmod -R a+rX "$APP/Contents/Frameworks/Sparkle.framework"
-  install_name_tool -add_rpath "@executable_path/../Frameworks" "$APP/Contents/MacOS/CodexBar"
-  # Re-sign Sparkle and all nested components with Developer ID + timestamp
-  SPARKLE="$APP/Contents/Frameworks/Sparkle.framework"
+SPARKLE_SOURCE=$(codexbar_require_product_directory "$PREFERRED_BUILD_DIR" Sparkle.framework packaging)
+cp -R "$SPARKLE_SOURCE" "$APP/Contents/Frameworks/"
+chmod -R a+rX "$APP/Contents/Frameworks/Sparkle.framework"
+install_name_tool -add_rpath "@executable_path/../Frameworks" "$APP/Contents/MacOS/CodexBar"
+# Re-sign Sparkle and all nested components with Developer ID + timestamp
+SPARKLE="$APP/Contents/Frameworks/Sparkle.framework"
 if [[ "$SIGNING_MODE" == "adhoc" ]]; then
   CODESIGN_ID="-"
   CODESIGN_ARGS=(--force --sign "$CODESIGN_ID")
@@ -320,19 +450,11 @@ else
   CODESIGN_ARGS=(--force --timestamp --options runtime --sign "$CODESIGN_ID")
 fi
 function resign() { codesign "${CODESIGN_ARGS[@]}" "$1"; }
-  # Sign innermost binaries first, then the framework root to seal resources
-  resign "$SPARKLE"
-  resign "$SPARKLE/Versions/B/Sparkle"
-  resign "$SPARKLE/Versions/B/Autoupdate"
-  resign "$SPARKLE/Versions/B/Updater.app"
-  resign "$SPARKLE/Versions/B/Updater.app/Contents/MacOS/Updater"
-  resign "$SPARKLE/Versions/B/XPCServices/Downloader.xpc"
-  resign "$SPARKLE/Versions/B/XPCServices/Downloader.xpc/Contents/MacOS/Downloader"
-  resign "$SPARKLE/Versions/B/XPCServices/Installer.xpc"
-  resign "$SPARKLE/Versions/B/XPCServices/Installer.xpc/Contents/MacOS/Installer"
-  resign "$SPARKLE/Versions/B"
-  resign "$SPARKLE"
-fi
+# Validate Sparkle's nested layout before signing so framework layout drift fails clearly.
+SPARKLE_SIGNING_TARGETS=$(codexbar_sparkle_signing_targets "$SPARKLE")
+while IFS= read -r SPARKLE_TARGET; do
+  resign "$SPARKLE_TARGET"
+done <<<"$SPARKLE_SIGNING_TARGETS"
 
 if [[ -f "$ICON_TARGET" ]]; then
   cp "$ICON_TARGET" "$APP/Contents/Resources/Icon.icns"
@@ -349,8 +471,6 @@ if [[ ! -f "$APP/Contents/Resources/Icon-classic.icns" ]]; then
 fi
 
 # SwiftPM resource bundles (e.g. KeyboardShortcuts) are emitted next to the built binary.
-CODEXBAR_BINARY="$(resolve_binary_path "CodexBar" "${ARCH_LIST[0]}")"
-PREFERRED_BUILD_DIR="$(dirname "${CODEXBAR_BINARY:-$(build_product_path "CodexBar" "${ARCH_LIST[0]}")}")"
 shopt -s nullglob
 SWIFTPM_BUNDLES=("${PREFERRED_BUILD_DIR}/"*.bundle)
 shopt -u nullglob
@@ -396,4 +516,7 @@ codesign "${CODESIGN_ARGS[@]}" \
   --entitlements "$APP_ENTITLEMENTS" \
   "$APP"
 
+rm -rf "$APP_FINAL"
+mv "$APP" "$APP_FINAL"
+APP="$APP_FINAL"
 echo "Created $APP"
diff --git a/Scripts/package_product_paths.sh b/Scripts/package_product_paths.sh
new file mode 100755
index 0000000000..09823537d6
--- /dev/null
+++ b/Scripts/package_product_paths.sh
@@ -0,0 +1,72 @@
+#!/usr/bin/env bash
+
+codexbar_swiftpm_bin_path() {
+  local conf="$1"
+  shift
+  local command=(swift build --show-bin-path -c "$conf")
+  local arch
+  for arch in "$@"; do
+    command+=(--arch "$arch")
+  done
+
+  local path
+  if ! path=$("${command[@]}"); then
+    echo "ERROR: SwiftPM failed to report the ${conf} product directory for: $*" >&2
+    return 1
+  fi
+  if [[ -z "$path" ]]; then
+    echo "ERROR: SwiftPM reported an empty ${conf} product directory for: $*" >&2
+    return 1
+  fi
+  printf '%s\n' "$path"
+}
+
+codexbar_require_product_file() {
+  local bin_dir="$1"
+  local name="$2"
+  local arch_label="$3"
+  local product="$bin_dir/$name"
+  if [[ ! -f "$product" ]]; then
+    echo "ERROR: Missing ${name} for ${arch_label} at SwiftPM-reported path: ${product}" >&2
+    return 1
+  fi
+  printf '%s\n' "$product"
+}
+
+codexbar_require_product_directory() {
+  local bin_dir="$1"
+  local name="$2"
+  local context="$3"
+  local product="$bin_dir/$name"
+  if [[ ! -d "$product" ]]; then
+    echo "ERROR: Missing ${name} for ${context} at SwiftPM-reported path: ${product}" >&2
+    return 1
+  fi
+  printf '%s\n' "$product"
+}
+
+codexbar_resolve_staged_or_reported_file() {
+  local stage_root="$1"
+  local bin_dir="$2"
+  local name="$3"
+  local arch="$4"
+  local staged="$stage_root/$arch/$name"
+  if [[ -f "$staged" ]]; then
+    printf '%s\n' "$staged"
+    return
+  fi
+  codexbar_require_product_file "$bin_dir" "$name" "$arch"
+}
+
+codexbar_resolve_dsym_path() {
+  local stage_root="$1"
+  local bin_dir="$2"
+  local app_name="$3"
+  local arch="$4"
+  local staged="$stage_root/$arch/${app_name}.dSYM"
+  if [[ -d "$staged" ]]; then
+    printf '%s\n' "$staged"
+    return
+  fi
+  codexbar_require_product_directory "$bin_dir" "${app_name}.dSYM" "$arch"
+}
diff --git a/Scripts/prepare_upstream_pr.sh b/Scripts/prepare_upstream_pr.sh
index b8be56139d..97fdcde151 100755
--- a/Scripts/prepare_upstream_pr.sh
+++ b/Scripts/prepare_upstream_pr.sh
@@ -63,7 +63,7 @@ echo "   ${GREEN}git add <files>${NC}"
 echo "   ${GREEN}git commit -m 'fix: description'${NC}"
 echo ""
 echo "3. Ensure tests pass:"
-echo "   ${GREEN}swift test${NC}"
+echo "   ${GREEN}make test${NC}"
 echo ""
 echo "4. Review changes:"
 echo "   ${GREEN}git diff upstream/main${NC}"
@@ -75,4 +75,3 @@ echo "6. Create PR on GitHub:"
 echo "   ${GREEN}https://github.com/steipete/CodexBar/compare/main...topoffunnel:$BRANCH_NAME${NC}"
 echo ""
 echo -e "${YELLOW}Remember: Keep PRs small and focused for better merge chances!${NC}"
-
diff --git a/Scripts/regenerate-codex-parser-hash.sh b/Scripts/regenerate-codex-parser-hash.sh
new file mode 100755
index 0000000000..91e4863e73
--- /dev/null
+++ b/Scripts/regenerate-codex-parser-hash.sh
@@ -0,0 +1,83 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+SOURCE_DIR="${ROOT_DIR}/Sources/CodexBarCore/Vendored/CostUsage"
+OUTPUT_FILE="${ROOT_DIR}/Sources/CodexBarCore/Generated/CodexParserHash.generated.swift"
+MODE="${1:-write}"
+
+case "$MODE" in
+  write | --write)
+    CHECK_ONLY=0
+    ;;
+  check | --check)
+    CHECK_ONLY=1
+    ;;
+  *)
+    echo "Usage: $0 [write|--write|check|--check]" >&2
+    exit 2
+    ;;
+esac
+
+if command -v shasum >/dev/null 2>&1; then
+  HASH_CMD=(shasum -a 256)
+elif command -v sha256sum >/dev/null 2>&1; then
+  HASH_CMD=(sha256sum)
+else
+  echo "error: shasum or sha256sum is required" >&2
+  exit 1
+fi
+
+FILE_LIST="$(mktemp)"
+trap 'rm -f "$FILE_LIST"' EXIT
+
+find "$SOURCE_DIR" \
+  -type f \
+  -name '*.swift' \
+  ! -name '*Claude*' \
+  -print |
+  sed "s#^${ROOT_DIR}/##" |
+  LC_ALL=C sort >"$FILE_LIST"
+
+HASH="$(
+  while IFS= read -r file; do
+    printf '== %s ==\n' "$file"
+    cat "${ROOT_DIR}/${file}"
+    printf '\n'
+  done <"$FILE_LIST" | "${HASH_CMD[@]}"
+)"
+HASH="${HASH%% *}"
+SHORT_HASH="${HASH:0:16}"
+
+render_generated() {
+  cat <<SWIFT
+// Generated by Scripts/regenerate-codex-parser-hash.sh. Do not edit by hand.
+
+enum CodexParserHash {
+    static let value = "$SHORT_HASH"
+}
+SWIFT
+}
+
+if [[ "$CHECK_ONLY" -eq 1 ]]; then
+  EXPECTED_FILE="$(mktemp)"
+  trap 'rm -f "$FILE_LIST" "$EXPECTED_FILE"' EXIT
+  render_generated >"$EXPECTED_FILE"
+  if ! cmp -s "$EXPECTED_FILE" "$OUTPUT_FILE"; then
+    echo "error: ${OUTPUT_FILE#${ROOT_DIR}/} is stale. Run Scripts/regenerate-codex-parser-hash.sh and commit the result." >&2
+    if [[ -f "$OUTPUT_FILE" ]]; then
+      diff -u "$OUTPUT_FILE" "$EXPECTED_FILE" >&2 || true
+    else
+      diff -u /dev/null "$EXPECTED_FILE" >&2 || true
+    fi
+    exit 1
+  fi
+  echo "Codex parser hash is current (${SHORT_HASH})"
+  exit 0
+fi
+
+mkdir -p "$(dirname "$OUTPUT_FILE")"
+render_generated >"$OUTPUT_FILE"
+
+echo "Updated ${OUTPUT_FILE#${ROOT_DIR}/} to ${SHORT_HASH}"
diff --git a/Scripts/release.sh b/Scripts/release.sh
index eda66bdc01..4a95fbe496 100755
--- a/Scripts/release.sh
+++ b/Scripts/release.sh
@@ -1,68 +1,4 @@
 #!/usr/bin/env bash
 set -euo pipefail
-
-ROOT=$(cd "$(dirname "$0")/.." && pwd)
-cd "$ROOT"
-
-source "$ROOT/version.env"
-source "$HOME/Projects/agent-scripts/release/sparkle_lib.sh"
-
-APPCAST="$ROOT/appcast.xml"
-APP_NAME="CodexBar"
-ARTIFACT_PREFIX="CodexBar-"
-BUNDLE_ID="com.steipete.codexbar"
-TAG="v${MARKETING_VERSION}"
-
-err() { echo "ERROR: $*" >&2; exit 1; }
-
-require_clean_worktree
-ensure_changelog_finalized "$MARKETING_VERSION"
-ensure_appcast_monotonic "$APPCAST" "$MARKETING_VERSION" "$BUILD_NUMBER"
-
-swiftformat Sources Tests >/dev/null
-swiftlint --strict
-swift test
-
-# Note: run this script in the foreground; do not background it so it waits to completion.
-"$ROOT/Scripts/sign-and-notarize.sh"
-
-KEY_FILE=$(clean_key "$SPARKLE_PRIVATE_KEY_FILE")
-trap 'rm -f "$KEY_FILE"' EXIT
-
-probe_sparkle_key "$KEY_FILE"
-
-clear_sparkle_caches "$BUNDLE_ID"
-
-NOTES_FILE=$(mktemp /tmp/codexbar-notes.XXXXXX.md)
-extract_notes_from_changelog "$MARKETING_VERSION" "$NOTES_FILE"
-trap 'rm -f "$KEY_FILE" "$NOTES_FILE"' EXIT
-
-git tag -f "$TAG"
-git push -f origin "$TAG"
-
-gh release create "$TAG" ${APP_NAME}-${MARKETING_VERSION}.zip ${APP_NAME}-${MARKETING_VERSION}.dSYM.zip \
-  --title "${APP_NAME} ${MARKETING_VERSION}" \
-  --notes-file "$NOTES_FILE"
-
-SPARKLE_PRIVATE_KEY_FILE="$KEY_FILE" \
-  "$ROOT/Scripts/make_appcast.sh" \
-  "${APP_NAME}-${MARKETING_VERSION}.zip" \
-  "https://raw.githubusercontent.com/steipete/CodexBar/main/appcast.xml"
-
-verify_appcast_entry "$APPCAST" "$MARKETING_VERSION" "$KEY_FILE"
-
-git add "$APPCAST"
-git commit -m "docs: update appcast for ${MARKETING_VERSION}"
-git push origin main
-
-if [[ "${RUN_SPARKLE_UPDATE_TEST:-0}" == "1" ]]; then
-  PREV_TAG=$(git tag --sort=-v:refname | sed -n '2p')
-  [[ -z "$PREV_TAG" ]] && err "RUN_SPARKLE_UPDATE_TEST=1 set but no previous tag found"
-  "$ROOT/Scripts/test_live_update.sh" "$PREV_TAG" "v${MARKETING_VERSION}"
-fi
-
-check_assets "$TAG" "$ARTIFACT_PREFIX"
-
-git push origin --tags
-
-echo "Release ${MARKETING_VERSION} complete."
+SCRIPT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+exec "$SCRIPT_DIR/mac-release" release "$@"
diff --git a/Scripts/release_artifacts.sh b/Scripts/release_artifacts.sh
new file mode 100755
index 0000000000..bc065c1dea
--- /dev/null
+++ b/Scripts/release_artifacts.sh
@@ -0,0 +1,44 @@
+#!/usr/bin/env bash
+
+codexbar_release_arch_label() {
+  local raw="${1:-arm64 x86_64}"
+  local normalized
+  local has_arm64=0
+  local has_x86_64=0
+  local arch
+
+  normalized=$(printf "%s" "$raw" | tr ',' ' ')
+  for arch in $normalized; do
+    case "$arch" in
+      arm64) has_arm64=1 ;;
+      x86_64) has_x86_64=1 ;;
+    esac
+  done
+
+  if [[ "$has_arm64" == "1" && "$has_x86_64" == "1" ]]; then
+    printf "macos-universal"
+    return
+  fi
+  if [[ "$has_arm64" == "1" ]]; then
+    printf "macos-arm64"
+    return
+  fi
+  if [[ "$has_x86_64" == "1" ]]; then
+    printf "macos-x86_64"
+    return
+  fi
+
+  printf "macos-%s" "$(printf "%s" "$normalized" | tr ' ' '+')"
+}
+
+codexbar_app_zip_name() {
+  local version=$1
+  local arches="${2:-arm64 x86_64}"
+  printf "CodexBar-%s-%s.zip" "$(codexbar_release_arch_label "$arches")" "$version"
+}
+
+codexbar_dsym_zip_name() {
+  local version=$1
+  local arches="${2:-arm64 x86_64}"
+  printf "CodexBar-%s-%s.dSYM.zip" "$(codexbar_release_arch_label "$arches")" "$version"
+}
diff --git a/Scripts/release_dsym_paths.sh b/Scripts/release_dsym_paths.sh
new file mode 100755
index 0000000000..56d88db473
--- /dev/null
+++ b/Scripts/release_dsym_paths.sh
@@ -0,0 +1,75 @@
+#!/usr/bin/env bash
+
+codexbar_dsym_dwarf_path() {
+  local dsym_path="$1"
+  local app_name="$2"
+  local dwarf_path="${dsym_path}/Contents/Resources/DWARF/${app_name}"
+
+  if [[ ! -f "$dwarf_path" ]]; then
+    echo "Missing fresh dSYM for ${app_name} at: ${dwarf_path}" >&2
+    return 1
+  fi
+
+  printf '%s\n' "$dwarf_path"
+}
+
+codexbar_require_dsym_dwarf_for_arch() {
+  local dsym_path="$1"
+  local app_name="$2"
+  local arch="$3"
+  local dwarf_path
+
+  if ! dwarf_path=$(codexbar_dsym_dwarf_path "$dsym_path" "$app_name"); then
+    return 1
+  fi
+
+  if ! lipo -archs "$dwarf_path" | tr ' ' '\n' | grep -qx "$arch"; then
+    echo "dSYM at ${dwarf_path} does not contain required architecture: ${arch}" >&2
+    return 1
+  fi
+
+  printf '%s\n' "$dwarf_path"
+}
+
+codexbar_dwarf_uuid_for_arch() {
+  local path="$1"
+  local arch="$2"
+  local uuid
+
+  uuid=$(dwarfdump --uuid "$path" | awk -v arch="(${arch})" '$1 == "UUID:" && $3 == arch { print $2; exit }')
+  if [[ -z "$uuid" ]]; then
+    echo "Missing UUID for ${arch} in: ${path}" >&2
+    return 1
+  fi
+
+  printf '%s\n' "$uuid"
+}
+
+codexbar_verify_dsym_matches_binary() {
+  local app_binary="$1"
+  local dsym_dwarf="$2"
+  shift 2
+  local arch app_uuid dsym_uuid
+
+  if [[ ! -f "$app_binary" ]]; then
+    echo "Missing app binary for dSYM UUID verification: ${app_binary}" >&2
+    return 1
+  fi
+  if [[ ! -f "$dsym_dwarf" ]]; then
+    echo "Missing dSYM DWARF file for UUID verification: ${dsym_dwarf}" >&2
+    return 1
+  fi
+
+  for arch in "$@"; do
+    if ! app_uuid=$(codexbar_dwarf_uuid_for_arch "$app_binary" "$arch"); then
+      return 1
+    fi
+    if ! dsym_uuid=$(codexbar_dwarf_uuid_for_arch "$dsym_dwarf" "$arch"); then
+      return 1
+    fi
+    if [[ "$app_uuid" != "$dsym_uuid" ]]; then
+      echo "dSYM UUID mismatch for ${arch}: app=${app_uuid}, dSYM=${dsym_uuid}" >&2
+      return 1
+    fi
+  done
+}
diff --git a/Scripts/review_upstream.sh b/Scripts/review_upstream.sh
index cf1f37688e..57b634eb69 100755
--- a/Scripts/review_upstream.sh
+++ b/Scripts/review_upstream.sh
@@ -1,8 +1,8 @@
-#!/bin/bash
+#!/usr/bin/env bash
 # Create a review branch for upstream changes
 # Usage: ./Scripts/review_upstream.sh [upstream|quotio]
 
-set -e
+set -euo pipefail
 
 UPSTREAM=${1:-upstream}
 DATE=$(date +%Y%m%d)
@@ -21,20 +21,81 @@ if [ "$UPSTREAM" != "upstream" ] && [ "$UPSTREAM" != "quotio" ]; then
     exit 1
 fi
 
-echo -e "${BLUE}==> Creating review branch for $UPSTREAM...${NC}"
-git checkout main
-git checkout -b "$BRANCH_NAME"
+ensure_remote() {
+    local remote=$1
+    local url=$2
+    local origin_url
+
+    if git remote get-url "$remote" >/dev/null 2>&1; then
+        echo "$remote"
+        return 0
+    fi
+
+    if [ "$remote" = "upstream" ] && git remote get-url origin >/dev/null 2>&1; then
+        origin_url=$(git remote get-url origin)
+        case "$origin_url" in
+            https://github.com/steipete/CodexBar|https://github.com/steipete/CodexBar.git|git@github.com:steipete/CodexBar.git)
+                echo -e "${YELLOW}Remote 'upstream' missing; using origin for steipete/CodexBar.${NC}" >&2
+                echo "origin"
+                return 0
+                ;;
+            *)
+                echo -e "${YELLOW}Remote 'upstream' missing; origin is not steipete/CodexBar, adding upstream.${NC}" >&2
+                ;;
+        esac
+    fi
+
+    echo -e "${YELLOW}Adding $remote remote...${NC}" >&2
+    git remote add "$remote" "$url"
+    echo "$remote"
+}
+
+remote_default_branch() {
+    local remote=$1
+    local branch=""
+    local candidate
+
+    branch=$(git symbolic-ref -q --short "refs/remotes/${remote}/HEAD" 2>/dev/null | sed "s#^${remote}/##" || true)
+    if [ -z "$branch" ]; then
+        branch=$(git remote show "$remote" 2>/dev/null | awk '/HEAD branch/ {print $NF; exit}' || true)
+    fi
+    if [ -n "$branch" ] && git rev-parse --verify -q "${remote}/${branch}" >/dev/null; then
+        echo "$branch"
+        return 0
+    fi
+
+    for candidate in main master; do
+        if git rev-parse --verify -q "${remote}/${candidate}" >/dev/null; then
+            echo "$candidate"
+            return 0
+        fi
+    done
+
+    echo -e "${RED}Error: Could not resolve default branch for remote '$remote'.${NC}" >&2
+    exit 1
+}
+
+case "$UPSTREAM" in
+    upstream) REMOTE=$(ensure_remote upstream "https://github.com/steipete/CodexBar.git") ;;
+    quotio) REMOTE=$(ensure_remote quotio "https://github.com/nguyenphutrong/quotio.git") ;;
+esac
 
 echo -e "${BLUE}==> Fetching latest from $UPSTREAM...${NC}"
-git fetch "$UPSTREAM"
+git fetch "$REMOTE" --prune
+REMOTE_BRANCH=$(remote_default_branch "$REMOTE")
+REMOTE_REF="${REMOTE}/${REMOTE_BRANCH}"
+
+echo -e "${BLUE}==> Creating review branch for $UPSTREAM (${REMOTE_REF})...${NC}"
+git switch main
+git switch -c "$BRANCH_NAME"
 
 echo ""
 echo -e "${GREEN}==> Commits to review:${NC}"
-git log --oneline --graph main.."$UPSTREAM"/main | head -30
+git log --oneline --graph "main..${REMOTE_REF}" | head -30 || true
 
 echo ""
 echo -e "${GREEN}==> File changes summary:${NC}"
-git diff --stat main.."$UPSTREAM"/main
+git diff --stat "main..${REMOTE_REF}"
 
 echo ""
 echo -e "${YELLOW}==> Review branch created: $BRANCH_NAME${NC}"
@@ -42,16 +103,16 @@ echo ""
 echo -e "${BLUE}Next steps:${NC}"
 echo ""
 echo "1. Review commits in detail:"
-echo "   ${GREEN}git log -p main..$UPSTREAM/main${NC}"
+echo "   ${GREEN}git log -p main..$REMOTE_REF${NC}"
 echo ""
 echo "2. View specific files:"
-echo "   ${GREEN}git show $UPSTREAM/main:path/to/file${NC}"
+echo "   ${GREEN}git show $REMOTE_REF:path/to/file${NC}"
 echo ""
 echo "3. Cherry-pick specific commits:"
 echo "   ${GREEN}git cherry-pick <commit-hash>${NC}"
 echo ""
 echo "4. Or merge all changes:"
-echo "   ${GREEN}git merge $UPSTREAM/main${NC}"
+echo "   ${GREEN}git merge $REMOTE_REF${NC}"
 echo ""
 echo "5. Test thoroughly:"
 echo "   ${GREEN}./Scripts/compile_and_run.sh${NC}"
@@ -68,10 +129,9 @@ LOG_FILE="upstream-review-${UPSTREAM}-${DATE}.txt"
 echo "=== Upstream Review: $UPSTREAM @ $DATE ===" > "$LOG_FILE"
 echo "" >> "$LOG_FILE"
 echo "Commits:" >> "$LOG_FILE"
-git log --oneline main.."$UPSTREAM"/main >> "$LOG_FILE"
+git log --oneline "main..${REMOTE_REF}" >> "$LOG_FILE"
 echo "" >> "$LOG_FILE"
 echo "File changes:" >> "$LOG_FILE"
-git diff --stat main.."$UPSTREAM"/main >> "$LOG_FILE"
+git diff --stat "main..${REMOTE_REF}" >> "$LOG_FILE"
 
 echo -e "${GREEN}Review log saved to: $LOG_FILE${NC}"
-
diff --git a/Scripts/sign-and-notarize.sh b/Scripts/sign-and-notarize.sh
index 6a6c87072b..12a4e570bb 100755
--- a/Scripts/sign-and-notarize.sh
+++ b/Scripts/sign-and-notarize.sh
@@ -6,36 +6,33 @@ APP_IDENTITY="Developer ID Application: Peter Steinberger (Y5PE65HELJ)"
 APP_BUNDLE="CodexBar.app"
 ROOT=$(cd "$(dirname "$0")/.." && pwd)
 source "$ROOT/version.env"
-ZIP_NAME="${APP_NAME}-${MARKETING_VERSION}.zip"
-DSYM_ZIP="${APP_NAME}-${MARKETING_VERSION}.dSYM.zip"
+source "$ROOT/Scripts/release_artifacts.sh"
+source "$ROOT/Scripts/package_product_paths.sh"
+source "$ROOT/Scripts/release_dsym_paths.sh"
+
+# Allow building a universal binary if ARCHES is provided; default to universal (arm64 + x86_64).
+ARCHES_VALUE=${ARCHES:-"arm64 x86_64"}
+ZIP_NAME=$(codexbar_app_zip_name "$MARKETING_VERSION" "$ARCHES_VALUE")
+DSYM_ZIP=$(codexbar_dsym_zip_name "$MARKETING_VERSION" "$ARCHES_VALUE")
 
 if [[ -z "${APP_STORE_CONNECT_API_KEY_P8:-}" || -z "${APP_STORE_CONNECT_KEY_ID:-}" || -z "${APP_STORE_CONNECT_ISSUER_ID:-}" ]]; then
   echo "Missing APP_STORE_CONNECT_* env vars (API key, key id, issuer id)." >&2
   exit 1
 fi
-if [[ -z "${SPARKLE_PRIVATE_KEY_FILE:-}" ]]; then
-  echo "SPARKLE_PRIVATE_KEY_FILE is required for release signing/verification." >&2
-  exit 1
-fi
-if [[ ! -f "$SPARKLE_PRIVATE_KEY_FILE" ]]; then
-  echo "Sparkle key file not found: $SPARKLE_PRIVATE_KEY_FILE" >&2
-  exit 1
-fi
-key_lines=$(grep -v '^[[:space:]]*#' "$SPARKLE_PRIVATE_KEY_FILE" | sed '/^[[:space:]]*$/d')
-if [[ $(printf "%s\n" "$key_lines" | wc -l) -ne 1 ]]; then
-  echo "Sparkle key file must contain exactly one base64 line (no comments/blank lines)." >&2
-  exit 1
-fi
 
-echo "$APP_STORE_CONNECT_API_KEY_P8" | sed 's/\\n/\n/g' > /tmp/codexbar-api-key.p8
-trap 'rm -f /tmp/codexbar-api-key.p8 /tmp/${APP_NAME}Notarize.zip' EXIT
+NOTARIZATION_TEMP_DIR=$(mktemp -d "${TMPDIR:-/tmp}/codexbar-notarize.XXXXXX")
+chmod 700 "$NOTARIZATION_TEMP_DIR"
+API_KEY_PATH="$NOTARIZATION_TEMP_DIR/codexbar-api-key.p8"
+NOTARIZATION_ZIP="$NOTARIZATION_TEMP_DIR/${APP_NAME}Notarize.zip"
+trap 'rm -rf "$NOTARIZATION_TEMP_DIR"' EXIT
+
+(
+  umask 077
+  printf '%s' "$APP_STORE_CONNECT_API_KEY_P8" | sed 's/\\n/\n/g' > "$API_KEY_PATH"
+)
+chmod 600 "$API_KEY_PATH"
 
-# Allow building a universal binary if ARCHES is provided; default to universal (arm64 + x86_64).
-ARCHES_VALUE=${ARCHES:-"arm64 x86_64"}
 ARCH_LIST=( ${ARCHES_VALUE} )
-for ARCH in "${ARCH_LIST[@]}"; do
-  swift build -c release --arch "$ARCH"
-done
 ARCHES="${ARCHES_VALUE}" ./Scripts/package_app.sh release
 
 ENTITLEMENTS_DIR="$ROOT/.build/entitlements"
@@ -64,11 +61,11 @@ codesign --force --timestamp --options runtime --sign "$APP_IDENTITY" \
   "$APP_BUNDLE"
 
 DITTO_BIN=${DITTO_BIN:-/usr/bin/ditto}
-"$DITTO_BIN" --norsrc -c -k --keepParent "$APP_BUNDLE" "/tmp/${APP_NAME}Notarize.zip"
+"$DITTO_BIN" --norsrc -c -k --keepParent "$APP_BUNDLE" "$NOTARIZATION_ZIP"
 
 echo "Submitting for notarization"
-xcrun notarytool submit "/tmp/${APP_NAME}Notarize.zip" \
-  --key /tmp/codexbar-api-key.p8 \
+xcrun notarytool submit "$NOTARIZATION_ZIP" \
+  --key "$API_KEY_PATH" \
   --key-id "$APP_STORE_CONNECT_KEY_ID" \
   --issuer "$APP_STORE_CONNECT_ISSUER_ID" \
   --wait
@@ -86,30 +83,46 @@ spctl -a -t exec -vv "$APP_BUNDLE"
 stapler validate "$APP_BUNDLE"
 
 echo "Packaging dSYM"
-FIRST_ARCH="${ARCH_LIST[0]}"
-PREFERRED_ARCH_DIR=".build/${FIRST_ARCH}-apple-macosx/release"
-DSYM_PATH="${PREFERRED_ARCH_DIR}/${APP_NAME}.dSYM"
-if [[ ! -d "$DSYM_PATH" ]]; then
-  echo "Missing dSYM at $DSYM_PATH" >&2
-  exit 1
-fi
+DSYM_STAGE_ROOT="$ROOT/.build/package-products/release"
+DSYM_PATHS=()
+for ARCH in "${ARCH_LIST[@]}"; do
+  STAGED_DSYM="$DSYM_STAGE_ROOT/$ARCH/${APP_NAME}.dSYM"
+  if [[ -d "$STAGED_DSYM" ]]; then
+    DSYM_PATHS+=("$STAGED_DSYM")
+    continue
+  fi
+  BIN_DIR=$(codexbar_swiftpm_bin_path release "$ARCH")
+  DSYM_PATHS+=("$(codexbar_resolve_dsym_path "$DSYM_STAGE_ROOT" "$BIN_DIR" "$APP_NAME" "$ARCH")")
+done
+
+DSYM_PATH="${DSYM_PATHS[0]}"
+DSYM_DWARF_PATHS=()
+for ((index = 0; index < ${#ARCH_LIST[@]}; index++)); do
+  ARCH="${ARCH_LIST[$index]}"
+  if ! ARCH_DSYM=$(codexbar_require_dsym_dwarf_for_arch "${DSYM_PATHS[$index]}" "$APP_NAME" "$ARCH"); then
+    exit 1
+  fi
+  DSYM_DWARF_PATHS+=("$ARCH_DSYM")
+done
+
 if [[ ${#ARCH_LIST[@]} -gt 1 ]]; then
-  MERGED_DSYM="${PREFERRED_ARCH_DIR}/${APP_NAME}.dSYM-universal"
-  rm -rf "$MERGED_DSYM"
+  MERGED_DSYM_ROOT="${DSYM_STAGE_ROOT}/${APP_NAME}.dSYM-universal"
+  MERGED_DSYM="${MERGED_DSYM_ROOT}/${APP_NAME}.dSYM"
+  rm -rf "$MERGED_DSYM_ROOT"
+  mkdir -p "$MERGED_DSYM_ROOT"
   cp -R "$DSYM_PATH" "$MERGED_DSYM"
   DWARF_PATH="${MERGED_DSYM}/Contents/Resources/DWARF/${APP_NAME}"
-  BINARIES=()
-  for ARCH in "${ARCH_LIST[@]}"; do
-    ARCH_DSYM=".build/${ARCH}-apple-macosx/release/${APP_NAME}.dSYM/Contents/Resources/DWARF/${APP_NAME}"
-    if [[ ! -f "$ARCH_DSYM" ]]; then
-      echo "Missing dSYM for ${ARCH} at $ARCH_DSYM" >&2
-      exit 1
-    fi
-    BINARIES+=("$ARCH_DSYM")
-  done
-  lipo -create "${BINARIES[@]}" -output "$DWARF_PATH"
+  lipo -create "${DSYM_DWARF_PATHS[@]}" -output "$DWARF_PATH"
   DSYM_PATH="$MERGED_DSYM"
 fi
+if [[ ! -d "$DSYM_PATH" ]]; then
+  echo "Missing dSYM at SwiftPM-reported path: $DSYM_PATH" >&2
+  exit 1
+fi
+codexbar_verify_dsym_matches_binary \
+  "$APP_BUNDLE/Contents/MacOS/$APP_NAME" \
+  "$DSYM_PATH/Contents/Resources/DWARF/$APP_NAME" \
+  "${ARCH_LIST[@]}"
 "$DITTO_BIN" --norsrc -c -k --keepParent "$DSYM_PATH" "$DSYM_ZIP"
 
 echo "Done: $ZIP_NAME"
diff --git a/Scripts/sparkle_signing_paths.sh b/Scripts/sparkle_signing_paths.sh
new file mode 100755
index 0000000000..bb0b6dae9c
--- /dev/null
+++ b/Scripts/sparkle_signing_paths.sh
@@ -0,0 +1,137 @@
+#!/usr/bin/env bash
+
+codexbar_resolve_sparkle_version_child() {
+  local versions_dir="$1"
+  local candidate="$2"
+  local label="$3"
+  local versions_root resolved
+
+  versions_root=$(cd "$versions_dir" && pwd -P)
+  if ! resolved=$(cd "$candidate" 2>/dev/null && pwd -P); then
+    echo "ERROR: Sparkle ${label} does not resolve: ${candidate}" >&2
+    return 1
+  fi
+  if [[ "$(dirname "$resolved")" != "$versions_root" ]]; then
+    echo "ERROR: Sparkle ${label} resolves outside the framework versions directory: ${candidate}" >&2
+    return 1
+  fi
+
+  printf '%s\n' "$resolved"
+}
+
+codexbar_sparkle_version_dir() {
+  local sparkle="$1"
+  local versions_dir="${sparkle}/Versions"
+
+  if [[ -L "$sparkle" ]]; then
+    echo "ERROR: Sparkle framework root must not be a symlink: ${sparkle}" >&2
+    return 1
+  fi
+  if [[ -L "$versions_dir" ]]; then
+    echo "ERROR: Sparkle versions directory must not be a symlink: ${versions_dir}" >&2
+    return 1
+  fi
+  if [[ ! -d "$versions_dir" ]]; then
+    echo "ERROR: Missing Sparkle versions directory: ${versions_dir}" >&2
+    return 1
+  fi
+
+  if [[ -e "$versions_dir/Current" || -L "$versions_dir/Current" ]]; then
+    local current
+    if ! current=$(codexbar_resolve_sparkle_version_child "$versions_dir" "$versions_dir/Current" "Versions/Current"); then
+      return 1
+    fi
+    printf '%s\n' "$current"
+    return
+  fi
+
+  local version_dirs=()
+  local candidate
+  shopt -s nullglob
+  for candidate in "$versions_dir"/*; do
+    if [[ -d "$candidate" ]]; then
+      version_dirs+=("$candidate")
+    fi
+  done
+  shopt -u nullglob
+
+  case "${#version_dirs[@]}" in
+    0)
+      echo "ERROR: Sparkle framework has no version directory under: ${versions_dir}" >&2
+      return 1
+      ;;
+    1)
+      local resolved
+      if ! resolved=$(codexbar_resolve_sparkle_version_child \
+        "$versions_dir" "${version_dirs[0]}" "version directory"); then
+        return 1
+      fi
+      printf '%s\n' "$resolved"
+      ;;
+    *)
+      echo "ERROR: Sparkle framework has multiple version directories and no Versions/Current symlink: ${versions_dir}" >&2
+      return 1
+      ;;
+  esac
+}
+
+codexbar_require_sparkle_signing_target() {
+  local path="$1"
+  local label="$2"
+  local trusted_root="$3"
+  local resolved trusted_root_resolved
+
+  if [[ -L "$path" ]]; then
+    echo "ERROR: Sparkle signing target must not be a symlink (${label}): ${path}" >&2
+    return 1
+  fi
+
+  if [[ ! -e "$path" ]]; then
+    echo "ERROR: Missing Sparkle signing target (${label}): ${path}" >&2
+    return 1
+  fi
+
+  if ! trusted_root_resolved=$(cd "$trusted_root" 2>/dev/null && pwd -P); then
+    echo "ERROR: Sparkle signing root does not resolve (${label}): ${trusted_root}" >&2
+    return 1
+  fi
+  if [[ -d "$path" ]]; then
+    resolved=$(cd "$path" && pwd -P)
+  else
+    resolved="$(cd "$(dirname "$path")" && pwd -P)/$(basename "$path")"
+  fi
+  if [[ "$resolved" != "$trusted_root_resolved" &&
+    "${resolved#"$trusted_root_resolved"/}" == "$resolved" ]]; then
+    echo "ERROR: Sparkle signing target resolves outside its trusted root (${label}): ${path}" >&2
+    return 1
+  fi
+
+  printf '%s\n' "$resolved"
+}
+
+codexbar_sparkle_signing_targets() {
+  local sparkle="$1"
+  local version_dir
+  if ! version_dir=$(codexbar_sparkle_version_dir "$sparkle"); then
+    return 1
+  fi
+
+  codexbar_require_sparkle_signing_target "$sparkle" "framework root" "$sparkle" || return 1
+  codexbar_require_sparkle_signing_target "$version_dir/Sparkle" "framework binary" "$version_dir" || return 1
+  codexbar_require_sparkle_signing_target "$version_dir/Autoupdate" "autoupdate tool" "$version_dir" || return 1
+  codexbar_require_sparkle_signing_target "$version_dir/Updater.app" "updater app" "$version_dir" || return 1
+  codexbar_require_sparkle_signing_target \
+    "$version_dir/Updater.app/Contents/MacOS/Updater" "updater executable" "$version_dir" || return 1
+  codexbar_require_sparkle_signing_target \
+    "$version_dir/XPCServices/Downloader.xpc" "downloader xpc" "$version_dir" || return 1
+  codexbar_require_sparkle_signing_target \
+    "$version_dir/XPCServices/Downloader.xpc/Contents/MacOS/Downloader" \
+    "downloader executable" "$version_dir" || return 1
+  codexbar_require_sparkle_signing_target \
+    "$version_dir/XPCServices/Installer.xpc" "installer xpc" "$version_dir" || return 1
+  codexbar_require_sparkle_signing_target \
+    "$version_dir/XPCServices/Installer.xpc/Contents/MacOS/Installer" \
+    "installer executable" "$version_dir" || return 1
+  codexbar_require_sparkle_signing_target "$version_dir" "framework version" "$version_dir" || return 1
+  codexbar_require_sparkle_signing_target "$sparkle" "framework root" "$sparkle" || return 1
+}
diff --git a/Scripts/test.sh b/Scripts/test.sh
new file mode 100755
index 0000000000..9b0f2c5cd8
--- /dev/null
+++ b/Scripts/test.sh
@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+GROUP_SIZE="${CODEXBAR_TEST_GROUP_SIZE:-12}"
+SUITE_TIMEOUT="${CODEXBAR_TEST_SUITE_TIMEOUT:-180}"
+
+cd "${ROOT_DIR}"
+ARGS=(
+  --group-size "${GROUP_SIZE}"
+  --timeout "${SUITE_TIMEOUT}"
+)
+
+if [[ -n "${CODEXBAR_TEST_SHARD_INDEX:-}" || -n "${CODEXBAR_TEST_SHARD_COUNT:-}" ]]; then
+  ARGS+=(
+    --shard-index "${CODEXBAR_TEST_SHARD_INDEX:?CODEXBAR_TEST_SHARD_COUNT requires CODEXBAR_TEST_SHARD_INDEX}"
+    --shard-count "${CODEXBAR_TEST_SHARD_COUNT:?CODEXBAR_TEST_SHARD_INDEX requires CODEXBAR_TEST_SHARD_COUNT}"
+  )
+fi
+
+exec python3 "${ROOT_DIR}/Scripts/ci_swift_test_by_suite.py" "${ARGS[@]}" "$@"
diff --git a/Scripts/test_ci_path_gate.sh b/Scripts/test_ci_path_gate.sh
new file mode 100755
index 0000000000..3cea56bb8a
--- /dev/null
+++ b/Scripts/test_ci_path_gate.sh
@@ -0,0 +1,99 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+tmp_dir="$(mktemp -d)"
+trap 'rm -rf "$tmp_dir"' EXIT
+
+assert_gate() {
+  local expected="$1"
+  local name="$2"
+  local paths_file="${tmp_dir}/${name}.paths"
+  local output_file="${tmp_dir}/${name}.output"
+  shift 2
+
+  printf '%s\n' "$@" > "$paths_file"
+  GITHUB_OUTPUT="$output_file" "${ROOT_DIR}/Scripts/ci_macos_test_gate.sh" "$paths_file" >/dev/null
+  local actual
+  actual="$(sed -n 's/^macos-tests=//p' "$output_file")"
+  if [[ "$actual" != "$expected" ]]; then
+    printf '%s: expected macos-tests=%s, got %s\n' "$name" "$expected" "${actual:-<empty>}" >&2
+    exit 1
+  fi
+}
+
+assert_gate false docs-only $'M\tdocs/providers.md' $'M\tREADME.md'
+assert_gate true configuration-doc $'M\tdocs/configuration.md'
+assert_gate true rename-to-configuration-doc $'R100\tdocs/old.md\tdocs/configuration.md'
+assert_gate true rename-from-configuration-doc $'R100\tdocs/configuration.md\tdocs/new.md'
+assert_gate true agents-contract $'M\tAGENTS.md'
+assert_gate true rename-to-agents-contract $'R100\tdocs/old.md\tAGENTS.md'
+assert_gate true rename-from-agents-contract $'R100\tAGENTS.md\tdocs/new.md'
+assert_gate true source $'M\tSources/CodexBar/App.swift'
+assert_gate false docs-site $'M\tdocs/index.html' $'M\tdocs/site.css' $'M\tdocs/site.js' \
+  $'M\tdocs/site-locales.mjs' $'M\tdocs/social.html' $'M\tdocs/social.png' \
+  $'M\tdocs/CNAME' $'M\tdocs/.nojekyll' $'M\tdocs/llms.txt'
+assert_gate false docs-site-assets $'M\tdocs/icon.png' $'M\tdocs/logos/provider-logo.svg'
+assert_gate true docs-unknown-code $'M\tdocs/custom-tool.js'
+assert_gate true docs-site-with-config $'M\tdocs/site.css' $'M\tdocs/configuration.md'
+assert_gate true empty
+assert_gate true source-to-docs $'R100\tSources/CodexBar/App.swift\tdocs/App.md'
+assert_gate true docs-to-source $'R100\tdocs/App.md\tSources/CodexBar/App.swift'
+assert_gate false docs-to-site $'R100\tdocs/old.md\tdocs/site.css'
+
+assert_gate_fails() {
+  local name="$1"
+  local paths_file="${tmp_dir}/${name}.paths"
+  local output_file="${tmp_dir}/${name}.output"
+  shift
+
+  printf '%s\n' "$@" > "$paths_file"
+  if GITHUB_OUTPUT="$output_file" "${ROOT_DIR}/Scripts/ci_macos_test_gate.sh" "$paths_file" >/dev/null 2>&1; then
+    printf '%s: malformed gate input unexpectedly succeeded\n' "$name" >&2
+    exit 1
+  fi
+  if [[ -s "$output_file" ]]; then
+    printf '%s: malformed gate input emitted an output\n' "$name" >&2
+    exit 1
+  fi
+}
+
+assert_gate_fails missing-rename-target $'R100\tREADME.md'
+assert_gate_fails extra-modified-path $'M\tREADME.md\tdocs/configuration.md'
+assert_gate_fails missing-rename-score $'R\tREADME.md\tdocs/README.md'
+assert_gate_fails invalid-rename-score $'Rfoo\tREADME.md\tdocs/README.md'
+assert_gate_fails out-of-range-rename-score $'R101\tREADME.md\tdocs/README.md'
+
+unterminated_paths="${tmp_dir}/unterminated.paths"
+unterminated_output="${tmp_dir}/unterminated.output"
+printf '%s' $'M\tREADME.md\tdocs/configuration.md' > "$unterminated_paths"
+if GITHUB_OUTPUT="$unterminated_output" \
+  "${ROOT_DIR}/Scripts/ci_macos_test_gate.sh" "$unterminated_paths" >/dev/null 2>&1
+then
+  printf 'unterminated malformed gate input unexpectedly succeeded\n' >&2
+  exit 1
+fi
+if [[ -s "$unterminated_output" ]]; then
+  printf 'unterminated malformed gate input emitted an output\n' >&2
+  exit 1
+fi
+
+verify="${ROOT_DIR}/Scripts/ci_verify_test_jobs.sh"
+"$verify" success success true success >/dev/null
+"$verify" success success false skipped >/dev/null
+
+assert_verify_fails() {
+  if "$verify" "$@" >/dev/null 2>&1; then
+    printf 'unexpected aggregate success: %s\n' "$*" >&2
+    exit 1
+  fi
+}
+
+assert_verify_fails success success true skipped
+assert_verify_fails success success false success
+assert_verify_fails success success "" skipped
+assert_verify_fails failure success true success
+assert_verify_fails success failure true success
+
+printf 'CI macOS path gate tests passed.\n'
diff --git a/Scripts/test_package_product_paths.sh b/Scripts/test_package_product_paths.sh
new file mode 100755
index 0000000000..1dcfb66f8c
--- /dev/null
+++ b/Scripts/test_package_product_paths.sh
@@ -0,0 +1,91 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT=$(cd "$(dirname "$0")/.." && pwd)
+source "$ROOT/Scripts/package_product_paths.sh"
+
+TEMP_DIR=$(mktemp -d "${TMPDIR:-/tmp}/codexbar-package-paths.XXXXXX")
+trap 'rm -rf "$TEMP_DIR"' EXIT
+
+NATIVE_DIR="$TEMP_DIR/.build/arm64-apple-macosx/release"
+SWIFTBUILD_DIR="$TEMP_DIR/.build/out/Products/Release"
+STAGE_ROOT="$TEMP_DIR/.build/package-products/release"
+mkdir -p "$NATIVE_DIR/CodexBar.dSYM" "$SWIFTBUILD_DIR/Sparkle.framework" "$SWIFTBUILD_DIR/CodexBar.dSYM"
+touch "$NATIVE_DIR/CodexBar" "$SWIFTBUILD_DIR/CodexBar"
+
+native=$(codexbar_require_product_file "$NATIVE_DIR" CodexBar arm64)
+[[ "$native" == "$NATIVE_DIR/CodexBar" ]]
+
+swiftbuild=$(codexbar_require_product_file "$SWIFTBUILD_DIR" CodexBar arm64)
+[[ "$swiftbuild" == "$SWIFTBUILD_DIR/CodexBar" ]]
+
+framework=$(codexbar_require_product_directory "$SWIFTBUILD_DIR" Sparkle.framework packaging)
+[[ "$framework" == "$SWIFTBUILD_DIR/Sparkle.framework" ]]
+
+dsym=$(codexbar_require_product_directory "$SWIFTBUILD_DIR" CodexBar.dSYM release)
+[[ "$dsym" == "$SWIFTBUILD_DIR/CodexBar.dSYM" ]]
+
+resolved=$(codexbar_resolve_staged_or_reported_file "$STAGE_ROOT" "$SWIFTBUILD_DIR" CodexBar arm64)
+[[ "$resolved" == "$SWIFTBUILD_DIR/CodexBar" ]]
+
+resolved_dsym=$(codexbar_resolve_dsym_path "$STAGE_ROOT" "$SWIFTBUILD_DIR" CodexBar arm64)
+[[ "$resolved_dsym" == "$SWIFTBUILD_DIR/CodexBar.dSYM" ]]
+
+mkdir -p "$STAGE_ROOT/arm64/CodexBar.dSYM"
+touch "$STAGE_ROOT/arm64/CodexBar"
+staged=$(codexbar_resolve_staged_or_reported_file "$STAGE_ROOT" "$SWIFTBUILD_DIR" CodexBar arm64)
+[[ "$staged" == "$STAGE_ROOT/arm64/CodexBar" ]]
+staged_dsym=$(codexbar_resolve_dsym_path "$STAGE_ROOT" "$SWIFTBUILD_DIR" CodexBar arm64)
+[[ "$staged_dsym" == "$STAGE_ROOT/arm64/CodexBar.dSYM" ]]
+
+rm -rf "$STAGE_ROOT"
+rm "$SWIFTBUILD_DIR/CodexBar"
+if codexbar_resolve_staged_or_reported_file "$STAGE_ROOT" "$SWIFTBUILD_DIR" CodexBar arm64 \
+  2>"$TEMP_DIR/missing-file.log"; then
+  echo "ERROR: Missing reported product unexpectedly fell back to legacy output." >&2
+  exit 1
+fi
+grep -Fq "$SWIFTBUILD_DIR/CodexBar" "$TEMP_DIR/missing-file.log"
+
+rm -rf "$SWIFTBUILD_DIR/Sparkle.framework"
+if codexbar_require_product_directory "$SWIFTBUILD_DIR" Sparkle.framework packaging \
+  2>"$TEMP_DIR/missing-directory.log"; then
+  echo "ERROR: Missing reported framework was accepted." >&2
+  exit 1
+fi
+grep -Fq "$SWIFTBUILD_DIR/Sparkle.framework" "$TEMP_DIR/missing-directory.log"
+
+rm -rf "$SWIFTBUILD_DIR/CodexBar.dSYM"
+if codexbar_resolve_dsym_path "$STAGE_ROOT" "$SWIFTBUILD_DIR" CodexBar arm64 \
+  2>"$TEMP_DIR/missing-dsym.log"; then
+  echo "ERROR: Missing reported dSYM unexpectedly fell back to legacy output." >&2
+  exit 1
+fi
+grep -Fq "$SWIFTBUILD_DIR/CodexBar.dSYM" "$TEMP_DIR/missing-dsym.log"
+
+swift() {
+  [[ "$*" == "build --show-bin-path -c release --arch arm64" ]]
+  printf '%s\n' "$SWIFTBUILD_DIR"
+}
+reported=$(codexbar_swiftpm_bin_path release arm64)
+[[ "$reported" == "$SWIFTBUILD_DIR" ]]
+
+swift() {
+  return 23
+}
+if codexbar_swiftpm_bin_path release arm64 2>"$TEMP_DIR/query.log"; then
+  echo "ERROR: SwiftPM bin-path query failure was ignored." >&2
+  exit 1
+fi
+grep -Fq "SwiftPM failed to report" "$TEMP_DIR/query.log"
+
+swift() {
+  return 0
+}
+if codexbar_swiftpm_bin_path release arm64 2>"$TEMP_DIR/empty.log"; then
+  echo "ERROR: Empty SwiftPM bin path was accepted." >&2
+  exit 1
+fi
+grep -Fq "SwiftPM reported an empty" "$TEMP_DIR/empty.log"
+
+echo "Package product path tests passed."
diff --git a/Scripts/test_package_strip.sh b/Scripts/test_package_strip.sh
new file mode 100755
index 0000000000..b8901d1786
--- /dev/null
+++ b/Scripts/test_package_strip.sh
@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT=$(cd "$(dirname "$0")/.." && pwd)
+PACKAGE_SCRIPT="$ROOT/Scripts/package_app.sh"
+FUNCTIONS_FILE=$(mktemp "${TMPDIR:-/tmp}/codexbar-package-strip-functions.XXXXXX")
+TEMP_DIR=$(mktemp -d "${TMPDIR:-/tmp}/codexbar-package-strip.XXXXXX")
+trap 'rm -rf "$FUNCTIONS_FILE" "$TEMP_DIR"' EXIT
+
+python3 - "$PACKAGE_SCRIPT" "$FUNCTIONS_FILE" <<'PY'
+import sys
+from pathlib import Path
+
+script = Path(sys.argv[1]).read_text()
+start = script.index('strip_release_binary() {')
+end = script.index('\n}\n', start) + 3
+Path(sys.argv[2]).write_text(script[start:end])
+PY
+
+xcrun() {
+  [[ "$1" == "strip" && "$2" == "-x" ]]
+  printf '%s\n' "$3" >> "$STRIP_LOG"
+}
+
+source "$FUNCTIONS_FILE"
+
+binary="$TEMP_DIR/CodexBar"
+touch "$binary"
+
+STRIP_LOG="$TEMP_DIR/release.log"
+LOWER_CONF=release
+strip_release_binary "$binary"
+grep -Fqx "$binary" "$STRIP_LOG"
+
+STRIP_LOG="$TEMP_DIR/debug.log"
+LOWER_CONF=debug
+strip_release_binary "$binary"
+[[ ! -e "$STRIP_LOG" ]]
+
+STRIP_LOG="$TEMP_DIR/missing.log"
+LOWER_CONF=release
+strip_release_binary "$TEMP_DIR/MissingBinary"
+[[ ! -e "$STRIP_LOG" ]]
+
+echo "Package strip tests passed."
diff --git a/Scripts/test_release_dsym_paths.sh b/Scripts/test_release_dsym_paths.sh
new file mode 100755
index 0000000000..353fb6df75
--- /dev/null
+++ b/Scripts/test_release_dsym_paths.sh
@@ -0,0 +1,108 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT=$(cd "$(dirname "$0")/.." && pwd)
+source "$ROOT/Scripts/release_dsym_paths.sh"
+
+TEMP_DIR=$(mktemp -d "${TMPDIR:-/tmp}/codexbar-release-dsym-paths.XXXXXX")
+trap 'rm -rf "$TEMP_DIR"' EXIT
+
+make_dsym() {
+  local dsym_path="$1"
+  mkdir -p "$dsym_path/Contents/Resources/DWARF"
+  touch "$dsym_path/Contents/Resources/DWARF/CodexBar"
+}
+
+ARM_DSYM="$TEMP_DIR/CodexBar arm64.dSYM"
+UNIVERSAL_DSYM="$TEMP_DIR/CodexBar universal.dSYM"
+WRONG_ARCH_DSYM="$TEMP_DIR/CodexBar stale.dSYM"
+MISSING_DWARF_DSYM="$TEMP_DIR/CodexBar missing.dSYM"
+APP_BINARY="$TEMP_DIR/CodexBar.app"
+MATCHING_DWARF="$TEMP_DIR/CodexBar matching"
+MISMATCHED_DWARF="$TEMP_DIR/CodexBar mismatched"
+MISSING_UUID_DWARF="$TEMP_DIR/CodexBar missing UUID"
+make_dsym "$ARM_DSYM"
+make_dsym "$UNIVERSAL_DSYM"
+make_dsym "$WRONG_ARCH_DSYM"
+mkdir -p "$MISSING_DWARF_DSYM/Contents/Resources/DWARF"
+touch "$APP_BINARY" "$MATCHING_DWARF" "$MISMATCHED_DWARF" "$MISSING_UUID_DWARF"
+
+lipo() {
+  [[ "$1" == "-archs" ]]
+  case "$2" in
+    "$ARM_DSYM/Contents/Resources/DWARF/CodexBar")
+      printf '%s\n' "arm64"
+      ;;
+    "$UNIVERSAL_DSYM/Contents/Resources/DWARF/CodexBar")
+      printf '%s\n' "arm64 x86_64"
+      ;;
+    "$WRONG_ARCH_DSYM/Contents/Resources/DWARF/CodexBar")
+      printf '%s\n' "x86_64"
+      ;;
+    *)
+      echo "unexpected lipo path: $2" >&2
+      return 2
+      ;;
+  esac
+}
+
+dwarfdump() {
+  [[ "$1" == "--uuid" ]]
+  case "$2" in
+    "$APP_BINARY" | "$MATCHING_DWARF")
+      printf '%s\n' \
+        "UUID: AAAAAAAA-AAAA-AAAA-AAAA-AAAAAAAAAAAA (arm64) $2" \
+        "UUID: BBBBBBBB-BBBB-BBBB-BBBB-BBBBBBBBBBBB (x86_64) $2"
+      ;;
+    "$MISMATCHED_DWARF")
+      printf '%s\n' \
+        "UUID: AAAAAAAA-AAAA-AAAA-AAAA-AAAAAAAAAAAA (arm64) $2" \
+        "UUID: CCCCCCCC-CCCC-CCCC-CCCC-CCCCCCCCCCCC (x86_64) $2"
+      ;;
+    "$MISSING_UUID_DWARF")
+      printf '%s\n' "UUID: AAAAAAAA-AAAA-AAAA-AAAA-AAAAAAAAAAAA (arm64) $2"
+      ;;
+    *)
+      echo "unexpected dwarfdump path: $2" >&2
+      return 2
+      ;;
+  esac
+}
+
+arm_dwarf=$(codexbar_require_dsym_dwarf_for_arch "$ARM_DSYM" CodexBar arm64)
+[[ "$arm_dwarf" == "$ARM_DSYM/Contents/Resources/DWARF/CodexBar" ]]
+
+x86_dwarf=$(codexbar_require_dsym_dwarf_for_arch "$UNIVERSAL_DSYM" CodexBar x86_64)
+[[ "$x86_dwarf" == "$UNIVERSAL_DSYM/Contents/Resources/DWARF/CodexBar" ]]
+
+if codexbar_require_dsym_dwarf_for_arch "$MISSING_DWARF_DSYM" CodexBar arm64 \
+  2>"$TEMP_DIR/missing-dwarf.log"; then
+  echo "ERROR: Missing dSYM DWARF file was accepted." >&2
+  exit 1
+fi
+grep -Fq "$MISSING_DWARF_DSYM/Contents/Resources/DWARF/CodexBar" "$TEMP_DIR/missing-dwarf.log"
+
+if codexbar_require_dsym_dwarf_for_arch "$WRONG_ARCH_DSYM" CodexBar arm64 \
+  2>"$TEMP_DIR/wrong-arch.log"; then
+  echo "ERROR: Wrong-architecture dSYM was accepted." >&2
+  exit 1
+fi
+grep -Fq "required architecture: arm64" "$TEMP_DIR/wrong-arch.log"
+
+codexbar_verify_dsym_matches_binary "$APP_BINARY" "$MATCHING_DWARF" arm64 x86_64
+
+if codexbar_verify_dsym_matches_binary "$APP_BINARY" "$MISMATCHED_DWARF" arm64 x86_64 \
+  2>"$TEMP_DIR/mismatched-uuid.log"; then
+  echo "ERROR: Mismatched dSYM UUID was accepted." >&2
+  exit 1
+fi
+grep -Fq "dSYM UUID mismatch for x86_64" "$TEMP_DIR/mismatched-uuid.log"
+
+if codexbar_verify_dsym_matches_binary "$APP_BINARY" "$MISSING_UUID_DWARF" arm64 x86_64 \
+  2>"$TEMP_DIR/missing-uuid.log"; then
+  echo "ERROR: Missing dSYM UUID was accepted." >&2
+  exit 1
+fi
+grep -Fq "Missing UUID for x86_64" "$TEMP_DIR/missing-uuid.log"
+
+echo "Release dSYM path tests passed."
diff --git a/Scripts/test_sparkle_signing_paths.sh b/Scripts/test_sparkle_signing_paths.sh
new file mode 100755
index 0000000000..f450e47288
--- /dev/null
+++ b/Scripts/test_sparkle_signing_paths.sh
@@ -0,0 +1,129 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT=$(cd "$(dirname "$0")/.." && pwd)
+source "$ROOT/Scripts/sparkle_signing_paths.sh"
+
+TEMP_DIR=$(mktemp -d "${TMPDIR:-/tmp}/codexbar-sparkle-signing.XXXXXX")
+TEMP_DIR=$(cd "$TEMP_DIR" && pwd -P)
+trap 'rm -rf "$TEMP_DIR"' EXIT
+
+make_sparkle_version() {
+  local sparkle="$1"
+  local version="$2"
+  local version_dir="$sparkle/Versions/$version"
+
+  mkdir -p \
+    "$version_dir/Updater.app/Contents/MacOS" \
+    "$version_dir/XPCServices/Downloader.xpc/Contents/MacOS" \
+    "$version_dir/XPCServices/Installer.xpc/Contents/MacOS"
+  touch \
+    "$version_dir/Sparkle" \
+    "$version_dir/Autoupdate" \
+    "$version_dir/Updater.app/Contents/MacOS/Updater" \
+    "$version_dir/XPCServices/Downloader.xpc/Contents/MacOS/Downloader" \
+    "$version_dir/XPCServices/Installer.xpc/Contents/MacOS/Installer"
+}
+
+SINGLE="$TEMP_DIR/Single Sparkle.framework"
+make_sparkle_version "$SINGLE" B
+single_version=$(codexbar_sparkle_version_dir "$SINGLE")
+[[ "$single_version" == "$SINGLE/Versions/B" ]]
+
+single_targets=$(codexbar_sparkle_signing_targets "$SINGLE")
+grep -Fqx "$SINGLE" <<<"$single_targets"
+grep -Fqx "$SINGLE/Versions/B/Sparkle" <<<"$single_targets"
+grep -Fqx "$SINGLE/Versions/B/XPCServices/Installer.xpc/Contents/MacOS/Installer" <<<"$single_targets"
+
+CURRENT="$TEMP_DIR/Current Sparkle.framework"
+make_sparkle_version "$CURRENT" A
+make_sparkle_version "$CURRENT" C
+ln -s C "$CURRENT/Versions/Current"
+current_version=$(codexbar_sparkle_version_dir "$CURRENT")
+[[ "$current_version" == "$CURRENT/Versions/C" ]]
+
+rm "$CURRENT/Versions/C/Autoupdate"
+if codexbar_sparkle_signing_targets "$CURRENT" >"$TEMP_DIR/missing-target.out" 2>"$TEMP_DIR/missing-target.log"; then
+  echo "ERROR: Missing Sparkle signing target was accepted." >&2
+  exit 1
+fi
+grep -Fq "Autoupdate" "$TEMP_DIR/missing-target.log"
+
+AMBIGUOUS="$TEMP_DIR/Ambiguous Sparkle.framework"
+make_sparkle_version "$AMBIGUOUS" A
+make_sparkle_version "$AMBIGUOUS" B
+if codexbar_sparkle_version_dir "$AMBIGUOUS" 2>"$TEMP_DIR/ambiguous.log"; then
+  echo "ERROR: Ambiguous Sparkle versions were accepted without Versions/Current." >&2
+  exit 1
+fi
+grep -Fq "multiple version directories" "$TEMP_DIR/ambiguous.log"
+
+BROKEN_CURRENT="$TEMP_DIR/Broken Current Sparkle.framework"
+make_sparkle_version "$BROKEN_CURRENT" B
+ln -s Missing "$BROKEN_CURRENT/Versions/Current"
+if codexbar_sparkle_version_dir "$BROKEN_CURRENT" 2>"$TEMP_DIR/broken-current.log"; then
+  echo "ERROR: Broken Sparkle Versions/Current was accepted." >&2
+  exit 1
+fi
+grep -Fq "Versions/Current does not resolve" "$TEMP_DIR/broken-current.log"
+
+ESCAPING_CURRENT="$TEMP_DIR/Escaping Current Sparkle.framework"
+OUTSIDE_SPARKLE="$TEMP_DIR/Outside Sparkle.framework"
+make_sparkle_version "$ESCAPING_CURRENT" B
+make_sparkle_version "$OUTSIDE_SPARKLE" C
+ln -s "$OUTSIDE_SPARKLE/Versions/C" "$ESCAPING_CURRENT/Versions/Current"
+if codexbar_sparkle_version_dir "$ESCAPING_CURRENT" 2>"$TEMP_DIR/escaping-current.log"; then
+  echo "ERROR: Escaping Sparkle Versions/Current was accepted." >&2
+  exit 1
+fi
+grep -Fq "outside the framework versions directory" "$TEMP_DIR/escaping-current.log"
+
+SYMLINKED_VERSIONS="$TEMP_DIR/Symlinked Versions Sparkle.framework"
+mkdir -p "$SYMLINKED_VERSIONS"
+ln -s "$OUTSIDE_SPARKLE/Versions" "$SYMLINKED_VERSIONS/Versions"
+if codexbar_sparkle_version_dir "$SYMLINKED_VERSIONS" 2>"$TEMP_DIR/symlinked-versions.log"; then
+  echo "ERROR: Symlinked Sparkle Versions directory was accepted." >&2
+  exit 1
+fi
+grep -Fq "versions directory must not be a symlink" "$TEMP_DIR/symlinked-versions.log"
+
+SYMLINKED_FRAMEWORK="$TEMP_DIR/Symlinked Sparkle.framework"
+ln -s "$OUTSIDE_SPARKLE" "$SYMLINKED_FRAMEWORK"
+if codexbar_sparkle_version_dir "$SYMLINKED_FRAMEWORK" 2>"$TEMP_DIR/symlinked-framework.log"; then
+  echo "ERROR: Symlinked Sparkle framework root was accepted." >&2
+  exit 1
+fi
+grep -Fq "framework root must not be a symlink" "$TEMP_DIR/symlinked-framework.log"
+
+SYMLINKED_TARGET="$TEMP_DIR/Symlinked Target Sparkle.framework"
+make_sparkle_version "$SYMLINKED_TARGET" B
+rm "$SYMLINKED_TARGET/Versions/B/Autoupdate"
+ln -s "$OUTSIDE_SPARKLE/Versions/C/Autoupdate" "$SYMLINKED_TARGET/Versions/B/Autoupdate"
+if codexbar_sparkle_signing_targets \
+  "$SYMLINKED_TARGET" >"$TEMP_DIR/symlinked-target.out" 2>"$TEMP_DIR/symlinked-target.log"; then
+  echo "ERROR: Symlinked Sparkle signing target was accepted." >&2
+  exit 1
+fi
+grep -Fq "signing target must not be a symlink" "$TEMP_DIR/symlinked-target.log"
+
+ESCAPING_TARGET_PARENT="$TEMP_DIR/Escaping Target Parent Sparkle.framework"
+make_sparkle_version "$ESCAPING_TARGET_PARENT" B
+mv "$ESCAPING_TARGET_PARENT/Versions/B/XPCServices" "$TEMP_DIR/displaced-xpc-services"
+ln -s "$OUTSIDE_SPARKLE/Versions/C/XPCServices" "$ESCAPING_TARGET_PARENT/Versions/B/XPCServices"
+if codexbar_sparkle_signing_targets \
+  "$ESCAPING_TARGET_PARENT" >"$TEMP_DIR/escaping-target-parent.out" 2>"$TEMP_DIR/escaping-target-parent.log"; then
+  echo "ERROR: Sparkle signing target with an escaping parent was accepted." >&2
+  exit 1
+fi
+grep -Fq "signing target resolves outside its trusted root" "$TEMP_DIR/escaping-target-parent.log"
+
+ESCAPING_SINGLE="$TEMP_DIR/Escaping Single Sparkle.framework"
+mkdir -p "$ESCAPING_SINGLE/Versions"
+ln -s "$OUTSIDE_SPARKLE/Versions/C" "$ESCAPING_SINGLE/Versions/B"
+if codexbar_sparkle_version_dir "$ESCAPING_SINGLE" 2>"$TEMP_DIR/escaping-single.log"; then
+  echo "ERROR: Escaping single Sparkle version directory was accepted." >&2
+  exit 1
+fi
+grep -Fq "outside the framework versions directory" "$TEMP_DIR/escaping-single.log"
+
+echo "Sparkle signing path tests passed."
diff --git a/Scripts/test_swift_test_sharding.sh b/Scripts/test_swift_test_sharding.sh
new file mode 100755
index 0000000000..9fb755d918
--- /dev/null
+++ b/Scripts/test_swift_test_sharding.sh
@@ -0,0 +1,120 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+TEMP_DIR="$(mktemp -d "${TMPDIR:-/tmp}/codexbar-test-sharding.XXXXXX")"
+trap 'rm -rf "${TEMP_DIR}"' EXIT
+
+IFS= read -r -d '' FAKE_SWIFT_SCRIPT <<'EOF' || true
+set -euo pipefail
+
+printf '%s\n' "$*" >> "${FAKE_SWIFT_LOG}"
+if [[ "$*" == "test list" ]]; then
+  if [[ "${FAKE_SWIFT_LIST_FAIL:-0}" == "1" ]]; then
+    printf 'test-list stdout marker\n'
+    printf 'test-list stderr marker\n' >&2
+    exit 42
+  fi
+  printf '%s\n' \
+    "CodexBarTests.Alpha/test_one()" \
+    "CodexBarTests.Alpha/test_two(argument:)" \
+    "CodexBarTests.Beta/test_two" \
+    'CodexBarTests.`top level works`()' \
+    'CodexBarTests.`top/level slash works`()'
+  exit 0
+fi
+if [[ "$*" == *"|"* ]]; then
+  group_runs="$(grep -c '|' "${FAKE_SWIFT_LOG}")"
+  if [[ "${FAKE_SWIFT_GROUP_ALWAYS_FAIL:-0}" == "1" || "${group_runs}" -eq 1 ]]; then
+    exit 1
+  fi
+fi
+EOF
+
+export FAKE_SWIFT_LOG="${TEMP_DIR}/swift.log"
+
+python3 "${ROOT_DIR}/Scripts/ci_swift_test_by_suite.py" \
+  --group-size 4 \
+  --timeout 10 \
+  --swift-command /bin/bash \
+  --swift-command-arg=-c \
+  --swift-command-arg="${FAKE_SWIFT_SCRIPT}" \
+  --swift-command-arg=fake-swift \
+  >"${TEMP_DIR}/retry.log"
+grep -Fq "failed with exit code 1; retrying shard once" "${TEMP_DIR}/retry.log"
+grep -Fq "CodexBarTests\\.Alpha" "${FAKE_SWIFT_LOG}"
+grep -Fq "CodexBarTests\\.Beta" "${FAKE_SWIFT_LOG}"
+grep -Fq "CodexBarTests\\..*top\\ level\\ works" "${FAKE_SWIFT_LOG}"
+grep -Fq "CodexBarTests\\..*top/level\\ slash\\ works" "${FAKE_SWIFT_LOG}"
+[[ "$(wc -l < "${FAKE_SWIFT_LOG}")" -eq 3 ]]
+
+python3 "${ROOT_DIR}/Scripts/ci_swift_test_by_suite.py" \
+  --group-size 1 \
+  --timeout 10 \
+  --shard-index 0 \
+  --shard-count 2 \
+  --list-only \
+  --swift-command /bin/bash \
+  --swift-command-arg=-c \
+  --swift-command-arg="${FAKE_SWIFT_SCRIPT}" \
+  --swift-command-arg=fake-swift \
+  >"${TEMP_DIR}/shard-0.log"
+
+python3 "${ROOT_DIR}/Scripts/ci_swift_test_by_suite.py" \
+  --group-size 1 \
+  --timeout 10 \
+  --shard-index 1 \
+  --shard-count 2 \
+  --list-only \
+  --swift-command /bin/bash \
+  --swift-command-arg=-c \
+  --swift-command-arg="${FAKE_SWIFT_SCRIPT}" \
+  --swift-command-arg=fake-swift \
+  >"${TEMP_DIR}/shard-1.log"
+
+cat "${TEMP_DIR}/shard-0.log" "${TEMP_DIR}/shard-1.log" \
+  | grep -v '^Discovered ' \
+  | sort >"${TEMP_DIR}/shards-combined.log"
+python3 "${ROOT_DIR}/Scripts/ci_swift_test_by_suite.py" \
+  --group-size 1 \
+  --timeout 10 \
+  --list-only \
+  --swift-command /bin/bash \
+  --swift-command-arg=-c \
+  --swift-command-arg="${FAKE_SWIFT_SCRIPT}" \
+  --swift-command-arg=fake-swift \
+  | grep -v '^Discovered ' \
+  | sort >"${TEMP_DIR}/shards-expected.log"
+diff -u "${TEMP_DIR}/shards-expected.log" "${TEMP_DIR}/shards-combined.log"
+
+if FAKE_SWIFT_GROUP_ALWAYS_FAIL=1 \
+  python3 "${ROOT_DIR}/Scripts/ci_swift_test_by_suite.py" \
+    --group-size 4 \
+    --timeout 10 \
+    --swift-command /bin/bash \
+    --swift-command-arg=-c \
+    --swift-command-arg="${FAKE_SWIFT_SCRIPT}" \
+    --swift-command-arg=fake-swift \
+    >"${TEMP_DIR}/failure.log" 2>&1; then
+  echo "ERROR: Repeated shard failure was masked." >&2
+  exit 1
+fi
+
+if FAKE_SWIFT_LIST_FAIL=1 \
+  python3 "${ROOT_DIR}/Scripts/ci_swift_test_by_suite.py" \
+    --group-size 1 \
+    --timeout 10 \
+    --list-only \
+    --swift-command /bin/bash \
+    --swift-command-arg=-c \
+    --swift-command-arg="${FAKE_SWIFT_SCRIPT}" \
+    --swift-command-arg=fake-swift \
+    >"${TEMP_DIR}/list-failure.log" 2>&1; then
+  echo "ERROR: Failed test discovery was masked." >&2
+  exit 1
+fi
+grep -Fq "test-list stdout marker" "${TEMP_DIR}/list-failure.log"
+grep -Fq "test-list stderr marker" "${TEMP_DIR}/list-failure.log"
+
+echo "Swift test sharding tests passed."
diff --git a/Scripts/verify_appcast.sh b/Scripts/verify_appcast.sh
index fc3735d2db..4e0f20037e 100755
--- a/Scripts/verify_appcast.sh
+++ b/Scripts/verify_appcast.sh
@@ -1,92 +1,4 @@
 #!/usr/bin/env bash
 set -euo pipefail
-
-# Verifies that the appcast entry for the given version has a valid ed25519 signature
-# and that the enclosure length matches the downloaded archive.
-#
-# Usage: SPARKLE_PRIVATE_KEY_FILE=/path/to/key ./Scripts/verify_appcast.sh [version]
-
-ROOT=$(cd "$(dirname "$0")/.." && pwd)
-VERSION=${1:-$(source "$ROOT/version.env" && echo "$MARKETING_VERSION")}
-APPCAST="${ROOT}/appcast.xml"
-
-if [[ -z "${SPARKLE_PRIVATE_KEY_FILE:-}" ]]; then
-  echo "SPARKLE_PRIVATE_KEY_FILE is required" >&2
-  exit 1
-fi
-if [[ ! -f "$SPARKLE_PRIVATE_KEY_FILE" ]]; then
-  echo "Sparkle key file not found: $SPARKLE_PRIVATE_KEY_FILE" >&2
-  exit 1
-fi
-if [[ ! -f "$APPCAST" ]]; then
-  echo "appcast.xml not found at $APPCAST" >&2
-  exit 1
-fi
-
-# Clean the key file: strip comments/blank lines and require exactly one line of base64.
-function cleaned_key_path() {
-  local tmp key_lines
-  key_lines=$(grep -v '^[[:space:]]*#' "$SPARKLE_PRIVATE_KEY_FILE" | sed '/^[[:space:]]*$/d')
-  if [[ $(printf "%s\n" "$key_lines" | wc -l) -ne 1 ]]; then
-    echo "Sparkle key file must contain exactly one base64 line (no comments/blank lines)." >&2
-    exit 1
-  fi
-  tmp=$(mktemp)
-  printf "%s" "$key_lines" > "$tmp"
-  echo "$tmp"
-}
-
-KEY_FILE=$(cleaned_key_path)
-trap 'rm -f "$KEY_FILE" "$TMP_ZIP"' EXIT
-
-TMP_ZIP=$(mktemp /tmp/codexbar-enclosure.XXXX.zip)
-
-python3 - "$APPCAST" "$VERSION" >"$TMP_ZIP.meta" <<'PY'
-import sys, xml.etree.ElementTree as ET
-
-appcast = sys.argv[1]
-version = sys.argv[2]
-tree = ET.parse(appcast)
-root = tree.getroot()
-ns = {"sparkle": "http://www.andymatuschak.org/xml-namespaces/sparkle"}
-
-entry = None
-for item in root.findall("./channel/item"):
-    sv = item.findtext("sparkle:shortVersionString", default="", namespaces=ns)
-    if sv == version:
-        entry = item
-        break
-
-if entry is None:
-    sys.exit("No appcast entry found for version {}".format(version))
-
-enclosure = entry.find("enclosure")
-url = enclosure.get("url")
-sig = enclosure.get("{http://www.andymatuschak.org/xml-namespaces/sparkle}edSignature")
-length = enclosure.get("length")
-
-if not all([url, sig, length]):
-    sys.exit("Missing url/signature/length in appcast for version {}".format(version))
-
-print(url)
-print(sig)
-print(length)
-PY
-
-readarray -t META <"$TMP_ZIP.meta"
-URL="${META[0]}"
-SIG="${META[1]}"
-LEN_EXPECTED="${META[2]}"
-
-echo "Downloading enclosure: $URL"
-curl -L -o "$TMP_ZIP" "$URL"
-
-LEN_ACTUAL=$(stat -f%z "$TMP_ZIP")
-if [[ "$LEN_ACTUAL" != "$LEN_EXPECTED" ]]; then
-  echo "Length mismatch: expected $LEN_EXPECTED, got $LEN_ACTUAL" >&2
-  exit 1
-fi
-
-echo "Verifying Sparkle signature…"
-sign_update --verify "$TMP_ZIP" "$SIG" --ed-key-file "$KEY_FILE"
-echo "Appcast entry for $VERSION verified (signature and length match)."
+SCRIPT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+exec "$SCRIPT_DIR/mac-release" verify-appcast "$@"
diff --git a/Sources/CSQLite3/module.modulemap b/Sources/CSQLite3/module.modulemap
new file mode 100644
index 0000000000..ae14eca222
--- /dev/null
+++ b/Sources/CSQLite3/module.modulemap
@@ -0,0 +1,5 @@
+module CSQLite3 [system] {
+    header "shim.h"
+    link "sqlite3"
+    export *
+}
diff --git a/Sources/CSQLite3/shim.h b/Sources/CSQLite3/shim.h
new file mode 100644
index 0000000000..f52e1f09e6
--- /dev/null
+++ b/Sources/CSQLite3/shim.h
@@ -0,0 +1 @@
+#include <sqlite3.h>
diff --git a/Sources/CodexBar/AppNotifications.swift b/Sources/CodexBar/AppNotifications.swift
index 6bd3bc55a5..56065dfb56 100644
--- a/Sources/CodexBar/AppNotifications.swift
+++ b/Sources/CodexBar/AppNotifications.swift
@@ -19,7 +19,13 @@ final class AppNotifications {
         _ = self.ensureAuthorizationTask()
     }
 
-    func post(idPrefix: String, title: String, body: String, badge: NSNumber? = nil) {
+    func post(
+        idPrefix: String,
+        title: String,
+        body: String,
+        badge: NSNumber? = nil,
+        soundEnabled: Bool = true)
+    {
         guard !Self.isRunningUnderTests else { return }
         let center = self.centerProvider()
         let logger = self.logger
@@ -34,7 +40,7 @@ final class AppNotifications {
             let content = UNMutableNotificationContent()
             content.title = title
             content.body = body
-            content.sound = .default
+            content.sound = soundEnabled ? .default : nil
             content.badge = badge
 
             let request = UNNotificationRequest(
diff --git a/Sources/CodexBar/ChartBarHoverSelection.swift b/Sources/CodexBar/ChartBarHoverSelection.swift
new file mode 100644
index 0000000000..cc01e74f99
--- /dev/null
+++ b/Sources/CodexBar/ChartBarHoverSelection.swift
@@ -0,0 +1,11 @@
+import Foundation
+
+enum ChartBarHoverSelection {
+    static func accepts(distanceFromBarCenter: CGFloat, barHalfWidth: CGFloat, selectableCount: Int) -> Bool {
+        selectableCount <= 1 || distanceFromBarCenter <= barHalfWidth
+    }
+
+    static func nextCalendarDay(after date: Date, calendar: Calendar = .current) -> Date {
+        calendar.date(byAdding: .day, value: 1, to: date) ?? date.addingTimeInterval(86400)
+    }
+}
diff --git a/Sources/CodexBar/ClaudeLoginRunner.swift b/Sources/CodexBar/ClaudeLoginRunner.swift
index dc13fd53b4..e9f89934f2 100644
--- a/Sources/CodexBar/ClaudeLoginRunner.swift
+++ b/Sources/CodexBar/ClaudeLoginRunner.swift
@@ -3,7 +3,7 @@ import Darwin
 import Foundation
 
 struct ClaudeLoginRunner {
-    enum Phase: Sendable {
+    enum Phase {
         case requesting
         case waitingBrowser
     }
diff --git a/Sources/CodexBar/ClickToCopyOverlay.swift b/Sources/CodexBar/ClickToCopyOverlay.swift
new file mode 100644
index 0000000000..b6ea3ea7d7
--- /dev/null
+++ b/Sources/CodexBar/ClickToCopyOverlay.swift
@@ -0,0 +1,77 @@
+import AppKit
+import SwiftUI
+
+@MainActor
+enum MenuPasteboardCopy {
+    typealias DeferredAction = @MainActor @Sendable () -> Void
+    typealias Scheduler = @MainActor @Sendable (@escaping DeferredAction) -> Void
+    typealias Writer = @MainActor @Sendable (String) -> Void
+
+    static func perform(
+        _ text: String,
+        scheduler: Scheduler = Self.schedule,
+        writer: @escaping Writer = Self.write,
+        completion: @escaping DeferredAction = {})
+    {
+        scheduler {
+            writer(text)
+            completion()
+        }
+    }
+
+    private static func schedule(_ action: @escaping DeferredAction) {
+        DispatchQueue.main.async(execute: action)
+    }
+
+    private static func write(_ text: String) {
+        let pasteboard = NSPasteboard.general
+        pasteboard.clearContents()
+        pasteboard.setString(text, forType: .string)
+    }
+}
+
+struct ClickToCopyOverlay: NSViewRepresentable {
+    let copyText: String
+
+    func makeNSView(context: Context) -> ClickToCopyView {
+        ClickToCopyView(copyText: self.copyText)
+    }
+
+    func updateNSView(_ nsView: ClickToCopyView, context: Context) {
+        // Guard against no-op writes to avoid AppKit view invalidation on every
+        // parent card SwiftUI diff (each MenuCardView body re-eval runs through
+        // .overlay { ClickToCopyOverlay(...) }, which calls updateNSView even
+        // when copyText is unchanged).
+        guard nsView.copyText != self.copyText else { return }
+        nsView.copyText = self.copyText
+    }
+}
+
+final class ClickToCopyView: NSView {
+    var copyText: String
+    private let copyAction: (String) -> Void
+
+    init(
+        copyText: String,
+        copyAction: @escaping (String) -> Void = { MenuPasteboardCopy.perform($0) })
+    {
+        self.copyText = copyText
+        self.copyAction = copyAction
+        super.init(frame: .zero)
+        self.wantsLayer = false
+    }
+
+    @available(*, unavailable)
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    override func acceptsFirstMouse(for event: NSEvent?) -> Bool {
+        true
+    }
+
+    override func mouseDown(with event: NSEvent) {
+        _ = event
+        self.copyAction(self.copyText)
+    }
+}
diff --git a/Sources/CodexBar/CodexAccountMenuPresentation.swift b/Sources/CodexBar/CodexAccountMenuPresentation.swift
new file mode 100644
index 0000000000..5628ee26e1
--- /dev/null
+++ b/Sources/CodexBar/CodexAccountMenuPresentation.swift
@@ -0,0 +1,180 @@
+import CodexBarCore
+import Foundation
+
+enum CodexAccountHealth: Equatable {
+    case ok
+    case needsReauth
+    case workspaceDeactivated
+    case missingAuth
+    case unavailable
+
+    var label: String? {
+        switch self {
+        case .ok:
+            nil
+        case .needsReauth:
+            "Needs re-auth"
+        case .workspaceDeactivated:
+            "Workspace deactivated"
+        case .missingAuth:
+            "Missing auth"
+        case .unavailable:
+            "Unavailable"
+        }
+    }
+
+    static func status(for account: CodexVisibleAccount, error: String?) -> CodexAccountHealth {
+        if let error {
+            return self.status(forError: error)
+        }
+        if account.authenticationHealthLabel != nil {
+            return .missingAuth
+        }
+        return .ok
+    }
+
+    static func status(forError error: String) -> CodexAccountHealth {
+        let normalized = error.lowercased()
+        if normalized.contains("deactivated") {
+            return .workspaceDeactivated
+        }
+        if normalized.contains("expired") ||
+            normalized.contains("revoked") ||
+            normalized.contains("unauthorized") ||
+            normalized.contains("401")
+        {
+            return .needsReauth
+        }
+        if normalized.contains("missing"), normalized.contains("auth") {
+            return .missingAuth
+        }
+        return .unavailable
+    }
+}
+
+enum CodexAccountPresentationOrdering {
+    static func orderedAccounts(
+        _ accounts: [CodexVisibleAccount],
+        snapshots: [CodexAccountUsageSnapshot],
+        activeVisibleAccountID: String?)
+        -> [CodexVisibleAccount]
+    {
+        guard accounts.count > 1 else { return accounts }
+        let snapshotByID = Dictionary(uniqueKeysWithValues: snapshots.map { ($0.id, $0) })
+        let rankedAccounts = accounts.enumerated().map { index, account in
+            RankedAccount(
+                account: account,
+                rank: Rank(
+                    account: account,
+                    snapshot: snapshotByID[account.id],
+                    activeVisibleAccountID: activeVisibleAccountID,
+                    originalIndex: index))
+        }
+        let grouped = Dictionary(grouping: rankedAccounts, by: { Self.workspaceSortKey(for: $0.account) })
+        return grouped.values.sorted { lhs, rhs in
+            (lhs.map(\.rank).min() ?? .last) < (rhs.map(\.rank).min() ?? .last)
+        }.flatMap { group in
+            group.sorted { lhs, rhs in lhs.rank < rhs.rank }.map(\.account)
+        }
+    }
+
+    private struct RankedAccount {
+        let account: CodexVisibleAccount
+        let rank: Rank
+    }
+
+    private struct Rank: Comparable {
+        static let last = Rank(bucket: Int.max, availabilityScore: -.greatestFiniteMagnitude, originalIndex: Int.max)
+
+        let bucket: Int
+        let availabilityScore: Double
+        let displaySort: String
+        let originalIndex: Int
+
+        private init(bucket: Int, availabilityScore: Double, originalIndex: Int) {
+            self.bucket = bucket
+            self.availabilityScore = availabilityScore
+            self.displaySort = ""
+            self.originalIndex = originalIndex
+        }
+
+        init(
+            account: CodexVisibleAccount,
+            snapshot: CodexAccountUsageSnapshot?,
+            activeVisibleAccountID: String?,
+            originalIndex: Int)
+        {
+            self.originalIndex = originalIndex
+            self.displaySort = account.menuDisplayName.lowercased()
+
+            if account.id == activeVisibleAccountID {
+                self.bucket = 0
+            } else {
+                let health = CodexAccountHealth.status(for: account, error: snapshot?.error)
+                if health != .ok {
+                    self.bucket = health == .missingAuth ? 4 : 3
+                } else if let availability = Self.availability(snapshot?.snapshot), availability <= 0 {
+                    self.bucket = 2
+                } else {
+                    self.bucket = 1
+                }
+            }
+            self.availabilityScore = Self.availability(snapshot?.snapshot) ?? -1
+        }
+
+        static func < (lhs: Rank, rhs: Rank) -> Bool {
+            if lhs.bucket != rhs.bucket { return lhs.bucket < rhs.bucket }
+            if lhs.availabilityScore != rhs.availabilityScore {
+                return lhs.availabilityScore > rhs.availabilityScore
+            }
+            if lhs.displaySort != rhs.displaySort { return lhs.displaySort < rhs.displaySort }
+            return lhs.originalIndex < rhs.originalIndex
+        }
+
+        private static func availability(_ snapshot: UsageSnapshot?) -> Double? {
+            guard let snapshot else { return nil }
+            let session = snapshot.primary?.remainingPercent
+            let weekly = snapshot.secondary?.remainingPercent
+            return switch (session, weekly) {
+            case let (.some(session), .some(weekly)):
+                min(session, weekly)
+            case let (.some(session), .none):
+                session
+            case let (.none, .some(weekly)):
+                weekly
+            case (.none, .none):
+                nil
+            }
+        }
+    }
+
+    private static func workspaceSortKey(for account: CodexVisibleAccount) -> String {
+        if let workspaceAccountID = account.workspaceAccountID, !workspaceAccountID.isEmpty {
+            return workspaceAccountID.lowercased()
+        }
+        return account.menuWorkspaceLabel?.lowercased() ?? "personal"
+    }
+}
+
+struct CodexAccountWorkspaceSection: Equatable {
+    let title: String
+    let accounts: [CodexVisibleAccount]
+}
+
+extension [CodexVisibleAccount] {
+    func codexWorkspaceSections() -> [CodexAccountWorkspaceSection] {
+        guard !self.isEmpty else { return [] }
+        var sections: [CodexAccountWorkspaceSection] = []
+        for account in self {
+            let title = account.menuWorkspaceLabel ?? "Personal"
+            if let index = sections.firstIndex(where: { $0.title == title }) {
+                var accounts = sections[index].accounts
+                accounts.append(account)
+                sections[index] = CodexAccountWorkspaceSection(title: title, accounts: accounts)
+            } else {
+                sections.append(CodexAccountWorkspaceSection(title: title, accounts: [account]))
+            }
+        }
+        return sections
+    }
+}
diff --git a/Sources/CodexBar/CodexAccountPromotionCoordinator.swift b/Sources/CodexBar/CodexAccountPromotionCoordinator.swift
new file mode 100644
index 0000000000..c22699bef0
--- /dev/null
+++ b/Sources/CodexBar/CodexAccountPromotionCoordinator.swift
@@ -0,0 +1,114 @@
+import Foundation
+import Observation
+
+struct CodexSystemAccountPromotionUserFacingError: Error, Equatable {
+    let title: String
+    let message: String
+}
+
+@MainActor
+@Observable
+final class CodexAccountPromotionCoordinator {
+    let service: CodexAccountPromotionService
+    weak var managedAccountCoordinator: ManagedCodexAccountCoordinator?
+    private(set) var isAuthenticatingLiveAccount = false
+    private(set) var isPromotingSystemAccount = false
+    private(set) var userFacingError: CodexSystemAccountPromotionUserFacingError?
+
+    init(
+        service: CodexAccountPromotionService,
+        managedAccountCoordinator: ManagedCodexAccountCoordinator? = nil)
+    {
+        self.service = service
+        self.managedAccountCoordinator = managedAccountCoordinator
+    }
+
+    convenience init(
+        settingsStore: SettingsStore,
+        usageStore: UsageStore,
+        managedAccountCoordinator: ManagedCodexAccountCoordinator? = nil)
+    {
+        self.init(
+            service: CodexAccountPromotionService(settingsStore: settingsStore, usageStore: usageStore),
+            managedAccountCoordinator: managedAccountCoordinator)
+    }
+
+    func promote(managedAccountID: UUID)
+        async -> Result<CodexAccountPromotionResult, CodexSystemAccountPromotionUserFacingError>
+    {
+        self.userFacingError = nil
+
+        guard !self.isInteractionBlocked() else {
+            let error = Self.interactionBlockedError()
+            self.userFacingError = error
+            return .failure(error)
+        }
+
+        self.isPromotingSystemAccount = true
+        defer { self.isPromotingSystemAccount = false }
+
+        do {
+            let result = try await self.service.promoteManagedAccount(id: managedAccountID)
+            return .success(result)
+        } catch {
+            let mapped = Self.mapUserFacingError(error)
+            self.userFacingError = mapped
+            return .failure(mapped)
+        }
+    }
+
+    func clearError() {
+        self.userFacingError = nil
+    }
+
+    func setLiveReauthenticationInProgress(_ isInProgress: Bool) {
+        self.isAuthenticatingLiveAccount = isInProgress
+    }
+
+    func isInteractionBlocked() -> Bool {
+        self.isPromotingSystemAccount ||
+            self.isAuthenticatingLiveAccount ||
+            self.managedAccountCoordinator?.hasConflictingManagedAccountOperationInFlight == true
+    }
+
+    private static func interactionBlockedError() -> CodexSystemAccountPromotionUserFacingError {
+        CodexSystemAccountPromotionUserFacingError(
+            title: L("Could not switch system account"),
+            message: L("Finish the current managed account change before switching the system account."))
+    }
+
+    static func mapUserFacingError(_ error: Error) -> CodexSystemAccountPromotionUserFacingError {
+        let title = L("Could not switch system account")
+
+        if let error = error as? CodexAccountPromotionError {
+            let message = switch error {
+            case .targetManagedAccountNotFound:
+                L("That account is no longer available in CodexBar. Refresh the account list and try again.")
+            case .targetManagedAccountAuthMissing:
+                L("CodexBar could not find saved auth for that account. Re-authenticate it and try again.")
+            case .targetManagedAccountAuthUnreadable:
+                L("CodexBar could not read saved auth for that account. Re-authenticate it and try again.")
+            case .liveAccountUnreadable:
+                L("CodexBar could not read the current system account on this Mac.")
+            case .liveAccountMissingIdentityForPreservation:
+                L("CodexBar could not safely preserve the current system account before switching.")
+            case .liveAccountAPIKeyOnlyUnsupported:
+                L("CodexBar can't replace a system account that is signed in with an API key only setup.")
+            case .displacedLiveManagedAccountConflict:
+                L(
+                    "CodexBar found another managed account that already uses the current system account. " +
+                        "Resolve the duplicate account before switching.")
+            case .displacedLiveImportFailed:
+                L("CodexBar could not save the current system account before switching.")
+            case .managedStoreCommitFailed:
+                L("CodexBar could not update managed account storage.")
+            case .liveAuthSwapFailed:
+                L("CodexBar could not replace the live Codex auth on this Mac.")
+            }
+
+            return CodexSystemAccountPromotionUserFacingError(title: title, message: message)
+        }
+
+        return CodexSystemAccountPromotionUserFacingError(title: title, message: error.localizedDescription)
+    }
+}
diff --git a/Sources/CodexBar/CodexAccountPromotionExecution.swift b/Sources/CodexBar/CodexAccountPromotionExecution.swift
new file mode 100644
index 0000000000..7ca58658f8
--- /dev/null
+++ b/Sources/CodexBar/CodexAccountPromotionExecution.swift
@@ -0,0 +1,277 @@
+import CodexBarCore
+import Foundation
+
+private struct CodexPreparedImportedAccount {
+    let account: ManagedCodexAccount
+    let homeURL: URL
+}
+
+struct CodexDisplacedLivePreservationExecutionResult: Equatable {
+    let displacedLiveDisposition: CodexAccountPromotionResult.DisplacedLiveDisposition
+}
+
+@MainActor
+struct CodexDisplacedLivePreservationExecutor {
+    private let store: any ManagedCodexAccountStoring
+    private let homeFactory: any ManagedCodexHomeProducing
+    private let fileManager: FileManager
+
+    init(
+        store: any ManagedCodexAccountStoring,
+        homeFactory: any ManagedCodexHomeProducing,
+        fileManager: FileManager = .default)
+    {
+        self.store = store
+        self.homeFactory = homeFactory
+        self.fileManager = fileManager
+    }
+
+    func execute(
+        plan: CodexDisplacedLivePreservationPlan,
+        context: PreparedPromotionContext) throws
+        -> CodexDisplacedLivePreservationExecutionResult
+    {
+        /*
+         Safety contract:
+         - This executor never swaps live auth. The caller must do that only after success.
+         - Import cleanup is best-effort and leaves no orphaned managed home on failure.
+         - Refresh/repair may copy auth before store commit, matching current behavior.
+         */
+        switch plan {
+        case .none:
+            return CodexDisplacedLivePreservationExecutionResult(displacedLiveDisposition: .none)
+
+        case let .reject(reason):
+            throw self.error(for: reason)
+
+        case .importNew:
+            let importedAccount = try self.importDisplacedLiveAccount(from: context)
+            return try self.commitImportedAccount(importedAccount)
+
+        case let .refreshExisting(destination, _),
+             let .repairExisting(destination, _):
+            guard destination.persisted.id != context.target.persisted.id else {
+                throw CodexAccountPromotionError.managedStoreCommitFailed
+            }
+
+            let refreshed = try self.refreshExistingManagedAccount(destination, from: context)
+            return CodexDisplacedLivePreservationExecutionResult(
+                displacedLiveDisposition: .alreadyManaged(managedAccountID: refreshed.id))
+        }
+    }
+
+    private func error(for reason: CodexDisplacedLivePreservationRejectReason) -> CodexAccountPromotionError {
+        switch reason {
+        case .liveUnreadable:
+            .liveAccountUnreadable
+        case .liveAPIKeyOnlyUnsupported:
+            .liveAccountAPIKeyOnlyUnsupported
+        case .liveIdentityMissingForPreservation:
+            .liveAccountMissingIdentityForPreservation
+        case .conflictingReadableManagedHome:
+            .displacedLiveManagedAccountConflict
+        }
+    }
+
+    private func importDisplacedLiveAccount(
+        from context: PreparedPromotionContext) throws
+        -> CodexPreparedImportedAccount
+    {
+        guard case let .readable(liveAuthMaterial) = context.live.homeState else {
+            throw CodexAccountPromotionError.displacedLiveImportFailed
+        }
+
+        let importedHomeURL = self.homeFactory.makeHomeURL()
+        let importedAccountID = Self.accountID(for: importedHomeURL)
+
+        do {
+            try self.fileManager.createDirectory(at: importedHomeURL, withIntermediateDirectories: true)
+            try self.writeManagedAuthData(liveAuthMaterial.rawData, to: importedHomeURL)
+
+            guard let liveAuthIdentity = context.live.authIdentity,
+                  let email = liveAuthIdentity.email,
+                  liveAuthIdentity.identity != .unresolved
+            else {
+                throw CodexAccountPromotionError.liveAccountMissingIdentityForPreservation
+            }
+
+            let now = Date().timeIntervalSince1970
+            return CodexPreparedImportedAccount(
+                account: ManagedCodexAccount(
+                    id: importedAccountID,
+                    email: email,
+                    providerAccountID: liveAuthIdentity.providerAccountID,
+                    workspaceLabel: liveAuthIdentity.workspaceLabel,
+                    workspaceAccountID: liveAuthIdentity.workspaceAccountID,
+                    authFingerprint: CodexAuthFingerprint.fingerprint(data: liveAuthMaterial.rawData),
+                    managedHomePath: importedHomeURL.path,
+                    createdAt: now,
+                    updatedAt: now,
+                    lastAuthenticatedAt: now),
+                homeURL: importedHomeURL)
+        } catch let error as CodexAccountPromotionError {
+            try? self.removeManagedHomeIfSafe(importedHomeURL)
+            throw error
+        } catch {
+            try? self.removeManagedHomeIfSafe(importedHomeURL)
+            throw CodexAccountPromotionError.displacedLiveImportFailed
+        }
+    }
+
+    private func commitImportedAccount(_ importedAccount: CodexPreparedImportedAccount) throws
+        -> CodexDisplacedLivePreservationExecutionResult
+    {
+        do {
+            let latestManagedAccounts = try self.store.loadAccounts()
+            try self.store.storeAccounts(ManagedCodexAccountSet(
+                version: latestManagedAccounts.version,
+                accounts: latestManagedAccounts.accounts + [importedAccount.account]))
+            return try self.resolveImportedAccountAfterCommit(importedAccount)
+        } catch let error as CodexAccountPromotionError {
+            try? self.removeManagedHomeIfSafe(importedAccount.homeURL)
+            throw error
+        } catch {
+            try? self.removeManagedHomeIfSafe(importedAccount.homeURL)
+            throw CodexAccountPromotionError.managedStoreCommitFailed
+        }
+    }
+
+    private func resolveImportedAccountAfterCommit(_ importedAccount: CodexPreparedImportedAccount) throws
+        -> CodexDisplacedLivePreservationExecutionResult
+    {
+        let persistedManagedAccounts = try self.store.loadAccounts()
+        if persistedManagedAccounts.account(id: importedAccount.account.id) != nil {
+            return CodexDisplacedLivePreservationExecutionResult(
+                displacedLiveDisposition: .imported(managedAccountID: importedAccount.account.id))
+        }
+
+        guard let existingManagedAccount = self.repairDestination(
+            in: persistedManagedAccounts,
+            for: importedAccount.account)
+        else {
+            throw CodexAccountPromotionError.managedStoreCommitFailed
+        }
+
+        let repairedManagedAccount = ManagedCodexAccount(
+            id: existingManagedAccount.id,
+            email: importedAccount.account.email,
+            providerAccountID: importedAccount.account.providerAccountID,
+            workspaceLabel: importedAccount.account.workspaceLabel,
+            workspaceAccountID: importedAccount.account.workspaceAccountID,
+            authFingerprint: importedAccount.account.authFingerprint,
+            managedHomePath: importedAccount.homeURL.path,
+            createdAt: existingManagedAccount.createdAt,
+            updatedAt: importedAccount.account.updatedAt,
+            lastAuthenticatedAt: importedAccount.account.lastAuthenticatedAt)
+        try self.store.storeAccounts(ManagedCodexAccountSet(
+            version: persistedManagedAccounts.version,
+            accounts: persistedManagedAccounts.accounts.map { account in
+                guard account.id == existingManagedAccount.id else { return account }
+                return repairedManagedAccount
+            }))
+        if existingManagedAccount.managedHomePath != importedAccount.homeURL.path {
+            try? self.removeManagedHomeIfSafe(
+                URL(fileURLWithPath: existingManagedAccount.managedHomePath, isDirectory: true))
+        }
+
+        return CodexDisplacedLivePreservationExecutionResult(
+            displacedLiveDisposition: .alreadyManaged(managedAccountID: existingManagedAccount.id))
+    }
+
+    private func repairDestination(
+        in persistedManagedAccounts: ManagedCodexAccountSet,
+        for importedAccount: ManagedCodexAccount) -> ManagedCodexAccount?
+    {
+        if let providerAccountID = importedAccount.providerAccountID {
+            return persistedManagedAccounts.account(
+                email: importedAccount.email,
+                providerAccountID: providerAccountID)
+        }
+
+        let normalizedEmail = importedAccount.email
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .lowercased()
+        return persistedManagedAccounts.accounts.first {
+            $0.email == normalizedEmail && $0.providerAccountID == nil
+        }
+    }
+
+    private func refreshExistingManagedAccount(
+        _ destination: PreparedStoredManagedAccount,
+        from context: PreparedPromotionContext) throws
+        -> ManagedCodexAccount
+    {
+        guard case let .readable(liveAuthMaterial) = context.live.homeState else {
+            throw CodexAccountPromotionError.managedStoreCommitFailed
+        }
+        guard let liveAuthIdentity = context.live.authIdentity else {
+            throw CodexAccountPromotionError.liveAccountMissingIdentityForPreservation
+        }
+
+        do {
+            let latestManagedAccounts = try self.store.loadAccounts()
+            guard let persistedManagedAccount = latestManagedAccounts.account(id: destination.persisted.id) else {
+                throw CodexAccountPromotionError.managedStoreCommitFailed
+            }
+
+            let email = liveAuthIdentity.email
+                ?? (liveAuthIdentity.providerAccountID != nil ? persistedManagedAccount.email : nil)
+            guard let email, liveAuthIdentity.identity != .unresolved else {
+                throw CodexAccountPromotionError.liveAccountMissingIdentityForPreservation
+            }
+
+            let now = Date().timeIntervalSince1970
+            let refreshedManagedAccount = ManagedCodexAccount(
+                id: persistedManagedAccount.id,
+                email: email,
+                providerAccountID: liveAuthIdentity.providerAccountID ?? persistedManagedAccount.providerAccountID,
+                workspaceLabel: liveAuthIdentity.workspaceLabel ?? persistedManagedAccount.workspaceLabel,
+                workspaceAccountID: liveAuthIdentity.workspaceAccountID ?? persistedManagedAccount.workspaceAccountID,
+                authFingerprint: CodexAuthFingerprint.fingerprint(data: liveAuthMaterial.rawData),
+                managedHomePath: persistedManagedAccount.managedHomePath,
+                createdAt: persistedManagedAccount.createdAt,
+                updatedAt: now,
+                lastAuthenticatedAt: now)
+
+            let refreshedHomeURL = URL(fileURLWithPath: persistedManagedAccount.managedHomePath, isDirectory: true)
+            do {
+                try self.homeFactory.validateManagedHomeForDeletion(refreshedHomeURL)
+            } catch {
+                throw CodexAccountPromotionError.displacedLiveImportFailed
+            }
+
+            try self.fileManager.createDirectory(at: refreshedHomeURL, withIntermediateDirectories: true)
+            try self.writeManagedAuthData(liveAuthMaterial.rawData, to: refreshedHomeURL)
+            try self.store.storeAccounts(ManagedCodexAccountSet(
+                version: latestManagedAccounts.version,
+                accounts: latestManagedAccounts.accounts.map { account in
+                    guard account.id == persistedManagedAccount.id else { return account }
+                    return refreshedManagedAccount
+                }))
+            return refreshedManagedAccount
+        } catch let error as CodexAccountPromotionError {
+            throw error
+        } catch {
+            throw CodexAccountPromotionError.managedStoreCommitFailed
+        }
+    }
+
+    private func writeManagedAuthData(_ data: Data, to homeURL: URL) throws {
+        let authFileURL = CodexAccountPromotionService.authFileURL(for: homeURL)
+        try data.write(to: authFileURL, options: .atomic)
+        try self.fileManager.setAttributes(
+            [.posixPermissions: NSNumber(value: Int16(0o600))],
+            ofItemAtPath: authFileURL.path)
+    }
+
+    private func removeManagedHomeIfSafe(_ homeURL: URL) throws {
+        try self.homeFactory.validateManagedHomeForDeletion(homeURL)
+        if self.fileManager.fileExists(atPath: homeURL.path) {
+            try self.fileManager.removeItem(at: homeURL)
+        }
+    }
+
+    private static func accountID(for homeURL: URL) -> UUID {
+        UUID(uuidString: homeURL.lastPathComponent) ?? UUID()
+    }
+}
diff --git a/Sources/CodexBar/CodexAccountPromotionPlanning.swift b/Sources/CodexBar/CodexAccountPromotionPlanning.swift
new file mode 100644
index 0000000000..8fd94ea83a
--- /dev/null
+++ b/Sources/CodexBar/CodexAccountPromotionPlanning.swift
@@ -0,0 +1,190 @@
+import CodexBarCore
+import Foundation
+
+enum CodexDisplacedLivePreservationNoneReason: Equatable {
+    case liveMissing
+    case targetMatchesLiveAuthIdentity
+}
+
+enum CodexDisplacedLivePreservationRejectReason: Equatable {
+    case liveUnreadable
+    case liveAPIKeyOnlyUnsupported
+    case liveIdentityMissingForPreservation
+    case conflictingReadableManagedHome
+}
+
+enum CodexDisplacedLivePreservationImportReason: Equatable {
+    case noExistingManagedDestination
+}
+
+enum CodexDisplacedLivePreservationRefreshReason: Equatable {
+    case readableHomeIdentityMatch
+    case readableHomeIdentityMatchUsingPersistedEmailFallback
+}
+
+enum CodexDisplacedLivePreservationRepairReason: Equatable {
+    case persistedProviderMatchWithMissingHome
+    case persistedProviderMatchWithUnreadableHome
+    case persistedLegacyEmailMatch
+}
+
+enum CodexDisplacedLivePreservationPlan {
+    case none(reason: CodexDisplacedLivePreservationNoneReason)
+    case reject(reason: CodexDisplacedLivePreservationRejectReason)
+    case importNew(reason: CodexDisplacedLivePreservationImportReason)
+    case refreshExisting(
+        destination: PreparedStoredManagedAccount,
+        reason: CodexDisplacedLivePreservationRefreshReason)
+    case repairExisting(
+        destination: PreparedStoredManagedAccount,
+        reason: CodexDisplacedLivePreservationRepairReason)
+}
+
+struct CodexDisplacedLivePreservationPlanner {
+    func makePlan(context: PreparedPromotionContext) -> CodexDisplacedLivePreservationPlan {
+        switch context.live.homeState {
+        case .missing:
+            return .none(reason: .liveMissing)
+        case .unreadable:
+            return .reject(reason: .liveUnreadable)
+        case .apiKeyOnly:
+            return .reject(reason: .liveAPIKeyOnlyUnsupported)
+        case .readable:
+            break
+        }
+
+        guard let liveAuthIdentity = context.live.authIdentity else {
+            return .reject(reason: .liveIdentityMissingForPreservation)
+        }
+
+        if let targetAuthIdentity = context.target.authIdentity,
+           CodexIdentityMatcher.matches(
+               targetAuthIdentity.identity,
+               lhsEmail: targetAuthIdentity.email,
+               liveAuthIdentity.identity,
+               rhsEmail: liveAuthIdentity.email)
+        {
+            return .none(reason: .targetMatchesLiveAuthIdentity)
+        }
+
+        let candidates = context.storedManagedAccounts.filter { $0.persisted.id != context.target.persisted.id }
+        if let destination = self.findReadableHomeMatch(in: candidates, liveAuthIdentity: liveAuthIdentity) {
+            let reason: CodexDisplacedLivePreservationRefreshReason =
+                if liveAuthIdentity.email == nil {
+                    .readableHomeIdentityMatchUsingPersistedEmailFallback
+                } else {
+                    .readableHomeIdentityMatch
+                }
+            return .refreshExisting(destination: destination, reason: reason)
+        }
+
+        if self.hasConflictingReadableHome(in: candidates, liveAuthIdentity: liveAuthIdentity) {
+            return .reject(reason: .conflictingReadableManagedHome)
+        }
+
+        if let repaired = self.findPersistedRepairMatch(in: candidates, liveAuthIdentity: liveAuthIdentity) {
+            return .repairExisting(destination: repaired.destination, reason: repaired.reason)
+        }
+
+        guard liveAuthIdentity.identity != .unresolved, liveAuthIdentity.email != nil else {
+            return .reject(reason: .liveIdentityMissingForPreservation)
+        }
+
+        return .importNew(reason: .noExistingManagedDestination)
+    }
+
+    private func findReadableHomeMatch(
+        in candidates: [PreparedStoredManagedAccount],
+        liveAuthIdentity: PreparedIdentity)
+        -> PreparedStoredManagedAccount?
+    {
+        candidates.first { candidate in
+            guard let candidateAuthIdentity = candidate.authIdentity else { return false }
+            return CodexIdentityMatcher.matches(
+                candidateAuthIdentity.identity,
+                lhsEmail: candidateAuthIdentity.email,
+                liveAuthIdentity.identity,
+                rhsEmail: liveAuthIdentity.email)
+        }
+    }
+
+    private func findPersistedRepairMatch(
+        in candidates: [PreparedStoredManagedAccount],
+        liveAuthIdentity: PreparedIdentity)
+        -> (destination: PreparedStoredManagedAccount, reason: CodexDisplacedLivePreservationRepairReason)?
+    {
+        switch liveAuthIdentity.identity {
+        case let .providerAccount(id):
+            let providerAccountID = ManagedCodexAccount.normalizeProviderAccountID(id)
+            if let destination = candidates.first(where: {
+                guard $0.persisted.providerAccountID == providerAccountID else { return false }
+                guard let liveEmail = liveAuthIdentity.email else { return true }
+                return $0.persisted.email == liveEmail
+            }),
+                let reason = self.providerRepairReason(for: destination)
+            {
+                return (destination, reason)
+            }
+
+            if let liveEmail = liveAuthIdentity.email,
+               let destination = candidates.first(where: {
+                   $0.persisted.providerAccountID == nil && $0.persisted.email == liveEmail
+               })
+            {
+                return (destination, .persistedLegacyEmailMatch)
+            }
+
+            return nil
+
+        case let .emailOnly(normalizedEmail):
+            guard let destination = candidates.first(where: {
+                $0.persisted.providerAccountID == nil && $0.persisted.email == normalizedEmail
+            }) else {
+                return nil
+            }
+            return (destination, .persistedLegacyEmailMatch)
+
+        case .unresolved:
+            return nil
+        }
+    }
+
+    private func hasConflictingReadableHome(
+        in candidates: [PreparedStoredManagedAccount],
+        liveAuthIdentity: PreparedIdentity)
+        -> Bool
+    {
+        guard case let .providerAccount(id) = liveAuthIdentity.identity else {
+            return false
+        }
+
+        let providerAccountID = ManagedCodexAccount.normalizeProviderAccountID(id)
+        return candidates.contains { candidate in
+            guard candidate.persisted.providerAccountID == providerAccountID else { return false }
+            if let liveEmail = liveAuthIdentity.email, candidate.persisted.email != liveEmail {
+                return false
+            }
+            guard case .readable = candidate.homeState else { return false }
+            guard let candidateAuthIdentity = candidate.authIdentity else { return false }
+            return !CodexIdentityMatcher.matches(
+                candidateAuthIdentity.identity,
+                lhsEmail: candidateAuthIdentity.email,
+                liveAuthIdentity.identity,
+                rhsEmail: liveAuthIdentity.email)
+        }
+    }
+
+    private func providerRepairReason(
+        for destination: PreparedStoredManagedAccount)
+        -> CodexDisplacedLivePreservationRepairReason?
+    {
+        switch destination.homeState {
+        case .missing:
+            .persistedProviderMatchWithMissingHome
+        case .unreadable:
+            .persistedProviderMatchWithUnreadableHome
+        case .readable:
+            nil
+        }
+    }
+}
diff --git a/Sources/CodexBar/CodexAccountPromotionPreparation.swift b/Sources/CodexBar/CodexAccountPromotionPreparation.swift
new file mode 100644
index 0000000000..bb686a5c18
--- /dev/null
+++ b/Sources/CodexBar/CodexAccountPromotionPreparation.swift
@@ -0,0 +1,346 @@
+import CodexBarCore
+import Foundation
+
+struct PreparedIdentity: Equatable {
+    let email: String?
+    let identity: CodexIdentity
+    let providerAccountID: String?
+    let workspaceLabel: String?
+    let workspaceAccountID: String?
+}
+
+struct PreparedAuthMaterial {
+    let homeURL: URL
+    let rawData: Data
+    let credentials: CodexOAuthCredentials
+    let runtimeAccount: CodexAuthBackedAccount
+    let authIdentity: PreparedIdentity
+}
+
+enum PreparedManagedHomeState {
+    case readable(PreparedAuthMaterial)
+    case missing(homeURL: URL)
+    case unreadable(homeURL: URL)
+}
+
+struct PreparedStoredManagedAccount {
+    let persisted: ManagedCodexAccount
+    let persistedIdentity: PreparedIdentity
+    let homeState: PreparedManagedHomeState
+
+    var authIdentity: PreparedIdentity? {
+        switch self.homeState {
+        case let .readable(authMaterial):
+            authMaterial.authIdentity
+        case .missing, .unreadable:
+            nil
+        }
+    }
+}
+
+enum PreparedLiveHomeState {
+    case missing(homeURL: URL)
+    case unreadable(homeURL: URL)
+    case apiKeyOnly(PreparedAuthMaterial)
+    case readable(PreparedAuthMaterial)
+}
+
+struct PreparedLiveAccount {
+    let homeState: PreparedLiveHomeState
+
+    var homeURL: URL {
+        switch self.homeState {
+        case let .missing(homeURL), let .unreadable(homeURL):
+            homeURL
+        case let .apiKeyOnly(authMaterial), let .readable(authMaterial):
+            authMaterial.homeURL
+        }
+    }
+
+    var authIdentity: PreparedIdentity? {
+        switch self.homeState {
+        case let .apiKeyOnly(authMaterial), let .readable(authMaterial):
+            authMaterial.authIdentity
+        case .missing, .unreadable:
+            nil
+        }
+    }
+}
+
+struct PreparedPromotionContext {
+    let snapshot: CodexAccountReconciliationSnapshot
+    let managedAccounts: ManagedCodexAccountSet
+    let storedManagedAccounts: [PreparedStoredManagedAccount]
+    let target: PreparedStoredManagedAccount
+    let live: PreparedLiveAccount
+}
+
+@MainActor
+struct PreparedPromotionContextBuilder {
+    private let store: any ManagedCodexAccountStoring
+    private let workspaceResolver: any ManagedCodexWorkspaceResolving
+    private let snapshotLoader: any CodexAccountReconciliationSnapshotLoading
+    private let authMaterialReader: any CodexAuthMaterialReading
+    private let baseEnvironment: [String: String]
+    private let fileManager: FileManager
+
+    init(
+        store: any ManagedCodexAccountStoring,
+        workspaceResolver: any ManagedCodexWorkspaceResolving,
+        snapshotLoader: any CodexAccountReconciliationSnapshotLoading,
+        authMaterialReader: any CodexAuthMaterialReading,
+        baseEnvironment: [String: String] = ProcessInfo.processInfo.environment,
+        fileManager: FileManager = .default)
+    {
+        self.store = store
+        self.workspaceResolver = workspaceResolver
+        self.snapshotLoader = snapshotLoader
+        self.authMaterialReader = authMaterialReader
+        self.baseEnvironment = baseEnvironment
+        self.fileManager = fileManager
+    }
+
+    func build(targetID: UUID) async throws -> PreparedPromotionContext {
+        let snapshot = self.snapshotLoader.loadSnapshot()
+        let managedAccounts = try self.store.loadAccounts()
+        var preparedAccounts: [PreparedStoredManagedAccount] = []
+        preparedAccounts.reserveCapacity(managedAccounts.accounts.count)
+        for account in managedAccounts.accounts {
+            let preparedAccount = try await self.prepareStoredManagedAccount(account)
+            preparedAccounts.append(preparedAccount)
+        }
+
+        guard let target = preparedAccounts.first(where: { $0.persisted.id == targetID }) else {
+            throw CodexAccountPromotionError.targetManagedAccountNotFound
+        }
+
+        let live = await self.prepareLiveAccount()
+        return PreparedPromotionContext(
+            snapshot: snapshot,
+            managedAccounts: managedAccounts,
+            storedManagedAccounts: preparedAccounts,
+            target: target,
+            live: live)
+    }
+
+    private func prepareStoredManagedAccount(
+        _ account: ManagedCodexAccount) async throws
+        -> PreparedStoredManagedAccount
+    {
+        let homeURL = URL(fileURLWithPath: account.managedHomePath, isDirectory: true)
+        let persistedIdentity = Self.persistedIdentity(from: account)
+        let homeState = await self.prepareManagedHomeState(homeURL: homeURL)
+
+        return PreparedStoredManagedAccount(
+            persisted: account,
+            persistedIdentity: persistedIdentity,
+            homeState: homeState)
+    }
+
+    private func prepareManagedHomeState(homeURL: URL) async -> PreparedManagedHomeState {
+        let readResult = self.readAuthData(homeURL: homeURL)
+        switch readResult {
+        case .missing:
+            return .missing(homeURL: homeURL)
+        case .unreadable:
+            return .unreadable(homeURL: homeURL)
+        case let .readable(rawData):
+            guard let authMaterial = await self.inspectAuthMaterial(homeURL: homeURL, rawData: rawData) else {
+                return .unreadable(homeURL: homeURL)
+            }
+            return .readable(authMaterial)
+        }
+    }
+
+    private func prepareLiveAccount() async -> PreparedLiveAccount {
+        let liveHomeURL = self.liveHomeURL()
+        let readResult = self.readAuthData(homeURL: liveHomeURL)
+        switch readResult {
+        case .missing:
+            return PreparedLiveAccount(homeState: .missing(homeURL: liveHomeURL))
+        case .unreadable:
+            return PreparedLiveAccount(homeState: .unreadable(homeURL: liveHomeURL))
+        case let .readable(rawData):
+            guard let authMaterial = await self.inspectAuthMaterial(homeURL: liveHomeURL, rawData: rawData) else {
+                return PreparedLiveAccount(homeState: .unreadable(homeURL: liveHomeURL))
+            }
+            if Self.isAPIKeyOnly(credentials: authMaterial.credentials, rawData: authMaterial.rawData) {
+                return PreparedLiveAccount(homeState: .apiKeyOnly(authMaterial))
+            }
+            return PreparedLiveAccount(homeState: .readable(authMaterial))
+        }
+    }
+
+    private func inspectAuthMaterial(homeURL: URL, rawData: Data) async -> PreparedAuthMaterial? {
+        guard let credentials = try? CodexOAuthCredentialsStore.parse(data: rawData),
+              let runtimeAccount = try? Self.runtimeAccount(from: rawData)
+        else {
+            return nil
+        }
+
+        let authIdentity = await self.derivedIdentity(
+            homePath: homeURL.path,
+            runtimeAccount: runtimeAccount)
+
+        return PreparedAuthMaterial(
+            homeURL: homeURL,
+            rawData: rawData,
+            credentials: credentials,
+            runtimeAccount: runtimeAccount,
+            authIdentity: authIdentity)
+    }
+
+    private func derivedIdentity(homePath: String, runtimeAccount: CodexAuthBackedAccount) async -> PreparedIdentity {
+        let normalizedEmail = Self.normalizeEmail(runtimeAccount.email)
+        let normalizedIdentity = Self.normalizedIdentity(runtimeAccount.identity, email: normalizedEmail)
+        let providerAccountID: String? = switch normalizedIdentity {
+        case let .providerAccount(id):
+            ManagedCodexAccount.normalizeProviderAccountID(id)
+        case .emailOnly, .unresolved:
+            nil
+        }
+        let workspaceIdentity: CodexOpenAIWorkspaceIdentity? = if let providerAccountID {
+            await self.workspaceResolver.resolveWorkspaceIdentity(
+                homePath: homePath,
+                providerAccountID: providerAccountID)
+        } else {
+            nil
+        }
+
+        return PreparedIdentity(
+            email: normalizedEmail,
+            identity: normalizedIdentity,
+            providerAccountID: providerAccountID,
+            workspaceLabel: workspaceIdentity?.workspaceLabel,
+            workspaceAccountID: workspaceIdentity?.workspaceAccountID ?? providerAccountID)
+    }
+
+    private static func persistedIdentity(from account: ManagedCodexAccount) -> PreparedIdentity {
+        let normalizedEmail = Self.normalizeEmail(account.email)
+        let providerAccountID = ManagedCodexAccount.normalizeProviderAccountID(account.providerAccountID)
+        let identity = Self.normalizedIdentity(
+            CodexIdentityResolver.resolve(accountId: providerAccountID, email: normalizedEmail),
+            email: normalizedEmail)
+
+        return PreparedIdentity(
+            email: normalizedEmail,
+            identity: identity,
+            providerAccountID: providerAccountID,
+            workspaceLabel: account.workspaceLabel,
+            workspaceAccountID: account.workspaceAccountID)
+    }
+
+    private func liveHomeURL() -> URL {
+        CodexHomeScope.ambientHomeURL(env: self.baseEnvironment, fileManager: self.fileManager)
+    }
+
+    private func readAuthData(homeURL: URL) -> PreparedAuthReadState {
+        do {
+            let rawData = try self.authMaterialReader.readAuthData(homeURL: homeURL)
+            guard let rawData else {
+                return .missing
+            }
+            return .readable(rawData)
+        } catch {
+            return .unreadable
+        }
+    }
+
+    private static func runtimeAccount(from rawData: Data) throws -> CodexAuthBackedAccount {
+        guard let json = try JSONSerialization.jsonObject(with: rawData) as? [String: Any] else {
+            throw CodexOAuthCredentialsError.decodeFailed("Invalid JSON")
+        }
+
+        let tokens = json["tokens"] as? [String: Any]
+        let idToken = tokens.flatMap {
+            Self.nonEmptyString(in: $0, snakeCaseKey: "id_token", camelCaseKey: "idToken")
+        }
+        let payload = idToken.flatMap(UsageFetcher.parseJWT)
+        let authDict = payload?["https://api.openai.com/auth"] as? [String: Any]
+        let profileDict = payload?["https://api.openai.com/profile"] as? [String: Any]
+
+        let email = Self.normalizeEmail(
+            (payload?["email"] as? String) ?? (profileDict?["email"] as? String))
+        let plan = Self.normalizedField(
+            (authDict?["chatgpt_plan_type"] as? String) ?? (payload?["chatgpt_plan_type"] as? String))
+        let accountID = ManagedCodexAccount.normalizeProviderAccountID(
+            tokens.flatMap {
+                Self.nonEmptyString(in: $0, snakeCaseKey: "account_id", camelCaseKey: "accountId")
+            }
+                ?? (authDict?["chatgpt_account_id"] as? String)
+                ?? (payload?["chatgpt_account_id"] as? String))
+        let identity = Self.normalizedIdentity(
+            CodexIdentityResolver.resolve(accountId: accountID, email: email),
+            email: email)
+
+        return CodexAuthBackedAccount(identity: identity, email: email, plan: plan)
+    }
+
+    private static func normalizedField(_ value: String?) -> String? {
+        guard let value = value?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
+            return nil
+        }
+        return value
+    }
+
+    private static func normalizeEmail(_ email: String?) -> String? {
+        CodexIdentityResolver.normalizeEmail(email)
+    }
+
+    private static func normalizedIdentity(_ identity: CodexIdentity, email: String?) -> CodexIdentity {
+        guard let email else { return identity }
+        return CodexIdentityMatcher.normalized(identity, fallbackEmail: email)
+    }
+
+    private static func isAPIKeyOnly(credentials: CodexOAuthCredentials, rawData: Data) -> Bool {
+        guard self.hasUsableOAuthTokens(in: rawData) == false else {
+            return false
+        }
+        return credentials.refreshToken.isEmpty
+            && credentials.idToken == nil
+            && credentials.accountId == nil
+            && credentials.lastRefresh == nil
+    }
+
+    private static func hasUsableOAuthTokens(in rawData: Data) -> Bool {
+        guard let json = try? JSONSerialization.jsonObject(with: rawData) as? [String: Any],
+              let tokens = json["tokens"] as? [String: Any]
+        else {
+            return false
+        }
+        let accessToken = self.nonEmptyString(
+            in: tokens,
+            snakeCaseKey: "access_token",
+            camelCaseKey: "accessToken")
+        let refreshToken = self.nonEmptyString(
+            in: tokens,
+            snakeCaseKey: "refresh_token",
+            camelCaseKey: "refreshToken")
+        return accessToken != nil && refreshToken != nil
+    }
+
+    private static func nonEmptyString(
+        in dictionary: [String: Any],
+        snakeCaseKey: String,
+        camelCaseKey: String)
+        -> String?
+    {
+        if let value = dictionary[snakeCaseKey] as? String,
+           value.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty == false
+        {
+            return value
+        }
+        if let value = dictionary[camelCaseKey] as? String,
+           value.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty == false
+        {
+            return value
+        }
+        return nil
+    }
+}
+
+private enum PreparedAuthReadState {
+    case missing
+    case unreadable
+    case readable(Data)
+}
diff --git a/Sources/CodexBar/CodexAccountPromotionService.swift b/Sources/CodexBar/CodexAccountPromotionService.swift
new file mode 100644
index 0000000000..c8bf589699
--- /dev/null
+++ b/Sources/CodexBar/CodexAccountPromotionService.swift
@@ -0,0 +1,311 @@
+import CodexBarCore
+import Darwin
+import Foundation
+
+@MainActor
+protocol CodexAccountReconciliationSnapshotLoading {
+    func loadSnapshot() -> CodexAccountReconciliationSnapshot
+}
+
+protocol CodexAuthMaterialReading: Sendable {
+    func readAuthData(homeURL: URL) throws -> Data?
+}
+
+protocol CodexLiveAuthSwapping: Sendable {
+    func swapLiveAuthData(_ data: Data, liveHomeURL: URL) throws
+}
+
+@MainActor
+protocol CodexActiveSourceWriting {
+    func writeCodexActiveSource(_ source: CodexActiveSource)
+}
+
+@MainActor
+protocol CodexAccountScopedRefreshing {
+    func refreshCodexAccountScopedState(allowDisabled: Bool) async
+}
+
+@MainActor
+struct SettingsStoreCodexAccountReconciliationSnapshotLoader: CodexAccountReconciliationSnapshotLoading {
+    private let settingsStore: SettingsStore
+
+    init(settingsStore: SettingsStore) {
+        self.settingsStore = settingsStore
+    }
+
+    func loadSnapshot() -> CodexAccountReconciliationSnapshot {
+        self.settingsStore.codexAccountReconciliationSnapshot
+    }
+}
+
+struct DefaultCodexAuthMaterialReader: CodexAuthMaterialReading {
+    func readAuthData(homeURL: URL) throws -> Data? {
+        let authFileURL = CodexAccountPromotionService.authFileURL(for: homeURL)
+        guard FileManager.default.fileExists(atPath: authFileURL.path) else {
+            return nil
+        }
+        return try Data(contentsOf: authFileURL)
+    }
+}
+
+struct DefaultCodexLiveAuthSwapper: CodexLiveAuthSwapping {
+    func swapLiveAuthData(_ data: Data, liveHomeURL: URL) throws {
+        try FileManager.default.createDirectory(at: liveHomeURL, withIntermediateDirectories: true)
+
+        let liveAuthURL = CodexAccountPromotionService.authFileURL(for: liveHomeURL)
+        let stagedAuthURL = liveHomeURL.appendingPathComponent(
+            "auth.json.codexbar-staged-\(UUID().uuidString)",
+            isDirectory: false)
+
+        do {
+            try data.write(to: stagedAuthURL)
+            try FileManager.default.setAttributes(
+                [.posixPermissions: NSNumber(value: Int16(0o600))],
+                ofItemAtPath: stagedAuthURL.path)
+            try self.renameItem(at: stagedAuthURL, to: liveAuthURL)
+        } catch {
+            try? FileManager.default.removeItem(at: stagedAuthURL)
+            throw error
+        }
+    }
+
+    private func renameItem(at sourceURL: URL, to destinationURL: URL) throws {
+        let sourcePath = sourceURL.path
+        let destinationPath = destinationURL.path
+
+        let result = sourcePath.withCString { sourceFS in
+            destinationPath.withCString { destinationFS in
+                rename(sourceFS, destinationFS)
+            }
+        }
+
+        guard result == 0 else {
+            throw NSError(
+                domain: NSPOSIXErrorDomain,
+                code: Int(errno),
+                userInfo: [NSFilePathErrorKey: destinationPath])
+        }
+    }
+}
+
+@MainActor
+struct SettingsStoreCodexActiveSourceWriter: CodexActiveSourceWriting {
+    private let settingsStore: SettingsStore
+
+    init(settingsStore: SettingsStore) {
+        self.settingsStore = settingsStore
+    }
+
+    func writeCodexActiveSource(_ source: CodexActiveSource) {
+        self.settingsStore.codexActiveSource = source
+    }
+}
+
+@MainActor
+struct UsageStoreCodexAccountScopedRefresher: CodexAccountScopedRefreshing {
+    private let usageStore: UsageStore
+
+    init(usageStore: UsageStore) {
+        self.usageStore = usageStore
+    }
+
+    func refreshCodexAccountScopedState(allowDisabled: Bool) async {
+        await self.usageStore.refreshCodexAccountScopedState(allowDisabled: allowDisabled)
+    }
+}
+
+struct CodexAccountPromotionResult: Equatable {
+    enum Outcome: Equatable {
+        case promoted
+        case convergedNoOp
+    }
+
+    enum DisplacedLiveDisposition: Equatable {
+        case none
+        case alreadyManaged(managedAccountID: UUID)
+        case imported(managedAccountID: UUID)
+    }
+
+    let targetManagedAccountID: UUID
+    let outcome: Outcome
+    let displacedLiveDisposition: DisplacedLiveDisposition
+    let didMutateLiveAuth: Bool
+    let resultingActiveSource: CodexActiveSource
+}
+
+enum CodexAccountPromotionError: Error, Equatable {
+    case targetManagedAccountNotFound
+    case targetManagedAccountAuthMissing
+    case targetManagedAccountAuthUnreadable
+    case liveAccountUnreadable
+    case liveAccountMissingIdentityForPreservation
+    case liveAccountAPIKeyOnlyUnsupported
+    case displacedLiveManagedAccountConflict
+    case displacedLiveImportFailed
+    case managedStoreCommitFailed
+    case liveAuthSwapFailed
+}
+
+@MainActor
+final class CodexAccountPromotionService {
+    private let store: any ManagedCodexAccountStoring
+    private let homeFactory: any ManagedCodexHomeProducing
+    private let identityReader: any ManagedCodexIdentityReading
+    private let workspaceResolver: any ManagedCodexWorkspaceResolving
+    private let snapshotLoader: any CodexAccountReconciliationSnapshotLoading
+    private let authMaterialReader: any CodexAuthMaterialReading
+    private let liveAuthSwapper: any CodexLiveAuthSwapping
+    private let activeSourceWriter: any CodexActiveSourceWriting
+    private let accountScopedRefresher: any CodexAccountScopedRefreshing
+    private let baseEnvironment: [String: String]
+    private let fileManager: FileManager
+
+    init(
+        store: any ManagedCodexAccountStoring,
+        homeFactory: any ManagedCodexHomeProducing,
+        identityReader: any ManagedCodexIdentityReading,
+        workspaceResolver: any ManagedCodexWorkspaceResolving = DefaultManagedCodexWorkspaceResolver(),
+        snapshotLoader: any CodexAccountReconciliationSnapshotLoading,
+        authMaterialReader: any CodexAuthMaterialReading,
+        liveAuthSwapper: any CodexLiveAuthSwapping,
+        activeSourceWriter: any CodexActiveSourceWriting,
+        accountScopedRefresher: any CodexAccountScopedRefreshing,
+        baseEnvironment: [String: String] = ProcessInfo.processInfo.environment,
+        fileManager: FileManager = .default)
+    {
+        self.store = store
+        self.homeFactory = homeFactory
+        self.identityReader = identityReader
+        self.workspaceResolver = workspaceResolver
+        self.snapshotLoader = snapshotLoader
+        self.authMaterialReader = authMaterialReader
+        self.liveAuthSwapper = liveAuthSwapper
+        self.activeSourceWriter = activeSourceWriter
+        self.accountScopedRefresher = accountScopedRefresher
+        self.baseEnvironment = baseEnvironment
+        self.fileManager = fileManager
+    }
+
+    convenience init(
+        settingsStore: SettingsStore,
+        usageStore: UsageStore,
+        baseEnvironment: [String: String] = ProcessInfo.processInfo.environment,
+        fileManager: FileManager = .default)
+    {
+        self.init(
+            store: FileManagedCodexAccountStore(fileManager: fileManager),
+            homeFactory: ManagedCodexHomeFactory(fileManager: fileManager),
+            identityReader: DefaultManagedCodexIdentityReader(),
+            workspaceResolver: DefaultManagedCodexWorkspaceResolver(),
+            snapshotLoader: SettingsStoreCodexAccountReconciliationSnapshotLoader(settingsStore: settingsStore),
+            authMaterialReader: DefaultCodexAuthMaterialReader(),
+            liveAuthSwapper: DefaultCodexLiveAuthSwapper(),
+            activeSourceWriter: SettingsStoreCodexActiveSourceWriter(settingsStore: settingsStore),
+            accountScopedRefresher: UsageStoreCodexAccountScopedRefresher(usageStore: usageStore),
+            baseEnvironment: baseEnvironment,
+            fileManager: fileManager)
+    }
+
+    func promoteManagedAccount(id: UUID) async throws -> CodexAccountPromotionResult {
+        let contextBuilder = PreparedPromotionContextBuilder(
+            store: self.store,
+            workspaceResolver: self.workspaceResolver,
+            snapshotLoader: self.snapshotLoader,
+            authMaterialReader: self.authMaterialReader,
+            baseEnvironment: self.baseEnvironment,
+            fileManager: self.fileManager)
+        let context = try await contextBuilder.build(targetID: id)
+
+        if let resultingActiveSource = self.convergedActiveSource(for: context) {
+            self.activeSourceWriter.writeCodexActiveSource(resultingActiveSource)
+            await self.accountScopedRefresher.refreshCodexAccountScopedState(allowDisabled: true)
+            return CodexAccountPromotionResult(
+                targetManagedAccountID: id,
+                outcome: .convergedNoOp,
+                displacedLiveDisposition: .none,
+                didMutateLiveAuth: false,
+                resultingActiveSource: resultingActiveSource)
+        }
+
+        let targetAuthMaterial = try self.requiredTargetAuthMaterial(from: context.target)
+        let preservationPlan = CodexDisplacedLivePreservationPlanner().makePlan(context: context)
+        let executionResult = try CodexDisplacedLivePreservationExecutor(
+            store: self.store,
+            homeFactory: self.homeFactory,
+            fileManager: self.fileManager)
+            .execute(plan: preservationPlan, context: context)
+
+        do {
+            try self.liveAuthSwapper.swapLiveAuthData(targetAuthMaterial.rawData, liveHomeURL: context.live.homeURL)
+        } catch {
+            throw CodexAccountPromotionError.liveAuthSwapFailed
+        }
+
+        self.activeSourceWriter.writeCodexActiveSource(.liveSystem)
+        await self.accountScopedRefresher.refreshCodexAccountScopedState(allowDisabled: true)
+
+        return CodexAccountPromotionResult(
+            targetManagedAccountID: id,
+            outcome: .promoted,
+            displacedLiveDisposition: executionResult.displacedLiveDisposition,
+            didMutateLiveAuth: true,
+            resultingActiveSource: .liveSystem)
+    }
+
+    nonisolated static func authFileURL(for homeURL: URL) -> URL {
+        homeURL.appendingPathComponent("auth.json", isDirectory: false)
+    }
+
+    private func convergedActiveSource(for context: PreparedPromotionContext) -> CodexActiveSource? {
+        if let liveAuthIdentity = context.live.authIdentity {
+            let targetIdentity = context.target.authIdentity ?? context.target.persistedIdentity
+            guard CodexIdentityMatcher.matches(
+                targetIdentity.identity,
+                lhsEmail: targetIdentity.email,
+                liveAuthIdentity.identity,
+                rhsEmail: liveAuthIdentity.email)
+            else {
+                return nil
+            }
+
+            if liveAuthIdentity.email != nil {
+                return .liveSystem
+            }
+
+            if liveAuthIdentity.providerAccountID != nil {
+                return .managedAccount(id: context.target.persisted.id)
+            }
+
+            return nil
+        }
+
+        guard let liveSystemAccount = context.snapshot.liveSystemAccount else {
+            return nil
+        }
+
+        guard CodexIdentityMatcher.matches(
+            context.snapshot.runtimeIdentity(for: context.target.persisted),
+            lhsEmail: context.snapshot.runtimeEmail(for: context.target.persisted),
+            context.snapshot.runtimeIdentity(for: liveSystemAccount),
+            rhsEmail: liveSystemAccount.email)
+        else {
+            return nil
+        }
+
+        return .liveSystem
+    }
+
+    private func requiredTargetAuthMaterial(from target: PreparedStoredManagedAccount) throws -> PreparedAuthMaterial {
+        switch target.homeState {
+        case let .readable(authMaterial):
+            guard authMaterial.authIdentity.email != nil else {
+                throw CodexAccountPromotionError.targetManagedAccountAuthUnreadable
+            }
+            return authMaterial
+        case .missing:
+            throw CodexAccountPromotionError.targetManagedAccountAuthMissing
+        case .unreadable:
+            throw CodexAccountPromotionError.targetManagedAccountAuthUnreadable
+        }
+    }
+}
diff --git a/Sources/CodexBar/CodexAccountReconciliation.swift b/Sources/CodexBar/CodexAccountReconciliation.swift
new file mode 100644
index 0000000000..aacd921e37
--- /dev/null
+++ b/Sources/CodexBar/CodexAccountReconciliation.swift
@@ -0,0 +1,4 @@
+import CodexBarCore
+
+typealias CodexVisibleAccount = CodexBarCore.CodexVisibleAccount
+typealias CodexVisibleAccountProjection = CodexBarCore.CodexVisibleAccountProjection
diff --git a/Sources/CodexBar/CodexAccountUsageSnapshotStore.swift b/Sources/CodexBar/CodexAccountUsageSnapshotStore.swift
new file mode 100644
index 0000000000..891b409610
--- /dev/null
+++ b/Sources/CodexBar/CodexAccountUsageSnapshotStore.swift
@@ -0,0 +1,146 @@
+import CodexBarCore
+import Foundation
+
+protocol CodexAccountUsageSnapshotStoring: Sendable {
+    func load(for accounts: [CodexVisibleAccount]) -> [CodexAccountUsageSnapshot]
+    func store(_ snapshots: [CodexAccountUsageSnapshot])
+}
+
+struct FileCodexAccountUsageSnapshotStore: CodexAccountUsageSnapshotStoring, @unchecked Sendable {
+    private struct Payload: Codable {
+        let version: Int
+        let records: [Record]
+    }
+
+    private struct Record: Codable {
+        let id: String
+        let accountIdentity: AccountIdentity?
+        let snapshot: UsageSnapshot?
+        let error: String?
+        let sourceLabel: String?
+    }
+
+    private struct AccountIdentity: Codable, Equatable {
+        let normalizedEmail: String?
+        let workspaceAccountID: String?
+        let authFingerprint: String?
+        let storedAccountID: UUID?
+        let selectionSource: CodexActiveSource?
+
+        init(account: CodexVisibleAccount) {
+            self.normalizedEmail = CodexIdentityResolver.normalizeEmail(account.email)
+            self.workspaceAccountID = CodexOpenAIWorkspaceResolver.normalizeWorkspaceAccountID(
+                account.workspaceAccountID)
+            self.authFingerprint = CodexAuthFingerprint.normalize(account.authFingerprint)
+            self.storedAccountID = account.storedAccountID
+            self.selectionSource = account.selectionSource
+        }
+
+        func matches(_ account: CodexVisibleAccount) -> Bool {
+            guard self.normalizedEmail == CodexIdentityResolver.normalizeEmail(account.email) else {
+                return false
+            }
+
+            let currentWorkspaceAccountID = CodexOpenAIWorkspaceResolver.normalizeWorkspaceAccountID(
+                account.workspaceAccountID)
+            if self.workspaceAccountID != nil || currentWorkspaceAccountID != nil {
+                return self.workspaceAccountID == currentWorkspaceAccountID
+            }
+
+            let currentAuthFingerprint = CodexAuthFingerprint.normalize(account.authFingerprint)
+            if self.authFingerprint != nil || currentAuthFingerprint != nil {
+                return self.authFingerprint == currentAuthFingerprint
+            }
+
+            if self.storedAccountID != nil || account.storedAccountID != nil {
+                return self.storedAccountID == account.storedAccountID
+            }
+
+            guard let selectionSource else { return true }
+            return selectionSource == account.selectionSource
+        }
+    }
+
+    private static let currentVersion = 1
+
+    private let fileURL: URL
+    private let fileManager: FileManager
+
+    init(fileURL: URL = Self.defaultURL(), fileManager: FileManager = .default) {
+        self.fileURL = fileURL
+        self.fileManager = fileManager
+    }
+
+    func load(for accounts: [CodexVisibleAccount]) -> [CodexAccountUsageSnapshot] {
+        guard self.fileManager.fileExists(atPath: self.fileURL.path),
+              let data = try? Data(contentsOf: self.fileURL),
+              let payload = try? JSONDecoder().decode(Payload.self, from: data),
+              payload.version == Self.currentVersion
+        else {
+            return []
+        }
+
+        let accountsByID = Dictionary(uniqueKeysWithValues: accounts.map { ($0.id, $0) })
+        return payload.records.compactMap { record in
+            guard let account = accountsByID[record.id] else { return nil }
+            guard record.accountIdentity?.matches(account)
+                ?? Self.canHydrateLegacyRecord(record, account: account)
+            else {
+                return nil
+            }
+            return CodexAccountUsageSnapshot(
+                account: account,
+                snapshot: record.snapshot,
+                error: record.error,
+                sourceLabel: record.sourceLabel)
+        }
+    }
+
+    func store(_ snapshots: [CodexAccountUsageSnapshot]) {
+        let payload = Payload(
+            version: Self.currentVersion,
+            records: snapshots.map { snapshot in
+                Record(
+                    id: snapshot.id,
+                    accountIdentity: AccountIdentity(account: snapshot.account),
+                    snapshot: snapshot.snapshot,
+                    error: snapshot.error,
+                    sourceLabel: snapshot.sourceLabel)
+            })
+        let directory = self.fileURL.deletingLastPathComponent()
+        do {
+            if !self.fileManager.fileExists(atPath: directory.path) {
+                try self.fileManager.createDirectory(at: directory, withIntermediateDirectories: true)
+            }
+            let encoder = JSONEncoder()
+            encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
+            try encoder.encode(payload).write(to: self.fileURL, options: [.atomic])
+            #if os(macOS)
+            try self.fileManager.setAttributes([
+                .posixPermissions: NSNumber(value: Int16(0o600)),
+            ], ofItemAtPath: self.fileURL.path)
+            #endif
+        } catch {
+            // Snapshot hydration is best-effort; never make menu refresh fail because disk cache failed.
+        }
+    }
+
+    private static func canHydrateLegacyRecord(_ record: Record, account: CodexVisibleAccount) -> Bool {
+        guard record.accountIdentity == nil else { return false }
+        let normalizedID = CodexIdentityResolver.normalizeEmail(record.id)
+        let normalizedEmail = CodexIdentityResolver.normalizeEmail(account.email)
+        let isEmailOnlyVisibleID = normalizedID == normalizedEmail
+        guard isEmailOnlyVisibleID else { return true }
+        return CodexOpenAIWorkspaceResolver.normalizeWorkspaceAccountID(account.workspaceAccountID) == nil &&
+            account.storedAccountID == nil &&
+            CodexAuthFingerprint.normalize(account.authFingerprint) == nil
+    }
+
+    static func defaultURL() -> URL {
+        let base = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask).first
+            ?? FileManager.default.homeDirectoryForCurrentUser
+        return base
+            .appendingPathComponent("CodexBar", isDirectory: true)
+            .appendingPathComponent("codex-account-snapshots.json", isDirectory: false)
+    }
+}
diff --git a/Sources/CodexBar/CodexHistoryOwnership.swift b/Sources/CodexBar/CodexHistoryOwnership.swift
new file mode 100644
index 0000000000..e9f613fd06
--- /dev/null
+++ b/Sources/CodexBar/CodexHistoryOwnership.swift
@@ -0,0 +1,139 @@
+import CodexBarCore
+import CryptoKit
+import Foundation
+
+enum CodexHistoryPersistedOwner: Equatable {
+    case canonical(String)
+    case legacyEmailHash(String)
+    case legacyOpaqueScoped(String)
+    case legacyUnscoped
+}
+
+enum CodexHistoryOwnership {
+    private static let providerAccountPrefix = "codex:v1:provider-account:"
+    private static let emailHashPrefix = "codex:v1:email-hash:"
+
+    static func canonicalKey(for identity: CodexIdentity) -> String? {
+        switch identity {
+        case let .providerAccount(id):
+            guard let normalized = Self.normalizeScopedValue(id) else { return nil }
+            return "\(Self.providerAccountPrefix)\(normalized)"
+        case let .emailOnly(normalizedEmail):
+            guard let normalized = CodexIdentityResolver.normalizeEmail(normalizedEmail) else { return nil }
+            return self.canonicalEmailHashKey(for: normalized)
+        case .unresolved:
+            return nil
+        }
+    }
+
+    static func canonicalEmailHashKey(for normalizedEmail: String) -> String {
+        "\(self.emailHashPrefix)\(self.legacyEmailHash(normalizedEmail: normalizedEmail))"
+    }
+
+    static func legacyEmailHash(normalizedEmail: String) -> String {
+        guard let normalized = CodexIdentityResolver.normalizeEmail(normalizedEmail) else { return "" }
+        return self.sha256Hex(normalized)
+    }
+
+    static func classifyPersistedKey(
+        _ rawKey: String?,
+        legacyEmailHash: String? = nil) -> CodexHistoryPersistedOwner
+    {
+        guard let normalizedKey = normalizeScopedValue(rawKey) else {
+            return .legacyUnscoped
+        }
+        if self.isCanonicalKey(normalizedKey) {
+            return .canonical(normalizedKey)
+        }
+        if let legacyEmailHash, normalizedKey == legacyEmailHash {
+            return .legacyEmailHash(normalizedKey)
+        }
+        return .legacyOpaqueScoped(normalizedKey)
+    }
+
+    static func belongsToTargetContinuity(
+        _ owner: CodexHistoryPersistedOwner,
+        targetCanonicalKey: String,
+        canonicalEmailHashKey: String?) -> Bool
+    {
+        switch owner {
+        case let .canonical(key):
+            if key == targetCanonicalKey {
+                return true
+            }
+            guard let canonicalEmailHashKey, self.isCanonicalEmailHashKey(canonicalEmailHashKey) else {
+                return false
+            }
+            return key == canonicalEmailHashKey
+        case .legacyEmailHash:
+            guard let canonicalEmailHashKey, self.isCanonicalEmailHashKey(canonicalEmailHashKey) else {
+                return false
+            }
+            return canonicalEmailHashKey == targetCanonicalKey ||
+                targetCanonicalKey.hasPrefix(self.providerAccountPrefix)
+        case .legacyOpaqueScoped, .legacyUnscoped:
+            return false
+        }
+    }
+
+    static func hasStrictSingleAccountContinuity(
+        scopedRawKeys: [String],
+        targetCanonicalKey: String,
+        canonicalEmailHashKey: String?,
+        legacyEmailHash: String?,
+        hasAdjacentMultiAccountVeto: Bool) -> Bool
+    {
+        guard !hasAdjacentMultiAccountVeto else { return false }
+
+        let normalizedCandidates = Set(scopedRawKeys.compactMap { rawKey in
+            let owner = self.classifyPersistedKey(rawKey, legacyEmailHash: legacyEmailHash)
+            if self.belongsToTargetContinuity(
+                owner,
+                targetCanonicalKey: targetCanonicalKey,
+                canonicalEmailHashKey: canonicalEmailHashKey)
+            {
+                return targetCanonicalKey
+            }
+
+            switch owner {
+            case .legacyUnscoped:
+                return nil
+            case let .legacyOpaqueScoped(key):
+                return "legacy-opaque:\(key)"
+            case let .legacyEmailHash(hash):
+                return "legacy-email-hash:\(hash)"
+            case let .canonical(key):
+                return key
+            }
+        })
+
+        guard normalizedCandidates.count == 1, normalizedCandidates.first == targetCanonicalKey else {
+            return false
+        }
+        return true
+    }
+
+    private static func isCanonicalKey(_ rawKey: String) -> Bool {
+        self.isCanonicalProviderAccountKey(rawKey) || self.isCanonicalEmailHashKey(rawKey)
+    }
+
+    static func isCanonicalProviderAccountKey(_ rawKey: String) -> Bool {
+        rawKey.hasPrefix(self.providerAccountPrefix) && rawKey.count > self.providerAccountPrefix.count
+    }
+
+    private static func isCanonicalEmailHashKey(_ rawKey: String) -> Bool {
+        rawKey.hasPrefix(self.emailHashPrefix) && rawKey.count > self.emailHashPrefix.count
+    }
+
+    private static func normalizeScopedValue(_ value: String?) -> String? {
+        guard let trimmed = value?.trimmingCharacters(in: .whitespacesAndNewlines), !trimmed.isEmpty else {
+            return nil
+        }
+        return trimmed
+    }
+
+    private static func sha256Hex(_ input: String) -> String {
+        let digest = SHA256.hash(data: Data(input.utf8))
+        return digest.map { String(format: "%02x", $0) }.joined()
+    }
+}
diff --git a/Sources/CodexBar/CodexLoginAlertPresentation.swift b/Sources/CodexBar/CodexLoginAlertPresentation.swift
new file mode 100644
index 0000000000..30702f1539
--- /dev/null
+++ b/Sources/CodexBar/CodexLoginAlertPresentation.swift
@@ -0,0 +1,44 @@
+import Foundation
+
+struct CodexLoginAlertInfo: Equatable {
+    let title: String
+    let message: String
+}
+
+enum CodexLoginAlertPresentation {
+    static func alertInfo(for result: CodexLoginRunner.Result) -> CodexLoginAlertInfo? {
+        switch result.outcome {
+        case .success:
+            return nil
+        case .missingBinary:
+            return CodexLoginAlertInfo(
+                title: L("Codex CLI not found"),
+                message: L("Install the Codex CLI (npm i -g @openai/codex) and try again."))
+        case let .launchFailed(message):
+            return CodexLoginAlertInfo(title: L("Could not start codex login"), message: message)
+        case .timedOut:
+            return CodexLoginAlertInfo(
+                title: L("Codex login timed out"),
+                message: self.trimmedOutput(result.output))
+        case let .failed(status):
+            let statusLine = String(format: L("codex login exited with status %d."), status)
+            let message = self.trimmedOutput(result.output.isEmpty ? statusLine : result.output)
+            return CodexLoginAlertInfo(title: L("Codex login failed"), message: message)
+        }
+    }
+
+    static func managedLoginFailureMessage(for result: CodexLoginRunner.Result) -> String {
+        let baseMessage = L("managed_login_failed")
+        guard let info = self.alertInfo(for: result) else { return baseMessage }
+        return "\(baseMessage)\n\n\(L("codex_login_output"))\n\(info.message)"
+    }
+
+    private static func trimmedOutput(_ text: String) -> String {
+        let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
+        let limit = 600
+        if trimmed.isEmpty { return L("No output captured.") }
+        if trimmed.count <= limit { return trimmed }
+        let idx = trimmed.index(trimmed.startIndex, offsetBy: limit)
+        return "\(trimmed[..<idx])…"
+    }
+}
diff --git a/Sources/CodexBar/CodexLoginRunner.swift b/Sources/CodexBar/CodexLoginRunner.swift
index 8f1f654f2d..09b941eacb 100644
--- a/Sources/CodexBar/CodexLoginRunner.swift
+++ b/Sources/CodexBar/CodexLoginRunner.swift
@@ -3,8 +3,8 @@ import Darwin
 import Foundation
 
 struct CodexLoginRunner {
-    struct Result {
-        enum Outcome {
+    struct Result: Equatable {
+        enum Outcome: Equatable {
             case success
             case timedOut
             case failed(status: Int32)
@@ -16,17 +16,24 @@ struct CodexLoginRunner {
         let output: String
     }
 
-    static func run(timeout: TimeInterval = 120) async -> Result {
+    static func run(
+        homePath: String? = nil,
+        timeout: TimeInterval = 120,
+        outputDrainTimeout: TimeInterval = 3,
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        loginPATH: [String]? = LoginShellPathCache.shared.current) async -> Result
+    {
         await Task(priority: .userInitiated) {
-            var env = ProcessInfo.processInfo.environment
+            var env = environment
             env["PATH"] = PathBuilder.effectivePATH(
                 purposes: [.rpc, .tty, .nodeTooling],
                 env: env,
-                loginPATH: LoginShellPathCache.shared.current)
+                loginPATH: loginPATH)
+            env = CodexHomeScope.scopedEnvironment(base: env, codexHome: homePath)
 
             guard let executable = BinaryLocator.resolveCodexBinary(
                 env: env,
-                loginPATH: LoginShellPathCache.shared.current)
+                loginPATH: loginPATH)
             else {
                 return Result(outcome: .missingBinary, output: "")
             }
@@ -40,6 +47,13 @@ struct CodexLoginRunner {
             let stderr = Pipe()
             process.standardOutput = stdout
             process.standardError = stderr
+            let stdoutCapture = ProcessPipeCapture(pipe: stdout)
+            let stderrCapture = ProcessPipeCapture(pipe: stderr)
+
+            let termination = ProcessTermination()
+            process.terminationHandler = { _ in
+                termination.resolve(timedOut: false)
+            }
 
             var processGroup: pid_t?
             do {
@@ -48,13 +62,18 @@ struct CodexLoginRunner {
             } catch {
                 return Result(outcome: .launchFailed(error.localizedDescription), output: "")
             }
+            stdoutCapture.start()
+            stderrCapture.start()
 
-            let timedOut = await self.wait(for: process, timeout: timeout)
+            let timedOut = await self.wait(timeout: timeout, termination: termination)
             if timedOut {
                 self.terminate(process, processGroup: processGroup)
             }
 
-            let output = await self.combinedOutput(stdout: stdout, stderr: stderr)
+            let output = await self.combinedOutput(
+                stdout: stdoutCapture,
+                stderr: stderrCapture,
+                timeout: outputDrainTimeout)
             if timedOut {
                 return Result(outcome: .timedOut, output: output)
             }
@@ -67,21 +86,58 @@ struct CodexLoginRunner {
         }.value
     }
 
-    private static func wait(for process: Process, timeout: TimeInterval) async -> Bool {
-        await withTaskGroup(of: Bool.self) { group -> Bool in
-            group.addTask {
-                process.waitUntilExit()
-                return false
+    private final class ProcessTermination: @unchecked Sendable {
+        private let lock = NSLock()
+        private var timedOut: Bool?
+        private var continuation: CheckedContinuation<Bool, Never>?
+
+        func resolve(timedOut: Bool) {
+            let continuation: CheckedContinuation<Bool, Never>?
+            self.lock.lock()
+            guard self.timedOut == nil else {
+                self.lock.unlock()
+                return
+            }
+            self.timedOut = timedOut
+            continuation = self.continuation
+            self.continuation = nil
+            self.lock.unlock()
+            continuation?.resume(returning: timedOut)
+        }
+
+        func wait() async -> Bool {
+            await withCheckedContinuation { continuation in
+                let timedOut: Bool?
+                self.lock.lock()
+                timedOut = self.timedOut
+                if timedOut == nil {
+                    self.continuation = continuation
+                }
+                self.lock.unlock()
+
+                if let timedOut {
+                    continuation.resume(returning: timedOut)
+                }
             }
-            group.addTask {
-                let nanos = UInt64(max(0, timeout) * 1_000_000_000)
-                try? await Task.sleep(nanoseconds: nanos)
-                return true
+        }
+    }
+
+    private static func wait(timeout: TimeInterval, termination: ProcessTermination) async -> Bool {
+        let timeoutTask = Task.detached(priority: .userInitiated) {
+            try? await Task.sleep(nanoseconds: self.timeoutNanoseconds(timeout))
+            if Task.isCancelled == false {
+                termination.resolve(timedOut: true)
             }
-            let result = await group.next() ?? false
-            group.cancelAll()
-            return result
         }
+        let timedOut = await termination.wait()
+        timeoutTask.cancel()
+        return timedOut
+    }
+
+    private static func timeoutNanoseconds(_ timeout: TimeInterval) -> UInt64 {
+        guard timeout.isFinite else { return UInt64.max }
+        let seconds = max(0, min(timeout, Double(UInt64.max) / 1_000_000_000))
+        return UInt64(seconds * 1_000_000_000)
     }
 
     private static func terminate(_ process: Process, processGroup: pid_t?) {
@@ -110,45 +166,28 @@ struct CodexLoginRunner {
         return setpgid(pid, pid) == 0 ? pid : nil
     }
 
-    private static func combinedOutput(stdout: Pipe, stderr: Pipe) async -> String {
-        async let out = self.readToEnd(stdout)
-        async let err = self.readToEnd(stderr)
-        let stdoutText = await out
-        let stderrText = await err
-
-        let merged: String = if !stdoutText.isEmpty, !stderrText.isEmpty {
-            [stdoutText, stderrText].joined(separator: "\n")
+    private static func combinedOutput(
+        stdout: ProcessPipeCapture,
+        stderr: ProcessPipeCapture,
+        timeout: TimeInterval) async -> String
+    {
+        let drainTimeout = Duration.seconds(max(0, timeout))
+        async let outData = stdout.finish(timeout: drainTimeout)
+        async let errData = stderr.finish(timeout: drainTimeout)
+        let out = await self.decode(outData)
+        let err = await self.decode(errData)
+
+        let merged: String = if !out.isEmpty, !err.isEmpty {
+            [out, err].joined(separator: "\n")
         } else {
-            stdoutText + stderrText
+            out + err
         }
         let trimmed = merged.trimmingCharacters(in: .whitespacesAndNewlines)
         let limited = trimmed.prefix(4000)
-        return limited.isEmpty ? "No output captured." : String(limited)
-    }
-
-    private static func readToEnd(_ pipe: Pipe, timeout: TimeInterval = 3.0) async -> String {
-        await withTaskGroup(of: String?.self) { group -> String in
-            group.addTask {
-                if #available(macOS 13.0, *) {
-                    if let data = try? pipe.fileHandleForReading.readToEnd() { return self.decode(data) }
-                }
-                let data = pipe.fileHandleForReading.readDataToEndOfFile()
-                return Self.decode(data)
-            }
-            group.addTask {
-                let nanos = UInt64(max(0, timeout) * 1_000_000_000)
-                try? await Task.sleep(nanoseconds: nanos)
-                return nil
-            }
-            let result = await group.next()
-            group.cancelAll()
-            if let result, let text = result { return text }
-            return ""
-        }
+        return limited.isEmpty ? L("No output captured.") : String(limited)
     }
 
     private static func decode(_ data: Data) -> String {
-        guard let text = String(data: data, encoding: .utf8) else { return "" }
-        return text
+        ProcessPipeCapture.decodeUTF8(data)
     }
 }
diff --git a/Sources/CodexBar/CodexOwnershipContext.swift b/Sources/CodexBar/CodexOwnershipContext.swift
new file mode 100644
index 0000000000..7231ee6308
--- /dev/null
+++ b/Sources/CodexBar/CodexOwnershipContext.swift
@@ -0,0 +1,188 @@
+import CodexBarCore
+import CryptoKit
+import Foundation
+
+struct CodexOwnershipContext {
+    let canonicalKey: String?
+    let canonicalEmailHashKey: String?
+    let historicalLegacyEmailHash: String?
+    let planUtilizationLegacyEmailHash: String?
+    let currentWeeklyResetAt: Date?
+    let hasAdjacentMultiAccountVeto: Bool
+    let hasAdjacentEmailScopeAmbiguity: Bool
+}
+
+extension UsageStore {
+    func codexOwnershipContext(
+        preferredEmail: String? = nil,
+        snapshot: UsageSnapshot? = nil,
+        includeDashboardFallback: Bool = false) -> CodexOwnershipContext
+    {
+        let resolvedIdentity = self.currentCodexRuntimeIdentity(
+            source: self.settings.codexResolvedActiveSource,
+            preferCurrentSnapshot: true,
+            allowLastKnownLiveFallback: true)
+        let activeSourceEmail = self.codexAccountScopedRefreshEmail(
+            preferCurrentSnapshot: true,
+            allowLastKnownLiveFallback: true)
+        let normalizedEmail = CodexIdentityResolver.normalizeEmail(
+            preferredEmail ??
+                activeSourceEmail ??
+                snapshot?.accountEmail(for: .codex) ??
+                self.snapshots[.codex]?.accountEmail(for: .codex) ??
+                (includeDashboardFallback ? self.codexAccountEmailForOpenAIDashboard() : nil))
+        let canonicalIdentity: CodexIdentity = switch resolvedIdentity {
+        case .unresolved:
+            if let normalizedEmail {
+                .emailOnly(normalizedEmail: normalizedEmail)
+            } else {
+                .unresolved
+            }
+        default:
+            resolvedIdentity
+        }
+        let legacyEmailSource: String? = switch canonicalIdentity {
+        case let .emailOnly(normalizedEmail):
+            normalizedEmail
+        case .providerAccount, .unresolved:
+            normalizedEmail
+        }
+        let attachedDashboardSnapshot = includeDashboardFallback
+            ? self.attachedOpenAIDashboardSnapshot
+            : nil
+        let normalizedDashboardSnapshot = attachedDashboardSnapshot?
+            .toUsageSnapshot(provider: .codex, accountEmail: normalizedEmail)
+        let currentWeeklyResetAt = snapshot?.secondary?.resetsAt
+            ?? self.snapshots[.codex]?.secondary?.resetsAt
+            ?? normalizedDashboardSnapshot?.secondary?.resetsAt
+
+        return CodexOwnershipContext(
+            canonicalKey: CodexHistoryOwnership.canonicalKey(for: canonicalIdentity),
+            canonicalEmailHashKey: normalizedEmail.map { CodexHistoryOwnership.canonicalEmailHashKey(for: $0) },
+            historicalLegacyEmailHash: legacyEmailSource.map {
+                CodexHistoryOwnership.legacyEmailHash(normalizedEmail: $0)
+            },
+            planUtilizationLegacyEmailHash: legacyEmailSource.map {
+                Self.codexLegacyPlanUtilizationEmailHashKey(for: $0)
+            },
+            currentWeeklyResetAt: currentWeeklyResetAt,
+            hasAdjacentMultiAccountVeto: self.codexHasAdjacentMultiAccountVeto(),
+            hasAdjacentEmailScopeAmbiguity: normalizedEmail.map {
+                self.codexHasAdjacentEmailScopeAmbiguity(normalizedEmail: $0) ||
+                    self.codexVisibleAccountsHaveAdjacentEmailScopeAmbiguity(normalizedEmail: $0)
+            } ?? false)
+    }
+
+    func codexOwnershipContext(
+        forVisibleAccount account: CodexVisibleAccount,
+        currentWeeklyResetAt: Date? = nil) -> CodexOwnershipContext
+    {
+        let normalizedEmail = CodexIdentityResolver.normalizeEmail(account.email)
+        let workspaceAccountID = CodexOpenAIWorkspaceResolver.normalizeWorkspaceAccountID(account.workspaceAccountID)
+        let canonicalIdentity: CodexIdentity = if let workspaceAccountID {
+            .providerAccount(id: workspaceAccountID)
+        } else if let normalizedEmail {
+            .emailOnly(normalizedEmail: normalizedEmail)
+        } else {
+            .unresolved
+        }
+
+        return CodexOwnershipContext(
+            canonicalKey: CodexHistoryOwnership.canonicalKey(for: canonicalIdentity),
+            canonicalEmailHashKey: normalizedEmail.map { CodexHistoryOwnership.canonicalEmailHashKey(for: $0) },
+            historicalLegacyEmailHash: normalizedEmail.map {
+                CodexHistoryOwnership.legacyEmailHash(normalizedEmail: $0)
+            },
+            planUtilizationLegacyEmailHash: normalizedEmail.map {
+                Self.codexLegacyPlanUtilizationEmailHashKey(for: $0)
+            },
+            currentWeeklyResetAt: currentWeeklyResetAt,
+            hasAdjacentMultiAccountVeto: self.codexHasAdjacentMultiAccountVeto() ||
+                self.codexVisibleAccountsHaveAdjacentMultiAccountVeto(),
+            hasAdjacentEmailScopeAmbiguity: normalizedEmail.map {
+                self.codexHasAdjacentEmailScopeAmbiguity(normalizedEmail: $0) ||
+                    self.codexVisibleAccountsHaveAdjacentEmailScopeAmbiguity(normalizedEmail: $0)
+            } ?? false)
+    }
+
+    func codexHasAdjacentMultiAccountVeto() -> Bool {
+        let snapshot = self.settings.codexAccountReconciliationSnapshot
+        var distinctAccounts: Set<String> = []
+
+        if let activeManagedAccount = self.settings.activeManagedCodexAccount {
+            distinctAccounts.insert(CodexIdentityMatcher.selectionKey(
+                for: snapshot.runtimeIdentity(for: activeManagedAccount),
+                fallbackEmail: snapshot.runtimeEmail(for: activeManagedAccount)))
+        }
+
+        if let liveSystemAccount = snapshot.liveSystemAccount {
+            distinctAccounts.insert(CodexIdentityMatcher.selectionKey(
+                for: snapshot.runtimeIdentity(for: liveSystemAccount),
+                fallbackEmail: liveSystemAccount.email))
+        }
+
+        return distinctAccounts.count > 1
+    }
+
+    private func codexHasAdjacentEmailScopeAmbiguity(normalizedEmail: String) -> Bool {
+        let snapshot = self.settings.codexAccountReconciliationSnapshot
+        var distinctAccounts: Set<String> = []
+
+        if let activeManagedAccount = self.settings.activeManagedCodexAccount,
+           CodexIdentityResolver.normalizeEmail(snapshot.runtimeEmail(for: activeManagedAccount)) == normalizedEmail
+        {
+            distinctAccounts.insert(CodexIdentityMatcher.selectionKey(
+                for: snapshot.runtimeIdentity(for: activeManagedAccount),
+                fallbackEmail: snapshot.runtimeEmail(for: activeManagedAccount)))
+        }
+
+        if let liveSystemAccount = snapshot.liveSystemAccount,
+           CodexIdentityResolver.normalizeEmail(liveSystemAccount.email) == normalizedEmail
+        {
+            distinctAccounts.insert(CodexIdentityMatcher.selectionKey(
+                for: snapshot.runtimeIdentity(for: liveSystemAccount),
+                fallbackEmail: liveSystemAccount.email))
+        }
+
+        return distinctAccounts.count > 1
+    }
+
+    private func codexVisibleAccountsHaveAdjacentMultiAccountVeto() -> Bool {
+        let accounts = self.settings.codexVisibleAccountProjection.visibleAccounts
+        var distinctAccounts: Set<String> = []
+        for account in accounts {
+            if let workspaceAccountID = CodexOpenAIWorkspaceResolver.normalizeWorkspaceAccountID(
+                account.workspaceAccountID)
+            {
+                distinctAccounts.insert("provider:\(workspaceAccountID)")
+            } else if let normalizedEmail = CodexIdentityResolver.normalizeEmail(account.email) {
+                distinctAccounts.insert("email:\(normalizedEmail)")
+            }
+        }
+        return distinctAccounts.count > 1
+    }
+
+    private func codexVisibleAccountsHaveAdjacentEmailScopeAmbiguity(normalizedEmail: String) -> Bool {
+        let accounts = self.settings.codexVisibleAccountProjection.visibleAccounts
+        var distinctAccounts: Set<String> = []
+        for account in accounts where CodexIdentityResolver.normalizeEmail(account.email) == normalizedEmail {
+            if let workspaceAccountID = CodexOpenAIWorkspaceResolver.normalizeWorkspaceAccountID(
+                account.workspaceAccountID)
+            {
+                distinctAccounts.insert("provider:\(workspaceAccountID)")
+            } else {
+                distinctAccounts.insert("email:\(normalizedEmail)")
+            }
+        }
+        return distinctAccounts.count > 1
+    }
+
+    nonisolated static func codexLegacyPlanUtilizationEmailHashKey(for normalizedEmail: String) -> String {
+        self.sha256Hex("\(UsageProvider.codex.rawValue):email:\(normalizedEmail)")
+    }
+
+    nonisolated static func sha256Hex(_ input: String) -> String {
+        let digest = SHA256.hash(data: Data(input.utf8))
+        return digest.map { String(format: "%02x", $0) }.joined()
+    }
+}
diff --git a/Sources/CodexBar/CodexbarApp.swift b/Sources/CodexBar/CodexbarApp.swift
index fca4af153d..e5d7f485a4 100644
--- a/Sources/CodexBar/CodexbarApp.swift
+++ b/Sources/CodexBar/CodexbarApp.swift
@@ -11,6 +11,8 @@ struct CodexBarApp: App {
     @NSApplicationDelegateAdaptor(AppDelegate.self) private var appDelegate
     @State private var settings: SettingsStore
     @State private var store: UsageStore
+    @State private var managedCodexAccountCoordinator: ManagedCodexAccountCoordinator
+    @State private var codexAccountPromotionCoordinator: CodexAccountPromotionCoordinator
     private let preferencesSelection: PreferencesSelection
     private let account: AccountInfo
 
@@ -38,23 +40,41 @@ struct CodexBarApp: App {
 
         KeychainAccessGate.isDisabled = UserDefaults.standard.bool(forKey: "debugDisableKeychainAccess")
         KeychainPromptCoordinator.install()
+        if MainThreadHangWatchdog.isEnabledForCurrentProcess {
+            MainThreadHangWatchdog.shared.start()
+        }
 
         let preferencesSelection = PreferencesSelection()
         let settings = SettingsStore()
+        Self.applyLanguagePreference(from: settings)
+        configureUsageFormatterLocalizationProvider()
+        let managedCodexAccountCoordinator = ManagedCodexAccountCoordinator()
+        managedCodexAccountCoordinator.onManagedAccountsDidChange = {
+            _ = settings.refreshCodexAccountReconciliationAfterManagedAccountsDidChange()
+        }
+        _ = settings.persistResolvedCodexActiveSourceCorrectionIfNeeded()
         let fetcher = UsageFetcher()
         let browserDetection = BrowserDetection(cacheTTL: BrowserDetection.defaultCacheTTL)
         let account = fetcher.loadAccountInfo()
         let store = UsageStore(fetcher: fetcher, browserDetection: browserDetection, settings: settings)
+        let codexAccountPromotionCoordinator = CodexAccountPromotionCoordinator(
+            settingsStore: settings,
+            usageStore: store,
+            managedAccountCoordinator: managedCodexAccountCoordinator)
         self.preferencesSelection = preferencesSelection
         _settings = State(wrappedValue: settings)
         _store = State(wrappedValue: store)
+        _managedCodexAccountCoordinator = State(wrappedValue: managedCodexAccountCoordinator)
+        _codexAccountPromotionCoordinator = State(wrappedValue: codexAccountPromotionCoordinator)
         self.account = account
         CodexBarLog.setLogLevel(settings.debugLogLevel)
-        self.appDelegate.configure(
+        self.appDelegate.configure(.init(
             store: store,
             settings: settings,
             account: account,
-            selection: preferencesSelection)
+            selection: preferencesSelection,
+            managedCodexAccountCoordinator: managedCodexAccountCoordinator,
+            codexAccountPromotionCoordinator: codexAccountPromotionCoordinator))
     }
 
     @SceneBuilder
@@ -72,7 +92,12 @@ struct CodexBarApp: App {
                 settings: self.settings,
                 store: self.store,
                 updater: self.appDelegate.updaterController,
-                selection: self.preferencesSelection)
+                selection: self.preferencesSelection,
+                managedCodexAccountCoordinator: self.managedCodexAccountCoordinator,
+                codexAccountPromotionCoordinator: self.codexAccountPromotionCoordinator,
+                runProviderLoginFlow: { provider in
+                    await self.appDelegate.runProviderLoginFlow(provider)
+                })
         }
         .defaultSize(width: PreferencesTab.general.preferredWidth, height: PreferencesTab.general.preferredHeight)
         .windowResizability(.contentSize)
@@ -83,6 +108,15 @@ struct CodexBarApp: App {
         NSApp.activate(ignoringOtherApps: true)
         _ = NSApp.sendAction(Selector(("showPreferencesWindow:")), to: nil, from: nil)
     }
+
+    private static func applyLanguagePreference(from settings: SettingsStore) {
+        let language = settings.appLanguage
+        if language.isEmpty {
+            UserDefaults.standard.removeObject(forKey: "AppleLanguages")
+        } else {
+            UserDefaults.standard.set([language], forKey: "AppleLanguages")
+        }
+    }
 }
 
 // MARK: - Updater abstraction
@@ -95,6 +129,7 @@ protocol UpdaterProviding: AnyObject {
     var unavailableReason: String? { get }
     var updateStatus: UpdateStatus { get }
     func checkForUpdates(_ sender: Any?)
+    func installUpdate()
 }
 
 /// No-op updater used for debug builds and non-bundled runs to suppress Sparkle dialogs.
@@ -110,6 +145,7 @@ final class DisabledUpdaterController: UpdaterProviding {
     }
 
     func checkForUpdates(_ sender: Any?) {}
+    func installUpdate() {}
 }
 
 @MainActor
@@ -128,12 +164,25 @@ import Sparkle
 
 @MainActor
 final class SparkleUpdaterController: NSObject, UpdaterProviding, SPUUpdaterDelegate {
+    private final class ImmediateInstallHandler: @unchecked Sendable {
+        private let handler: () -> Void
+
+        init(_ handler: @escaping () -> Void) {
+            self.handler = handler
+        }
+
+        func install() {
+            self.handler()
+        }
+    }
+
     private lazy var controller = SPUStandardUpdaterController(
         startingUpdater: false,
         updaterDelegate: self,
         userDriverDelegate: nil)
     let updateStatus = UpdateStatus()
     let unavailableReason: String? = nil
+    private var immediateInstallHandler: ImmediateInstallHandler?
 
     init(savedAutoUpdate: Bool) {
         super.init()
@@ -161,20 +210,59 @@ final class SparkleUpdaterController: NSObject, UpdaterProviding, SPUUpdaterDele
         self.controller.checkForUpdates(sender)
     }
 
-    nonisolated func updater(_ updater: SPUUpdater, didDownloadUpdate item: SUAppcastItem) {
-        Task { @MainActor in
-            self.updateStatus.isUpdateReady = true
+    func installUpdate() {
+        guard let immediateInstallHandler else {
+            self.controller.checkForUpdates(nil)
+            return
         }
+
+        immediateInstallHandler.install()
+    }
+
+    nonisolated func updater(_ updater: SPUUpdater, didDownloadUpdate item: SUAppcastItem) {
+        _ = updater
+        _ = item
     }
 
     nonisolated func updater(_ updater: SPUUpdater, failedToDownloadUpdate item: SUAppcastItem, error: Error) {
+        _ = updater
+        _ = item
+        _ = error
         Task { @MainActor in
+            self.immediateInstallHandler = nil
             self.updateStatus.isUpdateReady = false
         }
     }
 
     nonisolated func userDidCancelDownload(_ updater: SPUUpdater) {
+        _ = updater
+        Task { @MainActor in
+            self.immediateInstallHandler = nil
+            self.updateStatus.isUpdateReady = false
+        }
+    }
+
+    nonisolated func updater(
+        _ updater: SPUUpdater,
+        willInstallUpdateOnQuit item: SUAppcastItem,
+        immediateInstallationBlock immediateInstallHandler: @escaping () -> Void)
+        -> Bool
+    {
+        _ = updater
+        _ = item
+        let installHandler = ImmediateInstallHandler(immediateInstallHandler)
+        Task { @MainActor in
+            self.immediateInstallHandler = installHandler
+            self.updateStatus.isUpdateReady = true
+        }
+        return true
+    }
+
+    nonisolated func updater(_ updater: SPUUpdater, didAbortWithError error: Error) {
+        _ = updater
+        _ = error
         Task { @MainActor in
+            self.immediateInstallHandler = nil
             self.updateStatus.isUpdateReady = false
         }
     }
@@ -189,10 +277,12 @@ final class SparkleUpdaterController: NSObject, UpdaterProviding, SPUUpdaterDele
         Task { @MainActor in
             switch choice {
             case .install, .skip:
+                self.immediateInstallHandler = nil
                 self.updateStatus.isUpdateReady = false
             case .dismiss:
                 self.updateStatus.isUpdateReady = downloaded
             @unknown default:
+                self.immediateInstallHandler = nil
                 self.updateStatus.isUpdateReady = false
             }
         }
@@ -251,18 +341,44 @@ private func makeUpdaterController() -> UpdaterProviding {
 
 @MainActor
 final class AppDelegate: NSObject, NSApplicationDelegate {
+    struct Dependencies {
+        let store: UsageStore
+        let settings: SettingsStore
+        let account: AccountInfo
+        let selection: PreferencesSelection
+        let managedCodexAccountCoordinator: ManagedCodexAccountCoordinator
+        let codexAccountPromotionCoordinator: CodexAccountPromotionCoordinator
+    }
+
     let updaterController: UpdaterProviding = makeUpdaterController()
+    private let confettiOverlayController = ScreenConfettiOverlayController()
+    private let confettiLogger = CodexBarLog.logger(LogCategories.confetti)
+    private lazy var memoryPressureMonitor = MemoryPressureMonitor(trimAppCaches: { [weak self] in
+        self?.trimRebuildableCachesForMemoryPressure() ?? MemoryPressureCacheTrimSummary()
+    })
+
     private var statusController: StatusItemControlling?
     private var store: UsageStore?
     private var settings: SettingsStore?
     private var account: AccountInfo?
     private var preferencesSelection: PreferencesSelection?
+    private var managedCodexAccountCoordinator: ManagedCodexAccountCoordinator?
+    private var codexAccountPromotionCoordinator: CodexAccountPromotionCoordinator?
+    private var hasInstalledWeeklyLimitResetObserver = false
+    #if DEBUG
+    private var debugMemoryPressureObserver: NSObjectProtocol?
+    #endif
+    var terminateActiveProcessesForAppShutdown: () -> Void = {
+        TTYCommandRunner.terminateActiveProcessesForAppShutdown()
+    }
 
-    func configure(store: UsageStore, settings: SettingsStore, account: AccountInfo, selection: PreferencesSelection) {
-        self.store = store
-        self.settings = settings
-        self.account = account
-        self.preferencesSelection = selection
+    func configure(_ dependencies: Dependencies) {
+        self.store = dependencies.store
+        self.settings = dependencies.settings
+        self.account = dependencies.account
+        self.preferencesSelection = dependencies.selection
+        self.managedCodexAccountCoordinator = dependencies.managedCodexAccountCoordinator
+        self.codexAccountPromotionCoordinator = dependencies.codexAccountPromotionCoordinator
     }
 
     func applicationWillFinishLaunching(_ notification: Notification) {
@@ -271,16 +387,56 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
 
     func applicationDidFinishLaunching(_ notification: Notification) {
         AppNotifications.shared.requestAuthorizationOnStartup()
+        self.memoryPressureMonitor.start()
+        #if DEBUG
+        self.installDebugMemoryPressureObserverIfNeeded()
+        #endif
         self.ensureStatusController()
         KeyboardShortcuts.onKeyUp(for: .openMenu) { [weak self] in
-            Task { @MainActor [weak self] in
+            // KeyboardShortcuts dispatches both normal and menu-tracking hotkeys on the main event loop.
+            MainActor.assumeIsolated {
                 self?.statusController?.openMenuFromShortcut()
             }
         }
+        if !self.hasInstalledWeeklyLimitResetObserver {
+            NotificationCenter.default.addObserver(
+                self,
+                selector: #selector(self.handleWeeklyLimitResetNotification(_:)),
+                name: .codexbarWeeklyLimitReset,
+                object: nil)
+            self.hasInstalledWeeklyLimitResetObserver = true
+        }
     }
 
     func applicationWillTerminate(_ notification: Notification) {
-        TTYCommandRunner.terminateActiveProcessesForAppShutdown()
+        self.memoryPressureMonitor.stop()
+        #if DEBUG
+        self.removeDebugMemoryPressureObserver()
+        #endif
+        self.statusController?.prepareForAppShutdown()
+        self.confettiOverlayController.dismiss()
+        self.dismissAppKitWindowsForShutdown()
+        self.terminateActiveProcessesForAppShutdown()
+    }
+
+    func runProviderLoginFlow(_ provider: UsageProvider) async {
+        self.ensureStatusController()
+        guard let statusController else { return }
+        await statusController.runLoginFlowFromSettings(provider: provider)
+    }
+
+    @objc private func handleWeeklyLimitResetNotification(_ notification: Notification) {
+        guard let event = notification.object as? WeeklyLimitResetEvent else { return }
+        guard self.settings?.confettiOnWeeklyLimitResetsEnabled == true else { return }
+        let origin = self.statusController?.celebrationOriginPoint(for: event.provider)
+        self.confettiLogger.info(
+            "Triggering confetti",
+            metadata: [
+                "provider": event.provider.rawValue,
+                "accountIdentifier": event.accountIdentifier,
+                "originKnown": origin == nil ? "0" : "1",
+            ])
+        self.confettiOverlayController.play(originInScreen: origin)
     }
 
     /// Use the classic (non-Liquid Glass) app icon on macOS versions before 26.
@@ -308,16 +464,31 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
         Bundle.main.url(forResource: "Icon-classic", withExtension: "icns")
     }
 
+    private func dismissAppKitWindowsForShutdown() {
+        guard let app = NSApp else { return }
+        for window in app.windows {
+            window.orderOut(nil)
+        }
+    }
+
     private func ensureStatusController() {
         if self.statusController != nil { return }
 
-        if let store, let settings, let account, let selection = self.preferencesSelection {
+        if let store,
+           let settings,
+           let account,
+           let selection = self.preferencesSelection,
+           let managedCodexAccountCoordinator,
+           let codexAccountPromotionCoordinator
+        {
             self.statusController = StatusItemController.factory(
                 store,
                 settings,
                 account,
                 self.updaterController,
-                selection)
+                selection,
+                managedCodexAccountCoordinator,
+                codexAccountPromotionCoordinator)
             return
         }
 
@@ -330,11 +501,74 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
         let browserDetection = BrowserDetection(cacheTTL: BrowserDetection.defaultCacheTTL)
         let fallbackAccount = fetcher.loadAccountInfo()
         let fallbackStore = UsageStore(fetcher: fetcher, browserDetection: browserDetection, settings: fallbackSettings)
+        let fallbackManagedCodexAccountCoordinator = ManagedCodexAccountCoordinator()
+        let fallbackCodexAccountPromotionCoordinator = CodexAccountPromotionCoordinator(
+            settingsStore: fallbackSettings,
+            usageStore: fallbackStore,
+            managedAccountCoordinator: fallbackManagedCodexAccountCoordinator)
         self.statusController = StatusItemController.factory(
             fallbackStore,
             fallbackSettings,
             fallbackAccount,
             self.updaterController,
-            PreferencesSelection())
+            PreferencesSelection(),
+            fallbackManagedCodexAccountCoordinator,
+            fallbackCodexAccountPromotionCoordinator)
+    }
+
+    private func trimRebuildableCachesForMemoryPressure() -> MemoryPressureCacheTrimSummary {
+        var summary = MemoryPressureCacheTrimSummary()
+        let statusSummary = self.statusController?.trimRebuildableCachesForMemoryPressure()
+            ?? MemoryPressureCacheTrimSummary()
+        let storeSummary = self.store?.trimRebuildableCachesForMemoryPressure()
+            ?? MemoryPressureCacheTrimSummary()
+        summary.merge(statusSummary)
+        summary.merge(storeSummary)
+        return summary
+    }
+
+    #if DEBUG
+    private func installDebugMemoryPressureObserverIfNeeded() {
+        guard self.debugMemoryPressureObserver == nil else { return }
+        self.debugMemoryPressureObserver = DistributedNotificationCenter.default().addObserver(
+            forName: .codexbarDebugSimulateMemoryPressure,
+            object: nil,
+            queue: .main)
+        { [weak self] notification in
+            let rawLevel = notification.userInfo?["level"] as? String
+            let shouldSeedCaches = notification.userInfo?["seedCaches"] as? String == "1"
+            MainActor.assumeIsolated {
+                self?.handleDebugMemoryPressureNotification(
+                    rawLevel: rawLevel,
+                    shouldSeedCaches: shouldSeedCaches)
+            }
+        }
+    }
+
+    private func removeDebugMemoryPressureObserver() {
+        guard let observer = self.debugMemoryPressureObserver else { return }
+        DistributedNotificationCenter.default().removeObserver(observer)
+        self.debugMemoryPressureObserver = nil
+    }
+
+    private func handleDebugMemoryPressureNotification(rawLevel: String?, shouldSeedCaches: Bool) {
+        let isCritical = rawLevel?.caseInsensitiveCompare("critical") == .orderedSame
+        if shouldSeedCaches {
+            OpenAIDashboardFetcher.seedCachedWebViewsForMemoryPressureProof()
+            self.statusController?.seedRebuildableCachesForMemoryPressureProof()
+            self.store?.seedRebuildableCachesForMemoryPressureProof()
+        }
+        CodexBarLog.logger(LogCategories.memoryPressure).info(
+            "Debug memory pressure notification received",
+            metadata: [
+                "level": isCritical ? "critical" : "warning",
+                "seedCaches": shouldSeedCaches ? "1" : "0",
+            ])
+        self.memoryPressureMonitor.handleMemoryPressureForTesting(isWarning: !isCritical, isCritical: isCritical)
+    }
+    #endif
+
+    deinit {
+        NotificationCenter.default.removeObserver(self)
     }
 }
diff --git a/Sources/CodexBar/Config/CodexBarConfigMigrator.swift b/Sources/CodexBar/Config/CodexBarConfigMigrator.swift
index a346297661..733e4198ee 100644
--- a/Sources/CodexBar/Config/CodexBarConfigMigrator.swift
+++ b/Sources/CodexBar/Config/CodexBarConfigMigrator.swift
@@ -20,6 +20,8 @@ struct CodexBarConfigMigrator {
         let tokenAccountStore: any ProviderTokenAccountStoring
     }
 
+    private static let legacyMigrationCompletedKey = "codexbar.legacySecretsMigrationCompleted"
+
     private struct MigrationState {
         var didUpdate = false
         var sawLegacySecrets = false
@@ -36,24 +38,43 @@ struct CodexBarConfigMigrator {
         var config = (existing ?? CodexBarConfig.makeDefault()).normalized()
         var state = MigrationState()
 
-        if existing == nil {
-            self.applyLegacyOrderAndToggles(userDefaults: userDefaults, config: &config, state: &state)
-        }
-
+        // applyLegacyCookieSources reads only UserDefaults — cheap, runs unconditionally so
+        // newly-added cookie-source keys are picked up on every launch.
         self.applyLegacyCookieSources(userDefaults: userDefaults, config: &config, state: &state)
-        self.migrateLegacySecrets(userDefaults: userDefaults, stores: stores, config: &config, state: &state)
-        self.migrateLegacyAccounts(stores: stores, config: &config, state: &state)
 
+        let migrationCompleted = userDefaults.bool(forKey: Self.legacyMigrationCompletedKey)
+        if !migrationCompleted {
+            // Run once: migrate Keychain/file secrets then clear them. Using a completion flag rather
+            // than `existing == nil` ensures a crash between config-save and clearLegacyStores can
+            // finish cleanup on the next launch without re-doing the (already-saved) data migration.
+            if existing == nil {
+                self.applyLegacyOrderAndToggles(userDefaults: userDefaults, config: &config, state: &state)
+            }
+            self.migrateLegacySecrets(userDefaults: userDefaults, stores: stores, config: &config, state: &state)
+            self.migrateLegacyAccounts(stores: stores, config: &config, state: &state)
+        }
+
+        var didPersistUpdates = true
         if state.didUpdate {
             do {
                 try configStore.save(config)
             } catch {
+                didPersistUpdates = false
                 log.error("Failed to persist config: \(error)")
             }
         }
 
+        guard didPersistUpdates else {
+            return config.normalized()
+        }
+
         if state.sawLegacySecrets || state.sawLegacyAccounts {
-            self.clearLegacyStores(stores: stores, sawAccounts: state.sawLegacyAccounts, log: log)
+            let cleared = self.clearLegacyStores(stores: stores, sawAccounts: state.sawLegacyAccounts, log: log)
+            if cleared {
+                userDefaults.set(true, forKey: Self.legacyMigrationCompletedKey)
+            }
+        } else if !migrationCompleted {
+            userDefaults.set(true, forKey: Self.legacyMigrationCompletedKey)
         }
 
         return config.normalized()
@@ -274,11 +295,13 @@ struct CodexBarConfigMigrator {
         return false
     }
 
+    @discardableResult
     private static func clearLegacyStores(
         stores: LegacyStores,
         sawAccounts: Bool,
-        log: CodexBarLogger)
+        log: CodexBarLogger) -> Bool
     {
+        var success = true
         do {
             try stores.zaiTokenStore.storeToken(nil)
             try stores.syntheticTokenStore.storeToken(nil)
@@ -296,6 +319,7 @@ struct CodexBarConfigMigrator {
             try stores.ampCookieStore.storeCookieHeader(nil)
         } catch {
             log.error("Failed to clear legacy secrets: \(error)")
+            success = false
         }
 
         if sawAccounts {
@@ -304,6 +328,8 @@ struct CodexBarConfigMigrator {
                 try? FileManager.default.removeItem(at: legacyURL)
             }
         }
+
+        return success
     }
 
     private static func applyProviderOrder(_ raw: [String], config: CodexBarConfig) -> CodexBarConfig {
diff --git a/Sources/CodexBar/CostHistoryChartMenuView.swift b/Sources/CodexBar/CostHistoryChartMenuView.swift
index 9c77cf4ef7..17fc33d3db 100644
--- a/Sources/CodexBar/CostHistoryChartMenuView.swift
+++ b/Sources/CodexBar/CostHistoryChartMenuView.swift
@@ -6,69 +6,106 @@ import SwiftUI
 struct CostHistoryChartMenuView: View {
     typealias DailyEntry = CostUsageDailyReport.Entry
 
+    enum AxisLabelPlacement: Equatable {
+        case hidden
+        case centered
+        case edges
+    }
+
     private struct Point: Identifiable {
         let id: String
         let date: Date
         let costUSD: Double
         let totalTokens: Int?
+        let requestCount: Int?
 
-        init(date: Date, costUSD: Double, totalTokens: Int?) {
+        init(date: Date, costUSD: Double, totalTokens: Int?, requestCount: Int?) {
             self.date = date
             self.costUSD = costUSD
             self.totalTokens = totalTokens
+            self.requestCount = requestCount
             self.id = "\(Int(date.timeIntervalSince1970))-\(costUSD)"
         }
     }
 
+    private struct DetailRow: Identifiable {
+        let id: String
+        let title: String
+        let subtitle: String?
+        let modeSubtitle: String?
+        let accentColor: Color
+    }
+
+    private struct DetailContent {
+        let primary: String
+        let rows: [DetailRow]
+    }
+
     private let provider: UsageProvider
     private let daily: [DailyEntry]
     private let totalCostUSD: Double?
+    private let currencyCode: String
+    private let historyDays: Int
+    private let windowLabel: String?
     private let width: CGFloat
+    private let onHeightChange: ((CGFloat) -> Void)?
     @State private var selectedDateKey: String?
 
-    init(provider: UsageProvider, daily: [DailyEntry], totalCostUSD: Double?, width: CGFloat) {
+    init(
+        provider: UsageProvider,
+        daily: [DailyEntry],
+        totalCostUSD: Double?,
+        currencyCode: String = "USD",
+        historyDays: Int = 30,
+        windowLabel: String? = nil,
+        onHeightChange: ((CGFloat) -> Void)? = nil,
+        width: CGFloat)
+    {
         self.provider = provider
         self.daily = daily
         self.totalCostUSD = totalCostUSD
+        self.currencyCode = currencyCode
+        self.historyDays = max(1, min(365, historyDays))
+        self.windowLabel = windowLabel
+        self.onHeightChange = onHeightChange
         self.width = width
     }
 
     var body: some View {
         let model = Self.makeModel(provider: self.provider, daily: self.daily)
-        VStack(alignment: .leading, spacing: 10) {
+        let selectedDateKey = self.selectedDateKey ?? Self.defaultSelectedDateKey(model: model)
+        VStack(alignment: .leading, spacing: Self.outerSpacing) {
             if model.points.isEmpty {
-                Text("No cost history data.")
+                Text(L("No cost history data."))
                     .font(.footnote)
                     .foregroundStyle(.secondary)
+                    .accessibilityLabel(L("No cost history data."))
             } else {
                 Chart {
                     ForEach(model.points) { point in
                         BarMark(
-                            x: .value("Day", point.date, unit: .day),
-                            y: .value("Cost", point.costUSD))
+                            x: .value(L("Day"), point.date, unit: .day),
+                            y: .value(L("Cost"), point.costUSD))
                             .foregroundStyle(model.barColor)
                     }
                     if let peak = Self.peakPoint(model: model) {
                         let capStart = max(peak.costUSD - Self.capHeight(maxValue: model.maxCostUSD), 0)
                         BarMark(
-                            x: .value("Day", peak.date, unit: .day),
-                            yStart: .value("Cap start", capStart),
-                            yEnd: .value("Cap end", peak.costUSD))
+                            x: .value(L("Day"), peak.date, unit: .day),
+                            yStart: .value(L("Cap start"), capStart),
+                            yEnd: .value(L("Cap end"), peak.costUSD))
                             .foregroundStyle(Color(nsColor: .systemYellow))
                     }
                 }
                 .chartYAxis(.hidden)
-                .chartXAxis {
-                    AxisMarks(values: model.axisDates) { _ in
-                        AxisGridLine().foregroundStyle(Color.clear)
-                        AxisTick().foregroundStyle(Color.clear)
-                        AxisValueLabel(format: .dateTime.month(.abbreviated).day())
-                            .font(.caption2)
-                            .foregroundStyle(Color(nsColor: .tertiaryLabelColor))
-                    }
-                }
+                .chartXAxis(.hidden)
                 .chartLegend(.hidden)
-                .frame(height: 130)
+                .frame(height: Self.chartHeight)
+                .accessibilityLabel(L("Cost history chart"))
+                .accessibilityValue(
+                    model.points.isEmpty
+                        ? L("No data")
+                        : String(format: L("%d days of cost data"), model.points.count))
                 .chartOverlay { proxy in
                     GeometryReader { geo in
                         ZStack(alignment: .topLeading) {
@@ -88,33 +125,109 @@ struct CostHistoryChartMenuView: View {
                     }
                 }
 
-                let detail = self.detailLines(model: model)
-                VStack(alignment: .leading, spacing: 0) {
+                let axisLabelPlacement = Self.axisLabelPlacement(for: model.axisDates)
+                if axisLabelPlacement != .hidden {
+                    HStack {
+                        if axisLabelPlacement == .centered {
+                            Spacer()
+                        }
+                        Text(model.axisDates[0], format: .dateTime.month(.abbreviated).day())
+                            .font(.caption2)
+                            .foregroundStyle(Color(nsColor: .tertiaryLabelColor))
+                        Spacer()
+                        if axisLabelPlacement == .edges {
+                            Text(
+                                model.axisDates[model.axisDates.count - 1],
+                                format: .dateTime.month(.abbreviated).day())
+                                .font(.caption2)
+                                .foregroundStyle(Color(nsColor: .tertiaryLabelColor))
+                        }
+                    }
+                    .frame(height: Self.axisLabelAreaHeight)
+                    .padding(.top, -Self.outerSpacing)
+                }
+
+                let detail = self.detailContent(selectedDateKey: selectedDateKey, model: model)
+                VStack(alignment: .leading, spacing: Self.detailSpacing) {
                     Text(detail.primary)
                         .font(.caption)
                         .foregroundStyle(.secondary)
                         .lineLimit(1)
                         .truncationMode(.tail)
-                        .frame(height: 16, alignment: .leading)
-                    Text(detail.secondary ?? " ")
-                        .font(.caption)
-                        .foregroundStyle(.secondary)
-                        .lineLimit(1)
-                        .truncationMode(.tail)
-                        .frame(height: 16, alignment: .leading)
-                        .opacity(detail.secondary == nil ? 0 : 1)
+                        .frame(height: Self.detailPrimaryLineHeight, alignment: .leading)
+                    if !detail.rows.isEmpty {
+                        ScrollView(.vertical) {
+                            VStack(alignment: .leading, spacing: Self.detailSpacing) {
+                                ForEach(detail.rows) { row in
+                                    HStack(alignment: .top, spacing: 8) {
+                                        Rectangle()
+                                            .fill(row.accentColor)
+                                            .frame(
+                                                width: 2,
+                                                height: Self.accentHeight(for: row))
+                                            .padding(.top, 1)
+
+                                        VStack(alignment: .leading, spacing: 1) {
+                                            Text(row.title)
+                                                .font(.caption)
+                                                .foregroundStyle(.secondary)
+                                                .lineLimit(1)
+                                                .truncationMode(.tail)
+                                                .frame(height: Self.detailTitleLineHeight, alignment: .leading)
+                                            if let subtitle = row.subtitle {
+                                                Text(subtitle)
+                                                    .font(.caption2)
+                                                    .foregroundStyle(Color(nsColor: .tertiaryLabelColor))
+                                                    .lineLimit(1)
+                                                    .truncationMode(.tail)
+                                                    .frame(
+                                                        height: Self.detailSubtitleLineHeight,
+                                                        alignment: .leading)
+                                            }
+                                            if let modeSubtitle = row.modeSubtitle {
+                                                Text(modeSubtitle)
+                                                    .font(.caption2)
+                                                    .foregroundStyle(Color(nsColor: .tertiaryLabelColor))
+                                                    .lineLimit(1)
+                                                    .truncationMode(.tail)
+                                                    .frame(
+                                                        height: Self.detailSubtitleLineHeight,
+                                                        alignment: .leading)
+                                            }
+                                        }
+                                    }
+                                    .frame(height: Self.detailRowHeight(for: row), alignment: .leading)
+                                }
+                            }
+                        }
+                        .scrollIndicators(
+                            Self.detailRowsNeedScrolling(itemCount: detail.rows.count) ? .visible : .hidden)
+                        .frame(
+                            height: Self.detailRowsViewportHeight(rows: detail.rows),
+                            alignment: .topLeading)
+                        .id(selectedDateKey)
+                    }
                 }
+                .frame(
+                    height: Self.detailBlockHeight(rows: detail.rows),
+                    alignment: .topLeading)
             }
 
             if let total = self.totalCostUSD {
-                Text("Total (30d): \(UsageFormatter.usdString(total))")
+                Text(String(
+                    format: L("Est. total (%@): %@"),
+                    self.windowLabel ?? Self.windowLabel(days: self.historyDays),
+                    self.costString(total)))
                     .font(.caption)
                     .foregroundStyle(.secondary)
+                    .lineLimit(1)
+                    .truncationMode(.head)
+                    .frame(height: Self.detailPrimaryLineHeight, alignment: .leading)
             }
         }
         .padding(.horizontal, 16)
-        .padding(.vertical, 10)
-        .frame(minWidth: self.width, maxWidth: .infinity, alignment: .leading)
+        .padding(.vertical, Self.verticalPadding)
+        .frame(minWidth: self.width, maxWidth: .infinity, alignment: .top)
     }
 
     private struct Model {
@@ -129,6 +242,53 @@ struct CostHistoryChartMenuView: View {
     }
 
     private static let selectionBandColor = Color(nsColor: .labelColor).opacity(0.1)
+    static let maxVisibleDetailLines = 4
+    private static let detailPrimaryLineHeight: CGFloat = 16
+    private static let detailTitleLineHeight: CGFloat = 16
+    private static let detailSubtitleLineHeight: CGFloat = 13
+    private static let compactDetailRowHeight: CGFloat = 36
+    private static let expandedDetailRowHeight: CGFloat = 44
+    private static let detailSpacing: CGFloat = 6
+    private static let chartHeight: CGFloat = 114
+    private static let axisLabelAreaHeight: CGFloat = 16
+    private static let outerSpacing: CGFloat = 10
+    static let verticalPadding: CGFloat = 10
+
+    /// Deterministic total height of the rendered card for a given selection. NSMenu's modal
+    /// tracking run loop never delivers SwiftUI `onPreferenceChange`, so the live height can't be
+    /// measured via a GeometryReader while the menu is open. Every component height is fixed, so
+    /// we compute the total directly and resize from the hover handler instead.
+    private static func totalCardHeight(rows: [DetailRow], hasTotal: Bool) -> CGFloat {
+        var height = self.verticalPadding * 2
+        height += self.chartHeight
+        height += self.axisLabelAreaHeight
+        height += self.outerSpacing
+        height += self.detailBlockHeight(rows: rows)
+        if hasTotal {
+            height += self.outerSpacing
+            height += self.detailPrimaryLineHeight
+        }
+        return height
+    }
+
+    static func windowLabel(days: Int) -> String {
+        if days == 1 {
+            return L("Today")
+        }
+        return String(format: L("Last %d days"), days)
+    }
+
+    private static func detailRowHeight(for row: DetailRow) -> CGFloat {
+        self.detailRowHeight(hasModeSubtitle: row.modeSubtitle != nil)
+    }
+
+    private static func detailRowHeight(hasModeSubtitle: Bool) -> CGFloat {
+        hasModeSubtitle ? self.expandedDetailRowHeight : self.compactDetailRowHeight
+    }
+
+    private static func accentHeight(for row: DetailRow) -> CGFloat {
+        row.subtitle == nil && row.modeSubtitle == nil ? 14 : self.detailRowHeight(for: row)
+    }
 
     private static func capHeight(maxValue: Double) -> Double {
         maxValue * 0.05
@@ -151,9 +311,13 @@ struct CostHistoryChartMenuView: View {
         var peak: (key: String, costUSD: Double)?
         var maxCostUSD: Double = 0
         for entry in sorted {
-            guard let costUSD = entry.costUSD, costUSD > 0 else { continue }
+            guard let costUSD = entry.costUSD, costUSD >= 0 else { continue }
             guard let date = self.dateFromDayKey(entry.date) else { continue }
-            let point = Point(date: date, costUSD: costUSD, totalTokens: entry.totalTokens)
+            let point = Point(
+                date: date,
+                costUSD: costUSD,
+                totalTokens: entry.totalTokens,
+                requestCount: entry.requestCount)
             points.append(point)
             pointsByKey[entry.date] = point
             entriesByKey[entry.date] = entry
@@ -180,10 +344,18 @@ struct CostHistoryChartMenuView: View {
             dateKeys: dateKeys,
             axisDates: axisDates,
             barColor: barColor,
-            peakKey: peak?.key,
+            peakKey: maxCostUSD > 0 ? peak?.key : nil,
             maxCostUSD: maxCostUSD)
     }
 
+    private static func axisLabelPlacement(for dates: [Date]) -> AxisLabelPlacement {
+        switch dates.count {
+        case 0: .hidden
+        case 1: .centered
+        default: .edges
+        }
+    }
+
     private static func barColor(for provider: UsageProvider) -> Color {
         let color = ProviderDescriptorRegistry.descriptor(for: provider).branding.color
         return Color(red: color.red, green: color.green, blue: color.blue)
@@ -211,6 +383,30 @@ struct CostHistoryChartMenuView: View {
         return model.pointsByDateKey[key]
     }
 
+    private static func hasModeSubtitle(_ item: CostUsageDailyReport.ModelBreakdown) -> Bool {
+        item.standardCostUSD != nil || item.priorityCostUSD != nil
+    }
+
+    private static func detailBlockHeight(rows: [DetailRow]) -> CGFloat {
+        guard !rows.isEmpty else { return self.detailPrimaryLineHeight }
+        return self.detailPrimaryLineHeight + self.detailRowsViewportHeight(rows: rows) + self.detailSpacing
+    }
+
+    private static func detailRowsViewportHeight(rows: [DetailRow]) -> CGFloat {
+        let visibleRows = Array(rows.prefix(self.maxVisibleDetailLines))
+        guard !visibleRows.isEmpty else { return 0 }
+
+        let rowHeights = visibleRows.reduce(CGFloat(0)) { total, row in
+            total + self.detailRowHeight(for: row)
+        }
+        let spacing = CGFloat(max(visibleRows.count - 1, 0)) * self.detailSpacing
+        return rowHeights + spacing
+    }
+
+    private static func defaultSelectedDateKey(model: Model) -> String? {
+        model.dateKeys.last?.key
+    }
+
     private func selectionBandRect(model: Model, proxy: ChartProxy, geo: GeometryProxy) -> CGRect? {
         guard let key = self.selectedDateKey else { return nil }
         guard let plotAnchor = proxy.plotFrame else { return nil }
@@ -219,32 +415,13 @@ struct CostHistoryChartMenuView: View {
         let date = model.dateKeys[index].date
         guard let x = proxy.position(forX: date) else { return nil }
 
-        func xForIndex(_ idx: Int) -> CGFloat? {
-            guard idx >= 0, idx < model.dateKeys.count else { return nil }
-            return proxy.position(forX: model.dateKeys[idx].date)
-        }
-
-        let xPrev = xForIndex(index - 1)
-        let xNext = xForIndex(index + 1)
-
-        let leftInPlot: CGFloat = if let xPrev {
-            (xPrev + x) / 2
-        } else if let xNext {
-            x - (xNext - x) / 2
-        } else {
-            x - 8
-        }
+        // Use the calendar day slot width so the band stays the same size regardless of data gaps.
+        let nextDayX = proxy.position(forX: ChartBarHoverSelection.nextCalendarDay(after: date)) ?? (x + 20)
+        let slotWidth = abs(nextDayX - x)
+        let barHalfWidth = slotWidth * 0.25 + 2
 
-        let rightInPlot: CGFloat = if let xNext {
-            (xNext + x) / 2
-        } else if let xPrev {
-            x + (x - xPrev) / 2
-        } else {
-            x + 8
-        }
-
-        let left = plotFrame.origin.x + min(leftInPlot, rightInPlot)
-        let right = plotFrame.origin.x + max(leftInPlot, rightInPlot)
+        let left = plotFrame.origin.x + x - barHalfWidth
+        let right = plotFrame.origin.x + x + barHalfWidth
         return CGRect(x: left, y: plotFrame.origin.y, width: right - left, height: plotFrame.height)
     }
 
@@ -254,10 +431,9 @@ struct CostHistoryChartMenuView: View {
         proxy: ChartProxy,
         geo: GeometryProxy)
     {
-        guard let location else {
-            if self.selectedDateKey != nil { self.selectedDateKey = nil }
-            return
-        }
+        // Keep the last hovered day selected when the pointer leaves the chart so the adjacent
+        // model-breakdown scroller remains interactive. The selection resets with the menu view.
+        guard let location else { return }
 
         guard let plotAnchor = proxy.plotFrame else { return }
         let plotFrame = geo[plotAnchor]
@@ -267,11 +443,35 @@ struct CostHistoryChartMenuView: View {
         guard let date: Date = proxy.value(atX: xInPlot) else { return }
         guard let nearest = self.nearestDateKey(to: date, model: model) else { return }
 
+        // Stay on the last selected bar when cursor is in the gap between bars.
+        if let nearestEntry = model.dateKeys.first(where: { $0.key == nearest }),
+           let barX = proxy.position(forX: nearestEntry.date)
+        {
+            let nextDayX = proxy.position(forX: ChartBarHoverSelection.nextCalendarDay(after: nearestEntry.date)) ??
+                (barX + 20)
+            let slotWidth = abs(nextDayX - barX)
+            guard ChartBarHoverSelection.accepts(
+                distanceFromBarCenter: abs(location.x - (plotFrame.origin.x + barX)),
+                barHalfWidth: slotWidth * 0.25 + 2,
+                selectableCount: model.dateKeys.count)
+            else { return }
+        }
+
         if self.selectedDateKey != nearest {
             self.selectedDateKey = nearest
+            // Resize directly from the hover handler: this runs synchronously inside NSMenu's
+            // tracking run loop, unlike SwiftUI preference callbacks which are never delivered
+            // while the menu is open.
+            self.notifyHeightChange(selectedDateKey: nearest, model: model)
         }
     }
 
+    private func notifyHeightChange(selectedDateKey: String?, model: Model) {
+        guard let onHeightChange = self.onHeightChange else { return }
+        let rows = selectedDateKey.map { self.breakdownRows(key: $0, model: model) } ?? []
+        onHeightChange(Self.totalCardHeight(rows: rows, hasTotal: self.totalCostUSD != nil))
+    }
+
     private func nearestDateKey(to date: Date, model: Model) -> String? {
         guard !model.dateKeys.isEmpty else { return nil }
         var best: (key: String, distance: TimeInterval)?
@@ -286,41 +486,154 @@ struct CostHistoryChartMenuView: View {
         return best?.key
     }
 
-    private func detailLines(model: Model) -> (primary: String, secondary: String?) {
-        guard let key = self.selectedDateKey,
+    private func detailContent(selectedDateKey: String?, model: Model) -> DetailContent {
+        guard let key = selectedDateKey,
               let point = model.pointsByDateKey[key],
               let date = Self.dateFromDayKey(key)
         else {
-            return ("Hover a bar for details", nil)
+            return DetailContent(primary: L("Hover a bar for details"), rows: [])
         }
 
         let dayLabel = date.formatted(.dateTime.month(.abbreviated).day())
-        let cost = UsageFormatter.usdString(point.costUSD)
+        let cost = self.costString(point.costUSD)
+        var parts = [cost]
         if let tokens = point.totalTokens {
-            let primary = "\(dayLabel): \(cost) · \(UsageFormatter.tokenCountString(tokens)) tokens"
-            let secondary = self.topModelsText(key: key, model: model)
-            return (primary, secondary)
+            parts.append("\(UsageFormatter.tokenCountString(tokens)) tokens")
         }
-        let primary = "\(dayLabel): \(cost)"
-        let secondary = self.topModelsText(key: key, model: model)
-        return (primary, secondary)
-    }
-
-    private func topModelsText(key: String, model: Model) -> String? {
-        guard let entry = model.entriesByDateKey[key] else { return nil }
-        guard let breakdown = entry.modelBreakdowns, !breakdown.isEmpty else { return nil }
-        let parts = breakdown
-            .compactMap { item -> (name: String, costUSD: Double)? in
-                guard let costUSD = item.costUSD, costUSD > 0 else { return nil }
-                return (UsageFormatter.modelDisplayName(item.modelName), costUSD)
+        if let requests = point.requestCount {
+            parts.append("\(UsageFormatter.tokenCountString(requests)) requests")
+        }
+        let primary = "\(dayLabel): \(parts.joined(separator: " · "))"
+        return DetailContent(primary: primary, rows: self.breakdownRows(key: key, model: model))
+    }
+
+    private func breakdownRows(key: String, model: Model) -> [DetailRow] {
+        guard let entry = model.entriesByDateKey[key] else { return [] }
+        guard let breakdown = entry.modelBreakdowns, !breakdown.isEmpty else { return [] }
+
+        return Self.orderedBreakdownItems(breakdown)
+            .enumerated()
+            .map { index, item in
+                DetailRow(
+                    id: "\(item.modelName)-\(index)",
+                    title: UsageFormatter.modelDisplayName(item.modelName),
+                    subtitle: self.modelBreakdownTotalSubtitle(item),
+                    modeSubtitle: self.modelBreakdownModeSubtitle(item),
+                    accentColor: model.barColor.opacity(Self.breakdownAccentOpacity(for: index)))
             }
-            .sorted { lhs, rhs in
-                if lhs.costUSD == rhs.costUSD { return lhs.name < rhs.name }
-                return lhs.costUSD > rhs.costUSD
+    }
+
+    static func orderedBreakdownItems(
+        _ breakdown: [CostUsageDailyReport.ModelBreakdown]) -> [CostUsageDailyReport.ModelBreakdown]
+    {
+        breakdown.sorted { lhs, rhs in
+            let lCost = lhs.costUSD ?? -1
+            let rCost = rhs.costUSD ?? -1
+            if lCost != rCost { return lCost > rCost }
+
+            let lTokens = lhs.totalTokens ?? -1
+            let rTokens = rhs.totalTokens ?? -1
+            if lTokens != rTokens { return lTokens > rTokens }
+
+            return lhs.modelName > rhs.modelName
+        }
+    }
+
+    static func detailViewportRowCount(itemCount: Int) -> Int {
+        min(max(itemCount, 0), self.maxVisibleDetailLines)
+    }
+
+    static func detailRowsNeedScrolling(itemCount: Int) -> Bool {
+        itemCount > self.maxVisibleDetailLines
+    }
+
+    private func modelBreakdownTotalSubtitle(_ item: CostUsageDailyReport.ModelBreakdown) -> String? {
+        UsageFormatter.modelCostDetail(
+            item.modelName,
+            costUSD: item.costUSD,
+            totalTokens: item.totalTokens,
+            currencyCode: self.currencyCode)
+    }
+
+    private func modelBreakdownModeSubtitle(_ item: CostUsageDailyReport.ModelBreakdown) -> String? {
+        var parts: [String] = []
+        if let standardCost = item.standardCostUSD {
+            var standardPart = "Std \(self.costString(standardCost))"
+            if let standardTokens = item.standardTokens {
+                standardPart += " · \(UsageFormatter.tokenCountString(standardTokens))"
+            }
+            parts.append(standardPart)
+        }
+        if let priorityCost = item.priorityCostUSD {
+            var priorityPart = "Fast \(self.costString(priorityCost))"
+            if let priorityTokens = item.priorityTokens {
+                priorityPart += " · \(UsageFormatter.tokenCountString(priorityTokens))"
             }
-            .prefix(3)
-            .map { "\($0.name) \(UsageFormatter.usdString($0.costUSD))" }
+            parts.append(priorityPart)
+        }
         guard !parts.isEmpty else { return nil }
-        return "Top: \(parts.joined(separator: " · "))"
+        return parts.joined(separator: " / ")
+    }
+
+    private func costString(_ value: Double) -> String {
+        UsageFormatter.currencyString(value, currencyCode: self.currencyCode)
+    }
+
+    private static func breakdownAccentOpacity(for index: Int) -> Double {
+        let opacity = 0.75 - (Double(index) * 0.12)
+        return max(0.3, opacity)
+    }
+}
+
+extension CostHistoryChartMenuView {
+    static func _defaultSelectedDateKeyForTesting(provider: UsageProvider, daily: [DailyEntry]) -> String? {
+        self.defaultSelectedDateKey(model: self.makeModel(provider: provider, daily: daily))
+    }
+
+    static func _axisDatesForTesting(provider: UsageProvider, daily: [DailyEntry]) -> [Date] {
+        self.makeModel(provider: provider, daily: daily).axisDates
+    }
+
+    static func _axisLabelPlacementForTesting(
+        provider: UsageProvider,
+        daily: [DailyEntry]) -> AxisLabelPlacement
+    {
+        self.axisLabelPlacement(for: self.makeModel(provider: provider, daily: daily).axisDates)
+    }
+
+    static func _detailViewportHeightForTesting(modeSubtitlePresence: [Bool]) -> CGFloat {
+        let rows = modeSubtitlePresence.enumerated().map { index, hasModeSubtitle in
+            DetailRow(
+                id: "\(index)",
+                title: "Row \(index)",
+                subtitle: "Subtitle",
+                modeSubtitle: hasModeSubtitle ? "Mode" : nil,
+                accentColor: .blue)
+        }
+        return self.detailRowsViewportHeight(rows: rows)
+    }
+
+    static func _detailBlockHeightForTesting(modeSubtitlePresence: [Bool]) -> CGFloat {
+        let rows = modeSubtitlePresence.enumerated().map { index, hasModeSubtitle in
+            DetailRow(
+                id: "\(index)",
+                title: "Row \(index)",
+                subtitle: "Subtitle",
+                modeSubtitle: hasModeSubtitle ? "Mode" : nil,
+                accentColor: .blue)
+        }
+        return self.detailBlockHeight(rows: rows)
+    }
+
+    static func _totalCardHeightForTesting(modeSubtitlePresence: [Bool], hasTotal: Bool) -> CGFloat {
+        let rows = modeSubtitlePresence.enumerated().map { index, hasModeSubtitle in
+            DetailRow(
+                id: "\(index)",
+                title: "Row \(index)",
+                subtitle: "Subtitle",
+                modeSubtitle: hasModeSubtitle ? "Mode" : nil,
+                accentColor: .blue)
+        }
+        return self.totalCardHeight(rows: rows, hasTotal: hasTotal)
     }
 }
diff --git a/Sources/CodexBar/CreditsHistoryChartMenuView.swift b/Sources/CodexBar/CreditsHistoryChartMenuView.swift
index 9c5ca0b50a..c7fb3508ad 100644
--- a/Sources/CodexBar/CreditsHistoryChartMenuView.swift
+++ b/Sources/CodexBar/CreditsHistoryChartMenuView.swift
@@ -29,23 +29,24 @@ struct CreditsHistoryChartMenuView: View {
         let model = Self.makeModel(from: self.breakdown)
         VStack(alignment: .leading, spacing: 10) {
             if model.points.isEmpty {
-                Text("No credits history data.")
+                Text(L("No credits history data."))
                     .font(.footnote)
                     .foregroundStyle(.secondary)
+                    .accessibilityLabel(L("No credits history data available."))
             } else {
                 Chart {
                     ForEach(model.points) { point in
                         BarMark(
-                            x: .value("Day", point.date, unit: .day),
-                            y: .value("Credits used", point.creditsUsed))
+                            x: .value(L("Day"), point.date, unit: .day),
+                            y: .value(L("Credits used"), point.creditsUsed))
                             .foregroundStyle(Self.barColor)
                     }
                     if let peak = Self.peakPoint(model: model) {
                         let capStart = max(peak.creditsUsed - Self.capHeight(maxValue: model.maxCreditsUsed), 0)
                         BarMark(
-                            x: .value("Day", peak.date, unit: .day),
-                            yStart: .value("Cap start", capStart),
-                            yEnd: .value("Cap end", peak.creditsUsed))
+                            x: .value(L("Day"), peak.date, unit: .day),
+                            yStart: .value(L("Cap start"), capStart),
+                            yEnd: .value(L("Cap end"), peak.creditsUsed))
                             .foregroundStyle(Color(nsColor: .systemYellow))
                     }
                 }
@@ -61,6 +62,11 @@ struct CreditsHistoryChartMenuView: View {
                 }
                 .chartLegend(.hidden)
                 .frame(height: 130)
+                .accessibilityLabel(L("Credits history chart"))
+                .accessibilityValue(
+                    model.points.isEmpty
+                        ? L("No data")
+                        : String(format: L("%d days of credits data"), model.points.count))
                 .chartOverlay { proxy in
                     GeometryReader { geo in
                         ZStack(alignment: .topLeading) {
@@ -98,7 +104,9 @@ struct CreditsHistoryChartMenuView: View {
                 }
 
                 if let total = model.totalCreditsUsed {
-                    Text("Total (30d): \(total.formatted(.number.precision(.fractionLength(0...2)))) credits")
+                    Text(String(
+                        format: L("Total (30d): %@ credits"),
+                        total.formatted(.number.precision(.fractionLength(0...2)))))
                         .font(.caption)
                         .foregroundStyle(.secondary)
                 }
@@ -219,14 +227,6 @@ struct CreditsHistoryChartMenuView: View {
         let date = model.dayDates[index].date
         guard let x = proxy.position(forX: date) else { return nil }
 
-        func xForIndex(_ idx: Int) -> CGFloat? {
-            guard idx >= 0, idx < model.dayDates.count else { return nil }
-            return proxy.position(forX: model.dayDates[idx].date)
-        }
-
-        let xPrev = xForIndex(index - 1)
-        let xNext = xForIndex(index + 1)
-
         if model.dayDates.count <= 1 {
             return CGRect(
                 x: plotFrame.origin.x,
@@ -235,24 +235,14 @@ struct CreditsHistoryChartMenuView: View {
                 height: plotFrame.height)
         }
 
-        let leftInPlot: CGFloat = if let xPrev {
-            (xPrev + x) / 2
-        } else if let xNext {
-            x - (xNext - x) / 2
-        } else {
-            x - 8
-        }
-
-        let rightInPlot: CGFloat = if let xNext {
-            (xNext + x) / 2
-        } else if let xPrev {
-            x + (x - xPrev) / 2
-        } else {
-            x + 8
-        }
+        // Use the calendar day slot width (always 1 day on the time axis) so the band is the
+        // same size for every bar regardless of gaps in the data.
+        let nextDayX = proxy.position(forX: ChartBarHoverSelection.nextCalendarDay(after: date)) ?? (x + 20)
+        let slotWidth = abs(nextDayX - x)
+        let barHalfWidth = slotWidth * 0.25 + 2
 
-        let left = plotFrame.origin.x + min(leftInPlot, rightInPlot)
-        let right = plotFrame.origin.x + max(leftInPlot, rightInPlot)
+        let left = plotFrame.origin.x + x - barHalfWidth
+        let right = plotFrame.origin.x + x + barHalfWidth
         return CGRect(x: left, y: plotFrame.origin.y, width: right - left, height: plotFrame.height)
     }
 
@@ -275,6 +265,24 @@ struct CreditsHistoryChartMenuView: View {
         guard let date: Date = proxy.value(atX: xInPlot) else { return }
         guard let nearest = self.nearestDayKey(to: date, model: model) else { return }
 
+        // Stay on the last selected bar when cursor is in the gap between bars; only switch
+        // selection when the cursor is over the bar's own visual body.
+        // Skip this gate for single-day charts: no gap exists, and selectionBandRect
+        // already covers the full plot width in that case.
+        if model.selectableDayDates.count > 1,
+           let nearestEntry = model.selectableDayDates.first(where: { $0.dayKey == nearest }),
+           let barX = proxy.position(forX: nearestEntry.date)
+        {
+            let nextDayX = proxy.position(forX: ChartBarHoverSelection.nextCalendarDay(after: nearestEntry.date)) ??
+                (barX + 20)
+            let slotWidth = abs(nextDayX - barX)
+            guard ChartBarHoverSelection.accepts(
+                distanceFromBarCenter: abs(location.x - (plotFrame.origin.x + barX)),
+                barHalfWidth: slotWidth * 0.25 + 2,
+                selectableCount: model.selectableDayDates.count)
+            else { return }
+        }
+
         if self.selectedDayKey != nearest {
             self.selectedDayKey = nearest
         }
@@ -299,17 +307,17 @@ struct CreditsHistoryChartMenuView: View {
               let day = model.breakdownByDayKey[key],
               let date = Self.dateFromDayKey(key)
         else {
-            return ("Hover a bar for details", nil)
+            return (L("Hover a bar for details"), nil)
         }
 
         let dayLabel = date.formatted(.dateTime.month(.abbreviated).day())
         let total = day.totalCreditsUsed.formatted(.number.precision(.fractionLength(0...2)))
         if day.services.isEmpty {
-            return ("\(dayLabel): \(total) credits", nil)
+            return (String(format: L("%@: %@ credits"), dayLabel, total), nil)
         }
         if day.services.count <= 1, let first = day.services.first {
             let used = first.creditsUsed.formatted(.number.precision(.fractionLength(0...2)))
-            return ("\(dayLabel): \(used) credits", first.service)
+            return (String(format: L("%@: %@ credits"), dayLabel, used), first.service)
         }
 
         let services = day.services
@@ -321,6 +329,6 @@ struct CreditsHistoryChartMenuView: View {
             .map { "\($0.service) \($0.creditsUsed.formatted(.number.precision(.fractionLength(0...2))))" }
             .joined(separator: " · ")
 
-        return ("\(dayLabel): \(total) credits", services)
+        return (String(format: L("%@: %@ credits"), dayLabel, total), services)
     }
 }
diff --git a/Sources/CodexBar/CursorLoginRunner.swift b/Sources/CodexBar/CursorLoginRunner.swift
index 880722539c..5dc39d9ed0 100644
--- a/Sources/CodexBar/CursorLoginRunner.swift
+++ b/Sources/CodexBar/CursorLoginRunner.swift
@@ -1,21 +1,19 @@
 import AppKit
 import CodexBarCore
 import Foundation
-import WebKit
 
-/// Handles Cursor login flow using a WebKit-based browser window.
-/// Captures session cookies after successful authentication.
+/// Opens Cursor in the user's browser and waits until the normal browser-cookie importer can read a session.
 @MainActor
-final class CursorLoginRunner: NSObject {
-    enum Phase: Sendable {
+final class CursorLoginRunner {
+    enum Phase {
         case loading
         case waitingLogin
         case success
         case failed(String)
     }
 
-    struct Result: Sendable {
-        enum Outcome: Sendable {
+    struct Result {
+        enum Outcome {
             case success
             case cancelled
             case failed(String)
@@ -25,198 +23,95 @@ final class CursorLoginRunner: NSObject {
         let email: String?
     }
 
-    private let browserDetection: BrowserDetection
-    private var webView: WKWebView?
-    private var window: NSWindow?
-    private var continuation: CheckedContinuation<Result, Never>?
-    private var phaseCallback: ((Phase) -> Void)?
-    private var hasCompletedLogin = false
-    private let logger = CodexBarLog.logger(LogCategories.cursorLogin)
+    typealias SnapshotLoader = @Sendable () async throws -> CursorStatusSnapshot
+    typealias Sleeper = @Sendable (UInt64) async throws -> Void
+    typealias SessionCacheResetter = @Sendable () async -> Void
 
-    private static let dashboardURL = URL(string: "https://cursor.com/dashboard")!
-    private static let loginURLPattern = "authenticator.cursor.sh"
+    private let loadSnapshot: SnapshotLoader
+    private let openURL: @MainActor (URL) -> Bool
+    private let sleeper: Sleeper
+    private let resetSessionCache: SessionCacheResetter
+    private let timeout: TimeInterval
+    private let pollInterval: TimeInterval
+    private let logger = CodexBarLog.logger(LogCategories.cursorLogin)
 
-    init(browserDetection: BrowserDetection) {
-        self.browserDetection = browserDetection
-        super.init()
+    static let authURL = URL(string: "https://authenticator.cursor.sh/")!
+
+    init(
+        browserDetection: BrowserDetection,
+        timeout: TimeInterval = 120,
+        pollInterval: TimeInterval = 2,
+        openURL: @escaping @MainActor (URL) -> Bool = { NSWorkspace.shared.open($0) },
+        loadSnapshot: SnapshotLoader? = nil,
+        sleeper: @escaping Sleeper = { try await Task.sleep(nanoseconds: $0) },
+        resetSessionCache: @escaping SessionCacheResetter = {
+            CookieHeaderCache.clear(provider: .cursor)
+            CursorSessionStore.shared.clearCookies()
+        })
+    {
+        self.timeout = timeout
+        self.pollInterval = pollInterval
+        self.openURL = openURL
+        self.sleeper = sleeper
+        self.resetSessionCache = resetSessionCache
+        self.loadSnapshot = loadSnapshot ?? {
+            let probe = CursorStatusProbe(browserDetection: browserDetection)
+            return try await probe.fetch(
+                allowCachedSessions: false,
+                allowAppAuthFallback: false)
+        }
     }
 
-    /// Runs the Cursor login flow in a browser window.
-    /// Returns the result after the user completes login or cancels.
-    func run(onPhaseChange: @escaping @Sendable (Phase) -> Void) async -> Result {
-        // Keep this instance alive during the flow.
-        WebKitTeardown.retain(self)
-        self.phaseCallback = onPhaseChange
+    func run(onPhaseChange: @escaping @MainActor (Phase) -> Void) async -> Result {
         onPhaseChange(.loading)
         self.logger.info("Cursor login started")
+        await self.resetSessionCache()
 
-        return await withCheckedContinuation { continuation in
-            self.continuation = continuation
-            self.setupWindow()
+        guard self.openURL(Self.authURL) else {
+            let message = L("Could not open Cursor login in your browser.")
+            onPhaseChange(.failed(message))
+            self.logger.error("Cursor login browser launch failed")
+            return Result(outcome: .failed(message), email: nil)
         }
-    }
-
-    private func setupWindow() {
-        // Use a non-persistent store for the login flow; cookies are persisted explicitly.
-        let config = WKWebViewConfiguration()
-        config.websiteDataStore = .nonPersistent()
-
-        let webView = WKWebView(frame: NSRect(x: 0, y: 0, width: 480, height: 640), configuration: config)
-        webView.navigationDelegate = self
-        self.webView = webView
 
-        // Create window
-        let window = NSWindow(
-            contentRect: NSRect(x: 0, y: 0, width: 480, height: 640),
-            styleMask: [.titled, .closable, .resizable],
-            backing: .buffered,
-            defer: false)
-        window.isReleasedWhenClosed = false
-        window.title = "Cursor Login"
-        window.contentView = webView
-        window.center()
-        window.delegate = self
-        window.makeKeyAndOrderFront(nil)
-        self.window = window
-        self.logger.info("Cursor login window opened")
-
-        // Navigate to dashboard (will redirect to login if not authenticated)
-        let request = URLRequest(url: Self.dashboardURL)
-        webView.load(request)
-    }
-
-    private func complete(with result: Result) {
-        guard let continuation = self.continuation else { return }
-        self.continuation = nil
-        self.logger.info("Cursor login completed", metadata: ["outcome": "\(result.outcome)"])
-        self.scheduleCleanup()
-        continuation.resume(returning: result)
-    }
-
-    private func scheduleCleanup() {
-        self.logger.info("Cursor login window closing")
-        WebKitTeardown.scheduleCleanup(owner: self, window: self.window, webView: self.webView)
-    }
+        onPhaseChange(.waitingLogin)
+        let deadline = Date().addingTimeInterval(self.timeout)
+        var lastError: Error?
 
-    private func captureSessionCookies() async {
-        guard let webView = self.webView else { return }
-
-        let dataStore = webView.configuration.websiteDataStore
-        let cookies = await dataStore.httpCookieStore.allCookies()
-
-        // Filter for cursor.com cookies
-        let cursorCookies = cookies.filter { cookie in
-            cookie.domain.contains("cursor.com") || cookie.domain.contains("cursor.sh")
-        }
-
-        guard !cursorCookies.isEmpty else {
-            self.phaseCallback?(.failed("No session cookies found"))
-            self.logger.warning("Cursor login failed: no session cookies found")
-            self.complete(with: Result(outcome: .failed("No session cookies found"), email: nil))
-            return
-        }
-
-        // Save cookies to the session store
-        await CursorSessionStore.shared.setCookies(cursorCookies)
-        self.logger.info("Cursor session cookies captured", metadata: ["count": "\(cursorCookies.count)"])
-
-        // Try to get user email
-        let email = await self.fetchUserEmail()
-
-        self.hasCompletedLogin = true
-        self.phaseCallback?(.success)
-        self.complete(with: Result(outcome: .success, email: email))
-    }
-
-    private func fetchUserEmail() async -> String? {
-        do {
-            let probe = CursorStatusProbe(browserDetection: self.browserDetection)
-            let snapshot = try await probe.fetch()
-            return snapshot.accountEmail
-        } catch {
-            return nil
-        }
-    }
-}
-
-// MARK: - WKNavigationDelegate
-
-extension CursorLoginRunner: WKNavigationDelegate {
-    nonisolated func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {
-        Task { @MainActor in
-            guard let url = webView.url else { return }
-
-            let urlString = url.absoluteString
-
-            // Check if on login page
-            if urlString.contains(Self.loginURLPattern) {
-                self.phaseCallback?(.waitingLogin)
-                return
-            }
-
-            // Check if on dashboard (login successful)
-            if urlString.contains("cursor.com/dashboard"), !self.hasCompletedLogin {
-                await self.captureSessionCookies()
+        repeat {
+            if Task.isCancelled {
+                self.logger.info("Cursor login cancelled")
+                return Result(outcome: .cancelled, email: nil)
             }
-        }
-    }
-
-    nonisolated func webView(
-        _ webView: WKWebView,
-        didReceiveServerRedirectForProvisionalNavigation navigation: WKNavigation!)
-    {
-        Task { @MainActor in
-            guard let url = webView.url else { return }
-            let urlString = url.absoluteString
 
-            // Detect redirect to dashboard after login
-            if urlString.contains("cursor.com/dashboard"), !self.hasCompletedLogin {
-                // Wait a moment for cookies to be set, then capture
-                try? await Task.sleep(nanoseconds: 500_000_000)
-                await self.captureSessionCookies()
+            do {
+                let snapshot = try await self.loadSnapshot()
+                onPhaseChange(.success)
+                self.logger.info("Cursor login completed", metadata: ["outcome": "success"])
+                return Result(outcome: .success, email: snapshot.accountEmail)
+            } catch {
+                lastError = error
             }
-        }
-    }
 
-    nonisolated func webView(
-        _ webView: WKWebView,
-        didFail navigation: WKNavigation!,
-        withError error: Error)
-    {
-        Task { @MainActor in
-            self.phaseCallback?(.failed(error.localizedDescription))
-            self.logger.error("Cursor login navigation failed", metadata: ["error": error.localizedDescription])
-            self.complete(with: Result(outcome: .failed(error.localizedDescription), email: nil))
-        }
-    }
+            guard Date() < deadline else { break }
+            let delay = UInt64(max(0.1, self.pollInterval) * 1_000_000_000)
+            try? await self.sleeper(delay)
+        } while true
 
-    nonisolated func webView(
-        _ webView: WKWebView,
-        didFailProvisionalNavigation navigation: WKNavigation!,
-        withError error: Error)
-    {
-        Task { @MainActor in
-            // Ignore cancelled navigations (common during redirects)
-            let nsError = error as NSError
-            if nsError.domain == NSURLErrorDomain, nsError.code == NSURLErrorCancelled {
-                return
-            }
-            self.phaseCallback?(.failed(error.localizedDescription))
-            self.logger.error("Cursor login navigation failed", metadata: ["error": error.localizedDescription])
-            self.complete(with: Result(outcome: .failed(error.localizedDescription), email: nil))
-        }
+        let message = Self.timeoutMessage(lastError: lastError)
+        onPhaseChange(.failed(message))
+        self.logger.warning("Cursor login timed out", metadata: ["error": message])
+        return Result(outcome: .failed(message), email: nil)
     }
-}
 
-// MARK: - NSWindowDelegate
-
-extension CursorLoginRunner: NSWindowDelegate {
-    nonisolated func windowWillClose(_ notification: Notification) {
-        Task { @MainActor in
-            if !self.hasCompletedLogin {
-                self.logger.info("Cursor login cancelled")
-                self.complete(with: Result(outcome: .cancelled, email: nil))
-            }
+    private static func timeoutMessage(lastError: Error?) -> String {
+        let hint = L("Sign in to cursor.com in your browser, then refresh Cursor in CodexBar.")
+        guard let lastError else {
+            return String(format: L("Timed out waiting for Cursor login. %@"), hint)
         }
+        return String(
+            format: L("Timed out waiting for Cursor login. %@ Last error: %@"),
+            hint,
+            lastError.localizedDescription)
     }
 }
diff --git a/Sources/CodexBar/Date+RelativeDescription.swift b/Sources/CodexBar/Date+RelativeDescription.swift
index 7356f96710..4341379938 100644
--- a/Sources/CodexBar/Date+RelativeDescription.swift
+++ b/Sources/CodexBar/Date+RelativeDescription.swift
@@ -2,11 +2,12 @@ import Foundation
 
 enum RelativeTimeFormatters {
     @MainActor
-    static let full: RelativeDateTimeFormatter = {
+    static func full(locale: Locale) -> RelativeDateTimeFormatter {
         let formatter = RelativeDateTimeFormatter()
+        formatter.locale = locale
         formatter.unitsStyle = .full
         return formatter
-    }()
+    }
 }
 
 extension Date {
@@ -14,8 +15,9 @@ extension Date {
     func relativeDescription(now: Date = .now) -> String {
         let seconds = abs(now.timeIntervalSince(self))
         if seconds < 15 {
-            return "just now"
+            return L("just now")
         }
-        return RelativeTimeFormatters.full.localizedString(for: self, relativeTo: now)
+        let locale = codexBarLocalizedLocale()
+        return RelativeTimeFormatters.full(locale: locale).localizedString(for: self, relativeTo: now)
     }
 }
diff --git a/Sources/CodexBar/HistoricalUsagePace.swift b/Sources/CodexBar/HistoricalUsagePace.swift
index b018a18315..f43ebceab8 100644
--- a/Sources/CodexBar/HistoricalUsagePace.swift
+++ b/Sources/CodexBar/HistoricalUsagePace.swift
@@ -1,16 +1,16 @@
 import CodexBarCore
 import Foundation
 
-enum HistoricalUsageWindowKind: String, Codable, Sendable {
+enum HistoricalUsageWindowKind: String, Codable {
     case secondary
 }
 
-enum HistoricalUsageRecordSource: String, Codable, Sendable {
+enum HistoricalUsageRecordSource: String, Codable {
     case live
     case backfill
 }
 
-struct HistoricalUsageRecord: Codable, Sendable {
+struct HistoricalUsageRecord: Codable {
     let v: Int
     let provider: UsageProvider
     let windowKind: HistoricalUsageWindowKind
@@ -57,13 +57,13 @@ struct HistoricalUsageRecord: Codable, Sendable {
     }
 }
 
-struct HistoricalWeekProfile: Sendable {
+struct HistoricalWeekProfile {
     let resetsAt: Date
     let windowMinutes: Int
     let curve: [Double]
 }
 
-struct CodexHistoricalDataset: Sendable {
+struct CodexHistoricalDataset {
     static let gridPointCount = 169
     let weeks: [HistoricalWeekProfile]
 }
@@ -80,7 +80,7 @@ actor HistoricalUsageHistoryStore {
     private static let backfillCalibrationMinimumCredits = 0.001
     private static let backfillSampleFractions: [Double] = (0...14).map { Double($0) / 14.0 }
     private static let coverageTolerance: TimeInterval = 16 * 60 * 60
-    private static let resetBucketSeconds: TimeInterval = 60
+    private static let resetBucketSeconds: TimeInterval = 5 * 60
 
     private let fileURL: URL
     private var records: [HistoricalUsageRecord] = []
@@ -95,6 +95,20 @@ actor HistoricalUsageHistoryStore {
         return self.buildDataset(accountKey: accountKey)
     }
 
+    func loadCodexDataset(
+        canonicalAccountKey: String?,
+        canonicalEmailHashKey: String?,
+        legacyEmailHash: String?,
+        hasAdjacentMultiAccountVeto: Bool) -> CodexHistoricalDataset?
+    {
+        self.ensureLoaded()
+        return self.buildDataset(
+            canonicalAccountKey: canonicalAccountKey,
+            canonicalEmailHashKey: canonicalEmailHashKey,
+            legacyEmailHash: legacyEmailHash,
+            hasAdjacentMultiAccountVeto: hasAdjacentMultiAccountVeto)
+    }
+
     func recordCodexWeekly(
         window: RateWindow,
         sampledAt: Date = .init(),
@@ -155,7 +169,10 @@ actor HistoricalUsageHistoryStore {
 
         let windowStart = resetsAt.addingTimeInterval(-duration)
         let calibrationEnd = Self.clampDate(now, lower: windowStart, upper: resetsAt)
-        let dayUsages = Self.parseDayUsages(from: breakdown, asOf: calibrationEnd)
+        let dayUsages = Self.parseDayUsages(
+            from: breakdown,
+            asOf: calibrationEnd,
+            fillingFrom: windowStart)
         guard !dayUsages.isEmpty else { return existingDataset }
         guard let coverageStart = dayUsages.first?.start, let coverageEnd = dayUsages.last?.end else {
             return existingDataset
@@ -346,21 +363,54 @@ actor HistoricalUsageHistoryStore {
     }
 
     private func buildDataset(accountKey: String?) -> CodexHistoricalDataset? {
+        let scoped = self.records.filter { record in
+            guard Self.isCodexSecondaryRecord(record) else { return false }
+            if let accountKey {
+                return record.accountKey == accountKey
+            }
+            return record.accountKey == nil
+        }
+        return self.buildDataset(from: scoped)
+    }
+
+    private func buildDataset(
+        canonicalAccountKey: String?,
+        canonicalEmailHashKey: String?,
+        legacyEmailHash: String?,
+        hasAdjacentMultiAccountVeto: Bool) -> CodexHistoricalDataset?
+    {
+        guard let canonicalAccountKey else {
+            return self.buildDataset(accountKey: nil)
+        }
+
+        let shouldIncludeUnscoped = CodexHistoryOwnership.hasStrictSingleAccountContinuity(
+            scopedRawKeys: Self.scopedRawKeysRelevantToCodexUnscopedHistory(self.records),
+            targetCanonicalKey: canonicalAccountKey,
+            canonicalEmailHashKey: canonicalEmailHashKey,
+            legacyEmailHash: legacyEmailHash,
+            hasAdjacentMultiAccountVeto: hasAdjacentMultiAccountVeto)
+
+        let scoped = self.records.filter { record in
+            guard Self.isCodexSecondaryRecord(record) else { return false }
+            guard let rawKey = record.accountKey else {
+                return shouldIncludeUnscoped
+            }
+
+            let owner = CodexHistoryOwnership.classifyPersistedKey(rawKey, legacyEmailHash: legacyEmailHash)
+            return CodexHistoryOwnership.belongsToTargetContinuity(
+                owner,
+                targetCanonicalKey: canonicalAccountKey,
+                canonicalEmailHashKey: canonicalEmailHashKey)
+        }
+        return self.buildDataset(from: scoped)
+    }
+
+    private func buildDataset(from scoped: [HistoricalUsageRecord]) -> CodexHistoricalDataset? {
         struct WeekKey: Hashable {
             let resetsAt: Date
             let windowMinutes: Int
         }
 
-        let scoped = self.records
-            .filter { record in
-                guard record.provider == .codex, record.windowKind == .secondary, record.windowMinutes > 0 else {
-                    return false
-                }
-                if let accountKey {
-                    return record.accountKey == accountKey
-                }
-                return record.accountKey == nil
-            }
         if scoped.isEmpty { return nil }
 
         let grouped = Dictionary(grouping: scoped) {
@@ -398,6 +448,10 @@ actor HistoricalUsageHistoryStore {
         return CodexHistoricalDataset(weeks: weeks)
     }
 
+    private nonisolated static func isCodexSecondaryRecord(_ record: HistoricalUsageRecord) -> Bool {
+        record.provider == .codex && record.windowKind == .secondary && record.windowMinutes > 0
+    }
+
     private static func reconstructWeekCurve(
         samples: [HistoricalUsageRecord],
         windowStart: Date,
@@ -501,13 +555,51 @@ actor HistoricalUsageHistoryStore {
         return hasStartCoverage && hasEndCoverage
     }
 
+    private nonisolated static func scopedRawKeysRelevantToCodexUnscopedHistory(
+        _ records: [HistoricalUsageRecord]) -> [String]
+    {
+        let unscopedRecords = records.filter { record in
+            Self.isCodexSecondaryRecord(record) && record.accountKey == nil
+        }
+        guard let continuityWindow = self.historicalContinuityWindow(for: unscopedRecords) else {
+            return []
+        }
+
+        return records.compactMap { record in
+            guard Self.isCodexSecondaryRecord(record),
+                  let accountKey = record.accountKey,
+                  continuityWindow.contains(record.sampledAt)
+            else {
+                return nil
+            }
+            return accountKey
+        }
+    }
+
+    private nonisolated static func historicalContinuityWindow(
+        for records: [HistoricalUsageRecord]) -> ClosedRange<Date>?
+    {
+        let sampledDates = records.map(\.sampledAt)
+        guard let lowerBound = sampledDates.min(),
+              let upperBound = sampledDates.max()
+        else {
+            return nil
+        }
+        let expansion = TimeInterval(records.map(\.windowMinutes).max() ?? 0) * 60
+        return lowerBound.addingTimeInterval(-expansion)...upperBound.addingTimeInterval(expansion)
+    }
+
     private struct DayUsage {
         let start: Date
         let end: Date
         let creditsUsed: Double
     }
 
-    private static func parseDayUsages(from breakdown: [OpenAIDashboardDailyBreakdown], asOf: Date) -> [DayUsage] {
+    private static func parseDayUsages(
+        from breakdown: [OpenAIDashboardDailyBreakdown],
+        asOf: Date,
+        fillingFrom expectedCoverageStart: Date? = nil) -> [DayUsage]
+    {
         var creditsByStart: [Date: Double] = [:]
         creditsByStart.reserveCapacity(breakdown.count)
 
@@ -531,22 +623,34 @@ actor HistoricalUsageHistoryStore {
         }
 
         dayUsages.sort { lhs, rhs in lhs.start < rhs.start }
-        return Self.fillMissingZeroUsageDays(in: dayUsages, through: asOf)
+        return Self.fillMissingZeroUsageDays(
+            in: dayUsages,
+            through: asOf,
+            fillingFrom: expectedCoverageStart)
     }
 
-    private static func fillMissingZeroUsageDays(in dayUsages: [DayUsage], through asOf: Date) -> [DayUsage] {
+    private static func fillMissingZeroUsageDays(
+        in dayUsages: [DayUsage],
+        through asOf: Date,
+        fillingFrom expectedCoverageStart: Date? = nil) -> [DayUsage]
+    {
         guard let firstStart = dayUsages.first?.start else { return [] }
 
         let calendar = Self.gregorianCalendar()
+        let fillStart: Date = if let expectedCoverageStart {
+            min(firstStart, calendar.startOfDay(for: expectedCoverageStart))
+        } else {
+            firstStart
+        }
         let finalDayStart = calendar.startOfDay(for: asOf)
-        guard firstStart <= finalDayStart else { return dayUsages }
+        guard fillStart <= finalDayStart else { return dayUsages }
 
         let creditsByStart = Dictionary(uniqueKeysWithValues: dayUsages.map { ($0.start, $0.creditsUsed) })
-        let daySpan = max(0, calendar.dateComponents([.day], from: firstStart, to: finalDayStart).day ?? 0)
+        let daySpan = max(0, calendar.dateComponents([.day], from: fillStart, to: finalDayStart).day ?? 0)
         var filled: [DayUsage] = []
         filled.reserveCapacity(daySpan + 1)
 
-        var cursor = firstStart
+        var cursor = fillStart
         while cursor <= finalDayStart {
             guard let nominalEnd = calendar.date(byAdding: .day, value: 1, to: cursor) else { break }
             let effectiveEnd: Date = if cursor <= asOf, asOf < nominalEnd {
@@ -658,7 +762,7 @@ enum CodexHistoricalPaceEvaluator {
     static let minimumWeeksForRisk = 5
     private static let recencyTauWeeks: Double = 3
     private static let epsilon: Double = 1e-9
-    private static let resetBucketSeconds: TimeInterval = 60
+    private static let resetBucketSeconds: TimeInterval = 5 * 60
 
     static func evaluate(window: RateWindow, now: Date, dataset: CodexHistoricalDataset?) -> UsagePace? {
         guard let dataset else { return nil }
@@ -707,10 +811,11 @@ enum CodexHistoricalPaceEvaluator {
             let weights = weightedWeeks.map(\.weight)
             let historicalMedian = Self.weightedMedian(values: values, weights: weights)
             let linearBaseline = 100 * u
+            // Historical demand can exceed a sustainable quota pace. Never call that excess a reserve.
             expectedCurve[index] = Self.clamp(
                 (lambda * historicalMedian) + ((1 - lambda) * linearBaseline),
                 lower: 0,
-                upper: 100)
+                upper: linearBaseline)
         }
 
         // Expected cumulative usage should be monotone.
@@ -727,17 +832,30 @@ enum CodexHistoricalPaceEvaluator {
         crossingCandidates.reserveCapacity(weightedWeeks.count)
 
         for weighted in weightedWeeks {
-            let week = weighted.week
+            var extendedCurve = weighted.week.curve
+            if let capIndex = extendedCurve.firstIndex(where: { $0 >= 100 - Self.epsilon }),
+               capIndex > 0, capIndex < extendedCurve.count - 1
+            {
+                let gridCount = CodexHistoricalDataset.gridPointCount
+                let uCap = Double(capIndex) / Double(gridCount - 1)
+                let valCap = extendedCurve[capIndex]
+                let slope: Double = valCap / uCap
+                for i in capIndex..<extendedCurve.count {
+                    let u = Double(i) / Double(gridCount - 1)
+                    extendedCurve[i] = slope * u
+                }
+            }
+
             let weight = weighted.weight
-            let weekNow = Self.interpolate(curve: week.curve, at: uNow)
+            let weekNow = Self.interpolate(curve: extendedCurve, at: uNow)
             let shift = actual - weekNow
-            let shiftedEnd = Self.clamp((week.curve.last ?? 0) + shift, lower: 0, upper: 100)
+            let shiftedEnd = (extendedCurve.last ?? 0) + shift
             let runOut = shiftedEnd >= 100 - Self.epsilon
             if runOut {
                 weightedRunOutMass += weight
                 if let crossingU = Self.firstCrossing(
                     after: uNow,
-                    curve: week.curve,
+                    curve: extendedCurve,
                     shift: shift,
                     actualAtNow: actual)
                 {
@@ -751,12 +869,16 @@ enum CodexHistoricalPaceEvaluator {
             (weightedRunOutMass + 0.5) / (totalWeight + 1),
             lower: 0,
             upper: 1)
-        let runOutProbability: Double? = scopedWeeks.count >= Self.minimumWeeksForRisk ? smoothedProbability : nil
+        var runOutProbability: Double? = scopedWeeks.count >= Self.minimumWeeksForRisk ? smoothedProbability : nil
 
         var willLastToReset = smoothedProbability < 0.5
         var etaSeconds: TimeInterval?
 
-        if !willLastToReset {
+        if actual >= 100 {
+            willLastToReset = false
+            etaSeconds = 0
+            runOutProbability = 1
+        } else if !willLastToReset {
             let values = crossingCandidates.map(\.etaSeconds)
             let weights = crossingCandidates.map(\.weight)
             if values.isEmpty {
diff --git a/Sources/CodexBar/IconRemainingResolver.swift b/Sources/CodexBar/IconRemainingResolver.swift
new file mode 100644
index 0000000000..fe62830d16
--- /dev/null
+++ b/Sources/CodexBar/IconRemainingResolver.swift
@@ -0,0 +1,163 @@
+import CodexBarCore
+
+enum IconRemainingResolver {
+    private static let visibleZeroPercent = 0.0001
+    private static let antigravityQuotaSummaryWindowIDPrefix = "antigravity-quota-summary-"
+    private static let antigravityGeminiQuotaBucketIDPrefix = "gemini-"
+    // Antigravity quota summaries currently expose exact 5-hour session and weekly buckets for the compact icon.
+    private static let sessionWindowMinutes = 5 * 60
+    private static let weeklyWindowMinutes = 7 * 24 * 60
+
+    private static func codexProjection(snapshot: UsageSnapshot) -> CodexConsumerProjection {
+        CodexConsumerProjection.make(
+            surface: .menuBar,
+            context: CodexConsumerProjection.Context(
+                snapshot: snapshot,
+                rawUsageError: nil,
+                liveCredits: nil,
+                rawCreditsError: nil,
+                liveDashboard: nil,
+                rawDashboardError: nil,
+                dashboardAttachmentAuthorized: false,
+                dashboardRequiresLogin: false,
+                now: snapshot.updatedAt))
+    }
+
+    private static func codexVisibleWindows(snapshot: UsageSnapshot) -> [RateWindow] {
+        let projection = self.codexProjection(snapshot: snapshot)
+        return projection.visibleRateLanes.compactMap { projection.rateWindow(for: $0) }
+    }
+
+    private static func antigravityQuotaSummaryWindows(
+        snapshot: UsageSnapshot)
+        -> (primary: RateWindow?, secondary: RateWindow?)?
+    {
+        let quotaSummaryWindows = snapshot.extraRateWindows?
+            .filter {
+                $0.id.hasPrefix(Self.antigravityQuotaSummaryWindowIDPrefix)
+            } ?? []
+        guard !quotaSummaryWindows.isEmpty else { return nil }
+
+        let geminiWindows = quotaSummaryWindows.filter(Self.isAntigravityGeminiQuotaSummaryWindow)
+        // The Antigravity menu-bar icon represents Gemini quotas. If any Gemini cadence is present,
+        // keep missing Gemini lanes empty instead of silently borrowing Claude + GPT quota.
+        if !geminiWindows.isEmpty {
+            return self.antigravityQuotaSummaryPair(in: geminiWindows.filter(\.usageKnown))
+                ?? (primary: nil, secondary: nil)
+        }
+        return self.antigravityQuotaSummaryPair(in: quotaSummaryWindows.filter(\.usageKnown))
+    }
+
+    private static func antigravityQuotaSummaryPair(
+        in windows: [NamedRateWindow])
+        -> (primary: RateWindow?, secondary: RateWindow?)?
+    {
+        let session = self.mostConstrainedWindow(in: windows, windowMinutes: Self.sessionWindowMinutes)
+        let weekly = self.mostConstrainedWindow(in: windows, windowMinutes: Self.weeklyWindowMinutes)
+        guard session != nil || weekly != nil else { return nil }
+        return (primary: session, secondary: weekly)
+    }
+
+    private static func isAntigravityGeminiQuotaSummaryWindow(_ window: NamedRateWindow) -> Bool {
+        self.antigravityQuotaSummaryBucketID(for: window)?.hasPrefix(self.antigravityGeminiQuotaBucketIDPrefix) == true
+    }
+
+    private static func antigravityQuotaSummaryBucketID(for window: NamedRateWindow) -> String? {
+        guard window.id.hasPrefix(self.antigravityQuotaSummaryWindowIDPrefix) else { return nil }
+        return String(window.id.dropFirst(self.antigravityQuotaSummaryWindowIDPrefix.count))
+    }
+
+    /// Returns the highest-usage window for an exact Antigravity compact-icon cadence.
+    private static func mostConstrainedWindow(in windows: [NamedRateWindow], windowMinutes: Int) -> RateWindow? {
+        windows
+            .filter { $0.window.windowMinutes == windowMinutes }
+            .max { lhs, rhs in
+                if lhs.window.usedPercent != rhs.window.usedPercent {
+                    return lhs.window.usedPercent < rhs.window.usedPercent
+                }
+                // max(by:) keeps the right-hand element when this returns true; use `>` so the smallest id wins ties.
+                return lhs.id > rhs.id
+            }?
+            .window
+    }
+
+    static func resolvedWindows(
+        snapshot: UsageSnapshot,
+        style: IconStyle,
+        secondaryOverrideWindowID: String? = nil)
+        -> (primary: RateWindow?, secondary: RateWindow?)
+    {
+        if style == .perplexity {
+            let windows = snapshot.orderedPerplexityDisplayWindows()
+            return (
+                primary: windows.first,
+                secondary: windows.dropFirst().first)
+        }
+        if style == .antigravity {
+            // Only current quota-summary buckets define the fixed session/weekly icon lanes.
+            return self.antigravityQuotaSummaryWindows(snapshot: snapshot)
+                ?? (primary: nil, secondary: nil)
+        }
+        if style == .codex {
+            let windows = self.codexVisibleWindows(snapshot: snapshot)
+            return (
+                primary: windows.first,
+                secondary: windows.dropFirst().first)
+        }
+        if style == .copilot,
+           let secondaryOverrideWindowID,
+           let extraWindow = snapshot.extraRateWindows?.first(where: { $0.id == secondaryOverrideWindowID })?.window
+        {
+            return (
+                primary: snapshot.primary,
+                secondary: extraWindow)
+        }
+        return (
+            primary: snapshot.primary,
+            secondary: snapshot.secondary)
+    }
+
+    static func resolvedRemaining(
+        snapshot: UsageSnapshot,
+        style: IconStyle,
+        secondaryOverrideWindowID: String? = nil)
+        -> (primary: Double?, secondary: Double?)
+    {
+        let windows = self.resolvedWindows(
+            snapshot: snapshot,
+            style: style,
+            secondaryOverrideWindowID: secondaryOverrideWindowID)
+        return (
+            primary: windows.primary?.remainingPercent,
+            secondary: windows.secondary?.remainingPercent)
+    }
+
+    static func resolvedPercents(
+        snapshot: UsageSnapshot,
+        style: IconStyle,
+        showUsed: Bool,
+        renderingStyle: IconStyle? = nil,
+        secondaryOverrideWindowID: String? = nil)
+        -> (primary: Double?, secondary: Double?)
+    {
+        let windows = Self.resolvedWindows(
+            snapshot: snapshot,
+            style: style,
+            secondaryOverrideWindowID: secondaryOverrideWindowID)
+        var percents = (
+            primary: showUsed ? windows.primary?.usedPercent : windows.primary?.remainingPercent,
+            secondary: showUsed ? windows.secondary?.usedPercent : windows.secondary?.remainingPercent)
+        // Provider style chooses the usage lanes; rendering style controls renderer-specific layout sentinels.
+        // Merged icons still resolve Warp's lanes, but render as `.combined` and must keep the real percentage.
+        if showUsed, style == .warp, (renderingStyle ?? style) == .warp, let secondary = windows.secondary {
+            if secondary.remainingPercent <= 0 {
+                // Preserve Warp's exhausted/no-bonus layout even though used percent is 100.
+                percents.secondary = 0
+            } else if percents.secondary == 0 {
+                // A zero fill means "lane absent" to IconRenderer; keep an unused bonus lane visible.
+                percents.secondary = self.visibleZeroPercent
+            }
+        }
+        return percents
+    }
+}
diff --git a/Sources/CodexBar/IconRenderer.swift b/Sources/CodexBar/IconRenderer.swift
index 648a3fc5f4..8c64673871 100644
--- a/Sources/CodexBar/IconRenderer.swift
+++ b/Sources/CodexBar/IconRenderer.swift
@@ -10,7 +10,7 @@ enum IconRenderer {
     private static let outputScale: CGFloat = 2
     private static let canvasPx = Int(outputSize.width * outputScale)
 
-    private struct PixelGrid: Sendable {
+    private struct PixelGrid {
         let scale: CGFloat
 
         func pt(_ px: Int) -> CGFloat {
@@ -35,6 +35,7 @@ enum IconRenderer {
         let stale: Bool
         let style: Int
         let indicator: Int
+        let hideCritters: Bool
     }
 
     private final class IconCacheStore: @unchecked Sendable {
@@ -87,7 +88,7 @@ enum IconRenderer {
         }
     }
 
-    private struct RectPx: Hashable, Sendable {
+    private struct RectPx: Hashable {
         let x: Int
         let y: Int
         let w: Int
@@ -118,7 +119,8 @@ enum IconRenderer {
         blink: CGFloat = 0,
         wiggle: CGFloat = 0,
         tilt: CGFloat = 0,
-        statusIndicator: ProviderStatusIndicator = .none) -> NSImage
+        statusIndicator: ProviderStatusIndicator = .none,
+        hideCritters: Bool = false) -> NSImage
     {
         let shouldCache = blink <= 0.0001 && wiggle <= 0.0001 && tilt <= 0.0001
         let render = {
@@ -655,17 +657,25 @@ enum IconRenderer {
                 // Warp special case: when no bonus or bonus exhausted, show "top monthly, bottom dimmed"
                 let warpNoBonus = style == .warp && !weeklyAvailable
 
+                // "Hide critters" renders plain meter bars: suppress all face/decoration twists.
+                let twistFace = !hideCritters && style == .codex
+                let twistNotches = !hideCritters && style == .claude
+                let twistGemini = !hideCritters && (style == .gemini || style == .antigravity)
+                let twistAntigravity = !hideCritters && style == .antigravity
+                let twistFactory = !hideCritters && style == .factory
+                let twistWarp = !hideCritters && style == .warp
+
                 if weeklyAvailable {
                     // Normal: top=primary, bottom=secondary (bonus/weekly).
                     drawBar(
                         rectPx: topRectPx,
                         remaining: topValue,
-                        addNotches: style == .claude,
-                        addFace: style == .codex,
-                        addGeminiTwist: style == .gemini || style == .antigravity,
-                        addAntigravityTwist: style == .antigravity,
-                        addFactoryTwist: style == .factory,
-                        addWarpTwist: style == .warp,
+                        addNotches: twistNotches,
+                        addFace: twistFace,
+                        addGeminiTwist: twistGemini,
+                        addAntigravityTwist: twistAntigravity,
+                        addFactoryTwist: twistFactory,
+                        addWarpTwist: twistWarp,
                         blink: blink)
                     drawBar(rectPx: bottomRectPx, remaining: bottomValue)
                 } else if !hasWeekly || warpNoBonus {
@@ -674,7 +684,7 @@ enum IconRenderer {
                         drawBar(
                             rectPx: topRectPx,
                             remaining: topValue,
-                            addWarpTwist: true,
+                            addWarpTwist: twistWarp,
                             blink: blink)
                         drawBar(rectPx: bottomRectPx, remaining: nil, alpha: 0.45)
                     } else {
@@ -686,24 +696,24 @@ enum IconRenderer {
                                 rectPx: creditsRectPx,
                                 remaining: ratio,
                                 alpha: creditsAlpha,
-                                addNotches: style == .claude,
-                                addFace: style == .codex,
-                                addGeminiTwist: style == .gemini || style == .antigravity,
-                                addAntigravityTwist: style == .antigravity,
-                                addFactoryTwist: style == .factory,
-                                addWarpTwist: style == .warp,
+                                addNotches: twistNotches,
+                                addFace: twistFace,
+                                addGeminiTwist: twistGemini,
+                                addAntigravityTwist: twistAntigravity,
+                                addFactoryTwist: twistFactory,
+                                addWarpTwist: twistWarp,
                                 blink: blink)
                             drawBar(rectPx: creditsBottomRectPx, remaining: nil, alpha: 0.45)
                         } else {
                             drawBar(
                                 rectPx: topRectPx,
                                 remaining: topValue,
-                                addNotches: style == .claude,
-                                addFace: style == .codex,
-                                addGeminiTwist: style == .gemini || style == .antigravity,
-                                addAntigravityTwist: style == .antigravity,
-                                addFactoryTwist: style == .factory,
-                                addWarpTwist: style == .warp,
+                                addNotches: twistNotches,
+                                addFace: twistFace,
+                                addGeminiTwist: twistGemini,
+                                addAntigravityTwist: twistAntigravity,
+                                addFactoryTwist: twistFactory,
+                                addWarpTwist: twistWarp,
                                 blink: blink)
                             drawBar(rectPx: bottomRectPx, remaining: nil, alpha: 0.45)
                         }
@@ -715,24 +725,24 @@ enum IconRenderer {
                             rectPx: creditsRectPx,
                             remaining: ratio,
                             alpha: creditsAlpha,
-                            addNotches: style == .claude,
-                            addFace: style == .codex,
-                            addGeminiTwist: style == .gemini || style == .antigravity,
-                            addAntigravityTwist: style == .antigravity,
-                            addFactoryTwist: style == .factory,
-                            addWarpTwist: style == .warp,
+                            addNotches: twistNotches,
+                            addFace: twistFace,
+                            addGeminiTwist: twistGemini,
+                            addAntigravityTwist: twistAntigravity,
+                            addFactoryTwist: twistFactory,
+                            addWarpTwist: twistWarp,
                             blink: blink)
                     } else {
                         // No credits available; fall back to 5h if present.
                         drawBar(
                             rectPx: topRectPx,
                             remaining: topValue,
-                            addNotches: style == .claude,
-                            addFace: style == .codex,
-                            addGeminiTwist: style == .gemini || style == .antigravity,
-                            addAntigravityTwist: style == .antigravity,
-                            addFactoryTwist: style == .factory,
-                            addWarpTwist: style == .warp,
+                            addNotches: twistNotches,
+                            addFace: twistFace,
+                            addGeminiTwist: twistGemini,
+                            addAntigravityTwist: twistAntigravity,
+                            addFactoryTwist: twistFactory,
+                            addWarpTwist: twistWarp,
                             blink: blink)
                     }
                     drawBar(rectPx: creditsBottomRectPx, remaining: bottomValue)
@@ -749,7 +759,8 @@ enum IconRenderer {
                 credits: self.quantizedCredits(creditsRemaining),
                 stale: stale,
                 style: self.styleKey(style),
-                indicator: self.indicatorKey(statusIndicator))
+                indicator: self.indicatorKey(statusIndicator),
+                hideCritters: hideCritters)
             if let cached = self.cachedIcon(for: key) {
                 return cached
             }
@@ -764,14 +775,14 @@ enum IconRenderer {
     // swiftlint:enable function_body_length
 
     /// Morph helper: unbraids a simplified knot into our bar icon.
-    static func makeMorphIcon(progress: Double, style: IconStyle) -> NSImage {
+    static func makeMorphIcon(progress: Double, style: IconStyle, hideCritters: Bool = false) -> NSImage {
         let clamped = max(0, min(progress, 1))
-        let key = self.morphCacheKey(progress: clamped, style: style)
+        let key = self.morphCacheKey(progress: clamped, style: style, hideCritters: hideCritters)
         if let cached = self.morphCache.image(for: key) {
             return cached
         }
         let image = self.renderImage {
-            self.drawUnbraidMorph(t: clamped, style: style)
+            self.drawUnbraidMorph(t: clamped, style: style, hideCritters: hideCritters)
         }
         self.morphCache.set(image, for: key)
         return image
@@ -811,9 +822,9 @@ enum IconRenderer {
         }
     }
 
-    private static func morphCacheKey(progress: Double, style: IconStyle) -> NSNumber {
+    private static func morphCacheKey(progress: Double, style: IconStyle, hideCritters: Bool) -> NSNumber {
         let bucket = Int((progress * Double(self.morphBucketCount)).rounded())
-        let key = self.styleKey(style) * 1000 + bucket
+        let key = (hideCritters ? 1_000_000 : 0) + self.styleKey(style) * 1000 + bucket
         return NSNumber(value: key)
     }
 
@@ -825,7 +836,7 @@ enum IconRenderer {
         self.iconCacheStore.storeIcon(image, for: key, limit: self.iconCacheLimit)
     }
 
-    private static func drawUnbraidMorph(t: Double, style: IconStyle) {
+    private static func drawUnbraidMorph(t: Double, style: IconStyle, hideCritters: Bool) {
         let t = CGFloat(max(0, min(t, 1)))
         let size = Self.baseSize
         let center = CGPoint(x: size.width / 2, y: size.height / 2)
@@ -903,7 +914,8 @@ enum IconRenderer {
                 weeklyRemaining: 100,
                 creditsRemaining: nil,
                 stale: false,
-                style: style)
+                style: style,
+                hideCritters: hideCritters)
             bars.draw(in: CGRect(origin: .zero, size: size), from: .zero, operation: .sourceOver, fraction: barT)
         }
     }
@@ -944,6 +956,8 @@ enum IconRenderer {
                 y: 2,
                 width: size,
                 height: size)
+            Self.clearStatusOverlayHalo(
+                NSBezierPath(ovalIn: rect.insetBy(dx: -1, dy: -1)))
             let path = NSBezierPath(ovalIn: rect)
             color.setFill()
             path.fill()
@@ -953,21 +967,35 @@ enum IconRenderer {
                 y: 4,
                 width: 2.0,
                 height: 6)
-            let linePath = NSBezierPath(roundedRect: lineRect, xRadius: 1, yRadius: 1)
-            color.setFill()
-            linePath.fill()
-
             let dotRect = Self.snapRect(
                 x: Self.baseSize.width - 6,
                 y: 2,
                 width: 2.0,
                 height: 2.0)
+
+            let haloRect = lineRect.union(dotRect).insetBy(dx: -1, dy: -1)
+            Self.clearStatusOverlayHalo(
+                NSBezierPath(roundedRect: haloRect, xRadius: 2, yRadius: 2))
+
+            let linePath = NSBezierPath(roundedRect: lineRect, xRadius: 1, yRadius: 1)
+            color.setFill()
+            linePath.fill()
             NSBezierPath(ovalIn: dotRect).fill()
         case .none:
             break
         }
     }
 
+    private static func clearStatusOverlayHalo(_ path: NSBezierPath) {
+        guard let ctx = NSGraphicsContext.current?.cgContext else { return }
+        ctx.saveGState()
+        ctx.setBlendMode(.clear)
+        // The fill color is ignored by .clear; it only drives the path fill operation.
+        NSColor.black.setFill()
+        path.fill()
+        ctx.restoreGState()
+    }
+
     private static func withScaledContext(_ draw: () -> Void) {
         guard let ctx = NSGraphicsContext.current?.cgContext else {
             draw()
diff --git a/Sources/CodexBar/IconView.swift b/Sources/CodexBar/IconView.swift
deleted file mode 100644
index 26eb6463f2..0000000000
--- a/Sources/CodexBar/IconView.swift
+++ /dev/null
@@ -1,122 +0,0 @@
-import CodexBarCore
-import SwiftUI
-
-@MainActor
-struct IconView: View {
-    let snapshot: UsageSnapshot?
-    let creditsRemaining: Double?
-    let isStale: Bool
-    let showLoadingAnimation: Bool
-    let style: IconStyle
-    @State private var phase: CGFloat = 0
-    @State private var displayLink = DisplayLinkDriver()
-    @State private var pattern: LoadingPattern = .knightRider
-    @State private var debugCycle = false
-    @State private var cycleIndex = 0
-    @State private var cycleCounter = 0
-    private let loadingFPS: Double = 12
-    // Advance to next pattern every N ticks when debug cycling.
-    private let cycleIntervalTicks = 20
-    private let patterns = LoadingPattern.allCases
-
-    private var isLoading: Bool {
-        self.showLoadingAnimation && self.snapshot == nil
-    }
-
-    var body: some View {
-        Group {
-            if let snapshot {
-                Image(nsImage: IconRenderer.makeIcon(
-                    primaryRemaining: snapshot.primary?.remainingPercent,
-                    weeklyRemaining: snapshot.secondary?.remainingPercent,
-                    creditsRemaining: self.creditsRemaining,
-                    stale: self.isStale,
-                    style: self.style))
-                    .renderingMode(.original)
-                    .interpolation(.none)
-                    .frame(width: 20, height: 18, alignment: .center)
-                    .padding(.horizontal, 2)
-            } else if self.showLoadingAnimation {
-                // Loading: animate bars with the current pattern until data arrives.
-                Image(nsImage: self.loadingImage)
-                    .renderingMode(.original)
-                    .interpolation(.none)
-                    .frame(width: 20, height: 18, alignment: .center)
-                    .padding(.horizontal, 2)
-                    .onChange(of: self.displayLink.tick) { _, _ in
-                        self.phase += 0.09 // half-speed animation
-                        if self.debugCycle {
-                            self.cycleCounter += 1
-                            if self.cycleCounter >= self.cycleIntervalTicks {
-                                self.cycleCounter = 0
-                                self.cycleIndex = (self.cycleIndex + 1) % self.patterns.count
-                                self.pattern = self.patterns[self.cycleIndex]
-                            }
-                        }
-                    }
-            } else {
-                // No animation when usage/account is unavailable; show empty tracks.
-                Image(nsImage: IconRenderer.makeIcon(
-                    primaryRemaining: nil,
-                    weeklyRemaining: nil,
-                    creditsRemaining: self.creditsRemaining,
-                    stale: self.isStale,
-                    style: self.style))
-                    .renderingMode(.original)
-                    .interpolation(.none)
-                    .frame(width: 20, height: 18, alignment: .center)
-                    .padding(.horizontal, 2)
-            }
-        }
-        .onChange(of: self.isLoading, initial: true) { _, isLoading in
-            if isLoading {
-                self.displayLink.start(fps: self.loadingFPS)
-                if !self.debugCycle {
-                    self.pattern = self.patterns.randomElement() ?? .knightRider
-                }
-            } else {
-                self.displayLink.stop()
-                self.debugCycle = false
-                self.phase = 0
-            }
-        }
-        .onDisappear { self.displayLink.stop() }
-        .onReceive(NotificationCenter.default.publisher(for: .codexbarDebugReplayAllAnimations)) { notification in
-            if let raw = notification.userInfo?["pattern"] as? String,
-               let selected = LoadingPattern(rawValue: raw)
-            {
-                self.debugCycle = false
-                self.pattern = selected
-                self.cycleIndex = self.patterns.firstIndex(of: selected) ?? 0
-            } else {
-                self.debugCycle = true
-                self.cycleIndex = 0
-                self.pattern = self.patterns.first ?? .knightRider
-            }
-            self.cycleCounter = 0
-            self.phase = 0
-        }
-    }
-
-    private var loadingPrimary: Double {
-        self.pattern.value(phase: Double(self.phase))
-    }
-
-    private var loadingSecondary: Double {
-        self.pattern.value(phase: Double(self.phase + self.pattern.secondaryOffset))
-    }
-
-    private var loadingImage: NSImage {
-        if self.pattern == .unbraid {
-            let progress = self.loadingPrimary / 100
-            return IconRenderer.makeMorphIcon(progress: progress, style: self.style)
-        } else {
-            return IconRenderer.makeIcon(
-                primaryRemaining: self.loadingPrimary,
-                weeklyRemaining: self.loadingSecondary,
-                creditsRemaining: nil,
-                stale: false,
-                style: self.style)
-        }
-    }
-}
diff --git a/Sources/CodexBar/InlineUsageDashboardContent.swift b/Sources/CodexBar/InlineUsageDashboardContent.swift
new file mode 100644
index 0000000000..762007bdc0
--- /dev/null
+++ b/Sources/CodexBar/InlineUsageDashboardContent.swift
@@ -0,0 +1,793 @@
+import CodexBarCore
+import SwiftUI
+
+struct InlineUsageDashboardModel: Equatable {
+    struct KPI: Equatable {
+        let title: String
+        let value: String
+        let emphasis: Bool
+    }
+
+    struct Point: Equatable, Identifiable {
+        let id: String
+        let label: String
+        let value: Double
+        let accessibilityValue: String
+    }
+
+    enum ValueStyle: Equatable {
+        case currencyUSD
+        case currency(symbol: String)
+        case tokens
+        case points
+    }
+
+    let accessibilityLabel: String
+    let valueStyle: ValueStyle
+    let kpis: [KPI]
+    let points: [Point]
+    let detailLines: [String]
+    /// Provider branding color used to fill the mini usage bars. When nil the bars fall back to a
+    /// neutral palette derived from `valueStyle`.
+    var barColor: Color?
+}
+
+extension UsageMenuCardView.Model {
+    static func apiProviderUsageNotes(input: Input) -> [String]? {
+        if input.provider == .openai,
+           let usage = input.snapshot?.openAIAPIUsage
+        {
+            return self.openAIAPIUsageNotes(usage)
+        }
+
+        if input.provider == .deepgram,
+           let usage = input.snapshot?.deepgramUsage
+        {
+            return usage.displayLines
+        }
+
+        if input.provider == .minimax,
+           input.showOptionalCreditsAndExtraUsage,
+           let billing = input.snapshot?.minimaxUsage?.billingSummary
+        {
+            return [
+                String(format: L("Today: %@ tokens"), UsageFormatter.tokenCountString(billing.todayTokens)),
+                String(
+                    format: L("Last 30 days: %@ tokens"),
+                    UsageFormatter.tokenCountString(billing.last30DaysTokens)),
+            ]
+        }
+
+        if input.provider == .deepseek,
+           input.showOptionalCreditsAndExtraUsage,
+           let usage = input.snapshot?.deepseekUsage
+        {
+            let symbol = usage.currency == "CNY" ? "¥" : "$"
+            let todayCostStr = usage.todayCost.map { "\(symbol)\(String(format: "%.4f", max(0, $0)))" } ?? "—"
+            return [
+                String(
+                    format: L("Today: %@ · %@ tokens"),
+                    todayCostStr,
+                    UsageFormatter.tokenCountString(usage.todayTokens)),
+                String(format: L("This month: %@ tokens"), UsageFormatter.tokenCountString(usage.currentMonthTokens)),
+            ]
+        }
+
+        if input.provider == .poe,
+           let usage = input.snapshot?.poeUsage
+        {
+            return self.poeUsageNotes(usage)
+        }
+
+        if input.provider == .ollama,
+           input.snapshot?.identity?.loginMethod == "API key"
+        {
+            return [L("API key verified. Ollama does not expose Cloud quota limits through the API.")]
+        }
+
+        return nil
+    }
+
+    static func openAIAPIUsageNotes(_ usage: OpenAIAPIUsageSnapshot) -> [String] {
+        let today = usage.latestDay
+        let seven = usage.last7Days
+        let thirty = usage.last30Days
+        let historyLabel = usage.historyWindowLabel
+        let todayNote = String(
+            format: L("Today: %@ · %@ tokens"),
+            UsageFormatter.usdString(today.costUSD),
+            UsageFormatter.tokenCountString(today.totalTokens))
+        let sevenDayNote = "7d: \(UsageFormatter.usdString(seven.costUSD)) · " +
+            "\(UsageFormatter.tokenCountString(seven.requests)) \(L("requests"))"
+        let thirtyDayNote =
+            "\(historyLabel): \(UsageFormatter.tokenCountString(thirty.totalTokens)) \(L("tokens")) · " +
+            "\(UsageFormatter.tokenCountString(thirty.requests)) \(L("requests"))"
+        var notes: [String] = [
+            todayNote,
+            sevenDayNote,
+            thirtyDayNote,
+        ]
+        if let topModel = usage.topModels.first {
+            notes.append("\(L("Top model")): \(topModel.name)")
+        }
+        return notes
+    }
+
+    static func poeUsageNotes(_ usage: PoeUsageHistorySnapshot) -> [String] {
+        let today = usage.latestDay
+        let week = usage.last7Days
+        let month = usage.last30Days
+        let todayUSD = today.costUSD.map { " · \(UsageFormatter.usdString($0))" } ?? ""
+        let weekUSD = week.costUSD.map { " · \(UsageFormatter.usdString($0))" } ?? ""
+        let monthUSD = month.costUSD.map { " · \(UsageFormatter.usdString($0))" } ?? ""
+        let todayLine = "Today: \(Self.pointsSummary(today.points)) · " +
+            "\(UsageFormatter.tokenCountString(today.requests)) \(L("requests"))\(todayUSD)"
+        let weekLine = "7d: \(Self.pointsSummary(week.points)) · " +
+            "\(UsageFormatter.tokenCountString(week.requests)) \(L("requests"))\(weekUSD)"
+        let monthLine = "30d: \(Self.pointsSummary(month.points)) · " +
+            "\(UsageFormatter.tokenCountString(month.requests)) \(L("requests"))\(monthUSD)"
+        var notes = [
+            todayLine,
+            weekLine,
+            monthLine,
+        ]
+        if let topModel = usage.topModels.first {
+            notes.append("\(L("Top model")): \(topModel.name) (\(Self.pointsSummary(topModel.points)))")
+        }
+        if !usage.topUsageTypes.isEmpty {
+            let mix = usage.topUsageTypes.prefix(2)
+                .map { "\($0.name): \(Self.pointsSummary($0.points))" }
+                .joined(separator: " · ")
+            notes.append("Usage mix: \(mix)")
+        }
+        return notes
+    }
+
+    static func inlineUsageDashboard(input: Input) -> InlineUsageDashboardModel? {
+        guard var model = self.resolveInlineUsageDashboard(input: input) else { return nil }
+        model.barColor = Self.inlineDashboardBarColor(for: input.provider)
+        return model
+    }
+
+    /// Provider branding color for the inline usage bars, matching the provider's switcher tab and
+    /// detailed cost-history chart.
+    static func inlineDashboardBarColor(for provider: UsageProvider) -> Color {
+        let color = ProviderDescriptorRegistry.descriptor(for: provider).branding.color
+        return Color(red: color.red, green: color.green, blue: color.blue)
+    }
+
+    private static func resolveInlineUsageDashboard(input: Input) -> InlineUsageDashboardModel? {
+        if self.usesProviderCostHistoryAsPrimaryDashboard(input.provider),
+           let tokenSnapshot = primaryCostHistorySnapshot(input: input),
+           !tokenSnapshot.daily.isEmpty
+        {
+            return self.costHistoryInlineDashboard(provider: input.provider, snapshot: tokenSnapshot)
+        }
+        if input.provider == .claude,
+           let usage = input.snapshot?.claudeAdminAPIUsage
+        {
+            return Self.claudeAdminAPIInlineDashboard(usage)
+        }
+        if input.provider == .openrouter,
+           let usage = input.snapshot?.openRouterUsage
+        {
+            return Self.openRouterInlineDashboard(usage)
+        }
+        if input.provider == .zai,
+           let modelUsage = input.snapshot?.zaiUsage?.modelUsage
+        {
+            return Self.zaiInlineDashboard(modelUsage: modelUsage, now: input.now)
+        }
+        if input.provider == .minimax,
+           input.showOptionalCreditsAndExtraUsage,
+           let billing = input.snapshot?.minimaxUsage?.billingSummary,
+           !billing.daily.isEmpty
+        {
+            return Self.minimaxInlineDashboard(billing)
+        }
+        if input.provider == .deepseek,
+           input.showOptionalCreditsAndExtraUsage,
+           let usage = input.snapshot?.deepseekUsage,
+           !usage.daily.isEmpty
+        {
+            return Self.deepseekInlineDashboard(usage)
+        }
+        if input.provider == .poe,
+           let usage = input.snapshot?.poeUsage,
+           !usage.daily.isEmpty
+        {
+            return Self.poeInlineDashboard(usage)
+        }
+        if [.codex, .claude, .vertexai, .bedrock].contains(input.provider),
+           input.tokenCostUsageEnabled,
+           let tokenSnapshot = input.tokenSnapshot,
+           !tokenSnapshot.daily.isEmpty
+        {
+            return Self.costHistoryInlineDashboard(provider: input.provider, snapshot: tokenSnapshot)
+        }
+        return nil
+    }
+
+    static func usesProviderCostHistoryAsPrimaryDashboard(_ provider: UsageProvider) -> Bool {
+        provider == .openai || provider == .mistral
+    }
+
+    static func primaryCostHistorySnapshot(input: Input) -> CostUsageTokenSnapshot? {
+        switch input.provider {
+        case .openai:
+            if let projected = input.snapshot?.openAIAPIUsage?.toCostUsageTokenSnapshot() {
+                return projected
+            }
+            return input.snapshot == nil ? input.tokenSnapshot : nil
+        case .mistral:
+            if let projected = input.snapshot?.mistralUsage?.toCostUsageTokenSnapshot() {
+                return projected
+            }
+            return input.snapshot == nil ? input.tokenSnapshot : nil
+        default:
+            return input.tokenSnapshot
+        }
+    }
+
+    static func poeInlineDashboard(_ usage: PoeUsageHistorySnapshot) -> InlineUsageDashboardModel {
+        let today = usage.latestDay
+        let week = usage.last7Days
+        let month = usage.last30Days
+        let points = usage.daily.suffix(30).map {
+            InlineUsageDashboardModel.Point(
+                id: $0.day,
+                label: Self.shortDayLabel($0.day),
+                value: $0.points,
+                accessibilityValue: "\($0.day): \(Self.pointsSummary($0.points))")
+        }
+        var details = ["30d requests: \(UsageFormatter.tokenCountString(month.requests))"]
+        if let topModel = usage.topModel {
+            details.append("\(L("Top model")): \(topModel)")
+        }
+        if !usage.topUsageTypes.isEmpty {
+            let mix = usage.topUsageTypes.prefix(3)
+                .map { "\($0.name): \(Self.pointsSummary($0.points))" }
+                .joined(separator: " · ")
+            details.append("Usage mix: \(mix)")
+        }
+        if let usd = today.costUSD, usd > 0 {
+            details.append("Today USD: \(UsageFormatter.usdString(usd))")
+        }
+        if let usd = week.costUSD, usd > 0 {
+            details.append("7d USD: \(UsageFormatter.usdString(usd))")
+        }
+        if let usd = month.costUSD, usd > 0 {
+            details.append("30d USD: \(UsageFormatter.usdString(usd))")
+        }
+        let recent = usage.recentEntries(limit: 2)
+        if !recent.isEmpty {
+            let text = recent.map { "\($0.model) \(Self.pointsSummary($0.points))" }.joined(separator: " · ")
+            details.append("Recent: \(text)")
+        }
+        return InlineUsageDashboardModel(
+            accessibilityLabel: "Poe points usage trend",
+            valueStyle: .points,
+            kpis: [
+                .init(title: L("Today"), value: Self.pointsSummary(today.points), emphasis: true),
+                .init(title: "7d", value: Self.pointsSummary(week.points), emphasis: false),
+                .init(title: "30d", value: Self.pointsSummary(month.points), emphasis: false),
+                .init(title: L("Requests"), value: UsageFormatter.tokenCountString(month.requests), emphasis: false),
+            ],
+            points: points,
+            detailLines: details)
+    }
+
+    static func pointsSummary(_ value: Double) -> String {
+        let clamped = max(0, value)
+        if clamped.rounded() == clamped {
+            return "\(UsageFormatter.tokenCountString(Int(clamped))) points"
+        }
+        return "\(String(format: "%.1f", clamped)) points"
+    }
+
+    private static func costHistoryInlineDashboard(
+        provider: UsageProvider,
+        snapshot: CostUsageTokenSnapshot) -> InlineUsageDashboardModel
+    {
+        let historyDays = max(1, min(365, snapshot.historyDays))
+        let historyTitle = snapshot.historyLabel
+            ?? (historyDays == 1
+                ? L("Today")
+                : historyDays == 30
+                ? L("30d cost")
+                : "\(String(format: L("Last %d days"), historyDays)) \(L("Cost"))")
+        let tokenHistoryTitle = snapshot.historyLabel.map { "\($0) \(L("tokens"))" }
+            ?? (historyDays == 1
+                ? L("Today tokens")
+                : historyDays == 30
+                ? L("30d tokens")
+                : String(format: L("%@ tokens"), String(format: L("Last %d days"), historyDays)))
+        let requestHistoryTitle = snapshot.historyLabel.map { "\($0) \(L("requests"))" }
+            ?? (historyDays == 1
+                ? L("Today requests")
+                : historyDays == 30
+                ? L("30d requests")
+                : String(format: L("%@ requests"), String(format: L("Last %d days"), historyDays)))
+        let periodLabel = snapshot.historyLabel?.lowercased()
+            ?? (historyDays == 1 ? "today" : "\(historyDays) day")
+        let points = snapshot.daily.suffix(historyDays).compactMap { entry -> InlineUsageDashboardModel.Point? in
+            guard let cost = entry.costUSD else { return nil }
+            return InlineUsageDashboardModel.Point(
+                id: entry.date,
+                label: Self.shortDayLabel(entry.date),
+                value: cost,
+                accessibilityValue: "\(entry.date): \(Self.costString(cost, currencyCode: snapshot.currencyCode))")
+        }
+        let latest = snapshot.daily.max { lhs, rhs in lhs.date < rhs.date }
+        var details: [String] = []
+        if let topModel = Self.topCostModel(from: snapshot.daily) {
+            details.append("\(L("Top model")): \(Self.shortModelName(topModel))")
+        }
+        if let requestCount = snapshot.last30DaysRequests {
+            details.append("\(requestHistoryTitle): \(UsageFormatter.tokenCountString(requestCount)) \(L("requests"))")
+        }
+        if let hint = Self.tokenUsageHint(provider: provider) {
+            details.append(hint)
+        } else {
+            details.append(L("cost_estimate_hint"))
+        }
+        let providerName = ProviderDefaults.metadata[provider]?.displayName ?? provider.rawValue
+        return InlineUsageDashboardModel(
+            accessibilityLabel: "\(providerName) \(periodLabel) cost trend",
+            valueStyle: Self.costValueStyle(currencyCode: snapshot.currencyCode),
+            kpis: [
+                .init(
+                    title: provider == .bedrock || provider == .mistral ? L("Latest") : L("Today"),
+                    value: latest?.costUSD.map { Self.costString($0, currencyCode: snapshot.currencyCode) } ?? "—",
+                    emphasis: true),
+                .init(
+                    title: historyTitle,
+                    value: snapshot.last30DaysCostUSD
+                        .map { Self.costString($0, currencyCode: snapshot.currencyCode) } ?? "—",
+                    emphasis: false),
+                .init(
+                    title: tokenHistoryTitle,
+                    value: snapshot.last30DaysTokens.map(UsageFormatter.tokenCountString) ?? "—",
+                    emphasis: false),
+            ] + Self.costHistoryTrailingKPIs(snapshot: snapshot, latest: latest),
+            points: points,
+            detailLines: details)
+    }
+
+    private static func costHistoryTrailingKPIs(
+        snapshot: CostUsageTokenSnapshot,
+        latest: CostUsageDailyReport.Entry?)
+        -> [InlineUsageDashboardModel.KPI]
+    {
+        if let requests = snapshot.last30DaysRequests {
+            return [
+                .init(
+                    title: L("Requests"),
+                    value: UsageFormatter.tokenCountString(requests),
+                    emphasis: false),
+            ]
+        }
+        return [
+            .init(
+                title: L("Latest tokens"),
+                value: latest?.totalTokens.map(UsageFormatter.tokenCountString) ?? "—",
+                emphasis: false),
+        ]
+    }
+
+    fileprivate static func claudeAdminAPIInlineDashboard(_ usage: ClaudeAdminAPIUsageSnapshot)
+        -> InlineUsageDashboardModel
+    {
+        let today = usage.latestDay
+        let last7 = usage.last7Days
+        let last30 = usage.last30Days
+        let points = usage.daily.suffix(30).map {
+            InlineUsageDashboardModel.Point(
+                id: $0.day,
+                label: Self.shortDayLabel($0.day),
+                value: $0.costUSD,
+                accessibilityValue: "\($0.day): \(UsageFormatter.usdString($0.costUSD))")
+        }
+        var details = [
+            "30d: \(UsageFormatter.tokenCountString(last30.totalTokens)) \(L("tokens"))",
+            "\(L("Cache read")): \(UsageFormatter.tokenCountString(last30.cacheReadInputTokens)) \(L("tokens"))",
+        ]
+        if let topModel = usage.topModels.first {
+            details.append("\(L("Top model")): \(Self.shortModelName(topModel.name))")
+        }
+        return InlineUsageDashboardModel(
+            accessibilityLabel: L("Claude Admin API 30 day spend trend"),
+            valueStyle: .currencyUSD,
+            kpis: [
+                .init(title: L("Today"), value: UsageFormatter.usdString(today.costUSD), emphasis: true),
+                .init(title: L("7d spend"), value: UsageFormatter.usdString(last7.costUSD), emphasis: false),
+                .init(
+                    title: L("30d spend"),
+                    value: UsageFormatter.usdString(last30.costUSD),
+                    emphasis: false),
+                .init(
+                    title: L("Today tokens"),
+                    value: UsageFormatter.tokenCountString(today.totalTokens),
+                    emphasis: false),
+            ],
+            points: points,
+            detailLines: details)
+    }
+
+    private static func openRouterInlineDashboard(_ usage: OpenRouterUsageSnapshot) -> InlineUsageDashboardModel? {
+        let periodValues: [(String, String, Double?)] = [
+            ("day", L("Today"), usage.keyUsageDaily),
+            ("week", L("Week"), usage.keyUsageWeekly),
+            ("month", L("Month"), usage.keyUsageMonthly),
+        ]
+        let points = periodValues.compactMap { id, label, value -> InlineUsageDashboardModel.Point? in
+            guard let value else { return nil }
+            return InlineUsageDashboardModel.Point(
+                id: id,
+                label: label,
+                value: value,
+                accessibilityValue: "\(label): \(Self.openRouterCurrencyString(value))")
+        }
+        guard !points.isEmpty else { return nil }
+        var details: [String] = []
+        if let rate = usage.rateLimit {
+            details.append(String(format: L("Rate limit: %d / %@"), rate.requests, rate.interval))
+        }
+        switch usage.keyQuotaStatus {
+        case .available:
+            if let remaining = usage.keyRemaining {
+                details.append("\(L("Key remaining")): \(Self.openRouterCurrencyString(remaining))")
+            }
+        case .noLimitConfigured:
+            details.append(L("No limit set for the API key"))
+        case .unavailable:
+            details.append(L("API key limit unavailable right now"))
+        }
+        return InlineUsageDashboardModel(
+            accessibilityLabel: L("OpenRouter API key spend trend"),
+            valueStyle: .currencyUSD,
+            kpis: [
+                .init(title: L("Balance"), value: Self.openRouterCurrencyString(usage.balance), emphasis: true),
+                .init(
+                    title: L("Today"),
+                    value: usage.keyUsageDaily.map(Self.openRouterCurrencyString) ?? "—",
+                    emphasis: false),
+                .init(
+                    title: L("Week"),
+                    value: usage.keyUsageWeekly.map(Self.openRouterCurrencyString) ?? "—",
+                    emphasis: false),
+                .init(
+                    title: L("Month"),
+                    value: usage.keyUsageMonthly.map(Self.openRouterCurrencyString) ?? "—",
+                    emphasis: false),
+            ],
+            points: points,
+            detailLines: details)
+    }
+
+    private static func zaiInlineDashboard(modelUsage: ZaiModelUsageData, now: Date) -> InlineUsageDashboardModel? {
+        let bars = ZaiHourlyBars.from(modelData: modelUsage, range: .last24h, now: now)
+        guard !bars.isEmpty else { return nil }
+        let total = bars.reduce(0) { $0 + $1.totalTokens }
+        let latest = bars.last
+        let peak = bars.max { $0.totalTokens < $1.totalTokens }
+        let points = bars.enumerated().map { index, bar in
+            InlineUsageDashboardModel.Point(
+                id: "\(index)-\(bar.label)",
+                label: bar.label,
+                value: Double(bar.totalTokens),
+                accessibilityValue: "\(bar.label): \(UsageFormatter.tokenCountString(bar.totalTokens)) \(L("tokens"))")
+        }
+        let topModel = Self.topZaiModel(from: bars)
+        return InlineUsageDashboardModel(
+            accessibilityLabel: L("z.ai hourly token trend"),
+            valueStyle: .tokens,
+            kpis: [
+                .init(title: L("24h tokens"), value: UsageFormatter.tokenCountString(total), emphasis: true),
+                .init(
+                    title: L("Latest hour"),
+                    value: latest.map { UsageFormatter.tokenCountString($0.totalTokens) } ?? "—",
+                    emphasis: false),
+                .init(
+                    title: L("Peak hour"),
+                    value: peak.map { UsageFormatter.tokenCountString($0.totalTokens) } ?? "—",
+                    emphasis: false),
+                .init(title: L("Models"), value: "\(modelUsage.modelNames.count)", emphasis: false),
+            ],
+            points: points,
+            detailLines: topModel.map { ["\(L("Top model")): \(Self.shortModelName($0))"] } ?? [])
+    }
+
+    private static func minimaxInlineDashboard(_ billing: MiniMaxBillingSummary) -> InlineUsageDashboardModel {
+        let points = billing.daily.suffix(30).map {
+            InlineUsageDashboardModel.Point(
+                id: $0.day,
+                label: Self.shortDayLabel($0.day),
+                value: Double($0.tokens),
+                accessibilityValue: "\($0.day): \(UsageFormatter.tokenCountString($0.tokens)) \(L("tokens"))")
+        }
+        var details = [L("30d billing history from MiniMax web session")]
+        if let topModel = billing.topModels.first {
+            details.append("\(L("Top model")): \(Self.shortModelName(topModel.name))")
+        }
+        if let topMethod = billing.topMethods.first {
+            details.append("\(L("Top method")): \(Self.shortModelName(topMethod.name))")
+        }
+        if let cash = billing.last30DaysCash {
+            details.append("\(L("30d cash")): \(Self.minimaxCashString(cash))")
+        }
+        return InlineUsageDashboardModel(
+            accessibilityLabel: L("MiniMax 30 day token usage trend"),
+            valueStyle: .tokens,
+            kpis: [
+                .init(
+                    title: L("Today"),
+                    value: UsageFormatter.tokenCountString(billing.todayTokens),
+                    emphasis: true),
+                .init(
+                    title: L("30d tokens"),
+                    value: UsageFormatter.tokenCountString(billing.last30DaysTokens),
+                    emphasis: false),
+                .init(
+                    title: L("Today cash"),
+                    value: billing.todayCash.map(Self.minimaxCashString) ?? "—",
+                    emphasis: false),
+                .init(
+                    title: L("Models"),
+                    value: "\(billing.topModels.count)",
+                    emphasis: false),
+            ],
+            points: points,
+            detailLines: details)
+    }
+
+    private static func deepseekInlineDashboard(_ usage: DeepSeekUsageSummary) -> InlineUsageDashboardModel {
+        let symbol = usage.currency == "CNY" ? "¥" : "$"
+        let points = usage.daily.suffix(30).map {
+            InlineUsageDashboardModel.Point(
+                id: $0.date,
+                label: Self.shortDayLabel($0.date),
+                value: Double($0.totalTokens),
+                accessibilityValue: "\($0.date): \(UsageFormatter.tokenCountString($0.totalTokens)) \(L("tokens"))")
+        }
+        var details: [String] = []
+        if let topModel = usage.topModel {
+            details.append("\(L("Top model")): \(Self.shortModelName(topModel))")
+        }
+        if let cacheHit = usage.categoryBreakdown.first(where: { $0.category == .promptCacheHitToken }) {
+            details.append("\(L("cache-hit input")): \(UsageFormatter.tokenCountString(cacheHit.tokens))")
+        }
+        if let cacheMiss = usage.categoryBreakdown.first(where: { $0.category == .promptCacheMissToken }) {
+            details.append("\(L("cache-miss input")): \(UsageFormatter.tokenCountString(cacheMiss.tokens))")
+        }
+        if let output = usage.categoryBreakdown.first(where: { $0.category == .responseToken }) {
+            details.append("\(L("output")): \(UsageFormatter.tokenCountString(output.tokens))")
+        }
+        details.append("\(L("requests")): \(usage.currentMonthRequestCount)")
+
+        let todayCostStr = usage.todayCost.map { "\(symbol)\(String(format: "%.4f", max(0, $0)))" } ?? "—"
+        let monthCostStr = usage.currentMonthCost.map { "\(symbol)\(String(format: "%.4f", max(0, $0)))" } ?? "—"
+        let monthTokensStr = UsageFormatter.tokenCountString(usage.currentMonthTokens)
+
+        return InlineUsageDashboardModel(
+            accessibilityLabel: L("DeepSeek 30 day token usage trend"),
+            valueStyle: .tokens,
+            kpis: [
+                .init(
+                    title: L("Today"),
+                    value: "\(todayCostStr) · \(UsageFormatter.tokenCountString(usage.todayTokens))",
+                    emphasis: true),
+                .init(
+                    title: L("This month"),
+                    value: "\(monthCostStr) · \(monthTokensStr)",
+                    emphasis: false),
+                .init(
+                    title: L("Models"),
+                    value: usage.topModel.map { Self.shortModelName($0) } ?? "—",
+                    emphasis: false),
+                .init(
+                    title: L("Requests"),
+                    value: "\(usage.currentMonthRequestCount)",
+                    emphasis: false),
+            ],
+            points: points,
+            detailLines: details)
+    }
+
+    private static func topMistralModel(from entries: [MistralDailyUsageBucket]) -> String? {
+        var tokens: [String: Int] = [:]
+        for entry in entries {
+            for model in entry.models {
+                tokens[model.name, default: 0] += model.totalTokens
+            }
+        }
+        return tokens.max {
+            if $0.value == $1.value { return $0.key > $1.key }
+            return $0.value < $1.value
+        }?.key
+    }
+
+    private static func topZaiModel(from bars: [ZaiHourlyBar]) -> String? {
+        var tokens: [String: Int] = [:]
+        for bar in bars {
+            for segment in bar.segments {
+                tokens[segment.model, default: 0] += segment.tokens
+            }
+        }
+        return tokens.max {
+            if $0.value == $1.value { return $0.key > $1.key }
+            return $0.value < $1.value
+        }?.key
+    }
+
+    private static func openRouterCurrencyString(_ value: Double) -> String {
+        String(format: "$%.2f", value)
+    }
+
+    private static func minimaxCashString(_ value: Double) -> String {
+        String(format: "%.2f", max(0, value))
+    }
+
+    private static func costString(_ value: Double, currencyCode: String) -> String {
+        UsageFormatter.currencyString(value, currencyCode: currencyCode)
+    }
+
+    private static func costValueStyle(currencyCode: String) -> InlineUsageDashboardModel.ValueStyle {
+        if currencyCode == "USD" { return .currencyUSD }
+        let formatter = NumberFormatter()
+        formatter.numberStyle = .currency
+        formatter.currencyCode = currencyCode
+        formatter.locale = Locale(identifier: "en_US")
+        let symbol = formatter.currencySymbol ?? currencyCode
+        return .currency(symbol: symbol)
+    }
+
+    private static func shortDayLabel(_ day: String) -> String {
+        let pieces = day.split(separator: "-")
+        guard pieces.count == 3, let rawDay = Int(pieces[2]) else { return day }
+        return "\(rawDay)"
+    }
+
+    private static func shortModelName(_ name: String) -> String {
+        let trimmed = name.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard trimmed.count > 26 else { return trimmed }
+        return String(trimmed.prefix(25)) + "…"
+    }
+
+    private static func topCostModel(from entries: [CostUsageDailyReport.Entry]) -> String? {
+        var scores: [String: (cost: Double, tokens: Int)] = [:]
+        for entry in entries {
+            for model in entry.modelBreakdowns ?? [] {
+                var score = scores[model.modelName] ?? (0, 0)
+                score.cost += model.costUSD ?? 0
+                score.tokens += model.totalTokens ?? 0
+                scores[model.modelName] = score
+            }
+        }
+        return scores.max {
+            if $0.value.cost == $1.value.cost { return $0.value.tokens < $1.value.tokens }
+            return $0.value.cost < $1.value.cost
+        }?.key
+    }
+}
+
+struct InlineUsageDashboardContent: View {
+    private let model: InlineUsageDashboardModel
+    @Environment(\.menuItemHighlighted) private var isHighlighted
+
+    init(model: InlineUsageDashboardModel) {
+        self.model = model
+    }
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 10) {
+            self.kpis
+            MiniUsageBars(model: self.model)
+                .frame(height: 58)
+                .accessibilityLabel(self.model.accessibilityLabel)
+            self.detailLines
+        }
+        .frame(maxWidth: .infinity, alignment: .leading)
+    }
+
+    private var kpis: some View {
+        LazyVGrid(
+            columns: [
+                GridItem(.flexible(minimum: 118), alignment: .leading),
+                GridItem(.flexible(minimum: 100), alignment: .leading),
+            ],
+            alignment: .leading,
+            spacing: 6)
+        {
+            ForEach(Array(self.model.kpis.enumerated()), id: \.offset) { _, kpi in
+                KPIBlock(title: kpi.title, value: kpi.value, emphasis: kpi.emphasis)
+            }
+        }
+    }
+
+    private var detailLines: some View {
+        VStack(alignment: .leading, spacing: 3) {
+            ForEach(Array(self.model.detailLines.enumerated()), id: \.offset) { _, line in
+                Text(line)
+                    .font(.caption)
+                    .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
+                    .lineLimit(1)
+            }
+        }
+    }
+
+    private struct KPIBlock: View {
+        let title: String
+        let value: String
+        let emphasis: Bool
+        @Environment(\.menuItemHighlighted) private var isHighlighted
+
+        var body: some View {
+            VStack(alignment: .leading, spacing: 1) {
+                Text(self.title)
+                    .font(.caption2)
+                    .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
+                    .lineLimit(1)
+                Text(self.value)
+                    .font(self.emphasis ? .headline : .subheadline)
+                    .fontWeight(.semibold)
+                    .foregroundStyle(MenuHighlightStyle.primary(self.isHighlighted))
+                    .lineLimit(1)
+                    .minimumScaleFactor(0.72)
+            }
+            .frame(maxWidth: .infinity, alignment: .leading)
+        }
+    }
+
+    private struct MiniUsageBars: View {
+        let model: InlineUsageDashboardModel
+        @Environment(\.menuItemHighlighted) private var isHighlighted
+
+        var body: some View {
+            let maxValue = max(self.model.points.map(\.value).max() ?? 0, 1)
+            HStack(alignment: .bottom, spacing: 2) {
+                ForEach(self.model.points) { point in
+                    RoundedRectangle(cornerRadius: 1.5, style: .continuous)
+                        .fill(self.fill(for: point, maxValue: maxValue))
+                        .frame(maxWidth: .infinity)
+                        .frame(height: self.height(for: point, maxValue: maxValue))
+                        .accessibilityLabel(point.accessibilityValue)
+                }
+            }
+            .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .bottom)
+            .overlay(alignment: .bottomLeading) {
+                Rectangle()
+                    .fill(MenuHighlightStyle.secondary(self.isHighlighted).opacity(0.22))
+                    .frame(height: 1)
+            }
+        }
+
+        private func height(for point: InlineUsageDashboardModel.Point, maxValue: Double) -> CGFloat {
+            let ratio = point.value / maxValue
+            guard ratio > 0 else { return 1 }
+            return CGFloat(max(3, min(58, ratio * 58)))
+        }
+
+        private func fill(for point: InlineUsageDashboardModel.Point, maxValue: Double) -> Color {
+            let ratio = max(0.18, min(1, point.value / maxValue))
+            if self.isHighlighted {
+                return Color.white.opacity(0.55 + ratio * 0.35)
+            }
+            return self.baseColor.opacity(0.42 + ratio * 0.58)
+        }
+
+        private var baseColor: Color {
+            if let barColor = self.model.barColor {
+                return barColor
+            }
+            switch self.model.valueStyle {
+            case .currencyUSD, .currency:
+                return Color(red: 0.81, green: 0.56, blue: 0.24)
+            case .tokens:
+                return Color(red: 0.48, green: 0.41, blue: 0.86)
+            case .points:
+                return Color(red: 0.16, green: 0.62, blue: 0.36)
+            }
+        }
+    }
+}
diff --git a/Sources/CodexBar/KeychainMigration.swift b/Sources/CodexBar/KeychainMigration.swift
index edb9fc1ba4..51bf840ca3 100644
--- a/Sources/CodexBar/KeychainMigration.swift
+++ b/Sources/CodexBar/KeychainMigration.swift
@@ -8,7 +8,7 @@ enum KeychainMigration {
     private static let log = CodexBarLog.logger(LogCategories.keychainMigration)
     private static let migrationKey = "KeychainMigrationV1Completed"
 
-    struct MigrationItem: Hashable, Sendable {
+    struct MigrationItem: Hashable {
         let service: String
         let account: String?
 
diff --git a/Sources/CodexBar/KeychainPromptCoordinator.swift b/Sources/CodexBar/KeychainPromptCoordinator.swift
index a6add39ab3..d3678e018c 100644
--- a/Sources/CodexBar/KeychainPromptCoordinator.swift
+++ b/Sources/CodexBar/KeychainPromptCoordinator.swift
@@ -2,6 +2,58 @@ import AppKit
 import CodexBarCore
 import SweetCookieKit
 
+private enum KeychainPromptMessage {
+    static let browserCookie =
+        "CodexBar will ask macOS Keychain for “%@” so it can decrypt browser cookies " +
+        "and authenticate your account. Click OK to continue."
+
+    static let claudeOAuth =
+        "CodexBar will ask macOS Keychain for the Claude Code OAuth token " +
+        "so it can fetch your Claude usage. Click OK to continue."
+    static let codexCookie =
+        "CodexBar will ask macOS Keychain for your OpenAI cookie header " +
+        "so it can fetch Codex dashboard extras. Click OK to continue."
+    static let claudeCookie =
+        "CodexBar will ask macOS Keychain for your Claude cookie header " +
+        "so it can fetch Claude web usage. Click OK to continue."
+    static let cursorCookie =
+        "CodexBar will ask macOS Keychain for your Cursor cookie header " +
+        "so it can fetch usage. Click OK to continue."
+    static let openCodeCookie =
+        "CodexBar will ask macOS Keychain for your OpenCode cookie header " +
+        "so it can fetch usage. Click OK to continue."
+    static let factoryCookie =
+        "CodexBar will ask macOS Keychain for your Factory cookie header " +
+        "so it can fetch usage. Click OK to continue."
+    static let zaiToken =
+        "CodexBar will ask macOS Keychain for your z.ai API token " +
+        "so it can fetch usage. Click OK to continue."
+    static let syntheticToken =
+        "CodexBar will ask macOS Keychain for your Synthetic API key " +
+        "so it can fetch usage. Click OK to continue."
+    static let copilotToken =
+        "CodexBar will ask macOS Keychain for your GitHub Copilot token " +
+        "so it can fetch usage. Click OK to continue."
+    static let kimiToken =
+        "CodexBar will ask macOS Keychain for your Kimi auth token " +
+        "so it can fetch usage. Click OK to continue."
+    static let kimiK2Token =
+        "CodexBar will ask macOS Keychain for your Kimi K2 API key " +
+        "so it can fetch usage. Click OK to continue."
+    static let minimaxCookie =
+        "CodexBar will ask macOS Keychain for your MiniMax cookie header " +
+        "so it can fetch usage. Click OK to continue."
+    static let minimaxToken =
+        "CodexBar will ask macOS Keychain for your MiniMax API token " +
+        "so it can fetch usage. Click OK to continue."
+    static let augmentCookie =
+        "CodexBar will ask macOS Keychain for your Augment cookie header " +
+        "so it can fetch usage. Click OK to continue."
+    static let ampCookie =
+        "CodexBar will ask macOS Keychain for your Amp cookie header " +
+        "so it can fetch usage. Click OK to continue."
+}
+
 enum KeychainPromptCoordinator {
     private static let promptLock = NSLock()
     private static let log = CodexBarLog.logger(LogCategories.keychainPrompt)
@@ -13,6 +65,34 @@ enum KeychainPromptCoordinator {
         BrowserCookieKeychainPromptHandler.handler = { context in
             self.presentBrowserCookiePrompt(context)
         }
+        self.disableKeychainForUnbundledExecutableIfNeeded()
+    }
+
+    private static let unbundledExecutableCheckLock = NSLock()
+    private nonisolated(unsafe) static var didCheckUnbundledExecutable = false
+
+    static func disableKeychainForUnbundledExecutableIfNeeded() {
+        self.unbundledExecutableCheckLock.lock()
+        guard !self.didCheckUnbundledExecutable else {
+            self.unbundledExecutableCheckLock.unlock()
+            return
+        }
+        self.didCheckUnbundledExecutable = true
+        self.unbundledExecutableCheckLock.unlock()
+
+        let executablePath = Bundle.main.executableURL?.path ?? ""
+        guard Self.isUnbundledCodexBarExecutable(executablePath) else { return }
+        KeychainAccessGate.forceDisabledForProcess(reason: "unbundled-executable")
+        Self.log.warning(
+            "Unbundled CodexBar executable detected; disabling keychain access to avoid repeated prompts",
+            metadata: ["doc": "docs/DEVELOPMENT_SETUP.md"])
+    }
+
+    static func isUnbundledCodexBarExecutable(_ executablePath: String) -> Bool {
+        guard executablePath.hasPrefix("/") else { return false }
+        let executableURL = URL(fileURLWithPath: executablePath).standardizedFileURL
+        return executableURL.lastPathComponent == "CodexBar"
+            && !executableURL.pathComponents.contains(where: { $0.hasSuffix(".app") })
     }
 
     private static func presentKeychainPrompt(_ context: KeychainPromptContext) {
@@ -22,93 +102,47 @@ enum KeychainPromptCoordinator {
     }
 
     private static func presentBrowserCookiePrompt(_ context: BrowserCookieKeychainPromptContext) {
-        let title = "Keychain Access Required"
-        let message = [
-            "CodexBar will ask macOS Keychain for “\(context.label)” so it can decrypt browser cookies",
-            "and authenticate your account. Click OK to continue.",
-        ].joined(separator: " ")
+        let title = L("Keychain Access Required")
+        let message = L(
+            KeychainPromptMessage.browserCookie,
+            context.label)
         self.log.info("Browser cookie keychain prompt requested", metadata: ["label": context.label])
         self.presentAlert(title: title, message: message)
     }
 
     private static func keychainCopy(for context: KeychainPromptContext) -> (title: String, message: String) {
-        let title = "Keychain Access Required"
+        let title = L("Keychain Access Required")
         switch context.kind {
         case .claudeOAuth:
-            return (title, [
-                "CodexBar will ask macOS Keychain for the Claude Code OAuth token",
-                "so it can fetch your Claude usage. Click OK to continue.",
-            ].joined(separator: " "))
+            return (title, L(KeychainPromptMessage.claudeOAuth))
         case .codexCookie:
-            return (title, [
-                "CodexBar will ask macOS Keychain for your OpenAI cookie header",
-                "so it can fetch Codex dashboard extras. Click OK to continue.",
-            ].joined(separator: " "))
+            return (title, L(KeychainPromptMessage.codexCookie))
         case .claudeCookie:
-            return (title, [
-                "CodexBar will ask macOS Keychain for your Claude cookie header",
-                "so it can fetch Claude web usage. Click OK to continue.",
-            ].joined(separator: " "))
+            return (title, L(KeychainPromptMessage.claudeCookie))
         case .cursorCookie:
-            return (title, [
-                "CodexBar will ask macOS Keychain for your Cursor cookie header",
-                "so it can fetch usage. Click OK to continue.",
-            ].joined(separator: " "))
+            return (title, L(KeychainPromptMessage.cursorCookie))
         case .opencodeCookie:
-            return (title, [
-                "CodexBar will ask macOS Keychain for your OpenCode cookie header",
-                "so it can fetch usage. Click OK to continue.",
-            ].joined(separator: " "))
+            return (title, L(KeychainPromptMessage.openCodeCookie))
         case .factoryCookie:
-            return (title, [
-                "CodexBar will ask macOS Keychain for your Factory cookie header",
-                "so it can fetch usage. Click OK to continue.",
-            ].joined(separator: " "))
+            return (title, L(KeychainPromptMessage.factoryCookie))
         case .zaiToken:
-            return (title, [
-                "CodexBar will ask macOS Keychain for your z.ai API token",
-                "so it can fetch usage. Click OK to continue.",
-            ].joined(separator: " "))
+            return (title, L(KeychainPromptMessage.zaiToken))
         case .syntheticToken:
-            return (title, [
-                "CodexBar will ask macOS Keychain for your Synthetic API key",
-                "so it can fetch usage. Click OK to continue.",
-            ].joined(separator: " "))
+            return (title, L(KeychainPromptMessage.syntheticToken))
         case .copilotToken:
-            return (title, [
-                "CodexBar will ask macOS Keychain for your GitHub Copilot token",
-                "so it can fetch usage. Click OK to continue.",
-            ].joined(separator: " "))
+            return (title, L(KeychainPromptMessage.copilotToken))
         case .kimiToken:
-            return (title, [
-                "CodexBar will ask macOS Keychain for your Kimi auth token",
-                "so it can fetch usage. Click OK to continue.",
-            ].joined(separator: " "))
+            return (title, L(KeychainPromptMessage.kimiToken))
         case .kimiK2Token:
-            return (title, [
-                "CodexBar will ask macOS Keychain for your Kimi K2 API key",
-                "so it can fetch usage. Click OK to continue.",
-            ].joined(separator: " "))
+            return (title, L(KeychainPromptMessage.kimiK2Token))
         case .minimaxCookie:
-            return (title, [
-                "CodexBar will ask macOS Keychain for your MiniMax cookie header",
-                "so it can fetch usage. Click OK to continue.",
-            ].joined(separator: " "))
+            return (title, L(KeychainPromptMessage.minimaxCookie))
         case .minimaxToken:
-            return (title, [
-                "CodexBar will ask macOS Keychain for your MiniMax API token",
-                "so it can fetch usage. Click OK to continue.",
-            ].joined(separator: " "))
+            return (title, L(KeychainPromptMessage.minimaxToken))
         case .augmentCookie:
-            return (title, [
-                "CodexBar will ask macOS Keychain for your Augment cookie header",
-                "so it can fetch usage. Click OK to continue.",
-            ].joined(separator: " "))
+            return (title, L(KeychainPromptMessage.augmentCookie))
         case .ampCookie:
-            return (title, [
-                "CodexBar will ask macOS Keychain for your Amp cookie header",
-                "so it can fetch usage. Click OK to continue.",
-            ].joined(separator: " "))
+            return (title, L(KeychainPromptMessage.ampCookie))
         }
     }
 
@@ -132,9 +166,9 @@ enum KeychainPromptCoordinator {
     @MainActor
     private static func showAlert(title: String, message: String) {
         let alert = NSAlert()
-        alert.messageText = title
-        alert.informativeText = message
-        alert.addButton(withTitle: "OK")
+        alert.messageText = L(title)
+        alert.informativeText = L(message)
+        alert.addButton(withTitle: L("OK"))
         _ = alert.runModal()
     }
 }
diff --git a/Sources/CodexBar/KimiK2TokenStore.swift b/Sources/CodexBar/KimiK2TokenStore.swift
index 9ad23c028d..ed3cf55aa3 100644
--- a/Sources/CodexBar/KimiK2TokenStore.swift
+++ b/Sources/CodexBar/KimiK2TokenStore.swift
@@ -28,6 +28,10 @@ struct KeychainKimiK2TokenStore: KimiK2TokenStoring {
     private let account = "kimi-k2-api-token"
 
     func loadToken() throws -> String? {
+        guard !KeychainAccessGate.isDisabled else {
+            Self.log.debug("Keychain access disabled; skipping token load")
+            return nil
+        }
         var result: CFTypeRef?
         let query: [String: Any] = [
             kSecClass as String: kSecClassGenericPassword,
@@ -66,6 +70,10 @@ struct KeychainKimiK2TokenStore: KimiK2TokenStoring {
     }
 
     func storeToken(_ token: String?) throws {
+        guard !KeychainAccessGate.isDisabled else {
+            Self.log.debug("Keychain access disabled; skipping token store")
+            return
+        }
         let cleaned = token?.trimmingCharacters(in: .whitespacesAndNewlines)
         if cleaned == nil || cleaned?.isEmpty == true {
             try self.deleteTokenIfPresent()
@@ -104,6 +112,7 @@ struct KeychainKimiK2TokenStore: KimiK2TokenStoring {
     }
 
     private func deleteTokenIfPresent() throws {
+        guard !KeychainAccessGate.isDisabled else { return }
         let query: [String: Any] = [
             kSecClass as String: kSecClassGenericPassword,
             kSecAttrService as String: self.service,
diff --git a/Sources/CodexBar/LaunchAtLoginManager.swift b/Sources/CodexBar/LaunchAtLoginManager.swift
index e282efab4d..29d143f0a9 100644
--- a/Sources/CodexBar/LaunchAtLoginManager.swift
+++ b/Sources/CodexBar/LaunchAtLoginManager.swift
@@ -2,6 +2,9 @@ import CodexBarCore
 import ServiceManagement
 
 enum LaunchAtLoginManager {
+    typealias StatusProvider = () -> SMAppService.Status
+    typealias RegistrationAction = () throws -> Void
+
     private static let isRunningTests: Bool = {
         let env = ProcessInfo.processInfo.environment
         if env["XCTestConfigurationFilePath"] != nil { return true }
@@ -13,11 +16,38 @@ enum LaunchAtLoginManager {
     static func setEnabled(_ enabled: Bool) {
         if self.isRunningTests { return }
         let service = SMAppService.mainApp
+        self.setEnabled(
+            enabled,
+            status: { service.status },
+            register: { try service.register() },
+            unregister: { try service.unregister() })
+    }
+
+    static func setEnabled(
+        _ enabled: Bool,
+        status: StatusProvider,
+        register: RegistrationAction,
+        unregister: RegistrationAction)
+    {
         do {
             if enabled {
-                try service.register()
+                switch status() {
+                case .enabled, .requiresApproval:
+                    return
+                case .notRegistered, .notFound:
+                    try register()
+                @unknown default:
+                    try register()
+                }
             } else {
-                try service.unregister()
+                switch status() {
+                case .enabled, .requiresApproval:
+                    try unregister()
+                case .notRegistered, .notFound:
+                    return
+                @unknown default:
+                    try unregister()
+                }
             }
         } catch {
             CodexBarLog.logger(LogCategories.launchAtLogin).error("Failed to update login item: \(error)")
diff --git a/Sources/CodexBar/Localization.swift b/Sources/CodexBar/Localization.swift
new file mode 100644
index 0000000000..38c9d15736
--- /dev/null
+++ b/Sources/CodexBar/Localization.swift
@@ -0,0 +1,234 @@
+import CodexBarCore
+import Foundation
+
+enum CodexBarLocalizationOverride {
+    @TaskLocal static var appLanguage: String?
+}
+
+private func appLanguageDefaults() -> UserDefaults {
+    if Bundle.main.bundleIdentifier != nil {
+        return .standard
+    }
+    if UserDefaults.standard.object(forKey: "appLanguage") != nil {
+        return .standard
+    }
+    // Fallback for running outside a .app bundle (swift run / debug builds)
+    return UserDefaults(suiteName: "CodexBar") ?? .standard
+}
+
+private let isRunningTestsProcessAtStartup: Bool = {
+    let env = ProcessInfo.processInfo.environment
+    if env["XCTestConfigurationFilePath"] != nil { return true }
+    if env["TESTING_LIBRARY_VERSION"] != nil { return true }
+    if env["SWIFT_TESTING"] != nil { return true }
+    return NSClassFromString("XCTestCase") != nil
+}()
+
+private func isRunningTestsProcess() -> Bool {
+    isRunningTestsProcessAtStartup
+}
+
+private func resolvedAppLanguage() -> String {
+    if let override = CodexBarLocalizationOverride.appLanguage {
+        return override
+    }
+    if isRunningTestsProcess() {
+        return "en"
+    }
+    return appLanguageDefaults().string(forKey: "appLanguage") ?? ""
+}
+
+func codexBarLocalizationSignature() -> String {
+    resolvedAppLanguage()
+}
+
+/// Resolving the `.lproj`/resource bundles repeats `Bundle(url:)`/`Bundle(path:)` filesystem lookups,
+/// which are surprisingly hot: every `L(…)` and `codexBarLocalizationSignature()` call runs them, and
+/// menu row bodies (`MetricRow`, `ProviderCostContent`, `UsageMenuCardView.Model`) re-evaluate them on
+/// every closed-menu rebuild tick on the main thread (#1347). The resolved bundles never change unless
+/// the language changes, so cache them. A single lock with compute-happening-outside-the-lock keeps the
+/// disk work off the critical section and avoids re-entrant deadlock when the localized-bundle compute
+/// closure calls back into the resource-bundle accessor.
+private enum LocalizationBundleCache {
+    private static let lock = NSLock()
+    private nonisolated(unsafe) static var resourceBundle: Bundle?
+    private nonisolated(unsafe) static var cachedLanguage: String?
+    private nonisolated(unsafe) static var cachedLocalizedBundle: Bundle?
+
+    static func defaultResourceBundle(_ compute: () -> Bundle) -> Bundle {
+        self.lock.lock()
+        if let resourceBundle {
+            self.lock.unlock()
+            return resourceBundle
+        }
+        self.lock.unlock()
+        let computed = compute()
+        self.lock.lock()
+        resourceBundle = computed
+        self.lock.unlock()
+        return computed
+    }
+
+    static func localizedBundle(forLanguage language: String, _ compute: () -> Bundle) -> Bundle {
+        self.lock.lock()
+        if self.cachedLanguage == language, let cachedLocalizedBundle {
+            let hit = cachedLocalizedBundle
+            self.lock.unlock()
+            return hit
+        }
+        self.lock.unlock()
+        let computed = compute()
+        self.lock.lock()
+        self.cachedLanguage = language
+        cachedLocalizedBundle = computed
+        self.lock.unlock()
+        return computed
+    }
+
+    static func reset() {
+        self.lock.lock()
+        self.resourceBundle = nil
+        self.cachedLanguage = nil
+        self.cachedLocalizedBundle = nil
+        self.lock.unlock()
+    }
+}
+
+func codexBarLocalizationResourceBundle(
+    mainBundle: Bundle = .main,
+    bundleName: String = "CodexBar_CodexBar") -> Bundle
+{
+    // Only the default (process `.main`) resolution is cached: it is constant for the lifetime of the
+    // process. Custom arguments (tests) keep resolving directly so they stay isolated from the cache.
+    guard mainBundle === Bundle.main, bundleName == "CodexBar_CodexBar" else {
+        return resolveLocalizationResourceBundle(mainBundle: mainBundle, bundleName: bundleName)
+    }
+    return LocalizationBundleCache.defaultResourceBundle {
+        resolveLocalizationResourceBundle(mainBundle: mainBundle, bundleName: bundleName)
+    }
+}
+
+private func resolveLocalizationResourceBundle(mainBundle: Bundle, bundleName: String) -> Bundle {
+    guard mainBundle.bundleURL.pathExtension == "app" else {
+        return Bundle.module
+    }
+
+    if let url = mainBundle.url(forResource: bundleName, withExtension: "bundle"),
+       let bundle = Bundle(url: url)
+    {
+        return bundle
+    }
+
+    if let resourceURL = mainBundle.resourceURL?.absoluteURL,
+       let bundle = Bundle(url: resourceURL.appendingPathComponent("\(bundleName).bundle"))
+    {
+        return bundle
+    }
+
+    return mainBundle
+}
+
+private func localizedBundle() -> Bundle {
+    // Keyed on the resolved language so a language switch (settings change or test override) transparently
+    // re-resolves; otherwise the cached bundle is returned without touching the filesystem.
+    let language = resolvedAppLanguage()
+    return LocalizationBundleCache.localizedBundle(forLanguage: language) {
+        resolveLocalizedBundle(forLanguage: language)
+    }
+}
+
+private func resolveLocalizedBundle(forLanguage language: String) -> Bundle {
+    let resourceBundle = codexBarLocalizationResourceBundle()
+    if !language.isEmpty {
+        if let bundle = lprojBundle(named: language, in: resourceBundle) {
+            return bundle
+        }
+    } else {
+        // System mode: follow macOS language preferences
+        if let preferred = resourceBundle.preferredLocalizations.first,
+           let bundle = lprojBundle(named: preferred, in: resourceBundle)
+        {
+            return bundle
+        }
+    }
+    // Fallback to en.lproj
+    if let path = resourceBundle.path(forResource: "en", ofType: "lproj"),
+       let bundle = Bundle(path: path)
+    {
+        return bundle
+    }
+    return resourceBundle
+}
+
+private func lprojBundle(named language: String, in resourceBundle: Bundle) -> Bundle? {
+    let candidates = [language, language.lowercased()]
+    for candidate in candidates where !candidate.isEmpty {
+        if let path = resourceBundle.path(forResource: candidate, ofType: "lproj"),
+           let bundle = Bundle(path: path)
+        {
+            return bundle
+        }
+    }
+    return nil
+}
+
+func L(_ key: String) -> String {
+    let resourceBundle = codexBarLocalizationResourceBundle()
+    return codexBarLocalizedString(key, bundle: localizedBundle(), resourceBundle: resourceBundle)
+}
+
+func L(_ key: String, _ arguments: CVarArg...) -> String {
+    String(format: L(key), arguments: arguments)
+}
+
+func codexBarLocalizedLocale() -> Locale {
+    let language = resolvedAppLanguage()
+    guard !language.isEmpty else { return .current }
+    switch language.lowercased() {
+    case "zh-hans":
+        return Locale(identifier: "zh-Hans")
+    case "zh-hant":
+        return Locale(identifier: "zh-Hant")
+    case "pt-br":
+        return Locale(identifier: "pt-BR")
+    default:
+        return Locale(identifier: language)
+    }
+}
+
+func codexBarLocalizedString(_ key: String, bundle: Bundle, resourceBundle: Bundle) -> String {
+    let value = bundle.localizedString(forKey: key, value: nil, table: nil)
+    let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
+    if !trimmed.isEmpty, value != key {
+        return value
+    }
+
+    guard bundle.bundleURL.lastPathComponent != "en.lproj",
+          let englishBundle = lprojBundle(named: "en", in: resourceBundle)
+    else {
+        return trimmed.isEmpty ? key : value
+    }
+
+    let fallback = englishBundle.localizedString(forKey: key, value: nil, table: nil)
+    return fallback.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty ? key : fallback
+}
+
+#if DEBUG
+func codexBarLocalizedBundleForTesting() -> Bundle {
+    localizedBundle()
+}
+
+func resetCodexBarLocalizationCacheForTesting() {
+    LocalizationBundleCache.reset()
+}
+#endif
+
+func configureUsageFormatterLocalizationProvider() {
+    UsageFormatter.setLocalizationProvider { key in
+        let resourceBundle = codexBarLocalizationResourceBundle()
+        return codexBarLocalizedString(key, bundle: localizedBundle(), resourceBundle: resourceBundle)
+    }
+    UsageFormatter.setLocaleProvider {
+        codexBarLocalizedLocale()
+    }
+}
diff --git a/Sources/CodexBar/MainThreadHangWatchdog.swift b/Sources/CodexBar/MainThreadHangWatchdog.swift
new file mode 100644
index 0000000000..6df99e6cb7
--- /dev/null
+++ b/Sources/CodexBar/MainThreadHangWatchdog.swift
@@ -0,0 +1,311 @@
+import CodexBarCore
+import Foundation
+
+/// Tracks what the main thread is currently doing so hang reports can name the
+/// operation even when the stall happens in uninstrumented code.
+enum MainThreadActivityBreadcrumb {
+    private final class State: @unchecked Sendable {
+        let lock = NSLock()
+        var stack: [String] = []
+    }
+
+    private static let state = State()
+
+    static var current: String? {
+        guard MainThreadHangWatchdog.isEnabledForCurrentProcess else { return nil }
+        return self.state.lock.withLock { self.state.stack.last }
+    }
+
+    static func push(_ label: String) {
+        guard MainThreadHangWatchdog.isEnabledForCurrentProcess else { return }
+        self.state.lock.withLock {
+            self.state.stack.append(label)
+        }
+    }
+
+    static func pop() {
+        guard MainThreadHangWatchdog.isEnabledForCurrentProcess else { return }
+        self.state.lock.withLock {
+            _ = self.state.stack.popLast()
+        }
+    }
+}
+
+/// Detects main-queue response delays and records breadcrumbs for the work that
+/// occupied the main thread. Long hangs launch `/usr/bin/sample` asynchronously
+/// so sampling cannot delay recovery detection or inflate the reported duration.
+final class MainThreadHangWatchdog: @unchecked Sendable {
+    static let shared = MainThreadHangWatchdog()
+    static let isEnabledForCurrentProcess: Bool = {
+        #if DEBUG
+        true
+        #else
+        let environment = ProcessInfo.processInfo.environment
+        return environment["CODEXBAR_MAIN_THREAD_HANG_WATCHDOG"] == "1" ||
+            UserDefaults.standard.bool(forKey: "debugMainThreadHangWatchdog")
+        #endif
+    }()
+
+    private let logger = CodexBarLog.logger(LogCategories.app)
+    private let pingInterval: TimeInterval
+    private let hangThreshold: TimeInterval
+    private let sampleThreshold: TimeInterval
+    private let sampleCooldown: TimeInterval
+    private let sampleCaptureOverride: (@Sendable () -> String?)?
+    private let schedulePing: @Sendable (@escaping @Sendable () -> Void) -> Void
+    private let lock = NSLock()
+    private var isRunning = false
+    private var lastSampleAt: Date?
+    private var activeSampleProcesses: [ObjectIdentifier: Process] = [:]
+    var onHangForTesting: ((TimeInterval, [String]) -> Void)?
+    #if DEBUG
+    var onHangDetectionForTesting: (() -> Void)?
+    private var onSampleAttemptForTesting: (() -> Void)?
+    #endif
+
+    private enum SampleCaptureResult {
+        case coolingDown
+        case attempted(String?)
+    }
+
+    init(
+        pingInterval: TimeInterval = 0.025,
+        hangThreshold: TimeInterval = 0.15,
+        sampleThreshold: TimeInterval = 2.0,
+        sampleCooldown: TimeInterval = 300,
+        sampleCaptureOverride: (@Sendable () -> String?)? = nil,
+        schedulePing: @escaping @Sendable (@escaping @Sendable () -> Void) -> Void = { response in
+            DispatchQueue.main.async(execute: response)
+        })
+    {
+        self.pingInterval = pingInterval
+        self.hangThreshold = hangThreshold
+        self.sampleThreshold = sampleThreshold
+        self.sampleCooldown = sampleCooldown
+        self.sampleCaptureOverride = sampleCaptureOverride
+        self.schedulePing = schedulePing
+    }
+
+    func start() {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        guard !self.isRunning else { return }
+        self.isRunning = true
+        let thread = Thread { [weak self] in self?.run() }
+        thread.name = "CodexBar.MainThreadHangWatchdog"
+        thread.qualityOfService = .utility
+        thread.start()
+    }
+
+    func stop() {
+        self.lock.withLock {
+            self.isRunning = false
+        }
+    }
+
+    private var shouldRun: Bool {
+        self.lock.withLock { self.isRunning }
+    }
+
+    private final class PingBox: @unchecked Sendable {
+        private let lock = NSLock()
+        private let semaphore = DispatchSemaphore(value: 0)
+        private var _respondedAt: DispatchTime?
+
+        func markResponded() {
+            self.lock.withLock {
+                self._respondedAt = .now()
+            }
+            self.semaphore.signal()
+        }
+
+        var respondedAt: DispatchTime? {
+            self.lock.withLock { self._respondedAt }
+        }
+
+        func waitForResponse(timeout: TimeInterval) -> Bool {
+            self.semaphore.wait(timeout: .now() + timeout) == .success
+        }
+    }
+
+    private func run() {
+        while self.shouldRun {
+            let box = PingBox()
+            let pingSentAt = DispatchTime.now()
+            self.schedulePing { box.markResponded() }
+            if !box.waitForResponse(timeout: self.hangThreshold) {
+                guard self.shouldRun else { return }
+                #if DEBUG
+                self.onHangDetectionForTesting?()
+                #endif
+                self.traceHang(box: box, pingSentAt: pingSentAt)
+            }
+            guard self.shouldRun else { return }
+            Thread.sleep(forTimeInterval: self.pingInterval)
+        }
+    }
+
+    private func traceHang(box: PingBox, pingSentAt: DispatchTime) {
+        // One delayed ping can span several main-thread operations, so retain each
+        // distinct breadcrumb observed until the queued ping finally executes.
+        var activities: [String] = []
+        func recordActivity() {
+            guard activities.count < 8,
+                  let activity = MainThreadActivityBreadcrumb.current,
+                  !activities.contains(activity)
+            else { return }
+            activities.append(activity)
+        }
+
+        recordActivity()
+        var sampleFile: String?
+        var didAttemptSample = false
+        while box.respondedAt == nil, self.shouldRun {
+            recordActivity()
+            if !didAttemptSample, self.elapsedSeconds(since: pingSentAt) >= self.sampleThreshold {
+                #if DEBUG
+                self.onSampleAttemptForTesting?()
+                #endif
+                switch self.captureSampleIfAllowed() {
+                case .coolingDown:
+                    break
+                case let .attempted(file):
+                    didAttemptSample = true
+                    sampleFile = file
+                }
+            }
+            Thread.sleep(forTimeInterval: 0.025)
+        }
+        guard let respondedAt = box.respondedAt else { return }
+        let duration = self.elapsedSeconds(from: pingSentAt, to: respondedAt)
+        var metadata: [String: String] = [
+            "durationMs": String(format: "%.0f", duration * 1000),
+            "activity": activities.isEmpty ? "unknown" : activities.joined(separator: ","),
+        ]
+        if let sampleFile {
+            metadata["sampleRequested"] = sampleFile
+        }
+        self.logger.warning("main thread hang", metadata: metadata)
+        self.onHangForTesting?(duration, activities)
+    }
+
+    private func elapsedSeconds(since start: DispatchTime) -> TimeInterval {
+        self.elapsedSeconds(from: start, to: .now())
+    }
+
+    private func elapsedSeconds(from start: DispatchTime, to end: DispatchTime) -> TimeInterval {
+        TimeInterval(end.uptimeNanoseconds - start.uptimeNanoseconds) / 1_000_000_000
+    }
+
+    private func captureSampleIfAllowed() -> SampleCaptureResult {
+        let now = Date()
+        let shouldCapture = self.lock.withLock {
+            if self.lastSampleAt.map({ now.timeIntervalSince($0) < self.sampleCooldown }) ?? false {
+                return false
+            }
+            self.lastSampleAt = now
+            return true
+        }
+        guard shouldCapture else { return .coolingDown }
+
+        let file = if let sampleCaptureOverride {
+            sampleCaptureOverride()
+        } else {
+            self.launchSample()
+        }
+        return .attempted(file)
+    }
+
+    private func launchSample() -> String? {
+        let directory = FileManager.default.homeDirectoryForCurrentUser
+            .appendingPathComponent("Library/Logs/CodexBar", isDirectory: true)
+        do {
+            try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+        } catch {
+            self.logger.warning(
+                "main thread hang sample failed",
+                metadata: ["error": "\(error)"])
+            return nil
+        }
+
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withFullDate, .withTime]
+        let stamp = formatter.string(from: Date()).replacingOccurrences(of: ":", with: "-")
+        let file = directory.appendingPathComponent("hang-sample-\(stamp).txt")
+
+        let process = Process()
+        let processID = ObjectIdentifier(process)
+        process.executableURL = URL(fileURLWithPath: "/usr/bin/sample")
+        process.arguments = ["\(ProcessInfo.processInfo.processIdentifier)", "3", "-file", file.path]
+        process.terminationHandler = { [weak self] completedProcess in
+            self?.sampleDidFinish(completedProcess, processID: processID, file: file)
+        }
+        self.lock.withLock {
+            self.activeSampleProcesses[processID] = process
+        }
+        do {
+            try process.run()
+        } catch {
+            _ = self.lock.withLock {
+                self.activeSampleProcesses.removeValue(forKey: processID)
+            }
+            self.logger.warning(
+                "main thread hang sample failed",
+                metadata: ["error": "\(error)"])
+            return nil
+        }
+        return file.path
+    }
+
+    private func sampleDidFinish(_ process: Process, processID: ObjectIdentifier, file: URL) {
+        _ = self.lock.withLock {
+            self.activeSampleProcesses.removeValue(forKey: processID)
+        }
+        guard process.terminationStatus == 0,
+              FileManager.default.fileExists(atPath: file.path)
+        else {
+            self.logger.warning(
+                "main thread hang sample failed",
+                metadata: ["status": "\(process.terminationStatus)"])
+            return
+        }
+        self.logger.info(
+            "main thread hang sample captured",
+            metadata: ["sample": file.path])
+    }
+
+    #if DEBUG
+    func traceHangForTesting(
+        responseDelay: TimeInterval,
+        waitForSampleAttempt: Bool = false,
+        responseBeforeTrace: Bool = false)
+    {
+        self.lock.withLock {
+            self.isRunning = true
+        }
+        defer {
+            self.lock.withLock {
+                self.isRunning = false
+            }
+            self.onSampleAttemptForTesting = nil
+        }
+
+        let box = PingBox()
+        let pingSentAt = DispatchTime.now()
+        let scheduleResponse = {
+            DispatchQueue.global(qos: .userInitiated).asyncAfter(deadline: .now() + responseDelay) {
+                box.markResponded()
+            }
+        }
+        if responseBeforeTrace {
+            Thread.sleep(forTimeInterval: responseDelay)
+            box.markResponded()
+        } else if waitForSampleAttempt {
+            self.onSampleAttemptForTesting = scheduleResponse
+        } else {
+            scheduleResponse()
+        }
+        self.traceHang(box: box, pingSentAt: pingSentAt)
+    }
+    #endif
+}
diff --git a/Sources/CodexBar/ManagedCodexAccountCoordinator.swift b/Sources/CodexBar/ManagedCodexAccountCoordinator.swift
new file mode 100644
index 0000000000..066a25532f
--- /dev/null
+++ b/Sources/CodexBar/ManagedCodexAccountCoordinator.swift
@@ -0,0 +1,61 @@
+import CodexBarCore
+import Foundation
+import Observation
+
+enum ManagedCodexAccountCoordinatorError: Error, Equatable {
+    case authenticationInProgress
+}
+
+@MainActor
+@Observable
+final class ManagedCodexAccountCoordinator {
+    let service: ManagedCodexAccountService
+    private(set) var isAuthenticatingManagedAccount: Bool = false
+    private(set) var authenticatingManagedAccountID: UUID?
+    private(set) var isRemovingManagedAccount: Bool = false
+    private(set) var removingManagedAccountID: UUID?
+    var onManagedAccountsDidChange: (@MainActor () -> Void)?
+
+    var hasConflictingManagedAccountOperationInFlight: Bool {
+        self.isAuthenticatingManagedAccount || self.isRemovingManagedAccount
+    }
+
+    init(service: ManagedCodexAccountService = ManagedCodexAccountService()) {
+        self.service = service
+    }
+
+    func authenticateManagedAccount(
+        existingAccountID: UUID? = nil,
+        timeout: TimeInterval = 120)
+        async throws -> ManagedCodexAccount
+    {
+        guard self.isAuthenticatingManagedAccount == false else {
+            throw ManagedCodexAccountCoordinatorError.authenticationInProgress
+        }
+
+        self.isAuthenticatingManagedAccount = true
+        self.authenticatingManagedAccountID = existingAccountID
+        defer {
+            self.isAuthenticatingManagedAccount = false
+            self.authenticatingManagedAccountID = nil
+        }
+
+        let account = try await self.service.authenticateManagedAccount(
+            existingAccountID: existingAccountID,
+            timeout: timeout)
+        self.onManagedAccountsDidChange?()
+        return account
+    }
+
+    func removeManagedAccount(id: UUID) async throws {
+        self.isRemovingManagedAccount = true
+        self.removingManagedAccountID = id
+        defer {
+            self.isRemovingManagedAccount = false
+            self.removingManagedAccountID = nil
+        }
+
+        try await self.service.removeManagedAccount(id: id)
+        self.onManagedAccountsDidChange?()
+    }
+}
diff --git a/Sources/CodexBar/ManagedCodexAccountService.swift b/Sources/CodexBar/ManagedCodexAccountService.swift
new file mode 100644
index 0000000000..b4ba6cee18
--- /dev/null
+++ b/Sources/CodexBar/ManagedCodexAccountService.swift
@@ -0,0 +1,497 @@
+import AppKit
+import CodexBarCore
+import Foundation
+
+protocol ManagedCodexHomeProducing: Sendable {
+    func makeHomeURL() -> URL
+    func validateManagedHomeForDeletion(_ url: URL) throws
+}
+
+protocol ManagedCodexLoginRunning: Sendable {
+    func run(homePath: String, timeout: TimeInterval) async -> CodexLoginRunner.Result
+}
+
+protocol ManagedCodexIdentityReading: Sendable {
+    func loadAccountIdentity(homePath: String) throws -> CodexAuthBackedAccount
+}
+
+protocol ManagedCodexWorkspaceResolving: Sendable {
+    func resolveWorkspaceIdentity(homePath: String, providerAccountID: String) async -> CodexOpenAIWorkspaceIdentity?
+    func availableWorkspaceIdentities(homePath: String) async -> [CodexOpenAIWorkspaceIdentity]
+}
+
+extension ManagedCodexWorkspaceResolving {
+    func availableWorkspaceIdentities(homePath _: String) async -> [CodexOpenAIWorkspaceIdentity] {
+        []
+    }
+}
+
+protocol ManagedCodexWorkspaceSelecting: Sendable {
+    @MainActor
+    func selectWorkspace(
+        email: String,
+        currentWorkspaceID: String?,
+        workspaces: [CodexOpenAIWorkspaceIdentity]) async -> CodexOpenAIWorkspaceIdentity?
+}
+
+enum ManagedCodexAccountServiceError: Error, Equatable {
+    case loginFailed(CodexLoginRunner.Result)
+    case missingEmail
+    case workspaceSelectionCancelled
+    case unsafeManagedHome(String)
+}
+
+extension ManagedCodexAccountServiceError {
+    var userFacingMessage: String {
+        switch self {
+        case let .loginFailed(result):
+            CodexLoginAlertPresentation.managedLoginFailureMessage(for: result)
+        case .missingEmail:
+            L("managed_login_missing_email")
+        case .workspaceSelectionCancelled:
+            L("workspace_selection_cancelled")
+        case let .unsafeManagedHome(path):
+            String(format: L("unsafe_managed_home"), path)
+        }
+    }
+}
+
+struct ManagedCodexHomeFactory: ManagedCodexHomeProducing {
+    let root: URL
+
+    init(root: URL = Self.defaultRootURL(), fileManager: FileManager = .default) {
+        let standardizedRoot = root.standardizedFileURL
+        if standardizedRoot.path != root.path {
+            self.root = standardizedRoot
+        } else {
+            self.root = root
+        }
+        _ = fileManager
+    }
+
+    func makeHomeURL() -> URL {
+        self.root.appendingPathComponent(UUID().uuidString, isDirectory: true)
+    }
+
+    func validateManagedHomeForDeletion(_ url: URL) throws {
+        let rootPath = self.root.standardizedFileURL.path
+        let targetPath = url.standardizedFileURL.path
+        let rootPrefix = rootPath.hasSuffix("/") ? rootPath : rootPath + "/"
+        guard targetPath.hasPrefix(rootPrefix), targetPath != rootPath else {
+            throw ManagedCodexAccountServiceError.unsafeManagedHome(url.path)
+        }
+    }
+
+    static func defaultRootURL(fileManager: FileManager = .default) -> URL {
+        let base = fileManager.urls(for: .applicationSupportDirectory, in: .userDomainMask).first
+            ?? fileManager.homeDirectoryForCurrentUser
+        return base
+            .appendingPathComponent("CodexBar", isDirectory: true)
+            .appendingPathComponent("managed-codex-homes", isDirectory: true)
+    }
+}
+
+struct DefaultManagedCodexLoginRunner: ManagedCodexLoginRunning {
+    func run(homePath: String, timeout: TimeInterval) async -> CodexLoginRunner.Result {
+        await CodexLoginRunner.run(homePath: homePath, timeout: timeout)
+    }
+}
+
+struct DefaultManagedCodexIdentityReader: ManagedCodexIdentityReading {
+    func loadAccountIdentity(homePath: String) throws -> CodexAuthBackedAccount {
+        let env = CodexHomeScope.scopedEnvironment(
+            base: ProcessInfo.processInfo.environment,
+            codexHome: homePath)
+        return UsageFetcher(environment: env).loadAuthBackedCodexAccount()
+    }
+}
+
+struct DefaultManagedCodexWorkspaceResolver: ManagedCodexWorkspaceResolving {
+    private let workspaceCache: CodexOpenAIWorkspaceIdentityCache
+
+    init(
+        workspaceCache: CodexOpenAIWorkspaceIdentityCache = CodexOpenAIWorkspaceIdentityCache())
+    {
+        self.workspaceCache = workspaceCache
+    }
+
+    func resolveWorkspaceIdentity(homePath: String, providerAccountID: String) async -> CodexOpenAIWorkspaceIdentity? {
+        let normalizedProviderAccountID = ManagedCodexAccount.normalizeProviderAccountID(providerAccountID)
+            ?? providerAccountID
+        let env = CodexHomeScope.scopedEnvironment(
+            base: ProcessInfo.processInfo.environment,
+            codexHome: homePath)
+
+        if let credentials = try? CodexOAuthCredentialsStore.load(env: env),
+           let authoritativeIdentity = try? await CodexOpenAIWorkspaceResolver.resolve(credentials: credentials)
+        {
+            try? self.workspaceCache.store(authoritativeIdentity)
+            return authoritativeIdentity
+        }
+
+        let cachedLabel = self.workspaceCache.workspaceLabel(for: normalizedProviderAccountID)
+        return CodexOpenAIWorkspaceIdentity(
+            workspaceAccountID: normalizedProviderAccountID,
+            workspaceLabel: cachedLabel)
+    }
+
+    func availableWorkspaceIdentities(homePath: String) async -> [CodexOpenAIWorkspaceIdentity] {
+        let env = CodexHomeScope.scopedEnvironment(
+            base: ProcessInfo.processInfo.environment,
+            codexHome: homePath)
+        guard let credentials = try? CodexOAuthCredentialsStore.load(env: env),
+              let identities = try? await CodexOpenAIWorkspaceResolver.listWorkspaces(credentials: credentials)
+        else {
+            return []
+        }
+
+        for identity in identities {
+            try? self.workspaceCache.store(identity)
+        }
+        return identities
+    }
+}
+
+struct CodexWorkspaceAlertSelector: ManagedCodexWorkspaceSelecting {
+    @MainActor
+    func selectWorkspace(
+        email: String,
+        currentWorkspaceID: String?,
+        workspaces: [CodexOpenAIWorkspaceIdentity]) async -> CodexOpenAIWorkspaceIdentity?
+    {
+        guard workspaces.count > 1 else { return workspaces.first }
+
+        let popup = NSPopUpButton(frame: NSRect(x: 0, y: 0, width: 360, height: 26), pullsDown: false)
+        let sortedWorkspaces = workspaces.sorted { lhs, rhs in
+            self.workspaceTitle(lhs) < self.workspaceTitle(rhs)
+        }
+        for workspace in sortedWorkspaces {
+            popup.addItem(withTitle: self.workspaceTitle(workspace))
+            popup.lastItem?.representedObject = workspace.workspaceAccountID
+        }
+        if let currentWorkspaceID,
+           let selectedIndex = sortedWorkspaces.firstIndex(where: { $0.workspaceAccountID == currentWorkspaceID })
+        {
+            popup.selectItem(at: selectedIndex)
+        }
+
+        let alert = NSAlert()
+        alert.messageText = L("Choose Codex workspace")
+        alert.informativeText = String(format: L("multiple_workspaces_found"), email)
+        alert.alertStyle = .informational
+        alert.accessoryView = popup
+        alert.addButton(withTitle: L("Add Workspace"))
+        alert.addButton(withTitle: L("Cancel"))
+
+        guard alert.runModal() == .alertFirstButtonReturn else {
+            return nil
+        }
+        let selectedWorkspaceID = popup.selectedItem?.representedObject as? String
+        return sortedWorkspaces.first { $0.workspaceAccountID == selectedWorkspaceID }
+    }
+
+    private func workspaceTitle(_ workspace: CodexOpenAIWorkspaceIdentity) -> String {
+        workspace.workspaceLabel ?? workspace.workspaceAccountID
+    }
+}
+
+@MainActor
+final class ManagedCodexAccountService {
+    private let store: any ManagedCodexAccountStoring
+    private let homeFactory: any ManagedCodexHomeProducing
+    private let loginRunner: any ManagedCodexLoginRunning
+    private let identityReader: any ManagedCodexIdentityReading
+    private let workspaceResolver: any ManagedCodexWorkspaceResolving
+    private let workspaceSelector: any ManagedCodexWorkspaceSelecting
+    private let fileManager: FileManager
+
+    init(
+        store: any ManagedCodexAccountStoring,
+        homeFactory: any ManagedCodexHomeProducing,
+        loginRunner: any ManagedCodexLoginRunning,
+        identityReader: any ManagedCodexIdentityReading,
+        workspaceResolver: any ManagedCodexWorkspaceResolving = DefaultManagedCodexWorkspaceResolver(),
+        workspaceSelector: any ManagedCodexWorkspaceSelecting = CodexWorkspaceAlertSelector(),
+        fileManager: FileManager = .default)
+    {
+        self.store = store
+        self.homeFactory = homeFactory
+        self.loginRunner = loginRunner
+        self.identityReader = identityReader
+        self.workspaceResolver = workspaceResolver
+        self.workspaceSelector = workspaceSelector
+        self.fileManager = fileManager
+    }
+
+    convenience init(fileManager: FileManager = .default) {
+        self.init(
+            store: FileManagedCodexAccountStore(fileManager: fileManager),
+            homeFactory: ManagedCodexHomeFactory(fileManager: fileManager),
+            loginRunner: DefaultManagedCodexLoginRunner(),
+            identityReader: DefaultManagedCodexIdentityReader(),
+            workspaceResolver: DefaultManagedCodexWorkspaceResolver(),
+            workspaceSelector: CodexWorkspaceAlertSelector(),
+            fileManager: fileManager)
+    }
+
+    func authenticateManagedAccount(
+        existingAccountID: UUID? = nil,
+        timeout: TimeInterval = 120)
+        async throws -> ManagedCodexAccount
+    {
+        let snapshot = try self.store.loadAccounts()
+        let homeURL = self.homeFactory.makeHomeURL()
+        try self.fileManager.createDirectory(at: homeURL, withIntermediateDirectories: true)
+        let account: ManagedCodexAccount
+        let existingHomePathsToDelete: [String]
+
+        do {
+            let result = await self.loginRunner.run(homePath: homeURL.path, timeout: timeout)
+            guard case .success = result.outcome else { throw ManagedCodexAccountServiceError.loginFailed(result) }
+
+            let identity = try self.identityReader.loadAccountIdentity(homePath: homeURL.path)
+            guard let rawEmail = identity.email?.trimmingCharacters(in: .whitespacesAndNewlines),
+                  !rawEmail.isEmpty
+            else {
+                throw ManagedCodexAccountServiceError.missingEmail
+            }
+            let authenticatedProviderAccountID: String? = switch identity.identity {
+            case let .providerAccount(id):
+                ManagedCodexAccount.normalizeProviderAccountID(id)
+            case .emailOnly, .unresolved:
+                nil
+            }
+            let selectedWorkspace = try await self.selectedWorkspaceIdentity(
+                email: rawEmail,
+                homePath: homeURL.path,
+                authenticatedProviderAccountID: authenticatedProviderAccountID)
+            let providerAccountID = selectedWorkspace?.workspaceAccountID ?? authenticatedProviderAccountID
+            let workspaceIdentity: CodexOpenAIWorkspaceIdentity? = if let selectedWorkspace {
+                selectedWorkspace
+            } else {
+                await self.resolvedWorkspaceIdentity(
+                    homePath: homeURL.path,
+                    providerAccountID: providerAccountID)
+            }
+
+            let now = Date().timeIntervalSince1970
+            let existing = self.reconciledExistingAccount(
+                authenticatedEmail: rawEmail,
+                providerAccountID: providerAccountID,
+                existingAccountID: existingAccountID,
+                snapshot: snapshot)
+            let persistedMetadata = self.persistedProviderMetadata(
+                authenticatedProviderAccountID: providerAccountID,
+                resolvedWorkspaceIdentity: workspaceIdentity,
+                existingAccount: existing)
+
+            account = ManagedCodexAccount(
+                id: existing?.id ?? UUID(),
+                email: rawEmail,
+                providerAccountID: persistedMetadata.providerAccountID,
+                workspaceLabel: persistedMetadata.workspaceLabel,
+                workspaceAccountID: persistedMetadata.workspaceAccountID,
+                authFingerprint: CodexAuthFingerprint.fingerprint(
+                    homePath: homeURL.path,
+                    fileManager: self.fileManager),
+                managedHomePath: homeURL.path,
+                createdAt: existing?.createdAt ?? now,
+                updatedAt: now,
+                lastAuthenticatedAt: now)
+            let replacedAccountIDs = self.replacedAccountIDs(
+                authenticatedEmail: rawEmail,
+                providerAccountID: providerAccountID,
+                existingAccountID: existingAccountID,
+                matchedAccountID: existing?.id,
+                snapshot: snapshot)
+            existingHomePathsToDelete = snapshot.accounts
+                .filter { replacedAccountIDs.contains($0.id) }
+                .map(\.managedHomePath)
+
+            let updatedSnapshot = ManagedCodexAccountSet(
+                version: snapshot.version,
+                accounts: snapshot.accounts.filter { replacedAccountIDs.contains($0.id) == false } + [account])
+            try self.store.storeAccounts(updatedSnapshot)
+        } catch {
+            try? self.removeManagedHomeIfSafe(atPath: homeURL.path)
+            throw error
+        }
+
+        for existingHomePathToDelete in existingHomePathsToDelete where existingHomePathToDelete != homeURL.path {
+            try? self.removeManagedHomeIfSafe(atPath: existingHomePathToDelete)
+        }
+        return account
+    }
+
+    func removeManagedAccount(id: UUID) async throws {
+        let snapshot = try self.store.loadAccounts()
+        guard let account = snapshot.account(id: id) else { return }
+
+        let homeURL = URL(fileURLWithPath: account.managedHomePath, isDirectory: true)
+        let canDeleteHome = (try? self.homeFactory.validateManagedHomeForDeletion(homeURL)) != nil
+
+        let remaining = snapshot.accounts.filter { $0.id != id }
+        try self.store.storeAccounts(ManagedCodexAccountSet(
+            version: snapshot.version,
+            accounts: remaining))
+
+        if canDeleteHome, self.fileManager.fileExists(atPath: homeURL.path) {
+            try? self.fileManager.removeItem(at: homeURL)
+        }
+    }
+
+    private func removeManagedHomeIfSafe(atPath path: String) throws {
+        let homeURL = URL(fileURLWithPath: path, isDirectory: true)
+        try self.homeFactory.validateManagedHomeForDeletion(homeURL)
+        if self.fileManager.fileExists(atPath: homeURL.path) {
+            try self.fileManager.removeItem(at: homeURL)
+        }
+    }
+
+    private func selectedWorkspaceIdentity(
+        email: String,
+        homePath: String,
+        authenticatedProviderAccountID: String?) async throws -> CodexOpenAIWorkspaceIdentity?
+    {
+        let workspaces = await self.workspaceResolver.availableWorkspaceIdentities(homePath: homePath)
+        guard workspaces.count > 1 else {
+            return workspaces.first { $0.workspaceAccountID == authenticatedProviderAccountID }
+        }
+        guard let selected = await self.workspaceSelector.selectWorkspace(
+            email: email,
+            currentWorkspaceID: authenticatedProviderAccountID,
+            workspaces: workspaces)
+        else {
+            throw ManagedCodexAccountServiceError.workspaceSelectionCancelled
+        }
+        try self.persistSelectedWorkspaceID(selected.workspaceAccountID, homePath: homePath)
+        return selected
+    }
+
+    private func resolvedWorkspaceIdentity(
+        homePath: String,
+        providerAccountID: String?) async -> CodexOpenAIWorkspaceIdentity?
+    {
+        guard let providerAccountID else { return nil }
+        return await self.workspaceResolver.resolveWorkspaceIdentity(
+            homePath: homePath,
+            providerAccountID: providerAccountID)
+    }
+
+    private func persistSelectedWorkspaceID(_ workspaceID: String, homePath: String) throws {
+        let env = CodexHomeScope.scopedEnvironment(
+            base: ProcessInfo.processInfo.environment,
+            codexHome: homePath)
+        let credentials = try CodexOAuthCredentialsStore.load(env: env)
+        try CodexOAuthCredentialsStore.save(
+            CodexOAuthCredentials(
+                accessToken: credentials.accessToken,
+                refreshToken: credentials.refreshToken,
+                idToken: credentials.idToken,
+                accountId: workspaceID,
+                lastRefresh: credentials.lastRefresh),
+            env: env)
+    }
+
+    private func reconciledExistingAccount(
+        authenticatedEmail: String,
+        providerAccountID: String?,
+        existingAccountID: UUID?,
+        snapshot: ManagedCodexAccountSet)
+        -> ManagedCodexAccount?
+    {
+        if let providerAccountID,
+           let existingByProviderAccountID = snapshot.account(
+               email: authenticatedEmail,
+               providerAccountID: providerAccountID)
+        {
+            return existingByProviderAccountID
+        }
+        if let existingAccountID,
+           let existingByID = snapshot.account(id: existingAccountID),
+           existingByID.email == Self.normalizeEmail(authenticatedEmail),
+           providerAccountID == nil || existingByID.providerAccountID == nil
+        {
+            return existingByID
+        }
+        guard providerAccountID == nil else {
+            return nil
+        }
+        // Email-only reconciliation is a legacy/hardening fallback. Once an auth payload carries a
+        // provider account ID, matching must stay on that ID so same-email workspaces can coexist.
+        return snapshot.account(email: authenticatedEmail)
+    }
+
+    private func replacedAccountIDs(
+        authenticatedEmail: String,
+        providerAccountID: String?,
+        existingAccountID: UUID?,
+        matchedAccountID: UUID?,
+        snapshot: ManagedCodexAccountSet) -> Set<UUID>
+    {
+        var ids: Set<UUID> = []
+        let normalizedEmail = Self.normalizeEmail(authenticatedEmail)
+        if let matchedAccountID {
+            ids.insert(matchedAccountID)
+        }
+
+        if providerAccountID != nil {
+            let legacySameEmailIDs = snapshot.accounts
+                .filter {
+                    $0.id != matchedAccountID &&
+                        $0.providerAccountID == nil &&
+                        $0.email == normalizedEmail
+                }
+                .map(\.id)
+            ids.formUnion(legacySameEmailIDs)
+        }
+
+        guard let existingAccountID,
+              existingAccountID != matchedAccountID,
+              let existingByID = snapshot.account(id: existingAccountID)
+        else {
+            return ids
+        }
+
+        if existingByID.providerAccountID == nil,
+           existingByID.email == normalizedEmail,
+           providerAccountID != nil
+        {
+            ids.insert(existingAccountID)
+        }
+        return ids
+    }
+
+    private static func normalizeEmail(_ email: String) -> String {
+        email.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+    }
+
+    private func persistedProviderMetadata(
+        authenticatedProviderAccountID: String?,
+        resolvedWorkspaceIdentity: CodexOpenAIWorkspaceIdentity?,
+        existingAccount: ManagedCodexAccount?) -> (
+        providerAccountID: String?,
+        workspaceLabel: String?,
+        workspaceAccountID: String?)
+    {
+        if let authenticatedProviderAccountID {
+            let isExistingProviderMatch = existingAccount?.providerAccountID == authenticatedProviderAccountID
+            return (
+                providerAccountID: authenticatedProviderAccountID,
+                workspaceLabel: resolvedWorkspaceIdentity?.workspaceLabel
+                    ?? (isExistingProviderMatch ? existingAccount?.workspaceLabel : nil),
+                workspaceAccountID: resolvedWorkspaceIdentity?.workspaceAccountID ??
+                    (isExistingProviderMatch ? existingAccount?.workspaceAccountID : nil) ??
+                    authenticatedProviderAccountID)
+        }
+
+        guard let existingAccount, existingAccount.providerAccountID != nil else {
+            return (providerAccountID: nil, workspaceLabel: nil, workspaceAccountID: nil)
+        }
+
+        return (
+            providerAccountID: existingAccount.providerAccountID,
+            workspaceLabel: existingAccount.workspaceLabel,
+            workspaceAccountID: existingAccount.workspaceAccountID ?? existingAccount.providerAccountID)
+    }
+}
diff --git a/Sources/CodexBar/MemoryPressureMonitor.swift b/Sources/CodexBar/MemoryPressureMonitor.swift
new file mode 100644
index 0000000000..3b2e3fc8a2
--- /dev/null
+++ b/Sources/CodexBar/MemoryPressureMonitor.swift
@@ -0,0 +1,139 @@
+import CodexBarCore
+import Dispatch
+import Foundation
+
+@MainActor
+struct MemoryPressureCacheTrimSummary: Equatable {
+    var menuCardHeights = 0
+    var menuWidths = 0
+    var mergedSwitcherSelections = 0
+    var recycledMenuCardViews = 0
+    var openAIWebDebugLines = 0
+
+    var total: Int {
+        self.menuCardHeights +
+            self.menuWidths +
+            self.mergedSwitcherSelections +
+            self.recycledMenuCardViews +
+            self.openAIWebDebugLines
+    }
+
+    var metadata: [String: String] {
+        [
+            "menuCardHeights": "\(self.menuCardHeights)",
+            "menuWidths": "\(self.menuWidths)",
+            "mergedSwitcherSelections": "\(self.mergedSwitcherSelections)",
+            "recycledMenuCardViews": "\(self.recycledMenuCardViews)",
+            "openAIWebDebugLines": "\(self.openAIWebDebugLines)",
+            "total": "\(self.total)",
+        ]
+    }
+
+    mutating func merge(_ other: MemoryPressureCacheTrimSummary) {
+        self.menuCardHeights += other.menuCardHeights
+        self.menuWidths += other.menuWidths
+        self.mergedSwitcherSelections += other.mergedSwitcherSelections
+        self.recycledMenuCardViews += other.recycledMenuCardViews
+        self.openAIWebDebugLines += other.openAIWebDebugLines
+    }
+}
+
+@MainActor
+final class MemoryPressureMonitor {
+    typealias CacheTrimHandler = @MainActor () -> MemoryPressureCacheTrimSummary
+
+    private let logger = CodexBarLog.logger(LogCategories.memoryPressure)
+    private let releaseFreeMallocPages: @Sendable () -> Void
+    private let trimAppCaches: CacheTrimHandler
+    private var source: DispatchSourceMemoryPressure?
+
+    init(
+        trimAppCaches: @escaping CacheTrimHandler = { MemoryPressureCacheTrimSummary() },
+        releaseFreeMallocPages: @escaping @Sendable () -> Void = {
+            MemoryPressureRelief.releaseFreeMallocPages()
+        })
+    {
+        self.trimAppCaches = trimAppCaches
+        self.releaseFreeMallocPages = releaseFreeMallocPages
+    }
+
+    func start() {
+        guard self.source == nil else { return }
+
+        let source = DispatchSource.makeMemoryPressureSource(
+            eventMask: [.warning, .critical],
+            queue: .global(qos: .utility))
+        source.setEventHandler(handler: Self.makeEventHandler(
+            eventReader: { [weak source] in source?.data ?? [] },
+            handle: { [weak self] isWarning, isCritical in
+                self?.handleMemoryPressure(isWarning: isWarning, isCritical: isCritical)
+            }))
+        self.source = source
+        source.resume()
+    }
+
+    nonisolated static func makeEventHandler(
+        eventReader: @escaping @Sendable () -> DispatchSource.MemoryPressureEvent,
+        handle: @escaping @MainActor @Sendable (_ isWarning: Bool, _ isCritical: Bool) -> Void)
+        -> @Sendable () -> Void
+    {
+        // DispatchSource invokes this on the utility queue. Keep the handler
+        // nonisolated, then hop to MainActor for app-state cleanup.
+        { @Sendable in
+            let event = eventReader()
+            let isWarning = event.contains(.warning)
+            let isCritical = event.contains(.critical)
+            Task { @MainActor in
+                handle(isWarning, isCritical)
+            }
+        }
+    }
+
+    func stop() {
+        self.source?.cancel()
+        self.source = nil
+    }
+
+    deinit {
+        self.source?.cancel()
+    }
+
+    #if DEBUG
+    func handleMemoryPressureForTesting(isWarning: Bool, isCritical: Bool) {
+        self.handleMemoryPressure(isWarning: isWarning, isCritical: isCritical)
+    }
+    #endif
+
+    private func handleMemoryPressure(isWarning: Bool, isCritical: Bool) {
+        let level = if isCritical {
+            "critical"
+        } else if isWarning {
+            "warning"
+        } else {
+            "normal"
+        }
+        self.logger.warning("System memory pressure", metadata: ["level": level])
+        #if DEBUG
+        let cachedWebViewsBefore = OpenAIDashboardFetcher.cachedWebViewCountForTesting()
+        #endif
+        OpenAIDashboardFetcher.evictIdleCachedWebViews()
+        #if DEBUG
+        let cachedWebViewsAfter = OpenAIDashboardFetcher.cachedWebViewCountForTesting()
+        self.logger.info(
+            "Memory pressure OpenAI webview cache",
+            metadata: [
+                "before": "\(cachedWebViewsBefore)",
+                "after": "\(cachedWebViewsAfter)",
+                "evicted": "\(max(0, cachedWebViewsBefore - cachedWebViewsAfter))",
+            ])
+        #endif
+        let trimSummary = self.trimAppCaches()
+        if trimSummary.total > 0 {
+            self.logger.info("Trimmed app caches for memory pressure", metadata: trimSummary.metadata)
+        }
+        let releaseFreeMallocPages = self.releaseFreeMallocPages
+        Task.detached(priority: .utility) {
+            releaseFreeMallocPages()
+        }
+    }
+}
diff --git a/Sources/CodexBar/MemoryPressureRelief.swift b/Sources/CodexBar/MemoryPressureRelief.swift
new file mode 100644
index 0000000000..7a2162e348
--- /dev/null
+++ b/Sources/CodexBar/MemoryPressureRelief.swift
@@ -0,0 +1,7 @@
+import Darwin
+
+enum MemoryPressureRelief {
+    static func releaseFreeMallocPages() {
+        _ = malloc_zone_pressure_relief(nil, 0)
+    }
+}
diff --git a/Sources/CodexBar/MenuBarDisplayMode.swift b/Sources/CodexBar/MenuBarDisplayMode.swift
index 8daa30ccfd..24c6d25249 100644
--- a/Sources/CodexBar/MenuBarDisplayMode.swift
+++ b/Sources/CodexBar/MenuBarDisplayMode.swift
@@ -5,6 +5,7 @@ enum MenuBarDisplayMode: String, CaseIterable, Identifiable {
     case percent
     case pace
     case both
+    case resetTime
 
     var id: String {
         self.rawValue
@@ -12,17 +13,19 @@ enum MenuBarDisplayMode: String, CaseIterable, Identifiable {
 
     var label: String {
         switch self {
-        case .percent: "Percent"
-        case .pace: "Pace"
-        case .both: "Both"
+        case .percent: L("display_mode_percent")
+        case .pace: L("display_mode_pace")
+        case .both: L("display_mode_both")
+        case .resetTime: L("display_mode_reset_time")
         }
     }
 
     var description: String {
         switch self {
-        case .percent: "Show remaining/used percentage (e.g. 45%)"
-        case .pace: "Show pace indicator (e.g. +5%)"
-        case .both: "Show both percentage and pace (e.g. 45% · +5%)"
+        case .percent: L("display_mode_percent_desc")
+        case .pace: L("display_mode_pace_desc")
+        case .both: L("display_mode_both_desc")
+        case .resetTime: L("display_mode_reset_time_desc")
         }
     }
 }
diff --git a/Sources/CodexBar/MenuBarDisplayText.swift b/Sources/CodexBar/MenuBarDisplayText.swift
index 283cb77340..824bb41e29 100644
--- a/Sources/CodexBar/MenuBarDisplayText.swift
+++ b/Sources/CodexBar/MenuBarDisplayText.swift
@@ -16,22 +16,84 @@ enum MenuBarDisplayText {
         return "\(sign)\(deltaValue)%"
     }
 
+    static func codexCombinedPercentText(
+        sessionWindow: RateWindow?,
+        weeklyWindow: RateWindow?,
+        showUsed: Bool)
+        -> String?
+    {
+        var parts: [String] = []
+        if let sessionWindow,
+           let session = self.percentText(window: sessionWindow, showUsed: showUsed)
+        {
+            parts.append("\(self.codexSessionLabel(window: sessionWindow)) \(session)")
+        }
+        if let weekly = self.percentText(window: weeklyWindow, showUsed: showUsed) {
+            parts.append("W \(weekly)")
+        }
+        return parts.isEmpty ? nil : parts.joined(separator: " · ")
+    }
+
+    private static func codexSessionLabel(window: RateWindow) -> String {
+        guard let minutes = window.windowMinutes, minutes > 0 else { return "S" }
+        guard minutes.isMultiple(of: 60) else { return "\(minutes)m" }
+        return "\(minutes / 60)h"
+    }
+
     static func displayText(
         mode: MenuBarDisplayMode,
         percentWindow: RateWindow?,
         pace: UsagePace? = nil,
-        showUsed: Bool) -> String?
+        showUsed: Bool,
+        resetTimeDisplayStyle: ResetTimeDisplayStyle = .countdown,
+        now: Date = .init()) -> String?
     {
         switch mode {
         case .percent:
             return self.percentText(window: percentWindow, showUsed: showUsed)
         case .pace:
+            // Pace can be temporarily unavailable near a reset or when a provider omits window metadata.
+            // Keep the selected quota visible instead of collapsing the status item to an icon-only state.
             return self.paceText(pace: pace)
+                ?? self.percentText(window: percentWindow, showUsed: showUsed)
         case .both:
             guard let percent = percentText(window: percentWindow, showUsed: showUsed) else { return nil }
-            let paceText: String? = Self.paceText(pace: pace)
-            guard let paceText else { return nil }
+            // Fall back to percent-only when pace is unavailable (e.g. Copilot)
+            guard let paceText = Self.paceText(pace: pace) else { return percent }
             return "\(percent) · \(paceText)"
+        case .resetTime:
+            guard let percentWindow else { return nil }
+            if let resetsAt = percentWindow.resetsAt {
+                let description = switch resetTimeDisplayStyle {
+                case .countdown:
+                    UsageFormatter.resetCountdownDescription(from: resetsAt, now: now)
+                case .absolute:
+                    UsageFormatter.resetDescription(from: resetsAt, now: now)
+                }
+                return "↻ \(description)"
+            }
+            if let resetDescription = self.resetMetadataText(percentWindow.resetDescription) {
+                return "↻ \(resetDescription)"
+            }
+            return self.percentText(window: percentWindow, showUsed: showUsed)
         }
     }
+
+    private static func resetMetadataText(_ description: String?) -> String? {
+        guard let description else { return nil }
+        let trimmed = description.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else { return nil }
+
+        // RateWindow.resetDescription predates provider-specific detail fields and is also used for
+        // request/token summaries. Only trust phrases that explicitly describe reset timing.
+        let normalized = trimmed.lowercased()
+        let resetPrefixes = [
+            "reset ", "resets ", "in ", "today ", "today,", "tomorrow ", "tomorrow,", "next ",
+            "expire ", "expires ", "refill ", "refills ",
+        ]
+        let exactResetDescriptions = ["today", "tomorrow", "expired", "now", "soon"]
+        return exactResetDescriptions.contains(normalized) || resetPrefixes.contains(where: normalized.hasPrefix)
+            ? trimmed
+            : nil
+    }
 }
diff --git a/Sources/CodexBar/MenuBarMetricWindowResolver.swift b/Sources/CodexBar/MenuBarMetricWindowResolver.swift
new file mode 100644
index 0000000000..f6041204c2
--- /dev/null
+++ b/Sources/CodexBar/MenuBarMetricWindowResolver.swift
@@ -0,0 +1,272 @@
+import CodexBarCore
+import Foundation
+
+enum MenuBarMetricWindowResolver {
+    private enum Lane {
+        case primary
+        case secondary
+        case tertiary
+    }
+
+    static func rateWindow(
+        preference: MenuBarMetricPreference,
+        provider: UsageProvider,
+        snapshot: UsageSnapshot?,
+        supportsAverage: Bool)
+        -> RateWindow?
+    {
+        guard let snapshot else { return nil }
+        switch preference {
+        case .monthlyPlan:
+            return snapshot.extraRateWindows?.first { $0.id == "mistral-monthly-plan" }?.window
+        case .extraUsage:
+            return Self.extraUsageWindow(snapshot: snapshot)
+        case .tertiary:
+            return Self.requestedWindow(
+                provider: provider,
+                snapshot: snapshot,
+                lanes: Self.tertiaryOrder(for: provider))
+        case .primary:
+            return Self.requestedWindow(
+                provider: provider,
+                snapshot: snapshot,
+                lanes: Self.primaryOrder(for: provider))
+        case .secondary:
+            return Self.requestedWindow(
+                provider: provider,
+                snapshot: snapshot,
+                lanes: Self.secondaryOrder(for: provider))
+        case .primaryAndSecondary:
+            return Self.mostConstrainedWindow(
+                primary: snapshot.primary,
+                secondary: snapshot.secondary,
+                tertiary: nil)
+        case .average:
+            return Self.averageWindow(provider: provider, snapshot: snapshot, supportsAverage: supportsAverage)
+        case .automatic:
+            return Self.automaticWindow(provider: provider, snapshot: snapshot)
+        }
+    }
+
+    private static func tertiaryOrder(for provider: UsageProvider) -> [Lane] {
+        if provider == .zai {
+            return [.tertiary, .primary, .secondary]
+        }
+        if provider == .perplexity || provider == .cursor || provider == .antigravity {
+            return [.tertiary, .secondary, .primary]
+        }
+        return [.primary, .secondary]
+    }
+
+    private static func primaryOrder(for provider: UsageProvider) -> [Lane] {
+        if provider == .zai {
+            return [.primary, .tertiary, .secondary]
+        }
+        if provider == .perplexity || provider == .antigravity {
+            return [.primary, .secondary, .tertiary]
+        }
+        return [.primary, .secondary]
+    }
+
+    private static func secondaryOrder(for provider: UsageProvider) -> [Lane] {
+        if provider == .zai || provider == .antigravity {
+            return [.secondary, .primary, .tertiary]
+        }
+        if provider == .perplexity {
+            return [.secondary, .tertiary, .primary]
+        }
+        return [.secondary, .primary]
+    }
+
+    private static func averageWindow(
+        provider: UsageProvider,
+        snapshot: UsageSnapshot,
+        supportsAverage: Bool)
+        -> RateWindow?
+    {
+        guard supportsAverage,
+              let primary = snapshot.primary,
+              let secondary = snapshot.secondary
+        else {
+            if provider == .antigravity {
+                return self.window(in: snapshot, following: [.primary, .secondary, .tertiary])
+            }
+            return snapshot.primary ?? snapshot.secondary
+        }
+
+        let usedPercent = (primary.usedPercent + secondary.usedPercent) / 2
+        return RateWindow(usedPercent: usedPercent, windowMinutes: nil, resetsAt: nil, resetDescription: nil)
+    }
+
+    private static func automaticWindow(provider: UsageProvider, snapshot: UsageSnapshot) -> RateWindow? {
+        if provider == .antigravity {
+            if let window = mostConstrainedAntigravityQuotaSummaryWindow(snapshot: snapshot) {
+                return window
+            }
+            return self.mostConstrainedWindow(
+                primary: snapshot.primary,
+                secondary: snapshot.secondary,
+                tertiary: snapshot.tertiary)
+                ?? self.mostConstrainedAntigravityLegacyExtraWindow(snapshot: snapshot)
+        }
+        if provider == .perplexity {
+            return snapshot.automaticPerplexityWindow()
+        }
+        if provider == .zai {
+            return self.mostConstrainedWindow(
+                primary: snapshot.primary,
+                secondary: snapshot.tertiary,
+                tertiary: nil) ?? snapshot.secondary
+        }
+        if provider == .factory || provider == .kimi {
+            return snapshot.secondary ?? snapshot.primary
+        }
+        if provider == .litellm {
+            return snapshot.secondary ?? snapshot.primary
+        }
+        if provider == .copilot,
+           let primary = snapshot.primary,
+           let secondary = snapshot.secondary
+        {
+            return primary.usedPercent >= secondary.usedPercent ? primary : secondary
+        }
+        if provider == .cursor {
+            return Self.mostConstrainedCursorWindow(
+                total: snapshot.primary,
+                auto: snapshot.secondary,
+                api: snapshot.tertiary)
+        }
+        if provider == .minimax {
+            return Self.mostConstrainedWindow(
+                primary: snapshot.primary,
+                secondary: snapshot.secondary,
+                tertiary: snapshot.tertiary)
+        }
+        if provider == .claude,
+           Self.shouldUseClaudeSpendLimit(providerCost: snapshot.providerCost, snapshot: snapshot),
+           let extraUsage = Self.extraUsageWindow(snapshot: snapshot)
+        {
+            return extraUsage
+        }
+        return snapshot.primary ?? snapshot.secondary
+    }
+
+    private static let antigravityQuotaSummaryWindowIDPrefix = "antigravity-quota-summary-"
+    private static let antigravityCompactFallbackWindowIDPrefix = "antigravity-compact-fallback-"
+
+    private static func mostConstrainedAntigravityQuotaSummaryWindow(snapshot: UsageSnapshot) -> RateWindow? {
+        let windows = snapshot.extraRateWindows?
+            .filter { $0.usageKnown && $0.id.hasPrefix(Self.antigravityQuotaSummaryWindowIDPrefix) }
+            .map(\.window) ?? []
+        guard !windows.isEmpty else { return nil }
+
+        let usableWindows = windows.filter { $0.usedPercent < 100 }
+        if let maxUsable = usableWindows.max(by: { $0.usedPercent < $1.usedPercent }) {
+            return maxUsable
+        }
+        return windows.max(by: { $0.usedPercent < $1.usedPercent })
+    }
+
+    private static func mostConstrainedAntigravityLegacyExtraWindow(snapshot: UsageSnapshot) -> RateWindow? {
+        let windows = snapshot.extraRateWindows?
+            .filter {
+                $0.usageKnown && $0.id.hasPrefix(Self.antigravityCompactFallbackWindowIDPrefix)
+            }
+            .map(\.window) ?? []
+        guard !windows.isEmpty else { return nil }
+
+        let usableWindows = windows.filter { $0.usedPercent < 100 }
+        if let maxUsable = usableWindows.max(by: { $0.usedPercent < $1.usedPercent }) {
+            return maxUsable
+        }
+        return windows.max(by: { $0.usedPercent < $1.usedPercent })
+    }
+
+    private static func requestedWindow(
+        provider: UsageProvider,
+        snapshot: UsageSnapshot,
+        lanes: [Lane]) -> RateWindow?
+    {
+        self.window(in: snapshot, following: lanes)
+            ?? (provider == .antigravity
+                ? self.mostConstrainedAntigravityLegacyExtraWindow(snapshot: snapshot)
+                : nil)
+    }
+
+    private static func window(in snapshot: UsageSnapshot, following lanes: [Lane]) -> RateWindow? {
+        for lane in lanes {
+            if let window = self.window(in: snapshot, lane: lane) {
+                return window
+            }
+        }
+        return nil
+    }
+
+    private static func window(in snapshot: UsageSnapshot, lane: Lane) -> RateWindow? {
+        switch lane {
+        case .primary:
+            snapshot.primary
+        case .secondary:
+            snapshot.secondary
+        case .tertiary:
+            snapshot.tertiary
+        }
+    }
+
+    private static func mostConstrainedWindow(
+        primary: RateWindow?,
+        secondary: RateWindow?,
+        tertiary: RateWindow?)
+        -> RateWindow?
+    {
+        let windows = [primary, secondary, tertiary].compactMap(\.self)
+        guard !windows.isEmpty else { return nil }
+        return windows.max(by: { $0.usedPercent < $1.usedPercent })
+    }
+
+    private static func mostConstrainedCursorWindow(
+        total: RateWindow?,
+        auto: RateWindow?,
+        api: RateWindow?)
+        -> RateWindow?
+    {
+        if let total, total.usedPercent >= 100 {
+            return total
+        }
+
+        let subquotaWindows = [auto, api].compactMap(\.self)
+        let usableSubquotaWindows = subquotaWindows.filter { $0.usedPercent < 100 }
+        if !subquotaWindows.isEmpty, usableSubquotaWindows.isEmpty {
+            return subquotaWindows.max(by: { $0.usedPercent < $1.usedPercent })
+        }
+
+        return ([total].compactMap(\.self) + usableSubquotaWindows)
+            .max(by: { $0.usedPercent < $1.usedPercent })
+    }
+
+    private static func shouldUseClaudeSpendLimit(
+        providerCost: ProviderCostSnapshot?,
+        snapshot: UsageSnapshot)
+        -> Bool
+    {
+        guard providerCost?.limit ?? 0 > 0,
+              snapshot.secondary == nil,
+              snapshot.tertiary == nil
+        else { return false }
+        guard let primary = snapshot.primary else { return true }
+        return primary.usedPercent == 0
+            && primary.windowMinutes == 5 * 60
+            && primary.resetsAt == nil
+            && primary.resetDescription == nil
+    }
+
+    private static func extraUsageWindow(snapshot: UsageSnapshot?) -> RateWindow? {
+        guard let cost = snapshot?.providerCost, cost.limit > 0 else { return nil }
+        let usedPercent = max(0, min(100, (cost.used / cost.limit) * 100))
+        return RateWindow(
+            usedPercent: usedPercent,
+            windowMinutes: nil,
+            resetsAt: cost.resetsAt,
+            resetDescription: nil)
+    }
+}
diff --git a/Sources/CodexBar/MenuBarStatusItemDefaultsRepair.swift b/Sources/CodexBar/MenuBarStatusItemDefaultsRepair.swift
new file mode 100644
index 0000000000..6e7c6cafd6
--- /dev/null
+++ b/Sources/CodexBar/MenuBarStatusItemDefaultsRepair.swift
@@ -0,0 +1,45 @@
+import Foundation
+
+enum MenuBarStatusItemDefaultsRepair {
+    static let didRepairKey = "hasRepairedHiddenStatusItemVisibilityDefaults"
+    private static let visibilityPrefix = "NSStatusItem VisibleCC "
+    private static let legacyAutosavePrefix = "codexbar-"
+
+    static func repairHiddenVisibilityDefaultsIfNeeded(defaults: UserDefaults) -> [String] {
+        guard !defaults.bool(forKey: self.didRepairKey) else { return [] }
+
+        let repairedKeys = defaults.dictionaryRepresentation().keys
+            .filter { key in
+                self.shouldRepair(key: key, value: defaults.object(forKey: key))
+            }
+            .sorted()
+
+        for key in repairedKeys {
+            defaults.removeObject(forKey: key)
+        }
+        defaults.set(true, forKey: self.didRepairKey)
+        return repairedKeys
+    }
+
+    static func shouldRepair(key: String, value: Any?) -> Bool {
+        guard key.hasPrefix(self.visibilityPrefix), self.isFalse(value) else { return false }
+        let itemName = String(key.dropFirst(self.visibilityPrefix.count))
+        return itemName.hasPrefix(self.legacyAutosavePrefix) || self.isDefaultStatusItemName(itemName)
+    }
+
+    private static func isDefaultStatusItemName(_ itemName: String) -> Bool {
+        guard itemName.hasPrefix("Item-") else { return false }
+        return itemName.dropFirst("Item-".count).allSatisfy(\.isNumber)
+    }
+
+    private static func isFalse(_ value: Any?) -> Bool {
+        switch value {
+        case let number as NSNumber:
+            !number.boolValue
+        case let bool as Bool:
+            !bool
+        default:
+            false
+        }
+    }
+}
diff --git a/Sources/CodexBar/MenuBarStatusItemPlacementPreflight.swift b/Sources/CodexBar/MenuBarStatusItemPlacementPreflight.swift
new file mode 100644
index 0000000000..473fabd7eb
--- /dev/null
+++ b/Sources/CodexBar/MenuBarStatusItemPlacementPreflight.swift
@@ -0,0 +1,61 @@
+import AppKit
+
+@MainActor
+enum MenuBarStatusItemPlacementPreflight {
+    static let preferredPositionPrefix = "NSStatusItem Preferred Position "
+    static let suspiciousPreferredPositionPadding: Double = 512
+
+    static func preferredPositionKey(autosaveName: String) -> String {
+        "\(self.preferredPositionPrefix)\(autosaveName)"
+    }
+
+    @discardableResult
+    static func prepare(
+        defaults: UserDefaults,
+        autosaveName: String,
+        legacyDefaultItemIndex: Int? = nil,
+        maximumPreferredPosition: Double? = currentMaximumPreferredPosition())
+        -> Bool
+    {
+        let key = self.preferredPositionKey(autosaveName: autosaveName)
+        var repaired = self.clearPreferredPositionIfNeeded(
+            defaults: defaults,
+            key: key,
+            maximumPreferredPosition: maximumPreferredPosition)
+        if let legacyDefaultItemIndex {
+            let legacyKey = self.preferredPositionKey(autosaveName: "Item-\(legacyDefaultItemIndex)")
+            repaired = self.clearPreferredPositionIfNeeded(
+                defaults: defaults,
+                key: legacyKey,
+                maximumPreferredPosition: maximumPreferredPosition) || repaired
+        }
+        return repaired
+    }
+
+    static func shouldClearPreferredPosition(_ value: Any, maximumPreferredPosition: Double?) -> Bool {
+        guard let number = value as? NSNumber else { return true }
+        let position = number.doubleValue
+        if position <= 0 {
+            return true
+        }
+        guard let maximumPreferredPosition else { return false }
+        return position > maximumPreferredPosition + self.suspiciousPreferredPositionPadding
+    }
+
+    private static func clearPreferredPositionIfNeeded(
+        defaults: UserDefaults,
+        key: String,
+        maximumPreferredPosition: Double?)
+        -> Bool
+    {
+        guard let value = defaults.object(forKey: key),
+              self.shouldClearPreferredPosition(value, maximumPreferredPosition: maximumPreferredPosition)
+        else { return false }
+        defaults.removeObject(forKey: key)
+        return true
+    }
+
+    private static func currentMaximumPreferredPosition() -> Double? {
+        NSScreen.screens.map { Double($0.frame.maxX) }.max()
+    }
+}
diff --git a/Sources/CodexBar/MenuBarStatusItemWindowProbe.swift b/Sources/CodexBar/MenuBarStatusItemWindowProbe.swift
new file mode 100644
index 0000000000..51ee404e26
--- /dev/null
+++ b/Sources/CodexBar/MenuBarStatusItemWindowProbe.swift
@@ -0,0 +1,110 @@
+import AppKit
+import CoreGraphics
+import Foundation
+
+struct MenuBarStatusItemWindowSnapshot: Equatable, CustomStringConvertible {
+    let name: String
+    let ownerName: String
+    let bounds: CGRect
+    let isOnscreen: Bool
+    let displayBounds: CGRect?
+
+    var isWithinDisplayBounds: Bool {
+        guard let displayBounds else { return false }
+        return displayBounds.contains(self.bounds)
+    }
+
+    var isTahoeBlockedProxy: Bool {
+        self.ownerName == "Control Center"
+            && self.isOnscreen
+            && abs(self.bounds.minX) <= 1
+            && self.bounds.maxY <= 0
+            && self.bounds.width > 0
+            && self.bounds.height > 0
+            && !self.isWithinDisplayBounds
+    }
+
+    var description: String {
+        let display = self.displayBounds.map {
+            "display=\(Int($0.minX)),\(Int($0.minY)) \(Int($0.width))x\(Int($0.height))"
+        } ?? "display=nil"
+        return "name=\(self.name),owner=\(self.ownerName),x=\(Int(self.bounds.minX)),"
+            + "w=\(Int(self.bounds.width)),onscreen=\(self.isOnscreen),"
+            + "withinDisplay=\(self.isWithinDisplayBounds),\(display)"
+    }
+}
+
+enum MenuBarStatusItemWindowProbe {
+    static func snapshots(matching names: Set<String>) -> [MenuBarStatusItemWindowSnapshot] {
+        self.snapshots(
+            matching: names,
+            windowInfo: self.windowInfo(),
+            displayBounds: NSScreen.screens.map(\.frame))
+    }
+
+    static func snapshots(
+        matching names: Set<String>,
+        windowInfo: [[String: Any]],
+        displayBounds: [CGRect])
+        -> [MenuBarStatusItemWindowSnapshot]
+    {
+        guard !names.isEmpty else { return [] }
+        return windowInfo.compactMap { record in
+            self.snapshot(record: record, matching: names, displayBounds: displayBounds)
+        }
+    }
+
+    private static func windowInfo() -> [[String: Any]] {
+        guard let windows = CGWindowListCopyWindowInfo([.optionAll], kCGNullWindowID) as? [[String: Any]] else {
+            return []
+        }
+        return windows
+    }
+
+    private static func snapshot(
+        record: [String: Any],
+        matching names: Set<String>,
+        displayBounds: [CGRect])
+        -> MenuBarStatusItemWindowSnapshot?
+    {
+        guard let name = record[kCGWindowName as String] as? String,
+              names.contains(name),
+              let bounds = self.bounds(record[kCGWindowBounds as String])
+        else { return nil }
+        let ownerName = record[kCGWindowOwnerName as String] as? String ?? "unknown"
+        let isOnscreen = (record[kCGWindowIsOnscreen as String] as? NSNumber)?.boolValue
+            ?? record[kCGWindowIsOnscreen as String] as? Bool
+            ?? false
+        return MenuBarStatusItemWindowSnapshot(
+            name: name,
+            ownerName: ownerName,
+            bounds: bounds,
+            isOnscreen: isOnscreen,
+            displayBounds: displayBounds.first { $0.intersects(bounds) })
+    }
+
+    private static func bounds(_ value: Any?) -> CGRect? {
+        guard let dictionary = value as? [String: Any],
+              let x = self.double(dictionary["X"]),
+              let y = self.double(dictionary["Y"]),
+              let width = self.double(dictionary["Width"]),
+              let height = self.double(dictionary["Height"])
+        else { return nil }
+        return CGRect(x: x, y: y, width: width, height: height)
+    }
+
+    private static func double(_ value: Any?) -> Double? {
+        switch value {
+        case let number as NSNumber:
+            number.doubleValue
+        case let double as Double:
+            double
+        case let int as Int:
+            Double(int)
+        case let cgFloat as CGFloat:
+            Double(cgFloat)
+        default:
+            nil
+        }
+    }
+}
diff --git a/Sources/CodexBar/MenuBarVisibilityWatcher.swift b/Sources/CodexBar/MenuBarVisibilityWatcher.swift
new file mode 100644
index 0000000000..2d637008b3
--- /dev/null
+++ b/Sources/CodexBar/MenuBarVisibilityWatcher.swift
@@ -0,0 +1,407 @@
+import AppKit
+import Foundation
+
+struct StatusItemVisibilitySnapshot: Equatable {
+    let isVisible: Bool
+    let hasButton: Bool
+    let hasWindow: Bool
+    let hasScreen: Bool
+    let isOnCurrentScreen: Bool
+    let buttonWidth: CGFloat
+
+    init(
+        isVisible: Bool,
+        hasButton: Bool,
+        hasWindow: Bool,
+        hasScreen: Bool,
+        isOnCurrentScreen: Bool = true,
+        buttonWidth: CGFloat)
+    {
+        self.isVisible = isVisible
+        self.hasButton = hasButton
+        self.hasWindow = hasWindow
+        self.hasScreen = hasScreen
+        self.isOnCurrentScreen = isOnCurrentScreen
+        self.buttonWidth = buttonWidth
+    }
+}
+
+extension StatusItemVisibilitySnapshot: CustomStringConvertible {
+    var description: String {
+        "visible=\(self.isVisible),button=\(self.hasButton),window=\(self.hasWindow),"
+            + "screen=\(self.hasScreen),currentScreen=\(self.isOnCurrentScreen),"
+            + "width=\(String(format: "%.1f", Double(self.buttonWidth)))"
+    }
+}
+
+@MainActor
+func isStatusItemBlocked(_ item: NSStatusItem) -> Bool {
+    MenuBarVisibilityWatcher.isBlockedSnapshot(snapshot: MenuBarVisibilityWatcher.visibilitySnapshot(item))
+}
+
+enum MenuBarVisibilityWatcher {
+    static let guidanceShownKey = "hasShownTahoeAllowListGuidance"
+    static let guidanceLastShownAtKey = "tahoeAllowListGuidanceLastShownAt"
+    static let guidanceRepeatInterval: TimeInterval = 24 * 60 * 60
+    static let startupFreshnessInterval: TimeInterval = 10
+    static let startupCheckDelay: TimeInterval = 2
+    static let screenChangeCheckDelay: Duration = .milliseconds(750)
+    static let screenChangeFollowUpDelay: Duration = .seconds(2)
+    static let settingsURL = URL(string: "x-apple.systempreferences:com.apple.MenuBarSettings")!
+
+    @MainActor
+    static func visibilitySnapshot(_ item: NSStatusItem) -> StatusItemVisibilitySnapshot {
+        let screen = item.button?.window?.screen
+        return StatusItemVisibilitySnapshot(
+            isVisible: item.isVisible,
+            hasButton: item.button != nil,
+            hasWindow: item.button?.window != nil,
+            hasScreen: screen != nil,
+            isOnCurrentScreen: screen.map(self.isCurrentScreen) ?? false,
+            buttonWidth: item.button?.frame.size.width ?? 0)
+    }
+
+    @MainActor
+    private static func isCurrentScreen(_ screen: NSScreen) -> Bool {
+        let screenNumber = self.screenNumber(screen)
+        return NSScreen.screens.contains { candidate in
+            if let screenNumber, let candidateNumber = self.screenNumber(candidate) {
+                return candidateNumber == screenNumber
+            }
+            return candidate === screen
+        }
+    }
+
+    private static func screenNumber(_ screen: NSScreen) -> NSNumber? {
+        screen.deviceDescription[NSDeviceDescriptionKey("NSScreenNumber")] as? NSNumber
+    }
+
+    static func isBlockedSnapshot(snapshot: StatusItemVisibilitySnapshot) -> Bool {
+        guard snapshot.isVisible else { return false }
+        guard snapshot.hasButton else { return true }
+        // Menu bar managers can park status-item windows off the current screen while preserving the
+        // underlying NSStatusItem. Recreating in that state makes those managers see a new item.
+        return !snapshot.hasWindow || snapshot.buttonWidth <= 0
+    }
+
+    static func isDisplacedSnapshot(snapshot: StatusItemVisibilitySnapshot) -> Bool {
+        guard snapshot.isVisible, snapshot.hasButton, snapshot.hasWindow, snapshot.buttonWidth > 0 else {
+            return false
+        }
+        return !snapshot.hasScreen || !snapshot.isOnCurrentScreen
+    }
+
+    static func hasBlockedVisibleSnapshots(_ snapshots: [StatusItemVisibilitySnapshot]) -> Bool {
+        let visibleItems = snapshots.filter(\.isVisible)
+        guard !visibleItems.isEmpty else { return false }
+        return visibleItems.allSatisfy { snapshot in
+            self.isBlockedSnapshot(snapshot: snapshot)
+        }
+    }
+
+    static func hasAnyBlockedVisibleSnapshot(_ snapshots: [StatusItemVisibilitySnapshot]) -> Bool {
+        snapshots.contains { snapshot in
+            snapshot.isVisible && self.isBlockedSnapshot(snapshot: snapshot)
+        }
+    }
+
+    static func hasAnyDisplacedVisibleSnapshot(_ snapshots: [StatusItemVisibilitySnapshot]) -> Bool {
+        snapshots.contains { snapshot in
+            self.isDisplacedSnapshot(snapshot: snapshot)
+        }
+    }
+
+    static func hasAnyStartupRecoveryCandidate(
+        snapshots: [StatusItemVisibilitySnapshot],
+        windowSnapshots: [MenuBarStatusItemWindowSnapshot] = [],
+        detectTahoeBlockedProxy: Bool = false)
+        -> Bool
+    {
+        if self.hasAnyBlockedVisibleSnapshot(snapshots) {
+            return true
+        }
+        guard detectTahoeBlockedProxy,
+              self.hasAnyDisplacedVisibleSnapshot(snapshots),
+              windowSnapshots.contains(where: \.isTahoeBlockedProxy)
+        else {
+            return false
+        }
+        return true
+    }
+
+    @MainActor
+    static func visibilitySnapshots(_ items: [NSStatusItem]) -> [StatusItemVisibilitySnapshot] {
+        items.map { item in
+            self.visibilitySnapshot(item)
+        }
+    }
+
+    @MainActor
+    static func hasBlockedVisibleStatusItems(_ items: [NSStatusItem]) -> Bool {
+        self.hasBlockedVisibleSnapshots(self.visibilitySnapshots(items))
+    }
+
+    static func shouldAttemptStartupRecovery(
+        appLaunchedAt: Date,
+        now: Date = Date(),
+        snapshots: [StatusItemVisibilitySnapshot],
+        windowSnapshots: [MenuBarStatusItemWindowSnapshot] = [],
+        detectTahoeBlockedProxy: Bool = false)
+        -> Bool
+    {
+        guard now.timeIntervalSince(appLaunchedAt) <= self.startupFreshnessInterval else { return false }
+        return self.hasAnyStartupRecoveryCandidate(
+            snapshots: snapshots,
+            windowSnapshots: windowSnapshots,
+            detectTahoeBlockedProxy: detectTahoeBlockedProxy)
+    }
+
+    static func shouldRefreshScreenChangePlacement(
+        previousScreenCount _: Int,
+        currentScreenCount _: Int,
+        snapshots: [StatusItemVisibilitySnapshot])
+        -> Bool
+    {
+        self.hasAnyDisplacedVisibleSnapshot(snapshots)
+    }
+
+    static func shouldAttemptScreenChangeRecovery(snapshots: [StatusItemVisibilitySnapshot]) -> Bool {
+        self.hasAnyBlockedVisibleSnapshot(snapshots)
+    }
+
+    static func shouldShowGuidance(defaults: UserDefaults, now: Date = Date()) -> Bool {
+        guard defaults.bool(forKey: self.guidanceShownKey) else { return true }
+        let lastShownAt = defaults.double(forKey: self.guidanceLastShownAtKey)
+        guard lastShownAt > 0 else { return false }
+        return now.timeIntervalSince1970 - lastShownAt >= self.guidanceRepeatInterval
+    }
+
+    static func markGuidanceShown(defaults: UserDefaults, now: Date = Date()) {
+        defaults.set(true, forKey: self.guidanceShownKey)
+        defaults.set(now.timeIntervalSince1970, forKey: self.guidanceLastShownAtKey)
+    }
+
+    @MainActor
+    static func presentGuidance(
+        defaults: UserDefaults,
+        now: Date = Date(),
+        openURL: (URL) -> Void = { NSWorkspace.shared.open($0) })
+    {
+        self.markGuidanceShown(defaults: defaults, now: now)
+
+        let alert = NSAlert()
+        alert.messageText = L("CodexBar can't show its menu bar icon")
+        alert.informativeText = L(
+            "macOS Tahoe can block menu bar apps in System Settings → Menu Bar → Allow in the Menu Bar. "
+                + "CodexBar is running, but macOS may be hiding its icon. Open Menu Bar settings and turn CodexBar on.")
+        alert.alertStyle = .warning
+        alert.addButton(withTitle: L("Open Menu Bar Settings"))
+        alert.addButton(withTitle: L("Dismiss"))
+
+        if alert.runModal() == .alertFirstButtonReturn {
+            openURL(self.settingsURL)
+        }
+    }
+}
+
+extension StatusItemController {
+    func scheduleStartupStatusItemVisibilityCheck(appLaunchedAt: Date = Date()) {
+        guard !SettingsStore.isRunningTests else { return }
+        DispatchQueue.main.asyncAfter(deadline: .now() + MenuBarVisibilityWatcher.startupCheckDelay) { [weak self] in
+            Task { @MainActor [weak self] in
+                self?.checkStartupStatusItemVisibility(appLaunchedAt: appLaunchedAt)
+            }
+        }
+    }
+
+    private func checkStartupStatusItemVisibility(appLaunchedAt: Date, now: Date = Date()) {
+        let snapshots = MenuBarVisibilityWatcher.visibilitySnapshots(self.startupVisibilityStatusItems)
+        let windowSnapshots = self.statusItemWindowSnapshots()
+        guard MenuBarVisibilityWatcher.shouldAttemptStartupRecovery(
+            appLaunchedAt: appLaunchedAt,
+            now: now,
+            snapshots: snapshots,
+            windowSnapshots: windowSnapshots,
+            detectTahoeBlockedProxy: self.canDetectTahoeBlockedProxy)
+        else {
+            return
+        }
+
+        self.menuLogger.error(
+            "Status item failed to materialize or remained detached; recreating status items",
+            metadata: [
+                "snapshots": snapshots.map(\.description).joined(separator: " | "),
+                "windows": self.statusItemWindowDiagnosticsDescription(windowSnapshots),
+            ])
+        self.recreateStatusItemsForVisibilityRecovery()
+
+        let recoveredSnapshots = MenuBarVisibilityWatcher.visibilitySnapshots(self.startupVisibilityStatusItems)
+        let recoveredWindowSnapshots = self.statusItemWindowSnapshots()
+        guard MenuBarVisibilityWatcher.shouldAttemptStartupRecovery(
+            appLaunchedAt: appLaunchedAt,
+            now: now,
+            snapshots: recoveredSnapshots,
+            windowSnapshots: recoveredWindowSnapshots,
+            detectTahoeBlockedProxy: self.canDetectTahoeBlockedProxy)
+        else {
+            self.menuLogger.info(
+                "Status item materialized after recreation",
+                metadata: ["snapshots": recoveredSnapshots.map(\.description).joined(separator: " | ")])
+            return
+        }
+
+        self.menuLogger.error(
+            "Status item still unavailable after recreation",
+            metadata: [
+                "snapshots": recoveredSnapshots.map(\.description).joined(separator: " | "),
+                "windows": self.statusItemWindowDiagnosticsDescription(recoveredWindowSnapshots),
+            ])
+        guard #available(macOS 26.0, *),
+              MenuBarVisibilityWatcher.shouldShowGuidance(defaults: self.settings.userDefaults, now: now)
+        else {
+            return
+        }
+        MenuBarVisibilityWatcher.presentGuidance(defaults: self.settings.userDefaults, now: now)
+    }
+
+    @objc func handleScreenParametersDidChange(_: Notification) {
+        let previousScreenCount = max(
+            self.pendingScreenChangePreviousCount ?? self.lastKnownScreenCount,
+            self.lastKnownScreenCount)
+        let currentScreenCount = NSScreen.screens.count
+        self.pendingScreenChangePreviousCount = previousScreenCount
+        self.lastKnownScreenCount = currentScreenCount
+        self.scheduleScreenChangeStatusItemVisibilityCheck(
+            previousScreenCount: previousScreenCount,
+            currentScreenCount: currentScreenCount)
+    }
+
+    private func scheduleScreenChangeStatusItemVisibilityCheck(
+        previousScreenCount: Int,
+        currentScreenCount: Int)
+    {
+        guard !SettingsStore.isRunningTests else { return }
+        self.screenChangeVisibilityTask?.cancel()
+        self.screenChangeVisibilityTask = Task { @MainActor [weak self] in
+            do {
+                try await Task.sleep(for: MenuBarVisibilityWatcher.screenChangeCheckDelay)
+            } catch {
+                return
+            }
+            self?.checkScreenChangeStatusItemVisibility(
+                previousScreenCount: previousScreenCount,
+                currentScreenCount: currentScreenCount)
+        }
+    }
+
+    private func checkScreenChangeStatusItemVisibility(previousScreenCount: Int, currentScreenCount: Int) {
+        self.pendingScreenChangePreviousCount = nil
+        let settledCurrentScreenCount = NSScreen.screens.count
+        self.lastKnownScreenCount = settledCurrentScreenCount
+        let snapshots = MenuBarVisibilityWatcher.visibilitySnapshots(self.startupVisibilityStatusItems)
+        if MenuBarVisibilityWatcher.shouldAttemptScreenChangeRecovery(snapshots: snapshots) {
+            self.menuLogger.error(
+                "Display configuration changed; recreating status items",
+                metadata: [
+                    "previousScreenCount": "\(previousScreenCount)",
+                    "currentScreenCount": "\(settledCurrentScreenCount)",
+                    "capturedScreenCount": "\(currentScreenCount)",
+                    "snapshots": snapshots.map(\.description).joined(separator: " | "),
+                    "windows": self.statusItemWindowDiagnosticsDescription(),
+                ])
+            self.recreateStatusItemsForVisibilityRecovery()
+            self.schedulePostScreenChangeRecoveryVerification(attempt: 1)
+            return
+        }
+
+        guard MenuBarVisibilityWatcher.shouldRefreshScreenChangePlacement(
+            previousScreenCount: previousScreenCount,
+            currentScreenCount: settledCurrentScreenCount,
+            snapshots: snapshots)
+        else {
+            return
+        }
+
+        self.menuLogger.info(
+            "Display configuration changed; refreshing existing status items",
+            metadata: [
+                "previousScreenCount": "\(previousScreenCount)",
+                "currentScreenCount": "\(settledCurrentScreenCount)",
+                "capturedScreenCount": "\(currentScreenCount)",
+                "snapshots": snapshots.map(\.description).joined(separator: " | "),
+            ])
+        self.refreshExistingStatusItemsForVisibilityRecovery()
+    }
+
+    private func schedulePostScreenChangeRecoveryVerification(attempt: Int) {
+        self.screenChangeVisibilityTask = Task { @MainActor [weak self] in
+            do {
+                try await Task.sleep(for: MenuBarVisibilityWatcher.screenChangeFollowUpDelay)
+            } catch {
+                return
+            }
+            self?.verifyScreenChangeRecoveryIfNeeded(attempt: attempt)
+        }
+    }
+
+    private func verifyScreenChangeRecoveryIfNeeded(attempt: Int) {
+        let snapshots = MenuBarVisibilityWatcher.visibilitySnapshots(self.startupVisibilityStatusItems)
+        guard MenuBarVisibilityWatcher.hasAnyBlockedVisibleSnapshot(snapshots) else {
+            self.menuLogger.info(
+                "Status item recovered after display-change recovery",
+                metadata: ["attempt": "\(attempt)", "snapshots": snapshots.map(\.description).joined(separator: " | ")])
+            return
+        }
+
+        self.menuLogger.error(
+            "Status item still blocked after display-change recovery; recreating status items again",
+            metadata: [
+                "attempt": "\(attempt)",
+                "snapshots": snapshots.map(\.description).joined(separator: " | "),
+                "windows": self.statusItemWindowDiagnosticsDescription(),
+            ])
+        self.recreateStatusItemsForVisibilityRecovery()
+        // No further async retries: a menu bar manager may park the newly recreated item in a state
+        // that still looks blocked, causing repeated NSStatusItem destruction that corrupts Control Center.
+        // Instead, do one synchronous re-check to surface guidance if macOS itself is blocking the item.
+        let finalSnapshots = MenuBarVisibilityWatcher.visibilitySnapshots(self.startupVisibilityStatusItems)
+        guard MenuBarVisibilityWatcher.hasAnyBlockedVisibleSnapshot(finalSnapshots) else { return }
+        self.menuLogger.error(
+            "Status item still blocked after display-change recovery recreation",
+            metadata: [
+                "snapshots": finalSnapshots.map(\.description).joined(separator: " | "),
+                "windows": self.statusItemWindowDiagnosticsDescription(),
+            ])
+        guard #available(macOS 26.0, *),
+              MenuBarVisibilityWatcher.shouldShowGuidance(defaults: self.settings.userDefaults)
+        else { return }
+        MenuBarVisibilityWatcher.presentGuidance(defaults: self.settings.userDefaults)
+    }
+
+    private var startupVisibilityStatusItems: [NSStatusItem] {
+        [self.statusItem] + Array(self.statusItems.values)
+    }
+
+    private var canDetectTahoeBlockedProxy: Bool {
+        if #available(macOS 26.0, *) {
+            return true
+        }
+        return false
+    }
+
+    private func statusItemWindowSnapshots() -> [MenuBarStatusItemWindowSnapshot] {
+        let names = Set(self.startupVisibilityStatusItems.compactMap { item in
+            item.autosaveName.isEmpty ? nil : item.autosaveName
+        })
+        return MenuBarStatusItemWindowProbe.snapshots(matching: names)
+    }
+
+    private func statusItemWindowDiagnosticsDescription(
+        _ snapshots: [MenuBarStatusItemWindowSnapshot]? = nil)
+        -> String
+    {
+        let snapshots = snapshots ?? self.statusItemWindowSnapshots()
+        guard !snapshots.isEmpty else { return "none" }
+        return snapshots.map(\.description).joined(separator: " | ")
+    }
+}
diff --git a/Sources/CodexBar/MenuCardHeightFingerprint.swift b/Sources/CodexBar/MenuCardHeightFingerprint.swift
new file mode 100644
index 0000000000..9e1962b85c
--- /dev/null
+++ b/Sources/CodexBar/MenuCardHeightFingerprint.swift
@@ -0,0 +1,167 @@
+import Foundation
+
+extension UsageMenuCardView.Model {
+    func heightFingerprint(section: String, additional: [String] = []) -> String {
+        let notesFingerprint = MenuCardHeightFingerprint.join(self.usageNotes.map {
+            MenuCardHeightFingerprint.field("note", $0)
+        })
+        return MenuCardHeightFingerprint.join([
+            "section=\(section)",
+            "provider=\(self.provider.rawValue)",
+            "localization=\(codexBarLocalizationSignature())",
+            MenuCardHeightFingerprint.field("name", self.providerName),
+            MenuCardHeightFingerprint.field("email", self.email),
+            MenuCardHeightFingerprint.field("subtitle", self.subtitleText),
+            "subtitleStyle=\(self.subtitleStyle.heightFingerprint)",
+            MenuCardHeightFingerprint.field("plan", self.planText),
+            MenuCardHeightFingerprint.field("placeholder", self.placeholder),
+            MenuCardHeightFingerprint.field("credits", self.creditsText),
+            "creditsRemaining=\(self.creditsRemaining.map(String.init(describing:)) ?? "nil")",
+            MenuCardHeightFingerprint.field("creditsHint", self.creditsHintText),
+            MenuCardHeightFingerprint.field("creditsCopy", self.creditsHintCopyText),
+            MenuCardHeightFingerprint.field("codexResetCredits", self.codexResetCreditsText),
+            MenuCardHeightFingerprint.field("codexResetCreditsDetail", self.codexResetCreditsDetailText),
+            "metrics=\(MenuCardHeightFingerprint.join(self.metrics.map(\.heightFingerprint)))",
+            "notes=\(notesFingerprint)",
+            "dashboard=\(self.inlineUsageDashboard?.heightFingerprint ?? "")",
+            "providerCost=\(self.providerCost?.heightFingerprint ?? "")",
+            "tokenUsage=\(self.tokenUsage?.heightFingerprint ?? "")",
+            "openaiAPI=\(self.openAIAPIUsage == nil ? "0" : "1")",
+        ] + additional)
+    }
+
+    static func heightFingerprintField(_ name: String, _ value: String?) -> String {
+        MenuCardHeightFingerprint.field(name, value)
+    }
+}
+
+private enum MenuCardHeightFingerprint {
+    private static let hashSalt = UUID()
+
+    static func join(_ values: [String]) -> String {
+        values.map { "\($0.count):\($0)" }.joined(separator: "|")
+    }
+
+    static func field(_ name: String, _ value: String?) -> String {
+        guard let value else {
+            return "\(name)=nil"
+        }
+        return "\(name)=\(Self.stringShape(value))"
+    }
+
+    private static func stringShape(_ value: String) -> String {
+        var hasher = Hasher()
+        hasher.combine(Self.hashSalt)
+        hasher.combine(value)
+        let digest = String(UInt(bitPattern: hasher.finalize()), radix: 16)
+        return "chars:\(value.count),utf8:\(value.utf8.count),lines:\(Self.lineCount(value)),hash:\(digest)"
+    }
+
+    private static func lineCount(_ value: String) -> Int {
+        guard !value.isEmpty else { return 0 }
+        return value.utf8.reduce(1) { count, byte in
+            byte == 10 ? count + 1 : count
+        }
+    }
+}
+
+extension UsageMenuCardView.Model.SubtitleStyle {
+    fileprivate var heightFingerprint: String {
+        switch self {
+        case .info: "info"
+        case .loading: "loading"
+        case .error: "error"
+        }
+    }
+}
+
+extension UsageMenuCardView.Model.Metric {
+    fileprivate var heightFingerprint: String {
+        MenuCardHeightFingerprint.join([
+            self.id,
+            MenuCardHeightFingerprint.field("title", self.title),
+            "percent=\(Int(self.percent.rounded()))",
+            "percentStyle=\(self.percentStyle.rawValue)",
+            MenuCardHeightFingerprint.field("status", self.statusText),
+            MenuCardHeightFingerprint.field("reset", self.resetText),
+            MenuCardHeightFingerprint.field("detail", self.detailText),
+            MenuCardHeightFingerprint.field("detailLeft", self.detailLeftText),
+            MenuCardHeightFingerprint.field("detailRight", self.detailRightText),
+            self.pacePercent == nil ? "pace=0" : "pace=1",
+            self.paceOnTop ? "paceTop=1" : "paceTop=0",
+            self.cardStyle ? "card=1" : "card=0",
+            "markers=\(self.warningMarkerPercents.count)",
+        ])
+    }
+}
+
+extension UsageMenuCardView.Model.ProviderCostSection {
+    fileprivate var heightFingerprint: String {
+        MenuCardHeightFingerprint.join([
+            MenuCardHeightFingerprint.field("title", self.title),
+            MenuCardHeightFingerprint.field("spend", self.spendLine),
+            MenuCardHeightFingerprint.field("percentLine", self.percentLine),
+            MenuCardHeightFingerprint.field("personalSpend", self.personalSpendLine),
+            self.percentUsed == nil ? "percent=0" : "percent=1",
+        ])
+    }
+}
+
+extension UsageMenuCardView.Model.TokenUsageSection {
+    fileprivate var heightFingerprint: String {
+        MenuCardHeightFingerprint.join([
+            MenuCardHeightFingerprint.field("session", self.sessionLine),
+            MenuCardHeightFingerprint.field("month", self.monthLine),
+            MenuCardHeightFingerprint.field("hint", self.hintLine),
+            MenuCardHeightFingerprint.field("error", self.errorLine),
+            MenuCardHeightFingerprint.field("errorCopy", self.errorCopyText),
+        ])
+    }
+}
+
+extension InlineUsageDashboardModel {
+    fileprivate var heightFingerprint: String {
+        MenuCardHeightFingerprint.join([
+            MenuCardHeightFingerprint.field("accessibility", self.accessibilityLabel),
+            self.valueStyle.heightFingerprint,
+            MenuCardHeightFingerprint.join(self.kpis.map(\.heightFingerprint)),
+            MenuCardHeightFingerprint.join(self.points.map(\.heightFingerprint)),
+            MenuCardHeightFingerprint.join(self.detailLines.map { MenuCardHeightFingerprint.field("detail", $0) }),
+        ])
+    }
+}
+
+extension InlineUsageDashboardModel.KPI {
+    fileprivate var heightFingerprint: String {
+        MenuCardHeightFingerprint.join([
+            MenuCardHeightFingerprint.field("title", self.title),
+            MenuCardHeightFingerprint.field("value", self.value),
+            self.emphasis ? "1" : "0",
+        ])
+    }
+}
+
+extension InlineUsageDashboardModel.Point {
+    fileprivate var heightFingerprint: String {
+        MenuCardHeightFingerprint.join([
+            self.id,
+            MenuCardHeightFingerprint.field("label", self.label),
+            MenuCardHeightFingerprint.field("accessibilityValue", self.accessibilityValue),
+        ])
+    }
+}
+
+extension InlineUsageDashboardModel.ValueStyle {
+    fileprivate var heightFingerprint: String {
+        switch self {
+        case .currencyUSD:
+            "currencyUSD"
+        case let .currency(symbol):
+            "currency:\(symbol)"
+        case .tokens:
+            "tokens"
+        case .points:
+            "points"
+        }
+    }
+}
diff --git a/Sources/CodexBar/MenuCardQuotaWarningMarkers.swift b/Sources/CodexBar/MenuCardQuotaWarningMarkers.swift
new file mode 100644
index 0000000000..abe15e2879
--- /dev/null
+++ b/Sources/CodexBar/MenuCardQuotaWarningMarkers.swift
@@ -0,0 +1,80 @@
+import CodexBarCore
+
+extension CodexConsumerProjection.RateLane {
+    var quotaWarningWindow: QuotaWarningWindow {
+        switch self {
+        case .session:
+            .session
+        case .weekly:
+            .weekly
+        }
+    }
+}
+
+extension UsageMenuCardView.Model {
+    static func warningMarkerPercents(thresholds: [Int]?, showUsed: Bool) -> [Double] {
+        guard let thresholds, !thresholds.isEmpty else { return [] }
+        return QuotaWarningThresholds.active(thresholds)
+            .map { showUsed ? 100 - Double($0) : Double($0) }
+            .filter { $0 > 0 && $0 < 100 }
+    }
+
+    /// Merges quota warning markers with optional work-day boundary markers.
+    /// Preserves original warning-marker ordering when workdayMarkers is empty,
+    /// sorts the combined set when workday markers are present.
+    static func mergedMarkerPercents(
+        warningMarkers: [Double],
+        workdayMarkers: [Double]) -> [Double]
+    {
+        let combined = warningMarkers + workdayMarkers
+        return workdayMarkers.isEmpty ? combined : combined.sorted()
+    }
+
+    /// Combines quota warning markers with optional work-day boundary markers
+    /// into a single sorted array. Workday markers are only applied when
+    /// includeWorkdayMarkers is true and windowMinutes == 10080.
+    static func markerPercents(
+        thresholds: [Int]?,
+        showUsed: Bool,
+        workDays: Int?,
+        windowMinutes: Int?,
+        includeWorkdayMarkers: Bool) -> [Double]
+    {
+        let warningMarkers = Self.warningMarkerPercents(thresholds: thresholds, showUsed: showUsed)
+        let workdayMarkers = includeWorkdayMarkers
+            ? workDayMarkerPercents(workDays: workDays, windowMinutes: windowMinutes)
+            : []
+        return Self.mergedMarkerPercents(warningMarkers: warningMarkers, workdayMarkers: workdayMarkers)
+    }
+
+    static func weeklyMarkerPercents(input: Input, windowMinutes: Int?) -> [Double] {
+        UsageMenuCardView.Model.markerPercents(
+            thresholds: input.quotaWarningThresholds[.weekly],
+            showUsed: input.usageBarsShowUsed,
+            workDays: input.workDaysPerWeek,
+            windowMinutes: windowMinutes,
+            includeWorkdayMarkers: true)
+    }
+
+    static func codexLaneMarkerPercents(
+        input: Input,
+        lane: CodexConsumerProjection.RateLane,
+        windowMinutes: Int?) -> [Double]
+    {
+        UsageMenuCardView.Model.markerPercents(
+            thresholds: input.quotaWarningThresholds[lane.quotaWarningWindow],
+            showUsed: input.usageBarsShowUsed,
+            workDays: input.workDaysPerWeek,
+            windowMinutes: windowMinutes,
+            includeWorkdayMarkers: lane == .weekly)
+    }
+}
+
+/// Returns boundary percentages for work day markers on a weekly progress bar.
+/// Only valid when windowMinutes == 10080 (standard 7-day week).
+/// nil workDays means feature is disabled.
+func workDayMarkerPercents(workDays: Int?, windowMinutes: Int?) -> [Double] {
+    guard workDays != nil, windowMinutes == 10080 else { return [] }
+    guard let wd = workDays, wd >= 2, wd <= 7 else { return [] }
+    return (1..<wd).map { Double($0) * 100.0 / Double(wd) }
+}
diff --git a/Sources/CodexBar/MenuCardRefreshMonitor.swift b/Sources/CodexBar/MenuCardRefreshMonitor.swift
new file mode 100644
index 0000000000..781c15e8f9
--- /dev/null
+++ b/Sources/CodexBar/MenuCardRefreshMonitor.swift
@@ -0,0 +1,80 @@
+import CodexBarCore
+import Observation
+
+struct MenuCardLiveSubtitle {
+    let text: String
+    let style: UsageMenuCardView.Model.SubtitleStyle
+}
+
+/// Updates values in an already-hosted card without rebuilding its tracked NSMenu.
+@MainActor
+@Observable
+final class MenuCardRefreshMonitor {
+    typealias ModelResolver = @MainActor (UsageProvider) -> UsageMenuCardView.Model?
+
+    private let resolveModel: ModelResolver
+    var isManualRefreshInFlight = false
+    private var manualRefreshProvider: UsageProvider?
+    private var frozenManualRefreshModels: [UsageProvider: UsageMenuCardView.Model] = [:]
+
+    init(resolveModel: @escaping ModelResolver) {
+        self.resolveModel = resolveModel
+    }
+
+    func beginManualRefresh(
+        frozenModels: [UsageProvider: UsageMenuCardView.Model],
+        provider: UsageProvider? = nil)
+    {
+        self.frozenManualRefreshModels = frozenModels
+        self.manualRefreshProvider = provider
+        self.isManualRefreshInFlight = true
+    }
+
+    func endManualRefresh() {
+        self.isManualRefreshInFlight = false
+        self.manualRefreshProvider = nil
+        self.frozenManualRefreshModels.removeAll(keepingCapacity: true)
+    }
+
+    func isManualRefreshInFlight(for provider: UsageProvider) -> Bool {
+        self.isManualRefreshInFlight && (self.manualRefreshProvider == nil || self.manualRefreshProvider == provider)
+    }
+
+    func model(
+        for provider: UsageProvider,
+        fallback: UsageMenuCardView.Model) -> UsageMenuCardView.Model
+    {
+        guard !self.isManualRefreshInFlight(for: provider) else {
+            guard let frozen = self.frozenManualRefreshModels[provider] else {
+                return fallback
+            }
+            if fallback.hasCompatibleTrackedLayout(with: frozen) {
+                return frozen
+            }
+            // A rebuilding menu may temporarily lose some metric rows, but retained rows and other sections
+            // must still match the frozen layout.
+            if fallback.hasCompatibleTrackedMetricSubset(of: frozen) {
+                return frozen
+            }
+            return fallback
+        }
+
+        guard let resolved = self.resolveModel(provider),
+              fallback.hasCompatibleTrackedLayout(with: resolved)
+        else {
+            return fallback
+        }
+        return resolved
+    }
+
+    func subtitle(
+        for provider: UsageProvider,
+        fallback: MenuCardLiveSubtitle) -> MenuCardLiveSubtitle
+    {
+        if self.isManualRefreshInFlight(for: provider) {
+            return MenuCardLiveSubtitle(text: "\(L("Refreshing"))…", style: .loading)
+        }
+        guard let model = self.resolveModel(provider) else { return fallback }
+        return MenuCardLiveSubtitle(text: model.subtitleText, style: model.subtitleStyle)
+    }
+}
diff --git a/Sources/CodexBar/MenuCardView+CodexResetCredits.swift b/Sources/CodexBar/MenuCardView+CodexResetCredits.swift
new file mode 100644
index 0000000000..f9dae12b34
--- /dev/null
+++ b/Sources/CodexBar/MenuCardView+CodexResetCredits.swift
@@ -0,0 +1,73 @@
+import CodexBarCore
+import SwiftUI
+
+struct CodexResetCreditsContent: View {
+    let text: String
+    let detailText: String?
+    @Environment(\.menuItemHighlighted) private var isHighlighted
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 4) {
+            HStack(alignment: .firstTextBaseline) {
+                Text(L("Limit Reset Credits"))
+                    .font(.body)
+                    .fontWeight(.medium)
+                    .lineLimit(1)
+                Spacer()
+                Text(self.text)
+                    .font(.footnote)
+                    .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
+                    .lineLimit(1)
+            }
+            if let detailText, !detailText.isEmpty {
+                Text(detailText)
+                    .font(.footnote)
+                    .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
+                    .lineLimit(1)
+            }
+        }
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .accessibilityElement(children: .combine)
+        .accessibilityLabel([
+            L("Limit Reset Credits"),
+            self.text,
+            self.detailText,
+        ].compactMap(\.self).joined(separator: ", "))
+    }
+}
+
+extension UsageMenuCardView.Model {
+    static func codexResetCreditsText(input: Input) -> String? {
+        guard input.provider == .codex,
+              input.showOptionalCreditsAndExtraUsage,
+              let resetCredits = input.snapshot?.codexResetCredits,
+              resetCredits.availableCount > 0
+        else {
+            return nil
+        }
+        let count = resetCredits.availableCount
+        if count == 1 {
+            return L("1 manual reset available")
+        }
+        return String(format: L("%d manual resets available"), count)
+    }
+
+    static func codexResetCreditsDetailText(input: Input) -> String? {
+        guard input.provider == .codex,
+              input.showOptionalCreditsAndExtraUsage,
+              let resetCredits = input.snapshot?.codexResetCredits,
+              let expiresAt = resetCredits.nextExpiringAvailableCredit?.expiresAt
+        else {
+            return nil
+        }
+        let timeText: String
+        switch input.resetTimeDisplayStyle {
+        case .absolute:
+            timeText = UsageFormatter.resetDescription(from: expiresAt, now: input.now)
+        case .countdown:
+            let countdown = UsageFormatter.resetCountdownDescription(from: expiresAt, now: input.now)
+            timeText = countdown == "now" ? L("now") : countdown
+        }
+        return String(format: L("Next expires %@"), timeText)
+    }
+}
diff --git a/Sources/CodexBar/MenuCardView+Costs.swift b/Sources/CodexBar/MenuCardView+Costs.swift
new file mode 100644
index 0000000000..542ac63a20
--- /dev/null
+++ b/Sources/CodexBar/MenuCardView+Costs.swift
@@ -0,0 +1,328 @@
+import CodexBarCore
+import Foundation
+
+extension UsageMenuCardView.Model.ProviderCostSection {
+    init(
+        title: String,
+        percentUsed: Double?,
+        spendLine: String,
+        percentLine: String?)
+    {
+        self.init(
+            title: title,
+            percentUsed: percentUsed,
+            spendLine: spendLine,
+            percentLine: percentLine,
+            personalSpendLine: nil)
+    }
+}
+
+extension UsageMenuCardView.Model {
+    static func isRequiredOpenCodeZenBalance(_ snapshot: UsageSnapshot?) -> Bool {
+        snapshot?.primary == nil &&
+            snapshot?.secondary == nil &&
+            snapshot?.providerCost?.period == "Zen balance"
+    }
+
+    static func tokenUsageSnapshot(input: Input) -> CostUsageTokenSnapshot? {
+        if usesProviderCostHistoryAsPrimaryDashboard(input.provider), input.snapshot != nil {
+            return primaryCostHistorySnapshot(input: input)
+        }
+        return input.tokenSnapshot
+    }
+
+    static func creditsLine(
+        metadata: ProviderMetadata,
+        snapshot: UsageSnapshot?,
+        credits: CreditsSnapshot?,
+        error: String?) -> String?
+    {
+        guard metadata.supportsCredits else { return nil }
+        if metadata.id == .amp,
+           let ampUsage = snapshot?.ampUsage,
+           let ampCredits = self.ampCreditsLine(ampUsage)
+        {
+            return ampCredits
+        }
+        if let credits {
+            return UsageFormatter.creditsString(from: credits.remaining)
+        }
+        if let error, !error.isEmpty {
+            return error.trimmingCharacters(in: .whitespacesAndNewlines)
+        }
+        return L(metadata.creditsHint)
+    }
+
+    private static func ampCreditsLine(_ usage: AmpUsageDetails) -> String? {
+        var lines: [String] = []
+        if let individualCredits = usage.individualCredits {
+            lines.append(
+                "\(L("Individual credits")): \(UsageFormatter.currencyString(individualCredits, currencyCode: "USD"))")
+        }
+        lines.append(contentsOf: usage.workspaceBalances.map { workspace in
+            "\(L("Workspace")) \(workspace.name): " +
+                UsageFormatter.currencyString(workspace.remaining, currencyCode: "USD")
+        })
+        return lines.isEmpty ? nil : lines.joined(separator: "\n")
+    }
+
+    static func tokenUsageSection(
+        provider: UsageProvider,
+        enabled: Bool,
+        snapshot: CostUsageTokenSnapshot?,
+        error: String?) -> TokenUsageSection?
+    {
+        guard ProviderDescriptorRegistry.descriptor(for: provider).tokenCost.supportsTokenCost else {
+            return nil
+        }
+        guard enabled else { return nil }
+        guard let snapshot else { return nil }
+
+        let sessionCost = snapshot.sessionCostUSD.map {
+            UsageFormatter.currencyString($0, currencyCode: snapshot.currencyCode)
+        } ?? "—"
+        let sessionTokens = snapshot.sessionTokens.map { UsageFormatter.tokenCountString($0) }
+        let sessionLabel = if provider == .bedrock || provider == .mistral {
+            Self.latestBillingDayLabel(from: snapshot)
+        } else {
+            L("Today")
+        }
+        let sessionLine: String = {
+            if let sessionTokens {
+                return String(format: L("%@: %@ · %@ tokens"), sessionLabel, sessionCost, sessionTokens)
+            }
+            return "\(sessionLabel): \(sessionCost)"
+        }()
+
+        let monthCost = snapshot.last30DaysCostUSD.map {
+            UsageFormatter.currencyString($0, currencyCode: snapshot.currencyCode)
+        } ?? "—"
+        let fallbackTokens = snapshot.daily.compactMap(\.totalTokens).reduce(0, +)
+        let monthTokensValue = snapshot.last30DaysTokens ?? (fallbackTokens > 0 ? fallbackTokens : nil)
+        let monthTokens = monthTokensValue.map { UsageFormatter.tokenCountString($0) }
+        let windowLabel = snapshot.historyLabel ?? Self.costHistoryWindowLabel(days: snapshot.historyDays)
+        let monthLine: String = {
+            if let monthTokens {
+                return String(format: L("%@: %@ · %@ tokens"), windowLabel, monthCost, monthTokens)
+            }
+            return "\(windowLabel): \(monthCost)"
+        }()
+        let err = (error?.isEmpty ?? true) ? nil : error
+        return TokenUsageSection(
+            sessionLine: sessionLine,
+            monthLine: monthLine,
+            hintLine: Self.tokenUsageHint(provider: provider),
+            errorLine: err,
+            errorCopyText: (error?.isEmpty ?? true) ? nil : error)
+    }
+
+    static func tokenUsageHint(provider: UsageProvider) -> String? {
+        switch provider {
+        case .codex:
+            L("Estimated from local Codex logs for the selected account.")
+        case .claude:
+            UsageFormatter.costEstimateHint(provider: provider)
+        case .vertexai:
+            L("cost_estimate_hint")
+        case .bedrock:
+            L("AWS Cost Explorer billing can lag.")
+        case .openai:
+            L("Reported by OpenAI Admin API organization usage.")
+        case .mistral:
+            L("Reported by Mistral billing usage.")
+        default:
+            nil
+        }
+    }
+
+    static func costHistoryWindowLabel(days: Int) -> String {
+        days == 1 ? L("Today") : String(format: L("Last %d days"), days)
+    }
+
+    private static func latestBillingDayLabel(from snapshot: CostUsageTokenSnapshot) -> String {
+        guard let entry = bedrockLatestBillingDay(from: snapshot.daily),
+              let displayDate = bedrockDisplayDate(from: entry.date)
+        else { return L("Latest billing day") }
+        return String(format: L("Latest billing day (%@)"), displayDate)
+    }
+
+    private static func bedrockLatestBillingDay(from entries: [CostUsageDailyReport.Entry])
+        -> CostUsageDailyReport.Entry?
+    {
+        entries.compactMap { entry -> (entry: CostUsageDailyReport.Entry, dayKey: String)? in
+            guard let dayKey = bedrockBillingDayKey(from: entry.date) else { return nil }
+            return (entry, dayKey)
+        }
+        .max { lhs, rhs in
+            if lhs.dayKey != rhs.dayKey { return lhs.dayKey < rhs.dayKey }
+            let lCost = lhs.entry.costUSD ?? -1
+            let rCost = rhs.entry.costUSD ?? -1
+            if lCost != rCost { return lCost < rCost }
+            let lTokens = lhs.entry.totalTokens ?? -1
+            let rTokens = rhs.entry.totalTokens ?? -1
+            if lTokens != rTokens { return lTokens < rTokens }
+            return lhs.entry.date < rhs.entry.date
+        }?.entry
+    }
+
+    private static func bedrockDisplayDate(from text: String) -> String? {
+        guard let dayKey = bedrockBillingDayKey(from: text) else { return nil }
+        let monthStart = dayKey.index(dayKey.startIndex, offsetBy: 5)
+        let monthEnd = dayKey.index(monthStart, offsetBy: 2)
+        let dayStart = dayKey.index(dayKey.startIndex, offsetBy: 8)
+        guard
+            let month = Int(dayKey[monthStart..<monthEnd]),
+            let day = Int(dayKey[dayStart...]),
+            (1...Self.bedrockMonthAbbreviations.count).contains(month),
+            (1...31).contains(day)
+        else { return nil }
+        return "\(Self.bedrockMonthAbbreviations[month - 1]) \(day)"
+    }
+
+    private static let bedrockMonthAbbreviations = [
+        "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+        "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
+    ]
+
+    private static func bedrockBillingDayKey(from text: String) -> String? {
+        let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard trimmed.count == 10 else { return nil }
+        for (offset, character) in trimmed.enumerated() {
+            switch offset {
+            case 4, 7:
+                guard character == "-" else { return nil }
+            default:
+                guard character.isNumber else { return nil }
+            }
+        }
+        let monthStart = trimmed.index(trimmed.startIndex, offsetBy: 5)
+        let monthEnd = trimmed.index(monthStart, offsetBy: 2)
+        let dayStart = trimmed.index(trimmed.startIndex, offsetBy: 8)
+        let yearEnd = trimmed.index(trimmed.startIndex, offsetBy: 4)
+        guard
+            let year = Int(trimmed[..<yearEnd]),
+            let month = Int(trimmed[monthStart..<monthEnd]),
+            let day = Int(trimmed[dayStart...]),
+            (1...Self.bedrockMonthAbbreviations.count).contains(month),
+            (1...Self.daysInBedrockBillingMonth(month, year: year)).contains(day)
+        else { return nil }
+        return trimmed
+    }
+
+    private static func daysInBedrockBillingMonth(_ month: Int, year: Int) -> Int {
+        switch month {
+        case 2:
+            if year.isMultiple(of: 400) { return 29 }
+            if year.isMultiple(of: 100) { return 28 }
+            return year.isMultiple(of: 4) ? 29 : 28
+        case 4, 6, 9, 11:
+            return 30
+        default:
+            return 31
+        }
+    }
+
+    static func providerCostSection(
+        provider: UsageProvider,
+        cost: ProviderCostSnapshot?) -> ProviderCostSection?
+    {
+        if provider == .manus {
+            return nil
+        }
+        guard let cost else { return nil }
+        guard provider != .synthetic else { return nil }
+
+        if provider == .factory, cost.period == "Extra usage balance" {
+            let balance = UsageFormatter.currencyString(cost.used, currencyCode: cost.currencyCode)
+            return ProviderCostSection(
+                title: L("Extra usage"),
+                percentUsed: nil,
+                spendLine: "\(L("Balance")): \(balance)",
+                percentLine: nil)
+        }
+
+        if provider == .opencodego, cost.period == "Zen balance" {
+            let balance = UsageFormatter.currencyString(cost.used, currencyCode: cost.currencyCode)
+            return ProviderCostSection(
+                title: L("Zen balance"),
+                percentUsed: nil,
+                spendLine: "\(L("Balance")): \(balance)",
+                percentLine: nil)
+        }
+
+        if provider == .minimax, cost.period == "MiniMax points balance" {
+            let balance = String(format: "%.0f", cost.used)
+            return ProviderCostSection(
+                title: L("Credits"),
+                percentUsed: nil,
+                spendLine: "\(L("Balance")): \(balance)",
+                percentLine: nil)
+        }
+
+        if provider == .openai || provider == .claude || provider == .litellm, cost.limit <= 0 {
+            let spend = UsageFormatter.currencyString(cost.used, currencyCode: cost.currencyCode)
+            let periodLabel = Self.localizedPeriodLabel(cost.period ?? "Last 30 days")
+            return ProviderCostSection(
+                title: L("API spend"),
+                percentUsed: nil,
+                spendLine: "\(periodLabel): \(spend)",
+                percentLine: nil)
+        }
+
+        if provider == .litellm {
+            return nil
+        }
+
+        guard cost.limit > 0 else { return nil }
+
+        let used: String
+        let limit: String
+        let title: String
+
+        if cost.currencyCode == "Quota" {
+            title = L("Quota usage")
+            used = String(format: "%.0f", cost.used)
+            limit = String(format: "%.0f", cost.limit)
+        } else {
+            title = L("Extra usage")
+            used = UsageFormatter.currencyString(cost.used, currencyCode: cost.currencyCode)
+            limit = UsageFormatter.currencyString(cost.limit, currencyCode: cost.currencyCode)
+        }
+
+        let percentUsed = Self.clamped((cost.used / cost.limit) * 100)
+        let periodLabel = Self.localizedPeriodLabel(cost.period ?? "This month")
+
+        // When the headline budget is a shared pool (e.g. Cursor team on-demand), show the
+        // account's own contribution underneath it.
+        let personalSpendLine: String? = cost.personalUsed.flatMap { personal in
+            personal > 0
+                ? "\(L("Your spend")): \(UsageFormatter.currencyString(personal, currencyCode: cost.currencyCode))"
+                : nil
+        }
+
+        return ProviderCostSection(
+            title: title,
+            percentUsed: percentUsed,
+            spendLine: "\(periodLabel): \(used) / \(limit)",
+            percentLine: String(format: L("%.0f%% used"), min(100, max(0, percentUsed))),
+            personalSpendLine: personalSpendLine)
+    }
+
+    private static func localizedPeriodLabel(_ label: String) -> String {
+        let trimmed = label.trimmingCharacters(in: .whitespacesAndNewlines)
+        switch trimmed.lowercased() {
+        case "last 30 days":
+            return L("Last 30 days")
+        case "this month":
+            return L("This month")
+        case "today":
+            return L("Today")
+        default:
+            return L(trimmed)
+        }
+    }
+
+    static func clamped(_ value: Double) -> Double {
+        min(100, max(0, value))
+    }
+}
diff --git a/Sources/CodexBar/MenuCardView+Kiro.swift b/Sources/CodexBar/MenuCardView+Kiro.swift
new file mode 100644
index 0000000000..f9f61a9c03
--- /dev/null
+++ b/Sources/CodexBar/MenuCardView+Kiro.swift
@@ -0,0 +1,43 @@
+import CodexBarCore
+import Foundation
+
+extension UsageMenuCardView.Model {
+    static func kiroUsageNotes(input: Input) -> [String] {
+        var notes: [String] = []
+        if let authMethod = input.snapshot?.loginMethod(for: .kiro)?
+            .trimmingCharacters(in: .whitespacesAndNewlines),
+            !authMethod.isEmpty
+        {
+            notes.append("\(L("Auth")): \(authMethod)")
+        }
+        if let overages = input.snapshot?.kiroUsage?.overagesStatus?
+            .trimmingCharacters(in: .whitespacesAndNewlines),
+            !overages.isEmpty
+        {
+            notes.append("\(L("Overages")): \(overages)")
+        }
+        let overagesEnabled = input.snapshot?.kiroUsage?.overagesStatus?
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .lowercased()
+            .hasPrefix("enabled") == true
+        if overagesEnabled,
+           let overageCreditsUsed = input.snapshot?.kiroUsage?.overageCreditsUsed
+        {
+            notes.append(
+                "\(L("Overage usage")): \(UsageFormatter.kiroCreditNumber(overageCreditsUsed)) \(L("credits"))")
+        }
+        if overagesEnabled,
+           let estimatedOverageCostUSD = input.snapshot?.kiroUsage?.estimatedOverageCostUSD
+        {
+            notes.append("\(L("Overage cost")): \(UsageFormatter.usdString(estimatedOverageCostUSD))")
+        }
+        return notes
+    }
+
+    static func kiroPlan(snapshot: UsageSnapshot?) -> String? {
+        guard let plan = snapshot?.kiroUsage?.displayPlanName,
+              !plan.isEmpty
+        else { return nil }
+        return plan
+    }
+}
diff --git a/Sources/CodexBar/MenuCardView+MiniMax.swift b/Sources/CodexBar/MenuCardView+MiniMax.swift
new file mode 100644
index 0000000000..d410770619
--- /dev/null
+++ b/Sources/CodexBar/MenuCardView+MiniMax.swift
@@ -0,0 +1,135 @@
+import CodexBarCore
+import Foundation
+
+extension UsageMenuCardView.Model {
+    static func minimaxMetrics(services: [MiniMaxServiceUsage], input: Input) -> [Metric] {
+        let percentStyle: PercentStyle = .used
+        let displayNameCounts = Dictionary(grouping: services.map(\.displayName), by: { $0 }).mapValues(\.count)
+
+        return services.enumerated().map { index, service in
+            let used = service.usage
+            let displayPercent = min(100, max(0, service.percent))
+            let usageLabel = if service.isUnlimited {
+                nil as String?
+            } else {
+                String(
+                    format: L("minimax_usage_amount_format"),
+                    used.formatted(),
+                    service.limit.formatted())
+            }
+            let localizedName = Self.localizedMiniMaxServiceName(service.displayName)
+            let title = if (displayNameCounts[service.displayName] ?? 0) > 1 {
+                "\(localizedName) · \(Self.displayWindowBadge(for: service.windowType))"
+            } else {
+                localizedName
+            }
+
+            return Metric(
+                id: "minimax-service-\(index)",
+                title: title,
+                percent: displayPercent,
+                percentStyle: percentStyle,
+                statusText: service.isUnlimited ? "∞ Unlimited" : nil,
+                resetText: Self.localizedMiniMaxResetDescription(service.resetDescription),
+                detailText: nil,
+                detailLeftText: usageLabel,
+                detailRightText: nil,
+                pacePercent: nil,
+                paceOnTop: true,
+                warningMarkerPercents: service.isUnlimited
+                    ? []
+                    : Self.miniMaxWarningMarkerPercents(service: service, input: input),
+                cardStyle: false)
+        }
+    }
+
+    private static func miniMaxWarningMarkerPercents(service: MiniMaxServiceUsage, input: Input) -> [Double] {
+        switch self.miniMaxQuotaWarningWindow(for: service) {
+        case .session:
+            warningMarkerPercents(
+                thresholds: input.quotaWarningThresholds[.session],
+                showUsed: true)
+        case .weekly:
+            markerPercents(
+                thresholds: input.quotaWarningThresholds[.weekly],
+                showUsed: true,
+                workDays: input.workDaysPerWeek,
+                windowMinutes: self.miniMaxWindowMinutes(for: service.windowType),
+                includeWorkdayMarkers: true)
+        }
+    }
+
+    private static func miniMaxQuotaWarningWindow(for service: MiniMaxServiceUsage) -> QuotaWarningWindow {
+        service.windowType.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() == "weekly" ? .weekly : .session
+    }
+
+    private static func miniMaxWindowMinutes(for windowType: String) -> Int? {
+        let normalized = windowType.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+        if normalized == "weekly" {
+            return 7 * 24 * 60
+        }
+        if normalized == "today" || normalized == "daily" {
+            return 24 * 60
+        }
+        if normalized == "5h" {
+            return 5 * 60
+        }
+        let pieces = normalized.split(separator: " ")
+        guard pieces.count >= 2, let value = Int(pieces[0]) else { return nil }
+        switch pieces[1] {
+        case "hour", "hours", "hr", "hrs":
+            return value * 60
+        case "minute", "minutes", "min", "mins":
+            return value
+        default:
+            return nil
+        }
+    }
+
+    private static func displayWindowBadge(for windowType: String) -> String {
+        let trimmed = windowType.trimmingCharacters(in: .whitespacesAndNewlines)
+        let normalized = trimmed.lowercased()
+
+        if normalized == "weekly" {
+            return L("Weekly")
+        }
+        if normalized == "5 hours" || normalized == "5 hour" || normalized == "5h" {
+            return "5h"
+        }
+        if normalized == "today" {
+            return L("Today")
+        }
+        if normalized == "daily" {
+            return L("Daily")
+        }
+        return trimmed.isEmpty ? windowType : trimmed
+    }
+
+    private static func localizedMiniMaxResetDescription(_ text: String) -> String {
+        let prefix = "Resets in "
+        guard text.hasPrefix(prefix) else { return text }
+        let rest = String(text.dropFirst(prefix.count))
+        return L("Resets in %@", rest)
+    }
+
+    private static func localizedMiniMaxServiceName(_ raw: String) -> String {
+        switch raw {
+        case "Text Generation", "text_generation":
+            L("minimax_service_text_generation")
+        case "Text to Speech", "text_to_speech":
+            L("minimax_service_text_to_speech")
+        case "Music Generation", "music_generation":
+            L("minimax_service_music_generation")
+        case "Image Generation", "image_generation":
+            L("minimax_service_image_generation")
+        case "lyrics_generation":
+            L("minimax_service_lyrics_generation")
+        case "coding-plan-vlm":
+            L("minimax_service_coding_plan_vlm")
+        case "coding-plan-search":
+            L("minimax_service_coding_plan_search")
+        default:
+            raw
+        }
+    }
+}
diff --git a/Sources/CodexBar/MenuCardView+ModelHelpers.swift b/Sources/CodexBar/MenuCardView+ModelHelpers.swift
new file mode 100644
index 0000000000..c604bf2f84
--- /dev/null
+++ b/Sources/CodexBar/MenuCardView+ModelHelpers.swift
@@ -0,0 +1,726 @@
+import CodexBarCore
+import SwiftUI
+
+extension UsageMenuCardView.Model {
+    struct PaceDetail {
+        let leftLabel: String
+        let rightLabel: String?
+        let pacePercent: Double?
+        let paceOnTop: Bool
+    }
+
+    static func redactedMetricDetail(_ detail: String?, provider: UsageProvider, metricID: String) -> String? {
+        let redacted = PersonalInfoRedactor.redactEmails(in: detail, isEnabled: true)
+        guard provider == .litellm,
+              metricID == "secondary",
+              let redacted,
+              redacted.hasPrefix("Team "),
+              let separator = redacted.range(of: ": ", options: .backwards)
+        else {
+            return redacted
+        }
+        return "Team Hidden\(redacted[separator.lowerBound...])"
+    }
+
+    static func redactedMetrics(
+        _ metrics: [Metric],
+        provider: UsageProvider,
+        hidePersonalInfo: Bool) -> [Metric]
+    {
+        guard hidePersonalInfo else { return metrics }
+        return metrics.map { metric in
+            Metric(
+                id: metric.id,
+                title: PersonalInfoRedactor.redactEmails(in: metric.title, isEnabled: true) ?? metric.title,
+                percent: metric.percent,
+                percentStyle: metric.percentStyle,
+                statusText: PersonalInfoRedactor.redactEmails(in: metric.statusText, isEnabled: true),
+                resetText: PersonalInfoRedactor.redactEmails(in: metric.resetText, isEnabled: true),
+                detailText: Self.redactedMetricDetail(
+                    metric.detailText,
+                    provider: provider,
+                    metricID: metric.id),
+                detailLeftText: PersonalInfoRedactor.redactEmails(in: metric.detailLeftText, isEnabled: true),
+                detailRightText: PersonalInfoRedactor.redactEmails(in: metric.detailRightText, isEnabled: true),
+                pacePercent: metric.pacePercent,
+                paceOnTop: metric.paceOnTop,
+                warningMarkerPercents: metric.warningMarkerPercents,
+                cardStyle: metric.cardStyle)
+        }
+    }
+
+    var isOverviewErrorOnly: Bool {
+        self.subtitleStyle == .error &&
+            self.metrics.isEmpty &&
+            self.usageNotes.isEmpty &&
+            self.openAIAPIUsage == nil &&
+            self.inlineUsageDashboard == nil &&
+            self.creditsRemaining == nil &&
+            self.providerCost == nil &&
+            self.tokenUsage == nil &&
+            self.placeholder == nil
+    }
+
+    var hasUsageContent: Bool {
+        !self.metrics.isEmpty ||
+            !self.usageNotes.isEmpty ||
+            self.openAIAPIUsage != nil ||
+            self.inlineUsageDashboard != nil ||
+            self.codexResetCreditsText != nil ||
+            self.placeholder != nil
+    }
+
+    var usesStackedDetailLayout: Bool {
+        !self.metrics.isEmpty ||
+            self.creditsText != nil ||
+            self.codexResetCreditsText != nil ||
+            self.providerCost != nil ||
+            self.tokenUsage != nil
+    }
+
+    func hasCompatibleTrackedLayout(with candidate: Self) -> Bool {
+        self.hasCompatibleTrackedLayout(with: candidate, includeMetrics: true)
+    }
+
+    func hasCompatibleTrackedLayoutIgnoringMetrics(with candidate: Self) -> Bool {
+        self.hasCompatibleTrackedLayout(with: candidate, includeMetrics: false)
+    }
+
+    func hasCompatibleTrackedMetricSubset(of candidate: Self) -> Bool {
+        guard self.metrics.count < candidate.metrics.count,
+              self.hasCompatibleTrackedLayoutIgnoringMetrics(with: candidate)
+        else {
+            return false
+        }
+        return self.metrics.allSatisfy { metric in
+            candidate.metrics.contains { Self.hasCompatibleMetricLayout(metric, $0) }
+        }
+    }
+
+    private func hasCompatibleTrackedLayout(with candidate: Self, includeMetrics: Bool) -> Bool {
+        guard self.provider == candidate.provider,
+              !includeMetrics || self.metrics.count == candidate.metrics.count,
+              self.usageNotes == candidate.usageNotes,
+              (self.openAIAPIUsage == nil) == (candidate.openAIAPIUsage == nil),
+              Self.hasCompatibleCreditsLayout(
+                  currentText: self.creditsText,
+                  currentRemaining: self.creditsRemaining,
+                  candidateText: candidate.creditsText,
+                  candidateRemaining: candidate.creditsRemaining),
+              self.creditsHintText == candidate.creditsHintText,
+              self.codexResetCreditsText == candidate.codexResetCreditsText,
+              self.codexResetCreditsDetailText == candidate.codexResetCreditsDetailText,
+              self.placeholder == candidate.placeholder,
+              Self.hasCompatibleDashboardLayout(self.inlineUsageDashboard, candidate.inlineUsageDashboard),
+              Self.hasCompatibleProviderCostLayout(self.providerCost, candidate.providerCost),
+              Self.hasCompatibleTokenUsageLayout(self.tokenUsage, candidate.tokenUsage)
+        else {
+            return false
+        }
+
+        guard includeMetrics else { return true }
+        return zip(self.metrics, candidate.metrics).allSatisfy(Self.hasCompatibleMetricLayout)
+    }
+
+    private static func hasCompatibleMetricLayout(_ current: Metric, _ candidate: Metric) -> Bool {
+        current.id == candidate.id &&
+            current.title == candidate.title &&
+            current.percentStyle == candidate.percentStyle &&
+            (current.statusText == nil) == (candidate.statusText == nil) &&
+            (current.resetText == nil) == (candidate.resetText == nil) &&
+            (current.detailText == nil) == (candidate.detailText == nil) &&
+            (current.detailLeftText == nil) == (candidate.detailLeftText == nil) &&
+            (current.detailRightText == nil) == (candidate.detailRightText == nil) &&
+            current.cardStyle == candidate.cardStyle
+    }
+
+    private static func hasCompatibleCreditsLayout(
+        currentText: String?,
+        currentRemaining: Double?,
+        candidateText: String?,
+        candidateRemaining: Double?) -> Bool
+    {
+        switch (currentText, candidateText) {
+        case (nil, nil):
+            return true
+        case let (currentText?, candidateText?):
+            guard (currentRemaining == nil) == (candidateRemaining == nil) else { return false }
+            // Numeric balances render as a fixed single line beside the full-scale label.
+            // Multiline workspace balances retain their measured text until the menu reopens.
+            return currentRemaining != nil || currentText == candidateText
+        default:
+            return false
+        }
+    }
+
+    private static func hasCompatibleDashboardLayout(
+        _ current: InlineUsageDashboardModel?,
+        _ candidate: InlineUsageDashboardModel?) -> Bool
+    {
+        switch (current, candidate) {
+        case (nil, nil):
+            true
+        case let (current?, candidate?):
+            current.valueStyle == candidate.valueStyle &&
+                current.kpis.count == candidate.kpis.count &&
+                current.points.count == candidate.points.count &&
+                current.detailLines.count == candidate.detailLines.count &&
+                zip(current.kpis, candidate.kpis).allSatisfy {
+                    $0.title == $1.title && $0.emphasis == $1.emphasis
+                } &&
+                zip(current.points, candidate.points).allSatisfy {
+                    $0.id == $1.id && $0.label == $1.label
+                }
+        default:
+            false
+        }
+    }
+
+    private static func hasCompatibleProviderCostLayout(
+        _ current: ProviderCostSection?,
+        _ candidate: ProviderCostSection?) -> Bool
+    {
+        switch (current, candidate) {
+        case (nil, nil):
+            true
+        case let (current?, candidate?):
+            current.title == candidate.title &&
+                (current.percentUsed == nil) == (candidate.percentUsed == nil) &&
+                (current.percentLine == nil) == (candidate.percentLine == nil) &&
+                (current.personalSpendLine == nil) == (candidate.personalSpendLine == nil)
+        default:
+            false
+        }
+    }
+
+    private static func hasCompatibleTokenUsageLayout(
+        _ current: TokenUsageSection?,
+        _ candidate: TokenUsageSection?) -> Bool
+    {
+        switch (current, candidate) {
+        case (nil, nil):
+            true
+        case let (current?, candidate?):
+            current.hintLine == candidate.hintLine &&
+                current.errorLine == candidate.errorLine
+        default:
+            false
+        }
+    }
+
+    static func progressColor(for provider: UsageProvider) -> Color {
+        if provider == .elevenlabs {
+            return Color(nsColor: .labelColor)
+        }
+
+        let color = ProviderDescriptorRegistry.descriptor(for: provider).branding.color
+        return Color(red: color.red, green: color.green, blue: color.blue)
+    }
+
+    static func rateWindowLabels(
+        input: Input,
+        snapshot: UsageSnapshot) -> (primary: String, secondary: String, tertiary: String, showsTertiary: Bool)
+    {
+        if input.provider == .factory, snapshot.tertiary != nil {
+            return ("5-hour", L("Weekly"), L("Monthly"), true)
+        }
+        // Legacy request-based Cursor plans track a request quota, not the token-based "Total" pool.
+        let primaryLabel = if input.provider == .cursor, snapshot.cursorRequests != nil {
+            "Requests"
+        } else if input.provider == .grok {
+            GrokProviderDescriptor.primaryLabel(window: snapshot.primary) ?? input.metadata.sessionLabel
+        } else {
+            input.metadata.sessionLabel
+        }
+        return (
+            L(primaryLabel),
+            L(input.metadata.weeklyLabel),
+            input.metadata.opusLabel.map(L) ?? L("Sonnet"),
+            input.metadata.supportsOpus)
+    }
+
+    static func resetText(
+        for window: RateWindow,
+        style: ResetTimeDisplayStyle,
+        now: Date) -> String?
+    {
+        UsageFormatter.resetLine(for: window, style: style, now: now)
+    }
+
+    static func placeholder(input: Input) -> String? {
+        if self.shouldShowRateLimitsUnavailablePlaceholder(input: input) {
+            return L("Limits not available")
+        }
+
+        if input.snapshot == nil, !input.isRefreshing, input.lastError == nil {
+            return self.hasLocalCodexTokenUsage(input) ? nil : L("No usage yet")
+        }
+
+        return nil
+    }
+
+    static func lastError(input: Input) -> String? {
+        guard let lastError = input.lastError?.trimmingCharacters(in: .whitespacesAndNewlines),
+              !lastError.isEmpty
+        else {
+            return nil
+        }
+        if self.shouldShowRateLimitsUnavailablePlaceholder(input: input, lastError: lastError) {
+            return nil
+        }
+        return lastError
+    }
+
+    static func dashboardHint(error: String?) -> String? {
+        guard let error, !error.isEmpty else { return nil }
+        return error
+    }
+
+    static func mimoUsageNotes(input: Input, subscriptionNotes: [String]) -> [String] {
+        let source = input.sourceLabel?
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .lowercased()
+        guard source != "local" else { return [] }
+        return [
+            L("Balance updates in near-real time (up to 5 min lag)"),
+            L("Daily billing data finalizes at 07:00 UTC"),
+        ] + subscriptionNotes
+    }
+
+    static func subscriptionMetadataNotes(snapshot: UsageSnapshot?, provider: UsageProvider) -> [String] {
+        guard let snapshot else { return [] }
+        if let renewsAt = snapshot.subscriptionRenewsAt {
+            return [String(format: L("Renews: %@"), self.subscriptionDateString(renewsAt, provider: provider))]
+        }
+        if let expiresAt = snapshot.subscriptionExpiresAt {
+            return [String(format: L("Plan expires: %@"), self.subscriptionDateString(expiresAt, provider: provider))]
+        }
+        return []
+    }
+
+    private static func subscriptionDateString(_ date: Date, provider: UsageProvider) -> String {
+        let formatter = DateFormatter()
+        formatter.locale = Locale.current
+        formatter.timeZone = self.subscriptionDateTimeZone(provider: provider)
+        formatter.setLocalizedDateFormatFromTemplate("MMM d, yyyy")
+        return formatter.string(from: date)
+    }
+
+    private static func subscriptionDateTimeZone(provider: UsageProvider) -> TimeZone {
+        switch provider {
+        case .minimax:
+            TimeZone(identifier: "Asia/Shanghai") ?? .current
+        default:
+            .current
+        }
+    }
+
+    static func poeBalanceDetailText(input: Input) -> String? {
+        guard input.provider == .poe else { return nil }
+        return StatusItemController.poeBalanceDisplayText(snapshot: input.snapshot)
+    }
+
+    private static func hasLocalCodexTokenUsage(_ input: Input) -> Bool {
+        input.provider == .codex &&
+            input.tokenCostUsageEnabled &&
+            self.tokenUsageSnapshot(input: input) != nil
+    }
+
+    private static func shouldShowRateLimitsUnavailablePlaceholder(input: Input, lastError: String? = nil) -> Bool {
+        let currentError = lastError ?? input.lastError
+        if let currentError = currentError?.trimmingCharacters(in: .whitespacesAndNewlines),
+           !currentError.isEmpty,
+           !UsageError.isNoRateLimitsFoundDescription(currentError)
+        {
+            return false
+        }
+        return self.rateLimitsUnavailable(input: input, lastError: currentError)
+    }
+
+    private static func rateLimitsUnavailable(input: Input, lastError: String? = nil) -> Bool {
+        UsageLimitsAvailability.resolve(
+            provider: input.provider,
+            snapshot: input.snapshot,
+            account: input.account,
+            lastErrorDescription: lastError ?? input.lastError)
+            .isUnavailable
+    }
+
+    static func sessionPaceDetail(
+        provider: UsageProvider,
+        window: RateWindow,
+        now: Date,
+        showUsed: Bool) -> PaceDetail?
+    {
+        guard let detail = UsagePaceText.sessionDetail(provider: provider, window: window, now: now) else { return nil }
+        let expectedUsed = detail.expectedUsedPercent
+        let actualUsed = window.usedPercent
+        let expectedPercent = showUsed ? expectedUsed : (100 - expectedUsed)
+        let actualPercent = showUsed ? actualUsed : (100 - actualUsed)
+        if expectedPercent.isFinite == false || actualPercent.isFinite == false { return nil }
+        let paceOnTop = actualUsed <= expectedUsed
+        let pacePercent: Double? = if detail.stage == .onTrack { nil } else { expectedPercent }
+        return PaceDetail(
+            leftLabel: detail.leftLabel,
+            rightLabel: detail.rightLabel,
+            pacePercent: pacePercent,
+            paceOnTop: paceOnTop)
+    }
+
+    static func weeklyPaceDetail(
+        window: RateWindow,
+        now: Date,
+        pace: UsagePace?,
+        showUsed: Bool) -> PaceDetail?
+    {
+        guard let pace else { return nil }
+        let detail = UsagePaceText.weeklyDetail(pace: pace, now: now)
+        let expectedUsed = detail.expectedUsedPercent
+        let actualUsed = window.usedPercent
+        let expectedPercent = showUsed ? expectedUsed : (100 - expectedUsed)
+        let actualPercent = showUsed ? actualUsed : (100 - actualUsed)
+        if expectedPercent.isFinite == false || actualPercent.isFinite == false { return nil }
+        let paceOnTop = actualUsed <= expectedUsed
+        let pacePercent: Double? = if detail.stage == .onTrack { nil } else { expectedPercent }
+        return PaceDetail(
+            leftLabel: detail.leftLabel,
+            rightLabel: detail.rightLabel,
+            pacePercent: pacePercent,
+            paceOnTop: paceOnTop)
+    }
+
+    static func standardWeeklyPace(input: Input, window: RateWindow) -> UsagePace? {
+        if let weeklyPace = input.weeklyPace {
+            return weeklyPace
+        }
+        return Self.displayableWeeklyPace(UsagePace.weekly(
+            window: window,
+            now: input.now,
+            defaultWindowMinutes: 10080,
+            workDays: input.workDaysPerWeek))
+    }
+
+    private static func displayableWeeklyPace(_ pace: UsagePace?) -> UsagePace? {
+        guard let pace else { return nil }
+        return pace.expectedUsedPercent >= 3 || pace.etaSeconds == 0 ? pace : nil
+    }
+
+    static func cursorBillingCyclePaceDetail(
+        window: RateWindow,
+        input: Input,
+        pace: UsagePace? = nil) -> PaceDetail?
+    {
+        guard input.provider == .cursor,
+              window.windowMinutes != nil
+        else { return nil }
+        let resolved = pace ?? UsagePace.weekly(
+            window: window,
+            now: input.now,
+            defaultWindowMinutes: 10080,
+            workDays: input.workDaysPerWeek)
+        guard let resolved = Self.displayableWeeklyPace(resolved) else { return nil }
+        return Self.weeklyPaceDetail(
+            window: window,
+            now: input.now,
+            pace: resolved,
+            showUsed: input.usageBarsShowUsed)
+    }
+
+    static func antigravityMetrics(input: Input, snapshot: UsageSnapshot) -> [Metric] {
+        let percentStyle: PercentStyle = input.usageBarsShowUsed ? .used : .left
+        if Self.hasAntigravityQuotaSummaryWindows(snapshot) {
+            return Self.extraRateWindowMetrics(
+                snapshot: snapshot,
+                input: input,
+                percentStyle: percentStyle)
+        }
+
+        var metrics: [Metric] = []
+        if let primary = snapshot.primary {
+            metrics.append(Self.antigravityMetric(
+                id: "primary",
+                title: L(input.metadata.sessionLabel),
+                window: primary,
+                input: input,
+                percentStyle: percentStyle))
+        }
+        if let secondary = snapshot.secondary {
+            metrics.append(Self.antigravityMetric(
+                id: "secondary",
+                title: L(input.metadata.weeklyLabel),
+                window: secondary,
+                input: input,
+                percentStyle: percentStyle))
+        }
+        if input.metadata.supportsOpus, let tertiary = snapshot.tertiary {
+            metrics.append(Self.antigravityMetric(
+                id: "tertiary",
+                title: input.metadata.opusLabel.map(L) ?? L("Gemini Flash"),
+                window: tertiary,
+                input: input,
+                percentStyle: percentStyle))
+        }
+        metrics.append(contentsOf: Self.extraRateWindowMetrics(
+            snapshot: snapshot,
+            input: input,
+            percentStyle: percentStyle))
+        return metrics
+    }
+
+    static func extraRateWindowMetrics(
+        snapshot: UsageSnapshot,
+        input: Input,
+        percentStyle: PercentStyle) -> [Metric]
+    {
+        guard let extraRateWindows = snapshot.extraRateWindows else { return [] }
+        // Codex additional limits (e.g. Codex Spark) are optional extra usage and follow the
+        // "optional credits and extra usage" setting. Other providers' extra windows (Antigravity
+        // per-model quotas, Factory core windows, etc.) are core data and must always render.
+        if input.provider == .codex, !input.showOptionalCreditsAndExtraUsage {
+            return []
+        }
+        if input.provider == .copilot, !input.copilotBudgetExtrasEnabled {
+            return []
+        }
+        return extraRateWindows.map { namedWindow in
+            let paceDetail = Self.extraRateWindowPaceDetail(
+                provider: input.provider,
+                window: namedWindow.window,
+                input: input)
+            let usageKnown = namedWindow.usageKnown
+            let resetText = Self.extraRateWindowResetText(
+                namedWindow: namedWindow,
+                input: input)
+            let statusText: String? = if usageKnown {
+                nil
+            } else if let resetText {
+                "\(L("Unavailable")) - \(resetText)"
+            } else {
+                L("Unavailable")
+            }
+            return Metric(
+                id: namedWindow.id,
+                title: namedWindow.title,
+                percent: Self.clamped(
+                    input.usageBarsShowUsed
+                        ? namedWindow.window.usedPercent
+                        : namedWindow.window.remainingPercent),
+                percentStyle: percentStyle,
+                statusText: statusText,
+                resetText: usageKnown ? resetText : nil,
+                detailText: nil,
+                detailLeftText: usageKnown ? paceDetail?.leftLabel : nil,
+                detailRightText: usageKnown ? paceDetail?.rightLabel : nil,
+                pacePercent: usageKnown ? paceDetail?.pacePercent : nil,
+                paceOnTop: paceDetail?.paceOnTop ?? true)
+        }
+    }
+
+    private static let antigravityQuotaSummaryWindowIDPrefix = "antigravity-quota-summary-"
+
+    private static func hasAntigravityQuotaSummaryWindows(_ snapshot: UsageSnapshot) -> Bool {
+        snapshot.extraRateWindows?.contains(where: self.isAntigravityQuotaSummaryWindow) == true
+    }
+
+    private static func isAntigravityQuotaSummaryWindow(_ namedWindow: NamedRateWindow) -> Bool {
+        namedWindow.id.hasPrefix(self.antigravityQuotaSummaryWindowIDPrefix)
+    }
+
+    private static func extraRateWindowResetText(
+        namedWindow: NamedRateWindow,
+        input: Input) -> String?
+    {
+        if namedWindow.window.resetsAt != nil {
+            return self.resetText(
+                for: namedWindow.window,
+                style: input.resetTimeDisplayStyle,
+                now: input.now)
+        }
+        if input.provider == .antigravity,
+           self.isAntigravityQuotaSummaryWindow(namedWindow)
+        {
+            return self.antigravityQuotaSummaryResetText(namedWindow.window.resetDescription)
+        }
+        return self.resetText(
+            for: namedWindow.window,
+            style: input.resetTimeDisplayStyle,
+            now: input.now)
+    }
+
+    private static func antigravityQuotaSummaryResetText(_ description: String?) -> String? {
+        guard let description = description?.trimmingCharacters(in: .whitespacesAndNewlines),
+              !description.isEmpty
+        else { return nil }
+
+        if let range = description.range(of: "fully refresh in ", options: .caseInsensitive) {
+            var suffix = String(description[range.upperBound...])
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+            while suffix.last == "." {
+                suffix.removeLast()
+            }
+            guard !suffix.isEmpty else { return description }
+            return String(format: L("Resets in %@"), suffix)
+        }
+
+        return description
+    }
+
+    private static func extraRateWindowPaceDetail(
+        provider: UsageProvider,
+        window: RateWindow,
+        input: Input) -> PaceDetail?
+    {
+        guard provider == .codex else { return nil }
+        switch window.windowMinutes {
+        case 300:
+            return self.sessionPaceDetail(
+                provider: provider,
+                window: window,
+                now: input.now,
+                showUsed: input.usageBarsShowUsed)
+        case 10080:
+            let pace = Self.displayableWeeklyPace(UsagePace.weekly(
+                window: window,
+                now: input.now,
+                defaultWindowMinutes: 10080,
+                workDays: input.workDaysPerWeek))
+            return Self.weeklyPaceDetail(
+                window: window,
+                now: input.now,
+                pace: pace,
+                showUsed: input.usageBarsShowUsed)
+        default:
+            return nil
+        }
+    }
+
+    static func antigravityMetric(
+        id: String,
+        title: String,
+        window: RateWindow?,
+        input: Input,
+        percentStyle: PercentStyle) -> Metric
+    {
+        guard let window else {
+            let placeholderPercent = input.usageBarsShowUsed ? 100.0 : 0.0
+            return Metric(
+                id: id,
+                title: title,
+                percent: placeholderPercent,
+                percentStyle: percentStyle,
+                statusText: nil,
+                resetText: nil,
+                detailText: nil,
+                detailLeftText: nil,
+                detailRightText: nil,
+                pacePercent: nil,
+                paceOnTop: true)
+        }
+        let percent = input.usageBarsShowUsed ? window.usedPercent : window.remainingPercent
+        return Metric(
+            id: id,
+            title: title,
+            percent: Self.clamped(percent),
+            percentStyle: percentStyle,
+            resetText: Self.resetText(for: window, style: input.resetTimeDisplayStyle, now: input.now),
+            detailText: nil,
+            detailLeftText: nil,
+            detailRightText: nil,
+            pacePercent: nil,
+            paceOnTop: true)
+    }
+
+    static func zaiLimitDetailText(limit: ZaiLimitEntry?) -> String? {
+        guard let limit else { return nil }
+
+        if let currentValue = limit.currentValue,
+           let usage = limit.usage,
+           let remaining = limit.remaining
+        {
+            let currentStr = UsageFormatter.tokenCountString(currentValue)
+            let usageStr = UsageFormatter.tokenCountString(usage)
+            let remainingStr = UsageFormatter.tokenCountString(remaining)
+            return String(format: L("%@ / %@ (%@ remaining)"), currentStr, usageStr, remainingStr)
+        }
+
+        return nil
+    }
+
+    static func openRouterQuotaDetail(provider: UsageProvider, snapshot: UsageSnapshot) -> String? {
+        guard provider == .openrouter,
+              let usage = snapshot.openRouterUsage,
+              usage.hasValidKeyQuota,
+              let keyRemaining = usage.keyRemaining,
+              let keyLimit = usage.keyLimit
+        else {
+            return nil
+        }
+
+        let remaining = UsageFormatter.usdString(keyRemaining)
+        let limit = UsageFormatter.usdString(keyLimit)
+        return String(format: L("%@/%@ left"), remaining, limit)
+    }
+
+    static func syntheticRegenDetail(
+        weekly: RateWindow,
+        cost: ProviderCostSnapshot?,
+        now: Date,
+        showUsed: Bool) -> (resetText: String, pace: PaceDetail)?
+    {
+        guard let cost,
+              cost.limit > 0,
+              let nextRegenAmount = cost.nextRegenAmount,
+              nextRegenAmount > 0,
+              let resetsAt = weekly.resetsAt
+        else { return nil }
+
+        let countdown = UsageFormatter.resetCountdownDescription(from: resetsAt, now: now)
+        let resetText = String(format: L("Regenerates %@"), countdown)
+
+        let nextRegenPercent = (nextRegenAmount / cost.limit) * 100
+        let afterNextRegenRemaining = min(100, weekly.remainingPercent + nextRegenPercent)
+        let afterNextRegen = showUsed ? max(0, 100 - afterNextRegenRemaining) : afterNextRegenRemaining
+        let suffix = showUsed ? L("used after next regen") : L("after next regen")
+        let ticksToFull = max(0, cost.used) / nextRegenAmount
+        let left = String(format: "%.0f%% %@", afterNextRegen, suffix)
+        let right = if ticksToFull <= 0.1 {
+            L("Near full")
+        } else if ticksToFull < 1.5 {
+            L("Full in ~1 regen")
+        } else {
+            String(format: L("Full in ~%.0f regens"), ceil(ticksToFull))
+        }
+        return (resetText, PaceDetail(leftLabel: left, rightLabel: right, pacePercent: nil, paceOnTop: true))
+    }
+
+    static func syntheticRollingRegenDetail(
+        window: RateWindow,
+        now: Date,
+        showUsed: Bool) -> (resetText: String, pace: PaceDetail)?
+    {
+        guard let resetsAt = window.resetsAt,
+              let nextRegenPercent = window.nextRegenPercent,
+              nextRegenPercent > 0
+        else { return nil }
+
+        let countdown = UsageFormatter.resetCountdownDescription(from: resetsAt, now: now)
+        let resetText = String(format: L("Regenerates %@"), countdown)
+
+        let afterNextRegenRemaining = min(100, window.remainingPercent + nextRegenPercent)
+        let afterNextRegen = showUsed ? max(0, 100 - afterNextRegenRemaining) : afterNextRegenRemaining
+        let suffix = showUsed ? L("used after next regen") : L("after next regen")
+        let left = String(format: "%.0f%% %@", afterNextRegen, suffix)
+
+        let missingPercent = max(0, window.usedPercent)
+        let ticksToFull = missingPercent / nextRegenPercent
+        let right = if ticksToFull <= 0.1 {
+            L("Near full")
+        } else if ticksToFull < 1.5 {
+            L("Full in ~1 regen")
+        } else {
+            String(format: L("Full in ~%.0f regens"), ceil(ticksToFull))
+        }
+
+        return (resetText, PaceDetail(leftLabel: left, rightLabel: right, pacePercent: nil, paceOnTop: true))
+    }
+}
diff --git a/Sources/CodexBar/MenuCardView.swift b/Sources/CodexBar/MenuCardView.swift
index 789a517e11..22de077a85 100644
--- a/Sources/CodexBar/MenuCardView.swift
+++ b/Sources/CodexBar/MenuCardView.swift
@@ -5,21 +5,21 @@ import SwiftUI
 /// SwiftUI card used inside the NSMenu to mirror Apple's rich menu panels.
 struct UsageMenuCardView: View {
     struct Model {
-        enum PercentStyle: String, Sendable {
+        enum PercentStyle: String {
             case left
             case used
 
             var labelSuffix: String {
                 switch self {
-                case .left: "left"
-                case .used: "used"
+                case .left: L("usage_percent_suffix_left")
+                case .used: L("usage_percent_suffix_used")
                 }
             }
 
             var accessibilityLabel: String {
                 switch self {
-                case .left: "Usage remaining"
-                case .used: "Usage used"
+                case .left: L("Usage remaining")
+                case .used: L("Usage used")
                 }
             }
         }
@@ -29,12 +29,45 @@ struct UsageMenuCardView: View {
             let title: String
             let percent: Double
             let percentStyle: PercentStyle
+            let statusText: String?
             let resetText: String?
             let detailText: String?
             let detailLeftText: String?
             let detailRightText: String?
             let pacePercent: Double?
             let paceOnTop: Bool
+            let warningMarkerPercents: [Double]
+            let cardStyle: Bool
+
+            init(
+                id: String,
+                title: String,
+                percent: Double,
+                percentStyle: PercentStyle,
+                statusText: String? = nil,
+                resetText: String?,
+                detailText: String?,
+                detailLeftText: String?,
+                detailRightText: String?,
+                pacePercent: Double?,
+                paceOnTop: Bool,
+                warningMarkerPercents: [Double] = [],
+                cardStyle: Bool = false)
+            {
+                self.id = id
+                self.title = title
+                self.percent = percent
+                self.percentStyle = percentStyle
+                self.statusText = statusText
+                self.resetText = resetText
+                self.detailText = detailText
+                self.detailLeftText = detailLeftText
+                self.detailRightText = detailRightText
+                self.pacePercent = pacePercent
+                self.paceOnTop = paceOnTop
+                self.warningMarkerPercents = warningMarkerPercents
+                self.cardStyle = cardStyle
+            }
 
             var percentLabel: String {
                 String(format: "%.0f%% %@", self.percent, self.percentStyle.labelSuffix)
@@ -47,7 +80,7 @@ struct UsageMenuCardView: View {
             case error
         }
 
-        struct TokenUsageSection: Sendable {
+        struct TokenUsageSection {
             let sessionLine: String
             let monthLine: String
             let hintLine: String?
@@ -55,10 +88,12 @@ struct UsageMenuCardView: View {
             let errorCopyText: String?
         }
 
-        struct ProviderCostSection: Sendable {
+        struct ProviderCostSection {
             let title: String
-            let percentUsed: Double
+            let percentUsed: Double?
             let spendLine: String
+            let percentLine: String?
+            var personalSpendLine: String?
         }
 
         let provider: UsageProvider
@@ -66,13 +101,18 @@ struct UsageMenuCardView: View {
         let email: String
         let subtitleText: String
         let subtitleStyle: SubtitleStyle
+        var usesLiveSubtitle: Bool = false
         let planText: String?
         let metrics: [Metric]
         let usageNotes: [String]
+        let openAIAPIUsage: OpenAIAPIUsageSnapshot?
+        let inlineUsageDashboard: InlineUsageDashboardModel?
         let creditsText: String?
         let creditsRemaining: Double?
         let creditsHintText: String?
         let creditsHintCopyText: String?
+        var codexResetCreditsText: String?
+        var codexResetCreditsDetailText: String?
         let providerCost: ProviderCostSection?
         let tokenUsage: TokenUsageSection?
         let placeholder: String?
@@ -80,83 +120,83 @@ struct UsageMenuCardView: View {
     }
 
     let model: Model
+    var layoutModel: Model?
     let width: CGFloat
     @Environment(\.menuItemHighlighted) private var isHighlighted
+    @Environment(\.menuCardRefreshMonitor) private var refreshMonitor
 
     static func popupMetricTitle(provider: UsageProvider, metric: Model.Metric) -> String {
         if provider == .openrouter, metric.id == "primary" {
-            return "API key limit"
+            return L("API key limit")
         }
         return metric.title
     }
 
     var body: some View {
-        VStack(alignment: .leading, spacing: 6) {
-            UsageMenuCardHeaderView(model: self.model)
+        let liveModel = self.liveModel
+        VStack(alignment: .leading, spacing: 0) {
+            UsageMenuCardHeaderView(model: self.layoutModel ?? self.model)
 
-            if self.hasDetails {
+            if Self.hasDetails(for: liveModel) {
                 Divider()
+                    .padding(.top, UsageMenuCardLayout.headerContentSpacing)
+                    .padding(.bottom, Self.dividerBottomPadding(for: liveModel))
             }
 
-            if self.model.metrics.isEmpty {
-                if !self.model.usageNotes.isEmpty {
-                    UsageNotesContent(notes: self.model.usageNotes)
-                } else if let placeholder = self.model.placeholder {
+            if !liveModel.usesStackedDetailLayout {
+                if let dashboard = liveModel.inlineUsageDashboard {
+                    InlineUsageDashboardContent(model: dashboard)
+                } else if !liveModel.usageNotes.isEmpty {
+                    UsageNotesContent(notes: liveModel.usageNotes)
+                } else if let placeholder = liveModel.placeholder {
+                    // Non-stacked placeholders are standalone detail rows; stacked usage placeholders are gated below.
                     Text(placeholder)
                         .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
                         .font(.subheadline)
                 }
             } else {
-                let hasUsage = !self.model.metrics.isEmpty || !self.model.usageNotes.isEmpty
-                let hasCredits = self.model.creditsText != nil
-                let hasProviderCost = self.model.providerCost != nil
-                let hasCost = self.model.tokenUsage != nil || hasProviderCost
+                let hasUsage = liveModel.hasUsageContent
+                let hasCredits = liveModel.creditsText != nil
+                let hasProviderCost = liveModel.providerCost != nil
+                let hasCost = liveModel.tokenUsage != nil || hasProviderCost
 
                 VStack(alignment: .leading, spacing: 12) {
                     if hasUsage {
-                        VStack(alignment: .leading, spacing: 12) {
-                            ForEach(self.model.metrics, id: \.id) { metric in
-                                MetricRow(
-                                    metric: metric,
-                                    title: Self.popupMetricTitle(provider: self.model.provider, metric: metric),
-                                    progressColor: self.model.progressColor)
-                            }
-                            if !self.model.usageNotes.isEmpty {
-                                UsageNotesContent(notes: self.model.usageNotes)
-                            }
-                        }
+                        UsageMenuCardUsageContentView(model: liveModel, showBottomDivider: false)
                     }
                     if hasUsage, hasCredits || hasCost {
                         Divider()
                     }
-                    if let credits = self.model.creditsText {
+                    if let credits = liveModel.creditsText {
                         CreditsBarContent(
                             creditsText: credits,
-                            creditsRemaining: self.model.creditsRemaining,
-                            hintText: self.model.creditsHintText,
-                            hintCopyText: self.model.creditsHintCopyText,
-                            progressColor: self.model.progressColor)
+                            creditsRemaining: liveModel.creditsRemaining,
+                            hintText: liveModel.creditsHintText,
+                            hintCopyText: liveModel.creditsHintCopyText,
+                            progressColor: liveModel.progressColor)
                     }
                     if hasCredits, hasCost {
                         Divider()
                     }
-                    if let providerCost = self.model.providerCost {
+                    if let providerCost = liveModel.providerCost {
                         ProviderCostContent(
                             section: providerCost,
-                            progressColor: self.model.progressColor)
+                            progressColor: liveModel.progressColor)
                     }
-                    if hasProviderCost, self.model.tokenUsage != nil {
+                    if hasProviderCost, liveModel.tokenUsage != nil {
                         Divider()
                     }
-                    if let tokenUsage = self.model.tokenUsage {
+                    if let tokenUsage = liveModel.tokenUsage {
                         VStack(alignment: .leading, spacing: 6) {
-                            Text("Cost")
+                            Text(L("cost_header_estimated"))
                                 .font(.body)
                                 .fontWeight(.medium)
                             Text(tokenUsage.sessionLine)
                                 .font(.footnote)
+                                .lineLimit(1)
                             Text(tokenUsage.monthLine)
                                 .font(.footnote)
+                                .lineLimit(1)
                             if let hint = tokenUsage.hintLine, !hint.isEmpty {
                                 Text(hint)
                                     .font(.footnote)
@@ -177,50 +217,96 @@ struct UsageMenuCardView: View {
                         }
                     }
                 }
-                .padding(.bottom, self.model.creditsText == nil ? 6 : 0)
             }
         }
-        .padding(.horizontal, 16)
-        .padding(.top, 2)
-        .padding(.bottom, 2)
+        .padding(.horizontal, UsageMenuCardLayout.horizontalPadding)
+        .padding(
+            .top,
+            Self.hasDetails(for: liveModel)
+                ? UsageMenuCardLayout.sectionTopPadding
+                : UsageMenuCardLayout.headerOnlyVerticalPadding)
+        // AppKit's following separator row adds visual bottom space, so detail cards keep this inset tight.
+        .padding(
+            .bottom,
+            Self.hasDetails(for: liveModel)
+                ? UsageMenuCardLayout.sectionBottomPadding
+                : UsageMenuCardLayout.headerOnlyVerticalPadding)
         .frame(width: self.width, alignment: .leading)
     }
 
-    private var hasDetails: Bool {
-        !self.model.metrics.isEmpty || !self.model.usageNotes.isEmpty || self.model.placeholder != nil ||
-            self.model.tokenUsage != nil ||
-            self.model.providerCost != nil
+    private var liveModel: Model {
+        guard self.model.usesLiveSubtitle else { return self.model }
+        return self.refreshMonitor?.model(for: self.model.provider, fallback: self.model) ?? self.model
+    }
+
+    private static func hasDetails(for model: Model) -> Bool {
+        model.hasUsageContent || model.usesStackedDetailLayout
+    }
+
+    static func dividerBottomPadding(for model: Model) -> CGFloat {
+        if model.usesStackedDetailLayout, model.hasUsageContent {
+            return UsageMenuCardLayout.postHeaderDividerContentSpacing
+        }
+        return UsageMenuCardLayout.sectionBottomPadding
     }
 }
 
 private struct UsageMenuCardHeaderView: View {
     let model: UsageMenuCardView.Model
     @Environment(\.menuItemHighlighted) private var isHighlighted
+    @Environment(\.menuCardRefreshMonitor) private var refreshMonitor
 
     var body: some View {
-        VStack(alignment: .leading, spacing: 3) {
-            HStack(alignment: .firstTextBaseline) {
-                Text(self.model.providerName)
-                    .font(.headline)
+        VStack(alignment: .leading, spacing: UsageMenuCardLayout.headerLineSpacing) {
+            HStack(alignment: .firstTextBaseline, spacing: UsageMenuCardLayout.headerColumnSpacing) {
+                Text(self.model.providerName).font(.headline)
                     .fontWeight(.semibold)
+                    .lineLimit(1).truncationMode(.tail).layoutPriority(1)
                 Spacer()
-                Text(self.model.email)
-                    .font(.subheadline)
+                Text(self.model.email).font(.subheadline)
                     .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
+                    .lineLimit(1).truncationMode(.middle)
             }
-            let subtitleAlignment: VerticalAlignment = self.model.subtitleStyle == .error ? .top : .firstTextBaseline
-            HStack(alignment: subtitleAlignment) {
-                Text(self.model.subtitleText)
-                    .font(.footnote)
-                    .foregroundStyle(self.subtitleColor)
-                    .lineLimit(self.model.subtitleStyle == .error ? 4 : 1)
-                    .multilineTextAlignment(.leading)
-                    .fixedSize(horizontal: false, vertical: true)
-                    .layoutPriority(1)
-                    .padding(.bottom, self.model.subtitleStyle == .error ? 4 : 0)
+            let liveSubtitle = self.liveSubtitle
+            // Keep the geometry AppKit measured for this hosted row. A new error stays one line
+            // until the next rebuild; a recovered error keeps its reserved height until then.
+            let usesErrorLayout = self.model.subtitleStyle == .error
+            let subtitleAlignment: VerticalAlignment = usesErrorLayout ? .top : .firstTextBaseline
+            HStack(alignment: subtitleAlignment, spacing: UsageMenuCardLayout.headerColumnSpacing) {
+                if usesErrorLayout {
+                    Text(self.model.subtitleText)
+                        .font(.footnote)
+                        .lineLimit(4)
+                        .multilineTextAlignment(.leading)
+                        .fixedSize(horizontal: false, vertical: true)
+                        .padding(.bottom, 4)
+                        .hidden()
+                        .overlay(alignment: .topLeading) {
+                            Text(liveSubtitle.text)
+                                .font(.footnote)
+                                .foregroundStyle(self.subtitleColor(for: liveSubtitle.style))
+                                .lineLimit(4)
+                                .multilineTextAlignment(.leading)
+                                .fixedSize(horizontal: false, vertical: true)
+                        }
+                        .clipped()
+                        .layoutPriority(1)
+                } else {
+                    Text(liveSubtitle.text)
+                        .font(.footnote)
+                        .foregroundStyle(self.subtitleColor(for: liveSubtitle.style))
+                        .lineLimit(1)
+                        .multilineTextAlignment(.leading)
+                        .fixedSize(horizontal: false, vertical: true)
+                        .layoutPriority(1)
+                }
                 Spacer()
-                if self.model.subtitleStyle == .error, !self.model.subtitleText.isEmpty {
-                    CopyIconButton(copyText: self.model.subtitleText, isHighlighted: self.isHighlighted)
+                if usesErrorLayout {
+                    let showsCopyButton = liveSubtitle.style == .error && !liveSubtitle.text.isEmpty
+                    CopyIconButton(copyText: liveSubtitle.text, isHighlighted: self.isHighlighted)
+                        .opacity(showsCopyButton ? 1 : 0)
+                        .allowsHitTesting(showsCopyButton)
+                        .accessibilityHidden(!showsCopyButton)
                 }
                 if let plan = self.model.planText {
                     Text(plan)
@@ -232,8 +318,14 @@ private struct UsageMenuCardHeaderView: View {
         }
     }
 
-    private var subtitleColor: Color {
-        switch self.model.subtitleStyle {
+    private var liveSubtitle: MenuCardLiveSubtitle {
+        let fallback = MenuCardLiveSubtitle(text: self.model.subtitleText, style: self.model.subtitleStyle)
+        guard self.model.usesLiveSubtitle else { return fallback }
+        return self.refreshMonitor?.subtitle(for: self.model.provider, fallback: fallback) ?? fallback
+    }
+
+    private func subtitleColor(for style: UsageMenuCardView.Model.SubtitleStyle) -> Color {
+        switch style {
         case .info: MenuHighlightStyle.secondary(self.isHighlighted)
         case .loading: MenuHighlightStyle.secondary(self.isHighlighted)
         case .error: MenuHighlightStyle.error(self.isHighlighted)
@@ -265,17 +357,7 @@ private struct CopyIconButton: View {
 
     var body: some View {
         Button {
-            self.copyToPasteboard()
-            withAnimation(.easeOut(duration: 0.12)) {
-                self.didCopy = true
-            }
-            self.resetTask?.cancel()
-            self.resetTask = Task { @MainActor in
-                try? await Task.sleep(for: .seconds(0.9))
-                withAnimation(.easeOut(duration: 0.2)) {
-                    self.didCopy = false
-                }
-            }
+            self.handleCopy()
         } label: {
             Image(systemName: self.didCopy ? "checkmark" : "doc.on.doc")
                 .font(.caption2.weight(.semibold))
@@ -283,13 +365,19 @@ private struct CopyIconButton: View {
                 .frame(width: 18, height: 18)
         }
         .buttonStyle(CopyIconButtonStyle(isHighlighted: self.isHighlighted))
-        .accessibilityLabel(self.didCopy ? "Copied" : "Copy error")
+        .accessibilityLabel(self.didCopy ? L("Copied") : L("Copy error"))
     }
 
-    private func copyToPasteboard() {
-        let pb = NSPasteboard.general
-        pb.clearContents()
-        pb.setString(self.copyText, forType: .string)
+    private func handleCopy() {
+        let text = self.copyText
+        self.resetTask?.cancel()
+        MenuPasteboardCopy.perform(text, completion: {
+            self.didCopy = true
+            self.resetTask = Task { @MainActor in
+                try? await Task.sleep(for: .seconds(0.9))
+                self.didCopy = false
+            }
+        })
     }
 }
 
@@ -303,17 +391,25 @@ private struct ProviderCostContent: View {
             Text(self.section.title)
                 .font(.body)
                 .fontWeight(.medium)
-            UsageProgressBar(
-                percent: self.section.percentUsed,
-                tint: self.progressColor,
-                accessibilityLabel: "Extra usage spent")
+            if let percentUsed = self.section.percentUsed {
+                UsageProgressBar(
+                    percent: percentUsed,
+                    tint: self.progressColor,
+                    accessibilityLabel: L("Extra usage spent"))
+            }
             HStack(alignment: .firstTextBaseline) {
-                Text(self.section.spendLine)
-                    .font(.footnote)
+                Text(self.section.spendLine).font(.footnote).lineLimit(1)
                 Spacer()
-                Text(String(format: "%.0f%% used", min(100, max(0, self.section.percentUsed))))
-                    .font(.footnote)
-                    .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
+                if let percentLine = self.section.percentLine {
+                    Text(percentLine)
+                        .font(.footnote)
+                        .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
+                        .lineLimit(1)
+                }
+            }
+            if let personalSpendLine = self.section.personalSpendLine {
+                Text(personalSpendLine)
+                    .font(.footnote).foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted)).lineLimit(1)
             }
         }
     }
@@ -330,52 +426,63 @@ private struct MetricRow: View {
             Text(self.title)
                 .font(.body)
                 .fontWeight(.medium)
-            UsageProgressBar(
-                percent: self.metric.percent,
-                tint: self.progressColor,
-                accessibilityLabel: self.metric.percentStyle.accessibilityLabel,
-                pacePercent: self.metric.pacePercent,
-                paceOnTop: self.metric.paceOnTop)
-            VStack(alignment: .leading, spacing: 2) {
-                HStack(alignment: .firstTextBaseline) {
-                    Text(self.metric.percentLabel)
-                        .font(.footnote)
-                        .lineLimit(1)
-                    Spacer()
-                    if let rightLabel = self.metric.resetText {
-                        Text(rightLabel)
+            if let statusText = self.metric.statusText {
+                Text(statusText)
+                    .font(.footnote)
+                    .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
+                    .lineLimit(1)
+            } else {
+                UsageProgressBar(
+                    percent: self.metric.percent,
+                    tint: self.progressColor,
+                    accessibilityLabel: self.metric.percentStyle.accessibilityLabel,
+                    pacePercent: self.metric.pacePercent,
+                    paceOnTop: self.metric.paceOnTop,
+                    warningMarkerPercents: self.metric.warningMarkerPercents)
+                VStack(alignment: .leading, spacing: 2) {
+                    HStack(alignment: .firstTextBaseline) {
+                        Text(self.metric.percentLabel)
                             .font(.footnote)
-                            .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
                             .lineLimit(1)
-                    }
-                }
-                if self.metric.detailLeftText != nil || self.metric.detailRightText != nil {
-                    HStack(alignment: .firstTextBaseline) {
-                        if let detailLeft = self.metric.detailLeftText {
-                            Text(detailLeft)
-                                .font(.footnote)
-                                .foregroundStyle(MenuHighlightStyle.primary(self.isHighlighted))
-                                .lineLimit(1)
-                        }
                         Spacer()
-                        if let detailRight = self.metric.detailRightText {
-                            Text(detailRight)
+                        if let rightLabel = self.metric.resetText {
+                            Text(rightLabel)
                                 .font(.footnote)
                                 .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
                                 .lineLimit(1)
                         }
                     }
+                    if self.metric.detailLeftText != nil || self.metric.detailRightText != nil {
+                        HStack(alignment: .firstTextBaseline) {
+                            if let detailLeft = self.metric.detailLeftText {
+                                Text(detailLeft)
+                                    .font(.footnote)
+                                    .foregroundStyle(MenuHighlightStyle.primary(self.isHighlighted))
+                                    .lineLimit(1)
+                            }
+                            Spacer()
+                            if let detailRight = self.metric.detailRightText {
+                                Text(detailRight)
+                                    .font(.footnote)
+                                    .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
+                                    .lineLimit(1)
+                            }
+                        }
+                    }
+                }
+                .frame(maxWidth: .infinity, alignment: .leading)
+                if let detail = self.metric.detailText {
+                    Text(detail)
+                        .font(.footnote)
+                        .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
+                        .lineLimit(1)
                 }
-            }
-            .frame(maxWidth: .infinity, alignment: .leading)
-            if let detail = self.metric.detailText {
-                Text(detail)
-                    .font(.footnote)
-                    .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
-                    .lineLimit(1)
             }
         }
         .frame(maxWidth: .infinity, alignment: .leading)
+        .padding(self.metric.cardStyle ? 10 : 0)
+        .background(self.metric.cardStyle ? Color.secondary.opacity(self.isHighlighted ? 0.2 : 0.08) : Color.clear)
+        .clipShape(RoundedRectangle(cornerRadius: self.metric.cardStyle ? 10 : 0))
     }
 }
 
@@ -403,56 +510,87 @@ struct UsageMenuCardHeaderSectionView: View {
     let width: CGFloat
 
     var body: some View {
-        VStack(alignment: .leading, spacing: 6) {
+        VStack(alignment: .leading, spacing: UsageMenuCardLayout.headerContentSpacing) {
             UsageMenuCardHeaderView(model: self.model)
 
             if self.showDivider {
                 Divider()
             }
         }
-        .padding(.horizontal, 16)
-        .padding(.top, 2)
-        .padding(.bottom, self.model.subtitleStyle == .error ? 2 : 0)
+        .padding(.horizontal, UsageMenuCardLayout.horizontalPadding)
+        .padding(.top, UsageMenuCardLayout.headerOnlyVerticalPadding)
+        .padding(.bottom, self.headerBottomPadding)
         .frame(width: self.width, alignment: .leading)
     }
+
+    private var headerBottomPadding: CGFloat {
+        if self.model.subtitleStyle == .error {
+            return UsageMenuCardLayout.sectionBottomPadding
+        }
+        return self.showDivider
+            ? UsageMenuCardLayout.sectionBottomPadding
+            : UsageMenuCardLayout.headerOnlyVerticalPadding
+    }
 }
 
-struct UsageMenuCardUsageSectionView: View {
+private struct UsageMenuCardUsageContentView: View {
     let model: UsageMenuCardView.Model
     let showBottomDivider: Bool
-    let bottomPadding: CGFloat
-    let width: CGFloat
     @Environment(\.menuItemHighlighted) private var isHighlighted
 
     var body: some View {
         VStack(alignment: .leading, spacing: 12) {
-            if self.model.metrics.isEmpty {
-                if !self.model.usageNotes.isEmpty {
-                    UsageNotesContent(notes: self.model.usageNotes)
-                } else if let placeholder = self.model.placeholder {
-                    Text(placeholder)
-                        .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
-                        .font(.subheadline)
-                }
-            } else {
-                ForEach(self.model.metrics, id: \.id) { metric in
-                    MetricRow(
-                        metric: metric,
-                        title: UsageMenuCardView.popupMetricTitle(provider: self.model.provider, metric: metric),
-                        progressColor: self.model.progressColor)
-                }
-                if !self.model.usageNotes.isEmpty {
-                    UsageNotesContent(notes: self.model.usageNotes)
+            ForEach(self.model.metrics, id: \.id) { metric in
+                MetricRow(
+                    metric: metric,
+                    title: UsageMenuCardView.popupMetricTitle(provider: self.model.provider, metric: metric),
+                    progressColor: self.model.progressColor)
+            }
+            if let resetCredits = self.model.codexResetCreditsText {
+                if !self.model.metrics.isEmpty {
+                    Divider()
                 }
+                CodexResetCreditsContent(
+                    text: resetCredits,
+                    detailText: self.model.codexResetCreditsDetailText)
+            }
+            if let dashboard = self.model.inlineUsageDashboard {
+                InlineUsageDashboardContent(model: dashboard)
+            } else if !self.model.usageNotes.isEmpty {
+                UsageNotesContent(notes: self.model.usageNotes)
+            } else if let placeholder = self.model.placeholder, self.model.metrics.isEmpty,
+                      self.model.codexResetCreditsText == nil
+            {
+                Text(placeholder)
+                    .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
+                    .font(.subheadline)
             }
             if self.showBottomDivider {
                 Divider()
             }
         }
-        .padding(.horizontal, 16)
-        .padding(.top, 10)
-        .padding(.bottom, self.bottomPadding)
-        .frame(width: self.width, alignment: .leading)
+    }
+}
+
+struct UsageMenuCardUsageSectionView: View {
+    let model: UsageMenuCardView.Model
+    let showBottomDivider: Bool
+    let bottomPadding: CGFloat
+    let width: CGFloat
+    @Environment(\.menuCardRefreshMonitor) private var refreshMonitor
+
+    var body: some View {
+        let liveModel = self.liveModel
+        UsageMenuCardUsageContentView(model: liveModel, showBottomDivider: self.showBottomDivider)
+            .padding(.horizontal, UsageMenuCardLayout.horizontalPadding)
+            .padding(.top, UsageMenuCardLayout.usageSectionTopPadding)
+            .padding(.bottom, self.bottomPadding)
+            .frame(width: self.width, alignment: .leading)
+    }
+
+    private var liveModel: UsageMenuCardView.Model {
+        guard self.model.usesLiveSubtitle else { return self.model }
+        return self.refreshMonitor?.model(for: self.model.provider, fallback: self.model) ?? self.model
     }
 }
 
@@ -462,26 +600,33 @@ struct UsageMenuCardCreditsSectionView: View {
     let topPadding: CGFloat
     let bottomPadding: CGFloat
     let width: CGFloat
+    @Environment(\.menuCardRefreshMonitor) private var refreshMonitor
 
     var body: some View {
-        if let credits = self.model.creditsText {
+        let liveModel = self.liveModel
+        if let credits = liveModel.creditsText {
             VStack(alignment: .leading, spacing: 6) {
                 CreditsBarContent(
                     creditsText: credits,
-                    creditsRemaining: self.model.creditsRemaining,
-                    hintText: self.model.creditsHintText,
-                    hintCopyText: self.model.creditsHintCopyText,
-                    progressColor: self.model.progressColor)
+                    creditsRemaining: liveModel.creditsRemaining,
+                    hintText: liveModel.creditsHintText,
+                    hintCopyText: liveModel.creditsHintCopyText,
+                    progressColor: liveModel.progressColor)
                 if self.showBottomDivider {
                     Divider()
                 }
             }
-            .padding(.horizontal, 16)
+            .padding(.horizontal, UsageMenuCardLayout.horizontalPadding)
             .padding(.top, self.topPadding)
             .padding(.bottom, self.bottomPadding)
             .frame(width: self.width, alignment: .leading)
         }
     }
+
+    private var liveModel: UsageMenuCardView.Model {
+        guard self.model.usesLiveSubtitle else { return self.model }
+        return self.refreshMonitor?.model(for: self.model.provider, fallback: self.model) ?? self.model
+    }
 }
 
 private struct CreditsBarContent: View {
@@ -502,22 +647,23 @@ private struct CreditsBarContent: View {
 
     private var scaleText: String {
         let scale = UsageFormatter.tokenCountString(Int(Self.fullScaleTokens))
-        return "\(scale) tokens"
+        return "\(scale) \(L("tokens"))"
     }
 
     var body: some View {
         VStack(alignment: .leading, spacing: 6) {
-            Text("Credits")
+            Text(L("Credits"))
                 .font(.body)
                 .fontWeight(.medium)
             if let percentLeft {
                 UsageProgressBar(
                     percent: percentLeft,
                     tint: self.progressColor,
-                    accessibilityLabel: "Credits remaining")
+                    accessibilityLabel: L("Credits remaining"))
                 HStack(alignment: .firstTextBaseline) {
                     Text(self.creditsText)
                         .font(.caption)
+                        .lineLimit(1)
                     Spacer()
                     Text(self.scaleText)
                         .font(.caption)
@@ -547,21 +693,25 @@ struct UsageMenuCardCostSectionView: View {
     let bottomPadding: CGFloat
     let width: CGFloat
     @Environment(\.menuItemHighlighted) private var isHighlighted
+    @Environment(\.menuCardRefreshMonitor) private var refreshMonitor
 
     var body: some View {
-        let hasTokenCost = self.model.tokenUsage != nil
+        let liveModel = self.liveModel
+        let hasTokenCost = liveModel.tokenUsage != nil
         return Group {
             if hasTokenCost {
                 VStack(alignment: .leading, spacing: 10) {
-                    if let tokenUsage = self.model.tokenUsage {
+                    if let tokenUsage = liveModel.tokenUsage {
                         VStack(alignment: .leading, spacing: 6) {
-                            Text("Cost")
+                            Text(L("cost_header_estimated"))
                                 .font(.body)
                                 .fontWeight(.medium)
                             Text(tokenUsage.sessionLine)
                                 .font(.caption)
+                                .lineLimit(1)
                             Text(tokenUsage.monthLine)
                                 .font(.caption)
+                                .lineLimit(1)
                             if let hint = tokenUsage.hintLine, !hint.isEmpty {
                                 Text(hint)
                                     .font(.footnote)
@@ -582,13 +732,18 @@ struct UsageMenuCardCostSectionView: View {
                         }
                     }
                 }
-                .padding(.horizontal, 16)
+                .padding(.horizontal, UsageMenuCardLayout.horizontalPadding)
                 .padding(.top, self.topPadding)
                 .padding(.bottom, self.bottomPadding)
                 .frame(width: self.width, alignment: .leading)
             }
         }
     }
+
+    private var liveModel: UsageMenuCardView.Model {
+        guard self.model.usesLiveSubtitle else { return self.model }
+        return self.refreshMonitor?.model(for: self.model.provider, fallback: self.model) ?? self.model
+    }
 }
 
 struct UsageMenuCardExtraUsageSectionView: View {
@@ -596,20 +751,27 @@ struct UsageMenuCardExtraUsageSectionView: View {
     let topPadding: CGFloat
     let bottomPadding: CGFloat
     let width: CGFloat
+    @Environment(\.menuCardRefreshMonitor) private var refreshMonitor
 
     var body: some View {
+        let liveModel = self.liveModel
         Group {
-            if let providerCost = self.model.providerCost {
+            if let providerCost = liveModel.providerCost {
                 ProviderCostContent(
                     section: providerCost,
-                    progressColor: self.model.progressColor)
-                    .padding(.horizontal, 16)
+                    progressColor: liveModel.progressColor)
+                    .padding(.horizontal, UsageMenuCardLayout.horizontalPadding)
                     .padding(.top, self.topPadding)
                     .padding(.bottom, self.bottomPadding)
                     .frame(width: self.width, alignment: .leading)
             }
         }
     }
+
+    private var liveModel: UsageMenuCardView.Model {
+        guard self.model.usesLiveSubtitle else { return self.model }
+        return self.refreshMonitor?.model(for: self.model.provider, fallback: self.model) ?? self.model
+    }
 }
 
 // MARK: - Model factory
@@ -619,6 +781,7 @@ extension UsageMenuCardView.Model {
         let provider: UsageProvider
         let metadata: ProviderMetadata
         let snapshot: UsageSnapshot?
+        let codexProjection: CodexConsumerProjection?
         let credits: CreditsSnapshot?
         let creditsError: String?
         let dashboard: OpenAIDashboardSnapshot?
@@ -632,16 +795,21 @@ extension UsageMenuCardView.Model {
         let resetTimeDisplayStyle: ResetTimeDisplayStyle
         let tokenCostUsageEnabled: Bool
         let showOptionalCreditsAndExtraUsage: Bool
+        let copilotBudgetExtrasEnabled: Bool
         let sourceLabel: String?
         let kiloAutoMode: Bool
         let hidePersonalInfo: Bool
         let weeklyPace: UsagePace?
+        let quotaWarningThresholds: [QuotaWarningWindow: [Int]]
+        let workDaysPerWeek: Int?
+        let usesLiveSubtitle: Bool
         let now: Date
 
         init(
             provider: UsageProvider,
             metadata: ProviderMetadata,
             snapshot: UsageSnapshot?,
+            codexProjection: CodexConsumerProjection? = nil,
             credits: CreditsSnapshot?,
             creditsError: String?,
             dashboard: OpenAIDashboardSnapshot?,
@@ -655,15 +823,20 @@ extension UsageMenuCardView.Model {
             resetTimeDisplayStyle: ResetTimeDisplayStyle,
             tokenCostUsageEnabled: Bool,
             showOptionalCreditsAndExtraUsage: Bool,
+            copilotBudgetExtrasEnabled: Bool = false,
             sourceLabel: String? = nil,
             kiloAutoMode: Bool = false,
             hidePersonalInfo: Bool,
             weeklyPace: UsagePace? = nil,
+            quotaWarningThresholds: [QuotaWarningWindow: [Int]] = [:],
+            workDaysPerWeek: Int? = nil,
+            usesLiveSubtitle: Bool = false,
             now: Date)
         {
             self.provider = provider
             self.metadata = metadata
             self.snapshot = snapshot
+            self.codexProjection = codexProjection
             self.credits = credits
             self.creditsError = creditsError
             self.dashboard = dashboard
@@ -677,10 +850,14 @@ extension UsageMenuCardView.Model {
             self.resetTimeDisplayStyle = resetTimeDisplayStyle
             self.tokenCostUsageEnabled = tokenCostUsageEnabled
             self.showOptionalCreditsAndExtraUsage = showOptionalCreditsAndExtraUsage
+            self.copilotBudgetExtrasEnabled = copilotBudgetExtrasEnabled
             self.sourceLabel = sourceLabel
             self.kiloAutoMode = kiloAutoMode
             self.hidePersonalInfo = hidePersonalInfo
             self.weeklyPace = weeklyPace
+            self.quotaWarningThresholds = quotaWarningThresholds
+            self.workDaysPerWeek = workDaysPerWeek
+            self.usesLiveSubtitle = usesLiveSubtitle
             self.now = now
         }
     }
@@ -691,31 +868,52 @@ extension UsageMenuCardView.Model {
             snapshot: input.snapshot,
             account: input.account,
             metadata: input.metadata)
-        let metrics = Self.metrics(input: input)
+        let metrics = Self.redactedMetrics(
+            Self.metrics(input: input),
+            provider: input.provider,
+            hidePersonalInfo: input.hidePersonalInfo)
+        let openAIAPIUsage = input.snapshot?.openAIAPIUsage
+        let inlineUsageDashboard = Self.inlineUsageDashboard(input: input)
         let usageNotes = Self.usageNotes(input: input)
-        let creditsText: String? = if input.provider == .openrouter {
+        let rawCreditsText: String? = if input.provider == .openrouter {
             nil
-        } else if input.provider == .codex, !input.showOptionalCreditsAndExtraUsage {
+        } else if input.codexProjection != nil, !input.showOptionalCreditsAndExtraUsage {
             nil
         } else {
-            Self.creditsLine(metadata: input.metadata, credits: input.credits, error: input.creditsError)
+            Self.creditsLine(
+                metadata: input.metadata,
+                snapshot: input.snapshot,
+                credits: input.credits,
+                error: input.creditsError)
         }
-        let providerCost: ProviderCostSection? = if input.provider == .claude, !input.showOptionalCreditsAndExtraUsage {
+        let creditsText = PersonalInfoRedactor.redactEmails(in: rawCreditsText, isEnabled: input.hidePersonalInfo)
+        let isClaudeAdminAPI = input.provider == .claude &&
+            input.snapshot?.identity?.loginMethod == "Admin API"
+        let isRequiredOpenCodeZenBalance = Self.isRequiredOpenCodeZenBalance(input.snapshot)
+        let hidesOptionalProviderCost = ((input.provider == .claude && !isClaudeAdminAPI) ||
+            input.provider == .factory ||
+            (input.provider == .opencodego && !isRequiredOpenCodeZenBalance)) &&
+            !input.showOptionalCreditsAndExtraUsage
+        let providerCost: ProviderCostSection? = if hidesOptionalProviderCost ||
+            (input.provider == .openai && openAIAPIUsage != nil)
+        {
             nil
         } else {
             Self.providerCostSection(provider: input.provider, cost: input.snapshot?.providerCost)
         }
+        let tokenUsageSnapshot = Self.tokenUsageSnapshot(input: input)
         let tokenUsage = Self.tokenUsageSection(
             provider: input.provider,
             enabled: input.tokenCostUsageEnabled,
-            snapshot: input.tokenSnapshot,
+            snapshot: tokenUsageSnapshot,
             error: input.tokenError)
         let subtitle = Self.subtitle(
             snapshot: input.snapshot,
             isRefreshing: input.isRefreshing,
-            lastError: input.lastError)
+            lastError: Self.lastError(input: input),
+            now: input.now)
         let redacted = Self.redactedText(input: input, subtitle: subtitle)
-        let placeholder = input.snapshot == nil && !input.isRefreshing && input.lastError == nil ? "No usage yet" : nil
+        let placeholder = Self.placeholder(input: input)
 
         return UsageMenuCardView.Model(
             provider: input.provider,
@@ -723,13 +921,18 @@ extension UsageMenuCardView.Model {
             email: redacted.email,
             subtitleText: redacted.subtitleText,
             subtitleStyle: subtitle.style,
+            usesLiveSubtitle: input.usesLiveSubtitle,
             planText: planText,
             metrics: metrics,
             usageNotes: usageNotes,
+            openAIAPIUsage: openAIAPIUsage,
+            inlineUsageDashboard: inlineUsageDashboard,
             creditsText: creditsText,
             creditsRemaining: input.credits?.remaining,
             creditsHintText: redacted.creditsHintText,
             creditsHintCopyText: redacted.creditsHintCopyText,
+            codexResetCreditsText: Self.codexResetCreditsText(input: input),
+            codexResetCreditsDetailText: Self.codexResetCreditsDetailText(input: input),
             providerCost: providerCost,
             tokenUsage: tokenUsage,
             placeholder: placeholder,
@@ -737,6 +940,12 @@ extension UsageMenuCardView.Model {
     }
 
     private static func usageNotes(input: Input) -> [String] {
+        let subscriptionNotes = self.subscriptionMetadataNotes(snapshot: input.snapshot, provider: input.provider)
+
+        if input.provider == .kiro {
+            return kiroUsageNotes(input: input) + subscriptionNotes
+        }
+
         if input.provider == .kilo {
             var notes = Self.kiloLoginDetails(snapshot: input.snapshot)
             let resolvedSource = input.sourceLabel?
@@ -746,22 +955,51 @@ extension UsageMenuCardView.Model {
                resolvedSource == "cli",
                !notes.contains(where: { $0.caseInsensitiveCompare("Using CLI fallback") == .orderedSame })
             {
-                notes.append("Using CLI fallback")
+                notes.append(L("Using CLI fallback"))
             }
-            return notes
+            return notes + subscriptionNotes
+        }
+
+        if input.provider == .mimo, input.snapshot != nil {
+            return Self.mimoUsageNotes(input: input, subscriptionNotes: subscriptionNotes)
+        }
+
+        if let notes = apiProviderUsageNotes(input: input) {
+            return notes + subscriptionNotes
         }
 
         guard input.provider == .openrouter,
               let openRouter = input.snapshot?.openRouterUsage
         else {
-            return []
+            return subscriptionNotes
         }
 
-        return switch openRouter.keyQuotaStatus {
-        case .available: []
-        case .noLimitConfigured: ["No limit set for the API key"]
-        case .unavailable: ["API key limit unavailable right now"]
+        var notes = Self.openRouterSpendNotes(openRouter)
+        switch openRouter.keyQuotaStatus {
+        case .available:
+            break
+        case .noLimitConfigured:
+            notes.append(L("No limit set for the API key"))
+        case .unavailable:
+            notes.append(L("API key limit unavailable right now"))
+        }
+        return notes + subscriptionNotes
+    }
+
+    private static func openRouterSpendNotes(_ usage: OpenRouterUsageSnapshot) -> [String] {
+        var parts: [String] = []
+        if let daily = usage.keyUsageDaily {
+            parts.append("\(L("Today")): \(Self.openRouterCurrencyString(daily))")
+        }
+        if let weekly = usage.keyUsageWeekly {
+            parts.append("\(L("This week")): \(Self.openRouterCurrencyString(weekly))")
         }
+        guard !parts.isEmpty else { return [] }
+        return [parts.joined(separator: " · ")]
+    }
+
+    private static func openRouterCurrencyString(_ value: Double) -> String {
+        String(format: "$%.2f", value)
     }
 
     private static func email(
@@ -785,28 +1023,55 @@ extension UsageMenuCardView.Model {
         account: AccountInfo,
         metadata: ProviderMetadata) -> String?
     {
+        if provider == .kiro,
+           let plan = kiroPlan(snapshot: snapshot)
+        {
+            return plan
+        }
         if provider == .kilo {
             guard let pass = self.kiloLoginPass(snapshot: snapshot) else {
                 return nil
             }
-            return self.planDisplay(pass)
+            return self.planDisplay(pass, for: provider)
         }
         if let plan = snapshot?.loginMethod(for: provider), !plan.isEmpty {
-            return self.planDisplay(plan)
+            return self.planDisplay(plan, for: provider)
         }
         if metadata.usesAccountFallback,
            let plan = account.plan, !plan.isEmpty
         {
-            return Self.planDisplay(plan)
+            return Self.planDisplay(plan, for: provider)
         }
         return nil
     }
 
-    private static func planDisplay(_ text: String) -> String {
-        let cleaned = UsageFormatter.cleanPlanName(text)
+    private static func planDisplay(_ text: String, for provider: UsageProvider) -> String {
+        if provider == .minimax {
+            return self.miniMaxPlanDisplay(text)
+        }
+        let cleaned = if provider == .codex {
+            CodexPlanFormatting.displayName(text) ?? UsageFormatter.cleanPlanName(text)
+        } else {
+            UsageFormatter.cleanPlanName(text)
+        }
         return cleaned.isEmpty ? text : cleaned
     }
 
+    private static func miniMaxPlanDisplay(_ text: String) -> String {
+        let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
+        let normalized = trimmed.lowercased()
+        if normalized.contains("tokenplanplus") || normalized.contains("token plan plus") {
+            return "Plus"
+        }
+        if normalized.contains("tokenplanmax") || normalized.contains("token plan max") {
+            return "Max"
+        }
+        if normalized.contains("tokenplanultra") || normalized.contains("token plan ultra") {
+            return "Ultra"
+        }
+        return trimmed
+    }
+
     private static func kiloLoginPass(snapshot: UsageSnapshot?) -> String? {
         self.kiloLoginParts(snapshot: snapshot).pass
     }
@@ -841,21 +1106,22 @@ extension UsageMenuCardView.Model {
     private static func subtitle(
         snapshot: UsageSnapshot?,
         isRefreshing: Bool,
-        lastError: String?) -> (text: String, style: SubtitleStyle)
+        lastError: String?,
+        now: Date) -> (text: String, style: SubtitleStyle)
     {
         if let lastError, !lastError.isEmpty {
             return (lastError.trimmingCharacters(in: .whitespacesAndNewlines), .error)
         }
 
-        if isRefreshing, snapshot == nil {
-            return ("Refreshing...", .loading)
+        if isRefreshing {
+            return ("\(L("Refreshing"))…", .loading)
         }
 
         if let updated = snapshot?.updatedAt {
-            return (UsageFormatter.updatedString(from: updated), .info)
+            return (UsageFormatter.updatedString(from: updated, now: now), .info)
         }
 
-        return ("Not fetched yet", .info)
+        return (L("Not fetched yet"), .info)
     }
 
     private struct RedactedText {
@@ -879,7 +1145,7 @@ extension UsageMenuCardView.Model {
         let subtitleText = PersonalInfoRedactor.redactEmails(in: subtitle.text, isEnabled: input.hidePersonalInfo)
             ?? subtitle.text
         let creditsHintText = PersonalInfoRedactor.redactEmails(
-            in: Self.dashboardHint(provider: input.provider, error: input.dashboardError),
+            in: Self.dashboardHint(error: input.dashboardError),
             isEnabled: input.hidePersonalInfo)
         let creditsHintCopyText = Self.creditsHintCopyText(
             dashboardError: input.dashboardError,
@@ -898,78 +1164,96 @@ extension UsageMenuCardView.Model {
 
     private static func metrics(input: Input) -> [Metric] {
         guard let snapshot = input.snapshot else { return [] }
+        if input.provider == .antigravity {
+            return Self.antigravityMetrics(input: input, snapshot: snapshot)
+        }
+        if input.provider == .minimax {
+            if let minimaxUsage = snapshot.minimaxUsage {
+                let services = minimaxUsage.orderedQuotaServices
+                if !services.isEmpty {
+                    return Self.minimaxMetrics(services: services, input: input)
+                }
+            }
+        }
         var metrics: [Metric] = []
         let percentStyle: PercentStyle = input.usageBarsShowUsed ? .used : .left
         let zaiUsage = input.provider == .zai ? snapshot.zaiUsage : nil
         let zaiTokenDetail = Self.zaiLimitDetailText(limit: zaiUsage?.tokenLimit)
         let zaiTimeDetail = Self.zaiLimitDetailText(limit: zaiUsage?.timeLimit)
+        let zaiSessionDetail = Self.zaiLimitDetailText(limit: zaiUsage?.sessionTokenLimit)
         let openRouterQuotaDetail = Self.openRouterQuotaDetail(provider: input.provider, snapshot: snapshot)
-        if let primary = snapshot.primary {
-            var primaryDetailText: String? = input.provider == .zai ? zaiTokenDetail : nil
-            var primaryResetText = Self.resetText(for: primary, style: input.resetTimeDisplayStyle, now: input.now)
-            if input.provider == .openrouter,
-               let openRouterQuotaDetail
-            {
-                primaryResetText = openRouterQuotaDetail
-            }
-            if input.provider == .warp || input.provider == .kilo,
-               let detail = primary.resetDescription,
-               !detail.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
-            {
-                primaryDetailText = detail
-            }
-            if input.provider == .warp || input.provider == .kilo, primary.resetsAt == nil {
-                primaryResetText = nil
-            }
+        let labels = Self.rateWindowLabels(input: input, snapshot: snapshot)
+        if input.provider == .codex, let codexProjection = input.codexProjection {
+            metrics.append(contentsOf: Self.codexRateMetrics(
+                input: input,
+                projection: codexProjection,
+                percentStyle: percentStyle))
+        } else if let primary = snapshot.primary {
+            metrics.append(Self.primaryMetric(
+                input: input,
+                primary: primary,
+                percentStyle: percentStyle,
+                title: labels.primary,
+                zaiTokenDetail: zaiTokenDetail,
+                openRouterQuotaDetail: openRouterQuotaDetail))
+        }
+        if input.provider != .codex, let weekly = snapshot.secondary {
+            metrics.append(Self.secondaryMetric(
+                input: input,
+                weekly: weekly,
+                percentStyle: percentStyle,
+                title: labels.secondary,
+                zaiTimeDetail: zaiTimeDetail))
+        }
+        if input.provider == .mimo, let mimoUsage = snapshot.mimoUsage {
             metrics.append(Metric(
-                id: "primary",
-                title: input.metadata.sessionLabel,
-                percent: Self.clamped(
-                    input.usageBarsShowUsed ? primary.usedPercent : primary.remainingPercent),
+                id: "mimo-balance",
+                title: L("Balance"),
+                percent: 0,
                 percentStyle: percentStyle,
-                resetText: primaryResetText,
-                detailText: primaryDetailText,
+                statusText: mimoUsage.balanceDetail,
+                resetText: nil,
+                detailText: nil,
                 detailLeftText: nil,
                 detailRightText: nil,
                 pacePercent: nil,
                 paceOnTop: true))
         }
-        if let weekly = snapshot.secondary {
-            let paceDetail = Self.weeklyPaceDetail(
-                window: weekly,
-                now: input.now,
-                pace: input.weeklyPace,
-                showUsed: input.usageBarsShowUsed)
-            var weeklyResetText = Self.resetText(for: weekly, style: input.resetTimeDisplayStyle, now: input.now)
-            var weeklyDetailText: String? = input.provider == .zai ? zaiTimeDetail : nil
-            if input.provider == .warp,
-               let detail = weekly.resetDescription,
+        if labels.showsTertiary, let opus = snapshot.tertiary {
+            var tertiaryDetailText: String?
+            if input.provider == .alibaba || input.provider == .alibabatokenplan,
+               let detail = opus.resetDescription,
                !detail.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
             {
-                weeklyResetText = nil
-                weeklyDetailText = detail
+                tertiaryDetailText = detail
             }
-            if input.provider == .kilo,
-               let detail = weekly.resetDescription,
-               !detail.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
-            {
-                weeklyDetailText = detail
-                if weekly.resetsAt == nil {
-                    weeklyResetText = nil
-                }
+            if input.provider == .zai, let detail = zaiSessionDetail {
+                tertiaryDetailText = detail
             }
+            // Perplexity purchased credits don't reset; show balance without "Resets" prefix.
+            let opusResetText: String? = input.provider == .perplexity
+                ? opus.resetDescription?.trimmingCharacters(in: .whitespacesAndNewlines)
+                : Self.resetText(for: opus, style: input.resetTimeDisplayStyle, now: input.now)
+            let tertiaryPaceDetail = Self.cursorBillingCyclePaceDetail(window: opus, input: input)
             metrics.append(Metric(
-                id: "secondary",
-                title: input.metadata.weeklyLabel,
-                percent: Self.clamped(input.usageBarsShowUsed ? weekly.usedPercent : weekly.remainingPercent),
+                id: "tertiary",
+                title: labels.tertiary,
+                percent: Self.clamped(input.usageBarsShowUsed ? opus.usedPercent : opus.remainingPercent),
                 percentStyle: percentStyle,
-                resetText: weeklyResetText,
-                detailText: weeklyDetailText,
-                detailLeftText: paceDetail?.leftLabel,
-                detailRightText: paceDetail?.rightLabel,
-                pacePercent: paceDetail?.pacePercent,
-                paceOnTop: paceDetail?.paceOnTop ?? true))
+                resetText: opusResetText,
+                detailText: tertiaryDetailText,
+                detailLeftText: tertiaryPaceDetail?.leftLabel,
+                detailRightText: tertiaryPaceDetail?.rightLabel,
+                pacePercent: tertiaryPaceDetail?.pacePercent,
+                paceOnTop: tertiaryPaceDetail?.paceOnTop ?? true,
+                warningMarkerPercents: Self.warningMarkerPercents(
+                    thresholds: input.quotaWarningThresholds[.weekly],
+                    showUsed: input.usageBarsShowUsed)))
         }
+        metrics.append(contentsOf: Self.extraRateWindowMetrics(
+            snapshot: snapshot,
+            input: input,
+            percentStyle: percentStyle))
         if input.provider == .kilo,
            metrics.contains(where: { $0.id == "primary" }),
            metrics.contains(where: { $0.id == "secondary" })
@@ -982,28 +1266,21 @@ extension UsageMenuCardView.Model {
                 return (kiloOrder[lhs.id] ?? Int.max) < (kiloOrder[rhs.id] ?? Int.max)
             }
         }
-        if input.metadata.supportsOpus, let opus = snapshot.tertiary {
-            metrics.append(Metric(
-                id: "tertiary",
-                title: input.metadata.opusLabel ?? "Sonnet",
-                percent: Self.clamped(input.usageBarsShowUsed ? opus.usedPercent : opus.remainingPercent),
-                percentStyle: percentStyle,
-                resetText: Self.resetText(for: opus, style: input.resetTimeDisplayStyle, now: input.now),
-                detailText: nil,
-                detailLeftText: nil,
-                detailRightText: nil,
-                pacePercent: nil,
-                paceOnTop: true))
-        }
 
-        if input.provider == .codex, let remaining = input.dashboard?.codeReviewRemainingPercent {
+        if let codexProjection = input.codexProjection,
+           codexProjection.supplementalMetrics.contains(.codeReview),
+           let remaining = codexProjection.remainingPercent(for: .codeReview)
+        {
             let percent = input.usageBarsShowUsed ? (100 - remaining) : remaining
+            let resetText = codexProjection.limitWindow(for: .codeReview).flatMap {
+                Self.resetText(for: $0, style: input.resetTimeDisplayStyle, now: input.now)
+            }
             metrics.append(Metric(
                 id: "code-review",
-                title: "Code review",
+                title: L("Code review"),
                 percent: Self.clamped(percent),
                 percentStyle: percentStyle,
-                resetText: nil,
+                resetText: resetText,
                 detailText: nil,
                 detailLeftText: nil,
                 detailRightText: nil,
@@ -1013,209 +1290,300 @@ extension UsageMenuCardView.Model {
         return metrics
     }
 
-    private static func zaiLimitDetailText(limit: ZaiLimitEntry?) -> String? {
-        guard let limit else { return nil }
-
-        if let currentValue = limit.currentValue,
-           let usage = limit.usage,
-           let remaining = limit.remaining
+    private static func primaryMetric(
+        input: Input,
+        primary: RateWindow,
+        percentStyle: PercentStyle,
+        title: String? = nil,
+        zaiTokenDetail: String?,
+        openRouterQuotaDetail: String?) -> Metric
+    {
+        var primaryDetailText: String? = input.provider == .zai ? zaiTokenDetail : nil
+        var primaryResetText = Self.resetText(for: primary, style: input.resetTimeDisplayStyle, now: input.now)
+        var primaryDetailLeft: String?
+        var primaryDetailRight: String?
+        if input.provider == .crof,
+           let detail = primary.resetDescription?.trimmingCharacters(in: .whitespacesAndNewlines),
+           !detail.isEmpty
         {
-            let currentStr = UsageFormatter.tokenCountString(currentValue)
-            let usageStr = UsageFormatter.tokenCountString(usage)
-            let remainingStr = UsageFormatter.tokenCountString(remaining)
-            return "\(currentStr) / \(usageStr) (\(remainingStr) remaining)"
+            primaryDetailRight = detail
         }
-
-        return nil
-    }
-
-    private static func openRouterQuotaDetail(provider: UsageProvider, snapshot: UsageSnapshot) -> String? {
-        guard provider == .openrouter,
-              let usage = snapshot.openRouterUsage,
-              usage.hasValidKeyQuota,
-              let keyRemaining = usage.keyRemaining,
-              let keyLimit = usage.keyLimit
-        else {
-            return nil
+        if input.provider == .openrouter,
+           let openRouterQuotaDetail
+        {
+            primaryResetText = openRouterQuotaDetail
         }
-
-        let remaining = UsageFormatter.usdString(keyRemaining)
-        let limit = UsageFormatter.usdString(keyLimit)
-        return "\(remaining)/\(limit) left"
-    }
-
-    private struct PaceDetail {
-        let leftLabel: String
-        let rightLabel: String?
-        let pacePercent: Double?
-        let paceOnTop: Bool
-    }
-
-    private static func weeklyPaceDetail(
-        window: RateWindow,
-        now: Date,
-        pace: UsagePace?,
-        showUsed: Bool) -> PaceDetail?
-    {
-        guard let pace else { return nil }
-        let detail = UsagePaceText.weeklyDetail(pace: pace, now: now)
-        let expectedUsed = detail.expectedUsedPercent
-        let actualUsed = window.usedPercent
-        let expectedPercent = showUsed ? expectedUsed : (100 - expectedUsed)
-        let actualPercent = showUsed ? actualUsed : (100 - actualUsed)
-        if expectedPercent.isFinite == false || actualPercent.isFinite == false { return nil }
-        let paceOnTop = actualUsed <= expectedUsed
-        let pacePercent: Double? = if detail.stage == .onTrack { nil } else { expectedPercent }
-        return PaceDetail(
-            leftLabel: detail.leftLabel,
-            rightLabel: detail.rightLabel,
-            pacePercent: pacePercent,
-            paceOnTop: paceOnTop)
-    }
-
-    private static func creditsLine(
-        metadata: ProviderMetadata,
-        credits: CreditsSnapshot?,
-        error: String?) -> String?
-    {
-        guard metadata.supportsCredits else { return nil }
-        if let credits {
-            return UsageFormatter.creditsString(from: credits.remaining)
+        if input.provider == .copilot,
+           let detail = primary.resetDescription?.trimmingCharacters(in: .whitespacesAndNewlines),
+           !detail.isEmpty
+        {
+            primaryDetailLeft = detail
         }
-        if let error, !error.isEmpty {
-            return error.trimmingCharacters(in: .whitespacesAndNewlines)
+        if input.provider == .warp || input.provider == .kilo || input.provider == .mimo || input.provider == .deepseek
+            || input.provider == .litellm,
+            let detail = primary.resetDescription,
+            !detail.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+        {
+            primaryDetailText = detail
         }
-        return metadata.creditsHint
-    }
-
-    private static func dashboardHint(provider: UsageProvider, error: String?) -> String? {
-        guard provider == .codex else { return nil }
-        guard let error, !error.isEmpty else { return nil }
-        return error
-    }
-
-    private static func tokenUsageSection(
-        provider: UsageProvider,
-        enabled: Bool,
-        snapshot: CostUsageTokenSnapshot?,
-        error: String?) -> TokenUsageSection?
-    {
-        guard provider == .codex || provider == .claude || provider == .vertexai else { return nil }
-        guard enabled else { return nil }
-        guard let snapshot else { return nil }
-
-        let sessionCost = snapshot.sessionCostUSD.map { UsageFormatter.usdString($0) } ?? "—"
-        let sessionTokens = snapshot.sessionTokens.map { UsageFormatter.tokenCountString($0) }
-        let sessionLine: String = {
-            if let sessionTokens {
-                return "Today: \(sessionCost) · \(sessionTokens) tokens"
+        if let balance = Self.poeBalanceDetailText(input: input) {
+            primaryDetailText = balance
+        }
+        if input.provider == .kiro,
+           let kiroUsage = input.snapshot?.kiroUsage,
+           kiroUsage.creditsTotal > 0
+        {
+            let remaining = UsageFormatter.kiroCreditNumber(kiroUsage.creditsRemaining)
+            let total = UsageFormatter.kiroCreditNumber(kiroUsage.creditsTotal)
+            primaryDetailLeft = String(format: L("%@ of %@ credits left"), remaining, total)
+        }
+        if input.provider == .alibaba || input.provider == .alibabatokenplan || input.provider == .mistral || input
+            .provider == .manus,
+            let detail = primary.resetDescription,
+            !detail.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+        {
+            primaryDetailText = detail
+            if input.provider == .manus { primaryResetText = nil }
+        }
+        if [.warp, .kilo, .mimo, .deepseek, .litellm].contains(input.provider), primary.resetsAt == nil {
+            primaryResetText = nil
+        }
+        // Abacus: show credits as detail, compute pace on the primary monthly window
+        var primaryPacePercent: Double?
+        var primaryPaceOnTop = true
+        if let paceDetail = Self.sessionPaceDetail(
+            provider: input.provider,
+            window: primary,
+            now: input.now,
+            showUsed: input.usageBarsShowUsed)
+        {
+            primaryDetailLeft = paceDetail.leftLabel
+            primaryDetailRight = paceDetail.rightLabel
+            primaryPacePercent = paceDetail.pacePercent
+            primaryPaceOnTop = paceDetail.paceOnTop
+        }
+        if input.provider == .abacus {
+            if let detail = primary.resetDescription,
+               !detail.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+            {
+                primaryDetailText = detail
             }
-            return "Today: \(sessionCost)"
-        }()
-
-        let monthCost = snapshot.last30DaysCostUSD.map { UsageFormatter.usdString($0) } ?? "—"
-        let fallbackTokens = snapshot.daily.compactMap(\.totalTokens).reduce(0, +)
-        let monthTokensValue = snapshot.last30DaysTokens ?? (fallbackTokens > 0 ? fallbackTokens : nil)
-        let monthTokens = monthTokensValue.map { UsageFormatter.tokenCountString($0) }
-        let monthLine: String = {
-            if let monthTokens {
-                return "Last 30 days: \(monthCost) · \(monthTokens) tokens"
+            if primary.resetsAt == nil {
+                primaryResetText = nil
             }
-            return "Last 30 days: \(monthCost)"
-        }()
-        let err = (error?.isEmpty ?? true) ? nil : error
-        return TokenUsageSection(
-            sessionLine: sessionLine,
-            monthLine: monthLine,
-            hintLine: nil,
-            errorLine: err,
-            errorCopyText: (error?.isEmpty ?? true) ? nil : error)
+            if let pace = input.weeklyPace {
+                let paceDetail = Self.weeklyPaceDetail(
+                    window: primary,
+                    now: input.now,
+                    pace: pace,
+                    showUsed: input.usageBarsShowUsed)
+                if let paceDetail {
+                    primaryDetailLeft = paceDetail.leftLabel
+                    primaryDetailRight = paceDetail.rightLabel
+                    primaryPacePercent = paceDetail.pacePercent
+                    primaryPaceOnTop = paceDetail.paceOnTop
+                }
+            }
+        }
+        if let paceDetail = Self.cursorBillingCyclePaceDetail(window: primary, input: input) {
+            primaryDetailLeft = paceDetail.leftLabel
+            primaryDetailRight = paceDetail.rightLabel
+            primaryPacePercent = paceDetail.pacePercent
+            primaryPaceOnTop = paceDetail.paceOnTop
+        }
+        // Legacy request-based Cursor plans: surface the raw used/limit quota on its own line,
+        // since the percentage bar and pace detail alone never spell out the request cap.
+        if input.provider == .cursor, let requests = input.snapshot?.cursorRequests {
+            primaryDetailText = String(
+                format: L("Request quota: %@ / %@"),
+                "\(requests.used)",
+                "\(requests.limit)")
+        }
+        if input.provider == .synthetic,
+           let regen = Self.syntheticRollingRegenDetail(
+               window: primary,
+               now: input.now,
+               showUsed: input.usageBarsShowUsed)
+        {
+            primaryResetText = regen.resetText
+            primaryDetailLeft = regen.pace.leftLabel
+            primaryDetailRight = regen.pace.rightLabel
+            primaryPacePercent = regen.pace.pacePercent
+            primaryPaceOnTop = regen.pace.paceOnTop
+        }
+        let primaryStatusText = input.provider == .deepseek ? primaryDetailText : nil
+        if input.provider == .deepseek {
+            primaryDetailText = nil
+        }
+        return Metric(
+            id: "primary",
+            title: title ?? L(input.metadata.sessionLabel),
+            percent: Self.clamped(
+                input.usageBarsShowUsed ? primary.usedPercent : primary.remainingPercent),
+            percentStyle: percentStyle,
+            statusText: primaryStatusText,
+            resetText: primaryResetText,
+            detailText: primaryDetailText,
+            detailLeftText: primaryDetailLeft,
+            detailRightText: primaryDetailRight,
+            pacePercent: primaryPacePercent,
+            paceOnTop: primaryPaceOnTop,
+            warningMarkerPercents: Self.warningMarkerPercents(
+                thresholds: input.quotaWarningThresholds[.session],
+                showUsed: input.usageBarsShowUsed))
     }
 
-    private static func providerCostSection(
-        provider: UsageProvider,
-        cost: ProviderCostSnapshot?) -> ProviderCostSection?
+    private static func secondaryMetric(
+        input: Input,
+        weekly: RateWindow,
+        percentStyle: PercentStyle,
+        title: String? = nil,
+        zaiTimeDetail: String?) -> Metric
     {
-        guard let cost else { return nil }
-        guard cost.limit > 0 else { return nil }
-
-        let used: String
-        let limit: String
-        let title: String
-
-        if cost.currencyCode == "Quota" {
-            title = "Quota usage"
-            used = String(format: "%.0f", cost.used)
-            limit = String(format: "%.0f", cost.limit)
-        } else {
-            title = "Extra usage"
-            used = UsageFormatter.currencyString(cost.used, currencyCode: cost.currencyCode)
-            limit = UsageFormatter.currencyString(cost.limit, currencyCode: cost.currencyCode)
+        var paceDetail = Self.weeklyPaceDetail(
+            window: weekly,
+            now: input.now,
+            pace: input.weeklyPace,
+            showUsed: input.usageBarsShowUsed)
+        var weeklyResetText = Self.resetText(for: weekly, style: input.resetTimeDisplayStyle, now: input.now)
+        var weeklyDetailText: String? = input.provider == .zai ? zaiTimeDetail : nil
+        if input.provider == .warp,
+           let detail = weekly.resetDescription,
+           !detail.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+        {
+            weeklyResetText = nil
+            weeklyDetailText = detail
         }
-
-        let percentUsed = Self.clamped((cost.used / cost.limit) * 100)
-        let periodLabel = cost.period ?? "This month"
-
-        return ProviderCostSection(
-            title: title,
-            percentUsed: percentUsed,
-            spendLine: "\(periodLabel): \(used) / \(limit)")
-    }
-
-    private static func clamped(_ value: Double) -> Double {
-        min(100, max(0, value))
-    }
-
-    private static func progressColor(for provider: UsageProvider) -> Color {
-        let color = ProviderDescriptorRegistry.descriptor(for: provider).branding.color
-        return Color(red: color.red, green: color.green, blue: color.blue)
+        if input.provider == .kilo || input.provider == .litellm,
+           let detail = weekly.resetDescription,
+           !detail.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+        {
+            weeklyDetailText = detail
+            if weekly.resetsAt == nil {
+                weeklyResetText = nil
+            }
+        }
+        if input.provider == .kiro,
+           let kiroUsage = input.snapshot?.kiroUsage,
+           let remaining = kiroUsage.bonusCreditsRemaining,
+           let total = kiroUsage.bonusCreditsTotal
+        {
+            let remainingText = UsageFormatter.kiroCreditNumber(remaining)
+            let totalText = UsageFormatter.kiroCreditNumber(total)
+            paceDetail = PaceDetail(
+                leftLabel: String(format: L("%@ of %@ bonus credits left"), remainingText, totalText),
+                rightLabel: nil,
+                pacePercent: nil,
+                paceOnTop: true)
+        }
+        if input.provider == .alibaba || input.provider == .alibabatokenplan,
+           let detail = weekly.resetDescription,
+           !detail.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+        {
+            weeklyDetailText = detail
+        }
+        if input.provider == .manus,
+           let detail = weekly.resetDescription,
+           !detail.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+        {
+            weeklyDetailText = detail
+        }
+        if input.provider == .crof,
+           let detail = weekly.resetDescription?.trimmingCharacters(in: .whitespacesAndNewlines),
+           !detail.isEmpty
+        {
+            weeklyResetText = detail
+        }
+        if input.provider == .copilot,
+           let detail = weekly.resetDescription?.trimmingCharacters(in: .whitespacesAndNewlines),
+           !detail.isEmpty
+        {
+            paceDetail = PaceDetail(leftLabel: detail, rightLabel: nil, pacePercent: nil, paceOnTop: true)
+        }
+        if let cursorPaceDetail = Self.cursorBillingCyclePaceDetail(
+            window: weekly,
+            input: input,
+            pace: input.weeklyPace)
+        {
+            paceDetail = cursorPaceDetail
+        }
+        // Perplexity bonus credits don't reset; show balance without "Resets" prefix.
+        if input.provider == .perplexity,
+           let detail = weekly.resetDescription?.trimmingCharacters(in: .whitespacesAndNewlines),
+           !detail.isEmpty
+        {
+            weeklyResetText = detail
+        }
+        if input.provider == .synthetic,
+           let regen = Self.syntheticRegenDetail(
+               weekly: weekly,
+               cost: input.snapshot?.providerCost,
+               now: input.now,
+               showUsed: input.usageBarsShowUsed)
+        {
+            weeklyResetText = regen.resetText
+            paceDetail = regen.pace
+        }
+        return Metric(
+            id: "secondary",
+            title: title ?? L(input.metadata.weeklyLabel),
+            percent: Self.clamped(input.usageBarsShowUsed ? weekly.usedPercent : weekly.remainingPercent),
+            percentStyle: percentStyle,
+            statusText: nil,
+            resetText: weeklyResetText,
+            detailText: weeklyDetailText,
+            detailLeftText: paceDetail?.leftLabel,
+            detailRightText: paceDetail?.rightLabel,
+            pacePercent: paceDetail?.pacePercent,
+            paceOnTop: paceDetail?.paceOnTop ?? true,
+            warningMarkerPercents: Self.weeklyMarkerPercents(input: input, windowMinutes: weekly.windowMinutes))
     }
 
-    private static func resetText(
-        for window: RateWindow,
-        style: ResetTimeDisplayStyle,
-        now: Date) -> String?
+    private static func codexRateMetrics(
+        input: Input,
+        projection: CodexConsumerProjection,
+        percentStyle: PercentStyle) -> [Metric]
     {
-        UsageFormatter.resetLine(for: window, style: style, now: now)
-    }
-}
-
-// MARK: - Copy-on-click overlay
-
-private struct ClickToCopyOverlay: NSViewRepresentable {
-    let copyText: String
-
-    func makeNSView(context: Context) -> ClickToCopyView {
-        ClickToCopyView(copyText: self.copyText)
-    }
+        projection.visibleRateLanes.compactMap { lane in
+            guard let window = projection.rateWindow(for: lane) else { return nil }
 
-    func updateNSView(_ nsView: ClickToCopyView, context: Context) {
-        nsView.copyText = self.copyText
-    }
-}
-
-private final class ClickToCopyView: NSView {
-    var copyText: String
-
-    init(copyText: String) {
-        self.copyText = copyText
-        super.init(frame: .zero)
-        self.wantsLayer = false
-    }
-
-    @available(*, unavailable)
-    required init?(coder: NSCoder) {
-        fatalError("init(coder:) has not been implemented")
-    }
-
-    override func acceptsFirstMouse(for event: NSEvent?) -> Bool {
-        true
-    }
+            let title: String
+            let id: String
+            let paceDetail: PaceDetail?
+            switch lane {
+            case .session:
+                title = L(input.metadata.sessionLabel)
+                id = "primary"
+                paceDetail = Self.sessionPaceDetail(
+                    provider: input.provider,
+                    window: window,
+                    now: input.now,
+                    showUsed: input.usageBarsShowUsed)
+            case .weekly:
+                title = L(input.metadata.weeklyLabel)
+                id = "secondary"
+                paceDetail = Self.weeklyPaceDetail(
+                    window: window,
+                    now: input.now,
+                    pace: Self.standardWeeklyPace(input: input, window: window),
+                    showUsed: input.usageBarsShowUsed)
+            }
 
-    override func mouseDown(with event: NSEvent) {
-        _ = event
-        let pb = NSPasteboard.general
-        pb.clearContents()
-        pb.setString(self.copyText, forType: .string)
+            return Metric(
+                id: id,
+                title: title,
+                percent: Self.clamped(input.usageBarsShowUsed ? window.usedPercent : window.remainingPercent),
+                percentStyle: percentStyle,
+                resetText: Self.resetText(for: window, style: input.resetTimeDisplayStyle, now: input.now),
+                detailText: nil,
+                detailLeftText: paceDetail?.leftLabel,
+                detailRightText: paceDetail?.rightLabel,
+                pacePercent: paceDetail?.pacePercent,
+                paceOnTop: paceDetail?.paceOnTop ?? true,
+                warningMarkerPercents: Self.codexLaneMarkerPercents(
+                    input: input,
+                    lane: lane,
+                    windowMinutes: window.windowMinutes))
+        }
     }
 }
diff --git a/Sources/CodexBar/MenuContent.swift b/Sources/CodexBar/MenuContent.swift
index fa41695f5f..1a98a67063 100644
--- a/Sources/CodexBar/MenuContent.swift
+++ b/Sources/CodexBar/MenuContent.swift
@@ -43,10 +43,13 @@ struct MenuContent: View {
             switch style {
             case .headline:
                 Text(text).font(.headline)
+                    .accessibilityLabel(text)
             case .primary:
                 Text(text)
+                    .accessibilityLabel(text)
             case .secondary:
                 Text(text).foregroundStyle(.secondary).font(.footnote)
+                    .accessibilityLabel(text)
             }
         case let .action(title, action):
             Button {
@@ -60,11 +63,40 @@ struct MenuContent: View {
                         Text(title)
                     }
                     .foregroundStyle(.primary)
+                    .accessibilityElement(children: .combine)
+                    .accessibilityLabel(title)
                 } else {
                     Text(title)
+                        .accessibilityLabel(title)
                 }
             }
             .buttonStyle(.plain)
+        case let .submenu(title, systemImageName, submenuItems):
+            VStack(alignment: .leading, spacing: 4) {
+                HStack(spacing: 8) {
+                    if let systemImageName {
+                        Image(systemName: systemImageName)
+                    }
+                    Text(title).font(.headline)
+                }
+                .accessibilityElement(children: .combine)
+                .accessibilityLabel(title)
+                ForEach(Array(submenuItems.enumerated()), id: \.offset) { _, submenuItem in
+                    HStack(spacing: 8) {
+                        if submenuItem.isChecked {
+                            Image(systemName: "checkmark")
+                                .imageScale(.small)
+                                .frame(width: 18, alignment: .center)
+                        } else {
+                            Spacer().frame(width: 18)
+                        }
+                        Text(submenuItem.title)
+                            .foregroundStyle(submenuItem.isEnabled ? .primary : .secondary)
+                    }
+                    .accessibilityElement(children: .combine)
+                    .accessibilityLabel(submenuItem.title)
+                }
+            }
         case .divider:
             Divider()
         }
@@ -86,6 +118,14 @@ struct MenuContent: View {
             self.actions.openDashboard()
         case .statusPage:
             self.actions.openStatusPage()
+        case .changelog:
+            self.actions.openChangelog()
+        case .addCodexAccount:
+            self.actions.addCodexAccount()
+        case .requestCodexSystemPromotion:
+            return
+        case let .addProviderAccount(provider):
+            self.actions.switchAccount(provider)
         case let .switchAccount(provider):
             self.actions.switchAccount(provider)
         case let .openTerminal(command):
@@ -112,6 +152,8 @@ struct MenuActions {
     let refreshAugmentSession: () -> Void
     let openDashboard: () -> Void
     let openStatusPage: () -> Void
+    let openChangelog: () -> Void
+    let addCodexAccount: () -> Void
     let switchAccount: (UsageProvider) -> Void
     let openTerminal: (String) -> Void
     let openSettings: () -> Void
@@ -120,6 +162,32 @@ struct MenuActions {
     let copyError: (String) -> Void
 }
 
+struct PersistentMenuActionRowView: View {
+    let title: String
+    let systemImageName: String?
+    @Environment(\.menuItemHighlighted) private var isHighlighted
+
+    var body: some View {
+        HStack(spacing: 8) {
+            if let systemImageName {
+                Image(systemName: systemImageName)
+                    .imageScale(.medium)
+                    .frame(width: 18, alignment: .center)
+                    .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
+            }
+            Text(self.title)
+                .font(.body)
+                .foregroundStyle(MenuHighlightStyle.primary(self.isHighlighted))
+            Spacer(minLength: 0)
+        }
+        .padding(.horizontal, 18)
+        .padding(.vertical, 4)
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .accessibilityElement(children: .combine)
+        .accessibilityLabel(self.title)
+    }
+}
+
 @MainActor
 struct StatusIconView: View {
     @Bindable var store: UsageStore
@@ -129,15 +197,55 @@ struct StatusIconView: View {
         Image(nsImage: self.icon)
             .renderingMode(.template)
             .interpolation(.none)
+            .accessibilityLabel(self.accessibilityLabel)
+            .accessibilityValue(self.accessibilityValue)
+    }
+
+    private var accessibilityLabel: String {
+        let descriptor = ProviderDescriptorRegistry.descriptor(for: self.provider)
+        return descriptor.metadata.displayName
+    }
+
+    private var accessibilityValue: String {
+        let snapshot = self.store.snapshot(for: self.provider)
+        guard let snap = snapshot else {
+            return L("No data")
+        }
+        let remaining = IconRemainingResolver.resolvedRemaining(
+            snapshot: snap,
+            style: self.store.style(for: self.provider))
+        let primary = remaining.primary
+        let percent = primary.map(Self.accessibilityPercentRemaining) ?? L("Unknown")
+        let stale = self.store.isStale(provider: self.provider)
+        return stale ? "\(percent), \(L("stale data"))" : percent
+    }
+
+    static func accessibilityPercentRemaining(_ remaining: Double) -> String {
+        String(format: L("%d percent remaining"), Int(remaining.rounded()))
     }
 
     private var icon: NSImage {
-        IconRenderer.makeIcon(
-            primaryRemaining: self.store.snapshot(for: self.provider)?.primary?.remainingPercent,
-            weeklyRemaining: self.store.snapshot(for: self.provider)?.secondary?.remainingPercent,
-            creditsRemaining: self.provider == .codex ? self.store.credits?.remaining : nil,
+        let snapshot = self.store.snapshot(for: self.provider)
+        let remaining = snapshot.map {
+            IconRemainingResolver.resolvedRemaining(snapshot: $0, style: self.store.style(for: self.provider))
+        }
+        let creditsProjection = self.store.codexConsumerProjectionIfNeeded(
+            for: self.provider,
+            surface: .menuBar,
+            snapshotOverride: snapshot,
+            now: snapshot?.updatedAt ?? Date())
+        let creditsRemaining = creditsProjection?.menuBarFallback == .creditsBalance
+            ? self.store.codexMenuBarCreditsRemaining(
+                snapshotOverride: snapshot,
+                now: snapshot?.updatedAt ?? Date())
+            : nil
+        return IconRenderer.makeIcon(
+            primaryRemaining: remaining?.primary,
+            weeklyRemaining: remaining?.secondary,
+            creditsRemaining: creditsRemaining,
             stale: self.store.isStale(provider: self.provider),
             style: self.store.style(for: self.provider),
-            statusIndicator: self.store.statusIndicator(for: self.provider))
+            statusIndicator: self.store.statusIndicator(for: self.provider),
+            hideCritters: self.store.settings.menuBarHidesCritters)
     }
 }
diff --git a/Sources/CodexBar/MenuDescriptor.swift b/Sources/CodexBar/MenuDescriptor.swift
index 05aa55fffd..75cc63d059 100644
--- a/Sources/CodexBar/MenuDescriptor.swift
+++ b/Sources/CodexBar/MenuDescriptor.swift
@@ -3,6 +3,20 @@ import Foundation
 
 @MainActor
 struct MenuDescriptor {
+    struct SubmenuItem: Equatable {
+        let title: String
+        let action: MenuAction?
+        let isEnabled: Bool
+        let isChecked: Bool
+
+        init(title: String, action: MenuAction?, isEnabled: Bool = true, isChecked: Bool = false) {
+            self.title = title
+            self.action = action
+            self.isEnabled = isEnabled
+            self.isChecked = isChecked
+        }
+    }
+
     struct Section {
         var entries: [Entry]
     }
@@ -10,13 +24,18 @@ struct MenuDescriptor {
     enum Entry {
         case text(String, TextStyle)
         case action(String, MenuAction)
+        case submenu(String, String?, [SubmenuItem])
         case divider
     }
 
     enum MenuActionSystemImage: String {
+        case installUpdate = "arrow.down.circle"
         case refresh = "arrow.clockwise"
         case dashboard = "chart.bar"
         case statusPage = "waveform.path.ecg"
+        case changelog = "list.bullet.rectangle"
+        case addAccount = "plus"
+        case systemAccount = "person.crop.circle"
         case switchAccount = "key"
         case openTerminal = "terminal"
         case loginToProvider = "arrow.right.square"
@@ -32,12 +51,16 @@ struct MenuDescriptor {
         case secondary
     }
 
-    enum MenuAction {
+    enum MenuAction: Equatable {
         case installUpdate
         case refresh
         case refreshAugmentSession
         case dashboard
         case statusPage
+        case changelog
+        case addCodexAccount
+        case requestCodexSystemPromotion(UUID)
+        case addProviderAccount(UsageProvider)
         case switchAccount(UsageProvider)
         case openTerminal(command: String)
         case loginToProvider(url: String)
@@ -54,18 +77,21 @@ struct MenuDescriptor {
         store: UsageStore,
         settings: SettingsStore,
         account: AccountInfo,
+        managedCodexAccountCoordinator: ManagedCodexAccountCoordinator? = nil,
+        codexAccountPromotionCoordinator: CodexAccountPromotionCoordinator? = nil,
         updateReady: Bool,
         includeContextualActions: Bool = true) -> MenuDescriptor
     {
         var sections: [Section] = []
 
         if let provider {
+            let fallbackAccount = store.accountInfo(for: provider)
             sections.append(Self.usageSection(for: provider, store: store, settings: settings))
             if let accountSection = Self.accountSection(
                 for: provider,
                 store: store,
                 settings: settings,
-                account: account)
+                account: fallbackAccount)
             {
                 sections.append(accountSection)
             }
@@ -78,21 +104,27 @@ struct MenuDescriptor {
             }
             if addedUsage {
                 if let accountProvider = Self.accountProviderForCombined(store: store),
+                   let fallbackAccount = Optional(store.accountInfo(for: accountProvider)),
                    let accountSection = Self.accountSection(
                        for: accountProvider,
                        store: store,
                        settings: settings,
-                       account: account)
+                       account: fallbackAccount)
                 {
                     sections.append(accountSection)
                 }
             } else {
-                sections.append(Section(entries: [.text("No usage configured.", .secondary)]))
+                sections.append(Section(entries: [.text(L("No usage configured."), .secondary)]))
             }
         }
 
         if includeContextualActions {
-            let actions = Self.actionsSection(for: provider, store: store, account: account)
+            let actions = Self.actionsSection(
+                for: provider,
+                store: store,
+                account: account,
+                managedCodexAccountCoordinator: managedCodexAccountCoordinator,
+                codexAccountPromotionCoordinator: codexAccountPromotionCoordinator)
             if !actions.entries.isEmpty {
                 sections.append(actions)
             }
@@ -117,10 +149,14 @@ struct MenuDescriptor {
 
         if let snap = store.snapshot(for: provider) {
             let resetStyle = settings.resetTimeDisplayStyle
+            let labels = Self.rateWindowLabels(provider: provider, metadata: meta, snapshot: snap)
             if let primary = snap.primary {
-                let primaryWindow = if provider == .warp || provider == .kilo {
-                    // Warp/Kilo primary uses resetDescription for non-reset detail (e.g., "Unlimited", "X/Y credits").
-                    // Avoid rendering it as a "Resets ..." line.
+                let primaryDetail = primary.resetDescription?.trimmingCharacters(in: .whitespacesAndNewlines)
+                let primaryDescriptionIsDetail = provider == .warp || provider == .kilo || provider == .abacus ||
+                    provider == .deepseek || provider == .azureopenai || provider == .mimo
+                let primaryWindow = if primaryDescriptionIsDetail {
+                    // Some providers use resetDescription for non-reset detail
+                    // (e.g., "Unlimited", "X/Y credits"). Avoid rendering it as a "Resets ..." line.
                     RateWindow(
                         usedPercent: primary.usedPercent,
                         windowMinutes: primary.windowMinutes,
@@ -131,20 +167,37 @@ struct MenuDescriptor {
                 }
                 Self.appendRateWindow(
                     entries: &entries,
-                    title: meta.sessionLabel,
+                    title: labels.primary,
                     window: primaryWindow,
                     resetStyle: resetStyle,
                     showUsed: settings.usageBarsShowUsed)
-                if provider == .warp || provider == .kilo,
+                if primaryDescriptionIsDetail,
+                   let primaryDetail,
+                   !primaryDetail.isEmpty
+                {
+                    entries.append(.text(primaryDetail, .secondary))
+                }
+                if provider == .crof,
+                   primary.resetsAt != nil,
                    let detail = primary.resetDescription?.trimmingCharacters(in: .whitespacesAndNewlines),
                    !detail.isEmpty
                 {
                     entries.append(.text(detail, .secondary))
                 }
+                if provider == .abacus,
+                   let pace = store.weeklyPace(provider: provider, window: primary)
+                {
+                    let paceSummary = UsagePaceText.weeklySummary(pace: pace)
+                    entries.append(.text(paceSummary, .secondary))
+                }
+                if let paceSummary = UsagePaceText.sessionSummary(provider: provider, window: primary) {
+                    entries.append(.text(paceSummary, .secondary))
+                }
             }
             if let weekly = snap.secondary {
                 let weeklyResetOverride: String? = {
-                    guard provider == .warp || provider == .kilo else { return nil }
+                    guard provider == .warp || provider == .kilo || provider == .perplexity || provider == .crof
+                    else { return nil }
                     let detail = weekly.resetDescription?.trimmingCharacters(in: .whitespacesAndNewlines)
                     guard let detail, !detail.isEmpty else { return nil }
                     if provider == .kilo, weekly.resetsAt != nil {
@@ -154,7 +207,7 @@ struct MenuDescriptor {
                 }()
                 Self.appendRateWindow(
                     entries: &entries,
-                    title: meta.weeklyLabel,
+                    title: labels.secondary,
                     window: weekly,
                     resetStyle: resetStyle,
                     showUsed: settings.usageBarsShowUsed,
@@ -171,24 +224,26 @@ struct MenuDescriptor {
                     entries.append(.text(paceSummary, .secondary))
                 }
             }
-            if meta.supportsOpus, let opus = snap.tertiary {
+            if labels.showsTertiary, let opus = snap.tertiary {
+                // Perplexity purchased credits don't reset; show the balance as plain text.
+                let opusResetOverride: String? = provider == .perplexity
+                    ? opus.resetDescription?.trimmingCharacters(in: .whitespacesAndNewlines)
+                    : nil
                 Self.appendRateWindow(
                     entries: &entries,
-                    title: meta.opusLabel ?? "Sonnet",
+                    title: labels.tertiary,
                     window: opus,
                     resetStyle: resetStyle,
-                    showUsed: settings.usageBarsShowUsed)
+                    showUsed: settings.usageBarsShowUsed,
+                    resetOverride: opusResetOverride)
             }
 
-            if let cost = snap.providerCost {
-                if cost.currencyCode == "Quota" {
-                    let used = String(format: "%.0f", cost.used)
-                    let limit = String(format: "%.0f", cost.limit)
-                    entries.append(.text("Quota: \(used) / \(limit)", .primary))
-                }
+            Self.appendProviderUsageSummaries(entries: &entries, snapshot: snap)
+            if snap.rateLimitsUnavailable(for: provider) {
+                entries.append(.text(L("Limits not available"), .secondary))
             }
         } else {
-            entries.append(.text("No usage yet", .secondary))
+            entries.append(.text(L("No usage yet"), .secondary))
         }
 
         let usageContext = ProviderMenuUsageContext(
@@ -203,6 +258,200 @@ struct MenuDescriptor {
         return Section(entries: entries)
     }
 
+    private static func appendProviderUsageSummaries(
+        entries: inout [Entry],
+        snapshot: UsageSnapshot)
+    {
+        if let cost = snapshot.providerCost {
+            if cost.currencyCode == "Quota" {
+                let used = String(format: "%.0f", cost.used)
+                let limit = String(format: "%.0f", cost.limit)
+                entries.append(.text("\(L("Quota")): \(used) / \(limit)", .primary))
+            }
+        }
+        if let openAIAPIUsage = snapshot.openAIAPIUsage {
+            Self.appendOpenAIAPIUsageSummary(entries: &entries, usage: openAIAPIUsage)
+        }
+        if let claudeAdminAPIUsage = snapshot.claudeAdminAPIUsage {
+            Self.appendClaudeAdminAPIUsageSummary(entries: &entries, usage: claudeAdminAPIUsage)
+        }
+        if let openRouterUsage = snapshot.openRouterUsage {
+            Self.appendOpenRouterUsageSummary(entries: &entries, usage: openRouterUsage)
+        }
+        if let poeUsage = snapshot.poeUsage, !poeUsage.daily.isEmpty {
+            Self.appendPoeUsageSummary(entries: &entries, usage: poeUsage)
+        }
+        if let mistralUsage = snapshot.mistralUsage, !mistralUsage.daily.isEmpty {
+            Self.appendMistralUsageSummary(entries: &entries, usage: mistralUsage)
+        }
+        if let mimoUsage = snapshot.mimoUsage {
+            entries.append(.text("\(L("Balance")): \(mimoUsage.balanceDetail)", .primary))
+        }
+    }
+
+    private static func appendOpenAIAPIUsageSummary(
+        entries: inout [Entry],
+        usage: OpenAIAPIUsageSnapshot)
+    {
+        let today = usage.latestDay
+        let last7 = usage.last7Days
+        let last30 = usage.last30Days
+        let historyLabel = usage.historyWindowLabel
+
+        entries.append(.text(
+            "\(L("Today")): \(UsageFormatter.usdString(today.costUSD)) · " +
+                "\(UsageFormatter.tokenCountString(today.totalTokens)) \(L("tokens"))",
+            .secondary))
+        entries.append(.text(
+            "7d: \(UsageFormatter.usdString(last7.costUSD)) · " +
+                "\(UsageFormatter.tokenCountString(last7.requests)) \(L("requests"))",
+            .secondary))
+        entries.append(.text(
+            "\(historyLabel): \(UsageFormatter.usdString(last30.costUSD)) · " +
+                "\(UsageFormatter.tokenCountString(last30.requests)) \(L("requests"))",
+            .secondary))
+        if let topModel = usage.topModels.first?.name {
+            entries.append(.text("\(L("Top model")): \(topModel)", .secondary))
+        }
+    }
+
+    private static func appendClaudeAdminAPIUsageSummary(
+        entries: inout [Entry],
+        usage: ClaudeAdminAPIUsageSnapshot)
+    {
+        let today = usage.latestDay
+        let last7 = usage.last7Days
+        let last30 = usage.last30Days
+
+        entries.append(.text(
+            "\(L("Today")): \(UsageFormatter.usdString(today.costUSD)) · " +
+                "\(UsageFormatter.tokenCountString(today.totalTokens)) \(L("tokens"))",
+            .secondary))
+        entries.append(.text(
+            "7d: \(UsageFormatter.usdString(last7.costUSD)) · " +
+                "\(UsageFormatter.tokenCountString(last7.totalTokens)) \(L("tokens"))",
+            .secondary))
+        entries.append(.text(
+            "30d: \(UsageFormatter.usdString(last30.costUSD)) · " +
+                "\(UsageFormatter.tokenCountString(last30.totalTokens)) \(L("tokens"))",
+            .secondary))
+        if let topModel = usage.topModels.first?.name {
+            entries.append(.text("\(L("Top model")): \(topModel)", .secondary))
+        }
+    }
+
+    private static func appendOpenRouterUsageSummary(
+        entries: inout [Entry],
+        usage: OpenRouterUsageSnapshot)
+    {
+        if let daily = usage.keyUsageDaily {
+            entries.append(.text("\(L("Today")): \(UsageFormatter.usdString(daily))", .secondary))
+        }
+        if let weekly = usage.keyUsageWeekly {
+            entries.append(.text("\(L("Week")): \(UsageFormatter.usdString(weekly))", .secondary))
+        }
+        if let monthly = usage.keyUsageMonthly {
+            entries.append(.text("\(L("Month")): \(UsageFormatter.usdString(monthly))", .secondary))
+        }
+    }
+
+    private static func appendMistralUsageSummary(
+        entries: inout [Entry],
+        usage: MistralUsageSnapshot)
+    {
+        let latest = usage.daily.last
+        if let latest {
+            entries.append(.text(
+                "\(L("Latest")): \(usage.currencySymbol)\(String(format: "%.4f", max(0, latest.cost))) · " +
+                    "\(UsageFormatter.tokenCountString(latest.totalTokens)) \(L("tokens"))",
+                .secondary))
+        }
+        let totalTokens = usage.totalInputTokens + usage.totalCachedTokens + usage.totalOutputTokens
+        entries.append(.text(
+            "\(L("Month")): \(usage.currencySymbol)\(String(format: "%.4f", max(0, usage.totalCost))) · " +
+                "\(UsageFormatter.tokenCountString(totalTokens)) \(L("tokens"))",
+            .secondary))
+        if let top = Self.topMistralModel(from: usage.daily) {
+            entries.append(.text("\(L("Top model")): \(top)", .secondary))
+        }
+    }
+
+    private static func topMistralModel(from entries: [MistralDailyUsageBucket]) -> String? {
+        var tokens: [String: Int] = [:]
+        for entry in entries {
+            for model in entry.models {
+                tokens[model.name, default: 0] += model.totalTokens
+            }
+        }
+        return tokens.max {
+            if $0.value == $1.value { return $0.key > $1.key }
+            return $0.value < $1.value
+        }?.key
+    }
+
+    private static func appendPoeUsageSummary(
+        entries: inout [Entry],
+        usage: PoeUsageHistorySnapshot)
+    {
+        let today = usage.latestDay
+        let week = usage.last7Days
+        let month = usage.last30Days
+        let todayCostSuffix = today.costUSD.map { " · \(UsageFormatter.usdString($0))" } ?? ""
+        let weekCostSuffix = week.costUSD.map { " · \(UsageFormatter.usdString($0))" } ?? ""
+        let monthCostSuffix = month.costUSD.map { " · \(UsageFormatter.usdString($0))" } ?? ""
+        entries.append(.text(
+            "\(L("Today")): \(Self.pointsString(today.points)) · " +
+                "\(UsageFormatter.tokenCountString(today.requests)) \(L("requests"))\(todayCostSuffix)",
+            .secondary))
+        entries.append(.text(
+            "7d: \(Self.pointsString(week.points)) · " +
+                "\(UsageFormatter.tokenCountString(week.requests)) \(L("requests"))\(weekCostSuffix)",
+            .secondary))
+        entries.append(.text(
+            "30d: \(Self.pointsString(month.points)) · " +
+                "\(UsageFormatter.tokenCountString(month.requests)) \(L("requests"))\(monthCostSuffix)",
+            .secondary))
+        if let topModel = usage.topModels.first {
+            entries.append(
+                .text(
+                    "\(L("Top model")): \(topModel.name) (\(Self.pointsString(topModel.points)))",
+                    .secondary))
+        }
+        if !usage.topUsageTypes.isEmpty {
+            let summary = usage.topUsageTypes
+                .prefix(2)
+                .map { "\($0.name): \(Self.pointsString($0.points))" }
+                .joined(separator: " · ")
+            entries.append(.text("Usage mix: \(summary)", .secondary))
+        }
+        let recent = usage.recentEntries(limit: 3)
+        if !recent.isEmpty {
+            entries.append(.text("Recent activity:", .secondary))
+            for entry in recent {
+                let stamp = Self.poeTimeString(entry.createdAt)
+                entries.append(.text(
+                    "\(stamp) · \(entry.model) · \(Self.pointsString(entry.points))",
+                    .secondary))
+            }
+        }
+    }
+
+    private static func pointsString(_ points: Double) -> String {
+        let value = max(0, points)
+        if value.rounded() == value {
+            return "\(UsageFormatter.tokenCountString(Int(value))) points"
+        }
+        return "\(String(format: "%.1f", value)) points"
+    }
+
+    private static func poeTimeString(_ date: Date) -> String {
+        let formatter = DateFormatter()
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        formatter.timeZone = .current
+        formatter.dateFormat = "MM-dd HH:mm"
+        return formatter.string(from: date)
+    }
+
     private static func accountSection(
         for provider: UsageProvider,
         store: UsageStore,
@@ -236,27 +485,61 @@ struct MenuDescriptor {
         let redactedEmail = PersonalInfoRedactor.redactEmail(emailText, isEnabled: hidePersonalInfo)
 
         if let emailText, !emailText.isEmpty {
-            entries.append(.text("Account: \(redactedEmail)", .secondary))
+            entries.append(.text("\(L("Account")): \(redactedEmail)", .secondary))
         }
-        if provider == .kilo {
+        if provider == .kiro {
+            if let plan = snapshot?.kiroUsage?.displayPlanName,
+               !plan.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+            {
+                entries.append(.text("\(L("Plan")): \(plan)", .secondary))
+            }
+            if let loginMethodText, !loginMethodText.isEmpty {
+                entries.append(.text("\(L("Auth")): \(loginMethodText)", .secondary))
+            }
+            if let overages = snapshot?.kiroUsage?.overagesStatus,
+               !overages.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+            {
+                entries.append(.text("\(L("Overages")): \(overages)", .secondary))
+            }
+        } else if provider == .kilo {
             let kiloLogin = self.kiloLoginParts(loginMethod: loginMethodText)
             if let pass = kiloLogin.pass {
-                entries.append(.text("Plan: \(AccountFormatter.plan(pass))", .secondary))
+                entries.append(.text("\(L("Plan")): \(AccountFormatter.plan(pass, provider: provider))", .secondary))
             }
             for detail in kiloLogin.details {
-                entries.append(.text("Activity: \(detail)", .secondary))
+                entries.append(.text("\(L("Activity")): \(detail)", .secondary))
             }
         } else if let loginMethodText, !loginMethodText.isEmpty {
-            entries.append(.text("Plan: \(AccountFormatter.plan(loginMethodText))", .secondary))
+            if provider == .openrouter || provider == .mimo || provider == .poe,
+               loginMethodText.localizedCaseInsensitiveContains("balance:")
+            {
+                let balanceValue = loginMethodText
+                    .replacingOccurrences(
+                        of: #"(?i)^\s*balance:\s*"#,
+                        with: "",
+                        options: [.regularExpression])
+                    .trimmingCharacters(in: .whitespacesAndNewlines)
+                let value = balanceValue.isEmpty ? loginMethodText : balanceValue
+                entries.append(
+                    .text("\(L("Balance")): \(AccountFormatter.plan(value, provider: provider))", .secondary))
+            } else {
+                entries.append(
+                    .text(
+                        "\(L("Plan")): \(AccountFormatter.plan(loginMethodText, provider: provider))",
+                        .secondary))
+            }
         }
 
         if metadata.usesAccountFallback {
             if emailText?.isEmpty ?? true, let fallbackEmail = fallback.email, !fallbackEmail.isEmpty {
                 let redacted = PersonalInfoRedactor.redactEmail(fallbackEmail, isEnabled: hidePersonalInfo)
-                entries.append(.text("Account: \(redacted)", .secondary))
+                entries.append(.text("\(L("Account")): \(redacted)", .secondary))
             }
             if loginMethodText?.isEmpty ?? true, let fallbackPlan = fallback.plan, !fallbackPlan.isEmpty {
-                entries.append(.text("Plan: \(AccountFormatter.plan(fallbackPlan))", .secondary))
+                entries.append(
+                    .text(
+                        "\(L("Plan")): \(AccountFormatter.plan(fallbackPlan, provider: provider))",
+                        .secondary))
             }
         }
 
@@ -302,17 +585,20 @@ struct MenuDescriptor {
     private static func actionsSection(
         for provider: UsageProvider?,
         store: UsageStore,
-        account: AccountInfo) -> Section
+        account: AccountInfo,
+        managedCodexAccountCoordinator: ManagedCodexAccountCoordinator?,
+        codexAccountPromotionCoordinator: CodexAccountPromotionCoordinator?) -> Section
     {
         var entries: [Entry] = []
         let targetProvider = provider ?? store.enabledProviders().first
         let metadata = targetProvider.map { store.metadata(for: $0) }
+        let fallbackAccount = targetProvider.map { store.accountInfo(for: $0) } ?? account
         let loginContext = targetProvider.map {
             ProviderMenuLoginContext(
                 provider: $0,
                 store: store,
                 settings: store.settings,
-                account: account)
+                account: fallbackAccount)
         }
 
         // Show "Add Account" if no account, "Switch Account" if logged in
@@ -326,8 +612,8 @@ struct MenuDescriptor {
                 entries.append(.action(override.label, override.action))
             } else {
                 let loginAction = self.switchAccountTarget(for: provider, store: store)
-                let hasAccount = self.hasAccount(for: provider, store: store, account: account)
-                let accountLabel = hasAccount ? "Switch Account..." : "Add Account..."
+                let hasAccount = self.hasAccount(for: provider, store: store, account: fallbackAccount)
+                let accountLabel = hasAccount ? L("Switch Account...") : L("Add Account...")
                 entries.append(.action(accountLabel, loginAction))
             }
         }
@@ -337,16 +623,21 @@ struct MenuDescriptor {
                 provider: targetProvider,
                 store: store,
                 settings: store.settings,
-                account: account)
+                account: fallbackAccount,
+                managedCodexAccountCoordinator: managedCodexAccountCoordinator,
+                codexAccountPromotionCoordinator: codexAccountPromotionCoordinator)
             ProviderCatalog.implementation(for: targetProvider)?
                 .appendActionMenuEntries(context: actionContext, entries: &entries)
         }
 
         if metadata?.dashboardURL != nil {
-            entries.append(.action("Usage Dashboard", .dashboard))
+            entries.append(.action(L("Usage Dashboard"), .dashboard))
         }
         if metadata?.statusPageURL != nil || metadata?.statusLinkURL != nil {
-            entries.append(.action("Status Page", .statusPage))
+            entries.append(.action(L("Status Page"), .statusPage))
+        }
+        if store.settings.providerChangelogLinksEnabled, metadata?.changelogURL != nil {
+            entries.append(.action(L("Changelog"), .changelog))
         }
 
         if let statusLine = self.statusLine(for: provider, store: store) {
@@ -359,12 +650,13 @@ struct MenuDescriptor {
     private static func metaSection(updateReady: Bool) -> Section {
         var entries: [Entry] = []
         if updateReady {
-            entries.append(.action("Update ready, restart now?", .installUpdate))
+            entries.append(.action(L("Update ready, restart now?"), .installUpdate))
         }
         entries.append(contentsOf: [
-            .action("Settings...", .settings),
-            .action("About CodexBar", .about),
-            .action("Quit", .quit),
+            .action(L("Refresh"), .refresh),
+            .action(L("Settings..."), .settings),
+            .action(L("About CodexBar"), .about),
+            .action(L("Quit"), .quit),
         ])
         return Section(entries: entries)
     }
@@ -407,6 +699,24 @@ struct MenuDescriptor {
         return false
     }
 
+    private static func rateWindowLabels(
+        provider: UsageProvider,
+        metadata: ProviderMetadata,
+        snapshot: UsageSnapshot) -> (primary: String, secondary: String, tertiary: String, showsTertiary: Bool)
+    {
+        if provider == .factory, snapshot.tertiary != nil {
+            return ("5-hour", L("Weekly"), L("Monthly"), true)
+        }
+        let primaryLabel = provider == .grok
+            ? GrokProviderDescriptor.primaryLabel(window: snapshot.primary) ?? metadata.sessionLabel
+            : metadata.sessionLabel
+        return (
+            L(primaryLabel),
+            L(metadata.weeklyLabel),
+            metadata.opusLabel.map(L) ?? L("Sonnet"),
+            metadata.supportsOpus)
+    }
+
     private static func appendRateWindow(
         entries: inout [Entry],
         title: String,
@@ -437,8 +747,12 @@ struct MenuDescriptor {
 }
 
 private enum AccountFormatter {
-    static func plan(_ text: String) -> String {
-        let cleaned = UsageFormatter.cleanPlanName(text)
+    static func plan(_ text: String, provider: UsageProvider) -> String {
+        let cleaned = if provider == .codex {
+            CodexPlanFormatting.displayName(text) ?? UsageFormatter.cleanPlanName(text)
+        } else {
+            UsageFormatter.cleanPlanName(text)
+        }
         return cleaned.isEmpty ? text : cleaned
     }
 
@@ -450,12 +764,18 @@ private enum AccountFormatter {
 extension MenuDescriptor.MenuAction {
     var systemImageName: String? {
         switch self {
-        case .installUpdate, .settings, .about, .quit:
-            nil
+        case .installUpdate: MenuDescriptor.MenuActionSystemImage.installUpdate.rawValue
+        case .settings: MenuDescriptor.MenuActionSystemImage.settings.rawValue
+        case .about: MenuDescriptor.MenuActionSystemImage.about.rawValue
+        case .quit: MenuDescriptor.MenuActionSystemImage.quit.rawValue
         case .refresh: MenuDescriptor.MenuActionSystemImage.refresh.rawValue
         case .refreshAugmentSession: MenuDescriptor.MenuActionSystemImage.refresh.rawValue
         case .dashboard: MenuDescriptor.MenuActionSystemImage.dashboard.rawValue
         case .statusPage: MenuDescriptor.MenuActionSystemImage.statusPage.rawValue
+        case .changelog: MenuDescriptor.MenuActionSystemImage.changelog.rawValue
+        case .addCodexAccount, .addProviderAccount: MenuDescriptor.MenuActionSystemImage.addAccount.rawValue
+        case .requestCodexSystemPromotion:
+            nil
         case .switchAccount: MenuDescriptor.MenuActionSystemImage.switchAccount.rawValue
         case .openTerminal: MenuDescriptor.MenuActionSystemImage.openTerminal.rawValue
         case .loginToProvider: MenuDescriptor.MenuActionSystemImage.loginToProvider.rawValue
diff --git a/Sources/CodexBar/MenuHighlightStyle.swift b/Sources/CodexBar/MenuHighlightStyle.swift
index be76fe04a7..bb493b5026 100644
--- a/Sources/CodexBar/MenuHighlightStyle.swift
+++ b/Sources/CodexBar/MenuHighlightStyle.swift
@@ -2,6 +2,10 @@ import SwiftUI
 
 extension EnvironmentValues {
     @Entry var menuItemHighlighted: Bool = false
+    /// Optional live-refresh monitor injected into menu card views so the provider card
+    /// subtitle can reflect the in-flight "Refreshing…" state in place while the NSMenu
+    /// stays open, without rebuilding the menu during AppKit tracking.
+    @Entry var menuCardRefreshMonitor: MenuCardRefreshMonitor?
 }
 
 enum MenuHighlightStyle {
diff --git a/Sources/CodexBar/MenuSessionCoordinator.swift b/Sources/CodexBar/MenuSessionCoordinator.swift
new file mode 100644
index 0000000000..d367c87f64
--- /dev/null
+++ b/Sources/CodexBar/MenuSessionCoordinator.swift
@@ -0,0 +1,150 @@
+struct MenuSessionCoordinator<MenuID: Hashable> {
+    enum ClosedPreparationPlan: Equatable {
+        case none
+        case nonDeferred
+        case required(version: Int)
+    }
+
+    private(set) var contentVersion = 0
+    private(set) var latestRequiredRebuildVersion = 0
+    private(set) var latestDataOnlyContentVersion = 0
+    private(set) var latestStructuralContentVersion = 0
+    private(set) var renderedVersions: [MenuID: Int] = [:]
+    private(set) var deferredUntilNextOpen: Set<MenuID> = []
+    private(set) var parentRebuildsDeferredDuringTracking: Set<MenuID> = []
+
+    @discardableResult
+    mutating func invalidate(
+        allowsStaleContent: Bool,
+        requiresRebuild: Bool)
+        -> Int
+    {
+        self.contentVersion &+= 1
+        if allowsStaleContent {
+            self.latestDataOnlyContentVersion = self.contentVersion
+        } else {
+            self.latestStructuralContentVersion = self.contentVersion
+            if requiresRebuild {
+                self.latestRequiredRebuildVersion = self.contentVersion
+            }
+        }
+        return self.contentVersion
+    }
+
+    func needsRefresh(_ menuID: MenuID) -> Bool {
+        self.renderedVersions[menuID] != self.contentVersion
+    }
+
+    mutating func markFresh(_ menuID: MenuID) {
+        self.renderedVersions[menuID] = self.contentVersion
+    }
+
+    func renderedVersion(for menuID: MenuID) -> Int? {
+        self.renderedVersions[menuID]
+    }
+
+    func canPreserveStaleContent(for menuID: MenuID) -> Bool {
+        guard let renderedVersion = self.renderedVersions[menuID] else { return false }
+        return self.contentVersion == self.latestDataOnlyContentVersion &&
+            renderedVersion >= self.latestStructuralContentVersion
+    }
+
+    func hasRequiredClosedPreparation(for menuIDs: some Sequence<MenuID>) -> Bool {
+        guard self.latestRequiredRebuildVersion > 0 else { return false }
+        return menuIDs.contains { self.isRenderedVersion($0, olderThan: self.latestRequiredRebuildVersion) }
+    }
+
+    func closedPreparationPlan(for menuIDs: some Sequence<MenuID>) -> ClosedPreparationPlan {
+        if self.hasRequiredClosedPreparation(for: menuIDs) {
+            return .required(version: self.latestRequiredRebuildVersion)
+        }
+        if self.contentVersion > self.latestRequiredRebuildVersion {
+            return .none
+        }
+        return .nonDeferred
+    }
+
+    func isRenderedVersion(_ menuID: MenuID, olderThan version: Int) -> Bool {
+        (self.renderedVersions[menuID] ?? -1) < version
+    }
+
+    mutating func deferUntilNextOpen(_ menuID: MenuID) {
+        self.deferredUntilNextOpen.insert(menuID)
+    }
+
+    mutating func clearNextOpenDeferral(_ menuID: MenuID) {
+        self.deferredUntilNextOpen.remove(menuID)
+    }
+
+    func isDeferredUntilNextOpen(_ menuID: MenuID) -> Bool {
+        self.deferredUntilNextOpen.contains(menuID)
+    }
+
+    mutating func deferParentRebuild(_ menuID: MenuID) {
+        self.parentRebuildsDeferredDuringTracking.insert(menuID)
+    }
+
+    mutating func clearParentRebuildDeferral(_ menuID: MenuID) {
+        self.parentRebuildsDeferredDuringTracking.remove(menuID)
+    }
+
+    func isParentRebuildDeferred(_ menuID: MenuID) -> Bool {
+        self.parentRebuildsDeferredDuringTracking.contains(menuID)
+    }
+
+    mutating func removeMenu(_ menuID: MenuID) {
+        self.renderedVersions.removeValue(forKey: menuID)
+        self.deferredUntilNextOpen.remove(menuID)
+        self.parentRebuildsDeferredDuringTracking.remove(menuID)
+    }
+
+    mutating func clearMenuTracking() {
+        self.renderedVersions.removeAll(keepingCapacity: false)
+        self.deferredUntilNextOpen.removeAll(keepingCapacity: false)
+        self.parentRebuildsDeferredDuringTracking.removeAll(keepingCapacity: false)
+    }
+
+    #if DEBUG
+    mutating func replaceContentVersionForTesting(_ version: Int) {
+        self.contentVersion = version
+    }
+
+    mutating func replaceRenderedVersionsForTesting(_ versions: [MenuID: Int]) {
+        self.renderedVersions = versions
+    }
+
+    mutating func replaceDeferredMenusForTesting(_ menuIDs: Set<MenuID>) {
+        self.deferredUntilNextOpen = menuIDs
+    }
+    #endif
+}
+
+struct MenuRebuildRequestRegistry<MenuID: Hashable> {
+    private var nextToken = 0
+    private(set) var tokens: [MenuID: Int] = [:]
+
+    mutating func replaceRequest(for menuID: MenuID) -> Int {
+        self.nextToken &+= 1
+        self.tokens[menuID] = self.nextToken
+        return self.nextToken
+    }
+
+    func isCurrent(_ token: Int, for menuID: MenuID) -> Bool {
+        self.tokens[menuID] == token
+    }
+
+    @discardableResult
+    mutating func finish(_ token: Int, for menuID: MenuID) -> Bool {
+        guard self.isCurrent(token, for: menuID) else { return false }
+        self.tokens.removeValue(forKey: menuID)
+        return true
+    }
+
+    mutating func cancel(for menuID: MenuID) {
+        self.tokens.removeValue(forKey: menuID)
+    }
+
+    mutating func cancelAll() {
+        self.tokens.removeAll(keepingCapacity: false)
+    }
+}
diff --git a/Sources/CodexBar/MouseLocationReader.swift b/Sources/CodexBar/MouseLocationReader.swift
index 73abc8f088..55a326b913 100644
--- a/Sources/CodexBar/MouseLocationReader.swift
+++ b/Sources/CodexBar/MouseLocationReader.swift
@@ -22,6 +22,10 @@ struct MouseLocationReader: NSViewRepresentable {
         var onMoved: ((CGPoint?) -> Void)?
         private var trackingArea: NSTrackingArea?
 
+        override var isFlipped: Bool {
+            true
+        }
+
         override func viewDidMoveToWindow() {
             super.viewDidMoveToWindow()
             self.window?.acceptsMouseMovedEvents = true
diff --git a/Sources/CodexBar/Notifications+CodexBar.swift b/Sources/CodexBar/Notifications+CodexBar.swift
index 8c04562769..65daec3f64 100644
--- a/Sources/CodexBar/Notifications+CodexBar.swift
+++ b/Sources/CodexBar/Notifications+CodexBar.swift
@@ -1,7 +1,44 @@
+import CodexBarCore
 import Foundation
 
 extension Notification.Name {
     static let codexbarOpenSettings = Notification.Name("codexbarOpenSettings")
     static let codexbarDebugBlinkNow = Notification.Name("codexbarDebugBlinkNow")
+    #if DEBUG
+    static let codexbarDebugSimulateMemoryPressure =
+        Notification.Name("com.steipete.codexbar.debug.simulateMemoryPressure")
+    #endif
+    static let codexbarWeeklyLimitReset = Notification.Name("codexbarWeeklyLimitReset")
     static let codexbarProviderConfigDidChange = Notification.Name("codexbarProviderConfigDidChange")
+    static let codexbarQuotaWarningDidPost = Notification.Name("codexbarQuotaWarningDidPost")
+}
+
+@MainActor
+final class WeeklyLimitResetEvent: NSObject {
+    let provider: UsageProvider
+    let accountIdentifier: String
+    let accountLabel: String?
+    let usedPercent: Double
+
+    init(provider: UsageProvider, accountIdentifier: String, accountLabel: String?, usedPercent: Double) {
+        self.provider = provider
+        self.accountIdentifier = accountIdentifier
+        self.accountLabel = accountLabel
+        self.usedPercent = usedPercent
+    }
+}
+
+@MainActor
+final class QuotaWarningPostedEvent: NSObject {
+    let provider: UsageProvider
+    let window: QuotaWarningWindow
+    let threshold: Int
+    let postedAt: Date
+
+    init(provider: UsageProvider, window: QuotaWarningWindow, threshold: Int, postedAt: Date) {
+        self.provider = provider
+        self.window = window
+        self.threshold = threshold
+        self.postedAt = postedAt
+    }
 }
diff --git a/Sources/CodexBar/OpenAICreditsPurchaseWindowController.swift b/Sources/CodexBar/OpenAICreditsPurchaseWindowController.swift
index 99ec8eef69..8455c222b7 100644
--- a/Sources/CodexBar/OpenAICreditsPurchaseWindowController.swift
+++ b/Sources/CodexBar/OpenAICreditsPurchaseWindowController.swift
@@ -361,6 +361,7 @@ final class OpenAICreditsPurchaseWindowController: NSWindowController, WKNavigat
     private let logger = CodexBarLog.logger(LogCategories.creditsPurchase)
     private var webView: WKWebView?
     private var accountEmail: String?
+    private var cacheScope: CookieHeaderCache.Scope?
     private var pendingAutoStart = false
     private let logHandler = WeakScriptMessageHandler()
 
@@ -374,10 +375,23 @@ final class OpenAICreditsPurchaseWindowController: NSWindowController, WKNavigat
         fatalError("init(coder:) has not been implemented")
     }
 
-    func show(purchaseURL: URL, accountEmail: String?, autoStartPurchase: Bool) {
+    func show(
+        purchaseURL: URL,
+        accountEmail: String?,
+        cacheScope: CookieHeaderCache.Scope?,
+        autoStartPurchase: Bool)
+    {
+        guard Self.canOpenPurchaseWindow(accountEmail: accountEmail, cacheScope: cacheScope) else {
+            self.close()
+            self.accountEmail = nil
+            self.cacheScope = nil
+            self.logger.error("Buy credits blocked: scoped account email unavailable")
+            return
+        }
         let normalizedEmail = Self.normalizeEmail(accountEmail)
-        if self.window == nil || normalizedEmail != self.accountEmail {
+        if self.window == nil || normalizedEmail != self.accountEmail || cacheScope != self.cacheScope {
             self.accountEmail = normalizedEmail
+            self.cacheScope = cacheScope
             self.buildWindow()
         }
         Self.resetDebugLog()
@@ -399,7 +413,9 @@ final class OpenAICreditsPurchaseWindowController: NSWindowController, WKNavigat
     private func buildWindow() {
         let config = WKWebViewConfiguration()
         config.userContentController.add(self.logHandler, name: Self.logHandlerName)
-        config.websiteDataStore = OpenAIDashboardWebsiteDataStore.store(forAccountEmail: self.accountEmail)
+        config.websiteDataStore = OpenAIDashboardWebsiteDataStore.store(
+            forAccountEmail: self.accountEmail,
+            scope: self.cacheScope)
 
         let webView = WKWebView(frame: .zero, configuration: config)
         webView.navigationDelegate = self
@@ -468,6 +484,10 @@ final class OpenAICreditsPurchaseWindowController: NSWindowController, WKNavigat
         return raw.lowercased()
     }
 
+    static func canOpenPurchaseWindow(accountEmail: String?, cacheScope: CookieHeaderCache.Scope?) -> Bool {
+        cacheScope == nil || self.normalizeEmail(accountEmail) != nil
+    }
+
     private static func defaultFrame() -> NSRect {
         let visible = NSScreen.main?.visibleFrame ?? NSRect(x: 0, y: 0, width: 1200, height: 900)
         let width = min(Self.defaultSize.width, visible.width * 0.92)
diff --git a/Sources/CodexBar/PlanUtilizationHistoryChartMenuView.swift b/Sources/CodexBar/PlanUtilizationHistoryChartMenuView.swift
new file mode 100644
index 0000000000..b704754af5
--- /dev/null
+++ b/Sources/CodexBar/PlanUtilizationHistoryChartMenuView.swift
@@ -0,0 +1,853 @@
+import Charts
+import CodexBarCore
+import SwiftUI
+
+@MainActor
+struct PlanUtilizationHistoryChartMenuView: View {
+    private enum Layout {
+        static let chartHeight: CGFloat = 130
+        static let detailHeight: CGFloat = 16
+        static let emptyStateHeight: CGFloat = chartHeight + detailHeight
+        static let maxPoints = 30
+        static let maxAxisLabels = 4
+        static let barWidth: CGFloat = 6
+    }
+
+    private struct SeriesSelection: Hashable {
+        let name: PlanUtilizationSeriesName
+        let windowMinutes: Int
+
+        var id: String {
+            "\(self.name.rawValue):\(self.windowMinutes)"
+        }
+    }
+
+    private struct VisibleSeries: Identifiable, Equatable {
+        let selection: SeriesSelection
+        let title: String
+        let history: PlanUtilizationSeriesHistory
+
+        var id: String {
+            self.selection.id
+        }
+    }
+
+    private struct EntryPointAccumulator {
+        let effectiveBoundaryDate: Date
+        let displayBoundaryDate: Date
+        let observedAt: Date
+        let usedPercent: Double
+        let hasObservedResetBoundary: Bool
+    }
+
+    private struct ResetBoundaryLattice {
+        let referenceBoundaryDate: Date
+        let windowInterval: TimeInterval
+    }
+
+    private struct Point: Identifiable {
+        let id: Date
+        let index: Int
+        let date: Date
+        let usedPercent: Double
+        let isObserved: Bool
+    }
+
+    private struct Model {
+        let points: [Point]
+        let axisIndexes: [Double]
+        let xDomain: ClosedRange<Double>?
+        let pointsByID: [Date: Point]
+        let pointsByIndex: [Int: Point]
+        let barColor: Color
+        let trackColor: Color
+    }
+
+    private let provider: UsageProvider
+    private let visibleSeries: [VisibleSeries]
+    private let modelsBySeriesID: [String: Model]
+    private let emptyModel: Model
+    private let width: CGFloat
+
+    @State private var selectedSeriesID: String?
+    @State private var selectedPointID: Date?
+
+    init(
+        provider: UsageProvider,
+        histories: [PlanUtilizationSeriesHistory],
+        snapshot: UsageSnapshot? = nil,
+        width: CGFloat)
+    {
+        self.provider = provider
+        let visibleSeries = Self.visibleSeries(
+            histories: histories,
+            provider: provider,
+            snapshot: snapshot)
+        let referenceDate = Date()
+        self.visibleSeries = visibleSeries
+        self.modelsBySeriesID = Dictionary(uniqueKeysWithValues: visibleSeries.map {
+            ($0.id, Self.makeModel(history: $0.history, provider: provider, referenceDate: referenceDate))
+        })
+        self.emptyModel = Self.emptyModel(provider: provider)
+        self.width = width
+    }
+
+    var body: some View {
+        let effectiveSelectedSeries = self.visibleSeries.first(where: { $0.id == self.selectedSeriesID })
+            ?? self.visibleSeries.first
+        let model = effectiveSelectedSeries.flatMap { self.modelsBySeriesID[$0.id] } ?? self.emptyModel
+
+        VStack(alignment: .leading, spacing: 10) {
+            if self.visibleSeries.count > 1 {
+                Picker(selection: Binding(
+                    get: { effectiveSelectedSeries?.id ?? "" },
+                    set: { newValue in
+                        self.selectedSeriesID = newValue
+                        self.selectedPointID = nil
+                    })) {
+                        ForEach(self.visibleSeries) { series in
+                            Text(series.title).tag(series.id)
+                        }
+                    } label: {
+                        EmptyView()
+                    }
+                    .labelsHidden()
+                        .pickerStyle(.segmented)
+            }
+
+            if model.points.isEmpty {
+                ZStack {
+                    Text(Self.emptyStateText(title: effectiveSelectedSeries?.title))
+                        .font(.footnote)
+                        .foregroundStyle(.secondary)
+                }
+                .frame(maxWidth: .infinity)
+                .frame(height: Layout.emptyStateHeight)
+            } else {
+                self.utilizationChart(model: model)
+                    .chartYAxis(.hidden)
+                    .chartYScale(domain: 0...100)
+                    .chartXAxis {
+                        AxisMarks(values: model.axisIndexes) { value in
+                            AxisGridLine().foregroundStyle(Color.clear)
+                            AxisTick().foregroundStyle(Color.clear)
+                            AxisValueLabel {
+                                if let raw = value.as(Double.self) {
+                                    let index = Int(raw.rounded())
+                                    if let point = model.pointsByIndex[index] {
+                                        let isTrailingFullChartLabel = index == model.points.last?.index
+                                            && model.points.count == Layout.maxPoints
+                                        Self.axisLabel(
+                                            for: point,
+                                            windowMinutes: effectiveSelectedSeries?.history.windowMinutes ?? 0,
+                                            isTrailingFullChartLabel: isTrailingFullChartLabel)
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    .chartLegend(.hidden)
+                    .frame(height: Layout.chartHeight)
+                    .accessibilityLabel(L("Plan utilization chart"))
+                    .accessibilityValue(
+                        model.points.isEmpty
+                            ? L("No data")
+                            : String(format: L("%d utilization samples"), model.points.count))
+                    .chartOverlay { proxy in
+                        GeometryReader { geo in
+                            MouseLocationReader { location in
+                                self.updateSelection(location: location, model: model, proxy: proxy, geo: geo)
+                            }
+                            .frame(maxWidth: .infinity, maxHeight: .infinity)
+                            .contentShape(Rectangle())
+                        }
+                    }
+
+                Text(self.detailLine(model: model, windowMinutes: effectiveSelectedSeries?.history.windowMinutes ?? 0))
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+                    .lineLimit(1)
+                    .truncationMode(.tail)
+                    .frame(height: Layout.detailHeight, alignment: .leading)
+            }
+        }
+        .padding(.horizontal, 16)
+        .padding(.vertical, 10)
+        .frame(minWidth: self.width, maxWidth: .infinity, alignment: .topLeading)
+        .task(id: self.visibleSeries.map(\.id).joined(separator: ",")) {
+            guard let firstVisibleSeries = self.visibleSeries.first else { return }
+            guard !self.visibleSeries.contains(where: { $0.id == self.selectedSeriesID }) else { return }
+            self.selectedSeriesID = firstVisibleSeries.id
+            self.selectedPointID = nil
+        }
+    }
+
+    private nonisolated static func visibleSeries(
+        histories: [PlanUtilizationSeriesHistory],
+        provider: UsageProvider,
+        snapshot: UsageSnapshot?) -> [VisibleSeries]
+    {
+        let metadata = ProviderDescriptorRegistry.metadata[provider]
+        let allowedNames = self.visibleSeriesNames(provider: provider, snapshot: snapshot)
+        var historiesBySelection: [SeriesSelection: PlanUtilizationSeriesHistory] = [:]
+        for history in histories {
+            guard !history.entries.isEmpty else { continue }
+            guard history.windowMinutes > 0 else { continue }
+            guard allowedNames?.contains(history.name) ?? true else { continue }
+
+            let canonicalWindowMinutes = history.name.canonicalWindowMinutes(history.windowMinutes)
+            let selection = SeriesSelection(name: history.name, windowMinutes: canonicalWindowMinutes)
+            if let existingHistory = historiesBySelection[selection] {
+                historiesBySelection[selection] = PlanUtilizationSeriesHistory(
+                    name: history.name,
+                    windowMinutes: canonicalWindowMinutes,
+                    entries: Self.mergedEntries(existingHistory.entries + history.entries))
+            } else {
+                historiesBySelection[selection] = PlanUtilizationSeriesHistory(
+                    name: history.name,
+                    windowMinutes: canonicalWindowMinutes,
+                    entries: history.entries)
+            }
+        }
+
+        return historiesBySelection.values
+            .sorted { lhs, rhs in
+                let lhsOrder = self.seriesSortOrder(lhs.name)
+                let rhsOrder = self.seriesSortOrder(rhs.name)
+                if lhsOrder != rhsOrder {
+                    return lhsOrder < rhsOrder
+                }
+                if lhs.windowMinutes != rhs.windowMinutes {
+                    return lhs.windowMinutes < rhs.windowMinutes
+                }
+                return lhs.name.rawValue < rhs.name.rawValue
+            }
+            .map { history in
+                VisibleSeries(
+                    selection: SeriesSelection(name: history.name, windowMinutes: history.windowMinutes),
+                    title: self.seriesTitle(name: history.name, metadata: metadata),
+                    history: history)
+            }
+    }
+
+    nonisolated static func mergedEntries(
+        _ entries: [PlanUtilizationHistoryEntry]) -> [PlanUtilizationHistoryEntry]
+    {
+        var seen: Set<PlanUtilizationHistoryEntry> = []
+        return entries.filter { entry in
+            seen.insert(entry).inserted
+        }
+    }
+
+    private nonisolated static func visibleSeriesNames(
+        provider: UsageProvider,
+        snapshot: UsageSnapshot?) -> Set<PlanUtilizationSeriesName>?
+    {
+        guard let snapshot else { return nil }
+
+        var names: Set<PlanUtilizationSeriesName> = []
+        switch provider {
+        case .codex:
+            if snapshot.primary != nil { names.insert(.session) }
+            if snapshot.secondary != nil { names.insert(.weekly) }
+        case .claude:
+            if snapshot.primary != nil { names.insert(.session) }
+            if snapshot.secondary != nil { names.insert(.weekly) }
+            if snapshot.tertiary != nil,
+               ProviderDescriptorRegistry.metadata[provider]?.supportsOpus == true
+            {
+                names.insert(.opus)
+            }
+        default:
+            let windows = [snapshot.primary, snapshot.secondary, snapshot.tertiary].compactMap(\.self)
+                + (snapshot.extraRateWindows?.filter(\.usageKnown).map(\.window) ?? [])
+            guard windows.contains(where: { $0.windowMinutes == 7 * 24 * 60 }) else { return nil }
+            names.insert(.weekly)
+        }
+
+        return names
+    }
+
+    private nonisolated static func makeModel(
+        history: PlanUtilizationSeriesHistory?,
+        provider: UsageProvider,
+        referenceDate: Date) -> Model
+    {
+        guard let history else {
+            return self.emptyModel(provider: provider)
+        }
+
+        var points = self.seriesPoints(history: history, referenceDate: referenceDate)
+        if points.count > Layout.maxPoints {
+            points = Array(points.suffix(Layout.maxPoints))
+        }
+
+        points = points.enumerated().map { offset, point in
+            Point(
+                id: point.id,
+                index: offset,
+                date: point.date,
+                usedPercent: point.usedPercent,
+                isObserved: point.isObserved)
+        }
+
+        let pointsByID = Dictionary(uniqueKeysWithValues: points.map { ($0.id, $0) })
+        let pointsByIndex = Dictionary(uniqueKeysWithValues: points.map { ($0.index, $0) })
+        let color = ProviderDescriptorRegistry.descriptor(for: provider).branding.color
+        let barColor = Color(red: color.red, green: color.green, blue: color.blue)
+        let trackColor = MenuHighlightStyle.progressTrack(false)
+
+        return Model(
+            points: points,
+            axisIndexes: self.axisIndexes(points: points, windowMinutes: history.windowMinutes),
+            xDomain: self.xDomain(points: points),
+            pointsByID: pointsByID,
+            pointsByIndex: pointsByIndex,
+            barColor: barColor,
+            trackColor: trackColor)
+    }
+
+    private nonisolated static func emptyModel(provider: UsageProvider) -> Model {
+        let color = ProviderDescriptorRegistry.descriptor(for: provider).branding.color
+        let barColor = Color(red: color.red, green: color.green, blue: color.blue)
+        let trackColor = MenuHighlightStyle.progressTrack(false)
+        return Model(
+            points: [],
+            axisIndexes: [],
+            xDomain: nil,
+            pointsByID: [:],
+            pointsByIndex: [:],
+            barColor: barColor,
+            trackColor: trackColor)
+    }
+
+    private nonisolated static func seriesPoints(
+        history: PlanUtilizationSeriesHistory,
+        referenceDate: Date) -> [Point]
+    {
+        guard history.windowMinutes > 0 else { return [] }
+        let windowInterval = Double(history.windowMinutes) * 60
+        let resetBoundaryLattice = self.resetBoundaryLattice(
+            entries: history.entries,
+            windowMinutes: history.windowMinutes)
+        var strongestObservedPointByPeriod: [Date: EntryPointAccumulator] = [:]
+
+        for entry in history.entries {
+            let candidate = self.observedPointCandidate(
+                for: entry,
+                windowMinutes: history.windowMinutes,
+                resetBoundaryLattice: resetBoundaryLattice)
+
+            if let existing = strongestObservedPointByPeriod[candidate.effectiveBoundaryDate],
+               !self.shouldPreferObservedPoint(candidate, over: existing)
+            {
+                continue
+            }
+            strongestObservedPointByPeriod[candidate.effectiveBoundaryDate] = candidate
+        }
+
+        guard !strongestObservedPointByPeriod.isEmpty else { return [] }
+
+        let sortedPeriodBoundaryDates = strongestObservedPointByPeriod.keys.sorted()
+        var points: [Point] = []
+        var previousPeriodBoundaryDate: Date?
+
+        for periodBoundaryDate in sortedPeriodBoundaryDates {
+            if let previousPeriodBoundaryDate {
+                var cursor = previousPeriodBoundaryDate.addingTimeInterval(windowInterval)
+                while cursor < periodBoundaryDate {
+                    points.append(Point(
+                        id: cursor,
+                        index: 0,
+                        date: cursor,
+                        usedPercent: 0,
+                        isObserved: false))
+                    cursor = cursor.addingTimeInterval(windowInterval)
+                }
+            }
+
+            if let bucket = strongestObservedPointByPeriod[periodBoundaryDate] {
+                points.append(Point(
+                    id: bucket.effectiveBoundaryDate,
+                    index: 0,
+                    date: bucket.displayBoundaryDate,
+                    usedPercent: bucket.usedPercent,
+                    isObserved: true))
+            }
+            previousPeriodBoundaryDate = periodBoundaryDate
+        }
+
+        if let lastObservedPeriodBoundaryDate = sortedPeriodBoundaryDates.last {
+            let currentPeriodBoundaryDate = self.currentPeriodBoundaryDate(
+                for: referenceDate,
+                windowMinutes: history.windowMinutes,
+                resetBoundaryLattice: resetBoundaryLattice)
+
+            if currentPeriodBoundaryDate > lastObservedPeriodBoundaryDate {
+                var cursor = lastObservedPeriodBoundaryDate.addingTimeInterval(windowInterval)
+                while cursor <= currentPeriodBoundaryDate {
+                    points.append(Point(
+                        id: cursor,
+                        index: 0,
+                        date: cursor,
+                        usedPercent: 0,
+                        isObserved: false))
+                    cursor = cursor.addingTimeInterval(windowInterval)
+                }
+            }
+        }
+
+        return points
+    }
+
+    private nonisolated static func observedPointCandidate(
+        for entry: PlanUtilizationHistoryEntry,
+        windowMinutes: Int,
+        resetBoundaryLattice: ResetBoundaryLattice?) -> EntryPointAccumulator
+    {
+        let rawResetBoundaryDate = entry.resetsAt.map(self.normalizedBoundaryDate)
+        let effectiveBoundaryDate = self.effectivePeriodBoundaryDate(
+            for: entry,
+            windowMinutes: windowMinutes,
+            rawResetBoundaryDate: rawResetBoundaryDate,
+            resetBoundaryLattice: resetBoundaryLattice)
+        return EntryPointAccumulator(
+            effectiveBoundaryDate: effectiveBoundaryDate,
+            displayBoundaryDate: rawResetBoundaryDate ?? effectiveBoundaryDate,
+            observedAt: entry.capturedAt,
+            usedPercent: max(0, min(100, entry.usedPercent)),
+            hasObservedResetBoundary: rawResetBoundaryDate != nil)
+    }
+
+    private nonisolated static func resetBoundaryLattice(
+        entries: [PlanUtilizationHistoryEntry],
+        windowMinutes: Int) -> ResetBoundaryLattice?
+    {
+        guard let latestObservedResetBoundaryDate = entries
+            .compactMap(\.resetsAt)
+            .map(self.normalizedBoundaryDate)
+            .max()
+        else {
+            return nil
+        }
+        return ResetBoundaryLattice(
+            referenceBoundaryDate: latestObservedResetBoundaryDate,
+            windowInterval: Double(windowMinutes) * 60)
+    }
+
+    private nonisolated static func normalizedBoundaryDate(_ date: Date) -> Date {
+        Date(timeIntervalSince1970: floor(date.timeIntervalSince1970))
+    }
+
+    private nonisolated static func effectivePeriodBoundaryDate(
+        for entry: PlanUtilizationHistoryEntry,
+        windowMinutes: Int,
+        rawResetBoundaryDate: Date?,
+        resetBoundaryLattice: ResetBoundaryLattice?) -> Date
+    {
+        if let rawResetBoundaryDate {
+            if let resetBoundaryLattice {
+                return self.closestPeriodBoundaryDate(
+                    to: rawResetBoundaryDate,
+                    resetBoundaryLattice: resetBoundaryLattice)
+            }
+            return rawResetBoundaryDate
+        }
+        if let resetBoundaryLattice {
+            return self.periodBoundaryDate(
+                containing: entry.capturedAt,
+                resetBoundaryLattice: resetBoundaryLattice)
+        }
+        return self.syntheticBoundaryDate(for: entry.capturedAt, windowMinutes: windowMinutes)
+    }
+
+    private nonisolated static func shouldPreferObservedPoint(
+        _ candidate: EntryPointAccumulator,
+        over existing: EntryPointAccumulator) -> Bool
+    {
+        if candidate.usedPercent != existing.usedPercent {
+            return candidate.usedPercent > existing.usedPercent
+        }
+        if candidate.hasObservedResetBoundary != existing.hasObservedResetBoundary {
+            return candidate.hasObservedResetBoundary
+        }
+        if candidate.displayBoundaryDate != existing.displayBoundaryDate {
+            return candidate.displayBoundaryDate > existing.displayBoundaryDate
+        }
+        return candidate.observedAt >= existing.observedAt
+    }
+
+    private nonisolated static func currentPeriodBoundaryDate(
+        for referenceDate: Date,
+        windowMinutes: Int,
+        resetBoundaryLattice: ResetBoundaryLattice?) -> Date
+    {
+        if let resetBoundaryLattice {
+            return self.periodBoundaryDate(
+                containing: referenceDate,
+                resetBoundaryLattice: resetBoundaryLattice)
+        }
+        return self.syntheticBoundaryDate(for: referenceDate, windowMinutes: windowMinutes)
+    }
+
+    private nonisolated static func closestPeriodBoundaryDate(
+        to rawBoundaryDate: Date,
+        resetBoundaryLattice: ResetBoundaryLattice) -> Date
+    {
+        let offset = rawBoundaryDate.timeIntervalSince(resetBoundaryLattice.referenceBoundaryDate)
+        let periodOffset = (offset / resetBoundaryLattice.windowInterval).rounded()
+        return resetBoundaryLattice.referenceBoundaryDate
+            .addingTimeInterval(periodOffset * resetBoundaryLattice.windowInterval)
+    }
+
+    private nonisolated static func periodBoundaryDate(
+        containing capturedAt: Date,
+        resetBoundaryLattice: ResetBoundaryLattice) -> Date
+    {
+        let offset = capturedAt.timeIntervalSince(resetBoundaryLattice.referenceBoundaryDate)
+        let periodOffset = ceil(offset / resetBoundaryLattice.windowInterval)
+        return resetBoundaryLattice.referenceBoundaryDate
+            .addingTimeInterval(periodOffset * resetBoundaryLattice.windowInterval)
+    }
+
+    private nonisolated static func syntheticBoundaryDate(for date: Date, windowMinutes: Int) -> Date {
+        let bucketSeconds = Double(windowMinutes) * 60
+        let bucketIndex = floor(date.timeIntervalSince1970 / bucketSeconds)
+        return Date(timeIntervalSince1970: (bucketIndex + 1) * bucketSeconds)
+    }
+
+    private nonisolated static func xDomain(points: [Point]) -> ClosedRange<Double>? {
+        guard !points.isEmpty else { return nil }
+        return -0.5...(Double(Layout.maxPoints) - 0.5)
+    }
+
+    private nonisolated static func axisIndexes(points: [Point], windowMinutes: Int) -> [Double] {
+        let candidateIndexes = self.axisCandidateIndexes(points: points, windowMinutes: windowMinutes)
+        return self.proportionalAxisIndexes(points: points, candidateIndexes: candidateIndexes)
+    }
+
+    private nonisolated static func axisCandidateIndexes(points: [Point], windowMinutes: Int) -> [Int] {
+        if windowMinutes <= 300 {
+            return self.sessionAxisCandidateIndexes(points: points)
+        }
+        return points.map(\.index)
+    }
+
+    private nonisolated static func sessionAxisCandidateIndexes(points: [Point]) -> [Int] {
+        guard let firstPoint = points.first else { return [] }
+        let calendar = Calendar.current
+        var previousPoint = firstPoint
+        var rawIndexes: [Int] = [firstPoint.index]
+
+        for point in points.dropFirst() {
+            if !calendar.isDate(point.date, inSameDayAs: previousPoint.date) {
+                rawIndexes.append(point.index)
+            }
+            previousPoint = point
+        }
+
+        return rawIndexes
+    }
+
+    private nonisolated static func proportionalAxisIndexes(points: [Point], candidateIndexes: [Int]) -> [Double] {
+        guard !points.isEmpty, !candidateIndexes.isEmpty else { return [] }
+
+        let occupiedFraction = Double(points.count) / Double(Layout.maxPoints)
+        let proportionalBudget = Int(ceil(Double(Layout.maxAxisLabels) * occupiedFraction))
+        let labelBudget = max(1, min(Layout.maxAxisLabels, proportionalBudget, candidateIndexes.count))
+
+        if labelBudget == 1 {
+            return [Double(candidateIndexes[0])]
+        }
+
+        let step = Double(candidateIndexes.count - 1) / Double(labelBudget - 1)
+        var selectedIndexes = (0..<labelBudget).map { position in
+            let candidateOffset = Int((Double(position) * step).rounded())
+            return candidateIndexes[candidateOffset]
+        }
+        selectedIndexes = Array(NSOrderedSet(array: selectedIndexes)) as? [Int] ?? selectedIndexes
+
+        let trailingLabelCutoff = points.first!.index + Int(floor(Double(points.count) * 0.8))
+        if selectedIndexes.count > 1,
+           let lastSelectedIndex = selectedIndexes.last,
+           lastSelectedIndex >= trailingLabelCutoff
+        {
+            selectedIndexes.removeLast()
+        }
+
+        if points.count == Layout.maxPoints,
+           let lastVisibleIndex = points.last?.index,
+           !selectedIndexes.contains(lastVisibleIndex)
+        {
+            selectedIndexes.append(lastVisibleIndex)
+        }
+
+        let deduplicated = Array(NSOrderedSet(array: selectedIndexes)) as? [Int] ?? selectedIndexes
+        return deduplicated.map(Double.init)
+    }
+
+    @ViewBuilder
+    private static func axisLabel(
+        for point: Point,
+        windowMinutes: Int,
+        isTrailingFullChartLabel: Bool) -> some View
+    {
+        let label = Text(point.date.formatted(self.axisFormat(windowMinutes: windowMinutes)))
+            .font(.caption2)
+            .foregroundStyle(Color(nsColor: .tertiaryLabelColor))
+
+        if isTrailingFullChartLabel {
+            label
+                .frame(width: 48, alignment: .trailing)
+                .offset(x: -24)
+        } else {
+            label
+        }
+    }
+
+    private nonisolated static func axisFormat(windowMinutes: Int) -> Date.FormatStyle {
+        if windowMinutes <= 300 {
+            return .dateTime.month(.abbreviated).day()
+        }
+        return .dateTime.month(.abbreviated).day()
+    }
+
+    private nonisolated static func seriesTitle(
+        name: PlanUtilizationSeriesName,
+        metadata: ProviderMetadata?) -> String
+    {
+        switch name {
+        case .session:
+            L(metadata?.sessionLabel ?? "Session")
+        case .weekly:
+            L(metadata?.weeklyLabel ?? "Weekly")
+        case .opus:
+            metadata?.opusLabel ?? "Opus"
+        default:
+            self.fallbackTitle(for: name.rawValue)
+        }
+    }
+
+    private nonisolated static func fallbackTitle(for rawValue: String) -> String {
+        let words = rawValue
+            .replacingOccurrences(of: "([a-z0-9])([A-Z])", with: "$1 $2", options: .regularExpression)
+            .split(separator: " ")
+        return words.map { $0.prefix(1).uppercased() + $0.dropFirst() }.joined(separator: " ")
+    }
+
+    private nonisolated static func seriesSortOrder(_ name: PlanUtilizationSeriesName) -> Int {
+        switch name {
+        case .session:
+            0
+        case .weekly:
+            1
+        case .opus:
+            2
+        default:
+            100
+        }
+    }
+
+    private nonisolated static func emptyStateText(title: String?) -> String {
+        if let title {
+            return String(format: L("No %@ utilization data yet."), title.lowercased())
+        }
+        return L("No utilization data yet.")
+    }
+
+    #if DEBUG
+    struct ModelSnapshot: Equatable {
+        let pointCount: Int
+        let axisIndexes: [Double]
+        let xDomain: ClosedRange<Double>?
+        let selectedSeries: String?
+        let visibleSeries: [String]
+        let usedPercents: [Double]
+        let pointDates: [String]
+    }
+
+    nonisolated static func _modelSnapshotForTesting(
+        selectedSeriesRawValue: String? = nil,
+        histories: [PlanUtilizationSeriesHistory],
+        provider: UsageProvider,
+        snapshot: UsageSnapshot? = nil,
+        referenceDate: Date? = nil) -> ModelSnapshot
+    {
+        let visibleSeries = self.visibleSeries(histories: histories, provider: provider, snapshot: snapshot)
+        let selectedSeries = visibleSeries.first(where: { $0.id == selectedSeriesRawValue }) ?? visibleSeries.first
+        let model = self.makeModel(
+            history: selectedSeries?.history,
+            provider: provider,
+            referenceDate: referenceDate ?? histories.flatMap(\.entries).map(\.capturedAt).max() ?? Date())
+        return ModelSnapshot(
+            pointCount: model.points.count,
+            axisIndexes: model.axisIndexes,
+            xDomain: model.xDomain,
+            selectedSeries: selectedSeries?.id,
+            visibleSeries: visibleSeries.map(\.id),
+            usedPercents: model.points.map(\.usedPercent),
+            pointDates: model.points.map { point in
+                let formatter = DateFormatter()
+                formatter.locale = Locale(identifier: "en_US_POSIX")
+                formatter.timeZone = TimeZone.current
+                formatter.dateFormat = "yyyy-MM-dd HH:mm"
+                return formatter.string(from: point.date)
+            })
+    }
+
+    nonisolated static func _detailLineForTesting(
+        selectedSeriesRawValue: String? = nil,
+        histories: [PlanUtilizationSeriesHistory],
+        provider: UsageProvider,
+        snapshot: UsageSnapshot? = nil,
+        referenceDate: Date? = nil) -> String
+    {
+        let visibleSeries = self.visibleSeries(histories: histories, provider: provider, snapshot: snapshot)
+        let selectedSeries = visibleSeries.first(where: { $0.id == selectedSeriesRawValue }) ?? visibleSeries.first
+        let model = self.makeModel(
+            history: selectedSeries?.history,
+            provider: provider,
+            referenceDate: referenceDate ?? histories.flatMap(\.entries).map(\.capturedAt).max() ?? Date())
+        return self.detailLine(point: model.points.last, windowMinutes: selectedSeries?.history.windowMinutes ?? 0)
+    }
+
+    nonisolated static func _emptyStateTextForTesting(title: String?) -> String {
+        self.emptyStateText(title: title)
+    }
+    #endif
+
+    private func xValue(for index: Int) -> PlottableValue<Double> {
+        .value(L("Series"), Double(index))
+    }
+
+    @ViewBuilder
+    private func utilizationChart(model: Model) -> some View {
+        if let xDomain = model.xDomain {
+            Chart {
+                self.utilizationChartContent(model: model)
+            }
+            .chartXScale(domain: xDomain)
+        } else {
+            Chart {
+                self.utilizationChartContent(model: model)
+            }
+        }
+    }
+
+    @ChartContentBuilder
+    private func utilizationChartContent(model: Model) -> some ChartContent {
+        ForEach(model.points) { point in
+            BarMark(
+                x: self.xValue(for: point.index),
+                yStart: .value(L("Capacity Start"), 0),
+                yEnd: .value(L("Capacity End"), 100),
+                width: .fixed(Layout.barWidth))
+                .foregroundStyle(model.trackColor)
+            BarMark(
+                x: self.xValue(for: point.index),
+                yStart: .value(L("Utilization Start"), 0),
+                yEnd: .value(L("Utilization End"), point.usedPercent),
+                width: .fixed(Layout.barWidth))
+                .foregroundStyle(model.barColor)
+        }
+        if let selected = self.selectedPoint(model: model) {
+            RuleMark(x: self.xValue(for: selected.index))
+                .foregroundStyle(Color(nsColor: .tertiaryLabelColor))
+                .lineStyle(StrokeStyle(lineWidth: 1, dash: [3, 3]))
+        }
+    }
+
+    private func selectedPoint(model: Model) -> Point? {
+        guard let selectedPointID else { return nil }
+        return model.pointsByID[selectedPointID]
+    }
+
+    private func detailLine(model: Model, windowMinutes: Int) -> String {
+        let activePoint = self.selectedPoint(model: model) ?? model.points.last
+        return Self.detailLine(point: activePoint, windowMinutes: windowMinutes)
+    }
+
+    private func updateSelection(
+        location: CGPoint?,
+        model: Model,
+        proxy: ChartProxy,
+        geo: GeometryProxy)
+    {
+        guard let location else {
+            if self.selectedPointID != nil { self.selectedPointID = nil }
+            return
+        }
+
+        guard let plotAnchor = proxy.plotFrame else { return }
+        let plotFrame = geo[plotAnchor]
+        guard plotFrame.contains(location) else {
+            if self.selectedPointID != nil { self.selectedPointID = nil }
+            return
+        }
+
+        let xInPlot = location.x - plotFrame.origin.x
+        guard let xValue: Double = proxy.value(atX: xInPlot) else { return }
+
+        var best: (id: Date, distance: Double)?
+        for point in model.points {
+            let distance = abs(Double(point.index) - xValue)
+            if let current = best {
+                if distance < current.distance {
+                    best = (point.id, distance)
+                }
+            } else {
+                best = (point.id, distance)
+            }
+        }
+
+        // Stay on the last selected bar when cursor is in the gap between bars; only switch
+        // selection when the cursor is over the bar's own visual body.
+        if let best, let bestPoint = model.pointsByID[best.id],
+           let barX = proxy.position(forX: Double(bestPoint.index))
+        {
+            guard ChartBarHoverSelection.accepts(
+                distanceFromBarCenter: abs(location.x - (plotFrame.origin.x + barX)),
+                barHalfWidth: Layout.barWidth / 2,
+                selectableCount: model.points.count)
+            else { return }
+        }
+
+        if self.selectedPointID != best?.id {
+            self.selectedPointID = best?.id
+        }
+    }
+}
+
+extension PlanUtilizationHistoryChartMenuView {
+    private nonisolated static func detailLine(point: Point?, windowMinutes: Int) -> String {
+        guard let point else {
+            return "-"
+        }
+
+        let dateLabel = self.detailDateLabel(for: point.date, windowMinutes: windowMinutes)
+
+        let used = max(0, min(100, point.usedPercent))
+        if !point.isObserved {
+            return "\(dateLabel): -"
+        }
+        let usedText = used.formatted(.number.precision(.fractionLength(0...1)))
+        return L("%@: %@%% used", dateLabel, usedText)
+    }
+
+    private nonisolated static func detailDateLabel(for date: Date, windowMinutes: Int) -> String {
+        let formatter = DateFormatter()
+        formatter.locale = codexBarLocalizedLocale()
+        formatter.timeZone = TimeZone.current
+        formatter.setLocalizedDateFormatFromTemplate("MMM d, h:mm a")
+        var rendered = formatter.string(from: date).replacingOccurrences(of: "\u{202F}", with: " ")
+        let amSymbol = formatter.amSymbol ?? ""
+        let pmSymbol = formatter.pmSymbol ?? ""
+        if !amSymbol.isEmpty {
+            rendered = rendered.replacingOccurrences(of: amSymbol, with: amSymbol.lowercased())
+        }
+        if !pmSymbol.isEmpty {
+            rendered = rendered.replacingOccurrences(of: pmSymbol, with: pmSymbol.lowercased())
+        }
+        return rendered
+    }
+}
diff --git a/Sources/CodexBar/PlanUtilizationHistoryStore.swift b/Sources/CodexBar/PlanUtilizationHistoryStore.swift
new file mode 100644
index 0000000000..e9843f309e
--- /dev/null
+++ b/Sources/CodexBar/PlanUtilizationHistoryStore.swift
@@ -0,0 +1,269 @@
+import CodexBarCore
+import Foundation
+
+struct PlanUtilizationSeriesName: RawRepresentable, Hashable, Codable, ExpressibleByStringLiteral {
+    let rawValue: String
+
+    init(rawValue: String) {
+        self.rawValue = rawValue
+    }
+
+    init(stringLiteral value: StringLiteralType) {
+        self.rawValue = value
+    }
+
+    static let session: Self = "session"
+    static let weekly: Self = "weekly"
+    static let opus: Self = "opus"
+
+    func canonicalWindowMinutes(_ windowMinutes: Int) -> Int {
+        switch self {
+        case .session where (295...305).contains(windowMinutes):
+            300
+        case .weekly where (10070...10090).contains(windowMinutes):
+            10080
+        default:
+            windowMinutes
+        }
+    }
+}
+
+struct PlanUtilizationHistoryEntry: Codable, Equatable, Hashable {
+    let capturedAt: Date
+    let usedPercent: Double
+    let resetsAt: Date?
+}
+
+struct PlanUtilizationSeriesHistory: Codable, Equatable {
+    let name: PlanUtilizationSeriesName
+    let windowMinutes: Int
+    let entries: [PlanUtilizationHistoryEntry]
+
+    init(name: PlanUtilizationSeriesName, windowMinutes: Int, entries: [PlanUtilizationHistoryEntry]) {
+        self.name = name
+        self.windowMinutes = windowMinutes
+        self.entries = entries.sorted { lhs, rhs in
+            if lhs.capturedAt != rhs.capturedAt {
+                return lhs.capturedAt < rhs.capturedAt
+            }
+            if lhs.usedPercent != rhs.usedPercent {
+                return lhs.usedPercent < rhs.usedPercent
+            }
+            let lhsReset = lhs.resetsAt?.timeIntervalSince1970 ?? Date.distantPast.timeIntervalSince1970
+            let rhsReset = rhs.resetsAt?.timeIntervalSince1970 ?? Date.distantPast.timeIntervalSince1970
+            return lhsReset < rhsReset
+        }
+    }
+
+    var latestCapturedAt: Date? {
+        self.entries.last?.capturedAt
+    }
+}
+
+struct PlanUtilizationHistoryBuckets: Equatable {
+    var preferredAccountKey: String?
+    var unscoped: [PlanUtilizationSeriesHistory] = []
+    var accounts: [String: [PlanUtilizationSeriesHistory]] = [:]
+
+    func histories(for accountKey: String?) -> [PlanUtilizationSeriesHistory] {
+        guard let accountKey, !accountKey.isEmpty else { return self.unscoped }
+        return self.accounts[accountKey] ?? []
+    }
+
+    mutating func setHistories(_ histories: [PlanUtilizationSeriesHistory], for accountKey: String?) {
+        let sorted = Self.sortedHistories(histories)
+        guard let accountKey, !accountKey.isEmpty else {
+            self.unscoped = sorted
+            return
+        }
+        if sorted.isEmpty {
+            self.accounts.removeValue(forKey: accountKey)
+        } else {
+            self.accounts[accountKey] = sorted
+        }
+    }
+
+    var isEmpty: Bool {
+        self.unscoped.isEmpty && self.accounts.values.allSatisfy(\.isEmpty)
+    }
+
+    private static func sortedHistories(_ histories: [PlanUtilizationSeriesHistory]) -> [PlanUtilizationSeriesHistory] {
+        histories.sorted { lhs, rhs in
+            if lhs.windowMinutes != rhs.windowMinutes {
+                return lhs.windowMinutes < rhs.windowMinutes
+            }
+            return lhs.name.rawValue < rhs.name.rawValue
+        }
+    }
+}
+
+private struct ProviderHistoryFile: Codable {
+    let preferredAccountKey: String?
+    let unscoped: [PlanUtilizationSeriesHistory]
+    let accounts: [String: [PlanUtilizationSeriesHistory]]
+}
+
+private struct ProviderHistoryDocument: Codable {
+    let version: Int
+    let preferredAccountKey: String?
+    let unscoped: [PlanUtilizationSeriesHistory]
+    let accounts: [String: [PlanUtilizationSeriesHistory]]
+}
+
+struct PlanUtilizationHistoryStore {
+    fileprivate static let providerSchemaVersion = 1
+
+    let directoryURL: URL?
+
+    init(directoryURL: URL? = Self.defaultDirectoryURL()) {
+        self.directoryURL = directoryURL
+    }
+
+    static func defaultAppSupport() -> Self {
+        Self()
+    }
+
+    func load() -> [UsageProvider: PlanUtilizationHistoryBuckets] {
+        self.loadProviderFiles()
+    }
+
+    func save(_ providers: [UsageProvider: PlanUtilizationHistoryBuckets]) {
+        guard let directoryURL = self.directoryURL else { return }
+        do {
+            try FileManager.default.createDirectory(
+                at: directoryURL,
+                withIntermediateDirectories: true)
+            let encoder = JSONEncoder()
+            encoder.dateEncodingStrategy = .iso8601
+            encoder.outputFormatting = [.sortedKeys]
+
+            for provider in UsageProvider.allCases {
+                let fileURL = self.providerFileURL(for: provider)
+                let buckets = providers[provider] ?? PlanUtilizationHistoryBuckets()
+                let unscoped = Self.sortedHistories(buckets.unscoped)
+                let accounts = Self.sortedAccounts(buckets.accounts)
+                guard !unscoped.isEmpty || !accounts.isEmpty else {
+                    try? FileManager.default.removeItem(at: fileURL)
+                    continue
+                }
+
+                let payload = ProviderHistoryDocument(
+                    version: Self.providerSchemaVersion,
+                    preferredAccountKey: buckets.preferredAccountKey,
+                    unscoped: unscoped,
+                    accounts: accounts)
+                let data = try encoder.encode(payload)
+                try data.write(to: fileURL, options: Data.WritingOptions.atomic)
+            }
+        } catch {
+            // Best-effort persistence only.
+        }
+    }
+
+    private func loadProviderFiles() -> [UsageProvider: PlanUtilizationHistoryBuckets] {
+        guard self.directoryURL != nil else { return [:] }
+
+        let decoder = JSONDecoder()
+        decoder.dateDecodingStrategy = .iso8601
+
+        var output: [UsageProvider: PlanUtilizationHistoryBuckets] = [:]
+
+        for provider in UsageProvider.allCases {
+            let fileURL = self.providerFileURL(for: provider)
+            guard FileManager.default.fileExists(atPath: fileURL.path) else { continue }
+            guard let data = try? Data(contentsOf: fileURL),
+                  let decoded = try? decoder.decode(ProviderHistoryDocument.self, from: data)
+            else {
+                continue
+            }
+
+            let history = ProviderHistoryFile(
+                preferredAccountKey: decoded.preferredAccountKey,
+                unscoped: decoded.unscoped,
+                accounts: decoded.accounts)
+            output[provider] = Self.decodeProvider(history)
+        }
+
+        return output
+    }
+
+    private static func decodeProviders(
+        _ providers: [String: ProviderHistoryFile]) -> [UsageProvider: PlanUtilizationHistoryBuckets]
+    {
+        var output: [UsageProvider: PlanUtilizationHistoryBuckets] = [:]
+        for (rawProvider, providerHistory) in providers {
+            guard let provider = UsageProvider(rawValue: rawProvider) else { continue }
+            output[provider] = Self.decodeProvider(providerHistory)
+        }
+        return output
+    }
+
+    private static func decodeProvider(_ providerHistory: ProviderHistoryFile) -> PlanUtilizationHistoryBuckets {
+        PlanUtilizationHistoryBuckets(
+            preferredAccountKey: providerHistory.preferredAccountKey,
+            unscoped: self.sortedHistories(providerHistory.unscoped),
+            accounts: Dictionary(
+                uniqueKeysWithValues: providerHistory.accounts.compactMap { accountKey, histories in
+                    let sorted = Self.sortedHistories(histories)
+                    guard !sorted.isEmpty else { return nil }
+                    return (accountKey, sorted)
+                }))
+    }
+
+    private static func sortedAccounts(
+        _ accounts: [String: [PlanUtilizationSeriesHistory]]) -> [String: [PlanUtilizationSeriesHistory]]
+    {
+        Dictionary(
+            uniqueKeysWithValues: accounts.compactMap { accountKey, histories in
+                let sorted = Self.sortedHistories(histories)
+                guard !sorted.isEmpty else { return nil }
+                return (accountKey, sorted)
+            })
+    }
+
+    private static func sortedHistories(_ histories: [PlanUtilizationSeriesHistory]) -> [PlanUtilizationSeriesHistory] {
+        self.sanitizedHistories(histories).sorted { lhs, rhs in
+            if lhs.windowMinutes != rhs.windowMinutes {
+                return lhs.windowMinutes < rhs.windowMinutes
+            }
+            return lhs.name.rawValue < rhs.name.rawValue
+        }
+    }
+
+    private static func sanitizedHistories(_ histories: [PlanUtilizationSeriesHistory])
+    -> [PlanUtilizationSeriesHistory] {
+        histories.filter { history in
+            history.windowMinutes > 0 && !history.entries.isEmpty
+        }
+    }
+
+    private static func defaultDirectoryURL() -> URL? {
+        guard let root = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask).first else {
+            return nil
+        }
+        let dir = root.appendingPathComponent("com.steipete.codexbar", isDirectory: true)
+        return dir.appendingPathComponent("history", isDirectory: true)
+    }
+
+    private func providerFileURL(for provider: UsageProvider) -> URL {
+        let directoryURL = self.directoryURL ?? URL(fileURLWithPath: "/dev/null", isDirectory: true)
+        return directoryURL.appendingPathComponent("\(provider.rawValue).json", isDirectory: false)
+    }
+}
+
+extension ProviderHistoryDocument {
+    init(from decoder: any Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        let version = try container.decode(Int.self, forKey: .version)
+        guard version == PlanUtilizationHistoryStore.providerSchemaVersion else {
+            throw DecodingError.dataCorruptedError(
+                forKey: .version,
+                in: container,
+                debugDescription: "Unsupported provider history schema version \(version)")
+        }
+        self.version = version
+        self.preferredAccountKey = try container.decodeIfPresent(String.self, forKey: .preferredAccountKey)
+        self.unscoped = try container.decode([PlanUtilizationSeriesHistory].self, forKey: .unscoped)
+        self.accounts = try container.decode([String: [PlanUtilizationSeriesHistory]].self, forKey: .accounts)
+    }
+}
diff --git a/Sources/CodexBar/PreferencesAboutPane.swift b/Sources/CodexBar/PreferencesAboutPane.swift
index 16e27189e6..31c3bbe438 100644
--- a/Sources/CodexBar/PreferencesAboutPane.swift
+++ b/Sources/CodexBar/PreferencesAboutPane.swift
@@ -51,14 +51,14 @@ struct AboutPane: View {
             VStack(spacing: 2) {
                 Text("CodexBar")
                     .font(.title3).bold()
-                Text("Version \(self.versionString)")
+                Text(String(format: L("version_format"), self.versionString))
                     .foregroundStyle(.secondary)
                 if let buildTimestamp {
-                    Text("Built \(buildTimestamp)")
+                    Text(String(format: L("built_format"), buildTimestamp))
                         .font(.footnote)
                         .foregroundStyle(.secondary)
                 }
-                Text("May your tokens never run out—keep agent limits in view.")
+                Text(L("about_tagline"))
                     .font(.footnote)
                     .foregroundStyle(.secondary)
             }
@@ -66,11 +66,11 @@ struct AboutPane: View {
             VStack(alignment: .center, spacing: 10) {
                 AboutLinkRow(
                     icon: "chevron.left.slash.chevron.right",
-                    title: "GitHub",
+                    title: L("link_github"),
                     url: "https://github.com/steipete/CodexBar")
-                AboutLinkRow(icon: "globe", title: "Website", url: "https://steipete.me")
-                AboutLinkRow(icon: "bird", title: "Twitter", url: "https://twitter.com/steipete")
-                AboutLinkRow(icon: "envelope", title: "Email", url: "mailto:peter@steipete.me")
+                AboutLinkRow(icon: "globe", title: L("link_website"), url: "https://steipete.me")
+                AboutLinkRow(icon: "bird", title: L("link_twitter"), url: "https://twitter.com/steipete")
+                AboutLinkRow(icon: "envelope", title: L("link_email"), url: "mailto:peter@steipete.me")
             }
             .padding(.top, 8)
             .frame(maxWidth: .infinity)
@@ -80,12 +80,12 @@ struct AboutPane: View {
 
             if self.updater.isAvailable {
                 VStack(spacing: 10) {
-                    Toggle("Check for updates automatically", isOn: self.$autoUpdateEnabled)
+                    Toggle(L("check_updates_auto"), isOn: self.$autoUpdateEnabled)
                         .toggleStyle(.checkbox)
                         .frame(maxWidth: .infinity, alignment: .center)
                     VStack(spacing: 6) {
                         HStack(spacing: 12) {
-                            Text("Update Channel")
+                            Text(L("update_channel"))
                             Spacer()
                             Picker("", selection: self.updateChannelBinding) {
                                 ForEach(UpdateChannel.allCases) { channel in
@@ -102,14 +102,14 @@ struct AboutPane: View {
                             .multilineTextAlignment(.center)
                             .frame(maxWidth: 280)
                     }
-                    Button("Check for Updates…") { self.updater.checkForUpdates(nil) }
+                    Button(L("check_for_updates")) { self.updater.checkForUpdates(nil) }
                 }
             } else {
-                Text(self.updater.unavailableReason ?? "Updates unavailable in this build.")
+                Text(self.updater.unavailableReason ?? L("updates_unavailable"))
                     .foregroundStyle(.secondary)
             }
 
-            Text("© 2025 Peter Steinberger. MIT License.")
+            Text(L("copyright"))
                 .font(.footnote)
                 .foregroundStyle(.secondary)
                 .padding(.top, 4)
diff --git a/Sources/CodexBar/PreferencesAdvancedPane.swift b/Sources/CodexBar/PreferencesAdvancedPane.swift
index 1db4897f26..1545eba847 100644
--- a/Sources/CodexBar/PreferencesAdvancedPane.swift
+++ b/Sources/CodexBar/PreferencesAdvancedPane.swift
@@ -11,17 +11,17 @@ struct AdvancedPane: View {
         ScrollView(.vertical, showsIndicators: true) {
             VStack(alignment: .leading, spacing: 16) {
                 SettingsSection(contentSpacing: 8) {
-                    Text("Keyboard shortcut")
+                    Text(L("section_keyboard_shortcut"))
                         .font(.caption)
                         .foregroundStyle(.secondary)
                         .textCase(.uppercase)
                     HStack(alignment: .center, spacing: 12) {
-                        Text("Open menu")
+                        Text(L("open_menu_shortcut_title"))
                             .font(.body)
                         Spacer()
-                        KeyboardShortcuts.Recorder(for: .openMenu)
+                        OpenMenuShortcutRecorder()
                     }
-                    Text("Trigger the menu bar menu from anywhere.")
+                    Text(L("open_menu_shortcut_subtitle"))
                         .font(.footnote)
                         .foregroundStyle(.tertiary)
                 }
@@ -36,7 +36,7 @@ struct AdvancedPane: View {
                             if self.isInstallingCLI {
                                 ProgressView().controlSize(.small)
                             } else {
-                                Text("Install CLI")
+                                Text(L("install_cli"))
                             }
                         }
                         .disabled(self.isInstallingCLI)
@@ -48,7 +48,7 @@ struct AdvancedPane: View {
                                 .lineLimit(2)
                         }
                     }
-                    Text("Symlink CodexBarCLI to /usr/local/bin and /opt/homebrew/bin as codexbar.")
+                    Text(L("install_cli_subtitle"))
                         .font(.footnote)
                         .foregroundStyle(.tertiary)
                 }
@@ -57,37 +57,43 @@ struct AdvancedPane: View {
 
                 SettingsSection(contentSpacing: 10) {
                     PreferenceToggleRow(
-                        title: "Show Debug Settings",
-                        subtitle: "Expose troubleshooting tools in the Debug tab.",
+                        title: L("show_debug_settings_title"),
+                        subtitle: L("show_debug_settings_subtitle"),
                         binding: self.$settings.debugMenuEnabled)
                     PreferenceToggleRow(
-                        title: "Surprise me",
-                        subtitle: "Check if you like your agents having some fun up there.",
+                        title: L("surprise_me_title"),
+                        subtitle: L("surprise_me_subtitle"),
                         binding: self.$settings.randomBlinkEnabled)
+                    PreferenceToggleRow(
+                        title: L("weekly_limit_confetti_title"),
+                        subtitle: L("weekly_limit_confetti_subtitle"),
+                        binding: self.$settings.confettiOnWeeklyLimitResetsEnabled)
                 }
 
                 Divider()
 
                 SettingsSection(contentSpacing: 10) {
                     PreferenceToggleRow(
-                        title: "Hide personal information",
-                        subtitle: "Obscure email addresses in the menu bar and menu UI.",
+                        title: L("hide_personal_info_title"),
+                        subtitle: L("hide_personal_info_subtitle"),
                         binding: self.$settings.hidePersonalInfo)
+                    PreferenceToggleRow(
+                        title: L("show_provider_storage_usage_title"),
+                        subtitle: L("show_provider_storage_usage_subtitle"),
+                        binding: self.$settings.providerStorageFootprintsEnabled)
                 }
 
                 Divider()
 
                 SettingsSection(
-                    title: "Keychain access",
-                    caption: """
-                    Disable all Keychain reads and writes. Browser cookie import is unavailable; paste Cookie \
-                    headers manually in Providers.
-                    """) {
-                        PreferenceToggleRow(
-                            title: "Disable Keychain access",
-                            subtitle: "Prevents any Keychain access while enabled.",
-                            binding: self.$settings.debugDisableKeychainAccess)
-                    }
+                    title: L("section_keychain_access"),
+                    caption: L("keychain_access_caption"))
+                {
+                    PreferenceToggleRow(
+                        title: L("disable_keychain_access_title"),
+                        subtitle: L("disable_keychain_access_subtitle"),
+                        binding: self.$settings.debugDisableKeychainAccess)
+                }
             }
             .frame(maxWidth: .infinity, alignment: .leading)
             .padding(.horizontal, 20)
@@ -96,6 +102,32 @@ struct AdvancedPane: View {
     }
 }
 
+@MainActor
+struct OpenMenuShortcutRecorder: NSViewRepresentable {
+    static let preferredWidth: CGFloat = 170
+
+    func makeNSView(context: Context) -> KeyboardShortcuts.RecorderCocoa {
+        KeyboardShortcuts.RecorderCocoa(for: .openMenu)
+    }
+
+    func updateNSView(_ nsView: KeyboardShortcuts.RecorderCocoa, context: Context) {
+        nsView.shortcutName = .openMenu
+    }
+
+    func sizeThatFits(
+        _: ProposedViewSize,
+        nsView: KeyboardShortcuts.RecorderCocoa,
+        context: Context)
+        -> CGSize?
+    {
+        Self.fittedSize(intrinsicHeight: nsView.intrinsicContentSize.height)
+    }
+
+    static func fittedSize(intrinsicHeight: CGFloat) -> CGSize {
+        CGSize(width: self.preferredWidth, height: intrinsicHeight)
+    }
+}
+
 extension AdvancedPane {
     private func installCLI() async {
         if self.isInstallingCLI { return }
@@ -105,7 +137,7 @@ extension AdvancedPane {
         let helperURL = Bundle.main.bundleURL.appendingPathComponent("Contents/Helpers/CodexBarCLI")
         let fm = FileManager.default
         guard fm.fileExists(atPath: helperURL.path) else {
-            self.cliStatus = "CodexBarCLI not found in app bundle."
+            self.cliStatus = L("cli_not_found")
             return
         }
 
@@ -141,7 +173,7 @@ extension AdvancedPane {
         }
 
         self.cliStatus = results.isEmpty
-            ? "No writable bin dirs found."
+            ? L("no_writable_bin_dirs")
             : results.joined(separator: " · ")
     }
 
diff --git a/Sources/CodexBar/PreferencesCodexAccountsSection.swift b/Sources/CodexBar/PreferencesCodexAccountsSection.swift
new file mode 100644
index 0000000000..f42be52718
--- /dev/null
+++ b/Sources/CodexBar/PreferencesCodexAccountsSection.swift
@@ -0,0 +1,331 @@
+import Foundation
+import SwiftUI
+
+protocol CodexAmbientLoginRunning: Sendable {
+    func run(timeout: TimeInterval) async -> CodexLoginRunner.Result
+}
+
+struct DefaultCodexAmbientLoginRunner: CodexAmbientLoginRunning {
+    func run(timeout: TimeInterval) async -> CodexLoginRunner.Result {
+        await CodexLoginRunner.run(timeout: timeout)
+    }
+}
+
+struct CodexAccountsSectionNotice: Equatable {
+    enum Tone: Equatable {
+        case secondary
+        case warning
+    }
+
+    let text: String
+    let tone: Tone
+}
+
+struct CodexAccountsSectionState: Equatable {
+    let visibleAccounts: [CodexVisibleAccount]
+    let activeVisibleAccountID: String?
+    let liveVisibleAccountID: String?
+    let hasUnreadableManagedAccountStore: Bool
+    let isAuthenticatingManagedAccount: Bool
+    let authenticatingManagedAccountID: UUID?
+    let isRemovingManagedAccount: Bool
+    let isAuthenticatingLiveAccount: Bool
+    let isPromotingSystemAccount: Bool
+    let notice: CodexAccountsSectionNotice?
+
+    var showsActivePicker: Bool {
+        self.visibleAccounts.count > 1
+    }
+
+    var singleVisibleAccount: CodexVisibleAccount? {
+        self.visibleAccounts.count == 1 ? self.visibleAccounts.first : nil
+    }
+
+    var systemVisibleAccount: CodexVisibleAccount? {
+        guard let liveVisibleAccountID else { return nil }
+        return self.visibleAccounts.first { $0.id == liveVisibleAccountID }
+    }
+
+    var showsSystemPicker: Bool {
+        self.visibleAccounts.count > 1 || (self.liveVisibleAccountID == nil && !self.visibleAccounts.isEmpty)
+    }
+
+    var systemDisplayName: String {
+        self.systemVisibleAccount?.displayName ?? L("No system account")
+    }
+
+    var canAddAccount: Bool {
+        !self.hasUnreadableManagedAccountStore &&
+            !self.isAuthenticatingManagedAccount &&
+            !self.isRemovingManagedAccount &&
+            !self.isAuthenticatingLiveAccount &&
+            !self.isPromotingSystemAccount
+    }
+
+    var addAccountTitle: String {
+        if self.isAuthenticatingManagedAccount, self.authenticatingManagedAccountID == nil {
+            return L("Adding Account…")
+        }
+        return L("Add Account")
+    }
+
+    func showsLiveBadge(for account: CodexVisibleAccount) -> Bool {
+        account.isLive
+    }
+
+    var isSystemSelectionDisabled: Bool {
+        self.hasUnreadableManagedAccountStore ||
+            self.isAuthenticatingManagedAccount ||
+            self.isRemovingManagedAccount ||
+            self.isAuthenticatingLiveAccount ||
+            self.isPromotingSystemAccount
+    }
+
+    func canPromoteToSystem(_ account: CodexVisibleAccount) -> Bool {
+        guard self.isSystemSelectionDisabled == false else { return false }
+        guard account.id != self.liveVisibleAccountID else { return false }
+        return account.storedAccountID != nil
+    }
+
+    func canReauthenticate(_ account: CodexVisibleAccount) -> Bool {
+        guard account.canReauthenticate else { return false }
+        guard self.isAuthenticatingManagedAccount == false else { return false }
+        guard self.isRemovingManagedAccount == false else { return false }
+        guard self.isAuthenticatingLiveAccount == false else { return false }
+        guard self.isPromotingSystemAccount == false else { return false }
+        if account.storedAccountID != nil {
+            return self.hasUnreadableManagedAccountStore == false
+        }
+        return true
+    }
+
+    func canRemove(_ account: CodexVisibleAccount) -> Bool {
+        guard account.canRemove else { return false }
+        guard self.isAuthenticatingManagedAccount == false else { return false }
+        guard self.isRemovingManagedAccount == false else { return false }
+        guard self.isAuthenticatingLiveAccount == false else { return false }
+        guard self.isPromotingSystemAccount == false else { return false }
+        return self.hasUnreadableManagedAccountStore == false
+    }
+
+    func reauthenticateTitle(for account: CodexVisibleAccount) -> String {
+        if let accountID = account.storedAccountID,
+           self.isAuthenticatingManagedAccount,
+           self.authenticatingManagedAccountID == accountID
+        {
+            return L("Re-authenticating…")
+        }
+        if account.storedAccountID == nil, self.isAuthenticatingLiveAccount {
+            return L("Re-authenticating…")
+        }
+        return L("Re-auth")
+    }
+}
+
+@MainActor
+struct CodexAccountsSectionView: View {
+    let state: CodexAccountsSectionState
+    let setActiveVisibleAccount: (String) -> Void
+    let reauthenticateAccount: (CodexVisibleAccount) -> Void
+    let removeAccount: (CodexVisibleAccount) -> Void
+    let requestSystemVisibleAccount: (String) -> Void
+    let addAccount: () -> Void
+
+    var body: some View {
+        ProviderSettingsSection(title: L("Accounts")) {
+            if let selection = self.activeSelectionBinding {
+                VStack(alignment: .leading, spacing: 6) {
+                    HStack(alignment: .firstTextBaseline, spacing: 10) {
+                        Text(L("Active"))
+                            .font(.subheadline.weight(.semibold))
+                            .frame(width: ProviderSettingsMetrics.pickerLabelWidth, alignment: .leading)
+
+                        Picker("", selection: selection) {
+                            ForEach(self.state.visibleAccounts) { account in
+                                Text(account.displayName).tag(account.id)
+                            }
+                        }
+                        .labelsHidden()
+                        .pickerStyle(.menu)
+                        .controlSize(.small)
+
+                        Spacer(minLength: 0)
+                    }
+
+                    Text(L("Choose which Codex account CodexBar should follow."))
+                        .font(.footnote)
+                        .foregroundStyle(.secondary)
+
+                    self.systemRow(selection: self.systemSelectionBinding)
+                }
+                .disabled(
+                    self.state.isAuthenticatingManagedAccount ||
+                        self.state.isRemovingManagedAccount ||
+                        self.state.isAuthenticatingLiveAccount ||
+                        self.state.isPromotingSystemAccount)
+            } else if let account = self.state.singleVisibleAccount {
+                VStack(alignment: .leading, spacing: 6) {
+                    HStack(alignment: .firstTextBaseline, spacing: 10) {
+                        Text(L("Account"))
+                            .font(.subheadline.weight(.semibold))
+                            .frame(width: ProviderSettingsMetrics.pickerLabelWidth, alignment: .leading)
+
+                        Text(account.displayName)
+                            .font(.subheadline)
+
+                        Spacer(minLength: 0)
+                    }
+
+                    self.systemRow(selection: nil)
+                }
+            }
+
+            if self.state.visibleAccounts.isEmpty {
+                Text(L("No Codex accounts detected yet."))
+                    .font(.footnote)
+                    .foregroundStyle(.secondary)
+            } else {
+                VStack(alignment: .leading, spacing: 10) {
+                    ForEach(self.state.visibleAccounts) { account in
+                        CodexAccountsSectionRowView(
+                            account: account,
+                            showsSystemBadge: self.state.showsLiveBadge(for: account),
+                            reauthenticateTitle: self.state.reauthenticateTitle(for: account),
+                            canReauthenticate: self.state.canReauthenticate(account),
+                            canRemove: self.state.canRemove(account),
+                            onReauthenticate: { self.reauthenticateAccount(account) },
+                            onRemove: { self.removeAccount(account) })
+                    }
+                }
+            }
+
+            if let notice = self.state.notice {
+                Text(notice.text)
+                    .font(.footnote)
+                    .foregroundStyle(notice.tone == .warning ? .red : .secondary)
+                    .fixedSize(horizontal: false, vertical: true)
+            }
+
+            Button(self.state.addAccountTitle) {
+                self.addAccount()
+            }
+            .buttonStyle(.bordered)
+            .controlSize(.small)
+            .disabled(self.state.canAddAccount == false)
+        }
+    }
+
+    private var activeSelectionBinding: Binding<String>? {
+        guard self.state.showsActivePicker else { return nil }
+        let fallbackID = self.state.activeVisibleAccountID ?? self.state.visibleAccounts.first?.id
+        guard let fallbackID else { return nil }
+        return Binding(
+            get: { self.state.activeVisibleAccountID ?? fallbackID },
+            set: { self.setActiveVisibleAccount($0) })
+    }
+
+    private var systemSelectionBinding: Binding<String>? {
+        guard self.state.showsSystemPicker else { return nil }
+        guard let liveVisibleAccountID = self.state.liveVisibleAccountID else { return nil }
+        return Binding(
+            get: { self.state.liveVisibleAccountID ?? liveVisibleAccountID },
+            set: { self.requestSystemVisibleAccount($0) })
+    }
+
+    @ViewBuilder
+    private func systemRow(selection: Binding<String>?) -> some View {
+        HStack(alignment: .firstTextBaseline, spacing: 10) {
+            Text(L("System"))
+                .font(.subheadline.weight(.semibold))
+                .frame(width: ProviderSettingsMetrics.pickerLabelWidth, alignment: .leading)
+
+            if let selection {
+                Picker("", selection: selection) {
+                    ForEach(self.state.visibleAccounts) { account in
+                        Text(account.displayName)
+                            .tag(account.id)
+                    }
+                }
+                .labelsHidden()
+                .pickerStyle(.menu)
+                .controlSize(.small)
+                .disabled(self.state.isSystemSelectionDisabled)
+            } else if self.state.showsSystemPicker {
+                Menu {
+                    ForEach(self.state.visibleAccounts) { account in
+                        Button(account.displayName) {
+                            self.requestSystemVisibleAccount(account.id)
+                        }
+                        .disabled(self.state.canPromoteToSystem(account) == false)
+                    }
+                } label: {
+                    Text(self.state.systemDisplayName)
+                        .font(.subheadline)
+                        .foregroundStyle(.secondary)
+                }
+                .disabled(self.state.isSystemSelectionDisabled)
+            } else {
+                Text(self.state.systemDisplayName)
+                    .font(.subheadline)
+                    .foregroundStyle(self.state.systemVisibleAccount == nil ? .secondary : .primary)
+            }
+
+            Spacer(minLength: 0)
+        }
+
+        Text(L("The default Codex account on this Mac."))
+            .font(.footnote)
+            .foregroundStyle(.secondary)
+    }
+}
+
+private struct CodexAccountsSectionRowView: View {
+    let account: CodexVisibleAccount
+    let showsSystemBadge: Bool
+    let reauthenticateTitle: String
+    let canReauthenticate: Bool
+    let canRemove: Bool
+    let onReauthenticate: () -> Void
+    let onRemove: () -> Void
+
+    var body: some View {
+        HStack(alignment: .center, spacing: 12) {
+            VStack(alignment: .leading, spacing: 2) {
+                HStack(alignment: .firstTextBaseline, spacing: 6) {
+                    Text(self.account.displayName)
+                        .font(.subheadline.weight(.semibold))
+                    if self.showsSystemBadge {
+                        Text(L("(System)"))
+                            .font(.caption.weight(.semibold))
+                            .foregroundStyle(.secondary)
+                    }
+                }
+                if let health = self.account.authenticationHealthLabel {
+                    Text(health)
+                        .font(.caption)
+                        .foregroundStyle(.orange)
+                }
+            }
+
+            Spacer(minLength: 8)
+
+            if self.account.canReauthenticate {
+                Button(self.reauthenticateTitle) {
+                    self.onReauthenticate()
+                }
+                .buttonStyle(.bordered)
+                .controlSize(.small)
+                .disabled(self.canReauthenticate == false)
+            }
+
+            if self.account.canRemove {
+                Button(L("Remove")) {
+                    self.onRemove()
+                }
+                .buttonStyle(.bordered)
+                .controlSize(.small)
+                .disabled(self.canRemove == false)
+            }
+        }
+    }
+}
diff --git a/Sources/CodexBar/PreferencesDebugPane.swift b/Sources/CodexBar/PreferencesDebugPane.swift
index c5d4730b4a..d21336adfc 100644
--- a/Sources/CodexBar/PreferencesDebugPane.swift
+++ b/Sources/CodexBar/PreferencesDebugPane.swift
@@ -13,6 +13,7 @@ struct DebugPane: View {
     @State private var logText: String = ""
     @State private var isClearingCostCache = false
     @State private var costCacheStatus: String?
+    @State private var cookieCacheStatus: String?
     #if DEBUG
     @State private var currentErrorProvider: UsageProvider = .codex
     @State private var simulatedErrorText: String = """
@@ -26,10 +27,10 @@ struct DebugPane: View {
     var body: some View {
         ScrollView(.vertical, showsIndicators: true) {
             VStack(alignment: .leading, spacing: 20) {
-                SettingsSection(title: "Logging") {
+                SettingsSection(title: L("section_logging")) {
                     PreferenceToggleRow(
-                        title: "Enable file logging",
-                        subtitle: "Write logs to \(self.fileLogPath) for debugging.",
+                        title: L("enable_file_logging"),
+                        subtitle: String(format: L("enable_file_logging_subtitle"), self.fileLogPath),
                         binding: self.$debugFileLoggingEnabled)
                         .onChange(of: self.debugFileLoggingEnabled) { _, newValue in
                             if self.settings.debugFileLoggingEnabled != newValue {
@@ -39,14 +40,14 @@ struct DebugPane: View {
 
                     HStack(alignment: .center, spacing: 12) {
                         VStack(alignment: .leading, spacing: 4) {
-                            Text("Verbosity")
+                            Text(L("verbosity_title"))
                                 .font(.body)
-                            Text("Controls how much detail is logged.")
+                            Text(L("verbosity_subtitle"))
                                 .font(.footnote)
                                 .foregroundStyle(.tertiary)
                         }
                         Spacer()
-                        Picker("Verbosity", selection: self.$settings.debugLogLevel) {
+                        Picker(L("Verbosity"), selection: self.$settings.debugLogLevel) {
                             ForEach(CodexBarLog.Level.allCases) { level in
                                 Text(level.displayName).tag(level)
                             }
@@ -59,31 +60,31 @@ struct DebugPane: View {
                     Button {
                         NSWorkspace.shared.open(CodexBarLog.fileLogURL)
                     } label: {
-                        Label("Open log file", systemImage: "doc.text.magnifyingglass")
+                        Label(L("open_log_file"), systemImage: "doc.text.magnifyingglass")
                     }
                     .controlSize(.small)
                 }
 
                 SettingsSection {
                     PreferenceToggleRow(
-                        title: "Force animation on next refresh",
-                        subtitle: "Temporarily shows the loading animation after the next refresh.",
+                        title: L("force_animation_next_refresh"),
+                        subtitle: L("force_animation_next_refresh_subtitle"),
                         binding: self.$store.debugForceAnimation)
                 }
 
                 SettingsSection(
-                    title: "Loading animations",
-                    caption: "Pick a pattern and replay it in the menu bar. \"Random\" keeps the existing behavior.")
+                    title: L("section_loading_animations"),
+                    caption: L("loading_animations_caption"))
                 {
-                    Picker("Animation pattern", selection: self.animationPatternBinding) {
-                        Text("Random (default)").tag(nil as LoadingPattern?)
+                    Picker(L("Animation pattern"), selection: self.animationPatternBinding) {
+                        Text(L("animation_random_default")).tag(nil as LoadingPattern?)
                         ForEach(LoadingPattern.allCases) { pattern in
                             Text(pattern.displayName).tag(Optional(pattern))
                         }
                     }
                     .pickerStyle(.radioGroup)
 
-                    Button("Replay selected animation") {
+                    Button(L("replay_selected_animation")) {
                         self.replaySelectedAnimation()
                     }
                     .keyboardShortcut(.defaultAction)
@@ -91,16 +92,16 @@ struct DebugPane: View {
                     Button {
                         NotificationCenter.default.post(name: .codexbarDebugBlinkNow, object: nil)
                     } label: {
-                        Label("Blink now", systemImage: "eyes")
+                        Label(L("blink_now"), systemImage: "eyes")
                     }
                     .controlSize(.small)
                 }
 
                 SettingsSection(
-                    title: "Probe logs",
-                    caption: "Fetch the latest probe output for debugging; Copy keeps the full text.")
+                    title: L("section_probe_logs"),
+                    caption: L("probe_logs_caption"))
                 {
-                    Picker("Provider", selection: self.$currentLogProvider) {
+                    Picker(L("Provider"), selection: self.$currentLogProvider) {
                         Text("Codex").tag(UsageProvider.codex)
                         Text("Claude").tag(UsageProvider.claude)
                         Text("Cursor").tag(UsageProvider.cursor)
@@ -113,23 +114,23 @@ struct DebugPane: View {
 
                     HStack(spacing: 12) {
                         Button { self.loadLog(self.currentLogProvider) } label: {
-                            Label("Fetch log", systemImage: "arrow.clockwise")
+                            Label(L("fetch_log"), systemImage: "arrow.clockwise")
                         }
                         .disabled(self.isLoadingLog)
 
                         Button { self.copyToPasteboard(self.logText) } label: {
-                            Label("Copy", systemImage: "doc.on.doc")
+                            Label(L("copy"), systemImage: "doc.on.doc")
                         }
                         .disabled(self.logText.isEmpty)
 
                         Button { self.saveLog(self.currentLogProvider) } label: {
-                            Label("Save to file", systemImage: "externaldrive.badge.plus")
+                            Label(L("save_to_file"), systemImage: "externaldrive.badge.plus")
                         }
                         .disabled(self.isLoadingLog && self.logText.isEmpty)
 
                         if self.currentLogProvider == .claude {
                             Button { self.loadClaudeDump() } label: {
-                                Label("Load parse dump", systemImage: "doc.text.magnifyingglass")
+                                Label(L("load_parse_dump"), systemImage: "doc.text.magnifyingglass")
                             }
                             .disabled(self.isLoadingLog)
                         }
@@ -139,7 +140,7 @@ struct DebugPane: View {
                         self.settings.rerunProviderDetection()
                         self.loadLog(self.currentLogProvider)
                     } label: {
-                        Label("Re-run provider autodetect", systemImage: "dot.radiowaves.left.and.right")
+                        Label(L("rerun_provider_autodetect"), systemImage: "dot.radiowaves.left.and.right")
                     }
                     .controlSize(.small)
 
@@ -165,10 +166,10 @@ struct DebugPane: View {
                 }
 
                 SettingsSection(
-                    title: "Fetch strategy attempts",
-                    caption: "Last fetch pipeline decisions and errors for a provider.")
+                    title: L("section_fetch_strategy"),
+                    caption: L("fetch_strategy_caption"))
                 {
-                    Picker("Provider", selection: self.$currentFetchProvider) {
+                    Picker(L("Provider"), selection: self.$currentFetchProvider) {
                         ForEach(UsageProvider.allCases, id: \.self) { provider in
                             Text(provider.rawValue.capitalized).tag(provider)
                         }
@@ -190,14 +191,14 @@ struct DebugPane: View {
 
                 if !self.settings.debugDisableKeychainAccess {
                     SettingsSection(
-                        title: "OpenAI cookies",
-                        caption: "Cookie import + WebKit scrape logs from the last OpenAI cookies attempt.")
+                        title: L("section_openai_cookies"),
+                        caption: L("openai_cookies_caption"))
                     {
                         HStack(spacing: 12) {
                             Button {
                                 self.copyToPasteboard(self.store.openAIDashboardCookieImportDebugLog ?? "")
                             } label: {
-                                Label("Copy", systemImage: "doc.on.doc")
+                                Label(L("copy"), systemImage: "doc.on.doc")
                             }
                             .disabled((self.store.openAIDashboardCookieImportDebugLog ?? "").isEmpty)
                         }
@@ -206,7 +207,7 @@ struct DebugPane: View {
                             Text(
                                 self.store.openAIDashboardCookieImportDebugLog?.isEmpty == false
                                     ? (self.store.openAIDashboardCookieImportDebugLog ?? "")
-                                    : "No log yet. Update OpenAI cookies in Providers → Codex to run an import.")
+                                    : L("no_log_yet"))
                                 .font(.system(.footnote, design: .monospaced))
                                 .textSelection(.enabled)
                                 .frame(maxWidth: .infinity, alignment: .leading)
@@ -219,8 +220,8 @@ struct DebugPane: View {
                 }
 
                 SettingsSection(
-                    title: "Caches",
-                    caption: "Clear cached cost scan results.")
+                    title: L("section_caches"),
+                    caption: L("caches_caption"))
                 {
                     let isTokenRefreshActive = self.store.isTokenRefreshInFlight(for: .codex)
                         || self.store.isTokenRefreshInFlight(for: .claude)
@@ -229,7 +230,7 @@ struct DebugPane: View {
                         Button {
                             Task { await self.clearCostCache() }
                         } label: {
-                            Label("Clear cost cache", systemImage: "trash")
+                            Label(L("clear_cost_cache"), systemImage: "trash")
                         }
                         .disabled(self.isClearingCostCache || isTokenRefreshActive)
 
@@ -239,13 +240,27 @@ struct DebugPane: View {
                                 .foregroundStyle(.tertiary)
                         }
                     }
+
+                    HStack(spacing: 12) {
+                        Button {
+                            self.clearCookieCache()
+                        } label: {
+                            Label(L("clear_cookie_cache"), systemImage: "trash")
+                        }
+
+                        if let status = self.cookieCacheStatus {
+                            Text(status)
+                                .font(.footnote)
+                                .foregroundStyle(.tertiary)
+                        }
+                    }
                 }
 
                 SettingsSection(
-                    title: "Notifications",
-                    caption: "Trigger test notifications for the 5-hour session window (depleted/restored).")
+                    title: L("section_notifications"),
+                    caption: L("notifications_caption"))
                 {
-                    Picker("Provider", selection: self.$currentLogProvider) {
+                    Picker(L("Provider"), selection: self.$currentLogProvider) {
                         Text("Codex").tag(UsageProvider.codex)
                         Text("Claude").tag(UsageProvider.claude)
                     }
@@ -256,26 +271,26 @@ struct DebugPane: View {
                         Button {
                             self.postSessionNotification(.depleted, provider: self.currentLogProvider)
                         } label: {
-                            Label("Post depleted", systemImage: "bell.badge")
+                            Label(L("post_depleted"), systemImage: "bell.badge")
                         }
                         .controlSize(.small)
 
                         Button {
                             self.postSessionNotification(.restored, provider: self.currentLogProvider)
                         } label: {
-                            Label("Post restored", systemImage: "bell")
+                            Label(L("post_restored"), systemImage: "bell")
                         }
                         .controlSize(.small)
                     }
                 }
 
                 SettingsSection(
-                    title: "CLI sessions",
-                    caption: "Keep Codex/Claude CLI sessions alive after a probe. Default exits once data is captured.")
+                    title: L("section_cli_sessions"),
+                    caption: L("cli_sessions_caption"))
                 {
                     PreferenceToggleRow(
-                        title: "Keep CLI sessions alive",
-                        subtitle: "Skip teardown between probes (debug-only).",
+                        title: L("keep_cli_sessions_alive"),
+                        subtitle: L("keep_cli_sessions_alive_subtitle"),
                         binding: self.$settings.debugKeepCLISessionsAlive)
 
                     Button {
@@ -283,29 +298,30 @@ struct DebugPane: View {
                             await CLIProbeSessionResetter.resetAll()
                         }
                     } label: {
-                        Label("Reset CLI sessions", systemImage: "arrow.counterclockwise")
+                        Label(L("reset_cli_sessions"), systemImage: "arrow.counterclockwise")
                     }
                     .controlSize(.small)
                 }
 
                 #if DEBUG
                 SettingsSection(
-                    title: "Error simulation",
-                    caption: "Inject a fake error message into the menu card for layout testing.")
+                    title: L("section_error_simulation"),
+                    caption: L("error_simulation_caption"))
                 {
-                    Picker("Provider", selection: self.$currentErrorProvider) {
+                    Picker(L("Provider"), selection: self.$currentErrorProvider) {
                         Text("Codex").tag(UsageProvider.codex)
                         Text("Claude").tag(UsageProvider.claude)
                         Text("Gemini").tag(UsageProvider.gemini)
                         Text("Antigravity").tag(UsageProvider.antigravity)
                         Text("Augment").tag(UsageProvider.augment)
                         Text("Amp").tag(UsageProvider.amp)
+                        Text("T3 Chat").tag(UsageProvider.t3chat)
                         Text("Ollama").tag(UsageProvider.ollama)
                     }
                     .pickerStyle(.segmented)
                     .frame(width: 360)
 
-                    TextField("Simulated error text", text: self.$simulatedErrorText, axis: .vertical)
+                    TextField(L("Simulated error text"), text: self.$simulatedErrorText, axis: .vertical)
                         .lineLimit(4)
 
                     HStack(spacing: 12) {
@@ -314,14 +330,14 @@ struct DebugPane: View {
                                 self.simulatedErrorText,
                                 provider: self.currentErrorProvider)
                         } label: {
-                            Label("Set menu error", systemImage: "exclamationmark.triangle")
+                            Label(L("set_menu_error"), systemImage: "exclamationmark.triangle")
                         }
                         .controlSize(.small)
 
                         Button {
                             self.store._setErrorForTesting(nil, provider: self.currentErrorProvider)
                         } label: {
-                            Label("Clear menu error", systemImage: "xmark.circle")
+                            Label(L("clear_menu_error"), systemImage: "xmark.circle")
                         }
                         .controlSize(.small)
                     }
@@ -333,7 +349,7 @@ struct DebugPane: View {
                                 self.simulatedErrorText,
                                 provider: self.currentErrorProvider)
                         } label: {
-                            Label("Set cost error", systemImage: "banknote")
+                            Label(L("set_cost_error"), systemImage: "banknote")
                         }
                         .controlSize(.small)
                         .disabled(!supportsTokenError)
@@ -341,7 +357,7 @@ struct DebugPane: View {
                         Button {
                             self.store._setTokenErrorForTesting(nil, provider: self.currentErrorProvider)
                         } label: {
-                            Label("Clear cost error", systemImage: "xmark.circle")
+                            Label(L("clear_cost_error"), systemImage: "xmark.circle")
                         }
                         .controlSize(.small)
                         .disabled(!supportsTokenError)
@@ -350,19 +366,19 @@ struct DebugPane: View {
                 #endif
 
                 SettingsSection(
-                    title: "CLI paths",
-                    caption: "Resolved Codex binary and PATH layers; startup login PATH capture (short timeout).")
+                    title: L("section_cli_paths"),
+                    caption: L("cli_paths_caption"))
                 {
-                    self.binaryRow(title: "Codex binary", value: self.store.pathDebugInfo.codexBinary)
-                    self.binaryRow(title: "Claude binary", value: self.store.pathDebugInfo.claudeBinary)
+                    self.binaryRow(title: L("codex_binary"), value: self.store.pathDebugInfo.codexBinary)
+                    self.binaryRow(title: L("claude_binary"), value: self.store.pathDebugInfo.claudeBinary)
 
                     VStack(alignment: .leading, spacing: 6) {
-                        Text("Effective PATH")
+                        Text(L("effective_path"))
                             .font(.callout.weight(.semibold))
                         ScrollView {
                             Text(
                                 self.store.pathDebugInfo.effectivePATH.isEmpty
-                                    ? "Unavailable"
+                                    ? L("unavailable")
                                     : self.store.pathDebugInfo.effectivePATH)
                                 .font(.system(.footnote, design: .monospaced))
                                 .textSelection(.enabled)
@@ -376,7 +392,7 @@ struct DebugPane: View {
 
                     if let loginPATH = self.store.pathDebugInfo.loginShellPATH {
                         VStack(alignment: .leading, spacing: 6) {
-                            Text("Login shell PATH (startup capture)")
+                            Text(L("login_shell_path"))
                                 .font(.callout.weight(.semibold))
                             ScrollView {
                                 Text(loginPATH)
@@ -422,7 +438,7 @@ struct DebugPane: View {
 
     private var displayedLog: String {
         if self.logText.isEmpty {
-            return self.isLoadingLog ? "Loading…" : "No log yet. Fetch to load."
+            return self.isLoadingLog ? L("loading") : L("no_log_yet_fetch")
         }
         return self.logText
     }
@@ -430,7 +446,11 @@ struct DebugPane: View {
     private func loadLog(_ provider: UsageProvider) {
         self.isLoadingLog = true
         Task {
-            let text = await self.store.debugLog(for: provider)
+            let text = await ProviderInteractionContext.$current.withValue(.userInitiated) {
+                await ProviderRefreshContext.$current.withValue(.regular) {
+                    await self.store.debugLog(for: provider)
+                }
+            }
             await MainActor.run {
                 self.logText = text
                 self.isLoadingLog = false
@@ -442,11 +462,19 @@ struct DebugPane: View {
         Task {
             if self.logText.isEmpty {
                 self.isLoadingLog = true
-                let text = await self.store.debugLog(for: provider)
+                let text = await ProviderInteractionContext.$current.withValue(.userInitiated) {
+                    await ProviderRefreshContext.$current.withValue(.regular) {
+                        await self.store.debugLog(for: provider)
+                    }
+                }
                 await MainActor.run { self.logText = text }
                 self.isLoadingLog = false
             }
-            _ = await self.store.dumpLog(toFileFor: provider)
+            _ = await ProviderInteractionContext.$current.withValue(.userInitiated) {
+                await ProviderRefreshContext.$current.withValue(.regular) {
+                    await self.store.dumpLog(toFileFor: provider)
+                }
+            }
         }
     }
 
@@ -460,7 +488,7 @@ struct DebugPane: View {
         VStack(alignment: .leading, spacing: 6) {
             Text(title)
                 .font(.callout.weight(.semibold))
-            Text(value ?? "Not found")
+            Text(value ?? L("not_found"))
                 .font(.system(.footnote, design: .monospaced))
                 .foregroundStyle(value == nil ? .secondary : .primary)
         }
@@ -492,12 +520,25 @@ struct DebugPane: View {
             return
         }
 
-        self.costCacheStatus = "Cleared."
+        self.costCacheStatus = L("cleared")
+    }
+
+    private func clearCookieCache() {
+        let summary = CookieHeaderCache.clearAllDetailed()
+        if summary.failedCount > 0 {
+            self.cookieCacheStatus = "Cookie cache cleanup failed for \(summary.failedCount) "
+                + "operation\(summary.failedCount == 1 ? "" : "s")."
+        } else if summary.clearedCount > 0 {
+            self.cookieCacheStatus = "Cleared \(summary.clearedCount) "
+                + "provider\(summary.clearedCount == 1 ? "" : "s")."
+        } else {
+            self.cookieCacheStatus = "No cached cookies found."
+        }
     }
 
     private func fetchAttemptsText(for provider: UsageProvider) -> String {
         let attempts = self.store.fetchAttempts(for: provider)
-        guard !attempts.isEmpty else { return "No fetch attempts yet." }
+        guard !attempts.isEmpty else { return L("no_fetch_attempts") }
         return attempts.map { attempt in
             let kind = Self.fetchKindLabel(attempt.kind)
             var line = "\(attempt.strategyID) (\(kind))"
diff --git a/Sources/CodexBar/PreferencesDisplayPane.swift b/Sources/CodexBar/PreferencesDisplayPane.swift
index 04050b3bb0..b1b2f3e884 100644
--- a/Sources/CodexBar/PreferencesDisplayPane.swift
+++ b/Sources/CodexBar/PreferencesDisplayPane.swift
@@ -5,6 +5,10 @@ import SwiftUI
 struct DisplayPane: View {
     private static let maxOverviewProviders = SettingsStore.mergedOverviewProviderLimit
 
+    static func overviewProviderLimitText(limit: Int = Self.maxOverviewProviders) -> String {
+        L("overview_choose_providers", String(limit))
+    }
+
     @State private var isOverviewProviderPopoverPresented = false
     @Bindable var settings: SettingsStore
     @Bindable var store: UsageStore
@@ -13,40 +17,44 @@ struct DisplayPane: View {
         ScrollView(.vertical, showsIndicators: true) {
             VStack(alignment: .leading, spacing: 16) {
                 SettingsSection(contentSpacing: 12) {
-                    Text("Menu bar")
+                    Text(L("section_menu_bar"))
                         .font(.caption)
                         .foregroundStyle(.secondary)
                         .textCase(.uppercase)
                     PreferenceToggleRow(
-                        title: "Merge Icons",
-                        subtitle: "Use a single menu bar icon with a provider switcher.",
+                        title: L("merge_icons_title"),
+                        subtitle: L("merge_icons_subtitle"),
                         binding: self.$settings.mergeIcons)
                     PreferenceToggleRow(
-                        title: "Switcher shows icons",
-                        subtitle: "Show provider icons in the switcher (otherwise show a weekly progress line).",
+                        title: L("switcher_shows_icons_title"),
+                        subtitle: L("switcher_shows_icons_subtitle"),
                         binding: self.$settings.switcherShowsIcons)
                         .disabled(!self.settings.mergeIcons)
                         .opacity(self.settings.mergeIcons ? 1 : 0.5)
                     PreferenceToggleRow(
-                        title: "Show most-used provider",
-                        subtitle: "Menu bar auto-shows the provider closest to its rate limit.",
+                        title: L("show_most_used_provider_title"),
+                        subtitle: L("show_most_used_provider_subtitle"),
                         binding: self.$settings.menuBarShowsHighestUsage)
                         .disabled(!self.settings.mergeIcons)
                         .opacity(self.settings.mergeIcons ? 1 : 0.5)
                     PreferenceToggleRow(
-                        title: "Menu bar shows percent",
-                        subtitle: "Replace critter bars with provider branding icons and a percentage.",
+                        title: L("hide_critters_title"),
+                        subtitle: L("hide_critters_subtitle"),
+                        binding: self.$settings.menuBarHidesCritters)
+                    PreferenceToggleRow(
+                        title: L("menu_bar_shows_percent_title"),
+                        subtitle: L("menu_bar_shows_percent_subtitle"),
                         binding: self.$settings.menuBarShowsBrandIconWithPercent)
                     HStack(alignment: .top, spacing: 12) {
                         VStack(alignment: .leading, spacing: 4) {
-                            Text("Display mode")
+                            Text(L("display_mode_title"))
                                 .font(.body)
-                            Text("Choose what to show in the menu bar (Pace shows usage vs. expected).")
+                            Text(L("display_mode_subtitle"))
                                 .font(.footnote)
                                 .foregroundStyle(.tertiary)
                         }
                         Spacer()
-                        Picker("Display mode", selection: self.$settings.menuBarDisplayMode) {
+                        Picker(L("Display mode"), selection: self.$settings.menuBarDisplayMode) {
                             ForEach(MenuBarDisplayMode.allCases) { mode in
                                 Text(mode.label).tag(mode)
                             }
@@ -62,26 +70,67 @@ struct DisplayPane: View {
                 Divider()
 
                 SettingsSection(contentSpacing: 12) {
-                    Text("Menu content")
+                    Text(L("section_menu_content"))
                         .font(.caption)
                         .foregroundStyle(.secondary)
                         .textCase(.uppercase)
                     PreferenceToggleRow(
-                        title: "Show usage as used",
-                        subtitle: "Progress bars fill as you consume quota (instead of showing remaining).",
+                        title: L("show_usage_as_used_title"),
+                        subtitle: L("show_usage_as_used_subtitle"),
                         binding: self.$settings.usageBarsShowUsed)
                     PreferenceToggleRow(
-                        title: "Show reset time as clock",
-                        subtitle: "Display reset times as absolute clock values instead of countdowns.",
+                        title: L("show_quota_warning_markers_title"),
+                        subtitle: L("show_quota_warning_markers_subtitle"),
+                        binding: self.$settings.quotaWarningMarkersVisible)
+                    HStack(alignment: .top, spacing: 12) {
+                        VStack(alignment: .leading, spacing: 4) {
+                            Text(L("weekly_progress_work_days_title"))
+                                .font(.body)
+                            Text(L("weekly_progress_work_days_subtitle"))
+                                .font(.footnote)
+                                .foregroundStyle(.tertiary)
+                        }
+                        Spacer()
+                        Picker(L("weekly_progress_work_days_title"), selection: self.$settings.weeklyProgressWorkDays) {
+                            Text(L("Off")).tag(nil as Int?)
+                            Text(L("4 days")).tag(4 as Int?)
+                            Text(L("5 days")).tag(5 as Int?)
+                            Text(L("7 days")).tag(7 as Int?)
+                        }
+                        .labelsHidden()
+                        .pickerStyle(.menu)
+                        .frame(maxWidth: 100)
+                    }
+                    PreferenceToggleRow(
+                        title: L("show_reset_time_as_clock_title"),
+                        subtitle: L("show_reset_time_as_clock_subtitle"),
                         binding: self.$settings.resetTimesShowAbsolute)
                     PreferenceToggleRow(
-                        title: "Show credits + extra usage",
-                        subtitle: "Show Codex Credits and Claude Extra usage sections in the menu.",
-                        binding: self.$settings.showOptionalCreditsAndExtraUsage)
+                        title: L("show_provider_changelog_links_title"),
+                        subtitle: L("show_provider_changelog_links_subtitle"),
+                        binding: self.$settings.providerChangelogLinksEnabled)
                     PreferenceToggleRow(
-                        title: "Show all token accounts",
-                        subtitle: "Stack token accounts in the menu (otherwise show an account switcher bar).",
-                        binding: self.$settings.showAllTokenAccountsInMenu)
+                        title: L("show_credits_extra_usage_title"),
+                        subtitle: L("show_credits_extra_usage_subtitle"),
+                        binding: self.$settings.showOptionalCreditsAndExtraUsage)
+                    HStack(alignment: .top, spacing: 12) {
+                        VStack(alignment: .leading, spacing: 4) {
+                            Text(L("multi_account_layout_title"))
+                                .font(.body)
+                            Text(L("multi_account_layout_subtitle"))
+                                .font(.footnote)
+                                .foregroundStyle(.tertiary)
+                        }
+                        Spacer()
+                        Picker(L("multi_account_layout_title"), selection: self.$settings.multiAccountMenuLayout) {
+                            ForEach(MultiAccountMenuLayout.allCases) { layout in
+                                Text(layout.label).tag(layout)
+                            }
+                        }
+                        .labelsHidden()
+                        .pickerStyle(.menu)
+                        .frame(maxWidth: 200)
+                    }
                     self.overviewProviderSelector
                 }
             }
@@ -110,11 +159,11 @@ struct DisplayPane: View {
     private var overviewProviderSelector: some View {
         VStack(alignment: .leading, spacing: 6) {
             HStack(alignment: .center, spacing: 12) {
-                Text("Overview tab providers")
+                Text(L("overview_tab_providers_title"))
                     .font(.body)
                 Spacer(minLength: 0)
                 if self.showsOverviewConfigureButton {
-                    Button("Configure…") {
+                    Button(L("configure")) {
                         self.isOverviewProviderPopoverPresented = true
                     }
                     .offset(y: 1)
@@ -125,11 +174,11 @@ struct DisplayPane: View {
             }
 
             if !self.settings.mergeIcons {
-                Text("Enable Merge Icons to configure Overview tab providers.")
+                Text(L("overview_enable_merge_icons_hint"))
                     .font(.footnote)
                     .foregroundStyle(.tertiary)
             } else if self.activeProvidersInOrder.isEmpty {
-                Text("No enabled providers available for Overview.")
+                Text(L("overview_no_providers_hint"))
                     .font(.footnote)
                     .foregroundStyle(.tertiary)
             } else {
@@ -144,9 +193,9 @@ struct DisplayPane: View {
 
     private var overviewProviderPopover: some View {
         VStack(alignment: .leading, spacing: 10) {
-            Text("Choose up to \(Self.maxOverviewProviders) providers")
+            Text(Self.overviewProviderLimitText())
                 .font(.headline)
-            Text("Overview rows always follow provider order.")
+            Text(L("overview_rows_follow_order"))
                 .font(.footnote)
                 .foregroundStyle(.tertiary)
 
@@ -191,7 +240,7 @@ struct DisplayPane: View {
 
     private var overviewProviderSelectionSummary: String {
         let selectedNames = self.overviewSelectedProviders.map(self.providerDisplayName)
-        guard !selectedNames.isEmpty else { return "No providers selected" }
+        guard !selectedNames.isEmpty else { return L("overview_no_providers_selected") }
         return selectedNames.joined(separator: ", ")
     }
 
diff --git a/Sources/CodexBar/PreferencesGeneralPane.swift b/Sources/CodexBar/PreferencesGeneralPane.swift
index 39a95a55ff..e60992ce13 100644
--- a/Sources/CodexBar/PreferencesGeneralPane.swift
+++ b/Sources/CodexBar/PreferencesGeneralPane.swift
@@ -2,6 +2,62 @@ import AppKit
 import CodexBarCore
 import SwiftUI
 
+enum AppLanguage: String, CaseIterable, Identifiable {
+    case system = ""
+    case english = "en"
+    case chineseSimplified = "zh-Hans"
+    case chineseTraditional = "zh-Hant"
+    case japanese = "ja"
+    case spanish = "es"
+    case portugueseBrazilian = "pt-BR"
+    case korean = "ko"
+    case german = "de"
+    case french = "fr"
+    case arabic = "ar"
+    case italian = "it"
+    case vietnamese = "vi"
+    case dutch = "nl"
+    case turkish = "tr"
+    case ukrainian = "uk"
+    case indonesian = "id"
+    case polish = "pl"
+    case persian = "fa"
+    case thai = "th"
+    case catalan = "ca"
+    case swedish = "sv"
+
+    var id: String {
+        self.rawValue
+    }
+
+    var label: String {
+        switch self {
+        case .system: L("language_system")
+        case .english: L("language_english")
+        case .chineseSimplified: L("language_chinese_simplified")
+        case .chineseTraditional: L("language_chinese_traditional")
+        case .japanese: L("language_japanese")
+        case .spanish: L("language_spanish")
+        case .portugueseBrazilian: L("language_portuguese_brazilian")
+        case .korean: L("language_korean")
+        case .german: L("language_german")
+        case .french: L("language_french")
+        case .arabic: L("language_arabic")
+        case .italian: L("language_italian")
+        case .vietnamese: L("language_vietnamese")
+        case .dutch: L("language_dutch")
+        case .turkish: L("language_turkish")
+        case .ukrainian: L("language_ukrainian")
+        case .indonesian: L("language_indonesian")
+        case .polish: L("language_polish")
+        case .persian: L("language_persian")
+        case .thai: L("language_thai")
+        case .catalan: L("language_catalan")
+        case .swedish: L("language_swedish")
+        }
+    }
+}
+
 @MainActor
 struct GeneralPane: View {
     @Bindable var settings: SettingsStore
@@ -11,20 +67,63 @@ struct GeneralPane: View {
         ScrollView(.vertical, showsIndicators: true) {
             VStack(alignment: .leading, spacing: 16) {
                 SettingsSection(contentSpacing: 12) {
-                    Text("System")
+                    Text(L("section_system"))
                         .font(.caption)
                         .foregroundStyle(.secondary)
                         .textCase(.uppercase)
+
+                    VStack(alignment: .leading, spacing: 6) {
+                        HStack(alignment: .top, spacing: 12) {
+                            VStack(alignment: .leading, spacing: 4) {
+                                Text(L("language_title"))
+                                    .font(.body)
+                                Text(L("language_subtitle"))
+                                    .font(.footnote)
+                                    .foregroundStyle(.tertiary)
+                                    .fixedSize(horizontal: false, vertical: true)
+                            }
+                            Spacer()
+                            Picker(L("language_title"), selection: self.$settings.appLanguage) {
+                                ForEach(AppLanguage.allCases) { option in
+                                    Text(option.label).tag(option.rawValue)
+                                }
+                            }
+                            .labelsHidden()
+                            .pickerStyle(.menu)
+                            .frame(maxWidth: 200)
+                        }
+                    }
+
+                    HStack(alignment: .top, spacing: 12) {
+                        VStack(alignment: .leading, spacing: 4) {
+                            Text(L("terminal_app_title"))
+                                .font(.body)
+                            Text(L("terminal_app_subtitle"))
+                                .font(.footnote)
+                                .foregroundStyle(.tertiary)
+                                .fixedSize(horizontal: false, vertical: true)
+                        }
+                        Spacer()
+                        Picker(L("terminal_app_title"), selection: self.$settings.terminalApp) {
+                            ForEach(TerminalApp.allCases) { option in
+                                Text(option.label).tag(option)
+                            }
+                        }
+                        .labelsHidden()
+                        .pickerStyle(.menu)
+                        .frame(maxWidth: 200)
+                    }
+
                     PreferenceToggleRow(
-                        title: "Start at Login",
-                        subtitle: "Automatically opens CodexBar when you start your Mac.",
+                        title: L("start_at_login_title"),
+                        subtitle: L("start_at_login_subtitle"),
                         binding: self.$settings.launchAtLogin)
                 }
 
                 Divider()
 
                 SettingsSection(contentSpacing: 12) {
-                    Text("Usage")
+                    Text(L("section_usage"))
                         .font(.caption)
                         .foregroundStyle(.secondary)
                         .textCase(.uppercase)
@@ -32,18 +131,20 @@ struct GeneralPane: View {
                     VStack(alignment: .leading, spacing: 10) {
                         VStack(alignment: .leading, spacing: 4) {
                             Toggle(isOn: self.$settings.costUsageEnabled) {
-                                Text("Show cost summary")
+                                Text(L("show_cost_summary"))
                                     .font(.body)
                             }
                             .toggleStyle(.checkbox)
 
-                            Text("Reads local usage logs. Shows today + last 30 days cost in the menu.")
+                            Text(L("show_cost_summary_subtitle"))
                                 .font(.footnote)
                                 .foregroundStyle(.tertiary)
                                 .fixedSize(horizontal: false, vertical: true)
 
                             if self.settings.costUsageEnabled {
-                                Text("Auto-refresh: hourly · Timeout: 10m")
+                                CostHistoryDaysEditor(settings: self.settings)
+
+                                Text(L("cost_auto_refresh_info"))
                                     .font(.footnote)
                                     .foregroundStyle(.tertiary)
 
@@ -57,21 +158,21 @@ struct GeneralPane: View {
                 Divider()
 
                 SettingsSection(contentSpacing: 12) {
-                    Text("Automation")
+                    Text(L("section_automation"))
                         .font(.caption)
                         .foregroundStyle(.secondary)
                         .textCase(.uppercase)
                     VStack(alignment: .leading, spacing: 6) {
                         HStack(alignment: .top, spacing: 12) {
                             VStack(alignment: .leading, spacing: 4) {
-                                Text("Refresh cadence")
+                                Text(L("refresh_cadence_title"))
                                     .font(.body)
-                                Text("How often CodexBar polls providers in the background.")
+                                Text(L("refresh_cadence_subtitle"))
                                     .font(.footnote)
                                     .foregroundStyle(.tertiary)
                             }
                             Spacer()
-                            Picker("Refresh cadence", selection: self.$settings.refreshFrequency) {
+                            Picker(L("Refresh cadence"), selection: self.$settings.refreshFrequency) {
                                 ForEach(RefreshFrequency.allCases) { option in
                                     Text(option.label).tag(option)
                                 }
@@ -81,21 +182,26 @@ struct GeneralPane: View {
                             .frame(maxWidth: 200)
                         }
                         if self.settings.refreshFrequency == .manual {
-                            Text("Auto-refresh is off; use the menu's Refresh command.")
+                            Text(L("manual_refresh_hint"))
                                 .font(.footnote)
                                 .foregroundStyle(.secondary)
                         }
                     }
                     PreferenceToggleRow(
-                        title: "Check provider status",
-                        subtitle: "Polls OpenAI/Claude status pages and Google Workspace for " +
-                            "Gemini/Antigravity, surfacing incidents in the icon and menu.",
+                        title: L("check_provider_status_title"),
+                        subtitle: L("check_provider_status_subtitle"),
                         binding: self.$settings.statusChecksEnabled)
                     PreferenceToggleRow(
-                        title: "Session quota notifications",
-                        subtitle: "Notifies when the 5-hour session quota hits 0% and when it becomes " +
-                            "available again.",
+                        title: L("session_quota_notifications_title"),
+                        subtitle: L("session_quota_notifications_subtitle"),
                         binding: self.$settings.sessionQuotaNotificationsEnabled)
+                    PreferenceToggleRow(
+                        title: L("quota_warning_notifications_title"),
+                        subtitle: L("quota_warning_notifications_subtitle"),
+                        binding: self.$settings.quotaWarningNotificationsEnabled)
+                    if self.settings.quotaWarningNotificationsEnabled {
+                        GlobalQuotaWarningSettingsView(settings: self.settings)
+                    }
                 }
 
                 Divider()
@@ -103,7 +209,7 @@ struct GeneralPane: View {
                 SettingsSection(contentSpacing: 12) {
                     HStack {
                         Spacer()
-                        Button("Quit CodexBar") { NSApp.terminate(nil) }
+                        Button(L("quit_app")) { NSApp.terminate(nil) }
                             .buttonStyle(.borderedProminent)
                             .controlSize(.large)
                     }
@@ -119,7 +225,7 @@ struct GeneralPane: View {
         let name = ProviderDescriptorRegistry.descriptor(for: provider).metadata.displayName
 
         guard provider == .claude || provider == .codex else {
-            return Text("\(name): unsupported")
+            return Text(String(format: L("cost_status_unsupported"), name))
                 .font(.footnote)
                 .foregroundStyle(.tertiary)
         }
@@ -133,33 +239,70 @@ struct GeneralPane: View {
                 formatter.unitsStyle = .abbreviated
                 return formatter.string(from: seconds).map { " (\($0))" } ?? ""
             }()
-            return Text("\(name): fetching…\(elapsed)")
+            return Text(String(format: L("cost_status_fetching"), name, elapsed))
                 .font(.footnote)
                 .foregroundStyle(.tertiary)
         }
         if let snapshot = self.store.tokenSnapshot(for: provider) {
             let updated = UsageFormatter.updatedString(from: snapshot.updatedAt)
-            let cost = snapshot.last30DaysCostUSD.map { UsageFormatter.usdString($0) } ?? "—"
-            return Text("\(name): \(updated) · 30d \(cost)")
+            let cost = snapshot.last30DaysCostUSD
+                .map { UsageFormatter.currencyString($0, currencyCode: snapshot.currencyCode) } ?? "—"
+            let window = snapshot.historyLabel ?? (snapshot.historyDays == 1 ? "today" : "\(snapshot.historyDays)d")
+            return Text(String(format: L("cost_status_snapshot"), name, updated, window, cost))
                 .font(.footnote)
                 .foregroundStyle(.tertiary)
         }
         if let error = self.store.tokenError(for: provider), !error.isEmpty {
             let truncated = UsageFormatter.truncatedSingleLine(error, max: 120)
-            return Text("\(name): \(truncated)")
+            return Text(String(format: L("cost_status_error"), name, truncated))
                 .font(.footnote)
                 .foregroundStyle(.tertiary)
         }
         if let lastAttempt = self.store.tokenLastAttemptAt(for: provider) {
             let rel = RelativeDateTimeFormatter()
+            rel.locale = Locale(identifier: "en_US")
             rel.unitsStyle = .abbreviated
             let when = rel.localizedString(for: lastAttempt, relativeTo: Date())
-            return Text("\(name): last attempt \(when)")
+            return Text(String(format: L("cost_status_last_attempt"), name, when))
                 .font(.footnote)
                 .foregroundStyle(.tertiary)
         }
-        return Text("\(name): no data yet")
+        return Text(String(format: L("cost_status_no_data"), name))
             .font(.footnote)
             .foregroundStyle(.tertiary)
     }
 }
+
+@MainActor
+struct CostHistoryDaysEditor: View {
+    @Bindable var settings: SettingsStore
+
+    static func title(days: Int) -> String {
+        String(format: L("cost_history_days_title"), days)
+    }
+
+    var body: some View {
+        let title = Self.title(days: self.settings.costUsageHistoryDays)
+
+        HStack(alignment: .firstTextBaseline, spacing: 8) {
+            Stepper(
+                value: self.$settings.costUsageHistoryDays,
+                in: 1...365,
+                step: 1)
+            {
+                Text(title)
+                    .font(.footnote)
+            }
+
+            TextField(
+                title,
+                value: self.$settings.costUsageHistoryDays,
+                format: .number)
+                .labelsHidden()
+                .textFieldStyle(.roundedBorder)
+                .font(.footnote)
+                .monospacedDigit()
+                .frame(width: 64)
+        }
+    }
+}
diff --git a/Sources/CodexBar/PreferencesProviderDetailView.swift b/Sources/CodexBar/PreferencesProviderDetailView.swift
index 58a55deb59..b9754ca3f1 100644
--- a/Sources/CodexBar/PreferencesProviderDetailView.swift
+++ b/Sources/CodexBar/PreferencesProviderDetailView.swift
@@ -1,8 +1,13 @@
 import CodexBarCore
 import SwiftUI
 
+enum ProviderMetricInlinePresentation: Equatable {
+    case progress
+    case status(String)
+}
+
 @MainActor
-struct ProviderDetailView: View {
+struct ProviderDetailView<SupplementaryContent: View>: View {
     let provider: UsageProvider
     @Bindable var store: UsageStore
     @Binding var isEnabled: Bool
@@ -11,14 +16,65 @@ struct ProviderDetailView: View {
     let settingsPickers: [ProviderSettingsPickerDescriptor]
     let settingsToggles: [ProviderSettingsToggleDescriptor]
     let settingsFields: [ProviderSettingsFieldDescriptor]
+    let settingsActions: [ProviderSettingsActionsDescriptor]
     let settingsTokenAccounts: ProviderSettingsTokenAccountsDescriptor?
+    let settingsOrganizations: ProviderSettingsOrganizationsDescriptor?
     let errorDisplay: ProviderErrorDisplay?
     @Binding var isErrorExpanded: Bool
     let onCopyError: (String) -> Void
     let onRefresh: () -> Void
+    let supplementarySettingsContent: SupplementaryContent
+    let showsSupplementarySettingsContent: Bool
+
+    init(
+        provider: UsageProvider,
+        store: UsageStore,
+        isEnabled: Binding<Bool>,
+        subtitle: String,
+        model: UsageMenuCardView.Model,
+        settingsPickers: [ProviderSettingsPickerDescriptor],
+        settingsToggles: [ProviderSettingsToggleDescriptor],
+        settingsFields: [ProviderSettingsFieldDescriptor],
+        settingsActions: [ProviderSettingsActionsDescriptor] = [],
+        settingsTokenAccounts: ProviderSettingsTokenAccountsDescriptor?,
+        settingsOrganizations: ProviderSettingsOrganizationsDescriptor? = nil,
+        errorDisplay: ProviderErrorDisplay?,
+        isErrorExpanded: Binding<Bool>,
+        onCopyError: @escaping (String) -> Void,
+        onRefresh: @escaping () -> Void,
+        showsSupplementarySettingsContent: Bool = false,
+        @ViewBuilder supplementarySettingsContent: () -> SupplementaryContent)
+    {
+        self.provider = provider
+        self.store = store
+        self._isEnabled = isEnabled
+        self.subtitle = subtitle
+        self.model = model
+        self.settingsPickers = settingsPickers
+        self.settingsToggles = settingsToggles
+        self.settingsFields = settingsFields
+        self.settingsActions = settingsActions
+        self.settingsTokenAccounts = settingsTokenAccounts
+        self.settingsOrganizations = settingsOrganizations
+        self.errorDisplay = errorDisplay
+        self._isErrorExpanded = isErrorExpanded
+        self.onCopyError = onCopyError
+        self.onRefresh = onRefresh
+        self.showsSupplementarySettingsContent = showsSupplementarySettingsContent
+        self.supplementarySettingsContent = supplementarySettingsContent()
+    }
 
     static func metricTitle(provider: UsageProvider, metric: UsageMenuCardView.Model.Metric) -> String {
-        UsageMenuCardView.popupMetricTitle(provider: provider, metric: metric)
+        L(UsageMenuCardView.popupMetricTitle(provider: provider, metric: metric))
+    }
+
+    static func metricInlinePresentation(
+        _ metric: UsageMenuCardView.Model.Metric) -> ProviderMetricInlinePresentation
+    {
+        if let statusText = metric.statusText {
+            return .status(statusText)
+        }
+        return .progress
     }
 
     static func planRow(provider: UsageProvider, planText: String?) -> (label: String, value: String)? {
@@ -27,8 +83,8 @@ struct ProviderDetailView: View {
         else {
             return nil
         }
-        guard provider == .openrouter else {
-            return (label: "Plan", value: rawPlan)
+        guard provider == .openrouter || provider == .mimo || provider == .moonshot || provider == .poe else {
+            return (label: L("Plan"), value: rawPlan)
         }
 
         let prefix = "Balance:"
@@ -36,10 +92,13 @@ struct ProviderDetailView: View {
             let valueStart = rawPlan.index(rawPlan.startIndex, offsetBy: prefix.count)
             let trimmedValue = rawPlan[valueStart...].trimmingCharacters(in: .whitespacesAndNewlines)
             if !trimmedValue.isEmpty {
-                return (label: "Balance", value: trimmedValue)
+                return (label: L("Balance"), value: trimmedValue)
             }
         }
-        return (label: "Balance", value: rawPlan)
+        if provider == .mimo {
+            return (label: L("Plan"), value: rawPlan)
+        }
+        return (label: L("Balance"), value: rawPlan)
     }
 
     var body: some View {
@@ -63,14 +122,16 @@ struct ProviderDetailView: View {
 
                 if let errorDisplay {
                     ProviderErrorView(
-                        title: "Last \(self.store.metadata(for: self.provider).displayName) fetch failed:",
+                        title: String(
+                            format: L("last_fetch_failed_with_provider"),
+                            self.store.metadata(for: self.provider).displayName),
                         display: errorDisplay,
                         isExpanded: self.$isErrorExpanded,
                         onCopy: { self.onCopyError(errorDisplay.full) })
                 }
 
                 if self.hasSettings {
-                    ProviderSettingsSection(title: "Settings") {
+                    ProviderSettingsSection(title: L("Settings")) {
                         ForEach(self.settingsPickers) { picker in
                             ProviderSettingsPickerRowView(picker: picker)
                         }
@@ -82,11 +143,23 @@ struct ProviderDetailView: View {
                         ForEach(self.settingsFields) { field in
                             ProviderSettingsFieldRowView(field: field)
                         }
+                        ForEach(self.settingsActions) { descriptor in
+                            ProviderSettingsActionsRowView(descriptor: descriptor)
+                        }
+                        if let organizations = self.settingsOrganizations {
+                            ProviderSettingsOrganizationsRowView(descriptor: organizations)
+                        }
                     }
                 }
 
+                if self.showsSupplementarySettingsContent {
+                    self.supplementarySettingsContent
+                }
+
+                ProviderQuotaWarningSettingsView(provider: self.provider, settings: self.store.settings)
+
                 if !self.settingsToggles.isEmpty {
-                    ProviderSettingsSection(title: "Options") {
+                    ProviderSettingsSection(title: L("Options")) {
                         ForEach(self.settingsToggles) { toggle in
                             ProviderSettingsToggleRowView(toggle: toggle)
                         }
@@ -103,16 +176,23 @@ struct ProviderDetailView: View {
     private var hasSettings: Bool {
         !self.settingsPickers.isEmpty ||
             !self.settingsFields.isEmpty ||
-            self.settingsTokenAccounts != nil
+            !self.settingsActions.isEmpty ||
+            self.settingsTokenAccounts != nil ||
+            self.settingsOrganizations != nil
     }
 
     private var detailLabelWidth: CGFloat {
-        var infoLabels = ["State", "Source", "Version", "Updated"]
+        var infoLabels = [L("State"), L("Source"), L("Version"), L("Updated")]
         if self.store.status(for: self.provider) != nil {
-            infoLabels.append("Status")
+            infoLabels.append(L("Status"))
         }
         if !self.model.email.isEmpty {
-            infoLabels.append("Account")
+            infoLabels.append(L("Account"))
+        }
+        if self.provider == .kiro,
+           self.model.metrics.isEmpty == false
+        {
+            infoLabels.append(L("Auth"))
         }
         if let planRow = Self.planRow(provider: self.provider, planText: self.model.planText) {
             infoLabels.append(planRow.label)
@@ -122,13 +202,13 @@ struct ProviderDetailView: View {
             Self.metricTitle(provider: self.provider, metric: metric)
         }
         if self.model.creditsText != nil {
-            metricLabels.append("Credits")
+            metricLabels.append(L("Credits"))
         }
         if let providerCost = self.model.providerCost {
             metricLabels.append(providerCost.title)
         }
         if self.model.tokenUsage != nil {
-            metricLabels.append("Cost")
+            metricLabels.append(L("Cost"))
         }
 
         let infoWidth = ProviderSettingsMetrics.labelWidth(
@@ -174,7 +254,7 @@ private struct ProviderDetailHeaderView: View {
                 }
                 .buttonStyle(.bordered)
                 .controlSize(.small)
-                .help("Refresh")
+                .help(L("Refresh"))
 
                 Toggle("", isOn: self.$isEnabled)
                     .labelsHidden()
@@ -234,29 +314,39 @@ private struct ProviderDetailInfoGrid: View {
     var body: some View {
         let status = self.store.status(for: self.provider)
         let source = self.store.sourceLabel(for: self.provider)
-        let version = self.store.version(for: self.provider) ?? "not detected"
+        let version = self.store.version(for: self.provider) ?? L("not detected")
         let updated = self.updatedText
         let email = self.model.email
-        let enabledText = self.isEnabled ? "Enabled" : "Disabled"
+        let enabledText = self.isEnabled ? L("Enabled") : L("Disabled")
 
         Grid(alignment: .leading, horizontalSpacing: 12, verticalSpacing: 6) {
-            ProviderDetailInfoRow(label: "State", value: enabledText, labelWidth: self.labelWidth)
-            ProviderDetailInfoRow(label: "Source", value: source, labelWidth: self.labelWidth)
-            ProviderDetailInfoRow(label: "Version", value: version, labelWidth: self.labelWidth)
-            ProviderDetailInfoRow(label: "Updated", value: updated, labelWidth: self.labelWidth)
+            ProviderDetailInfoRow(label: L("State"), value: enabledText, labelWidth: self.labelWidth)
+            ProviderDetailInfoRow(label: L("Source"), value: source, labelWidth: self.labelWidth)
+            ProviderDetailInfoRow(label: L("Version"), value: version, labelWidth: self.labelWidth)
+            ProviderDetailInfoRow(label: L("Updated"), value: updated, labelWidth: self.labelWidth)
 
             if let status {
                 ProviderDetailInfoRow(
-                    label: "Status",
+                    label: L("Status"),
                     value: status.description ?? status.indicator.label,
                     labelWidth: self.labelWidth)
             }
 
             if !email.isEmpty {
-                ProviderDetailInfoRow(label: "Account", value: email, labelWidth: self.labelWidth)
+                ProviderDetailInfoRow(label: L("Account"), value: email, labelWidth: self.labelWidth)
             }
 
-            if let planRow = ProviderDetailView.planRow(provider: self.provider, planText: self.model.planText) {
+            if self.provider == .kiro,
+               let authMethod = self.store.snapshot(for: self.provider)?.loginMethod(for: .kiro),
+               !authMethod.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+            {
+                ProviderDetailInfoRow(label: L("Auth"), value: authMethod, labelWidth: self.labelWidth)
+            }
+
+            if let planRow = ProviderDetailView<EmptyView>.planRow(
+                provider: self.provider,
+                planText: self.model.planText)
+            {
                 ProviderDetailInfoRow(label: planRow.label, value: planRow.value, labelWidth: self.labelWidth)
             }
         }
@@ -269,9 +359,12 @@ private struct ProviderDetailInfoGrid: View {
             return UsageFormatter.updatedString(from: updated)
         }
         if self.store.refreshingProviders.contains(self.provider) {
-            return "Refreshing"
+            return L("Refreshing")
         }
-        return "Not fetched yet"
+        if self.store.unavailableMessage(for: self.provider) != nil {
+            return L("Unavailable")
+        }
+        return L("Not fetched yet")
     }
 }
 
@@ -304,7 +397,7 @@ struct ProviderMetricsInlineView: View {
         let hasProviderCost = self.model.providerCost != nil
         let hasTokenUsage = self.model.tokenUsage != nil
         ProviderSettingsSection(
-            title: "Usage",
+            title: L("Usage"),
             spacing: 8,
             verticalPadding: 6,
             horizontalPadding: 0)
@@ -317,7 +410,7 @@ struct ProviderMetricsInlineView: View {
                 ForEach(self.model.metrics, id: \.id) { metric in
                     ProviderMetricInlineRow(
                         metric: metric,
-                        title: ProviderDetailView.metricTitle(provider: self.provider, metric: metric),
+                        title: ProviderDetailView<EmptyView>.metricTitle(provider: self.provider, metric: metric),
                         progressColor: self.model.progressColor,
                         labelWidth: self.labelWidth)
                 }
@@ -331,7 +424,7 @@ struct ProviderMetricsInlineView: View {
 
                 if let credits = self.model.creditsText {
                     ProviderMetricInlineTextRow(
-                        title: "Credits",
+                        title: L("Credits"),
                         value: credits,
                         labelWidth: self.labelWidth)
                 }
@@ -345,7 +438,7 @@ struct ProviderMetricsInlineView: View {
 
                 if let tokenUsage = self.model.tokenUsage {
                     ProviderMetricInlineTextRow(
-                        title: "Cost",
+                        title: L("Cost"),
                         value: tokenUsage.sessionLine,
                         labelWidth: self.labelWidth)
                     ProviderMetricInlineTextRow(
@@ -359,9 +452,9 @@ struct ProviderMetricsInlineView: View {
 
     private var placeholderText: String {
         if !self.isEnabled {
-            return "Disabled — no recent data"
+            return L("Disabled — no recent data")
         }
-        return self.model.placeholder ?? "No usage yet"
+        return self.model.placeholder.map(L) ?? L("No usage yet")
     }
 }
 
@@ -379,49 +472,57 @@ private struct ProviderMetricInlineRow: View {
                 .frame(width: self.labelWidth, alignment: .leading)
 
             VStack(alignment: .leading, spacing: 4) {
-                UsageProgressBar(
-                    percent: self.metric.percent,
-                    tint: self.progressColor,
-                    accessibilityLabel: self.metric.percentStyle.accessibilityLabel,
-                    pacePercent: self.metric.pacePercent,
-                    paceOnTop: self.metric.paceOnTop)
-                    .frame(minWidth: ProviderSettingsMetrics.metricBarWidth, maxWidth: .infinity)
-
-                HStack(alignment: .firstTextBaseline, spacing: 8) {
-                    Text(self.metric.percentLabel)
+                switch ProviderDetailView<EmptyView>.metricInlinePresentation(self.metric) {
+                case let .status(statusText):
+                    Text(statusText)
                         .font(.footnote)
                         .foregroundStyle(.secondary)
-                        .monospacedDigit()
-                    Spacer(minLength: 8)
-                    if let resetText = self.metric.resetText, !resetText.isEmpty {
-                        Text(resetText)
-                            .font(.footnote)
-                            .foregroundStyle(.secondary)
-                    }
-                }
+                case .progress:
+                    UsageProgressBar(
+                        percent: self.metric.percent,
+                        tint: self.progressColor,
+                        accessibilityLabel: self.metric.percentStyle.accessibilityLabel,
+                        pacePercent: self.metric.pacePercent,
+                        paceOnTop: self.metric.paceOnTop,
+                        warningMarkerPercents: self.metric.warningMarkerPercents)
+                        .frame(minWidth: ProviderSettingsMetrics.metricBarWidth, maxWidth: .infinity)
 
-                let hasLeftDetail = self.metric.detailLeftText?.isEmpty == false
-                let hasRightDetail = self.metric.detailRightText?.isEmpty == false
-                if hasLeftDetail || hasRightDetail {
                     HStack(alignment: .firstTextBaseline, spacing: 8) {
-                        if let leftDetail = self.metric.detailLeftText, !leftDetail.isEmpty {
-                            Text(leftDetail)
-                                .font(.footnote)
-                                .foregroundStyle(.secondary)
-                        }
+                        Text(self.metric.percentLabel)
+                            .font(.footnote)
+                            .foregroundStyle(.secondary)
+                            .monospacedDigit()
                         Spacer(minLength: 8)
-                        if let rightDetail = self.metric.detailRightText, !rightDetail.isEmpty {
-                            Text(rightDetail)
+                        if let resetText = self.metric.resetText, !resetText.isEmpty {
+                            Text(resetText)
                                 .font(.footnote)
                                 .foregroundStyle(.secondary)
                         }
                     }
-                }
 
-                if let detail = self.detailText, !detail.isEmpty {
-                    Text(detail)
-                        .font(.footnote)
-                        .foregroundStyle(.tertiary)
+                    let hasLeftDetail = self.metric.detailLeftText?.isEmpty == false
+                    let hasRightDetail = self.metric.detailRightText?.isEmpty == false
+                    if hasLeftDetail || hasRightDetail {
+                        HStack(alignment: .firstTextBaseline, spacing: 8) {
+                            if let leftDetail = self.metric.detailLeftText, !leftDetail.isEmpty {
+                                Text(leftDetail)
+                                    .font(.footnote)
+                                    .foregroundStyle(.secondary)
+                            }
+                            Spacer(minLength: 8)
+                            if let rightDetail = self.metric.detailRightText, !rightDetail.isEmpty {
+                                Text(rightDetail)
+                                    .font(.footnote)
+                                    .foregroundStyle(.secondary)
+                            }
+                        }
+                    }
+
+                    if let detail = self.detailText, !detail.isEmpty {
+                        Text(detail)
+                            .font(.footnote)
+                            .foregroundStyle(.tertiary)
+                    }
                 }
             }
             .frame(maxWidth: .infinity, alignment: .leading)
@@ -494,17 +595,21 @@ private struct ProviderMetricInlineCostRow: View {
                 .frame(width: self.labelWidth, alignment: .leading)
 
             VStack(alignment: .leading, spacing: 4) {
-                UsageProgressBar(
-                    percent: self.section.percentUsed,
-                    tint: self.progressColor,
-                    accessibilityLabel: "Usage used")
-                    .frame(minWidth: ProviderSettingsMetrics.metricBarWidth, maxWidth: .infinity)
+                if let percentUsed = self.section.percentUsed {
+                    UsageProgressBar(
+                        percent: percentUsed,
+                        tint: self.progressColor,
+                        accessibilityLabel: L("Usage used"))
+                        .frame(minWidth: ProviderSettingsMetrics.metricBarWidth, maxWidth: .infinity)
+                }
 
                 HStack(alignment: .firstTextBaseline, spacing: 8) {
-                    Text(String(format: "%.0f%% used", self.section.percentUsed))
-                        .font(.footnote)
-                        .foregroundStyle(.secondary)
-                        .monospacedDigit()
+                    if let percentLine = self.section.percentLine {
+                        Text(percentLine)
+                            .font(.footnote)
+                            .foregroundStyle(.secondary)
+                            .monospacedDigit()
+                    }
                     Spacer(minLength: 8)
                     Text(self.section.spendLine)
                         .font(.footnote)
diff --git a/Sources/CodexBar/PreferencesProviderErrorView.swift b/Sources/CodexBar/PreferencesProviderErrorView.swift
index 55d45fcbb9..156dc62719 100644
--- a/Sources/CodexBar/PreferencesProviderErrorView.swift
+++ b/Sources/CodexBar/PreferencesProviderErrorView.swift
@@ -1,6 +1,6 @@
 import SwiftUI
 
-struct ProviderErrorDisplay: Sendable {
+struct ProviderErrorDisplay {
     let preview: String
     let full: String
 }
@@ -26,7 +26,7 @@ struct ProviderErrorView: View {
                 }
                 .buttonStyle(.plain)
                 .foregroundStyle(.secondary)
-                .help("Copy error")
+                .help(L("Copy error"))
             }
 
             Text(self.display.preview)
@@ -36,7 +36,7 @@ struct ProviderErrorView: View {
                 .fixedSize(horizontal: false, vertical: true)
 
             if self.display.preview != self.display.full {
-                Button(self.isExpanded ? "Hide details" : "Show details") { self.isExpanded.toggle() }
+                Button(self.isExpanded ? L("Hide details") : L("Show details")) { self.isExpanded.toggle() }
                     .buttonStyle(.link)
                     .font(.footnote)
             }
diff --git a/Sources/CodexBar/PreferencesProviderSettingsRows.swift b/Sources/CodexBar/PreferencesProviderSettingsRows.swift
index 414f41c55e..8c7bf026e5 100644
--- a/Sources/CodexBar/PreferencesProviderSettingsRows.swift
+++ b/Sources/CodexBar/PreferencesProviderSettingsRows.swift
@@ -23,7 +23,7 @@ struct ProviderSettingsSection<Content: View>: View {
 
     var body: some View {
         VStack(alignment: .leading, spacing: self.spacing) {
-            Text(self.title)
+            Text(L(self.title))
                 .font(.headline)
             self.content()
         }
@@ -38,14 +38,16 @@ struct ProviderSettingsToggleRowView: View {
     let toggle: ProviderSettingsToggleDescriptor
 
     var body: some View {
+        let isEnabled = self.toggle.isEnabled?() ?? true
         VStack(alignment: .leading, spacing: 8) {
             HStack(alignment: .firstTextBaseline, spacing: 12) {
                 VStack(alignment: .leading, spacing: 4) {
-                    Text(self.toggle.title)
+                    Text(L(self.toggle.title))
                         .font(.subheadline.weight(.semibold))
-                    Text(self.toggle.subtitle)
+                        .foregroundStyle(isEnabled ? .primary : .tertiary)
+                    Text(L(self.toggle.subtitle))
                         .font(.footnote)
-                        .foregroundStyle(.secondary)
+                        .foregroundStyle(isEnabled ? .secondary : .tertiary)
                         .fixedSize(horizontal: false, vertical: true)
                 }
                 Spacer(minLength: 8)
@@ -67,7 +69,7 @@ struct ProviderSettingsToggleRowView: View {
                 if !actions.isEmpty {
                     HStack(spacing: 10) {
                         ForEach(actions) { action in
-                            Button(action.title) {
+                            Button(L(action.title)) {
                                 Task { @MainActor in
                                     await action.perform()
                                 }
@@ -79,6 +81,7 @@ struct ProviderSettingsToggleRowView: View {
                 }
             }
         }
+        .disabled(!isEnabled)
         .onChange(of: self.toggle.binding.wrappedValue) { _, enabled in
             guard let onChange = self.toggle.onChange else { return }
             Task { @MainActor in
@@ -101,13 +104,13 @@ struct ProviderSettingsPickerRowView: View {
         let isEnabled = self.picker.isEnabled?() ?? true
         VStack(alignment: .leading, spacing: 6) {
             HStack(alignment: .firstTextBaseline, spacing: 10) {
-                Text(self.picker.title)
+                Text(L(self.picker.title))
                     .font(.subheadline.weight(.semibold))
                     .frame(width: ProviderSettingsMetrics.pickerLabelWidth, alignment: .leading)
 
                 Picker("", selection: self.picker.binding) {
                     ForEach(self.picker.options) { option in
-                        Text(option.title).tag(option.id)
+                        Text(L(option.title)).tag(option.id)
                     }
                 }
                 .labelsHidden()
@@ -128,7 +131,7 @@ struct ProviderSettingsPickerRowView: View {
 
             let subtitle = self.picker.dynamicSubtitle?() ?? self.picker.subtitle
             if !subtitle.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
-                Text(subtitle)
+                Text(L(subtitle))
                     .font(.footnote)
                     .foregroundStyle(.secondary)
                     .fixedSize(horizontal: false, vertical: true)
@@ -157,11 +160,11 @@ struct ProviderSettingsFieldRowView: View {
             if hasHeader {
                 VStack(alignment: .leading, spacing: 4) {
                     if !trimmedTitle.isEmpty {
-                        Text(trimmedTitle)
+                        Text(L(trimmedTitle))
                             .font(.subheadline.weight(.semibold))
                     }
                     if !trimmedSubtitle.isEmpty {
-                        Text(trimmedSubtitle)
+                        Text(L(trimmedSubtitle))
                             .font(.footnote)
                             .foregroundStyle(.secondary)
                             .fixedSize(horizontal: false, vertical: true)
@@ -171,12 +174,12 @@ struct ProviderSettingsFieldRowView: View {
 
             switch self.field.kind {
             case .plain:
-                TextField(self.field.placeholder ?? "", text: self.field.binding)
+                TextField(L(self.field.placeholder ?? ""), text: self.field.binding)
                     .textFieldStyle(.roundedBorder)
                     .font(.footnote)
                     .onTapGesture { self.field.onActivate?() }
             case .secure:
-                SecureField(self.field.placeholder ?? "", text: self.field.binding)
+                SecureField(L(self.field.placeholder ?? ""), text: self.field.binding)
                     .textFieldStyle(.roundedBorder)
                     .font(.footnote)
                     .onTapGesture { self.field.onActivate?() }
@@ -186,7 +189,48 @@ struct ProviderSettingsFieldRowView: View {
             if !actions.isEmpty {
                 HStack(spacing: 10) {
                     ForEach(actions) { action in
-                        Button(action.title) {
+                        Button(L(action.title)) {
+                            Task { @MainActor in
+                                await action.perform()
+                            }
+                        }
+                        .applyProviderSettingsButtonStyle(action.style)
+                        .controlSize(.small)
+                    }
+                }
+            }
+
+            if let footer = self.field.footerText, !footer.isEmpty {
+                Text(L(footer))
+                    .font(.footnote)
+                    .foregroundStyle(.secondary)
+                    .fixedSize(horizontal: false, vertical: true)
+            }
+        }
+    }
+}
+
+@MainActor
+struct ProviderSettingsActionsRowView: View {
+    let descriptor: ProviderSettingsActionsDescriptor
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 8) {
+            Text(L(self.descriptor.title))
+                .font(.subheadline.weight(.semibold))
+
+            if !self.descriptor.subtitle.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
+                Text(L(self.descriptor.subtitle))
+                    .font(.footnote)
+                    .foregroundStyle(.secondary)
+                    .fixedSize(horizontal: false, vertical: true)
+            }
+
+            let actions = self.descriptor.actions.filter { $0.isVisible?() ?? true }
+            if !actions.isEmpty {
+                HStack(spacing: 10) {
+                    ForEach(actions) { action in
+                        Button(L(action.title)) {
                             Task { @MainActor in
                                 await action.perform()
                             }
@@ -205,14 +249,29 @@ struct ProviderSettingsTokenAccountsRowView: View {
     let descriptor: ProviderSettingsTokenAccountsDescriptor
     @State private var newLabel: String = ""
     @State private var newToken: String = ""
+    @State private var newOrgID: String = ""
 
     var body: some View {
-        VStack(alignment: .leading, spacing: 8) {
-            Text(self.descriptor.title)
-                .font(.subheadline.weight(.semibold))
+        VStack(alignment: .leading, spacing: 10) {
+            HStack(alignment: .center, spacing: 12) {
+                Text(L(self.descriptor.title))
+                    .font(.subheadline.weight(.semibold))
+                Spacer(minLength: 8)
+                if let title = self.descriptor.primaryAddActionTitle,
+                   let action = self.descriptor.primaryAddAction
+                {
+                    Button(L(title)) {
+                        Task { @MainActor in
+                            await action()
+                        }
+                    }
+                    .buttonStyle(.bordered)
+                    .controlSize(.small)
+                }
+            }
 
             if !self.descriptor.subtitle.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
-                Text(self.descriptor.subtitle)
+                Text(L(self.descriptor.subtitle))
                     .font(.footnote)
                     .foregroundStyle(.secondary)
                     .fixedSize(horizontal: false, vertical: true)
@@ -220,59 +279,90 @@ struct ProviderSettingsTokenAccountsRowView: View {
 
             let accounts = self.descriptor.accounts()
             if accounts.isEmpty {
-                Text("No token accounts yet.")
+                Text(L("No token accounts yet."))
                     .font(.footnote)
                     .foregroundStyle(.secondary)
             } else {
-                let selectedIndex = min(self.descriptor.activeIndex(), max(0, accounts.count - 1))
-                Picker("", selection: Binding(
-                    get: { selectedIndex },
-                    set: { index in self.descriptor.setActiveIndex(index) }))
-                {
-                    ForEach(Array(accounts.enumerated()), id: \.offset) { index, account in
-                        Text(account.displayName).tag(index)
-                    }
-                }
-                .labelsHidden()
-                .pickerStyle(.menu)
-                .controlSize(.small)
+                VStack(alignment: .leading, spacing: 8) {
+                    ForEach(Array(accounts.enumerated()), id: \.element.id) { index, account in
+                        HStack(alignment: .center, spacing: 10) {
+                            Button {
+                                self.descriptor.setActiveIndex(index)
+                            } label: {
+                                HStack(alignment: .center, spacing: 8) {
+                                    Image(systemName: self.isActive(index: index, accountCount: accounts.count) ?
+                                        "checkmark.circle.fill" : "circle")
+                                        .font(.system(size: 13, weight: .medium))
+                                        .foregroundStyle(self.isActive(index: index, accountCount: accounts.count) ?
+                                            Color.accentColor : Color.secondary)
+                                    Text(account.displayName)
+                                        .font(
+                                            .footnote.weight(
+                                                self.isActive(index: index, accountCount: accounts.count) ?
+                                                    .semibold : .regular))
+                                        .foregroundStyle(.primary)
+                                    Spacer(minLength: 0)
+                                }
+                                .contentShape(Rectangle())
+                            }
+                            .buttonStyle(.plain)
 
-                Button("Remove selected account") {
-                    let account = accounts[selectedIndex]
-                    self.descriptor.removeAccount(account.id)
+                            Button(L("Remove")) {
+                                self.descriptor.removeAccount(account.id)
+                            }
+                            .buttonStyle(.bordered)
+                            .controlSize(.small)
+                        }
+                        if index < accounts.count - 1 {
+                            Divider()
+                        }
+                    }
                 }
-                .buttonStyle(.bordered)
-                .controlSize(.small)
             }
 
-            HStack(spacing: 8) {
-                TextField("Label", text: self.$newLabel)
-                    .textFieldStyle(.roundedBorder)
-                    .font(.footnote)
-                SecureField(self.descriptor.placeholder, text: self.$newToken)
-                    .textFieldStyle(.roundedBorder)
-                    .font(.footnote)
-                Button("Add") {
-                    let label = self.newLabel.trimmingCharacters(in: .whitespacesAndNewlines)
-                    let token = self.newToken.trimmingCharacters(in: .whitespacesAndNewlines)
-                    guard !label.isEmpty, !token.isEmpty else { return }
-                    self.descriptor.addAccount(label, token)
-                    self.newLabel = ""
-                    self.newToken = ""
+            if self.descriptor.primaryAddAction == nil {
+                VStack(alignment: .leading, spacing: 6) {
+                    HStack(spacing: 8) {
+                        TextField(L("Label"), text: self.$newLabel)
+                            .textFieldStyle(.roundedBorder)
+                            .font(.footnote)
+                        SecureField(L(self.descriptor.placeholder), text: self.$newToken)
+                            .textFieldStyle(.roundedBorder)
+                            .font(.footnote)
+                        Button(L("Add")) {
+                            let label = self.newLabel.trimmingCharacters(in: .whitespacesAndNewlines)
+                            let token = self.newToken.trimmingCharacters(in: .whitespacesAndNewlines)
+                            guard !label.isEmpty, !token.isEmpty else { return }
+                            let orgID = self.descriptor.showsOrganizationField
+                                ? self.newOrgID.trimmingCharacters(in: .whitespacesAndNewlines)
+                                : ""
+                            self.descriptor.addAccount(label, token, orgID.isEmpty ? nil : orgID)
+                            self.newLabel = ""
+                            self.newToken = ""
+                            self.newOrgID = ""
+                        }
+                        .buttonStyle(.bordered)
+                        .controlSize(.small)
+                        .disabled(self.newLabel.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty ||
+                            self.newToken.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty)
+                    }
+                    if self.descriptor.showsOrganizationField {
+                        TextField(L("Org ID (optional)"), text: self.$newOrgID)
+                            .textFieldStyle(.roundedBorder)
+                            .font(.footnote)
+                            .help(
+                                L("Optional organization ID for accounts linked to multiple Anthropic organizations."))
+                    }
                 }
-                .buttonStyle(.bordered)
-                .controlSize(.small)
-                .disabled(self.newLabel.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty ||
-                    self.newToken.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty)
             }
 
             HStack(spacing: 10) {
-                Button("Open token file") {
+                Button(L("Open token file")) {
                     self.descriptor.openConfigFile()
                 }
                 .buttonStyle(.link)
                 .controlSize(.small)
-                Button("Reload") {
+                Button(L("Reload")) {
                     self.descriptor.reloadFromDisk()
                 }
                 .buttonStyle(.link)
@@ -280,6 +370,12 @@ struct ProviderSettingsTokenAccountsRowView: View {
             }
         }
     }
+
+    private func isActive(index: Int, accountCount: Int) -> Bool {
+        guard accountCount > 0 else { return false }
+        let selectedIndex = min(self.descriptor.activeIndex(), max(0, accountCount - 1))
+        return selectedIndex == index
+    }
 }
 
 extension View {
@@ -293,3 +389,79 @@ extension View {
         }
     }
 }
+
+@MainActor
+struct ProviderSettingsOrganizationsRowView: View {
+    let descriptor: ProviderSettingsOrganizationsDescriptor
+    @State private var errorMessage: String?
+    @State private var isRefreshing = false
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 10) {
+            HStack(alignment: .center, spacing: 12) {
+                Text(L(self.descriptor.title))
+                    .font(.subheadline.weight(.semibold))
+                Spacer(minLength: 8)
+            }
+
+            if let subtitle = self.descriptor.subtitle,
+               !subtitle.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+            {
+                Text(L(subtitle))
+                    .font(.footnote)
+                    .foregroundStyle(.secondary)
+                    .fixedSize(horizontal: false, vertical: true)
+            }
+
+            let entries = self.descriptor.entries()
+            if entries.allSatisfy(\.isLocked) {
+                Text(L("No organizations loaded. Click Refresh after setting your API key."))
+                    .font(.footnote)
+                    .foregroundStyle(.secondary)
+            } else {
+                VStack(alignment: .leading, spacing: 6) {
+                    ForEach(entries) { entry in
+                        Toggle(isOn: Binding(
+                            get: { entry.isEnabled },
+                            set: { newValue in
+                                self.descriptor.onToggle(entry.id, newValue)
+                            })) {
+                                VStack(alignment: .leading, spacing: 1) {
+                                    Text(entry.localizesTitle ? L(entry.title) : entry.title)
+                                        .font(.footnote)
+                                    if let subtitle = entry.subtitle,
+                                       !subtitle.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+                                    {
+                                        Text(entry.localizesSubtitle ? L(subtitle) : subtitle)
+                                            .font(.caption)
+                                            .foregroundStyle(.secondary)
+                                    }
+                                }
+                            }
+                            .toggleStyle(.checkbox)
+                                .disabled(entry.isLocked)
+                    }
+                }
+            }
+
+            HStack(spacing: 10) {
+                Button(L("Refresh organizations")) {
+                    Task { @MainActor in
+                        self.isRefreshing = true
+                        let result = await self.descriptor.onRefresh()
+                        self.isRefreshing = false
+                        self.errorMessage = result.success ? nil : result.errorMessage
+                    }
+                }
+                .buttonStyle(.bordered)
+                .controlSize(.small)
+                .disabled(!self.descriptor.canRefresh() || self.isRefreshing)
+                if let errorMessage = self.errorMessage, !errorMessage.isEmpty {
+                    Text(errorMessage)
+                        .font(.caption)
+                        .foregroundStyle(.red)
+                }
+            }
+        }
+    }
+}
diff --git a/Sources/CodexBar/PreferencesProviderSidebarView.swift b/Sources/CodexBar/PreferencesProviderSidebarView.swift
index ee34cb3e7c..899a62f950 100644
--- a/Sources/CodexBar/PreferencesProviderSidebarView.swift
+++ b/Sources/CodexBar/PreferencesProviderSidebarView.swift
@@ -1,3 +1,4 @@
+import AppKit
 import CodexBarCore
 import SwiftUI
 import UniformTypeIdentifiers
@@ -5,37 +6,68 @@ import UniformTypeIdentifiers
 @MainActor
 struct ProviderSidebarListView: View {
     let providers: [UsageProvider]
+    let orderedProviders: [UsageProvider]
     @Bindable var store: UsageStore
     let isEnabled: (UsageProvider) -> Binding<Bool>
     let subtitle: (UsageProvider) -> String
+    @Binding var searchText: String
     @Binding var selection: UsageProvider?
+    @Binding var sortAlphabetically: Bool
     let moveProviders: (IndexSet, Int) -> Void
     @State private var draggingProvider: UsageProvider?
 
     var body: some View {
-        List(selection: self.$selection) {
-            ForEach(self.providers, id: \.self) { provider in
-                ProviderSidebarRowView(
-                    provider: provider,
-                    store: self.store,
-                    isEnabled: self.isEnabled(provider),
-                    subtitle: self.subtitle(provider),
-                    draggingProvider: self.$draggingProvider)
-                    .tag(provider)
-                    .onDrop(
-                        of: [UTType.plainText],
-                        delegate: ProviderSidebarDropDelegate(
-                            item: provider,
-                            providers: self.providers,
-                            dragging: self.$draggingProvider,
-                            moveProviders: self.moveProviders))
+        VStack(spacing: 8) {
+            HStack(spacing: 6) {
+                ProviderSidebarSearchField(searchText: self.$searchText)
+                ProviderSidebarSortToggle(isOn: self.$sortAlphabetically)
+            }
+            .padding(.horizontal, 8)
+            .padding(.top, 8)
+
+            ScrollView {
+                VStack(spacing: 0) {
+                    if self.providers.isEmpty {
+                        Text(L("No matching providers"))
+                            .font(.caption)
+                            .foregroundStyle(.secondary)
+                            .frame(maxWidth: .infinity, minHeight: 80)
+                    }
+
+                    ForEach(self.providers, id: \.self) { provider in
+                        ProviderSidebarRowView(
+                            provider: provider,
+                            store: self.store,
+                            isEnabled: self.isEnabled(provider),
+                            subtitle: self.subtitle(provider),
+                            isSelected: self.selection == provider,
+                            showsReorderHandle: !self.sortAlphabetically,
+                            draggingProvider: self.$draggingProvider)
+                            .padding(.horizontal, 8)
+                            .background(
+                                RoundedRectangle(cornerRadius: 6, style: .continuous)
+                                    .fill(
+                                        self.selection == provider
+                                            ? Color(nsColor: .selectedContentBackgroundColor)
+                                            : Color.clear)
+                                    .padding(.horizontal, 4))
+                            .contentShape(Rectangle())
+                            .onTapGesture { self.selection = provider }
+                            .onDrop(
+                                of: [UTType.plainText],
+                                delegate: ProviderSidebarDropDelegate(
+                                    item: provider,
+                                    providers: self.orderedProviders,
+                                    dragging: self.$draggingProvider,
+                                    moveProviders: self.moveProviders))
+                    }
+                }
+                .padding(.vertical, 4)
             }
         }
-        .listStyle(.sidebar)
-        .scrollContentBackground(.hidden)
         .background(
             RoundedRectangle(cornerRadius: ProviderSettingsMetrics.sidebarCornerRadius, style: .continuous)
-                .fill(.regularMaterial))
+                .fill(Color(nsColor: .controlBackgroundColor).opacity(0.8)))
         .overlay(
             RoundedRectangle(cornerRadius: ProviderSettingsMetrics.sidebarCornerRadius, style: .continuous)
                 .stroke(Color(nsColor: .separatorColor).opacity(0.7), lineWidth: 1))
@@ -44,37 +76,109 @@ struct ProviderSidebarListView: View {
     }
 }
 
+private struct ProviderSidebarSearchField: View {
+    @Binding var searchText: String
+
+    var body: some View {
+        HStack(spacing: 6) {
+            Image(systemName: "magnifyingglass")
+                .foregroundStyle(.secondary)
+                .accessibilityHidden(true)
+
+            TextField(L("Search providers"), text: self.$searchText)
+                .textFieldStyle(.plain)
+
+            if !self.searchText.isEmpty {
+                Button {
+                    self.searchText = ""
+                } label: {
+                    Image(systemName: "xmark.circle.fill")
+                        .foregroundStyle(.secondary)
+                        .accessibilityLabel(L("Clear"))
+                }
+                .buttonStyle(.plain)
+            }
+        }
+        .font(.callout)
+        .padding(.horizontal, 8)
+        .padding(.vertical, 6)
+        .background(
+            RoundedRectangle(cornerRadius: 6, style: .continuous)
+                .fill(Color(nsColor: .textBackgroundColor)))
+        .overlay(
+            RoundedRectangle(cornerRadius: 6, style: .continuous)
+                .stroke(Color(nsColor: .separatorColor).opacity(0.7), lineWidth: 1))
+    }
+}
+
+private struct ProviderSidebarSortToggle: View {
+    @Binding var isOn: Bool
+
+    var body: some View {
+        Button {
+            self.isOn.toggle()
+        } label: {
+            Image(systemName: "arrow.up.arrow.down")
+                .font(.callout)
+                .foregroundStyle(self.isOn ? Color.accentColor : Color.secondary)
+                .frame(width: 28, height: 28)
+                .background(
+                    RoundedRectangle(cornerRadius: 6, style: .continuous)
+                        .fill(self.isOn
+                            ? Color.accentColor.opacity(0.15)
+                            : Color(nsColor: .textBackgroundColor)))
+                .overlay(
+                    RoundedRectangle(cornerRadius: 6, style: .continuous)
+                        .stroke(Color(nsColor: .separatorColor).opacity(0.7), lineWidth: 1))
+        }
+        .buttonStyle(.plain)
+        .help(self.isOn
+            ? L("Sorted alphabetically (enabled first) — click to use your custom order")
+            : L("Sort providers alphabetically (enabled first)"))
+        .accessibilityLabel(L("Sort providers alphabetically"))
+        .accessibilityAddTraits(self.isOn ? .isSelected : [])
+    }
+}
+
 @MainActor
 private struct ProviderSidebarRowView: View {
     let provider: UsageProvider
     @Bindable var store: UsageStore
     @Binding var isEnabled: Bool
     let subtitle: String
+    let isSelected: Bool
+    let showsReorderHandle: Bool
     @Binding var draggingProvider: UsageProvider?
 
     var body: some View {
         let isRefreshing = self.store.refreshingProviders.contains(self.provider)
         let showStatus = self.store.statusChecksEnabled
         let statusText = self.statusText
+        let palette = ProviderSidebarRowPalette(isSelected: self.isSelected)
 
         HStack(alignment: .center, spacing: 10) {
-            ProviderSidebarReorderHandle()
-                .contentShape(Rectangle())
-                .padding(.vertical, 4)
-                .padding(.horizontal, 2)
-                .help("Drag to reorder")
-                .onDrag {
-                    self.draggingProvider = self.provider
-                    return NSItemProvider(object: self.provider.rawValue as NSString)
-                }
+            if self.showsReorderHandle {
+                ProviderSidebarReorderHandle(color: palette.tertiary)
+                    .contentShape(Rectangle())
+                    .padding(.vertical, 4)
+                    .padding(.horizontal, 2)
+                    .help(L("Drag to reorder"))
+                    .onDrag {
+                        self.draggingProvider = self.provider
+                        return NSItemProvider(object: self.provider.rawValue as NSString)
+                    }
+            } else {
+                // Inset the icon a touch so rows don't hug the left edge once the drag handle is gone.
+                Color.clear.frame(width: 8, height: 1)
+            }
 
-            ProviderSidebarBrandIcon(provider: self.provider)
+            ProviderSidebarBrandIcon(provider: self.provider, color: palette.secondary)
 
             VStack(alignment: .leading, spacing: 2) {
                 HStack(spacing: 6) {
                     Text(self.store.metadata(for: self.provider).displayName)
                         .font(.subheadline.weight(.semibold))
-                        .foregroundStyle(.primary)
+                        .foregroundStyle(Color(nsColor: palette.primary))
 
                     if showStatus {
                         ProviderStatusDot(indicator: self.store.statusIndicator(for: self.provider))
@@ -87,7 +191,7 @@ private struct ProviderSidebarRowView: View {
                 }
                 Text(statusText)
                     .font(.caption)
-                    .foregroundStyle(.secondary)
+                    .foregroundStyle(Color(nsColor: palette.secondary))
                     .lineLimit(2)
                     .frame(height: ProviderSettingsMetrics.sidebarSubtitleHeight, alignment: .topLeading)
             }
@@ -99,6 +203,7 @@ private struct ProviderSidebarRowView: View {
                 .toggleStyle(.checkbox)
                 .controlSize(.small)
         }
+        .padding(.trailing, 6)
         .contentShape(Rectangle())
         .padding(.vertical, 2)
     }
@@ -109,13 +214,15 @@ private struct ProviderSidebarRowView: View {
         if lines.count >= 2 {
             let first = lines[0]
             let rest = lines.dropFirst().joined(separator: "\n")
-            return "Disabled — \(first)\n\(rest)"
+            return "\(L("Disabled")) — \(first)\n\(rest)"
         }
-        return "Disabled — \(self.subtitle)"
+        return "\(L("Disabled")) — \(self.subtitle)"
     }
 }
 
 private struct ProviderSidebarReorderHandle: View {
+    let color: NSColor
+
     var body: some View {
         VStack(spacing: ProviderSettingsMetrics.reorderDotSpacing) {
             ForEach(0..<3, id: \.self) { _ in
@@ -134,14 +241,15 @@ private struct ProviderSidebarReorderHandle: View {
         .frame(
             width: ProviderSettingsMetrics.reorderHandleSize,
             height: ProviderSettingsMetrics.reorderHandleSize)
-        .foregroundStyle(.tertiary)
-        .accessibilityLabel("Reorder")
+        .foregroundStyle(Color(nsColor: self.color))
+        .accessibilityLabel(L("Reorder"))
     }
 }
 
 @MainActor
 private struct ProviderSidebarBrandIcon: View {
     let provider: UsageProvider
+    let color: NSColor
 
     var body: some View {
         if let brand = ProviderBrandIcon.image(for: self.provider) {
@@ -149,17 +257,36 @@ private struct ProviderSidebarBrandIcon: View {
                 .resizable()
                 .scaledToFit()
                 .frame(width: ProviderSettingsMetrics.iconSize, height: ProviderSettingsMetrics.iconSize)
-                .foregroundStyle(.secondary)
+                .foregroundStyle(Color(nsColor: self.color))
                 .accessibilityHidden(true)
         } else {
             Image(systemName: "circle.dotted")
                 .font(.system(size: ProviderSettingsMetrics.iconSize, weight: .regular))
-                .foregroundStyle(.secondary)
+                .foregroundStyle(Color(nsColor: self.color))
                 .accessibilityHidden(true)
         }
     }
 }
 
+struct ProviderSidebarRowPalette {
+    let primary: NSColor
+    let secondary: NSColor
+    let tertiary: NSColor
+
+    init(isSelected: Bool) {
+        if isSelected {
+            let selectedText = NSColor.alternateSelectedControlTextColor
+            self.primary = selectedText
+            self.secondary = selectedText.withAlphaComponent(0.82)
+            self.tertiary = selectedText.withAlphaComponent(0.65)
+        } else {
+            self.primary = .labelColor
+            self.secondary = .secondaryLabelColor
+            self.tertiary = .tertiaryLabelColor
+        }
+    }
+}
+
 private struct ProviderSidebarDropDelegate: DropDelegate {
     let item: UsageProvider
     let providers: [UsageProvider]
diff --git a/Sources/CodexBar/PreferencesProvidersPane+Testing.swift b/Sources/CodexBar/PreferencesProvidersPane+Testing.swift
index e2dce0a7ff..607c91dc9d 100644
--- a/Sources/CodexBar/PreferencesProvidersPane+Testing.swift
+++ b/Sources/CodexBar/PreferencesProvidersPane+Testing.swift
@@ -11,10 +11,58 @@ extension ProvidersPane {
         self.providerSubtitle(provider)
     }
 
+    func _test_moveProviders(fromOffsets: IndexSet, toOffset: Int) {
+        self.moveProviders(fromOffsets: fromOffsets, toOffset: toOffset)
+    }
+
     func _test_menuBarMetricPicker(for provider: UsageProvider) -> ProviderSettingsPickerDescriptor? {
         self.menuBarMetricPicker(for: provider)
     }
 
+    func _test_settingsPickers(for provider: UsageProvider) -> [ProviderSettingsPickerDescriptor] {
+        guard let impl = ProviderCatalog.implementation(for: provider) else { return [] }
+        var statusTextByID: [String: String] = [:]
+        var lastAppActiveRunAtByID: [String: Date] = [:]
+        let context = ProviderSettingsContext(
+            provider: provider,
+            settings: self.settings,
+            store: self.store,
+            boolBinding: { keyPath in
+                Binding(
+                    get: { self.settings[keyPath: keyPath] },
+                    set: { self.settings[keyPath: keyPath] = $0 })
+            },
+            stringBinding: { keyPath in
+                Binding(
+                    get: { self.settings[keyPath: keyPath] },
+                    set: { self.settings[keyPath: keyPath] = $0 })
+            },
+            statusText: { id in
+                statusTextByID[id]
+            },
+            setStatusText: { id, text in
+                if let text {
+                    statusTextByID[id] = text
+                } else {
+                    statusTextByID.removeValue(forKey: id)
+                }
+            },
+            lastAppActiveRunAt: { id in
+                lastAppActiveRunAtByID[id]
+            },
+            setLastAppActiveRunAt: { id, date in
+                if let date {
+                    lastAppActiveRunAtByID[id] = date
+                } else {
+                    lastAppActiveRunAtByID.removeValue(forKey: id)
+                }
+            },
+            requestConfirmation: { _ in },
+            runLoginFlow: {})
+        return impl.settingsPickers(context: context)
+            .filter { $0.isVisible?() ?? true }
+    }
+
     func _test_tokenAccountDescriptor(for provider: UsageProvider) -> ProviderSettingsTokenAccountsDescriptor? {
         self.tokenAccountDescriptor(for: provider)
     }
@@ -22,6 +70,30 @@ extension ProvidersPane {
     func _test_menuCardModel(for provider: UsageProvider) -> UsageMenuCardView.Model {
         self.menuCardModel(for: provider)
     }
+
+    func _test_providerErrorDisplay(for provider: UsageProvider) -> ProviderErrorDisplay? {
+        self.providerErrorDisplay(provider)
+    }
+
+    func _test_codexAccountsSectionState() -> CodexAccountsSectionState? {
+        self.codexAccountsSectionState(for: .codex)
+    }
+
+    func _test_selectCodexVisibleAccount(id: String) async {
+        await self.selectCodexVisibleAccount(id: id)
+    }
+
+    func _test_addManagedCodexAccount() async {
+        await self.addManagedCodexAccount()
+    }
+
+    func _test_reauthenticateCodexAccount(_ account: CodexVisibleAccount) async {
+        await self.reauthenticateCodexAccount(account)
+    }
+
+    func _test_requestCodexSystemVisibleAccount(id: String) async {
+        await self.requestCodexSystemVisibleAccount(id: id)
+    }
 }
 
 @MainActor
@@ -52,6 +124,7 @@ enum ProvidersPaneTestHarness {
         settings.claudeCookieSource = .manual
         settings.cursorCookieSource = .manual
         settings.opencodeCookieSource = .manual
+        settings.opencodegoCookieSource = .manual
         settings.factoryCookieSource = .manual
         settings.minimaxCookieSource = .manual
         settings.augmentCookieSource = .manual
@@ -63,6 +136,7 @@ enum ProvidersPaneTestHarness {
         _ = pane._test_providerSubtitle(.claude)
         _ = pane._test_providerSubtitle(.cursor)
         _ = pane._test_providerSubtitle(.opencode)
+        _ = pane._test_providerSubtitle(.opencodego)
         _ = pane._test_providerSubtitle(.zai)
         _ = pane._test_providerSubtitle(.synthetic)
         _ = pane._test_providerSubtitle(.minimax)
@@ -100,7 +174,13 @@ enum ProvidersPaneTestHarness {
             errorDisplay: ProviderErrorDisplay(preview: "Preview", full: "Full"),
             isErrorExpanded: expandedBinding,
             onCopyError: { _ in },
-            onRefresh: {}).body
+            onRefresh: {},
+            showsSupplementarySettingsContent: true,
+            supplementarySettingsContent: {
+                ProviderSettingsSection(title: "Accounts") {
+                    Text("Supplementary")
+                }
+            }).body
     }
 
     private static func makeDescriptors() -> ProviderListTestDescriptors {
@@ -171,8 +251,11 @@ enum ProvidersPaneTestHarness {
             accounts: { [] },
             activeIndex: { 0 },
             setActiveIndex: { _ in },
-            addAccount: { _, _ in },
+            showsOrganizationField: false,
+            addAccount: { _, _, _ in },
             removeAccount: { _ in },
+            primaryAddActionTitle: nil,
+            primaryAddAction: nil,
             openConfigFile: {},
             reloadFromDisk: {})
 
diff --git a/Sources/CodexBar/PreferencesProvidersPane.swift b/Sources/CodexBar/PreferencesProvidersPane.swift
index 7a040dafd0..6dec38c951 100644
--- a/Sources/CodexBar/PreferencesProvidersPane.swift
+++ b/Sources/CodexBar/PreferencesProvidersPane.swift
@@ -6,29 +6,73 @@ import SwiftUI
 struct ProvidersPane: View {
     @Bindable var settings: SettingsStore
     @Bindable var store: UsageStore
+    let managedCodexAccountCoordinator: ManagedCodexAccountCoordinator
+    let codexAccountPromotionCoordinator: CodexAccountPromotionCoordinator
+    let codexAmbientLoginRunner: any CodexAmbientLoginRunning
+    let runProviderLoginFlow: @MainActor (UsageProvider) async -> Void
     @State private var expandedErrors: Set<UsageProvider> = []
     @State private var settingsStatusTextByID: [String: String] = [:]
     @State private var settingsLastAppActiveRunAtByID: [String: Date] = [:]
     @State private var activeConfirmation: ProviderSettingsConfirmationState?
+    @State private var codexAccountsNotice: CodexAccountsSectionNotice?
+    @State private var isAuthenticatingLiveCodexAccount = false
+    @State private var providerSearchText = ""
     @State private var selectedProvider: UsageProvider?
 
     private var providers: [UsageProvider] {
-        self.settings.orderedProviders()
+        guard self.settings.providersSortedAlphabetically else {
+            return self.settings.orderedProviders()
+        }
+        return CodexBarConfig.alphabeticalProviderOrder(enablement: { provider in
+            self.settings.isProviderEnabled(provider: provider, metadata: self.store.metadata(for: provider))
+        })
+    }
+
+    private var filteredProviders: [UsageProvider] {
+        Self.filteredProviders(
+            self.providers,
+            query: self.providerSearchText,
+            displayName: { provider in self.store.metadata(for: provider).displayName })
+    }
+
+    init(
+        settings: SettingsStore,
+        store: UsageStore,
+        managedCodexAccountCoordinator: ManagedCodexAccountCoordinator = ManagedCodexAccountCoordinator(),
+        codexAccountPromotionCoordinator: CodexAccountPromotionCoordinator? = nil,
+        codexAmbientLoginRunner: any CodexAmbientLoginRunning = DefaultCodexAmbientLoginRunner(),
+        runProviderLoginFlow: @escaping @MainActor (UsageProvider) async -> Void = { _ in })
+    {
+        self.settings = settings
+        self.store = store
+        self.managedCodexAccountCoordinator = managedCodexAccountCoordinator
+        self.codexAccountPromotionCoordinator = codexAccountPromotionCoordinator
+            ?? CodexAccountPromotionCoordinator(
+                settingsStore: settings,
+                usageStore: store,
+                managedAccountCoordinator: managedCodexAccountCoordinator)
+        self.codexAmbientLoginRunner = codexAmbientLoginRunner
+        self.runProviderLoginFlow = runProviderLoginFlow
     }
 
     var body: some View {
         HStack(alignment: .top, spacing: 16) {
             ProviderSidebarListView(
-                providers: self.providers,
+                providers: self.filteredProviders,
+                orderedProviders: self.providers,
                 store: self.store,
                 isEnabled: { provider in self.binding(for: provider) },
-                subtitle: { provider in self.providerSubtitle(provider) },
+                subtitle: { provider in self.providerSidebarSubtitle(provider) },
+                searchText: self.$providerSearchText,
                 selection: self.$selectedProvider,
+                sortAlphabetically: Binding(
+                    get: { self.settings.providersSortedAlphabetically },
+                    set: { self.settings.providersSortedAlphabetically = $0 }),
                 moveProviders: { fromOffsets, toOffset in
-                    self.settings.moveProvider(fromOffsets: fromOffsets, toOffset: toOffset)
+                    self.moveProviders(fromOffsets: fromOffsets, toOffset: toOffset)
                 })
 
-            if let provider = self.selectedProvider ?? self.providers.first {
+            if let provider = self.selectedVisibleProvider {
                 ProviderDetailView(
                     provider: provider,
                     store: self.store,
@@ -38,19 +82,47 @@ struct ProvidersPane: View {
                     settingsPickers: self.extraSettingsPickers(for: provider),
                     settingsToggles: self.extraSettingsToggles(for: provider),
                     settingsFields: self.extraSettingsFields(for: provider),
+                    settingsActions: self.extraSettingsActions(for: provider),
                     settingsTokenAccounts: self.tokenAccountDescriptor(for: provider),
+                    settingsOrganizations: self.extraSettingsOrganizations(for: provider),
                     errorDisplay: self.providerErrorDisplay(provider),
                     isErrorExpanded: self.expandedBinding(for: provider),
                     onCopyError: { text in self.copyToPasteboard(text) },
                     onRefresh: {
-                        Task { @MainActor in
-                            await ProviderInteractionContext.$current.withValue(.userInitiated) {
-                                await self.store.refreshProvider(provider, allowDisabled: true)
-                            }
+                        self.triggerRefresh(for: provider)
+                    },
+                    showsSupplementarySettingsContent: self.codexAccountsSectionState(for: provider) != nil,
+                    supplementarySettingsContent: {
+                        if let state = self.codexAccountsSectionState(for: provider) {
+                            CodexAccountsSectionView(
+                                state: state,
+                                setActiveVisibleAccount: { visibleAccountID in
+                                    Task { @MainActor in
+                                        await self.selectCodexVisibleAccount(id: visibleAccountID)
+                                    }
+                                },
+                                reauthenticateAccount: { account in
+                                    Task { @MainActor in
+                                        await self.reauthenticateCodexAccount(account)
+                                    }
+                                },
+                                removeAccount: { account in
+                                    self.requestManagedCodexAccountRemoval(account)
+                                },
+                                requestSystemVisibleAccount: { visibleAccountID in
+                                    Task { @MainActor in
+                                        await self.requestCodexSystemVisibleAccount(id: visibleAccountID)
+                                    }
+                                },
+                                addAccount: {
+                                    Task { @MainActor in
+                                        await self.addManagedCodexAccount()
+                                    }
+                                })
                         }
                     })
             } else {
-                Text("Select a provider")
+                Text(L("select_a_provider"))
                     .foregroundStyle(.secondary)
                     .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .center)
             }
@@ -62,6 +134,9 @@ struct ProvidersPane: View {
         .onChange(of: self.providers) { _, _ in
             self.ensureSelection()
         }
+        .onChange(of: self.providerSearchText) { _, _ in
+            self.ensureSelection()
+        }
         .onReceive(NotificationCenter.default.publisher(for: NSApplication.didBecomeActiveNotification)) { _ in
             self.runSettingsDidBecomeActiveHooks()
         }
@@ -78,7 +153,7 @@ struct ProvidersPane: View {
                         active.onConfirm()
                         self.activeConfirmation = nil
                     }
-                    Button("Cancel", role: .cancel) { self.activeConfirmation = nil }
+                    Button(L("cancel"), role: .cancel) { self.activeConfirmation = nil }
                 }
             },
             message: {
@@ -88,15 +163,55 @@ struct ProvidersPane: View {
             })
     }
 
+    private var selectedVisibleProvider: UsageProvider? {
+        let filteredProviders = self.filteredProviders
+        if let selected = self.selectedProvider, filteredProviders.contains(selected) {
+            return selected
+        }
+        return filteredProviders.first
+    }
+
+    static func filteredProviders(
+        _ providers: [UsageProvider],
+        query: String,
+        displayName: (UsageProvider) -> String) -> [UsageProvider]
+    {
+        let trimmedQuery = query.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmedQuery.isEmpty else { return providers }
+
+        return providers.filter { provider in
+            displayName(provider).localizedCaseInsensitiveContains(trimmedQuery)
+                || provider.rawValue.localizedCaseInsensitiveContains(trimmedQuery)
+        }
+    }
+
+    func moveProviders(fromOffsets: IndexSet, toOffset: Int) {
+        guard !self.settings.providersSortedAlphabetically else { return }
+        self.settings.moveProvider(fromOffsets: fromOffsets, toOffset: toOffset)
+    }
+
     private func ensureSelection() {
-        guard !self.providers.isEmpty else {
+        let filteredProviders = self.filteredProviders
+        guard !filteredProviders.isEmpty else {
             self.selectedProvider = nil
             return
         }
-        if let selected = self.selectedProvider, self.providers.contains(selected) {
+        if let selected = self.selectedProvider, filteredProviders.contains(selected) {
             return
         }
-        self.selectedProvider = self.providers.first
+        self.selectedProvider = filteredProviders.first
+    }
+
+    private func triggerRefresh(for provider: UsageProvider) {
+        Task { @MainActor in
+            await ProviderInteractionContext.$current.withValue(.userInitiated) {
+                if provider == .codex {
+                    await self.store.refreshCodexAccountScopedState(allowDisabled: true)
+                } else {
+                    await self.store.refreshProvider(provider, allowDisabled: true)
+                }
+            }
+        }
     }
 
     func binding(for provider: UsageProvider) -> Binding<Bool> {
@@ -115,9 +230,9 @@ struct ProvidersPane: View {
             let relative = snapshot.updatedAt.relativeDescription()
             usageText = relative
         } else if self.store.isStale(provider: provider) {
-            usageText = "last fetch failed"
+            usageText = L("last_fetch_failed")
         } else {
-            usageText = "usage not fetched yet"
+            usageText = L("usage_not_fetched_yet")
         }
 
         let presentationContext = ProviderPresentationContext(
@@ -133,11 +248,151 @@ struct ProvidersPane: View {
         return "\(detailLine)\n\(usageText)"
     }
 
-    private func providerErrorDisplay(_ provider: UsageProvider) -> ProviderErrorDisplay? {
-        guard let raw = self.store.error(for: provider), !raw.isEmpty else { return nil }
+    func providerSidebarSubtitle(_ provider: UsageProvider) -> String {
+        let meta = self.store.metadata(for: provider)
+        let usageText: String = if let snapshot = self.store.snapshot(for: provider) {
+            snapshot.updatedAt.relativeDescription()
+        } else if self.store.isStale(provider: provider) {
+            L("last_fetch_failed")
+        } else {
+            L("usage_not_fetched_yet")
+        }
+
+        let detailLine: String = if let sourceLabel = self.store.lastSourceLabels[provider], !sourceLabel.isEmpty {
+            sourceLabel
+        } else if let version = self.store.version(for: provider), !version.isEmpty {
+            "\(meta.cliName) \(version)"
+        } else {
+            meta.cliName
+        }
+
+        return "\(detailLine)\n\(usageText)"
+    }
+
+    func codexAccountsSectionState(for provider: UsageProvider) -> CodexAccountsSectionState? {
+        guard provider == .codex else { return nil }
+        let projection = self.settings.codexVisibleAccountProjection
+        let degradedNotice: CodexAccountsSectionNotice? = if projection.hasUnreadableAddedAccountStore {
+            CodexAccountsSectionNotice(
+                text: L("managed_account_storage_unreadable"),
+                tone: .warning)
+        } else {
+            nil
+        }
+
+        return CodexAccountsSectionState(
+            visibleAccounts: projection.visibleAccounts,
+            activeVisibleAccountID: projection.activeVisibleAccountID,
+            liveVisibleAccountID: projection.liveVisibleAccountID,
+            hasUnreadableManagedAccountStore: projection.hasUnreadableAddedAccountStore,
+            isAuthenticatingManagedAccount: self.managedCodexAccountCoordinator.isAuthenticatingManagedAccount,
+            authenticatingManagedAccountID: self.managedCodexAccountCoordinator.authenticatingManagedAccountID,
+            isRemovingManagedAccount: self.managedCodexAccountCoordinator.isRemovingManagedAccount,
+            isAuthenticatingLiveAccount: self.isAuthenticatingLiveCodexAccount,
+            isPromotingSystemAccount: self.codexAccountPromotionCoordinator.isPromotingSystemAccount,
+            notice: self.codexAccountsNotice ?? degradedNotice)
+    }
+
+    func selectCodexVisibleAccount(id: String) async {
+        self.codexAccountsNotice = nil
+        guard self.settings.selectCodexVisibleAccount(id: id) else { return }
+        await self.refreshCodexProvider()
+    }
+
+    func requestCodexSystemVisibleAccount(id: String) async {
+        self.codexAccountsNotice = nil
+        guard let account = self.settings.codexVisibleAccountProjection.visibleAccounts.first(where: { $0.id == id }),
+              let managedAccountID = account.storedAccountID
+        else {
+            return
+        }
+
+        let result = await self.codexAccountPromotionCoordinator.promote(managedAccountID: managedAccountID)
+        if case let .failure(error) = result {
+            self.codexAccountsNotice = CodexAccountsSectionNotice(text: error.message, tone: .warning)
+        }
+    }
+
+    func addManagedCodexAccount() async {
+        self.codexAccountsNotice = nil
+        guard let state = self.codexAccountsSectionState(for: .codex), state.canAddAccount else {
+            return
+        }
+
+        do {
+            let account = try await self.managedCodexAccountCoordinator.authenticateManagedAccount()
+            self.selectCodexVisibleAccountForAuthenticatedManagedAccount(account)
+            await self.refreshCodexProvider()
+        } catch {
+            self.codexAccountsNotice = self.codexAccountsNotice(for: error)
+        }
+    }
+
+    func reauthenticateCodexAccount(_ account: CodexVisibleAccount) async {
+        self.codexAccountsNotice = nil
+        if let accountID = account.storedAccountID {
+            guard let state = self.codexAccountsSectionState(for: .codex), state.canReauthenticate(account) else {
+                return
+            }
+            do {
+                _ = try await self.managedCodexAccountCoordinator
+                    .authenticateManagedAccount(existingAccountID: accountID)
+                await self.refreshCodexProvider()
+            } catch {
+                self.codexAccountsNotice = self.codexAccountsNotice(for: error)
+            }
+            return
+        }
+
+        guard let state = self.codexAccountsSectionState(for: .codex), state.canReauthenticate(account) else {
+            return
+        }
+
+        self.isAuthenticatingLiveCodexAccount = true
+        self.codexAccountPromotionCoordinator.setLiveReauthenticationInProgress(true)
+        defer {
+            self.isAuthenticatingLiveCodexAccount = false
+            self.codexAccountPromotionCoordinator.setLiveReauthenticationInProgress(false)
+        }
+
+        let result = await self.codexAmbientLoginRunner.run(timeout: 120)
+        if let info = CodexLoginAlertPresentation.alertInfo(for: result) {
+            self.presentLoginAlert(title: info.title, message: info.message)
+            return
+        }
+
+        await self.refreshCodexProvider()
+    }
+
+    func removeManagedCodexAccount(id: UUID) async {
+        self.codexAccountsNotice = nil
+        do {
+            try await self.managedCodexAccountCoordinator.removeManagedAccount(id: id)
+            await self.refreshCodexProvider()
+        } catch {
+            self.codexAccountsNotice = self.codexAccountsNotice(for: error)
+        }
+    }
+
+    func requestManagedCodexAccountRemoval(_ account: CodexVisibleAccount) {
+        guard let accountID = account.storedAccountID else { return }
+        self.activeConfirmation = ProviderSettingsConfirmationState(
+            title: L("remove_codex_account_title"),
+            message: String(format: L("remove_account_message"), account.email),
+            confirmTitle: L("remove"),
+            onConfirm: {
+                Task { @MainActor in
+                    await self.removeManagedCodexAccount(id: accountID)
+                }
+            })
+    }
+
+    func providerErrorDisplay(_ provider: UsageProvider) -> ProviderErrorDisplay? {
+        guard let full = self.store.error(for: provider), !full.isEmpty else { return nil }
+        let preview = self.store.userFacingError(for: provider) ?? full
         return ProviderErrorDisplay(
-            preview: self.truncated(raw, prefix: ""),
-            full: raw)
+            preview: self.truncated(preview, prefix: ""),
+            full: full)
     }
 
     private func extraSettingsToggles(for provider: UsageProvider) -> [ProviderSettingsToggleDescriptor] {
@@ -165,6 +420,21 @@ struct ProvidersPane: View {
             .filter { $0.isVisible?() ?? true }
     }
 
+    private func extraSettingsActions(for provider: UsageProvider) -> [ProviderSettingsActionsDescriptor] {
+        guard let impl = ProviderCatalog.implementation(for: provider) else { return [] }
+        let context = self.makeSettingsContext(provider: provider)
+        return impl.settingsActions(context: context)
+            .filter { $0.isVisible?() ?? true }
+    }
+
+    private func extraSettingsOrganizations(
+        for provider: UsageProvider) -> ProviderSettingsOrganizationsDescriptor?
+    {
+        guard let impl = ProviderCatalog.implementation(for: provider) else { return nil }
+        let context = self.makeSettingsContext(provider: provider)
+        return impl.settingsOrganizations(context: context)
+    }
+
     func tokenAccountDescriptor(for provider: UsageProvider) -> ProviderSettingsTokenAccountsDescriptor? {
         guard let support = TokenAccountSupportCatalog.support(for: provider) else { return nil }
         let context = self.makeSettingsContext(provider: provider)
@@ -193,8 +463,13 @@ struct ProvidersPane: View {
                     }
                 }
             },
-            addAccount: { label, token in
-                self.settings.addTokenAccount(provider: provider, label: label, token: token)
+            showsOrganizationField: provider == .claude,
+            addAccount: { label, token, organizationID in
+                self.settings.addTokenAccount(
+                    provider: provider,
+                    label: label,
+                    token: token,
+                    organizationID: organizationID)
                 Task { @MainActor in
                     await ProviderInteractionContext.$current.withValue(.userInitiated) {
                         await self.store.refreshProvider(provider, allowDisabled: true)
@@ -209,6 +484,13 @@ struct ProvidersPane: View {
                     }
                 }
             },
+            primaryAddActionTitle: provider == .copilot ? "Add Account" : nil,
+            primaryAddAction: provider == .copilot ? {
+                await CopilotLoginFlow.run(settings: self.settings)
+                await ProviderInteractionContext.$current.withValue(.userInitiated) {
+                    await self.store.refreshProvider(provider, allowDisabled: true)
+                }
+            } : nil,
             openConfigFile: {
                 self.settings.openTokenAccountsFile()
             },
@@ -259,44 +541,105 @@ struct ProvidersPane: View {
             },
             requestConfirmation: { confirmation in
                 self.activeConfirmation = ProviderSettingsConfirmationState(confirmation: confirmation)
+            },
+            runLoginFlow: {
+                await self.runProviderLoginFlow(provider)
             })
     }
 
     func menuBarMetricPicker(for provider: UsageProvider) -> ProviderSettingsPickerDescriptor? {
-        if provider == .zai { return nil }
         let options: [ProviderSettingsPickerOption]
         if provider == .openrouter {
             options = [
-                ProviderSettingsPickerOption(id: MenuBarMetricPreference.automatic.rawValue, title: "Automatic"),
+                ProviderSettingsPickerOption(id: MenuBarMetricPreference.automatic.rawValue, title: L("automatic")),
+                ProviderSettingsPickerOption(
+                    id: MenuBarMetricPreference.primary.rawValue,
+                    title: L("primary_api_key_limit")),
+            ]
+        } else if provider == .mistral {
+            options = [
+                ProviderSettingsPickerOption(
+                    id: MenuBarMetricPreference.automatic.rawValue,
+                    title: L("metric_mistral_payg")),
+                ProviderSettingsPickerOption(
+                    id: MenuBarMetricPreference.monthlyPlan.rawValue,
+                    title: L("metric_mistral_monthly_plan")),
+            ]
+        } else if SettingsStore.isBalanceOnlyProvider(provider) {
+            options = [
+                ProviderSettingsPickerOption(id: MenuBarMetricPreference.automatic.rawValue, title: L("Automatic")),
+            ]
+        } else if provider == .mimo {
+            let snapshot = self.store.snapshot(for: provider)
+            var metricOptions = [
+                ProviderSettingsPickerOption(id: MenuBarMetricPreference.automatic.rawValue, title: L("automatic")),
+            ]
+            if snapshot?.primary != nil, snapshot?.mimoUsage != nil {
+                metricOptions.append(ProviderSettingsPickerOption(
+                    id: MenuBarMetricPreference.primary.rawValue,
+                    title: String(format: L("metric_primary"), L("Credits"))))
+                metricOptions.append(ProviderSettingsPickerOption(
+                    id: MenuBarMetricPreference.secondary.rawValue,
+                    title: String(format: L("metric_secondary"), L("Balance"))))
+            }
+            options = metricOptions
+        } else if provider == .abacus {
+            let metadata = self.store.metadata(for: provider)
+            options = [
+                ProviderSettingsPickerOption(id: MenuBarMetricPreference.automatic.rawValue, title: L("automatic")),
                 ProviderSettingsPickerOption(
                     id: MenuBarMetricPreference.primary.rawValue,
-                    title: "Primary (API key limit)"),
+                    title: String(format: L("metric_primary"), metadata.sessionLabel)),
             ]
         } else {
             let metadata = self.store.metadata(for: provider)
+            let snapshot = self.store.snapshot(for: provider)
             let supportsAverage = self.settings.menuBarMetricSupportsAverage(for: provider)
+            let supportsPrimaryAndSecondary = self.settings.menuBarMetricSupportsPrimaryAndSecondary(for: provider)
+            let supportsTertiary = self.settings.menuBarMetricSupportsTertiary(for: provider, snapshot: snapshot)
+            let supportsExtraUsage = self.settings.menuBarMetricSupportsExtraUsage(for: provider, snapshot: snapshot)
             var metricOptions: [ProviderSettingsPickerOption] = [
-                ProviderSettingsPickerOption(id: MenuBarMetricPreference.automatic.rawValue, title: "Automatic"),
+                ProviderSettingsPickerOption(id: MenuBarMetricPreference.automatic.rawValue, title: L("automatic")),
                 ProviderSettingsPickerOption(
                     id: MenuBarMetricPreference.primary.rawValue,
-                    title: "Primary (\(metadata.sessionLabel))"),
+                    title: String(format: L("metric_primary"), metadata.sessionLabel)),
                 ProviderSettingsPickerOption(
                     id: MenuBarMetricPreference.secondary.rawValue,
-                    title: "Secondary (\(metadata.weeklyLabel))"),
+                    title: String(format: L("metric_secondary"), metadata.weeklyLabel)),
             ]
+            if supportsPrimaryAndSecondary {
+                metricOptions.append(ProviderSettingsPickerOption(
+                    id: MenuBarMetricPreference.primaryAndSecondary.rawValue,
+                    title: "\(L(metadata.sessionLabel)) + \(L(metadata.weeklyLabel))"))
+            }
+            if supportsTertiary {
+                let tertiaryTitle = metadata.opusLabel ?? MenuBarMetricPreference.tertiary.label
+                metricOptions.append(ProviderSettingsPickerOption(
+                    id: MenuBarMetricPreference.tertiary.rawValue,
+                    title: String(format: L("metric_tertiary"), tertiaryTitle)))
+            }
+            if supportsExtraUsage {
+                metricOptions.append(ProviderSettingsPickerOption(
+                    id: MenuBarMetricPreference.extraUsage.rawValue,
+                    title: MenuBarMetricPreference.extraUsage.label))
+            }
             if supportsAverage {
                 metricOptions.append(ProviderSettingsPickerOption(
                     id: MenuBarMetricPreference.average.rawValue,
-                    title: "Average (\(metadata.sessionLabel) + \(metadata.weeklyLabel))"))
+                    title: String(format: L("metric_average"), metadata.sessionLabel, metadata.weeklyLabel)))
             }
             options = metricOptions
         }
         return ProviderSettingsPickerDescriptor(
             id: "menuBarMetric",
-            title: "Menu bar metric",
-            subtitle: "Choose which window drives the menu bar percent.",
+            title: L("menu_bar_metric_title"),
+            subtitle: Self.menuBarMetricPickerSubtitle(for: provider),
             binding: Binding(
-                get: { self.settings.menuBarMetricPreference(for: provider).rawValue },
+                get: {
+                    self.settings
+                        .menuBarMetricPreference(for: provider, snapshot: self.store.snapshot(for: provider))
+                        .rawValue
+                },
                 set: { rawValue in
                     guard let preference = MenuBarMetricPreference(rawValue: rawValue) else { return }
                     self.settings.setMenuBarMetricPreference(preference, for: provider)
@@ -306,23 +649,43 @@ struct ProvidersPane: View {
             onChange: nil)
     }
 
+    private static func menuBarMetricPickerSubtitle(for provider: UsageProvider) -> String {
+        switch provider {
+        case .deepseek:
+            L("menu_bar_metric_subtitle_deepseek")
+        case .moonshot:
+            L("menu_bar_metric_subtitle_moonshot")
+        case .mistral:
+            L("menu_bar_metric_subtitle_mistral")
+        case .kimik2:
+            L("menu_bar_metric_subtitle_kimik2")
+        default:
+            L("menu_bar_metric_subtitle")
+        }
+    }
+
     func menuCardModel(for provider: UsageProvider) -> UsageMenuCardView.Model {
         let metadata = self.store.metadata(for: provider)
         let snapshot = self.store.snapshot(for: provider)
+        let now = Date()
+        let codexProjection = self.store.codexConsumerProjectionIfNeeded(
+            for: provider,
+            surface: .liveCard,
+            now: now)
         let credits: CreditsSnapshot?
         let creditsError: String?
         let dashboard: OpenAIDashboardSnapshot?
         let dashboardError: String?
         let tokenSnapshot: CostUsageTokenSnapshot?
         let tokenError: String?
-        if provider == .codex {
-            credits = self.store.credits
-            creditsError = self.store.lastCreditsError
-            dashboard = self.store.openAIDashboardRequiresLogin ? nil : self.store.openAIDashboard
-            dashboardError = self.store.lastOpenAIDashboardError
+        if let codexProjection {
+            credits = codexProjection.credits?.snapshot
+            creditsError = codexProjection.credits?.userFacingError
+            dashboard = nil
+            dashboardError = codexProjection.userFacingErrors.dashboard
             tokenSnapshot = self.store.tokenSnapshot(for: provider)
             tokenError = self.store.tokenError(for: provider)
-        } else if provider == .claude || provider == .vertexai {
+        } else if ProviderDescriptorRegistry.descriptor(for: provider).tokenCost.supportsTokenCost {
             credits = nil
             creditsError = nil
             dashboard = nil
@@ -338,33 +701,89 @@ struct ProvidersPane: View {
             tokenError = nil
         }
 
-        let now = Date()
-        let weeklyPace = snapshot?.secondary.flatMap { window in
-            self.store.weeklyPace(provider: provider, window: window, now: now)
+        // Abacus uses primary for monthly credits (no secondary window)
+        let paceWindow = provider == .abacus ? snapshot?.primary : snapshot?.secondary
+        let weeklyPace = if let codexProjection,
+                            let weekly = codexProjection.rateWindow(for: .weekly)
+        {
+            self.store.weeklyPace(provider: provider, window: weekly, now: now)
+        } else {
+            paceWindow.flatMap { window in
+                self.store.weeklyPace(provider: provider, window: window, now: now)
+            }
         }
         let input = UsageMenuCardView.Model.Input(
             provider: provider,
             metadata: metadata,
             snapshot: snapshot,
+            codexProjection: codexProjection,
             credits: credits,
             creditsError: creditsError,
             dashboard: dashboard,
             dashboardError: dashboardError,
             tokenSnapshot: tokenSnapshot,
             tokenError: tokenError,
-            account: self.store.accountInfo(),
+            account: self.store.accountInfo(for: provider),
             isRefreshing: self.store.refreshingProviders.contains(provider),
-            lastError: self.store.error(for: provider),
+            lastError: codexProjection?.userFacingErrors.usage ?? self.store.userFacingError(for: provider),
             usageBarsShowUsed: self.settings.usageBarsShowUsed,
             resetTimeDisplayStyle: self.settings.resetTimeDisplayStyle,
             tokenCostUsageEnabled: self.settings.isCostUsageEffectivelyEnabled(for: provider),
             showOptionalCreditsAndExtraUsage: self.settings.showOptionalCreditsAndExtraUsage,
+            copilotBudgetExtrasEnabled: self.settings.copilotBudgetExtrasEnabled,
             hidePersonalInfo: self.settings.hidePersonalInfo,
             weeklyPace: weeklyPace,
+            quotaWarningThresholds: [
+                .session: self.quotaWarningMarkerThresholds(provider: provider, window: .session),
+                .weekly: self.quotaWarningMarkerThresholds(provider: provider, window: .weekly),
+            ],
+            workDaysPerWeek: self.settings.weeklyProgressWorkDays,
             now: now)
         return UsageMenuCardView.Model.make(input)
     }
 
+    private func quotaWarningMarkerThresholds(provider: UsageProvider, window: QuotaWarningWindow) -> [Int] {
+        guard self.settings.quotaWarningMarkersVisible else { return [] }
+        guard self.settings.quotaWarningEnabled(provider: provider, window: window) else { return [] }
+        return self.settings.resolvedQuotaWarningThresholds(provider: provider, window: window)
+    }
+
+    private func refreshCodexProvider() async {
+        await ProviderInteractionContext.$current.withValue(.userInitiated) {
+            await self.store.refreshCodexAccountScopedState(allowDisabled: true)
+        }
+    }
+
+    private func selectCodexVisibleAccountForAuthenticatedManagedAccount(_ account: ManagedCodexAccount) {
+        self.settings.selectAuthenticatedManagedCodexAccount(account)
+    }
+
+    private func codexAccountsNotice(for error: Error) -> CodexAccountsSectionNotice {
+        if let error = error as? ManagedCodexAccountCoordinatorError,
+           error == .authenticationInProgress
+        {
+            return CodexAccountsSectionNotice(
+                text: L("managed_login_already_running"),
+                tone: .warning)
+        }
+
+        if let error = error as? ManagedCodexAccountServiceError {
+            return CodexAccountsSectionNotice(text: error.userFacingMessage, tone: .warning)
+        }
+
+        return CodexAccountsSectionNotice(
+            text: error.localizedDescription,
+            tone: .warning)
+    }
+
+    private func presentLoginAlert(title: String, message: String) {
+        let alert = NSAlert()
+        alert.messageText = L(title)
+        alert.informativeText = L(message)
+        alert.alertStyle = .warning
+        alert.runModal()
+    }
+
     private func runSettingsDidBecomeActiveHooks() {
         for provider in UsageProvider.allCases {
             for toggle in self.extraSettingsToggles(for: provider) {
@@ -412,10 +831,22 @@ struct ProviderSettingsConfirmationState: Identifiable {
     let confirmTitle: String
     let onConfirm: () -> Void
 
+    init(
+        title: String,
+        message: String,
+        confirmTitle: String,
+        onConfirm: @escaping () -> Void)
+    {
+        self.title = title
+        self.message = message
+        self.confirmTitle = confirmTitle
+        self.onConfirm = onConfirm
+    }
+
     init(confirmation: ProviderSettingsConfirmation) {
-        self.title = confirmation.title
-        self.message = confirmation.message
-        self.confirmTitle = confirmation.confirmTitle
+        self.title = L(confirmation.title)
+        self.message = L(confirmation.message)
+        self.confirmTitle = L(confirmation.confirmTitle)
         self.onConfirm = confirmation.onConfirm
     }
 }
diff --git a/Sources/CodexBar/PreferencesView.swift b/Sources/CodexBar/PreferencesView.swift
index a6f8939505..0816f0d42c 100644
--- a/Sources/CodexBar/PreferencesView.swift
+++ b/Sources/CodexBar/PreferencesView.swift
@@ -1,7 +1,8 @@
 import AppKit
+import CodexBarCore
 import SwiftUI
 
-enum PreferencesTab: String, Hashable {
+enum PreferencesTab: String, CaseIterable, Hashable {
     case general
     case providers
     case display
@@ -9,9 +10,20 @@ enum PreferencesTab: String, Hashable {
     case about
     case debug
 
-    static let defaultWidth: CGFloat = 496
-    static let providersWidth: CGFloat = 720
-    static let windowHeight: CGFloat = 580
+    static let defaultWidth: CGFloat = 546
+    static let providersWidth: CGFloat = 792
+    static let windowHeight: CGFloat = 662
+
+    var title: String {
+        switch self {
+        case .general: L("tab_general")
+        case .providers: L("tab_providers")
+        case .display: L("tab_display")
+        case .advanced: L("tab_advanced")
+        case .about: L("tab_about")
+        case .debug: L("tab_debug")
+        }
+    }
 
     var preferredWidth: CGFloat {
         self == .providers ? PreferencesTab.providersWidth : PreferencesTab.defaultWidth
@@ -22,58 +34,139 @@ enum PreferencesTab: String, Hashable {
     }
 }
 
+struct PreferencesTabLayoutCoordinator {
+    private(set) var bindingHandledTab: PreferencesTab?
+
+    mutating func beginBindingSelection(from current: PreferencesTab, to requested: PreferencesTab) -> Bool {
+        guard current != requested else { return false }
+        self.bindingHandledTab = requested
+        return true
+    }
+
+    mutating func layoutForObservedSelection(
+        _ observed: PreferencesTab,
+        current: PreferencesTab) -> PreferencesTab?
+    {
+        guard observed == current else { return nil }
+        defer { self.bindingHandledTab = nil }
+        return self.bindingHandledTab == observed ? nil : observed
+    }
+
+    func layoutForDeferredSelection(_ requested: PreferencesTab, current: PreferencesTab) -> PreferencesTab? {
+        current == requested ? requested : nil
+    }
+}
+
 @MainActor
 struct PreferencesView: View {
     @Bindable var settings: SettingsStore
     @Bindable var store: UsageStore
     let updater: UpdaterProviding
     @Bindable var selection: PreferencesSelection
+    let managedCodexAccountCoordinator: ManagedCodexAccountCoordinator
+    let codexAccountPromotionCoordinator: CodexAccountPromotionCoordinator
+    let runProviderLoginFlow: @MainActor (UsageProvider) async -> Void
+    @Environment(\.colorScheme) private var colorScheme
     @State private var contentWidth: CGFloat = PreferencesTab.general.preferredWidth
     @State private var contentHeight: CGFloat = PreferencesTab.general.preferredHeight
+    @State private var tabLayoutCoordinator = PreferencesTabLayoutCoordinator()
+
+    init(
+        settings: SettingsStore,
+        store: UsageStore,
+        updater: UpdaterProviding,
+        selection: PreferencesSelection,
+        managedCodexAccountCoordinator: ManagedCodexAccountCoordinator = ManagedCodexAccountCoordinator(),
+        codexAccountPromotionCoordinator: CodexAccountPromotionCoordinator? = nil,
+        runProviderLoginFlow: @escaping @MainActor (UsageProvider) async -> Void = { _ in })
+    {
+        self.settings = settings
+        self.store = store
+        self.updater = updater
+        self.selection = selection
+        self.managedCodexAccountCoordinator = managedCodexAccountCoordinator
+        self.codexAccountPromotionCoordinator = codexAccountPromotionCoordinator
+            ?? CodexAccountPromotionCoordinator(
+                settingsStore: settings,
+                usageStore: store,
+                managedAccountCoordinator: managedCodexAccountCoordinator)
+        self.runProviderLoginFlow = runProviderLoginFlow
+    }
 
     var body: some View {
-        TabView(selection: self.$selection.tab) {
+        TabView(selection: self.tabSelectionBinding) {
             GeneralPane(settings: self.settings, store: self.store)
-                .tabItem { Label("General", systemImage: "gearshape") }
+                .tabItem { Label(L("tab_general"), systemImage: "gearshape") }
                 .tag(PreferencesTab.general)
 
-            ProvidersPane(settings: self.settings, store: self.store)
-                .tabItem { Label("Providers", systemImage: "square.grid.2x2") }
+            ProvidersPane(
+                settings: self.settings,
+                store: self.store,
+                managedCodexAccountCoordinator: self.managedCodexAccountCoordinator,
+                codexAccountPromotionCoordinator: self.codexAccountPromotionCoordinator,
+                runProviderLoginFlow: self.runProviderLoginFlow)
+                .tabItem { Label(L("tab_providers"), systemImage: "square.grid.2x2") }
                 .tag(PreferencesTab.providers)
 
             DisplayPane(settings: self.settings, store: self.store)
-                .tabItem { Label("Display", systemImage: "eye") }
+                .tabItem { Label(L("tab_display"), systemImage: "eye") }
                 .tag(PreferencesTab.display)
 
             AdvancedPane(settings: self.settings)
-                .tabItem { Label("Advanced", systemImage: "slider.horizontal.3") }
+                .tabItem { Label(L("tab_advanced"), systemImage: "slider.horizontal.3") }
                 .tag(PreferencesTab.advanced)
 
             AboutPane(updater: self.updater)
-                .tabItem { Label("About", systemImage: "info.circle") }
+                .tabItem { Label(L("tab_about"), systemImage: "info.circle") }
                 .tag(PreferencesTab.about)
 
             if self.settings.debugMenuEnabled {
                 DebugPane(settings: self.settings, store: self.store)
-                    .tabItem { Label("Debug", systemImage: "ladybug") }
+                    .tabItem { Label(L("tab_debug"), systemImage: "ladybug") }
                     .tag(PreferencesTab.debug)
             }
         }
+        .id(self.settings.appLanguage)
         .padding(.horizontal, 24)
         .padding(.vertical, 16)
         .frame(width: self.contentWidth, height: self.contentHeight)
+        .background {
+            SettingsWindowAppearanceBridge(colorScheme: self.colorScheme)
+                .allowsHitTesting(false)
+        }
         .onAppear {
             self.updateLayout(for: self.selection.tab, animate: false)
             self.ensureValidTabSelection()
         }
         .onChange(of: self.selection.tab) { _, newValue in
-            self.updateLayout(for: newValue, animate: true)
+            guard let tab = self.tabLayoutCoordinator.layoutForObservedSelection(
+                newValue,
+                current: self.selection.tab)
+            else { return }
+            self.updateLayout(for: tab, animate: true)
         }
         .onChange(of: self.settings.debugMenuEnabled) { _, _ in
             self.ensureValidTabSelection()
         }
     }
 
+    private var tabSelectionBinding: Binding<PreferencesTab> {
+        Binding(
+            get: { self.selection.tab },
+            set: { newValue in
+                let oldValue = self.selection.tab
+                guard self.tabLayoutCoordinator.beginBindingSelection(from: oldValue, to: newValue) else { return }
+                self.selection.tab = newValue
+                Task { @MainActor in
+                    guard let tab = self.tabLayoutCoordinator.layoutForDeferredSelection(
+                        newValue,
+                        current: self.selection.tab)
+                    else { return }
+                    self.updateLayout(for: tab, animate: true)
+                }
+            })
+    }
+
     private func updateLayout(for tab: PreferencesTab, animate: Bool) {
         let change = {
             self.contentWidth = tab.preferredWidth
@@ -84,6 +177,28 @@ struct PreferencesView: View {
         } else {
             change()
         }
+        Self.resizeSettingsWindow(width: tab.preferredWidth, height: tab.preferredHeight, animate: animate)
+    }
+
+    private static let settingsWindowIdentifier = "com_apple_SwiftUI_Settings_window"
+    private static let knownTabTitles = Set(PreferencesTab.allCases.map(\.title))
+
+    private static func settingsWindow() -> NSWindow? {
+        NSApp.windows.first(where: {
+            $0.identifier?.rawValue == self.settingsWindowIdentifier
+                || self.knownTabTitles.contains($0.title)
+        })
+    }
+
+    private static func resizeSettingsWindow(width: CGFloat, height: CGFloat, animate: Bool) {
+        guard let window = settingsWindow() else { return }
+        let toolbarHeight = window.frame.height - window.contentLayoutRect.height
+        guard toolbarHeight > 0 else { return }
+        let newSize = NSSize(width: width, height: height + toolbarHeight)
+        var frame = window.frame
+        frame.origin.y += frame.size.height - newSize.height
+        frame.size = newSize
+        window.setFrame(frame, display: true, animate: animate)
     }
 
     private func ensureValidTabSelection() {
@@ -93,3 +208,76 @@ struct PreferencesView: View {
         }
     }
 }
+
+@MainActor
+enum SettingsWindowAppearance {
+    typealias ResetAction = @MainActor @Sendable () -> Void
+    typealias ResetScheduler = @MainActor @Sendable (@escaping ResetAction) -> Void
+
+    static func refresh(
+        _ window: NSWindow,
+        application: NSApplication = NSApp,
+        scheduleReset: ResetScheduler = Self.scheduleReset)
+    {
+        window.appearanceSource = application
+        // Pulse the exact effective appearance so the native toolbar redraws without
+        // dropping inherited accessibility attributes, then restore KVO inheritance.
+        window.appearance = application.effectiveAppearance
+        scheduleReset { [weak window] in
+            window?.appearance = nil
+            window?.viewsNeedDisplay = true
+        }
+    }
+
+    static func scheduleReset(_ action: @escaping ResetAction) {
+        Task { @MainActor in
+            await Task.yield()
+            action()
+        }
+    }
+}
+
+@MainActor
+struct SettingsWindowAppearanceBridge: NSViewRepresentable {
+    let colorScheme: ColorScheme
+
+    func makeNSView(context: Context) -> SettingsWindowAppearanceView {
+        SettingsWindowAppearanceView()
+    }
+
+    func updateNSView(_ nsView: SettingsWindowAppearanceView, context: Context) {
+        nsView.refreshWindowAppearance(for: self.colorScheme)
+    }
+}
+
+@MainActor
+final class SettingsWindowAppearanceView: NSView {
+    private let scheduleReset: SettingsWindowAppearance.ResetScheduler
+    private var colorScheme: ColorScheme?
+
+    init(scheduleReset: @escaping SettingsWindowAppearance.ResetScheduler = SettingsWindowAppearance.scheduleReset) {
+        self.scheduleReset = scheduleReset
+        super.init(frame: .zero)
+    }
+
+    @available(*, unavailable)
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    override func viewDidMoveToWindow() {
+        super.viewDidMoveToWindow()
+        self.refreshWindowAppearance()
+    }
+
+    func refreshWindowAppearance(for colorScheme: ColorScheme) {
+        guard self.colorScheme != colorScheme else { return }
+        self.colorScheme = colorScheme
+        self.refreshWindowAppearance()
+    }
+
+    private func refreshWindowAppearance() {
+        guard let window else { return }
+        SettingsWindowAppearance.refresh(window, scheduleReset: self.scheduleReset)
+    }
+}
diff --git a/Sources/CodexBar/ProviderBrandIcon.swift b/Sources/CodexBar/ProviderBrandIcon.swift
index d07477e693..844e46770f 100644
--- a/Sources/CodexBar/ProviderBrandIcon.swift
+++ b/Sources/CodexBar/ProviderBrandIcon.swift
@@ -1,11 +1,16 @@
 import AppKit
 import CodexBarCore
 
+@MainActor
 enum ProviderBrandIcon {
     private static let size = NSSize(width: 16, height: 16)
+    private static var cache: [UsageProvider: NSImage] = [:]
 
     /// Lazy-loaded resource bundle for provider icons.
     private static let resourceBundle: Bundle? = {
+        guard Bundle.main.bundleURL.pathExtension == "app" else {
+            return Bundle.module
+        }
         // SwiftPM creates a CodexBar_CodexBar.bundle for resources in the CodexBar target.
         if let bundleURL = Bundle.main.url(forResource: "CodexBar_CodexBar", withExtension: "bundle"),
            let bundle = Bundle(url: bundleURL)
@@ -17,9 +22,15 @@ enum ProviderBrandIcon {
     }()
 
     static func image(for provider: UsageProvider) -> NSImage? {
+        if let cached = self.cache[provider] {
+            return cached
+        }
+
         let baseName = ProviderDescriptorRegistry.descriptor(for: provider).branding.iconResourceName
-        guard let bundle = self.resourceBundle,
-              let url = bundle.url(forResource: baseName, withExtension: "svg"),
+        guard let bundle = self.resourceBundle else {
+            return nil
+        }
+        guard let url = bundle.url(forResource: baseName, withExtension: "svg"),
               let image = NSImage(contentsOf: url)
         else {
             return nil
@@ -27,6 +38,11 @@ enum ProviderBrandIcon {
 
         image.size = self.size
         image.isTemplate = true
+        self.cache[provider] = image
         return image
     }
+
+    static func resetCacheForTesting() {
+        self.cache.removeAll()
+    }
 }
diff --git a/Sources/CodexBar/ProviderRefreshCoordinator.swift b/Sources/CodexBar/ProviderRefreshCoordinator.swift
new file mode 100644
index 0000000000..2ebc29c116
--- /dev/null
+++ b/Sources/CodexBar/ProviderRefreshCoordinator.swift
@@ -0,0 +1,183 @@
+import Foundation
+
+@MainActor
+final class ProviderRefreshCoordinator<Key: Hashable> {
+    enum WaitResult: Equatable {
+        case completed
+        case retryRequired
+        case cancelled
+    }
+
+    struct Request {
+        let generation: UInt64
+        let state: ProviderRefreshTaskState
+        let predecessorStates: [ProviderRefreshTaskState]
+    }
+
+    private var states: [Key: [ProviderRefreshTaskState]] = [:]
+    private var latestGenerations: [Key: UInt64] = [:]
+    private var activeCounts: [Key: Int] = [:]
+    private var nextGeneration: UInt64 = 0
+    private var nextWaiterID: UInt64 = 0
+
+    func coalescingState(for key: Key) -> ProviderRefreshTaskState? {
+        guard let latestGeneration = self.latestGenerations[key] else { return nil }
+        return self.states[key]?.last { $0.generation == latestGeneration }
+    }
+
+    func beginReplacingRequest(for key: Key) -> Request {
+        self.nextGeneration &+= 1
+        let generation = self.nextGeneration
+        let predecessorStates = self.states[key] ?? []
+        for predecessorState in predecessorStates {
+            predecessorState.cancelTask()
+        }
+        self.latestGenerations[key] = generation
+        let state = ProviderRefreshTaskState(generation: generation)
+        self.states[key, default: []].append(state)
+        return Request(
+            generation: generation,
+            state: state,
+            predecessorStates: predecessorStates)
+    }
+
+    func wait(for key: Key, state: ProviderRefreshTaskState) async -> WaitResult {
+        self.nextWaiterID &+= 1
+        let waiterID = self.nextWaiterID
+        guard let task = state.addWaiter(waiterID) else { return .completed }
+        await withTaskCancellationHandler {
+            await task.value
+        } onCancel: {
+            state.cancelWaiter(waiterID)
+        }
+        state.finishWaiter(waiterID)
+        let result: WaitResult = if Task.isCancelled {
+            .cancelled
+        } else if state.shouldRetry {
+            .retryRequired
+        } else {
+            .completed
+        }
+        if state.canRemove {
+            self.scheduleRemoval(for: key, state: state)
+        }
+        return result
+    }
+
+    func complete(_ state: ProviderRefreshTaskState, for key: Key, retryRequired: Bool) {
+        state.markCompleted(retryRequired: retryRequired)
+        self.scheduleRemoval(for: key, state: state)
+    }
+
+    func remove(_ state: ProviderRefreshTaskState, for key: Key) {
+        guard var keyStates = self.states[key] else { return }
+        keyStates.removeAll { $0 === state }
+        if keyStates.isEmpty {
+            self.states.removeValue(forKey: key)
+        } else {
+            self.states[key] = keyStates
+        }
+    }
+
+    func isCurrent(_ generation: UInt64, for key: Key) -> Bool {
+        self.latestGenerations[key] == generation
+    }
+
+    @discardableResult
+    func beginActivity(for key: Key) -> Bool {
+        self.activeCounts[key, default: 0] += 1
+        return self.activeCounts[key] == 1
+    }
+
+    @discardableResult
+    func endActivity(for key: Key) -> Bool {
+        let remaining = max(0, self.activeCounts[key, default: 1] - 1)
+        if remaining == 0 {
+            self.activeCounts.removeValue(forKey: key)
+            return true
+        }
+        self.activeCounts[key] = remaining
+        return false
+    }
+
+    private func scheduleRemoval(for key: Key, state: ProviderRefreshTaskState) {
+        Task { @MainActor [weak self] in
+            await Task.yield()
+            guard let self,
+                  self.states[key]?.contains(where: { $0 === state }) == true,
+                  state.canRemove
+            else {
+                return
+            }
+            self.remove(state, for: key)
+        }
+    }
+}
+
+final class ProviderRefreshTaskState: @unchecked Sendable {
+    let generation: UInt64
+
+    private let lock = NSLock()
+    private var task: Task<Void, Never>?
+    private var waiterIDs: Set<UInt64> = []
+    private var completed = false
+    private var retryRequired = false
+
+    init(generation: UInt64) {
+        self.generation = generation
+    }
+
+    func install(task: Task<Void, Never>) {
+        self.lock.withLock {
+            self.task = task
+        }
+    }
+
+    func addWaiter(_ waiterID: UInt64) -> Task<Void, Never>? {
+        self.lock.withLock {
+            self.waiterIDs.insert(waiterID)
+            return self.task
+        }
+    }
+
+    func cancelWaiter(_ waiterID: UInt64) {
+        let taskToCancel = self.lock.withLock {
+            guard self.waiterIDs.remove(waiterID) != nil else { return nil as Task<Void, Never>? }
+            return self.waiterIDs.isEmpty && !self.completed ? self.task : nil
+        }
+        taskToCancel?.cancel()
+    }
+
+    func finishWaiter(_ waiterID: UInt64) {
+        _ = self.lock.withLock {
+            self.waiterIDs.remove(waiterID)
+        }
+    }
+
+    func markCompleted(retryRequired: Bool) {
+        self.lock.withLock {
+            self.completed = true
+            self.retryRequired = retryRequired
+        }
+    }
+
+    func cancelTask() {
+        let task = self.lock.withLock {
+            self.completed ? nil : self.task
+        }
+        task?.cancel()
+    }
+
+    func waitForTaskCompletion() async {
+        let task = self.lock.withLock { self.task }
+        await task?.value
+    }
+
+    fileprivate var shouldRetry: Bool {
+        self.lock.withLock { self.retryRequired }
+    }
+
+    var canRemove: Bool {
+        self.lock.withLock { self.completed && self.waiterIDs.isEmpty }
+    }
+}
diff --git a/Sources/CodexBar/ProviderRegistry.swift b/Sources/CodexBar/ProviderRegistry.swift
index 1e26c4c86b..847c477d4b 100644
--- a/Sources/CodexBar/ProviderRegistry.swift
+++ b/Sources/CodexBar/ProviderRegistry.swift
@@ -23,7 +23,8 @@ struct ProviderRegistry {
         metadata: [UsageProvider: ProviderMetadata],
         codexFetcher: UsageFetcher,
         claudeFetcher: any ClaudeUsageFetching,
-        browserDetection: BrowserDetection) -> [UsageProvider: ProviderSpec]
+        browserDetection: BrowserDetection,
+        environmentBase: [String: String] = ProcessInfo.processInfo.environment) -> [UsageProvider: ProviderSpec]
     {
         var specs: [UsageProvider: ProviderSpec] = [:]
         specs.reserveCapacity(UsageProvider.allCases.count)
@@ -36,28 +37,54 @@ struct ProviderRegistry {
                 isEnabled: { settings.isProviderEnabled(provider: provider, metadata: meta) },
                 descriptor: descriptor,
                 makeFetchContext: {
+                    let account = ProviderTokenAccountSelection.selectedAccount(
+                        provider: provider,
+                        settings: settings,
+                        override: nil)
                     let sourceMode = ProviderCatalog.implementation(for: provider)?
                         .sourceMode(context: ProviderSourceModeContext(provider: provider, settings: settings))
                         ?? .auto
                     let snapshot = Self.makeSettingsSnapshot(settings: settings, tokenOverride: nil)
                     let env = Self.makeEnvironment(
-                        base: ProcessInfo.processInfo.environment,
+                        base: environmentBase,
                         provider: provider,
                         settings: settings,
                         tokenOverride: nil)
+                    let fetcher = Self.makeFetcher(base: codexFetcher, provider: provider, env: env)
                     let verbose = settings.isVerboseLoggingEnabled
                     return ProviderFetchContext(
                         runtime: .app,
                         sourceMode: sourceMode,
                         includeCredits: false,
+                        includeOptionalUsage: settings.showOptionalCreditsAndExtraUsage,
                         webTimeout: 60,
                         webDebugDumpHTML: false,
                         verbose: verbose,
                         env: env,
                         settings: snapshot,
-                        fetcher: codexFetcher,
+                        fetcher: fetcher,
                         claudeFetcher: claudeFetcher,
-                        browserDetection: browserDetection)
+                        browserDetection: browserDetection,
+                        selectedTokenAccountID: account?.id,
+                        tokenAccountTokenUpdater: { provider, accountID, token in
+                            await MainActor.run {
+                                settings.updateTokenAccount(
+                                    provider: provider,
+                                    accountID: accountID,
+                                    token: token)
+                            }
+                        },
+                        providerManualTokenUpdater: { provider, token in
+                            await MainActor.run {
+                                if provider == .stepfun {
+                                    settings.stepfunToken = token
+                                }
+                            }
+                        },
+                        costUsageHistoryDays: settings.costUsageHistoryDays,
+                        persistsCLISessions: true,
+                        persistentCLISessionIdleWindow: Self.persistentCLISessionIdleWindow(
+                            refreshInterval: settings.refreshFrequency.seconds))
                 })
             specs[provider] = spec
         }
@@ -65,16 +92,24 @@ struct ProviderRegistry {
         return specs
     }
 
+    static func persistentCLISessionIdleWindow(refreshInterval: TimeInterval?) -> TimeInterval {
+        max(180, (refreshInterval ?? 120) + 60)
+    }
+
     @MainActor
     static func makeSettingsSnapshot(
         settings: SettingsStore,
-        tokenOverride: TokenAccountOverride?) -> ProviderSettingsSnapshot
+        tokenOverride: TokenAccountOverride?,
+        codexActiveSourceOverride: CodexActiveSource? = nil) -> ProviderSettingsSnapshot
     {
         settings.ensureTokenAccountsLoaded()
         var builder = ProviderSettingsSnapshotBuilder(
             debugMenuEnabled: settings.debugMenuEnabled,
             debugKeepCLISessionsAlive: settings.debugKeepCLISessionsAlive)
-        let context = ProviderSettingsSnapshotContext(settings: settings, tokenOverride: tokenOverride)
+        let context = ProviderSettingsSnapshotContext(
+            settings: settings,
+            tokenOverride: tokenOverride,
+            codexActiveSourceOverride: codexActiveSourceOverride)
         for implementation in ProviderCatalog.all {
             if let contribution = implementation.settingsSnapshot(context: context) {
                 builder.apply(contribution)
@@ -88,25 +123,37 @@ struct ProviderRegistry {
         base: [String: String],
         provider: UsageProvider,
         settings: SettingsStore,
-        tokenOverride: TokenAccountOverride?) -> [String: String]
+        tokenOverride: TokenAccountOverride?,
+        codexActiveSourceOverride: CodexActiveSource? = nil) -> [String: String]
     {
         let account = ProviderTokenAccountSelection.selectedAccount(
             provider: provider,
             settings: settings,
             override: tokenOverride)
-        var env = ProviderConfigEnvironment.applyAPIKeyOverride(
+        var env = ProviderEnvironmentResolver.resolve(
             base: base,
             provider: provider,
-            config: settings.providerConfig(for: provider))
-        // If token account is selected, use its token instead of config's apiKey
-        if let account, let override = TokenAccountSupportCatalog.envOverride(
-            for: provider,
-            token: account.token)
-        {
-            for (key, value) in override {
-                env[key] = value
+            config: settings.providerConfig(for: provider),
+            selectedAccount: account)
+        // Codex account routing scopes remote account fetches such as identity, plan,
+        // quotas, and dashboard data. Token-cost/session history is intentionally handled
+        // separately because it is provider-level local telemetry from this Mac's Codex sessions,
+        // not account-owned remote state.
+        if provider == .codex {
+            let codexActiveSource = codexActiveSourceOverride ?? settings.codexResolvedActiveSource
+            if let managedHomePath = settings.managedCodexRemoteHomePath(forActiveSource: codexActiveSource) {
+                env = CodexHomeScope.scopedEnvironment(base: env, codexHome: managedHomePath)
+            } else if let liveHomePath = settings.liveSystemCodexHomePath(forActiveSource: codexActiveSource) {
+                env = CodexHomeScope.scopedEnvironment(base: env, codexHome: liveHomePath)
+            } else if let profileHomePath = settings.profileCodexHomePath(forActiveSource: codexActiveSource) {
+                env = CodexHomeScope.scopedEnvironment(base: env, codexHome: profileHomePath)
             }
         }
         return env
     }
+
+    static func makeFetcher(base: UsageFetcher, provider: UsageProvider, env: [String: String]) -> UsageFetcher {
+        guard provider == .codex else { return base }
+        return UsageFetcher(environment: env)
+    }
 }
diff --git a/Sources/CodexBar/ProviderSwitcherButtons.swift b/Sources/CodexBar/ProviderSwitcherButtons.swift
index 05ce53c538..1779621933 100644
--- a/Sources/CodexBar/ProviderSwitcherButtons.swift
+++ b/Sources/CodexBar/ProviderSwitcherButtons.swift
@@ -34,7 +34,7 @@ final class InlineIconToggleButton: NSButton {
             self.paddingConstraints.first { $0.firstAttribute == .top }?.constant = self.contentPadding.top
             self.paddingConstraints.first { $0.firstAttribute == .leading }?.constant = self.contentPadding.left
             self.paddingConstraints.first { $0.firstAttribute == .trailing }?.constant = -self.contentPadding.right
-            self.paddingConstraints.first { $0.firstAttribute == .bottom }?.constant = -(self.contentPadding.bottom + 4)
+            self.paddingConstraints.first { $0.firstAttribute == .bottom }?.constant = -self.contentPadding.bottom
             if !self.isConfiguring { self.invalidateIntrinsicContentSize() }
         }
     }
@@ -47,6 +47,7 @@ final class InlineIconToggleButton: NSButton {
             super.attributedTitle = NSAttributedString(string: "")
             super.attributedAlternateTitle = NSAttributedString(string: "")
             self.titleField.stringValue = newValue
+            self.setAccessibilityLabel(newValue)
             if !self.isConfiguring { self.invalidateIntrinsicContentSize() }
         }
     }
@@ -108,6 +109,7 @@ final class InlineIconToggleButton: NSButton {
         self.setButtonType(.toggle)
         self.controlSize = .small
         self.wantsLayer = true
+        self.setAccessibilityRole(.button)
 
         self.iconView.imageScaling = .scaleNone
         self.iconView.translatesAutoresizingMaskIntoConstraints = false
@@ -131,7 +133,7 @@ final class InlineIconToggleButton: NSButton {
         self.iconSizeConstraints = [iconWidth, iconHeight]
 
         let top = self.stack.topAnchor.constraint(
-            equalTo: self.topAnchor,
+            greaterThanOrEqualTo: self.topAnchor,
             constant: self.contentPadding.top)
         let leading = self.stack.leadingAnchor.constraint(
             greaterThanOrEqualTo: self.leadingAnchor,
@@ -141,10 +143,11 @@ final class InlineIconToggleButton: NSButton {
             constant: -self.contentPadding.right)
         let centerX = self.stack.centerXAnchor.constraint(equalTo: self.centerXAnchor)
         centerX.priority = .defaultHigh
+        let centerY = self.stack.centerYAnchor.constraint(equalTo: self.centerYAnchor)
         let bottom = self.stack.bottomAnchor.constraint(
             lessThanOrEqualTo: self.bottomAnchor,
-            constant: -(self.contentPadding.bottom + 4))
-        self.paddingConstraints = [top, leading, trailing, bottom, centerX]
+            constant: -self.contentPadding.bottom)
+        self.paddingConstraints = [top, leading, trailing, bottom, centerX, centerY]
 
         NSLayoutConstraint.activate(self.paddingConstraints + self.iconSizeConstraints)
     }
@@ -176,6 +179,7 @@ final class StackedToggleButton: NSButton {
             super.attributedTitle = NSAttributedString(string: "")
             super.attributedAlternateTitle = NSAttributedString(string: "")
             self.titleField.stringValue = newValue
+            self.setAccessibilityLabel(newValue)
             if !self.isConfiguring { self.invalidateIntrinsicContentSize() }
         }
     }
@@ -237,6 +241,7 @@ final class StackedToggleButton: NSButton {
         self.setButtonType(.toggle)
         self.controlSize = .small
         self.wantsLayer = true
+        self.setAccessibilityRole(.button)
 
         self.iconView.imageScaling = .scaleNone
         self.iconView.translatesAutoresizingMaskIntoConstraints = false
@@ -259,11 +264,9 @@ final class StackedToggleButton: NSButton {
         let iconHeight = self.iconView.heightAnchor.constraint(equalToConstant: 16)
         self.iconSizeConstraints = [iconWidth, iconHeight]
 
-        // Avoid subpixel centering: pin from the top so the icon sits on whole-point coordinates.
         // Force an even layout width (button width minus padding) so the icon doesn't land on 0.5pt centers.
-        // Reserve some bottom space for the "weekly remaining" indicator line.
         let top = self.stack.topAnchor.constraint(
-            equalTo: self.topAnchor,
+            greaterThanOrEqualTo: self.topAnchor,
             constant: self.contentPadding.top)
         let leading = self.stack.leadingAnchor.constraint(
             equalTo: self.leadingAnchor,
@@ -273,8 +276,9 @@ final class StackedToggleButton: NSButton {
             constant: -self.contentPadding.right)
         let bottom = self.stack.bottomAnchor.constraint(
             lessThanOrEqualTo: self.bottomAnchor,
-            constant: -(self.contentPadding.bottom + 4))
-        self.paddingConstraints = [top, leading, trailing, bottom]
+            constant: -self.contentPadding.bottom)
+        let centerY = self.stack.centerYAnchor.constraint(equalTo: self.centerYAnchor)
+        self.paddingConstraints = [top, leading, trailing, bottom, centerY]
 
         NSLayoutConstraint.activate(self.paddingConstraints + self.iconSizeConstraints)
     }
diff --git a/Sources/CodexBar/Providers/Abacus/AbacusProviderImplementation.swift b/Sources/CodexBar/Providers/Abacus/AbacusProviderImplementation.swift
new file mode 100644
index 0000000000..6a4fc26c57
--- /dev/null
+++ b/Sources/CodexBar/Providers/Abacus/AbacusProviderImplementation.swift
@@ -0,0 +1,98 @@
+import AppKit
+import CodexBarCore
+import Foundation
+import SwiftUI
+
+struct AbacusProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .abacus
+
+    @MainActor
+    func observeSettings(_ settings: SettingsStore) {
+        _ = settings.abacusCookieSource
+        _ = settings.abacusCookieHeader
+    }
+
+    @MainActor
+    func settingsSnapshot(context: ProviderSettingsSnapshotContext) -> ProviderSettingsSnapshotContribution? {
+        .abacus(context.settings.abacusSettingsSnapshot(tokenOverride: context.tokenOverride))
+    }
+
+    @MainActor
+    func tokenAccountsVisibility(context: ProviderSettingsContext, support: TokenAccountSupport) -> Bool {
+        guard support.requiresManualCookieSource else { return true }
+        if !context.settings.tokenAccounts(for: context.provider).isEmpty { return true }
+        return context.settings.abacusCookieSource == .manual
+    }
+
+    @MainActor
+    func applyTokenAccountCookieSource(settings: SettingsStore) {
+        if settings.abacusCookieSource != .manual {
+            settings.abacusCookieSource = .manual
+        }
+    }
+
+    @MainActor
+    func settingsPickers(context: ProviderSettingsContext) -> [ProviderSettingsPickerDescriptor] {
+        let cookieBinding = Binding(
+            get: { context.settings.abacusCookieSource.rawValue },
+            set: { raw in
+                context.settings.abacusCookieSource = ProviderCookieSource(rawValue: raw) ?? .auto
+            })
+        let cookieOptions = ProviderCookieSourceUI.options(
+            allowsOff: false,
+            keychainDisabled: context.settings.debugDisableKeychainAccess)
+
+        let cookieSubtitle: () -> String? = {
+            ProviderCookieSourceUI.subtitle(
+                source: context.settings.abacusCookieSource,
+                keychainDisabled: context.settings.debugDisableKeychainAccess,
+                auto: "Automatic imports browser cookies.",
+                manual: "Paste a Cookie header or cURL capture from the Abacus AI dashboard.",
+                off: "Abacus AI cookies are disabled.")
+        }
+
+        return [
+            ProviderSettingsPickerDescriptor(
+                id: "abacus-cookie-source",
+                title: "Cookie source",
+                subtitle: "Automatic imports browser cookies.",
+                dynamicSubtitle: cookieSubtitle,
+                binding: cookieBinding,
+                options: cookieOptions,
+                isVisible: nil,
+                onChange: nil,
+                trailingText: {
+                    guard let entry = CookieHeaderCache.loadForDisplay(provider: .abacus) else { return nil }
+                    let when = entry.storedAt.relativeDescription()
+                    return "Cached: \(entry.sourceLabel) • \(when)"
+                }),
+        ]
+    }
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "abacus-cookie",
+                title: "",
+                subtitle: "",
+                kind: .secure,
+                placeholder: "Cookie: \u{2026}\n\nor paste a cURL capture from the Abacus AI dashboard",
+                binding: context.stringBinding(\.abacusCookieHeader),
+                actions: [
+                    ProviderSettingsActionDescriptor(
+                        id: "abacus-open-dashboard",
+                        title: "Open Dashboard",
+                        style: .link,
+                        isVisible: nil,
+                        perform: {
+                            if let url = URL(string: "https://apps.abacus.ai/chatllm/admin/compute-points-usage") {
+                                NSWorkspace.shared.open(url)
+                            }
+                        }),
+                ],
+                isVisible: { context.settings.abacusCookieSource == .manual },
+                onActivate: nil),
+        ]
+    }
+}
diff --git a/Sources/CodexBar/Providers/Abacus/AbacusSettingsStore.swift b/Sources/CodexBar/Providers/Abacus/AbacusSettingsStore.swift
new file mode 100644
index 0000000000..aa33089acc
--- /dev/null
+++ b/Sources/CodexBar/Providers/Abacus/AbacusSettingsStore.swift
@@ -0,0 +1,35 @@
+import CodexBarCore
+import Foundation
+
+extension SettingsStore {
+    var abacusCookieHeader: String {
+        get { self.configSnapshot.providerConfig(for: .abacus)?.sanitizedCookieHeader ?? "" }
+        set {
+            self.updateProviderConfig(provider: .abacus) { entry in
+                entry.cookieHeader = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .abacus, field: "cookieHeader", value: newValue)
+        }
+    }
+
+    var abacusCookieSource: ProviderCookieSource {
+        get { self.resolvedCookieSource(provider: .abacus, fallback: .auto) }
+        set {
+            self.updateProviderConfig(provider: .abacus) { entry in
+                entry.cookieSource = newValue
+            }
+            self.logProviderModeChange(provider: .abacus, field: "cookieSource", value: newValue.rawValue)
+        }
+    }
+}
+
+extension SettingsStore {
+    func abacusSettingsSnapshot(tokenOverride: TokenAccountOverride?) -> ProviderSettingsSnapshot
+    .AbacusProviderSettings {
+        self.resolvedCookieSettings(
+            provider: .abacus,
+            configuredSource: self.abacusCookieSource,
+            configuredHeader: self.abacusCookieHeader,
+            tokenOverride: tokenOverride)
+    }
+}
diff --git a/Sources/CodexBar/Providers/Alibaba/AlibabaCodingPlanProviderImplementation.swift b/Sources/CodexBar/Providers/Alibaba/AlibabaCodingPlanProviderImplementation.swift
new file mode 100644
index 0000000000..169fdd5a9c
--- /dev/null
+++ b/Sources/CodexBar/Providers/Alibaba/AlibabaCodingPlanProviderImplementation.swift
@@ -0,0 +1,130 @@
+import AppKit
+import CodexBarCore
+import Foundation
+import SwiftUI
+
+struct AlibabaCodingPlanProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .alibaba
+
+    @MainActor
+    func presentation(context _: ProviderPresentationContext) -> ProviderPresentation {
+        ProviderPresentation { context in
+            context.store.sourceLabel(for: context.provider)
+        }
+    }
+
+    @MainActor
+    func observeSettings(_ settings: SettingsStore) {
+        _ = settings.alibabaCodingPlanAPIToken
+        _ = settings.alibabaCodingPlanCookieSource
+        _ = settings.alibabaCodingPlanCookieHeader
+        _ = settings.alibabaCodingPlanAPIRegion
+    }
+
+    @MainActor
+    func settingsSnapshot(context: ProviderSettingsSnapshotContext) -> ProviderSettingsSnapshotContribution? {
+        _ = context
+        return .alibaba(context.settings.alibabaCodingPlanSettingsSnapshot())
+    }
+
+    @MainActor
+    func settingsPickers(context: ProviderSettingsContext) -> [ProviderSettingsPickerDescriptor] {
+        let binding = Binding(
+            get: { context.settings.alibabaCodingPlanAPIRegion.rawValue },
+            set: { raw in
+                context.settings
+                    .alibabaCodingPlanAPIRegion = AlibabaCodingPlanAPIRegion(rawValue: raw) ?? .international
+            })
+        let options = AlibabaCodingPlanAPIRegion.allCases.map {
+            ProviderSettingsPickerOption(id: $0.rawValue, title: $0.displayName)
+        }
+
+        let cookieBinding = Binding(
+            get: { context.settings.alibabaCodingPlanCookieSource.rawValue },
+            set: { raw in
+                context.settings.alibabaCodingPlanCookieSource = ProviderCookieSource(rawValue: raw) ?? .auto
+            })
+        let cookieOptions = ProviderCookieSourceUI.options(
+            allowsOff: false,
+            keychainDisabled: context.settings.debugDisableKeychainAccess)
+        let cookieSubtitle: () -> String? = {
+            ProviderCookieSourceUI.subtitle(
+                source: context.settings.alibabaCodingPlanCookieSource,
+                keychainDisabled: context.settings.debugDisableKeychainAccess,
+                auto: "Automatic imports browser cookies from Model Studio/Bailian.",
+                manual: "Paste a Cookie header from modelstudio.console.alibabacloud.com.",
+                off: "Alibaba cookies are disabled.")
+        }
+
+        return [
+            ProviderSettingsPickerDescriptor(
+                id: "alibaba-coding-plan-cookie-source",
+                title: "Cookie source",
+                subtitle: "Automatic imports browser cookies from Model Studio/Bailian.",
+                dynamicSubtitle: cookieSubtitle,
+                binding: cookieBinding,
+                options: cookieOptions,
+                isVisible: nil,
+                onChange: nil,
+                trailingText: {
+                    guard let entry = CookieHeaderCache.loadForDisplay(provider: .alibaba) else { return nil }
+                    let when = entry.storedAt.relativeDescription()
+                    return "Cached: \(entry.sourceLabel) • \(when)"
+                }),
+            ProviderSettingsPickerDescriptor(
+                id: "alibaba-coding-plan-region",
+                title: "Gateway region",
+                subtitle: "Use international or China mainland console gateways for quota fetches.",
+                binding: binding,
+                options: options,
+                isVisible: nil,
+                onChange: nil),
+        ]
+    }
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "alibaba-coding-plan-api-key",
+                title: "API key",
+                subtitle: "Stored in ~/.codexbar/config.json. Paste your Coding Plan API key from Model Studio.",
+                kind: .secure,
+                placeholder: "cpk-...",
+                binding: context.stringBinding(\.alibabaCodingPlanAPIToken),
+                actions: [
+                    ProviderSettingsActionDescriptor(
+                        id: "alibaba-coding-plan-open-dashboard",
+                        title: "Open Coding Plan",
+                        style: .link,
+                        isVisible: nil,
+                        perform: {
+                            NSWorkspace.shared.open(context.settings.alibabaCodingPlanAPIRegion.dashboardURL)
+                        }),
+                ],
+                isVisible: nil,
+                onActivate: { context.settings.ensureAlibabaCodingPlanAPITokenLoaded() }),
+            ProviderSettingsFieldDescriptor(
+                id: "alibaba-coding-plan-cookie",
+                title: "Cookie header",
+                subtitle: "",
+                kind: .secure,
+                placeholder: "Cookie: ...",
+                binding: context.stringBinding(\.alibabaCodingPlanCookieHeader),
+                actions: [
+                    ProviderSettingsActionDescriptor(
+                        id: "alibaba-coding-plan-open-dashboard-cookie",
+                        title: "Open Coding Plan",
+                        style: .link,
+                        isVisible: nil,
+                        perform: {
+                            NSWorkspace.shared.open(context.settings.alibabaCodingPlanAPIRegion.dashboardURL)
+                        }),
+                ],
+                isVisible: {
+                    context.settings.alibabaCodingPlanCookieSource == .manual
+                },
+                onActivate: nil),
+        ]
+    }
+}
diff --git a/Sources/CodexBar/Providers/Alibaba/AlibabaCodingPlanSettingsStore.swift b/Sources/CodexBar/Providers/Alibaba/AlibabaCodingPlanSettingsStore.swift
new file mode 100644
index 0000000000..61e12ce4ed
--- /dev/null
+++ b/Sources/CodexBar/Providers/Alibaba/AlibabaCodingPlanSettingsStore.swift
@@ -0,0 +1,86 @@
+import CodexBarCore
+import Foundation
+
+extension SettingsStore {
+    private static let alibabaAutoEnableAppliedKey = "alibabaCodingPlanAutoEnableApplied"
+
+    var alibabaCodingPlanAPIRegion: AlibabaCodingPlanAPIRegion {
+        get {
+            let raw = self.configSnapshot.providerConfig(for: .alibaba)?.region
+            return AlibabaCodingPlanAPIRegion(rawValue: raw ?? "") ?? .international
+        }
+        set {
+            self.updateProviderConfig(provider: .alibaba) { entry in
+                entry.region = newValue.rawValue
+            }
+        }
+    }
+
+    var alibabaCodingPlanCookieHeader: String {
+        get { self.configSnapshot.providerConfig(for: .alibaba)?.sanitizedCookieHeader ?? "" }
+        set {
+            self.updateProviderConfig(provider: .alibaba) { entry in
+                entry.cookieHeader = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .alibaba, field: "cookieHeader", value: newValue)
+        }
+    }
+
+    var alibabaCodingPlanCookieSource: ProviderCookieSource {
+        get { self.resolvedCookieSource(provider: .alibaba, fallback: .auto) }
+        set {
+            self.updateProviderConfig(provider: .alibaba) { entry in
+                entry.cookieSource = newValue
+            }
+            self.logProviderModeChange(provider: .alibaba, field: "cookieSource", value: newValue.rawValue)
+        }
+    }
+
+    var alibabaCodingPlanAPIToken: String {
+        get { self.configSnapshot.providerConfig(for: .alibaba)?.sanitizedAPIKey ?? "" }
+        set {
+            self.updateProviderConfig(provider: .alibaba) { entry in
+                entry.apiKey = self.normalizedConfigValue(newValue)
+            }
+            let hasToken = !newValue.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+            if hasToken,
+               let metadata = ProviderDescriptorRegistry.metadata[.alibaba],
+               !self.isProviderEnabled(provider: .alibaba, metadata: metadata)
+            {
+                self.setProviderEnabled(provider: .alibaba, metadata: metadata, enabled: true)
+            }
+            self.logSecretUpdate(provider: .alibaba, field: "apiKey", value: newValue)
+        }
+    }
+
+    func ensureAlibabaCodingPlanAPITokenLoaded() {}
+
+    func ensureAlibabaProviderAutoEnabledIfNeeded(
+        environment: [String: String] = ProcessInfo.processInfo.environment)
+    {
+        guard self.userDefaults.bool(forKey: Self.alibabaAutoEnableAppliedKey) == false else { return }
+
+        let hasConfigToken = self.configSnapshot.providerConfig(for: .alibaba)?.sanitizedAPIKey != nil
+        let shouldUseEnvironmentToken = !Self.isRunningTests || self.userDefaults === UserDefaults.standard
+        let hasEnvironmentToken = shouldUseEnvironmentToken &&
+            AlibabaCodingPlanSettingsReader.apiToken(environment: environment) != nil
+        guard hasConfigToken || hasEnvironmentToken else { return }
+
+        if let metadata = ProviderDescriptorRegistry.metadata[.alibaba],
+           !self.isProviderEnabled(provider: .alibaba, metadata: metadata)
+        {
+            self.setProviderEnabled(provider: .alibaba, metadata: metadata, enabled: true)
+        }
+
+        self.userDefaults.set(true, forKey: Self.alibabaAutoEnableAppliedKey)
+    }
+}
+
+extension SettingsStore {
+    func alibabaCodingPlanSettingsSnapshot() -> ProviderSettingsSnapshot.AlibabaCodingPlanProviderSettings {
+        ProviderSettingsSnapshot.AlibabaCodingPlanProviderSettings(
+            cookieSource: self.alibabaCodingPlanCookieSource,
+            manualCookieHeader: self.alibabaCodingPlanCookieHeader,
+            apiRegion: self.alibabaCodingPlanAPIRegion)
+    }
+}
diff --git a/Sources/CodexBar/Providers/Alibaba/AlibabaTokenPlanProviderImplementation.swift b/Sources/CodexBar/Providers/Alibaba/AlibabaTokenPlanProviderImplementation.swift
new file mode 100644
index 0000000000..e3d51bd35c
--- /dev/null
+++ b/Sources/CodexBar/Providers/Alibaba/AlibabaTokenPlanProviderImplementation.swift
@@ -0,0 +1,91 @@
+import AppKit
+import CodexBarCore
+import Foundation
+import SwiftUI
+
+struct AlibabaTokenPlanProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .alibabatokenplan
+
+    @MainActor
+    func presentation(context _: ProviderPresentationContext) -> ProviderPresentation {
+        ProviderPresentation { context in
+            context.store.sourceLabel(for: context.provider)
+        }
+    }
+
+    @MainActor
+    func observeSettings(_ settings: SettingsStore) {
+        _ = settings.alibabaTokenPlanCookieSource
+        _ = settings.alibabaTokenPlanCookieHeader
+    }
+
+    @MainActor
+    func settingsSnapshot(context: ProviderSettingsSnapshotContext) -> ProviderSettingsSnapshotContribution? {
+        _ = context
+        return .alibabaTokenPlan(context.settings.alibabaTokenPlanSettingsSnapshot())
+    }
+
+    @MainActor
+    func settingsPickers(context: ProviderSettingsContext) -> [ProviderSettingsPickerDescriptor] {
+        let cookieBinding = Binding(
+            get: { context.settings.alibabaTokenPlanCookieSource.rawValue },
+            set: { raw in
+                context.settings.alibabaTokenPlanCookieSource = ProviderCookieSource(rawValue: raw) ?? .auto
+            })
+        let cookieOptions = ProviderCookieSourceUI.options(
+            allowsOff: false,
+            keychainDisabled: context.settings.debugDisableKeychainAccess)
+        let cookieSubtitle: () -> String? = {
+            ProviderCookieSourceUI.subtitle(
+                source: context.settings.alibabaTokenPlanCookieSource,
+                keychainDisabled: context.settings.debugDisableKeychainAccess,
+                auto: "Automatic imports browser cookies from Bailian.",
+                manual: "Paste a Cookie header from bailian.console.aliyun.com.",
+                off: "Alibaba Token Plan cookies are disabled.")
+        }
+
+        return [
+            ProviderSettingsPickerDescriptor(
+                id: "alibaba-token-plan-cookie-source",
+                title: "Cookie source",
+                subtitle: "Automatic imports browser cookies from Bailian.",
+                dynamicSubtitle: cookieSubtitle,
+                binding: cookieBinding,
+                options: cookieOptions,
+                isVisible: nil,
+                onChange: nil,
+                trailingText: {
+                    guard let entry = CookieHeaderCache.loadForDisplay(provider: .alibabatokenplan) else { return nil }
+                    let when = entry.storedAt.relativeDescription()
+                    return "Cached: \(entry.sourceLabel) • \(when)"
+                }),
+        ]
+    }
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "alibaba-token-plan-cookie",
+                title: "Cookie header",
+                subtitle: "",
+                kind: .secure,
+                placeholder: "Cookie: ...",
+                binding: context.stringBinding(\.alibabaTokenPlanCookieHeader),
+                actions: [
+                    ProviderSettingsActionDescriptor(
+                        id: "alibaba-token-plan-open-dashboard",
+                        title: "Open Token Plan",
+                        style: .link,
+                        isVisible: nil,
+                        perform: {
+                            NSWorkspace.shared.open(AlibabaTokenPlanUsageFetcher.dashboardURL)
+                        }),
+                ],
+                isVisible: {
+                    context.settings.alibabaTokenPlanCookieSource == .manual
+                },
+                onActivate: nil),
+        ]
+    }
+}
diff --git a/Sources/CodexBar/Providers/Alibaba/AlibabaTokenPlanSettingsStore.swift b/Sources/CodexBar/Providers/Alibaba/AlibabaTokenPlanSettingsStore.swift
new file mode 100644
index 0000000000..6f2ed187b3
--- /dev/null
+++ b/Sources/CodexBar/Providers/Alibaba/AlibabaTokenPlanSettingsStore.swift
@@ -0,0 +1,30 @@
+import CodexBarCore
+import Foundation
+
+extension SettingsStore {
+    var alibabaTokenPlanCookieHeader: String {
+        get { self.configSnapshot.providerConfig(for: .alibabatokenplan)?.sanitizedCookieHeader ?? "" }
+        set {
+            self.updateProviderConfig(provider: .alibabatokenplan) { entry in
+                entry.cookieHeader = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .alibabatokenplan, field: "cookieHeader", value: newValue)
+        }
+    }
+
+    var alibabaTokenPlanCookieSource: ProviderCookieSource {
+        get { self.resolvedCookieSource(provider: .alibabatokenplan, fallback: .auto) }
+        set {
+            self.updateProviderConfig(provider: .alibabatokenplan) { entry in
+                entry.cookieSource = newValue
+            }
+            self.logProviderModeChange(provider: .alibabatokenplan, field: "cookieSource", value: newValue.rawValue)
+        }
+    }
+
+    func alibabaTokenPlanSettingsSnapshot() -> ProviderSettingsSnapshot.AlibabaTokenPlanProviderSettings {
+        ProviderSettingsSnapshot.AlibabaTokenPlanProviderSettings(
+            cookieSource: self.alibabaTokenPlanCookieSource,
+            manualCookieHeader: self.alibabaTokenPlanCookieHeader)
+    }
+}
diff --git a/Sources/CodexBar/Providers/Amp/AmpProviderImplementation.swift b/Sources/CodexBar/Providers/Amp/AmpProviderImplementation.swift
index 25ca6c9326..7359c304c8 100644
--- a/Sources/CodexBar/Providers/Amp/AmpProviderImplementation.swift
+++ b/Sources/CodexBar/Providers/Amp/AmpProviderImplementation.swift
@@ -1,19 +1,24 @@
 import AppKit
 import CodexBarCore
-import CodexBarMacroSupport
 import Foundation
 import SwiftUI
 
-@ProviderImplementationRegistration
 struct AmpProviderImplementation: ProviderImplementation {
     let id: UsageProvider = .amp
 
     @MainActor
     func observeSettings(_ settings: SettingsStore) {
+        _ = settings.ampUsageDataSource
+        _ = settings.ampAPIToken
         _ = settings.ampCookieSource
         _ = settings.ampCookieHeader
     }
 
+    @MainActor
+    func sourceMode(context: ProviderSourceModeContext) -> ProviderSourceMode {
+        context.settings.ampUsageDataSource
+    }
+
     @MainActor
     func settingsSnapshot(context: ProviderSettingsSnapshotContext) -> ProviderSettingsSnapshotContribution? {
         .amp(context.settings.ampSettingsSnapshot(tokenOverride: context.tokenOverride))
@@ -21,6 +26,17 @@ struct AmpProviderImplementation: ProviderImplementation {
 
     @MainActor
     func settingsPickers(context: ProviderSettingsContext) -> [ProviderSettingsPickerDescriptor] {
+        let sourceBinding = Binding(
+            get: { context.settings.ampUsageDataSource.rawValue },
+            set: { raw in
+                context.settings.ampUsageDataSource = ProviderSourceMode(rawValue: raw) ?? .auto
+            })
+        let sourceOptions: [ProviderSettingsPickerOption] = [
+            ProviderSettingsPickerOption(id: ProviderSourceMode.auto.rawValue, title: "Auto"),
+            ProviderSettingsPickerOption(id: ProviderSourceMode.cli.rawValue, title: "Amp CLI"),
+            ProviderSettingsPickerOption(id: ProviderSourceMode.api.rawValue, title: "Access token"),
+            ProviderSettingsPickerOption(id: ProviderSourceMode.web.rawValue, title: "Browser cookies"),
+        ]
         let cookieBinding = Binding(
             get: { context.settings.ampCookieSource.rawValue },
             set: { raw in
@@ -40,6 +56,14 @@ struct AmpProviderImplementation: ProviderImplementation {
         }
 
         return [
+            ProviderSettingsPickerDescriptor(
+                id: "amp-usage-source",
+                title: "Usage source",
+                subtitle: "Auto tries the Amp CLI, access token, then browser cookies.",
+                binding: sourceBinding,
+                options: sourceOptions,
+                isVisible: nil,
+                onChange: nil),
             ProviderSettingsPickerDescriptor(
                 id: "amp-cookie-source",
                 title: "Cookie source",
@@ -47,7 +71,10 @@ struct AmpProviderImplementation: ProviderImplementation {
                 dynamicSubtitle: cookieSubtitle,
                 binding: cookieBinding,
                 options: cookieOptions,
-                isVisible: nil,
+                isVisible: {
+                    context.settings.ampUsageDataSource == .auto ||
+                        context.settings.ampUsageDataSource == .web
+                },
                 onChange: nil),
         ]
     }
@@ -55,6 +82,30 @@ struct AmpProviderImplementation: ProviderImplementation {
     @MainActor
     func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
         [
+            ProviderSettingsFieldDescriptor(
+                id: "amp-api-token",
+                title: "Access token",
+                subtitle: "Stored in ~/.codexbar/config.json. You can also set AMP_API_KEY.",
+                kind: .secure,
+                placeholder: "sgamp_...",
+                binding: context.stringBinding(\.ampAPIToken),
+                actions: [
+                    ProviderSettingsActionDescriptor(
+                        id: "amp-open-access-tokens",
+                        title: "Open Amp Access Tokens",
+                        style: .link,
+                        isVisible: nil,
+                        perform: {
+                            if let url = URL(string: "https://ampcode.com/settings") {
+                                NSWorkspace.shared.open(url)
+                            }
+                        }),
+                ],
+                isVisible: {
+                    context.settings.ampUsageDataSource == .auto ||
+                        context.settings.ampUsageDataSource == .api
+                },
+                onActivate: { context.settings.ensureAmpAPITokenLoaded() }),
             ProviderSettingsFieldDescriptor(
                 id: "amp-cookie",
                 title: "",
@@ -74,7 +125,11 @@ struct AmpProviderImplementation: ProviderImplementation {
                             }
                         }),
                 ],
-                isVisible: { context.settings.ampCookieSource == .manual },
+                isVisible: {
+                    (context.settings.ampUsageDataSource == .auto ||
+                        context.settings.ampUsageDataSource == .web) &&
+                        context.settings.ampCookieSource == .manual
+                },
                 onActivate: { context.settings.ensureAmpCookieLoaded() }),
         ]
     }
diff --git a/Sources/CodexBar/Providers/Amp/AmpSettingsStore.swift b/Sources/CodexBar/Providers/Amp/AmpSettingsStore.swift
index a7b237ba18..e6fbd01192 100644
--- a/Sources/CodexBar/Providers/Amp/AmpSettingsStore.swift
+++ b/Sources/CodexBar/Providers/Amp/AmpSettingsStore.swift
@@ -2,6 +2,26 @@ import CodexBarCore
 import Foundation
 
 extension SettingsStore {
+    var ampUsageDataSource: ProviderSourceMode {
+        get { self.configSnapshot.providerConfig(for: .amp)?.source ?? .auto }
+        set {
+            self.updateProviderConfig(provider: .amp) { entry in
+                entry.source = newValue == .auto ? nil : newValue
+            }
+            self.logProviderModeChange(provider: .amp, field: "source", value: newValue.rawValue)
+        }
+    }
+
+    var ampAPIToken: String {
+        get { self.configSnapshot.providerConfig(for: .amp)?.sanitizedAPIKey ?? "" }
+        set {
+            self.updateProviderConfig(provider: .amp) { entry in
+                entry.apiKey = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .amp, field: "apiKey", value: newValue)
+        }
+    }
+
     var ampCookieHeader: String {
         get { self.configSnapshot.providerConfig(for: .amp)?.sanitizedCookieHeader ?? "" }
         set {
@@ -22,41 +42,17 @@ extension SettingsStore {
         }
     }
 
+    func ensureAmpAPITokenLoaded() {}
+
     func ensureAmpCookieLoaded() {}
 }
 
 extension SettingsStore {
     func ampSettingsSnapshot(tokenOverride: TokenAccountOverride?) -> ProviderSettingsSnapshot.AmpProviderSettings {
-        ProviderSettingsSnapshot.AmpProviderSettings(
-            cookieSource: self.ampSnapshotCookieSource(tokenOverride: tokenOverride),
-            manualCookieHeader: self.ampSnapshotCookieHeader(tokenOverride: tokenOverride))
-    }
-
-    private func ampSnapshotCookieHeader(tokenOverride: TokenAccountOverride?) -> String {
-        let fallback = self.ampCookieHeader
-        guard let support = TokenAccountSupportCatalog.support(for: .amp),
-              case .cookieHeader = support.injection
-        else {
-            return fallback
-        }
-        guard let account = ProviderTokenAccountSelection.selectedAccount(
+        self.resolvedCookieSettings(
             provider: .amp,
-            settings: self,
-            override: tokenOverride)
-        else {
-            return fallback
-        }
-        return TokenAccountSupportCatalog.normalizedCookieHeader(account.token, support: support)
-    }
-
-    private func ampSnapshotCookieSource(tokenOverride: TokenAccountOverride?) -> ProviderCookieSource {
-        let fallback = self.ampCookieSource
-        guard let support = TokenAccountSupportCatalog.support(for: .amp),
-              support.requiresManualCookieSource
-        else {
-            return fallback
-        }
-        if self.tokenAccounts(for: .amp).isEmpty { return fallback }
-        return .manual
+            configuredSource: self.ampCookieSource,
+            configuredHeader: self.ampCookieHeader,
+            tokenOverride: tokenOverride)
     }
 }
diff --git a/Sources/CodexBar/Providers/Antigravity/AntigravityLoginFlow.swift b/Sources/CodexBar/Providers/Antigravity/AntigravityLoginFlow.swift
index e41aa8fe65..b42790e3ea 100644
--- a/Sources/CodexBar/Providers/Antigravity/AntigravityLoginFlow.swift
+++ b/Sources/CodexBar/Providers/Antigravity/AntigravityLoginFlow.swift
@@ -3,9 +3,31 @@ import CodexBarCore
 @MainActor
 extension StatusItemController {
     func runAntigravityLoginFlow() async {
+        let store = self.store
+        let phaseHandler: @Sendable (AntigravityLoginRunner.Phase) -> Void = { [weak self] phase in
+            Task { @MainActor in
+                switch phase {
+                case .waitingBrowser:
+                    self?.loginPhase = .waitingBrowser
+                }
+            }
+        }
+        let result = await AntigravityLoginRunner.run(onPhaseChange: phaseHandler) {
+            Task { @MainActor in
+                if let credentials = try? AntigravityOAuthCredentialsStore().load() {
+                    self.store.settings.upsertAntigravityOAuthAccount(credentials)
+                }
+                await store.refresh()
+                CodexBarLog.logger(LogCategories.login).info("Auto-refreshed after Antigravity auth")
+            }
+        }
+        guard !Task.isCancelled else { return }
         self.loginPhase = .idle
-        self.presentLoginAlert(
-            title: "Antigravity login is managed in the app",
-            message: "Open Antigravity to sign in, then refresh CodexBar.")
+        self.presentAntigravityLoginResult(result)
+        let outcome = self.describe(result.outcome)
+        self.loginLogger.info("Antigravity login", metadata: ["outcome": outcome])
+        if case .success = result.outcome {
+            self.postLoginNotification(for: .antigravity)
+        }
     }
 }
diff --git a/Sources/CodexBar/Providers/Antigravity/AntigravityLoginRunner.swift b/Sources/CodexBar/Providers/Antigravity/AntigravityLoginRunner.swift
new file mode 100644
index 0000000000..0ac446c876
--- /dev/null
+++ b/Sources/CodexBar/Providers/Antigravity/AntigravityLoginRunner.swift
@@ -0,0 +1,484 @@
+import AppKit
+import CodexBarCore
+import Darwin
+import Foundation
+import Network
+
+enum AntigravityLoginRunner {
+    enum Phase {
+        case waitingBrowser
+    }
+
+    struct Result {
+        enum Outcome {
+            case success(String?)
+            case cancelled
+            case timedOut
+            case launchFailed(String)
+            case failed(String)
+        }
+
+        let outcome: Outcome
+    }
+
+    static func run(
+        timeout: TimeInterval = 120,
+        onPhaseChange: (@Sendable (Phase) -> Void)? = nil,
+        onCredentialsCreated: (@Sendable () -> Void)? = nil) async -> Result
+    {
+        guard let oauthClient = AntigravityOAuthConfig.resolvedClient() else {
+            return Result(outcome: .failed(AntigravityOAuthConfig.missingCredentialsMessage))
+        }
+
+        let state = UUID().uuidString.replacingOccurrences(of: "-", with: "")
+        let server = AntigravityLoopbackServer(state: state)
+
+        do {
+            let callbackURL = try await server.start()
+            let authURL = try Self.makeAuthorizationURL(
+                redirectURL: callbackURL,
+                state: state,
+                oauthClient: oauthClient)
+            onPhaseChange?(.waitingBrowser)
+
+            let opened = await MainActor.run {
+                NSWorkspace.shared.open(authURL)
+            }
+            guard opened else {
+                server.stop()
+                return Result(outcome: .launchFailed(authURL.absoluteString))
+            }
+
+            let callback = try await withThrowingTaskGroup(of: AntigravityOAuthCallback.self) { group in
+                group.addTask {
+                    try await server.waitForCallback()
+                }
+                group.addTask {
+                    try await Task.sleep(for: .seconds(timeout))
+                    server.cancelCallbackWait(with: AntigravityLoginError.timedOut)
+                    throw AntigravityLoginError.timedOut
+                }
+                defer { group.cancelAll() }
+                return try await group.next().unsafelyUnwrapped
+            }
+            server.stop()
+
+            if let error = callback.error?.trimmingCharacters(in: .whitespacesAndNewlines), !error.isEmpty {
+                if error == "access_denied" {
+                    return Result(outcome: .cancelled)
+                }
+                return Result(outcome: .failed(error))
+            }
+
+            guard callback.returnedState == state else {
+                return Result(outcome: .failed("Google login state mismatch."))
+            }
+            guard let code = callback.code?.trimmingCharacters(in: .whitespacesAndNewlines), !code.isEmpty else {
+                return Result(outcome: .failed("Google login did not return an authorization code."))
+            }
+
+            let tokenResponse = try await Self.exchangeCodeForTokens(
+                code: code,
+                redirectURL: callbackURL,
+                oauthClient: oauthClient)
+            let email = try await Self.fetchUserEmail(accessToken: tokenResponse.accessToken)
+            let credentials = AntigravityOAuthCredentials(
+                accessToken: tokenResponse.accessToken,
+                refreshToken: tokenResponse.refreshToken,
+                expiryDate: Date().addingTimeInterval(TimeInterval(tokenResponse.expiresIn)),
+                idToken: tokenResponse.idToken,
+                email: email,
+                projectID: nil,
+                clientID: oauthClient.clientID,
+                clientSecret: oauthClient.clientSecret)
+            try AntigravityOAuthCredentialsStore().save(credentials)
+            onCredentialsCreated?()
+            return Result(outcome: .success(email))
+        } catch is CancellationError {
+            server.stop()
+            return Result(outcome: .cancelled)
+        } catch AntigravityLoginError.timedOut {
+            server.stop()
+            return Result(outcome: .timedOut)
+        } catch let AntigravityLoginError.launchFailed(message) {
+            server.stop()
+            return Result(outcome: .launchFailed(message))
+        } catch {
+            server.stop()
+            return Result(outcome: .failed(error.localizedDescription))
+        }
+    }
+
+    static func makeAuthorizationURL(
+        redirectURL: URL,
+        state: String,
+        oauthClient: AntigravityOAuthClient) throws -> URL
+    {
+        guard var components = URLComponents(url: AntigravityOAuthConfig.authURL, resolvingAgainstBaseURL: false) else {
+            throw AntigravityLoginError.invalidAuthorizationURL
+        }
+        components.queryItems = [
+            URLQueryItem(name: "client_id", value: oauthClient.clientID),
+            URLQueryItem(name: "redirect_uri", value: redirectURL.absoluteString),
+            URLQueryItem(name: "response_type", value: "code"),
+            URLQueryItem(name: "scope", value: AntigravityOAuthConfig.scopes.joined(separator: " ")),
+            URLQueryItem(name: "access_type", value: "offline"),
+            URLQueryItem(name: "prompt", value: "select_account consent"),
+            URLQueryItem(name: "state", value: state),
+        ]
+        guard let url = components.url else {
+            throw AntigravityLoginError.invalidAuthorizationURL
+        }
+        return url
+    }
+
+    private static func exchangeCodeForTokens(
+        code: String,
+        redirectURL: URL,
+        oauthClient: AntigravityOAuthClient) async throws -> TokenResponse
+    {
+        var request = URLRequest(url: AntigravityOAuthConfig.tokenURL)
+        request.httpMethod = "POST"
+        request.timeoutInterval = 30
+        request.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
+        request.httpBody = Self.formBody([
+            "code": code,
+            "client_id": oauthClient.clientID,
+            "client_secret": oauthClient.clientSecret,
+            "redirect_uri": redirectURL.absoluteString,
+            "grant_type": "authorization_code",
+        ])
+
+        let (data, response) = try await ProviderHTTPClient.shared.data(for: request)
+        guard let httpResponse = response as? HTTPURLResponse else {
+            throw AntigravityLoginError.failed("Invalid token response.")
+        }
+        guard httpResponse.statusCode == 200 else {
+            let message = String(data: data, encoding: .utf8)?.trimmingCharacters(in: .whitespacesAndNewlines)
+                ?? "HTTP \(httpResponse.statusCode)"
+            throw AntigravityLoginError.failed(message)
+        }
+        do {
+            return try JSONDecoder().decode(TokenResponse.self, from: data)
+        } catch {
+            throw AntigravityLoginError.failed("Could not decode token response.")
+        }
+    }
+
+    private static func fetchUserEmail(accessToken: String) async throws -> String? {
+        var request = URLRequest(url: AntigravityOAuthConfig.userInfoURL)
+        request.timeoutInterval = 15
+        request.setValue("Bearer \(accessToken)", forHTTPHeaderField: "Authorization")
+
+        do {
+            let (data, response) = try await ProviderHTTPClient.shared.data(for: request)
+            guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
+                return nil
+            }
+            let userInfo = try JSONDecoder().decode(UserInfoResponse.self, from: data)
+            let email = userInfo.email?.trimmingCharacters(in: .whitespacesAndNewlines)
+            return (email?.isEmpty == false) ? email : nil
+        } catch {
+            return nil
+        }
+    }
+
+    private static func formBody(_ values: [String: String]) -> Data? {
+        values
+            .map { key, value in
+                let encodedKey = key.addingPercentEncoding(withAllowedCharacters: .urlQueryValueAllowed) ?? key
+                let encodedValue = value.addingPercentEncoding(withAllowedCharacters: .urlQueryValueAllowed) ?? value
+                return "\(encodedKey)=\(encodedValue)"
+            }
+            .joined(separator: "&")
+            .data(using: .utf8)
+    }
+}
+
+private enum AntigravityLoginError: LocalizedError {
+    case invalidAuthorizationURL
+    case timedOut
+    case launchFailed(String)
+    case failed(String)
+
+    var errorDescription: String? {
+        switch self {
+        case .invalidAuthorizationURL:
+            "Could not build the Antigravity login URL."
+        case .timedOut:
+            "Antigravity login timed out."
+        case let .launchFailed(message):
+            message
+        case let .failed(message):
+            message
+        }
+    }
+}
+
+private struct TokenResponse: Decodable {
+    let accessToken: String
+    let refreshToken: String?
+    let expiresIn: Int
+    let idToken: String?
+
+    enum CodingKeys: String, CodingKey {
+        case accessToken = "access_token"
+        case refreshToken = "refresh_token"
+        case expiresIn = "expires_in"
+        case idToken = "id_token"
+    }
+}
+
+private struct UserInfoResponse: Decodable {
+    let email: String?
+}
+
+private struct AntigravityOAuthCallback {
+    let code: String?
+    let returnedState: String?
+    let error: String?
+}
+
+private final class AntigravityLoopbackServer: @unchecked Sendable {
+    private let expectedState: String
+    private let queue = DispatchQueue(label: "codexbar.antigravity.oauth")
+    private let lock = NSLock()
+    private var listener: NWListener?
+    private var readyContinuation: CheckedContinuation<URL, Error>?
+    private var callbackContinuation: CheckedContinuation<AntigravityOAuthCallback, Error>?
+    private var pendingCallbackResult: Result<AntigravityOAuthCallback, Error>?
+    private var completed = false
+
+    init(state: String) {
+        self.expectedState = state
+    }
+
+    func start() async throws -> URL {
+        let port = try Self.findAvailablePort()
+        guard let endpointPort = NWEndpoint.Port(rawValue: port) else {
+            throw AntigravityLoginError.failed("Could not reserve a local callback port.")
+        }
+        let listener = try NWListener(using: .tcp, on: endpointPort)
+        self.listener = listener
+        listener.newConnectionHandler = { [weak self] connection in
+            self?.handle(connection)
+        }
+
+        return try await withCheckedThrowingContinuation { continuation in
+            self.readyContinuation = continuation
+            listener.stateUpdateHandler = { [weak self] state in
+                guard let self else { return }
+                switch state {
+                case .ready:
+                    let url = URL(string: "http://127.0.0.1:\(port)/callback")!
+                    self.finishReady(with: .success(url))
+                case let .failed(error):
+                    self.finishReady(with: .failure(error))
+                    self.finishCallback(with: .failure(error))
+                default:
+                    break
+                }
+            }
+            listener.start(queue: self.queue)
+        }
+    }
+
+    func waitForCallback() async throws -> AntigravityOAuthCallback {
+        try await withCheckedThrowingContinuation { continuation in
+            self.lock.lock()
+            defer { self.lock.unlock() }
+            if let pending = self.pendingCallbackResult {
+                self.pendingCallbackResult = nil
+                switch pending {
+                case let .success(callback):
+                    continuation.resume(returning: callback)
+                case let .failure(error):
+                    continuation.resume(throwing: error)
+                }
+                return
+            }
+            self.callbackContinuation = continuation
+        }
+    }
+
+    func stop() {
+        self.listener?.cancel()
+        self.listener = nil
+    }
+
+    func cancelCallbackWait(with error: Error) {
+        self.stop()
+        self.finishCallback(with: .failure(error))
+    }
+
+    private func handle(_ connection: NWConnection) {
+        connection.start(queue: self.queue)
+        self.receive(on: connection, accumulated: Data())
+    }
+
+    private func receive(on connection: NWConnection, accumulated: Data) {
+        connection.receive(minimumIncompleteLength: 1, maximumLength: 65536) { [weak self] data, _, isComplete, error in
+            guard let self else { return }
+            if let error {
+                self.finishCallback(with: .failure(error))
+                connection.cancel()
+                return
+            }
+
+            var buffer = accumulated
+            if let data {
+                buffer.append(data)
+            }
+
+            let headerMarker = Data("\r\n\r\n".utf8)
+            if buffer.range(of: headerMarker) == nil, !isComplete {
+                self.receive(on: connection, accumulated: buffer)
+                return
+            }
+
+            let callback = self.parseCallback(from: buffer)
+            let response = self.httpResponse(for: callback)
+            connection.send(content: response, completion: .contentProcessed { _ in
+                connection.cancel()
+            })
+            self.finishCallback(with: .success(callback))
+        }
+    }
+
+    private func parseCallback(from data: Data) -> AntigravityOAuthCallback {
+        guard let request = String(data: data, encoding: .utf8),
+              let line = request.components(separatedBy: "\r\n").first
+        else {
+            return AntigravityOAuthCallback(code: nil, returnedState: nil, error: "Invalid callback request.")
+        }
+
+        let parts = line.split(separator: " ")
+        guard parts.count >= 2,
+              let url = URL(string: "http://127.0.0.1\(parts[1])"),
+              let components = URLComponents(url: url, resolvingAgainstBaseURL: false)
+        else {
+            return AntigravityOAuthCallback(code: nil, returnedState: nil, error: "Invalid callback URL.")
+        }
+
+        let code = components.queryItems?.first(where: { $0.name == "code" })?.value
+        let returnedState = components.queryItems?.first(where: { $0.name == "state" })?.value
+        let error = components.queryItems?.first(where: { $0.name == "error" })?.value
+
+        guard components.path == "/callback" else {
+            return AntigravityOAuthCallback(code: nil, returnedState: returnedState, error: "Unexpected callback path.")
+        }
+        if let returnedState, returnedState != self.expectedState {
+            return AntigravityOAuthCallback(code: code, returnedState: returnedState, error: "State mismatch.")
+        }
+        return AntigravityOAuthCallback(code: code, returnedState: returnedState, error: error)
+    }
+
+    private func httpResponse(for callback: AntigravityOAuthCallback) -> Data {
+        let success = callback.error == nil && callback.code?.isEmpty == false
+        let status = success ? "200 OK" : "400 Bad Request"
+        let title = success ? "Login Successful" : "Login Failed"
+        let detail = success
+            ? "You can close this window and return to CodexBar."
+            : "You can close this window and try again."
+        let html = """
+        <html>
+          <body style="font-family: -apple-system, BlinkMacSystemFont, sans-serif; padding: 32px; text-align: center;">
+            <h1>\(title)</h1>
+            <p>\(detail)</p>
+          </body>
+        </html>
+        """
+        let body = Data(html.utf8)
+        let header = """
+        HTTP/1.1 \(status)\r
+        Content-Type: text/html; charset=utf-8\r
+        Content-Length: \(body.count)\r
+        Connection: close\r
+        \r
+        """
+        var response = Data(header.utf8)
+        response.append(body)
+        return response
+    }
+
+    private func finishReady(with result: Result<URL, Error>) {
+        self.lock.lock()
+        let continuation = self.readyContinuation
+        self.readyContinuation = nil
+        self.lock.unlock()
+        switch result {
+        case let .success(url):
+            continuation?.resume(returning: url)
+        case let .failure(error):
+            continuation?.resume(throwing: error)
+        }
+    }
+
+    private func finishCallback(with result: Result<AntigravityOAuthCallback, Error>) {
+        self.lock.lock()
+        guard !self.completed else {
+            self.lock.unlock()
+            return
+        }
+        self.completed = true
+        let continuation = self.callbackContinuation
+        self.callbackContinuation = nil
+        if continuation == nil {
+            self.pendingCallbackResult = result
+        }
+        self.lock.unlock()
+        guard let continuation else { return }
+        switch result {
+        case let .success(callback):
+            continuation.resume(returning: callback)
+        case let .failure(error):
+            continuation.resume(throwing: error)
+        }
+    }
+
+    private static func findAvailablePort() throws -> UInt16 {
+        let socketFD = socket(AF_INET, Int32(SOCK_STREAM), 0)
+        guard socketFD >= 0 else {
+            throw AntigravityLoginError.failed("Could not create a local callback socket.")
+        }
+        defer { close(socketFD) }
+
+        var value: Int32 = 1
+        setsockopt(socketFD, SOL_SOCKET, SO_REUSEADDR, &value, socklen_t(MemoryLayout<Int32>.size))
+
+        var address = sockaddr_in()
+        address.sin_len = UInt8(MemoryLayout<sockaddr_in>.stride)
+        address.sin_family = sa_family_t(AF_INET)
+        address.sin_port = in_port_t(0).bigEndian
+        address.sin_addr = in_addr(s_addr: inet_addr("127.0.0.1"))
+
+        let bindResult = withUnsafePointer(to: &address) { pointer in
+            pointer.withMemoryRebound(to: sockaddr.self, capacity: 1) { sockaddrPointer in
+                bind(socketFD, sockaddrPointer, socklen_t(MemoryLayout<sockaddr_in>.stride))
+            }
+        }
+        guard bindResult == 0 else {
+            throw AntigravityLoginError.failed("Could not bind a local callback port.")
+        }
+
+        var boundAddress = sockaddr_in()
+        var length = socklen_t(MemoryLayout<sockaddr_in>.stride)
+        let nameResult = withUnsafeMutablePointer(to: &boundAddress) { pointer in
+            pointer.withMemoryRebound(to: sockaddr.self, capacity: 1) { sockaddrPointer in
+                getsockname(socketFD, sockaddrPointer, &length)
+            }
+        }
+        guard nameResult == 0 else {
+            throw AntigravityLoginError.failed("Could not inspect the callback port.")
+        }
+        return UInt16(bigEndian: boundAddress.sin_port)
+    }
+}
+
+extension CharacterSet {
+    fileprivate static let urlQueryValueAllowed: CharacterSet = {
+        var allowed = CharacterSet.urlQueryAllowed
+        allowed.remove(charactersIn: "+&=")
+        return allowed
+    }()
+}
diff --git a/Sources/CodexBar/Providers/Antigravity/AntigravityProviderImplementation.swift b/Sources/CodexBar/Providers/Antigravity/AntigravityProviderImplementation.swift
index 88492f0700..ff844d2ebc 100644
--- a/Sources/CodexBar/Providers/Antigravity/AntigravityProviderImplementation.swift
+++ b/Sources/CodexBar/Providers/Antigravity/AntigravityProviderImplementation.swift
@@ -1,15 +1,99 @@
 import CodexBarCore
-import CodexBarMacroSupport
 import Foundation
+import SwiftUI
 
-@ProviderImplementationRegistration
 struct AntigravityProviderImplementation: ProviderImplementation {
     let id: UsageProvider = .antigravity
+    let supportsLoginFlow: Bool = true
+
+    @MainActor
+    func observeSettings(_ settings: SettingsStore) {
+        _ = settings.antigravityUsageDataSource
+        _ = settings.tokenAccountsData(for: .antigravity)
+    }
+
+    @MainActor
+    func defaultSourceLabel(context: ProviderSourceLabelContext) -> String? {
+        context.settings.antigravityUsageDataSource.rawValue
+    }
+
+    @MainActor
+    func sourceMode(context: ProviderSourceModeContext) -> ProviderSourceMode {
+        switch context.settings.antigravityUsageDataSource {
+        case .auto: .auto
+        case .oauth: .oauth
+        case .cli: .cli
+        }
+    }
+
+    @MainActor
+    func settingsPickers(context: ProviderSettingsContext) -> [ProviderSettingsPickerDescriptor] {
+        let usageBinding = Binding(
+            get: { context.settings.antigravityUsageDataSource.rawValue },
+            set: { raw in
+                context.settings.antigravityUsageDataSource = AntigravityUsageDataSource(rawValue: raw) ?? .auto
+            })
+        let usageOptions = AntigravityUsageDataSource.allCases.map {
+            ProviderSettingsPickerOption(id: $0.rawValue, title: $0.displayName)
+        }
+        return [
+            ProviderSettingsPickerDescriptor(
+                id: "antigravity-usage-source",
+                title: "Usage source",
+                subtitle: "Auto tries Antigravity app, agy CLI, then IDE; " +
+                    "OAuth follows for selected or signed-in accounts.",
+                binding: usageBinding,
+                options: usageOptions,
+                isVisible: nil,
+                onChange: nil,
+                trailingText: {
+                    guard context.settings.antigravityUsageDataSource == .auto else { return nil }
+                    let label = context.store.sourceLabel(for: .antigravity)
+                    return label == "auto" ? nil : label
+                }),
+        ]
+    }
+
+    @MainActor
+    func settingsActions(context: ProviderSettingsContext) -> [ProviderSettingsActionsDescriptor] {
+        let accountCount = context.settings.tokenAccounts(for: .antigravity).count
+        let loginTitle = accountCount > 0 ? "Add Google Account" : "Login with Google"
+        let subtitle = """
+        Stores each signed-in Google account for quick Antigravity switching. \
+        Uses Antigravity.app OAuth when available, \
+        or ANTIGRAVITY_OAUTH_CLIENT_ID and ANTIGRAVITY_OAUTH_CLIENT_SECRET as an override.
+        """
+        return [
+            ProviderSettingsActionsDescriptor(
+                id: "antigravity-oauth",
+                title: "Google OAuth",
+                subtitle: subtitle,
+                actions: [
+                    ProviderSettingsActionDescriptor(
+                        id: "antigravity-oauth-login",
+                        title: loginTitle,
+                        style: .bordered,
+                        isVisible: nil,
+                        perform: {
+                            await context.runLoginFlow()
+                        }),
+                ],
+                isVisible: nil),
+        ]
+    }
 
     func detectVersion(context _: ProviderVersionContext) async -> String? {
         await AntigravityStatusProbe.detectVersion()
     }
 
+    @MainActor
+    func appendUsageMenuEntries(context _: ProviderMenuUsageContext, entries _: inout [ProviderMenuEntry]) {}
+
+    @MainActor
+    func loginMenuAction(context _: ProviderMenuLoginContext) -> (label: String, action: MenuDescriptor.MenuAction)? {
+        ("Add Account...", .switchAccount(.antigravity))
+    }
+
     @MainActor
     func runLoginFlow(context: ProviderLoginContext) async -> Bool {
         await context.controller.runAntigravityLoginFlow()
diff --git a/Sources/CodexBar/Providers/Antigravity/AntigravitySettingsStore.swift b/Sources/CodexBar/Providers/Antigravity/AntigravitySettingsStore.swift
new file mode 100644
index 0000000000..f32a9443de
--- /dev/null
+++ b/Sources/CodexBar/Providers/Antigravity/AntigravitySettingsStore.swift
@@ -0,0 +1,65 @@
+import CodexBarCore
+import Foundation
+
+extension SettingsStore {
+    var antigravityUsageDataSource: AntigravityUsageDataSource {
+        get {
+            let source = self.configSnapshot.providerConfig(for: .antigravity)?.source
+            return Self.antigravityUsageDataSource(from: source)
+        }
+        set {
+            let source: ProviderSourceMode? = switch newValue {
+            case .auto: .auto
+            case .oauth: .oauth
+            case .cli: .cli
+            }
+            self.updateProviderConfig(provider: .antigravity) { entry in
+                entry.source = source
+            }
+            self.logProviderModeChange(provider: .antigravity, field: "usageSource", value: newValue.rawValue)
+        }
+    }
+
+    func upsertAntigravityOAuthAccount(_ credentials: AntigravityOAuthCredentials) {
+        guard let token = try? AntigravityOAuthCredentialsStore.tokenAccountValue(for: credentials) else { return }
+        let trimmedEmail = credentials.email?.trimmingCharacters(in: .whitespacesAndNewlines)
+        let email = (trimmedEmail?.isEmpty == false) ? trimmedEmail : nil
+        let data = self.tokenAccountsData(for: .antigravity)
+        let label = email ?? "Google Account \((data?.accounts.count ?? 0) + 1)"
+        if let email,
+           let data,
+           let index = data.accounts.firstIndex(where: { account in
+               account.externalIdentifier == email
+           })
+        {
+            let account = data.accounts[index]
+            self.updateTokenAccount(
+                provider: .antigravity,
+                accountID: account.id,
+                label: label,
+                token: token,
+                externalIdentifier: .some(email))
+            self.setActiveTokenAccountIndex(index, for: .antigravity)
+        } else {
+            self.addTokenAccount(
+                provider: .antigravity,
+                label: label,
+                token: token,
+                externalIdentifier: email)
+        }
+    }
+}
+
+extension SettingsStore {
+    private static func antigravityUsageDataSource(from source: ProviderSourceMode?) -> AntigravityUsageDataSource {
+        guard let source else { return .auto }
+        switch source {
+        case .auto, .web, .api:
+            return .auto
+        case .oauth:
+            return .oauth
+        case .cli:
+            return .cli
+        }
+    }
+}
diff --git a/Sources/CodexBar/Providers/Augment/AugmentProviderImplementation.swift b/Sources/CodexBar/Providers/Augment/AugmentProviderImplementation.swift
index c1529bd58b..71fc80201a 100644
--- a/Sources/CodexBar/Providers/Augment/AugmentProviderImplementation.swift
+++ b/Sources/CodexBar/Providers/Augment/AugmentProviderImplementation.swift
@@ -1,10 +1,8 @@
 import AppKit
 import CodexBarCore
-import CodexBarMacroSupport
 import Foundation
 import SwiftUI
 
-@ProviderImplementationRegistration
 struct AugmentProviderImplementation: ProviderImplementation {
     let id: UsageProvider = .augment
 
@@ -68,7 +66,7 @@ struct AugmentProviderImplementation: ProviderImplementation {
                 isVisible: nil,
                 onChange: nil,
                 trailingText: {
-                    guard let entry = CookieHeaderCache.load(provider: .augment) else { return nil }
+                    guard let entry = CookieHeaderCache.loadForDisplay(provider: .augment) else { return nil }
                     let when = entry.storedAt.relativeDescription()
                     return "Cached: \(entry.sourceLabel) • \(when)"
                 }),
@@ -83,14 +81,14 @@ struct AugmentProviderImplementation: ProviderImplementation {
 
     @MainActor
     func appendActionMenuEntries(context: ProviderMenuActionContext, entries: inout [ProviderMenuEntry]) {
-        entries.append(.action("Refresh Session", .refreshAugmentSession))
+        entries.append(.action(L("Refresh Session"), .refreshAugmentSession))
 
         if let error = context.store.error(for: .augment) {
             if error.contains("session has expired") ||
                 error.contains("No Augment session cookie found")
             {
                 entries.append(.action(
-                    "Open Augment (Log Out & Back In)",
+                    L("Open Augment (Log Out & Back In)"),
                     .loginToProvider(url: "https://app.augmentcode.com")))
             }
         }
diff --git a/Sources/CodexBar/Providers/Augment/AugmentProviderRuntime.swift b/Sources/CodexBar/Providers/Augment/AugmentProviderRuntime.swift
index b2593c546d..173822d1f2 100644
--- a/Sources/CodexBar/Providers/Augment/AugmentProviderRuntime.swift
+++ b/Sources/CodexBar/Providers/Augment/AugmentProviderRuntime.swift
@@ -5,6 +5,12 @@ import Foundation
 final class AugmentProviderRuntime: ProviderRuntime {
     let id: UsageProvider = .augment
     private var keepalive: AugmentSessionKeepalive?
+    #if DEBUG
+    private(set) var _test_keepaliveStopCount = 0
+    var _test_isKeepaliveRunning: Bool {
+        self.keepalive != nil
+    }
+    #endif
 
     func start(context: ProviderRuntimeContext) {
         self.updateKeepalive(context: context)
@@ -83,8 +89,12 @@ final class AugmentProviderRuntime: ProviderRuntime {
 
     private func stopKeepalive(context: ProviderRuntimeContext, reason: String) {
         #if os(macOS)
-        self.keepalive?.stop()
+        guard let keepalive = self.keepalive else { return }
+        keepalive.stop()
         self.keepalive = nil
+        #if DEBUG
+        self._test_keepaliveStopCount += 1
+        #endif
         context.store.augmentLogger.info("Augment keepalive stopped (\(reason))")
         #endif
     }
@@ -92,6 +102,7 @@ final class AugmentProviderRuntime: ProviderRuntime {
     private func forceRefresh(context: ProviderRuntimeContext) async {
         #if os(macOS)
         context.store.augmentLogger.info("Augment force refresh requested")
+        CookieHeaderCache.clear(provider: .augment)
         guard let keepalive = self.keepalive else {
             context.store.augmentLogger.warning("Augment keepalive not running; starting")
             self.startKeepalive(context: context)
@@ -105,8 +116,6 @@ final class AugmentProviderRuntime: ProviderRuntime {
         }
 
         await keepalive.forceRefresh()
-        context.store.augmentLogger.info("Refreshing Augment usage after session refresh")
-        await context.store.refreshProvider(.augment)
         #endif
     }
 }
diff --git a/Sources/CodexBar/Providers/Augment/AugmentSettingsStore.swift b/Sources/CodexBar/Providers/Augment/AugmentSettingsStore.swift
index c0b3bc4617..4e500616ce 100644
--- a/Sources/CodexBar/Providers/Augment/AugmentSettingsStore.swift
+++ b/Sources/CodexBar/Providers/Augment/AugmentSettingsStore.swift
@@ -28,36 +28,10 @@ extension SettingsStore {
 extension SettingsStore {
     func augmentSettingsSnapshot(tokenOverride: TokenAccountOverride?) -> ProviderSettingsSnapshot
     .AugmentProviderSettings {
-        ProviderSettingsSnapshot.AugmentProviderSettings(
-            cookieSource: self.augmentSnapshotCookieSource(tokenOverride: tokenOverride),
-            manualCookieHeader: self.augmentSnapshotCookieHeader(tokenOverride: tokenOverride))
-    }
-
-    private func augmentSnapshotCookieHeader(tokenOverride: TokenAccountOverride?) -> String {
-        let fallback = self.augmentCookieHeader
-        guard let support = TokenAccountSupportCatalog.support(for: .augment),
-              case .cookieHeader = support.injection
-        else {
-            return fallback
-        }
-        guard let account = ProviderTokenAccountSelection.selectedAccount(
+        self.resolvedCookieSettings(
             provider: .augment,
-            settings: self,
-            override: tokenOverride)
-        else {
-            return fallback
-        }
-        return TokenAccountSupportCatalog.normalizedCookieHeader(account.token, support: support)
-    }
-
-    private func augmentSnapshotCookieSource(tokenOverride: TokenAccountOverride?) -> ProviderCookieSource {
-        let fallback = self.augmentCookieSource
-        guard let support = TokenAccountSupportCatalog.support(for: .augment),
-              support.requiresManualCookieSource
-        else {
-            return fallback
-        }
-        if self.tokenAccounts(for: .augment).isEmpty { return fallback }
-        return .manual
+            configuredSource: self.augmentCookieSource,
+            configuredHeader: self.augmentCookieHeader,
+            tokenOverride: tokenOverride)
     }
 }
diff --git a/Sources/CodexBar/Providers/AzureOpenAI/AzureOpenAIProviderImplementation.swift b/Sources/CodexBar/Providers/AzureOpenAI/AzureOpenAIProviderImplementation.swift
new file mode 100644
index 0000000000..9b8c6f3e0a
--- /dev/null
+++ b/Sources/CodexBar/Providers/AzureOpenAI/AzureOpenAIProviderImplementation.swift
@@ -0,0 +1,67 @@
+import CodexBarCore
+import Foundation
+
+struct AzureOpenAIProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .azureopenai
+
+    @MainActor
+    func presentation(context _: ProviderPresentationContext) -> ProviderPresentation {
+        ProviderPresentation { _ in "api" }
+    }
+
+    @MainActor
+    func observeSettings(_ settings: SettingsStore) {
+        _ = settings.azureOpenAIAPIKey
+        _ = settings.azureOpenAIEndpoint
+        _ = settings.azureOpenAIDeploymentName
+    }
+
+    @MainActor
+    func isAvailable(context: ProviderAvailabilityContext) -> Bool {
+        let environment = context.environment
+        let hasEnvironmentConfig = AzureOpenAISettingsReader.apiKey(environment: environment) != nil &&
+            AzureOpenAISettingsReader.rawEndpoint(environment: environment) != nil &&
+            AzureOpenAISettingsReader.deploymentName(environment: environment) != nil
+        if hasEnvironmentConfig { return true }
+
+        return !context.settings.azureOpenAIAPIKey.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty &&
+            !context.settings.azureOpenAIEndpoint.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty &&
+            !context.settings.azureOpenAIDeploymentName.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+    }
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "azure-openai-api-key",
+                title: "API key",
+                subtitle: "Stored in ~/.codexbar/config.json. AZURE_OPENAI_API_KEY is also supported.",
+                kind: .secure,
+                placeholder: "Azure OpenAI key",
+                binding: context.stringBinding(\.azureOpenAIAPIKey),
+                actions: [],
+                isVisible: nil,
+                onActivate: nil),
+            ProviderSettingsFieldDescriptor(
+                id: "azure-openai-endpoint",
+                title: "Endpoint",
+                subtitle: "Azure OpenAI resource endpoint. AZURE_OPENAI_ENDPOINT is also supported.",
+                kind: .plain,
+                placeholder: "https://resource.openai.azure.com",
+                binding: context.stringBinding(\.azureOpenAIEndpoint),
+                actions: [],
+                isVisible: nil,
+                onActivate: nil),
+            ProviderSettingsFieldDescriptor(
+                id: "azure-openai-deployment-name",
+                title: "Deployment",
+                subtitle: "Azure OpenAI deployment name. AZURE_OPENAI_DEPLOYMENT_NAME is also supported.",
+                kind: .plain,
+                placeholder: "gpt-4o-mini",
+                binding: context.stringBinding(\.azureOpenAIDeploymentName),
+                actions: [],
+                isVisible: nil,
+                onActivate: nil),
+        ]
+    }
+}
diff --git a/Sources/CodexBar/Providers/AzureOpenAI/AzureOpenAISettingsStore.swift b/Sources/CodexBar/Providers/AzureOpenAI/AzureOpenAISettingsStore.swift
new file mode 100644
index 0000000000..a2740dba0e
--- /dev/null
+++ b/Sources/CodexBar/Providers/AzureOpenAI/AzureOpenAISettingsStore.swift
@@ -0,0 +1,32 @@
+import CodexBarCore
+import Foundation
+
+extension SettingsStore {
+    var azureOpenAIAPIKey: String {
+        get { self.configSnapshot.providerConfig(for: .azureopenai)?.sanitizedAPIKey ?? "" }
+        set {
+            self.updateProviderConfig(provider: .azureopenai) { entry in
+                entry.apiKey = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .azureopenai, field: "apiKey", value: newValue)
+        }
+    }
+
+    var azureOpenAIEndpoint: String {
+        get { self.configSnapshot.providerConfig(for: .azureopenai)?.sanitizedEnterpriseHost ?? "" }
+        set {
+            self.updateProviderConfig(provider: .azureopenai) { entry in
+                entry.enterpriseHost = self.normalizedConfigValue(newValue)
+            }
+        }
+    }
+
+    var azureOpenAIDeploymentName: String {
+        get { self.configSnapshot.providerConfig(for: .azureopenai)?.sanitizedWorkspaceID ?? "" }
+        set {
+            self.updateProviderConfig(provider: .azureopenai) { entry in
+                entry.workspaceID = self.normalizedConfigValue(newValue)
+            }
+        }
+    }
+}
diff --git a/Sources/CodexBar/Providers/Bedrock/BedrockProviderImplementation.swift b/Sources/CodexBar/Providers/Bedrock/BedrockProviderImplementation.swift
new file mode 100644
index 0000000000..8cdc396fee
--- /dev/null
+++ b/Sources/CodexBar/Providers/Bedrock/BedrockProviderImplementation.swift
@@ -0,0 +1,98 @@
+import AppKit
+import CodexBarCore
+import Foundation
+import SwiftUI
+
+struct BedrockProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .bedrock
+
+    @MainActor
+    func presentation(context _: ProviderPresentationContext) -> ProviderPresentation {
+        ProviderPresentation { _ in "api" }
+    }
+
+    @MainActor
+    func observeSettings(_ settings: SettingsStore) {
+        _ = settings.bedrockAuthMode
+        _ = settings.bedrockProfile
+        _ = settings.bedrockAccessKeyID
+        _ = settings.bedrockSecretAccessKey
+        _ = settings.bedrockRegion
+    }
+
+    @MainActor
+    func isAvailable(context: ProviderAvailabilityContext) -> Bool {
+        BedrockSettingsReader.hasCredentials(environment: context.environment)
+    }
+
+    @MainActor
+    func settingsPickers(context: ProviderSettingsContext) -> [ProviderSettingsPickerDescriptor] {
+        let binding = Binding(
+            get: { context.settings.bedrockAuthMode },
+            set: { context.settings.bedrockAuthMode = $0 })
+        let options = [
+            ProviderSettingsPickerOption(id: BedrockAuthMode.keys.rawValue, title: "Access keys"),
+            ProviderSettingsPickerOption(id: BedrockAuthMode.profile.rawValue, title: "AWS profile"),
+        ]
+        return [
+            ProviderSettingsPickerDescriptor(
+                id: "bedrock-auth-mode",
+                title: "Authentication",
+                subtitle: "Use static access keys, or resolve credentials from a named AWS profile "
+                    + "(supports SSO and assume-role via the AWS CLI).",
+                binding: binding,
+                options: options,
+                isVisible: nil,
+                onChange: nil),
+        ]
+    }
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        let isKeysMode = { context.settings.bedrockAuthMode != BedrockAuthMode.profile.rawValue }
+        let isProfileMode = { context.settings.bedrockAuthMode == BedrockAuthMode.profile.rawValue }
+        return [
+            ProviderSettingsFieldDescriptor(
+                id: "bedrock-profile",
+                title: "Profile name",
+                subtitle: "Named AWS profile from ~/.aws/config. Can also be set with AWS_PROFILE.",
+                kind: .plain,
+                placeholder: "default",
+                binding: context.stringBinding(\.bedrockProfile),
+                actions: [],
+                isVisible: isProfileMode,
+                onActivate: nil),
+            ProviderSettingsFieldDescriptor(
+                id: "bedrock-access-key-id",
+                title: "Access key ID",
+                subtitle: "AWS access key ID. Can also be set with AWS_ACCESS_KEY_ID.",
+                kind: .secure,
+                placeholder: "AKIA...",
+                binding: context.stringBinding(\.bedrockAccessKeyID),
+                actions: [],
+                isVisible: isKeysMode,
+                onActivate: nil),
+            ProviderSettingsFieldDescriptor(
+                id: "bedrock-secret-access-key",
+                title: "Secret access key",
+                subtitle: "AWS secret access key. Can also be set with AWS_SECRET_ACCESS_KEY.",
+                kind: .secure,
+                placeholder: "",
+                binding: context.stringBinding(\.bedrockSecretAccessKey),
+                actions: [],
+                isVisible: isKeysMode,
+                onActivate: nil),
+            ProviderSettingsFieldDescriptor(
+                id: "bedrock-region",
+                title: "Region",
+                subtitle: "AWS region. Can also be set with AWS_REGION. "
+                    + "In profile mode, leave blank to use the profile's region.",
+                kind: .plain,
+                placeholder: "us-east-1",
+                binding: context.stringBinding(\.bedrockRegion),
+                actions: [],
+                isVisible: nil,
+                onActivate: nil),
+        ]
+    }
+}
diff --git a/Sources/CodexBar/Providers/Bedrock/BedrockSettingsStore.swift b/Sources/CodexBar/Providers/Bedrock/BedrockSettingsStore.swift
new file mode 100644
index 0000000000..f01a570685
--- /dev/null
+++ b/Sources/CodexBar/Providers/Bedrock/BedrockSettingsStore.swift
@@ -0,0 +1,58 @@
+import CodexBarCore
+import Foundation
+
+extension SettingsStore {
+    var bedrockAccessKeyID: String {
+        get { self.configSnapshot.providerConfig(for: .bedrock)?.sanitizedAPIKey ?? "" }
+        set {
+            self.updateProviderConfig(provider: .bedrock) { entry in
+                entry.apiKey = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .bedrock, field: "accessKeyID", value: newValue)
+        }
+    }
+
+    var bedrockSecretAccessKey: String {
+        get { self.configSnapshot.providerConfig(for: .bedrock)?.sanitizedSecretKey ?? "" }
+        set {
+            self.updateProviderConfig(provider: .bedrock) { entry in
+                entry.secretKey = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .bedrock, field: "secretAccessKey", value: newValue)
+        }
+    }
+
+    var bedrockRegion: String {
+        get { self.configSnapshot.providerConfig(for: .bedrock)?.region ?? "" }
+        set {
+            self.updateProviderConfig(provider: .bedrock) { entry in
+                entry.region = self.normalizedConfigValue(newValue)
+            }
+            self.logProviderModeChange(provider: .bedrock, field: "region", value: newValue)
+        }
+    }
+
+    var bedrockAuthMode: String {
+        get {
+            self.configSnapshot.providerConfig(for: .bedrock)?.sanitizedAWSAuthMode
+                ?? BedrockAuthMode.keys.rawValue
+        }
+        set {
+            let normalized = BedrockAuthMode(rawValue: newValue)?.rawValue ?? BedrockAuthMode.keys.rawValue
+            self.updateProviderConfig(provider: .bedrock) { entry in
+                entry.awsAuthMode = normalized
+            }
+            self.logProviderModeChange(provider: .bedrock, field: "authMode", value: normalized)
+        }
+    }
+
+    var bedrockProfile: String {
+        get { self.configSnapshot.providerConfig(for: .bedrock)?.awsProfile ?? "" }
+        set {
+            self.updateProviderConfig(provider: .bedrock) { entry in
+                entry.awsProfile = self.normalizedConfigValue(newValue)
+            }
+            self.logProviderModeChange(provider: .bedrock, field: "profile", value: newValue)
+        }
+    }
+}
diff --git a/Sources/CodexBar/Providers/Chutes/ChutesProviderImplementation.swift b/Sources/CodexBar/Providers/Chutes/ChutesProviderImplementation.swift
new file mode 100644
index 0000000000..485392785c
--- /dev/null
+++ b/Sources/CodexBar/Providers/Chutes/ChutesProviderImplementation.swift
@@ -0,0 +1,40 @@
+import CodexBarCore
+import Foundation
+
+struct ChutesProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .chutes
+
+    @MainActor
+    func presentation(context _: ProviderPresentationContext) -> ProviderPresentation {
+        ProviderPresentation { _ in "api" }
+    }
+
+    @MainActor
+    func observeSettings(_ settings: SettingsStore) {
+        _ = settings.chutesAPIKey
+    }
+
+    @MainActor
+    func isAvailable(context: ProviderAvailabilityContext) -> Bool {
+        if ChutesSettingsReader.apiKey(environment: context.environment) != nil {
+            return true
+        }
+        return !context.settings.chutesAPIKey.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+    }
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "chutes-api-key",
+                title: "API key",
+                subtitle: "Stored in ~/.codexbar/config.json. Paste a Chutes API key.",
+                kind: .secure,
+                placeholder: "chutes key...",
+                binding: context.stringBinding(\.chutesAPIKey),
+                actions: [],
+                isVisible: nil,
+                onActivate: nil),
+        ]
+    }
+}
diff --git a/Sources/CodexBar/Providers/Chutes/ChutesSettingsStore.swift b/Sources/CodexBar/Providers/Chutes/ChutesSettingsStore.swift
new file mode 100644
index 0000000000..7c09486298
--- /dev/null
+++ b/Sources/CodexBar/Providers/Chutes/ChutesSettingsStore.swift
@@ -0,0 +1,16 @@
+import CodexBarCore
+import Foundation
+
+extension SettingsStore {
+    var chutesAPIKey: String {
+        get { self.configSnapshot.providerConfig(for: .chutes)?.sanitizedAPIKey ?? "" }
+        set {
+            self.updateProviderConfig(provider: .chutes) { entry in
+                entry.apiKey = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .chutes, field: "apiKey", value: newValue)
+        }
+    }
+
+    func ensureChutesAPIKeyLoaded() {}
+}
diff --git a/Sources/CodexBar/Providers/Claude/ClaudeLoginFlow.swift b/Sources/CodexBar/Providers/Claude/ClaudeLoginFlow.swift
index 9550abb05b..76002520ef 100644
--- a/Sources/CodexBar/Providers/Claude/ClaudeLoginFlow.swift
+++ b/Sources/CodexBar/Providers/Claude/ClaudeLoginFlow.swift
@@ -2,7 +2,7 @@ import CodexBarCore
 
 @MainActor
 extension StatusItemController {
-    func runClaudeLoginFlow() async {
+    func runClaudeLoginFlow() async -> Bool {
         let phaseHandler: @Sendable (ClaudeLoginRunner.Phase) -> Void = { [weak self] phase in
             Task { @MainActor in
                 switch phase {
@@ -12,14 +12,19 @@ extension StatusItemController {
             }
         }
         let result = await ClaudeLoginRunner.run(timeout: 120, onPhaseChange: phaseHandler)
-        guard !Task.isCancelled else { return }
+        guard !Task.isCancelled else { return false }
         self.loginPhase = .idle
         self.presentClaudeLoginResult(result)
         let outcome = self.describe(result.outcome)
         let length = result.output.count
         self.loginLogger.info("Claude login", metadata: ["outcome": outcome, "length": "\(length)"])
         if case .success = result.outcome {
+            let metadata = self.store.metadata(for: .claude)
+            self.settings.setProviderEnabled(provider: .claude, metadata: metadata, enabled: true)
+            self.settings.claudeUsageDataSource = .oauth
             self.postLoginNotification(for: .claude)
+            return true
         }
+        return false
     }
 }
diff --git a/Sources/CodexBar/Providers/Claude/ClaudeProviderImplementation.swift b/Sources/CodexBar/Providers/Claude/ClaudeProviderImplementation.swift
index de1bdffc7f..89134321a9 100644
--- a/Sources/CodexBar/Providers/Claude/ClaudeProviderImplementation.swift
+++ b/Sources/CodexBar/Providers/Claude/ClaudeProviderImplementation.swift
@@ -1,8 +1,6 @@
 import CodexBarCore
-import CodexBarMacroSupport
 import SwiftUI
 
-@ProviderImplementationRegistration
 struct ClaudeProviderImplementation: ProviderImplementation {
     let id: UsageProvider = .claude
     let supportsLoginFlow: Bool = true
@@ -21,6 +19,7 @@ struct ClaudeProviderImplementation: ProviderImplementation {
     @MainActor
     func observeSettings(_ settings: SettingsStore) {
         _ = settings.claudeUsageDataSource
+        _ = settings.claudeAdminAPIKey
         _ = settings.claudeCookieSource
         _ = settings.claudeCookieHeader
         _ = settings.claudeOAuthKeychainPromptMode
@@ -56,6 +55,7 @@ struct ClaudeProviderImplementation: ProviderImplementation {
     func sourceMode(context: ProviderSourceModeContext) -> ProviderSourceMode {
         switch context.settings.claudeUsageDataSource {
         case .auto: .auto
+        case .api: .api
         case .oauth: .oauth
         case .web: .web
         case .cli: .cli
@@ -80,12 +80,13 @@ struct ClaudeProviderImplementation: ProviderImplementation {
         return [
             ProviderSettingsToggleDescriptor(
                 id: "claude-oauth-prompt-free-credentials",
-                title: "Avoid Keychain prompts (experimental)",
+                title: "Avoid Keychain prompts",
                 subtitle: subtitle,
                 binding: promptFreeBinding,
                 statusText: nil,
                 actions: [],
                 isVisible: nil,
+                isEnabled: { !context.settings.debugDisableKeychainAccess },
                 onChange: nil,
                 onAppDidBecomeActive: nil,
                 onAppearWhenEnabled: nil),
@@ -140,7 +141,7 @@ struct ClaudeProviderImplementation: ProviderImplementation {
             if context.settings.debugDisableKeychainAccess {
                 return "Global Keychain access is disabled in Advanced, so this setting is currently inactive."
             }
-            return "Controls Claude OAuth Keychain prompts when experimental reader mode is off. Choosing " +
+            return "Controls Claude OAuth Keychain prompts when the standard reader is active. Choosing " +
                 "\"Never prompt\" can make OAuth unavailable; use Web/CLI when needed."
         }
 
@@ -178,7 +179,7 @@ struct ClaudeProviderImplementation: ProviderImplementation {
                 isVisible: nil,
                 onChange: nil,
                 trailingText: {
-                    guard let entry = CookieHeaderCache.load(provider: .claude) else { return nil }
+                    guard let entry = CookieHeaderCache.loadForDisplay(provider: .claude) else { return nil }
                     let when = entry.storedAt.relativeDescription()
                     return "Cached: \(entry.sourceLabel) • \(when)"
                 }),
@@ -187,20 +188,29 @@ struct ClaudeProviderImplementation: ProviderImplementation {
 
     @MainActor
     func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
-        _ = context
-        return []
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "claude-admin-api-key",
+                title: "Admin API key",
+                subtitle: "Stored in ~/.codexbar/config.json. Requires an Anthropic Admin API key.",
+                kind: .secure,
+                placeholder: "sk-ant-admin...",
+                binding: context.stringBinding(\.claudeAdminAPIKey),
+                actions: [],
+                isVisible: nil,
+                onActivate: nil),
+        ]
     }
 
     @MainActor
     func runLoginFlow(context: ProviderLoginContext) async -> Bool {
         await context.controller.runClaudeLoginFlow()
-        return true
     }
 
     @MainActor
     func appendUsageMenuEntries(context: ProviderMenuUsageContext, entries: inout [ProviderMenuEntry]) {
         if context.snapshot?.secondary == nil {
-            entries.append(.text("Weekly usage unavailable for this account.", .secondary))
+            entries.append(.text(L("Weekly usage unavailable for this account."), .secondary))
         }
 
         if let cost = context.snapshot?.providerCost,
@@ -209,7 +219,7 @@ struct ClaudeProviderImplementation: ProviderImplementation {
         {
             let used = UsageFormatter.currencyString(cost.used, currencyCode: cost.currencyCode)
             let limit = UsageFormatter.currencyString(cost.limit, currencyCode: cost.currencyCode)
-            entries.append(.text("Extra usage: \(used) / \(limit)", .primary))
+            entries.append(.text(String(format: L("extra_usage_format"), used, limit), .primary))
         }
     }
 
@@ -217,10 +227,37 @@ struct ClaudeProviderImplementation: ProviderImplementation {
     func loginMenuAction(context: ProviderMenuLoginContext)
         -> (label: String, action: MenuDescriptor.MenuAction)?
     {
+        if self.shouldOpenBrowserForWebSessionError(context: context) {
+            return ("Re-login at claude.ai", .loginToProvider(url: "https://claude.ai/"))
+        }
         guard self.shouldOpenTerminalForOAuthError(store: context.store) else { return nil }
         return ("Open Terminal", .openTerminal(command: "claude"))
     }
 
+    @MainActor
+    private func shouldOpenBrowserForWebSessionError(context: ProviderMenuLoginContext) -> Bool {
+        let settings = context.settings.claudeSettingsSnapshot(tokenOverride: nil)
+        let source = settings.usageDataSource
+        guard source == .auto || source == .web,
+              settings.cookieSource == .auto,
+              let error = context.store.error(for: .claude)
+        else { return false }
+
+        let sessionErrors = [
+            ClaudeWebAPIFetcher.FetchError.unauthorized.localizedDescription,
+            ClaudeWebAPIFetcher.FetchError.noSessionKeyFound.localizedDescription,
+            ClaudeWebAPIFetcher.FetchError.invalidSessionKey.localizedDescription,
+        ]
+        if sessionErrors.contains(error) {
+            return true
+        }
+
+        guard error == ProviderFetchError.noAvailableStrategy(.claude).localizedDescription else { return false }
+        return context.store.fetchAttempts(for: .claude).contains {
+            $0.strategyID == "claude.web" && !$0.wasAvailable
+        }
+    }
+
     @MainActor
     private func shouldOpenTerminalForOAuthError(store: UsageStore) -> Bool {
         guard store.error(for: .claude) != nil else { return false }
diff --git a/Sources/CodexBar/Providers/Claude/ClaudeSettingsStore.swift b/Sources/CodexBar/Providers/Claude/ClaudeSettingsStore.swift
index f28a473740..0819b75033 100644
--- a/Sources/CodexBar/Providers/Claude/ClaudeSettingsStore.swift
+++ b/Sources/CodexBar/Providers/Claude/ClaudeSettingsStore.swift
@@ -10,6 +10,7 @@ extension SettingsStore {
         set {
             let source: ProviderSourceMode? = switch newValue {
             case .auto: .auto
+            case .api: .api
             case .oauth: .oauth
             case .web: .web
             case .cli: .cli
@@ -45,23 +46,38 @@ extension SettingsStore {
     }
 
     func ensureClaudeCookieLoaded() {}
+
+    var claudeAdminAPIKey: String {
+        get { self.configSnapshot.providerConfig(for: .claude)?.sanitizedAPIKey ?? "" }
+        set {
+            self.updateProviderConfig(provider: .claude) { entry in
+                entry.apiKey = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .claude, field: "apiKey", value: newValue)
+        }
+    }
 }
 
 extension SettingsStore {
     func claudeSettingsSnapshot(tokenOverride: TokenAccountOverride?) -> ProviderSettingsSnapshot
     .ClaudeProviderSettings {
-        ProviderSettingsSnapshot.ClaudeProviderSettings(
+        let account = self.selectedClaudeTokenAccount(tokenOverride: tokenOverride)
+        let routing = self.claudeCredentialRouting(account: account)
+        return ProviderSettingsSnapshot.ClaudeProviderSettings(
             usageDataSource: self.claudeUsageDataSource,
             webExtrasEnabled: self.claudeWebExtrasEnabled,
-            cookieSource: self.claudeSnapshotCookieSource(tokenOverride: tokenOverride),
-            manualCookieHeader: self.claudeSnapshotCookieHeader(tokenOverride: tokenOverride))
+            cookieSource: self.claudeSnapshotCookieSource(tokenOverride: tokenOverride, routing: routing),
+            manualCookieHeader: self.claudeSnapshotCookieHeader(
+                routing: routing,
+                hasSelectedAccount: account != nil),
+            organizationID: account?.sanitizedOrganizationID)
     }
 
     private static func claudeUsageDataSource(from source: ProviderSourceMode?) -> ClaudeUsageDataSource {
         guard let source else { return .auto }
         switch source {
         case .auto, .api:
-            return .auto
+            return source == .api ? .api : .auto
         case .web:
             return .web
         case .cli:
@@ -71,42 +87,53 @@ extension SettingsStore {
         }
     }
 
-    private func claudeSnapshotCookieHeader(tokenOverride: TokenAccountOverride?) -> String {
-        let fallback = self.claudeCookieHeader
-        guard let support = TokenAccountSupportCatalog.support(for: .claude),
-              case .cookieHeader = support.injection
-        else {
-            return fallback
-        }
-        guard let account = ProviderTokenAccountSelection.selectedAccount(
-            provider: .claude,
-            settings: self,
-            override: tokenOverride)
-        else {
-            return fallback
-        }
-        if TokenAccountSupportCatalog.isClaudeOAuthToken(account.token) {
-            return ""
+    private func claudeSnapshotCookieHeader(
+        routing: ClaudeCredentialRouting,
+        hasSelectedAccount: Bool) -> String
+    {
+        switch routing {
+        case .none:
+            hasSelectedAccount ? "" : self.claudeCookieHeader
+        case .oauth:
+            ""
+        case .adminAPIKey:
+            ""
+        case let .webCookie(header):
+            header
         }
-        return TokenAccountSupportCatalog.normalizedCookieHeader(account.token, support: support)
     }
 
-    private func claudeSnapshotCookieSource(tokenOverride: TokenAccountOverride?) -> ProviderCookieSource {
+    private func claudeSnapshotCookieSource(
+        tokenOverride: TokenAccountOverride?,
+        routing: ClaudeCredentialRouting) -> ProviderCookieSource
+    {
         let fallback = self.claudeCookieSource
         guard let support = TokenAccountSupportCatalog.support(for: .claude),
               support.requiresManualCookieSource
         else {
             return fallback
         }
-        if let account = ProviderTokenAccountSelection.selectedAccount(
-            provider: .claude,
-            settings: self,
-            override: tokenOverride),
-            TokenAccountSupportCatalog.isClaudeOAuthToken(account.token)
-        {
+        if routing.isOAuth {
+            return .off
+        }
+        if routing.adminAPIKey != nil {
             return .off
         }
         if self.tokenAccounts(for: .claude).isEmpty { return fallback }
         return .manual
     }
+
+    private func claudeCredentialRouting(account: ProviderTokenAccount?) -> ClaudeCredentialRouting {
+        let manualCookieHeader = account == nil ? self.claudeCookieHeader : nil
+        return ClaudeCredentialRouting.resolve(
+            tokenAccountToken: account?.token,
+            manualCookieHeader: manualCookieHeader)
+    }
+
+    private func selectedClaudeTokenAccount(tokenOverride: TokenAccountOverride?) -> ProviderTokenAccount? {
+        ProviderTokenAccountSelection.selectedAccount(
+            provider: .claude,
+            settings: self,
+            override: tokenOverride)
+    }
 }
diff --git a/Sources/CodexBar/Providers/Codebuff/CodebuffProviderImplementation.swift b/Sources/CodexBar/Providers/Codebuff/CodebuffProviderImplementation.swift
new file mode 100644
index 0000000000..be32da459e
--- /dev/null
+++ b/Sources/CodexBar/Providers/Codebuff/CodebuffProviderImplementation.swift
@@ -0,0 +1,40 @@
+import AppKit
+import CodexBarCore
+import Foundation
+
+struct CodebuffProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .codebuff
+
+    @MainActor
+    func observeSettings(_ settings: SettingsStore) {
+        _ = settings.codebuffAPIToken
+    }
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "codebuff-api-key",
+                title: "API key",
+                subtitle: "Stored in ~/.codexbar/config.json. You can also provide CODEBUFF_API_KEY or let " +
+                    "CodexBar read ~/.config/manicode/credentials.json (created by `codebuff login`).",
+                kind: .secure,
+                placeholder: "cb_...",
+                binding: context.stringBinding(\.codebuffAPIToken),
+                actions: [
+                    ProviderSettingsActionDescriptor(
+                        id: "codebuff-open-dashboard",
+                        title: "Open Codebuff Dashboard",
+                        style: .link,
+                        isVisible: nil,
+                        perform: {
+                            if let url = URL(string: "https://www.codebuff.com/usage") {
+                                NSWorkspace.shared.open(url)
+                            }
+                        }),
+                ],
+                isVisible: nil,
+                onActivate: nil),
+        ]
+    }
+}
diff --git a/Sources/CodexBar/Providers/Codebuff/CodebuffSettingsStore.swift b/Sources/CodexBar/Providers/Codebuff/CodebuffSettingsStore.swift
new file mode 100644
index 0000000000..d07c8b3fa2
--- /dev/null
+++ b/Sources/CodexBar/Providers/Codebuff/CodebuffSettingsStore.swift
@@ -0,0 +1,14 @@
+import CodexBarCore
+import Foundation
+
+extension SettingsStore {
+    var codebuffAPIToken: String {
+        get { self.configSnapshot.providerConfig(for: .codebuff)?.sanitizedAPIKey ?? "" }
+        set {
+            self.updateProviderConfig(provider: .codebuff) { entry in
+                entry.apiKey = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .codebuff, field: "apiKey", value: newValue)
+        }
+    }
+}
diff --git a/Sources/CodexBar/Providers/Codex/CodexConsumerProjection.swift b/Sources/CodexBar/Providers/Codex/CodexConsumerProjection.swift
new file mode 100644
index 0000000000..287db61f4c
--- /dev/null
+++ b/Sources/CodexBar/Providers/Codex/CodexConsumerProjection.swift
@@ -0,0 +1,433 @@
+import CodexBarCore
+import Foundation
+
+struct CodexUIErrorMapper {
+    private static let codexCLINotSignedInMessage =
+        "Codex CLI is not signed in. Run `codex login --device-auth`, then refresh."
+
+    static func userFacingMessage(_ raw: String?) -> String? {
+        guard let raw, !raw.isEmpty else { return nil }
+        let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else { return nil }
+
+        let lower = trimmed.lowercased()
+        if self.isAlreadyUserFacing(lower: lower) {
+            return trimmed
+        }
+
+        if let cachedMessage = self.cachedMessage(raw: trimmed, lower: lower) {
+            return cachedMessage
+        }
+
+        if self.looksCodexCLIMissing(lower: lower) {
+            return CodexStatusProbeError.codexNotInstalled.localizedDescription
+        }
+
+        if self.looksCodexCLILoginRequired(lower: lower) {
+            return self.codexCLINotSignedInMessage
+        }
+
+        if self.looksExpired(lower: lower) {
+            return "Codex session expired. Sign in again."
+        }
+
+        if lower.contains("frame load interrupted") {
+            return "OpenAI web refresh was interrupted. Refresh OpenAI cookies and try again."
+        }
+
+        if self.looksOpenAIWebTimeout(lower: lower) {
+            return "OpenAI web refresh timed out. Refresh OpenAI cookies and try again."
+        }
+
+        if self.looksOpenAIWebNetworkError(lower: lower) {
+            return "OpenAI web refresh hit a network error. "
+                + "Check your connection, then refresh OpenAI cookies and try again."
+        }
+
+        if self.looksInternalTransport(lower: lower) {
+            return "Codex usage is temporarily unavailable. Try refreshing."
+        }
+
+        return trimmed
+    }
+
+    private static func cachedMessage(raw: String, lower: String) -> String? {
+        let cachedMarker = " Cached values from "
+        guard let suffixRange = raw.range(of: cachedMarker) else { return nil }
+
+        let suffix = String(raw[suffixRange.lowerBound...]).trimmingCharacters(in: .whitespacesAndNewlines)
+        if lower.hasPrefix("last codex credits refresh failed:"),
+           let base = self.userFacingMessage(String(raw[..<suffixRange.lowerBound]))
+        {
+            return "\(base) \(suffix)"
+        }
+
+        if lower.hasPrefix("last openai dashboard refresh failed:"),
+           let base = self.userFacingMessage(String(raw[..<suffixRange.lowerBound]))
+        {
+            return "\(base) \(suffix)"
+        }
+
+        return nil
+    }
+
+    private static func isAlreadyUserFacing(lower: String) -> Bool {
+        lower.contains("openai cookies are for")
+            || lower.contains("sign in to chatgpt.com")
+            || lower.contains("requires a signed-in chatgpt.com session")
+            || lower.contains("managed codex account data is unavailable")
+            || lower.contains("selected managed codex account is unavailable")
+            || lower.contains("codex credits are still loading")
+            || lower.contains("codex account changed; importing browser cookies")
+            || lower.contains("codex cli is not signed in.")
+            || lower.contains("codex session expired. sign in again.")
+            || lower.contains("openai web refresh timed out. refresh openai cookies and try again.")
+            || lower.contains(
+                "openai web refresh hit a network error. "
+                    + "check your connection, then refresh openai cookies and try again.")
+            || lower.contains("codex usage is temporarily unavailable. try refreshing.")
+    }
+
+    private static func looksCodexCLIMissing(lower: String) -> Bool {
+        lower.contains("codex cli missing")
+            || lower.contains("codex cli not found")
+            || lower.contains("missing cli codex")
+            || lower.contains("missing cli 'codex'")
+            || lower.contains("missing cli \"codex\"")
+            || (lower.contains("binary not found") && lower.contains("codex"))
+    }
+
+    private static func looksCodexCLILoginRequired(lower: String) -> Bool {
+        lower.contains("codex account authentication required")
+            || lower.contains("account authentication required to read rate limits")
+            || lower.contains("requiresopenaiauth")
+    }
+
+    private static func looksExpired(lower: String) -> Bool {
+        lower.contains("token_expired")
+            || lower.contains("authentication token is expired")
+            || lower.contains("oauth token has expired")
+            || lower.contains("provided authentication token is expired")
+            || lower.contains("please try signing in again")
+            || lower.contains("please sign in again")
+            || (lower.contains("401") && lower.contains("unauthorized"))
+    }
+
+    private static func looksInternalTransport(lower: String) -> Bool {
+        lower.contains("codex connection failed")
+            || lower.contains("failed to fetch codex rate limits")
+            || lower.contains("/backend-api/")
+            || lower.contains("content-type=")
+            || lower.contains("body={")
+            || lower.contains("body=")
+            || lower.contains("get https://")
+            || lower.contains("get http://")
+            || lower.contains("returned invalid data")
+    }
+
+    private static func looksOpenAIWebTimeout(lower: String) -> Bool {
+        lower.contains("nsurlerrordomain")
+            && (lower.contains("timed out") || lower.contains("error -1001"))
+    }
+
+    private static func looksOpenAIWebNetworkError(lower: String) -> Bool {
+        lower.contains("nsurlerrordomain")
+    }
+}
+
+struct CodexConsumerProjection {
+    enum Surface {
+        case liveCard
+        case overrideCard
+        case widget
+        case menuBar
+    }
+
+    enum RateLane: String {
+        case session
+        case weekly
+    }
+
+    enum SupplementalMetric: String {
+        case codeReview
+    }
+
+    struct PlanUtilizationLane {
+        let role: PlanUtilizationSeriesName
+        let window: RateWindow
+    }
+
+    enum DashboardVisibility {
+        case hidden
+        case displayOnly
+        case attached
+    }
+
+    struct CreditsProjection {
+        let snapshot: CreditsSnapshot?
+        let userFacingError: String?
+
+        var remaining: Double? {
+            self.snapshot?.remaining
+        }
+    }
+
+    struct UserFacingErrors {
+        let usage: String?
+        let credits: String?
+        let dashboard: String?
+    }
+
+    struct Context {
+        let snapshot: UsageSnapshot?
+        let rawUsageError: String?
+        let liveCredits: CreditsSnapshot?
+        let rawCreditsError: String?
+        let liveDashboard: OpenAIDashboardSnapshot?
+        let rawDashboardError: String?
+        let dashboardAttachmentAuthorized: Bool
+        let dashboardRequiresLogin: Bool
+        let now: Date
+    }
+
+    enum MenuBarFallback {
+        case none
+        case creditsBalance
+    }
+
+    let visibleRateLanes: [RateLane]
+    let supplementalMetrics: [SupplementalMetric]
+    let planUtilizationLanes: [PlanUtilizationLane]
+    let dashboardVisibility: DashboardVisibility
+    let credits: CreditsProjection?
+    let menuBarFallback: MenuBarFallback
+    let userFacingErrors: UserFacingErrors
+    let canShowBuyCredits: Bool
+    let hasUsageBreakdown: Bool
+    let hasCreditsHistory: Bool
+
+    private let rateWindowsByLane: [RateLane: RateWindow]
+    private let codeReviewRemainingPercent: Double?
+    private let codeReviewLimit: RateWindow?
+
+    static func make(surface: Surface, context: Context) -> CodexConsumerProjection {
+        let allowsLiveAdjuncts = surface != .overrideCard
+        let dashboardVisibility = self.dashboardVisibility(surface: surface, context: context)
+        let dashboard = allowsLiveAdjuncts && dashboardVisibility != .hidden ? context.liveDashboard : nil
+
+        let rateWindowsByLane = self.rateWindowsByLane(snapshot: context.snapshot)
+        let visibleRateLanes = self.visibleRateLanes(from: rateWindowsByLane, snapshot: context.snapshot)
+        let planUtilizationLanes = self.planUtilizationLanes(from: rateWindowsByLane)
+
+        let creditsProjection: CreditsProjection? = if allowsLiveAdjuncts,
+                                                       context.liveCredits != nil || context.rawCreditsError != nil
+        {
+            CreditsProjection(
+                snapshot: context.liveCredits,
+                userFacingError: CodexUIErrorMapper.userFacingMessage(context.rawCreditsError))
+        } else {
+            nil
+        }
+
+        let userFacingErrors = UserFacingErrors(
+            usage: CodexUIErrorMapper.userFacingMessage(context.rawUsageError),
+            credits: allowsLiveAdjuncts ? CodexUIErrorMapper.userFacingMessage(context.rawCreditsError) : nil,
+            dashboard: allowsLiveAdjuncts ? CodexUIErrorMapper.userFacingMessage(context.rawDashboardError) : nil)
+
+        let supplementalMetrics: [SupplementalMetric] = if surface == .liveCard,
+                                                           dashboardVisibility == .attached,
+                                                           dashboard?.codeReviewRemainingPercent != nil
+        {
+            [.codeReview]
+        } else {
+            []
+        }
+
+        let displayableUsageBreakdown = OpenAIDashboardDailyBreakdown.removingSkillUsageServices(
+            from: dashboard?.usageBreakdown ?? [])
+        let canShowBuyCredits = surface == .liveCard
+        let hasUsageBreakdown = surface == .liveCard
+            && dashboardVisibility == .attached
+            && !displayableUsageBreakdown.isEmpty
+        let hasCreditsHistory = surface == .liveCard
+            && dashboardVisibility == .attached
+            && !(dashboard?.dailyBreakdown ?? []).isEmpty
+
+        return CodexConsumerProjection(
+            visibleRateLanes: visibleRateLanes,
+            supplementalMetrics: supplementalMetrics,
+            planUtilizationLanes: planUtilizationLanes,
+            dashboardVisibility: dashboardVisibility,
+            credits: creditsProjection,
+            menuBarFallback: self.menuBarFallback(
+                creditsRemaining: creditsProjection?.remaining,
+                rateWindowsByLane: rateWindowsByLane),
+            userFacingErrors: userFacingErrors,
+            canShowBuyCredits: canShowBuyCredits,
+            hasUsageBreakdown: hasUsageBreakdown,
+            hasCreditsHistory: hasCreditsHistory,
+            rateWindowsByLane: rateWindowsByLane,
+            codeReviewRemainingPercent: dashboardVisibility == .attached ? dashboard?.codeReviewRemainingPercent : nil,
+            codeReviewLimit: dashboardVisibility == .attached ? dashboard?.codeReviewLimit : nil)
+    }
+
+    func rateWindow(for lane: RateLane) -> RateWindow? {
+        self.rateWindowsByLane[lane]
+    }
+
+    func remainingPercent(for metric: SupplementalMetric) -> Double? {
+        switch metric {
+        case .codeReview:
+            self.codeReviewRemainingPercent
+        }
+    }
+
+    func limitWindow(for metric: SupplementalMetric) -> RateWindow? {
+        switch metric {
+        case .codeReview:
+            self.codeReviewLimit
+        }
+    }
+
+    private static func dashboardVisibility(surface: Surface, context: Context) -> DashboardVisibility {
+        guard surface != .overrideCard else { return .hidden }
+        guard context.dashboardRequiresLogin == false, context.liveDashboard != nil else { return .hidden }
+        return context.dashboardAttachmentAuthorized ? .attached : .displayOnly
+    }
+
+    private static func rateWindowsByLane(snapshot: UsageSnapshot?) -> [RateLane: RateWindow] {
+        guard let snapshot else { return [:] }
+
+        var windowsByLane: [RateLane: RateWindow] = [:]
+        let slottedWindows: [(RateLane, RateWindow)] = [
+            self.classifyRateWindow(snapshot.primary, slot: .primary),
+            self.classifyRateWindow(snapshot.secondary, slot: .secondary),
+        ].compactMap(\.self)
+
+        for (lane, window) in slottedWindows {
+            windowsByLane[lane] = window
+        }
+        return windowsByLane
+    }
+
+    private static func visibleRateLanes(
+        from rateWindowsByLane: [RateLane: RateWindow],
+        snapshot: UsageSnapshot?) -> [RateLane]
+    {
+        guard let snapshot else { return [] }
+
+        let slottedLanes = [
+            self.classifyRateWindow(snapshot.primary, slot: .primary)?.0,
+            self.classifyRateWindow(snapshot.secondary, slot: .secondary)?.0,
+        ].compactMap(\.self)
+
+        var visible: [RateLane] = []
+        for lane in slottedLanes where rateWindowsByLane[lane] != nil && !visible.contains(lane) {
+            visible.append(lane)
+        }
+        return visible
+    }
+
+    private static func planUtilizationLanes(from rateWindowsByLane: [RateLane: RateWindow]) -> [PlanUtilizationLane] {
+        let semanticOrder: [RateLane] = [.session, .weekly]
+        return semanticOrder.compactMap { lane in
+            guard let window = rateWindowsByLane[lane] else { return nil }
+            return PlanUtilizationLane(role: self.planUtilizationRole(for: lane), window: window)
+        }
+    }
+
+    private static func planUtilizationRole(for lane: RateLane) -> PlanUtilizationSeriesName {
+        switch lane {
+        case .session:
+            .session
+        case .weekly:
+            .weekly
+        }
+    }
+
+    private enum SnapshotSlot {
+        case primary
+        case secondary
+    }
+
+    private static func classifyRateWindow(_ window: RateWindow?, slot: SnapshotSlot) -> (RateLane, RateWindow)? {
+        guard let window else { return nil }
+
+        let lane: RateLane = switch window.windowMinutes {
+        case 300:
+            .session
+        case 10080:
+            .weekly
+        default:
+            switch slot {
+            case .primary:
+                .session
+            case .secondary:
+                .weekly
+            }
+        }
+
+        return (lane, window)
+    }
+
+    private static func menuBarFallback(
+        creditsRemaining: Double?,
+        rateWindowsByLane: [RateLane: RateWindow]) -> MenuBarFallback
+    {
+        guard let creditsRemaining, creditsRemaining > 0 else { return .none }
+        let hasExhaustedLane = rateWindowsByLane.values.contains { $0.remainingPercent <= 0 }
+        let hasNoRateWindows = rateWindowsByLane.isEmpty
+        return (hasExhaustedLane || hasNoRateWindows) ? .creditsBalance : .none
+    }
+
+    var hasExhaustedRateLane: Bool {
+        self.rateWindowsByLane.values.contains { $0.remainingPercent <= 0 }
+    }
+}
+
+extension UsageStore {
+    func codexConsumerProjectionIfNeeded(
+        for provider: UsageProvider,
+        surface: CodexConsumerProjection.Surface,
+        snapshotOverride: UsageSnapshot? = nil,
+        errorOverride: String? = nil,
+        now: Date = Date()) -> CodexConsumerProjection?
+    {
+        guard provider == .codex else { return nil }
+        return self.codexConsumerProjection(
+            surface: surface,
+            snapshotOverride: snapshotOverride,
+            errorOverride: errorOverride,
+            now: now)
+    }
+
+    func codexConsumerProjection(
+        surface: CodexConsumerProjection.Surface,
+        snapshotOverride: UsageSnapshot? = nil,
+        errorOverride: String? = nil,
+        now: Date = Date()) -> CodexConsumerProjection
+    {
+        let snapshot = surface == .overrideCard ? snapshotOverride : snapshotOverride ?? self.snapshots[.codex]
+        let rawUsageError = surface == .overrideCard ? errorOverride : errorOverride ?? self.errors[.codex]
+        let context = CodexConsumerProjection.Context(
+            snapshot: snapshot,
+            rawUsageError: rawUsageError,
+            liveCredits: self.credits,
+            rawCreditsError: self.lastCreditsError,
+            liveDashboard: self.openAIDashboard,
+            rawDashboardError: self.lastOpenAIDashboardError,
+            dashboardAttachmentAuthorized: self.openAIDashboardAttachmentAuthorized,
+            dashboardRequiresLogin: self.openAIDashboardRequiresLogin,
+            now: now)
+        return CodexConsumerProjection.make(surface: surface, context: context)
+    }
+
+    func codexMenuBarCreditsRemaining(snapshotOverride: UsageSnapshot? = nil, now: Date = Date()) -> Double? {
+        let projection = self.codexConsumerProjection(
+            surface: .menuBar,
+            snapshotOverride: snapshotOverride,
+            now: now)
+        guard projection.menuBarFallback == .creditsBalance else { return nil }
+        return projection.credits?.remaining
+    }
+}
diff --git a/Sources/CodexBar/Providers/Codex/CodexLoginFlow.swift b/Sources/CodexBar/Providers/Codex/CodexLoginFlow.swift
index c8847374c1..a35c38b4d4 100644
--- a/Sources/CodexBar/Providers/Codex/CodexLoginFlow.swift
+++ b/Sources/CodexBar/Providers/Codex/CodexLoginFlow.swift
@@ -3,7 +3,23 @@ import CodexBarCore
 @MainActor
 extension StatusItemController {
     func runCodexLoginFlow() async {
+        // This menu action still follows the ambient Codex login behavior. Managed-account authentication is
+        // implemented separately, but wiring add/switch/re-auth UI through that service needs its own account-aware
+        // flow so this entry point does not silently change what "Switch Account" means for existing users.
+        self.codexAccountPromotionCoordinator.setLiveReauthenticationInProgress(true)
+        defer {
+            self.codexAccountPromotionCoordinator.setLiveReauthenticationInProgress(false)
+        }
+        #if DEBUG
+        let result =
+            if let override = self._test_codexAmbientLoginRunnerOverride {
+                await override(120)
+            } else {
+                await CodexLoginRunner.run(timeout: 120)
+            }
+        #else
         let result = await CodexLoginRunner.run(timeout: 120)
+        #endif
         guard !Task.isCancelled else { return }
         self.loginPhase = .idle
         self.presentCodexLoginResult(result)
diff --git a/Sources/CodexBar/Providers/Codex/CodexProviderImplementation.swift b/Sources/CodexBar/Providers/Codex/CodexProviderImplementation.swift
index 61aa3a5017..92c67ec9af 100644
--- a/Sources/CodexBar/Providers/Codex/CodexProviderImplementation.swift
+++ b/Sources/CodexBar/Providers/Codex/CodexProviderImplementation.swift
@@ -1,9 +1,7 @@
 import CodexBarCore
-import CodexBarMacroSupport
 import Foundation
 import SwiftUI
 
-@ProviderImplementationRegistration
 struct CodexProviderImplementation: ProviderImplementation {
     let id: UsageProvider = .codex
     let supportsLoginFlow: Bool = true
@@ -24,7 +22,9 @@ struct CodexProviderImplementation: ProviderImplementation {
 
     @MainActor
     func settingsSnapshot(context: ProviderSettingsSnapshotContext) -> ProviderSettingsSnapshotContribution? {
-        .codex(context.settings.codexSettingsSnapshot(tokenOverride: context.tokenOverride))
+        .codex(context.settings.codexSettingsSnapshot(
+            tokenOverride: context.tokenOverride,
+            activeSourceOverride: context.codexActiveSourceOverride))
     }
 
     @MainActor
@@ -69,6 +69,7 @@ struct CodexProviderImplementation: ProviderImplementation {
                         for: .codex)
                 }
             })
+        let batterySaverBinding = context.boolBinding(\.openAIWebBatterySaverEnabled)
 
         return [
             ProviderSettingsToggleDescriptor(
@@ -85,7 +86,10 @@ struct CodexProviderImplementation: ProviderImplementation {
             ProviderSettingsToggleDescriptor(
                 id: "codex-openai-web-extras",
                 title: "OpenAI web extras",
-                subtitle: "Show usage breakdown, credits history, and code review via chatgpt.com.",
+                subtitle: [
+                    "Optional.",
+                    "Turn this on to show code review, usage breakdown, and credits history via chatgpt.com.",
+                ].joined(separator: " "),
                 binding: extrasBinding,
                 statusText: nil,
                 actions: [],
@@ -93,6 +97,20 @@ struct CodexProviderImplementation: ProviderImplementation {
                 onChange: nil,
                 onAppDidBecomeActive: nil,
                 onAppearWhenEnabled: nil),
+            ProviderSettingsToggleDescriptor(
+                id: "codex-openai-web-battery-saver",
+                title: "Battery Saver",
+                subtitle: [
+                    "Limits background chatgpt.com refreshes to reduce battery and network usage.",
+                    "Dashboard extras may stay stale until you refresh them manually.",
+                ].joined(separator: " "),
+                binding: batterySaverBinding,
+                statusText: nil,
+                actions: [],
+                isVisible: { context.settings.openAIWebAccessEnabled },
+                onChange: nil,
+                onAppDidBecomeActive: nil,
+                onAppearWhenEnabled: nil),
         ]
     }
 
@@ -149,7 +167,7 @@ struct CodexProviderImplementation: ProviderImplementation {
                 isVisible: { context.settings.openAIWebAccessEnabled },
                 onChange: nil,
                 trailingText: {
-                    guard let entry = CookieHeaderCache.load(provider: .codex) else { return nil }
+                    guard let entry = CookieHeaderCache.loadForDisplay(provider: .codex) else { return nil }
                     let when = entry.storedAt.relativeDescription()
                     return "Cached: \(entry.sourceLabel) • \(when)"
                 }),
@@ -181,16 +199,56 @@ struct CodexProviderImplementation: ProviderImplementation {
         else { return }
 
         if let credits = context.store.credits {
-            entries.append(.text("Credits: \(UsageFormatter.creditsString(from: credits.remaining))", .primary))
+            entries.append(.text(
+                String(format: L("credits_remaining"), UsageFormatter.creditsString(from: credits.remaining)),
+                .primary))
             if let latest = credits.events.first {
-                entries.append(.text("Last spend: \(UsageFormatter.creditEventSummary(latest))", .secondary))
+                entries.append(.text(
+                    String(format: L("last_spend"), UsageFormatter.creditEventSummary(latest)),
+                    .secondary))
             }
         } else {
-            let hint = context.store.lastCreditsError ?? context.metadata.creditsHint
+            let hint = context.store.userFacingLastCreditsError ?? context.metadata.creditsHint
             entries.append(.text(hint, .secondary))
         }
     }
 
+    @MainActor
+    func loginMenuAction(context _: ProviderMenuLoginContext)
+        -> (label: String, action: MenuDescriptor.MenuAction)?
+    {
+        ("Add Account...", .addCodexAccount)
+    }
+
+    @MainActor
+    func appendActionMenuEntries(context: ProviderMenuActionContext, entries: inout [ProviderMenuEntry]) {
+        let projection = context.settings.codexVisibleAccountProjection
+        guard !projection.visibleAccounts.isEmpty else { return }
+
+        let isInteractionBlocked = context.codexAccountPromotionCoordinator?.isInteractionBlocked() ?? false
+
+        let submenuItems = projection.visibleAccounts.map { account in
+            let isChecked = account.id == projection.liveVisibleAccountID
+            let isEnabled = !isInteractionBlocked &&
+                !isChecked &&
+                account.storedAccountID != nil
+            let action = account.storedAccountID.map(MenuDescriptor.MenuAction.requestCodexSystemPromotion)
+            return MenuDescriptor.SubmenuItem(
+                title: account.displayName,
+                action: action,
+                isEnabled: isEnabled,
+                isChecked: isChecked)
+        }
+        guard submenuItems.count > 1 || submenuItems.contains(where: { $0.isEnabled && $0.action != nil }) else {
+            return
+        }
+
+        entries.append(.submenu(
+            "System Account",
+            MenuDescriptor.MenuActionSystemImage.systemAccount.rawValue,
+            submenuItems))
+    }
+
     @MainActor
     func runLoginFlow(context: ProviderLoginContext) async -> Bool {
         await context.controller.runCodexLoginFlow()
diff --git a/Sources/CodexBar/Providers/Codex/CodexSettingsStore.swift b/Sources/CodexBar/Providers/Codex/CodexSettingsStore.swift
index 335dbf4113..79ffbf1a95 100644
--- a/Sources/CodexBar/Providers/Codex/CodexSettingsStore.swift
+++ b/Sources/CodexBar/Providers/Codex/CodexSettingsStore.swift
@@ -2,6 +2,148 @@ import CodexBarCore
 import Foundation
 
 extension SettingsStore {
+    private var codexPersistedActiveSource: CodexActiveSource {
+        self.providerConfig(for: .codex)?.codexActiveSource ?? .liveSystem
+    }
+
+    private enum ManagedCodexAccountStoreState {
+        case none
+        case selected(ManagedCodexAccount)
+        case unreadable
+    }
+
+    private static func failClosedManagedCodexHomePath(fileManager: FileManager = .default) -> String {
+        ManagedCodexHomeFactory.defaultRootURL(fileManager: fileManager)
+            .appendingPathComponent("managed-store-unreadable", isDirectory: true)
+            .path
+    }
+
+    private static func normalizedCodexProfileHomePaths(_ paths: [String]?) -> [String] {
+        var seen: Set<String> = []
+        var result: [String] = []
+        for path in (paths ?? []).compactMap({ CodexHomeScope.normalizedHomePath($0) }) {
+            guard seen.insert(path).inserted else { continue }
+            result.append(path)
+        }
+        return result
+    }
+
+    private func loadManagedCodexAccounts() throws -> ManagedCodexAccountSet {
+        #if DEBUG
+        if CodexManagedRemoteHomeTestingOverride.isUnreadable(for: self) {
+            throw CodexManagedRemoteHomeTestingOverrideError.unreadableManagedStore
+        }
+        if let override = CodexManagedRemoteHomeTestingOverride.account(for: self) {
+            return ManagedCodexAccountSet(
+                version: FileManagedCodexAccountStore.currentVersion,
+                accounts: [override])
+        }
+        let store = if let storeURL = CodexManagedRemoteHomeTestingOverride.managedStoreURL(for: self) {
+            FileManagedCodexAccountStore(fileURL: storeURL)
+        } else {
+            FileManagedCodexAccountStore()
+        }
+        #else
+        let store = FileManagedCodexAccountStore()
+        #endif
+
+        return try store.loadAccounts()
+    }
+
+    private func managedCodexAccountStoreState(
+        activeSource: CodexActiveSource? = nil) -> ManagedCodexAccountStoreState
+    {
+        let source = activeSource ?? self.codexResolvedActiveSource
+        guard case let .managedAccount(id) = source else {
+            return .none
+        }
+        do {
+            let accounts = try self.loadManagedCodexAccounts()
+            guard let account = accounts.account(id: id)
+            else {
+                return .none
+            }
+            return .selected(account)
+        } catch {
+            return .unreadable
+        }
+    }
+
+    var activeManagedCodexAccount: ManagedCodexAccount? {
+        guard case let .selected(account) = self.managedCodexAccountStoreState() else {
+            return nil
+        }
+        return account
+    }
+
+    var activeManagedCodexRemoteHomePath: String? {
+        self.managedCodexRemoteHomePath(forActiveSource: self.codexResolvedActiveSource)
+    }
+
+    func liveSystemCodexHomePath(forActiveSource source: CodexActiveSource) -> String? {
+        guard source == .liveSystem else {
+            return nil
+        }
+        let path = self.codexAccountReconciliationSnapshot(activeSourceOverride: source)
+            .liveSystemAccount?.codexHomePath.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard let path, !path.isEmpty else {
+            return nil
+        }
+        return path
+    }
+
+    var codexProfileHomePaths: [String] {
+        Self.normalizedCodexProfileHomePaths(
+            self.configSnapshot.providerConfig(for: .codex)?.codexProfileHomePaths)
+    }
+
+    func profileCodexHomePath(forActiveSource source: CodexActiveSource) -> String? {
+        guard case let .profileHome(path) = source else {
+            return nil
+        }
+        guard let normalizedPath = CodexHomeScope.normalizedHomePath(path),
+              self.codexProfileHomePaths.contains(normalizedPath)
+        else {
+            return nil
+        }
+        return normalizedPath
+    }
+
+    func managedCodexRemoteHomePath(forActiveSource source: CodexActiveSource) -> String? {
+        guard case let .managedAccount(id) = source else {
+            return nil
+        }
+
+        #if DEBUG
+        if let override = CodexManagedRemoteHomeTestingOverride.homePath(for: self) {
+            return override
+        }
+        #endif
+
+        do {
+            let accounts = try self.loadManagedCodexAccounts()
+            // A selected managed source must never fall back to ambient ~/.codex.
+            return accounts.account(id: id)?.managedHomePath ?? Self.failClosedManagedCodexHomePath()
+        } catch {
+            return Self.failClosedManagedCodexHomePath()
+        }
+    }
+
+    var activeManagedCodexCookieCacheScope: CookieHeaderCache.Scope? {
+        switch self.managedCodexAccountStoreState() {
+        case let .selected(account):
+            .managedAccount(account.id)
+        case .unreadable:
+            .managedStoreUnreadable
+        case .none:
+            nil
+        }
+    }
+
+    var hasUnreadableManagedCodexAccountStore: Bool {
+        self.codexAccountReconciliationSnapshot.hasUnreadableAddedAccountStore
+    }
+
     var codexUsageDataSource: CodexUsageDataSource {
         get {
             let source = self.configSnapshot.providerConfig(for: .codex)?.source
@@ -20,9 +162,47 @@ extension SettingsStore {
         }
     }
 
+    var codexActiveSource: CodexActiveSource {
+        get {
+            self.codexPersistedActiveSource
+        }
+        set {
+            self.invalidateCodexAccountReconciliationSnapshotCache()
+            self.cachedCodexAccountMenuProjection = nil
+            self.updateProviderConfig(provider: .codex) { entry in
+                entry.codexActiveSource = newValue
+            }
+        }
+    }
+
+    var codexResolvedActiveSource: CodexActiveSource {
+        self.codexResolvedActiveSourceState.resolvedSource
+    }
+
+    var codexResolvedActiveSourceState: CodexResolvedActiveSource {
+        CodexActiveSourceResolver.resolve(from: self.codexAccountReconciliationSnapshot)
+    }
+
+    @discardableResult
+    func persistResolvedCodexActiveSourceCorrectionIfNeeded() -> Bool {
+        let resolution = self.codexResolvedActiveSourceState
+        guard resolution.requiresPersistenceCorrection else { return false }
+        self.codexActiveSource = resolution.resolvedSource
+        return true
+    }
+
+    @discardableResult
+    func refreshCodexAccountReconciliationAfterManagedAccountsDidChange() -> Bool {
+        self.invalidateCodexAccountReconciliationSnapshotCache()
+        self.cachedCodexAccountMenuProjection = nil
+        return self.persistResolvedCodexActiveSourceCorrectionIfNeeded()
+    }
+
     var codexCookieHeader: String {
         get { self.configSnapshot.providerConfig(for: .codex)?.sanitizedCookieHeader ?? "" }
         set {
+            // This is intentionally provider-scoped today. A per-managed-account manual cookie override would need
+            // its own storage and UI semantics so editing one account's header does not silently rewrite another's.
             self.updateProviderConfig(provider: .codex) { entry in
                 entry.cookieHeader = self.normalizedConfigValue(newValue)
             }
@@ -48,11 +228,475 @@ extension SettingsStore {
 }
 
 extension SettingsStore {
-    func codexSettingsSnapshot(tokenOverride: TokenAccountOverride?) -> ProviderSettingsSnapshot.CodexProviderSettings {
-        ProviderSettingsSnapshot.CodexProviderSettings(
+    private static var codexAccountReconciliationSnapshotCacheInterval: TimeInterval {
+        #if DEBUG
+        if let codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting {
+            return codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting
+        }
+        #endif
+        return self.isRunningTests ? 0 : self.productionCodexAccountReconciliationSnapshotCacheInterval
+    }
+
+    func invalidateCodexAccountReconciliationSnapshotCache() {
+        self.cachedCodexAccountReconciliationSnapshot = nil
+        self.codexAccountReconciliationGeneration &+= 1
+    }
+
+    var codexAccountReconciliationSnapshot: CodexAccountReconciliationSnapshot {
+        self.codexAccountReconciliationSnapshot(activeSourceOverride: nil)
+    }
+
+    func codexAccountReconciliationSnapshot(
+        activeSourceOverride: CodexActiveSource?) -> CodexAccountReconciliationSnapshot
+    {
+        let activeSource = activeSourceOverride ?? self.codexPersistedActiveSource
+        let cacheInterval = Self.codexAccountReconciliationSnapshotCacheInterval
+        let now = Date()
+        if cacheInterval > 0,
+           let cached = self.cachedCodexAccountReconciliationSnapshot,
+           cached.activeSource == activeSource,
+           now.timeIntervalSince(cached.loadedAt) < cacheInterval
+        {
+            return cached.snapshot
+        }
+
+        let snapshot = self.codexAccountSnapshotLoader(activeSource: activeSource)()
+        let loadedAt = Date()
+        if cacheInterval > 0 {
+            self.cachedCodexAccountReconciliationSnapshot = CachedCodexAccountReconciliationSnapshot(
+                activeSource: activeSource,
+                loadedAt: loadedAt,
+                snapshot: snapshot)
+        }
+        if activeSource == self.codexPersistedActiveSource {
+            self.cachedCodexAccountMenuProjection = CachedCodexAccountMenuProjection(
+                activeSource: activeSource,
+                loadedAt: loadedAt,
+                projection: CodexVisibleAccountProjection.make(from: snapshot))
+        }
+        return snapshot
+    }
+
+    /// Menu rendering must stay side-effect free: no `auth.json` reads, JWT parsing, or fingerprint hashing.
+    var codexVisibleAccountProjectionForMenuDisplay: CodexVisibleAccountProjection? {
+        let activeSource = self.codexPersistedActiveSource
+        guard let cached = self.cachedCodexAccountMenuProjection,
+              cached.activeSource == activeSource
+        else {
+            return nil
+        }
+        return cached.projection
+    }
+
+    var codexAccountMenuProjectionNeedsRevalidation: Bool {
+        let activeSource = self.codexPersistedActiveSource
+        guard let cached = self.cachedCodexAccountMenuProjection,
+              cached.activeSource == activeSource
+        else {
+            return true
+        }
+        return Date().timeIntervalSince(cached.loadedAt) >= Self.codexAccountReconciliationSnapshotCacheInterval
+    }
+
+    func revalidateCodexAccountMenuProjection() async -> CodexAccountMenuProjectionRevalidationResult {
+        guard self.codexAccountMenuProjectionNeedsRevalidation else { return .skipped }
+
+        let activeSource = self.codexPersistedActiveSource
+        let generation = self.codexAccountReconciliationGeneration
+        let loader = self.codexAccountSnapshotLoader(activeSource: activeSource)
+        let snapshot = await Self.loadCodexAccountSnapshot(loader)
+
+        guard generation == self.codexAccountReconciliationGeneration,
+              activeSource == self.codexPersistedActiveSource
+        else {
+            return .discarded
+        }
+
+        let now = Date()
+        let projection = CodexVisibleAccountProjection.make(from: snapshot)
+        let previousProjection = self.cachedCodexAccountMenuProjection.flatMap { cached in
+            cached.activeSource == activeSource ? cached.projection : nil
+        }
+        self.cachedCodexAccountMenuProjection = CachedCodexAccountMenuProjection(
+            activeSource: activeSource,
+            loadedAt: now,
+            projection: projection)
+        if Self.codexAccountReconciliationSnapshotCacheInterval > 0 {
+            self.cachedCodexAccountReconciliationSnapshot = CachedCodexAccountReconciliationSnapshot(
+                activeSource: activeSource,
+                loadedAt: now,
+                snapshot: snapshot)
+        }
+        return previousProjection == projection ? .unchanged : .updated
+    }
+
+    @concurrent
+    private nonisolated static func loadCodexAccountSnapshot(
+        _ loader: @escaping @Sendable () -> CodexAccountReconciliationSnapshot)
+        async -> CodexAccountReconciliationSnapshot
+    {
+        loader()
+    }
+
+    var codexVisibleAccountProjection: CodexVisibleAccountProjection {
+        CodexVisibleAccountProjection.make(from: self.codexAccountReconciliationSnapshot)
+    }
+
+    var codexVisibleAccounts: [CodexVisibleAccount] {
+        self.codexVisibleAccountProjection.visibleAccounts
+    }
+
+    @discardableResult
+    func selectCodexVisibleAccount(id: String) -> Bool {
+        guard let source = self.codexSource(forVisibleAccountID: id) else { return false }
+        self.invalidateCodexAccountReconciliationSnapshotCache()
+        self.codexActiveSource = source
+        return true
+    }
+
+    func selectDisplayedCodexVisibleAccount(_ account: CodexVisibleAccount) {
+        // The row already carries the exact source it represented. Re-resolving its ID would synchronously
+        // reload auth state from the menu click callback and can also fail after a stale snapshot is rendered.
+        self.codexActiveSource = account.selectionSource
+    }
+
+    func selectAuthenticatedManagedCodexAccount(_ account: ManagedCodexAccount) {
+        if let visibleAccountID = self.codexVisibleAccountProjection.visibleAccounts
+            .first(where: { $0.storedAccountID == account.id })?
+            .id,
+            self.selectCodexVisibleAccount(id: visibleAccountID)
+        {
+            return
+        }
+
+        self.invalidateCodexAccountReconciliationSnapshotCache()
+        self.codexActiveSource = .managedAccount(id: account.id)
+        _ = self.persistResolvedCodexActiveSourceCorrectionIfNeeded()
+    }
+
+    func codexSource(forVisibleAccountID id: String) -> CodexActiveSource? {
+        self.codexVisibleAccountProjection.source(forVisibleAccountID: id)
+    }
+
+    private func codexAccountSnapshotLoader(
+        activeSource: CodexActiveSource) -> @Sendable () -> CodexAccountReconciliationSnapshot
+    {
+        #if DEBUG
+        if let loader = self._test_codexAccountSnapshotLoader {
+            return { loader(activeSource) }
+        }
+        #endif
+        let reconciler = self.codexAccountReconciler(activeSource: activeSource)
+        return { reconciler.loadSnapshot() }
+    }
+
+    private func codexAccountReconciler(activeSource: CodexActiveSource) -> DefaultCodexAccountReconciler {
+        let baseEnvironment = self.codexReconciliationEnvironment()
+        #if DEBUG
+        let liveSystemAccountOverride = CodexManagedRemoteHomeTestingOverride.liveSystemAccount(for: self)
+        let reconciliationEnvironmentOverride = CodexManagedRemoteHomeTestingOverride
+            .reconciliationEnvironment(for: self)
+        let managedAccountOverride = CodexManagedRemoteHomeTestingOverride.account(for: self)
+        let managedStoreURLOverride = CodexManagedRemoteHomeTestingOverride.managedStoreURL(for: self)
+        let unreadableStoreOverride = CodexManagedRemoteHomeTestingOverride.isUnreadable(for: self)
+        guard CodexManagedRemoteHomeTestingOverride.hasAnyOverride(for: self) else {
+            return DefaultCodexAccountReconciler(
+                activeSource: activeSource,
+                baseEnvironment: baseEnvironment,
+                profileHomePaths: self.codexProfileHomePaths,
+                managedEnvironmentBuilder: { environment, account in
+                    CodexHomeScope.scopedEnvironment(base: environment, codexHome: account.managedHomePath)
+                })
+        }
+
+        let storeLoader: @Sendable () throws -> ManagedCodexAccountSet
+        if unreadableStoreOverride {
+            storeLoader = { throw CodexManagedRemoteHomeTestingOverrideError.unreadableManagedStore }
+        } else if let managedAccountOverride {
+            let accounts = ManagedCodexAccountSet(
+                version: FileManagedCodexAccountStore.currentVersion,
+                accounts: [managedAccountOverride])
+            storeLoader = { accounts }
+        } else if let managedStoreURLOverride {
+            let store = FileManagedCodexAccountStore(fileURL: managedStoreURLOverride)
+            storeLoader = { try store.loadAccounts() }
+        } else {
+            let accounts = ManagedCodexAccountSet(
+                version: FileManagedCodexAccountStore.currentVersion,
+                accounts: [])
+            storeLoader = { accounts }
+        }
+
+        return DefaultCodexAccountReconciler(
+            storeLoader: storeLoader,
+            systemObserver: CodexManagedRemoteHomeTestingSystemObserver(
+                overrideAccount: liveSystemAccountOverride,
+                usesInjectedEnvironment: reconciliationEnvironmentOverride != nil),
+            activeSource: activeSource,
+            baseEnvironment: baseEnvironment,
+            profileHomePaths: self.codexProfileHomePaths,
+            managedEnvironmentBuilder: { environment, account in
+                CodexHomeScope.scopedEnvironment(base: environment, codexHome: account.managedHomePath)
+            })
+        #else
+        return DefaultCodexAccountReconciler(
+            activeSource: activeSource,
+            baseEnvironment: baseEnvironment,
+            profileHomePaths: self.codexProfileHomePaths,
+            managedEnvironmentBuilder: { environment, account in
+                CodexHomeScope.scopedEnvironment(base: environment, codexHome: account.managedHomePath)
+            })
+        #endif
+    }
+
+    private func codexReconciliationEnvironment() -> [String: String] {
+        #if DEBUG
+        if let override = CodexManagedRemoteHomeTestingOverride.reconciliationEnvironment(for: self) {
+            return override
+        }
+        #endif
+        return ProcessInfo.processInfo.environment
+    }
+}
+
+#if DEBUG
+private enum CodexManagedRemoteHomeTestingOverride {
+    private struct Override {
+        var account: ManagedCodexAccount?
+        var homePath: String?
+        var unreadableStore: Bool = false
+        var managedStoreURL: URL?
+        var liveSystemAccount: ObservedSystemCodexAccount?
+        var reconciliationEnvironment: [String: String]?
+
+        var isEmpty: Bool {
+            self.account == nil && self.homePath == nil && self.unreadableStore == false && self
+                .managedStoreURL == nil && self.liveSystemAccount == nil && self
+                .reconciliationEnvironment == nil
+        }
+    }
+
+    private final class Entry {
+        weak var settings: SettingsStore?
+        var overrideValue: Override
+
+        init(settings: SettingsStore, overrideValue: Override) {
+            self.settings = settings
+            self.overrideValue = overrideValue
+        }
+    }
+
+    @MainActor
+    private static var values: [ObjectIdentifier: Entry] = [:]
+
+    @MainActor
+    private static func entry(for settings: SettingsStore) -> Entry? {
+        let key = ObjectIdentifier(settings)
+        guard let entry = self.values[key] else { return nil }
+        guard let storedSettings = entry.settings, storedSettings === settings else {
+            self.values.removeValue(forKey: key)
+            return nil
+        }
+        return entry
+    }
+
+    @MainActor
+    static func account(for settings: SettingsStore) -> ManagedCodexAccount? {
+        self.entry(for: settings)?.overrideValue.account
+    }
+
+    @MainActor
+    static func setAccount(_ account: ManagedCodexAccount?, for settings: SettingsStore) {
+        let key = ObjectIdentifier(settings)
+        var override = self.entry(for: settings)?.overrideValue ?? Override()
+        override.account = account
+        if override.isEmpty {
+            self.values.removeValue(forKey: key)
+        } else {
+            self.values[key] = Entry(settings: settings, overrideValue: override)
+        }
+    }
+
+    @MainActor
+    static func homePath(for settings: SettingsStore) -> String? {
+        self.entry(for: settings)?.overrideValue.homePath
+    }
+
+    @MainActor
+    static func setHomePath(_ value: String?, for settings: SettingsStore) {
+        let key = ObjectIdentifier(settings)
+        var override = self.entry(for: settings)?.overrideValue ?? Override()
+        override.homePath = value
+        if override.isEmpty {
+            self.values.removeValue(forKey: key)
+        } else {
+            self.values[key] = Entry(settings: settings, overrideValue: override)
+        }
+    }
+
+    @MainActor
+    static func isUnreadable(for settings: SettingsStore) -> Bool {
+        self.entry(for: settings)?.overrideValue.unreadableStore == true
+    }
+
+    @MainActor
+    static func setUnreadable(_ value: Bool, for settings: SettingsStore) {
+        let key = ObjectIdentifier(settings)
+        var override = self.entry(for: settings)?.overrideValue ?? Override()
+        override.unreadableStore = value
+        if override.isEmpty {
+            self.values.removeValue(forKey: key)
+        } else {
+            self.values[key] = Entry(settings: settings, overrideValue: override)
+        }
+    }
+
+    @MainActor
+    static func liveSystemAccount(for settings: SettingsStore) -> ObservedSystemCodexAccount? {
+        self.entry(for: settings)?.overrideValue.liveSystemAccount
+    }
+
+    @MainActor
+    static func managedStoreURL(for settings: SettingsStore) -> URL? {
+        self.entry(for: settings)?.overrideValue.managedStoreURL
+    }
+
+    @MainActor
+    static func setManagedStoreURL(_ value: URL?, for settings: SettingsStore) {
+        let key = ObjectIdentifier(settings)
+        var override = self.entry(for: settings)?.overrideValue ?? Override()
+        override.managedStoreURL = value
+        if override.isEmpty {
+            self.values.removeValue(forKey: key)
+        } else {
+            self.values[key] = Entry(settings: settings, overrideValue: override)
+        }
+    }
+
+    @MainActor
+    static func setLiveSystemAccount(_ account: ObservedSystemCodexAccount?, for settings: SettingsStore) {
+        let key = ObjectIdentifier(settings)
+        var override = self.entry(for: settings)?.overrideValue ?? Override()
+        override.liveSystemAccount = account
+        if override.isEmpty {
+            self.values.removeValue(forKey: key)
+        } else {
+            self.values[key] = Entry(settings: settings, overrideValue: override)
+        }
+    }
+
+    @MainActor
+    static func reconciliationEnvironment(for settings: SettingsStore) -> [String: String]? {
+        self.entry(for: settings)?.overrideValue.reconciliationEnvironment
+    }
+
+    @MainActor
+    static func setReconciliationEnvironment(_ environment: [String: String]?, for settings: SettingsStore) {
+        let key = ObjectIdentifier(settings)
+        var override = self.entry(for: settings)?.overrideValue ?? Override()
+        override.reconciliationEnvironment = environment
+        if override.isEmpty {
+            self.values.removeValue(forKey: key)
+        } else {
+            self.values[key] = Entry(settings: settings, overrideValue: override)
+        }
+    }
+
+    @MainActor
+    static func hasAnyOverride(for settings: SettingsStore) -> Bool {
+        self.entry(for: settings)?.overrideValue.isEmpty == false
+    }
+}
+
+private enum CodexManagedRemoteHomeTestingOverrideError: Error {
+    case unreadableManagedStore
+}
+
+private struct CodexManagedRemoteHomeTestingSystemObserver: CodexSystemAccountObserving {
+    let overrideAccount: ObservedSystemCodexAccount?
+    let usesInjectedEnvironment: Bool
+
+    func loadSystemAccount(environment: [String: String]) throws -> ObservedSystemCodexAccount? {
+        if let overrideAccount {
+            return overrideAccount
+        }
+        guard self.usesInjectedEnvironment else {
+            return nil
+        }
+        return try DefaultCodexSystemAccountObserver().loadSystemAccount(environment: environment)
+    }
+}
+
+extension SettingsStore {
+    private func invalidateCodexAccountReconciliationCachesForTesting() {
+        self.invalidateCodexAccountReconciliationSnapshotCache()
+        self.cachedCodexAccountMenuProjection = nil
+    }
+
+    var _test_activeManagedCodexRemoteHomePath: String? {
+        get { CodexManagedRemoteHomeTestingOverride.homePath(for: self) }
+        set {
+            self.invalidateCodexAccountReconciliationCachesForTesting()
+            CodexManagedRemoteHomeTestingOverride.setHomePath(newValue, for: self)
+        }
+    }
+
+    var _test_activeManagedCodexAccount: ManagedCodexAccount? {
+        get { CodexManagedRemoteHomeTestingOverride.account(for: self) }
+        set {
+            self.invalidateCodexAccountReconciliationCachesForTesting()
+            CodexManagedRemoteHomeTestingOverride.setAccount(newValue, for: self)
+        }
+    }
+
+    var _test_unreadableManagedCodexAccountStore: Bool {
+        get { CodexManagedRemoteHomeTestingOverride.isUnreadable(for: self) }
+        set {
+            self.invalidateCodexAccountReconciliationCachesForTesting()
+            CodexManagedRemoteHomeTestingOverride.setUnreadable(newValue, for: self)
+        }
+    }
+
+    var _test_managedCodexAccountStoreURL: URL? {
+        get { CodexManagedRemoteHomeTestingOverride.managedStoreURL(for: self) }
+        set {
+            self.invalidateCodexAccountReconciliationCachesForTesting()
+            CodexManagedRemoteHomeTestingOverride.setManagedStoreURL(newValue, for: self)
+        }
+    }
+
+    var _test_liveSystemCodexAccount: ObservedSystemCodexAccount? {
+        get { CodexManagedRemoteHomeTestingOverride.liveSystemAccount(for: self) }
+        set {
+            self.invalidateCodexAccountReconciliationCachesForTesting()
+            CodexManagedRemoteHomeTestingOverride.setLiveSystemAccount(newValue, for: self)
+        }
+    }
+
+    var _test_codexReconciliationEnvironment: [String: String]? {
+        get { CodexManagedRemoteHomeTestingOverride.reconciliationEnvironment(for: self) }
+        set {
+            self.invalidateCodexAccountReconciliationCachesForTesting()
+            CodexManagedRemoteHomeTestingOverride.setReconciliationEnvironment(newValue, for: self)
+        }
+    }
+}
+#endif
+
+extension SettingsStore {
+    func codexSettingsSnapshot(
+        tokenOverride: TokenAccountOverride?,
+        activeSourceOverride: CodexActiveSource? = nil) -> ProviderSettingsSnapshot.CodexProviderSettings
+    {
+        let reconciliationSnapshot = self.codexAccountReconciliationSnapshot(
+            activeSourceOverride: activeSourceOverride)
+        let resolvedActiveSource = CodexActiveSourceResolver.resolve(from: reconciliationSnapshot)
+        return CodexProviderSettingsBuilder.make(input: CodexProviderSettingsBuilderInput(
             usageDataSource: self.codexUsageDataSource,
             cookieSource: self.codexSnapshotCookieSource(tokenOverride: tokenOverride),
-            manualCookieHeader: self.codexSnapshotCookieHeader(tokenOverride: tokenOverride))
+            manualCookieHeader: self.codexSnapshotCookieHeader(tokenOverride: tokenOverride),
+            reconciliationSnapshot: reconciliationSnapshot,
+            resolvedActiveSource: resolvedActiveSource))
     }
 
     private static func codexUsageDataSource(from source: ProviderSourceMode?) -> CodexUsageDataSource {
diff --git a/Sources/CodexBar/Providers/Codex/UsageStore+CodexAccountState.swift b/Sources/CodexBar/Providers/Codex/UsageStore+CodexAccountState.swift
new file mode 100644
index 0000000000..a6083df731
--- /dev/null
+++ b/Sources/CodexBar/Providers/Codex/UsageStore+CodexAccountState.swift
@@ -0,0 +1,678 @@
+import CodexBarCore
+import Foundation
+
+enum CodexAccountScopedRefreshPhase {
+    case invalidated
+    case usage
+    case credits
+    case dashboard
+    case completed
+}
+
+struct CodexAccountScopedRefreshGuard: Equatable {
+    let source: CodexActiveSource
+    let identity: CodexIdentity
+    let accountKey: String?
+    let authFingerprint: String?
+
+    init(
+        source: CodexActiveSource,
+        identity: CodexIdentity,
+        accountKey: String?,
+        authFingerprint: String? = nil)
+    {
+        self.source = source
+        self.identity = identity
+        self.accountKey = accountKey
+        self.authFingerprint = CodexAuthFingerprint.normalize(authFingerprint)
+    }
+}
+
+@MainActor
+extension UsageStore {
+    func refreshCodexAccountScopedState(
+        allowDisabled: Bool = false,
+        phaseDidChange: (@MainActor (CodexAccountScopedRefreshPhase) -> Void)? = nil)
+        async
+    {
+        let refreshStartedAt = Date()
+        self.prepareRefreshState(for: .codex)
+        if self.prepareCodexAccountScopedRefreshIfNeeded() {
+            phaseDidChange?(.invalidated)
+        }
+
+        await self.refreshProvider(.codex, allowDisabled: allowDisabled)
+        phaseDidChange?(.usage)
+        await self.refreshCreditsIfNeeded(minimumSnapshotUpdatedAt: refreshStartedAt)
+        phaseDidChange?(.credits)
+
+        if self.settings.codexCookieSource.isEnabled {
+            let expectedGuard = self.freshCodexOpenAIWebRefreshGuard()
+            await self.refreshOpenAIDashboardIfNeeded(
+                force: true,
+                expectedGuard: expectedGuard,
+                allowCodexUsageBackfill: true)
+            phaseDidChange?(.dashboard)
+        }
+
+        if self.openAIDashboardRequiresLogin {
+            await self.refreshProvider(.codex, allowDisabled: allowDisabled)
+            phaseDidChange?(.usage)
+            await self.refreshCreditsIfNeeded(minimumSnapshotUpdatedAt: refreshStartedAt)
+            phaseDidChange?(.credits)
+        }
+
+        self.persistWidgetSnapshot(reason: "codex-account-refresh")
+        phaseDidChange?(.completed)
+    }
+
+    @discardableResult
+    func prepareCodexAccountScopedRefreshIfNeeded() -> Bool {
+        let currentGuard = self.freshCodexAccountScopedRefreshGuard(
+            preferCurrentSnapshot: false,
+            allowLastKnownLiveFallback: false)
+        let previousGuard = self.lastCodexAccountScopedRefreshGuard
+        self.lastCodexAccountScopedRefreshGuard = currentGuard
+
+        guard let previousGuard,
+              !Self.codexScopedRefreshGuardsMatchAccount(previousGuard, currentGuard)
+        else { return false }
+
+        self.snapshots.removeValue(forKey: .codex)
+        self.errors[.codex] = nil
+        self.lastSourceLabels.removeValue(forKey: .codex)
+        self.lastFetchAttempts.removeValue(forKey: .codex)
+        self.accountSnapshots.removeValue(forKey: .codex)
+        self.codexAccountSnapshots = []
+        self.failureGates[.codex]?.reset()
+        self.lastKnownSessionRemaining.removeValue(forKey: .codex)
+        self.lastKnownSessionWindowSource.removeValue(forKey: .codex)
+        self.lastKnownResetSnapshots.removeValue(forKey: .codex)
+
+        self.credits = nil
+        self.lastCreditsError = nil
+        self.lastCreditsSnapshot = nil
+        self.lastCreditsSnapshotAccountKey = nil
+        self.lastCreditsSource = .none
+        self.creditsFailureStreak = 0
+
+        self.clearCodexOpenAIWebStateForAccountTransition(targetEmail: self.codexAccountEmailForOpenAIDashboard())
+
+        self.persistWidgetSnapshot(reason: "codex-account-invalidate")
+        return true
+    }
+
+    func seedCodexAccountScopedRefreshGuard(
+        source: CodexActiveSource? = nil,
+        accountEmail: String?)
+    {
+        let resolvedSource = source ?? self.settings.codexResolvedActiveSource
+        let resolvedEmail = Self.normalizeCodexAccountScopedEmail(accountEmail)
+        let currentIdentity = self.currentCodexRuntimeIdentity(
+            source: resolvedSource,
+            preferCurrentSnapshot: false,
+            allowLastKnownLiveFallback: false)
+        let resolvedIdentity = CodexIdentityMatcher.normalized(
+            currentIdentity == .unresolved ? CodexIdentityResolver.resolve(accountId: nil, email: resolvedEmail) :
+                currentIdentity,
+            fallbackEmail: resolvedEmail ?? "")
+        let accountKey = Self.normalizeCodexAccountScopedKey(resolvedEmail ?? Self.email(for: resolvedIdentity))
+        guard resolvedIdentity != .unresolved || accountKey != nil else { return }
+        self.lastCodexAccountScopedRefreshGuard = CodexAccountScopedRefreshGuard(
+            source: resolvedSource,
+            identity: resolvedIdentity,
+            accountKey: accountKey,
+            authFingerprint: self.currentCodexAuthFingerprint(source: resolvedSource))
+    }
+
+    func currentCodexAccountScopedRefreshGuard(
+        preferCurrentSnapshot: Bool = true,
+        allowLastKnownLiveFallback: Bool = true) -> CodexAccountScopedRefreshGuard
+    {
+        CodexAccountScopedRefreshGuard(
+            source: self.settings.codexResolvedActiveSource,
+            identity: self.currentCodexRuntimeIdentity(
+                source: self.settings.codexResolvedActiveSource,
+                preferCurrentSnapshot: preferCurrentSnapshot,
+                allowLastKnownLiveFallback: allowLastKnownLiveFallback),
+            accountKey: self.codexAccountScopedRefreshKey(
+                preferCurrentSnapshot: preferCurrentSnapshot,
+                allowLastKnownLiveFallback: allowLastKnownLiveFallback),
+            authFingerprint: self.currentCodexAuthFingerprint(source: self.settings.codexResolvedActiveSource))
+    }
+
+    func currentCodexOpenAIWebRefreshGuard() -> CodexAccountScopedRefreshGuard {
+        let source = self.settings.codexResolvedActiveSource
+        let accountKey: String? = switch self.settings.codexResolvedActiveSource {
+        case .liveSystem:
+            Self
+                .normalizeCodexAccountScopedKey(self.settings.codexAccountReconciliationSnapshot.liveSystemAccount?
+                    .email)
+        case .managedAccount:
+            Self.normalizeCodexAccountScopedKey(self.currentManagedCodexRuntimeEmail())
+        case let .profileHome(path):
+            Self.normalizeCodexAccountScopedKey(self.currentProfileCodexRuntimeEmail(path: path))
+        }
+        return CodexAccountScopedRefreshGuard(
+            source: source,
+            identity: self.currentCodexOpenAIWebIdentity(source: source),
+            accountKey: accountKey,
+            authFingerprint: self.currentCodexAuthFingerprint(source: source))
+    }
+
+    func freshCodexAccountScopedRefreshGuard(
+        preferCurrentSnapshot: Bool = true,
+        allowLastKnownLiveFallback: Bool = true) -> CodexAccountScopedRefreshGuard
+    {
+        self.settings.invalidateCodexAccountReconciliationSnapshotCache()
+        return self.currentCodexAccountScopedRefreshGuard(
+            preferCurrentSnapshot: preferCurrentSnapshot,
+            allowLastKnownLiveFallback: allowLastKnownLiveFallback)
+    }
+
+    func freshCodexOpenAIWebRefreshGuard() -> CodexAccountScopedRefreshGuard {
+        self.settings.invalidateCodexAccountReconciliationSnapshotCache()
+        return self.currentCodexOpenAIWebRefreshGuard()
+    }
+
+    func shouldApplyCodexUsageResult(
+        expectedGuard: CodexAccountScopedRefreshGuard,
+        usage: UsageSnapshot) -> Bool
+    {
+        let currentGuard = self.freshCodexAccountScopedRefreshGuard()
+        guard currentGuard.source == expectedGuard.source else { return false }
+        let fingerprintsAllowApply = Self.codexGuardAuthFingerprintAllowsUsageApply(
+            currentGuard,
+            expectedGuard)
+        let expectedAuthFingerprint = CodexAuthFingerprint.normalize(expectedGuard.authFingerprint)
+        let currentAuthFingerprint = CodexAuthFingerprint.normalize(currentGuard.authFingerprint)
+        let canProveNilToCurrentAuth = expectedAuthFingerprint == nil && currentAuthFingerprint != nil
+        let resultIdentity = CodexIdentityResolver.resolve(accountId: nil, email: usage.accountEmail(for: .codex))
+        let resultAccountKey = Self.normalizeCodexAccountScopedKey(usage.accountEmail(for: .codex))
+        let resultMatchesCurrentAccountKey = Self.codexUsageResultAccountKeyMatchesCurrentGuard(
+            resultAccountKey,
+            expectedGuard: expectedGuard,
+            currentGuard: currentGuard)
+
+        if expectedGuard.identity != .unresolved {
+            guard currentGuard.identity == expectedGuard.identity else { return false }
+            if fingerprintsAllowApply {
+                guard case .managedAccount = currentGuard.source else { return true }
+                return resultMatchesCurrentAccountKey
+            }
+            guard canProveNilToCurrentAuth else { return false }
+            guard resultMatchesCurrentAccountKey else { return false }
+            return resultIdentity == currentGuard.identity ||
+                (resultAccountKey != nil && resultAccountKey == currentGuard.accountKey)
+        }
+
+        if currentGuard.identity != .unresolved {
+            guard resultIdentity == currentGuard.identity else { return false }
+            return fingerprintsAllowApply || canProveNilToCurrentAuth
+        }
+
+        switch currentGuard.source {
+        case .liveSystem:
+            guard resultIdentity != .unresolved else { return false }
+            if fingerprintsAllowApply { return true }
+            guard canProveNilToCurrentAuth else { return false }
+            guard let currentAccountKey = currentGuard.accountKey else { return true }
+            return resultAccountKey == currentAccountKey
+        case .managedAccount:
+            return false
+        case .profileHome:
+            return false
+        }
+    }
+
+    func shouldApplyCodexScopedFailure(expectedGuard: CodexAccountScopedRefreshGuard) -> Bool {
+        let currentGuard = self.freshCodexAccountScopedRefreshGuard()
+        guard currentGuard.source == expectedGuard.source else { return false }
+        guard Self.codexGuardAuthFingerprintMatches(currentGuard, expectedGuard) else { return false }
+
+        if expectedGuard.identity != .unresolved {
+            return currentGuard.identity == expectedGuard.identity
+        }
+
+        return currentGuard.identity == .unresolved
+    }
+
+    func codexScopedNonUsageSuccessApplyGuard(
+        expectedGuard: CodexAccountScopedRefreshGuard) -> CodexAccountScopedRefreshGuard?
+    {
+        let currentGuard = self.freshCodexAccountScopedRefreshGuard()
+        guard currentGuard.source == expectedGuard.source else { return nil }
+        guard Self.codexGuardAuthFingerprintAllowsUsageApply(currentGuard, expectedGuard) else { return nil }
+        guard expectedGuard.identity != .unresolved else { return nil }
+        guard currentGuard.identity == expectedGuard.identity else { return nil }
+        return currentGuard
+    }
+
+    func shouldApplyCodexScopedNonUsageResult(expectedGuard: CodexAccountScopedRefreshGuard) -> Bool {
+        self.codexScopedNonUsageSuccessApplyGuard(expectedGuard: expectedGuard) != nil
+    }
+
+    func shouldApplyCodexScopedNonUsageFailure(expectedGuard: CodexAccountScopedRefreshGuard) -> Bool {
+        let currentGuard = self.freshCodexAccountScopedRefreshGuard()
+        guard currentGuard.source == expectedGuard.source else { return false }
+        guard Self.codexGuardAuthFingerprintMatches(currentGuard, expectedGuard) else { return false }
+        guard expectedGuard.identity != .unresolved else { return false }
+        return currentGuard.identity == expectedGuard.identity
+    }
+
+    func shouldApplyOpenAIDashboardRefreshGuard(
+        expectedGuard: CodexAccountScopedRefreshGuard,
+        routingTargetEmail: String?) -> Bool
+    {
+        let normalizedRoutingTargetEmail = CodexIdentityResolver.normalizeEmail(routingTargetEmail)
+        let currentGuard = self.freshCodexOpenAIWebRefreshGuard()
+        guard currentGuard.source == expectedGuard.source else { return false }
+        guard Self.codexGuardAuthFingerprintAllowsUsageApply(currentGuard, expectedGuard) else { return false }
+
+        if expectedGuard.identity != .unresolved {
+            return currentGuard.identity == expectedGuard.identity
+        }
+
+        guard case .liveSystem = expectedGuard.source else { return false }
+        guard currentGuard.identity == .unresolved else { return false }
+        return CodexIdentityResolver.normalizeEmail(
+            self.currentCodexOpenAIWebTargetEmail(
+                allowCurrentSnapshotFallback: true,
+                allowLastKnownLiveFallback: false)) == normalizedRoutingTargetEmail
+    }
+
+    func shouldApplyOpenAIWebNonSuccessResult(
+        expectedGuard: CodexAccountScopedRefreshGuard,
+        routingTargetEmail: String?) -> Bool
+    {
+        let normalizedRoutingTargetEmail = CodexIdentityResolver.normalizeEmail(routingTargetEmail)
+        let currentGuard = self.freshCodexOpenAIWebRefreshGuard()
+        guard currentGuard.source == expectedGuard.source else { return false }
+        guard Self.codexGuardAuthFingerprintMatches(currentGuard, expectedGuard) else { return false }
+
+        if expectedGuard.identity != .unresolved {
+            return currentGuard.identity == expectedGuard.identity
+        }
+
+        guard case .liveSystem = expectedGuard.source else { return false }
+        guard currentGuard.identity == .unresolved else { return false }
+        return CodexIdentityResolver.normalizeEmail(
+            self.currentCodexOpenAIWebTargetEmail(
+                allowCurrentSnapshotFallback: true,
+                allowLastKnownLiveFallback: false)) == normalizedRoutingTargetEmail
+    }
+
+    func shouldApplyOpenAIDashboardPolicyResult(
+        expectedGuard: CodexAccountScopedRefreshGuard,
+        routingTargetEmail: String?) -> Bool
+    {
+        let normalizedRoutingTargetEmail = CodexIdentityResolver.normalizeEmail(routingTargetEmail)
+        let currentGuard = self.freshCodexOpenAIWebRefreshGuard()
+        guard currentGuard.source == expectedGuard.source else { return false }
+
+        if expectedGuard.identity != .unresolved {
+            guard currentGuard.identity == expectedGuard.identity else { return false }
+            return Self.codexGuardAuthFingerprintMatches(currentGuard, expectedGuard) ||
+                Self.codexGuardAuthFingerprintAllowsSameProviderAccount(currentGuard, expectedGuard)
+        }
+
+        guard case .liveSystem = expectedGuard.source else { return false }
+        guard currentGuard.identity == .unresolved else { return false }
+        guard Self.codexGuardAuthFingerprintMatches(currentGuard, expectedGuard) else { return false }
+        return CodexIdentityResolver.normalizeEmail(
+            self.currentCodexOpenAIWebTargetEmail(
+                allowCurrentSnapshotFallback: true,
+                allowLastKnownLiveFallback: false)) == normalizedRoutingTargetEmail
+    }
+
+    func codexDashboardKnownOwnerCandidates() -> [CodexDashboardKnownOwnerCandidate] {
+        CodexKnownOwnerCatalog.candidates(from: self.settings.codexAccountReconciliationSnapshot)
+    }
+
+    func trustedCurrentCodexUsageEmailForDashboardAuthority() -> String? {
+        guard let sourceLabel = self.lastSourceLabels[.codex], sourceLabel != "openai-web" else {
+            return nil
+        }
+        return CodexIdentityResolver.normalizeEmail(self.snapshots[.codex]?.accountEmail(for: .codex))
+    }
+
+    func currentCodexDashboardExpectedScopedEmail() -> String? {
+        switch self.settings.codexResolvedActiveSource {
+        case .liveSystem:
+            CodexIdentityResolver.normalizeEmail(
+                self.settings.codexAccountReconciliationSnapshot.liveSystemAccount?.email)
+        case .managedAccount:
+            CodexIdentityResolver.normalizeEmail(self.currentManagedCodexRuntimeEmail())
+        case let .profileHome(path):
+            CodexIdentityResolver.normalizeEmail(self.currentProfileCodexRuntimeEmail(path: path))
+        }
+    }
+
+    func makeCodexDashboardAuthorityInput(
+        dashboard: OpenAIDashboardSnapshot,
+        sourceKind: CodexDashboardSourceKind,
+        routingTargetEmail: String?) -> CodexDashboardAuthorityInput
+    {
+        let source = self.settings.codexResolvedActiveSource
+        return CodexDashboardAuthorityInput(
+            sourceKind: sourceKind,
+            proof: CodexDashboardOwnershipProofContext(
+                currentIdentity: self.currentCodexOpenAIWebIdentity(source: source),
+                expectedScopedEmail: self.currentCodexDashboardExpectedScopedEmail(),
+                trustedCurrentUsageEmail: self.trustedCurrentCodexUsageEmailForDashboardAuthority(),
+                dashboardSignedInEmail: dashboard.signedInEmail,
+                knownOwners: self.codexDashboardKnownOwnerCandidates()),
+            routing: CodexDashboardRoutingHints(
+                targetEmail: CodexIdentityResolver.normalizeEmail(routingTargetEmail),
+                lastKnownDashboardRoutingEmail: CodexIdentityResolver.normalizeEmail(
+                    self.lastKnownLiveSystemCodexEmail)))
+    }
+
+    func evaluateCodexDashboardAuthority(
+        dashboard: OpenAIDashboardSnapshot,
+        sourceKind: CodexDashboardSourceKind,
+        routingTargetEmail: String?) -> (input: CodexDashboardAuthorityInput, decision: CodexDashboardAuthorityDecision)
+    {
+        let input = self.makeCodexDashboardAuthorityInput(
+            dashboard: dashboard,
+            sourceKind: sourceKind,
+            routingTargetEmail: routingTargetEmail)
+        return (input, CodexDashboardAuthority.evaluate(input))
+    }
+
+    func codexDashboardAttachmentEmail(from input: CodexDashboardAuthorityInput) -> String? {
+        CodexIdentityResolver.normalizeEmail(
+            input.proof.expectedScopedEmail ??
+                input.proof.trustedCurrentUsageEmail ??
+                input.proof.dashboardSignedInEmail)
+    }
+
+    func rememberLiveSystemCodexEmailIfNeeded(_ email: String?) {
+        guard case .liveSystem = self.settings.codexResolvedActiveSource else { return }
+        guard let normalized = Self.normalizeCodexAccountScopedEmail(email) else { return }
+        self.lastKnownLiveSystemCodexEmail = normalized
+    }
+
+    nonisolated static func codexGuardAuthFingerprintMatches(
+        _ lhs: CodexAccountScopedRefreshGuard,
+        _ rhs: CodexAccountScopedRefreshGuard) -> Bool
+    {
+        let lhsFingerprint = CodexAuthFingerprint.normalize(lhs.authFingerprint)
+        let rhsFingerprint = CodexAuthFingerprint.normalize(rhs.authFingerprint)
+        if lhsFingerprint != nil || rhsFingerprint != nil {
+            return lhsFingerprint == rhsFingerprint
+        }
+        return true
+    }
+
+    nonisolated static func codexGuardAuthFingerprintAllowsUsageApply(
+        _ lhs: CodexAccountScopedRefreshGuard,
+        _ rhs: CodexAccountScopedRefreshGuard) -> Bool
+    {
+        if self.codexGuardAuthFingerprintMatches(lhs, rhs) {
+            return true
+        }
+        let lhsFingerprint = CodexAuthFingerprint.normalize(lhs.authFingerprint)
+        let rhsFingerprint = CodexAuthFingerprint.normalize(rhs.authFingerprint)
+        guard lhsFingerprint != nil, rhsFingerprint != nil else { return false }
+        guard case .providerAccount = rhs.identity, lhs.identity == rhs.identity else { return false }
+        guard case .liveSystem = lhs.source else { return true }
+        return lhs.accountKey != nil && lhs.accountKey == rhs.accountKey
+    }
+
+    private nonisolated static func codexGuardAuthFingerprintAllowsSameProviderAccount(
+        _ lhs: CodexAccountScopedRefreshGuard,
+        _ rhs: CodexAccountScopedRefreshGuard) -> Bool
+    {
+        let lhsFingerprint = CodexAuthFingerprint.normalize(lhs.authFingerprint)
+        let rhsFingerprint = CodexAuthFingerprint.normalize(rhs.authFingerprint)
+        guard lhsFingerprint != nil, rhsFingerprint != nil else { return false }
+        guard case .providerAccount = rhs.identity else { return false }
+        return lhs.identity == rhs.identity
+    }
+
+    nonisolated static func codexScopedRefreshGuardsMatchAccount(
+        _ lhs: CodexAccountScopedRefreshGuard,
+        _ rhs: CodexAccountScopedRefreshGuard) -> Bool
+    {
+        guard lhs.source == rhs.source else { return false }
+        if lhs == rhs { return true }
+        guard lhs.identity != .unresolved,
+              lhs.identity == rhs.identity,
+              lhs.accountKey == rhs.accountKey
+        else {
+            return false
+        }
+        return self.codexGuardAuthFingerprintAllowsUsageApply(lhs, rhs)
+    }
+
+    private nonisolated static func codexUsageResultAccountKeyMatchesCurrentGuard(
+        _ resultAccountKey: String?,
+        expectedGuard: CodexAccountScopedRefreshGuard,
+        currentGuard: CodexAccountScopedRefreshGuard) -> Bool
+    {
+        guard let currentAccountKey = currentGuard.accountKey else { return true }
+        guard let resultAccountKey else {
+            guard let expectedAccountKey = expectedGuard.accountKey else { return true }
+            return expectedAccountKey == currentAccountKey
+        }
+        return resultAccountKey == currentAccountKey
+    }
+
+    func currentCodexAuthFingerprint(source: CodexActiveSource) -> String? {
+        let snapshot = self.settings.codexAccountReconciliationSnapshot
+        switch source {
+        case .liveSystem:
+            return CodexAuthFingerprint.normalize(snapshot.liveSystemAccount?.authFingerprint)
+        case let .managedAccount(id):
+            guard let account = snapshot.storedAccounts.first(where: { $0.id == id }) else { return nil }
+            return CodexAuthFingerprint.fingerprint(homePath: account.managedHomePath)
+        case let .profileHome(path):
+            guard let profileAccount = snapshot.profileHomeAccount(path: path) else {
+                guard let normalizedPath = CodexHomeScope.normalizedHomePath(path) else { return nil }
+                return CodexAuthFingerprint.fingerprint(homePath: normalizedPath)
+            }
+            return CodexAuthFingerprint.normalize(profileAccount.authFingerprint)
+        }
+    }
+
+    func codexAccountScopedRefreshKey(
+        preferCurrentSnapshot: Bool = true,
+        allowLastKnownLiveFallback: Bool = true) -> String?
+    {
+        Self.normalizeCodexAccountScopedKey(
+            self.codexAccountScopedRefreshEmail(
+                preferCurrentSnapshot: preferCurrentSnapshot,
+                allowLastKnownLiveFallback: allowLastKnownLiveFallback))
+    }
+
+    func codexAccountScopedRefreshEmail(
+        preferCurrentSnapshot: Bool = true,
+        allowLastKnownLiveFallback: Bool = true) -> String?
+    {
+        switch self.settings.codexResolvedActiveSource {
+        case .liveSystem:
+            let liveSystem = Self.normalizeCodexAccountScopedEmail(
+                self.settings.codexAccountReconciliationSnapshot.liveSystemAccount?.email)
+            if let liveSystem {
+                self.lastKnownLiveSystemCodexEmail = liveSystem
+                return liveSystem
+            }
+
+            if preferCurrentSnapshot,
+               let snapshotEmail = Self
+                   .normalizeCodexAccountScopedEmail(self.snapshots[.codex]?.accountEmail(for: .codex))
+            {
+                self.lastKnownLiveSystemCodexEmail = snapshotEmail
+                return snapshotEmail
+            }
+
+            if allowLastKnownLiveFallback,
+               let lastKnown = Self.normalizeCodexAccountScopedEmail(self.lastKnownLiveSystemCodexEmail)
+            {
+                return lastKnown
+            }
+
+            return nil
+        case .managedAccount:
+            if self.settings.codexSettingsSnapshot(tokenOverride: nil).managedAccountStoreUnreadable {
+                return nil
+            }
+            return self.currentManagedCodexRuntimeEmail()
+        case let .profileHome(path):
+            return self.currentProfileCodexRuntimeEmail(path: path)
+        }
+    }
+
+    func currentCodexRuntimeIdentity(
+        source: CodexActiveSource,
+        preferCurrentSnapshot: Bool,
+        allowLastKnownLiveFallback: Bool) -> CodexIdentity
+    {
+        switch source {
+        case .liveSystem:
+            if let liveSystem = self.settings.codexAccountReconciliationSnapshot.liveSystemAccount {
+                return self.settings.codexAccountReconciliationSnapshot.runtimeIdentity(for: liveSystem)
+            }
+
+            if preferCurrentSnapshot,
+               let snapshotEmail = Self
+                   .normalizeCodexAccountScopedEmail(self.snapshots[.codex]?.accountEmail(for: .codex))
+            {
+                self.lastKnownLiveSystemCodexEmail = snapshotEmail
+                return CodexIdentityResolver.resolve(accountId: nil, email: snapshotEmail)
+            }
+
+            if allowLastKnownLiveFallback,
+               let lastKnown = Self.normalizeCodexAccountScopedEmail(self.lastKnownLiveSystemCodexEmail)
+            {
+                return CodexIdentityResolver.resolve(accountId: nil, email: lastKnown)
+            }
+
+            return .unresolved
+        case .managedAccount:
+            guard !self.settings.codexSettingsSnapshot(tokenOverride: nil).managedAccountStoreUnreadable else {
+                return .unresolved
+            }
+            guard let activeStoredAccount = self.settings.codexAccountReconciliationSnapshot.activeStoredAccount else {
+                return .unresolved
+            }
+            return self.settings.codexAccountReconciliationSnapshot.runtimeIdentity(for: activeStoredAccount)
+        case let .profileHome(path):
+            guard let profileAccount = self.settings.codexAccountReconciliationSnapshot.profileHomeAccount(path: path)
+            else {
+                return .unresolved
+            }
+            return self.settings.codexAccountReconciliationSnapshot.runtimeIdentity(for: profileAccount)
+        }
+    }
+
+    private func currentCodexOpenAIWebIdentity(source: CodexActiveSource) -> CodexIdentity {
+        switch source {
+        case .liveSystem:
+            guard let liveSystem = self.settings.codexAccountReconciliationSnapshot.liveSystemAccount else {
+                return .unresolved
+            }
+            return self.settings.codexAccountReconciliationSnapshot.runtimeIdentity(for: liveSystem)
+        case .managedAccount:
+            guard !self.settings.codexSettingsSnapshot(tokenOverride: nil).managedAccountStoreUnreadable else {
+                return .unresolved
+            }
+            guard let activeStoredAccount = self.settings.codexAccountReconciliationSnapshot.activeStoredAccount else {
+                return .unresolved
+            }
+            return self.settings.codexAccountReconciliationSnapshot.runtimeIdentity(for: activeStoredAccount)
+        case let .profileHome(path):
+            guard let profileAccount = self.settings.codexAccountReconciliationSnapshot.profileHomeAccount(path: path)
+            else {
+                return .unresolved
+            }
+            return self.settings.codexAccountReconciliationSnapshot.runtimeIdentity(for: profileAccount)
+        }
+    }
+
+    func currentManagedCodexRuntimeEmail() -> String? {
+        guard !self.settings.codexSettingsSnapshot(tokenOverride: nil).managedAccountStoreUnreadable else {
+            return nil
+        }
+        guard let activeStoredAccount = self.settings.codexAccountReconciliationSnapshot.activeStoredAccount else {
+            return nil
+        }
+        return Self.normalizeCodexAccountScopedEmail(
+            self.settings.codexAccountReconciliationSnapshot.runtimeEmail(for: activeStoredAccount))
+    }
+
+    func currentProfileCodexRuntimeEmail(path: String) -> String? {
+        guard let profileAccount = self.settings.codexAccountReconciliationSnapshot.profileHomeAccount(path: path)
+        else {
+            return nil
+        }
+        return Self.normalizeCodexAccountScopedEmail(profileAccount.email)
+    }
+
+    private func clearCodexOpenAIWebStateForAccountTransition(targetEmail: String?) {
+        self.invalidateOpenAIDashboardRefreshTask()
+        if self.settings.codexCookieSource.isEnabled,
+           let normalizedTarget = Self.normalizeCodexAccountScopedEmail(targetEmail)
+        {
+            let scope = self.codexCookieCacheScopeForOpenAIWeb()
+            let isolationKey = Self.openAIWebTargetIsolationKey(email: normalizedTarget, scope: scope)
+            let previousIsolationKey = self.lastOpenAIDashboardTargetIsolationKey
+            self.lastOpenAIDashboardTargetEmail = normalizedTarget
+            self.lastOpenAIDashboardTargetIsolationKey = isolationKey
+            if let previousIsolationKey, previousIsolationKey != isolationKey {
+                self.openAIWebAccountDidChange = true
+                self.openAIDashboardCookieImportStatus = "Codex account changed; importing browser cookies…"
+            } else {
+                self.openAIDashboardCookieImportStatus = nil
+            }
+            self.openAIDashboardRequiresLogin = true
+        } else {
+            self.lastOpenAIDashboardTargetEmail = Self.normalizeCodexAccountScopedEmail(targetEmail)
+            self.lastOpenAIDashboardTargetIsolationKey = nil
+            self.openAIWebAccountDidChange = false
+            self.openAIDashboardRequiresLogin = false
+            self.openAIDashboardCookieImportStatus = nil
+        }
+
+        self.openAIDashboard = nil
+        self.openAIDashboardAttachmentAuthorized = false
+        self.lastOpenAIDashboardSnapshot = nil
+        self.lastOpenAIDashboardAttachmentAuthorized = false
+        self.lastOpenAIDashboardError = nil
+        self.openAIDashboardCookieImportDebugLog = nil
+        self.lastOpenAIDashboardCookieImportAttemptAt = nil
+        self.lastOpenAIDashboardCookieImportEmail = nil
+    }
+
+    static func normalizeCodexAccountScopedEmail(_ email: String?) -> String? {
+        guard let trimmed = email?.trimmingCharacters(in: .whitespacesAndNewlines), !trimmed.isEmpty else {
+            return nil
+        }
+        return trimmed
+    }
+
+    static func normalizeCodexAccountScopedKey(_ email: String?) -> String? {
+        self.normalizeCodexAccountScopedEmail(email)?.lowercased()
+    }
+
+    static func codexIdentityGuardKey(_ identity: CodexIdentity) -> String? {
+        switch identity {
+        case let .providerAccount(id):
+            "provider:\(id)"
+        case let .emailOnly(normalizedEmail):
+            "email:\(normalizedEmail)"
+        case .unresolved:
+            nil
+        }
+    }
+
+    private static func email(for identity: CodexIdentity) -> String? {
+        switch identity {
+        case .providerAccount, .unresolved:
+            nil
+        case let .emailOnly(normalizedEmail):
+            normalizedEmail
+        }
+    }
+}
diff --git a/Sources/CodexBar/Providers/Codex/UsageStore+CodexRefresh.swift b/Sources/CodexBar/Providers/Codex/UsageStore+CodexRefresh.swift
new file mode 100644
index 0000000000..b081d17a88
--- /dev/null
+++ b/Sources/CodexBar/Providers/Codex/UsageStore+CodexRefresh.swift
@@ -0,0 +1,262 @@
+import CodexBarCore
+import Foundation
+
+@MainActor
+extension UsageStore {
+    nonisolated static let codexSnapshotWaitTimeoutSeconds: TimeInterval = 6
+    nonisolated static let codexRefreshStartGraceSeconds: TimeInterval = 0.25
+    nonisolated static let codexSnapshotPollIntervalNanoseconds: UInt64 = 100_000_000
+
+    func codexCreditsFetcher() -> UsageFetcher {
+        // Credits are remote Codex account state, so they need the same managed-home routing as the
+        // primary Codex usage fetch. Local token-cost scanning intentionally stays ambient-system scoped.
+        self.makeFetchContext(provider: .codex, override: nil).fetcher
+    }
+
+    func scheduleCreditsRefreshIfNeeded(minimumSnapshotUpdatedAt: Date? = nil) {
+        let refreshKey = self.codexCreditsRefreshKey(
+            expectedGuard: self.freshCodexAccountScopedRefreshGuard())
+        if let existing = self.creditsRefreshTask,
+           !existing.isCancelled,
+           self.creditsRefreshTaskKey == refreshKey
+        {
+            return
+        }
+
+        self.creditsRefreshTask?.cancel()
+        self.creditsRefreshTaskKey = refreshKey
+        self.creditsRefreshTask = Task(priority: .utility) { @MainActor [weak self] in
+            guard let self else { return }
+            defer {
+                if self.creditsRefreshTaskKey == refreshKey {
+                    self.creditsRefreshTask = nil
+                    self.creditsRefreshTaskKey = nil
+                }
+            }
+            await self.refreshCreditsIfNeeded(minimumSnapshotUpdatedAt: minimumSnapshotUpdatedAt)
+            guard !Task.isCancelled else { return }
+            self.persistWidgetSnapshot(reason: "credits")
+        }
+    }
+
+    func cancelScheduledCreditsRefresh() {
+        self.creditsRefreshTask?.cancel()
+        self.creditsRefreshTask = nil
+        self.creditsRefreshTaskKey = nil
+    }
+
+    func refreshCreditsNow(minimumSnapshotUpdatedAt: Date? = nil) async {
+        self.cancelScheduledCreditsRefresh()
+        await self.refreshCreditsIfNeeded(minimumSnapshotUpdatedAt: minimumSnapshotUpdatedAt)
+    }
+
+    func codexCreditsRefreshKey(expectedGuard: CodexAccountScopedRefreshGuard) -> String {
+        let sourceKey = switch expectedGuard.source {
+        case .liveSystem:
+            "live"
+        case let .managedAccount(id):
+            "managed:\(id.uuidString)"
+        case let .profileHome(path):
+            "profile:\(path)"
+        }
+
+        let identityKey = switch expectedGuard.identity {
+        case let .providerAccount(id):
+            "provider:\(id)"
+        case let .emailOnly(normalizedEmail):
+            "email:\(normalizedEmail)"
+        case .unresolved:
+            "unresolved"
+        }
+
+        return [
+            sourceKey,
+            identityKey,
+            expectedGuard.accountKey ?? "account:nil",
+            "auth:\(expectedGuard.authFingerprint ?? "nil")",
+        ].joined(separator: "|")
+    }
+
+    func refreshCreditsIfNeeded(minimumSnapshotUpdatedAt: Date? = nil) async {
+        guard self.isEnabled(.codex) else { return }
+        var expectedGuard = self.freshCodexAccountScopedRefreshGuard()
+        if expectedGuard.identity == .unresolved,
+           let minimumSnapshotUpdatedAt,
+           case .liveSystem = expectedGuard.source
+        {
+            _ = await self.waitForCodexSnapshotOrRefreshCompletion(minimumUpdatedAt: minimumSnapshotUpdatedAt)
+            expectedGuard = self.freshCodexAccountScopedRefreshGuard()
+        }
+        guard expectedGuard.identity != .unresolved,
+              expectedGuard.accountKey != nil
+        else {
+            return
+        }
+        do {
+            let credits = try await self.loadLatestCodexCredits()
+            guard !Task.isCancelled else { return }
+            guard let applyGuard = self.codexScopedNonUsageSuccessApplyGuard(
+                expectedGuard: expectedGuard) else { return }
+            await MainActor.run {
+                self.credits = credits
+                self.lastCreditsError = nil
+                self.lastCreditsSnapshot = credits
+                self.lastCreditsSnapshotAccountKey = applyGuard.accountKey
+                self.lastCreditsSource = .api
+                self.creditsFailureStreak = 0
+                self.lastCodexAccountScopedRefreshGuard = applyGuard
+            }
+            let codexSnapshot = await MainActor.run {
+                self.snapshots[.codex]
+            }
+            if let minimumSnapshotUpdatedAt,
+               codexSnapshot == nil || codexSnapshot?.updatedAt ?? .distantPast < minimumSnapshotUpdatedAt
+            {
+                self.scheduleCodexPlanHistoryBackfill(
+                    minimumSnapshotUpdatedAt: minimumSnapshotUpdatedAt)
+                return
+            }
+
+            self.cancelCodexPlanHistoryBackfill()
+            guard let codexSnapshot else { return }
+            await self.recordPlanUtilizationHistorySample(
+                provider: .codex,
+                snapshot: codexSnapshot,
+                now: codexSnapshot.updatedAt)
+        } catch {
+            guard !Task.isCancelled else { return }
+            let message = error.localizedDescription
+            if message.localizedCaseInsensitiveContains("data not available yet") {
+                guard self.shouldApplyCodexScopedNonUsageFailure(expectedGuard: expectedGuard) else { return }
+                await MainActor.run {
+                    if let cached = self.lastCreditsSnapshot,
+                       self.lastCreditsSnapshotAccountKey == expectedGuard.accountKey
+                    {
+                        self.credits = cached
+                        self.lastCreditsError = nil
+                        self.lastCodexAccountScopedRefreshGuard = expectedGuard
+                    } else {
+                        self.credits = nil
+                        self.lastCreditsSource = .none
+                        self.lastCreditsError = "Codex credits are still loading; will retry shortly."
+                    }
+                }
+                return
+            }
+
+            guard self.shouldApplyCodexScopedNonUsageFailure(expectedGuard: expectedGuard) else { return }
+            await MainActor.run {
+                self.creditsFailureStreak += 1
+                if let cached = self.lastCreditsSnapshot,
+                   self.lastCreditsSnapshotAccountKey == expectedGuard.accountKey
+                {
+                    self.credits = cached
+                    let stamp = cached.updatedAt.formatted(date: .abbreviated, time: .shortened)
+                    self.lastCreditsError =
+                        "Last Codex credits refresh failed: \(message). Cached values from \(stamp)."
+                    self.lastCodexAccountScopedRefreshGuard = expectedGuard
+                } else {
+                    self.lastCreditsError = message
+                    self.credits = nil
+                    self.lastCreditsSource = .none
+                }
+            }
+        }
+    }
+
+    private func loadLatestCodexCredits() async throws -> CreditsSnapshot {
+        if let override = self._test_codexCreditsLoaderOverride {
+            return try await override()
+        }
+        let descriptor = self.providerSpecs[.codex]?.descriptor ?? ProviderDescriptorRegistry.descriptor(for: .codex)
+        let context = self.makeFetchContext(provider: .codex, override: nil, includeCredits: true)
+        let strategies = await descriptor.fetchPlan.pipeline.resolveStrategies(context)
+        var lastAvailableError: Error?
+
+        for strategy in strategies {
+            guard await strategy.isAvailable(context) else { continue }
+            do {
+                let result = try await strategy.fetch(context)
+                if let credits = result.credits {
+                    return credits
+                }
+                lastAvailableError = UsageError.noRateLimitsFound
+                guard context.sourceMode == .auto else { break }
+            } catch {
+                lastAvailableError = error
+                guard strategy.shouldFallback(on: error, context: context) else { break }
+            }
+        }
+        throw lastAvailableError ?? ProviderFetchError.noAvailableStrategy(.codex)
+    }
+
+    func waitForCodexSnapshot(minimumUpdatedAt: Date) async -> UsageSnapshot? {
+        let deadline = Date().addingTimeInterval(Self.codexSnapshotWaitTimeoutSeconds)
+
+        while Date() < deadline {
+            if Task.isCancelled { return nil }
+            if let snapshot = await MainActor.run(body: { self.snapshots[.codex] }),
+               snapshot.updatedAt >= minimumUpdatedAt
+            {
+                return snapshot
+            }
+            try? await Task.sleep(nanoseconds: Self.codexSnapshotPollIntervalNanoseconds)
+        }
+
+        return nil
+    }
+
+    func waitForCodexSnapshotOrRefreshCompletion(minimumUpdatedAt: Date) async -> UsageSnapshot? {
+        let deadline = Date().addingTimeInterval(Self.codexSnapshotWaitTimeoutSeconds)
+        let refreshStartDeadline = Date().addingTimeInterval(Self.codexRefreshStartGraceSeconds)
+
+        while Date() < deadline {
+            if Task.isCancelled { return nil }
+            let state = await MainActor.run {
+                (
+                    snapshot: self.snapshots[.codex],
+                    isRefreshing: self.refreshingProviders.contains(.codex),
+                    hasAttempts: !(self.lastFetchAttempts[.codex] ?? []).isEmpty,
+                    hasError: self.errors[.codex] != nil)
+            }
+            if let snapshot = state.snapshot, snapshot.updatedAt >= minimumUpdatedAt {
+                return snapshot
+            }
+            if !state.isRefreshing, state.hasAttempts || state.hasError {
+                return nil
+            }
+            if !state.isRefreshing,
+               !state.hasAttempts,
+               !state.hasError,
+               Date() >= refreshStartDeadline
+            {
+                return nil
+            }
+            try? await Task.sleep(nanoseconds: Self.codexSnapshotPollIntervalNanoseconds)
+        }
+
+        return nil
+    }
+
+    func scheduleCodexPlanHistoryBackfill(
+        minimumSnapshotUpdatedAt: Date)
+    {
+        self.cancelCodexPlanHistoryBackfill()
+        self.codexPlanHistoryBackfillTask = Task { @MainActor [weak self] in
+            guard let self else { return }
+            guard let snapshot = await self.waitForCodexSnapshot(minimumUpdatedAt: minimumSnapshotUpdatedAt) else {
+                return
+            }
+            await self.recordPlanUtilizationHistorySample(
+                provider: .codex,
+                snapshot: snapshot,
+                now: snapshot.updatedAt)
+            self.codexPlanHistoryBackfillTask = nil
+        }
+    }
+
+    func cancelCodexPlanHistoryBackfill() {
+        self.codexPlanHistoryBackfillTask?.cancel()
+        self.codexPlanHistoryBackfillTask = nil
+    }
+}
diff --git a/Sources/CodexBar/Providers/CommandCode/CommandCodeProviderImplementation.swift b/Sources/CodexBar/Providers/CommandCode/CommandCodeProviderImplementation.swift
new file mode 100644
index 0000000000..bc71670418
--- /dev/null
+++ b/Sources/CodexBar/Providers/CommandCode/CommandCodeProviderImplementation.swift
@@ -0,0 +1,79 @@
+import AppKit
+import CodexBarCore
+import Foundation
+import SwiftUI
+
+struct CommandCodeProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .commandcode
+
+    @MainActor
+    func observeSettings(_ settings: SettingsStore) {
+        _ = settings.commandcodeCookieSource
+        _ = settings.commandcodeCookieHeader
+    }
+
+    @MainActor
+    func settingsSnapshot(context: ProviderSettingsSnapshotContext) -> ProviderSettingsSnapshotContribution? {
+        .commandcode(context.settings.commandcodeSettingsSnapshot(tokenOverride: context.tokenOverride))
+    }
+
+    @MainActor
+    func settingsPickers(context: ProviderSettingsContext) -> [ProviderSettingsPickerDescriptor] {
+        let cookieBinding = Binding(
+            get: { context.settings.commandcodeCookieSource.rawValue },
+            set: { raw in
+                context.settings.commandcodeCookieSource = ProviderCookieSource(rawValue: raw) ?? .auto
+            })
+        let cookieOptions = ProviderCookieSourceUI.options(
+            allowsOff: false,
+            keychainDisabled: context.settings.debugDisableKeychainAccess)
+
+        let cookieSubtitle: () -> String? = {
+            ProviderCookieSourceUI.subtitle(
+                source: context.settings.commandcodeCookieSource,
+                keychainDisabled: context.settings.debugDisableKeychainAccess,
+                auto: "Automatic imports browser cookies.",
+                manual: "Paste a Cookie header or cURL capture from Command Code.",
+                off: "Command Code cookies are disabled.")
+        }
+
+        return [
+            ProviderSettingsPickerDescriptor(
+                id: "commandcode-cookie-source",
+                title: "Cookie source",
+                subtitle: "Automatic imports browser cookies.",
+                dynamicSubtitle: cookieSubtitle,
+                binding: cookieBinding,
+                options: cookieOptions,
+                isVisible: nil,
+                onChange: nil),
+        ]
+    }
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "commandcode-cookie",
+                title: "",
+                subtitle: "",
+                kind: .secure,
+                placeholder: "Cookie: …",
+                binding: context.stringBinding(\.commandcodeCookieHeader),
+                actions: [
+                    ProviderSettingsActionDescriptor(
+                        id: "commandcode-open-settings",
+                        title: "Open Command Code Settings",
+                        style: .link,
+                        isVisible: nil,
+                        perform: {
+                            if let url = URL(string: "https://commandcode.ai/studio") {
+                                NSWorkspace.shared.open(url)
+                            }
+                        }),
+                ],
+                isVisible: { context.settings.commandcodeCookieSource == .manual },
+                onActivate: { context.settings.ensureCommandCodeCookieLoaded() }),
+        ]
+    }
+}
diff --git a/Sources/CodexBar/Providers/CommandCode/CommandCodeSettingsStore.swift b/Sources/CodexBar/Providers/CommandCode/CommandCodeSettingsStore.swift
new file mode 100644
index 0000000000..bf4a4c5a12
--- /dev/null
+++ b/Sources/CodexBar/Providers/CommandCode/CommandCodeSettingsStore.swift
@@ -0,0 +1,37 @@
+import CodexBarCore
+import Foundation
+
+extension SettingsStore {
+    var commandcodeCookieHeader: String {
+        get { self.configSnapshot.providerConfig(for: .commandcode)?.sanitizedCookieHeader ?? "" }
+        set {
+            self.updateProviderConfig(provider: .commandcode) { entry in
+                entry.cookieHeader = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .commandcode, field: "cookieHeader", value: newValue)
+        }
+    }
+
+    var commandcodeCookieSource: ProviderCookieSource {
+        get { self.resolvedCookieSource(provider: .commandcode, fallback: .auto) }
+        set {
+            self.updateProviderConfig(provider: .commandcode) { entry in
+                entry.cookieSource = newValue
+            }
+            self.logProviderModeChange(provider: .commandcode, field: "cookieSource", value: newValue.rawValue)
+        }
+    }
+
+    func ensureCommandCodeCookieLoaded() {}
+}
+
+extension SettingsStore {
+    func commandcodeSettingsSnapshot(tokenOverride: TokenAccountOverride?) -> ProviderSettingsSnapshot
+    .CommandCodeProviderSettings {
+        self.resolvedCookieSettings(
+            provider: .commandcode,
+            configuredSource: self.commandcodeCookieSource,
+            configuredHeader: self.commandcodeCookieHeader,
+            tokenOverride: tokenOverride)
+    }
+}
diff --git a/Sources/CodexBar/Providers/Copilot/CopilotLoginFlow.swift b/Sources/CodexBar/Providers/Copilot/CopilotLoginFlow.swift
index 55275ae613..14374c5f27 100644
--- a/Sources/CodexBar/Providers/Copilot/CopilotLoginFlow.swift
+++ b/Sources/CodexBar/Providers/Copilot/CopilotLoginFlow.swift
@@ -5,7 +5,8 @@ import SwiftUI
 @MainActor
 struct CopilotLoginFlow {
     static func run(settings: SettingsStore) async {
-        let flow = CopilotDeviceFlow()
+        let enterpriseHost = settings.copilotEnterpriseHost
+        let flow = CopilotDeviceFlow(enterpriseHost: enterpriseHost.isEmpty ? nil : enterpriseHost)
 
         do {
             let code = try await flow.requestDeviceCode()
@@ -16,21 +17,17 @@ struct CopilotLoginFlow {
             pb.setString(code.userCode, forType: .string)
 
             let alert = NSAlert()
-            alert.messageText = "GitHub Copilot Login"
-            alert.informativeText = """
-            A device code has been copied to your clipboard: \(code.userCode)
-
-            Please verify it at: \(code.verificationUri)
-            """
-            alert.addButton(withTitle: "Open Browser")
-            alert.addButton(withTitle: "Cancel")
+            alert.messageText = L("GitHub Copilot Login")
+            alert.informativeText = String(format: L("copilot_device_code"), code.userCode, code.verificationUri)
+            alert.addButton(withTitle: L("Open Browser"))
+            alert.addButton(withTitle: L("Cancel"))
 
             let response = alert.runModal()
             if response == .alertSecondButtonReturn {
                 return // Cancelled
             }
 
-            if let url = URL(string: code.verificationUri) {
+            if let url = URL(string: code.verificationURLToOpen) {
                 NSWorkspace.shared.open(url)
             }
 
@@ -43,12 +40,9 @@ struct CopilotLoginFlow {
 
             // Let's show a "Waiting" alert that can be cancelled.
             let waitingAlert = NSAlert()
-            waitingAlert.messageText = "Waiting for Authentication..."
-            waitingAlert.informativeText = """
-            Please complete the login in your browser.
-            This window will close automatically when finished.
-            """
-            waitingAlert.addButton(withTitle: "Cancel")
+            waitingAlert.messageText = L("Waiting for Authentication...")
+            waitingAlert.informativeText = L("copilot_waiting_text")
+            waitingAlert.addButton(withTitle: L("Cancel"))
             let parentWindow = Self.resolveWaitingParentWindow()
             let hostWindow = parentWindow ?? Self.makeWaitingHostWindow()
             let shouldCloseHostWindow = parentWindow == nil
@@ -80,14 +74,72 @@ struct CopilotLoginFlow {
 
             switch tokenResult {
             case let .success(token):
-                settings.copilotAPIToken = token
+                // Fetch username for account label.
+                // If accounts already exist, fail closed when identity lookup fails so re-auth cannot create
+                // an anonymous duplicate with stale credentials left on the original account.
+                let existingAccounts = settings.tokenAccounts(for: .copilot)
+                let label: String
+                let identity: CopilotUsageFetcher.GitHubUserIdentity?
+                do {
+                    let resolvedIdentity = try await CopilotUsageFetcher.fetchGitHubIdentity(token: token)
+                    let resolvedUsername = resolvedIdentity.login
+                    let planSuffix: String
+                    do {
+                        let fetcher = CopilotUsageFetcher(
+                            token: token,
+                            enterpriseHost: enterpriseHost.isEmpty ? nil : enterpriseHost)
+                        let usage = try await fetcher.fetch()
+                        let plan = usage.identity(for: .copilot)?.loginMethod ?? ""
+                        planSuffix = plan.isEmpty ? "" : " (\(plan))"
+                    } catch {
+                        planSuffix = ""
+                    }
+                    identity = resolvedIdentity
+                    label = "\(resolvedUsername)\(planSuffix)"
+                } catch {
+                    guard existingAccounts.isEmpty else {
+                        let err = NSAlert()
+                        err.messageText = "Could Not Identify GitHub Account"
+                        err.informativeText = "GitHub login succeeded, but CodexBar could not verify which " +
+                            "account it belongs to. Please try again."
+                        err.runModal()
+                        return
+                    }
+                    identity = nil
+                    label = "Account 1"
+                }
+
+                // Match existing account by stable GitHub user ID. For legacy accounts that pre-date stable
+                // identifiers, also accept login-based externalIdentifier values and resolve stored token identity
+                // before falling back to labels.
+                let matchedExisting = await Self.matchExistingAccount(
+                    existingAccounts: existingAccounts,
+                    identity: identity,
+                    label: label)
+                let externalIdentifier = identity.map(Self.externalIdentifier)
+                let wasRefresh = matchedExisting != nil
+                if let existing = matchedExisting {
+                    settings.updateTokenAccount(
+                        provider: .copilot,
+                        accountID: existing.id,
+                        label: label,
+                        token: token,
+                        externalIdentifier: .some(externalIdentifier))
+                } else {
+                    settings.addTokenAccount(
+                        provider: .copilot,
+                        label: label,
+                        token: token,
+                        externalIdentifier: externalIdentifier)
+                }
                 settings.setProviderEnabled(
                     provider: .copilot,
                     metadata: ProviderRegistry.shared.metadata[.copilot]!,
                     enabled: true)
 
                 let success = NSAlert()
-                success.messageText = "Login Successful"
+                success.messageText = wasRefresh ? "Token Refreshed" : "Account Added"
+                success.informativeText = label
                 success.runModal()
             case let .failure(error):
                 guard !(error is CancellationError) else { return }
@@ -105,6 +157,73 @@ struct CopilotLoginFlow {
         }
     }
 
+    static func matchExistingAccount(
+        existingAccounts: [ProviderTokenAccount],
+        identity: CopilotUsageFetcher.GitHubUserIdentity?,
+        label: String,
+        legacyIdentityResolver: @escaping @Sendable (ProviderTokenAccount) async
+            -> CopilotUsageFetcher.GitHubUserIdentity? = { account in
+                try? await CopilotUsageFetcher.fetchGitHubIdentity(token: account.token)
+            }) async -> ProviderTokenAccount?
+    {
+        guard let identity, !existingAccounts.isEmpty else { return nil }
+        let stableIdentifier = self.externalIdentifier(for: identity)
+        let login = self.normalizedGitHubLogin(identity.login)
+
+        if let byID = existingAccounts.first(where: { account in
+            self.normalizedExternalIdentifier(account.externalIdentifier) == stableIdentifier
+        }) {
+            return byID
+        }
+
+        // Previous PR revisions stored GitHub login in externalIdentifier. Keep matching those
+        // accounts case-insensitively, then write back the stable ID on update.
+        if let byLegacyLogin = existingAccounts.first(where: { account in
+            self.normalizedGitHubLogin(account.externalIdentifier) == login
+        }) {
+            return byLegacyLogin
+        }
+
+        let legacyAccounts = existingAccounts.filter { $0.externalIdentifier == nil }
+        for account in legacyAccounts {
+            guard let resolvedIdentity = await legacyIdentityResolver(account) else { continue }
+            if resolvedIdentity.id == identity.id ||
+                self.normalizedGitHubLogin(resolvedIdentity.login) == login
+            {
+                return account
+            }
+        }
+
+        let usernamePrefix = self.displayLabelPrefix(label)
+        return legacyAccounts.first { account in
+            self.displayLabelPrefix(account.label) == usernamePrefix
+        }
+    }
+
+    static func externalIdentifier(for identity: CopilotUsageFetcher.GitHubUserIdentity) -> String {
+        "github:user:\(identity.id)"
+    }
+
+    private static func normalizedExternalIdentifier(_ identifier: String?) -> String? {
+        let trimmed = identifier?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+        return trimmed.isEmpty ? nil : trimmed.lowercased()
+    }
+
+    private static func normalizedGitHubLogin(_ login: String?) -> String? {
+        let trimmed = login?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+        guard !trimmed.isEmpty else { return nil }
+        // Stable IDs are not valid GitHub logins; do not let a numeric-looking login fallback
+        // match the "github:user:<id>" identifier path accidentally.
+        guard !trimmed.lowercased().hasPrefix("github:user:") else { return nil }
+        return trimmed.lowercased()
+    }
+
+    private static func displayLabelPrefix(_ label: String) -> String {
+        (label.components(separatedBy: " (").first ?? label)
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .lowercased()
+    }
+
     @MainActor
     private static func presentWaitingAlert(
         _ alert: NSAlert,
diff --git a/Sources/CodexBar/Providers/Copilot/CopilotProviderImplementation.swift b/Sources/CodexBar/Providers/Copilot/CopilotProviderImplementation.swift
index 986d81f2f4..e9fd21b80b 100644
--- a/Sources/CodexBar/Providers/Copilot/CopilotProviderImplementation.swift
+++ b/Sources/CodexBar/Providers/Copilot/CopilotProviderImplementation.swift
@@ -1,9 +1,7 @@
 import AppKit
 import CodexBarCore
-import CodexBarMacroSupport
 import SwiftUI
 
-@ProviderImplementationRegistration
 struct CopilotProviderImplementation: ProviderImplementation {
     let id: UsageProvider = .copilot
     let supportsLoginFlow: Bool = true
@@ -16,44 +14,201 @@ struct CopilotProviderImplementation: ProviderImplementation {
     @MainActor
     func observeSettings(_ settings: SettingsStore) {
         _ = settings.copilotAPIToken
+        _ = settings.copilotEnterpriseHost
+        _ = settings.copilotBudgetExtrasEnabled
+        _ = settings.copilotBudgetCookieSource
+        _ = settings.copilotBudgetCookieHeader
     }
 
     @MainActor
     func settingsSnapshot(context: ProviderSettingsSnapshotContext) -> ProviderSettingsSnapshotContribution? {
-        _ = context
-        return .copilot(context.settings.copilotSettingsSnapshot())
+        .copilot(context.settings.copilotSettingsSnapshot(tokenOverride: context.tokenOverride))
+    }
+
+    @MainActor
+    func loginMenuAction(context _: ProviderMenuLoginContext)
+        -> (label: String, action: MenuDescriptor.MenuAction)?
+    {
+        ("Add Account...", .addProviderAccount(.copilot))
+    }
+
+    @MainActor
+    func settingsToggles(context: ProviderSettingsContext) -> [ProviderSettingsToggleDescriptor] {
+        let budgetExtrasBinding = Binding(
+            get: { context.settings.copilotBudgetExtrasEnabled },
+            set: { enabled in
+                context.settings.copilotBudgetExtrasEnabled = enabled
+            })
+        let budgetExtrasStatus: () -> String? = {
+            if context.store.snapshot(for: .copilot)?.extraRateWindows?.isEmpty == false {
+                return nil
+            }
+            if context.settings.copilotBudgetCookieSource == .manual,
+               context.settings.copilotBudgetCookieHeader.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+            {
+                return [
+                    "Paste a github.com Cookie header, then refresh Copilot.",
+                    "Copilot reauth does not provide the GitHub web cookie used for budgets.",
+                ].joined(separator: " ")
+            }
+            return [
+                "Refresh Copilot to load budget bars.",
+                "Budget extras require a logged-in github.com browser session or a manual Cookie header.",
+            ].joined(separator: " ")
+        }
+
+        return [
+            ProviderSettingsToggleDescriptor(
+                id: "copilot-budget-extras",
+                title: "Budget extras",
+                subtitle: [
+                    "Optional.",
+                    "Turn this on to fetch configured GitHub Copilot budget limits and show them as extra bars.",
+                ].joined(separator: " "),
+                binding: budgetExtrasBinding,
+                statusText: budgetExtrasStatus,
+                actions: [],
+                isVisible: nil,
+                onChange: { enabled in
+                    if enabled {
+                        await context.store.refreshProvider(.copilot, allowDisabled: true)
+                    } else {
+                        context.store.clearCopilotBudgetExtras()
+                    }
+                },
+                onAppDidBecomeActive: nil,
+                onAppearWhenEnabled: nil),
+        ]
+    }
+
+    @MainActor
+    func settingsPickers(context: ProviderSettingsContext) -> [ProviderSettingsPickerDescriptor] {
+        let extraWindows = context.store.snapshot(for: .copilot)?.extraRateWindows ?? []
+        let cookieBinding = Binding(
+            get: { context.settings.copilotBudgetCookieSource.rawValue },
+            set: { raw in
+                context.settings.copilotBudgetCookieSource = ProviderCookieSource(rawValue: raw) ?? .auto
+            })
+        let cookieOptions = ProviderCookieSourceUI.options(
+            allowsOff: false,
+            keychainDisabled: context.settings.debugDisableKeychainAccess)
+        let cookieSubtitle: () -> String? = {
+            ProviderCookieSourceUI.subtitle(
+                source: context.settings.copilotBudgetCookieSource,
+                keychainDisabled: context.settings.debugDisableKeychainAccess,
+                auto: "Automatically imports browser cookies for github.com budget extras.",
+                manual: "Paste a Cookie header from github.com.",
+                off: "GitHub cookies are disabled.")
+        }
+        let options = [
+            ProviderSettingsPickerOption(
+                id: CopilotIconSecondaryWindowSelection.chat,
+                title: "Chat"),
+        ] + extraWindows.map { window in
+            ProviderSettingsPickerOption(id: window.id, title: window.title)
+        }
+
+        return [
+            ProviderSettingsPickerDescriptor(
+                id: "copilot-icon-secondary-window",
+                title: "Menu bar secondary metric",
+                subtitle: "Choose the second meter shown in the menu bar icon.",
+                dynamicSubtitle: {
+                    extraWindows.isEmpty
+                        ? "Budget options appear after a refresh finds configured Copilot budgets."
+                        : nil
+                },
+                binding: Binding(
+                    get: {
+                        let selected = context.settings.copilotIconSecondaryWindowID
+                        if selected == CopilotIconSecondaryWindowSelection.chat {
+                            return selected
+                        }
+                        return extraWindows.contains(where: { $0.id == selected })
+                            ? selected
+                            : CopilotIconSecondaryWindowSelection.chat
+                    },
+                    set: { selection in
+                        context.settings.copilotIconSecondaryWindowID = selection
+                    }),
+                options: options,
+                isVisible: { context.settings.copilotBudgetExtrasEnabled },
+                onChange: nil),
+            ProviderSettingsPickerDescriptor(
+                id: "copilot-budget-cookie-source",
+                title: "GitHub cookies",
+                subtitle: "Automatically imports browser cookies for budget extras.",
+                dynamicSubtitle: cookieSubtitle,
+                binding: cookieBinding,
+                options: cookieOptions,
+                isVisible: { context.settings.copilotBudgetExtrasEnabled },
+                onChange: { _ in
+                    await context.store.refreshProvider(.copilot, allowDisabled: true)
+                },
+                trailingText: {
+                    guard context.settings.copilotBudgetCookieSource != .manual else { return nil }
+                    guard let entry = CookieHeaderCache.loadForDisplay(provider: .copilot) else { return nil }
+                    let when = entry.storedAt.relativeDescription()
+                    return "Cached: \(entry.sourceLabel) • \(when)"
+                }),
+        ]
     }
 
     @MainActor
     func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
         [
             ProviderSettingsFieldDescriptor(
-                id: "copilot-api-token",
-                title: "GitHub Login",
-                subtitle: "Requires authentication via GitHub Device Flow.",
+                id: "copilot-budget-cookie-header",
+                title: "Manual GitHub Cookie header",
+                subtitle: "Paste a github.com Cookie header. Treat this value like a password.",
                 kind: .secure,
-                placeholder: "Sign in via button below",
-                binding: context.stringBinding(\.copilotAPIToken),
+                placeholder: "Cookie: ...",
+                binding: context.stringBinding(\.copilotBudgetCookieHeader),
                 actions: [
                     ProviderSettingsActionDescriptor(
-                        id: "copilot-login",
-                        title: "Sign in with GitHub",
+                        id: "refresh-copilot-budget-cookie",
+                        title: "Refresh budgets",
                         style: .bordered,
-                        isVisible: { context.settings.copilotAPIToken.isEmpty },
+                        isVisible: nil,
                         perform: {
-                            await CopilotLoginFlow.run(settings: context.settings)
+                            await context.store.refreshProvider(.copilot, allowDisabled: true)
                         }),
+                ],
+                isVisible: {
+                    context.settings.copilotBudgetExtrasEnabled &&
+                        context.settings.copilotBudgetCookieSource == .manual
+                },
+                onActivate: nil),
+            ProviderSettingsFieldDescriptor(
+                id: "copilot-enterprise-host",
+                title: "Enterprise host",
+                subtitle: "Optional. Enter your GitHub Enterprise host, for example octocorp.ghe.com. " +
+                    "Leave blank for github.com.",
+                kind: .plain,
+                placeholder: "github.com",
+                binding: context.stringBinding(\.copilotEnterpriseHost),
+                actions: [],
+                isVisible: nil,
+                onActivate: nil),
+            ProviderSettingsFieldDescriptor(
+                id: "copilot-add-account",
+                title: "GitHub Login",
+                subtitle: "Add accounts via GitHub OAuth Device Flow on the selected host.",
+                kind: .plain,
+                placeholder: nil,
+                binding: .constant(""),
+                actions: [
                     ProviderSettingsActionDescriptor(
-                        id: "copilot-relogin",
-                        title: "Sign in again",
-                        style: .link,
-                        isVisible: { !context.settings.copilotAPIToken.isEmpty },
+                        id: "copilot-add-account-action",
+                        title: "Add Account",
+                        style: .bordered,
+                        isVisible: { true },
                         perform: {
                             await CopilotLoginFlow.run(settings: context.settings)
                         }),
                 ],
                 isVisible: nil,
-                onActivate: { context.settings.ensureCopilotAPITokenLoaded() }),
+                onActivate: nil),
         ]
     }
 
diff --git a/Sources/CodexBar/Providers/Copilot/CopilotSettingsStore.swift b/Sources/CodexBar/Providers/Copilot/CopilotSettingsStore.swift
index c40a51f3dc..4fdf677eef 100644
--- a/Sources/CodexBar/Providers/Copilot/CopilotSettingsStore.swift
+++ b/Sources/CodexBar/Providers/Copilot/CopilotSettingsStore.swift
@@ -1,6 +1,10 @@
 import CodexBarCore
 import Foundation
 
+enum CopilotIconSecondaryWindowSelection {
+    static let chat = "chat"
+}
+
 extension SettingsStore {
     var copilotAPIToken: String {
         get { self.configSnapshot.providerConfig(for: .copilot)?.sanitizedAPIKey ?? "" }
@@ -12,11 +16,75 @@ extension SettingsStore {
         }
     }
 
+    var copilotEnterpriseHost: String {
+        get { self.configSnapshot.providerConfig(for: .copilot)?.sanitizedEnterpriseHost ?? "" }
+        set {
+            self.updateProviderConfig(provider: .copilot) { entry in
+                entry.enterpriseHost = self.normalizedConfigValue(newValue)
+            }
+        }
+    }
+
+    var copilotBudgetCookieHeader: String {
+        get { self.configSnapshot.providerConfig(for: .copilot)?.sanitizedCookieHeader ?? "" }
+        set {
+            self.updateProviderConfig(provider: .copilot) { entry in
+                entry.cookieHeader = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .copilot, field: "cookieHeader", value: newValue)
+        }
+    }
+
+    var copilotBudgetCookieSource: ProviderCookieSource {
+        get { self.resolvedCookieSource(provider: .copilot, fallback: .auto) }
+        set {
+            self.updateProviderConfig(provider: .copilot) { entry in
+                entry.cookieSource = newValue
+            }
+            self.logProviderModeChange(provider: .copilot, field: "cookieSource", value: newValue.rawValue)
+        }
+    }
+
     func ensureCopilotAPITokenLoaded() {}
+
+    var copilotIconSecondaryWindowID: String {
+        get {
+            let raw = self.copilotIconSecondaryWindowIDRaw.trimmingCharacters(in: .whitespacesAndNewlines)
+            return raw.isEmpty ? CopilotIconSecondaryWindowSelection.chat : raw
+        }
+        set {
+            let trimmed = newValue.trimmingCharacters(in: .whitespacesAndNewlines)
+            self.copilotIconSecondaryWindowIDRaw = trimmed.isEmpty
+                ? CopilotIconSecondaryWindowSelection.chat
+                : trimmed
+        }
+    }
+
+    func copilotIconSecondaryWindowOverrideID(snapshot: UsageSnapshot?) -> String? {
+        guard self.copilotBudgetExtrasEnabled else { return nil }
+        let selected = self.copilotIconSecondaryWindowID
+        guard selected != CopilotIconSecondaryWindowSelection.chat else { return nil }
+        guard snapshot?.extraRateWindows?.contains(where: { $0.id == selected }) == true else { return nil }
+        return selected
+    }
 }
 
 extension SettingsStore {
-    func copilotSettingsSnapshot() -> ProviderSettingsSnapshot.CopilotProviderSettings {
-        ProviderSettingsSnapshot.CopilotProviderSettings()
+    func copilotSettingsSnapshot(
+        tokenOverride: TokenAccountOverride?) -> ProviderSettingsSnapshot.CopilotProviderSettings
+    {
+        let account = ProviderTokenAccountSelection.selectedAccount(
+            provider: .copilot,
+            settings: self,
+            override: tokenOverride)
+        let token = account?.token ?? self.copilotAPIToken
+        let host = CopilotDeviceFlow.normalizedHost(self.copilotEnterpriseHost)
+        return ProviderSettingsSnapshot.CopilotProviderSettings(
+            apiToken: self.normalizedConfigValue(token),
+            enterpriseHost: host == CopilotDeviceFlow.defaultHost ? nil : host,
+            selectedAccountExternalIdentifier: account?.externalIdentifier.flatMap(self.normalizedConfigValue),
+            budgetExtrasEnabled: self.copilotBudgetExtrasEnabled,
+            budgetCookieSource: self.copilotBudgetCookieSource,
+            manualBudgetCookieHeader: self.normalizedConfigValue(self.copilotBudgetCookieHeader))
     }
 }
diff --git a/Sources/CodexBar/Providers/Copilot/UsageStore+CopilotBudgets.swift b/Sources/CodexBar/Providers/Copilot/UsageStore+CopilotBudgets.swift
new file mode 100644
index 0000000000..0d6dc4075c
--- /dev/null
+++ b/Sources/CodexBar/Providers/Copilot/UsageStore+CopilotBudgets.swift
@@ -0,0 +1,19 @@
+import CodexBarCore
+import Foundation
+
+@MainActor
+extension UsageStore {
+    func clearCopilotBudgetExtras() {
+        if let snapshot = self.snapshots[.copilot],
+           snapshot.extraRateWindows?.isEmpty == false
+        {
+            let updated = snapshot.with(extraRateWindows: nil)
+            self.snapshots[.copilot] = updated
+            self.lastKnownResetSnapshots[.copilot] = updated
+        } else if let resetSnapshot = self.lastKnownResetSnapshots[.copilot],
+                  resetSnapshot.extraRateWindows?.isEmpty == false
+        {
+            self.lastKnownResetSnapshots[.copilot] = resetSnapshot.with(extraRateWindows: nil)
+        }
+    }
+}
diff --git a/Sources/CodexBar/Providers/Crof/CrofProviderImplementation.swift b/Sources/CodexBar/Providers/Crof/CrofProviderImplementation.swift
new file mode 100644
index 0000000000..f53257e24a
--- /dev/null
+++ b/Sources/CodexBar/Providers/Crof/CrofProviderImplementation.swift
@@ -0,0 +1,52 @@
+import AppKit
+import CodexBarCore
+import Foundation
+
+struct CrofProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .crof
+
+    @MainActor
+    func presentation(context _: ProviderPresentationContext) -> ProviderPresentation {
+        ProviderPresentation { _ in "api" }
+    }
+
+    @MainActor
+    func observeSettings(_ settings: SettingsStore) {
+        _ = settings.crofAPIToken
+    }
+
+    @MainActor
+    func isAvailable(context: ProviderAvailabilityContext) -> Bool {
+        if CrofSettingsReader.apiKey(environment: context.environment) != nil {
+            return true
+        }
+        return !context.settings.crofAPIToken.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+    }
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "crof-api-key",
+                title: "API key",
+                subtitle: "Stored in ~/.codexbar/config.json. You can also provide CROF_API_KEY.",
+                kind: .secure,
+                placeholder: "crof_...",
+                binding: context.stringBinding(\.crofAPIToken),
+                actions: [
+                    ProviderSettingsActionDescriptor(
+                        id: "crof-open-dashboard",
+                        title: "Open Crof dashboard",
+                        style: .link,
+                        isVisible: nil,
+                        perform: {
+                            if let url = URL(string: "https://crof.ai/dashboard") {
+                                NSWorkspace.shared.open(url)
+                            }
+                        }),
+                ],
+                isVisible: nil,
+                onActivate: nil),
+        ]
+    }
+}
diff --git a/Sources/CodexBar/Providers/Crof/CrofSettingsStore.swift b/Sources/CodexBar/Providers/Crof/CrofSettingsStore.swift
new file mode 100644
index 0000000000..86c152ea07
--- /dev/null
+++ b/Sources/CodexBar/Providers/Crof/CrofSettingsStore.swift
@@ -0,0 +1,14 @@
+import CodexBarCore
+import Foundation
+
+extension SettingsStore {
+    var crofAPIToken: String {
+        get { self.configSnapshot.providerConfig(for: .crof)?.sanitizedAPIKey ?? "" }
+        set {
+            self.updateProviderConfig(provider: .crof) { entry in
+                entry.apiKey = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .crof, field: "apiKey", value: newValue)
+        }
+    }
+}
diff --git a/Sources/CodexBar/Providers/Cursor/CursorLoginFlow.swift b/Sources/CodexBar/Providers/Cursor/CursorLoginFlow.swift
index ff65fb5393..04f75022d2 100644
--- a/Sources/CodexBar/Providers/Cursor/CursorLoginFlow.swift
+++ b/Sources/CodexBar/Providers/Cursor/CursorLoginFlow.swift
@@ -4,14 +4,12 @@ import CodexBarCore
 extension StatusItemController {
     func runCursorLoginFlow() async {
         let cursorRunner = CursorLoginRunner(browserDetection: self.store.browserDetection)
-        let phaseHandler: @Sendable (CursorLoginRunner.Phase) -> Void = { [weak self] phase in
-            Task { @MainActor in
-                switch phase {
-                case .loading, .waitingLogin:
-                    self?.loginPhase = .waitingBrowser
-                case .success, .failed:
-                    self?.loginPhase = .idle
-                }
+        let phaseHandler: @MainActor (CursorLoginRunner.Phase) -> Void = { [weak self] phase in
+            switch phase {
+            case .loading, .waitingLogin:
+                self?.loginPhase = .waitingBrowser
+            case .success, .failed:
+                self?.loginPhase = .idle
             }
         }
         let result = await cursorRunner.run(onPhaseChange: phaseHandler)
diff --git a/Sources/CodexBar/Providers/Cursor/CursorProviderImplementation.swift b/Sources/CodexBar/Providers/Cursor/CursorProviderImplementation.swift
index 48db614f96..e547a7cd67 100644
--- a/Sources/CodexBar/Providers/Cursor/CursorProviderImplementation.swift
+++ b/Sources/CodexBar/Providers/Cursor/CursorProviderImplementation.swift
@@ -1,9 +1,7 @@
 import CodexBarCore
-import CodexBarMacroSupport
 import Foundation
 import SwiftUI
 
-@ProviderImplementationRegistration
 struct CursorProviderImplementation: ProviderImplementation {
     let id: UsageProvider = .cursor
     let supportsLoginFlow: Bool = true
@@ -69,7 +67,7 @@ struct CursorProviderImplementation: ProviderImplementation {
                 isVisible: nil,
                 onChange: nil,
                 trailingText: {
-                    guard let entry = CookieHeaderCache.load(provider: .cursor) else { return nil }
+                    guard let entry = CookieHeaderCache.loadForDisplay(provider: .cursor) else { return nil }
                     let when = entry.storedAt.relativeDescription()
                     return "Cached: \(entry.sourceLabel) • \(when)"
                 }),
@@ -94,9 +92,9 @@ struct CursorProviderImplementation: ProviderImplementation {
         let used = UsageFormatter.currencyString(cost.used, currencyCode: cost.currencyCode)
         if cost.limit > 0 {
             let limitStr = UsageFormatter.currencyString(cost.limit, currencyCode: cost.currencyCode)
-            entries.append(.text("On-Demand: \(used) / \(limitStr)", .primary))
+            entries.append(.text(String(format: L("cursor_on_demand_with_limit"), used, limitStr), .primary))
         } else {
-            entries.append(.text("On-Demand: \(used)", .primary))
+            entries.append(.text(String(format: L("cursor_on_demand"), used), .primary))
         }
     }
 }
diff --git a/Sources/CodexBar/Providers/Cursor/CursorSettingsStore.swift b/Sources/CodexBar/Providers/Cursor/CursorSettingsStore.swift
index 92bc131c75..0de2438feb 100644
--- a/Sources/CodexBar/Providers/Cursor/CursorSettingsStore.swift
+++ b/Sources/CodexBar/Providers/Cursor/CursorSettingsStore.swift
@@ -28,36 +28,10 @@ extension SettingsStore {
 extension SettingsStore {
     func cursorSettingsSnapshot(tokenOverride: TokenAccountOverride?) -> ProviderSettingsSnapshot
     .CursorProviderSettings {
-        ProviderSettingsSnapshot.CursorProviderSettings(
-            cookieSource: self.cursorSnapshotCookieSource(tokenOverride: tokenOverride),
-            manualCookieHeader: self.cursorSnapshotCookieHeader(tokenOverride: tokenOverride))
-    }
-
-    private func cursorSnapshotCookieHeader(tokenOverride: TokenAccountOverride?) -> String {
-        let fallback = self.cursorCookieHeader
-        guard let support = TokenAccountSupportCatalog.support(for: .cursor),
-              case .cookieHeader = support.injection
-        else {
-            return fallback
-        }
-        guard let account = ProviderTokenAccountSelection.selectedAccount(
+        self.resolvedCookieSettings(
             provider: .cursor,
-            settings: self,
-            override: tokenOverride)
-        else {
-            return fallback
-        }
-        return TokenAccountSupportCatalog.normalizedCookieHeader(account.token, support: support)
-    }
-
-    private func cursorSnapshotCookieSource(tokenOverride: TokenAccountOverride?) -> ProviderCookieSource {
-        let fallback = self.cursorCookieSource
-        guard let support = TokenAccountSupportCatalog.support(for: .cursor),
-              support.requiresManualCookieSource
-        else {
-            return fallback
-        }
-        if self.tokenAccounts(for: .cursor).isEmpty { return fallback }
-        return .manual
+            configuredSource: self.cursorCookieSource,
+            configuredHeader: self.cursorCookieHeader,
+            tokenOverride: tokenOverride)
     }
 }
diff --git a/Sources/CodexBar/Providers/DeepSeek/DeepSeekProviderImplementation.swift b/Sources/CodexBar/Providers/DeepSeek/DeepSeekProviderImplementation.swift
new file mode 100644
index 0000000000..2d9b000e33
--- /dev/null
+++ b/Sources/CodexBar/Providers/DeepSeek/DeepSeekProviderImplementation.swift
@@ -0,0 +1,27 @@
+import CodexBarCore
+import Foundation
+
+struct DeepSeekProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .deepseek
+
+    @MainActor
+    func presentation(context _: ProviderPresentationContext) -> ProviderPresentation {
+        ProviderPresentation { _ in "api" }
+    }
+
+    @MainActor
+    func observeSettings(_: SettingsStore) {}
+
+    @MainActor
+    func isAvailable(context: ProviderAvailabilityContext) -> Bool {
+        if DeepSeekSettingsReader.apiKey(environment: context.environment) != nil {
+            return true
+        }
+        return !context.settings.tokenAccounts(for: .deepseek).isEmpty
+    }
+
+    @MainActor
+    func settingsFields(context _: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        []
+    }
+}
diff --git a/Sources/CodexBar/Providers/Deepgram/DeepgramProviderImplementation.swift b/Sources/CodexBar/Providers/Deepgram/DeepgramProviderImplementation.swift
new file mode 100644
index 0000000000..a230196345
--- /dev/null
+++ b/Sources/CodexBar/Providers/Deepgram/DeepgramProviderImplementation.swift
@@ -0,0 +1,51 @@
+import CodexBarCore
+import Foundation
+
+struct DeepgramProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .deepgram
+
+    @MainActor
+    func presentation(context _: ProviderPresentationContext) -> ProviderPresentation {
+        ProviderPresentation { _ in "api" }
+    }
+
+    @MainActor
+    func observeSettings(_ settings: SettingsStore) {
+        _ = settings.deepgramAPIKey
+        _ = settings.deepgramProjectID
+    }
+
+    @MainActor
+    func isAvailable(context: ProviderAvailabilityContext) -> Bool {
+        if DeepgramSettingsReader.apiKey(environment: context.environment) != nil {
+            return true
+        }
+        return !context.settings.deepgramAPIKey.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+    }
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "deepgram-api-key",
+                title: "API key",
+                subtitle: "Stored in ~/.codexbar/config.json. Get your key from console.deepgram.com.",
+                kind: .secure,
+                placeholder: "dg_...",
+                binding: context.stringBinding(\.deepgramAPIKey),
+                actions: [],
+                isVisible: nil,
+                onActivate: nil),
+            ProviderSettingsFieldDescriptor(
+                id: "deepgram-project-id",
+                title: "Project ID",
+                subtitle: "Optional. Leave blank to discover and aggregate projects visible to the API key.",
+                kind: .plain,
+                placeholder: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
+                binding: context.stringBinding(\.deepgramProjectID),
+                actions: [],
+                isVisible: nil,
+                onActivate: nil),
+        ]
+    }
+}
diff --git a/Sources/CodexBar/Providers/Deepgram/DeepgramSettingsStore.swift b/Sources/CodexBar/Providers/Deepgram/DeepgramSettingsStore.swift
new file mode 100644
index 0000000000..e3588596dd
--- /dev/null
+++ b/Sources/CodexBar/Providers/Deepgram/DeepgramSettingsStore.swift
@@ -0,0 +1,27 @@
+import CodexBarCore
+import Foundation
+
+extension SettingsStore {
+    var deepgramAPIKey: String {
+        get {
+            self.configSnapshot.providerConfig(for: .deepgram)?.sanitizedAPIKey ?? ""
+        }
+        set {
+            self.updateProviderConfig(provider: .deepgram) { entry in
+                entry.apiKey = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .deepgram, field: "apiKey", value: newValue)
+        }
+    }
+
+    var deepgramProjectID: String {
+        get {
+            self.configSnapshot.providerConfig(for: .deepgram)?.sanitizedWorkspaceID ?? ""
+        }
+        set {
+            self.updateProviderConfig(provider: .deepgram) { entry in
+                entry.workspaceID = self.normalizedConfigValue(newValue)
+            }
+        }
+    }
+}
diff --git a/Sources/CodexBar/Providers/Devin/DevinProviderImplementation.swift b/Sources/CodexBar/Providers/Devin/DevinProviderImplementation.swift
new file mode 100644
index 0000000000..fd667dfd0a
--- /dev/null
+++ b/Sources/CodexBar/Providers/Devin/DevinProviderImplementation.swift
@@ -0,0 +1,121 @@
+import AppKit
+import CodexBarCore
+import Foundation
+import SwiftUI
+
+struct DevinProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .devin
+    let supportsLoginFlow: Bool = true
+
+    @MainActor
+    func presentation(context _: ProviderPresentationContext) -> ProviderPresentation {
+        ProviderPresentation { context in
+            context.store.sourceLabel(for: context.provider)
+        }
+    }
+
+    @MainActor
+    func observeSettings(_ settings: SettingsStore) {
+        _ = settings.devinCookieSource
+        _ = settings.devinBearerToken
+        _ = settings.devinOrganization
+    }
+
+    @MainActor
+    func settingsSnapshot(context: ProviderSettingsSnapshotContext) -> ProviderSettingsSnapshotContribution? {
+        .devin(context.settings.devinSettingsSnapshot(tokenOverride: context.tokenOverride))
+    }
+
+    @MainActor
+    func settingsPickers(context: ProviderSettingsContext) -> [ProviderSettingsPickerDescriptor] {
+        let cookieBinding = Binding(
+            get: { context.settings.devinCookieSource.rawValue },
+            set: { raw in
+                context.settings.devinCookieSource = ProviderCookieSource(rawValue: raw) ?? .auto
+            })
+        let cookieOptions = ProviderCookieSourceUI.options(
+            allowsOff: false,
+            keychainDisabled: context.settings.debugDisableKeychainAccess)
+        let subtitle: () -> String? = {
+            ProviderCookieSourceUI.subtitle(
+                source: context.settings.devinCookieSource,
+                keychainDisabled: context.settings.debugDisableKeychainAccess,
+                auto: "Automatically imports the app.devin.ai session from Chrome.",
+                manual: "Paste an Authorization Bearer token from app.devin.ai.",
+                off: "Paste an Authorization Bearer token from app.devin.ai.")
+        }
+
+        return [
+            ProviderSettingsPickerDescriptor(
+                id: "devin-cookie-source",
+                title: "Auth source",
+                subtitle: "Automatically imports the app.devin.ai session from Chrome.",
+                dynamicSubtitle: subtitle,
+                binding: cookieBinding,
+                options: cookieOptions,
+                isVisible: nil,
+                onChange: nil),
+        ]
+    }
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "devin-organization",
+                title: "Organization",
+                subtitle: "Optional. Use the slug from app.devin.ai/org/<slug>, or paste the full Devin org URL.",
+                kind: .plain,
+                placeholder: "org/example-org",
+                binding: context.stringBinding(\.devinOrganization),
+                actions: [
+                    ProviderSettingsActionDescriptor(
+                        id: "devin-open-usage",
+                        title: "Open Devin Usage",
+                        style: .link,
+                        isVisible: nil,
+                        perform: {
+                            NSWorkspace.shared.open(Self.usageURL(organization: context.settings.devinOrganization))
+                        }),
+                ],
+                isVisible: nil,
+                onActivate: nil),
+            ProviderSettingsFieldDescriptor(
+                id: "devin-bearer-token",
+                title: "Bearer token",
+                subtitle: "Paste the Authorization header value from app.devin.ai.",
+                kind: .secure,
+                placeholder: "Bearer eyJ...",
+                binding: context.stringBinding(\.devinBearerToken),
+                actions: [],
+                isVisible: { context.settings.devinCookieSource == .manual },
+                onActivate: nil),
+        ]
+    }
+
+    @MainActor
+    func loginMenuAction(context _: ProviderMenuLoginContext)
+        -> (label: String, action: MenuDescriptor.MenuAction)?
+    {
+        ("Open Devin...", .loginToProvider(url: Self.usageURL(organization: nil).absoluteString))
+    }
+
+    @MainActor
+    func runLoginFlow(context: ProviderLoginContext) async -> Bool {
+        let organization = context.controller.settings.devinOrganization
+        NSWorkspace.shared.open(Self.usageURL(organization: organization))
+        return false
+    }
+
+    private static func usageURL(organization: String?) -> URL {
+        let normalized = DevinUsageFetcher.normalizedOrganization(organization)
+        let urlString: String
+        if let normalized, normalized.hasPrefix("org/") {
+            let slug = String(normalized.dropFirst(4))
+            urlString = "https://app.devin.ai/org/\(slug)/settings/usage"
+        } else {
+            urlString = "https://app.devin.ai/settings/usage"
+        }
+        return URL(string: urlString) ?? URL(string: "https://app.devin.ai")!
+    }
+}
diff --git a/Sources/CodexBar/Providers/Devin/DevinSettingsStore.swift b/Sources/CodexBar/Providers/Devin/DevinSettingsStore.swift
new file mode 100644
index 0000000000..430f440439
--- /dev/null
+++ b/Sources/CodexBar/Providers/Devin/DevinSettingsStore.swift
@@ -0,0 +1,43 @@
+import CodexBarCore
+import Foundation
+
+extension SettingsStore {
+    var devinBearerToken: String {
+        get { self.configSnapshot.providerConfig(for: .devin)?.sanitizedCookieHeader ?? "" }
+        set {
+            self.updateProviderConfig(provider: .devin) { entry in
+                entry.cookieHeader = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .devin, field: "cookieHeader", value: newValue)
+        }
+    }
+
+    var devinCookieSource: ProviderCookieSource {
+        get { self.resolvedCookieSource(provider: .devin, fallback: .auto) }
+        set {
+            self.updateProviderConfig(provider: .devin) { entry in
+                entry.cookieSource = newValue
+            }
+            self.logProviderModeChange(provider: .devin, field: "cookieSource", value: newValue.rawValue)
+        }
+    }
+
+    var devinOrganization: String {
+        get { self.configSnapshot.providerConfig(for: .devin)?.sanitizedWorkspaceID ?? "" }
+        set {
+            self.updateProviderConfig(provider: .devin) { entry in
+                entry.workspaceID = self.normalizedConfigValue(newValue)
+            }
+        }
+    }
+}
+
+extension SettingsStore {
+    func devinSettingsSnapshot(tokenOverride _: TokenAccountOverride?) -> ProviderSettingsSnapshot
+    .DevinProviderSettings {
+        ProviderSettingsSnapshot.DevinProviderSettings(
+            cookieSource: self.devinCookieSource,
+            manualBearerToken: self.devinBearerToken,
+            organization: self.devinOrganization)
+    }
+}
diff --git a/Sources/CodexBar/Providers/Doubao/DoubaoProviderImplementation.swift b/Sources/CodexBar/Providers/Doubao/DoubaoProviderImplementation.swift
new file mode 100644
index 0000000000..ba91a2fc5f
--- /dev/null
+++ b/Sources/CodexBar/Providers/Doubao/DoubaoProviderImplementation.swift
@@ -0,0 +1,40 @@
+import AppKit
+import CodexBarCore
+import Foundation
+
+struct DoubaoProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .doubao
+
+    @MainActor
+    func observeSettings(_ settings: SettingsStore) {
+        _ = settings.doubaoAPIToken
+    }
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "doubao-api-token",
+                title: "API key",
+                subtitle: "Stored in ~/.codexbar/config.json. Get your API key from the Volcengine "
+                    + "Ark console.",
+                kind: .secure,
+                placeholder: "ark-...",
+                binding: context.stringBinding(\.doubaoAPIToken),
+                actions: [
+                    ProviderSettingsActionDescriptor(
+                        id: "doubao-open-dashboard",
+                        title: "Open Volcengine Ark Console",
+                        style: .link,
+                        isVisible: nil,
+                        perform: {
+                            if let url = URL(string: "https://console.volcengine.com/ark/") {
+                                NSWorkspace.shared.open(url)
+                            }
+                        }),
+                ],
+                isVisible: nil,
+                onActivate: nil),
+        ]
+    }
+}
diff --git a/Sources/CodexBar/Providers/Doubao/DoubaoSettingsStore.swift b/Sources/CodexBar/Providers/Doubao/DoubaoSettingsStore.swift
new file mode 100644
index 0000000000..4d69a273f1
--- /dev/null
+++ b/Sources/CodexBar/Providers/Doubao/DoubaoSettingsStore.swift
@@ -0,0 +1,14 @@
+import CodexBarCore
+import Foundation
+
+extension SettingsStore {
+    var doubaoAPIToken: String {
+        get { self.configSnapshot.providerConfig(for: .doubao)?.sanitizedAPIKey ?? "" }
+        set {
+            self.updateProviderConfig(provider: .doubao) { entry in
+                entry.apiKey = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .doubao, field: "apiKey", value: newValue)
+        }
+    }
+}
diff --git a/Sources/CodexBar/Providers/ElevenLabs/ElevenLabsProviderImplementation.swift b/Sources/CodexBar/Providers/ElevenLabs/ElevenLabsProviderImplementation.swift
new file mode 100644
index 0000000000..cf3d314022
--- /dev/null
+++ b/Sources/CodexBar/Providers/ElevenLabs/ElevenLabsProviderImplementation.swift
@@ -0,0 +1,43 @@
+import CodexBarCore
+import Foundation
+
+struct ElevenLabsProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .elevenlabs
+
+    @MainActor
+    func presentation(context _: ProviderPresentationContext) -> ProviderPresentation {
+        ProviderPresentation { _ in "api" }
+    }
+
+    @MainActor
+    func observeSettings(_ settings: SettingsStore) {
+        _ = settings.elevenLabsAPIKey
+    }
+
+    @MainActor
+    func isAvailable(context: ProviderAvailabilityContext) -> Bool {
+        if ElevenLabsSettingsReader.apiKey(environment: context.environment) != nil {
+            return true
+        }
+        if !context.settings.elevenLabsAPIKey.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
+            return true
+        }
+        return !context.settings.tokenAccounts(for: .elevenlabs).isEmpty
+    }
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "elevenlabs-api-key",
+                title: "API key",
+                subtitle: "Stored in ~/.codexbar/config.json. Get your key from elevenlabs.io/app/settings/api-keys.",
+                kind: .secure,
+                placeholder: "xi-...",
+                binding: context.stringBinding(\.elevenLabsAPIKey),
+                actions: [],
+                isVisible: nil,
+                onActivate: nil),
+        ]
+    }
+}
diff --git a/Sources/CodexBar/Providers/ElevenLabs/ElevenLabsSettingsStore.swift b/Sources/CodexBar/Providers/ElevenLabs/ElevenLabsSettingsStore.swift
new file mode 100644
index 0000000000..4ebdc787f1
--- /dev/null
+++ b/Sources/CodexBar/Providers/ElevenLabs/ElevenLabsSettingsStore.swift
@@ -0,0 +1,14 @@
+import CodexBarCore
+import Foundation
+
+extension SettingsStore {
+    var elevenLabsAPIKey: String {
+        get { self.configSnapshot.providerConfig(for: .elevenlabs)?.sanitizedAPIKey ?? "" }
+        set {
+            self.updateProviderConfig(provider: .elevenlabs) { entry in
+                entry.apiKey = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .elevenlabs, field: "apiKey", value: newValue)
+        }
+    }
+}
diff --git a/Sources/CodexBar/Providers/Factory/FactoryProviderImplementation.swift b/Sources/CodexBar/Providers/Factory/FactoryProviderImplementation.swift
index d8d2d20245..b9e7e8e10a 100644
--- a/Sources/CodexBar/Providers/Factory/FactoryProviderImplementation.swift
+++ b/Sources/CodexBar/Providers/Factory/FactoryProviderImplementation.swift
@@ -1,9 +1,7 @@
 import CodexBarCore
-import CodexBarMacroSupport
 import Foundation
 import SwiftUI
 
-@ProviderImplementationRegistration
 struct FactoryProviderImplementation: ProviderImplementation {
     let id: UsageProvider = .factory
     let supportsLoginFlow: Bool = true
@@ -49,7 +47,7 @@ struct FactoryProviderImplementation: ProviderImplementation {
                 source: context.settings.factoryCookieSource,
                 keychainDisabled: context.settings.debugDisableKeychainAccess,
                 auto: "Automatic imports browser cookies and WorkOS tokens.",
-                manual: "Paste a Cookie header from app.factory.ai.",
+                manual: "Paste a Cookie or Authorization header from app.factory.ai.",
                 off: "Factory cookies are disabled.")
         }
 
@@ -64,7 +62,7 @@ struct FactoryProviderImplementation: ProviderImplementation {
                 isVisible: nil,
                 onChange: nil,
                 trailingText: {
-                    guard let entry = CookieHeaderCache.load(provider: .factory) else { return nil }
+                    guard let entry = CookieHeaderCache.loadForDisplay(provider: .factory) else { return nil }
                     let when = entry.storedAt.relativeDescription()
                     return "Cached: \(entry.sourceLabel) • \(when)"
                 }),
@@ -82,4 +80,22 @@ struct FactoryProviderImplementation: ProviderImplementation {
         await context.controller.runFactoryLoginFlow()
         return true
     }
+
+    @MainActor
+    func loginMenuAction(context _: ProviderMenuLoginContext)
+        -> (label: String, action: MenuDescriptor.MenuAction)?
+    {
+        ("Open Droid in Browser...", .loginToProvider(url: "https://app.factory.ai"))
+    }
+
+    @MainActor
+    func appendUsageMenuEntries(context: ProviderMenuUsageContext, entries: inout [ProviderMenuEntry]) {
+        guard context.settings.showOptionalCreditsAndExtraUsage,
+              let cost = context.snapshot?.providerCost,
+              cost.period == "Extra usage balance"
+        else { return }
+
+        let balance = UsageFormatter.currencyString(cost.used, currencyCode: cost.currencyCode)
+        entries.append(.text(L("Extra usage balance: %@", balance), .primary))
+    }
 }
diff --git a/Sources/CodexBar/Providers/Factory/FactorySettingsStore.swift b/Sources/CodexBar/Providers/Factory/FactorySettingsStore.swift
index 968132998d..88931e3a20 100644
--- a/Sources/CodexBar/Providers/Factory/FactorySettingsStore.swift
+++ b/Sources/CodexBar/Providers/Factory/FactorySettingsStore.swift
@@ -28,36 +28,10 @@ extension SettingsStore {
 extension SettingsStore {
     func factorySettingsSnapshot(tokenOverride: TokenAccountOverride?) -> ProviderSettingsSnapshot
     .FactoryProviderSettings {
-        ProviderSettingsSnapshot.FactoryProviderSettings(
-            cookieSource: self.factorySnapshotCookieSource(tokenOverride: tokenOverride),
-            manualCookieHeader: self.factorySnapshotCookieHeader(tokenOverride: tokenOverride))
-    }
-
-    private func factorySnapshotCookieHeader(tokenOverride: TokenAccountOverride?) -> String {
-        let fallback = self.factoryCookieHeader
-        guard let support = TokenAccountSupportCatalog.support(for: .factory),
-              case .cookieHeader = support.injection
-        else {
-            return fallback
-        }
-        guard let account = ProviderTokenAccountSelection.selectedAccount(
+        self.resolvedCookieSettings(
             provider: .factory,
-            settings: self,
-            override: tokenOverride)
-        else {
-            return fallback
-        }
-        return TokenAccountSupportCatalog.normalizedCookieHeader(account.token, support: support)
-    }
-
-    private func factorySnapshotCookieSource(tokenOverride: TokenAccountOverride?) -> ProviderCookieSource {
-        let fallback = self.factoryCookieSource
-        guard let support = TokenAccountSupportCatalog.support(for: .factory),
-              support.requiresManualCookieSource
-        else {
-            return fallback
-        }
-        if self.tokenAccounts(for: .factory).isEmpty { return fallback }
-        return .manual
+            configuredSource: self.factoryCookieSource,
+            configuredHeader: self.factoryCookieHeader,
+            tokenOverride: tokenOverride)
     }
 }
diff --git a/Sources/CodexBar/Providers/Gemini/GeminiProviderImplementation.swift b/Sources/CodexBar/Providers/Gemini/GeminiProviderImplementation.swift
index 12b6e7c917..b9caa5144a 100644
--- a/Sources/CodexBar/Providers/Gemini/GeminiProviderImplementation.swift
+++ b/Sources/CodexBar/Providers/Gemini/GeminiProviderImplementation.swift
@@ -1,8 +1,6 @@
 import CodexBarCore
-import CodexBarMacroSupport
 import Foundation
 
-@ProviderImplementationRegistration
 struct GeminiProviderImplementation: ProviderImplementation {
     let id: UsageProvider = .gemini
     let supportsLoginFlow: Bool = true
diff --git a/Sources/CodexBar/Providers/Grok/GrokProviderImplementation.swift b/Sources/CodexBar/Providers/Grok/GrokProviderImplementation.swift
new file mode 100644
index 0000000000..1d53f20a08
--- /dev/null
+++ b/Sources/CodexBar/Providers/Grok/GrokProviderImplementation.swift
@@ -0,0 +1,6 @@
+import CodexBarCore
+import Foundation
+
+struct GrokProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .grok
+}
diff --git a/Sources/CodexBar/Providers/Groq/GroqProviderImplementation.swift b/Sources/CodexBar/Providers/Groq/GroqProviderImplementation.swift
new file mode 100644
index 0000000000..cffdb38ea9
--- /dev/null
+++ b/Sources/CodexBar/Providers/Groq/GroqProviderImplementation.swift
@@ -0,0 +1,38 @@
+import CodexBarCore
+import Foundation
+
+struct GroqProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .groq
+
+    @MainActor
+    func presentation(context _: ProviderPresentationContext) -> ProviderPresentation {
+        ProviderPresentation { _ in "metrics" }
+    }
+
+    @MainActor
+    func observeSettings(_ settings: SettingsStore) {
+        _ = settings.groqAPIKey
+    }
+
+    @MainActor
+    func isAvailable(context: ProviderAvailabilityContext) -> Bool {
+        ProviderTokenResolver.groqToken(environment: context.environment) != nil ||
+            !context.settings.groqAPIKey.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+    }
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "groq-api-key",
+                title: "API key",
+                subtitle: "Stored in ~/.codexbar/config.json. Metrics require Groq Enterprise Prometheus access.",
+                kind: .secure,
+                placeholder: "gsk_...",
+                binding: context.stringBinding(\.groqAPIKey),
+                actions: [],
+                isVisible: nil,
+                onActivate: nil),
+        ]
+    }
+}
diff --git a/Sources/CodexBar/Providers/Groq/GroqSettingsStore.swift b/Sources/CodexBar/Providers/Groq/GroqSettingsStore.swift
new file mode 100644
index 0000000000..61f1113d6d
--- /dev/null
+++ b/Sources/CodexBar/Providers/Groq/GroqSettingsStore.swift
@@ -0,0 +1,16 @@
+import CodexBarCore
+import Foundation
+
+extension SettingsStore {
+    var groqAPIKey: String {
+        get {
+            self.configSnapshot.providerConfig(for: .groq)?.sanitizedAPIKey ?? ""
+        }
+        set {
+            self.updateProviderConfig(provider: .groq) { entry in
+                entry.apiKey = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .groq, field: "apiKey", value: newValue)
+        }
+    }
+}
diff --git a/Sources/CodexBar/Providers/JetBrains/JetBrainsLoginFlow.swift b/Sources/CodexBar/Providers/JetBrains/JetBrainsLoginFlow.swift
index bfb92438e7..e188c04bbb 100644
--- a/Sources/CodexBar/Providers/JetBrains/JetBrainsLoginFlow.swift
+++ b/Sources/CodexBar/Providers/JetBrains/JetBrainsLoginFlow.swift
@@ -1,4 +1,5 @@
 import CodexBarCore
+import Foundation
 
 @MainActor
 extension StatusItemController {
@@ -17,10 +18,10 @@ extension StatusItemController {
             let ideNames = detectedIDEs.prefix(3).map(\.displayName).joined(separator: ", ")
             let hasQuotaFile = !JetBrainsIDEDetector.detectInstalledIDEs().isEmpty
             let message = hasQuotaFile
-                ? "Detected: \(ideNames). Select your preferred IDE in Settings, then refresh CodexBar."
-                : "Detected: \(ideNames). Use AI Assistant once to generate quota data, then refresh CodexBar."
+                ? String(format: L("jetbrains_detected_select"), ideNames)
+                : String(format: L("jetbrains_detected_generate"), ideNames)
             self.presentLoginAlert(
-                title: "JetBrains AI is ready",
+                title: L("JetBrains AI is ready"),
                 message: message)
         }
     }
diff --git a/Sources/CodexBar/Providers/JetBrains/JetBrainsProviderImplementation.swift b/Sources/CodexBar/Providers/JetBrains/JetBrainsProviderImplementation.swift
index 7e7096f50f..beaf36b780 100644
--- a/Sources/CodexBar/Providers/JetBrains/JetBrainsProviderImplementation.swift
+++ b/Sources/CodexBar/Providers/JetBrains/JetBrainsProviderImplementation.swift
@@ -1,9 +1,7 @@
 import CodexBarCore
-import CodexBarMacroSupport
 import Foundation
 import SwiftUI
 
-@ProviderImplementationRegistration
 struct JetBrainsProviderImplementation: ProviderImplementation {
     let id: UsageProvider = .jetbrains
 
diff --git a/Sources/CodexBar/Providers/Kilo/KiloProviderImplementation.swift b/Sources/CodexBar/Providers/Kilo/KiloProviderImplementation.swift
index e2bdb3cfae..5e54327402 100644
--- a/Sources/CodexBar/Providers/Kilo/KiloProviderImplementation.swift
+++ b/Sources/CodexBar/Providers/Kilo/KiloProviderImplementation.swift
@@ -1,10 +1,8 @@
 import AppKit
 import CodexBarCore
-import CodexBarMacroSupport
 import Foundation
 import SwiftUI
 
-@ProviderImplementationRegistration
 struct KiloProviderImplementation: ProviderImplementation {
     let id: UsageProvider = .kilo
 
@@ -84,4 +82,86 @@ struct KiloProviderImplementation: ProviderImplementation {
                 onActivate: nil),
         ]
     }
+
+    @MainActor
+    func settingsOrganizations(
+        context: ProviderSettingsContext) -> ProviderSettingsOrganizationsDescriptor?
+    {
+        let settings = context.settings
+        let store = context.store
+        return ProviderSettingsOrganizationsDescriptor(
+            id: "kilo-organizations",
+            title: "Organizations",
+            subtitle: "Show usage for organizations you belong to. Personal account is always shown.",
+            entries: {
+                var entries: [ProviderSettingsOrganizationsDescriptor.Entry] = [
+                    .init(
+                        id: "personal",
+                        title: "Personal account",
+                        subtitle: nil,
+                        isEnabled: true,
+                        isLocked: true),
+                ]
+                for org in settings.kiloKnownOrganizations {
+                    entries.append(
+                        .init(
+                            id: org.id,
+                            title: org.name,
+                            subtitle: org.role,
+                            localizesTitle: false,
+                            localizesSubtitle: false,
+                            isEnabled: settings.kiloIsOrganizationEnabled(org.id),
+                            isLocked: false))
+                }
+                return entries
+            },
+            onToggle: { orgID, enabled in
+                guard orgID != "personal" else { return }
+                settings.setKiloOrganization(orgID, enabled: enabled)
+                Task { @MainActor in
+                    await ProviderInteractionContext.$current.withValue(.userInitiated) {
+                        await store.refreshProvider(.kilo, allowDisabled: true)
+                    }
+                }
+            },
+            onRefresh: { [weak settings] in
+                guard let settings else {
+                    return .init(success: false, errorMessage: "Settings unavailable.")
+                }
+                let resolved: KiloResolvedBearerToken
+                do {
+                    resolved = try KiloBearerTokenResolver.resolve(
+                        source: settings.kiloUsageDataSource,
+                        apiKey: settings.configSnapshot.providerConfig(for: .kilo)?.sanitizedAPIKey)
+                } catch let error as LocalizedError {
+                    return .init(
+                        success: false,
+                        errorMessage: error.errorDescription ?? "Failed to resolve Kilo credentials.")
+                } catch {
+                    return .init(success: false, errorMessage: error.localizedDescription)
+                }
+                do {
+                    let orgs = try await KiloUsageFetcher.fetchOrganizations(apiKey: resolved.token)
+                    await MainActor.run {
+                        settings.setKiloKnownOrganizationsPruningEnabled(orgs)
+                    }
+                    return .init(success: true, errorMessage: nil)
+                } catch let error as LocalizedError {
+                    return .init(
+                        success: false,
+                        errorMessage: error.errorDescription ?? "Failed to load organizations.")
+                } catch {
+                    return .init(success: false, errorMessage: error.localizedDescription)
+                }
+            },
+            canRefresh: {
+                switch settings.kiloUsageDataSource {
+                case .api:
+                    !settings.kiloAPIToken.isEmpty
+                        || !(ProcessInfo.processInfo.environment[KiloSettingsReader.apiTokenKey] ?? "").isEmpty
+                case .cli, .auto:
+                    true
+                }
+            })
+    }
 }
diff --git a/Sources/CodexBar/Providers/Kilo/KiloSettingsStore.swift b/Sources/CodexBar/Providers/Kilo/KiloSettingsStore.swift
index d900bf4dc4..50fc279121 100644
--- a/Sources/CodexBar/Providers/Kilo/KiloSettingsStore.swift
+++ b/Sources/CodexBar/Providers/Kilo/KiloSettingsStore.swift
@@ -73,3 +73,70 @@ extension SettingsStore {
         }
     }
 }
+
+extension SettingsStore {
+    var kiloKnownOrganizations: [KiloOrganization] {
+        get { self.configSnapshot.providerConfig(for: .kilo)?.kiloKnownOrganizations ?? [] }
+        set {
+            self.updateProviderConfig(provider: .kilo) { entry in
+                entry.kiloKnownOrganizations = newValue.isEmpty ? nil : newValue
+            }
+        }
+    }
+
+    var kiloEnabledOrganizationIDs: [String] {
+        get { self.configSnapshot.providerConfig(for: .kilo)?.kiloEnabledOrganizationIDs ?? [] }
+        set {
+            let cleaned = Array(KiloOrgIDLinkedHashSet(newValue
+                    .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
+                    .filter { !$0.isEmpty }))
+            self.updateProviderConfig(provider: .kilo) { entry in
+                entry.kiloEnabledOrganizationIDs = cleaned.isEmpty ? nil : cleaned
+            }
+            self.logProviderModeChange(
+                provider: .kilo,
+                field: "enabledOrganizations",
+                value: cleaned.joined(separator: ","))
+        }
+    }
+
+    func setKiloKnownOrganizationsPruningEnabled(_ orgs: [KiloOrganization]) {
+        self.kiloKnownOrganizations = orgs
+        let validIDs = Set(orgs.map(\.id))
+        let pruned = self.kiloEnabledOrganizationIDs.filter { validIDs.contains($0) }
+        if pruned != self.kiloEnabledOrganizationIDs {
+            self.kiloEnabledOrganizationIDs = pruned
+        }
+    }
+
+    func kiloIsOrganizationEnabled(_ orgID: String) -> Bool {
+        self.kiloEnabledOrganizationIDs.contains(orgID)
+    }
+
+    func setKiloOrganization(_ orgID: String, enabled: Bool) {
+        var current = self.kiloEnabledOrganizationIDs
+        if enabled {
+            guard !current.contains(orgID) else { return }
+            current.append(orgID)
+        } else {
+            current.removeAll { $0 == orgID }
+        }
+        self.kiloEnabledOrganizationIDs = current
+    }
+}
+
+/// Small order-preserving set used to dedupe enabled IDs without sorting.
+private struct KiloOrgIDLinkedHashSet<Element: Hashable>: Sequence {
+    private var seen: Set<Element> = []
+    private var ordered: [Element] = []
+
+    init(_ sequence: some Sequence<Element>) {
+        for element in sequence where self.seen.insert(element).inserted {
+            self.ordered.append(element)
+        }
+    }
+
+    func makeIterator() -> IndexingIterator<[Element]> {
+        self.ordered.makeIterator()
+    }
+}
diff --git a/Sources/CodexBar/Providers/Kilo/UsageStore+KiloOrgRefresh.swift b/Sources/CodexBar/Providers/Kilo/UsageStore+KiloOrgRefresh.swift
new file mode 100644
index 0000000000..2d601f5cfe
--- /dev/null
+++ b/Sources/CodexBar/Providers/Kilo/UsageStore+KiloOrgRefresh.swift
@@ -0,0 +1,121 @@
+import CodexBarCore
+import Foundation
+
+struct KiloScopeSnapshot: Identifiable, Equatable {
+    let id: String // KiloUsageScope.scopeIdentifier
+    let scope: KiloUsageScope
+    let snapshot: UsageSnapshot?
+    let errorMessage: String?
+    let sourceLabel: String?
+
+    static func == (lhs: KiloScopeSnapshot, rhs: KiloScopeSnapshot) -> Bool {
+        lhs.id == rhs.id
+            && lhs.snapshot?.updatedAt == rhs.snapshot?.updatedAt
+            && lhs.errorMessage == rhs.errorMessage
+            && lhs.sourceLabel == rhs.sourceLabel
+    }
+}
+
+extension UsageStore {
+    var kiloEnabledScopes: [KiloUsageScope] {
+        var scopes: [KiloUsageScope] = [.personal]
+        let enabled = self.settings.kiloEnabledOrganizationIDs
+        guard !enabled.isEmpty else { return scopes }
+        let knownByID = Dictionary(
+            uniqueKeysWithValues: self.settings.kiloKnownOrganizations.map { ($0.id, $0) })
+        for id in enabled {
+            if let org = knownByID[id] {
+                scopes.append(.organization(id: org.id, name: org.name))
+            }
+        }
+        return scopes
+    }
+
+    func shouldFanOutKiloScopes() -> Bool {
+        self.kiloEnabledScopes.count > 1
+    }
+
+    func refreshKiloScopes(generation: UInt64? = nil) async {
+        let scopes = self.kiloEnabledScopes
+        guard scopes.count > 1 else {
+            await MainActor.run { self.kiloScopeSnapshots = [] }
+            return
+        }
+        let env = ProcessInfo.processInfo.environment
+        let resolved: KiloResolvedBearerToken
+        do {
+            resolved = try KiloBearerTokenResolver.resolve(
+                source: self.settings.kiloUsageDataSource,
+                apiKey: self.settings.configSnapshot.providerConfig(for: .kilo)?.sanitizedAPIKey,
+                environment: env)
+        } catch {
+            let message = (error as? LocalizedError)?.errorDescription
+                ?? error.localizedDescription
+            await MainActor.run {
+                self.kiloScopeSnapshots = scopes.map {
+                    KiloScopeSnapshot(
+                        id: $0.scopeIdentifier,
+                        scope: $0,
+                        snapshot: nil,
+                        errorMessage: message,
+                        sourceLabel: nil)
+                }
+            }
+            return
+        }
+
+        let results: [KiloScopeSnapshot] = await withTaskGroup(of: KiloScopeSnapshot.self) { group in
+            for scope in scopes {
+                group.addTask {
+                    do {
+                        let raw = try await KiloUsageFetcher.fetchUsage(
+                            apiKey: resolved.token,
+                            scope: scope,
+                            environment: env)
+                        let snapshot = raw.toUsageSnapshot()
+                            .withAccountOrganization(scope.displayName)
+                        return KiloScopeSnapshot(
+                            id: scope.scopeIdentifier,
+                            scope: scope,
+                            snapshot: snapshot,
+                            errorMessage: nil,
+                            sourceLabel: resolved.sourceLabel)
+                    } catch {
+                        return KiloScopeSnapshot(
+                            id: scope.scopeIdentifier,
+                            scope: scope,
+                            snapshot: nil,
+                            errorMessage: (error as? LocalizedError)?.errorDescription
+                                ?? error.localizedDescription,
+                            sourceLabel: nil)
+                    }
+                }
+            }
+            var collected: [KiloScopeSnapshot] = []
+            for await result in group {
+                collected.append(result)
+            }
+            return collected
+        }
+
+        let resultByID = Dictionary(uniqueKeysWithValues: results.map { ($0.id, $0) })
+        let ordered = scopes.compactMap { resultByID[$0.scopeIdentifier] }
+
+        await MainActor.run {
+            guard self.isCurrentProviderRefreshGeneration(.kilo, generation: generation) else { return }
+            self.kiloScopeSnapshots = ordered
+        }
+    }
+}
+
+extension UsageSnapshot {
+    fileprivate func withAccountOrganization(_ org: String) -> UsageSnapshot {
+        let baseIdentity = self.identity
+        let newIdentity = ProviderIdentitySnapshot(
+            providerID: baseIdentity?.providerID ?? .kilo,
+            accountEmail: baseIdentity?.accountEmail,
+            accountOrganization: org,
+            loginMethod: baseIdentity?.loginMethod)
+        return self.withIdentity(newIdentity)
+    }
+}
diff --git a/Sources/CodexBar/Providers/Kimi/KimiProviderImplementation.swift b/Sources/CodexBar/Providers/Kimi/KimiProviderImplementation.swift
index d48511963d..0210b4b64b 100644
--- a/Sources/CodexBar/Providers/Kimi/KimiProviderImplementation.swift
+++ b/Sources/CodexBar/Providers/Kimi/KimiProviderImplementation.swift
@@ -1,20 +1,22 @@
 import AppKit
 import CodexBarCore
-import CodexBarMacroSupport
 import Foundation
 import SwiftUI
 
-@ProviderImplementationRegistration
 struct KimiProviderImplementation: ProviderImplementation {
     let id: UsageProvider = .kimi
 
     @MainActor
     func presentation(context _: ProviderPresentationContext) -> ProviderPresentation {
-        ProviderPresentation { _ in "web" }
+        ProviderPresentation { context in
+            context.store.sourceLabel(for: context.provider)
+        }
     }
 
     @MainActor
     func observeSettings(_ settings: SettingsStore) {
+        _ = settings.kimiUsageDataSource
+        _ = settings.kimiAPIKey
         _ = settings.kimiCookieSource
         _ = settings.kimiManualCookieHeader
     }
@@ -24,8 +26,33 @@ struct KimiProviderImplementation: ProviderImplementation {
         .kimi(context.settings.kimiSettingsSnapshot(tokenOverride: context.tokenOverride))
     }
 
+    @MainActor
+    func defaultSourceLabel(context: ProviderSourceLabelContext) -> String? {
+        context.settings.kimiUsageDataSource.rawValue
+    }
+
+    @MainActor
+    func sourceMode(context: ProviderSourceModeContext) -> ProviderSourceMode {
+        switch context.settings.kimiUsageDataSource {
+        case .api: .api
+        case .web: .web
+        case .auto, .cli, .oauth: .auto
+        }
+    }
+
     @MainActor
     func settingsPickers(context: ProviderSettingsContext) -> [ProviderSettingsPickerDescriptor] {
+        let usageBinding = Binding(
+            get: { context.settings.kimiUsageDataSource.rawValue },
+            set: { raw in
+                context.settings.kimiUsageDataSource = ProviderSourceMode(rawValue: raw) ?? .auto
+            })
+        let usageOptions = [
+            ProviderSettingsPickerOption(id: ProviderSourceMode.auto.rawValue, title: "Auto"),
+            ProviderSettingsPickerOption(id: ProviderSourceMode.api.rawValue, title: "API key"),
+            ProviderSettingsPickerOption(id: ProviderSourceMode.web.rawValue, title: "Browser cookies"),
+        ]
+
         let cookieBinding = Binding(
             get: { context.settings.kimiCookieSource.rawValue },
             set: { raw in
@@ -45,6 +72,19 @@ struct KimiProviderImplementation: ProviderImplementation {
         }
 
         return [
+            ProviderSettingsPickerDescriptor(
+                id: "kimi-usage-source",
+                title: "Usage source",
+                subtitle: "Auto uses the Kimi Code API key first, then falls back to browser cookies.",
+                binding: usageBinding,
+                options: usageOptions,
+                isVisible: nil,
+                onChange: nil,
+                trailingText: {
+                    guard context.settings.kimiUsageDataSource == .auto else { return nil }
+                    let label = context.store.sourceLabel(for: .kimi)
+                    return label == "auto" ? nil : label
+                }),
             ProviderSettingsPickerDescriptor(
                 id: "kimi-cookie-source",
                 title: "Cookie source",
@@ -60,6 +100,27 @@ struct KimiProviderImplementation: ProviderImplementation {
     @MainActor
     func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
         [
+            ProviderSettingsFieldDescriptor(
+                id: "kimi-api-key",
+                title: "API key",
+                subtitle: "Stored in ~/.codexbar/config.json. You can also provide KIMI_CODE_API_KEY.",
+                kind: .secure,
+                placeholder: "Paste Kimi Code API key...",
+                binding: context.stringBinding(\.kimiAPIKey),
+                actions: [
+                    ProviderSettingsActionDescriptor(
+                        id: "kimi-open-api-docs",
+                        title: "Open API docs",
+                        style: .link,
+                        isVisible: nil,
+                        perform: {
+                            if let url = URL(string: "https://www.kimi.com/code/docs/en/") {
+                                NSWorkspace.shared.open(url)
+                            }
+                        }),
+                ],
+                isVisible: nil,
+                onActivate: nil),
             ProviderSettingsFieldDescriptor(
                 id: "kimi-cookie",
                 title: "",
diff --git a/Sources/CodexBar/Providers/Kimi/KimiSettingsStore.swift b/Sources/CodexBar/Providers/Kimi/KimiSettingsStore.swift
index a79241d4b7..6d5adf2c14 100644
--- a/Sources/CodexBar/Providers/Kimi/KimiSettingsStore.swift
+++ b/Sources/CodexBar/Providers/Kimi/KimiSettingsStore.swift
@@ -2,6 +2,32 @@ import CodexBarCore
 import Foundation
 
 extension SettingsStore {
+    var kimiUsageDataSource: ProviderSourceMode {
+        get { self.configSnapshot.providerConfig(for: .kimi)?.source ?? .auto }
+        set {
+            let source: ProviderSourceMode? = switch newValue {
+            case .auto: .auto
+            case .api: .api
+            case .web: .web
+            case .cli, .oauth: .auto
+            }
+            self.updateProviderConfig(provider: .kimi) { entry in
+                entry.source = source
+            }
+            self.logProviderModeChange(provider: .kimi, field: "usageSource", value: newValue.rawValue)
+        }
+    }
+
+    var kimiAPIKey: String {
+        get { self.configSnapshot.providerConfig(for: .kimi)?.sanitizedAPIKey ?? "" }
+        set {
+            self.updateProviderConfig(provider: .kimi) { entry in
+                entry.apiKey = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .kimi, field: "apiKey", value: newValue)
+        }
+    }
+
     var kimiManualCookieHeader: String {
         get { self.configSnapshot.providerConfig(for: .kimi)?.sanitizedCookieHeader ?? "" }
         set {
@@ -27,10 +53,11 @@ extension SettingsStore {
 
 extension SettingsStore {
     func kimiSettingsSnapshot(tokenOverride: TokenAccountOverride?) -> ProviderSettingsSnapshot.KimiProviderSettings {
-        _ = tokenOverride
         self.ensureKimiAuthTokenLoaded()
-        return ProviderSettingsSnapshot.KimiProviderSettings(
-            cookieSource: self.kimiCookieSource,
-            manualCookieHeader: self.kimiManualCookieHeader)
+        return self.resolvedCookieSettings(
+            provider: .kimi,
+            configuredSource: self.kimiCookieSource,
+            configuredHeader: self.kimiManualCookieHeader,
+            tokenOverride: tokenOverride)
     }
 }
diff --git a/Sources/CodexBar/Providers/KimiK2/KimiK2ProviderImplementation.swift b/Sources/CodexBar/Providers/KimiK2/KimiK2ProviderImplementation.swift
index 9209bba71c..c6314c4f74 100644
--- a/Sources/CodexBar/Providers/KimiK2/KimiK2ProviderImplementation.swift
+++ b/Sources/CodexBar/Providers/KimiK2/KimiK2ProviderImplementation.swift
@@ -1,9 +1,7 @@
 import AppKit
 import CodexBarCore
-import CodexBarMacroSupport
 import Foundation
 
-@ProviderImplementationRegistration
 struct KimiK2ProviderImplementation: ProviderImplementation {
     let id: UsageProvider = .kimik2
 
@@ -18,18 +16,18 @@ struct KimiK2ProviderImplementation: ProviderImplementation {
             ProviderSettingsFieldDescriptor(
                 id: "kimi-k2-api-token",
                 title: "API key",
-                subtitle: "Stored in ~/.codexbar/config.json. Generate one at kimi-k2.ai.",
+                subtitle: "Stored in ~/.codexbar/config.json. For the official Kimi API, use Moonshot / Kimi API.",
                 kind: .secure,
                 placeholder: "Paste API key…",
                 binding: context.stringBinding(\.kimiK2APIToken),
                 actions: [
                     ProviderSettingsActionDescriptor(
                         id: "kimi-k2-open-api-keys",
-                        title: "Open API Keys",
+                        title: "Open legacy provider docs",
                         style: .link,
                         isVisible: nil,
                         perform: {
-                            if let url = URL(string: "https://kimi-k2.ai/user-center/api-keys") {
+                            if let url = URL(string: "https://github.com/steipete/CodexBar/blob/main/docs/kimi-k2.md") {
                                 NSWorkspace.shared.open(url)
                             }
                         }),
diff --git a/Sources/CodexBar/Providers/Kiro/KiroProviderImplementation.swift b/Sources/CodexBar/Providers/Kiro/KiroProviderImplementation.swift
index e54bc4290e..e4abb5a11d 100644
--- a/Sources/CodexBar/Providers/Kiro/KiroProviderImplementation.swift
+++ b/Sources/CodexBar/Providers/Kiro/KiroProviderImplementation.swift
@@ -1,8 +1,27 @@
 import CodexBarCore
-import CodexBarMacroSupport
 import Foundation
+import SwiftUI
 
-@ProviderImplementationRegistration
 struct KiroProviderImplementation: ProviderImplementation {
     let id: UsageProvider = .kiro
+
+    func settingsPickers(context: ProviderSettingsContext) -> [ProviderSettingsPickerDescriptor] {
+        [
+            ProviderSettingsPickerDescriptor(
+                id: "kiroMenuBarDisplay",
+                title: "Kiro menu bar value",
+                subtitle: "Show or hide Kiro credits, percent, or both next to the menu bar icon.",
+                binding: Binding(
+                    get: { context.settings.kiroMenuBarDisplayMode.rawValue },
+                    set: { rawValue in
+                        guard let mode = KiroMenuBarDisplayMode(rawValue: rawValue) else { return }
+                        context.settings.kiroMenuBarDisplayMode = mode
+                    }),
+                options: KiroMenuBarDisplayMode.allCases.map {
+                    ProviderSettingsPickerOption(id: $0.rawValue, title: $0.label)
+                },
+                isVisible: { true },
+                onChange: nil),
+        ]
+    }
 }
diff --git a/Sources/CodexBar/Providers/LLMProxy/LLMProxyProviderImplementation.swift b/Sources/CodexBar/Providers/LLMProxy/LLMProxyProviderImplementation.swift
new file mode 100644
index 0000000000..47d475f0b0
--- /dev/null
+++ b/Sources/CodexBar/Providers/LLMProxy/LLMProxyProviderImplementation.swift
@@ -0,0 +1,49 @@
+import CodexBarCore
+import Foundation
+
+struct LLMProxyProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .llmproxy
+
+    @MainActor
+    func presentation(context _: ProviderPresentationContext) -> ProviderPresentation {
+        ProviderPresentation { _ in "api" }
+    }
+
+    @MainActor
+    func observeSettings(_ settings: SettingsStore) {
+        _ = settings.llmProxyAPIKey
+        _ = settings.llmProxyBaseURL
+    }
+
+    @MainActor
+    func isAvailable(context: ProviderAvailabilityContext) -> Bool {
+        ProviderTokenResolver.llmProxyToken(environment: context.environment) != nil &&
+            LLMProxySettingsReader.baseURL(environment: context.environment) != nil
+    }
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "llmproxy-api-key",
+                title: "API key",
+                subtitle: "Stored in ~/.codexbar/config.json. Used for /v1/quota-stats.",
+                kind: .secure,
+                placeholder: "proxy key…",
+                binding: context.stringBinding(\.llmProxyAPIKey),
+                actions: [],
+                isVisible: nil,
+                onActivate: nil),
+            ProviderSettingsFieldDescriptor(
+                id: "llmproxy-base-url",
+                title: "Base URL",
+                subtitle: "Base URL for the LLM-API-Key-Proxy instance.",
+                kind: .plain,
+                placeholder: "https://proxy.example.com",
+                binding: context.stringBinding(\.llmProxyBaseURL),
+                actions: [],
+                isVisible: nil,
+                onActivate: nil),
+        ]
+    }
+}
diff --git a/Sources/CodexBar/Providers/LLMProxy/LLMProxySettingsStore.swift b/Sources/CodexBar/Providers/LLMProxy/LLMProxySettingsStore.swift
new file mode 100644
index 0000000000..96b52e467b
--- /dev/null
+++ b/Sources/CodexBar/Providers/LLMProxy/LLMProxySettingsStore.swift
@@ -0,0 +1,27 @@
+import CodexBarCore
+import Foundation
+
+extension SettingsStore {
+    var llmProxyAPIKey: String {
+        get {
+            self.configSnapshot.providerConfig(for: .llmproxy)?.sanitizedAPIKey ?? ""
+        }
+        set {
+            self.updateProviderConfig(provider: .llmproxy) { entry in
+                entry.apiKey = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .llmproxy, field: "apiKey", value: newValue)
+        }
+    }
+
+    var llmProxyBaseURL: String {
+        get {
+            self.configSnapshot.providerConfig(for: .llmproxy)?.sanitizedEnterpriseHost ?? ""
+        }
+        set {
+            self.updateProviderConfig(provider: .llmproxy) { entry in
+                entry.enterpriseHost = self.normalizedConfigValue(newValue)
+            }
+        }
+    }
+}
diff --git a/Sources/CodexBar/Providers/LiteLLM/LiteLLMProviderImplementation.swift b/Sources/CodexBar/Providers/LiteLLM/LiteLLMProviderImplementation.swift
new file mode 100644
index 0000000000..5cf08a2340
--- /dev/null
+++ b/Sources/CodexBar/Providers/LiteLLM/LiteLLMProviderImplementation.swift
@@ -0,0 +1,49 @@
+import CodexBarCore
+import Foundation
+
+struct LiteLLMProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .litellm
+
+    @MainActor
+    func presentation(context _: ProviderPresentationContext) -> ProviderPresentation {
+        ProviderPresentation { _ in "api" }
+    }
+
+    @MainActor
+    func observeSettings(_ settings: SettingsStore) {
+        _ = settings.liteLLMAPIKey
+        _ = settings.liteLLMBaseURL
+    }
+
+    @MainActor
+    func isAvailable(context: ProviderAvailabilityContext) -> Bool {
+        ProviderTokenResolver.liteLLMToken(environment: context.environment) != nil &&
+            LiteLLMSettingsReader.baseURL(environment: context.environment) != nil
+    }
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "litellm-api-key",
+                title: "API key",
+                subtitle: "LiteLLM virtual key used to read its own spend and budget.",
+                kind: .secure,
+                placeholder: "sk-…",
+                binding: context.stringBinding(\.liteLLMAPIKey),
+                actions: [],
+                isVisible: nil,
+                onActivate: nil),
+            ProviderSettingsFieldDescriptor(
+                id: "litellm-base-url",
+                title: "Base URL",
+                subtitle: "LiteLLM proxy base URL. /v1 suffixes are accepted and stripped for management endpoints.",
+                kind: .plain,
+                placeholder: "https://litellm.example.com",
+                binding: context.stringBinding(\.liteLLMBaseURL),
+                actions: [],
+                isVisible: nil,
+                onActivate: nil),
+        ]
+    }
+}
diff --git a/Sources/CodexBar/Providers/LiteLLM/LiteLLMSettingsStore.swift b/Sources/CodexBar/Providers/LiteLLM/LiteLLMSettingsStore.swift
new file mode 100644
index 0000000000..2f0c28a79a
--- /dev/null
+++ b/Sources/CodexBar/Providers/LiteLLM/LiteLLMSettingsStore.swift
@@ -0,0 +1,27 @@
+import CodexBarCore
+import Foundation
+
+extension SettingsStore {
+    var liteLLMAPIKey: String {
+        get {
+            self.configSnapshot.providerConfig(for: .litellm)?.sanitizedAPIKey ?? ""
+        }
+        set {
+            self.updateProviderConfig(provider: .litellm) { entry in
+                entry.apiKey = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .litellm, field: "apiKey", value: newValue)
+        }
+    }
+
+    var liteLLMBaseURL: String {
+        get {
+            self.configSnapshot.providerConfig(for: .litellm)?.sanitizedEnterpriseHost ?? ""
+        }
+        set {
+            self.updateProviderConfig(provider: .litellm) { entry in
+                entry.enterpriseHost = self.normalizedConfigValue(newValue)
+            }
+        }
+    }
+}
diff --git a/Sources/CodexBar/Providers/Manus/ManusProviderImplementation.swift b/Sources/CodexBar/Providers/Manus/ManusProviderImplementation.swift
new file mode 100644
index 0000000000..7578b78cb6
--- /dev/null
+++ b/Sources/CodexBar/Providers/Manus/ManusProviderImplementation.swift
@@ -0,0 +1,107 @@
+import AppKit
+import CodexBarCore
+import Foundation
+import SwiftUI
+
+struct ManusProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .manus
+    let supportsLoginFlow: Bool = true
+
+    @MainActor
+    func presentation(context _: ProviderPresentationContext) -> ProviderPresentation {
+        ProviderPresentation { _ in "web" }
+    }
+
+    @MainActor
+    func runLoginFlow(context _: ProviderLoginContext) async -> Bool {
+        if let url = URL(string: "https://manus.im") {
+            NSWorkspace.shared.open(url)
+        }
+        return false
+    }
+
+    @MainActor
+    func observeSettings(_ settings: SettingsStore) {
+        _ = settings.manusCookieSource
+        _ = settings.manusManualCookieHeader
+    }
+
+    @MainActor
+    func settingsSnapshot(context: ProviderSettingsSnapshotContext) -> ProviderSettingsSnapshotContribution? {
+        .manus(context.settings.manusSettingsSnapshot(tokenOverride: context.tokenOverride))
+    }
+
+    @MainActor
+    func tokenAccountsVisibility(context: ProviderSettingsContext, support: TokenAccountSupport) -> Bool {
+        guard support.requiresManualCookieSource else { return true }
+        if !context.settings.tokenAccounts(for: context.provider).isEmpty { return true }
+        return context.settings.manusCookieSource == .manual
+    }
+
+    @MainActor
+    func applyTokenAccountCookieSource(settings: SettingsStore) {
+        if settings.manusCookieSource != .manual {
+            settings.manusCookieSource = .manual
+        }
+    }
+
+    @MainActor
+    func settingsPickers(context: ProviderSettingsContext) -> [ProviderSettingsPickerDescriptor] {
+        let cookieBinding = Binding(
+            get: { context.settings.manusCookieSource.rawValue },
+            set: { raw in
+                context.settings.manusCookieSource = ProviderCookieSource(rawValue: raw) ?? .auto
+            })
+        let options = ProviderCookieSourceUI.options(
+            allowsOff: true,
+            keychainDisabled: context.settings.debugDisableKeychainAccess)
+
+        let subtitle: () -> String? = {
+            ProviderCookieSourceUI.subtitle(
+                source: context.settings.manusCookieSource,
+                keychainDisabled: context.settings.debugDisableKeychainAccess,
+                auto: "Automatically imports browser session cookies.",
+                manual: "Paste the session_id value or a full Cookie header.",
+                off: "Manus cookies are disabled.")
+        }
+
+        return [
+            ProviderSettingsPickerDescriptor(
+                id: "manus-cookie-source",
+                title: "Cookie source",
+                subtitle: "Automatically imports browser session cookies.",
+                dynamicSubtitle: subtitle,
+                binding: cookieBinding,
+                options: options,
+                isVisible: nil,
+                onChange: nil),
+        ]
+    }
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "manus-cookie",
+                title: "",
+                subtitle: "",
+                kind: .secure,
+                placeholder: "session_id=...\n\nor paste just the session_id value",
+                binding: context.stringBinding(\.manusManualCookieHeader),
+                actions: [
+                    ProviderSettingsActionDescriptor(
+                        id: "manus-open-dashboard",
+                        title: "Open Manus",
+                        style: .link,
+                        isVisible: nil,
+                        perform: {
+                            if let url = URL(string: "https://manus.im") {
+                                NSWorkspace.shared.open(url)
+                            }
+                        }),
+                ],
+                isVisible: { context.settings.manusCookieSource == .manual },
+                onActivate: nil),
+        ]
+    }
+}
diff --git a/Sources/CodexBar/Providers/Manus/ManusSettingsStore.swift b/Sources/CodexBar/Providers/Manus/ManusSettingsStore.swift
new file mode 100644
index 0000000000..4a11d3d46e
--- /dev/null
+++ b/Sources/CodexBar/Providers/Manus/ManusSettingsStore.swift
@@ -0,0 +1,34 @@
+import CodexBarCore
+import Foundation
+
+extension SettingsStore {
+    var manusManualCookieHeader: String {
+        get { self.configSnapshot.providerConfig(for: .manus)?.sanitizedCookieHeader ?? "" }
+        set {
+            self.updateProviderConfig(provider: .manus) { entry in
+                entry.cookieHeader = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .manus, field: "cookieHeader", value: newValue)
+        }
+    }
+
+    var manusCookieSource: ProviderCookieSource {
+        get { self.resolvedCookieSource(provider: .manus, fallback: .auto) }
+        set {
+            self.updateProviderConfig(provider: .manus) { entry in
+                entry.cookieSource = newValue
+            }
+            self.logProviderModeChange(provider: .manus, field: "cookieSource", value: newValue.rawValue)
+        }
+    }
+}
+
+extension SettingsStore {
+    func manusSettingsSnapshot(tokenOverride: TokenAccountOverride?) -> ProviderSettingsSnapshot.ManusProviderSettings {
+        self.resolvedCookieSettings(
+            provider: .manus,
+            configuredSource: self.manusCookieSource,
+            configuredHeader: self.manusManualCookieHeader,
+            tokenOverride: tokenOverride)
+    }
+}
diff --git a/Sources/CodexBar/Providers/MiMo/MiMoProviderImplementation.swift b/Sources/CodexBar/Providers/MiMo/MiMoProviderImplementation.swift
new file mode 100644
index 0000000000..ef5f91532c
--- /dev/null
+++ b/Sources/CodexBar/Providers/MiMo/MiMoProviderImplementation.swift
@@ -0,0 +1,100 @@
+import AppKit
+import CodexBarCore
+import Foundation
+import SwiftUI
+
+struct MiMoProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .mimo
+    let supportsLoginFlow: Bool = true
+
+    @MainActor
+    func presentation(context _: ProviderPresentationContext) -> ProviderPresentation {
+        ProviderPresentation { _ in "web" }
+    }
+
+    @MainActor
+    func observeSettings(_ settings: SettingsStore) {
+        _ = settings.miMoCookieSource
+        _ = settings.miMoCookieHeader
+    }
+
+    @MainActor
+    func settingsSnapshot(context: ProviderSettingsSnapshotContext) -> ProviderSettingsSnapshotContribution? {
+        .mimo(context.settings.miMoSettingsSnapshot(tokenOverride: context.tokenOverride))
+    }
+
+    @MainActor
+    func settingsPickers(context: ProviderSettingsContext) -> [ProviderSettingsPickerDescriptor] {
+        let cookieBinding = Binding(
+            get: { context.settings.miMoCookieSource.rawValue },
+            set: { raw in
+                context.settings.miMoCookieSource = ProviderCookieSource(rawValue: raw) ?? .auto
+            })
+        let cookieOptions = ProviderCookieSourceUI.options(
+            allowsOff: false,
+            keychainDisabled: context.settings.debugDisableKeychainAccess)
+        let cookieSubtitle: () -> String? = {
+            ProviderCookieSourceUI.subtitle(
+                source: context.settings.miMoCookieSource,
+                keychainDisabled: context.settings.debugDisableKeychainAccess,
+                auto: "Automatic imports browser cookies from Xiaomi MiMo.",
+                manual: "Paste a Cookie header from platform.xiaomimimo.com.",
+                off: "Xiaomi MiMo cookies are disabled.")
+        }
+
+        return [
+            ProviderSettingsPickerDescriptor(
+                id: "mimo-cookie-source",
+                title: "Cookie source",
+                subtitle: "Automatic imports browser cookies from Xiaomi MiMo.",
+                dynamicSubtitle: cookieSubtitle,
+                binding: cookieBinding,
+                options: cookieOptions,
+                isVisible: nil,
+                onChange: nil,
+                trailingText: {
+                    guard let entry = CookieHeaderCache.loadForDisplay(provider: .mimo) else { return nil }
+                    let when = entry.storedAt.relativeDescription()
+                    return "Cached: \(entry.sourceLabel) • \(when)"
+                }),
+        ]
+    }
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "mimo-cookie",
+                title: "",
+                subtitle: "",
+                kind: .secure,
+                placeholder: "Cookie: ...",
+                binding: context.stringBinding(\.miMoCookieHeader),
+                actions: [
+                    ProviderSettingsActionDescriptor(
+                        id: "mimo-open-balance",
+                        title: "Open MiMo Balance",
+                        style: .link,
+                        isVisible: nil,
+                        perform: {
+                            guard let url = URL(string: "https://platform.xiaomimimo.com/#/console/balance") else {
+                                return
+                            }
+                            NSWorkspace.shared.open(url)
+                        }),
+                ],
+                isVisible: { context.settings.miMoCookieSource == .manual },
+                onActivate: { context.settings.ensureMiMoCookieLoaded() }),
+        ]
+    }
+
+    @MainActor
+    func runLoginFlow(context _: ProviderLoginContext) async -> Bool {
+        let loginURL = "https://platform.xiaomimimo.com/api/v1/genLoginUrl?currentPath=%2F%23%2Fconsole%2Fbalance"
+        guard let url = URL(string: loginURL) else {
+            return false
+        }
+        NSWorkspace.shared.open(url)
+        return false
+    }
+}
diff --git a/Sources/CodexBar/Providers/MiMo/MiMoSettingsStore.swift b/Sources/CodexBar/Providers/MiMo/MiMoSettingsStore.swift
new file mode 100644
index 0000000000..0bbda51759
--- /dev/null
+++ b/Sources/CodexBar/Providers/MiMo/MiMoSettingsStore.swift
@@ -0,0 +1,36 @@
+import CodexBarCore
+import Foundation
+
+extension SettingsStore {
+    var miMoCookieHeader: String {
+        get { self.configSnapshot.providerConfig(for: .mimo)?.sanitizedCookieHeader ?? "" }
+        set {
+            self.updateProviderConfig(provider: .mimo) { entry in
+                entry.cookieHeader = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .mimo, field: "cookieHeader", value: newValue)
+        }
+    }
+
+    var miMoCookieSource: ProviderCookieSource {
+        get { self.resolvedCookieSource(provider: .mimo, fallback: .auto) }
+        set {
+            self.updateProviderConfig(provider: .mimo) { entry in
+                entry.cookieSource = newValue
+            }
+            self.logProviderModeChange(provider: .mimo, field: "cookieSource", value: newValue.rawValue)
+        }
+    }
+
+    func ensureMiMoCookieLoaded() {}
+}
+
+extension SettingsStore {
+    func miMoSettingsSnapshot(tokenOverride: TokenAccountOverride?) -> ProviderSettingsSnapshot.MiMoProviderSettings {
+        self.resolvedCookieSettings(
+            provider: .mimo,
+            configuredSource: self.miMoCookieSource,
+            configuredHeader: self.miMoCookieHeader,
+            tokenOverride: tokenOverride)
+    }
+}
diff --git a/Sources/CodexBar/Providers/MiniMax/MiniMaxProviderImplementation.swift b/Sources/CodexBar/Providers/MiniMax/MiniMaxProviderImplementation.swift
index 6b7432edcf..46795f00d5 100644
--- a/Sources/CodexBar/Providers/MiniMax/MiniMaxProviderImplementation.swift
+++ b/Sources/CodexBar/Providers/MiniMax/MiniMaxProviderImplementation.swift
@@ -1,10 +1,8 @@
 import AppKit
 import CodexBarCore
-import CodexBarMacroSupport
 import Foundation
 import SwiftUI
 
-@ProviderImplementationRegistration
 struct MiniMaxProviderImplementation: ProviderImplementation {
     let id: UsageProvider = .minimax
 
@@ -65,7 +63,7 @@ struct MiniMaxProviderImplementation: ProviderImplementation {
                 source: context.settings.minimaxCookieSource,
                 keychainDisabled: context.settings.debugDisableKeychainAccess,
                 auto: "Automatic imports browser cookies and local storage tokens.",
-                manual: "Paste a Cookie header or cURL capture from the Coding Plan page.",
+                manual: "Paste a Cookie header or cURL capture from the Token Plan page.",
                 off: "MiniMax cookies are disabled.")
         }
 
@@ -89,7 +87,7 @@ struct MiniMaxProviderImplementation: ProviderImplementation {
                 isVisible: { authMode().allowsCookies },
                 onChange: nil,
                 trailingText: {
-                    guard let entry = CookieHeaderCache.load(provider: .minimax) else { return nil }
+                    guard let entry = CookieHeaderCache.loadForDisplay(provider: .minimax) else { return nil }
                     let when = entry.storedAt.relativeDescription()
                     return "Cached: \(entry.sourceLabel) • \(when)"
                 }),
@@ -122,7 +120,7 @@ struct MiniMaxProviderImplementation: ProviderImplementation {
                 actions: [
                     ProviderSettingsActionDescriptor(
                         id: "minimax-open-dashboard",
-                        title: "Open Coding Plan",
+                        title: "Open Token Plan",
                         style: .link,
                         isVisible: nil,
                         perform: {
@@ -141,7 +139,7 @@ struct MiniMaxProviderImplementation: ProviderImplementation {
                 actions: [
                     ProviderSettingsActionDescriptor(
                         id: "minimax-open-dashboard-cookie",
-                        title: "Open Coding Plan",
+                        title: "Open Token Plan",
                         style: .link,
                         isVisible: nil,
                         perform: {
diff --git a/Sources/CodexBar/Providers/MiniMax/MiniMaxSettingsStore.swift b/Sources/CodexBar/Providers/MiniMax/MiniMaxSettingsStore.swift
index e10b621a5a..75fd496307 100644
--- a/Sources/CodexBar/Providers/MiniMax/MiniMaxSettingsStore.swift
+++ b/Sources/CodexBar/Providers/MiniMax/MiniMaxSettingsStore.swift
@@ -60,37 +60,14 @@ extension SettingsStore {
 extension SettingsStore {
     func minimaxSettingsSnapshot(tokenOverride: TokenAccountOverride?) -> ProviderSettingsSnapshot
     .MiniMaxProviderSettings {
-        ProviderSettingsSnapshot.MiniMaxProviderSettings(
-            cookieSource: self.minimaxSnapshotCookieSource(tokenOverride: tokenOverride),
-            manualCookieHeader: self.minimaxSnapshotCookieHeader(tokenOverride: tokenOverride),
-            apiRegion: self.minimaxAPIRegion)
-    }
-
-    private func minimaxSnapshotCookieHeader(tokenOverride: TokenAccountOverride?) -> String {
-        let fallback = self.minimaxCookieHeader
-        guard let support = TokenAccountSupportCatalog.support(for: .minimax),
-              case .cookieHeader = support.injection
-        else {
-            return fallback
-        }
-        guard let account = ProviderTokenAccountSelection.selectedAccount(
+        let cookieSettings: ProviderSettingsSnapshot.CookieProviderSettings = self.resolvedCookieSettings(
             provider: .minimax,
-            settings: self,
-            override: tokenOverride)
-        else {
-            return fallback
-        }
-        return TokenAccountSupportCatalog.normalizedCookieHeader(account.token, support: support)
-    }
-
-    private func minimaxSnapshotCookieSource(tokenOverride: TokenAccountOverride?) -> ProviderCookieSource {
-        let fallback = self.minimaxCookieSource
-        guard let support = TokenAccountSupportCatalog.support(for: .minimax),
-              support.requiresManualCookieSource
-        else {
-            return fallback
-        }
-        if self.tokenAccounts(for: .minimax).isEmpty { return fallback }
-        return .manual
+            configuredSource: self.minimaxCookieSource,
+            configuredHeader: self.minimaxCookieHeader,
+            tokenOverride: tokenOverride)
+        return ProviderSettingsSnapshot.MiniMaxProviderSettings(
+            cookieSource: cookieSettings.cookieSource,
+            manualCookieHeader: cookieSettings.manualCookieHeader,
+            apiRegion: self.minimaxAPIRegion)
     }
 }
diff --git a/Sources/CodexBar/Providers/Mistral/MistralProviderImplementation.swift b/Sources/CodexBar/Providers/Mistral/MistralProviderImplementation.swift
new file mode 100644
index 0000000000..0620425272
--- /dev/null
+++ b/Sources/CodexBar/Providers/Mistral/MistralProviderImplementation.swift
@@ -0,0 +1,104 @@
+import AppKit
+import CodexBarCore
+import Foundation
+import SwiftUI
+
+struct MistralProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .mistral
+
+    @MainActor
+    func presentation(context _: ProviderPresentationContext) -> ProviderPresentation {
+        ProviderPresentation { _ in "web" }
+    }
+
+    @MainActor
+    func observeSettings(_ settings: SettingsStore) {
+        _ = settings.mistralCookieSource
+        _ = settings.mistralCookieHeader
+    }
+
+    @MainActor
+    func settingsSnapshot(context: ProviderSettingsSnapshotContext) -> ProviderSettingsSnapshotContribution? {
+        .mistral(context.settings.mistralSettingsSnapshot(tokenOverride: context.tokenOverride))
+    }
+
+    @MainActor
+    func tokenAccountsVisibility(context: ProviderSettingsContext, support: TokenAccountSupport) -> Bool {
+        guard support.requiresManualCookieSource else { return true }
+        if !context.settings.tokenAccounts(for: context.provider).isEmpty { return true }
+        return context.settings.mistralCookieSource == .manual
+    }
+
+    @MainActor
+    func applyTokenAccountCookieSource(settings: SettingsStore) {
+        if settings.mistralCookieSource != .manual {
+            settings.mistralCookieSource = .manual
+        }
+    }
+
+    @MainActor
+    func settingsPickers(context: ProviderSettingsContext) -> [ProviderSettingsPickerDescriptor] {
+        let cookieBinding = Binding(
+            get: { context.settings.mistralCookieSource.rawValue },
+            set: { raw in
+                context.settings.mistralCookieSource = ProviderCookieSource(rawValue: raw) ?? .auto
+            })
+        let cookieOptions = ProviderCookieSourceUI.options(
+            allowsOff: false,
+            keychainDisabled: context.settings.debugDisableKeychainAccess)
+
+        let cookieSubtitle: () -> String? = {
+            ProviderCookieSourceUI.subtitle(
+                source: context.settings.mistralCookieSource,
+                keychainDisabled: context.settings.debugDisableKeychainAccess,
+                auto: "Automatic imports browser cookies from admin.mistral.ai.",
+                manual: "Paste a Cookie header captured from the billing page.",
+                off: "Mistral cookies are disabled.")
+        }
+
+        return [
+            ProviderSettingsPickerDescriptor(
+                id: "mistral-cookie-source",
+                title: "Cookie source",
+                subtitle: "Automatic imports browser cookies from admin.mistral.ai.",
+                dynamicSubtitle: cookieSubtitle,
+                binding: cookieBinding,
+                options: cookieOptions,
+                isVisible: nil,
+                onChange: nil,
+                trailingText: {
+                    guard let entry = CookieHeaderCache.loadForDisplay(provider: .mistral) else { return nil }
+                    let when = entry.storedAt.relativeDescription()
+                    return "Cached: \(entry.sourceLabel) • \(when)"
+                }),
+        ]
+    }
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "mistral-cookie-header",
+                title: "Cookie header",
+                subtitle: "Paste the Cookie header from a request to admin.mistral.ai. "
+                    + "Must contain an ory_session_* cookie.",
+                kind: .secure,
+                placeholder: "ory_session_…=…; csrftoken=…",
+                binding: context.stringBinding(\.mistralCookieHeader),
+                actions: [
+                    ProviderSettingsActionDescriptor(
+                        id: "mistral-open-console",
+                        title: "Open Mistral Admin",
+                        style: .link,
+                        isVisible: nil,
+                        perform: {
+                            if let url = URL(string: "https://admin.mistral.ai/organization/usage") {
+                                NSWorkspace.shared.open(url)
+                            }
+                        }),
+                ],
+                isVisible: { context.settings.mistralCookieSource == .manual },
+                onActivate: nil),
+        ]
+    }
+}
diff --git a/Sources/CodexBar/Providers/Mistral/MistralSettingsStore.swift b/Sources/CodexBar/Providers/Mistral/MistralSettingsStore.swift
new file mode 100644
index 0000000000..3332ef46b9
--- /dev/null
+++ b/Sources/CodexBar/Providers/Mistral/MistralSettingsStore.swift
@@ -0,0 +1,38 @@
+import CodexBarCore
+import Foundation
+
+extension SettingsStore {
+    var mistralCookieHeader: String {
+        get { self.configSnapshot.providerConfig(for: .mistral)?.sanitizedCookieHeader ?? "" }
+        set {
+            self.updateProviderConfig(provider: .mistral) { entry in
+                entry.cookieHeader = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .mistral, field: "cookieHeader", value: newValue)
+        }
+    }
+
+    var mistralCookieSource: ProviderCookieSource {
+        get { self.resolvedCookieSource(provider: .mistral, fallback: .auto) }
+        set {
+            self.updateProviderConfig(provider: .mistral) { entry in
+                entry.cookieSource = newValue
+            }
+            self.logProviderModeChange(provider: .mistral, field: "cookieSource", value: newValue.rawValue)
+        }
+    }
+
+    func ensureMistralCookieLoaded() {}
+}
+
+extension SettingsStore {
+    func mistralSettingsSnapshot(tokenOverride: TokenAccountOverride?) -> ProviderSettingsSnapshot
+        .MistralProviderSettings
+    {
+        self.resolvedCookieSettings(
+            provider: .mistral,
+            configuredSource: self.mistralCookieSource,
+            configuredHeader: self.mistralCookieHeader,
+            tokenOverride: tokenOverride)
+    }
+}
diff --git a/Sources/CodexBar/Providers/Moonshot/MoonshotProviderImplementation.swift b/Sources/CodexBar/Providers/Moonshot/MoonshotProviderImplementation.swift
new file mode 100644
index 0000000000..c96088fd24
--- /dev/null
+++ b/Sources/CodexBar/Providers/Moonshot/MoonshotProviderImplementation.swift
@@ -0,0 +1,86 @@
+import AppKit
+import CodexBarCore
+import Foundation
+import SwiftUI
+
+struct MoonshotProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .moonshot
+
+    @MainActor
+    func presentation(context _: ProviderPresentationContext) -> ProviderPresentation {
+        ProviderPresentation { _ in "api" }
+    }
+
+    @MainActor
+    func observeSettings(_ settings: SettingsStore) {
+        _ = settings.moonshotAPIToken
+        _ = settings.moonshotRegion
+    }
+
+    @MainActor
+    func settingsSnapshot(context: ProviderSettingsSnapshotContext)
+        -> ProviderSettingsSnapshotContribution?
+    {
+        .moonshot(context.settings.moonshotSettingsSnapshot())
+    }
+
+    @MainActor
+    func isAvailable(context: ProviderAvailabilityContext) -> Bool {
+        if MoonshotSettingsReader.apiKey(environment: context.environment) != nil {
+            return true
+        }
+        context.settings.ensureMoonshotAPITokenLoaded()
+        return !context.settings.moonshotAPIToken.trimmingCharacters(in: .whitespacesAndNewlines)
+            .isEmpty
+    }
+
+    @MainActor
+    func settingsPickers(context: ProviderSettingsContext) -> [ProviderSettingsPickerDescriptor] {
+        let binding = Binding(
+            get: { context.settings.moonshotRegion.rawValue },
+            set: { raw in
+                context.settings.moonshotRegion = MoonshotRegion(rawValue: raw) ?? .international
+            })
+        let options = MoonshotRegion.allCases.map {
+            ProviderSettingsPickerOption(id: $0.rawValue, title: $0.displayName)
+        }
+
+        return [
+            ProviderSettingsPickerDescriptor(
+                id: "moonshot-api-region",
+                title: "API region",
+                subtitle: "Choose the Moonshot/Kimi API host for international or China mainland accounts.",
+                binding: binding,
+                options: options,
+                isVisible: nil,
+                onChange: nil),
+        ]
+    }
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "moonshot-api-key",
+                title: "API key",
+                subtitle: "Stored in ~/.codexbar/config.json.",
+                kind: .secure,
+                placeholder: "sk-...",
+                binding: context.stringBinding(\.moonshotAPIToken),
+                actions: [
+                    ProviderSettingsActionDescriptor(
+                        id: "moonshot-open-dashboard",
+                        title: "Open Moonshot Console",
+                        style: .link,
+                        isVisible: nil,
+                        perform: {
+                            if let url = URL(string: "https://platform.moonshot.ai/console/account") {
+                                NSWorkspace.shared.open(url)
+                            }
+                        }),
+                ],
+                isVisible: nil,
+                onActivate: { context.settings.ensureMoonshotAPITokenLoaded() }),
+        ]
+    }
+}
diff --git a/Sources/CodexBar/Providers/Moonshot/MoonshotSettingsStore.swift b/Sources/CodexBar/Providers/Moonshot/MoonshotSettingsStore.swift
new file mode 100644
index 0000000000..beb808af3a
--- /dev/null
+++ b/Sources/CodexBar/Providers/Moonshot/MoonshotSettingsStore.swift
@@ -0,0 +1,44 @@
+import CodexBarCore
+import Foundation
+
+extension SettingsStore {
+    var moonshotAPIToken: String {
+        get { self.configSnapshot.providerConfig(for: .moonshot)?.sanitizedAPIKey ?? "" }
+        set {
+            self.updateProviderConfig(provider: .moonshot) { entry in
+                entry.apiKey = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .moonshot, field: "apiKey", value: newValue)
+        }
+    }
+
+    var moonshotRegion: MoonshotRegion {
+        get {
+            let raw = self.configSnapshot.providerConfig(for: .moonshot)?.region
+            return MoonshotRegion(rawValue: raw ?? "") ?? .international
+        }
+        set {
+            self.updateProviderConfig(provider: .moonshot) { entry in
+                entry.region = newValue.rawValue
+            }
+        }
+    }
+
+    func ensureMoonshotAPITokenLoaded() {}
+
+    var configuredMoonshotRegion: MoonshotRegion? {
+        guard let raw = self.configSnapshot.providerConfig(for: .moonshot)?.region?
+            .trimmingCharacters(in: .whitespacesAndNewlines),
+            !raw.isEmpty
+        else {
+            return nil
+        }
+        return MoonshotRegion(rawValue: raw)
+    }
+}
+
+extension SettingsStore {
+    func moonshotSettingsSnapshot() -> ProviderSettingsSnapshot.MoonshotProviderSettings {
+        ProviderSettingsSnapshot.MoonshotProviderSettings(region: self.configuredMoonshotRegion)
+    }
+}
diff --git a/Sources/CodexBar/Providers/Ollama/OllamaProviderImplementation.swift b/Sources/CodexBar/Providers/Ollama/OllamaProviderImplementation.swift
index 99d8582f10..565f167498 100644
--- a/Sources/CodexBar/Providers/Ollama/OllamaProviderImplementation.swift
+++ b/Sources/CodexBar/Providers/Ollama/OllamaProviderImplementation.swift
@@ -1,19 +1,36 @@
 import AppKit
 import CodexBarCore
-import CodexBarMacroSupport
 import Foundation
 import SwiftUI
 
-@ProviderImplementationRegistration
 struct OllamaProviderImplementation: ProviderImplementation {
     let id: UsageProvider = .ollama
 
     @MainActor
     func observeSettings(_ settings: SettingsStore) {
+        _ = settings.ollamaUsageDataSource
+        _ = settings.ollamaAPIToken
         _ = settings.ollamaCookieSource
         _ = settings.ollamaCookieHeader
     }
 
+    @MainActor
+    func sourceMode(context: ProviderSourceModeContext) -> ProviderSourceMode {
+        context.settings.ollamaUsageDataSource
+    }
+
+    @MainActor
+    func isAvailable(context: ProviderAvailabilityContext) -> Bool {
+        if OllamaAPISettingsReader.apiKey(environment: context.environment) != nil {
+            return true
+        }
+        context.settings.ensureOllamaAPITokenLoaded()
+        if !context.settings.ollamaAPIToken.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
+            return true
+        }
+        return context.settings.ollamaCookieSource != .off
+    }
+
     @MainActor
     func settingsSnapshot(context: ProviderSettingsSnapshotContext) -> ProviderSettingsSnapshotContribution? {
         .ollama(context.settings.ollamaSettingsSnapshot(tokenOverride: context.tokenOverride))
@@ -35,6 +52,16 @@ struct OllamaProviderImplementation: ProviderImplementation {
 
     @MainActor
     func settingsPickers(context: ProviderSettingsContext) -> [ProviderSettingsPickerDescriptor] {
+        let sourceBinding = Binding(
+            get: { context.settings.ollamaUsageDataSource.rawValue },
+            set: { raw in
+                context.settings.ollamaUsageDataSource = ProviderSourceMode(rawValue: raw) ?? .auto
+            })
+        let sourceOptions: [ProviderSettingsPickerOption] = [
+            ProviderSettingsPickerOption(id: ProviderSourceMode.auto.rawValue, title: "Auto"),
+            ProviderSettingsPickerOption(id: ProviderSourceMode.web.rawValue, title: "Browser cookies"),
+            ProviderSettingsPickerOption(id: ProviderSourceMode.api.rawValue, title: "API key"),
+        ]
         let cookieBinding = Binding(
             get: { context.settings.ollamaCookieSource.rawValue },
             set: { raw in
@@ -54,6 +81,14 @@ struct OllamaProviderImplementation: ProviderImplementation {
         }
 
         return [
+            ProviderSettingsPickerDescriptor(
+                id: "ollama-usage-source",
+                title: "Usage source",
+                subtitle: "API key verifies Ollama Cloud access; cookies still expose quota limits.",
+                binding: sourceBinding,
+                options: sourceOptions,
+                isVisible: nil,
+                onChange: nil),
             ProviderSettingsPickerDescriptor(
                 id: "ollama-cookie-source",
                 title: "Cookie source",
@@ -69,6 +104,27 @@ struct OllamaProviderImplementation: ProviderImplementation {
     @MainActor
     func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
         [
+            ProviderSettingsFieldDescriptor(
+                id: "ollama-api-key",
+                title: "API key",
+                subtitle: "Stored in ~/.codexbar/config.json. Get your key from Ollama settings.",
+                kind: .secure,
+                placeholder: "ollama-...",
+                binding: context.stringBinding(\.ollamaAPIToken),
+                actions: [
+                    ProviderSettingsActionDescriptor(
+                        id: "ollama-open-api-keys",
+                        title: "Open Ollama API Keys",
+                        style: .link,
+                        isVisible: nil,
+                        perform: {
+                            if let url = URL(string: "https://ollama.com/settings/keys") {
+                                NSWorkspace.shared.open(url)
+                            }
+                        }),
+                ],
+                isVisible: nil,
+                onActivate: { context.settings.ensureOllamaAPITokenLoaded() }),
             ProviderSettingsFieldDescriptor(
                 id: "ollama-cookie",
                 title: "",
diff --git a/Sources/CodexBar/Providers/Ollama/OllamaSettingsStore.swift b/Sources/CodexBar/Providers/Ollama/OllamaSettingsStore.swift
index 99e0d65040..2c464b9c98 100644
--- a/Sources/CodexBar/Providers/Ollama/OllamaSettingsStore.swift
+++ b/Sources/CodexBar/Providers/Ollama/OllamaSettingsStore.swift
@@ -2,6 +2,29 @@ import CodexBarCore
 import Foundation
 
 extension SettingsStore {
+    var ollamaUsageDataSource: ProviderSourceMode {
+        get {
+            let source = self.configSnapshot.providerConfig(for: .ollama)?.source
+            return source ?? .auto
+        }
+        set {
+            self.updateProviderConfig(provider: .ollama) { entry in
+                entry.source = newValue == .auto ? nil : newValue
+            }
+            self.logProviderModeChange(provider: .ollama, field: "source", value: newValue.rawValue)
+        }
+    }
+
+    var ollamaAPIToken: String {
+        get { self.configSnapshot.providerConfig(for: .ollama)?.sanitizedAPIKey ?? "" }
+        set {
+            self.updateProviderConfig(provider: .ollama) { entry in
+                entry.apiKey = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .ollama, field: "apiKey", value: newValue)
+        }
+    }
+
     var ollamaCookieHeader: String {
         get { self.configSnapshot.providerConfig(for: .ollama)?.sanitizedCookieHeader ?? "" }
         set {
@@ -22,42 +45,18 @@ extension SettingsStore {
         }
     }
 
+    func ensureOllamaAPITokenLoaded() {}
+
     func ensureOllamaCookieLoaded() {}
 }
 
 extension SettingsStore {
     func ollamaSettingsSnapshot(tokenOverride: TokenAccountOverride?) -> ProviderSettingsSnapshot
     .OllamaProviderSettings {
-        ProviderSettingsSnapshot.OllamaProviderSettings(
-            cookieSource: self.ollamaSnapshotCookieSource(tokenOverride: tokenOverride),
-            manualCookieHeader: self.ollamaSnapshotCookieHeader(tokenOverride: tokenOverride))
-    }
-
-    private func ollamaSnapshotCookieHeader(tokenOverride: TokenAccountOverride?) -> String {
-        let fallback = self.ollamaCookieHeader
-        guard let support = TokenAccountSupportCatalog.support(for: .ollama),
-              case .cookieHeader = support.injection
-        else {
-            return fallback
-        }
-        guard let account = ProviderTokenAccountSelection.selectedAccount(
+        self.resolvedCookieSettings(
             provider: .ollama,
-            settings: self,
-            override: tokenOverride)
-        else {
-            return fallback
-        }
-        return TokenAccountSupportCatalog.normalizedCookieHeader(account.token, support: support)
-    }
-
-    private func ollamaSnapshotCookieSource(tokenOverride: TokenAccountOverride?) -> ProviderCookieSource {
-        let fallback = self.ollamaCookieSource
-        guard let support = TokenAccountSupportCatalog.support(for: .ollama),
-              support.requiresManualCookieSource
-        else {
-            return fallback
-        }
-        if self.tokenAccounts(for: .ollama).isEmpty { return fallback }
-        return .manual
+            configuredSource: self.ollamaCookieSource,
+            configuredHeader: self.ollamaCookieHeader,
+            tokenOverride: tokenOverride)
     }
 }
diff --git a/Sources/CodexBar/Providers/OpenAI/OpenAIAPIProviderImplementation.swift b/Sources/CodexBar/Providers/OpenAI/OpenAIAPIProviderImplementation.swift
new file mode 100644
index 0000000000..a5079f4a8f
--- /dev/null
+++ b/Sources/CodexBar/Providers/OpenAI/OpenAIAPIProviderImplementation.swift
@@ -0,0 +1,78 @@
+import AppKit
+import CodexBarCore
+import Foundation
+
+struct OpenAIAPIProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .openai
+
+    @MainActor
+    func presentation(context _: ProviderPresentationContext) -> ProviderPresentation {
+        ProviderPresentation { _ in "api" }
+    }
+
+    @MainActor
+    func observeSettings(_ settings: SettingsStore) {
+        _ = settings.openAIAPIKey
+        _ = settings.openAIAPIProjectID
+    }
+
+    @MainActor
+    func isAvailable(context: ProviderAvailabilityContext) -> Bool {
+        if OpenAIAPISettingsReader.apiKey(environment: context.environment) != nil {
+            return true
+        }
+        return !context.settings.openAIAPIKey.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+    }
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "openai-api-key",
+                title: "Admin API key",
+                subtitle: "Stored in ~/.codexbar/config.json. OPENAI_ADMIN_KEY is preferred; " +
+                    "OPENAI_API_KEY still works.",
+                kind: .secure,
+                placeholder: "sk-admin-...",
+                binding: context.stringBinding(\.openAIAPIKey),
+                actions: [
+                    ProviderSettingsActionDescriptor(
+                        id: "openai-open-billing",
+                        title: "Open billing",
+                        style: .link,
+                        isVisible: nil,
+                        perform: {
+                            if let url = URL(
+                                string: "https://platform.openai.com/settings/organization/billing/overview")
+                            {
+                                NSWorkspace.shared.open(url)
+                            }
+                        }),
+                ],
+                isVisible: nil,
+                onActivate: nil),
+            ProviderSettingsFieldDescriptor(
+                id: "openai-project-id",
+                title: "Project ID",
+                subtitle: "Optional. Applies to the configured Admin API key; selected token accounts do not " +
+                    "inherit OPENAI_PROJECT_ID.",
+                kind: .plain,
+                placeholder: "proj_...",
+                binding: context.stringBinding(\.openAIAPIProjectID),
+                actions: [
+                    ProviderSettingsActionDescriptor(
+                        id: "openai-open-projects",
+                        title: "Open projects",
+                        style: .link,
+                        isVisible: nil,
+                        perform: {
+                            if let url = URL(string: "https://platform.openai.com/settings/organization/projects") {
+                                NSWorkspace.shared.open(url)
+                            }
+                        }),
+                ],
+                isVisible: nil,
+                onActivate: nil),
+        ]
+    }
+}
diff --git a/Sources/CodexBar/Providers/OpenAI/OpenAIAPISettingsStore.swift b/Sources/CodexBar/Providers/OpenAI/OpenAIAPISettingsStore.swift
new file mode 100644
index 0000000000..7dfb7edf68
--- /dev/null
+++ b/Sources/CodexBar/Providers/OpenAI/OpenAIAPISettingsStore.swift
@@ -0,0 +1,24 @@
+import CodexBarCore
+import Foundation
+
+extension SettingsStore {
+    var openAIAPIKey: String {
+        get { self.configSnapshot.providerConfig(for: .openai)?.sanitizedAPIKey ?? "" }
+        set {
+            self.updateProviderConfig(provider: .openai) { entry in
+                entry.apiKey = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .openai, field: "apiKey", value: newValue)
+        }
+    }
+
+    var openAIAPIProjectID: String {
+        get { self.configSnapshot.providerConfig(for: .openai)?.sanitizedWorkspaceID ?? "" }
+        set {
+            self.updateProviderConfig(provider: .openai) { entry in
+                entry.workspaceID = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .openai, field: "projectID", value: newValue)
+        }
+    }
+}
diff --git a/Sources/CodexBar/Providers/OpenCode/OpenCodeProviderImplementation.swift b/Sources/CodexBar/Providers/OpenCode/OpenCodeProviderImplementation.swift
index 5e069f0a14..313513511b 100644
--- a/Sources/CodexBar/Providers/OpenCode/OpenCodeProviderImplementation.swift
+++ b/Sources/CodexBar/Providers/OpenCode/OpenCodeProviderImplementation.swift
@@ -1,10 +1,8 @@
 import AppKit
 import CodexBarCore
-import CodexBarMacroSupport
 import Foundation
 import SwiftUI
 
-@ProviderImplementationRegistration
 struct OpenCodeProviderImplementation: ProviderImplementation {
     let id: UsageProvider = .opencode
 
@@ -70,9 +68,9 @@ struct OpenCodeProviderImplementation: ProviderImplementation {
                 isVisible: nil,
                 onChange: nil,
                 trailingText: {
-                    guard let entry = CookieHeaderCache.load(provider: .opencode) else { return nil }
-                    let when = entry.storedAt.relativeDescription()
-                    return "Cached: \(entry.sourceLabel) • \(when)"
+                    OpenCodeProviderUI.cachedCookieTrailingText(
+                        provider: .opencode,
+                        cookieSource: context.settings.opencodeCookieSource)
                 }),
         ]
     }
diff --git a/Sources/CodexBar/Providers/OpenCode/OpenCodeProviderUI.swift b/Sources/CodexBar/Providers/OpenCode/OpenCodeProviderUI.swift
new file mode 100644
index 0000000000..a2c77e734c
--- /dev/null
+++ b/Sources/CodexBar/Providers/OpenCode/OpenCodeProviderUI.swift
@@ -0,0 +1,12 @@
+import CodexBarCore
+import Foundation
+
+enum OpenCodeProviderUI {
+    @MainActor
+    static func cachedCookieTrailingText(provider: UsageProvider, cookieSource: ProviderCookieSource) -> String? {
+        guard cookieSource != .manual else { return nil }
+        guard let entry = CookieHeaderCache.loadForDisplay(provider: provider) else { return nil }
+        let when = entry.storedAt.relativeDescription()
+        return "Cached: \(entry.sourceLabel) • \(when)"
+    }
+}
diff --git a/Sources/CodexBar/Providers/OpenCode/OpenCodeSettingsStore.swift b/Sources/CodexBar/Providers/OpenCode/OpenCodeSettingsStore.swift
index b33abcfd13..b718e8638c 100644
--- a/Sources/CodexBar/Providers/OpenCode/OpenCodeSettingsStore.swift
+++ b/Sources/CodexBar/Providers/OpenCode/OpenCodeSettingsStore.swift
@@ -39,37 +39,14 @@ extension SettingsStore {
 extension SettingsStore {
     func opencodeSettingsSnapshot(tokenOverride: TokenAccountOverride?) -> ProviderSettingsSnapshot
     .OpenCodeProviderSettings {
-        ProviderSettingsSnapshot.OpenCodeProviderSettings(
-            cookieSource: self.opencodeSnapshotCookieSource(tokenOverride: tokenOverride),
-            manualCookieHeader: self.opencodeSnapshotCookieHeader(tokenOverride: tokenOverride),
-            workspaceID: self.opencodeWorkspaceID)
-    }
-
-    private func opencodeSnapshotCookieHeader(tokenOverride: TokenAccountOverride?) -> String {
-        let fallback = self.opencodeCookieHeader
-        guard let support = TokenAccountSupportCatalog.support(for: .opencode),
-              case .cookieHeader = support.injection
-        else {
-            return fallback
-        }
-        guard let account = ProviderTokenAccountSelection.selectedAccount(
+        let cookieSettings: ProviderSettingsSnapshot.CookieProviderSettings = self.resolvedCookieSettings(
             provider: .opencode,
-            settings: self,
-            override: tokenOverride)
-        else {
-            return fallback
-        }
-        return TokenAccountSupportCatalog.normalizedCookieHeader(account.token, support: support)
-    }
-
-    private func opencodeSnapshotCookieSource(tokenOverride: TokenAccountOverride?) -> ProviderCookieSource {
-        let fallback = self.opencodeCookieSource
-        guard let support = TokenAccountSupportCatalog.support(for: .opencode),
-              support.requiresManualCookieSource
-        else {
-            return fallback
-        }
-        if self.tokenAccounts(for: .opencode).isEmpty { return fallback }
-        return .manual
+            configuredSource: self.opencodeCookieSource,
+            configuredHeader: self.opencodeCookieHeader,
+            tokenOverride: tokenOverride)
+        return ProviderSettingsSnapshot.OpenCodeProviderSettings(
+            cookieSource: cookieSettings.cookieSource,
+            manualCookieHeader: cookieSettings.manualCookieHeader,
+            workspaceID: self.opencodeWorkspaceID)
     }
 }
diff --git a/Sources/CodexBar/Providers/OpenCodeGo/OpenCodeGoProviderImplementation.swift b/Sources/CodexBar/Providers/OpenCodeGo/OpenCodeGoProviderImplementation.swift
new file mode 100644
index 0000000000..d7f937cb05
--- /dev/null
+++ b/Sources/CodexBar/Providers/OpenCodeGo/OpenCodeGoProviderImplementation.swift
@@ -0,0 +1,93 @@
+import AppKit
+import CodexBarCore
+import Foundation
+import SwiftUI
+
+struct OpenCodeGoProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .opencodego
+
+    @MainActor
+    func presentation(context _: ProviderPresentationContext) -> ProviderPresentation {
+        ProviderPresentation { _ in "web" }
+    }
+
+    @MainActor
+    func observeSettings(_ settings: SettingsStore) {
+        _ = settings.opencodegoCookieSource
+        _ = settings.opencodegoCookieHeader
+        _ = settings.opencodegoWorkspaceID
+    }
+
+    @MainActor
+    func settingsSnapshot(context: ProviderSettingsSnapshotContext) -> ProviderSettingsSnapshotContribution? {
+        .opencodego(context.settings.opencodegoSettingsSnapshot(tokenOverride: context.tokenOverride))
+    }
+
+    @MainActor
+    func tokenAccountsVisibility(context: ProviderSettingsContext, support: TokenAccountSupport) -> Bool {
+        guard support.requiresManualCookieSource else { return true }
+        if !context.settings.tokenAccounts(for: context.provider).isEmpty { return true }
+        return context.settings.opencodegoCookieSource == .manual
+    }
+
+    @MainActor
+    func applyTokenAccountCookieSource(settings: SettingsStore) {
+        if settings.opencodegoCookieSource != .manual {
+            settings.opencodegoCookieSource = .manual
+        }
+    }
+
+    @MainActor
+    func settingsPickers(context: ProviderSettingsContext) -> [ProviderSettingsPickerDescriptor] {
+        let cookieBinding = Binding(
+            get: { context.settings.opencodegoCookieSource.rawValue },
+            set: { raw in
+                context.settings.opencodegoCookieSource = ProviderCookieSource(rawValue: raw) ?? .auto
+            })
+        let cookieOptions = ProviderCookieSourceUI.options(
+            allowsOff: false,
+            keychainDisabled: context.settings.debugDisableKeychainAccess)
+
+        let cookieSubtitle: () -> String? = {
+            ProviderCookieSourceUI.subtitle(
+                source: context.settings.opencodegoCookieSource,
+                keychainDisabled: context.settings.debugDisableKeychainAccess,
+                auto: "Automatic imports browser cookies from opencode.ai.",
+                manual: "Paste a Cookie header captured from the billing page.",
+                off: "OpenCode Go cookies are disabled.")
+        }
+
+        return [
+            ProviderSettingsPickerDescriptor(
+                id: "opencodego-cookie-source",
+                title: "Cookie source",
+                subtitle: "Automatic imports browser cookies from opencode.ai.",
+                dynamicSubtitle: cookieSubtitle,
+                binding: cookieBinding,
+                options: cookieOptions,
+                isVisible: nil,
+                onChange: nil,
+                trailingText: {
+                    OpenCodeProviderUI.cachedCookieTrailingText(
+                        provider: .opencodego,
+                        cookieSource: context.settings.opencodegoCookieSource)
+                }),
+        ]
+    }
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "opencodego-workspace-id",
+                title: "Workspace ID",
+                subtitle: "Optional override if workspace lookup fails.",
+                kind: .plain,
+                placeholder: "wrk_…",
+                binding: context.stringBinding(\.opencodegoWorkspaceID),
+                actions: [],
+                isVisible: nil,
+                onActivate: nil),
+        ]
+    }
+}
diff --git a/Sources/CodexBar/Providers/OpenCodeGo/OpenCodeGoSettingsStore.swift b/Sources/CodexBar/Providers/OpenCodeGo/OpenCodeGoSettingsStore.swift
new file mode 100644
index 0000000000..3e1780f4b8
--- /dev/null
+++ b/Sources/CodexBar/Providers/OpenCodeGo/OpenCodeGoSettingsStore.swift
@@ -0,0 +1,65 @@
+import CodexBarCore
+import Foundation
+
+extension SettingsStore {
+    var opencodegoWorkspaceID: String {
+        get { self.configSnapshot.providerConfig(for: .opencodego)?.workspaceID ?? "" }
+        set {
+            let trimmed = newValue.trimmingCharacters(in: .whitespacesAndNewlines)
+            let value = trimmed.isEmpty ? nil : trimmed
+            self.updateProviderConfig(provider: .opencodego) { entry in
+                entry.workspaceID = value
+            }
+        }
+    }
+
+    var opencodegoCookieHeader: String {
+        get { self.configSnapshot.providerConfig(for: .opencodego)?.sanitizedCookieHeader ?? "" }
+        set {
+            self.updateProviderConfig(provider: .opencodego) { entry in
+                entry.cookieHeader = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .opencodego, field: "cookieHeader", value: newValue)
+        }
+    }
+
+    var opencodegoCookieSource: ProviderCookieSource {
+        get { self.resolvedCookieSource(provider: .opencodego, fallback: .auto) }
+        set {
+            self.updateProviderConfig(provider: .opencodego) { entry in
+                entry.cookieSource = newValue
+            }
+            self.logProviderModeChange(provider: .opencodego, field: "cookieSource", value: newValue.rawValue)
+        }
+    }
+
+    var opencodegoDashboardURL: URL {
+        OpenCodeGoUsageFetcher.dashboardURL(workspaceID: self.opencodegoWorkspaceID)
+    }
+
+    func ensureOpenCodeGoCookieLoaded() {}
+}
+
+extension SettingsStore {
+    func opencodegoSettingsSnapshot(tokenOverride: TokenAccountOverride?) -> ProviderSettingsSnapshot
+        .OpenCodeProviderSettings
+    {
+        let cookieSettings: ProviderSettingsSnapshot.CookieProviderSettings = self.resolvedCookieSettings(
+            provider: .opencodego,
+            configuredSource: self.opencodegoCookieSource,
+            configuredHeader: self.opencodegoCookieHeader,
+            tokenOverride: tokenOverride)
+        return ProviderSettingsSnapshot.OpenCodeProviderSettings(
+            cookieSource: cookieSettings.cookieSource,
+            manualCookieHeader: cookieSettings.manualCookieHeader,
+            workspaceID: self.opencodegoSnapshotWorkspaceID)
+    }
+
+    private var opencodegoSnapshotWorkspaceID: String? {
+        guard let workspaceID = self.configSnapshot.providerConfig(for: .opencodego)?.workspaceID else {
+            return nil
+        }
+        let trimmed = workspaceID.trimmingCharacters(in: .whitespacesAndNewlines)
+        return trimmed.isEmpty ? nil : trimmed
+    }
+}
diff --git a/Sources/CodexBar/Providers/OpenRouter/OpenRouterProviderImplementation.swift b/Sources/CodexBar/Providers/OpenRouter/OpenRouterProviderImplementation.swift
index d584a24306..e91337548c 100644
--- a/Sources/CodexBar/Providers/OpenRouter/OpenRouterProviderImplementation.swift
+++ b/Sources/CodexBar/Providers/OpenRouter/OpenRouterProviderImplementation.swift
@@ -1,10 +1,8 @@
 import AppKit
 import CodexBarCore
-import CodexBarMacroSupport
 import Foundation
 import SwiftUI
 
-@ProviderImplementationRegistration
 struct OpenRouterProviderImplementation: ProviderImplementation {
     let id: UsageProvider = .openrouter
 
diff --git a/Sources/CodexBar/Providers/Perplexity/PerplexityProviderImplementation.swift b/Sources/CodexBar/Providers/Perplexity/PerplexityProviderImplementation.swift
new file mode 100644
index 0000000000..00887bdb9c
--- /dev/null
+++ b/Sources/CodexBar/Providers/Perplexity/PerplexityProviderImplementation.swift
@@ -0,0 +1,93 @@
+import AppKit
+import CodexBarCore
+import Foundation
+import SwiftUI
+
+struct PerplexityProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .perplexity
+    let supportsLoginFlow: Bool = true
+
+    @MainActor
+    func presentation(context _: ProviderPresentationContext) -> ProviderPresentation {
+        ProviderPresentation { _ in "web" }
+    }
+
+    @MainActor
+    func runLoginFlow(context _: ProviderLoginContext) async -> Bool {
+        if let url = URL(string: "https://www.perplexity.ai/") {
+            NSWorkspace.shared.open(url)
+        }
+        return false
+    }
+
+    @MainActor
+    func observeSettings(_ settings: SettingsStore) {
+        _ = settings.perplexityCookieSource
+        _ = settings.perplexityManualCookieHeader
+    }
+
+    @MainActor
+    func settingsSnapshot(context: ProviderSettingsSnapshotContext) -> ProviderSettingsSnapshotContribution? {
+        .perplexity(context.settings.perplexitySettingsSnapshot(tokenOverride: context.tokenOverride))
+    }
+
+    @MainActor
+    func settingsPickers(context: ProviderSettingsContext) -> [ProviderSettingsPickerDescriptor] {
+        let cookieBinding = Binding(
+            get: { context.settings.perplexityCookieSource.rawValue },
+            set: { raw in
+                context.settings.perplexityCookieSource = ProviderCookieSource(rawValue: raw) ?? .auto
+            })
+        let options = ProviderCookieSourceUI.options(
+            allowsOff: true,
+            keychainDisabled: context.settings.debugDisableKeychainAccess)
+
+        let subtitle: () -> String? = {
+            ProviderCookieSourceUI.subtitle(
+                source: context.settings.perplexityCookieSource,
+                keychainDisabled: context.settings.debugDisableKeychainAccess,
+                auto: "Automatically imports browser session cookie.",
+                manual: "Paste a full cookie header or the __Secure-next-auth.session-token value.",
+                off: "Perplexity cookies are disabled.")
+        }
+
+        return [
+            ProviderSettingsPickerDescriptor(
+                id: "perplexity-cookie-source",
+                title: "Cookie source",
+                subtitle: "Automatically imports browser session cookie.",
+                dynamicSubtitle: subtitle,
+                binding: cookieBinding,
+                options: options,
+                isVisible: nil,
+                onChange: nil),
+        ]
+    }
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "perplexity-cookie",
+                title: "",
+                subtitle: "",
+                kind: .secure,
+                placeholder: "Cookie: \u{2026}\n\nor paste the __Secure-next-auth.session-token value",
+                binding: context.stringBinding(\.perplexityManualCookieHeader),
+                actions: [
+                    ProviderSettingsActionDescriptor(
+                        id: "perplexity-open-usage",
+                        title: "Open Usage Page",
+                        style: .link,
+                        isVisible: nil,
+                        perform: {
+                            if let url = URL(string: "https://www.perplexity.ai/account/usage") {
+                                NSWorkspace.shared.open(url)
+                            }
+                        }),
+                ],
+                isVisible: { context.settings.perplexityCookieSource == .manual },
+                onActivate: nil),
+        ]
+    }
+}
diff --git a/Sources/CodexBar/Providers/Perplexity/PerplexitySettingsStore.swift b/Sources/CodexBar/Providers/Perplexity/PerplexitySettingsStore.swift
new file mode 100644
index 0000000000..e5d430d425
--- /dev/null
+++ b/Sources/CodexBar/Providers/Perplexity/PerplexitySettingsStore.swift
@@ -0,0 +1,35 @@
+import CodexBarCore
+import Foundation
+
+extension SettingsStore {
+    var perplexityManualCookieHeader: String {
+        get { self.configSnapshot.providerConfig(for: .perplexity)?.sanitizedCookieHeader ?? "" }
+        set {
+            self.updateProviderConfig(provider: .perplexity) { entry in
+                entry.cookieHeader = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .perplexity, field: "cookieHeader", value: newValue)
+        }
+    }
+
+    var perplexityCookieSource: ProviderCookieSource {
+        get { self.resolvedCookieSource(provider: .perplexity, fallback: .auto) }
+        set {
+            self.updateProviderConfig(provider: .perplexity) { entry in
+                entry.cookieSource = newValue
+            }
+            self.logProviderModeChange(provider: .perplexity, field: "cookieSource", value: newValue.rawValue)
+        }
+    }
+}
+
+extension SettingsStore {
+    func perplexitySettingsSnapshot(tokenOverride: TokenAccountOverride?) -> ProviderSettingsSnapshot
+    .PerplexityProviderSettings {
+        self.resolvedCookieSettings(
+            provider: .perplexity,
+            configuredSource: self.perplexityCookieSource,
+            configuredHeader: self.perplexityManualCookieHeader,
+            tokenOverride: tokenOverride)
+    }
+}
diff --git a/Sources/CodexBar/Providers/Poe/PoeProviderImplementation.swift b/Sources/CodexBar/Providers/Poe/PoeProviderImplementation.swift
new file mode 100644
index 0000000000..57023af8b9
--- /dev/null
+++ b/Sources/CodexBar/Providers/Poe/PoeProviderImplementation.swift
@@ -0,0 +1,38 @@
+import CodexBarCore
+import Foundation
+
+struct PoeProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .poe
+
+    @MainActor
+    func presentation(context _: ProviderPresentationContext) -> ProviderPresentation {
+        ProviderPresentation { _ in "api" }
+    }
+
+    @MainActor
+    func observeSettings(_ settings: SettingsStore) {
+        _ = settings.poeAPIKey
+    }
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "poe-api-key",
+                title: "API key",
+                subtitle: "Stored in ~/.codexbar/config.json. Get your key from poe.com/api/keys.",
+                kind: .secure,
+                placeholder: nil,
+                binding: context.stringBinding(\.poeAPIKey),
+                actions: [],
+                isVisible: nil,
+                onActivate: nil),
+        ]
+    }
+
+    @MainActor
+    func isAvailable(context: ProviderAvailabilityContext) -> Bool {
+        ProviderTokenResolver.poeToken(environment: context.environment) != nil ||
+            !context.settings.poeAPIKey.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+    }
+}
diff --git a/Sources/CodexBar/Providers/Poe/PoeSettingsStore.swift b/Sources/CodexBar/Providers/Poe/PoeSettingsStore.swift
new file mode 100644
index 0000000000..150bdac160
--- /dev/null
+++ b/Sources/CodexBar/Providers/Poe/PoeSettingsStore.swift
@@ -0,0 +1,16 @@
+import CodexBarCore
+import Foundation
+
+extension SettingsStore {
+    var poeAPIKey: String {
+        get {
+            self.configSnapshot.providerConfig(for: .poe)?.sanitizedAPIKey ?? ""
+        }
+        set {
+            self.updateProviderConfig(provider: .poe) { entry in
+                entry.apiKey = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .poe, field: "apiKey", value: newValue)
+        }
+    }
+}
diff --git a/Sources/CodexBar/Providers/Shared/ProviderContext.swift b/Sources/CodexBar/Providers/Shared/ProviderContext.swift
index 8b0069a6ae..57493fe86b 100644
--- a/Sources/CodexBar/Providers/Shared/ProviderContext.swift
+++ b/Sources/CodexBar/Providers/Shared/ProviderContext.swift
@@ -34,4 +34,15 @@ struct ProviderVersionContext {
 struct ProviderSettingsSnapshotContext {
     let settings: SettingsStore
     let tokenOverride: TokenAccountOverride?
+    let codexActiveSourceOverride: CodexActiveSource?
+
+    init(
+        settings: SettingsStore,
+        tokenOverride: TokenAccountOverride?,
+        codexActiveSourceOverride: CodexActiveSource? = nil)
+    {
+        self.settings = settings
+        self.tokenOverride = tokenOverride
+        self.codexActiveSourceOverride = codexActiveSourceOverride
+    }
 }
diff --git a/Sources/CodexBar/Providers/Shared/ProviderCookieSettingsResolution.swift b/Sources/CodexBar/Providers/Shared/ProviderCookieSettingsResolution.swift
new file mode 100644
index 0000000000..e6804793fc
--- /dev/null
+++ b/Sources/CodexBar/Providers/Shared/ProviderCookieSettingsResolution.swift
@@ -0,0 +1,22 @@
+import CodexBarCore
+
+extension SettingsStore {
+    func resolvedCookieSettings<Settings: ProviderCookieSettings>(
+        provider: UsageProvider,
+        configuredSource: ProviderCookieSource,
+        configuredHeader: String?,
+        tokenOverride: TokenAccountOverride?) -> Settings
+    {
+        let resolved = ProviderCookieSettingsResolver.resolve(
+            provider: provider,
+            configuredSource: configuredSource,
+            configuredHeader: configuredHeader,
+            selectedAccount: ProviderTokenAccountSelection.selectedAccount(
+                provider: provider,
+                settings: self,
+                override: tokenOverride))
+        return Settings(
+            cookieSource: resolved.cookieSource,
+            manualCookieHeader: resolved.manualCookieHeader)
+    }
+}
diff --git a/Sources/CodexBar/Providers/Shared/ProviderCookieSourceUI.swift b/Sources/CodexBar/Providers/Shared/ProviderCookieSourceUI.swift
index 4964f4df4b..7c3fccc720 100644
--- a/Sources/CodexBar/Providers/Shared/ProviderCookieSourceUI.swift
+++ b/Sources/CodexBar/Providers/Shared/ProviderCookieSourceUI.swift
@@ -1,7 +1,7 @@
 import CodexBarCore
 
 enum ProviderCookieSourceUI {
-    static let keychainDisabledPrefix =
+    static let keychainDisabledPrefixKey =
         "Keychain access is disabled in Advanced, so browser cookie import is unavailable."
 
     static func options(allowsOff: Bool, keychainDisabled: Bool) -> [ProviderSettingsPickerOption] {
@@ -29,16 +29,88 @@ enum ProviderCookieSourceUI {
         manual: String,
         off: String) -> String
     {
+        let localizedAuto = self.localizedSubtitle(auto)
+        let localizedManual = self.localizedSubtitle(manual)
+        let localizedOff = self.localizedSubtitle(off)
         if keychainDisabled {
-            return source == .off ? off : "\(self.keychainDisabledPrefix) \(manual)"
+            return source == .off
+                ? localizedOff
+                : "\(L(self.keychainDisabledPrefixKey)) \(localizedManual)"
         }
         switch source {
         case .auto:
-            return auto
+            return localizedAuto
         case .manual:
-            return manual
+            return localizedManual
         case .off:
-            return off
+            return localizedOff
         }
     }
+
+    private static func localizedSubtitle(_ subtitle: String) -> String {
+        let trimmed = subtitle.trimmingCharacters(in: .whitespacesAndNewlines)
+        if let source = trimmed.removing(prefix: "Paste a Cookie header or cURL capture from ", suffix: ".") {
+            return L("Paste a Cookie header or cURL capture from %@.", source)
+        }
+        if let source = trimmed.removing(prefix: "Paste a Cookie header or full cURL capture from ", suffix: ".") {
+            return L("Paste a Cookie header or full cURL capture from %@.", source)
+        }
+        if let source = trimmed.removing(prefix: "Paste a Cookie header captured from ", suffix: ".") {
+            return L("Paste a Cookie header captured from %@.", source)
+        }
+        if let source = trimmed.removing(prefix: "Paste a Cookie header from ", suffix: ".") {
+            return L("Paste a Cookie header from %@.", source)
+        }
+        if let token = trimmed.removing(prefix: "Paste a full cookie header or the ", suffix: " value.") {
+            return L("Paste a full cookie header or the %@ value.", token)
+        }
+        if let source = trimmed.removing(prefix: "Paste a Cookie or Authorization header from ", suffix: ".") {
+            return L("Paste a Cookie or Authorization header from %@.", source)
+        }
+        if let token = trimmed.removing(prefix: "Paste the ", suffix: " value or a full Cookie header.") {
+            return L("Paste the %@ value or a full Cookie header.", token)
+        }
+        if let token = trimmed.removing(prefix: "Manually paste an ", suffix: " from a browser session.") {
+            return L("Manually paste an %@ from a browser session.", token)
+        }
+        if let token = trimmed.removing(
+            prefix: "Uses username + password to login and obtain an ",
+            suffix: " automatically.")
+        {
+            return L("Uses username + password to login and obtain an %@ automatically.", token)
+        }
+        if let parts = trimmed.removingTwoParts(prefix: "Paste the ", separator: " JSON bundle from ", suffix: ".") {
+            return L("Paste the %@ JSON bundle from %@.", parts.0, parts.1)
+        }
+        if let provider = trimmed.removing(prefix: "Disable ", suffix: " dashboard cookie usage.") {
+            return L("Disable %@ dashboard cookie usage.", provider)
+        }
+        if let provider = trimmed.removing(prefix: "", suffix: " cookies are disabled.") {
+            return L("%@ cookies are disabled.", provider)
+        }
+        if let provider = trimmed.removing(prefix: "", suffix: " authentication is disabled.") {
+            return L("%@ authentication is disabled.", provider)
+        }
+        if let provider = trimmed.removing(prefix: "", suffix: " web API access is disabled.") {
+            return L("%@ web API access is disabled.", provider)
+        }
+        return L(trimmed)
+    }
+}
+
+extension String {
+    fileprivate func removing(prefix: String, suffix: String) -> String? {
+        guard self.hasPrefix(prefix), self.hasSuffix(suffix) else { return nil }
+        let start = self.index(self.startIndex, offsetBy: prefix.count)
+        let end = self.index(self.endIndex, offsetBy: -suffix.count)
+        guard start <= end else { return nil }
+        return String(self[start..<end])
+    }
+
+    fileprivate func removingTwoParts(prefix: String, separator: String, suffix: String) -> (String, String)? {
+        guard let value = self.removing(prefix: prefix, suffix: suffix),
+              let range = value.range(of: separator)
+        else { return nil }
+        return (String(value[..<range.lowerBound]), String(value[range.upperBound...]))
+    }
 }
diff --git a/Sources/CodexBar/Providers/Shared/ProviderImplementation.swift b/Sources/CodexBar/Providers/Shared/ProviderImplementation.swift
index 7d5e22bd29..84e709525a 100644
--- a/Sources/CodexBar/Providers/Shared/ProviderImplementation.swift
+++ b/Sources/CodexBar/Providers/Shared/ProviderImplementation.swift
@@ -42,10 +42,18 @@ protocol ProviderImplementation: Sendable {
     @MainActor
     func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor]
 
+    /// Optional provider-specific settings action rows to render in the Providers pane.
+    @MainActor
+    func settingsActions(context: ProviderSettingsContext) -> [ProviderSettingsActionsDescriptor]
+
     /// Optional provider-specific settings pickers to render in the Providers pane.
     @MainActor
     func settingsPickers(context: ProviderSettingsContext) -> [ProviderSettingsPickerDescriptor]
 
+    /// Optional provider-specific organizations selection rendered in the Providers pane.
+    @MainActor
+    func settingsOrganizations(context: ProviderSettingsContext) -> ProviderSettingsOrganizationsDescriptor?
+
     /// Optional visibility gate for token account settings.
     @MainActor
     func tokenAccountsVisibility(context: ProviderSettingsContext, support: TokenAccountSupport) -> Bool
@@ -129,11 +137,21 @@ extension ProviderImplementation {
         []
     }
 
+    @MainActor
+    func settingsActions(context _: ProviderSettingsContext) -> [ProviderSettingsActionsDescriptor] {
+        []
+    }
+
     @MainActor
     func settingsPickers(context _: ProviderSettingsContext) -> [ProviderSettingsPickerDescriptor] {
         []
     }
 
+    @MainActor
+    func settingsOrganizations(context _: ProviderSettingsContext) -> ProviderSettingsOrganizationsDescriptor? {
+        nil
+    }
+
     @MainActor
     func tokenAccountsVisibility(context: ProviderSettingsContext, support: TokenAccountSupport) -> Bool {
         guard support.requiresManualCookieSource else { return true }
diff --git a/Sources/CodexBar/Providers/Shared/ProviderImplementationRegistry.swift b/Sources/CodexBar/Providers/Shared/ProviderImplementationRegistry.swift
index 7938b3d498..098e69325e 100644
--- a/Sources/CodexBar/Providers/Shared/ProviderImplementationRegistry.swift
+++ b/Sources/CodexBar/Providers/Shared/ProviderImplementationRegistry.swift
@@ -14,15 +14,22 @@ enum ProviderImplementationRegistry {
     private static func makeImplementation(for provider: UsageProvider) -> (any ProviderImplementation) {
         switch provider {
         case .codex: CodexProviderImplementation()
+        case .openai: OpenAIAPIProviderImplementation()
+        case .azureopenai: AzureOpenAIProviderImplementation()
         case .claude: ClaudeProviderImplementation()
         case .cursor: CursorProviderImplementation()
         case .opencode: OpenCodeProviderImplementation()
+        case .opencodego: OpenCodeGoProviderImplementation()
+        case .alibaba: AlibabaCodingPlanProviderImplementation()
+        case .alibabatokenplan: AlibabaTokenPlanProviderImplementation()
         case .factory: FactoryProviderImplementation()
         case .gemini: GeminiProviderImplementation()
         case .antigravity: AntigravityProviderImplementation()
         case .copilot: CopilotProviderImplementation()
+        case .devin: DevinProviderImplementation()
         case .zai: ZaiProviderImplementation()
         case .minimax: MiniMaxProviderImplementation()
+        case .manus: ManusProviderImplementation()
         case .kimi: KimiProviderImplementation()
         case .kilo: KiloProviderImplementation()
         case .kiro: KiroProviderImplementation()
@@ -30,11 +37,35 @@ enum ProviderImplementationRegistry {
         case .augment: AugmentProviderImplementation()
         case .jetbrains: JetBrainsProviderImplementation()
         case .kimik2: KimiK2ProviderImplementation()
+        case .moonshot: MoonshotProviderImplementation()
         case .amp: AmpProviderImplementation()
+        case .t3chat: T3ChatProviderImplementation()
         case .ollama: OllamaProviderImplementation()
         case .synthetic: SyntheticProviderImplementation()
         case .openrouter: OpenRouterProviderImplementation()
+        case .elevenlabs: ElevenLabsProviderImplementation()
         case .warp: WarpProviderImplementation()
+        case .windsurf: WindsurfProviderImplementation()
+        case .zed: ZedProviderImplementation()
+        case .perplexity: PerplexityProviderImplementation()
+        case .mimo: MiMoProviderImplementation()
+        case .doubao: DoubaoProviderImplementation()
+        case .abacus: AbacusProviderImplementation()
+        case .mistral: MistralProviderImplementation()
+        case .deepseek: DeepSeekProviderImplementation()
+        case .codebuff: CodebuffProviderImplementation()
+        case .crof: CrofProviderImplementation()
+        case .venice: VeniceProviderImplementation()
+        case .commandcode: CommandCodeProviderImplementation()
+        case .stepfun: StepFunProviderImplementation()
+        case .bedrock: BedrockProviderImplementation()
+        case .grok: GrokProviderImplementation()
+        case .groq: GroqProviderImplementation()
+        case .llmproxy: LLMProxyProviderImplementation()
+        case .litellm: LiteLLMProviderImplementation()
+        case .deepgram: DeepgramProviderImplementation()
+        case .poe: PoeProviderImplementation()
+        case .chutes: ChutesProviderImplementation()
         }
     }
 
diff --git a/Sources/CodexBar/Providers/Shared/ProviderMenuContext.swift b/Sources/CodexBar/Providers/Shared/ProviderMenuContext.swift
index 9161dd8352..ac350b05e6 100644
--- a/Sources/CodexBar/Providers/Shared/ProviderMenuContext.swift
+++ b/Sources/CodexBar/Providers/Shared/ProviderMenuContext.swift
@@ -16,6 +16,8 @@ struct ProviderMenuActionContext {
     let store: UsageStore
     let settings: SettingsStore
     let account: AccountInfo
+    let managedCodexAccountCoordinator: ManagedCodexAccountCoordinator?
+    let codexAccountPromotionCoordinator: CodexAccountPromotionCoordinator?
 }
 
 struct ProviderMenuLoginContext {
diff --git a/Sources/CodexBar/Providers/Shared/ProviderRuntime.swift b/Sources/CodexBar/Providers/Shared/ProviderRuntime.swift
index bac370d092..188543ed9a 100644
--- a/Sources/CodexBar/Providers/Shared/ProviderRuntime.swift
+++ b/Sources/CodexBar/Providers/Shared/ProviderRuntime.swift
@@ -7,7 +7,7 @@ struct ProviderRuntimeContext {
     let store: UsageStore
 }
 
-enum ProviderRuntimeAction: Sendable {
+enum ProviderRuntimeAction {
     case forceSessionRefresh
     case openAIWebAccessToggled(Bool)
 }
diff --git a/Sources/CodexBar/Providers/Shared/ProviderSettingsDescriptors.swift b/Sources/CodexBar/Providers/Shared/ProviderSettingsDescriptors.swift
index d5a85b8f7a..eb600b09b5 100644
--- a/Sources/CodexBar/Providers/Shared/ProviderSettingsDescriptors.swift
+++ b/Sources/CodexBar/Providers/Shared/ProviderSettingsDescriptors.swift
@@ -25,6 +25,33 @@ struct ProviderSettingsContext {
     let setLastAppActiveRunAt: (String, Date?) -> Void
 
     let requestConfirmation: (ProviderSettingsConfirmation) -> Void
+    let runLoginFlow: () async -> Void
+
+    init(
+        provider: UsageProvider,
+        settings: SettingsStore,
+        store: UsageStore,
+        boolBinding: @escaping (ReferenceWritableKeyPath<SettingsStore, Bool>) -> Binding<Bool>,
+        stringBinding: @escaping (ReferenceWritableKeyPath<SettingsStore, String>) -> Binding<String>,
+        statusText: @escaping (String) -> String?,
+        setStatusText: @escaping (String, String?) -> Void,
+        lastAppActiveRunAt: @escaping (String) -> Date?,
+        setLastAppActiveRunAt: @escaping (String, Date?) -> Void,
+        requestConfirmation: @escaping (ProviderSettingsConfirmation) -> Void,
+        runLoginFlow: @escaping () async -> Void = {})
+    {
+        self.provider = provider
+        self.settings = settings
+        self.store = store
+        self.boolBinding = boolBinding
+        self.stringBinding = stringBinding
+        self.statusText = statusText
+        self.setStatusText = setStatusText
+        self.lastAppActiveRunAt = lastAppActiveRunAt
+        self.setLastAppActiveRunAt = setLastAppActiveRunAt
+        self.requestConfirmation = requestConfirmation
+        self.runLoginFlow = runLoginFlow
+    }
 }
 
 /// Shared confirmation alert descriptor.
@@ -55,6 +82,9 @@ struct ProviderSettingsToggleDescriptor: Identifiable {
     /// Optional runtime visibility gate.
     let isVisible: (() -> Bool)?
 
+    /// Optional runtime enabled gate.
+    let isEnabled: (() -> Bool)?
+
     /// Called whenever the toggle changes.
     let onChange: ((_ enabled: Bool) async -> Void)?
 
@@ -63,6 +93,32 @@ struct ProviderSettingsToggleDescriptor: Identifiable {
 
     /// Called when the view appears while the toggle is enabled.
     let onAppearWhenEnabled: (() async -> Void)?
+
+    init(
+        id: String,
+        title: String,
+        subtitle: String,
+        binding: Binding<Bool>,
+        statusText: (() -> String?)?,
+        actions: [ProviderSettingsActionDescriptor],
+        isVisible: (() -> Bool)?,
+        isEnabled: (() -> Bool)? = nil,
+        onChange: ((_ enabled: Bool) async -> Void)?,
+        onAppDidBecomeActive: (() async -> Void)?,
+        onAppearWhenEnabled: (() async -> Void)?)
+    {
+        self.id = id
+        self.title = title
+        self.subtitle = subtitle
+        self.binding = binding
+        self.statusText = statusText
+        self.actions = actions
+        self.isVisible = isVisible
+        self.isEnabled = isEnabled
+        self.onChange = onChange
+        self.onAppDidBecomeActive = onAppDidBecomeActive
+        self.onAppearWhenEnabled = onAppearWhenEnabled
+    }
 }
 
 /// Shared text field descriptor rendered in the Providers settings pane.
@@ -76,6 +132,7 @@ struct ProviderSettingsFieldDescriptor: Identifiable {
     let id: String
     let title: String
     let subtitle: String
+    var footerText: String?
     let kind: Kind
     let placeholder: String?
     let binding: Binding<String>
@@ -84,6 +141,16 @@ struct ProviderSettingsFieldDescriptor: Identifiable {
     let onActivate: (() -> Void)?
 }
 
+/// Shared action row descriptor rendered in the Providers settings pane.
+@MainActor
+struct ProviderSettingsActionsDescriptor: Identifiable {
+    let id: String
+    let title: String
+    let subtitle: String
+    let actions: [ProviderSettingsActionDescriptor]
+    let isVisible: (() -> Bool)?
+}
+
 /// Shared token account descriptor rendered in the Providers settings pane.
 @MainActor
 struct ProviderSettingsTokenAccountsDescriptor: Identifiable {
@@ -96,12 +163,63 @@ struct ProviderSettingsTokenAccountsDescriptor: Identifiable {
     let accounts: () -> [ProviderTokenAccount]
     let activeIndex: () -> Int
     let setActiveIndex: (Int) -> Void
-    let addAccount: (_ label: String, _ token: String) -> Void
+    let showsOrganizationField: Bool
+    let addAccount: (_ label: String, _ token: String, _ organizationID: String?) -> Void
     let removeAccount: (_ accountID: UUID) -> Void
+    let primaryAddActionTitle: String?
+    let primaryAddAction: (() async -> Void)?
     let openConfigFile: () -> Void
     let reloadFromDisk: () -> Void
 }
 
+/// Shared organizations descriptor rendered in the Providers settings pane.
+///
+/// Used by providers that let the user opt in to additional account scopes
+/// (e.g. Kilo organizations) shown alongside the personal account.
+@MainActor
+struct ProviderSettingsOrganizationsDescriptor: Identifiable {
+    struct Entry: Identifiable {
+        let id: String
+        let title: String
+        let subtitle: String?
+        let localizesTitle: Bool
+        let localizesSubtitle: Bool
+        let isEnabled: Bool
+        let isLocked: Bool
+
+        init(
+            id: String,
+            title: String,
+            subtitle: String?,
+            localizesTitle: Bool = true,
+            localizesSubtitle: Bool = true,
+            isEnabled: Bool,
+            isLocked: Bool)
+        {
+            self.id = id
+            self.title = title
+            self.subtitle = subtitle
+            self.localizesTitle = localizesTitle
+            self.localizesSubtitle = localizesSubtitle
+            self.isEnabled = isEnabled
+            self.isLocked = isLocked
+        }
+    }
+
+    struct RefreshOutcome {
+        let success: Bool
+        let errorMessage: String?
+    }
+
+    let id: String
+    let title: String
+    let subtitle: String?
+    let entries: () -> [Entry]
+    let onToggle: (String, Bool) -> Void
+    let onRefresh: () async -> RefreshOutcome
+    let canRefresh: () -> Bool
+}
+
 /// Shared picker descriptor rendered in the Providers settings pane.
 @MainActor
 struct ProviderSettingsPickerDescriptor: Identifiable {
diff --git a/Sources/CodexBar/Providers/Shared/ProviderTokenAccountSelection.swift b/Sources/CodexBar/Providers/Shared/ProviderTokenAccountSelection.swift
index 58c18de55c..86c2618ceb 100644
--- a/Sources/CodexBar/Providers/Shared/ProviderTokenAccountSelection.swift
+++ b/Sources/CodexBar/Providers/Shared/ProviderTokenAccountSelection.swift
@@ -1,7 +1,7 @@
 import CodexBarCore
 import Foundation
 
-struct TokenAccountOverride: Sendable {
+struct TokenAccountOverride {
     let provider: UsageProvider
     let account: ProviderTokenAccount
 }
diff --git a/Sources/CodexBar/Providers/StepFun/StepFunProviderImplementation.swift b/Sources/CodexBar/Providers/StepFun/StepFunProviderImplementation.swift
new file mode 100644
index 0000000000..1f53aca705
--- /dev/null
+++ b/Sources/CodexBar/Providers/StepFun/StepFunProviderImplementation.swift
@@ -0,0 +1,159 @@
+import AppKit
+import CodexBarCore
+import Foundation
+import SwiftUI
+
+struct StepFunProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .stepfun
+
+    @MainActor
+    func presentation(context _: ProviderPresentationContext) -> ProviderPresentation {
+        ProviderPresentation { _ in "web" }
+    }
+
+    @MainActor
+    func observeSettings(_ settings: SettingsStore) {
+        _ = settings.stepfunCookieSource
+        _ = settings.stepfunUsername
+        _ = settings.stepfunPassword
+        _ = settings.stepfunToken
+    }
+
+    @MainActor
+    func isAvailable(context: ProviderAvailabilityContext) -> Bool {
+        // Available if any auth method is configured
+        if !context.settings.stepfunUsername.isEmpty, !context.settings.stepfunPassword.isEmpty {
+            return true
+        }
+        if context.settings.stepfunCookieSource == .manual, !context.settings.stepfunToken.isEmpty {
+            return true
+        }
+        if CookieHeaderCache.load(provider: .stepfun) != nil {
+            return true
+        }
+        if StepFunSettingsReader.username(environment: context.environment) != nil,
+           StepFunSettingsReader.password(environment: context.environment) != nil
+        {
+            return true
+        }
+        if StepFunSettingsReader.token(environment: context.environment) != nil {
+            return true
+        }
+        return false
+    }
+
+    @MainActor
+    func settingsSnapshot(context: ProviderSettingsSnapshotContext) -> ProviderSettingsSnapshotContribution? {
+        .stepfun(context.settings.stepfunSettingsSnapshot(tokenOverride: context.tokenOverride))
+    }
+
+    @MainActor
+    func tokenAccountsVisibility(context: ProviderSettingsContext, support: TokenAccountSupport) -> Bool {
+        guard support.requiresManualCookieSource else { return true }
+        if !context.settings.tokenAccounts(for: context.provider).isEmpty { return true }
+        return context.settings.stepfunCookieSource == .manual
+    }
+
+    @MainActor
+    func applyTokenAccountCookieSource(settings: SettingsStore) {
+        if settings.stepfunCookieSource != .manual {
+            settings.stepfunCookieSource = .manual
+        }
+    }
+
+    // MARK: - Settings Pickers
+
+    @MainActor
+    func settingsPickers(context: ProviderSettingsContext) -> [ProviderSettingsPickerDescriptor] {
+        let cookieBinding = Binding(
+            get: { context.settings.stepfunCookieSource.rawValue },
+            set: { raw in
+                context.settings.stepfunCookieSource = ProviderCookieSource(rawValue: raw) ?? .auto
+            })
+        let cookieOptions = ProviderCookieSourceUI.options(
+            allowsOff: true,
+            keychainDisabled: context.settings.debugDisableKeychainAccess)
+
+        let cookieSubtitle: () -> String? = {
+            ProviderCookieSourceUI.subtitle(
+                source: context.settings.stepfunCookieSource,
+                keychainDisabled: context.settings.debugDisableKeychainAccess,
+                auto: "Uses username + password to login and obtain an Oasis-Token automatically.",
+                manual: "Manually paste an Oasis-Token from a browser session.",
+                off: "StepFun authentication is disabled.")
+        }
+
+        return [
+            ProviderSettingsPickerDescriptor(
+                id: "stepfun-cookie-source",
+                title: "Auth source",
+                subtitle: "Uses username + password to login and obtain an Oasis-Token automatically.",
+                dynamicSubtitle: cookieSubtitle,
+                binding: cookieBinding,
+                options: cookieOptions,
+                isVisible: nil,
+                onChange: nil,
+                trailingText: {
+                    guard let entry = CookieHeaderCache.loadForDisplay(provider: .stepfun) else { return nil }
+                    let when = entry.storedAt.relativeDescription()
+                    return "Cached: \(entry.sourceLabel) • \(when)"
+                }),
+        ]
+    }
+
+    // MARK: - Settings Fields
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        // Auto mode: show username + password fields
+        let autoFields: [ProviderSettingsFieldDescriptor] = [
+            ProviderSettingsFieldDescriptor(
+                id: "stepfun-username",
+                title: "Username",
+                subtitle: "StepFun platform account (phone number or email).",
+                kind: .plain,
+                placeholder: "user@example.com",
+                binding: context.stringBinding(\.stepfunUsername),
+                actions: [],
+                isVisible: { context.settings.stepfunCookieSource != .manual },
+                onActivate: nil),
+            ProviderSettingsFieldDescriptor(
+                id: "stepfun-password",
+                title: "Password",
+                subtitle: "Your StepFun platform password. Used to login and obtain a session token.",
+                kind: .secure,
+                placeholder: "Password",
+                binding: context.stringBinding(\.stepfunPassword),
+                actions: [],
+                isVisible: { context.settings.stepfunCookieSource != .manual },
+                onActivate: nil),
+        ]
+
+        // Manual mode: show token field
+        let manualFields: [ProviderSettingsFieldDescriptor] = [
+            ProviderSettingsFieldDescriptor(
+                id: "stepfun-token",
+                title: "Oasis-Token",
+                subtitle: "Paste the Oasis-Token from a logged-in browser session on platform.stepfun.com.",
+                kind: .secure,
+                placeholder: "Oasis-Token=…",
+                binding: context.stringBinding(\.stepfunToken),
+                actions: [
+                    ProviderSettingsActionDescriptor(
+                        id: "stepfun-open-platform",
+                        title: "Open StepFun Platform",
+                        style: .link,
+                        isVisible: nil,
+                        perform: {
+                            if let url = URL(string: "https://platform.stepfun.com/plan-usage") {
+                                NSWorkspace.shared.open(url)
+                            }
+                        }),
+                ],
+                isVisible: { context.settings.stepfunCookieSource == .manual },
+                onActivate: nil),
+        ]
+
+        return autoFields + manualFields
+    }
+}
diff --git a/Sources/CodexBar/Providers/StepFun/StepFunSettingsStore.swift b/Sources/CodexBar/Providers/StepFun/StepFunSettingsStore.swift
new file mode 100644
index 0000000000..27fa571f8e
--- /dev/null
+++ b/Sources/CodexBar/Providers/StepFun/StepFunSettingsStore.swift
@@ -0,0 +1,65 @@
+import CodexBarCore
+import Foundation
+
+extension SettingsStore {
+    /// Username for StepFun login — stored in the apiKey config field.
+    var stepfunUsername: String {
+        get { self.configSnapshot.providerConfig(for: .stepfun)?.sanitizedAPIKey ?? "" }
+        set {
+            self.updateProviderConfig(provider: .stepfun) { entry in
+                entry.apiKey = self.normalizedConfigValue(newValue)
+            }
+            self.logProviderModeChange(
+                provider: .stepfun,
+                field: "username",
+                value: newValue.isEmpty ? "(cleared)" : "(updated)")
+        }
+    }
+
+    /// Password for StepFun login — stored in the cookieHeader config field (secure storage).
+    var stepfunPassword: String {
+        get { self.configSnapshot.providerConfig(for: .stepfun)?.sanitizedCookieHeader ?? "" }
+        set {
+            self.updateProviderConfig(provider: .stepfun) { entry in
+                entry.cookieHeader = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .stepfun, field: "password", value: newValue)
+        }
+    }
+
+    /// Manual Oasis-Token — stored in the region config field (repurposed for token).
+    var stepfunToken: String {
+        get { self.configSnapshot.providerConfig(for: .stepfun)?.region ?? "" }
+        set {
+            self.updateProviderConfig(provider: .stepfun) { entry in
+                entry.region = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .stepfun, field: "token", value: newValue)
+        }
+    }
+
+    var stepfunCookieSource: ProviderCookieSource {
+        get { self.resolvedCookieSource(provider: .stepfun, fallback: .auto) }
+        set {
+            self.updateProviderConfig(provider: .stepfun) { entry in
+                entry.cookieSource = newValue
+            }
+            self.logProviderModeChange(provider: .stepfun, field: "cookieSource", value: newValue.rawValue)
+        }
+    }
+
+    func stepfunSettingsSnapshot(tokenOverride: TokenAccountOverride?) -> ProviderSettingsSnapshot
+        .StepFunProviderSettings
+    {
+        let cookieSettings: ProviderSettingsSnapshot.CookieProviderSettings = self.resolvedCookieSettings(
+            provider: .stepfun,
+            configuredSource: self.stepfunCookieSource,
+            configuredHeader: self.stepfunToken,
+            tokenOverride: tokenOverride)
+        return ProviderSettingsSnapshot.StepFunProviderSettings(
+            cookieSource: cookieSettings.cookieSource,
+            manualToken: cookieSettings.manualCookieHeader ?? "",
+            username: self.stepfunUsername,
+            password: self.stepfunPassword)
+    }
+}
diff --git a/Sources/CodexBar/Providers/Synthetic/SyntheticProviderImplementation.swift b/Sources/CodexBar/Providers/Synthetic/SyntheticProviderImplementation.swift
index dcef3eb675..b8aa9b0634 100644
--- a/Sources/CodexBar/Providers/Synthetic/SyntheticProviderImplementation.swift
+++ b/Sources/CodexBar/Providers/Synthetic/SyntheticProviderImplementation.swift
@@ -1,9 +1,7 @@
 import AppKit
 import CodexBarCore
-import CodexBarMacroSupport
 import Foundation
 
-@ProviderImplementationRegistration
 struct SyntheticProviderImplementation: ProviderImplementation {
     let id: UsageProvider = .synthetic
 
diff --git a/Sources/CodexBar/Providers/T3Chat/T3ChatProviderImplementation.swift b/Sources/CodexBar/Providers/T3Chat/T3ChatProviderImplementation.swift
new file mode 100644
index 0000000000..abb6d53220
--- /dev/null
+++ b/Sources/CodexBar/Providers/T3Chat/T3ChatProviderImplementation.swift
@@ -0,0 +1,79 @@
+import AppKit
+import CodexBarCore
+import Foundation
+import SwiftUI
+
+struct T3ChatProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .t3chat
+
+    @MainActor
+    func observeSettings(_ settings: SettingsStore) {
+        _ = settings.t3ChatCookieSource
+        _ = settings.t3ChatCookieHeader
+    }
+
+    @MainActor
+    func settingsSnapshot(context: ProviderSettingsSnapshotContext) -> ProviderSettingsSnapshotContribution? {
+        .t3chat(context.settings.t3ChatSettingsSnapshot(tokenOverride: context.tokenOverride))
+    }
+
+    @MainActor
+    func settingsPickers(context: ProviderSettingsContext) -> [ProviderSettingsPickerDescriptor] {
+        let cookieBinding = Binding(
+            get: { context.settings.t3ChatCookieSource.rawValue },
+            set: { raw in
+                context.settings.t3ChatCookieSource = ProviderCookieSource(rawValue: raw) ?? .auto
+            })
+        let cookieOptions = ProviderCookieSourceUI.options(
+            allowsOff: false,
+            keychainDisabled: context.settings.debugDisableKeychainAccess)
+
+        let cookieSubtitle: () -> String? = {
+            ProviderCookieSourceUI.subtitle(
+                source: context.settings.t3ChatCookieSource,
+                keychainDisabled: context.settings.debugDisableKeychainAccess,
+                auto: "Automatically imports browser cookies.",
+                manual: "Paste a Cookie header or cURL capture from T3 Chat settings.",
+                off: "Paste a Cookie header or cURL capture from T3 Chat settings.")
+        }
+
+        return [
+            ProviderSettingsPickerDescriptor(
+                id: "t3chat-cookie-source",
+                title: "Cookie source",
+                subtitle: "Automatically imports browser cookies.",
+                dynamicSubtitle: cookieSubtitle,
+                binding: cookieBinding,
+                options: cookieOptions,
+                isVisible: nil,
+                onChange: nil),
+        ]
+    }
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "t3chat-cookie",
+                title: "T3 Chat cookie",
+                subtitle: "Paste a Cookie header or full cURL capture from T3 Chat settings.",
+                kind: .secure,
+                placeholder: "Cookie: ...",
+                binding: context.stringBinding(\.t3ChatCookieHeader),
+                actions: [
+                    ProviderSettingsActionDescriptor(
+                        id: "t3chat-open-settings",
+                        title: "Open T3 Chat Settings",
+                        style: .link,
+                        isVisible: nil,
+                        perform: {
+                            if let url = URL(string: "https://t3.chat/settings/customization") {
+                                NSWorkspace.shared.open(url)
+                            }
+                        }),
+                ],
+                isVisible: { context.settings.t3ChatCookieSource == .manual },
+                onActivate: nil),
+        ]
+    }
+}
diff --git a/Sources/CodexBar/Providers/T3Chat/T3ChatSettingsStore.swift b/Sources/CodexBar/Providers/T3Chat/T3ChatSettingsStore.swift
new file mode 100644
index 0000000000..4ea59eb182
--- /dev/null
+++ b/Sources/CodexBar/Providers/T3Chat/T3ChatSettingsStore.swift
@@ -0,0 +1,36 @@
+import CodexBarCore
+import Foundation
+
+extension SettingsStore {
+    var t3ChatCookieHeader: String {
+        get { self.configSnapshot.providerConfig(for: .t3chat)?.sanitizedCookieHeader ?? "" }
+        set {
+            self.updateProviderConfig(provider: .t3chat) { entry in
+                entry.cookieHeader = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .t3chat, field: "cookieHeader", value: newValue)
+        }
+    }
+
+    var t3ChatCookieSource: ProviderCookieSource {
+        get { self.resolvedCookieSource(provider: .t3chat, fallback: .auto) }
+        set {
+            self.updateProviderConfig(provider: .t3chat) { entry in
+                entry.cookieSource = newValue
+            }
+            self.logProviderModeChange(provider: .t3chat, field: "cookieSource", value: newValue.rawValue)
+        }
+    }
+}
+
+extension SettingsStore {
+    func t3ChatSettingsSnapshot(
+        tokenOverride: TokenAccountOverride?) -> ProviderSettingsSnapshot.T3ChatProviderSettings
+    {
+        self.resolvedCookieSettings(
+            provider: .t3chat,
+            configuredSource: self.t3ChatCookieSource,
+            configuredHeader: self.t3ChatCookieHeader,
+            tokenOverride: tokenOverride)
+    }
+}
diff --git a/Sources/CodexBar/Providers/Venice/VeniceProviderImplementation.swift b/Sources/CodexBar/Providers/Venice/VeniceProviderImplementation.swift
new file mode 100644
index 0000000000..2886d30dd6
--- /dev/null
+++ b/Sources/CodexBar/Providers/Venice/VeniceProviderImplementation.swift
@@ -0,0 +1,27 @@
+import CodexBarCore
+import Foundation
+
+struct VeniceProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .venice
+
+    @MainActor
+    func presentation(context _: ProviderPresentationContext) -> ProviderPresentation {
+        ProviderPresentation { _ in "api" }
+    }
+
+    @MainActor
+    func observeSettings(_: SettingsStore) {}
+
+    @MainActor
+    func isAvailable(context: ProviderAvailabilityContext) -> Bool {
+        if VeniceSettingsReader.apiKey(environment: context.environment) != nil {
+            return true
+        }
+        return !context.settings.tokenAccounts(for: .venice).isEmpty
+    }
+
+    @MainActor
+    func settingsFields(context _: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        []
+    }
+}
diff --git a/Sources/CodexBar/Providers/VertexAI/VertexAILoginFlow.swift b/Sources/CodexBar/Providers/VertexAI/VertexAILoginFlow.swift
index 1f8fe54185..8e8e0ed9f1 100644
--- a/Sources/CodexBar/Providers/VertexAI/VertexAILoginFlow.swift
+++ b/Sources/CodexBar/Providers/VertexAI/VertexAILoginFlow.swift
@@ -7,25 +7,17 @@ extension StatusItemController {
     func runVertexAILoginFlow() async {
         // Show alert with instructions
         let alert = NSAlert()
-        alert.messageText = "Vertex AI Login"
-        alert.informativeText = """
-        To use Vertex AI tracking, you need to authenticate with Google Cloud.
-
-        1. Open Terminal
-        2. Run: gcloud auth application-default login
-        3. Follow the browser prompts to sign in
-        4. Set your project: gcloud config set project PROJECT_ID
-
-        Would you like to open Terminal now?
-        """
+        alert.messageText = L("Vertex AI Login")
+        alert.informativeText = L("vertex_ai_login_instructions")
         alert.alertStyle = .informational
-        alert.addButton(withTitle: "Open Terminal")
-        alert.addButton(withTitle: "Cancel")
+        alert.addButton(withTitle: L("Open Terminal"))
+        alert.addButton(withTitle: L("Cancel"))
 
         let response = alert.runModal()
 
         if response == .alertFirstButtonReturn {
-            Self.openTerminalWithGcloudCommand()
+            self.openTerminal(
+                command: "gcloud auth application-default login --scopes=openid,https://www.googleapis.com/auth/userinfo.email,https://www.googleapis.com/auth/cloud-platform")
         }
 
         // Refresh after user may have logged in
@@ -35,23 +27,4 @@ extension StatusItemController {
             await self.store.refresh()
         }
     }
-
-    private static func openTerminalWithGcloudCommand() {
-        let script = """
-        tell application "Terminal"
-            activate
-            do script "gcloud auth application-default login --scopes=openid,https://www.googleapis.com/auth/userinfo.email,https://www.googleapis.com/auth/cloud-platform"
-        end tell
-        """
-
-        if let appleScript = NSAppleScript(source: script) {
-            var error: NSDictionary?
-            appleScript.executeAndReturnError(&error)
-            if let error {
-                CodexBarLog.logger(LogCategories.terminal).error(
-                    "Failed to open Terminal",
-                    metadata: ["error": String(describing: error)])
-            }
-        }
-    }
 }
diff --git a/Sources/CodexBar/Providers/VertexAI/VertexAIProviderImplementation.swift b/Sources/CodexBar/Providers/VertexAI/VertexAIProviderImplementation.swift
index 0f3b6f82c5..7399d55868 100644
--- a/Sources/CodexBar/Providers/VertexAI/VertexAIProviderImplementation.swift
+++ b/Sources/CodexBar/Providers/VertexAI/VertexAIProviderImplementation.swift
@@ -1,8 +1,6 @@
 import CodexBarCore
-import CodexBarMacroSupport
 import Foundation
 
-@ProviderImplementationRegistration
 struct VertexAIProviderImplementation: ProviderImplementation {
     let id: UsageProvider = .vertexai
     let supportsLoginFlow: Bool = true
diff --git a/Sources/CodexBar/Providers/Warp/WarpProviderImplementation.swift b/Sources/CodexBar/Providers/Warp/WarpProviderImplementation.swift
index e9cb82de9b..97bfcc8680 100644
--- a/Sources/CodexBar/Providers/Warp/WarpProviderImplementation.swift
+++ b/Sources/CodexBar/Providers/Warp/WarpProviderImplementation.swift
@@ -1,9 +1,7 @@
 import AppKit
 import CodexBarCore
-import CodexBarMacroSupport
 import Foundation
 
-@ProviderImplementationRegistration
 struct WarpProviderImplementation: ProviderImplementation {
     let id: UsageProvider = .warp
 
diff --git a/Sources/CodexBar/Providers/Windsurf/WindsurfProviderImplementation.swift b/Sources/CodexBar/Providers/Windsurf/WindsurfProviderImplementation.swift
new file mode 100644
index 0000000000..66ff4fbb3c
--- /dev/null
+++ b/Sources/CodexBar/Providers/Windsurf/WindsurfProviderImplementation.swift
@@ -0,0 +1,104 @@
+import CodexBarCore
+import Foundation
+import SwiftUI
+
+struct WindsurfProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .windsurf
+
+    @MainActor
+    func observeSettings(_ settings: SettingsStore) {
+        _ = settings.windsurfUsageDataSource
+        _ = settings.windsurfCookieSource
+        _ = settings.windsurfCookieHeader
+    }
+
+    @MainActor
+    func settingsSnapshot(context: ProviderSettingsSnapshotContext) -> ProviderSettingsSnapshotContribution? {
+        .windsurf(context.settings.windsurfSettingsSnapshot(tokenOverride: context.tokenOverride))
+    }
+
+    @MainActor
+    func sourceMode(context: ProviderSourceModeContext) -> ProviderSourceMode {
+        switch context.settings.windsurfUsageDataSource {
+        case .auto: .auto
+        case .web: .web
+        case .cli: .cli
+        }
+    }
+
+    @MainActor
+    func settingsPickers(context: ProviderSettingsContext) -> [ProviderSettingsPickerDescriptor] {
+        // Usage source picker
+        let usageBinding = Binding(
+            get: { context.settings.windsurfUsageDataSource.rawValue },
+            set: { raw in
+                context.settings.windsurfUsageDataSource = WindsurfUsageDataSource(rawValue: raw) ?? .auto
+            })
+        let usageOptions = WindsurfUsageDataSource.allCases.map {
+            ProviderSettingsPickerOption(id: $0.rawValue, title: $0.displayName)
+        }
+
+        // Cookie source picker
+        let cookieBinding = Binding(
+            get: { context.settings.windsurfCookieSource.rawValue },
+            set: { raw in
+                context.settings.windsurfCookieSource = ProviderCookieSource(rawValue: raw) ?? .auto
+            })
+        let cookieOptions = ProviderCookieSourceUI.options(
+            allowsOff: true,
+            keychainDisabled: context.settings.debugDisableKeychainAccess)
+
+        let cookieSubtitle: () -> String? = {
+            ProviderCookieSourceUI.subtitle(
+                source: context.settings.windsurfCookieSource,
+                keychainDisabled: context.settings.debugDisableKeychainAccess,
+                auto: "Automatic imports Windsurf session data from Chromium browser localStorage.",
+                manual: "Paste the Windsurf session JSON bundle from localStorage.",
+                off: "Windsurf web API access is disabled.")
+        }
+
+        return [
+            ProviderSettingsPickerDescriptor(
+                id: "windsurf-usage-source",
+                title: "Usage source",
+                subtitle: "Auto falls back to the next source if the preferred one fails.",
+                binding: usageBinding,
+                options: usageOptions,
+                isVisible: nil,
+                onChange: nil,
+                trailingText: {
+                    guard context.settings.windsurfUsageDataSource == .auto else { return nil }
+                    let label = context.store.sourceLabel(for: .windsurf)
+                    return label == "auto" ? nil : label
+                }),
+            ProviderSettingsPickerDescriptor(
+                id: "windsurf-cookie-source",
+                title: "Cookie source",
+                subtitle: "Automatic imports Windsurf session data from Chromium browser localStorage.",
+                dynamicSubtitle: cookieSubtitle,
+                binding: cookieBinding,
+                options: cookieOptions,
+                isVisible: nil,
+                onChange: nil,
+                trailingText: nil),
+        ]
+    }
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "windsurf-cookie-header",
+                title: "",
+                subtitle: "",
+                kind: .secure,
+                placeholder: "Windsurf session JSON bundle",
+                binding: context.stringBinding(\.windsurfCookieHeader),
+                actions: [],
+                isVisible: {
+                    context.settings.windsurfCookieSource == .manual
+                },
+                onActivate: nil),
+        ]
+    }
+}
diff --git a/Sources/CodexBar/Providers/Windsurf/WindsurfSettingsStore.swift b/Sources/CodexBar/Providers/Windsurf/WindsurfSettingsStore.swift
new file mode 100644
index 0000000000..60357ca7af
--- /dev/null
+++ b/Sources/CodexBar/Providers/Windsurf/WindsurfSettingsStore.swift
@@ -0,0 +1,70 @@
+import CodexBarCore
+import Foundation
+
+extension SettingsStore {
+    var windsurfUsageDataSource: WindsurfUsageDataSource {
+        get {
+            let source = self.configSnapshot.providerConfig(for: .windsurf)?.source
+            return Self.windsurfUsageDataSource(from: source)
+        }
+        set {
+            let source: ProviderSourceMode? = switch newValue {
+            case .auto: .auto
+            case .web: .web
+            case .cli: .cli
+            }
+            self.updateProviderConfig(provider: .windsurf) { entry in
+                entry.source = source
+            }
+            self.logProviderModeChange(provider: .windsurf, field: "usageSource", value: newValue.rawValue)
+        }
+    }
+
+    var windsurfCookieSource: ProviderCookieSource {
+        get { self.resolvedCookieSource(provider: .windsurf, fallback: .auto) }
+        set {
+            self.updateProviderConfig(provider: .windsurf) { entry in
+                entry.cookieSource = newValue
+            }
+            self.logProviderModeChange(provider: .windsurf, field: "cookieSource", value: newValue.rawValue)
+        }
+    }
+
+    var windsurfCookieHeader: String {
+        get { self.configSnapshot.providerConfig(for: .windsurf)?.sanitizedCookieHeader ?? "" }
+        set {
+            self.updateProviderConfig(provider: .windsurf) { entry in
+                entry.cookieHeader = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .windsurf, field: "cookieHeader", value: newValue)
+        }
+    }
+}
+
+extension SettingsStore {
+    func windsurfSettingsSnapshot(
+        tokenOverride: TokenAccountOverride?) -> ProviderSettingsSnapshot.WindsurfProviderSettings
+    {
+        let cookieSettings: ProviderSettingsSnapshot.CookieProviderSettings = self.resolvedCookieSettings(
+            provider: .windsurf,
+            configuredSource: self.windsurfCookieSource,
+            configuredHeader: self.windsurfCookieHeader,
+            tokenOverride: tokenOverride)
+        return ProviderSettingsSnapshot.WindsurfProviderSettings(
+            usageDataSource: self.windsurfUsageDataSource,
+            cookieSource: cookieSettings.cookieSource,
+            manualCookieHeader: cookieSettings.manualCookieHeader)
+    }
+
+    private static func windsurfUsageDataSource(from source: ProviderSourceMode?) -> WindsurfUsageDataSource {
+        guard let source else { return .auto }
+        switch source {
+        case .auto, .oauth, .api:
+            return .auto
+        case .web:
+            return .web
+        case .cli:
+            return .cli
+        }
+    }
+}
diff --git a/Sources/CodexBar/Providers/Zai/ZaiProviderImplementation.swift b/Sources/CodexBar/Providers/Zai/ZaiProviderImplementation.swift
index d4bc64a9f5..0ba6c1cb8d 100644
--- a/Sources/CodexBar/Providers/Zai/ZaiProviderImplementation.swift
+++ b/Sources/CodexBar/Providers/Zai/ZaiProviderImplementation.swift
@@ -1,10 +1,8 @@
 import AppKit
 import CodexBarCore
-import CodexBarMacroSupport
 import Foundation
 import SwiftUI
 
-@ProviderImplementationRegistration
 struct ZaiProviderImplementation: ProviderImplementation {
     let id: UsageProvider = .zai
 
diff --git a/Sources/CodexBar/Providers/Zed/ZedProviderImplementation.swift b/Sources/CodexBar/Providers/Zed/ZedProviderImplementation.swift
new file mode 100644
index 0000000000..d7287ea3b7
--- /dev/null
+++ b/Sources/CodexBar/Providers/Zed/ZedProviderImplementation.swift
@@ -0,0 +1,5 @@
+import CodexBarCore
+
+struct ZedProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .zed
+}
diff --git a/Sources/CodexBar/QuotaWarningSettingsViews.swift b/Sources/CodexBar/QuotaWarningSettingsViews.swift
new file mode 100644
index 0000000000..ce37b40f1b
--- /dev/null
+++ b/Sources/CodexBar/QuotaWarningSettingsViews.swift
@@ -0,0 +1,252 @@
+import CodexBarCore
+import SwiftUI
+
+@MainActor
+struct GlobalQuotaWarningSettingsView: View {
+    @Bindable var settings: SettingsStore
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 10) {
+            HStack(spacing: 16) {
+                Toggle(isOn: Binding(
+                    get: { self.settings.quotaWarningWindowEnabled(.session) },
+                    set: { self.settings.setQuotaWarningWindowEnabled(.session, enabled: $0) }))
+                {
+                    Text(L("quota_warning_session_capitalized"))
+                        .font(.footnote)
+                }
+                .toggleStyle(.checkbox)
+
+                Toggle(isOn: Binding(
+                    get: { self.settings.quotaWarningWindowEnabled(.weekly) },
+                    set: { self.settings.setQuotaWarningWindowEnabled(.weekly, enabled: $0) }))
+                {
+                    Text(L("quota_warning_weekly_capitalized"))
+                        .font(.footnote)
+                }
+                .toggleStyle(.checkbox)
+            }
+
+            self.windowThresholdField(.session)
+            self.windowThresholdField(.weekly)
+
+            Toggle(isOn: self.$settings.quotaWarningSoundEnabled) {
+                Text(L("quota_warning_sound"))
+                    .font(.footnote)
+            }
+            .toggleStyle(.checkbox)
+        }
+        .padding(.leading, 20)
+    }
+
+    private func windowThresholdField(_ window: QuotaWarningWindow) -> some View {
+        QuotaWarningThresholdField(
+            title: String(format: L("quota_warning_window_warn_at"), window.localizedCapitalizedDisplayName),
+            subtitle: L("quota_warning_global_threshold_subtitle"),
+            thresholds: { self.settings.quotaWarningThresholds(window) },
+            setThresholds: { self.settings.setQuotaWarningThresholds(window, thresholds: $0) })
+            .disabled(!self.settings.quotaWarningWindowEnabled(window))
+            .opacity(!self.settings.quotaWarningWindowEnabled(window) ? 0.55 : 1)
+    }
+}
+
+@MainActor
+struct ProviderQuotaWarningSettingsView: View {
+    let provider: UsageProvider
+    @Bindable var settings: SettingsStore
+
+    var body: some View {
+        ProviderSettingsSection(title: L("quota_warnings_title")) {
+            Text(L("quota_warning_provider_inherits"))
+                .font(.footnote)
+                .foregroundStyle(.secondary)
+                .fixedSize(horizontal: false, vertical: true)
+
+            self.windowRow(.session)
+            self.windowRow(.weekly)
+        }
+    }
+
+    private func windowRow(_ window: QuotaWarningWindow) -> some View {
+        VStack(alignment: .leading, spacing: 8) {
+            Toggle(isOn: Binding(
+                get: { self.settings.hasQuotaWarningOverride(provider: self.provider, window: window) },
+                set: { isOn in
+                    if isOn {
+                        self.settings.setQuotaWarningOverride(
+                            provider: self.provider,
+                            window: window,
+                            thresholds: self.settings.quotaWarningThresholds(window),
+                            enabled: self.settings.quotaWarningWindowEnabled(window))
+                    } else {
+                        self.settings.setQuotaWarningOverride(
+                            provider: self.provider,
+                            window: window,
+                            thresholds: nil,
+                            enabled: nil)
+                    }
+                })) {
+                    Text(String(format: L("quota_warning_customize_thresholds"), window.localizedDisplayName))
+                        .font(.subheadline.weight(.semibold))
+                }
+                .toggleStyle(.checkbox)
+
+            if self.settings.hasQuotaWarningOverride(provider: self.provider, window: window) {
+                Toggle(isOn: Binding(
+                    get: { self.settings.quotaWarningEnabled(provider: self.provider, window: window) },
+                    set: {
+                        self.settings.setQuotaWarningWindowEnabled(
+                            provider: self.provider,
+                            window: window,
+                            enabled: $0)
+                    })) {
+                        Text(String(format: L("quota_warning_enable_warnings"), window.localizedDisplayName))
+                            .font(.footnote)
+                    }
+                    .toggleStyle(.checkbox)
+                        .padding(.leading, 20)
+
+                if self.settings.quotaWarningEnabled(provider: self.provider, window: window) {
+                    QuotaWarningThresholdField(
+                        title: String(
+                            format: L("quota_warning_window_warn_at"),
+                            window.localizedCapitalizedDisplayName),
+                        subtitle: "",
+                        thresholds: {
+                            self.settings.resolvedQuotaWarningThresholds(provider: self.provider, window: window)
+                        },
+                        setThresholds: {
+                            self.settings.setQuotaWarningThresholds(
+                                provider: self.provider,
+                                window: window,
+                                thresholds: $0)
+                        })
+                        .padding(.leading, 20)
+                } else {
+                    Text(L("quota_warning_off"))
+                        .font(.footnote)
+                        .foregroundStyle(.secondary)
+                        .padding(.leading, 20)
+                }
+            } else {
+                Text(String(format: L("quota_warning_inherited"), Self.thresholdText(
+                    self.settings.quotaWarningThresholds(window),
+                    enabled: self.settings.quotaWarningWindowEnabled(window))))
+                    .font(.footnote)
+                    .foregroundStyle(.secondary)
+                    .padding(.leading, 20)
+            }
+        }
+    }
+
+    private static func thresholdText(_ thresholds: [Int], enabled: Bool) -> String {
+        guard enabled else { return L("quota_warning_off") }
+        let text = QuotaWarningThresholds.active(thresholds).map { "\($0)%" }.joined(separator: ", ")
+        return text.isEmpty ? L("quota_warning_depleted_only") : text
+    }
+}
+
+extension QuotaWarningWindow {
+    fileprivate var localizedDisplayName: String {
+        switch self {
+        case .session: L("quota_warning_session")
+        case .weekly: L("quota_warning_weekly")
+        }
+    }
+
+    fileprivate var localizedCapitalizedDisplayName: String {
+        switch self {
+        case .session: L("quota_warning_session_capitalized")
+        case .weekly: L("quota_warning_weekly_capitalized")
+        }
+    }
+}
+
+@MainActor
+private struct QuotaWarningThresholdField: View {
+    let title: String
+    let subtitle: String
+    let thresholds: () -> [Int]
+    let setThresholds: ([Int]) -> Void
+
+    @State private var upperText: String = ""
+    @State private var lowerText: String = ""
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 6) {
+            HStack(alignment: .firstTextBaseline, spacing: 10) {
+                Text(self.title)
+                    .font(.footnote.weight(.semibold))
+                    .frame(width: 110, alignment: .leading)
+
+                Text(L("quota_warning_upper"))
+                    .font(.footnote)
+                    .foregroundStyle(.secondary)
+
+                TextField("50", text: self.$upperText)
+                    .textFieldStyle(.roundedBorder)
+                    .font(.footnote)
+                    .frame(width: 56)
+                    .onChange(of: self.upperText) { _, value in
+                        self.upperText = Self.filteredIntegerText(value)
+                    }
+                    .onSubmit { self.commit() }
+
+                Text(L("quota_warning_lower"))
+                    .font(.footnote)
+                    .foregroundStyle(.secondary)
+
+                TextField("20", text: self.$lowerText)
+                    .textFieldStyle(.roundedBorder)
+                    .font(.footnote)
+                    .frame(width: 56)
+                    .onChange(of: self.lowerText) { _, value in
+                        self.lowerText = Self.filteredIntegerText(value)
+                    }
+                    .onSubmit { self.commit() }
+
+                Button(L("apply")) { self.commit() }
+                    .controlSize(.small)
+            }
+
+            if !self.subtitle.isEmpty {
+                Text(self.subtitle)
+                    .font(.footnote)
+                    .foregroundStyle(.secondary)
+                    .fixedSize(horizontal: false, vertical: true)
+            }
+        }
+        .onAppear { self.updateText(from: self.thresholds()) }
+        .onChange(of: self.thresholds()) { _, value in
+            self.updateText(from: value)
+        }
+    }
+
+    private func commit() {
+        let sanitized = QuotaWarningThresholds.resolved(
+            upper: Self.integer(from: self.upperText),
+            lower: Self.integer(from: self.lowerText))
+        self.updateText(from: sanitized)
+        self.setThresholds(sanitized)
+    }
+
+    private func updateText(from thresholds: [Int]) {
+        let pair = Self.pair(from: thresholds)
+        self.upperText = pair.upper.map(String.init) ?? ""
+        self.lowerText = pair.lower.map(String.init) ?? ""
+    }
+
+    private static func pair(from thresholds: [Int]) -> (upper: Int?, lower: Int?) {
+        let sanitized = QuotaWarningThresholds.sanitized(thresholds)
+        return (sanitized.first, sanitized.dropFirst().first)
+    }
+
+    private static func integer(from text: String) -> Int? {
+        guard !text.isEmpty else { return nil }
+        return Int(text)
+    }
+
+    private static func filteredIntegerText(_ text: String) -> String {
+        String(text.filter(\.isNumber).prefix(2))
+    }
+}
diff --git a/Sources/CodexBar/Resources/ProviderIcon-abacus.svg b/Sources/CodexBar/Resources/ProviderIcon-abacus.svg
new file mode 100644
index 0000000000..468bb3dfe4
--- /dev/null
+++ b/Sources/CodexBar/Resources/ProviderIcon-abacus.svg
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="100" height="100" viewBox="0 0 100 100" fill="none" xmlns="http://www.w3.org/2000/svg">
+    <!-- Abacus AI logo: stylized vertical lines with dots -->
+    <g transform="translate(15, 10)">
+        <!-- Vertical lines -->
+        <rect x="0" y="0" width="4" height="80" rx="2" fill="white"/>
+        <rect x="17.5" y="0" width="4" height="80" rx="2" fill="white"/>
+        <rect x="35" y="0" width="4" height="80" rx="2" fill="white"/>
+        <rect x="52.5" y="0" width="4" height="80" rx="2" fill="white"/>
+        <rect x="66" y="0" width="4" height="80" rx="2" fill="white"/>
+        <!-- Dots on the lines (beads on an abacus) -->
+        <circle cx="2" cy="20" r="7" fill="white"/>
+        <circle cx="19.5" cy="45" r="7" fill="white"/>
+        <circle cx="37" cy="30" r="7" fill="white"/>
+        <circle cx="54.5" cy="60" r="7" fill="white"/>
+        <circle cx="68" cy="40" r="7" fill="white"/>
+    </g>
+</svg>
diff --git a/Sources/CodexBar/Resources/ProviderIcon-alibaba.svg b/Sources/CodexBar/Resources/ProviderIcon-alibaba.svg
new file mode 100644
index 0000000000..dce0fb9dab
--- /dev/null
+++ b/Sources/CodexBar/Resources/ProviderIcon-alibaba.svg
@@ -0,0 +1,3 @@
+<svg width="200" height="200" viewBox="0 0 200 200" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path fill-rule="evenodd" clip-rule="evenodd" d="M174.82 108.75L155.38 75L165.64 57.75C166.46 56.31 166.46 54.53 165.64 53.09L155.38 35.84C154.86 34.91 153.87 34.33 152.78 34.33H114.88L106.14 19.03C105.62 18.1 104.63 17.52 103.54 17.52H83.3C82.21 17.52 81.22 18.1 80.7 19.03L61.26 52.77H41.02C39.93 52.77 38.94 53.35 38.42 54.28L28.16 71.53C27.34 72.97 27.34 74.75 28.16 76.19L45.52 107.5L36.78 122.8C35.96 124.24 35.96 126.02 36.78 127.46L47.04 144.71C47.56 145.64 48.55 146.22 49.64 146.22H87.54L96.28 161.52C96.8 162.45 97.79 163.03 98.88 163.03H119.12C120.21 163.03 121.2 162.45 121.72 161.52L141.16 127.78H158.52C159.61 127.78 160.6 127.2 161.12 126.27L171.38 109.02C172.2 107.58 172.2 105.8 171.38 104.36L174.82 108.75ZM127.86 79.83H76.14L101.18 122.11L127.86 79.83Z" fill="#111111"/>
+</svg>
diff --git a/Sources/CodexBar/Resources/ProviderIcon-bedrock.svg b/Sources/CodexBar/Resources/ProviderIcon-bedrock.svg
new file mode 100644
index 0000000000..01dd2f59f4
--- /dev/null
+++ b/Sources/CodexBar/Resources/ProviderIcon-bedrock.svg
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="100" height="100" viewBox="0 0 100 100" version="1.1" xmlns="http://www.w3.org/2000/svg">
+    <g stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+        <g transform="scale(2, 2)" fill="#FFFFFF">
+            <path d="M41,20.9998818 C40.448,20.9998818 40,20.5508818 40,19.9998818 C40,19.4488818 40.448,18.9998818 41,18.9998818 C41.552,18.9998818 42,19.4488818 42,19.9998818 C42,20.5508818 41.552,20.9998818 41,20.9998818 L41,20.9998818 Z M16.977,41.8478818 L13.774,40.1018818 L17.515,37.8568818 L16.485,36.1428818 L11.738,38.9908818 L7,36.4058818 L7,30.5658818 L11.515,27.8568818 L10.485,26.1428818 L6,28.8338818 L2,26.4338818 L2,22.6178818 L7.447,19.8948818 L6.553,18.1048818 L2,20.3818818 L2,17.6178818 L6.956,15.1398818 L11,17.5658818 L11,20.3818818 L7.553,22.1048818 L8.447,23.8948818 L12.003,22.1168818 L15.557,23.8768818 L16.443,22.0848818 L13,20.3798818 L13,17.5658818 L17.515,14.8568818 C17.815,14.6768818 18,14.3508818 18,13.9998818 L18,8.99988178 L16,8.99988178 L16,13.4338818 L12,15.8338818 L8,13.4338818 L8,6.58788178 L11,4.92188178 L11,10.9998818 L13,10.9998818 L13,3.81088178 L16.024,2.12988178 L21.002,4.61588178 L21.001,26.4498818 L10.463,33.1558818 L11.537,34.8438818 L21.001,28.8218818 L21,39.4338818 L16.977,41.8478818 Z M38,28.9998818 C38.552,28.9998818 39,29.4488818 39,29.9998818 C39,30.5508818 38.552,30.9998818 38,30.9998818 C37.448,30.9998818 37,30.5508818 37,29.9998818 C37,29.4488818 37.448,28.9998818 38,28.9998818 L38,28.9998818 Z M30,38.9998818 C29.448,38.9998818 29,38.5508818 29,37.9998818 C29,37.4488818 29.448,36.9998818 30,36.9998818 C30.552,36.9998818 31,37.4488818 31,37.9998818 C31,38.5508818 30.552,38.9998818 30,38.9998818 L30,38.9998818 Z M32,5.99988178 C32.552,5.99988178 33,6.44888178 33,6.99988178 C33,7.55088178 32.552,7.99988178 32,7.99988178 C31.448,7.99988178 31,7.55088178 31,6.99988178 C31,6.44888178 31.448,5.99988178 32,5.99988178 L32,5.99988178 Z M41,16.9998818 C39.698,16.9998818 38.598,17.8388818 38.184,18.9998818 L23.001,18.9998818 L23.001,14.9998818 L32,14.9998818 C32.553,14.9998818 33,14.5518818 33,13.9998818 L33,9.81588178 C34.161,9.40188178 35,8.30188178 35,6.99988178 C35,5.34588178 33.654,3.99988178 32,3.99988178 C30.346,3.99988178 29,5.34588178 29,6.99988178 C29,8.30188178 29.839,9.40188178 31,9.81588178 L31,12.9998818 L23.001,12.9998818 L23.002,3.99788178 C23.002,3.61888178 22.788,3.27288178 22.449,3.10388178 L16.447,0.104881781 C16.151,-0.0421182195 15.803,-0.0341182195 15.515,0.125881781 L6.515,5.12588178 C6.197,5.30188178 6,5.63688178 6,5.99988178 L6,13.3818818 L0.553,16.1048818 C0.214,16.2748818 0,16.6208818 0,16.9998818 L0,26.9998818 C0,27.3508818 0.185,27.6768818 0.485,27.8568818 L5,30.5658818 L5,36.9998818 C5,37.3658818 5.2,37.7028818 5.521,37.8778818 L16.521,43.8778818 C16.671,43.9588818 16.835,43.9998818 17,43.9998818 C17.179,43.9998818 17.356,43.9518818 17.515,43.8568818 L22.515,40.8568818 C22.815,40.6768818 23,40.3508818 23,39.9998818 L23,32.9998818 L29,32.9998818 L29,35.1838818 C27.839,35.5978818 27,36.6978818 27,37.9998818 C27,39.6538818 28.346,40.9998818 30,40.9998818 C31.654,40.9998818 33,39.6538818 33,37.9998818 C33,36.6978818 32.161,35.5978818 31,35.1838818 L31,31.9998818 C31,31.4478818 30.553,30.9998818 30,30.9998818 L23,30.9998818 L23.001,26.9998818 L33.586,26.9998818 L35.301,28.7148818 C35.113,29.1058818 35,29.5378818 35,29.9998818 C35,31.6538818 36.346,32.9998818 38,32.9998818 C39.654,32.9998818 41,31.6538818 41,29.9998818 C41,28.3458818 39.654,26.9998818 38,26.9998818 C37.538,26.9998818 37.106,27.1128818 36.715,27.3008818 L34.707,25.2928818 C34.52,25.1048818 34.266,24.9998818 34,24.9998818 L23.001,24.9998818 L23.001,20.9998818 L38.184,20.9998818 C38.598,22.1608818 39.698,22.9998818 41,22.9998818 C42.654,22.9998818 44,21.6538818 44,19.9998818 C44,18.3458818 42.654,16.9998818 41,16.9998818 L41,16.9998818 Z" />
+        </g>
+    </g>
+</svg>
diff --git a/Sources/CodexBar/Resources/ProviderIcon-chutes.svg b/Sources/CodexBar/Resources/ProviderIcon-chutes.svg
new file mode 100644
index 0000000000..f30860b1a4
--- /dev/null
+++ b/Sources/CodexBar/Resources/ProviderIcon-chutes.svg
@@ -0,0 +1,6 @@
+<svg viewBox="0 0 32 32" fill="currentColor" xmlns="http://www.w3.org/2000/svg">
+  <path d="M16 3c-6.1 0-11 4.9-11 11h5c0-3.3 2.7-6 6-6s6 2.7 6 6h5c0-6.1-4.9-11-11-11Z"/>
+  <path d="M11 14h10l-5 8-5-8Z"/>
+  <path d="M15 21h2v5h-2v-5Z"/>
+  <path d="M11 26h10v3H11v-3Z"/>
+</svg>
diff --git a/Sources/CodexBar/Resources/ProviderIcon-codebuff.svg b/Sources/CodexBar/Resources/ProviderIcon-codebuff.svg
new file mode 100644
index 0000000000..6d5f9e4550
--- /dev/null
+++ b/Sources/CodexBar/Resources/ProviderIcon-codebuff.svg
@@ -0,0 +1,4 @@
+<svg width="100" height="100" viewBox="0 0 100 100" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path fill-rule="evenodd" clip-rule="evenodd" d="M50 8L12 28V72L50 92L88 72V28L50 8ZM50 22.5L74 35.25V64.75L50 77.5L26 64.75V35.25L50 22.5Z" fill="#44FF00"/>
+  <path d="M50 40L61 46V54L50 60L39 54V46L50 40Z" fill="#44FF00"/>
+</svg>
diff --git a/Sources/CodexBar/Resources/ProviderIcon-commandcode.svg b/Sources/CodexBar/Resources/ProviderIcon-commandcode.svg
new file mode 100644
index 0000000000..eb48c4358a
--- /dev/null
+++ b/Sources/CodexBar/Resources/ProviderIcon-commandcode.svg
@@ -0,0 +1,3 @@
+<svg width="100" height="100" viewBox="0 0 100 100" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path d="M38 38H27C20.925 38 16 33.075 16 27C16 20.925 20.925 16 27 16C33.075 16 38 20.925 38 27V73C38 79.075 33.075 84 27 84C20.925 84 16 79.075 16 73C16 66.925 20.925 62 27 62H73C79.075 62 84 66.925 84 73C84 79.075 79.075 84 73 84C66.925 84 62 79.075 62 73V27C62 20.925 66.925 16 73 16C79.075 16 84 20.925 84 27C84 33.075 79.075 38 73 38H38V62" stroke="white" stroke-width="9" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>
diff --git a/Sources/CodexBar/Resources/ProviderIcon-crof.svg b/Sources/CodexBar/Resources/ProviderIcon-crof.svg
new file mode 100644
index 0000000000..fdde018b8f
--- /dev/null
+++ b/Sources/CodexBar/Resources/ProviderIcon-crof.svg
@@ -0,0 +1,3 @@
+<svg width="100" height="100" viewBox="0 0 100 100" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path d="M44.2 8.5H82.4C85.6 8.5 88.1 11.1 87.8 14.2C87.7 15.5 87.2 16.7 86.4 17.8L73.3 35.5C69.7 40.3 64.1 43.1 58.1 43.1H28.1L40.2 60.1H68.4C72.8 60.1 76.9 62.1 79.6 65.6L88.2 76.9C89.8 79.1 89.7 82.1 87.8 84.2C86.6 85.5 84.9 86.3 83.1 86.3H45.1C36.5 86.3 28.5 82.1 23.6 75L8.9 53.6C5.2 48.2 5.3 41 9.2 35.7L20.6 20.1C26.1 12.8 34.8 8.5 44.2 8.5ZM28.1 43.1H15.4C13.5 43.1 12.4 45.2 13.5 46.8L27.3 66.9C31.3 72.8 38 76.3 45.1 76.3H75L68.6 68.1C67.2 66.3 65.1 65.2 62.8 65.2H38.6C34.4 65.2 30.5 63.2 28.1 59.8L19.7 48.1C18.2 45.9 19.8 43.1 22.5 43.1H28.1Z" fill="white"/>
+</svg>
diff --git a/Sources/CodexBar/Resources/ProviderIcon-deepgram.svg b/Sources/CodexBar/Resources/ProviderIcon-deepgram.svg
new file mode 100644
index 0000000000..a72ab7db15
--- /dev/null
+++ b/Sources/CodexBar/Resources/ProviderIcon-deepgram.svg
@@ -0,0 +1,4 @@
+<svg viewBox="0 0 32 32" fill="currentColor" xmlns="http://www.w3.org/2000/svg">
+  <path d="M6 9h3v14H6V9Zm6-4h3v22h-3V5Zm6 7h3v8h-3v-8Zm6-3h3v14h-3V9Z"/>
+  <path d="M4 26h24v2H4v-2Z" opacity=".35"/>
+</svg>
diff --git a/Sources/CodexBar/Resources/ProviderIcon-deepseek.svg b/Sources/CodexBar/Resources/ProviderIcon-deepseek.svg
new file mode 100644
index 0000000000..72020f9ad3
--- /dev/null
+++ b/Sources/CodexBar/Resources/ProviderIcon-deepseek.svg
@@ -0,0 +1,3 @@
+<svg viewBox="3.5 5.5 24.8 20" fill="currentColor" xmlns="http://www.w3.org/2000/svg">
+  <path fill-rule="nonzero" d="M27.501 8.46875C27.249 8.3457 27.1406 8.58008 26.9932 8.69922C26.9434 8.73828 26.9004 8.78906 26.8584 8.83398C26.4902 9.22852 26.0605 9.48633 25.5 9.45508C24.6787 9.41016 23.9785 9.66797 23.3594 10.2969C23.2275 9.52148 22.79 9.05859 22.125 8.76172C21.7764 8.60742 21.4238 8.45312 21.1807 8.11719C21.0098 7.87891 20.9639 7.61328 20.8779 7.35156C20.8242 7.19336 20.7695 7.03125 20.5879 7.00391C20.3906 6.97266 20.3135 7.13867 20.2363 7.27734C19.9258 7.84375 19.8066 8.46875 19.8174 9.10156C19.8447 10.5234 20.4453 11.6562 21.6367 12.4629C21.7725 12.5547 21.8076 12.6484 21.7646 12.7832C21.6836 13.0605 21.5869 13.3301 21.501 13.6074C21.4473 13.7852 21.3662 13.8242 21.1768 13.7461C20.5225 13.4727 19.957 13.0684 19.458 12.5781C18.6104 11.7578 17.8438 10.8516 16.8877 10.1426C16.6631 9.97656 16.4395 9.82227 16.207 9.67578C15.2314 8.72656 16.335 7.94727 16.5898 7.85547C16.8574 7.75977 16.6826 7.42773 15.8193 7.43164C14.957 7.43555 14.167 7.72461 13.1611 8.10938C13.0137 8.16797 12.8594 8.21094 12.7002 8.24414C11.7871 8.07227 10.8389 8.0332 9.84766 8.14453C7.98242 8.35352 6.49219 9.23633 5.39648 10.7441C4.08105 12.5547 3.77148 14.6133 4.15039 16.7617C4.54883 19.0234 5.70215 20.8984 7.47559 22.3633C9.31348 23.8809 11.4307 24.625 13.8457 24.4824C15.3125 24.3984 16.9463 24.2012 18.7881 22.6406C19.2529 22.8711 19.7402 22.9629 20.5498 23.0332C21.1729 23.0918 21.7725 23.002 22.2373 22.9062C22.9648 22.752 22.9141 22.0781 22.6514 21.9531C20.5186 20.959 20.9863 21.3633 20.5605 21.0371C21.6445 19.752 23.2783 18.418 23.917 14.0977C23.9668 13.7539 23.9238 13.5391 23.917 13.2598C23.9131 13.0918 23.9512 13.0254 24.1445 13.0059C24.6787 12.9453 25.1973 12.7988 25.6738 12.5352C27.0557 11.7793 27.6123 10.5391 27.7441 9.05078C27.7637 8.82422 27.7402 8.58789 27.501 8.46875ZM15.46 21.8613C13.3926 20.2344 12.3906 19.6992 11.9766 19.7227C11.5898 19.7441 11.6592 20.1875 11.7441 20.4766C11.833 20.7617 11.9492 20.959 12.1123 21.209C12.2246 21.375 12.3018 21.623 12 21.8066C11.334 22.2207 10.1768 21.668 10.1221 21.6406C8.77539 20.8477 7.64941 19.7988 6.85547 18.3652C6.08984 16.9844 5.64453 15.5039 5.57129 13.9238C5.55176 13.541 5.66406 13.4062 6.04297 13.3379C6.54199 13.2461 7.05762 13.2266 7.55664 13.2988C9.66602 13.6074 11.4619 14.5527 12.9668 16.0469C13.8262 16.9004 14.4766 17.918 15.1465 18.9121C15.8584 19.9688 16.625 20.9746 17.6006 21.7988C17.9443 22.0879 18.2197 22.3086 18.4824 22.4707C17.6895 22.5586 16.3652 22.5781 15.46 21.8613ZM16.4502 15.4805C16.4502 15.3105 16.5859 15.1758 16.7568 15.1758C16.7949 15.1758 16.8301 15.1836 16.8613 15.1953C16.9033 15.2109 16.9424 15.2344 16.9727 15.2695C17.0273 15.3223 17.0586 15.4004 17.0586 15.4805C17.0586 15.6504 16.9229 15.7852 16.7529 15.7852C16.582 15.7852 16.4502 15.6504 16.4502 15.4805ZM19.5273 17.0625C19.3301 17.1426 19.1328 17.2129 18.9434 17.2207C18.6494 17.2344 18.3281 17.1152 18.1533 16.9688C17.8828 16.7422 17.6895 16.6152 17.6074 16.2168C17.5732 16.0469 17.5928 15.7852 17.623 15.6348C17.6934 15.3105 17.6152 15.1035 17.3877 14.9141C17.2012 14.7598 16.9658 14.7188 16.7061 14.7188C16.6094 14.7188 16.5205 14.6758 16.4541 14.6406C16.3457 14.5859 16.2568 14.4512 16.3418 14.2852C16.3691 14.2324 16.501 14.1016 16.5322 14.0781C16.8838 13.877 17.29 13.9434 17.666 14.0938C18.0146 14.2363 18.2773 14.498 18.6562 14.8672C19.0439 15.3145 19.1133 15.4395 19.334 15.7734C19.5078 16.0371 19.667 16.3066 19.7754 16.6152C19.8408 16.8066 19.7559 16.9648 19.5273 17.0625Z"/>
+</svg>
diff --git a/Sources/CodexBar/Resources/ProviderIcon-devin.svg b/Sources/CodexBar/Resources/ProviderIcon-devin.svg
new file mode 100644
index 0000000000..e2b1cd5f67
--- /dev/null
+++ b/Sources/CodexBar/Resources/ProviderIcon-devin.svg
@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
+  <path fill="currentColor" d="M12 2.25c1.18 0 2.18.76 2.54 1.82a8.1 8.1 0 0 1 2.04.85 2.68 2.68 0 0 1 3.08.5 2.68 2.68 0 0 1 .5 3.08c.4.64.69 1.33.85 2.04A2.68 2.68 0 0 1 22.75 13c0 1.18-.76 2.18-1.82 2.54a8.1 8.1 0 0 1-.85 2.04 2.68 2.68 0 0 1-.5 3.08 2.68 2.68 0 0 1-3.08.5 8.1 8.1 0 0 1-2.04.85A2.68 2.68 0 0 1 12 23.75a2.68 2.68 0 0 1-2.54-1.82 8.1 8.1 0 0 1-2.04-.85 2.68 2.68 0 0 1-3.08-.5 2.68 2.68 0 0 1-.5-3.08 8.1 8.1 0 0 1-.85-2.04A2.68 2.68 0 0 1 1.25 13c0-1.18.76-2.18 1.82-2.54.16-.71.45-1.4.85-2.04a2.68 2.68 0 0 1 .5-3.08 2.68 2.68 0 0 1 3.08-.5c.64-.4 1.33-.69 2.04-.85A2.68 2.68 0 0 1 12 2.25Zm0 3.5a6.25 6.25 0 1 0 0 12.5 6.25 6.25 0 0 0 0-12.5Zm0 3.25a3 3 0 1 1 0 6 3 3 0 0 1 0-6Z"/>
+</svg>
diff --git a/Sources/CodexBar/Resources/ProviderIcon-doubao.svg b/Sources/CodexBar/Resources/ProviderIcon-doubao.svg
new file mode 100644
index 0000000000..9c20430a1c
--- /dev/null
+++ b/Sources/CodexBar/Resources/ProviderIcon-doubao.svg
@@ -0,0 +1 @@
+<svg fill="currentColor" fill-rule="evenodd" height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>Doubao</title><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 1.5c4.69 0 8.5 3.81 8.5 8.5s-3.81 8.5-8.5 8.5S3.5 16.69 3.5 12 7.31 3.5 12 3.5zm-3 5a1.5 1.5 0 100 3 1.5 1.5 0 000-3zm6 0a1.5 1.5 0 100 3 1.5 1.5 0 000-3zM8 15a4 4 0 008 0H8z"/></svg>
diff --git a/Sources/CodexBar/Resources/ProviderIcon-elevenlabs.svg b/Sources/CodexBar/Resources/ProviderIcon-elevenlabs.svg
new file mode 100644
index 0000000000..338e42b284
--- /dev/null
+++ b/Sources/CodexBar/Resources/ProviderIcon-elevenlabs.svg
@@ -0,0 +1,4 @@
+<svg viewBox="0 0 32 32" fill="currentColor" xmlns="http://www.w3.org/2000/svg">
+  <path d="M7 6h4v20H7V6Zm7 0h4v20h-4V6Zm7 0h4v20h-4V6Z"/>
+  <path d="M3.5 15h25v2h-25v-2Z" opacity=".35"/>
+</svg>
diff --git a/Sources/CodexBar/Resources/ProviderIcon-grok.svg b/Sources/CodexBar/Resources/ProviderIcon-grok.svg
new file mode 100644
index 0000000000..876acc82c2
--- /dev/null
+++ b/Sources/CodexBar/Resources/ProviderIcon-grok.svg
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="100" height="100" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg" fill="none">
+    <path fill="#FFFFFF" fill-rule="evenodd" d="M9.27 15.29l7.978-5.897c.391-.29.95-.177 1.137.272.98 2.369.542 5.215-1.41 7.169-1.951 1.954-4.667 2.382-7.149 1.406l-2.711 1.257c3.889 2.661 8.611 2.003 11.562-.953 2.341-2.344 3.066-5.539 2.388-8.42l.006.007c-.983-4.232.242-5.924 2.75-9.383.06-.082.12-.164.179-.248l-3.301 3.305v-.01L9.267 15.292M7.623 16.723c-2.792-2.67-2.31-6.801.071-9.184 1.761-1.763 4.647-2.483 7.166-1.425l2.705-1.25a7.808 7.808 0 00-1.829-1A8.975 8.975 0 005.984 5.83c-2.533 2.536-3.33 6.436-1.962 9.764 1.022 2.487-.653 4.246-2.34 6.022-.599.63-1.199 1.259-1.682 1.925l7.62-6.815"/>
+</svg>
diff --git a/Sources/CodexBar/Resources/ProviderIcon-groq.svg b/Sources/CodexBar/Resources/ProviderIcon-groq.svg
new file mode 100644
index 0000000000..4b283c370d
--- /dev/null
+++ b/Sources/CodexBar/Resources/ProviderIcon-groq.svg
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="100" height="100" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg" fill="none">
+    <path fill="#FFFFFF" d="M12.036 2c-3.853-.035-7 3-7.036 6.781-.035 3.782 3.055 6.872 6.908 6.907h2.42v-2.566h-2.292c-2.407.028-4.38-1.866-4.408-4.23-.029-2.362 1.901-4.298 4.308-4.326h.1c2.407 0 4.358 1.915 4.365 4.278v6.305c0 2.342-1.944 4.25-4.323 4.279a4.375 4.375 0 01-3.033-1.252l-1.851 1.818A7 7 0 0012.029 22h.092c3.803-.056 6.858-3.083 6.879-6.816v-6.5C18.907 4.963 15.817 2 12.036 2z"/>
+</svg>
diff --git a/Sources/CodexBar/Resources/ProviderIcon-kimi.svg b/Sources/CodexBar/Resources/ProviderIcon-kimi.svg
index 03dee9305c..77cba2eacd 100644
--- a/Sources/CodexBar/Resources/ProviderIcon-kimi.svg
+++ b/Sources/CodexBar/Resources/ProviderIcon-kimi.svg
@@ -1 +1 @@
-<svg fill="currentColor" fill-rule="evenodd" height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>Kimi</title><path d="M21.7202 0.939941C22.9502 0.939941 23.9502 1.93994 23.9502 3.16994C23.9502 4.39994 22.9502 5.39994 21.7202 5.39994H19.7502C19.6002 5.39994 19.4902 5.27994 19.4902 5.13994V3.16994C19.4902 1.93994 20.4902 0.939941 21.7202 0.939941ZM9.39 13.9501L17.82 5.59012C17.98 5.43012 17.89 5.12012 17.68 5.12012H13.14C13.14 5.12012 13.04 5.14012 13 5.18012L3.92 14.1901C3.78 14.3301 3.57 14.2101 3.57 13.9801V5.39012C3.57 5.24012 3.47 5.12012 3.35 5.12012H0.219999C0.0999993 5.12012 0 5.24012 0 5.39012V23.9201C0 24.0701 0.0999993 24.1901 0.219999 24.1901H3.35C3.47 24.1901 3.57 24.0701 3.57 23.9201V20.1401C3.57 20.0601 3.6 19.9801 3.65 19.9301L6.47 17.1401C6.54 17.0701 6.63 17.0601 6.71 17.1101L14.24 22.6501C15.47 23.4801 16.85 23.9901 18.25 24.1401C18.37 24.1501 18.48 24.0301 18.48 23.8701V20.3101C18.48 20.1701 18.4 20.0601 18.29 20.0501C17.47 19.9201 16.66 19.6001 15.94 19.1101L9.42 14.3901C9.28 14.3001 9.27 14.0701 9.39 13.9501Z"/></svg>
+<svg fill="currentColor" fill-rule="evenodd" height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>Kimi</title><path transform="translate(0 -0.56)" d="M21.7202 0.939941C22.9502 0.939941 23.9502 1.93994 23.9502 3.16994C23.9502 4.39994 22.9502 5.39994 21.7202 5.39994H19.7502C19.6002 5.39994 19.4902 5.27994 19.4902 5.13994V3.16994C19.4902 1.93994 20.4902 0.939941 21.7202 0.939941ZM9.39 13.9501L17.82 5.59012C17.98 5.43012 17.89 5.12012 17.68 5.12012H13.14C13.14 5.12012 13.04 5.14012 13 5.18012L3.92 14.1901C3.78 14.3301 3.57 14.2101 3.57 13.9801V5.39012C3.57 5.24012 3.47 5.12012 3.35 5.12012H0.219999C0.0999993 5.12012 0 5.24012 0 5.39012V23.9201C0 24.0701 0.0999993 24.1901 0.219999 24.1901H3.35C3.47 24.1901 3.57 24.0701 3.57 23.9201V20.1401C3.57 20.0601 3.6 19.9801 3.65 19.9301L6.47 17.1401C6.54 17.0701 6.63 17.0601 6.71 17.1101L14.24 22.6501C15.47 23.4801 16.85 23.9901 18.25 24.1401C18.37 24.1501 18.48 24.0301 18.48 23.8701V20.3101C18.48 20.1701 18.4 20.0601 18.29 20.0501C17.47 19.9201 16.66 19.6001 15.94 19.1101L9.42 14.3901C9.28 14.3001 9.27 14.0701 9.39 13.9501Z"/></svg>
diff --git a/Sources/CodexBar/Resources/ProviderIcon-litellm.svg b/Sources/CodexBar/Resources/ProviderIcon-litellm.svg
new file mode 100644
index 0000000000..3a6c20b880
--- /dev/null
+++ b/Sources/CodexBar/Resources/ProviderIcon-litellm.svg
@@ -0,0 +1,16 @@
+<svg viewBox="0 0 32 32" xmlns="http://www.w3.org/2000/svg">
+  <g fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M8.1 12.4C12.5 8.8 17.7 6.3 22.4 5.7c0-.5.5-.7 1-.8 1.8-.4 4.1-.5 5.8-.5.6 0 1 .4 1 1v19c0 .6-.4 1-1 1H10c-.7 0-1.3 0-1.9-.1V12.4Z" stroke-width="1.35"/>
+    <path d="M8.1 12.4C5 14.8 3 17 2.8 19.2c-.2 1.9 1.8 3.5 5.3 4.5V12.4Z" fill="currentColor" stroke-width="1.35"/>
+    <path d="M10.6 19.5h3.7" stroke-width="1.35"/>
+    <path d="M20.6 25.5l-1.3 2.6c.5.3 1.1.4 1.7.2.9-.2 1.6-1.2 1.7-2.8" stroke-width="1.2"/>
+    <path d="M25.3 25.5c.1 1.8 1.2 3 2.6 3s2.5-1.2 2.6-3" stroke-width="1.2"/>
+    <path d="M25.3 15.5h2.9c.5 0 .9.4.9.9v6.9c0 .5-.4.9-.9.9h-2.9c-.5 0-.9-.4-.9-.9v-6.9c0-.5.4-.9.9-.9Z" stroke-width="1.2"/>
+    <path d="M17.3 22.6h7.1m4.7 0h1.1" stroke-width="1.05"/>
+  </g>
+  <path d="M12.9 13.1c4.2-2.3 8.3-3.5 12.7-3.6.8.2 1.8 1.5 2.4 3.1-5.3.2-10.3.8-15.2 2.6-1.2.4-1.5-1.2.1-2.1Z" fill="currentColor"/>
+  <path d="M20.4 16.5h4v5.4h-6.6l2.6-5.4Z" fill="currentColor"/>
+  <path d="M29.1 16.5h1.1v5.4h-1.1v-5.4Z" fill="currentColor"/>
+  <path d="M10.9 25.5h9.5l-1.6 2.3H10c-.8 0-1.1-.7-.7-1.3l1.6-1Z" fill="currentColor"/>
+  <path d="M25.8 25.5h4c-.1 1.2-.9 2.1-2 2.1s-1.9-.9-2-2.1Z" fill="currentColor"/>
+</svg>
diff --git a/Sources/CodexBar/Resources/ProviderIcon-llmproxy.svg b/Sources/CodexBar/Resources/ProviderIcon-llmproxy.svg
new file mode 100644
index 0000000000..812831dcac
--- /dev/null
+++ b/Sources/CodexBar/Resources/ProviderIcon-llmproxy.svg
@@ -0,0 +1,7 @@
+<svg viewBox="0 0 32 32" fill="currentColor" xmlns="http://www.w3.org/2000/svg">
+  <path d="M7 8.5A5.5 5.5 0 0 1 12.5 3H18v4h-5.5A1.5 1.5 0 0 0 11 8.5V12H7V8.5Z"/>
+  <path d="M25 23.5A5.5 5.5 0 0 1 19.5 29H14v-4h5.5a1.5 1.5 0 0 0 1.5-1.5V20h4v3.5Z"/>
+  <path d="M12 21H8.5A5.5 5.5 0 0 1 3 15.5v-3A5.5 5.5 0 0 1 8.5 7H12v4H8.5A1.5 1.5 0 0 0 7 12.5v3A1.5 1.5 0 0 0 8.5 17H12v4Z"/>
+  <path d="M20 11h3.5A1.5 1.5 0 0 1 25 12.5v3a1.5 1.5 0 0 1-1.5 1.5H20v4h3.5a5.5 5.5 0 0 0 5.5-5.5v-3A5.5 5.5 0 0 0 23.5 7H20v4Z"/>
+  <path d="M10 14h12v4H10v-4Z"/>
+</svg>
diff --git a/Sources/CodexBar/Resources/ProviderIcon-manus.svg b/Sources/CodexBar/Resources/ProviderIcon-manus.svg
new file mode 100644
index 0000000000..fcfd81daf9
--- /dev/null
+++ b/Sources/CodexBar/Resources/ProviderIcon-manus.svg
@@ -0,0 +1,6 @@
+<svg width="60" height="60" viewBox="0 0 60 60" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M9.40053 8.55905C8.88268 9.6224 9.31868 10.9073 10.3744 11.4289C11.8907 12.1781 13.2065 12.9168 14.5094 14.3964C15.2896 15.2825 16.6353 15.3637 17.515 14.5777C18.3947 13.7918 18.4753 12.4364 17.695 11.5503C15.8385 9.44198 13.9275 8.40713 12.2497 7.57813C11.194 7.05652 9.91838 7.49569 9.40053 8.55905Z" fill="#34322D"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M20.9079 2.3149C19.7672 2.60216 19.0736 3.76651 19.3588 4.91555C19.558 5.71831 19.7438 6.40473 19.9139 7.03309C20.2395 8.23578 20.5075 9.22579 20.7019 10.4119C20.8934 11.5804 21.9892 12.3714 23.1493 12.1785C24.3095 11.9856 25.0947 10.8818 24.9032 9.71326C24.6735 8.31142 24.3157 6.98504 23.9566 5.65374C23.7976 5.06422 23.6383 4.47373 23.4898 3.87529C23.2046 2.72625 22.0487 2.02764 20.9079 2.3149Z" fill="#34322D"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M33.0786 3.63426C32.0734 3.01986 30.7639 3.34265 30.154 4.35522C29.0225 6.23356 28.4277 8.08306 27.8752 10.3089C27.59 11.458 28.2836 12.6223 29.4244 12.9096C30.5651 13.1968 31.7211 12.4982 32.0063 11.3492C32.5183 9.28598 32.9881 7.91866 33.7944 6.58017C34.4044 5.5676 34.0839 4.24867 33.0786 3.63426Z" fill="#34322D"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M43.9331 56.6116C48.0617 53.9731 50.9164 39.8228 50.2884 35.6091C50.2884 35.6091 49.634 33.3469 48.0372 33.3468C46.8137 33.3468 46.1377 34.3415 45.8884 34.8067C45.6728 34.7269 45.4533 34.6547 45.2792 34.5985C45.1853 34.5681 45.0537 34.5263 44.9304 34.4871L44.6964 34.4125C44.5053 34.3512 44.3255 34.2922 44.1561 34.2338L44.1566 34.1738C44.164 32.8061 44.025 30.6718 42.6083 28.4481C42.3816 28.0922 42.1677 27.7741 41.9848 27.5042L41.8701 27.3352C41.734 27.1348 41.6272 26.9775 41.5245 26.8205C41.2723 26.4354 41.2034 26.2871 41.1767 26.2187L41.1755 26.2156C41.1651 26.1891 41.1438 26.1351 41.138 25.9704C41.1309 25.7681 41.1481 25.3852 41.2793 24.7155L41.9612 21.9906L41.9637 21.9766C42.0087 21.7265 42.0491 21.5016 42.0711 21.1356C42.0914 20.7986 42.0956 20.3088 42.01 19.7408C41.8478 18.6648 41.2257 16.6253 39.0332 15.4429C38.4974 15.154 37.8556 14.9811 37.2229 14.8983C36.7976 14.8427 36.229 14.8047 35.5687 14.8557C34.2216 14.9597 32.4539 15.4447 30.8803 16.8875L30.4884 17.2997C29.5737 18.4044 28.6076 19.7723 27.8747 20.9829C25.6495 19.9355 23.0302 18.733 21.2001 18.0864C19.1915 17.3769 16.9497 16.7831 14.843 16.8595C12.5099 16.9441 9.88675 17.9222 8.51344 20.6906C7.94928 21.8279 7.70856 23.1561 7.99827 24.5403C8.27511 25.8631 8.95981 26.8748 9.61373 27.5807C10.8279 28.8914 12.4542 29.7033 13.6004 30.1954C14.478 30.5722 15.3797 30.8857 16.178 31.1395C16.0937 31.2921 16.0092 31.4501 15.9278 31.6103C15.6864 32.085 15.3976 32.7201 15.2075 33.4466C15.0179 34.1711 14.8684 35.2035 15.1387 36.368C15.4161 37.5632 15.965 38.4967 16.6189 39.2106C16.5941 39.5819 16.5848 39.9731 16.5986 40.3779C16.6906 43.0818 18.3417 44.8845 19.7939 45.9067C21.1776 46.8806 22.8071 47.4783 24.1246 47.8802C25.3968 48.2683 26.7402 48.5762 27.8317 48.8265L28.0653 48.88C29.2286 49.1473 30.3783 49.4564 31.5285 49.7657C32.833 50.1165 34.1381 50.4674 35.4641 50.7575C35.8978 50.8524 36.3192 50.9432 36.7069 51.0259L36.8481 51.3939C38.5683 55.7897 40.8651 58.5723 43.9331 56.6116ZM28.2156 38.6202C27.9801 38.5246 27.845 38.4612 27.7251 38.4007C26.6832 37.8586 25.4015 38.2672 24.8596 39.3157C24.3165 40.3662 24.723 41.6619 25.7659 42.2088C25.8514 42.2535 25.9381 42.2955 26.0253 42.3366C26.1714 42.4055 26.3749 42.4973 26.6227 42.598C27.1114 42.7965 27.8062 43.0437 28.5938 43.212C29.9917 43.5107 32.5756 43.7384 34.3274 41.716C35.1684 40.7451 35.5727 39.4694 35.7263 38.2766C35.8845 37.0476 35.8056 35.6995 35.4968 34.3874C34.8887 31.8026 33.2785 28.9743 30.272 27.6329C27.6959 26.4835 25.1502 26.2133 23.0033 26.4557C21.57 26.6176 20.2006 27.0239 19.1006 27.6431V27.5954C16.4105 26.8216 11.0571 25.2818 12.3754 22.6242C13.3748 20.6096 16.1129 20.7761 19.8267 22.0881C21.3351 22.621 23.4312 23.5706 25.4084 24.4966C26.0213 24.7836 26.6228 25.0684 27.1918 25.3378C28.0211 25.7305 29.4076 26.3772 29.4076 26.3772C30.9845 24.471 31.5968 23.4209 32.1372 22.4941C32.5089 21.8566 32.8466 21.2775 33.4408 20.5182C34.2818 19.4434 35.6412 18.7792 37.0357 19.1681C38.0076 19.6922 37.7607 21.0159 37.7607 21.0159L37.0852 23.7151C36.4404 26.8915 37.1541 27.9426 38.3305 29.6751C38.5371 29.9793 38.7581 30.3048 38.9884 30.6663C39.9266 32.139 39.8833 33.5552 39.8479 34.711C39.8251 35.4544 39.8057 36.0901 40.0528 36.5639C40.5618 37.5397 42.4666 38.1448 43.7154 38.5415C44.0155 38.6368 44.2777 38.7201 44.4736 38.7936L44.6074 38.8467C44.4314 39.3965 44.2715 39.9656 44.1117 40.5342C43.4013 43.0628 42.6941 45.5801 40.5854 46.3344C37.9241 47.2863 35.2627 46.3856 35.2627 46.3856C34.783 46.2444 34.2945 46.1351 33.806 46.0257C33.1971 45.8894 32.588 45.7531 31.9952 45.555C31.1691 45.2461 30.0119 44.9805 28.7543 44.692C25.7598 44.005 22.1958 43.1872 21.1752 41.3416C21.0033 41.0306 20.9035 40.6906 20.8908 40.317C20.8331 38.6196 21.4235 37.0999 21.4235 37.0999C21.4235 37.0999 20.5079 37.1038 19.8658 36.4816C19.6264 36.2496 19.4251 35.9307 19.3233 35.4922C19.12 34.6163 19.2946 33.3466 20.3591 32.2743L20.8926 31.7384C21.1621 31.4669 21.961 30.8894 23.4778 30.7181C24.9176 30.5555 26.7 30.7302 28.5474 31.5544C29.9644 32.1867 30.9442 33.6372 31.3534 35.3765C31.5534 36.2265 31.5901 37.0517 31.5034 37.725C31.4121 38.4344 31.211 38.7897 31.1188 38.8962C31.0042 39.0285 30.6006 39.2562 29.4775 39.0163C29.0047 38.9152 28.5556 38.7584 28.2156 38.6202Z" fill="#34322D"/>
+</svg>
diff --git a/Sources/CodexBar/Resources/ProviderIcon-mimo.svg b/Sources/CodexBar/Resources/ProviderIcon-mimo.svg
new file mode 100644
index 0000000000..50b1b8e3e4
--- /dev/null
+++ b/Sources/CodexBar/Resources/ProviderIcon-mimo.svg
@@ -0,0 +1,4 @@
+<svg width="24" height="24" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg" fill="none">
+<path d="M5 18V11" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" />
+<path d="M5 5L12 12L19 5V18" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round" />
+</svg>
diff --git a/Sources/CodexBar/Resources/ProviderIcon-mistral.svg b/Sources/CodexBar/Resources/ProviderIcon-mistral.svg
new file mode 100644
index 0000000000..c946b52252
--- /dev/null
+++ b/Sources/CodexBar/Resources/ProviderIcon-mistral.svg
@@ -0,0 +1 @@
+<svg fill="currentColor" fill-rule="evenodd" height="512" style="flex:none;line-height:1" viewBox="0 0 24 24" width="512" xmlns="http://www.w3.org/2000/svg"><title>Mistral</title><path clip-rule="evenodd" d="M3.428 3.4h3.429v3.428h3.429v3.429h-.002 3.431V6.828h3.427V3.4h3.43v13.714H24v3.429H13.714v-3.428h-3.428v-3.429h-3.43v3.428h3.43v3.429H0v-3.429h3.428V3.4zm10.286 13.715h3.428v-3.429h-3.427v3.429z"></path></svg>
diff --git a/Sources/CodexBar/Resources/ProviderIcon-ollama.svg b/Sources/CodexBar/Resources/ProviderIcon-ollama.svg
index 23b80bc53d..92efd117e8 100644
--- a/Sources/CodexBar/Resources/ProviderIcon-ollama.svg
+++ b/Sources/CodexBar/Resources/ProviderIcon-ollama.svg
@@ -1,3 +1,7 @@
-<svg width="28" height="28" viewBox="0 0 28 28" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path fill-rule="evenodd" clip-rule="evenodd" d="M7.25558 0.114339C7.61134 0.222519 7.93252 0.400698 8.22405 0.636149C8.70993 1.0256 9.12005 1.58303 9.433 2.24356C9.74758 2.90792 9.95182 3.64354 10.0292 4.38171C11.0662 3.9284 12.2171 3.65235 13.4041 3.57227L13.4881 3.56718C14.921 3.47809 16.3375 3.6779 17.5728 4.17044C17.7391 4.2379 17.9022 4.31044 18.062 4.3868C18.1443 3.66263 18.3453 2.94355 18.6549 2.29447C18.9678 1.63266 19.378 1.07651 19.8622 0.685785C20.1328 0.459579 20.4638 0.281532 20.8323 0.163974C21.2556 0.0367035 21.7053 0.0137947 22.1434 0.110521C22.8039 0.255609 23.3704 0.578877 23.8168 1.04851C24.2253 1.47739 24.5316 2.0272 24.7408 2.68646C25.1196 3.87517 25.1855 5.43933 24.9302 7.32549L25.0175 7.37639L25.0603 7.40058C26.3072 8.13366 27.1752 9.17855 27.6348 10.3914C28.3512 12.284 27.9905 14.4068 26.7552 15.5943L26.7255 15.621L26.7288 15.6248C27.4157 16.5946 27.8324 17.6192 27.9214 18.6793L27.9246 18.7175C28.0301 20.0729 27.5952 21.4373 26.5839 22.7774L26.5723 22.7902L26.5888 22.8207C27.3663 24.2932 27.6101 25.7759 27.3103 27.2574L27.3004 27.307C27.254 27.5234 27.0983 27.7168 26.8677 27.8446C26.637 27.9724 26.3501 28.0246 26.07 27.9892C25.9312 27.9724 25.7982 27.9347 25.6783 27.8782C25.5585 27.8217 25.4543 27.7474 25.3717 27.6595C25.289 27.572 25.2296 27.4725 25.1968 27.3668C25.164 27.2614 25.1585 27.152 25.1806 27.0448C25.4556 25.7301 25.197 24.4116 24.39 23.0702C24.3147 22.9456 24.2812 22.8083 24.2927 22.671C24.3043 22.5338 24.3604 22.401 24.4559 22.2849L24.4624 22.2773C25.4573 21.1013 25.869 19.9482 25.7801 18.8155C25.7043 17.8241 25.2448 16.8504 24.4624 15.9226C24.3103 15.7423 24.2561 15.5229 24.3115 15.3119C24.367 15.1009 24.5277 14.9152 24.7589 14.795L24.7737 14.7874C25.174 14.585 25.5429 14.0683 25.729 13.3619C25.9344 12.5267 25.8808 11.6658 25.5726 10.8496C25.2349 9.95872 24.6173 9.21546 23.7526 8.70765C22.7726 8.12984 21.4747 7.85111 19.8326 7.9313C19.6178 7.94209 19.4039 7.90286 19.2183 7.81869C19.0327 7.73451 18.8841 7.60927 18.7916 7.45912C18.2744 6.61277 17.5201 6.00696 16.5796 5.63151C15.6767 5.2833 14.6658 5.13696 13.661 5.20897C11.6104 5.33497 9.80194 6.22841 9.26335 7.35476C9.18715 7.51329 9.05009 7.65005 8.87052 7.74673C8.69096 7.84338 8.47747 7.89535 8.25864 7.89566C6.50122 7.8982 5.14075 8.21638 4.14592 8.79037C3.28615 9.28673 2.6998 9.98036 2.39015 10.8114C2.10995 11.5937 2.07158 12.4159 2.27815 13.2118C2.46262 13.9219 2.82333 14.5099 3.23674 14.8268L3.24992 14.8357C3.5991 15.0992 3.67321 15.5103 3.42945 15.8348C2.83651 16.6264 2.39345 17.8062 2.32098 18.9402C2.23862 20.2358 2.62733 21.3609 3.50521 22.1678L3.53157 22.192C3.66406 22.3113 3.74924 22.4576 3.77701 22.6133C3.80475 22.769 3.77385 22.9276 3.68804 23.0702C2.73933 24.6432 2.4478 25.9363 2.76239 26.9545C2.81892 27.1662 2.76631 27.3867 2.61573 27.5687C2.46516 27.7509 2.22851 27.8805 1.95615 27.9299C1.68379 27.9795 1.39724 27.9446 1.15746 27.8334C0.917644 27.7219 0.743586 27.5427 0.672268 27.3337C0.272031 26.0381 0.543797 24.5541 1.45133 22.8818L1.47438 22.8373L1.46121 22.822C1.01515 22.3129 0.682282 21.7498 0.476267 21.156L0.468032 21.1318C0.218008 20.391 0.119645 19.6244 0.176502 18.86C0.248972 17.7019 0.634385 16.5157 1.20097 15.5637L1.22074 15.5306L1.21744 15.5281C0.734856 14.9961 0.377443 14.3152 0.179796 13.5618L0.17156 13.5312C-0.100765 12.4803 -0.0482896 11.3945 0.324737 10.3622C0.756268 9.19764 1.6045 8.19729 2.85462 7.47439C2.95345 7.41712 3.05721 7.35985 3.16098 7.3064C2.89909 5.40624 2.96498 3.8319 3.34545 2.63556C3.55463 1.97629 3.86263 1.42648 4.2711 0.997598C4.71581 0.529242 5.2824 0.205974 5.94287 0.0596123C6.38099 -0.0371136 6.83228 -0.0142049 7.25558 0.114339ZM14.0349 11.6832C15.5765 11.6832 16.9996 12.0816 18.0636 12.7714C19.1013 13.4421 19.7189 14.3432 19.7189 15.2405C19.7189 16.3706 19.0502 17.2513 17.8528 17.8139C16.8316 18.2911 15.4629 18.5228 13.8949 18.5228C12.233 18.5228 10.8132 18.1931 9.78876 17.5886C8.77252 16.9904 8.20264 16.1504 8.20264 15.2405C8.20264 14.3407 8.85817 13.437 9.94194 12.7638C11.0422 12.0803 12.4949 11.6832 14.0349 11.6832ZM14.0349 12.8236C12.8922 12.8159 11.7798 13.1075 10.8791 13.6508C10.1198 14.1217 9.68994 14.7136 9.68994 15.2417C9.68994 15.7865 10.0358 16.2968 10.6946 16.685C11.4441 17.1266 12.5459 17.3824 13.8949 17.3824C15.2109 17.3824 16.321 17.1953 17.077 16.8403C17.8396 16.4839 18.23 15.9672 18.23 15.2405C18.23 14.7021 17.8248 14.1077 17.105 13.6419C16.3078 13.1265 15.2274 12.8236 14.0349 12.8236ZM15.1252 14.3636L15.1318 14.3687C15.3295 14.5608 15.2883 14.8396 15.0396 14.9923L14.5587 15.285V15.8526C14.5578 15.979 14.4921 16.0999 14.376 16.1889C14.2599 16.2779 14.1029 16.3277 13.9394 16.3274C13.7758 16.3277 13.6188 16.2779 13.5027 16.1889C13.3866 16.0999 13.3209 15.979 13.3201 15.8526V15.2672L12.8737 14.9897C12.8148 14.9533 12.7659 14.9082 12.7297 14.857C12.6935 14.8059 12.6707 14.7497 12.6628 14.6917C12.6548 14.6337 12.6618 14.5751 12.6833 14.5192C12.7048 14.4633 12.7404 14.4113 12.7881 14.3661C12.8853 14.2747 13.0253 14.2166 13.1776 14.2044C13.3299 14.1923 13.4824 14.2271 13.6017 14.3012L13.9558 14.5201L14.3182 14.2987C14.4371 14.2261 14.588 14.1922 14.7388 14.2043C14.8896 14.2165 15.0282 14.2736 15.1252 14.3636ZM6.82405 11.9212C7.61134 11.9212 8.25205 12.4176 8.25205 13.0298C8.25248 13.3232 8.10217 13.6048 7.83409 13.8127C7.56602 14.0205 7.20215 14.1376 6.8224 14.1383C6.44321 14.1373 6.08 14.0202 5.81235 13.8127C5.54467 13.6051 5.3944 13.324 5.3944 13.031C5.39351 12.7376 5.54342 12.4559 5.81117 12.2478C6.07895 12.0397 6.4443 11.9223 6.82405 11.9212ZM21.1634 11.9212C21.954 11.9212 22.593 12.4176 22.593 13.0298C22.5935 13.3232 22.4432 13.6048 22.1751 13.8127C21.907 14.0205 21.5431 14.1376 21.1634 14.1383C20.7842 14.1373 20.421 14.0202 20.1533 13.8127C19.8857 13.6051 19.7354 13.324 19.7354 13.031C19.7345 12.7376 19.8844 12.4559 20.1522 12.2478C20.4199 12.0397 20.7836 11.9223 21.1634 11.9212ZM6.48969 1.6543L6.48475 1.65684C6.29392 1.72096 6.131 1.82611 6.01534 1.95975L6.0071 1.96738C5.77981 2.20793 5.58216 2.56174 5.43393 3.02628C5.15392 3.90699 5.07816 5.10206 5.22969 6.56695C5.93793 6.40405 6.7104 6.30223 7.54217 6.26532L7.55864 6.26405L7.58993 6.22077C7.6657 6.11641 7.7464 6.01587 7.8337 5.9166C8.03629 4.93534 7.86993 3.76318 7.41699 2.8061C7.19628 2.34283 6.92781 1.97884 6.67087 1.77139C6.61783 1.72827 6.55871 1.68986 6.49463 1.65684L6.48969 1.6543ZM21.5999 1.70521L21.5966 1.70648C21.5325 1.73949 21.4734 1.7779 21.4203 1.82102C21.1634 2.02847 20.8933 2.39374 20.6742 2.85701C20.1966 3.86754 20.0368 5.11734 20.2954 6.13041L20.3909 6.25387L20.4041 6.27168H20.4535C21.2709 6.27186 22.0841 6.36273 22.8681 6.5415C23.0097 5.11097 22.9307 3.94136 22.6573 3.07719C22.509 2.61265 22.3114 2.25883 22.0824 2.01829L22.0759 2.01066C21.9604 1.87654 21.7975 1.77095 21.6064 1.70648L21.5999 1.70521Z" fill="white"/>
+<svg width="240" height="240" viewBox="0 0 240 240" fill="none" xmlns="http://www.w3.org/2000/svg">
+<!-- Template-safe vector adaptation of https://github.com/ollama/ollama/blob/main/docs/images/logo.png -->
+<path d="M178.46 4.35561C184.336 17.4008 185.708 34.691 181.282 48.9317C173.371 46.2895 166.112 44.2644 157.689 43.6987C157.683 31.339 159.916 19.3337 165.062 8.06984C167.606 2.50202 174.409 -4.63787 178.46 4.35561Z" fill="white"/>
+<path d="M71.0775 3.03524C78.6788 14.9096 81.1013 29.9224 81.5422 43.7049C76.2668 44.1323 73.3195 44.3426 68.1429 45.475C64.2552 46.5137 61.5822 47.5774 57.9607 49.1793C53.4513 36.0203 54.6527 19.0144 59.7519 6.05038C61.7817 0.89087 67.2534 -2.93785 71.0775 3.03524Z" fill="white"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M118.468 34.9089C133.047 34.4971 143.909 40.9545 152.475 52.3242C155.36 52.3174 158.114 52.3188 161.007 52.5342C192.594 54.8898 214.339 87.9185 202.9 117.705C201.118 122.346 199.259 125.395 196.558 129.482C199.777 134.285 202.183 139.586 203.679 145.17C207.471 158.991 206.629 172.355 201.064 185.655C200.363 187.326 198.819 189.956 197.538 192.138C197.083 192.912 196.662 193.629 196.323 194.228C196.657 194.972 197.06 195.734 197.461 196.493L197.461 196.494C197.746 197.034 198.031 197.572 198.29 198.103C204.271 210.316 207.346 226.522 204.209 240L34.8319 239.986C31.6644 223.366 34.9109 209.011 42.7579 194.305C41.608 192.023 40.6474 190.29 39.815 188.789C37.4308 184.489 36.0988 182.087 34.3839 174.119C30.992 158.767 33.8942 142.702 42.4428 129.502C36.7922 120.354 33.0087 112.387 33.0115 101.22C33.1229 88.2256 38.3544 75.798 47.5731 66.6286C58.8619 55.3546 71.1566 52.3046 86.5175 52.3527C95.0381 41.0683 104.069 35.6943 118.468 34.9089ZM178.913 103.272C180.049 108.491 176.742 113.643 171.523 114.795C166.275 115.956 161.084 112.633 159.942 107.387C158.802 102.142 162.146 96.9687 167.4 95.8482C172.631 94.7331 177.777 98.0525 178.913 103.272ZM78.993 103.057C80.2302 108.169 77.1438 113.332 72.0506 114.668C68.6649 115.557 65.0631 114.546 62.6329 112.031C60.2028 109.514 59.324 105.883 60.3354 102.535C61.3467 99.188 64.09 96.6478 67.5082 95.8941C72.6505 94.7597 77.7561 97.9438 78.993 103.057ZM147.427 104.182C140.194 98.1187 130.52 94.6173 120.041 94.6173C109.572 94.6173 99.6973 98.1075 92.2183 104.115C84.8512 110.032 80.3951 117.975 80.3951 125.884C80.3951 133.882 84.269 141.265 91.177 146.523C98.1411 151.836 107.792 154.734 119.089 154.734C129.748 154.734 139.052 152.698 145.993 148.503C154.133 143.558 158.679 135.817 158.679 125.884C158.679 117.997 154.48 110.077 147.427 104.182Z" fill="white"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M120.041 104.64C112.273 104.573 104.712 107.136 98.5889 111.912C93.4275 116.051 90.5053 121.252 90.5053 125.895C90.5053 130.683 92.8565 135.168 97.3349 138.58C102.429 142.462 109.919 144.711 119.089 144.711C128.035 144.711 135.581 143.066 140.72 139.945C145.904 136.813 148.557 132.271 148.557 125.884C148.557 121.152 145.803 115.928 140.91 111.833C135.491 107.303 128.147 104.64 120.041 104.64ZM127.497 118.221L127.453 118.176C126.793 117.385 125.85 116.883 124.826 116.777C123.801 116.67 122.775 116.967 121.966 117.606L119.503 119.552L117.096 117.628C116.285 116.976 115.249 116.67 114.213 116.777C113.178 116.884 112.226 117.395 111.565 118.198C111.241 118.596 110.999 119.053 110.853 119.544C110.707 120.036 110.659 120.551 110.714 121.06C110.768 121.57 110.922 122.064 111.168 122.513C111.414 122.963 111.747 123.359 112.147 123.68L115.182 126.119V131.264C115.188 132.375 115.634 133.438 116.423 134.22C117.212 135.002 118.28 135.44 119.391 135.437C120.503 135.44 121.57 135.002 122.36 134.22C123.149 133.438 123.595 132.375 123.601 131.264V126.275L126.87 123.702C128.561 122.36 128.841 119.91 127.497 118.221Z" fill="white"/>
 </svg>
diff --git a/Sources/CodexBar/Resources/ProviderIcon-opencodego.svg b/Sources/CodexBar/Resources/ProviderIcon-opencodego.svg
new file mode 100644
index 0000000000..eaebc91bd5
--- /dev/null
+++ b/Sources/CodexBar/Resources/ProviderIcon-opencodego.svg
@@ -0,0 +1,3 @@
+<svg width="100" height="100" viewBox="0 0 100 100" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path fill-rule="evenodd" clip-rule="evenodd" d="M80 88H20V12H80V88ZM35 27H65V72H35V27Z" fill="#211E1E"/>
+</svg>
diff --git a/Sources/CodexBar/Resources/ProviderIcon-perplexity.svg b/Sources/CodexBar/Resources/ProviderIcon-perplexity.svg
new file mode 100644
index 0000000000..d869791b2c
--- /dev/null
+++ b/Sources/CodexBar/Resources/ProviderIcon-perplexity.svg
@@ -0,0 +1 @@
+<svg fill="currentColor" fill-rule="evenodd" height="1em" style="flex:none;line-height:1" viewBox="0 0 100 100" width="1em" xmlns="http://www.w3.org/2000/svg"><title>Perplexity</title><g transform="translate(10 10) scale(3.3333)"><path d="M22.3977 7.0896h-2.3106V.0676l-7.5094 6.3542V.1577h-1.1554v6.1966L4.4904 0v7.0896H1.6023v10.3976h2.8882V24l6.932-6.3591v6.2005h1.1554v-6.0469l6.9318 6.1807v-6.4879h2.8882V7.0896zm-3.4657-4.531v4.531h-5.355l5.355-4.531zm-13.2862.0676 4.8691 4.4634H5.6458V2.6262zM2.7576 16.332V8.245h7.8476l-6.1149 6.1147v1.9723H2.7576zm2.8882 5.0404v-3.8852h.0001v-2.6488l5.7763-5.7764v7.0111l-5.7764 5.2993zm12.7086.0248-5.7766-5.1509V9.0618l5.7766 5.7766v6.5588zm2.8882-5.0652h-1.733v-1.9723L13.3948 8.245h7.8478v8.087z"/></g></svg>
diff --git a/Sources/CodexBar/Resources/ProviderIcon-poe.svg b/Sources/CodexBar/Resources/ProviderIcon-poe.svg
new file mode 100644
index 0000000000..e45e85cd5e
--- /dev/null
+++ b/Sources/CodexBar/Resources/ProviderIcon-poe.svg
@@ -0,0 +1 @@
+<svg fill="currentColor" fill-rule="evenodd" height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>Poe</title><path d="M12.003 2C6.48 2 2 6.48 2 12s4.48 10 10.003 10 10.003-4.48 10.003-10S17.526 2 12.003 2zm4.45 13.897c-.397.6-.968.963-1.71.963-.742 0-1.313-.363-1.71-.963-.445-.668-.58-1.457-.41-2.347.172-.892.628-1.605 1.25-2.07.624-.462 1.34-.65 2.124-.65.79 0 1.53.216 2.13.65.64.494 1.11 1.232 1.29 2.14.18.91.04 1.72-.43 2.43-.42.64-1.05 1.03-1.88 1.03-.74 0-1.34-.36-1.75-1.03v2.85H12.003v-3.01l1.67.002c.59.002 1.01.27 1.25.8.26.57.21 1.23-.18 1.95-.4.71-1.07 1.07-2.06 1.07-1 0-1.69-.36-2.1-1.07-.4-.72-.51-1.52-.31-2.39.19-.87.64-1.54 1.34-2.01.7-.47 1.55-.7 2.52-.7.84 0 1.63.18 2.32.52.7.34 1.24.8 1.61 1.34l-1.24.8c-.56-.8-1.5-1.2-2.82-1.2-1.1 0-1.91.35-2.4 1.05-.49.7-.58 1.55-.27 2.57.32 1 .95 1.5 1.88 1.5.93 0 1.61-.4 2.05-1.2.27-.47.37-.97.3-1.5h-3.14v-1.2h4.45z"/></svg>
\ No newline at end of file
diff --git a/Sources/CodexBar/Resources/ProviderIcon-stepfun.svg b/Sources/CodexBar/Resources/ProviderIcon-stepfun.svg
new file mode 100644
index 0000000000..915c71d2c7
--- /dev/null
+++ b/Sources/CodexBar/Resources/ProviderIcon-stepfun.svg
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" id="_图层_2" data-name="图层 2" viewBox="0 0 84.47 84.47">
+  <defs>
+    <style>
+      .cls-1 {
+        fill: url(#_未命名的渐变_64);
+      }
+      .cls-1, .cls-4 {
+        stroke-width: 0px;
+      }
+      .cls-4 {
+        fill: #999999;
+      }
+    </style>
+    <radialGradient id="_未命名的渐变_64" data-name="未命名的渐变 64" cx="25.5" cy="102.67" fx="25.5" fy="102.67" r="51.59" gradientTransform="translate(-112.31 94.12) rotate(-75.81) scale(1 1.32)" gradientUnits="userSpaceOnUse">
+      <stop offset=".4" stop-color="#888888"/>
+      <stop offset=".43" stop-color="#878787" stop-opacity=".92"/>
+      <stop offset=".52" stop-color="#868686" stop-opacity=".68"/>
+      <stop offset=".61" stop-color="#858585" stop-opacity=".47"/>
+      <stop offset=".69" stop-color="#858585" stop-opacity=".3"/>
+      <stop offset=".78" stop-color="#848484" stop-opacity=".17"/>
+      <stop offset=".86" stop-color="#848484" stop-opacity=".08"/>
+      <stop offset=".94" stop-color="#848484" stop-opacity=".02"/>
+      <stop offset="1" stop-color="#848484" stop-opacity="0"/>
+    </radialGradient>
+  </defs>
+  <g id="_图层_1-2" data-name="图层 1">
+    <g>
+      <path class="cls-4" d="m42.23,0C18.91,0,0,18.91,0,42.23s18.91,42.23,42.23,42.23,42.23-18.91,42.23-42.23S65.56,0,42.23,0Zm-11.35,69.03h-15.44v-15.44h15.44v15.44Zm19.07,0h-15.44v-15.44h15.44v15.44Zm0-19.08h-15.44v-15.44h15.44v15.44Zm0-19.07h-15.44v-15.44h15.44v15.44Zm19.07,0h-15.44v-15.44h15.44v15.44Z"/>
+      <path class="cls-1" d="m47.24.3C24.08-2.46,3.07,14.07.3,37.23c-2.76,23.16,13.77,44.17,36.92,46.94,23.16,2.76,44.17-13.77,46.94-36.92C86.93,24.08,70.4,3.07,47.24.3Zm-16.36,68.73h-15.44v-15.44h15.44v15.44Zm19.07,0h-15.44v-15.44h15.44v15.44Zm0-19.08h-15.44v-15.44h15.44v15.44Zm0-19.07h-15.44v-15.44h15.44v15.44Zm19.07,0h-15.44v-15.44h15.44v15.44Z"/>
+    </g>
+  </g>
+</svg>
diff --git a/Sources/CodexBar/Resources/ProviderIcon-t3chat.svg b/Sources/CodexBar/Resources/ProviderIcon-t3chat.svg
new file mode 100644
index 0000000000..68a174a697
--- /dev/null
+++ b/Sources/CodexBar/Resources/ProviderIcon-t3chat.svg
@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512">
+  <g transform="translate(0 512) scale(0.1 -0.1)" fill="currentColor" stroke="none">
+    <path d="M1010 5110 c-364 -19 -535 -83 -726 -274 -157 -157 -226 -303 -262 -550 -16 -111 -17 -252 -17 -1721 0 -1691 0 -1707 46 -1889 38 -148 129 -297 253 -414 182 -170 345 -231 671 -252 207 -13 2966 -13 3170 0 179 12 297 32 385 67 256 102 475 345 539 600 45 178 46 200 46 1888 0 1469 -1 1610 -17 1721 -36 247 -105 393 -262 550 -159 158 -317 232 -571 265 -104 14 -3011 22 -3255 9z m1746 -1000 c518 -42 1026 -285 1302 -623 195 -238 285 -474 286 -747 0 -189 -35 -335 -121 -505 -227 -450 -721 -765 -1348 -861 -161 -24 -479 -22 -649 4 l-128 21 -322 -130 c-176 -72 -383 -155 -459 -186 -134 -54 -162 -58 -173 -29 -3 8 17 173 45 367 44 314 48 357 36 385 -7 18 -23 37 -34 43 -30 17 -163 171 -217 254 -134 202 -194 401 -194 638 0 190 36 336 126 509 209 406 656 711 1206 824 206 43 415 54 644 36z"/>
+  </g>
+</svg>
diff --git a/Sources/CodexBar/Resources/ProviderIcon-venice.svg b/Sources/CodexBar/Resources/ProviderIcon-venice.svg
new file mode 100644
index 0000000000..31408ddf78
--- /dev/null
+++ b/Sources/CodexBar/Resources/ProviderIcon-venice.svg
@@ -0,0 +1,4 @@
+<svg viewBox="4 4 24 24" fill="currentColor" xmlns="http://www.w3.org/2000/svg">
+  <path d="M6.2 7.2h4.1l4.6 12.7 4.6-12.7h4L15.7 27h-3.3L6.2 7.2Z"/>
+  <path d="M13 18.2h5.9l-1 2.8h-4l-.9-2.8Z" opacity="0.35"/>
+</svg>
diff --git a/Sources/CodexBar/Resources/ProviderIcon-windsurf.svg b/Sources/CodexBar/Resources/ProviderIcon-windsurf.svg
new file mode 100644
index 0000000000..3bc4246797
--- /dev/null
+++ b/Sources/CodexBar/Resources/ProviderIcon-windsurf.svg
@@ -0,0 +1,3 @@
+<svg width="100" height="100" viewBox="0 0 100 100" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M897.246 286.869H889.819C850.735 286.808 819.017 318.46 819.017 357.539V515.589C819.017 547.15 792.93 572.716 761.882 572.716C743.436 572.716 725.02 563.433 714.093 547.85L552.673 317.304C539.28 298.16 517.486 286.747 493.895 286.747C457.094 286.747 423.976 318.034 423.976 356.657V515.619C423.976 547.181 398.103 572.746 366.842 572.746C348.335 572.746 329.949 563.463 319.021 547.881L138.395 289.882C134.316 284.038 125.154 286.93 125.154 294.052V431.892C125.154 438.862 127.285 445.619 131.272 451.34L309.037 705.2C319.539 720.204 335.033 731.344 352.9 735.392C397.616 745.557 438.77 711.135 438.77 667.278V508.406C438.77 476.845 464.339 451.279 495.904 451.279H495.995C515.02 451.279 532.857 460.562 543.785 476.145L705.235 706.661C718.659 725.835 739.327 737.218 763.983 737.218C801.606 737.218 833.841 705.9 833.841 667.308V508.376C833.841 476.815 859.41 451.249 890.975 451.249H897.276C901.233 451.249 904.43 448.053 904.43 444.097V294.021C904.43 290.065 901.233 286.869 897.276 286.869H897.246Z" fill="white" transform="translate(0 21.1) scale(0.1283) translate(-125.154 -286.747)"/>
+</svg>
diff --git a/Sources/CodexBar/Resources/ProviderIcon-zed.svg b/Sources/CodexBar/Resources/ProviderIcon-zed.svg
new file mode 100644
index 0000000000..fdb37112bc
--- /dev/null
+++ b/Sources/CodexBar/Resources/ProviderIcon-zed.svg
@@ -0,0 +1,3 @@
+<svg width="100" height="100" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path fill="white" d="M2.25 1.5a.75.75 0 0 0-.75.75v16.5H0V2.25A2.25 2.25 0 0 1 2.25 0h20.095c1.002 0 1.504 1.212.795 1.92L10.764 14.298h3.486V12.75h1.5v1.922a1.125 1.125 0 0 1-1.125 1.125H9.264l-2.578 2.578h11.689V9h1.5v9.375a1.5 1.5 0 0 1-1.5 1.5H5.185L2.562 22.5H21.75a.75.75 0 0 0 .75-.75V5.25H24v16.5A2.25 2.25 0 0 1 21.75 24H1.655C.653 24 .151 22.788.86 22.08L13.19 9.75H9.75v1.5h-1.5V9.375A1.125 1.125 0 0 1 9.375 8.25h5.314l2.625-2.625H5.625V15h-1.5V5.625a1.5 1.5 0 0 1 1.5-1.5h13.19L21.438 1.5z"/>
+</svg>
diff --git a/Sources/CodexBar/Resources/ar.lproj/Localizable.strings b/Sources/CodexBar/Resources/ar.lproj/Localizable.strings
new file mode 100644
index 0000000000..e4729e10e7
--- /dev/null
+++ b/Sources/CodexBar/Resources/ar.lproj/Localizable.strings
@@ -0,0 +1,1110 @@
+/* Arabic localization for CodexBar */
+
+" providers" = " providers";
+"(System)" = "(النظام)";
+"30d" = "30 يومًا";
+"A managed Codex login is already running. Wait for it to finish before adding " = "تسجيل دخول Codex المدار يعمل بالفعل. انتظر حتى ينتهي قبل إضافة  ";
+"API key" = "مفتاح API";
+"API region" = "منطقة API";
+"API token" = "API رمز";
+"API tokens" = "رموز API";
+"About" = "حول";
+"Account" = "الحساب";
+"Accounts" = "الحسابات";
+"Accounts subtitle" = "العنوان الفرعي للحسابات";
+"Active" = "نشط";
+"Add" = "إضافة";
+"Add Workspace" = "إضافة مساحة العمل";
+"Advanced" = "متقدمة";
+"All" = "الجميع";
+"Always allow prompts" = "دائما اسمح بالمحفزات";
+"Animation pattern" = "نمط الرسوم المتحركة";
+"Antigravity login is managed in the app" = "يتم إدارة Antigravity تسجيل الدخول في التطبيق";
+"Applies only to the Security.framework OAuth keychain reader." = "ينطبق فقط على قارئ سلسلة مفاتيح Security.framework OAuth.";
+"Auto falls back to the next source if the preferred one fails." = "التلقائي يعود إلى المصدر التالي إذا فشل المصدر المفضل.";
+"Auto uses API first, then falls back to CLI on auth failures." = "يستخدم التلقائي API أولا، ثم يعود إلى CLI عند فشل التصديق.";
+"Auto-detect" = "الكشف التلقائي";
+"Auto-refresh is off; use the menu's Refresh command." = "التحديث التلقائي مغلق؛ استخدم أمر التحديث في القائمة.";
+"Auto-refresh: hourly · Timeout: 10m" = "التحديث التلقائي: كل ساعة · المهلة: 10m";
+"Automatic" = "أوتوماتيكي";
+"Automatic imports browser cookies and WorkOS tokens." = "يقوم الاستيراد التلقائي بملفات تعريف الارتباط ورموز WorkOS في المصفح.";
+"Automatic imports browser cookies and local storage tokens." = "يقوم باستيراد ملفات تعريف الارتباط في المتصفح ورموز التخزين المحلية تلقائيا.";
+"Automatic imports browser cookies for dashboard extras." = "يقوم باستيراد ملفات تعريف الارتباط تلقائيا للمتصفح للحصول على إضافات في لوحة التحكم.";
+"Automatic imports browser cookies for the web API." = "يقوم الاستيراد التلقائي بملفات تعريف الارتباط للمتصفح لخدمة الويب API.";
+"Automatic imports browser cookies from Model Studio/Bailian." = "يقوم الاستيراد التلقائي بملفات تعريف الارتباط في المتصفح من Model Studio/Bailian.";
+"Automatic imports browser cookies from admin.mistral.ai." = "يقوم الاستيراد التلقائي بملفات تعريف الارتباط من admin.mistral.ai.";
+"Automatic imports browser cookies from opencode.ai." = "يقوم الكوكيز تلقائيا باستيراد ملفات تعريف الارتباط من opencode.ai.";
+"Automatic imports browser cookies or stored sessions." = "يقوم الاستيراد التلقائي بملفات تعريف الارتباط أو الجلسات المخزنة في المتصفح تلقائيا.";
+"Automatic imports browser cookies." = "يقوم الاستيراد التلقائي بملفات تعريف الارتباط من المتصفح.";
+"Automatically imports browser session cookie." = "يقوم تلقائيا باستيراد كوكي جلسة المتصفح.";
+"Automatically opens CodexBar when you start your Mac." = "يفتح تلقائيا CodexBar عند تشغيل جهاز الماك.";
+"Automation" = "الأتمتة";
+"Average (\\(label1) + \\(label2))" = "المتوسط (\\(label1) + \\(label2))";
+"Average (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))" = "المتوسط (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))";
+"Avoid Keychain prompts" = "تجنب Keychain الأسئلة";
+"Balance" = "التوازن";
+"Battery Saver" = "منقذ البطارية";
+"Bordered" = "الحدود";
+"Build" = "البناء";
+"Built \\(buildTimestamp)" = "بنيت \\(buildTimestamp)";
+"Buy Credits..." = "اشتر الاعتمادات...";
+"Buy Credits…" = "اشتر الاعتمادات...";
+"CLI paths" = "CLI المسارات";
+"CLI sessions" = "جلسات CLI";
+"Caches" = "التخزين المؤقت";
+"Cancel" = "إلغاء";
+"Check for Updates…" = "تحقق من التحديثات...";
+"Check for updates automatically" = "تحقق تلقائيا من التحديثات";
+"Check if you like your agents having some fun up there." = "تحقق إذا كنت تحب وكلائنك يستمتعون هناك.";
+"Check provider status" = "تحقق من حالة المزود";
+"Choose Codex workspace" = "اختر Codex مساحة العمل";
+"Choose the MiniMax host (global .io or China mainland .com)." = "اختر المضيف MiniMax (.io العالمي أو .com البر الرئيسي الصيني).";
+"Choose up to " = "اختر حتى  ";
+"Choose up to \\(Self.maxOverviewProviders) providers" = "اختر حتى \\(Self.maxOverviewProviders) المزودين";
+"Choose up to \\(count) providers" = "اختر حتى \\(count) المزودين";
+"Choose what to show in the menu bar (Pace shows usage vs. expected)." = "اختر ما تريد عرضه في شريط القائمة (Pace يظهر الاستخدام مقابل المتوقع).";
+"Choose which Codex account CodexBar should follow." = "اختر أي حساب Codex يجب CodexBar اتباعه.";
+"Choose which window drives the menu bar percent." = "اختر أي نافذة تحدد نسبة شريط القوائم.";
+"Chrome" = "Chrome";
+"Claude CLI not found" = "Claude CLI لم يعثر عليه";
+"Claude binary" = "Claude الثنائية";
+"Claude cookies" = "Claude كوكيز";
+"Claude login failed" = "فشل تسجيل الدخول Claude";
+"Claude login timed out" = "انتهى وقت تسجيل الدخول Claude";
+"Close" = "إغلاق";
+"Code review" = "مراجعة الكود";
+"Codex CLI not found" = "Codex CLI لم يعثر عليه";
+"Codex account login already running" = "Codex تسجيل الدخول للحساب يعمل بالفعل";
+"Codex binary" = "Codex الثنائية";
+"Codex login failed" = "فشل تسجيل الدخول Codex";
+"Codex login timed out" = "انتهى وقت تسجيل الدخول Codex";
+"CodexBar Lifecycle Keepalive" = "CodexBar دورة الحياة في العيش";
+"CodexBar can't show its menu bar icon" = "لا يمكن CodexBar عرض أيقونة شريط القائمة";
+"CodexBar could not read managed account storage. " = "لم يكن CodexBar قادرا على قراءة تخزين الحساب المدار.  ";
+"Configure…" = "تكوين...";
+"Connected" = "متصل";
+"Controls how much detail is logged." = "يتحكم في كمية التفاصيل المسجلة.";
+"Cookie header" = "رأس الكوكي";
+"Cookie source" = "مصدر الكوكيز";
+"Cookie: ..." = "كوكي: ...";
+"Cookie: \\u{2026}\\\n\\\nor paste a cURL capture from the Abacus AI dashboard" = "كوكي: \\u{2026}\\\n\\\nأو لصق التقاط cURL من لوحة Abacus AI";
+"Cookie: \\u{2026}\\\n\\\nor paste the __Secure-next-auth.session-token value" = "كوكي: \\u{2026}\\\n\\\nأو لصق قيمة __Secure-next-auth.session-token";
+"Cookie: \\u{2026}\\\n\\\nor paste the kimi-auth token value" = "كوكي: \\u{2026}\\\n\\\n أو لصق قيمة رمز kimi-authentic";
+"Cookie: …" = "كوكي: ...";
+"CopilotDeviceFlow" = "CopilotDeviceFlow";
+"Cost" = "التكلفة";
+"Could not add Codex account" = "لم أتمكن من إضافة Codex الحساب";
+"Could not open Terminal for Gemini" = "لم أتمكن من فتح الطرفية من Gemini";
+"Could not start claude /login" = "لم تستطع بدء كلود /login";
+"Could not start codex login" = "لم أتمكن من بدء تسجيل الدخول إلى الكودكس";
+"Could not switch system account" = "لم أتمكن من تغيير حساب النظام";
+"Credits" = "الاعتمادات";
+"Individual credits" = "الاعتمادات الفردية";
+"Workspace" = "مساحة العمل";
+"Credits history" = "تاريخ الاعتمادات";
+"Cursor login failed" = "فشل تسجيل الدخول Cursor";
+"Custom" = "العرف";
+"Custom Path" = "المسار المخصص";
+"Daily Routines" = "الروتين اليومي";
+"Debug" = "تصحيح الأخطاء";
+"Default" = "الافتراضي";
+"Disable Keychain access" = "تعطيل Keychain الوصول";
+"Disabled" = "معاق";
+"Dismiss" = "انصرف";
+"Disconnected" = "مفصل";
+"Display" = "العرض";
+"Display mode" = "وضع العرض";
+"Display reset times as absolute clock values instead of countdowns." = "عرض أوقات إعادة الضبط كقيم ساعة مطلقة بدلا من العد التنازلي.";
+"Done" = "تم";
+"Effective PATH" = "PATH فعالة";
+"Email" = "البريد الإلكتروني";
+"Enable Merge Icons to configure Overview tab providers." = "تفعيل أيقونات الدمج لتكوين مزودي تبويب النظرة العامة.";
+"Enable file logging" = "تمكين تسجيل الملفات";
+"Enabled" = "مفعل";
+"Error" = "خطأ";
+"Error simulation" = "محاكاة الخطأ";
+"Expose troubleshooting tools in the Debug tab." = "اعرض أدوات استكشاف الأخطاء في تبويب التصحيح.";
+"Failed" = "فشل";
+"False" = "خطأ";
+"Fetch strategy attempts" = "محاولات استراتيجية الجلب";
+"Fetching" = "الجلب";
+"Field" = "الميدان";
+"Field subtitle" = "عنوان فرعي للميدان";
+"Finish the current managed account change before switching the system account." = "أكمل تغيير الحساب المدار الحالي قبل تغيير حساب النظام.";
+"Force animation on next refresh" = "الرسوم المتحركة بالقوة في التحديث القادم";
+"Gateway region" = "منطقة البوابة";
+"Gemini CLI not found" = "Gemini CLI لم يعثر عليه";
+"Gemini/Antigravity, surfacing incidents in the icon and menu." = "Gemini/Antigravity، تظهر الحوادث في الأيقونة والقائمة.";
+"General" = "عام";
+"GitHub" = "GitHub";
+"GitHub Copilot Login" = "GitHub Copilot تسجيل الدخول";
+"GitHub Login" = "GitHub تسجيل الدخول";
+"Hide details" = "إخفاء التفاصيل";
+"Hide personal information" = "إخفاء المعلومات الشخصية";
+"Historical tracking" = "التتبع التاريخي";
+"How often CodexBar polls providers in the background." = "كم مرة CodexBar استطلاعات في الخلفية.";
+"Inactive" = "غير نشط";
+"Install CLI" = "تثبيت CLI";
+"Install the Claude CLI (npm i -g @anthropic-ai/claude-code) and try again." = "ثبت Claude CLI (npm i -g @anthropic-ai/claude-code) وجرب مرة أخرى.";
+"Install the Codex CLI (npm i -g @openai/codex) and try again." = "ثبت Codex CLI (npm i -g @openai/codex) وجرب مرة أخرى.";
+"Install the Gemini CLI (npm i -g @google/gemini-cli) and try again." = "ثبت Gemini CLI (npm i -g @google/gemini-cli) وجرب مرة أخرى.";
+"JetBrains AI is ready" = "JetBrains الذكاء الاصطناعي جاهز";
+"JetBrains IDE" = "JetBrains IDE";
+"Keep CLI sessions alive" = "حافظ على الجلسات CLI حية";
+"Keyboard shortcut" = "اختصار لوحة المفاتيح";
+"Keychain access" = "Keychain الوصول";
+"Keychain prompt policy" = "سياسة Keychain السريع.";
+"Last \\(name) fetch failed:" = "آخر \\(name) فشل في الجلب:";
+"Last \\(self.store.metadata(for: self.provider).displayName) fetch failed:" = "فشل جلب Last \\(self.store.metadata(for: self.provider).displayName):";
+"Last attempt" = "المحاولة الأخيرة";
+"Link" = "رابط";
+"Loading animations" = "رسوم التحميل";
+"Loading…" = "جار التحميل...";
+"Local" = "محلي";
+"Logging" = "قطع الأشجار";
+"Login failed" = "فشل تسجيل الدخول";
+"Login shell PATH (startup capture)" = "PATH shell تسجيل الدخول (التقاط بدء التشغيل)";
+"Login timed out" = "انتهى وقت تسجيل الدخول";
+"MCP details" = "MCP التفاصيل";
+"Managed Codex accounts unavailable" = "الحسابات Codex المدارة غير متاحة";
+"Managed account storage is unreadable. Live account access is still available, " = "تخزين الحساب المدار غير مقروء. الوصول إلى الحساب الحي لا يزال متاحا  ";
+"Manual" = "الدليل";
+"May your tokens never run out—keep agent limits in view." = "عسى أن لا تنفد رموزك أبدا—حافظ على حدود الوكلاء في مرآه.";
+"Menu bar" = "شريط القوائم";
+"Menu bar auto-shows the provider closest to its rate limit." = "شريط القوائم يعرض تلقائيا مزود الخدمة الأقرب إلى حد السعر.";
+"Menu bar metric" = "مقياس شريط القائمة";
+"Menu bar shows percent" = "شريط القائمة يعرض النسبة المئوية";
+"Menu content" = "محتوى القائمة";
+"Merge Icons" = "أيقونات الدمج";
+"Never prompt" = "لم يكن هناك طلب أبدا";
+"No" = "لا";
+"No Codex accounts detected yet." = "لم يتم اكتشاف حسابات Codex حتى الآن.";
+"No JetBrains IDE detected" = "لم يتم اكتشاف JetBrains IDE";
+"No cost history data." = "بيانات تاريخ مجانية.";
+"No data available" = "لا توجد بيانات متاحة";
+"No data yet" = "لا توجد بيانات حتى الآن";
+"No enabled providers available for Overview." = "لا يوجد مزودون مفعلون متاحون للنظرة العامة.";
+"No providers selected" = "لم يتم اختيار أي مقدمي خدمة";
+"No token accounts yet." = "لا توجد حسابات رمزية حتى الآن.";
+"No usage breakdown data." = "لا توجد بيانات تفصيلية للاستخدام.";
+"None" = "لا شيء";
+"Notifications" = "الإشعارات";
+"Notifies when the 5-hour session quota hits 0% and when it becomes " = "يرسل إشعارًا عندما تصل حصة جلسة الخمس ساعات إلى 0% وعندما تصبح ";
+"OK" = "حسنا";
+"Obscure email addresses in the menu bar and menu UI." = "عناوين بريد إلكتروني غامضة في شريط القائمة وواجهة القائمة.";
+"Off" = "انطلق";
+"Offline" = "غير متصل";
+"On" = "شغلوا";
+"Online" = "عبر الإنترنت";
+"Only on user action" = "فقط عند إجراء المستخدم";
+"Open" = "مفتوح";
+"Open API Keys" = "مفاتيح API المفتوحة";
+"Open Amp Settings" = "افتح إعدادات Amp";
+"Open Antigravity to sign in, then refresh CodexBar." = "افتح Antigravity لتسجيل الدخول، ثم قم بتحديث CodexBar.";
+"Open Browser" = "المتصفح المفتوح";
+"Open Coding Plan" = "خطة الترميز المفتوحة";
+"Open Console" = "وحدة التحكم المفتوحة";
+"Open Dashboard" = "لوحة التحكم المفتوحة";
+"Open Mistral Admin" = "Open Mistral Admin";
+"Open Menu Bar Settings" = "إعدادات شريط القائمة المفتوح";
+"Open Ollama Settings" = "افتح إعدادات Ollama";
+"Open Terminal" = "المحطة المفتوحة";
+"Open Usage Page" = "صفحة الاستخدام المفتوحة";
+"Open Warp API Key Guide" = "دليل مفتاح Warp API المفتوح";
+"Open menu" = "قائمة مفتوحة";
+"Open token file" = "ملف الرمز المفتوح";
+"OpenAI cookies" = "OpenAI كوكيز";
+"OpenAI web extras" = "OpenAI إضافات الويب";
+"Option A" = "الخيار أ";
+"Option B" = "الخيار ب";
+"Optional override if workspace lookup fails." = "تجاوز اختياري إذا فشل البحث في مساحة العمل.";
+"Options" = "الخيارات";
+"Override auto-detection with a custom IDE base path" = "تجاوز الكشف التلقائي باستخدام مسار IDE الأساسي المخصص";
+"Overview" = "نظرة عامة";
+"Overview rows always follow provider order." = "الصفوف العامة دائما تتبع ترتيب مقدم الخدمة.";
+"Overview tab providers" = "نظرة عامة على مزودي تبويب";
+"Paste API key…" = "الصق API المفتاح...";
+"Paste API token…" = "الصق API الرمز...";
+"Paste key…" = "مفتاح لصق...";
+"Paste sessionKey or OAuth token…" = "الصق مفتاح الجلسة أو رمز OAuth...";
+"Paste the Cookie header from a request to admin.mistral.ai. " = "الصق رأس الكوكي من طلب إلى admin.mistral.ai. ";
+"Paste token…" = "اللصق الرمز...";
+"Personal" = "شخصي";
+"Picker" = "بيكر";
+"Picker subtitle" = "عنوان فرعي لاختيار";
+"Placeholder" = "العنصر المؤقت";
+"Plan" = "الخطة";
+"Play full-screen confetti when weekly usage resets." = "شغل ورق الورق الورقية بملء الشاشة عند إعادة ضبط الاستخدام الأسبوعي.";
+"Polls OpenAI/Claude status pages and Google Workspace for " = "استطلاعات OpenAI/Claude صفحات الحالة ومساحة العمل Google ل  ";
+"Prevents any Keychain access while enabled." = "يمنع أي وصول Keychain أثناء التفعيل.";
+"Primary (API key limit)" = "الحد الأساسي (API المفاتيح)";
+"Primary (\\(label))" = "الابتدائي (\\(label))";
+"Primary (\\(metadata.sessionLabel))" = "الابتدائي (\\(metadata.sessionLabel))";
+"Probe logs" = "سجلات المسبار";
+"Progress bars fill as you consume quota (instead of showing remaining)." = "تمتلئ أشرطة التقدم كلما استهلكت الحصة (بدلا من إظهار الحصة المتبقية).";
+"Provider" = "المزود";
+"Providers" = "مقدمو الخدمات";
+"Quit CodexBar" = "اترك CodexBar";
+"Random (default)" = "عشوائي (افتراضي)";
+"Reads local usage logs. Shows today + last 30 days cost in the menu." = "يقرأ سجلات الاستخدام المحلية. يعرض اليوم + نافذة التاريخ المحددة في القائمة.";
+"Refresh" = "تحديث";
+"Refresh cadence" = "وتيرة التحديث";
+"Remote" = "البعيد";
+"Remove" = "إزالة";
+"Remove Codex account?" = "هل تحذف Codex الحساب؟";
+"Remove \\(account.email) from CodexBar? Its managed Codex home will be deleted." = "إزالة \\(account.email) من CodexBar؟ سيتم حذف Codex المنزل الذي يديره.";
+"Remove \\(email) from CodexBar? Its managed Codex home will be deleted." = "إزالة \\(email) من CodexBar؟ سيتم حذف Codex المنزل الذي يديره.";
+"Remove selected account" = "إزالة الحساب المحدد";
+"Replace critter bars with provider branding icons and a percentage." = "استبدل ألواح الحيوانات بأيقونات علامة مزودة ونسبة مئوية.";
+"Replay selected animation" = "إعادة تشغيل الرسوم المتحركة المختارة";
+"Requires authentication via GitHub Device Flow." = "يتطلب المصادقة عبر تدفق الجهاز GitHub.";
+"Resets: \\(reset)" = "إعادة الضبط: \\(reset)";
+"Rolling five-hour limit" = "الحد الأقصى المتجدد لخمس ساعات";
+"Search hourly" = "البحث بالساعة";
+"Secondary (\\(label))" = "الثانوية (\\(label))";
+"Secondary (\\(metadata.weeklyLabel))" = "الثانوية (\\(metadata.weeklyLabel))";
+"Select a provider" = "اختر مزودا";
+"Select the IDE to monitor" = "اختر IDE للمراقبة";
+"Session quota notifications" = "إشعارات حصص الجلسة";
+"Session tokens" = "رموز الجلسة";
+"Settings" = "الإعدادات";
+"Show Codex Credits and Claude Extra usage sections in the menu." = "عرض أقسام Codex الاعتمادات و Claude الاستخدام الإضافي في القائمة.";
+"Show Debug Settings" = "عرض إعدادات التصحيح";
+"Show all token accounts" = "عرض جميع حسابات الرموز";
+"Show cost summary" = "ملخص تكلفة العرض";
+"Show credits + extra usage" = "اعتمادات العرض + الاستخدام الإضافي";
+"Show details" = "تفاصيل العرض";
+"Show most-used provider" = "عرض المزود الأكثر استخداما";
+"Show provider icons in the switcher (otherwise show a weekly progress line)." = "عرض أيقونات المزودين في جهاز التبديل (وإلا اعرض خط تقدم أسبوعي).";
+"Show reset time as clock" = "عرض وقت إعادة التعيين كساعة";
+"Show usage as used" = "استخدام العرض كما هو مستخدم";
+"Sign in via button below" = "سجل الدخول عبر الزر أدناه";
+"Skip teardown between probes (debug-only)." = "تخطي التفكيك بين المجسات (تصحيح فقط).";
+"Stack token accounts in the menu (otherwise show an account switcher bar)." = "قم بتكديس حسابات الرموز في القائمة (وإلا اعرض شريط تبديل الحسابات).";
+"Start at Login" = "ابدأ عند تسجيل الدخول";
+"Status" = "الحالة";
+"Store Claude sessionKey cookies or OAuth access tokens." = "تخزين ملفات تعريف الارتباط الخاصة Claude sessionKey أو رموز الوصول OAuth.";
+"Store multiple Abacus AI Cookie headers." = "احتفظ بعدة رؤوس Abacus AI كوكي.";
+"Store multiple Augment Cookie headers." = "احتفظ بعدة رؤوس Augment كوكي.";
+"Store multiple Cursor Cookie headers." = "احتفظ بعدة رؤوس Cursor كوكي.";
+"Store multiple Factory Cookie headers." = "احتفظ بعدة رؤوس Factory كوكي.";
+"Store multiple MiniMax Cookie headers." = "احتفظ بعدة رؤوس MiniMax كوكي.";
+"Store multiple Mistral Cookie headers." = "احتفظ بعدة رؤوس Mistral كوكي.";
+"Store multiple Ollama Cookie headers." = "احتفظ بعدة رؤوس Ollama كوكي.";
+"Store multiple OpenCode Cookie headers." = "احتفظ بعدة رؤوس OpenCode كوكي.";
+"Store multiple OpenCode Go Cookie headers." = "تخزين عدة رؤوس OpenCode Go Cookie.";
+"Stored in the CodexBar config file." = "مخزنة في ملف الإعدادات CodexBar.";
+"Stored in ~/.codexbar/config.json. " = "مخزنة في ~/.codexbar/config.json. ";
+"Stored in ~/.codexbar/config.json. Generate one at kimi-k2.ai." = "مخزن في ~/.codexbar/config.json. تولد واحدا عند kimi-k2.ai.";
+"Stored in ~/.codexbar/config.json. Paste the key from the Synthetic dashboard." = "مخزنة في ~/.codexbar/config.json. الصق المفتاح من لوحة Synthetic.";
+"Stored in ~/.codexbar/config.json. Paste your Coding Plan API key from Model Studio." = "مخزن في ~/.codexbar/config.json. الصق مفتاح خطة البرمجة الخاصة بك API من Model Studio.";
+"Stored in ~/.codexbar/config.json. Paste your MiniMax API key." = "مخزن في ~/.codexbar/config.json. الصق مفتاح MiniMax API الخاص بك.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or " = "مخزنة في ~/.codexbar/config.json. يمكنك أيضا توفير KILO_API_KEY or ";
+"Stores local Codex usage history (8 weeks) to personalize Pace predictions." = "يخزن تاريخ استخدام Codex محليا (8 أسابيع) لتخصيص توقعات Pac.";
+"Subscription Utilization" = "استخدام الاشتراكات";
+"Surprise me" = "فاجئني";
+"Switcher shows icons" = "المحول يعرض الأيقونات";
+"Symlink CodexBarCLI to /usr/local/bin and /opt/homebrew/bin as codexbar." = "Symlink CodexBarCLI إلى /usr/local/bin و /opt/homebrew/bin ك codexbar.";
+"System" = "النظام";
+"Temporarily shows the loading animation after the next refresh." = "يعرض مؤقتا حركة التحميل بعد التحديث التالي.";
+"terminal_app_subtitle" = "الطرفية المستخدمة في إجراء الطرفية المفتوحة";
+"terminal_app_title" = "المحطة الافتراضية";
+"Tertiary (\\(label))" = "الثالثية (\\(label))";
+"Tertiary (\\(tertiaryTitle))" = "الثالثية (\\(tertiaryTitle))";
+"The default Codex account on this Mac." = "الحساب الافتراضي Codex على هذا الجهاز.";
+"Toggle" = "التبديل";
+"Toggle subtitle" = "تبديل العنوان الفرعي";
+"Token" = "الرمز";
+"Trigger the menu bar menu from anywhere." = "فعل قائمة شريط القوائم من أي مكان.";
+"True" = "صحيح";
+"Twitter" = "تويتر";
+"Unsupported" = "غير مدعوم";
+"Update Channel" = "قناة التحديث";
+"Updated" = "تحديث";
+"Updates unavailable in this build." = "التحديثات غير متوفرة في هذا الإصدار.";
+"Usage" = "الاستخدام";
+"Usage breakdown" = "تفصيل الاستخدام";
+"Usage history (30 days)" = "تاريخ الاستخدام";
+"Usage source" = "مصدر الاستخدام";
+"Use BigModel for the China mainland endpoints (open.bigmodel.cn)." = "استخدم BigModel لنقاط نهاية البر الرئيسي للصين (open.bigmodel.cn).";
+"Use a single menu bar icon with a provider switcher." = "استخدم أيقونة شريط قائمة واحدة مع محول المزود.";
+"Use international or China mainland console gateways for quota fetches." = "استخدم بوابات الكونسول الدولية أو الصينية لجلب الحصص.";
+"Version" = "النسخة";
+"Version \\(self.versionString)" = "النسخة \\(self.versionString)";
+"Version \\(version)" = "النسخة \\(version)";
+"Version \\(versionString)" = "النسخة \\(versionString)";
+"Vertex AI Login" = "Vertex AI تسجيل الدخول";
+"Wait for the current managed Codex login to finish before adding another account." = "انتظر حتى ينتهي تسجيل الدخول Codex المدار الحالي قبل إضافة حساب آخر.";
+"Waiting for Authentication..." = "في انتظار المصادقة...";
+"Website" = "الموقع الإلكتروني";
+"Weekly limit confetti" = "قصاصات كونفيتي أسبوعية محدودة";
+"Weekly token limit" = "الحد الأسبوعي للرموز";
+"Weekly usage" = "الاستخدام الأسبوعي";
+"Weekly usage unavailable for this account." = "الاستخدام الأسبوعي غير متاح لهذا الحساب.";
+"Window: \\(window)" = "النافذة: \\(window)";
+"Write logs to \\(self.fileLogPath) for debugging." = "اكتب السجلات إلى \\(self.fileLogPath) للتصحيح.";
+"Yes" = "نعم";
+"\\(detail.modelCode): \\(usage)" = "\\(detail.modelCode): \\(usage)";
+"\\(name): \\(truncated)" = "\\(name): \\(truncated)";
+"\\(name): \\(updated) · 30d \\(cost)" = "\\(name): \\(updated) · 30d \\(cost)";
+"\\(name): fetching…\\(elapsed)" = "\\(name): رائع... \\(elapsed)";
+"\\(name): last attempt \\(when)" = "\\(name): المحاولة الأخيرة \\(when)";
+"\\(name): no data yet" = "\\(name): لا توجد بيانات حتى الآن";
+"\\(name): unsupported" = "\\(name): غير مدعوم";
+"all browsers" = "جميع المتصفحات";
+"available again." = "متاح مرة أخرى.";
+"built_format" = "بنيت %@";
+"copilot_complete_in_browser" = "تسجيل الدخول الكامل في متصفحك.";
+"copilot_device_code" = "رمز الجهاز المنسوخ إلى الحافظة: %1$@\n\nVerify على: %2$@";
+"copilot_device_code_copied" = "تم نسخ رمز الجهاز.";
+"copilot_verify_at" = "تحقق على %@";
+"copilot_waiting_text" = "تسجيل الدخول الكامل في متصفحك. \nتغلق هذه النافذة تلقائيا عند اكتمال تسجيل الدخول.";
+"copilot_window_closes_auto" = "تغلق هذه النافذة تلقائيا عند اكتمال تسجيل الدخول.";
+"cost_status_error" = "%1$@: %2$@";
+"cost_status_fetching" = "%1$@: رائع... %2$@";
+"cost_status_last_attempt" = "%1$@: المحاولة الأخيرة %2$@";
+"cost_status_no_data" = "%@: لا توجد بيانات حتى الآن";
+"cost_status_snapshot" = "%1$@: %2$@ · %3$@ %4$@";
+"cost_status_unsupported" = "%@: غير مدعوم";
+"credits_remaining" = "الاعتمادات: %@";
+"cursor_on_demand" = "عند الطلب: %@";
+"cursor_on_demand_with_limit" = "عند الطلب: %1$@ / %2$@";
+"extra_usage_format" = "الاستخدام الإضافي: %1$@ / %2$@";
+"jetbrains_detected_generate" = "تم اكتشاف: %@. استخدم مساعد الذكاء الاصطناعي مرة واحدة لتوليد بيانات الحصص، ثم قم بتحديث CodexBar.";
+"jetbrains_detected_select" = "تم اكتشاف: %@. اختر IDE المفضل لديك في الإعدادات، ثم قم بتحديث CodexBar.";
+"last_fetch_failed_with_provider" = "آخر %@ فشل في الجلب:";
+"last_spend" = "آخر إنفاق: %@";
+"mcp_model_usage" = "%1$@: %2$@";
+"mcp_resets" = "إعادة الضبط: %@";
+"mcp_window" = "النافذة: %@";
+"metric_average" = "المتوسط (%1$@ + %2$@)";
+"metric_primary" = "الابتدائي (%@)";
+"metric_secondary" = "الثانوية (%@)";
+"metric_tertiary" = "الثالثية (%@)";
+"multiple_workspaces_found" = "CodexBar وجدت عدة مساحات عمل ل %@. يرجى اختيار مساحة العمل التي ستضيفها.";
+"ory_session_…=…; csrftoken=…" = "ory_session_...=...; csrftoken=...";
+"overview_choose_providers" = "اختر حتى %@ المزودين";
+"remove_account_message" = "إزالة %@ من CodexBar؟ سيتم حذف Codex المنزل الذي يديره.";
+"version_format" = "النسخة %@";
+"vertex_ai_login_instructions" = "لتتبع Vertex AI الاستخدام، قم بالتحقق باستخدام Google Cloud.\n\n1. افتح الطرفية\n2. تشغيل: gcloud مصادقة التطبيق - login\n3. اتبع تعليمات المتصفح لتوقيع in\n4. هل تضبط مشروعك: gcloud config set project PROJECT_ID\n\nOpen الآن؟";
+"workspaceID is set but only opencode, opencodego, and deepgram support workspaceID." = "يتم تعيين WorkspaceID لكن فقط opencode وopencodego وdeepgram يدعمون WorkspaceID.";
+"© 2026 Peter Steinberger. MIT License." = "© 2026 بيتر ستاينبرجر. MIT الرخصة.";
+
+/* General Pane */
+"section_system" = "النظام";
+"section_usage" = "الاستخدام";
+"section_automation" = "الأتمتة";
+"language_title" = "اللغة";
+"language_subtitle" = "غير لغة العرض. يتطلب إعادة تشغيل التطبيق ليكون مفعوله بالكامل.";
+"language_system" = "النظام";
+"language_english" = "الإنجليزية";
+"language_spanish" = "الإسبانيول";
+"language_catalan" = "كاتالا";
+"language_chinese_simplified" = "简体中文";
+"language_chinese_traditional" = "繁體中文";
+"language_portuguese_brazilian" = "البرتغاليون (البرازيل)";
+"language_dutch" = "هولندا";
+"language_german" = "دويتش";
+"language_swedish" = "السويديا";
+"language_french" = "الفرنسية";
+"language_ukrainian" = "Українська";
+"language_japanese" = "ياباني";
+"language_korean" = "الكورية";
+"language_turkish" = "تركجه";
+"language_italian" = "إيطاليانو";
+"language_polish" = "بولسكي";
+"start_at_login_title" = "ابدأ عند تسجيل الدخول";
+"start_at_login_subtitle" = "يفتح تلقائيا CodexBar عند تشغيل جهاز الماك.";
+"show_cost_summary" = "ملخص تكلفة العرض";
+"show_cost_summary_subtitle" = "يقرأ سجلات الاستخدام المحلية. يعرض اليوم + نافذة التاريخ المحددة في القائمة.";
+"cost_history_days_title" = "نافذة التاريخ: %d أيام";
+"cost_auto_refresh_info" = "تحديث تلقائي: كل ساعة · وقت الاستراحة: 10m";
+"refresh_cadence_title" = "وتيرة التحديث";
+"refresh_cadence_subtitle" = "كم مرة CodexBar استطلاعات في الخلفية.";
+"manual_refresh_hint" = "التحديث التلقائي مغلق؛ استخدم أمر التحديث في القائمة.";
+"check_provider_status_title" = "تحقق من حالة المزود";
+"check_provider_status_subtitle" = "استطلاعات OpenAI/Claude صفحات الحالة و Google مساحة العمل Gemini/Antigravity، وتظهر الحوادث في الأيقونة والقائمة.";
+"session_quota_notifications_title" = "إشعارات حصص الجلسة";
+"session_quota_notifications_subtitle" = "يرسل إشعارًا عندما تصل حصة جلسة الخمس ساعات إلى 0% وعندما تصبح متاحة مجددًا.";
+"quota_warning_notifications_title" = "إشعارات تحذير الحصص";
+"quota_warning_notifications_subtitle" = "يحذر عندما يتجاوز الحصة المتبقية من الجلسة أو الحصة الأسبوعية العتبات المكونة.";
+"quota_warnings_title" = "تحذيرات الحصص";
+"quota_warning_session" = "الجلسة";
+"quota_warning_session_capitalized" = "الجلسة";
+"quota_warning_weekly" = "أسبوعيا";
+"quota_warning_weekly_capitalized" = "الأسبوعي";
+"quota_warning_notification_title" = "انخفاض حصة %2$@ لدى %1$@";
+"quota_warning_notification_body" = "%1$@ متبقٍ. تم بلوغ حد التحذير البالغ %2$d%% لحصة %3$@.";
+"quota_warning_notification_body_with_account" = "الحساب %1$@. متبقٍ %2$@. تم بلوغ حد التحذير البالغ %3$d%% لحصة %4$@.";
+"session_depleted_notification_title" = "جلسة %@ استنزفت";
+"session_depleted_notification_body" = "المتبقي 0%. سنبلغك عندما تصبح الحصة متاحة مجددًا.";
+"session_restored_notification_title" = "%@ الجلسة التي استعادت";
+"session_restored_notification_body" = "حصة الجلسة متاحة مرة أخرى.";
+"quota_warning_warn_at" = "التحذير في";
+"quota_warning_global_threshold_subtitle" = "النسب المتبقية للجلسات والفترات الأسبوعية ما لم يتجاوزها مقدم الخدمة.";
+"quota_warning_sound" = "تشغيل صوت الإشعار";
+"quota_warning_provider_inherits" = "يستخدم إعدادات تحذير الحصص العامة إلا إذا تم تخصيص نافذة هنا.";
+"quota_warning_customize_thresholds" = "تخصيص عتبات %@";
+"quota_warning_enable_warnings" = "تفعيل تحذيرات %@";
+"quota_warning_window_warn_at" = "%@ التحذير في";
+"quota_warning_off" = "انطلق";
+"quota_warning_inherited" = "الموروث: %@";
+"quota_warning_depleted_only" = "مستنزف فقط";
+"quota_warning_upper" = "الأعلى";
+"quota_warning_lower" = "الأسفل";
+"apply" = "قدم";
+"quit_app" = "إنهاء CodexBar";
+
+/* Tab titles */
+"tab_general" = "عام";
+"tab_providers" = "مقدمو الخدمات";
+"tab_display" = "العرض";
+"tab_advanced" = "متقدمة";
+"tab_about" = "حول";
+"tab_debug" = "تصحيح الأخطاء";
+
+/* Providers Pane */
+"select_a_provider" = "اختر مزودا";
+"cancel" = "إلغاء";
+"last_fetch_failed" = "فشل آخر جلب";
+"usage_not_fetched_yet" = "الاستخدام لم يتم استحضاره بعد";
+"managed_account_storage_unreadable" = "تخزين الحساب المدار غير مقروء. لا يزال الوصول إلى الحساب المباشر متاحا، لكن إجراءات الإضافة المدارة، وإعادة المصادقة، والإزالة يتم تعطيلها حتى يصبح المتجر قابلا للاسترداد.";
+"remove_codex_account_title" = "هل تحذف Codex الحساب؟";
+"remove" = "إزالة";
+"managed_login_already_running" = "تسجيل دخول Codex المدار يعمل بالفعل. انتظر حتى ينتهي قبل إضافة أو إعادة المصادقة على حساب آخر.";
+"managed_login_failed" = "لم يكتمل تسجيل الدخول Codex تدخله. تحقق من أن `codex --version` يعمل في الطرفية. إذا تم حظر macOS أو تم نقلها `codex` إلى سلة المهملات، قم بإزالة التثبيت المكررة القديمة، وشغل `npm install -g --include=optional @openai/codex@latest`، ثم جرب مرة أخرى.";
+"codex_login_output" = "مخرج تسجيل الدخول إلى الكودكس:";
+"managed_login_missing_email" = "تم تسجيل Codex الدخول، لكن لم يكن هناك بريد إلكتروني للحساب متاح. حاول مرة أخرى بعد التأكد من تسجيل الدخول بالكامل.";
+"login_success_notification_title" = "%@ تسجيل الدخول ناجحا";
+"login_success_notification_body" = "يمكنك العودة إلى التطبيق؛ انتهى التوثيق.";
+"workspace_selection_cancelled" = "CodexBar وجدت عدة مساحات عمل، لكن لم يتم اختيار مساحة عمل.";
+"unsafe_managed_home" = "رفض CodexBar تعديل مسار منزلي مدار غير متوقع: %@";
+"menu_bar_metric_title" = "مقياس شريط القائمة";
+"menu_bar_metric_subtitle" = "اختر أي نافذة تحدد نسبة شريط القوائم.";
+"menu_bar_metric_subtitle_deepseek" = "يظهر توازن DeepSeek في شريط القوائم.";
+"menu_bar_metric_subtitle_moonshot" = "يظهر توازن Moonshot / Kimi API في شريط القوائم.";
+"menu_bar_metric_subtitle_mistral" = "يعرض الإنفاق Mistral API الشهري الحالي في شريط القوائم.";
+"menu_bar_metric_subtitle_kimik2" = "يعرض Kimi اعتمادات K2 API المفاتيح في شريط القوائم.";
+"automatic" = "أوتوماتيكي";
+"primary_api_key_limit" = "الحد الأساسي (API المفاتيح)";
+
+/* Display Pane */
+"section_menu_bar" = "شريط القوائم";
+"merge_icons_title" = "أيقونات الدمج";
+"merge_icons_subtitle" = "استخدم أيقونة شريط قائمة واحدة مع محول المزود.";
+"switcher_shows_icons_title" = "المحول يعرض الأيقونات";
+"switcher_shows_icons_subtitle" = "عرض أيقونات المزودين في جهاز التبديل (وإلا اعرض خط تقدم أسبوعي).";
+"show_most_used_provider_title" = "عرض المزود الأكثر استخداما";
+"show_most_used_provider_subtitle" = "شريط القوائم يعرض تلقائيا مزود الخدمة الأقرب إلى حد السعر.";
+"menu_bar_shows_percent_title" = "شريط القائمة يعرض النسبة المئوية";
+"menu_bar_shows_percent_subtitle" = "استبدل ألواح الحيوانات بأيقونات علامة مزودة ونسبة مئوية.";
+"hide_critters_title" = "إخفاء الكائنات الصغيرة";
+"hide_critters_subtitle" = "عرض أشرطة القياس البسيطة بدون الوجه والزخارف.";
+"display_mode_title" = "وضع العرض";
+"display_mode_subtitle" = "اختر ما تريد عرضه في شريط القائمة (Pace يظهر الاستخدام مقابل المتوقع).";
+"section_menu_content" = "محتوى القائمة";
+"show_usage_as_used_title" = "استخدام العرض كما هو مستخدم";
+"show_usage_as_used_subtitle" = "تمتلئ أشرطة التقدم كلما استهلكت الحصة (بدلا من إظهار الحصة المتبقية).";
+"show_quota_warning_markers_title" = "عرض علامات التحذير من الحصص";
+"show_quota_warning_markers_subtitle" = "ارسم علامات عتبة على أشرطة الاستخدام عند تكوين تحذيرات الحصص.";
+"weekly_progress_work_days_title" = "أيام العمل الأسبوعية للتقدم";
+"weekly_progress_work_days_subtitle" = "حدد أيام عمل لمؤشرات شريط الاستخدام الأسبوعي وحسابات السرعة.";
+"show_reset_time_as_clock_title" = "عرض وقت إعادة التعيين كساعة";
+"show_reset_time_as_clock_subtitle" = "عرض أوقات إعادة الضبط كقيم ساعة مطلقة بدلا من العد التنازلي.";
+"show_provider_changelog_links_title" = "اعرض روابط سجل التغييرات لمزود الخدمة";
+"show_provider_changelog_links_subtitle" = "يضيف روابط ملاحظات الإصدار لمزودي الخدمة المدعومين بدعم CLI إلى القائمة.";
+"show_credits_extra_usage_title" = "اعتمادات العرض + الاستخدام الإضافي";
+"show_credits_extra_usage_subtitle" = "عرض أقسام Codex الاعتمادات و Claude الاستخدام الإضافي في القائمة.";
+"show_all_token_accounts_title" = "عرض جميع حسابات الرموز";
+"show_all_token_accounts_subtitle" = "قم بتكديس حسابات الرموز في القائمة (وإلا اعرض شريط تبديل الحسابات).";
+"multi_account_layout_title" = "تخطيط الحسابات المتعددة";
+"multi_account_layout_subtitle" = "اختر تبديل الحسابات المجزأة أو بطاقات الحساب المكدسة.";
+"multi_account_layout_segmented" = "مقسم";
+"multi_account_layout_stacked" = "مكدس";
+"overview_tab_providers_title" = "نظرة عامة على مزودي تبويب";
+"configure" = "تكوين...";
+"overview_enable_merge_icons_hint" = "تفعيل أيقونات الدمج لتكوين مزودي تبويب النظرة العامة.";
+"overview_no_providers_hint" = "لا يوجد مزودون مفعلون متاحون للنظرة العامة.";
+"overview_rows_follow_order" = "الصفوف العامة دائما تتبع ترتيب مقدم الخدمة.";
+"overview_no_providers_selected" = "لم يتم اختيار أي مقدمي خدمة";
+
+/* Advanced Pane */
+"section_keyboard_shortcut" = "اختصار لوحة المفاتيح";
+"open_menu_shortcut_title" = "قائمة مفتوحة";
+"open_menu_shortcut_subtitle" = "فعل قائمة شريط القوائم من أي مكان.";
+"install_cli" = "تثبيت CLI";
+"install_cli_subtitle" = "Symlink CodexBarCLI إلى /usr/local/bin و /opt/homebrew/bin ك codexbar.";
+"cli_not_found" = "CodexBarCLI غير موجود في حزمة التطبيقات.";
+"no_writable_bin_dirs" = "لم يتم العثور على أي سجلات قابلة للكتابة.";
+"show_debug_settings_title" = "عرض إعدادات التصحيح";
+"show_debug_settings_subtitle" = "اعرض أدوات استكشاف الأخطاء في تبويب التصحيح.";
+"surprise_me_title" = "فاجئني";
+"surprise_me_subtitle" = "تحقق إذا كنت تحب وكلائنك يستمتعون هناك.";
+"weekly_limit_confetti_title" = "قصاصات كونفيتي أسبوعية محدودة";
+"weekly_limit_confetti_subtitle" = "شغل ورق الورق الورقية بملء الشاشة عند إعادة ضبط الاستخدام الأسبوعي.";
+"hide_personal_info_title" = "إخفاء المعلومات الشخصية";
+"hide_personal_info_subtitle" = "عناوين بريد إلكتروني غامضة في شريط القائمة وواجهة القائمة.";
+"show_provider_storage_usage_title" = "عرض استخدام التخزين لمزود الخدمة";
+"show_provider_storage_usage_subtitle" = "عرض استخدام القرص المحلي في القوائم. يمسح المسارات المعروفة المملوكة لمزود الخدمة في الخلفية.";
+"section_keychain_access" = "Keychain الوصول";
+"keychain_access_caption" = "قم بتعطيل جميع Keychain القراءة والكتابة. استخدم هذا إذا استمر macOS في طلب 'Chrome/Brave/Edge التخزين الآمن' حتى بعد الضغط على 'دائما السماح'. استيراد ملفات تعريف الارتباط من المتصفح غير متاح أثناء تفعيله؛ الصق رؤوس الكوكيز يدويا في المزودين. Claude/Codex OAuth عبر CLI لا يزال يعمل.";
+"disable_keychain_access_title" = "تعطيل Keychain الوصول";
+"disable_keychain_access_subtitle" = "يمنع أي وصول Keychain أثناء التفعيل.";
+
+/* About Pane */
+"about_tagline" = "عسى أن لا تنفد رموزك أبدا—حافظ على حدود الوكلاء في مرآه.";
+"link_github" = "GitHub";
+"link_website" = "الموقع الإلكتروني";
+"link_twitter" = "تويتر";
+"link_email" = "البريد الإلكتروني";
+"check_updates_auto" = "تحقق تلقائيا من التحديثات";
+"update_channel" = "قناة التحديث";
+"check_for_updates" = "تحقق من التحديثات...";
+"updates_unavailable" = "التحديثات غير متوفرة في هذا الإصدار.";
+"copyright" = "© 2026 بيتر ستاينبرجر. MIT الرخصة.";
+
+/* Debug Pane */
+"section_logging" = "قطع الأشجار";
+"enable_file_logging" = "تمكين تسجيل الملفات";
+"enable_file_logging_subtitle" = "اكتب السجلات إلى %@ للتصحيح.";
+"verbosity_title" = "التكرار";
+"verbosity_subtitle" = "يتحكم في كمية التفاصيل المسجلة.";
+"open_log_file" = "ملف سجل مفتوح";
+"force_animation_next_refresh" = "الرسوم المتحركة بالقوة في التحديث القادم";
+"force_animation_next_refresh_subtitle" = "يعرض مؤقتا حركة التحميل بعد التحديث التالي.";
+"section_loading_animations" = "رسوم التحميل";
+"loading_animations_caption" = "اختر نمطا وأعد تشغيله في شريط القوائم. \"عشوائي\" يحافظ على السلوك القائم.";
+"animation_random_default" = "عشوائي (افتراضي)";
+"replay_selected_animation" = "إعادة تشغيل الرسوم المتحركة المختارة";
+"blink_now" = "ارمش الآن";
+"section_probe_logs" = "سجلات المسبار";
+"probe_logs_caption" = "جلب أحدث مخرجات المسبار للتصحيح؛ النسخة تحتفظ بالنص الكامل.";
+"fetch_log" = "سجل الجلب";
+"copy" = "نسخة";
+"save_to_file" = "احفظ في الملف";
+"load_parse_dump" = "تحميل تحليل التفريغ";
+"rerun_provider_autodetect" = "إعادة تشغيل الكشف التلقائي عن مزود الخدمة";
+"loading" = "جار التحميل...";
+"no_log_yet_fetch" = "لا يوجد سجل بعد. أحضر للتحميل.";
+"section_fetch_strategy" = "محاولات استراتيجية الجلب";
+"fetch_strategy_caption" = "قرارات وأخطاء خط الأنابيب الأخير للجلب للمزود.";
+"section_openai_cookies" = "OpenAI كوكيز";
+"openai_cookies_caption" = "استيراد ملفات تعريف الارتباط + WebKit لجمع سجلات الكوكيز من آخر محاولة OpenAI للكوكيز.";
+"no_log_yet" = "لا يوجد سجل بعد. قم بتحديث ملفات تعريف الارتباط OpenAI في → Codex المزودين لتشغيل استيراد.";
+"section_caches" = "التخزين المؤقت";
+"caches_caption" = "امسح نتائج مسح التكلفة المخبأة أو ملفات تعريف الارتباط في المتصفح.";
+"clear_cookie_cache" = "مسح ذاكرة الكوكيز";
+"clear_cost_cache" = "مسح ذاكرة التكلفة";
+"section_notifications" = "الإشعارات";
+"notifications_caption" = "تفعيل إشعارات الاختبار لنافذة الجلسة التي مدتها 5 ساعات (/restored مستنفد).";
+"post_depleted" = "استنزاف العمود";
+"post_restored" = "تم ترميم العمود";
+"section_cli_sessions" = "جلسات CLI";
+"cli_sessions_caption" = "حافظ على الجلسات Codex/Claude CLI بعد الاستعلام. الخروج الافتراضي بمجرد التقاط البيانات.";
+"keep_cli_sessions_alive" = "حافظ على الجلسات CLI حية";
+"keep_cli_sessions_alive_subtitle" = "تخطي التفكيك بين المجسات (تصحيح فقط).";
+"reset_cli_sessions" = "إعادة تعيين CLI الجلسات";
+"section_error_simulation" = "محاكاة الخطأ";
+"error_simulation_caption" = "قم بإدخال رسالة خطأ مزيفة في بطاقة القائمة لاختبار التخطيط.";
+"set_menu_error" = "خطأ في قائمة التعيين";
+"clear_menu_error" = "خطأ في إزالة القائمة";
+"set_cost_error" = "خطأ تكلفة التعيين";
+"clear_cost_error" = "خطأ واضح في التكلفة";
+"section_cli_paths" = "CLI المسارات";
+"cli_paths_caption" = "تم حل Codex الطبقتين الثنائية و PATH؛ تسجيل الدخول PATH الالتقاط لبدء التشغيل (مهلة قصيرة).";
+"codex_binary" = "Codex الثنائية";
+"claude_binary" = "Claude الثنائية";
+"effective_path" = "PATH فعالة";
+"unavailable" = "غير متوفر";
+"login_shell_path" = "PATH shell تسجيل الدخول (التقاط بدء التشغيل)";
+"cleared" = "تم الموافقة.";
+"no_fetch_attempts" = "لم تحاول الجلب حتى الآن.";
+"macOS Tahoe can block menu bar apps in System Settings → Menu Bar → Allow in the Menu Bar. CodexBar is running, but macOS may be hiding its icon. Open Menu Bar settings and turn CodexBar on." = "macOS Tahoe يمكنها حظر تطبيقات شريط القوائم في إعدادات النظام → شريط القوائم → السماح في شريط القوائم. CodexBar قيد التشغيل، لكن قد يكون macOS يخفي أيقونته. افتح إعدادات شريط القوائم وفعل CodexBar.";
+
+/* Metric preferences */
+"metric_pref_automatic" = "أوتوماتيكي";
+"metric_pref_primary" = "الابتدائي";
+"metric_pref_secondary" = "الثانوية";
+"metric_pref_tertiary" = "الدرجة الثالثة";
+"metric_pref_extra_usage" = "الاستخدام الإضافي";
+"metric_pref_average" = "المتوسط";
+"metric_mistral_payg" = "Pay-as-you-go";
+"metric_mistral_monthly_plan" = "Monthly Plan";
+
+/* Display modes */
+"display_mode_percent" = "النسبة المئوية";
+"display_mode_pace" = "السرعة";
+"display_mode_both" = "كلاهما";
+"display_mode_reset_time" = "وقت إعادة الضبط";
+"display_mode_percent_desc" = "أظهر النسبة المتبقية /used (مثلا 45%)";
+"display_mode_pace_desc" = "مؤشر السرعة (مثلا +5%)";
+"display_mode_both_desc" = "أظهر كل من النسبة المئوية والسرعة (مثلا 45% · +5%)";
+"display_mode_reset_time_desc" = "عرض وقت إعادة الضبط للمقياس المحدد (مثلا ↻ 3:56 مساء)";
+
+/* Provider status */
+"status_operational" = "التشغيل";
+"status_partial_outage" = "انقطاع جزئي";
+"status_major_outage" = "انقطاع كبير";
+"status_critical_issue" = "القضية الحرجة";
+"status_maintenance" = "الصيانة";
+"status_unknown" = "الحالة غير معروفة";
+
+/* Refresh frequency */
+"refresh_manual" = "الدليل";
+"refresh_1min" = "دقيقة واحدة";
+"refresh_2min" = "دقيقتان";
+"refresh_5min" = "5 دقائق";
+"refresh_15min" = "15 دقيقة";
+"refresh_30min" = "30 دقيقة";
+
+/* Additional keys */
+"not_found" = "لم يعثر عليه";
+
+/* Cost estimation */
+"cost_header_estimated" = "التكلفة (تقديرية)";
+"cost_estimate_hint" = "تقديرات من سجلات محلية · قد تختلف عن فاتورتك";
+"No JetBrains IDE with AI Assistant detected. Install a JetBrains IDE and enable AI Assistant." = "لم يتم اكتشاف أي JetBrains IDE مع مساعدة الذكاء الاصطناعي. قم بتثبيت JetBrains IDE وفعل AI Assistant.";
+"OpenRouter API token not configured. Set OPENROUTER_API_KEY environment variable or configure in Settings." = "OpenRouter API الرمز غير مكون. حدد OPENROUTER_API_KEY متغير البيئة أو قم بالتكوين في الإعدادات.";
+"z.ai API token not found. Set apiKey in ~/.codexbar/config.json or Z_AI_API_KEY." = "z.ai API الرمز لم يعثر عليه. اضبط apiKey في ~/.codexbar/config.json أو Z_AI_API_KEY.";
+"Missing DeepSeek API key." = "مفتاح DeepSeek API مفقود.";
+"%@ is unavailable in the current environment." = "%@ غير متاح في البيئة الحالية.";
+"All Systems Operational" = "جميع الأنظمة تعمل";
+"Last 30 days" = "آخر 30 يوما";
+"Last 30 days:" = "آخر 30 يوما:";
+"This month" = "هذا الشهر";
+"Store multiple OpenAI API keys." = "خزن عدة مفاتيح OpenAI API.";
+"Admin API key" = "مفتاح API الإدارة";
+"Open billing" = "الفوترة المفتوحة";
+"Google accounts" = "Google الروايات";
+"Store multiple Antigravity Google OAuth accounts for quick switching." = "تخزين عدة حسابات Antigravity Google OAuth للتبديل السريع.";
+"Add Google Account" = "أضف Google الحساب";
+"Open Token Plan" = "خطة التوكن المفتوحة";
+"Text Generation" = "توليد النصوص";
+"Text to Speech" = "التحويل من النص إلى كلام";
+"Music Generation" = "توليد الموسيقى";
+"Image Generation" = "توليد الصور";
+"No local data found" = "لم يتم العثور على بيانات محلية";
+"Credits unavailable; keep Codex running to refresh." = "الاعتمادات غير متوفرة؛ استمر في Codex لتجديد النشاط.";
+"No available fetch strategy for minimax." = "لا توجد استراتيجية جلب متاحة للمينيماكس.";
+"No Cursor session found. Please log in to cursor.com in Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX, or Edge Canary. If you use Safari, grant CodexBar Full Disk Access in System Settings ▸ Privacy & Security. You can also sign in to Cursor from the CodexBar menu (Add / switch account)." = "لم يتم العثور على جلسة Cursor. يرجى تسجيل الدخول إلى cursor.com في Safari، Chrome، مايكروسوفت إيدج، بريف، آرك، دييا، شات جي بي تي أطلس، كروميوم، هيليوم، فيفالدي، متصفح ياندكس، فايرفوكس، زين، كوليبري، سايدكيك، أوبرا، أوبرا GX، أو إيدج كاناري. إذا كنت تستخدم Safari، امنح CodexBar الوصول الكامل للقرص في إعدادات النظام ▸ الخصوصية والأمان. يمكنك أيضا تسجيل الدخول إلى Cursor من قائمة CodexBar (إضافة / تغيير الحساب).";
+"No OpenCode session cookies found in browsers." = "لا توجد ملفات تعريف الارتباط للجلسة OpenCode في المتصفحات.";
+"No available fetch strategy for %@." = "لا توجد استراتيجية جلب متاحة %@.";
+"Today" = "اليوم";
+"Today tokens" = "الرموز اليوم";
+"30d cost" = "تكلفة 30d";
+"30d tokens" = "رموز 30d";
+"Latest tokens" = "أحدث الرموز";
+"Top model" = "أفضل موديل";
+"Storage" = "التخزين";
+"Add Account..." = "أضف حساب...";
+"Usage Dashboard" = "لوحة تحكم الاستخدام";
+"Status Page" = "صفحة الحالة";
+"Settings..." = "الإعدادات...";
+"About CodexBar" = "حول CodexBar";
+"Quit" = "استقال";
+"Last %d day" = "آخر %d يوم";
+"Last %d days" = "آخر %d أيام";
+"%@ tokens" = "رموز %@";
+"Latest billing day" = "آخر يوم فوترة";
+"Latest billing day (%@)" = "آخر يوم فوترة (%@)";
+"%@ left" = "%@ متبقٍ";
+"Resets %@" = "إعادة التعيين %@";
+"Resets in %@" = "إعادة التعيين في %@";
+"Resets now" = "إعادة التعيين الآن";
+"reset_tomorrow_format" = "غدًا، %@";
+"Lasts until reset" = "يستمر حتى إعادة التعيين";
+"Updated %@" = "تحديث %@";
+"Updated %@h ago" = "تم التحديث %@h قبل";
+"Updated %@m ago" = "تم التحديث %@m قبل";
+"Updated just now" = "تم التحديث للتو";
+"Projected empty in %@" = "إسقاط فارغ في %@";
+"Runs out in %@" = "ينفد في %@";
+"Pace: %@" = "الوتيرة: %@";
+"Pace: %@ · %@" = "الوتيرة: %@ · %@";
+"%@ · %@" = "%@ · %@";
+"≈ %d%% run-out risk" = "≈ %d%% خطر الانتهاء";
+"%d%% in deficit" = "%d%% في العجز";
+"%d%% in reserve" = "%d%% في الاحتياط";
+"usage_percent_suffix_left" = "متبقٍ";
+"usage_percent_suffix_used" = "مستخدم";
+"Store multiple DeepSeek API keys." = "خزن عدة مفاتيح DeepSeek API.";
+"This week" = "هذا الأسبوع";
+"Week" = "الأسبوع";
+"Month" = "الشهر";
+"Models" = "النماذج";
+"24h tokens" = "رموز 24h";
+"Latest hour" = "آخر ساعة";
+"Peak hour" = "ساعة الذروة";
+"Top method" = "الطريقة العليا";
+"30d cash" = "30d نقدا";
+"30d billing history from MiniMax web session" = "30d تاريخ الفوترة من جلسة الويب MiniMax";
+"AWS Cost Explorer billing can lag." = "AWS قد تتأخر فوترة Cost Explorer.";
+"Rate limit: %d / %@" = "الحد الأقصى للسعر: %d / %@";
+"Key remaining" = "المفتاح المتبقي";
+"No limit set for the API key" = "لا يوجد حد محدد لمفتاح API";
+"API key limit unavailable right now" = "API حد المفتاح غير متوفر حاليا";
+"This month: %@ tokens" = "هذا الشهر: %@ الرموز";
+"No utilization data yet." = "لا توجد بيانات استخدام حتى الآن.";
+"No %@ utilization data yet." = "لا توجد بيانات استخدام %@ حتى الآن.";
+"%@: %@%% used" = "%@: %@%% مستخدمة";
+"%dd" = "%d يوم";
+"today" = "اليوم";
+"just now" = "الآن فقط";
+"On pace" = "على الوتيرة";
+"Runs out now" = "ينتهي العدد الآن";
+"Projected empty now" = "متوقعة فارغة الآن";
+"Switch Account..." = "تحويل الحساب...";
+"Update ready, restart now?" = "هل التحديث جاهز، هل أعد التشغيل الآن؟";
+"Daily" = "يوميا";
+"Hourly Tokens" = "الرموز بالساعة";
+"No data" = "لا توجد بيانات";
+"No usage breakdown data available." = "لا توجد بيانات تفصيلية للاستخدام متاحة.";
+
+"Today: %@ · %@ tokens" = "اليوم: %@ · رموز %@";
+"Today: %@" = "اليوم: %@";
+"Today: %@ tokens" = "اليوم: %@ الرموز";
+"Last 30 days: %@ · %@ tokens" = "آخر 30 يوما: %@ · رموز %@";
+"Last 30 days: %@" = "آخر 30 يوما: %@";
+"Est. total (30d): %@" = "التقدير الكلي (30d): %@";
+"Est. total (%@): %@" = "التقدير الكلي (%@): %@";
+"Hover a bar for details" = "مرر المؤشر على الشريط لمزيد من التفاصيل";
+"%@: %@ · %@ tokens" = "%@: %@ · رموز %@";
+"No providers selected for Overview." = "لم يتم اختيار أي مقدمي خدمة للنظرة العامة.";
+"No overview data available." = "لا توجد بيانات عامة متوفرة.";
+"Auto uses the local IDE API first, then Google OAuth when the IDE is closed." = "يستخدم الأوتوماتيكي IDE API المحلي أولا، ثم Google OAuth عندما يكون IDE مغلقا.";
+"Login with Google" = "تسجيل الدخول عبر Google";
+
+/* Popup panels */
+"No usage configured." = "لا يوجد استخدام محدد.";
+"Quota" = "الحصة";
+"tokens" = "الرموز";
+"requests" = "الطلبات";
+"Latest" = "أحدث الإصدارات";
+"Monthly" = "شهريا";
+"Sonnet" = "السوناتة";
+"Overages" = "الزيادات";
+"Activity" = "النشاط";
+"Copied" = "تم النسخ";
+"Copy error" = "خطأ في النسخ.";
+"Copy path" = "مسار النسخ";
+"Extra usage spent" = "الاستخدام الإضافي المخصص";
+"Credits remaining" = "الاعتمادات المتبقية";
+"Using CLI fallback" = "استخدام CLI الخطة الاحتياطية";
+"Balance updates in near-real time (up to 5 min lag)" = "تحديثات التوازن في الوقت شبه الحقيقي (حتى تأخير 5 دقائق)";
+"Daily billing data finalizes at 07:00 UTC" = "يتم الانتهاء من بيانات الفوترة اليومية في الساعة 07:00 UTC";
+"%@ of %@ credits left" = "%@ من %@ اعتمادات متبقية";
+"%@ of %@ bonus credits left" = "%@ من %@ رصيد إضافي متبقي";
+"%@ / %@ (%@ remaining)" = "%@ / %@ (%@ متبقية)";
+"%@/%@ left" = "%@/%@ متبقٍ";
+"Gemini Flash" = "Gemini فلاش";
+"Regenerates %@" = "يجدد %@";
+"used after next regen" = "تم استخدامه بعد التجديد التالي";
+"after next regen" = "بعد التجديد التالي";
+"Near full" = "شبه مكتمل";
+"Full in ~1 regen" = "تجدد كامل ~1";
+"Full in ~%.0f regens" = "جميع التحديثات ~%.0f";
+"Overage usage" = "الاستخدام الزائد";
+"Overage cost" = "تكلفة التجاوز";
+"credits" = "الاعتمادات";
+"Zen balance" = "توازن الزن";
+"API spend" = "API تنفق";
+"Extra usage" = "الاستخدام الإضافي";
+"Quota usage" = "استخدام الحصص";
+"Your spend" = "إنفاقك";
+"%.0f%% used" = "%.0f%% مستخدمة";
+"Usage history (today)" = "تاريخ الاستخدام (اليوم)";
+"Usage history (%d days)" = "تاريخ الاستخدام (%d أيام)";
+"%d percent remaining" = "%d بالمئة المتبقية";
+"Unknown" = "غير معروف";
+"stale data" = "بيانات قديمة";
+"No credits history data." = "لا توجد بيانات عن تاريخ الاعتمادات.";
+"No credits history data available." = "لا توجد بيانات تاريخ الاعتمادات المتاحة.";
+"Credits history chart" = "قائمة تاريخ الاعتمادات";
+"%d days of credits data" = "بيانات %d أيام الاعتمادات";
+"Usage breakdown chart" = "مخطط تحليل الاستخدام";
+"%d days of usage data across %d services" = "%d بيانات الاستخدام عبر خدمات %d";
+"Cost history chart" = "مخطط تاريخ التكاليف";
+"%d days of cost data" = "%d أيام بيانات التكلفة";
+"Plan utilization chart" = "مخطط استخدام الخطة";
+"%d utilization samples" = "%d عينات الاستخدام";
+"Hourly Usage" = "الاستخدام بالساعة";
+"Usage remaining" = "الاستخدام المتبقي";
+"Usage used" = "الاستخدام المستخدم";
+"API key verified. Ollama does not expose Cloud quota limits through the API." = "تم التحقق من API المفتاح. Ollama لا يكشف حدود حصص السحابة عبر API.";
+"Last 30 days: %@ tokens" = "آخر 30 يوما: %@ الرموز";
+"7d spend" = "7d تنفق";
+"30d spend" = "30d تنفق";
+"Cache read" = "قراءة الذاكرة المؤقتة";
+"Claude Admin API 30 day spend trend" = "Claude API المسؤول اتجاه الإنفاق لمدة 30 يوما";
+"OpenRouter API key spend trend" = "OpenRouter API الاتجاه الرئيسي للإنفاق";
+"z.ai hourly token trend" = "z.ai اتجاه الرموز بالساعة";
+"MiniMax 30 day token usage trend" = "MiniMax اتجاه استخدام الرموز خلال 30 يوما";
+"Today cash" = "اليوم نقدا";
+"DeepSeek 30 day token usage trend" = "DeepSeek اتجاه استخدام الرموز خلال 30 يوما";
+"cache-hit input" = "إدخال الضربات المؤقتة";
+"cache-miss input" = "إدخال ذاكرة تخزين مؤقت (CACHE-miss)";
+"output" = "الإنتاج";
+"Requests" = "الطلبات";
+"Reported by OpenAI Admin API organization usage." = "تم الإبلاغ عنه من قبل OpenAI الإدارة API استخدام المنظمة.";
+"Reported by Mistral billing usage." = "تم الإبلاغ عنه حسب استخدام Mistral الفوترة.";
+"Google OAuth" = "Google OAuth";
+"Add accounts via GitHub OAuth Device Flow on the selected host." = "أضف حسابات عبر تدفق الجهاز GitHub OAuth على المضيف المحدد.";
+"Stores each signed-in Google account for quick Antigravity switching. Uses Antigravity.app OAuth when available, or ANTIGRAVITY_OAUTH_CLIENT_ID and ANTIGRAVITY_OAUTH_CLIENT_SECRET as an override." = "يخزن كل حساب Google مسجلا للتبديل السريع Antigravity. يستخدم Antigravity.app OAuth عندما يتوفر البرنامج، أو ANTIGRAVITY_OAUTH_CLIENT_ID و ANTIGRAVITY_OAUTH_CLIENT_SECRET كوسيلة تجاوز.";
+"Manual cleanup: past sessions" = "التنظيف اليدوي: الجلسات السابقة";
+"Clearing removes past resume, continue, and rewind history." = "إزالة الفحص القديم يحذف السيرة الذاتية السابقة، استمر، وإعادة التاريخ إلى الوراء.";
+"Manual cleanup: file checkpoints" = "التنظيف اليدوي: نقاط تفتيش الملفات";
+"Clearing removes checkpoint restore data for previous edits." = "مسح البيانات يزيل بيانات استعادة نقاط التحقق من التعديلات السابقة.";
+"Manual cleanup: saved plans" = "التنظيف اليدوي: الخطط المحفوظة";
+"Clearing removes old plan-mode files." = "إزالة الملفات القديمة في وضع التخطيط.";
+"Manual cleanup: debug logs" = "التنظيف اليدوي: تصحيح السجلات";
+"Clearing removes past debug logs." = "المسح يزيل سجلات التصحيح السابقة.";
+"Manual cleanup: attachment cache" = "التنظيف اليدوي: ذاكرة التخزين المؤقت للملحقات";
+"Clearing removes cached large pastes or attached images." = "إزالة المسح إزالة المعجون الكبيرة المخزنة أو الصور المرفقة.";
+"Manual cleanup: session metadata" = "التنظيف اليدوي: بيانات الجلسة الوصفية";
+"Clearing removes per-session environment metadata." = "إزالة المسح يزيل بيانات وصفية البيئة لكل جلسة.";
+"Manual cleanup: shell snapshots" = "التنظيف اليدوي: لقطات الغلاف";
+"Clearing removes leftover runtime shell snapshot files." = "إزالة الملفات المتبقية من ملفات لقطات الصدفة التشغيلية.";
+"Manual cleanup: legacy todos" = "تنظيف يدوي: المهام القديمة";
+"Clearing removes legacy per-session task lists." = "إزالة المهمة تزيل قوائم المهام القديمة لكل جلسة.";
+"Manual cleanup: sessions" = "التنظيف اليدوي: الجلسات";
+"Clearing removes past Codex session history." = "إزالة الفحص تحذف سجل الجلسة Codex السابق.";
+"Manual cleanup: archived sessions" = "التنظيف اليدوي: الجلسات المؤرشفة";
+"Clearing removes archived Codex session history." = "المسح يزيل تاريخ الجلسة Codex المؤرشف.";
+"Manual cleanup: cache" = "التنظيف اليدوي: ذاكرة تخزين مؤقت";
+"Clearing removes provider-owned cached data." = "إزالة المسح تزيل البيانات المخزنة مؤقتا المملوكة لمزود الخدمة.";
+"Manual cleanup: logs" = "التنظيف اليدوي: السجلات";
+"Clearing removes local diagnostic logs." = "إزالة السجلات المحلية للتشخيص.";
+"Manual cleanup: file history" = "تنظيف الدليل اليدوي: سجل الملفات";
+"Clearing removes local edit checkpoint history." = "المسح يزيل سجل نقاط التحرير المحلية.";
+"Manual cleanup: temporary data" = "التنظيف اليدوي: بيانات مؤقتة";
+"Clearing removes local temporary provider data." = "المسح يزيل بيانات مقدم الخدمة المؤقت المحلي.";
+"Total: %@" = "المجموع: %@";
+"%d more items" = "%d المزيد من العناصر";
+"Other (%d items)" = "أخرى (%d عناصر)";
+"Expand" = "توسيع";
+"Collapse" = "طيّ";
+"Cleanup ideas" = "أفكار التنظيف";
+"%d unreadable item(s) skipped" = "%d العناصر غير القابلة للقراءة تم تخطيها";
+
+"API key limit" = "حد API المفتاح";
+"Auth" = "المصادقة";
+"Auto" = "أوتو";
+"Disabled — no recent data" = "معطلة — لا توجد بيانات حديثة";
+"Limits not available" = "الحدود غير المتاحة";
+"No usage yet" = "لم يستخدم حتى الآن";
+"Not fetched yet" = "لم يتم إحضاره بعد";
+"Refreshing" = "منعش";
+"Session" = "الجلسة";
+"Source" = "المصدر";
+"State" = "الدولة";
+"Unavailable" = "غير متوفر";
+"Weekly" = "الأسبوعي";
+"not detected" = "لم يتم اكتشافه";
+"Estimated from local Codex logs for the selected account." = "تم التقدير من سجلات Codex المحلية للحساب المختار.";
+"minimax_usage_amount_format" = "الاستخدام: %@ / %@";
+"minimax_used_percent_format" = "المستخدم %@";
+"minimax_service_text_generation" = "توليد النصوص";
+"minimax_service_text_to_speech" = "التحويل من النص إلى كلام";
+"minimax_service_music_generation" = "توليد الموسيقى";
+"minimax_service_image_generation" = "توليد الصور";
+"minimax_service_lyrics_generation" = "توليد الكلمات";
+"minimax_service_coding_plan_vlm" = "خطة البرمجة VLM";
+"minimax_service_coding_plan_search" = "البحث عن خطة الترميز";
+
+/* Additional provider settings and alerts */
+"%@ is waiting for permission" = "%@ ينتظر الإذن";
+"%@ requests" = "طلبات %@";
+"%@: %@ credits" = "%@: %@ اعتمادات";
+"30d requests" = "طلبات 30d";
+"4 days" = "4 أيام";
+"5 days" = "5 أيام";
+"7 days" = "7 أيام";
+"API key verifies Ollama Cloud access; cookies still expose quota limits." = "API المفتاح يتحقق Ollama الوصول إلى السحابة؛ لا تزال ملفات تعريف الارتباط تكشف عن حدود الحصص.";
+"AWS access key ID. Can also be set with AWS_ACCESS_KEY_ID." = "AWS معرف مفتاح الوصول. يمكن أيضا ضبطها باستخدام AWS_ACCESS_KEY_ID.";
+"AWS region. Can also be set with AWS_REGION." = "AWS المنطقة. يمكن أيضا ضبطها باستخدام AWS_REGION.";
+"AWS secret access key. Can also be set with AWS_SECRET_ACCESS_KEY." = "AWS مفتاح وصول سري. يمكن أيضا ضبطها باستخدام AWS_SECRET_ACCESS_KEY.";
+"Access key ID" = "معرف مفتاح الوصول";
+"Add Account" = "إضافة حساب";
+"Adding Account…" = "إضافة حساب...";
+"Antigravity login failed" = "فشل تسجيل الدخول Antigravity";
+"Antigravity login timed out" = "انتهى وقت تسجيل الدخول Antigravity";
+"Auth source" = "المصدر المعتمد";
+"Automatic imports browser cookies from Xiaomi MiMo." = "يقوم الكوكيز تلقائيا باستيراد ملفات تعريف الارتباط من Xiaomi MiMo.";
+"Automatic imports Windsurf session data from Chromium browser localStorage." = "يقوم الاستيراد التلقائي Windsurf بيانات الجلسة من متصفح Chromium localStorage.";
+"Automatic imports browser cookies from Bailian." = "يقوم الاستيراد التلقائي بملفات تعريف الارتباط من المتصفح من Bailian.";
+"Automatically imports browser cookies." = "يقوم باستيراد ملفات تعريف الارتباط تلقائيا في المتصفح.";
+"Automatically imports browser session cookies." = "يقوم تلقائيا باستيراد ملفات تعريف الارتباط لجلسات المتصفح.";
+"Azure OpenAI deployment name. AZURE_OPENAI_DEPLOYMENT_NAME is also supported." = "اسم Azure OpenAI الانتشار. AZURE_OPENAI_DEPLOYMENT_NAME مدعوم أيضا.";
+"Azure OpenAI key" = "مفتاح Azure OpenAI";
+"Azure OpenAI resource endpoint. AZURE_OPENAI_ENDPOINT is also supported." = "Azure OpenAI نقطة نهاية الموارد. AZURE_OPENAI_ENDPOINT مدعوم أيضا.";
+"Base URL" = "URL القاعدة";
+"Base URL for the LLM-API-Key-Proxy instance." = "URL أساسي لنسخة LLM-API-Key-Proxy (الوكيل الرئيسي).";
+"Browser cookies" = "ملفات تعريف الارتباط في المتصفح";
+"Cap end" = "نهاية الغطاء";
+"Cap start" = "بداية الكابر";
+"Capacity End" = "نهاية السعة";
+"Capacity Start" = "بدء السعة";
+"Changelog" = "سجل التغييرات";
+"Choose the Moonshot/Kimi API host for international or China mainland accounts." = "اختر المضيف Moonshot/Kimi API للحسابات الدولية أو القارية الصينية.";
+"CodexBar can't replace a system account that is signed in with an API key only setup." = "لا CodexBar استبدال حساب نظام مسجل الدخول بإعداد API فقط على المفتاح.";
+"CodexBar could not find saved auth for that account. Re-authenticate it and try again." = "لم CodexBar العثور على مصحة محفوظة لهذا الحساب. أعد التحقق من صحتك وحاول مرة أخرى.";
+"CodexBar could not read managed account storage. Recover the store before adding another account." = "لم يكن CodexBar قادرا على قراءة تخزين الحساب المدار. استرجع المتجر قبل إضافة حساب آخر.";
+"CodexBar could not read saved auth for that account. Re-authenticate it and try again." = "لم CodexBar أستطيع قراءة المصادقة المحفوظة لهذا الحساب. أعد التحقق من صحتك وحاول مرة أخرى.";
+"CodexBar could not read the current system account on this Mac." = "لم CodexBar أستطيع قراءة حساب النظام الحالي على هذا الجهاز.";
+"CodexBar could not replace the live Codex auth on this Mac." = "لم CodexBar استطعت استبدال المصادقة الحية Codex على هذا الجهاز.";
+"CodexBar could not safely preserve the current system account before switching." = "لم يكن بإمكان CodexBar الحفاظ على حساب النظام الحالي بأمان قبل التحويل.";
+"CodexBar could not save the current system account before switching." = "لم يكن بإمكان CodexBar حفظ حساب النظام الحالي قبل التحويل.";
+"CodexBar could not update managed account storage." = "لم يتمكن CodexBar تحديث تخزين الحساب المدار.";
+"CodexBar found another managed account that already uses the current system account. Resolve the duplicate account before switching." = "CodexBar وجدت حسابا مديرا آخر يستخدم حساب النظام الحالي بالفعل. قم بحل مشكلة الحساب المكرر قبل التغيير.";
+"CodexBar will ask macOS Keychain for “%@” so it can decrypt browser cookies and authenticate your account. Click OK to continue." = "سيطلب CodexBar macOS Keychain \"%@\" حتى يتمكن من فك تشفير ملفات تعريف الارتباط في المتصفح وتوثيق حسابك. انقر موافقا للمتابعة.";
+"CodexBar will ask macOS Keychain for the Claude Code OAuth token so it can fetch your Claude usage. Click OK to continue." = "سيطلب CodexBar macOS Keychain رمز Claude OAuth ليتمكن من جلب استخدامك Claude. انقر موافقا للمتابعة.";
+"CodexBar will ask macOS Keychain for your Amp cookie header so it can fetch usage. Click OK to continue." = "CodexBar سيطلب macOS Keychain رأس الكوكيز Amp الخاص بك حتى يتمكن من استخدام الاستخدام. انقر موافقا للمتابعة.";
+"CodexBar will ask macOS Keychain for your Augment cookie header so it can fetch usage. Click OK to continue." = "CodexBar سيطلب macOS Keychain رأس الكوكيز Augment الخاص بك حتى يتمكن من استخدام الاستخدام. انقر موافقا للمتابعة.";
+"CodexBar will ask macOS Keychain for your Claude cookie header so it can fetch Claude web usage. Click OK to continue." = "CodexBar ستطلب macOS Keychain رأس الكوكيز Claude الخاص بك حتى يتمكن من جلب Claude استخدام الويب. انقر موافقا للمتابعة.";
+"CodexBar will ask macOS Keychain for your Cursor cookie header so it can fetch usage. Click OK to continue." = "CodexBar سيطلب macOS Keychain رأس الكوكيز Cursor الخاص بك حتى يتمكن من استخدام الاستخدام. انقر موافقا للمتابعة.";
+"CodexBar will ask macOS Keychain for your Factory cookie header so it can fetch usage. Click OK to continue." = "CodexBar سيطلب macOS Keychain رأس الكوكيز Factory الخاص بك حتى يتمكن من استخدام الاستخدام. انقر موافقا للمتابعة.";
+"CodexBar will ask macOS Keychain for your GitHub Copilot token so it can fetch usage. Click OK to continue." = "CodexBar سيطلب macOS Keychain رمز GitHub Copilot الخاص بك حتى يتمكن من استدعاء الاستخدام. انقر موافقا للمتابعة.";
+"CodexBar will ask macOS Keychain for your Kimi K2 API key so it can fetch usage. Click OK to continue." = "CodexBar سيطلب macOS Keychain مفتاح API K2 Kimi الخاص بك حتى يتمكن من جلب الاستخدام. انقر موافقا للمتابعة.";
+"CodexBar will ask macOS Keychain for your Kimi auth token so it can fetch usage. Click OK to continue." = "CodexBar سيطلب macOS Keychain رمز التوثيق Kimi الخاص بك حتى يتمكن من استدعاء الاستخدام. انقر موافقا للمتابعة.";
+"CodexBar will ask macOS Keychain for your MiniMax API token so it can fetch usage. Click OK to continue." = "CodexBar سيطلب macOS Keychain رمز MiniMax API الخاص بك حتى يتمكن من استدعاء الاستخدام. انقر موافقا للمتابعة.";
+"CodexBar will ask macOS Keychain for your MiniMax cookie header so it can fetch usage. Click OK to continue." = "CodexBar سيطلب macOS Keychain رأس الكوكيز MiniMax الخاص بك حتى يتمكن من استخدام الاستخدام. انقر موافقا للمتابعة.";
+"CodexBar will ask macOS Keychain for your OpenAI cookie header so it can fetch Codex dashboard extras. Click OK to continue." = "سيطلب CodexBar macOS Keychain رأس الكوكيز OpenAI الخاص بك حتى يتمكن من جلب إضافات Codex لوحة التحكم. انقر موافقا للمتابعة.";
+"CodexBar will ask macOS Keychain for your OpenCode cookie header so it can fetch usage. Click OK to continue." = "CodexBar سيطلب macOS Keychain رأس الكوكيز OpenCode الخاص بك حتى يتمكن من استخدام الاستخدام. انقر موافقا للمتابعة.";
+"CodexBar will ask macOS Keychain for your Synthetic API key so it can fetch usage. Click OK to continue." = "CodexBar ستطلب macOS Keychain مفتاح Synthetic API الخاص بك حتى يتمكن من جلب الاستخدام. انقر موافقا للمتابعة.";
+"CodexBar will ask macOS Keychain for your z.ai API token so it can fetch usage. Click OK to continue." = "CodexBar سيطلب macOS Keychain رمز z.ai API الخاص بك حتى يتمكن من استدعاء الاستخدام. انقر موافقا للمتابعة.";
+"Could not open Cursor login in your browser." = "لم أتمكن من فتح Cursor تسجيل الدخول في متصفحك.";
+"Could not open browser for Antigravity" = "لم أتمكن من فتح المتصفح من Antigravity";
+"Credits used" = "الاعتمادات المستخدمة";
+"Day" = "اليوم";
+"Deployment" = "النشر";
+"Drag to reorder" = "سحب لإعادة ترتيب";
+"Sort providers alphabetically" = "فرز المزوّدين أبجديًا";
+"Sort providers alphabetically (enabled first)" = "فرز المزوّدين أبجديًا (المفعّلون أولاً)";
+"Sorted alphabetically (enabled first) — click to use your custom order" = "مرتّبة أبجديًا (المفعّلون أولاً) — انقر لاستخدام ترتيبك المخصّص";
+"Endpoint" = "نقطة النهاية";
+"Enterprise host" = "مضيف مؤسسي";
+"Extra usage balance: %@" = "توازن الاستخدام الإضافي: %@";
+"Keychain Access Required" = "Keychain الوصول المطلوب";
+"Kiro menu bar value" = "Kiro قيمة شريط القائمة";
+"Label" = "العلامة التجارية";
+"No organizations loaded. Click Refresh after setting your API key." = "لا توجد منظمات محملة. انقر على تحديث بعد تعيين مفتاح API.";
+"No output captured." = "لم يتم التقاط أي مخرجات.";
+"No system account" = "لا يوجد حساب نظام";
+"Oasis-Token" = "رمز الواحة";
+"Open Augment (Log Out & Back In)" = "فتح Augment (تسجيل الخروج والعودة للدخول)";
+"Open Codebuff Dashboard" = "لوحة تحكم مفتوحة Codebuff";
+"Open Command Code Settings" = "افتح إعدادات Command Code";
+"Open Crof dashboard" = "لوحة تحكم Open Crof";
+"Open Manus" = "فتح Manus";
+"Open MiMo Balance" = "توازن MiMo مفتوح";
+"Open Moonshot Console" = "وحدة التحكم المفتوحة Moonshot";
+"Open Ollama API Keys" = "مفاتيح Ollama API المفتوحة";
+"Open StepFun Platform" = "منصة StepFun المفتوحة";
+"Open T3 Chat Settings" = "افتح إعدادات T3 Chat";
+"Open Volcengine Ark Console" = "وحدة تحكم فولكموتور المفتوحة";
+"Open legacy provider docs" = "وثائق مزود الوراثة المفتوحة";
+"Open projects" = "المشاريع المفتوحة";
+"Open this URL manually to continue login:\n\n%@" = "افتح هذا URL يدويا لمتابعة تسجيل الدخول:\n\n%@";
+"Optional organization ID for accounts linked to multiple Anthropic organizations." = "معرف منظمة اختياري للحسابات المرتبطة بعدة منظمات أنثروبية.";
+"Optional. Applies to the configured Admin API key; selected token accounts do not inherit OPENAI_PROJECT_ID." = "اختياري. ينطبق على مفتاح API المسؤول المكون؛ بعض الحسابات الرمزية لا ترث OPENAI_PROJECT_ID.";
+"Optional. Enter your GitHub Enterprise host, for example octocorp.ghe.com. Leave blank for github.com." = "اختياري. هنا يأتي مضيف GitHub Enterprise، على سبيل المثال octocorp.ghe.com. اترك الفراغ github.com.";
+"Optional. Leave blank to discover and aggregate projects visible to the API key." = "اختياري. اترك فارغا لاكتشاف وتجميع المشاريع المرئية لمفتاح API.";
+"Org ID (optional)" = "معرف المنظمة (اختياري)";
+"Organizations" = "المنظمات";
+"Password" = "كلمة المرور";
+"%@ authentication is disabled." = "%@ المصادقة معطلة.";
+"%@ cookies are disabled." = "%@ ملفات تعريف الارتباط معطلة.";
+"%@ web API access is disabled." = "%@ الوصول إلى API الويب معطل.";
+"Disable %@ dashboard cookie usage." = "قم بتعطيل استخدام ملفات تعريف الارتباط %@ لوحة التحكم.";
+"Keychain access is disabled in Advanced, so browser cookie import is unavailable." = "Keychain الوصول معطل في القسم المتقدم، لذا فإن استيراد ملفات تعريف الارتباط من المتصفح غير متاح.";
+"Manually paste an %@ from a browser session." = "قم بلصق %@ يدويا من جلسة متصفح.";
+"Paste a Cookie header captured from %@." = "الصق رأس كوكي تم التقاطه من %@.";
+"Paste a Cookie header from %@." = "لصق رأس كوكي من %@.";
+"Paste a Cookie header or cURL capture from %@." = "الصق رأس كوكي أو التقاط رابط cURL من %@.";
+"Paste a Cookie header or full cURL capture from %@." = "الصق رأس كوكي أو التقاط CURL بالكامل من %@.";
+"Paste a Cookie or Authorization header from %@." = "الصق رأس كوكيز أو تفويض من %@.";
+"Paste a full cookie header or the %@ value." = "الصق رأس كوكيز كامل أو قيمة %@.";
+"Paste a Cookie header or full cURL capture from T3 Chat settings." = "الصق رأس كوكي أو التقاط CURL بالكامل من T3 Chat الإعدادات.";
+"Paste the Cookie header from a request to admin.mistral.ai. Must contain an ory_session_* cookie." = "الصق رأس الكوكي من طلب إلى admin.mistral.ai. يجب أن يحتوي على كوكيز ory_session_*.";
+"Paste the Oasis-Token from a logged-in browser session on platform.stepfun.com." = "الصق رمز الواحة من جلسة متصفح مسجلة الدخول على platform.stepfun.com.";
+"Paste the %@ JSON bundle from %@." = "الصق حزمة %@ JSON من %@.";
+"Paste the %@ value or a full Cookie header." = "الصق قيمة %@ أو رأس كوكي كامل.";
+"Personal account" = "الحساب الشخصي";
+"Project ID" = "معرف المشروع";
+"Re-auth" = "إعادة التصديق";
+"Re-login at claude.ai" = "إعادة تسجيل الدخول في claude.ai";
+"Re-authenticating…" = "إعادة التوثيق...";
+"Refresh Session" = "جلسة التحديث";
+"Refresh organizations" = "تحديث المنظمات";
+"Region" = "المنطقة";
+"Reload" = "إعادة التعبئة";
+"Reorder" = "إعادة ترتيب";
+"Secret access key" = "مفتاح الوصول السري";
+"Series" = "السلسلة";
+"Service" = "الخدمة";
+"Show or hide Kiro credits, percent, or both next to the menu bar icon." = "اعرض أو أخف Kiro الاعتمادات، النسبة المئوية، أو كلاهما بجانب أيقونة شريط القوائم.";
+"Show usage for organizations you belong to. Personal account is always shown." = "اعرض الاستخدام للمنظمات التي تنتمي إليها. الحساب الشخصي يعرض دائما.";
+"Sign in to cursor.com in your browser, then refresh Cursor in CodexBar." = "سجل الدخول إلى cursor.com في متصفحك، ثم قم بتحديث Cursor في CodexBar.";
+"Simulated error text" = "نص خطأ محاكى";
+"StepFun platform account (phone number or email)." = "StepFun حساب المنصة (رقم الهاتف أو البريد الإلكتروني).";
+"Stored in ~/.codexbar/config.json." = "مخزنة في ~/.codexbar/config.json.";
+"Stored in ~/.codexbar/config.json. AZURE_OPENAI_API_KEY is also supported." = "كما يدعم التخزين في ~/.codexbar/config.json. AZURE_OPENAI_API_KEY.";
+"Stored in ~/.codexbar/config.json. For the official Kimi API, use Moonshot / Kimi API." = "مخزن في ~/.codexbar/config.json. بالنسبة Kimi API الرسمي، استخدم Moonshot / Kimi API.";
+"Stored in ~/.codexbar/config.json. Get your API key from the Volcengine Ark console." = "مخزن في ~/.codexbar/config.json. احصل على مفتاح API من وحدة التحكم Volcengine Ark.";
+"Stored in ~/.codexbar/config.json. Get your key from Ollama settings." = "مخزن في ~/.codexbar/config.json. احصل على مفتاحك من Ollama الإعدادات.";
+"Stored in ~/.codexbar/config.json. Get your key from console.deepgram.com." = "مخزن في ~/.codexbar/config.json. احصل على مفتاحك من console.deepgram.com.";
+"Stored in ~/.codexbar/config.json. Get your key from elevenlabs.io/app/settings/api-keys." = "مخزن في ~/.codexbar/config.json. احصل على مفتاحك من elevenlabs.io/app/settings/api-keys.";
+"Stored in ~/.codexbar/config.json. Get your key from openrouter.ai/settings/keys and set a key spending limit there to enable API key quota tracking." = "مخزن في ~/.codexbar/config.json. احصل على مفتاحك من openrouter.ai/settings/keys وحدد حدا لإنفاق المفاتيح هناك لتمكين تتبع حصص API المفاتيح.";
+"Stored in ~/.codexbar/config.json. In Warp, open Settings > Platform > API Keys, then create one." = "مخزن في ~/.codexbar/config.json. في Warp، افتح الإعدادات > مفاتيح > API المنصة، ثم أنشئ واحدا.";
+"Stored in ~/.codexbar/config.json. Metrics require Groq Enterprise Prometheus access." = "التخزين في ~/.codexbar/config.json. Metrics يتطلب الوصول Groq Prometheus Enterprise.";
+"Stored in ~/.codexbar/config.json. OPENAI_ADMIN_KEY is preferred; OPENAI_API_KEY still works." = "يفضل التخزين في ~/.codexbar/config.json. OPENAI_ADMIN_KEY؛ OPENAI_API_KEY لا يزال يعمل.";
+"Stored in ~/.codexbar/config.json. Requires an Anthropic Admin API key." = "التخزين في ~/.codexbar/config.json. يتطلب مفتاح API إداري بشري.";
+"Stored in ~/.codexbar/config.json. Used for /v1/quota-stats." = "مخزنة في ~/.codexbar/config.json. تستخدم /v1/quota-stats.";
+"Stored in ~/.codexbar/config.json. You can also provide CODEBUFF_API_KEY or let CodexBar read ~/.config/manicode/credentials.json (created by `codebuff login`)." = "مخزن في ~/.codexbar/config.json. يمكنك أيضا توفير CODEBUFF_API_KEY أو السماح CodexBar بقراءة ~/.config/manicode/credentials.json (تم إنشاؤه بواسطة `codebuff login`).";
+"Stored in ~/.codexbar/config.json. You can also provide CROF_API_KEY." = "مخزن في ~/.codexbar/config.json. يمكنك أيضا توفير CROF_API_KEY.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or ~/.local/share/kilo/auth.json (kilo.access)." = "مخزنة في ~/.codexbar/config.json. يمكنك أيضا توفير KILO_API_KEY أو ~/.local/share/kilo/auth.json (كيلو.أكس).";
+"T3 Chat cookie" = "T3 Chat كوكي";
+"That account is no longer available in CodexBar. Refresh the account list and try again." = "هذا الحساب لم يعد متاحا في عام CodexBar. قم بتحديث قائمة الحسابات وحاول مرة أخرى.";
+"The browser login did not complete in time. Try Antigravity login again." = "لم يكتمل تسجيل الدخول في المتصفح في الوقت المناسب. حاول تسجيل الدخول Antigravity مرة أخرى.";
+"Timed out waiting for Cursor login. %@" = "انتهى الوقت في انتظار تسجيل الدخول Cursor. %@";
+"Timed out waiting for Cursor login. %@ Last error: %@" = "انتهى الوقت في انتظار تسجيل الدخول Cursor. %@ آخر خطأ: %@";
+"Today requests" = "طلبات اليوم";
+"Total (30d): %@ credits" = "الإجمالي (30d): %@ ساعات معتمدة";
+"Username" = "اسم المستخدم";
+"Uses username + password to login and obtain an Oasis-Token automatically." = "يستخدم اسم المستخدم + كلمة المرور لتسجيل الدخول والحصول تلقائيا على رمز الواحة.";
+"Uses username + password to login and obtain an %@ automatically." = "يستخدم اسم المستخدم + كلمة المرور لتسجيل الدخول والحصول على %@ تلقائيا.";
+"Utilization End" = "نهاية الاستخدام";
+"Utilization Start" = "بداية الاستخدام";
+"Verbosity" = "التكرار";
+"Windsurf session JSON bundle" = "حزمة Windsurf JSON الجلسة";
+"Workspace ID" = "معرف مساحة العمل";
+"Your StepFun platform password. Used to login and obtain a session token." = "كلمة مرور المنصة StepFun الخاصة بك. يستخدم لتسجيل الدخول والحصول على رمز الجلسة.";
+"claude /login exited with status %d." = "/login كلود غادر بوضعية %d.";
+"codex login exited with status %d." = "تم الخروج من تسجيل الدخول إلى الكودكس مع الحالة %d.";
+"Cookie: …\n\nor paste a cURL capture from the Abacus AI dashboard" = "كوكي: ... \n\n أو لصق التقاط cURL من لوحة Abacus AI";
+"Cookie: …\n\nor paste the __Secure-next-auth.session-token value" = "كوكي: ... \n\n أو لصق قيمة __Secure-next-auth.session-token";
+"Cookie: …\n\nor paste the kimi-auth token value" = "كوكي: ... \n\n أو لصق قيمة رمز kimi-authentic";
+"session_id=...\n\nor paste just the session_id value" = "session_id=... \n\n أو لصق القيمة session_id فقط";
+"Clear" = "واضح";
+"No matching providers" = "لا يوجد مزودون مطابقون";
+"Search providers" = "مزودو البحث";
+
+"language_vietnamese" = "الفيتناميون";
+"language_indonesian" = "بهاسا إندونيسيا";
+
+"Request quota: %@ / %@" = "طلب الحصة: %@ / %@";
+"language_arabic" = "العربية";
+"language_persian" = "فارسی";
+"language_thai" = "ไทย";
+"Limit Reset Credits" = "أرصدة إعادة تعيين الحد";
+"1 manual reset available" = "تتوفر إعادة تعيين يدوية واحدة";
+"%d manual resets available" = "تتوفر %d عمليات إعادة تعيين يدوية";
+"Next expires %@" = "تنتهي صلاحية التالية %@";
+"byte_unit_byte" = "بايت";
+"byte_unit_bytes" = "بايتات";
+"byte_unit_kilobyte" = "كيلوبايت";
+"byte_unit_kilobytes" = "كيلوبايتات";
+"byte_unit_megabyte" = "ميغابايت";
+"byte_unit_megabytes" = "ميغابايتات";
+"byte_unit_gigabyte" = "غيغابايت";
+"byte_unit_gigabytes" = "غيغابايتات";
diff --git a/Sources/CodexBar/Resources/ca.lproj/Localizable.strings b/Sources/CodexBar/Resources/ca.lproj/Localizable.strings
new file mode 100644
index 0000000000..1ebe5878aa
--- /dev/null
+++ b/Sources/CodexBar/Resources/ca.lproj/Localizable.strings
@@ -0,0 +1,1109 @@
+/* Catalan localization for CodexBar */
+
+" providers" = " proveïdors";
+"(System)" = "(Sistema)";
+"30d" = "30 d";
+"A managed Codex login is already running. Wait for it to finish before adding " = "Ja hi ha un inici de sessió gestionat de Codex en curs. Espera que acabi abans d'afegir ";
+"API key" = "Clau d'API";
+"API region" = "Regió de l'API";
+"API token" = "Token d'API";
+"API tokens" = "Tokens d'API";
+"About" = "Quant a";
+"Account" = "Compte";
+"Accounts" = "Comptes";
+"Accounts subtitle" = "Subtítol de comptes";
+"Active" = "Actiu";
+"Add" = "Afegeix";
+"Add Workspace" = "Afegiu espai de treball";
+"Advanced" = "Avançat";
+"All" = "Tot";
+"Always allow prompts" = "Permeteu sempre les sol·licituds";
+"Animation pattern" = "Patró d'animació";
+"Antigravity login is managed in the app" = "L'inici de sessió d'Antigravity es gestiona a l'app";
+"Applies only to the Security.framework OAuth keychain reader." = "Només s'aplica al lector de Clauer OAuth de Security.framework.";
+"Auto falls back to the next source if the preferred one fails." = "Auto recorre a la font següent si la preferida falla.";
+"Auto uses API first, then falls back to CLI on auth failures." = "Auto fa servir primer l'API i recorre a la CLI si falla l'autenticació.";
+"Auto-detect" = "Detecció automàtica";
+"Auto-refresh is off; use the menu's Refresh command." = "L'actualització automàtica està desactivada; feu servir l'ordre Actualitza del menú.";
+"Auto-refresh: hourly · Timeout: 10m" = "Actualització automàtica: cada hora · Temps d'espera: 10 min";
+"Automatic" = "Automàtic";
+"Automatic imports browser cookies and WorkOS tokens." = "El mode automàtic importa galetes del navegador i tokens de WorkOS.";
+"Automatic imports browser cookies and local storage tokens." = "El mode automàtic importa galetes del navegador i tokens de l'emmagatzematge local.";
+"Automatic imports browser cookies for dashboard extras." = "El mode automàtic importa galetes del navegador per als extres del tauler.";
+"Automatic imports browser cookies for the web API." = "El mode automàtic importa galetes del navegador per a l'API web.";
+"Automatic imports browser cookies from Model Studio/Bailian." = "El mode automàtic importa galetes del navegador des de Model Studio/Bailian.";
+"Automatic imports browser cookies from admin.mistral.ai." = "El mode automàtic importa galetes del navegador des d'admin.mistral.ai.";
+"Automatic imports browser cookies from opencode.ai." = "El mode automàtic importa galetes del navegador des d'opencode.ai.";
+"Automatic imports browser cookies or stored sessions." = "El mode automàtic importa galetes del navegador o sessions desades.";
+"Automatic imports browser cookies." = "El mode automàtic importa galetes del navegador.";
+"Automatically imports browser session cookie." = "Importa automàticament la galeta de sessió del navegador.";
+"Automatically opens CodexBar when you start your Mac." = "Obre el CodexBar automàticament en iniciar el Mac.";
+"Automation" = "Automatització";
+"Average (\\(label1) + \\(label2))" = "Mitjana (\\(label1) + \\(label2))";
+"Average (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))" = "Mitjana (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))";
+"Avoid Keychain prompts" = "Evita les sol·licituds del Clauer";
+"Balance" = "Saldo";
+"Battery Saver" = "Estalvi de bateria";
+"Bordered" = "Amb vora";
+"Build" = "Compilació";
+"Built \\(buildTimestamp)" = "Compilat \\(buildTimestamp)";
+"Buy Credits..." = "Compreu crèdits...";
+"Buy Credits…" = "Compreu crèdits…";
+"CLI paths" = "Camins de la CLI";
+"CLI sessions" = "Sessions de la CLI";
+"Caches" = "Memòries cau";
+"Cancel" = "Cancel·la";
+"Check for Updates…" = "Cerca actualitzacions…";
+"Check for updates automatically" = "Cerca actualitzacions automàticament";
+"Check if you like your agents having some fun up there." = "Activeu-ho si us agrada que els vostres agents es diverteixin allà dalt.";
+"Check provider status" = "Comproveu l'estat del proveïdor";
+"Choose Codex workspace" = "Trieu l'espai de treball de Codex";
+"Choose the MiniMax host (global .io or China mainland .com)." = "Trieu l'amfitrió de MiniMax (global .io o la Xina continental .com).";
+"Choose up to " = "Trieu fins a ";
+"Choose up to \\(Self.maxOverviewProviders) providers" = "Trieu fins a \\(Self.maxOverviewProviders) proveïdors";
+"Choose up to \\(count) providers" = "Trieu fins a \\(count) proveïdors";
+"Choose what to show in the menu bar (Pace shows usage vs. expected)." = "Trieu què es mostra a la barra de menús (Ritme mostra l'ús respecte al previst).";
+"Choose which Codex account CodexBar should follow." = "Trieu quin compte de Codex ha de seguir el CodexBar.";
+"Choose which window drives the menu bar percent." = "Trieu quina finestra determina el percentatge de la barra de menús.";
+"Chrome" = "Chrome";
+"Claude CLI not found" = "No s'ha trobat la CLI de Claude";
+"Claude binary" = "Binari de Claude";
+"Claude cookies" = "Galetes de Claude";
+"Claude login failed" = "L'inici de sessió de Claude ha fallat";
+"Claude login timed out" = "L'inici de sessió de Claude ha esgotat el temps d'espera";
+"Close" = "Tanca";
+"Codex CLI not found" = "No s'ha trobat la CLI de Codex";
+"Codex account login already running" = "Ja hi ha un inici de sessió de compte de Codex en curs";
+"Codex binary" = "Binari de Codex";
+"Codex login failed" = "L'inici de sessió de Codex ha fallat";
+"Codex login timed out" = "L'inici de sessió de Codex ha esgotat el temps d'espera";
+"CodexBar Lifecycle Keepalive" = "Manteniment del cicle de vida del CodexBar";
+"CodexBar can't show its menu bar icon" = "El CodexBar no pot mostrar la seva icona a la barra de menús";
+"CodexBar could not read managed account storage. " = "El CodexBar no ha pogut llegir l'emmagatzematge de comptes gestionats. ";
+"Configure…" = "Configureu…";
+"Connected" = "Connectat";
+"Controls how much detail is logged." = "Controla quant detall es registra.";
+"Cookie header" = "Capçalera de galeta";
+"Cookie source" = "Origen de la galeta";
+"Cookie: ..." = "Cookie: ...";
+"Cookie: \\u{2026}\\\n\\\nor paste a cURL capture from the Abacus AI dashboard" = "Cookie: \\u{2026}\\\n\\\no enganxa una captura cURL del tauler d'Abacus AI";
+"Cookie: \\u{2026}\\\n\\\nor paste the __Secure-next-auth.session-token value" = "Cookie: \\u{2026}\\\n\\\no enganxa el valor de __Secure-next-auth.session-token";
+"Cookie: \\u{2026}\\\n\\\nor paste the kimi-auth token value" = "Cookie: \\u{2026}\\\n\\\no enganxa el valor del token kimi-auth";
+"Cookie: …" = "Cookie: …";
+"CopilotDeviceFlow" = "CopilotDeviceFlow";
+"Cost" = "Cost";
+"Could not add Codex account" = "No s'ha pogut afegir el compte de Codex";
+"Could not open Terminal for Gemini" = "No s'ha pogut obrir el Terminal per a Gemini";
+"Could not start claude /login" = "No s'ha pogut iniciar claude /login";
+"Could not start codex login" = "No s'ha pogut iniciar codex login";
+"Could not switch system account" = "No s'ha pogut canviar el compte del sistema";
+"Credits" = "Crèdits";
+"Individual credits" = "Crèdits individuals";
+"Workspace" = "Espai de treball";
+"Credits history" = "Historial de crèdits";
+"Cursor login failed" = "L'inici de sessió de Cursor ha fallat";
+"Custom" = "Personalitzat";
+"Custom Path" = "Camí personalitzat";
+"Daily Routines" = "Rutines diàries";
+"Debug" = "Depuració";
+"Default" = "Per defecte";
+"Disable Keychain access" = "Desactiveu l'accés al Clauer";
+"Disabled" = "Desactivat";
+"Dismiss" = "Descarteu";
+"Disconnected" = "Desconnectat";
+"Display" = "Pantalla";
+"Display mode" = "Mode de visualització";
+"Display reset times as absolute clock values instead of countdowns." = "Mostreu les hores de reinici com a valors de rellotge absoluts en comptes de comptes enrere.";
+"Done" = "Fet";
+"Effective PATH" = "PATH efectiu";
+"Email" = "Correu electrònic";
+"Enable Merge Icons to configure Overview tab providers." = "Activeu Combina les icones per configurar els proveïdors de la pestanya Resum.";
+"Enable file logging" = "Activeu el registre en fitxer";
+"Enabled" = "Activat";
+"Error" = "Error";
+"Error simulation" = "Simulació d'errors";
+"Expose troubleshooting tools in the Debug tab." = "Mostreu eines de diagnòstic a la pestanya Depuració.";
+"Failed" = "Ha fallat";
+"False" = "Fals";
+"Fetch strategy attempts" = "Intents d'estratègia d'obtenció";
+"Fetching" = "S'està obtenint";
+"Field" = "Camp";
+"Field subtitle" = "Subtítol del camp";
+"Finish the current managed account change before switching the system account." = "Acaba el canvi de compte gestionat actual abans de canviar el compte del sistema.";
+"Force animation on next refresh" = "Forceu l'animació a la pròxima actualització";
+"Gateway region" = "Regió de la passarel·la";
+"Gemini CLI not found" = "No s'ha trobat la CLI de Gemini";
+"Gemini/Antigravity, surfacing incidents in the icon and menu." = "Gemini/Antigravity, mostrant incidències a la icona i al menú.";
+"General" = "General";
+"GitHub" = "GitHub";
+"GitHub Copilot Login" = "Inici de sessió de GitHub Copilot";
+"GitHub Login" = "Inici de sessió de GitHub";
+"Hide details" = "Amagueu els detalls";
+"Hide personal information" = "Amagueu la informació personal";
+"Historical tracking" = "Seguiment històric";
+"How often CodexBar polls providers in the background." = "Amb quina freqüència el CodexBar consulta els proveïdors en segon pla.";
+"Inactive" = "Inactiu";
+"Install CLI" = "Instal·la la CLI";
+"Install the Claude CLI (npm i -g @anthropic-ai/claude-code) and try again." = "Instal·leu la CLI de Claude (npm i -g @anthropic-ai/claude-code) i torneu-ho a provar.";
+"Install the Codex CLI (npm i -g @openai/codex) and try again." = "Instal·leu la CLI de Codex (npm i -g @openai/codex) i torneu-ho a provar.";
+"Install the Gemini CLI (npm i -g @google/gemini-cli) and try again." = "Instal·leu la CLI de Gemini (npm i -g @google/gemini-cli) i torneu-ho a provar.";
+"JetBrains AI is ready" = "JetBrains AI està a punt";
+"JetBrains IDE" = "IDE de JetBrains";
+"Keep CLI sessions alive" = "Mantingueu actives les sessions de la CLI";
+"Keyboard shortcut" = "Drecera de teclat";
+"Keychain access" = "Accés al Clauer";
+"Keychain prompt policy" = "Política de sol·licituds del Clauer";
+"Last \\(name) fetch failed:" = "L'última obtenció de \\(name) ha fallat:";
+"Last \\(self.store.metadata(for: self.provider).displayName) fetch failed:" = "L'última obtenció de \\(self.store.metadata(for: self.provider).displayName) ha fallat:";
+"Last attempt" = "Últim intent";
+"Link" = "Enllaç";
+"Loading animations" = "Animacions de càrrega";
+"Loading…" = "S'està carregant…";
+"Local" = "Local";
+"Logging" = "Registre";
+"Login failed" = "L'inici de sessió ha fallat";
+"Login shell PATH (startup capture)" = "PATH del shell d'inici de sessió (captura a l'arrencada)";
+"Login timed out" = "L'inici de sessió ha esgotat el temps d'espera";
+"MCP details" = "Detalls de l'MCP";
+"Managed Codex accounts unavailable" = "Comptes gestionats de Codex no disponibles";
+"Managed account storage is unreadable. Live account access is still available, " = "L'emmagatzematge de comptes gestionats no es pot llegir. L'accés a comptes en directe encara està disponible, ";
+"Manual" = "Manual";
+"May your tokens never run out—keep agent limits in view." = "Que els vostres tokens no s'esgotin mai: mantingueu els límits dels vostres agents a la vista.";
+"Menu bar" = "Barra de menús";
+"Menu bar auto-shows the provider closest to its rate limit." = "La barra de menús mostra automàticament el proveïdor més a prop del seu límit.";
+"Menu bar metric" = "Mètrica de la barra de menús";
+"Menu bar shows percent" = "La barra de menús mostra el percentatge";
+"Menu content" = "Contingut del menú";
+"Merge Icons" = "Combina les icones";
+"Never prompt" = "No ho demanis mai";
+"No" = "No";
+"No Codex accounts detected yet." = "Encara no s'han detectat comptes de Codex.";
+"No JetBrains IDE detected" = "No s'ha detectat cap IDE de JetBrains";
+"No cost history data." = "No hi ha dades d'historial de cost.";
+"No credits history data." = "No hi ha dades d'historial de crèdits.";
+"No data available" = "No hi ha dades disponibles";
+"No data yet" = "Encara no hi ha dades";
+"No enabled providers available for Overview." = "No hi ha proveïdors activats disponibles per al Resum.";
+"No providers selected" = "No hi ha cap proveïdor seleccionat";
+"No token accounts yet." = "Encara no hi ha comptes amb token.";
+"No usage breakdown data." = "No hi ha dades de desglossament d'ús.";
+"None" = "Cap";
+"Notifications" = "Notificacions";
+"Notifies when the 5-hour session quota hits 0% and when it becomes " = "Avisa quan la quota de sessió de 5 hores arriba al 0% i quan torna a estar ";
+"OK" = "D'acord";
+"Obscure email addresses in the menu bar and menu UI." = "Amagueu les adreces de correu a la barra de menús i a la interfície del menú.";
+"Off" = "Desactivat";
+"Offline" = "Sense connexió";
+"On" = "Activat";
+"Online" = "En línia";
+"Only on user action" = "Només en accions de l'usuari";
+"Open" = "Obriu";
+"Open API Keys" = "Obriu les claus d'API";
+"Open Amp Settings" = "Obriu la configuració d'Amp";
+"Open Antigravity to sign in, then refresh CodexBar." = "Obriu Antigravity per iniciar la sessió i després actualitzeu el CodexBar.";
+"Open Browser" = "Obriu el navegador";
+"Open Coding Plan" = "Obriu el pla de programació";
+"Open Console" = "Obriu la Consola";
+"Open Dashboard" = "Obriu el tauler";
+"Open Mistral Admin" = "Obriu l'administració de Mistral";
+"Open Menu Bar Settings" = "Obriu la configuració de la barra de menús";
+"Open Ollama Settings" = "Obriu la configuració d'Ollama";
+"Open Terminal" = "Obriu el Terminal";
+"Open Usage Page" = "Obriu la pàgina d'ús";
+"Open Warp API Key Guide" = "Obriu la guia de la clau d'API de Warp";
+"Open menu" = "Obriu el menú";
+"Open token file" = "Obriu el fitxer de token";
+"OpenAI cookies" = "Galetes d'OpenAI";
+"OpenAI web extras" = "Extres web d'OpenAI";
+"Option A" = "Opció A";
+"Option B" = "Opció B";
+"Optional override if workspace lookup fails." = "Substitució opcional si falla la cerca de l'espai de treball.";
+"Options" = "Opcions";
+"Override auto-detection with a custom IDE base path" = "Substituïu la detecció automàtica amb un camí base d'IDE personalitzat";
+"Overview" = "Resum";
+"Overview rows always follow provider order." = "Les files del Resum sempre segueixen l'ordre dels proveïdors.";
+"Overview tab providers" = "Proveïdors de la pestanya Resum";
+"Paste API key…" = "Enganxeu la clau d'API…";
+"Paste API token…" = "Enganxeu el token d'API…";
+"Paste key…" = "Enganxeu la clau…";
+"Paste sessionKey or OAuth token…" = "Enganxeu la sessionKey o el token OAuth…";
+"Paste the Cookie header from a request to admin.mistral.ai. " = "Enganxeu la capçalera Cookie d'una petició a admin.mistral.ai. ";
+"Paste token…" = "Enganxeu el token…";
+"Personal" = "Personal";
+"Picker" = "Selector";
+"Picker subtitle" = "Subtítol del selector";
+"Placeholder" = "Text de marcador";
+"Plan" = "Pla";
+"Play full-screen confetti when weekly usage resets." = "Mostreu confeti a pantalla completa quan es reinicia l'ús setmanal.";
+"Polls OpenAI/Claude status pages and Google Workspace for " = "Consulta les pàgines d'estat d'OpenAI/Claude i Google Workspace per a ";
+"Prevents any Keychain access while enabled." = "Impedeix qualsevol accés al Clauer mentre estigui activat.";
+"Primary (API key limit)" = "Principal (límit de la clau d'API)";
+"Primary (\\(label))" = "Principal (\\(label))";
+"Primary (\\(metadata.sessionLabel))" = "Principal (\\(metadata.sessionLabel))";
+"Probe logs" = "Registres de sondeig";
+"Progress bars fill as you consume quota (instead of showing remaining)." = "Les barres de progrés s'omplen a mesura que consumeixes la quota (en comptes de mostrar el que queda).";
+"Provider" = "Proveïdor";
+"Providers" = "Proveïdors";
+"Quit CodexBar" = "Sortiu del CodexBar";
+"Random (default)" = "Aleatori (per defecte)";
+"Reads local usage logs. Shows today + last 30 days cost in the menu." = "Llegeix els registres d'ús locals. Mostra el cost d'avui + la finestra d'historial seleccionada al menú.";
+"Refresh" = "Actualitza";
+"Refresh cadence" = "Freqüència d'actualització";
+"Remote" = "Remot";
+"Remove" = "Elimineu";
+"Remove Codex account?" = "Voleu eliminar el compte de Codex?";
+"Remove \\(account.email) from CodexBar? Its managed Codex home will be deleted." = "Voleu eliminar \\(account.email) del CodexBar? El seu directori Codex gestionat s'esborrarà.";
+"Remove \\(email) from CodexBar? Its managed Codex home will be deleted." = "Voleu eliminar \\(email) del CodexBar? El seu directori Codex gestionat s'esborrarà.";
+"Remove selected account" = "Elimineu el compte seleccionat";
+"Replace critter bars with provider branding icons and a percentage." = "Substituïu les barres de bestioles per icones de marca del proveïdor i un percentatge.";
+"Replay selected animation" = "Reprodueix l'animació seleccionada";
+"Requires authentication via GitHub Device Flow." = "Requereix autenticació mitjançant el flux de dispositiu de GitHub.";
+"Resets: \\(reset)" = "Es reinicia: \\(reset)";
+"reset_tomorrow_format" = "demà, %@";
+"Rolling five-hour limit" = "Límit mòbil de cinc hores";
+"Search hourly" = "Cerques per hora";
+"Secondary (\\(label))" = "Secundari (\\(label))";
+"Secondary (\\(metadata.weeklyLabel))" = "Secundari (\\(metadata.weeklyLabel))";
+"Select a provider" = "Seleccioneu un proveïdor";
+"Select the IDE to monitor" = "Seleccioneu l'IDE que cal monitorar";
+"Session quota notifications" = "Notificacions de quota de sessió";
+"Session tokens" = "Tokens de sessió";
+"Settings" = "Configuració";
+"Show Codex Credits and Claude Extra usage sections in the menu." = "Mostreu les seccions de Crèdits de Codex i Ús addicional de Claude al menú.";
+"Show Debug Settings" = "Mostreu la configuració de depuració";
+"Show all token accounts" = "Mostreu tots els comptes amb token";
+"Show cost summary" = "Mostreu el resum de cost";
+"Show credits + extra usage" = "Mostreu crèdits + ús addicional";
+"Show details" = "Mostreu els detalls";
+"Show most-used provider" = "Mostreu el proveïdor més utilitzat";
+"Show provider icons in the switcher (otherwise show a weekly progress line)." = "Mostreu les icones de proveïdor al selector (si no, mostreu una línia de progrés setmanal).";
+"Show reset time as clock" = "Mostreu l'hora de reinici com a rellotge";
+"Show usage as used" = "Mostreu l'ús com a consumit";
+"Sign in via button below" = "Inicieu la sessió amb el botó de sota";
+"Skip teardown between probes (debug-only)." = "Ometeu el tancament entre sondeigs (només depuració).";
+"Stack token accounts in the menu (otherwise show an account switcher bar)." = "Apileu els comptes amb token al menú (si no, mostreu una barra de canvi de compte).";
+"Start at Login" = "Obrir en iniciar la sessió";
+"Status" = "Estat";
+"Store Claude sessionKey cookies or OAuth access tokens." = "Deseu galetes sessionKey de Claude o tokens d'accés OAuth.";
+"Store multiple Abacus AI Cookie headers." = "Deseu diverses capçaleres Cookie d'Abacus AI.";
+"Store multiple Augment Cookie headers." = "Deseu diverses capçaleres Cookie d'Augment.";
+"Store multiple Cursor Cookie headers." = "Deseu diverses capçaleres Cookie de Cursor.";
+"Store multiple Factory Cookie headers." = "Deseu diverses capçaleres Cookie de Factory.";
+"Store multiple MiniMax Cookie headers." = "Deseu diverses capçaleres Cookie de MiniMax.";
+"Store multiple Mistral Cookie headers." = "Deseu diverses capçaleres Cookie de Mistral.";
+"Store multiple Ollama Cookie headers." = "Deseu diverses capçaleres Cookie d'Ollama.";
+"Store multiple OpenCode Cookie headers." = "Deseu diverses capçaleres Cookie d'OpenCode.";
+"Store multiple OpenCode Go Cookie headers." = "Deseu diverses capçaleres Cookie d'OpenCode Go.";
+"Stored in the CodexBar config file." = "Desat al fitxer de configuració del CodexBar.";
+"Stored in ~/.codexbar/config.json. " = "Desat a ~/.codexbar/config.json. ";
+"Stored in ~/.codexbar/config.json. Generate one at kimi-k2.ai." = "Desat a ~/.codexbar/config.json. Genera'n una a kimi-k2.ai.";
+"Stored in ~/.codexbar/config.json. Paste the key from the Synthetic dashboard." = "Desat a ~/.codexbar/config.json. Enganxa la clau del tauler de Synthetic.";
+"Stored in ~/.codexbar/config.json. Paste your Coding Plan API key from Model Studio." = "Desat a ~/.codexbar/config.json. Enganxeu la clau d'API del vostre pla de programació des de Model Studio.";
+"Stored in ~/.codexbar/config.json. Paste your MiniMax API key." = "Desat a ~/.codexbar/config.json. Enganxeu la vostra clau d'API de MiniMax.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or " = "Desat a ~/.codexbar/config.json. També podeu proporcionar KILO_API_KEY o ";
+"Stores local Codex usage history (8 weeks) to personalize Pace predictions." = "Desa l'historial d'ús local de Codex (8 setmanes) per personalitzar les prediccions de Ritme.";
+"Subscription Utilization" = "Ús de la subscripció";
+"Surprise me" = "Sorprèn-me";
+"Switcher shows icons" = "El selector mostra icones";
+"Symlink CodexBarCLI to /usr/local/bin and /opt/homebrew/bin as codexbar." = "Creeu un enllaç simbòlic de CodexBarCLI a /usr/local/bin i /opt/homebrew/bin com a codexbar.";
+"System" = "Sistema";
+"Temporarily shows the loading animation after the next refresh." = "Mostra temporalment l'animació de càrrega després de la pròxima actualització.";
+"Tertiary (\\(label))" = "Terciari (\\(label))";
+"Tertiary (\\(tertiaryTitle))" = "Terciari (\\(tertiaryTitle))";
+"The default Codex account on this Mac." = "El compte de Codex per defecte en aquest Mac.";
+"Toggle" = "Commutador";
+"Toggle subtitle" = "Subtítol del commutador";
+"Token" = "Token";
+"Trigger the menu bar menu from anywhere." = "Obriu el menú de la barra de menús des de qualsevol lloc.";
+"True" = "Cert";
+"Twitter" = "Twitter";
+"Unsupported" = "No compatible";
+"Update Channel" = "Canal d'actualitzacions";
+"Updated" = "Actualitzat";
+"Updates unavailable in this build." = "Actualitzacions no disponibles en aquesta compilació.";
+"Usage" = "Ús";
+"Usage breakdown" = "Desglossament d'ús";
+"Usage history (30 days)" = "Historial d'ús";
+"Usage source" = "Origen de l'ús";
+"Use BigModel for the China mainland endpoints (open.bigmodel.cn)." = "Feu servir BigModel per als endpoints de la Xina continental (open.bigmodel.cn).";
+"Use a single menu bar icon with a provider switcher." = "Feu servir una sola icona a la barra de menús amb un selector de proveïdor.";
+"Use international or China mainland console gateways for quota fetches." = "Feu servir les passarel·les de consola internacionals o de la Xina continental per obtenir la quota.";
+"Version" = "Versió";
+"Version \\(self.versionString)" = "Versió \\(self.versionString)";
+"Version \\(version)" = "Versió \\(version)";
+"Version \\(versionString)" = "Versió \\(versionString)";
+"Vertex AI Login" = "Inici de sessió de Vertex AI";
+"Wait for the current managed Codex login to finish before adding another account." = "Espereu que acabi l'inici de sessió gestionat de Codex actual abans d'afegir un altre compte.";
+"Waiting for Authentication..." = "S'està esperant l'autenticació...";
+"Website" = "Lloc web";
+"Weekly limit confetti" = "Confeti del límit setmanal";
+"Weekly token limit" = "Límit setmanal de tokens";
+"Weekly usage" = "Ús setmanal";
+"Weekly usage unavailable for this account." = "Ús setmanal no disponible per a aquest compte.";
+"Window: \\(window)" = "Finestra: \\(window)";
+"Write logs to \\(self.fileLogPath) for debugging." = "Escriu els registres a \\(self.fileLogPath) per a la depuració.";
+"Yes" = "Sí";
+"\\(detail.modelCode): \\(usage)" = "\\(detail.modelCode): \\(usage)";
+"\\(name): \\(truncated)" = "\\(name): \\(truncated)";
+"\\(name): \\(updated) · 30d \\(cost)" = "\\(name): \\(updated) · 30 d \\(cost)";
+"\\(name): fetching…\\(elapsed)" = "\\(name): s'està obtenint…\\(elapsed)";
+"\\(name): last attempt \\(when)" = "\\(name): últim intent \\(when)";
+"\\(name): no data yet" = "\\(name): encara sense dades";
+"\\(name): unsupported" = "\\(name): no compatible";
+"all browsers" = "tots els navegadors";
+"available again." = "disponible de nou.";
+"built_format" = "Compilació %@";
+"copilot_complete_in_browser" = "Completa l'inici de sessió al teu navegador.";
+"copilot_device_code" = "Codi de dispositiu copiat al porta-retalls: %1$@\n\nVerifiqueu-lo a: %2$@";
+"copilot_device_code_copied" = "Codi de dispositiu copiat.";
+"copilot_verify_at" = "Verifiqueu-lo a %@";
+"copilot_waiting_text" = "Completa l'inici de sessió al teu navegador.\nAquesta finestra es tanca automàticament quan finalitza l'inici de sessió.";
+"copilot_window_closes_auto" = "Aquesta finestra es tanca automàticament quan finalitza l'inici de sessió.";
+"cost_status_error" = "%1$@: %2$@";
+"cost_status_fetching" = "%1$@: s'està obtenint… %2$@";
+"cost_status_last_attempt" = "%1$@: últim intent %2$@";
+"cost_status_no_data" = "%@: encara sense dades";
+"cost_status_snapshot" = "%1$@: %2$@ · %3$@ %4$@";
+"cost_status_unsupported" = "%@: no compatible";
+"credits_remaining" = "Crèdits: %@";
+"cursor_on_demand" = "Sota demanda: %@";
+"cursor_on_demand_with_limit" = "Sota demanda: %1$@ / %2$@";
+"extra_usage_format" = "Ús addicional: %1$@ / %2$@";
+"jetbrains_detected_generate" = "Detectat: %@. Feu servir l'assistent d'IA una vegada per generar dades de quota i després actualitzeu el CodexBar.";
+"jetbrains_detected_select" = "Detectat: %@. Seleccioneu el vostre IDE preferit a la configuració i després actualitzeu el CodexBar.";
+"last_fetch_failed_with_provider" = "L'última obtenció de %@ ha fallat:";
+"last_spend" = "Última despesa: %@";
+"mcp_model_usage" = "%1$@: %2$@";
+"mcp_resets" = "Es reinicia: %@";
+"mcp_window" = "Finestra: %@";
+"metric_average" = "Mitjana (%1$@ + %2$@)";
+"metric_primary" = "Principal (%@)";
+"metric_secondary" = "Secundari (%@)";
+"metric_tertiary" = "Terciari (%@)";
+"multiple_workspaces_found" = "El CodexBar ha trobat diversos espais de treball per a %@. Trieu l'espai de treball que voleu afegir.";
+"ory_session_…=…; csrftoken=…" = "ory_session_…=…; csrftoken=…";
+"overview_choose_providers" = "Trieu fins a %@ proveïdors";
+"remove_account_message" = "Voleu eliminar %@ del CodexBar? El seu directori Codex gestionat s'esborrarà.";
+"version_format" = "Versió %@";
+"vertex_ai_login_instructions" = "Per fer un seguiment de l'ús de Vertex AI, autentiqueu-vos amb Google Cloud.\n\n1. Obriu el Terminal\n2. Executeu: gcloud auth application-default login\n3. Seguiu les indicacions del navegador per iniciar la sessió\n4. Definiu el vostre projecte: gcloud config set project PROJECT_ID\n\nVoleu obrir el Terminal ara?";
+"workspaceID is set but only opencode, opencodego, and deepgram support workspaceID." = "workspaceID està definit, però només opencode, opencodego i deepgram admeten workspaceID.";
+"© 2026 Peter Steinberger. MIT License." = "© 2026 Peter Steinberger. Llicència MIT.";
+
+/* General Pane */
+"section_system" = "Sistema";
+"section_usage" = "Ús";
+"section_automation" = "Automatització";
+"language_title" = "Idioma";
+"language_subtitle" = "Canvia l'idioma de la interfície. Cal reiniciar l'app perquè s'apliqui completament.";
+"language_system" = "Sistema";
+"language_english" = "English";
+"language_spanish" = "Español";
+"language_catalan" = "Català";
+"language_chinese_simplified" = "简体中文";
+"language_chinese_traditional" = "繁體中文";
+"language_portuguese_brazilian" = "Português (Brasil)";
+"language_swedish" = "Suec";
+"language_dutch" = "Nederlands";
+"language_german" = "Deutsch";
+"language_french" = "Francès";
+"language_ukrainian" = "Ucraïnès";
+"language_japanese" = "Japonès";
+"language_korean" = "Coreà";
+"language_italian" = "Italiano";
+"language_polish" = "Polski";
+"start_at_login_title" = "Obrir en iniciar la sessió";
+"start_at_login_subtitle" = "Obre el CodexBar automàticament en iniciar el Mac.";
+"show_cost_summary" = "Mostreu el resum de cost";
+"show_cost_summary_subtitle" = "Llegeix els registres d'ús locals. Mostra el cost d'avui + la finestra d'historial seleccionada al menú.";
+"cost_history_days_title" = "Finestra d'historial: %d dies";
+"cost_auto_refresh_info" = "Actualització automàtica: cada hora · Temps d'espera: 10 min";
+"refresh_cadence_title" = "Freqüència d'actualització";
+"refresh_cadence_subtitle" = "Amb quina freqüència el CodexBar consulta els proveïdors en segon pla.";
+"manual_refresh_hint" = "L'actualització automàtica està desactivada; feu servir l'ordre Actualitza del menú.";
+"check_provider_status_title" = "Comproveu l'estat del proveïdor";
+"check_provider_status_subtitle" = "Consulta les pàgines d'estat d'OpenAI/Claude i Google Workspace per a Gemini/Antigravity, mostrant incidències a la icona i al menú.";
+"session_quota_notifications_title" = "Notificacions de quota de sessió";
+"session_quota_notifications_subtitle" = "Avisa quan la quota de sessió de 5 hores arriba al 0% i quan torna a estar disponible.";
+"quota_warning_notifications_title" = "Notificacions d'avís de quota";
+"quota_warning_notifications_subtitle" = "Avisa quan la quota restant de sessió o setmanal supera els llindars configurats.";
+"quota_warnings_title" = "Avisos de quota";
+"quota_warning_session" = "sessió";
+"quota_warning_session_capitalized" = "Sessió";
+"quota_warning_weekly" = "setmanal";
+"quota_warning_weekly_capitalized" = "Setmanal";
+"quota_warning_warn_at" = "Aviseu al";
+"quota_warning_global_threshold_subtitle" = "Percentatges restants per a les finestres de sessió i setmanal, llevat que un proveïdor els substitueixi.";
+"quota_warning_sound" = "Reprodueix el so de notificació";
+"quota_warning_provider_inherits" = "Fa servir la configuració global d'avís de quota llevat que es personalitzi una finestra aquí.";
+"quota_warning_customize_thresholds" = "Personalitza els llindars de %@";
+"quota_warning_enable_warnings" = "Activeu els avisos de %@";
+"quota_warning_window_warn_at" = "%@ avisa al";
+"quota_warning_off" = "Desactivat";
+"quota_warning_inherited" = "Heretat: %@";
+"quota_warning_depleted_only" = "només esgotat";
+"quota_warning_upper" = "Superior";
+"quota_warning_lower" = "Inferior";
+"apply" = "Apliqueu";
+"quit_app" = "Sortiu del CodexBar";
+
+/* Tab titles */
+"tab_general" = "General";
+"tab_providers" = "Proveïdors";
+"tab_display" = "Pantalla";
+"tab_advanced" = "Avançat";
+"tab_about" = "Quant a";
+"tab_debug" = "Depuració";
+
+/* Providers Pane */
+"select_a_provider" = "Seleccioneu un proveïdor";
+"cancel" = "Cancel·leu";
+"last_fetch_failed" = "l'última obtenció ha fallat";
+"usage_not_fetched_yet" = "encara no s'ha obtingut l'ús";
+"managed_account_storage_unreadable" = "L'emmagatzematge de comptes gestionats no es pot llegir. L'accés a comptes en directe encara està disponible, però les accions d'afegir, reautenticar i eliminar comptes gestionats estan desactivades fins que l'emmagatzematge es pugui recuperar.";
+"remove_codex_account_title" = "Voleu eliminar el compte de Codex?";
+"remove" = "Elimineu";
+"managed_login_already_running" = "Ja hi ha un inici de sessió gestionat de Codex en curs. Espereu que acabi abans d'afegir o reautenticar un altre compte.";
+"managed_login_failed" = "L'inici de sessió gestionat de Codex no s'ha completat. Comproveu que `codex --version` funciona al Terminal. Si macOS ha bloquejat o ha mogut `codex` a la Paperera, elimineu les instal·lacions duplicades obsoletes, executeu `npm install -g --include=optional @openai/codex@latest` i torneu-ho a provar.";
+"codex_login_output" = "Sortida de codex login:";
+"managed_login_missing_email" = "L'inici de sessió de Codex s'ha completat, però no hi havia cap correu de compte disponible. Torneu-ho a provar després de confirmar que el compte té la sessió totalment iniciada.";
+"workspace_selection_cancelled" = "El CodexBar ha trobat diversos espais de treball, però no se n'ha seleccionat cap.";
+"unsafe_managed_home" = "El CodexBar s'ha negat a modificar un camí de directori gestionat inesperat: %@";
+"menu_bar_metric_title" = "Mètrica de la barra de menús";
+"menu_bar_metric_subtitle" = "Trieu quina finestra determina el percentatge de la barra de menús.";
+"menu_bar_metric_subtitle_deepseek" = "Mostra el saldo de DeepSeek a la barra de menús.";
+"menu_bar_metric_subtitle_moonshot" = "Mostra el saldo de l'API de Moonshot / Kimi a la barra de menús.";
+"menu_bar_metric_subtitle_mistral" = "Mostra la despesa de l'API de Mistral del mes actual a la barra de menús.";
+"menu_bar_metric_subtitle_kimik2" = "Mostra els crèdits de la clau d'API de Kimi K2 a la barra de menús.";
+"automatic" = "Automàtic";
+"primary_api_key_limit" = "Principal (límit de la clau d'API)";
+
+/* Display Pane */
+"section_menu_bar" = "Barra de menús";
+"merge_icons_title" = "Combina les icones";
+"merge_icons_subtitle" = "Feu servir una sola icona a la barra de menús amb un selector de proveïdor.";
+"switcher_shows_icons_title" = "El selector mostra icones";
+"switcher_shows_icons_subtitle" = "Mostreu les icones de proveïdor al selector (si no, mostreu una línia de progrés setmanal).";
+"show_most_used_provider_title" = "Mostreu el proveïdor més utilitzat";
+"show_most_used_provider_subtitle" = "La barra de menús mostra automàticament el proveïdor més a prop del seu límit.";
+"menu_bar_shows_percent_title" = "La barra de menús mostra el percentatge";
+"menu_bar_shows_percent_subtitle" = "Substitueix les barres de bestioles per icones de marca del proveïdor i un percentatge.";
+"hide_critters_title" = "Amaga les bestioles";
+"hide_critters_subtitle" = "Mostra barres de mesura simples sense la cara ni les decoracions.";
+"display_mode_title" = "Mode de visualització";
+"display_mode_subtitle" = "Trieu què es mostra a la barra de menús (Ritme mostra l'ús respecte al previst).";
+"section_menu_content" = "Contingut del menú";
+"show_usage_as_used_title" = "Mostreu l'ús com a consumit";
+"show_usage_as_used_subtitle" = "Les barres de progrés s'omplen a mesura que consumeixes la quota (en comptes de mostrar el que queda).";
+"show_quota_warning_markers_title" = "Mostreu els marcadors d'avís de quota";
+"show_quota_warning_markers_subtitle" = "Dibuixa marques de llindar a les barres d'ús quan hi ha avisos de quota configurats.";
+"weekly_progress_work_days_title" = "Dies laborables del progrés setmanal";
+"weekly_progress_work_days_subtitle" = "Definiu els dies laborables per als marcadors de les barres d'ús setmanal i els càlculs de ritme.";
+"show_reset_time_as_clock_title" = "Mostreu l'hora de reinici com a rellotge";
+"show_reset_time_as_clock_subtitle" = "Mostreu les hores de reinici com a valors de rellotge absoluts en comptes de comptes enrere.";
+"show_provider_changelog_links_title" = "Mostreu els enllaços al registre de canvis del proveïdor";
+"show_provider_changelog_links_subtitle" = "Afegiu al menú enllaços a les notes de versió dels proveïdors compatibles basats en CLI.";
+"show_credits_extra_usage_title" = "Mostreu crèdits + ús addicional";
+"show_credits_extra_usage_subtitle" = "Mostreu les seccions de Crèdits de Codex i Ús addicional de Claude al menú.";
+"show_all_token_accounts_title" = "Mostreu tots els comptes amb token";
+"show_all_token_accounts_subtitle" = "Apileu els comptes amb token al menú (si no, mostreu una barra de canvi de compte).";
+"multi_account_layout_title" = "Disposició multicompte";
+"multi_account_layout_subtitle" = "Trieu el canvi de compte segmentat o targetes de compte apilades.";
+"multi_account_layout_segmented" = "Segmentat";
+"multi_account_layout_stacked" = "Apilat";
+"overview_tab_providers_title" = "Proveïdors de la pestanya Resum";
+"configure" = "Configureu…";
+"overview_enable_merge_icons_hint" = "Activeu Combina les icones per configurar els proveïdors de la pestanya Resum.";
+"overview_no_providers_hint" = "No hi ha proveïdors activats disponibles per al Resum.";
+"overview_rows_follow_order" = "Les files del Resum sempre segueixen l'ordre dels proveïdors.";
+"overview_no_providers_selected" = "No hi ha cap proveïdor seleccionat";
+
+/* Advanced Pane */
+"section_keyboard_shortcut" = "Drecera de teclat";
+"open_menu_shortcut_title" = "Obriu el menú";
+"open_menu_shortcut_subtitle" = "Obriu el menú de la barra de menús des de qualsevol lloc.";
+"install_cli" = "Instal·la la CLI";
+"install_cli_subtitle" = "Creeu un enllaç simbòlic de CodexBarCLI a /usr/local/bin i /opt/homebrew/bin com a codexbar.";
+"cli_not_found" = "No s'ha trobat CodexBarCLI al paquet de l'app.";
+"no_writable_bin_dirs" = "No s'han trobat directoris bin amb permís d'escriptura.";
+"show_debug_settings_title" = "Mostreu la configuració de depuració";
+"show_debug_settings_subtitle" = "Mostreu eines de diagnòstic a la pestanya Depuració.";
+"surprise_me_title" = "Sorprèn-me";
+"surprise_me_subtitle" = "Activeu-ho si us agrada que els vostres agents es diverteixin allà dalt.";
+"weekly_limit_confetti_title" = "Confeti del límit setmanal";
+"weekly_limit_confetti_subtitle" = "Mostreu confeti a pantalla completa quan es reinicia l'ús setmanal.";
+"hide_personal_info_title" = "Amagueu la informació personal";
+"hide_personal_info_subtitle" = "Amagueu les adreces de correu a la barra de menús i a la interfície del menú.";
+"show_provider_storage_usage_title" = "Mostreu l'ús d'emmagatzematge del proveïdor";
+"show_provider_storage_usage_subtitle" = "Mostreu l'ús de disc local als menús. Analitza en segon pla els camins coneguts del proveïdor.";
+"section_keychain_access" = "Accés al Clauer";
+"keychain_access_caption" = "Desactiveu totes les lectures i escriptures del Clauer. La importació de galetes del navegador no estarà disponible; enganxeu les capçaleres Cookie manualment a Proveïdors.";
+"disable_keychain_access_title" = "Desactiveu l'accés al Clauer";
+"disable_keychain_access_subtitle" = "Impedeix qualsevol accés al Clauer mentre estigui activat.";
+
+/* About Pane */
+"about_tagline" = "Que els vostres tokens no s'esgotin mai: mantingueu els límits dels vostres agents a la vista.";
+"link_github" = "GitHub";
+"link_website" = "Lloc web";
+"link_twitter" = "Twitter";
+"link_email" = "Correu electrònic";
+"check_updates_auto" = "Cerca actualitzacions automàticament";
+"update_channel" = "Canal d'actualitzacions";
+"check_for_updates" = "Cerca actualitzacions…";
+"updates_unavailable" = "Actualitzacions no disponibles en aquesta compilació.";
+"copyright" = "© 2026 Peter Steinberger. Llicència MIT.";
+
+/* Debug Pane */
+"section_logging" = "Registre";
+"enable_file_logging" = "Activeu el registre en fitxer";
+"enable_file_logging_subtitle" = "Escriu els registres a %@ per a la depuració.";
+"verbosity_title" = "Nivell de detall";
+"verbosity_subtitle" = "Controla quant detall es registra.";
+"open_log_file" = "Obriu el fitxer de registre";
+"force_animation_next_refresh" = "Forceu l'animació a la pròxima actualització";
+"force_animation_next_refresh_subtitle" = "Mostra temporalment l'animació de càrrega després de la pròxima actualització.";
+"section_loading_animations" = "Animacions de càrrega";
+"loading_animations_caption" = "Trieu un patró i reproduïu-lo a la barra de menús. «Aleatori» manté el comportament actual.";
+"animation_random_default" = "Aleatori (per defecte)";
+"replay_selected_animation" = "Reprodueix l'animació seleccionada";
+"blink_now" = "Parpelleja ara";
+"section_probe_logs" = "Registres de sondeig";
+"probe_logs_caption" = "Obté la sortida de sondeig més recent per a la depuració; l'opció Copia conserva el text complet.";
+"fetch_log" = "Obtingueu el registre";
+"copy" = "Copia";
+"save_to_file" = "Deseu en un fitxer";
+"load_parse_dump" = "Carregueu l'abocament d'anàlisi";
+"rerun_provider_autodetect" = "Torneu a executar l'autodetecció de proveïdors";
+"loading" = "S'està carregant…";
+"no_log_yet_fetch" = "Encara no hi ha registre. Obtingueu per carregar-lo.";
+"section_fetch_strategy" = "Intents d'estratègia d'obtenció";
+"fetch_strategy_caption" = "Últimes decisions i errors del flux d'obtenció d'un proveïdor.";
+"section_openai_cookies" = "Galetes d'OpenAI";
+"openai_cookies_caption" = "Registres d'importació de galetes i extracció amb WebKit de l'últim intent de galetes d'OpenAI.";
+"no_log_yet" = "Encara no hi ha registre. Actualitzeu les galetes d'OpenAI a Proveïdors → Codex per executar una importació.";
+"section_caches" = "Memòries cau";
+"caches_caption" = "Esborreu els resultats d'anàlisi de cost a la memòria cau o les memòries cau de galetes del navegador.";
+"clear_cookie_cache" = "Esborreu la memòria cau de galetes";
+"clear_cost_cache" = "Esborreu la memòria cau de cost";
+"section_notifications" = "Notificacions";
+"notifications_caption" = "Llanceu notificacions de prova per a la finestra de sessió de 5 hores (esgotada/restaurada).";
+"post_depleted" = "Envia esgotada";
+"post_restored" = "Envia restaurada";
+"section_cli_sessions" = "Sessions de la CLI";
+"cli_sessions_caption" = "Mantingueu actives les sessions de la CLI de Codex/Claude després d'un sondeig. Per defecte es tanquen quan es capturen les dades.";
+"keep_cli_sessions_alive" = "Mantingueu actives les sessions de la CLI";
+"keep_cli_sessions_alive_subtitle" = "Ometeu el tancament entre sondeigs (només depuració).";
+"reset_cli_sessions" = "Reinicieu les sessions de la CLI";
+"section_error_simulation" = "Simulació d'errors";
+"error_simulation_caption" = "Injecta un missatge d'error fals a la targeta del menú per provar la disposició.";
+"set_menu_error" = "Estableix l'error de menú";
+"clear_menu_error" = "Esborreu l'error de menú";
+"set_cost_error" = "Estableix l'error de cost";
+"clear_cost_error" = "Esborreu l'error de cost";
+"section_cli_paths" = "Camins de la CLI";
+"cli_paths_caption" = "Binari de Codex resolt i capes de PATH; captura del PATH d'inici de sessió a l'arrencada (temps d'espera curt).";
+"codex_binary" = "Binari de Codex";
+"claude_binary" = "Binari de Claude";
+"effective_path" = "PATH efectiu";
+"unavailable" = "No disponible";
+"login_shell_path" = "PATH del shell d'inici de sessió (captura a l'arrencada)";
+"cleared" = "Esborrat.";
+"no_fetch_attempts" = "Encara no hi ha intents d'obtenció.";
+"macOS Tahoe can block menu bar apps in System Settings → Menu Bar → Allow in the Menu Bar. CodexBar is running, but macOS may be hiding its icon. Open Menu Bar settings and turn CodexBar on." = "macOS Tahoe pot bloquejar les apps de la barra de menús a Configuració del Sistema → Barra de menús → Permet a la barra de menús. El CodexBar s'està executant, però macOS podria estar amagant-ne la icona. Obriu la configuració de la barra de menús i activeu el CodexBar.";
+
+/* Metric preferences */
+"metric_pref_automatic" = "Automàtic";
+"metric_pref_primary" = "Principal";
+"metric_pref_secondary" = "Secundari";
+"metric_pref_tertiary" = "Terciari";
+"metric_pref_extra_usage" = "Ús addicional";
+"metric_pref_average" = "Mitjana";
+"metric_mistral_payg" = "Pay-as-you-go";
+"metric_mistral_monthly_plan" = "Monthly Plan";
+
+/* Display modes */
+"display_mode_percent" = "Percentatge";
+"display_mode_pace" = "Ritme";
+"display_mode_both" = "Tots dos";
+"display_mode_reset_time" = "Temps de reinici";
+"display_mode_percent_desc" = "Mostreu el percentatge restant/usat (p. ex. 45%)";
+"display_mode_pace_desc" = "Mostreu l'indicador de ritme (p. ex. +5%)";
+"display_mode_both_desc" = "Mostreu el percentatge i el ritme (p. ex. 45% · +5%)";
+"display_mode_reset_time_desc" = "Mostreu l'hora de reinici de la mètrica seleccionada (p. ex. ↻ 3:56 PM)";
+
+/* Provider status */
+"status_operational" = "Operatiu";
+"status_partial_outage" = "Interrupció parcial";
+"status_major_outage" = "Interrupció greu";
+"status_critical_issue" = "Problema crític";
+"status_maintenance" = "Manteniment";
+"status_unknown" = "Estat desconegut";
+
+/* Refresh frequency */
+"refresh_manual" = "Manual";
+"refresh_1min" = "1 min";
+"refresh_2min" = "2 min";
+"refresh_5min" = "5 min";
+"refresh_15min" = "15 min";
+"refresh_30min" = "30 min";
+
+/* Additional keys */
+"not_found" = "No trobat";
+
+/* Cost estimation */
+"cost_header_estimated" = "Cost (estimat)";
+"cost_estimate_hint" = "Estimat a partir de registres locals · pot diferir de la vostra factura";
+
+/* Popup panels */
+"No usage configured." = "No hi ha cap ús configurat.";
+"Quota" = "Quota";
+"tokens" = "tokens";
+"requests" = "sol·licituds";
+"Latest" = "Més recent";
+"Monthly" = "Mensual";
+"Sonnet" = "Sonnet";
+"Auth" = "Autenticació";
+"Overages" = "Excedents";
+"Activity" = "Activitat";
+"Copied" = "Copiat";
+"Copy error" = "Error en copiar";
+"Copy path" = "Copia el camí";
+"Extra usage spent" = "Despesa d'ús addicional";
+"Credits remaining" = "Crèdits restants";
+"Using CLI fallback" = "S'utilitza l'alternativa de la CLI";
+"Balance updates in near-real time (up to 5 min lag)" = "El saldo s'actualitza gairebé en temps real (fins a 5 min de retard)";
+"Daily billing data finalizes at 07:00 UTC" = "Les dades diàries de facturació es tanquen a les 07:00 UTC";
+"%@ of %@ credits left" = "Queden %@ de %@ crèdits";
+"%@ of %@ bonus credits left" = "Queden %@ de %@ crèdits de bonificació";
+"%@ / %@ (%@ remaining)" = "%@ / %@ (%@ restants)";
+"%@/%@ left" = "%@/%@ restant";
+"Gemini Flash" = "Gemini Flash";
+"Regenerates %@" = "Es regenera %@";
+"used after next regen" = "usat després de la pròxima regeneració";
+"after next regen" = "després de la pròxima regeneració";
+"Near full" = "Gairebé ple";
+"Full in ~1 regen" = "Ple en ~1 regeneració";
+"Full in ~%.0f regens" = "Ple en ~%.0f regeneracions";
+"Overage usage" = "Ús excedent";
+"Overage cost" = "Cost excedent";
+"credits" = "crèdits";
+"Zen balance" = "Saldo Zen";
+"API spend" = "Despesa d'API";
+"Extra usage" = "Ús addicional";
+"Quota usage" = "Ús de quota";
+"Your spend" = "La teva despesa";
+"%.0f%% used" = "%.0f%% usat";
+"Usage history (today)" = "Historial d'ús (avui)";
+"Usage history (%d days)" = "Historial d'ús (%d dies)";
+"%d percent remaining" = "%d%% restant";
+"Unknown" = "Desconegut";
+"stale data" = "dades obsoletes";
+"No credits history data available." = "No hi ha dades d'historial de crèdits disponibles.";
+"Credits history chart" = "Gràfic d'historial de crèdits";
+"%d days of credits data" = "%d dies de dades de crèdits";
+"Usage breakdown chart" = "Gràfic de desglossament d'ús";
+"%d days of usage data across %d services" = "%d dies de dades d'ús en %d serveis";
+"Cost history chart" = "Gràfic d'historial de costos";
+"%d days of cost data" = "%d dies de dades de costos";
+"Plan utilization chart" = "Gràfic d'utilització del pla";
+"%d utilization samples" = "%d mostres d'utilització";
+"Hourly Usage" = "Ús per hora";
+"Usage remaining" = "Ús restant";
+"Usage used" = "Ús consumit";
+"API key verified. Ollama does not expose Cloud quota limits through the API." = "Clau d'API verificada. Ollama no exposa els límits de quota de Cloud a través de l'API.";
+"Last 30 days: %@ tokens" = "Últims 30 dies: %@ tokens";
+"7d spend" = "Despesa 7 d";
+"30d spend" = "Despesa 30 d";
+"Cache read" = "Lectura de memòria cau";
+"Claude Admin API 30 day spend trend" = "Tendència de despesa de 30 dies de Claude Admin API";
+"OpenRouter API key spend trend" = "Tendència de despesa de la clau API d'OpenRouter";
+"z.ai hourly token trend" = "Tendència horària de tokens de z.ai";
+"MiniMax 30 day token usage trend" = "Tendència d'ús de tokens de 30 dies de MiniMax";
+"Today cash" = "Efectiu d'avui";
+"DeepSeek 30 day token usage trend" = "Tendència d'ús de tokens de 30 dies de DeepSeek";
+"cache-hit input" = "entrada amb encert de memòria cau";
+"cache-miss input" = "entrada sense encert de memòria cau";
+"output" = "sortida";
+"Requests" = "Sol·licituds";
+"Reported by OpenAI Admin API organization usage." = "Informat per l'ús de l'organització a OpenAI Admin API.";
+"Reported by Mistral billing usage." = "Informat per l'ús de facturació de Mistral.";
+"Today" = "Avui";
+"Today tokens" = "Tokens d'avui";
+"30d cost" = "Cost 30 d";
+"30d tokens" = "Tokens 30 d";
+"Latest tokens" = "Tokens recents";
+"Top model" = "Model principal";
+"Storage" = "Emmagatzematge";
+"No data" = "Sense dades";
+"Last %d days" = "Últims %d dies";
+"%@ tokens" = "%@ tokens";
+"Latest billing day" = "Últim dia de facturació";
+"Latest billing day (%@)" = "Últim dia de facturació (%@)";
+"This week" = "Aquesta setmana";
+"This month" = "Aquest mes";
+"Week" = "Setmana";
+"Month" = "Mes";
+"Models" = "Models";
+"24h tokens" = "Tokens 24 h";
+"Latest hour" = "Última hora";
+"Peak hour" = "Hora punta";
+"Top method" = "Mètode principal";
+"30d cash" = "Efectiu 30 d";
+"30d billing history from MiniMax web session" = "Historial de facturació de 30 dies de la sessió web de MiniMax";
+"AWS Cost Explorer billing can lag." = "La facturació d'AWS Cost Explorer pot endarrerir-se.";
+"Rate limit: %d / %@" = "Límit de taxa: %d / %@";
+"Key remaining" = "Restant de la clau";
+"No limit set for the API key" = "No hi ha cap límit configurat per a la clau API";
+"API key limit unavailable right now" = "El límit de la clau API no està disponible ara mateix";
+"Today: %@ · %@ tokens" = "Avui: %@ · %@ tokens";
+"Today: %@" = "Avui: %@";
+"Today: %@ tokens" = "Avui: %@ tokens";
+"This month: %@ tokens" = "Aquest mes: %@ tokens";
+"API key limit" = "Límit de la clau API";
+"Limits not available" = "Límits no disponibles";
+"No usage yet" = "Encara no hi ha ús";
+"Not fetched yet" = "Encara no obtingut";
+"Code review" = "Revisió de codi";
+
+/* Additional provider settings and alerts */
+"%@ is waiting for permission" = "%@ espera permís";
+"%@ requests" = "%@ sol·licituds";
+"%@: %@ credits" = "%@: %@ crèdits";
+"30d requests" = "Sol·licituds de 30 d";
+"4 days" = "4 dies";
+"5 days" = "5 dies";
+"7 days" = "7 dies";
+"API key verifies Ollama Cloud access; cookies still expose quota limits." = "La clau API verifica l'accés a Ollama Cloud; les galetes encara exposen els límits de quota.";
+"AWS access key ID. Can also be set with AWS_ACCESS_KEY_ID." = "ID de clau d'accés d'AWS. També es pot definir amb AWS_ACCESS_KEY_ID.";
+"AWS region. Can also be set with AWS_REGION." = "Regió d'AWS. També es pot definir amb AWS_REGION.";
+"AWS secret access key. Can also be set with AWS_SECRET_ACCESS_KEY." = "Clau secreta d'accés d'AWS. També es pot definir amb AWS_SECRET_ACCESS_KEY.";
+"Access key ID" = "ID de clau d'accés";
+"Add Account" = "Afegiu compte";
+"Adding Account…" = "S'està afegint el compte…";
+"Antigravity login failed" = "L'inici de sessió d'Antigravity ha fallat";
+"Antigravity login timed out" = "L'inici de sessió d'Antigravity ha esgotat el temps";
+"Auth source" = "Font d'autenticació";
+"Automatic imports browser cookies from Xiaomi MiMo." = "Importa automàticament les galetes del navegador de Xiaomi MiMo.";
+"Automatic imports Windsurf session data from Chromium browser localStorage." = "Importa automàticament dades de sessió de Windsurf del localStorage de Chromium.";
+"Automatic imports browser cookies from Bailian." = "Importa automàticament galetes del navegador de Bailian.";
+"Automatically imports browser cookies." = "Importa automàticament galetes del navegador.";
+"Automatically imports browser session cookies." = "Importa automàticament galetes de sessió del navegador.";
+"Azure OpenAI deployment name. AZURE_OPENAI_DEPLOYMENT_NAME is also supported." = "Nom del desplegament d'Azure OpenAI. També s'admet AZURE_OPENAI_DEPLOYMENT_NAME.";
+"Azure OpenAI key" = "Clau d'Azure OpenAI";
+"Azure OpenAI resource endpoint. AZURE_OPENAI_ENDPOINT is also supported." = "Endpoint del recurs Azure OpenAI. També s'admet AZURE_OPENAI_ENDPOINT.";
+"Base URL" = "URL base";
+"Base URL for the LLM-API-Key-Proxy instance." = "URL base de la instància LLM-API-Key-Proxy.";
+"Browser cookies" = "Galetes del navegador";
+"Cap end" = "Final del límit";
+"Cap start" = "Inici del límit";
+"Capacity End" = "Final de capacitat";
+"Capacity Start" = "Inici de capacitat";
+"Changelog" = "Registre de canvis";
+"Choose the Moonshot/Kimi API host for international or China mainland accounts." = "Trieu el host de l'API Moonshot/Kimi per a comptes internacionals o de la Xina continental.";
+"CodexBar can't replace a system account that is signed in with an API key only setup." = "CodexBar no pot substituir un compte del sistema iniciat només amb una clau API.";
+"CodexBar could not find saved auth for that account. Re-authenticate it and try again." = "CodexBar no ha trobat autenticació desada per a aquest compte. Torna'l a autenticar i prova-ho de nou.";
+"CodexBar could not read managed account storage. Recover the store before adding another account." = "CodexBar no ha pogut llegir l'emmagatzematge de comptes gestionats. Recupera'l abans d'afegir un altre compte.";
+"CodexBar could not read saved auth for that account. Re-authenticate it and try again." = "CodexBar no ha pogut llegir l'autenticació desada per a aquest compte. Torna'l a autenticar i prova-ho de nou.";
+"CodexBar could not read the current system account on this Mac." = "CodexBar no ha pogut llegir el compte del sistema actual en aquest Mac.";
+"CodexBar could not replace the live Codex auth on this Mac." = "CodexBar no ha pogut substituir l'autenticació activa de Codex en aquest Mac.";
+"CodexBar could not safely preserve the current system account before switching." = "CodexBar no ha pogut preservar de manera segura el compte del sistema actual abans de canviar.";
+"CodexBar could not save the current system account before switching." = "CodexBar no ha pogut desar el compte del sistema actual abans de canviar.";
+"CodexBar could not update managed account storage." = "CodexBar no ha pogut actualitzar l'emmagatzematge de comptes gestionats.";
+"CodexBar found another managed account that already uses the current system account. Resolve the duplicate account before switching." = "CodexBar ha trobat un altre compte gestionat que ja utilitza el compte del sistema actual. Resol el compte duplicat abans de canviar.";
+"CodexBar will ask macOS Keychain for “%@” so it can decrypt browser cookies and authenticate your account. Click OK to continue." = "CodexBar demanarà a Clauer de macOS “%@” per desxifrar galetes del navegador i autenticar el compte. Premeu D'acord per continuar.";
+"CodexBar will ask macOS Keychain for the Claude Code OAuth token so it can fetch your Claude usage. Click OK to continue." = "CodexBar demanarà a Clauer de macOS el token OAuth de Claude Code per obtenir l'ús de Claude. Premeu D'acord per continuar.";
+"CodexBar will ask macOS Keychain for your Amp cookie header so it can fetch usage. Click OK to continue." = "CodexBar demanarà a Clauer de macOS la capçalera Cookie d'Amp per obtenir l'ús. Premeu D'acord per continuar.";
+"CodexBar will ask macOS Keychain for your Augment cookie header so it can fetch usage. Click OK to continue." = "CodexBar demanarà a Clauer de macOS la capçalera Cookie d'Augment per obtenir l'ús. Premeu D'acord per continuar.";
+"CodexBar will ask macOS Keychain for your Claude cookie header so it can fetch Claude web usage. Click OK to continue." = "CodexBar demanarà a Clauer de macOS la capçalera Cookie de Claude per obtenir l'ús web de Claude. Premeu D'acord per continuar.";
+"CodexBar will ask macOS Keychain for your Cursor cookie header so it can fetch usage. Click OK to continue." = "CodexBar demanarà a Clauer de macOS la capçalera Cookie de Cursor per obtenir l'ús. Premeu D'acord per continuar.";
+"CodexBar will ask macOS Keychain for your Factory cookie header so it can fetch usage. Click OK to continue." = "CodexBar demanarà a Clauer de macOS la capçalera Cookie de Factory per obtenir l'ús. Premeu D'acord per continuar.";
+"CodexBar will ask macOS Keychain for your GitHub Copilot token so it can fetch usage. Click OK to continue." = "CodexBar demanarà a Clauer de macOS el token de GitHub Copilot per obtenir l'ús. Premeu D'acord per continuar.";
+"CodexBar will ask macOS Keychain for your Kimi K2 API key so it can fetch usage. Click OK to continue." = "CodexBar demanarà a Clauer de macOS la clau API de Kimi K2 per obtenir l'ús. Premeu D'acord per continuar.";
+"CodexBar will ask macOS Keychain for your Kimi auth token so it can fetch usage. Click OK to continue." = "CodexBar demanarà a Clauer de macOS el token d'autenticació de Kimi per obtenir l'ús. Premeu D'acord per continuar.";
+"CodexBar will ask macOS Keychain for your MiniMax API token so it can fetch usage. Click OK to continue." = "CodexBar demanarà a Clauer de macOS el token API de MiniMax per obtenir l'ús. Premeu D'acord per continuar.";
+"CodexBar will ask macOS Keychain for your MiniMax cookie header so it can fetch usage. Click OK to continue." = "CodexBar demanarà a Clauer de macOS la capçalera Cookie de MiniMax per obtenir l'ús. Premeu D'acord per continuar.";
+"CodexBar will ask macOS Keychain for your OpenAI cookie header so it can fetch Codex dashboard extras. Click OK to continue." = "CodexBar demanarà a Clauer de macOS la capçalera Cookie d'OpenAI per obtenir extres del tauler de Codex. Premeu D'acord per continuar.";
+"CodexBar will ask macOS Keychain for your OpenCode cookie header so it can fetch usage. Click OK to continue." = "CodexBar demanarà a Clauer de macOS la capçalera Cookie d'OpenCode per obtenir l'ús. Premeu D'acord per continuar.";
+"CodexBar will ask macOS Keychain for your Synthetic API key so it can fetch usage. Click OK to continue." = "CodexBar demanarà a Clauer de macOS la clau API de Synthetic per obtenir l'ús. Premeu D'acord per continuar.";
+"CodexBar will ask macOS Keychain for your z.ai API token so it can fetch usage. Click OK to continue." = "CodexBar demanarà a Clauer de macOS el token API de z.ai per obtenir l'ús. Premeu D'acord per continuar.";
+"Could not open Cursor login in your browser." = "No s'ha pogut obrir l'inici de sessió de Cursor al navegador.";
+"Could not open browser for Antigravity" = "No s'ha pogut obrir el navegador per a Antigravity";
+"Credits used" = "Crèdits usats";
+"Day" = "Dia";
+"Deployment" = "Desplegament";
+"Drag to reorder" = "Arrossegueu per reordenar";
+"Sort providers alphabetically" = "Ordena els proveïdors alfabèticament";
+"Sort providers alphabetically (enabled first)" = "Ordena els proveïdors alfabèticament (els activats primer)";
+"Sorted alphabetically (enabled first) — click to use your custom order" = "Ordenats alfabèticament (els activats primer) — fes clic per utilitzar l’ordre personalitzat";
+"Endpoint" = "Endpoint";
+"Enterprise host" = "Host Enterprise";
+"Extra usage balance: %@" = "Saldo d'ús extra: %@";
+"Keychain Access Required" = "Cal accés al Clauer";
+"Kiro menu bar value" = "Valor de Kiro a la barra de menús";
+"Label" = "Etiqueta";
+"No organizations loaded. Click Refresh after setting your API key." = "No hi ha organitzacions carregades. Feu clic a Actualitza després de configurar la clau API.";
+"No output captured." = "No s'ha capturat cap sortida.";
+"No system account" = "Sense compte del sistema";
+"Oasis-Token" = "Oasis-Token";
+"Open Augment (Log Out & Back In)" = "Obriu Augment (tanqueu la sessió i torneu a iniciar-la)";
+"Open Codebuff Dashboard" = "Obriu el tauler de Codebuff";
+"Open Command Code Settings" = "Obriu la configuració de Command Code";
+"Open Crof dashboard" = "Obriu el tauler de Crof";
+"Open Manus" = "Obriu Manus";
+"Open MiMo Balance" = "Obriu el saldo de MiMo";
+"Open Moonshot Console" = "Obriu la consola de Moonshot";
+"Open Ollama API Keys" = "Obriu les claus API d'Ollama";
+"Open StepFun Platform" = "Obriu la plataforma StepFun";
+"Open T3 Chat Settings" = "Obriu la configuració de T3 Chat";
+"Open Volcengine Ark Console" = "Obriu la consola Volcengine Ark";
+"Open legacy provider docs" = "Obriu la documentació del proveïdor heretat";
+"Open projects" = "Obriu projectes";
+"Open this URL manually to continue login:\n\n%@" = "Obriu aquesta URL manualment per continuar l'inici de sessió:\n\n%@";
+"Optional organization ID for accounts linked to multiple Anthropic organizations." = "ID d'organització opcional per a comptes vinculats a diverses organitzacions d'Anthropic.";
+"Optional. Applies to the configured Admin API key; selected token accounts do not inherit OPENAI_PROJECT_ID." = "Opcional. S'aplica a la clau Admin API configurada; els comptes de token seleccionats no hereten OPENAI_PROJECT_ID.";
+"Optional. Enter your GitHub Enterprise host, for example octocorp.ghe.com. Leave blank for github.com." = "Opcional. Introduïu el host de GitHub Enterprise, per exemple octocorp.ghe.com. Deixeu-ho en blanc per a github.com.";
+"Optional. Leave blank to discover and aggregate projects visible to the API key." = "Opcional. Deixeu-ho en blanc per descobrir i agregar projectes visibles per a la clau API.";
+"Org ID (optional)" = "ID d'org. (opcional)";
+"Organizations" = "Organitzacions";
+"Password" = "Contrasenya";
+"%@ authentication is disabled." = "L'autenticació de %@ està desactivada.";
+"%@ cookies are disabled." = "Les galetes de %@ estan desactivades.";
+"%@ web API access is disabled." = "L'accés a l'API web de %@ està desactivat.";
+"Disable %@ dashboard cookie usage." = "Desactiveu l'ús de galetes del tauler de %@.";
+"Keychain access is disabled in Advanced, so browser cookie import is unavailable." = "L'accés al Clauer està desactivat a Avançat, així que la importació de galetes del navegador no està disponible.";
+"Manually paste an %@ from a browser session." = "Enganxeu manualment un %@ d'una sessió del navegador.";
+"Paste a Cookie header captured from %@." = "Enganxeu una capçalera Cookie capturada de %@.";
+"Paste a Cookie header from %@." = "Enganxeu una capçalera Cookie de %@.";
+"Paste a Cookie header or cURL capture from %@." = "Enganxeu una capçalera Cookie o una captura cURL de %@.";
+"Paste a Cookie header or full cURL capture from %@." = "Enganxeu una capçalera Cookie o una captura cURL completa de %@.";
+"Paste a Cookie or Authorization header from %@." = "Enganxeu una capçalera Cookie o Authorization de %@.";
+"Paste a full cookie header or the %@ value." = "Enganxeu una capçalera de galetes completa o el valor %@.";
+"Paste a Cookie header or full cURL capture from T3 Chat settings." = "Enganxeu una capçalera Cookie o una captura cURL completa de la configuració de T3 Chat.";
+"Paste the Cookie header from a request to admin.mistral.ai. Must contain an ory_session_* cookie." = "Enganxeu la capçalera Cookie d'una sol·licitud a admin.mistral.ai. Ha de contenir una galeta ory_session_*.";
+"Paste the Oasis-Token from a logged-in browser session on platform.stepfun.com." = "Enganxeu l'Oasis-Token d'una sessió iniciada a platform.stepfun.com.";
+"Paste the %@ JSON bundle from %@." = "Enganxeu el paquet JSON %@ de %@.";
+"Paste the %@ value or a full Cookie header." = "Enganxeu el valor %@ o una capçalera Cookie completa.";
+"Personal account" = "Compte personal";
+"Project ID" = "ID de projecte";
+"Re-auth" = "Reautentiqueu";
+"Re-login at claude.ai" = "Torneu a iniciar sessió a claude.ai";
+"Re-authenticating…" = "S'està reautenticant…";
+"Refresh Session" = "Actualitzeu la sessió";
+"Refresh organizations" = "Actualitzeu organitzacions";
+"Region" = "Regió";
+"Reload" = "Recarregueu";
+"Reorder" = "Reordeneu";
+"Secret access key" = "Clau secreta d'accés";
+"Series" = "Sèrie";
+"Service" = "Servei";
+"Show or hide Kiro credits, percent, or both next to the menu bar icon." = "Mostreu o amagueu crèdits de Kiro, percentatge o tots dos al costat de la icona de la barra de menús.";
+"Show usage for organizations you belong to. Personal account is always shown." = "Mostreu l'ús de les organitzacions a què pertanyeu. El compte personal sempre es mostra.";
+"Sign in to cursor.com in your browser, then refresh Cursor in CodexBar." = "Inicieu sessió a cursor.com al navegador i després actualitzeu Cursor a CodexBar.";
+"Simulated error text" = "Text d'error simulat";
+"StepFun platform account (phone number or email)." = "Compte de la plataforma StepFun (telèfon o correu).";
+"Stored in ~/.codexbar/config.json." = "Desat a ~/.codexbar/config.json.";
+"Stored in ~/.codexbar/config.json. AZURE_OPENAI_API_KEY is also supported." = "Desat a ~/.codexbar/config.json. També s'admet AZURE_OPENAI_API_KEY.";
+"Stored in ~/.codexbar/config.json. For the official Kimi API, use Moonshot / Kimi API." = "Desat a ~/.codexbar/config.json. Per a l'API oficial de Kimi, useu Moonshot / Kimi API.";
+"Stored in ~/.codexbar/config.json. Get your API key from the Volcengine Ark console." = "Desat a ~/.codexbar/config.json. Obteniu la clau API a la consola Volcengine Ark.";
+"Stored in ~/.codexbar/config.json. Get your key from Ollama settings." = "Desat a ~/.codexbar/config.json. Obteniu la clau a la configuració d'Ollama.";
+"Stored in ~/.codexbar/config.json. Get your key from console.deepgram.com." = "Desat a ~/.codexbar/config.json. Obteniu la clau a console.deepgram.com.";
+"Stored in ~/.codexbar/config.json. Get your key from elevenlabs.io/app/settings/api-keys." = "Desat a ~/.codexbar/config.json. Obteniu la clau a elevenlabs.io/app/settings/api-keys.";
+"Stored in ~/.codexbar/config.json. Get your key from openrouter.ai/settings/keys and set a key spending limit there to enable API key quota tracking." = "Desat a ~/.codexbar/config.json. Obteniu la clau a openrouter.ai/settings/keys i definiu-hi un límit de despesa per activar el seguiment de quota.";
+"Stored in ~/.codexbar/config.json. In Warp, open Settings > Platform > API Keys, then create one." = "Desat a ~/.codexbar/config.json. A Warp, obriu Settings > Platform > API Keys i creeu-ne una.";
+"Stored in ~/.codexbar/config.json. Metrics require Groq Enterprise Prometheus access." = "Desat a ~/.codexbar/config.json. Les mètriques requereixen accés a Groq Enterprise Prometheus.";
+"Stored in ~/.codexbar/config.json. OPENAI_ADMIN_KEY is preferred; OPENAI_API_KEY still works." = "Desat a ~/.codexbar/config.json. Es prefereix OPENAI_ADMIN_KEY; OPENAI_API_KEY encara funciona.";
+"Stored in ~/.codexbar/config.json. Requires an Anthropic Admin API key." = "Desat a ~/.codexbar/config.json. Requereix una clau Anthropic Admin API.";
+"Stored in ~/.codexbar/config.json. Used for /v1/quota-stats." = "Desat a ~/.codexbar/config.json. S'usa per a /v1/quota-stats.";
+"Stored in ~/.codexbar/config.json. You can also provide CODEBUFF_API_KEY or let CodexBar read ~/.config/manicode/credentials.json (created by `codebuff login`)." = "Desat a ~/.codexbar/config.json. També podeu proporcionar CODEBUFF_API_KEY o deixar que CodexBar llegeixi ~/.config/manicode/credentials.json (creat per `codebuff login`).";
+"Stored in ~/.codexbar/config.json. You can also provide CROF_API_KEY." = "Desat a ~/.codexbar/config.json. També podeu proporcionar CROF_API_KEY.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or ~/.local/share/kilo/auth.json (kilo.access)." = "Desat a ~/.codexbar/config.json. També podeu proporcionar KILO_API_KEY o ~/.local/share/kilo/auth.json (kilo.access).";
+"T3 Chat cookie" = "Galeta de T3 Chat";
+"That account is no longer available in CodexBar. Refresh the account list and try again." = "Aquest compte ja no està disponible a CodexBar. Actualitzeu la llista de comptes i torneu-ho a provar.";
+"The browser login did not complete in time. Try Antigravity login again." = "L'inici de sessió del navegador no s'ha completat a temps. Torna a provar l'inici de sessió d'Antigravity.";
+"Timed out waiting for Cursor login. %@" = "S'ha esgotat el temps esperant l'inici de sessió de Cursor. %@";
+"Timed out waiting for Cursor login. %@ Last error: %@" = "S'ha esgotat el temps esperant l'inici de sessió de Cursor. %@ Últim error: %@";
+"Today requests" = "Sol·licituds d'avui";
+"Total (30d): %@ credits" = "Total (30 d): %@ crèdits";
+"Username" = "Nom d'usuari";
+"Uses username + password to login and obtain an Oasis-Token automatically." = "Fa servir el nom d'usuari i la contrasenya per iniciar sessió i obtenir automàticament un Oasis-Token.";
+"Uses username + password to login and obtain an %@ automatically." = "Fa servir el nom d'usuari i la contrasenya per iniciar sessió i obtenir automàticament un %@.";
+"Utilization End" = "Final d'utilització";
+"Utilization Start" = "Inici d'utilització";
+"Verbosity" = "Detall";
+"Windsurf session JSON bundle" = "Paquet JSON de sessió de Windsurf";
+"Workspace ID" = "ID d'espai de treball";
+"Your StepFun platform password. Used to login and obtain a session token." = "La contrasenya de la plataforma StepFun. S'usa per iniciar sessió i obtenir un token de sessió.";
+"claude /login exited with status %d." = "claude /login ha sortit amb estat %d.";
+"codex login exited with status %d." = "codex login ha sortit amb estat %d.";
+"Cookie: …\n\nor paste a cURL capture from the Abacus AI dashboard" = "Cookie: …\n\no enganxa una captura cURL del tauler d'Abacus AI";
+"Cookie: …\n\nor paste the __Secure-next-auth.session-token value" = "Cookie: …\n\no enganxa el valor de __Secure-next-auth.session-token";
+"Cookie: …\n\nor paste the kimi-auth token value" = "Cookie: …\n\no enganxa el valor del token kimi-auth";
+"session_id=...\n\nor paste just the session_id value" = "session_id=...\n\no enganxa només el valor de session_id";
+"Clear" = "Esborreu";
+"No matching providers" = "No hi ha proveïdors coincidents";
+"Search providers" = "Cerca proveïdors";
+
+"language_vietnamese" = "Vietnamita";
+"language_turkish" = "Türkçe";
+"language_indonesian" = "Indonesi";
+"language_arabic" = "العربية";
+"language_persian" = "فارسی";
+"language_thai" = "ไทย";
+"Limit Reset Credits" = "Crèdits de restabliment del límit";
+"1 manual reset available" = "Hi ha 1 restabliment manual disponible";
+"%d manual resets available" = "Hi ha %d restabliments manuals disponibles";
+"Next expires %@" = "El següent caduca %@";
+"Other (%d items)" = "Altres (%d elements)";
+"Expand" = "Amplia";
+"Collapse" = "Redueix";
+"byte_unit_byte" = "byte";
+"byte_unit_bytes" = "bytes";
+"byte_unit_kilobyte" = "quilobyte";
+"byte_unit_kilobytes" = "quilobytes";
+"byte_unit_megabyte" = "megabyte";
+"byte_unit_megabytes" = "megabytes";
+"byte_unit_gigabyte" = "gigabyte";
+"byte_unit_gigabytes" = "gigabytes";
+
+/* Noves traduccions */
+"%@ is unavailable in the current environment." = "%@ no està disponible en l'entorn actual.";
+"%@ left" = "Queden %@";
+"%@ · %@" = "%@ · %@";
+"%@: %@ · %@ tokens" = "%@: %@ · %@ tokens";
+"%@: %@%% used" = "%@: %@%% usat";
+"%d more items" = "%d elements més";
+"%d unreadable item(s) skipped" = "%d elements no llegibles omesos";
+"%d%% in deficit" = "%d%% en dèficit";
+"%d%% in reserve" = "%d%% en reserva";
+"%dd" = "%dd";
+"About CodexBar" = "Quant al CodexBar";
+"Add Account..." = "Afegiu un compte...";
+"Add accounts via GitHub OAuth Device Flow on the selected host." = "Afegiu comptes mitjançant el flux de dispositiu de GitHub OAuth a l'amfitrió seleccionat.";
+"Add Google Account" = "Afegiu un compte de Google";
+"Admin API key" = "Clau d'Admin API";
+"All Systems Operational" = "Tots els sistemes estan operatius";
+"Auto" = "Automàtic";
+"Auto uses the local IDE API first, then Google OAuth when the IDE is closed." = "El mode automàtic fa servir primer l'API local de l'IDE i després Google OAuth quan l'IDE està tancat.";
+"Cleanup ideas" = "Idees de neteja";
+"Clearing removes archived Codex session history." = "En esborrar, s'elimina l'historial arxivat de sessions de Codex.";
+"Clearing removes cached large pastes or attached images." = "En esborrar, s'eliminen de la memòria cau els continguts voluminosos enganxats o les imatges adjuntes.";
+"Clearing removes checkpoint restore data for previous edits." = "En esborrar, s'eliminen les dades de restauració dels punts de control d'edicions anteriors.";
+"Clearing removes leftover runtime shell snapshot files." = "En esborrar, s'eliminen els fitxers residuals d'instantànies de shell en execució.";
+"Clearing removes legacy per-session task lists." = "En esborrar, s'eliminen les llistes de tasques antigues per sessió.";
+"Clearing removes local diagnostic logs." = "En esborrar, s'eliminen els registres de diagnòstic locals.";
+"Clearing removes local edit checkpoint history." = "En esborrar, s'elimina l'historial local de punts de control d'edició.";
+"Clearing removes local temporary provider data." = "En esborrar, s'eliminen les dades temporals locals del proveïdor.";
+"Clearing removes old plan-mode files." = "En esborrar, s'eliminen els fitxers antics del mode plan.";
+"Clearing removes past Codex session history." = "En esborrar, s'elimina l'historial anterior de sessions de Codex.";
+"Clearing removes past debug logs." = "En esborrar, s'eliminen els registres de depuració anteriors.";
+"Clearing removes past resume, continue, and rewind history." = "En esborrar, s'elimina l'historial anterior de represa, continuació i rebobinat.";
+"Clearing removes per-session environment metadata." = "En esborrar, s'eliminen les metadades d'entorn de cada sessió.";
+"Clearing removes provider-owned cached data." = "En esborrar, s'eliminen les dades de la memòria cau pertanyents al proveïdor.";
+"Credits unavailable; keep Codex running to refresh." = "Crèdits no disponibles; mantingueu el Codex en execució per actualitzar.";
+"Daily" = "Diari";
+"Disabled — no recent data" = "Desactivat — sense dades recents";
+"Est. total (%@): %@" = "Total estimat (%@): %@";
+"Est. total (30d): %@" = "Total estimat (30 d): %@";
+"Estimated from local Codex logs for the selected account." = "Estimat a partir dels registres locals de Codex per al compte seleccionat.";
+"Google accounts" = "Comptes de Google";
+"Google OAuth" = "Google OAuth";
+"Hourly Tokens" = "Tokens per hora";
+"Hover a bar for details" = "Passeu el cursor per una barra per veure'n els detalls";
+"Image Generation" = "Generació d'imatges";
+"just now" = "ara mateix";
+"Last %d day" = "Últim %d dia";
+"Last 30 days" = "Últims 30 dies";
+"Last 30 days:" = "Últims 30 dies:";
+"Last 30 days: %@" = "Últims 30 dies: %@";
+"Last 30 days: %@ · %@ tokens" = "Últims 30 dies: %@ · %@ tokens";
+"Lasts until reset" = "Dura fins al reinici";
+"Login with Google" = "Inicieu sessió amb Google";
+"login_success_notification_body" = "Podeu tornar a l'app; l'autenticació ha finalitzat.";
+"login_success_notification_title" = "Inici de sessió de %@ correcte";
+"Manual cleanup: archived sessions" = "Neteja manual: sessions arxivades";
+"Manual cleanup: attachment cache" = "Neteja manual: memòria cau d'adjuncions";
+"Manual cleanup: cache" = "Neteja manual: memòria cau";
+"Manual cleanup: debug logs" = "Neteja manual: registres de depuració";
+"Manual cleanup: file checkpoints" = "Neteja manual: punts de control de fitxers";
+"Manual cleanup: file history" = "Neteja manual: historial de fitxers";
+"Manual cleanup: legacy todos" = "Neteja manual: tasques antigues";
+"Manual cleanup: logs" = "Neteja manual: registres";
+"Manual cleanup: past sessions" = "Neteja manual: sessions anteriors";
+"Manual cleanup: saved plans" = "Neteja manual: plans desats";
+"Manual cleanup: session metadata" = "Neteja manual: metadades de sessió";
+"Manual cleanup: sessions" = "Neteja manual: sessions";
+"Manual cleanup: shell snapshots" = "Neteja manual: instantànies de shell";
+"Manual cleanup: temporary data" = "Neteja manual: dades temporals";
+"minimax_service_coding_plan_search" = "Cerca (pla de programació)";
+"minimax_service_coding_plan_vlm" = "Model de visió (pla de programació)";
+"minimax_service_image_generation" = "Generació d'imatges";
+"minimax_service_lyrics_generation" = "Generació de lletres";
+"minimax_service_music_generation" = "Generació de música";
+"minimax_service_text_generation" = "Generació de text";
+"minimax_service_text_to_speech" = "Síntesi de veu";
+"minimax_usage_amount_format" = "Ús: %@ / %@";
+"minimax_used_percent_format" = "%@ usat";
+"Missing DeepSeek API key." = "Falta la clau d'API de DeepSeek.";
+"Music Generation" = "Generació de música";
+"No %@ utilization data yet." = "Encara no hi ha dades d'utilització de %@.";
+"No available fetch strategy for %@." = "No hi ha cap estratègia d'obtenció disponible per a %@.";
+"No available fetch strategy for minimax." = "No hi ha cap estratègia d'obtenció disponible per a MiniMax.";
+"No Cursor session found. Please log in to cursor.com in Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX, or Edge Canary. If you use Safari, grant CodexBar Full Disk Access in System Settings ▸ Privacy & Security. You can also sign in to Cursor from the CodexBar menu (Add / switch account)." = "No s'ha trobat cap sessió de Cursor. Inicieu la sessió a cursor.com amb Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX o Edge Canary. Si feu servir Safari, atorgueu al CodexBar Accés complet al disc a Configuració del Sistema ▸ Privadesa i Seguretat. També podeu iniciar la sessió a Cursor des del menú del CodexBar (Afegiu / canvieu de compte).";
+"No JetBrains IDE with AI Assistant detected. Install a JetBrains IDE and enable AI Assistant." = "No s'ha detectat cap IDE de JetBrains amb AI Assistant. Instal·leu un IDE de JetBrains i activeu l'AI Assistant.";
+"No local data found" = "No s'han trobat dades locals";
+"No OpenCode session cookies found in browsers." = "No s'han trobat galetes de sessió d'OpenCode als navegadors.";
+"No overview data available." = "No hi ha dades de resum disponibles.";
+"No providers selected for Overview." = "No hi ha cap proveïdor seleccionat per al Resum.";
+"No usage breakdown data available." = "No hi ha dades de desglossament d'ús disponibles.";
+"No utilization data yet." = "Encara no hi ha dades d'utilització.";
+"not detected" = "no detectat";
+"On pace" = "Al ritme";
+"Open billing" = "Obriu la facturació";
+"Open Token Plan" = "Obriu el pla de tokens";
+"OpenRouter API token not configured. Set OPENROUTER_API_KEY environment variable or configure in Settings." = "Token d'API d'OpenRouter no configurat. Definiu la variable d'entorn OPENROUTER_API_KEY o configureu-lo a Configuració.";
+"Pace: %@" = "Ritme: %@";
+"Pace: %@ · %@" = "Ritme: %@ · %@";
+"Projected empty in %@" = "Es preveu que s'esgotarà en %@";
+"Projected empty now" = "Es preveu que s'esgotarà ara";
+"Quit" = "Sortiu";
+"quota_warning_notification_body" = "Queda un %1$@. Heu assolit el llindar d'avís del %2$d%% (%3$@).";
+"quota_warning_notification_body_with_account" = "Compte %1$@. Queda un %2$@. Heu assolit el llindar d'avís del %3$d%% (%4$@).";
+"quota_warning_notification_title" = "Quota baixa de %1$@ (%2$@)";
+"Refreshing" = "S'està actualitzant";
+"Request quota: %@ / %@" = "Quota de sol·licituds: %@ / %@";
+"Resets %@" = "Es reinicia %@";
+"Resets in %@" = "Es reinicia en %@";
+"Resets now" = "Es reinicia ara";
+"Runs out in %@" = "S'esgota en %@";
+"Runs out now" = "S'esgota ara";
+"Session" = "Sessió";
+"session_depleted_notification_body" = "Queda un 0%. Es notificarà quan torni a estar disponible.";
+"session_depleted_notification_title" = "Quota de sessió de %@ esgotada";
+"session_restored_notification_body" = "La quota de sessió torna a estar disponible.";
+"session_restored_notification_title" = "Quota de sessió de %@ restablerta";
+"Settings..." = "Configuració...";
+"Source" = "Origen";
+"State" = "Estat";
+"Status Page" = "Pàgina d'estat";
+"Store multiple Antigravity Google OAuth accounts for quick switching." = "Deseu diversos comptes OAuth de Google d'Antigravity per canviar ràpidament.";
+"Store multiple DeepSeek API keys." = "Deseu diverses claus d'API de DeepSeek.";
+"Store multiple OpenAI API keys." = "Deseu diverses claus d'API d'OpenAI.";
+"Stores each signed-in Google account for quick Antigravity switching. Uses Antigravity.app OAuth when available, or ANTIGRAVITY_OAUTH_CLIENT_ID and ANTIGRAVITY_OAUTH_CLIENT_SECRET as an override." = "Desa cada compte de Google amb la sessió iniciada per canviar ràpidament a Antigravity. Fa servir OAuth d'Antigravity.app quan està disponible, o ANTIGRAVITY_OAUTH_CLIENT_ID i ANTIGRAVITY_OAUTH_CLIENT_SECRET com a substitució.";
+"Switch Account..." = "Canvieu de compte...";
+"terminal_app_subtitle" = "Terminal que fa servir l'acció Obre el Terminal";
+"terminal_app_title" = "Terminal per defecte";
+"Text Generation" = "Generació de text";
+"Text to Speech" = "Síntesi de veu";
+"today" = "avui";
+"Total: %@" = "Total: %@";
+"Unavailable" = "No disponible";
+"Update ready, restart now?" = "Actualització a punt, voleu reiniciar ara?";
+"Updated %@" = "Actualitzat %@";
+"Updated %@h ago" = "Actualitzat fa %@h";
+"Updated %@m ago" = "Actualitzat fa %@m";
+"Updated just now" = "Actualitzat ara mateix";
+"Usage Dashboard" = "Tauler d'ús";
+"usage_percent_suffix_left" = "restant";
+"usage_percent_suffix_used" = "usat";
+"Weekly" = "Setmanal";
+"z.ai API token not found. Set apiKey in ~/.codexbar/config.json or Z_AI_API_KEY." = "No s'ha trobat el token d'API de z.ai. Definiu apiKey a ~/.codexbar/config.json o Z_AI_API_KEY.";
+"≈ %d%% run-out risk" = "≈ %d%% risc d'esgotament";
diff --git a/Sources/CodexBar/Resources/de.lproj/Localizable.strings b/Sources/CodexBar/Resources/de.lproj/Localizable.strings
new file mode 100644
index 0000000000..cba1149257
--- /dev/null
+++ b/Sources/CodexBar/Resources/de.lproj/Localizable.strings
@@ -0,0 +1,1107 @@
+/* English localization for CodexBar (base/fallback) */
+
+" providers" = "Anbieter";
+"(System)" = "(System)";
+"30d" = "30d";
+"A managed Codex login is already running. Wait for it to finish before adding " = "Eine verwaltete Codex-Anmeldung läuft bereits. Warten Sie, bis der Vorgang abgeschlossen ist, bevor Sie ihn hinzufügen";
+"API key" = "API-Schlüssel";
+"API region" = "API-Region";
+"API token" = "API-Token";
+"API tokens" = "API-Tokens";
+"About" = "Über";
+"Account" = "Konto";
+"Accounts" = "Konten";
+"Accounts subtitle" = "Untertitel \"Konten\".";
+"Active" = "Aktiv";
+"Add" = "Hinzufügen";
+"Add Workspace" = "Arbeitsbereich hinzufügen";
+"Advanced" = "Erweitert";
+"All" = "Alle";
+"Always allow prompts" = "Erlauben Sie immer Aufforderungen";
+"Animation pattern" = "Animationsmuster";
+"Antigravity login is managed in the app" = "Der Antigravity-Login wird in der App verwaltet";
+"Applies only to the Security.framework OAuth keychain reader." = "Gilt nur für den Security.framework OAuth-Schlüsselbundleser.";
+"Auto falls back to the next source if the preferred one fails." = "Wenn die bevorzugte Quelle ausfällt, wird automatisch auf die nächste Quelle zurückgegriffen.";
+"Auto uses API first, then falls back to CLI on auth failures." = "Auto verwendet zuerst die API und greift dann bei Authentifizierungsfehlern auf die CLI zurück.";
+"Auto-detect" = "Automatische Erkennung";
+"Auto-refresh is off; use the menu's Refresh command." = "Die automatische Aktualisierung ist deaktiviert. Verwenden Sie den Befehl \"Aktualisieren\" des Menüs.";
+"Auto-refresh: hourly · Timeout: 10m" = "Automatische Aktualisierung: stündlich · Zeitüberschreitung: 10 Minuten";
+"Automatic" = "Automatisch";
+"Automatic imports browser cookies and WorkOS tokens." = "Automatischer Import von Browser-Cookies und WorkOS-Tokens.";
+"Automatic imports browser cookies and local storage tokens." = "Automatischer Import von Browser-Cookies und lokalen Speichertokens.";
+"Automatic imports browser cookies for dashboard extras." = "Automatischer Import von Browser-Cookies für Dashboard-Extras.";
+"Automatic imports browser cookies for the web API." = "Automatischer Import von Browser-Cookies für die Web-API.";
+"Automatic imports browser cookies from Model Studio/Bailian." = "Importiert automatisch Browser-Cookies von Model Studio/Bailian.";
+"Automatic imports browser cookies from admin.mistral.ai." = "Importiert automatisch Browser-Cookies von admin.mistral.ai.";
+"Automatic imports browser cookies from opencode.ai." = "Importiert automatisch Browser-Cookies von opencode.ai.";
+"Automatic imports browser cookies or stored sessions." = "Automatischer Import von Browser-Cookies oder gespeicherten Sitzungen.";
+"Automatic imports browser cookies." = "Automatischer Import von Browser-Cookies.";
+"Automatically imports browser session cookie." = "Importiert automatisch Browser-Sitzungscookies.";
+"Automatically opens CodexBar when you start your Mac." = "CodexBar wird automatisch geöffnet, wenn Sie Ihren Mac starten.";
+"Automation" = "Automatisierung";
+"Average (\\(label1) + \\(label2))" = "Durchschnitt (\\\\(label1) + \\\\(label2))";
+"Average (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))" = "Durchschnitt (\\\\(metadata.sessionLabel) + \\\\(metadata.weeklyLabel))";
+"Avoid Keychain prompts" = "Vermeiden Sie Aufforderungen zum Schlüsselbund";
+"Balance" = "Gleichgewicht";
+"Battery Saver" = "Batteriesparmodus";
+"Bordered" = "Umrandet";
+"Build" = "Build";
+"Built \\(buildTimestamp)" = "Gebaut \\\\(buildTimestamp)";
+"Buy Credits..." = "Credits kaufen...";
+"Buy Credits…" = "Credits kaufen…";
+"CLI paths" = "CLI-Pfade";
+"CLI sessions" = "CLI-Sitzungen";
+"Caches" = "Caches";
+"Cancel" = "Stornieren";
+"Check for Updates…" = "Nach Updates suchen…";
+"Check for updates automatically" = "Suchen Sie automatisch nach Updates";
+"Check if you like your agents having some fun up there." = "Prüfen Sie, ob Sie möchten, dass Ihre Agenten dort oben Spaß haben.";
+"Check provider status" = "Überprüfen Sie den Anbieterstatus";
+"Choose Codex workspace" = "Wählen Sie Codex-Arbeitsbereich";
+"Choose the MiniMax host (global .io or China mainland .com)." = "Wählen Sie den MiniMax-Host (global .io oder China Mainland .com).";
+"Choose up to " = "Wählen Sie bis zu";
+"Choose up to \\(Self.maxOverviewProviders) providers" = "Wählen Sie bis zu \\\\(Self.maxOverviewProviders) Anbieter aus";
+"Choose up to \\(count) providers" = "Wählen Sie bis zu \\\\(count) Anbieter aus";
+"Choose what to show in the menu bar (Pace shows usage vs. expected)." = "Wählen Sie aus, was in der Menüleiste angezeigt werden soll (Pace zeigt die Nutzung im Vergleich zur erwarteten).";
+"Choose which Codex account CodexBar should follow." = "Wählen Sie aus, welchem ​​Codex-Konto CodexBar folgen soll.";
+"Choose which window drives the menu bar percent." = "Wählen Sie aus, welches Fenster den Prozentwert der Menüleiste steuert.";
+"Chrome" = "Chrome";
+"Claude CLI not found" = "Claude CLI nicht gefunden";
+"Claude binary" = "Claude binär";
+"Claude cookies" = "Claude-Cookies";
+"Claude login failed" = "Die Anmeldung von Claude ist fehlgeschlagen";
+"Claude login timed out" = "Zeitüberschreitung beim Claude-Login";
+"Close" = "Schließen";
+"Code review" = "Codeüberprüfung";
+"Codex CLI not found" = "Codex-CLI nicht gefunden";
+"Codex account login already running" = "Die Codex-Kontoanmeldung läuft bereits";
+"Codex binary" = "Codex-Binärdatei";
+"Codex login failed" = "Codex-Anmeldung fehlgeschlagen";
+"Codex login timed out" = "Zeitüberschreitung beim Codex-Login";
+"CodexBar Lifecycle Keepalive" = "CodexBar Lifecycle Keepalive";
+"CodexBar can't show its menu bar icon" = "CodexBar kann sein Menüleistensymbol nicht anzeigen";
+"CodexBar could not read managed account storage. " = "CodexBar konnte den verwalteten Kontospeicher nicht lesen.";
+"Configure…" = "Konfigurieren…";
+"Connected" = "Verbunden";
+"Controls how much detail is logged." = "Steuert, wie viele Details protokolliert werden.";
+"Cookie header" = "Cookie-Header";
+"Cookie source" = "Cookie-Quelle";
+"Cookie: ..." = "Cookie: ...";
+"Cookie: \\u{2026}\\\n\\\nor paste a cURL capture from the Abacus AI dashboard" = "Cookie: \\u{2026}\\\n\\\noder fügen Sie eine cURL-Erfassung aus dem Abacus AI-Dashboard ein";
+"Cookie: \\u{2026}\\\n\\\nor paste the __Secure-next-auth.session-token value" = "Cookie: \\u{2026}\\\n\\\noder fügen Sie den __Secure-next-auth.session-token-Wert ein";
+"Cookie: \\u{2026}\\\n\\\nor paste the kimi-auth token value" = "Cookie: \\u{2026}\\\n\\\noder fügen Sie den Kimi-Auth-Token-Wert ein";
+"Cookie: …" = "Cookie: …";
+"CopilotDeviceFlow" = "CopilotDeviceFlow";
+"Cost" = "Kosten";
+"Could not add Codex account" = "Codex-Konto konnte nicht hinzugefügt werden";
+"Could not open Terminal for Gemini" = "Terminal für Gemini konnte nicht geöffnet werden";
+"Could not start claude /login" = "Claude /login konnte nicht gestartet werden";
+"Could not start codex login" = "Die Codex-Anmeldung konnte nicht gestartet werden";
+"Could not switch system account" = "Das Systemkonto konnte nicht gewechselt werden";
+"Credits" = "Credits";
+"Credits history" = "Credits-Geschichte";
+"Cursor login failed" = "Die Cursor-Anmeldung ist fehlgeschlagen";
+"Custom" = "Benutzerdefiniert";
+"Custom Path" = "Benutzerdefinierter Pfad";
+"Daily Routines" = "Tägliche Routinen";
+"Debug" = "Debuggen";
+"Default" = "Standard";
+"Disable Keychain access" = "Deaktivieren Sie den Schlüsselbundzugriff";
+"Disabled" = "Deaktiviert";
+"Dismiss" = "Zurückweisen";
+"Disconnected" = "Getrennt";
+"Display" = "Anzeige";
+"Display mode" = "Anzeigemodus";
+"Display reset times as absolute clock values instead of countdowns." = "Anzeige der Rücksetzzeiten als absolute Uhrwerte statt als Countdown.";
+"Done" = "Erledigt";
+"Effective PATH" = "Effektiver WEG";
+"Email" = "E-Mail";
+"Enable Merge Icons to configure Overview tab providers." = "Aktivieren Sie \"Symbole zusammenführen\", um Anbieter für die Registerkarte \"Übersicht\" zu konfigurieren.";
+"Enable file logging" = "Aktivieren Sie die Dateiprotokollierung";
+"Enabled" = "Ermöglicht";
+"Error" = "Fehler";
+"Error simulation" = "Fehlersimulation";
+"Expose troubleshooting tools in the Debug tab." = "Stellen Sie Tools zur Fehlerbehebung auf der Registerkarte \"Debug\" bereit.";
+"Failed" = "Fehlgeschlagen";
+"False" = "FALSCH";
+"Fetch strategy attempts" = "Strategieversuche abrufen";
+"Fetching" = "Holen";
+"Field" = "Feld";
+"Field subtitle" = "Felduntertitel";
+"Finish the current managed account change before switching the system account." = "Schließen Sie die Änderung des aktuellen verwalteten Kontos ab, bevor Sie das Systemkonto wechseln.";
+"Force animation on next refresh" = "Animation bei der nächsten Aktualisierung erzwingen";
+"Gateway region" = "Gateway-Region";
+"Gemini CLI not found" = "Gemini-CLI nicht gefunden";
+"Gemini/Antigravity, surfacing incidents in the icon and menu." = "Zwillinge/Antigravitation, auftauchende Ereignisse im Symbol und Menü.";
+"General" = "Allgemein";
+"GitHub" = "GitHub";
+"GitHub Copilot Login" = "GitHub Copilot-Anmeldung";
+"GitHub Login" = "GitHub-Anmeldung";
+"Hide details" = "Details ausblenden";
+"Hide personal information" = "Persönliche Informationen ausblenden";
+"Historical tracking" = "Historische Verfolgung";
+"How often CodexBar polls providers in the background." = "Wie oft fragt CodexBar Anbieter im Hintergrund ab?";
+"Inactive" = "Inaktiv";
+"Install CLI" = "CLI installieren";
+"Install the Claude CLI (npm i -g @anthropic-ai/claude-code) and try again." = "Installieren Sie die Claude-CLI (npm i -g @anthropic-ai/claude-code) und versuchen Sie es erneut.";
+"Install the Codex CLI (npm i -g @openai/codex) and try again." = "Installieren Sie die Codex-CLI (npm i -g @openai/codex) und versuchen Sie es erneut.";
+"Install the Gemini CLI (npm i -g @google/gemini-cli) and try again." = "Installieren Sie die Gemini-CLI (npm i -g @google/gemini-cli) und versuchen Sie es erneut.";
+"JetBrains AI is ready" = "JetBrains AI ist bereit";
+"JetBrains IDE" = "JetBrains-IDE";
+"Keep CLI sessions alive" = "Halten Sie CLI-Sitzungen am Leben";
+"Keyboard shortcut" = "Tastenkombination";
+"Keychain access" = "Schlüsselbundzugriff";
+"Keychain prompt policy" = "Richtlinie für Schlüsselbund-Eingabeaufforderungen";
+"Last \\(name) fetch failed:" = "Der letzte Abruf von \\\\(name) ist fehlgeschlagen:";
+"Last \\(self.store.metadata(for: self.provider).displayName) fetch failed:" = "Letzter Abruf von \\\\(self.store.metadata(for: self.provider).displayName) ist fehlgeschlagen:";
+"Last attempt" = "Letzter Versuch";
+"Link" = "Link";
+"Loading animations" = "Animationen werden geladen";
+"Loading…" = "Laden…";
+"Local" = "Lokal";
+"Logging" = "Protokollierung";
+"Login failed" = "Fehler bei der Anmeldung";
+"Login shell PATH (startup capture)" = "Login-Shell-PATH (Starterfassung)";
+"Login timed out" = "Zeitüberschreitung bei der Anmeldung";
+"MCP details" = "MCP-Details";
+"Managed Codex accounts unavailable" = "Verwaltete Codex-Konten nicht verfügbar";
+"Managed account storage is unreadable. Live account access is still available, " = "Der verwaltete Kontospeicher ist nicht lesbar. Der Live-Kontozugriff ist weiterhin verfügbar.";
+"Manual" = "Handbuch";
+"May your tokens never run out—keep agent limits in view." = "Mögen Ihre Token nie ausgehen – behalten Sie die Agentenlimits im Blick.";
+"Menu bar" = "Menüleiste";
+"Menu bar auto-shows the provider closest to its rate limit." = "In der Menüleiste wird automatisch der Anbieter angezeigt, der seinem Tariflimit am nächsten kommt.";
+"Menu bar metric" = "Menüleistenmetrik";
+"Menu bar shows percent" = "Die Menüleiste zeigt Prozent an";
+"Menu content" = "Menüinhalt";
+"Merge Icons" = "Symbole zusammenführen";
+"Never prompt" = "Niemals auffordern";
+"No" = "NEIN";
+"No Codex accounts detected yet." = "Es wurden noch keine Codex-Konten erkannt.";
+"No JetBrains IDE detected" = "Keine JetBrains-IDE erkannt";
+"No cost history data." = "Keine Daten zur Kostenhistorie.";
+"No data available" = "Keine Daten verfügbar";
+"No data yet" = "Noch keine Daten";
+"No enabled providers available for Overview." = "Für die Übersicht sind keine aktivierten Anbieter verfügbar.";
+"No providers selected" = "Keine Anbieter ausgewählt";
+"No token accounts yet." = "Noch keine Token-Konten.";
+"No usage breakdown data." = "Keine Nutzungsaufschlüsselungsdaten.";
+"None" = "Keiner";
+"Notifications" = "Benachrichtigungen";
+"Notifies when the 5-hour session quota hits 0% and when it becomes " = "Benachrichtigt, wenn das 5-Stunden-Sitzungskontingent 0 % erreicht und wenn dies der Fall ist";
+"OK" = "OK";
+"Obscure email addresses in the menu bar and menu UI." = "Verdecken Sie E-Mail-Adressen in der Menüleiste und der Menü-Benutzeroberfläche.";
+"Off" = "Aus";
+"Offline" = "Offline";
+"On" = "An";
+"Online" = "Online";
+"Only on user action" = "Nur bei Benutzeraktion";
+"Open" = "Offen";
+"Open API Keys" = "Offene API-Schlüssel";
+"Open Amp Settings" = "Öffnen Sie die Verstärkereinstellungen";
+"Open Antigravity to sign in, then refresh CodexBar." = "Öffnen Sie Antigravity, um sich anzumelden, und aktualisieren Sie dann CodexBar.";
+"Open Browser" = "Öffnen Sie den Browser";
+"Open Coding Plan" = "Codierungsplan öffnen";
+"Open Console" = "Öffnen Sie die Konsole";
+"Open Dashboard" = "Öffnen Sie das Dashboard";
+"Open Mistral Admin" = "Öffnen Sie Mistral Admin";
+"Open Menu Bar Settings" = "Öffnen Sie die Menüleisteneinstellungen";
+"Open Ollama Settings" = "Öffnen Sie die Ollama-Einstellungen";
+"Open Terminal" = "Öffnen Sie das Terminal";
+"Open Usage Page" = "Öffnen Sie die Nutzungsseite";
+"Open Warp API Key Guide" = "Öffnen Sie den Warp-API-Schlüsselleitfaden";
+"Open menu" = "Menü öffnen";
+"Open token file" = "Tokendatei öffnen";
+"OpenAI cookies" = "OpenAI-Cookies";
+"OpenAI web extras" = "OpenAI-Web-Extras";
+"Option A" = "Option A";
+"Option B" = "Option B";
+"Optional override if workspace lookup fails." = "Optionale Überschreibung, wenn die Arbeitsbereichssuche fehlschlägt.";
+"Options" = "Optionen";
+"Override auto-detection with a custom IDE base path" = "Überschreiben Sie die automatische Erkennung mit einem benutzerdefinierten IDE-Basispfad";
+"Overview" = "Überblick";
+"Overview rows always follow provider order." = "Übersichtszeilen folgen immer der Anbieterreihenfolge.";
+"Overview tab providers" = "Anbieter von Übersichtsregisterkarten";
+"Paste API key…" = "API-Schlüssel einfügen…";
+"Paste API token…" = "API-Token einfügen…";
+"Paste key…" = "Schlüssel einfügen…";
+"Paste sessionKey or OAuth token…" = "SessionKey oder OAuth-Token einfügen…";
+"Paste the Cookie header from a request to admin.mistral.ai. " = "Fügen Sie den Cookie-Header aus einer Anfrage in admin.mistral.ai ein.";
+"Paste token…" = "Token einfügen…";
+"Personal" = "Persönlich";
+"Picker" = "Auswahl";
+"Picker subtitle" = "Picker-Untertitel";
+"Placeholder" = "Platzhalter";
+"Plan" = "Planen";
+"Play full-screen confetti when weekly usage resets." = "Spielen Sie Konfetti im Vollbildmodus ab, wenn die wöchentliche Nutzung zurückgesetzt wird.";
+"Polls OpenAI/Claude status pages and Google Workspace for " = "Fragt OpenAI/Claude-Statusseiten und Google Workspace ab";
+"Prevents any Keychain access while enabled." = "Verhindert jeglichen Zugriff auf den Schlüsselbund, solange diese Option aktiviert ist.";
+"Primary (API key limit)" = "Primär (API-Schlüssellimit)";
+"Primary (\\(label))" = "Primär (\\\\(label))";
+"Primary (\\(metadata.sessionLabel))" = "Primär (\\\\(metadata.sessionLabel))";
+"Probe logs" = "Sondenprotokolle";
+"Progress bars fill as you consume quota (instead of showing remaining)." = "Fortschrittsbalken füllen sich, wenn Sie das Kontingent verbrauchen (anstatt die verbleibende Menge anzuzeigen).";
+"Provider" = "Anbieter";
+"Providers" = "Anbieter";
+"Quit CodexBar" = "CodexBar beenden";
+"Random (default)" = "Zufällig (Standard)";
+"Reads local usage logs. Shows today + last 30 days cost in the menu." = "Liest lokale Nutzungsprotokolle. Zeigt heute + das ausgewählte Verlaufsfenster im Menü an.";
+"Refresh" = "Aktualisieren";
+"Refresh cadence" = "Trittfrequenz aktualisieren";
+"Remote" = "Remote";
+"Remove" = "Entfernen";
+"Remove Codex account?" = "Codex-Konto entfernen?";
+"Remove \\(account.email) from CodexBar? Its managed Codex home will be deleted." = "\\\\(account.email) aus CodexBar entfernen? Das verwaltete Codex-Heim wird gelöscht.";
+"Remove \\(email) from CodexBar? Its managed Codex home will be deleted." = "\\\\(email) aus CodexBar entfernen? Das verwaltete Codex-Heim wird gelöscht.";
+"Remove selected account" = "Ausgewähltes Konto entfernen";
+"Replace critter bars with provider branding icons and a percentage." = "Ersetzen Sie die Leisten durch Anbieter-Branding-Symbole und einen Prozentsatz.";
+"Replay selected animation" = "Ausgewählte Animation erneut abspielen";
+"Requires authentication via GitHub Device Flow." = "Erfordert Authentifizierung über GitHub Device Flow.";
+"Resets: \\(reset)" = "Zurückgesetzt: \\\\(reset)";
+"Rolling five-hour limit" = "Rollierendes Fünf-Stunden-Limit";
+"Search hourly" = "Stündlich suchen";
+"Secondary (\\(label))" = "Sekundär (\\\\(label))";
+"Secondary (\\(metadata.weeklyLabel))" = "Sekundär (\\\\(metadata.weeklyLabel))";
+"Select a provider" = "Wählen Sie einen Anbieter aus";
+"Select the IDE to monitor" = "Wählen Sie die zu überwachende IDE aus";
+"Session quota notifications" = "Benachrichtigungen über Sitzungskontingente";
+"Session tokens" = "Sitzungstoken";
+"Settings" = "Einstellungen";
+"Show Codex Credits and Claude Extra usage sections in the menu." = "Zeigen Sie die Nutzungsabschnitte \"Codex Credits\" und \"Claude Extra\" im Menü an.";
+"Show Debug Settings" = "Debug-Einstellungen anzeigen";
+"Show all token accounts" = "Alle Token-Konten anzeigen";
+"Show cost summary" = "Kostenübersicht anzeigen";
+"Show credits + extra usage" = "Credits + zusätzliche Nutzung anzeigen";
+"Show details" = "Details anzeigen";
+"Show most-used provider" = "Meistgenutzten Anbieter anzeigen";
+"Show provider icons in the switcher (otherwise show a weekly progress line)." = "Anbietersymbole im Umschalter anzeigen (andernfalls eine wöchentliche Fortschrittslinie anzeigen).";
+"Show reset time as clock" = "Reset-Zeit als Uhr anzeigen";
+"Show usage as used" = "Nutzung als verbraucht anzeigen";
+"Sign in via button below" = "Melden Sie sich über die Schaltfläche unten an";
+"Skip teardown between probes (debug-only)." = "Teardown zwischen Probes überspringen (nur Debug).";
+"Stack token accounts in the menu (otherwise show an account switcher bar)." = "Stapeln Sie Token-Konten im Menü (andernfalls wird eine Kontowechselleiste angezeigt).";
+"Start at Login" = "Beginnen Sie mit der Anmeldung";
+"Status" = "Status";
+"Store Claude sessionKey cookies or OAuth access tokens." = "Speichern Sie Claude-SessionKey-Cookies oder OAuth-Zugriffstoken.";
+"Store multiple Abacus AI Cookie headers." = "Speichern Sie mehrere Abacus AI Cookie-Header.";
+"Store multiple Augment Cookie headers." = "Speichern Sie mehrere Augment-Cookie-Header.";
+"Store multiple Cursor Cookie headers." = "Speichern Sie mehrere Cursor-Cookie-Header.";
+"Store multiple Factory Cookie headers." = "Speichern Sie mehrere Factory-Cookie-Header.";
+"Store multiple MiniMax Cookie headers." = "Speichern Sie mehrere MiniMax-Cookie-Header.";
+"Store multiple Mistral Cookie headers." = "Speichern Sie mehrere Mistral-Cookie-Header.";
+"Store multiple Ollama Cookie headers." = "Speichern Sie mehrere Ollama-Cookie-Header.";
+"Store multiple OpenCode Cookie headers." = "Speichern Sie mehrere OpenCode-Cookie-Header.";
+"Store multiple OpenCode Go Cookie headers." = "Speichern Sie mehrere OpenCode Go-Cookie-Header.";
+"Stored in the CodexBar config file." = "Wird in der CodexBar-Konfigurationsdatei gespeichert.";
+"Stored in ~/.codexbar/config.json. " = "Gespeichert in ~/.codexbar/config.json.";
+"Stored in ~/.codexbar/config.json. Generate one at kimi-k2.ai." = "Gespeichert in ~/.codexbar/config.json. Generieren Sie eines unter kimi-k2.ai.";
+"Stored in ~/.codexbar/config.json. Paste the key from the Synthetic dashboard." = "Gespeichert in ~/.codexbar/config.json. Fügen Sie den Schlüssel aus dem Synthetic-Dashboard ein.";
+"Stored in ~/.codexbar/config.json. Paste your Coding Plan API key from Model Studio." = "Gespeichert in ~/.codexbar/config.json. Fügen Sie Ihren Coding Plan API-Schlüssel aus Model Studio ein.";
+"Stored in ~/.codexbar/config.json. Paste your MiniMax API key." = "Gespeichert in ~/.codexbar/config.json. Fügen Sie Ihren MiniMax-API-Schlüssel ein.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or " = "Gespeichert in ~/.codexbar/config.json. Sie können auch KILO_API_KEY oder angeben";
+"Stores local Codex usage history (8 weeks) to personalize Pace predictions." = "Speichert den lokalen Codex-Nutzungsverlauf (8 Wochen), um Pace-Vorhersagen zu personalisieren.";
+"Subscription Utilization" = "Abonnementnutzung";
+"Surprise me" = "Überrasche mich";
+"Switcher shows icons" = "Switcher zeigt Symbole an";
+"Symlink CodexBarCLI to /usr/local/bin and /opt/homebrew/bin as codexbar." = "Verknüpfen Sie CodexBarCLI mit /usr/local/bin und /opt/homebrew/bin als Codexbar.";
+"System" = "System";
+"terminal_app_subtitle" = "Terminal für die Aktion „Terminal öffnen“";
+"terminal_app_title" = "Standardterminal";
+"Temporarily shows the loading animation after the next refresh." = "Zeigt nach der nächsten Aktualisierung vorübergehend die Ladeanimation an.";
+"Tertiary (\\(label))" = "Tertiär (\\\\(label))";
+"Tertiary (\\(tertiaryTitle))" = "Tertiär (\\\\(tertiaryTitle))";
+"The default Codex account on this Mac." = "Das Standard-Codex-Konto auf diesem Mac.";
+"Toggle" = "Umschalten";
+"Toggle subtitle" = "Untertitel umschalten";
+"Token" = "Token";
+"Trigger the menu bar menu from anywhere." = "Lösen Sie das Menü der Menüleiste von überall aus aus.";
+"True" = "WAHR";
+"Twitter" = "Twitter";
+"Unsupported" = "Nicht unterstützt";
+"Update Channel" = "Kanal aktualisieren";
+"Updated" = "Aktualisiert";
+"Updates unavailable in this build." = "Updates sind in diesem Build nicht verfügbar.";
+"Usage" = "Verwendung";
+"Usage breakdown" = "Aufschlüsselung der Nutzung";
+"Usage history (30 days)" = "Nutzungsverlauf";
+"Usage source" = "Nutzungsquelle";
+"Use BigModel for the China mainland endpoints (open.bigmodel.cn)." = "Verwenden Sie BigModel für die Endpunkte auf dem chinesischen Festland (open.bigmodel.cn).";
+"Use a single menu bar icon with a provider switcher." = "Verwenden Sie ein einzelnes Menüleistensymbol mit einem Anbieter-Umschalter.";
+"Use international or China mainland console gateways for quota fetches." = "Verwenden Sie für Kontingentabrufe internationale Konsolen-Gateways oder Konsolen-Gateways auf dem chinesischen Festland.";
+"Version" = "Version";
+"Version \\(self.versionString)" = "Version \\(self.versionString)";
+"Version \\(version)" = "Version \\(version)";
+"Version \\(versionString)" = "Version \\(versionString)";
+"Vertex AI Login" = "Vertex AI Login";
+"Wait for the current managed Codex login to finish before adding another account." = "Warten Sie, bis die aktuell verwaltete Codex-Anmeldung abgeschlossen ist, bevor Sie ein weiteres Konto hinzufügen.";
+"Waiting for Authentication..." = "Warten auf Authentifizierung...";
+"Website" = "Webseite";
+"Weekly limit confetti" = "Wöchentliches Konfetti-Limit";
+"Weekly token limit" = "Wöchentliches Token-Limit";
+"Weekly usage" = "Wöchentliche Nutzung";
+"Weekly usage unavailable for this account." = "Die wöchentliche Nutzung ist für dieses Konto nicht verfügbar.";
+"Window: \\(window)" = "Fenster: \\\\(window)";
+"Write logs to \\(self.fileLogPath) for debugging." = "Schreiben Sie Protokolle zum Debuggen nach \\\\(self.fileLogPath).";
+"Yes" = "Ja";
+"\\(detail.modelCode): \\(usage)" = "\\(detail.modelCode): \\(usage)";
+"\\(name): \\(truncated)" = "\\(name): \\(truncated)";
+"\\(name): \\(updated) · 30d \\(cost)" = "\\(name): \\(updated) · 30d \\(cost)";
+"\\(name): fetching…\\(elapsed)" = "\\\\(name): Abrufen…\\\\(elapsed)";
+"\\(name): last attempt \\(when)" = "\\\\(name): letzter Versuch \\\\(when)";
+"\\(name): no data yet" = "\\\\(name): noch keine Daten";
+"\\(name): unsupported" = "\\\\(name): nicht unterstützt";
+"all browsers" = "alle Browser";
+"available again." = "wieder verfügbar.";
+"built_format" = "Gebaut %@";
+"copilot_complete_in_browser" = "Melden Sie sich vollständig in Ihrem Browser an.";
+"copilot_device_code" = "Gerätecode in die Zwischenablage kopiert: %1$@\n\nÜberprüfen unter: %2$@";
+"copilot_device_code_copied" = "Gerätecode kopiert.";
+"copilot_verify_at" = "Überprüfen Sie um %@";
+"copilot_waiting_text" = "Schließen Sie die Anmeldung in Ihrem Browser ab.\nDieses Fenster wird automatisch geschlossen, wenn die Anmeldung abgeschlossen ist.";
+"copilot_window_closes_auto" = "Dieses Fenster wird automatisch geschlossen, wenn die Anmeldung abgeschlossen ist.";
+"cost_status_error" = "%1$@: %2$@";
+"cost_status_fetching" = "%1$@: Abrufen… %2$@";
+"cost_status_last_attempt" = "%1$@: letzter Versuch %2$@";
+"cost_status_no_data" = "%@: noch keine Daten";
+"cost_status_snapshot" = "%1$@: %2$@ · %3$@ %4$@";
+"cost_status_unsupported" = "%@: nicht unterstützt";
+"credits_remaining" = "Credits: %@";
+"cursor_on_demand" = "Auf Anfrage: %@";
+"cursor_on_demand_with_limit" = "Auf Anfrage: %1$@ / %2$@";
+"extra_usage_format" = "Zusätzliche Nutzung: %1$@ / %2$@";
+"jetbrains_detected_generate" = "Erkannt: %@. Verwenden Sie den KI-Assistenten einmal, um Quotendaten zu generieren, und aktualisieren Sie dann CodexBar.";
+"jetbrains_detected_select" = "Erkannt: %@. Wählen Sie in den Einstellungen Ihre bevorzugte IDE aus und aktualisieren Sie dann CodexBar.";
+"last_fetch_failed_with_provider" = "Der letzte Abruf von %@ ist fehlgeschlagen:";
+"last_spend" = "Letzte Ausgabe: %@";
+"mcp_model_usage" = "%1$@: %2$@";
+"mcp_resets" = "Zurückgesetzt: %@";
+"mcp_window" = "Fenster: %@";
+"metric_average" = "Durchschnitt (%1$@ + %2$@)";
+"metric_primary" = "Primär (%@)";
+"metric_secondary" = "Sekundär (%@)";
+"metric_tertiary" = "Tertiärbereich (%@)";
+"multiple_workspaces_found" = "CodexBar hat mehrere Arbeitsbereiche für %@ gefunden. Bitte wählen Sie den Arbeitsbereich aus, den Sie hinzufügen möchten.";
+"ory_session_…=…; csrftoken=…" = "ory_session_…=…; csrftoken=…";
+"overview_choose_providers" = "Wählen Sie bis zu %@ Anbieter aus";
+"remove_account_message" = "%@ aus CodexBar entfernen? Das verwaltete Codex-Heim wird gelöscht.";
+"version_format" = "Version %@";
+"vertex_ai_login_instructions" = "Um die Vertex AI-Nutzung zu verfolgen, authentifizieren Sie sich bei Google Cloud.\n\n1. Öffnen Sie Terminal\n2. Führen Sie Folgendes aus: gcloud auth application-default login\n3. Befolgen Sie die Anweisungen des Browsers, um sich anzumelden\n4. Legen Sie Ihr Projekt fest: gcloud config set project PROJECT_ID\n\nTerminal jetzt öffnen?";
+"workspaceID is set but only opencode, opencodego, and deepgram support workspaceID." = "Die Arbeitsbereichs-ID ist festgelegt, aber nur Opencode, Opencodego und Deepgram unterstützen die Arbeitsbereichs-ID.";
+"© 2026 Peter Steinberger. MIT License." = "© 2026 Peter Steinberger. MIT-Lizenz.";
+
+/* General Pane */
+"section_system" = "System";
+"section_usage" = "Nutzung";
+"section_automation" = "Automatisierung";
+"language_title" = "Sprache";
+"language_subtitle" = "Anzeigesprache wechseln. Ein App-Neustart wird empfohlen.";
+"language_system" = "System";
+"language_english" = "Englisch";
+"language_spanish" = "Español";
+"language_catalan" = "Català";
+"language_chinese_simplified" = "简体中文";
+"language_chinese_traditional" = "繁體中文";
+"language_portuguese_brazilian" = "Português (Brasil)";
+"language_german" = "Deutsch";
+"language_japanese" = "Japanisch";
+"language_swedish" = "Svenska";
+"language_dutch" = "Niederländisch";
+"language_french" = "Französisch";
+"language_ukrainian" = "Ukrainisch";
+"language_vietnamese" = "Vietnamesisch";
+"language_korean" = "Koreanisch";
+"language_turkish" = "Türkçe";
+"language_italian" = "Italiano";
+"language_indonesian" = "Indonesisch";
+"language_polish" = "Polnisch";
+"start_at_login_title" = "Beim Login starten";
+"start_at_login_subtitle" = "Startet CodexBar automatisch, wenn dein Mac hochfährt.";
+"show_cost_summary" = "Kostenübersicht anzeigen";
+"show_cost_summary_subtitle" = "Liest lokale Nutzungsprotokolle. Zeigt heute + das gewählte Verlaufsfenster im Menü.";
+"cost_history_days_title" = "Verlaufsfenster: %d Tage";
+"cost_auto_refresh_info" = "Auto-Aktualisierung: stündlich · Timeout: 10 Min.";
+"refresh_cadence_title" = "Aktualisierungsintervall";
+"refresh_cadence_subtitle" = "Wie oft CodexBar Anbieter im Hintergrund abfragt.";
+"manual_refresh_hint" = "Auto-Aktualisierung ist aus; nutze im Menü den Befehl „Aktualisieren“.";
+"check_provider_status_title" = "Anbieterstatus prüfen";
+"check_provider_status_subtitle" = "Prüft OpenAI/Claude-Statusseiten und Google Workspace für Gemini/Antigravity und zeigt Vorfälle in Icon und Menü.";
+"session_quota_notifications_title" = "Sitzungs-Quota-Benachrichtigungen";
+"session_quota_notifications_subtitle" = "Benachrichtigt, wenn das 5-Stunden-Sitzungslimit 0 % erreicht und wenn es wieder verfügbar ist.";
+"quota_warning_notifications_title" = "Quota-Warnungen";
+"quota_warning_notifications_subtitle" = "Warnt, wenn verbleibende Sitzungs- oder Wochenquote die konfigurierten Schwellenwerte unterschreitet.";
+"quota_warnings_title" = "Kontingentwarnungen";
+"quota_warning_session" = "Sitzung";
+"quota_warning_session_capitalized" = "Sitzung";
+"quota_warning_weekly" = "wöchentlich";
+"quota_warning_weekly_capitalized" = "Wöchentlich";
+"quota_warning_notification_title" = "%1$@ %2$@ Kontingent niedrig";
+"quota_warning_notification_body" = "%1$@ übrig. Reached your %2$d%% %3$@ warning threshold.";
+"quota_warning_notification_body_with_account" = "Konto %1$@. %2$@ übrig. Ihr Warnschwellenwert von %3$d%% %4$@ wurde erreicht.";
+"session_depleted_notification_title" = "%@ Sitzung erschöpft";
+"session_depleted_notification_body" = "0 % übrig. Werde benachrichtigen, wenn es wieder verfügbar ist.";
+"session_restored_notification_title" = "%@ Sitzung wiederhergestellt";
+"session_restored_notification_body" = "Das Sitzungskontingent ist wieder verfügbar.";
+"quota_warning_warn_at" = "Warnen Sie vor";
+"quota_warning_global_threshold_subtitle" = "Verbleibende Prozentsätze für Sitzungs- und Wochenfenster, es sei denn, ein Anbieter überschreibt sie.";
+"quota_warning_sound" = "Benachrichtigungston abspielen";
+"quota_warning_provider_inherits" = "Verwendet die globalen Einstellungen für Kontingentwarnungen, es sei denn, hier wird ein Fenster angepasst.";
+"quota_warning_customize_thresholds" = "Passen Sie die Schwellenwerte für %@ an";
+"quota_warning_enable_warnings" = "Aktivieren Sie %@-Warnungen";
+"quota_warning_window_warn_at" = "%@ warnen bei";
+"quota_warning_off" = "Aus";
+"quota_warning_inherited" = "Geerbt: %@";
+"quota_warning_depleted_only" = "nur erschöpft";
+"quota_warning_upper" = "Obere";
+"quota_warning_lower" = "Untere";
+"apply" = "Anwenden";
+"quit_app" = "CodexBar beenden";
+
+/* Tab titles */
+"tab_general" = "Allgemein";
+"tab_providers" = "Anbieter";
+"tab_display" = "Anzeige";
+"tab_advanced" = "Fortschrittlich";
+"tab_about" = "Um";
+"tab_debug" = "Debuggen";
+
+/* Providers Pane */
+"select_a_provider" = "Wählen Sie einen Anbieter aus";
+"cancel" = "Stornieren";
+"last_fetch_failed" = "Der letzte Abruf ist fehlgeschlagen";
+"usage_not_fetched_yet" = "Nutzung noch nicht abgerufen";
+"managed_account_storage_unreadable" = "Der verwaltete Kontospeicher ist nicht lesbar. Der Live-Kontozugriff ist weiterhin verfügbar, die verwalteten Aktionen \"Hinzufügen\", \"Erneute Authentifizierung\" und \"Entfernen\" sind jedoch deaktiviert, bis der Store wiederhergestellt werden kann.";
+"remove_codex_account_title" = "Codex-Konto entfernen?";
+"remove" = "Entfernen";
+"managed_login_already_running" = "Eine verwaltete Codex-Anmeldung läuft bereits. Warten Sie, bis der Vorgang abgeschlossen ist, bevor Sie ein weiteres Konto hinzufügen oder erneut authentifizieren.";
+"managed_login_failed" = "Die Anmeldung bei verwaltetem Codex wurde nicht abgeschlossen. Stellen Sie sicher, dass \"codex --version\" im Terminal funktioniert. Wenn macOS blockiert oder \"Codex\" in den Papierkorb verschoben hat, entfernen Sie veraltete doppelte Installationen, führen Sie \"npm install -g --include=optional @openai/codex@latest\" aus und versuchen Sie es dann erneut.";
+"codex_login_output" = "Codex-Login-Ausgabe:";
+"managed_login_missing_email" = "Codex-Anmeldung abgeschlossen, aber keine Konto-E-Mail-Adresse verfügbar. Versuchen Sie es erneut, nachdem Sie sich vergewissert haben, dass das Konto vollständig angemeldet ist.";
+"login_success_notification_title" = "%@ Anmeldung erfolgreich";
+"login_success_notification_body" = "Sie können zur App zurückkehren; Authentifizierung abgeschlossen.";
+"workspace_selection_cancelled" = "CodexBar hat mehrere Arbeitsbereiche gefunden, es wurde jedoch kein Arbeitsbereich ausgewählt.";
+"unsafe_managed_home" = "CodexBar weigerte sich, einen unerwarteten verwalteten Home-Pfad zu ändern: %@";
+"menu_bar_metric_title" = "Menüleistenmetrik";
+"menu_bar_metric_subtitle" = "Wählen Sie aus, welches Fenster den Prozentwert der Menüleiste steuert.";
+"menu_bar_metric_subtitle_deepseek" = "Zeigt das DeepSeek-Guthaben in der Menüleiste an.";
+"menu_bar_metric_subtitle_moonshot" = "Zeigt das Moonshot-/Kimi-API-Guthaben in der Menüleiste an.";
+"menu_bar_metric_subtitle_mistral" = "Zeigt die Mistral-API-Ausgaben des aktuellen Monats in der Menüleiste an.";
+"menu_bar_metric_subtitle_kimik2" = "Zeigt Kimi K2 API-Schlüssel-Credits in der Menüleiste an.";
+"automatic" = "Automatisch";
+"primary_api_key_limit" = "Primär (API-Schlüssellimit)";
+
+/* Display Pane */
+"section_menu_bar" = "Menüleiste";
+"merge_icons_title" = "Symbole zusammenführen";
+"merge_icons_subtitle" = "Verwenden Sie ein einzelnes Menüleistensymbol mit einem Anbieter-Umschalter.";
+"switcher_shows_icons_title" = "Switcher zeigt Symbole an";
+"switcher_shows_icons_subtitle" = "Anbietersymbole im Umschalter anzeigen (andernfalls eine wöchentliche Fortschrittslinie anzeigen).";
+"show_most_used_provider_title" = "Meistgenutzten Anbieter anzeigen";
+"show_most_used_provider_subtitle" = "In der Menüleiste wird automatisch der Anbieter angezeigt, der seinem Tariflimit am nächsten kommt.";
+"menu_bar_shows_percent_title" = "Die Menüleiste zeigt Prozent an";
+"menu_bar_shows_percent_subtitle" = "Ersetzen Sie die Leisten durch Anbieter-Branding-Symbole und einen Prozentsatz.";
+"hide_critters_title" = "Kreaturen ausblenden";
+"hide_critters_subtitle" = "Schlichte Messleisten ohne Gesicht und Verzierungen anzeigen.";
+"display_mode_title" = "Anzeigemodus";
+"display_mode_subtitle" = "Wählen Sie aus, was in der Menüleiste angezeigt werden soll (Pace zeigt die Nutzung im Vergleich zur erwarteten).";
+"section_menu_content" = "Menüinhalt";
+"show_usage_as_used_title" = "Nutzung als verbraucht anzeigen";
+"show_usage_as_used_subtitle" = "Fortschrittsbalken füllen sich, wenn Sie das Kontingent verbrauchen (anstatt die verbleibende Menge anzuzeigen).";
+"show_quota_warning_markers_title" = "Quotenwarnmarkierungen anzeigen";
+"show_quota_warning_markers_subtitle" = "Zeichnen Sie Schwellenwertmarkierungen auf Nutzungsbalken, wenn Kontingentwarnungen konfiguriert sind.";
+"weekly_progress_work_days_title" = "Wöchentliche Fortschrittsarbeitstage";
+"weekly_progress_work_days_subtitle" = "Legt Arbeitstage für Markierungen in wöchentlichen Nutzungsbalken und Tempo-Berechnungen fest.";
+"show_reset_time_as_clock_title" = "Reset-Zeit als Uhr anzeigen";
+"show_reset_time_as_clock_subtitle" = "Anzeige der Rücksetzzeiten als absolute Uhrwerte statt als Countdown.";
+"show_provider_changelog_links_title" = "Links zum Änderungsprotokoll des Anbieters anzeigen";
+"show_provider_changelog_links_subtitle" = "Fügt dem Menü Versionshinweise-Links für unterstützte CLI-gestützte Anbieter hinzu.";
+"show_credits_extra_usage_title" = "Credits + zusätzliche Nutzung anzeigen";
+"show_credits_extra_usage_subtitle" = "Zeigen Sie die Nutzungsabschnitte \"Codex Credits\" und \"Claude Extra\" im Menü an.";
+"show_all_token_accounts_title" = "Alle Token-Konten anzeigen";
+"show_all_token_accounts_subtitle" = "Stapeln Sie Token-Konten im Menü (andernfalls wird eine Kontowechselleiste angezeigt).";
+"multi_account_layout_title" = "Layout für mehrere Konten";
+"multi_account_layout_subtitle" = "Wählen Sie segmentierte Kontoumschaltung oder gestapelte Kontokarten.";
+"multi_account_layout_segmented" = "Segmentiert";
+"multi_account_layout_stacked" = "Gestapelt";
+"overview_tab_providers_title" = "Anbieter von Übersichtsregisterkarten";
+"configure" = "Konfigurieren…";
+"overview_enable_merge_icons_hint" = "Aktivieren Sie \"Symbole zusammenführen\", um Anbieter für die Registerkarte \"Übersicht\" zu konfigurieren.";
+"overview_no_providers_hint" = "Für die Übersicht sind keine aktivierten Anbieter verfügbar.";
+"overview_rows_follow_order" = "Übersichtszeilen folgen immer der Anbieterreihenfolge.";
+"overview_no_providers_selected" = "Keine Anbieter ausgewählt";
+
+/* Advanced Pane */
+"section_keyboard_shortcut" = "Tastenkombination";
+"open_menu_shortcut_title" = "Menü öffnen";
+"open_menu_shortcut_subtitle" = "Lösen Sie das Menü der Menüleiste von überall aus aus.";
+"install_cli" = "CLI installieren";
+"install_cli_subtitle" = "Verknüpfen Sie CodexBarCLI mit /usr/local/bin und /opt/homebrew/bin als Codexbar.";
+"cli_not_found" = "CodexBarCLI wurde im App-Bundle nicht gefunden.";
+"no_writable_bin_dirs" = "Keine beschreibbaren Bin-Verzeichnisse gefunden.";
+"show_debug_settings_title" = "Debug-Einstellungen anzeigen";
+"show_debug_settings_subtitle" = "Stellen Sie Tools zur Fehlerbehebung auf der Registerkarte \"Debug\" bereit.";
+"surprise_me_title" = "Überrasche mich";
+"surprise_me_subtitle" = "Prüfen Sie, ob Sie möchten, dass Ihre Agenten dort oben Spaß haben.";
+"weekly_limit_confetti_title" = "Wöchentliches Konfetti-Limit";
+"weekly_limit_confetti_subtitle" = "Spielen Sie Konfetti im Vollbildmodus ab, wenn die wöchentliche Nutzung zurückgesetzt wird.";
+"hide_personal_info_title" = "Persönliche Informationen ausblenden";
+"hide_personal_info_subtitle" = "Verdecken Sie E-Mail-Adressen in der Menüleiste und der Menü-Benutzeroberfläche.";
+"show_provider_storage_usage_title" = "Speichernutzung des Anbieters anzeigen";
+"show_provider_storage_usage_subtitle" = "Zeigen Sie die lokale Festplattennutzung in Menüs an. Scannt bekannte anbietereigene Pfade im Hintergrund.";
+"section_keychain_access" = "Schlüsselbundzugriff";
+"keychain_access_caption" = "Deaktivieren Sie alle Lese- und Schreibvorgänge im Schlüsselbund. Verwenden Sie diese Option, wenn macOS weiterhin nach \"Chrome/Brave/Edge Safe Storage\" fragt, auch nachdem Sie auf \"Immer zulassen\" geklickt haben. Der Browser-Cookie-Import ist nicht verfügbar, solange er aktiviert ist. Fügen Sie Cookie-Header manuell in Provider ein. Claude/Codex OAuth über die CLI funktioniert weiterhin.";
+"disable_keychain_access_title" = "Deaktivieren Sie den Schlüsselbundzugriff";
+"disable_keychain_access_subtitle" = "Verhindert jeglichen Zugriff auf den Schlüsselbund, solange diese Option aktiviert ist.";
+
+/* About Pane */
+"about_tagline" = "Mögen Ihre Token nie ausgehen – behalten Sie die Agentenlimits im Blick.";
+"link_github" = "GitHub";
+"link_website" = "Webseite";
+"link_twitter" = "Twitter";
+"link_email" = "E-Mail";
+"check_updates_auto" = "Suchen Sie automatisch nach Updates";
+"update_channel" = "Kanal aktualisieren";
+"check_for_updates" = "Nach Updates suchen…";
+"updates_unavailable" = "Updates sind in diesem Build nicht verfügbar.";
+"copyright" = "© 2026 Peter Steinberger. MIT-Lizenz.";
+
+/* Debug Pane */
+"section_logging" = "Protokollierung";
+"enable_file_logging" = "Aktivieren Sie die Dateiprotokollierung";
+"enable_file_logging_subtitle" = "Schreiben Sie Protokolle zum Debuggen in %@.";
+"verbosity_title" = "Ausführlichkeit";
+"verbosity_subtitle" = "Steuert, wie viele Details protokolliert werden.";
+"open_log_file" = "Protokolldatei öffnen";
+"force_animation_next_refresh" = "Animation bei der nächsten Aktualisierung erzwingen";
+"force_animation_next_refresh_subtitle" = "Zeigt nach der nächsten Aktualisierung vorübergehend die Ladeanimation an.";
+"section_loading_animations" = "Animationen werden geladen";
+"loading_animations_caption" = "Wählen Sie ein Muster aus und spielen Sie es in der Menüleiste ab. \\\"Random\\\" behält das bestehende Verhalten bei.";
+"animation_random_default" = "Zufällig (Standard)";
+"replay_selected_animation" = "Ausgewählte Animation erneut abspielen";
+"blink_now" = "Blinzeln Sie jetzt";
+"section_probe_logs" = "Sondenprotokolle";
+"probe_logs_caption" = "Rufen Sie die neueste Probe-Ausgabe zum Debuggen ab. Beim Kopieren bleibt der vollständige Text erhalten.";
+"fetch_log" = "Protokoll abrufen";
+"copy" = "Kopie";
+"save_to_file" = "In Datei speichern";
+"load_parse_dump" = "Parse-Dump laden";
+"rerun_provider_autodetect" = "Führen Sie die automatische Anbietererkennung erneut aus";
+"loading" = "Laden…";
+"no_log_yet_fetch" = "Noch kein Protokoll. Zum Laden abrufen.";
+"section_fetch_strategy" = "Strategieversuche abrufen";
+"fetch_strategy_caption" = "Entscheidungen und Fehler der letzten Abrufpipeline für einen Anbieter.";
+"section_openai_cookies" = "OpenAI-Cookies";
+"openai_cookies_caption" = "Cookie-Import + WebKit-Scrape-Protokolle vom letzten OpenAI-Cookie-Versuch.";
+"no_log_yet" = "Noch kein Protokoll. Aktualisieren Sie OpenAI-Cookies unter Anbieter → Codex, um einen Import auszuführen.";
+"section_caches" = "Caches";
+"caches_caption" = "Löschen Sie zwischengespeicherte Kosten-Scan-Ergebnisse oder Browser-Cookie-Caches.";
+"clear_cookie_cache" = "Cookie-Cache leeren";
+"clear_cost_cache" = "Kostencache löschen";
+"section_notifications" = "Benachrichtigungen";
+"notifications_caption" = "Testbenachrichtigungen für das 5-Stunden-Sitzungsfenster auslösen (erschöpft/wiederhergestellt).";
+"post_depleted" = "Beitrag erschöpft";
+"post_restored" = "Beitrag wiederhergestellt";
+"section_cli_sessions" = "CLI-Sitzungen";
+"cli_sessions_caption" = "Halten Sie Codex/Claude-CLI-Sitzungen nach einer Untersuchung am Leben. Die Standardeinstellung wird beendet, sobald Daten erfasst wurden.";
+"keep_cli_sessions_alive" = "Halten Sie CLI-Sitzungen am Leben";
+"keep_cli_sessions_alive_subtitle" = "Teardown zwischen Probes überspringen (nur Debug).";
+"reset_cli_sessions" = "CLI-Sitzungen zurücksetzen";
+"section_error_simulation" = "Fehlersimulation";
+"error_simulation_caption" = "Fügen Sie zum Testen des Layouts eine gefälschte Fehlermeldung in die Menükarte ein.";
+"set_menu_error" = "Menüfehler einstellen";
+"clear_menu_error" = "Menüfehler löschen";
+"set_cost_error" = "Kostenfehler festlegen";
+"clear_cost_error" = "Klarer Kostenfehler";
+"section_cli_paths" = "CLI-Pfade";
+"cli_paths_caption" = "Codex-Binär- und PATH-Ebenen behoben; Start-Login-PATH-Erfassung (kurze Zeitüberschreitung).";
+"codex_binary" = "Codex-Binärdatei";
+"claude_binary" = "Claude binär";
+"effective_path" = "Effektiver WEG";
+"unavailable" = "Nicht verfügbar";
+"login_shell_path" = "Login-Shell-PATH (Starterfassung)";
+"cleared" = "Gelöscht.";
+"no_fetch_attempts" = "Noch keine Abrufversuche.";
+"macOS Tahoe can block menu bar apps in System Settings → Menu Bar → Allow in the Menu Bar. CodexBar is running, but macOS may be hiding its icon. Open Menu Bar settings and turn CodexBar on." = "macOS Tahoe kann Menüleisten-Apps unter Systemeinstellungen → Menüleiste → Zulassen in der Menüleiste blockieren. CodexBar wird ausgeführt, aber macOS verbirgt möglicherweise sein Symbol. Öffnen Sie die Menüleisteneinstellungen und aktivieren Sie CodexBar.";
+
+/* Metric preferences */
+"metric_pref_automatic" = "Automatisch";
+"metric_pref_primary" = "Primär";
+"metric_pref_secondary" = "Sekundär";
+"metric_pref_tertiary" = "Tertiär";
+"metric_pref_extra_usage" = "Zusätzliche Nutzung";
+"metric_pref_average" = "Durchschnitt";
+"metric_mistral_payg" = "Pay-as-you-go";
+"metric_mistral_monthly_plan" = "Monthly Plan";
+
+/* Display modes */
+"display_mode_percent" = "Prozent";
+"display_mode_pace" = "Tempo";
+"display_mode_both" = "Beide";
+"display_mode_reset_time" = "Zurücksetzungszeit";
+"display_mode_percent_desc" = "Verbleibenden/verwendeten Prozentsatz anzeigen (z. B. 45 %)";
+"display_mode_pace_desc" = "Tempoanzeige anzeigen (z. B. +5%)";
+"display_mode_both_desc" = "Zeigen Sie sowohl Prozentsatz als auch Tempo an (z. B. 45 % · +5 %)";
+"display_mode_reset_time_desc" = "Zurücksetzungszeit der ausgewählten Metrik anzeigen (z. B. ↻ 15:56)";
+
+/* Provider status */
+"status_operational" = "Betriebsbereit";
+"status_partial_outage" = "Teilweiser Ausfall";
+"status_major_outage" = "Schwerwiegender Ausfall";
+"status_critical_issue" = "Kritisches Problem";
+"status_maintenance" = "Wartung";
+"status_unknown" = "Status unbekannt";
+
+/* Refresh frequency */
+"refresh_manual" = "Handbuch";
+"refresh_1min" = "1 Minute";
+"refresh_2min" = "2 Min";
+"refresh_5min" = "5 Min";
+"refresh_15min" = "15 Min";
+"refresh_30min" = "30 Min";
+
+/* Additional keys */
+"not_found" = "Nicht gefunden";
+
+/* Cost estimation */
+"cost_header_estimated" = "Kosten (geschätzt)";
+"cost_estimate_hint" = "Schätzung aus lokalen Protokollen · kann von Ihrer Rechnung abweichen";
+"No JetBrains IDE with AI Assistant detected. Install a JetBrains IDE and enable AI Assistant." = "Keine JetBrains-IDE mit AI Assistant erkannt. Installieren Sie eine JetBrains-IDE und aktivieren Sie AI Assistant.";
+"OpenRouter API token not configured. Set OPENROUTER_API_KEY environment variable or configure in Settings." = "OpenRouter-API-Token nicht konfiguriert. Legen Sie die Umgebungsvariable OPENROUTER_API_KEY fest oder konfigurieren Sie sie in den Einstellungen.";
+"z.ai API token not found. Set apiKey in ~/.codexbar/config.json or Z_AI_API_KEY." = "z.ai-API-Token nicht gefunden. Legen Sie apiKey in ~/.codexbar/config.json oder Z_AI_API_KEY fest.";
+"Missing DeepSeek API key." = "Fehlender DeepSeek-API-Schlüssel.";
+"%@ is unavailable in the current environment." = "%@ ist in der aktuellen Umgebung nicht verfügbar.";
+"All Systems Operational" = "Alle Systeme betriebsbereit";
+"Last 30 days" = "Letzte 30 Tage";
+"Last 30 days:" = "Letzte 30 Tage:";
+"This month" = "Diesen Monat";
+"Store multiple OpenAI API keys." = "Speichern Sie mehrere OpenAI-API-Schlüssel.";
+"Admin API key" = "Admin-API-Schlüssel";
+"Open billing" = "Abrechnung öffnen";
+"Google accounts" = "Google-Konten";
+"Store multiple Antigravity Google OAuth accounts for quick switching." = "Speichern Sie mehrere Antigravity Google OAuth-Konten für einen schnellen Wechsel.";
+"Add Google Account" = "Google-Konto hinzufügen";
+"Open Token Plan" = "Offener Token-Plan";
+"Text Generation" = "Textgenerierung";
+"Text to Speech" = "Text-to-Speech";
+"Music Generation" = "Musikgeneration";
+"Image Generation" = "Bilderzeugung";
+"No local data found" = "Keine lokalen Daten gefunden";
+"Credits unavailable; keep Codex running to refresh." = "Credits nicht verfügbar; Lassen Sie Codex zum Aktualisieren laufen.";
+"No available fetch strategy for minimax." = "Für Minimax ist keine Abrufstrategie verfügbar.";
+"No Cursor session found. Please log in to cursor.com in Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX, or Edge Canary. If you use Safari, grant CodexBar Full Disk Access in System Settings ▸ Privacy & Security. You can also sign in to Cursor from the CodexBar menu (Add / switch account)." = "Keine Cursor-Sitzung gefunden. Bitte melden Sie sich bei Cursor.com in Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX oder Edge Canary an. Wenn Sie Safari verwenden, gewähren Sie CodexBar vollständigen Festplattenzugriff unter Systemeinstellungen ▸ Datenschutz und Sicherheit. Sie können sich auch über das CodexBar-Menü (Konto hinzufügen/wechseln) bei Cursor anmelden.";
+"No OpenCode session cookies found in browsers." = "In Browsern wurden keine OpenCode-Sitzungscookies gefunden.";
+"No available fetch strategy for %@." = "Für %@ ist keine Abrufstrategie verfügbar.";
+"Today" = "Heute";
+"Today tokens" = "Heute Token";
+"30d cost" = "30 Tage Kosten";
+"30d tokens" = "30d-Token";
+"Latest tokens" = "Neueste Token";
+"Top model" = "Topmodell";
+"Storage" = "Speicher";
+"Add Account..." = "Konto hinzufügen...";
+"Usage Dashboard" = "Nutzungs-Dashboard";
+"Status Page" = "Statusseite";
+"Settings..." = "Einstellungen...";
+"About CodexBar" = "About CodexBar";
+"Quit" = "Beenden";
+"Last %d day" = "Letzter %d Tag";
+"Last %d days" = "Letzte %d Tage";
+"%@ tokens" = "%@ Token";
+"Latest billing day" = "Letzter Abrechnungstag";
+"Latest billing day (%@)" = "Letzter Abrechnungstag (%@)";
+"%@ left" = "%@ übrig";
+"Resets %@" = "Setzt %@ zurück";
+"Resets in %@" = "Zurückgesetzt in %@";
+"Resets now" = "Wird jetzt zurückgesetzt";
+"reset_tomorrow_format" = "morgen, %@";
+"Lasts until reset" = "Hält bis zum Zurücksetzen an";
+"Updated %@" = "Aktualisiert %@";
+"Updated %@h ago" = "Vor %@h aktualisiert";
+"Updated %@m ago" = "Vor %@m aktualisiert";
+"Updated just now" = "Gerade erst aktualisiert";
+"Projected empty in %@" = "Voraussichtlich leer in %@";
+"Runs out in %@" = "Läuft in %@ aus";
+"Pace: %@" = "Tempo: %@";
+"Pace: %@ · %@" = "Tempo: %@ · %@";
+"%@ · %@" = "%@ · %@";
+"≈ %d%% run-out risk" = "≈ %d%% Auslaufrisiko";
+"%d%% in deficit" = "%d%% im Defizit";
+"%d%% in reserve" = "%d%% in Reserve";
+"usage_percent_suffix_left" = "übrig";
+"usage_percent_suffix_used" = "verbraucht";
+"Store multiple DeepSeek API keys." = "Speichern Sie mehrere DeepSeek-API-Schlüssel.";
+"This week" = "Diese Woche";
+"Week" = "Woche";
+"Month" = "Monat";
+"Models" = "Modelle";
+"24h tokens" = "24-Stunden-Token";
+"Latest hour" = "Letzte Stunde";
+"Peak hour" = "Spitzenstunde";
+"Top method" = "Top-Methode";
+"30d cash" = "30 Tage Bargeld";
+"30d billing history from MiniMax web session" = "30-tägiger Abrechnungsverlauf aus der MiniMax-Websitzung";
+"AWS Cost Explorer billing can lag." = "Die Abrechnung mit AWS Cost Explorer kann verzögert sein.";
+"Rate limit: %d / %@" = "Ratenlimit: %d / %@";
+"Key remaining" = "Schlüssel übrig";
+"No limit set for the API key" = "Für den API-Schlüssel ist kein Limit festgelegt";
+"API key limit unavailable right now" = "Das API-Schlüssellimit ist derzeit nicht verfügbar";
+"This month: %@ tokens" = "Diesen Monat: %@ Token";
+"No utilization data yet." = "Noch keine Nutzungsdaten.";
+"No %@ utilization data yet." = "Noch keine %@-Nutzungsdaten.";
+"%@: %@%% used" = "%@: %@%% verwendet";
+"%dd" = "%dd";
+"today" = "Heute";
+"just now" = "soeben";
+"On pace" = "Auf Tempo";
+"Runs out now" = "Ist jetzt ausverkauft";
+"Projected empty now" = "Voraussichtlich jetzt leer";
+"Switch Account..." = "Konto wechseln...";
+"Update ready, restart now?" = "Update bereit, jetzt neu starten?";
+"Daily" = "Täglich";
+"Hourly Tokens" = "Stündliche Token";
+"No data" = "Keine Daten";
+"No usage breakdown data available." = "Es sind keine Nutzungsaufschlüsselungsdaten verfügbar.";
+
+"Today: %@ · %@ tokens" = "Heute: %@ · %@ Token";
+"Today: %@" = "Heute: %@";
+"Today: %@ tokens" = "Heute: %@ Token";
+"Last 30 days: %@ · %@ tokens" = "Letzte 30 Tage: %@ · %@ Token";
+"Last 30 days: %@" = "Letzte 30 Tage: %@";
+"Est. total (30d): %@" = "Schätzung: Gesamt (30 Tage): %@";
+"Est. total (%@): %@" = "Schätzung: Gesamt (%@): %@";
+"Hover a bar for details" = "Bewegen Sie den Mauszeiger über eine Leiste, um Einzelheiten anzuzeigen";
+"%@: %@ · %@ tokens" = "%@: %@ · %@ Token";
+"No providers selected for Overview." = "Für die Übersicht wurden keine Anbieter ausgewählt.";
+"No overview data available." = "Keine Übersichtsdaten verfügbar.";
+"Auto uses the local IDE API first, then Google OAuth when the IDE is closed." = "Auto verwendet zuerst die lokale IDE-API und dann Google OAuth, wenn die IDE geschlossen wird.";
+"Login with Google" = "Melden Sie sich mit Google an";
+
+/* Popup panels */
+"No usage configured." = "Keine Nutzung konfiguriert.";
+"Quota" = "Kontingent";
+"tokens" = "Token";
+"requests" = "Anfragen";
+"Latest" = "Letzte";
+"Monthly" = "Monatlich";
+"Sonnet" = "Sonett";
+"Overages" = "Überschreitungen";
+"Activity" = "Aktivität";
+"Copied" = "Kopiert";
+"Copy error" = "Kopierfehler";
+"Copy path" = "Pfad kopieren";
+"Extra usage spent" = "Zusätzliche Nutzung aufgewendet";
+"Credits remaining" = "Verbleibende Credits";
+"Using CLI fallback" = "CLI-Fallback verwenden";
+"Balance updates in near-real time (up to 5 min lag)" = "Guthabenaktualisierungen nahezu in Echtzeit (bis zu 5 Minuten Verzögerung)";
+"Daily billing data finalizes at 07:00 UTC" = "Die täglichen Abrechnungsdaten werden um 07:00 UTC finalisiert";
+"%@ of %@ credits left" = "%@ von %@ Credits übrig";
+"%@ of %@ bonus credits left" = "%@ von %@ Bonusguthaben übrig";
+"%@ / %@ (%@ remaining)" = "%@ / %@ (%@ verbleibend)";
+"%@/%@ left" = "%@/%@ übrig";
+"Gemini Flash" = "Gemini Flash";
+"Regenerates %@" = "Regeneriert %@";
+"used after next regen" = "Wird nach der nächsten Regenerierung verwendet";
+"after next regen" = "nach der nächsten Regeneration";
+"Near full" = "Fast voll";
+"Full in ~1 regen" = "Voll in ~1 Regeneration";
+"Full in ~%.0f regens" = "Voll in ~%.0f Regenerationen";
+"Overage usage" = "Übermäßige Nutzung";
+"Overage cost" = "Überschreitungskosten";
+"credits" = "Credits";
+"Zen balance" = "Zen-Balance";
+"API spend" = "API-Ausgaben";
+"Extra usage" = "Zusätzliche Nutzung";
+"Quota usage" = "Kontingentnutzung";
+"Your spend" = "Deine Ausgaben";
+"%.0f%% used" = "%.0f%% verwendet";
+"Usage history (today)" = "Nutzungshistorie (heute)";
+"Usage history (%d days)" = "Nutzungsverlauf (%d Tage)";
+"%d percent remaining" = "%d Prozent verbleibend";
+"Unknown" = "Unbekannt";
+"stale data" = "veraltete Daten";
+"No credits history data." = "Keine Credits-Verlaufsdaten.";
+"No credits history data available." = "Es sind keine Daten zum Kreditverlauf verfügbar.";
+"Credits history chart" = "Diagramm zum Verlauf der Credits";
+"%d days of credits data" = "%d Tage Credits-Daten";
+"Usage breakdown chart" = "Aufschlüsselungsdiagramm zur Nutzung";
+"%d days of usage data across %d services" = "%d Tage Nutzungsdaten für %d Dienste";
+"Cost history chart" = "Kostenverlaufsdiagramm";
+"%d days of cost data" = "%d Tage Kostendaten";
+"Plan utilization chart" = "Planauslastungsdiagramm";
+"%d utilization samples" = "%d Nutzungsbeispiele";
+"Hourly Usage" = "Stündliche Nutzung";
+"Usage remaining" = "Verbleibende Nutzung";
+"Usage used" = "Verbraucht";
+"API key verified. Ollama does not expose Cloud quota limits through the API." = "API-Schlüssel überprüft. Ollama legt über die API keine Cloud-Kontingentgrenzen offen.";
+"Last 30 days: %@ tokens" = "Letzte 30 Tage: %@ Token";
+"7d spend" = "7d ausgeben";
+"30d spend" = "30 Tage ausgeben";
+"Cache read" = "Cache gelesen";
+"Claude Admin API 30 day spend trend" = "30-Tage-Ausgabentrend der Claude Admin API";
+"OpenRouter API key spend trend" = "Trend zu Ausgaben für OpenRouter-API-Schlüssel";
+"z.ai hourly token trend" = "z.ai stündlicher Token-Trend";
+"MiniMax 30 day token usage trend" = "MiniMax 30-Tage-Token-Nutzungstrend";
+"Today cash" = "Heutige Kosten";
+"DeepSeek 30 day token usage trend" = "Trend zur 30-Tage-Token-Nutzung von DeepSeek";
+"cache-hit input" = "Cache-Hit-Eingabe";
+"cache-miss input" = "Cache-Miss-Eingabe";
+"output" = "Ausgabe";
+"Requests" = "Anfragen";
+"Reported by OpenAI Admin API organization usage." = "Gemeldet durch die Nutzung der OpenAI Admin API-Organisation.";
+"Reported by Mistral billing usage." = "Gemeldet durch Mistral-Abrechnungsnutzung.";
+"Google OAuth" = "Google OAuth";
+"Add accounts via GitHub OAuth Device Flow on the selected host." = "Fügen Sie Konten über GitHub OAuth Device Flow auf dem ausgewählten Host hinzu.";
+"Stores each signed-in Google account for quick Antigravity switching. Uses Antigravity.app OAuth when available, or ANTIGRAVITY_OAUTH_CLIENT_ID and ANTIGRAVITY_OAUTH_CLIENT_SECRET as an override." = "Speichert jedes angemeldete Google-Konto für einen schnellen Antigravity-Wechsel. Verwendet Antigravity.app OAuth, sofern verfügbar, oder ANTIGRAVITY_OAUTH_CLIENT_ID und ANTIGRAVITY_OAUTH_CLIENT_SECRET als Überschreibung.";
+"Manual cleanup: past sessions" = "Manuelle Bereinigung: vergangene Sitzungen";
+"Clearing removes past resume, continue, and rewind history." = "Durch das Löschen werden vergangene Fortsetzungs-, Fortsetzungs- und Rückspulverläufe entfernt.";
+"Manual cleanup: file checkpoints" = "Manuelle Bereinigung: Dateiprüfpunkte";
+"Clearing removes checkpoint restore data for previous edits." = "Durch das Löschen werden Prüfpunkt-Wiederherstellungsdaten für frühere Bearbeitungen entfernt.";
+"Manual cleanup: saved plans" = "Manuelle Bereinigung: gespeicherte Pläne";
+"Clearing removes old plan-mode files." = "Durch das Löschen werden alte Planmodusdateien entfernt.";
+"Manual cleanup: debug logs" = "Manuelle Bereinigung: Debug-Protokolle";
+"Clearing removes past debug logs." = "Durch das Löschen werden frühere Debugprotokolle entfernt.";
+"Manual cleanup: attachment cache" = "Manuelle Bereinigung: Anhang-Cache";
+"Clearing removes cached large pastes or attached images." = "Durch das Löschen werden zwischengespeicherte große Einfügungen oder angehängte Bilder entfernt.";
+"Manual cleanup: session metadata" = "Manuelle Bereinigung: Sitzungsmetadaten";
+"Clearing removes per-session environment metadata." = "Durch das Löschen werden Umgebungsmetadaten pro Sitzung entfernt.";
+"Manual cleanup: shell snapshots" = "Manuelle Bereinigung: Shell-Snapshots";
+"Clearing removes leftover runtime shell snapshot files." = "Durch das Löschen werden übrig gebliebene Runtime-Shell-Snapshot-Dateien entfernt.";
+"Manual cleanup: legacy todos" = "Manuelle Bereinigung: Legacy-Aufgaben";
+"Clearing removes legacy per-session task lists." = "Durch das Löschen werden alte Aufgabenlisten pro Sitzung entfernt.";
+"Manual cleanup: sessions" = "Manuelle Bereinigung: Sitzungen";
+"Clearing removes past Codex session history." = "Durch das Löschen wird der Verlauf vergangener Codex-Sitzungen entfernt.";
+"Manual cleanup: archived sessions" = "Manuelle Bereinigung: archivierte Sitzungen";
+"Clearing removes archived Codex session history." = "Beim Löschen wird der archivierte Codex-Sitzungsverlauf entfernt.";
+"Manual cleanup: cache" = "Manuelle Bereinigung: Cache";
+"Clearing removes provider-owned cached data." = "Durch das Löschen werden zwischengespeicherte Daten des Anbieters entfernt.";
+"Manual cleanup: logs" = "Manuelle Bereinigung: Protokolle";
+"Clearing removes local diagnostic logs." = "Durch das Löschen werden lokale Diagnoseprotokolle entfernt.";
+"Manual cleanup: file history" = "Manuelle Bereinigung: Dateiverlauf";
+"Clearing removes local edit checkpoint history." = "Durch das Löschen wird der lokale Bearbeitungsprüfpunktverlauf entfernt.";
+"Manual cleanup: temporary data" = "Manuelle Bereinigung: temporäre Daten";
+"Clearing removes local temporary provider data." = "Durch das Löschen werden lokale temporäre Anbieterdaten entfernt.";
+"Total: %@" = "Gesamt: %@";
+"%d more items" = "%d weitere Artikel";
+"Cleanup ideas" = "Aufräumideen";
+"%d unreadable item(s) skipped" = "%d unlesbare Elemente wurden übersprungen";
+
+"API key limit" = "API-Schlüssellimit";
+"Auth" = "Auth";
+"Auto" = "Auto";
+"Disabled — no recent data" = "Deaktiviert – keine aktuellen Daten";
+"Limits not available" = "Limits nicht verfügbar";
+"No usage yet" = "Noch keine Nutzung";
+"Not fetched yet" = "Noch nicht abgerufen";
+"Refreshing" = "Aktualisiere";
+"Session" = "Sitzung";
+"Source" = "Quelle";
+"State" = "Zustand";
+"Unavailable" = "Nicht verfügbar";
+"Weekly" = "Wöchentlich";
+"not detected" = "nicht erkannt";
+"Estimated from local Codex logs for the selected account." = "Geschätzt aus lokalen Codex-Protokollen für das ausgewählte Konto.";
+"minimax_usage_amount_format" = "Verwendung: %@ / %@";
+"minimax_used_percent_format" = "Verbraucht %@";
+"minimax_service_text_generation" = "Textgenerierung";
+"minimax_service_text_to_speech" = "Text-to-Speech";
+"minimax_service_music_generation" = "Musikgeneration";
+"minimax_service_image_generation" = "Bilderzeugung";
+"minimax_service_lyrics_generation" = "Songtextgenerierung";
+"minimax_service_coding_plan_vlm" = "Codierungsplan VLM";
+"minimax_service_coding_plan_search" = "Suche nach Kodierungsplänen";
+
+/* Additional provider settings and alerts */
+"%@ is waiting for permission" = "%@ wartet auf Erlaubnis";
+"%@ requests" = "%@ Anfragen";
+"%@: %@ credits" = "%@: %@ Credits";
+"30d requests" = "30 Tage Anfragen";
+"4 days" = "4 Tage";
+"5 days" = "5 Tage";
+"7 days" = "7 Tage";
+"API key verifies Ollama Cloud access; cookies still expose quota limits." = "Der API-Schlüssel überprüft den Ollama-Cloud-Zugriff. Cookies unterliegen weiterhin Kontingentgrenzen.";
+"AWS access key ID. Can also be set with AWS_ACCESS_KEY_ID." = "AWS-Zugriffsschlüssel-ID. Kann auch mit AWS_ACCESS_KEY_ID festgelegt werden.";
+"AWS region. Can also be set with AWS_REGION." = "AWS-Region. Kann auch mit AWS_REGION festgelegt werden.";
+"AWS secret access key. Can also be set with AWS_SECRET_ACCESS_KEY." = "Geheimer AWS-Zugriffsschlüssel. Kann auch mit AWS_SECRET_ACCESS_KEY festgelegt werden.";
+"Access key ID" = "Zugriffsschlüssel-ID";
+"Add Account" = "Konto hinzufügen";
+"Adding Account…" = "Konto wird hinzugefügt…";
+"Antigravity login failed" = "Antigravity-Anmeldung fehlgeschlagen";
+"Antigravity login timed out" = "Zeitüberschreitung beim Antigravity-Login";
+"Auth source" = "Authentifizierungsquelle";
+"Automatic imports browser cookies from Xiaomi MiMo." = "Importiert automatisch Browser-Cookies von Xiaomi MiMo.";
+"Automatic imports Windsurf session data from Chromium browser localStorage." = "Importiert Windsurf-Sitzungsdaten automatisch aus dem lokalen Speicher des Chromium-Browsers.";
+"Automatic imports browser cookies from Bailian." = "Automatischer Import von Browser-Cookies von Bailian.";
+"Automatically imports browser cookies." = "Importiert automatisch Browser-Cookies.";
+"Automatically imports browser session cookies." = "Importiert automatisch Browser-Sitzungscookies.";
+"Azure OpenAI deployment name. AZURE_OPENAI_DEPLOYMENT_NAME is also supported." = "Name der Azure OpenAI-Bereitstellung. AZURE_OPENAI_DEPLOYMENT_NAME wird ebenfalls unterstützt.";
+"Azure OpenAI key" = "Azure OpenAI-Schlüssel";
+"Azure OpenAI resource endpoint. AZURE_OPENAI_ENDPOINT is also supported." = "Azure OpenAI-Ressourcenendpunkt. AZURE_OPENAI_ENDPOINT wird ebenfalls unterstützt.";
+"Base URL" = "Basis-URL";
+"Base URL for the LLM-API-Key-Proxy instance." = "Basis-URL für die LLM-API-Key-Proxy-Instanz.";
+"Browser cookies" = "Browser-Cookies";
+"Cap end" = "Kappenende";
+"Cap start" = "Kappenanfang";
+"Capacity End" = "Kapazitätsende";
+"Capacity Start" = "Kapazitätsanfang";
+"Changelog" = "Änderungsprotokoll";
+"Choose the Moonshot/Kimi API host for international or China mainland accounts." = "Wählen Sie den Moonshot/Kimi-API-Host für internationale Konten oder Konten auf dem chinesischen Festland.";
+"CodexBar can't replace a system account that is signed in with an API key only setup." = "CodexBar kann kein Systemkonto ersetzen, das nur mit einem API-Schlüssel angemeldet ist.";
+"CodexBar could not find saved auth for that account. Re-authenticate it and try again." = "CodexBar konnte die gespeicherte Authentifizierung für dieses Konto nicht finden. Authentifizieren Sie es erneut und versuchen Sie es erneut.";
+"CodexBar could not read managed account storage. Recover the store before adding another account." = "CodexBar konnte den verwalteten Kontospeicher nicht lesen. Stellen Sie den Store wieder her, bevor Sie ein weiteres Konto hinzufügen.";
+"CodexBar could not read saved auth for that account. Re-authenticate it and try again." = "CodexBar konnte die gespeicherte Authentifizierung für dieses Konto nicht lesen. Authentifizieren Sie es erneut und versuchen Sie es erneut.";
+"CodexBar could not read the current system account on this Mac." = "CodexBar konnte das aktuelle Systemkonto auf diesem Mac nicht lesen.";
+"CodexBar could not replace the live Codex auth on this Mac." = "CodexBar konnte die Live-Codex-Authentifizierung auf diesem Mac nicht ersetzen.";
+"CodexBar could not safely preserve the current system account before switching." = "CodexBar konnte das aktuelle Systemkonto vor dem Wechsel nicht sicher beibehalten.";
+"CodexBar could not save the current system account before switching." = "CodexBar konnte das aktuelle Systemkonto vor dem Wechsel nicht speichern.";
+"CodexBar could not update managed account storage." = "CodexBar konnte den verwalteten Kontospeicher nicht aktualisieren.";
+"CodexBar found another managed account that already uses the current system account. Resolve the duplicate account before switching." = "CodexBar hat ein anderes verwaltetes Konto gefunden, das bereits das aktuelle Systemkonto verwendet. Lösen Sie das doppelte Konto auf, bevor Sie wechseln.";
+"CodexBar will ask macOS Keychain for “%@” so it can decrypt browser cookies and authenticate your account. Click OK to continue." = "CodexBar fragt den macOS-Schlüsselbund nach \"%@\", damit es Browser-Cookies entschlüsseln und Ihr Konto authentifizieren kann. Klicken Sie auf OK, um fortzufahren.";
+"CodexBar will ask macOS Keychain for the Claude Code OAuth token so it can fetch your Claude usage. Click OK to continue." = "CodexBar fragt den macOS-Schlüsselbund nach dem Claude Code OAuth-Token, damit es Ihre Claude-Nutzung abrufen kann. Klicken Sie auf OK, um fortzufahren.";
+"CodexBar will ask macOS Keychain for your Amp cookie header so it can fetch usage. Click OK to continue." = "CodexBar fragt den macOS-Schlüsselbund nach Ihrem Amp-Cookie-Header, damit er die Nutzung abrufen kann. Klicken Sie auf OK, um fortzufahren.";
+"CodexBar will ask macOS Keychain for your Augment cookie header so it can fetch usage. Click OK to continue." = "CodexBar fragt den macOS-Schlüsselbund nach Ihrem Augment-Cookie-Header, damit er die Nutzung abrufen kann. Klicken Sie auf OK, um fortzufahren.";
+"CodexBar will ask macOS Keychain for your Claude cookie header so it can fetch Claude web usage. Click OK to continue." = "CodexBar fragt den macOS-Schlüsselbund nach Ihrem Claude-Cookie-Header, damit die Claude-Webnutzung abgerufen werden kann. Klicken Sie auf OK, um fortzufahren.";
+"CodexBar will ask macOS Keychain for your Cursor cookie header so it can fetch usage. Click OK to continue." = "CodexBar fragt den macOS-Schlüsselbund nach Ihrem Cursor-Cookie-Header, damit er die Nutzung abrufen kann. Klicken Sie auf OK, um fortzufahren.";
+"CodexBar will ask macOS Keychain for your Factory cookie header so it can fetch usage. Click OK to continue." = "CodexBar fragt den macOS-Schlüsselbund nach Ihrem Factory-Cookie-Header, damit er die Nutzung abrufen kann. Klicken Sie auf OK, um fortzufahren.";
+"CodexBar will ask macOS Keychain for your GitHub Copilot token so it can fetch usage. Click OK to continue." = "CodexBar fragt den macOS-Schlüsselbund nach Ihrem GitHub-Copilot-Token, damit es die Nutzung abrufen kann. Klicken Sie auf OK, um fortzufahren.";
+"CodexBar will ask macOS Keychain for your Kimi K2 API key so it can fetch usage. Click OK to continue." = "CodexBar fragt den macOS-Schlüsselbund nach Ihrem Kimi K2-API-Schlüssel, damit er die Nutzung abrufen kann. Klicken Sie auf OK, um fortzufahren.";
+"CodexBar will ask macOS Keychain for your Kimi auth token so it can fetch usage. Click OK to continue." = "CodexBar fragt den macOS-Schlüsselbund nach Ihrem Kimi-Authentifizierungstoken, damit es die Nutzung abrufen kann. Klicken Sie auf OK, um fortzufahren.";
+"CodexBar will ask macOS Keychain for your MiniMax API token so it can fetch usage. Click OK to continue." = "CodexBar fragt den macOS-Schlüsselbund nach Ihrem MiniMax-API-Token, damit die Nutzung abgerufen werden kann. Klicken Sie auf OK, um fortzufahren.";
+"CodexBar will ask macOS Keychain for your MiniMax cookie header so it can fetch usage. Click OK to continue." = "CodexBar fragt den macOS-Schlüsselbund nach Ihrem MiniMax-Cookie-Header, damit er die Nutzung abrufen kann. Klicken Sie auf OK, um fortzufahren.";
+"CodexBar will ask macOS Keychain for your OpenAI cookie header so it can fetch Codex dashboard extras. Click OK to continue." = "CodexBar fragt den macOS-Schlüsselbund nach Ihrem OpenAI-Cookie-Header, damit Codex-Dashboard-Extras abgerufen werden können. Klicken Sie auf OK, um fortzufahren.";
+"CodexBar will ask macOS Keychain for your OpenCode cookie header so it can fetch usage. Click OK to continue." = "CodexBar fragt den macOS-Schlüsselbund nach Ihrem OpenCode-Cookie-Header, damit er die Nutzung abrufen kann. Klicken Sie auf OK, um fortzufahren.";
+"CodexBar will ask macOS Keychain for your Synthetic API key so it can fetch usage. Click OK to continue." = "CodexBar fragt den macOS-Schlüsselbund nach Ihrem synthetischen API-Schlüssel, damit er die Nutzung abrufen kann. Klicken Sie auf OK, um fortzufahren.";
+"CodexBar will ask macOS Keychain for your z.ai API token so it can fetch usage. Click OK to continue." = "CodexBar fragt den macOS-Schlüsselbund nach Ihrem z.ai-API-Token, damit es die Nutzung abrufen kann. Klicken Sie auf OK, um fortzufahren.";
+"Could not open Cursor login in your browser." = "Die Cursor-Anmeldung konnte in Ihrem Browser nicht geöffnet werden.";
+"Could not open browser for Antigravity" = "Der Browser für Antigravity konnte nicht geöffnet werden";
+"Credits used" = "Verwendete Credits";
+"Day" = "Tag";
+"Deployment" = "Einsatz";
+"Drag to reorder" = "Zum Neuanordnen ziehen";
+"Sort providers alphabetically" = "Anbieter alphabetisch sortieren";
+"Sort providers alphabetically (enabled first)" = "Anbieter alphabetisch sortieren (aktivierte zuerst)";
+"Sorted alphabetically (enabled first) — click to use your custom order" = "Alphabetisch sortiert (aktivierte zuerst) — klicken, um die eigene Reihenfolge zu verwenden";
+"Endpoint" = "Endpunkt";
+"Enterprise host" = "Unternehmenshost";
+"Extra usage balance: %@" = "Zusätzlicher Nutzungssaldo: %@";
+"Keychain Access Required" = "Schlüsselbundzugriff erforderlich";
+"Kiro menu bar value" = "Wert der Kiro-Menüleiste";
+"Label" = "Etikett";
+"No organizations loaded. Click Refresh after setting your API key." = "Keine Organisationen geladen. Klicken Sie auf Aktualisieren, nachdem Sie Ihren API-Schlüssel festgelegt haben.";
+"No output captured." = "Keine Ausgabe erfasst.";
+"No system account" = "Kein Systemkonto";
+"Oasis-Token" = "Oasis-Token";
+"Open Augment (Log Out & Back In)" = "Augment öffnen (abmelden und wieder anmelden)";
+"Open Codebuff Dashboard" = "Öffnen Sie das Codebuff-Dashboard";
+"Open Command Code Settings" = "Öffnen Sie die Befehlscode-Einstellungen";
+"Open Crof dashboard" = "Öffnen Sie das Crof-Dashboard";
+"Open Manus" = "Öffne Manus";
+"Open MiMo Balance" = "Öffnen Sie MiMo Balance";
+"Open Moonshot Console" = "Öffnen Sie die Moonshot-Konsole";
+"Open Ollama API Keys" = "Öffnen Sie die Ollama-API-Schlüssel";
+"Open StepFun Platform" = "Öffnen Sie die StepFun-Plattform";
+"Open T3 Chat Settings" = "Öffnen Sie die T3-Chat-Einstellungen";
+"Open Volcengine Ark Console" = "Öffnen Sie die Volcengine Ark-Konsole";
+"Open legacy provider docs" = "Öffnen Sie die Dokumente älterer Anbieter";
+"Open projects" = "Offene Projekte";
+"Open this URL manually to continue login:\n\n%@" = "Öffnen Sie diese URL manuell, um mit der Anmeldung fortzufahren:\n\n%@";
+"Optional organization ID for accounts linked to multiple Anthropic organizations." = "Optionale Organisations-ID für Konten, die mit mehreren Anthropic-Organisationen verknüpft sind.";
+"Optional. Applies to the configured Admin API key; selected token accounts do not inherit OPENAI_PROJECT_ID." = "Optional. Gilt für den konfigurierten Admin-API-Schlüssel; Ausgewählte Token-Konten erben OPENAI_PROJECT_ID nicht.";
+"Optional. Enter your GitHub Enterprise host, for example octocorp.ghe.com. Leave blank for github.com." = "Optional. Geben Sie Ihren GitHub Enterprise-Host ein, zum Beispiel octocorp.ghe.com. Für github.com leer lassen.";
+"Optional. Leave blank to discover and aggregate projects visible to the API key." = "Optional. Lassen Sie das Feld leer, um für den API-Schlüssel sichtbare Projekte zu ermitteln und zu aggregieren.";
+"Org ID (optional)" = "Organisations-ID (optional)";
+"Organizations" = "Organisationen";
+"Password" = "Passwort";
+"%@ authentication is disabled." = "Die %@-Authentifizierung ist deaktiviert.";
+"%@ cookies are disabled." = "%@ Cookies sind deaktiviert.";
+"%@ web API access is disabled." = "%@ Web-API-Zugriff ist deaktiviert.";
+"Disable %@ dashboard cookie usage." = "Deaktivieren Sie die Verwendung von Dashboard-Cookies für %@.";
+"Keychain access is disabled in Advanced, so browser cookie import is unavailable." = "Der Schlüsselbundzugriff ist in \"Erweitert\" deaktiviert, daher ist der Browser-Cookie-Import nicht verfügbar.";
+"Manually paste an %@ from a browser session." = "Fügen Sie manuell einen %@ aus einer Browsersitzung ein.";
+"Paste a Cookie header captured from %@." = "Fügen Sie einen von %@ erfassten Cookie-Header ein.";
+"Paste a Cookie header from %@." = "Fügen Sie einen Cookie-Header von %@ ein.";
+"Paste a Cookie header or cURL capture from %@." = "Fügen Sie einen Cookie-Header oder eine cURL-Erfassung aus %@ ein.";
+"Paste a Cookie header or full cURL capture from %@." = "Fügen Sie einen Cookie-Header oder eine vollständige cURL-Erfassung aus %@ ein.";
+"Paste a Cookie or Authorization header from %@." = "Fügen Sie einen Cookie- oder Autorisierungsheader von %@ ein.";
+"Paste a full cookie header or the %@ value." = "Fügen Sie einen vollständigen Cookie-Header oder den Wert %@ ein.";
+"Paste a Cookie header or full cURL capture from T3 Chat settings." = "Fügen Sie einen Cookie-Header oder eine vollständige cURL-Erfassung aus den T3-Chat-Einstellungen ein.";
+"Paste the Cookie header from a request to admin.mistral.ai. Must contain an ory_session_* cookie." = "Fügen Sie den Cookie-Header aus einer Anfrage in admin.mistral.ai ein. Muss ein ory_session_*-Cookie enthalten.";
+"Paste the Oasis-Token from a logged-in browser session on platform.stepfun.com." = "Fügen Sie den Oasis-Token aus einer angemeldeten Browsersitzung auf platform.stepfun.com ein.";
+"Paste the %@ JSON bundle from %@." = "Fügen Sie das JSON-Bundle %@ aus %@ ein.";
+"Paste the %@ value or a full Cookie header." = "Fügen Sie den Wert %@ oder einen vollständigen Cookie-Header ein.";
+"Personal account" = "Persönliches Konto";
+"Project ID" = "Projekt-ID";
+"Re-auth" = "Erneut authentifizieren";
+"Re-login at claude.ai" = "Erneut bei claude.ai anmelden";
+"Re-authenticating…" = "Erneute Authentifizierung…";
+"Refresh Session" = "Sitzung aktualisieren";
+"Refresh organizations" = "Organisationen aktualisieren";
+"Region" = "Region";
+"Reload" = "Neu laden";
+"Reorder" = "Neu anordnen";
+"Secret access key" = "Geheimer Zugangsschlüssel";
+"Series" = "Serie";
+"Service" = "Service";
+"Show or hide Kiro credits, percent, or both next to the menu bar icon." = "Kiro-Credits, Prozent oder beides neben dem Menüleistensymbol ein- oder ausblenden.";
+"Show usage for organizations you belong to. Personal account is always shown." = "Zeigen Sie die Nutzung für Organisationen an, denen Sie angehören. Persönliches Konto wird immer angezeigt.";
+"Sign in to cursor.com in your browser, then refresh Cursor in CodexBar." = "Melden Sie sich in Ihrem Browser bei Cursor.com an und aktualisieren Sie dann Cursor in CodexBar.";
+"Simulated error text" = "Simulierter Fehlertext";
+"StepFun platform account (phone number or email)." = "StepFun-Plattformkonto (Telefonnummer oder E-Mail).";
+"Stored in ~/.codexbar/config.json." = "Gespeichert in ~/.codexbar/config.json.";
+"Stored in ~/.codexbar/config.json. AZURE_OPENAI_API_KEY is also supported." = "Gespeichert in ~/.codexbar/config.json. AZURE_OPENAI_API_KEY wird ebenfalls unterstützt.";
+"Stored in ~/.codexbar/config.json. For the official Kimi API, use Moonshot / Kimi API." = "Gespeichert in ~/.codexbar/config.json. Verwenden Sie für die offizielle Kimi-API die Moonshot/Kimi-API.";
+"Stored in ~/.codexbar/config.json. Get your API key from the Volcengine Ark console." = "Gespeichert in ~/.codexbar/config.json. Holen Sie sich Ihren API-Schlüssel von der Volcengine Ark-Konsole.";
+"Stored in ~/.codexbar/config.json. Get your key from Ollama settings." = "Gespeichert in ~/.codexbar/config.json. Holen Sie sich Ihren Schlüssel aus den Ollama-Einstellungen.";
+"Stored in ~/.codexbar/config.json. Get your key from console.deepgram.com." = "Gespeichert in ~/.codexbar/config.json. Holen Sie sich Ihren Schlüssel von console.deepgram.com.";
+"Stored in ~/.codexbar/config.json. Get your key from elevenlabs.io/app/settings/api-keys." = "Gespeichert in ~/.codexbar/config.json. Holen Sie sich Ihren Schlüssel von elevenlabs.io/app/settings/api-keys.";
+"Stored in ~/.codexbar/config.json. Get your key from openrouter.ai/settings/keys and set a key spending limit there to enable API key quota tracking." = "Gespeichert in ~/.codexbar/config.json. Holen Sie sich Ihren Schlüssel von openrouter.ai/settings/keys und legen Sie dort ein Schlüsselausgabelimit fest, um die API-Schlüsselkontingentverfolgung zu ermöglichen.";
+"Stored in ~/.codexbar/config.json. In Warp, open Settings > Platform > API Keys, then create one." = "Gespeichert in ~/.codexbar/config.json. Öffnen Sie in Warp Einstellungen > Plattform > API-Schlüssel und erstellen Sie einen.";
+"Stored in ~/.codexbar/config.json. Metrics require Groq Enterprise Prometheus access." = "Gespeichert in ~/.codexbar/config.json. Für Metriken ist Groq Enterprise Prometheus-Zugriff erforderlich.";
+"Stored in ~/.codexbar/config.json. OPENAI_ADMIN_KEY is preferred; OPENAI_API_KEY still works." = "Gespeichert in ~/.codexbar/config.json. OPENAI_ADMIN_KEY wird bevorzugt; OPENAI_API_KEY funktioniert immer noch.";
+"Stored in ~/.codexbar/config.json. Requires an Anthropic Admin API key." = "Gespeichert in ~/.codexbar/config.json. Erfordert einen Anthropic Admin API-Schlüssel.";
+"Stored in ~/.codexbar/config.json. Used for /v1/quota-stats." = "Gespeichert in ~/.codexbar/config.json. Wird für /v1/quota-stats verwendet.";
+"Stored in ~/.codexbar/config.json. You can also provide CODEBUFF_API_KEY or let CodexBar read ~/.config/manicode/credentials.json (created by `codebuff login`)." = "Gespeichert in ~/.codexbar/config.json. Sie können auch CODEBUFF_API_KEY bereitstellen oder CodexBar ~/.config/manicode/credentials.json lesen lassen (erstellt durch \"codebuff login\").";
+"Stored in ~/.codexbar/config.json. You can also provide CROF_API_KEY." = "Gespeichert in ~/.codexbar/config.json. Sie können auch CROF_API_KEY angeben.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or ~/.local/share/kilo/auth.json (kilo.access)." = "Gespeichert in ~/.codexbar/config.json. Sie können auch KILO_API_KEY oder ~/.local/share/kilo/auth.json (kilo.access) angeben.";
+"T3 Chat cookie" = "T3-Chat-Cookie";
+"That account is no longer available in CodexBar. Refresh the account list and try again." = "Dieses Konto ist in CodexBar nicht mehr verfügbar. Aktualisieren Sie die Kontoliste und versuchen Sie es erneut.";
+"The browser login did not complete in time. Try Antigravity login again." = "Die Browseranmeldung wurde nicht rechtzeitig abgeschlossen. Versuchen Sie erneut, sich bei Antigravity anzumelden.";
+"Timed out waiting for Cursor login. %@" = "Zeitüberschreitung beim Warten auf die Cursor-Anmeldung. %@";
+"Timed out waiting for Cursor login. %@ Last error: %@" = "Zeitüberschreitung beim Warten auf die Cursor-Anmeldung. %@ Letzter Fehler: %@";
+"Today requests" = "Heute Anfragen";
+"Total (30d): %@ credits" = "Gesamt (30 Tage): %@ Credits";
+"Username" = "Benutzername";
+"Uses username + password to login and obtain an Oasis-Token automatically." = "Verwendet Benutzername + Passwort, um sich anzumelden und automatisch ein Oasis-Token zu erhalten.";
+"Uses username + password to login and obtain an %@ automatically." = "Verwendet Benutzername + Passwort, um sich anzumelden und automatisch einen %@ zu erhalten.";
+"Utilization End" = "Nutzungsende";
+"Utilization Start" = "Nutzungsbeginn";
+"Verbosity" = "Ausführlichkeit";
+"Windsurf session JSON bundle" = "JSON-Paket für Windsurf-Sitzungen";
+"Workspace ID" = "Arbeitsbereichs-ID";
+"Your StepFun platform password. Used to login and obtain a session token." = "Ihr Passwort für die StepFun-Plattform. Wird verwendet, um sich anzumelden und ein Sitzungstoken zu erhalten.";
+"claude /login exited with status %d." = "Claude /login wurde mit dem Status %d beendet.";
+"codex login exited with status %d." = "Codex-Anmeldung mit Status %d beendet.";
+"Cookie: …\n\nor paste a cURL capture from the Abacus AI dashboard" = "Cookie: …\n\noder fügen Sie eine cURL-Erfassung aus dem Abacus AI-Dashboard ein";
+"Cookie: …\n\nor paste the __Secure-next-auth.session-token value" = "Cookie: …\n\noder fügen Sie den Wert __Secure-next-auth.session-token ein";
+"Cookie: …\n\nor paste the kimi-auth token value" = "Cookie: …\n\noder fügen Sie den Kimi-Auth-Token-Wert ein";
+"session_id=...\n\nor paste just the session_id value" = "session_id=...\n\noder fügen Sie nur den session_id-Wert ein";
+"Clear" = "Klar";
+"No matching providers" = "Keine passenden Anbieter";
+"Search providers" = "Suchanbieter";
+
+"Request quota: %@ / %@" = "Anfragelimit: %@ / %@";
+"language_arabic" = "العربية";
+"language_persian" = "فارسی";
+"language_thai" = "ไทย";
+"Limit Reset Credits" = "Credits zum Zurücksetzen des Limits";
+"1 manual reset available" = "1 manuelle Zurücksetzung verfügbar";
+"%d manual resets available" = "%d manuelle Zurücksetzungen verfügbar";
+"Next expires %@" = "Nächster Ablauf %@";
+"Other (%d items)" = "Andere (%d Elemente)";
+"Expand" = "Aufklappen";
+"Collapse" = "Zuklappen";
+"byte_unit_byte" = "Byte";
+"byte_unit_bytes" = "Byte";
+"byte_unit_kilobyte" = "Kilobyte";
+"byte_unit_kilobytes" = "Kilobyte";
+"byte_unit_megabyte" = "Megabyte";
+"byte_unit_megabytes" = "Megabyte";
+"byte_unit_gigabyte" = "Gigabyte";
+"byte_unit_gigabytes" = "Gigabyte";
diff --git a/Sources/CodexBar/Resources/en.lproj/Localizable.strings b/Sources/CodexBar/Resources/en.lproj/Localizable.strings
new file mode 100644
index 0000000000..50db29fba8
--- /dev/null
+++ b/Sources/CodexBar/Resources/en.lproj/Localizable.strings
@@ -0,0 +1,1110 @@
+/* English localization for CodexBar (base/fallback) */
+
+" providers" = " providers";
+"(System)" = "(System)";
+"30d" = "30d";
+"A managed Codex login is already running. Wait for it to finish before adding " = "A managed Codex login is already running. Wait for it to finish before adding ";
+"API key" = "API key";
+"API region" = "API region";
+"API token" = "API token";
+"API tokens" = "API tokens";
+"About" = "About";
+"Account" = "Account";
+"Accounts" = "Accounts";
+"Accounts subtitle" = "Accounts subtitle";
+"Active" = "Active";
+"Add" = "Add";
+"Add Workspace" = "Add Workspace";
+"Advanced" = "Advanced";
+"All" = "All";
+"Always allow prompts" = "Always allow prompts";
+"Animation pattern" = "Animation pattern";
+"Antigravity login is managed in the app" = "Antigravity login is managed in the app";
+"Applies only to the Security.framework OAuth keychain reader." = "Applies only to the Security.framework OAuth keychain reader.";
+"Auto falls back to the next source if the preferred one fails." = "Auto falls back to the next source if the preferred one fails.";
+"Auto uses API first, then falls back to CLI on auth failures." = "Auto uses API first, then falls back to CLI on auth failures.";
+"Auto-detect" = "Auto-detect";
+"Auto-refresh is off; use the menu's Refresh command." = "Auto-refresh is off; use the menu's Refresh command.";
+"Auto-refresh: hourly · Timeout: 10m" = "Auto-refresh: hourly · Timeout: 10m";
+"Automatic" = "Automatic";
+"Automatic imports browser cookies and WorkOS tokens." = "Automatic imports browser cookies and WorkOS tokens.";
+"Automatic imports browser cookies and local storage tokens." = "Automatic imports browser cookies and local storage tokens.";
+"Automatic imports browser cookies for dashboard extras." = "Automatic imports browser cookies for dashboard extras.";
+"Automatic imports browser cookies for the web API." = "Automatic imports browser cookies for the web API.";
+"Automatic imports browser cookies from Model Studio/Bailian." = "Automatic imports browser cookies from Model Studio/Bailian.";
+"Automatic imports browser cookies from admin.mistral.ai." = "Automatic imports browser cookies from admin.mistral.ai.";
+"Automatic imports browser cookies from opencode.ai." = "Automatic imports browser cookies from opencode.ai.";
+"Automatic imports browser cookies or stored sessions." = "Automatic imports browser cookies or stored sessions.";
+"Automatic imports browser cookies." = "Automatic imports browser cookies.";
+"Automatically imports browser session cookie." = "Automatically imports browser session cookie.";
+"Automatically opens CodexBar when you start your Mac." = "Automatically opens CodexBar when you start your Mac.";
+"Automation" = "Automation";
+"Average (\\(label1) + \\(label2))" = "Average (\\(label1) + \\(label2))";
+"Average (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))" = "Average (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))";
+"Avoid Keychain prompts" = "Avoid Keychain prompts";
+"Balance" = "Balance";
+"Battery Saver" = "Battery Saver";
+"Bordered" = "Bordered";
+"Build" = "Build";
+"Built \\(buildTimestamp)" = "Built \\(buildTimestamp)";
+"Buy Credits..." = "Buy Credits...";
+"Buy Credits…" = "Buy Credits…";
+"CLI paths" = "CLI paths";
+"CLI sessions" = "CLI sessions";
+"Caches" = "Caches";
+"Cancel" = "Cancel";
+"Check for Updates…" = "Check for Updates…";
+"Check for updates automatically" = "Check for updates automatically";
+"Check if you like your agents having some fun up there." = "Check if you like your agents having some fun up there.";
+"Check provider status" = "Check provider status";
+"Choose Codex workspace" = "Choose Codex workspace";
+"Choose the MiniMax host (global .io or China mainland .com)." = "Choose the MiniMax host (global .io or China mainland .com).";
+"Choose up to " = "Choose up to ";
+"Choose up to \\(Self.maxOverviewProviders) providers" = "Choose up to \\(Self.maxOverviewProviders) providers";
+"Choose up to \\(count) providers" = "Choose up to \\(count) providers";
+"Choose what to show in the menu bar (Pace shows usage vs. expected)." = "Choose what to show in the menu bar (Pace shows usage vs. expected).";
+"Choose which Codex account CodexBar should follow." = "Choose which Codex account CodexBar should follow.";
+"Choose which window drives the menu bar percent." = "Choose which window drives the menu bar percent.";
+"Chrome" = "Chrome";
+"Claude CLI not found" = "Claude CLI not found";
+"Claude binary" = "Claude binary";
+"Claude cookies" = "Claude cookies";
+"Claude login failed" = "Claude login failed";
+"Claude login timed out" = "Claude login timed out";
+"Close" = "Close";
+"Code review" = "Code review";
+"Codex CLI not found" = "Codex CLI not found";
+"Codex account login already running" = "Codex account login already running";
+"Codex binary" = "Codex binary";
+"Codex login failed" = "Codex login failed";
+"Codex login timed out" = "Codex login timed out";
+"CodexBar Lifecycle Keepalive" = "CodexBar Lifecycle Keepalive";
+"CodexBar can't show its menu bar icon" = "CodexBar can't show its menu bar icon";
+"CodexBar could not read managed account storage. " = "CodexBar could not read managed account storage. ";
+"Configure…" = "Configure…";
+"Connected" = "Connected";
+"Controls how much detail is logged." = "Controls how much detail is logged.";
+"Cookie header" = "Cookie header";
+"Cookie source" = "Cookie source";
+"Cookie: ..." = "Cookie: ...";
+"Cookie: \\u{2026}\\\n\\\nor paste a cURL capture from the Abacus AI dashboard" = "Cookie: \\u{2026}\\\n\\\nor paste a cURL capture from the Abacus AI dashboard";
+"Cookie: \\u{2026}\\\n\\\nor paste the __Secure-next-auth.session-token value" = "Cookie: \\u{2026}\\\n\\\nor paste the __Secure-next-auth.session-token value";
+"Cookie: \\u{2026}\\\n\\\nor paste the kimi-auth token value" = "Cookie: \\u{2026}\\\n\\\nor paste the kimi-auth token value";
+"Cookie: …" = "Cookie: …";
+"CopilotDeviceFlow" = "CopilotDeviceFlow";
+"Cost" = "Cost";
+"Could not add Codex account" = "Could not add Codex account";
+"Could not open Terminal for Gemini" = "Could not open Terminal for Gemini";
+"Could not start claude /login" = "Could not start claude /login";
+"Could not start codex login" = "Could not start codex login";
+"Could not switch system account" = "Could not switch system account";
+"Credits" = "Credits";
+"Individual credits" = "Individual credits";
+"Workspace" = "Workspace";
+"Credits history" = "Credits history";
+"Cursor login failed" = "Cursor login failed";
+"Custom" = "Custom";
+"Custom Path" = "Custom Path";
+"Daily Routines" = "Daily Routines";
+"Debug" = "Debug";
+"Default" = "Default";
+"Disable Keychain access" = "Disable Keychain access";
+"Disabled" = "Disabled";
+"Dismiss" = "Dismiss";
+"Disconnected" = "Disconnected";
+"Display" = "Display";
+"Display mode" = "Display mode";
+"Display reset times as absolute clock values instead of countdowns." = "Display reset times as absolute clock values instead of countdowns.";
+"Done" = "Done";
+"Effective PATH" = "Effective PATH";
+"Email" = "Email";
+"Enable Merge Icons to configure Overview tab providers." = "Enable Merge Icons to configure Overview tab providers.";
+"Enable file logging" = "Enable file logging";
+"Enabled" = "Enabled";
+"Error" = "Error";
+"Error simulation" = "Error simulation";
+"Expose troubleshooting tools in the Debug tab." = "Expose troubleshooting tools in the Debug tab.";
+"Failed" = "Failed";
+"False" = "False";
+"Fetch strategy attempts" = "Fetch strategy attempts";
+"Fetching" = "Fetching";
+"Field" = "Field";
+"Field subtitle" = "Field subtitle";
+"Finish the current managed account change before switching the system account." = "Finish the current managed account change before switching the system account.";
+"Force animation on next refresh" = "Force animation on next refresh";
+"Gateway region" = "Gateway region";
+"Gemini CLI not found" = "Gemini CLI not found";
+"Gemini/Antigravity, surfacing incidents in the icon and menu." = "Gemini/Antigravity, surfacing incidents in the icon and menu.";
+"General" = "General";
+"GitHub" = "GitHub";
+"GitHub Copilot Login" = "GitHub Copilot Login";
+"GitHub Login" = "GitHub Login";
+"Hide details" = "Hide details";
+"Hide personal information" = "Hide personal information";
+"Historical tracking" = "Historical tracking";
+"How often CodexBar polls providers in the background." = "How often CodexBar polls providers in the background.";
+"Inactive" = "Inactive";
+"Install CLI" = "Install CLI";
+"Install the Claude CLI (npm i -g @anthropic-ai/claude-code) and try again." = "Install the Claude CLI (npm i -g @anthropic-ai/claude-code) and try again.";
+"Install the Codex CLI (npm i -g @openai/codex) and try again." = "Install the Codex CLI (npm i -g @openai/codex) and try again.";
+"Install the Gemini CLI (npm i -g @google/gemini-cli) and try again." = "Install the Gemini CLI (npm i -g @google/gemini-cli) and try again.";
+"JetBrains AI is ready" = "JetBrains AI is ready";
+"JetBrains IDE" = "JetBrains IDE";
+"Keep CLI sessions alive" = "Keep CLI sessions alive";
+"Keyboard shortcut" = "Keyboard shortcut";
+"Keychain access" = "Keychain access";
+"Keychain prompt policy" = "Keychain prompt policy";
+"Last \\(name) fetch failed:" = "Last \\(name) fetch failed:";
+"Last \\(self.store.metadata(for: self.provider).displayName) fetch failed:" = "Last \\(self.store.metadata(for: self.provider).displayName) fetch failed:";
+"Last attempt" = "Last attempt";
+"Link" = "Link";
+"Loading animations" = "Loading animations";
+"Loading…" = "Loading…";
+"Local" = "Local";
+"Logging" = "Logging";
+"Login failed" = "Login failed";
+"Login shell PATH (startup capture)" = "Login shell PATH (startup capture)";
+"Login timed out" = "Login timed out";
+"MCP details" = "MCP details";
+"Managed Codex accounts unavailable" = "Managed Codex accounts unavailable";
+"Managed account storage is unreadable. Live account access is still available, " = "Managed account storage is unreadable. Live account access is still available, ";
+"Manual" = "Manual";
+"May your tokens never run out—keep agent limits in view." = "May your tokens never run out—keep agent limits in view.";
+"Menu bar" = "Menu bar";
+"Menu bar auto-shows the provider closest to its rate limit." = "Menu bar auto-shows the provider closest to its rate limit.";
+"Menu bar metric" = "Menu bar metric";
+"Menu bar shows percent" = "Menu bar shows percent";
+"Menu content" = "Menu content";
+"Merge Icons" = "Merge Icons";
+"Never prompt" = "Never prompt";
+"No" = "No";
+"No Codex accounts detected yet." = "No Codex accounts detected yet.";
+"No JetBrains IDE detected" = "No JetBrains IDE detected";
+"No cost history data." = "No cost history data.";
+"No data available" = "No data available";
+"No data yet" = "No data yet";
+"No enabled providers available for Overview." = "No enabled providers available for Overview.";
+"No providers selected" = "No providers selected";
+"No token accounts yet." = "No token accounts yet.";
+"No usage breakdown data." = "No usage breakdown data.";
+"None" = "None";
+"Notifications" = "Notifications";
+"Notifies when the 5-hour session quota hits 0% and when it becomes " = "Notifies when the 5-hour session quota hits 0% and when it becomes ";
+"OK" = "OK";
+"Obscure email addresses in the menu bar and menu UI." = "Obscure email addresses in the menu bar and menu UI.";
+"Off" = "Off";
+"Offline" = "Offline";
+"On" = "On";
+"Online" = "Online";
+"Only on user action" = "Only on user action";
+"Open" = "Open";
+"Open API Keys" = "Open API Keys";
+"Open Amp Settings" = "Open Amp Settings";
+"Open Antigravity to sign in, then refresh CodexBar." = "Open Antigravity to sign in, then refresh CodexBar.";
+"Open Browser" = "Open Browser";
+"Open Coding Plan" = "Open Coding Plan";
+"Open Console" = "Open Console";
+"Open Dashboard" = "Open Dashboard";
+"Open Mistral Admin" = "Open Mistral Admin";
+"Open Menu Bar Settings" = "Open Menu Bar Settings";
+"Open Ollama Settings" = "Open Ollama Settings";
+"Open Terminal" = "Open Terminal";
+"Open Usage Page" = "Open Usage Page";
+"Open Warp API Key Guide" = "Open Warp API Key Guide";
+"Open menu" = "Open menu";
+"Open token file" = "Open token file";
+"OpenAI cookies" = "OpenAI cookies";
+"OpenAI web extras" = "OpenAI web extras";
+"Option A" = "Option A";
+"Option B" = "Option B";
+"Optional override if workspace lookup fails." = "Optional override if workspace lookup fails.";
+"Options" = "Options";
+"Override auto-detection with a custom IDE base path" = "Override auto-detection with a custom IDE base path";
+"Overview" = "Overview";
+"Overview rows always follow provider order." = "Overview rows always follow provider order.";
+"Overview tab providers" = "Overview tab providers";
+"Paste API key…" = "Paste API key…";
+"Paste API token…" = "Paste API token…";
+"Paste key…" = "Paste key…";
+"Paste sessionKey or OAuth token…" = "Paste sessionKey or OAuth token…";
+"Paste the Cookie header from a request to admin.mistral.ai. " = "Paste the Cookie header from a request to admin.mistral.ai. ";
+"Paste token…" = "Paste token…";
+"Personal" = "Personal";
+"Picker" = "Picker";
+"Picker subtitle" = "Picker subtitle";
+"Placeholder" = "Placeholder";
+"Plan" = "Plan";
+"Play full-screen confetti when weekly usage resets." = "Play full-screen confetti when weekly usage resets.";
+"Polls OpenAI/Claude status pages and Google Workspace for " = "Polls OpenAI/Claude status pages and Google Workspace for ";
+"Prevents any Keychain access while enabled." = "Prevents any Keychain access while enabled.";
+"Primary (API key limit)" = "Primary (API key limit)";
+"Primary (\\(label))" = "Primary (\\(label))";
+"Primary (\\(metadata.sessionLabel))" = "Primary (\\(metadata.sessionLabel))";
+"Probe logs" = "Probe logs";
+"Progress bars fill as you consume quota (instead of showing remaining)." = "Progress bars fill as you consume quota (instead of showing remaining).";
+"Provider" = "Provider";
+"Providers" = "Providers";
+"Quit CodexBar" = "Quit CodexBar";
+"Random (default)" = "Random (default)";
+"Reads local usage logs. Shows today + last 30 days cost in the menu." = "Reads local usage logs. Shows today + the selected history window in the menu.";
+"Refresh" = "Refresh";
+"Refresh cadence" = "Refresh cadence";
+"Remote" = "Remote";
+"Remove" = "Remove";
+"Remove Codex account?" = "Remove Codex account?";
+"Remove \\(account.email) from CodexBar? Its managed Codex home will be deleted." = "Remove \\(account.email) from CodexBar? Its managed Codex home will be deleted.";
+"Remove \\(email) from CodexBar? Its managed Codex home will be deleted." = "Remove \\(email) from CodexBar? Its managed Codex home will be deleted.";
+"Remove selected account" = "Remove selected account";
+"Replace critter bars with provider branding icons and a percentage." = "Replace critter bars with provider branding icons and a percentage.";
+"Replay selected animation" = "Replay selected animation";
+"Requires authentication via GitHub Device Flow." = "Requires authentication via GitHub Device Flow.";
+"Resets: \\(reset)" = "Resets: \\(reset)";
+"Rolling five-hour limit" = "Rolling five-hour limit";
+"Search hourly" = "Search hourly";
+"Secondary (\\(label))" = "Secondary (\\(label))";
+"Secondary (\\(metadata.weeklyLabel))" = "Secondary (\\(metadata.weeklyLabel))";
+"Select a provider" = "Select a provider";
+"Select the IDE to monitor" = "Select the IDE to monitor";
+"Session quota notifications" = "Session quota notifications";
+"Session tokens" = "Session tokens";
+"Settings" = "Settings";
+"Show Codex Credits and Claude Extra usage sections in the menu." = "Show Codex Credits and Claude Extra usage sections in the menu.";
+"Show Debug Settings" = "Show Debug Settings";
+"Show all token accounts" = "Show all token accounts";
+"Show cost summary" = "Show cost summary";
+"Show credits + extra usage" = "Show credits + extra usage";
+"Show details" = "Show details";
+"Show most-used provider" = "Show most-used provider";
+"Show provider icons in the switcher (otherwise show a weekly progress line)." = "Show provider icons in the switcher (otherwise show a weekly progress line).";
+"Show reset time as clock" = "Show reset time as clock";
+"Show usage as used" = "Show usage as used";
+"Sign in via button below" = "Sign in via button below";
+"Skip teardown between probes (debug-only)." = "Skip teardown between probes (debug-only).";
+"Stack token accounts in the menu (otherwise show an account switcher bar)." = "Stack token accounts in the menu (otherwise show an account switcher bar).";
+"Start at Login" = "Start at Login";
+"Status" = "Status";
+"Store Claude sessionKey cookies or OAuth access tokens." = "Store Claude sessionKey cookies or OAuth access tokens.";
+"Store multiple Abacus AI Cookie headers." = "Store multiple Abacus AI Cookie headers.";
+"Store multiple Augment Cookie headers." = "Store multiple Augment Cookie headers.";
+"Store multiple Cursor Cookie headers." = "Store multiple Cursor Cookie headers.";
+"Store multiple Factory Cookie headers." = "Store multiple Factory Cookie headers.";
+"Store multiple MiniMax Cookie headers." = "Store multiple MiniMax Cookie headers.";
+"Store multiple Mistral Cookie headers." = "Store multiple Mistral Cookie headers.";
+"Store multiple Ollama Cookie headers." = "Store multiple Ollama Cookie headers.";
+"Store multiple OpenCode Cookie headers." = "Store multiple OpenCode Cookie headers.";
+"Store multiple OpenCode Go Cookie headers." = "Store multiple OpenCode Go Cookie headers.";
+"Stored in the CodexBar config file." = "Stored in the CodexBar config file.";
+"Stored in ~/.codexbar/config.json. " = "Stored in ~/.codexbar/config.json. ";
+"Stored in ~/.codexbar/config.json. Generate one at kimi-k2.ai." = "Stored in ~/.codexbar/config.json. Generate one at kimi-k2.ai.";
+"Stored in ~/.codexbar/config.json. Paste the key from the Synthetic dashboard." = "Stored in ~/.codexbar/config.json. Paste the key from the Synthetic dashboard.";
+"Stored in ~/.codexbar/config.json. Paste your Coding Plan API key from Model Studio." = "Stored in ~/.codexbar/config.json. Paste your Coding Plan API key from Model Studio.";
+"Stored in ~/.codexbar/config.json. Paste your MiniMax API key." = "Stored in ~/.codexbar/config.json. Paste your MiniMax API key.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or " = "Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or ";
+"Stores local Codex usage history (8 weeks) to personalize Pace predictions." = "Stores local Codex usage history (8 weeks) to personalize Pace predictions.";
+"Subscription Utilization" = "Subscription Utilization";
+"Surprise me" = "Surprise me";
+"Switcher shows icons" = "Switcher shows icons";
+"Symlink CodexBarCLI to /usr/local/bin and /opt/homebrew/bin as codexbar." = "Symlink CodexBarCLI to /usr/local/bin and /opt/homebrew/bin as codexbar.";
+"System" = "System";
+"Temporarily shows the loading animation after the next refresh." = "Temporarily shows the loading animation after the next refresh.";
+"terminal_app_subtitle" = "Terminal used by the Open Terminal action";
+"terminal_app_title" = "Default Terminal";
+"Tertiary (\\(label))" = "Tertiary (\\(label))";
+"Tertiary (\\(tertiaryTitle))" = "Tertiary (\\(tertiaryTitle))";
+"The default Codex account on this Mac." = "The default Codex account on this Mac.";
+"Toggle" = "Toggle";
+"Toggle subtitle" = "Toggle subtitle";
+"Token" = "Token";
+"Trigger the menu bar menu from anywhere." = "Trigger the menu bar menu from anywhere.";
+"True" = "True";
+"Twitter" = "Twitter";
+"Unsupported" = "Unsupported";
+"Update Channel" = "Update Channel";
+"Updated" = "Updated";
+"Updates unavailable in this build." = "Updates unavailable in this build.";
+"Usage" = "Usage";
+"Usage breakdown" = "Usage breakdown";
+"Usage history (30 days)" = "Usage history";
+"Usage source" = "Usage source";
+"Use BigModel for the China mainland endpoints (open.bigmodel.cn)." = "Use BigModel for the China mainland endpoints (open.bigmodel.cn).";
+"Use a single menu bar icon with a provider switcher." = "Use a single menu bar icon with a provider switcher.";
+"Use international or China mainland console gateways for quota fetches." = "Use international or China mainland console gateways for quota fetches.";
+"Version" = "Version";
+"Version \\(self.versionString)" = "Version \\(self.versionString)";
+"Version \\(version)" = "Version \\(version)";
+"Version \\(versionString)" = "Version \\(versionString)";
+"Vertex AI Login" = "Vertex AI Login";
+"Wait for the current managed Codex login to finish before adding another account." = "Wait for the current managed Codex login to finish before adding another account.";
+"Waiting for Authentication..." = "Waiting for Authentication...";
+"Website" = "Website";
+"Weekly limit confetti" = "Weekly limit confetti";
+"Weekly token limit" = "Weekly token limit";
+"Weekly usage" = "Weekly usage";
+"Weekly usage unavailable for this account." = "Weekly usage unavailable for this account.";
+"Window: \\(window)" = "Window: \\(window)";
+"Write logs to \\(self.fileLogPath) for debugging." = "Write logs to \\(self.fileLogPath) for debugging.";
+"Yes" = "Yes";
+"\\(detail.modelCode): \\(usage)" = "\\(detail.modelCode): \\(usage)";
+"\\(name): \\(truncated)" = "\\(name): \\(truncated)";
+"\\(name): \\(updated) · 30d \\(cost)" = "\\(name): \\(updated) · 30d \\(cost)";
+"\\(name): fetching…\\(elapsed)" = "\\(name): fetching…\\(elapsed)";
+"\\(name): last attempt \\(when)" = "\\(name): last attempt \\(when)";
+"\\(name): no data yet" = "\\(name): no data yet";
+"\\(name): unsupported" = "\\(name): unsupported";
+"all browsers" = "all browsers";
+"available again." = "available again.";
+"built_format" = "Built %@";
+"copilot_complete_in_browser" = "Complete sign in in your browser.";
+"copilot_device_code" = "Device code copied to clipboard: %1$@\n\nVerify at: %2$@";
+"copilot_device_code_copied" = "Device code copied.";
+"copilot_verify_at" = "Verify at %@";
+"copilot_waiting_text" = "Complete sign in in your browser.\nThis window closes automatically when sign-in completes.";
+"copilot_window_closes_auto" = "This window closes automatically when sign-in completes.";
+"cost_status_error" = "%1$@: %2$@";
+"cost_status_fetching" = "%1$@: fetching… %2$@";
+"cost_status_last_attempt" = "%1$@: last attempt %2$@";
+"cost_status_no_data" = "%@: no data yet";
+"cost_status_snapshot" = "%1$@: %2$@ · %3$@ %4$@";
+"cost_status_unsupported" = "%@: unsupported";
+"credits_remaining" = "Credits: %@";
+"cursor_on_demand" = "On-demand: %@";
+"cursor_on_demand_with_limit" = "On-demand: %1$@ / %2$@";
+"extra_usage_format" = "Extra usage: %1$@ / %2$@";
+"jetbrains_detected_generate" = "Detected: %@. Use the AI assistant once to generate quota data, then refresh CodexBar.";
+"jetbrains_detected_select" = "Detected: %@. Select your preferred IDE in Settings, then refresh CodexBar.";
+"last_fetch_failed_with_provider" = "Last %@ fetch failed:";
+"last_spend" = "Last spend: %@";
+"mcp_model_usage" = "%1$@: %2$@";
+"mcp_resets" = "Resets: %@";
+"mcp_window" = "Window: %@";
+"metric_average" = "Average (%1$@ + %2$@)";
+"metric_primary" = "Primary (%@)";
+"metric_secondary" = "Secondary (%@)";
+"metric_tertiary" = "Tertiary (%@)";
+"multiple_workspaces_found" = "CodexBar found multiple workspaces for %@. Please choose the workspace to add.";
+"ory_session_…=…; csrftoken=…" = "ory_session_…=…; csrftoken=…";
+"overview_choose_providers" = "Choose up to %@ providers";
+"remove_account_message" = "Remove %@ from CodexBar? Its managed Codex home will be deleted.";
+"version_format" = "Version %@";
+"vertex_ai_login_instructions" = "To track Vertex AI usage, authenticate with Google Cloud.\n\n1. Open Terminal\n2. Run: gcloud auth application-default login\n3. Follow the browser prompts to sign in\n4. Set your project: gcloud config set project PROJECT_ID\n\nOpen Terminal now?";
+"workspaceID is set but only opencode, opencodego, and deepgram support workspaceID." = "workspaceID is set but only opencode, opencodego, and deepgram support workspaceID.";
+"© 2026 Peter Steinberger. MIT License." = "© 2026 Peter Steinberger. MIT License.";
+
+/* General Pane */
+"section_system" = "System";
+"section_usage" = "Usage";
+"section_automation" = "Automation";
+"language_title" = "Language";
+"language_subtitle" = "Change the display language. Requires app restart to take full effect.";
+"language_system" = "System";
+"language_english" = "English";
+"language_spanish" = "Español";
+"language_catalan" = "Català";
+"language_chinese_simplified" = "简体中文";
+"language_chinese_traditional" = "繁體中文";
+"language_portuguese_brazilian" = "Português (Brasil)";
+"language_dutch" = "Nederlands";
+"language_german" = "Deutsch";
+"language_swedish" = "Svenska";
+"language_french" = "French";
+"language_ukrainian" = "Українська";
+"language_japanese" = "Japanese";
+"language_korean" = "Korean";
+"language_turkish" = "Türkçe";
+"language_italian" = "Italiano";
+"language_polish" = "Polski";
+"start_at_login_title" = "Start at Login";
+"start_at_login_subtitle" = "Automatically opens CodexBar when you start your Mac.";
+"show_cost_summary" = "Show cost summary";
+"show_cost_summary_subtitle" = "Reads local usage logs. Shows today + the selected history window in the menu.";
+"cost_history_days_title" = "History window: %d days";
+"cost_auto_refresh_info" = "Auto-refresh: hourly · Timeout: 10m";
+"refresh_cadence_title" = "Refresh cadence";
+"refresh_cadence_subtitle" = "How often CodexBar polls providers in the background.";
+"manual_refresh_hint" = "Auto-refresh is off; use the menu's Refresh command.";
+"check_provider_status_title" = "Check provider status";
+"check_provider_status_subtitle" = "Polls OpenAI/Claude status pages and Google Workspace for Gemini/Antigravity, surfacing incidents in the icon and menu.";
+"session_quota_notifications_title" = "Session quota notifications";
+"session_quota_notifications_subtitle" = "Notifies when the 5-hour session quota hits 0% and when it becomes available again.";
+"quota_warning_notifications_title" = "Quota warning notifications";
+"quota_warning_notifications_subtitle" = "Warns when session or weekly quota remaining crosses configured thresholds.";
+"quota_warnings_title" = "Quota warnings";
+"quota_warning_session" = "session";
+"quota_warning_session_capitalized" = "Session";
+"quota_warning_weekly" = "weekly";
+"quota_warning_weekly_capitalized" = "Weekly";
+"quota_warning_notification_title" = "%1$@ %2$@ quota low";
+"quota_warning_notification_body" = "%1$@ left. Reached your %2$d%% %3$@ warning threshold.";
+"quota_warning_notification_body_with_account" = "Account %1$@. %2$@ left. Reached your %3$d%% %4$@ warning threshold.";
+"session_depleted_notification_title" = "%@ session depleted";
+"session_depleted_notification_body" = "0% left. Will notify when it's available again.";
+"session_restored_notification_title" = "%@ session restored";
+"session_restored_notification_body" = "Session quota is available again.";
+"quota_warning_warn_at" = "Warn at";
+"quota_warning_global_threshold_subtitle" = "Remaining percentages for session and weekly windows unless a provider overrides them.";
+"quota_warning_sound" = "Play notification sound";
+"quota_warning_provider_inherits" = "Uses the global quota warning settings unless a window is customized here.";
+"quota_warning_customize_thresholds" = "Customize %@ thresholds";
+"quota_warning_enable_warnings" = "Enable %@ warnings";
+"quota_warning_window_warn_at" = "%@ warn at";
+"quota_warning_off" = "Off";
+"quota_warning_inherited" = "Inherited: %@";
+"quota_warning_depleted_only" = "depleted only";
+"quota_warning_upper" = "Upper";
+"quota_warning_lower" = "Lower";
+"apply" = "Apply";
+"quit_app" = "Quit CodexBar";
+
+/* Tab titles */
+"tab_general" = "General";
+"tab_providers" = "Providers";
+"tab_display" = "Display";
+"tab_advanced" = "Advanced";
+"tab_about" = "About";
+"tab_debug" = "Debug";
+
+/* Providers Pane */
+"select_a_provider" = "Select a provider";
+"cancel" = "Cancel";
+"last_fetch_failed" = "last fetch failed";
+"usage_not_fetched_yet" = "usage not fetched yet";
+"managed_account_storage_unreadable" = "Managed account storage is unreadable. Live account access is still available, but managed add, re-auth, and remove actions are disabled until the store is recoverable.";
+"remove_codex_account_title" = "Remove Codex account?";
+"remove" = "Remove";
+"managed_login_already_running" = "A managed Codex login is already running. Wait for it to finish before adding or re-authenticating another account.";
+"managed_login_failed" = "Managed Codex login did not complete. Verify that `codex --version` works in Terminal. If macOS blocked or moved `codex` to Trash, remove stale duplicate installs, run `npm install -g --include=optional @openai/codex@latest`, then try again.";
+"codex_login_output" = "codex login output:";
+"managed_login_missing_email" = "Codex login completed, but no account email was available. Try again after confirming the account is fully signed in.";
+"login_success_notification_title" = "%@ login successful";
+"login_success_notification_body" = "You can return to the app; authentication finished.";
+"workspace_selection_cancelled" = "CodexBar found multiple workspaces, but no workspace was selected.";
+"unsafe_managed_home" = "CodexBar refused to modify an unexpected managed home path: %@";
+"menu_bar_metric_title" = "Menu bar metric";
+"menu_bar_metric_subtitle" = "Choose which window drives the menu bar percent.";
+"menu_bar_metric_subtitle_deepseek" = "Shows the DeepSeek balance in the menu bar.";
+"menu_bar_metric_subtitle_moonshot" = "Shows the Moonshot / Kimi API balance in the menu bar.";
+"menu_bar_metric_subtitle_mistral" = "Shows current-month Mistral API spend in the menu bar.";
+"menu_bar_metric_subtitle_kimik2" = "Shows Kimi K2 API-key credits in the menu bar.";
+"automatic" = "Automatic";
+"primary_api_key_limit" = "Primary (API key limit)";
+
+/* Display Pane */
+"section_menu_bar" = "Menu bar";
+"merge_icons_title" = "Merge Icons";
+"merge_icons_subtitle" = "Use a single menu bar icon with a provider switcher.";
+"switcher_shows_icons_title" = "Switcher shows icons";
+"switcher_shows_icons_subtitle" = "Show provider icons in the switcher (otherwise show a weekly progress line).";
+"show_most_used_provider_title" = "Show most-used provider";
+"show_most_used_provider_subtitle" = "Menu bar auto-shows the provider closest to its rate limit.";
+"menu_bar_shows_percent_title" = "Menu bar shows percent";
+"menu_bar_shows_percent_subtitle" = "Replace critter bars with provider branding icons and a percentage.";
+"hide_critters_title" = "Hide critters";
+"hide_critters_subtitle" = "Show plain meter bars without the face and decorations.";
+"display_mode_title" = "Display mode";
+"display_mode_subtitle" = "Choose what to show in the menu bar (Pace shows usage vs. expected).";
+"section_menu_content" = "Menu content";
+"show_usage_as_used_title" = "Show usage as used";
+"show_usage_as_used_subtitle" = "Progress bars fill as you consume quota (instead of showing remaining).";
+"show_quota_warning_markers_title" = "Show quota warning markers";
+"show_quota_warning_markers_subtitle" = "Draw threshold tick marks on usage bars when quota warnings are configured.";
+"weekly_progress_work_days_title" = "Weekly progress work days";
+"weekly_progress_work_days_subtitle" = "Set work days for weekly usage-bar markers and pace calculations.";
+"show_reset_time_as_clock_title" = "Show reset time as clock";
+"show_reset_time_as_clock_subtitle" = "Display reset times as absolute clock values instead of countdowns.";
+"show_provider_changelog_links_title" = "Show provider changelog links";
+"show_provider_changelog_links_subtitle" = "Adds release-notes links for supported CLI-backed providers to the menu.";
+"show_credits_extra_usage_title" = "Show credits + extra usage";
+"show_credits_extra_usage_subtitle" = "Show Codex Credits and Claude Extra usage sections in the menu.";
+"show_all_token_accounts_title" = "Show all token accounts";
+"show_all_token_accounts_subtitle" = "Stack token accounts in the menu (otherwise show an account switcher bar).";
+"multi_account_layout_title" = "Multi-account layout";
+"multi_account_layout_subtitle" = "Choose segmented account switching or stacked account cards.";
+"multi_account_layout_segmented" = "Segmented";
+"multi_account_layout_stacked" = "Stacked";
+"overview_tab_providers_title" = "Overview tab providers";
+"configure" = "Configure…";
+"overview_enable_merge_icons_hint" = "Enable Merge Icons to configure Overview tab providers.";
+"overview_no_providers_hint" = "No enabled providers available for Overview.";
+"overview_rows_follow_order" = "Overview rows always follow provider order.";
+"overview_no_providers_selected" = "No providers selected";
+
+/* Advanced Pane */
+"section_keyboard_shortcut" = "Keyboard shortcut";
+"open_menu_shortcut_title" = "Open menu";
+"open_menu_shortcut_subtitle" = "Trigger the menu bar menu from anywhere.";
+"install_cli" = "Install CLI";
+"install_cli_subtitle" = "Symlink CodexBarCLI to /usr/local/bin and /opt/homebrew/bin as codexbar.";
+"cli_not_found" = "CodexBarCLI not found in app bundle.";
+"no_writable_bin_dirs" = "No writable bin dirs found.";
+"show_debug_settings_title" = "Show Debug Settings";
+"show_debug_settings_subtitle" = "Expose troubleshooting tools in the Debug tab.";
+"surprise_me_title" = "Surprise me";
+"surprise_me_subtitle" = "Check if you like your agents having some fun up there.";
+"weekly_limit_confetti_title" = "Weekly limit confetti";
+"weekly_limit_confetti_subtitle" = "Play full-screen confetti when weekly usage resets.";
+"hide_personal_info_title" = "Hide personal information";
+"hide_personal_info_subtitle" = "Obscure email addresses in the menu bar and menu UI.";
+"show_provider_storage_usage_title" = "Show provider storage usage";
+"show_provider_storage_usage_subtitle" = "Show local disk usage in menus. Scans known provider-owned paths in the background.";
+"section_keychain_access" = "Keychain access";
+"keychain_access_caption" = "Disable all Keychain reads and writes. Use this if macOS keeps prompting for 'Chrome/Brave/Edge Safe Storage' even after clicking Always Allow. Browser cookie import is unavailable while enabled; paste Cookie headers manually in Providers. Claude/Codex OAuth via the CLI still works.";
+"disable_keychain_access_title" = "Disable Keychain access";
+"disable_keychain_access_subtitle" = "Prevents any Keychain access while enabled.";
+
+/* About Pane */
+"about_tagline" = "May your tokens never run out—keep agent limits in view.";
+"link_github" = "GitHub";
+"link_website" = "Website";
+"link_twitter" = "Twitter";
+"link_email" = "Email";
+"check_updates_auto" = "Check for updates automatically";
+"update_channel" = "Update Channel";
+"check_for_updates" = "Check for Updates…";
+"updates_unavailable" = "Updates unavailable in this build.";
+"copyright" = "© 2026 Peter Steinberger. MIT License.";
+
+/* Debug Pane */
+"section_logging" = "Logging";
+"enable_file_logging" = "Enable file logging";
+"enable_file_logging_subtitle" = "Write logs to %@ for debugging.";
+"verbosity_title" = "Verbosity";
+"verbosity_subtitle" = "Controls how much detail is logged.";
+"open_log_file" = "Open log file";
+"force_animation_next_refresh" = "Force animation on next refresh";
+"force_animation_next_refresh_subtitle" = "Temporarily shows the loading animation after the next refresh.";
+"section_loading_animations" = "Loading animations";
+"loading_animations_caption" = "Pick a pattern and replay it in the menu bar. \"Random\" keeps the existing behavior.";
+"animation_random_default" = "Random (default)";
+"replay_selected_animation" = "Replay selected animation";
+"blink_now" = "Blink now";
+"section_probe_logs" = "Probe logs";
+"probe_logs_caption" = "Fetch the latest probe output for debugging; Copy keeps the full text.";
+"fetch_log" = "Fetch log";
+"copy" = "Copy";
+"save_to_file" = "Save to file";
+"load_parse_dump" = "Load parse dump";
+"rerun_provider_autodetect" = "Re-run provider autodetect";
+"loading" = "Loading…";
+"no_log_yet_fetch" = "No log yet. Fetch to load.";
+"section_fetch_strategy" = "Fetch strategy attempts";
+"fetch_strategy_caption" = "Last fetch pipeline decisions and errors for a provider.";
+"section_openai_cookies" = "OpenAI cookies";
+"openai_cookies_caption" = "Cookie import + WebKit scrape logs from the last OpenAI cookies attempt.";
+"no_log_yet" = "No log yet. Update OpenAI cookies in Providers → Codex to run an import.";
+"section_caches" = "Caches";
+"caches_caption" = "Clear cached cost scan results or browser cookie caches.";
+"clear_cookie_cache" = "Clear cookie cache";
+"clear_cost_cache" = "Clear cost cache";
+"section_notifications" = "Notifications";
+"notifications_caption" = "Trigger test notifications for the 5-hour session window (depleted/restored).";
+"post_depleted" = "Post depleted";
+"post_restored" = "Post restored";
+"section_cli_sessions" = "CLI sessions";
+"cli_sessions_caption" = "Keep Codex/Claude CLI sessions alive after a probe. Default exits once data is captured.";
+"keep_cli_sessions_alive" = "Keep CLI sessions alive";
+"keep_cli_sessions_alive_subtitle" = "Skip teardown between probes (debug-only).";
+"reset_cli_sessions" = "Reset CLI sessions";
+"section_error_simulation" = "Error simulation";
+"error_simulation_caption" = "Inject a fake error message into the menu card for layout testing.";
+"set_menu_error" = "Set menu error";
+"clear_menu_error" = "Clear menu error";
+"set_cost_error" = "Set cost error";
+"clear_cost_error" = "Clear cost error";
+"section_cli_paths" = "CLI paths";
+"cli_paths_caption" = "Resolved Codex binary and PATH layers; startup login PATH capture (short timeout).";
+"codex_binary" = "Codex binary";
+"claude_binary" = "Claude binary";
+"effective_path" = "Effective PATH";
+"unavailable" = "Unavailable";
+"login_shell_path" = "Login shell PATH (startup capture)";
+"cleared" = "Cleared.";
+"no_fetch_attempts" = "No fetch attempts yet.";
+"macOS Tahoe can block menu bar apps in System Settings → Menu Bar → Allow in the Menu Bar. CodexBar is running, but macOS may be hiding its icon. Open Menu Bar settings and turn CodexBar on." = "macOS Tahoe can block menu bar apps in System Settings → Menu Bar → Allow in the Menu Bar. CodexBar is running, but macOS may be hiding its icon. Open Menu Bar settings and turn CodexBar on.";
+
+/* Metric preferences */
+"metric_pref_automatic" = "Automatic";
+"metric_pref_primary" = "Primary";
+"metric_pref_secondary" = "Secondary";
+"metric_pref_tertiary" = "Tertiary";
+"metric_pref_extra_usage" = "Extra usage";
+"metric_pref_average" = "Average";
+"metric_mistral_payg" = "Pay-as-you-go";
+"metric_mistral_monthly_plan" = "Monthly Plan";
+
+/* Display modes */
+"display_mode_percent" = "Percent";
+"display_mode_pace" = "Pace";
+"display_mode_both" = "Both";
+"display_mode_reset_time" = "Reset time";
+"display_mode_percent_desc" = "Show remaining/used percentage (e.g. 45%)";
+"display_mode_pace_desc" = "Show pace indicator (e.g. +5%)";
+"display_mode_both_desc" = "Show both percentage and pace (e.g. 45% · +5%)";
+"display_mode_reset_time_desc" = "Show the reset time for the selected metric (e.g. ↻ 3:56 PM)";
+
+/* Provider status */
+"status_operational" = "Operational";
+"status_partial_outage" = "Partial outage";
+"status_major_outage" = "Major outage";
+"status_critical_issue" = "Critical issue";
+"status_maintenance" = "Maintenance";
+"status_unknown" = "Status unknown";
+
+/* Refresh frequency */
+"refresh_manual" = "Manual";
+"refresh_1min" = "1 min";
+"refresh_2min" = "2 min";
+"refresh_5min" = "5 min";
+"refresh_15min" = "15 min";
+"refresh_30min" = "30 min";
+
+/* Additional keys */
+"not_found" = "Not found";
+
+/* Cost estimation */
+"cost_header_estimated" = "Cost (estimated)";
+"cost_estimate_hint" = "Estimated from local logs · may differ from your bill";
+"No JetBrains IDE with AI Assistant detected. Install a JetBrains IDE and enable AI Assistant." = "No JetBrains IDE with AI Assistant detected. Install a JetBrains IDE and enable AI Assistant.";
+"OpenRouter API token not configured. Set OPENROUTER_API_KEY environment variable or configure in Settings." = "OpenRouter API token not configured. Set OPENROUTER_API_KEY environment variable or configure in Settings.";
+"z.ai API token not found. Set apiKey in ~/.codexbar/config.json or Z_AI_API_KEY." = "z.ai API token not found. Set apiKey in ~/.codexbar/config.json or Z_AI_API_KEY.";
+"Missing DeepSeek API key." = "Missing DeepSeek API key.";
+"%@ is unavailable in the current environment." = "%@ is unavailable in the current environment.";
+"All Systems Operational" = "All Systems Operational";
+"Last 30 days" = "Last 30 days";
+"Last 30 days:" = "Last 30 days:";
+"This month" = "This month";
+"Store multiple OpenAI API keys." = "Store multiple OpenAI API keys.";
+"Admin API key" = "Admin API key";
+"Open billing" = "Open billing";
+"Google accounts" = "Google accounts";
+"Store multiple Antigravity Google OAuth accounts for quick switching." = "Store multiple Antigravity Google OAuth accounts for quick switching.";
+"Add Google Account" = "Add Google Account";
+"Open Token Plan" = "Open Token Plan";
+"Text Generation" = "Text Generation";
+"Text to Speech" = "Text to Speech";
+"Music Generation" = "Music Generation";
+"Image Generation" = "Image Generation";
+"No local data found" = "No local data found";
+"Credits unavailable; keep Codex running to refresh." = "Credits unavailable; keep Codex running to refresh.";
+"No available fetch strategy for minimax." = "No available fetch strategy for minimax.";
+"No Cursor session found. Please log in to cursor.com in Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX, or Edge Canary. If you use Safari, grant CodexBar Full Disk Access in System Settings ▸ Privacy & Security. You can also sign in to Cursor from the CodexBar menu (Add / switch account)." = "No Cursor session found. Please log in to cursor.com in Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX, or Edge Canary. If you use Safari, grant CodexBar Full Disk Access in System Settings ▸ Privacy & Security. You can also sign in to Cursor from the CodexBar menu (Add / switch account).";
+"No OpenCode session cookies found in browsers." = "No OpenCode session cookies found in browsers.";
+"No available fetch strategy for %@." = "No available fetch strategy for %@.";
+"Today" = "Today";
+"Today tokens" = "Today tokens";
+"30d cost" = "30d cost";
+"30d tokens" = "30d tokens";
+"Latest tokens" = "Latest tokens";
+"Top model" = "Top model";
+"Storage" = "Storage";
+"Add Account..." = "Add Account...";
+"Usage Dashboard" = "Usage Dashboard";
+"Status Page" = "Status Page";
+"Settings..." = "Settings...";
+"About CodexBar" = "About CodexBar";
+"Quit" = "Quit";
+"Last %d day" = "Last %d day";
+"Last %d days" = "Last %d days";
+"%@ tokens" = "%@ tokens";
+"Latest billing day" = "Latest billing day";
+"Latest billing day (%@)" = "Latest billing day (%@)";
+"%@ left" = "%@ left";
+"Resets %@" = "Resets %@";
+"Resets in %@" = "Resets in %@";
+"Resets now" = "Resets now";
+"reset_tomorrow_format" = "tomorrow, %@";
+"Lasts until reset" = "Lasts until reset";
+"Updated %@" = "Updated %@";
+"Updated %@h ago" = "Updated %@h ago";
+"Updated %@m ago" = "Updated %@m ago";
+"Updated just now" = "Updated just now";
+"Projected empty in %@" = "Projected empty in %@";
+"Runs out in %@" = "Runs out in %@";
+"Pace: %@" = "Pace: %@";
+"Pace: %@ · %@" = "Pace: %@ · %@";
+"%@ · %@" = "%@ · %@";
+"≈ %d%% run-out risk" = "≈ %d%% run-out risk";
+"%d%% in deficit" = "%d%% in deficit";
+"%d%% in reserve" = "%d%% in reserve";
+"usage_percent_suffix_left" = "left";
+"usage_percent_suffix_used" = "used";
+"Store multiple DeepSeek API keys." = "Store multiple DeepSeek API keys.";
+"This week" = "This week";
+"Week" = "Week";
+"Month" = "Month";
+"Models" = "Models";
+"24h tokens" = "24h tokens";
+"Latest hour" = "Latest hour";
+"Peak hour" = "Peak hour";
+"Top method" = "Top method";
+"30d cash" = "30d cash";
+"30d billing history from MiniMax web session" = "30d billing history from MiniMax web session";
+"AWS Cost Explorer billing can lag." = "AWS Cost Explorer billing can lag.";
+"Rate limit: %d / %@" = "Rate limit: %d / %@";
+"Key remaining" = "Key remaining";
+"No limit set for the API key" = "No limit set for the API key";
+"API key limit unavailable right now" = "API key limit unavailable right now";
+"This month: %@ tokens" = "This month: %@ tokens";
+"No utilization data yet." = "No utilization data yet.";
+"No %@ utilization data yet." = "No %@ utilization data yet.";
+"%@: %@%% used" = "%@: %@%% used";
+"%dd" = "%dd";
+"today" = "today";
+"just now" = "just now";
+"On pace" = "On pace";
+"Runs out now" = "Runs out now";
+"Projected empty now" = "Projected empty now";
+"Switch Account..." = "Switch Account...";
+"Update ready, restart now?" = "Update ready, restart now?";
+"Daily" = "Daily";
+"Hourly Tokens" = "Hourly Tokens";
+"No data" = "No data";
+"No usage breakdown data available." = "No usage breakdown data available.";
+
+"Today: %@ · %@ tokens" = "Today: %@ · %@ tokens";
+"Today: %@" = "Today: %@";
+"Today: %@ tokens" = "Today: %@ tokens";
+"Last 30 days: %@ · %@ tokens" = "Last 30 days: %@ · %@ tokens";
+"Last 30 days: %@" = "Last 30 days: %@";
+"Est. total (30d): %@" = "Est. total (30d): %@";
+"Est. total (%@): %@" = "Est. total (%@): %@";
+"Hover a bar for details" = "Hover a bar for details";
+"%@: %@ · %@ tokens" = "%@: %@ · %@ tokens";
+"No providers selected for Overview." = "No providers selected for Overview.";
+"No overview data available." = "No overview data available.";
+"Auto uses the local IDE API first, then Google OAuth when the IDE is closed." = "Auto uses the local IDE API first, then Google OAuth when the IDE is closed.";
+"Login with Google" = "Login with Google";
+
+/* Popup panels */
+"No usage configured." = "No usage configured.";
+"Quota" = "Quota";
+"tokens" = "tokens";
+"requests" = "requests";
+"Latest" = "Latest";
+"Monthly" = "Monthly";
+"Sonnet" = "Sonnet";
+"Overages" = "Overages";
+"Activity" = "Activity";
+"Copied" = "Copied";
+"Copy error" = "Copy error";
+"Copy path" = "Copy path";
+"Extra usage spent" = "Extra usage spent";
+"Credits remaining" = "Credits remaining";
+"Using CLI fallback" = "Using CLI fallback";
+"Balance updates in near-real time (up to 5 min lag)" = "Balance updates in near-real time (up to 5 min lag)";
+"Daily billing data finalizes at 07:00 UTC" = "Daily billing data finalizes at 07:00 UTC";
+"%@ of %@ credits left" = "%@ of %@ credits left";
+"%@ of %@ bonus credits left" = "%@ of %@ bonus credits left";
+"%@ / %@ (%@ remaining)" = "%@ / %@ (%@ remaining)";
+"%@/%@ left" = "%@/%@ left";
+"Gemini Flash" = "Gemini Flash";
+"Regenerates %@" = "Regenerates %@";
+"used after next regen" = "used after next regen";
+"after next regen" = "after next regen";
+"Near full" = "Near full";
+"Full in ~1 regen" = "Full in ~1 regen";
+"Full in ~%.0f regens" = "Full in ~%.0f regens";
+"Overage usage" = "Overage usage";
+"Overage cost" = "Overage cost";
+"credits" = "credits";
+"Zen balance" = "Zen balance";
+"API spend" = "API spend";
+"Extra usage" = "Extra usage";
+"Quota usage" = "Quota usage";
+"Your spend" = "Your spend";
+"%.0f%% used" = "%.0f%% used";
+"Usage history (today)" = "Usage history (today)";
+"Usage history (%d days)" = "Usage history (%d days)";
+"%d percent remaining" = "%d percent remaining";
+"Unknown" = "Unknown";
+"stale data" = "stale data";
+"No credits history data." = "No credits history data.";
+"No credits history data available." = "No credits history data available.";
+"Credits history chart" = "Credits history chart";
+"%d days of credits data" = "%d days of credits data";
+"Usage breakdown chart" = "Usage breakdown chart";
+"%d days of usage data across %d services" = "%d days of usage data across %d services";
+"Cost history chart" = "Cost history chart";
+"%d days of cost data" = "%d days of cost data";
+"Plan utilization chart" = "Plan utilization chart";
+"%d utilization samples" = "%d utilization samples";
+"Hourly Usage" = "Hourly Usage";
+"Usage remaining" = "Usage remaining";
+"Usage used" = "Usage used";
+"API key verified. Ollama does not expose Cloud quota limits through the API." = "API key verified. Ollama does not expose Cloud quota limits through the API.";
+"Last 30 days: %@ tokens" = "Last 30 days: %@ tokens";
+"7d spend" = "7d spend";
+"30d spend" = "30d spend";
+"Cache read" = "Cache read";
+"Claude Admin API 30 day spend trend" = "Claude Admin API 30 day spend trend";
+"OpenRouter API key spend trend" = "OpenRouter API key spend trend";
+"z.ai hourly token trend" = "z.ai hourly token trend";
+"MiniMax 30 day token usage trend" = "MiniMax 30 day token usage trend";
+"Today cash" = "Today cash";
+"DeepSeek 30 day token usage trend" = "DeepSeek 30 day token usage trend";
+"cache-hit input" = "cache-hit input";
+"cache-miss input" = "cache-miss input";
+"output" = "output";
+"Requests" = "Requests";
+"Reported by OpenAI Admin API organization usage." = "Reported by OpenAI Admin API organization usage.";
+"Reported by Mistral billing usage." = "Reported by Mistral billing usage.";
+"Google OAuth" = "Google OAuth";
+"Add accounts via GitHub OAuth Device Flow on the selected host." = "Add accounts via GitHub OAuth Device Flow on the selected host.";
+"Stores each signed-in Google account for quick Antigravity switching. Uses Antigravity.app OAuth when available, or ANTIGRAVITY_OAUTH_CLIENT_ID and ANTIGRAVITY_OAUTH_CLIENT_SECRET as an override." = "Stores each signed-in Google account for quick Antigravity switching. Uses Antigravity.app OAuth when available, or ANTIGRAVITY_OAUTH_CLIENT_ID and ANTIGRAVITY_OAUTH_CLIENT_SECRET as an override.";
+"Manual cleanup: past sessions" = "Manual cleanup: past sessions";
+"Clearing removes past resume, continue, and rewind history." = "Clearing removes past resume, continue, and rewind history.";
+"Manual cleanup: file checkpoints" = "Manual cleanup: file checkpoints";
+"Clearing removes checkpoint restore data for previous edits." = "Clearing removes checkpoint restore data for previous edits.";
+"Manual cleanup: saved plans" = "Manual cleanup: saved plans";
+"Clearing removes old plan-mode files." = "Clearing removes old plan-mode files.";
+"Manual cleanup: debug logs" = "Manual cleanup: debug logs";
+"Clearing removes past debug logs." = "Clearing removes past debug logs.";
+"Manual cleanup: attachment cache" = "Manual cleanup: attachment cache";
+"Clearing removes cached large pastes or attached images." = "Clearing removes cached large pastes or attached images.";
+"Manual cleanup: session metadata" = "Manual cleanup: session metadata";
+"Clearing removes per-session environment metadata." = "Clearing removes per-session environment metadata.";
+"Manual cleanup: shell snapshots" = "Manual cleanup: shell snapshots";
+"Clearing removes leftover runtime shell snapshot files." = "Clearing removes leftover runtime shell snapshot files.";
+"Manual cleanup: legacy todos" = "Manual cleanup: legacy todos";
+"Clearing removes legacy per-session task lists." = "Clearing removes legacy per-session task lists.";
+"Manual cleanup: sessions" = "Manual cleanup: sessions";
+"Clearing removes past Codex session history." = "Clearing removes past Codex session history.";
+"Manual cleanup: archived sessions" = "Manual cleanup: archived sessions";
+"Clearing removes archived Codex session history." = "Clearing removes archived Codex session history.";
+"Manual cleanup: cache" = "Manual cleanup: cache";
+"Clearing removes provider-owned cached data." = "Clearing removes provider-owned cached data.";
+"Manual cleanup: logs" = "Manual cleanup: logs";
+"Clearing removes local diagnostic logs." = "Clearing removes local diagnostic logs.";
+"Manual cleanup: file history" = "Manual cleanup: file history";
+"Clearing removes local edit checkpoint history." = "Clearing removes local edit checkpoint history.";
+"Manual cleanup: temporary data" = "Manual cleanup: temporary data";
+"Clearing removes local temporary provider data." = "Clearing removes local temporary provider data.";
+"Total: %@" = "Total: %@";
+"%d more items" = "%d more items";
+"Other (%d items)" = "Other (%d items)";
+"Expand" = "Expand";
+"Collapse" = "Collapse";
+"Cleanup ideas" = "Cleanup ideas";
+"%d unreadable item(s) skipped" = "%d unreadable item(s) skipped";
+
+"API key limit" = "API key limit";
+"Auth" = "Auth";
+"Auto" = "Auto";
+"Disabled — no recent data" = "Disabled — no recent data";
+"Limits not available" = "Limits not available";
+"No usage yet" = "No usage yet";
+"Not fetched yet" = "Not fetched yet";
+"Refreshing" = "Refreshing";
+"Session" = "Session";
+"Source" = "Source";
+"State" = "State";
+"Unavailable" = "Unavailable";
+"Weekly" = "Weekly";
+"not detected" = "not detected";
+"Estimated from local Codex logs for the selected account." = "Estimated from local Codex logs for the selected account.";
+"minimax_usage_amount_format" = "Usage: %@ / %@";
+"minimax_used_percent_format" = "Used %@";
+"minimax_service_text_generation" = "Text Generation";
+"minimax_service_text_to_speech" = "Text to Speech";
+"minimax_service_music_generation" = "Music Generation";
+"minimax_service_image_generation" = "Image Generation";
+"minimax_service_lyrics_generation" = "Lyrics generation";
+"minimax_service_coding_plan_vlm" = "Coding plan VLM";
+"minimax_service_coding_plan_search" = "Coding plan search";
+
+/* Additional provider settings and alerts */
+"%@ is waiting for permission" = "%@ is waiting for permission";
+"%@ requests" = "%@ requests";
+"%@: %@ credits" = "%@: %@ credits";
+"30d requests" = "30d requests";
+"4 days" = "4 days";
+"5 days" = "5 days";
+"7 days" = "7 days";
+"API key verifies Ollama Cloud access; cookies still expose quota limits." = "API key verifies Ollama Cloud access; cookies still expose quota limits.";
+"AWS access key ID. Can also be set with AWS_ACCESS_KEY_ID." = "AWS access key ID. Can also be set with AWS_ACCESS_KEY_ID.";
+"AWS region. Can also be set with AWS_REGION." = "AWS region. Can also be set with AWS_REGION.";
+"AWS secret access key. Can also be set with AWS_SECRET_ACCESS_KEY." = "AWS secret access key. Can also be set with AWS_SECRET_ACCESS_KEY.";
+"Access key ID" = "Access key ID";
+"Add Account" = "Add Account";
+"Adding Account…" = "Adding Account…";
+"Antigravity login failed" = "Antigravity login failed";
+"Antigravity login timed out" = "Antigravity login timed out";
+"Auth source" = "Auth source";
+"Automatic imports browser cookies from Xiaomi MiMo." = "Automatic imports browser cookies from Xiaomi MiMo.";
+"Automatic imports Windsurf session data from Chromium browser localStorage." = "Automatic imports Windsurf session data from Chromium browser localStorage.";
+"Automatic imports browser cookies from Bailian." = "Automatic imports browser cookies from Bailian.";
+"Automatically imports browser cookies." = "Automatically imports browser cookies.";
+"Automatically imports browser session cookies." = "Automatically imports browser session cookies.";
+"Azure OpenAI deployment name. AZURE_OPENAI_DEPLOYMENT_NAME is also supported." = "Azure OpenAI deployment name. AZURE_OPENAI_DEPLOYMENT_NAME is also supported.";
+"Azure OpenAI key" = "Azure OpenAI key";
+"Azure OpenAI resource endpoint. AZURE_OPENAI_ENDPOINT is also supported." = "Azure OpenAI resource endpoint. AZURE_OPENAI_ENDPOINT is also supported.";
+"Base URL" = "Base URL";
+"Base URL for the LLM-API-Key-Proxy instance." = "Base URL for the LLM-API-Key-Proxy instance.";
+"Browser cookies" = "Browser cookies";
+"Cap end" = "Cap end";
+"Cap start" = "Cap start";
+"Capacity End" = "Capacity End";
+"Capacity Start" = "Capacity Start";
+"Changelog" = "Changelog";
+"Choose the Moonshot/Kimi API host for international or China mainland accounts." = "Choose the Moonshot/Kimi API host for international or China mainland accounts.";
+"CodexBar can't replace a system account that is signed in with an API key only setup." = "CodexBar can't replace a system account that is signed in with an API key only setup.";
+"CodexBar could not find saved auth for that account. Re-authenticate it and try again." = "CodexBar could not find saved auth for that account. Re-authenticate it and try again.";
+"CodexBar could not read managed account storage. Recover the store before adding another account." = "CodexBar could not read managed account storage. Recover the store before adding another account.";
+"CodexBar could not read saved auth for that account. Re-authenticate it and try again." = "CodexBar could not read saved auth for that account. Re-authenticate it and try again.";
+"CodexBar could not read the current system account on this Mac." = "CodexBar could not read the current system account on this Mac.";
+"CodexBar could not replace the live Codex auth on this Mac." = "CodexBar could not replace the live Codex auth on this Mac.";
+"CodexBar could not safely preserve the current system account before switching." = "CodexBar could not safely preserve the current system account before switching.";
+"CodexBar could not save the current system account before switching." = "CodexBar could not save the current system account before switching.";
+"CodexBar could not update managed account storage." = "CodexBar could not update managed account storage.";
+"CodexBar found another managed account that already uses the current system account. Resolve the duplicate account before switching." = "CodexBar found another managed account that already uses the current system account. Resolve the duplicate account before switching.";
+"CodexBar will ask macOS Keychain for “%@” so it can decrypt browser cookies and authenticate your account. Click OK to continue." = "CodexBar will ask macOS Keychain for “%@” so it can decrypt browser cookies and authenticate your account. Click OK to continue.";
+"CodexBar will ask macOS Keychain for the Claude Code OAuth token so it can fetch your Claude usage. Click OK to continue." = "CodexBar will ask macOS Keychain for the Claude Code OAuth token so it can fetch your Claude usage. Click OK to continue.";
+"CodexBar will ask macOS Keychain for your Amp cookie header so it can fetch usage. Click OK to continue." = "CodexBar will ask macOS Keychain for your Amp cookie header so it can fetch usage. Click OK to continue.";
+"CodexBar will ask macOS Keychain for your Augment cookie header so it can fetch usage. Click OK to continue." = "CodexBar will ask macOS Keychain for your Augment cookie header so it can fetch usage. Click OK to continue.";
+"CodexBar will ask macOS Keychain for your Claude cookie header so it can fetch Claude web usage. Click OK to continue." = "CodexBar will ask macOS Keychain for your Claude cookie header so it can fetch Claude web usage. Click OK to continue.";
+"CodexBar will ask macOS Keychain for your Cursor cookie header so it can fetch usage. Click OK to continue." = "CodexBar will ask macOS Keychain for your Cursor cookie header so it can fetch usage. Click OK to continue.";
+"CodexBar will ask macOS Keychain for your Factory cookie header so it can fetch usage. Click OK to continue." = "CodexBar will ask macOS Keychain for your Factory cookie header so it can fetch usage. Click OK to continue.";
+"CodexBar will ask macOS Keychain for your GitHub Copilot token so it can fetch usage. Click OK to continue." = "CodexBar will ask macOS Keychain for your GitHub Copilot token so it can fetch usage. Click OK to continue.";
+"CodexBar will ask macOS Keychain for your Kimi K2 API key so it can fetch usage. Click OK to continue." = "CodexBar will ask macOS Keychain for your Kimi K2 API key so it can fetch usage. Click OK to continue.";
+"CodexBar will ask macOS Keychain for your Kimi auth token so it can fetch usage. Click OK to continue." = "CodexBar will ask macOS Keychain for your Kimi auth token so it can fetch usage. Click OK to continue.";
+"CodexBar will ask macOS Keychain for your MiniMax API token so it can fetch usage. Click OK to continue." = "CodexBar will ask macOS Keychain for your MiniMax API token so it can fetch usage. Click OK to continue.";
+"CodexBar will ask macOS Keychain for your MiniMax cookie header so it can fetch usage. Click OK to continue." = "CodexBar will ask macOS Keychain for your MiniMax cookie header so it can fetch usage. Click OK to continue.";
+"CodexBar will ask macOS Keychain for your OpenAI cookie header so it can fetch Codex dashboard extras. Click OK to continue." = "CodexBar will ask macOS Keychain for your OpenAI cookie header so it can fetch Codex dashboard extras. Click OK to continue.";
+"CodexBar will ask macOS Keychain for your OpenCode cookie header so it can fetch usage. Click OK to continue." = "CodexBar will ask macOS Keychain for your OpenCode cookie header so it can fetch usage. Click OK to continue.";
+"CodexBar will ask macOS Keychain for your Synthetic API key so it can fetch usage. Click OK to continue." = "CodexBar will ask macOS Keychain for your Synthetic API key so it can fetch usage. Click OK to continue.";
+"CodexBar will ask macOS Keychain for your z.ai API token so it can fetch usage. Click OK to continue." = "CodexBar will ask macOS Keychain for your z.ai API token so it can fetch usage. Click OK to continue.";
+"Could not open Cursor login in your browser." = "Could not open Cursor login in your browser.";
+"Could not open browser for Antigravity" = "Could not open browser for Antigravity";
+"Credits used" = "Credits used";
+"Day" = "Day";
+"Deployment" = "Deployment";
+"Drag to reorder" = "Drag to reorder";
+"Sort providers alphabetically" = "Sort providers alphabetically";
+"Sort providers alphabetically (enabled first)" = "Sort providers alphabetically (enabled first)";
+"Sorted alphabetically (enabled first) — click to use your custom order" = "Sorted alphabetically (enabled first) — click to use your custom order";
+"Endpoint" = "Endpoint";
+"Enterprise host" = "Enterprise host";
+"Extra usage balance: %@" = "Extra usage balance: %@";
+"Keychain Access Required" = "Keychain Access Required";
+"Kiro menu bar value" = "Kiro menu bar value";
+"Label" = "Label";
+"No organizations loaded. Click Refresh after setting your API key." = "No organizations loaded. Click Refresh after setting your API key.";
+"No output captured." = "No output captured.";
+"No system account" = "No system account";
+"Oasis-Token" = "Oasis-Token";
+"Open Augment (Log Out & Back In)" = "Open Augment (Log Out & Back In)";
+"Open Codebuff Dashboard" = "Open Codebuff Dashboard";
+"Open Command Code Settings" = "Open Command Code Settings";
+"Open Crof dashboard" = "Open Crof dashboard";
+"Open Manus" = "Open Manus";
+"Open MiMo Balance" = "Open MiMo Balance";
+"Open Moonshot Console" = "Open Moonshot Console";
+"Open Ollama API Keys" = "Open Ollama API Keys";
+"Open StepFun Platform" = "Open StepFun Platform";
+"Open T3 Chat Settings" = "Open T3 Chat Settings";
+"Open Volcengine Ark Console" = "Open Volcengine Ark Console";
+"Open legacy provider docs" = "Open legacy provider docs";
+"Open projects" = "Open projects";
+"Open this URL manually to continue login:\n\n%@" = "Open this URL manually to continue login:\n\n%@";
+"Optional organization ID for accounts linked to multiple Anthropic organizations." = "Optional organization ID for accounts linked to multiple Anthropic organizations.";
+"Optional. Applies to the configured Admin API key; selected token accounts do not inherit OPENAI_PROJECT_ID." = "Optional. Applies to the configured Admin API key; selected token accounts do not inherit OPENAI_PROJECT_ID.";
+"Optional. Enter your GitHub Enterprise host, for example octocorp.ghe.com. Leave blank for github.com." = "Optional. Enter your GitHub Enterprise host, for example octocorp.ghe.com. Leave blank for github.com.";
+"Optional. Leave blank to discover and aggregate projects visible to the API key." = "Optional. Leave blank to discover and aggregate projects visible to the API key.";
+"Org ID (optional)" = "Org ID (optional)";
+"Organizations" = "Organizations";
+"Password" = "Password";
+"%@ authentication is disabled." = "%@ authentication is disabled.";
+"%@ cookies are disabled." = "%@ cookies are disabled.";
+"%@ web API access is disabled." = "%@ web API access is disabled.";
+"Disable %@ dashboard cookie usage." = "Disable %@ dashboard cookie usage.";
+"Keychain access is disabled in Advanced, so browser cookie import is unavailable." = "Keychain access is disabled in Advanced, so browser cookie import is unavailable.";
+"Manually paste an %@ from a browser session." = "Manually paste an %@ from a browser session.";
+"Paste a Cookie header captured from %@." = "Paste a Cookie header captured from %@.";
+"Paste a Cookie header from %@." = "Paste a Cookie header from %@.";
+"Paste a Cookie header or cURL capture from %@." = "Paste a Cookie header or cURL capture from %@.";
+"Paste a Cookie header or full cURL capture from %@." = "Paste a Cookie header or full cURL capture from %@.";
+"Paste a Cookie or Authorization header from %@." = "Paste a Cookie or Authorization header from %@.";
+"Paste a full cookie header or the %@ value." = "Paste a full cookie header or the %@ value.";
+"Paste a Cookie header or full cURL capture from T3 Chat settings." = "Paste a Cookie header or full cURL capture from T3 Chat settings.";
+"Paste the Cookie header from a request to admin.mistral.ai. Must contain an ory_session_* cookie." = "Paste the Cookie header from a request to admin.mistral.ai. Must contain an ory_session_* cookie.";
+"Paste the Oasis-Token from a logged-in browser session on platform.stepfun.com." = "Paste the Oasis-Token from a logged-in browser session on platform.stepfun.com.";
+"Paste the %@ JSON bundle from %@." = "Paste the %@ JSON bundle from %@.";
+"Paste the %@ value or a full Cookie header." = "Paste the %@ value or a full Cookie header.";
+"Personal account" = "Personal account";
+"Project ID" = "Project ID";
+"Re-auth" = "Re-auth";
+"Re-login at claude.ai" = "Re-login at claude.ai";
+"Re-authenticating…" = "Re-authenticating…";
+"Refresh Session" = "Refresh Session";
+"Refresh organizations" = "Refresh organizations";
+"Region" = "Region";
+"Reload" = "Reload";
+"Reorder" = "Reorder";
+"Secret access key" = "Secret access key";
+"Series" = "Series";
+"Service" = "Service";
+"Show or hide Kiro credits, percent, or both next to the menu bar icon." = "Show or hide Kiro credits, percent, or both next to the menu bar icon.";
+"Show usage for organizations you belong to. Personal account is always shown." = "Show usage for organizations you belong to. Personal account is always shown.";
+"Sign in to cursor.com in your browser, then refresh Cursor in CodexBar." = "Sign in to cursor.com in your browser, then refresh Cursor in CodexBar.";
+"Simulated error text" = "Simulated error text";
+"StepFun platform account (phone number or email)." = "StepFun platform account (phone number or email).";
+"Stored in ~/.codexbar/config.json." = "Stored in ~/.codexbar/config.json.";
+"Stored in ~/.codexbar/config.json. AZURE_OPENAI_API_KEY is also supported." = "Stored in ~/.codexbar/config.json. AZURE_OPENAI_API_KEY is also supported.";
+"Stored in ~/.codexbar/config.json. For the official Kimi API, use Moonshot / Kimi API." = "Stored in ~/.codexbar/config.json. For the official Kimi API, use Moonshot / Kimi API.";
+"Stored in ~/.codexbar/config.json. Get your API key from the Volcengine Ark console." = "Stored in ~/.codexbar/config.json. Get your API key from the Volcengine Ark console.";
+"Stored in ~/.codexbar/config.json. Get your key from Ollama settings." = "Stored in ~/.codexbar/config.json. Get your key from Ollama settings.";
+"Stored in ~/.codexbar/config.json. Get your key from console.deepgram.com." = "Stored in ~/.codexbar/config.json. Get your key from console.deepgram.com.";
+"Stored in ~/.codexbar/config.json. Get your key from elevenlabs.io/app/settings/api-keys." = "Stored in ~/.codexbar/config.json. Get your key from elevenlabs.io/app/settings/api-keys.";
+"Stored in ~/.codexbar/config.json. Get your key from openrouter.ai/settings/keys and set a key spending limit there to enable API key quota tracking." = "Stored in ~/.codexbar/config.json. Get your key from openrouter.ai/settings/keys and set a key spending limit there to enable API key quota tracking.";
+"Stored in ~/.codexbar/config.json. In Warp, open Settings > Platform > API Keys, then create one." = "Stored in ~/.codexbar/config.json. In Warp, open Settings > Platform > API Keys, then create one.";
+"Stored in ~/.codexbar/config.json. Metrics require Groq Enterprise Prometheus access." = "Stored in ~/.codexbar/config.json. Metrics require Groq Enterprise Prometheus access.";
+"Stored in ~/.codexbar/config.json. OPENAI_ADMIN_KEY is preferred; OPENAI_API_KEY still works." = "Stored in ~/.codexbar/config.json. OPENAI_ADMIN_KEY is preferred; OPENAI_API_KEY still works.";
+"Stored in ~/.codexbar/config.json. Requires an Anthropic Admin API key." = "Stored in ~/.codexbar/config.json. Requires an Anthropic Admin API key.";
+"Stored in ~/.codexbar/config.json. Used for /v1/quota-stats." = "Stored in ~/.codexbar/config.json. Used for /v1/quota-stats.";
+"Stored in ~/.codexbar/config.json. You can also provide CODEBUFF_API_KEY or let CodexBar read ~/.config/manicode/credentials.json (created by `codebuff login`)." = "Stored in ~/.codexbar/config.json. You can also provide CODEBUFF_API_KEY or let CodexBar read ~/.config/manicode/credentials.json (created by `codebuff login`).";
+"Stored in ~/.codexbar/config.json. You can also provide CROF_API_KEY." = "Stored in ~/.codexbar/config.json. You can also provide CROF_API_KEY.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or ~/.local/share/kilo/auth.json (kilo.access)." = "Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or ~/.local/share/kilo/auth.json (kilo.access).";
+"T3 Chat cookie" = "T3 Chat cookie";
+"That account is no longer available in CodexBar. Refresh the account list and try again." = "That account is no longer available in CodexBar. Refresh the account list and try again.";
+"The browser login did not complete in time. Try Antigravity login again." = "The browser login did not complete in time. Try Antigravity login again.";
+"Timed out waiting for Cursor login. %@" = "Timed out waiting for Cursor login. %@";
+"Timed out waiting for Cursor login. %@ Last error: %@" = "Timed out waiting for Cursor login. %@ Last error: %@";
+"Today requests" = "Today requests";
+"Total (30d): %@ credits" = "Total (30d): %@ credits";
+"Username" = "Username";
+"Uses username + password to login and obtain an Oasis-Token automatically." = "Uses username + password to login and obtain an Oasis-Token automatically.";
+"Uses username + password to login and obtain an %@ automatically." = "Uses username + password to login and obtain an %@ automatically.";
+"Utilization End" = "Utilization End";
+"Utilization Start" = "Utilization Start";
+"Verbosity" = "Verbosity";
+"Windsurf session JSON bundle" = "Windsurf session JSON bundle";
+"Workspace ID" = "Workspace ID";
+"Your StepFun platform password. Used to login and obtain a session token." = "Your StepFun platform password. Used to login and obtain a session token.";
+"claude /login exited with status %d." = "claude /login exited with status %d.";
+"codex login exited with status %d." = "codex login exited with status %d.";
+"Cookie: …\n\nor paste a cURL capture from the Abacus AI dashboard" = "Cookie: …\n\nor paste a cURL capture from the Abacus AI dashboard";
+"Cookie: …\n\nor paste the __Secure-next-auth.session-token value" = "Cookie: …\n\nor paste the __Secure-next-auth.session-token value";
+"Cookie: …\n\nor paste the kimi-auth token value" = "Cookie: …\n\nor paste the kimi-auth token value";
+"session_id=...\n\nor paste just the session_id value" = "session_id=...\n\nor paste just the session_id value";
+"Clear" = "Clear";
+"No matching providers" = "No matching providers";
+"Search providers" = "Search providers";
+
+"language_vietnamese" = "Vietnamese";
+"language_indonesian" = "Bahasa Indonesia";
+
+"Request quota: %@ / %@" = "Request quota: %@ / %@";
+"language_arabic" = "العربية";
+"language_persian" = "فارسی";
+"language_thai" = "ไทย";
+"Limit Reset Credits" = "Limit Reset Credits";
+"1 manual reset available" = "1 manual reset available";
+"%d manual resets available" = "%d manual resets available";
+"Next expires %@" = "Next expires %@";
+"byte_unit_byte" = "byte";
+"byte_unit_bytes" = "bytes";
+"byte_unit_kilobyte" = "kilobyte";
+"byte_unit_kilobytes" = "kilobytes";
+"byte_unit_megabyte" = "megabyte";
+"byte_unit_megabytes" = "megabytes";
+"byte_unit_gigabyte" = "gigabyte";
+"byte_unit_gigabytes" = "gigabytes";
diff --git a/Sources/CodexBar/Resources/es.lproj/Localizable.strings b/Sources/CodexBar/Resources/es.lproj/Localizable.strings
new file mode 100644
index 0000000000..a48add1d0e
--- /dev/null
+++ b/Sources/CodexBar/Resources/es.lproj/Localizable.strings
@@ -0,0 +1,965 @@
+/* Spanish localization for CodexBar */
+
+" providers" = " proveedores";
+"(System)" = "(Sistema)";
+"30d" = "30 d";
+"A managed Codex login is already running. Wait for it to finish before adding " = "Ya hay un inicio de sesión gestionado de Codex en curso. Espera a que termine antes de añadir ";
+"API key" = "Clave de API";
+"API region" = "Región de API";
+"API token" = "Token de API";
+"API tokens" = "Tokens de API";
+"About" = "Acerca de";
+"Account" = "Cuenta";
+"Accounts" = "Cuentas";
+"Accounts subtitle" = "Subtítulo de cuentas";
+"Active" = "Activo";
+"Add" = "Añadir";
+"Add Workspace" = "Añadir espacio de trabajo";
+"Advanced" = "Avanzado";
+"All" = "Todo";
+"Always allow prompts" = "Permitir siempre las solicitudes";
+"Animation pattern" = "Patrón de animación";
+"Antigravity login is managed in the app" = "El inicio de sesión de Antigravity se gestiona en la app";
+"Applies only to the Security.framework OAuth keychain reader." = "Solo se aplica al lector de Llavero OAuth de Security.framework.";
+"Auto falls back to the next source if the preferred one fails." = "Auto recurre a la siguiente fuente si la preferida falla.";
+"Auto uses API first, then falls back to CLI on auth failures." = "Auto usa primero la API y recurre a la CLI si falla la autenticación.";
+"Auto-detect" = "Detección automática";
+"Auto-refresh is off; use the menu's Refresh command." = "La actualización automática está desactivada; usa el comando Actualizar del menú.";
+"Auto-refresh: hourly · Timeout: 10m" = "Actualización automática: cada hora · Tiempo de espera: 10 m";
+"Automatic" = "Automático";
+"Automatic imports browser cookies and WorkOS tokens." = "El modo automático importa cookies del navegador y tokens de WorkOS.";
+"Automatic imports browser cookies and local storage tokens." = "El modo automático importa cookies del navegador y tokens del almacenamiento local.";
+"Automatic imports browser cookies for dashboard extras." = "El modo automático importa cookies del navegador para los extras del panel.";
+"Automatic imports browser cookies for the web API." = "El modo automático importa cookies del navegador para la API web.";
+"Automatic imports browser cookies from Model Studio/Bailian." = "El modo automático importa cookies del navegador desde Model Studio/Bailian.";
+"Automatic imports browser cookies from admin.mistral.ai." = "El modo automático importa cookies del navegador desde admin.mistral.ai.";
+"Automatic imports browser cookies from opencode.ai." = "El modo automático importa cookies del navegador desde opencode.ai.";
+"Automatic imports browser cookies or stored sessions." = "El modo automático importa cookies del navegador o sesiones guardadas.";
+"Automatic imports browser cookies." = "El modo automático importa cookies del navegador.";
+"Automatically imports browser session cookie." = "Importa automáticamente la cookie de sesión del navegador.";
+"Automatically opens CodexBar when you start your Mac." = "Abre CodexBar automáticamente al iniciar tu Mac.";
+"Automation" = "Automatización";
+"Average (\\(label1) + \\(label2))" = "Promedio (\\(label1) + \\(label2))";
+"Average (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))" = "Promedio (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))";
+"Avoid Keychain prompts" = "Evitar solicitudes del Llavero";
+"Balance" = "Saldo";
+"Battery Saver" = "Ahorro de batería";
+"Bordered" = "Con borde";
+"Build" = "Compilación";
+"Built \\(buildTimestamp)" = "Compilado \\(buildTimestamp)";
+"Buy Credits..." = "Comprar créditos...";
+"Buy Credits…" = "Comprar créditos…";
+"CLI paths" = "Rutas de la CLI";
+"CLI sessions" = "Sesiones de la CLI";
+"Caches" = "Cachés";
+"Cancel" = "Cancelar";
+"Check for Updates…" = "Buscar actualizaciones…";
+"Check for updates automatically" = "Buscar actualizaciones automáticamente";
+"Check if you like your agents having some fun up there." = "Actívalo si te gusta que tus agentes se diviertan ahí arriba.";
+"Check provider status" = "Comprobar estado del proveedor";
+"Choose Codex workspace" = "Elegir espacio de trabajo de Codex";
+"Choose the MiniMax host (global .io or China mainland .com)." = "Elige el host de MiniMax (global .io o China continental .com).";
+"Choose up to " = "Elige hasta ";
+"Choose up to \\(Self.maxOverviewProviders) providers" = "Elige hasta \\(Self.maxOverviewProviders) proveedores";
+"Choose up to \\(count) providers" = "Elige hasta \\(count) proveedores";
+"Choose what to show in the menu bar (Pace shows usage vs. expected)." = "Elige qué mostrar en la barra de menús (Ritmo muestra el uso frente al previsto).";
+"Choose which Codex account CodexBar should follow." = "Elige qué cuenta de Codex debe seguir CodexBar.";
+"Choose which window drives the menu bar percent." = "Elige qué ventana determina el porcentaje de la barra de menús.";
+"Chrome" = "Chrome";
+"Claude CLI not found" = "No se encontró la CLI de Claude";
+"Claude binary" = "Binario de Claude";
+"Claude cookies" = "Cookies de Claude";
+"Claude login failed" = "El inicio de sesión de Claude falló";
+"Claude login timed out" = "El inicio de sesión de Claude agotó el tiempo de espera";
+"Close" = "Cerrar";
+"Codex CLI not found" = "No se encontró la CLI de Codex";
+"Codex account login already running" = "Ya hay un inicio de sesión de cuenta de Codex en curso";
+"Codex binary" = "Binario de Codex";
+"Codex login failed" = "El inicio de sesión de Codex falló";
+"Codex login timed out" = "El inicio de sesión de Codex agotó el tiempo de espera";
+"CodexBar Lifecycle Keepalive" = "Mantenimiento del ciclo de vida de CodexBar";
+"CodexBar can't show its menu bar icon" = "CodexBar no puede mostrar su icono en la barra de menús";
+"CodexBar could not read managed account storage. " = "CodexBar no pudo leer el almacenamiento de cuentas gestionadas. ";
+"Configure…" = "Configurar…";
+"Connected" = "Conectado";
+"Controls how much detail is logged." = "Controla cuánto detalle se registra.";
+"Cookie header" = "Cabecera de cookie";
+"Cookie source" = "Origen de la cookie";
+"Cookie: ..." = "Cookie: ...";
+"Cookie: \\u{2026}\\\n\\\nor paste a cURL capture from the Abacus AI dashboard" = "Cookie: \\u{2026}\\\n\\\no pega una captura cURL del panel de Abacus AI";
+"Cookie: \\u{2026}\\\n\\\nor paste the __Secure-next-auth.session-token value" = "Cookie: \\u{2026}\\\n\\\no pega el valor de __Secure-next-auth.session-token";
+"Cookie: \\u{2026}\\\n\\\nor paste the kimi-auth token value" = "Cookie: \\u{2026}\\\n\\\no pega el valor del token kimi-auth";
+"Cookie: …" = "Cookie: …";
+"CopilotDeviceFlow" = "CopilotDeviceFlow";
+"Cost" = "Coste";
+"Could not add Codex account" = "No se pudo añadir la cuenta de Codex";
+"Could not open Terminal for Gemini" = "No se pudo abrir la Terminal para Gemini";
+"Could not start claude /login" = "No se pudo iniciar claude /login";
+"Could not start codex login" = "No se pudo iniciar codex login";
+"Could not switch system account" = "No se pudo cambiar la cuenta del sistema";
+"Credits" = "Créditos";
+"Individual credits" = "Créditos individuales";
+"Workspace" = "Espacio de trabajo";
+"Credits history" = "Historial de créditos";
+"Cursor login failed" = "El inicio de sesión de Cursor falló";
+"Custom" = "Personalizado";
+"Custom Path" = "Ruta personalizada";
+"Daily Routines" = "Rutinas diarias";
+"Debug" = "Depuración";
+"Default" = "Predeterminado";
+"Disable Keychain access" = "Desactivar el acceso al Llavero";
+"Disabled" = "Desactivado";
+"Dismiss" = "Descartar";
+"Disconnected" = "Desconectado";
+"Display" = "Pantalla";
+"Display mode" = "Modo de visualización";
+"Display reset times as absolute clock values instead of countdowns." = "Mostrar las horas de reinicio como valores de reloj absolutos en lugar de cuentas atrás.";
+"Done" = "Listo";
+"Effective PATH" = "PATH efectivo";
+"Email" = "Correo electrónico";
+"Enable Merge Icons to configure Overview tab providers." = "Activa Combinar iconos para configurar los proveedores de la pestaña Resumen.";
+"Enable file logging" = "Activar registro en archivo";
+"Enabled" = "Activado";
+"Error" = "Error";
+"Error simulation" = "Simulación de errores";
+"Expose troubleshooting tools in the Debug tab." = "Muestra herramientas de diagnóstico en la pestaña Depuración.";
+"Failed" = "Falló";
+"False" = "Falso";
+"Fetch strategy attempts" = "Intentos de estrategia de obtención";
+"Fetching" = "Obteniendo";
+"Field" = "Campo";
+"Field subtitle" = "Subtítulo del campo";
+"Finish the current managed account change before switching the system account." = "Termina el cambio de cuenta gestionada actual antes de cambiar la cuenta del sistema.";
+"Force animation on next refresh" = "Forzar animación en la próxima actualización";
+"Gateway region" = "Región de la pasarela";
+"Gemini CLI not found" = "No se encontró la CLI de Gemini";
+"Gemini/Antigravity, surfacing incidents in the icon and menu." = "Gemini/Antigravity, mostrando incidencias en el icono y el menú.";
+"General" = "General";
+"GitHub" = "GitHub";
+"GitHub Copilot Login" = "Inicio de sesión de GitHub Copilot";
+"GitHub Login" = "Inicio de sesión de GitHub";
+"Hide details" = "Ocultar detalles";
+"Hide personal information" = "Ocultar información personal";
+"Historical tracking" = "Seguimiento histórico";
+"How often CodexBar polls providers in the background." = "Con qué frecuencia CodexBar consulta a los proveedores en segundo plano.";
+"Inactive" = "Inactivo";
+"Install CLI" = "Instalar CLI";
+"Install the Claude CLI (npm i -g @anthropic-ai/claude-code) and try again." = "Instala la CLI de Claude (npm i -g @anthropic-ai/claude-code) e inténtalo de nuevo.";
+"Install the Codex CLI (npm i -g @openai/codex) and try again." = "Instala la CLI de Codex (npm i -g @openai/codex) e inténtalo de nuevo.";
+"Install the Gemini CLI (npm i -g @google/gemini-cli) and try again." = "Instala la CLI de Gemini (npm i -g @google/gemini-cli) e inténtalo de nuevo.";
+"JetBrains AI is ready" = "JetBrains AI está listo";
+"JetBrains IDE" = "IDE de JetBrains";
+"Keep CLI sessions alive" = "Mantener activas las sesiones de la CLI";
+"Keyboard shortcut" = "Atajo de teclado";
+"Keychain access" = "Acceso al Llavero";
+"Keychain prompt policy" = "Política de solicitudes del Llavero";
+"Last \\(name) fetch failed:" = "La última obtención de \\(name) falló:";
+"Last \\(self.store.metadata(for: self.provider).displayName) fetch failed:" = "La última obtención de \\(self.store.metadata(for: self.provider).displayName) falló:";
+"Last attempt" = "Último intento";
+"Link" = "Enlace";
+"Loading animations" = "Animaciones de carga";
+"Loading…" = "Cargando…";
+"Local" = "Local";
+"Logging" = "Registro";
+"Login failed" = "El inicio de sesión falló";
+"Login shell PATH (startup capture)" = "PATH del shell de inicio (captura al arrancar)";
+"Login timed out" = "El inicio de sesión agotó el tiempo de espera";
+"MCP details" = "Detalles de MCP";
+"Managed Codex accounts unavailable" = "Cuentas gestionadas de Codex no disponibles";
+"Managed account storage is unreadable. Live account access is still available, " = "El almacenamiento de cuentas gestionadas no se puede leer. El acceso a cuentas en vivo sigue disponible, ";
+"Manual" = "Manual";
+"May your tokens never run out—keep agent limits in view." = "Que tus tokens nunca se agoten: mantén los límites de tus agentes a la vista.";
+"Menu bar" = "Barra de menús";
+"Menu bar auto-shows the provider closest to its rate limit." = "La barra de menús muestra automáticamente el proveedor más cercano a su límite.";
+"Menu bar metric" = "Métrica de la barra de menús";
+"Menu bar shows percent" = "La barra de menús muestra el porcentaje";
+"Menu content" = "Contenido del menú";
+"Merge Icons" = "Combinar iconos";
+"Never prompt" = "No solicitar nunca";
+"No" = "No";
+"No Codex accounts detected yet." = "Aún no se han detectado cuentas de Codex.";
+"No JetBrains IDE detected" = "No se detectó ningún IDE de JetBrains";
+"No cost history data." = "No hay datos de historial de coste.";
+"No credits history data." = "No hay datos de historial de créditos.";
+"No data available" = "No hay datos disponibles";
+"No data yet" = "Aún no hay datos";
+"No enabled providers available for Overview." = "No hay proveedores activados disponibles para Resumen.";
+"No providers selected" = "No hay proveedores seleccionados";
+"No token accounts yet." = "Aún no hay cuentas con token.";
+"No usage breakdown data." = "No hay datos de desglose de uso.";
+"None" = "Ninguno";
+"Notifications" = "Notificaciones";
+"Notifies when the 5-hour session quota hits 0% and when it becomes " = "Avisa cuando la cuota de sesión de 5 horas llega al 0 % y cuando vuelve a estar ";
+"OK" = "Aceptar";
+"Obscure email addresses in the menu bar and menu UI." = "Oculta las direcciones de correo en la barra de menús y la interfaz del menú.";
+"Off" = "Desactivado";
+"Offline" = "Sin conexión";
+"On" = "Activado";
+"Online" = "En línea";
+"Only on user action" = "Solo en acciones del usuario";
+"Open" = "Abrir";
+"Open API Keys" = "Abrir claves de API";
+"Open Amp Settings" = "Abrir ajustes de Amp";
+"Open Antigravity to sign in, then refresh CodexBar." = "Abre Antigravity para iniciar sesión y luego actualiza CodexBar.";
+"Open Browser" = "Abrir navegador";
+"Open Coding Plan" = "Abrir plan de programación";
+"Open Console" = "Abrir Consola";
+"Open Dashboard" = "Abrir panel";
+"Open Mistral Admin" = "Abrir administración de Mistral";
+"Open Menu Bar Settings" = "Abrir ajustes de la barra de menús";
+"Open Ollama Settings" = "Abrir ajustes de Ollama";
+"Open Terminal" = "Abrir Terminal";
+"Open Usage Page" = "Abrir página de uso";
+"Open Warp API Key Guide" = "Abrir la guía de la clave de API de Warp";
+"Open menu" = "Abrir menú";
+"Open token file" = "Abrir archivo de token";
+"OpenAI cookies" = "Cookies de OpenAI";
+"OpenAI web extras" = "Extras web de OpenAI";
+"Option A" = "Opción A";
+"Option B" = "Opción B";
+"Optional override if workspace lookup fails." = "Anulación opcional si falla la búsqueda del espacio de trabajo.";
+"Options" = "Opciones";
+"Override auto-detection with a custom IDE base path" = "Anular la detección automática con una ruta base de IDE personalizada";
+"Overview" = "Resumen";
+"Overview rows always follow provider order." = "Las filas de Resumen siempre siguen el orden de los proveedores.";
+"Overview tab providers" = "Proveedores de la pestaña Resumen";
+"Paste API key…" = "Pega la clave de API…";
+"Paste API token…" = "Pega el token de API…";
+"Paste key…" = "Pega la clave…";
+"Paste sessionKey or OAuth token…" = "Pega la sessionKey o el token OAuth…";
+"Paste the Cookie header from a request to admin.mistral.ai. " = "Pega la cabecera Cookie de una petición a admin.mistral.ai. ";
+"Paste token…" = "Pega el token…";
+"Personal" = "Personal";
+"Picker" = "Selector";
+"Picker subtitle" = "Subtítulo del selector";
+"Placeholder" = "Marcador de posición";
+"Plan" = "Plan";
+"Play full-screen confetti when weekly usage resets." = "Mostrar confeti a pantalla completa cuando se reinicia el uso semanal.";
+"Polls OpenAI/Claude status pages and Google Workspace for " = "Consulta las páginas de estado de OpenAI/Claude y Google Workspace para ";
+"Prevents any Keychain access while enabled." = "Impide cualquier acceso al Llavero mientras esté activado.";
+"Primary (API key limit)" = "Principal (límite de la clave de API)";
+"Primary (\\(label))" = "Principal (\\(label))";
+"Primary (\\(metadata.sessionLabel))" = "Principal (\\(metadata.sessionLabel))";
+"Probe logs" = "Registros de sondeo";
+"Progress bars fill as you consume quota (instead of showing remaining)." = "Las barras de progreso se llenan a medida que consumes la cuota (en lugar de mostrar lo restante).";
+"Provider" = "Proveedor";
+"Providers" = "Proveedores";
+"Quit CodexBar" = "Salir de CodexBar";
+"Random (default)" = "Aleatorio (predeterminado)";
+"Reads local usage logs. Shows today + last 30 days cost in the menu." = "Lee los registros de uso locales. Muestra el coste de hoy + la ventana de historial seleccionada en el menú.";
+"Refresh" = "Actualizar";
+"Refresh cadence" = "Frecuencia de actualización";
+"Remote" = "Remoto";
+"Remove" = "Eliminar";
+"Remove Codex account?" = "¿Eliminar la cuenta de Codex?";
+"Remove \\(account.email) from CodexBar? Its managed Codex home will be deleted." = "¿Eliminar \\(account.email) de CodexBar? Su directorio Codex gestionado se borrará.";
+"Remove \\(email) from CodexBar? Its managed Codex home will be deleted." = "¿Eliminar \\(email) de CodexBar? Su directorio Codex gestionado se borrará.";
+"Remove selected account" = "Eliminar la cuenta seleccionada";
+"Replace critter bars with provider branding icons and a percentage." = "Sustituir las barras de bichitos por iconos de marca del proveedor y un porcentaje.";
+"Replay selected animation" = "Reproducir la animación seleccionada";
+"Requires authentication via GitHub Device Flow." = "Requiere autenticación mediante el flujo de dispositivo de GitHub.";
+"Resets: \\(reset)" = "Se reinicia: \\(reset)";
+"reset_tomorrow_format" = "mañana, %@";
+"Rolling five-hour limit" = "Límite móvil de cinco horas";
+"Search hourly" = "Búsquedas por hora";
+"Secondary (\\(label))" = "Secundario (\\(label))";
+"Secondary (\\(metadata.weeklyLabel))" = "Secundario (\\(metadata.weeklyLabel))";
+"Select a provider" = "Selecciona un proveedor";
+"Select the IDE to monitor" = "Selecciona el IDE a monitorizar";
+"Session quota notifications" = "Notificaciones de cuota de sesión";
+"Session tokens" = "Tokens de sesión";
+"Settings" = "Ajustes";
+"Show Codex Credits and Claude Extra usage sections in the menu." = "Mostrar las secciones de Créditos de Codex y Uso adicional de Claude en el menú.";
+"Show Debug Settings" = "Mostrar ajustes de depuración";
+"Show all token accounts" = "Mostrar todas las cuentas con token";
+"Show cost summary" = "Mostrar resumen de coste";
+"Show credits + extra usage" = "Mostrar créditos + uso adicional";
+"Show details" = "Mostrar detalles";
+"Show most-used provider" = "Mostrar el proveedor más usado";
+"Show provider icons in the switcher (otherwise show a weekly progress line)." = "Mostrar los iconos de proveedor en el selector (de lo contrario, mostrar una línea de progreso semanal).";
+"Show reset time as clock" = "Mostrar la hora de reinicio como reloj";
+"Show usage as used" = "Mostrar el uso como consumido";
+"Sign in via button below" = "Inicia sesión con el botón de abajo";
+"Skip teardown between probes (debug-only)." = "Omitir el cierre entre sondeos (solo depuración).";
+"Stack token accounts in the menu (otherwise show an account switcher bar)." = "Apilar las cuentas con token en el menú (de lo contrario, mostrar una barra de cambio de cuenta).";
+"Start at Login" = "Abrir al iniciar sesión";
+"Status" = "Estado";
+"Store Claude sessionKey cookies or OAuth access tokens." = "Almacena cookies sessionKey de Claude o tokens de acceso OAuth.";
+"Store multiple Abacus AI Cookie headers." = "Almacena varias cabeceras Cookie de Abacus AI.";
+"Store multiple Augment Cookie headers." = "Almacena varias cabeceras Cookie de Augment.";
+"Store multiple Cursor Cookie headers." = "Almacena varias cabeceras Cookie de Cursor.";
+"Store multiple Factory Cookie headers." = "Almacena varias cabeceras Cookie de Factory.";
+"Store multiple MiniMax Cookie headers." = "Almacena varias cabeceras Cookie de MiniMax.";
+"Store multiple Mistral Cookie headers." = "Almacena varias cabeceras Cookie de Mistral.";
+"Store multiple Ollama Cookie headers." = "Almacena varias cabeceras Cookie de Ollama.";
+"Store multiple OpenCode Cookie headers." = "Almacena varias cabeceras Cookie de OpenCode.";
+"Store multiple OpenCode Go Cookie headers." = "Almacena varias cabeceras Cookie de OpenCode Go.";
+"Stored in the CodexBar config file." = "Almacenado en el archivo de configuración de CodexBar.";
+"Stored in ~/.codexbar/config.json. " = "Almacenado en ~/.codexbar/config.json. ";
+"Stored in ~/.codexbar/config.json. Generate one at kimi-k2.ai." = "Almacenado en ~/.codexbar/config.json. Genera una en kimi-k2.ai.";
+"Stored in ~/.codexbar/config.json. Paste the key from the Synthetic dashboard." = "Almacenado en ~/.codexbar/config.json. Pega la clave del panel de Synthetic.";
+"Stored in ~/.codexbar/config.json. Paste your Coding Plan API key from Model Studio." = "Almacenado en ~/.codexbar/config.json. Pega tu clave de API del plan de programación desde Model Studio.";
+"Stored in ~/.codexbar/config.json. Paste your MiniMax API key." = "Almacenado en ~/.codexbar/config.json. Pega tu clave de API de MiniMax.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or " = "Almacenado en ~/.codexbar/config.json. También puedes proporcionar KILO_API_KEY o ";
+"Stores local Codex usage history (8 weeks) to personalize Pace predictions." = "Almacena el historial de uso local de Codex (8 semanas) para personalizar las predicciones de Ritmo.";
+"Subscription Utilization" = "Uso de la suscripción";
+"Surprise me" = "Sorpréndeme";
+"Switcher shows icons" = "El selector muestra iconos";
+"Symlink CodexBarCLI to /usr/local/bin and /opt/homebrew/bin as codexbar." = "Crear un enlace simbólico de CodexBarCLI en /usr/local/bin y /opt/homebrew/bin como codexbar.";
+"System" = "Sistema";
+"Temporarily shows the loading animation after the next refresh." = "Muestra temporalmente la animación de carga tras la próxima actualización.";
+"Tertiary (\\(label))" = "Terciario (\\(label))";
+"Tertiary (\\(tertiaryTitle))" = "Terciario (\\(tertiaryTitle))";
+"The default Codex account on this Mac." = "La cuenta de Codex predeterminada en este Mac.";
+"Toggle" = "Interruptor";
+"Toggle subtitle" = "Subtítulo del interruptor";
+"Token" = "Token";
+"Trigger the menu bar menu from anywhere." = "Abrir el menú de la barra de menús desde cualquier lugar.";
+"True" = "Verdadero";
+"Twitter" = "Twitter";
+"Unsupported" = "No compatible";
+"Update Channel" = "Canal de actualizaciones";
+"Updated" = "Actualizado";
+"Updates unavailable in this build." = "Actualizaciones no disponibles en esta compilación.";
+"Usage" = "Uso";
+"Usage breakdown" = "Desglose de uso";
+"Usage history (30 days)" = "Historial de uso";
+"Usage source" = "Origen del uso";
+"Use BigModel for the China mainland endpoints (open.bigmodel.cn)." = "Usar BigModel para los endpoints de China continental (open.bigmodel.cn).";
+"Use a single menu bar icon with a provider switcher." = "Usar un único icono en la barra de menús con un selector de proveedor.";
+"Use international or China mainland console gateways for quota fetches." = "Usar las pasarelas de consola internacionales o de China continental para obtener la cuota.";
+"Version" = "Versión";
+"Version \\(self.versionString)" = "Versión \\(self.versionString)";
+"Version \\(version)" = "Versión \\(version)";
+"Version \\(versionString)" = "Versión \\(versionString)";
+"Vertex AI Login" = "Inicio de sesión de Vertex AI";
+"Wait for the current managed Codex login to finish before adding another account." = "Espera a que termine el inicio de sesión gestionado de Codex actual antes de añadir otra cuenta.";
+"Waiting for Authentication..." = "Esperando la autenticación...";
+"Website" = "Sitio web";
+"Weekly limit confetti" = "Confeti del límite semanal";
+"Weekly token limit" = "Límite semanal de tokens";
+"Weekly usage" = "Uso semanal";
+"Weekly usage unavailable for this account." = "Uso semanal no disponible para esta cuenta.";
+"Window: \\(window)" = "Ventana: \\(window)";
+"Write logs to \\(self.fileLogPath) for debugging." = "Escribir registros en \\(self.fileLogPath) para depuración.";
+"Yes" = "Sí";
+"\\(detail.modelCode): \\(usage)" = "\\(detail.modelCode): \\(usage)";
+"\\(name): \\(truncated)" = "\\(name): \\(truncated)";
+"\\(name): \\(updated) · 30d \\(cost)" = "\\(name): \\(updated) · 30 d \\(cost)";
+"\\(name): fetching…\\(elapsed)" = "\\(name): obteniendo…\\(elapsed)";
+"\\(name): last attempt \\(when)" = "\\(name): último intento \\(when)";
+"\\(name): no data yet" = "\\(name): aún sin datos";
+"\\(name): unsupported" = "\\(name): no compatible";
+"all browsers" = "todos los navegadores";
+"available again." = "disponible de nuevo.";
+"built_format" = "Compilación %@";
+"copilot_complete_in_browser" = "Completa el inicio de sesión en tu navegador.";
+"copilot_device_code" = "Código de dispositivo copiado al portapapeles: %1$@\n\nVerifícalo en: %2$@";
+"copilot_device_code_copied" = "Código de dispositivo copiado.";
+"copilot_verify_at" = "Verifícalo en %@";
+"copilot_waiting_text" = "Completa el inicio de sesión en tu navegador.\nEsta ventana se cierra automáticamente cuando finaliza el inicio de sesión.";
+"copilot_window_closes_auto" = "Esta ventana se cierra automáticamente cuando finaliza el inicio de sesión.";
+"cost_status_error" = "%1$@: %2$@";
+"cost_status_fetching" = "%1$@: obteniendo… %2$@";
+"cost_status_last_attempt" = "%1$@: último intento %2$@";
+"cost_status_no_data" = "%@: aún sin datos";
+"cost_status_snapshot" = "%1$@: %2$@ · %3$@ %4$@";
+"cost_status_unsupported" = "%@: no compatible";
+"credits_remaining" = "Créditos: %@";
+"cursor_on_demand" = "Bajo demanda: %@";
+"cursor_on_demand_with_limit" = "Bajo demanda: %1$@ / %2$@";
+"extra_usage_format" = "Uso adicional: %1$@ / %2$@";
+"jetbrains_detected_generate" = "Detectado: %@. Usa el asistente de IA una vez para generar datos de cuota y luego actualiza CodexBar.";
+"jetbrains_detected_select" = "Detectado: %@. Selecciona tu IDE preferido en Ajustes y luego actualiza CodexBar.";
+"last_fetch_failed_with_provider" = "La última obtención de %@ falló:";
+"last_spend" = "Último gasto: %@";
+"mcp_model_usage" = "%1$@: %2$@";
+"mcp_resets" = "Se reinicia: %@";
+"mcp_window" = "Ventana: %@";
+"metric_average" = "Promedio (%1$@ + %2$@)";
+"metric_primary" = "Principal (%@)";
+"metric_secondary" = "Secundario (%@)";
+"metric_tertiary" = "Terciario (%@)";
+"multiple_workspaces_found" = "CodexBar encontró varios espacios de trabajo para %@. Elige el espacio de trabajo que añadir.";
+"ory_session_…=…; csrftoken=…" = "ory_session_…=…; csrftoken=…";
+"overview_choose_providers" = "Elige hasta %@ proveedores";
+"remove_account_message" = "¿Eliminar %@ de CodexBar? Su directorio Codex gestionado se borrará.";
+"version_format" = "Versión %@";
+"vertex_ai_login_instructions" = "Para hacer seguimiento del uso de Vertex AI, autentícate con Google Cloud.\n\n1. Abre la Terminal\n2. Ejecuta: gcloud auth application-default login\n3. Sigue las indicaciones del navegador para iniciar sesión\n4. Define tu proyecto: gcloud config set project PROJECT_ID\n\n¿Abrir la Terminal ahora?";
+"workspaceID is set but only opencode, opencodego, and deepgram support workspaceID." = "workspaceID está definido, pero solo opencode, opencodego y deepgram admiten workspaceID.";
+"© 2026 Peter Steinberger. MIT License." = "© 2026 Peter Steinberger. Licencia MIT.";
+
+/* General Pane */
+"section_system" = "Sistema";
+"section_usage" = "Uso";
+"section_automation" = "Automatización";
+"language_title" = "Idioma";
+"language_subtitle" = "Cambia el idioma de la interfaz. Requiere reiniciar la app para aplicarse por completo.";
+"language_system" = "Sistema";
+"language_english" = "English";
+"language_spanish" = "Español";
+"language_catalan" = "Català";
+"language_chinese_simplified" = "简体中文";
+"language_chinese_traditional" = "繁體中文";
+"language_portuguese_brazilian" = "Português (Brasil)";
+"language_swedish" = "Sueco";
+"language_dutch" = "Nederlands";
+"language_german" = "Deutsch";
+"language_french" = "Francés";
+"language_ukrainian" = "Ucraniano";
+"language_japanese" = "Japonés";
+"language_korean" = "Coreano";
+"language_italian" = "Italiano";
+"language_polish" = "Polski";
+"start_at_login_title" = "Abrir al iniciar sesión";
+"start_at_login_subtitle" = "Abre CodexBar automáticamente al iniciar tu Mac.";
+"show_cost_summary" = "Mostrar resumen de coste";
+"show_cost_summary_subtitle" = "Lee los registros de uso locales. Muestra el coste de hoy + la ventana de historial seleccionada en el menú.";
+"cost_history_days_title" = "Ventana de historial: %d días";
+"cost_auto_refresh_info" = "Actualización automática: cada hora · Tiempo de espera: 10 m";
+"refresh_cadence_title" = "Frecuencia de actualización";
+"refresh_cadence_subtitle" = "Con qué frecuencia CodexBar consulta a los proveedores en segundo plano.";
+"manual_refresh_hint" = "La actualización automática está desactivada; usa el comando Actualizar del menú.";
+"check_provider_status_title" = "Comprobar estado del proveedor";
+"check_provider_status_subtitle" = "Consulta las páginas de estado de OpenAI/Claude y Google Workspace para Gemini/Antigravity, mostrando incidencias en el icono y el menú.";
+"session_quota_notifications_title" = "Notificaciones de cuota de sesión";
+"session_quota_notifications_subtitle" = "Avisa cuando la cuota de sesión de 5 horas llega al 0 % y cuando vuelve a estar disponible.";
+"quota_warning_notifications_title" = "Notificaciones de aviso de cuota";
+"quota_warning_notifications_subtitle" = "Avisa cuando la cuota restante de sesión o semanal cruza los umbrales configurados.";
+"quota_warnings_title" = "Avisos de cuota";
+"quota_warning_session" = "sesión";
+"quota_warning_session_capitalized" = "Sesión";
+"quota_warning_weekly" = "semanal";
+"quota_warning_weekly_capitalized" = "Semanal";
+"quota_warning_warn_at" = "Avisar al";
+"quota_warning_global_threshold_subtitle" = "Porcentajes restantes para las ventanas de sesión y semanal, salvo que un proveedor los anule.";
+"quota_warning_sound" = "Reproducir sonido de notificación";
+"quota_warning_provider_inherits" = "Usa los ajustes globales de aviso de cuota salvo que se personalice una ventana aquí.";
+"quota_warning_customize_thresholds" = "Personalizar umbrales de %@";
+"quota_warning_enable_warnings" = "Activar avisos de %@";
+"quota_warning_window_warn_at" = "%@ avisar al";
+"quota_warning_off" = "Desactivado";
+"quota_warning_inherited" = "Heredado: %@";
+"quota_warning_depleted_only" = "solo agotado";
+"quota_warning_upper" = "Superior";
+"quota_warning_lower" = "Inferior";
+"apply" = "Aplicar";
+"quit_app" = "Salir de CodexBar";
+
+/* Tab titles */
+"tab_general" = "General";
+"tab_providers" = "Proveedores";
+"tab_display" = "Pantalla";
+"tab_advanced" = "Avanzado";
+"tab_about" = "Acerca de";
+"tab_debug" = "Depuración";
+
+/* Providers Pane */
+"select_a_provider" = "Selecciona un proveedor";
+"cancel" = "Cancelar";
+"last_fetch_failed" = "la última obtención falló";
+"usage_not_fetched_yet" = "uso aún no obtenido";
+"managed_account_storage_unreadable" = "El almacenamiento de cuentas gestionadas no se puede leer. El acceso a cuentas en vivo sigue disponible, pero las acciones de añadir, reautenticar y eliminar cuentas gestionadas están desactivadas hasta que el almacén se pueda recuperar.";
+"remove_codex_account_title" = "¿Eliminar la cuenta de Codex?";
+"remove" = "Eliminar";
+"managed_login_already_running" = "Ya hay un inicio de sesión gestionado de Codex en curso. Espera a que termine antes de añadir o reautenticar otra cuenta.";
+"managed_login_failed" = "El inicio de sesión gestionado de Codex no se completó. Comprueba que `codex --version` funciona en la Terminal. Si macOS bloqueó o movió `codex` a la Papelera, elimina instalaciones duplicadas obsoletas, ejecuta `npm install -g --include=optional @openai/codex@latest` y vuelve a intentarlo.";
+"codex_login_output" = "Salida de codex login:";
+"managed_login_missing_email" = "El inicio de sesión de Codex se completó, pero no había ningún correo de cuenta disponible. Inténtalo de nuevo tras confirmar que la cuenta tiene la sesión totalmente iniciada.";
+"workspace_selection_cancelled" = "CodexBar encontró varios espacios de trabajo, pero no se seleccionó ninguno.";
+"unsafe_managed_home" = "CodexBar se negó a modificar una ruta de directorio gestionado inesperada: %@";
+"menu_bar_metric_title" = "Métrica de la barra de menús";
+"menu_bar_metric_subtitle" = "Elige qué ventana determina el porcentaje de la barra de menús.";
+"menu_bar_metric_subtitle_deepseek" = "Muestra el saldo de DeepSeek en la barra de menús.";
+"menu_bar_metric_subtitle_moonshot" = "Muestra el saldo de la API de Moonshot / Kimi en la barra de menús.";
+"menu_bar_metric_subtitle_mistral" = "Muestra el gasto de la API de Mistral del mes actual en la barra de menús.";
+"menu_bar_metric_subtitle_kimik2" = "Muestra los créditos de la clave de API de Kimi K2 en la barra de menús.";
+"automatic" = "Automático";
+"primary_api_key_limit" = "Principal (límite de la clave de API)";
+
+/* Display Pane */
+"section_menu_bar" = "Barra de menús";
+"merge_icons_title" = "Combinar iconos";
+"merge_icons_subtitle" = "Usar un único icono en la barra de menús con un selector de proveedor.";
+"switcher_shows_icons_title" = "El selector muestra iconos";
+"switcher_shows_icons_subtitle" = "Mostrar los iconos de proveedor en el selector (de lo contrario, mostrar una línea de progreso semanal).";
+"show_most_used_provider_title" = "Mostrar el proveedor más usado";
+"show_most_used_provider_subtitle" = "La barra de menús muestra automáticamente el proveedor más cercano a su límite.";
+"menu_bar_shows_percent_title" = "La barra de menús muestra el porcentaje";
+"menu_bar_shows_percent_subtitle" = "Sustituir las barras de bichitos por iconos de marca del proveedor y un porcentaje.";
+"hide_critters_title" = "Ocultar bichitos";
+"hide_critters_subtitle" = "Mostrar barras de medición simples sin la cara ni las decoraciones.";
+"display_mode_title" = "Modo de visualización";
+"display_mode_subtitle" = "Elige qué mostrar en la barra de menús (Ritmo muestra el uso frente al previsto).";
+"section_menu_content" = "Contenido del menú";
+"show_usage_as_used_title" = "Mostrar el uso como consumido";
+"show_usage_as_used_subtitle" = "Las barras de progreso se llenan a medida que consumes la cuota (en lugar de mostrar lo restante).";
+"show_quota_warning_markers_title" = "Mostrar marcadores de aviso de cuota";
+"show_quota_warning_markers_subtitle" = "Dibuja marcas de umbral en las barras de uso cuando hay avisos de cuota configurados.";
+"weekly_progress_work_days_title" = "Días laborables del progreso semanal";
+"weekly_progress_work_days_subtitle" = "Define los días laborables para los marcadores de las barras de uso semanal y los cálculos de ritmo.";
+"show_reset_time_as_clock_title" = "Mostrar la hora de reinicio como reloj";
+"show_reset_time_as_clock_subtitle" = "Mostrar las horas de reinicio como valores de reloj absolutos en lugar de cuentas atrás.";
+"show_provider_changelog_links_title" = "Mostrar enlaces al registro de cambios del proveedor";
+"show_provider_changelog_links_subtitle" = "Añade al menú enlaces a las notas de versión de los proveedores compatibles basados en CLI.";
+"show_credits_extra_usage_title" = "Mostrar créditos + uso adicional";
+"show_credits_extra_usage_subtitle" = "Mostrar las secciones de Créditos de Codex y Uso adicional de Claude en el menú.";
+"show_all_token_accounts_title" = "Mostrar todas las cuentas con token";
+"show_all_token_accounts_subtitle" = "Apilar las cuentas con token en el menú (de lo contrario, mostrar una barra de cambio de cuenta).";
+"multi_account_layout_title" = "Diseño multicuenta";
+"multi_account_layout_subtitle" = "Elige cambio de cuenta segmentado o tarjetas de cuenta apiladas.";
+"multi_account_layout_segmented" = "Segmentado";
+"multi_account_layout_stacked" = "Apilado";
+"overview_tab_providers_title" = "Proveedores de la pestaña Resumen";
+"configure" = "Configurar…";
+"overview_enable_merge_icons_hint" = "Activa Combinar iconos para configurar los proveedores de la pestaña Resumen.";
+"overview_no_providers_hint" = "No hay proveedores activados disponibles para Resumen.";
+"overview_rows_follow_order" = "Las filas de Resumen siempre siguen el orden de los proveedores.";
+"overview_no_providers_selected" = "No hay proveedores seleccionados";
+
+/* Advanced Pane */
+"section_keyboard_shortcut" = "Atajo de teclado";
+"open_menu_shortcut_title" = "Abrir menú";
+"open_menu_shortcut_subtitle" = "Abrir el menú de la barra de menús desde cualquier lugar.";
+"install_cli" = "Instalar CLI";
+"install_cli_subtitle" = "Crear un enlace simbólico de CodexBarCLI en /usr/local/bin y /opt/homebrew/bin como codexbar.";
+"cli_not_found" = "No se encontró CodexBarCLI en el paquete de la app.";
+"no_writable_bin_dirs" = "No se encontraron directorios bin con permiso de escritura.";
+"show_debug_settings_title" = "Mostrar ajustes de depuración";
+"show_debug_settings_subtitle" = "Muestra herramientas de diagnóstico en la pestaña Depuración.";
+"surprise_me_title" = "Sorpréndeme";
+"surprise_me_subtitle" = "Actívalo si te gusta que tus agentes se diviertan ahí arriba.";
+"weekly_limit_confetti_title" = "Confeti del límite semanal";
+"weekly_limit_confetti_subtitle" = "Mostrar confeti a pantalla completa cuando se reinicia el uso semanal.";
+"hide_personal_info_title" = "Ocultar información personal";
+"hide_personal_info_subtitle" = "Oculta las direcciones de correo en la barra de menús y la interfaz del menú.";
+"show_provider_storage_usage_title" = "Mostrar uso de almacenamiento del proveedor";
+"show_provider_storage_usage_subtitle" = "Muestra el uso de disco local en los menús. Analiza en segundo plano las rutas conocidas del proveedor.";
+"section_keychain_access" = "Acceso al Llavero";
+"keychain_access_caption" = "Desactiva todas las lecturas y escrituras del Llavero. La importación de cookies del navegador no estará disponible; pega las cabeceras Cookie manualmente en Proveedores.";
+"disable_keychain_access_title" = "Desactivar el acceso al Llavero";
+"disable_keychain_access_subtitle" = "Impide cualquier acceso al Llavero mientras esté activado.";
+
+/* About Pane */
+"about_tagline" = "Que tus tokens nunca se agoten: mantén los límites de tus agentes a la vista.";
+"link_github" = "GitHub";
+"link_website" = "Sitio web";
+"link_twitter" = "Twitter";
+"link_email" = "Correo electrónico";
+"check_updates_auto" = "Buscar actualizaciones automáticamente";
+"update_channel" = "Canal de actualizaciones";
+"check_for_updates" = "Buscar actualizaciones…";
+"updates_unavailable" = "Actualizaciones no disponibles en esta compilación.";
+"copyright" = "© 2026 Peter Steinberger. Licencia MIT.";
+
+/* Debug Pane */
+"section_logging" = "Registro";
+"enable_file_logging" = "Activar registro en archivo";
+"enable_file_logging_subtitle" = "Escribir registros en %@ para depuración.";
+"verbosity_title" = "Nivel de detalle";
+"verbosity_subtitle" = "Controla cuánto detalle se registra.";
+"open_log_file" = "Abrir archivo de registro";
+"force_animation_next_refresh" = "Forzar animación en la próxima actualización";
+"force_animation_next_refresh_subtitle" = "Muestra temporalmente la animación de carga tras la próxima actualización.";
+"section_loading_animations" = "Animaciones de carga";
+"loading_animations_caption" = "Elige un patrón y reprodúcelo en la barra de menús. «Aleatorio» mantiene el comportamiento actual.";
+"animation_random_default" = "Aleatorio (predeterminado)";
+"replay_selected_animation" = "Reproducir la animación seleccionada";
+"blink_now" = "Parpadear ahora";
+"section_probe_logs" = "Registros de sondeo";
+"probe_logs_caption" = "Obtén la salida de sondeo más reciente para depuración; Copiar conserva el texto completo.";
+"fetch_log" = "Obtener registro";
+"copy" = "Copiar";
+"save_to_file" = "Guardar en archivo";
+"load_parse_dump" = "Cargar volcado de análisis";
+"rerun_provider_autodetect" = "Reejecutar la autodetección de proveedores";
+"loading" = "Cargando…";
+"no_log_yet_fetch" = "Aún no hay registro. Obtén para cargar.";
+"section_fetch_strategy" = "Intentos de estrategia de obtención";
+"fetch_strategy_caption" = "Últimas decisiones y errores del flujo de obtención de un proveedor.";
+"section_openai_cookies" = "Cookies de OpenAI";
+"openai_cookies_caption" = "Registros de importación de cookies y extracción con WebKit del último intento de cookies de OpenAI.";
+"no_log_yet" = "Aún no hay registro. Actualiza las cookies de OpenAI en Proveedores → Codex para ejecutar una importación.";
+"section_caches" = "Cachés";
+"caches_caption" = "Borra los resultados de análisis de coste en caché o las cachés de cookies del navegador.";
+"clear_cookie_cache" = "Borrar caché de cookies";
+"clear_cost_cache" = "Borrar caché de coste";
+"section_notifications" = "Notificaciones";
+"notifications_caption" = "Lanza notificaciones de prueba para la ventana de sesión de 5 horas (agotada/restaurada).";
+"post_depleted" = "Enviar agotada";
+"post_restored" = "Enviar restaurada";
+"section_cli_sessions" = "Sesiones de la CLI";
+"cli_sessions_caption" = "Mantén activas las sesiones de la CLI de Codex/Claude tras un sondeo. Por defecto se cierran cuando se capturan los datos.";
+"keep_cli_sessions_alive" = "Mantener activas las sesiones de la CLI";
+"keep_cli_sessions_alive_subtitle" = "Omitir el cierre entre sondeos (solo depuración).";
+"reset_cli_sessions" = "Reiniciar sesiones de la CLI";
+"section_error_simulation" = "Simulación de errores";
+"error_simulation_caption" = "Inyecta un mensaje de error falso en la tarjeta del menú para probar el diseño.";
+"set_menu_error" = "Establecer error de menú";
+"clear_menu_error" = "Borrar error de menú";
+"set_cost_error" = "Establecer error de coste";
+"clear_cost_error" = "Borrar error de coste";
+"section_cli_paths" = "Rutas de la CLI";
+"cli_paths_caption" = "Binario de Codex resuelto y capas de PATH; captura del PATH de inicio de sesión al arrancar (tiempo de espera corto).";
+"codex_binary" = "Binario de Codex";
+"claude_binary" = "Binario de Claude";
+"effective_path" = "PATH efectivo";
+"unavailable" = "No disponible";
+"login_shell_path" = "PATH del shell de inicio (captura al arrancar)";
+"cleared" = "Borrado.";
+"no_fetch_attempts" = "Aún no hay intentos de obtención.";
+"macOS Tahoe can block menu bar apps in System Settings → Menu Bar → Allow in the Menu Bar. CodexBar is running, but macOS may be hiding its icon. Open Menu Bar settings and turn CodexBar on." = "macOS Tahoe puede bloquear apps de la barra de menús en Ajustes del Sistema → Barra de menús → Permitir en la barra de menús. CodexBar está en ejecución, pero macOS podría estar ocultando su icono. Abre los ajustes de la barra de menús y activa CodexBar.";
+
+/* Metric preferences */
+"metric_pref_automatic" = "Automático";
+"metric_pref_primary" = "Principal";
+"metric_pref_secondary" = "Secundario";
+"metric_pref_tertiary" = "Terciario";
+"metric_pref_extra_usage" = "Uso adicional";
+"metric_pref_average" = "Promedio";
+"metric_mistral_payg" = "Pay-as-you-go";
+"metric_mistral_monthly_plan" = "Monthly Plan";
+
+/* Display modes */
+"display_mode_percent" = "Porcentaje";
+"display_mode_pace" = "Ritmo";
+"display_mode_both" = "Ambos";
+"display_mode_reset_time" = "Tiempo de restablecimiento";
+"display_mode_percent_desc" = "Mostrar el porcentaje restante/usado (p. ej. 45 %)";
+"display_mode_pace_desc" = "Mostrar el indicador de ritmo (p. ej. +5 %)";
+"display_mode_both_desc" = "Mostrar porcentaje y ritmo (p. ej. 45 % · +5 %)";
+"display_mode_reset_time_desc" = "Mostrar el tiempo de restablecimiento de la métrica seleccionada (p. ej. ↻ 3:56 PM)";
+
+/* Provider status */
+"status_operational" = "Operativo";
+"status_partial_outage" = "Interrupción parcial";
+"status_major_outage" = "Interrupción grave";
+"status_critical_issue" = "Problema crítico";
+"status_maintenance" = "Mantenimiento";
+"status_unknown" = "Estado desconocido";
+
+/* Refresh frequency */
+"refresh_manual" = "Manual";
+"refresh_1min" = "1 min";
+"refresh_2min" = "2 min";
+"refresh_5min" = "5 min";
+"refresh_15min" = "15 min";
+"refresh_30min" = "30 min";
+
+/* Additional keys */
+"not_found" = "No encontrado";
+
+/* Cost estimation */
+"cost_header_estimated" = "Coste (estimado)";
+"cost_estimate_hint" = "Estimado a partir de registros locales · puede diferir de tu factura";
+
+/* Popup panels */
+"No usage configured." = "No hay uso configurado.";
+"Quota" = "Cuota";
+"tokens" = "tokens";
+"requests" = "solicitudes";
+"Latest" = "Último";
+"Monthly" = "Mensual";
+"Sonnet" = "Sonnet";
+"Auth" = "Autenticación";
+"Overages" = "Excesos";
+"Activity" = "Actividad";
+"Copied" = "Copiado";
+"Copy error" = "Error al copiar";
+"Copy path" = "Copiar ruta";
+"Extra usage spent" = "Gasto de uso adicional";
+"Credits remaining" = "Créditos restantes";
+"Using CLI fallback" = "Usando alternativa de CLI";
+"Balance updates in near-real time (up to 5 min lag)" = "El saldo se actualiza casi en tiempo real (hasta 5 min de retraso)";
+"Daily billing data finalizes at 07:00 UTC" = "Los datos diarios de facturación se cierran a las 07:00 UTC";
+"%@ of %@ credits left" = "Quedan %@ de %@ créditos";
+"%@ of %@ bonus credits left" = "Quedan %@ de %@ créditos de bonificación";
+"%@ / %@ (%@ remaining)" = "%@ / %@ (%@ restante)";
+"%@/%@ left" = "%@/%@ restante";
+"Gemini Flash" = "Gemini Flash";
+"Regenerates %@" = "Se regenera %@";
+"used after next regen" = "usado tras la próxima regeneración";
+"after next regen" = "tras la próxima regeneración";
+"Near full" = "Casi lleno";
+"Full in ~1 regen" = "Lleno en ~1 regeneración";
+"Full in ~%.0f regens" = "Lleno en ~%.0f regeneraciones";
+"Overage usage" = "Uso excedente";
+"Overage cost" = "Coste excedente";
+"credits" = "créditos";
+"Zen balance" = "Saldo Zen";
+"API spend" = "Gasto de API";
+"Extra usage" = "Uso adicional";
+"Quota usage" = "Uso de cuota";
+"Your spend" = "Tu gasto";
+"%.0f%% used" = "%.0f%% usado";
+"Usage history (today)" = "Historial de uso (hoy)";
+"Usage history (%d days)" = "Historial de uso (%d días)";
+"%d percent remaining" = "%d%% restante";
+"Unknown" = "Desconocido";
+"stale data" = "datos obsoletos";
+"No credits history data available." = "No hay datos de historial de créditos disponibles.";
+"Credits history chart" = "Gráfico de historial de créditos";
+"%d days of credits data" = "%d días de datos de créditos";
+"Usage breakdown chart" = "Gráfico de desglose de uso";
+"%d days of usage data across %d services" = "%d días de datos de uso en %d servicios";
+"Cost history chart" = "Gráfico de historial de costes";
+"%d days of cost data" = "%d días de datos de costes";
+"Plan utilization chart" = "Gráfico de uso del plan";
+"%d utilization samples" = "%d muestras de uso";
+"Hourly Usage" = "Uso por hora";
+"Usage remaining" = "Uso restante";
+"Usage used" = "Uso utilizado";
+"API key verified. Ollama does not expose Cloud quota limits through the API." = "Clave de API verificada. Ollama no expone los límites de cuota de Cloud mediante la API.";
+"Last 30 days: %@ tokens" = "Últimos 30 días: %@ tokens";
+"7d spend" = "Gasto 7 d";
+"30d spend" = "Gasto 30 d";
+"Cache read" = "Lectura de caché";
+"Claude Admin API 30 day spend trend" = "Tendencia de gasto de 30 días de Claude Admin API";
+"OpenRouter API key spend trend" = "Tendencia de gasto de la clave API de OpenRouter";
+"z.ai hourly token trend" = "Tendencia horaria de tokens de z.ai";
+"MiniMax 30 day token usage trend" = "Tendencia de uso de tokens de 30 días de MiniMax";
+"Today cash" = "Efectivo de hoy";
+"DeepSeek 30 day token usage trend" = "Tendencia de uso de tokens de 30 días de DeepSeek";
+"cache-hit input" = "entrada con acierto de caché";
+"cache-miss input" = "entrada sin acierto de caché";
+"output" = "salida";
+"Requests" = "Solicitudes";
+"Reported by OpenAI Admin API organization usage." = "Informado por el uso de la organización en OpenAI Admin API.";
+"Reported by Mistral billing usage." = "Informado por el uso de facturación de Mistral.";
+"Today" = "Hoy";
+"Today tokens" = "Tokens de hoy";
+"30d cost" = "Coste 30 d";
+"30d tokens" = "Tokens 30 d";
+"Latest tokens" = "Tokens recientes";
+"Top model" = "Modelo principal";
+"Storage" = "Almacenamiento";
+"No data" = "Sin datos";
+"Last %d days" = "Últimos %d días";
+"%@ tokens" = "%@ tokens";
+"Latest billing day" = "Último día de facturación";
+"Latest billing day (%@)" = "Último día de facturación (%@)";
+"This week" = "Esta semana";
+"This month" = "Este mes";
+"Week" = "Semana";
+"Month" = "Mes";
+"Models" = "Modelos";
+"24h tokens" = "Tokens 24 h";
+"Latest hour" = "Última hora";
+"Peak hour" = "Hora pico";
+"Top method" = "Método principal";
+"30d cash" = "Efectivo 30 d";
+"30d billing history from MiniMax web session" = "Historial de facturación de 30 días de la sesión web de MiniMax";
+"AWS Cost Explorer billing can lag." = "La facturación de AWS Cost Explorer puede retrasarse.";
+"Rate limit: %d / %@" = "Límite de tasa: %d / %@";
+"Key remaining" = "Clave restante";
+"No limit set for the API key" = "No hay límite configurado para la clave API";
+"API key limit unavailable right now" = "El límite de la clave API no está disponible ahora";
+"Today: %@ · %@ tokens" = "Hoy: %@ · %@ tokens";
+"Today: %@" = "Hoy: %@";
+"Today: %@ tokens" = "Hoy: %@ tokens";
+"This month: %@ tokens" = "Este mes: %@ tokens";
+"API key limit" = "Límite de clave API";
+"Limits not available" = "Límites no disponibles";
+"No usage yet" = "Aún no hay uso";
+"Not fetched yet" = "Aún no obtenido";
+"Code review" = "Revisión de código";
+
+/* Additional provider settings and alerts */
+"%@ is waiting for permission" = "%@ espera permiso";
+"%@ requests" = "%@ solicitudes";
+"%@: %@ credits" = "%@: %@ créditos";
+"30d requests" = "Solicitudes de 30 d";
+"4 days" = "4 días";
+"5 days" = "5 días";
+"7 days" = "7 días";
+"API key verifies Ollama Cloud access; cookies still expose quota limits." = "La clave API verifica el acceso a Ollama Cloud; las cookies aún muestran los límites de cuota.";
+"AWS access key ID. Can also be set with AWS_ACCESS_KEY_ID." = "ID de clave de acceso de AWS. También puede definirse con AWS_ACCESS_KEY_ID.";
+"AWS region. Can also be set with AWS_REGION." = "Región de AWS. También puede definirse con AWS_REGION.";
+"AWS secret access key. Can also be set with AWS_SECRET_ACCESS_KEY." = "Clave secreta de AWS. También puede definirse con AWS_SECRET_ACCESS_KEY.";
+"Access key ID" = "ID de clave de acceso";
+"Add Account" = "Añadir cuenta";
+"Adding Account…" = "Añadiendo cuenta…";
+"Antigravity login failed" = "Error al iniciar sesión en Antigravity";
+"Antigravity login timed out" = "El inicio de sesión en Antigravity agotó el tiempo";
+"Auth source" = "Fuente de autenticación";
+"Automatic imports browser cookies from Xiaomi MiMo." = "Importa automáticamente las cookies del navegador desde Xiaomi MiMo.";
+"Automatic imports Windsurf session data from Chromium browser localStorage." = "Importa automáticamente datos de sesión de Windsurf desde localStorage de Chromium.";
+"Automatic imports browser cookies from Bailian." = "Importa automáticamente cookies del navegador desde Bailian.";
+"Automatically imports browser cookies." = "Importa automáticamente cookies del navegador.";
+"Automatically imports browser session cookies." = "Importa automáticamente cookies de sesión del navegador.";
+"Azure OpenAI deployment name. AZURE_OPENAI_DEPLOYMENT_NAME is also supported." = "Nombre de despliegue de Azure OpenAI. También se admite AZURE_OPENAI_DEPLOYMENT_NAME.";
+"Azure OpenAI key" = "Clave de Azure OpenAI";
+"Azure OpenAI resource endpoint. AZURE_OPENAI_ENDPOINT is also supported." = "Endpoint del recurso de Azure OpenAI. También se admite AZURE_OPENAI_ENDPOINT.";
+"Base URL" = "URL base";
+"Base URL for the LLM-API-Key-Proxy instance." = "URL base de la instancia de LLM-API-Key-Proxy.";
+"Browser cookies" = "Cookies del navegador";
+"Cap end" = "Fin del límite";
+"Cap start" = "Inicio del límite";
+"Capacity End" = "Fin de capacidad";
+"Capacity Start" = "Inicio de capacidad";
+"Changelog" = "Registro de cambios";
+"Choose the Moonshot/Kimi API host for international or China mainland accounts." = "Elige el host de la API Moonshot/Kimi para cuentas internacionales o de China continental.";
+"CodexBar can't replace a system account that is signed in with an API key only setup." = "CodexBar no puede reemplazar una cuenta del sistema iniciada solo con una clave API.";
+"CodexBar could not find saved auth for that account. Re-authenticate it and try again." = "CodexBar no encontró autenticación guardada para esa cuenta. Vuelve a autenticarla e inténtalo de nuevo.";
+"CodexBar could not read managed account storage. Recover the store before adding another account." = "CodexBar no pudo leer el almacenamiento de cuentas gestionadas. Recupera el almacén antes de añadir otra cuenta.";
+"CodexBar could not read saved auth for that account. Re-authenticate it and try again." = "CodexBar no pudo leer la autenticación guardada para esa cuenta. Vuelve a autenticarla e inténtalo de nuevo.";
+"CodexBar could not read the current system account on this Mac." = "CodexBar no pudo leer la cuenta del sistema actual en este Mac.";
+"CodexBar could not replace the live Codex auth on this Mac." = "CodexBar no pudo reemplazar la autenticación activa de Codex en este Mac.";
+"CodexBar could not safely preserve the current system account before switching." = "CodexBar no pudo preservar con seguridad la cuenta del sistema actual antes de cambiar.";
+"CodexBar could not save the current system account before switching." = "CodexBar no pudo guardar la cuenta del sistema actual antes de cambiar.";
+"CodexBar could not update managed account storage." = "CodexBar no pudo actualizar el almacenamiento de cuentas gestionadas.";
+"CodexBar found another managed account that already uses the current system account. Resolve the duplicate account before switching." = "CodexBar encontró otra cuenta gestionada que ya usa la cuenta del sistema actual. Resuelve la cuenta duplicada antes de cambiar.";
+"CodexBar will ask macOS Keychain for “%@” so it can decrypt browser cookies and authenticate your account. Click OK to continue." = "CodexBar pedirá a Llaveros de macOS “%@” para descifrar cookies del navegador y autenticar tu cuenta. Haz clic en OK para continuar.";
+"CodexBar will ask macOS Keychain for the Claude Code OAuth token so it can fetch your Claude usage. Click OK to continue." = "CodexBar pedirá a Llaveros de macOS el token OAuth de Claude Code para obtener tu uso de Claude. Haz clic en OK para continuar.";
+"CodexBar will ask macOS Keychain for your Amp cookie header so it can fetch usage. Click OK to continue." = "CodexBar pedirá a Llaveros de macOS tu cabecera Cookie de Amp para obtener el uso. Haz clic en OK para continuar.";
+"CodexBar will ask macOS Keychain for your Augment cookie header so it can fetch usage. Click OK to continue." = "CodexBar pedirá a Llaveros de macOS tu cabecera Cookie de Augment para obtener el uso. Haz clic en OK para continuar.";
+"CodexBar will ask macOS Keychain for your Claude cookie header so it can fetch Claude web usage. Click OK to continue." = "CodexBar pedirá a Llaveros de macOS tu cabecera Cookie de Claude para obtener el uso web de Claude. Haz clic en OK para continuar.";
+"CodexBar will ask macOS Keychain for your Cursor cookie header so it can fetch usage. Click OK to continue." = "CodexBar pedirá a Llaveros de macOS tu cabecera Cookie de Cursor para obtener el uso. Haz clic en OK para continuar.";
+"CodexBar will ask macOS Keychain for your Factory cookie header so it can fetch usage. Click OK to continue." = "CodexBar pedirá a Llaveros de macOS tu cabecera Cookie de Factory para obtener el uso. Haz clic en OK para continuar.";
+"CodexBar will ask macOS Keychain for your GitHub Copilot token so it can fetch usage. Click OK to continue." = "CodexBar pedirá a Llaveros de macOS tu token de GitHub Copilot para obtener el uso. Haz clic en OK para continuar.";
+"CodexBar will ask macOS Keychain for your Kimi K2 API key so it can fetch usage. Click OK to continue." = "CodexBar pedirá a Llaveros de macOS tu clave API de Kimi K2 para obtener el uso. Haz clic en OK para continuar.";
+"CodexBar will ask macOS Keychain for your Kimi auth token so it can fetch usage. Click OK to continue." = "CodexBar pedirá a Llaveros de macOS tu token de autenticación de Kimi para obtener el uso. Haz clic en OK para continuar.";
+"CodexBar will ask macOS Keychain for your MiniMax API token so it can fetch usage. Click OK to continue." = "CodexBar pedirá a Llaveros de macOS tu token API de MiniMax para obtener el uso. Haz clic en OK para continuar.";
+"CodexBar will ask macOS Keychain for your MiniMax cookie header so it can fetch usage. Click OK to continue." = "CodexBar pedirá a Llaveros de macOS tu cabecera Cookie de MiniMax para obtener el uso. Haz clic en OK para continuar.";
+"CodexBar will ask macOS Keychain for your OpenAI cookie header so it can fetch Codex dashboard extras. Click OK to continue." = "CodexBar pedirá a Llaveros de macOS tu cabecera Cookie de OpenAI para obtener extras del panel de Codex. Haz clic en OK para continuar.";
+"CodexBar will ask macOS Keychain for your OpenCode cookie header so it can fetch usage. Click OK to continue." = "CodexBar pedirá a Llaveros de macOS tu cabecera Cookie de OpenCode para obtener el uso. Haz clic en OK para continuar.";
+"CodexBar will ask macOS Keychain for your Synthetic API key so it can fetch usage. Click OK to continue." = "CodexBar pedirá a Llaveros de macOS tu clave API de Synthetic para obtener el uso. Haz clic en OK para continuar.";
+"CodexBar will ask macOS Keychain for your z.ai API token so it can fetch usage. Click OK to continue." = "CodexBar pedirá a Llaveros de macOS tu token API de z.ai para obtener el uso. Haz clic en OK para continuar.";
+"Could not open Cursor login in your browser." = "No se pudo abrir el inicio de sesión de Cursor en el navegador.";
+"Could not open browser for Antigravity" = "No se pudo abrir el navegador para Antigravity";
+"Credits used" = "Créditos usados";
+"Day" = "Día";
+"Deployment" = "Despliegue";
+"Drag to reorder" = "Arrastra para reordenar";
+"Sort providers alphabetically" = "Ordenar proveedores alfabéticamente";
+"Sort providers alphabetically (enabled first)" = "Ordenar proveedores alfabéticamente (activados primero)";
+"Sorted alphabetically (enabled first) — click to use your custom order" = "Ordenados alfabéticamente (activados primero) — haz clic para usar tu orden personalizado";
+"Endpoint" = "Endpoint";
+"Enterprise host" = "Host Enterprise";
+"Extra usage balance: %@" = "Saldo de uso extra: %@";
+"Keychain Access Required" = "Se requiere acceso a Llaveros";
+"Kiro menu bar value" = "Valor de Kiro en la barra de menús";
+"Label" = "Etiqueta";
+"No organizations loaded. Click Refresh after setting your API key." = "No hay organizaciones cargadas. Haz clic en Actualizar después de configurar tu clave API.";
+"No output captured." = "No se capturó salida.";
+"No system account" = "Sin cuenta del sistema";
+"Oasis-Token" = "Oasis-Token";
+"Open Augment (Log Out & Back In)" = "Abrir Augment (cerrar sesión y volver a entrar)";
+"Open Codebuff Dashboard" = "Abrir panel de Codebuff";
+"Open Command Code Settings" = "Abrir ajustes de Command Code";
+"Open Crof dashboard" = "Abrir panel de Crof";
+"Open Manus" = "Abrir Manus";
+"Open MiMo Balance" = "Abrir saldo de MiMo";
+"Open Moonshot Console" = "Abrir consola de Moonshot";
+"Open Ollama API Keys" = "Abrir claves API de Ollama";
+"Open StepFun Platform" = "Abrir plataforma StepFun";
+"Open T3 Chat Settings" = "Abrir ajustes de T3 Chat";
+"Open Volcengine Ark Console" = "Abrir consola Volcengine Ark";
+"Open legacy provider docs" = "Abrir documentación del proveedor heredado";
+"Open projects" = "Abrir proyectos";
+"Open this URL manually to continue login:\n\n%@" = "Abre esta URL manualmente para continuar el inicio de sesión:\n\n%@";
+"Optional organization ID for accounts linked to multiple Anthropic organizations." = "ID de organización opcional para cuentas vinculadas a varias organizaciones de Anthropic.";
+"Optional. Applies to the configured Admin API key; selected token accounts do not inherit OPENAI_PROJECT_ID." = "Opcional. Se aplica a la clave Admin API configurada; las cuentas de token seleccionadas no heredan OPENAI_PROJECT_ID.";
+"Optional. Enter your GitHub Enterprise host, for example octocorp.ghe.com. Leave blank for github.com." = "Opcional. Introduce tu host de GitHub Enterprise, por ejemplo octocorp.ghe.com. Déjalo vacío para github.com.";
+"Optional. Leave blank to discover and aggregate projects visible to the API key." = "Opcional. Déjalo vacío para descubrir y agregar proyectos visibles para la clave API.";
+"Org ID (optional)" = "ID de org. (opcional)";
+"Organizations" = "Organizaciones";
+"Password" = "Contraseña";
+"%@ authentication is disabled." = "La autenticación de %@ está desactivada.";
+"%@ cookies are disabled." = "Las cookies de %@ están desactivadas.";
+"%@ web API access is disabled." = "El acceso a la API web de %@ está desactivado.";
+"Disable %@ dashboard cookie usage." = "Desactiva el uso de cookies del panel de %@.";
+"Keychain access is disabled in Advanced, so browser cookie import is unavailable." = "El acceso al llavero está desactivado en Avanzado, así que la importación de cookies del navegador no está disponible.";
+"Manually paste an %@ from a browser session." = "Pega manualmente un %@ de una sesión del navegador.";
+"Paste a Cookie header captured from %@." = "Pega una cabecera Cookie capturada desde %@.";
+"Paste a Cookie header from %@." = "Pega una cabecera Cookie de %@.";
+"Paste a Cookie header or cURL capture from %@." = "Pega una cabecera Cookie o una captura cURL de %@.";
+"Paste a Cookie header or full cURL capture from %@." = "Pega una cabecera Cookie o una captura cURL completa de %@.";
+"Paste a Cookie or Authorization header from %@." = "Pega una cabecera Cookie o Authorization de %@.";
+"Paste a full cookie header or the %@ value." = "Pega una cabecera de cookies completa o el valor %@.";
+"Paste a Cookie header or full cURL capture from T3 Chat settings." = "Pega una cabecera Cookie o una captura cURL completa desde los ajustes de T3 Chat.";
+"Paste the Cookie header from a request to admin.mistral.ai. Must contain an ory_session_* cookie." = "Pega la cabecera Cookie de una solicitud a admin.mistral.ai. Debe contener una cookie ory_session_*.";
+"Paste the Oasis-Token from a logged-in browser session on platform.stepfun.com." = "Pega el Oasis-Token de una sesión iniciada en platform.stepfun.com.";
+"Paste the %@ JSON bundle from %@." = "Pega el paquete JSON %@ de %@.";
+"Paste the %@ value or a full Cookie header." = "Pega el valor %@ o una cabecera Cookie completa.";
+"Personal account" = "Cuenta personal";
+"Project ID" = "ID de proyecto";
+"Re-auth" = "Reautenticar";
+"Re-login at claude.ai" = "Volver a iniciar sesión en claude.ai";
+"Re-authenticating…" = "Reautenticando…";
+"Refresh Session" = "Actualizar sesión";
+"Refresh organizations" = "Actualizar organizaciones";
+"Region" = "Región";
+"Reload" = "Recargar";
+"Reorder" = "Reordenar";
+"Secret access key" = "Clave de acceso secreta";
+"Series" = "Serie";
+"Service" = "Servicio";
+"Show or hide Kiro credits, percent, or both next to the menu bar icon." = "Muestra u oculta créditos de Kiro, porcentaje o ambos junto al icono de la barra de menús.";
+"Show usage for organizations you belong to. Personal account is always shown." = "Muestra el uso de las organizaciones a las que perteneces. La cuenta personal siempre se muestra.";
+"Sign in to cursor.com in your browser, then refresh Cursor in CodexBar." = "Inicia sesión en cursor.com en el navegador y luego actualiza Cursor en CodexBar.";
+"Simulated error text" = "Texto de error simulado";
+"StepFun platform account (phone number or email)." = "Cuenta de la plataforma StepFun (teléfono o correo).";
+"Stored in ~/.codexbar/config.json." = "Guardado en ~/.codexbar/config.json.";
+"Stored in ~/.codexbar/config.json. AZURE_OPENAI_API_KEY is also supported." = "Guardado en ~/.codexbar/config.json. También se admite AZURE_OPENAI_API_KEY.";
+"Stored in ~/.codexbar/config.json. For the official Kimi API, use Moonshot / Kimi API." = "Guardado en ~/.codexbar/config.json. Para la API oficial de Kimi, usa Moonshot / Kimi API.";
+"Stored in ~/.codexbar/config.json. Get your API key from the Volcengine Ark console." = "Guardado en ~/.codexbar/config.json. Obtén tu clave API en la consola Volcengine Ark.";
+"Stored in ~/.codexbar/config.json. Get your key from Ollama settings." = "Guardado en ~/.codexbar/config.json. Obtén tu clave en los ajustes de Ollama.";
+"Stored in ~/.codexbar/config.json. Get your key from console.deepgram.com." = "Guardado en ~/.codexbar/config.json. Obtén tu clave en console.deepgram.com.";
+"Stored in ~/.codexbar/config.json. Get your key from elevenlabs.io/app/settings/api-keys." = "Guardado en ~/.codexbar/config.json. Obtén tu clave en elevenlabs.io/app/settings/api-keys.";
+"Stored in ~/.codexbar/config.json. Get your key from openrouter.ai/settings/keys and set a key spending limit there to enable API key quota tracking." = "Guardado en ~/.codexbar/config.json. Obtén tu clave en openrouter.ai/settings/keys y define allí un límite de gasto para activar el seguimiento de cuota.";
+"Stored in ~/.codexbar/config.json. In Warp, open Settings > Platform > API Keys, then create one." = "Guardado en ~/.codexbar/config.json. En Warp, abre Settings > Platform > API Keys y crea una.";
+"Stored in ~/.codexbar/config.json. Metrics require Groq Enterprise Prometheus access." = "Guardado en ~/.codexbar/config.json. Las métricas requieren acceso a Groq Enterprise Prometheus.";
+"Stored in ~/.codexbar/config.json. OPENAI_ADMIN_KEY is preferred; OPENAI_API_KEY still works." = "Guardado en ~/.codexbar/config.json. Se prefiere OPENAI_ADMIN_KEY; OPENAI_API_KEY también funciona.";
+"Stored in ~/.codexbar/config.json. Requires an Anthropic Admin API key." = "Guardado en ~/.codexbar/config.json. Requiere una clave Anthropic Admin API.";
+"Stored in ~/.codexbar/config.json. Used for /v1/quota-stats." = "Guardado en ~/.codexbar/config.json. Se usa para /v1/quota-stats.";
+"Stored in ~/.codexbar/config.json. You can also provide CODEBUFF_API_KEY or let CodexBar read ~/.config/manicode/credentials.json (created by `codebuff login`)." = "Guardado en ~/.codexbar/config.json. También puedes proporcionar CODEBUFF_API_KEY o dejar que CodexBar lea ~/.config/manicode/credentials.json (creado por `codebuff login`).";
+"Stored in ~/.codexbar/config.json. You can also provide CROF_API_KEY." = "Guardado en ~/.codexbar/config.json. También puedes proporcionar CROF_API_KEY.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or ~/.local/share/kilo/auth.json (kilo.access)." = "Guardado en ~/.codexbar/config.json. También puedes proporcionar KILO_API_KEY o ~/.local/share/kilo/auth.json (kilo.access).";
+"T3 Chat cookie" = "Cookie de T3 Chat";
+"That account is no longer available in CodexBar. Refresh the account list and try again." = "Esa cuenta ya no está disponible en CodexBar. Actualiza la lista de cuentas e inténtalo de nuevo.";
+"The browser login did not complete in time. Try Antigravity login again." = "El inicio de sesión del navegador no terminó a tiempo. Intenta iniciar sesión en Antigravity de nuevo.";
+"Timed out waiting for Cursor login. %@" = "Se agotó el tiempo esperando el inicio de sesión de Cursor. %@";
+"Timed out waiting for Cursor login. %@ Last error: %@" = "Se agotó el tiempo esperando el inicio de sesión de Cursor. %@ Último error: %@";
+"Today requests" = "Solicitudes de hoy";
+"Total (30d): %@ credits" = "Total (30 d): %@ créditos";
+"Username" = "Usuario";
+"Uses username + password to login and obtain an Oasis-Token automatically." = "Usa usuario y contraseña para iniciar sesión y obtener un Oasis-Token automáticamente.";
+"Uses username + password to login and obtain an %@ automatically." = "Usa usuario y contraseña para iniciar sesión y obtener un %@ automáticamente.";
+"Utilization End" = "Fin de utilización";
+"Utilization Start" = "Inicio de utilización";
+"Verbosity" = "Detalle";
+"Windsurf session JSON bundle" = "Paquete JSON de sesión de Windsurf";
+"Workspace ID" = "ID de espacio de trabajo";
+"Your StepFun platform password. Used to login and obtain a session token." = "Tu contraseña de la plataforma StepFun. Se usa para iniciar sesión y obtener un token de sesión.";
+"claude /login exited with status %d." = "claude /login salió con estado %d.";
+"codex login exited with status %d." = "codex login salió con estado %d.";
+"Cookie: …\n\nor paste a cURL capture from the Abacus AI dashboard" = "Cookie: …\n\no pega una captura cURL del panel de Abacus AI";
+"Cookie: …\n\nor paste the __Secure-next-auth.session-token value" = "Cookie: …\n\no pega el valor de __Secure-next-auth.session-token";
+"Cookie: …\n\nor paste the kimi-auth token value" = "Cookie: …\n\no pega el valor del token kimi-auth";
+"session_id=...\n\nor paste just the session_id value" = "session_id=...\n\no pega solo el valor de session_id";
+"Clear" = "Borrar";
+"No matching providers" = "No hay proveedores coincidentes";
+"Search providers" = "Buscar proveedores";
+
+"language_vietnamese" = "Vietnamita";
+"language_turkish" = "Türkçe";
+"language_indonesian" = "Indonesio";
+"language_arabic" = "العربية";
+"language_persian" = "فارسی";
+"language_thai" = "ไทย";
+"Limit Reset Credits" = "Créditos para restablecer límites";
+"1 manual reset available" = "1 restablecimiento manual disponible";
+"%d manual resets available" = "%d restablecimientos manuales disponibles";
+"Next expires %@" = "El siguiente caduca %@";
+"Other (%d items)" = "Otros (%d elementos)";
+"Expand" = "Expandir";
+"Collapse" = "Contraer";
+"byte_unit_byte" = "byte";
+"byte_unit_bytes" = "bytes";
+"byte_unit_kilobyte" = "kilobyte";
+"byte_unit_kilobytes" = "kilobytes";
+"byte_unit_megabyte" = "megabyte";
+"byte_unit_megabytes" = "megabytes";
+"byte_unit_gigabyte" = "gigabyte";
+"byte_unit_gigabytes" = "gigabytes";
diff --git a/Sources/CodexBar/Resources/fa.lproj/Localizable.strings b/Sources/CodexBar/Resources/fa.lproj/Localizable.strings
new file mode 100644
index 0000000000..83a08a91d8
--- /dev/null
+++ b/Sources/CodexBar/Resources/fa.lproj/Localizable.strings
@@ -0,0 +1,1110 @@
+/* Persian localization for CodexBar */
+
+" providers" = " providers";
+"(System)" = "(سیستم)";
+"30d" = "30 روز";
+"A managed Codex login is already running. Wait for it to finish before adding " = "یک ورود Codex مدیریت شده هم اکنون در حال اجرا است. صبر کنید تا تمام شود و بعد   را اضافه کنید";
+"API key" = "کلید API";
+"API region" = "منطقه API";
+"API token" = "API توکن";
+"API tokens" = "توکن های API";
+"About" = "درباره";
+"Account" = "حساب";
+"Accounts" = "گزارش ها";
+"Accounts subtitle" = "زیرنویس حساب ها";
+"Active" = "فعال";
+"Add" = "افزودن";
+"Add Workspace" = "افزودن فضای کاری";
+"Advanced" = "پیشرفته";
+"All" = "همه";
+"Always allow prompts" = "همیشه اجازه دهید پرامپت ها";
+"Animation pattern" = "الگوی انیمیشن";
+"Antigravity login is managed in the app" = "ورود Antigravity در اپلیکیشن مدیریت می شود";
+"Applies only to the Security.framework OAuth keychain reader." = "فقط برای Security.framework OAuth خواننده جاکلیدی کاربرد دارد.";
+"Auto falls back to the next source if the preferred one fails." = "اگر منبع ترجیحی خراب شود، خودکار به منبع بعدی برمی گردد.";
+"Auto uses API first, then falls back to CLI on auth failures." = "خودکار اول از API استفاده می کند، سپس در صورت خطاهای احراز هویت به CLI برمی گردد.";
+"Auto-detect" = "تشخیص خودکار";
+"Auto-refresh is off; use the menu's Refresh command." = "تازه سازی خودکار خاموش است؛ از فرمان تازه سازی منو استفاده کنید.";
+"Auto-refresh: hourly · Timeout: 10m" = "بازخوانی خودکار: ساعتی · مهلت: 10m";
+"Automatic" = "اتوماتیک";
+"Automatic imports browser cookies and WorkOS tokens." = "به طور خودکار کوکی های مرورگر و توکن های WorkOS را وارد می کند.";
+"Automatic imports browser cookies and local storage tokens." = "به طور خودکار کوکی های مرورگر و توکن های ذخیره سازی محلی را وارد می کند.";
+"Automatic imports browser cookies for dashboard extras." = "کوکی های مرورگر را به طور خودکار برای اضافه کردن داشبورد وارد می کند.";
+"Automatic imports browser cookies for the web API." = "کوکی های مرورگر را به صورت خودکار برای API وب وارد می کند.";
+"Automatic imports browser cookies from Model Studio/Bailian." = "کوکی های مرورگر را به صورت خودکار از Model Studio/Bailian. وارد می کند";
+"Automatic imports browser cookies from admin.mistral.ai." = "کوکی های مرورگر را به طور خودکار از admin.mistral.ai وارد می کند.";
+"Automatic imports browser cookies from opencode.ai." = "کوکی های مرورگر را به طور خودکار از opencode.ai وارد می کند.";
+"Automatic imports browser cookies or stored sessions." = "به طور خودکار کوکی های مرورگر یا جلسات ذخیره شده را وارد می کند.";
+"Automatic imports browser cookies." = "کوکی های مرورگر را به صورت خودکار وارد می کند.";
+"Automatically imports browser session cookie." = "به طور خودکار کوکی نشست مرورگر را وارد می کند.";
+"Automatically opens CodexBar when you start your Mac." = "وقتی مک را روشن می کنید، CodexBar به طور خودکار باز می شود.";
+"Automation" = "اتوماسیون";
+"Average (\\(label1) + \\(label2))" = "میانگین (\\(label1) + \\(label2))";
+"Average (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))" = "میانگین (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))";
+"Avoid Keychain prompts" = "از درخواست های Keychain اجتناب کنید";
+"Balance" = "تعادل";
+"Battery Saver" = "باتری سیور";
+"Bordered" = "مرز";
+"Build" = "ساخت";
+"Built \\(buildTimestamp)" = "ساخته شده \\(buildTimestamp)";
+"Buy Credits..." = "خرید اعتبار...";
+"Buy Credits…" = "خرید اعتبار...";
+"CLI paths" = "مسیرهای CLI";
+"CLI sessions" = "جلسات CLI";
+"Caches" = "کش ها";
+"Cancel" = "لغو";
+"Check for Updates…" = "به روزرسانی ها را بررسی کنید...";
+"Check for updates automatically" = "به طور خودکار به روزرسانی ها را بررسی کنید";
+"Check if you like your agents having some fun up there." = "بررسی کن که آیا دوست داری مأمورانت آنجا خوش بگذرانند یا نه.";
+"Check provider status" = "وضعیت ارائه دهنده را بررسی کنید";
+"Choose Codex workspace" = "فضای کاری Codex را انتخاب کنید";
+"Choose the MiniMax host (global .io or China mainland .com)." = "میزبان MiniMax را انتخاب کنید (جهانی .io یا .com سرزمین اصلی چین).";
+"Choose up to " = "تا   انتخاب کنید";
+"Choose up to \\(Self.maxOverviewProviders) providers" = "تا \\(Self.maxOverviewProviders) ارائه دهنده را انتخاب کنید";
+"Choose up to \\(count) providers" = "تا \\(count) ارائه دهنده را انتخاب کنید";
+"Choose what to show in the menu bar (Pace shows usage vs. expected)." = "انتخاب کنید که در نوار منو چه چیزی نمایش داده شود (Pace میزان مصرف در مقابل مورد انتظار را نشان می دهد).";
+"Choose which Codex account CodexBar should follow." = "انتخاب کنید که کدام حساب Codex را دنبال CodexBar.";
+"Choose which window drives the menu bar percent." = "انتخاب کنید کدام پنجره درصد نوار منو را تنظیم کند.";
+"Chrome" = "Chrome";
+"Claude CLI not found" = "Claude CLI پیدا نشد";
+"Claude binary" = "Claude دودویی";
+"Claude cookies" = "Claude کوکی";
+"Claude login failed" = "ورود Claude ناموفق";
+"Claude login timed out" = "ورود Claude به پایان رسید";
+"Close" = "بسته شدن";
+"Code review" = "بررسی کد";
+"Codex CLI not found" = "Codex CLI پیدا نشد";
+"Codex account login already running" = "ورود Codex حساب کاربری در حال اجرا است";
+"Codex binary" = "Codex دودویی";
+"Codex login failed" = "ورود Codex ناموفق";
+"Codex login timed out" = "ورود Codex به پایان رسید";
+"CodexBar Lifecycle Keepalive" = "CodexBar چرخه زندگی زنده نگه داشتن";
+"CodexBar can't show its menu bar icon" = "CodexBar نمی تواند آیکون نوار منویش را نشان دهد";
+"CodexBar could not read managed account storage. " = "CodexBar نمی توانست ذخیره سازی حساب مدیریت شده را بخواند.  ";
+"Configure…" = "پیکربندی کن...";
+"Connected" = "متصل";
+"Controls how much detail is logged." = "میزان جزئیات ثبت شده را کنترل می کند.";
+"Cookie header" = "هدر کوکی";
+"Cookie source" = "منبع کوکی";
+"Cookie: ..." = "کوکی: ...";
+"Cookie: \\u{2026}\\\n\\\nor paste a cURL capture from the Abacus AI dashboard" = "کوکی: \\u{2026}\\\n\\\n یا یک cURL capture از داشبورد Abacus AI پیست کنید";
+"Cookie: \\u{2026}\\\n\\\nor paste the __Secure-next-auth.session-token value" = "کوکی: \\u{2026}\\\n\\\nیا مقدار توکن __Secure-next-auth.session-token را بچسبانید";
+"Cookie: \\u{2026}\\\n\\\nor paste the kimi-auth token value" = "کوکی: \\u{2026}\\\n\\\nیا مقدار توکن kimi-authentic را بچسبانید";
+"Cookie: …" = "کوکی: ...";
+"CopilotDeviceFlow" = "CopilotDeviceFlow";
+"Cost" = "هزینه";
+"Could not add Codex account" = "نتوانستم حساب Codex اضافه کنم";
+"Could not open Terminal for Gemini" = "نتوانستم ترمینال را برای Gemini باز کنم";
+"Could not start claude /login" = "نتوانستم کلود را شروع /login";
+"Could not start codex login" = "ورود به کدکس فعال نشد";
+"Could not switch system account" = "نتوانستم حساب سیستم را تغییر دهم";
+"Credits" = "اعتبارات";
+"Individual credits" = "اعتبارات فردی";
+"Workspace" = "فضای کاری";
+"Credits history" = "تاریخچه اعتبارها";
+"Cursor login failed" = "ورود Cursor ناموفق";
+"Custom" = "عرف";
+"Custom Path" = "مسیر سفارشی";
+"Daily Routines" = "روال روزانه";
+"Debug" = "اشکال زدایی";
+"Default" = "پیش فرض";
+"Disable Keychain access" = "غیرفعال کردن دسترسی Keychain";
+"Disabled" = "معلول";
+"Dismiss" = "اخراج";
+"Disconnected" = "قطع ارتباط";
+"Display" = "نمایش";
+"Display mode" = "حالت نمایش";
+"Display reset times as absolute clock values instead of countdowns." = "زمان بازنشانی را به جای شمارش معکوس، به صورت مقادیر مطلق ساعت نمایش دهید.";
+"Done" = "انجام شد";
+"Effective PATH" = "PATH مؤثر";
+"Email" = "ایمیل";
+"Enable Merge Icons to configure Overview tab providers." = "فعال سازی Merge Icons برای پیکربندی ارائه دهندگان تب نمای کلی.";
+"Enable file logging" = "فعال سازی ثبت فایل";
+"Enabled" = "فعال";
+"Error" = "خطا";
+"Error simulation" = "شبیه سازی خطا";
+"Expose troubleshooting tools in the Debug tab." = "ابزارهای عیب یابی را در تب اشکال زدایی آشکار کنید.";
+"Failed" = "شکست خورد";
+"False" = "نادرست";
+"Fetch strategy attempts" = "تلاش های استراتژی جمع آوری";
+"Fetching" = "جمع آوری";
+"Field" = "میدان";
+"Field subtitle" = "زیرنویس فیلد";
+"Finish the current managed account change before switching the system account." = "قبل از تغییر حساب سیستم، تغییر حساب مدیریت شده فعلی را تکمیل کنید.";
+"Force animation on next refresh" = "انیمیشن فورس در رفرش بعدی";
+"Gateway region" = "منطقه گیت وی";
+"Gemini CLI not found" = "Gemini CLI پیدا نشد";
+"Gemini/Antigravity, surfacing incidents in the icon and menu." = "Gemini/Antigravity، نمایش حوادث در آیکون و منو.";
+"General" = "عمومی";
+"GitHub" = "GitHub";
+"GitHub Copilot Login" = "GitHub Copilot ورود";
+"GitHub Login" = "GitHub ورود";
+"Hide details" = "مخفی کردن جزئیات";
+"Hide personal information" = "مخفی کردن اطلاعات شخصی";
+"Historical tracking" = "ردیابی تاریخی";
+"How often CodexBar polls providers in the background." = "چند وقت یکبار CodexBar ارائه دهندگان نظرسنجی در پس زمینه انجام می دهند.";
+"Inactive" = "غیرفعال";
+"Install CLI" = "نصب CLI";
+"Install the Claude CLI (npm i -g @anthropic-ai/claude-code) and try again." = "Claude CLI (npm i -g @anthropic-ai/claude-code) را نصب کنید و دوباره امتحان کنید.";
+"Install the Codex CLI (npm i -g @openai/codex) and try again." = "Codex CLI (npm i -g @openai/codex) را نصب کنید و دوباره امتحان کنید.";
+"Install the Gemini CLI (npm i -g @google/gemini-cli) and try again." = "Gemini CLI (npm i -g @google/gemini-cli) را نصب کنید و دوباره امتحان کنید.";
+"JetBrains AI is ready" = "JetBrains هوش مصنوعی آماده است";
+"JetBrains IDE" = "JetBrains IDE";
+"Keep CLI sessions alive" = "جلسات CLI را زنده نگه دارید";
+"Keyboard shortcut" = "میانبر کیبورد";
+"Keychain access" = "دسترسی Keychain";
+"Keychain prompt policy" = "سیاست Keychain سرعت";
+"Last \\(name) fetch failed:" = "آخرین \\(name) آوردن ناموفق بود:";
+"Last \\(self.store.metadata(for: self.provider).displayName) fetch failed:" = "آخرین \\(self.store.metadata(for: self.provider).displayName) واکشی ناموفق بود:";
+"Last attempt" = "آخرین تلاش";
+"Link" = "لینک";
+"Loading animations" = "انیمیشن های بارگذاری";
+"Loading…" = "در حال بارگذاری...";
+"Local" = "محلی";
+"Logging" = "چوب بری";
+"Login failed" = "ورود ناموفق";
+"Login shell PATH (startup capture)" = "PATH پوسته ورود (ضبط راه انداز)";
+"Login timed out" = "زمان ورود تمام شد";
+"MCP details" = "جزئیات MCP";
+"Managed Codex accounts unavailable" = "حساب های مدیریت شده Codex در دسترس نیستند";
+"Managed account storage is unreadable. Live account access is still available, " = "ذخیره سازی حساب مدیریت شده قابل خواندن نیست. دسترسی به حساب زنده هنوز در دسترس است  ";
+"Manual" = "دفترچه راهنما";
+"May your tokens never run out—keep agent limits in view." = "امیدوارم توکن های شما هرگز تمام نشوند—محدودیت های عامل را در نظر داشته باشید.";
+"Menu bar" = "نوار منو";
+"Menu bar auto-shows the provider closest to its rate limit." = "نوار منو به طور خودکار ارائه دهنده ای را نشان می دهد که به محدودیت نرخ خود نزدیک تر است.";
+"Menu bar metric" = "معیار نوار منو";
+"Menu bar shows percent" = "نوار منو درصد را نشان می دهد";
+"Menu content" = "محتوای منو";
+"Merge Icons" = "آیکون های ادغام";
+"Never prompt" = "هرگز پرامپت نکنید";
+"No" = "نه";
+"No Codex accounts detected yet." = "هنوز حساب Codex شناسایی نشده است.";
+"No JetBrains IDE detected" = "هیچ JetBrains IDE ای شناسایی نشد.";
+"No cost history data." = "داده های تاریخچه رایگان.";
+"No data available" = "داده ای در دسترس نیست";
+"No data yet" = "هنوز داده ای وجود ندارد";
+"No enabled providers available for Overview." = "هیچ ارائه دهنده فعالی برای مرور کلی در دسترس نیست.";
+"No providers selected" = "هیچ ارائه دهنده ای انتخاب نشده است";
+"No token accounts yet." = "هنوز حساب توکنی ندارم.";
+"No usage breakdown data." = "هیچ داده ای درباره تقسیم بندی مصرف وجود ندارد.";
+"None" = "هیچ کدام";
+"Notifications" = "اعلان ها";
+"Notifies when the 5-hour session quota hits 0% and when it becomes " = "هنگامی که سهمیه جلسه پنج‌ساعته به 0% می‌رسد و دوباره ";
+"OK" = "باشه";
+"Obscure email addresses in the menu bar and menu UI." = "آدرس های ایمیل مبهم در نوار منو و رابط کاربری منو.";
+"Off" = "خاموش";
+"Offline" = "آفلاین";
+"On" = "روشن است";
+"Online" = "آنلاین";
+"Only on user action" = "فقط با اقدام کاربر";
+"Open" = "باز";
+"Open API Keys" = "کلیدهای API باز";
+"Open Amp Settings" = "تنظیمات باز Amp";
+"Open Antigravity to sign in, then refresh CodexBar." = "Antigravity را باز کنید تا وارد شوید، سپس CodexBar را تازه کنید.";
+"Open Browser" = "مرورگر باز";
+"Open Coding Plan" = "طرح کدگذاری باز";
+"Open Console" = "کنسول باز";
+"Open Dashboard" = "داشبورد باز";
+"Open Mistral Admin" = "Open Mistral Admin";
+"Open Menu Bar Settings" = "تنظیمات نوار منو را باز کنید";
+"Open Ollama Settings" = "تنظیمات باز Ollama";
+"Open Terminal" = "ترمینال باز";
+"Open Usage Page" = "صفحه استفاده باز";
+"Open Warp API Key Guide" = "راهنمای کلید باز Warp API";
+"Open menu" = "منوی باز";
+"Open token file" = "فایل توکن باز";
+"OpenAI cookies" = "OpenAI کوکی";
+"OpenAI web extras" = "OpenAI افزونه های وب";
+"Option A" = "گزینه الف";
+"Option B" = "گزینه B";
+"Optional override if workspace lookup fails." = "اگر جستجوی workspace شکست بخورد، جایگزین اختیاری است.";
+"Options" = "گزینه ها";
+"Override auto-detection with a custom IDE base path" = "لغو تشخیص خودکار با یک مسیر پایه سفارشی IDE";
+"Overview" = "بررسی اجمالی";
+"Overview rows always follow provider order." = "ردیف های نمای کلی همیشه مطابق با ترتیب ارائه دهنده انجام می شوند.";
+"Overview tab providers" = "ارائه دهندگان تب مرور کلی";
+"Paste API key…" = "کلید API بچسبان...";
+"Paste API token…" = "توکن API بچسبان...";
+"Paste key…" = "کلید چسباندن...";
+"Paste sessionKey or OAuth token…" = "sessionKey یا توکن OAuth را پیست کنید...";
+"Paste the Cookie header from a request to admin.mistral.ai. " = "هدر کوکی را از درخواست به admin.mistral.ai. ";
+"Paste token…" = "توکن چسباندن...";
+"Personal" = "زندگی شخصی";
+"Picker" = "پیکر";
+"Picker subtitle" = "زیرعنوان پیکر";
+"Placeholder" = "جایگزین جایگزین";
+"Plan" = "طرح";
+"Play full-screen confetti when weekly usage resets." = "وقتی استفاده هفتگی ریست می شود، کنفتی تمام صفحه را پخش کنید.";
+"Polls OpenAI/Claude status pages and Google Workspace for " = "نظرسنجی ها OpenAI/Claude صفحات وضعیت و Google Workspace for ";
+"Prevents any Keychain access while enabled." = "در حالت فعال بودن از هرگونه دسترسی Keychain جلوگیری می کند.";
+"Primary (API key limit)" = "کلید اصلی (API حد کلید)";
+"Primary (\\(label))" = "ابتدایی (\\(label))";
+"Primary (\\(metadata.sessionLabel))" = "ابتدایی (\\(metadata.sessionLabel))";
+"Probe logs" = "گزارش های کاوشگر";
+"Progress bars fill as you consume quota (instead of showing remaining)." = "نوارهای پیشرفت هنگام مصرف سهمیه پر می شوند (به جای اینکه باقی مانده را نشان دهند).";
+"Provider" = "ارائه دهنده";
+"Providers" = "ارائه دهندگان";
+"Quit CodexBar" = "ترک CodexBar";
+"Random (default)" = "تصادفی (پیش فرض)";
+"Reads local usage logs. Shows today + last 30 days cost in the menu." = "گزارش های استفاده محلی را می خواند. امروز نمایش داده می شود + پنجره تاریخچه انتخاب شده در منو.";
+"Refresh" = "تازه سازی";
+"Refresh cadence" = "کادانس تازه سازی";
+"Remote" = "دورافتاده";
+"Remove" = "حذف";
+"Remove Codex account?" = "حساب Codex حذف کنم؟";
+"Remove \\(account.email) from CodexBar? Its managed Codex home will be deleted." = "حذف \\(account.email) از CodexBar؟ مدیریت Codex خانه آن حذف خواهد شد.";
+"Remove \\(email) from CodexBar? Its managed Codex home will be deleted." = "حذف \\(email) از CodexBar؟ مدیریت Codex خانه آن حذف خواهد شد.";
+"Remove selected account" = "حذف حساب انتخاب شده";
+"Replace critter bars with provider branding icons and a percentage." = "بارهای کریتر را با آیکون های برندینگ ارائه دهنده و درصدی جایگزین کنید.";
+"Replay selected animation" = "بازپخش انیمیشن انتخاب شده";
+"Requires authentication via GitHub Device Flow." = "نیاز به احراز هویت از طریق جریان دستگاه GitHub دارد.";
+"Resets: \\(reset)" = "بازنشانی: \\(reset)";
+"Rolling five-hour limit" = "محدودیت پنج ساعته متحرک";
+"Search hourly" = "جستجو ساعتی";
+"Secondary (\\(label))" = "ثانویه (\\(label))";
+"Secondary (\\(metadata.weeklyLabel))" = "ثانویه (\\(metadata.weeklyLabel))";
+"Select a provider" = "یک ارائه دهنده انتخاب کنید";
+"Select the IDE to monitor" = "IDE را برای مانیتور انتخاب کنید";
+"Session quota notifications" = "اعلان های سهمیه نشست";
+"Session tokens" = "توکن های جلسه";
+"Settings" = "محیط ها";
+"Show Codex Credits and Claude Extra usage sections in the menu." = "بخش های Codex اعتبارها و Claude استفاده اضافی را در منو نمایش دهید.";
+"Show Debug Settings" = "نمایش تنظیمات اشکال زدایی";
+"Show all token accounts" = "نمایش همه حساب های توکن";
+"Show cost summary" = "خلاصه هزینه نمایش";
+"Show credits + extra usage" = "نمایش اعتبارها + استفاده اضافی";
+"Show details" = "جزئیات برنامه";
+"Show most-used provider" = "نمایش ارائه دهنده پرکاربرد";
+"Show provider icons in the switcher (otherwise show a weekly progress line)." = "آیکون های ارائه دهنده را در سوئیچر نشان دهید (در غیر این صورت یک خط پیشرفت هفتگی نمایش دهید).";
+"Show reset time as clock" = "نمایش زمان بازنشانی به صورت ساعت";
+"Show usage as used" = "کاربرد نمایش همان طور که استفاده می شود";
+"Sign in via button below" = "از طریق دکمه زیر وارد شوید";
+"Skip teardown between probes (debug-only)." = "رد کردن بین پروب ها (فقط برای اشکال زدایی).";
+"Stack token accounts in the menu (otherwise show an account switcher bar)." = "حساب های توکن را در منو انباشته کنید (در غیر این صورت نوار تعویض حساب نمایش داده شود).";
+"Start at Login" = "شروع از ورود";
+"Status" = "وضعیت";
+"Store Claude sessionKey cookies or OAuth access tokens." = "کوکی های sessionKey Claude یا توکن های دسترسی OAuth را ذخیره کنید.";
+"Store multiple Abacus AI Cookie headers." = "چندین هدر Abacus AI کوکی را ذخیره کنید.";
+"Store multiple Augment Cookie headers." = "چندین هدر Augment کوکی را ذخیره کنید.";
+"Store multiple Cursor Cookie headers." = "چندین هدر Cursor کوکی را ذخیره کنید.";
+"Store multiple Factory Cookie headers." = "چندین هدر Factory کوکی را ذخیره کنید.";
+"Store multiple MiniMax Cookie headers." = "چندین هدر MiniMax کوکی را ذخیره کنید.";
+"Store multiple Mistral Cookie headers." = "چندین هدر Mistral کوکی را ذخیره کنید.";
+"Store multiple Ollama Cookie headers." = "چندین هدر Ollama کوکی را ذخیره کنید.";
+"Store multiple OpenCode Cookie headers." = "چندین هدر OpenCode کوکی را ذخیره کنید.";
+"Store multiple OpenCode Go Cookie headers." = "چندین هدر OpenCode Go Cookie را ذخیره کنید.";
+"Stored in the CodexBar config file." = "در فایل پیکربندی CodexBar ذخیره شده است.";
+"Stored in ~/.codexbar/config.json. " = "ذخیره شده در ~/.codexbar/config.json. ";
+"Stored in ~/.codexbar/config.json. Generate one at kimi-k2.ai." = "ذخیره شده در ~/.codexbar/config.json. یکی را در kimi-k2.ai تولید کنید.";
+"Stored in ~/.codexbar/config.json. Paste the key from the Synthetic dashboard." = "ذخیره شده در ~/.codexbar/config.json. کلید را از داشبورد Synthetic پیست کنید.";
+"Stored in ~/.codexbar/config.json. Paste your Coding Plan API key from Model Studio." = "ذخیره شده در ~/.codexbar/config.json. کلید API برنامه کدنویسی خود را از مدل استودیو چسبانده کنید.";
+"Stored in ~/.codexbar/config.json. Paste your MiniMax API key." = "ذخیره شده در ~/.codexbar/config.json. کلید MiniMax API خود را بچسبانید.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or " = "ذخیره شده در ~/.codexbar/config.json. همچنین می توانید KILO_API_KEY or  ارائه دهید";
+"Stores local Codex usage history (8 weeks) to personalize Pace predictions." = "تاریخچه استفاده Codex محلی (۸ هفته) را برای شخصی سازی پیش بینی های سرعت ذخیره می کند.";
+"Subscription Utilization" = "استفاده از اشتراک";
+"Surprise me" = "سورپرایزم کن";
+"Switcher shows icons" = "سوئیچر آیکون ها را نشان می دهد";
+"Symlink CodexBarCLI to /usr/local/bin and /opt/homebrew/bin as codexbar." = "Symlink CodexBarCLI به /usr/local/bin و /opt/homebrew/bin به عنوان codexbar.";
+"System" = "سیستم";
+"Temporarily shows the loading animation after the next refresh." = "انیمیشن بارگذاری پس از تازه سازی بعدی به طور موقت نمایش داده می شود.";
+"terminal_app_subtitle" = "ترمینال مورد استفاده در عملکرد ترمینال باز";
+"terminal_app_title" = "ترمینال پیش فرض";
+"Tertiary (\\(label))" = "دوره سوم (\\(label))";
+"Tertiary (\\(tertiaryTitle))" = "دوره سوم (\\(tertiaryTitle))";
+"The default Codex account on this Mac." = "حساب پیش فرض Codex این مک.";
+"Toggle" = "تغییر وضعیت";
+"Toggle subtitle" = "تغییر زیرنویس";
+"Token" = "توکن";
+"Trigger the menu bar menu from anywhere." = "منوی نوار منو را از هر جایی فعال کنید.";
+"True" = "درسته";
+"Twitter" = "توییتر";
+"Unsupported" = "بدون پشتیبانی";
+"Update Channel" = "به روزرسانی کانال";
+"Updated" = "به روزرسانی شده";
+"Updates unavailable in this build." = "به روزرسانی ها در این نسخه در دسترس نیستند.";
+"Usage" = "کاربرد";
+"Usage breakdown" = "تفکیک استفاده";
+"Usage history (30 days)" = "تاریخچه استفاده";
+"Usage source" = "منبع استفاده";
+"Use BigModel for the China mainland endpoints (open.bigmodel.cn)." = "برای نقاط پایانی سرزمین اصلی چین از BigModel استفاده کنید (open.bigmodel.cn).";
+"Use a single menu bar icon with a provider switcher." = "از یک آیکون نوار منو با یک تغییر دهنده ارائه دهنده استفاده کنید.";
+"Use international or China mainland console gateways for quota fetches." = "برای دریافت سهمیه از دروازه های کنسول بین المللی یا چین استفاده کنید.";
+"Version" = "نسخه";
+"Version \\(self.versionString)" = "نسخه \\(self.versionString)";
+"Version \\(version)" = "نسخه \\(version)";
+"Version \\(versionString)" = "نسخه \\(versionString)";
+"Vertex AI Login" = "Vertex AI ورود";
+"Wait for the current managed Codex login to finish before adding another account." = "صبر کنید تا ورود مدیریت شده فعلی Codex کامل شود و بعد حساب جدیدی اضافه کنید.";
+"Waiting for Authentication..." = "منتظر احراز هویت...";
+"Website" = "وب سایت";
+"Weekly limit confetti" = "کنفتی محدود هفتگی";
+"Weekly token limit" = "محدودیت هفتگی توکن";
+"Weekly usage" = "استفاده هفتگی";
+"Weekly usage unavailable for this account." = "استفاده هفتگی برای این حساب در دسترس نیست.";
+"Window: \\(window)" = "پنجره: \\(window)";
+"Write logs to \\(self.fileLogPath) for debugging." = "لاگ ها را برای \\(self.fileLogPath) برای اشکال زدایی بنویسید.";
+"Yes" = "بله";
+"\\(detail.modelCode): \\(usage)" = "\\(detail.modelCode): \\(usage)";
+"\\(name): \\(truncated)" = "\\(name): \\(truncated)";
+"\\(name): \\(updated) · 30d \\(cost)" = "\\(name): \\(updated) · 30d \\(cost)";
+"\\(name): fetching…\\(elapsed)" = "\\(name): جالب است... \\(elapsed)";
+"\\(name): last attempt \\(when)" = "\\(name): آخرین تلاش \\(when)";
+"\\(name): no data yet" = "\\(name): هنوز داده ای وجود ندارد";
+"\\(name): unsupported" = "\\(name): بدون پشتیبانی";
+"all browsers" = "تمام مرورگرها";
+"available again." = "دوباره در دسترس است.";
+"built_format" = "ساخته شده %@";
+"copilot_complete_in_browser" = "ورود کامل به مرورگر خود را انجام دهید.";
+"copilot_device_code" = "کد دستگاه کپی شده به کلیپ بورد: %1$@\n\nVerify در: %2$@";
+"copilot_device_code_copied" = "کد دستگاه کپی شد.";
+"copilot_verify_at" = "تأیید کنید در %@";
+"copilot_waiting_text" = "ورود کامل به مرورگر خود را انجام دهید. \nاین پنجره به طور خودکار پس از تکمیل ورود بسته می شود.";
+"copilot_window_closes_auto" = "این پنجره به طور خودکار هنگام تکمیل ورود بسته می شود.";
+"cost_status_error" = "%1$@: %2$@";
+"cost_status_fetching" = "%1$@: جالب است... %2$@";
+"cost_status_last_attempt" = "%1$@: آخرین تلاش %2$@";
+"cost_status_no_data" = "%@: هنوز داده ای وجود ندارد";
+"cost_status_snapshot" = "%1$@: %2$@ · %3$@ %4$@";
+"cost_status_unsupported" = "%@: بدون پشتیبانی";
+"credits_remaining" = "اعتبارات: %@";
+"cursor_on_demand" = "درخواست: %@";
+"cursor_on_demand_with_limit" = "درخواست: %1$@ / %2$@";
+"extra_usage_format" = "استفاده اضافی: %1$@ / %2$@";
+"jetbrains_detected_generate" = "شناسایی شد: %@. یک بار از دستیار هوش مصنوعی برای تولید داده های سهمیه استفاده کنید، سپس CodexBar را تازه کنید.";
+"jetbrains_detected_select" = "شناسایی شد: %@. IDE مورد علاقه تان را در تنظیمات انتخاب کنید، سپس CodexBar را تازه کنید.";
+"last_fetch_failed_with_provider" = "آخرین %@ آوردن ناموفق بود:";
+"last_spend" = "آخرین هزینه ها: %@";
+"mcp_model_usage" = "%1$@: %2$@";
+"mcp_resets" = "بازنشانی: %@";
+"mcp_window" = "پنجره: %@";
+"metric_average" = "میانگین (%1$@ + %2$@)";
+"metric_primary" = "ابتدایی (%@)";
+"metric_secondary" = "ثانویه (%@)";
+"metric_tertiary" = "دوره سوم (%@)";
+"multiple_workspaces_found" = "CodexBar چندین فضای کاری برای %@ پیدا کردم. لطفا فضای کاری را برای افزودن انتخاب کنید.";
+"ory_session_…=…; csrftoken=…" = "ory_session_...=...; csrftoken=...";
+"overview_choose_providers" = "تا %@ ارائه دهنده را انتخاب کنید";
+"remove_account_message" = "حذف %@ از CodexBar؟ مدیریت Codex خانه آن حذف خواهد شد.";
+"version_format" = "نسخه %@";
+"vertex_ai_login_instructions" = "برای پیگیری Vertex AI استفاده، با Google Cloud.\n\n1 احراز هویت کنید. ترمینال باز\n2. اجرا: gcloud auth application-default-login\n3. دستورالعمل های مرورگر را دنبال کنید تا in\n4 را امضا کنید. پروژه ات را تنظیم کن: gcloud config set project PROJECT_ID\n\nOpen Terminal را همین حالا؟";
+"workspaceID is set but only opencode, opencodego, and deepgram support workspaceID." = "workspaceID فعال است اما فقط opencode، opencodego و deepgram از workspaceID پشتیبانی می کنند.";
+"© 2026 Peter Steinberger. MIT License." = "© ۲۰۲۶ پیتر استاینبرگر. MIT مجوز.";
+
+/* General Pane */
+"section_system" = "سیستم";
+"section_usage" = "کاربرد";
+"section_automation" = "اتوماسیون";
+"language_title" = "زبان";
+"language_subtitle" = "زبان نمایش را تغییر دهید. برای اجرایی شدن کامل برنامه نیاز به ریستارت دارد.";
+"language_system" = "سیستم";
+"language_english" = "انگلیسی";
+"language_spanish" = "اسپانیایی";
+"language_catalan" = "کاتالا";
+"language_chinese_simplified" = "简体中文";
+"language_chinese_traditional" = "繁體中文";
+"language_portuguese_brazilian" = "پرتغالی ها (برزیل)";
+"language_dutch" = "هلند ها";
+"language_german" = "دویچ";
+"language_swedish" = "سوئنسکا";
+"language_french" = "فرانسوی";
+"language_ukrainian" = "Українська";
+"language_japanese" = "ژاپنی";
+"language_korean" = "کره ای";
+"language_turkish" = "ترک چه";
+"language_italian" = "ایتالیانو";
+"language_polish" = "پولسکی";
+"start_at_login_title" = "شروع از ورود";
+"start_at_login_subtitle" = "وقتی مک را روشن می کنید، CodexBar به طور خودکار باز می شود.";
+"show_cost_summary" = "خلاصه هزینه نمایش";
+"show_cost_summary_subtitle" = "گزارش های استفاده محلی را می خواند. امروز نمایش داده می شود + پنجره تاریخچه انتخاب شده در منو.";
+"cost_history_days_title" = "پنجره تاریخچه: %d روز";
+"cost_auto_refresh_info" = "تازه سازی خودکار: ساعتی · زمان استراحت: 10m";
+"refresh_cadence_title" = "کادانس تازه سازی";
+"refresh_cadence_subtitle" = "چند وقت یکبار CodexBar ارائه دهندگان نظرسنجی در پس زمینه انجام می دهند.";
+"manual_refresh_hint" = "تازه سازی خودکار خاموش است؛ از فرمان تازه سازی منو استفاده کنید.";
+"check_provider_status_title" = "وضعیت ارائه دهنده را بررسی کنید";
+"check_provider_status_subtitle" = "نظرسنجی ها OpenAI/Claude صفحات وضعیت و Google Workspace برای Gemini/Antigravity که حوادث را در آیکون و منو نمایش می دهد.";
+"session_quota_notifications_title" = "اعلان های سهمیه نشست";
+"session_quota_notifications_subtitle" = "هنگامی که سهمیه جلسه پنج‌ساعته به 0% می‌رسد و دوباره در دسترس قرار می‌گیرد، اطلاع می‌دهد.";
+"quota_warning_notifications_title" = "هشدارهای هشدار سهمیه";
+"quota_warning_notifications_subtitle" = "هشدار می دهد وقتی سهمیه نشست یا هفتگی باقی مانده از آستانه های پیکربندی شده عبور کند.";
+"quota_warnings_title" = "هشدارهای سهمیه";
+"quota_warning_session" = "جلسه";
+"quota_warning_session_capitalized" = "جلسه";
+"quota_warning_weekly" = "هفتگی";
+"quota_warning_weekly_capitalized" = "هفتگی";
+"quota_warning_notification_title" = "سهمیه %2$@ در %1$@ رو به اتمام است";
+"quota_warning_notification_body" = "%1$@ باقی مانده است. آستانه هشدار %2$d%% برای سهمیه %3$@ شما فعال شد.";
+"quota_warning_notification_body_with_account" = "حساب %1$@. %2$@ باقی مانده است. آستانه هشدار %3$d%% برای سهمیه %4$@ شما فعال شد.";
+"session_depleted_notification_title" = "%@ جلسه تخلیه شد";
+"session_depleted_notification_body" = "0% باقی مانده است. وقتی دوباره در دسترس قرار گیرد اطلاع می‌دهیم.";
+"session_restored_notification_title" = "جلسه %@ بازیابی شد";
+"session_restored_notification_body" = "سهمیه جلسه دوباره در دسترس است.";
+"quota_warning_warn_at" = "هشدار در";
+"quota_warning_global_threshold_subtitle" = "درصدهای باقی مانده برای جلسات و بازه های هفتگی مگر اینکه ارائه دهنده آن ها را لغو کند.";
+"quota_warning_sound" = "صدای اعلان پخش کن";
+"quota_warning_provider_inherits" = "از تنظیمات هشدار سهمیه جهانی استفاده می کند مگر اینکه پنجره ای اینجا سفارشی شده باشد.";
+"quota_warning_customize_thresholds" = "آستانه های %@ شخصی سازی کنید";
+"quota_warning_enable_warnings" = "فعال کردن هشدارهای %@";
+"quota_warning_window_warn_at" = "%@ هشدار می دهد";
+"quota_warning_off" = "خاموش";
+"quota_warning_inherited" = "به ارث رسیده: %@";
+"quota_warning_depleted_only" = "فقط کاهش یافته";
+"quota_warning_upper" = "بالا";
+"quota_warning_lower" = "پایین تر";
+"apply" = "درخواست بده";
+"quit_app" = "خروج از CodexBar";
+
+/* Tab titles */
+"tab_general" = "عمومی";
+"tab_providers" = "ارائه دهندگان";
+"tab_display" = "نمایش";
+"tab_advanced" = "پیشرفته";
+"tab_about" = "درباره";
+"tab_debug" = "اشکال زدایی";
+
+/* Providers Pane */
+"select_a_provider" = "یک ارائه دهنده انتخاب کنید";
+"cancel" = "لغو";
+"last_fetch_failed" = "آخرین واکشی شکست خورد";
+"usage_not_fetched_yet" = "هنوز استفاده را دریافت نکرده ایم";
+"managed_account_storage_unreadable" = "ذخیره سازی حساب مدیریت شده قابل خواندن نیست. دسترسی به حساب زنده هنوز در دسترس است، اما اقدامات مدیریت شده افزودن، احراز هویت مجدد و حذف تا زمانی که فروشگاه قابل بازیابی شود، غیرفعال می شوند.";
+"remove_codex_account_title" = "حساب Codex حذف کنم؟";
+"remove" = "حذف";
+"managed_login_already_running" = "یک ورود Codex مدیریت شده هم اکنون در حال اجرا است. صبر کنید تا تمام شود قبل از اینکه حساب دیگری را اضافه یا دوباره احراز هویت کنید.";
+"managed_login_failed" = "ورود Codex کامل نشد. بررسی کنید که `codex --version` در ترمینال کار می کند. اگر مسدود macOS یا `codex` به سطل زباله منتقل شد، نصب های تکراری و قدیمی را حذف کنید، `npm install -g --include=optional @openai/codex@latest` را اجرا کنید و دوباره امتحان کنید.";
+"codex_login_output" = "خروجی ورود به کدکس:";
+"managed_login_missing_email" = "ورود Codex تکمیل شد، اما هیچ ایمیل حسابی در دسترس نبود. پس از اطمینان از اینکه حساب کاملا وارد شده است، دوباره تلاش کنید.";
+"login_success_notification_title" = "ورود %@ موفقیت آمیز بود";
+"login_success_notification_body" = "می توانید به اپلیکیشن بازگردید؛ احراز هویت تمام شد.";
+"workspace_selection_cancelled" = "CodexBar چندین فضای کاری پیدا کردم، اما هیچ فضای کاری انتخاب نشده بود.";
+"unsafe_managed_home" = "CodexBar از تغییر مسیر خانه مدیریت شده غیرمنتظره خودداری کرد: %@";
+"menu_bar_metric_title" = "معیار نوار منو";
+"menu_bar_metric_subtitle" = "انتخاب کنید کدام پنجره درصد نوار منو را تنظیم کند.";
+"menu_bar_metric_subtitle_deepseek" = "تعادل DeepSeek را در نوار منو نشان می دهد.";
+"menu_bar_metric_subtitle_moonshot" = "تعادل Moonshot / Kimi API را در نوار منو نشان می دهد.";
+"menu_bar_metric_subtitle_mistral" = "هزینه های Mistral API ماه جاری را در نوار منو نشان می دهد.";
+"menu_bar_metric_subtitle_kimik2" = "Kimi تیتراژ API کلید K2 در نوار منو نمایش داده می شود.";
+"automatic" = "اتوماتیک";
+"primary_api_key_limit" = "کلید اصلی (API حد کلید)";
+
+/* Display Pane */
+"section_menu_bar" = "نوار منو";
+"merge_icons_title" = "آیکون های ادغام";
+"merge_icons_subtitle" = "از یک آیکون نوار منو با یک تغییر دهنده ارائه دهنده استفاده کنید.";
+"switcher_shows_icons_title" = "سوئیچر آیکون ها را نشان می دهد";
+"switcher_shows_icons_subtitle" = "آیکون های ارائه دهنده را در سوئیچر نشان دهید (در غیر این صورت یک خط پیشرفت هفتگی نمایش دهید).";
+"show_most_used_provider_title" = "نمایش ارائه دهنده پرکاربرد";
+"show_most_used_provider_subtitle" = "نوار منو به طور خودکار ارائه دهنده ای را نشان می دهد که به محدودیت نرخ خود نزدیک تر است.";
+"menu_bar_shows_percent_title" = "نوار منو درصد را نشان می دهد";
+"menu_bar_shows_percent_subtitle" = "بارهای کریتر را با آیکون های برندینگ ارائه دهنده و درصدی جایگزین کنید.";
+"hide_critters_title" = "پنهان کردن موجودات";
+"hide_critters_subtitle" = "نمایش نوارهای ساده بدون چهره و تزئینات.";
+"display_mode_title" = "حالت نمایش";
+"display_mode_subtitle" = "انتخاب کنید که در نوار منو چه چیزی نمایش داده شود (Pace میزان مصرف در مقابل مورد انتظار را نشان می دهد).";
+"section_menu_content" = "محتوای منو";
+"show_usage_as_used_title" = "کاربرد نمایش همان طور که استفاده می شود";
+"show_usage_as_used_subtitle" = "نوارهای پیشرفت هنگام مصرف سهمیه پر می شوند (به جای اینکه باقی مانده را نشان دهند).";
+"show_quota_warning_markers_title" = "نشانگرهای هشدار سهمیه را نشان دهید";
+"show_quota_warning_markers_subtitle" = "علامت تیک آستانه را روی نوارهای استفاده هنگام پیکربندی هشدارهای سهمیه رسم کنید.";
+"weekly_progress_work_days_title" = "روزهای کاری پیشرفت هفتگی";
+"weekly_progress_work_days_subtitle" = "روزهای کاری را برای نشانگرهای نوار مصرف هفتگی و محاسبات سرعت تعیین کنید.";
+"show_reset_time_as_clock_title" = "نمایش زمان بازنشانی به صورت ساعت";
+"show_reset_time_as_clock_subtitle" = "زمان بازنشانی را به جای شمارش معکوس، به صورت مقادیر مطلق ساعت نمایش دهید.";
+"show_provider_changelog_links_title" = "لینک های تغییرات ارائه دهنده را نمایش دهید";
+"show_provider_changelog_links_subtitle" = "لینک های یادداشت های انتشار برای ارائه دهندگان پشتیبانی شده با پشتیبانی CLI به منو اضافه می شود.";
+"show_credits_extra_usage_title" = "نمایش اعتبارها + استفاده اضافی";
+"show_credits_extra_usage_subtitle" = "بخش های Codex اعتبارها و Claude استفاده اضافی را در منو نمایش دهید.";
+"show_all_token_accounts_title" = "نمایش همه حساب های توکن";
+"show_all_token_accounts_subtitle" = "حساب های توکن را در منو انباشته کنید (در غیر این صورت نوار تعویض حساب نمایش داده شود).";
+"multi_account_layout_title" = "چیدمان چندحسابی";
+"multi_account_layout_subtitle" = "کارت های حساب سوئیچینگ تقسیم شده یا کارت های حساب انباشته را انتخاب کنید.";
+"multi_account_layout_segmented" = "بخش بندی شده";
+"multi_account_layout_stacked" = "انباشته شده";
+"overview_tab_providers_title" = "ارائه دهندگان تب مرور کلی";
+"configure" = "پیکربندی کن...";
+"overview_enable_merge_icons_hint" = "فعال سازی Merge Icons برای پیکربندی ارائه دهندگان تب نمای کلی.";
+"overview_no_providers_hint" = "هیچ ارائه دهنده فعالی برای مرور کلی در دسترس نیست.";
+"overview_rows_follow_order" = "ردیف های نمای کلی همیشه مطابق با ترتیب ارائه دهنده انجام می شوند.";
+"overview_no_providers_selected" = "هیچ ارائه دهنده ای انتخاب نشده است";
+
+/* Advanced Pane */
+"section_keyboard_shortcut" = "میانبر کیبورد";
+"open_menu_shortcut_title" = "منوی باز";
+"open_menu_shortcut_subtitle" = "منوی نوار منو را از هر جایی فعال کنید.";
+"install_cli" = "نصب CLI";
+"install_cli_subtitle" = "Symlink CodexBarCLI به /usr/local/bin و /opt/homebrew/bin به عنوان codexbar.";
+"cli_not_found" = "CodexBarCLI در بسته برنامه ها یافت نمی شود.";
+"no_writable_bin_dirs" = "هیچ سطل قابل نوشتاری پیدا نشد.";
+"show_debug_settings_title" = "نمایش تنظیمات اشکال زدایی";
+"show_debug_settings_subtitle" = "ابزارهای عیب یابی را در تب اشکال زدایی آشکار کنید.";
+"surprise_me_title" = "سورپرایزم کن";
+"surprise_me_subtitle" = "بررسی کن که آیا دوست داری مأمورانت آنجا خوش بگذرانند یا نه.";
+"weekly_limit_confetti_title" = "کنفتی محدود هفتگی";
+"weekly_limit_confetti_subtitle" = "وقتی استفاده هفتگی ریست می شود، کنفتی تمام صفحه را پخش کنید.";
+"hide_personal_info_title" = "مخفی کردن اطلاعات شخصی";
+"hide_personal_info_subtitle" = "آدرس های ایمیل مبهم در نوار منو و رابط کاربری منو.";
+"show_provider_storage_usage_title" = "استفاده از ذخیره سازی ارائه دهنده را نمایش دهید";
+"show_provider_storage_usage_subtitle" = "استفاده محلی از دیسک را در منوها نمایش دهید. مسیرهای شناخته شده متعلق به ارائه دهندگان را در پس زمینه اسکن می کند.";
+"section_keychain_access" = "دسترسی Keychain";
+"keychain_access_caption" = "تمام قابلیت های خواندن و نوشتن Keychain را غیرفعال کنید. اگر macOS حتی بعد از کلیک روی همیشه اجازه مدام درخواست «ذخیره سازی امن» Chrome/Brave/Edge کند، از این گزینه استفاده کنید. وارد کردن کوکی مرورگر در حالت فعال بودن در دسترس نیست؛ هدرهای کوکی را به صورت دستی در Providers پیست کنید. Claude/Codex OAuth از طریق CLI هنوز کار می کند.";
+"disable_keychain_access_title" = "غیرفعال کردن دسترسی Keychain";
+"disable_keychain_access_subtitle" = "در حالت فعال بودن از هرگونه دسترسی Keychain جلوگیری می کند.";
+
+/* About Pane */
+"about_tagline" = "امیدوارم توکن های شما هرگز تمام نشوند—محدودیت های عامل را در نظر داشته باشید.";
+"link_github" = "GitHub";
+"link_website" = "وب سایت";
+"link_twitter" = "توییتر";
+"link_email" = "ایمیل";
+"check_updates_auto" = "به طور خودکار به روزرسانی ها را بررسی کنید";
+"update_channel" = "به روزرسانی کانال";
+"check_for_updates" = "به روزرسانی ها را بررسی کنید...";
+"updates_unavailable" = "به روزرسانی ها در این نسخه در دسترس نیستند.";
+"copyright" = "© ۲۰۲۶ پیتر استاینبرگر. MIT مجوز.";
+
+/* Debug Pane */
+"section_logging" = "چوب بری";
+"enable_file_logging" = "فعال سازی ثبت فایل";
+"enable_file_logging_subtitle" = "لاگ ها را برای %@ برای اشکال زدایی بنویسید.";
+"verbosity_title" = "پرسۆزی";
+"verbosity_subtitle" = "میزان جزئیات ثبت شده را کنترل می کند.";
+"open_log_file" = "فایل لاگ باز";
+"force_animation_next_refresh" = "انیمیشن فورس در رفرش بعدی";
+"force_animation_next_refresh_subtitle" = "انیمیشن بارگذاری پس از تازه سازی بعدی به طور موقت نمایش داده می شود.";
+"section_loading_animations" = "انیمیشن های بارگذاری";
+"loading_animations_caption" = "یک الگو انتخاب کنید و دوباره در نوار منو پخش کنید. «تصادفی» رفتار موجود را حفظ می کند.";
+"animation_random_default" = "تصادفی (پیش فرض)";
+"replay_selected_animation" = "بازپخش انیمیشن انتخاب شده";
+"blink_now" = "الان پلک بزن";
+"section_probe_logs" = "گزارش های کاوشگر";
+"probe_logs_caption" = "آخرین خروجی پروب برای اشکال زدایی را دریافت کنید؛ کپی متن کامل را نگه می دارد.";
+"fetch_log" = "لاگ جمع آوری";
+"copy" = "کپی";
+"save_to_file" = "ذخیره در فایل";
+"load_parse_dump" = "بارگذاری تحلیل dump";
+"rerun_provider_autodetect" = "Re-run provider autodetect";
+"loading" = "در حال بارگذاری...";
+"no_log_yet_fetch" = "هنوز گزارش نشده. برای بارگذاری بیاور.";
+"section_fetch_strategy" = "تلاش های استراتژی جمع آوری";
+"fetch_strategy_caption" = "تصمیمات و خطاهای خط لوله آخرین واکشی برای یک ارائه دهنده.";
+"section_openai_cookies" = "OpenAI کوکی";
+"openai_cookies_caption" = "وارد کردن کوکی + WebKit لاگ های آخرین تلاش OpenAI کوکی را استخراج می کند.";
+"no_log_yet" = "هنوز گزارش نشده. به روزرسانی کوکی های OpenAI در → Codex ارائه دهندگان برای اجرای واردات.";
+"section_caches" = "کش ها";
+"caches_caption" = "نتایج اسکن هزینه کش شده یا کش های کوکی مرورگر را پاک کنید.";
+"clear_cookie_cache" = "پاک کردن کش کوکی";
+"clear_cost_cache" = "پاک سازی کش هزینه";
+"section_notifications" = "اعلان ها";
+"notifications_caption" = "اعلان های تست را برای پنجره نشست ۵ ساعته فعال کنید (تخلیه /restored).";
+"post_depleted" = "پست تخلیه شده";
+"post_restored" = "پست بازسازی شد";
+"section_cli_sessions" = "جلسات CLI";
+"cli_sessions_caption" = "جلسات Codex/Claude CLI را بعد از پروب زنده نگه دارید. پس از جمع آوری داده ها، پیش فرض خارج می شود.";
+"keep_cli_sessions_alive" = "جلسات CLI را زنده نگه دارید";
+"keep_cli_sessions_alive_subtitle" = "رد کردن بین پروب ها (فقط برای اشکال زدایی).";
+"reset_cli_sessions" = "بازنشانی جلسات CLI";
+"section_error_simulation" = "شبیه سازی خطا";
+"error_simulation_caption" = "یک پیام خطای جعلی را در کارت منو برای تست چیدمان وارد کنید.";
+"set_menu_error" = "خطای تنظیم منوی";
+"clear_menu_error" = "خطای پاک کردن منو";
+"set_cost_error" = "خطای هزینه تنظیم";
+"clear_cost_error" = "خطای هزینه ای واضح";
+"section_cli_paths" = "مسیرهای CLI";
+"cli_paths_caption" = "Codex لایه های دودویی و PATH حل شد؛ ورود به راه اندازی PATH ضبط (تایم اوت کوتاه).";
+"codex_binary" = "Codex دودویی";
+"claude_binary" = "Claude دودویی";
+"effective_path" = "PATH مؤثر";
+"unavailable" = "در دسترس نیست";
+"login_shell_path" = "PATH پوسته ورود (ضبط راه انداز)";
+"cleared" = "تأیید شد.";
+"no_fetch_attempts" = "هنوز هیچ تلاشی برای آوردن توپ انجام نشده.";
+"macOS Tahoe can block menu bar apps in System Settings → Menu Bar → Allow in the Menu Bar. CodexBar is running, but macOS may be hiding its icon. Open Menu Bar settings and turn CodexBar on." = "macOS تاهو می تواند برنامه های نوار منو را در تنظیمات سیستم → نوار منو → اجازه را در نوار منو مسدود کند. CodexBar در حال اجرا است، اما ممکن است آیکون macOS مخفی شده باشد. تنظیمات نوار منو را باز کنید و CodexBar را روشن کنید.";
+
+/* Metric preferences */
+"metric_pref_automatic" = "اتوماتیک";
+"metric_pref_primary" = "انتخابات مقدماتی";
+"metric_pref_secondary" = "دبیرستان";
+"metric_pref_tertiary" = "دوره سوم";
+"metric_pref_extra_usage" = "استفاده اضافی";
+"metric_pref_average" = "میانگین";
+"metric_mistral_payg" = "Pay-as-you-go";
+"metric_mistral_monthly_plan" = "Monthly Plan";
+
+/* Display modes */
+"display_mode_percent" = "درصد";
+"display_mode_pace" = "سرعت";
+"display_mode_both" = "هر دو";
+"display_mode_reset_time" = "زمان بازنشانی";
+"display_mode_percent_desc" = "درصد باقی مانده /used را نشان دهید (مثلا 45%)";
+"display_mode_pace_desc" = "نمایش شاخص سرعت (مثلا +5%)";
+"display_mode_both_desc" = "هم درصد و هم سرعت را نشان دهید (مثلا 45% · +5%)";
+"display_mode_reset_time_desc" = "زمان بازنشانی متریک انتخاب شده را نشان دهید (مثلا ↻ ساعت ۳:۵۶ بعدازظهر)";
+
+/* Provider status */
+"status_operational" = "عملیاتی";
+"status_partial_outage" = "قطعی جزئی";
+"status_major_outage" = "قطعی عمده";
+"status_critical_issue" = "مسئله بحرانی";
+"status_maintenance" = "نگهداری";
+"status_unknown" = "وضعیت نامشخص";
+
+/* Refresh frequency */
+"refresh_manual" = "دفترچه راهنما";
+"refresh_1min" = "۱ دقیقه";
+"refresh_2min" = "۲ دقیقه";
+"refresh_5min" = "۵ دقیقه";
+"refresh_15min" = "۱۵ دقیقه";
+"refresh_30min" = "۳۰ دقیقه";
+
+/* Additional keys */
+"not_found" = "پیدا نشد";
+
+/* Cost estimation */
+"cost_header_estimated" = "هزینه (تخمینی)";
+"cost_estimate_hint" = "برآورد شده از چوب های محلی · ممکن است با صورتحساب شما متفاوت باشد";
+"No JetBrains IDE with AI Assistant detected. Install a JetBrains IDE and enable AI Assistant." = "هیچ JetBrains IDE ای با AI Assistant شناسایی نشد. یک JetBrains IDE نصب کنید و AI Assistant را فعال کنید.";
+"OpenRouter API token not configured. Set OPENROUTER_API_KEY environment variable or configure in Settings." = "OpenRouter API توکن پیکربندی نشده است. متغیر محیطی OPENROUTER_API_KEY تنظیم کنید یا در تنظیمات پیکربندی کنید.";
+"z.ai API token not found. Set apiKey in ~/.codexbar/config.json or Z_AI_API_KEY." = "z.ai API توکن پیدا نشد. apiKey را در ~/.codexbar/config.json یا Z_AI_API_KEY تنظیم کنید.";
+"Missing DeepSeek API key." = "کلید DeepSeek API گم شده.";
+"%@ is unavailable in the current environment." = "%@ در شرایط فعلی در دسترس نیست.";
+"All Systems Operational" = "تمام سیستم ها عملیاتی هستند";
+"Last 30 days" = "۳۰ روز آخر";
+"Last 30 days:" = "۳۰ روز آخر:";
+"This month" = "این ماه";
+"Store multiple OpenAI API keys." = "چند کلید OpenAI API را ذخیره کنید.";
+"Admin API key" = "کلید API مدیریت";
+"Open billing" = "صورتحساب باز";
+"Google accounts" = "Google حساب ها";
+"Store multiple Antigravity Google OAuth accounts for quick switching." = "چندین حساب Antigravity Google OAuth را برای تعویض سریع ذخیره کنید.";
+"Add Google Account" = "افزودن Google حساب کاربری";
+"Open Token Plan" = "طرح توکن باز";
+"Text Generation" = "تولید متن";
+"Text to Speech" = "تبدیل متن به گفتار";
+"Music Generation" = "تولید موسیقی";
+"Image Generation" = "تولید تصویر";
+"No local data found" = "داده محلی یافت نشد";
+"Credits unavailable; keep Codex running to refresh." = "اعتبارها در دسترس نیست؛ Codex را روشن نگه دارید تا تازه شوید.";
+"No available fetch strategy for minimax." = "هیچ استراتژی جمع آوری برای مینیمکس در دسترس نیست.";
+"No Cursor session found. Please log in to cursor.com in Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX, or Edge Canary. If you use Safari, grant CodexBar Full Disk Access in System Settings ▸ Privacy & Security. You can also sign in to Cursor from the CodexBar menu (Add / switch account)." = "جلسه Cursor پیدا نشد. لطفا در Safari، Chrome، مایکروسافت اج، بریو، آرک، دیا، چت جی پی تی اطلس، کرومیوم، هلیوم، ویوالدی، مرورگر یاندکس، فایرفاکس، زن، کولیبری، سایدکیک، اپرا، اپرا جی ایکس یا اج کنری وارد cursor.com شوید. اگر از Safari استفاده می کنید، به CodexBar دسترسی کامل دیسک در تنظیمات سیستم ▸ حریم خصوصی و امنیت اعطا کنید. همچنین می توانید از منوی CodexBar (افزودن / تغییر حساب) وارد Cursor شوید.";
+"No OpenCode session cookies found in browsers." = "هیچ کوکی نشست OpenCode در مرورگرها یافت نمی شود.";
+"No available fetch strategy for %@." = "استراتژی جمع آوری برای %@ موجود نیست.";
+"Today" = "امروز";
+"Today tokens" = "توکن های امروزی";
+"30d cost" = "هزینه 30d";
+"30d tokens" = "توکن های 30d";
+"Latest tokens" = "جدیدترین توکن ها";
+"Top model" = "مدل برتر";
+"Storage" = "ذخیره سازی";
+"Add Account..." = "افزودن حساب...";
+"Usage Dashboard" = "داشبورد استفاده";
+"Status Page" = "صفحه وضعیت";
+"Settings..." = "محیط ها...";
+"About CodexBar" = "درباره CodexBar";
+"Quit" = "ترک کن";
+"Last %d day" = "روز %d گذشته";
+"Last %d days" = "%d روز آخر";
+"%@ tokens" = "توکن های %@";
+"Latest billing day" = "آخرین روز صورتحساب";
+"Latest billing day (%@)" = "آخرین روز صورتحساب (%@)";
+"%@ left" = "%@ باقی مانده";
+"Resets %@" = "ریست %@";
+"Resets in %@" = "ریست ها در %@";
+"Resets now" = "اکنون بازنشانی می شود";
+"reset_tomorrow_format" = "فردا، %@";
+"Lasts until reset" = "تا زمان ریست ادامه دارد";
+"Updated %@" = "به روزرسانی %@";
+"Updated %@h ago" = "%@h پیش به روزرسانی شده است";
+"Updated %@m ago" = "%@m پیش به روزرسانی شده";
+"Updated just now" = "همین الان به روزرسانی شد";
+"Projected empty in %@" = "خالی در %@";
+"Runs out in %@" = "در %@ تمام می شود";
+"Pace: %@" = "سرعت: %@";
+"Pace: %@ · %@" = "سرعت: %@ · %@";
+"%@ · %@" = "%@ · %@";
+"≈ %d%% run-out risk" = "≈ %d%% خطر تمام شدن";
+"%d%% in deficit" = "%d%% در کسری بودجه";
+"%d%% in reserve" = "%d%% در ذخیره";
+"usage_percent_suffix_left" = "باقی مانده";
+"usage_percent_suffix_used" = "استفاده شده";
+"Store multiple DeepSeek API keys." = "چند کلید DeepSeek API را ذخیره کنید.";
+"This week" = "این هفته";
+"Week" = "هفته";
+"Month" = "ماه";
+"Models" = "مدل ها";
+"24h tokens" = "توکن های 24h";
+"Latest hour" = "آخرین ساعت";
+"Peak hour" = "ساعت اوج";
+"Top method" = "روش تاپ";
+"30d cash" = "30d پول نقد";
+"30d billing history from MiniMax web session" = "تاریخچه صورتحساب 30d از جلسه وب MiniMax";
+"AWS Cost Explorer billing can lag." = "AWS صورتحساب اکسپلورر هزینه ممکن است کند شود.";
+"Rate limit: %d / %@" = "محدودیت نرخ: %d / %@";
+"Key remaining" = "کلید باقی مانده";
+"No limit set for the API key" = "هیچ محدودیتی برای کلید API تعیین نشده است";
+"API key limit unavailable right now" = "API محدودیت کلید در حال حاضر در دسترس نیست";
+"This month: %@ tokens" = "این ماه: توکن های %@";
+"No utilization data yet." = "هنوز داده ای برای استفاده وجود ندارد.";
+"No %@ utilization data yet." = "هنوز داده های استفاده %@ نشده است.";
+"%@: %@%% used" = "%@: استفاده %@%%";
+"%dd" = "%d روز";
+"today" = "امروز";
+"just now" = "همین الان";
+"On pace" = "روی سرعت";
+"Runs out now" = "الان تمام می شود";
+"Projected empty now" = "اکنون خالی پیش بینی شده است";
+"Switch Account..." = "حساب را عوض کن...";
+"Update ready, restart now?" = "به روزرسانی آماده ای؟ الان ریستارت می کنی؟";
+"Daily" = "روزانه";
+"Hourly Tokens" = "توکن های ساعتی";
+"No data" = "داده ای وجود ندارد";
+"No usage breakdown data available." = "هیچ داده ای درباره تقسیم بندی استفاده در دسترس نیست.";
+
+"Today: %@ · %@ tokens" = "امروز: %@ · توکن های %@";
+"Today: %@" = "امروز: %@";
+"Today: %@ tokens" = "امروز: توکن های %@";
+"Last 30 days: %@ · %@ tokens" = "۳۰ روز آخر: %@ · توکن های %@";
+"Last 30 days: %@" = "۳۰ روز آخر: %@";
+"Est. total (30d): %@" = "برآورد کل (30d): %@";
+"Est. total (%@): %@" = "برآورد کل (%@): %@";
+"Hover a bar for details" = "برای جزئیات بیشتر روی یک نوار نگه دارید";
+"%@: %@ · %@ tokens" = "%@: %@ · توکن های %@";
+"No providers selected for Overview." = "هیچ ارائه دهنده ای برای مرور کلی انتخاب نشده است.";
+"No overview data available." = "داده های کلی در دسترس نیست.";
+"Auto uses the local IDE API first, then Google OAuth when the IDE is closed." = "Auto ابتدا از IDE API محلی استفاده می کند، سپس وقتی IDE بسته است Google OAuth می کند.";
+"Login with Google" = "با Google وارد شوید";
+
+/* Popup panels */
+"No usage configured." = "هیچ استفاده ای تنظیم نشده است.";
+"Quota" = "سهمیه";
+"tokens" = "توکن ها";
+"requests" = "درخواست ها";
+"Latest" = "جدیدترین ها";
+"Monthly" = "ماهانه";
+"Sonnet" = "سونت";
+"Overages" = "اضافه هزینه ها";
+"Activity" = "فعالیت ها";
+"Copied" = "کپی شده";
+"Copy error" = "خطای کپی";
+"Copy path" = "مسیر کپی";
+"Extra usage spent" = "استفاده اضافی صرف شده";
+"Credits remaining" = "اعتبار باقی‌مانده";
+"Using CLI fallback" = "استفاده از CLI پشتیبان";
+"Balance updates in near-real time (up to 5 min lag)" = "به روزرسانی تعادل تقریبا در زمان واقعی (تا ۵ دقیقه تأخیر)";
+"Daily billing data finalizes at 07:00 UTC" = "داده های صورتحساب روزانه در ساعت ۰۷:۰۰ نهایی می شود UTC";
+"%@ of %@ credits left" = "%@ از %@ اعتبار باقی مانده";
+"%@ of %@ bonus credits left" = "%@ از %@ اعتبار اضافی باقی مانده";
+"%@ / %@ (%@ remaining)" = "%@ / %@ (%@ باقی مانده)";
+"%@/%@ left" = "%@/%@ باقی مانده";
+"Gemini Flash" = "Gemini فلش";
+"Regenerates %@" = "بازسازی %@";
+"used after next regen" = "استفاده شده بعد از بازسازی بعدی";
+"after next regen" = "پس از بازسازی بعدی";
+"Near full" = "تقریبا پر";
+"Full in ~1 regen" = "بازیابی کامل ~۱";
+"Full in ~%.0f regens" = "بازسازی های کامل ~%.0f";
+"Overage usage" = "استفاده بیش از حد";
+"Overage cost" = "هزینه اضافی";
+"credits" = "اعتبارات";
+"Zen balance" = "تعادل ذن";
+"API spend" = "API خرج می کنم";
+"Extra usage" = "استفاده اضافی";
+"Quota usage" = "استفاده از سهمیه";
+"Your spend" = "هزینه شما";
+"%.0f%% used" = "%.0f%% استفاده می شود";
+"Usage history (today)" = "تاریخچه استفاده (امروز)";
+"Usage history (%d days)" = "تاریخچه استفاده (%d روز)";
+"%d percent remaining" = "%d درصد باقی مانده";
+"Unknown" = "نامشخص";
+"stale data" = "داده های کهنه";
+"No credits history data." = "هیچ داده ای درباره سابقه اعتباری وجود ندارد.";
+"No credits history data available." = "هیچ داده ای درباره تاریخچه اعتبارها در دسترس نیست.";
+"Credits history chart" = "جدول تاریخچه اعتبارها";
+"%d days of credits data" = "%d روز داده های اعتباری";
+"Usage breakdown chart" = "جدول تقسیم بندی مصرف";
+"%d days of usage data across %d services" = "%d روز داده های استفاده در سرویس های %d";
+"Cost history chart" = "نمودار تاریخچه هزینه";
+"%d days of cost data" = "%d روز داده های هزینه";
+"Plan utilization chart" = "نمودار استفاده از برنامه";
+"%d utilization samples" = "نمونه های %d استفاده";
+"Hourly Usage" = "استفاده ساعتی";
+"Usage remaining" = "کاربرد باقی مانده";
+"Usage used" = "کاربرد مورد استفاده";
+"API key verified. Ollama does not expose Cloud quota limits through the API." = "API کلید تأیید شد. Ollama محدودیت های سهمیه ابری را از طریق API آشکار نمی کند.";
+"Last 30 days: %@ tokens" = "۳۰ روز آخر: توکن های %@";
+"7d spend" = "7d خرج می کنم";
+"30d spend" = "30d خرج می کنم";
+"Cache read" = "خواندن کش";
+"Claude Admin API 30 day spend trend" = "Claude روند مدیریت API هزینه ۳۰ روزه";
+"OpenRouter API key spend trend" = "OpenRouter API روند کلیدی هزینه کرد";
+"z.ai hourly token trend" = "z.ai روند توکن ساعتی";
+"MiniMax 30 day token usage trend" = "MiniMax روند استفاده ۳۰ روزه از توکن";
+"Today cash" = "امروزه پول نقد";
+"DeepSeek 30 day token usage trend" = "DeepSeek روند استفاده ۳۰ روزه از توکن";
+"cache-hit input" = "ورودی کش و ضربه";
+"cache-miss input" = "ورودی کش-خطا";
+"output" = "خروجی";
+"Requests" = "درخواست ها";
+"Reported by OpenAI Admin API organization usage." = "گزارش شده توسط مدیر OpenAI API استفاده سازمانی.";
+"Reported by Mistral billing usage." = "بر اساس Mistral استفاده از صورتحساب گزارش شده است.";
+"Google OAuth" = "Google OAuth";
+"Add accounts via GitHub OAuth Device Flow on the selected host." = "حساب ها را از طریق GitHub OAuth Device Flow روی میزبان انتخاب شده اضافه کنید.";
+"Stores each signed-in Google account for quick Antigravity switching. Uses Antigravity.app OAuth when available, or ANTIGRAVITY_OAUTH_CLIENT_ID and ANTIGRAVITY_OAUTH_CLIENT_SECRET as an override." = "هر حساب کاربری وارد شده Google را برای تعویض سریع Antigravity ذخیره می کند. در صورت امکان از Antigravity.app OAuth استفاده می کند، یا ANTIGRAVITY_OAUTH_CLIENT_ID و ANTIGRAVITY_OAUTH_CLIENT_SECRET را به عنوان یک اورراید استفاده می کند.";
+"Manual cleanup: past sessions" = "تمیزکاری دستی: جلسات قبلی";
+"Clearing removes past resume, continue, and rewind history." = "پاک سازی گذشته را حذف می کند، ادامه می دهد و تاریخ را به عقب برمی گرداند.";
+"Manual cleanup: file checkpoints" = "پاک سازی دستی: نقاط کنترل فایل";
+"Clearing removes checkpoint restore data for previous edits." = "پاک کردن داده های بازیابی چک پوینت برای ویرایش های قبلی حذف می شود.";
+"Manual cleanup: saved plans" = "پاک سازی دستی: نقشه های ذخیره شده";
+"Clearing removes old plan-mode files." = "پاک کردن فایل های قدیمی حالت طرح را حذف می کند.";
+"Manual cleanup: debug logs" = "پاک سازی دستی: لاگ های اشکال زدایی";
+"Clearing removes past debug logs." = "پاک کردن لاگ های دیباگ گذشته را حذف می کند.";
+"Manual cleanup: attachment cache" = "پاک سازی دستی: کش ضمیمه";
+"Clearing removes cached large pastes or attached images." = "پاک کردن پیست های بزرگ کش شده یا تصاویر پیوست شده را حذف می کند.";
+"Manual cleanup: session metadata" = "پاک سازی دستی: فراداده نشست";
+"Clearing removes per-session environment metadata." = "پاک سازی متادیتای محیط به ازای هر جلسه را حذف می کند.";
+"Manual cleanup: shell snapshots" = "پاک سازی دستی: عکس های فوری گلوله";
+"Clearing removes leftover runtime shell snapshot files." = "پاک کردن فایل های اسنپ شات شل زمان اجرا باقی مانده را حذف می کند.";
+"Manual cleanup: legacy todos" = "پاک سازی دستی: کارهای میراثی";
+"Clearing removes legacy per-session task lists." = "پاک سازی فهرست وظایف قدیمی هر جلسه را حذف می کند.";
+"Manual cleanup: sessions" = "پاک سازی دستی: جلسات";
+"Clearing removes past Codex session history." = "پاک سازی تاریخچه جلسه Codex را حذف می کند.";
+"Manual cleanup: archived sessions" = "پاک سازی دستی: جلسات بایگانی شده";
+"Clearing removes archived Codex session history." = "پاک سازی تاریخچه نشست آرشیو شده Codex را حذف می کند.";
+"Manual cleanup: cache" = "پاک سازی دستی: کش";
+"Clearing removes provider-owned cached data." = "پاک سازی داده های کش شده متعلق به ارائه دهنده را حذف می کند.";
+"Manual cleanup: logs" = "پاک سازی دستی: لاگ ها";
+"Clearing removes local diagnostic logs." = "پاک سازی لاگ های تشخیصی محلی را حذف می کند.";
+"Manual cleanup: file history" = "پاک سازی دستی: تاریخچه فایل";
+"Clearing removes local edit checkpoint history." = "پاک سازی تاریخچه چک پوینت ویرایش محلی را حذف می کند.";
+"Manual cleanup: temporary data" = "پاک سازی دستی: داده های موقتی";
+"Clearing removes local temporary provider data." = "پاک سازی داده های ارائه دهنده موقت محلی را حذف می کند.";
+"Total: %@" = "کل: %@";
+"%d more items" = "%d آیتم های بیشتر";
+"Other (%d items)" = "موارد دیگر (%d مورد)";
+"Expand" = "گسترش";
+"Collapse" = "جمع کردن";
+"Cleanup ideas" = "ایده های پاکسازی";
+"%d unreadable item(s) skipped" = "%d آیتم(های) غیرقابل خواندن رد شده اند";
+
+"API key limit" = "محدودیت کلید API";
+"Auth" = "احراز هویت";
+"Auto" = "اتو";
+"Disabled — no recent data" = "غیرفعال — داده های اخیر وجود ندارد";
+"Limits not available" = "محدودیت ها در دسترس نیستند";
+"No usage yet" = "هنوز استفاده نشده";
+"Not fetched yet" = "هنوز نیامده";
+"Refreshing" = "تازه کننده";
+"Session" = "جلسه";
+"Source" = "منبع";
+"State" = "ایالت";
+"Unavailable" = "در دسترس نیست";
+"Weekly" = "هفتگی";
+"not detected" = "شناسایی نشد";
+"Estimated from local Codex logs for the selected account." = "برآورد شده از لاگ های محلی Codex حساب انتخاب شده.";
+"minimax_usage_amount_format" = "استفاده: %@ / %@";
+"minimax_used_percent_format" = "%@ استفاده شده";
+"minimax_service_text_generation" = "تولید متن";
+"minimax_service_text_to_speech" = "تبدیل متن به گفتار";
+"minimax_service_music_generation" = "تولید موسیقی";
+"minimax_service_image_generation" = "تولید تصویر";
+"minimax_service_lyrics_generation" = "تولید اشعار";
+"minimax_service_coding_plan_vlm" = "برنامه کدنویسی VLM";
+"minimax_service_coding_plan_search" = "جستجوی برنامه کدنویسی";
+
+/* Additional provider settings and alerts */
+"%@ is waiting for permission" = "%@ منتظر اجازه است";
+"%@ requests" = "درخواست های %@";
+"%@: %@ credits" = "%@: %@ اعتبار";
+"30d requests" = "درخواست های 30d";
+"4 days" = "۴ روز";
+"5 days" = "۵ روز";
+"7 days" = "۷ روز";
+"API key verifies Ollama Cloud access; cookies still expose quota limits." = "API کلید دسترسی Ollama ابری را تأیید می کند؛ کوکی ها هنوز محدودیت سهمیه را نشان می دهند.";
+"AWS access key ID. Can also be set with AWS_ACCESS_KEY_ID." = "AWS شناسه کلید دسترسی داشته باشید. همچنین می توان آن را با AWS_ACCESS_KEY_ID تنظیم کرد.";
+"AWS region. Can also be set with AWS_REGION." = "AWS منطقه. همچنین می توان آن را با AWS_REGION تنظیم کرد.";
+"AWS secret access key. Can also be set with AWS_SECRET_ACCESS_KEY." = "AWS کلید دسترسی مخفی. همچنین می توان آن را با AWS_SECRET_ACCESS_KEY تنظیم کرد.";
+"Access key ID" = "شناسه کلید دسترسی";
+"Add Account" = "افزودن حساب کاربری";
+"Adding Account…" = "اضافه کردن حساب...";
+"Antigravity login failed" = "ورود Antigravity ناموفق";
+"Antigravity login timed out" = "ورود Antigravity به پایان رسید";
+"Auth source" = "منبع احراز هویت";
+"Automatic imports browser cookies from Xiaomi MiMo." = "کوکی های مرورگر را به طور خودکار از شیائومی MiMo وارد می کند.";
+"Automatic imports Windsurf session data from Chromium browser localStorage." = "وارد کردن خودکار داده های نشست Windsurf از مرورگر Chromium localStorage.";
+"Automatic imports browser cookies from Bailian." = "کوکی های مرورگر را به طور خودکار از Bailian وارد می کند.";
+"Automatically imports browser cookies." = "کوکی های مرورگر را به طور خودکار وارد می کند.";
+"Automatically imports browser session cookies." = "کوکی های نشست مرورگر را به طور خودکار وارد می کند.";
+"Azure OpenAI deployment name. AZURE_OPENAI_DEPLOYMENT_NAME is also supported." = "Azure OpenAI نام اعزام. AZURE_OPENAI_DEPLOYMENT_NAME نیز پشتیبانی می شود.";
+"Azure OpenAI key" = "کلید Azure OpenAI";
+"Azure OpenAI resource endpoint. AZURE_OPENAI_ENDPOINT is also supported." = "Azure OpenAI نقطه پایانی منابع. AZURE_OPENAI_ENDPOINT نیز پشتیبانی می شود.";
+"Base URL" = "پایگاه URL";
+"Base URL for the LLM-API-Key-Proxy instance." = "URL پایه برای نمونه LLM-API-Key-Proxy.";
+"Browser cookies" = "کوکی های مرورگر";
+"Cap end" = "انتهای نهایی";
+"Cap start" = "شروع کپ";
+"Capacity End" = "پایان ظرفیت";
+"Capacity Start" = "شروع ظرفیت";
+"Changelog" = "فهرست تغییرات";
+"Choose the Moonshot/Kimi API host for international or China mainland accounts." = "میزبان Moonshot/Kimi API را برای حساب های بین المللی یا حساب های سرزمین اصلی چین انتخاب کنید.";
+"CodexBar can't replace a system account that is signed in with an API key only setup." = "نمی CodexBar حساب سیستمی که فقط با کلید API وارد شده جایگزین شود.";
+"CodexBar could not find saved auth for that account. Re-authenticate it and try again." = "CodexBar نتوانستم احراز هویت ذخیره شده آن حساب را پیدا کنم. دوباره احراز هویت کنید و دوباره تلاش کنید.";
+"CodexBar could not read managed account storage. Recover the store before adding another account." = "CodexBar نمی توانست ذخیره سازی حساب مدیریت شده را بخواند. قبل از اضافه کردن حساب جدید، فروشگاه را بازیابی کنید.";
+"CodexBar could not read saved auth for that account. Re-authenticate it and try again." = "CodexBar نمی توانستم احراز هویت ذخیره شده آن حساب را بخوانم. دوباره احراز هویت کنید و دوباره تلاش کنید.";
+"CodexBar could not read the current system account on this Mac." = "CodexBar نمی توانستم حساب فعلی سیستم را روی این مک بخوانم.";
+"CodexBar could not replace the live Codex auth on this Mac." = "CodexBar نتوانستم احراز هویت زنده Codex این مک را جایگزین کنم.";
+"CodexBar could not safely preserve the current system account before switching." = "CodexBar نتوانستم حساب فعلی سیستم را قبل از تغییر به طور ایمن حفظ کنم.";
+"CodexBar could not save the current system account before switching." = "CodexBar نتوانستم حساب فعلی سیستم را قبل از تغییر ذخیره کنم.";
+"CodexBar could not update managed account storage." = "CodexBar نتوانست ذخیره سازی حساب مدیریت شده را به روزرسانی کند.";
+"CodexBar found another managed account that already uses the current system account. Resolve the duplicate account before switching." = "CodexBar یک حساب مدیریت شده دیگر پیدا کردم که قبلا از حساب فعلی سیستم استفاده می کند. قبل از تغییر حساب، حساب تکراری را حل کنید.";
+"CodexBar will ask macOS Keychain for “%@” so it can decrypt browser cookies and authenticate your account. Click OK to continue." = "CodexBar از macOS Keychain درخواست «%@» می کند تا بتواند کوکی های مرورگر را رمزگشایی کرده و حساب شما را احراز هویت کند. برای ادامه روی OK کلیک کنید.";
+"CodexBar will ask macOS Keychain for the Claude Code OAuth token so it can fetch your Claude usage. Click OK to continue." = "CodexBar از macOS Keychain کد Claude توکن OAuth را درخواست می کند تا بتواند استفاده Claude شما را دریافت کند. برای ادامه روی OK کلیک کنید.";
+"CodexBar will ask macOS Keychain for your Amp cookie header so it can fetch usage. Click OK to continue." = "CodexBar از macOS Keychain Amp هدر کوکی تان را می خواهید تا بتواند استفاده را دریافت کند. برای ادامه روی OK کلیک کنید.";
+"CodexBar will ask macOS Keychain for your Augment cookie header so it can fetch usage. Click OK to continue." = "CodexBar از macOS Keychain Augment هدر کوکی تان را می خواهید تا بتواند استفاده را دریافت کند. برای ادامه روی OK کلیک کنید.";
+"CodexBar will ask macOS Keychain for your Claude cookie header so it can fetch Claude web usage. Click OK to continue." = "CodexBar از macOS Keychain هدر کوکی Claude شما را می خواهید تا بتواند استفاده Claude وب را دریافت کند. برای ادامه روی OK کلیک کنید.";
+"CodexBar will ask macOS Keychain for your Cursor cookie header so it can fetch usage. Click OK to continue." = "CodexBar از macOS Keychain Cursor هدر کوکی تان را می خواهید تا بتواند استفاده را دریافت کند. برای ادامه روی OK کلیک کنید.";
+"CodexBar will ask macOS Keychain for your Factory cookie header so it can fetch usage. Click OK to continue." = "CodexBar از macOS Keychain Factory هدر کوکی تان را می خواهید تا بتواند استفاده را دریافت کند. برای ادامه روی OK کلیک کنید.";
+"CodexBar will ask macOS Keychain for your GitHub Copilot token so it can fetch usage. Click OK to continue." = "CodexBar از macOS Keychain توکن GitHub Copilot شما را درخواست می کند تا بتواند استفاده را دریافت کند. برای ادامه روی OK کلیک کنید.";
+"CodexBar will ask macOS Keychain for your Kimi K2 API key so it can fetch usage. Click OK to continue." = "CodexBar از macOS Keychain کلید API K2 Kimi می خواهید تا بتواند استفاده را دریافت کند. برای ادامه روی OK کلیک کنید.";
+"CodexBar will ask macOS Keychain for your Kimi auth token so it can fetch usage. Click OK to continue." = "CodexBar از macOS Keychain توکن احراز هویت Kimi می خواهید تا بتواند استفاده را دریافت کند. برای ادامه روی OK کلیک کنید.";
+"CodexBar will ask macOS Keychain for your MiniMax API token so it can fetch usage. Click OK to continue." = "CodexBar از macOS Keychain توکن MiniMax API شما را درخواست می کند تا بتواند استفاده را دریافت کند. برای ادامه روی OK کلیک کنید.";
+"CodexBar will ask macOS Keychain for your MiniMax cookie header so it can fetch usage. Click OK to continue." = "CodexBar از macOS Keychain MiniMax هدر کوکی تان را می خواهید تا بتواند استفاده را دریافت کند. برای ادامه روی OK کلیک کنید.";
+"CodexBar will ask macOS Keychain for your OpenAI cookie header so it can fetch Codex dashboard extras. Click OK to continue." = "CodexBar از macOS Keychain OpenAI هدر کوکی تان را می خواهید تا اضافه های داشبورد Codex را دریافت کند. برای ادامه روی OK کلیک کنید.";
+"CodexBar will ask macOS Keychain for your OpenCode cookie header so it can fetch usage. Click OK to continue." = "CodexBar از macOS Keychain OpenCode هدر کوکی تان را می خواهید تا بتواند استفاده را دریافت کند. برای ادامه روی OK کلیک کنید.";
+"CodexBar will ask macOS Keychain for your Synthetic API key so it can fetch usage. Click OK to continue." = "CodexBar از macOS Keychain کلید Synthetic API می خواهید تا بتواند استفاده را دریافت کند. برای ادامه روی OK کلیک کنید.";
+"CodexBar will ask macOS Keychain for your z.ai API token so it can fetch usage. Click OK to continue." = "CodexBar از macOS Keychain توکن z.ai API شما را درخواست می کند تا بتواند استفاده را دریافت کند. برای ادامه روی OK کلیک کنید.";
+"Could not open Cursor login in your browser." = "نتوانستم مرورگر Cursor ورود را باز کنم.";
+"Could not open browser for Antigravity" = "برای مدت Antigravity نتوانستم مرورگر را باز کنم";
+"Credits used" = "اعتبارات استفاده شده";
+"Day" = "روز";
+"Deployment" = "استقرار";
+"Drag to reorder" = "درگ برای بازآرایی";
+"Sort providers alphabetically" = "مرتب‌سازی ارائه‌دهندگان بر اساس حروف الفبا";
+"Sort providers alphabetically (enabled first)" = "مرتب‌سازی الفبایی ارائه‌دهندگان (فعال‌ها ابتدا)";
+"Sorted alphabetically (enabled first) — click to use your custom order" = "مرتب‌شده بر اساس حروف الفبا (فعال‌ها ابتدا) — برای استفاده از ترتیب سفارشی کلیک کنید";
+"Endpoint" = "نقطه پایان";
+"Enterprise host" = "میزبان سازمانی";
+"Extra usage balance: %@" = "تعادل استفاده اضافی: %@";
+"Keychain Access Required" = "دسترسی Keychain مورد نیاز است";
+"Kiro menu bar value" = "Kiro مقدار نوار منو";
+"Label" = "برچسب";
+"No organizations loaded. Click Refresh after setting your API key." = "هیچ سازمانی بارگذاری نشده بود. پس از تنظیم کلید API روی «تازه سازی» کلیک کنید.";
+"No output captured." = "هیچ خروجی ای ضبط نشد.";
+"No system account" = "بدون حساب سیستمی";
+"Oasis-Token" = "اوسیس-توکن";
+"Open Augment (Log Out & Back In)" = "Augment باز (خروج و ورود دوباره)";
+"Open Codebuff Dashboard" = "داشبورد Open Codebuff";
+"Open Command Code Settings" = "تنظیمات باز Command Code";
+"Open Crof dashboard" = "داشبورد Open Crof";
+"Open Manus" = "Manus باز";
+"Open MiMo Balance" = "تعادل باز MiMo";
+"Open Moonshot Console" = "کنسول Moonshot باز";
+"Open Ollama API Keys" = "کلیدهای باز Ollama API";
+"Open StepFun Platform" = "پلتفرم StepFun باز";
+"Open T3 Chat Settings" = "تنظیمات باز T3 Chat";
+"Open Volcengine Ark Console" = "کنسول Open Volcengine Ark";
+"Open legacy provider docs" = "مستندات ارائه دهنده قدیمی باز";
+"Open projects" = "پروژه های باز";
+"Open this URL manually to continue login:\n\n%@" = "این URL را به صورت دستی باز کنید تا ورود ادامه یابد \n\n%@";
+"Optional organization ID for accounts linked to multiple Anthropic organizations." = "شناسه سازمان اختیاری برای حساب هایی که به چندین سازمان انسان شناس متصل هستند.";
+"Optional. Applies to the configured Admin API key; selected token accounts do not inherit OPENAI_PROJECT_ID." = "اختیاری. روی کلید API مدیر پیکربندی شده اعمال می شود؛ حساب های توکن منتخب OPENAI_PROJECT_ID را به ارث نمی برند.";
+"Optional. Enter your GitHub Enterprise host, for example octocorp.ghe.com. Leave blank for github.com." = "اختیاری. برای مثال، میزبان GitHub Enterprise شما وارد octocorp.ghe.com. برای github.com خالی بگذارید.";
+"Optional. Leave blank to discover and aggregate projects visible to the API key." = "اختیاری. برای کشف و تجمیع پروژه هایی که با کلید API قابل مشاهده هستند، صفحه خالی بگذارید.";
+"Org ID (optional)" = "شناسه سازمان (اختیاری)";
+"Organizations" = "سازمان ها";
+"Password" = "رمز عبور";
+"%@ authentication is disabled." = "%@ احراز هویت غیرفعال است.";
+"%@ cookies are disabled." = "%@ کوکی ها غیرفعال هستند.";
+"%@ web API access is disabled." = "دسترسی %@ وب API غیرفعال است.";
+"Disable %@ dashboard cookie usage." = "استفاده %@ از کوکی داشبورد را غیرفعال کنید.";
+"Keychain access is disabled in Advanced, so browser cookie import is unavailable." = "دسترسی Keychain در حالت پیشرفته غیرفعال است، بنابراین وارد کردن کوکی مرورگر در دسترس نیست.";
+"Manually paste an %@ from a browser session." = "یک %@ را به صورت دستی از یک جلسه مرورگر پیست کنید.";
+"Paste a Cookie header captured from %@." = "یک هدر کوکی که از %@ گرفته شده بچسبان.";
+"Paste a Cookie header from %@." = "یک هدر کوکی از %@ بچسبان.";
+"Paste a Cookie header or cURL capture from %@." = "یک هدر کوکی یا cURL را از %@ کپچر بچسبانید.";
+"Paste a Cookie header or full cURL capture from %@." = "یک هدر کوکی یا ضبط کامل cURL از %@ را بچسبانید.";
+"Paste a Cookie or Authorization header from %@." = "یک هدر کوکی یا مجوز از %@ بچسبانید.";
+"Paste a full cookie header or the %@ value." = "یک هدر کامل کوکی یا مقدار %@ را بچسبانید.";
+"Paste a Cookie header or full cURL capture from T3 Chat settings." = "یک هدر کوکی یا ضبط کامل CURL از تنظیمات T3 Chat بچسبان.";
+"Paste the Cookie header from a request to admin.mistral.ai. Must contain an ory_session_* cookie." = "هدر کوکی را از درخواست به admin.mistral.ai بچسبانید. باید یک کوکی ory_session_* داشته باشد.";
+"Paste the Oasis-Token from a logged-in browser session on platform.stepfun.com." = "Oasis-Token را از یک نشست مرورگر وارد شده در platform.stepfun.com بچسبانید.";
+"Paste the %@ JSON bundle from %@." = "بسته %@ JSON را از %@ پیست کنید.";
+"Paste the %@ value or a full Cookie header." = "مقدار %@ یا یک هدر کامل کوکی را بچسبانید.";
+"Personal account" = "حساب شخصی";
+"Project ID" = "شناسه پروژه";
+"Re-auth" = "تجدید احراز هویت";
+"Re-login at claude.ai" = "ورود مجدد در claude.ai";
+"Re-authenticating…" = "احراز هویت مجدد...";
+"Refresh Session" = "جلسه تازه سازی";
+"Refresh organizations" = "سازمان های تازه سازی";
+"Region" = "منطقه";
+"Reload" = "بارگذاری مجدد";
+"Reorder" = "بازآرایی";
+"Secret access key" = "کلید دسترسی مخفی";
+"Series" = "سری ها";
+"Service" = "خدمت";
+"Show or hide Kiro credits, percent, or both next to the menu bar icon." = "Kiro اعتبار، درصد یا هر دو را کنار آیکون نوار منو نمایش یا پنهان کنید.";
+"Show usage for organizations you belong to. Personal account is always shown." = "استفاده از سازمان هایی که عضو آن هستید را نشان دهید. حساب شخصی همیشه نمایش داده می شود.";
+"Sign in to cursor.com in your browser, then refresh Cursor in CodexBar." = "در مرورگر خود وارد cursor.com شوید، سپس Cursor را در CodexBar تازه سازی کنید.";
+"Simulated error text" = "متن خطای شبیه سازی شده";
+"StepFun platform account (phone number or email)." = "StepFun حساب پلتفرم (شماره تلفن یا ایمیل).";
+"Stored in ~/.codexbar/config.json." = "ذخیره شده در ~/.codexbar/config.json.";
+"Stored in ~/.codexbar/config.json. AZURE_OPENAI_API_KEY is also supported." = "ذخیره سازی در ~/.codexbar/config.json. AZURE_OPENAI_API_KEY نیز پشتیبانی می شود.";
+"Stored in ~/.codexbar/config.json. For the official Kimi API, use Moonshot / Kimi API." = "ذخیره شده در ~/.codexbar/config.json. برای Kimi API رسمی، از Moonshot / Kimi API استفاده کنید.";
+"Stored in ~/.codexbar/config.json. Get your API key from the Volcengine Ark console." = "ذخیره شده در ~/.codexbar/config.json. کلید API خود را از کنسول Volcengine Ark دریافت کنید.";
+"Stored in ~/.codexbar/config.json. Get your key from Ollama settings." = "ذخیره شده در ~/.codexbar/config.json. کلید خود را از تنظیمات Ollama بگیرید.";
+"Stored in ~/.codexbar/config.json. Get your key from console.deepgram.com." = "ذخیره شده در ~/.codexbar/config.json. کلیدت را از console.deepgram.com بگیر.";
+"Stored in ~/.codexbar/config.json. Get your key from elevenlabs.io/app/settings/api-keys." = "ذخیره شده در ~/.codexbar/config.json. کلید خود را از elevenlabs.io/app/settings/api-keys. دریافت کنید";
+"Stored in ~/.codexbar/config.json. Get your key from openrouter.ai/settings/keys and set a key spending limit there to enable API key quota tracking." = "ذخیره شده در ~/.codexbar/config.json. کلید خود را از openrouter.ai/settings/keys بگیرید و یک محدودیت هزینه کلید آنجا تعیین کنید تا ردیابی سهمیه کلید فعال API.";
+"Stored in ~/.codexbar/config.json. In Warp, open Settings > Platform > API Keys, then create one." = "ذخیره شده در ~/.codexbar/config.json. در Warp، تنظیمات را > Platform > API Keys باز کنید و سپس یکی بسازید.";
+"Stored in ~/.codexbar/config.json. Metrics require Groq Enterprise Prometheus access." = "ذخیره سازی در معیارهای ~/.codexbar/config.json. نیازمند دسترسی Groq پرومتئوس سازمانی است.";
+"Stored in ~/.codexbar/config.json. OPENAI_ADMIN_KEY is preferred; OPENAI_API_KEY still works." = "نگهداری در ~/.codexbar/config.json. OPENAI_ADMIN_KEY ترجیح داده می شود؛ OPENAI_API_KEY هنوز کار می کند.";
+"Stored in ~/.codexbar/config.json. Requires an Anthropic Admin API key." = "ذخیره سازی در ~/.codexbar/config.json. نیاز به کلید API مدیریت انسان شناسی دارد.";
+"Stored in ~/.codexbar/config.json. Used for /v1/quota-stats." = "ذخیره شده در ~/.codexbar/config.json. برای /v1/quota-stats.";
+"Stored in ~/.codexbar/config.json. You can also provide CODEBUFF_API_KEY or let CodexBar read ~/.config/manicode/credentials.json (created by `codebuff login`)." = "ذخیره شده در ~/.codexbar/config.json. همچنین می توانید CODEBUFF_API_KEY ارائه دهید یا اجازه دهید CodexBar ~/.config/manicode/credentials.json (ایجاد شده توسط `codebuff login`) را بخوانند.";
+"Stored in ~/.codexbar/config.json. You can also provide CROF_API_KEY." = "ذخیره شده در ~/.codexbar/config.json. همچنین می توانید CROF_API_KEY ارائه دهید.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or ~/.local/share/kilo/auth.json (kilo.access)." = "ذخیره شده در ~/.codexbar/config.json. همچنین می توانید KILO_API_KEY یا ~/.local/share/kilo/auth.json (kilo.access) ارائه دهید.";
+"T3 Chat cookie" = "T3 Chat کوکی";
+"That account is no longer available in CodexBar. Refresh the account list and try again." = "آن حساب دیگر در CodexBar در دسترس نیست. لیست حساب ها را تازه کنید و دوباره تلاش کنید.";
+"The browser login did not complete in time. Try Antigravity login again." = "ورود به مرورگر به موقع کامل نشد. دوباره Antigravity حساب کاربری امتحان کن.";
+"Timed out waiting for Cursor login. %@" = "زمان خروج منتظر ورود Cursor هستم. %@";
+"Timed out waiting for Cursor login. %@ Last error: %@" = "زمان خروج منتظر ورود Cursor هستم. %@ آخرین خطا: %@";
+"Today requests" = "درخواست های امروز";
+"Total (30d): %@ credits" = "مجموع (30d): %@ اعتبار";
+"Username" = "نام کاربری";
+"Uses username + password to login and obtain an Oasis-Token automatically." = "برای ورود و دریافت خودکار توکن اوسیس از نام کاربری + رمز عبور استفاده می کند.";
+"Uses username + password to login and obtain an %@ automatically." = "از نام کاربری + رمز عبور برای ورود و دریافت خودکار %@ استفاده می کند.";
+"Utilization End" = "پایان استفاده";
+"Utilization Start" = "شروع استفاده";
+"Verbosity" = "پرسۆزی";
+"Windsurf session JSON bundle" = "Windsurf جلسه JSON بسته";
+"Workspace ID" = "شناسه فضای کاری";
+"Your StepFun platform password. Used to login and obtain a session token." = "رمز عبور پلتفرم StepFun شما. برای ورود و دریافت توکن نشست استفاده می شود.";
+"claude /login exited with status %d." = "کلود با %d جایگاه /login خارج شد.";
+"codex login exited with status %d." = "ورود به کدکس با وضعیت %d خارج شد.";
+"Cookie: …\n\nor paste a cURL capture from the Abacus AI dashboard" = "کوکی: ... \n\n یا کپچر cURL را از داشبورد Abacus AI پیست کنید";
+"Cookie: …\n\nor paste the __Secure-next-auth.session-token value" = "کوکی: ... \n\n یا مقدار توکن __Secure-next-auth.session-token را جای گذاری کنید";
+"Cookie: …\n\nor paste the kimi-auth token value" = "کوکی: ... \n\n یا مقدار توکن kimi-authentic را پیست کنید";
+"session_id=...\n\nor paste just the session_id value" = "session_id=... \n\n یا فقط مقدار session_id را بچسباند";
+"Clear" = "پاک است";
+"No matching providers" = "هیچ ارائه دهنده تطبیقی وجود ندارد";
+"Search providers" = "ارائه دهندگان جستجو";
+
+"language_vietnamese" = "ویتنامی ها";
+"language_indonesian" = "زبان اندونزی";
+
+"Request quota: %@ / %@" = "سهمیه درخواستی: %@ / %@";
+"language_arabic" = "العربية";
+"language_persian" = "فارسی";
+"language_thai" = "ไทย";
+"Limit Reset Credits" = "اعتبارهای بازنشانی محدودیت";
+"1 manual reset available" = "۱ بازنشانی دستی موجود است";
+"%d manual resets available" = "%d بازنشانی دستی موجود است";
+"Next expires %@" = "مورد بعدی در %@ منقضی می‌شود";
+"byte_unit_byte" = "بایت";
+"byte_unit_bytes" = "بایت";
+"byte_unit_kilobyte" = "کیلوبایت";
+"byte_unit_kilobytes" = "کیلوبایت";
+"byte_unit_megabyte" = "مگابایت";
+"byte_unit_megabytes" = "مگابایت";
+"byte_unit_gigabyte" = "گیگابایت";
+"byte_unit_gigabytes" = "گیگابایت";
diff --git a/Sources/CodexBar/Resources/fr.lproj/Localizable.strings b/Sources/CodexBar/Resources/fr.lproj/Localizable.strings
new file mode 100644
index 0000000000..ad47dc984d
--- /dev/null
+++ b/Sources/CodexBar/Resources/fr.lproj/Localizable.strings
@@ -0,0 +1,1105 @@
+/* English localization for CodexBar (base/fallback) */
+
+" providers" = " fournisseurs";
+"(System)" = "(System)";
+"30d" = "30d";
+"A managed Codex login is already running. Wait for it to finish before adding " = "Une connexion Codex gérée est déjà en cours d'exécution. Attendez qu'il soit terminé avant d'ajouter";
+"API key" = "Clé API";
+"API region" = "Région API";
+"API token" = "Jeton API";
+"API tokens" = "Jetons API";
+"About" = "À propos";
+"Account" = "Compte";
+"Accounts" = "Comptes";
+"Accounts subtitle" = "Sous-titre des comptes";
+"Active" = "Actif";
+"Add" = "Ajouter";
+"Add Workspace" = "Ajouter un espace de travail";
+"Advanced" = "Avancé";
+"All" = "Tout";
+"Always allow prompts" = "Toujours autoriser les invites";
+"Animation pattern" = "Modèle d'animation";
+"Antigravity login is managed in the app" = "La connexion antigravité est gérée dans l’app";
+"Applies only to the Security.framework OAuth keychain reader." = "S’applique uniquement au lecteur de Trousseau OAuth Security.framework.";
+"Auto falls back to the next source if the preferred one fails." = "Revient automatiquement à la source suivante si la source préférée échoue.";
+"Auto uses API first, then falls back to CLI on auth failures." = "Auto utilise d'abord l'API, puis revient à la CLI en cas d'échec d'authentification.";
+"Auto-detect" = "Auto-detect";
+"Auto-refresh is off; use the menu's Refresh command." = "L'actualisation automatique est désactivée ; utilisez la commande Actualiser du menu.";
+"Auto-refresh: hourly · Timeout: 10m" = "Actualisation automatique : toutes les heures · Délai d'expiration : 10 min";
+"Automatic" = "Automatique";
+"Automatic imports browser cookies and WorkOS tokens." = "Importe automatiquement les cookies du navigateur et les jetons WorkOS.";
+"Automatic imports browser cookies and local storage tokens." = "Importe automatiquement les cookies du navigateur et les jetons de stockage local.";
+"Automatic imports browser cookies for dashboard extras." = "Importe automatiquement les cookies du navigateur pour les extras du tableau de bord.";
+"Automatic imports browser cookies for the web API." = "Importe automatiquement les cookies du navigateur pour l'API Web.";
+"Automatic imports browser cookies from Model Studio/Bailian." = "Importe automatiquement les cookies du navigateur depuis Model Studio/Bailian.";
+"Automatic imports browser cookies from admin.mistral.ai." = "Importe automatiquement les cookies du navigateur depuis admin.mistral.ai.";
+"Automatic imports browser cookies from opencode.ai." = "Importe automatiquement les cookies du navigateur depuis opencode.ai.";
+"Automatic imports browser cookies or stored sessions." = "Importe automatiquement les cookies du navigateur ou les sessions stockées.";
+"Automatic imports browser cookies." = "Importe automatiquement les cookies du navigateur.";
+"Automatically imports browser session cookie." = "Importe automatiquement le cookie de session du navigateur.";
+"Automatically opens CodexBar when you start your Mac." = "Ouvre automatiquement CodexBar lorsque vous démarrez votre Mac.";
+"Automation" = "Automatisation";
+"Average (\\(label1) + \\(label2))" = "Moyenne (\\(label1) + \\(label2))";
+"Average (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))" = "Moyenne (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))";
+"Avoid Keychain prompts" = "Éviter les invites du Trousseau";
+"Balance" = "Balance";
+"Battery Saver" = "Économiseur de batterie";
+"Bordered" = "Bordé";
+"Build" = "Version";
+"Built \\(buildTimestamp)" = "Construit \\(buildTimestamp)";
+"Buy Credits..." = "Acheter des crédits...";
+"Buy Credits…" = "Acheter des crédits…";
+"CLI paths" = "Chemins CLI";
+"CLI sessions" = "Sessions CLI";
+"Caches" = "Caches";
+"Cancel" = "Annuler";
+"Check for Updates…" = "Rechercher les mises à jour…";
+"Check for updates automatically" = "Rechercher automatiquement les mises à jour";
+"Check if you like your agents having some fun up there." = "Vérifiez si vous aimez que vos agents s'amusent là-haut.";
+"Check provider status" = "Vérifier le statut du fournisseur";
+"Choose Codex workspace" = "Choisissez l'espace de travail Codex";
+"Choose the MiniMax host (global .io or China mainland .com)." = "Choisissez l'hôte MiniMax (global .io ou Chine continentale .com).";
+"Choose up to " = "Choisissez jusqu'à ";
+"Choose up to \\(Self.maxOverviewProviders) providers" = "Choisissez jusqu'à \\(Self.maxOverviewProviders) fournisseurs";
+"Choose up to \\(count) providers" = "Choisissez jusqu'à \\(count) fournisseurs";
+"Choose what to show in the menu bar (Pace shows usage vs. expected)." = "Choisissez ce que vous voulez afficher dans la barre de menu (Pace affiche l'utilisation par rapport à celle attendue).";
+"Choose which Codex account CodexBar should follow." = "Choisissez quel compte Codex CodexBar doit suivre.";
+"Choose which window drives the menu bar percent." = "Choisissez quelle fenêtre gère le pourcentage de la barre de menus.";
+"Chrome" = "Chrome";
+"Claude CLI not found" = "Claude CLI introuvable";
+"Claude binary" = "Binaire Claude";
+"Claude cookies" = "cookies Claude";
+"Claude login failed" = "La connexion de Claude a échoué";
+"Claude login timed out" = "La connexion de Claude a expiré";
+"Close" = "Fermer";
+"Code review" = "Revue de code";
+"Codex CLI not found" = "Codex CLI introuvable";
+"Codex account login already running" = "La connexion au compte Codex est déjà en cours";
+"Codex binary" = "Binaire Codex";
+"Codex login failed" = "Échec de la connexion au Codex";
+"Codex login timed out" = "La connexion au Codex a expiré";
+"CodexBar Lifecycle Keepalive" = "Cycle de vie de CodexBar Keepalive";
+"CodexBar can't show its menu bar icon" = "CodexBar ne peut pas afficher l'icône de sa barre de menus";
+"CodexBar could not read managed account storage. " = "CodexBar n'a pas pu lire le stockage du compte géré.";
+"Configure…" = "Configurer…";
+"Connected" = "Connecté";
+"Controls how much detail is logged." = "Contrôle la quantité de détails enregistrés.";
+"Cookie header" = "En-tête du cookie";
+"Cookie source" = "Source des cookies";
+"Cookie: ..." = "Cookie : …";
+"Cookie: \\u{2026}\\\n\\\nor paste a cURL capture from the Abacus AI dashboard" = "Cookie : \\u{2026}\\\n\\\nou collez une capture cURL à partir du tableau de bord Abacus AI";
+"Cookie: \\u{2026}\\\n\\\nor paste the __Secure-next-auth.session-token value" = "Cookie : \\u{2026}\\\n\\\nou collez la valeur __Secure-next-auth.session-token";
+"Cookie: \\u{2026}\\\n\\\nor paste the kimi-auth token value" = "Cookie : \\u{2026}\\\n\\\nou collez la valeur du jeton kimi-auth";
+"Cookie: …" = "Cookie : …";
+"CopilotDeviceFlow" = "CopilotDeviceFlow";
+"Cost" = "Coût";
+"Could not add Codex account" = "Impossible d'ajouter un compte Codex";
+"Could not open Terminal for Gemini" = "Impossible d'ouvrir le terminal pour Gemini";
+"Could not start claude /login" = "Impossible de démarrer Claude /connexion";
+"Could not start codex login" = "Impossible de démarrer la connexion à Codex";
+"Could not switch system account" = "Impossible de changer de compte système";
+"Credits" = "Crédits";
+"Individual credits" = "Crédits individuels";
+"Workspace" = "Espace de travail";
+"Credits history" = "Historique des crédits";
+"Cursor login failed" = "La connexion au curseur a échoué";
+"Custom" = "Personnalisé";
+"Custom Path" = "Chemin personnalisé";
+"Daily Routines" = "Routines quotidiennes";
+"Debug" = "Débogage";
+"Default" = "Par défaut";
+"Disable Keychain access" = "Désactiver l'accès au Trousseau";
+"Disabled" = "Désactivé";
+"Dismiss" = "Ignorer";
+"Disconnected" = "Déconnecté";
+"Display" = "Affichage";
+"Display mode" = "Mode d'affichage";
+"Display reset times as absolute clock values instead of countdowns." = "Affichez les temps de réinitialisation sous forme de valeurs d'horloge absolues au lieu de comptes à rebours.";
+"Done" = "Terminé";
+"Effective PATH" = "CHEMIN efficace";
+"Email" = "E-mail";
+"Enable Merge Icons to configure Overview tab providers." = "Activez Fusionner les icônes pour configurer les fournisseurs d'onglets Présentation.";
+"Enable file logging" = "Activer la journalisation des fichiers";
+"Enabled" = "Activé";
+"Error" = "Erreur";
+"Error simulation" = "Simulation d'erreur";
+"Expose troubleshooting tools in the Debug tab." = "Exposez les outils de dépannage dans l’onglet Débogage.";
+"Failed" = "Échec";
+"False" = "False";
+"Fetch strategy attempts" = "Récupérer les tentatives de stratégie";
+"Fetching" = "Récupération";
+"Field" = "Champ";
+"Field subtitle" = "Sous-titre du champ";
+"Finish the current managed account change before switching the system account." = "Terminez la modification du compte géré actuel avant de changer de compte système.";
+"Force animation on next refresh" = "Forcer l'animation au prochain rafraîchissement";
+"Gateway region" = "Région passerelle";
+"Gemini CLI not found" = "Gemini CLI introuvable";
+"Gemini/Antigravity, surfacing incidents in the icon and menu." = "Gemini/Antigravity, signale les incidents dans l'icône et le menu.";
+"General" = "Général";
+"GitHub" = "GitHub";
+"GitHub Copilot Login" = "Connexion à GitHub Copilot";
+"GitHub Login" = "Connexion à GitHub";
+"Hide details" = "Masquer les détails";
+"Hide personal information" = "Masquer les informations personnelles";
+"Historical tracking" = "Suivi historique";
+"How often CodexBar polls providers in the background." = "À quelle fréquence CodexBar interroge les fournisseurs en arrière-plan.";
+"Inactive" = "Inactif";
+"Install CLI" = "Installer la CLI";
+"Install the Claude CLI (npm i -g @anthropic-ai/claude-code) and try again." = "Installez la CLI Claude (npm i -g @anthropic-ai/claude-code) et réessayez.";
+"Install the Codex CLI (npm i -g @openai/codex) and try again." = "Installez la CLI Codex (npm i -g @openai/codex) et réessayez.";
+"Install the Gemini CLI (npm i -g @google/gemini-cli) and try again." = "Installez la CLI Gemini (npm i -g @google/gemini-cli) et réessayez.";
+"JetBrains AI is ready" = "L'IA JetBrains est prête";
+"JetBrains IDE" = "EDI JetBrains";
+"Keep CLI sessions alive" = "Maintenir les sessions CLI en vie";
+"Keyboard shortcut" = "Raccourci clavier";
+"Keychain access" = "Accès au Trousseau";
+"Keychain prompt policy" = "Politique d'invite du Trousseau";
+"Last \\(name) fetch failed:" = "La dernière récupération de \\(name) a échoué :";
+"Last \\(self.store.metadata(for: self.provider).displayName) fetch failed:" = "La dernière récupération de \\(self.store.metadata(for: self.provider).displayName) a échoué :";
+"Last attempt" = "Dernière tentative";
+"Link" = "Lien";
+"Loading animations" = "Chargement des animations";
+"Loading…" = "Chargement…";
+"Local" = "Local";
+"Logging" = "Journalisation";
+"Login failed" = "La connexion a échoué";
+"Login shell PATH (startup capture)" = "CHEMIN du shell de connexion (capture de démarrage)";
+"Login timed out" = "La connexion a expiré";
+"MCP details" = "Détails du MCP";
+"Managed Codex accounts unavailable" = "Comptes Codex gérés indisponibles";
+"Managed account storage is unreadable. Live account access is still available, " = "Le stockage du compte géré est illisible. L'accès au compte en direct est toujours disponible,";
+"Manual" = "Manuel";
+"May your tokens never run out—keep agent limits in view." = "Que vos jetons ne soient jamais épuisés : gardez un œil sur les limites des agents.";
+"Menu bar" = "Barre de menus";
+"Menu bar auto-shows the provider closest to its rate limit." = "La barre de menu affiche automatiquement le fournisseur le plus proche de sa limite de débit.";
+"Menu bar metric" = "Métrique de la barre de menus";
+"Menu bar shows percent" = "La barre de menu affiche le pourcentage";
+"Menu content" = "Contenu des menus";
+"Merge Icons" = "Fusionner les icônes";
+"Never prompt" = "Ne jamais demander";
+"No" = "Non";
+"No Codex accounts detected yet." = "Aucun compte Codex détecté pour l'instant.";
+"No JetBrains IDE detected" = "Aucun IDE JetBrains détecté";
+"No cost history data." = "Aucune donnée historique des coûts.";
+"No data available" = "Aucune donnée disponible";
+"No data yet" = "Aucune donnée pour l'instant";
+"No enabled providers available for Overview." = "Aucun fournisseur activé disponible pour la présentation.";
+"No providers selected" = "Aucun fournisseur sélectionné";
+"No token accounts yet." = "Aucun compte symbolique pour l'instant.";
+"No usage breakdown data." = "Aucune donnée de répartition d'utilisation.";
+"None" = "Aucun";
+"Notifications" = "Notifications";
+"Notifies when the 5-hour session quota hits 0% and when it becomes " = "Avertit lorsque le quota de session de 5 heures atteint 0 % et lorsqu'il devient";
+"OK" = "OK";
+"Obscure email addresses in the menu bar and menu UI." = "Adresses e-mail obscures dans la barre de menus et l'interface utilisateur du menu.";
+"Off" = "Désactivé";
+"Offline" = "Hors ligne";
+"On" = "Activé";
+"Online" = "En ligne";
+"Only on user action" = "Uniquement sur l'action de l'utilisateur";
+"Open" = "Ouvrir";
+"Open API Keys" = "Clés API ouvertes";
+"Open Amp Settings" = "Ouvrir les paramètres de l'ampli";
+"Open Antigravity to sign in, then refresh CodexBar." = "Ouvrez Antigravity pour vous connecter, puis actualisez CodexBar.";
+"Open Browser" = "Ouvrir le navigateur";
+"Open Coding Plan" = "Plan de codage ouvert";
+"Open Console" = "Ouvrir la console";
+"Open Dashboard" = "Ouvrir le tableau de bord";
+"Open Mistral Admin" = "Ouvrir l'administrateur Mistral";
+"Open Menu Bar Settings" = "Ouvrir les paramètres de la barre de menu";
+"Open Ollama Settings" = "Ouvrir les paramètres Ollama";
+"Open Terminal" = "Terminal ouvert";
+"Open Usage Page" = "Ouvrir la page d'utilisation";
+"Open Warp API Key Guide" = "Guide des clés de l'API Open Warp";
+"Open menu" = "Ouvrir le menu";
+"Open token file" = "Ouvrir le fichier de jeton";
+"OpenAI cookies" = "Cookies OpenAI";
+"OpenAI web extras" = "Extras Web OpenAI";
+"Option A" = "Option A";
+"Option B" = "Option B";
+"Optional override if workspace lookup fails." = "Remplacement facultatif si la recherche d’espace de travail échoue.";
+"Options" = "Options";
+"Override auto-detection with a custom IDE base path" = "Remplacer la détection automatique par un chemin de base IDE personnalisé";
+"Overview" = "Aperçu";
+"Overview rows always follow provider order." = "Les lignes de présentation suivent toujours l’ordre des fournisseurs.";
+"Overview tab providers" = "Fournisseurs d'onglets de présentation";
+"Paste API key…" = "Coller la clé API…";
+"Paste API token…" = "Coller le jeton API…";
+"Paste key…" = "Coller la clé…";
+"Paste sessionKey or OAuth token…" = "Collez sessionKey ou le jeton OAuth…";
+"Paste the Cookie header from a request to admin.mistral.ai. " = "Collez l'en-tête Cookie d'une requête vers admin.mistral.ai.";
+"Paste token…" = "Coller le jeton…";
+"Personal" = "Personnel";
+"Picker" = "Sélecteur";
+"Picker subtitle" = "Sous-titre du sélecteur";
+"Placeholder" = "Espace réservé";
+"Plan" = "Forfait";
+"Play full-screen confetti when weekly usage resets." = "Jouez des confettis en plein écran lorsque l'utilisation hebdomadaire est réinitialisée.";
+"Polls OpenAI/Claude status pages and Google Workspace for " = "Sonde les pages d'état OpenAI/Claude et Google Workspace pour";
+"Prevents any Keychain access while enabled." = "Empêche tout accès au Trousseau lorsqu'il est activé.";
+"Primary (API key limit)" = "Primaire (limite de clé API)";
+"Primary (\\(label))" = "Primaire (\\(label))";
+"Primary (\\(metadata.sessionLabel))" = "Primaire (\\(metadata.sessionLabel))";
+"Probe logs" = "Journaux de sonde";
+"Progress bars fill as you consume quota (instead of showing remaining)." = "Les barres de progression se remplissent à mesure que vous consommez le quota (au lieu d'afficher le reste).";
+"Provider" = "Fournisseur";
+"Providers" = "Fournisseurs";
+"Quit CodexBar" = "Quitter CodexBar";
+"Random (default)" = "Aléatoire (par défaut)";
+"Reads local usage logs. Shows today + last 30 days cost in the menu." = "Lit les journaux d'utilisation locaux. Affiche aujourd'hui + la fenêtre d'historique sélectionnée dans le menu.";
+"Refresh" = "Actualiser";
+"Refresh cadence" = "Cadence de rafraîchissement";
+"Remote" = "Distant";
+"Remove" = "Supprimer";
+"Remove Codex account?" = "Supprimer le compte Codex ?";
+"Remove \\(account.email) from CodexBar? Its managed Codex home will be deleted." = "Supprimer \\(account.email) de CodexBar ? Sa maison Codex gérée sera supprimée.";
+"Remove \\(email) from CodexBar? Its managed Codex home will be deleted." = "Supprimer \\(email) de CodexBar ? Sa maison Codex gérée sera supprimée.";
+"Remove selected account" = "Supprimer le compte sélectionné";
+"Replace critter bars with provider branding icons and a percentage." = "Remplacez les barres de créatures par des icônes de marque du fournisseur et un pourcentage.";
+"Replay selected animation" = "Rejouer l'animation sélectionnée";
+"Requires authentication via GitHub Device Flow." = "Nécessite une authentification via GitHub Device Flow.";
+"Resets: \\(reset)" = "Réinitialisation : \\(reset)";
+"Rolling five-hour limit" = "Limite mobile de cinq heures";
+"Search hourly" = "Recherche horaire";
+"Secondary (\\(label))" = "Secondaire (\\(label))";
+"Secondary (\\(metadata.weeklyLabel))" = "Secondaire (\\(metadata.weeklyLabel))";
+"Select a provider" = "Sélectionnez un fournisseur";
+"Select the IDE to monitor" = "Sélectionnez l'IDE à surveiller";
+"Session quota notifications" = "Notifications de quota de session";
+"Session tokens" = "Jetons de session";
+"Settings" = "Réglages";
+"Show Codex Credits and Claude Extra usage sections in the menu." = "Afficher les sections d'utilisation des crédits Codex et de Claude Extra dans le menu.";
+"Show Debug Settings" = "Afficher les paramètres de débogage";
+"Show all token accounts" = "Afficher tous les comptes de jetons";
+"Show cost summary" = "Afficher le récapitulatif des coûts";
+"Show credits + extra usage" = "Afficher les crédits + utilisation supplémentaire";
+"Show details" = "Afficher les détails";
+"Show most-used provider" = "Afficher le fournisseur le plus utilisé";
+"Show provider icons in the switcher (otherwise show a weekly progress line)." = "Afficher les icônes des fournisseurs dans le sélecteur (sinon, afficher une ligne de progression hebdomadaire).";
+"Show reset time as clock" = "Afficher l'heure de réinitialisation sous forme d'horloge";
+"Show usage as used" = "Afficher l'utilisation telle qu'utilisée";
+"Sign in via button below" = "Connectez-vous via le bouton ci-dessous";
+"Skip teardown between probes (debug-only)." = "Ignorer le démontage entre les sondes (débogage uniquement).";
+"Stack token accounts in the menu (otherwise show an account switcher bar)." = "Empilez les comptes de jetons dans le menu (sinon, affichez une barre de changement de compte).";
+"Start at Login" = "Commencez par la connexion";
+"Status" = "Statut";
+"Store Claude sessionKey cookies or OAuth access tokens." = "Stockez les cookies sessionKey de Claude ou les jetons d'accès OAuth.";
+"Store multiple Abacus AI Cookie headers." = "Stockez plusieurs en-têtes Abacus AI Cookie.";
+"Store multiple Augment Cookie headers." = "Stockez plusieurs en-têtes de cookies d’augmentation.";
+"Store multiple Cursor Cookie headers." = "Stockez plusieurs en-têtes de cookies de curseur.";
+"Store multiple Factory Cookie headers." = "Stockez plusieurs en-têtes Factory Cookie.";
+"Store multiple MiniMax Cookie headers." = "Stockez plusieurs en-têtes MiniMax Cookie.";
+"Store multiple Mistral Cookie headers." = "Stockez plusieurs en-têtes Mistral Cookie.";
+"Store multiple Ollama Cookie headers." = "Stockez plusieurs en-têtes Ollama Cookie.";
+"Store multiple OpenCode Cookie headers." = "Stockez plusieurs en-têtes de cookies OpenCode.";
+"Store multiple OpenCode Go Cookie headers." = "Stockez plusieurs en-têtes OpenCode Go Cookie.";
+"Stored in the CodexBar config file." = "Stocké dans le fichier de configuration CodexBar.";
+"Stored in ~/.codexbar/config.json. " = "Stocké dans ~/.codexbar/config.json.";
+"Stored in ~/.codexbar/config.json. Generate one at kimi-k2.ai." = "Stocké dans ~/.codexbar/config.json. Générez-en un sur kimi-k2.ai.";
+"Stored in ~/.codexbar/config.json. Paste the key from the Synthetic dashboard." = "Stocké dans ~/.codexbar/config.json. Collez la clé du tableau de bord synthétique.";
+"Stored in ~/.codexbar/config.json. Paste your Coding Plan API key from Model Studio." = "Stocké dans ~/.codexbar/config.json. Collez la clé API de votre plan de codage depuis Model Studio.";
+"Stored in ~/.codexbar/config.json. Paste your MiniMax API key." = "Stocké dans ~/.codexbar/config.json. Collez votre clé API MiniMax.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or " = "Stocké dans ~/.codexbar/config.json. Vous pouvez également fournir KILO_API_KEY ou";
+"Stores local Codex usage history (8 weeks) to personalize Pace predictions." = "Stocke l’historique d’utilisation local du Codex (8 semaines) pour personnaliser les prédictions Pace.";
+"Subscription Utilization" = "Utilisation de l'abonnement";
+"Surprise me" = "Surprenez-moi";
+"Switcher shows icons" = "Le commutateur affiche des icônes";
+"Symlink CodexBarCLI to /usr/local/bin and /opt/homebrew/bin as codexbar." = "Lien symbolique CodexBarCLI vers /usr/local/bin et /opt/homebrew/bin en tant que codexbar.";
+"System" = "Système";
+"Temporarily shows the loading animation after the next refresh." = "Affiche temporairement l'animation de chargement après la prochaine actualisation.";
+"Tertiary (\\(label))" = "Tertiaire (\\(label))";
+"Tertiary (\\(tertiaryTitle))" = "Tertiaire (\\(tertiaryTitle))";
+"The default Codex account on this Mac." = "Le compte Codex par défaut sur ce Mac.";
+"Toggle" = "Basculer";
+"Toggle subtitle" = "Basculer le sous-titre";
+"Token" = "Jeton";
+"Trigger the menu bar menu from anywhere." = "Déclenchez le menu de la barre de menus depuis n'importe où.";
+"True" = "Vrai";
+"Twitter" = "Twitter";
+"Unsupported" = "Non pris en charge";
+"Update Channel" = "Mettre à jour la chaîne";
+"Updated" = "Mis à jour";
+"Updates unavailable in this build." = "Mises à jour non disponibles dans cette version.";
+"Usage" = "Utilisation";
+"Usage breakdown" = "Répartition de l'utilisation";
+"Usage history (30 days)" = "Historique d'utilisation";
+"Usage source" = "Source d'utilisation";
+"Use BigModel for the China mainland endpoints (open.bigmodel.cn)." = "Utilisez BigModel pour les points de terminaison de la Chine continentale (open.bigmodel.cn).";
+"Use a single menu bar icon with a provider switcher." = "Utilisez une seule icône de barre de menu avec un sélecteur de fournisseur.";
+"Use international or China mainland console gateways for quota fetches." = "Utilisez les passerelles de console internationales ou chinoises pour les récupérations de quotas.";
+"Version" = "Version";
+"Version \\(self.versionString)" = "Version \\(self.versionString)";
+"Version \\(version)" = "Version \\(version)";
+"Version \\(versionString)" = "Version \\(versionString)";
+"Vertex AI Login" = "Connexion à Vertex AI";
+"Wait for the current managed Codex login to finish before adding another account." = "Attendez la fin de la connexion Codex gérée actuelle avant d'ajouter un autre compte.";
+"Waiting for Authentication..." = "En attente d'authentification...";
+"Website" = "Site web";
+"Weekly limit confetti" = "Confettis de limite hebdomadaire";
+"Weekly token limit" = "Limite hebdomadaire de jetons";
+"Weekly usage" = "Utilisation hebdomadaire";
+"Weekly usage unavailable for this account." = "Utilisation hebdomadaire indisponible pour ce compte.";
+"Window: \\(window)" = "Fenêtre : \\(window)";
+"Write logs to \\(self.fileLogPath) for debugging." = "Écrivez les journaux dans \\(self.fileLogPath) pour le débogage.";
+"Yes" = "Oui";
+"\\(detail.modelCode): \\(usage)" = "\\(detail.modelCode) : \\(usage)";
+"\\(name): \\(truncated)" = "\\(name) : \\(truncated)";
+"\\(name): \\(updated) · 30d \\(cost)" = "\\(name) : \\(updated) · 30j \\(cost)";
+"\\(name): fetching…\\(elapsed)" = "\\(name) : récupération de…\\(elapsed)";
+"\\(name): last attempt \\(when)" = "\\(name) : dernière tentative \\(when)";
+"\\(name): no data yet" = "\\(name) : aucune donnée pour l'instant";
+"\\(name): unsupported" = "\\(name) : non pris en charge";
+"all browsers" = "tous les navigateurs";
+"available again." = "à nouveau disponible.";
+"built_format" = "Construit %@";
+"copilot_complete_in_browser" = "Connectez-vous complètement dans votre navigateur.";
+"copilot_device_code" = "Code de l'appareil copié dans le presse-papier : %1$@\n\nVérifiez à : %2$@";
+"copilot_device_code_copied" = "Code de l'appareil copié.";
+"copilot_verify_at" = "Vérifiez à %@";
+"copilot_waiting_text" = "Terminez la connexion dans votre navigateur.\nCette fenêtre se ferme automatiquement une fois la connexion terminée.";
+"copilot_window_closes_auto" = "Cette fenêtre se ferme automatiquement une fois la connexion terminée.";
+"cost_status_error" = "%1$@ : %2$@";
+"cost_status_fetching" = "%1$@ : récupération de … %2$@";
+"cost_status_last_attempt" = "%1$@ : dernière tentative %2$@";
+"cost_status_no_data" = "%@ : aucune donnée pour l'instant";
+"cost_status_snapshot" = "%1$@ : %2$@ · %3$@ %4$@";
+"cost_status_unsupported" = "%@ : non pris en charge";
+"credits_remaining" = "Crédits : %@";
+"cursor_on_demand" = "À la demande : %@";
+"cursor_on_demand_with_limit" = "À la demande : %1$@ / %2$@";
+"extra_usage_format" = "Utilisation supplémentaire : %1$@ / %2$@";
+"jetbrains_detected_generate" = "Détecté : %@. Utilisez l'assistant IA une fois pour générer des données de quota, puis actualisez CodexBar.";
+"jetbrains_detected_select" = "Détecté : %@. Sélectionnez votre IDE préféré dans Paramètres, puis actualisez CodexBar.";
+"last_fetch_failed_with_provider" = "La dernière récupération de %@ a échoué :";
+"last_spend" = "Dernière dépense : %@";
+"mcp_model_usage" = "%1$@ : %2$@";
+"mcp_resets" = "Réinitialisation : %@";
+"mcp_window" = "Fenêtre : %@";
+"metric_average" = "Moyenne (%1$@ + %2$@)";
+"metric_primary" = "Primaire (%@)";
+"metric_secondary" = "Secondaire (%@)";
+"metric_tertiary" = "Tertiaire (%@)";
+"multiple_workspaces_found" = "CodexBar a trouvé plusieurs espaces de travail pour %@. Veuillez choisir l'espace de travail à ajouter.";
+"ory_session_…=…; csrftoken=…" = "ory_session_…=…; csrftoken=…";
+"overview_choose_providers" = "Choisissez jusqu'à %@ fournisseurs";
+"remove_account_message" = "Supprimer %@ de CodexBar ? Sa maison Codex gérée sera supprimée.";
+"version_format" = "Version %@";
+"vertex_ai_login_instructions" = "Pour suivre l'utilisation de Vertex AI, authentifiez-vous auprès de Google Cloud.\n\n1. Ouvrez le terminal\n2. Exécutez : gcloud auth application-default login\n3. Suivez les invites du navigateur pour vous connecter\n4. Définissez votre projet : gcloud config set project PROJECT_ID\n\nOuvrir le terminal maintenant ?";
+"workspaceID is set but only opencode, opencodego, and deepgram support workspaceID." = "workspaceID est défini mais seuls opencode, opencodego et deepgram prennent en charge workspaceID.";
+"© 2026 Peter Steinberger. MIT License." = "© 2026 Peter Steinberger. Licence MIT.";
+
+/* General Pane */
+"section_system" = "Système";
+"section_usage" = "Utilisation";
+"section_automation" = "Automatisation";
+"language_title" = "Langue";
+"language_subtitle" = "Change la langue d'affichage. Nécessite de redémarrer l'app pour une prise en compte complète.";
+"language_system" = "Système";
+"language_english" = "Anglais";
+"language_spanish" = "Espagnol";
+"language_catalan" = "Catalan";
+"language_chinese_simplified" = "Chinois simplifié";
+"language_chinese_traditional" = "Chinois traditionnel";
+"language_portuguese_brazilian" = "Portugais (Brésil)";
+"language_german" = "Allemand";
+"language_swedish" = "Suédois";
+"language_french" = "Français";
+"language_dutch" = "Néerlandais";
+"language_ukrainian" = "Ukrainien";
+"language_japanese" = "Japonais";
+"language_korean" = "Coréen";
+"language_italian" = "Italiano";
+"language_vietnamese" = "Vietnamien";
+"language_turkish" = "Türkçe";
+"language_indonesian" = "Indonésien";
+"language_polish" = "Polonais";
+"start_at_login_title" = "Lancer à l'ouverture de session";
+"start_at_login_subtitle" = "Ouvre automatiquement CodexBar au démarrage de votre Mac.";
+"show_cost_summary" = "Afficher le récapitulatif des coûts";
+"show_cost_summary_subtitle" = "Lit les journaux d'utilisation locaux. Affiche le coût d'aujourd'hui et de la période sélectionnée dans le menu.";
+"cost_history_days_title" = "Fenêtre d'historique : %d jours";
+"cost_auto_refresh_info" = "Actualisation automatique : toutes les heures · Délai d'expiration : 10 min";
+"refresh_cadence_title" = "Fréquence d'actualisation";
+"refresh_cadence_subtitle" = "Définit la fréquence à laquelle CodexBar interroge les fournisseurs en arrière-plan.";
+"manual_refresh_hint" = "L'actualisation automatique est désactivée ; utilisez la commande Actualiser du menu.";
+"check_provider_status_title" = "Vérifier l'état des fournisseurs";
+"check_provider_status_subtitle" = "Interroge les pages d'état OpenAI/Claude et Google Workspace pour Gemini/Antigravity, et affiche les incidents dans l'icône et le menu.";
+"session_quota_notifications_title" = "Notifications de quota de session";
+"session_quota_notifications_subtitle" = "Vous avertit lorsque le quota de session sur 5 heures atteint 0 % puis lorsqu'il redevient disponible.";
+"quota_warning_notifications_title" = "Alertes de quota";
+"quota_warning_notifications_subtitle" = "Vous avertit lorsque le quota restant (session ou hebdomadaire) franchit les seuils configurés.";
+"quota_warnings_title" = "Alertes de quota";
+"quota_warning_session" = "session";
+"quota_warning_session_capitalized" = "Session";
+"quota_warning_weekly" = "hebdomadaire";
+"quota_warning_weekly_capitalized" = "Hebdomadaire";
+"quota_warning_notification_title" = "%1$@ %2$@ : quota faible";
+"quota_warning_notification_body" = "Il reste %1$@. Seuil d'alerte %2$d %% (%3$@) atteint.";
+"quota_warning_notification_body_with_account" = "Compte %1$@. Il reste %2$@. Seuil d'alerte %3$d %% (%4$@) atteint.";
+"session_depleted_notification_title" = "Session %@ épuisée";
+"session_depleted_notification_body" = "0 % restant. Vous serez notifié quand elle redeviendra disponible.";
+"session_restored_notification_title" = "Session %@ rétablie";
+"session_restored_notification_body" = "Le quota de session est à nouveau disponible.";
+"quota_warning_warn_at" = "Avertir à";
+"quota_warning_global_threshold_subtitle" = "Pourcentages restants pour les fenêtres de session et hebdomadaires, sauf si un fournisseur les remplace.";
+"quota_warning_sound" = "Lire un son de notification";
+"quota_warning_provider_inherits" = "Utilise les réglages globaux d'alerte de quota, sauf personnalisation de cette fenêtre.";
+"quota_warning_customize_thresholds" = "Personnaliser les seuils %@";
+"quota_warning_enable_warnings" = "Activer les alertes %@";
+"quota_warning_window_warn_at" = "Alerte %@";
+"quota_warning_off" = "Désactivé";
+"quota_warning_inherited" = "Hérité : %@";
+"quota_warning_depleted_only" = "uniquement à l'épuisement";
+"quota_warning_upper" = "Seuil haut";
+"quota_warning_lower" = "Seuil bas";
+"apply" = "Appliquer";
+"quit_app" = "Quitter CodexBar";
+
+/* Tab titles */
+"tab_general" = "Général";
+"tab_providers" = "Fournisseurs";
+"tab_display" = "Affichage";
+"tab_advanced" = "Avancé";
+"tab_about" = "À propos";
+"tab_debug" = "Débogage";
+
+/* Providers Pane */
+"select_a_provider" = "Sélectionner un fournisseur";
+"cancel" = "Annuler";
+"last_fetch_failed" = "dernière récupération échouée";
+"usage_not_fetched_yet" = "utilisation pas encore récupérée";
+"managed_account_storage_unreadable" = "Le stockage du compte géré est illisible. L'accès au compte réel est toujours disponible, mais les actions gérées d'ajout, de réauthentification et de suppression sont désactivées jusqu'à ce que le magasin soit récupérable.";
+"remove_codex_account_title" = "Supprimer le compte Codex ?";
+"remove" = "Supprimer";
+"managed_login_already_running" = "Une connexion Codex gérée est déjà en cours d'exécution. Attendez la fin avant d'ajouter ou de ré-authentifier un autre compte.";
+"managed_login_failed" = "La connexion au Codex géré n'a pas abouti. Vérifiez que `codex --version` fonctionne dans Terminal. Si macOS a bloqué ou déplacé « codex » vers la corbeille, supprimez les installations en double obsolètes, exécutez « npm install -g --include=optional @openai/codex@latest », puis réessayez.";
+"codex_login_output" = "Résultat de connexion à Codex :";
+"managed_login_missing_email" = "Connexion au Codex terminée, mais aucune adresse e-mail du compte n'était disponible. Réessayez après avoir confirmé que le compte est entièrement connecté.";
+"login_success_notification_title" = "%@ connexion réussie";
+"login_success_notification_body" = "Vous pouvez revenir à l’app ; authentification terminée.";
+"workspace_selection_cancelled" = "CodexBar a trouvé plusieurs espaces de travail, mais aucun espace de travail n'a été sélectionné.";
+"unsafe_managed_home" = "CodexBar a refusé de modifier un chemin d'accès à la maison géré inattendu : %@";
+"menu_bar_metric_title" = "Métrique de la barre de menus";
+"menu_bar_metric_subtitle" = "Choisissez quelle fenêtre gère le pourcentage de la barre de menus.";
+"menu_bar_metric_subtitle_deepseek" = "Affiche le solde DeepSeek dans la barre de menu.";
+"menu_bar_metric_subtitle_moonshot" = "Affiche le solde de l'API Moonshot / Kimi dans la barre de menu.";
+"menu_bar_metric_subtitle_mistral" = "Affiche les dépenses de l'API Mistral du mois en cours dans la barre de menu.";
+"menu_bar_metric_subtitle_kimik2" = "Affiche les crédits de la clé API Kimi K2 dans la barre de menu.";
+"automatic" = "Automatique";
+"primary_api_key_limit" = "Primaire (limite de clé API)";
+
+/* Display Pane */
+"section_menu_bar" = "Barre de menus";
+"merge_icons_title" = "Fusionner les icônes";
+"merge_icons_subtitle" = "Utilisez une seule icône de barre de menu avec un sélecteur de fournisseur.";
+"switcher_shows_icons_title" = "Le commutateur affiche des icônes";
+"switcher_shows_icons_subtitle" = "Afficher les icônes des fournisseurs dans le sélecteur (sinon, afficher une ligne de progression hebdomadaire).";
+"show_most_used_provider_title" = "Afficher le fournisseur le plus utilisé";
+"show_most_used_provider_subtitle" = "La barre de menu affiche automatiquement le fournisseur le plus proche de sa limite de débit.";
+"menu_bar_shows_percent_title" = "La barre de menu affiche le pourcentage";
+"menu_bar_shows_percent_subtitle" = "Remplacez les barres de créatures par des icônes de marque du fournisseur et un pourcentage.";
+"hide_critters_title" = "Masquer les créatures";
+"hide_critters_subtitle" = "Afficher des barres de mesure simples sans le visage ni les décorations.";
+"display_mode_title" = "Mode d'affichage";
+"display_mode_subtitle" = "Choisissez ce que vous voulez afficher dans la barre de menu (Pace affiche l'utilisation par rapport à celle attendue).";
+"section_menu_content" = "Contenu des menus";
+"show_usage_as_used_title" = "Afficher l'utilisation telle qu'utilisée";
+"show_usage_as_used_subtitle" = "Les barres de progression se remplissent à mesure que vous consommez le quota (au lieu d'afficher le reste).";
+"show_quota_warning_markers_title" = "Afficher les marqueurs d'avertissement de quota";
+"show_quota_warning_markers_subtitle" = "Dessinez des coches de seuil sur les barres d’utilisation lorsque des avertissements de quota sont configurés.";
+"weekly_progress_work_days_title" = "Jours de travail hebdomadaires";
+"weekly_progress_work_days_subtitle" = "Définit les jours ouvrés pour les repères des barres d’utilisation hebdomadaire et le calcul du rythme.";
+"show_reset_time_as_clock_title" = "Afficher l'heure de réinitialisation sous forme d'horloge";
+"show_reset_time_as_clock_subtitle" = "Affichez les temps de réinitialisation sous forme de valeurs d'horloge absolues au lieu de comptes à rebours.";
+"show_provider_changelog_links_title" = "Afficher les liens du journal des modifications du fournisseur";
+"show_provider_changelog_links_subtitle" = "Ajoute au menu des liens de notes de version pour les fournisseurs pris en charge par CLI.";
+"show_credits_extra_usage_title" = "Afficher les crédits + utilisation supplémentaire";
+"show_credits_extra_usage_subtitle" = "Afficher les sections d'utilisation des crédits Codex et de Claude Extra dans le menu.";
+"show_all_token_accounts_title" = "Afficher tous les comptes de jetons";
+"show_all_token_accounts_subtitle" = "Empilez les comptes de jetons dans le menu (sinon, affichez une barre de changement de compte).";
+"multi_account_layout_title" = "Disposition multi-comptes";
+"multi_account_layout_subtitle" = "Choisissez un changement de compte segmenté ou des cartes de compte empilées.";
+"multi_account_layout_segmented" = "Segmenté";
+"multi_account_layout_stacked" = "Empilé";
+"overview_tab_providers_title" = "Fournisseurs d'onglets de présentation";
+"configure" = "Configurer…";
+"overview_enable_merge_icons_hint" = "Activez Fusionner les icônes pour configurer les fournisseurs d'onglets Présentation.";
+"overview_no_providers_hint" = "Aucun fournisseur activé disponible pour la présentation.";
+"overview_rows_follow_order" = "Les lignes de présentation suivent toujours l’ordre des fournisseurs.";
+"overview_no_providers_selected" = "Aucun fournisseur sélectionné";
+
+/* Advanced Pane */
+"section_keyboard_shortcut" = "Raccourci clavier";
+"open_menu_shortcut_title" = "Ouvrir le menu";
+"open_menu_shortcut_subtitle" = "Déclenchez le menu de la barre de menus depuis n'importe où.";
+"install_cli" = "Installer la CLI";
+"install_cli_subtitle" = "Lien symbolique CodexBarCLI vers /usr/local/bin et /opt/homebrew/bin en tant que codexbar.";
+"cli_not_found" = "CodexBarCLI introuvable dans l'ensemble d'applications.";
+"no_writable_bin_dirs" = "Aucun répertoire bin inscriptible trouvé.";
+"show_debug_settings_title" = "Afficher les paramètres de débogage";
+"show_debug_settings_subtitle" = "Exposez les outils de dépannage dans l’onglet Débogage.";
+"surprise_me_title" = "Surprenez-moi";
+"surprise_me_subtitle" = "Vérifiez si vous aimez que vos agents s'amusent là-haut.";
+"weekly_limit_confetti_title" = "Confettis de limite hebdomadaire";
+"weekly_limit_confetti_subtitle" = "Jouez des confettis en plein écran lorsque l'utilisation hebdomadaire est réinitialisée.";
+"hide_personal_info_title" = "Masquer les informations personnelles";
+"hide_personal_info_subtitle" = "Adresses e-mail obscures dans la barre de menus et l'interface utilisateur du menu.";
+"show_provider_storage_usage_title" = "Afficher l'utilisation du stockage du fournisseur";
+"show_provider_storage_usage_subtitle" = "Afficher l'utilisation du disque local dans les menus. Analyse les chemins connus appartenant au fournisseur en arrière-plan.";
+"section_keychain_access" = "Accès au Trousseau";
+"keychain_access_caption" = "Désactivez toutes les lectures et écritures du Trousseau. Utilisez-le si macOS continue de demander « Chrome/Brave/Edge Safe Storage » même après avoir cliqué sur Toujours autoriser. L'importation des cookies du navigateur n'est pas disponible lorsqu'elle est activée ; collez manuellement les en-têtes de cookies dans les fournisseurs. Claude/Codex OAuth via la CLI fonctionne toujours.";
+"disable_keychain_access_title" = "Désactiver l'accès au Trousseau";
+"disable_keychain_access_subtitle" = "Empêche tout accès au Trousseau lorsqu'il est activé.";
+
+/* About Pane */
+"about_tagline" = "Que vos jetons ne soient jamais épuisés : gardez un œil sur les limites des agents.";
+"link_github" = "GitHub";
+"link_website" = "Site web";
+"link_twitter" = "X/Twitter";
+"link_email" = "E-mail";
+"check_updates_auto" = "Rechercher automatiquement les mises à jour";
+"update_channel" = "Mettre à jour la chaîne";
+"check_for_updates" = "Rechercher les mises à jour…";
+"updates_unavailable" = "Mises à jour non disponibles dans cette version.";
+"copyright" = "© 2026 Peter Steinberger. Licence MIT.";
+
+/* Debug Pane */
+"section_logging" = "Journalisation";
+"enable_file_logging" = "Activer la journalisation des fichiers";
+"enable_file_logging_subtitle" = "Écrivez les journaux dans %@ pour le débogage.";
+"verbosity_title" = "Niveau de verbosité";
+"verbosity_subtitle" = "Contrôle la quantité de détails enregistrés.";
+"open_log_file" = "Ouvrir le fichier journal";
+"force_animation_next_refresh" = "Forcer l'animation au prochain rafraîchissement";
+"force_animation_next_refresh_subtitle" = "Affiche temporairement l'animation de chargement après la prochaine actualisation.";
+"section_loading_animations" = "Chargement des animations";
+"loading_animations_caption" = "Choisissez un motif et rejouez-le dans la barre de menu. \"Aléatoire\" conserve le comportement existant.";
+"animation_random_default" = "Aléatoire (par défaut)";
+"replay_selected_animation" = "Rejouer l'animation sélectionnée";
+"blink_now" = "Cligne des yeux maintenant";
+"section_probe_logs" = "Journaux de sonde";
+"probe_logs_caption" = "Récupère la dernière sortie de la sonde pour le débogage ; La copie conserve le texte intégral.";
+"fetch_log" = "Récupérer le journal";
+"copy" = "Copier";
+"save_to_file" = "Enregistrer dans un fichier";
+"load_parse_dump" = "Charger le vidage d'analyse";
+"rerun_provider_autodetect" = "Réexécuter la détection automatique du fournisseur";
+"loading" = "Chargement…";
+"no_log_yet_fetch" = "Pas de journal pour l'instant. Récupérer pour charger.";
+"section_fetch_strategy" = "Récupérer les tentatives de stratégie";
+"fetch_strategy_caption" = "Dernières décisions et erreurs du pipeline de récupération pour un fournisseur.";
+"section_openai_cookies" = "Cookies OpenAI";
+"openai_cookies_caption" = "Importation de cookies + journaux de récupération WebKit de la dernière tentative de cookies OpenAI.";
+"no_log_yet" = "Pas de journal pour l'instant. Mettez à jour les cookies OpenAI dans Fournisseurs → Codex pour exécuter une importation.";
+"section_caches" = "Caches";
+"caches_caption" = "Effacez les résultats de l’analyse des coûts mis en cache ou les caches des cookies du navigateur.";
+"clear_cookie_cache" = "Vider le cache des cookies";
+"clear_cost_cache" = "Vider le cache des coûts";
+"section_notifications" = "Notifications";
+"notifications_caption" = "Déclenchez des notifications de test pour la fenêtre de session de 5 heures (épuisée/restaurée).";
+"post_depleted" = "Post épuisé";
+"post_restored" = "Message restauré";
+"section_cli_sessions" = "Sessions CLI";
+"cli_sessions_caption" = "Gardez les sessions Codex/Claude CLI actives après une sonde. La valeur par défaut se ferme une fois les données capturées.";
+"keep_cli_sessions_alive" = "Maintenir les sessions CLI en vie";
+"keep_cli_sessions_alive_subtitle" = "Ignorer le démontage entre les sondes (débogage uniquement).";
+"reset_cli_sessions" = "Réinitialiser les sessions CLI";
+"section_error_simulation" = "Simulation d'erreur";
+"error_simulation_caption" = "Injectez un faux message d'erreur dans la carte de menu pour tester la mise en page.";
+"set_menu_error" = "Erreur de menu de définition";
+"clear_menu_error" = "Effacer l'erreur de menu";
+"set_cost_error" = "Erreur de définition du coût";
+"clear_cost_error" = "Effacer l'erreur de coût";
+"section_cli_paths" = "Chemins CLI";
+"cli_paths_caption" = "Couches binaires et PATH du Codex résolues ; Capture du chemin de connexion au démarrage (délai d'attente court).";
+"codex_binary" = "Binaire Codex";
+"claude_binary" = "Binaire Claude";
+"effective_path" = "CHEMIN efficace";
+"unavailable" = "Indisponible";
+"login_shell_path" = "CHEMIN du shell de connexion (capture de démarrage)";
+"cleared" = "Effacé";
+"no_fetch_attempts" = "Aucune tentative de récupération pour l'instant.";
+"macOS Tahoe can block menu bar apps in System Settings → Menu Bar → Allow in the Menu Bar. CodexBar is running, but macOS may be hiding its icon. Open Menu Bar settings and turn CodexBar on." = "macOS Tahoe peut bloquer les applications de la barre de menus dans Paramètres système → Barre de menus → Autoriser dans la barre de menus. CodexBar est en cours d'exécution, mais macOS cache peut-être son icône. Ouvrez les paramètres de la barre de menu et activez CodexBar.";
+
+/* Metric preferences */
+"metric_pref_automatic" = "Automatique";
+"metric_pref_primary" = "Principal";
+"metric_pref_secondary" = "Secondaire";
+"metric_pref_tertiary" = "Tertiaire";
+"metric_pref_extra_usage" = "Utilisation supplémentaire";
+"metric_pref_average" = "Moyenne";
+"metric_mistral_payg" = "Pay-as-you-go";
+"metric_mistral_monthly_plan" = "Monthly Plan";
+
+/* Display modes */
+"display_mode_percent" = "Pourcentage";
+"display_mode_pace" = "Rythme";
+"display_mode_both" = "Les deux";
+"display_mode_reset_time" = "Heure de réinitialisation";
+"display_mode_percent_desc" = "Afficher le pourcentage restant/utilisé (par exemple 45 %)";
+"display_mode_pace_desc" = "Afficher l'indicateur d'allure (par exemple +5 %)";
+"display_mode_both_desc" = "Afficher à la fois le pourcentage et le rythme (par exemple 45 % · +5 %)";
+"display_mode_reset_time_desc" = "Afficher l'heure de réinitialisation de la métrique sélectionnée (par exemple ↻ 15:56)";
+
+/* Provider status */
+"status_operational" = "Opérationnel";
+"status_partial_outage" = "Dégradation partielle";
+"status_major_outage" = "Panne majeure";
+"status_critical_issue" = "Problème critique";
+"status_maintenance" = "Maintenance";
+"status_unknown" = "Statut inconnu";
+
+/* Refresh frequency */
+"refresh_manual" = "Manuel";
+"refresh_1min" = "1 minute";
+"refresh_2min" = "2 minutes";
+"refresh_5min" = "5 minutes";
+"refresh_15min" = "15 minutes";
+"refresh_30min" = "30 minutes";
+
+/* Additional keys */
+"not_found" = "Pas trouvé";
+
+/* Cost estimation */
+"cost_header_estimated" = "Coût (estimé)";
+"cost_estimate_hint" = "Estimé à partir des journaux locaux · peut différer de votre facture";
+"No JetBrains IDE with AI Assistant detected. Install a JetBrains IDE and enable AI Assistant." = "Aucun IDE JetBrains avec AI Assistant détecté. Installez un IDE JetBrains et activez AI Assistant.";
+"OpenRouter API token not configured. Set OPENROUTER_API_KEY environment variable or configure in Settings." = "Jeton API OpenRouter non configuré. Définissez la variable d'environnement OPENROUTER_API_KEY ou configurez-la dans Paramètres.";
+"z.ai API token not found. Set apiKey in ~/.codexbar/config.json or Z_AI_API_KEY." = "Jeton API z.ai introuvable. Définissez apiKey dans ~/.codexbar/config.json ou Z_AI_API_KEY.";
+"Missing DeepSeek API key." = "Clé API DeepSeek manquante.";
+"%@ is unavailable in the current environment." = "%@ n'est pas disponible dans l'environnement actuel.";
+"All Systems Operational" = "Tous les systèmes opérationnels";
+"Last 30 days" = "30 derniers jours";
+"Last 30 days:" = "30 derniers jours :";
+"This month" = "Ce mois-ci";
+"Store multiple OpenAI API keys." = "Stockez plusieurs clés API OpenAI.";
+"Admin API key" = "Clé API d'administration";
+"Open billing" = "Facturation ouverte";
+"Google accounts" = "Comptes Google";
+"Store multiple Antigravity Google OAuth accounts for quick switching." = "Stockez plusieurs comptes Google OAuth Antigravity pour une commutation rapide.";
+"Add Google Account" = "Ajouter un compte Google";
+"Open Token Plan" = "Plan de jetons ouverts";
+"Text Generation" = "Génération de texte";
+"Text to Speech" = "Synthèse vocale";
+"Music Generation" = "Génération de musique";
+"Image Generation" = "Génération d'images";
+"No local data found" = "Aucune donnée locale trouvée";
+"Credits unavailable; keep Codex running to refresh." = "Crédits indisponibles ; laissez le Codex fonctionner pour l'actualiser.";
+"No available fetch strategy for minimax." = "Aucune stratégie de récupération disponible pour minimax.";
+"No Cursor session found. Please log in to cursor.com in Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX, or Edge Canary. If you use Safari, grant CodexBar Full Disk Access in System Settings ▸ Privacy & Security. You can also sign in to Cursor from the CodexBar menu (Add / switch account)." = "Aucune session de Cursor trouvée. Veuillez vous connecter à cursor.com dans Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX ou Edge Canary. Si vous utilisez Safari, accordez l'accès complet au disque à CodexBar dans Paramètres système ▸ Confidentialité et sécurité. Vous pouvez également vous connecter à Cursor à partir du menu CodexBar (Ajouter/changer de compte).";
+"No OpenCode session cookies found in browsers." = "Aucun cookie de session OpenCode trouvé dans les navigateurs.";
+"No available fetch strategy for %@." = "Aucune stratégie de récupération disponible pour %@.";
+"Today" = "Aujourd’hui";
+"Today tokens" = "Jetons d'aujourd'hui";
+"30d cost" = "coût 30 jours";
+"30d tokens" = "jetons 30d";
+"Latest tokens" = "Derniers jetons";
+"Top model" = "Top modèle";
+"Storage" = "Stockage";
+"Add Account..." = "Ajouter un compte...";
+"Usage Dashboard" = "Tableau de bord d'utilisation";
+"Status Page" = "Page d'état";
+"Settings..." = "Réglages…";
+"About CodexBar" = "À propos de CodexBar";
+"Quit" = "Quitter";
+"Last %d day" = "Dernier %d jour";
+"Last %d days" = "%d derniers jours";
+"%@ tokens" = "Jetons %@";
+"Latest billing day" = "Dernier jour de facturation";
+"Latest billing day (%@)" = "Dernier jour de facturation (%@)";
+"%@ left" = "%@ restant";
+"Resets %@" = "Réinitialise %@";
+"Resets in %@" = "Réinitialisé dans %@";
+"Resets now" = "Réinitialise maintenant";
+"reset_tomorrow_format" = "demain, %@";
+"Lasts until reset" = "Dure jusqu'à la réinitialisation";
+"Updated %@" = "%@ mis à jour";
+"Updated %@h ago" = "Mis à jour il y a %@h";
+"Updated %@m ago" = "Mis à jour il y a %@m";
+"Updated just now" = "Mis à jour tout à l'heure";
+"Projected empty in %@" = "Projeté vide dans %@";
+"Runs out in %@" = "S'épuise dans %@";
+"Pace: %@" = "Rythme : %@";
+"Pace: %@ · %@" = "Rythme : %@ · %@";
+"%@ · %@" = "%@ · %@";
+"≈ %d%% run-out risk" = "≈ %d%% risque d'épuisement";
+"%d%% in deficit" = "%d%% en déficit";
+"%d%% in reserve" = "%d%% en réserve";
+"usage_percent_suffix_left" = "restant";
+"usage_percent_suffix_used" = "utilisé";
+"Store multiple DeepSeek API keys." = "Stockez plusieurs clés API DeepSeek.";
+"This week" = "Cette semaine";
+"Week" = "Semaine";
+"Month" = "Mois";
+"Models" = "Modèles";
+"24h tokens" = "jetons 24h";
+"Latest hour" = "Dernière heure";
+"Peak hour" = "Heure de pointe";
+"Top method" = "Méthode supérieure";
+"30d cash" = "30 jours en espèces";
+"30d billing history from MiniMax web session" = "Historique de facturation 30 jours à partir de la session Web MiniMax";
+"AWS Cost Explorer billing can lag." = "La facturation d'AWS Cost Explorer peut prendre du retard.";
+"Rate limit: %d / %@" = "Limite de débit : %d / %@";
+"Key remaining" = "Clé restante";
+"No limit set for the API key" = "Aucune limite définie pour la clé API";
+"API key limit unavailable right now" = "Limite de clé API indisponible pour le moment";
+"This month: %@ tokens" = "Ce mois-ci : %@ jetons";
+"No utilization data yet." = "Aucune donnée d'utilisation pour l'instant.";
+"No %@ utilization data yet." = "Aucune donnée d'utilisation de %@ pour l'instant.";
+"%@: %@%% used" = "%@ : %@%% utilisé";
+"%dd" = "%dd";
+"today" = "aujourd'hui";
+"just now" = "tout à l' heure";
+"On pace" = "Au rythme";
+"Runs out now" = "S'épuise maintenant";
+"Projected empty now" = "Projeté vide maintenant";
+"Switch Account..." = "Changer de compte...";
+"Update ready, restart now?" = "La mise à jour est prête, redémarrer maintenant ?";
+"Daily" = "Quotidien";
+"Hourly Tokens" = "Jetons horaires";
+"No data" = "Aucune donnée";
+"No usage breakdown data available." = "Aucune donnée de répartition d'utilisation disponible.";
+
+"Today: %@ · %@ tokens" = "Aujourd'hui : %@ · %@ jetons";
+"Today: %@" = "Aujourd'hui : %@";
+"Today: %@ tokens" = "Aujourd'hui : %@ jetons";
+"Last 30 days: %@ · %@ tokens" = "30 derniers jours : %@ · %@ jetons";
+"Last 30 days: %@" = "30 derniers jours : %@";
+"Est. total (30d): %@" = "HNE. total (30j) : %@";
+"Est. total (%@): %@" = "HNE. total (%@) : %@";
+"Hover a bar for details" = "Passez la souris sur une barre pour plus de détails";
+"%@: %@ · %@ tokens" = "%@ : %@ · %@ jetons";
+"No providers selected for Overview." = "Aucun fournisseur sélectionné pour la vue d'ensemble.";
+"No overview data available." = "Aucune donnée globale disponible.";
+"Auto uses the local IDE API first, then Google OAuth when the IDE is closed." = "Auto utilise d'abord l'API IDE locale, puis Google OAuth lorsque l'EDI est fermé.";
+"Login with Google" = "Connectez-vous avec Google";
+
+/* Popup panels */
+"No usage configured." = "Aucune utilisation configurée.";
+"Quota" = "Quota";
+"tokens" = "jetons";
+"requests" = "requêtes";
+"Latest" = "Dernier";
+"Monthly" = "Mensuel";
+"Sonnet" = "Sonnet";
+"Overages" = "Dépassements";
+"Activity" = "Activité";
+"Copied" = "Copié";
+"Copy error" = "Erreur de copie";
+"Copy path" = "Copier le chemin";
+"Extra usage spent" = "Utilisation supplémentaire dépensée";
+"Credits remaining" = "Crédits restants";
+"Using CLI fallback" = "Utilisation de la solution de secours CLI";
+"Balance updates in near-real time (up to 5 min lag)" = "Mises à jour du solde en temps quasi réel (jusqu'à 5 minutes de décalage)";
+"Daily billing data finalizes at 07:00 UTC" = "Les données de facturation quotidiennes se terminent à 07h00 UTC";
+"%@ of %@ credits left" = "%@ sur %@ crédits restants";
+"%@ of %@ bonus credits left" = "%@ de %@ crédits bonus restants";
+"%@ / %@ (%@ remaining)" = "%@ / %@ (%@ restant)";
+"%@/%@ left" = "%@/%@ gauche";
+"Gemini Flash" = "Flash Gémeaux";
+"Regenerates %@" = "Régénère %@";
+"used after next regen" = "utilisé après la prochaine régénération";
+"after next regen" = "après la prochaine régénération";
+"Near full" = "Presque plein";
+"Full in ~1 regen" = "Complet en ~1 régénération";
+"Full in ~%.0f regens" = "Plein en ~%.0f régénérations";
+"Overage usage" = "Utilisation excédentaire";
+"Overage cost" = "Coût excédentaire";
+"credits" = "crédits";
+"Zen balance" = "L'équilibre zen";
+"API spend" = "Dépenses API";
+"Extra usage" = "Utilisation supplémentaire";
+"Quota usage" = "Utilisation des quotas";
+"Your spend" = "Votre dépense";
+"%.0f%% used" = "%.0f%% utilisé";
+"Usage history (today)" = "Historique d'utilisation (aujourd'hui)";
+"Usage history (%d days)" = "Historique d'utilisation (%d jours)";
+"%d percent remaining" = "%d pour cent restant";
+"Unknown" = "Inconnu";
+"stale data" = "données obsolètes";
+"No credits history data." = "Aucune donnée d'historique de crédits.";
+"No credits history data available." = "Aucune donnée d'historique de crédits disponible.";
+"Credits history chart" = "Graphique de l'historique des crédits";
+"%d days of credits data" = "%d jours de données de crédits";
+"Usage breakdown chart" = "Tableau de répartition de l'utilisation";
+"%d days of usage data across %d services" = "%d jours de données d'utilisation sur %d services";
+"Cost history chart" = "Graphique de l'historique des coûts";
+"%d days of cost data" = "%d jours de données sur les coûts";
+"Plan utilization chart" = "Tableau d'utilisation du plan";
+"%d utilization samples" = "Exemples d'utilisation de %d";
+"Hourly Usage" = "Utilisation horaire";
+"Usage remaining" = "Utilisation restante";
+"Usage used" = "Utilisation utilisée";
+"API key verified. Ollama does not expose Cloud quota limits through the API." = "Clé API vérifiée. Ollama n'expose pas les limites de quota Cloud via l'API.";
+"Last 30 days: %@ tokens" = "30 derniers jours : jetons %@";
+"7d spend" = "7j dépensés";
+"30d spend" = "30 jours de dépenses";
+"Cache read" = "Lecture du cache";
+"Claude Admin API 30 day spend trend" = "Tendance des dépenses de l'API Claude Admin sur 30 jours";
+"OpenRouter API key spend trend" = "Tendance des dépenses liées aux clés API OpenRouter";
+"z.ai hourly token trend" = "tendance des jetons horaires z.ai";
+"MiniMax 30 day token usage trend" = "Tendance d'utilisation des jetons MiniMax sur 30 jours";
+"Today cash" = "Aujourd'hui en espèces";
+"DeepSeek 30 day token usage trend" = "Tendance d'utilisation des jetons DeepSeek sur 30 jours";
+"cache-hit input" = "entrée d'accès au cache";
+"cache-miss input" = "entrée manquante dans le cache";
+"output" = "sortie";
+"Requests" = "Requêtes";
+"Reported by OpenAI Admin API organization usage." = "Signalé par l’utilisation de l’organisation de l’API OpenAI Admin.";
+"Reported by Mistral billing usage." = "Rapporté par l'utilisation de la facturation Mistral.";
+"Google OAuth" = "Google OAuth";
+"Add accounts via GitHub OAuth Device Flow on the selected host." = "Ajoutez des comptes via GitHub OAuth Device Flow sur l'hôte sélectionné.";
+"Stores each signed-in Google account for quick Antigravity switching. Uses Antigravity.app OAuth when available, or ANTIGRAVITY_OAUTH_CLIENT_ID and ANTIGRAVITY_OAUTH_CLIENT_SECRET as an override." = "Stocke chaque compte Google connecté pour un changement rapide d'antigravité. Utilise Antigravity.app OAuth lorsqu'il est disponible, ou ANTIGRAVITY_OAUTH_CLIENT_ID et ANTIGRAVITY_OAUTH_CLIENT_SECRET comme remplacement.";
+"Manual cleanup: past sessions" = "Nettoyage manuel : sessions précédentes";
+"Clearing removes past resume, continue, and rewind history." = "L'effacement supprime l'historique de reprise, de continuation et de rembobinage passé.";
+"Manual cleanup: file checkpoints" = "Nettoyage manuel : points de contrôle des fichiers";
+"Clearing removes checkpoint restore data for previous edits." = "La suppression supprime les données de restauration du point de contrôle pour les modifications précédentes.";
+"Manual cleanup: saved plans" = "Nettoyage manuel : plans enregistrés";
+"Clearing removes old plan-mode files." = "La suppression supprime les anciens fichiers en mode plan.";
+"Manual cleanup: debug logs" = "Nettoyage manuel : journaux de débogage";
+"Clearing removes past debug logs." = "La suppression supprime les anciens journaux de débogage.";
+"Manual cleanup: attachment cache" = "Nettoyage manuel : cache des pièces jointes";
+"Clearing removes cached large pastes or attached images." = "La suppression supprime les gros collages mis en cache ou les images jointes.";
+"Manual cleanup: session metadata" = "Nettoyage manuel : métadonnées de session";
+"Clearing removes per-session environment metadata." = "La suppression supprime les métadonnées de l'environnement par session.";
+"Manual cleanup: shell snapshots" = "Nettoyage manuel : instantanés du shell";
+"Clearing removes leftover runtime shell snapshot files." = "La suppression supprime les fichiers instantanés du shell d'exécution restants.";
+"Manual cleanup: legacy todos" = "Nettoyage manuel : tâches héritées";
+"Clearing removes legacy per-session task lists." = "La suppression supprime les anciennes listes de tâches par session.";
+"Manual cleanup: sessions" = "Nettoyage manuel : sessions";
+"Clearing removes past Codex session history." = "La suppression supprime l'historique des sessions Codex passées.";
+"Manual cleanup: archived sessions" = "Nettoyage manuel : sessions archivées";
+"Clearing removes archived Codex session history." = "La suppression supprime l'historique des sessions Codex archivé.";
+"Manual cleanup: cache" = "Nettoyage manuel : cache";
+"Clearing removes provider-owned cached data." = "La suppression supprime les données mises en cache appartenant au fournisseur.";
+"Manual cleanup: logs" = "Nettoyage manuel : journaux";
+"Clearing removes local diagnostic logs." = "La suppression supprime les journaux de diagnostic locaux.";
+"Manual cleanup: file history" = "Nettoyage manuel : historique des fichiers";
+"Clearing removes local edit checkpoint history." = "La suppression supprime l’historique des points de contrôle des modifications locales.";
+"Manual cleanup: temporary data" = "Nettoyage manuel : données temporaires";
+"Clearing removes local temporary provider data." = "La suppression supprime les données du fournisseur temporaire local.";
+"Total: %@" = "Total : %@";
+"%d more items" = "%d plus d'articles";
+"Cleanup ideas" = "Idées de nettoyage";
+"%d unreadable item(s) skipped" = "%d élément(s) illisible(s) ignoré(s)";
+
+"API key limit" = "Limite de clé API";
+"Auth" = "Authentification";
+"Auto" = "Auto";
+"Disabled — no recent data" = "Désactivé – aucune donnée récente";
+"Limits not available" = "Limites non disponibles";
+"No usage yet" = "Pas encore d'utilisation";
+"Not fetched yet" = "Pas encore récupéré";
+"Refreshing" = "Actualisation";
+"Session" = "Session";
+"Source" = "Source";
+"State" = "État";
+"Unavailable" = "Indisponible";
+"Weekly" = "Hebdomadaire";
+"not detected" = "non détecté";
+"Estimated from local Codex logs for the selected account." = "Estimé à partir des journaux Codex locaux pour le compte sélectionné.";
+"minimax_usage_amount_format" = "Utilisation : %@ / %@";
+"minimax_used_percent_format" = "Utilisé %@";
+"minimax_service_text_generation" = "Génération de texte";
+"minimax_service_text_to_speech" = "Synthèse vocale";
+"minimax_service_music_generation" = "Génération de musique";
+"minimax_service_image_generation" = "Génération d'images";
+"minimax_service_lyrics_generation" = "Génération de paroles";
+"minimax_service_coding_plan_vlm" = "Plan de codage VLM";
+"minimax_service_coding_plan_search" = "Recherche de plan de codage";
+
+/* Additional provider settings and alerts */
+"%@ is waiting for permission" = "%@ attend l'autorisation";
+"%@ requests" = "%@ requêtes";
+"%@: %@ credits" = "%@ : %@ crédits";
+"30d requests" = "demandes 30j";
+"4 days" = "4 jours";
+"5 days" = "5 jours";
+"7 days" = "7 jours";
+"API key verifies Ollama Cloud access; cookies still expose quota limits." = "La clé API vérifie l'accès à Ollama Cloud ; les cookies exposent toujours des limites de quota.";
+"AWS access key ID. Can also be set with AWS_ACCESS_KEY_ID." = "ID de clé d'accès AWS. Peut également être défini avec AWS_ACCESS_KEY_ID.";
+"AWS region. Can also be set with AWS_REGION." = "Région AWS. Peut également être défini avec AWS_REGION.";
+"AWS secret access key. Can also be set with AWS_SECRET_ACCESS_KEY." = "Clé d'accès secrète AWS. Peut également être défini avec AWS_SECRET_ACCESS_KEY.";
+"Access key ID" = "ID de la clé d'accès";
+"Add Account" = "Ajouter un compte";
+"Adding Account…" = "Ajout d'un compte…";
+"Antigravity login failed" = "La connexion antigravité a échoué";
+"Antigravity login timed out" = "La connexion antigravité a expiré";
+"Auth source" = "Source d'authentification";
+"Automatic imports browser cookies from Xiaomi MiMo." = "Importe automatiquement les cookies du navigateur de Xiaomi MiMo.";
+"Automatic imports Windsurf session data from Chromium browser localStorage." = "Importe automatiquement les données de session Windsurf à partir du navigateur Chromium localStorage.";
+"Automatic imports browser cookies from Bailian." = "Importe automatiquement les cookies du navigateur depuis Bailian.";
+"Automatically imports browser cookies." = "Importe automatiquement les cookies du navigateur.";
+"Automatically imports browser session cookies." = "Importe automatiquement les cookies de session du navigateur.";
+"Azure OpenAI deployment name. AZURE_OPENAI_DEPLOYMENT_NAME is also supported." = "Nom du déploiement Azure OpenAI. AZURE_OPENAI_DEPLOYMENT_NAME est également pris en charge.";
+"Azure OpenAI key" = "Clé Azure OpenAI";
+"Azure OpenAI resource endpoint. AZURE_OPENAI_ENDPOINT is also supported." = "Point de terminaison de ressource Azure OpenAI. AZURE_OPENAI_ENDPOINT est également pris en charge.";
+"Base URL" = "URL de base";
+"Base URL for the LLM-API-Key-Proxy instance." = "URL de base pour l'instance LLM-API-Key-Proxy.";
+"Browser cookies" = "Cookies du navigateur";
+"Cap end" = "Fin du capuchon";
+"Cap start" = "Début du plafond";
+"Capacity End" = "Fin de capacité";
+"Capacity Start" = "Capacité Début";
+"Changelog" = "Journal des modifications";
+"Choose the Moonshot/Kimi API host for international or China mainland accounts." = "Choisissez l'hôte API Moonshot/Kimi pour les comptes internationaux ou en Chine continentale.";
+"CodexBar can't replace a system account that is signed in with an API key only setup." = "CodexBar ne peut pas remplacer un compte système connecté par une configuration de clé API uniquement.";
+"CodexBar could not find saved auth for that account. Re-authenticate it and try again." = "CodexBar n'a pas pu trouver l'authentification enregistrée pour ce compte. Ré-authentifiez-le et réessayez.";
+"CodexBar could not read managed account storage. Recover the store before adding another account." = "CodexBar n'a pas pu lire le stockage du compte géré. Récupérez la boutique avant d'ajouter un autre compte.";
+"CodexBar could not read saved auth for that account. Re-authenticate it and try again." = "CodexBar n'a pas pu lire l'authentification enregistrée pour ce compte. Ré-authentifiez-le et réessayez.";
+"CodexBar could not read the current system account on this Mac." = "CodexBar n'a pas pu lire le compte système actuel sur ce Mac.";
+"CodexBar could not replace the live Codex auth on this Mac." = "CodexBar n'a pas pu remplacer l'authentification Codex en direct sur ce Mac.";
+"CodexBar could not safely preserve the current system account before switching." = "CodexBar n'a pas pu conserver en toute sécurité le compte système actuel avant le changement.";
+"CodexBar could not save the current system account before switching." = "CodexBar n'a pas pu enregistrer le compte système actuel avant de changer.";
+"CodexBar could not update managed account storage." = "CodexBar n'a pas pu mettre à jour le stockage du compte géré.";
+"CodexBar found another managed account that already uses the current system account. Resolve the duplicate account before switching." = "CodexBar a trouvé un autre compte géré qui utilise déjà le compte système actuel. Résolvez le compte en double avant de changer.";
+"CodexBar will ask macOS Keychain for “%@” so it can decrypt browser cookies and authenticate your account. Click OK to continue." = "CodexBar demandera au Trousseau macOS « %@ » afin de pouvoir décrypter les cookies du navigateur et authentifier votre compte. Cliquez sur OK pour continuer.";
+"CodexBar will ask macOS Keychain for the Claude Code OAuth token so it can fetch your Claude usage. Click OK to continue." = "CodexBar demandera au Trousseau macOS le jeton Claude Code OAuth afin de pouvoir récupérer votre utilisation de Claude. Cliquez sur OK pour continuer.";
+"CodexBar will ask macOS Keychain for your Amp cookie header so it can fetch usage. Click OK to continue." = "CodexBar demandera au Trousseau macOS l'en-tête de votre cookie Amp afin de pouvoir récupérer son utilisation. Cliquez sur OK pour continuer.";
+"CodexBar will ask macOS Keychain for your Augment cookie header so it can fetch usage. Click OK to continue." = "CodexBar demandera au Trousseau macOS votre en-tête de cookie Augment afin de pouvoir récupérer son utilisation. Cliquez sur OK pour continuer.";
+"CodexBar will ask macOS Keychain for your Claude cookie header so it can fetch Claude web usage. Click OK to continue." = "CodexBar demandera au Trousseau macOS votre en-tête de cookie Claude afin de pouvoir récupérer l'utilisation du Web de Claude. Cliquez sur OK pour continuer.";
+"CodexBar will ask macOS Keychain for your Cursor cookie header so it can fetch usage. Click OK to continue." = "CodexBar demandera au Trousseau macOS l'en-tête de votre cookie Cursor afin de pouvoir récupérer son utilisation. Cliquez sur OK pour continuer.";
+"CodexBar will ask macOS Keychain for your Factory cookie header so it can fetch usage. Click OK to continue." = "CodexBar demandera au Trousseau macOS l'en-tête de votre cookie d'usine afin de pouvoir récupérer son utilisation. Cliquez sur OK pour continuer.";
+"CodexBar will ask macOS Keychain for your GitHub Copilot token so it can fetch usage. Click OK to continue." = "CodexBar demandera au Trousseau macOS votre jeton GitHub Copilot afin de pouvoir récupérer son utilisation. Cliquez sur OK pour continuer.";
+"CodexBar will ask macOS Keychain for your Kimi K2 API key so it can fetch usage. Click OK to continue." = "CodexBar demandera au Trousseau macOS votre clé API Kimi K2 afin de pouvoir récupérer son utilisation. Cliquez sur OK pour continuer.";
+"CodexBar will ask macOS Keychain for your Kimi auth token so it can fetch usage. Click OK to continue." = "CodexBar demandera au Trousseau macOS votre jeton d'authentification Kimi afin de pouvoir récupérer son utilisation. Cliquez sur OK pour continuer.";
+"CodexBar will ask macOS Keychain for your MiniMax API token so it can fetch usage. Click OK to continue." = "CodexBar demandera au Trousseau macOS votre jeton API MiniMax afin de pouvoir récupérer son utilisation. Cliquez sur OK pour continuer.";
+"CodexBar will ask macOS Keychain for your MiniMax cookie header so it can fetch usage. Click OK to continue." = "CodexBar demandera au Trousseau macOS votre en-tête de cookie MiniMax afin de pouvoir récupérer son utilisation. Cliquez sur OK pour continuer.";
+"CodexBar will ask macOS Keychain for your OpenAI cookie header so it can fetch Codex dashboard extras. Click OK to continue." = "CodexBar demandera au Trousseau macOS votre en-tête de cookie OpenAI afin de pouvoir récupérer les extras du tableau de bord Codex. Cliquez sur OK pour continuer.";
+"CodexBar will ask macOS Keychain for your OpenCode cookie header so it can fetch usage. Click OK to continue." = "CodexBar demandera au Trousseau macOS votre en-tête de cookie OpenCode afin de pouvoir récupérer son utilisation. Cliquez sur OK pour continuer.";
+"CodexBar will ask macOS Keychain for your Synthetic API key so it can fetch usage. Click OK to continue." = "CodexBar demandera au Trousseau macOS votre clé API synthétique afin de pouvoir récupérer son utilisation. Cliquez sur OK pour continuer.";
+"CodexBar will ask macOS Keychain for your z.ai API token so it can fetch usage. Click OK to continue." = "CodexBar demandera au Trousseau macOS votre jeton API z.ai afin de pouvoir récupérer son utilisation. Cliquez sur OK pour continuer.";
+"Could not open Cursor login in your browser." = "Impossible d'ouvrir la connexion par curseur dans votre navigateur.";
+"Could not open browser for Antigravity" = "Impossible d'ouvrir le navigateur pour Antigravity";
+"Credits used" = "Crédits utilisés";
+"Day" = "Jour";
+"Deployment" = "Déploiement";
+"Drag to reorder" = "Faites glisser pour réorganiser";
+"Sort providers alphabetically" = "Trier les fournisseurs par ordre alphabétique";
+"Sort providers alphabetically (enabled first)" = "Trier les fournisseurs par ordre alphabétique (activés en premier)";
+"Sorted alphabetically (enabled first) — click to use your custom order" = "Triés par ordre alphabétique (activés en premier) — cliquez pour utiliser votre ordre personnalisé";
+"Endpoint" = "Point de terminaison";
+"Enterprise host" = "Hôte d'entreprise";
+"Extra usage balance: %@" = "Solde d'utilisation supplémentaire : %@";
+"Keychain Access Required" = "Accès au Trousseau requis";
+"Kiro menu bar value" = "Valeur de la barre de menu Kiro";
+"Label" = "Libellé";
+"No organizations loaded. Click Refresh after setting your API key." = "Aucune organisation chargée. Cliquez sur Actualiser après avoir défini votre clé API.";
+"No output captured." = "Aucune sortie capturée.";
+"No system account" = "Aucun compte système";
+"Oasis-Token" = "Oasis-Token";
+"Open Augment (Log Out & Back In)" = "Ouvrir l'augmentation (déconnexion et reconnexion)";
+"Open Codebuff Dashboard" = "Ouvrir le tableau de bord Codebuff";
+"Open Command Code Settings" = "Ouvrir les paramètres du code de commande";
+"Open Crof dashboard" = "Ouvrir le tableau de bord Crof";
+"Open Manus" = "Ouvrir Manus";
+"Open MiMo Balance" = "Ouvrir la balance MiMo";
+"Open Moonshot Console" = "Ouvrir la console Moonshot";
+"Open Ollama API Keys" = "Ouvrir les clés API Ollama";
+"Open StepFun Platform" = "Ouvrir la plateforme StepFun";
+"Open T3 Chat Settings" = "Ouvrir les paramètres de discussion T3";
+"Open Volcengine Ark Console" = "Ouvrir la console Volcengine Ark";
+"Open legacy provider docs" = "Ouvrir les documents du fournisseur existant";
+"Open projects" = "Projets ouverts";
+"Open this URL manually to continue login:\n\n%@" = "Ouvrez cette URL manuellement pour continuer la connexion :\n\n%@";
+"Optional organization ID for accounts linked to multiple Anthropic organizations." = "ID d'organisation facultatif pour les comptes liés à plusieurs organisations Anthropic.";
+"Optional. Applies to the configured Admin API key; selected token accounts do not inherit OPENAI_PROJECT_ID." = "Facultatif. S'applique à la clé API Admin configurée ; Les comptes de jetons sélectionnés n'héritent pas d'OPENAI_PROJECT_ID.";
+"Optional. Enter your GitHub Enterprise host, for example octocorp.ghe.com. Leave blank for github.com." = "Facultatif. Entrez votre hôte GitHub Enterprise, par exemple octocorp.ghe.com. Laissez vide pour github.com.";
+"Optional. Leave blank to discover and aggregate projects visible to the API key." = "Facultatif. Laissez vide pour découvrir et regrouper les projets visibles par la clé API.";
+"Org ID (optional)" = "ID de l'organisation (facultatif)";
+"Organizations" = "Organisations";
+"Password" = "Mot de passe";
+"%@ authentication is disabled." = "L'authentification %@ est désactivée.";
+"%@ cookies are disabled." = "Les cookies %@ sont désactivés.";
+"%@ web API access is disabled." = "L'accès à l'API Web %@ est désactivé.";
+"Disable %@ dashboard cookie usage." = "Désactivez l'utilisation des cookies du tableau de bord %@.";
+"Keychain access is disabled in Advanced, so browser cookie import is unavailable." = "L'accès au Trousseau est désactivé dans Advanced, donc l'importation des cookies du navigateur n'est pas disponible.";
+"Manually paste an %@ from a browser session." = "Collez manuellement un %@ à partir d'une session de navigateur.";
+"Paste a Cookie header captured from %@." = "Collez un en-tête de cookie capturé à partir de %@.";
+"Paste a Cookie header from %@." = "Collez un en-tête de cookie à partir de %@.";
+"Paste a Cookie header or cURL capture from %@." = "Collez un en-tête de cookie ou une capture cURL à partir de %@.";
+"Paste a Cookie header or full cURL capture from %@." = "Collez un en-tête de cookie ou une capture cURL complète à partir de %@.";
+"Paste a Cookie or Authorization header from %@." = "Collez un en-tête de cookie ou d'autorisation à partir de %@.";
+"Paste a full cookie header or the %@ value." = "Collez un en-tête de cookie complet ou la valeur %@.";
+"Paste a Cookie header or full cURL capture from T3 Chat settings." = "Collez un en-tête de cookie ou une capture cURL complète à partir des paramètres de T3 Chat.";
+"Paste the Cookie header from a request to admin.mistral.ai. Must contain an ory_session_* cookie." = "Collez l'en-tête Cookie d'une requête vers admin.mistral.ai. Doit contenir un cookie ory_session_*.";
+"Paste the Oasis-Token from a logged-in browser session on platform.stepfun.com." = "Collez le jeton Oasis à partir d'une session de navigateur connectée sur platform.stepfun.com.";
+"Paste the %@ JSON bundle from %@." = "Collez le bundle JSON %@ de %@.";
+"Paste the %@ value or a full Cookie header." = "Collez la valeur %@ ou un en-tête de cookie complet.";
+"Personal account" = "Compte personnel";
+"Project ID" = "ID du projet";
+"Re-auth" = "Se reconnecter";
+"Re-login at claude.ai" = "Se reconnecter à claude.ai";
+"Re-authenticating…" = "Réauthentification…";
+"Refresh Session" = "Session de rafraîchissement";
+"Refresh organizations" = "Actualiser les organisations";
+"Region" = "Région";
+"Reload" = "Recharger";
+"Reorder" = "Réorganiser";
+"Secret access key" = "Clé d'accès secrète";
+"Series" = "Séries";
+"Service" = "Service";
+"Show or hide Kiro credits, percent, or both next to the menu bar icon." = "Affichez ou masquez les crédits Kiro, le pourcentage ou les deux à côté de l'icône de la barre de menu.";
+"Show usage for organizations you belong to. Personal account is always shown." = "Afficher l'utilisation des organisations auxquelles vous appartenez. Le compte personnel est toujours affiché.";
+"Sign in to cursor.com in your browser, then refresh Cursor in CodexBar." = "Connectez-vous à cursor.com dans votre navigateur, puis actualisez Cursor dans CodexBar.";
+"Simulated error text" = "Texte d'erreur simulé";
+"StepFun platform account (phone number or email)." = "Compte de la plateforme StepFun (numéro de téléphone ou email).";
+"Stored in ~/.codexbar/config.json." = "Stocké dans ~/.codexbar/config.json.";
+"Stored in ~/.codexbar/config.json. AZURE_OPENAI_API_KEY is also supported." = "Stocké dans ~/.codexbar/config.json. AZURE_OPENAI_API_KEY est également pris en charge.";
+"Stored in ~/.codexbar/config.json. For the official Kimi API, use Moonshot / Kimi API." = "Stocké dans ~/.codexbar/config.json. Pour l'API Kimi officielle, utilisez l'API Moonshot / Kimi.";
+"Stored in ~/.codexbar/config.json. Get your API key from the Volcengine Ark console." = "Stocké dans ~/.codexbar/config.json. Obtenez votre clé API depuis la console Volcengine Ark.";
+"Stored in ~/.codexbar/config.json. Get your key from Ollama settings." = "Stocké dans ~/.codexbar/config.json. Obtenez votre clé dans les paramètres d'Ollama.";
+"Stored in ~/.codexbar/config.json. Get your key from console.deepgram.com." = "Stocké dans ~/.codexbar/config.json. Obtenez votre clé sur console.deepgram.com.";
+"Stored in ~/.codexbar/config.json. Get your key from elevenlabs.io/app/settings/api-keys." = "Stocké dans ~/.codexbar/config.json. Obtenez votre clé sur Elevenlabs.io/app/settings/api-keys.";
+"Stored in ~/.codexbar/config.json. Get your key from openrouter.ai/settings/keys and set a key spending limit there to enable API key quota tracking." = "Stocké dans ~/.codexbar/config.json. Obtenez votre clé sur openrouter.ai/settings/keys et définissez-y une limite de dépenses pour activer le suivi des quotas de clés API.";
+"Stored in ~/.codexbar/config.json. In Warp, open Settings > Platform > API Keys, then create one." = "Stocké dans ~/.codexbar/config.json. Dans Warp, ouvrez Paramètres > Plateforme > Clés API, puis créez-en une.";
+"Stored in ~/.codexbar/config.json. Metrics require Groq Enterprise Prometheus access." = "Stocké dans ~/.codexbar/config.json. Les métriques nécessitent un accès à Groq Enterprise Prometheus.";
+"Stored in ~/.codexbar/config.json. OPENAI_ADMIN_KEY is preferred; OPENAI_API_KEY still works." = "Stocké dans ~/.codexbar/config.json. OPENAI_ADMIN_KEY est préféré ; OPENAI_API_KEY fonctionne toujours.";
+"Stored in ~/.codexbar/config.json. Requires an Anthropic Admin API key." = "Stocké dans ~/.codexbar/config.json. Nécessite une clé API Anthropic Admin.";
+"Stored in ~/.codexbar/config.json. Used for /v1/quota-stats." = "Stocké dans ~/.codexbar/config.json. Utilisé pour /v1/quota-stats.";
+"Stored in ~/.codexbar/config.json. You can also provide CODEBUFF_API_KEY or let CodexBar read ~/.config/manicode/credentials.json (created by `codebuff login`)." = "Stocké dans ~/.codexbar/config.json. Vous pouvez également fournir CODEBUFF_API_KEY ou laisser CodexBar lire ~/.config/manicode/credentials.json (créé par `codebuff login`).";
+"Stored in ~/.codexbar/config.json. You can also provide CROF_API_KEY." = "Stocké dans ~/.codexbar/config.json. Vous pouvez également fournir CROF_API_KEY.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or ~/.local/share/kilo/auth.json (kilo.access)." = "Stocké dans ~/.codexbar/config.json. Vous pouvez également fournir KILO_API_KEY ou ~/.local/share/kilo/auth.json (kilo.access).";
+"T3 Chat cookie" = "Cookie de discussion T3";
+"That account is no longer available in CodexBar. Refresh the account list and try again." = "Ce compte n'est plus disponible dans CodexBar. Actualisez la liste des comptes et réessayez.";
+"The browser login did not complete in time. Try Antigravity login again." = "La connexion au navigateur ne s'est pas terminée à temps. Essayez à nouveau de vous connecter à Antigravity.";
+"Timed out waiting for Cursor login. %@" = "Le délai d'attente pour la connexion au curseur a expiré. %@";
+"Timed out waiting for Cursor login. %@ Last error: %@" = "Le délai d'attente pour la connexion au curseur a expiré. %@ Dernière erreur : %@";
+"Today requests" = "Demandes d'aujourd'hui";
+"Total (30d): %@ credits" = "Total (30j) : %@ crédits";
+"Username" = "Nom d’utilisateur";
+"Uses username + password to login and obtain an Oasis-Token automatically." = "Utilise le nom d'utilisateur + le mot de passe pour se connecter et obtenir automatiquement un jeton Oasis.";
+"Uses username + password to login and obtain an %@ automatically." = "Utilise le nom d'utilisateur + le mot de passe pour se connecter et obtenir automatiquement un %@.";
+"Utilization End" = "Fin d'utilisation";
+"Utilization Start" = "Début de l'utilisation";
+"Verbosity" = "Niveau de verbosité";
+"Windsurf session JSON bundle" = "Pack JSON de session de planche à voile";
+"Workspace ID" = "ID de l'espace de travail";
+"Your StepFun platform password. Used to login and obtain a session token." = "Votre mot de passe de la plateforme StepFun. Utilisé pour se connecter et obtenir un jeton de session.";
+"claude /login exited with status %d." = "claude /login est sorti avec le statut %d.";
+"codex login exited with status %d." = "La connexion à Codex s'est terminée avec le statut %d.";
+"Cookie: …\n\nor paste a cURL capture from the Abacus AI dashboard" = "Cookie : …\n\nou collez une capture cURL à partir du tableau de bord Abacus AI";
+"Cookie: …\n\nor paste the __Secure-next-auth.session-token value" = "Cookie : …\n\nou collez la valeur __Secure-next-auth.session-token";
+"Cookie: …\n\nor paste the kimi-auth token value" = "Cookie : …\n\nou collez la valeur du jeton kimi-auth";
+"session_id=...\n\nor paste just the session_id value" = "session_id=...\n\nou collez uniquement la valeur session_id";
+"Clear" = "Effacer";
+"No matching providers" = "Aucun fournisseur correspondant";
+"Search providers" = "Fournisseurs de recherche";
+"language_arabic" = "العربية";
+"language_persian" = "فارسی";
+"language_thai" = "ไทย";
+"Limit Reset Credits" = "Crédits de réinitialisation de limite";
+"1 manual reset available" = "1 réinitialisation manuelle disponible";
+"%d manual resets available" = "%d réinitialisations manuelles disponibles";
+"Next expires %@" = "Prochaine expiration %@";
+"Other (%d items)" = "Autres (%d éléments)";
+"Expand" = "Développer";
+"Collapse" = "Réduire";
+"byte_unit_byte" = "octet";
+"byte_unit_bytes" = "octets";
+"byte_unit_kilobyte" = "kilooctet";
+"byte_unit_kilobytes" = "kilooctets";
+"byte_unit_megabyte" = "mégaoctet";
+"byte_unit_megabytes" = "mégaoctets";
+"byte_unit_gigabyte" = "gigaoctet";
+"byte_unit_gigabytes" = "gigaoctets";
diff --git a/Sources/CodexBar/Resources/id.lproj/Localizable.strings b/Sources/CodexBar/Resources/id.lproj/Localizable.strings
new file mode 100644
index 0000000000..a37fe38932
--- /dev/null
+++ b/Sources/CodexBar/Resources/id.lproj/Localizable.strings
@@ -0,0 +1,1109 @@
+/* Indonesian localization for CodexBar */
+
+" providers" = " penyedia";
+"(System)" = "(Sistem)";
+"30d" = "30 hari";
+"A managed Codex login is already running. Wait for it to finish before adding " = "Login Codex terkelola sudah berjalan. Tunggu hingga selesai sebelum menambahkan ";
+"API key" = "Kunci API";
+"API region" = "Wilayah API";
+"API token" = "Token API";
+"API tokens" = "Token API";
+"About" = "Tentang";
+"Account" = "Akun";
+"Accounts" = "Akun";
+"Accounts subtitle" = "Subjudul akun";
+"Active" = "Aktif";
+"Add" = "Tambah";
+"Add Workspace" = "Tambah Workspace";
+"Advanced" = "Lanjutan";
+"All" = "Semua";
+"Always allow prompts" = "Selalu izinkan permintaan";
+"Animation pattern" = "Pola animasi";
+"Antigravity login is managed in the app" = "Login Antigravity dikelola di dalam aplikasi";
+"Applies only to the Security.framework OAuth keychain reader." = "Hanya berlaku untuk pembaca keychain OAuth Security.framework.";
+"Auto falls back to the next source if the preferred one fails." = "Otomatis beralih ke sumber berikutnya jika yang dipilih gagal.";
+"Auto uses API first, then falls back to CLI on auth failures." = "Otomatis menggunakan API terlebih dahulu, lalu beralih ke CLI saat autentikasi gagal.";
+"Auto-detect" = "Deteksi otomatis";
+"Auto-refresh is off; use the menu's Refresh command." = "Penyegaran otomatis nonaktif; gunakan perintah Segarkan di menu.";
+"Auto-refresh: hourly · Timeout: 10m" = "Penyegaran otomatis: per jam · Batas waktu: 10m";
+"Automatic" = "Otomatis";
+"Automatic imports browser cookies and WorkOS tokens." = "Otomatis mengimpor cookie browser dan token WorkOS.";
+"Automatic imports browser cookies and local storage tokens." = "Otomatis mengimpor cookie browser dan token penyimpanan lokal.";
+"Automatic imports browser cookies for dashboard extras." = "Otomatis mengimpor cookie browser untuk fitur tambahan dasbor.";
+"Automatic imports browser cookies for the web API." = "Otomatis mengimpor cookie browser untuk web API.";
+"Automatic imports browser cookies from Model Studio/Bailian." = "Otomatis mengimpor cookie browser dari Model Studio/Bailian.";
+"Automatic imports browser cookies from admin.mistral.ai." = "Otomatis mengimpor cookie browser dari admin.mistral.ai.";
+"Automatic imports browser cookies from opencode.ai." = "Otomatis mengimpor cookie browser dari opencode.ai.";
+"Automatic imports browser cookies or stored sessions." = "Otomatis mengimpor cookie browser atau sesi tersimpan.";
+"Automatic imports browser cookies." = "Otomatis mengimpor cookie browser.";
+"Automatically imports browser session cookie." = "Otomatis mengimpor cookie sesi browser.";
+"Automatically opens CodexBar when you start your Mac." = "Otomatis membuka CodexBar saat Anda menyalakan Mac.";
+"Automation" = "Otomatisasi";
+"Average (\\(label1) + \\(label2))" = "Rata-rata (\\(label1) + \\(label2))";
+"Average (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))" = "Rata-rata (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))";
+"Avoid Keychain prompts" = "Hindari permintaan Keychain";
+"Balance" = "Saldo";
+"Battery Saver" = "Penghemat Baterai";
+"Bordered" = "Berbingkai";
+"Build" = "Build";
+"Built \\(buildTimestamp)" = "Dibangun \\(buildTimestamp)";
+"Buy Credits..." = "Beli Kredit...";
+"Buy Credits…" = "Beli Kredit…";
+"CLI paths" = "Path CLI";
+"CLI sessions" = "Sesi CLI";
+"Caches" = "Cache";
+"Cancel" = "Batal";
+"Check for Updates…" = "Periksa Pembaruan…";
+"Check for updates automatically" = "Periksa pembaruan secara otomatis";
+"Check if you like your agents having some fun up there." = "Centang jika Anda suka agen bersenang-senang di atas sana.";
+"Check provider status" = "Periksa status penyedia";
+"Choose Codex workspace" = "Pilih workspace Codex";
+"Choose the MiniMax host (global .io or China mainland .com)." = "Pilih host MiniMax (global .io atau Tiongkok daratan .com).";
+"Choose up to " = "Pilih hingga ";
+"Choose up to \\(Self.maxOverviewProviders) providers" = "Pilih hingga \\(Self.maxOverviewProviders) penyedia";
+"Choose up to \\(count) providers" = "Pilih hingga \\(count) penyedia";
+"Choose what to show in the menu bar (Pace shows usage vs. expected)." = "Pilih apa yang ditampilkan di menu bar (Pace menampilkan penggunaan vs. perkiraan).";
+"Choose which Codex account CodexBar should follow." = "Pilih akun Codex mana yang harus diikuti CodexBar.";
+"Choose which window drives the menu bar percent." = "Pilih jendela mana yang menggerakkan persentase menu bar.";
+"Chrome" = "Chrome";
+"Claude CLI not found" = "Claude CLI tidak ditemukan";
+"Claude binary" = "Biner Claude";
+"Claude cookies" = "Cookie Claude";
+"Claude login failed" = "Login Claude gagal";
+"Claude login timed out" = "Login Claude kehabisan waktu";
+"Close" = "Tutup";
+"Code review" = "Tinjauan kode";
+"Codex CLI not found" = "Codex CLI tidak ditemukan";
+"Codex account login already running" = "Login akun Codex sudah berjalan";
+"Codex binary" = "Biner Codex";
+"Codex login failed" = "Login Codex gagal";
+"Codex login timed out" = "Login Codex kehabisan waktu";
+"CodexBar Lifecycle Keepalive" = "CodexBar Lifecycle Keepalive";
+"CodexBar can't show its menu bar icon" = "CodexBar tidak dapat menampilkan ikon menu bar";
+"CodexBar could not read managed account storage. " = "CodexBar tidak dapat membaca penyimpanan akun terkelola. ";
+"Configure…" = "Konfigurasi…";
+"Connected" = "Terhubung";
+"Controls how much detail is logged." = "Mengontrol seberapa banyak detail yang dicatat.";
+"Cookie header" = "Header Cookie";
+"Cookie source" = "Sumber cookie";
+"Cookie: ..." = "Cookie: ...";
+"Cookie: \\u{2026}\\\n\\\nor paste a cURL capture from the Abacus AI dashboard" = "Cookie: \\u{2026}\\\n\\\natau tempel tangkapan cURL dari dasbor Abacus AI";
+"Cookie: \\u{2026}\\\n\\\nor paste the __Secure-next-auth.session-token value" = "Cookie: \\u{2026}\\\n\\\natau tempel nilai __Secure-next-auth.session-token";
+"Cookie: \\u{2026}\\\n\\\nor paste the kimi-auth token value" = "Cookie: \\u{2026}\\\n\\\natau tempel nilai token kimi-auth";
+"Cookie: …" = "Cookie: …";
+"CopilotDeviceFlow" = "CopilotDeviceFlow";
+"Cost" = "Biaya";
+"Could not add Codex account" = "Tidak dapat menambahkan akun Codex";
+"Could not open Terminal for Gemini" = "Tidak dapat membuka Terminal untuk Gemini";
+"Could not start claude /login" = "Tidak dapat memulai claude /login";
+"Could not start codex login" = "Tidak dapat memulai codex login";
+"Could not switch system account" = "Tidak dapat beralih akun sistem";
+"Credits" = "Kredit";
+"Individual credits" = "Kredit individual";
+"Workspace" = "Workspace";
+"Credits history" = "Riwayat kredit";
+"Cursor login failed" = "Login Cursor gagal";
+"Custom" = "Kustom";
+"Custom Path" = "Path Kustom";
+"Daily Routines" = "Rutinitas Harian";
+"Debug" = "Debug";
+"Default" = "Bawaan";
+"Disable Keychain access" = "Nonaktifkan akses Keychain";
+"Disabled" = "Nonaktif";
+"Dismiss" = "Tutup";
+"Disconnected" = "Terputus";
+"Display" = "Tampilan";
+"Display mode" = "Mode tampilan";
+"Display reset times as absolute clock values instead of countdowns." = "Tampilkan waktu reset sebagai jam absolut alih-alih hitung mundur.";
+"Done" = "Selesai";
+"Effective PATH" = "PATH Efektif";
+"Email" = "Email";
+"Enable Merge Icons to configure Overview tab providers." = "Aktifkan Gabung Ikon untuk mengonfigurasi penyedia tab Ikhtisar.";
+"Enable file logging" = "Aktifkan pencatatan file";
+"Enabled" = "Aktif";
+"Error" = "Error";
+"Error simulation" = "Simulasi error";
+"Expose troubleshooting tools in the Debug tab." = "Tampilkan alat pemecahan masalah di tab Debug.";
+"Failed" = "Gagal";
+"False" = "Salah";
+"Fetch strategy attempts" = "Percobaan strategi pengambilan";
+"Fetching" = "Mengambil";
+"Field" = "Bidang";
+"Field subtitle" = "Subjudul bidang";
+"Finish the current managed account change before switching the system account." = "Selesaikan perubahan akun terkelola saat ini sebelum beralih akun sistem.";
+"Force animation on next refresh" = "Paksa animasi pada penyegaran berikutnya";
+"Gateway region" = "Wilayah gateway";
+"Gemini CLI not found" = "Gemini CLI tidak ditemukan";
+"Gemini/Antigravity, surfacing incidents in the icon and menu." = "Gemini/Antigravity, menampilkan insiden di ikon dan menu.";
+"General" = "Umum";
+"GitHub" = "GitHub";
+"GitHub Copilot Login" = "Login GitHub Copilot";
+"GitHub Login" = "Login GitHub";
+"Hide details" = "Sembunyikan detail";
+"Hide personal information" = "Sembunyikan informasi pribadi";
+"Historical tracking" = "Pelacakan riwayat";
+"How often CodexBar polls providers in the background." = "Seberapa sering CodexBar memeriksa penyedia di latar belakang.";
+"Inactive" = "Tidak aktif";
+"Install CLI" = "Pasang CLI";
+"Install the Claude CLI (npm i -g @anthropic-ai/claude-code) and try again." = "Pasang Claude CLI (npm i -g @anthropic-ai/claude-code) dan coba lagi.";
+"Install the Codex CLI (npm i -g @openai/codex) and try again." = "Pasang Codex CLI (npm i -g @openai/codex) dan coba lagi.";
+"Install the Gemini CLI (npm i -g @google/gemini-cli) and try again." = "Pasang Gemini CLI (npm i -g @google/gemini-cli) dan coba lagi.";
+"JetBrains AI is ready" = "JetBrains AI siap";
+"JetBrains IDE" = "JetBrains IDE";
+"Keep CLI sessions alive" = "Pertahankan sesi CLI";
+"Keyboard shortcut" = "Pintasan keyboard";
+"Keychain access" = "Akses Keychain";
+"Keychain prompt policy" = "Kebijakan permintaan Keychain";
+"Last \\(name) fetch failed:" = "Pengambilan \\(name) terakhir gagal:";
+"Last \\(self.store.metadata(for: self.provider).displayName) fetch failed:" = "Pengambilan \\(self.store.metadata(for: self.provider).displayName) terakhir gagal:";
+"Last attempt" = "Percobaan terakhir";
+"Link" = "Tautan";
+"Loading animations" = "Animasi pemuatan";
+"Loading…" = "Memuat…";
+"Local" = "Lokal";
+"Logging" = "Pencatatan";
+"Login failed" = "Login gagal";
+"Login shell PATH (startup capture)" = "PATH shell login (tangkapan startup)";
+"Login timed out" = "Login kehabisan waktu";
+"MCP details" = "Detail MCP";
+"Managed Codex accounts unavailable" = "Akun Codex terkelola tidak tersedia";
+"Managed account storage is unreadable. Live account access is still available, " = "Penyimpanan akun terkelola tidak dapat dibaca. Akses akun langsung masih tersedia, ";
+"Manual" = "Manual";
+"May your tokens never run out—keep agent limits in view." = "Semoga token Anda tidak pernah habis—pantau batas agen Anda.";
+"Menu bar" = "Menu bar";
+"Menu bar auto-shows the provider closest to its rate limit." = "Menu bar otomatis menampilkan penyedia yang paling dekat batas penggunaannya.";
+"Menu bar metric" = "Metrik menu bar";
+"Menu bar shows percent" = "Menu bar tampilkan persen";
+"Menu content" = "Konten menu";
+"Merge Icons" = "Gabung Ikon";
+"Never prompt" = "Jangan pernah minta";
+"No" = "Tidak";
+"No Codex accounts detected yet." = "Belum ada akun Codex yang terdeteksi.";
+"No JetBrains IDE detected" = "Tidak ada JetBrains IDE terdeteksi";
+"No cost history data." = "Tidak ada data riwayat biaya.";
+"No data available" = "Tidak ada data tersedia";
+"No data yet" = "Belum ada data";
+"No enabled providers available for Overview." = "Tidak ada penyedia aktif untuk Ikhtisar.";
+"No providers selected" = "Tidak ada penyedia dipilih";
+"No token accounts yet." = "Belum ada akun token.";
+"No usage breakdown data." = "Tidak ada data rincian penggunaan.";
+"None" = "Tidak ada";
+"Notifications" = "Notifikasi";
+"Notifies when the 5-hour session quota hits 0% and when it becomes " = "Memberi tahu saat kuota sesi 5 jam mencapai 0% dan saat menjadi ";
+"OK" = "OK";
+"Obscure email addresses in the menu bar and menu UI." = "Samarkan alamat email di menu bar dan antarmuka menu.";
+"Off" = "Nonaktif";
+"Offline" = "Luring";
+"On" = "Aktif";
+"Online" = "Daring";
+"Only on user action" = "Hanya saat tindakan pengguna";
+"Open" = "Buka";
+"Open API Keys" = "Buka Kunci API";
+"Open Amp Settings" = "Buka Pengaturan Amp";
+"Open Antigravity to sign in, then refresh CodexBar." = "Buka Antigravity untuk masuk, lalu segarkan CodexBar.";
+"Open Browser" = "Buka Browser";
+"Open Coding Plan" = "Buka Coding Plan";
+"Open Console" = "Buka Konsol";
+"Open Dashboard" = "Buka Dasbor";
+"Open Mistral Admin" = "Buka Mistral Admin";
+"Open Menu Bar Settings" = "Buka Pengaturan Menu Bar";
+"Open Ollama Settings" = "Buka Pengaturan Ollama";
+"Open Terminal" = "Buka Terminal";
+"Open Usage Page" = "Buka Halaman Penggunaan";
+"Open Warp API Key Guide" = "Buka Panduan Kunci API Warp";
+"Open menu" = "Buka menu";
+"Open token file" = "Buka file token";
+"OpenAI cookies" = "Cookie OpenAI";
+"OpenAI web extras" = "Ekstra web OpenAI";
+"Option A" = "Opsi A";
+"Option B" = "Opsi B";
+"Optional override if workspace lookup fails." = "Penggantian opsional jika pencarian workspace gagal.";
+"Options" = "Opsi";
+"Override auto-detection with a custom IDE base path" = "Timpa deteksi otomatis dengan path dasar IDE kustom";
+"Overview" = "Ikhtisar";
+"Overview rows always follow provider order." = "Baris ikhtisar selalu mengikuti urutan penyedia.";
+"Overview tab providers" = "Penyedia tab ikhtisar";
+"Paste API key…" = "Tempel kunci API…";
+"Paste API token…" = "Tempel token API…";
+"Paste key…" = "Tempel kunci…";
+"Paste sessionKey or OAuth token…" = "Tempel sessionKey atau token OAuth…";
+"Paste the Cookie header from a request to admin.mistral.ai. " = "Tempel header Cookie dari permintaan ke admin.mistral.ai. ";
+"Paste token…" = "Tempel token…";
+"Personal" = "Pribadi";
+"Picker" = "Pemilih";
+"Picker subtitle" = "Subjudul pemilih";
+"Placeholder" = "Placeholder";
+"Plan" = "Paket";
+"Play full-screen confetti when weekly usage resets." = "Mainkan confetti layar penuh saat penggunaan mingguan direset.";
+"Polls OpenAI/Claude status pages and Google Workspace for " = "Memeriksa halaman status OpenAI/Claude dan Google Workspace untuk ";
+"Prevents any Keychain access while enabled." = "Mencegah semua akses Keychain saat diaktifkan.";
+"Primary (API key limit)" = "Utama (batas kunci API)";
+"Primary (\\(label))" = "Utama (\\(label))";
+"Primary (\\(metadata.sessionLabel))" = "Utama (\\(metadata.sessionLabel))";
+"Probe logs" = "Log probe";
+"Progress bars fill as you consume quota (instead of showing remaining)." = "Bilah progres terisi saat Anda menggunakan kuota (alih-alih menampilkan sisa).";
+"Provider" = "Penyedia";
+"Providers" = "Penyedia";
+"Quit CodexBar" = "Keluar CodexBar";
+"Random (default)" = "Acak (bawaan)";
+"Reads local usage logs. Shows today + last 30 days cost in the menu." = "Membaca log penggunaan lokal. Menampilkan hari ini + jendela riwayat yang dipilih di menu.";
+"Refresh" = "Segarkan";
+"Refresh cadence" = "Frekuensi penyegaran";
+"Remote" = "Jarak jauh";
+"Remove" = "Hapus";
+"Remove Codex account?" = "Hapus akun Codex?";
+"Remove \\(account.email) from CodexBar? Its managed Codex home will be deleted." = "Hapus \\(account.email) dari CodexBar? Home Codex terkelolanya akan dihapus.";
+"Remove \\(email) from CodexBar? Its managed Codex home will be deleted." = "Hapus \\(email) dari CodexBar? Home Codex terkelolanya akan dihapus.";
+"Remove selected account" = "Hapus akun terpilih";
+"Replace critter bars with provider branding icons and a percentage." = "Ganti bilah critter dengan ikon merek penyedia dan persentase.";
+"Replay selected animation" = "Putar ulang animasi terpilih";
+"Requires authentication via GitHub Device Flow." = "Memerlukan autentikasi via GitHub Device Flow.";
+"Resets: \\(reset)" = "Reset: \\(reset)";
+"Rolling five-hour limit" = "Batas bergulir lima jam";
+"Search hourly" = "Cari per jam";
+"Secondary (\\(label))" = "Sekunder (\\(label))";
+"Secondary (\\(metadata.weeklyLabel))" = "Sekunder (\\(metadata.weeklyLabel))";
+"Select a provider" = "Pilih penyedia";
+"Select the IDE to monitor" = "Pilih IDE yang dipantau";
+"Session quota notifications" = "Notifikasi kuota sesi";
+"Session tokens" = "Token sesi";
+"Settings" = "Pengaturan";
+"Show Codex Credits and Claude Extra usage sections in the menu." = "Tampilkan bagian Kredit Codex dan penggunaan Ekstra Claude di menu.";
+"Show Debug Settings" = "Tampilkan Pengaturan Debug";
+"Show all token accounts" = "Tampilkan semua akun token";
+"Show cost summary" = "Tampilkan ringkasan biaya";
+"Show credits + extra usage" = "Tampilkan kredit + penggunaan ekstra";
+"Show details" = "Tampilkan detail";
+"Show most-used provider" = "Tampilkan penyedia paling sering digunakan";
+"Show provider icons in the switcher (otherwise show a weekly progress line)." = "Tampilkan ikon penyedia di pengalih (jika tidak, tampilkan garis progres mingguan).";
+"Show reset time as clock" = "Tampilkan waktu reset sebagai jam";
+"Show usage as used" = "Tampilkan penggunaan sebagai terpakai";
+"Sign in via button below" = "Masuk via tombol di bawah";
+"Skip teardown between probes (debug-only)." = "Lewati pembersihan antar probe (hanya debug).";
+"Stack token accounts in the menu (otherwise show an account switcher bar)." = "Tumpuk akun token di menu (jika tidak, tampilkan bilah pengalih akun).";
+"Start at Login" = "Mulai saat Login";
+"Status" = "Status";
+"Store Claude sessionKey cookies or OAuth access tokens." = "Simpan cookie sessionKey Claude atau token akses OAuth.";
+"Store multiple Abacus AI Cookie headers." = "Simpan beberapa header Cookie Abacus AI.";
+"Store multiple Augment Cookie headers." = "Simpan beberapa header Cookie Augment.";
+"Store multiple Cursor Cookie headers." = "Simpan beberapa header Cookie Cursor.";
+"Store multiple Factory Cookie headers." = "Simpan beberapa header Cookie Factory.";
+"Store multiple MiniMax Cookie headers." = "Simpan beberapa header Cookie MiniMax.";
+"Store multiple Mistral Cookie headers." = "Simpan beberapa header Cookie Mistral.";
+"Store multiple Ollama Cookie headers." = "Simpan beberapa header Cookie Ollama.";
+"Store multiple OpenCode Cookie headers." = "Simpan beberapa header Cookie OpenCode.";
+"Store multiple OpenCode Go Cookie headers." = "Simpan beberapa header Cookie OpenCode Go.";
+"Stored in the CodexBar config file." = "Disimpan dalam file konfigurasi CodexBar.";
+"Stored in ~/.codexbar/config.json. " = "Disimpan di ~/.codexbar/config.json. ";
+"Stored in ~/.codexbar/config.json. Generate one at kimi-k2.ai." = "Disimpan di ~/.codexbar/config.json. Buat satu di kimi-k2.ai.";
+"Stored in ~/.codexbar/config.json. Paste the key from the Synthetic dashboard." = "Disimpan di ~/.codexbar/config.json. Tempel kunci dari dasbor Synthetic.";
+"Stored in ~/.codexbar/config.json. Paste your Coding Plan API key from Model Studio." = "Disimpan di ~/.codexbar/config.json. Tempel kunci API Coding Plan Anda dari Model Studio.";
+"Stored in ~/.codexbar/config.json. Paste your MiniMax API key." = "Disimpan di ~/.codexbar/config.json. Tempel kunci API MiniMax Anda.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or " = "Disimpan di ~/.codexbar/config.json. Anda juga dapat menyediakan KILO_API_KEY atau ";
+"Stores local Codex usage history (8 weeks) to personalize Pace predictions." = "Menyimpan riwayat penggunaan Codex lokal (8 minggu) untuk personalisasi prediksi Pace.";
+"Subscription Utilization" = "Pemanfaatan Langganan";
+"Surprise me" = "Kejutkan saya";
+"Switcher shows icons" = "Pengalih tampilkan ikon";
+"Symlink CodexBarCLI to /usr/local/bin and /opt/homebrew/bin as codexbar." = "Symlink CodexBarCLI ke /usr/local/bin dan /opt/homebrew/bin sebagai codexbar.";
+"System" = "Sistem";
+"Temporarily shows the loading animation after the next refresh." = "Sementara menampilkan animasi pemuatan setelah penyegaran berikutnya.";
+"terminal_app_subtitle" = "Terminal yang digunakan oleh tindakan Buka Terminal";
+"terminal_app_title" = "Terminal Bawaan";
+"Tertiary (\\(label))" = "Tersier (\\(label))";
+"Tertiary (\\(tertiaryTitle))" = "Tersier (\\(tertiaryTitle))";
+"The default Codex account on this Mac." = "Akun Codex bawaan di Mac ini.";
+"Toggle" = "Alihkan";
+"Toggle subtitle" = "Subjudul alihkan";
+"Token" = "Token";
+"Trigger the menu bar menu from anywhere." = "Picu menu bar dari mana saja.";
+"True" = "Benar";
+"Twitter" = "Twitter";
+"Unsupported" = "Tidak didukung";
+"Update Channel" = "Saluran Pembaruan";
+"Updated" = "Diperbarui";
+"Updates unavailable in this build." = "Pembaruan tidak tersedia di build ini.";
+"Usage" = "Penggunaan";
+"Usage breakdown" = "Rincian penggunaan";
+"Usage history (30 days)" = "Riwayat penggunaan";
+"Usage source" = "Sumber penggunaan";
+"Use BigModel for the China mainland endpoints (open.bigmodel.cn)." = "Gunakan BigModel untuk endpoint Tiongkok daratan (open.bigmodel.cn).";
+"Use a single menu bar icon with a provider switcher." = "Gunakan satu ikon menu bar dengan pengalih penyedia.";
+"Use international or China mainland console gateways for quota fetches." = "Gunakan gateway konsol internasional atau Tiongkok daratan untuk pengambilan kuota.";
+"Version" = "Versi";
+"Version \\(self.versionString)" = "Versi \\(self.versionString)";
+"Version \\(version)" = "Versi \\(version)";
+"Version \\(versionString)" = "Versi \\(versionString)";
+"Vertex AI Login" = "Login Vertex AI";
+"Wait for the current managed Codex login to finish before adding another account." = "Tunggu login Codex terkelola saat ini selesai sebelum menambahkan akun lain.";
+"Waiting for Authentication..." = "Menunggu Autentikasi...";
+"Website" = "Situs Web";
+"Weekly limit confetti" = "Confetti batas mingguan";
+"Weekly token limit" = "Batas token mingguan";
+"Weekly usage" = "Penggunaan mingguan";
+"Weekly usage unavailable for this account." = "Penggunaan mingguan tidak tersedia untuk akun ini.";
+"Window: \\(window)" = "Jendela: \\(window)";
+"Write logs to \\(self.fileLogPath) for debugging." = "Tulis log ke \\(self.fileLogPath) untuk debugging.";
+"Yes" = "Ya";
+"\\(detail.modelCode): \\(usage)" = "\\(detail.modelCode): \\(usage)";
+"\\(name): \\(truncated)" = "\\(name): \\(truncated)";
+"\\(name): \\(updated) · 30d \\(cost)" = "\\(name): \\(updated) · 30 hari \\(cost)";
+"\\(name): fetching…\\(elapsed)" = "\\(name): mengambil…\\(elapsed)";
+"\\(name): last attempt \\(when)" = "\\(name): percobaan terakhir \\(when)";
+"\\(name): no data yet" = "\\(name): belum ada data";
+"\\(name): unsupported" = "\\(name): tidak didukung";
+"all browsers" = "semua browser";
+"available again." = "tersedia kembali.";
+"built_format" = "Dibangun %@";
+"copilot_complete_in_browser" = "Selesaikan login di browser Anda.";
+"copilot_device_code" = "Kode perangkat disalin ke clipboard: %1$@\n\nVerifikasi di: %2$@";
+"copilot_device_code_copied" = "Kode perangkat disalin.";
+"copilot_verify_at" = "Verifikasi di %@";
+"copilot_waiting_text" = "Selesaikan login di browser Anda.\nJendela ini tertutup otomatis saat login selesai.";
+"copilot_window_closes_auto" = "Jendela ini tertutup otomatis saat login selesai.";
+"cost_status_error" = "%1$@: %2$@";
+"cost_status_fetching" = "%1$@: mengambil… %2$@";
+"cost_status_last_attempt" = "%1$@: percobaan terakhir %2$@";
+"cost_status_no_data" = "%@: belum ada data";
+"cost_status_snapshot" = "%1$@: %2$@ · %3$@ %4$@";
+"cost_status_unsupported" = "%@: tidak didukung";
+"credits_remaining" = "Kredit: %@";
+"cursor_on_demand" = "On-demand: %@";
+"cursor_on_demand_with_limit" = "On-demand: %1$@ / %2$@";
+"extra_usage_format" = "Penggunaan ekstra: %1$@ / %2$@";
+"jetbrains_detected_generate" = "Terdeteksi: %@. Gunakan asisten AI sekali untuk menghasilkan data kuota, lalu segarkan CodexBar.";
+"jetbrains_detected_select" = "Terdeteksi: %@. Pilih IDE pilihan Anda di Pengaturan, lalu segarkan CodexBar.";
+"last_fetch_failed_with_provider" = "Pengambilan %@ terakhir gagal:";
+"last_spend" = "Pengeluaran terakhir: %@";
+"mcp_model_usage" = "%1$@: %2$@";
+"mcp_resets" = "Reset: %@";
+"mcp_window" = "Jendela: %@";
+"metric_average" = "Rata-rata (%1$@ + %2$@)";
+"metric_primary" = "Utama (%@)";
+"metric_secondary" = "Sekunder (%@)";
+"metric_tertiary" = "Tersier (%@)";
+"multiple_workspaces_found" = "CodexBar menemukan beberapa workspace untuk %@. Silakan pilih workspace yang akan ditambahkan.";
+"ory_session_…=…; csrftoken=…" = "ory_session_…=…; csrftoken=…";
+"overview_choose_providers" = "Pilih hingga %@ penyedia";
+"remove_account_message" = "Hapus %@ dari CodexBar? Home Codex terkelolanya akan dihapus.";
+"version_format" = "Versi %@";
+"vertex_ai_login_instructions" = "Untuk melacak penggunaan Vertex AI, autentikasi dengan Google Cloud.\n\n1. Buka Terminal\n2. Jalankan: gcloud auth application-default login\n3. Ikuti petunjuk browser untuk masuk\n4. Atur proyek Anda: gcloud config set project PROJECT_ID\n\nBuka Terminal sekarang?";
+"workspaceID is set but only opencode, opencodego, and deepgram support workspaceID." = "workspaceID diatur tetapi hanya opencode, opencodego, dan deepgram yang mendukung workspaceID.";
+"© 2026 Peter Steinberger. MIT License." = "© 2026 Peter Steinberger. Lisensi MIT.";
+
+/* General Pane */
+"section_system" = "Sistem";
+"section_usage" = "Penggunaan";
+"section_automation" = "Otomatisasi";
+"language_title" = "Bahasa";
+"language_subtitle" = "Ubah bahasa tampilan. Memerlukan restart aplikasi agar berlaku penuh.";
+"language_system" = "Sistem";
+"language_english" = "English";
+"language_spanish" = "Español";
+"language_catalan" = "Català";
+"language_chinese_simplified" = "简体中文";
+"language_chinese_traditional" = "繁體中文";
+"language_portuguese_brazilian" = "Português (Brasil)";
+"language_dutch" = "Nederlands";
+"language_german" = "Deutsch";
+"language_swedish" = "Svenska";
+"language_french" = "Français";
+"language_ukrainian" = "Українська";
+"language_japanese" = "日本語";
+"language_korean" = "한국어";
+"language_turkish" = "Türkçe";
+"language_vietnamese" = "Tiếng Việt";
+"language_italian" = "Italiano";
+"language_indonesian" = "Bahasa Indonesia";
+"language_polish" = "Bahasa Polandia";
+"start_at_login_title" = "Mulai saat Login";
+"start_at_login_subtitle" = "Otomatis membuka CodexBar saat Anda menyalakan Mac.";
+"show_cost_summary" = "Tampilkan ringkasan biaya";
+"show_cost_summary_subtitle" = "Membaca log penggunaan lokal. Menampilkan hari ini + jendela riwayat yang dipilih di menu.";
+"cost_history_days_title" = "Jendela riwayat: %d hari";
+"cost_auto_refresh_info" = "Penyegaran otomatis: per jam · Batas waktu: 10m";
+"refresh_cadence_title" = "Frekuensi penyegaran";
+"refresh_cadence_subtitle" = "Seberapa sering CodexBar memeriksa penyedia di latar belakang.";
+"manual_refresh_hint" = "Penyegaran otomatis nonaktif; gunakan perintah Segarkan di menu.";
+"check_provider_status_title" = "Periksa status penyedia";
+"check_provider_status_subtitle" = "Memeriksa halaman status OpenAI/Claude dan Google Workspace untuk Gemini/Antigravity, menampilkan insiden di ikon dan menu.";
+"session_quota_notifications_title" = "Notifikasi kuota sesi";
+"session_quota_notifications_subtitle" = "Memberi tahu saat kuota sesi 5 jam mencapai 0% dan saat tersedia kembali.";
+"quota_warning_notifications_title" = "Notifikasi peringatan kuota";
+"quota_warning_notifications_subtitle" = "Memperingatkan saat sisa kuota sesi atau mingguan melewati ambang batas yang dikonfigurasi.";
+"quota_warnings_title" = "Peringatan kuota";
+"quota_warning_session" = "sesi";
+"quota_warning_session_capitalized" = "Sesi";
+"quota_warning_weekly" = "mingguan";
+"quota_warning_weekly_capitalized" = "Mingguan";
+"quota_warning_notification_title" = "%1$@ kuota %2$@ rendah";
+"quota_warning_notification_body" = "%1$@ tersisa. Mencapai ambang batas peringatan %3$@ %2$d%% Anda.";
+"quota_warning_notification_body_with_account" = "Akun %1$@. %2$@ tersisa. Mencapai ambang batas peringatan %4$@ %3$d%% Anda.";
+"session_depleted_notification_title" = "Sesi %@ habis";
+"session_depleted_notification_body" = "0% tersisa. Akan memberi tahu saat tersedia kembali.";
+"session_restored_notification_title" = "Sesi %@ pulih";
+"session_restored_notification_body" = "Kuota sesi tersedia kembali.";
+"quota_warning_warn_at" = "Peringatkan pada";
+"quota_warning_global_threshold_subtitle" = "Persentase sisa untuk jendela sesi dan mingguan kecuali penyedia menimpanya.";
+"quota_warning_sound" = "Mainkan suara notifikasi";
+"quota_warning_provider_inherits" = "Menggunakan pengaturan peringatan kuota global kecuali jendela dikustomisasi di sini.";
+"quota_warning_customize_thresholds" = "Kustomisasi ambang batas %@";
+"quota_warning_enable_warnings" = "Aktifkan peringatan %@";
+"quota_warning_window_warn_at" = "Peringatan %@ pada";
+"quota_warning_off" = "Mati";
+"quota_warning_inherited" = "Diwariskan: %@";
+"quota_warning_depleted_only" = "hanya habis";
+"quota_warning_upper" = "Atas";
+"quota_warning_lower" = "Bawah";
+"apply" = "Terapkan";
+"quit_app" = "Keluar CodexBar";
+
+/* Tab titles */
+"tab_general" = "Umum";
+"tab_providers" = "Penyedia";
+"tab_display" = "Tampilan";
+"tab_advanced" = "Lanjutan";
+"tab_about" = "Tentang";
+"tab_debug" = "Debug";
+
+/* Providers Pane */
+"select_a_provider" = "Pilih penyedia";
+"cancel" = "Batal";
+"last_fetch_failed" = "pengambilan terakhir gagal";
+"usage_not_fetched_yet" = "penggunaan belum diambil";
+"managed_account_storage_unreadable" = "Penyimpanan akun terkelola tidak dapat dibaca. Akses akun langsung masih tersedia, tetapi tindakan tambah, autentikasi ulang, dan hapus akun terkelola dinonaktifkan hingga penyimpanan dapat dipulihkan.";
+"remove_codex_account_title" = "Hapus akun Codex?";
+"remove" = "Hapus";
+"managed_login_already_running" = "Login Codex terkelola sudah berjalan. Tunggu hingga selesai sebelum menambahkan atau mengautentikasi ulang akun lain.";
+"managed_login_failed" = "Login Codex terkelola tidak selesai. Verifikasi bahwa `codex --version` berfungsi di Terminal. Jika macOS memblokir atau memindahkan `codex` ke Tempat Sampah, hapus instalasi duplikat yang kedaluwarsa, jalankan `npm install -g --include=optional @openai/codex@latest`, lalu coba lagi.";
+"codex_login_output" = "Output login codex:";
+"managed_login_missing_email" = "Login Codex selesai, tetapi email akun tidak tersedia. Coba lagi setelah mengonfirmasi akun sudah sepenuhnya masuk.";
+"login_success_notification_title" = "Login %@ berhasil";
+"login_success_notification_body" = "Anda dapat kembali ke aplikasi; autentikasi selesai.";
+"workspace_selection_cancelled" = "CodexBar menemukan beberapa workspace, tetapi tidak ada workspace yang dipilih.";
+"unsafe_managed_home" = "CodexBar menolak memodifikasi path home terkelola yang tidak terduga: %@";
+"menu_bar_metric_title" = "Metrik menu bar";
+"menu_bar_metric_subtitle" = "Pilih jendela mana yang menggerakkan persentase menu bar.";
+"menu_bar_metric_subtitle_deepseek" = "Menampilkan saldo DeepSeek di menu bar.";
+"menu_bar_metric_subtitle_moonshot" = "Menampilkan saldo API Moonshot / Kimi di menu bar.";
+"menu_bar_metric_subtitle_mistral" = "Menampilkan pengeluaran API Mistral bulan ini di menu bar.";
+"menu_bar_metric_subtitle_kimik2" = "Menampilkan kredit kunci API Kimi K2 di menu bar.";
+"automatic" = "Otomatis";
+"primary_api_key_limit" = "Utama (batas kunci API)";
+
+/* Display Pane */
+"section_menu_bar" = "Menu bar";
+"merge_icons_title" = "Gabung Ikon";
+"merge_icons_subtitle" = "Gunakan satu ikon menu bar dengan pengalih penyedia.";
+"switcher_shows_icons_title" = "Pengalih tampilkan ikon";
+"switcher_shows_icons_subtitle" = "Tampilkan ikon penyedia di pengalih (jika tidak, tampilkan garis progres mingguan).";
+"show_most_used_provider_title" = "Tampilkan penyedia paling sering digunakan";
+"show_most_used_provider_subtitle" = "Menu bar otomatis menampilkan penyedia yang paling dekat batas penggunaannya.";
+"menu_bar_shows_percent_title" = "Menu bar tampilkan persen";
+"menu_bar_shows_percent_subtitle" = "Ganti bilah critter dengan ikon merek penyedia dan persentase.";
+"hide_critters_title" = "Sembunyikan critter";
+"hide_critters_subtitle" = "Tampilkan bilah meter polos tanpa wajah dan dekorasi.";
+"display_mode_title" = "Mode tampilan";
+"display_mode_subtitle" = "Pilih apa yang ditampilkan di menu bar (Pace menampilkan penggunaan vs. perkiraan).";
+"section_menu_content" = "Konten menu";
+"show_usage_as_used_title" = "Tampilkan penggunaan sebagai terpakai";
+"show_usage_as_used_subtitle" = "Bilah progres terisi saat Anda menggunakan kuota (alih-alih menampilkan sisa).";
+"show_quota_warning_markers_title" = "Tampilkan penanda peringatan kuota";
+"show_quota_warning_markers_subtitle" = "Gambar tanda centang ambang batas pada bilah penggunaan saat peringatan kuota dikonfigurasi.";
+"weekly_progress_work_days_title" = "Hari kerja progres mingguan";
+"weekly_progress_work_days_subtitle" = "Atur hari kerja untuk penanda bilah penggunaan mingguan dan perhitungan pace.";
+"show_reset_time_as_clock_title" = "Tampilkan waktu reset sebagai jam";
+"show_reset_time_as_clock_subtitle" = "Tampilkan waktu reset sebagai nilai jam absolut alih-alih hitung mundur.";
+"show_provider_changelog_links_title" = "Tampilkan tautan changelog penyedia";
+"show_provider_changelog_links_subtitle" = "Menambahkan tautan catatan rilis untuk penyedia berbasis CLI yang didukung ke menu.";
+"show_credits_extra_usage_title" = "Tampilkan kredit + penggunaan ekstra";
+"show_credits_extra_usage_subtitle" = "Tampilkan bagian Kredit Codex dan penggunaan Ekstra Claude di menu.";
+"show_all_token_accounts_title" = "Tampilkan semua akun token";
+"show_all_token_accounts_subtitle" = "Tumpuk akun token di menu (jika tidak, tampilkan bilah pengalih akun).";
+"multi_account_layout_title" = "Tata letak multi-akun";
+"multi_account_layout_subtitle" = "Pilih pengalihan akun tersegmentasi atau kartu akun bertumpuk.";
+"multi_account_layout_segmented" = "Tersegmentasi";
+"multi_account_layout_stacked" = "Bertumpuk";
+"overview_tab_providers_title" = "Penyedia tab ikhtisar";
+"configure" = "Konfigurasi…";
+"overview_enable_merge_icons_hint" = "Aktifkan Gabung Ikon untuk mengonfigurasi penyedia tab Ikhtisar.";
+"overview_no_providers_hint" = "Tidak ada penyedia aktif untuk Ikhtisar.";
+"overview_rows_follow_order" = "Baris ikhtisar selalu mengikuti urutan penyedia.";
+"overview_no_providers_selected" = "Tidak ada penyedia dipilih";
+
+/* Advanced Pane */
+"section_keyboard_shortcut" = "Pintasan keyboard";
+"open_menu_shortcut_title" = "Buka menu";
+"open_menu_shortcut_subtitle" = "Picu menu bar dari mana saja.";
+"install_cli" = "Pasang CLI";
+"install_cli_subtitle" = "Symlink CodexBarCLI ke /usr/local/bin dan /opt/homebrew/bin sebagai codexbar.";
+"cli_not_found" = "CodexBarCLI tidak ditemukan di bundel aplikasi.";
+"no_writable_bin_dirs" = "Tidak ada direktori bin yang dapat ditulis.";
+"show_debug_settings_title" = "Tampilkan Pengaturan Debug";
+"show_debug_settings_subtitle" = "Tampilkan alat pemecahan masalah di tab Debug.";
+"surprise_me_title" = "Kejutkan saya";
+"surprise_me_subtitle" = "Centang jika Anda suka agen bersenang-senang di atas sana.";
+"weekly_limit_confetti_title" = "Confetti batas mingguan";
+"weekly_limit_confetti_subtitle" = "Mainkan confetti layar penuh saat penggunaan mingguan direset.";
+"hide_personal_info_title" = "Sembunyikan informasi pribadi";
+"hide_personal_info_subtitle" = "Samarkan alamat email di menu bar dan antarmuka menu.";
+"show_provider_storage_usage_title" = "Tampilkan penggunaan penyimpanan penyedia";
+"show_provider_storage_usage_subtitle" = "Tampilkan penggunaan disk lokal di menu. Memindai path milik penyedia di latar belakang.";
+"section_keychain_access" = "Akses Keychain";
+"keychain_access_caption" = "Nonaktifkan semua pembacaan dan penulisan Keychain. Gunakan ini jika macOS terus meminta 'Chrome/Brave/Edge Safe Storage' meskipun sudah mengklik Always Allow. Impor cookie browser tidak tersedia saat diaktifkan; tempel header Cookie secara manual di Penyedia. OAuth Claude/Codex via CLI masih berfungsi.";
+"disable_keychain_access_title" = "Nonaktifkan akses Keychain";
+"disable_keychain_access_subtitle" = "Mencegah semua akses Keychain saat diaktifkan.";
+
+/* About Pane */
+"about_tagline" = "Semoga token Anda tidak pernah habis—pantau batas agen Anda.";
+"link_github" = "GitHub";
+"link_website" = "Situs Web";
+"link_twitter" = "Twitter";
+"link_email" = "Email";
+"check_updates_auto" = "Periksa pembaruan secara otomatis";
+"update_channel" = "Saluran Pembaruan";
+"check_for_updates" = "Periksa Pembaruan…";
+"updates_unavailable" = "Pembaruan tidak tersedia di build ini.";
+"copyright" = "© 2026 Peter Steinberger. Lisensi MIT.";
+
+/* Debug Pane */
+"section_logging" = "Pencatatan";
+"enable_file_logging" = "Aktifkan pencatatan file";
+"enable_file_logging_subtitle" = "Tulis log ke %@ untuk debugging.";
+"verbosity_title" = "Verbositas";
+"verbosity_subtitle" = "Mengontrol seberapa banyak detail yang dicatat.";
+"open_log_file" = "Buka file log";
+"force_animation_next_refresh" = "Paksa animasi pada penyegaran berikutnya";
+"force_animation_next_refresh_subtitle" = "Sementara menampilkan animasi pemuatan setelah penyegaran berikutnya.";
+"section_loading_animations" = "Animasi pemuatan";
+"loading_animations_caption" = "Pilih pola dan putar ulang di menu bar. \"Acak\" mempertahankan perilaku yang ada.";
+"animation_random_default" = "Acak (bawaan)";
+"replay_selected_animation" = "Putar ulang animasi terpilih";
+"blink_now" = "Kedipkan sekarang";
+"section_probe_logs" = "Log probe";
+"probe_logs_caption" = "Ambil output probe terbaru untuk debugging; Salin menyimpan teks lengkap.";
+"fetch_log" = "Ambil log";
+"copy" = "Salin";
+"save_to_file" = "Simpan ke file";
+"load_parse_dump" = "Muat parse dump";
+"rerun_provider_autodetect" = "Jalankan ulang deteksi otomatis penyedia";
+"loading" = "Memuat…";
+"no_log_yet_fetch" = "Belum ada log. Ambil untuk memuat.";
+"section_fetch_strategy" = "Percobaan strategi pengambilan";
+"fetch_strategy_caption" = "Keputusan dan error pipeline pengambilan terakhir untuk penyedia.";
+"section_openai_cookies" = "Cookie OpenAI";
+"openai_cookies_caption" = "Log impor cookie + scrape WebKit dari percobaan cookie OpenAI terakhir.";
+"no_log_yet" = "Belum ada log. Perbarui cookie OpenAI di Penyedia → Codex untuk menjalankan impor.";
+"section_caches" = "Cache";
+"caches_caption" = "Hapus hasil pemindaian biaya yang di-cache atau cache cookie browser.";
+"clear_cookie_cache" = "Hapus cache cookie";
+"clear_cost_cache" = "Hapus cache biaya";
+"section_notifications" = "Notifikasi";
+"notifications_caption" = "Picu notifikasi uji untuk jendela sesi 5 jam (habis/pulih).";
+"post_depleted" = "Kirim habis";
+"post_restored" = "Kirim pulih";
+"section_cli_sessions" = "Sesi CLI";
+"cli_sessions_caption" = "Pertahankan sesi CLI Codex/Claude setelah probe. Bawaan keluar setelah data diambil.";
+"keep_cli_sessions_alive" = "Pertahankan sesi CLI";
+"keep_cli_sessions_alive_subtitle" = "Lewati pembersihan antar probe (hanya debug).";
+"reset_cli_sessions" = "Reset sesi CLI";
+"section_error_simulation" = "Simulasi error";
+"error_simulation_caption" = "Suntikkan pesan error palsu ke kartu menu untuk pengujian tata letak.";
+"set_menu_error" = "Atur error menu";
+"clear_menu_error" = "Hapus error menu";
+"set_cost_error" = "Atur error biaya";
+"clear_cost_error" = "Hapus error biaya";
+"section_cli_paths" = "Path CLI";
+"cli_paths_caption" = "Biner Codex yang terselesaikan dan lapisan PATH; tangkapan PATH shell login startup (batas waktu singkat).";
+"codex_binary" = "Biner Codex";
+"claude_binary" = "Biner Claude";
+"effective_path" = "PATH Efektif";
+"unavailable" = "Tidak tersedia";
+"login_shell_path" = "PATH shell login (tangkapan startup)";
+"cleared" = "Dihapus.";
+"no_fetch_attempts" = "Belum ada percobaan pengambilan.";
+"macOS Tahoe can block menu bar apps in System Settings → Menu Bar → Allow in the Menu Bar. CodexBar is running, but macOS may be hiding its icon. Open Menu Bar settings and turn CodexBar on." = "macOS Tahoe dapat memblokir aplikasi menu bar di Pengaturan Sistem → Menu Bar → Izinkan di Menu Bar. CodexBar berjalan, tetapi macOS mungkin menyembunyikan ikonnya. Buka pengaturan Menu Bar dan aktifkan CodexBar.";
+
+/* Metric preferences */
+"metric_pref_automatic" = "Otomatis";
+"metric_pref_primary" = "Utama";
+"metric_pref_secondary" = "Sekunder";
+"metric_pref_tertiary" = "Tersier";
+"metric_pref_extra_usage" = "Penggunaan ekstra";
+"metric_pref_average" = "Rata-rata";
+"metric_mistral_payg" = "Pay-as-you-go";
+"metric_mistral_monthly_plan" = "Monthly Plan";
+
+/* Display modes */
+"display_mode_percent" = "Persen";
+"display_mode_pace" = "Pace";
+"display_mode_both" = "Keduanya";
+"display_mode_reset_time" = "Waktu reset";
+"display_mode_percent_desc" = "Tampilkan persentase sisa/terpakai (mis. 45%)";
+"display_mode_pace_desc" = "Tampilkan indikator pace (mis. +5%)";
+"display_mode_both_desc" = "Tampilkan persentase dan pace (mis. 45% · +5%)";
+"display_mode_reset_time_desc" = "Tampilkan waktu reset untuk metrik yang dipilih (mis. ↻ 3:56 PM)";
+
+/* Provider status */
+"status_operational" = "Operasional";
+"status_partial_outage" = "Gangguan sebagian";
+"status_major_outage" = "Gangguan besar";
+"status_critical_issue" = "Masalah kritis";
+"status_maintenance" = "Pemeliharaan";
+"status_unknown" = "Status tidak diketahui";
+
+/* Refresh frequency */
+"refresh_manual" = "Manual";
+"refresh_1min" = "1 mnt";
+"refresh_2min" = "2 mnt";
+"refresh_5min" = "5 mnt";
+"refresh_15min" = "15 mnt";
+"refresh_30min" = "30 mnt";
+
+/* Additional keys */
+"not_found" = "Tidak ditemukan";
+
+/* Cost estimation */
+"cost_header_estimated" = "Biaya (perkiraan)";
+"cost_estimate_hint" = "Diperkirakan dari log lokal · mungkin berbeda dari tagihan Anda";
+"No JetBrains IDE with AI Assistant detected. Install a JetBrains IDE and enable AI Assistant." = "Tidak ada JetBrains IDE dengan AI Assistant terdeteksi. Pasang JetBrains IDE dan aktifkan AI Assistant.";
+"OpenRouter API token not configured. Set OPENROUTER_API_KEY environment variable or configure in Settings." = "Token API OpenRouter belum dikonfigurasi. Atur variabel lingkungan OPENROUTER_API_KEY atau konfigurasi di Pengaturan.";
+"z.ai API token not found. Set apiKey in ~/.codexbar/config.json or Z_AI_API_KEY." = "Token API z.ai tidak ditemukan. Atur apiKey di ~/.codexbar/config.json atau Z_AI_API_KEY.";
+"Missing DeepSeek API key." = "Kunci API DeepSeek tidak ada.";
+"%@ is unavailable in the current environment." = "%@ tidak tersedia di lingkungan saat ini.";
+"All Systems Operational" = "Semua Sistem Operasional";
+"Last 30 days" = "30 hari terakhir";
+"Last 30 days:" = "30 hari terakhir:";
+"This month" = "Bulan ini";
+"Store multiple OpenAI API keys." = "Simpan beberapa kunci API OpenAI.";
+"Admin API key" = "Kunci API Admin";
+"Open billing" = "Buka tagihan";
+"Google accounts" = "Akun Google";
+"Store multiple Antigravity Google OAuth accounts for quick switching." = "Simpan beberapa akun Google OAuth Antigravity untuk beralih cepat.";
+"Add Google Account" = "Tambah Akun Google";
+"Open Token Plan" = "Buka Token Plan";
+"Text Generation" = "Pembuatan Teks";
+"Text to Speech" = "Teks ke Suara";
+"Music Generation" = "Pembuatan Musik";
+"Image Generation" = "Pembuatan Gambar";
+"No local data found" = "Tidak ada data lokal ditemukan";
+"Credits unavailable; keep Codex running to refresh." = "Kredit tidak tersedia; biarkan Codex berjalan untuk menyegarkan.";
+"No available fetch strategy for minimax." = "Tidak ada strategi pengambilan tersedia untuk minimax.";
+"No Cursor session found. Please log in to cursor.com in Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX, or Edge Canary. If you use Safari, grant CodexBar Full Disk Access in System Settings ▸ Privacy & Security. You can also sign in to Cursor from the CodexBar menu (Add / switch account)." = "Sesi Cursor tidak ditemukan. Silakan masuk ke cursor.com di Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX, atau Edge Canary. Jika Anda menggunakan Safari, berikan CodexBar Akses Disk Penuh di Pengaturan Sistem ▸ Privasi & Keamanan. Anda juga dapat masuk ke Cursor dari menu CodexBar (Tambah / beralih akun).";
+"No OpenCode session cookies found in browsers." = "Cookie sesi OpenCode tidak ditemukan di browser.";
+"No available fetch strategy for %@." = "Tidak ada strategi pengambilan tersedia untuk %@.";
+"Today" = "Hari ini";
+"Today tokens" = "Token hari ini";
+"30d cost" = "Biaya 30 hari";
+"30d tokens" = "Token 30 hari";
+"Latest tokens" = "Token terbaru";
+"Top model" = "Model teratas";
+"Storage" = "Penyimpanan";
+"Add Account..." = "Tambah Akun...";
+"Usage Dashboard" = "Dasbor Penggunaan";
+"Status Page" = "Halaman Status";
+"Settings..." = "Pengaturan...";
+"About CodexBar" = "Tentang CodexBar";
+"Quit" = "Keluar";
+"Last %d day" = "%d hari terakhir";
+"Last %d days" = "%d hari terakhir";
+"%@ tokens" = "%@ token";
+"Latest billing day" = "Hari tagihan terbaru";
+"Latest billing day (%@)" = "Hari tagihan terbaru (%@)";
+"%@ left" = "%@ tersisa";
+"Resets %@" = "Reset %@";
+"Resets in %@" = "Reset dalam %@";
+"Resets now" = "Reset sekarang";
+"reset_tomorrow_format" = "besok, %@";
+"Lasts until reset" = "Bertahan hingga reset";
+"Updated %@" = "Diperbarui %@";
+"Updated %@h ago" = "Diperbarui %@ jam lalu";
+"Updated %@m ago" = "Diperbarui %@ menit lalu";
+"Updated just now" = "Baru saja diperbarui";
+"Projected empty in %@" = "Diproyeksikan habis dalam %@";
+"Runs out in %@" = "Habis dalam %@";
+"Pace: %@" = "Pace: %@";
+"Pace: %@ · %@" = "Pace: %@ · %@";
+"%@ · %@" = "%@ · %@";
+"≈ %d%% run-out risk" = "≈ %d%% risiko habis";
+"%d%% in deficit" = "%d%% defisit";
+"%d%% in reserve" = "%d%% cadangan";
+"usage_percent_suffix_left" = "tersisa";
+"usage_percent_suffix_used" = "terpakai";
+"Store multiple DeepSeek API keys." = "Simpan beberapa kunci API DeepSeek.";
+"This week" = "Minggu ini";
+"Week" = "Minggu";
+"Month" = "Bulan";
+"Models" = "Model";
+"24h tokens" = "Token 24j";
+"Latest hour" = "Jam terbaru";
+"Peak hour" = "Jam puncak";
+"Top method" = "Metode teratas";
+"30d cash" = "Kas 30 hari";
+"30d billing history from MiniMax web session" = "Riwayat tagihan 30 hari dari sesi web MiniMax";
+"AWS Cost Explorer billing can lag." = "Tagihan AWS Cost Explorer dapat tertunda.";
+"Rate limit: %d / %@" = "Batas rate: %d / %@";
+"Key remaining" = "Sisa kunci";
+"No limit set for the API key" = "Tidak ada batas yang ditetapkan untuk kunci API";
+"API key limit unavailable right now" = "Batas kunci API tidak tersedia saat ini";
+"This month: %@ tokens" = "Bulan ini: %@ token";
+"No utilization data yet." = "Belum ada data pemanfaatan.";
+"No %@ utilization data yet." = "Belum ada data pemanfaatan %@.";
+"%@: %@%% used" = "%@: %@%% terpakai";
+"%dd" = "%d hari";
+"today" = "hari ini";
+"just now" = "baru saja";
+"On pace" = "Sesuai pace";
+"Runs out now" = "Habis sekarang";
+"Projected empty now" = "Diproyeksikan habis sekarang";
+"Switch Account..." = "Beralih Akun...";
+"Update ready, restart now?" = "Pembaruan siap, mulai ulang sekarang?";
+"Daily" = "Harian";
+"Hourly Tokens" = "Token Per Jam";
+"No data" = "Tidak ada data";
+"No usage breakdown data available." = "Tidak ada data rincian penggunaan tersedia.";
+
+"Today: %@ · %@ tokens" = "Hari ini: %@ · %@ token";
+"Today: %@" = "Hari ini: %@";
+"Today: %@ tokens" = "Hari ini: %@ token";
+"Last 30 days: %@ · %@ tokens" = "30 hari terakhir: %@ · %@ token";
+"Last 30 days: %@" = "30 hari terakhir: %@";
+"Est. total (30d): %@" = "Perkiraan total (30 hari): %@";
+"Est. total (%@): %@" = "Perkiraan total (%@): %@";
+"Hover a bar for details" = "Arahkan kursor ke bilah untuk detail";
+"%@: %@ · %@ tokens" = "%@: %@ · %@ token";
+"No providers selected for Overview." = "Tidak ada penyedia dipilih untuk Ikhtisar.";
+"No overview data available." = "Tidak ada data ikhtisar tersedia.";
+"Auto uses the local IDE API first, then Google OAuth when the IDE is closed." = "Otomatis menggunakan API IDE lokal terlebih dahulu, lalu Google OAuth saat IDE ditutup.";
+"Login with Google" = "Masuk dengan Google";
+
+/* Popup panels */
+"No usage configured." = "Tidak ada penggunaan dikonfigurasi.";
+"Quota" = "Kuota";
+"tokens" = "token";
+"requests" = "permintaan";
+"Latest" = "Terbaru";
+"Monthly" = "Bulanan";
+"Sonnet" = "Sonnet";
+"Overages" = "Kelebihan";
+"Activity" = "Aktivitas";
+"Copied" = "Disalin";
+"Copy error" = "Salin error";
+"Copy path" = "Salin path";
+"Extra usage spent" = "Penggunaan ekstra dibelanjakan";
+"Credits remaining" = "Kredit tersisa";
+"Using CLI fallback" = "Menggunakan fallback CLI";
+"Balance updates in near-real time (up to 5 min lag)" = "Saldo diperbarui hampir real-time (hingga 5 menit keterlambatan)";
+"Daily billing data finalizes at 07:00 UTC" = "Data tagihan harian final pada 07:00 UTC";
+"%@ of %@ credits left" = "%@ dari %@ kredit tersisa";
+"%@ of %@ bonus credits left" = "%@ dari %@ kredit bonus tersisa";
+"%@ / %@ (%@ remaining)" = "%@ / %@ (%@ tersisa)";
+"%@/%@ left" = "%@/%@ tersisa";
+"Gemini Flash" = "Gemini Flash";
+"Regenerates %@" = "Regenerasi %@";
+"used after next regen" = "terpakai setelah regenerasi berikutnya";
+"after next regen" = "setelah regenerasi berikutnya";
+"Near full" = "Hampir penuh";
+"Full in ~1 regen" = "Penuh dalam ~1 regenerasi";
+"Full in ~%.0f regens" = "Penuh dalam ~%.0f regenerasi";
+"Overage usage" = "Penggunaan kelebihan";
+"Overage cost" = "Biaya kelebihan";
+"credits" = "kredit";
+"Zen balance" = "Saldo Zen";
+"API spend" = "Pengeluaran API";
+"Extra usage" = "Penggunaan ekstra";
+"Quota usage" = "Penggunaan kuota";
+"Your spend" = "Pengeluaran Anda";
+"%.0f%% used" = "%.0f%% terpakai";
+"Usage history (today)" = "Riwayat penggunaan (hari ini)";
+"Usage history (%d days)" = "Riwayat penggunaan (%d hari)";
+"%d percent remaining" = "%d persen tersisa";
+"Unknown" = "Tidak diketahui";
+"stale data" = "data kedaluwarsa";
+"No credits history data." = "Tidak ada data riwayat kredit.";
+"No credits history data available." = "Tidak ada data riwayat kredit tersedia.";
+"Credits history chart" = "Grafik riwayat kredit";
+"%d days of credits data" = "%d hari data kredit";
+"Usage breakdown chart" = "Grafik rincian penggunaan";
+"%d days of usage data across %d services" = "%d hari data penggunaan di %d layanan";
+"Cost history chart" = "Grafik riwayat biaya";
+"%d days of cost data" = "%d hari data biaya";
+"Plan utilization chart" = "Grafik pemanfaatan paket";
+"%d utilization samples" = "%d sampel pemanfaatan";
+"Hourly Usage" = "Penggunaan Per Jam";
+"Usage remaining" = "Penggunaan tersisa";
+"Usage used" = "Penggunaan terpakai";
+"API key verified. Ollama does not expose Cloud quota limits through the API." = "Kunci API terverifikasi. Ollama tidak menampilkan batas kuota Cloud melalui API.";
+"Last 30 days: %@ tokens" = "30 hari terakhir: %@ token";
+"7d spend" = "Pengeluaran 7 hari";
+"30d spend" = "Pengeluaran 30 hari";
+"Cache read" = "Baca cache";
+"Claude Admin API 30 day spend trend" = "Tren pengeluaran 30 hari API Admin Claude";
+"OpenRouter API key spend trend" = "Tren pengeluaran kunci API OpenRouter";
+"z.ai hourly token trend" = "Tren token per jam z.ai";
+"MiniMax 30 day token usage trend" = "Tren penggunaan token 30 hari MiniMax";
+"Today cash" = "Kas hari ini";
+"DeepSeek 30 day token usage trend" = "Tren penggunaan token 30 hari DeepSeek";
+"cache-hit input" = "input cache-hit";
+"cache-miss input" = "input cache-miss";
+"output" = "output";
+"Requests" = "Permintaan";
+"Reported by OpenAI Admin API organization usage." = "Dilaporkan oleh penggunaan organisasi API Admin OpenAI.";
+"Reported by Mistral billing usage." = "Dilaporkan oleh penggunaan tagihan Mistral.";
+"Google OAuth" = "Google OAuth";
+"Add accounts via GitHub OAuth Device Flow on the selected host." = "Tambah akun via GitHub OAuth Device Flow pada host yang dipilih.";
+"Stores each signed-in Google account for quick Antigravity switching. Uses Antigravity.app OAuth when available, or ANTIGRAVITY_OAUTH_CLIENT_ID and ANTIGRAVITY_OAUTH_CLIENT_SECRET as an override." = "Menyimpan setiap akun Google yang masuk untuk beralih Antigravity cepat. Menggunakan OAuth Antigravity.app jika tersedia, atau ANTIGRAVITY_OAUTH_CLIENT_ID dan ANTIGRAVITY_OAUTH_CLIENT_SECRET sebagai pengganti.";
+"Manual cleanup: past sessions" = "Pembersihan manual: sesi sebelumnya";
+"Clearing removes past resume, continue, and rewind history." = "Menghapus riwayat lanjutkan, teruskan, dan mundur sebelumnya.";
+"Manual cleanup: file checkpoints" = "Pembersihan manual: checkpoint file";
+"Clearing removes checkpoint restore data for previous edits." = "Menghapus data pemulihan checkpoint untuk pengeditan sebelumnya.";
+"Manual cleanup: saved plans" = "Pembersihan manual: rencana tersimpan";
+"Clearing removes old plan-mode files." = "Menghapus file mode rencana lama.";
+"Manual cleanup: debug logs" = "Pembersihan manual: log debug";
+"Clearing removes past debug logs." = "Menghapus log debug sebelumnya.";
+"Manual cleanup: attachment cache" = "Pembersihan manual: cache lampiran";
+"Clearing removes cached large pastes or attached images." = "Menghapus tempel besar atau gambar terlampir yang di-cache.";
+"Manual cleanup: session metadata" = "Pembersihan manual: metadata sesi";
+"Clearing removes per-session environment metadata." = "Menghapus metadata lingkungan per-sesi.";
+"Manual cleanup: shell snapshots" = "Pembersihan manual: snapshot shell";
+"Clearing removes leftover runtime shell snapshot files." = "Menghapus file snapshot shell runtime yang tersisa.";
+"Manual cleanup: legacy todos" = "Pembersihan manual: todo lama";
+"Clearing removes legacy per-session task lists." = "Menghapus daftar tugas per-sesi lama.";
+"Manual cleanup: sessions" = "Pembersihan manual: sesi";
+"Clearing removes past Codex session history." = "Menghapus riwayat sesi Codex sebelumnya.";
+"Manual cleanup: archived sessions" = "Pembersihan manual: sesi terarsip";
+"Clearing removes archived Codex session history." = "Menghapus riwayat sesi Codex terarsip.";
+"Manual cleanup: cache" = "Pembersihan manual: cache";
+"Clearing removes provider-owned cached data." = "Menghapus data cache milik penyedia.";
+"Manual cleanup: logs" = "Pembersihan manual: log";
+"Clearing removes local diagnostic logs." = "Menghapus log diagnostik lokal.";
+"Manual cleanup: file history" = "Pembersihan manual: riwayat file";
+"Clearing removes local edit checkpoint history." = "Menghapus riwayat checkpoint edit lokal.";
+"Manual cleanup: temporary data" = "Pembersihan manual: data sementara";
+"Clearing removes local temporary provider data." = "Menghapus data sementara penyedia lokal.";
+"Total: %@" = "Total: %@";
+"%d more items" = "%d item lagi";
+"Other (%d items)" = "Lainnya (%d item)";
+"Expand" = "Perluas";
+"Collapse" = "Ciutkan";
+"Cleanup ideas" = "Ide pembersihan";
+"%d unreadable item(s) skipped" = "%d item tidak terbaca dilewati";
+
+"API key limit" = "Batas kunci API";
+"Auth" = "Auth";
+"Auto" = "Otomatis";
+"Disabled — no recent data" = "Nonaktif — tidak ada data terbaru";
+"Limits not available" = "Batas tidak tersedia";
+"No usage yet" = "Belum ada penggunaan";
+"Not fetched yet" = "Belum diambil";
+"Refreshing" = "Menyegarkan";
+"Session" = "Sesi";
+"Source" = "Sumber";
+"State" = "Status";
+"Unavailable" = "Tidak tersedia";
+"Weekly" = "Mingguan";
+"not detected" = "tidak terdeteksi";
+"Estimated from local Codex logs for the selected account." = "Diperkirakan dari log Codex lokal untuk akun yang dipilih.";
+"minimax_usage_amount_format" = "Penggunaan: %@ / %@";
+"minimax_used_percent_format" = "Terpakai %@";
+"minimax_service_text_generation" = "Pembuatan Teks";
+"minimax_service_text_to_speech" = "Teks ke Suara";
+"minimax_service_music_generation" = "Pembuatan Musik";
+"minimax_service_image_generation" = "Pembuatan Gambar";
+"minimax_service_lyrics_generation" = "Pembuatan Lirik";
+"minimax_service_coding_plan_vlm" = "VLM Coding Plan";
+"minimax_service_coding_plan_search" = "Pencarian Coding Plan";
+
+/* Additional provider settings and alerts */
+"%@ is waiting for permission" = "%@ menunggu izin";
+"%@ requests" = "%@ permintaan";
+"%@: %@ credits" = "%@: %@ kredit";
+"30d requests" = "Permintaan 30 hari";
+"4 days" = "4 hari";
+"5 days" = "5 hari";
+"7 days" = "7 hari";
+"API key verifies Ollama Cloud access; cookies still expose quota limits." = "Kunci API memverifikasi akses Ollama Cloud; cookie masih menampilkan batas kuota.";
+"AWS access key ID. Can also be set with AWS_ACCESS_KEY_ID." = "AWS access key ID. Dapat juga diatur dengan AWS_ACCESS_KEY_ID.";
+"AWS region. Can also be set with AWS_REGION." = "Wilayah AWS. Dapat juga diatur dengan AWS_REGION.";
+"AWS secret access key. Can also be set with AWS_SECRET_ACCESS_KEY." = "AWS secret access key. Dapat juga diatur dengan AWS_SECRET_ACCESS_KEY.";
+"Access key ID" = "Access key ID";
+"Add Account" = "Tambah Akun";
+"Adding Account…" = "Menambahkan Akun…";
+"Antigravity login failed" = "Login Antigravity gagal";
+"Antigravity login timed out" = "Login Antigravity kehabisan waktu";
+"Auth source" = "Sumber auth";
+"Automatic imports browser cookies from Xiaomi MiMo." = "Otomatis mengimpor cookie browser dari Xiaomi MiMo.";
+"Automatic imports Windsurf session data from Chromium browser localStorage." = "Otomatis mengimpor data sesi Windsurf dari localStorage browser Chromium.";
+"Automatic imports browser cookies from Bailian." = "Otomatis mengimpor cookie browser dari Bailian.";
+"Automatically imports browser cookies." = "Otomatis mengimpor cookie browser.";
+"Automatically imports browser session cookies." = "Otomatis mengimpor cookie sesi browser.";
+"Azure OpenAI deployment name. AZURE_OPENAI_DEPLOYMENT_NAME is also supported." = "Nama deployment Azure OpenAI. AZURE_OPENAI_DEPLOYMENT_NAME juga didukung.";
+"Azure OpenAI key" = "Kunci Azure OpenAI";
+"Azure OpenAI resource endpoint. AZURE_OPENAI_ENDPOINT is also supported." = "Endpoint resource Azure OpenAI. AZURE_OPENAI_ENDPOINT juga didukung.";
+"Base URL" = "URL Dasar";
+"Base URL for the LLM-API-Key-Proxy instance." = "URL dasar untuk instance LLM-API-Key-Proxy.";
+"Browser cookies" = "Cookie browser";
+"Cap end" = "Akhir batas";
+"Cap start" = "Awal batas";
+"Capacity End" = "Akhir Kapasitas";
+"Capacity Start" = "Awal Kapasitas";
+"Changelog" = "Log perubahan";
+"Choose the Moonshot/Kimi API host for international or China mainland accounts." = "Pilih host API Moonshot/Kimi untuk akun internasional atau Tiongkok daratan.";
+"CodexBar can't replace a system account that is signed in with an API key only setup." = "CodexBar tidak dapat mengganti akun sistem yang masuk dengan pengaturan hanya kunci API.";
+"CodexBar could not find saved auth for that account. Re-authenticate it and try again." = "CodexBar tidak dapat menemukan auth tersimpan untuk akun tersebut. Autentikasi ulang dan coba lagi.";
+"CodexBar could not read managed account storage. Recover the store before adding another account." = "CodexBar tidak dapat membaca penyimpanan akun terkelola. Pulihkan penyimpanan sebelum menambahkan akun lain.";
+"CodexBar could not read saved auth for that account. Re-authenticate it and try again." = "CodexBar tidak dapat membaca auth tersimpan untuk akun tersebut. Autentikasi ulang dan coba lagi.";
+"CodexBar could not read the current system account on this Mac." = "CodexBar tidak dapat membaca akun sistem saat ini di Mac ini.";
+"CodexBar could not replace the live Codex auth on this Mac." = "CodexBar tidak dapat mengganti auth Codex aktif di Mac ini.";
+"CodexBar could not safely preserve the current system account before switching." = "CodexBar tidak dapat menyimpan akun sistem saat ini dengan aman sebelum beralih.";
+"CodexBar could not save the current system account before switching." = "CodexBar tidak dapat menyimpan akun sistem saat ini sebelum beralih.";
+"CodexBar could not update managed account storage." = "CodexBar tidak dapat memperbarui penyimpanan akun terkelola.";
+"CodexBar found another managed account that already uses the current system account. Resolve the duplicate account before switching." = "CodexBar menemukan akun terkelola lain yang sudah menggunakan akun sistem saat ini. Selesaikan akun duplikat sebelum beralih.";
+"CodexBar will ask macOS Keychain for \U201c%@\U201d so it can decrypt browser cookies and authenticate your account. Click OK to continue." = "CodexBar akan meminta Keychain macOS untuk \U201c%@\U201d agar dapat mendekripsi cookie browser dan mengautentikasi akun Anda. Klik OK untuk melanjutkan.";
+"CodexBar will ask macOS Keychain for the Claude Code OAuth token so it can fetch your Claude usage. Click OK to continue." = "CodexBar akan meminta Keychain macOS untuk token OAuth Claude Code agar dapat mengambil penggunaan Claude Anda. Klik OK untuk melanjutkan.";
+"CodexBar will ask macOS Keychain for your Amp cookie header so it can fetch usage. Click OK to continue." = "CodexBar akan meminta Keychain macOS untuk header cookie Amp Anda agar dapat mengambil penggunaan. Klik OK untuk melanjutkan.";
+"CodexBar will ask macOS Keychain for your Augment cookie header so it can fetch usage. Click OK to continue." = "CodexBar akan meminta Keychain macOS untuk header cookie Augment Anda agar dapat mengambil penggunaan. Klik OK untuk melanjutkan.";
+"CodexBar will ask macOS Keychain for your Claude cookie header so it can fetch Claude web usage. Click OK to continue." = "CodexBar akan meminta Keychain macOS untuk header cookie Claude Anda agar dapat mengambil penggunaan web Claude. Klik OK untuk melanjutkan.";
+"CodexBar will ask macOS Keychain for your Cursor cookie header so it can fetch usage. Click OK to continue." = "CodexBar akan meminta Keychain macOS untuk header cookie Cursor Anda agar dapat mengambil penggunaan. Klik OK untuk melanjutkan.";
+"CodexBar will ask macOS Keychain for your Factory cookie header so it can fetch usage. Click OK to continue." = "CodexBar akan meminta Keychain macOS untuk header cookie Factory Anda agar dapat mengambil penggunaan. Klik OK untuk melanjutkan.";
+"CodexBar will ask macOS Keychain for your GitHub Copilot token so it can fetch usage. Click OK to continue." = "CodexBar akan meminta Keychain macOS untuk token GitHub Copilot Anda agar dapat mengambil penggunaan. Klik OK untuk melanjutkan.";
+"CodexBar will ask macOS Keychain for your Kimi K2 API key so it can fetch usage. Click OK to continue." = "CodexBar akan meminta Keychain macOS untuk kunci API Kimi K2 Anda agar dapat mengambil penggunaan. Klik OK untuk melanjutkan.";
+"CodexBar will ask macOS Keychain for your Kimi auth token so it can fetch usage. Click OK to continue." = "CodexBar akan meminta Keychain macOS untuk token auth Kimi Anda agar dapat mengambil penggunaan. Klik OK untuk melanjutkan.";
+"CodexBar will ask macOS Keychain for your MiniMax API token so it can fetch usage. Click OK to continue." = "CodexBar akan meminta Keychain macOS untuk token API MiniMax Anda agar dapat mengambil penggunaan. Klik OK untuk melanjutkan.";
+"CodexBar will ask macOS Keychain for your MiniMax cookie header so it can fetch usage. Click OK to continue." = "CodexBar akan meminta Keychain macOS untuk header cookie MiniMax Anda agar dapat mengambil penggunaan. Klik OK untuk melanjutkan.";
+"CodexBar will ask macOS Keychain for your OpenAI cookie header so it can fetch Codex dashboard extras. Click OK to continue." = "CodexBar akan meminta Keychain macOS untuk header cookie OpenAI Anda agar dapat mengambil ekstra dasbor Codex. Klik OK untuk melanjutkan.";
+"CodexBar will ask macOS Keychain for your OpenCode cookie header so it can fetch usage. Click OK to continue." = "CodexBar akan meminta Keychain macOS untuk header cookie OpenCode Anda agar dapat mengambil penggunaan. Klik OK untuk melanjutkan.";
+"CodexBar will ask macOS Keychain for your Synthetic API key so it can fetch usage. Click OK to continue." = "CodexBar akan meminta Keychain macOS untuk kunci API Synthetic Anda agar dapat mengambil penggunaan. Klik OK untuk melanjutkan.";
+"CodexBar will ask macOS Keychain for your z.ai API token so it can fetch usage. Click OK to continue." = "CodexBar akan meminta Keychain macOS untuk token API z.ai Anda agar dapat mengambil penggunaan. Klik OK untuk melanjutkan.";
+"Could not open Cursor login in your browser." = "Tidak dapat membuka login Cursor di browser Anda.";
+"Could not open browser for Antigravity" = "Tidak dapat membuka browser untuk Antigravity";
+"Credits used" = "Kredit terpakai";
+"Day" = "Hari";
+"Deployment" = "Deployment";
+"Drag to reorder" = "Seret untuk mengatur ulang";
+"Sort providers alphabetically" = "Urutkan penyedia menurut abjad";
+"Sort providers alphabetically (enabled first)" = "Urutkan penyedia menurut abjad (yang aktif lebih dulu)";
+"Sorted alphabetically (enabled first) — click to use your custom order" = "Diurutkan menurut abjad (yang aktif lebih dulu) — klik untuk memakai urutan khusus";
+"Endpoint" = "Endpoint";
+"Enterprise host" = "Host enterprise";
+"Extra usage balance: %@" = "Saldo penggunaan ekstra: %@";
+"Keychain Access Required" = "Akses Keychain Diperlukan";
+"Kiro menu bar value" = "Nilai menu bar Kiro";
+"Label" = "Label";
+"No organizations loaded. Click Refresh after setting your API key." = "Tidak ada organisasi dimuat. Klik Segarkan setelah mengatur kunci API Anda.";
+"No output captured." = "Tidak ada output tertangkap.";
+"No system account" = "Tidak ada akun sistem";
+"Oasis-Token" = "Oasis-Token";
+"Open Augment (Log Out & Back In)" = "Buka Augment (Keluar & Masuk Kembali)";
+"Open Codebuff Dashboard" = "Buka Dasbor Codebuff";
+"Open Command Code Settings" = "Buka Pengaturan Command Code";
+"Open Crof dashboard" = "Buka dasbor Crof";
+"Open Manus" = "Buka Manus";
+"Open MiMo Balance" = "Buka Saldo MiMo";
+"Open Moonshot Console" = "Buka Konsol Moonshot";
+"Open Ollama API Keys" = "Buka Kunci API Ollama";
+"Open StepFun Platform" = "Buka Platform StepFun";
+"Open T3 Chat Settings" = "Buka Pengaturan T3 Chat";
+"Open Volcengine Ark Console" = "Buka Konsol Volcengine Ark";
+"Open legacy provider docs" = "Buka dokumentasi penyedia lama";
+"Open projects" = "Buka proyek";
+"Open this URL manually to continue login:\n\n%@" = "Buka URL ini secara manual untuk melanjutkan login:\n\n%@";
+"Optional organization ID for accounts linked to multiple Anthropic organizations." = "ID organisasi opsional untuk akun yang terhubung ke beberapa organisasi Anthropic.";
+"Optional. Applies to the configured Admin API key; selected token accounts do not inherit OPENAI_PROJECT_ID." = "Opsional. Berlaku untuk kunci API Admin yang dikonfigurasi; akun token yang dipilih tidak mewarisi OPENAI_PROJECT_ID.";
+"Optional. Enter your GitHub Enterprise host, for example octocorp.ghe.com. Leave blank for github.com." = "Opsional. Masukkan host GitHub Enterprise Anda, misalnya octocorp.ghe.com. Biarkan kosong untuk github.com.";
+"Optional. Leave blank to discover and aggregate projects visible to the API key." = "Opsional. Biarkan kosong untuk menemukan dan menggabungkan proyek yang terlihat oleh kunci API.";
+"Org ID (optional)" = "ID Org (opsional)";
+"Organizations" = "Organisasi";
+"Password" = "Kata sandi";
+"%@ authentication is disabled." = "Autentikasi %@ dinonaktifkan.";
+"%@ cookies are disabled." = "Cookie %@ dinonaktifkan.";
+"%@ web API access is disabled." = "Akses web API %@ dinonaktifkan.";
+"Disable %@ dashboard cookie usage." = "Nonaktifkan penggunaan cookie dasbor %@.";
+"Keychain access is disabled in Advanced, so browser cookie import is unavailable." = "Akses Keychain dinonaktifkan di Lanjutan, jadi impor cookie browser tidak tersedia.";
+"Manually paste an %@ from a browser session." = "Tempel %@ secara manual dari sesi browser.";
+"Paste a Cookie header captured from %@." = "Tempel header Cookie yang ditangkap dari %@.";
+"Paste a Cookie header from %@." = "Tempel header Cookie dari %@.";
+"Paste a Cookie header or cURL capture from %@." = "Tempel header Cookie atau tangkapan cURL dari %@.";
+"Paste a Cookie header or full cURL capture from %@." = "Tempel header Cookie atau tangkapan cURL lengkap dari %@.";
+"Paste a Cookie or Authorization header from %@." = "Tempel header Cookie atau Authorization dari %@.";
+"Paste a full cookie header or the %@ value." = "Tempel header cookie lengkap atau nilai %@.";
+"Paste a Cookie header or full cURL capture from T3 Chat settings." = "Tempel header Cookie atau tangkapan cURL lengkap dari pengaturan T3 Chat.";
+"Paste the Cookie header from a request to admin.mistral.ai. Must contain an ory_session_* cookie." = "Tempel header Cookie dari permintaan ke admin.mistral.ai. Harus berisi cookie ory_session_*.";
+"Paste the Oasis-Token from a logged-in browser session on platform.stepfun.com." = "Tempel Oasis-Token dari sesi browser yang sudah masuk di platform.stepfun.com.";
+"Paste the %@ JSON bundle from %@." = "Tempel bundel JSON %@ dari %@.";
+"Paste the %@ value or a full Cookie header." = "Tempel nilai %@ atau header Cookie lengkap.";
+"Personal account" = "Akun pribadi";
+"Project ID" = "ID Proyek";
+"Re-auth" = "Autentikasi ulang";
+"Re-login at claude.ai" = "Login ulang di claude.ai";
+"Re-authenticating…" = "Mengautentikasi ulang…";
+"Refresh Session" = "Segarkan Sesi";
+"Refresh organizations" = "Segarkan organisasi";
+"Region" = "Wilayah";
+"Reload" = "Muat ulang";
+"Reorder" = "Atur ulang";
+"Secret access key" = "Secret access key";
+"Series" = "Seri";
+"Service" = "Layanan";
+"Show or hide Kiro credits, percent, or both next to the menu bar icon." = "Tampilkan atau sembunyikan kredit Kiro, persen, atau keduanya di sebelah ikon menu bar.";
+"Show usage for organizations you belong to. Personal account is always shown." = "Tampilkan penggunaan untuk organisasi yang Anda ikuti. Akun pribadi selalu ditampilkan.";
+"Sign in to cursor.com in your browser, then refresh Cursor in CodexBar." = "Masuk ke cursor.com di browser Anda, lalu segarkan Cursor di CodexBar.";
+"Simulated error text" = "Teks error simulasi";
+"StepFun platform account (phone number or email)." = "Akun platform StepFun (nomor telepon atau email).";
+"Stored in ~/.codexbar/config.json." = "Disimpan di ~/.codexbar/config.json.";
+"Stored in ~/.codexbar/config.json. AZURE_OPENAI_API_KEY is also supported." = "Disimpan di ~/.codexbar/config.json. AZURE_OPENAI_API_KEY juga didukung.";
+"Stored in ~/.codexbar/config.json. For the official Kimi API, use Moonshot / Kimi API." = "Disimpan di ~/.codexbar/config.json. Untuk API Kimi resmi, gunakan Moonshot / Kimi API.";
+"Stored in ~/.codexbar/config.json. Get your API key from the Volcengine Ark console." = "Disimpan di ~/.codexbar/config.json. Dapatkan kunci API Anda dari konsol Volcengine Ark.";
+"Stored in ~/.codexbar/config.json. Get your key from Ollama settings." = "Disimpan di ~/.codexbar/config.json. Dapatkan kunci Anda dari pengaturan Ollama.";
+"Stored in ~/.codexbar/config.json. Get your key from console.deepgram.com." = "Disimpan di ~/.codexbar/config.json. Dapatkan kunci Anda dari console.deepgram.com.";
+"Stored in ~/.codexbar/config.json. Get your key from elevenlabs.io/app/settings/api-keys." = "Disimpan di ~/.codexbar/config.json. Dapatkan kunci Anda dari elevenlabs.io/app/settings/api-keys.";
+"Stored in ~/.codexbar/config.json. Get your key from openrouter.ai/settings/keys and set a key spending limit there to enable API key quota tracking." = "Disimpan di ~/.codexbar/config.json. Dapatkan kunci Anda dari openrouter.ai/settings/keys dan atur batas pengeluaran kunci di sana untuk mengaktifkan pelacakan kuota kunci API.";
+"Stored in ~/.codexbar/config.json. In Warp, open Settings > Platform > API Keys, then create one." = "Disimpan di ~/.codexbar/config.json. Di Warp, buka Settings > Platform > API Keys, lalu buat satu.";
+"Stored in ~/.codexbar/config.json. Metrics require Groq Enterprise Prometheus access." = "Disimpan di ~/.codexbar/config.json. Metrik memerlukan akses Groq Enterprise Prometheus.";
+"Stored in ~/.codexbar/config.json. OPENAI_ADMIN_KEY is preferred; OPENAI_API_KEY still works." = "Disimpan di ~/.codexbar/config.json. OPENAI_ADMIN_KEY lebih diutamakan; OPENAI_API_KEY masih berfungsi.";
+"Stored in ~/.codexbar/config.json. Requires an Anthropic Admin API key." = "Disimpan di ~/.codexbar/config.json. Memerlukan kunci API Admin Anthropic.";
+"Stored in ~/.codexbar/config.json. Used for /v1/quota-stats." = "Disimpan di ~/.codexbar/config.json. Digunakan untuk /v1/quota-stats.";
+"Stored in ~/.codexbar/config.json. You can also provide CODEBUFF_API_KEY or let CodexBar read ~/.config/manicode/credentials.json (created by `codebuff login`)." = "Disimpan di ~/.codexbar/config.json. Anda juga dapat menyediakan CODEBUFF_API_KEY atau biarkan CodexBar membaca ~/.config/manicode/credentials.json (dibuat oleh `codebuff login`).";
+"Stored in ~/.codexbar/config.json. You can also provide CROF_API_KEY." = "Disimpan di ~/.codexbar/config.json. Anda juga dapat menyediakan CROF_API_KEY.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or ~/.local/share/kilo/auth.json (kilo.access)." = "Disimpan di ~/.codexbar/config.json. Anda juga dapat menyediakan KILO_API_KEY atau ~/.local/share/kilo/auth.json (kilo.access).";
+"T3 Chat cookie" = "Cookie T3 Chat";
+"That account is no longer available in CodexBar. Refresh the account list and try again." = "Akun tersebut tidak lagi tersedia di CodexBar. Segarkan daftar akun dan coba lagi.";
+"The browser login did not complete in time. Try Antigravity login again." = "Login browser tidak selesai tepat waktu. Coba login Antigravity lagi.";
+"Timed out waiting for Cursor login. %@" = "Kehabisan waktu menunggu login Cursor. %@";
+"Timed out waiting for Cursor login. %@ Last error: %@" = "Kehabisan waktu menunggu login Cursor. %@ Error terakhir: %@";
+"Today requests" = "Permintaan hari ini";
+"Total (30d): %@ credits" = "Total (30 hari): %@ kredit";
+"Username" = "Nama pengguna";
+"Uses username + password to login and obtain an Oasis-Token automatically." = "Menggunakan nama pengguna + kata sandi untuk login dan mendapatkan Oasis-Token secara otomatis.";
+"Uses username + password to login and obtain an %@ automatically." = "Menggunakan nama pengguna + kata sandi untuk login dan mendapatkan %@ secara otomatis.";
+"Utilization End" = "Akhir Pemanfaatan";
+"Utilization Start" = "Awal Pemanfaatan";
+"Verbosity" = "Verbositas";
+"Windsurf session JSON bundle" = "Bundel JSON sesi Windsurf";
+"Workspace ID" = "ID Workspace";
+"Your StepFun platform password. Used to login and obtain a session token." = "Kata sandi platform StepFun Anda. Digunakan untuk login dan mendapatkan token sesi.";
+"claude /login exited with status %d." = "claude /login keluar dengan status %d.";
+"codex login exited with status %d." = "codex login keluar dengan status %d.";
+"Cookie: …\n\nor paste a cURL capture from the Abacus AI dashboard" = "Cookie: …\n\natau tempel tangkapan cURL dari dasbor Abacus AI";
+"Cookie: …\n\nor paste the __Secure-next-auth.session-token value" = "Cookie: …\n\natau tempel nilai __Secure-next-auth.session-token";
+"Cookie: …\n\nor paste the kimi-auth token value" = "Cookie: …\n\natau tempel nilai token kimi-auth";
+"session_id=...\n\nor paste just the session_id value" = "session_id=...\n\natau tempel hanya nilai session_id";
+"Clear" = "Hapus";
+"No matching providers" = "Tidak ada penyedia cocok";
+"Search providers" = "Cari penyedia";
+
+"Request quota: %@ / %@" = "Kuota permintaan: %@ / %@";
+"language_arabic" = "العربية";
+"language_persian" = "فارسی";
+"language_thai" = "ไทย";
+"Limit Reset Credits" = "Kredit pengaturan ulang batas";
+"1 manual reset available" = "1 pengaturan ulang manual tersedia";
+"%d manual resets available" = "%d pengaturan ulang manual tersedia";
+"Next expires %@" = "Berikutnya kedaluwarsa %@";
+"byte_unit_byte" = "byte";
+"byte_unit_bytes" = "byte";
+"byte_unit_kilobyte" = "kilobyte";
+"byte_unit_kilobytes" = "kilobyte";
+"byte_unit_megabyte" = "megabyte";
+"byte_unit_megabytes" = "megabyte";
+"byte_unit_gigabyte" = "gigabyte";
+"byte_unit_gigabytes" = "gigabyte";
diff --git a/Sources/CodexBar/Resources/it.lproj/Localizable.strings b/Sources/CodexBar/Resources/it.lproj/Localizable.strings
new file mode 100644
index 0000000000..ea446916a0
--- /dev/null
+++ b/Sources/CodexBar/Resources/it.lproj/Localizable.strings
@@ -0,0 +1,1109 @@
+/* Italian localization for CodexBar */
+
+" providers" = " provider";
+"(System)" = "(Sistema)";
+"30d" = "30 g";
+"A managed Codex login is already running. Wait for it to finish before adding " = "È già in corso un accesso gestito a Codex. Attendi che termini prima di aggiungere ";
+"API key" = "Chiave API";
+"API region" = "Regione API";
+"API token" = "Token API";
+"API tokens" = "Token API";
+"About" = "Informazioni";
+"Account" = "Account";
+"Accounts" = "Account";
+"Accounts subtitle" = "Scegli e gestisci gli account monitorati da CodexBar.";
+"Active" = "Attivo";
+"Add" = "Aggiungi";
+"Add Workspace" = "Aggiungi workspace";
+"Advanced" = "Avanzate";
+"All" = "Tutti";
+"Always allow prompts" = "Consenti sempre i prompt";
+"Animation pattern" = "Schema animazione";
+"Antigravity login is managed in the app" = "L'accesso ad Antigravity è gestito nell'app";
+"Applies only to the Security.framework OAuth keychain reader." = "Si applica solo al lettore OAuth del portachiavi di Security.framework.";
+"Auto falls back to the next source if the preferred one fails." = "In modalità Auto passa alla fonte successiva se quella preferita fallisce.";
+"Auto uses API first, then falls back to CLI on auth failures." = "Auto usa prima l'API, poi passa alla CLI se l'autenticazione fallisce.";
+"Auto-detect" = "Rilevamento automatico";
+"Auto-refresh is off; use the menu's Refresh command." = "L'aggiornamento automatico è disattivato; usa il comando Aggiorna del menu.";
+"Auto-refresh: hourly · Timeout: 10m" = "Aggiornamento automatico: ogni ora · Timeout: 10 min";
+"Automatic" = "Automatico";
+"Automatic imports browser cookies and WorkOS tokens." = "Importa automaticamente i cookie del browser e i token WorkOS.";
+"Automatic imports browser cookies and local storage tokens." = "Importa automaticamente i cookie del browser e i token del local storage.";
+"Automatic imports browser cookies for dashboard extras." = "Importa automaticamente i cookie del browser per gli extra della dashboard.";
+"Automatic imports browser cookies for the web API." = "Importa automaticamente i cookie del browser per la web API.";
+"Automatic imports browser cookies from Model Studio/Bailian." = "Importa automaticamente i cookie del browser da Model Studio/Bailian.";
+"Automatic imports browser cookies from admin.mistral.ai." = "Importa automaticamente i cookie del browser da admin.mistral.ai.";
+"Automatic imports browser cookies from opencode.ai." = "Importa automaticamente i cookie del browser da opencode.ai.";
+"Automatic imports browser cookies or stored sessions." = "Importa automaticamente i cookie del browser o le sessioni salvate.";
+"Automatic imports browser cookies." = "Importa automaticamente i cookie del browser.";
+"Automatically imports browser session cookie." = "Importa automaticamente il cookie di sessione del browser.";
+"Automatically opens CodexBar when you start your Mac." = "Apre automaticamente CodexBar quando avvii il Mac.";
+"Automation" = "Automazione";
+"Average (\\(label1) + \\(label2))" = "Media (\\(label1) + \\(label2))";
+"Average (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))" = "Media (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))";
+"Avoid Keychain prompts" = "Evita i prompt del portachiavi";
+"Balance" = "Saldo";
+"Battery Saver" = "Risparmio batteria";
+"Bordered" = "Con bordo";
+"Build" = "Build";
+"Built \\(buildTimestamp)" = "Build \\(buildTimestamp)";
+"Buy Credits..." = "Acquista crediti...";
+"Buy Credits…" = "Acquista crediti…";
+"CLI paths" = "Percorsi CLI";
+"CLI sessions" = "Sessioni CLI";
+"Caches" = "Cache";
+"Cancel" = "Annulla";
+"Check for Updates…" = "Controlla aggiornamenti…";
+"Check for updates automatically" = "Controlla automaticamente gli aggiornamenti";
+"Check if you like your agents having some fun up there." = "Attivalo se vuoi che i tuoi agenti si divertano un po' lassù.";
+"Check provider status" = "Controlla stato provider";
+"Choose Codex workspace" = "Scegli il workspace Codex";
+"Choose the MiniMax host (global .io or China mainland .com)." = "Scegli l'host MiniMax (.io globale o .com per la Cina continentale).";
+"Choose up to " = "Scegli fino a ";
+"Choose up to \\(Self.maxOverviewProviders) providers" = "Scegli fino a \\(Self.maxOverviewProviders) provider";
+"Choose up to \\(count) providers" = "Scegli fino a \\(count) provider";
+"Choose what to show in the menu bar (Pace shows usage vs. expected)." = "Scegli cosa mostrare nella barra menu (Andamento mostra l'uso rispetto al previsto).";
+"Choose which Codex account CodexBar should follow." = "Scegli quale account Codex deve seguire CodexBar.";
+"Choose which window drives the menu bar percent." = "Scegli quale finestra determina la percentuale nella barra menu.";
+"Chrome" = "Chrome";
+"Claude CLI not found" = "Claude CLI non trovata";
+"Claude binary" = "Binario Claude";
+"Claude cookies" = "Cookie Claude";
+"Claude login failed" = "Accesso Claude non riuscito";
+"Claude login timed out" = "Timeout accesso Claude";
+"Close" = "Chiudi";
+"Code review" = "Revisione codice";
+"Codex CLI not found" = "Codex CLI non trovata";
+"Codex account login already running" = "Accesso account Codex già in corso";
+"Codex binary" = "Binario Codex";
+"Codex login failed" = "Accesso Codex non riuscito";
+"Codex login timed out" = "Timeout accesso Codex";
+"CodexBar Lifecycle Keepalive" = "Keepalive ciclo di vita CodexBar";
+"CodexBar can't show its menu bar icon" = "CodexBar non può mostrare la sua icona nella barra menu";
+"CodexBar could not read managed account storage. " = "CodexBar non è riuscito a leggere l'archivio degli account gestiti. ";
+"Configure…" = "Configura…";
+"Connected" = "Connesso";
+"Controls how much detail is logged." = "Controlla il livello di dettaglio registrato nei log.";
+"Cookie header" = "Header Cookie";
+"Cookie source" = "Fonte cookie";
+"Cookie: ..." = "Cookie: ...";
+"Cookie: \\u{2026}\\\n\\\nor paste a cURL capture from the Abacus AI dashboard" = "Cookie: \\u{2026}\\\n\\\noppure incolla una cattura cURL dalla dashboard di Abacus AI";
+"Cookie: \\u{2026}\\\n\\\nor paste the __Secure-next-auth.session-token value" = "Cookie: \\u{2026}\\\n\\\noppure incolla il valore di __Secure-next-auth.session-token";
+"Cookie: \\u{2026}\\\n\\\nor paste the kimi-auth token value" = "Cookie: \\u{2026}\\\n\\\noppure incolla il valore del token kimi-auth";
+"Cookie: …" = "Cookie: …";
+"CopilotDeviceFlow" = "Copilot Device Flow";
+"Cost" = "Costo";
+"Could not add Codex account" = "Impossibile aggiungere l'account Codex";
+"Could not open Terminal for Gemini" = "Impossibile aprire Terminale per Gemini";
+"Could not start claude /login" = "Impossibile avviare claude /login";
+"Could not start codex login" = "Impossibile avviare codex login";
+"Could not switch system account" = "Impossibile cambiare account di sistema";
+"Credits" = "Crediti";
+"Individual credits" = "Crediti individuali";
+"Workspace" = "Spazio di lavoro";
+"Credits history" = "Storico crediti";
+"Cursor login failed" = "Accesso Cursor non riuscito";
+"Custom" = "Personalizzato";
+"Custom Path" = "Percorso personalizzato";
+"Daily Routines" = "Routine quotidiane";
+"Debug" = "Diagnostica";
+"Default" = "Predefinito";
+"Disable Keychain access" = "Disabilita accesso al portachiavi";
+"Disabled" = "Disattivato";
+"Dismiss" = "Chiudi";
+"Disconnected" = "Disconnesso";
+"Display" = "Aspetto";
+"Display mode" = "Modalità di visualizzazione";
+"Display reset times as absolute clock values instead of countdowns." = "Mostra gli orari di reset come orari assoluti invece che come conto alla rovescia.";
+"Done" = "Fine";
+"Effective PATH" = "PATH effettivo";
+"Email" = "Email";
+"Enable Merge Icons to configure Overview tab providers." = "Abilita Unisci icone per configurare i provider della scheda Panoramica.";
+"Enable file logging" = "Abilita logging su file";
+"Enabled" = "Attivo";
+"Error" = "Errore";
+"Error simulation" = "Simulazione errore";
+"Expose troubleshooting tools in the Debug tab." = "Espone gli strumenti di risoluzione problemi nella scheda Debug.";
+"Failed" = "Fallito";
+"False" = "Falso";
+"Fetch strategy attempts" = "Tentativi strategia di recupero";
+"Fetching" = "Recupero in corso";
+"Field" = "Campo";
+"Field subtitle" = "Sottotitolo campo";
+"Finish the current managed account change before switching the system account." = "Completa l'attuale cambio di account gestito prima di cambiare l'account di sistema.";
+"Force animation on next refresh" = "Forza animazione al prossimo aggiornamento";
+"Gateway region" = "Regione gateway";
+"Gemini CLI not found" = "Gemini CLI non trovata";
+"Gemini/Antigravity, surfacing incidents in the icon and menu." = "Gemini/Antigravity, con incidenti mostrati nell'icona e nel menu.";
+"General" = "Generale";
+"GitHub" = "GitHub";
+"GitHub Copilot Login" = "Accesso GitHub Copilot";
+"GitHub Login" = "Accesso GitHub";
+"Hide details" = "Nascondi dettagli";
+"Hide personal information" = "Nascondi informazioni personali";
+"Historical tracking" = "Tracciamento storico";
+"How often CodexBar polls providers in the background." = "Quanto spesso CodexBar interroga i provider in background.";
+"Inactive" = "Inattivo";
+"Install CLI" = "Installa CLI";
+"Install the Claude CLI (npm i -g @anthropic-ai/claude-code) and try again." = "Installa la Claude CLI (npm i -g @anthropic-ai/claude-code) e riprova.";
+"Install the Codex CLI (npm i -g @openai/codex) and try again." = "Installa la Codex CLI (npm i -g @openai/codex) e riprova.";
+"Install the Gemini CLI (npm i -g @google/gemini-cli) and try again." = "Installa la Gemini CLI (npm i -g @google/gemini-cli) e riprova.";
+"JetBrains AI is ready" = "JetBrains AI è pronto";
+"JetBrains IDE" = "IDE JetBrains";
+"Keep CLI sessions alive" = "Mantieni attive le sessioni CLI";
+"Keyboard shortcut" = "Scorciatoia da tastiera";
+"Keychain access" = "Accesso al portachiavi";
+"Keychain prompt policy" = "Politica prompt portachiavi";
+"Last \\(name) fetch failed:" = "Ultimo recupero di \\(name) non riuscito:";
+"Last \\(self.store.metadata(for: self.provider).displayName) fetch failed:" = "Ultimo recupero di \\(self.store.metadata(for: self.provider).displayName) non riuscito:";
+"Last attempt" = "Ultimo tentativo";
+"Link" = "Collegamento";
+"Loading animations" = "Animazioni di caricamento";
+"Loading…" = "Caricamento…";
+"Local" = "Locale";
+"Logging" = "Log";
+"Login failed" = "Accesso non riuscito";
+"Login shell PATH (startup capture)" = "PATH della shell di login (cattura all'avvio)";
+"Login timed out" = "Timeout accesso";
+"MCP details" = "Dettagli MCP";
+"Managed Codex accounts unavailable" = "Account Codex gestiti non disponibili";
+"Managed account storage is unreadable. Live account access is still available, " = "L'archivio degli account gestiti non è leggibile. L'accesso agli account live è ancora disponibile, ";
+"Manual" = "Manuale";
+"May your tokens never run out—keep agent limits in view." = "Che i tuoi token non finiscano mai: tieni d'occhio i limiti degli agenti.";
+"Menu bar" = "Barra menu";
+"Menu bar auto-shows the provider closest to its rate limit." = "La barra menu mostra automaticamente il provider più vicino al proprio limite.";
+"Menu bar metric" = "Metrica barra menu";
+"Menu bar shows percent" = "La barra menu mostra la percentuale";
+"Menu content" = "Contenuto menu";
+"Merge Icons" = "Unisci icone";
+"Never prompt" = "Non chiedere mai";
+"No" = "No";
+"No Codex accounts detected yet." = "Nessun account Codex rilevato finora.";
+"No JetBrains IDE detected" = "Nessun IDE JetBrains rilevato";
+"No cost history data." = "Nessun dato storico costi.";
+"No data available" = "Nessun dato disponibile";
+"No data yet" = "Nessun dato";
+"No enabled providers available for Overview." = "Nessun provider abilitato disponibile per la Panoramica.";
+"No providers selected" = "Nessun provider selezionato";
+"No token accounts yet." = "Nessun account token al momento.";
+"No usage breakdown data." = "Nessun dato di dettaglio utilizzo.";
+"None" = "Nessuno";
+"Notifications" = "Notifiche";
+"Notifies when the 5-hour session quota hits 0% and when it becomes " = "Notifica quando la quota di sessione di 5 ore raggiunge lo 0% e quando torna ";
+"OK" = "Va bene";
+"Obscure email addresses in the menu bar and menu UI." = "Oscura gli indirizzi email nella barra menu e nell'interfaccia del menu.";
+"Off" = "Disattivato";
+"Offline" = "Non in linea";
+"On" = "Attivo";
+"Online" = "In linea";
+"Only on user action" = "Solo su azione dell'utente";
+"Open" = "Apri";
+"Open API Keys" = "Apri chiavi API";
+"Open Amp Settings" = "Apri impostazioni Amp";
+"Open Antigravity to sign in, then refresh CodexBar." = "Apri Antigravity per accedere, poi aggiorna CodexBar.";
+"Open Browser" = "Apri browser";
+"Open Coding Plan" = "Apri Coding Plan";
+"Open Console" = "Apri console";
+"Open Dashboard" = "Apri dashboard";
+"Open Mistral Admin" = "Apri Mistral Admin";
+"Open Menu Bar Settings" = "Apri impostazioni barra menu";
+"Open Ollama Settings" = "Apri impostazioni Ollama";
+"Open Terminal" = "Apri Terminale";
+"Open Usage Page" = "Apri pagina utilizzo";
+"Open Warp API Key Guide" = "Apri guida chiave API Warp";
+"Open menu" = "Apri menu";
+"Open token file" = "Apri file token";
+"OpenAI cookies" = "Cookie OpenAI";
+"OpenAI web extras" = "Extra web OpenAI";
+"Option A" = "Opzione A";
+"Option B" = "Opzione B";
+"Optional override if workspace lookup fails." = "Override opzionale se la ricerca del workspace fallisce.";
+"Options" = "Opzioni";
+"Override auto-detection with a custom IDE base path" = "Sostituisci il rilevamento automatico con un percorso base IDE personalizzato";
+"Overview" = "Panoramica";
+"Overview rows always follow provider order." = "Le righe della Panoramica seguono sempre l'ordine dei provider.";
+"Overview tab providers" = "Provider scheda Panoramica";
+"Paste API key…" = "Incolla chiave API…";
+"Paste API token…" = "Incolla token API…";
+"Paste key…" = "Incolla chiave…";
+"Paste sessionKey or OAuth token…" = "Incolla sessionKey o token OAuth…";
+"Paste the Cookie header from a request to admin.mistral.ai. " = "Incolla l'header Cookie da una richiesta a admin.mistral.ai. ";
+"Paste token…" = "Incolla token…";
+"Personal" = "Personale";
+"Picker" = "Selettore";
+"Picker subtitle" = "Sottotitolo selettore";
+"Placeholder" = "Segnaposto";
+"Plan" = "Piano";
+"Play full-screen confetti when weekly usage resets." = "Mostra coriandoli a schermo intero quando l'utilizzo settimanale si resetta.";
+"Polls OpenAI/Claude status pages and Google Workspace for " = "Interroga le pagine di stato di OpenAI/Claude e Google Workspace per ";
+"Prevents any Keychain access while enabled." = "Impedisce qualsiasi accesso al portachiavi quando è attivo.";
+"Primary (API key limit)" = "Primario (limite chiave API)";
+"Primary (\\(label))" = "Primario (\\(label))";
+"Primary (\\(metadata.sessionLabel))" = "Primario (\\(metadata.sessionLabel))";
+"Probe logs" = "Log probe";
+"Progress bars fill as you consume quota (instead of showing remaining)." = "Le barre di avanzamento si riempiono man mano che consumi la quota (invece di mostrare il rimanente).";
+"Provider" = "Provider";
+"Providers" = "Provider";
+"Quit CodexBar" = "Esci da CodexBar";
+"Random (default)" = "Casuale (predefinito)";
+"Reads local usage logs. Shows today + last 30 days cost in the menu." = "Legge i log di utilizzo locali. Mostra oggi + la finestra storica selezionata nel menu.";
+"Refresh" = "Aggiorna";
+"Refresh cadence" = "Frequenza aggiornamento";
+"Remote" = "Remoto";
+"Remove" = "Rimuovi";
+"Remove Codex account?" = "Rimuovere l'account Codex?";
+"Remove \\(account.email) from CodexBar? Its managed Codex home will be deleted." = "Rimuovere \\(account.email) da CodexBar? La sua home Codex gestita verrà eliminata.";
+"Remove \\(email) from CodexBar? Its managed Codex home will be deleted." = "Rimuovere \\(email) da CodexBar? La sua home Codex gestita verrà eliminata.";
+"Remove selected account" = "Rimuovi account selezionato";
+"Replace critter bars with provider branding icons and a percentage." = "Sostituisce le barre con icone del brand del provider e una percentuale.";
+"Replay selected animation" = "Riproduci di nuovo l'animazione selezionata";
+"Requires authentication via GitHub Device Flow." = "Richiede autenticazione tramite GitHub Device Flow.";
+"Resets: \\(reset)" = "Si resetta: \\(reset)";
+"Rolling five-hour limit" = "Limite mobile di cinque ore";
+"Search hourly" = "Ricerca oraria";
+"Secondary (\\(label))" = "Secondario (\\(label))";
+"Secondary (\\(metadata.weeklyLabel))" = "Secondario (\\(metadata.weeklyLabel))";
+"Select a provider" = "Seleziona un provider";
+"Select the IDE to monitor" = "Seleziona l'IDE da monitorare";
+"Session quota notifications" = "Notifiche quota sessione";
+"Session tokens" = "Token di sessione";
+"Settings" = "Impostazioni";
+"Show Codex Credits and Claude Extra usage sections in the menu." = "Mostra nel menu le sezioni Crediti Codex e Uso extra Claude.";
+"Show Debug Settings" = "Mostra impostazioni debug";
+"Show all token accounts" = "Mostra tutti gli account token";
+"Show cost summary" = "Mostra riepilogo costi";
+"Show credits + extra usage" = "Mostra crediti + uso extra";
+"Show details" = "Mostra dettagli";
+"Show most-used provider" = "Mostra provider più usato";
+"Show provider icons in the switcher (otherwise show a weekly progress line)." = "Mostra le icone dei provider nel selettore (altrimenti mostra una linea di progresso settimanale).";
+"Show reset time as clock" = "Mostra l'ora di reset come orario";
+"Show usage as used" = "Mostra l'utilizzo come consumato";
+"Sign in via button below" = "Accedi con il pulsante qui sotto";
+"Skip teardown between probes (debug-only)." = "Salta il teardown tra i probe (solo debug).";
+"Stack token accounts in the menu (otherwise show an account switcher bar)." = "Impila gli account token nel menu (altrimenti mostra una barra per cambiare account).";
+"Start at Login" = "Avvia all'accesso";
+"Status" = "Stato";
+"Store Claude sessionKey cookies or OAuth access tokens." = "Memorizza i cookie sessionKey di Claude o i token di accesso OAuth.";
+"Store multiple Abacus AI Cookie headers." = "Memorizza più header Cookie di Abacus AI.";
+"Store multiple Augment Cookie headers." = "Memorizza più header Cookie di Augment.";
+"Store multiple Cursor Cookie headers." = "Memorizza più header Cookie di Cursor.";
+"Store multiple Factory Cookie headers." = "Memorizza più header Cookie di Factory.";
+"Store multiple MiniMax Cookie headers." = "Memorizza più header Cookie di MiniMax.";
+"Store multiple Mistral Cookie headers." = "Memorizza più header Cookie di Mistral.";
+"Store multiple Ollama Cookie headers." = "Memorizza più header Cookie di Ollama.";
+"Store multiple OpenCode Cookie headers." = "Memorizza più header Cookie di OpenCode.";
+"Store multiple OpenCode Go Cookie headers." = "Memorizza più header Cookie di OpenCode Go.";
+"Stored in the CodexBar config file." = "Memorizzato nel file di configurazione di CodexBar.";
+"Stored in ~/.codexbar/config.json. " = "Memorizzato in ~/.codexbar/config.json. ";
+"Stored in ~/.codexbar/config.json. Generate one at kimi-k2.ai." = "Memorizzato in ~/.codexbar/config.json. Generane uno su kimi-k2.ai.";
+"Stored in ~/.codexbar/config.json. Paste the key from the Synthetic dashboard." = "Memorizzato in ~/.codexbar/config.json. Incolla la chiave dalla dashboard di Synthetic.";
+"Stored in ~/.codexbar/config.json. Paste your Coding Plan API key from Model Studio." = "Memorizzato in ~/.codexbar/config.json. Incolla la tua chiave API Coding Plan da Model Studio.";
+"Stored in ~/.codexbar/config.json. Paste your MiniMax API key." = "Memorizzato in ~/.codexbar/config.json. Incolla la tua chiave API MiniMax.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or " = "Memorizzato in ~/.codexbar/config.json. Puoi anche fornire KILO_API_KEY o ";
+"Stores local Codex usage history (8 weeks) to personalize Pace predictions." = "Memorizza la cronologia di utilizzo locale di Codex (8 settimane) per personalizzare le previsioni di andamento.";
+"Subscription Utilization" = "Utilizzo abbonamento";
+"Surprise me" = "Sorprendimi";
+"Switcher shows icons" = "Il selettore mostra icone";
+"Symlink CodexBarCLI to /usr/local/bin and /opt/homebrew/bin as codexbar." = "Crea il symlink di CodexBarCLI in /usr/local/bin e /opt/homebrew/bin come codexbar.";
+"System" = "Sistema";
+"terminal_app_subtitle" = "Terminale usato dall'azione Apri terminale";
+"terminal_app_title" = "Terminale predefinito";
+"Temporarily shows the loading animation after the next refresh." = "Mostra temporaneamente l'animazione di caricamento dopo il prossimo aggiornamento.";
+"Tertiary (\\(label))" = "Terziario (\\(label))";
+"Tertiary (\\(tertiaryTitle))" = "Terziario (\\(tertiaryTitle))";
+"The default Codex account on this Mac." = "L'account Codex predefinito su questo Mac.";
+"Toggle" = "Interruttore";
+"Toggle subtitle" = "Sottotitolo interruttore";
+"Token" = "Token";
+"Trigger the menu bar menu from anywhere." = "Attiva il menu della barra da qualsiasi punto.";
+"True" = "Vero";
+"Twitter" = "X";
+"Unsupported" = "Non supportato";
+"Update Channel" = "Canale aggiornamenti";
+"Updated" = "Aggiornato";
+"Updates unavailable in this build." = "Aggiornamenti non disponibili in questa build.";
+"Usage" = "Utilizzo";
+"Usage breakdown" = "Dettaglio utilizzo";
+"Usage history (30 days)" = "Storico utilizzo (30 giorni)";
+"Usage source" = "Fonte utilizzo";
+"Use BigModel for the China mainland endpoints (open.bigmodel.cn)." = "Usa BigModel per gli endpoint della Cina continentale (open.bigmodel.cn).";
+"Use a single menu bar icon with a provider switcher." = "Usa una singola icona nella barra menu con selettore provider.";
+"Use international or China mainland console gateways for quota fetches." = "Usa i gateway console internazionali o della Cina continentale per recuperare le quote.";
+"Version" = "Versione";
+"Version \\(self.versionString)" = "Versione \\(self.versionString)";
+"Version \\(version)" = "Versione \\(version)";
+"Version \\(versionString)" = "Versione \\(versionString)";
+"Vertex AI Login" = "Accesso Vertex AI";
+"Wait for the current managed Codex login to finish before adding another account." = "Attendi che l'accesso gestito di Codex in corso finisca prima di aggiungere un altro account.";
+"Waiting for Authentication..." = "In attesa di autenticazione...";
+"Website" = "Sito web";
+"Weekly limit confetti" = "Coriandoli limite settimanale";
+"Weekly token limit" = "Limite token settimanale";
+"Weekly usage" = "Utilizzo settimanale";
+"Weekly usage unavailable for this account." = "Utilizzo settimanale non disponibile per questo account.";
+"Window: \\(window)" = "Finestra: \\(window)";
+"Write logs to \\(self.fileLogPath) for debugging." = "Scrive i log in \\(self.fileLogPath) per il debug.";
+"Yes" = "Sì";
+"\\(detail.modelCode): \\(usage)" = "Modello \\(detail.modelCode): \\(usage)";
+"\\(name): \\(truncated)" = "\\(name): \\(truncated) (ridotto)";
+"\\(name): \\(updated) · 30d \\(cost)" = "\\(name): \\(updated) · 30 g \\(cost)";
+"\\(name): fetching…\\(elapsed)" = "\\(name): recupero…\\(elapsed)";
+"\\(name): last attempt \\(when)" = "\\(name): ultimo tentativo \\(when)";
+"\\(name): no data yet" = "\\(name): nessun dato ancora";
+"\\(name): unsupported" = "\\(name): non supportato";
+"all browsers" = "tutti i browser";
+"available again." = "nuovamente disponibile.";
+"built_format" = "Build %@";
+"copilot_complete_in_browser" = "Completa l'accesso nel browser.";
+"copilot_device_code" = "Codice dispositivo copiato negli appunti: %1$@\n\nVerifica su: %2$@";
+"copilot_device_code_copied" = "Codice dispositivo copiato.";
+"copilot_verify_at" = "Verifica su %@";
+"copilot_waiting_text" = "Completa l'accesso nel browser.\nQuesta finestra si chiuderà automaticamente quando l'accesso sarà completato.";
+"copilot_window_closes_auto" = "Questa finestra si chiuderà automaticamente quando l'accesso sarà completato.";
+"cost_status_error" = "%1$@: errore %2$@";
+"cost_status_fetching" = "%1$@: recupero in corso… %2$@";
+"cost_status_last_attempt" = "%1$@: ultimo tentativo %2$@";
+"cost_status_no_data" = "%@: nessun dato ancora";
+"cost_status_snapshot" = "%1$@: %2$@ · %3$@: %4$@";
+"cost_status_unsupported" = "%@: non supportato";
+"credits_remaining" = "Crediti: %@";
+"cursor_on_demand" = "Su richiesta: %@";
+"cursor_on_demand_with_limit" = "Su richiesta: %1$@ / %2$@";
+"extra_usage_format" = "Uso extra: %1$@ / %2$@";
+"jetbrains_detected_generate" = "Rilevato: %@. Usa l'assistente AI una volta per generare i dati di quota, poi aggiorna CodexBar.";
+"jetbrains_detected_select" = "Rilevato: %@. Seleziona l'IDE preferito nelle Impostazioni, poi aggiorna CodexBar.";
+"last_fetch_failed_with_provider" = "Ultimo recupero %@ non riuscito:";
+"last_spend" = "Ultima spesa: %@";
+"mcp_model_usage" = "Modello %1$@: %2$@";
+"mcp_resets" = "Si resetta: %@";
+"mcp_window" = "Finestra: %@";
+"metric_average" = "Media (%1$@ + %2$@)";
+"metric_primary" = "Primario (%@)";
+"metric_secondary" = "Secondario (%@)";
+"metric_tertiary" = "Terziario (%@)";
+"multiple_workspaces_found" = "CodexBar ha trovato più workspace per %@. Scegli il workspace da aggiungere.";
+"ory_session_…=…; csrftoken=…" = "ory_session_…=…; csrftoken=…";
+"overview_choose_providers" = "Scegli fino a %@ provider";
+"remove_account_message" = "Rimuovere %@ da CodexBar? La sua home Codex gestita verrà eliminata.";
+"version_format" = "Versione %@";
+"vertex_ai_login_instructions" = "Per monitorare l'utilizzo di Vertex AI, autenticati con Google Cloud.\n\n1. Apri Terminale\n2. Esegui: gcloud auth application-default login\n3. Segui le istruzioni nel browser per accedere\n4. Imposta il progetto: gcloud config set project PROJECT_ID\n\nAprire Terminale ora?";
+"workspaceID is set but only opencode, opencodego, and deepgram support workspaceID." = "workspaceID è impostato ma solo opencode, opencodego e deepgram supportano workspaceID.";
+"© 2026 Peter Steinberger. MIT License." = "© 2026 Peter Steinberger. Licenza MIT.";
+
+/* General Pane */
+"section_system" = "Sistema";
+"section_usage" = "Utilizzo";
+"section_automation" = "Automazione";
+"language_title" = "Lingua";
+"language_subtitle" = "Cambia la lingua dell'interfaccia. Richiede il riavvio dell'app per applicare completamente la modifica.";
+"language_system" = "Sistema";
+"language_english" = "Inglese";
+"language_spanish" = "Spagnolo";
+"language_catalan" = "Catalano";
+"language_chinese_simplified" = "Cinese semplificato";
+"language_chinese_traditional" = "Cinese tradizionale";
+"language_portuguese_brazilian" = "Portoghese (Brasile)";
+"language_german" = "Tedesco";
+"language_swedish" = "Svedese";
+"language_italian" = "Italiano";
+"language_polish" = "Polacco";
+"language_japanese" = "Giapponese";
+"language_korean" = "Coreano";
+"language_turkish" = "Turco";
+"language_french" = "Francese";
+"language_dutch" = "Olandese";
+"language_ukrainian" = "Ucraino";
+"language_vietnamese" = "Vietnamita";
+"language_indonesian" = "Indonesiano";
+"start_at_login_title" = "Avvia all'accesso";
+"start_at_login_subtitle" = "Apre automaticamente CodexBar quando avvii il Mac.";
+"show_cost_summary" = "Mostra riepilogo costi";
+"show_cost_summary_subtitle" = "Legge i log di utilizzo locali. Mostra oggi + la finestra storica selezionata nel menu.";
+"cost_history_days_title" = "Finestra storica: %d giorni";
+"cost_auto_refresh_info" = "Aggiornamento automatico: ogni ora · Timeout: 10 min";
+"refresh_cadence_title" = "Frequenza aggiornamento";
+"refresh_cadence_subtitle" = "Con quale frequenza CodexBar interroga i provider in background.";
+"manual_refresh_hint" = "Aggiornamento automatico disattivato; usa il comando Aggiorna nel menu.";
+"check_provider_status_title" = "Controlla stato provider";
+"check_provider_status_subtitle" = "Controlla le pagine di stato OpenAI/Claude e Google Workspace per Gemini/Antigravity, mostrando incidenti in icona e menu.";
+"session_quota_notifications_title" = "Notifiche quota sessione";
+"session_quota_notifications_subtitle" = "Notifica quando la quota sessione di 5 ore arriva allo 0% e quando torna disponibile.";
+"quota_warning_notifications_title" = "Notifiche avviso quota";
+"quota_warning_notifications_subtitle" = "Avvisa quando la quota residua di sessione o settimanale scende sotto le soglie configurate.";
+"quota_warnings_title" = "Avvisi quota";
+"quota_warning_session" = "sessione";
+"quota_warning_session_capitalized" = "Sessione";
+"quota_warning_weekly" = "settimanale";
+"quota_warning_weekly_capitalized" = "Settimanale";
+"quota_warning_notification_title" = "Quota %2$@ di %1$@ quasi esaurita";
+"quota_warning_notification_body" = "Rimane %1$@. Hai raggiunto la soglia di avviso del %2$d%% per la quota %3$@.";
+"quota_warning_notification_body_with_account" = "Account %1$@. Rimane %2$@. Hai raggiunto la soglia di avviso del %3$d%% per la quota %4$@.";
+"session_depleted_notification_title" = "Sessione %@ esaurita";
+"session_depleted_notification_body" = "Rimane lo 0%. Ti avviseremo quando tornerà disponibile.";
+"session_restored_notification_title" = "Sessione %@ ripristinata";
+"session_restored_notification_body" = "La quota di sessione è di nuovo disponibile.";
+"quota_warning_warn_at" = "Avvisa a";
+"quota_warning_global_threshold_subtitle" = "Percentuali residue per le finestre di sessione e settimanale, salvo override del provider.";
+"quota_warning_sound" = "Riproduci suono di notifica";
+"quota_warning_provider_inherits" = "Usa le impostazioni globali di avviso quota, salvo personalizzazione di una finestra qui.";
+"quota_warning_customize_thresholds" = "Personalizza soglie %@";
+"quota_warning_enable_warnings" = "Abilita avvisi %@";
+"quota_warning_window_warn_at" = "Avvisa %@ a";
+"quota_warning_off" = "Disattivato";
+"quota_warning_inherited" = "Ereditato: %@";
+"quota_warning_depleted_only" = "solo esaurita";
+"quota_warning_upper" = "Superiore";
+"quota_warning_lower" = "Inferiore";
+"apply" = "Applica";
+"quit_app" = "Esci da CodexBar";
+
+/* Tab titles */
+"tab_general" = "Generale";
+"tab_providers" = "Provider";
+"tab_display" = "Aspetto";
+"tab_advanced" = "Avanzate";
+"tab_about" = "Informazioni";
+"tab_debug" = "Diagnostica";
+
+/* Providers Pane */
+"select_a_provider" = "Seleziona un provider";
+"cancel" = "Annulla";
+"last_fetch_failed" = "ultimo recupero fallito";
+"usage_not_fetched_yet" = "utilizzo non ancora recuperato";
+"managed_account_storage_unreadable" = "L'archivio degli account gestiti non è leggibile. L'accesso account live è ancora disponibile, ma aggiunta, re-autenticazione e rimozione degli account gestiti sono disabilitate finché l'archivio non viene ripristinato.";
+"remove_codex_account_title" = "Rimuovere account Codex?";
+"remove" = "Rimuovi";
+"managed_login_already_running" = "È già in corso un accesso gestito a Codex. Attendi che termini prima di aggiungere o riautenticare un altro account.";
+"managed_login_failed" = "L'accesso gestito a Codex non è stato completato. Verifica che `codex --version` funzioni in Terminale. Se macOS ha bloccato `codex` o lo ha spostato nel Cestino, rimuovi le installazioni duplicate obsolete, esegui `npm install -g --include=optional @openai/codex@latest`, poi riprova.";
+"codex_login_output" = "output di codex login:";
+"managed_login_missing_email" = "L'accesso Codex è stato completato, ma nessuna email account era disponibile. Riprova dopo aver verificato che l'account sia completamente autenticato.";
+"login_success_notification_title" = "Accesso %@ riuscito";
+"login_success_notification_body" = "Puoi tornare all'app; l'autenticazione è terminata.";
+"workspace_selection_cancelled" = "CodexBar ha trovato più workspace, ma non ne è stato selezionato nessuno.";
+"unsafe_managed_home" = "CodexBar ha rifiutato di modificare un percorso home gestito inatteso: %@";
+"menu_bar_metric_title" = "Metrica barra menu";
+"menu_bar_metric_subtitle" = "Scegli quale finestra guida la percentuale nella barra menu.";
+"menu_bar_metric_subtitle_deepseek" = "Mostra il saldo DeepSeek nella barra menu.";
+"menu_bar_metric_subtitle_moonshot" = "Mostra il saldo API Moonshot / Kimi nella barra menu.";
+"menu_bar_metric_subtitle_mistral" = "Mostra la spesa API Mistral del mese corrente nella barra menu.";
+"menu_bar_metric_subtitle_kimik2" = "Mostra i crediti della chiave API Kimi K2 nella barra menu.";
+"automatic" = "Automatico";
+"primary_api_key_limit" = "Principale (limite chiave API)";
+
+/* Display Pane */
+"section_menu_bar" = "Barra menu";
+"merge_icons_title" = "Unisci icone";
+"merge_icons_subtitle" = "Usa un'unica icona nella barra menu con selettore provider.";
+"switcher_shows_icons_title" = "Selettore con icone";
+"switcher_shows_icons_subtitle" = "Mostra le icone provider nel selettore (altrimenti mostra una linea di progresso settimanale).";
+"show_most_used_provider_title" = "Mostra provider più usato";
+"show_most_used_provider_subtitle" = "La barra menu mostra automaticamente il provider più vicino al limite.";
+"menu_bar_shows_percent_title" = "Mostra percentuale nella barra menu";
+"menu_bar_shows_percent_subtitle" = "Sostituisce le barre con icone provider e percentuale.";
+"hide_critters_title" = "Nascondi creature";
+"hide_critters_subtitle" = "Mostra barre semplici senza volto e decorazioni.";
+"display_mode_title" = "Modalità visualizzazione";
+"display_mode_subtitle" = "Scegli cosa mostrare nella barra menu (Andamento confronta utilizzo e atteso).";
+"section_menu_content" = "Contenuto menu";
+"show_usage_as_used_title" = "Mostra utilizzo come consumato";
+"show_usage_as_used_subtitle" = "Le barre si riempiono man mano che consumi quota (anziché mostrare il residuo).";
+"show_quota_warning_markers_title" = "Mostra indicatori avviso quota";
+"show_quota_warning_markers_subtitle" = "Disegna tacche soglia sulle barre quando gli avvisi quota sono configurati.";
+"weekly_progress_work_days_title" = "Giorni lavorativi progresso settimanale";
+"weekly_progress_work_days_subtitle" = "Disegna i confini giornalieri sulle barre settimanali.";
+"show_reset_time_as_clock_title" = "Mostra reset come orario";
+"show_reset_time_as_clock_subtitle" = "Mostra i reset come orari assoluti invece del conto alla rovescia.";
+"show_provider_changelog_links_title" = "Mostra link changelog provider";
+"show_provider_changelog_links_subtitle" = "Aggiunge link alle note di rilascio per i provider CLI supportati.";
+"show_credits_extra_usage_title" = "Mostra crediti + uso extra";
+"show_credits_extra_usage_subtitle" = "Mostra nel menu le sezioni Crediti Codex e Uso extra Claude.";
+"show_all_token_accounts_title" = "Mostra tutti gli account token";
+"show_all_token_accounts_subtitle" = "Impila gli account token nel menu (altrimenti mostra una barra di cambio account).";
+"multi_account_layout_title" = "Layout multi-account";
+"multi_account_layout_subtitle" = "Scegli tra selezione segmentata o schede account impilate.";
+"multi_account_layout_segmented" = "Segmentato";
+"multi_account_layout_stacked" = "Impilato";
+"overview_tab_providers_title" = "Provider della scheda Panoramica";
+"configure" = "Configura…";
+"overview_enable_merge_icons_hint" = "Abilita Unisci icone per configurare i provider della scheda Panoramica.";
+"overview_no_providers_hint" = "Nessun provider attivo disponibile per Panoramica.";
+"overview_rows_follow_order" = "Le righe Panoramica seguono sempre l'ordine dei provider.";
+"overview_no_providers_selected" = "Nessun provider selezionato";
+
+/* Advanced Pane */
+"section_keyboard_shortcut" = "Scorciatoia tastiera";
+"open_menu_shortcut_title" = "Apri menu";
+"open_menu_shortcut_subtitle" = "Attiva il menu della barra da qualsiasi punto.";
+"install_cli" = "Installa CLI";
+"install_cli_subtitle" = "Crea il symlink di CodexBarCLI in /usr/local/bin e /opt/homebrew/bin come codexbar.";
+"cli_not_found" = "CodexBarCLI non trovato nel bundle dell'app.";
+"no_writable_bin_dirs" = "Nessuna directory bin scrivibile trovata.";
+"show_debug_settings_title" = "Mostra impostazioni debug";
+"show_debug_settings_subtitle" = "Espone strumenti di diagnosi nella scheda Debug.";
+"surprise_me_title" = "Sorprendimi";
+"surprise_me_subtitle" = "Per chi apprezza un po' di personalità dagli agenti.";
+"weekly_limit_confetti_title" = "Coriandoli limite settimanale";
+"weekly_limit_confetti_subtitle" = "Mostra coriandoli a schermo intero quando la quota settimanale si resetta.";
+"hide_personal_info_title" = "Nascondi informazioni personali";
+"hide_personal_info_subtitle" = "Oscura gli indirizzi email nella barra menu e nell'interfaccia menu.";
+"show_provider_storage_usage_title" = "Mostra spazio usato dai provider";
+"show_provider_storage_usage_subtitle" = "Mostra l'uso disco locale nei menu. Scansiona in background i percorsi dei provider.";
+"section_keychain_access" = "Accesso Portachiavi";
+"keychain_access_caption" = "Disattiva tutte le letture e scritture del Portachiavi. Usalo se macOS continua a chiedere accesso a 'Chrome/Brave/Edge Safe Storage' anche dopo aver scelto Consenti sempre. Quando è attivo, l'importazione dei cookie dal browser non è disponibile; incolla manualmente gli header Cookie in Provider. L'OAuth di Claude/Codex tramite CLI continua a funzionare.";
+"disable_keychain_access_title" = "Disattiva accesso Portachiavi";
+"disable_keychain_access_subtitle" = "Impedisce qualsiasi accesso al Portachiavi quando attivo.";
+
+/* About Pane */
+"about_tagline" = "Che i tuoi token non finiscano mai: tieni sempre sotto controllo i limiti degli agenti.";
+"link_github" = "GitHub";
+"link_website" = "Sito web";
+"link_twitter" = "X";
+"link_email" = "Email";
+"check_updates_auto" = "Controlla automaticamente gli aggiornamenti";
+"update_channel" = "Canale aggiornamenti";
+"check_for_updates" = "Controlla aggiornamenti…";
+"updates_unavailable" = "Aggiornamenti non disponibili in questa build.";
+"copyright" = "© 2026 Peter Steinberger. Licenza MIT.";
+
+/* Debug Pane */
+"section_logging" = "Log";
+"enable_file_logging" = "Abilita log su file";
+"enable_file_logging_subtitle" = "Scrive i log in %@ per il debug.";
+"verbosity_title" = "Verbosità";
+"verbosity_subtitle" = "Controlla quanto dettaglio viene registrato nei log.";
+"open_log_file" = "Apri file di log";
+"force_animation_next_refresh" = "Forza animazione al prossimo aggiornamento";
+"force_animation_next_refresh_subtitle" = "Mostra temporaneamente l'animazione di caricamento dopo il prossimo aggiornamento.";
+"section_loading_animations" = "Animazioni di caricamento";
+"loading_animations_caption" = "Scegli un pattern e riproducilo nella barra menu. \"Casuale\" mantiene il comportamento esistente.";
+"animation_random_default" = "Casuale (predefinito)";
+"replay_selected_animation" = "Riproduci animazione selezionata";
+"blink_now" = "Lampeggia ora";
+"section_probe_logs" = "Log probe";
+"probe_logs_caption" = "Recupera l'ultimo output del probe per il debug; Copia mantiene il testo completo.";
+"fetch_log" = "Recupera log";
+"copy" = "Copia";
+"save_to_file" = "Salva su file";
+"load_parse_dump" = "Carica dump di parsing";
+"rerun_provider_autodetect" = "Riesegui rilevamento automatico provider";
+"loading" = "Caricamento…";
+"no_log_yet_fetch" = "Nessun log ancora. Recupera per caricare.";
+"section_fetch_strategy" = "Tentativi strategia di recupero";
+"fetch_strategy_caption" = "Ultime decisioni ed errori della pipeline di recupero per un provider.";
+"section_openai_cookies" = "Cookie OpenAI";
+"openai_cookies_caption" = "Importazione cookie + log di scraping WebKit dall'ultimo tentativo cookie OpenAI.";
+"no_log_yet" = "Nessun log ancora. Aggiorna i cookie OpenAI in Provider → Codex per avviare un'importazione.";
+"section_caches" = "Cache";
+"caches_caption" = "Cancella i risultati memorizzati delle scansioni costi o le cache dei cookie del browser.";
+"clear_cookie_cache" = "Svuota cache cookie";
+"clear_cost_cache" = "Svuota cache costi";
+"section_notifications" = "Notifiche";
+"notifications_caption" = "Attiva notifiche di test per la finestra di sessione di 5 ore (esaurita/ripristinata).";
+"post_depleted" = "Invia notifica esaurita";
+"post_restored" = "Invia notifica ripristinata";
+"section_cli_sessions" = "Sessioni CLI";
+"cli_sessions_caption" = "Mantieni attive le sessioni CLI di Codex/Claude dopo un probe. Per impostazione predefinita si chiudono dopo aver raccolto i dati.";
+"keep_cli_sessions_alive" = "Mantieni attive le sessioni CLI";
+"keep_cli_sessions_alive_subtitle" = "Salta il teardown tra i probe (solo debug).";
+"reset_cli_sessions" = "Reimposta sessioni CLI";
+"section_error_simulation" = "Simulazione errori";
+"error_simulation_caption" = "Inserisce un messaggio di errore fittizio nella scheda menu per testare il layout.";
+"set_menu_error" = "Imposta errore del menu";
+"clear_menu_error" = "Cancella errore del menu";
+"set_cost_error" = "Imposta errore dei costi";
+"clear_cost_error" = "Cancella errore dei costi";
+"section_cli_paths" = "Percorsi CLI";
+"cli_paths_caption" = "Binario Codex e livelli PATH risolti; acquisizione del PATH della shell di login all'avvio (timeout breve).";
+"codex_binary" = "Binario Codex";
+"claude_binary" = "Binario Claude";
+"effective_path" = "PATH effettivo";
+"unavailable" = "Non disponibile";
+"login_shell_path" = "PATH della shell di login (cattura all'avvio)";
+"cleared" = "Cancellato.";
+"no_fetch_attempts" = "Nessun tentativo di recupero ancora.";
+"macOS Tahoe can block menu bar apps in System Settings → Menu Bar → Allow in the Menu Bar. CodexBar is running, but macOS may be hiding its icon. Open Menu Bar settings and turn CodexBar on." = "macOS Tahoe può bloccare le app della barra menu in Impostazioni di Sistema → Barra menu → Consenti nella barra menu. CodexBar è in esecuzione, ma macOS potrebbe nasconderne l'icona. Apri le impostazioni della barra menu e attiva CodexBar.";
+
+/* Metric preferences */
+"metric_pref_automatic" = "Automatico";
+"metric_pref_primary" = "Principale";
+"metric_pref_secondary" = "Secondario";
+"metric_pref_tertiary" = "Terziario";
+"metric_pref_extra_usage" = "Uso extra";
+"metric_pref_average" = "Media";
+"metric_mistral_payg" = "A consumo";
+"metric_mistral_monthly_plan" = "Piano mensile";
+
+/* Display modes */
+"display_mode_percent" = "Percentuale";
+"display_mode_pace" = "Andamento";
+"display_mode_both" = "Entrambi";
+"display_mode_reset_time" = "Ora di reimpostazione";
+"display_mode_percent_desc" = "Mostra percentuale residua/consumata (es. 45%)";
+"display_mode_pace_desc" = "Mostra indicatore andamento (es. +5%)";
+"display_mode_both_desc" = "Mostra percentuale e andamento (es. 45% · +5%)";
+"display_mode_reset_time_desc" = "Mostra l'ora di reimpostazione per la metrica selezionata (es. ↻ 15:56)";
+
+/* Provider status */
+"status_operational" = "Operativo";
+"status_partial_outage" = "Interruzione parziale";
+"status_major_outage" = "Interruzione grave";
+"status_critical_issue" = "Problema critico";
+"status_maintenance" = "Manutenzione";
+"status_unknown" = "Stato sconosciuto";
+
+/* Refresh frequency */
+"refresh_manual" = "Manuale";
+"refresh_1min" = "1 min.";
+"refresh_2min" = "2 min.";
+"refresh_5min" = "5 min.";
+"refresh_15min" = "15 min.";
+"refresh_30min" = "30 min.";
+
+/* Additional keys */
+"not_found" = "Non trovato";
+
+/* Cost estimation */
+"cost_header_estimated" = "Costo (stimato)";
+"cost_estimate_hint" = "Stimato dai log locali · può differire dalla fattura";
+"No JetBrains IDE with AI Assistant detected. Install a JetBrains IDE and enable AI Assistant." = "Nessun IDE JetBrains con AI Assistant rilevato. Installa un IDE JetBrains e abilita AI Assistant.";
+"OpenRouter API token not configured. Set OPENROUTER_API_KEY environment variable or configure in Settings." = "Token API OpenRouter non configurato. Imposta la variabile d'ambiente OPENROUTER_API_KEY oppure configuralo nelle Impostazioni.";
+"z.ai API token not found. Set apiKey in ~/.codexbar/config.json or Z_AI_API_KEY." = "Token API z.ai non trovato. Imposta apiKey in ~/.codexbar/config.json o Z_AI_API_KEY.";
+"Missing DeepSeek API key." = "Chiave API DeepSeek mancante.";
+"%@ is unavailable in the current environment." = "%@ non è disponibile nell'ambiente corrente.";
+"All Systems Operational" = "Tutti i sistemi sono operativi";
+"Last 30 days" = "Ultimi 30 giorni";
+"Last 30 days:" = "Ultimi 30 giorni:";
+"This month" = "Questo mese";
+"Store multiple OpenAI API keys." = "Memorizza più chiavi API OpenAI.";
+"Admin API key" = "Chiave API admin";
+"Open billing" = "Apri fatturazione";
+"Google accounts" = "Account Google";
+"Store multiple Antigravity Google OAuth accounts for quick switching." = "Memorizza più account Google OAuth di Antigravity per un cambio rapido.";
+"Add Google Account" = "Aggiungi account Google";
+"Open Token Plan" = "Apri Token Plan";
+"Text Generation" = "Generazione testo";
+"Text to Speech" = "Sintesi vocale";
+"Music Generation" = "Generazione musica";
+"Image Generation" = "Generazione immagini";
+"No local data found" = "Nessun dato locale trovato";
+"Credits unavailable; keep Codex running to refresh." = "Crediti non disponibili; lascia Codex in esecuzione per aggiornare.";
+"No available fetch strategy for minimax." = "Nessuna strategia di recupero disponibile per minimax.";
+"No Cursor session found. Please log in to cursor.com in Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX, or Edge Canary. If you use Safari, grant CodexBar Full Disk Access in System Settings ▸ Privacy & Security. You can also sign in to Cursor from the CodexBar menu (Add / switch account)." = "Nessuna sessione Cursor trovata. Accedi a cursor.com in Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX o Edge Canary. Se usi Safari, concedi a CodexBar l'accesso completo al disco in Impostazioni di Sistema ▸ Privacy e sicurezza. Puoi anche accedere a Cursor dal menu di CodexBar (Aggiungi / cambia account).";
+"No OpenCode session cookies found in browsers." = "Nessun cookie di sessione OpenCode trovato nei browser.";
+"No available fetch strategy for %@." = "Nessuna strategia di recupero disponibile per %@.";
+"Today" = "Oggi";
+"Today tokens" = "Token di oggi";
+"30d cost" = "Costo 30 g";
+"30d tokens" = "Token 30 g";
+"Latest tokens" = "Token recenti";
+"Top model" = "Modello principale";
+"Storage" = "Archiviazione";
+"Add Account..." = "Aggiungi account...";
+"Usage Dashboard" = "Dashboard utilizzo";
+"Status Page" = "Pagina di stato";
+"Settings..." = "Impostazioni...";
+"About CodexBar" = "Informazioni su CodexBar";
+"Quit" = "Esci";
+"Last %d day" = "Ultimo %d giorno";
+"Last %d days" = "Ultimi %d giorni";
+"%@ tokens" = "%@ token";
+"Latest billing day" = "Ultimo giorno di fatturazione";
+"Latest billing day (%@)" = "Ultimo giorno di fatturazione (%@)";
+"%@ left" = "%@ rimasto";
+"Resets %@" = "Si resetta %@";
+"Resets in %@" = "Si reimposta tra %@";
+"Resets now" = "Si resetta ora";
+"reset_tomorrow_format" = "domani, %@";
+"Lasts until reset" = "Valido fino al reset";
+"Updated %@" = "Aggiornato %@";
+"Updated %@h ago" = "Aggiornato %@ h fa";
+"Updated %@m ago" = "Aggiornato %@ min fa";
+"Updated just now" = "Aggiornato ora";
+"Projected empty in %@" = "Esaurimento previsto tra %@";
+"Runs out in %@" = "Si esaurisce tra %@";
+"Pace: %@" = "Andamento: %@";
+"Pace: %@ · %@" = "Andamento: %@ · %@";
+"%@ · %@" = "%@ • %@";
+"≈ %d%% run-out risk" = "≈ %d%% rischio di esaurimento";
+"%d%% in deficit" = "deficit del %d%%";
+"%d%% in reserve" = "%d%% di riserva";
+"usage_percent_suffix_left" = "rimasto";
+"usage_percent_suffix_used" = "usato";
+"Store multiple DeepSeek API keys." = "Memorizza più chiavi API DeepSeek.";
+"This week" = "Questa settimana";
+"Week" = "Settimana";
+"Month" = "Mese";
+"Models" = "Modelli";
+"24h tokens" = "Token 24h";
+"Latest hour" = "Ultima ora";
+"Peak hour" = "Ora di picco";
+"Top method" = "Metodo principale";
+"30d cash" = "Spesa 30 g";
+"30d billing history from MiniMax web session" = "Cronologia di fatturazione degli ultimi 30 giorni dalla sessione web MiniMax";
+"AWS Cost Explorer billing can lag." = "La fatturazione di AWS Cost Explorer può avere ritardi.";
+"Rate limit: %d / %@" = "Limite di richiesta: %d / %@";
+"Key remaining" = "Residuo chiave";
+"No limit set for the API key" = "Nessun limite impostato per la chiave API";
+"API key limit unavailable right now" = "Limite della chiave API non disponibile al momento";
+"This month: %@ tokens" = "Questo mese: %@ token";
+"No utilization data yet." = "Nessun dato di utilizzo ancora disponibile.";
+"No %@ utilization data yet." = "Nessun dato di utilizzo %@ ancora disponibile.";
+"%@: %@%% used" = "%@: %@%% usato";
+"%dd" = "%d g";
+"today" = "oggi";
+"just now" = "proprio ora";
+"On pace" = "In linea";
+"Runs out now" = "Si esaurisce ora";
+"Projected empty now" = "Esaurimento previsto ora";
+"Switch Account..." = "Cambia account...";
+"Update ready, restart now?" = "Aggiornamento pronto, riavviare ora?";
+"Daily" = "Giornaliero";
+"Hourly Tokens" = "Token orari";
+"No data" = "Nessun dato";
+"No usage breakdown data available." = "Nessun dato di dettaglio utilizzo disponibile.";
+
+"Today: %@ · %@ tokens" = "Oggi: %@ · %@ token";
+"Today: %@" = "Oggi: %@";
+"Today: %@ tokens" = "Oggi: %@ token";
+"Last 30 days: %@ · %@ tokens" = "Ultimi 30 giorni: %@ · %@ token";
+"Last 30 days: %@" = "Ultimi 30 giorni: %@";
+"Est. total (30d): %@" = "Totale stimato (30 g): %@";
+"Est. total (%@): %@" = "Totale stimato (%@): %@";
+"Hover a bar for details" = "Passa il mouse su una barra per i dettagli";
+"%@: %@ · %@ tokens" = "%@: %@ • %@ token";
+"No providers selected for Overview." = "Nessun provider selezionato per Panoramica.";
+"No overview data available." = "Nessun dato di panoramica disponibile.";
+"Auto uses the local IDE API first, then Google OAuth when the IDE is closed." = "Auto usa prima l'API IDE locale, poi Google OAuth quando l'IDE è chiuso.";
+"Login with Google" = "Accedi con Google";
+
+/* Popup panels */
+"No usage configured." = "Nessun utilizzo configurato.";
+"Quota" = "Limite";
+"tokens" = "token";
+"requests" = "richieste";
+"Latest" = "Più recente";
+"Monthly" = "Mensile";
+"Sonnet" = "Claude Sonnet";
+"Overages" = "Eccedenze";
+"Activity" = "Attività";
+"Copied" = "Copiato";
+"Copy error" = "Errore di copia";
+"Copy path" = "Copia percorso";
+"Extra usage spent" = "Uso extra speso";
+"Credits remaining" = "Crediti rimanenti";
+"Using CLI fallback" = "Uso del fallback CLI";
+"Balance updates in near-real time (up to 5 min lag)" = "Il saldo si aggiorna quasi in tempo reale (ritardo fino a 5 min)";
+"Daily billing data finalizes at 07:00 UTC" = "I dati giornalieri di fatturazione si consolidano alle 07:00 UTC";
+"%@ of %@ credits left" = "%@ di %@ crediti rimasti";
+"%@ of %@ bonus credits left" = "%@ di %@ crediti bonus rimasti";
+"%@ / %@ (%@ remaining)" = "%@ / %@ (%@ rimanenti)";
+"%@/%@ left" = "%@/%@ rimasti";
+"Gemini Flash" = "Gemini Flash";
+"Regenerates %@" = "Si rigenera %@";
+"used after next regen" = "usato dopo la prossima rigenerazione";
+"after next regen" = "dopo la prossima rigenerazione";
+"Near full" = "Quasi pieno";
+"Full in ~1 regen" = "Pieno tra ~1 rigenerazione";
+"Full in ~%.0f regens" = "Pieno tra ~%.0f rigenerazioni";
+"Overage usage" = "Utilizzo in eccedenza";
+"Overage cost" = "Costo eccedenza";
+"credits" = "crediti";
+"Zen balance" = "Saldo Zen";
+"API spend" = "Spesa API";
+"Extra usage" = "Utilizzo extra";
+"Quota usage" = "Utilizzo quota";
+"Your spend" = "La tua spesa";
+"%.0f%% used" = "%.0f%% usato";
+"Usage history (today)" = "Cronologia utilizzo (oggi)";
+"Usage history (%d days)" = "Cronologia utilizzo (%d giorni)";
+"%d percent remaining" = "%d percento rimanente";
+"Unknown" = "Sconosciuto";
+"stale data" = "dati obsoleti";
+"No credits history data." = "Nessun dato storico crediti.";
+"No credits history data available." = "Nessun dato storico crediti disponibile.";
+"Credits history chart" = "Grafico storico crediti";
+"%d days of credits data" = "%d giorni di dati crediti";
+"Usage breakdown chart" = "Grafico dettaglio utilizzo";
+"%d days of usage data across %d services" = "%d giorni di dati di utilizzo su %d servizi";
+"Cost history chart" = "Grafico storico costi";
+"%d days of cost data" = "%d giorni di dati costi";
+"Plan utilization chart" = "Grafico utilizzo piano";
+"%d utilization samples" = "%d campioni di utilizzo";
+"Hourly Usage" = "Utilizzo orario";
+"Usage remaining" = "Utilizzo rimanente";
+"Usage used" = "Utilizzo consumato";
+"API key verified. Ollama does not expose Cloud quota limits through the API." = "Chiave API verificata. Ollama non espone i limiti di quota Cloud tramite API.";
+"Last 30 days: %@ tokens" = "Ultimi 30 giorni: %@ token";
+"7d spend" = "Spesa 7 g";
+"30d spend" = "Spesa 30 g";
+"Cache read" = "Lettura cache";
+"Claude Admin API 30 day spend trend" = "Trend spesa 30 giorni Claude Admin API";
+"OpenRouter API key spend trend" = "Trend spesa chiave API OpenRouter";
+"z.ai hourly token trend" = "Trend orario token z.ai";
+"MiniMax 30 day token usage trend" = "Trend utilizzo token 30 giorni MiniMax";
+"Today cash" = "Spesa di oggi";
+"DeepSeek 30 day token usage trend" = "Trend utilizzo token 30 giorni DeepSeek";
+"cache-hit input" = "input cache-hit";
+"cache-miss input" = "input cache-miss";
+"output" = "uscita";
+"Requests" = "Richieste";
+"Reported by OpenAI Admin API organization usage." = "Segnalato dall'utilizzo dell'organizzazione OpenAI Admin API.";
+"Reported by Mistral billing usage." = "Segnalato dall'utilizzo di fatturazione Mistral.";
+"Google OAuth" = "Google OAuth";
+"Add accounts via GitHub OAuth Device Flow on the selected host." = "Aggiungi account tramite GitHub OAuth Device Flow sull'host selezionato.";
+"Stores each signed-in Google account for quick Antigravity switching. Uses Antigravity.app OAuth when available, or ANTIGRAVITY_OAUTH_CLIENT_ID and ANTIGRAVITY_OAUTH_CLIENT_SECRET as an override." = "Memorizza ogni account Google connesso per un rapido cambio Antigravity. Usa l'OAuth di Antigravity.app quando disponibile, oppure ANTIGRAVITY_OAUTH_CLIENT_ID e ANTIGRAVITY_OAUTH_CLIENT_SECRET come override.";
+"Manual cleanup: past sessions" = "Pulizia manuale: sessioni passate";
+"Clearing removes past resume, continue, and rewind history." = "La cancellazione rimuove la cronologia passata di riprendi, continua e rewind.";
+"Manual cleanup: file checkpoints" = "Pulizia manuale: checkpoint dei file";
+"Clearing removes checkpoint restore data for previous edits." = "La cancellazione rimuove i dati di ripristino dei checkpoint per le modifiche precedenti.";
+"Manual cleanup: saved plans" = "Pulizia manuale: piani salvati";
+"Clearing removes old plan-mode files." = "La cancellazione rimuove i vecchi file della modalità piano.";
+"Manual cleanup: debug logs" = "Pulizia manuale: log di debug";
+"Clearing removes past debug logs." = "La cancellazione rimuove i log di debug passati.";
+"Manual cleanup: attachment cache" = "Pulizia manuale: cache allegati";
+"Clearing removes cached large pastes or attached images." = "La cancellazione rimuove grandi incolli memorizzati o immagini allegate.";
+"Manual cleanup: session metadata" = "Pulizia manuale: metadati sessione";
+"Clearing removes per-session environment metadata." = "La cancellazione rimuove i metadati dell'ambiente per sessione.";
+"Manual cleanup: shell snapshots" = "Pulizia manuale: snapshot della shell";
+"Clearing removes leftover runtime shell snapshot files." = "La cancellazione rimuove i file snapshot della shell rimasti in esecuzione.";
+"Manual cleanup: legacy todos" = "Pulizia manuale: todo legacy";
+"Clearing removes legacy per-session task lists." = "La cancellazione rimuove i vecchi elenchi attività per sessione.";
+"Manual cleanup: sessions" = "Pulizia manuale: sessioni";
+"Clearing removes past Codex session history." = "La cancellazione rimuove la cronologia delle sessioni Codex passate.";
+"Manual cleanup: archived sessions" = "Pulizia manuale: sessioni archiviate";
+"Clearing removes archived Codex session history." = "La cancellazione rimuove la cronologia delle sessioni Codex archiviate.";
+"Manual cleanup: cache" = "Pulizia manuale: cache";
+"Clearing removes provider-owned cached data." = "La cancellazione rimuove i dati memorizzati appartenenti ai provider.";
+"Manual cleanup: logs" = "Pulizia manuale: log";
+"Clearing removes local diagnostic logs." = "La cancellazione rimuove i log diagnostici locali.";
+"Manual cleanup: file history" = "Pulizia manuale: cronologia file";
+"Clearing removes local edit checkpoint history." = "La cancellazione rimuove la cronologia locale dei checkpoint di modifica.";
+"Manual cleanup: temporary data" = "Pulizia manuale: dati temporanei";
+"Clearing removes local temporary provider data." = "La cancellazione rimuove i dati temporanei locali dei provider.";
+"Total: %@" = "Totale: %@";
+"%d more items" = "%d elementi in più";
+"Other (%d items)" = "Altro (%d elementi)";
+"Expand" = "Espandi";
+"Collapse" = "Comprimi";
+"Cleanup ideas" = "Idee di pulizia";
+"%d unreadable item(s) skipped" = "Saltati %d elemento/i illeggibili";
+
+"API key limit" = "Limite chiave API";
+"Auth" = "Autenticazione";
+"Auto" = "Automatico";
+"Disabled — no recent data" = "Disattivato — nessun dato recente";
+"Limits not available" = "Limiti non disponibili";
+"No usage yet" = "Nessun utilizzo";
+"Not fetched yet" = "Non ancora recuperato";
+"Refreshing" = "Aggiornamento in corso";
+"Session" = "Sessione";
+"Source" = "Origine";
+"State" = "Stato";
+"Unavailable" = "Non disponibile";
+"Weekly" = "Settimanale";
+"not detected" = "non rilevato";
+"Estimated from local Codex logs for the selected account." = "Stima basata sui log locali di Codex per l'account selezionato.";
+"minimax_usage_amount_format" = "Utilizzo: %@ / %@";
+"minimax_used_percent_format" = "Usato %@";
+"minimax_service_text_generation" = "Generazione testo";
+"minimax_service_text_to_speech" = "Sintesi vocale";
+"minimax_service_music_generation" = "Generazione musica";
+"minimax_service_image_generation" = "Generazione immagini";
+"minimax_service_lyrics_generation" = "Generazione testi";
+"minimax_service_coding_plan_vlm" = "Piano di coding VLM";
+"minimax_service_coding_plan_search" = "Ricerca coding plan";
+
+/* Additional provider settings and alerts */
+"%@ is waiting for permission" = "%@ è in attesa di autorizzazione";
+"%@ requests" = "%@ richieste";
+"%@: %@ credits" = "%@: %@ crediti";
+"30d requests" = "Richieste 30 g";
+"4 days" = "4 giorni";
+"5 days" = "5 giorni";
+"7 days" = "7 giorni";
+"API key verifies Ollama Cloud access; cookies still expose quota limits." = "La chiave API verifica l'accesso a Ollama Cloud; i cookie espongono comunque i limiti di quota.";
+"AWS access key ID. Can also be set with AWS_ACCESS_KEY_ID." = "ID chiave di accesso AWS. Può anche essere impostato con AWS_ACCESS_KEY_ID.";
+"AWS region. Can also be set with AWS_REGION." = "Regione AWS. Può anche essere impostata con AWS_REGION.";
+"AWS secret access key. Can also be set with AWS_SECRET_ACCESS_KEY." = "Chiave segreta di accesso AWS. Può anche essere impostata con AWS_SECRET_ACCESS_KEY.";
+"Access key ID" = "ID chiave di accesso";
+"Add Account" = "Aggiungi account";
+"Adding Account…" = "Aggiunta account…";
+"Antigravity login failed" = "Accesso Antigravity non riuscito";
+"Antigravity login timed out" = "Timeout durante l'accesso Antigravity";
+"Auth source" = "Fonte autenticazione";
+"Automatic imports browser cookies from Xiaomi MiMo." = "Importa automaticamente i cookie del browser da Xiaomi MiMo.";
+"Automatic imports Windsurf session data from Chromium browser localStorage." = "Importa automaticamente i dati di sessione Windsurf dal localStorage del browser Chromium.";
+"Automatic imports browser cookies from Bailian." = "Importa automaticamente i cookie del browser da Bailian.";
+"Automatically imports browser cookies." = "Importa automaticamente i cookie del browser.";
+"Automatically imports browser session cookies." = "Importa automaticamente i cookie di sessione del browser.";
+"Azure OpenAI deployment name. AZURE_OPENAI_DEPLOYMENT_NAME is also supported." = "Nome del deployment Azure OpenAI. È supportato anche AZURE_OPENAI_DEPLOYMENT_NAME.";
+"Azure OpenAI key" = "Chiave Azure OpenAI";
+"Azure OpenAI resource endpoint. AZURE_OPENAI_ENDPOINT is also supported." = "Endpoint della risorsa Azure OpenAI. È supportato anche AZURE_OPENAI_ENDPOINT.";
+"Base URL" = "URL di base";
+"Base URL for the LLM-API-Key-Proxy instance." = "URL di base dell'istanza LLM-API-Key-Proxy.";
+"Browser cookies" = "Cookie browser";
+"Cap end" = "Fine tetto";
+"Cap start" = "Inizio tetto";
+"Capacity End" = "Fine capacità";
+"Capacity Start" = "Inizio capacità";
+"Changelog" = "Registro modifiche";
+"Choose the Moonshot/Kimi API host for international or China mainland accounts." = "Scegli l'host API Moonshot/Kimi per account internazionali o della Cina continentale.";
+"CodexBar can't replace a system account that is signed in with an API key only setup." = "CodexBar non può sostituire un account di sistema autenticato solo tramite configurazione con chiave API.";
+"CodexBar could not find saved auth for that account. Re-authenticate it and try again." = "CodexBar non ha trovato l'autenticazione salvata per quell'account. Ri-autenticati e riprova.";
+"CodexBar could not read managed account storage. Recover the store before adding another account." = "CodexBar non è riuscito a leggere l'archivio degli account gestiti. Ripristinalo prima di aggiungere un altro account.";
+"CodexBar could not read saved auth for that account. Re-authenticate it and try again." = "CodexBar non è riuscito a leggere l'autenticazione salvata per quell'account. Ri-autenticati e riprova.";
+"CodexBar could not read the current system account on this Mac." = "CodexBar non è riuscito a leggere l'account di sistema corrente su questo Mac.";
+"CodexBar could not replace the live Codex auth on this Mac." = "CodexBar non è riuscito a sostituire l'autenticazione Codex attiva su questo Mac.";
+"CodexBar could not safely preserve the current system account before switching." = "CodexBar non è riuscito a conservare in sicurezza l'account di sistema corrente prima del cambio.";
+"CodexBar could not save the current system account before switching." = "CodexBar non è riuscito a salvare l'account di sistema corrente prima del cambio.";
+"CodexBar could not update managed account storage." = "CodexBar non è riuscito ad aggiornare l'archivio degli account gestiti.";
+"CodexBar found another managed account that already uses the current system account. Resolve the duplicate account before switching." = "CodexBar ha trovato un altro account gestito che usa già l'account di sistema corrente. Risolvi il duplicato prima di cambiare.";
+"CodexBar will ask macOS Keychain for “%@” so it can decrypt browser cookies and authenticate your account. Click OK to continue." = "CodexBar chiederà al Portachiavi di macOS “%@” per poter decifrare i cookie del browser e autenticare il tuo account. Fai clic su OK per continuare.";
+"CodexBar will ask macOS Keychain for the Claude Code OAuth token so it can fetch your Claude usage. Click OK to continue." = "CodexBar chiederà al Portachiavi di macOS il token OAuth di Claude Code per recuperare il tuo utilizzo Claude. Fai clic su OK per continuare.";
+"CodexBar will ask macOS Keychain for your Amp cookie header so it can fetch usage. Click OK to continue." = "CodexBar chiederà al Portachiavi di macOS il tuo header Cookie di Amp per recuperare l'utilizzo. Fai clic su OK per continuare.";
+"CodexBar will ask macOS Keychain for your Augment cookie header so it can fetch usage. Click OK to continue." = "CodexBar chiederà al Portachiavi di macOS il tuo header Cookie di Augment per recuperare l'utilizzo. Fai clic su OK per continuare.";
+"CodexBar will ask macOS Keychain for your Claude cookie header so it can fetch Claude web usage. Click OK to continue." = "CodexBar chiederà al Portachiavi di macOS il tuo header Cookie di Claude per recuperare l'utilizzo web di Claude. Fai clic su OK per continuare.";
+"CodexBar will ask macOS Keychain for your Cursor cookie header so it can fetch usage. Click OK to continue." = "CodexBar chiederà al Portachiavi di macOS il tuo header Cookie di Cursor per recuperare l'utilizzo. Fai clic su OK per continuare.";
+"CodexBar will ask macOS Keychain for your Factory cookie header so it can fetch usage. Click OK to continue." = "CodexBar chiederà al Portachiavi di macOS il tuo header Cookie di Factory per recuperare l'utilizzo. Fai clic su OK per continuare.";
+"CodexBar will ask macOS Keychain for your GitHub Copilot token so it can fetch usage. Click OK to continue." = "CodexBar chiederà al Portachiavi di macOS il tuo token GitHub Copilot per recuperare l'utilizzo. Fai clic su OK per continuare.";
+"CodexBar will ask macOS Keychain for your Kimi K2 API key so it can fetch usage. Click OK to continue." = "CodexBar chiederà al Portachiavi di macOS la tua chiave API Kimi K2 per recuperare l'utilizzo. Fai clic su OK per continuare.";
+"CodexBar will ask macOS Keychain for your Kimi auth token so it can fetch usage. Click OK to continue." = "CodexBar chiederà al Portachiavi di macOS il tuo token di autenticazione Kimi per recuperare l'utilizzo. Fai clic su OK per continuare.";
+"CodexBar will ask macOS Keychain for your MiniMax API token so it can fetch usage. Click OK to continue." = "CodexBar chiederà al Portachiavi di macOS il tuo token API MiniMax per recuperare l'utilizzo. Fai clic su OK per continuare.";
+"CodexBar will ask macOS Keychain for your MiniMax cookie header so it can fetch usage. Click OK to continue." = "CodexBar chiederà al Portachiavi di macOS il tuo header Cookie di MiniMax per recuperare l'utilizzo. Fai clic su OK per continuare.";
+"CodexBar will ask macOS Keychain for your OpenAI cookie header so it can fetch Codex dashboard extras. Click OK to continue." = "CodexBar chiederà al Portachiavi di macOS il tuo header Cookie OpenAI per recuperare gli extra della dashboard Codex. Fai clic su OK per continuare.";
+"CodexBar will ask macOS Keychain for your OpenCode cookie header so it can fetch usage. Click OK to continue." = "CodexBar chiederà al Portachiavi di macOS il tuo header Cookie OpenCode per recuperare l'utilizzo. Fai clic su OK per continuare.";
+"CodexBar will ask macOS Keychain for your Synthetic API key so it can fetch usage. Click OK to continue." = "CodexBar chiederà al Portachiavi di macOS la tua chiave API Synthetic per recuperare l'utilizzo. Fai clic su OK per continuare.";
+"CodexBar will ask macOS Keychain for your z.ai API token so it can fetch usage. Click OK to continue." = "CodexBar chiederà al Portachiavi di macOS il tuo token API z.ai per recuperare l'utilizzo. Fai clic su OK per continuare.";
+"Could not open Cursor login in your browser." = "Impossibile aprire l'accesso Cursor nel browser.";
+"Could not open browser for Antigravity" = "Impossibile aprire il browser per Antigravity";
+"Credits used" = "Crediti usati";
+"Day" = "Giorno";
+"Deployment" = "Deployment";
+"Drag to reorder" = "Trascina per riordinare";
+"Sort providers alphabetically" = "Ordina i provider alfabeticamente";
+"Sort providers alphabetically (enabled first)" = "Ordina i provider alfabeticamente (prima quelli attivi)";
+"Sorted alphabetically (enabled first) — click to use your custom order" = "Ordinati alfabeticamente (prima quelli attivi) — fai clic per usare l’ordine personalizzato";
+"Endpoint" = "Endpoint";
+"Enterprise host" = "Host Enterprise";
+"Extra usage balance: %@" = "Saldo uso extra: %@";
+"Keychain Access Required" = "Accesso Portachiavi richiesto";
+"Kiro menu bar value" = "Valore barra menu Kiro";
+"Label" = "Etichetta";
+"No organizations loaded. Click Refresh after setting your API key." = "Nessuna organizzazione caricata. Fai clic su Aggiorna dopo aver impostato la chiave API.";
+"No output captured." = "Nessun output acquisito.";
+"No system account" = "Nessun account di sistema";
+"Oasis-Token" = "Oasis-Token";
+"Open Augment (Log Out & Back In)" = "Apri Augment (Esci e rientra)";
+"Open Codebuff Dashboard" = "Apri dashboard Codebuff";
+"Open Command Code Settings" = "Apri impostazioni Command Code";
+"Open Crof dashboard" = "Apri dashboard Crof";
+"Open Manus" = "Apri Manus";
+"Open MiMo Balance" = "Apri saldo MiMo";
+"Open Moonshot Console" = "Apri console Moonshot";
+"Open Ollama API Keys" = "Apri chiavi API Ollama";
+"Open StepFun Platform" = "Apri piattaforma StepFun";
+"Open T3 Chat Settings" = "Apri impostazioni T3 Chat";
+"Open Volcengine Ark Console" = "Apri console Volcengine Ark";
+"Open legacy provider docs" = "Apri documentazione provider legacy";
+"Open projects" = "Apri progetti";
+"Open this URL manually to continue login:\n\n%@" = "Apri manualmente questo URL per continuare l'accesso:\n\n%@";
+"Optional organization ID for accounts linked to multiple Anthropic organizations." = "ID organizzazione opzionale per account collegati a più organizzazioni Anthropic.";
+"Optional. Applies to the configured Admin API key; selected token accounts do not inherit OPENAI_PROJECT_ID." = "Opzionale. Si applica alla chiave API admin configurata; gli account token selezionati non ereditano OPENAI_PROJECT_ID.";
+"Optional. Enter your GitHub Enterprise host, for example octocorp.ghe.com. Leave blank for github.com." = "Opzionale. Inserisci il tuo host GitHub Enterprise, ad esempio octocorp.ghe.com. Lascia vuoto per github.com.";
+"Optional. Leave blank to discover and aggregate projects visible to the API key." = "Opzionale. Lascia vuoto per rilevare e aggregare i progetti visibili alla chiave API.";
+"Org ID (optional)" = "ID org (opzionale)";
+"Organizations" = "Organizzazioni";
+"Password" = "Password";
+"%@ authentication is disabled." = "L'autenticazione %@ è disabilitata.";
+"%@ cookies are disabled." = "I cookie %@ sono disabilitati.";
+"%@ web API access is disabled." = "L'accesso web API %@ è disabilitato.";
+"Disable %@ dashboard cookie usage." = "Disabilita l'uso dei cookie dashboard %@.";
+"Keychain access is disabled in Advanced, so browser cookie import is unavailable." = "L'accesso al portachiavi è disabilitato in Avanzate, quindi l'importazione dei cookie dal browser non è disponibile.";
+"Manually paste an %@ from a browser session." = "Incolla manualmente un %@ da una sessione del browser.";
+"Paste a Cookie header captured from %@." = "Incolla un header Cookie catturato da %@.";
+"Paste a Cookie header from %@." = "Incolla un header Cookie da %@.";
+"Paste a Cookie header or cURL capture from %@." = "Incolla un header Cookie o una cattura cURL da %@.";
+"Paste a Cookie header or full cURL capture from %@." = "Incolla un header Cookie o una cattura cURL completa da %@.";
+"Paste a Cookie or Authorization header from %@." = "Incolla un header Cookie o Authorization da %@.";
+"Paste a full cookie header or the %@ value." = "Incolla un header Cookie completo o il valore %@.";
+"Paste a Cookie header or full cURL capture from T3 Chat settings." = "Incolla un header Cookie o una cattura cURL completa dalle impostazioni di T3 Chat.";
+"Paste the Cookie header from a request to admin.mistral.ai. Must contain an ory_session_* cookie." = "Incolla l'header Cookie da una richiesta a admin.mistral.ai. Deve contenere un cookie ory_session_*.";
+"Paste the Oasis-Token from a logged-in browser session on platform.stepfun.com." = "Incolla l'Oasis-Token da una sessione browser autenticata su platform.stepfun.com.";
+"Paste the %@ JSON bundle from %@." = "Incolla il bundle JSON %@ da %@.";
+"Paste the %@ value or a full Cookie header." = "Incolla il valore %@ o un header Cookie completo.";
+"Personal account" = "Account personale";
+"Project ID" = "ID progetto";
+"Re-auth" = "Riautentica";
+"Re-login at claude.ai" = "Accedi di nuovo su claude.ai";
+"Re-authenticating…" = "Riautenticazione…";
+"Refresh Session" = "Aggiorna sessione";
+"Refresh organizations" = "Aggiorna organizzazioni";
+"Region" = "Regione";
+"Reload" = "Ricarica";
+"Reorder" = "Riordina";
+"Secret access key" = "Chiave di accesso segreta";
+"Series" = "Serie";
+"Service" = "Servizio";
+"Show or hide Kiro credits, percent, or both next to the menu bar icon." = "Mostra o nascondi i crediti Kiro, la percentuale o entrambi accanto all'icona della barra menu.";
+"Show usage for organizations you belong to. Personal account is always shown." = "Mostra l'utilizzo per le organizzazioni di cui fai parte. L'account personale è sempre mostrato.";
+"Sign in to cursor.com in your browser, then refresh Cursor in CodexBar." = "Accedi a cursor.com nel browser, poi aggiorna Cursor in CodexBar.";
+"Simulated error text" = "Testo errore simulato";
+"StepFun platform account (phone number or email)." = "Account piattaforma StepFun (numero di telefono o email).";
+"Stored in ~/.codexbar/config.json." = "Memorizzato in ~/.codexbar/config.json.";
+"Stored in ~/.codexbar/config.json. AZURE_OPENAI_API_KEY is also supported." = "Memorizzato in ~/.codexbar/config.json. È supportato anche AZURE_OPENAI_API_KEY.";
+"Stored in ~/.codexbar/config.json. For the official Kimi API, use Moonshot / Kimi API." = "Memorizzato in ~/.codexbar/config.json. Per l'API ufficiale Kimi, usa Moonshot / Kimi API.";
+"Stored in ~/.codexbar/config.json. Get your API key from the Volcengine Ark console." = "Memorizzato in ~/.codexbar/config.json. Ottieni la tua chiave API dalla console Volcengine Ark.";
+"Stored in ~/.codexbar/config.json. Get your key from Ollama settings." = "Memorizzato in ~/.codexbar/config.json. Ottieni la tua chiave dalle impostazioni di Ollama.";
+"Stored in ~/.codexbar/config.json. Get your key from console.deepgram.com." = "Memorizzato in ~/.codexbar/config.json. Ottieni la tua chiave da console.deepgram.com.";
+"Stored in ~/.codexbar/config.json. Get your key from elevenlabs.io/app/settings/api-keys." = "Memorizzato in ~/.codexbar/config.json. Ottieni la tua chiave da elevenlabs.io/app/settings/api-keys.";
+"Stored in ~/.codexbar/config.json. Get your key from openrouter.ai/settings/keys and set a key spending limit there to enable API key quota tracking." = "Memorizzato in ~/.codexbar/config.json. Ottieni la tua chiave da openrouter.ai/settings/keys e imposta lì un limite di spesa per abilitare il monitoraggio della quota della chiave API.";
+"Stored in ~/.codexbar/config.json. In Warp, open Settings > Platform > API Keys, then create one." = "Memorizzato in ~/.codexbar/config.json. In Warp, apri Impostazioni > Piattaforma > Chiavi API, poi creane una.";
+"Stored in ~/.codexbar/config.json. Metrics require Groq Enterprise Prometheus access." = "Memorizzato in ~/.codexbar/config.json. Le metriche richiedono accesso a Groq Enterprise Prometheus.";
+"Stored in ~/.codexbar/config.json. OPENAI_ADMIN_KEY is preferred; OPENAI_API_KEY still works." = "Memorizzato in ~/.codexbar/config.json. È preferibile OPENAI_ADMIN_KEY; OPENAI_API_KEY continua a funzionare.";
+"Stored in ~/.codexbar/config.json. Requires an Anthropic Admin API key." = "Memorizzato in ~/.codexbar/config.json. Richiede una chiave Anthropic Admin API.";
+"Stored in ~/.codexbar/config.json. Used for /v1/quota-stats." = "Memorizzato in ~/.codexbar/config.json. Usato per /v1/quota-stats.";
+"Stored in ~/.codexbar/config.json. You can also provide CODEBUFF_API_KEY or let CodexBar read ~/.config/manicode/credentials.json (created by `codebuff login`)." = "Memorizzato in ~/.codexbar/config.json. Puoi anche fornire CODEBUFF_API_KEY o lasciare che CodexBar legga ~/.config/manicode/credentials.json (creato da `codebuff login`).";
+"Stored in ~/.codexbar/config.json. You can also provide CROF_API_KEY." = "Memorizzato in ~/.codexbar/config.json. Puoi anche fornire CROF_API_KEY.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or ~/.local/share/kilo/auth.json (kilo.access)." = "Memorizzato in ~/.codexbar/config.json. Puoi anche fornire KILO_API_KEY o ~/.local/share/kilo/auth.json (kilo.access).";
+"T3 Chat cookie" = "Cookie T3 Chat";
+"That account is no longer available in CodexBar. Refresh the account list and try again." = "Quell'account non è più disponibile in CodexBar. Aggiorna l'elenco account e riprova.";
+"The browser login did not complete in time. Try Antigravity login again." = "L'accesso nel browser non è stato completato in tempo. Riprova l'accesso ad Antigravity.";
+"Timed out waiting for Cursor login. %@" = "Timeout in attesa dell'accesso Cursor. %@";
+"Timed out waiting for Cursor login. %@ Last error: %@" = "Timeout in attesa dell'accesso Cursor. %@ Ultimo errore: %@";
+"Today requests" = "Richieste di oggi";
+"Total (30d): %@ credits" = "Totale (30 g): %@ crediti";
+"Username" = "Nome utente";
+"Uses username + password to login and obtain an Oasis-Token automatically." = "Usa nome utente e password per accedere e ottenere automaticamente un Oasis-Token.";
+"Uses username + password to login and obtain an %@ automatically." = "Usa nome utente e password per accedere e ottenere automaticamente un %@.";
+"Utilization End" = "Fine utilizzo";
+"Utilization Start" = "Inizio utilizzo";
+"Verbosity" = "Verbosità";
+"Windsurf session JSON bundle" = "Bundle JSON sessione Windsurf";
+"Workspace ID" = "ID workspace";
+"Your StepFun platform password. Used to login and obtain a session token." = "La tua password della piattaforma StepFun. Usata per accedere e ottenere un token di sessione.";
+"claude /login exited with status %d." = "claude /login è terminato con stato %d.";
+"codex login exited with status %d." = "codex login è terminato con stato %d.";
+"Cookie: …\n\nor paste a cURL capture from the Abacus AI dashboard" = "Cookie: …\n\noppure incolla una cattura cURL dalla dashboard di Abacus AI";
+"Cookie: …\n\nor paste the __Secure-next-auth.session-token value" = "Cookie: …\n\noppure incolla il valore di __Secure-next-auth.session-token";
+"Cookie: …\n\nor paste the kimi-auth token value" = "Cookie: …\n\noppure incolla il valore del token kimi-auth";
+"session_id=...\n\nor paste just the session_id value" = "session_id=...\n\noppure incolla solo il valore di session_id";
+"Clear" = "Cancella";
+"No matching providers" = "Nessun provider corrispondente";
+"Search providers" = "Cerca provider";
+
+"Request quota: %@ / %@" = "Quota richieste: %@ / %@";
+"language_arabic" = "العربية";
+"language_persian" = "فارسی";
+"language_thai" = "ไทย";
+"Limit Reset Credits" = "Crediti di reimpostazione limite";
+"1 manual reset available" = "1 reimpostazione manuale disponibile";
+"%d manual resets available" = "%d reimpostazioni manuali disponibili";
+"Next expires %@" = "La prossima scade %@";
+"byte_unit_byte" = "byte";
+"byte_unit_bytes" = "byte";
+"byte_unit_kilobyte" = "kilobyte";
+"byte_unit_kilobytes" = "kilobyte";
+"byte_unit_megabyte" = "megabyte";
+"byte_unit_megabytes" = "megabyte";
+"byte_unit_gigabyte" = "gigabyte";
+"byte_unit_gigabytes" = "gigabyte";
diff --git a/Sources/CodexBar/Resources/ja.lproj/Localizable.strings b/Sources/CodexBar/Resources/ja.lproj/Localizable.strings
new file mode 100644
index 0000000000..2ba6ce470c
--- /dev/null
+++ b/Sources/CodexBar/Resources/ja.lproj/Localizable.strings
@@ -0,0 +1,1106 @@
+/* Japanese localization for CodexBar */
+
+" providers" = " 件のプロバイダ";
+"(System)" = "（システム）";
+"30d" = "30日";
+"A managed Codex login is already running. Wait for it to finish before adding " = "管理対象の Codex ログインがすでに実行中です。完了を待ってから追加してください ";
+"API key" = "API キー";
+"API region" = "API リージョン";
+"API token" = "API トークン";
+"API tokens" = "API トークン";
+"About" = "このアプリについて";
+"Account" = "アカウント";
+"Accounts" = "アカウント";
+"Accounts subtitle" = "アカウントのサブタイトル";
+"Active" = "アクティブ";
+"Add" = "追加";
+"Add Workspace" = "ワークスペースを追加";
+"Advanced" = "詳細";
+"All" = "すべて";
+"Always allow prompts" = "常にプロンプトを許可";
+"Animation pattern" = "アニメーションパターン";
+"Antigravity login is managed in the app" = "Antigravity のログインはアプリ内で管理されます";
+"Applies only to the Security.framework OAuth keychain reader." = "Security.framework の OAuth キーチェーンリーダーにのみ適用されます。";
+"Auto falls back to the next source if the preferred one fails." = "自動では、優先ソースが失敗した場合に次のソースへフォールバックします。";
+"Auto uses API first, then falls back to CLI on auth failures." = "自動では、まず API を使用し、認証に失敗した場合は CLI にフォールバックします。";
+"Auto-detect" = "自動検出";
+"Auto-refresh is off; use the menu's Refresh command." = "自動更新はオフです。メニューの「更新」コマンドを使用してください。";
+"Auto-refresh: hourly · Timeout: 10m" = "自動更新: 1時間ごと · タイムアウト: 10分";
+"Automatic" = "自動";
+"Automatic imports browser cookies and WorkOS tokens." = "自動では、ブラウザの Cookie と WorkOS トークンを読み込みます。";
+"Automatic imports browser cookies and local storage tokens." = "自動では、ブラウザの Cookie とローカルストレージのトークンを読み込みます。";
+"Automatic imports browser cookies for dashboard extras." = "自動では、ダッシュボードの追加情報用にブラウザの Cookie を読み込みます。";
+"Automatic imports browser cookies for the web API." = "自動では、Web API 用にブラウザの Cookie を読み込みます。";
+"Automatic imports browser cookies from Model Studio/Bailian." = "自動では、Model Studio/Bailian からブラウザの Cookie を読み込みます。";
+"Automatic imports browser cookies from admin.mistral.ai." = "自動では、admin.mistral.ai からブラウザの Cookie を読み込みます。";
+"Automatic imports browser cookies from opencode.ai." = "自動では、opencode.ai からブラウザの Cookie を読み込みます。";
+"Automatic imports browser cookies or stored sessions." = "自動では、ブラウザの Cookie または保存済みセッションを読み込みます。";
+"Automatic imports browser cookies." = "自動では、ブラウザの Cookie を読み込みます。";
+"Automatically imports browser session cookie." = "ブラウザのセッション Cookie を自動的に読み込みます。";
+"Automatically opens CodexBar when you start your Mac." = "Mac の起動時に CodexBar を自動的に開きます。";
+"Automation" = "オートメーション";
+"Average (\\(label1) + \\(label2))" = "平均 (\\(label1) + \\(label2))";
+"Average (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))" = "平均 (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))";
+"Avoid Keychain prompts" = "キーチェーンのプロンプトを回避";
+"Balance" = "残高";
+"Battery Saver" = "バッテリーセーバー";
+"Bordered" = "枠線あり";
+"Build" = "ビルド";
+"Built \\(buildTimestamp)" = "ビルド日時 \\(buildTimestamp)";
+"Buy Credits..." = "クレジットを購入...";
+"Buy Credits…" = "クレジットを購入…";
+"CLI paths" = "CLI パス";
+"CLI sessions" = "CLI セッション";
+"Caches" = "キャッシュ";
+"Cancel" = "キャンセル";
+"Check for Updates…" = "アップデートを確認…";
+"Check for updates automatically" = "アップデートを自動的に確認";
+"Check if you like your agents having some fun up there." = "エージェントがメニューバーで楽しく動き回るのがお好みならチェックしてください。";
+"Check provider status" = "プロバイダの状態を確認";
+"Choose Codex workspace" = "Codex ワークスペースを選択";
+"Choose the MiniMax host (global .io or China mainland .com)." = "MiniMax のホストを選択します（グローバルの .io または中国本土の .com）。";
+"Choose up to " = "選択可能数: 最大 ";
+"Choose up to \\(Self.maxOverviewProviders) providers" = "最大 \\(Self.maxOverviewProviders) 件のプロバイダを選択";
+"Choose up to \\(count) providers" = "最大 \\(count) 件のプロバイダを選択";
+"Choose what to show in the menu bar (Pace shows usage vs. expected)." = "メニューバーに表示する内容を選択します（ペースは想定に対する使用量を表示します）。";
+"Choose which Codex account CodexBar should follow." = "CodexBar が追跡する Codex アカウントを選択します。";
+"Choose which window drives the menu bar percent." = "メニューバーのパーセント表示に使用するウインドウを選択します。";
+"Chrome" = "Chrome";
+"Claude CLI not found" = "Claude CLI が見つかりません";
+"Claude binary" = "Claude バイナリ";
+"Claude cookies" = "Claude の Cookie";
+"Claude login failed" = "Claude のログインに失敗しました";
+"Claude login timed out" = "Claude のログインがタイムアウトしました";
+"Close" = "閉じる";
+"Code review" = "コードレビュー";
+"Codex CLI not found" = "Codex CLI が見つかりません";
+"Codex account login already running" = "Codex アカウントのログインがすでに実行中です";
+"Codex binary" = "Codex バイナリ";
+"Codex login failed" = "Codex のログインに失敗しました";
+"Codex login timed out" = "Codex のログインがタイムアウトしました";
+"CodexBar Lifecycle Keepalive" = "CodexBar ライフサイクルキープアライブ";
+"CodexBar can't show its menu bar icon" = "CodexBar はメニューバーアイコンを表示できません";
+"CodexBar could not read managed account storage. " = "CodexBar は管理対象アカウントのストレージを読み取れませんでした。";
+"Configure…" = "設定…";
+"Connected" = "接続済み";
+"Controls how much detail is logged." = "記録するログの詳細度を制御します。";
+"Cookie header" = "Cookie ヘッダー";
+"Cookie source" = "Cookie ソース";
+"Cookie: ..." = "Cookie: ...";
+"Cookie: \\u{2026}\\\n\\\nor paste a cURL capture from the Abacus AI dashboard" = "Cookie: \\u{2026}\\\n\\\nまたは Abacus AI ダッシュボードからの cURL キャプチャを貼り付けてください";
+"Cookie: \\u{2026}\\\n\\\nor paste the __Secure-next-auth.session-token value" = "Cookie: \\u{2026}\\\n\\\nまたは __Secure-next-auth.session-token の値を貼り付けてください";
+"Cookie: \\u{2026}\\\n\\\nor paste the kimi-auth token value" = "Cookie: \\u{2026}\\\n\\\nまたは kimi-auth トークンの値を貼り付けてください";
+"Cookie: …" = "Cookie: …";
+"CopilotDeviceFlow" = "CopilotDeviceFlow";
+"Cost" = "コスト";
+"Could not add Codex account" = "Codex アカウントを追加できませんでした";
+"Could not open Terminal for Gemini" = "Gemini 用のターミナルを開けませんでした";
+"Could not start claude /login" = "claude /login を開始できませんでした";
+"Could not start codex login" = "codex login を開始できませんでした";
+"Could not switch system account" = "システムアカウントを切り替えられませんでした";
+"Credits" = "クレジット";
+"Individual credits" = "個人クレジット";
+"Workspace" = "ワークスペース";
+"Credits history" = "クレジット履歴";
+"Cursor login failed" = "Cursor のログインに失敗しました";
+"Custom" = "カスタム";
+"Custom Path" = "カスタムパス";
+"Daily Routines" = "デイリールーティン";
+"Debug" = "デバッグ";
+"Default" = "デフォルト";
+"Disable Keychain access" = "キーチェーンへのアクセスを無効にする";
+"Disabled" = "無効";
+"Dismiss" = "閉じる";
+"Disconnected" = "未接続";
+"Display" = "表示";
+"Display mode" = "表示モード";
+"Display reset times as absolute clock values instead of countdowns." = "リセット時刻をカウントダウンではなく絶対時刻で表示します。";
+"Done" = "完了";
+"Effective PATH" = "有効な PATH";
+"Email" = "メールアドレス";
+"Enable Merge Icons to configure Overview tab providers." = "「アイコンを統合」を有効にすると、概要タブのプロバイダを設定できます。";
+"Enable file logging" = "ファイルへのログ記録を有効にする";
+"Enabled" = "有効";
+"Error" = "エラー";
+"Error simulation" = "エラーシミュレーション";
+"Expose troubleshooting tools in the Debug tab." = "デバッグタブにトラブルシューティングツールを表示します。";
+"Failed" = "失敗";
+"False" = "False";
+"Fetch strategy attempts" = "取得戦略の試行";
+"Fetching" = "取得中";
+"Field" = "フィールド";
+"Field subtitle" = "フィールドのサブタイトル";
+"Finish the current managed account change before switching the system account." = "システムアカウントを切り替える前に、現在の管理対象アカウントの変更を完了してください。";
+"Force animation on next refresh" = "次回の更新時にアニメーションを強制実行";
+"Gateway region" = "ゲートウェイリージョン";
+"Gemini CLI not found" = "Gemini CLI が見つかりません";
+"Gemini/Antigravity, surfacing incidents in the icon and menu." = "Gemini/Antigravity の障害情報をアイコンとメニューに表示します。";
+"General" = "一般";
+"GitHub" = "GitHub";
+"GitHub Copilot Login" = "GitHub Copilot ログイン";
+"GitHub Login" = "GitHub ログイン";
+"Hide details" = "詳細を非表示";
+"Hide personal information" = "個人情報を非表示";
+"Historical tracking" = "履歴トラッキング";
+"How often CodexBar polls providers in the background." = "CodexBar がバックグラウンドでプロバイダをポーリングする頻度です。";
+"Inactive" = "非アクティブ";
+"Install CLI" = "CLI をインストール";
+"Install the Claude CLI (npm i -g @anthropic-ai/claude-code) and try again." = "Claude CLI をインストールして（npm i -g @anthropic-ai/claude-code）、もう一度お試しください。";
+"Install the Codex CLI (npm i -g @openai/codex) and try again." = "Codex CLI をインストールして（npm i -g @openai/codex）、もう一度お試しください。";
+"Install the Gemini CLI (npm i -g @google/gemini-cli) and try again." = "Gemini CLI をインストールして（npm i -g @google/gemini-cli）、もう一度お試しください。";
+"JetBrains AI is ready" = "JetBrains AI の準備ができました";
+"JetBrains IDE" = "JetBrains IDE";
+"Keep CLI sessions alive" = "CLI セッションを維持する";
+"Keyboard shortcut" = "キーボードショートカット";
+"Keychain access" = "キーチェーンへのアクセス";
+"Keychain prompt policy" = "キーチェーンのプロンプトポリシー";
+"Last \\(name) fetch failed:" = "前回の \\(name) の取得に失敗しました:";
+"Last \\(self.store.metadata(for: self.provider).displayName) fetch failed:" = "前回の \\(self.store.metadata(for: self.provider).displayName) の取得に失敗しました:";
+"Last attempt" = "最終試行";
+"Link" = "リンク";
+"Loading animations" = "読み込み中アニメーション";
+"Loading…" = "読み込み中…";
+"Local" = "ローカル";
+"Logging" = "ログ";
+"Login failed" = "ログインに失敗しました";
+"Login shell PATH (startup capture)" = "ログインシェルの PATH（起動時に取得）";
+"Login timed out" = "ログインがタイムアウトしました";
+"MCP details" = "MCP の詳細";
+"Managed Codex accounts unavailable" = "管理対象の Codex アカウントを利用できません";
+"Managed account storage is unreadable. Live account access is still available, " = "管理対象アカウントのストレージを読み取れません。ライブアカウントへのアクセスは引き続き利用できます。";
+"Manual" = "手動";
+"May your tokens never run out—keep agent limits in view." = "トークンが尽きませんように — エージェントの上限を常に見守りましょう。";
+"Menu bar" = "メニューバー";
+"Menu bar auto-shows the provider closest to its rate limit." = "メニューバーには、レート制限に最も近いプロバイダが自動的に表示されます。";
+"Menu bar metric" = "メニューバーの指標";
+"Menu bar shows percent" = "メニューバーにパーセントを表示";
+"Menu content" = "メニューの内容";
+"Merge Icons" = "アイコンを統合";
+"Never prompt" = "プロンプトを表示しない";
+"No" = "いいえ";
+"No Codex accounts detected yet." = "Codex アカウントはまだ検出されていません。";
+"No JetBrains IDE detected" = "JetBrains IDE が検出されません";
+"No cost history data." = "コスト履歴データがありません。";
+"No data available" = "データがありません";
+"No data yet" = "まだデータがありません";
+"No enabled providers available for Overview." = "概要に表示できる有効なプロバイダがありません。";
+"No providers selected" = "プロバイダが選択されていません";
+"No token accounts yet." = "トークンアカウントはまだありません。";
+"No usage breakdown data." = "使用量の内訳データがありません。";
+"None" = "なし";
+"Notifications" = "通知";
+"Notifies when the 5-hour session quota hits 0% and when it becomes " = "5時間セッションのクォータが 0% になったとき、および再び利用可能になったときに通知します ";
+"OK" = "OK";
+"Obscure email addresses in the menu bar and menu UI." = "メニューバーとメニュー UI でメールアドレスを伏せ字にします。";
+"Off" = "オフ";
+"Offline" = "オフライン";
+"On" = "オン";
+"Online" = "オンライン";
+"Only on user action" = "ユーザー操作時のみ";
+"Open" = "開く";
+"Open API Keys" = "API キーを開く";
+"Open Amp Settings" = "Amp の設定を開く";
+"Open Antigravity to sign in, then refresh CodexBar." = "Antigravity を開いてサインインしてから、CodexBar を更新してください。";
+"Open Browser" = "ブラウザを開く";
+"Open Coding Plan" = "コーディングプランを開く";
+"Open Console" = "コンソールを開く";
+"Open Dashboard" = "ダッシュボードを開く";
+"Open Mistral Admin" = "Mistral 管理画面を開く";
+"Open Menu Bar Settings" = "メニューバー設定を開く";
+"Open Ollama Settings" = "Ollama の設定を開く";
+"Open Terminal" = "ターミナルを開く";
+"Open Usage Page" = "使用状況ページを開く";
+"Open Warp API Key Guide" = "Warp API キーガイドを開く";
+"Open menu" = "メニューを開く";
+"Open token file" = "トークンファイルを開く";
+"OpenAI cookies" = "OpenAI の Cookie";
+"OpenAI web extras" = "OpenAI Web 追加情報";
+"Option A" = "オプション A";
+"Option B" = "オプション B";
+"Optional override if workspace lookup fails." = "ワークスペースの検索に失敗した場合の任意の上書き設定です。";
+"Options" = "オプション";
+"Override auto-detection with a custom IDE base path" = "カスタムの IDE ベースパスで自動検出を上書き";
+"Overview" = "概要";
+"Overview rows always follow provider order." = "概要の行は常にプロバイダの順序に従います。";
+"Overview tab providers" = "概要タブのプロバイダ";
+"Paste API key…" = "API キーを貼り付け…";
+"Paste API token…" = "API トークンを貼り付け…";
+"Paste key…" = "キーを貼り付け…";
+"Paste sessionKey or OAuth token…" = "sessionKey または OAuth トークンを貼り付け…";
+"Paste the Cookie header from a request to admin.mistral.ai. " = "admin.mistral.ai へのリクエストの Cookie ヘッダーを貼り付けてください。";
+"Paste token…" = "トークンを貼り付け…";
+"Personal" = "個人";
+"Picker" = "ピッカー";
+"Picker subtitle" = "ピッカーのサブタイトル";
+"Placeholder" = "プレースホルダ";
+"Plan" = "プラン";
+"Play full-screen confetti when weekly usage resets." = "週間使用量がリセットされたときに全画面の紙吹雪を表示します。";
+"Polls OpenAI/Claude status pages and Google Workspace for " = "OpenAI/Claude のステータスページと Google Workspace をポーリングして、";
+"Prevents any Keychain access while enabled." = "有効にすると、キーチェーンへのアクセスをすべて防ぎます。";
+"Primary (API key limit)" = "プライマリ（API キー上限）";
+"Primary (\\(label))" = "プライマリ (\\(label))";
+"Primary (\\(metadata.sessionLabel))" = "プライマリ (\\(metadata.sessionLabel))";
+"Probe logs" = "プローブログ";
+"Progress bars fill as you consume quota (instead of showing remaining)." = "プログレスバーは（残量表示ではなく）クォータの消費に応じて満たされていきます。";
+"Provider" = "プロバイダ";
+"Providers" = "プロバイダ";
+"Quit CodexBar" = "CodexBar を終了";
+"Random (default)" = "ランダム（デフォルト）";
+"Reads local usage logs. Shows today + last 30 days cost in the menu." = "ローカルの使用ログを読み取り、今日のコストと選択した履歴期間のコストをメニューに表示します。";
+"Refresh" = "更新";
+"Refresh cadence" = "更新間隔";
+"Remote" = "リモート";
+"Remove" = "削除";
+"Remove Codex account?" = "Codex アカウントを削除しますか？";
+"Remove \\(account.email) from CodexBar? Its managed Codex home will be deleted." = "\\(account.email) を CodexBar から削除しますか？管理対象の Codex ホームは削除されます。";
+"Remove \\(email) from CodexBar? Its managed Codex home will be deleted." = "\\(email) を CodexBar から削除しますか？管理対象の Codex ホームは削除されます。";
+"Remove selected account" = "選択したアカウントを削除";
+"Replace critter bars with provider branding icons and a percentage." = "クリッターバーをプロバイダのブランドアイコンとパーセント表示に置き換えます。";
+"Replay selected animation" = "選択したアニメーションを再生";
+"Requires authentication via GitHub Device Flow." = "GitHub Device Flow による認証が必要です。";
+"Resets: \\(reset)" = "リセット: \\(reset)";
+"Rolling five-hour limit" = "5時間のローリング上限";
+"Search hourly" = "1時間ごとに検索";
+"Secondary (\\(label))" = "セカンダリ (\\(label))";
+"Secondary (\\(metadata.weeklyLabel))" = "セカンダリ (\\(metadata.weeklyLabel))";
+"Select a provider" = "プロバイダを選択";
+"Select the IDE to monitor" = "監視する IDE を選択";
+"Session quota notifications" = "セッションクォータ通知";
+"Session tokens" = "セッショントークン";
+"Settings" = "設定";
+"Show Codex Credits and Claude Extra usage sections in the menu." = "Codex クレジットと Claude 追加使用量のセクションをメニューに表示します。";
+"Show Debug Settings" = "デバッグ設定を表示";
+"Show all token accounts" = "すべてのトークンアカウントを表示";
+"Show cost summary" = "コスト概要を表示";
+"Show credits + extra usage" = "クレジットと追加使用量を表示";
+"Show details" = "詳細を表示";
+"Show most-used provider" = "最も使用中のプロバイダを表示";
+"Show provider icons in the switcher (otherwise show a weekly progress line)." = "切替バーにプロバイダのアイコンを表示します（オフの場合は週間進捗ラインを表示します）。";
+"Show reset time as clock" = "リセット時刻を時計表示";
+"Show usage as used" = "使用量を消費分で表示";
+"Sign in via button below" = "下のボタンからサインイン";
+"Skip teardown between probes (debug-only)." = "プローブ間のティアダウンをスキップします（デバッグ専用）。";
+"Stack token accounts in the menu (otherwise show an account switcher bar)." = "メニューにトークンアカウントを積み重ねて表示します（オフの場合はアカウント切替バーを表示します）。";
+"Start at Login" = "ログイン時に起動";
+"Status" = "ステータス";
+"Store Claude sessionKey cookies or OAuth access tokens." = "Claude の sessionKey Cookie または OAuth アクセストークンを保存します。";
+"Store multiple Abacus AI Cookie headers." = "複数の Abacus AI Cookie ヘッダーを保存します。";
+"Store multiple Augment Cookie headers." = "複数の Augment Cookie ヘッダーを保存します。";
+"Store multiple Cursor Cookie headers." = "複数の Cursor Cookie ヘッダーを保存します。";
+"Store multiple Factory Cookie headers." = "複数の Factory Cookie ヘッダーを保存します。";
+"Store multiple MiniMax Cookie headers." = "複数の MiniMax Cookie ヘッダーを保存します。";
+"Store multiple Mistral Cookie headers." = "複数の Mistral Cookie ヘッダーを保存します。";
+"Store multiple Ollama Cookie headers." = "複数の Ollama Cookie ヘッダーを保存します。";
+"Store multiple OpenCode Cookie headers." = "複数の OpenCode Cookie ヘッダーを保存します。";
+"Store multiple OpenCode Go Cookie headers." = "複数の OpenCode Go Cookie ヘッダーを保存します。";
+"Stored in the CodexBar config file." = "CodexBar の設定ファイルに保存されます。";
+"Stored in ~/.codexbar/config.json. " = "~/.codexbar/config.json に保存されます。 ";
+"Stored in ~/.codexbar/config.json. Generate one at kimi-k2.ai." = "~/.codexbar/config.json に保存されます。kimi-k2.ai で生成できます。";
+"Stored in ~/.codexbar/config.json. Paste the key from the Synthetic dashboard." = "~/.codexbar/config.json に保存されます。Synthetic ダッシュボードのキーを貼り付けてください。";
+"Stored in ~/.codexbar/config.json. Paste your Coding Plan API key from Model Studio." = "~/.codexbar/config.json に保存されます。Model Studio の Coding Plan API キーを貼り付けてください。";
+"Stored in ~/.codexbar/config.json. Paste your MiniMax API key." = "~/.codexbar/config.json に保存されます。MiniMax API キーを貼り付けてください。";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or " = "~/.codexbar/config.json に保存されます。KILO_API_KEY を指定することもできます。または ";
+"Stores local Codex usage history (8 weeks) to personalize Pace predictions." = "ローカルの Codex 使用履歴（8 週間分）を保存して、ペース予測をパーソナライズします。";
+"Subscription Utilization" = "サブスクリプション利用率";
+"Surprise me" = "サプライズ";
+"Switcher shows icons" = "切替バーにアイコンを表示";
+"Symlink CodexBarCLI to /usr/local/bin and /opt/homebrew/bin as codexbar." = "CodexBarCLI を codexbar として /usr/local/bin と /opt/homebrew/bin にシンボリックリンクします。";
+"System" = "システム";
+"Temporarily shows the loading animation after the next refresh." = "次回の更新後に読み込みアニメーションを一時的に表示します。";
+"Tertiary (\\(label))" = "第3（\\(label)）";
+"Tertiary (\\(tertiaryTitle))" = "第3（\\(tertiaryTitle)）";
+"The default Codex account on this Mac." = "この Mac のデフォルトの Codex アカウントです。";
+"Toggle" = "切り替え";
+"Toggle subtitle" = "サブタイトルを切り替え";
+"Token" = "トークン";
+"Trigger the menu bar menu from anywhere." = "どこからでもメニューバーのメニューを開きます。";
+"True" = "True";
+"Twitter" = "Twitter";
+"Unsupported" = "未対応";
+"Update Channel" = "アップデートチャンネル";
+"Updated" = "更新済み";
+"Updates unavailable in this build." = "このビルドではアップデートを利用できません。";
+"Usage" = "使用量";
+"Usage breakdown" = "使用量の内訳";
+"Usage history (30 days)" = "使用履歴";
+"Usage source" = "使用量の取得元";
+"Use BigModel for the China mainland endpoints (open.bigmodel.cn)." = "中国本土向けエンドポイント（open.bigmodel.cn）には BigModel を使用します。";
+"Use a single menu bar icon with a provider switcher." = "プロバイダ切替付きの単一のメニューバーアイコンを使用します。";
+"Use international or China mainland console gateways for quota fetches." = "クォータ取得に国際版または中国本土版のコンソールゲートウェイを使用します。";
+"Version" = "バージョン";
+"Version \\(self.versionString)" = "バージョン \\(self.versionString)";
+"Version \\(version)" = "バージョン \\(version)";
+"Version \\(versionString)" = "バージョン \\(versionString)";
+"Vertex AI Login" = "Vertex AI ログイン";
+"Wait for the current managed Codex login to finish before adding another account." = "別のアカウントを追加する前に、現在のマネージド Codex ログインが完了するまでお待ちください。";
+"Waiting for Authentication..." = "認証を待機中...";
+"Website" = "Web サイト";
+"Weekly limit confetti" = "週間上限の紙吹雪";
+"Weekly token limit" = "週間トークン上限";
+"Weekly usage" = "週間使用量";
+"Weekly usage unavailable for this account." = "このアカウントでは週間使用量を取得できません。";
+"Window: \\(window)" = "ウインドウ: \\(window)";
+"Write logs to \\(self.fileLogPath) for debugging." = "デバッグ用にログを \\(self.fileLogPath) に書き込みます。";
+"Yes" = "はい";
+"\\(detail.modelCode): \\(usage)" = "\\(detail.modelCode): \\(usage)";
+"\\(name): \\(truncated)" = "\\(name): \\(truncated)";
+"\\(name): \\(updated) · 30d \\(cost)" = "\\(name): \\(updated) · 30日 \\(cost)";
+"\\(name): fetching…\\(elapsed)" = "\\(name): 取得中…\\(elapsed)";
+"\\(name): last attempt \\(when)" = "\\(name): 最終試行 \\(when)";
+"\\(name): no data yet" = "\\(name): データなし";
+"\\(name): unsupported" = "\\(name): 未対応";
+"all browsers" = "すべてのブラウザ";
+"available again." = "再び利用可能になりました。";
+"built_format" = "ビルド: %@";
+"copilot_complete_in_browser" = "ブラウザでサインインを完了してください。";
+"copilot_device_code" = "デバイスコードをクリップボードにコピーしました: %1$@\n\n確認先: %2$@";
+"copilot_device_code_copied" = "デバイスコードをコピーしました。";
+"copilot_verify_at" = "%@ で確認してください";
+"copilot_waiting_text" = "ブラウザでサインインを完了してください。\nサインインが完了すると、このウインドウは自動的に閉じます。";
+"copilot_window_closes_auto" = "サインインが完了すると、このウインドウは自動的に閉じます。";
+"cost_status_error" = "%1$@: %2$@";
+"cost_status_fetching" = "%1$@: 取得中… %2$@";
+"cost_status_last_attempt" = "%1$@: 最終試行 %2$@";
+"cost_status_no_data" = "%@: データなし";
+"cost_status_snapshot" = "%1$@: %2$@ · %3$@ %4$@";
+"cost_status_unsupported" = "%@: 未対応";
+"credits_remaining" = "クレジット: %@";
+"cursor_on_demand" = "オンデマンド: %@";
+"cursor_on_demand_with_limit" = "オンデマンド: %1$@ / %2$@";
+"extra_usage_format" = "追加使用量: %1$@ / %2$@";
+"jetbrains_detected_generate" = "検出: %@。AI アシスタントを一度使用してクォータデータを生成してから、CodexBar を更新してください。";
+"jetbrains_detected_select" = "検出: %@。設定でお使いの IDE を選択してから、CodexBar を更新してください。";
+"last_fetch_failed_with_provider" = "前回の %@ の取得に失敗しました:";
+"last_spend" = "直近の支出: %@";
+"mcp_model_usage" = "%1$@: %2$@";
+"mcp_resets" = "リセット: %@";
+"mcp_window" = "ウインドウ: %@";
+"metric_average" = "平均（%1$@ + %2$@）";
+"metric_primary" = "プライマリ（%@）";
+"metric_secondary" = "セカンダリ（%@）";
+"metric_tertiary" = "第3（%@）";
+"multiple_workspaces_found" = "CodexBar は %@ の複数のワークスペースを見つけました。追加するワークスペースを選択してください。";
+"ory_session_…=…; csrftoken=…" = "ory_session_…=…; csrftoken=…";
+"overview_choose_providers" = "最大 %@ 個のプロバイダを選択";
+"remove_account_message" = "%@ を CodexBar から削除しますか？マネージド Codex ホームも削除されます。";
+"version_format" = "バージョン %@";
+"vertex_ai_login_instructions" = "Vertex AI の使用状況を追跡するには、Google Cloud で認証してください。\n\n1. ターミナルを開く\n2. 実行: gcloud auth application-default login\n3. ブラウザの指示に従ってサインイン\n4. プロジェクトを設定: gcloud config set project PROJECT_ID\n\n今すぐターミナルを開きますか？";
+"workspaceID is set but only opencode, opencodego, and deepgram support workspaceID." = "workspaceID が設定されていますが、workspaceID に対応しているのは opencode、opencodego、deepgram のみです。";
+"© 2026 Peter Steinberger. MIT License." = "© 2026 Peter Steinberger. MIT License.";
+
+/* General Pane */
+"section_system" = "システム";
+"section_usage" = "使用量";
+"section_automation" = "自動化";
+"language_title" = "言語";
+"language_subtitle" = "表示言語を変更します。完全に反映するにはアプリの再起動が必要です。";
+"language_system" = "システム";
+"language_english" = "英語";
+"language_spanish" = "スペイン語";
+"language_catalan" = "カタロニア語";
+"language_chinese_simplified" = "簡体字中国語";
+"language_chinese_traditional" = "繁体字中国語";
+"language_portuguese_brazilian" = "ポルトガル語（ブラジル）";
+"language_dutch" = "オランダ語";
+"language_swedish" = "スウェーデン語";
+"language_french" = "フランス語";
+"language_german" = "ドイツ語";
+"language_ukrainian" = "ウクライナ語";
+"language_japanese" = "日本語";
+"language_korean" = "韓国語";
+"language_italian" = "イタリア語";
+"language_polish" = "ポーランド語";
+"start_at_login_title" = "ログイン時に起動";
+"start_at_login_subtitle" = "Mac の起動時に CodexBar を自動的に開きます。";
+"show_cost_summary" = "コスト概要を表示";
+"show_cost_summary_subtitle" = "ローカルの使用ログを読み取り、今日分と選択した履歴期間をメニューに表示します。";
+"cost_history_days_title" = "履歴期間: %d 日";
+"cost_auto_refresh_info" = "自動更新: 1 時間ごと · タイムアウト: 10 分";
+"refresh_cadence_title" = "更新間隔";
+"refresh_cadence_subtitle" = "CodexBar がバックグラウンドでプロバイダをポーリングする頻度です。";
+"manual_refresh_hint" = "自動更新はオフです。メニューの「更新」コマンドを使用してください。";
+"check_provider_status_title" = "プロバイダのステータスを確認";
+"check_provider_status_subtitle" = "OpenAI/Claude のステータスページと Gemini/Antigravity 用の Google Workspace をポーリングし、障害情報をアイコンとメニューに表示します。";
+"session_quota_notifications_title" = "セッションクォータ通知";
+"session_quota_notifications_subtitle" = "5 時間のセッションクォータが 0% になったとき、および再び利用可能になったときに通知します。";
+"quota_warning_notifications_title" = "クォータ警告通知";
+"quota_warning_notifications_subtitle" = "セッションまたは週間クォータの残量が設定したしきい値を下回ったときに警告します。";
+"quota_warnings_title" = "クォータ警告";
+"quota_warning_session" = "セッション";
+"quota_warning_session_capitalized" = "セッション";
+"quota_warning_weekly" = "週間";
+"quota_warning_weekly_capitalized" = "週間";
+"quota_warning_notification_title" = "%1$@ の%2$@クォータが残りわずか";
+"quota_warning_notification_body" = "残り %1$@。設定した %2$d%% の%3$@警告しきい値に達しました。";
+"quota_warning_notification_body_with_account" = "アカウント %1$@。残り %2$@。設定した %3$d%% の%4$@警告しきい値に達しました。";
+"session_depleted_notification_title" = "%@ のセッションを使い切りました";
+"session_depleted_notification_body" = "残り 0% です。再び利用可能になったら通知します。";
+"session_restored_notification_title" = "%@ のセッションが回復しました";
+"session_restored_notification_body" = "セッションクォータが再び利用可能になりました。";
+"quota_warning_warn_at" = "警告する残量";
+"quota_warning_global_threshold_subtitle" = "プロバイダ側で上書きされない限り、セッションおよび週間ウインドウの残量パーセントに適用されます。";
+"quota_warning_sound" = "通知音を再生";
+"quota_warning_provider_inherits" = "ここでウインドウをカスタマイズしない限り、グローバルのクォータ警告設定を使用します。";
+"quota_warning_customize_thresholds" = "%@ のしきい値をカスタマイズ";
+"quota_warning_enable_warnings" = "%@ の警告を有効にする";
+"quota_warning_window_warn_at" = "%@ の警告残量";
+"quota_warning_off" = "オフ";
+"quota_warning_inherited" = "継承: %@";
+"quota_warning_depleted_only" = "枯渇時のみ";
+"quota_warning_upper" = "上限";
+"quota_warning_lower" = "下限";
+"apply" = "適用";
+"quit_app" = "CodexBar を終了";
+
+/* Tab titles */
+"tab_general" = "一般";
+"tab_providers" = "プロバイダ";
+"tab_display" = "表示";
+"tab_advanced" = "詳細";
+"tab_about" = "情報";
+"tab_debug" = "デバッグ";
+
+/* Providers Pane */
+"select_a_provider" = "プロバイダを選択";
+"cancel" = "キャンセル";
+"last_fetch_failed" = "前回の取得に失敗";
+"usage_not_fetched_yet" = "使用量は未取得";
+"managed_account_storage_unreadable" = "マネージドアカウントのストレージを読み取れません。ライブアカウントへのアクセスは引き続き可能ですが、ストアが復旧するまで、マネージドアカウントの追加・再認証・削除操作は無効になります。";
+"remove_codex_account_title" = "Codex アカウントを削除しますか？";
+"remove" = "削除";
+"managed_login_already_running" = "マネージド Codex ログインがすでに実行中です。別のアカウントを追加または再認証する前に、完了するまでお待ちください。";
+"managed_login_failed" = "マネージド Codex ログインが完了しませんでした。ターミナルで `codex --version` が動作することを確認してください。macOS が `codex` をブロックした、またはゴミ箱に移動した場合は、古い重複インストールを削除し、`npm install -g --include=optional @openai/codex@latest` を実行してから再試行してください。";
+"codex_login_output" = "codex login の出力:";
+"managed_login_missing_email" = "Codex ログインは完了しましたが、アカウントのメールアドレスを取得できませんでした。アカウントが完全にサインインしていることを確認してから、再試行してください。";
+"login_success_notification_title" = "%@ のログインに成功しました";
+"login_success_notification_body" = "アプリに戻れます。認証が完了しました。";
+"workspace_selection_cancelled" = "CodexBar は複数のワークスペースを見つけましたが、ワークスペースが選択されませんでした。";
+"unsafe_managed_home" = "CodexBar は想定外のマネージドホームパスの変更を拒否しました: %@";
+"menu_bar_metric_title" = "メニューバーの指標";
+"menu_bar_metric_subtitle" = "メニューバーのパーセント表示に使用するウインドウを選択します。";
+"menu_bar_metric_subtitle_deepseek" = "DeepSeek の残高をメニューバーに表示します。";
+"menu_bar_metric_subtitle_moonshot" = "Moonshot / Kimi API の残高をメニューバーに表示します。";
+"menu_bar_metric_subtitle_mistral" = "今月の Mistral API 支出をメニューバーに表示します。";
+"menu_bar_metric_subtitle_kimik2" = "Kimi K2 API キーのクレジットをメニューバーに表示します。";
+"automatic" = "自動";
+"primary_api_key_limit" = "プライマリ（API キー上限）";
+
+/* Display Pane */
+"section_menu_bar" = "メニューバー";
+"merge_icons_title" = "アイコンを統合";
+"merge_icons_subtitle" = "プロバイダ切替付きの単一のメニューバーアイコンを使用します。";
+"switcher_shows_icons_title" = "切替バーにアイコンを表示";
+"switcher_shows_icons_subtitle" = "切替バーにプロバイダのアイコンを表示します（オフの場合は週間進捗ラインを表示します）。";
+"show_most_used_provider_title" = "最も使用中のプロバイダを表示";
+"show_most_used_provider_subtitle" = "レート制限に最も近いプロバイダをメニューバーに自動表示します。";
+"menu_bar_shows_percent_title" = "メニューバーにパーセントを表示";
+"menu_bar_shows_percent_subtitle" = "クリッターバーをプロバイダのブランドアイコンとパーセント表示に置き換えます。";
+"hide_critters_title" = "クリッターを非表示";
+"hide_critters_subtitle" = "顔や装飾のないシンプルなメーターバーを表示します。";
+"display_mode_title" = "表示モード";
+"display_mode_subtitle" = "メニューバーに表示する内容を選択します（ペースは使用量と想定値の比較を表示します）。";
+"section_menu_content" = "メニューの内容";
+"show_usage_as_used_title" = "使用量を消費分で表示";
+"show_usage_as_used_subtitle" = "プログレスバーが（残量ではなく）クォータの消費に応じて増えていきます。";
+"show_quota_warning_markers_title" = "クォータ警告マーカーを表示";
+"show_quota_warning_markers_subtitle" = "クォータ警告が設定されている場合、使用量バーにしきい値の目盛りを描画します。";
+"weekly_progress_work_days_title" = "週間進捗の作業日";
+"weekly_progress_work_days_subtitle" = "週間使用量バーの目盛りとペース計算に使用する作業日を設定します。";
+"show_reset_time_as_clock_title" = "リセット時刻を時計表示";
+"show_reset_time_as_clock_subtitle" = "リセット時刻をカウントダウンではなく絶対時刻で表示します。";
+"show_provider_changelog_links_title" = "プロバイダの変更履歴リンクを表示";
+"show_provider_changelog_links_subtitle" = "対応する CLI ベースのプロバイダのリリースノートへのリンクをメニューに追加します。";
+"show_credits_extra_usage_title" = "クレジットと追加使用量を表示";
+"show_credits_extra_usage_subtitle" = "Codex クレジットと Claude 追加使用量のセクションをメニューに表示します。";
+"show_all_token_accounts_title" = "すべてのトークンアカウントを表示";
+"show_all_token_accounts_subtitle" = "メニューにトークンアカウントを積み重ねて表示します（オフの場合はアカウント切替バーを表示します）。";
+"multi_account_layout_title" = "複数アカウントのレイアウト";
+"multi_account_layout_subtitle" = "セグメント式のアカウント切替か、積み重ね式のアカウントカードを選択します。";
+"multi_account_layout_segmented" = "セグメント";
+"multi_account_layout_stacked" = "スタック";
+"overview_tab_providers_title" = "概要タブのプロバイダ";
+"configure" = "設定…";
+"overview_enable_merge_icons_hint" = "概要タブのプロバイダを設定するには「アイコンを統合」を有効にしてください。";
+"overview_no_providers_hint" = "概要に使用できる有効なプロバイダがありません。";
+"overview_rows_follow_order" = "概要の行は常にプロバイダの並び順に従います。";
+"overview_no_providers_selected" = "プロバイダが選択されていません";
+
+/* Advanced Pane */
+"section_keyboard_shortcut" = "キーボードショートカット";
+"open_menu_shortcut_title" = "メニューを開く";
+"open_menu_shortcut_subtitle" = "どこからでもメニューバーのメニューを開きます。";
+"install_cli" = "CLI をインストール";
+"install_cli_subtitle" = "CodexBarCLI を codexbar として /usr/local/bin と /opt/homebrew/bin にシンボリックリンクします。";
+"cli_not_found" = "アプリバンドル内に CodexBarCLI が見つかりません。";
+"no_writable_bin_dirs" = "書き込み可能な bin ディレクトリが見つかりません。";
+"show_debug_settings_title" = "デバッグ設定を表示";
+"show_debug_settings_subtitle" = "デバッグタブにトラブルシューティングツールを表示します。";
+"surprise_me_title" = "サプライズ";
+"surprise_me_subtitle" = "エージェントたちがメニューバーで少し遊ぶのが好きか試してみてください。";
+"weekly_limit_confetti_title" = "週間上限の紙吹雪";
+"weekly_limit_confetti_subtitle" = "週間使用量がリセットされたときに全画面の紙吹雪を再生します。";
+"hide_personal_info_title" = "個人情報を隠す";
+"hide_personal_info_subtitle" = "メニューバーとメニュー UI のメールアドレスを伏せ字にします。";
+"show_provider_storage_usage_title" = "プロバイダのストレージ使用量を表示";
+"show_provider_storage_usage_subtitle" = "ローカルディスクの使用量をメニューに表示します。既知のプロバイダ所有パスをバックグラウンドでスキャンします。";
+"section_keychain_access" = "キーチェーンアクセス";
+"keychain_access_caption" = "キーチェーンの読み書きをすべて無効にします。「常に許可」をクリックしても macOS が「Chrome/Brave/Edge Safe Storage」のプロンプトを表示し続ける場合に使用してください。有効中はブラウザの Cookie 読み込みが利用できないため、プロバイダで Cookie ヘッダーを手動で貼り付けてください。CLI 経由の Claude/Codex OAuth は引き続き動作します。";
+"disable_keychain_access_title" = "キーチェーンアクセスを無効にする";
+"disable_keychain_access_subtitle" = "有効中はキーチェーンへのアクセスを一切行いません。";
+
+/* About Pane */
+"about_tagline" = "トークンが尽きませんように—エージェントの上限を常に見守りましょう。";
+"link_github" = "GitHub";
+"link_website" = "ウェブサイト";
+"link_twitter" = "Twitter";
+"link_email" = "メール";
+"check_updates_auto" = "アップデートを自動的に確認";
+"update_channel" = "アップデートチャンネル";
+"check_for_updates" = "アップデートを確認…";
+"updates_unavailable" = "このビルドではアップデートを利用できません。";
+"copyright" = "© 2026 Peter Steinberger. MIT License.";
+
+/* Debug Pane */
+"section_logging" = "ログ";
+"enable_file_logging" = "ファイルログを有効にする";
+"enable_file_logging_subtitle" = "デバッグ用に %@ へログを書き込みます。";
+"verbosity_title" = "詳細度";
+"verbosity_subtitle" = "ログに記録する詳細の量を制御します。";
+"open_log_file" = "ログファイルを開く";
+"force_animation_next_refresh" = "次回の更新時にアニメーションを強制する";
+"force_animation_next_refresh_subtitle" = "次回の更新後に読み込みアニメーションを一時的に表示します。";
+"section_loading_animations" = "読み込みアニメーション";
+"loading_animations_caption" = "パターンを選んでメニューバーで再生できます。\"ランダム\"は既存の動作を維持します。";
+"animation_random_default" = "ランダム（デフォルト）";
+"replay_selected_animation" = "選択したアニメーションを再生";
+"blink_now" = "今すぐ点滅";
+"section_probe_logs" = "プローブログ";
+"probe_logs_caption" = "デバッグ用に最新のプローブ出力を取得します。コピーでは全文が保持されます。";
+"fetch_log" = "ログを取得";
+"copy" = "コピー";
+"save_to_file" = "ファイルに保存";
+"load_parse_dump" = "解析ダンプを読み込む";
+"rerun_provider_autodetect" = "プロバイダの自動検出を再実行";
+"loading" = "読み込み中…";
+"no_log_yet_fetch" = "ログはまだありません。取得して読み込んでください。";
+"section_fetch_strategy" = "取得戦略の試行";
+"fetch_strategy_caption" = "プロバイダに対する直近の取得パイプラインの判断とエラーです。";
+"section_openai_cookies" = "OpenAI Cookie";
+"openai_cookies_caption" = "前回の OpenAI Cookie 試行における Cookie インポートと WebKit スクレイピングのログです。";
+"no_log_yet" = "ログはまだありません。プロバイダ → Codex で OpenAI Cookie を更新するとインポートが実行されます。";
+"section_caches" = "キャッシュ";
+"caches_caption" = "キャッシュされたコストスキャン結果またはブラウザの Cookie キャッシュを消去します。";
+"clear_cookie_cache" = "Cookie キャッシュを消去";
+"clear_cost_cache" = "コストキャッシュを消去";
+"section_notifications" = "通知";
+"notifications_caption" = "5時間セッション枠（枯渇/回復）のテスト通知を発行します。";
+"post_depleted" = "枯渇通知を送信";
+"post_restored" = "回復通知を送信";
+"section_cli_sessions" = "CLI セッション";
+"cli_sessions_caption" = "プローブ後も Codex/Claude の CLI セッションを維持します。デフォルトではデータ取得後に終了します。";
+"keep_cli_sessions_alive" = "CLI セッションを維持する";
+"keep_cli_sessions_alive_subtitle" = "プローブ間のクリーンアップをスキップします（デバッグ専用）。";
+"reset_cli_sessions" = "CLI セッションをリセット";
+"section_error_simulation" = "エラーシミュレーション";
+"error_simulation_caption" = "レイアウトテスト用に、メニューカードへ偽のエラーメッセージを挿入します。";
+"set_menu_error" = "メニューエラーを設定";
+"clear_menu_error" = "メニューエラーを消去";
+"set_cost_error" = "コストエラーを設定";
+"clear_cost_error" = "コストエラーを消去";
+"section_cli_paths" = "CLI パス";
+"cli_paths_caption" = "解決された Codex バイナリと PATH レイヤー、起動時のログインシェル PATH 取得（短いタイムアウト）です。";
+"codex_binary" = "Codex バイナリ";
+"claude_binary" = "Claude バイナリ";
+"effective_path" = "有効な PATH";
+"unavailable" = "利用不可";
+"login_shell_path" = "ログインシェル PATH（起動時に取得）";
+"cleared" = "消去しました。";
+"no_fetch_attempts" = "取得の試行はまだありません。";
+"macOS Tahoe can block menu bar apps in System Settings → Menu Bar → Allow in the Menu Bar. CodexBar is running, but macOS may be hiding its icon. Open Menu Bar settings and turn CodexBar on." = "macOS Tahoe では、システム設定 → メニューバー → メニューバーに表示を許可 でメニューバーアプリがブロックされることがあります。CodexBar は実行中ですが、macOS がアイコンを非表示にしている可能性があります。メニューバー設定を開き、CodexBar をオンにしてください。";
+
+/* Metric preferences */
+"metric_pref_automatic" = "自動";
+"metric_pref_primary" = "プライマリ";
+"metric_pref_secondary" = "セカンダリ";
+"metric_pref_tertiary" = "第3";
+"metric_pref_extra_usage" = "追加使用量";
+"metric_pref_average" = "平均";
+"metric_mistral_payg" = "Pay-as-you-go";
+"metric_mistral_monthly_plan" = "Monthly Plan";
+
+/* Display modes */
+"display_mode_percent" = "パーセント";
+"display_mode_pace" = "ペース";
+"display_mode_both" = "両方";
+"display_mode_reset_time" = "リセット時刻";
+"display_mode_percent_desc" = "残り/使用済みのパーセンテージを表示（例: 45%）";
+"display_mode_pace_desc" = "ペースインジケータを表示（例: +5%）";
+"display_mode_both_desc" = "パーセンテージとペースの両方を表示（例: 45% · +5%）";
+"display_mode_reset_time_desc" = "選択した指標のリセット時刻を表示（例: ↻ 15:56）";
+
+/* Provider status */
+"status_operational" = "正常稼働中";
+"status_partial_outage" = "一部障害";
+"status_major_outage" = "重大な障害";
+"status_critical_issue" = "致命的な問題";
+"status_maintenance" = "メンテナンス中";
+"status_unknown" = "ステータス不明";
+
+/* Refresh frequency */
+"refresh_manual" = "手動";
+"refresh_1min" = "1分";
+"refresh_2min" = "2分";
+"refresh_5min" = "5分";
+"refresh_15min" = "15分";
+"refresh_30min" = "30分";
+
+/* Additional keys */
+"not_found" = "見つかりません";
+
+/* Cost estimation */
+"cost_header_estimated" = "コスト（推定）";
+"cost_estimate_hint" = "ローカルログからの推定値 · 請求額と異なる場合があります";
+"No JetBrains IDE with AI Assistant detected. Install a JetBrains IDE and enable AI Assistant." = "AI Assistant 対応の JetBrains IDE が検出されませんでした。JetBrains IDE をインストールし、AI Assistant を有効にしてください。";
+"OpenRouter API token not configured. Set OPENROUTER_API_KEY environment variable or configure in Settings." = "OpenRouter API トークンが設定されていません。環境変数 OPENROUTER_API_KEY を設定するか、設定で構成してください。";
+"z.ai API token not found. Set apiKey in ~/.codexbar/config.json or Z_AI_API_KEY." = "z.ai API トークンが見つかりません。~/.codexbar/config.json の apiKey または Z_AI_API_KEY を設定してください。";
+"Missing DeepSeek API key." = "DeepSeek API キーがありません。";
+"%@ is unavailable in the current environment." = "%@ は現在の環境では利用できません。";
+"All Systems Operational" = "全システム正常稼働中";
+"Last 30 days" = "過去30日間";
+"Last 30 days:" = "過去30日間:";
+"This month" = "今月";
+"Store multiple OpenAI API keys." = "複数の OpenAI API キーを保存します。";
+"Admin API key" = "管理者 API キー";
+"Open billing" = "請求情報を開く";
+"Google accounts" = "Google アカウント";
+"Store multiple Antigravity Google OAuth accounts for quick switching." = "複数の Antigravity Google OAuth アカウントを保存して素早く切り替えられます。";
+"Add Google Account" = "Google アカウントを追加";
+"Open Token Plan" = "トークンプランを開く";
+"Text Generation" = "テキスト生成";
+"Text to Speech" = "音声合成";
+"Music Generation" = "音楽生成";
+"Image Generation" = "画像生成";
+"No local data found" = "ローカルデータが見つかりません";
+"Credits unavailable; keep Codex running to refresh." = "クレジット情報を取得できません。更新するには Codex を実行したままにしてください。";
+"No available fetch strategy for minimax." = "minimax に利用可能な取得戦略がありません。";
+"No Cursor session found. Please log in to cursor.com in Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX, or Edge Canary. If you use Safari, grant CodexBar Full Disk Access in System Settings ▸ Privacy & Security. You can also sign in to Cursor from the CodexBar menu (Add / switch account)." = "Cursor のセッションが見つかりません。Safari、Chrome、Microsoft Edge、Brave、Arc、Dia、ChatGPT Atlas、Chromium、Helium、Vivaldi、Yandex Browser、Firefox、Zen、Colibri、Sidekick、Opera、Opera GX、または Edge Canary で cursor.com にログインしてください。Safari をお使いの場合は、システム設定 ▸ プライバシーとセキュリティ で CodexBar にフルディスクアクセスを許可してください。CodexBar のメニューから Cursor にサインインすることもできます（アカウントを追加/切り替え）。";
+"No OpenCode session cookies found in browsers." = "ブラウザに OpenCode のセッション Cookie が見つかりません。";
+"No available fetch strategy for %@." = "%@ に利用可能な取得戦略がありません。";
+"Today" = "今日";
+"Today tokens" = "今日のトークン";
+"30d cost" = "過去30日間のコスト";
+"30d tokens" = "過去30日間のトークン";
+"Latest tokens" = "最新のトークン";
+"Top model" = "最多使用モデル";
+"Storage" = "ストレージ";
+"Add Account..." = "アカウントを追加...";
+"Usage Dashboard" = "使用状況ダッシュボード";
+"Status Page" = "ステータスページ";
+"Settings..." = "設定...";
+"About CodexBar" = "CodexBar について";
+"Quit" = "終了";
+"Last %d day" = "過去%d日間";
+"Last %d days" = "過去%d日間";
+"%@ tokens" = "%@ トークン";
+"Latest billing day" = "直近の請求日";
+"Latest billing day (%@)" = "直近の請求日（%@）";
+"%@ left" = "残り %@";
+"Resets %@" = "%@ にリセット";
+"Resets in %@" = "%@ 後にリセット";
+"Resets now" = "まもなくリセット";
+"reset_tomorrow_format" = "明日 %@";
+"Lasts until reset" = "リセットまで持続";
+"Updated %@" = "%@ に更新";
+"Updated %@h ago" = "%@時間前に更新";
+"Updated %@m ago" = "%@分前に更新";
+"Updated just now" = "たった今更新";
+"Projected empty in %@" = "%@ 後に枯渇する見込み";
+"Runs out in %@" = "%@ 後に使い切る見込み";
+"Pace: %@" = "ペース: %@";
+"Pace: %@ · %@" = "ペース: %@ · %@";
+"%@ · %@" = "%@ · %@";
+"≈ %d%% run-out risk" = "枯渇リスク ≈ %d%%";
+"%d%% in deficit" = "%d%% 不足";
+"%d%% in reserve" = "%d%% 余裕";
+"usage_percent_suffix_left" = "残り";
+"usage_percent_suffix_used" = "使用済み";
+"Store multiple DeepSeek API keys." = "複数の DeepSeek API キーを保存します。";
+"This week" = "今週";
+"Week" = "週";
+"Month" = "月";
+"Models" = "モデル";
+"24h tokens" = "24時間のトークン";
+"Latest hour" = "直近1時間";
+"Peak hour" = "ピーク時間帯";
+"Top method" = "最多使用メソッド";
+"30d cash" = "過去30日間の支出";
+"30d billing history from MiniMax web session" = "MiniMax Web セッションからの30日間の請求履歴";
+"AWS Cost Explorer billing can lag." = "AWS Cost Explorer の請求情報は反映が遅れることがあります。";
+"Rate limit: %d / %@" = "レート制限: %d / %@";
+"Key remaining" = "キーの残量";
+"No limit set for the API key" = "API キーに上限が設定されていません";
+"API key limit unavailable right now" = "API キーの上限は現在取得できません";
+"This month: %@ tokens" = "今月: %@ トークン";
+"No utilization data yet." = "使用率データはまだありません。";
+"No %@ utilization data yet." = "%@ の使用率データはまだありません。";
+"%@: %@%% used" = "%@: %@%% 使用済み";
+"%dd" = "%d日";
+"today" = "今日";
+"just now" = "たった今";
+"On pace" = "想定ペース";
+"Runs out now" = "まもなく使い切ります";
+"Projected empty now" = "まもなく枯渇する見込み";
+"Switch Account..." = "アカウントを切り替え...";
+"Update ready, restart now?" = "アップデートの準備ができました。今すぐ再起動しますか？";
+"Daily" = "日別";
+"Hourly Tokens" = "時間別トークン";
+"No data" = "データなし";
+"No usage breakdown data available." = "使用状況の内訳データがありません。";
+
+"Today: %@ · %@ tokens" = "今日: %@ · %@ トークン";
+"Today: %@" = "今日: %@";
+"Today: %@ tokens" = "今日: %@ トークン";
+"Last 30 days: %@ · %@ tokens" = "過去30日間: %@ · %@ トークン";
+"Last 30 days: %@" = "過去30日間: %@";
+"Est. total (30d): %@" = "推定合計（30日間）: %@";
+"Est. total (%@): %@" = "推定合計（%@）: %@";
+"Hover a bar for details" = "バーにポインタを合わせると詳細が表示されます";
+"%@: %@ · %@ tokens" = "%@: %@ · %@ トークン";
+"No providers selected for Overview." = "概要に表示するプロバイダが選択されていません。";
+"No overview data available." = "概要データがありません。";
+"Auto uses the local IDE API first, then Google OAuth when the IDE is closed." = "自動では、まずローカルの IDE API を使用し、IDE が閉じている場合は Google OAuth を使用します。";
+"Login with Google" = "Google でログイン";
+
+/* Popup panels */
+"No usage configured." = "使用状況が設定されていません。";
+"Quota" = "クォータ";
+"tokens" = "トークン";
+"requests" = "リクエスト";
+"Latest" = "最新";
+"Monthly" = "月間";
+"Sonnet" = "Sonnet";
+"Overages" = "超過分";
+"Activity" = "アクティビティ";
+"Copied" = "コピーしました";
+"Copy error" = "エラーをコピー";
+"Copy path" = "パスをコピー";
+"Extra usage spent" = "追加使用分の支出";
+"Credits remaining" = "残りクレジット";
+"Using CLI fallback" = "CLI フォールバックを使用中";
+"Balance updates in near-real time (up to 5 min lag)" = "残高はほぼリアルタイムで更新されます（最大5分の遅延）";
+"Daily billing data finalizes at 07:00 UTC" = "日次請求データは 07:00 UTC に確定します";
+"%@ of %@ credits left" = "クレジット残り %@ / %@";
+"%@ of %@ bonus credits left" = "ボーナスクレジット残り %@ / %@";
+"%@ / %@ (%@ remaining)" = "%@ / %@（残り %@）";
+"%@/%@ left" = "残り %@/%@";
+"Gemini Flash" = "Gemini Flash";
+"Regenerates %@" = "%@ に再生成";
+"used after next regen" = "次回再生成後の使用率";
+"after next regen" = "次回再生成後";
+"Near full" = "ほぼ満タン";
+"Full in ~1 regen" = "約1回の再生成で満タン";
+"Full in ~%.0f regens" = "約%.0f回の再生成で満タン";
+"Overage usage" = "超過使用量";
+"Overage cost" = "超過コスト";
+"credits" = "クレジット";
+"Zen balance" = "Zen 残高";
+"API spend" = "API 支出";
+"Extra usage" = "追加使用量";
+"Quota usage" = "クォータ使用量";
+"Your spend" = "あなたの支出";
+"%.0f%% used" = "%.0f%% 使用済み";
+"Usage history (today)" = "使用履歴（今日）";
+"Usage history (%d days)" = "使用履歴（%d日間）";
+"%d percent remaining" = "残り %d パーセント";
+"Unknown" = "不明";
+"stale data" = "古いデータ";
+"No credits history data." = "クレジット履歴データがありません。";
+"No credits history data available." = "利用可能なクレジット履歴データがありません。";
+"Credits history chart" = "クレジット履歴チャート";
+"%d days of credits data" = "%d日間のクレジットデータ";
+"Usage breakdown chart" = "使用状況の内訳チャート";
+"%d days of usage data across %d services" = "%2$dサービスにわたる%1$d日間の使用状況データ";
+"Cost history chart" = "コスト履歴チャート";
+"%d days of cost data" = "%d日間のコストデータ";
+"Plan utilization chart" = "プラン使用率チャート";
+"%d utilization samples" = "%d 件の使用率サンプル";
+"Hourly Usage" = "時間別使用量";
+"Usage remaining" = "残りの使用量";
+"Usage used" = "使用済みの使用量";
+"API key verified. Ollama does not expose Cloud quota limits through the API." = "API キーを確認しました。OllamaはAPI経由でCloudクォータ上限を公開していません。";
+"Last 30 days: %@ tokens" = "過去30日間: %@ トークン";
+"7d spend" = "7日間の支出";
+"30d spend" = "過去30日間の支出";
+"Cache read" = "キャッシュ読み取り";
+"Claude Admin API 30 day spend trend" = "Claude Admin API の30日間支出推移";
+"OpenRouter API key spend trend" = "OpenRouter API キーの支出推移";
+"z.ai hourly token trend" = "z.ai の時間別トークン推移";
+"MiniMax 30 day token usage trend" = "MiniMax の30日間トークン使用量推移";
+"Today cash" = "本日の現金";
+"DeepSeek 30 day token usage trend" = "DeepSeek の30日間トークン使用量推移";
+"cache-hit input" = "キャッシュヒット入力";
+"cache-miss input" = "キャッシュミス入力";
+"output" = "出力";
+"Requests" = "リクエスト";
+"Reported by OpenAI Admin API organization usage." = "OpenAI Admin API の組織使用量から報告されています。";
+"Reported by Mistral billing usage." = "Mistral の請求使用量から報告されています。";
+"Google OAuth" = "Google OAuth";
+"Add accounts via GitHub OAuth Device Flow on the selected host." = "選択したホスト上で GitHub OAuth Device Flow を使ってアカウントを追加します。";
+"Stores each signed-in Google account for quick Antigravity switching. Uses Antigravity.app OAuth when available, or ANTIGRAVITY_OAUTH_CLIENT_ID and ANTIGRAVITY_OAUTH_CLIENT_SECRET as an override." = "サインイン済みの各 Google アカウントを保存し、Antigravity をすばやく切り替えられるようにします。利用可能な場合は Antigravity.app の OAuth を使用し、上書き設定として ANTIGRAVITY_OAUTH_CLIENT_ID と ANTIGRAVITY_OAUTH_CLIENT_SECRET を使用できます。";
+"Manual cleanup: past sessions" = "手動クリーンアップ: 過去のセッション";
+"Clearing removes past resume, continue, and rewind history." = "消去すると、過去の再開・継続・巻き戻しの履歴が削除されます。";
+"Manual cleanup: file checkpoints" = "手動クリーンアップ: ファイルチェックポイント";
+"Clearing removes checkpoint restore data for previous edits." = "消去すると、過去の編集のチェックポイント復元データが削除されます。";
+"Manual cleanup: saved plans" = "手動クリーンアップ: 保存済みプラン";
+"Clearing removes old plan-mode files." = "消去すると、古いプランモードのファイルが削除されます。";
+"Manual cleanup: debug logs" = "手動クリーンアップ: デバッグログ";
+"Clearing removes past debug logs." = "消去すると、過去のデバッグログが削除されます。";
+"Manual cleanup: attachment cache" = "手動クリーンアップ: 添付ファイルキャッシュ";
+"Clearing removes cached large pastes or attached images." = "消去すると、キャッシュされた大きなペースト内容や添付画像が削除されます。";
+"Manual cleanup: session metadata" = "手動クリーンアップ: セッションメタデータ";
+"Clearing removes per-session environment metadata." = "消去すると、セッションごとの環境メタデータが削除されます。";
+"Manual cleanup: shell snapshots" = "手動クリーンアップ: シェルスナップショット";
+"Clearing removes leftover runtime shell snapshot files." = "消去すると、残存しているランタイムシェルのスナップショットファイルが削除されます。";
+"Manual cleanup: legacy todos" = "手動クリーンアップ: レガシー ToDo";
+"Clearing removes legacy per-session task lists." = "消去すると、セッションごとのレガシータスクリストが削除されます。";
+"Manual cleanup: sessions" = "手動クリーンアップ: セッション";
+"Clearing removes past Codex session history." = "消去すると、過去の Codex セッション履歴が削除されます。";
+"Manual cleanup: archived sessions" = "手動クリーンアップ: アーカイブ済みセッション";
+"Clearing removes archived Codex session history." = "消去すると、アーカイブされた Codex セッション履歴が削除されます。";
+"Manual cleanup: cache" = "手動クリーンアップ: キャッシュ";
+"Clearing removes provider-owned cached data." = "消去すると、プロバイダが保持するキャッシュデータが削除されます。";
+"Manual cleanup: logs" = "手動クリーンアップ: ログ";
+"Clearing removes local diagnostic logs." = "消去すると、ローカルの診断ログが削除されます。";
+"Manual cleanup: file history" = "手動クリーンアップ: ファイル履歴";
+"Clearing removes local edit checkpoint history." = "消去すると、ローカルの編集チェックポイント履歴が削除されます。";
+"Manual cleanup: temporary data" = "手動クリーンアップ: 一時データ";
+"Clearing removes local temporary provider data." = "消去すると、ローカルのプロバイダ一時データが削除されます。";
+"Total: %@" = "合計: %@";
+"%d more items" = "他 %d 件の項目";
+"Cleanup ideas" = "クリーンアップの候補";
+"%d unreadable item(s) skipped" = "読み取れない項目 %d 件をスキップしました";
+
+"API key limit" = "API キー上限";
+"Auth" = "認証";
+"Auto" = "自動";
+"Disabled — no recent data" = "無効 — 最近のデータなし";
+"Limits not available" = "上限情報なし";
+"No usage yet" = "まだ使用量がありません";
+"Not fetched yet" = "未取得";
+"Refreshing" = "更新中";
+"Session" = "セッション";
+"Source" = "ソース";
+"State" = "状態";
+"Unavailable" = "利用不可";
+"Weekly" = "週間";
+"not detected" = "未検出";
+"Estimated from local Codex logs for the selected account." = "選択したアカウントのローカル Codex ログから推定しています。";
+"minimax_usage_amount_format" = "使用量: %@ / %@";
+"minimax_used_percent_format" = "使用済み %@";
+"minimax_service_text_generation" = "テキスト生成";
+"minimax_service_text_to_speech" = "音声合成";
+"minimax_service_music_generation" = "音楽生成";
+"minimax_service_image_generation" = "画像生成";
+"minimax_service_lyrics_generation" = "歌詞生成";
+"minimax_service_coding_plan_vlm" = "コーディングプラン VLM";
+"minimax_service_coding_plan_search" = "コーディングプラン検索";
+
+/* Additional provider settings and alerts */
+"%@ is waiting for permission" = "%@ は許可を待っています";
+"%@ requests" = "%@ リクエスト";
+"%@: %@ credits" = "%@: %@ クレジット";
+"30d requests" = "過去30日間のリクエスト";
+"4 days" = "4日間";
+"5 days" = "5日間";
+"7 days" = "7日間";
+"API key verifies Ollama Cloud access; cookies still expose quota limits." = "API キーで Ollama Cloud へのアクセスを確認できますが、クォータ上限の取得には引き続き Cookie が必要です。";
+"AWS access key ID. Can also be set with AWS_ACCESS_KEY_ID." = "AWS アクセスキー ID。AWS_ACCESS_KEY_ID でも設定できます。";
+"AWS region. Can also be set with AWS_REGION." = "AWS リージョン。AWS_REGION でも設定できます。";
+"AWS secret access key. Can also be set with AWS_SECRET_ACCESS_KEY." = "AWS シークレットアクセスキー。AWS_SECRET_ACCESS_KEY でも設定できます。";
+"Access key ID" = "アクセスキー ID";
+"Add Account" = "アカウントを追加";
+"Adding Account…" = "アカウントを追加中…";
+"Antigravity login failed" = "Antigravity のログインに失敗しました";
+"Antigravity login timed out" = "Antigravity のログインがタイムアウトしました";
+"Auth source" = "認証ソース";
+"Automatic imports browser cookies from Xiaomi MiMo." = "自動では Xiaomi MiMo のブラウザ Cookie を読み込みます。";
+"Automatic imports Windsurf session data from Chromium browser localStorage." = "自動では Chromium ブラウザの localStorage から Windsurf セッションデータを読み込みます。";
+"Automatic imports browser cookies from Bailian." = "自動では Bailian のブラウザ Cookie を読み込みます。";
+"Automatically imports browser cookies." = "ブラウザの Cookie を自動的に読み込みます。";
+"Automatically imports browser session cookies." = "ブラウザのセッション Cookie を自動的に読み込みます。";
+"Azure OpenAI deployment name. AZURE_OPENAI_DEPLOYMENT_NAME is also supported." = "Azure OpenAI のデプロイメント名。AZURE_OPENAI_DEPLOYMENT_NAME もサポートされています。";
+"Azure OpenAI key" = "Azure OpenAI キー";
+"Azure OpenAI resource endpoint. AZURE_OPENAI_ENDPOINT is also supported." = "Azure OpenAI リソースのエンドポイント。AZURE_OPENAI_ENDPOINT もサポートされています。";
+"Base URL" = "ベース URL";
+"Base URL for the LLM-API-Key-Proxy instance." = "LLM-API-Key-Proxy インスタンスのベース URL。";
+"Browser cookies" = "ブラウザ Cookie";
+"Cap end" = "上限終了";
+"Cap start" = "上限開始";
+"Capacity End" = "キャパシティ終了";
+"Capacity Start" = "キャパシティ開始";
+"Changelog" = "変更履歴";
+"Choose the Moonshot/Kimi API host for international or China mainland accounts." = "国際アカウントまたは中国本土アカウント用の Moonshot/Kimi API ホストを選択します。";
+"CodexBar can't replace a system account that is signed in with an API key only setup." = "CodexBar は、API キーのみの構成でサインインしているシステムアカウントを置き換えることはできません。";
+"CodexBar could not find saved auth for that account. Re-authenticate it and try again." = "CodexBar はそのアカウントの保存済み認証情報を見つけられませんでした。再認証してからやり直してください。";
+"CodexBar could not read managed account storage. Recover the store before adding another account." = "CodexBar は管理アカウントのストレージを読み取れませんでした。別のアカウントを追加する前にストアを復旧してください。";
+"CodexBar could not read saved auth for that account. Re-authenticate it and try again." = "CodexBar はそのアカウントの保存済み認証情報を読み取れませんでした。再認証してからやり直してください。";
+"CodexBar could not read the current system account on this Mac." = "CodexBar はこの Mac の現在のシステムアカウントを読み取れませんでした。";
+"CodexBar could not replace the live Codex auth on this Mac." = "CodexBar はこの Mac の現在使用中の Codex 認証情報を置き換えられませんでした。";
+"CodexBar could not safely preserve the current system account before switching." = "CodexBar は切り替え前に現在のシステムアカウントを安全に保全できませんでした。";
+"CodexBar could not save the current system account before switching." = "CodexBar は切り替え前に現在のシステムアカウントを保存できませんでした。";
+"CodexBar could not update managed account storage." = "CodexBar は管理アカウントのストレージを更新できませんでした。";
+"CodexBar found another managed account that already uses the current system account. Resolve the duplicate account before switching." = "CodexBar は、現在のシステムアカウントをすでに使用している別の管理アカウントを検出しました。切り替える前に重複アカウントを解消してください。";
+"CodexBar will ask macOS Keychain for “%@” so it can decrypt browser cookies and authenticate your account. Click OK to continue." = "CodexBar はブラウザの Cookie を復号してアカウントを認証するために、macOS キーチェーンに「%@」へのアクセスを求めます。続けるには OK をクリックしてください。";
+"CodexBar will ask macOS Keychain for the Claude Code OAuth token so it can fetch your Claude usage. Click OK to continue." = "CodexBar は Claude の使用量を取得するために、macOS キーチェーンに Claude Code の OAuth トークンへのアクセスを求めます。続けるには OK をクリックしてください。";
+"CodexBar will ask macOS Keychain for your Amp cookie header so it can fetch usage. Click OK to continue." = "CodexBar は使用量を取得するために、macOS キーチェーンに Amp の Cookie ヘッダーへのアクセスを求めます。続けるには OK をクリックしてください。";
+"CodexBar will ask macOS Keychain for your Augment cookie header so it can fetch usage. Click OK to continue." = "CodexBar は使用量を取得するために、macOS キーチェーンに Augment の Cookie ヘッダーへのアクセスを求めます。続けるには OK をクリックしてください。";
+"CodexBar will ask macOS Keychain for your Claude cookie header so it can fetch Claude web usage. Click OK to continue." = "CodexBar は Claude ウェブの使用量を取得するために、macOS キーチェーンに Claude の Cookie ヘッダーへのアクセスを求めます。続けるには OK をクリックしてください。";
+"CodexBar will ask macOS Keychain for your Cursor cookie header so it can fetch usage. Click OK to continue." = "CodexBar は使用量を取得するために、macOS キーチェーンに Cursor の Cookie ヘッダーへのアクセスを求めます。続けるには OK をクリックしてください。";
+"CodexBar will ask macOS Keychain for your Factory cookie header so it can fetch usage. Click OK to continue." = "CodexBar は使用量を取得するために、macOS キーチェーンに Factory の Cookie ヘッダーへのアクセスを求めます。続けるには OK をクリックしてください。";
+"CodexBar will ask macOS Keychain for your GitHub Copilot token so it can fetch usage. Click OK to continue." = "CodexBar は使用量を取得するために、macOS キーチェーンに GitHub Copilot のトークンへのアクセスを求めます。続けるには OK をクリックしてください。";
+"CodexBar will ask macOS Keychain for your Kimi K2 API key so it can fetch usage. Click OK to continue." = "CodexBar は使用量を取得するために、macOS キーチェーンに Kimi K2 の API キーへのアクセスを求めます。続けるには OK をクリックしてください。";
+"CodexBar will ask macOS Keychain for your Kimi auth token so it can fetch usage. Click OK to continue." = "CodexBar は使用量を取得するために、macOS キーチェーンに Kimi の認証トークンへのアクセスを求めます。続けるには OK をクリックしてください。";
+"CodexBar will ask macOS Keychain for your MiniMax API token so it can fetch usage. Click OK to continue." = "CodexBar は使用量を取得するために、macOS キーチェーンに MiniMax の API トークンへのアクセスを求めます。続けるには OK をクリックしてください。";
+"CodexBar will ask macOS Keychain for your MiniMax cookie header so it can fetch usage. Click OK to continue." = "CodexBar は使用量を取得するために、macOS キーチェーンに MiniMax の Cookie ヘッダーへのアクセスを求めます。続けるには OK をクリックしてください。";
+"CodexBar will ask macOS Keychain for your OpenAI cookie header so it can fetch Codex dashboard extras. Click OK to continue." = "CodexBar は Codex ダッシュボードの追加情報を取得するために、macOS キーチェーンに OpenAI の Cookie ヘッダーへのアクセスを求めます。続けるには OK をクリックしてください。";
+"CodexBar will ask macOS Keychain for your OpenCode cookie header so it can fetch usage. Click OK to continue." = "CodexBar は使用量を取得するために、macOS キーチェーンに OpenCode の Cookie ヘッダーへのアクセスを求めます。続けるには OK をクリックしてください。";
+"CodexBar will ask macOS Keychain for your Synthetic API key so it can fetch usage. Click OK to continue." = "CodexBar は使用量を取得するために、macOS キーチェーンに Synthetic の API キーへのアクセスを求めます。続けるには OK をクリックしてください。";
+"CodexBar will ask macOS Keychain for your z.ai API token so it can fetch usage. Click OK to continue." = "CodexBar は使用量を取得するために、macOS キーチェーンに z.ai の API トークンへのアクセスを求めます。続けるには OK をクリックしてください。";
+"Could not open Cursor login in your browser." = "ブラウザで Cursor のログイン画面を開けませんでした。";
+"Could not open browser for Antigravity" = "Antigravity 用のブラウザを開けませんでした";
+"Credits used" = "使用済みクレジット";
+"Day" = "日";
+"Deployment" = "デプロイメント";
+"Drag to reorder" = "ドラッグして並べ替え";
+"Sort providers alphabetically" = "プロバイダーをアルファベット順に並べ替え";
+"Sort providers alphabetically (enabled first)" = "プロバイダーをアルファベット順に並べ替え（有効なものを先頭）";
+"Sorted alphabetically (enabled first) — click to use your custom order" = "アルファベット順（有効なものを先頭）— クリックしてカスタム順に戻す";
+"Endpoint" = "エンドポイント";
+"Enterprise host" = "Enterprise ホスト";
+"Extra usage balance: %@" = "追加使用量の残高: %@";
+"Keychain Access Required" = "キーチェーンへのアクセスが必要です";
+"Kiro menu bar value" = "Kiro メニューバー表示値";
+"Label" = "ラベル";
+"No organizations loaded. Click Refresh after setting your API key." = "組織が読み込まれていません。API キーを設定してから「更新」をクリックしてください。";
+"No output captured." = "出力は取得されませんでした。";
+"No system account" = "システムアカウントなし";
+"Oasis-Token" = "Oasis-Token";
+"Open Augment (Log Out & Back In)" = "Augment を開く(ログアウトして再ログイン)";
+"Open Codebuff Dashboard" = "Codebuff ダッシュボードを開く";
+"Open Command Code Settings" = "Command Code 設定を開く";
+"Open Crof dashboard" = "Crof ダッシュボードを開く";
+"Open Manus" = "Manus を開く";
+"Open MiMo Balance" = "MiMo 残高を開く";
+"Open Moonshot Console" = "Moonshot コンソールを開く";
+"Open Ollama API Keys" = "Ollama API キーを開く";
+"Open StepFun Platform" = "StepFun プラットフォームを開く";
+"Open T3 Chat Settings" = "T3 Chat 設定を開く";
+"Open Volcengine Ark Console" = "Volcengine Ark コンソールを開く";
+"Open legacy provider docs" = "レガシープロバイダのドキュメントを開く";
+"Open projects" = "プロジェクトを開く";
+"Open this URL manually to continue login:\n\n%@" = "ログインを続けるには、この URL を手動で開いてください:\n\n%@";
+"Optional organization ID for accounts linked to multiple Anthropic organizations." = "複数の Anthropic 組織にリンクされたアカウント用のオプションの組織 ID。";
+"Optional. Applies to the configured Admin API key; selected token accounts do not inherit OPENAI_PROJECT_ID." = "オプション。設定済みの Admin API キーに適用されます。選択したトークンアカウントには OPENAI_PROJECT_ID は引き継がれません。";
+"Optional. Enter your GitHub Enterprise host, for example octocorp.ghe.com. Leave blank for github.com." = "オプション。GitHub Enterprise のホストを入力してください(例: octocorp.ghe.com)。github.com の場合は空欄のままにしてください。";
+"Optional. Leave blank to discover and aggregate projects visible to the API key." = "オプション。空欄のままにすると、API キーから参照できるプロジェクトを検出して集計します。";
+"Org ID (optional)" = "組織 ID(オプション)";
+"Organizations" = "組織";
+"Password" = "パスワード";
+"%@ authentication is disabled." = "%@ の認証は無効になっています。";
+"%@ cookies are disabled." = "%@ の Cookie は無効になっています。";
+"%@ web API access is disabled." = "%@ のウェブ API アクセスは無効になっています。";
+"Disable %@ dashboard cookie usage." = "%@ ダッシュボードの Cookie 使用を無効にします。";
+"Keychain access is disabled in Advanced, so browser cookie import is unavailable." = "詳細設定でキーチェーンへのアクセスが無効になっているため、ブラウザ Cookie の読み込みは利用できません。";
+"Manually paste an %@ from a browser session." = "ブラウザセッションから %@ を手動で貼り付けてください。";
+"Paste a Cookie header captured from %@." = "%@ から取得した Cookie ヘッダーを貼り付けてください。";
+"Paste a Cookie header from %@." = "%@ の Cookie ヘッダーを貼り付けてください。";
+"Paste a Cookie header or cURL capture from %@." = "%@ の Cookie ヘッダーまたは cURL キャプチャを貼り付けてください。";
+"Paste a Cookie header or full cURL capture from %@." = "%@ の Cookie ヘッダーまたは完全な cURL キャプチャを貼り付けてください。";
+"Paste a Cookie or Authorization header from %@." = "%@ の Cookie または Authorization ヘッダーを貼り付けてください。";
+"Paste a full cookie header or the %@ value." = "完全な Cookie ヘッダーまたは %@ の値を貼り付けてください。";
+"Paste a Cookie header or full cURL capture from T3 Chat settings." = "T3 Chat 設定から取得した Cookie ヘッダーまたは完全な cURL キャプチャを貼り付けてください。";
+"Paste the Cookie header from a request to admin.mistral.ai. Must contain an ory_session_* cookie." = "admin.mistral.ai へのリクエストの Cookie ヘッダーを貼り付けてください。ory_session_* Cookie が含まれている必要があります。";
+"Paste the Oasis-Token from a logged-in browser session on platform.stepfun.com." = "platform.stepfun.com にログイン中のブラウザセッションから Oasis-Token を貼り付けてください。";
+"Paste the %@ JSON bundle from %@." = "%@ の JSON バンドルを %@ から貼り付けてください。";
+"Paste the %@ value or a full Cookie header." = "%@ の値または完全な Cookie ヘッダーを貼り付けてください。";
+"Personal account" = "個人アカウント";
+"Project ID" = "プロジェクト ID";
+"Re-auth" = "再認証";
+"Re-login at claude.ai" = "claude.ai で再ログイン";
+"Re-authenticating…" = "再認証中…";
+"Refresh Session" = "セッションを更新";
+"Refresh organizations" = "組織を更新";
+"Region" = "リージョン";
+"Reload" = "再読み込み";
+"Reorder" = "並べ替え";
+"Secret access key" = "シークレットアクセスキー";
+"Series" = "シリーズ";
+"Service" = "サービス";
+"Show or hide Kiro credits, percent, or both next to the menu bar icon." = "メニューバーアイコンの横に Kiro のクレジット、パーセント、またはその両方を表示/非表示にします。";
+"Show usage for organizations you belong to. Personal account is always shown." = "所属している組織の使用量を表示します。個人アカウントは常に表示されます。";
+"Sign in to cursor.com in your browser, then refresh Cursor in CodexBar." = "ブラウザで cursor.com にサインインしてから、CodexBar で Cursor を更新してください。";
+"Simulated error text" = "シミュレートされたエラーテキスト";
+"StepFun platform account (phone number or email)." = "StepFun プラットフォームのアカウント(電話番号またはメールアドレス)。";
+"Stored in ~/.codexbar/config.json." = "~/.codexbar/config.json に保存されます。";
+"Stored in ~/.codexbar/config.json. AZURE_OPENAI_API_KEY is also supported." = "~/.codexbar/config.json に保存されます。AZURE_OPENAI_API_KEY もサポートされています。";
+"Stored in ~/.codexbar/config.json. For the official Kimi API, use Moonshot / Kimi API." = "~/.codexbar/config.json に保存されます。公式の Kimi API には Moonshot / Kimi API を使用してください。";
+"Stored in ~/.codexbar/config.json. Get your API key from the Volcengine Ark console." = "~/.codexbar/config.json に保存されます。API キーは Volcengine Ark コンソールから取得してください。";
+"Stored in ~/.codexbar/config.json. Get your key from Ollama settings." = "~/.codexbar/config.json に保存されます。キーは Ollama の設定から取得してください。";
+"Stored in ~/.codexbar/config.json. Get your key from console.deepgram.com." = "~/.codexbar/config.json に保存されます。キーは console.deepgram.com から取得してください。";
+"Stored in ~/.codexbar/config.json. Get your key from elevenlabs.io/app/settings/api-keys." = "~/.codexbar/config.json に保存されます。キーは elevenlabs.io/app/settings/api-keys から取得してください。";
+"Stored in ~/.codexbar/config.json. Get your key from openrouter.ai/settings/keys and set a key spending limit there to enable API key quota tracking." = "~/.codexbar/config.json に保存されます。キーは openrouter.ai/settings/keys から取得し、そこでキーの支出上限を設定すると API キーのクォータ追跡が有効になります。";
+"Stored in ~/.codexbar/config.json. In Warp, open Settings > Platform > API Keys, then create one." = "~/.codexbar/config.json に保存されます。Warp で「Settings」>「Platform」>「API Keys」を開いて作成してください。";
+"Stored in ~/.codexbar/config.json. Metrics require Groq Enterprise Prometheus access." = "~/.codexbar/config.json に保存されます。メトリクスには Groq Enterprise の Prometheus アクセスが必要です。";
+"Stored in ~/.codexbar/config.json. OPENAI_ADMIN_KEY is preferred; OPENAI_API_KEY still works." = "~/.codexbar/config.json に保存されます。OPENAI_ADMIN_KEY が推奨されますが、OPENAI_API_KEY も引き続き使用できます。";
+"Stored in ~/.codexbar/config.json. Requires an Anthropic Admin API key." = "~/.codexbar/config.json に保存されます。Anthropic の Admin API キーが必要です。";
+"Stored in ~/.codexbar/config.json. Used for /v1/quota-stats." = "~/.codexbar/config.json に保存されます。/v1/quota-stats に使用されます。";
+"Stored in ~/.codexbar/config.json. You can also provide CODEBUFF_API_KEY or let CodexBar read ~/.config/manicode/credentials.json (created by `codebuff login`)." = "~/.codexbar/config.json に保存されます。CODEBUFF_API_KEY を指定するか、CodexBar に ~/.config/manicode/credentials.json(`codebuff login` で作成)を読み込ませることもできます。";
+"Stored in ~/.codexbar/config.json. You can also provide CROF_API_KEY." = "~/.codexbar/config.json に保存されます。CROF_API_KEY を指定することもできます。";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or ~/.local/share/kilo/auth.json (kilo.access)." = "~/.codexbar/config.json に保存されます。KILO_API_KEY または ~/.local/share/kilo/auth.json(kilo.access)を指定することもできます。";
+"T3 Chat cookie" = "T3 Chat Cookie";
+"That account is no longer available in CodexBar. Refresh the account list and try again." = "そのアカウントは CodexBar で利用できなくなっています。アカウントリストを更新してからやり直してください。";
+"The browser login did not complete in time. Try Antigravity login again." = "ブラウザでのログインが時間内に完了しませんでした。Antigravity のログインをもう一度お試しください。";
+"Timed out waiting for Cursor login. %@" = "Cursor のログイン待機がタイムアウトしました。%@";
+"Timed out waiting for Cursor login. %@ Last error: %@" = "Cursor のログイン待機がタイムアウトしました。%@ 最後のエラー: %@";
+"Today requests" = "本日のリクエスト";
+"Total (30d): %@ credits" = "合計(30日間): %@ クレジット";
+"Username" = "ユーザ名";
+"Uses username + password to login and obtain an Oasis-Token automatically." = "ユーザ名とパスワードでログインし、Oasis-Token を自動的に取得します。";
+"Uses username + password to login and obtain an %@ automatically." = "ユーザ名とパスワードでログインし、%@ を自動的に取得します。";
+"Utilization End" = "使用率終了";
+"Utilization Start" = "使用率開始";
+"Verbosity" = "詳細度";
+"Windsurf session JSON bundle" = "Windsurf セッション JSON バンドル";
+"Workspace ID" = "ワークスペース ID";
+"Your StepFun platform password. Used to login and obtain a session token." = "StepFun プラットフォームのパスワード。ログインしてセッショントークンを取得するために使用されます。";
+"claude /login exited with status %d." = "claude /login がステータス %d で終了しました。";
+"codex login exited with status %d." = "codex login がステータス %d で終了しました。";
+"Cookie: …\n\nor paste a cURL capture from the Abacus AI dashboard" = "Cookie: …\n\nまたは Abacus AI ダッシュボードからの cURL キャプチャを貼り付けてください";
+"Cookie: …\n\nor paste the __Secure-next-auth.session-token value" = "Cookie: …\n\nまたは __Secure-next-auth.session-token の値を貼り付けてください";
+"Cookie: …\n\nor paste the kimi-auth token value" = "Cookie: …\n\nまたは kimi-auth トークンの値を貼り付けてください";
+"session_id=...\n\nor paste just the session_id value" = "session_id=...\n\nまたは session_id の値のみを貼り付けてください";
+"Clear" = "消去";
+"No matching providers" = "一致するプロバイダがありません";
+"Search providers" = "プロバイダを検索";
+
+"language_vietnamese" = "ベトナム語";
+"language_turkish" = "トルコ語";
+"language_indonesian" = "インドネシア語";
+"language_arabic" = "العربية";
+"language_persian" = "فارسی";
+"language_thai" = "ไทย";
+"Limit Reset Credits" = "上限リセットクレジット";
+"1 manual reset available" = "手動リセットが1回利用可能";
+"%d manual resets available" = "手動リセットが%d回利用可能";
+"Next expires %@" = "次回の有効期限：%@";
+"Other (%d items)" = "その他（%d項目）";
+"Expand" = "展開";
+"Collapse" = "折りたたむ";
+"byte_unit_byte" = "バイト";
+"byte_unit_bytes" = "バイト";
+"byte_unit_kilobyte" = "キロバイト";
+"byte_unit_kilobytes" = "キロバイト";
+"byte_unit_megabyte" = "メガバイト";
+"byte_unit_megabytes" = "メガバイト";
+"byte_unit_gigabyte" = "ギガバイト";
+"byte_unit_gigabytes" = "ギガバイト";
diff --git a/Sources/CodexBar/Resources/ko.lproj/Localizable.strings b/Sources/CodexBar/Resources/ko.lproj/Localizable.strings
new file mode 100644
index 0000000000..47a473f90e
--- /dev/null
+++ b/Sources/CodexBar/Resources/ko.lproj/Localizable.strings
@@ -0,0 +1,1076 @@
+/* Korean (한국어) localization for CodexBar */
+
+" providers" = " 공급자";
+"(System)" = "(시스템)";
+"30d" = "30일";
+"A managed Codex login is already running. Wait for it to finish before adding " = "관리되는 Codex 로그인이 이미 실행 중입니다. 추가하기 전에 완료될 때까지 기다리세요. ";
+"API key" = "API 키";
+"API region" = "API 지역";
+"API token" = "API 토큰";
+"API tokens" = "API 토큰";
+"About" = "정보";
+"Account" = "계정";
+"Accounts" = "계정";
+"Accounts subtitle" = "계정 부제";
+"Active" = "활성";
+"Add" = "추가";
+"Add Workspace" = "작업 공간 추가";
+"Advanced" = "고급";
+"All" = "전체";
+"Always allow prompts" = "항상 프롬프트 허용";
+"Animation pattern" = "애니메이션 패턴";
+"Antigravity login is managed in the app" = "Antigravity 로그인은 앱에서 관리됩니다";
+"Applies only to the Security.framework OAuth keychain reader." = "Security.framework OAuth 키체인 리더에만 적용됩니다.";
+"Auto falls back to the next source if the preferred one fails." = "자동은 선호하는 소스가 실패하면 다음 소스로 대체합니다.";
+"Auto uses API first, then falls back to CLI on auth failures." = "자동은 API를 먼저 사용하고, 인증 실패 시 CLI로 대체합니다.";
+"Auto-detect" = "자동 감지";
+"Auto-refresh is off; use the menu's Refresh command." = "자동 새로 고침이 꺼져 있습니다. 메뉴의 새로 고침 명령을 사용하세요.";
+"Auto-refresh: hourly · Timeout: 10m" = "자동 새로 고침: 매시간 · 시간 초과: 10분";
+"Automatic" = "자동";
+"Automatic imports browser cookies and WorkOS tokens." = "자동은 브라우저 쿠키와 WorkOS 토큰을 가져옵니다.";
+"Automatic imports browser cookies and local storage tokens." = "자동은 브라우저 쿠키와 로컬 저장소 토큰을 가져옵니다.";
+"Automatic imports browser cookies for dashboard extras." = "자동은 대시보드 추가 항목을 위한 브라우저 쿠키를 가져옵니다.";
+"Automatic imports browser cookies for the web API." = "자동은 웹 API를 위한 브라우저 쿠키를 가져옵니다.";
+"Automatic imports browser cookies from Model Studio/Bailian." = "자동은 Model Studio/Bailian에서 브라우저 쿠키를 가져옵니다.";
+"Automatic imports browser cookies from admin.mistral.ai." = "자동은 admin.mistral.ai에서 브라우저 쿠키를 가져옵니다.";
+"Automatic imports browser cookies from opencode.ai." = "자동은 opencode.ai에서 브라우저 쿠키를 가져옵니다.";
+"Automatic imports browser cookies or stored sessions." = "자동은 브라우저 쿠키 또는 저장된 세션을 가져옵니다.";
+"Automatic imports browser cookies." = "자동은 브라우저 쿠키를 가져옵니다.";
+"Automatically imports browser session cookie." = "브라우저 세션 쿠키를 자동으로 가져옵니다.";
+"Automatically opens CodexBar when you start your Mac." = "Mac을 시작할 때 CodexBar를 자동으로 엽니다.";
+"Automation" = "자동화";
+"Average (\\(label1) + \\(label2))" = "평균 (\\(label1) + \\(label2))";
+"Average (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))" = "평균 (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))";
+"Avoid Keychain prompts" = "키체인 프롬프트 방지";
+"Balance" = "잔액";
+"Battery Saver" = "배터리 절약";
+"Bordered" = "테두리 있음";
+"Build" = "빌드";
+"Built \\(buildTimestamp)" = "빌드 \\(buildTimestamp)";
+"Buy Credits..." = "크레딧 구매...";
+"Buy Credits…" = "크레딧 구매…";
+"CLI paths" = "CLI 경로";
+"CLI sessions" = "CLI 세션";
+"Caches" = "캐시";
+"Cancel" = "취소";
+"Check for Updates…" = "업데이트 확인…";
+"Check for updates automatically" = "자동으로 업데이트 확인";
+"Check if you like your agents having some fun up there." = "에이전트가 위에서 즐기는 모습을 보고 싶다면 선택하세요.";
+"Check provider status" = "공급자 상태 확인";
+"Choose Codex workspace" = "Codex 작업 공간 선택";
+"Choose the MiniMax host (global .io or China mainland .com)." = "MiniMax 호스트를 선택하세요 (글로벌 .io 또는 중국 본토 .com).";
+"Choose up to " = "최대 선택 ";
+"Choose up to \\(Self.maxOverviewProviders) providers" = "최대 \\(Self.maxOverviewProviders)개 공급자 선택";
+"Choose up to \\(count) providers" = "최대 \\(count)개 공급자 선택";
+"Choose what to show in the menu bar (Pace shows usage vs. expected)." = "메뉴 막대에 표시할 항목을 선택하세요 (사용 속도는 예상 대비 사용량을 표시).";
+"Choose which Codex account CodexBar should follow." = "CodexBar가 따를 Codex 계정을 선택하세요.";
+"Choose which window drives the menu bar percent." = "메뉴 막대 백분율을 결정하는 기간을 선택하세요.";
+"Chrome" = "Chrome";
+"Claude CLI not found" = "Claude CLI를 찾을 수 없음";
+"Claude binary" = "Claude 바이너리";
+"Claude cookies" = "Claude 쿠키";
+"Claude login failed" = "Claude 로그인 실패";
+"Claude login timed out" = "Claude 로그인 시간 초과";
+"Close" = "닫기";
+"Code review" = "코드 검토";
+"Codex CLI not found" = "Codex CLI를 찾을 수 없음";
+"Codex account login already running" = "Codex 계정 로그인이 이미 진행 중입니다";
+"Codex binary" = "Codex 바이너리";
+"Codex login failed" = "Codex 로그인 실패";
+"Codex login timed out" = "Codex 로그인 시간 초과";
+"CodexBar Lifecycle Keepalive" = "CodexBar 수명 주기 유지";
+"CodexBar can't show its menu bar icon" = "CodexBar가 메뉴 막대 아이콘을 표시할 수 없습니다";
+"CodexBar could not read managed account storage. " = "CodexBar가 관리 계정 저장소를 읽을 수 없습니다. ";
+"Configure…" = "구성…";
+"Connected" = "연결됨";
+"Controls how much detail is logged." = "기록되는 세부 정보의 양을 제어합니다.";
+"Cookie header" = "쿠키 헤더";
+"Cookie source" = "쿠키 소스";
+"Cookie: ..." = "쿠키: ...";
+"Cookie: \\u{2026}\\\n\\\nor paste a cURL capture from the Abacus AI dashboard" = "쿠키: \\u{2026}\\\n\\\n또는 Abacus AI 대시보드에서 캡처한 cURL을 붙여넣으세요";
+"Cookie: \\u{2026}\\\n\\\nor paste the __Secure-next-auth.session-token value" = "쿠키: \\u{2026}\\\n\\\n또는 __Secure-next-auth.session-token 값을 붙여넣으세요";
+"Cookie: \\u{2026}\\\n\\\nor paste the kimi-auth token value" = "쿠키: \\u{2026}\\\n\\\n또는 kimi-auth 토큰 값을 붙여넣으세요";
+"Cookie: …" = "쿠키: …";
+"CopilotDeviceFlow" = "CopilotDeviceFlow";
+"Cost" = "비용";
+"Could not add Codex account" = "Codex 계정을 추가할 수 없음";
+"Could not open Terminal for Gemini" = "Gemini용 터미널을 열 수 없음";
+"Could not start claude /login" = "claude /login을 시작할 수 없음";
+"Could not start codex login" = "codex login을 시작할 수 없음";
+"Could not switch system account" = "시스템 계정을 전환할 수 없음";
+"Credits" = "크레딧";
+"Individual credits" = "개인 크레딧";
+"Workspace" = "작업 공간";
+"Credits history" = "크레딧 내역";
+"Cursor login failed" = "Cursor 로그인 실패";
+"Custom" = "사용자 설정";
+"Custom Path" = "사용자 설정 경로";
+"Daily Routines" = "일일 루틴";
+"Debug" = "디버그";
+"Default" = "기본값";
+"Disable Keychain access" = "키체인 접근 사용 안 함";
+"Disabled" = "사용 안 함";
+"Dismiss" = "무시";
+"Disconnected" = "연결 끊김";
+"Display" = "표시";
+"Display mode" = "표시 모드";
+"Display reset times as absolute clock values instead of countdowns." = "재설정 시간을 카운트다운 대신 절대 시각으로 표시합니다.";
+"Done" = "완료";
+"Effective PATH" = "유효 PATH";
+"Email" = "이메일";
+"Enable Merge Icons to configure Overview tab providers." = "개요 탭 공급자를 구성하려면 아이콘 병합을 사용하세요.";
+"Enable file logging" = "파일 로깅 사용";
+"Enabled" = "사용";
+"Error" = "오류";
+"Error simulation" = "오류 시뮬레이션";
+"Expose troubleshooting tools in the Debug tab." = "디버그 탭에 문제 해결 도구를 표시합니다.";
+"Failed" = "실패";
+"False" = "False";
+"Fetch strategy attempts" = "가져오기 전략 시도";
+"Fetching" = "가져오는 중";
+"Field" = "필드";
+"Field subtitle" = "필드 부제목";
+"Finish the current managed account change before switching the system account." = "시스템 계정을 전환하기 전에 현재 관리 계정 변경을 완료하세요.";
+"Force animation on next refresh" = "다음 새로 고침 시 애니메이션 강제 적용";
+"Gateway region" = "게이트웨이 리전";
+"Gemini CLI not found" = "Gemini CLI를 찾을 수 없음";
+"Gemini/Antigravity, surfacing incidents in the icon and menu." = "Gemini/Antigravity의 장애를 아이콘과 메뉴에 표시합니다.";
+"General" = "일반";
+"GitHub" = "GitHub";
+"GitHub Copilot Login" = "GitHub Copilot 로그인";
+"GitHub Login" = "GitHub 로그인";
+"Hide details" = "세부 정보 가리기";
+"Hide personal information" = "개인 정보 가리기";
+"Historical tracking" = "기록 추적";
+"How often CodexBar polls providers in the background." = "CodexBar가 백그라운드에서 공급자를 폴링하는 빈도입니다.";
+"Inactive" = "비활성";
+"Install CLI" = "CLI 설치";
+"Install the Claude CLI (npm i -g @anthropic-ai/claude-code) and try again." = "Claude CLI(npm i -g @anthropic-ai/claude-code)를 설치한 후 다시 시도하세요.";
+"Install the Codex CLI (npm i -g @openai/codex) and try again." = "Codex CLI(npm i -g @openai/codex)를 설치한 후 다시 시도하세요.";
+"Install the Gemini CLI (npm i -g @google/gemini-cli) and try again." = "Gemini CLI(npm i -g @google/gemini-cli)를 설치한 후 다시 시도하세요.";
+"JetBrains AI is ready" = "JetBrains AI 준비 완료";
+"JetBrains IDE" = "JetBrains IDE";
+"Keep CLI sessions alive" = "CLI 세션 유지";
+"Keyboard shortcut" = "키보드 단축키";
+"Keychain access" = "키체인 접근";
+"Keychain prompt policy" = "키체인 프롬프트 정책";
+"Last \\(name) fetch failed:" = "마지막 \\(name) 가져오기 실패:";
+"Last \\(self.store.metadata(for: self.provider).displayName) fetch failed:" = "마지막 \\(self.store.metadata(for: self.provider).displayName) 가져오기 실패:";
+"Last attempt" = "마지막 시도";
+"Link" = "링크";
+"Loading animations" = "로딩 애니메이션";
+"Loading…" = "불러오는 중…";
+"Local" = "로컬";
+"Logging" = "로깅";
+"Login failed" = "로그인 실패";
+"Login shell PATH (startup capture)" = "로그인 셸 PATH(시작 시 캡처)";
+"Login timed out" = "로그인 시간 초과됨";
+"MCP details" = "MCP 세부 정보";
+"Managed Codex accounts unavailable" = "관리되는 Codex 계정을 사용할 수 없음";
+"Managed account storage is unreadable. Live account access is still available, " = "관리되는 계정 저장소를 읽을 수 없습니다. 실시간 계정 접근은 여전히 가능하며, ";
+"Manual" = "수동";
+"May your tokens never run out—keep agent limits in view." = "토큰이 결코 바닥나지 않기를—에이전트 한도를 한눈에 확인하세요.";
+"Menu bar" = "메뉴 막대";
+"Menu bar auto-shows the provider closest to its rate limit." = "메뉴 막대에 사용 한도에 가장 가까운 공급자를 자동으로 표시합니다.";
+"Menu bar metric" = "메뉴 막대 지표";
+"Menu bar shows percent" = "메뉴 막대에 백분율 표시";
+"Menu content" = "메뉴 내용";
+"Merge Icons" = "아이콘 병합";
+"Never prompt" = "표시 안 함";
+"No" = "아니요";
+"No Codex accounts detected yet." = "아직 감지된 Codex 계정이 없습니다.";
+"No JetBrains IDE detected" = "감지된 JetBrains IDE 없음";
+"No cost history data." = "비용 기록 데이터가 없습니다.";
+"No data available" = "사용 가능한 데이터 없음";
+"No data yet" = "아직 데이터 없음";
+"No enabled providers available for Overview." = "개요에 사용할 수 있는 공급자가 없습니다.";
+"No providers selected" = "선택된 공급자 없음";
+"No token accounts yet." = "아직 토큰 계정이 없습니다.";
+"No usage breakdown data." = "사용량 분석 데이터가 없습니다.";
+"None" = "없음";
+"Notifications" = "알림";
+"Notifies when the 5-hour session quota hits 0% and when it becomes " = "5시간 세션 할당량이 0%에 도달하거나 다시 사용 가능해질 때 알립니다 ";
+"OK" = "확인";
+"Obscure email addresses in the menu bar and menu UI." = "메뉴 막대와 메뉴 UI에서 이메일 주소를 가립니다.";
+"Off" = "끔";
+"Offline" = "오프라인";
+"On" = "켬";
+"Online" = "온라인";
+"Only on user action" = "사용자 작업 시에만";
+"Open" = "열기";
+"Open API Keys" = "API 키 열기";
+"Open Amp Settings" = "Amp 설정 열기";
+"Open Antigravity to sign in, then refresh CodexBar." = "Antigravity를 열어 로그인한 다음 CodexBar를 새로 고침하세요.";
+"Open Browser" = "브라우저 열기";
+"Open Coding Plan" = "코딩 요금제 열기";
+"Open Console" = "콘솔 열기";
+"Open Dashboard" = "대시보드 열기";
+"Open Mistral Admin" = "Mistral 관리 열기";
+"Open Menu Bar Settings" = "메뉴 막대 설정 열기";
+"Open Ollama Settings" = "Ollama 설정 열기";
+"Open Terminal" = "터미널 열기";
+"Open Usage Page" = "사용량 페이지 열기";
+"Open Warp API Key Guide" = "Warp API 키 가이드 열기";
+"Open menu" = "메뉴 열기";
+"Open token file" = "토큰 파일 열기";
+"OpenAI cookies" = "OpenAI 쿠키";
+"OpenAI web extras" = "OpenAI 웹 추가 항목";
+"Option A" = "옵션 A";
+"Option B" = "옵션 B";
+"Optional override if workspace lookup fails." = "작업 공간 조회에 실패할 경우의 선택적 재정의 값입니다.";
+"Options" = "옵션";
+"Override auto-detection with a custom IDE base path" = "사용자 설정 IDE 기본 경로로 자동 감지 재정의";
+"Overview" = "개요";
+"Overview rows always follow provider order." = "개요 행은 항상 공급자 순서를 따릅니다.";
+"Overview tab providers" = "개요 탭 공급자";
+"Paste API key…" = "API 키 붙여넣기…";
+"Paste API token…" = "API 토큰 붙여넣기…";
+"Paste key…" = "키 붙여넣기…";
+"Paste sessionKey or OAuth token…" = "sessionKey 또는 OAuth 토큰 붙여넣기…";
+"Paste the Cookie header from a request to admin.mistral.ai. " = "admin.mistral.ai 요청의 Cookie 헤더를 붙여넣으세요. ";
+"Paste token…" = "토큰 붙여넣기…";
+"Personal" = "개인";
+"Picker" = "선택기";
+"Picker subtitle" = "선택기 부제목";
+"Placeholder" = "플레이스홀더";
+"Plan" = "요금제";
+"Play full-screen confetti when weekly usage resets." = "주간 사용량이 재설정되면 전체 화면 색종이를 재생합니다.";
+"Polls OpenAI/Claude status pages and Google Workspace for " = "OpenAI/Claude 상태 페이지와 Google Workspace를 폴링하여 ";
+"Prevents any Keychain access while enabled." = "사용 중에는 모든 키체인 접근을 차단합니다.";
+"Primary (API key limit)" = "기본 (API 키 한도)";
+"Primary (\\(label))" = "기본 (\\(label))";
+"Primary (\\(metadata.sessionLabel))" = "기본 (\\(metadata.sessionLabel))";
+"Probe logs" = "프로브 로그";
+"Progress bars fill as you consume quota (instead of showing remaining)." = "남은 양을 표시하는 대신 할당량을 소비할수록 진행 막대가 채워집니다.";
+"Provider" = "공급자";
+"Providers" = "공급자";
+"Quit CodexBar" = "CodexBar 종료";
+"Random (default)" = "무작위 (기본값)";
+"Reads local usage logs. Shows today + last 30 days cost in the menu." = "로컬 사용량 로그를 읽습니다. 메뉴에 오늘과 선택한 기록 기간의 비용을 표시합니다.";
+"Refresh" = "새로 고침";
+"Refresh cadence" = "새로 고침 주기";
+"Remote" = "원격";
+"Remove" = "제거";
+"Remove Codex account?" = "Codex 계정을 제거하시겠습니까?";
+"Remove \\(account.email) from CodexBar? Its managed Codex home will be deleted." = "CodexBar에서 \\(account.email)을(를) 제거하시겠습니까? 관리되는 Codex 홈이 삭제됩니다.";
+"Remove \\(email) from CodexBar? Its managed Codex home will be deleted." = "CodexBar에서 \\(email)을(를) 제거하시겠습니까? 관리되는 Codex 홈이 삭제됩니다.";
+"Remove selected account" = "선택한 계정 제거";
+"Replace critter bars with provider branding icons and a percentage." = "크리터 막대를 공급자 브랜딩 아이콘과 백분율로 대체합니다.";
+"Replay selected animation" = "선택한 애니메이션 다시 재생";
+"Requires authentication via GitHub Device Flow." = "GitHub Device Flow를 통한 인증이 필요합니다.";
+"Resets: \\(reset)" = "재설정: \\(reset)";
+"Rolling five-hour limit" = "5시간 롤링 한도";
+"Search hourly" = "시간당 검색";
+"Secondary (\\(label))" = "보조 (\\(label))";
+"Secondary (\\(metadata.weeklyLabel))" = "보조 (\\(metadata.weeklyLabel))";
+"Select a provider" = "공급자 선택";
+"Select the IDE to monitor" = "모니터링할 IDE 선택";
+"Session quota notifications" = "세션 할당량 알림";
+"Session tokens" = "세션 토큰";
+"Settings" = "설정";
+"Show Codex Credits and Claude Extra usage sections in the menu." = "메뉴에 Codex 크레딧 및 Claude 추가 사용량 섹션을 표시합니다.";
+"Show Debug Settings" = "디버그 설정 표시";
+"Show all token accounts" = "모든 토큰 계정 표시";
+"Show cost summary" = "비용 요약 표시";
+"Show credits + extra usage" = "크레딧 + 추가 사용량 표시";
+"Show details" = "세부 정보 표시";
+"Show most-used provider" = "가장 많이 사용한 공급자 표시";
+"Show provider icons in the switcher (otherwise show a weekly progress line)." = "전환기에 공급자 아이콘을 표시합니다(그렇지 않으면 주간 진행률 막대를 표시).";
+"Show reset time as clock" = "재설정 시간을 시계로 표시";
+"Show usage as used" = "사용량을 사용한 양으로 표시";
+"Sign in via button below" = "아래 버튼으로 로그인";
+"Skip teardown between probes (debug-only)." = "프로브 간 정리를 건너뜁니다(디버그 전용).";
+"Stack token accounts in the menu (otherwise show an account switcher bar)." = "메뉴에 토큰 계정을 쌓아서 표시합니다(그렇지 않으면 계정 전환기 막대를 표시).";
+"Start at Login" = "로그인 시 시작";
+"Status" = "상태";
+"Store Claude sessionKey cookies or OAuth access tokens." = "Claude sessionKey 쿠키 또는 OAuth 액세스 토큰을 저장합니다.";
+"Store multiple Abacus AI Cookie headers." = "여러 Abacus AI 쿠키 헤더를 저장합니다.";
+"Store multiple Augment Cookie headers." = "여러 Augment 쿠키 헤더를 저장합니다.";
+"Store multiple Cursor Cookie headers." = "여러 Cursor 쿠키 헤더를 저장합니다.";
+"Store multiple Factory Cookie headers." = "여러 Factory 쿠키 헤더를 저장합니다.";
+"Store multiple MiniMax Cookie headers." = "여러 MiniMax 쿠키 헤더를 저장합니다.";
+"Store multiple Mistral Cookie headers." = "여러 Mistral 쿠키 헤더를 저장합니다.";
+"Store multiple Ollama Cookie headers." = "여러 Ollama 쿠키 헤더를 저장합니다.";
+"Store multiple OpenCode Cookie headers." = "여러 OpenCode 쿠키 헤더를 저장합니다.";
+"Store multiple OpenCode Go Cookie headers." = "여러 OpenCode Go 쿠키 헤더를 저장합니다.";
+"Stored in the CodexBar config file." = "CodexBar 설정 파일에 저장됩니다.";
+"Stored in ~/.codexbar/config.json. " = "~/.codexbar/config.json에 저장됩니다. ";
+"Stored in ~/.codexbar/config.json. Generate one at kimi-k2.ai." = "~/.codexbar/config.json에 저장됩니다. kimi-k2.ai에서 생성하세요.";
+"Stored in ~/.codexbar/config.json. Paste the key from the Synthetic dashboard." = "~/.codexbar/config.json에 저장됩니다. Synthetic 대시보드에서 키를 붙여넣으세요.";
+"Stored in ~/.codexbar/config.json. Paste your Coding Plan API key from Model Studio." = "~/.codexbar/config.json에 저장됩니다. Model Studio에서 Coding Plan API 키를 붙여넣으세요.";
+"Stored in ~/.codexbar/config.json. Paste your MiniMax API key." = "~/.codexbar/config.json에 저장됩니다. MiniMax API 키를 붙여넣으세요.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or " = "~/.codexbar/config.json에 저장됩니다. KILO_API_KEY를 제공할 수도 있습니다. ";
+"Stores local Codex usage history (8 weeks) to personalize Pace predictions." = "사용 속도 예측을 개인화하기 위해 로컬 Codex 사용 기록(8주)을 저장합니다.";
+"Subscription Utilization" = "구독 사용률";
+"Surprise me" = "랜덤으로 선택";
+"Switcher shows icons" = "전환기에 아이콘 표시";
+"Symlink CodexBarCLI to /usr/local/bin and /opt/homebrew/bin as codexbar." = "CodexBarCLI를 codexbar로 /usr/local/bin 및 /opt/homebrew/bin에 심볼릭 링크합니다.";
+"System" = "시스템";
+"Temporarily shows the loading animation after the next refresh." = "다음 새로 고침 후 불러오는 중 애니메이션을 일시적으로 표시합니다.";
+"terminal_app_subtitle" = "터미널 열기 동작에서 사용하는 터미널";
+"terminal_app_title" = "기본 터미널";
+"Tertiary (\\(label))" = "3차 (\\(label))";
+"Tertiary (\\(tertiaryTitle))" = "3차 (\\(tertiaryTitle))";
+"The default Codex account on this Mac." = "이 Mac의 기본 Codex 계정입니다.";
+"Toggle" = "전환";
+"Toggle subtitle" = "부제목 전환";
+"Token" = "토큰";
+"Trigger the menu bar menu from anywhere." = "어디서나 메뉴 막대 메뉴를 실행합니다.";
+"True" = "True";
+"Twitter" = "Twitter";
+"Unsupported" = "지원되지 않음";
+"Update Channel" = "업데이트 채널";
+"Updated" = "업데이트됨";
+"Updates unavailable in this build." = "이 빌드에서는 업데이트를 사용할 수 없습니다.";
+"Usage" = "사용량";
+"Usage breakdown" = "사용량 내역";
+"Usage history (30 days)" = "사용 기록";
+"Usage source" = "사용량 소스";
+"Use BigModel for the China mainland endpoints (open.bigmodel.cn)." = "중국 본토 엔드포인트에 BigModel을 사용합니다(open.bigmodel.cn).";
+"Use a single menu bar icon with a provider switcher." = "공급자 전환기와 함께 단일 메뉴 막대 아이콘 사용";
+"Use international or China mainland console gateways for quota fetches." = "할당량 가져오기에 국제 또는 중국 본토 콘솔 게이트웨이 사용";
+"Version" = "버전";
+"Version \\(self.versionString)" = "버전 \\(self.versionString)";
+"Version \\(version)" = "버전 \\(version)";
+"Version \\(versionString)" = "버전 \\(versionString)";
+"Vertex AI Login" = "Vertex AI 로그인";
+"Wait for the current managed Codex login to finish before adding another account." = "다른 계정을 추가하기 전에 현재 진행 중인 관리형 Codex 로그인이 끝날 때까지 기다리세요.";
+"Waiting for Authentication..." = "인증 대기 중...";
+"Website" = "웹사이트";
+"Weekly limit confetti" = "주간 한도 콘페티";
+"Weekly token limit" = "주간 토큰 한도";
+"Weekly usage" = "주간 사용량";
+"Weekly usage unavailable for this account." = "이 계정에서는 주간 사용량을 사용할 수 없습니다.";
+"Window: \\(window)" = "기간: \\(window)";
+"Write logs to \\(self.fileLogPath) for debugging." = "디버깅을 위해 \\(self.fileLogPath)에 로그 기록";
+"Yes" = "예";
+"\\(detail.modelCode): \\(usage)" = "\\(detail.modelCode): \\(usage)";
+"\\(name): \\(truncated)" = "\\(name): \\(truncated)";
+"\\(name): \\(updated) · 30d \\(cost)" = "\\(name): \\(updated) · 30일 \\(cost)";
+"\\(name): fetching…\\(elapsed)" = "\\(name): 가져오는 중…\\(elapsed)";
+"\\(name): last attempt \\(when)" = "\\(name): 마지막 시도 \\(when)";
+"\\(name): no data yet" = "\\(name): 아직 데이터 없음";
+"\\(name): unsupported" = "\\(name): 지원 안 함";
+"all browsers" = "모든 브라우저";
+"available again." = "다시 사용 가능합니다.";
+"built_format" = "빌드 %@";
+"copilot_complete_in_browser" = "브라우저에서 로그인을 완료하세요.";
+"copilot_device_code" = "기기 코드가 클립보드에 복사됨: %1$@\n\n확인 위치: %2$@";
+"copilot_device_code_copied" = "기기 코드가 복사되었습니다.";
+"copilot_verify_at" = "%@에서 확인";
+"copilot_waiting_text" = "브라우저에서 로그인을 완료하세요.\n로그인이 완료되면 이 창은 자동으로 닫힙니다.";
+"copilot_window_closes_auto" = "로그인이 완료되면 이 창은 자동으로 닫힙니다.";
+"cost_status_error" = "%1$@: %2$@";
+"cost_status_fetching" = "%1$@: 가져오는 중… %2$@";
+"cost_status_last_attempt" = "%1$@: 마지막 시도 %2$@";
+"cost_status_no_data" = "%@: 아직 데이터 없음";
+"cost_status_snapshot" = "%1$@: %2$@ · %3$@ %4$@";
+"cost_status_unsupported" = "%@: 지원 안 함";
+"credits_remaining" = "크레딧: %@";
+"cursor_on_demand" = "온디맨드: %@";
+"cursor_on_demand_with_limit" = "온디맨드: %1$@ / %2$@";
+"extra_usage_format" = "추가 사용량: %1$@ / %2$@";
+"jetbrains_detected_generate" = "감지됨: %@. AI 어시스턴트를 한 번 사용하여 할당량 데이터를 생성한 다음 CodexBar를 새로 고치세요.";
+"jetbrains_detected_select" = "감지됨: %@. 설정에서 선호하는 IDE를 선택한 다음 CodexBar를 새로 고치세요.";
+"last_fetch_failed_with_provider" = "마지막 %@ 가져오기 실패:";
+"last_spend" = "마지막 지출: %@";
+"mcp_model_usage" = "%1$@: %2$@";
+"mcp_resets" = "재설정: %@";
+"mcp_window" = "기간: %@";
+"metric_average" = "평균 (%1$@ + %2$@)";
+"metric_primary" = "1차 (%@)";
+"metric_secondary" = "2차 (%@)";
+"metric_tertiary" = "3차 (%@)";
+"multiple_workspaces_found" = "CodexBar가 %@에 대한 여러 작업 공간을 찾았습니다. 추가할 작업 공간을 선택하세요.";
+"ory_session_…=…; csrftoken=…" = "ory_session_…=…; csrftoken=…";
+"overview_choose_providers" = "최대 %@개의 공급자 선택";
+"remove_account_message" = "CodexBar에서 %@을(를) 제거하시겠습니까? 관리형 Codex 홈이 삭제됩니다.";
+"version_format" = "버전 %@";
+"vertex_ai_login_instructions" = "Vertex AI 사용량을 추적하려면 Google Cloud로 인증하세요.\n\n1. 터미널 열기\n2. 실행: gcloud auth application-default login\n3. 브라우저 안내에 따라 로그인\n4. 프로젝트 설정: gcloud config set project PROJECT_ID\n\n지금 터미널을 여시겠습니까?";
+"workspaceID is set but only opencode, opencodego, and deepgram support workspaceID." = "workspaceID가 설정되었지만 opencode, opencodego, deepgram만 workspaceID를 지원합니다.";
+"© 2026 Peter Steinberger. MIT License." = "© 2026 Peter Steinberger. MIT License.";
+"section_system" = "시스템";
+"section_usage" = "사용량";
+"section_automation" = "자동화";
+"language_title" = "언어";
+"language_subtitle" = "표시 언어를 변경합니다. 적용하려면 앱을 다시 시작해야 합니다.";
+"language_system" = "시스템";
+"language_english" = "영어";
+"language_spanish" = "스페인어";
+"language_catalan" = "카탈루냐어";
+"language_chinese_simplified" = "중국어(간체)";
+"language_chinese_traditional" = "중국어(번체)";
+"language_portuguese_brazilian" = "포르투갈어(브라질)";
+"language_german" = "독일어";
+"language_dutch" = "네덜란드어";
+"language_swedish" = "스웨덴어";
+"language_french" = "프랑스어";
+"language_ukrainian" = "우크라이나어";
+"language_japanese" = "일본어";
+"language_korean" = "한국어";
+"language_italian" = "Italiano";
+"language_polish" = "폴란드어";
+"start_at_login_title" = "로그인 시 시작";
+"start_at_login_subtitle" = "Mac을 시작할 때 CodexBar를 자동으로 엽니다.";
+"show_cost_summary" = "비용 요약 표시";
+"show_cost_summary_subtitle" = "로컬 사용량 로그를 읽습니다. 메뉴에 오늘 및 선택한 기록 범위를 표시합니다.";
+"cost_history_days_title" = "기록 범위: %d일";
+"cost_auto_refresh_info" = "자동 새로 고침: 매시간 · 시간 초과: 10분";
+"refresh_cadence_title" = "새로 고침 주기";
+"refresh_cadence_subtitle" = "CodexBar가 백그라운드에서 공급자를 폴링하는 빈도입니다.";
+"manual_refresh_hint" = "자동 새로 고침이 꺼져 있습니다. 메뉴의 새로 고침 명령을 사용하세요.";
+"check_provider_status_title" = "공급자 상태 확인";
+"check_provider_status_subtitle" = "OpenAI/Claude 상태 페이지와 Gemini/Antigravity용 Google Workspace를 폴링하여 아이콘과 메뉴에 문제를 표시합니다.";
+"session_quota_notifications_title" = "세션 할당량 알림";
+"session_quota_notifications_subtitle" = "5시간 세션 할당량이 0%에 도달할 때와 다시 사용할 수 있게 될 때 알립니다.";
+"quota_warning_notifications_title" = "할당량 경고 알림";
+"quota_warning_notifications_subtitle" = "세션 또는 주간 할당량 잔여량이 설정된 임곗값을 넘으면 경고합니다.";
+"quota_warnings_title" = "할당량 경고";
+"quota_warning_session" = "세션";
+"quota_warning_session_capitalized" = "세션";
+"quota_warning_weekly" = "주간";
+"quota_warning_weekly_capitalized" = "주간";
+"quota_warning_notification_title" = "%1$@ %2$@ 할당량 부족";
+"quota_warning_notification_body" = "%1$@ 남음. %2$d%% %3$@ 경고 임곗값에 도달했습니다.";
+"quota_warning_notification_body_with_account" = "계정 %1$@. %2$@ 남음. %3$d%% %4$@ 경고 임곗값에 도달했습니다.";
+"session_depleted_notification_title" = "%@ 세션 소진됨";
+"session_depleted_notification_body" = "0% 남음. 다시 사용할 수 있게 되면 알립니다.";
+"session_restored_notification_title" = "%@ 세션 복원됨";
+"session_restored_notification_body" = "세션 할당량을 다시 사용할 수 있습니다.";
+"quota_warning_warn_at" = "경고 기준";
+"quota_warning_global_threshold_subtitle" = "공급자가 재정의하지 않는 한 세션 및 주간 범위의 잔여 백분율입니다.";
+"quota_warning_sound" = "알림 소리 재생";
+"quota_warning_provider_inherits" = "여기서 범위를 사용자 설정하지 않는 한 전역 할당량 경고 설정을 사용합니다.";
+"quota_warning_customize_thresholds" = "%@ 임곗값 사용자 설정";
+"quota_warning_enable_warnings" = "%@ 경고 사용";
+"quota_warning_window_warn_at" = "%@ 경고 기준";
+"quota_warning_off" = "사용 안 함";
+"quota_warning_inherited" = "상속됨: %@";
+"quota_warning_depleted_only" = "소진 시에만";
+"quota_warning_upper" = "상한";
+"quota_warning_lower" = "하한";
+"apply" = "적용";
+"quit_app" = "CodexBar 종료";
+"tab_general" = "일반";
+"tab_providers" = "공급자";
+"tab_display" = "표시";
+"tab_advanced" = "고급";
+"tab_about" = "정보";
+"tab_debug" = "디버그";
+"select_a_provider" = "공급자 선택";
+"cancel" = "취소";
+"last_fetch_failed" = "마지막 가져오기 실패";
+"usage_not_fetched_yet" = "사용량을 아직 가져오지 않음";
+"managed_account_storage_unreadable" = "관리 계정 저장소를 읽을 수 없습니다. 실시간 계정 접근은 계속 사용할 수 있지만, 저장소를 복구할 수 있을 때까지 관리 추가, 재인증, 제거 작업은 사용할 수 없습니다.";
+"remove_codex_account_title" = "Codex 계정을 제거하시겠습니까?";
+"remove" = "제거";
+"managed_login_already_running" = "관리 Codex 로그인이 이미 실행 중입니다. 다른 계정을 추가하거나 재인증하기 전에 완료될 때까지 기다리세요.";
+"managed_login_failed" = "관리 Codex 로그인이 완료되지 않았습니다. 터미널에서 `codex --version`이 작동하는지 확인하세요. macOS가 `codex`를 차단했거나 휴지통으로 옮긴 경우, 오래된 중복 설치를 제거하고 `npm install -g --include=optional @openai/codex@latest`를 실행한 다음 다시 시도하세요.";
+"codex_login_output" = "codex 로그인 출력:";
+"managed_login_missing_email" = "Codex 로그인은 완료되었지만 계정 이메일을 가져올 수 없습니다. 계정이 완전히 로그인되었는지 확인한 후 다시 시도하세요.";
+"login_success_notification_title" = "%@ 로그인 성공";
+"login_success_notification_body" = "앱으로 돌아가셔도 됩니다. 인증이 완료되었습니다.";
+"workspace_selection_cancelled" = "CodexBar에서 여러 작업 공간을 찾았지만 선택된 작업 공간이 없습니다.";
+"unsafe_managed_home" = "CodexBar가 예기치 않은 관리 홈 경로 수정을 거부했습니다: %@";
+"menu_bar_metric_title" = "메뉴 막대 지표";
+"menu_bar_metric_subtitle" = "메뉴 막대 백분율을 결정할 창을 선택하세요.";
+"menu_bar_metric_subtitle_deepseek" = "메뉴 막대에 DeepSeek 잔액을 표시합니다.";
+"menu_bar_metric_subtitle_moonshot" = "메뉴 막대에 Moonshot / Kimi API 잔액을 표시합니다.";
+"menu_bar_metric_subtitle_mistral" = "메뉴 막대에 이번 달 Mistral API 지출을 표시합니다.";
+"menu_bar_metric_subtitle_kimik2" = "메뉴 막대에 Kimi K2 API 키 크레딧을 표시합니다.";
+"automatic" = "자동";
+"primary_api_key_limit" = "기본 (API 키 한도)";
+"section_menu_bar" = "메뉴 막대";
+"merge_icons_title" = "아이콘 병합";
+"merge_icons_subtitle" = "공급자 전환기가 있는 단일 메뉴 막대 아이콘을 사용합니다.";
+"switcher_shows_icons_title" = "전환기에 아이콘 표시";
+"switcher_shows_icons_subtitle" = "전환기에 공급자 아이콘을 표시합니다(그렇지 않으면 주간 진행률 선을 표시).";
+"show_most_used_provider_title" = "가장 많이 사용한 공급자 표시";
+"show_most_used_provider_subtitle" = "메뉴 막대에 사용 한도에 가장 가까운 공급자를 자동으로 표시합니다.";
+"menu_bar_shows_percent_title" = "메뉴 막대에 백분율 표시";
+"menu_bar_shows_percent_subtitle" = "크리터 막대를 공급자 브랜드 아이콘과 백분율로 대체합니다.";
+"hide_critters_title" = "크리터 숨기기";
+"hide_critters_subtitle" = "얼굴과 장식 없이 단순한 미터 막대를 표시합니다.";
+"display_mode_title" = "표시 모드";
+"display_mode_subtitle" = "메뉴 막대에 표시할 내용을 선택하세요(사용 속도는 사용량 대 예상치를 표시).";
+"section_menu_content" = "메뉴 내용";
+"show_usage_as_used_title" = "사용량을 사용한 만큼 표시";
+"show_usage_as_used_subtitle" = "할당량을 소비하면 진행률 막대가 채워집니다(남은 양을 표시하는 대신).";
+"show_quota_warning_markers_title" = "할당량 경고 표시기 표시";
+"show_quota_warning_markers_subtitle" = "할당량 경고가 구성된 경우 사용량 막대에 임계값 눈금 표시를 그립니다.";
+"weekly_progress_work_days_title" = "주간 진행률 근무일";
+"weekly_progress_work_days_subtitle" = "주간 사용량 막대 눈금과 페이스 계산에 사용할 근무일을 설정합니다.";
+"show_reset_time_as_clock_title" = "재설정 시간을 시계로 표시";
+"show_reset_time_as_clock_subtitle" = "재설정 시간을 카운트다운 대신 절대 시각으로 표시합니다.";
+"show_provider_changelog_links_title" = "공급자 변경 로그 링크 표시";
+"show_provider_changelog_links_subtitle" = "지원되는 CLI 기반 공급자의 릴리스 노트 링크를 메뉴에 추가합니다.";
+"show_credits_extra_usage_title" = "크레딧 + 추가 사용량 표시";
+"show_credits_extra_usage_subtitle" = "메뉴에 Codex 크레딧 및 Claude 추가 사용량 섹션을 표시합니다.";
+"show_all_token_accounts_title" = "모든 토큰 계정 표시";
+"show_all_token_accounts_subtitle" = "메뉴에 토큰 계정을 쌓아서 표시합니다(그렇지 않으면 계정 전환기 막대를 표시).";
+"multi_account_layout_title" = "다중 계정 레이아웃";
+"multi_account_layout_subtitle" = "분할된 계정 전환 또는 쌓인 계정 카드를 선택하세요.";
+"multi_account_layout_segmented" = "분할";
+"multi_account_layout_stacked" = "쌓기";
+"overview_tab_providers_title" = "개요 탭 공급자";
+"configure" = "구성…";
+"overview_enable_merge_icons_hint" = "개요 탭 공급자를 구성하려면 아이콘 병합을 사용하세요.";
+"overview_no_providers_hint" = "개요에 사용할 수 있는 활성화된 공급자가 없습니다.";
+"overview_rows_follow_order" = "개요 행은 항상 공급자 순서를 따릅니다.";
+"overview_no_providers_selected" = "선택된 공급자 없음";
+"section_keyboard_shortcut" = "키보드 단축키";
+"open_menu_shortcut_title" = "메뉴 열기";
+"open_menu_shortcut_subtitle" = "어디서나 메뉴 막대 메뉴를 실행합니다.";
+"install_cli" = "CLI 설치";
+"install_cli_subtitle" = "CodexBarCLI를 codexbar로 /usr/local/bin 및 /opt/homebrew/bin에 심볼릭 링크합니다.";
+"cli_not_found" = "앱 번들에서 CodexBarCLI를 찾을 수 없습니다.";
+"no_writable_bin_dirs" = "쓰기 가능한 bin 디렉터리를 찾을 수 없습니다.";
+"show_debug_settings_title" = "디버그 설정 표시";
+"show_debug_settings_subtitle" = "디버그 탭에 문제 해결 도구를 표시합니다.";
+"surprise_me_title" = "깜짝 놀래주기";
+"surprise_me_subtitle" = "에이전트가 저 위에서 조금 즐기는 모습이 마음에 드는지 확인해 보세요.";
+"weekly_limit_confetti_title" = "주간 한도 색종이";
+"weekly_limit_confetti_subtitle" = "주간 사용량이 재설정될 때 전체 화면 색종이를 재생합니다.";
+"hide_personal_info_title" = "개인 정보 가리기";
+"hide_personal_info_subtitle" = "메뉴 막대와 메뉴 UI에서 이메일 주소를 가립니다.";
+"show_provider_storage_usage_title" = "공급자 저장 공간 사용량 표시";
+"show_provider_storage_usage_subtitle" = "메뉴에 로컬 디스크 사용량을 표시합니다. 알려진 공급자 소유 경로를 백그라운드에서 스캔합니다.";
+"section_keychain_access" = "키체인 접근";
+"keychain_access_caption" = "모든 키체인 읽기 및 쓰기를 사용 안 함으로 설정합니다. 항상 허용을 클릭한 후에도 macOS가 'Chrome/Brave/Edge Safe Storage'를 계속 요청하는 경우 사용하세요. 사용 시 브라우저 쿠키 가져오기를 사용할 수 없으며, 공급자에서 Cookie 헤더를 직접 붙여넣으세요. CLI를 통한 Claude/Codex OAuth는 계속 작동합니다.";
+"disable_keychain_access_title" = "키체인 접근 사용 안 함";
+"disable_keychain_access_subtitle" = "사용 시 모든 키체인 접근을 차단합니다.";
+"about_tagline" = "토큰이 결코 바닥나지 않기를—에이전트 한도를 늘 확인하세요.";
+"link_github" = "GitHub";
+"link_website" = "웹사이트";
+"link_twitter" = "Twitter";
+"link_email" = "이메일";
+"check_updates_auto" = "자동으로 업데이트 확인";
+"update_channel" = "업데이트 채널";
+"check_for_updates" = "업데이트 확인…";
+"updates_unavailable" = "이 빌드에서는 업데이트를 사용할 수 없습니다.";
+"copyright" = "© 2026 Peter Steinberger. MIT License.";
+"section_logging" = "로깅";
+"enable_file_logging" = "파일 로깅 사용";
+"enable_file_logging_subtitle" = "디버깅을 위해 %@에 로그를 기록합니다.";
+"verbosity_title" = "상세 수준";
+"verbosity_subtitle" = "로그에 기록되는 세부 정보의 양을 제어합니다.";
+"open_log_file" = "로그 파일 열기";
+"force_animation_next_refresh" = "다음 새로 고침 시 애니메이션 강제 실행";
+"force_animation_next_refresh_subtitle" = "다음 새로 고침 후 불러오는 중 애니메이션을 일시적으로 표시합니다.";
+"section_loading_animations" = "불러오는 중 애니메이션";
+"loading_animations_caption" = "패턴을 선택하여 메뉴 막대에서 다시 재생하세요. \"무작위\"는 기존 동작을 유지합니다.";
+"animation_random_default" = "무작위(기본값)";
+"replay_selected_animation" = "선택한 애니메이션 다시 재생";
+"blink_now" = "지금 깜박이기";
+"section_probe_logs" = "프로브 로그";
+"probe_logs_caption" = "디버깅을 위해 최신 프로브 출력을 가져옵니다. 복사하면 전체 텍스트가 유지됩니다.";
+"fetch_log" = "로그 가져오기";
+"copy" = "복사";
+"save_to_file" = "파일로 저장";
+"load_parse_dump" = "파싱 덤프 불러오기";
+"rerun_provider_autodetect" = "공급자 자동 감지 다시 실행";
+"loading" = "불러오는 중…";
+"no_log_yet_fetch" = "아직 로그가 없습니다. 가져오기를 눌러 불러오세요.";
+"section_fetch_strategy" = "가져오기 전략 시도";
+"fetch_strategy_caption" = "공급자에 대한 마지막 가져오기 파이프라인 결정과 오류입니다.";
+"section_openai_cookies" = "OpenAI 쿠키";
+"openai_cookies_caption" = "마지막 OpenAI 쿠키 시도의 쿠키 가져오기 및 WebKit 스크레이프 로그입니다.";
+"no_log_yet" = "아직 로그가 없습니다. 공급자 → Codex에서 OpenAI 쿠키를 업데이트하여 가져오기를 실행하세요.";
+"section_caches" = "캐시";
+"caches_caption" = "캐시된 비용 스캔 결과 또는 브라우저 쿠키 캐시를 지웁니다.";
+"clear_cookie_cache" = "쿠키 캐시 지우기";
+"clear_cost_cache" = "비용 캐시 지우기";
+"section_notifications" = "알림";
+"notifications_caption" = "5시간 세션 기간에 대한 테스트 알림을 트리거합니다(소진/복원).";
+"post_depleted" = "소진 알림 보내기";
+"post_restored" = "복원 알림 보내기";
+"section_cli_sessions" = "CLI 세션";
+"cli_sessions_caption" = "프로브 후에도 Codex/Claude CLI 세션을 유지합니다. 기본값은 데이터가 캡처되면 종료합니다.";
+"keep_cli_sessions_alive" = "CLI 세션 유지";
+"keep_cli_sessions_alive_subtitle" = "프로브 간 종료를 건너뜁니다(디버그 전용).";
+"reset_cli_sessions" = "CLI 세션 재설정";
+"section_error_simulation" = "오류 시뮬레이션";
+"error_simulation_caption" = "레이아웃 테스트를 위해 메뉴 카드에 가짜 오류 메시지를 삽입합니다.";
+"set_menu_error" = "메뉴 오류 설정";
+"clear_menu_error" = "메뉴 오류 지우기";
+"set_cost_error" = "비용 오류 설정";
+"clear_cost_error" = "비용 오류 지우기";
+"section_cli_paths" = "CLI 경로";
+"cli_paths_caption" = "확인된 Codex 바이너리와 PATH 계층, 시작 시 로그인 PATH 캡처(짧은 시간 초과).";
+"codex_binary" = "Codex 바이너리";
+"claude_binary" = "Claude 바이너리";
+"effective_path" = "유효 PATH";
+"unavailable" = "사용할 수 없음";
+"login_shell_path" = "로그인 셸 PATH(시작 시 캡처)";
+"cleared" = "지웠습니다.";
+"no_fetch_attempts" = "아직 가져오기 시도가 없습니다.";
+"macOS Tahoe can block menu bar apps in System Settings → Menu Bar → Allow in the Menu Bar. CodexBar is running, but macOS may be hiding its icon. Open Menu Bar settings and turn CodexBar on." = "macOS Tahoe는 시스템 설정 → 메뉴 막대 → 메뉴 막대에서 허용 설정에서 메뉴 막대 앱을 차단할 수 있습니다. CodexBar는 실행 중이지만 macOS가 아이콘을 가리고 있을 수 있습니다. 메뉴 막대 설정을 열고 CodexBar를 켜세요.";
+"metric_pref_automatic" = "자동";
+"metric_pref_primary" = "1차";
+"metric_pref_secondary" = "2차";
+"metric_pref_tertiary" = "3차";
+"metric_pref_extra_usage" = "추가 사용량";
+"metric_pref_average" = "평균";
+"metric_mistral_payg" = "Pay-as-you-go";
+"metric_mistral_monthly_plan" = "Monthly Plan";
+"display_mode_percent" = "백분율";
+"display_mode_pace" = "사용 속도";
+"display_mode_both" = "둘 다";
+"display_mode_reset_time" = "재설정 시간";
+"display_mode_percent_desc" = "남은/사용한 백분율 표시(예: 45%)";
+"display_mode_pace_desc" = "사용 속도 표시기 표시(예: +5%)";
+"display_mode_both_desc" = "백분율과 사용 속도 모두 표시(예: 45% · +5%)";
+"display_mode_reset_time_desc" = "선택한 지표의 재설정 시간 표시(예: ↻ 오후 3:56)";
+"status_operational" = "정상 작동";
+"status_partial_outage" = "부분 장애";
+"status_major_outage" = "주요 장애";
+"status_critical_issue" = "심각한 문제";
+"status_maintenance" = "유지 보수";
+"status_unknown" = "상태 알 수 없음";
+"refresh_manual" = "수동";
+"refresh_1min" = "1분";
+"refresh_2min" = "2분";
+"refresh_5min" = "5분";
+"refresh_15min" = "15분";
+"refresh_30min" = "30분";
+"not_found" = "찾을 수 없음";
+"cost_header_estimated" = "비용(추정)";
+"cost_estimate_hint" = "로컬 로그에서 추정 · 실제 청구액과 다를 수 있음";
+"No JetBrains IDE with AI Assistant detected. Install a JetBrains IDE and enable AI Assistant." = "AI Assistant가 있는 JetBrains IDE를 찾지 못했습니다. JetBrains IDE를 설치하고 AI Assistant를 사용하세요.";
+"OpenRouter API token not configured. Set OPENROUTER_API_KEY environment variable or configure in Settings." = "OpenRouter API 토큰이 구성되지 않았습니다. OPENROUTER_API_KEY 환경 변수를 설정하거나 설정에서 구성하세요.";
+"z.ai API token not found. Set apiKey in ~/.codexbar/config.json or Z_AI_API_KEY." = "z.ai API 토큰을 찾을 수 없습니다. ~/.codexbar/config.json에 apiKey를 설정하거나 Z_AI_API_KEY를 설정하세요.";
+"Missing DeepSeek API key." = "DeepSeek API 키가 없습니다.";
+"%@ is unavailable in the current environment." = "%@은(는) 현재 환경에서 사용할 수 없습니다.";
+"All Systems Operational" = "모든 시스템 정상 작동";
+"Last 30 days" = "지난 30일";
+"Last 30 days:" = "지난 30일:";
+"This month" = "이번 달";
+"Store multiple OpenAI API keys." = "여러 OpenAI API 키를 저장합니다.";
+"Admin API key" = "관리자 API 키";
+"Open billing" = "결제 열기";
+"Google accounts" = "Google 계정";
+"Store multiple Antigravity Google OAuth accounts for quick switching." = "빠른 전환을 위해 여러 Antigravity Google OAuth 계정을 저장합니다.";
+"Add Google Account" = "Google 계정 추가";
+"Open Token Plan" = "Token Plan 열기";
+"Text Generation" = "텍스트 생성";
+"Text to Speech" = "텍스트 음성 변환";
+"Music Generation" = "음악 생성";
+"Image Generation" = "이미지 생성";
+"No local data found" = "로컬 데이터를 찾을 수 없음";
+"Credits unavailable; keep Codex running to refresh." = "크레딧을 사용할 수 없습니다. 새로 고치려면 Codex를 계속 실행하세요.";
+"No available fetch strategy for minimax." = "minimax에 사용할 수 있는 가져오기 전략이 없습니다.";
+"No Cursor session found. Please log in to cursor.com in Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX, or Edge Canary. If you use Safari, grant CodexBar Full Disk Access in System Settings ▸ Privacy & Security. You can also sign in to Cursor from the CodexBar menu (Add / switch account)." = "Cursor 세션을 찾을 수 없습니다. Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX 또는 Edge Canary에서 cursor.com에 로그인하세요. Safari를 사용하는 경우 시스템 설정 ▸ 개인정보 보호 및 보안에서 CodexBar에 전체 디스크 접근 권한을 부여하세요. CodexBar 메뉴(계정 추가/전환)에서 Cursor에 로그인할 수도 있습니다.";
+"No OpenCode session cookies found in browsers." = "브라우저에서 OpenCode 세션 쿠키를 찾을 수 없습니다.";
+"No available fetch strategy for %@." = "%@에 사용할 수 있는 가져오기 전략이 없습니다.";
+"Today" = "오늘";
+"Today tokens" = "오늘 토큰";
+"30d cost" = "30일 비용";
+"30d tokens" = "30일 토큰";
+"Latest tokens" = "최근 토큰";
+"Top model" = "상위 모델";
+"Storage" = "저장 공간";
+"Add Account..." = "계정 추가...";
+"Usage Dashboard" = "사용량 대시보드";
+"Status Page" = "상태 페이지";
+"Settings..." = "설정...";
+"About CodexBar" = "CodexBar 정보";
+"Quit" = "종료";
+"Last %d day" = "최근 %d일";
+"Last %d days" = "최근 %d일";
+"%@ tokens" = "%@ 토큰";
+"Latest billing day" = "최근 청구일";
+"Latest billing day (%@)" = "최근 청구일(%@)";
+"%@ left" = "%@ 남음";
+"Resets %@" = "%@에 재설정";
+"Resets in %@" = "%@ 후 재설정";
+"Resets now" = "지금 재설정";
+"reset_tomorrow_format" = "내일 %@";
+"Lasts until reset" = "재설정까지 유지";
+"Updated %@" = "%@에 업데이트됨";
+"Updated %@h ago" = "%@시간 전 업데이트됨";
+"Updated %@m ago" = "%@분 전 업데이트됨";
+"Updated just now" = "방금 업데이트됨";
+"Projected empty in %@" = "%@ 후 소진 예상";
+"Runs out in %@" = "%@ 후 소진";
+"Pace: %@" = "사용 속도: %@";
+"Pace: %@ · %@" = "사용 속도: %@ · %@";
+"%@ · %@" = "%@ · %@";
+"≈ %d%% run-out risk" = "≈ %d%% 소진 위험";
+"%d%% in deficit" = "%d%% 부족";
+"%d%% in reserve" = "%d%% 여유";
+"usage_percent_suffix_left" = "남음";
+"usage_percent_suffix_used" = "사용";
+"Store multiple DeepSeek API keys." = "여러 DeepSeek API 키를 저장합니다.";
+"This week" = "이번 주";
+"Week" = "주";
+"Month" = "월";
+"Models" = "모델";
+"24h tokens" = "24시간 토큰";
+"Latest hour" = "최근 1시간";
+"Peak hour" = "최대 사용 시간";
+"Top method" = "상위 메서드";
+"30d cash" = "30일 현금";
+"30d billing history from MiniMax web session" = "MiniMax 웹 세션의 30일 청구 내역";
+"AWS Cost Explorer billing can lag." = "AWS Cost Explorer 청구는 지연될 수 있습니다.";
+"Rate limit: %d / %@" = "속도 제한: %d / %@";
+"Key remaining" = "키 잔여량";
+"No limit set for the API key" = "API 키에 설정된 한도가 없습니다";
+"API key limit unavailable right now" = "지금은 API 키 한도를 사용할 수 없습니다";
+"This month: %@ tokens" = "이번 달: %@ 토큰";
+"No utilization data yet." = "아직 사용률 데이터가 없습니다.";
+"No %@ utilization data yet." = "아직 %@ 사용률 데이터가 없습니다.";
+"%@: %@%% used" = "%@: %@%% 사용";
+"%dd" = "%d일";
+"today" = "오늘";
+"just now" = "방금";
+"On pace" = "정상 속도";
+"Runs out now" = "지금 소진";
+"Projected empty now" = "지금 소진 예상";
+"Switch Account..." = "계정 전환...";
+"Update ready, restart now?" = "업데이트 준비 완료, 지금 다시 시작할까요?";
+"Daily" = "일간";
+"Hourly Tokens" = "시간별 토큰";
+"No data" = "데이터 없음";
+"No usage breakdown data available." = "사용량 분석 데이터가 없습니다.";
+"Today: %@ · %@ tokens" = "오늘: %@ · 토큰 %@개";
+"Today: %@" = "오늘: %@";
+"Today: %@ tokens" = "오늘: 토큰 %@개";
+"Last 30 days: %@ · %@ tokens" = "최근 30일: %@ · 토큰 %@개";
+"Last 30 days: %@" = "최근 30일: %@";
+"Est. total (30d): %@" = "예상 합계(30일): %@";
+"Est. total (%@): %@" = "예상 합계(%@): %@";
+"Hover a bar for details" = "막대에 마우스를 올리면 세부 정보 표시";
+"%@: %@ · %@ tokens" = "%@: %@ · 토큰 %@개";
+"No providers selected for Overview." = "개요에 선택된 공급자가 없습니다.";
+"No overview data available." = "개요 데이터가 없습니다.";
+"Auto uses the local IDE API first, then Google OAuth when the IDE is closed." = "자동 모드는 로컬 IDE API를 먼저 사용하고, IDE가 닫혀 있으면 Google OAuth를 사용합니다.";
+"Login with Google" = "Google로 로그인";
+"No usage configured." = "구성된 사용량이 없습니다.";
+"Quota" = "할당량";
+"tokens" = "토큰";
+"requests" = "요청";
+"Latest" = "최신";
+"Monthly" = "월간";
+"Sonnet" = "Sonnet";
+"Overages" = "초과분";
+"Activity" = "활동";
+"Copied" = "복사됨";
+"Copy error" = "오류 복사";
+"Copy path" = "경로 복사";
+"Extra usage spent" = "추가 사용 지출액";
+"Credits remaining" = "남은 크레딧";
+"Using CLI fallback" = "CLI 대체 사용 중";
+"Balance updates in near-real time (up to 5 min lag)" = "잔액은 거의 실시간으로 업데이트됩니다(최대 5분 지연)";
+"Daily billing data finalizes at 07:00 UTC" = "일간 청구 데이터는 07:00 UTC에 확정됩니다";
+"%@ of %@ credits left" = "크레딧 %2$@개 중 %1$@개 남음";
+"%@ of %@ bonus credits left" = "보너스 크레딧 %2$@개 중 %1$@개 남음";
+"%@ / %@ (%@ remaining)" = "%@ / %@ (%@ 남음)";
+"%@/%@ left" = "%@/%@ 남음";
+"Gemini Flash" = "Gemini Flash";
+"Regenerates %@" = "%@에 재생성";
+"used after next regen" = "다음 재생성 후 사용됨";
+"after next regen" = "다음 재생성 후";
+"Near full" = "거의 가득 참";
+"Full in ~1 regen" = "약 1회 재생성 후 가득 참";
+"Full in ~%.0f regens" = "약 %.0f회 재생성 후 가득 참";
+"Overage usage" = "초과 사용량";
+"Overage cost" = "초과 비용";
+"credits" = "크레딧";
+"Zen balance" = "Zen 잔액";
+"API spend" = "API 지출";
+"Extra usage" = "추가 사용량";
+"Quota usage" = "할당량 사용량";
+"Your spend" = "개인 지출";
+"%.0f%% used" = "%.0f%% 사용됨";
+"Usage history (today)" = "사용 기록(오늘)";
+"Usage history (%d days)" = "사용 기록(%d일)";
+"%d percent remaining" = "%d퍼센트 남음";
+"Unknown" = "알 수 없음";
+"stale data" = "오래된 데이터";
+"No credits history data." = "크레딧 기록 데이터가 없습니다.";
+"No credits history data available." = "크레딧 기록 데이터가 없습니다.";
+"Credits history chart" = "크레딧 기록 차트";
+"%d days of credits data" = "크레딧 데이터 %d일";
+"Usage breakdown chart" = "사용량 분석 차트";
+"%d days of usage data across %d services" = "%2$d개 서비스의 %1$d일간 사용량 데이터";
+"Cost history chart" = "비용 내역 차트";
+"%d days of cost data" = "%d일간 비용 데이터";
+"Plan utilization chart" = "요금제 사용률 차트";
+"%d utilization samples" = "사용률 샘플 %d개";
+"Hourly Usage" = "시간별 사용량";
+"Usage remaining" = "남은 사용량";
+"Usage used" = "사용한 사용량";
+"API key verified. Ollama does not expose Cloud quota limits through the API." = "API 키가 확인되었습니다. Ollama는 API를 통해 클라우드 할당량 한도를 제공하지 않습니다.";
+"Last 30 days: %@ tokens" = "지난 30일: %@ 토큰";
+"7d spend" = "7일 지출";
+"30d spend" = "30일 지출";
+"Cache read" = "캐시 읽기";
+"Claude Admin API 30 day spend trend" = "Claude Admin API 30일 지출 추세";
+"OpenRouter API key spend trend" = "OpenRouter API 키 지출 추세";
+"z.ai hourly token trend" = "z.ai 시간별 토큰 추세";
+"MiniMax 30 day token usage trend" = "MiniMax 30일 토큰 사용량 추세";
+"Today cash" = "오늘 현금";
+"DeepSeek 30 day token usage trend" = "DeepSeek 30일 토큰 사용량 추세";
+"cache-hit input" = "캐시 적중 입력";
+"cache-miss input" = "캐시 미스 입력";
+"output" = "출력";
+"Requests" = "요청";
+"Reported by OpenAI Admin API organization usage." = "OpenAI Admin API 조직 사용량 기준으로 보고됨";
+"Reported by Mistral billing usage." = "Mistral 청구 사용량 기준으로 보고됨";
+"Google OAuth" = "Google OAuth";
+"Add accounts via GitHub OAuth Device Flow on the selected host." = "선택한 호스트에서 GitHub OAuth 장치 흐름으로 계정을 추가합니다.";
+"Stores each signed-in Google account for quick Antigravity switching. Uses Antigravity.app OAuth when available, or ANTIGRAVITY_OAUTH_CLIENT_ID and ANTIGRAVITY_OAUTH_CLIENT_SECRET as an override." = "빠른 Antigravity 전환을 위해 로그인한 각 Google 계정을 저장합니다. 가능한 경우 Antigravity.app OAuth를 사용하며, 재정의하려면 ANTIGRAVITY_OAUTH_CLIENT_ID와 ANTIGRAVITY_OAUTH_CLIENT_SECRET을 사용합니다.";
+"Manual cleanup: past sessions" = "수동 정리: 지난 세션";
+"Clearing removes past resume, continue, and rewind history." = "지우면 지난 재개, 계속, 되감기 기록이 제거됩니다.";
+"Manual cleanup: file checkpoints" = "수동 정리: 파일 체크포인트";
+"Clearing removes checkpoint restore data for previous edits." = "지우면 이전 편집의 체크포인트 복원 데이터가 제거됩니다.";
+"Manual cleanup: saved plans" = "수동 정리: 저장된 계획";
+"Clearing removes old plan-mode files." = "지우면 오래된 계획 모드 파일이 제거됩니다.";
+"Manual cleanup: debug logs" = "수동 정리: 디버그 로그";
+"Clearing removes past debug logs." = "지우면 지난 디버그 로그가 제거됩니다.";
+"Manual cleanup: attachment cache" = "수동 정리: 첨부 파일 캐시";
+"Clearing removes cached large pastes or attached images." = "지우면 캐시된 대용량 붙여넣기 또는 첨부 이미지가 제거됩니다.";
+"Manual cleanup: session metadata" = "수동 정리: 세션 메타데이터";
+"Clearing removes per-session environment metadata." = "지우면 세션별 환경 메타데이터가 제거됩니다.";
+"Manual cleanup: shell snapshots" = "수동 정리: 셸 스냅샷";
+"Clearing removes leftover runtime shell snapshot files." = "지우면 남아 있는 런타임 셸 스냅샷 파일이 제거됩니다.";
+"Manual cleanup: legacy todos" = "수동 정리: 레거시 할 일";
+"Clearing removes legacy per-session task lists." = "지우면 레거시 세션별 작업 목록이 제거됩니다.";
+"Manual cleanup: sessions" = "수동 정리: 세션";
+"Clearing removes past Codex session history." = "지우면 지난 Codex 세션 기록이 제거됩니다.";
+"Manual cleanup: archived sessions" = "수동 정리: 보관된 세션";
+"Clearing removes archived Codex session history." = "지우면 보관된 Codex 세션 기록이 제거됩니다.";
+"Manual cleanup: cache" = "수동 정리: 캐시";
+"Clearing removes provider-owned cached data." = "지우면 공급자 소유의 캐시 데이터가 제거됩니다.";
+"Manual cleanup: logs" = "수동 정리: 로그";
+"Clearing removes local diagnostic logs." = "지우면 로컬 진단 로그가 제거됩니다.";
+"Manual cleanup: file history" = "수동 정리: 파일 기록";
+"Clearing removes local edit checkpoint history." = "지우면 로컬 편집 체크포인트 기록이 제거됩니다.";
+"Manual cleanup: temporary data" = "수동 정리: 임시 데이터";
+"Clearing removes local temporary provider data." = "지우면 로컬 임시 공급자 데이터가 제거됩니다.";
+"Total: %@" = "총계: %@";
+"%d more items" = "항목 %d개 더";
+"Cleanup ideas" = "정리 아이디어";
+"%d unreadable item(s) skipped" = "읽을 수 없는 항목 %d개 건너뜀";
+"API key limit" = "API 키 한도";
+"Auth" = "인증";
+"Auto" = "자동";
+"Disabled — no recent data" = "사용 안 함 — 최근 데이터 없음";
+"Limits not available" = "한도를 사용할 수 없음";
+"No usage yet" = "아직 사용량 없음";
+"Not fetched yet" = "아직 가져오지 않음";
+"Refreshing" = "새로 고치는 중";
+"Session" = "세션";
+"Source" = "소스";
+"State" = "상태";
+"Unavailable" = "사용할 수 없음";
+"Weekly" = "주간";
+"not detected" = "감지되지 않음";
+"Estimated from local Codex logs for the selected account." = "선택한 계정의 로컬 Codex 로그를 기반으로 추정됨.";
+"minimax_usage_amount_format" = "사용량: %@ / %@";
+"minimax_used_percent_format" = "%@ 사용됨";
+"minimax_service_text_generation" = "텍스트 생성";
+"minimax_service_text_to_speech" = "텍스트 음성 변환";
+"minimax_service_music_generation" = "음악 생성";
+"minimax_service_image_generation" = "이미지 생성";
+"minimax_service_lyrics_generation" = "가사 생성";
+"minimax_service_coding_plan_vlm" = "코딩 요금제 VLM";
+"minimax_service_coding_plan_search" = "코딩 요금제 검색";
+"%@ is waiting for permission" = "%@이(가) 권한을 기다리는 중";
+"%@ requests" = "%@ 요청";
+"%@: %@ credits" = "%@: %@ 크레딧";
+"30d requests" = "30일 요청";
+"4 days" = "4일";
+"5 days" = "5일";
+"7 days" = "7일";
+"API key verifies Ollama Cloud access; cookies still expose quota limits." = "API 키는 Ollama Cloud 접근을 확인하며, 쿠키는 여전히 할당량 한도를 노출합니다.";
+"AWS access key ID. Can also be set with AWS_ACCESS_KEY_ID." = "AWS 액세스 키 ID. AWS_ACCESS_KEY_ID로도 설정할 수 있습니다.";
+"AWS region. Can also be set with AWS_REGION." = "AWS 리전. AWS_REGION으로도 설정할 수 있습니다.";
+"AWS secret access key. Can also be set with AWS_SECRET_ACCESS_KEY." = "AWS 시크릿 액세스 키. AWS_SECRET_ACCESS_KEY로도 설정할 수 있습니다.";
+"Access key ID" = "액세스 키 ID";
+"Add Account" = "계정 추가";
+"Adding Account…" = "계정 추가 중…";
+"Antigravity login failed" = "Antigravity 로그인 실패";
+"Antigravity login timed out" = "Antigravity 로그인 시간 초과";
+"Auth source" = "인증 소스";
+"Automatic imports browser cookies from Xiaomi MiMo." = "Xiaomi MiMo에서 브라우저 쿠키를 자동으로 가져옵니다.";
+"Automatic imports Windsurf session data from Chromium browser localStorage." = "Chromium 브라우저 localStorage에서 Windsurf 세션 데이터를 자동으로 가져옵니다.";
+"Automatic imports browser cookies from Bailian." = "Bailian에서 브라우저 쿠키를 자동으로 가져옵니다.";
+"Automatically imports browser cookies." = "브라우저 쿠키를 자동으로 가져옵니다.";
+"Automatically imports browser session cookies." = "브라우저 세션 쿠키를 자동으로 가져옵니다.";
+"Azure OpenAI deployment name. AZURE_OPENAI_DEPLOYMENT_NAME is also supported." = "Azure OpenAI 배포 이름. AZURE_OPENAI_DEPLOYMENT_NAME도 지원됩니다.";
+"Azure OpenAI key" = "Azure OpenAI 키";
+"Azure OpenAI resource endpoint. AZURE_OPENAI_ENDPOINT is also supported." = "Azure OpenAI 리소스 엔드포인트. AZURE_OPENAI_ENDPOINT도 지원됩니다.";
+"Base URL" = "기본 URL";
+"Base URL for the LLM-API-Key-Proxy instance." = "LLM-API-Key-Proxy 인스턴스의 기본 URL.";
+"Browser cookies" = "브라우저 쿠키";
+"Cap end" = "한도 종료";
+"Cap start" = "한도 시작";
+"Capacity End" = "용량 종료";
+"Capacity Start" = "용량 시작";
+"Changelog" = "변경 사항";
+"Choose the Moonshot/Kimi API host for international or China mainland accounts." = "해외 또는 중국 본토 계정에 맞는 Moonshot/Kimi API 호스트를 선택하세요.";
+"CodexBar can't replace a system account that is signed in with an API key only setup." = "CodexBar는 API 키 전용 설정으로 로그인된 시스템 계정을 교체할 수 없습니다.";
+"CodexBar could not find saved auth for that account. Re-authenticate it and try again." = "CodexBar가 해당 계정의 저장된 인증을 찾을 수 없습니다. 다시 인증한 후 시도하세요.";
+"CodexBar could not read managed account storage. Recover the store before adding another account." = "CodexBar가 관리되는 계정 저장소를 읽을 수 없습니다. 다른 계정을 추가하기 전에 저장소를 복구하세요.";
+"CodexBar could not read saved auth for that account. Re-authenticate it and try again." = "CodexBar가 해당 계정의 저장된 인증을 읽을 수 없습니다. 다시 인증한 후 시도하세요.";
+"CodexBar could not read the current system account on this Mac." = "CodexBar가 이 Mac의 현재 시스템 계정을 읽을 수 없습니다.";
+"CodexBar could not replace the live Codex auth on this Mac." = "CodexBar가 이 Mac의 활성 Codex 인증을 교체할 수 없습니다.";
+"CodexBar could not safely preserve the current system account before switching." = "CodexBar가 전환하기 전에 현재 시스템 계정을 안전하게 보존할 수 없습니다.";
+"CodexBar could not save the current system account before switching." = "CodexBar가 전환하기 전에 현재 시스템 계정을 저장할 수 없습니다.";
+"CodexBar could not update managed account storage." = "CodexBar가 관리되는 계정 저장소를 업데이트할 수 없습니다.";
+"CodexBar found another managed account that already uses the current system account. Resolve the duplicate account before switching." = "CodexBar가 현재 시스템 계정을 이미 사용 중인 다른 관리 계정을 발견했습니다. 전환하기 전에 중복된 계정을 해결하세요.";
+"CodexBar will ask macOS Keychain for “%@” so it can decrypt browser cookies and authenticate your account. Click OK to continue." = "CodexBar가 브라우저 쿠키를 복호화하고 계정을 인증할 수 있도록 macOS 키체인에 “%@”을(를) 요청합니다. 계속하려면 확인을 클릭하세요.";
+"CodexBar will ask macOS Keychain for the Claude Code OAuth token so it can fetch your Claude usage. Click OK to continue." = "CodexBar가 Claude 사용량을 가져올 수 있도록 macOS 키체인에 Claude Code OAuth 토큰을 요청합니다. 계속하려면 확인을 클릭하세요.";
+"CodexBar will ask macOS Keychain for your Amp cookie header so it can fetch usage. Click OK to continue." = "CodexBar가 사용량을 가져올 수 있도록 macOS 키체인에 Amp 쿠키 헤더를 요청합니다. 계속하려면 확인을 클릭하세요.";
+"CodexBar will ask macOS Keychain for your Augment cookie header so it can fetch usage. Click OK to continue." = "CodexBar가 사용량을 가져올 수 있도록 macOS 키체인에 Augment 쿠키 헤더를 요청합니다. 계속하려면 확인을 클릭하세요.";
+"CodexBar will ask macOS Keychain for your Claude cookie header so it can fetch Claude web usage. Click OK to continue." = "CodexBar가 Claude 웹 사용량을 가져올 수 있도록 macOS 키체인에 Claude 쿠키 헤더를 요청합니다. 계속하려면 확인을 클릭하세요.";
+"CodexBar will ask macOS Keychain for your Cursor cookie header so it can fetch usage. Click OK to continue." = "CodexBar가 사용량을 가져올 수 있도록 macOS 키체인에 Cursor 쿠키 헤더를 요청합니다. 계속하려면 확인을 클릭하세요.";
+"CodexBar will ask macOS Keychain for your Factory cookie header so it can fetch usage. Click OK to continue." = "CodexBar가 사용량을 가져올 수 있도록 macOS 키체인에 Factory 쿠키 헤더를 요청합니다. 계속하려면 확인을 클릭하세요.";
+"CodexBar will ask macOS Keychain for your GitHub Copilot token so it can fetch usage. Click OK to continue." = "CodexBar가 사용량을 가져올 수 있도록 macOS 키체인에 GitHub Copilot 토큰을 요청합니다. 계속하려면 확인을 클릭하세요.";
+"CodexBar will ask macOS Keychain for your Kimi K2 API key so it can fetch usage. Click OK to continue." = "CodexBar가 사용량을 가져올 수 있도록 macOS 키체인에 Kimi K2 API 키를 요청합니다. 계속하려면 확인을 클릭하세요.";
+"CodexBar will ask macOS Keychain for your Kimi auth token so it can fetch usage. Click OK to continue." = "CodexBar가 사용량을 가져올 수 있도록 macOS 키체인에 Kimi 인증 토큰을 요청합니다. 계속하려면 확인을 클릭하세요.";
+"CodexBar will ask macOS Keychain for your MiniMax API token so it can fetch usage. Click OK to continue." = "CodexBar가 사용량을 가져올 수 있도록 macOS 키체인에 MiniMax API 토큰을 요청합니다. 계속하려면 확인을 클릭하세요.";
+"CodexBar will ask macOS Keychain for your MiniMax cookie header so it can fetch usage. Click OK to continue." = "CodexBar가 사용량을 가져올 수 있도록 macOS 키체인에 MiniMax 쿠키 헤더를 요청합니다. 계속하려면 확인을 클릭하세요.";
+"CodexBar will ask macOS Keychain for your OpenAI cookie header so it can fetch Codex dashboard extras. Click OK to continue." = "CodexBar가 Codex 대시보드 추가 정보를 가져올 수 있도록 macOS 키체인에 OpenAI 쿠키 헤더를 요청합니다. 계속하려면 확인을 클릭하세요.";
+"CodexBar will ask macOS Keychain for your OpenCode cookie header so it can fetch usage. Click OK to continue." = "CodexBar가 사용량을 가져올 수 있도록 macOS 키체인에 OpenCode 쿠키 헤더를 요청합니다. 계속하려면 확인을 클릭하세요.";
+"CodexBar will ask macOS Keychain for your Synthetic API key so it can fetch usage. Click OK to continue." = "CodexBar가 사용량을 가져올 수 있도록 macOS 키체인에 Synthetic API 키를 요청합니다. 계속하려면 확인을 클릭하세요.";
+"CodexBar will ask macOS Keychain for your z.ai API token so it can fetch usage. Click OK to continue." = "CodexBar가 사용량을 가져올 수 있도록 macOS 키체인에 z.ai API 토큰을 요청합니다. 계속하려면 확인을 클릭하세요.";
+"Could not open Cursor login in your browser." = "브라우저에서 Cursor 로그인을 열 수 없습니다.";
+"Could not open browser for Antigravity" = "Antigravity용 브라우저를 열 수 없습니다";
+"Credits used" = "사용한 크레딧";
+"Day" = "일간";
+"Deployment" = "배포";
+"Drag to reorder" = "드래그하여 순서 변경";
+"Sort providers alphabetically" = "공급자를 알파벳순으로 정렬";
+"Sort providers alphabetically (enabled first)" = "공급자를 알파벳순으로 정렬(활성화 항목 우선)";
+"Sorted alphabetically (enabled first) — click to use your custom order" = "알파벳순으로 정렬됨(활성화 항목 우선) — 사용자 지정 순서를 사용하려면 클릭";
+"Endpoint" = "엔드포인트";
+"Enterprise host" = "엔터프라이즈 호스트";
+"Extra usage balance: %@" = "추가 사용량 잔액: %@";
+"Keychain Access Required" = "키체인 접근 필요";
+"Kiro menu bar value" = "Kiro 메뉴 막대 값";
+"Label" = "레이블";
+"No organizations loaded. Click Refresh after setting your API key." = "불러온 조직이 없습니다. API 키를 설정한 후 새로 고침을 클릭하세요.";
+"No output captured." = "캡처된 출력이 없습니다.";
+"No system account" = "시스템 계정 없음";
+"Oasis-Token" = "Oasis-Token";
+"Open Augment (Log Out & Back In)" = "Augment 열기(로그아웃 후 다시 로그인)";
+"Open Codebuff Dashboard" = "Codebuff 대시보드 열기";
+"Open Command Code Settings" = "Command Code 설정 열기";
+"Open Crof dashboard" = "Crof 대시보드 열기";
+"Open Manus" = "Manus 열기";
+"Open MiMo Balance" = "MiMo 잔액 열기";
+"Open Moonshot Console" = "Moonshot 콘솔 열기";
+"Open Ollama API Keys" = "Ollama API 키 열기";
+"Open StepFun Platform" = "StepFun 플랫폼 열기";
+"Open T3 Chat Settings" = "T3 Chat 설정 열기";
+"Open Volcengine Ark Console" = "Volcengine Ark 콘솔 열기";
+"Open legacy provider docs" = "레거시 공급자 문서 열기";
+"Open projects" = "프로젝트 열기";
+"Open this URL manually to continue login:\n\n%@" = "로그인을 계속하려면 이 URL을 수동으로 여세요:\n\n%@";
+"Optional organization ID for accounts linked to multiple Anthropic organizations." = "여러 Anthropic 조직에 연결된 계정을 위한 선택적 조직 ID입니다.";
+"Optional. Applies to the configured Admin API key; selected token accounts do not inherit OPENAI_PROJECT_ID." = "선택 사항입니다. 구성된 Admin API 키에 적용되며, 선택한 토큰 계정은 OPENAI_PROJECT_ID를 상속하지 않습니다.";
+"Optional. Enter your GitHub Enterprise host, for example octocorp.ghe.com. Leave blank for github.com." = "선택 사항입니다. GitHub Enterprise 호스트를 입력하세요. 예: octocorp.ghe.com. github.com을 사용하려면 비워 두세요.";
+"Optional. Leave blank to discover and aggregate projects visible to the API key." = "선택 사항입니다. API 키에 표시되는 프로젝트를 검색하고 집계하려면 비워 두세요.";
+"Org ID (optional)" = "조직 ID(선택 사항)";
+"Organizations" = "조직";
+"Password" = "암호";
+"%@ authentication is disabled." = "%@ 인증이 사용 안 함으로 설정되어 있습니다.";
+"%@ cookies are disabled." = "%@ 쿠키가 사용 안 함으로 설정되어 있습니다.";
+"%@ web API access is disabled." = "%@ 웹 API 접근이 사용 안 함으로 설정되어 있습니다.";
+"Disable %@ dashboard cookie usage." = "%@ 대시보드 쿠키 사용을 사용 안 함으로 설정합니다.";
+"Keychain access is disabled in Advanced, so browser cookie import is unavailable." = "고급에서 키체인 접근이 사용 안 함으로 설정되어 있어 브라우저 쿠키 가져오기를 사용할 수 없습니다.";
+"Manually paste an %@ from a browser session." = "브라우저 세션에서 %@을(를) 수동으로 붙여넣으세요.";
+"Paste a Cookie header captured from %@." = "%@에서 캡처한 쿠키 헤더를 붙여넣으세요.";
+"Paste a Cookie header from %@." = "%@의 쿠키 헤더를 붙여넣으세요.";
+"Paste a Cookie header or cURL capture from %@." = "%@의 쿠키 헤더 또는 cURL 캡처를 붙여넣으세요.";
+"Paste a Cookie header or full cURL capture from %@." = "%@의 쿠키 헤더 또는 전체 cURL 캡처를 붙여넣으세요.";
+"Paste a Cookie or Authorization header from %@." = "%@의 쿠키 또는 Authorization 헤더를 붙여넣으세요.";
+"Paste a full cookie header or the %@ value." = "전체 쿠키 헤더 또는 %@ 값을 붙여넣으세요.";
+"Paste a Cookie header or full cURL capture from T3 Chat settings." = "T3 Chat 설정에서 쿠키 헤더 또는 전체 cURL 캡처를 붙여넣으세요.";
+"Paste the Cookie header from a request to admin.mistral.ai. Must contain an ory_session_* cookie." = "admin.mistral.ai에 대한 요청의 Cookie 헤더를 붙여넣으세요. ory_session_* 쿠키가 포함되어야 합니다.";
+"Paste the Oasis-Token from a logged-in browser session on platform.stepfun.com." = "platform.stepfun.com에 로그인된 브라우저 세션의 Oasis-Token을 붙여넣으세요.";
+"Paste the %@ JSON bundle from %@." = "%2$@의 %1$@ JSON 번들을 붙여넣으세요.";
+"Paste the %@ value or a full Cookie header." = "%@ 값 또는 전체 Cookie 헤더를 붙여넣으세요.";
+"Personal account" = "개인 계정";
+"Project ID" = "프로젝트 ID";
+"Re-auth" = "재인증";
+"Re-login at claude.ai" = "claude.ai에서 다시 로그인";
+"Re-authenticating…" = "다시 인증하는 중…";
+"Refresh Session" = "세션 새로 고침";
+"Refresh organizations" = "조직 새로 고침";
+"Region" = "지역";
+"Reload" = "다시 불러오기";
+"Reorder" = "순서 변경";
+"Secret access key" = "보안 액세스 키";
+"Series" = "시리즈";
+"Service" = "서비스";
+"Show or hide Kiro credits, percent, or both next to the menu bar icon." = "메뉴 막대 아이콘 옆에 Kiro 크레딧, 백분율 또는 둘 다를 표시하거나 가립니다.";
+"Show usage for organizations you belong to. Personal account is always shown." = "사용자가 속한 조직의 사용량을 표시합니다. 개인 계정은 항상 표시됩니다.";
+"Sign in to cursor.com in your browser, then refresh Cursor in CodexBar." = "브라우저에서 cursor.com에 로그인한 다음 CodexBar에서 Cursor를 새로 고침하세요.";
+"Simulated error text" = "시뮬레이션된 오류 텍스트";
+"StepFun platform account (phone number or email)." = "StepFun 플랫폼 계정(전화번호 또는 이메일).";
+"Stored in ~/.codexbar/config.json." = "~/.codexbar/config.json에 저장됩니다.";
+"Stored in ~/.codexbar/config.json. AZURE_OPENAI_API_KEY is also supported." = "~/.codexbar/config.json에 저장됩니다. AZURE_OPENAI_API_KEY도 지원됩니다.";
+"Stored in ~/.codexbar/config.json. For the official Kimi API, use Moonshot / Kimi API." = "~/.codexbar/config.json에 저장됩니다. 공식 Kimi API의 경우 Moonshot / Kimi API를 사용하세요.";
+"Stored in ~/.codexbar/config.json. Get your API key from the Volcengine Ark console." = "~/.codexbar/config.json에 저장됩니다. Volcengine Ark 콘솔에서 API 키를 받으세요.";
+"Stored in ~/.codexbar/config.json. Get your key from Ollama settings." = "~/.codexbar/config.json에 저장됩니다. Ollama 설정에서 키를 받으세요.";
+"Stored in ~/.codexbar/config.json. Get your key from console.deepgram.com." = "~/.codexbar/config.json에 저장됩니다. console.deepgram.com에서 키를 받으세요.";
+"Stored in ~/.codexbar/config.json. Get your key from elevenlabs.io/app/settings/api-keys." = "~/.codexbar/config.json에 저장됩니다. elevenlabs.io/app/settings/api-keys에서 키를 받으세요.";
+"Stored in ~/.codexbar/config.json. Get your key from openrouter.ai/settings/keys and set a key spending limit there to enable API key quota tracking." = "~/.codexbar/config.json에 저장됩니다. openrouter.ai/settings/keys에서 키를 받고, API 키 할당량 추적을 사용하려면 그곳에서 키 지출 한도를 설정하세요.";
+"Stored in ~/.codexbar/config.json. In Warp, open Settings > Platform > API Keys, then create one." = "~/.codexbar/config.json에 저장됩니다. Warp에서 Settings > Platform > API Keys를 연 다음 하나를 생성하세요.";
+"Stored in ~/.codexbar/config.json. Metrics require Groq Enterprise Prometheus access." = "~/.codexbar/config.json에 저장됩니다. 지표를 보려면 Groq Enterprise Prometheus 액세스가 필요합니다.";
+"Stored in ~/.codexbar/config.json. OPENAI_ADMIN_KEY is preferred; OPENAI_API_KEY still works." = "~/.codexbar/config.json에 저장됩니다. OPENAI_ADMIN_KEY를 권장하지만 OPENAI_API_KEY도 여전히 작동합니다.";
+"Stored in ~/.codexbar/config.json. Requires an Anthropic Admin API key." = "~/.codexbar/config.json에 저장됩니다. Anthropic Admin API 키가 필요합니다.";
+"Stored in ~/.codexbar/config.json. Used for /v1/quota-stats." = "~/.codexbar/config.json에 저장됩니다. /v1/quota-stats에 사용됩니다.";
+"Stored in ~/.codexbar/config.json. You can also provide CODEBUFF_API_KEY or let CodexBar read ~/.config/manicode/credentials.json (created by `codebuff login`)." = "~/.codexbar/config.json에 저장됩니다. CODEBUFF_API_KEY를 제공하거나 CodexBar가 ~/.config/manicode/credentials.json(`codebuff login`으로 생성됨)을 읽도록 할 수도 있습니다.";
+"Stored in ~/.codexbar/config.json. You can also provide CROF_API_KEY." = "~/.codexbar/config.json에 저장됩니다. CROF_API_KEY를 제공할 수도 있습니다.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or ~/.local/share/kilo/auth.json (kilo.access)." = "~/.codexbar/config.json에 저장됩니다. KILO_API_KEY 또는 ~/.local/share/kilo/auth.json(kilo.access)을 제공할 수도 있습니다.";
+"T3 Chat cookie" = "T3 Chat 쿠키";
+"That account is no longer available in CodexBar. Refresh the account list and try again." = "해당 계정은 더 이상 CodexBar에서 사용할 수 없습니다. 계정 목록을 새로 고침한 후 다시 시도하세요.";
+"The browser login did not complete in time. Try Antigravity login again." = "브라우저 로그인이 제때 완료되지 않았습니다. Antigravity 로그인을 다시 시도하세요.";
+"Timed out waiting for Cursor login. %@" = "Cursor 로그인을 기다리는 중 시간이 초과되었습니다. %@";
+"Timed out waiting for Cursor login. %@ Last error: %@" = "Cursor 로그인을 기다리는 중 시간이 초과되었습니다. %@ 마지막 오류: %@";
+"Today requests" = "오늘 요청";
+"Total (30d): %@ credits" = "총계(30일): %@ 크레딧";
+"Username" = "사용자 이름";
+"Uses username + password to login and obtain an Oasis-Token automatically." = "사용자 이름 + 비밀번호로 로그인하여 Oasis-Token을 자동으로 가져옵니다.";
+"Uses username + password to login and obtain an %@ automatically." = "사용자 이름 + 비밀번호로 로그인하여 %@을(를) 자동으로 가져옵니다.";
+"Utilization End" = "사용률 종료";
+"Utilization Start" = "사용률 시작";
+"Verbosity" = "상세도";
+"Windsurf session JSON bundle" = "Windsurf 세션 JSON 번들";
+"Workspace ID" = "작업 공간 ID";
+"Your StepFun platform password. Used to login and obtain a session token." = "StepFun 플랫폼 비밀번호입니다. 로그인하여 세션 토큰을 가져오는 데 사용됩니다.";
+"claude /login exited with status %d." = "claude /login이 상태 %d(으)로 종료되었습니다.";
+"codex login exited with status %d." = "codex login이 상태 %d(으)로 종료되었습니다.";
+"Cookie: …\n\nor paste a cURL capture from the Abacus AI dashboard" = "Cookie: …\n\n또는 Abacus AI 대시보드에서 캡처한 cURL을 붙여넣으세요";
+"Cookie: …\n\nor paste the __Secure-next-auth.session-token value" = "Cookie: …\n\n또는 __Secure-next-auth.session-token 값을 붙여넣으세요";
+"Cookie: …\n\nor paste the kimi-auth token value" = "Cookie: …\n\n또는 kimi-auth 토큰 값을 붙여넣으세요";
+"session_id=...\n\nor paste just the session_id value" = "session_id=...\n\n또는 session_id 값만 붙여넣으세요";
+"Clear" = "지우기";
+"No matching providers" = "일치하는 공급자 없음";
+"Search providers" = "공급자 검색";
+"language_vietnamese" = "베트남어";
+"language_turkish" = "Türkçe";
+"language_indonesian" = "인도네시아어";
+"Request quota: %@ / %@" = "요청 할당량: %@ / %@";
+"language_arabic" = "العربية";
+"language_persian" = "فارسی";
+"language_thai" = "ไทย";
+"Limit Reset Credits" = "한도 재설정 크레딧";
+"1 manual reset available" = "수동 재설정 1회 사용 가능";
+"%d manual resets available" = "수동 재설정 %d회 사용 가능";
+"Next expires %@" = "다음 만료: %@";
+"Other (%d items)" = "기타(%d개 항목)";
+"Expand" = "펼치기";
+"Collapse" = "접기";
+"byte_unit_byte" = "바이트";
+"byte_unit_bytes" = "바이트";
+"byte_unit_kilobyte" = "킬로바이트";
+"byte_unit_kilobytes" = "킬로바이트";
+"byte_unit_megabyte" = "메가바이트";
+"byte_unit_megabytes" = "메가바이트";
+"byte_unit_gigabyte" = "기가바이트";
+"byte_unit_gigabytes" = "기가바이트";
diff --git a/Sources/CodexBar/Resources/nl.lproj/Localizable.strings b/Sources/CodexBar/Resources/nl.lproj/Localizable.strings
new file mode 100644
index 0000000000..d811b403b3
--- /dev/null
+++ b/Sources/CodexBar/Resources/nl.lproj/Localizable.strings
@@ -0,0 +1,1105 @@
+/* Dutch localization for CodexBar */
+
+" providers" = " providers";
+"(System)" = "(Systeem)";
+"30d" = "30d";
+"A managed Codex login is already running. Wait for it to finish before adding " = "Er is al een beheerde Codex-aanmelding actief. Wacht tot het klaar is voordat je het toevoegt";
+"API key" = "API-sleutel";
+"API region" = "API-regio";
+"API token" = "API-token";
+"API tokens" = "API-tokens";
+"About" = "Over";
+"Account" = "Account";
+"Accounts" = "Accounts";
+"Accounts subtitle" = "Accounts";
+"Active" = "Actief";
+"Add" = "Toevoegen";
+"Add Workspace" = "Werkruimte toevoegen";
+"Advanced" = "Geavanceerd";
+"All" = "Alle";
+"Always allow prompts" = "Sta altijd aanwijzingen toe";
+"Animation pattern" = "Animatie patroon";
+"Antigravity login is managed in the app" = "Antigravity-login wordt beheerd in de app";
+"Applies only to the Security.framework OAuth keychain reader." = "Geldt alleen voor de Security.framework OAuth-sleutelhangerlezer.";
+"Auto falls back to the next source if the preferred one fails." = "Auto valt terug naar de volgende bron als de voorkeursbron uitvalt.";
+"Auto uses API first, then falls back to CLI on auth failures." = "Auto gebruikt eerst de API en valt vervolgens terug op CLI bij auth-mislukkingen.";
+"Auto-detect" = "Automatische detectie";
+"Auto-refresh is off; use the menu's Refresh command." = "Automatisch vernieuwen is uitgeschakeld; gebruik de opdracht Vernieuwen van het menu.";
+"Auto-refresh: hourly · Timeout: 10m" = "Automatisch vernieuwen: elk uur · Time-out: 10m";
+"Automatic" = "Automatisch";
+"Automatic imports browser cookies and WorkOS tokens." = "Importeert automatisch browsercookies en WorkOS-tokens.";
+"Automatic imports browser cookies and local storage tokens." = "Importeert automatisch browsercookies en lokale opslagtokens.";
+"Automatic imports browser cookies for dashboard extras." = "Importeert automatisch browsercookies voor dashboardextra's.";
+"Automatic imports browser cookies for the web API." = "Importeert automatisch browsercookies voor de web-API.";
+"Automatic imports browser cookies from Model Studio/Bailian." = "Importeert automatisch browsercookies van Model Studio/Bailian.";
+"Automatic imports browser cookies from admin.mistral.ai." = "Importeert automatisch browsercookies van admin.mistral.ai.";
+"Automatic imports browser cookies from opencode.ai." = "Importeert automatisch browsercookies van opencode.ai.";
+"Automatic imports browser cookies or stored sessions." = "Importeert automatisch browsercookies of opgeslagen sessies.";
+"Automatic imports browser cookies." = "Automatische import van browsercookies.";
+"Automatically imports browser session cookie." = "Importeert automatisch een browsersessiecookie.";
+"Automatically opens CodexBar when you start your Mac." = "Opent automatisch CodexBar wanneer u uw Mac start.";
+"Automation" = "Automatisering";
+"Average (\\(label1) + \\(label2))" = "Gemiddeld (\\(label1) + \\(label2))";
+"Average (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))" = "Gemiddeld (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))";
+"Avoid Keychain prompts" = "Vermijd sleutelhangerprompts";
+"Balance" = "Saldo";
+"Battery Saver" = "Batterijbesparing";
+"Bordered" = "Omzoomd";
+"Build" = "Bouwen";
+"Built \\(buildTimestamp)" = "Gebouwd \\(buildTimestamp)";
+"Buy Credits..." = "Koop tegoeden...";
+"Buy Credits…" = "Koop tegoeden…";
+"CLI paths" = "CLI-paden";
+"CLI sessions" = "CLI-sessies";
+"Caches" = "Caches";
+"Cancel" = "Annuleren";
+"Check for Updates…" = "Controleer op updates…";
+"Check for updates automatically" = "Automatisch controleren op updates";
+"Check if you like your agents having some fun up there." = "Controleer of je het leuk vindt dat je agenten daar plezier hebben.";
+"Check provider status" = "Controleer de status van de provider";
+"Choose Codex workspace" = "Kies Codex-werkruimte";
+"Choose the MiniMax host (global .io or China mainland .com)." = "Kies de MiniMax-host (global .io of China vasteland .com).";
+"Choose up to " = "Kies tot";
+"Choose up to \\(Self.maxOverviewProviders) providers" = "Kies maximaal \\(Self.maxOverviewProviders) providers";
+"Choose up to \\(count) providers" = "Kies maximaal \\(count) providers";
+"Choose what to show in the menu bar (Pace shows usage vs. expected)." = "Kies wat u wilt weergeven in de menubalk (Tempo toont gebruik vs. verwacht).";
+"Choose which Codex account CodexBar should follow." = "Kies welk Codex-account CodexBar moet volgen.";
+"Choose which window drives the menu bar percent." = "Kies welk venster het menubalkpercentage aanstuurt.";
+"Chrome" = "Chrome";
+"Claude CLI not found" = "Claude CLI niet gevonden";
+"Claude binary" = "Claude binair";
+"Claude cookies" = "Claude-koekjes";
+"Claude login failed" = "Inloggen bij Claude is mislukt";
+"Claude login timed out" = "Er is een time-out opgetreden bij het inloggen bij Claude";
+"Close" = "Sluiten";
+"Code review" = "Code review";
+"Codex CLI not found" = "Codex-CLI niet gevonden";
+"Codex account login already running" = "Inloggen op Codex-account is al actief";
+"Codex binary" = "Codex binair";
+"Codex login failed" = "Codex-aanmelding mislukt";
+"Codex login timed out" = "Er is een time-out opgetreden bij het inloggen op de Codex";
+"CodexBar Lifecycle Keepalive" = "CodexBar-levenscyclus Keepalive";
+"CodexBar can't show its menu bar icon" = "CodexBar kan het menubalkpictogram niet weergeven";
+"CodexBar could not read managed account storage. " = "CodexBar kan de beheerde accountopslag niet lezen.";
+"Configure…" = "Configureer…";
+"Connected" = "Aangesloten";
+"Controls how much detail is logged." = "Bepaalt hoeveel details worden geregistreerd.";
+"Cookie header" = "Cookie-header";
+"Cookie source" = "Cookie-bron";
+"Cookie: ..." = "Koekje: ...";
+"Cookie: \\u{2026}\\\n\\\nor paste a cURL capture from the Abacus AI dashboard" = "Cookie: \\u{2026}\\\n\\\nof plak een cURL-opname vanuit het Abacus AI-dashboard";
+"Cookie: \\u{2026}\\\n\\\nor paste the __Secure-next-auth.session-token value" = "Cookie: \\u{2026}\\\n\\\nof plak de __Secure-next-auth.session-token-waarde";
+"Cookie: \\u{2026}\\\n\\\nor paste the kimi-auth token value" = "Cookie: \\u{2026}\\\n\\\nof plak de kimi-auth tokenwaarde";
+"Cookie: …" = "Cookie: …";
+"CopilotDeviceFlow" = "CopilotDeviceFlow";
+"Cost" = "Kosten";
+"Could not add Codex account" = "Kan Codex-account niet toevoegen";
+"Could not open Terminal for Gemini" = "Kan Terminal voor Gemini niet openen";
+"Could not start claude /login" = "Kan claude /login niet starten";
+"Could not start codex login" = "Kan codex-aanmelding niet starten";
+"Could not switch system account" = "Kan van systeemaccount niet wisselen";
+"Credits" = "Kredieten";
+"Individual credits" = "Individuele kredieten";
+"Workspace" = "Werkruimte";
+"Credits history" = "Creditgeschiedenis";
+"Cursor login failed" = "Cursoraanmelding mislukt";
+"Custom" = "Aangepast";
+"Custom Path" = "Aangepast pad";
+"Daily Routines" = "Dagelijkse routines";
+"Debug" = "Foutopsporing";
+"Default" = "Standaard";
+"Disable Keychain access" = "Schakel sleutelhangertoegang uit";
+"Disabled" = "Uitgeschakeld";
+"Dismiss" = "Afwijzen";
+"Disconnected" = "Verbinding verbroken";
+"Display" = "Weergave";
+"Display mode" = "Weergavemodus";
+"Display reset times as absolute clock values instead of countdowns." = "Geef resettijden weer als absolute klokwaarden in plaats van aftellingen.";
+"Done" = "Klaar";
+"Effective PATH" = "Effectief PAD";
+"Email" = "E-mail";
+"Enable Merge Icons to configure Overview tab providers." = "Schakel Pictogrammen samenvoegen in om de providers van tabbladen Overzicht te configureren.";
+"Enable file logging" = "Bestandsregistratie inschakelen";
+"Enabled" = "Ingeschakeld";
+"Error" = "Fout";
+"Error simulation" = "Foutsimulatie";
+"Expose troubleshooting tools in the Debug tab." = "Geef hulpprogramma's voor probleemoplossing weer op het tabblad Foutopsporing.";
+"Failed" = "Mislukt";
+"False" = "Onwaar";
+"Fetch strategy attempts" = "Strategiepogingen ophalen";
+"Fetching" = "Ophalen";
+"Field" = "Veld";
+"Field subtitle" = "Ondertitel van veld";
+"Finish the current managed account change before switching the system account." = "Voltooi de huidige beheerde accountwijziging voordat u van systeemaccount wisselt.";
+"Force animation on next refresh" = "Animatie forceren bij volgende vernieuwing";
+"Gateway region" = "Gateway-regio";
+"Gemini CLI not found" = "Gemini-CLI niet gevonden";
+"Gemini/Antigravity, surfacing incidents in the icon and menu." = "Gemini/Antigravity, incidenten verschijnen in het pictogram en het menu.";
+"General" = "Algemeen";
+"GitHub" = "GitHub";
+"GitHub Copilot Login" = "GitHub Copilot-aanmelding";
+"GitHub Login" = "GitHub-aanmelding";
+"Hide details" = "Details verbergen";
+"Hide personal information" = "Verberg persoonlijke informatie";
+"Historical tracking" = "Historische tracking";
+"How often CodexBar polls providers in the background." = "Hoe vaak CodexBar providers op de achtergrond ondervraagt.";
+"Inactive" = "Inactief";
+"Install CLI" = "Installeer CLI";
+"Install the Claude CLI (npm i -g @anthropic-ai/claude-code) and try again." = "Installeer de Claude CLI (npm i -g @anthropic-ai/claude-code) en probeer het opnieuw.";
+"Install the Codex CLI (npm i -g @openai/codex) and try again." = "Installeer de Codex CLI (npm i -g @openai/codex) en probeer het opnieuw.";
+"Install the Gemini CLI (npm i -g @google/gemini-cli) and try again." = "Installeer de Gemini CLI (npm i -g @google/gemini-cli) en probeer het opnieuw.";
+"JetBrains AI is ready" = "JetBrains AI is klaar";
+"JetBrains IDE" = "JetBrains IDE";
+"Keep CLI sessions alive" = "Houd CLI-sessies levend";
+"Keyboard shortcut" = "Sneltoets";
+"Keychain access" = "Toegang via sleutelhanger";
+"Keychain prompt policy" = "Sleutelhangerpromptbeleid";
+"Last \\(name) fetch failed:" = "Laatste \\(name) ophalen mislukt:";
+"Last \\(self.store.metadata(for: self.provider).displayName) fetch failed:" = "Laatste ophalen van \\(self.store.metadata(for: self.provider).displayName) mislukt:";
+"Last attempt" = "Laatste poging";
+"Link" = "Link";
+"Loading animations" = "Animaties laden";
+"Loading…" = "Laden…";
+"Local" = "Lokaal";
+"Logging" = "Loggen";
+"Login failed" = "Inloggen mislukt";
+"Login shell PATH (startup capture)" = "Login shell PATH (opstartopname)";
+"Login timed out" = "Er is een time-out opgetreden voor het inloggen";
+"MCP details" = "MCP-details";
+"Managed Codex accounts unavailable" = "Beheerde Codex-accounts zijn niet beschikbaar";
+"Managed account storage is unreadable. Live account access is still available, " = "Beheerde accountopslag is onleesbaar. Live accounttoegang is nog steeds beschikbaar,";
+"Manual" = "Handmatig";
+"May your tokens never run out—keep agent limits in view." = "Moge uw tokens nooit opraken: houd de limieten van agenten in het oog.";
+"Menu bar" = "Menubalk";
+"Menu bar auto-shows the provider closest to its rate limit." = "De menubalk toont automatisch de aanbieder die het dichtst bij de tarieflimiet zit.";
+"Menu bar metric" = "Menubalkstatistiek";
+"Menu bar shows percent" = "Menubalk toont percentage";
+"Menu content" = "Menu-inhoud";
+"Merge Icons" = "Pictogrammen samenvoegen";
+"Never prompt" = "Nooit vragen";
+"No" = "Nee";
+"No Codex accounts detected yet." = "Er zijn nog geen Codex-accounts gedetecteerd.";
+"No JetBrains IDE detected" = "Geen JetBrains IDE gedetecteerd";
+"No cost history data." = "Geen kostengeschiedenisgegevens.";
+"No data available" = "Geen gegevens beschikbaar";
+"No data yet" = "Nog geen gegevens";
+"No enabled providers available for Overview." = "Er zijn geen ingeschakelde providers beschikbaar voor Overzicht.";
+"No providers selected" = "Geen aanbieders geselecteerd";
+"No token accounts yet." = "Nog geen tokenaccounts.";
+"No usage breakdown data." = "Geen gebruiksgegevens.";
+"None" = "Geen";
+"Notifications" = "Meldingen";
+"Notifies when the 5-hour session quota hits 0% and when it becomes " = "Geeft een melding wanneer het sessiequotum van 5 uur 0% bereikt en wanneer dit wordt bereikt";
+"OK" = "OK";
+"Obscure email addresses in the menu bar and menu UI." = "Onduidelijke e-mailadressen in de menubalk en menu-UI.";
+"Off" = "Uit";
+"Offline" = "Offline";
+"On" = "Op";
+"Online" = "Online";
+"Only on user action" = "Alleen bij gebruikersactie";
+"Open" = "Open";
+"Open API Keys" = "Open API-sleutels";
+"Open Amp Settings" = "Open Versterkerinstellingen";
+"Open Antigravity to sign in, then refresh CodexBar." = "Open Antigravity om in te loggen en vernieuw vervolgens CodexBar.";
+"Open Browser" = "Browser openen";
+"Open Coding Plan" = "Coderingsplan openen";
+"Open Console" = "Console openen";
+"Open Dashboard" = "Dashboard openen";
+"Open Mistral Admin" = "Open Mistral-beheer";
+"Open Menu Bar Settings" = "Open Menubalkinstellingen";
+"Open Ollama Settings" = "Open Ollama-instellingen";
+"Open Terminal" = "Terminal openen";
+"Open Usage Page" = "Gebruikspagina openen";
+"Open Warp API Key Guide" = "Open Warp API-sleutelgids";
+"Open menu" = "Menu openen";
+"Open token file" = "Tokenbestand openen";
+"OpenAI cookies" = "OpenAI-cookies";
+"OpenAI web extras" = "OpenAI-webextra's";
+"Option A" = "Optie A";
+"Option B" = "Optie B";
+"Optional override if workspace lookup fails." = "Optioneel overschrijven als het opzoeken van de werkruimte mislukt.";
+"Options" = "Opties";
+"Override auto-detection with a custom IDE base path" = "Overschrijf automatische detectie met een aangepast IDE-basispad";
+"Overview" = "Overzicht";
+"Overview rows always follow provider order." = "Overzichtsrijen volgen altijd de volgorde van de provider.";
+"Overview tab providers" = "Overzicht tabblad aanbieders";
+"Paste API key…" = "API-sleutel plakken…";
+"Paste API token…" = "API-token plakken…";
+"Paste key…" = "Sleutel plakken…";
+"Paste sessionKey or OAuth token…" = "SessionKey of OAuth-token plakken...";
+"Paste the Cookie header from a request to admin.mistral.ai. " = "Plak de Cookie-header uit een verzoek naar admin.mistral.ai.";
+"Paste token…" = "Token plakken...";
+"Personal" = "Persoonlijk";
+"Picker" = "Kikker";
+"Picker subtitle" = "Ondertitel kiezen";
+"Placeholder" = "Tijdelijke aanduiding";
+"Plan" = "Plan";
+"Play full-screen confetti when weekly usage resets." = "Speel confetti op volledig scherm af wanneer het wekelijkse gebruik wordt gereset.";
+"Polls OpenAI/Claude status pages and Google Workspace for " = "Polls OpenAI/Claude-statuspagina's en Google Workspace voor";
+"Prevents any Keychain access while enabled." = "Voorkomt elke sleutelhangertoegang indien ingeschakeld.";
+"Primary (API key limit)" = "Primair (API-sleutellimiet)";
+"Primary (\\(label))" = "Primair (\\(label))";
+"Primary (\\(metadata.sessionLabel))" = "Primair (\\(metadata.sessionLabel))";
+"Probe logs" = "Sondelogboeken";
+"Progress bars fill as you consume quota (instead of showing remaining)." = "Voortgangsbalken worden gevuld naarmate u uw quotum verbruikt (in plaats van de resterende hoeveelheid weer te geven).";
+"Provider" = "Aanbieder";
+"Providers" = "Providers";
+"Quit CodexBar" = "Sluit CodexBar af";
+"Random (default)" = "Willekeurig (standaard)";
+"Reads local usage logs. Shows today + last 30 days cost in the menu." = "Leest lokale gebruikslogboeken. Toont vandaag + het geselecteerde geschiedenisvenster in het menu.";
+"Refresh" = "Vernieuwen";
+"Refresh cadence" = "Cadans vernieuwen";
+"Remote" = "Op afstand";
+"Remove" = "Verwijderen";
+"Remove Codex account?" = "Codex-account verwijderen?";
+"Remove \\(account.email) from CodexBar? Its managed Codex home will be deleted." = "\\(account.email) verwijderen uit CodexBar? Het beheerde Codex-huis wordt verwijderd.";
+"Remove \\(email) from CodexBar? Its managed Codex home will be deleted." = "\\(email) verwijderen uit CodexBar? Het beheerde Codex-huis wordt verwijderd.";
+"Remove selected account" = "Geselecteerd account verwijderen";
+"Replace critter bars with provider branding icons and a percentage." = "Vervang critterbalken door brandingpictogrammen van de provider en een percentage.";
+"Replay selected animation" = "Speel de geselecteerde animatie opnieuw af";
+"Requires authentication via GitHub Device Flow." = "Vereist authenticatie via GitHub Device Flow.";
+"Resets: \\(reset)" = "Resetten: \\(reset)";
+"Rolling five-hour limit" = "Doorlopende limiet van vijf uur";
+"Search hourly" = "Zoek per uur";
+"Secondary (\\(label))" = "Secundair (\\(label))";
+"Secondary (\\(metadata.weeklyLabel))" = "Secundair (\\(metadata.weeklyLabel))";
+"Select a provider" = "Selecteer een aanbieder";
+"Select the IDE to monitor" = "Selecteer de IDE die u wilt monitoren";
+"Session quota notifications" = "Meldingen over sessiequota";
+"Session tokens" = "Sessietokens";
+"Settings" = "Instellingen";
+"Show Codex Credits and Claude Extra usage sections in the menu." = "Toon Codex Credits en Claude Extra gebruikssecties in het menu.";
+"Show Debug Settings" = "Toon foutopsporingsinstellingen";
+"Show all token accounts" = "Toon alle tokenaccounts";
+"Show cost summary" = "Kostenoverzicht weergeven";
+"Show credits + extra usage" = "Toon credits + extra gebruik";
+"Show details" = "Details weergeven";
+"Show most-used provider" = "Toon meest gebruikte provider";
+"Show provider icons in the switcher (otherwise show a weekly progress line)." = "Toon providerpictogrammen in de switcher (toon anders een wekelijkse voortgangslijn).";
+"Show reset time as clock" = "Toon resettijd als klok";
+"Show usage as used" = "Toon gebruik zoals gebruikt";
+"Sign in via button below" = "Meld u aan via onderstaande knop";
+"Skip teardown between probes (debug-only)." = "Sla demontage tussen tests over (alleen voor foutopsporing).";
+"Stack token accounts in the menu (otherwise show an account switcher bar)." = "Stapel token-accounts in het menu (laat anders een accountwisselbalk zien).";
+"Start at Login" = "Begin bij Inloggen";
+"Status" = "Status";
+"Store Claude sessionKey cookies or OAuth access tokens." = "Bewaar Claude sessionKey-cookies of OAuth-toegangstokens.";
+"Store multiple Abacus AI Cookie headers." = "Bewaar meerdere Abacus AI Cookie-headers.";
+"Store multiple Augment Cookie headers." = "Bewaar meerdere Augment Cookie-headers.";
+"Store multiple Cursor Cookie headers." = "Bewaar meerdere Cursor Cookie-headers.";
+"Store multiple Factory Cookie headers." = "Bewaar meerdere Factory Cookie-headers.";
+"Store multiple MiniMax Cookie headers." = "Bewaar meerdere MiniMax Cookie-headers.";
+"Store multiple Mistral Cookie headers." = "Bewaar meerdere Mistral Cookie-headers.";
+"Store multiple Ollama Cookie headers." = "Bewaar meerdere Ollama Cookie-headers.";
+"Store multiple OpenCode Cookie headers." = "Bewaar meerdere OpenCode Cookie-headers.";
+"Store multiple OpenCode Go Cookie headers." = "Bewaar meerdere OpenCode Go Cookie-headers.";
+"Stored in the CodexBar config file." = "Opgeslagen in het CodexBar-configuratiebestand.";
+"Stored in ~/.codexbar/config.json. " = "Opgeslagen in ~/.codexbar/config.json.";
+"Stored in ~/.codexbar/config.json. Generate one at kimi-k2.ai." = "Opgeslagen in ~/.codexbar/config.json. Genereer er een op kimi-k2.ai.";
+"Stored in ~/.codexbar/config.json. Paste the key from the Synthetic dashboard." = "Opgeslagen in ~/.codexbar/config.json. Plak de sleutel uit het synthetische dashboard.";
+"Stored in ~/.codexbar/config.json. Paste your Coding Plan API key from Model Studio." = "Opgeslagen in ~/.codexbar/config.json. Plak de API-sleutel van uw codeerplan uit Model Studio.";
+"Stored in ~/.codexbar/config.json. Paste your MiniMax API key." = "Opgeslagen in ~/.codexbar/config.json. Plak uw MiniMax API-sleutel.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or " = "Opgeslagen in ~/.codexbar/config.json. U kunt ook KILO_API_KEY of";
+"Stores local Codex usage history (8 weeks) to personalize Pace predictions." = "Slaat de lokale Codex-gebruiksgeschiedenis op (8 weken) om tempo-voorspellingen te personaliseren.";
+"Subscription Utilization" = "Abonnementsgebruik";
+"Surprise me" = "Verras mij";
+"Switcher shows icons" = "Switcher toont pictogrammen";
+"Symlink CodexBarCLI to /usr/local/bin and /opt/homebrew/bin as codexbar." = "Symlink CodexBarCLI naar /usr/local/bin en /opt/homebrew/bin als codexbar.";
+"System" = "Systeem";
+"Temporarily shows the loading animation after the next refresh." = "Toont tijdelijk de laadanimatie na de volgende vernieuwing.";
+"Tertiary (\\(label))" = "Tertiair (\\(label))";
+"Tertiary (\\(tertiaryTitle))" = "Tertiair (\\(tertiaryTitle))";
+"The default Codex account on this Mac." = "Het standaard Codex-account op deze Mac.";
+"Toggle" = "Schakelaar";
+"Toggle subtitle" = "Schakel ondertiteling in";
+"Token" = "Token";
+"Trigger the menu bar menu from anywhere." = "Activeer het menubalkmenu vanaf elke locatie.";
+"True" = "WAAR";
+"Twitter" = "Twitteren";
+"Unsupported" = "Niet ondersteund";
+"Update Channel" = "Kanaal bijwerken";
+"Updated" = "Bijgewerkt";
+"Updates unavailable in this build." = "Updates zijn niet beschikbaar in deze build.";
+"Usage" = "Gebruik";
+"Usage breakdown" = "Uitsplitsing van gebruik";
+"Usage history (30 days)" = "Gebruiksgeschiedenis";
+"Usage source" = "Gebruiksbron";
+"Use BigModel for the China mainland endpoints (open.bigmodel.cn)." = "Gebruik BigModel voor de eindpunten op het vasteland van China (open.bigmodel.cn).";
+"Use a single menu bar icon with a provider switcher." = "Gebruik één menubalkpictogram met een providerwisselaar.";
+"Use international or China mainland console gateways for quota fetches." = "Gebruik internationale of Chinese consolegateways voor het ophalen van quota.";
+"Version" = "Versie";
+"Version \\(self.versionString)" = "Versie \\(self.versionString)";
+"Version \\(version)" = "Versie \\(version)";
+"Version \\(versionString)" = "Versie \\(versionString)";
+"Vertex AI Login" = "Vertex AI-login";
+"Wait for the current managed Codex login to finish before adding another account." = "Wacht tot de huidige beheerde Codex-aanmelding is voltooid voordat u een ander account toevoegt.";
+"Waiting for Authentication..." = "Wachten op authenticatie...";
+"Website" = "Website";
+"Weekly limit confetti" = "Wekelijkse limiet confetti";
+"Weekly token limit" = "Wekelijkse tokenlimiet";
+"Weekly usage" = "Wekelijks gebruik";
+"Weekly usage unavailable for this account." = "Wekelijks gebruik is niet beschikbaar voor dit account.";
+"Window: \\(window)" = "Venster: \\(window)";
+"Write logs to \\(self.fileLogPath) for debugging." = "Schrijf logboeken naar \\(self.fileLogPath) voor foutopsporing.";
+"Yes" = "Ja";
+"\\(detail.modelCode): \\(usage)" = "\\(detail.modelCode): \\(usage)";
+"\\(name): \\(truncated)" = "\\(name): \\(truncated)";
+"\\(name): \\(updated) · 30d \\(cost)" = "\\(name): \\(updated) · 30d \\(cost)";
+"\\(name): fetching…\\(elapsed)" = "\\(name): ophalen…\\(elapsed)";
+"\\(name): last attempt \\(when)" = "\\(name): laatste poging \\(when)";
+"\\(name): no data yet" = "\\(name): nog geen gegevens";
+"\\(name): unsupported" = "\\(name): niet ondersteund";
+"all browsers" = "alle browsers";
+"available again." = "weer beschikbaar.";
+"built_format" = "Gebouwd %@";
+"copilot_complete_in_browser" = "Voltooi het inloggen in uw browser.";
+"copilot_device_code" = "Apparaatcode gekopieerd naar klembord: %1$@\n\nVerifiëren op: %2$@";
+"copilot_device_code_copied" = "Apparaatcode gekopieerd.";
+"copilot_verify_at" = "Verifiëren op %@";
+"copilot_waiting_text" = "Voltooi het inloggen in uw browser.\nDit venster wordt automatisch gesloten wanneer het inloggen is voltooid.";
+"copilot_window_closes_auto" = "Dit venster wordt automatisch gesloten wanneer het inloggen is voltooid.";
+"cost_status_error" = "%1$@: %2$@";
+"cost_status_fetching" = "%1$@: ophalen… %2$@";
+"cost_status_last_attempt" = "%1$@: laatste poging %2$@";
+"cost_status_no_data" = "%@: nog geen gegevens";
+"cost_status_snapshot" = "%1$@: %2$@ · %3$@ %4$@";
+"cost_status_unsupported" = "%@: niet ondersteund";
+"credits_remaining" = "Tegoeden: %@";
+"cursor_on_demand" = "Op aanvraag: %@";
+"cursor_on_demand_with_limit" = "Op aanvraag: %1$@ / %2$@";
+"extra_usage_format" = "Extra verbruik: %1$@ / %2$@";
+"jetbrains_detected_generate" = "Gedetecteerd: %@. Gebruik de AI-assistent één keer om quotagegevens te genereren en vernieuw vervolgens CodexBar.";
+"jetbrains_detected_select" = "Gedetecteerd: %@. Selecteer uw favoriete IDE in Instellingen en vernieuw vervolgens CodexBar.";
+"last_fetch_failed_with_provider" = "Laatste %@ ophaalactie mislukt:";
+"last_spend" = "Laatste uitgave: %@";
+"mcp_model_usage" = "%1$@: %2$@";
+"mcp_resets" = "Resetten: %@";
+"mcp_window" = "Venster: %@";
+"metric_average" = "Gemiddeld (%1$@ + %2$@)";
+"metric_primary" = "Primair (%@)";
+"metric_secondary" = "Secundair (%@)";
+"metric_tertiary" = "Tertiair (%@)";
+"multiple_workspaces_found" = "CodexBar heeft meerdere werkruimten gevonden voor %@. Kies de werkruimte die u wilt toevoegen.";
+"ory_session_…=…; csrftoken=…" = "ory_sessie_…=…; csrftoken=…";
+"overview_choose_providers" = "Kies maximaal %@ providers";
+"remove_account_message" = "%@ verwijderen uit CodexBar? Het beheerde Codex-huis wordt verwijderd.";
+"version_format" = "Versie %@";
+"vertex_ai_login_instructions" = "Om het gebruik van Vertex AI bij te houden, authenticeert u zich met Google Cloud.\n\n1. Open Terminal\n2. Uitvoeren: gcloud auth applicatie-standaard login\n3. Volg de browserprompts om in te loggen\n4. Stel uw project in: gcloud config set project PROJECT_ID\n\nTerminal nu openen?";
+"workspaceID is set but only opencode, opencodego, and deepgram support workspaceID." = "workspaceID is ingesteld, maar alleen opencode, opencodego en deepgram ondersteunen workspaceID.";
+"© 2026 Peter Steinberger. MIT License." = "© 2026 Peter Steinberger. MIT-licentie.";
+
+/* General Pane */
+"section_system" = "Systeem";
+"section_usage" = "Gebruik";
+"section_automation" = "Automatisering";
+"language_title" = "Taal";
+"language_subtitle" = "Wijzig de weergavetaal. Vereist een herstart van de app om volledig effect te krijgen.";
+"language_system" = "Systeem";
+"language_english" = "Engels";
+"language_spanish" = "Spaans";
+"language_catalan" = "Català";
+"language_chinese_simplified" = "简体中文";
+"language_chinese_traditional" = "繁體中文";
+"language_portuguese_brazilian" = "Portugees (Brazilië)";
+"language_dutch" = "Nederlands";
+"language_german" = "Duits";
+"language_french" = "Frans";
+"language_ukrainian" = "Oekraïens";
+"language_japanese" = "Japans";
+"language_korean" = "Koreaans";
+"language_italian" = "Italiano";
+"language_swedish" = "Zweeds";
+"language_vietnamese" = "Vietnamees";
+"language_turkish" = "Türkçe";
+"language_indonesian" = "Indonesisch";
+"language_polish" = "Pools";
+"start_at_login_title" = "Begin bij Inloggen";
+"start_at_login_subtitle" = "Opent automatisch CodexBar wanneer u uw Mac start.";
+"show_cost_summary" = "Kostenoverzicht weergeven";
+"show_cost_summary_subtitle" = "Leest lokale gebruikslogboeken. Toont vandaag + het geselecteerde geschiedenisvenster in het menu.";
+"cost_history_days_title" = "Geschiedenisvenster: %d dagen";
+"cost_auto_refresh_info" = "Automatisch vernieuwen: elk uur · Time-out: 10m";
+"refresh_cadence_title" = "Cadans vernieuwen";
+"refresh_cadence_subtitle" = "Hoe vaak CodexBar providers op de achtergrond ondervraagt.";
+"manual_refresh_hint" = "Automatisch vernieuwen is uitgeschakeld; gebruik de opdracht Vernieuwen van het menu.";
+"check_provider_status_title" = "Controleer de status van de provider";
+"check_provider_status_subtitle" = "Polls van OpenAI/Claude-statuspagina's en Google Workspace voor Gemini/Antigravity, waarbij incidenten in het pictogram en het menu worden weergegeven.";
+"session_quota_notifications_title" = "Meldingen over sessiequota";
+"session_quota_notifications_subtitle" = "Geeft een melding wanneer het sessiequotum van 5 uur 0% bereikt en wanneer het weer beschikbaar komt.";
+"quota_warning_notifications_title" = "Quotumwaarschuwingsmeldingen";
+"quota_warning_notifications_subtitle" = "Waarschuwt wanneer het resterende sessie- of wekelijkse quotum de geconfigureerde drempels overschrijdt.";
+"quota_warnings_title" = "Quotumwaarschuwingen";
+"quota_warning_session" = "sessie";
+"quota_warning_session_capitalized" = "Sessie";
+"quota_warning_weekly" = "wekelijks";
+"quota_warning_weekly_capitalized" = "Wekelijks";
+"quota_warning_notification_title" = "%1$@ %2$@ quotum laag";
+"quota_warning_notification_body" = "%1$@ over. Je waarschuwingsdrempel van %2$d%% %3$@ is bereikt.";
+"quota_warning_notification_body_with_account" = "Rekening %1$@. %2$@ over. Je waarschuwingsdrempel van %3$d%% %4$@ is bereikt.";
+"session_depleted_notification_title" = "%@ sessie uitgeput";
+"session_depleted_notification_body" = "0% over. Zal op de hoogte stellen wanneer het weer beschikbaar is.";
+"session_restored_notification_title" = "%@ sessie hersteld";
+"session_restored_notification_body" = "Sessiequota zijn weer beschikbaar.";
+"quota_warning_warn_at" = "Waarschuw bij";
+"quota_warning_global_threshold_subtitle" = "Resterende percentages voor sessie- en wekelijkse vensters, tenzij een provider deze overschrijft.";
+"quota_warning_sound" = "Meldingsgeluid afspelen";
+"quota_warning_provider_inherits" = "Gebruikt de algemene instellingen voor quotawaarschuwingen, tenzij hier een venster wordt aangepast.";
+"quota_warning_customize_thresholds" = "Pas %@ drempels aan";
+"quota_warning_enable_warnings" = "Schakel %@ waarschuwingen in";
+"quota_warning_window_warn_at" = "%@ waarschuwen om";
+"quota_warning_off" = "Uit";
+"quota_warning_inherited" = "Geërfd: %@";
+"quota_warning_depleted_only" = "alleen maar uitgeput";
+"quota_warning_upper" = "Bovenste";
+"quota_warning_lower" = "Lager";
+"apply" = "Toepassen";
+"quit_app" = "Sluit CodexBar af";
+
+/* Tab titles */
+"tab_general" = "Algemeen";
+"tab_providers" = "Aanbieders";
+"tab_display" = "Weergave";
+"tab_advanced" = "Geavanceerd";
+"tab_about" = "Over";
+"tab_debug" = "Foutopsporing";
+
+/* Providers Pane */
+"select_a_provider" = "Selecteer een aanbieder";
+"cancel" = "Annuleren";
+"last_fetch_failed" = "laatste ophaalactie mislukt";
+"usage_not_fetched_yet" = "gebruik nog niet opgehaald";
+"managed_account_storage_unreadable" = "Beheerde accountopslag is onleesbaar. Live accounttoegang is nog steeds beschikbaar, maar beheerde acties voor toevoegen, opnieuw verifiëren en verwijderen zijn uitgeschakeld totdat de winkel kan worden hersteld.";
+"remove_codex_account_title" = "Codex-account verwijderen?";
+"remove" = "Verwijderen";
+"managed_login_already_running" = "Er is al een beheerde Codex-aanmelding actief. Wacht tot het klaar is voordat u een ander account toevoegt of opnieuw verifieert.";
+"managed_login_failed" = "Beheerde Codex-aanmelding is niet voltooid. Controleer of `codex --version` werkt in Terminal. Als macOS `codex` naar de prullenbak heeft geblokkeerd of verplaatst, verwijdert u verouderde dubbele installaties, voert u `npm install -g --include=optioneel @openai/codex@latest` uit en probeert u het vervolgens opnieuw.";
+"codex_login_output" = "codex login-uitvoer:";
+"managed_login_missing_email" = "Codex-aanmelding voltooid, maar er was geen account-e-mailadres beschikbaar. Probeer het opnieuw nadat u heeft bevestigd dat het account volledig is aangemeld.";
+"login_success_notification_title" = "%@ inloggen succesvol";
+"login_success_notification_body" = "U kunt terugkeren naar de app; authenticatie voltooid.";
+"workspace_selection_cancelled" = "CodexBar heeft meerdere werkruimten gevonden, maar er is geen werkruimte geselecteerd.";
+"unsafe_managed_home" = "CodexBar weigerde een onverwacht beheerd thuispad te wijzigen: %@";
+"menu_bar_metric_title" = "Menubalkstatistiek";
+"menu_bar_metric_subtitle" = "Kies welk venster het menubalkpercentage aanstuurt.";
+"menu_bar_metric_subtitle_deepseek" = "Toont het DeepSeek-saldo in de menubalk.";
+"menu_bar_metric_subtitle_moonshot" = "Toont het Moonshot / Kimi API-saldo in de menubalk.";
+"menu_bar_metric_subtitle_mistral" = "Toont de Mistral API-uitgaven van de huidige maand in de menubalk.";
+"menu_bar_metric_subtitle_kimik2" = "Toont Kimi K2 API-sleutelcredits in de menubalk.";
+"automatic" = "Automatisch";
+"primary_api_key_limit" = "Primair (API-sleutellimiet)";
+
+/* Display Pane */
+"section_menu_bar" = "Menubalk";
+"merge_icons_title" = "Pictogrammen samenvoegen";
+"merge_icons_subtitle" = "Gebruik één menubalkpictogram met een providerwisselaar.";
+"switcher_shows_icons_title" = "Switcher toont pictogrammen";
+"switcher_shows_icons_subtitle" = "Toon providerpictogrammen in de switcher (toon anders een wekelijkse voortgangslijn).";
+"show_most_used_provider_title" = "Toon meest gebruikte provider";
+"show_most_used_provider_subtitle" = "De menubalk toont automatisch de aanbieder die het dichtst bij de tarieflimiet zit.";
+"menu_bar_shows_percent_title" = "Menubalk toont percentage";
+"menu_bar_shows_percent_subtitle" = "Vervang critterbalken door brandingpictogrammen van de provider en een percentage.";
+"hide_critters_title" = "Critters verbergen";
+"hide_critters_subtitle" = "Toon eenvoudige meterbalken zonder gezicht en versieringen.";
+"display_mode_title" = "Weergavemodus";
+"display_mode_subtitle" = "Kies wat u wilt weergeven in de menubalk (Tempo toont gebruik vs. verwacht).";
+"section_menu_content" = "Menu-inhoud";
+"show_usage_as_used_title" = "Toon gebruik zoals gebruikt";
+"show_usage_as_used_subtitle" = "Voortgangsbalken worden gevuld naarmate u uw quotum verbruikt (in plaats van de resterende hoeveelheid weer te geven).";
+"show_quota_warning_markers_title" = "Toon waarschuwingsmarkeringen voor quota";
+"show_quota_warning_markers_subtitle" = "Teken drempelmarkeringen op gebruiksbalken wanneer quotawaarschuwingen zijn geconfigureerd.";
+"weekly_progress_work_days_title" = "Wekelijkse voortgang werkdagen";
+"weekly_progress_work_days_subtitle" = "Stel werkdagen in voor markeringen op wekelijkse gebruiksbalken en tempoberekeningen.";
+"show_reset_time_as_clock_title" = "Toon resettijd als klok";
+"show_reset_time_as_clock_subtitle" = "Geef resettijden weer als absolute klokwaarden in plaats van aftellingen.";
+"show_provider_changelog_links_title" = "Toon provider changelog-links";
+"show_provider_changelog_links_subtitle" = "Voegt koppelingen naar release-opmerkingen voor ondersteunde CLI-ondersteunde providers toe aan het menu.";
+"show_credits_extra_usage_title" = "Toon credits + extra gebruik";
+"show_credits_extra_usage_subtitle" = "Toon Codex Credits en Claude Extra gebruikssecties in het menu.";
+"show_all_token_accounts_title" = "Toon alle tokenaccounts";
+"show_all_token_accounts_subtitle" = "Stapel token-accounts in het menu (laat anders een accountwisselbalk zien).";
+"multi_account_layout_title" = "Indeling voor meerdere accounts";
+"multi_account_layout_subtitle" = "Kies voor gesegmenteerd wisselen tussen accounts of gestapelde accountkaarten.";
+"multi_account_layout_segmented" = "Gesegmenteerd";
+"multi_account_layout_stacked" = "Gestapeld";
+"overview_tab_providers_title" = "Overzicht tabblad aanbieders";
+"configure" = "Configureer…";
+"overview_enable_merge_icons_hint" = "Schakel Pictogrammen samenvoegen in om de providers van tabbladen Overzicht te configureren.";
+"overview_no_providers_hint" = "Er zijn geen ingeschakelde providers beschikbaar voor Overzicht.";
+"overview_rows_follow_order" = "Overzichtsrijen volgen altijd de volgorde van de provider.";
+"overview_no_providers_selected" = "Geen aanbieders geselecteerd";
+
+/* Advanced Pane */
+"section_keyboard_shortcut" = "Sneltoets";
+"open_menu_shortcut_title" = "Menu openen";
+"open_menu_shortcut_subtitle" = "Activeer het menubalkmenu vanaf elke locatie.";
+"install_cli" = "Installeer CLI";
+"install_cli_subtitle" = "Symlink CodexBarCLI naar /usr/local/bin en /opt/homebrew/bin als codexbar.";
+"cli_not_found" = "CodexBarCLI niet gevonden in appbundel.";
+"no_writable_bin_dirs" = "Geen beschrijfbare mapmap gevonden.";
+"show_debug_settings_title" = "Toon foutopsporingsinstellingen";
+"show_debug_settings_subtitle" = "Geef hulpprogramma's voor probleemoplossing weer op het tabblad Foutopsporing.";
+"surprise_me_title" = "Verras mij";
+"surprise_me_subtitle" = "Controleer of je het leuk vindt dat je agenten daar plezier hebben.";
+"weekly_limit_confetti_title" = "Wekelijkse limiet confetti";
+"weekly_limit_confetti_subtitle" = "Speel confetti op volledig scherm af wanneer het wekelijkse gebruik wordt gereset.";
+"hide_personal_info_title" = "Verberg persoonlijke informatie";
+"hide_personal_info_subtitle" = "Onduidelijke e-mailadressen in de menubalk en menu-UI.";
+"show_provider_storage_usage_title" = "Toon het opslaggebruik van de provider";
+"show_provider_storage_usage_subtitle" = "Toon lokaal schijfgebruik in menu's. Scant bekende paden van de provider op de achtergrond.";
+"section_keychain_access" = "Toegang via sleutelhanger";
+"keychain_access_caption" = "Schakel alle lees- en schrijfbewerkingen van de sleutelhanger uit. Gebruik dit als macOS blijft vragen om 'Chrome/Brave/Edge Safe Storage', zelfs nadat u op Altijd toestaan ​​hebt geklikt. Browsercookie-import is niet beschikbaar als deze is ingeschakeld; plak Cookie-headers handmatig in Providers. Claude/Codex OAuth via de CLI werkt nog steeds.";
+"disable_keychain_access_title" = "Schakel sleutelhangertoegang uit";
+"disable_keychain_access_subtitle" = "Voorkomt elke sleutelhangertoegang indien ingeschakeld.";
+
+/* About Pane */
+"about_tagline" = "Moge uw tokens nooit opraken: houd de limieten van agenten in het oog.";
+"link_github" = "GitHub";
+"link_website" = "Website";
+"link_twitter" = "Twitteren";
+"link_email" = "E-mail";
+"check_updates_auto" = "Automatisch controleren op updates";
+"update_channel" = "Kanaal bijwerken";
+"check_for_updates" = "Controleer op updates…";
+"updates_unavailable" = "Updates zijn niet beschikbaar in deze build.";
+"copyright" = "© 2026 Peter Steinberger. MIT-licentie.";
+
+/* Debug Pane */
+"section_logging" = "Loggen";
+"enable_file_logging" = "Bestandsregistratie inschakelen";
+"enable_file_logging_subtitle" = "Schrijf logboeken naar %@ voor foutopsporing.";
+"verbosity_title" = "Breedsprakigheid";
+"verbosity_subtitle" = "Bepaalt hoeveel details worden geregistreerd.";
+"open_log_file" = "Logbestand openen";
+"force_animation_next_refresh" = "Animatie forceren bij volgende vernieuwing";
+"force_animation_next_refresh_subtitle" = "Toont tijdelijk de laadanimatie na de volgende vernieuwing.";
+"section_loading_animations" = "Animaties laden";
+"loading_animations_caption" = "Kies een patroon en speel het opnieuw af in de menubalk. \"Random\" behoudt het bestaande gedrag.";
+"animation_random_default" = "Willekeurig (standaard)";
+"replay_selected_animation" = "Speel de geselecteerde animatie opnieuw af";
+"blink_now" = "Knipper nu";
+"section_probe_logs" = "Sondelogboeken";
+"probe_logs_caption" = "Haal de nieuwste testuitvoer op voor foutopsporing; Bij kopiëren blijft de volledige tekst behouden.";
+"fetch_log" = "Logboek ophalen";
+"copy" = "Kopiëren";
+"save_to_file" = "Opslaan in bestand";
+"load_parse_dump" = "Parseerdump laden";
+"rerun_provider_autodetect" = "Voer de automatische detectie van de provider opnieuw uit";
+"loading" = "Laden...";
+"no_log_yet_fetch" = "Nog geen logboek. Ophalen om te laden.";
+"section_fetch_strategy" = "Strategiepogingen ophalen";
+"fetch_strategy_caption" = "Laatste ophaalpijplijnbeslissingen en fouten voor een provider.";
+"section_openai_cookies" = "OpenAI-cookies";
+"openai_cookies_caption" = "Cookie-import + WebKit-scraping-logboeken van de laatste OpenAI-cookiepoging.";
+"no_log_yet" = "Nog geen logboek. Update OpenAI-cookies in Providers → Codex om een ​​import uit te voeren.";
+"section_caches" = "Caches";
+"caches_caption" = "Wis in het cachegeheugen opgeslagen kostenscanresultaten of caches van browsercookies.";
+"clear_cookie_cache" = "Cookie-cache wissen";
+"clear_cost_cache" = "Wis de kostencache";
+"section_notifications" = "Meldingen";
+"notifications_caption" = "Activeer testmeldingen voor het sessievenster van 5 uur (opgebruikt/hersteld).";
+"post_depleted" = "Post uitgeput";
+"post_restored" = "Bericht hersteld";
+"section_cli_sessions" = "CLI-sessies";
+"cli_sessions_caption" = "Houd Codex/Claude CLI-sessies levend na een onderzoek. Standaard wordt afgesloten zodra gegevens zijn vastgelegd.";
+"keep_cli_sessions_alive" = "Houd CLI-sessies levend";
+"keep_cli_sessions_alive_subtitle" = "Sla demontage tussen tests over (alleen voor foutopsporing).";
+"reset_cli_sessions" = "CLI-sessies opnieuw instellen";
+"section_error_simulation" = "Foutsimulatie";
+"error_simulation_caption" = "Injecteer een valse foutmelding in de menukaart voor het testen van de lay-out.";
+"set_menu_error" = "Menufout instellen";
+"clear_menu_error" = "Menufout wissen";
+"set_cost_error" = "Fout bij instellen van kosten";
+"clear_cost_error" = "Duidelijke kostenfout";
+"section_cli_paths" = "CLI-paden";
+"cli_paths_caption" = "Opgelost Codex binaire en PATH-lagen; opstarten login PATH vastleggen (korte time-out).";
+"codex_binary" = "Codex binair";
+"claude_binary" = "Claude binair";
+"effective_path" = "Effectief PAD";
+"unavailable" = "Niet beschikbaar";
+"login_shell_path" = "Login shell PATH (opstartopname)";
+"cleared" = "Gewist.";
+"no_fetch_attempts" = "Nog geen ophaalpogingen.";
+"macOS Tahoe can block menu bar apps in System Settings → Menu Bar → Allow in the Menu Bar. CodexBar is running, but macOS may be hiding its icon. Open Menu Bar settings and turn CodexBar on." = "macOS Tahoe kan menubalk-apps blokkeren in Systeeminstellingen → Menubalk → Toestaan ​​in de menubalk. CodexBar is actief, maar macOS verbergt mogelijk het pictogram ervan. Open de Menubalkinstellingen en schakel CodexBar in.";
+
+/* Metric preferences */
+"metric_pref_automatic" = "Automatisch";
+"metric_pref_primary" = "Primair";
+"metric_pref_secondary" = "Secundair";
+"metric_pref_tertiary" = "Tertiair";
+"metric_pref_extra_usage" = "Extra gebruik";
+"metric_pref_average" = "Gemiddeld";
+"metric_mistral_payg" = "Pay-as-you-go";
+"metric_mistral_monthly_plan" = "Monthly Plan";
+
+/* Display modes */
+"display_mode_percent" = "Procent";
+"display_mode_pace" = "Tempo";
+"display_mode_both" = "Beide";
+"display_mode_reset_time" = "Resettijd";
+"display_mode_percent_desc" = "Toon resterend/gebruikt percentage (bijvoorbeeld 45%)";
+"display_mode_pace_desc" = "Toon tempo-indicator (bijv. +5%)";
+"display_mode_both_desc" = "Toon zowel percentage als tempo (bijvoorbeeld 45% · +5%)";
+"display_mode_reset_time_desc" = "Toon de resettijd voor de geselecteerde metriek (bijvoorbeeld ↻ 15:56)";
+
+/* Provider status */
+"status_operational" = "Operationeel";
+"status_partial_outage" = "Gedeeltelijke uitval";
+"status_major_outage" = "Grote storing";
+"status_critical_issue" = "Kritieke kwestie";
+"status_maintenance" = "Onderhoud";
+"status_unknown" = "Status onbekend";
+
+/* Refresh frequency */
+"refresh_manual" = "Handmatig";
+"refresh_1min" = "1 min";
+"refresh_2min" = "2 minuten";
+"refresh_5min" = "5 min";
+"refresh_15min" = "15 minuten";
+"refresh_30min" = "30 min";
+
+/* Additional keys */
+"not_found" = "Niet gevonden";
+
+/* Cost estimation */
+"cost_header_estimated" = "Kosten (geschat)";
+"cost_estimate_hint" = "Geschat op basis van lokale logboeken · kan afwijken van uw factuur";
+"No JetBrains IDE with AI Assistant detected. Install a JetBrains IDE and enable AI Assistant." = "Geen JetBrains IDE met AI Assistant gedetecteerd. Installeer een JetBrains IDE en schakel AI Assistant in.";
+"OpenRouter API token not configured. Set OPENROUTER_API_KEY environment variable or configure in Settings." = "OpenRouter API-token niet geconfigureerd. Stel de omgevingsvariabele OPENROUTER_API_KEY in of configureer deze in Instellingen.";
+"z.ai API token not found. Set apiKey in ~/.codexbar/config.json or Z_AI_API_KEY." = "z.ai API-token niet gevonden. Stel apiKey in ~/.codexbar/config.json of Z_AI_API_KEY.";
+"Missing DeepSeek API key." = "Ontbrekende DeepSeek API-sleutel.";
+"%@ is unavailable in the current environment." = "%@ is niet beschikbaar in de huidige omgeving.";
+"All Systems Operational" = "Alle systemen operationeel";
+"Last 30 days" = "Laatste 30 dagen";
+"Last 30 days:" = "Afgelopen 30 dagen:";
+"This month" = "Deze maand";
+"Store multiple OpenAI API keys." = "Bewaar meerdere OpenAI API-sleutels.";
+"Admin API key" = "Beheerder API-sleutel";
+"Open billing" = "Facturering openen";
+"Google accounts" = "Google-accounts";
+"Store multiple Antigravity Google OAuth accounts for quick switching." = "Bewaar meerdere Antigravity Google OAuth-accounts voor snel schakelen.";
+"Add Google Account" = "Google-account toevoegen";
+"Open Token Plan" = "Tokenplan openen";
+"Text Generation" = "Tekst genereren";
+"Text to Speech" = "Tekst naar spraak";
+"Music Generation" = "Muziek generatie";
+"Image Generation" = "Beeldgeneratie";
+"No local data found" = "Geen lokale gegevens gevonden";
+"Credits unavailable; keep Codex running to refresh." = "Tegoeden niet beschikbaar; laat Codex draaien om te vernieuwen.";
+"No available fetch strategy for minimax." = "Geen beschikbare ophaalstrategie voor minimax.";
+"No Cursor session found. Please log in to cursor.com in Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX, or Edge Canary. If you use Safari, grant CodexBar Full Disk Access in System Settings ▸ Privacy & Security. You can also sign in to Cursor from the CodexBar menu (Add / switch account)." = "Geen Cursorsessie gevonden. Meld u aan bij cursor.com in Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX of Edge Canary. Als u Safari gebruikt, verleen CodexBar volledige schijftoegang in Systeeminstellingen ▸ Privacy en beveiliging. U kunt zich ook aanmelden bij Cursor via het CodexBar-menu (Account toevoegen/wisselen).";
+"No OpenCode session cookies found in browsers." = "Er zijn geen OpenCode-sessiecookies gevonden in browsers.";
+"No available fetch strategy for %@." = "Geen beschikbare ophaalstrategie voor %@.";
+"Today" = "Vandaag";
+"Today tokens" = "Vandaag tokens";
+"30d cost" = "30d kosten";
+"30d tokens" = "30d-tokens";
+"Latest tokens" = "Nieuwste tokens";
+"Top model" = "Topmodel";
+"Storage" = "Opslag";
+"Add Account..." = "Account toevoegen...";
+"Usage Dashboard" = "Gebruiksdashboard";
+"Status Page" = "Statuspagina";
+"Settings..." = "Instellingen...";
+"About CodexBar" = "Over CodexBar";
+"Quit" = "Stoppen";
+"Last %d day" = "Afgelopen %d dag";
+"Last %d days" = "Afgelopen %d dagen";
+"%@ tokens" = "%@ tokens";
+"Latest billing day" = "Laatste factuurdag";
+"Latest billing day (%@)" = "Laatste factuurdag (%@)";
+"%@ left" = "%@ over";
+"Resets %@" = "Reset %@";
+"Resets in %@" = "Resetten over %@";
+"Resets now" = "Wordt nu gereset";
+"reset_tomorrow_format" = "morgen, %@";
+"Lasts until reset" = "Gaat mee tot reset";
+"Updated %@" = "Bijgewerkt %@";
+"Updated %@h ago" = "%@u geleden bijgewerkt";
+"Updated %@m ago" = "%@m geleden bijgewerkt";
+"Updated just now" = "Zojuist bijgewerkt";
+"Projected empty in %@" = "Geprojecteerd leeg in %@";
+"Runs out in %@" = "Loopt af over %@";
+"Pace: %@" = "Tempo: %@";
+"Pace: %@ · %@" = "Tempo: %@ · %@";
+"%@ · %@" = "%@ · %@";
+"≈ %d%% run-out risk" = "≈ %d%% uitlooprisico";
+"%d%% in deficit" = "%d%% tekort";
+"%d%% in reserve" = "%d%% in reserve";
+"usage_percent_suffix_left" = "over";
+"usage_percent_suffix_used" = "gebruikt";
+"Store multiple DeepSeek API keys." = "Bewaar meerdere DeepSeek API-sleutels.";
+"This week" = "Deze week";
+"Week" = "Week";
+"Month" = "Maand";
+"Models" = "Modellen";
+"24h tokens" = "24-uurs tokens";
+"Latest hour" = "Laatste uur";
+"Peak hour" = "Piekuur";
+"Top method" = "Topmethode";
+"30d cash" = "30d contant";
+"30d billing history from MiniMax web session" = "30d factuurgeschiedenis van MiniMax-websessie";
+"AWS Cost Explorer billing can lag." = "De facturering van AWS Cost Explorer kan vertraging oplopen.";
+"Rate limit: %d / %@" = "Tarieflimiet: %d / %@";
+"Key remaining" = "Sleutel resterend";
+"No limit set for the API key" = "Er is geen limiet ingesteld voor de API-sleutel";
+"API key limit unavailable right now" = "API-sleutellimiet momenteel niet beschikbaar";
+"This month: %@ tokens" = "Deze maand: %@ tokens";
+"No utilization data yet." = "Nog geen gebruiksgegevens.";
+"No %@ utilization data yet." = "Nog geen %@ gebruiksgegevens.";
+"%@: %@%% used" = "%@: %@%% gebruikt";
+"%dd" = "%dd";
+"today" = "Vandaag";
+"just now" = "zojuist";
+"On pace" = "Op tempo";
+"Runs out now" = "Is nu op";
+"Projected empty now" = "Nu leeg geprojecteerd";
+"Switch Account..." = "Account wisselen...";
+"Update ready, restart now?" = "Update klaar, nu opnieuw opstarten?";
+"Daily" = "Dagelijks";
+"Hourly Tokens" = "Tokens per uur";
+"No data" = "Geen gegevens";
+"No usage breakdown data available." = "Er zijn geen gebruiksgegevens beschikbaar.";
+
+"Today: %@ · %@ tokens" = "Vandaag: %@ · %@ tokens";
+"Today: %@" = "Vandaag: %@";
+"Today: %@ tokens" = "Vandaag: %@ tokens";
+"Last 30 days: %@ · %@ tokens" = "Afgelopen 30 dagen: %@ · %@ tokens";
+"Last 30 days: %@" = "Afgelopen 30 dagen: %@";
+"Est. total (30d): %@" = "Geschat. totaal (30d): %@";
+"Est. total (%@): %@" = "Geschat. totaal (%@): %@";
+"Hover a bar for details" = "Beweeg een balk voor details";
+"%@: %@ · %@ tokens" = "%@: %@ · %@ tokens";
+"No providers selected for Overview." = "Geen aanbieders geselecteerd voor Overzicht.";
+"No overview data available." = "Geen overzichtsgegevens beschikbaar.";
+"Auto uses the local IDE API first, then Google OAuth when the IDE is closed." = "Auto gebruikt eerst de lokale IDE API en vervolgens Google OAuth wanneer de IDE wordt gesloten.";
+"Login with Google" = "Inloggen met Google";
+
+/* Popup panels */
+"No usage configured." = "Geen gebruik geconfigureerd.";
+"Quota" = "Quotum";
+"tokens" = "tokens";
+"requests" = "verzoeken";
+"Latest" = "Nieuwste";
+"Monthly" = "Maandelijks";
+"Sonnet" = "Sonnet";
+"Overages" = "Overschotten";
+"Activity" = "Activiteit";
+"Copied" = "Gekopieerd";
+"Copy error" = "Kopieerfout";
+"Copy path" = "Kopieer pad";
+"Extra usage spent" = "Extra gebruik besteed";
+"Credits remaining" = "Resterende tegoeden";
+"Using CLI fallback" = "CLI-fallback gebruiken";
+"Balance updates in near-real time (up to 5 min lag)" = "Saldo-updates in bijna realtime (tot 5 minuten vertraging)";
+"Daily billing data finalizes at 07:00 UTC" = "De dagelijkse factureringsgegevens worden afgerond om 07:00 UTC";
+"%@ of %@ credits left" = "%@ van %@ credits over";
+"%@ of %@ bonus credits left" = "Er zijn nog %@ van %@ bonuscredits over";
+"%@ / %@ (%@ remaining)" = "%@ / %@ (%@ resterend)";
+"%@/%@ left" = "%@/%@ over";
+"Gemini Flash" = "Tweeling flits";
+"Regenerates %@" = "Regenereert %@";
+"used after next regen" = "gebruikt na de volgende regen";
+"after next regen" = "na de volgende regen";
+"Near full" = "Bijna vol";
+"Full in ~1 regen" = "Volledig in ~1 regeneratie";
+"Full in ~%.0f regens" = "Volledig in ~%.0f regens";
+"Overage usage" = "Overmatig gebruik";
+"Overage cost" = "Overschrijdingskosten";
+"credits" = "tegoeden";
+"Zen balance" = "Zen-balans";
+"API spend" = "API-uitgaven";
+"Extra usage" = "Extra gebruik";
+"Quota usage" = "Quotumgebruik";
+"Your spend" = "Jouw uitgaven";
+"%.0f%% used" = "%.0f%% gebruikt";
+"Usage history (today)" = "Gebruiksgeschiedenis (vandaag)";
+"Usage history (%d days)" = "Gebruiksgeschiedenis (%d dagen)";
+"%d percent remaining" = "%d procent resterend";
+"Unknown" = "Onbekend";
+"stale data" = "verouderde gegevens";
+"No credits history data." = "Geen kredietgeschiedenisgegevens.";
+"No credits history data available." = "Er zijn geen kredietgeschiedenisgegevens beschikbaar.";
+"Credits history chart" = "Creditgeschiedenisgrafiek";
+"%d days of credits data" = "%d dagen aan kredietgegevens";
+"Usage breakdown chart" = "Uitsplitsingsschema voor gebruik";
+"%d days of usage data across %d services" = "%d dagen aan gebruiksgegevens voor %d services";
+"Cost history chart" = "Kostengeschiedenisgrafiek";
+"%d days of cost data" = "%d dagen aan kostengegevens";
+"Plan utilization chart" = "Plan gebruiksgrafiek";
+"%d utilization samples" = "%d gebruiksvoorbeelden";
+"Hourly Usage" = "Uurgebruik";
+"Usage remaining" = "Resterend gebruik";
+"Usage used" = "Gebruik gebruikt";
+"API key verified. Ollama does not expose Cloud quota limits through the API." = "API-sleutel geverifieerd. Ollama stelt geen Cloud-quotumlimieten bloot via de API.";
+"Last 30 days: %@ tokens" = "Afgelopen 30 dagen: %@ tokens";
+"7d spend" = "7d uitgaven";
+"30d spend" = "30d uitgaven";
+"Cache read" = "Cache lezen";
+"Claude Admin API 30 day spend trend" = "Claude Admin API bestedingstrend van 30 dagen";
+"OpenRouter API key spend trend" = "Trend van uitgaven voor OpenRouter API-sleutels";
+"z.ai hourly token trend" = "z.ai tokentrend per uur";
+"MiniMax 30 day token usage trend" = "MiniMax 30 dagen tokengebruikstrend";
+"Today cash" = "Vandaag contant";
+"DeepSeek 30 day token usage trend" = "DeepSeek 30 dagen tokengebruikstrend";
+"cache-hit input" = "cache-hit-invoer";
+"cache-miss input" = "cache-miss invoer";
+"output" = "uitgang";
+"Requests" = "Verzoeken";
+"Reported by OpenAI Admin API organization usage." = "Gerapporteerd door het gebruik van de OpenAI Admin API-organisatie.";
+"Reported by Mistral billing usage." = "Gerapporteerd door Mistral-factureringsgebruik.";
+"Google OAuth" = "Google OAuth";
+"Add accounts via GitHub OAuth Device Flow on the selected host." = "Voeg accounts toe via GitHub OAuth Device Flow op de geselecteerde host.";
+"Stores each signed-in Google account for quick Antigravity switching. Uses Antigravity.app OAuth when available, or ANTIGRAVITY_OAUTH_CLIENT_ID and ANTIGRAVITY_OAUTH_CLIENT_SECRET as an override." = "Slaat elk ingelogd Google-account op voor snel schakelen tussen anti-zwaartekracht. Gebruikt Antigravity.app OAuth indien beschikbaar, of ANTIGRAVITY_OAUTH_CLIENT_ID en ANTIGRAVITY_OAUTH_CLIENT_SECRET als overschrijving.";
+"Manual cleanup: past sessions" = "Handmatig opschonen: afgelopen sessies";
+"Clearing removes past resume, continue, and rewind history." = "Door te wissen wordt de geschiedenis van het hervatten, doorgaan en terugspoelen uit het verleden verwijderd.";
+"Manual cleanup: file checkpoints" = "Handmatig opschonen: bestandscontrolepunten";
+"Clearing removes checkpoint restore data for previous edits." = "Door het wissen worden de controlepuntherstelgegevens van eerdere bewerkingen verwijderd.";
+"Manual cleanup: saved plans" = "Handmatig opschonen: opgeslagen plannen";
+"Clearing removes old plan-mode files." = "Door te wissen worden oude bestanden in de planmodus verwijderd.";
+"Manual cleanup: debug logs" = "Handmatig opschonen: foutopsporingslogboeken";
+"Clearing removes past debug logs." = "Door te wissen worden eerdere foutopsporingslogboeken verwijderd.";
+"Manual cleanup: attachment cache" = "Handmatig opschonen: bijlagecache";
+"Clearing removes cached large pastes or attached images." = "Door te wissen worden in de cache opgeslagen grote pasta's of bijgevoegde afbeeldingen verwijderd.";
+"Manual cleanup: session metadata" = "Handmatig opschonen: sessiemetagegevens";
+"Clearing removes per-session environment metadata." = "Door te wissen worden de metagegevens van de omgeving per sessie verwijderd.";
+"Manual cleanup: shell snapshots" = "Handmatig opschonen: shell-snapshots";
+"Clearing removes leftover runtime shell snapshot files." = "Door het wissen worden de overgebleven runtime shell-snapshotbestanden verwijderd.";
+"Manual cleanup: legacy todos" = "Handmatig opschonen: oude taken";
+"Clearing removes legacy per-session task lists." = "Door het wissen worden verouderde takenlijsten per sessie verwijderd.";
+"Manual cleanup: sessions" = "Handmatig opschonen: sessies";
+"Clearing removes past Codex session history." = "Door te wissen wordt de geschiedenis van de Codex-sessie verwijderd.";
+"Manual cleanup: archived sessions" = "Handmatig opschonen: gearchiveerde sessies";
+"Clearing removes archived Codex session history." = "Door te wissen wordt de gearchiveerde Codex-sessiegeschiedenis verwijderd.";
+"Manual cleanup: cache" = "Handmatig opschonen: cache";
+"Clearing removes provider-owned cached data." = "Door te wissen worden gegevens in de cache van de provider verwijderd.";
+"Manual cleanup: logs" = "Handmatig opschonen: logboeken";
+"Clearing removes local diagnostic logs." = "Door te wissen worden lokale diagnostische logboeken verwijderd.";
+"Manual cleanup: file history" = "Handmatig opschonen: bestandsgeschiedenis";
+"Clearing removes local edit checkpoint history." = "Door te wissen wordt de geschiedenis van de lokale bewerkingscontrolepunten verwijderd.";
+"Manual cleanup: temporary data" = "Handmatig opschonen: tijdelijke gegevens";
+"Clearing removes local temporary provider data." = "Door te wissen worden lokale tijdelijke providergegevens verwijderd.";
+"Total: %@" = "Totaal: %@";
+"%d more items" = "%d meer artikelen";
+"Cleanup ideas" = "Opruimideeën";
+"%d unreadable item(s) skipped" = "%d onleesbare item(s) overgeslagen";
+
+"API key limit" = "API-sleutellimiet";
+"Auth" = "Aut";
+"Auto" = "Auto";
+"Disabled — no recent data" = "Uitgeschakeld — geen recente gegevens";
+"Limits not available" = "Limieten niet beschikbaar";
+"No usage yet" = "Nog geen gebruik";
+"Not fetched yet" = "Nog niet opgehaald";
+"Refreshing" = "Verfrissend";
+"Session" = "Sessie";
+"Source" = "Bron";
+"State" = "Staat";
+"Unavailable" = "Niet beschikbaar";
+"Weekly" = "Wekelijks";
+"not detected" = "niet gedetecteerd";
+"Estimated from local Codex logs for the selected account." = "Geschat op basis van lokale Codex-logboeken voor het geselecteerde account.";
+"minimax_usage_amount_format" = "Gebruik: %@ / %@";
+"minimax_used_percent_format" = "Gebruikt %@";
+"minimax_service_text_generation" = "Tekst genereren";
+"minimax_service_text_to_speech" = "Tekst naar spraak";
+"minimax_service_music_generation" = "Muziek generatie";
+"minimax_service_image_generation" = "Beeldgeneratie";
+"minimax_service_lyrics_generation" = "Songtekst generatie";
+"minimax_service_coding_plan_vlm" = "Codeerplan VLM";
+"minimax_service_coding_plan_search" = "Coderingsplan zoeken";
+
+/* Additional provider settings and alerts */
+"%@ is waiting for permission" = "%@ wacht op toestemming";
+"%@ requests" = "%@ verzoeken";
+"%@: %@ credits" = "%@: %@ tegoeden";
+"30d requests" = "30d verzoeken";
+"4 days" = "4 dagen";
+"5 days" = "5 dagen";
+"7 days" = "7 dagen";
+"API key verifies Ollama Cloud access; cookies still expose quota limits." = "API-sleutel verifieert Ollama Cloud-toegang; cookies stellen nog steeds quotumlimieten bloot.";
+"AWS access key ID. Can also be set with AWS_ACCESS_KEY_ID." = "AWS-toegangssleutel-ID. Kan ook worden ingesteld met AWS_ACCESS_KEY_ID.";
+"AWS region. Can also be set with AWS_REGION." = "AWS-regio. Kan ook worden ingesteld met AWS_REGION.";
+"AWS secret access key. Can also be set with AWS_SECRET_ACCESS_KEY." = "Geheime toegangssleutel van AWS. Kan ook worden ingesteld met AWS_SECRET_ACCESS_KEY.";
+"Access key ID" = "Toegangssleutel-ID";
+"Add Account" = "Account toevoegen";
+"Adding Account…" = "Account toevoegen…";
+"Antigravity login failed" = "Antigravity-aanmelding mislukt";
+"Antigravity login timed out" = "Er is een time-out opgetreden bij het inloggen op anti-zwaartekracht";
+"Auth source" = "Authenticatiebron";
+"Automatic imports browser cookies from Xiaomi MiMo." = "Importeert automatisch browsercookies van Xiaomi MiMo.";
+"Automatic imports Windsurf session data from Chromium browser localStorage." = "Automatische import van windsurfsessiegegevens uit de Chromium-browser localStorage.";
+"Automatic imports browser cookies from Bailian." = "Importeert automatisch browsercookies van Bailian.";
+"Automatically imports browser cookies." = "Importeert automatisch browsercookies.";
+"Automatically imports browser session cookies." = "Importeert automatisch browsersessiecookies.";
+"Azure OpenAI deployment name. AZURE_OPENAI_DEPLOYMENT_NAME is also supported." = "Azure OpenAI-implementatienaam. AZURE_OPENAI_DEPLOYMENT_NAME wordt ook ondersteund.";
+"Azure OpenAI key" = "Azure OpenAI-sleutel";
+"Azure OpenAI resource endpoint. AZURE_OPENAI_ENDPOINT is also supported." = "Azure OpenAI-resource-eindpunt. AZURE_OPENAI_ENDPOINT wordt ook ondersteund.";
+"Base URL" = "Basis-URL";
+"Base URL for the LLM-API-Key-Proxy instance." = "Basis-URL voor de LLM-API-Key-Proxy-instantie.";
+"Browser cookies" = "Browser-cookies";
+"Cap end" = "Dop uiteinde";
+"Cap start" = "Kap begin";
+"Capacity End" = "Einde capaciteit";
+"Capacity Start" = "Capaciteit begin";
+"Changelog" = "Wijzigingslog";
+"Choose the Moonshot/Kimi API host for international or China mainland accounts." = "Kies de Moonshot/Kimi API-host voor internationale accounts of accounts op het vasteland van China.";
+"CodexBar can't replace a system account that is signed in with an API key only setup." = "CodexBar kan een systeemaccount dat is aangemeld met alleen een API-sleutelconfiguratie niet vervangen.";
+"CodexBar could not find saved auth for that account. Re-authenticate it and try again." = "CodexBar kon de opgeslagen verificatie voor dat account niet vinden. Authenticeer het opnieuw en probeer het opnieuw.";
+"CodexBar could not read managed account storage. Recover the store before adding another account." = "CodexBar kan de beheerde accountopslag niet lezen. Herstel de winkel voordat u een ander account toevoegt.";
+"CodexBar could not read saved auth for that account. Re-authenticate it and try again." = "CodexBar kan de opgeslagen verificatie voor dat account niet lezen. Authenticeer het opnieuw en probeer het opnieuw.";
+"CodexBar could not read the current system account on this Mac." = "CodexBar kon het huidige systeemaccount op deze Mac niet lezen.";
+"CodexBar could not replace the live Codex auth on this Mac." = "CodexBar kon de live Codex-authenticatie op deze Mac niet vervangen.";
+"CodexBar could not safely preserve the current system account before switching." = "CodexBar kon het huidige systeemaccount niet veilig behouden voordat hij overschakelde.";
+"CodexBar could not save the current system account before switching." = "CodexBar kon het huidige systeemaccount niet opslaan voordat er werd overgeschakeld.";
+"CodexBar could not update managed account storage." = "CodexBar kan de beheerde accountopslag niet updaten.";
+"CodexBar found another managed account that already uses the current system account. Resolve the duplicate account before switching." = "CodexBar heeft een ander beheerd account gevonden dat al gebruikmaakt van het huidige systeemaccount. Los het dubbele account op voordat u overstapt.";
+"CodexBar will ask macOS Keychain for “%@” so it can decrypt browser cookies and authenticate your account. Click OK to continue." = "CodexBar vraagt ​​macOS-sleutelhanger om “%@”, zodat browsercookies kunnen worden gedecodeerd en uw account kan worden geverifieerd. Klik op OK om door te gaan.";
+"CodexBar will ask macOS Keychain for the Claude Code OAuth token so it can fetch your Claude usage. Click OK to continue." = "CodexBar zal macOS Keychain om het Claude Code OAuth-token vragen, zodat het uw Claude-gebruik kan ophalen. Klik op OK om door te gaan.";
+"CodexBar will ask macOS Keychain for your Amp cookie header so it can fetch usage. Click OK to continue." = "CodexBar zal macOS Keychain om je Amp-cookieheader vragen, zodat deze het gebruik kan ophalen. Klik op OK om door te gaan.";
+"CodexBar will ask macOS Keychain for your Augment cookie header so it can fetch usage. Click OK to continue." = "CodexBar zal macOS Keychain om uw Augment-cookie-header vragen, zodat deze het gebruik kan ophalen. Klik op OK om door te gaan.";
+"CodexBar will ask macOS Keychain for your Claude cookie header so it can fetch Claude web usage. Click OK to continue." = "CodexBar zal macOS Keychain om uw Claude-cookieheader vragen, zodat deze het webgebruik van Claude kan ophalen. Klik op OK om door te gaan.";
+"CodexBar will ask macOS Keychain for your Cursor cookie header so it can fetch usage. Click OK to continue." = "CodexBar zal macOS Keychain om uw Cursor-cookieheader vragen, zodat deze het gebruik kan ophalen. Klik op OK om door te gaan.";
+"CodexBar will ask macOS Keychain for your Factory cookie header so it can fetch usage. Click OK to continue." = "CodexBar zal macOS Keychain om uw Factory-cookieheader vragen, zodat deze het gebruik kan ophalen. Klik op OK om door te gaan.";
+"CodexBar will ask macOS Keychain for your GitHub Copilot token so it can fetch usage. Click OK to continue." = "CodexBar zal macOS Keychain om uw GitHub Copilot-token vragen, zodat deze het gebruik kan ophalen. Klik op OK om door te gaan.";
+"CodexBar will ask macOS Keychain for your Kimi K2 API key so it can fetch usage. Click OK to continue." = "CodexBar vraagt ​​macOS Keychain om je Kimi K2 API-sleutel, zodat deze het gebruik kan ophalen. Klik op OK om door te gaan.";
+"CodexBar will ask macOS Keychain for your Kimi auth token so it can fetch usage. Click OK to continue." = "CodexBar vraagt ​​macOS Keychain om je Kimi-authenticatietoken, zodat het gebruik kan worden opgehaald. Klik op OK om door te gaan.";
+"CodexBar will ask macOS Keychain for your MiniMax API token so it can fetch usage. Click OK to continue." = "CodexBar zal macOS Keychain om uw MiniMax API-token vragen, zodat deze het gebruik kan ophalen. Klik op OK om door te gaan.";
+"CodexBar will ask macOS Keychain for your MiniMax cookie header so it can fetch usage. Click OK to continue." = "CodexBar zal macOS Keychain om uw MiniMax-cookieheader vragen, zodat deze het gebruik kan ophalen. Klik op OK om door te gaan.";
+"CodexBar will ask macOS Keychain for your OpenAI cookie header so it can fetch Codex dashboard extras. Click OK to continue." = "CodexBar zal macOS Keychain om uw OpenAI-cookieheader vragen, zodat deze extra's op het Codex-dashboard kan ophalen. Klik op OK om door te gaan.";
+"CodexBar will ask macOS Keychain for your OpenCode cookie header so it can fetch usage. Click OK to continue." = "CodexBar zal macOS Keychain om uw OpenCode-cookieheader vragen, zodat deze het gebruik kan ophalen. Klik op OK om door te gaan.";
+"CodexBar will ask macOS Keychain for your Synthetic API key so it can fetch usage. Click OK to continue." = "CodexBar vraagt ​​macOS-sleutelhanger om uw synthetische API-sleutel, zodat deze het gebruik kan ophalen. Klik op OK om door te gaan.";
+"CodexBar will ask macOS Keychain for your z.ai API token so it can fetch usage. Click OK to continue." = "CodexBar zal macOS Keychain om uw z.ai API-token vragen, zodat deze het gebruik kan ophalen. Klik op OK om door te gaan.";
+"Could not open Cursor login in your browser." = "Kan Cursor-login niet openen in uw browser.";
+"Could not open browser for Antigravity" = "Kan browser voor Antigravity niet openen";
+"Credits used" = "Gebruikte tegoeden";
+"Day" = "Dag";
+"Deployment" = "Inzet";
+"Drag to reorder" = "Sleep om de volgorde te wijzigen";
+"Sort providers alphabetically" = "Providers alfabetisch sorteren";
+"Sort providers alphabetically (enabled first)" = "Providers alfabetisch sorteren (ingeschakelde eerst)";
+"Sorted alphabetically (enabled first) — click to use your custom order" = "Alfabetisch gesorteerd (ingeschakelde eerst) — klik om je aangepaste volgorde te gebruiken";
+"Endpoint" = "Eindpunt";
+"Enterprise host" = "Enterprise-host";
+"Extra usage balance: %@" = "Extra gebruikssaldo: %@";
+"Keychain Access Required" = "Toegang tot sleutelhanger vereist";
+"Kiro menu bar value" = "Waarde van de Kiro-menubalk";
+"Label" = "Label";
+"No organizations loaded. Click Refresh after setting your API key." = "Er zijn geen organisaties geladen. Klik op Vernieuwen nadat u uw API-sleutel hebt ingesteld.";
+"No output captured." = "Geen uitvoer vastgelegd.";
+"No system account" = "Geen systeemaccount";
+"Oasis-Token" = "Oasis-token";
+"Open Augment (Log Out & Back In)" = "Augment openen (uitloggen en weer inloggen)";
+"Open Codebuff Dashboard" = "Open het Codebuff-dashboard";
+"Open Command Code Settings" = "Open de opdrachtcode-instellingen";
+"Open Crof dashboard" = "Open het Crof-dashboard";
+"Open Manus" = "Manus openen";
+"Open MiMo Balance" = "Open MiMo-saldo";
+"Open Moonshot Console" = "Open de Moonshot-console";
+"Open Ollama API Keys" = "Open Ollama API-sleutels";
+"Open StepFun Platform" = "Open het StepFun-platform";
+"Open T3 Chat Settings" = "Open T3 Chat-instellingen";
+"Open Volcengine Ark Console" = "Open de Volcengine Ark-console";
+"Open legacy provider docs" = "Open oude providerdocumenten";
+"Open projects" = "Openstaande projecten";
+"Open this URL manually to continue login:\n\n%@" = "Open deze URL handmatig om door te gaan met inloggen:\n\n%@";
+"Optional organization ID for accounts linked to multiple Anthropic organizations." = "Optionele organisatie-ID voor accounts die zijn gekoppeld aan meerdere Anthropic-organisaties.";
+"Optional. Applies to the configured Admin API key; selected token accounts do not inherit OPENAI_PROJECT_ID." = "Optioneel. Is van toepassing op de geconfigureerde Admin API-sleutel; geselecteerde tokenaccounts nemen OPENAI_PROJECT_ID niet over.";
+"Optional. Enter your GitHub Enterprise host, for example octocorp.ghe.com. Leave blank for github.com." = "Optioneel. Voer uw GitHub Enterprise-host in, bijvoorbeeld octocorp.ghe.com. Laat leeg voor github.com.";
+"Optional. Leave blank to discover and aggregate projects visible to the API key." = "Optioneel. Laat dit veld leeg om projecten te ontdekken en samen te voegen die zichtbaar zijn voor de API-sleutel.";
+"Org ID (optional)" = "Organisatie-ID (optioneel)";
+"Organizations" = "Organisaties";
+"Password" = "Wachtwoord";
+"%@ authentication is disabled." = "%@-authenticatie is uitgeschakeld.";
+"%@ cookies are disabled." = "%@ cookies zijn uitgeschakeld.";
+"%@ web API access is disabled." = "%@ web-API-toegang is uitgeschakeld.";
+"Disable %@ dashboard cookie usage." = "Schakel het gebruik van %@ dashboardcookies uit.";
+"Keychain access is disabled in Advanced, so browser cookie import is unavailable." = "De sleutelhangertoegang is uitgeschakeld in Geavanceerd, dus het importeren van browsercookies is niet beschikbaar.";
+"Manually paste an %@ from a browser session." = "Plak handmatig een %@ uit een browsersessie.";
+"Paste a Cookie header captured from %@." = "Plak een Cookie-header vastgelegd van %@.";
+"Paste a Cookie header from %@." = "Plak een Cookie-header van %@.";
+"Paste a Cookie header or cURL capture from %@." = "Plak een cookie-header of cURL-opname uit %@.";
+"Paste a Cookie header or full cURL capture from %@." = "Plak een cookiekoptekst of volledige krulopname uit %@.";
+"Paste a Cookie or Authorization header from %@." = "Plak een cookie- of autorisatiekop van %@.";
+"Paste a full cookie header or the %@ value." = "Plak een volledige cookiekop of de waarde %@.";
+"Paste a Cookie header or full cURL capture from T3 Chat settings." = "Plak een Cookie-header of volledige cURL-opname uit de T3 Chat-instellingen.";
+"Paste the Cookie header from a request to admin.mistral.ai. Must contain an ory_session_* cookie." = "Plak de Cookie-header uit een verzoek naar admin.mistral.ai. Moet een ory_session_* cookie bevatten.";
+"Paste the Oasis-Token from a logged-in browser session on platform.stepfun.com." = "Plak de Oasis-Token uit een ingelogde browsersessie op platform.stepfun.com.";
+"Paste the %@ JSON bundle from %@." = "Plak de %@ JSON-bundel uit %@.";
+"Paste the %@ value or a full Cookie header." = "Plak de waarde %@ of een volledige Cookie-header.";
+"Personal account" = "Persoonlijk account";
+"Project ID" = "Project-ID";
+"Re-auth" = "Opnieuw verifiëren";
+"Re-login at claude.ai" = "Opnieuw aanmelden bij claude.ai";
+"Re-authenticating…" = "Opnieuw authenticeren…";
+"Refresh Session" = "Sessie vernieuwen";
+"Refresh organizations" = "Vernieuw organisaties";
+"Region" = "Regio";
+"Reload" = "Herladen";
+"Reorder" = "Opnieuw ordenen";
+"Secret access key" = "Geheime toegangssleutel";
+"Series" = "Serie";
+"Service" = "Dienst";
+"Show or hide Kiro credits, percent, or both next to the menu bar icon." = "Toon of verberg Kiro-credits, percentages of beide naast het menubalkpictogram.";
+"Show usage for organizations you belong to. Personal account is always shown." = "Toon gebruik voor organisaties waartoe u behoort. Persoonlijk account wordt altijd getoond.";
+"Sign in to cursor.com in your browser, then refresh Cursor in CodexBar." = "Meld u aan bij cursor.com in uw browser en vernieuw vervolgens Cursor in CodexBar.";
+"Simulated error text" = "Gesimuleerde fouttekst";
+"StepFun platform account (phone number or email)." = "StepFun-platformaccount (telefoonnummer of e-mailadres).";
+"Stored in ~/.codexbar/config.json." = "Opgeslagen in ~/.codexbar/config.json.";
+"Stored in ~/.codexbar/config.json. AZURE_OPENAI_API_KEY is also supported." = "Opgeslagen in ~/.codexbar/config.json. AZURE_OPENAI_API_KEY wordt ook ondersteund.";
+"Stored in ~/.codexbar/config.json. For the official Kimi API, use Moonshot / Kimi API." = "Opgeslagen in ~/.codexbar/config.json. Gebruik Moonshot / Kimi API voor de officiële Kimi API.";
+"Stored in ~/.codexbar/config.json. Get your API key from the Volcengine Ark console." = "Opgeslagen in ~/.codexbar/config.json. Haal uw API-sleutel op via de Volcengine Ark-console.";
+"Stored in ~/.codexbar/config.json. Get your key from Ollama settings." = "Opgeslagen in ~/.codexbar/config.json. Haal uw sleutel op via Ollama-instellingen.";
+"Stored in ~/.codexbar/config.json. Get your key from console.deepgram.com." = "Opgeslagen in ~/.codexbar/config.json. Haal uw sleutel op via console.deepgram.com.";
+"Stored in ~/.codexbar/config.json. Get your key from elevenlabs.io/app/settings/api-keys." = "Opgeslagen in ~/.codexbar/config.json. Haal uw sleutel op via elevenlabs.io/app/settings/api-keys.";
+"Stored in ~/.codexbar/config.json. Get your key from openrouter.ai/settings/keys and set a key spending limit there to enable API key quota tracking." = "Opgeslagen in ~/.codexbar/config.json. Haal uw sleutel op via openrouter.ai/settings/keys en stel daar een sleutelbestedingslimiet in om het bijhouden van API-sleutelquota in te schakelen.";
+"Stored in ~/.codexbar/config.json. In Warp, open Settings > Platform > API Keys, then create one." = "Opgeslagen in ~/.codexbar/config.json. Open in Warp Instellingen > Platform > API-sleutels en maak er vervolgens een.";
+"Stored in ~/.codexbar/config.json. Metrics require Groq Enterprise Prometheus access." = "Opgeslagen in ~/.codexbar/config.json. Voor statistieken is toegang tot Groq Enterprise Prometheus vereist.";
+"Stored in ~/.codexbar/config.json. OPENAI_ADMIN_KEY is preferred; OPENAI_API_KEY still works." = "Opgeslagen in ~/.codexbar/config.json. OPENAI_ADMIN_KEY heeft de voorkeur; OPENAI_API_KEY werkt nog steeds.";
+"Stored in ~/.codexbar/config.json. Requires an Anthropic Admin API key." = "Opgeslagen in ~/.codexbar/config.json. Vereist een Anthropic Admin API-sleutel.";
+"Stored in ~/.codexbar/config.json. Used for /v1/quota-stats." = "Opgeslagen in ~/.codexbar/config.json. Gebruikt voor /v1/quota-stats.";
+"Stored in ~/.codexbar/config.json. You can also provide CODEBUFF_API_KEY or let CodexBar read ~/.config/manicode/credentials.json (created by `codebuff login`)." = "Opgeslagen in ~/.codexbar/config.json. Je kunt ook CODEBUFF_API_KEY opgeven of CodexBar ~/.config/manicode/credentials.json laten lezen (gemaakt door `codebuff login`).";
+"Stored in ~/.codexbar/config.json. You can also provide CROF_API_KEY." = "Opgeslagen in ~/.codexbar/config.json. U kunt ook CROF_API_KEY opgeven.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or ~/.local/share/kilo/auth.json (kilo.access)." = "Opgeslagen in ~/.codexbar/config.json. U kunt ook KILO_API_KEY of ~/.local/share/kilo/auth.json (kilo.access) opgeven.";
+"T3 Chat cookie" = "T3 Chat-cookie";
+"That account is no longer available in CodexBar. Refresh the account list and try again." = "Dat account is niet langer beschikbaar in CodexBar. Vernieuw de accountlijst en probeer het opnieuw.";
+"The browser login did not complete in time. Try Antigravity login again." = "De browseraanmelding is niet op tijd voltooid. Probeer Antigravity-login opnieuw.";
+"Timed out waiting for Cursor login. %@" = "Er is een time-out opgetreden tijdens het wachten op cursoraanmelding. %@";
+"Timed out waiting for Cursor login. %@ Last error: %@" = "Er is een time-out opgetreden tijdens het wachten op cursoraanmelding. %@ Laatste fout: %@";
+"Today requests" = "Vandaag verzoeken";
+"Total (30d): %@ credits" = "Totaal (30d): %@ credits";
+"Username" = "Gebruikersnaam";
+"Uses username + password to login and obtain an Oasis-Token automatically." = "Gebruikt gebruikersnaam + wachtwoord om in te loggen en automatisch een Oasis-Token te verkrijgen.";
+"Uses username + password to login and obtain an %@ automatically." = "Gebruikt gebruikersnaam + wachtwoord om in te loggen en automatisch een %@ te verkrijgen.";
+"Utilization End" = "Gebruik einde";
+"Utilization Start" = "Gebruik starten";
+"Verbosity" = "Breedsprakigheid";
+"Windsurf session JSON bundle" = "Windsurfsessie JSON-bundel";
+"Workspace ID" = "Werkruimte-ID";
+"Your StepFun platform password. Used to login and obtain a session token." = "Uw StepFun-platformwachtwoord. Wordt gebruikt om in te loggen en een sessietoken te verkrijgen.";
+"claude /login exited with status %d." = "claude /login afgesloten met status %d.";
+"codex login exited with status %d." = "codex login afgesloten met status %d.";
+"Cookie: …\n\nor paste a cURL capture from the Abacus AI dashboard" = "Cookie: …\n\nof plak een cURL-opname vanuit het Abacus AI-dashboard";
+"Cookie: …\n\nor paste the __Secure-next-auth.session-token value" = "Cookie: …\n\nof plak de __Secure-next-auth.session-token-waarde";
+"Cookie: …\n\nor paste the kimi-auth token value" = "Cookie: …\n\nof plak de kimi-auth-tokenwaarde";
+"session_id=...\n\nor paste just the session_id value" = "session_id=...\n\nof plak alleen de session_id-waarde";
+"Clear" = "Duidelijk";
+"No matching providers" = "Geen overeenkomende aanbieders";
+"Search providers" = "Zoekaanbieders";
+"language_arabic" = "العربية";
+"language_persian" = "فارسی";
+"language_thai" = "ไทย";
+"Limit Reset Credits" = "Limietresetcredits";
+"1 manual reset available" = "1 handmatige reset beschikbaar";
+"%d manual resets available" = "%d handmatige resets beschikbaar";
+"Next expires %@" = "Volgende verloopt %@";
+"Other (%d items)" = "Overig (%d onderdelen)";
+"Expand" = "Uitvouwen";
+"Collapse" = "Invouwen";
+"byte_unit_byte" = "byte";
+"byte_unit_bytes" = "bytes";
+"byte_unit_kilobyte" = "kilobyte";
+"byte_unit_kilobytes" = "kilobytes";
+"byte_unit_megabyte" = "megabyte";
+"byte_unit_megabytes" = "megabytes";
+"byte_unit_gigabyte" = "gigabyte";
+"byte_unit_gigabytes" = "gigabytes";
diff --git a/Sources/CodexBar/Resources/pl.lproj/Localizable.strings b/Sources/CodexBar/Resources/pl.lproj/Localizable.strings
new file mode 100644
index 0000000000..d4a2463cc9
--- /dev/null
+++ b/Sources/CodexBar/Resources/pl.lproj/Localizable.strings
@@ -0,0 +1,1109 @@
+/* English localization for CodexBar (base/fallback) */
+
+" providers" = " providers";
+"(System)" = "(System)";
+"30d" = "30d";
+"A managed Codex login is already running. Wait for it to finish before adding " = "Trwa już zarządzane logowanie Codex. Poczekaj na jego zakończenie, zanim dodasz ";
+"API key" = "Klucz API";
+"API region" = "Region API";
+"API token" = "Token API";
+"API tokens" = "Tokeny API";
+"About" = "O aplikacji";
+"Account" = "Konto";
+"Accounts" = "Konta";
+"Accounts subtitle" = "Podtytuł kont";
+"Active" = "Aktywne";
+"Add" = "Dodaj";
+"Add Workspace" = "Dodaj workspace";
+"Advanced" = "Zaawansowane";
+"All" = "Wszystko";
+"Always allow prompts" = "Zawsze zezwalaj na monity";
+"Animation pattern" = "Wzór animacji";
+"Antigravity login is managed in the app" = "Logowanie do Antigravity jest zarządzane w aplikacji";
+"Applies only to the Security.framework OAuth keychain reader." = "Dotyczy wyłącznie czytnika pęku kluczy OAuth Security.framework.";
+"Auto falls back to the next source if the preferred one fails." = "Automatycznie przełącza na kolejne źródło, jeśli preferowane zawiedzie.";
+"Auto uses API first, then falls back to CLI on auth failures." = "Tryb Auto najpierw używa API, a przy błędach uwierzytelniania przełącza się na CLI.";
+"Auto-detect" = "Automatyczne wykrywanie";
+"Auto-refresh is off; use the menu's Refresh command." = "Automatyczne odświeżanie jest wyłączone; użyj polecenia Odśwież w menu.";
+"Auto-refresh: hourly · Timeout: 10m" = "Automatyczne odświeżanie: co godzinę · Limit czasu: 10 min";
+"Automatic" = "Automatycznie";
+"Automatic imports browser cookies and WorkOS tokens." = "Automatycznie importuje pliki cookie przeglądarki i tokeny WorkOS.";
+"Automatic imports browser cookies and local storage tokens." = "Automatycznie importuje pliki cookie przeglądarki i tokeny z localStorage.";
+"Automatic imports browser cookies for dashboard extras." = "Automatycznie importuje pliki cookie przeglądarki dla dodatków panelu.";
+"Automatic imports browser cookies for the web API." = "Automatycznie importuje pliki cookie przeglądarki dla web API.";
+"Automatic imports browser cookies from Model Studio/Bailian." = "Automatycznie importuje pliki cookie przeglądarki z Model Studio/Bailian.";
+"Automatic imports browser cookies from admin.mistral.ai." = "Automatycznie importuje pliki cookie przeglądarki z admin.mistral.ai.";
+"Automatic imports browser cookies from opencode.ai." = "Automatycznie importuje pliki cookie przeglądarki z opencode.ai.";
+"Automatic imports browser cookies or stored sessions." = "Automatycznie importuje pliki cookie przeglądarki lub zapisane sesje.";
+"Automatic imports browser cookies." = "Automatycznie importuje pliki cookie przeglądarki.";
+"Automatically imports browser session cookie." = "Automatycznie importuje cookie sesji przeglądarki.";
+"Automatically opens CodexBar when you start your Mac." = "Automatycznie otwiera CodexBar przy uruchamianiu Maca.";
+"Automation" = "Automatyzacja";
+"Average (\\(label1) + \\(label2))" = "Średnia (\\(label1) + \\(label2))";
+"Average (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))" = "Średnia (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))";
+"Avoid Keychain prompts" = "Unikaj monitów pęku kluczy";
+"Balance" = "Saldo";
+"Battery Saver" = "Oszczędzanie baterii";
+"Bordered" = "Z obramowaniem";
+"Build" = "Wersja kompilacji";
+"Built \\(buildTimestamp)" = "Zbudowano \\(buildTimestamp)";
+"Buy Credits..." = "Kup kredyty...";
+"Buy Credits…" = "Kup kredyty…";
+"CLI paths" = "Ścieżki CLI";
+"CLI sessions" = "Sesje CLI";
+"Caches" = "Pamięci podręczne";
+"Cancel" = "Anuluj";
+"Check for Updates…" = "Sprawdź aktualizacje…";
+"Check for updates automatically" = "Sprawdzaj aktualizacje automatycznie";
+"Check if you like your agents having some fun up there." = "Sprawdź, czy lubisz, gdy twoi agenci trochę się tam bawią.";
+"Check provider status" = "Sprawdź status dostawcy";
+"Choose Codex workspace" = "Wybierz workspace Codex";
+"Choose the MiniMax host (global .io or China mainland .com)." = "Wybierz host MiniMax (.io globalny lub .com dla Chin kontynentalnych).";
+"Choose up to " = "Wybierz maksymalnie ";
+"Choose up to \\(Self.maxOverviewProviders) providers" = "Wybierz maksymalnie \\(Self.maxOverviewProviders) dostawców";
+"Choose up to \\(count) providers" = "Wybierz maksymalnie \\(count) dostawców";
+"Choose what to show in the menu bar (Pace shows usage vs. expected)." = "Wybierz, co pokazywać na pasku menu (Tempo pokazuje użycie względem oczekiwanego).";
+"Choose which Codex account CodexBar should follow." = "Wybierz, które konto Codex ma śledzić CodexBar.";
+"Choose which window drives the menu bar percent." = "Wybierz, które okno steruje procentem na pasku menu.";
+"Chrome" = "Chrome";
+"Claude CLI not found" = "Nie znaleziono Claude CLI";
+"Claude binary" = "Plik binarny Claude";
+"Claude cookies" = "Pliki cookie Claude";
+"Claude login failed" = "Logowanie do Claude nie powiodło się";
+"Claude login timed out" = "Przekroczono limit czasu logowania do Claude";
+"Close" = "Zamknij";
+"Code review" = "Przegląd kodu";
+"Codex CLI not found" = "Nie znaleziono Codex CLI";
+"Codex account login already running" = "Logowanie do konta Codex już trwa";
+"Codex binary" = "Plik binarny Codex";
+"Codex login failed" = "Logowanie do Codex nie powiodło się";
+"Codex login timed out" = "Przekroczono limit czasu logowania do Codex";
+"CodexBar Lifecycle Keepalive" = "Podtrzymanie cyklu życia CodexBar";
+"CodexBar can't show its menu bar icon" = "CodexBar nie może pokazać swojej ikony na pasku menu";
+"CodexBar could not read managed account storage. " = "CodexBar nie mógł odczytać magazynu zarządzanych kont. ";
+"Configure…" = "Skonfiguruj…";
+"Connected" = "Połączono";
+"Controls how much detail is logged." = "Określa poziom szczegółowości logowania.";
+"Cookie header" = "Nagłówek Cookie";
+"Cookie source" = "Źródło Cookie";
+"Cookie: ..." = "Cookie: ...";
+"Cookie: \\u{2026}\\\n\\\nor paste a cURL capture from the Abacus AI dashboard" = "Cookie: \\u{2026}\\\n\\\nalbo wklej przechwycony cURL z panelu Abacus AI";
+"Cookie: \\u{2026}\\\n\\\nor paste the __Secure-next-auth.session-token value" = "Cookie: \\u{2026}\\\n\\\nalbo wklej wartość __Secure-next-auth.session-token";
+"Cookie: \\u{2026}\\\n\\\nor paste the kimi-auth token value" = "Cookie: \\u{2026}\\\n\\\nalbo wklej wartość tokenu kimi-auth";
+"Cookie: …" = "Cookie: …";
+"CopilotDeviceFlow" = "Przepływ urządzenia Copilot";
+"Cost" = "Koszt";
+"Could not add Codex account" = "Nie udało się dodać konta Codex";
+"Could not open Terminal for Gemini" = "Nie udało się otworzyć Terminala dla Gemini";
+"Could not start claude /login" = "Nie udało się uruchomić `claude /login`";
+"Could not start codex login" = "Nie udało się uruchomić logowania Codex";
+"Could not switch system account" = "Nie udało się przełączyć konta systemowego";
+"Credits" = "Kredyty";
+"Individual credits" = "Kredyty indywidualne";
+"Workspace" = "Obszar roboczy";
+"Credits history" = "Historia kredytów";
+"Cursor login failed" = "Logowanie do Cursor nie powiodło się";
+"Custom" = "Niestandardowe";
+"Custom Path" = "Ścieżka niestandardowa";
+"Daily Routines" = "Codzienne rutyny";
+"Debug" = "Debugowanie";
+"Default" = "Domyślne";
+"Disable Keychain access" = "Wyłącz dostęp do pęku kluczy";
+"Disabled" = "Wyłączone";
+"Dismiss" = "Odrzuć";
+"Disconnected" = "Rozłączono";
+"Display" = "Wyświetlanie";
+"Display mode" = "Tryb wyświetlania";
+"Display reset times as absolute clock values instead of countdowns." = "Pokazuj czasy resetu jako wartości zegarowe zamiast odliczania.";
+"Done" = "Gotowe";
+"Effective PATH" = "Efektywny PATH";
+"Email" = "E-mail";
+"Enable Merge Icons to configure Overview tab providers." = "Włącz Scal ikony, aby skonfigurować dostawców zakładki Przegląd.";
+"Enable file logging" = "Włącz logowanie do pliku";
+"Enabled" = "Włączone";
+"Error" = "Błąd";
+"Error simulation" = "Symulacja błędu";
+"Expose troubleshooting tools in the Debug tab." = "Udostępnia narzędzia diagnostyczne na karcie Debug.";
+"Failed" = "Niepowodzenie";
+"False" = "Fałsz";
+"Fetch strategy attempts" = "Próby strategii pobierania";
+"Fetching" = "Pobieranie";
+"Field" = "Pole";
+"Field subtitle" = "Podtytuł pola";
+"Finish the current managed account change before switching the system account." = "Zakończ bieżącą zmianę zarządzanego konta przed przełączeniem konta systemowego.";
+"Force animation on next refresh" = "Wymuś animację przy następnym odświeżeniu";
+"Gateway region" = "Region bramy";
+"Gemini CLI not found" = "Nie znaleziono Gemini CLI";
+"Gemini/Antigravity, surfacing incidents in the icon and menu." = "Gemini/Antigravity, pokazując incydenty na ikonie i w menu.";
+"General" = "Ogólne";
+"GitHub" = "GitHub";
+"GitHub Copilot Login" = "Logowanie GitHub Copilot";
+"GitHub Login" = "Logowanie GitHub";
+"Hide details" = "Ukryj szczegóły";
+"Hide personal information" = "Ukryj dane osobowe";
+"Historical tracking" = "Śledzenie historyczne";
+"How often CodexBar polls providers in the background." = "Jak często CodexBar odpyta dostawców w tle.";
+"Inactive" = "Nieaktywne";
+"Install CLI" = "Zainstaluj CLI";
+"Install the Claude CLI (npm i -g @anthropic-ai/claude-code) and try again." = "Zainstaluj Claude CLI (`npm i -g @anthropic-ai/claude-code`) i spróbuj ponownie.";
+"Install the Codex CLI (npm i -g @openai/codex) and try again." = "Zainstaluj Codex CLI (`npm i -g @openai/codex`) i spróbuj ponownie.";
+"Install the Gemini CLI (npm i -g @google/gemini-cli) and try again." = "Zainstaluj Gemini CLI (`npm i -g @google/gemini-cli`) i spróbuj ponownie.";
+"JetBrains AI is ready" = "JetBrains AI jest gotowe";
+"JetBrains IDE" = "JetBrains IDE";
+"Keep CLI sessions alive" = "Utrzymuj sesje CLI aktywne";
+"Keyboard shortcut" = "Skrót klawiaturowy";
+"Keychain access" = "Dostęp do pęku kluczy";
+"Keychain prompt policy" = "Zasada monitów pęku kluczy";
+"Last \\(name) fetch failed:" = "Ostatnie pobranie \\(name) nie powiodło się:";
+"Last \\(self.store.metadata(for: self.provider).displayName) fetch failed:" = "Ostatnie pobranie \\(self.store.metadata(for: self.provider).displayName) nie powiodło się:";
+"Last attempt" = "Ostatnia próba";
+"Link" = "Link";
+"Loading animations" = "Animacje ładowania";
+"Loading…" = "Ładowanie…";
+"Local" = "Lokalne";
+"Logging" = "Logowanie";
+"Login failed" = "Logowanie nie powiodło się";
+"Login shell PATH (startup capture)" = "PATH powłoki logowania (przechwycony przy starcie)";
+"Login timed out" = "Przekroczono limit czasu logowania";
+"MCP details" = "Szczegóły MCP";
+"Managed Codex accounts unavailable" = "Zarządzane konta Codex są niedostępne";
+"Managed account storage is unreadable. Live account access is still available, " = "Magazyn zarządzanych kont jest nieczytelny. Dostęp do aktywnego konta nadal działa, ";
+"Manual" = "Ręcznie";
+"May your tokens never run out—keep agent limits in view." = "Niech twoje tokeny nigdy się nie skończą — miej limity agentów zawsze w zasięgu wzroku.";
+"Menu bar" = "Pasek menu";
+"Menu bar auto-shows the provider closest to its rate limit." = "Pasek menu automatycznie pokazuje dostawcę najbliżej jego limitu.";
+"Menu bar metric" = "Metryka paska menu";
+"Menu bar shows percent" = "Pasek menu pokazuje procent";
+"Menu content" = "Zawartość menu";
+"Merge Icons" = "Scal ikony";
+"Never prompt" = "Nigdy nie pytaj";
+"No" = "Nie";
+"No Codex accounts detected yet." = "Nie wykryto jeszcze żadnych kont Codex.";
+"No JetBrains IDE detected" = "Nie wykryto żadnego IDE JetBrains";
+"No cost history data." = "Brak danych historii kosztów.";
+"No data available" = "Brak dostępnych danych";
+"No data yet" = "Brak danych";
+"No enabled providers available for Overview." = "Brak włączonych dostawców dostępnych dla Przeglądu.";
+"No providers selected" = "Nie wybrano dostawców";
+"No token accounts yet." = "Brak jeszcze kont tokenów.";
+"No usage breakdown data." = "Brak danych podziału użycia.";
+"None" = "None";
+"Notifications" = "Powiadomienia";
+"Notifies when the 5-hour session quota hits 0% and when it becomes " = "Powiadamia, gdy limit 5-godzinnej sesji spadnie do 0% i gdy znów stanie się ";
+"OK" = "OK";
+"Obscure email addresses in the menu bar and menu UI." = "Ukrywa adresy e-mail na pasku menu i w interfejsie menu.";
+"Off" = "Wyłączone";
+"Offline" = "Offline";
+"On" = "On";
+"Online" = "Online";
+"Only on user action" = "Tylko po działaniu użytkownika";
+"Open" = "Otwórz";
+"Open API Keys" = "Otwórz klucze API";
+"Open Amp Settings" = "Otwórz ustawienia Amp";
+"Open Antigravity to sign in, then refresh CodexBar." = "Otwórz Antigravity, aby się zalogować, a następnie odśwież CodexBar.";
+"Open Browser" = "Otwórz przeglądarkę";
+"Open Coding Plan" = "Otwórz Coding Plan";
+"Open Console" = "Otwórz konsolę";
+"Open Dashboard" = "Otwórz panel";
+"Open Mistral Admin" = "Otwórz Mistral Admin";
+"Open Menu Bar Settings" = "Otwórz ustawienia paska menu";
+"Open Ollama Settings" = "Otwórz ustawienia Ollama";
+"Open Terminal" = "Otwórz Terminal";
+"Open Usage Page" = "Otwórz stronę użycia";
+"Open Warp API Key Guide" = "Otwórz przewodnik po kluczu API Warp";
+"Open menu" = "Otwórz menu";
+"Open token file" = "Otwórz plik tokenu";
+"OpenAI cookies" = "Pliki cookie OpenAI";
+"OpenAI web extras" = "Dodatki webowe OpenAI";
+"Option A" = "Option A";
+"Option B" = "Option B";
+"Optional override if workspace lookup fails." = "Opcjonalne nadpisanie, jeśli wyszukiwanie workspace się nie powiedzie.";
+"Options" = "Opcje";
+"Override auto-detection with a custom IDE base path" = "Nadpisz automatyczne wykrywanie niestandardową ścieżką bazową IDE";
+"Overview" = "Przegląd";
+"Overview rows always follow provider order." = "Wiersze Przeglądu zawsze podążają za kolejnością dostawców.";
+"Overview tab providers" = "Dostawcy zakładki Przegląd";
+"Paste API key…" = "Wklej klucz API…";
+"Paste API token…" = "Wklej token API…";
+"Paste key…" = "Wklej klucz…";
+"Paste sessionKey or OAuth token…" = "Wklej sessionKey lub token OAuth…";
+"Paste the Cookie header from a request to admin.mistral.ai. " = "Wklej nagłówek Cookie z żądania do admin.mistral.ai. ";
+"Paste token…" = "Wklej token…";
+"Personal" = "Osobiste";
+"Picker" = "Selektor";
+"Picker subtitle" = "Podtytuł selektora";
+"Placeholder" = "Tekst zastępczy";
+"Plan" = "Plan";
+"Play full-screen confetti when weekly usage resets." = "Odtwórz pełnoekranowe konfetti, gdy tygodniowe użycie się resetuje.";
+"Polls OpenAI/Claude status pages and Google Workspace for " = "Sprawdza strony statusu OpenAI/Claude oraz Google Workspace dla ";
+"Prevents any Keychain access while enabled." = "Blokuje wszelki dostęp do pęku kluczy, gdy opcja jest włączona.";
+"Primary (API key limit)" = "Główny (limit klucza API)";
+"Primary (\\(label))" = "Główny (\\(label))";
+"Primary (\\(metadata.sessionLabel))" = "Główny (\\(metadata.sessionLabel))";
+"Probe logs" = "Logi probe";
+"Progress bars fill as you consume quota (instead of showing remaining)." = "Paski postępu wypełniają się wraz ze zużyciem limitu (zamiast pokazywać pozostałą część).";
+"Provider" = "Dostawca";
+"Providers" = "Dostawcy";
+"Quit CodexBar" = "Zakończ CodexBar";
+"Random (default)" = "Losowo (domyślnie)";
+"Reads local usage logs. Shows today + last 30 days cost in the menu." = "Odczytuje lokalne logi użycia. Pokazuje dziś + koszty z ostatnich 30 dni w menu.";
+"Refresh" = "Odśwież";
+"Refresh cadence" = "Częstotliwość odświeżania";
+"Remote" = "Zdalne";
+"Remove" = "Usuń";
+"Remove Codex account?" = "Usunąć konto Codex?";
+"Remove \\(account.email) from CodexBar? Its managed Codex home will be deleted." = "Usunąć \\(account.email) z CodexBar? Jego zarządzony katalog domowy Codex zostanie usunięty.";
+"Remove \\(email) from CodexBar? Its managed Codex home will be deleted." = "Usunąć \\(email) z CodexBar? Jego zarządzony katalog domowy Codex zostanie usunięty.";
+"Remove selected account" = "Usuń wybrane konto";
+"Replace critter bars with provider branding icons and a percentage." = "Zastąp paski stworzonkami ikonami marek dostawców i wartością procentową.";
+"Replay selected animation" = "Odtwórz wybraną animację ponownie";
+"Requires authentication via GitHub Device Flow." = "Wymaga uwierzytelnienia przez GitHub Device Flow.";
+"Resets: \\(reset)" = "Reset: \\(reset)";
+"Rolling five-hour limit" = "Ruchomy limit pięciogodzinny";
+"Search hourly" = "Szukaj co godzinę";
+"Secondary (\\(label))" = "Wtórny (\\(label))";
+"Secondary (\\(metadata.weeklyLabel))" = "Wtórny (\\(metadata.weeklyLabel))";
+"Select a provider" = "Wybierz dostawcę";
+"Select the IDE to monitor" = "Wybierz IDE do monitorowania";
+"Session quota notifications" = "Powiadomienia o limicie sesji";
+"Session tokens" = "Tokeny sesji";
+"Settings" = "Ustawienia";
+"Show Codex Credits and Claude Extra usage sections in the menu." = "Pokazuj w menu sekcje Codex Credits i Claude Extra usage.";
+"Show Debug Settings" = "Pokaż ustawienia debugowania";
+"Show all token accounts" = "Pokaż wszystkie konta tokenów";
+"Show cost summary" = "Pokaż podsumowanie kosztów";
+"Show credits + extra usage" = "Pokaż kredyty + dodatkowe użycie";
+"Show details" = "Pokaż szczegóły";
+"Show most-used provider" = "Pokaż najczęściej używanego dostawcę";
+"Show provider icons in the switcher (otherwise show a weekly progress line)." = "Pokazuj ikony dostawców w przełączniku (w przeciwnym razie linię postępu tygodniowego).";
+"Show reset time as clock" = "Pokaż czas resetu jako godzinę";
+"Show usage as used" = "Pokazuj użycie jako wykorzystane";
+"Sign in via button below" = "Zaloguj się przyciskiem poniżej";
+"Skip teardown between probes (debug-only)." = "Pomiń sprzątanie między probe'ami (tylko do debugowania).";
+"Stack token accounts in the menu (otherwise show an account switcher bar)." = "Układa konta tokenów w stos w menu (w przeciwnym razie pokazuje pasek przełączania kont).";
+"Start at Login" = "Uruchamiaj przy logowaniu";
+"Status" = "Status";
+"Store Claude sessionKey cookies or OAuth access tokens." = "Przechowuj pliki cookie sessionKey Claude lub tokeny dostępu OAuth.";
+"Store multiple Abacus AI Cookie headers." = "Przechowuj wiele nagłówków Cookie dla Abacus AI.";
+"Store multiple Augment Cookie headers." = "Przechowuj wiele nagłówków Cookie dla Augment.";
+"Store multiple Cursor Cookie headers." = "Przechowuj wiele nagłówków Cookie dla Cursor.";
+"Store multiple Factory Cookie headers." = "Przechowuj wiele nagłówków Cookie dla Factory.";
+"Store multiple MiniMax Cookie headers." = "Przechowuj wiele nagłówków Cookie dla MiniMax.";
+"Store multiple Mistral Cookie headers." = "Przechowuj wiele nagłówków Cookie dla Mistral.";
+"Store multiple Ollama Cookie headers." = "Przechowuj wiele nagłówków Cookie dla Ollama.";
+"Store multiple OpenCode Cookie headers." = "Przechowuj wiele nagłówków Cookie dla OpenCode.";
+"Store multiple OpenCode Go Cookie headers." = "Przechowuj wiele nagłówków Cookie dla OpenCode Go.";
+"Stored in the CodexBar config file." = "Przechowywane w pliku konfiguracyjnym CodexBar.";
+"Stored in ~/.codexbar/config.json. " = "Przechowywane w ~/.codexbar/config.json. ";
+"Stored in ~/.codexbar/config.json. Generate one at kimi-k2.ai." = "Przechowywane w ~/.codexbar/config.json. Wygeneruj jeden na kimi-k2.ai.";
+"Stored in ~/.codexbar/config.json. Paste the key from the Synthetic dashboard." = "Przechowywane w ~/.codexbar/config.json. Wklej klucz z panelu Synthetic.";
+"Stored in ~/.codexbar/config.json. Paste your Coding Plan API key from Model Studio." = "Przechowywane w ~/.codexbar/config.json. Wklej klucz API Coding Plan z Model Studio.";
+"Stored in ~/.codexbar/config.json. Paste your MiniMax API key." = "Przechowywane w ~/.codexbar/config.json. Wklej swój klucz API MiniMax.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or " = "Przechowywane w ~/.codexbar/config.json. Możesz też podać KILO_API_KEY lub ";
+"Stores local Codex usage history (8 weeks) to personalize Pace predictions." = "Przechowuje lokalną historię użycia Codex (8 tygodni), aby personalizować prognozy Tempo.";
+"Subscription Utilization" = "Wykorzystanie subskrypcji";
+"Surprise me" = "Zaskocz mnie";
+"Switcher shows icons" = "Przełącznik pokazuje ikony";
+"Symlink CodexBarCLI to /usr/local/bin and /opt/homebrew/bin as codexbar." = "Dowiąż symbolicznie CodexBarCLI do /usr/local/bin i /opt/homebrew/bin jako codexbar.";
+"System" = "System";
+"Temporarily shows the loading animation after the next refresh." = "Tymczasowo pokazuje animację ładowania po następnym odświeżeniu.";
+"terminal_app_subtitle" = "Terminal używany przez akcję Otwórz terminal";
+"terminal_app_title" = "Domyślny terminal";
+"Tertiary (\\(label))" = "Trzeciorzędny (\\(label))";
+"Tertiary (\\(tertiaryTitle))" = "Trzeciorzędny (\\(tertiaryTitle))";
+"The default Codex account on this Mac." = "Domyślne konto Codex na tym Macu.";
+"Toggle" = "Przełącznik";
+"Toggle subtitle" = "Podtytuł przełącznika";
+"Token" = "Token";
+"Trigger the menu bar menu from anywhere." = "Wywołaj menu paska menu z dowolnego miejsca.";
+"True" = "Prawda";
+"Twitter" = "Twitter";
+"Unsupported" = "Nieobsługiwane";
+"Update Channel" = "Kanał aktualizacji";
+"Updated" = "Zaktualizowano";
+"Updates unavailable in this build." = "Aktualizacje niedostępne w tej wersji.";
+"Usage" = "Zużycie";
+"Usage breakdown" = "Podział użycia";
+"Usage history (30 days)" = "Historia użycia (30 dni)";
+"Usage source" = "Źródło użycia";
+"Use BigModel for the China mainland endpoints (open.bigmodel.cn)." = "Użyj BigModel dla punktów końcowych Chin kontynentalnych (open.bigmodel.cn).";
+"Use a single menu bar icon with a provider switcher." = "Używaj jednej ikony paska menu z przełącznikiem dostawcy.";
+"Use international or China mainland console gateways for quota fetches." = "Używaj międzynarodowych lub chińskich bram konsoli do pobierania limitów.";
+"Version" = "Wersja";
+"Version \\(self.versionString)" = "Wersja \\(self.versionString)";
+"Version \\(version)" = "Wersja \\(version)";
+"Version \\(versionString)" = "Wersja \\(versionString)";
+"Vertex AI Login" = "Logowanie Vertex AI";
+"Wait for the current managed Codex login to finish before adding another account." = "Poczekaj, aż bieżące zarządzane logowanie Codex się zakończy, zanim dodasz kolejne konto.";
+"Waiting for Authentication..." = "Oczekiwanie na uwierzytelnienie...";
+"Website" = "Strona internetowa";
+"Weekly limit confetti" = "Konfetti limitu tygodniowego";
+"Weekly token limit" = "Tygodniowy limit tokenów";
+"Weekly usage" = "Tygodniowe użycie";
+"Weekly usage unavailable for this account." = "Dane tygodniowego użycia są niedostępne dla tego konta.";
+"Window: \\(window)" = "Okno: \\(window)";
+"Write logs to \\(self.fileLogPath) for debugging." = "Zapisuj logi do \\(self.fileLogPath) na potrzeby debugowania.";
+"Yes" = "Tak";
+"\\(detail.modelCode): \\(usage)" = "\\(detail.modelCode): \\(usage)";
+"\\(name): \\(truncated)" = "\\(name): \\(truncated)";
+"\\(name): \\(updated) · 30d \\(cost)" = "\\(name): \\(updated) · 30d \\(cost)";
+"\\(name): fetching…\\(elapsed)" = "\\(name): pobieranie…\\(elapsed)";
+"\\(name): last attempt \\(when)" = "\\(name): ostatnia próba \\(when)";
+"\\(name): no data yet" = "\\(name): brak danych";
+"\\(name): unsupported" = "\\(name): nieobsługiwane";
+"all browsers" = "wszystkie przeglądarki";
+"available again." = "znów dostępny.";
+"built_format" = "Zbudowano %@";
+"copilot_complete_in_browser" = "Dokończ logowanie w przeglądarce.";
+"copilot_device_code" = "Kod urządzenia skopiowano do schowka: %1$@\n\nZweryfikuj na: %2$@";
+"copilot_device_code_copied" = "Kod urządzenia skopiowano.";
+"copilot_verify_at" = "Zweryfikuj na %@";
+"copilot_waiting_text" = "Dokończ logowanie w przeglądarce.\nTo okno zamknie się automatycznie po zakończeniu logowania.";
+"copilot_window_closes_auto" = "To okno zamknie się automatycznie po zakończeniu logowania.";
+"cost_status_error" = "%1$@: %2$@";
+"cost_status_fetching" = "%1$@: pobieranie… %2$@";
+"cost_status_last_attempt" = "%1$@: ostatnia próba %2$@";
+"cost_status_no_data" = "%@: brak danych";
+"cost_status_snapshot" = "%1$@: %2$@ · %3$@ %4$@";
+"cost_status_unsupported" = "%@: nieobsługiwane";
+"credits_remaining" = "Kredyty: %@";
+"cursor_on_demand" = "Na żądanie: %@";
+"cursor_on_demand_with_limit" = "Na żądanie: %1$@ / %2$@";
+"extra_usage_format" = "Dodatkowe użycie: %1$@ / %2$@";
+"jetbrains_detected_generate" = "Wykryto: %@. Użyj raz asystenta AI, aby wygenerować dane limitu, a następnie odśwież CodexBar.";
+"jetbrains_detected_select" = "Wykryto: %@. Wybierz preferowane IDE w Ustawieniach, a następnie odśwież CodexBar.";
+"last_fetch_failed_with_provider" = "Ostatnie pobranie %@ nie powiodło się:";
+"last_spend" = "Ostatni wydatek: %@";
+"mcp_model_usage" = "%1$@: %2$@";
+"mcp_resets" = "Reset: %@";
+"mcp_window" = "Okno: %@";
+"metric_average" = "Średnia (%1$@ + %2$@)";
+"metric_primary" = "Główny (%@)";
+"metric_secondary" = "Wtórny (%@)";
+"metric_tertiary" = "Trzeciorzędny (%@)";
+"multiple_workspaces_found" = "CodexBar znalazł wiele workspace dla %@. Wybierz workspace do dodania.";
+"ory_session_…=…; csrftoken=…" = "ory_session_…=…; csrftoken=…";
+"overview_choose_providers" = "Wybierz maksymalnie %@ dostawców";
+"remove_account_message" = "Usunąć %@ z CodexBar? Jego zarządzony katalog domowy Codex zostanie usunięty.";
+"version_format" = "Wersja %@";
+"vertex_ai_login_instructions" = "Aby śledzić użycie Vertex AI, uwierzytelnij się w Google Cloud.\n\n1. Otwórz Terminal\n2. Uruchom: gcloud auth application-default login\n3. Postępuj zgodnie z instrukcjami w przeglądarce, aby się zalogować\n4. Ustaw projekt: gcloud config set project PROJECT_ID\n\nOtworzyć teraz Terminal?";
+"workspaceID is set but only opencode, opencodego, and deepgram support workspaceID." = "Ustawiono `workspaceID`, ale obsługują go tylko opencode, opencodego i deepgram.";
+"© 2026 Peter Steinberger. MIT License." = "© 2026 Peter Steinberger. MIT License.";
+
+/* General Pane */
+"section_system" = "System";
+"section_usage" = "Zużycie";
+"section_automation" = "Automatyzacja";
+"language_title" = "Język";
+"language_subtitle" = "Zmień język interfejsu. Aby zmiana zaczęła w pełni obowiązywać, uruchom aplikację ponownie.";
+"language_system" = "System";
+"language_english" = "English";
+"language_spanish" = "Español";
+"language_catalan" = "Català";
+"language_chinese_simplified" = "简体中文";
+"language_chinese_traditional" = "繁體中文";
+"language_portuguese_brazilian" = "Português (Brasil)";
+"language_german" = "Niemiecki";
+"language_swedish" = "Svenska";
+"language_french" = "Francuski";
+"language_dutch" = "Niderlandzki";
+"language_ukrainian" = "Ukraiński";
+"language_vietnamese" = "Wietnamski";
+"language_italian" = "Włoski";
+"language_indonesian" = "Indonezyjski";
+"language_polish" = "Polski";
+"language_japanese" = "Japoński";
+"language_korean" = "Koreański";
+"language_turkish" = "Turecki";
+"start_at_login_title" = "Uruchamiaj przy logowaniu";
+"start_at_login_subtitle" = "Automatycznie uruchamia CodexBar podczas startu Maca.";
+"show_cost_summary" = "Pokaż podsumowanie kosztów";
+"show_cost_summary_subtitle" = "Odczytuje lokalne logi użycia. Pokazuje dziś + wybrany zakres historii w menu.";
+"cost_history_days_title" = "Zakres historii: %d dni";
+"cost_auto_refresh_info" = "Auto-odświeżanie: co godzinę · Limit czasu: 10 min";
+"refresh_cadence_title" = "Częstotliwość odświeżania";
+"refresh_cadence_subtitle" = "Jak często CodexBar odpyta dostawców w tle.";
+"manual_refresh_hint" = "Auto-odświeżanie jest wyłączone; użyj polecenia Odśwież w menu.";
+"check_provider_status_title" = "Sprawdzaj status dostawców";
+"check_provider_status_subtitle" = "Sprawdza status OpenAI/Claude oraz Google Workspace dla Gemini/Antigravity i pokazuje incydenty na ikonie i w menu.";
+"session_quota_notifications_title" = "Powiadomienia o limicie sesji";
+"session_quota_notifications_subtitle" = "Powiadamia, gdy limit 5-godzinnej sesji spadnie do 0% i gdy znów będzie dostępny.";
+"quota_warning_notifications_title" = "Powiadomienia o ostrzeżeniach limitu";
+"quota_warning_notifications_subtitle" = "Ostrzega, gdy pozostały limit sesji lub tygodnia przekroczy skonfigurowane progi.";
+"quota_warnings_title" = "Ostrzeżenia limitu";
+"quota_warning_session" = "sesja";
+"quota_warning_session_capitalized" = "Sesja";
+"quota_warning_weekly" = "tydzień";
+"quota_warning_weekly_capitalized" = "Tydzień";
+"quota_warning_notification_title" = "Niski limit %1$@ (%2$@)";
+"quota_warning_notification_body" = "Pozostało %1$@. Osiągnięto próg ostrzeżenia %2$d%% dla %3$@.";
+"quota_warning_notification_body_with_account" = "Konto %1$@. Pozostało %2$@. Osiągnięto próg ostrzeżenia %3$d%% dla %4$@.";
+"session_depleted_notification_title" = "Wyczerpano limit sesji (%@)";
+"session_depleted_notification_body" = "Pozostało 0%. Powiadomimy, gdy limit będzie ponownie dostępny.";
+"session_restored_notification_title" = "Przywrócono limit sesji (%@)";
+"session_restored_notification_body" = "Limit sesji jest ponownie dostępny.";
+"quota_warning_warn_at" = "Ostrzegaj przy";
+"quota_warning_global_threshold_subtitle" = "Procent pozostałego limitu dla okien sesji i tygodnia, chyba że dostawca ma nadpisanie.";
+"quota_warning_sound" = "Odtwarzaj dźwięk powiadomienia";
+"quota_warning_provider_inherits" = "Używa globalnych ustawień ostrzeżeń limitu, chyba że to okno jest tutaj dostosowane.";
+"quota_warning_customize_thresholds" = "Dostosuj progi dla %@";
+"quota_warning_enable_warnings" = "Włącz ostrzeżenia dla %@";
+"quota_warning_window_warn_at" = "%@ — ostrzegaj przy";
+"quota_warning_off" = "Wyłączone";
+"quota_warning_inherited" = "Dziedziczone: %@";
+"quota_warning_depleted_only" = "tylko wyczerpanie";
+"quota_warning_upper" = "Górny";
+"quota_warning_lower" = "Dolny";
+"apply" = "Zastosuj";
+"quit_app" = "Zakończ aplikację";
+
+/* Tab titles */
+"tab_general" = "Ogólne";
+"tab_providers" = "Dostawcy";
+"tab_display" = "Wygląd";
+"tab_advanced" = "Zaawansowane";
+"tab_about" = "O aplikacji";
+"tab_debug" = "Debugowanie";
+
+/* Providers Pane */
+"select_a_provider" = "Wybierz dostawcę";
+"cancel" = "Anuluj";
+"last_fetch_failed" = "ostatnie pobranie nieudane";
+"usage_not_fetched_yet" = "dane użycia nie zostały jeszcze pobrane";
+"managed_account_storage_unreadable" = "Magazyn zarządzanych kont jest nieczytelny. Dostęp do aktywnego konta nadal działa, ale dodawanie, ponowne uwierzytelnianie i usuwanie zarządzanych kont są wyłączone do czasu naprawy magazynu.";
+"remove_codex_account_title" = "Usunąć konto Codex?";
+"remove" = "Usuń";
+"managed_login_already_running" = "Trwa już zarządzane logowanie Codex. Poczekaj na zakończenie przed dodaniem lub ponowną autoryzacją kolejnego konta.";
+"managed_login_failed" = "Zarządzane logowanie Codex nie zostało ukończone. Sprawdź, czy `codex --version` działa w Terminalu. Jeśli macOS zablokował `codex` lub przeniósł go do Kosza, usuń stare duplikaty instalacji, uruchom `npm install -g --include=optional @openai/codex@latest`, a potem spróbuj ponownie.";
+"codex_login_output" = "wynik logowania codex:";
+"managed_login_missing_email" = "Logowanie Codex zakończone, ale brak adresu e-mail konta. Spróbuj ponownie po potwierdzeniu pełnego zalogowania.";
+"login_success_notification_title" = "Logowanie %@ zakończone powodzeniem";
+"login_success_notification_body" = "Możesz wrócić do aplikacji; uwierzytelnianie zostało zakończone.";
+"workspace_selection_cancelled" = "CodexBar wykrył wiele workspace, ale nie wybrano żadnego.";
+"unsafe_managed_home" = "CodexBar odmówił zmiany nieoczekiwanej ścieżki zarządzanego katalogu domowego: %@";
+"menu_bar_metric_title" = "Metryka paska menu";
+"menu_bar_metric_subtitle" = "Wybierz metrykę pokazywaną obok ikony na pasku menu.";
+"menu_bar_metric_subtitle_deepseek" = "Pokazuje saldo DeepSeek na pasku menu.";
+"menu_bar_metric_subtitle_moonshot" = "Pokazuje saldo API Moonshot / Kimi na pasku menu.";
+"menu_bar_metric_subtitle_mistral" = "Pokazuje wydatki Mistral API z bieżącego miesiąca na pasku menu.";
+"menu_bar_metric_subtitle_kimik2" = "Pokazuje kredyty klucza API Kimi K2 na pasku menu.";
+"automatic" = "Automatycznie";
+"primary_api_key_limit" = "Główny (limit klucza API)";
+
+/* Display Pane */
+"section_menu_bar" = "Pasek menu";
+"merge_icons_title" = "Scal ikony";
+"merge_icons_subtitle" = "Używaj jednej ikony paska menu z przełącznikiem dostawcy.";
+"switcher_shows_icons_title" = "Przełącznik pokazuje ikony";
+"switcher_shows_icons_subtitle" = "Pokazuj ikony dostawców w przełączniku (w przeciwnym razie linię postępu tygodniowego).";
+"show_most_used_provider_title" = "Pokaż najczęściej używanego dostawcę";
+"show_most_used_provider_subtitle" = "Pasek menu automatycznie pokazuje dostawcę najbliżej limitu.";
+"menu_bar_shows_percent_title" = "Pokaż procent na pasku menu";
+"menu_bar_shows_percent_subtitle" = "Pokazuje procent zużycia/pozostałego limitu obok ikony.";
+"hide_critters_title" = "Ukryj stworki";
+"hide_critters_subtitle" = "Pokaż zwykłe paski miernika bez twarzy i ozdób.";
+"display_mode_title" = "Tryb wyświetlania";
+"display_mode_subtitle" = "Wybierz, co pokazywać na pasku menu (Tempo pokazuje użycie względem oczekiwanego).";
+"section_menu_content" = "Zawartość menu";
+"show_usage_as_used_title" = "Pokazuj zużycie jako wykorzystane";
+"show_usage_as_used_subtitle" = "Zamiast pozostałego limitu pokazuje wartość już wykorzystaną.";
+"show_quota_warning_markers_title" = "Pokaż znaczniki ostrzeżeń limitu";
+"show_quota_warning_markers_subtitle" = "Rysuje znaczniki progów na paskach użycia, gdy skonfigurowano ostrzeżenia limitu.";
+"weekly_progress_work_days_title" = "Dni robocze postępu tygodniowego";
+"weekly_progress_work_days_subtitle" = "Rysuje znaczniki granic dni na tygodniowych paskach użycia.";
+"show_reset_time_as_clock_title" = "Pokaż czas resetu jako godzinę";
+"show_reset_time_as_clock_subtitle" = "Pokazuje reset jako godzinę zegarową zamiast względnego czasu.";
+"show_provider_changelog_links_title" = "Pokaż linki do changelogów dostawców";
+"show_provider_changelog_links_subtitle" = "Dodaje linki do informacji o wydaniach dla obsługiwanych dostawców CLI w menu.";
+"show_credits_extra_usage_title" = "Pokaż kredyty + dodatkowe użycie";
+"show_credits_extra_usage_subtitle" = "Pokazuje sekcje Codex Credits i Claude Extra usage w menu.";
+"show_all_token_accounts_title" = "Pokaż wszystkie konta tokenów";
+"show_all_token_accounts_subtitle" = "Układa konta tokenów w stos w menu (w przeciwnym razie pokazuje pasek przełączania kont).";
+"multi_account_layout_title" = "Układ wielu kont";
+"multi_account_layout_subtitle" = "Wybierz przełączanie segmentowe kont lub ułożone karty kont.";
+"multi_account_layout_segmented" = "Segmentowy";
+"multi_account_layout_stacked" = "Ułożony";
+"overview_tab_providers_title" = "Dostawcy zakładki Przegląd";
+"configure" = "Skonfiguruj…";
+"overview_enable_merge_icons_hint" = "Włącz Scal ikony, aby skonfigurować dostawców zakładki Przegląd.";
+"overview_no_providers_hint" = "Brak włączonych dostawców dla Przeglądu.";
+"overview_rows_follow_order" = "Wiersze Przeglądu zawsze podążają za kolejnością dostawców.";
+"overview_no_providers_selected" = "Nie wybrano dostawców";
+
+/* Advanced Pane */
+"section_keyboard_shortcut" = "Skrót klawiaturowy";
+"open_menu_shortcut_title" = "Skrót otwierania menu";
+"open_menu_shortcut_subtitle" = "Skrót klawiaturowy do otwierania menu CodexBar.";
+"install_cli" = "Zainstaluj CLI";
+"install_cli_subtitle" = "Utwórz dowiązanie symboliczne CodexBarCLI do /usr/local/bin i /opt/homebrew/bin jako codexbar.";
+"cli_not_found" = "Nie znaleziono CodexBarCLI w pakiecie aplikacji.";
+"no_writable_bin_dirs" = "Nie znaleziono zapisywalnych katalogów bin.";
+"show_debug_settings_title" = "Pokaż ustawienia debugowania";
+"show_debug_settings_subtitle" = "Pokazuje dodatkowe ustawienia debugowania i diagnostyki.";
+"surprise_me_title" = "Zaskocz mnie";
+"surprise_me_subtitle" = "Sprawdź, czy lubisz, gdy twoi agenci trochę się tam bawią.";
+"weekly_limit_confetti_title" = "Konfetti limitu tygodniowego";
+"weekly_limit_confetti_subtitle" = "Odtwórz pełnoekranowe konfetti, gdy tygodniowe użycie się resetuje.";
+"hide_personal_info_title" = "Ukryj dane osobowe";
+"hide_personal_info_subtitle" = "Ukrywa adresy e-mail na pasku menu i w interfejsie menu.";
+"show_provider_storage_usage_title" = "Pokaż użycie dysku dostawców";
+"show_provider_storage_usage_subtitle" = "Pokazuje lokalne zużycie dysku w menu. Skanuje znane ścieżki dostawców w tle.";
+"section_keychain_access" = "Dostęp do pęku kluczy";
+"keychain_access_caption" = "Wyłącz wszystkie odczyty i zapisy pęku kluczy. Użyj tego, jeśli macOS nadal pyta o „Chrome/Brave/Edge Safe Storage” nawet po kliknięciu Zawsze zezwalaj. Import plików cookie przeglądarki będzie niedostępny, gdy opcja jest włączona; wklejaj nagłówki Cookie ręcznie w Dostawcach. OAuth Claude/Codex przez CLI nadal działa.";
+"disable_keychain_access_title" = "Wyłącz dostęp do pęku kluczy";
+"disable_keychain_access_subtitle" = "Blokuje wszelki dostęp do pęku kluczy, gdy opcja jest włączona.";
+
+/* About Pane */
+"about_tagline" = "Niech twoje tokeny nigdy się nie skończą — miej limity agentów zawsze na oku.";
+"link_github" = "GitHub";
+"link_website" = "Strona internetowa";
+"link_twitter" = "Twitter";
+"link_email" = "E-mail";
+"check_updates_auto" = "Sprawdzaj aktualizacje automatycznie";
+"update_channel" = "Kanał aktualizacji";
+"check_for_updates" = "Sprawdź aktualizacje…";
+"updates_unavailable" = "Aktualizacje niedostępne w tej wersji.";
+"copyright" = "© 2026 Peter Steinberger. Licencja MIT.";
+
+/* Debug Pane */
+"section_logging" = "Logowanie";
+"enable_file_logging" = "Włącz logowanie do pliku";
+"enable_file_logging_subtitle" = "Zapisuj logi do %@ na potrzeby debugowania.";
+"verbosity_title" = "Szczegółowość";
+"verbosity_subtitle" = "Określa poziom szczegółowości logowania.";
+"open_log_file" = "Otwórz plik logu";
+"force_animation_next_refresh" = "Wymuś animację przy następnym odświeżeniu";
+"force_animation_next_refresh_subtitle" = "Tymczasowo pokazuje animację ładowania po następnym odświeżeniu.";
+"section_loading_animations" = "Animacje ładowania";
+"loading_animations_caption" = "Wybierz wzór i odtwórz go ponownie na pasku menu. „Losowo” zachowuje obecne działanie.";
+"animation_random_default" = "Losowo (domyślnie)";
+"replay_selected_animation" = "Odtwórz wybraną animację ponownie";
+"blink_now" = "Mignij teraz";
+"section_probe_logs" = "Logi probe";
+"probe_logs_caption" = "Pobiera najnowszy wynik probe do debugowania; Kopiuj zachowuje pełną treść.";
+"fetch_log" = "Pobierz log";
+"copy" = "Kopiuj";
+"save_to_file" = "Zapisz do pliku";
+"load_parse_dump" = "Wczytaj zrzut parsowania";
+"rerun_provider_autodetect" = "Uruchom ponownie automatyczne wykrywanie dostawcy";
+"loading" = "Ładowanie…";
+"no_log_yet_fetch" = "Brak logu. Pobierz, aby wczytać.";
+"section_fetch_strategy" = "Strategia pobierania";
+"fetch_strategy_caption" = "Ostatnie decyzje i błędy potoku pobierania dla dostawcy.";
+"section_openai_cookies" = "Ciasteczka OpenAI";
+"openai_cookies_caption" = "Logi importu ciasteczek + zrzutu WebKit z ostatniej próby odczytu ciasteczek OpenAI.";
+"no_log_yet" = "Brak logu. Zaktualizuj ciasteczka OpenAI w Dostawcy → Codex, aby uruchomić import.";
+"section_caches" = "Pamięci podręczne";
+"caches_caption" = "Wyczyść zapisane wyniki skanowania kosztów lub pamięci podręczne plików cookie przeglądarki.";
+"clear_cookie_cache" = "Wyczyść pamięć podręczną cookie";
+"clear_cost_cache" = "Wyczyść pamięć podręczną kosztów";
+"section_notifications" = "Powiadomienia";
+"notifications_caption" = "Wyzwala testowe powiadomienia dla 5-godzinnego okna sesji (wyczerpanie/przywrócenie).";
+"post_depleted" = "Wyślij wyczerpanie";
+"post_restored" = "Wyślij przywrócenie";
+"section_cli_sessions" = "Sesje CLI";
+"cli_sessions_caption" = "Utrzymuj sesje CLI Codex/Claude aktywne po probe. Domyślnie kończą się po przechwyceniu danych.";
+"keep_cli_sessions_alive" = "Utrzymuj sesje CLI aktywne";
+"keep_cli_sessions_alive_subtitle" = "Pomiń sprzątanie między probe'ami (tylko do debugowania).";
+"reset_cli_sessions" = "Zresetuj sesje CLI";
+"section_error_simulation" = "Symulacja błędów";
+"error_simulation_caption" = "Wstrzykuje fałszywy komunikat błędu do karty menu na potrzeby testów układu.";
+"set_menu_error" = "Ustaw błąd menu";
+"clear_menu_error" = "Wyczyść błąd menu";
+"set_cost_error" = "Ustaw błąd kosztów";
+"clear_cost_error" = "Wyczyść błąd kosztów";
+"section_cli_paths" = "Ścieżki CLI";
+"cli_paths_caption" = "Rozpoznany plik binarny Codex i warstwy PATH; przechwycony PATH logowania przy starcie (krótki limit czasu).";
+"codex_binary" = "Plik binarny Codex";
+"claude_binary" = "Plik binarny Claude";
+"effective_path" = "Efektywny PATH";
+"unavailable" = "Niedostępne";
+"login_shell_path" = "PATH powłoki logowania (przechwycony przy starcie)";
+"cleared" = "Wyczyszczono.";
+"no_fetch_attempts" = "Brak prób pobrania.";
+"macOS Tahoe can block menu bar apps in System Settings → Menu Bar → Allow in the Menu Bar. CodexBar is running, but macOS may be hiding its icon. Open Menu Bar settings and turn CodexBar on." = "macOS Tahoe can block menu bar apps in System Settings → Menu Bar → Allow in the Menu Bar. CodexBar is running, but macOS may be hiding its icon. Open Menu Bar settings and turn CodexBar on.";
+
+/* Metric preferences */
+"metric_pref_automatic" = "Automatycznie";
+"metric_pref_primary" = "Główny";
+"metric_pref_secondary" = "Wtórny";
+"metric_pref_tertiary" = "Trzeciorzędny";
+"metric_pref_extra_usage" = "Dodatkowe użycie";
+"metric_pref_average" = "Średnia";
+"metric_mistral_payg" = "Pay-as-you-go";
+"metric_mistral_monthly_plan" = "Monthly Plan";
+
+/* Display modes */
+"display_mode_percent" = "Procent";
+"display_mode_pace" = "Tempo";
+"display_mode_both" = "Oba";
+"display_mode_reset_time" = "Godzina resetu";
+"display_mode_percent_desc" = "Pokaż procent pozostałego/wykorzystanego limitu (np. 45%)";
+"display_mode_pace_desc" = "Pokaż wskaźnik tempa (np. +5%)";
+"display_mode_both_desc" = "Pokaż jednocześnie procent i tempo (np. 45% · +5%)";
+"display_mode_reset_time_desc" = "Pokaż godzinę resetu dla wybranej metryki (np. ↻ 15:56)";
+
+/* Provider status */
+"status_operational" = "Operacyjne";
+"status_partial_outage" = "Częściowa awaria";
+"status_major_outage" = "Poważna awaria";
+"status_critical_issue" = "Krytyczny problem";
+"status_maintenance" = "Prace serwisowe";
+"status_unknown" = "Nieznany status";
+
+/* Refresh frequency */
+"refresh_manual" = "Ręcznie";
+"refresh_1min" = "Co 1 min";
+"refresh_2min" = "Co 2 min";
+"refresh_5min" = "Co 5 min";
+"refresh_15min" = "Co 15 min";
+"refresh_30min" = "Co 30 min";
+
+/* Additional keys */
+"not_found" = "Nie znaleziono";
+
+/* Cost estimation */
+"cost_header_estimated" = "Koszt (szacowany)";
+"cost_estimate_hint" = "Oszacowano na podstawie lokalnych logów · może różnić się od rachunku";
+"No JetBrains IDE with AI Assistant detected. Install a JetBrains IDE and enable AI Assistant." = "Nie wykryto IDE JetBrains z AI Assistant. Zainstaluj IDE JetBrains i włącz AI Assistant.";
+"OpenRouter API token not configured. Set OPENROUTER_API_KEY environment variable or configure in Settings." = "Token API OpenRouter nie jest skonfigurowany. Ustaw zmienną środowiskową OPENROUTER_API_KEY albo skonfiguruj go w Ustawieniach.";
+"z.ai API token not found. Set apiKey in ~/.codexbar/config.json or Z_AI_API_KEY." = "Nie znaleziono tokenu API z.ai. Ustaw `apiKey` w ~/.codexbar/config.json albo Z_AI_API_KEY.";
+"Missing DeepSeek API key." = "Brakuje klucza API DeepSeek.";
+"%@ is unavailable in the current environment." = "%@ jest niedostępne w bieżącym środowisku.";
+"All Systems Operational" = "Wszystkie systemy działają";
+"Last 30 days" = "Ostatnie 30 dni";
+"Last 30 days:" = "Ostatnie 30 dni:";
+"This month" = "Ten miesiąc";
+"Store multiple OpenAI API keys." = "Przechowuj wiele kluczy API OpenAI.";
+"Admin API key" = "Klucz API administratora";
+"Open billing" = "Otwórz rozliczenia";
+"Google accounts" = "Konta Google";
+"Store multiple Antigravity Google OAuth accounts for quick switching." = "Przechowuj wiele kont Google OAuth Antigravity, aby szybko je przełączać.";
+"Add Google Account" = "Dodaj konto Google";
+"Open Token Plan" = "Otwórz Token Plan";
+"Text Generation" = "Generowanie tekstu";
+"Text to Speech" = "Synteza mowy";
+"Music Generation" = "Generowanie muzyki";
+"Image Generation" = "Generowanie obrazów";
+"No local data found" = "Nie znaleziono danych lokalnych";
+"Credits unavailable; keep Codex running to refresh." = "Kredyty są niedostępne; pozostaw Codex uruchomiony, aby je odświeżyć.";
+"No available fetch strategy for minimax." = "Brak dostępnej strategii pobierania dla minimax.";
+"No Cursor session found. Please log in to cursor.com in Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX, or Edge Canary. If you use Safari, grant CodexBar Full Disk Access in System Settings ▸ Privacy & Security. You can also sign in to Cursor from the CodexBar menu (Add / switch account)." = "Nie znaleziono sesji Cursor. Zaloguj się do cursor.com w Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX lub Edge Canary. Jeśli używasz Safari, przyznaj CodexBar pełny dostęp do dysku w Ustawieniach systemowych ▸ Prywatność i bezpieczeństwo. Możesz też zalogować się do Cursor z menu CodexBar (Dodaj / przełącz konto).";
+"No OpenCode session cookies found in browsers." = "Nie znaleziono w przeglądarkach plików cookie sesji OpenCode.";
+"No available fetch strategy for %@." = "Brak dostępnej strategii pobierania dla %@.";
+"Today" = "Dziś";
+"Today tokens" = "Dzisiejsze tokeny";
+"30d cost" = "Koszt 30 dni";
+"30d tokens" = "Tokeny 30 dni";
+"Latest tokens" = "Najnowsze tokeny";
+"Top model" = "Najlepszy model";
+"Storage" = "Pamięć";
+"Add Account..." = "Dodaj konto...";
+"Usage Dashboard" = "Panel użycia";
+"Status Page" = "Strona statusu";
+"Settings..." = "Ustawienia...";
+"About CodexBar" = "O CodexBar";
+"Quit" = "Zakończ";
+"Last %d day" = "Ostatni %d dzień";
+"Last %d days" = "Ostatnie %d dni";
+"%@ tokens" = "%@ tokenów";
+"Latest billing day" = "Najnowszy dzień rozliczeniowy";
+"Latest billing day (%@)" = "Najnowszy dzień rozliczeniowy (%@)";
+"%@ left" = "%@ pozostało";
+"Resets %@" = "Reset %@";
+"Resets in %@" = "Reset za %@";
+"Resets now" = "Reset teraz";
+"reset_tomorrow_format" = "jutro, %@";
+"Lasts until reset" = "Wystarcza do resetu";
+"Updated %@" = "Zaktualizowano %@";
+"Updated %@h ago" = "Zaktualizowano %@ godz. temu";
+"Updated %@m ago" = "Zaktualizowano %@ min temu";
+"Updated just now" = "Zaktualizowano przed chwilą";
+"Projected empty in %@" = "Szacowane wyczerpanie za %@";
+"Runs out in %@" = "Skończy się za %@";
+"Pace: %@" = "Tempo: %@";
+"Pace: %@ · %@" = "Tempo: %@ · %@";
+"%@ · %@" = "%@ · %@";
+"≈ %d%% run-out risk" = "≈ %d%% ryzyka wyczerpania";
+"%d%% in deficit" = "%d%% deficytu";
+"%d%% in reserve" = "%d%% rezerwy";
+"usage_percent_suffix_left" = "pozostało";
+"usage_percent_suffix_used" = "wykorzystano";
+"Store multiple DeepSeek API keys." = "Przechowuj wiele kluczy API DeepSeek.";
+"This week" = "Ten tydzień";
+"Week" = "Tydzień";
+"Month" = "Miesiąc";
+"Models" = "Modele";
+"24h tokens" = "Tokeny 24h";
+"Latest hour" = "Ostatnia godzina";
+"Peak hour" = "Szczytowa godzina";
+"Top method" = "Najlepsza metoda";
+"30d cash" = "Gotówka 30 dni";
+"30d billing history from MiniMax web session" = "30-dniowa historia rozliczeń z sesji webowej MiniMax";
+"AWS Cost Explorer billing can lag." = "Dane rozliczeń AWS Cost Explorer mogą być opóźnione.";
+"Rate limit: %d / %@" = "Limit żądań: %d / %@";
+"Key remaining" = "Pozostało klucza";
+"No limit set for the API key" = "Nie ustawiono limitu dla klucza API";
+"API key limit unavailable right now" = "Limit klucza API jest teraz niedostępny";
+"This month: %@ tokens" = "Ten miesiąc: %@ tokenów";
+"No utilization data yet." = "Brak jeszcze danych wykorzystania.";
+"No %@ utilization data yet." = "Brak jeszcze danych wykorzystania dla %@.";
+"%@: %@%% used" = "%@: wykorzystano %@%%";
+"%dd" = "%d d";
+"today" = "dzisiaj";
+"just now" = "przed chwilą";
+"On pace" = "Zgodnie z tempem";
+"Runs out now" = "Kończy się teraz";
+"Projected empty now" = "Szacowane wyczerpanie teraz";
+"Switch Account..." = "Przełącz konto...";
+"Update ready, restart now?" = "Aktualizacja gotowa, uruchomić ponownie teraz?";
+"Daily" = "Dziennie";
+"Hourly Tokens" = "Tokeny godzinowe";
+"No data" = "Brak danych";
+"No usage breakdown data available." = "Brak dostępnych danych podziału użycia.";
+
+"Today: %@ · %@ tokens" = "Dziś: %@ · %@ tokenów";
+"Today: %@" = "Dziś: %@";
+"Today: %@ tokens" = "Dziś: %@ tokenów";
+"Last 30 days: %@ · %@ tokens" = "Ostatnie 30 dni: %@ · %@ tokenów";
+"Last 30 days: %@" = "Ostatnie 30 dni: %@";
+"Est. total (30d): %@" = "Szac. łączna wartość (30 dni): %@";
+"Est. total (%@): %@" = "Szac. łączna wartość (%@): %@";
+"Hover a bar for details" = "Najedź na słupek, aby zobaczyć szczegóły";
+"%@: %@ · %@ tokens" = "%@: %@ · %@ tokenów";
+"No providers selected for Overview." = "Nie wybrano dostawców dla Przeglądu.";
+"No overview data available." = "Brak dostępnych danych Przeglądu.";
+"Auto uses the local IDE API first, then Google OAuth when the IDE is closed." = "Tryb Auto najpierw używa lokalnego API IDE, a potem Google OAuth, gdy IDE jest zamknięte.";
+"Login with Google" = "Zaloguj się przez Google";
+
+/* Popup panels */
+"No usage configured." = "Nie skonfigurowano użycia.";
+"Quota" = "Limit";
+"tokens" = "tokeny";
+"requests" = "żądania";
+"Latest" = "Najnowsze";
+"Monthly" = "Miesięcznie";
+"Sonnet" = "Sonnet";
+"Overages" = "Nadwyżki";
+"Activity" = "Aktywność";
+"Copied" = "Skopiowano";
+"Copy error" = "Błąd kopiowania";
+"Copy path" = "Skopiuj ścieżkę";
+"Extra usage spent" = "Wydane dodatkowe użycie";
+"Credits remaining" = "Pozostałe kredyty";
+"Using CLI fallback" = "Używane jest awaryjne CLI";
+"Balance updates in near-real time (up to 5 min lag)" = "Saldo aktualizuje się prawie w czasie rzeczywistym (opóźnienie do 5 min)";
+"Daily billing data finalizes at 07:00 UTC" = "Dzienne dane rozliczeniowe finalizują się o 07:00 UTC";
+"%@ of %@ credits left" = "%@ z %@ kredytów pozostało";
+"%@ of %@ bonus credits left" = "%@ z %@ bonusowych kredytów pozostało";
+"%@ / %@ (%@ remaining)" = "%@ / %@ (%@ pozostało)";
+"%@/%@ left" = "%@/%@ pozostało";
+"Gemini Flash" = "Gemini Flash";
+"Regenerates %@" = "Regeneruje się %@";
+"used after next regen" = "wykorzystano po następnym odnowieniu";
+"after next regen" = "po następnym odnowieniu";
+"Near full" = "Prawie pełne";
+"Full in ~1 regen" = "Pełne za ~1 odnowienie";
+"Full in ~%.0f regens" = "Pełne za ~%.0f odnowień";
+"Overage usage" = "Użycie nadwyżki";
+"Overage cost" = "Koszt nadwyżki";
+"credits" = "kredyty";
+"Zen balance" = "Saldo Zen";
+"API spend" = "Wydatki API";
+"Extra usage" = "Dodatkowe użycie";
+"Quota usage" = "Wykorzystanie limitu";
+"Your spend" = "Twoje wydatki";
+"%.0f%% used" = "wykorzystano %.0f%%";
+"Usage history (today)" = "Historia użycia (dzisiaj)";
+"Usage history (%d days)" = "Historia użycia (%d dni)";
+"%d percent remaining" = "pozostało %d procent";
+"Unknown" = "Nieznane";
+"stale data" = "nieaktualne dane";
+"No credits history data." = "Brak danych historii kredytów.";
+"No credits history data available." = "Brak dostępnych danych historii kredytów.";
+"Credits history chart" = "Wykres historii kredytów";
+"%d days of credits data" = "%d dni danych kredytów";
+"Usage breakdown chart" = "Wykres podziału użycia";
+"%d days of usage data across %d services" = "%d dni danych użycia dla %d usług";
+"Cost history chart" = "Wykres historii kosztów";
+"%d days of cost data" = "%d dni danych kosztów";
+"Plan utilization chart" = "Wykres wykorzystania planu";
+"%d utilization samples" = "%d próbek wykorzystania";
+"Hourly Usage" = "Użycie godzinowe";
+"Usage remaining" = "Pozostałe użycie";
+"Usage used" = "Wykorzystane użycie";
+"API key verified. Ollama does not expose Cloud quota limits through the API." = "Klucz API został zweryfikowany. Ollama nie udostępnia limitów Cloud przez API.";
+"Last 30 days: %@ tokens" = "Ostatnie 30 dni: %@ tokenów";
+"7d spend" = "Wydatki 7 dni";
+"30d spend" = "Wydatki 30 dni";
+"Cache read" = "Odczyt z pamięci podręcznej";
+"Claude Admin API 30 day spend trend" = "Trend wydatków 30 dni Claude Admin API";
+"OpenRouter API key spend trend" = "Trend wydatków klucza API OpenRouter";
+"z.ai hourly token trend" = "Godzinowy trend tokenów z.ai";
+"MiniMax 30 day token usage trend" = "Trend użycia tokenów MiniMax z 30 dni";
+"Today cash" = "Dzisiejsza gotówka";
+"DeepSeek 30 day token usage trend" = "Trend użycia tokenów DeepSeek z 30 dni";
+"cache-hit input" = "wejście trafienia pamięci podręcznej";
+"cache-miss input" = "wejście chybienia pamięci podręcznej";
+"output" = "wynik";
+"Requests" = "Żądania";
+"Reported by OpenAI Admin API organization usage." = "Zgłoszone przez użycie organizacji w OpenAI Admin API.";
+"Reported by Mistral billing usage." = "Zgłoszone przez dane rozliczeniowe Mistral.";
+"Google OAuth" = "Uwierzytelnianie Google OAuth";
+"Add accounts via GitHub OAuth Device Flow on the selected host." = "Dodawaj konta przez GitHub OAuth Device Flow na wybranym hoście.";
+"Stores each signed-in Google account for quick Antigravity switching. Uses Antigravity.app OAuth when available, or ANTIGRAVITY_OAUTH_CLIENT_ID and ANTIGRAVITY_OAUTH_CLIENT_SECRET as an override." = "Przechowuje każde zalogowane konto Google, aby szybko przełączać Antigravity. Używa OAuth z Antigravity.app, gdy jest dostępne, albo ANTIGRAVITY_OAUTH_CLIENT_ID i ANTIGRAVITY_OAUTH_CLIENT_SECRET jako nadpisania.";
+"Manual cleanup: past sessions" = "Ręczne czyszczenie: poprzednie sesje";
+"Clearing removes past resume, continue, and rewind history." = "Czyszczenie usuwa historię wcześniejszych wznowień, kontynuacji i cofnięć.";
+"Manual cleanup: file checkpoints" = "Ręczne czyszczenie: punkty kontrolne plików";
+"Clearing removes checkpoint restore data for previous edits." = "Czyszczenie usuwa dane przywracania punktów kontrolnych dla wcześniejszych edycji.";
+"Manual cleanup: saved plans" = "Ręczne czyszczenie: zapisane plany";
+"Clearing removes old plan-mode files." = "Czyszczenie usuwa stare pliki trybu planu.";
+"Manual cleanup: debug logs" = "Ręczne czyszczenie: logi debugowania";
+"Clearing removes past debug logs." = "Czyszczenie usuwa wcześniejsze logi debugowania.";
+"Manual cleanup: attachment cache" = "Ręczne czyszczenie: pamięć podręczna załączników";
+"Clearing removes cached large pastes or attached images." = "Czyszczenie usuwa zapisane duże wklejki lub dołączone obrazy.";
+"Manual cleanup: session metadata" = "Ręczne czyszczenie: metadane sesji";
+"Clearing removes per-session environment metadata." = "Czyszczenie usuwa metadane środowiska przypisane do każdej sesji.";
+"Manual cleanup: shell snapshots" = "Ręczne czyszczenie: migawki powłoki";
+"Clearing removes leftover runtime shell snapshot files." = "Czyszczenie usuwa pozostałe pliki migawek powłoki środowiska uruchomieniowego.";
+"Manual cleanup: legacy todos" = "Ręczne czyszczenie: stare listy zadań";
+"Clearing removes legacy per-session task lists." = "Czyszczenie usuwa starsze listy zadań przypisane do sesji.";
+"Manual cleanup: sessions" = "Ręczne czyszczenie: sesje";
+"Clearing removes past Codex session history." = "Czyszczenie usuwa historię poprzednich sesji Codex.";
+"Manual cleanup: archived sessions" = "Ręczne czyszczenie: zarchiwizowane sesje";
+"Clearing removes archived Codex session history." = "Czyszczenie usuwa historię zarchiwizowanych sesji Codex.";
+"Manual cleanup: cache" = "Ręczne czyszczenie: pamięć podręczna";
+"Clearing removes provider-owned cached data." = "Czyszczenie usuwa dane pamięci podręcznej należące do dostawców.";
+"Manual cleanup: logs" = "Ręczne czyszczenie: logi";
+"Clearing removes local diagnostic logs." = "Czyszczenie usuwa lokalne logi diagnostyczne.";
+"Manual cleanup: file history" = "Ręczne czyszczenie: historia plików";
+"Clearing removes local edit checkpoint history." = "Czyszczenie usuwa lokalną historię punktów kontrolnych edycji.";
+"Manual cleanup: temporary data" = "Ręczne czyszczenie: dane tymczasowe";
+"Clearing removes local temporary provider data." = "Czyszczenie usuwa lokalne tymczasowe dane dostawców.";
+"Total: %@" = "Łącznie: %@";
+"%d more items" = "Jeszcze %d pozycji";
+"Other (%d items)" = "Inne (%d elementów)";
+"Expand" = "Rozwiń";
+"Collapse" = "Zwiń";
+"Cleanup ideas" = "Pomysły na czyszczenie";
+"%d unreadable item(s) skipped" = "Pominięto %d nieczytelnych elementów";
+
+"API key limit" = "Limit klucza API";
+"Auth" = "Uwierzytelnianie";
+"Auto" = "Automatycznie";
+"Disabled — no recent data" = "Wyłączone — brak ostatnich danych";
+"Limits not available" = "Limity niedostępne";
+"No usage yet" = "Brak użycia";
+"Not fetched yet" = "Jeszcze nie pobrano";
+"Refreshing" = "Odświeżanie";
+"Session" = "Sesja";
+"Source" = "Źródło";
+"State" = "Stan";
+"Unavailable" = "Niedostępne";
+"Weekly" = "Tydzień";
+"not detected" = "nie wykryto";
+"Estimated from local Codex logs for the selected account." = "Oszacowano na podstawie lokalnych logów Codex dla wybranego konta.";
+"minimax_usage_amount_format" = "Użycie: %@ / %@";
+"minimax_used_percent_format" = "Wykorzystano %@";
+"minimax_service_text_generation" = "Generowanie tekstu";
+"minimax_service_text_to_speech" = "Synteza mowy";
+"minimax_service_music_generation" = "Generowanie muzyki";
+"minimax_service_image_generation" = "Generowanie obrazów";
+"minimax_service_lyrics_generation" = "Generowanie tekstów piosenek";
+"minimax_service_coding_plan_vlm" = "VLM planu kodowania";
+"minimax_service_coding_plan_search" = "Wyszukiwanie Coding Plan";
+
+/* Additional provider settings and alerts */
+"%@ is waiting for permission" = "%@ czeka na pozwolenie";
+"%@ requests" = "%@ żądań";
+"%@: %@ credits" = "%@: %@ kredytów";
+"30d requests" = "Żądania 30 dni";
+"4 days" = "4 dni";
+"5 days" = "5 dni";
+"7 days" = "7 dni";
+"API key verifies Ollama Cloud access; cookies still expose quota limits." = "Klucz API potwierdza dostęp do Ollama Cloud; limity nadal są widoczne przez pliki cookie.";
+"AWS access key ID. Can also be set with AWS_ACCESS_KEY_ID." = "Identyfikator klucza dostępu AWS. Można też ustawić przez AWS_ACCESS_KEY_ID.";
+"AWS region. Can also be set with AWS_REGION." = "Region AWS. Można też ustawić przez AWS_REGION.";
+"AWS secret access key. Can also be set with AWS_SECRET_ACCESS_KEY." = "Tajny klucz dostępu AWS. Można też ustawić przez AWS_SECRET_ACCESS_KEY.";
+"Access key ID" = "Identyfikator klucza dostępu";
+"Add Account" = "Dodaj konto";
+"Adding Account…" = "Dodawanie konta…";
+"Antigravity login failed" = "Logowanie do Antigravity nie powiodło się";
+"Antigravity login timed out" = "Przekroczono limit czasu logowania do Antigravity";
+"Auth source" = "Źródło uwierzytelniania";
+"Automatic imports browser cookies from Xiaomi MiMo." = "Automatycznie importuje pliki cookie przeglądarki z Xiaomi MiMo.";
+"Automatic imports Windsurf session data from Chromium browser localStorage." = "Automatycznie importuje dane sesji Windsurf z localStorage przeglądarki Chromium.";
+"Automatic imports browser cookies from Bailian." = "Automatycznie importuje pliki cookie przeglądarki z Bailian.";
+"Automatically imports browser cookies." = "Automatycznie importuje pliki cookie przeglądarki.";
+"Automatically imports browser session cookies." = "Automatycznie importuje pliki cookie sesji przeglądarki.";
+"Azure OpenAI deployment name. AZURE_OPENAI_DEPLOYMENT_NAME is also supported." = "Nazwa wdrożenia Azure OpenAI. Obsługiwane jest także AZURE_OPENAI_DEPLOYMENT_NAME.";
+"Azure OpenAI key" = "Klucz Azure OpenAI";
+"Azure OpenAI resource endpoint. AZURE_OPENAI_ENDPOINT is also supported." = "Punkt końcowy zasobu Azure OpenAI. Obsługiwane jest także AZURE_OPENAI_ENDPOINT.";
+"Base URL" = "Bazowy URL";
+"Base URL for the LLM-API-Key-Proxy instance." = "Bazowy URL dla instancji LLM-API-Key-Proxy.";
+"Browser cookies" = "Pliki cookie przeglądarki";
+"Cap end" = "Koniec limitu";
+"Cap start" = "Początek limitu";
+"Capacity End" = "Koniec pojemności";
+"Capacity Start" = "Początek pojemności";
+"Changelog" = "Dziennik zmian";
+"Choose the Moonshot/Kimi API host for international or China mainland accounts." = "Wybierz host API Moonshot/Kimi dla kont międzynarodowych lub z Chin kontynentalnych.";
+"CodexBar can't replace a system account that is signed in with an API key only setup." = "CodexBar nie może zastąpić konta systemowego zalogowanego wyłącznie przez konfigurację klucza API.";
+"CodexBar could not find saved auth for that account. Re-authenticate it and try again." = "CodexBar nie mógł znaleźć zapisanego uwierzytelnienia dla tego konta. Uwierzytelnij je ponownie i spróbuj jeszcze raz.";
+"CodexBar could not read managed account storage. Recover the store before adding another account." = "CodexBar nie mógł odczytać magazynu zarządzanych kont. Napraw magazyn przed dodaniem kolejnego konta.";
+"CodexBar could not read saved auth for that account. Re-authenticate it and try again." = "CodexBar nie mógł odczytać zapisanego uwierzytelnienia dla tego konta. Uwierzytelnij je ponownie i spróbuj jeszcze raz.";
+"CodexBar could not read the current system account on this Mac." = "CodexBar nie mógł odczytać bieżącego konta systemowego na tym Macu.";
+"CodexBar could not replace the live Codex auth on this Mac." = "CodexBar nie mógł zastąpić aktywnego uwierzytelnienia Codex na tym Macu.";
+"CodexBar could not safely preserve the current system account before switching." = "CodexBar nie mógł bezpiecznie zachować bieżącego konta systemowego przed przełączeniem.";
+"CodexBar could not save the current system account before switching." = "CodexBar nie mógł zapisać bieżącego konta systemowego przed przełączeniem.";
+"CodexBar could not update managed account storage." = "CodexBar nie mógł zaktualizować magazynu zarządzanych kont.";
+"CodexBar found another managed account that already uses the current system account. Resolve the duplicate account before switching." = "CodexBar znalazł inne zarządzane konto, które już używa bieżącego konta systemowego. Rozwiąż duplikat konta przed przełączeniem.";
+"CodexBar will ask macOS Keychain for “%@” so it can decrypt browser cookies and authenticate your account. Click OK to continue." = "CodexBar poprosi pęk kluczy macOS o „%@”, aby odszyfrować pliki cookie przeglądarki i uwierzytelnić twoje konto. Kliknij OK, aby kontynuować.";
+"CodexBar will ask macOS Keychain for the Claude Code OAuth token so it can fetch your Claude usage. Click OK to continue." = "CodexBar poprosi pęk kluczy macOS o token OAuth Claude Code, aby pobrać twoje użycie Claude. Kliknij OK, aby kontynuować.";
+"CodexBar will ask macOS Keychain for your Amp cookie header so it can fetch usage. Click OK to continue." = "CodexBar poprosi pęk kluczy macOS o nagłówek Cookie Amp, aby pobrać użycie. Kliknij OK, aby kontynuować.";
+"CodexBar will ask macOS Keychain for your Augment cookie header so it can fetch usage. Click OK to continue." = "CodexBar poprosi pęk kluczy macOS o nagłówek Cookie Augment, aby pobrać użycie. Kliknij OK, aby kontynuować.";
+"CodexBar will ask macOS Keychain for your Claude cookie header so it can fetch Claude web usage. Click OK to continue." = "CodexBar poprosi pęk kluczy macOS o nagłówek Cookie Claude, aby pobrać webowe użycie Claude. Kliknij OK, aby kontynuować.";
+"CodexBar will ask macOS Keychain for your Cursor cookie header so it can fetch usage. Click OK to continue." = "CodexBar poprosi pęk kluczy macOS o nagłówek Cookie Cursor, aby pobrać użycie. Kliknij OK, aby kontynuować.";
+"CodexBar will ask macOS Keychain for your Factory cookie header so it can fetch usage. Click OK to continue." = "CodexBar poprosi pęk kluczy macOS o nagłówek Cookie Factory, aby pobrać użycie. Kliknij OK, aby kontynuować.";
+"CodexBar will ask macOS Keychain for your GitHub Copilot token so it can fetch usage. Click OK to continue." = "CodexBar poprosi pęk kluczy macOS o token GitHub Copilot, aby pobrać użycie. Kliknij OK, aby kontynuować.";
+"CodexBar will ask macOS Keychain for your Kimi K2 API key so it can fetch usage. Click OK to continue." = "CodexBar poprosi pęk kluczy macOS o klucz API Kimi K2, aby pobrać użycie. Kliknij OK, aby kontynuować.";
+"CodexBar will ask macOS Keychain for your Kimi auth token so it can fetch usage. Click OK to continue." = "CodexBar poprosi pęk kluczy macOS o token uwierzytelniania Kimi, aby pobrać użycie. Kliknij OK, aby kontynuować.";
+"CodexBar will ask macOS Keychain for your MiniMax API token so it can fetch usage. Click OK to continue." = "CodexBar poprosi pęk kluczy macOS o token API MiniMax, aby pobrać użycie. Kliknij OK, aby kontynuować.";
+"CodexBar will ask macOS Keychain for your MiniMax cookie header so it can fetch usage. Click OK to continue." = "CodexBar poprosi pęk kluczy macOS o nagłówek Cookie MiniMax, aby pobrać użycie. Kliknij OK, aby kontynuować.";
+"CodexBar will ask macOS Keychain for your OpenAI cookie header so it can fetch Codex dashboard extras. Click OK to continue." = "CodexBar poprosi pęk kluczy macOS o nagłówek Cookie OpenAI, aby pobrać dodatki panelu Codex. Kliknij OK, aby kontynuować.";
+"CodexBar will ask macOS Keychain for your OpenCode cookie header so it can fetch usage. Click OK to continue." = "CodexBar poprosi pęk kluczy macOS o nagłówek Cookie OpenCode, aby pobrać użycie. Kliknij OK, aby kontynuować.";
+"CodexBar will ask macOS Keychain for your Synthetic API key so it can fetch usage. Click OK to continue." = "CodexBar poprosi pęk kluczy macOS o klucz API Synthetic, aby pobrać użycie. Kliknij OK, aby kontynuować.";
+"CodexBar will ask macOS Keychain for your z.ai API token so it can fetch usage. Click OK to continue." = "CodexBar poprosi pęk kluczy macOS o token API z.ai, aby pobrać użycie. Kliknij OK, aby kontynuować.";
+"Could not open Cursor login in your browser." = "Nie udało się otworzyć logowania Cursor w przeglądarce.";
+"Could not open browser for Antigravity" = "Nie udało się otworzyć przeglądarki dla Antigravity";
+"Credits used" = "Wykorzystane kredyty";
+"Day" = "Dzień";
+"Deployment" = "Wdrożenie";
+"Drag to reorder" = "Przeciągnij, aby zmienić kolejność";
+"Sort providers alphabetically" = "Sortuj dostawców alfabetycznie";
+"Sort providers alphabetically (enabled first)" = "Sortuj dostawców alfabetycznie (włączeni najpierw)";
+"Sorted alphabetically (enabled first) — click to use your custom order" = "Posortowano alfabetycznie (włączeni najpierw) — kliknij, aby użyć własnej kolejności";
+"Endpoint" = "Punkt końcowy";
+"Enterprise host" = "Host Enterprise";
+"Extra usage balance: %@" = "Saldo dodatkowego użycia: %@";
+"Keychain Access Required" = "Wymagany dostęp do pęku kluczy";
+"Kiro menu bar value" = "Wartość paska menu Kiro";
+"Label" = "Etykieta";
+"No organizations loaded. Click Refresh after setting your API key." = "Nie wczytano organizacji. Kliknij Odśwież po ustawieniu klucza API.";
+"No output captured." = "Nie przechwycono danych wyjściowych.";
+"No system account" = "Brak konta systemowego";
+"Oasis-Token" = "Token Oasis";
+"Open Augment (Log Out & Back In)" = "Otwórz Augment (wyloguj się i zaloguj ponownie)";
+"Open Codebuff Dashboard" = "Otwórz panel Codebuff";
+"Open Command Code Settings" = "Otwórz ustawienia Command Code";
+"Open Crof dashboard" = "Otwórz panel Crof";
+"Open Manus" = "Otwórz Manus";
+"Open MiMo Balance" = "Otwórz saldo MiMo";
+"Open Moonshot Console" = "Otwórz konsolę Moonshot";
+"Open Ollama API Keys" = "Otwórz klucze API Ollama";
+"Open StepFun Platform" = "Otwórz platformę StepFun";
+"Open T3 Chat Settings" = "Otwórz ustawienia T3 Chat";
+"Open Volcengine Ark Console" = "Otwórz konsolę Volcengine Ark";
+"Open legacy provider docs" = "Otwórz dokumentację starszych dostawców";
+"Open projects" = "Otwórz projekty";
+"Open this URL manually to continue login:\n\n%@" = "Otwórz ten URL ręcznie, aby kontynuować logowanie:\n\n%@";
+"Optional organization ID for accounts linked to multiple Anthropic organizations." = "Opcjonalny identyfikator organizacji dla kont powiązanych z wieloma organizacjami Anthropic.";
+"Optional. Applies to the configured Admin API key; selected token accounts do not inherit OPENAI_PROJECT_ID." = "Opcjonalne. Dotyczy skonfigurowanego klucza API administratora; wybrane konta tokenów nie dziedziczą OPENAI_PROJECT_ID.";
+"Optional. Enter your GitHub Enterprise host, for example octocorp.ghe.com. Leave blank for github.com." = "Opcjonalne. Wprowadź host GitHub Enterprise, na przykład octocorp.ghe.com. Pozostaw puste dla github.com.";
+"Optional. Leave blank to discover and aggregate projects visible to the API key." = "Opcjonalne. Pozostaw puste, aby wykrywać i agregować projekty widoczne dla klucza API.";
+"Org ID (optional)" = "ID organizacji (opcjonalnie)";
+"Organizations" = "Organizacje";
+"Password" = "Hasło";
+"%@ authentication is disabled." = "Uwierzytelnianie %@ jest wyłączone.";
+"%@ cookies are disabled." = "Pliki cookie %@ są wyłączone.";
+"%@ web API access is disabled." = "Dostęp do web API %@ jest wyłączony.";
+"Disable %@ dashboard cookie usage." = "Wyłącz użycie plików cookie panelu %@.";
+"Keychain access is disabled in Advanced, so browser cookie import is unavailable." = "Dostęp do pęku kluczy jest wyłączony w Zaawansowanych, więc import plików cookie przeglądarki jest niedostępny.";
+"Manually paste an %@ from a browser session." = "Wklej ręcznie %@ z sesji przeglądarki.";
+"Paste a Cookie header captured from %@." = "Wklej nagłówek Cookie przechwycony z %@.";
+"Paste a Cookie header from %@." = "Wklej nagłówek Cookie z %@.";
+"Paste a Cookie header or cURL capture from %@." = "Wklej nagłówek Cookie lub przechwycony cURL z %@.";
+"Paste a Cookie header or full cURL capture from %@." = "Wklej nagłówek Cookie lub pełny przechwycony cURL z %@.";
+"Paste a Cookie or Authorization header from %@." = "Wklej nagłówek Cookie lub Authorization z %@.";
+"Paste a full cookie header or the %@ value." = "Wklej pełny nagłówek Cookie albo wartość %@.";
+"Paste a Cookie header or full cURL capture from T3 Chat settings." = "Wklej nagłówek Cookie lub pełny przechwycony cURL z ustawień T3 Chat.";
+"Paste the Cookie header from a request to admin.mistral.ai. Must contain an ory_session_* cookie." = "Wklej nagłówek Cookie z żądania do admin.mistral.ai. Musi zawierać plik cookie ory_session_*.";
+"Paste the Oasis-Token from a logged-in browser session on platform.stepfun.com." = "Wklej Oasis-Token z zalogowanej sesji przeglądarki na platform.stepfun.com.";
+"Paste the %@ JSON bundle from %@." = "Wklej pakiet JSON %@ z %@.";
+"Paste the %@ value or a full Cookie header." = "Wklej wartość %@ albo pełny nagłówek Cookie.";
+"Personal account" = "Konto osobiste";
+"Project ID" = "ID projektu";
+"Re-auth" = "Uwierzytelnij ponownie";
+"Re-login at claude.ai" = "Zaloguj się ponownie na claude.ai";
+"Re-authenticating…" = "Ponowne uwierzytelnianie…";
+"Refresh Session" = "Odśwież sesję";
+"Refresh organizations" = "Odśwież organizacje";
+"Region" = "Region";
+"Reload" = "Przeładuj";
+"Reorder" = "Zmień kolejność";
+"Secret access key" = "Tajny klucz dostępu";
+"Series" = "Seria";
+"Service" = "Usługa";
+"Show or hide Kiro credits, percent, or both next to the menu bar icon." = "Pokaż lub ukryj kredyty Kiro, procent albo oba obok ikony paska menu.";
+"Show usage for organizations you belong to. Personal account is always shown." = "Pokazuj użycie dla organizacji, do których należysz. Konto osobiste jest zawsze widoczne.";
+"Sign in to cursor.com in your browser, then refresh Cursor in CodexBar." = "Zaloguj się do cursor.com w przeglądarce, a następnie odśwież Cursor w CodexBar.";
+"Simulated error text" = "Symulowany tekst błędu";
+"StepFun platform account (phone number or email)." = "Konto platformy StepFun (numer telefonu lub e-mail).";
+"Stored in ~/.codexbar/config.json." = "Przechowywane w ~/.codexbar/config.json.";
+"Stored in ~/.codexbar/config.json. AZURE_OPENAI_API_KEY is also supported." = "Przechowywane w ~/.codexbar/config.json. Obsługiwane jest także AZURE_OPENAI_API_KEY.";
+"Stored in ~/.codexbar/config.json. For the official Kimi API, use Moonshot / Kimi API." = "Przechowywane w ~/.codexbar/config.json. Dla oficjalnego API Kimi użyj Moonshot / Kimi API.";
+"Stored in ~/.codexbar/config.json. Get your API key from the Volcengine Ark console." = "Przechowywane w ~/.codexbar/config.json. Pobierz klucz API z konsoli Volcengine Ark.";
+"Stored in ~/.codexbar/config.json. Get your key from Ollama settings." = "Przechowywane w ~/.codexbar/config.json. Pobierz klucz z ustawień Ollama.";
+"Stored in ~/.codexbar/config.json. Get your key from console.deepgram.com." = "Przechowywane w ~/.codexbar/config.json. Pobierz klucz z console.deepgram.com.";
+"Stored in ~/.codexbar/config.json. Get your key from elevenlabs.io/app/settings/api-keys." = "Przechowywane w ~/.codexbar/config.json. Pobierz klucz z elevenlabs.io/app/settings/api-keys.";
+"Stored in ~/.codexbar/config.json. Get your key from openrouter.ai/settings/keys and set a key spending limit there to enable API key quota tracking." = "Przechowywane w ~/.codexbar/config.json. Pobierz klucz z openrouter.ai/settings/keys i ustaw tam limit wydatków klucza, aby włączyć śledzenie limitu klucza API.";
+"Stored in ~/.codexbar/config.json. In Warp, open Settings > Platform > API Keys, then create one." = "Przechowywane w ~/.codexbar/config.json. W Warp otwórz Ustawienia > Platform > API Keys, a następnie utwórz klucz.";
+"Stored in ~/.codexbar/config.json. Metrics require Groq Enterprise Prometheus access." = "Przechowywane w ~/.codexbar/config.json. Metryki wymagają dostępu do Groq Enterprise Prometheus.";
+"Stored in ~/.codexbar/config.json. OPENAI_ADMIN_KEY is preferred; OPENAI_API_KEY still works." = "Przechowywane w ~/.codexbar/config.json. Preferowany jest OPENAI_ADMIN_KEY; OPENAI_API_KEY nadal działa.";
+"Stored in ~/.codexbar/config.json. Requires an Anthropic Admin API key." = "Przechowywane w ~/.codexbar/config.json. Wymaga klucza Anthropic Admin API.";
+"Stored in ~/.codexbar/config.json. Used for /v1/quota-stats." = "Przechowywane w ~/.codexbar/config.json. Używane dla `/v1/quota-stats`.";
+"Stored in ~/.codexbar/config.json. You can also provide CODEBUFF_API_KEY or let CodexBar read ~/.config/manicode/credentials.json (created by `codebuff login`)." = "Przechowywane w ~/.codexbar/config.json. Możesz też podać CODEBUFF_API_KEY albo pozwolić CodexBar odczytać ~/.config/manicode/credentials.json (utworzony przez `codebuff login`).";
+"Stored in ~/.codexbar/config.json. You can also provide CROF_API_KEY." = "Przechowywane w ~/.codexbar/config.json. Możesz też podać CROF_API_KEY.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or ~/.local/share/kilo/auth.json (kilo.access)." = "Przechowywane w ~/.codexbar/config.json. Możesz też podać KILO_API_KEY albo ~/.local/share/kilo/auth.json (kilo.access).";
+"T3 Chat cookie" = "Plik cookie T3 Chat";
+"That account is no longer available in CodexBar. Refresh the account list and try again." = "To konto nie jest już dostępne w CodexBar. Odśwież listę kont i spróbuj ponownie.";
+"The browser login did not complete in time. Try Antigravity login again." = "Logowanie w przeglądarce nie zostało ukończone na czas. Spróbuj ponownie zalogować się do Antigravity.";
+"Timed out waiting for Cursor login. %@" = "Przekroczono limit czasu oczekiwania na logowanie Cursor. %@";
+"Timed out waiting for Cursor login. %@ Last error: %@" = "Przekroczono limit czasu oczekiwania na logowanie Cursor. %@ Ostatni błąd: %@";
+"Today requests" = "Dzisiejsze żądania";
+"Total (30d): %@ credits" = "Łącznie (30 dni): %@ kredytów";
+"Username" = "Nazwa użytkownika";
+"Uses username + password to login and obtain an Oasis-Token automatically." = "Używa nazwy użytkownika i hasła do logowania oraz automatycznego uzyskania Oasis-Token.";
+"Uses username + password to login and obtain an %@ automatically." = "Używa nazwy użytkownika i hasła do logowania oraz automatycznego uzyskania %@.";
+"Utilization End" = "Koniec wykorzystania";
+"Utilization Start" = "Początek wykorzystania";
+"Verbosity" = "Szczegółowość";
+"Windsurf session JSON bundle" = "Pakiet JSON sesji Windsurf";
+"Workspace ID" = "ID workspace";
+"Your StepFun platform password. Used to login and obtain a session token." = "Twoje hasło do platformy StepFun. Służy do logowania i uzyskania tokenu sesji.";
+"claude /login exited with status %d." = "`claude /login` zakończył się ze statusem %d.";
+"codex login exited with status %d." = "`codex login` zakończył się ze statusem %d.";
+"Cookie: …\n\nor paste a cURL capture from the Abacus AI dashboard" = "Cookie: …\n\nalbo wklej przechwycony cURL z panelu Abacus AI";
+"Cookie: …\n\nor paste the __Secure-next-auth.session-token value" = "Cookie: …\n\nalbo wklej wartość __Secure-next-auth.session-token";
+"Cookie: …\n\nor paste the kimi-auth token value" = "Cookie: …\n\nalbo wklej wartość tokenu kimi-auth";
+"session_id=...\n\nor paste just the session_id value" = "session_id=...\n\nalbo wklej samą wartość session_id";
+"Clear" = "Wyczyść";
+"No matching providers" = "Brak pasujących dostawców";
+"Search providers" = "Szukaj dostawców";
+
+"Request quota: %@ / %@" = "Limit żądań: %@ / %@";
+"language_arabic" = "العربية";
+"language_persian" = "فارسی";
+"language_thai" = "ไทย";
+"Limit Reset Credits" = "Kredyty resetowania limitu";
+"1 manual reset available" = "Dostępny 1 ręczny reset";
+"%d manual resets available" = "Dostępne ręczne resety: %d";
+"Next expires %@" = "Następny wygasa %@";
+"byte_unit_byte" = "bajt";
+"byte_unit_bytes" = "bajty";
+"byte_unit_kilobyte" = "kilobajt";
+"byte_unit_kilobytes" = "kilobajty";
+"byte_unit_megabyte" = "megabajt";
+"byte_unit_megabytes" = "megabajty";
+"byte_unit_gigabyte" = "gigabajt";
+"byte_unit_gigabytes" = "gigabajty";
diff --git a/Sources/CodexBar/Resources/pt-BR.lproj/Localizable.strings b/Sources/CodexBar/Resources/pt-BR.lproj/Localizable.strings
new file mode 100644
index 0000000000..a0f431795c
--- /dev/null
+++ b/Sources/CodexBar/Resources/pt-BR.lproj/Localizable.strings
@@ -0,0 +1,1106 @@
+/* Brazilian Portuguese localization for CodexBar */
+
+" providers" = " provedores";
+"(System)" = "(Sistema)";
+"30d" = "30d";
+"A managed Codex login is already running. Wait for it to finish before adding " = "Um login gerenciado do Codex já está em andamento. Aguarde terminar antes de adicionar ";
+"API key" = "Chave de API";
+"API region" = "Região da API";
+"API token" = "Token da API";
+"API tokens" = "Tokens de API";
+"About" = "Sobre";
+"Account" = "Conta";
+"Accounts" = "Contas";
+"Accounts subtitle" = "Subtítulo de contas";
+"Active" = "Ativo";
+"Add" = "Adicionar";
+"Add Workspace" = "Adicionar workspace";
+"Advanced" = "Avançado";
+"All" = "Todos";
+"Always allow prompts" = "Sempre permitir prompts";
+"Animation pattern" = "Padrão de animação";
+"Antigravity login is managed in the app" = "O login do Antigravity é gerenciado no app";
+"Applies only to the Security.framework OAuth keychain reader." = "Aplica-se apenas ao leitor de chaves OAuth Security.framework.";
+"Auto falls back to the next source if the preferred one fails." = "Automático usa a próxima fonte se a preferida falhar.";
+"Auto uses API first, then falls back to CLI on auth failures." = "Automático usa a API primeiro e recorre à CLI em falhas de autenticação.";
+"Auto-detect" = "Detectar automaticamente";
+"Auto-refresh is off; use the menu's Refresh command." = "A atualização automática está desativada; use Atualizar no menu.";
+"Auto-refresh: hourly · Timeout: 10m" = "Atualização automática: a cada hora · Timeout: 10 min";
+"Automatic" = "Automático";
+"Automatic imports browser cookies and WorkOS tokens." = "Importa automaticamente cookies do navegador e tokens WorkOS.";
+"Automatic imports browser cookies and local storage tokens." = "Importa automaticamente cookies do navegador e tokens do armazenamento local.";
+"Automatic imports browser cookies for dashboard extras." = "Importa automaticamente cookies do navegador para extras do dashboard.";
+"Automatic imports browser cookies for the web API." = "Importa automaticamente cookies do navegador para a API web.";
+"Automatic imports browser cookies from Model Studio/Bailian." = "Importa automaticamente cookies do navegador do Model Studio/Bailian.";
+"Automatic imports browser cookies from admin.mistral.ai." = "Importa automaticamente cookies do navegador de admin.mistral.ai.";
+"Automatic imports browser cookies from opencode.ai." = "Importa automaticamente cookies do navegador de opencode.ai.";
+"Automatic imports browser cookies or stored sessions." = "Importa automaticamente cookies do navegador ou sessões salvas.";
+"Automatic imports browser cookies." = "Importa cookies do navegador automaticamente.";
+"Automatically imports browser session cookie." = "Importa automaticamente o cookie de sessão do navegador.";
+"Automatically opens CodexBar when you start your Mac." = "Abre o CodexBar automaticamente ao iniciar o Mac.";
+"Automation" = "Automação";
+"Average (\\(label1) + \\(label2))" = "Média (\\(label1) + \\(label2))";
+"Average (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))" = "Média (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))";
+"Avoid Keychain prompts" = "Evitar prompts do Keychain";
+"Balance" = "Saldo";
+"Battery Saver" = "Economia de bateria";
+"Bordered" = "Com borda";
+"Build" = "Build";
+"Built \\(buildTimestamp)" = "Build \\(buildTimestamp)";
+"Buy Credits..." = "Comprar créditos...";
+"Buy Credits…" = "Comprar créditos…";
+"CLI paths" = "Caminhos da CLI";
+"CLI sessions" = "Sessões da CLI";
+"Caches" = "Caches";
+"Cancel" = "Cancelar";
+"Check for Updates…" = "Buscar atualizações…";
+"Check for updates automatically" = "Buscar atualizações automaticamente";
+"Check if you like your agents having some fun up there." = "Veja se você gosta dos seus agentes se divertindo ali em cima.";
+"Check provider status" = "Verificar status dos provedores";
+"Choose Codex workspace" = "Escolher workspace do Codex";
+"Choose the MiniMax host (global .io or China mainland .com)." = "Escolha o host MiniMax (global .io ou China continental .com).";
+"Choose up to " = "Escolha até ";
+"Choose up to \\(Self.maxOverviewProviders) providers" = "Escolha até \\(Self.maxOverviewProviders) provedores";
+"Choose up to \\(count) providers" = "Escolha até \\(count) provedores";
+"Choose what to show in the menu bar (Pace shows usage vs. expected)." = "Escolha o que mostrar na barra de menus (Ritmo mostra uso vs. esperado).";
+"Choose which Codex account CodexBar should follow." = "Escolha qual conta Codex o CodexBar deve acompanhar.";
+"Choose which window drives the menu bar percent." = "Escolha qual janela define a porcentagem da barra de menus.";
+"Chrome" = "Chrome";
+"Claude CLI not found" = "CLI do Claude não encontrada";
+"Claude binary" = "Binário do Claude";
+"Claude cookies" = "Cookies do Claude";
+"Claude login failed" = "Falha no login do Claude";
+"Claude login timed out" = "Tempo esgotado no login do Claude";
+"Close" = "Fechar";
+"Code review" = "Revisão de código";
+"Codex CLI not found" = "CLI do Codex não encontrada";
+"Codex account login already running" = "Login de conta Codex já em andamento";
+"Codex binary" = "Binário do Codex";
+"Codex login failed" = "Falha no login do Codex";
+"Codex login timed out" = "Tempo esgotado no login do Codex";
+"CodexBar Lifecycle Keepalive" = "Keepalive do ciclo de vida do CodexBar";
+"CodexBar can't show its menu bar icon" = "O CodexBar não consegue mostrar o ícone na barra de menus";
+"CodexBar could not read managed account storage. " = "O CodexBar não conseguiu ler o armazenamento de contas gerenciadas. ";
+"Configure…" = "Configurar…";
+"Connected" = "Conectado";
+"Controls how much detail is logged." = "Controla o nível de detalhe dos logs.";
+"Cookie header" = "Cabeçalho Cookie";
+"Cookie source" = "Fonte do cookie";
+"Cookie: ..." = "Cookie: ...";
+"Cookie: \\u{2026}\\\n\\\nor paste a cURL capture from the Abacus AI dashboard" = "Cookie: \\u{2026}\\\n\\\nou cole uma captura cURL do dashboard do Abacus AI";
+"Cookie: \\u{2026}\\\n\\\nor paste the __Secure-next-auth.session-token value" = "Cookie: \\u{2026}\\\n\\\nou cole o valor de __Secure-next-auth.session-token";
+"Cookie: \\u{2026}\\\n\\\nor paste the kimi-auth token value" = "Cookie: \\u{2026}\\\n\\\nou cole o valor do token kimi-auth";
+"Cookie: …" = "Cookie: …";
+"CopilotDeviceFlow" = "CopilotDeviceFlow";
+"Cost" = "Custo";
+"Could not add Codex account" = "Não foi possível adicionar a conta Codex";
+"Could not open Terminal for Gemini" = "Não foi possível abrir o Terminal para Gemini";
+"Could not start claude /login" = "Não foi possível iniciar claude /login";
+"Could not start codex login" = "Não foi possível iniciar o login do Codex";
+"Could not switch system account" = "Não foi possível trocar a conta do sistema";
+"Credits" = "Créditos";
+"Individual credits" = "Créditos individuais";
+"Workspace" = "Workspace";
+"Credits history" = "Histórico de créditos";
+"Cursor login failed" = "Falha no login do Cursor";
+"Custom" = "Personalizado";
+"Custom Path" = "Caminho personalizado";
+"Daily Routines" = "Rotinas diárias";
+"Debug" = "Depuração";
+"Default" = "Padrão";
+"Disable Keychain access" = "Desativar acesso ao Keychain";
+"Disabled" = "Desativado";
+"Dismiss" = "Dispensar";
+"Disconnected" = "Desconectado";
+"Display" = "Exibição";
+"Display mode" = "Modo de exibição";
+"Display reset times as absolute clock values instead of countdowns." = "Mostra horários de renovação como horas absolutas, em vez de contagens regressivas.";
+"Done" = "Concluído";
+"Effective PATH" = "PATH efetivo";
+"Email" = "E-mail";
+"Enable Merge Icons to configure Overview tab providers." = "Ative Mesclar Ícones para configurar provedores da aba Visão geral.";
+"Enable file logging" = "Ativar logs em arquivo";
+"Enabled" = "Ativado";
+"Error" = "Erro";
+"Error simulation" = "Simulação de erro";
+"Expose troubleshooting tools in the Debug tab." = "Exibe ferramentas de diagnóstico na aba Depuração.";
+"Failed" = "Falhou";
+"False" = "Falso";
+"Fetch strategy attempts" = "Tentativas da estratégia de busca";
+"Fetching" = "Buscando";
+"Field" = "Campo";
+"Field subtitle" = "Subtítulo do campo";
+"Finish the current managed account change before switching the system account." = "Conclua a alteração de conta gerenciada atual antes de trocar a conta do sistema.";
+"Force animation on next refresh" = "Forçar animação na próxima atualização";
+"Gateway region" = "Região do gateway";
+"Gemini CLI not found" = "CLI do Gemini não encontrada";
+"Gemini/Antigravity, surfacing incidents in the icon and menu." = "Gemini/Antigravity, exibindo incidentes no ícone e no menu.";
+"General" = "Geral";
+"GitHub" = "GitHub";
+"GitHub Copilot Login" = "Login do GitHub Copilot";
+"GitHub Login" = "Login do GitHub";
+"Hide details" = "Ocultar detalhes";
+"Hide personal information" = "Ocultar informações pessoais";
+"Historical tracking" = "Acompanhamento histórico";
+"How often CodexBar polls providers in the background." = "Frequência com que o CodexBar consulta provedores em segundo plano.";
+"Inactive" = "Inativo";
+"Install CLI" = "Instalar CLI";
+"Install the Claude CLI (npm i -g @anthropic-ai/claude-code) and try again." = "Instale a CLI do Claude (npm i -g @anthropic-ai/claude-code) e tente novamente.";
+"Install the Codex CLI (npm i -g @openai/codex) and try again." = "Instale a CLI do Codex (npm i -g @openai/codex) e tente novamente.";
+"Install the Gemini CLI (npm i -g @google/gemini-cli) and try again." = "Instale a CLI do Gemini (npm i -g @google/gemini-cli) e tente novamente.";
+"JetBrains AI is ready" = "JetBrains AI está pronto";
+"JetBrains IDE" = "IDE JetBrains";
+"Keep CLI sessions alive" = "Manter sessões da CLI ativas";
+"Keyboard shortcut" = "Atalho de teclado";
+"Keychain access" = "Acesso ao Keychain";
+"Keychain prompt policy" = "Política de prompts do Keychain";
+"Last \\(name) fetch failed:" = "Última busca de \\(name) falhou:";
+"Last \\(self.store.metadata(for: self.provider).displayName) fetch failed:" = "Última busca de \\(self.store.metadata(for: self.provider).displayName) falhou:";
+"Last attempt" = "Última tentativa";
+"Link" = "Link";
+"Loading animations" = "Animações de carregamento";
+"Loading…" = "Carregando…";
+"Local" = "Local";
+"Logging" = "Logs";
+"Login failed" = "Falha no login";
+"Login shell PATH (startup capture)" = "PATH do shell de login (captura na inicialização)";
+"Login timed out" = "Tempo esgotado no login";
+"MCP details" = "Detalhes MCP";
+"Managed Codex accounts unavailable" = "Contas Codex gerenciadas indisponíveis";
+"Managed account storage is unreadable. Live account access is still available, " = "O armazenamento de contas gerenciadas está ilegível. O acesso à conta ativa ainda está disponível, ";
+"Manual" = "Manual";
+"May your tokens never run out—keep agent limits in view." = "Que seus tokens nunca acabem — mantenha os limites dos agentes à vista.";
+"Menu bar" = "Barra de menus";
+"Menu bar auto-shows the provider closest to its rate limit." = "A barra de menus mostra automaticamente o provedor mais próximo do limite de taxa.";
+"Menu bar metric" = "Métrica da barra de menus";
+"Menu bar shows percent" = "Barra de menus mostra porcentagem";
+"Menu content" = "Conteúdo do menu";
+"Merge Icons" = "Mesclar Ícones";
+"Never prompt" = "Nunca perguntar";
+"No" = "Não";
+"No Codex accounts detected yet." = "Nenhuma conta Codex detectada ainda.";
+"No JetBrains IDE detected" = "Nenhuma IDE JetBrains detectada";
+"No cost history data." = "Sem dados de histórico de custos.";
+"No data available" = "Nenhum dado disponível";
+"No data yet" = "Ainda sem dados";
+"No enabled providers available for Overview." = "Nenhum provedor ativado disponível para Visão geral.";
+"No providers selected" = "Nenhum provedor selecionado";
+"No token accounts yet." = "Ainda sem contas de token.";
+"No usage breakdown data." = "Sem dados de detalhamento de uso.";
+"None" = "Nenhum";
+"Notifications" = "Notificações";
+"Notifies when the 5-hour session quota hits 0% and when it becomes " = "Notifica quando a cota de sessão de 5 horas chega a 0% e quando fica ";
+"OK" = "OK";
+"Obscure email addresses in the menu bar and menu UI." = "Oculta endereços de e-mail na barra de menus e na UI do menu.";
+"Off" = "Desligado";
+"Offline" = "Offline";
+"On" = "Ligado";
+"Online" = "Online";
+"Only on user action" = "Somente por ação do usuário";
+"Open" = "Abrir";
+"Open API Keys" = "Abrir chaves de API";
+"Open Amp Settings" = "Abrir ajustes do Amp";
+"Open Antigravity to sign in, then refresh CodexBar." = "Abra o Antigravity para entrar e depois atualize o CodexBar.";
+"Open Browser" = "Abrir navegador";
+"Open Coding Plan" = "Abrir Coding Plan";
+"Open Console" = "Abrir console";
+"Open Dashboard" = "Abrir dashboard";
+"Open Mistral Admin" = "Abrir Mistral Admin";
+"Open Menu Bar Settings" = "Abrir ajustes da barra de menus";
+"Open Ollama Settings" = "Abrir ajustes do Ollama";
+"Open Terminal" = "Abrir Terminal";
+"Open Usage Page" = "Abrir página de uso";
+"Open Warp API Key Guide" = "Abrir guia de chave de API do Warp";
+"Open menu" = "Abrir menu";
+"Open token file" = "Abrir arquivo de token";
+"OpenAI cookies" = "Cookies da OpenAI";
+"OpenAI web extras" = "Extras web da OpenAI";
+"Option A" = "Opção A";
+"Option B" = "Opção B";
+"Optional override if workspace lookup fails." = "Substituição opcional se a busca do workspace falhar.";
+"Options" = "Opções";
+"Override auto-detection with a custom IDE base path" = "Substituir detecção automática por um caminho base personalizado da IDE";
+"Overview" = "Visão geral";
+"Overview rows always follow provider order." = "As linhas da Visão geral sempre seguem a ordem dos provedores.";
+"Overview tab providers" = "Provedores da aba Visão geral";
+"Paste API key…" = "Cole a chave de API…";
+"Paste API token…" = "Cole o token da API…";
+"Paste key…" = "Cole a chave…";
+"Paste sessionKey or OAuth token…" = "Cole sessionKey ou token OAuth…";
+"Paste the Cookie header from a request to admin.mistral.ai. " = "Cole o cabeçalho Cookie de uma requisição para admin.mistral.ai. ";
+"Paste token…" = "Cole o token…";
+"Personal" = "Pessoal";
+"Picker" = "Seletor";
+"Picker subtitle" = "Subtítulo do seletor";
+"Placeholder" = "Texto de exemplo";
+"Plan" = "Plano";
+"Play full-screen confetti when weekly usage resets." = "Mostra confete em tela cheia quando o uso semanal for renovado.";
+"Polls OpenAI/Claude status pages and Google Workspace for " = "Consulta as páginas de status da OpenAI/Claude e o Google Workspace para ";
+"Prevents any Keychain access while enabled." = "Impede qualquer acesso ao Keychain quando ativado.";
+"Primary (API key limit)" = "Primário (limite da chave de API)";
+"Primary (\\(label))" = "Primário (\\(label))";
+"Primary (\\(metadata.sessionLabel))" = "Primário (\\(metadata.sessionLabel))";
+"Probe logs" = "Logs de verificação";
+"Progress bars fill as you consume quota (instead of showing remaining)." = "As barras de progresso preenchem conforme você consome a cota (em vez de mostrar o restante).";
+"Provider" = "Provedor";
+"Providers" = "Provedores";
+"Quit CodexBar" = "Encerrar CodexBar";
+"Random (default)" = "Aleatório (padrão)";
+"Reads local usage logs. Shows today + last 30 days cost in the menu." = "Lê logs de uso locais. Mostra o custo de hoje + a janela de histórico selecionada no menu.";
+"Refresh" = "Atualizar";
+"Refresh cadence" = "Cadência de atualização";
+"Remote" = "Remoto";
+"Remove" = "Remover";
+"Remove Codex account?" = "Remover conta Codex?";
+"Remove \\(account.email) from CodexBar? Its managed Codex home will be deleted." = "Remover \\(account.email) do CodexBar? O diretório Codex gerenciado será apagado.";
+"Remove \\(email) from CodexBar? Its managed Codex home will be deleted." = "Remover \\(email) do CodexBar? O diretório Codex gerenciado será apagado.";
+"Remove selected account" = "Remover conta selecionada";
+"Replace critter bars with provider branding icons and a percentage." = "Substitui barras de bichinhos por ícones da marca do provedor e uma porcentagem.";
+"Replay selected animation" = "Reproduzir animação selecionada";
+"Requires authentication via GitHub Device Flow." = "Requer autenticação via GitHub Device Flow.";
+"Resets: \\(reset)" = "Renova em: \\(reset)";
+"Rolling five-hour limit" = "Limite móvel de cinco horas";
+"Search hourly" = "Buscar a cada hora";
+"Secondary (\\(label))" = "Secundário (\\(label))";
+"Secondary (\\(metadata.weeklyLabel))" = "Secundário (\\(metadata.weeklyLabel))";
+"Select a provider" = "Selecione um provedor";
+"Select the IDE to monitor" = "Selecione a IDE para monitorar";
+"Session quota notifications" = "Notificações de cota de sessão";
+"Session tokens" = "Tokens de sessão";
+"Settings" = "Ajustes";
+"Show Codex Credits and Claude Extra usage sections in the menu." = "Mostra as seções de créditos do Codex e uso extra do Claude no menu.";
+"Show Debug Settings" = "Mostrar ajustes de depuração";
+"Show all token accounts" = "Mostrar todas as contas de token";
+"Show cost summary" = "Mostrar resumo de custos";
+"Show credits + extra usage" = "Mostrar créditos + uso extra";
+"Show details" = "Mostrar detalhes";
+"Show most-used provider" = "Mostrar provedor mais usado";
+"Show provider icons in the switcher (otherwise show a weekly progress line)." = "Mostra ícones dos provedores no alternador (caso contrário, mostra uma linha de progresso semanal).";
+"Show reset time as clock" = "Mostrar renovação como horário";
+"Show usage as used" = "Mostrar uso como consumido";
+"Sign in via button below" = "Entre pelo botão abaixo";
+"Skip teardown between probes (debug-only)." = "Não encerra entre verificações (somente depuração).";
+"Stack token accounts in the menu (otherwise show an account switcher bar)." = "Empilha contas de token no menu (caso contrário, mostra uma barra de alternância de contas).";
+"Start at Login" = "Iniciar ao fazer login";
+"Status" = "Status";
+"Store Claude sessionKey cookies or OAuth access tokens." = "Armazena cookies sessionKey ou tokens de acesso OAuth do Claude.";
+"Store multiple Abacus AI Cookie headers." = "Armazena vários cabeçalhos Cookie do Abacus AI.";
+"Store multiple Augment Cookie headers." = "Armazena vários cabeçalhos Cookie do Augment.";
+"Store multiple Cursor Cookie headers." = "Armazena vários cabeçalhos Cookie do Cursor.";
+"Store multiple Factory Cookie headers." = "Armazena vários cabeçalhos Cookie do Factory.";
+"Store multiple MiniMax Cookie headers." = "Armazena vários cabeçalhos Cookie do MiniMax.";
+"Store multiple Mistral Cookie headers." = "Armazena vários cabeçalhos Cookie do Mistral.";
+"Store multiple Ollama Cookie headers." = "Armazena vários cabeçalhos Cookie do Ollama.";
+"Store multiple OpenCode Cookie headers." = "Armazena vários cabeçalhos Cookie do OpenCode.";
+"Store multiple OpenCode Go Cookie headers." = "Armazena vários cabeçalhos Cookie do OpenCode Go.";
+"Stored in the CodexBar config file." = "Armazenado no arquivo de configuração do CodexBar.";
+"Stored in ~/.codexbar/config.json. " = "Armazenado em ~/.codexbar/config.json. ";
+"Stored in ~/.codexbar/config.json. Generate one at kimi-k2.ai." = "Armazenado em ~/.codexbar/config.json. Gere um em kimi-k2.ai.";
+"Stored in ~/.codexbar/config.json. Paste the key from the Synthetic dashboard." = "Armazenado em ~/.codexbar/config.json. Cole a chave do dashboard Synthetic.";
+"Stored in ~/.codexbar/config.json. Paste your Coding Plan API key from Model Studio." = "Armazenado em ~/.codexbar/config.json. Cole sua chave de API do Coding Plan do Model Studio.";
+"Stored in ~/.codexbar/config.json. Paste your MiniMax API key." = "Armazenado em ~/.codexbar/config.json. Cole sua chave de API do MiniMax.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or " = "Armazenado em ~/.codexbar/config.json. Você também pode informar KILO_API_KEY ou ";
+"Stores local Codex usage history (8 weeks) to personalize Pace predictions." = "Armazena histórico local de uso do Codex (8 semanas) para personalizar previsões de Ritmo.";
+"Subscription Utilization" = "Uso da assinatura";
+"Surprise me" = "Surpreenda-me";
+"Switcher shows icons" = "Alternador mostra ícones";
+"Symlink CodexBarCLI to /usr/local/bin and /opt/homebrew/bin as codexbar." = "Cria symlink de CodexBarCLI em /usr/local/bin e /opt/homebrew/bin como codexbar.";
+"System" = "Sistema";
+"Temporarily shows the loading animation after the next refresh." = "Mostra temporariamente a animação de carregamento após a próxima atualização.";
+"Tertiary (\\(label))" = "Terciário (\\(label))";
+"Tertiary (\\(tertiaryTitle))" = "Terciário (\\(tertiaryTitle))";
+"The default Codex account on this Mac." = "A conta Codex padrão deste Mac.";
+"Toggle" = "Alternar";
+"Toggle subtitle" = "Subtítulo do alternador";
+"Token" = "Token";
+"Trigger the menu bar menu from anywhere." = "Aciona o menu da barra de menus de qualquer lugar.";
+"True" = "Verdadeiro";
+"Twitter" = "Twitter";
+"Unsupported" = "Não suportado";
+"Update Channel" = "Canal de atualização";
+"Updated" = "Atualizado";
+"Updates unavailable in this build." = "Atualizações indisponíveis nesta build.";
+"Usage" = "Uso";
+"Usage breakdown" = "Detalhamento de uso";
+"Usage history (30 days)" = "Histórico de uso";
+"Usage source" = "Fonte de uso";
+"Use BigModel for the China mainland endpoints (open.bigmodel.cn)." = "Usa BigModel para endpoints da China continental (open.bigmodel.cn).";
+"Use a single menu bar icon with a provider switcher." = "Usa um único ícone na barra de menus com alternador de provedores.";
+"Use international or China mainland console gateways for quota fetches." = "Usa gateways de console internacionais ou da China continental para buscar cotas.";
+"Version" = "Versão";
+"Version \\(self.versionString)" = "Versão \\(self.versionString)";
+"Version \\(version)" = "Versão \\(version)";
+"Version \\(versionString)" = "Versão \\(versionString)";
+"Vertex AI Login" = "Login do Vertex AI";
+"Wait for the current managed Codex login to finish before adding another account." = "Aguarde o login gerenciado atual do Codex terminar antes de adicionar outra conta.";
+"Waiting for Authentication..." = "Aguardando autenticação...";
+"Website" = "Site";
+"Weekly limit confetti" = "Confete do limite semanal";
+"Weekly token limit" = "Limite semanal de tokens";
+"Weekly usage" = "Uso semanal";
+"Weekly usage unavailable for this account." = "Uso semanal indisponível para esta conta.";
+"Window: \\(window)" = "Janela: \\(window)";
+"Write logs to \\(self.fileLogPath) for debugging." = "Grava logs em \\(self.fileLogPath) para depuração.";
+"Yes" = "Sim";
+"\\(detail.modelCode): \\(usage)" = "\\(detail.modelCode): \\(usage)";
+"\\(name): \\(truncated)" = "\\(name): \\(truncated)";
+"\\(name): \\(updated) · 30d \\(cost)" = "\\(name): \\(updated) · 30d \\(cost)";
+"\\(name): fetching…\\(elapsed)" = "\\(name): buscando…\\(elapsed)";
+"\\(name): last attempt \\(when)" = "\\(name): última tentativa \\(when)";
+"\\(name): no data yet" = "\\(name): ainda sem dados";
+"\\(name): unsupported" = "\\(name): não suportado";
+"all browsers" = "todos os navegadores";
+"available again." = "disponível novamente.";
+"built_format" = "Build %@";
+"copilot_complete_in_browser" = "Conclua o login no navegador.";
+"copilot_device_code" = "Código do dispositivo copiado para a área de transferência: %1$@\n\nVerifique em: %2$@";
+"copilot_device_code_copied" = "Código do dispositivo copiado.";
+"copilot_verify_at" = "Verifique em %@";
+"copilot_waiting_text" = "Conclua o login no navegador.\nEsta janela fecha automaticamente quando o login for concluído.";
+"copilot_window_closes_auto" = "Esta janela fecha automaticamente quando o login for concluído.";
+"cost_status_error" = "%1$@: %2$@";
+"cost_status_fetching" = "%1$@: buscando… %2$@";
+"cost_status_last_attempt" = "%1$@: última tentativa %2$@";
+"cost_status_no_data" = "%@: ainda sem dados";
+"cost_status_snapshot" = "%1$@: %2$@ · %3$@ %4$@";
+"cost_status_unsupported" = "%@: não suportado";
+"credits_remaining" = "Créditos: %@";
+"cursor_on_demand" = "Sob demanda: %@";
+"cursor_on_demand_with_limit" = "Sob demanda: %1$@ / %2$@";
+"extra_usage_format" = "Uso extra: %1$@ / %2$@";
+"jetbrains_detected_generate" = "Detectado: %@. Use o assistente de IA uma vez para gerar dados de cota e atualize o CodexBar.";
+"jetbrains_detected_select" = "Detectado: %@. Selecione sua IDE preferida em Ajustes e atualize o CodexBar.";
+"last_fetch_failed_with_provider" = "Última busca de %@ falhou:";
+"last_spend" = "Último gasto: %@";
+"mcp_model_usage" = "%1$@: %2$@";
+"mcp_resets" = "Renova em: %@";
+"mcp_window" = "Janela: %@";
+"metric_average" = "Média (%1$@ + %2$@)";
+"metric_primary" = "Primário (%@)";
+"metric_secondary" = "Secundário (%@)";
+"metric_tertiary" = "Terciário (%@)";
+"multiple_workspaces_found" = "O CodexBar encontrou vários workspaces para %@. Escolha o workspace para adicionar.";
+"ory_session_…=…; csrftoken=…" = "ory_session_…=…; csrftoken=…";
+"overview_choose_providers" = "Escolha até %@ provedores";
+"remove_account_message" = "Remover %@ do CodexBar? O diretório Codex gerenciado será apagado.";
+"version_format" = "Versão %@";
+"vertex_ai_login_instructions" = "Para acompanhar o uso do Vertex AI, autentique-se no Google Cloud.\n\n1. Abra o Terminal\n2. Execute: gcloud auth application-default login\n3. Siga os prompts no navegador para entrar\n4. Defina seu projeto: gcloud config set project PROJECT_ID\n\nAbrir o Terminal agora?";
+"workspaceID is set but only opencode, opencodego, and deepgram support workspaceID." = "workspaceID está definido, mas somente opencode, opencodego e deepgram oferecem suporte a workspaceID.";
+"© 2026 Peter Steinberger. MIT License." = "© 2026 Peter Steinberger. Licença MIT.";
+
+/* General Pane */
+"section_system" = "Sistema";
+"section_usage" = "Uso";
+"section_automation" = "Automação";
+"language_title" = "Idioma";
+"language_subtitle" = "Altera o idioma de exibição. Requer reiniciar o app para ter efeito completo.";
+"language_system" = "Sistema";
+"language_english" = "Inglês";
+"language_spanish" = "Espanhol";
+"language_catalan" = "Catalão";
+"language_chinese_simplified" = "Chinês simplificado";
+"language_chinese_traditional" = "Chinês tradicional";
+"language_portuguese_brazilian" = "Português (Brasil)";
+"language_swedish" = "Sueco";
+"language_dutch" = "Nederlands";
+"language_german" = "Deutsch";
+"language_french" = "Francês";
+"language_ukrainian" = "Ucraniano";
+"language_japanese" = "Japonês";
+"language_korean" = "Coreano";
+"language_italian" = "Italiano";
+"language_polish" = "Polski";
+"start_at_login_title" = "Iniciar ao fazer login";
+"start_at_login_subtitle" = "Abre o CodexBar automaticamente ao iniciar o Mac.";
+"show_cost_summary" = "Mostrar resumo de custos";
+"show_cost_summary_subtitle" = "Lê logs de uso locais. Mostra o custo de hoje + janela selecionada no menu.";
+"cost_history_days_title" = "Janela do histórico: %d dias";
+"cost_auto_refresh_info" = "Atualização automática: a cada hora · Timeout: 10 min";
+"refresh_cadence_title" = "Cadência de atualização";
+"refresh_cadence_subtitle" = "Frequência com que o CodexBar consulta provedores em segundo plano.";
+"manual_refresh_hint" = "A atualização automática está desativada; use Atualizar no menu.";
+"check_provider_status_title" = "Verificar status dos provedores";
+"check_provider_status_subtitle" = "Consulta páginas de status da OpenAI/Claude e o Google Workspace para Gemini/Antigravity, exibindo incidentes no ícone e no menu.";
+"session_quota_notifications_title" = "Notificações de cota de sessão";
+"session_quota_notifications_subtitle" = "Notifica quando a cota de sessão de 5 horas chega a 0% e quando fica disponível novamente.";
+"quota_warning_notifications_title" = "Notificações de alerta de cota";
+"quota_warning_notifications_subtitle" = "Avisa quando a cota restante da sessão ou da semana fica abaixo dos limites configurados.";
+"quota_warnings_title" = "Alertas de cota";
+"quota_warning_session" = "sessão";
+"quota_warning_session_capitalized" = "Sessão";
+"quota_warning_weekly" = "semanal";
+"quota_warning_weekly_capitalized" = "Semanal";
+"quota_warning_notification_title" = "%1$@: cota baixa (%2$@)";
+"quota_warning_notification_body" = "%1$@ restante. Você atingiu o limite de alerta de %2$d%% (%3$@).";
+"quota_warning_notification_body_with_account" = "Conta %1$@. %2$@ restante. Você atingiu o limite de alerta de %3$d%% (%4$@).";
+"session_depleted_notification_title" = "Sessão do %@ esgotada";
+"session_depleted_notification_body" = "0% restante. Avisaremos quando estiver disponível novamente.";
+"session_restored_notification_title" = "Sessão do %@ restaurada";
+"session_restored_notification_body" = "A cota de sessão está disponível novamente.";
+"quota_warning_warn_at" = "Alertar em";
+"quota_warning_global_threshold_subtitle" = "Percentuais restantes para as janelas de sessão e semanal, a menos que um provedor defina valores próprios.";
+"quota_warning_sound" = "Reproduzir som de notificação";
+"quota_warning_provider_inherits" = "Usa as configurações globais de alerta de cota, a menos que uma janela seja personalizada aqui.";
+"quota_warning_customize_thresholds" = "Personalizar limites de %@";
+"quota_warning_enable_warnings" = "Ativar alertas de %@";
+"quota_warning_window_warn_at" = "%@: alertar em";
+"quota_warning_off" = "Desativado";
+"quota_warning_inherited" = "Usando global: %@";
+"quota_warning_depleted_only" = "somente ao esgotar";
+"quota_warning_upper" = "Limite superior";
+"quota_warning_lower" = "Limite inferior";
+"apply" = "Aplicar";
+"quit_app" = "Encerrar CodexBar";
+
+/* Tab titles */
+"tab_general" = "Geral";
+"tab_providers" = "Provedores";
+"tab_display" = "Exibição";
+"tab_advanced" = "Avançado";
+"tab_about" = "Sobre";
+"tab_debug" = "Depuração";
+
+/* Providers Pane */
+"select_a_provider" = "Selecione um provedor";
+"cancel" = "Cancelar";
+"last_fetch_failed" = "última busca falhou";
+"usage_not_fetched_yet" = "uso ainda não buscado";
+"managed_account_storage_unreadable" = "O armazenamento de contas gerenciadas está ilegível. O acesso à conta ativa ainda está disponível, mas adicionar, reautenticar e remover contas gerenciadas ficam desativados até o armazenamento ser recuperável.";
+"remove_codex_account_title" = "Remover conta Codex?";
+"remove" = "Remover";
+"managed_login_already_running" = "Um login gerenciado do Codex já está em andamento. Aguarde terminar antes de adicionar ou reautenticar outra conta.";
+"managed_login_failed" = "O login gerenciado do Codex não foi concluído. Verifique se `codex --version` funciona no Terminal. Se o macOS bloqueou ou moveu `codex` para o Lixo, remova instalações duplicadas antigas, execute `npm install -g --include=optional @openai/codex@latest` e tente novamente.";
+"codex_login_output" = "Saída do codex login:";
+"managed_login_missing_email" = "O login do Codex foi concluído, mas nenhum e-mail da conta estava disponível. Tente novamente após confirmar que a conta está totalmente conectada.";
+"login_success_notification_title" = "Login do %@ bem-sucedido";
+"login_success_notification_body" = "Você pode voltar ao app; a autenticação foi concluída.";
+"workspace_selection_cancelled" = "O CodexBar encontrou vários workspaces, mas nenhum foi selecionado.";
+"unsafe_managed_home" = "O CodexBar se recusou a modificar um caminho de diretório gerenciado inesperado: %@";
+"menu_bar_metric_title" = "Métrica da barra de menus";
+"menu_bar_metric_subtitle" = "Escolha qual janela define a porcentagem da barra de menus.";
+"menu_bar_metric_subtitle_deepseek" = "Mostra o saldo do DeepSeek na barra de menus.";
+"menu_bar_metric_subtitle_moonshot" = "Mostra o saldo da API Moonshot / Kimi na barra de menus.";
+"menu_bar_metric_subtitle_mistral" = "Mostra o gasto da API Mistral no mês atual na barra de menus.";
+"menu_bar_metric_subtitle_kimik2" = "Mostra os créditos da chave de API do Kimi K2 na barra de menus.";
+"automatic" = "Automático";
+"primary_api_key_limit" = "Primário (limite da chave de API)";
+
+/* Display Pane */
+"section_menu_bar" = "Barra de menus";
+"merge_icons_title" = "Mesclar Ícones";
+"merge_icons_subtitle" = "Usa um único ícone na barra de menus com alternador de provedores.";
+"switcher_shows_icons_title" = "Alternador mostra ícones";
+"switcher_shows_icons_subtitle" = "Mostra ícones dos provedores no alternador (caso contrário, mostra uma linha de progresso semanal).";
+"show_most_used_provider_title" = "Mostrar provedor mais usado";
+"show_most_used_provider_subtitle" = "A barra de menus mostra automaticamente o provedor mais próximo do limite de taxa.";
+"menu_bar_shows_percent_title" = "Barra de menus mostra porcentagem";
+"menu_bar_shows_percent_subtitle" = "Substitui barras de bichinhos por ícones da marca do provedor e uma porcentagem.";
+"hide_critters_title" = "Ocultar bichinhos";
+"hide_critters_subtitle" = "Mostrar barras de medição simples sem o rosto e as decorações.";
+"display_mode_title" = "Modo de exibição";
+"display_mode_subtitle" = "Escolha o que mostrar na barra de menus (Ritmo mostra uso vs. esperado).";
+"section_menu_content" = "Conteúdo do menu";
+"show_usage_as_used_title" = "Mostrar uso como consumido";
+"show_usage_as_used_subtitle" = "As barras de progresso preenchem conforme você consome a cota (em vez de mostrar o restante).";
+"show_quota_warning_markers_title" = "Mostrar marcadores de alerta de cota";
+"show_quota_warning_markers_subtitle" = "Desenha marcas de limite nas barras de uso quando os alertas de cota estão configurados.";
+"weekly_progress_work_days_title" = "Dias úteis no progresso semanal";
+"weekly_progress_work_days_subtitle" = "Define os dias úteis para marcadores das barras de uso semanal e cálculos de ritmo.";
+"show_reset_time_as_clock_title" = "Mostrar renovação como horário";
+"show_reset_time_as_clock_subtitle" = "Mostra horários de renovação como horas absolutas, em vez de contagens regressivas.";
+"show_provider_changelog_links_title" = "Mostrar links de changelog dos provedores";
+"show_provider_changelog_links_subtitle" = "Adiciona links de notas de versão para provedores baseados em CLI compatíveis no menu.";
+"show_credits_extra_usage_title" = "Mostrar créditos + uso extra";
+"show_credits_extra_usage_subtitle" = "Mostra as seções de créditos do Codex e uso extra do Claude no menu.";
+"show_all_token_accounts_title" = "Mostrar todas as contas de token";
+"show_all_token_accounts_subtitle" = "Empilha contas de token no menu (caso contrário, mostra uma barra de alternância de contas).";
+"multi_account_layout_title" = "Layout de múltiplas contas";
+"multi_account_layout_subtitle" = "Escolha alternância segmentada de contas ou cartões de contas empilhados.";
+"multi_account_layout_segmented" = "Segmentado";
+"multi_account_layout_stacked" = "Empilhado";
+"overview_tab_providers_title" = "Provedores da aba Visão geral";
+"configure" = "Configurar…";
+"overview_enable_merge_icons_hint" = "Ative Mesclar Ícones para configurar provedores da aba Visão geral.";
+"overview_no_providers_hint" = "Nenhum provedor ativado disponível para Visão geral.";
+"overview_rows_follow_order" = "As linhas da Visão geral sempre seguem a ordem dos provedores.";
+"overview_no_providers_selected" = "Nenhum provedor selecionado";
+
+/* Advanced Pane */
+"section_keyboard_shortcut" = "Atalho de teclado";
+"open_menu_shortcut_title" = "Abrir menu";
+"open_menu_shortcut_subtitle" = "Aciona o menu da barra de menus de qualquer lugar.";
+"install_cli" = "Instalar CLI";
+"install_cli_subtitle" = "Cria symlink de CodexBarCLI em /usr/local/bin e /opt/homebrew/bin como codexbar.";
+"cli_not_found" = "CodexBarCLI não encontrado no pacote do app.";
+"no_writable_bin_dirs" = "Nenhum diretório bin gravável encontrado.";
+"show_debug_settings_title" = "Mostrar ajustes de depuração";
+"show_debug_settings_subtitle" = "Exibe ferramentas de diagnóstico na aba Depuração.";
+"surprise_me_title" = "Surpreenda-me";
+"surprise_me_subtitle" = "Veja se você gosta dos seus agentes se divertindo ali em cima.";
+"weekly_limit_confetti_title" = "Confete do limite semanal";
+"weekly_limit_confetti_subtitle" = "Mostra confete em tela cheia quando o uso semanal for renovado.";
+"hide_personal_info_title" = "Ocultar informações pessoais";
+"hide_personal_info_subtitle" = "Oculta endereços de e-mail na barra de menus e na UI do menu.";
+"show_provider_storage_usage_title" = "Mostrar uso de armazenamento dos provedores";
+"show_provider_storage_usage_subtitle" = "Mostra o uso de disco local nos menus. Verifica em segundo plano caminhos conhecidos pertencentes aos provedores.";
+"section_keychain_access" = "Acesso ao Keychain";
+"keychain_access_caption" = "Desativa todas as leituras e gravações do Keychain. A importação de cookies do navegador fica indisponível; cole cabeçalhos Cookie manualmente em Provedores.";
+"disable_keychain_access_title" = "Desativar acesso ao Keychain";
+"disable_keychain_access_subtitle" = "Impede qualquer acesso ao Keychain quando ativado.";
+
+/* About Pane */
+"about_tagline" = "Que seus tokens nunca acabem — mantenha os limites dos agentes à vista.";
+"link_github" = "GitHub";
+"link_website" = "Site";
+"link_twitter" = "Twitter";
+"link_email" = "E-mail";
+"check_updates_auto" = "Buscar atualizações automaticamente";
+"update_channel" = "Canal de atualização";
+"check_for_updates" = "Buscar atualizações…";
+"updates_unavailable" = "Atualizações indisponíveis nesta build.";
+"copyright" = "© 2026 Peter Steinberger. Licença MIT.";
+
+/* Debug Pane */
+"section_logging" = "Logs";
+"enable_file_logging" = "Ativar logs em arquivo";
+"enable_file_logging_subtitle" = "Grava logs em %@ para depuração.";
+"verbosity_title" = "Verbosidade";
+"verbosity_subtitle" = "Controla o nível de detalhe dos logs.";
+"open_log_file" = "Abrir arquivo de log";
+"force_animation_next_refresh" = "Forçar animação na próxima atualização";
+"force_animation_next_refresh_subtitle" = "Mostra temporariamente a animação de carregamento após a próxima atualização.";
+"section_loading_animations" = "Animações de carregamento";
+"loading_animations_caption" = "Escolha um padrão e reproduza na barra de menus. \"Aleatório\" mantém o comportamento atual.";
+"animation_random_default" = "Aleatório (padrão)";
+"replay_selected_animation" = "Reproduzir animação selecionada";
+"blink_now" = "Piscar agora";
+"section_probe_logs" = "Logs de verificação";
+"probe_logs_caption" = "Busca a saída mais recente da verificação para depuração; Copiar mantém o texto completo.";
+"fetch_log" = "Buscar log";
+"copy" = "Copiar";
+"save_to_file" = "Salvar em arquivo";
+"load_parse_dump" = "Carregar dump de análise";
+"rerun_provider_autodetect" = "Executar novamente a detecção automática de provedores";
+"loading" = "Carregando…";
+"no_log_yet_fetch" = "Ainda sem log. Busque para carregar.";
+"section_fetch_strategy" = "Tentativas da estratégia de busca";
+"fetch_strategy_caption" = "Últimas decisões e erros do pipeline de busca de um provedor.";
+"section_openai_cookies" = "Cookies da OpenAI";
+"openai_cookies_caption" = "Logs de importação de cookies + scraping WebKit da última tentativa de cookies da OpenAI.";
+"no_log_yet" = "Ainda sem log. Atualize os cookies da OpenAI em Provedores → Codex para executar uma importação.";
+"section_caches" = "Caches";
+"caches_caption" = "Limpa resultados de varredura de custo em cache ou caches de cookies do navegador.";
+"clear_cookie_cache" = "Limpar cache de cookies";
+"clear_cost_cache" = "Limpar cache de custos";
+"section_notifications" = "Notificações";
+"notifications_caption" = "Aciona notificações de teste para a janela de sessão de 5 horas (esgotada/restaurada).";
+"post_depleted" = "Notificar esgotamento";
+"post_restored" = "Notificar restauração";
+"section_cli_sessions" = "Sessões da CLI";
+"cli_sessions_caption" = "Mantém sessões da CLI Codex/Claude ativas após uma verificação. Por padrão, sai assim que os dados são capturados.";
+"keep_cli_sessions_alive" = "Manter sessões da CLI ativas";
+"keep_cli_sessions_alive_subtitle" = "Não encerra entre verificações (somente depuração).";
+"reset_cli_sessions" = "Reiniciar sessões da CLI";
+"section_error_simulation" = "Simulação de erro";
+"error_simulation_caption" = "Insere uma mensagem de erro falsa no card do menu para testar o layout.";
+"set_menu_error" = "Definir erro do menu";
+"clear_menu_error" = "Limpar erro do menu";
+"set_cost_error" = "Definir erro de custo";
+"clear_cost_error" = "Limpar erro de custo";
+"section_cli_paths" = "Caminhos da CLI";
+"cli_paths_caption" = "Binário do Codex e camadas de PATH resolvidos; captura do PATH de login na inicialização (timeout curto).";
+"codex_binary" = "Binário do Codex";
+"claude_binary" = "Binário do Claude";
+"effective_path" = "PATH efetivo";
+"unavailable" = "Indisponível";
+"login_shell_path" = "PATH do shell de login (captura na inicialização)";
+"cleared" = "Limpo.";
+"no_fetch_attempts" = "Ainda sem tentativas de busca.";
+"macOS Tahoe can block menu bar apps in System Settings → Menu Bar → Allow in the Menu Bar. CodexBar is running, but macOS may be hiding its icon. Open Menu Bar settings and turn CodexBar on." = "O macOS Tahoe pode bloquear apps da barra de menus em Ajustes do Sistema → Barra de Menus → Permitir na Barra de Menus. O CodexBar está em execução, mas o macOS pode estar ocultando seu ícone. Abra os ajustes da Barra de Menus e ative o CodexBar.";
+
+/* Metric preferences */
+"metric_pref_automatic" = "Automático";
+"metric_pref_primary" = "Primário";
+"metric_pref_secondary" = "Secundário";
+"metric_pref_tertiary" = "Terciário";
+"metric_pref_extra_usage" = "Uso extra";
+"metric_pref_average" = "Média";
+"metric_mistral_payg" = "Pay-as-you-go";
+"metric_mistral_monthly_plan" = "Monthly Plan";
+
+/* Display modes */
+"display_mode_percent" = "Porcentagem";
+"display_mode_pace" = "Ritmo";
+"display_mode_both" = "Ambos";
+"display_mode_reset_time" = "Tempo de redefinição";
+"display_mode_percent_desc" = "Mostra a porcentagem restante/usada (ex.: 45%)";
+"display_mode_pace_desc" = "Mostra o indicador de ritmo (ex.: +5%)";
+"display_mode_both_desc" = "Mostra porcentagem e ritmo (ex.: 45% · +5%)";
+"display_mode_reset_time_desc" = "Mostra o tempo de redefinição da métrica selecionada (ex.: ↻ 3:56 PM)";
+
+/* Provider status */
+"status_operational" = "Operacional";
+"status_partial_outage" = "Falha parcial";
+"status_major_outage" = "Falha geral";
+"status_critical_issue" = "Problema crítico";
+"status_maintenance" = "Manutenção";
+"status_unknown" = "Status desconhecido";
+
+/* Refresh frequency */
+"refresh_manual" = "Manual";
+"refresh_1min" = "1 min";
+"refresh_2min" = "2 min";
+"refresh_5min" = "5 min";
+"refresh_15min" = "15 min";
+"refresh_30min" = "30 min";
+
+/* Additional keys */
+"not_found" = "Não encontrado";
+
+/* Cost estimation */
+"cost_header_estimated" = "Custo (estimado)";
+"cost_estimate_hint" = "Estimado a partir de logs locais · pode diferir da sua fatura";
+"No JetBrains IDE with AI Assistant detected. Install a JetBrains IDE and enable AI Assistant." = "Nenhuma IDE JetBrains com AI Assistant detectada. Instale uma IDE JetBrains e ative o AI Assistant.";
+"OpenRouter API token not configured. Set OPENROUTER_API_KEY environment variable or configure in Settings." = "Token de API do OpenRouter não configurado. Defina a variável de ambiente OPENROUTER_API_KEY ou configure em Ajustes.";
+"z.ai API token not found. Set apiKey in ~/.codexbar/config.json or Z_AI_API_KEY." = "Token de API do z.ai não encontrado. Defina apiKey em ~/.codexbar/config.json ou Z_AI_API_KEY.";
+"Missing DeepSeek API key." = "Chave de API do DeepSeek ausente.";
+"%@ is unavailable in the current environment." = "%@ está indisponível no ambiente atual.";
+"All Systems Operational" = "Todos os sistemas operacionais";
+"Last 30 days" = "Últimos 30 dias";
+"Last 30 days:" = "Últimos 30 dias:";
+"This month" = "Este mês";
+"Store multiple OpenAI API keys." = "Armazena várias chaves de API da OpenAI.";
+"Admin API key" = "Chave de API admin";
+"Open billing" = "Abrir faturamento";
+"Google accounts" = "Contas Google";
+"Store multiple Antigravity Google OAuth accounts for quick switching." = "Armazena várias contas Google OAuth do Antigravity para troca rápida.";
+"Add Google Account" = "Adicionar conta Google";
+"Open Token Plan" = "Abrir Token Plan";
+"Text Generation" = "Geração de texto";
+"Text to Speech" = "Texto para fala";
+"Music Generation" = "Geração de música";
+"Image Generation" = "Geração de imagem";
+"No local data found" = "Nenhum dado local encontrado";
+"Credits unavailable; keep Codex running to refresh." = "Créditos indisponíveis; mantenha o Codex em execução para atualizar.";
+"No available fetch strategy for minimax." = "Nenhuma estratégia de busca disponível para o minimax.";
+"No Cursor session found. Please log in to cursor.com in Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX, or Edge Canary. If you use Safari, grant CodexBar Full Disk Access in System Settings ▸ Privacy & Security. You can also sign in to Cursor from the CodexBar menu (Add / switch account)." = "Nenhuma sessão do Cursor encontrada. Faça login em cursor.com no Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX ou Edge Canary. Se você usa o Safari, conceda Acesso Total ao Disco ao CodexBar em Ajustes do Sistema ▸ Privacidade e Segurança. Você também pode entrar no Cursor pelo menu do CodexBar (Adicionar / trocar conta).";
+"No OpenCode session cookies found in browsers." = "Nenhum cookie de sessão do OpenCode encontrado nos navegadores.";
+"No available fetch strategy for %@." = "Nenhuma estratégia de busca disponível para %@.";
+"Today" = "Hoje";
+"Today tokens" = "Tokens de hoje";
+"30d cost" = "Custo 30 d";
+"30d tokens" = "Tokens 30 d";
+"Latest tokens" = "Tokens recentes";
+"Top model" = "Modelo principal";
+"Storage" = "Armazenamento";
+"Add Account..." = "Adicionar conta...";
+"Usage Dashboard" = "Dashboard de uso";
+"Status Page" = "Página de status";
+"Settings..." = "Ajustes...";
+"About CodexBar" = "Sobre o CodexBar";
+"Quit" = "Encerrar";
+"Last %d day" = "Último %d dia";
+"Last %d days" = "Últimos %d dias";
+"%@ tokens" = "%@ tokens";
+"Latest billing day" = "Último dia de cobrança";
+"Latest billing day (%@)" = "Último dia de cobrança (%@)";
+"%@ left" = "%@ restante";
+"Resets %@" = "Renova %@";
+"Resets in %@" = "Renova em %@";
+"Resets now" = "Renova agora";
+"reset_tomorrow_format" = "amanhã, %@";
+"Lasts until reset" = "Dura até a renovação";
+"Updated %@" = "Atualizado %@";
+"Updated %@h ago" = "Atualizado há %@h";
+"Updated %@m ago" = "Atualizado há %@m";
+"Updated just now" = "Atualizado agora mesmo";
+"Projected empty in %@" = "Esgotamento previsto em %@";
+"Runs out in %@" = "Esgota em %@";
+"Pace: %@" = "Ritmo: %@";
+"Pace: %@ · %@" = "Ritmo: %@ · %@";
+"%@ · %@" = "%@ · %@";
+"≈ %d%% run-out risk" = "≈ %d%% de risco de esgotar";
+"%d%% in deficit" = "%d%% em déficit";
+"%d%% in reserve" = "%d%% em reserva";
+"usage_percent_suffix_left" = "restante";
+"usage_percent_suffix_used" = "usado";
+"Store multiple DeepSeek API keys." = "Armazena várias chaves de API do DeepSeek.";
+"This week" = "Esta semana";
+"Week" = "Semana";
+"Month" = "Mês";
+"Models" = "Modelos";
+"24h tokens" = "Tokens 24 h";
+"Latest hour" = "Última hora";
+"Peak hour" = "Hora de pico";
+"Top method" = "Método principal";
+"30d cash" = "Dinheiro 30 d";
+"30d billing history from MiniMax web session" = "Histórico de cobrança de 30 dias da sessão web da MiniMax";
+"AWS Cost Explorer billing can lag." = "A cobrança do AWS Cost Explorer pode atrasar.";
+"Rate limit: %d / %@" = "Limite de taxa: %d / %@";
+"Key remaining" = "Restante da chave";
+"No limit set for the API key" = "Nenhum limite configurado para a chave API";
+"API key limit unavailable right now" = "O limite da chave API está indisponível no momento";
+"This month: %@ tokens" = "Este mês: %@ tokens";
+"No utilization data yet." = "Ainda sem dados de uso.";
+"No %@ utilization data yet." = "Ainda sem dados de uso de %@.";
+"%@: %@%% used" = "%@: %@%% usado";
+"%dd" = "%dd";
+"today" = "hoje";
+"just now" = "agora mesmo";
+"On pace" = "No ritmo";
+"Runs out now" = "Esgota agora";
+"Projected empty now" = "Esgotamento previsto agora";
+"Switch Account..." = "Trocar conta...";
+"Update ready, restart now?" = "Atualização pronta, reiniciar agora?";
+"Daily" = "Diário";
+"Hourly Tokens" = "Tokens por hora";
+"No data" = "Sem dados";
+"No usage breakdown data available." = "Nenhum dado de detalhamento de uso disponível.";
+
+"Today: %@ · %@ tokens" = "Hoje: %@ · %@ tokens";
+"Today: %@" = "Hoje: %@";
+"Today: %@ tokens" = "Hoje: %@ tokens";
+"Last 30 days: %@ · %@ tokens" = "Últimos 30 dias: %@ · %@ tokens";
+"Last 30 days: %@" = "Últimos 30 dias: %@";
+"Est. total (30d): %@" = "Total est. (30d): %@";
+"Est. total (%@): %@" = "Total est. (%@): %@";
+"Hover a bar for details" = "Passe o mouse sobre uma barra para ver detalhes";
+"%@: %@ · %@ tokens" = "%@: %@ · %@ tokens";
+"No providers selected for Overview." = "Nenhum provedor selecionado para a Visão geral.";
+"No overview data available." = "Nenhum dado de visão geral disponível.";
+"Auto uses the local IDE API first, then Google OAuth when the IDE is closed." = "Automático usa primeiro a API local da IDE e depois o Google OAuth quando a IDE está fechada.";
+"Login with Google" = "Entrar com o Google";
+
+/* Popup panels */
+"No usage configured." = "Nenhum uso configurado.";
+"Quota" = "Cota";
+"tokens" = "tokens";
+"requests" = "requisições";
+"Latest" = "Mais recente";
+"Monthly" = "Mensal";
+"Sonnet" = "Sonnet";
+"Overages" = "Excedentes";
+"Activity" = "Atividade";
+"Copied" = "Copiado";
+"Copy error" = "Erro ao copiar";
+"Copy path" = "Copiar caminho";
+"Extra usage spent" = "Gasto de uso extra";
+"Credits remaining" = "Créditos restantes";
+"Using CLI fallback" = "Usando fallback da CLI";
+"Balance updates in near-real time (up to 5 min lag)" = "O saldo atualiza quase em tempo real (até 5 min de atraso)";
+"Daily billing data finalizes at 07:00 UTC" = "Os dados diários de cobrança fecham às 07:00 UTC";
+"%@ of %@ credits left" = "Restam %@ de %@ créditos";
+"%@ of %@ bonus credits left" = "Restam %@ de %@ créditos bônus";
+"%@ / %@ (%@ remaining)" = "%@ / %@ (%@ restante)";
+"%@/%@ left" = "%@/%@ restante";
+"Gemini Flash" = "Gemini Flash";
+"Regenerates %@" = "Regenera %@";
+"used after next regen" = "usado após a próxima regeneração";
+"after next regen" = "após a próxima regeneração";
+"Near full" = "Quase cheio";
+"Full in ~1 regen" = "Cheio em ~1 regeneração";
+"Full in ~%.0f regens" = "Cheio em ~%.0f regenerações";
+"Overage usage" = "Uso excedente";
+"Overage cost" = "Custo excedente";
+"credits" = "créditos";
+"Zen balance" = "Saldo Zen";
+"API spend" = "Gasto de API";
+"Extra usage" = "Uso extra";
+"Quota usage" = "Uso da cota";
+"Your spend" = "Seu gasto";
+"%.0f%% used" = "%.0f%% usado";
+"Usage history (today)" = "Histórico de uso (hoje)";
+"Usage history (%d days)" = "Histórico de uso (%d dias)";
+"%d percent remaining" = "%d%% restante";
+"Unknown" = "Desconhecido";
+"stale data" = "dados desatualizados";
+"No credits history data." = "Sem dados de histórico de créditos.";
+"No credits history data available." = "Nenhum dado de histórico de créditos disponível.";
+"Credits history chart" = "Gráfico de histórico de créditos";
+"%d days of credits data" = "%d dias de dados de créditos";
+"Usage breakdown chart" = "Gráfico de detalhamento de uso";
+"%d days of usage data across %d services" = "%d dias de dados de uso em %d serviços";
+"Cost history chart" = "Gráfico de histórico de custos";
+"%d days of cost data" = "%d dias de dados de custos";
+"Plan utilization chart" = "Gráfico de utilização do plano";
+"%d utilization samples" = "%d amostras de utilização";
+"Hourly Usage" = "Uso por hora";
+"Usage remaining" = "Uso restante";
+"Usage used" = "Uso usado";
+"API key verified. Ollama does not expose Cloud quota limits through the API." = "Chave de API verificada. O Ollama não expõe limites de cota do Cloud pela API.";
+"Last 30 days: %@ tokens" = "Últimos 30 dias: %@ tokens";
+"7d spend" = "Gasto 7 d";
+"30d spend" = "Gasto 30 d";
+"Cache read" = "Leitura de cache";
+"Claude Admin API 30 day spend trend" = "Tendência de gasto de 30 dias da Claude Admin API";
+"OpenRouter API key spend trend" = "Tendência de gasto da chave API do OpenRouter";
+"z.ai hourly token trend" = "Tendência horária de tokens da z.ai";
+"MiniMax 30 day token usage trend" = "Tendência de uso de tokens de 30 dias da MiniMax";
+"Today cash" = "Dinheiro de hoje";
+"DeepSeek 30 day token usage trend" = "Tendência de uso de tokens de 30 dias da DeepSeek";
+"cache-hit input" = "entrada com acerto de cache";
+"cache-miss input" = "entrada sem acerto de cache";
+"output" = "saída";
+"Requests" = "Requisições";
+"Reported by OpenAI Admin API organization usage." = "Reportado pelo uso da organização na OpenAI Admin API.";
+"Reported by Mistral billing usage." = "Reportado pelo uso de cobrança da Mistral.";
+"Google OAuth" = "Google OAuth";
+"Add accounts via GitHub OAuth Device Flow on the selected host." = "Adiciona contas via GitHub OAuth Device Flow no host selecionado.";
+"Stores each signed-in Google account for quick Antigravity switching. Uses Antigravity.app OAuth when available, or ANTIGRAVITY_OAUTH_CLIENT_ID and ANTIGRAVITY_OAUTH_CLIENT_SECRET as an override." = "Armazena cada conta Google conectada para troca rápida no Antigravity. Usa o OAuth do Antigravity.app quando disponível, ou ANTIGRAVITY_OAUTH_CLIENT_ID e ANTIGRAVITY_OAUTH_CLIENT_SECRET como substituição.";
+"Manual cleanup: past sessions" = "Limpeza manual: sessões anteriores";
+"Clearing removes past resume, continue, and rewind history." = "A limpeza remove o histórico de retomar, continuar e voltar.";
+"Manual cleanup: file checkpoints" = "Limpeza manual: checkpoints de arquivo";
+"Clearing removes checkpoint restore data for previous edits." = "A limpeza remove os dados de restauração de checkpoint de edições anteriores.";
+"Manual cleanup: saved plans" = "Limpeza manual: planos salvos";
+"Clearing removes old plan-mode files." = "A limpeza remove arquivos antigos do modo de planejamento.";
+"Manual cleanup: debug logs" = "Limpeza manual: logs de depuração";
+"Clearing removes past debug logs." = "A limpeza remove logs de depuração anteriores.";
+"Manual cleanup: attachment cache" = "Limpeza manual: cache de anexos";
+"Clearing removes cached large pastes or attached images." = "A limpeza remove colagens grandes ou imagens anexadas em cache.";
+"Manual cleanup: session metadata" = "Limpeza manual: metadados de sessão";
+"Clearing removes per-session environment metadata." = "A limpeza remove os metadados de ambiente por sessão.";
+"Manual cleanup: shell snapshots" = "Limpeza manual: snapshots de shell";
+"Clearing removes leftover runtime shell snapshot files." = "A limpeza remove arquivos de snapshot de shell de runtime remanescentes.";
+"Manual cleanup: legacy todos" = "Limpeza manual: tarefas legadas";
+"Clearing removes legacy per-session task lists." = "A limpeza remove listas de tarefas legadas por sessão.";
+"Manual cleanup: sessions" = "Limpeza manual: sessões";
+"Clearing removes past Codex session history." = "A limpeza remove o histórico de sessões anteriores do Codex.";
+"Manual cleanup: archived sessions" = "Limpeza manual: sessões arquivadas";
+"Clearing removes archived Codex session history." = "A limpeza remove o histórico de sessões arquivadas do Codex.";
+"Manual cleanup: cache" = "Limpeza manual: cache";
+"Clearing removes provider-owned cached data." = "A limpeza remove dados em cache pertencentes ao provedor.";
+"Manual cleanup: logs" = "Limpeza manual: logs";
+"Clearing removes local diagnostic logs." = "A limpeza remove logs de diagnóstico locais.";
+"Manual cleanup: file history" = "Limpeza manual: histórico de arquivos";
+"Clearing removes local edit checkpoint history." = "A limpeza remove o histórico local de checkpoints de edição.";
+"Manual cleanup: temporary data" = "Limpeza manual: dados temporários";
+"Clearing removes local temporary provider data." = "A limpeza remove dados temporários locais do provedor.";
+"Total: %@" = "Total: %@";
+"%d more items" = "Mais %d itens";
+"Cleanup ideas" = "Ideias de limpeza";
+"%d unreadable item(s) skipped" = "%d item(ns) ilegível(is) ignorado(s)";
+
+"API key limit" = "Limite da chave API";
+"Auth" = "Autenticação";
+"Auto" = "Automático";
+"Disabled — no recent data" = "Desativado — sem dados recentes";
+"Limits not available" = "Limites indisponíveis";
+"No usage yet" = "Ainda sem uso";
+"Not fetched yet" = "Ainda não buscado";
+"Refreshing" = "Atualizando";
+"Session" = "Sessão";
+"Source" = "Fonte";
+"State" = "Estado";
+"Unavailable" = "Indisponível";
+"Weekly" = "Semanal";
+"not detected" = "não detectado";
+"Estimated from local Codex logs for the selected account." = "Estimado a partir de logs locais do Codex para a conta selecionada.";
+"minimax_usage_amount_format" = "Uso: %@ / %@";
+"minimax_used_percent_format" = "Usado %@";
+"minimax_service_text_generation" = "Geração de texto";
+"minimax_service_text_to_speech" = "Texto para fala";
+"minimax_service_music_generation" = "Geração de música";
+"minimax_service_image_generation" = "Geração de imagem";
+"minimax_service_lyrics_generation" = "Geração de letras";
+"minimax_service_coding_plan_vlm" = "VLM do Coding Plan";
+"minimax_service_coding_plan_search" = "Busca do Coding Plan";
+
+/* Additional provider settings and alerts */
+"%@ is waiting for permission" = "%@ está aguardando permissão";
+"%@ requests" = "%@ solicitações";
+"%@: %@ credits" = "%@: %@ créditos";
+"30d requests" = "Solicitações de 30 dias";
+"4 days" = "4 dias";
+"5 days" = "5 dias";
+"7 days" = "7 dias";
+"API key verifies Ollama Cloud access; cookies still expose quota limits." = "A chave de API verifica o acesso ao Ollama Cloud; os cookies ainda expõem limites de cota.";
+"AWS access key ID. Can also be set with AWS_ACCESS_KEY_ID." = "ID da chave de acesso da AWS. Também pode ser definido com AWS_ACCESS_KEY_ID.";
+"AWS region. Can also be set with AWS_REGION." = "Região da AWS. Também pode ser definida com AWS_REGION.";
+"AWS secret access key. Can also be set with AWS_SECRET_ACCESS_KEY." = "Chave secreta de acesso da AWS. Também pode ser definida com AWS_SECRET_ACCESS_KEY.";
+"Access key ID" = "ID da chave de acesso";
+"Add Account" = "Adicionar conta";
+"Adding Account…" = "Adicionando conta…";
+"Antigravity login failed" = "Falha no login do Antigravity";
+"Antigravity login timed out" = "Tempo esgotado no login do Antigravity";
+"Auth source" = "Fonte de autenticação";
+"Automatic imports browser cookies from Xiaomi MiMo." = "Importa automaticamente cookies do navegador do Xiaomi MiMo.";
+"Automatic imports Windsurf session data from Chromium browser localStorage." = "Importa automaticamente dados de sessão do Windsurf do localStorage do Chromium.";
+"Automatic imports browser cookies from Bailian." = "Importa automaticamente cookies do navegador do Bailian.";
+"Automatically imports browser cookies." = "Importa automaticamente cookies do navegador.";
+"Automatically imports browser session cookies." = "Importa automaticamente cookies de sessão do navegador.";
+"Azure OpenAI deployment name. AZURE_OPENAI_DEPLOYMENT_NAME is also supported." = "Nome do deployment do Azure OpenAI. AZURE_OPENAI_DEPLOYMENT_NAME também é aceito.";
+"Azure OpenAI key" = "Chave do Azure OpenAI";
+"Azure OpenAI resource endpoint. AZURE_OPENAI_ENDPOINT is also supported." = "Endpoint do recurso Azure OpenAI. AZURE_OPENAI_ENDPOINT também é aceito.";
+"Base URL" = "URL base";
+"Base URL for the LLM-API-Key-Proxy instance." = "URL base da instância LLM-API-Key-Proxy.";
+"Browser cookies" = "Cookies do navegador";
+"Cap end" = "Fim do limite";
+"Cap start" = "Início do limite";
+"Capacity End" = "Fim da capacidade";
+"Capacity Start" = "Início da capacidade";
+"Changelog" = "Registro de alterações";
+"Choose the Moonshot/Kimi API host for international or China mainland accounts." = "Escolha o host da API Moonshot/Kimi para contas internacionais ou da China continental.";
+"CodexBar can't replace a system account that is signed in with an API key only setup." = "O CodexBar não pode substituir uma conta do sistema conectada apenas com chave de API.";
+"CodexBar could not find saved auth for that account. Re-authenticate it and try again." = "O CodexBar não encontrou autenticação salva para essa conta. Reautentique e tente novamente.";
+"CodexBar could not read managed account storage. Recover the store before adding another account." = "O CodexBar não conseguiu ler o armazenamento de contas gerenciadas. Recupere o armazenamento antes de adicionar outra conta.";
+"CodexBar could not read saved auth for that account. Re-authenticate it and try again." = "O CodexBar não conseguiu ler a autenticação salva dessa conta. Reautentique e tente novamente.";
+"CodexBar could not read the current system account on this Mac." = "O CodexBar não conseguiu ler a conta do sistema atual neste Mac.";
+"CodexBar could not replace the live Codex auth on this Mac." = "O CodexBar não conseguiu substituir a autenticação ativa do Codex neste Mac.";
+"CodexBar could not safely preserve the current system account before switching." = "O CodexBar não conseguiu preservar com segurança a conta do sistema atual antes da troca.";
+"CodexBar could not save the current system account before switching." = "O CodexBar não conseguiu salvar a conta do sistema atual antes da troca.";
+"CodexBar could not update managed account storage." = "O CodexBar não conseguiu atualizar o armazenamento de contas gerenciadas.";
+"CodexBar found another managed account that already uses the current system account. Resolve the duplicate account before switching." = "O CodexBar encontrou outra conta gerenciada que já usa a conta do sistema atual. Resolva a conta duplicada antes de trocar.";
+"CodexBar will ask macOS Keychain for “%@” so it can decrypt browser cookies and authenticate your account. Click OK to continue." = "O CodexBar pedirá ao Chaves do macOS “%@” para descriptografar cookies do navegador e autenticar sua conta. Clique em OK para continuar.";
+"CodexBar will ask macOS Keychain for the Claude Code OAuth token so it can fetch your Claude usage. Click OK to continue." = "O CodexBar pedirá ao Chaves do macOS o token OAuth do Claude Code para buscar seu uso do Claude. Clique em OK para continuar.";
+"CodexBar will ask macOS Keychain for your Amp cookie header so it can fetch usage. Click OK to continue." = "O CodexBar pedirá ao Chaves do macOS o cabeçalho Cookie do Amp para buscar uso. Clique em OK para continuar.";
+"CodexBar will ask macOS Keychain for your Augment cookie header so it can fetch usage. Click OK to continue." = "O CodexBar pedirá ao Chaves do macOS o cabeçalho Cookie do Augment para buscar uso. Clique em OK para continuar.";
+"CodexBar will ask macOS Keychain for your Claude cookie header so it can fetch Claude web usage. Click OK to continue." = "O CodexBar pedirá ao Chaves do macOS o cabeçalho Cookie do Claude para buscar uso web do Claude. Clique em OK para continuar.";
+"CodexBar will ask macOS Keychain for your Cursor cookie header so it can fetch usage. Click OK to continue." = "O CodexBar pedirá ao Chaves do macOS o cabeçalho Cookie do Cursor para buscar uso. Clique em OK para continuar.";
+"CodexBar will ask macOS Keychain for your Factory cookie header so it can fetch usage. Click OK to continue." = "O CodexBar pedirá ao Chaves do macOS o cabeçalho Cookie do Factory para buscar uso. Clique em OK para continuar.";
+"CodexBar will ask macOS Keychain for your GitHub Copilot token so it can fetch usage. Click OK to continue." = "O CodexBar pedirá ao Chaves do macOS o token do GitHub Copilot para buscar uso. Clique em OK para continuar.";
+"CodexBar will ask macOS Keychain for your Kimi K2 API key so it can fetch usage. Click OK to continue." = "O CodexBar pedirá ao Chaves do macOS a chave API do Kimi K2 para buscar uso. Clique em OK para continuar.";
+"CodexBar will ask macOS Keychain for your Kimi auth token so it can fetch usage. Click OK to continue." = "O CodexBar pedirá ao Chaves do macOS o token de autenticação do Kimi para buscar uso. Clique em OK para continuar.";
+"CodexBar will ask macOS Keychain for your MiniMax API token so it can fetch usage. Click OK to continue." = "O CodexBar pedirá ao Chaves do macOS o token API do MiniMax para buscar uso. Clique em OK para continuar.";
+"CodexBar will ask macOS Keychain for your MiniMax cookie header so it can fetch usage. Click OK to continue." = "O CodexBar pedirá ao Chaves do macOS o cabeçalho Cookie do MiniMax para buscar uso. Clique em OK para continuar.";
+"CodexBar will ask macOS Keychain for your OpenAI cookie header so it can fetch Codex dashboard extras. Click OK to continue." = "O CodexBar pedirá ao Chaves do macOS o cabeçalho Cookie da OpenAI para buscar extras do painel Codex. Clique em OK para continuar.";
+"CodexBar will ask macOS Keychain for your OpenCode cookie header so it can fetch usage. Click OK to continue." = "O CodexBar pedirá ao Chaves do macOS o cabeçalho Cookie do OpenCode para buscar uso. Clique em OK para continuar.";
+"CodexBar will ask macOS Keychain for your Synthetic API key so it can fetch usage. Click OK to continue." = "O CodexBar pedirá ao Chaves do macOS a chave API do Synthetic para buscar uso. Clique em OK para continuar.";
+"CodexBar will ask macOS Keychain for your z.ai API token so it can fetch usage. Click OK to continue." = "O CodexBar pedirá ao Chaves do macOS o token API do z.ai para buscar uso. Clique em OK para continuar.";
+"Could not open Cursor login in your browser." = "Não foi possível abrir o login do Cursor no navegador.";
+"Could not open browser for Antigravity" = "Não foi possível abrir o navegador para Antigravity";
+"Credits used" = "Créditos usados";
+"Day" = "Dia";
+"Deployment" = "Deployment";
+"Drag to reorder" = "Arraste para reordenar";
+"Sort providers alphabetically" = "Ordenar provedores alfabeticamente";
+"Sort providers alphabetically (enabled first)" = "Ordenar provedores alfabeticamente (ativados primeiro)";
+"Sorted alphabetically (enabled first) — click to use your custom order" = "Ordenados alfabeticamente (ativados primeiro) — clique para usar sua ordem personalizada";
+"Endpoint" = "Endpoint";
+"Enterprise host" = "Host Enterprise";
+"Extra usage balance: %@" = "Saldo de uso extra: %@";
+"Keychain Access Required" = "Acesso ao Chaves necessário";
+"Kiro menu bar value" = "Valor do Kiro na barra de menu";
+"Label" = "Rótulo";
+"No organizations loaded. Click Refresh after setting your API key." = "Nenhuma organização carregada. Clique em Atualizar depois de definir sua chave API.";
+"No output captured." = "Nenhuma saída capturada.";
+"No system account" = "Sem conta do sistema";
+"Oasis-Token" = "Oasis-Token";
+"Open Augment (Log Out & Back In)" = "Abrir Augment (sair e entrar novamente)";
+"Open Codebuff Dashboard" = "Abrir painel do Codebuff";
+"Open Command Code Settings" = "Abrir configurações do Command Code";
+"Open Crof dashboard" = "Abrir painel do Crof";
+"Open Manus" = "Abrir Manus";
+"Open MiMo Balance" = "Abrir saldo do MiMo";
+"Open Moonshot Console" = "Abrir console do Moonshot";
+"Open Ollama API Keys" = "Abrir chaves API do Ollama";
+"Open StepFun Platform" = "Abrir plataforma StepFun";
+"Open T3 Chat Settings" = "Abrir configurações do T3 Chat";
+"Open Volcengine Ark Console" = "Abrir console Volcengine Ark";
+"Open legacy provider docs" = "Abrir docs do provedor legado";
+"Open projects" = "Abrir projetos";
+"Open this URL manually to continue login:\n\n%@" = "Abra esta URL manualmente para continuar o login:\n\n%@";
+"Optional organization ID for accounts linked to multiple Anthropic organizations." = "ID de organização opcional para contas vinculadas a várias organizações Anthropic.";
+"Optional. Applies to the configured Admin API key; selected token accounts do not inherit OPENAI_PROJECT_ID." = "Opcional. Aplica-se à chave Admin API configurada; contas de token selecionadas não herdam OPENAI_PROJECT_ID.";
+"Optional. Enter your GitHub Enterprise host, for example octocorp.ghe.com. Leave blank for github.com." = "Opcional. Informe seu host GitHub Enterprise, por exemplo octocorp.ghe.com. Deixe em branco para github.com.";
+"Optional. Leave blank to discover and aggregate projects visible to the API key." = "Opcional. Deixe em branco para descobrir e agregar projetos visíveis à chave API.";
+"Org ID (optional)" = "ID da org. (opcional)";
+"Organizations" = "Organizações";
+"Password" = "Senha";
+"%@ authentication is disabled." = "A autenticação de %@ está desativada.";
+"%@ cookies are disabled." = "Os cookies de %@ estão desativados.";
+"%@ web API access is disabled." = "O acesso à API web de %@ está desativado.";
+"Disable %@ dashboard cookie usage." = "Desativar o uso de cookies do painel de %@.";
+"Keychain access is disabled in Advanced, so browser cookie import is unavailable." = "O acesso ao Chaves está desativado em Avançado, então a importação de cookies do navegador está indisponível.";
+"Manually paste an %@ from a browser session." = "Cole manualmente um %@ de uma sessão do navegador.";
+"Paste a Cookie header captured from %@." = "Cole um cabeçalho Cookie capturado de %@.";
+"Paste a Cookie header from %@." = "Cole um cabeçalho Cookie de %@.";
+"Paste a Cookie header or cURL capture from %@." = "Cole um cabeçalho Cookie ou captura cURL de %@.";
+"Paste a Cookie header or full cURL capture from %@." = "Cole um cabeçalho Cookie ou captura cURL completa de %@.";
+"Paste a Cookie or Authorization header from %@." = "Cole um cabeçalho Cookie ou Authorization de %@.";
+"Paste a full cookie header or the %@ value." = "Cole um cabeçalho de cookies completo ou o valor %@.";
+"Paste a Cookie header or full cURL capture from T3 Chat settings." = "Cole um cabeçalho Cookie ou captura cURL completa das configurações do T3 Chat.";
+"Paste the Cookie header from a request to admin.mistral.ai. Must contain an ory_session_* cookie." = "Cole o cabeçalho Cookie de uma solicitação a admin.mistral.ai. Deve conter um cookie ory_session_*.";
+"Paste the Oasis-Token from a logged-in browser session on platform.stepfun.com." = "Cole o Oasis-Token de uma sessão conectada em platform.stepfun.com.";
+"Paste the %@ JSON bundle from %@." = "Cole o pacote JSON %@ de %@.";
+"Paste the %@ value or a full Cookie header." = "Cole o valor %@ ou um cabeçalho Cookie completo.";
+"Personal account" = "Conta pessoal";
+"Project ID" = "ID do projeto";
+"Re-auth" = "Reautenticar";
+"Re-login at claude.ai" = "Entrar novamente no claude.ai";
+"Re-authenticating…" = "Reautenticando…";
+"Refresh Session" = "Atualizar sessão";
+"Refresh organizations" = "Atualizar organizações";
+"Region" = "Região";
+"Reload" = "Recarregar";
+"Reorder" = "Reordenar";
+"Secret access key" = "Chave secreta de acesso";
+"Series" = "Série";
+"Service" = "Serviço";
+"Show or hide Kiro credits, percent, or both next to the menu bar icon." = "Mostra ou oculta créditos Kiro, porcentagem ou ambos ao lado do ícone da barra de menu.";
+"Show usage for organizations you belong to. Personal account is always shown." = "Mostra o uso das organizações às quais você pertence. A conta pessoal sempre é exibida.";
+"Sign in to cursor.com in your browser, then refresh Cursor in CodexBar." = "Entre em cursor.com no navegador e atualize Cursor no CodexBar.";
+"Simulated error text" = "Texto de erro simulado";
+"StepFun platform account (phone number or email)." = "Conta da plataforma StepFun (telefone ou email).";
+"Stored in ~/.codexbar/config.json." = "Armazenado em ~/.codexbar/config.json.";
+"Stored in ~/.codexbar/config.json. AZURE_OPENAI_API_KEY is also supported." = "Armazenado em ~/.codexbar/config.json. AZURE_OPENAI_API_KEY também é aceito.";
+"Stored in ~/.codexbar/config.json. For the official Kimi API, use Moonshot / Kimi API." = "Armazenado em ~/.codexbar/config.json. Para a API oficial do Kimi, use Moonshot / Kimi API.";
+"Stored in ~/.codexbar/config.json. Get your API key from the Volcengine Ark console." = "Armazenado em ~/.codexbar/config.json. Obtenha sua chave API no console Volcengine Ark.";
+"Stored in ~/.codexbar/config.json. Get your key from Ollama settings." = "Armazenado em ~/.codexbar/config.json. Obtenha sua chave nas configurações do Ollama.";
+"Stored in ~/.codexbar/config.json. Get your key from console.deepgram.com." = "Armazenado em ~/.codexbar/config.json. Obtenha sua chave em console.deepgram.com.";
+"Stored in ~/.codexbar/config.json. Get your key from elevenlabs.io/app/settings/api-keys." = "Armazenado em ~/.codexbar/config.json. Obtenha sua chave em elevenlabs.io/app/settings/api-keys.";
+"Stored in ~/.codexbar/config.json. Get your key from openrouter.ai/settings/keys and set a key spending limit there to enable API key quota tracking." = "Armazenado em ~/.codexbar/config.json. Obtenha sua chave em openrouter.ai/settings/keys e defina um limite de gasto para ativar o rastreamento de cota.";
+"Stored in ~/.codexbar/config.json. In Warp, open Settings > Platform > API Keys, then create one." = "Armazenado em ~/.codexbar/config.json. No Warp, abra Settings > Platform > API Keys e crie uma.";
+"Stored in ~/.codexbar/config.json. Metrics require Groq Enterprise Prometheus access." = "Armazenado em ~/.codexbar/config.json. As métricas exigem acesso ao Groq Enterprise Prometheus.";
+"Stored in ~/.codexbar/config.json. OPENAI_ADMIN_KEY is preferred; OPENAI_API_KEY still works." = "Armazenado em ~/.codexbar/config.json. OPENAI_ADMIN_KEY é preferida; OPENAI_API_KEY ainda funciona.";
+"Stored in ~/.codexbar/config.json. Requires an Anthropic Admin API key." = "Armazenado em ~/.codexbar/config.json. Requer uma chave Anthropic Admin API.";
+"Stored in ~/.codexbar/config.json. Used for /v1/quota-stats." = "Armazenado em ~/.codexbar/config.json. Usado para /v1/quota-stats.";
+"Stored in ~/.codexbar/config.json. You can also provide CODEBUFF_API_KEY or let CodexBar read ~/.config/manicode/credentials.json (created by `codebuff login`)." = "Armazenado em ~/.codexbar/config.json. Você também pode fornecer CODEBUFF_API_KEY ou permitir que o CodexBar leia ~/.config/manicode/credentials.json (criado por `codebuff login`).";
+"Stored in ~/.codexbar/config.json. You can also provide CROF_API_KEY." = "Armazenado em ~/.codexbar/config.json. Você também pode fornecer CROF_API_KEY.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or ~/.local/share/kilo/auth.json (kilo.access)." = "Armazenado em ~/.codexbar/config.json. Você também pode fornecer KILO_API_KEY ou ~/.local/share/kilo/auth.json (kilo.access).";
+"T3 Chat cookie" = "Cookie do T3 Chat";
+"That account is no longer available in CodexBar. Refresh the account list and try again." = "Essa conta não está mais disponível no CodexBar. Atualize a lista de contas e tente novamente.";
+"The browser login did not complete in time. Try Antigravity login again." = "O login no navegador não foi concluído a tempo. Tente o login do Antigravity novamente.";
+"Timed out waiting for Cursor login. %@" = "Tempo esgotado aguardando o login do Cursor. %@";
+"Timed out waiting for Cursor login. %@ Last error: %@" = "Tempo esgotado aguardando o login do Cursor. %@ Último erro: %@";
+"Today requests" = "Solicitações de hoje";
+"Total (30d): %@ credits" = "Total (30 dias): %@ créditos";
+"Username" = "Nome de usuário";
+"Uses username + password to login and obtain an Oasis-Token automatically." = "Usa nome de usuário e senha para entrar e obter um Oasis-Token automaticamente.";
+"Uses username + password to login and obtain an %@ automatically." = "Usa nome de usuário e senha para entrar e obter um %@ automaticamente.";
+"Utilization End" = "Fim da utilização";
+"Utilization Start" = "Início da utilização";
+"Verbosity" = "Detalhamento";
+"Windsurf session JSON bundle" = "Pacote JSON de sessão do Windsurf";
+"Workspace ID" = "ID do workspace";
+"Your StepFun platform password. Used to login and obtain a session token." = "Sua senha da plataforma StepFun. Usada para entrar e obter um token de sessão.";
+"claude /login exited with status %d." = "claude /login saiu com status %d.";
+"codex login exited with status %d." = "codex login saiu com status %d.";
+"Cookie: …\n\nor paste a cURL capture from the Abacus AI dashboard" = "Cookie: …\n\nou cole uma captura cURL do painel Abacus AI";
+"Cookie: …\n\nor paste the __Secure-next-auth.session-token value" = "Cookie: …\n\nou cole o valor de __Secure-next-auth.session-token";
+"Cookie: …\n\nor paste the kimi-auth token value" = "Cookie: …\n\nou cole o valor do token kimi-auth";
+"session_id=...\n\nor paste just the session_id value" = "session_id=...\n\nou cole apenas o valor de session_id";
+"Clear" = "Limpar";
+"No matching providers" = "Nenhum provedor correspondente";
+"Search providers" = "Buscar provedores";
+
+"language_vietnamese" = "Vietnamita";
+"language_turkish" = "Türkçe";
+"language_indonesian" = "Indonésio";
+"language_arabic" = "العربية";
+"language_persian" = "فارسی";
+"language_thai" = "ไทย";
+"Limit Reset Credits" = "Créditos de redefinição de limite";
+"1 manual reset available" = "1 redefinição manual disponível";
+"%d manual resets available" = "%d redefinições manuais disponíveis";
+"Next expires %@" = "Próximo expira %@";
+"Other (%d items)" = "Outros (%d itens)";
+"Expand" = "Expandir";
+"Collapse" = "Recolher";
+"byte_unit_byte" = "byte";
+"byte_unit_bytes" = "bytes";
+"byte_unit_kilobyte" = "quilobyte";
+"byte_unit_kilobytes" = "quilobytes";
+"byte_unit_megabyte" = "megabyte";
+"byte_unit_megabytes" = "megabytes";
+"byte_unit_gigabyte" = "gigabyte";
+"byte_unit_gigabytes" = "gigabytes";
diff --git a/Sources/CodexBar/Resources/sv.lproj/Localizable.strings b/Sources/CodexBar/Resources/sv.lproj/Localizable.strings
new file mode 100644
index 0000000000..9ecfc8e8d4
--- /dev/null
+++ b/Sources/CodexBar/Resources/sv.lproj/Localizable.strings
@@ -0,0 +1,1104 @@
+/* Swedish localization for CodexBar */
+
+" providers" = " leverantörer";
+"(System)" = "(System)";
+"30d" = "30 d";
+"A managed Codex login is already running. Wait for it to finish before adding " = "En hanterad Codex-inloggning körs redan. Vänta tills den är klar innan du lägger till ";
+"API key" = "API-nyckel";
+"API region" = "API-region";
+"API token" = "API-token";
+"API tokens" = "API-token";
+"About" = "Om";
+"Account" = "Konto";
+"Accounts" = "Konton";
+"Accounts subtitle" = "Kontounderrubrik";
+"Active" = "Aktiv";
+"Add" = "Lägg till";
+"Add Workspace" = "Lägg till arbetsyta";
+"Advanced" = "Avancerat";
+"All" = "Alla";
+"Always allow prompts" = "Tillåt alltid uppmaningar";
+"Animation pattern" = "Animationsmönster";
+"Antigravity login is managed in the app" = "Antigravity-inloggning hanteras i appen";
+"Applies only to the Security.framework OAuth keychain reader." = "Gäller bara OAuth-läsaren för Nyckelring via Security.framework.";
+"Auto falls back to the next source if the preferred one fails." = "Auto går vidare till nästa källa om den föredragna misslyckas.";
+"Auto uses API first, then falls back to CLI on auth failures." = "Auto använder API först och går sedan över till CLI vid autentiseringsfel.";
+"Auto-detect" = "Identifiera automatiskt";
+"Auto-refresh is off; use the menu's Refresh command." = "Automatisk uppdatering är avstängd. Använd Uppdatera i menyn.";
+"Auto-refresh: hourly · Timeout: 10m" = "Automatisk uppdatering: varje timme · Timeout: 10 min";
+"Automatic" = "Automatiskt";
+"Automatic imports browser cookies and WorkOS tokens." = "Importerar webbläsarcookies och WorkOS-token automatiskt.";
+"Automatic imports browser cookies and local storage tokens." = "Importerar webbläsarcookies och token från lokal lagring automatiskt.";
+"Automatic imports browser cookies for dashboard extras." = "Importerar webbläsarcookies automatiskt för extra instrumentpanelsdata.";
+"Automatic imports browser cookies for the web API." = "Importerar webbläsarcookies automatiskt för webb-API:t.";
+"Automatic imports browser cookies from Model Studio/Bailian." = "Importerar webbläsarcookies automatiskt från Model Studio/Bailian.";
+"Automatic imports browser cookies from admin.mistral.ai." = "Importerar webbläsarcookies automatiskt från admin.mistral.ai.";
+"Automatic imports browser cookies from opencode.ai." = "Importerar webbläsarcookies automatiskt från opencode.ai.";
+"Automatic imports browser cookies or stored sessions." = "Importerar webbläsarcookies eller sparade sessioner automatiskt.";
+"Automatic imports browser cookies." = "Importerar webbläsarcookies automatiskt.";
+"Automatically imports browser session cookie." = "Importerar webbläsarens sessionscookie automatiskt.";
+"Automatically opens CodexBar when you start your Mac." = "Öppnar CodexBar automatiskt när du startar din Mac.";
+"Automation" = "Automatisering";
+"Average (\\(label1) + \\(label2))" = "Genomsnitt (\\(label1) + \\(label2))";
+"Average (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))" = "Genomsnitt (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))";
+"Avoid Keychain prompts" = "Undvik frågor från Nyckelring";
+"Balance" = "Saldo";
+"Battery Saver" = "Batterisparläge";
+"Bordered" = "Med ram";
+"Build" = "Bygge";
+"Built \\(buildTimestamp)" = "Byggd \\(buildTimestamp)";
+"Buy Credits..." = "Köp krediter...";
+"Buy Credits…" = "Köp krediter…";
+"CLI paths" = "CLI-sökvägar";
+"CLI sessions" = "CLI-sessioner";
+"Caches" = "Cachar";
+"Cancel" = "Avbryt";
+"Check for Updates…" = "Sök efter uppdateringar…";
+"Check for updates automatically" = "Sök efter uppdateringar automatiskt";
+"Check if you like your agents having some fun up there." = "Kontrollera om du vill att agenterna ska få leka lite där uppe.";
+"Check provider status" = "Kontrollera leverantörsstatus";
+"Choose Codex workspace" = "Välj Codex-arbetsyta";
+"Choose the MiniMax host (global .io or China mainland .com)." = "Välj MiniMax-värd (global .io eller Fastlandskina .com).";
+"Choose up to " = "Välj upp till ";
+"Choose up to \\(Self.maxOverviewProviders) providers" = "Välj upp till \\(Self.maxOverviewProviders) leverantörer";
+"Choose up to \\(count) providers" = "Välj upp till \\(count) leverantörer";
+"Choose what to show in the menu bar (Pace shows usage vs. expected)." = "Välj vad som ska visas i menyraden (takt visar användning mot förväntat).";
+"Choose which Codex account CodexBar should follow." = "Välj vilket Codex-konto CodexBar ska följa.";
+"Choose which window drives the menu bar percent." = "Välj vilket fönster som styr procenttalet i menyraden.";
+"Chrome" = "Chrome";
+"Claude CLI not found" = "Claude CLI hittades inte";
+"Claude binary" = "Claude-binär";
+"Claude cookies" = "Claude-cookies";
+"Claude login failed" = "Claude-inloggning misslyckades";
+"Claude login timed out" = "Claude-inloggning tog för lång tid";
+"Close" = "Stäng";
+"Code review" = "Kodgranskning";
+"Codex CLI not found" = "Codex CLI hittades inte";
+"Codex account login already running" = "Codex-kontoinloggning körs redan";
+"Codex binary" = "Codex-binär";
+"Codex login failed" = "Codex-inloggning misslyckades";
+"Codex login timed out" = "Codex-inloggning tog för lång tid";
+"CodexBar Lifecycle Keepalive" = "CodexBar livscykel-keepalive";
+"CodexBar can't show its menu bar icon" = "CodexBar kan inte visa sin menyradsikon";
+"CodexBar could not read managed account storage. " = "CodexBar kunde inte läsa hanterad kontolagring. ";
+"Configure…" = "Konfigurera…";
+"Connected" = "Ansluten";
+"Controls how much detail is logged." = "Styr hur detaljerad loggningen är.";
+"Cookie header" = "Cookie-header";
+"Cookie source" = "Cookie-källa";
+"Cookie: ..." = "Cookie: ...";
+"Cookie: \\u{2026}\\\n\\\nor paste a cURL capture from the Abacus AI dashboard" = "Cookie: \\u{2026}\\\n\\\neller klistra in en cURL-fångst från Abacus AI-instrumentpanelen";
+"Cookie: \\u{2026}\\\n\\\nor paste the __Secure-next-auth.session-token value" = "Cookie: \\u{2026}\\\n\\\neller klistra in värdet för __Secure-next-auth.session-token";
+"Cookie: \\u{2026}\\\n\\\nor paste the kimi-auth token value" = "Cookie: \\u{2026}\\\n\\\neller klistra in värdet för kimi-auth-token";
+"Cookie: …" = "Cookie: …";
+"CopilotDeviceFlow" = "CopilotDeviceFlow";
+"Cost" = "Kostnad";
+"Could not add Codex account" = "Kunde inte lägga till Codex-konto";
+"Could not open Terminal for Gemini" = "Kunde inte öppna Terminal för Gemini";
+"Could not start claude /login" = "Kunde inte starta claude /login";
+"Could not start codex login" = "Kunde inte starta codex login";
+"Could not switch system account" = "Kunde inte byta systemkonto";
+"Credits" = "Krediter";
+"Individual credits" = "Individuella krediter";
+"Workspace" = "Arbetsyta";
+"Credits history" = "Kredithistorik";
+"Cursor login failed" = "Cursor-inloggning misslyckades";
+"Custom" = "Anpassat";
+"Custom Path" = "Anpassad sökväg";
+"Daily Routines" = "Dagliga rutiner";
+"Debug" = "Felsök";
+"Default" = "Standard";
+"Disable Keychain access" = "Inaktivera åtkomst till Nyckelring";
+"Disabled" = "Inaktiverad";
+"Dismiss" = "Stäng";
+"Disconnected" = "Frånkopplad";
+"Display" = "Visning";
+"Display mode" = "Visningsläge";
+"Display reset times as absolute clock values instead of countdowns." = "Visa återställningstider som klockslag i stället för nedräkningar.";
+"Done" = "Klar";
+"Effective PATH" = "Effektiv PATH";
+"Email" = "E-post";
+"Enable Merge Icons to configure Overview tab providers." = "Aktivera Slå ihop ikoner för att konfigurera leverantörer på översiktsfliken.";
+"Enable file logging" = "Aktivera filloggning";
+"Enabled" = "Aktiverad";
+"Error" = "Fel";
+"Error simulation" = "Felsimulering";
+"Expose troubleshooting tools in the Debug tab." = "Visa felsökningsverktyg på fliken Felsök.";
+"Failed" = "Misslyckades";
+"False" = "Falskt";
+"Fetch strategy attempts" = "Försök med hämtningsstrategi";
+"Fetching" = "Hämtar";
+"Field" = "Fält";
+"Field subtitle" = "Fältunderrubrik";
+"Finish the current managed account change before switching the system account." = "Slutför den pågående hanterade kontoändringen innan du byter systemkonto.";
+"Force animation on next refresh" = "Tvinga animation vid nästa uppdatering";
+"Gateway region" = "Gateway-region";
+"Gemini CLI not found" = "Gemini CLI hittades inte";
+"Gemini/Antigravity, surfacing incidents in the icon and menu." = "Gemini/Antigravity och visar incidenter i ikonen och menyn.";
+"General" = "Allmänt";
+"GitHub" = "GitHub";
+"GitHub Copilot Login" = "GitHub Copilot-inloggning";
+"GitHub Login" = "GitHub-inloggning";
+"Hide details" = "Dölj detaljer";
+"Hide personal information" = "Dölj personuppgifter";
+"Historical tracking" = "Historisk spårning";
+"How often CodexBar polls providers in the background." = "Hur ofta CodexBar kontrollerar leverantörer i bakgrunden.";
+"Inactive" = "Inaktiv";
+"Install CLI" = "Installera CLI";
+"Install the Claude CLI (npm i -g @anthropic-ai/claude-code) and try again." = "Installera Claude CLI (npm i -g @anthropic-ai/claude-code) och försök igen.";
+"Install the Codex CLI (npm i -g @openai/codex) and try again." = "Installera Codex CLI (npm i -g @openai/codex) och försök igen.";
+"Install the Gemini CLI (npm i -g @google/gemini-cli) and try again." = "Installera Gemini CLI (npm i -g @google/gemini-cli) och försök igen.";
+"JetBrains AI is ready" = "JetBrains AI är redo";
+"JetBrains IDE" = "JetBrains IDE";
+"Keep CLI sessions alive" = "Håll CLI-sessioner vid liv";
+"Keyboard shortcut" = "Kortkommando";
+"Keychain access" = "Åtkomst till Nyckelring";
+"Keychain prompt policy" = "Policy för frågor från Nyckelring";
+"Last \\(name) fetch failed:" = "Senaste hämtningen för \\(name) misslyckades:";
+"Last \\(self.store.metadata(for: self.provider).displayName) fetch failed:" = "Senaste hämtningen för \\(self.store.metadata(for: self.provider).displayName) misslyckades:";
+"Last attempt" = "Senaste försök";
+"Link" = "Länk";
+"Loading animations" = "Laddningsanimationer";
+"Loading…" = "Läser in…";
+"Local" = "Lokal";
+"Logging" = "Loggning";
+"Login failed" = "Inloggningen misslyckades";
+"Login shell PATH (startup capture)" = "Inloggningsskalets PATH (fångad vid start)";
+"Login timed out" = "Inloggningen tog för lång tid";
+"MCP details" = "MCP-detaljer";
+"Managed Codex accounts unavailable" = "Hanterade Codex-konton är inte tillgängliga";
+"Managed account storage is unreadable. Live account access is still available, " = "Hanterad kontolagring går inte att läsa. Direkt kontoåtkomst är fortfarande tillgänglig, ";
+"Manual" = "Manuellt";
+"May your tokens never run out—keep agent limits in view." = "Må dina token aldrig ta slut – håll agentgränserna synliga.";
+"Menu bar" = "Menyrad";
+"Menu bar auto-shows the provider closest to its rate limit." = "Menyraden visar automatiskt leverantören som ligger närmast sin gräns.";
+"Menu bar metric" = "Menyradsmått";
+"Menu bar shows percent" = "Menyraden visar procent";
+"Menu content" = "Menyinnehåll";
+"Merge Icons" = "Slå ihop ikoner";
+"Never prompt" = "Fråga aldrig";
+"No" = "Nej";
+"No Codex accounts detected yet." = "Inga Codex-konton har hittats än.";
+"No JetBrains IDE detected" = "Ingen JetBrains IDE hittades";
+"No cost history data." = "Ingen kostnadshistorik.";
+"No credits history data." = "Ingen kredithistorik.";
+"No data available" = "Inga data tillgängliga";
+"No data yet" = "Inga data än";
+"No enabled providers available for Overview." = "Inga aktiverade leverantörer är tillgängliga för översikten.";
+"No providers selected" = "Inga leverantörer valda";
+"No token accounts yet." = "Inga tokenkonton än.";
+"No usage breakdown data." = "Ingen användningsuppdelning.";
+"None" = "Ingen";
+"Notifications" = "Aviseringar";
+"Notifies when the 5-hour session quota hits 0% and when it becomes " = "Aviserar när femtimmarssessionens kvot når 0 % och när den blir ";
+"OK" = "OK";
+"Obscure email addresses in the menu bar and menu UI." = "Maskera e-postadresser i menyraden och menygränssnittet.";
+"Off" = "Av";
+"Offline" = "Offline";
+"On" = "På";
+"Online" = "Online";
+"Only on user action" = "Bara vid användaråtgärd";
+"Open" = "Öppna";
+"Open API Keys" = "Öppna API-nycklar";
+"Open Amp Settings" = "Öppna Amp-inställningar";
+"Open Antigravity to sign in, then refresh CodexBar." = "Öppna Antigravity för att logga in och uppdatera sedan CodexBar.";
+"Open Browser" = "Öppna webbläsare";
+"Open Coding Plan" = "Öppna Coding Plan";
+"Open Console" = "Öppna konsol";
+"Open Dashboard" = "Öppna instrumentpanel";
+"Open Mistral Admin" = "Öppna Mistral Admin";
+"Open Menu Bar Settings" = "Öppna inställningar för menyraden";
+"Open Ollama Settings" = "Öppna Ollama-inställningar";
+"Open Terminal" = "Öppna Terminal";
+"Open Usage Page" = "Öppna användningssida";
+"Open Warp API Key Guide" = "Öppna guide för Warp API-nyckel";
+"Open menu" = "Öppna meny";
+"Open token file" = "Öppna tokenfil";
+"OpenAI cookies" = "OpenAI-cookies";
+"OpenAI web extras" = "OpenAI-webbtillägg";
+"Option A" = "Alternativ A";
+"Option B" = "Alternativ B";
+"Optional override if workspace lookup fails." = "Valfri ersättning om sökning efter arbetsyta misslyckas.";
+"Options" = "Alternativ";
+"Override auto-detection with a custom IDE base path" = "Ersätt automatisk identifiering med en anpassad bas-sökväg till IDE:n";
+"Overview" = "Översikt";
+"Overview rows always follow provider order." = "Översiktsrader följer alltid leverantörsordningen.";
+"Overview tab providers" = "Leverantörer på översiktsfliken";
+"Paste API key…" = "Klistra in API-nyckel…";
+"Paste API token…" = "Klistra in API-token…";
+"Paste key…" = "Klistra in nyckel…";
+"Paste sessionKey or OAuth token…" = "Klistra in sessionKey eller OAuth-token…";
+"Paste the Cookie header from a request to admin.mistral.ai. " = "Klistra in Cookie-headern från en förfrågan till admin.mistral.ai. ";
+"Paste token…" = "Klistra in token…";
+"Personal" = "Personligt";
+"Picker" = "Väljare";
+"Picker subtitle" = "Väljarunderrubrik";
+"Placeholder" = "Platshållare";
+"Plan" = "Plan";
+"Play full-screen confetti when weekly usage resets." = "Spela konfetti i helskärm när veckoförbrukningen återställs.";
+"Polls OpenAI/Claude status pages and Google Workspace for " = "Kontrollerar OpenAI/Claude-statussidor och Google Workspace för ";
+"Prevents any Keychain access while enabled." = "Förhindrar all åtkomst till Nyckelring när det är aktiverat.";
+"Primary (API key limit)" = "Primär (API-nyckelgräns)";
+"Primary (\\(label))" = "Primär (\\(label))";
+"Primary (\\(metadata.sessionLabel))" = "Primär (\\(metadata.sessionLabel))";
+"Probe logs" = "Probloggar";
+"Progress bars fill as you consume quota (instead of showing remaining)." = "Förloppsstaplar fylls när du förbrukar kvot i stället för att visa återstående.";
+"Provider" = "Leverantör";
+"Providers" = "Leverantörer";
+"Quit CodexBar" = "Avsluta CodexBar";
+"Random (default)" = "Slumpmässig (standard)";
+"Reads local usage logs. Shows today + last 30 days cost in the menu." = "Läser lokala användningsloggar. Visar idag och valt historikfönster i menyn.";
+"Refresh" = "Uppdatera";
+"Refresh cadence" = "Uppdateringsintervall";
+"Remote" = "Fjärr";
+"Remove" = "Ta bort";
+"Remove Codex account?" = "Ta bort Codex-konto?";
+"Remove \\(account.email) from CodexBar? Its managed Codex home will be deleted." = "Ta bort \\(account.email) från CodexBar? Dess hanterade Codex-hem tas bort.";
+"Remove \\(email) from CodexBar? Its managed Codex home will be deleted." = "Ta bort \\(email) från CodexBar? Dess hanterade Codex-hem tas bort.";
+"Remove selected account" = "Ta bort valt konto";
+"Replace critter bars with provider branding icons and a percentage." = "Ersätt figurstaplar med leverantörsikoner och ett procenttal.";
+"Replay selected animation" = "Spela vald animation igen";
+"Requires authentication via GitHub Device Flow." = "Kräver autentisering via GitHub Device Flow.";
+"Resets: \\(reset)" = "Återställs: \\(reset)";
+"Rolling five-hour limit" = "Rullande femtimmarsgräns";
+"Search hourly" = "Sökning per timme";
+"Secondary (\\(label))" = "Sekundär (\\(label))";
+"Secondary (\\(metadata.weeklyLabel))" = "Sekundär (\\(metadata.weeklyLabel))";
+"Select a provider" = "Välj en leverantör";
+"Select the IDE to monitor" = "Välj IDE att övervaka";
+"Session quota notifications" = "Aviseringar för sessionskvot";
+"Session tokens" = "Sessionstoken";
+"Settings" = "Inställningar";
+"Show Codex Credits and Claude Extra usage sections in the menu." = "Visa avsnitt för Codex-krediter och Claude Extra-användning i menyn.";
+"Show Debug Settings" = "Visa felsökningsinställningar";
+"Show all token accounts" = "Visa alla tokenkonton";
+"Show cost summary" = "Visa kostnadssammanfattning";
+"Show credits + extra usage" = "Visa krediter och extra användning";
+"Show details" = "Visa detaljer";
+"Show most-used provider" = "Visa mest använda leverantör";
+"Show provider icons in the switcher (otherwise show a weekly progress line)." = "Visa leverantörsikoner i växlaren (annars visas en veckoförloppslinje).";
+"Show reset time as clock" = "Visa återställningstid som klockslag";
+"Show usage as used" = "Visa användning som förbrukad";
+"Sign in via button below" = "Logga in med knappen nedan";
+"Skip teardown between probes (debug-only)." = "Hoppa över nedstängning mellan prober (endast felsökning).";
+"Stack token accounts in the menu (otherwise show an account switcher bar)." = "Stapla tokenkonton i menyn (annars visas en kontoväxlare).";
+"Start at Login" = "Starta vid inloggning";
+"Status" = "Status";
+"Store Claude sessionKey cookies or OAuth access tokens." = "Spara Claude-sessionKey-cookies eller OAuth-åtkomsttoken.";
+"Store multiple Abacus AI Cookie headers." = "Spara flera Cookie-headers för Abacus AI.";
+"Store multiple Augment Cookie headers." = "Spara flera Cookie-headers för Augment.";
+"Store multiple Cursor Cookie headers." = "Spara flera Cookie-headers för Cursor.";
+"Store multiple Factory Cookie headers." = "Spara flera Cookie-headers för Factory.";
+"Store multiple MiniMax Cookie headers." = "Spara flera Cookie-headers för MiniMax.";
+"Store multiple Mistral Cookie headers." = "Spara flera Cookie-headers för Mistral.";
+"Store multiple Ollama Cookie headers." = "Spara flera Cookie-headers för Ollama.";
+"Store multiple OpenCode Cookie headers." = "Spara flera Cookie-headers för OpenCode.";
+"Store multiple OpenCode Go Cookie headers." = "Spara flera Cookie-headers för OpenCode Go.";
+"Stored in the CodexBar config file." = "Sparas i CodexBars konfigurationsfil.";
+"Stored in ~/.codexbar/config.json. " = "Sparas i ~/.codexbar/config.json. ";
+"Stored in ~/.codexbar/config.json. Generate one at kimi-k2.ai." = "Sparas i ~/.codexbar/config.json. Skapa en på kimi-k2.ai.";
+"Stored in ~/.codexbar/config.json. Paste the key from the Synthetic dashboard." = "Sparas i ~/.codexbar/config.json. Klistra in nyckeln från Synthetic-instrumentpanelen.";
+"Stored in ~/.codexbar/config.json. Paste your Coding Plan API key from Model Studio." = "Sparas i ~/.codexbar/config.json. Klistra in din Coding Plan-API-nyckel från Model Studio.";
+"Stored in ~/.codexbar/config.json. Paste your MiniMax API key." = "Sparas i ~/.codexbar/config.json. Klistra in din MiniMax-API-nyckel.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or " = "Sparas i ~/.codexbar/config.json. Du kan också ange KILO_API_KEY eller ";
+"Stores local Codex usage history (8 weeks) to personalize Pace predictions." = "Sparar lokal Codex-användningshistorik (8 veckor) för att anpassa taktprognoser.";
+"Subscription Utilization" = "Abonnemangsutnyttjande";
+"Surprise me" = "Överraska mig";
+"Switcher shows icons" = "Växlaren visar ikoner";
+"Symlink CodexBarCLI to /usr/local/bin and /opt/homebrew/bin as codexbar." = "Symlänka CodexBarCLI till /usr/local/bin och /opt/homebrew/bin som codexbar.";
+"System" = "System";
+"Temporarily shows the loading animation after the next refresh." = "Visar tillfälligt laddningsanimationen efter nästa uppdatering.";
+"Tertiary (\\(label))" = "Tertiär (\\(label))";
+"Tertiary (\\(tertiaryTitle))" = "Tertiär (\\(tertiaryTitle))";
+"The default Codex account on this Mac." = "Standardkontot för Codex på den här Macen.";
+"Toggle" = "Växla";
+"Toggle subtitle" = "Växlingsunderrubrik";
+"Token" = "Token";
+"Trigger the menu bar menu from anywhere." = "Öppna menyradsmenyn var du än är.";
+"True" = "Sant";
+"Twitter" = "Twitter";
+"Unsupported" = "Stöds inte";
+"Update Channel" = "Uppdateringskanal";
+"Updated" = "Uppdaterad";
+"Updates unavailable in this build." = "Uppdateringar är inte tillgängliga i det här bygget.";
+"Usage" = "Användning";
+"Usage breakdown" = "Användningsuppdelning";
+"Usage history (30 days)" = "Användningshistorik";
+"Usage source" = "Användningskälla";
+"Use BigModel for the China mainland endpoints (open.bigmodel.cn)." = "Använd BigModel för slutpunkterna i Fastlandskina (open.bigmodel.cn).";
+"Use a single menu bar icon with a provider switcher." = "Använd en enda menyradsikon med leverantörsväxlare.";
+"Use international or China mainland console gateways for quota fetches." = "Använd internationella gatewayar eller gatewayar för Fastlandskina vid kvothämtning.";
+"Version" = "Version";
+"Version \\(self.versionString)" = "Version \\(self.versionString)";
+"Version \\(version)" = "Version \\(version)";
+"Version \\(versionString)" = "Version \\(versionString)";
+"Vertex AI Login" = "Vertex AI-inloggning";
+"Wait for the current managed Codex login to finish before adding another account." = "Vänta tills den pågående hanterade Codex-inloggningen är klar innan du lägger till ett konto till.";
+"Waiting for Authentication..." = "Väntar på autentisering...";
+"Website" = "Webbplats";
+"Weekly limit confetti" = "Veckogränskonfetti";
+"Weekly token limit" = "Veckogräns för token";
+"Weekly usage" = "Veckoanvändning";
+"Weekly usage unavailable for this account." = "Veckoanvändning är inte tillgänglig för det här kontot.";
+"Window: \\(window)" = "Fönster: \\(window)";
+"Write logs to \\(self.fileLogPath) for debugging." = "Skriv loggar till \\(self.fileLogPath) för felsökning.";
+"Yes" = "Ja";
+"\\(detail.modelCode): \\(usage)" = "\\(detail.modelCode): \\(usage)";
+"\\(name): \\(truncated)" = "\\(name): \\(truncated)";
+"\\(name): \\(updated) · 30d \\(cost)" = "\\(name): \\(updated) · 30 d \\(cost)";
+"\\(name): fetching…\\(elapsed)" = "\\(name): hämtar…\\(elapsed)";
+"\\(name): last attempt \\(when)" = "\\(name): senaste försök \\(when)";
+"\\(name): no data yet" = "\\(name): inga data än";
+"\\(name): unsupported" = "\\(name): stöds inte";
+"all browsers" = "alla webbläsare";
+"available again." = "tillgänglig igen.";
+"built_format" = "Byggd %@";
+"copilot_complete_in_browser" = "Slutför inloggningen i webbläsaren.";
+"copilot_device_code" = "Enhetskoden kopierades till urklipp: %1$@\n\nVerifiera på: %2$@";
+"copilot_device_code_copied" = "Enhetskoden kopierades.";
+"copilot_verify_at" = "Verifiera på %@";
+"copilot_waiting_text" = "Slutför inloggningen i webbläsaren.\nDet här fönstret stängs automatiskt när inloggningen är klar.";
+"copilot_window_closes_auto" = "Det här fönstret stängs automatiskt när inloggningen är klar.";
+"cost_status_error" = "%1$@: %2$@";
+"cost_status_fetching" = "%1$@: hämtar… %2$@";
+"cost_status_last_attempt" = "%1$@: senaste försök %2$@";
+"cost_status_no_data" = "%@: inga data än";
+"cost_status_snapshot" = "%1$@: %2$@ · %3$@ %4$@";
+"cost_status_unsupported" = "%@: stöds inte";
+"credits_remaining" = "Krediter: %@";
+"cursor_on_demand" = "Vid behov: %@";
+"cursor_on_demand_with_limit" = "Vid behov: %1$@ / %2$@";
+"extra_usage_format" = "Extra användning: %1$@ / %2$@";
+"jetbrains_detected_generate" = "Hittade: %@. Använd AI-assistenten en gång för att skapa kvotdata och uppdatera sedan CodexBar.";
+"jetbrains_detected_select" = "Hittade: %@. Välj önskad IDE i Inställningar och uppdatera sedan CodexBar.";
+"last_fetch_failed_with_provider" = "Senaste hämtningen för %@ misslyckades:";
+"last_spend" = "Senaste utgift: %@";
+"mcp_model_usage" = "%1$@: %2$@";
+"mcp_resets" = "Återställs: %@";
+"mcp_window" = "Fönster: %@";
+"metric_average" = "Genomsnitt (%1$@ + %2$@)";
+"metric_primary" = "Primär (%@)";
+"metric_secondary" = "Sekundär (%@)";
+"metric_tertiary" = "Tertiär (%@)";
+"multiple_workspaces_found" = "CodexBar hittade flera arbetsytor för %@. Välj arbetsytan som ska läggas till.";
+"ory_session_…=…; csrftoken=…" = "ory_session_…=…; csrftoken=…";
+"overview_choose_providers" = "Välj upp till %@ leverantörer";
+"remove_account_message" = "Ta bort %@ från CodexBar? Dess hanterade Codex-hem tas bort.";
+"version_format" = "Version %@";
+"vertex_ai_login_instructions" = "Autentisera med Google Cloud för att följa Vertex AI-användning.\n\n1. Öppna Terminal\n2. Kör: gcloud auth application-default login\n3. Följ anvisningarna i webbläsaren för att logga in\n4. Ange ditt projekt: gcloud config set project PROJECT_ID\n\nÖppna Terminal nu?";
+"workspaceID is set but only opencode, opencodego, and deepgram support workspaceID." = "workspaceID är angivet, men bara opencode, opencodego och deepgram stöder workspaceID.";
+"© 2026 Peter Steinberger. MIT License." = "© 2026 Peter Steinberger. MIT-licens.";
+
+/* General Pane */
+"section_system" = "System";
+"section_usage" = "Användning";
+"section_automation" = "Automatisering";
+"language_title" = "Språk";
+"language_subtitle" = "Byt visningsspråk. Appen behöver startas om för att ändringen ska slå igenom helt.";
+"language_system" = "System";
+"language_english" = "English";
+"language_spanish" = "Español";
+"language_catalan" = "Català";
+"language_chinese_simplified" = "简体中文";
+"language_chinese_traditional" = "繁體中文";
+"language_portuguese_brazilian" = "Português (Brasil)";
+"language_dutch" = "Nederlands";
+"language_german" = "Deutsch";
+"language_swedish" = "Svenska";
+"language_french" = "Franska";
+"language_ukrainian" = "Ukrainska";
+"language_japanese" = "Japanska";
+"language_korean" = "Koreanska";
+"language_turkish" = "Türkçe";
+"language_italian" = "Italiano";
+"language_indonesian" = "Indonesiska";
+"language_polish" = "Polski";
+"start_at_login_title" = "Starta vid inloggning";
+"start_at_login_subtitle" = "Öppnar CodexBar automatiskt när du startar din Mac.";
+"show_cost_summary" = "Visa kostnadssammanfattning";
+"show_cost_summary_subtitle" = "Läser lokala användningsloggar. Visar idag och valt historikfönster i menyn.";
+"cost_history_days_title" = "Historikfönster: %d dagar";
+"cost_auto_refresh_info" = "Automatisk uppdatering: varje timme · Timeout: 10 min";
+"refresh_cadence_title" = "Uppdateringsintervall";
+"refresh_cadence_subtitle" = "Hur ofta CodexBar kontrollerar leverantörer i bakgrunden.";
+"manual_refresh_hint" = "Automatisk uppdatering är avstängd. Använd Uppdatera i menyn.";
+"check_provider_status_title" = "Kontrollera leverantörsstatus";
+"check_provider_status_subtitle" = "Kontrollerar OpenAI/Claude-statussidor och Google Workspace för Gemini/Antigravity och visar incidenter i ikonen och menyn.";
+"session_quota_notifications_title" = "Aviseringar för sessionskvot";
+"session_quota_notifications_subtitle" = "Aviserar när femtimmarssessionens kvot når 0 % och när den blir tillgänglig igen.";
+"quota_warning_notifications_title" = "Kvotvarningsaviseringar";
+"quota_warning_notifications_subtitle" = "Varnar när återstående sessions- eller veckokvot passerar inställda trösklar.";
+"quota_warnings_title" = "Kvotvarningar";
+"quota_warning_session" = "session";
+"quota_warning_session_capitalized" = "Session";
+"quota_warning_weekly" = "veckokvot";
+"quota_warning_weekly_capitalized" = "Veckokvot";
+"quota_warning_notification_title" = "%1$@ %2$@-kvot låg";
+"quota_warning_notification_body" = "%1$@ kvar. Din varningströskel på %2$d %% för %3$@ har nåtts.";
+"quota_warning_notification_body_with_account" = "Konto %1$@. %2$@ kvar. Din varningströskel på %3$d %% för %4$@ har nåtts.";
+"session_depleted_notification_title" = "%@-sessionen är slut";
+"session_depleted_notification_body" = "0 % kvar. Du får en avisering när den är tillgänglig igen.";
+"session_restored_notification_title" = "%@-sessionen är återställd";
+"session_restored_notification_body" = "Sessionskvoten är tillgänglig igen.";
+"quota_warning_warn_at" = "Varna vid";
+"quota_warning_global_threshold_subtitle" = "Återstående procent för sessions- och veckofönster, om inte en leverantör åsidosätter dem.";
+"quota_warning_sound" = "Spela aviseringsljud";
+"quota_warning_provider_inherits" = "Använder de globala kvotvarningsinställningarna om inte ett fönster anpassas här.";
+"quota_warning_customize_thresholds" = "Anpassa trösklar för %@";
+"quota_warning_enable_warnings" = "Aktivera varningar för %@";
+"quota_warning_window_warn_at" = "Varna vid för %@";
+"quota_warning_off" = "Av";
+"quota_warning_inherited" = "Ärvd: %@";
+"quota_warning_depleted_only" = "bara slut";
+"quota_warning_upper" = "Övre";
+"quota_warning_lower" = "Nedre";
+"apply" = "Tillämpa";
+"quit_app" = "Avsluta CodexBar";
+
+/* Tab titles */
+"tab_general" = "Allmänt";
+"tab_providers" = "Leverantörer";
+"tab_display" = "Visning";
+"tab_advanced" = "Avancerat";
+"tab_about" = "Om";
+"tab_debug" = "Felsök";
+
+/* Providers Pane */
+"select_a_provider" = "Välj en leverantör";
+"cancel" = "Avbryt";
+"last_fetch_failed" = "senaste hämtningen misslyckades";
+"usage_not_fetched_yet" = "användning har inte hämtats än";
+"managed_account_storage_unreadable" = "Hanterad kontolagring går inte att läsa. Direkt kontoåtkomst är fortfarande tillgänglig, men hanterade åtgärder för att lägga till, autentisera om och ta bort är inaktiverade tills lagringen kan återställas.";
+"remove_codex_account_title" = "Ta bort Codex-konto?";
+"remove" = "Ta bort";
+"managed_login_already_running" = "En hanterad Codex-inloggning körs redan. Vänta tills den är klar innan du lägger till eller autentiserar om ett annat konto.";
+"managed_login_failed" = "Den hanterade Codex-inloggningen slutfördes inte. Kontrollera att `codex --version` fungerar i Terminal. Om macOS blockerade eller flyttade `codex` till papperskorgen tar du bort gamla dubblettinstallationer, kör `npm install -g --include=optional @openai/codex@latest` och försöker igen.";
+"managed_login_missing_email" = "Codex-inloggningen slutfördes, men ingen e-postadress för kontot var tillgänglig. Försök igen när du har kontrollerat att kontot är helt inloggat.";
+"login_success_notification_title" = "%@-inloggning lyckades";
+"login_success_notification_body" = "Du kan återgå till appen. Autentiseringen är klar.";
+"workspace_selection_cancelled" = "CodexBar hittade flera arbetsytor, men ingen arbetsyta valdes.";
+"unsafe_managed_home" = "CodexBar vägrade ändra en oväntad hanterad hem-sökväg: %@";
+"menu_bar_metric_title" = "Menyradsmått";
+"menu_bar_metric_subtitle" = "Välj vilket fönster som styr procenttalet i menyraden.";
+"menu_bar_metric_subtitle_deepseek" = "Visar DeepSeek-saldot i menyraden.";
+"menu_bar_metric_subtitle_moonshot" = "Visar saldot för Moonshot/Kimi API i menyraden.";
+"menu_bar_metric_subtitle_mistral" = "Visar den aktuella månadens Mistral API-utgift i menyraden.";
+"menu_bar_metric_subtitle_kimik2" = "Visar Kimi K2-API-nyckelkrediter i menyraden.";
+"automatic" = "Automatiskt";
+"primary_api_key_limit" = "Primär (API-nyckelgräns)";
+
+/* Display Pane */
+"section_menu_bar" = "Menyrad";
+"merge_icons_title" = "Slå ihop ikoner";
+"merge_icons_subtitle" = "Använd en enda menyradsikon med leverantörsväxlare.";
+"switcher_shows_icons_title" = "Växlaren visar ikoner";
+"switcher_shows_icons_subtitle" = "Visa leverantörsikoner i växlaren (annars visas en veckoförloppslinje).";
+"show_most_used_provider_title" = "Visa mest använda leverantör";
+"show_most_used_provider_subtitle" = "Menyraden visar automatiskt leverantören som ligger närmast sin gräns.";
+"menu_bar_shows_percent_title" = "Menyraden visar procent";
+"menu_bar_shows_percent_subtitle" = "Ersätt figurstaplar med leverantörsikoner och ett procenttal.";
+"hide_critters_title" = "Dölj figurer";
+"hide_critters_subtitle" = "Visa enkla mätarstaplar utan ansikte och dekorationer.";
+"display_mode_title" = "Visningsläge";
+"display_mode_subtitle" = "Välj vad som ska visas i menyraden (takt visar användning mot förväntat).";
+"section_menu_content" = "Menyinnehåll";
+"show_usage_as_used_title" = "Visa användning som förbrukad";
+"show_usage_as_used_subtitle" = "Förloppsstaplar fylls när du förbrukar kvot i stället för att visa återstående.";
+"show_quota_warning_markers_title" = "Visa kvotvarningsmarkörer";
+"show_quota_warning_markers_subtitle" = "Rita tröskelmarkeringar på användningsstaplar när kvotvarningar är konfigurerade.";
+"weekly_progress_work_days_title" = "Arbetsdagar i veckoförlopp";
+"weekly_progress_work_days_subtitle" = "Ställ in arbetsdagar för markeringar i veckostaplar och tempoberäkningar.";
+"show_reset_time_as_clock_title" = "Visa återställningstid som klockslag";
+"show_reset_time_as_clock_subtitle" = "Visa återställningstider som klockslag i stället för nedräkningar.";
+"show_provider_changelog_links_title" = "Visa länkar till leverantörers ändringsloggar";
+"show_provider_changelog_links_subtitle" = "Lägger till länkar till utgåvekommentarer för stödda CLI-baserade leverantörer i menyn.";
+"show_credits_extra_usage_title" = "Visa krediter och extra användning";
+"show_credits_extra_usage_subtitle" = "Visa avsnitt för Codex-krediter och Claude Extra-användning i menyn.";
+"show_all_token_accounts_title" = "Visa alla tokenkonton";
+"show_all_token_accounts_subtitle" = "Stapla tokenkonton i menyn (annars visas en kontoväxlare).";
+"multi_account_layout_title" = "Layout för flera konton";
+"multi_account_layout_subtitle" = "Välj segmenterad kontoväxling eller staplade kontokort.";
+"multi_account_layout_segmented" = "Segmenterad";
+"multi_account_layout_stacked" = "Staplad";
+"overview_tab_providers_title" = "Leverantörer på översiktsfliken";
+"configure" = "Konfigurera…";
+"overview_enable_merge_icons_hint" = "Aktivera Slå ihop ikoner för att konfigurera leverantörer på översiktsfliken.";
+"overview_no_providers_hint" = "Inga aktiverade leverantörer är tillgängliga för översikten.";
+"overview_rows_follow_order" = "Översiktsrader följer alltid leverantörsordningen.";
+"overview_no_providers_selected" = "Inga leverantörer valda";
+
+/* Advanced Pane */
+"section_keyboard_shortcut" = "Kortkommando";
+"open_menu_shortcut_title" = "Öppna meny";
+"open_menu_shortcut_subtitle" = "Öppna menyradsmenyn var du än är.";
+"install_cli" = "Installera CLI";
+"install_cli_subtitle" = "Symlänka CodexBarCLI till /usr/local/bin och /opt/homebrew/bin som codexbar.";
+"cli_not_found" = "CodexBarCLI hittades inte i apppaketet.";
+"no_writable_bin_dirs" = "Inga skrivbara bin-kataloger hittades.";
+"show_debug_settings_title" = "Visa felsökningsinställningar";
+"show_debug_settings_subtitle" = "Visa felsökningsverktyg på fliken Felsök.";
+"surprise_me_title" = "Överraska mig";
+"surprise_me_subtitle" = "Kontrollera om du vill att agenterna ska få leka lite där uppe.";
+"weekly_limit_confetti_title" = "Veckogränskonfetti";
+"weekly_limit_confetti_subtitle" = "Spela konfetti i helskärm när veckoförbrukningen återställs.";
+"hide_personal_info_title" = "Dölj personuppgifter";
+"hide_personal_info_subtitle" = "Maskera e-postadresser i menyraden och menygränssnittet.";
+"show_provider_storage_usage_title" = "Visa leverantörers lagringsanvändning";
+"show_provider_storage_usage_subtitle" = "Visa lokal diskanvändning i menyer. Söker igenom kända leverantörsägda sökvägar i bakgrunden.";
+"section_keychain_access" = "Åtkomst till Nyckelring";
+"keychain_access_caption" = "Inaktivera all läsning och skrivning i Nyckelring. Använd detta om macOS fortsätter fråga om 'Chrome/Brave/Edge Safe Storage' även efter att du klickat på Tillåt alltid. Import av webbläsarcookies är inte tillgänglig när detta är aktiverat. Klistra in Cookie-headers manuellt under Leverantörer. Claude/Codex OAuth via CLI fungerar fortfarande.";
+"disable_keychain_access_title" = "Inaktivera åtkomst till Nyckelring";
+"disable_keychain_access_subtitle" = "Förhindrar all åtkomst till Nyckelring när det är aktiverat.";
+
+/* About Pane */
+"about_tagline" = "Må dina token aldrig ta slut – håll agentgränserna synliga.";
+"link_github" = "GitHub";
+"link_website" = "Webbplats";
+"link_twitter" = "Twitter";
+"link_email" = "E-post";
+"check_updates_auto" = "Sök efter uppdateringar automatiskt";
+"update_channel" = "Uppdateringskanal";
+"check_for_updates" = "Sök efter uppdateringar…";
+"updates_unavailable" = "Uppdateringar är inte tillgängliga i det här bygget.";
+"copyright" = "© 2026 Peter Steinberger. MIT-licens.";
+
+/* Debug Pane */
+"section_logging" = "Loggning";
+"enable_file_logging" = "Aktivera filloggning";
+"enable_file_logging_subtitle" = "Skriv loggar till %@ för felsökning.";
+"verbosity_title" = "Detaljnivå";
+"verbosity_subtitle" = "Styr hur detaljerad loggningen är.";
+"open_log_file" = "Öppna loggfil";
+"force_animation_next_refresh" = "Tvinga animation vid nästa uppdatering";
+"force_animation_next_refresh_subtitle" = "Visar tillfälligt laddningsanimationen efter nästa uppdatering.";
+"section_loading_animations" = "Laddningsanimationer";
+"loading_animations_caption" = "Välj ett mönster och spela upp det i menyraden. \"Slumpmässig\" behåller nuvarande beteende.";
+"animation_random_default" = "Slumpmässig (standard)";
+"replay_selected_animation" = "Spela vald animation igen";
+"blink_now" = "Blinka nu";
+"section_probe_logs" = "Probloggar";
+"probe_logs_caption" = "Hämta senaste probutdata för felsökning. Kopiera behåller hela texten.";
+"fetch_log" = "Hämta logg";
+"copy" = "Kopiera";
+"save_to_file" = "Spara till fil";
+"load_parse_dump" = "Läs in tolkningsdump";
+"rerun_provider_autodetect" = "Kör automatisk leverantörsidentifiering igen";
+"loading" = "Läser in…";
+"no_log_yet_fetch" = "Ingen logg än. Hämta för att läsa in.";
+"section_fetch_strategy" = "Försök med hämtningsstrategi";
+"fetch_strategy_caption" = "Senaste hämtningskedjans beslut och fel för en leverantör.";
+"section_openai_cookies" = "OpenAI-cookies";
+"openai_cookies_caption" = "Loggar för cookieimport och WebKit-skrapning från senaste OpenAI-cookieförsöket.";
+"no_log_yet" = "Ingen logg än. Uppdatera OpenAI-cookies under Leverantörer → Codex för att köra en import.";
+"section_caches" = "Cachar";
+"caches_caption" = "Rensa cachade resultat från kostnadsskanningar eller webbläsarcookiecachar.";
+"clear_cookie_cache" = "Rensa cookiecache";
+"clear_cost_cache" = "Rensa kostnadscache";
+"section_notifications" = "Aviseringar";
+"notifications_caption" = "Skicka testaviseringar för femtimmarsfönstret (slut/återställt).";
+"post_depleted" = "Skicka slut";
+"post_restored" = "Skicka återställd";
+"section_cli_sessions" = "CLI-sessioner";
+"cli_sessions_caption" = "Håll Codex/Claude-CLI-sessioner vid liv efter en prob. Standard är att avsluta när data har fångats.";
+"keep_cli_sessions_alive" = "Håll CLI-sessioner vid liv";
+"keep_cli_sessions_alive_subtitle" = "Hoppa över nedstängning mellan prober (endast felsökning).";
+"reset_cli_sessions" = "Återställ CLI-sessioner";
+"section_error_simulation" = "Felsimulering";
+"error_simulation_caption" = "Infoga ett falskt felmeddelande i menykortet för layouttestning.";
+"set_menu_error" = "Sätt menyfel";
+"clear_menu_error" = "Rensa menyfel";
+"set_cost_error" = "Sätt kostnadsfel";
+"clear_cost_error" = "Rensa kostnadsfel";
+"section_cli_paths" = "CLI-sökvägar";
+"cli_paths_caption" = "Löst Codex-binär och PATH-lager. Inloggningsskalets PATH fångas vid start (kort timeout).";
+"codex_binary" = "Codex-binär";
+"claude_binary" = "Claude-binär";
+"effective_path" = "Effektiv PATH";
+"unavailable" = "Inte tillgänglig";
+"login_shell_path" = "Inloggningsskalets PATH (fångad vid start)";
+"cleared" = "Rensat.";
+"no_fetch_attempts" = "Inga hämtningsförsök än.";
+"macOS Tahoe can block menu bar apps in System Settings → Menu Bar → Allow in the Menu Bar. CodexBar is running, but macOS may be hiding its icon. Open Menu Bar settings and turn CodexBar on." = "macOS Tahoe kan blockera menyradsappar i Systeminställningar → Menyrad → Tillåt i menyraden. CodexBar körs, men macOS kan dölja ikonen. Öppna menyradsinställningarna och slå på CodexBar.";
+
+/* Metric preferences */
+"metric_pref_automatic" = "Automatiskt";
+"metric_pref_primary" = "Primär";
+"metric_pref_secondary" = "Sekundär";
+"metric_pref_tertiary" = "Tertiär";
+"metric_pref_extra_usage" = "Extra användning";
+"metric_pref_average" = "Genomsnitt";
+"metric_mistral_payg" = "Pay-as-you-go";
+"metric_mistral_monthly_plan" = "Monthly Plan";
+
+/* Display modes */
+"display_mode_percent" = "Procent";
+"display_mode_pace" = "Takt";
+"display_mode_both" = "Båda";
+"display_mode_reset_time" = "Återställningstid";
+"display_mode_percent_desc" = "Visa återstående/förbrukad procent (t.ex. 45 %)";
+"display_mode_pace_desc" = "Visa taktindikator (t.ex. +5 %)";
+"display_mode_both_desc" = "Visa både procent och takt (t.ex. 45 % · +5 %)";
+"display_mode_reset_time_desc" = "Visa återställningstiden för valt mått (t.ex. ↻ 3:56 PM)";
+
+/* Provider status */
+"status_operational" = "Fungerar normalt";
+"status_partial_outage" = "Delvis avbrott";
+"status_major_outage" = "Större avbrott";
+"status_critical_issue" = "Kritiskt problem";
+"status_maintenance" = "Underhåll";
+"status_unknown" = "Okänd status";
+
+/* Refresh frequency */
+"refresh_manual" = "Manuellt";
+"refresh_1min" = "1 min";
+"refresh_2min" = "2 min";
+"refresh_5min" = "5 min";
+"refresh_15min" = "15 min";
+"refresh_30min" = "30 min";
+
+/* Additional keys */
+"not_found" = "Hittades inte";
+
+/* Cost estimation */
+"cost_header_estimated" = "Kostnad (uppskattad)";
+"cost_estimate_hint" = "Uppskattat från lokala loggar · kan skilja sig från din faktura";
+"No JetBrains IDE with AI Assistant detected. Install a JetBrains IDE and enable AI Assistant." = "Ingen JetBrains IDE med AI Assistant hittades. Installera en JetBrains IDE och aktivera AI Assistant.";
+"OpenRouter API token not configured. Set OPENROUTER_API_KEY environment variable or configure in Settings." = "OpenRouter-API-token är inte konfigurerad. Ange miljövariabeln OPENROUTER_API_KEY eller konfigurera i Inställningar.";
+"z.ai API token not found. Set apiKey in ~/.codexbar/config.json or Z_AI_API_KEY." = "z.ai-API-token hittades inte. Ange apiKey i ~/.codexbar/config.json eller Z_AI_API_KEY.";
+"Missing DeepSeek API key." = "DeepSeek-API-nyckel saknas.";
+"%@ is unavailable in the current environment." = "%@ är inte tillgänglig i den aktuella miljön.";
+"All Systems Operational" = "Alla system fungerar";
+"Last 30 days" = "Senaste 30 dagarna";
+"Last 30 days:" = "Senaste 30 dagarna:";
+"This month" = "Den här månaden";
+"Store multiple OpenAI API keys." = "Spara flera OpenAI-API-nycklar.";
+"Admin API key" = "Admin-API-nyckel";
+"Open billing" = "Öppna fakturering";
+"Google accounts" = "Google-konton";
+"Store multiple Antigravity Google OAuth accounts for quick switching." = "Spara flera Google OAuth-konton för Antigravity så att du snabbt kan växla.";
+"Add Google Account" = "Lägg till Google-konto";
+"Open Token Plan" = "Öppna tokenplan";
+"Text Generation" = "Textgenerering";
+"Text to Speech" = "Text till tal";
+"Music Generation" = "Musikgenerering";
+"Image Generation" = "Bildgenerering";
+"No local data found" = "Inga lokala data hittades";
+"Credits unavailable; keep Codex running to refresh." = "Krediter är inte tillgängliga. Håll Codex igång för att uppdatera.";
+"No available fetch strategy for minimax." = "Ingen tillgänglig hämtningsstrategi för minimax.";
+"No Cursor session found. Please log in to cursor.com in Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX, or Edge Canary. If you use Safari, grant CodexBar Full Disk Access in System Settings ▸ Privacy & Security. You can also sign in to Cursor from the CodexBar menu (Add / switch account)." = "Ingen Cursor-session hittades. Logga in på cursor.com i Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX eller Edge Canary. Om du använder Safari ger du CodexBar Fullständig skivåtkomst i Systeminställningar ▸ Integritet och säkerhet. Du kan också logga in på Cursor från CodexBar-menyn (lägg till/byt konto).";
+"No OpenCode session cookies found in browsers." = "Inga OpenCode-sessionscookies hittades i webbläsare.";
+"No available fetch strategy for %@." = "Ingen tillgänglig hämtningsstrategi för %@.";
+"Today" = "Idag";
+"Today tokens" = "Token idag";
+"30d cost" = "Kostnad 30 d";
+"30d tokens" = "Token 30 d";
+"Latest tokens" = "Senaste token";
+"Top model" = "Toppmodell";
+"Storage" = "Lagring";
+"Add Account..." = "Lägg till konto...";
+"Usage Dashboard" = "Användningsinstrumentpanel";
+"Status Page" = "Statussida";
+"Settings..." = "Inställningar...";
+"About CodexBar" = "Om CodexBar";
+"Quit" = "Avsluta";
+"Last %d day" = "Senaste %d dagen";
+"Last %d days" = "Senaste %d dagarna";
+"%@ tokens" = "%@ token";
+"Latest billing day" = "Senaste faktureringsdag";
+"Latest billing day (%@)" = "Senaste faktureringsdag (%@)";
+"%@ left" = "%@ kvar";
+"Resets %@" = "Återställs %@";
+"Resets in %@" = "Återställs om %@";
+"Resets now" = "Återställs nu";
+"reset_tomorrow_format" = "imorgon %@";
+"Lasts until reset" = "Räcker till återställning";
+"Updated %@" = "Uppdaterad %@";
+"Updated %@h ago" = "Uppdaterad för %@ h sedan";
+"Updated %@m ago" = "Uppdaterad för %@ min sedan";
+"Updated just now" = "Uppdaterad nyss";
+"Projected empty in %@" = "Beräknas ta slut om %@";
+"Runs out in %@" = "Tar slut om %@";
+"Pace: %@" = "Takt: %@";
+"Pace: %@ · %@" = "Takt: %@ · %@";
+"%@ · %@" = "%@ · %@";
+"≈ %d%% run-out risk" = "≈ %d %% risk att ta slut";
+"%d%% in deficit" = "%d %% underskott";
+"%d%% in reserve" = "%d %% reserv";
+"usage_percent_suffix_left" = "kvar";
+"usage_percent_suffix_used" = "förbrukat";
+"Store multiple DeepSeek API keys." = "Spara flera DeepSeek-API-nycklar.";
+"This week" = "Den här veckan";
+"Week" = "Vecka";
+"Month" = "Månad";
+"Models" = "Modeller";
+"24h tokens" = "Token 24 h";
+"Latest hour" = "Senaste timmen";
+"Peak hour" = "Topptimme";
+"Top method" = "Toppmetod";
+"30d cash" = "Pengar 30 d";
+"30d billing history from MiniMax web session" = "Faktureringshistorik 30 d från MiniMax-webbsession";
+"AWS Cost Explorer billing can lag." = "AWS Cost Explorer-fakturering kan släpa efter.";
+"Rate limit: %d / %@" = "Gräns: %d / %@";
+"Key remaining" = "Nyckel återstår";
+"No limit set for the API key" = "Ingen gräns är satt för API-nyckeln";
+"API key limit unavailable right now" = "API-nyckelgränsen är inte tillgänglig just nu";
+"This month: %@ tokens" = "Den här månaden: %@ token";
+"No utilization data yet." = "Inga utnyttjandedata än.";
+"No %@ utilization data yet." = "Inga utnyttjandedata för %@ än.";
+"%@: %@%% used" = "%@: %@ %% förbrukat";
+"%dd" = "%d d";
+"today" = "idag";
+"just now" = "nyss";
+"On pace" = "I takt";
+"Runs out now" = "Tar slut nu";
+"Projected empty now" = "Beräknas vara slut nu";
+"Switch Account..." = "Byt konto...";
+"Update ready, restart now?" = "Uppdatering redo. Starta om nu?";
+"Daily" = "Dagligen";
+"Hourly Tokens" = "Token per timme";
+"No data" = "Inga data";
+"No usage breakdown data available." = "Ingen användningsuppdelning tillgänglig.";
+
+"Today: %@ · %@ tokens" = "Idag: %@ · %@ token";
+"Today: %@" = "Idag: %@";
+"Today: %@ tokens" = "Idag: %@ token";
+"Last 30 days: %@ · %@ tokens" = "Senaste 30 dagarna: %@ · %@ token";
+"Last 30 days: %@" = "Senaste 30 dagarna: %@";
+"Est. total (30d): %@" = "Uppsk. totalt (30 d): %@";
+"Est. total (%@): %@" = "Uppsk. totalt (%@): %@";
+"Hover a bar for details" = "Håll pekaren över en stapel för detaljer";
+"%@: %@ · %@ tokens" = "%@: %@ · %@ token";
+"No providers selected for Overview." = "Inga leverantörer valda för översikten.";
+"No overview data available." = "Inga översiktsdata tillgängliga.";
+"Auto uses the local IDE API first, then Google OAuth when the IDE is closed." = "Auto använder det lokala IDE-API:t först och sedan Google OAuth när IDE:n är stängd.";
+"Login with Google" = "Logga in med Google";
+"Google OAuth" = "Google OAuth";
+"Add accounts via GitHub OAuth Device Flow on the selected host." = "Lägg till konton via GitHub OAuth Device Flow på vald värd.";
+"Stores each signed-in Google account for quick Antigravity switching. Uses Antigravity.app OAuth when available, or ANTIGRAVITY_OAUTH_CLIENT_ID and ANTIGRAVITY_OAUTH_CLIENT_SECRET as an override." = "Sparar varje inloggat Google-konto för snabb växling i Antigravity. Använder Antigravity.app OAuth när det finns, eller ANTIGRAVITY_OAUTH_CLIENT_ID och ANTIGRAVITY_OAUTH_CLIENT_SECRET som ersättning.";
+"Manual cleanup: past sessions" = "Manuell rensning: tidigare sessioner";
+"Clearing removes past resume, continue, and rewind history." = "Rensning tar bort historik för tidigare återuppta, fortsätt och spola tillbaka.";
+"Manual cleanup: file checkpoints" = "Manuell rensning: filkontrollpunkter";
+"Clearing removes checkpoint restore data for previous edits." = "Rensning tar bort återställningsdata från kontrollpunkter för tidigare ändringar.";
+"Manual cleanup: saved plans" = "Manuell rensning: sparade planer";
+"Clearing removes old plan-mode files." = "Rensning tar bort gamla planlägesfiler.";
+"Manual cleanup: debug logs" = "Manuell rensning: felsökningsloggar";
+"Clearing removes past debug logs." = "Rensning tar bort tidigare felsökningsloggar.";
+"Manual cleanup: attachment cache" = "Manuell rensning: cache för bilagor";
+"Clearing removes cached large pastes or attached images." = "Rensning tar bort cachade stora inklistringar eller bifogade bilder.";
+"Manual cleanup: session metadata" = "Manuell rensning: sessionsmetadata";
+"Clearing removes per-session environment metadata." = "Rensning tar bort miljömetadata per session.";
+"Manual cleanup: shell snapshots" = "Manuell rensning: skalögonblicksbilder";
+"Clearing removes leftover runtime shell snapshot files." = "Rensning tar bort kvarvarande skalögonblicksbilder från körtid.";
+"Manual cleanup: legacy todos" = "Manuell rensning: äldre att göra-listor";
+"Clearing removes legacy per-session task lists." = "Rensning tar bort äldre uppgiftslistor per session.";
+"Manual cleanup: sessions" = "Manuell rensning: sessioner";
+"Clearing removes past Codex session history." = "Rensning tar bort tidigare Codex-sessionshistorik.";
+"Manual cleanup: archived sessions" = "Manuell rensning: arkiverade sessioner";
+"Clearing removes archived Codex session history." = "Rensning tar bort arkiverad Codex-sessionshistorik.";
+"Manual cleanup: cache" = "Manuell rensning: cache";
+"Clearing removes provider-owned cached data." = "Rensning tar bort leverantörsägda cachade data.";
+"Manual cleanup: logs" = "Manuell rensning: loggar";
+"Clearing removes local diagnostic logs." = "Rensning tar bort lokala diagnostikloggar.";
+"Manual cleanup: file history" = "Manuell rensning: filhistorik";
+"Clearing removes local edit checkpoint history." = "Rensning tar bort lokal redigeringshistorik från kontrollpunkter.";
+"Manual cleanup: temporary data" = "Manuell rensning: tillfälliga data";
+"Clearing removes local temporary provider data." = "Rensning tar bort tillfälliga lokala leverantörsdata.";
+"Total: %@" = "Totalt: %@";
+"%d more items" = "%d objekt till";
+"Cleanup ideas" = "Rensningsförslag";
+"%d unreadable item(s) skipped" = "%d oläsbara objekt hoppades över";
+
+"API key limit" = "API-nyckelgräns";
+"Auth" = "Autentisering";
+"Auto" = "Auto";
+"Disabled — no recent data" = "Inaktiverad – inga färska data";
+"Limits not available" = "Gränser är inte tillgängliga";
+"No usage yet" = "Ingen användning än";
+"Not fetched yet" = "Inte hämtat än";
+"Refreshing" = "Uppdaterar";
+"Session" = "Session";
+"Source" = "Källa";
+"State" = "Tillstånd";
+"Unavailable" = "Inte tillgänglig";
+"Weekly" = "Vecka";
+"not detected" = "inte hittad";
+"Estimated from local Codex logs for the selected account." = "Uppskattat från lokala Codex-loggar för valt konto.";
+"minimax_usage_amount_format" = "Användning: %@ / %@";
+"minimax_used_percent_format" = "Förbrukat %@";
+"minimax_service_text_generation" = "Textgenerering";
+"minimax_service_text_to_speech" = "Text till tal";
+"minimax_service_music_generation" = "Musikgenerering";
+"minimax_service_image_generation" = "Bildgenerering";
+"minimax_service_lyrics_generation" = "Låttextgenerering";
+"minimax_service_coding_plan_vlm" = "Coding plan VLM";
+"minimax_service_coding_plan_search" = "Coding plan-sökning";
+
+/* Added after rebasing Swedish localization on current main. */
+"Open MiMo Balance" = "Öppna MiMo-saldo";
+"Stored in ~/.codexbar/config.json. Metrics require Groq Enterprise Prometheus access." = "Sparas i ~/.codexbar/config.json. Mätvärden kräver åtkomst till Groq Enterprise Prometheus.";
+"API spend" = "API-kostnad";
+"Open Command Code Settings" = "Öppna Command Code-inställningar";
+"Plan utilization chart" = "Diagram över plananvändning";
+"The browser login did not complete in time. Try Antigravity login again." = "Webbläsarinloggningen blev inte klar i tid. Försök logga in i Antigravity igen.";
+"Organizations" = "Organisationer";
+"Your StepFun platform password. Used to login and obtain a session token." = "Ditt lösenord för StepFun-plattformen. Används för att logga in och hämta en sessionstoken.";
+"Open this URL manually to continue login:\n\n%@" = "Öppna denna URL manuellt för att fortsätta inloggningen:\n\n%@";
+"CodexBar could not replace the live Codex auth on this Mac." = "CodexBar kunde inte ersätta aktiv Codex-autentisering på den här Mac-datorn.";
+"Stored in ~/.codexbar/config.json. Used for /v1/quota-stats." = "Sparas i ~/.codexbar/config.json. Används för /v1/quota-stats.";
+"CodexBar could not safely preserve the current system account before switching." = "CodexBar kunde inte spara det aktuella systemkontot säkert före bytet.";
+"Oasis-Token" = "Oasis-Token";
+"Open Crof dashboard" = "Öppna Crof-översikt";
+"Sonnet" = "Sonnet";
+"No credits history data available." = "Ingen kredithistorik finns tillgänglig.";
+"4 days" = "4 dagar";
+"AWS secret access key. Can also be set with AWS_SECRET_ACCESS_KEY." = "Hemlig AWS-åtkomstnyckel. Kan även anges med AWS_SECRET_ACCESS_KEY.";
+"Paste a Cookie header or cURL capture from %@." = "Klistra in en Cookie-header eller cURL-fångst från %@.";
+"Show or hide Kiro credits, percent, or both next to the menu bar icon." = "Visa eller dölj Kiro-krediter, procent eller båda bredvid menyradsikonen.";
+"credits" = "krediter";
+"CodexBar will ask macOS Keychain for “%@” so it can decrypt browser cookies and authenticate your account. Click OK to continue." = "CodexBar kommer att be macOS Nyckelring om ”%@” så att webbläsarcookies kan dekrypteras och ditt konto autentiseras. Klicka på OK för att fortsätta.";
+"StepFun platform account (phone number or email)." = "StepFun-plattformskonto (telefonnummer eller e-post).";
+"Timed out waiting for Cursor login. %@" = "Tidsgränsen nåddes i väntan på Cursor-inloggning. %@";
+"CodexBar will ask macOS Keychain for your Amp cookie header so it can fetch usage. Click OK to continue." = "CodexBar kommer att be macOS Nyckelring om din Amp-cookie-header så att användning kan hämtas. Klicka på OK för att fortsätta.";
+"Stored in ~/.codexbar/config.json." = "Sparas i ~/.codexbar/config.json.";
+"Reported by Mistral billing usage." = "Rapporteras av Mistrals debiteringsanvändning.";
+"Usage remaining" = "Användning kvar";
+"Usage used" = "Användning förbrukad";
+"Cookie: …\n\nor paste the __Secure-next-auth.session-token value" = "Cookie: …\n\neller klistra in värdet för __Secure-next-auth.session-token";
+"Password" = "Lösenord";
+"Stored in ~/.codexbar/config.json. In Warp, open Settings > Platform > API Keys, then create one." = "Sparas i ~/.codexbar/config.json. Öppna Settings > Platform > API Keys i Warp och skapa en nyckel.";
+"%d percent remaining" = "%d procent kvar";
+"Open Manus" = "Öppna Manus";
+"Unknown" = "Okänt";
+"Open Ollama API Keys" = "Öppna Ollama-API-nycklar";
+"Hourly Usage" = "Användning per timme";
+"Requests" = "Förfrågningar";
+"Antigravity login timed out" = "Antigravity-inloggning tog för lång tid";
+"%@ requests" = "%@ förfrågningar";
+"Open StepFun Platform" = "Öppna StepFun-plattformen";
+"CodexBar will ask macOS Keychain for your OpenCode cookie header so it can fetch usage. Click OK to continue." = "CodexBar kommer att be macOS Nyckelring om din OpenCode-cookie-header så att användning kan hämtas. Klicka på OK för att fortsätta.";
+"Endpoint" = "Slutpunkt";
+"Paste the %@ JSON bundle from %@." = "Klistra in %@-JSON-paketet från %@.";
+"Uses username + password to login and obtain an %@ automatically." = "Använder användarnamn och lösenord för att logga in och hämta ett %@ automatiskt.";
+"Capacity Start" = "Kapacitetsstart";
+"Paste the Oasis-Token from a logged-in browser session on platform.stepfun.com." = "Klistra in Oasis-Token från en inloggad webbläsarsession på platform.stepfun.com.";
+"Claude Admin API 30 day spend trend" = "30-dagars kostnadstrend för Claude Admin API";
+"%@/%@ left" = "%@/%@ kvar";
+"Monthly" = "Månadsvis";
+"Gemini Flash" = "Gemini Flash";
+"Cost history chart" = "Diagram över kostnadshistorik";
+"Today requests" = "Dagens förfrågningar";
+"Kiro menu bar value" = "Kiro-värde i menyraden";
+"CodexBar could not read managed account storage. Recover the store before adding another account." = "CodexBar kunde inte läsa hanterad kontolagring. Återställ lagringen innan du lägger till ett konto till.";
+"Using CLI fallback" = "Använder CLI-reserv";
+"%@ web API access is disabled." = "%@-åtkomst till webb-API är inaktiverad.";
+"tokens" = "token";
+"%@ / %@ (%@ remaining)" = "%@ / %@ (%@ kvar)";
+"Zen balance" = "Zen-saldo";
+"Daily billing data finalizes at 07:00 UTC" = "Dagliga debiteringsdata fastställs kl. 07.00 UTC";
+"Add Account" = "Lägg till konto";
+"CodexBar found another managed account that already uses the current system account. Resolve the duplicate account before switching." = "CodexBar hittade ett annat hanterat konto som redan använder det aktuella systemkontot. Lös dubbletten innan du byter.";
+"codex login exited with status %d." = "codex login avslutades med status %d.";
+"CodexBar could not read saved auth for that account. Re-authenticate it and try again." = "CodexBar kunde inte läsa sparad autentisering för kontot. Autentisera det igen och försök igen.";
+"Cookie: …\n\nor paste the kimi-auth token value" = "Cookie: …\n\neller klistra in värdet för kimi-auth-token";
+"Optional organization ID for accounts linked to multiple Anthropic organizations." = "Valfritt organisations-ID för konton som är kopplade till flera Anthropic-organisationer.";
+"Manually paste an %@ from a browser session." = "Klistra in ett %@ manuellt från en webbläsarsession.";
+"MiniMax 30 day token usage trend" = "30-dagars tokenanvändningstrend för MiniMax";
+"Choose the Moonshot/Kimi API host for international or China mainland accounts." = "Välj Moonshot/Kimi API-värd för internationella konton eller konton i Fastlandskina.";
+"Stored in ~/.codexbar/config.json. Get your key from openrouter.ai/settings/keys and set a key spending limit there to enable API key quota tracking." = "Sparas i ~/.codexbar/config.json. Hämta nyckeln från openrouter.ai/settings/keys och ange en köpgräns för nyckeln för att aktivera spårning av API-nyckelkvot.";
+"Uses username + password to login and obtain an Oasis-Token automatically." = "Använder användarnamn och lösenord för att logga in och hämta en Oasis-Token automatiskt.";
+"OpenRouter API key spend trend" = "Kostnadstrend för OpenRouter-API-nyckel";
+"Workspace ID" = "Arbetsyte-ID";
+"Refresh Session" = "Uppdatera session";
+"Today cash" = "Dagens kontanter";
+"Sign in to cursor.com in your browser, then refresh Cursor in CodexBar." = "Logga in på cursor.com i webbläsaren och uppdatera sedan Cursor i CodexBar.";
+"Extra usage spent" = "Extra användning förbrukad";
+"5 days" = "5 dagar";
+"T3 Chat cookie" = "T3 Chat-cookie";
+"Full in ~1 regen" = "Full om cirka 1 regenerering";
+"DeepSeek 30 day token usage trend" = "30-dagars tokenanvändningstrend för DeepSeek";
+"Reorder" = "Ändra ordning";
+"Changelog" = "Ändringslogg";
+"Deployment" = "Distribution";
+"Quota usage" = "Kvotanvändning";
+"Your spend" = "Din utgift";
+"No system account" = "Inget systemkonto";
+"Stored in ~/.codexbar/config.json. Requires an Anthropic Admin API key." = "Sparas i ~/.codexbar/config.json. Kräver en Anthropic Admin API-nyckel.";
+"AWS region. Can also be set with AWS_REGION." = "AWS-region. Kan även anges med AWS_REGION.";
+"CodexBar will ask macOS Keychain for your Claude cookie header so it can fetch Claude web usage. Click OK to continue." = "CodexBar kommer att be macOS Nyckelring om din Claude-cookie-header så att Claude-webbanvändning kan hämtas. Klicka på OK för att fortsätta.";
+"CodexBar will ask macOS Keychain for your z.ai API token so it can fetch usage. Click OK to continue." = "CodexBar kommer att be macOS Nyckelring om din z.ai-API-token så att användning kan hämtas. Klicka på OK för att fortsätta.";
+"Show usage for organizations you belong to. Personal account is always shown." = "Visa användning för organisationer du tillhör. Personligt konto visas alltid.";
+"%@ of %@ credits left" = "%@ av %@ krediter kvar";
+"Stored in ~/.codexbar/config.json. You can also provide CODEBUFF_API_KEY or let CodexBar read ~/.config/manicode/credentials.json (created by `codebuff login`)." = "Sparas i ~/.codexbar/config.json. Du kan också ange CODEBUFF_API_KEY eller låta CodexBar läsa ~/.config/manicode/credentials.json (skapas av `codebuff login`).";
+"Automatic imports Windsurf session data from Chromium browser localStorage." = "Importerar Windsurf-sessionsdata från Chromium-webbläsarens localStorage automatiskt.";
+"Full in ~%.0f regens" = "Full om cirka %.0f regenereringar";
+"Verbosity" = "Detaljnivå";
+"%d days of usage data across %d services" = "%d dagar med användningsdata för %d tjänster";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or ~/.local/share/kilo/auth.json (kilo.access)." = "Sparas i ~/.codexbar/config.json. Du kan också ange KILO_API_KEY eller ~/.local/share/kilo/auth.json (kilo.access).";
+"Windsurf session JSON bundle" = "Windsurf-sessionspaket i JSON";
+"CodexBar will ask macOS Keychain for your Cursor cookie header so it can fetch usage. Click OK to continue." = "CodexBar kommer att be macOS Nyckelring om din Cursor-cookie-header så att användning kan hämtas. Klicka på OK för att fortsätta.";
+"Drag to reorder" = "Dra för att ändra ordning";
+"Sort providers alphabetically" = "Sortera leverantörer alfabetiskt";
+"Sort providers alphabetically (enabled first)" = "Sortera leverantörer alfabetiskt (aktiverade först)";
+"Sorted alphabetically (enabled first) — click to use your custom order" = "Alfabetiskt sorterade (aktiverade först) — klicka för att använda din anpassade ordning";
+"cache-hit input" = "cacheträff-indata";
+"Automatically imports browser cookies." = "Importerar webbläsarcookies automatiskt.";
+"Open Volcengine Ark Console" = "Öppna Volcengine Ark-konsol";
+"Antigravity login failed" = "Antigravity-inloggning misslyckades";
+"Keychain access is disabled in Advanced, so browser cookie import is unavailable." = "Åtkomst till Nyckelring är inaktiverad under Avancerat, så import av webbläsarcookies är inte tillgänglig.";
+"Browser cookies" = "Webbläsarcookies";
+"Usage history (%d days)" = "Användningshistorik (%d dagar)";
+"Cache read" = "Cacheläsning";
+"Copied" = "Kopierat";
+"Disable %@ dashboard cookie usage." = "Inaktivera cookie-användning för %@-översikten.";
+"30d requests" = "30 d förfrågningar";
+"Adding Account…" = "Lägger till konto…";
+"Base URL" = "Bas-URL";
+"Utilization End" = "Användningsslut";
+"7d spend" = "7 d kostnad";
+"CodexBar could not read the current system account on this Mac." = "CodexBar kunde inte läsa det aktuella systemkontot på den här Mac-datorn.";
+"%@ of %@ bonus credits left" = "%@ av %@ bonuskrediter kvar";
+"Overage usage" = "Överförbrukning";
+"AWS access key ID. Can also be set with AWS_ACCESS_KEY_ID." = "AWS-åtkomstnyckel-ID. Kan även anges med AWS_ACCESS_KEY_ID.";
+"CodexBar could not find saved auth for that account. Re-authenticate it and try again." = "CodexBar kunde inte hitta sparad autentisering för kontot. Autentisera det igen och försök igen.";
+"Capacity End" = "Kapacitetsslut";
+"Paste the %@ value or a full Cookie header." = "Klistra in %@-värdet eller en fullständig Cookie-header.";
+"CodexBar will ask macOS Keychain for your Factory cookie header so it can fetch usage. Click OK to continue." = "CodexBar kommer att be macOS Nyckelring om din Factory-cookie-header så att användning kan hämtas. Klicka på OK för att fortsätta.";
+"Paste a Cookie header or full cURL capture from %@." = "Klistra in en Cookie-header eller fullständig cURL-fångst från %@.";
+"Paste the Cookie header from a request to admin.mistral.ai. Must contain an ory_session_* cookie." = "Klistra in Cookie-headern från en förfrågan till admin.mistral.ai. Den måste innehålla en ory_session_*-cookie.";
+"Copy error" = "Kopieringsfel";
+"CodexBar will ask macOS Keychain for your MiniMax API token so it can fetch usage. Click OK to continue." = "CodexBar kommer att be macOS Nyckelring om din MiniMax-API-token så att användning kan hämtas. Klicka på OK för att fortsätta.";
+"Project ID" = "Projekt-ID";
+"Timed out waiting for Cursor login. %@ Last error: %@" = "Tidsgränsen nåddes i väntan på Cursor-inloggning. %@ Senaste fel: %@";
+"codex_login_output" = "utdata från codex login:";
+"Stored in ~/.codexbar/config.json. Get your API key from the Volcengine Ark console." = "Sparas i ~/.codexbar/config.json. Hämta API-nyckeln från Volcengine Ark-konsolen.";
+"Overage cost" = "Kostnad för överförbrukning";
+"CodexBar can't replace a system account that is signed in with an API key only setup." = "CodexBar kan inte ersätta ett systemkonto som är inloggat med en konfiguration som bara använder API-nyckel.";
+"Utilization Start" = "Användningsstart";
+"API key verifies Ollama Cloud access; cookies still expose quota limits." = "API-nyckeln verifierar åtkomst till Ollama Cloud. Cookies visar fortfarande kvotgränser.";
+"Credits remaining" = "Krediter kvar";
+"Activity" = "Aktivitet";
+"Stored in ~/.codexbar/config.json. Get your key from console.deepgram.com." = "Sparas i ~/.codexbar/config.json. Hämta nyckeln från console.deepgram.com.";
+"Azure OpenAI deployment name. AZURE_OPENAI_DEPLOYMENT_NAME is also supported." = "Azure OpenAI-distributionens namn. AZURE_OPENAI_DEPLOYMENT_NAME stöds också.";
+"Extra usage balance: %@" = "Saldo för extra användning: %@";
+"requests" = "förfrågningar";
+"CodexBar could not save the current system account before switching." = "CodexBar kunde inte spara det aktuella systemkontot före bytet.";
+"Stored in ~/.codexbar/config.json. For the official Kimi API, use Moonshot / Kimi API." = "Sparas i ~/.codexbar/config.json. För det officiella Kimi-API:t använder du Moonshot / Kimi API.";
+"Cookie: …\n\nor paste a cURL capture from the Abacus AI dashboard" = "Cookie: …\n\neller klistra in en cURL-fångst från Abacus AI-översikten";
+"Last 30 days: %@ tokens" = "Senaste 30 dagarna: %@ token";
+"%@ authentication is disabled." = "%@-autentisering är inaktiverad.";
+"CodexBar will ask macOS Keychain for your GitHub Copilot token so it can fetch usage. Click OK to continue." = "CodexBar kommer att be macOS Nyckelring om din GitHub Copilot-token så att användning kan hämtas. Klicka på OK för att fortsätta.";
+"z.ai hourly token trend" = "Token-trend per timme för z.ai";
+"Near full" = "Nästan full";
+"Open Moonshot Console" = "Öppna Moonshot-konsol";
+"Open T3 Chat Settings" = "Öppna T3 Chat-inställningar";
+"after next regen" = "efter nästa regenerering";
+"%.0f%% used" = "%.0f%% använt";
+"claude /login exited with status %d." = "claude /login avslutades med status %d.";
+"%d days of cost data" = "%d dagar med kostnadsdata";
+"Open legacy provider docs" = "Öppna äldre leverantörsdokumentation";
+"Secret access key" = "Hemlig åtkomstnyckel";
+"Region" = "Region";
+"Paste a Cookie header captured from %@." = "Klistra in en Cookie-header fångad från %@.";
+"Credits history chart" = "Diagram över kredithistorik";
+"Re-authenticating…" = "Autentiserar igen…";
+"Paste a full cookie header or the %@ value." = "Klistra in en fullständig cookie-header eller %@-värdet.";
+"Reload" = "Läs in igen";
+"Stored in ~/.codexbar/config.json. OPENAI_ADMIN_KEY is preferred; OPENAI_API_KEY still works." = "Sparas i ~/.codexbar/config.json. OPENAI_ADMIN_KEY föredras, men OPENAI_API_KEY fungerar fortfarande.";
+"Access key ID" = "Åtkomstnyckel-ID";
+"No output captured." = "Ingen utdata fångades.";
+"Refresh organizations" = "Uppdatera organisationer";
+"session_id=...\n\nor paste just the session_id value" = "session_id=...\n\neller klistra bara in session_id-värdet";
+"Open Codebuff Dashboard" = "Öppna Codebuff-översikt";
+"7 days" = "7 dagar";
+"output" = "utdata";
+"Simulated error text" = "Simulerad feltext";
+"Regenerates %@" = "Regenererar %@";
+"Usage history (today)" = "Användningshistorik (i dag)";
+"Optional. Leave blank to discover and aggregate projects visible to the API key." = "Valfritt. Lämna tomt för att hitta och slå ihop projekt som är synliga för API-nyckeln.";
+"Stored in ~/.codexbar/config.json. Get your key from elevenlabs.io/app/settings/api-keys." = "Sparas i ~/.codexbar/config.json. Hämta nyckeln från elevenlabs.io/app/settings/api-keys.";
+"Automatic imports browser cookies from Bailian." = "Importerar webbläsarcookies från Bailian automatiskt.";
+"Enterprise host" = "Enterprise-värd";
+"Optional. Enter your GitHub Enterprise host, for example octocorp.ghe.com. Leave blank for github.com." = "Valfritt. Ange din GitHub Enterprise-värd, till exempel octocorp.ghe.com. Lämna tomt för github.com.";
+"%d utilization samples" = "%d användningsmätningar";
+"Cap start" = "Gränsstart";
+"Credits used" = "Använda krediter";
+"CodexBar will ask macOS Keychain for your OpenAI cookie header so it can fetch Codex dashboard extras. Click OK to continue." = "CodexBar kommer att be macOS Nyckelring om din OpenAI-cookie-header så att extra Codex-översiktsdata kan hämtas. Klicka på OK för att fortsätta.";
+"Re-auth" = "Autentisera igen";
+"Re-login at claude.ai" = "Logga in igen på claude.ai";
+"cache-miss input" = "cachemiss-indata";
+"Day" = "Dag";
+"Optional. Applies to the configured Admin API key; selected token accounts do not inherit OPENAI_PROJECT_ID." = "Valfritt. Gäller den konfigurerade Admin API-nyckeln. Valda tokenkonton ärver inte OPENAI_PROJECT_ID.";
+"Balance updates in near-real time (up to 5 min lag)" = "Saldot uppdateras nästan i realtid (upp till 5 min fördröjning)";
+"Cap end" = "Gränsslut";
+"Personal account" = "Personligt konto";
+"Automatically imports browser session cookies." = "Importerar webbläsarens sessionscookies automatiskt.";
+"Label" = "Etikett";
+"Stored in ~/.codexbar/config.json. Get your key from Ollama settings." = "Sparas i ~/.codexbar/config.json. Hämta nyckeln från Ollama-inställningarna.";
+"Open Augment (Log Out & Back In)" = "Öppna Augment (logga ut och in igen)";
+"Overages" = "Överförbrukning";
+"Open projects" = "Öppna projekt";
+"Reported by OpenAI Admin API organization usage." = "Rapporteras av OpenAI Admin API:s organisationsanvändning.";
+"%@: %@ credits" = "%@: %@ krediter";
+"CodexBar will ask macOS Keychain for your Kimi auth token so it can fetch usage. Click OK to continue." = "CodexBar kommer att be macOS Nyckelring om din Kimi-autentiseringstoken så att användning kan hämtas. Klicka på OK för att fortsätta.";
+"Keychain Access Required" = "Åtkomst till Nyckelring krävs";
+"Username" = "Användarnamn";
+"CodexBar will ask macOS Keychain for your MiniMax cookie header so it can fetch usage. Click OK to continue." = "CodexBar kommer att be macOS Nyckelring om din MiniMax-cookie-header så att användning kan hämtas. Klicka på OK för att fortsätta.";
+"30d spend" = "30 d kostnad";
+"API key verified. Ollama does not expose Cloud quota limits through the API." = "API-nyckeln har verifierats. Ollama exponerar inte Cloud-kvotgränser via API:t.";
+"Series" = "Serie";
+"Total (30d): %@ credits" = "Totalt (30 d): %@ krediter";
+"Paste a Cookie header or full cURL capture from T3 Chat settings." = "Klistra in en Cookie-header eller fullständig cURL-fångst från T3 Chat-inställningarna.";
+"%d days of credits data" = "%d dagar med kreditdata";
+"used after next regen" = "använt efter nästa regenerering";
+"CodexBar will ask macOS Keychain for your Kimi K2 API key so it can fetch usage. Click OK to continue." = "CodexBar kommer att be macOS Nyckelring om din Kimi K2-API-nyckel så att användning kan hämtas. Klicka på OK för att fortsätta.";
+"Usage breakdown chart" = "Diagram över användningsfördelning";
+"Could not open browser for Antigravity" = "Kunde inte öppna webbläsare för Antigravity";
+"Stored in ~/.codexbar/config.json. AZURE_OPENAI_API_KEY is also supported." = "Sparas i ~/.codexbar/config.json. AZURE_OPENAI_API_KEY stöds också.";
+"Could not open Cursor login in your browser." = "Kunde inte öppna Cursor-inloggning i webbläsaren.";
+"Latest" = "Senaste";
+"Azure OpenAI resource endpoint. AZURE_OPENAI_ENDPOINT is also supported." = "Azure OpenAI-resursens slutpunkt. AZURE_OPENAI_ENDPOINT stöds också.";
+"No organizations loaded. Click Refresh after setting your API key." = "Inga organisationer har lästs in. Klicka på Uppdatera efter att du har angett API-nyckeln.";
+"Copy path" = "Kopiera sökväg";
+"Paste a Cookie header from %@." = "Klistra in en Cookie-header från %@.";
+"CodexBar will ask macOS Keychain for the Claude Code OAuth token so it can fetch your Claude usage. Click OK to continue." = "CodexBar kommer att be macOS Nyckelring om OAuth-token för Claude Code så att din Claude-användning kan hämtas. Klicka på OK för att fortsätta.";
+"Base URL for the LLM-API-Key-Proxy instance." = "Bas-URL för LLM-API-Key-Proxy-instansen.";
+"Paste a Cookie or Authorization header from %@." = "Klistra in en Cookie- eller Authorization-header från %@.";
+"stale data" = "inaktuella data";
+"Quota" = "Kvot";
+"Auth source" = "Autentiseringskälla";
+"Automatic imports browser cookies from Xiaomi MiMo." = "Importerar webbläsarcookies från Xiaomi MiMo automatiskt.";
+"No usage configured." = "Ingen användning konfigurerad.";
+"Extra usage" = "Extra användning";
+"That account is no longer available in CodexBar. Refresh the account list and try again." = "Kontot finns inte längre i CodexBar. Uppdatera kontolistan och försök igen.";
+"%@ is waiting for permission" = "%@ väntar på behörighet";
+"Org ID (optional)" = "Org-ID (valfritt)";
+"Service" = "Tjänst";
+"Azure OpenAI key" = "Azure OpenAI-nyckel";
+"%@ cookies are disabled." = "%@-cookies är inaktiverade.";
+"Stored in ~/.codexbar/config.json. You can also provide CROF_API_KEY." = "Sparas i ~/.codexbar/config.json. Du kan också ange CROF_API_KEY.";
+"CodexBar will ask macOS Keychain for your Synthetic API key so it can fetch usage. Click OK to continue." = "CodexBar kommer att be macOS Nyckelring om din Synthetic-API-nyckel så att användning kan hämtas. Klicka på OK för att fortsätta.";
+"CodexBar could not update managed account storage." = "CodexBar kunde inte uppdatera hanterad kontolagring.";
+"CodexBar will ask macOS Keychain for your Augment cookie header so it can fetch usage. Click OK to continue." = "CodexBar kommer att be macOS Nyckelring om din Augment-cookie-header så att användning kan hämtas. Klicka på OK för att fortsätta.";
+"Clear" = "Rensa";
+"No matching providers" = "Inga matchande leverantörer";
+"Search providers" = "Sök leverantörer";
+
+"language_vietnamese" = "Vietnamesiska";
+"language_arabic" = "العربية";
+"language_persian" = "فارسی";
+"language_thai" = "ไทย";
+"Limit Reset Credits" = "Krediter för gränsåterställning";
+"1 manual reset available" = "1 manuell återställning tillgänglig";
+"%d manual resets available" = "%d manuella återställningar tillgängliga";
+"Next expires %@" = "Nästa upphör %@";
+"Other (%d items)" = "Övrigt (%d objekt)";
+"Expand" = "Expandera";
+"Collapse" = "Fäll ihop";
+"byte_unit_byte" = "byte";
+"byte_unit_bytes" = "byte";
+"byte_unit_kilobyte" = "kilobyte";
+"byte_unit_kilobytes" = "kilobyte";
+"byte_unit_megabyte" = "megabyte";
+"byte_unit_megabytes" = "megabyte";
+"byte_unit_gigabyte" = "gigabyte";
+"byte_unit_gigabytes" = "gigabyte";
diff --git a/Sources/CodexBar/Resources/th.lproj/Localizable.strings b/Sources/CodexBar/Resources/th.lproj/Localizable.strings
new file mode 100644
index 0000000000..93057705c7
--- /dev/null
+++ b/Sources/CodexBar/Resources/th.lproj/Localizable.strings
@@ -0,0 +1,1110 @@
+/* Thai localization for CodexBar */
+
+" providers" = "ผู้ให้บริการ  ";
+"(System)" = "(ระบบ)";
+"30d" = "30 วัน";
+"A managed Codex login is already running. Wait for it to finish before adding " = "การเข้าสู่ระบบ Codex ที่มีการจัดการกําลังทํางานอยู่แล้ว รอให้เสร็จก่อนที่จะเพิ่ม  ";
+"API key" = "ปุ่ม API";
+"API region" = "ภูมิภาค API";
+"API token" = "โทเค็น API";
+"API tokens" = "โทเค็น API";
+"About" = "เกี่ยวกับ";
+"Account" = "บัญชี";
+"Accounts" = "บัญชี";
+"Accounts subtitle" = "คําบรรยายบัญชี";
+"Active" = "คล่องแคล่ว";
+"Add" = "เพิ่ม";
+"Add Workspace" = "เพิ่มพื้นที่ทํางาน";
+"Advanced" = "ขั้นสูง";
+"All" = "ทั้งหมด";
+"Always allow prompts" = "อนุญาตข้อความแจ้งเสมอ";
+"Animation pattern" = "รูปแบบแอนิเมชั่น";
+"Antigravity login is managed in the app" = "Antigravity เข้าสู่ระบบได้รับการจัดการในแอป";
+"Applies only to the Security.framework OAuth keychain reader." = "นําไปใช้กับโปรแกรมอ่านพวงกุญแจ Security.framework OAuth เท่านั้น";
+"Auto falls back to the next source if the preferred one fails." = "อัตโนมัติจะถอยกลับไปยังแหล่งที่มาถัดไปหากแหล่งที่ต้องการล้มเหลว";
+"Auto uses API first, then falls back to CLI on auth failures." = "อัตโนมัติใช้ API ก่อน จากนั้นจึงกลับไป CLI เมื่อการตรวจสอบสิทธิ์ล้มเหลว";
+"Auto-detect" = "ตรวจจับอัตโนมัติ";
+"Auto-refresh is off; use the menu's Refresh command." = "การรีเฟรชอัตโนมัติปิดอยู่ ใช้คําสั่งรีเฟรชของเมนู";
+"Auto-refresh: hourly · Timeout: 10m" = "รีเฟรชอัตโนมัติ: รายชั่วโมง · หมดเวลา: 10m";
+"Automatic" = "อัตโนมัติ";
+"Automatic imports browser cookies and WorkOS tokens." = "นําเข้าคุกกี้เบราว์เซอร์และโทเค็น WorkOS โดยอัตโนมัติ";
+"Automatic imports browser cookies and local storage tokens." = "นําเข้าคุกกี้เบราว์เซอร์และโทเค็นที่เก็บข้อมูลในเครื่องโดยอัตโนมัติ";
+"Automatic imports browser cookies for dashboard extras." = "นําเข้าคุกกี้เบราว์เซอร์โดยอัตโนมัติสําหรับส่วนเสริมของแดชบอร์ด";
+"Automatic imports browser cookies for the web API." = "นําเข้าคุกกี้เบราว์เซอร์สําหรับเว็บ API โดยอัตโนมัติ";
+"Automatic imports browser cookies from Model Studio/Bailian." = "นําเข้าคุกกี้เบราว์เซอร์โดยอัตโนมัติจาก Model Studio/Bailian.";
+"Automatic imports browser cookies from admin.mistral.ai." = "นําเข้าคุกกี้เบราว์เซอร์จาก admin.mistral.ai โดยอัตโนมัติ";
+"Automatic imports browser cookies from opencode.ai." = "นําเข้าคุกกี้เบราว์เซอร์จาก opencode.ai โดยอัตโนมัติ";
+"Automatic imports browser cookies or stored sessions." = "นําเข้าคุกกี้เบราว์เซอร์หรือเซสชันที่เก็บไว้โดยอัตโนมัติ";
+"Automatic imports browser cookies." = "นําเข้าคุกกี้เบราว์เซอร์โดยอัตโนมัติ";
+"Automatically imports browser session cookie." = "นําเข้าคุกกี้เซสชันเบราว์เซอร์โดยอัตโนมัติ";
+"Automatically opens CodexBar when you start your Mac." = "เปิด CodexBar โดยอัตโนมัติเมื่อคุณเริ่มต้นระบบ Mac";
+"Automation" = "ระบบอัตโนมัติ";
+"Average (\\(label1) + \\(label2))" = "เฉลี่ย (\\(label1) + \\(label2))";
+"Average (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))" = "เฉลี่ย (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))";
+"Avoid Keychain prompts" = "หลีกเลี่ยงข้อความแจ้ง Keychain";
+"Balance" = "สมดุล";
+"Battery Saver" = "ประหยัดแบตเตอรี่";
+"Bordered" = "มีพรมแดน";
+"Build" = "สร้าง";
+"Built \\(buildTimestamp)" = "สร้าง \\(buildTimestamp)";
+"Buy Credits..." = "ซื้อเครดิต...";
+"Buy Credits…" = "ซื้อเครดิต...";
+"CLI paths" = "เส้นทาง CLI";
+"CLI sessions" = "CLI เซสชัน";
+"Caches" = "แคช";
+"Cancel" = "ยกเลิก";
+"Check for Updates…" = "ตรวจสอบการอัปเดต...";
+"Check for updates automatically" = "ตรวจสอบการอัปเดตโดยอัตโนมัติ";
+"Check if you like your agents having some fun up there." = "ตรวจสอบว่าคุณชอบให้ตัวแทนของคุณสนุกสนานที่นั่นหรือไม่";
+"Check provider status" = "ตรวจสอบสถานะผู้ให้บริการ";
+"Choose Codex workspace" = "เลือกพื้นที่ทํางาน Codex";
+"Choose the MiniMax host (global .io or China mainland .com)." = "เลือกโฮสต์ MiniMax (.io ทั่วโลกหรือจีนแผ่นดินใหญ่ .com)";
+"Choose up to " = "เลือกได้ถึง  ";
+"Choose up to \\(Self.maxOverviewProviders) providers" = "เลือกผู้ให้บริการได้สูงสุด \\(Self.maxOverviewProviders) ราย";
+"Choose up to \\(count) providers" = "เลือกผู้ให้บริการได้สูงสุด \\(count) ราย";
+"Choose what to show in the menu bar (Pace shows usage vs. expected)." = "เลือกสิ่งที่จะแสดงในแถบเมนู (อัตราก้าวแสดงการใช้งานเทียบกับที่คาดไว้)";
+"Choose which Codex account CodexBar should follow." = "เลือกบัญชี Codex CodexBar ควรติดตาม";
+"Choose which window drives the menu bar percent." = "เลือกหน้าต่างที่จะขับเคลื่อนเปอร์เซ็นต์ของแถบเมนู";
+"Chrome" = "Chrome";
+"Claude CLI not found" = "ไม่พบ Claude CLI";
+"Claude binary" = "Claude ไบนารี";
+"Claude cookies" = "คุกกี้ Claude";
+"Claude login failed" = "การเข้าสู่ระบบ Claude ล้มเหลว";
+"Claude login timed out" = "Claude เข้าสู่ระบบหมดเวลา";
+"Close" = "ปิด";
+"Code review" = "การตรวจสอบโค้ด";
+"Codex CLI not found" = "ไม่พบ Codex CLI";
+"Codex account login already running" = "Codex การเข้าสู่ระบบบัญชีผู้ใช้ที่ทํางานอยู่แล้ว";
+"Codex binary" = "Codex ไบนารี";
+"Codex login failed" = "การเข้าสู่ระบบ Codex ล้มเหลว";
+"Codex login timed out" = "Codex เข้าสู่ระบบหมดเวลา";
+"CodexBar Lifecycle Keepalive" = "CodexBar วงจรชีวิต Keepalive";
+"CodexBar can't show its menu bar icon" = "CodexBar ไม่สามารถแสดงไอคอนแถบเมนูได้";
+"CodexBar could not read managed account storage. " = "CodexBar อ่านพื้นที่เก็บข้อมูลของบัญชีที่มีการจัดการไม่ได้  ";
+"Configure…" = "กําหนดค่า...";
+"Connected" = "เชื่อมต่อ";
+"Controls how much detail is logged." = "ควบคุมจํานวนรายละเอียดที่บันทึกไว้";
+"Cookie header" = "ส่วนหัวของคุกกี้";
+"Cookie source" = "แหล่งที่มาของคุกกี้";
+"Cookie: ..." = "คุกกี้: ...";
+"Cookie: \\u{2026}\\\n\\\nor paste a cURL capture from the Abacus AI dashboard" = "คุกกี้: \\u{2026}\\\n\\\n หรือวางการจับภาพ cURL จากแดชบอร์ด Abacus AI";
+"Cookie: \\u{2026}\\\n\\\nor paste the __Secure-next-auth.session-token value" = "คุกกี้: \\u{2026}\\\n\\\n หรือวางค่า __Secure-next-auth.session-token";
+"Cookie: \\u{2026}\\\n\\\nor paste the kimi-auth token value" = "คุกกี้: \\u{2026}\\\n\\\n หรือวางค่าโทเค็น kimi-auth";
+"Cookie: …" = "คุกกี้: ...";
+"CopilotDeviceFlow" = "โคไพลอตอุปกรณ์โฟลว์";
+"Cost" = "ราคา";
+"Could not add Codex account" = "ไม่สามารถเพิ่มบัญชี Codex ได้";
+"Could not open Terminal for Gemini" = "ไม่สามารถเปิดเทอร์มินัลสําหรับ Gemini";
+"Could not start claude /login" = "ไม่สามารถเริ่ม claude /login";
+"Could not start codex login" = "ไม่สามารถเริ่มการเข้าสู่ระบบ codex";
+"Could not switch system account" = "ไม่สามารถสลับบัญชีระบบได้";
+"Credits" = "เครดิต";
+"Individual credits" = "หน่วยกิตส่วนบุคคล";
+"Workspace" = "พื้นที่ทํางาน";
+"Credits history" = "ประวัติเครดิต";
+"Cursor login failed" = "การเข้าสู่ระบบ Cursor ล้มเหลว";
+"Custom" = "กําหนดเอง";
+"Custom Path" = "เส้นทางที่กําหนดเอง";
+"Daily Routines" = "กิจวัตรประจําวัน";
+"Debug" = "แก้ไขข้อบกพร่อง";
+"Default" = "ค่าเริ่มต้น";
+"Disable Keychain access" = "ปิดใช้งานการเข้าถึง Keychain";
+"Disabled" = "พิการ";
+"Dismiss" = "ปิด";
+"Disconnected" = "ตัดการเชื่อมต่อ";
+"Display" = "แสดง";
+"Display mode" = "โหมดการแสดงผล";
+"Display reset times as absolute clock values instead of countdowns." = "แสดงเวลารีเซ็ตเป็นค่านาฬิกาสัมบูรณ์แทนการนับถอยหลัง";
+"Done" = "เสร็จสิ้น";
+"Effective PATH" = "PATH ที่มีประสิทธิภาพ";
+"Email" = "อีเมล";
+"Enable Merge Icons to configure Overview tab providers." = "เปิดใช้งานไอคอนผสานเพื่อกําหนดค่าผู้ให้บริการแท็บภาพรวม";
+"Enable file logging" = "เปิดใช้งานการบันทึกไฟล์";
+"Enabled" = "เปิดใช้งาน";
+"Error" = "ข้อผิดพลาด";
+"Error simulation" = "การจําลองข้อผิดพลาด";
+"Expose troubleshooting tools in the Debug tab." = "แสดงเครื่องมือการแก้ไขปัญหาในแท็บ แก้ไขข้อบกพร่อง";
+"Failed" = "ล้มเหลว";
+"False" = "เท็จ";
+"Fetch strategy attempts" = "ความพยายามในการดึงกลยุทธ์";
+"Fetching" = "การดึงข้อมูล";
+"Field" = "ฟิลด์";
+"Field subtitle" = "คําบรรยายของฟิลด์";
+"Finish the current managed account change before switching the system account." = "เปลี่ยนบัญชีที่จัดการปัจจุบันให้เสร็จสิ้นก่อนเปลี่ยนบัญชีระบบ";
+"Force animation on next refresh" = "บังคับให้เคลื่อนไหวในการรีเฟรชครั้งถัดไป";
+"Gateway region" = "ภูมิภาคเกตเวย์";
+"Gemini CLI not found" = "ไม่พบ Gemini CLI";
+"Gemini/Antigravity, surfacing incidents in the icon and menu." = "Gemini/Antigravity แสดงเหตุการณ์ในไอคอนและเมนู";
+"General" = "ทั่วไป";
+"GitHub" = "GitHub";
+"GitHub Copilot Login" = "เข้าสู่ระบบ GitHub Copilot";
+"GitHub Login" = "เข้าสู่ระบบ GitHub";
+"Hide details" = "ซ่อนรายละเอียด";
+"Hide personal information" = "ซ่อนข้อมูลส่วนบุคคล";
+"Historical tracking" = "การติดตามในอดีต";
+"How often CodexBar polls providers in the background." = "ความถี่ในการ CodexBar ผู้ให้บริการโพลในเบื้องหลัง";
+"Inactive" = "ไม่ได้ใช้งาน";
+"Install CLI" = "ติดตั้ง CLI";
+"Install the Claude CLI (npm i -g @anthropic-ai/claude-code) and try again." = "ติดตั้ง Claude CLI (npm i -g @anthropic-ai/claude-code) แล้วลองอีกครั้ง";
+"Install the Codex CLI (npm i -g @openai/codex) and try again." = "ติดตั้ง Codex CLI (npm i -g @openai/codex) แล้วลองอีกครั้ง";
+"Install the Gemini CLI (npm i -g @google/gemini-cli) and try again." = "ติดตั้ง Gemini CLI (npm i -g @google/gemini-cli) แล้วลองอีกครั้ง";
+"JetBrains AI is ready" = "JetBrains AI พร้อมแล้ว";
+"JetBrains IDE" = "JetBrains IDE";
+"Keep CLI sessions alive" = "รักษาเซสชัน CLI ให้มีชีวิตอยู่";
+"Keyboard shortcut" = "แป้นพิมพ์ลัด";
+"Keychain access" = "การเข้าถึง Keychain";
+"Keychain prompt policy" = "นโยบายพร้อมท์ Keychain";
+"Last \\(name) fetch failed:" = "การดึงข้อมูล \\(name) ครั้งล่าสุดล้มเหลว:";
+"Last \\(self.store.metadata(for: self.provider).displayName) fetch failed:" = "การดึงข้อมูล Last \\(self.store.metadata(for: self.provider).displayName) ล้มเหลว:";
+"Last attempt" = "ความพยายามครั้งสุดท้าย";
+"Link" = "ลิงค์";
+"Loading animations" = "กําลังโหลดภาพเคลื่อนไหว";
+"Loading…" = "กําลังโหลด...";
+"Local" = "ท้องถิ่น";
+"Logging" = "การบันทึก";
+"Login failed" = "เข้าสู่ระบบล้มเหลว";
+"Login shell PATH (startup capture)" = "PATH เชลล์เข้าสู่ระบบ (การจับภาพการเริ่มต้น)";
+"Login timed out" = "หมดเวลาเข้าสู่ระบบ";
+"MCP details" = "รายละเอียด MCP";
+"Managed Codex accounts unavailable" = "บัญชี Codex ที่มีการจัดการไม่พร้อมใช้งาน";
+"Managed account storage is unreadable. Live account access is still available, " = "พื้นที่เก็บข้อมูลของบัญชีที่มีการจัดการไม่สามารถอ่านได้ การเข้าถึงบัญชีจริงยังคงมีอยู่  ";
+"Manual" = "ด้วยมือ";
+"May your tokens never run out—keep agent limits in view." = "ขอให้โทเค็นของคุณไม่มีวันหมด ให้คํานึงถึงขีดจํากัดของเจ้าหน้าที่";
+"Menu bar" = "แถบเมนู";
+"Menu bar auto-shows the provider closest to its rate limit." = "แถบเมนูจะแสดงผู้ให้บริการที่ใกล้เคียงกับขีดจํากัดอัตรามากที่สุดโดยอัตโนมัติ";
+"Menu bar metric" = "เมตริกแถบเมนู";
+"Menu bar shows percent" = "แถบเมนูแสดงเปอร์เซ็นต์";
+"Menu content" = "เนื้อหาเมนู";
+"Merge Icons" = "ผสานไอคอน";
+"Never prompt" = "ไม่เคยแจ้ง";
+"No" = "ไม่";
+"No Codex accounts detected yet." = "ยังไม่พบบัญชี Codex";
+"No JetBrains IDE detected" = "ไม่พบ JetBrains IDE";
+"No cost history data." = "ไม่มีข้อมูลประวัติค่าใช้จ่าย";
+"No data available" = "ไม่มีข้อมูล";
+"No data yet" = "ยังไม่มีข้อมูล";
+"No enabled providers available for Overview." = "ไม่มีผู้ให้บริการที่เปิดใช้งานสําหรับภาพรวม";
+"No providers selected" = "ไม่มีผู้ให้บริการที่เลือก";
+"No token accounts yet." = "ยังไม่มีบัญชีโทเค็น";
+"No usage breakdown data." = "ไม่มีข้อมูลรายละเอียดการใช้งาน";
+"None" = "ไม่มี";
+"Notifications" = "การแจ้งเตือน";
+"Notifies when the 5-hour session quota hits 0% and when it becomes " = "แจ้งเตือนเมื่อโควตาเซสชัน 5 ชั่วโมงเหลือ 0% และเมื่อกลับมา";
+"OK" = "ตกลง";
+"Obscure email addresses in the menu bar and menu UI." = "ปิดบังที่อยู่อีเมลในแถบเมนูและ UI เมนู";
+"Off" = "ปิด";
+"Offline" = "ออฟไลน์";
+"On" = "เปิด";
+"Online" = "ออนไลน์";
+"Only on user action" = "เฉพาะกับการกระทําของผู้ใช้";
+"Open" = "เปิด";
+"Open API Keys" = "เปิดปุ่ม API";
+"Open Amp Settings" = "เปิดการตั้งค่า Amp";
+"Open Antigravity to sign in, then refresh CodexBar." = "เปิด Antigravity เพื่อลงชื่อเข้าใช้ แล้วรีเฟรช CodexBar";
+"Open Browser" = "เปิดเบราว์เซอร์";
+"Open Coding Plan" = "เปิดแผนการเข้ารหัส";
+"Open Console" = "เปิดคอนโซล";
+"Open Dashboard" = "เปิดแดชบอร์ด";
+"Open Mistral Admin" = "เปิดผู้ดูแลระบบ Mistral";
+"Open Menu Bar Settings" = "เปิดการตั้งค่าแถบเมนู";
+"Open Ollama Settings" = "เปิดการตั้งค่า Ollama";
+"Open Terminal" = "เปิดเทอร์มินัล";
+"Open Usage Page" = "เปิดหน้าการใช้งาน";
+"Open Warp API Key Guide" = "เปิดคู่มือคีย์ Warp API";
+"Open menu" = "เปิดเมนู";
+"Open token file" = "เปิดไฟล์โทเค็น";
+"OpenAI cookies" = "คุกกี้ OpenAI";
+"OpenAI web extras" = "OpenAI ความพิเศษของเว็บ";
+"Option A" = "ตัวเลือก A";
+"Option B" = "ตัวเลือก B";
+"Optional override if workspace lookup fails." = "การแทนที่ทางเลือกหากการค้นหาพื้นที่ทํางานล้มเหลว";
+"Options" = "ตัวเลือก";
+"Override auto-detection with a custom IDE base path" = "แทนที่การตรวจหาอัตโนมัติด้วยเส้นทางพื้นฐาน IDE แบบกําหนดเอง";
+"Overview" = "ภาพรวม";
+"Overview rows always follow provider order." = "แถวภาพรวมจะเป็นไปตามลําดับของผู้ให้บริการเสมอ";
+"Overview tab providers" = "ผู้ให้บริการแท็บภาพรวม";
+"Paste API key…" = "วาง API คีย์...";
+"Paste API token…" = "วางโทเค็น API...";
+"Paste key…" = "แป้นวาง...";
+"Paste sessionKey or OAuth token…" = "วาง sessionKey หรือ OAuth token...";
+"Paste the Cookie header from a request to admin.mistral.ai. " = "วางส่วนหัวคุกกี้จากคําขอไปยัง admin.mistral.ai. ";
+"Paste token…" = "วางโทเค็น...";
+"Personal" = "ส่วนบุคคล";
+"Picker" = "หยิบ";
+"Picker subtitle" = "คําบรรยาย Picker";
+"Placeholder" = "ตัวยึดตําแหน่ง";
+"Plan" = "วางแผน";
+"Play full-screen confetti when weekly usage resets." = "เล่นลูกปาแบบเต็มหน้าจอเมื่อรีเซ็ตการใช้งานรายสัปดาห์";
+"Polls OpenAI/Claude status pages and Google Workspace for " = "โพล OpenAI/Claude หน้าสถานะและพื้นที่ทํางาน Google สําหรับ  ";
+"Prevents any Keychain access while enabled." = "ป้องกันการเข้าถึง Keychain ใดๆ ขณะเปิดใช้งาน";
+"Primary (API key limit)" = "หลัก (จํากัดคีย์ API)";
+"Primary (\\(label))" = "ประถมศึกษา (\\(label))";
+"Primary (\\(metadata.sessionLabel))" = "ประถมศึกษา (\\(metadata.sessionLabel))";
+"Probe logs" = "บันทึกโพรบ";
+"Progress bars fill as you consume quota (instead of showing remaining)." = "แถบความคืบหน้าจะเต็มเมื่อคุณใช้โควต้า (แทนที่จะแสดงปริมาณที่เหลืออยู่)";
+"Provider" = "ผู้ให้บริการ";
+"Providers" = "ผู้ให้บริการ";
+"Quit CodexBar" = "ออกจาก CodexBar";
+"Random (default)" = "สุ่ม (ค่าเริ่มต้น)";
+"Reads local usage logs. Shows today + last 30 days cost in the menu." = "อ่านบันทึกการใช้งานในเครื่อง แสดงวันนี้ + หน้าต่างประวัติที่เลือกในเมนู";
+"Refresh" = "รีเฟรช";
+"Refresh cadence" = "จังหวะการรีเฟรช";
+"Remote" = "ระยะไกล";
+"Remove" = "ลบ";
+"Remove Codex account?" = "ลบบัญชี Codex?";
+"Remove \\(account.email) from CodexBar? Its managed Codex home will be deleted." = "ลบ \\(account.email) ออกจาก CodexBar? ระบบจะลบหน้าแรก Codex ที่มีการจัดการ";
+"Remove \\(email) from CodexBar? Its managed Codex home will be deleted." = "ลบ \\(email) ออกจาก CodexBar? ระบบจะลบหน้าแรก Codex ที่มีการจัดการ";
+"Remove selected account" = "ลบบัญชีที่เลือก";
+"Replace critter bars with provider branding icons and a percentage." = "แทนที่แถบสัตว์ด้วยไอคอนการสร้างแบรนด์ของผู้ให้บริการและเปอร์เซ็นต์";
+"Replay selected animation" = "เล่นซ้ําภาพเคลื่อนไหวที่เลือก";
+"Requires authentication via GitHub Device Flow." = "ต้องมีการรับรองความถูกต้องผ่าน GitHub Device Flow";
+"Resets: \\(reset)" = "รีเซ็ต: \\(reset)";
+"Rolling five-hour limit" = "ขีด จํากัด ห้าชั่วโมง";
+"Search hourly" = "ค้นหารายชั่วโมง";
+"Secondary (\\(label))" = "รอง (\\(label))";
+"Secondary (\\(metadata.weeklyLabel))" = "รอง (\\(metadata.weeklyLabel))";
+"Select a provider" = "เลือกผู้ให้บริการ";
+"Select the IDE to monitor" = "เลือก IDE ที่จะตรวจสอบ";
+"Session quota notifications" = "การแจ้งเตือนโควต้าเซสชัน";
+"Session tokens" = "โทเค็นเซสชัน";
+"Settings" = "การตั้งค่า";
+"Show Codex Credits and Claude Extra usage sections in the menu." = "แสดงส่วนเครดิต Codex และการใช้งานเพิ่มเติม Claude ในเมนู";
+"Show Debug Settings" = "แสดงการตั้งค่าการดีบัก";
+"Show all token accounts" = "แสดงบัญชีโทเค็นทั้งหมด";
+"Show cost summary" = "แสดงสรุปค่าใช้จ่าย";
+"Show credits + extra usage" = "แสดงเครดิต + การใช้งานเพิ่มเติม";
+"Show details" = "แสดงรายละเอียด";
+"Show most-used provider" = "แสดงผู้ให้บริการที่ใช้บ่อยที่สุด";
+"Show provider icons in the switcher (otherwise show a weekly progress line)." = "แสดงไอคอนผู้ให้บริการในตัวสลับ (มิฉะนั้นให้แสดงรายการความคืบหน้ารายสัปดาห์)";
+"Show reset time as clock" = "แสดงเวลารีเซ็ตเป็นนาฬิกา";
+"Show usage as used" = "แสดงการใช้งานตามที่ใช้";
+"Sign in via button below" = "ลงชื่อเข้าใช้ผ่านปุ่มด้านล่าง";
+"Skip teardown between probes (debug-only)." = "ข้ามการฉีกขาดระหว่างโพรบ (ดีบักเท่านั้น)";
+"Stack token accounts in the menu (otherwise show an account switcher bar)." = "สแต็คบัญชีโทเค็นในเมนู (มิฉะนั้นจะแสดงแถบตัวสลับบัญชี)";
+"Start at Login" = "เริ่มต้นที่เข้าสู่ระบบ";
+"Status" = "สถานะ";
+"Store Claude sessionKey cookies or OAuth access tokens." = "จัดเก็บคุกกี้ sessionKey Claude หรือโทเค็นการเข้าถึง OAuth";
+"Store multiple Abacus AI Cookie headers." = "จัดเก็บส่วนหัว Abacus AI Cookie หลายรายการ";
+"Store multiple Augment Cookie headers." = "จัดเก็บส่วนหัว Augment Cookie หลายรายการ";
+"Store multiple Cursor Cookie headers." = "จัดเก็บส่วนหัว Cursor Cookie หลายรายการ";
+"Store multiple Factory Cookie headers." = "จัดเก็บส่วนหัว Factory Cookie หลายรายการ";
+"Store multiple MiniMax Cookie headers." = "จัดเก็บส่วนหัว MiniMax Cookie หลายรายการ";
+"Store multiple Mistral Cookie headers." = "จัดเก็บส่วนหัว Mistral Cookie หลายรายการ";
+"Store multiple Ollama Cookie headers." = "จัดเก็บส่วนหัว Ollama Cookie หลายรายการ";
+"Store multiple OpenCode Cookie headers." = "จัดเก็บส่วนหัว OpenCode Cookie หลายรายการ";
+"Store multiple OpenCode Go Cookie headers." = "จัดเก็บส่วนหัวคุกกี้ OpenCode Go หลายรายการ";
+"Stored in the CodexBar config file." = "เก็บไว้ในไฟล์กําหนดค่า CodexBar";
+"Stored in ~/.codexbar/config.json. " = "เก็บไว้ใน ~/.codexbar/config.json. ";
+"Stored in ~/.codexbar/config.json. Generate one at kimi-k2.ai." = "เก็บไว้ใน ~/.codexbar/config.json. สร้างที่ kimi-k2.ai";
+"Stored in ~/.codexbar/config.json. Paste the key from the Synthetic dashboard." = "เก็บไว้ใน ~/.codexbar/config.json. วางคีย์จากแดชบอร์ด Synthetic";
+"Stored in ~/.codexbar/config.json. Paste your Coding Plan API key from Model Studio." = "เก็บไว้ใน ~/.codexbar/config.json. วาง API คีย์แผนการเข้ารหัสของคุณจาก Model Studio";
+"Stored in ~/.codexbar/config.json. Paste your MiniMax API key." = "เก็บไว้ใน ~/.codexbar/config.json. วางคีย์ MiniMax API ของคุณ";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or " = "เก็บไว้ใน ~/.codexbar/config.json. คุณยังสามารถระบุ KILO_API_KEY or ";
+"Stores local Codex usage history (8 weeks) to personalize Pace predictions." = "จัดเก็บประวัติการใช้งาน Codex ในพื้นที่ (8 สัปดาห์) เพื่อปรับแต่งการคาดการณ์ Pace ในแบบของคุณ";
+"Subscription Utilization" = "การใช้การสมัครสมาชิก";
+"Surprise me" = "ทําให้ฉันประหลาดใจ";
+"Switcher shows icons" = "ตัวสลับแสดงไอคอน";
+"Symlink CodexBarCLI to /usr/local/bin and /opt/homebrew/bin as codexbar." = "Symlink CodexBarCLI เป็น /usr/local/bin และ /opt/homebrew/bin เป็น codexbar";
+"System" = "ระบบ";
+"Temporarily shows the loading animation after the next refresh." = "แสดงภาพเคลื่อนไหวการโหลดชั่วคราวหลังจากการรีเฟรชครั้งถัดไป";
+"terminal_app_subtitle" = "เทอร์มินัลที่ใช้โดยการดําเนินการ Open Terminal";
+"terminal_app_title" = "เทอร์มินัลเริ่มต้น";
+"Tertiary (\\(label))" = "ระดับอุดมศึกษา (\\(label))";
+"Tertiary (\\(tertiaryTitle))" = "ระดับอุดมศึกษา (\\(tertiaryTitle))";
+"The default Codex account on this Mac." = "บัญชี Codex เริ่มต้นบน Mac เครื่องนี้";
+"Toggle" = "สลับ";
+"Toggle subtitle" = "สลับคําบรรยาย";
+"Token" = "โทเค็น";
+"Trigger the menu bar menu from anywhere." = "ทริกเกอร์เมนูแถบเมนูได้จากทุกที่";
+"True" = "จริง";
+"Twitter" = "ทวิตเตอร์";
+"Unsupported" = "ไม่รองรับ";
+"Update Channel" = "อัปเดตช่อง";
+"Updated" = "อัพเดท";
+"Updates unavailable in this build." = "การอัปเดตไม่พร้อมใช้งานในรุ่นนี้";
+"Usage" = "การใช้";
+"Usage breakdown" = "รายละเอียดการใช้งาน";
+"Usage history (30 days)" = "ประวัติการใช้งาน";
+"Usage source" = "แหล่งที่มาของการใช้งาน";
+"Use BigModel for the China mainland endpoints (open.bigmodel.cn)." = "ใช้ BigModel สําหรับปลายทางจีนแผ่นดินใหญ่ (open.bigmodel.cn)";
+"Use a single menu bar icon with a provider switcher." = "ใช้ไอคอนแถบเมนูเดียวกับตัวสลับผู้ให้บริการ";
+"Use international or China mainland console gateways for quota fetches." = "ใช้เกตเวย์คอนโซลระหว่างประเทศหรือจีนแผ่นดินใหญ่สําหรับการดึงข้อมูลโควต้า";
+"Version" = "รุ่น";
+"Version \\(self.versionString)" = "เวอร์ชัน \\(self.versionString)";
+"Version \\(version)" = "เวอร์ชัน \\(version)";
+"Version \\(versionString)" = "เวอร์ชัน \\(versionString)";
+"Vertex AI Login" = "เข้าสู่ระบบ Vertex AI";
+"Wait for the current managed Codex login to finish before adding another account." = "รอให้การเข้าสู่ระบบ Codex ที่มีการจัดการปัจจุบันเสร็จสิ้นก่อนที่จะเพิ่มบัญชีอื่น";
+"Waiting for Authentication..." = "กําลังรอการรับรองความถูกต้อง...";
+"Website" = "เว็บไซต์";
+"Weekly limit confetti" = "ลูกปาจํากัดรายสัปดาห์";
+"Weekly token limit" = "ขีดจํากัดโทเค็นรายสัปดาห์";
+"Weekly usage" = "การใช้งานรายสัปดาห์";
+"Weekly usage unavailable for this account." = "การใช้งานรายสัปดาห์ไม่พร้อมใช้งานสําหรับบัญชีนี้";
+"Window: \\(window)" = "หน้าต่าง: \\(window)";
+"Write logs to \\(self.fileLogPath) for debugging." = "เขียนบันทึกไปยัง \\(self.fileLogPath) เพื่อแก้ไขข้อบกพร่อง";
+"Yes" = "ใช่";
+"\\(detail.modelCode): \\(usage)" = "\\(detail.modelCode): \\(usage)";
+"\\(name): \\(truncated)" = "\\(name): \\(truncated)";
+"\\(name): \\(updated) · 30d \\(cost)" = "\\(name): \\(updated) · 30d \\(cost)";
+"\\(name): fetching…\\(elapsed)" = "\\(name): กําลังดึง... \\(elapsed)";
+"\\(name): last attempt \\(when)" = "\\(name): ความพยายามครั้งสุดท้าย \\(when)";
+"\\(name): no data yet" = "\\(name): ยังไม่มีข้อมูล";
+"\\(name): unsupported" = "\\(name): ไม่รองรับ";
+"all browsers" = "เบราว์เซอร์ทั้งหมด";
+"available again." = "ใช้ได้อีกครั้ง";
+"built_format" = "สร้าง %@";
+"copilot_complete_in_browser" = "ลงชื่อเข้าใช้ในเบราว์เซอร์ให้เสร็จสมบูรณ์";
+"copilot_device_code" = "รหัสอุปกรณ์ที่คัดลอกไปยังคลิปบอร์ด: %1$@\n\n ดูได้ที่: %2$@";
+"copilot_device_code_copied" = "คัดลอกรหัสอุปกรณ์";
+"copilot_verify_at" = "ยืนยันที่ %@";
+"copilot_waiting_text" = "ลงชื่อเข้าใช้ในเบราว์เซอร์ให้เสร็จสมบูรณ์ \n หน้าต่างนี้จะปิดโดยอัตโนมัติเมื่อลงชื่อเข้าใช้เสร็จสมบูรณ์";
+"copilot_window_closes_auto" = "หน้าต่างนี้จะปิดโดยอัตโนมัติเมื่อการลงชื่อเข้าใช้เสร็จสมบูรณ์";
+"cost_status_error" = "%1$@: %2$@";
+"cost_status_fetching" = "%1$@: กําลังดึง... %2$@";
+"cost_status_last_attempt" = "%1$@: ความพยายามครั้งสุดท้าย %2$@";
+"cost_status_no_data" = "%@: ยังไม่มีข้อมูล";
+"cost_status_snapshot" = "%1$@: %2$@ · %3$@ %4$@";
+"cost_status_unsupported" = "%@: ไม่รองรับ";
+"credits_remaining" = "เครดิต: %@";
+"cursor_on_demand" = "ตามความต้องการ: %@";
+"cursor_on_demand_with_limit" = "ตามความต้องการ: %1$@ / %2$@";
+"extra_usage_format" = "การใช้งานเพิ่มเติม: %1$@ / %2$@";
+"jetbrains_detected_generate" = "ตรวจพบ: %@ ใช้ผู้ช่วย AI หนึ่งครั้งเพื่อสร้างข้อมูลโควต้า จากนั้นรีเฟรช CodexBar";
+"jetbrains_detected_select" = "ตรวจพบ: %@ เลือก IDE ที่คุณต้องการในการตั้งค่า จากนั้นรีเฟรช CodexBar";
+"last_fetch_failed_with_provider" = "การดึงข้อมูล %@ ครั้งล่าสุดล้มเหลว:";
+"last_spend" = "ใช้จ่ายครั้งล่าสุด: %@";
+"mcp_model_usage" = "%1$@: %2$@";
+"mcp_resets" = "รีเซ็ต: %@";
+"mcp_window" = "หน้าต่าง: %@";
+"metric_average" = "เฉลี่ย (%1$@ + %2$@)";
+"metric_primary" = "ประถมศึกษา (%@)";
+"metric_secondary" = "รอง (%@)";
+"metric_tertiary" = "ระดับอุดมศึกษา (%@)";
+"multiple_workspaces_found" = "CodexBar พบพื้นที่ทํางานหลายแห่งสําหรับ %@ โปรดเลือกพื้นที่ทํางานที่จะเพิ่ม";
+"ory_session_…=…; csrftoken=…" = "ory_session_...=...; csrftoken=...";
+"overview_choose_providers" = "เลือกผู้ให้บริการได้สูงสุด %@ ราย";
+"remove_account_message" = "ลบ %@ ออกจาก CodexBar? ระบบจะลบหน้าแรก Codex ที่มีการจัดการ";
+"version_format" = "เวอร์ชัน %@";
+"vertex_ai_login_instructions" = "หากต้องการติดตามการใช้งาน Vertex AI ให้ตรวจสอบสิทธิ์ด้วย Google Cloud.\n\n1 เปิดเทอร์มินัล \n2 เรียกใช้: gcloud auth application-default login\n3 ทําตามคําแนะนําของเบราว์เซอร์เพื่อลงชื่อเข้าใช้ \n4 ตั้งค่าโครงการของคุณ: gcloud config set project PROJECT_ID\n\nOpen Terminal ตอนนี้?";
+"workspaceID is set but only opencode, opencodego, and deepgram support workspaceID." = "มีการตั้งค่า workspaceID แต่รองรับ opencode, opencodego และ deepgram workspaceID เท่านั้น";
+"© 2026 Peter Steinberger. MIT License." = "© 2026 ปีเตอร์ สไตน์เบอร์เกอร์ ใบอนุญาต MIT";
+
+/* General Pane */
+"section_system" = "ระบบ";
+"section_usage" = "การใช้";
+"section_automation" = "ระบบอัตโนมัติ";
+"language_title" = "ภาษา";
+"language_subtitle" = "เปลี่ยนภาษาที่แสดง ต้องรีสตาร์ทแอปเพื่อให้มีผลเต็มที่";
+"language_system" = "ระบบ";
+"language_english" = "อังกฤษ";
+"language_spanish" = "Español";
+"language_catalan" = "คาตาลา";
+"language_chinese_simplified" = "简体中文";
+"language_chinese_traditional" = "繁體中文";
+"language_portuguese_brazilian" = "Português (บราซิล)";
+"language_dutch" = "เนเธอร์แลนด์";
+"language_german" = "เยอรมัน";
+"language_swedish" = "สเวนสกา";
+"language_french" = "ฝรั่งเศส";
+"language_ukrainian" = "Українська";
+"language_japanese" = "ภาษาญี่ปุ่น";
+"language_korean" = "เกาหลี";
+"language_turkish" = "Türkçe";
+"language_italian" = "อิตาเลียโน";
+"language_polish" = "Polski";
+"start_at_login_title" = "เริ่มต้นที่เข้าสู่ระบบ";
+"start_at_login_subtitle" = "เปิด CodexBar โดยอัตโนมัติเมื่อคุณเริ่มต้นระบบ Mac";
+"show_cost_summary" = "แสดงสรุปค่าใช้จ่าย";
+"show_cost_summary_subtitle" = "อ่านบันทึกการใช้งานในเครื่อง แสดงวันนี้ + หน้าต่างประวัติที่เลือกในเมนู";
+"cost_history_days_title" = "กรอบเวลาประวัติ: %d วัน";
+"cost_auto_refresh_info" = "รีเฟรชอัตโนมัติ: รายชั่วโมง · หมดเวลา: 10m";
+"refresh_cadence_title" = "จังหวะการรีเฟรช";
+"refresh_cadence_subtitle" = "ความถี่ในการ CodexBar ผู้ให้บริการโพลในเบื้องหลัง";
+"manual_refresh_hint" = "การรีเฟรชอัตโนมัติปิดอยู่ ใช้คําสั่งรีเฟรชของเมนู";
+"check_provider_status_title" = "ตรวจสอบสถานะผู้ให้บริการ";
+"check_provider_status_subtitle" = "โพล OpenAI/Claude หน้าสถานะและ Google Workspace for Gemini/Antigravity โดยแสดงเหตุการณ์ในไอคอนและเมนู";
+"session_quota_notifications_title" = "การแจ้งเตือนโควต้าเซสชัน";
+"session_quota_notifications_subtitle" = "แจ้งเตือนเมื่อโควตาเซสชัน 5 ชั่วโมงเหลือ 0% และเมื่อกลับมาใช้งานได้อีกครั้ง";
+"quota_warning_notifications_title" = "การแจ้งเตือนคําเตือนโควต้า";
+"quota_warning_notifications_subtitle" = "เตือนเมื่อเซสชันหรือโควต้ารายสัปดาห์ที่เหลืออยู่ข้ามเกณฑ์ที่กําหนดค่าไว้";
+"quota_warnings_title" = "คําเตือนโควต้า";
+"quota_warning_session" = "เซสชั่น";
+"quota_warning_session_capitalized" = "เซสชั่น";
+"quota_warning_weekly" = "รายสัปดาห์";
+"quota_warning_weekly_capitalized" = "รายสัปดาห์";
+"quota_warning_notification_title" = "โควตา%2$@ของ %1$@ ใกล้หมด";
+"quota_warning_notification_body" = "เหลือ %1$@ ถึงเกณฑ์การเตือน %2$d%% สำหรับโควตา%3$@แล้ว";
+"quota_warning_notification_body_with_account" = "บัญชี %1$@ เหลือ %2$@ ถึงเกณฑ์การเตือน %3$d%% สำหรับโควตา%4$@แล้ว";
+"session_depleted_notification_title" = "เซสชัน %@ หมดลง";
+"session_depleted_notification_body" = "เหลือ 0% จะแจ้งเตือนเมื่อกลับมาใช้งานได้อีกครั้ง";
+"session_restored_notification_title" = "%@ เซสชันที่กู้คืน";
+"session_restored_notification_body" = "โควต้าเซสชันพร้อมใช้งานอีกครั้ง";
+"quota_warning_warn_at" = "เตือนที่";
+"quota_warning_global_threshold_subtitle" = "เปอร์เซ็นต์ที่เหลืออยู่สําหรับกรอบเวลาเซสชันและรายสัปดาห์ เว้นแต่ผู้ให้บริการจะแทนที่";
+"quota_warning_sound" = "เล่นเสียงแจ้งเตือน";
+"quota_warning_provider_inherits" = "ใช้การตั้งค่าคําเตือนโควต้าส่วนกลาง เว้นแต่จะมีการกําหนดหน้าต่างเองที่นี่";
+"quota_warning_customize_thresholds" = "ปรับแต่งเกณฑ์ %@";
+"quota_warning_enable_warnings" = "เปิดใช้งานคําเตือน %@";
+"quota_warning_window_warn_at" = "%@ เตือนที่";
+"quota_warning_off" = "ปิด";
+"quota_warning_inherited" = "สืบทอด: %@";
+"quota_warning_depleted_only" = "หมดลงเท่านั้น";
+"quota_warning_upper" = "ด้านบน";
+"quota_warning_lower" = "ต่ํากว่า";
+"apply" = "สมัคร";
+"quit_app" = "ออกจาก CodexBar";
+
+/* Tab titles */
+"tab_general" = "ทั่วไป";
+"tab_providers" = "ผู้ให้บริการ";
+"tab_display" = "แสดง";
+"tab_advanced" = "ขั้นสูง";
+"tab_about" = "เกี่ยวกับ";
+"tab_debug" = "แก้ไขข้อบกพร่อง";
+
+/* Providers Pane */
+"select_a_provider" = "เลือกผู้ให้บริการ";
+"cancel" = "ยกเลิก";
+"last_fetch_failed" = "การดึงข้อมูลครั้งล่าสุดล้มเหลว";
+"usage_not_fetched_yet" = "ยังไม่ได้ดึงข้อมูลการใช้งาน";
+"managed_account_storage_unreadable" = "พื้นที่เก็บข้อมูลของบัญชีที่มีการจัดการไม่สามารถอ่านได้ สิทธิ์การเข้าถึงบัญชีจริงจะยังคงใช้งานได้ แต่การดําเนินการเพิ่มที่มีการจัดการ การตรวจสอบสิทธิ์อีกครั้ง และลบออกจะถูกปิดใช้งานจนกว่าร้านค้าจะกู้คืนได้";
+"remove_codex_account_title" = "ลบบัญชี Codex?";
+"remove" = "ลบ";
+"managed_login_already_running" = "การเข้าสู่ระบบ Codex ที่มีการจัดการกําลังทํางานอยู่แล้ว รอให้เสร็จสิ้นก่อนที่จะเพิ่มหรือตรวจสอบสิทธิ์บัญชีอื่นอีกครั้ง";
+"managed_login_failed" = "การเข้าสู่ระบบ Codex ที่มีการจัดการไม่เสร็จสมบูรณ์ ตรวจสอบว่า `codex --version` ใช้งานได้ในเทอร์มินัล หาก macOS บล็อกหรือย้าย `codex` ไปที่ถังขยะ ให้ลบการติดตั้งที่ซ้ํากันที่เก่า แล้วเรียกใช้ `npm install -g --include=optional @openai/codex@latest` แล้วลองอีกครั้ง";
+"codex_login_output" = "เอาต์พุตการเข้าสู่ระบบ Codex:";
+"managed_login_missing_email" = "Codex เข้าสู่ระบบเสร็จสมบูรณ์ แต่ไม่มีอีเมลบัญชีผู้ใช้ ลองอีกครั้งหลังจากยืนยันว่าบัญชีลงชื่อเข้าใช้อย่างสมบูรณ์แล้ว";
+"login_success_notification_title" = "%@ เข้าสู่ระบบสําเร็จ";
+"login_success_notification_body" = "คุณสามารถกลับไปที่แอพ การรับรองความถูกต้องเสร็จสิ้น";
+"workspace_selection_cancelled" = "CodexBar พบพื้นที่ทํางานหลายพื้นที่ แต่ไม่มีการเลือกพื้นที่ทํางาน";
+"unsafe_managed_home" = "CodexBar ปฏิเสธที่จะแก้ไขเส้นทางโฮมที่มีการจัดการที่ไม่คาดคิด: %@";
+"menu_bar_metric_title" = "เมตริกแถบเมนู";
+"menu_bar_metric_subtitle" = "เลือกหน้าต่างที่จะขับเคลื่อนเปอร์เซ็นต์ของแถบเมนู";
+"menu_bar_metric_subtitle_deepseek" = "แสดงยอดคงเหลือ DeepSeek ในแถบเมนู";
+"menu_bar_metric_subtitle_moonshot" = "แสดงยอดคงเหลือ Moonshot / Kimi API ในแถบเมนู";
+"menu_bar_metric_subtitle_mistral" = "แสดงการใช้จ่าย Mistral API เดือนปัจจุบันในแถบเมนู";
+"menu_bar_metric_subtitle_kimik2" = "แสดงเครดิต API คีย์ K2 Kimi ในแถบเมนู";
+"automatic" = "อัตโนมัติ";
+"primary_api_key_limit" = "หลัก (จํากัดคีย์ API)";
+
+/* Display Pane */
+"section_menu_bar" = "แถบเมนู";
+"merge_icons_title" = "ผสานไอคอน";
+"merge_icons_subtitle" = "ใช้ไอคอนแถบเมนูเดียวกับตัวสลับผู้ให้บริการ";
+"switcher_shows_icons_title" = "ตัวสลับแสดงไอคอน";
+"switcher_shows_icons_subtitle" = "แสดงไอคอนผู้ให้บริการในตัวสลับ (มิฉะนั้นให้แสดงรายการความคืบหน้ารายสัปดาห์)";
+"show_most_used_provider_title" = "แสดงผู้ให้บริการที่ใช้บ่อยที่สุด";
+"show_most_used_provider_subtitle" = "แถบเมนูจะแสดงผู้ให้บริการที่ใกล้เคียงกับขีดจํากัดอัตรามากที่สุดโดยอัตโนมัติ";
+"menu_bar_shows_percent_title" = "แถบเมนูแสดงเปอร์เซ็นต์";
+"menu_bar_shows_percent_subtitle" = "แทนที่แถบสัตว์ด้วยไอคอนการสร้างแบรนด์ของผู้ให้บริการและเปอร์เซ็นต์";
+"hide_critters_title" = "ซ่อนตัวการ์ตูน";
+"hide_critters_subtitle" = "แสดงแถบวัดแบบเรียบโดยไม่มีหน้าและการตกแต่ง";
+"display_mode_title" = "โหมดการแสดงผล";
+"display_mode_subtitle" = "เลือกสิ่งที่จะแสดงในแถบเมนู (อัตราก้าวแสดงการใช้งานเทียบกับที่คาดไว้)";
+"section_menu_content" = "เนื้อหาเมนู";
+"show_usage_as_used_title" = "แสดงการใช้งานตามที่ใช้";
+"show_usage_as_used_subtitle" = "แถบความคืบหน้าจะเต็มเมื่อคุณใช้โควต้า (แทนที่จะแสดงปริมาณที่เหลืออยู่)";
+"show_quota_warning_markers_title" = "แสดงเครื่องหมายเตือนโควต้า";
+"show_quota_warning_markers_subtitle" = "วาดเครื่องหมายถูกเกณฑ์บนแถบการใช้งานเมื่อมีการกําหนดค่าคําเตือนโควต้า";
+"weekly_progress_work_days_title" = "วันทํางานความคืบหน้ารายสัปดาห์";
+"weekly_progress_work_days_subtitle" = "กําหนดวันทํางานสําหรับเครื่องหมายแถบการใช้งานรายสัปดาห์และการคํานวณความเร็ว";
+"show_reset_time_as_clock_title" = "แสดงเวลารีเซ็ตเป็นนาฬิกา";
+"show_reset_time_as_clock_subtitle" = "แสดงเวลารีเซ็ตเป็นค่านาฬิกาสัมบูรณ์แทนการนับถอยหลัง";
+"show_provider_changelog_links_title" = "แสดงลิงก์บันทึกการเปลี่ยนแปลงของผู้ให้บริการ";
+"show_provider_changelog_links_subtitle" = "เพิ่มลิงก์บันทึกประจํารุ่นสําหรับผู้ให้บริการที่ได้รับการสนับสนุน CLI ในเมนู";
+"show_credits_extra_usage_title" = "แสดงเครดิต + การใช้งานเพิ่มเติม";
+"show_credits_extra_usage_subtitle" = "แสดงส่วนเครดิต Codex และการใช้งานเพิ่มเติม Claude ในเมนู";
+"show_all_token_accounts_title" = "แสดงบัญชีโทเค็นทั้งหมด";
+"show_all_token_accounts_subtitle" = "สแต็คบัญชีโทเค็นในเมนู (มิฉะนั้นจะแสดงแถบตัวสลับบัญชี)";
+"multi_account_layout_title" = "รูปแบบหลายบัญชี";
+"multi_account_layout_subtitle" = "เลือกการสลับบัญชีแบบแบ่งกลุ่มหรือบัตรบัญชีแบบเรียงซ้อน";
+"multi_account_layout_segmented" = "แบ่งกลุ่ม";
+"multi_account_layout_stacked" = "ซ้อนกัน";
+"overview_tab_providers_title" = "ผู้ให้บริการแท็บภาพรวม";
+"configure" = "กําหนดค่า...";
+"overview_enable_merge_icons_hint" = "เปิดใช้งานไอคอนผสานเพื่อกําหนดค่าผู้ให้บริการแท็บภาพรวม";
+"overview_no_providers_hint" = "ไม่มีผู้ให้บริการที่เปิดใช้งานสําหรับภาพรวม";
+"overview_rows_follow_order" = "แถวภาพรวมจะเป็นไปตามลําดับของผู้ให้บริการเสมอ";
+"overview_no_providers_selected" = "ไม่มีผู้ให้บริการที่เลือก";
+
+/* Advanced Pane */
+"section_keyboard_shortcut" = "แป้นพิมพ์ลัด";
+"open_menu_shortcut_title" = "เปิดเมนู";
+"open_menu_shortcut_subtitle" = "ทริกเกอร์เมนูแถบเมนูได้จากทุกที่";
+"install_cli" = "ติดตั้ง CLI";
+"install_cli_subtitle" = "Symlink CodexBarCLI เป็น /usr/local/bin และ /opt/homebrew/bin เป็น codexbar";
+"cli_not_found" = "ไม่พบ CodexBarCLI ใน App Bundle";
+"no_writable_bin_dirs" = "ไม่พบ bin dirs ที่เขียนได้";
+"show_debug_settings_title" = "แสดงการตั้งค่าการดีบัก";
+"show_debug_settings_subtitle" = "แสดงเครื่องมือการแก้ไขปัญหาในแท็บ แก้ไขข้อบกพร่อง";
+"surprise_me_title" = "ทําให้ฉันประหลาดใจ";
+"surprise_me_subtitle" = "ตรวจสอบว่าคุณชอบให้ตัวแทนของคุณสนุกสนานที่นั่นหรือไม่";
+"weekly_limit_confetti_title" = "ลูกปาจํากัดรายสัปดาห์";
+"weekly_limit_confetti_subtitle" = "เล่นลูกปาแบบเต็มหน้าจอเมื่อรีเซ็ตการใช้งานรายสัปดาห์";
+"hide_personal_info_title" = "ซ่อนข้อมูลส่วนบุคคล";
+"hide_personal_info_subtitle" = "ปิดบังที่อยู่อีเมลในแถบเมนูและ UI เมนู";
+"show_provider_storage_usage_title" = "แสดงการใช้พื้นที่เก็บข้อมูลของผู้ให้บริการ";
+"show_provider_storage_usage_subtitle" = "แสดงการใช้ดิสก์ในเครื่องในเมนู สแกนเส้นทางที่รู้จักโดยผู้ให้บริการในเบื้องหลัง";
+"section_keychain_access" = "การเข้าถึง Keychain";
+"keychain_access_caption" = "ปิดใช้งานการอ่านและเขียน Keychain ทั้งหมด ใช้ตัวเลือกนี้หาก macOS ยังคงแจ้งให้ 'Chrome/Brave/Edge ที่เก็บข้อมูลที่ปลอดภัย' แม้ว่าจะคลิกอนุญาตเสมอแล้วก็ตาม การนําเข้าคุกกี้ของเบราว์เซอร์ไม่พร้อมใช้งานในขณะที่เปิดใช้งาน วางส่วนหัวของคุกกี้ด้วยตนเองในผู้ให้บริการ Claude/Codex OAuth ผ่าน CLI ยังคงใช้งานได้";
+"disable_keychain_access_title" = "ปิดใช้งานการเข้าถึง Keychain";
+"disable_keychain_access_subtitle" = "ป้องกันการเข้าถึง Keychain ใดๆ ขณะเปิดใช้งาน";
+
+/* About Pane */
+"about_tagline" = "ขอให้โทเค็นของคุณไม่มีวันหมด ให้คํานึงถึงขีดจํากัดของเจ้าหน้าที่";
+"link_github" = "GitHub";
+"link_website" = "เว็บไซต์";
+"link_twitter" = "ทวิตเตอร์";
+"link_email" = "อีเมล";
+"check_updates_auto" = "ตรวจสอบการอัปเดตโดยอัตโนมัติ";
+"update_channel" = "อัปเดตช่อง";
+"check_for_updates" = "ตรวจสอบการอัปเดต...";
+"updates_unavailable" = "การอัปเดตไม่พร้อมใช้งานในรุ่นนี้";
+"copyright" = "© 2026 ปีเตอร์ สไตน์เบอร์เกอร์ ใบอนุญาต MIT";
+
+/* Debug Pane */
+"section_logging" = "การบันทึก";
+"enable_file_logging" = "เปิดใช้งานการบันทึกไฟล์";
+"enable_file_logging_subtitle" = "เขียนบันทึกไปยัง %@ เพื่อแก้ไขข้อบกพร่อง";
+"verbosity_title" = "รายละเอียด";
+"verbosity_subtitle" = "ควบคุมจํานวนรายละเอียดที่บันทึกไว้";
+"open_log_file" = "เปิดไฟล์บันทึก";
+"force_animation_next_refresh" = "บังคับให้เคลื่อนไหวในการรีเฟรชครั้งถัดไป";
+"force_animation_next_refresh_subtitle" = "แสดงภาพเคลื่อนไหวการโหลดชั่วคราวหลังจากการรีเฟรชครั้งถัดไป";
+"section_loading_animations" = "กําลังโหลดภาพเคลื่อนไหว";
+"loading_animations_caption" = "เลือกรูปแบบและเล่นซ้ําในแถบเมนู \"สุ่ม\" จะคงพฤติกรรมที่มีอยู่ไว้";
+"animation_random_default" = "สุ่ม (ค่าเริ่มต้น)";
+"replay_selected_animation" = "เล่นซ้ําภาพเคลื่อนไหวที่เลือก";
+"blink_now" = "กะพริบตาตอนนี้";
+"section_probe_logs" = "บันทึกโพรบ";
+"probe_logs_caption" = "ดึงเอาท์พุตโพรบล่าสุดสําหรับการดีบัก สําเนาเก็บข้อความฉบับเต็ม";
+"fetch_log" = "ดึงข้อมูลบันทึก";
+"copy" = "สําเนา";
+"save_to_file" = "บันทึกลงในไฟล์";
+"load_parse_dump" = "โหลดการถ่ายโอนข้อมูลแยกวิเคราะห์";
+"rerun_provider_autodetect" = "เรียกใช้การตรวจหาอัตโนมัติของผู้ให้บริการอีกครั้ง";
+"loading" = "กําลังโหลด...";
+"no_log_yet_fetch" = "ยังไม่มีบันทึก ดึงข้อมูลเพื่อโหลด";
+"section_fetch_strategy" = "ความพยายามในการดึงกลยุทธ์";
+"fetch_strategy_caption" = "การตัดสินใจและข้อผิดพลาดในการดึงข้อมูลไปป์ไลน์ล่าสุดสําหรับผู้ให้บริการ";
+"section_openai_cookies" = "คุกกี้ OpenAI";
+"openai_cookies_caption" = "การนําเข้าคุกกี้ + บันทึกการขูด WebKit จากความพยายามใช้คุกกี้ OpenAI ครั้งล่าสุด";
+"no_log_yet" = "ยังไม่มีบันทึก อัปเดตคุกกี้ OpenAI ในผู้ให้บริการ→ Codex เพื่อเรียกใช้การนําเข้า";
+"section_caches" = "แคช";
+"caches_caption" = "ล้างผลการสแกนค่าใช้จ่ายที่แคชไว้หรือแคชคุกกี้ของเบราว์เซอร์";
+"clear_cookie_cache" = "ล้างแคชคุกกี้";
+"clear_cost_cache" = "ล้างแคชต้นทุน";
+"section_notifications" = "การแจ้งเตือน";
+"notifications_caption" = "ทริกเกอร์การแจ้งเตือนการทดสอบสําหรับกรอบเวลาเซสชัน 5 ชั่วโมง (หมด /restored)";
+"post_depleted" = "โพสต์หมด";
+"post_restored" = "โพสต์ที่ได้รับการกู้คืน";
+"section_cli_sessions" = "CLI เซสชัน";
+"cli_sessions_caption" = "รักษาเซสชัน Codex/Claude CLI ให้มีชีวิตอยู่หลังจากการสอบสวน ค่าเริ่มต้นจะออกเมื่อบันทึกข้อมูลแล้ว";
+"keep_cli_sessions_alive" = "รักษาเซสชัน CLI ให้มีชีวิตอยู่";
+"keep_cli_sessions_alive_subtitle" = "ข้ามการฉีกขาดระหว่างโพรบ (ดีบักเท่านั้น)";
+"reset_cli_sessions" = "รีเซ็ตเซสชัน CLI";
+"section_error_simulation" = "การจําลองข้อผิดพลาด";
+"error_simulation_caption" = "แทรกข้อความแสดงข้อผิดพลาดปลอมลงในการ์ดเมนูสําหรับการทดสอบเลย์เอาต์";
+"set_menu_error" = "ตั้งค่าเมนูผิดพลาด";
+"clear_menu_error" = "ล้างข้อผิดพลาดของเมนู";
+"set_cost_error" = "ตั้งค่าข้อผิดพลาดต้นทุน";
+"clear_cost_error" = "ล้างข้อผิดพลาดด้านต้นทุน";
+"section_cli_paths" = "เส้นทาง CLI";
+"cli_paths_caption" = "แก้ไข Codex ชั้นไบนารีและเลเยอร์ PATH การเข้าสู่ระบบเริ่มต้น PATH จับภาพ (หมดเวลาสั้น)";
+"codex_binary" = "Codex ไบนารี";
+"claude_binary" = "Claude ไบนารี";
+"effective_path" = "PATH ที่มีประสิทธิภาพ";
+"unavailable" = "ไม่พร้อมใช้งาน";
+"login_shell_path" = "PATH เชลล์เข้าสู่ระบบ (การจับภาพการเริ่มต้น)";
+"cleared" = "เคลียร์แล้ว";
+"no_fetch_attempts" = "ยังไม่มีความพยายามในการดึงข้อมูล";
+"macOS Tahoe can block menu bar apps in System Settings → Menu Bar → Allow in the Menu Bar. CodexBar is running, but macOS may be hiding its icon. Open Menu Bar settings and turn CodexBar on." = "macOS Tahoe สามารถบล็อกแอปแถบเมนูในการตั้งค่าระบบ→แถบเมนู→อนุญาตในแถบเมนู CodexBar กําลังทํางานอยู่ แต่ macOS อาจซ่อนไอคอนไว้ เปิดการตั้งค่าแถบเมนู แล้วเปิด CodexBar";
+
+/* Metric preferences */
+"metric_pref_automatic" = "อัตโนมัติ";
+"metric_pref_primary" = "ประถมศึกษา";
+"metric_pref_secondary" = "มัธยมศึกษา";
+"metric_pref_tertiary" = "ระดับอุดมศึกษา";
+"metric_pref_extra_usage" = "การใช้งานเพิ่มเติม";
+"metric_pref_average" = "ค่าเฉลี่ย";
+"metric_mistral_payg" = "Pay-as-you-go";
+"metric_mistral_monthly_plan" = "Monthly Plan";
+
+/* Display modes */
+"display_mode_percent" = "เปอร์เซ็นต์";
+"display_mode_pace" = "ก้าว";
+"display_mode_both" = "ทั้งสองอย่าง";
+"display_mode_reset_time" = "รีเซ็ตเวลา";
+"display_mode_percent_desc" = "แสดงเปอร์เซ็นต์ที่เหลือ /used (เช่น 45%)";
+"display_mode_pace_desc" = "แสดงตัวบ่งชี้อัตราการก้าว (เช่น +5%)";
+"display_mode_both_desc" = "แสดงทั้งเปอร์เซ็นต์และความเร็ว (เช่น 45% · +5%)";
+"display_mode_reset_time_desc" = "แสดงเวลารีเซ็ตสําหรับเมตริกที่เลือก (เช่น ↻ 15:56 น.)";
+
+/* Provider status */
+"status_operational" = "การดําเนินงาน";
+"status_partial_outage" = "ไฟฟ้าดับบางส่วน";
+"status_major_outage" = "ไฟฟ้าดับครั้งใหญ่";
+"status_critical_issue" = "ปัญหาสําคัญ";
+"status_maintenance" = "ซ่อมบํารุง";
+"status_unknown" = "ไม่ทราบสถานะ";
+
+/* Refresh frequency */
+"refresh_manual" = "ด้วยมือ";
+"refresh_1min" = "1 นาที";
+"refresh_2min" = "2 นาที";
+"refresh_5min" = "5 นาที";
+"refresh_15min" = "15 นาที";
+"refresh_30min" = "30 นาที";
+
+/* Additional keys */
+"not_found" = "ไม่พบ";
+
+/* Cost estimation */
+"cost_header_estimated" = "ต้นทุน (โดยประมาณ)";
+"cost_estimate_hint" = "ประมาณการจากบันทึกท้องถิ่น · อาจแตกต่างจากใบเรียกเก็บเงินของคุณ";
+"No JetBrains IDE with AI Assistant detected. Install a JetBrains IDE and enable AI Assistant." = "ตรวจไม่พบ JetBrains IDE ที่มี AI Assistant ติดตั้ง JetBrains IDE และเปิดใช้งาน AI Assistant";
+"OpenRouter API token not configured. Set OPENROUTER_API_KEY environment variable or configure in Settings." = "โทเค็น OpenRouter API ไม่ได้กําหนดค่า ตั้งค่าตัวแปรสภาพแวดล้อม OPENROUTER_API_KEY หรือกําหนดค่าในการตั้งค่า";
+"z.ai API token not found. Set apiKey in ~/.codexbar/config.json or Z_AI_API_KEY." = "ไม่พบโทเค็น z.ai API ตั้งค่า apiKey เป็น ~/.codexbar/config.json หรือ Z_AI_API_KEY";
+"Missing DeepSeek API key." = "ไม่มีคีย์ DeepSeek API";
+"%@ is unavailable in the current environment." = "%@ ไม่พร้อมใช้งานในสภาพแวดล้อมปัจจุบัน";
+"All Systems Operational" = "ทุกระบบทํางาน";
+"Last 30 days" = "30 วันที่ผ่านมา";
+"Last 30 days:" = "30 วันที่ผ่านมา:";
+"This month" = "เดือนนี้";
+"Store multiple OpenAI API keys." = "จัดเก็บปุ่ม OpenAI API หลายปุ่ม";
+"Admin API key" = "คีย์ API ของผู้ดูแลระบบ";
+"Open billing" = "การเรียกเก็บเงินแบบเปิด";
+"Google accounts" = "บัญชี Google";
+"Store multiple Antigravity Google OAuth accounts for quick switching." = "จัดเก็บบัญชี Antigravity Google OAuth หลายบัญชีเพื่อการสลับอย่างรวดเร็ว";
+"Add Google Account" = "เพิ่มบัญชี Google";
+"Open Token Plan" = "เปิดแผนโทเค็น";
+"Text Generation" = "การสร้างข้อความ";
+"Text to Speech" = "ข้อความเป็นคําพูด";
+"Music Generation" = "การสร้างเพลง";
+"Image Generation" = "การสร้างภาพ";
+"No local data found" = "ไม่พบข้อมูลในเครื่อง";
+"Credits unavailable; keep Codex running to refresh." = "ไม่มีเครดิต Codex ทํางานต่อไปเพื่อรีเฟรช";
+"No available fetch strategy for minimax." = "ไม่มีกลยุทธ์การดึงข้อมูลสําหรับ minimax";
+"No Cursor session found. Please log in to cursor.com in Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX, or Edge Canary. If you use Safari, grant CodexBar Full Disk Access in System Settings ▸ Privacy & Security. You can also sign in to Cursor from the CodexBar menu (Add / switch account)." = "ไม่พบเซสชัน Cursor โปรดเข้าสู่ระบบ cursor.com ใน Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX หรือ Edge Canary หากคุณใช้ Safari ให้สิทธิ์การเข้าถึงดิสก์แบบเต็ม CodexBar ใน การตั้งค่าระบบ ▸ ความเป็นส่วนตัวและความปลอดภัย คุณยังสามารถลงชื่อเข้าใช้ Cursor ได้จากเมนู CodexBar (เพิ่ม / สลับบัญชี)";
+"No OpenCode session cookies found in browsers." = "ไม่พบคุกกี้เซสชัน OpenCode ในเบราว์เซอร์";
+"No available fetch strategy for %@." = "ไม่มีกลยุทธ์การดึงข้อมูลสําหรับ %@";
+"Today" = "วันนี้";
+"Today tokens" = "โทเค็นวันนี้";
+"30d cost" = "ค่าใช้จ่าย 30d";
+"30d tokens" = "โทเค็น 30d";
+"Latest tokens" = "โทเค็นล่าสุด";
+"Top model" = "รุ่นยอดนิยม";
+"Storage" = "ค่าเช่าคลัง";
+"Add Account..." = "เพิ่มบัญชี...";
+"Usage Dashboard" = "แดชบอร์ดการใช้งาน";
+"Status Page" = "หน้าสถานะ";
+"Settings..." = "การตั้งค่า...";
+"About CodexBar" = "เกี่ยวกับ CodexBar";
+"Quit" = "ออก";
+"Last %d day" = "%d วันที่ผ่านมา";
+"Last %d days" = "%d วันที่ผ่านมา";
+"%@ tokens" = "โทเค็น %@";
+"Latest billing day" = "วันเรียกเก็บเงินล่าสุด";
+"Latest billing day (%@)" = "วันเรียกเก็บเงินล่าสุด (%@)";
+"%@ left" = "เหลือ %@";
+"Resets %@" = "รีเซ็ต %@";
+"Resets in %@" = "รีเซ็ตใน %@";
+"Resets now" = "รีเซ็ตเดี๋ยวนี้";
+"reset_tomorrow_format" = "พรุ่งนี้ %@";
+"Lasts until reset" = "คงอยู่จนกว่าจะรีเซ็ต";
+"Updated %@" = "อัพเดท %@";
+"Updated %@h ago" = "อัพเดท %@h ที่ผ่านมา";
+"Updated %@m ago" = "อัพเดท %@m ที่ผ่านมา";
+"Updated just now" = "อัปเดตเมื่อเร็ว ๆ นี้";
+"Projected empty in %@" = "คาดการณ์ว่างเปล่าเป็น %@";
+"Runs out in %@" = "หมดใน %@";
+"Pace: %@" = "ก้าว: %@";
+"Pace: %@ · %@" = "เพซ: %@ · %@";
+"%@ · %@" = "%@ · %@";
+"≈ %d%% run-out risk" = "≈ %d%% ความเสี่ยงในการหมด";
+"%d%% in deficit" = "%d%% ขาดดุล";
+"%d%% in reserve" = "%d%% สํารอง";
+"usage_percent_suffix_left" = "คงเหลือ";
+"usage_percent_suffix_used" = "ใช้แล้ว";
+"Store multiple DeepSeek API keys." = "จัดเก็บปุ่ม DeepSeek API หลายปุ่ม";
+"This week" = "สัปดาห์นี้";
+"Week" = "สัปดาห์";
+"Month" = "เดือน";
+"Models" = "โมเดล";
+"24h tokens" = "โทเค็น 24h";
+"Latest hour" = "ชั่วโมงล่าสุด";
+"Peak hour" = "ชั่วโมงเร่งด่วน";
+"Top method" = "วิธียอดนิยม";
+"30d cash" = "30d เงินสด";
+"30d billing history from MiniMax web session" = "30d ประวัติการเรียกเก็บเงินจากเซสชันเว็บ MiniMax";
+"AWS Cost Explorer billing can lag." = "AWS การเรียกเก็บเงิน Cost Explorer อาจล่าช้า";
+"Rate limit: %d / %@" = "จํากัดอัตรา: %d / %@";
+"Key remaining" = "กุญแจที่เหลืออยู่";
+"No limit set for the API key" = "ไม่มีขีดจํากัดสําหรับปุ่ม API";
+"API key limit unavailable right now" = "ขีดจํากัดคีย์ API ไม่พร้อมใช้งานในขณะนี้";
+"This month: %@ tokens" = "เดือนนี้: %@ โทเค็น";
+"No utilization data yet." = "ยังไม่มีข้อมูลการใช้งาน";
+"No %@ utilization data yet." = "ยังไม่มีข้อมูลการใช้ %@";
+"%@: %@%% used" = "%@: %@%% ใช้";
+"%dd" = "%d วัน";
+"today" = "วันนี้";
+"just now" = "เพิ่ง";
+"On pace" = "ก้าวไปข้างหน้า";
+"Runs out now" = "หมดแล้ว";
+"Projected empty now" = "คาดการณ์ว่างเปล่าในขณะนี้";
+"Switch Account..." = "สลับบัญชี...";
+"Update ready, restart now?" = "อัปเดตพร้อมแล้วรีสตาร์ททันทีใช่ไหม";
+"Daily" = "รายวัน";
+"Hourly Tokens" = "โทเค็นรายชั่วโมง";
+"No data" = "ไม่มีข้อมูล";
+"No usage breakdown data available." = "ไม่มีข้อมูลรายละเอียดการใช้งาน";
+
+"Today: %@ · %@ tokens" = "วันนี้: %@ · 2 min · 2 min · ฟาร์ฮาน โทเค็น %@";
+"Today: %@" = "วันนี้: %@";
+"Today: %@ tokens" = "วันนี้: โทเค็น %@";
+"Last 30 days: %@ · %@ tokens" = "30 วันที่ผ่านมา: %@ · 2 min · โทเค็น %@";
+"Last 30 days: %@" = "30 วันที่ผ่านมา: %@";
+"Est. total (30d): %@" = "รวมโดยประมาณ (30d): %@";
+"Est. total (%@): %@" = "รวมโดยประมาณ (%@): %@";
+"Hover a bar for details" = "วางเมาส์เหนือแถบเพื่อดูรายละเอียด";
+"%@: %@ · %@ tokens" = "%@: %@ · โทเค็น %@";
+"No providers selected for Overview." = "ไม่มีผู้ให้บริการที่เลือกสําหรับภาพรวม";
+"No overview data available." = "ไม่มีข้อมูลภาพรวม";
+"Auto uses the local IDE API first, then Google OAuth when the IDE is closed." = "อัตโนมัติจะใช้ IDE API ภายในเครื่องก่อน จากนั้นจึง Google OAuth เมื่อปิด IDE";
+"Login with Google" = "เข้าสู่ระบบด้วย Google";
+
+/* Popup panels */
+"No usage configured." = "ไม่มีการกําหนดค่าการใช้งาน";
+"Quota" = "โควต้า";
+"tokens" = "โทเค็น";
+"requests" = "คําขอ";
+"Latest" = "ล่าสุด";
+"Monthly" = "รายเดือน";
+"Sonnet" = "โคลง";
+"Overages" = "ส่วนเกิน";
+"Activity" = "กิจกรรม";
+"Copied" = "คัดลอกแล้ว";
+"Copy error" = "ข้อผิดพลาดในการคัดลอก";
+"Copy path" = "คัดลอกเส้นทาง";
+"Extra usage spent" = "การใช้จ่ายเพิ่มเติม";
+"Credits remaining" = "เครดิตที่เหลืออยู่";
+"Using CLI fallback" = "การใช้ CLI สํารอง";
+"Balance updates in near-real time (up to 5 min lag)" = "อัปเดตเครื่องชั่งแบบเกือบเรียลไทม์ (หน่วงสูงสุด 5 นาที)";
+"Daily billing data finalizes at 07:00 UTC" = "ข้อมูลการเรียกเก็บเงินรายวันจะสรุปเวลา 07:00 น. UTC";
+"%@ of %@ credits left" = "เหลือ %@ จาก %@ หน่วยกิต";
+"%@ of %@ bonus credits left" = "%@ จาก %@ เครดิตโบนัสที่เหลืออยู่";
+"%@ / %@ (%@ remaining)" = "%@ / %@ (เหลือ %@)";
+"%@/%@ left" = "เหลือ %@/%@";
+"Gemini Flash" = "แฟลช Gemini";
+"Regenerates %@" = "ฟื้นฟู %@";
+"used after next regen" = "ใช้หลังจากการฟื้นฟูครั้งต่อไป";
+"after next regen" = "หลังจากการฟื้นฟูครั้งต่อไป";
+"Near full" = "ใกล้เต็ม";
+"Full in ~1 regen" = "เต็มที่ ~1 รีเจน";
+"Full in ~%.0f regens" = "เต็มไปด้วยการฟื้นฟู ~%.0f ครั้ง";
+"Overage usage" = "การใช้งานส่วนเกิน";
+"Overage cost" = "ค่าใช้จ่ายส่วนเกิน";
+"credits" = "เครดิต";
+"Zen balance" = "ความสมดุลแบบเซน";
+"API spend" = "API ใช้จ่าย";
+"Extra usage" = "การใช้งานเพิ่มเติม";
+"Quota usage" = "การใช้โควต้า";
+"Your spend" = "การใช้จ่ายของคุณ";
+"%.0f%% used" = "%.0f%% ใช้แล้ว";
+"Usage history (today)" = "ประวัติการใช้งาน (วันนี้)";
+"Usage history (%d days)" = "ประวัติการใช้งาน (%d วัน)";
+"%d percent remaining" = "เหลือ %d เปอร์เซ็นต์";
+"Unknown" = "ไม่ทราบ";
+"stale data" = "ข้อมูลเก่า";
+"No credits history data." = "ไม่มีข้อมูลประวัติเครดิต";
+"No credits history data available." = "ไม่มีข้อมูลประวัติเครดิต";
+"Credits history chart" = "แผนภูมิประวัติเครดิต";
+"%d days of credits data" = "ข้อมูลเครดิต %d วัน";
+"Usage breakdown chart" = "แผนภูมิการแจกแจงการใช้งาน";
+"%d days of usage data across %d services" = "ข้อมูลการใช้งาน %d วันในบริการ %d";
+"Cost history chart" = "แผนภูมิประวัติต้นทุน";
+"%d days of cost data" = "ข้อมูลค่าใช้จ่าย %d วัน";
+"Plan utilization chart" = "แผนการใช้แผน";
+"%d utilization samples" = "ตัวอย่างการใช้ประโยชน์ %d";
+"Hourly Usage" = "การใช้งานรายชั่วโมง";
+"Usage remaining" = "การใช้งานที่เหลืออยู่";
+"Usage used" = "การใช้งานที่ใช้";
+"API key verified. Ollama does not expose Cloud quota limits through the API." = "API คีย์ที่ตรวจสอบแล้ว Ollama ไม่เปิดเผยขีดจํากัดโควต้าระบบคลาวด์ผ่าน API";
+"Last 30 days: %@ tokens" = "30 วันที่ผ่านมา: %@ โทเค็น";
+"7d spend" = "7d ใช้จ่าย";
+"30d spend" = "30d ใช้จ่าย";
+"Cache read" = "การอ่านแคช";
+"Claude Admin API 30 day spend trend" = "Claude Admin API เทรนด์การใช้จ่าย 30 วัน";
+"OpenRouter API key spend trend" = "OpenRouter API แนวโน้มการใช้จ่ายหลัก";
+"z.ai hourly token trend" = "z.ai แนวโน้มโทเค็นรายชั่วโมง";
+"MiniMax 30 day token usage trend" = "MiniMax แนวโน้มการใช้โทเค็น 30 วัน";
+"Today cash" = "เงินสดวันนี้";
+"DeepSeek 30 day token usage trend" = "DeepSeek แนวโน้มการใช้โทเค็น 30 วัน";
+"cache-hit input" = "อินพุต cache-hit";
+"cache-miss input" = "อินพุตแคชพลาด";
+"output" = "เอาท์พุท";
+"Requests" = "คําขอ";
+"Reported by OpenAI Admin API organization usage." = "รายงานโดยผู้ดูแลระบบ OpenAI API การใช้งานองค์กร";
+"Reported by Mistral billing usage." = "รายงานโดย Mistral การเรียกเก็บเงิน";
+"Google OAuth" = "Google OAuth";
+"Add accounts via GitHub OAuth Device Flow on the selected host." = "เพิ่มบัญชีผ่าน GitHub OAuth Device Flow บนโฮสต์ที่เลือก";
+"Stores each signed-in Google account for quick Antigravity switching. Uses Antigravity.app OAuth when available, or ANTIGRAVITY_OAUTH_CLIENT_ID and ANTIGRAVITY_OAUTH_CLIENT_SECRET as an override." = "จัดเก็บบัญชี Google ที่ลงชื่อเข้าใช้แต่ละบัญชีเพื่อการสลับ Antigravity อย่างรวดเร็ว ใช้ Antigravity.app OAuth เมื่อพร้อมใช้งาน หรือ ANTIGRAVITY_OAUTH_CLIENT_ID และ ANTIGRAVITY_OAUTH_CLIENT_SECRET เป็นการแทนที่";
+"Manual cleanup: past sessions" = "การล้างข้อมูลด้วยตนเอง: เซสชันที่ผ่านมา";
+"Clearing removes past resume, continue, and rewind history." = "การล้างข้อมูลจะลบประวัติการทํางานต่อ ดําเนินการต่อ และย้อนกลับในอดีต";
+"Manual cleanup: file checkpoints" = "การล้างข้อมูลด้วยตนเอง: จุดตรวจสอบไฟล์";
+"Clearing removes checkpoint restore data for previous edits." = "การล้างจะลบข้อมูลการคืนค่าจุดตรวจสําหรับการแก้ไขก่อนหน้านี้";
+"Manual cleanup: saved plans" = "การล้างข้อมูลด้วยตนเอง: แผนที่บันทึกไว้";
+"Clearing removes old plan-mode files." = "การล้างจะลบไฟล์โหมดแผนเก่า";
+"Manual cleanup: debug logs" = "การล้างข้อมูลด้วยตนเอง: บันทึกการดีบัก";
+"Clearing removes past debug logs." = "การล้างจะลบบันทึกการแก้ไขข้อบกพร่องที่ผ่านมา";
+"Manual cleanup: attachment cache" = "การล้างข้อมูลด้วยตนเอง: แคชไฟล์แนบ";
+"Clearing removes cached large pastes or attached images." = "การล้างจะลบแปะขนาดใหญ่ที่แคชไว้หรือรูปภาพที่แนบมา";
+"Manual cleanup: session metadata" = "การล้างข้อมูลด้วยตนเอง: ข้อมูลเมตาของเซสชัน";
+"Clearing removes per-session environment metadata." = "การล้างข้อมูลจะลบข้อมูลเมตาของสภาพแวดล้อมต่อเซสชัน";
+"Manual cleanup: shell snapshots" = "การล้างข้อมูลด้วยตนเอง: สแนปช็อตเปลือกหอย";
+"Clearing removes leftover runtime shell snapshot files." = "การล้างจะลบไฟล์สแนปช็อตเชลล์รันไทม์ที่เหลืออยู่";
+"Manual cleanup: legacy todos" = "การล้างข้อมูลด้วยตนเอง: สิ่งที่ต้องทําแบบเดิม";
+"Clearing removes legacy per-session task lists." = "การล้างจะลบรายการงานต่อเซสชันเดิม";
+"Manual cleanup: sessions" = "การล้างข้อมูลด้วยตนเอง: เซสชัน";
+"Clearing removes past Codex session history." = "การล้างจะลบประวัติเซสชัน Codex ที่ผ่านมา";
+"Manual cleanup: archived sessions" = "การล้างข้อมูลด้วยตนเอง: เซสชันที่เก็บถาวร";
+"Clearing removes archived Codex session history." = "การล้างข้อมูลจะลบประวัติเซสชัน Codex ที่เก็บถาวรออก";
+"Manual cleanup: cache" = "การล้างข้อมูลด้วยตนเอง: แคช";
+"Clearing removes provider-owned cached data." = "การล้างข้อมูลจะลบข้อมูลแคชที่ผู้ให้บริการเป็นเจ้าของ";
+"Manual cleanup: logs" = "การล้างข้อมูลด้วยตนเอง: บันทึก";
+"Clearing removes local diagnostic logs." = "การล้างข้อมูลจะลบบันทึกการวินิจฉัยในเครื่อง";
+"Manual cleanup: file history" = "การล้างข้อมูลด้วยตนเอง: ประวัติไฟล์";
+"Clearing removes local edit checkpoint history." = "การล้างจะลบประวัติจุดตรวจสอบการแก้ไขในเครื่อง";
+"Manual cleanup: temporary data" = "การล้างข้อมูลด้วยตนเอง: ข้อมูลชั่วคราว";
+"Clearing removes local temporary provider data." = "การหักล้างจะลบข้อมูลผู้ให้บริการชั่วคราวในเครื่อง";
+"Total: %@" = "ทั้งหมด: %@";
+"%d more items" = "%d รายการเพิ่มเติม";
+"Other (%d items)" = "อื่น ๆ (%d รายการ)";
+"Expand" = "ขยาย";
+"Collapse" = "ยุบ";
+"Cleanup ideas" = "ไอเดียการล้างข้อมูล";
+"%d unreadable item(s) skipped" = "ข้ามรายการที่อ่านไม่ได้ %d รายการ";
+
+"API key limit" = "ขีดจํากัด API คีย์";
+"Auth" = "รับรองความถูกต้อง";
+"Auto" = "อัตโนมัติ";
+"Disabled — no recent data" = "ปิดใช้งาน — ไม่มีข้อมูลล่าสุด";
+"Limits not available" = "ไม่มีขีดจํากัด";
+"No usage yet" = "ยังไม่มีการใช้งาน";
+"Not fetched yet" = "ยังไม่ได้ดึงข้อมูล";
+"Refreshing" = "สดชื่น";
+"Session" = "เซสชั่น";
+"Source" = "แหล่งที่มา";
+"State" = "สถานะ";
+"Unavailable" = "ไม่พร้อมใช้งาน";
+"Weekly" = "รายสัปดาห์";
+"not detected" = "ตรวจไม่พบ";
+"Estimated from local Codex logs for the selected account." = "ประมาณการจากบันทึก Codex ท้องถิ่นสําหรับบัญชีที่เลือก";
+"minimax_usage_amount_format" = "การใช้งาน: %@ / %@";
+"minimax_used_percent_format" = "ใช้ไป %@";
+"minimax_service_text_generation" = "การสร้างข้อความ";
+"minimax_service_text_to_speech" = "ข้อความเป็นคําพูด";
+"minimax_service_music_generation" = "การสร้างเพลง";
+"minimax_service_image_generation" = "การสร้างภาพ";
+"minimax_service_lyrics_generation" = "การสร้างเนื้อเพลง";
+"minimax_service_coding_plan_vlm" = "VLM แผนการเข้ารหัส";
+"minimax_service_coding_plan_search" = "การค้นหาแผนการเข้ารหัส";
+
+/* Additional provider settings and alerts */
+"%@ is waiting for permission" = "%@ กําลังรอการอนุญาต";
+"%@ requests" = "คําขอ %@";
+"%@: %@ credits" = "%@: %@ หน่วยกิต";
+"30d requests" = "คําขอ 30d";
+"4 days" = "4 วัน";
+"5 days" = "5 วัน";
+"7 days" = "7 วัน";
+"API key verifies Ollama Cloud access; cookies still expose quota limits." = "คีย์ API จะยืนยันการเข้าถึงระบบคลาวด์ Ollama คุกกี้ยังคงเปิดเผยขีดจํากัดโควต้า";
+"AWS access key ID. Can also be set with AWS_ACCESS_KEY_ID." = "AWS รหัสคีย์การเข้าถึง สามารถตั้งค่าด้วย AWS_ACCESS_KEY_ID";
+"AWS region. Can also be set with AWS_REGION." = "AWS ภูมิภาค สามารถตั้งค่าด้วย AWS_REGION";
+"AWS secret access key. Can also be set with AWS_SECRET_ACCESS_KEY." = "AWS คีย์การเข้าถึงลับ สามารถตั้งค่าด้วย AWS_SECRET_ACCESS_KEY";
+"Access key ID" = "รหัสคีย์การเข้าถึง";
+"Add Account" = "เพิ่มบัญชี";
+"Adding Account…" = "การเพิ่มบัญชี...";
+"Antigravity login failed" = "การเข้าสู่ระบบ Antigravity ล้มเหลว";
+"Antigravity login timed out" = "Antigravity เข้าสู่ระบบหมดเวลา";
+"Auth source" = "แหล่งที่มาของการตรวจสอบสิทธิ์";
+"Automatic imports browser cookies from Xiaomi MiMo." = "นําเข้าคุกกี้เบราว์เซอร์โดยอัตโนมัติจาก Xiaomi MiMo";
+"Automatic imports Windsurf session data from Chromium browser localStorage." = "นําเข้าข้อมูลเซสชัน Windsurf โดยอัตโนมัติจากเบราว์เซอร์ Chromium localStorage";
+"Automatic imports browser cookies from Bailian." = "นําเข้าคุกกี้เบราว์เซอร์จาก Bailian โดยอัตโนมัติ";
+"Automatically imports browser cookies." = "นําเข้าคุกกี้ของเบราว์เซอร์โดยอัตโนมัติ";
+"Automatically imports browser session cookies." = "นําเข้าคุกกี้เซสชันเบราว์เซอร์โดยอัตโนมัติ";
+"Azure OpenAI deployment name. AZURE_OPENAI_DEPLOYMENT_NAME is also supported." = "Azure OpenAI ชื่อการปรับใช้ นอกจากนี้ยังรองรับ AZURE_OPENAI_DEPLOYMENT_NAME";
+"Azure OpenAI key" = "ปุ่ม Azure OpenAI";
+"Azure OpenAI resource endpoint. AZURE_OPENAI_ENDPOINT is also supported." = "Azure OpenAI ตําแหน่งข้อมูลทรัพยากร นอกจากนี้ยังรองรับ AZURE_OPENAI_ENDPOINT";
+"Base URL" = "ฐาน URL";
+"Base URL for the LLM-API-Key-Proxy instance." = "URL พื้นฐานสําหรับอินสแตนซ์ LLM-API-Key-Proxy";
+"Browser cookies" = "คุกกี้เบราว์เซอร์";
+"Cap end" = "ปลายฝา";
+"Cap start" = "เริ่มต้นสูงสุด";
+"Capacity End" = "สิ้นสุดความจุ";
+"Capacity Start" = "ความจุเริ่มต้น";
+"Changelog" = "บันทึกการเปลี่ยนแปลง";
+"Choose the Moonshot/Kimi API host for international or China mainland accounts." = "เลือกโฮสต์ Moonshot/Kimi API สําหรับบัญชีระหว่างประเทศหรือจีนแผ่นดินใหญ่";
+"CodexBar can't replace a system account that is signed in with an API key only setup." = "CodexBar ไม่สามารถแทนที่บัญชีระบบที่ลงชื่อเข้าใช้ด้วยการตั้งค่าคีย์ API เท่านั้น";
+"CodexBar could not find saved auth for that account. Re-authenticate it and try again." = "CodexBar ไม่พบการตรวจสอบสิทธิ์ที่บันทึกไว้สําหรับบัญชีนั้น ตรวจสอบสิทธิ์อีกครั้งแล้วลองอีกครั้ง";
+"CodexBar could not read managed account storage. Recover the store before adding another account." = "CodexBar อ่านพื้นที่เก็บข้อมูลของบัญชีที่มีการจัดการไม่ได้ กู้คืนร้านค้าก่อนเพิ่มบัญชีอื่น";
+"CodexBar could not read saved auth for that account. Re-authenticate it and try again." = "CodexBar ไม่สามารถอ่านการตรวจสอบสิทธิ์ที่บันทึกไว้สําหรับบัญชีนั้นได้ ตรวจสอบสิทธิ์อีกครั้งแล้วลองอีกครั้ง";
+"CodexBar could not read the current system account on this Mac." = "CodexBar ไม่สามารถอ่านบัญชีระบบปัจจุบันบน Mac เครื่องนี้ได้";
+"CodexBar could not replace the live Codex auth on this Mac." = "CodexBar ไม่สามารถแทนที่การตรวจสอบสิทธิ์ Codex แบบสดบน Mac เครื่องนี้ได้";
+"CodexBar could not safely preserve the current system account before switching." = "CodexBar ไม่สามารถรักษาบัญชีระบบปัจจุบันได้อย่างปลอดภัยก่อนเปลี่ยน";
+"CodexBar could not save the current system account before switching." = "CodexBar ไม่สามารถบันทึกบัญชีระบบปัจจุบันก่อนที่จะเปลี่ยน";
+"CodexBar could not update managed account storage." = "CodexBar อัปเดตพื้นที่เก็บข้อมูลของบัญชีที่มีการจัดการไม่ได้";
+"CodexBar found another managed account that already uses the current system account. Resolve the duplicate account before switching." = "CodexBar พบบัญชีที่จัดการอื่นที่ใช้บัญชีระบบปัจจุบันอยู่แล้ว แก้ไขบัญชีที่ซ้ํากันก่อนเปลี่ยน";
+"CodexBar will ask macOS Keychain for “%@” so it can decrypt browser cookies and authenticate your account. Click OK to continue." = "CodexBar จะขอ \"%@\" จาก macOS Keychain เพื่อให้สามารถถอดรหัสคุกกี้ของเบราว์เซอร์และตรวจสอบบัญชีของคุณได้ คลิก ตกลง เพื่อดําเนินการต่อ";
+"CodexBar will ask macOS Keychain for the Claude Code OAuth token so it can fetch your Claude usage. Click OK to continue." = "CodexBar จะขอโทเค็น OAuth Claude Code จาก macOS Keychain เพื่อให้สามารถดึงข้อมูลการใช้งาน Claude ของคุณได้ คลิก ตกลง เพื่อดําเนินการต่อ";
+"CodexBar will ask macOS Keychain for your Amp cookie header so it can fetch usage. Click OK to continue." = "CodexBar จะขอส่วนหัวคุกกี้ Amp macOS Keychain ของคุณเพื่อให้สามารถดึงข้อมูลการใช้งานได้ คลิก ตกลง เพื่อดําเนินการต่อ";
+"CodexBar will ask macOS Keychain for your Augment cookie header so it can fetch usage. Click OK to continue." = "CodexBar จะขอส่วนหัวคุกกี้ Augment macOS Keychain ของคุณเพื่อให้สามารถดึงข้อมูลการใช้งานได้ คลิก ตกลง เพื่อดําเนินการต่อ";
+"CodexBar will ask macOS Keychain for your Claude cookie header so it can fetch Claude web usage. Click OK to continue." = "CodexBar จะขอส่วนหัวคุกกี้ Claude macOS Keychain ของคุณเพื่อให้สามารถดึงข้อมูลการใช้งานเว็บ Claude ได้ คลิก ตกลง เพื่อดําเนินการต่อ";
+"CodexBar will ask macOS Keychain for your Cursor cookie header so it can fetch usage. Click OK to continue." = "CodexBar จะขอส่วนหัวคุกกี้ Cursor macOS Keychain ของคุณเพื่อให้สามารถดึงข้อมูลการใช้งานได้ คลิก ตกลง เพื่อดําเนินการต่อ";
+"CodexBar will ask macOS Keychain for your Factory cookie header so it can fetch usage. Click OK to continue." = "CodexBar จะขอส่วนหัวคุกกี้ Factory macOS Keychain ของคุณเพื่อให้สามารถดึงข้อมูลการใช้งานได้ คลิก ตกลง เพื่อดําเนินการต่อ";
+"CodexBar will ask macOS Keychain for your GitHub Copilot token so it can fetch usage. Click OK to continue." = "CodexBar จะขอโทเค็น GitHub Copilot ของคุณจาก macOS Keychain เพื่อให้สามารถดึงข้อมูลการใช้งานได้ คลิก ตกลง เพื่อดําเนินการต่อ";
+"CodexBar will ask macOS Keychain for your Kimi K2 API key so it can fetch usage. Click OK to continue." = "CodexBar จะขอ macOS Keychain สําหรับคีย์ API Kimi K2 ของคุณเพื่อให้สามารถดึงการใช้งานได้ คลิก ตกลง เพื่อดําเนินการต่อ";
+"CodexBar will ask macOS Keychain for your Kimi auth token so it can fetch usage. Click OK to continue." = "CodexBar จะขอโทเค็นการรับรองความถูกต้อง Kimi macOS Keychain เพื่อให้สามารถดึงการใช้งานได้ คลิก ตกลง เพื่อดําเนินการต่อ";
+"CodexBar will ask macOS Keychain for your MiniMax API token so it can fetch usage. Click OK to continue." = "CodexBar จะขอโทเค็น MiniMax API ของคุณจาก macOS Keychain เพื่อให้สามารถดึงข้อมูลการใช้งานได้ คลิก ตกลง เพื่อดําเนินการต่อ";
+"CodexBar will ask macOS Keychain for your MiniMax cookie header so it can fetch usage. Click OK to continue." = "CodexBar จะขอส่วนหัวคุกกี้ MiniMax macOS Keychain ของคุณเพื่อให้สามารถดึงข้อมูลการใช้งานได้ คลิก ตกลง เพื่อดําเนินการต่อ";
+"CodexBar will ask macOS Keychain for your OpenAI cookie header so it can fetch Codex dashboard extras. Click OK to continue." = "CodexBar จะขอให้ macOS Keychain ป้อนส่วนหัวของคุกกี้ OpenAI ของคุณเพื่อให้สามารถดึงข้อมูลพิเศษ Codex แดชบอร์ดได้ คลิก ตกลง เพื่อดําเนินการต่อ";
+"CodexBar will ask macOS Keychain for your OpenCode cookie header so it can fetch usage. Click OK to continue." = "CodexBar จะขอส่วนหัวคุกกี้ OpenCode macOS Keychain ของคุณเพื่อให้สามารถดึงข้อมูลการใช้งานได้ คลิก ตกลง เพื่อดําเนินการต่อ";
+"CodexBar will ask macOS Keychain for your Synthetic API key so it can fetch usage. Click OK to continue." = "CodexBar จะขอคีย์ Synthetic API macOS Keychain เพื่อให้สามารถดึงข้อมูลการใช้งานได้ คลิก ตกลง เพื่อดําเนินการต่อ";
+"CodexBar will ask macOS Keychain for your z.ai API token so it can fetch usage. Click OK to continue." = "CodexBar จะขอโทเค็น z.ai API ของคุณจาก macOS Keychain เพื่อให้สามารถดึงข้อมูลการใช้งานได้ คลิก ตกลง เพื่อดําเนินการต่อ";
+"Could not open Cursor login in your browser." = "ไม่สามารถเปิด Cursor เข้าสู่ระบบในเบราว์เซอร์ของคุณ";
+"Could not open browser for Antigravity" = "ไม่สามารถเปิดเบราว์เซอร์สําหรับ Antigravity";
+"Credits used" = "เครดิตที่ใช้";
+"Day" = "วัน";
+"Deployment" = "การปรับใช้";
+"Drag to reorder" = "ลากเพื่อจัดลําดับใหม่";
+"Sort providers alphabetically" = "เรียงผู้ให้บริการตามตัวอักษร";
+"Sort providers alphabetically (enabled first)" = "เรียงผู้ให้บริการตามตัวอักษร (ที่เปิดใช้ก่อน)";
+"Sorted alphabetically (enabled first) — click to use your custom order" = "เรียงตามตัวอักษรแล้ว (ที่เปิดใช้ก่อน) — คลิกเพื่อใช้ลำดับที่กำหนดเอง";
+"Endpoint" = "ปลายทาง";
+"Enterprise host" = "โฮสต์องค์กร";
+"Extra usage balance: %@" = "ยอดการใช้งานเพิ่มเติม: %@";
+"Keychain Access Required" = "Keychain ต้องเข้าถึง";
+"Kiro menu bar value" = "ค่าแถบเมนู Kiro";
+"Label" = "ฉลาก";
+"No organizations loaded. Click Refresh after setting your API key." = "ไม่มีองค์กรโหลด คลิกรีเฟรชหลังจากตั้งค่าปุ่ม API";
+"No output captured." = "ไม่มีการบันทึกเอาต์พุต";
+"No system account" = "ไม่มีบัญชีระบบ";
+"Oasis-Token" = "โอเอซิส-โทเค็น";
+"Open Augment (Log Out & Back In)" = "เปิด Augment (ออกจากระบบและกลับเข้ามาใหม่)";
+"Open Codebuff Dashboard" = "เปิดแดชบอร์ด Codebuff";
+"Open Command Code Settings" = "เปิดการตั้งค่า Command Code";
+"Open Crof dashboard" = "เปิดแดชบอร์ด Crof";
+"Open Manus" = "เปิด Manus";
+"Open MiMo Balance" = "เปิดยอดคงเหลือ MiMo";
+"Open Moonshot Console" = "เปิดคอนโซล Moonshot";
+"Open Ollama API Keys" = "เปิดปุ่ม Ollama API";
+"Open StepFun Platform" = "เปิดแพลตฟอร์ม StepFun";
+"Open T3 Chat Settings" = "เปิดการตั้งค่า T3 Chat";
+"Open Volcengine Ark Console" = "เปิดคอนโซล Volcengine Ark";
+"Open legacy provider docs" = "เปิดเอกสารของผู้ให้บริการเดิม";
+"Open projects" = "เปิดโปรเจ็กต์";
+"Open this URL manually to continue login:\n\n%@" = "เปิด URL นี้ด้วยตนเองเพื่อเข้าสู่ระบบต่อ:\n\n%@";
+"Optional organization ID for accounts linked to multiple Anthropic organizations." = "รหัสองค์กรที่ไม่บังคับสําหรับบัญชีที่เชื่อมโยงกับองค์กร Anthropic หลายองค์กร";
+"Optional. Applies to the configured Admin API key; selected token accounts do not inherit OPENAI_PROJECT_ID." = "ไม่บังคับ นําไปใช้กับคีย์ API ผู้ดูแลระบบที่กําหนดค่าไว้ บัญชีโทเค็นที่เลือกจะไม่สืบทอด OPENAI_PROJECT_ID";
+"Optional. Enter your GitHub Enterprise host, for example octocorp.ghe.com. Leave blank for github.com." = "ไม่บังคับ ป้อนโฮสต์ GitHub Enterprise ของคุณ เช่น octocorp.ghe.com เว้นว่างไว้ github.com";
+"Optional. Leave blank to discover and aggregate projects visible to the API key." = "ไม่บังคับ เว้นว่างไว้เพื่อค้นหาและรวมโครงการที่มองเห็นได้จากคีย์ API";
+"Org ID (optional)" = "รหัสองค์กร (ไม่บังคับ)";
+"Organizations" = "องค์กร";
+"Password" = "รหัสผ่าน";
+"%@ authentication is disabled." = "%@ การตรวจสอบสิทธิ์ถูกปิดใช้งาน";
+"%@ cookies are disabled." = "คุกกี้ %@ ถูกปิดใช้งาน";
+"%@ web API access is disabled." = "%@ การเข้าถึง API เว็บถูกปิดใช้งาน";
+"Disable %@ dashboard cookie usage." = "ปิดใช้งานการใช้คุกกี้แดชบอร์ด %@";
+"Keychain access is disabled in Advanced, so browser cookie import is unavailable." = "การเข้าถึง Keychain ถูกปิดใช้งานในขั้นสูง ดังนั้นการนําเข้าคุกกี้ของเบราว์เซอร์จึงไม่พร้อมใช้งาน";
+"Manually paste an %@ from a browser session." = "วาง %@ จากเซสชันเบราว์เซอร์ด้วยตนเอง";
+"Paste a Cookie header captured from %@." = "วางส่วนหัวคุกกี้ที่บันทึกจาก %@";
+"Paste a Cookie header from %@." = "วางส่วนหัวคุกกี้จาก %@";
+"Paste a Cookie header or cURL capture from %@." = "วางส่วนหัวของคุกกี้หรือการจับภาพ cURL จาก %@";
+"Paste a Cookie header or full cURL capture from %@." = "วางส่วนหัวของคุกกี้หรือการจับภาพ cURL แบบเต็มจาก %@";
+"Paste a Cookie or Authorization header from %@." = "วางส่วนหัวคุกกี้หรือการให้สิทธิ์จาก %@";
+"Paste a full cookie header or the %@ value." = "วางส่วนหัวของคุกกี้แบบเต็มหรือค่า %@";
+"Paste a Cookie header or full cURL capture from T3 Chat settings." = "วางส่วนหัวของคุกกี้หรือการจับภาพ cURL แบบเต็มจากการตั้งค่า T3 Chat";
+"Paste the Cookie header from a request to admin.mistral.ai. Must contain an ory_session_* cookie." = "วางส่วนหัวคุกกี้จากคําขอไปยัง admin.mistral.ai ต้องมีคุกกี้ ory_session_*";
+"Paste the Oasis-Token from a logged-in browser session on platform.stepfun.com." = "วาง Oasis-Token จากเซสชันเบราว์เซอร์ที่เข้าสู่ระบบบน platform.stepfun.com";
+"Paste the %@ JSON bundle from %@." = "วางชุด %@ JSON จาก %@";
+"Paste the %@ value or a full Cookie header." = "วางค่า %@ หรือส่วนหัวของคุกกี้แบบเต็ม";
+"Personal account" = "บัญชีส่วนตัว";
+"Project ID" = "รหัสโครงการ";
+"Re-auth" = "ตรวจสอบสิทธิ์อีกครั้ง";
+"Re-login at claude.ai" = "เข้าสู่ระบบอีกครั้งที่ claude.ai";
+"Re-authenticating…" = "การตรวจสอบสิทธิ์อีกครั้ง...";
+"Refresh Session" = "รีเฟรชเซสชัน";
+"Refresh organizations" = "รีเฟรชองค์กร";
+"Region" = "ภูมิภาค";
+"Reload" = "โหลดซ้ํา";
+"Reorder" = "จัดลําดับใหม่";
+"Secret access key" = "คีย์การเข้าถึงลับ";
+"Series" = "ซีรีส์";
+"Service" = "บริการ";
+"Show or hide Kiro credits, percent, or both next to the menu bar icon." = "แสดงหรือซ่อนเครดิต เปอร์เซ็นต์ หรือทั้งสองอย่าง Kiro ถัดจากไอคอนแถบเมนู";
+"Show usage for organizations you belong to. Personal account is always shown." = "แสดงการใช้งานสําหรับองค์กรที่คุณเป็นสมาชิก บัญชีส่วนตัวจะแสดงอยู่เสมอ";
+"Sign in to cursor.com in your browser, then refresh Cursor in CodexBar." = "ลงชื่อเข้าใช้ cursor.com ในเบราว์เซอร์ แล้วรีเฟรช Cursor ใน CodexBar";
+"Simulated error text" = "ข้อความแสดงข้อผิดพลาดจําลอง";
+"StepFun platform account (phone number or email)." = "StepFun บัญชีแพลตฟอร์ม (หมายเลขโทรศัพท์หรืออีเมล)";
+"Stored in ~/.codexbar/config.json." = "เก็บไว้ใน ~/.codexbar/config.json.";
+"Stored in ~/.codexbar/config.json. AZURE_OPENAI_API_KEY is also supported." = "รองรับการจัดเก็บไว้ใน ~/.codexbar/config.json. AZURE_OPENAI_API_KEY";
+"Stored in ~/.codexbar/config.json. For the official Kimi API, use Moonshot / Kimi API." = "เก็บไว้ใน ~/.codexbar/config.json. สําหรับ Kimi API อย่างเป็นทางการ ให้ใช้ Moonshot / Kimi API";
+"Stored in ~/.codexbar/config.json. Get your API key from the Volcengine Ark console." = "เก็บไว้ใน ~/.codexbar/config.json. รับคีย์ API ของคุณจากคอนโซล Volcengine Ark";
+"Stored in ~/.codexbar/config.json. Get your key from Ollama settings." = "เก็บไว้ใน ~/.codexbar/config.json. รับคีย์จากการตั้งค่า Ollama";
+"Stored in ~/.codexbar/config.json. Get your key from console.deepgram.com." = "เก็บไว้ใน ~/.codexbar/config.json. รับคีย์ของคุณจาก console.deepgram.com";
+"Stored in ~/.codexbar/config.json. Get your key from elevenlabs.io/app/settings/api-keys." = "เก็บไว้ใน ~/.codexbar/config.json. รับกุญแจของคุณจาก elevenlabs.io/app/settings/api-keys.";
+"Stored in ~/.codexbar/config.json. Get your key from openrouter.ai/settings/keys and set a key spending limit there to enable API key quota tracking." = "เก็บไว้ใน ~/.codexbar/config.json. รับคีย์ของคุณจาก openrouter.ai/settings/keys และตั้งค่าขีดจํากัดการใช้จ่ายคีย์ที่นั่นเพื่อเปิดใช้งานการติดตามโควต้าคีย์ API";
+"Stored in ~/.codexbar/config.json. In Warp, open Settings > Platform > API Keys, then create one." = "เก็บไว้ใน ~/.codexbar/config.json. ใน Warp ให้เปิด การตั้งค่า > แพลตฟอร์ม > API คีย์ แล้วสร้างใหม่";
+"Stored in ~/.codexbar/config.json. Metrics require Groq Enterprise Prometheus access." = "ที่จัดเก็บไว้ในเมตริก ~/.codexbar/config.json. ต้องมีการเข้าถึง Enterprise Prometheus Groq";
+"Stored in ~/.codexbar/config.json. OPENAI_ADMIN_KEY is preferred; OPENAI_API_KEY still works." = "ควรเก็บไว้ใน ~/.codexbar/config.json. OPENAI_ADMIN_KEY OPENAI_API_KEY ยังคงใช้งานได้";
+"Stored in ~/.codexbar/config.json. Requires an Anthropic Admin API key." = "เก็บไว้ใน ~/.codexbar/config.json. ต้องใช้คีย์ API ผู้ดูแลระบบ Anthropic";
+"Stored in ~/.codexbar/config.json. Used for /v1/quota-stats." = "เก็บไว้ใน ~/.codexbar/config.json. ใช้สําหรับ /v1/quota-stats.";
+"Stored in ~/.codexbar/config.json. You can also provide CODEBUFF_API_KEY or let CodexBar read ~/.config/manicode/credentials.json (created by `codebuff login`)." = "เก็บไว้ใน ~/.codexbar/config.json. คุณยังสามารถระบุ CODEBUFF_API_KEY หรือให้ CodexBar อ่าน ~/.config/manicode/credentials.json (สร้างโดย `codebuff login`)";
+"Stored in ~/.codexbar/config.json. You can also provide CROF_API_KEY." = "เก็บไว้ใน ~/.codexbar/config.json. คุณยังสามารถให้ CROF_API_KEY";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or ~/.local/share/kilo/auth.json (kilo.access)." = "เก็บไว้ใน ~/.codexbar/config.json. คุณยังสามารถระบุ KILO_API_KEY หรือ ~/.local/share/kilo/auth.json (kilo.access) ได้อีกด้วย";
+"T3 Chat cookie" = "คุกกี้ T3 Chat";
+"That account is no longer available in CodexBar. Refresh the account list and try again." = "บัญชีนั้นไม่พร้อมใช้งานใน CodexBar อีกต่อไป รีเฟรชรายการบัญชีแล้วลองอีกครั้ง";
+"The browser login did not complete in time. Try Antigravity login again." = "การเข้าสู่ระบบเบราว์เซอร์ไม่เสร็จสมบูรณ์ทันเวลา ลองเข้าสู่ระบบ Antigravity อีกครั้ง";
+"Timed out waiting for Cursor login. %@" = "หมดเวลารอการเข้าสู่ระบบ Cursor %@";
+"Timed out waiting for Cursor login. %@ Last error: %@" = "หมดเวลารอการเข้าสู่ระบบ Cursor %@ ข้อผิดพลาดล่าสุด: %@";
+"Today requests" = "คําขอวันนี้";
+"Total (30d): %@ credits" = "รวม (30d): %@ หน่วยกิต";
+"Username" = "ชื่อผู้ใช้";
+"Uses username + password to login and obtain an Oasis-Token automatically." = "ใช้ชื่อผู้ใช้ + รหัสผ่านเพื่อเข้าสู่ระบบและรับ Oasis-Token โดยอัตโนมัติ";
+"Uses username + password to login and obtain an %@ automatically." = "ใช้ชื่อผู้ใช้ + รหัสผ่านเพื่อเข้าสู่ระบบและรับ %@ โดยอัตโนมัติ";
+"Utilization End" = "สิ้นสุดการใช้ประโยชน์";
+"Utilization Start" = "เริ่มต้นการใช้งาน";
+"Verbosity" = "รายละเอียด";
+"Windsurf session JSON bundle" = "Windsurf เซสชัน JSON บันเดิล";
+"Workspace ID" = "รหัสพื้นที่ทํางาน";
+"Your StepFun platform password. Used to login and obtain a session token." = "รหัสผ่านแพลตฟอร์ม StepFun ของคุณ ใช้เพื่อเข้าสู่ระบบและรับโทเค็นเซสชัน";
+"claude /login exited with status %d." = "Claude /login ออกจากสถานะด้วยสถานะ %d";
+"codex login exited with status %d." = "เข้าสู่ระบบ Codex ออกพร้อมกับสถานะ %d";
+"Cookie: …\n\nor paste a cURL capture from the Abacus AI dashboard" = "คุกกี้: ... \n\n หรือวางการจับภาพ cURL จากแดชบอร์ด Abacus AI";
+"Cookie: …\n\nor paste the __Secure-next-auth.session-token value" = "คุกกี้: ... \n\n หรือวางค่า __Secure-next-auth.session-token";
+"Cookie: …\n\nor paste the kimi-auth token value" = "คุกกี้: ... \n\n หรือวางค่าโทเค็น kimi-auth";
+"session_id=...\n\nor paste just the session_id value" = "session_id=... \n\n หรือวางเฉพาะค่า session_id";
+"Clear" = "ล้างค่าการค้นหา";
+"No matching providers" = "ไม่มีผู้ให้บริการที่ตรงกัน";
+"Search providers" = "ผู้ให้บริการการค้นหา";
+
+"language_vietnamese" = "เวียดนาม";
+"language_indonesian" = "บาฮาซาอินโดนีเซีย";
+
+"Request quota: %@ / %@" = "ขอโควต้า: %@ / %@";
+"language_arabic" = "العربية";
+"language_persian" = "فارسی";
+"language_thai" = "ไทย";
+"Limit Reset Credits" = "เครดิตรีเซ็ตขีดจำกัด";
+"1 manual reset available" = "มีการรีเซ็ตด้วยตนเอง 1 ครั้ง";
+"%d manual resets available" = "มีการรีเซ็ตด้วยตนเอง %d ครั้ง";
+"Next expires %@" = "รายการถัดไปหมดอายุ %@";
+"byte_unit_byte" = "ไบต์";
+"byte_unit_bytes" = "ไบต์";
+"byte_unit_kilobyte" = "กิโลไบต์";
+"byte_unit_kilobytes" = "กิโลไบต์";
+"byte_unit_megabyte" = "เมกะไบต์";
+"byte_unit_megabytes" = "เมกะไบต์";
+"byte_unit_gigabyte" = "กิกะไบต์";
+"byte_unit_gigabytes" = "กิกะไบต์";
diff --git a/Sources/CodexBar/Resources/tr.lproj/Localizable.strings b/Sources/CodexBar/Resources/tr.lproj/Localizable.strings
new file mode 100644
index 0000000000..dfcff2346b
--- /dev/null
+++ b/Sources/CodexBar/Resources/tr.lproj/Localizable.strings
@@ -0,0 +1,1107 @@
+/* Turkish localization for CodexBar */
+
+" providers" = " sağlayıcı";
+"(System)" = "(Sistem)";
+"30d" = "30 gün";
+"A managed Codex login is already running. Wait for it to finish before adding " = "Yönetilen bir Codex girişi zaten çalışıyor. Eklemeden önce bitmesini bekleyin ";
+"API key" = "API anahtarı";
+"API region" = "API bölgesi";
+"API token" = "API jetonu";
+"API tokens" = "API jetonları";
+"About" = "Hakkında";
+"Account" = "Hesap";
+"Accounts" = "Hesaplar";
+"Accounts subtitle" = "Hesaplar alt başlığı";
+"Active" = "Etkin";
+"Add" = "Ekle";
+"Add Workspace" = "Çalışma Alanı Ekle";
+"Advanced" = "Gelişmiş";
+"All" = "Tümü";
+"Always allow prompts" = "Her zaman istemlere izin ver";
+"Animation pattern" = "Animasyon deseni";
+"Antigravity login is managed in the app" = "Antigravity girişi uygulama içinden yönetilir";
+"Applies only to the Security.framework OAuth keychain reader." = "Yalnızca Security.framework OAuth Anahtarlık okuyucusu için geçerlidir.";
+"Auto falls back to the next source if the preferred one fails." = "Otomatik mod, tercih edilen kaynak başarısız olursa bir sonrakine geçer.";
+"Auto uses API first, then falls back to CLI on auth failures." = "Otomatik mod önce API'yi kullanır, kimlik doğrulama başarısız olursa CLI'ya geçer.";
+"Auto-detect" = "Otomatik algıla";
+"Auto-refresh is off; use the menu's Refresh command." = "Otomatik yenileme kapalı; menüdeki Yenile komutunu kullanın.";
+"Auto-refresh: hourly · Timeout: 10m" = "Otomatik yenileme: saatlik · Zaman aşımı: 10 dk";
+"Automatic" = "Otomatik";
+"Automatic imports browser cookies and WorkOS tokens." = "Otomatik olarak tarayıcı çerezlerini ve WorkOS jetonlarını içe aktarır.";
+"Automatic imports browser cookies and local storage tokens." = "Otomatik olarak tarayıcı çerezlerini ve yerel depolama jetonlarını içe aktarır.";
+"Automatic imports browser cookies for dashboard extras." = "Otomatik olarak panel ekleri için tarayıcı çerezlerini içe aktarır.";
+"Automatic imports browser cookies for the web API." = "Otomatik olarak web API'si için tarayıcı çerezlerini içe aktarır.";
+"Automatic imports browser cookies from Model Studio/Bailian." = "Otomatik olarak Model Studio/Bailian'dan tarayıcı çerezlerini içe aktarır.";
+"Automatic imports browser cookies from admin.mistral.ai." = "Otomatik olarak admin.mistral.ai'dan tarayıcı çerezlerini içe aktarır.";
+"Automatic imports browser cookies from opencode.ai." = "Otomatik olarak opencode.ai'dan tarayıcı çerezlerini içe aktarır.";
+"Automatic imports browser cookies or stored sessions." = "Otomatik olarak tarayıcı çerezlerini veya kayıtlı oturumları içe aktarır.";
+"Automatic imports browser cookies." = "Otomatik olarak tarayıcı çerezlerini içe aktarır.";
+"Automatically imports browser session cookie." = "Otomatik olarak tarayıcı oturum çerezini içe aktarır.";
+"Automatically opens CodexBar when you start your Mac." = "Mac'inizi başlattığınızda CodexBar'ı otomatik olarak açar.";
+"Automation" = "Otomasyon";
+"Average (\\(label1) + \\(label2))" = "Ortalama (\\(label1) + \\(label2))";
+"Average (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))" = "Ortalama (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))";
+"Avoid Keychain prompts" = "Anahtarlık istemlerini atla";
+"Balance" = "Bakiye";
+"Battery Saver" = "Pil Tasarrufu";
+"Bordered" = "Kenarlıklı";
+"Build" = "Derleme";
+"Built \\(buildTimestamp)" = "Derlenme \\(buildTimestamp)";
+"Buy Credits..." = "Kredi Satın Al...";
+"Buy Credits…" = "Kredi Satın Al…";
+"CLI paths" = "CLI yolları";
+"CLI sessions" = "CLI oturumları";
+"Caches" = "Önbellekler";
+"Cancel" = "İptal";
+"Check for Updates…" = "Güncellemeleri Denetle…";
+"Check for updates automatically" = "Güncellemeleri otomatik denetle";
+"Check if you like your agents having some fun up there." = "Ajanlarınızın yukarıda biraz eğlenmesini istiyorsanız işaretleyin.";
+"Check provider status" = "Sağlayıcı durumunu denetle";
+"Choose Codex workspace" = "Codex çalışma alanını seçin";
+"Choose the MiniMax host (global .io or China mainland .com)." = "MiniMax sunucusunu seçin (küresel .io veya Çin anakarası .com).";
+"Choose up to " = "En fazla seçin ";
+"Choose up to \\(Self.maxOverviewProviders) providers" = "En fazla \\(Self.maxOverviewProviders) sağlayıcı seçin";
+"Choose up to \\(count) providers" = "En fazla \\(count) sağlayıcı seçin";
+"Choose what to show in the menu bar (Pace shows usage vs. expected)." = "Menü çubuğunda ne gösterileceğini seçin (Hız, kullanımı beklentiyle karşılaştırır).";
+"Choose which Codex account CodexBar should follow." = "CodexBar'ın hangi Codex hesabını izleyeceğini seçin.";
+"Choose which window drives the menu bar percent." = "Menü çubuğu yüzdesini hangi pencerenin belirleyeceğini seçin.";
+"Chrome" = "Chrome";
+"Claude CLI not found" = "Claude CLI bulunamadı";
+"Claude binary" = "Claude çalıştırılabilir dosyası";
+"Claude cookies" = "Claude çerezleri";
+"Claude login failed" = "Claude girişi başarısız";
+"Claude login timed out" = "Claude girişi zaman aşımına uğradı";
+"Close" = "Kapat";
+"Code review" = "Kod incelemesi";
+"Codex CLI not found" = "Codex CLI bulunamadı";
+"Codex account login already running" = "Codex hesap girişi zaten çalışıyor";
+"Codex binary" = "Codex çalıştırılabilir dosyası";
+"Codex login failed" = "Codex girişi başarısız";
+"Codex login timed out" = "Codex girişi zaman aşımına uğradı";
+"CodexBar Lifecycle Keepalive" = "CodexBar Yaşam Döngüsü Canlı Tutma";
+"CodexBar can't show its menu bar icon" = "CodexBar menü çubuğu simgesini gösteremiyor";
+"CodexBar could not read managed account storage. " = "CodexBar yönetilen hesap depolamasını okuyamadı. ";
+"Configure…" = "Yapılandır…";
+"Connected" = "Bağlı";
+"Controls how much detail is logged." = "Ne kadar ayrıntının günlüğe kaydedileceğini denetler.";
+"Cookie header" = "Çerez başlığı";
+"Cookie source" = "Çerez kaynağı";
+"Cookie: ..." = "Çerez: ...";
+"Cookie: \\u{2026}\\\n\\\nor paste a cURL capture from the Abacus AI dashboard" = "Çerez: \\u{2026}\\\n\\\nveya Abacus AI panelinden bir cURL yakalaması yapıştırın";
+"Cookie: \\u{2026}\\\n\\\nor paste the __Secure-next-auth.session-token value" = "Çerez: \\u{2026}\\\n\\\nveya __Secure-next-auth.session-token değerini yapıştırın";
+"Cookie: \\u{2026}\\\n\\\nor paste the kimi-auth token value" = "Çerez: \\u{2026}\\\n\\\nveya kimi-auth jeton değerini yapıştırın";
+"Cookie: …" = "Çerez: …";
+"CopilotDeviceFlow" = "CopilotDeviceFlow";
+"Cost" = "Maliyet";
+"Could not add Codex account" = "Codex hesabı eklenemedi";
+"Could not open Terminal for Gemini" = "Gemini için Terminal açılamadı";
+"Could not start claude /login" = "claude /login başlatılamadı";
+"Could not start codex login" = "codex login başlatılamadı";
+"Could not switch system account" = "Sistem hesabı değiştirilemedi";
+"Credits" = "Krediler";
+"Individual credits" = "Bireysel krediler";
+"Workspace" = "Çalışma alanı";
+"Credits history" = "Kredi geçmişi";
+"Cursor login failed" = "Cursor girişi başarısız";
+"Custom" = "Özel";
+"Custom Path" = "Özel Yol";
+"Daily Routines" = "Günlük Rutinler";
+"Debug" = "Hata Ayıklama";
+"Default" = "Varsayılan";
+"Disable Keychain access" = "Anahtarlık erişimini devre dışı bırak";
+"Disabled" = "Devre dışı";
+"Dismiss" = "Kapat";
+"Disconnected" = "Bağlantı kesildi";
+"Display" = "Görünüm";
+"Display mode" = "Görünüm modu";
+"Display reset times as absolute clock values instead of countdowns." = "Sıfırlama sürelerini geri sayım yerine mutlak saat değerleri olarak göster.";
+"Done" = "Bitti";
+"Effective PATH" = "Etkili PATH";
+"Email" = "E-posta";
+"Enable Merge Icons to configure Overview tab providers." = "Genel Bakış sekmesi sağlayıcılarını yapılandırmak için Simgeleri Birleştir'i etkinleştirin.";
+"Enable file logging" = "Dosya günlüğünü etkinleştir";
+"Enabled" = "Etkin";
+"Error" = "Hata";
+"Error simulation" = "Hata simülasyonu";
+"Expose troubleshooting tools in the Debug tab." = "Sorun giderme araçlarını Hata Ayıklama sekmesinde göster.";
+"Failed" = "Başarısız";
+"False" = "Yanlış";
+"Fetch strategy attempts" = "Getirme stratejisi denemeleri";
+"Fetching" = "Getiriliyor";
+"Field" = "Alan";
+"Field subtitle" = "Alan alt başlığı";
+"Finish the current managed account change before switching the system account." = "Sistem hesabını değiştirmeden önce geçerli yönetilen hesap değişikliğini tamamlayın.";
+"Force animation on next refresh" = "Sonraki yenilemede animasyonu zorla";
+"Gateway region" = "Ağ geçidi bölgesi";
+"Gemini CLI not found" = "Gemini CLI bulunamadı";
+"Gemini/Antigravity, surfacing incidents in the icon and menu." = "Gemini/Antigravity, olayları simge ve menüde gösterir.";
+"General" = "Genel";
+"GitHub" = "GitHub";
+"GitHub Copilot Login" = "GitHub Copilot Girişi";
+"GitHub Login" = "GitHub Girişi";
+"Hide details" = "Ayrıntıları gizle";
+"Hide personal information" = "Kişisel bilgileri gizle";
+"Historical tracking" = "Geçmişsel izleme";
+"How often CodexBar polls providers in the background." = "CodexBar'ın arka planda sağlayıcıları ne sıklıkla sorgulayacağı.";
+"Inactive" = "Devre dışı";
+"Install CLI" = "CLI Kur";
+"Install the Claude CLI (npm i -g @anthropic-ai/claude-code) and try again." = "Claude CLI'yi kurun (npm i -g @anthropic-ai/claude-code) ve tekrar deneyin.";
+"Install the Codex CLI (npm i -g @openai/codex) and try again." = "Codex CLI'yi kurun (npm i -g @openai/codex) ve tekrar deneyin.";
+"Install the Gemini CLI (npm i -g @google/gemini-cli) and try again." = "Gemini CLI'yi kurun (npm i -g @google/gemini-cli) ve tekrar deneyin.";
+"JetBrains AI is ready" = "JetBrains AI hazır";
+"JetBrains IDE" = "JetBrains IDE";
+"Keep CLI sessions alive" = "CLI oturumlarını canlı tut";
+"Keyboard shortcut" = "Klavye kısayolu";
+"Keychain access" = "Anahtarlık erişimi";
+"Keychain prompt policy" = "Anahtarlık istem ilkesi";
+"Last \\(name) fetch failed:" = "Son \\(name) getirmesi başarısız:";
+"Last \\(self.store.metadata(for: self.provider).displayName) fetch failed:" = "Son \\(self.store.metadata(for: self.provider).displayName) getirmesi başarısız:";
+"Last attempt" = "Son deneme";
+"Link" = "Bağlantı";
+"Loading animations" = "Yükleme animasyonları";
+"Loading…" = "Yükleniyor…";
+"Local" = "Yerel";
+"Logging" = "Günlükleme";
+"Login failed" = "Giriş başarısız";
+"Login shell PATH (startup capture)" = "Oturum kabuğu PATH (başlangıç yakalaması)";
+"Login timed out" = "Giriş zaman aşımına uğradı";
+"MCP details" = "MCP ayrıntıları";
+"Managed Codex accounts unavailable" = "Yönetilen Codex hesapları kullanılamıyor";
+"Managed account storage is unreadable. Live account access is still available, " = "Yönetilen hesap depolaması okunamıyor. Canlı hesap erişimi hâlâ kullanılabilir, ";
+"Manual" = "El ile";
+"May your tokens never run out—keep agent limits in view." = "Jetonlarınız hiç bitmesin—ajan limitlerini göz önünde bulundurun.";
+"Menu bar" = "Menü çubuğu";
+"Menu bar auto-shows the provider closest to its rate limit." = "Menü çubuğu, hız limitine en yakın sağlayıcıyı otomatik gösterir.";
+"Menu bar metric" = "Menü çubuğu metriği";
+"Menu bar shows percent" = "Menü çubuğu yüzde gösterir";
+"Menu content" = "Menü içeriği";
+"Merge Icons" = "Simgeleri Birleştir";
+"Never prompt" = "Hiçbir zaman istem gösterme";
+"No" = "Hayır";
+"No Codex accounts detected yet." = "Henüz Codex hesabı algılanmadı.";
+"No JetBrains IDE detected" = "JetBrains IDE algılanmadı";
+"No cost history data." = "Maliyet geçmişi verisi yok.";
+"No data available" = "Veri yok";
+"No data yet" = "Henüz veri yok";
+"No enabled providers available for Overview." = "Genel Bakış için kullanılabilir etkin sağlayıcı yok.";
+"No providers selected" = "Sağlayıcı seçilmedi";
+"No token accounts yet." = "Henüz jeton hesabı yok.";
+"No usage breakdown data." = "Kullanım dağılım verisi yok.";
+"None" = "Hiçbiri";
+"Notifications" = "Bildirimler";
+"Notifies when the 5-hour session quota hits 0% and when it becomes " = "5 saatlik oturum kotası %0'a ulaştığında ve tekrar ";
+"OK" = "Tamam";
+"Obscure email addresses in the menu bar and menu UI." = "Menü çubuğu ve menü arayüzünde e-posta adreslerini gizle.";
+"Off" = "Kapalı";
+"Offline" = "Çevrimdışı";
+"On" = "Açık";
+"Online" = "Çevrimiçi";
+"Only on user action" = "Yalnızca kullanıcı eyleminde";
+"Open" = "Aç";
+"Open API Keys" = "API Anahtarlarını Aç";
+"Open Amp Settings" = "Amp Ayarlarını Aç";
+"Open Antigravity to sign in, then refresh CodexBar." = "Giriş yapmak için Antigravity'yi açın, ardından CodexBar'ı yenileyin.";
+"Open Browser" = "Tarayıcıyı Aç";
+"Open Coding Plan" = "Kodlama Planını Aç";
+"Open Console" = "Konsolu Aç";
+"Open Dashboard" = "Paneli Aç";
+"Open Mistral Admin" = "Mistral Yönetimini Aç";
+"Open Menu Bar Settings" = "Menü Çubuğu Ayarlarını Aç";
+"Open Ollama Settings" = "Ollama Ayarlarını Aç";
+"Open Terminal" = "Terminali Aç";
+"Open Usage Page" = "Kullanım Sayfasını Aç";
+"Open Warp API Key Guide" = "Warp API Anahtarı Kılavuzunu Aç";
+"Open menu" = "Menüyü aç";
+"Open token file" = "Jeton dosyasını aç";
+"OpenAI cookies" = "OpenAI çerezleri";
+"OpenAI web extras" = "OpenAI web ekleri";
+"Option A" = "Seçenek A";
+"Option B" = "Seçenek B";
+"Optional override if workspace lookup fails." = "Çalışma alanı araması başarısız olursa isteğe bağlı geçersiz kılma.";
+"Options" = "Seçenekler";
+"Override auto-detection with a custom IDE base path" = "Otomatik algılamayı özel bir IDE temel yoluyla geçersiz kıl";
+"Overview" = "Genel Bakış";
+"Overview rows always follow provider order." = "Genel Bakış satırları her zaman sağlayıcı sırasını takip eder.";
+"Overview tab providers" = "Genel Bakış sekmesi sağlayıcıları";
+"Paste API key…" = "API anahtarı yapıştır…";
+"Paste API token…" = "API jetonu yapıştır…";
+"Paste key…" = "Anahtar yapıştır…";
+"Paste sessionKey or OAuth token…" = "sessionKey veya OAuth jetonu yapıştır…";
+"Paste the Cookie header from a request to admin.mistral.ai. " = "admin.mistral.ai'a yapılan bir istekten Çerez başlığını yapıştırın. ";
+"Paste token…" = "Jeton yapıştır…";
+"Personal" = "Kişisel";
+"Picker" = "Seçici";
+"Picker subtitle" = "Seçici alt başlığı";
+"Placeholder" = "Yer tutucu";
+"Plan" = "Plan";
+"Play full-screen confetti when weekly usage resets." = "Haftalık kullanım sıfırlandığında tam ekran konfeti oynat.";
+"Polls OpenAI/Claude status pages and Google Workspace for " = "OpenAI/Claude durum sayfalarını ve Google Workspace'i ";
+"Prevents any Keychain access while enabled." = "Etkinleştirildiğinde tüm Anahtarlık erişimini engeller.";
+"Primary (API key limit)" = "Birincil (API anahtarı limiti)";
+"Primary (\\(label))" = "Birincil (\\(label))";
+"Primary (\\(metadata.sessionLabel))" = "Birincil (\\(metadata.sessionLabel))";
+"Probe logs" = "Sorgu günlükleri";
+"Progress bars fill as you consume quota (instead of showing remaining)." = "İlerleme çubukları kota tükettikçe dolar (kalanı göstermek yerine).";
+"Provider" = "Sağlayıcı";
+"Providers" = "Sağlayıcılar";
+"Quit CodexBar" = "CodexBar'dan Çık";
+"Random (default)" = "Rastgele (varsayılan)";
+"Reads local usage logs. Shows today + last 30 days cost in the menu." = "Yerel kullanım günlüklerini okur. Menüde bugün + seçilen geçmiş penceresini gösterir.";
+"Refresh" = "Yenile";
+"Refresh cadence" = "Yenileme sıklığı";
+"Remote" = "Uzak";
+"Remove" = "Kaldır";
+"Remove Codex account?" = "Codex hesabı kaldırılsın mı?";
+"Remove \\(account.email) from CodexBar? Its managed Codex home will be deleted." = "\\(account.email) CodexBar'dan kaldırılsın mı? Yönetilen Codex evi silinecek.";
+"Remove \\(email) from CodexBar? Its managed Codex home will be deleted." = "\\(email) CodexBar'dan kaldırılsın mı? Yönetilen Codex evi silinecek.";
+"Remove selected account" = "Seçili hesabı kaldır";
+"Replace critter bars with provider branding icons and a percentage." = "Canavar çubuklarını sağlayıcı marka simgeleri ve yüzde ile değiştir.";
+"Replay selected animation" = "Seçili animasyonu yeniden oynat";
+"Requires authentication via GitHub Device Flow." = "GitHub Cihaz Akışı ile kimlik doğrulaması gerektirir.";
+"Resets: \\(reset)" = "Sıfırlama: \\(reset)";
+"Rolling five-hour limit" = "Kayan beş saatlik limit";
+"Search hourly" = "Saatlik ara";
+"Secondary (\\(label))" = "İkincil (\\(label))";
+"Secondary (\\(metadata.weeklyLabel))" = "İkincil (\\(metadata.weeklyLabel))";
+"Select a provider" = "Bir sağlayıcı seçin";
+"Select the IDE to monitor" = "İzlenecek IDE'yi seçin";
+"Session quota notifications" = "Oturum kota bildirimleri";
+"Session tokens" = "Oturum jetonları";
+"Settings" = "Ayarlar";
+"Show Codex Credits and Claude Extra usage sections in the menu." = "Menüde Codex Kredileri ve Claude Ekstra kullanım bölümlerini göster.";
+"Show Debug Settings" = "Hata Ayıklama Ayarlarını Göster";
+"Show all token accounts" = "Tüm jeton hesaplarını göster";
+"Show cost summary" = "Maliyet özetini göster";
+"Show credits + extra usage" = "Krediler + ekstra kullanımı göster";
+"Show details" = "Ayrıntıları göster";
+"Show most-used provider" = "En çok kullanılan sağlayıcıyı göster";
+"Show provider icons in the switcher (otherwise show a weekly progress line)." = "Değiştiricide sağlayıcı simgelerini göster (aksi takdirde haftalık ilerleme çizgisi göster).";
+"Show reset time as clock" = "Sıfırlama süresini saat olarak göster";
+"Show usage as used" = "Kullanımı harcanan olarak göster";
+"Sign in via button below" = "Aşağıdaki düğmeyle oturum açın";
+"Skip teardown between probes (debug-only)." = "Sorgular arası sökmeyi atla (yalnızca hata ayıklama).";
+"Stack token accounts in the menu (otherwise show an account switcher bar)." = "Menüde jeton hesaplarını yığınla göster (aksi takdirde hesap değiştirici çubuk göster).";
+"Start at Login" = "Girişte Başlat";
+"Status" = "Durum";
+"Store Claude sessionKey cookies or OAuth access tokens." = "Claude sessionKey çerezlerini veya OAuth erişim jetonlarını depolayın.";
+"Store multiple Abacus AI Cookie headers." = "Birden fazla Abacus AI Çerez başlığı depolayın.";
+"Store multiple Augment Cookie headers." = "Birden fazla Augment Çerez başlığı depolayın.";
+"Store multiple Cursor Cookie headers." = "Birden fazla Cursor Çerez başlığı depolayın.";
+"Store multiple Factory Cookie headers." = "Birden fazla Factory Çerez başlığı depolayın.";
+"Store multiple MiniMax Cookie headers." = "Birden fazla MiniMax Çerez başlığı depolayın.";
+"Store multiple Mistral Cookie headers." = "Birden fazla Mistral Çerez başlığı depolayın.";
+"Store multiple Ollama Cookie headers." = "Birden fazla Ollama Çerez başlığı depolayın.";
+"Store multiple OpenCode Cookie headers." = "Birden fazla OpenCode Çerez başlığı depolayın.";
+"Store multiple OpenCode Go Cookie headers." = "Birden fazla OpenCode Go Çerez başlığı depolayın.";
+"Stored in the CodexBar config file." = "CodexBar yapılandırma dosyasında depolandı.";
+"Stored in ~/.codexbar/config.json. " = "~/.codexbar/config.json dosyasında depolandı. ";
+"Stored in ~/.codexbar/config.json. Generate one at kimi-k2.ai." = "~/.codexbar/config.json dosyasında depolandı. kimi-k2.ai adresinden bir tane oluşturun.";
+"Stored in ~/.codexbar/config.json. Paste the key from the Synthetic dashboard." = "~/.codexbar/config.json dosyasında depolandı. Synthetic panelinden anahtarı yapıştırın.";
+"Stored in ~/.codexbar/config.json. Paste your Coding Plan API key from Model Studio." = "~/.codexbar/config.json dosyasında depolandı. Model Studio'dan Kodlama Planı API anahtarınızı yapıştırın.";
+"Stored in ~/.codexbar/config.json. Paste your MiniMax API key." = "~/.codexbar/config.json dosyasında depolandı. MiniMax API anahtarınızı yapıştırın.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or " = "~/.codexbar/config.json dosyasında depolandı. Ayrıca KILO_API_KEY sağlayabilirsiniz veya ";
+"Stores local Codex usage history (8 weeks) to personalize Pace predictions." = "Hız tahminlerini kişiselleştirmek için yerel Codex kullanım geçmişini (8 hafta) depolar.";
+"Subscription Utilization" = "Abonelik Kullanımı";
+"Surprise me" = "Beni şaşırt";
+"Switcher shows icons" = "Değiştirici simgeleri gösterir";
+"Symlink CodexBarCLI to /usr/local/bin and /opt/homebrew/bin as codexbar." = "CodexBarCLI'yi codexbar olarak /usr/local/bin ve /opt/homebrew/bin dizinlerine sembolik bağlayın.";
+"System" = "Sistem";
+"Temporarily shows the loading animation after the next refresh." = "Sonraki yenilemeden sonra yükleme animasyonunu geçici olarak gösterir.";
+"Tertiary (\\(label))" = "Üçüncül (\\(label))";
+"Tertiary (\\(tertiaryTitle))" = "Üçüncül (\\(tertiaryTitle))";
+"The default Codex account on this Mac." = "Bu Mac'teki varsayılan Codex hesabı.";
+"Toggle" = "Geçiş";
+"Toggle subtitle" = "Geçiş alt başlığı";
+"Token" = "Jeton";
+"Trigger the menu bar menu from anywhere." = "Menü çubuğu menüsünü herhangi bir yerden tetikleyin.";
+"True" = "Doğru";
+"Twitter" = "Twitter";
+"Unsupported" = "Desteklenmiyor";
+"Update Channel" = "Güncelleme Kanalı";
+"Updated" = "Güncellendi";
+"Updates unavailable in this build." = "Bu derlemede güncellemeler kullanılamıyor.";
+"Usage" = "Kullanım";
+"Usage breakdown" = "Kullanım dağılımı";
+"Usage history (30 days)" = "Kullanım geçmişi";
+"Usage source" = "Kullanım kaynağı";
+"Use BigModel for the China mainland endpoints (open.bigmodel.cn)." = "Çin anakarası uç noktaları için BigModel kullanın (open.bigmodel.cn).";
+"Use a single menu bar icon with a provider switcher." = "Sağlayıcı değiştiricisiyle tek bir menü çubuğu simgesi kullan.";
+"Use international or China mainland console gateways for quota fetches." = "Kota getirmeleri için uluslararası veya Çin anakarası konsol ağ geçitlerini kullan.";
+"Version" = "Sürüm";
+"Version \\(self.versionString)" = "Sürüm \\(self.versionString)";
+"Version \\(version)" = "Sürüm \\(version)";
+"Version \\(versionString)" = "Sürüm \\(versionString)";
+"Vertex AI Login" = "Vertex AI Girişi";
+"Wait for the current managed Codex login to finish before adding another account." = "Başka bir hesap eklemeden önce geçerli yönetilen Codex girişinin bitmesini bekleyin.";
+"Waiting for Authentication..." = "Kimlik Doğrulaması Bekleniyor...";
+"Website" = "Web Sitesi";
+"Weekly limit confetti" = "Haftalık limit konfetisi";
+"Weekly token limit" = "Haftalık jeton limiti";
+"Weekly usage" = "Haftalık kullanım";
+"Weekly usage unavailable for this account." = "Bu hesap için haftalık kullanım kullanılamıyor.";
+"Window: \\(window)" = "Pencere: \\(window)";
+"Write logs to \\(self.fileLogPath) for debugging." = "Hata ayıklama için günlükleri \\(self.fileLogPath) konumuna yaz.";
+"Yes" = "Evet";
+"\\(detail.modelCode): \\(usage)" = "\\(detail.modelCode): \\(usage)";
+"\\(name): \\(truncated)" = "\\(name): \\(truncated)";
+"\\(name): \\(updated) · 30d \\(cost)" = "\\(name): \\(updated) · 30 gün \\(cost)";
+"\\(name): fetching…\\(elapsed)" = "\\(name): getiriliyor…\\(elapsed)";
+"\\(name): last attempt \\(when)" = "\\(name): son deneme \\(when)";
+"\\(name): no data yet" = "\\(name): henüz veri yok";
+"\\(name): unsupported" = "\\(name): desteklenmiyor";
+"all browsers" = "tüm tarayıcılar";
+"available again." = "tekrar kullanılabilir olduğunda bildirir.";
+"built_format" = "Derlenme %@";
+"copilot_complete_in_browser" = "Tarayıcınızda oturum açmayı tamamlayın.";
+"copilot_device_code" = "Cihaz kodu panoya kopyalandı: %1$@\n\nDoğrulayın: %2$@";
+"copilot_device_code_copied" = "Cihaz kodu kopyalandı.";
+"copilot_verify_at" = "Doğrulayın: %@";
+"copilot_waiting_text" = "Tarayıcınızda oturum açmayı tamamlayın.\nOturum açma tamamlandığında bu pencere otomatik olarak kapanır.";
+"copilot_window_closes_auto" = "Oturum açma tamamlandığında bu pencere otomatik olarak kapanır.";
+"cost_status_error" = "%1$@: %2$@";
+"cost_status_fetching" = "%1$@: getiriliyor… %2$@";
+"cost_status_last_attempt" = "%1$@: son deneme %2$@";
+"cost_status_no_data" = "%@: henüz veri yok";
+"cost_status_snapshot" = "%1$@: %2$@ · %3$@ %4$@";
+"cost_status_unsupported" = "%@: desteklenmiyor";
+"credits_remaining" = "Krediler: %@";
+"cursor_on_demand" = "İsteğe bağlı: %@";
+"cursor_on_demand_with_limit" = "İsteğe bağlı: %1$@ / %2$@";
+"extra_usage_format" = "Ekstra kullanım: %1$@ / %2$@";
+"jetbrains_detected_generate" = "Algılandı: %@. Kota verisini oluşturmak için AI asistanını bir kez kullanın, ardından CodexBar'ı yenileyin.";
+"jetbrains_detected_select" = "Algılandı: %@. Ayarlar'da tercih ettiğiniz IDE'yi seçin, ardından CodexBar'ı yenileyin.";
+"last_fetch_failed_with_provider" = "Son %@ getirmesi başarısız:";
+"last_spend" = "Son harcama: %@";
+"mcp_model_usage" = "%1$@: %2$@";
+"mcp_resets" = "Sıfırlama: %@";
+"mcp_window" = "Pencere: %@";
+"metric_average" = "Ortalama (%1$@ + %2$@)";
+"metric_primary" = "Birincil (%@)";
+"metric_secondary" = "İkincil (%@)";
+"metric_tertiary" = "Üçüncül (%@)";
+"multiple_workspaces_found" = "CodexBar %@ için birden fazla çalışma alanı buldu. Lütfen eklenecek çalışma alanını seçin.";
+"ory_session_…=…; csrftoken=…" = "ory_session_…=…; csrftoken=…";
+"overview_choose_providers" = "En fazla %@ sağlayıcı seçin";
+"remove_account_message" = "%@ CodexBar'dan kaldırılsın mı? Yönetilen Codex evi silinecek.";
+"version_format" = "Sürüm %@";
+"vertex_ai_login_instructions" = "Vertex AI kullanımını izlemek için Google Cloud ile kimlik doğrulaması yapın.\n\n1. Terminal'i açın\n2. Şunu çalıştırın: gcloud auth application-default login\n3. Tarayıcıdaki adımları takip ederek oturum açın\n4. Projenizi ayarlayın: gcloud config set project PROJECT_ID\n\nTerminal şimdi açılsın mı?";
+"workspaceID is set but only opencode, opencodego, and deepgram support workspaceID." = "workspaceID ayarlandı, ancak yalnızca opencode, opencodego ve deepgram workspaceID destekler.";
+"© 2026 Peter Steinberger. MIT License." = "© 2026 Peter Steinberger. MIT Lisansı.";
+
+/* General Pane */
+"section_system" = "Sistem";
+"section_usage" = "Kullanım";
+"section_automation" = "Otomasyon";
+"language_title" = "Dil";
+"language_subtitle" = "Görüntüleme dilini değiştirin. Tam olarak geçerli olması için uygulamanın yeniden başlatılması gerekir.";
+"language_system" = "Sistem";
+"language_english" = "English";
+"language_spanish" = "Español";
+"language_catalan" = "Català";
+"language_chinese_simplified" = "简体中文";
+"language_chinese_traditional" = "繁體中文";
+"language_portuguese_brazilian" = "Português (Brasil)";
+"language_swedish" = "Svenska";
+"language_dutch" = "Nederlands";
+"language_german" = "Deutsch";
+"language_french" = "Français";
+"language_ukrainian" = "Українська";
+"language_vietnamese" = "Tiếng Việt";
+"language_japanese" = "日本語";
+"language_korean" = "한국어";
+"language_turkish" = "Türkçe";
+"language_italian" = "Italiano";
+"language_indonesian" = "Endonezce";
+"language_polish" = "Lehçe";
+"start_at_login_title" = "Girişte Başlat";
+"start_at_login_subtitle" = "Mac'inizi başlattığınızda CodexBar'ı otomatik olarak açar.";
+"show_cost_summary" = "Maliyet özetini göster";
+"show_cost_summary_subtitle" = "Yerel kullanım günlüklerini okur. Menüde bugün + seçilen geçmiş penceresini gösterir.";
+"cost_history_days_title" = "Geçmiş penceresi: %d gün";
+"cost_auto_refresh_info" = "Otomatik yenileme: saatlik · Zaman aşımı: 10 dk";
+"refresh_cadence_title" = "Yenileme sıklığı";
+"refresh_cadence_subtitle" = "CodexBar'ın arka planda sağlayıcıları ne sıklıkla sorgulayacağı.";
+"manual_refresh_hint" = "Otomatik yenileme kapalı; menüdeki Yenile komutunu kullanın.";
+"check_provider_status_title" = "Sağlayıcı durumunu denetle";
+"check_provider_status_subtitle" = "OpenAI/Claude durum sayfalarını ve Google Workspace'i (Gemini/Antigravity) sorgular, olayları simge ve menüde gösterir.";
+"session_quota_notifications_title" = "Oturum kota bildirimleri";
+"session_quota_notifications_subtitle" = "5 saatlik oturum kotası %0'a ulaştığında ve tekrar kullanılabilir olduğunda bildirir.";
+"quota_warning_notifications_title" = "Kota uyarı bildirimleri";
+"quota_warning_notifications_subtitle" = "Oturum veya haftalık kalan kota yapılandırılan eşikleri geçtiğinde uyarır.";
+"quota_warnings_title" = "Kota uyarıları";
+"quota_warning_session" = "oturum";
+"quota_warning_session_capitalized" = "Oturum";
+"quota_warning_weekly" = "haftalık";
+"quota_warning_weekly_capitalized" = "Haftalık";
+"quota_warning_notification_title" = "%1$@ %2$@ kotası düşük";
+"quota_warning_notification_body" = "%1$@ kaldı. %2$d%% %3$@ uyarı eşiğinize ulaşıldı.";
+"quota_warning_notification_body_with_account" = "Hesap %1$@. %2$@ kaldı. %3$d%% %4$@ uyarı eşiğinize ulaşıldı.";
+"session_depleted_notification_title" = "%@ oturumu tükendi";
+"session_depleted_notification_body" = "0% kaldı. Tekrar kullanılabilir olduğunda bildirilecek.";
+"session_restored_notification_title" = "%@ oturumu geri yüklendi";
+"session_restored_notification_body" = "Oturum kotası tekrar kullanılabilir.";
+"quota_warning_warn_at" = "Uyarı eşikleri";
+"quota_warning_global_threshold_subtitle" = "Bir sağlayıcı geçersiz kılmadıkça oturum ve haftalık pencereler için kalan yüzdelerval.";
+"quota_warning_sound" = "Bildirim sesi çal";
+"quota_warning_provider_inherits" = "Bir pencere burada özelleştirilmediği sürece genel kota uyarı ayarlarını kullanır.";
+"quota_warning_customize_thresholds" = "%@ eşiklerini özelleştir";
+"quota_warning_enable_warnings" = "%@ uyarılarını etkinleştir";
+"quota_warning_window_warn_at" = "%@ uyarı eşiği";
+"quota_warning_off" = "Kapalı";
+"quota_warning_inherited" = "Devralınan: %@";
+"quota_warning_depleted_only" = "yalnızca tükenme";
+"quota_warning_upper" = "Üst";
+"quota_warning_lower" = "Alt";
+"apply" = "Uygula";
+"quit_app" = "CodexBar'dan Çık";
+
+/* Tab titles */
+"tab_general" = "Genel";
+"tab_providers" = "Sağlayıcılar";
+"tab_display" = "Görünüm";
+"tab_advanced" = "Gelişmiş";
+"tab_about" = "Hakkında";
+"tab_debug" = "Hata Ayıklama";
+
+/* Providers Pane */
+"select_a_provider" = "Bir sağlayıcı seçin";
+"cancel" = "İptal";
+"last_fetch_failed" = "son getirme başarısız";
+"usage_not_fetched_yet" = "kullanım henüz getirilmedi";
+"managed_account_storage_unreadable" = "Yönetilen hesap depolaması okunamıyor. Canlı hesap erişimi hâlâ kullanılabilir, ancak depo kurtarılana kadar yönetilen ekleme, yeniden kimlik doğrulama ve kaldırma işlemleri devre dışı bırakıldı.";
+"remove_codex_account_title" = "Codex hesabı kaldırılsın mı?";
+"remove" = "Kaldır";
+"managed_login_already_running" = "Yönetilen bir Codex girişi zaten çalışıyor. Başka bir hesap eklemeden veya yeniden kimlik doğrulamadan önce bitmesini bekleyin.";
+"managed_login_failed" = "Yönetilen Codex girişi tamamlanmadı. Terminal'de `codex --version` komutunun çalıştığını doğrulayın. macOS `codex` dosyasını engellediyse veya Çöp Kutusu'na taşıdıysa, eski yinelenen kurulumları kaldırın, `npm install -g --include=optional @openai/codex@latest` komutunu çalıştırın, ardından tekrar deneyin.";
+"codex_login_output" = "codex login çıktısı:";
+"managed_login_missing_email" = "Codex girişi tamamlandı, ancak hesap e-postası bulunamadı. Hesabın tam olarak oturum açtığını doğruladıktan sonra tekrar deneyin.";
+"login_success_notification_title" = "%@ girişi başarılı";
+"login_success_notification_body" = "Uygulamaya dönebilirsiniz; kimlik doğrulaması tamamlandı.";
+"workspace_selection_cancelled" = "CodexBar birden fazla çalışma alanı buldu, ancak hiçbir çalışma alanı seçilmedi.";
+"unsafe_managed_home" = "CodexBar beklenmeyen bir yönetilen ev yolunu değiştirmeyi reddetti: %@";
+"menu_bar_metric_title" = "Menü çubuğu metriği";
+"menu_bar_metric_subtitle" = "Menü çubuğu yüzdesini hangi pencerenin belirleyeceğini seçin.";
+"menu_bar_metric_subtitle_deepseek" = "Menü çubuğunda DeepSeek bakiyesini gösterir.";
+"menu_bar_metric_subtitle_moonshot" = "Menü çubuğunda Moonshot / Kimi API bakiyesini gösterir.";
+"menu_bar_metric_subtitle_mistral" = "Menü çubuğunda geçerli ayın Mistral API harcamasını gösterir.";
+"menu_bar_metric_subtitle_kimik2" = "Menü çubuğunda Kimi K2 API anahtarı kredilerini gösterir.";
+"automatic" = "Otomatik";
+"primary_api_key_limit" = "Birincil (API anahtarı limiti)";
+
+/* Display Pane */
+"section_menu_bar" = "Menü çubuğu";
+"merge_icons_title" = "Simgeleri Birleştir";
+"merge_icons_subtitle" = "Sağlayıcı değiştiricisiyle tek bir menü çubuğu simgesi kullan.";
+"switcher_shows_icons_title" = "Değiştirici simgeleri gösterir";
+"switcher_shows_icons_subtitle" = "Değiştiricide sağlayıcı simgelerini göster (aksi takdirde haftalık ilerleme çizgisi göster).";
+"show_most_used_provider_title" = "En çok kullanılan sağlayıcıyı göster";
+"show_most_used_provider_subtitle" = "Menü çubuğu, hız limitine en yakın sağlayıcıyı otomatik gösterir.";
+"menu_bar_shows_percent_title" = "Menü çubuğu yüzde gösterir";
+"menu_bar_shows_percent_subtitle" = "Canavar çubuklarını sağlayıcı marka simgeleri ve yüzde ile değiştir.";
+"hide_critters_title" = "Canavarları gizle";
+"hide_critters_subtitle" = "Yüz ve süslemeler olmadan düz ölçüm çubukları göster.";
+"display_mode_title" = "Görünüm modu";
+"display_mode_subtitle" = "Menü çubuğunda ne gösterileceğini seçin (Hız, kullanımı beklentiyle karşılaştırır).";
+"section_menu_content" = "Menü içeriği";
+"show_usage_as_used_title" = "Kullanımı harcanan olarak göster";
+"show_usage_as_used_subtitle" = "İlerleme çubukları kota tükettikçe dolar (kalanı göstermek yerine).";
+"show_quota_warning_markers_title" = "Kota uyarı işaretlerini göster";
+"show_quota_warning_markers_subtitle" = "Kota uyarıları yapılandırıldığında kullanım çubuklarına eşik çizgileri çizer.";
+"weekly_progress_work_days_title" = "Haftalık ilerleme iş günleri";
+"weekly_progress_work_days_subtitle" = "Haftalık kullanım çubuğu işaretleri ve tempo hesaplamaları için iş günlerini ayarlar.";
+"show_reset_time_as_clock_title" = "Sıfırlama süresini saat olarak göster";
+"show_reset_time_as_clock_subtitle" = "Sıfırlama sürelerini geri sayım yerine mutlak saat değerleri olarak göster.";
+"show_provider_changelog_links_title" = "Sağlayıcı değişiklik günlüğü bağlantılarını göster";
+"show_provider_changelog_links_subtitle" = "Desteklenen CLI destekli sağlayıcılar için menüye sürüm notları bağlantıları ekler.";
+"show_credits_extra_usage_title" = "Krediler + ekstra kullanımı göster";
+"show_credits_extra_usage_subtitle" = "Menüde Codex Kredileri ve Claude Ekstra kullanım bölümlerini göster.";
+"show_all_token_accounts_title" = "Tüm jeton hesaplarını göster";
+"show_all_token_accounts_subtitle" = "Menüde jeton hesaplarını yığınla göster (aksi takdirde hesap değiştirici çubuk göster).";
+"multi_account_layout_title" = "Çoklu hesap düzeni";
+"multi_account_layout_subtitle" = "Bölümlü hesap değiştirme veya yığınlı hesap kartları seçin.";
+"multi_account_layout_segmented" = "Bölümlü";
+"multi_account_layout_stacked" = "Yığınlı";
+"overview_tab_providers_title" = "Genel Bakış sekmesi sağlayıcıları";
+"configure" = "Yapılandır…";
+"overview_enable_merge_icons_hint" = "Genel Bakış sekmesi sağlayıcılarını yapılandırmak için Simgeleri Birleştir'i etkinleştirin.";
+"overview_no_providers_hint" = "Genel Bakış için kullanılabilir etkin sağlayıcı yok.";
+"overview_rows_follow_order" = "Genel Bakış satırları her zaman sağlayıcı sırasını takip eder.";
+"overview_no_providers_selected" = "Sağlayıcı seçilmedi";
+
+/* Advanced Pane */
+"section_keyboard_shortcut" = "Klavye kısayolu";
+"open_menu_shortcut_title" = "Menüyü aç";
+"open_menu_shortcut_subtitle" = "Menü çubuğu menüsünü herhangi bir yerden tetikleyin.";
+"install_cli" = "CLI Kur";
+"install_cli_subtitle" = "CodexBarCLI'yi codexbar olarak /usr/local/bin ve /opt/homebrew/bin dizinlerine sembolik bağlayın.";
+"cli_not_found" = "CodexBarCLI uygulama paketinde bulunamadı.";
+"no_writable_bin_dirs" = "Yazılabilir bin dizini bulunamadı.";
+"show_debug_settings_title" = "Hata Ayıklama Ayarlarını Göster";
+"show_debug_settings_subtitle" = "Sorun giderme araçlarını Hata Ayıklama sekmesinde göster.";
+"surprise_me_title" = "Beni şaşırt";
+"surprise_me_subtitle" = "Ajanlarınızın yukarıda biraz eğlenmesini istiyorsanız işaretleyin.";
+"weekly_limit_confetti_title" = "Haftalık limit konfetisi";
+"weekly_limit_confetti_subtitle" = "Haftalık kullanım sıfırlandığında tam ekran konfeti oynat.";
+"hide_personal_info_title" = "Kişisel bilgileri gizle";
+"hide_personal_info_subtitle" = "Menü çubuğu ve menü arayüzünde e-posta adreslerini gizle.";
+"show_provider_storage_usage_title" = "Sağlayıcı depolama kullanımını göster";
+"show_provider_storage_usage_subtitle" = "Menülerde yerel disk kullanımını göster. Bilinen sağlayıcıya ait yolları arka planda tarar.";
+"section_keychain_access" = "Anahtarlık erişimi";
+"keychain_access_caption" = "Tüm Anahtarlık okuma ve yazmalarını devre dışı bırakın. macOS 'Chrome/Brave/Edge Güvenli Depolama' için sürekli istem gösteriyorsa ve Her Zaman İzin Ver'e tıkladıktan sonra bile devam ediyorsa bunu kullanın. Etkinleştirildiğinde tarayıcı çerez içe aktarımı kullanılamaz; Sağlayıcılar bölümünden Çerez başlıklarını el ile yapıştırın. CLI üzerinden Claude/Codex OAuth hâlâ çalışır.";
+"disable_keychain_access_title" = "Anahtarlık erişimini devre dışı bırak";
+"disable_keychain_access_subtitle" = "Etkinleştirildiğinde tüm Anahtarlık erişimini engeller.";
+
+/* About Pane */
+"about_tagline" = "Jetonlarınız hiç bitmesin—ajan limitlerini göz önünde bulundurun.";
+"link_github" = "GitHub";
+"link_website" = "Web Sitesi";
+"link_twitter" = "Twitter";
+"link_email" = "E-posta";
+"check_updates_auto" = "Güncellemeleri otomatik denetle";
+"update_channel" = "Güncelleme Kanalı";
+"check_for_updates" = "Güncellemeleri Denetle…";
+"updates_unavailable" = "Bu derlemede güncellemeler kullanılamıyor.";
+"copyright" = "© 2026 Peter Steinberger. MIT Lisansı.";
+
+/* Debug Pane */
+"section_logging" = "Günlükleme";
+"enable_file_logging" = "Dosya günlüğünü etkinleştir";
+"enable_file_logging_subtitle" = "Hata ayıklama için günlükleri %@ konumuna yaz.";
+"verbosity_title" = "Ayrıntı düzeyi";
+"verbosity_subtitle" = "Ne kadar ayrıntının günlüğe kaydedileceğini denetler.";
+"open_log_file" = "Günlük dosyasını aç";
+"force_animation_next_refresh" = "Sonraki yenilemede animasyonu zorla";
+"force_animation_next_refresh_subtitle" = "Sonraki yenilemeden sonra yükleme animasyonunu geçici olarak gösterir.";
+"section_loading_animations" = "Yükleme animasyonları";
+"loading_animations_caption" = "Bir desen seçin ve menü çubuğunda yeniden oynatın. \"Rastgele\" mevcut davranışı korur.";
+"animation_random_default" = "Rastgele (varsayılan)";
+"replay_selected_animation" = "Seçili animasyonu yeniden oynat";
+"blink_now" = "Şimdi yanıp sön";
+"section_probe_logs" = "Sorgu günlükleri";
+"probe_logs_caption" = "Hata ayıklama için en son sorgu çıktısını getirin; Kopyala tüm metni tutar.";
+"fetch_log" = "Günlüğü getir";
+"copy" = "Kopyala";
+"save_to_file" = "Dosyaya kaydet";
+"load_parse_dump" = "Ayrıştırma dökümünü yükle";
+"rerun_provider_autodetect" = "Sağlayıcı otomatik algılamayı yeniden çalıştır";
+"loading" = "Yükleniyor…";
+"no_log_yet_fetch" = "Henüz günlük yok. Getirmek için tıklayın.";
+"section_fetch_strategy" = "Getirme stratejisi denemeleri";
+"fetch_strategy_caption" = "Bir sağlayıcı için son_getirme işlem hattı kararları ve hataları.";
+"section_openai_cookies" = "OpenAI çerezleri";
+"openai_cookies_caption" = "Son OpenAI çerez girişiminden çerez içe aktarımı + WebKit kazıma günlükleri.";
+"no_log_yet" = "Henüz günlük yok. Bir içe aktarım çalıştırmak için Sağlayıcılar → Codex bölümünde OpenAI çerezlerini güncelleyin.";
+"section_caches" = "Önbellekler";
+"caches_caption" = "Önbelleğe alınmış maliyet tarama sonuçlarını veya tarayıcı çerez önbelleklerini temizleyin.";
+"clear_cookie_cache" = "Çerez önbelleğini temizle";
+"clear_cost_cache" = "Maliyet önbelleğini temizle";
+"section_notifications" = "Bildirimler";
+"notifications_caption" = "5 saatlik oturum penceresi için test bildirimlerini tetikleyin (tükendi/geri yüklendi).";
+"post_depleted" = "Tükendi bildirimi gönder";
+"post_restored" = "Geri yüklendi bildirimi gönder";
+"section_cli_sessions" = "CLI oturumları";
+"cli_sessions_caption" = "Bir sorgudan sonra Codex/Claude CLI oturumlarını canlı tutun. Varsayılan olarak veri yakalandıktan sonra çıkılır.";
+"keep_cli_sessions_alive" = "CLI oturumlarını canlı tut";
+"keep_cli_sessions_alive_subtitle" = "Sorgular arası sökmeyi atla (yalnızca hata ayıklama).";
+"reset_cli_sessions" = "CLI oturumlarını sıfırla";
+"section_error_simulation" = "Hata simülasyonu";
+"error_simulation_caption" = "Düzen testi için menü kartına sahte bir hata mesajı enjekte edin.";
+"set_menu_error" = "Menü hatası ayarla";
+"clear_menu_error" = "Menü hatasını temizle";
+"set_cost_error" = "Maliyet hatası ayarla";
+"clear_cost_error" = "Maliyet hatasını temizle";
+"section_cli_paths" = "CLI yolları";
+"cli_paths_caption" = "Çözülmüş Codex çalıştırılabilir dosyası ve PATH katmanları; başlangıç oturum açma PATH yakalaması (kısa zaman aşımı).";
+"codex_binary" = "Codex çalıştırılabilir dosyası";
+"claude_binary" = "Claude çalıştırılabilir dosyası";
+"effective_path" = "Etkili PATH";
+"unavailable" = "Kullanılamıyor";
+"login_shell_path" = "Oturum kabuğu PATH (başlangıç yakalaması)";
+"cleared" = "Temizlendi.";
+"no_fetch_attempts" = "Henüz getirme denemesi yok.";
+"macOS Tahoe can block menu bar apps in System Settings → Menu Bar → Allow in the Menu Bar. CodexBar is running, but macOS may be hiding its icon. Open Menu Bar settings and turn CodexBar on." = "macOS Tahoe, Sistem Ayarları → Menü Çubuğu → Menü Çubuğunda İzin Ver bölümünde menü çubuğu uygulamalarını engelleyebilir. CodexBar çalışıyor, ancak macOS simgesini gizliyor olabilir. Menü Çubuğu ayarlarını açın ve CodexBar'ı etkinleştirin.";
+
+/* Metric preferences */
+"metric_pref_automatic" = "Otomatik";
+"metric_pref_primary" = "Birincil";
+"metric_pref_secondary" = "İkincil";
+"metric_pref_tertiary" = "Üçüncül";
+"metric_pref_extra_usage" = "Ekstra kullanım";
+"metric_pref_average" = "Ortalama";
+"metric_mistral_payg" = "Pay-as-you-go";
+"metric_mistral_monthly_plan" = "Monthly Plan";
+
+/* Display modes */
+"display_mode_percent" = "Yüzde";
+"display_mode_pace" = "Hız";
+"display_mode_both" = "İkisi de";
+"display_mode_percent_desc" = "Kalan/harcanan yüzdesini göster (ör. %45)";
+"display_mode_pace_desc" = "Hız göstergesini göster (ör. +%5)";
+"display_mode_both_desc" = "Hem yüzdeyi hem hızı göster (ör. %45 · +%5)";
+
+/* Provider status */
+"status_operational" = "Çalışır durumda";
+"status_partial_outage" = "Kısmi kesinti";
+"status_major_outage" = "Büyük kesinti";
+"status_critical_issue" = "Kritik sorun";
+"status_maintenance" = "Bakım";
+"status_unknown" = "Durum bilinmiyor";
+
+/* Refresh frequency */
+"refresh_manual" = "El ile";
+"refresh_1min" = "1 dak";
+"refresh_2min" = "2 dak";
+"refresh_5min" = "5 dak";
+"refresh_15min" = "15 dak";
+"refresh_30min" = "30 dak";
+
+/* Additional keys */
+"not_found" = "Bulunamadı";
+
+/* Cost estimation */
+"cost_header_estimated" = "Maliyet (tahmini)";
+"cost_estimate_hint" = "Yerel günlüklerden tahmini · faturanızdan farklı olabilir";
+"No JetBrains IDE with AI Assistant detected. Install a JetBrains IDE and enable AI Assistant." = "AI Asistan içeren JetBrains IDE algılanmadı. Bir JetBrains IDE kurun ve AI Asistan'ı etkinleştirin.";
+"OpenRouter API token not configured. Set OPENROUTER_API_KEY environment variable or configure in Settings." = "OpenRouter API jetonu yapılandırılmamış. OPENROUTER_API_KEY ortam değişkenini ayarlayın veya Ayarlar'dan yapılandırın.";
+"z.ai API token not found. Set apiKey in ~/.codexbar/config.json or Z_AI_API_KEY." = "z.ai API jetonu bulunamadı. ~/.codexbar/config.json dosyasında apiKey ayarlayın veya Z_AI_API_KEY kullanın.";
+"Missing DeepSeek API key." = "DeepSeek API anahtarı eksik.";
+"%@ is unavailable in the current environment." = "%@ geçerli ortamda kullanılamıyor.";
+"All Systems Operational" = "Tüm Sistemler Çalışır Durumda";
+"Last 30 days" = "Son 30 gün";
+"Last 30 days:" = "Son 30 gün:";
+"This month" = "Bu ay";
+"Store multiple OpenAI API keys." = "Birden fazla OpenAI API anahtarı depolayın.";
+"Admin API key" = "Yönetici API anahtarı";
+"Open billing" = "Faturalandırmayı aç";
+"Google accounts" = "Google hesapları";
+"Store multiple Antigravity Google OAuth accounts for quick switching." = "Hızlı geçiş için birden fazla Antigravity Google OAuth hesabı depolayın.";
+"Add Google Account" = "Google Hesabı Ekle";
+"Open Token Plan" = "Jeton Planını Aç";
+"Text Generation" = "Metin Üretimi";
+"Text to Speech" = "Metinden Sese";
+"Music Generation" = "Müzik Üretimi";
+"Image Generation" = "Görsel Üretimi";
+"No local data found" = "Yerel veri bulunamadı";
+"Credits unavailable; keep Codex running to refresh." = "Krediler kullanılamıyor; yenilemek için Codex'i çalışır durumda tutun.";
+"No available fetch strategy for minimax." = "MiniMax için kullanılabilir getirme stratejisi yok.";
+"No Cursor session found. Please log in to cursor.com in Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX, or Edge Canary. If you use Safari, grant CodexBar Full Disk Access in System Settings ▸ Privacy & Security. You can also sign in to Cursor from the CodexBar menu (Add / switch account)." = "Cursor oturumu bulunamadı. Lütfen Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX veya Edge Canary üzerinden cursor.com'da oturum açın. Safari kullanıyorsanız, Sistem Ayarları ▸ Gizlilik ve Güvenlik bölümünde CodexBar'a Tam Disk Erişimi verin. Cursor'a CodexBar menüsünden de oturum açabilirsiniz (Hesap ekle / değiştir).";
+"No OpenCode session cookies found in browsers." = "Tarayıcılarda OpenCode oturum çerezi bulunamadı.";
+"No available fetch strategy for %@." = "%@ için kullanılabilir getirme stratejisi yok.";
+"Today" = "Bugün";
+"Today tokens" = "Bugünkü jetonlar";
+"30d cost" = "30 günlük maliyet";
+"30d tokens" = "30 günlük jetonlar";
+"Latest tokens" = "Son jetonlar";
+"Top model" = "En çok kullanılan model";
+"Storage" = "Depolama";
+"Add Account..." = "Hesap Ekle...";
+"Usage Dashboard" = "Kullanım Paneli";
+"Status Page" = "Durum Sayfası";
+"Settings..." = "Ayarlar...";
+"About CodexBar" = "CodexBar Hakkında";
+"Quit" = "Çık";
+"Last %d day" = "Son %d gün";
+"Last %d days" = "Son %d gün";
+"%@ tokens" = "%@ jeton";
+"Latest billing day" = "Son faturalandırma günü";
+"Latest billing day (%@)" = "Son faturalandırma günü (%@)";
+"%@ left" = "%@ kaldı";
+"Resets %@" = "Sıfırlanma: %@";
+"Resets in %@" = "%@ içinde sıfırlanır";
+"Resets now" = "Şimdi sıfırlanır";
+"reset_tomorrow_format" = "yarın, %@";
+"Lasts until reset" = "Sıfırlamaya kadar sürer";
+"Updated %@" = "Güncellendi: %@";
+"Updated %@h ago" = "%@ saat önce güncellendi";
+"Updated %@m ago" = "%@ dakika önce güncellendi";
+"Updated just now" = "Az önce güncellendi";
+"Projected empty in %@" = "%@ içinde tükenmesi tahmin ediliyor";
+"Runs out in %@" = "%@ içinde biter";
+"Pace: %@" = "Hız: %@";
+"Pace: %@ · %@" = "Hız: %@ · %@";
+"%@ · %@" = "%@ · %@";
+"≈ %d%% run-out risk" = "≈ %%%d tükenme riski";
+"%d%% in deficit" = "%%%d açıkta";
+"%d%% in reserve" = "%%%d rezervde";
+"usage_percent_suffix_left" = "kaldı";
+"usage_percent_suffix_used" = "kullanıldı";
+"Store multiple DeepSeek API keys." = "Birden fazla DeepSeek API anahtarı depolayın.";
+"This week" = "Bu hafta";
+"Week" = "Hafta";
+"Month" = "Ay";
+"Models" = "Modeller";
+"24h tokens" = "24 saatlik jetonlar";
+"Latest hour" = "Son saat";
+"Peak hour" = "Yoğun saat";
+"Top method" = "En çok kullanılan yöntem";
+"30d cash" = "30 günlük nakit";
+"30d billing history from MiniMax web session" = "MiniMax web oturumundan 30 günlük faturalandırma geçmişi";
+"AWS Cost Explorer billing can lag." = "AWS Cost Explorer faturalandırması gecikmeli olabilir.";
+"Rate limit: %d / %@" = "Hız limiti: %d / %@";
+"Key remaining" = "Anahtar kalan";
+"No limit set for the API key" = "API anahtarı için limit ayarlanmamış";
+"API key limit unavailable right now" = "API anahtarı limiti şu anda kullanılamıyor";
+"This month: %@ tokens" = "Bu ay: %@ jeton";
+"No utilization data yet." = "Henüz kullanım verisi yok.";
+"No %@ utilization data yet." = "Henüz %@ kullanım verisi yok.";
+"%@: %@%% used" = "%@: %@%% kullanıldı";
+"%dd" = "%d gün";
+"today" = "bugün";
+"just now" = "az önce";
+"On pace" = "Hızda";
+"Runs out now" = "Şimdi biter";
+"Projected empty now" = "Şimdi tükenmesi tahmin ediliyor";
+"Switch Account..." = "Hesap Değiştir...";
+"Update ready, restart now?" = "Güncelleme hazır, şimdi yeniden başlatılsın mı?";
+"Daily" = "Günlük";
+"Hourly Tokens" = "Saatlik Jetonlar";
+"No data" = "Veri yok";
+"No usage breakdown data available." = "Kullanılabilir kullanım dağılım verisi yok.";
+
+"Today: %@ · %@ tokens" = "Bugün: %@ · %@ jeton";
+"Today: %@" = "Bugün: %@";
+"Today: %@ tokens" = "Bugün: %@ jeton";
+"Last 30 days: %@ · %@ tokens" = "Son 30 gün: %@ · %@ jeton";
+"Last 30 days: %@" = "Son 30 gün: %@";
+"Est. total (30d): %@" = "Tah. toplam (30 gün): %@";
+"Est. total (%@): %@" = "Tah. toplam (%@): %@";
+"Hover a bar for details" = "Ayrıntılar için bir çubuğun üzerine gelin";
+"%@: %@ · %@ tokens" = "%@: %@ · %@ jeton";
+"No providers selected for Overview." = "Genel Bakış için sağlayıcı seçilmedi.";
+"No overview data available." = "Kullanılabilir genel bakış verisi yok.";
+"Auto uses the local IDE API first, then Google OAuth when the IDE is closed." = "Otomatik mod önce yerel IDE API'sini kullanır, IDE kapatıldığında Google OAuth'a geçer.";
+"Login with Google" = "Google ile Giriş Yap";
+
+/* Popup panels */
+"No usage configured." = "Kullanım yapılandırılmamış.";
+"Quota" = "Kota";
+"tokens" = "jeton";
+"requests" = "istek";
+"Latest" = "Son";
+"Monthly" = "Aylık";
+"Sonnet" = "Sonnet";
+"Overages" = "Aşmalar";
+"Activity" = "Etkinlik";
+"Copied" = "Kopyalandı";
+"Copy error" = "Hata kopyala";
+"Copy path" = "Yolu kopyala";
+"Extra usage spent" = "Harcanan ekstra kullanım";
+"Credits remaining" = "Kalan krediler";
+"Using CLI fallback" = "CLI yedek kullanılıyor";
+"Balance updates in near-real time (up to 5 min lag)" = "Bakiye neredeyse gerçek zamanlı güncellenir (en fazla 5 dk gecikme)";
+"Daily billing data finalizes at 07:00 UTC" = "Günlük faturalandırma verisi 07:00 UTC'de kesinleşir";
+"%@ of %@ credits left" = "%@ / %@ kredi kaldı";
+"%@ of %@ bonus credits left" = "%@ / %@ bonus kredi kaldı";
+"%@ / %@ (%@ remaining)" = "%@ / %@ (%@ kaldı)";
+"%@/%@ left" = "%@/%@ kaldı";
+"Gemini Flash" = "Gemini Flash";
+"Regenerates %@" = "Yenilenme: %@";
+"used after next regen" = "sonraki yenilemeden sonra kullanıldı";
+"after next regen" = "sonraki yenilemeden sonra";
+"Near full" = "Neredeyse dolu";
+"Full in ~1 regen" = "~1 yenilemede dolacak";
+"Full in ~%.0f regens" = "~%.0f yenilemede dolacak";
+"Overage usage" = "Aşım kullanımı";
+"Overage cost" = "Aşım maliyeti";
+"credits" = "kredi";
+"Zen balance" = "Zen bakiye";
+"API spend" = "API harcaması";
+"Extra usage" = "Ekstra kullanım";
+"Quota usage" = "Kota kullanımı";
+"Your spend" = "Harcamanız";
+"%.0f%% used" = "%%%.0f kullanıldı";
+"Usage history (today)" = "Kullanım geçmişi (bugün)";
+"Usage history (%d days)" = "Kullanım geçmişi (%d gün)";
+"%d percent remaining" = "%%%d kaldı";
+"Unknown" = "Bilinmiyor";
+"stale data" = "eski veri";
+"No credits history data." = "Kredi geçmişi verisi yok.";
+"No credits history data available." = "Kullanılabilir kredi geçmişi verisi yok.";
+"Credits history chart" = "Kredi geçmişi grafiği";
+"%d days of credits data" = "%d günlük kredi verisi";
+"Usage breakdown chart" = "Kullanım dağılım grafiği";
+"%d days of usage data across %d services" = "%d hizmet için %d günlük kullanım verisi";
+"Cost history chart" = "Maliyet geçmişi grafiği";
+"%d days of cost data" = "%d günlük maliyet verisi";
+"Plan utilization chart" = "Plan kullanım grafiği";
+"%d utilization samples" = "%d kullanım örneği";
+"Hourly Usage" = "Saatlik Kullanım";
+"Usage remaining" = "Kalan kullanım";
+"Usage used" = "Harcanan kullanım";
+"API key verified. Ollama does not expose Cloud quota limits through the API." = "API anahtarı doğrulandı. Ollama, Cloud kota limitlerini API üzerinden göstermez.";
+"Last 30 days: %@ tokens" = "Son 30 gün: %@ jeton";
+"7d spend" = "7 günlük harcama";
+"30d spend" = "30 günlük harcama";
+"Cache read" = "Önbellek okuması";
+"Claude Admin API 30 day spend trend" = "Claude Yönetici API 30 günlük harcama trendi";
+"OpenRouter API key spend trend" = "OpenRouter API anahtarı harcama trendi";
+"z.ai hourly token trend" = "z.ai saatlik jeton trendi";
+"MiniMax 30 day token usage trend" = "MiniMax 30 günlük jeton kullanım trendi";
+"Today cash" = "Bugünkü nakit";
+"DeepSeek 30 day token usage trend" = "DeepSeek 30 günlük jeton kullanım trendi";
+"cache-hit input" = "önbellek-isabetli girdi";
+"cache-miss input" = "önbellek-kaçan girdi";
+"output" = "çıktı";
+"Requests" = "İstekler";
+"Reported by OpenAI Admin API organization usage." = "OpenAI Yönetici API kuruluş kullanımı tarafından bildirildi.";
+"Reported by Mistral billing usage." = "Mistral faturalandırma kullanımı tarafından bildirildi.";
+"Google OAuth" = "Google OAuth";
+"Add accounts via GitHub OAuth Device Flow on the selected host." = "Seçili sunucuda GitHub OAuth Cihaz Akışı ile hesap ekleyin.";
+"Stores each signed-in Google account for quick Antigravity switching. Uses Antigravity.app OAuth when available, or ANTIGRAVITY_OAUTH_CLIENT_ID and ANTIGRAVITY_OAUTH_CLIENT_SECRET as an override." = "Hızlı Antigravity geçişi için oturum açmış her Google hesabını depolar. Kullanılabilir olduğunda Antigravity.app OAuth kullanır veya geçersiz kılma olarak ANTIGRAVITY_OAUTH_CLIENT_ID ve ANTIGRAVITY_OAUTH_CLIENT_SECRET kullanır.";
+"Manual cleanup: past sessions" = "El ile temizlik: geçmiş oturumlar";
+"Clearing removes past resume, continue, and rewind history." = "Temizleme, geçmiş devam ettirme, sürdürme ve geri sarma geçmişini kaldırır.";
+"Manual cleanup: file checkpoints" = "El ile temizlik: dosya kontrol noktaları";
+"Clearing removes checkpoint restore data for previous edits." = "Temizleme, önceki düzenlemeler için kontrol noktası geri yükleme verisini kaldırır.";
+"Manual cleanup: saved plans" = "El ile temizlik: kaydedilen planlar";
+"Clearing removes old plan-mode files." = "Temizleme, eski plan modu dosyalarını kaldırır.";
+"Manual cleanup: debug logs" = "El ile temizlik: hata ayıklama günlükleri";
+"Clearing removes past debug logs." = "Temizleme, geçmiş hata ayıklama günlüklerini kaldırır.";
+"Manual cleanup: attachment cache" = "El ile temizlik: ek önbelleği";
+"Clearing removes cached large pastes or attached images." = "Temizleme, önbelleğe alınmış büyük yapıştırmaları veya eklenmiş görselleri kaldırır.";
+"Manual cleanup: session metadata" = "El ile temizlik: oturum üst verisi";
+"Clearing removes per-session environment metadata." = "Temizleme, oturum bazlı ortam üst verisini kaldırır.";
+"Manual cleanup: shell snapshots" = "El ile temizlik: kabuk anlık görüntüleri";
+"Clearing removes leftover runtime shell snapshot files." = "Temizleme, kalan çalışma zamanı kabuk anlık görüntü dosyalarını kaldırır.";
+"Manual cleanup: legacy todos" = "El ile temizlik: eski yapılacaklar";
+"Clearing removes legacy per-session task lists." = "Temizleme, eski oturum bazlı görev listelerini kaldırır.";
+"Manual cleanup: sessions" = "El ile temizlik: oturumlar";
+"Clearing removes past Codex session history." = "Temizleme, geçmiş Codex oturum geçmişini kaldırır.";
+"Manual cleanup: archived sessions" = "El ile temizlik: arşivlenmiş oturumlar";
+"Clearing removes archived Codex session history." = "Temizleme, arşivlenmiş Codex oturum geçmişini kaldırır.";
+"Manual cleanup: cache" = "El ile temizlik: önbellek";
+"Clearing removes provider-owned cached data." = "Temizleme, sağlayıcıya ait önbelleğe alınmış verileri kaldırır.";
+"Manual cleanup: logs" = "El ile temizlik: günlükler";
+"Clearing removes local diagnostic logs." = "Temizleme, yerel tanılama günlüklerini kaldırır.";
+"Manual cleanup: file history" = "El ile temizlik: dosya geçmişi";
+"Clearing removes local edit checkpoint history." = "Temizleme, yerel düzenleme kontrol noktası geçmişini kaldırır.";
+"Manual cleanup: temporary data" = "El ile temizlik: geçici veriler";
+"Clearing removes local temporary provider data." = "Temizleme, yerel geçici sağlayıcı verilerini kaldırır.";
+"Total: %@" = "Toplam: %@";
+"%d more items" = "%d öğe daha";
+"Other (%d items)" = "Diğer (%d öğe)";
+"Expand" = "Genişlet";
+"Collapse" = "Daralt";
+"Cleanup ideas" = "Temizlik önerileri";
+"%d unreadable item(s) skipped" = "%d okunamaz öğe atlandı";
+"API key limit" = "API anahtarı limiti";
+"Auth" = "Kimlik Doğr.";
+"Auto" = "Otomatik";
+"Disabled — no recent data" = "Devre dışı — son veri yok";
+"Limits not available" = "Limitler kullanılamıyor";
+"No usage yet" = "Henüz kullanım yok";
+"Not fetched yet" = "Henüz getirilmedi";
+"Refreshing" = "Yenileniyor";
+"Session" = "Oturum";
+"Source" = "Kaynak";
+"State" = "Durum";
+"Unavailable" = "Kullanılamıyor";
+"Weekly" = "Haftalık";
+"not detected" = "algılanmadı";
+"Estimated from local Codex logs for the selected account." = "Seçili hesap için yerel Codex günlüklerinden tahmin edildi.";
+"minimax_usage_amount_format" = "Kullanım: %@ / %@";
+"minimax_used_percent_format" = "%@ kullanıldı";
+"minimax_service_text_generation" = "Metin Üretimi";
+"minimax_service_text_to_speech" = "Metinden Sese";
+"minimax_service_music_generation" = "Müzik Üretimi";
+"minimax_service_image_generation" = "Görsel Üretimi";
+"minimax_service_lyrics_generation" = "Şarkı sözü üretimi";
+"minimax_service_coding_plan_vlm" = "Kodlama planı VLM";
+"minimax_service_coding_plan_search" = "Kodlama planı arama";
+
+/* Additional provider settings and alerts */
+"%@ is waiting for permission" = "%@ izin bekliyor";
+"%@ requests" = "%@ istek";
+"%@: %@ credits" = "%@: %@ kredi";
+"30d requests" = "30 günlük istekler";
+"4 days" = "4 gün";
+"5 days" = "5 gün";
+"7 days" = "7 gün";
+"API key verifies Ollama Cloud access; cookies still expose quota limits." = "API anahtarı Ollama Cloud erişimini doğrular; çerezler kota limitlerini göstermeye devam eder.";
+"AWS access key ID. Can also be set with AWS_ACCESS_KEY_ID." = "AWS erişim anahtarı kimliği. AWS_ACCESS_KEY_ID ile de ayarlanabilir.";
+"AWS region. Can also be set with AWS_REGION." = "AWS bölgesi. AWS_REGION ile de ayarlanabilir.";
+"AWS secret access key. Can also be set with AWS_SECRET_ACCESS_KEY." = "AWS gizli erişim anahtarı. AWS_SECRET_ACCESS_KEY ile de ayarlanabilir.";
+"Access key ID" = "Erişim anahtarı kimliği";
+"Add Account" = "Hesap Ekle";
+"Adding Account…" = "Hesap Ekleniyor…";
+"Antigravity login failed" = "Antigravity girişi başarısız";
+"Antigravity login timed out" = "Antigravity girişi zaman aşımına uğradı";
+"Auth source" = "Kimlik doğrulama kaynağı";
+"Automatic imports browser cookies from Xiaomi MiMo." = "Xiaomi MiMo'dan tarayıcı çerezlerini otomatik olarak içe aktarır.";
+"Automatic imports Windsurf session data from Chromium browser localStorage." = "Otomatik olarak Chromium tarayıcı yerel depolamasından Windsurf oturum verilerini içe aktarır.";
+"Automatic imports browser cookies from Bailian." = "Otomatik olarak Bailian'dan tarayıcı çerezlerini içe aktarır.";
+"Automatically imports browser cookies." = "Otomatik olarak tarayıcı çerezlerini içe aktarır.";
+"Automatically imports browser session cookies." = "Otomatik olarak tarayıcı oturum çerezlerini içe aktarır.";
+"Azure OpenAI deployment name. AZURE_OPENAI_DEPLOYMENT_NAME is also supported." = "Azure OpenAI dağıtım adı. AZURE_OPENAI_DEPLOYMENT_NAME de desteklenir.";
+"Azure OpenAI key" = "Azure OpenAI anahtarı";
+"Azure OpenAI resource endpoint. AZURE_OPENAI_ENDPOINT is also supported." = "Azure OpenAI kaynak uç noktası. AZURE_OPENAI_ENDPOINT de desteklenir.";
+"Base URL" = "Temel URL";
+"Base URL for the LLM-API-Key-Proxy instance." = "LLM-API-Key-Proxy örneği için temel URL.";
+"Browser cookies" = "Tarayıcı çerezleri";
+"Cap end" = "Kapasite sonu";
+"Cap start" = "Kapasite başlangıcı";
+"Capacity End" = "Kapasite Sonu";
+"Capacity Start" = "Kapasite Başlangıcı";
+"Changelog" = "Değişiklik Günlüğü";
+"Choose the Moonshot/Kimi API host for international or China mainland accounts." = "Uluslararası veya Çin anakarası hesapları için Moonshot/Kimi API sunucusunu seçin.";
+"CodexBar can't replace a system account that is signed in with an API key only setup." = "CodexBar, yalnızca API anahtarı ile oturum açmış bir sistem hesabını değiştiremez.";
+"CodexBar could not find saved auth for that account. Re-authenticate it and try again." = "CodexBar bu hesap için kaydedilmiş kimlik doğrulaması bulamadı. Yeniden kimlik doğrulayın ve tekrar deneyin.";
+"CodexBar could not read managed account storage. Recover the store before adding another account." = "CodexBar yönetilen hesap depolamasını okuyamadı. Başka bir hesap eklemeden önce depoyu kurtarın.";
+"CodexBar could not read saved auth for that account. Re-authenticate it and try again." = "CodexBar bu hesap için kaydedilmiş kimlik doğrulamasını okuyamadı. Yeniden kimlik doğrulayın ve tekrar deneyin.";
+"CodexBar could not read the current system account on this Mac." = "CodexBar bu Mac'teki geçerli sistem hesabını okuyamadı.";
+"CodexBar could not replace the live Codex auth on this Mac." = "CodexBar bu Mac'teki canlı Codex kimlik doğrulamasını değiştiremedi.";
+"CodexBar could not safely preserve the current system account before switching." = "CodexBar geçiş yapmadan önce geçerli sistem hesabını güvenli bir şekilde koruyamadı.";
+"CodexBar could not save the current system account before switching." = "CodexBar geçiş yapmadan önce geçerli sistem hesabını kaydedemedi.";
+"CodexBar could not update managed account storage." = "CodexBar yönetilen hesap depolamasını güncelleyemedi.";
+"CodexBar found another managed account that already uses the current system account. Resolve the duplicate account before switching." = "CodexBar, geçerli sistem hesabını zaten kullanan başka bir yönetilen hesap buldu. Geçiş yapmadan önce yinelenen hesabı çözün.";
+"CodexBar will ask macOS Keychain for “%@” so it can decrypt browser cookies and authenticate your account. Click OK to continue." = "CodexBar, tarayıcı çerezlerinin şifresini çözmek ve hesabınızı doğrulamak için macOS Anahtarlığı'ndan “%@” isteyecek. Devam etmek için Tamam'a tıklayın.";
+"CodexBar will ask macOS Keychain for the Claude Code OAuth token so it can fetch your Claude usage. Click OK to continue." = "CodexBar, Claude kullanımınızı getirmek için macOS Anahtarlığı'ndan Claude Code OAuth jetonunu isteyecek. Devam etmek için Tamam'a tıklayın.";
+"CodexBar will ask macOS Keychain for your Amp cookie header so it can fetch usage. Click OK to continue." = "CodexBar, kullanımı getirmek için macOS Anahtarlığı'ndan Amp çerez başlığınızı isteyecek. Devam etmek için Tamam'a tıklayın.";
+"CodexBar will ask macOS Keychain for your Augment cookie header so it can fetch usage. Click OK to continue." = "CodexBar, kullanımı getirmek için macOS Anahtarlığı'ndan Augment çerez başlığınızı isteyecek. Devam etmek için Tamam'a tıklayın.";
+"CodexBar will ask macOS Keychain for your Claude cookie header so it can fetch Claude web usage. Click OK to continue." = "CodexBar, Claude web kullanımını getirmek için macOS Anahtarlığı'ndan Claude çerez başlığınızı isteyecek. Devam etmek için Tamam'a tıklayın.";
+"CodexBar will ask macOS Keychain for your Cursor cookie header so it can fetch usage. Click OK to continue." = "CodexBar, kullanımı getirmek için macOS Anahtarlığı'ndan Cursor çerez başlığınızı isteyecek. Devam etmek için Tamam'a tıklayın.";
+"CodexBar will ask macOS Keychain for your Factory cookie header so it can fetch usage. Click OK to continue." = "CodexBar, kullanımı getirmek için macOS Anahtarlığı'ndan Factory çerez başlığınızı isteyecek. Devam etmek için Tamam'a tıklayın.";
+"CodexBar will ask macOS Keychain for your GitHub Copilot token so it can fetch usage. Click OK to continue." = "CodexBar, kullanımı getirmek için macOS Anahtarlığı'ndan GitHub Copilot jetonunuzu isteyecek. Devam etmek için Tamam'a tıklayın.";
+"CodexBar will ask macOS Keychain for your Kimi K2 API key so it can fetch usage. Click OK to continue." = "CodexBar, kullanımı getirmek için macOS Anahtarlığı'ndan Kimi K2 API anahtarınızı isteyecek. Devam etmek için Tamam'a tıklayın.";
+"CodexBar will ask macOS Keychain for your Kimi auth token so it can fetch usage. Click OK to continue." = "CodexBar, kullanımı getirmek için macOS Anahtarlığı'ndan Kimi kimlik doğrulama jetonunuzu isteyecek. Devam etmek için Tamam'a tıklayın.";
+"CodexBar will ask macOS Keychain for your MiniMax API token so it can fetch usage. Click OK to continue." = "CodexBar, kullanımı getirmek için macOS Anahtarlığı'ndan MiniMax API jetonunuzu isteyecek. Devam etmek için Tamam'a tıklayın.";
+"CodexBar will ask macOS Keychain for your MiniMax cookie header so it can fetch usage. Click OK to continue." = "CodexBar, kullanımı getirmek için macOS Anahtarlığı'ndan MiniMax çerez başlığınızı isteyecek. Devam etmek için Tamam'a tıklayın.";
+"CodexBar will ask macOS Keychain for your OpenAI cookie header so it can fetch Codex dashboard extras. Click OK to continue." = "CodexBar, Codex panel eklerini getirmek için macOS Anahtarlığı'ndan OpenAI çerez başlığınızı isteyecek. Devam etmek için Tamam'a tıklayın.";
+"CodexBar will ask macOS Keychain for your OpenCode cookie header so it can fetch usage. Click OK to continue." = "CodexBar, kullanımı getirmek için macOS Anahtarlığı'ndan OpenCode çerez başlığınızı isteyecek. Devam etmek için Tamam'a tıklayın.";
+"CodexBar will ask macOS Keychain for your Synthetic API key so it can fetch usage. Click OK to continue." = "CodexBar, kullanımı getirmek için macOS Anahtarlığı'ndan Synthetic API anahtarınızı isteyecek. Devam etmek için Tamam'a tıklayın.";
+"CodexBar will ask macOS Keychain for your z.ai API token so it can fetch usage. Click OK to continue." = "CodexBar, kullanımı getirmek için macOS Anahtarlığı'ndan z.ai API jetonunuzu isteyecek. Devam etmek için Tamam'a tıklayın.";
+"Could not open Cursor login in your browser." = "Tarayıcınızda Cursor girişi açılamadı.";
+"Could not open browser for Antigravity" = "Antigravity için tarayıcı açılamadı";
+"Credits used" = "Kullanılan krediler";
+"Day" = "Gün";
+"Deployment" = "Dağıtım";
+"Drag to reorder" = "Yeniden sıralamak için sürükleyin";
+"Sort providers alphabetically" = "Sağlayıcıları alfabetik sırala";
+"Sort providers alphabetically (enabled first)" = "Sağlayıcıları alfabetik sırala (etkin olanlar önce)";
+"Sorted alphabetically (enabled first) — click to use your custom order" = "Alfabetik sıralandı (etkin olanlar önce) — özel sıranızı kullanmak için tıklayın";
+"Endpoint" = "Uç nokta";
+"Enterprise host" = "Kurumsal sunucu";
+"Extra usage balance: %@" = "Ekstra kullanım bakiyesi: %@";
+"Keychain Access Required" = "Anahtarlık Erişimi Gerekli";
+"Kiro menu bar value" = "Kiro menü çubuğu değeri";
+"Label" = "Etiket";
+"No organizations loaded. Click Refresh after setting your API key." = "Kuruluş yüklenmedi. API anahtarınızı ayarladıktan sonra Yenile'ye tıklayın.";
+"No output captured." = "Çıktı yakalanmadı.";
+"No system account" = "Sistem hesabı yok";
+"Oasis-Token" = "Oasis-Token";
+"Open Augment (Log Out & Back In)" = "Augment'i Aç (Oturumu Kapat ve Tekrar Aç)";
+"Open Codebuff Dashboard" = "Codebuff Panelini Aç";
+"Open Command Code Settings" = "Command Code Ayarlarını Aç";
+"Open Crof dashboard" = "Crof Panelini Aç";
+"Open Manus" = "Manus'u Aç";
+"Open MiMo Balance" = "MiMo Bakiyesini Aç";
+"Open Moonshot Console" = "Moonshot Konsolunu Aç";
+"Open Ollama API Keys" = "Ollama API Anahtarlarını Aç";
+"Open StepFun Platform" = "StepFun Platformunu Aç";
+"Open T3 Chat Settings" = "T3 Chat Ayarlarını Aç";
+"Open Volcengine Ark Console" = "Volcengine Ark Konsolunu Aç";
+"Open legacy provider docs" = "Eski sağlayıcı belgelerini aç";
+"Open projects" = "Projeleri aç";
+"Open this URL manually to continue login:\n\n%@" = "Girişe devam etmek için bu URL'yi el ile açın:\n\n%@";
+"Optional organization ID for accounts linked to multiple Anthropic organizations." = "Birden fazla Anthropic kuruluşuna bağlı hesaplar için isteğe bağlı kuruluş kimliği.";
+"Optional. Applies to the configured Admin API key; selected token accounts do not inherit OPENAI_PROJECT_ID." = "İsteğe bağlı. Yapılandırılan Yönetici API anahtarına uygulanır; seçili jeton hesapları OPENAI_PROJECT_ID'yi devralmaz.";
+"Optional. Enter your GitHub Enterprise host, for example octocorp.ghe.com. Leave blank for github.com." = "İsteğe bağlı. GitHub Enterprise sunucunuzu girin, örneğin octocorp.ghe.com. github.com için boş bırakın.";
+"Optional. Leave blank to discover and aggregate projects visible to the API key." = "İsteğe bağlı. API anahtarına görünür projeleri keşfetmek ve toplamak için boş bırakın.";
+"Org ID (optional)" = "Kuruluş Kimliği (isteğe bağlı)";
+"Organizations" = "Kuruluşlar";
+"Password" = "Parola";
+"%@ authentication is disabled." = "%@ kimlik doğrulaması devre dışı.";
+"%@ cookies are disabled." = "%@ çerezleri devre dışı.";
+"%@ web API access is disabled." = "%@ web API erişimi devre dışı.";
+"Disable %@ dashboard cookie usage." = "%@ panel çerez kullanımını devre dışı bırak.";
+"Keychain access is disabled in Advanced, so browser cookie import is unavailable." = "Anahtarlık erişimi Gelişmiş bölümünde devre dışı bırakıldı, bu nedenle tarayıcı çerez içe aktarımı kullanılamıyor.";
+"Manually paste an %@ from a browser session." = "Bir tarayıcı oturumundan %@ yapıştırın.";
+"Paste a Cookie header captured from %@." = "%@ üzerinden yakalanan bir Çerez başlığı yapıştırın.";
+"Paste a Cookie header from %@." = "%@ üzerinden bir Çerez başlığı yapıştırın.";
+"Paste a Cookie header or cURL capture from %@." = "%@ üzerinden bir Çerez başlığı veya cURL yakalaması yapıştırın.";
+"Paste a Cookie header or full cURL capture from %@." = "%@ üzerinden bir Çerez başlığı veya tam cURL yakalaması yapıştırın.";
+"Paste a Cookie or Authorization header from %@." = "%@ üzerinden bir Çerez veya Yetkilendirme başlığı yapıştırın.";
+"Paste a full cookie header or the %@ value." = "Tam bir çerez başlığı veya %@ değerini yapıştırın.";
+"Paste a Cookie header or full cURL capture from T3 Chat settings." = "T3 Chat ayarlarından bir Çerez başlığı veya tam cURL yakalaması yapıştırın.";
+"Paste the Cookie header from a request to admin.mistral.ai. Must contain an ory_session_* cookie." = "admin.mistral.ai'a yapılan bir istekten Çerez başlığını yapıştırın. Bir ory_session_* çerezi içermelidir.";
+"Paste the Oasis-Token from a logged-in browser session on platform.stepfun.com." = "platform.stepfun.com'da oturum açmış bir tarayıcı oturumundan Oasis-Token yapıştırın.";
+"Paste the %@ JSON bundle from %@." = "%@ üzerinden %@ JSON paketini yapıştırın.";
+"Paste the %@ value or a full Cookie header." = "%@ değerini veya tam bir Çerez başlığı yapıştırın.";
+"Personal account" = "Kişisel hesap";
+"Project ID" = "Proje Kimliği";
+"Re-auth" = "Yeniden doğrula";
+"Re-authenticating…" = "Yeniden doğrulanıyor…";
+"Refresh Session" = "Oturumu Yenile";
+"Refresh organizations" = "Kuruluşları yenile";
+"Region" = "Bölge";
+"Reload" = "Yeniden yükle";
+"Reorder" = "Yeniden sırala";
+"Secret access key" = "Gizli erişim anahtarı";
+"Series" = "Seri";
+"Service" = "Hizmet";
+"Show or hide Kiro credits, percent, or both next to the menu bar icon." = "Menü çubuğu simgesinin yanında Kiro kredilerini, yüzdeyi veya ikisini birden göster veya gizle.";
+"Show usage for organizations you belong to. Personal account is always shown." = "Üye olduğunuz kuruluşların kullanımını göster. Kişisel hesap her zaman gösterilir.";
+"Sign in to cursor.com in your browser, then refresh Cursor in CodexBar." = "Tarayıcınızda cursor.com'da oturum açın, ardından CodexBar'da Cursor'ı yenileyin.";
+"Simulated error text" = "Simüle edilmiş hata metni";
+"StepFun platform account (phone number or email)." = "StepFun platform hesabı (telefon numarası veya e-posta).";
+"Stored in ~/.codexbar/config.json." = "~/.codexbar/config.json dosyasında depolandı.";
+"Stored in ~/.codexbar/config.json. AZURE_OPENAI_API_KEY is also supported." = "~/.codexbar/config.json dosyasında depolandı. AZURE_OPENAI_API_KEY de desteklenir.";
+"Stored in ~/.codexbar/config.json. For the official Kimi API, use Moonshot / Kimi API." = "~/.codexbar/config.json dosyasında depolandı. Resmi Kimi API'si için Moonshot / Kimi API kullanın.";
+"Stored in ~/.codexbar/config.json. Get your API key from the Volcengine Ark console." = "~/.codexbar/config.json dosyasında depolandı. API anahtarınızı Volcengine Ark konsolundan alın.";
+"Stored in ~/.codexbar/config.json. Get your key from Ollama settings." = "~/.codexbar/config.json dosyasında depolandı. Anahtarınızı Ollama ayarlarından alın.";
+"Stored in ~/.codexbar/config.json. Get your key from console.deepgram.com." = "~/.codexbar/config.json dosyasında depolandı. Anahtarınızı console.deepgram.com'dan alın.";
+"Stored in ~/.codexbar/config.json. Get your key from elevenlabs.io/app/settings/api-keys." = "~/.codexbar/config.json dosyasında depolandı. Anahtarınızı elevenlabs.io/app/settings/api-keys adresinden alın.";
+"Stored in ~/.codexbar/config.json. Get your key from openrouter.ai/settings/keys and set a key spending limit there to enable API key quota tracking." = "~/.codexbar/config.json dosyasında depolandı. Anahtarınızı openrouter.ai/settings/keys adresinden alın ve API anahtarı kota izlemeyi etkinleştirmek için orada bir anahtar harcama limiti ayarlayın.";
+"Stored in ~/.codexbar/config.json. In Warp, open Settings > Platform > API Keys, then create one." = "~/.codexbar/config.json dosyasında depolandı. Warp'ta Ayarlar > Platform > API Anahtarları'nı açın, ardından bir tane oluşturun.";
+"Stored in ~/.codexbar/config.json. Metrics require Groq Enterprise Prometheus access." = "~/.codexbar/config.json dosyasında depolandı. Metrikler Groq Enterprise Prometheus erişimi gerektirir.";
+"Stored in ~/.codexbar/config.json. OPENAI_ADMIN_KEY is preferred; OPENAI_API_KEY still works." = "~/.codexbar/config.json dosyasında depolandı. OPENAI_ADMIN_KEY tercih edilir; OPENAI_API_KEY hâlâ çalışır.";
+"Stored in ~/.codexbar/config.json. Requires an Anthropic Admin API key." = "~/.codexbar/config.json dosyasında depolandı. Anthropic Yönetici API anahtarı gerektirir.";
+"Stored in ~/.codexbar/config.json. Used for /v1/quota-stats." = "~/.codexbar/config.json dosyasında depolandı. /v1/quota-stats için kullanılır.";
+"Stored in ~/.codexbar/config.json. You can also provide CODEBUFF_API_KEY or let CodexBar read ~/.config/manicode/credentials.json (created by `codebuff login`)." = "~/.codexbar/config.json dosyasında depolandı. Ayrıca CODEBUFF_API_KEY sağlayabilir veya CodexBar'ın ~/.config/manicode/credentials.json dosyasını okumasına izin verebilirsiniz (`codebuff login` tarafından oluşturulur).";
+"Stored in ~/.codexbar/config.json. You can also provide CROF_API_KEY." = "~/.codexbar/config.json dosyasında depolandı. Ayrıca CROF_API_KEY sağlayabilirsiniz.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or ~/.local/share/kilo/auth.json (kilo.access)." = "~/.codexbar/config.json dosyasında depolandı. Ayrıca KILO_API_KEY veya ~/.local/share/kilo/auth.json (kilo.access) sağlayabilirsiniz.";
+"T3 Chat cookie" = "T3 Chat çerezi";
+"That account is no longer available in CodexBar. Refresh the account list and try again." = "Bu hesap artık CodexBar'da kullanılamıyor. Hesap listesini yenileyin ve tekrar deneyin.";
+"The browser login did not complete in time. Try Antigravity login again." = "Tarayıcı girişi zamanında tamamlanmadı. Antigravity girişini tekrar deneyin.";
+"Timed out waiting for Cursor login. %@" = "Cursor girişi beklenirken zaman aşımı. %@";
+"Timed out waiting for Cursor login. %@ Last error: %@" = "Cursor girişi beklenirken zaman aşımı. %@ Son hata: %@";
+"Today requests" = "Bugünkü istekler";
+"Total (30d): %@ credits" = "Toplam (30 gün): %@ kredi";
+"Username" = "Kullanıcı adı";
+"Uses username + password to login and obtain an Oasis-Token automatically." = "Oturum açmak ve otomatik olarak bir Oasis-Token almak için kullanıcı adı + parola kullanır.";
+"Uses username + password to login and obtain an %@ automatically." = "Oturum açmak ve otomatik olarak bir %@ almak için kullanıcı adı + parola kullanır.";
+"Utilization End" = "Kullanım Sonu";
+"Utilization Start" = "Kullanım Başlangıcı";
+"Verbosity" = "Ayrıntı düzeyi";
+"Windsurf session JSON bundle" = "Windsurf oturum JSON paketi";
+"Workspace ID" = "Çalışma Alanı Kimliği";
+"Your StepFun platform password. Used to login and obtain a session token." = "StepFun platform parolanız. Oturum açmak ve bir oturum jetonu almak için kullanılır.";
+"claude /login exited with status %d." = "claude /login %d durumuyla çıktı.";
+"codex login exited with status %d." = "codex login %d durumuyla çıktı.";
+"Cookie: …\n\nor paste a cURL capture from the Abacus AI dashboard" = "Çerez: …\n\nveya Abacus AI panelinden bir cURL yakalaması yapıştırın";
+"Cookie: …\n\nor paste the __Secure-next-auth.session-token value" = "Çerez: …\n\nveya __Secure-next-auth.session-token değerini yapıştırın";
+"Cookie: …\n\nor paste the kimi-auth token value" = "Çerez: …\n\nveya kimi-auth jeton değerini yapıştırın";
+"session_id=...\n\nor paste just the session_id value" = "session_id=...\n\nveya yalnızca session_id değerini yapıştırın";
+"Clear" = "Temizle";
+"No matching providers" = "Eşleşen sağlayıcı yok";
+"Search providers" = "Sağlayıcı ara";
+"Re-login at claude.ai" = "claude.ai'da yeniden oturum aç";
+"Request quota: %@ / %@" = "İstek kotası: %@ / %@";
+"display_mode_reset_time" = "Sıfırlama zamanı";
+"display_mode_reset_time_desc" = "Seçilen metrik için sıfırlama zamanını göster (örn. ↻ 15:56)";
+"terminal_app_title" = "Varsayılan Terminal";
+"terminal_app_subtitle" = "Terminali Aç eyleminde kullanılan terminal";
+"language_arabic" = "العربية";
+"language_persian" = "فارسی";
+"language_thai" = "ไทย";
+"Limit Reset Credits" = "Limit Sıfırlama Kredileri";
+"1 manual reset available" = "1 manuel sıfırlama kullanılabilir";
+"%d manual resets available" = "%d manuel sıfırlama kullanılabilir";
+"Next expires %@" = "Sonraki sona erme %@";
+"byte_unit_byte" = "bayt";
+"byte_unit_bytes" = "bayt";
+"byte_unit_kilobyte" = "kilobayt";
+"byte_unit_kilobytes" = "kilobayt";
+"byte_unit_megabyte" = "megabayt";
+"byte_unit_megabytes" = "megabayt";
+"byte_unit_gigabyte" = "gigabayt";
+"byte_unit_gigabytes" = "gigabayt";
diff --git a/Sources/CodexBar/Resources/uk.lproj/Localizable.strings b/Sources/CodexBar/Resources/uk.lproj/Localizable.strings
new file mode 100644
index 0000000000..ee73c7afd9
--- /dev/null
+++ b/Sources/CodexBar/Resources/uk.lproj/Localizable.strings
@@ -0,0 +1,1105 @@
+/* Ukrainian localization for CodexBar */
+
+" providers" = "провайдерів";
+"(System)" = "(Система)";
+"30d" = "30д";
+"A managed Codex login is already running. Wait for it to finish before adding " = "Керований вхід до Codex вже запущено. Перш ніж додавати, зачекайте, поки він закінчиться";
+"API key" = "Ключ API";
+"API region" = "регіон API";
+"API token" = "Маркер API";
+"API tokens" = "маркери API";
+"About" = "Про програму";
+"Account" = "Обліковий запис";
+"Accounts" = "Облікові записи";
+"Accounts subtitle" = "Підзаголовок облікових записів";
+"Active" = "Активний";
+"Add" = "Додати";
+"Add Workspace" = "Додати робочу область";
+"Advanced" = "Розширені";
+"All" = "Усі";
+"Always allow prompts" = "Завжди дозволяти підказки";
+"Animation pattern" = "Шаблон анімації";
+"Antigravity login is managed in the app" = "Вхід в Antigravity керується в додатку";
+"Applies only to the Security.framework OAuth keychain reader." = "Застосовується лише до зчитувача брелоків OAuth Security.framework.";
+"Auto falls back to the next source if the preferred one fails." = "Автоматичний перехід до наступного джерела, якщо бажане не вдається.";
+"Auto uses API first, then falls back to CLI on auth failures." = "Auto спочатку використовує API, а потім повертається до CLI у разі помилок авторизації.";
+"Auto-detect" = "Автоматичне визначення";
+"Auto-refresh is off; use the menu's Refresh command." = "Автооновлення вимкнено; скористайтеся командою меню «Оновити».";
+"Auto-refresh: hourly · Timeout: 10m" = "Автоматичне оновлення: щогодини · Час очікування: 10 хв";
+"Automatic" = "Автоматично";
+"Automatic imports browser cookies and WorkOS tokens." = "Автоматично імпортує файли cookie браузера та маркери WorkOS.";
+"Automatic imports browser cookies and local storage tokens." = "Автоматично імпортує файли cookie браузера та маркери локального зберігання.";
+"Automatic imports browser cookies for dashboard extras." = "Автоматично імпортує файли cookie браузера для додаткових функцій панелі інструментів.";
+"Automatic imports browser cookies for the web API." = "Автоматично імпортує файли cookie браузера для веб-API.";
+"Automatic imports browser cookies from Model Studio/Bailian." = "Автоматично імпортує файли cookie браузера з Model Studio/Bailian.";
+"Automatic imports browser cookies from admin.mistral.ai." = "Автоматично імпортує файли cookie браузера з admin.mistral.ai.";
+"Automatic imports browser cookies from opencode.ai." = "Автоматично імпортує файли cookie браузера з opencode.ai.";
+"Automatic imports browser cookies or stored sessions." = "Автоматично імпортує файли cookie браузера або збережені сесії.";
+"Automatic imports browser cookies." = "Автоматично імпортує файли cookie браузера.";
+"Automatically imports browser session cookie." = "Автоматично імпортує файл cookie сесії браузера.";
+"Automatically opens CodexBar when you start your Mac." = "Автоматично відкриває CodexBar під час запуску Mac.";
+"Automation" = "Автоматизація";
+"Average (\\(label1) + \\(label2))" = "Середній (\\(label1) + \\(label2))";
+"Average (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))" = "Середній (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))";
+"Avoid Keychain prompts" = "Уникайте підказок Keychain";
+"Balance" = "Баланс";
+"Battery Saver" = "Економія батареї";
+"Bordered" = "З рамкою";
+"Build" = "Збірка";
+"Built \\(buildTimestamp)" = "Побудовано \\(buildTimestamp)";
+"Buy Credits..." = "Купити кредити...";
+"Buy Credits…" = "Купити кредити…";
+"CLI paths" = "Шляхи CLI";
+"CLI sessions" = "Сесії CLI";
+"Caches" = "Кеші";
+"Cancel" = "Скасувати";
+"Check for Updates…" = "Перевірити наявність оновлень…";
+"Check for updates automatically" = "Автоматично перевіряти наявність оновлень";
+"Check if you like your agents having some fun up there." = "Перевірте, чи подобається вам, що ваші агенти розважаються там.";
+"Check provider status" = "Перевірте статус провайдера";
+"Choose Codex workspace" = "Виберіть робочу область Codex";
+"Choose the MiniMax host (global .io or China mainland .com)." = "Виберіть хост MiniMax (глобальний .io або материковий Китай .com).";
+"Choose up to " = "Виберіть до";
+"Choose up to \\(Self.maxOverviewProviders) providers" = "Виберіть до \\(Self.maxOverviewProviders) постачальників";
+"Choose up to \\(count) providers" = "Виберіть до \\(count) постачальників";
+"Choose what to show in the menu bar (Pace shows usage vs. expected)." = "Виберіть, що відображати на панелі меню (Pace показує використання порівняно з очікуваним).";
+"Choose which Codex account CodexBar should follow." = "Виберіть, який обліковий запис Codex має дотримуватися CodexBar.";
+"Choose which window drives the menu bar percent." = "Виберіть, яке вікно керує відсотками панелі меню.";
+"Chrome" = "Chrome";
+"Claude CLI not found" = "Claude CLI не знайдено";
+"Claude binary" = "Claude бінарний";
+"Claude cookies" = "Печиво Claude";
+"Claude login failed" = "Помилка входу Claude";
+"Claude login timed out" = "Час очікування входу Claude минув";
+"Close" = "Закрити";
+"Code review" = "Огляд коду";
+"Codex CLI not found" = "Codex CLI не знайдено";
+"Codex account login already running" = "Вхід до облікового запису Codex уже запущено";
+"Codex binary" = "Двійковий код Codex";
+"Codex login failed" = "Помилка входу в Codex";
+"Codex login timed out" = "Час очікування входу в Codex минув";
+"CodexBar Lifecycle Keepalive" = "Життєвий цикл CodexBar Keepalive";
+"CodexBar can't show its menu bar icon" = "CodexBar не може показати піктограму панелі меню";
+"CodexBar could not read managed account storage. " = "CodexBar не вдалося прочитати сховище керованого облікового запису.";
+"Configure…" = "Налаштувати…";
+"Connected" = "Підключено";
+"Controls how much detail is logged." = "Контролює, скільки деталей реєструється.";
+"Cookie header" = "Заголовок файлу cookie";
+"Cookie source" = "Джерело файлів cookie";
+"Cookie: ..." = "Печиво: ...";
+"Cookie: \\u{2026}\\\n\\\nor paste a cURL capture from the Abacus AI dashboard" = "Файл cookie: \\u{2026}\\\n\\\nабо вставте запис cURL із інформаційної панелі Abacus AI";
+"Cookie: \\u{2026}\\\n\\\nor paste the __Secure-next-auth.session-token value" = "Файл cookie: \\u{2026}\\\n\\\nабо вставте значення __Secure-next-auth.session-token";
+"Cookie: \\u{2026}\\\n\\\nor paste the kimi-auth token value" = "Файл cookie: \\u{2026}\\\n\\\nабо вставте значення маркера kimi-auth";
+"Cookie: …" = "Печиво: …";
+"CopilotDeviceFlow" = "CopilotDeviceFlow";
+"Cost" = "Вартість";
+"Could not add Codex account" = "Не вдалося додати обліковий запис Codex";
+"Could not open Terminal for Gemini" = "Не вдалося відкрити термінал для Gemini";
+"Could not start claude /login" = "Не вдалося запустити claude /login";
+"Could not start codex login" = "Не вдалося розпочати вхід до Codex";
+"Could not switch system account" = "Не вдалося змінити обліковий запис системи";
+"Credits" = "Кредити";
+"Individual credits" = "Особисті кредити";
+"Workspace" = "Робоча область";
+"Credits history" = "Кредитна історія";
+"Cursor login failed" = "Помилка входу в систему курсору";
+"Custom" = "Користувацький";
+"Custom Path" = "Спеціальний шлях";
+"Daily Routines" = "Розпорядок дня";
+"Debug" = "Налагодження";
+"Default" = "Типово";
+"Disable Keychain access" = "Вимкнути доступ Keychain";
+"Disabled" = "Вимкнено";
+"Dismiss" = "Закрити";
+"Disconnected" = "Відключено";
+"Display" = "Відображення";
+"Display mode" = "Режим відображення";
+"Display reset times as absolute clock values instead of countdowns." = "Відображення часу скидання як абсолютних значень годинника замість зворотного відліку.";
+"Done" = "Готово";
+"Effective PATH" = "Ефективний ШЛЯХ";
+"Email" = "Ел. пошта";
+"Enable Merge Icons to configure Overview tab providers." = "Увімкніть Merge Icons, щоб налаштувати постачальників вкладок «Огляд».";
+"Enable file logging" = "Увімкнути журналювання файлів";
+"Enabled" = "Увімкнено";
+"Error" = "Помилка";
+"Error simulation" = "Симуляція помилок";
+"Expose troubleshooting tools in the Debug tab." = "Розкрийте інструменти усунення несправностей на вкладці Debug.";
+"Failed" = "Помилка";
+"False" = "Неправда";
+"Fetch strategy attempts" = "Спроби отримання стратегії";
+"Fetching" = "Отримання";
+"Field" = "Поле";
+"Field subtitle" = "Підзаголовок поля";
+"Finish the current managed account change before switching the system account." = "Завершіть зміну поточного керованого облікового запису, перш ніж змінювати обліковий запис системи.";
+"Force animation on next refresh" = "Примусово запускати анімацію під час наступного оновлення";
+"Gateway region" = "Регіон шлюзу";
+"Gemini CLI not found" = "Gemini CLI не знайдено";
+"Gemini/Antigravity, surfacing incidents in the icon and menu." = "Gemini/Antigravity, інциденти на поверхні в іконці та меню.";
+"General" = "Загальні";
+"GitHub" = "GitHub";
+"GitHub Copilot Login" = "Логін GitHub Copilot";
+"GitHub Login" = "Вхід на GitHub";
+"Hide details" = "Приховати деталі";
+"Hide personal information" = "Приховати особисту інформацію";
+"Historical tracking" = "Історичне відстеження";
+"How often CodexBar polls providers in the background." = "Як часто CodexBar опитує постачальників у фоновому режимі.";
+"Inactive" = "Неактивний";
+"Install CLI" = "Встановіть CLI";
+"Install the Claude CLI (npm i -g @anthropic-ai/claude-code) and try again." = "Встановіть CLAude CLI (npm i -g @anthropic-ai/claude-code) і повторіть спробу.";
+"Install the Codex CLI (npm i -g @openai/codex) and try again." = "Встановіть Codex CLI (npm i -g @openai/codex) і повторіть спробу.";
+"Install the Gemini CLI (npm i -g @google/gemini-cli) and try again." = "Установіть Gemini CLI (npm i -g @google/gemini-cli) і повторіть спробу.";
+"JetBrains AI is ready" = "JetBrains AI готовий";
+"JetBrains IDE" = "JetBrains IDE";
+"Keep CLI sessions alive" = "Підтримуйте сесії CLI";
+"Keyboard shortcut" = "Комбінація клавіш";
+"Keychain access" = "Доступ через брелок";
+"Keychain prompt policy" = "Політика оперативного брелока";
+"Last \\(name) fetch failed:" = "Помилка останнього \\(name) отримання:";
+"Last \\(self.store.metadata(for: self.provider).displayName) fetch failed:" = "Помилка отримання останнього \\(self.store.metadata(for: self.provider).displayName):";
+"Last attempt" = "Остання спроба";
+"Link" = "Посилання";
+"Loading animations" = "Завантаження анімацій";
+"Loading…" = "Завантаження…";
+"Local" = "Місцевий";
+"Logging" = "Лісозаготівля";
+"Login failed" = "Помилка входу";
+"Login shell PATH (startup capture)" = "ШЛЯХ до оболонки входу (запис під час запуску)";
+"Login timed out" = "Час входу минув";
+"MCP details" = "Деталі MCP";
+"Managed Codex accounts unavailable" = "Керовані облікові записи Codex недоступні";
+"Managed account storage is unreadable. Live account access is still available, " = "Сховище керованого облікового запису не читається. Доступ до реального облікового запису все ще доступний,";
+"Manual" = "Вручну";
+"May your tokens never run out—keep agent limits in view." = "Нехай ваші токени ніколи не закінчаться — пам’ятайте про ліміти агентів.";
+"Menu bar" = "Рядок меню";
+"Menu bar auto-shows the provider closest to its rate limit." = "Рядок меню автоматично показує постачальника, який найближче до ліміту.";
+"Menu bar metric" = "Метрика панелі меню";
+"Menu bar shows percent" = "Рядок меню показує відсотки";
+"Menu content" = "Зміст меню";
+"Merge Icons" = "Злиття значків";
+"Never prompt" = "Ніколи не підказуйте";
+"No" = "Ні";
+"No Codex accounts detected yet." = "Облікових записів Codex ще не виявлено.";
+"No JetBrains IDE detected" = "JetBrains IDE не виявлено";
+"No cost history data." = "Немає даних історії витрат.";
+"No data available" = "Немає даних";
+"No data yet" = "Даних ще немає";
+"No enabled providers available for Overview." = "Немає активованих постачальників, доступних для огляду.";
+"No providers selected" = "Не вибрано жодного постачальника";
+"No token accounts yet." = "Жетонів ще немає.";
+"No usage breakdown data." = "Немає даних про використання.";
+"None" = "Жодного";
+"Notifications" = "Сповіщення";
+"Notifies when the 5-hour session quota hits 0% and when it becomes " = "Повідомляє, коли 5-годинна квота сеансу досягає 0% і коли вона стає";
+"OK" = "OK";
+"Obscure email addresses in the menu bar and menu UI." = "Незрозумілі адреси електронної пошти на панелі меню та інтерфейсі меню.";
+"Off" = "Вимкнено";
+"Offline" = "Офлайн";
+"On" = "Увімкнено";
+"Online" = "Онлайн";
+"Only on user action" = "Тільки за діями користувача";
+"Open" = "Відкрити";
+"Open API Keys" = "Відкрити ключі API";
+"Open Amp Settings" = "Відкрийте налаштування підсилювача";
+"Open Antigravity to sign in, then refresh CodexBar." = "Відкрийте Antigravity, щоб увійти, а потім оновіть CodexBar.";
+"Open Browser" = "Відкрийте браузер";
+"Open Coding Plan" = "Відкрити план кодування";
+"Open Console" = "Відкрийте консоль";
+"Open Dashboard" = "Відкрийте інформаційну панель";
+"Open Mistral Admin" = "Відкрийте Mistral Admin";
+"Open Menu Bar Settings" = "Відкрийте панель меню Параметри";
+"Open Ollama Settings" = "Відкрийте налаштування Ollama";
+"Open Terminal" = "Відкрийте термінал";
+"Open Usage Page" = "Відкрити сторінку використання";
+"Open Warp API Key Guide" = "Відкрийте посібник з ключів API Warp";
+"Open menu" = "Відкрити меню";
+"Open token file" = "Відкрити файл маркера";
+"OpenAI cookies" = "Файли cookie OpenAI";
+"OpenAI web extras" = "Веб-додатки OpenAI";
+"Option A" = "Варіант А";
+"Option B" = "Варіант Б";
+"Optional override if workspace lookup fails." = "Додаткове перевизначення, якщо пошук робочої області не вдається.";
+"Options" = "Опції";
+"Override auto-detection with a custom IDE base path" = "Замініть автоматичне виявлення власним базовим шляхом IDE";
+"Overview" = "Огляд";
+"Overview rows always follow provider order." = "Оглядові рядки завжди відповідають порядку постачальника.";
+"Overview tab providers" = "Постачальники вкладок огляду";
+"Paste API key…" = "Вставити ключ API…";
+"Paste API token…" = "Вставити маркер API…";
+"Paste key…" = "Вставити ключ…";
+"Paste sessionKey or OAuth token…" = "Вставте sessionKey або маркер OAuth…";
+"Paste the Cookie header from a request to admin.mistral.ai. " = "Вставте заголовок Cookie із запиту до admin.mistral.ai.";
+"Paste token…" = "Вставити маркер…";
+"Personal" = "Особистий";
+"Picker" = "Пікер";
+"Picker subtitle" = "Підзаголовок засобу вибору";
+"Placeholder" = "Заповнювач";
+"Plan" = "План";
+"Play full-screen confetti when weekly usage resets." = "Відтворення конфетті на весь екран, коли тижневе використання скидається.";
+"Polls OpenAI/Claude status pages and Google Workspace for " = "Опитує сторінки статусу OpenAI/Claude і Google Workspace для";
+"Prevents any Keychain access while enabled." = "Запобігає будь-якому доступу Keychain, коли ввімкнено.";
+"Primary (API key limit)" = "Основний (обмеження ключа API)";
+"Primary (\\(label))" = "Основний (\\(label))";
+"Primary (\\(metadata.sessionLabel))" = "Основний (\\(metadata.sessionLabel))";
+"Probe logs" = "Зондові журнали";
+"Progress bars fill as you consume quota (instead of showing remaining)." = "Індикатори прогресу заповнюються, коли ви витрачаєте квоту (замість відображення залишку).";
+"Provider" = "Провайдер";
+"Providers" = "Провайдери";
+"Quit CodexBar" = "Закрийте CodexBar";
+"Random (default)" = "Випадковий (за замовчуванням)";
+"Reads local usage logs. Shows today + last 30 days cost in the menu." = "Читає локальні журнали використання. Показує сьогодні + вибране вікно історії в меню.";
+"Refresh" = "Оновити";
+"Refresh cadence" = "Оновити каденцію";
+"Remote" = "Дистанційний";
+"Remove" = "Видалити";
+"Remove Codex account?" = "Видалити обліковий запис Codex?";
+"Remove \\(account.email) from CodexBar? Its managed Codex home will be deleted." = "Видалити \\(account.email) з CodexBar? Його керовану домашню сторінку Codex буде видалено.";
+"Remove \\(email) from CodexBar? Its managed Codex home will be deleted." = "Видалити \\(email) з CodexBar? Його керовану домашню сторінку Codex буде видалено.";
+"Remove selected account" = "Видалити вибраний обліковий запис";
+"Replace critter bars with provider branding icons and a percentage." = "Замініть смужки тварин на значки бренду постачальника та відсоток.";
+"Replay selected animation" = "Повторити вибрану анімацію";
+"Requires authentication via GitHub Device Flow." = "Потрібна автентифікація через GitHub Device Flow.";
+"Resets: \\(reset)" = "Скидання: \\(reset)";
+"Rolling five-hour limit" = "Рухливий п'ятигодинний ліміт";
+"Search hourly" = "Пошук щогодини";
+"Secondary (\\(label))" = "Вторинний (\\(label))";
+"Secondary (\\(metadata.weeklyLabel))" = "Вторинний (\\(metadata.weeklyLabel))";
+"Select a provider" = "Виберіть провайдера";
+"Select the IDE to monitor" = "Виберіть IDE для моніторингу";
+"Session quota notifications" = "Сповіщення про квоту сеансу";
+"Session tokens" = "Токени сесії";
+"Settings" = "Налаштування";
+"Show Codex Credits and Claude Extra usage sections in the menu." = "Показати в меню розділи використання кредитів Codex і Claude Extra.";
+"Show Debug Settings" = "Показати налаштування налагодження";
+"Show all token accounts" = "Показати всі облікові записи маркерів";
+"Show cost summary" = "Показати підсумок витрат";
+"Show credits + extra usage" = "Показати кредити + додаткове використання";
+"Show details" = "Показати деталі";
+"Show most-used provider" = "Показати постачальника, який найчастіше використовується";
+"Show provider icons in the switcher (otherwise show a weekly progress line)." = "Показувати піктограми постачальників у комутаторі (інакше показувати щотижневий рядок прогресу).";
+"Show reset time as clock" = "Показувати час скидання як годинник";
+"Show usage as used" = "Показати використання як використане";
+"Sign in via button below" = "Увійдіть за допомогою кнопки нижче";
+"Skip teardown between probes (debug-only)." = "Пропустити демонтаж між зондами (лише для налагодження).";
+"Stack token accounts in the menu (otherwise show an account switcher bar)." = "Облікові записи маркерів стека в меню (інакше відображати панель перемикання облікових записів).";
+"Start at Login" = "Почніть із входу";
+"Status" = "Статус";
+"Store Claude sessionKey cookies or OAuth access tokens." = "Зберігайте файли cookie Claude sessionKey або маркери доступу OAuth.";
+"Store multiple Abacus AI Cookie headers." = "Зберігайте кілька заголовків файлів cookie Abacus AI.";
+"Store multiple Augment Cookie headers." = "Зберігайте кілька заголовків Augment Cookie.";
+"Store multiple Cursor Cookie headers." = "Зберігайте кілька заголовків Cursor Cookie.";
+"Store multiple Factory Cookie headers." = "Зберігайте кілька заголовків Factory Cookie.";
+"Store multiple MiniMax Cookie headers." = "Зберігайте кілька заголовків MiniMax Cookie.";
+"Store multiple Mistral Cookie headers." = "Зберігайте кілька заголовків Mistral Cookie.";
+"Store multiple Ollama Cookie headers." = "Зберігайте кілька заголовків файлів cookie Ollama.";
+"Store multiple OpenCode Cookie headers." = "Зберігайте кілька заголовків файлів cookie OpenCode.";
+"Store multiple OpenCode Go Cookie headers." = "Зберігайте кілька заголовків OpenCode Go Cookie.";
+"Stored in the CodexBar config file." = "Зберігається у конфігураційному файлі CodexBar.";
+"Stored in ~/.codexbar/config.json. " = "Зберігається в ~/.codexbar/config.json.";
+"Stored in ~/.codexbar/config.json. Generate one at kimi-k2.ai." = "Зберігається в ~/.codexbar/config.json. Згенеруйте його на kimi-k2.ai.";
+"Stored in ~/.codexbar/config.json. Paste the key from the Synthetic dashboard." = "Зберігається в ~/.codexbar/config.json. Вставте ключ із панелі приладів Synthetic.";
+"Stored in ~/.codexbar/config.json. Paste your Coding Plan API key from Model Studio." = "Зберігається в ~/.codexbar/config.json. Вставте ключ API плану кодування з Model Studio.";
+"Stored in ~/.codexbar/config.json. Paste your MiniMax API key." = "Зберігається в ~/.codexbar/config.json. Вставте ключ MiniMax API.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or " = "Зберігається в ~/.codexbar/config.json. Ви також можете надати KILO_API_KEY або";
+"Stores local Codex usage history (8 weeks) to personalize Pace predictions." = "Зберігає локальну історію використання Codex (8 тижнів) для персоналізації прогнозів Pace.";
+"Subscription Utilization" = "Використання підписки";
+"Surprise me" = "Здивуйте мене";
+"Switcher shows icons" = "Перемикач показує значки";
+"Symlink CodexBarCLI to /usr/local/bin and /opt/homebrew/bin as codexbar." = "Символьне посилання CodexBarCLI на /usr/local/bin і /opt/homebrew/bin як codexbar.";
+"System" = "Система";
+"Temporarily shows the loading animation after the next refresh." = "Тимчасово показує анімацію завантаження після наступного оновлення.";
+"Tertiary (\\(label))" = "Вищий (\\(label))";
+"Tertiary (\\(tertiaryTitle))" = "Вищий (\\(tertiaryTitle))";
+"The default Codex account on this Mac." = "Обліковий запис Codex за умовчанням на цьому Mac.";
+"Toggle" = "Перемикач";
+"Toggle subtitle" = "Перемкнути субтитри";
+"Token" = "Токен";
+"Trigger the menu bar menu from anywhere." = "Викликати меню панелі меню з будь-якого місця.";
+"True" = "Так";
+"Twitter" = "Twitter";
+"Unsupported" = "Не підтримується";
+"Update Channel" = "Оновити канал";
+"Updated" = "Оновлено";
+"Updates unavailable in this build." = "Оновлення недоступні в цій збірці.";
+"Usage" = "Використання";
+"Usage breakdown" = "Розбивка використання";
+"Usage history (30 days)" = "Історія використання";
+"Usage source" = "Джерело використання";
+"Use BigModel for the China mainland endpoints (open.bigmodel.cn)." = "Використовуйте BigModel для кінцевих точок материкового Китаю (open.bigmodel.cn).";
+"Use a single menu bar icon with a provider switcher." = "Використовуйте одну піктограму панелі меню з перемикачем провайдерів.";
+"Use international or China mainland console gateways for quota fetches." = "Використовуйте міжнародні консольні шлюзи або шлюзи материкової частини Китаю для отримання квот.";
+"Version" = "Версія";
+"Version \\(self.versionString)" = "Версія \\(self.versionString)";
+"Version \\(version)" = "Версія \\(version)";
+"Version \\(versionString)" = "Версія \\(versionString)";
+"Vertex AI Login" = "Вхід у Vertex AI";
+"Wait for the current managed Codex login to finish before adding another account." = "Перш ніж додавати інший обліковий запис, дочекайтеся завершення поточного керованого входу в Codex.";
+"Waiting for Authentication..." = "Очікування автентифікації...";
+"Website" = "Веб-сайт";
+"Weekly limit confetti" = "Щотижневий ліміт конфетті";
+"Weekly token limit" = "Тижневий ліміт жетонів";
+"Weekly usage" = "Щотижневе використання";
+"Weekly usage unavailable for this account." = "Щотижневе використання недоступне для цього облікового запису.";
+"Window: \\(window)" = "Вікно: \\(window)";
+"Write logs to \\(self.fileLogPath) for debugging." = "Записати журнали в \\(self.fileLogPath) для налагодження.";
+"Yes" = "Так";
+"\\(detail.modelCode): \\(usage)" = "\\(detail.modelCode): \\(usage)";
+"\\(name): \\(truncated)" = "\\(name): \\(truncated)";
+"\\(name): \\(updated) · 30d \\(cost)" = "\\(name): \\(updated) · 30 дн \\(cost)";
+"\\(name): fetching…\\(elapsed)" = "\\(name): отримання…\\(elapsed)";
+"\\(name): last attempt \\(when)" = "\\(name): остання спроба \\(when)";
+"\\(name): no data yet" = "\\(name): ще немає даних";
+"\\(name): unsupported" = "\\(name): не підтримується";
+"all browsers" = "всі браузери";
+"available again." = "знову доступний.";
+"built_format" = "Побудовано %@";
+"copilot_complete_in_browser" = "Завершіть вхід у свій браузер.";
+"copilot_device_code" = "Код пристрою скопійовано в буфер обміну: %1$@\n\nПеревірити за адресою: %2$@";
+"copilot_device_code_copied" = "Код пристрою скопійовано.";
+"copilot_verify_at" = "Підтвердити в %@";
+"copilot_waiting_text" = "Завершіть вхід у свій браузер.\nЦе вікно закриється автоматично, коли вхід завершиться.";
+"copilot_window_closes_auto" = "Це вікно закривається автоматично після завершення входу.";
+"cost_status_error" = "%1$@: %2$@";
+"cost_status_fetching" = "%1$@: отримання… %2$@";
+"cost_status_last_attempt" = "%1$@: остання спроба %2$@";
+"cost_status_no_data" = "%@: ще немає даних";
+"cost_status_snapshot" = "%1$@: %2$@ · %3$@ %4$@";
+"cost_status_unsupported" = "%@: не підтримується";
+"credits_remaining" = "Кредити: %@";
+"cursor_on_demand" = "На вимогу: %@";
+"cursor_on_demand_with_limit" = "На вимогу: %1$@ / %2$@";
+"extra_usage_format" = "Додаткове використання: %1$@ / %2$@";
+"jetbrains_detected_generate" = "Виявлено: %@. Скористайтеся помічником штучного інтелекту один раз, щоб створити дані квоти, а потім оновіть CodexBar.";
+"jetbrains_detected_select" = "Виявлено: %@. Виберіть бажану IDE у налаштуваннях, а потім оновіть CodexBar.";
+"last_fetch_failed_with_provider" = "Помилка останнього %@ отримання:";
+"last_spend" = "Останні витрати: %@";
+"mcp_model_usage" = "%1$@: %2$@";
+"mcp_resets" = "Скидання: %@";
+"mcp_window" = "Вікно: %@";
+"metric_average" = "Середній (%1$@ + %2$@)";
+"metric_primary" = "Основний (%@)";
+"metric_secondary" = "Вторинний (%@)";
+"metric_tertiary" = "Вищий (%@)";
+"multiple_workspaces_found" = "CodexBar знайшов кілька робочих областей для %@. Виберіть робочу область для додавання.";
+"ory_session_…=…; csrftoken=…" = "ory_session_…=…; csrftoken=…";
+"overview_choose_providers" = "Виберіть до %@ постачальників";
+"remove_account_message" = "Видалити %@ з CodexBar? Його керовану домашню сторінку Codex буде видалено.";
+"version_format" = "Версія %@";
+"vertex_ai_login_instructions" = "Щоб відстежувати використання Vertex AI, пройдіть автентифікацію в Google Cloud.\n\n1. Відкрийте термінал\n2. Запустіть: gcloud auth application-default login\n3. Дотримуйтесь підказок браузера, щоб увійти\n4. Налаштуйте свій проект: gcloud config set project PROJECT_ID\n\nВідкрити термінал зараз?";
+"workspaceID is set but only opencode, opencodego, and deepgram support workspaceID." = "workspaceID встановлено, але лише opencode, opencodego та deepgram підтримують workspaceID.";
+"© 2026 Peter Steinberger. MIT License." = "© 2026 Пітер Штайнбергер. Ліцензія MIT.";
+
+/* General Pane */
+"section_system" = "Система";
+"section_usage" = "Використання";
+"section_automation" = "Автоматизація";
+"language_title" = "Мова";
+"language_subtitle" = "Змінює мову інтерфейсу. Для повного застосування потрібно перезапустити застосунок.";
+"language_system" = "Система";
+"language_english" = "English";
+"language_spanish" = "Español";
+"language_catalan" = "Català";
+"language_chinese_simplified" = "简体中文";
+"language_chinese_traditional" = "繁體中文";
+"language_portuguese_brazilian" = "Português (Brasil)";
+"language_german" = "Deutsch";
+"language_swedish" = "Svenska";
+"language_french" = "Français";
+"language_dutch" = "Нідерландська";
+"language_ukrainian" = "Українська";
+"language_japanese" = "Японська";
+"language_korean" = "Корейська";
+"language_italian" = "Italiano";
+"language_vietnamese" = "В'єтнамська";
+"language_turkish" = "Türkçe";
+"language_indonesian" = "Індонезійська";
+"language_polish" = "Польська";
+"start_at_login_title" = "Почніть із входу";
+"start_at_login_subtitle" = "Автоматично відкриває CodexBar під час запуску Mac.";
+"show_cost_summary" = "Показати підсумок витрат";
+"show_cost_summary_subtitle" = "Читає локальні журнали використання. Показує сьогодні + вибране вікно історії в меню.";
+"cost_history_days_title" = "Вікно історії: %d днів";
+"cost_auto_refresh_info" = "Автоматичне оновлення: щогодини · Час очікування: 10 хв";
+"refresh_cadence_title" = "Оновити каденцію";
+"refresh_cadence_subtitle" = "Як часто CodexBar опитує постачальників у фоновому режимі.";
+"manual_refresh_hint" = "Автооновлення вимкнено; скористайтеся командою меню «Оновити».";
+"check_provider_status_title" = "Перевірте статус провайдера";
+"check_provider_status_subtitle" = "Опитує сторінки статусу OpenAI/Claude і Google Workspace для Gemini/Antigravity, виявляючи інциденти в значку та меню.";
+"session_quota_notifications_title" = "Сповіщення про квоту сеансу";
+"session_quota_notifications_subtitle" = "Повідомляє, коли 5-годинна квота сеансу досягає 0% і коли вона знову стає доступною.";
+"quota_warning_notifications_title" = "Попередження про квоту";
+"quota_warning_notifications_subtitle" = "Попереджає, коли залишок сеансу або тижневої квоти перевищує налаштовані порогові значення.";
+"quota_warnings_title" = "Попередження про квоту";
+"quota_warning_session" = "сесії";
+"quota_warning_session_capitalized" = "Сесія";
+"quota_warning_weekly" = "щотижня";
+"quota_warning_weekly_capitalized" = "Щотижня";
+"quota_warning_notification_title" = "%1$@ %2$@ квота низька";
+"quota_warning_notification_body" = "%1$@ залишилося. Досягнуто %2$d%% %3$@ порогового значення попередження.";
+"quota_warning_notification_body_with_account" = "Рахунок %1$@. Залишилося %2$@. Досягнуто %3$d%% %4$@ порогового значення попередження.";
+"session_depleted_notification_title" = "%@ сеанс вичерпано";
+"session_depleted_notification_body" = "Залишилося 0%. Надішле сповіщення, коли знову стане доступним.";
+"session_restored_notification_title" = "%@ сеанс відновлено";
+"session_restored_notification_body" = "Квота сесії знову доступна.";
+"quota_warning_warn_at" = "Попередити при";
+"quota_warning_global_threshold_subtitle" = "Відсотки, що залишилися для вікон сесії та тижня, якщо постачальник не замінить їх.";
+"quota_warning_sound" = "Відтворити звук сповіщення";
+"quota_warning_provider_inherits" = "Використовує глобальні параметри попередження про квоту, якщо тут не налаштовано вікно.";
+"quota_warning_customize_thresholds" = "Налаштувати порогові значення %@";
+"quota_warning_enable_warnings" = "Увімкнути %@ попереджень";
+"quota_warning_window_warn_at" = "%@ попередити о";
+"quota_warning_off" = "Вимкнено";
+"quota_warning_inherited" = "Успадковано: %@";
+"quota_warning_depleted_only" = "лише виснажені";
+"quota_warning_upper" = "Верхній";
+"quota_warning_lower" = "Нижній";
+"apply" = "Застосувати";
+"quit_app" = "Закрийте CodexBar";
+
+/* Tab titles */
+"tab_general" = "Загальні";
+"tab_providers" = "Провайдери";
+"tab_display" = "Відображення";
+"tab_advanced" = "Розширені";
+"tab_about" = "Про програму";
+"tab_debug" = "Налагодження";
+
+/* Providers Pane */
+"select_a_provider" = "Виберіть провайдера";
+"cancel" = "Скасувати";
+"last_fetch_failed" = "остання вибірка не вдалася";
+"usage_not_fetched_yet" = "використання ще не отримано";
+"managed_account_storage_unreadable" = "Сховище керованого облікового запису не читається. Доступ до поточного облікового запису все ще доступний, але керовані дії додавання, повторної авторизації та видалення вимкнено, доки магазин не буде відновлено.";
+"remove_codex_account_title" = "Видалити обліковий запис Codex?";
+"remove" = "видалити";
+"managed_login_already_running" = "Керований вхід до Codex вже запущено. Зачекайте, поки це завершиться, перш ніж додавати або повторно автентифікувати інший обліковий запис.";
+"managed_login_failed" = "Керований вхід Codex не завершено. Переконайтеся, що `codex --version` працює в терміналі. Якщо macOS заблокувала або перемістила `codex` у кошик, видаліть застарілі повторювані встановлення, запустіть `npm install -g --include=optional @openai/codex@latest`, а потім повторіть спробу.";
+"codex_login_output" = "код входу в систему:";
+"managed_login_missing_email" = "Вхід до Codex завершено, але електронна адреса облікового запису недоступна. Повторіть спробу після того, як підтвердите, що обліковий запис повністю ввійшли.";
+"login_success_notification_title" = "%@ вхід успішний";
+"login_success_notification_body" = "Ви можете повернутися до програми; аутентифікація завершена.";
+"workspace_selection_cancelled" = "CodexBar знайшов кілька робочих областей, але жодна робоча область не була вибрана.";
+"unsafe_managed_home" = "CodexBar відмовився змінити неочікуваний керований домашній шлях: %@";
+"menu_bar_metric_title" = "Метрика панелі меню";
+"menu_bar_metric_subtitle" = "Виберіть, яке вікно керує відсотками панелі меню.";
+"menu_bar_metric_subtitle_deepseek" = "Показує баланс DeepSeek на панелі меню.";
+"menu_bar_metric_subtitle_moonshot" = "Показує баланс API Moonshot / Kimi на панелі меню.";
+"menu_bar_metric_subtitle_mistral" = "Показує поточні витрати Mistral API на панелі меню.";
+"menu_bar_metric_subtitle_kimik2" = "Показує кредити API-ключа Kimi K2 на панелі меню.";
+"automatic" = "Автоматичний";
+"primary_api_key_limit" = "Основний (обмеження ключа API)";
+
+/* Display Pane */
+"section_menu_bar" = "Рядок меню";
+"merge_icons_title" = "Злиття значків";
+"merge_icons_subtitle" = "Використовуйте одну піктограму панелі меню з перемикачем провайдерів.";
+"switcher_shows_icons_title" = "Перемикач показує значки";
+"switcher_shows_icons_subtitle" = "Показувати піктограми постачальників у комутаторі (інакше показувати щотижневий рядок прогресу).";
+"show_most_used_provider_title" = "Показати постачальника, який найчастіше використовується";
+"show_most_used_provider_subtitle" = "Рядок меню автоматично показує постачальника, який найближче до ліміту.";
+"menu_bar_shows_percent_title" = "Рядок меню показує відсотки";
+"menu_bar_shows_percent_subtitle" = "Замініть смужки тварин на значки бренду постачальника та відсоток.";
+"hide_critters_title" = "Сховати тварин";
+"hide_critters_subtitle" = "Показувати прості смужки вимірювання без обличчя та оздоблення.";
+"display_mode_title" = "Режим відображення";
+"display_mode_subtitle" = "Виберіть, що відображати на панелі меню (Pace показує використання порівняно з очікуваним).";
+"section_menu_content" = "Зміст меню";
+"show_usage_as_used_title" = "Показати використання як використане";
+"show_usage_as_used_subtitle" = "Індикатори прогресу заповнюються, коли ви витрачаєте квоту (замість відображення залишку).";
+"show_quota_warning_markers_title" = "Показати маркери попередження про квоти";
+"show_quota_warning_markers_subtitle" = "Малюйте порогові позначки на панелях використання, коли налаштовано попередження про квоту.";
+"weekly_progress_work_days_title" = "Щотижневі робочі дні";
+"weekly_progress_work_days_subtitle" = "Задайте робочі дні для позначок на смугах тижневого використання та розрахунків темпу.";
+"show_reset_time_as_clock_title" = "Показувати час скидання як годинник";
+"show_reset_time_as_clock_subtitle" = "Відображення часу скидання як абсолютних значень годинника замість зворотного відліку.";
+"show_provider_changelog_links_title" = "Показати посилання журналу змін провайдера";
+"show_provider_changelog_links_subtitle" = "Додає в меню посилання на примітки до випуску для підтримуваних постачальників, що підтримують CLI.";
+"show_credits_extra_usage_title" = "Показати кредити + додаткове використання";
+"show_credits_extra_usage_subtitle" = "Показати в меню розділи використання кредитів Codex і Claude Extra.";
+"show_all_token_accounts_title" = "Показати всі облікові записи маркерів";
+"show_all_token_accounts_subtitle" = "Облікові записи маркерів стека в меню (інакше відображати панель перемикання облікових записів).";
+"multi_account_layout_title" = "Макет кількох облікових записів";
+"multi_account_layout_subtitle" = "Виберіть сегментоване перемикання облікових записів або складені картки облікових записів.";
+"multi_account_layout_segmented" = "Сегментований";
+"multi_account_layout_stacked" = "складені";
+"overview_tab_providers_title" = "Постачальники вкладок огляду";
+"configure" = "Налаштувати…";
+"overview_enable_merge_icons_hint" = "Увімкніть Merge Icons, щоб налаштувати постачальників вкладок «Огляд».";
+"overview_no_providers_hint" = "Немає активованих постачальників, доступних для огляду.";
+"overview_rows_follow_order" = "Оглядові рядки завжди відповідають порядку постачальника.";
+"overview_no_providers_selected" = "Не вибрано жодного постачальника";
+
+/* Advanced Pane */
+"section_keyboard_shortcut" = "Комбінація клавіш";
+"open_menu_shortcut_title" = "Відкрити меню";
+"open_menu_shortcut_subtitle" = "Викликати меню панелі меню з будь-якого місця.";
+"install_cli" = "Встановіть CLI";
+"install_cli_subtitle" = "Символьне посилання CodexBarCLI на /usr/local/bin і /opt/homebrew/bin як codexbar.";
+"cli_not_found" = "CodexBarCLI не знайдено в пакеті програм.";
+"no_writable_bin_dirs" = "Не знайдено записуваних каталогів кошика.";
+"show_debug_settings_title" = "Показати налаштування налагодження";
+"show_debug_settings_subtitle" = "Розкрийте інструменти усунення несправностей на вкладці Debug.";
+"surprise_me_title" = "Здивуйте мене";
+"surprise_me_subtitle" = "Перевірте, чи подобається вам, що ваші агенти розважаються там.";
+"weekly_limit_confetti_title" = "Щотижневий ліміт конфетті";
+"weekly_limit_confetti_subtitle" = "Відтворення конфетті на весь екран, коли тижневе використання скидається.";
+"hide_personal_info_title" = "Приховати особисту інформацію";
+"hide_personal_info_subtitle" = "Незрозумілі адреси електронної пошти на панелі меню та інтерфейсі меню.";
+"show_provider_storage_usage_title" = "Показати використання сховища постачальника";
+"show_provider_storage_usage_subtitle" = "Показати використання локального диска в меню. Сканує відомі шляхи, що належать провайдеру, у фоновому режимі.";
+"section_keychain_access" = "Доступ через брелок";
+"keychain_access_caption" = "Вимкніть усі функції читання та запису Keychain. Використовуйте це, якщо macOS постійно запитує «Chrome/Brave/Edge Safe Storage» навіть після натискання «Завжди дозволяти». Імпорт файлів cookie браузера недоступний, якщо ввімкнено; вставте заголовки файлів cookie вручну в Провайдери. Claude/Codex OAuth через CLI все ще працює.";
+"disable_keychain_access_title" = "Вимкнути доступ Keychain";
+"disable_keychain_access_subtitle" = "Запобігає будь-якому доступу Keychain, коли ввімкнено.";
+
+/* About Pane */
+"about_tagline" = "Нехай ваші токени ніколи не закінчаться — пам’ятайте про ліміти агентів.";
+"link_github" = "GitHub";
+"link_website" = "Веб-сайт";
+"link_twitter" = "Twitter";
+"link_email" = "Електронна пошта";
+"check_updates_auto" = "Автоматично перевіряти наявність оновлень";
+"update_channel" = "Оновити канал";
+"check_for_updates" = "Перевірити наявність оновлень…";
+"updates_unavailable" = "Оновлення недоступні в цій збірці.";
+"copyright" = "© 2026 Пітер Штайнбергер. Ліцензія MIT.";
+
+/* Debug Pane */
+"section_logging" = "Лісозаготівля";
+"enable_file_logging" = "Увімкнути журналювання файлів";
+"enable_file_logging_subtitle" = "Записати журнали до %@ для налагодження.";
+"verbosity_title" = "Багатослівність";
+"verbosity_subtitle" = "Контролює, скільки деталей реєструється.";
+"open_log_file" = "Відкрити файл журналу";
+"force_animation_next_refresh" = "Примусово запускати анімацію під час наступного оновлення";
+"force_animation_next_refresh_subtitle" = "Тимчасово показує анімацію завантаження після наступного оновлення.";
+"section_loading_animations" = "Завантаження анімацій";
+"loading_animations_caption" = "Виберіть шаблон і відтворіть його на панелі меню. \\\"Випадкове\\\" зберігає існуючу поведінку.";
+"animation_random_default" = "Випадковий (за замовчуванням)";
+"replay_selected_animation" = "Повторити вибрану анімацію";
+"blink_now" = "Поморгай зараз";
+"section_probe_logs" = "Зондові журнали";
+"probe_logs_caption" = "Отримати останній результат тестування для налагодження; Копія зберігає повний текст.";
+"fetch_log" = "Отримати журнал";
+"copy" = "Копіювати";
+"save_to_file" = "Зберегти у файл";
+"load_parse_dump" = "Завантажити дамп аналізу";
+"rerun_provider_autodetect" = "Повторно запустіть автоматичне визначення постачальника";
+"loading" = "Завантаження…";
+"no_log_yet_fetch" = "Журналу ще немає. Отримати для завантаження.";
+"section_fetch_strategy" = "Спроби отримання стратегії";
+"fetch_strategy_caption" = "Рішення та помилки конвеєра останньої вибірки для постачальника.";
+"section_openai_cookies" = "Файли cookie OpenAI";
+"openai_cookies_caption" = "Імпорт файлів cookie + сканування журналів WebKit з останньої спроби файлів cookie OpenAI.";
+"no_log_yet" = "Журналу ще немає. Оновіть файли cookie OpenAI у Постачальники → Codex, щоб запустити імпорт.";
+"section_caches" = "Тайники";
+"caches_caption" = "Очистити кеш-пам’ять результатів сканування витрат або кешу файлів cookie браузера.";
+"clear_cookie_cache" = "Очистити кеш cookie";
+"clear_cost_cache" = "Очистити кеш вартості";
+"section_notifications" = "Сповіщення";
+"notifications_caption" = "Запуск тестових сповіщень для 5-годинного вікна сеансу (вичерпано/відновлено).";
+"post_depleted" = "Повідомлення вичерпано";
+"post_restored" = "Пост відновлено";
+"section_cli_sessions" = "Сесії CLI";
+"cli_sessions_caption" = "Підтримуйте сесії Codex/Claude CLI після зонду. За замовчуванням виходить після збору даних.";
+"keep_cli_sessions_alive" = "Підтримуйте сесії CLI";
+"keep_cli_sessions_alive_subtitle" = "Пропустити демонтаж між зондами (лише для налагодження).";
+"reset_cli_sessions" = "Скидання сеансів CLI";
+"section_error_simulation" = "Симуляція помилок";
+"error_simulation_caption" = "Введіть фальшиве повідомлення про помилку в картку меню для тестування макета.";
+"set_menu_error" = "Помилка налаштування меню";
+"clear_menu_error" = "Помилка очищення меню";
+"set_cost_error" = "Помилка встановлення вартості";
+"clear_cost_error" = "Очистити помилку вартості";
+"section_cli_paths" = "Шляхи CLI";
+"cli_paths_caption" = "Вирішено двійковий шар Codex і PATH; запуск входу PATH захоплення (короткий тайм-аут).";
+"codex_binary" = "Двійковий код Codex";
+"claude_binary" = "Claude бінарний";
+"effective_path" = "Ефективний ШЛЯХ";
+"unavailable" = "Недоступний";
+"login_shell_path" = "ШЛЯХ до оболонки входу (запис під час запуску)";
+"cleared" = "Очищено.";
+"no_fetch_attempts" = "Ще жодних спроб отримання.";
+"macOS Tahoe can block menu bar apps in System Settings → Menu Bar → Allow in the Menu Bar. CodexBar is running, but macOS may be hiding its icon. Open Menu Bar settings and turn CodexBar on." = "macOS Tahoe може блокувати програми панелі меню в системних параметрах → Рядок меню → Дозволити на панелі меню. CodexBar працює, але macOS може приховувати свій значок. Відкрийте налаштування рядка меню та ввімкніть CodexBar.";
+
+/* Metric preferences */
+"metric_pref_automatic" = "Автоматичний";
+"metric_pref_primary" = "Первинний";
+"metric_pref_secondary" = "Вторинний";
+"metric_pref_tertiary" = "Третинний";
+"metric_pref_extra_usage" = "Додаткове використання";
+"metric_pref_average" = "Середній";
+"metric_mistral_payg" = "Pay-as-you-go";
+"metric_mistral_monthly_plan" = "Monthly Plan";
+
+/* Display modes */
+"display_mode_percent" = "Відсоток";
+"display_mode_pace" = "Темп";
+"display_mode_both" = "Обидва";
+"display_mode_reset_time" = "Час скидання";
+"display_mode_percent_desc" = "Показати залишок/використаний відсоток (наприклад, 45%)";
+"display_mode_pace_desc" = "Показати індикатор темпу (наприклад, +5%)";
+"display_mode_both_desc" = "Показати відсоток і темп (наприклад, 45% · +5%)";
+"display_mode_reset_time_desc" = "Показувати час скидання для вибраного показника (наприклад, ↻ 15:56)";
+
+/* Provider status */
+"status_operational" = "Працює";
+"status_partial_outage" = "Часткове відключення";
+"status_major_outage" = "Серйозний збій";
+"status_critical_issue" = "Критична проблема";
+"status_maintenance" = "Технічне обслуговування";
+"status_unknown" = "Статус невідомий";
+
+/* Refresh frequency */
+"refresh_manual" = "Інструкція";
+"refresh_1min" = "1 хв";
+"refresh_2min" = "2 хв";
+"refresh_5min" = "5 хв";
+"refresh_15min" = "15 хв";
+"refresh_30min" = "30 хв";
+
+/* Additional keys */
+"not_found" = "Не знайдено";
+
+/* Cost estimation */
+"cost_header_estimated" = "Вартість (орієнтовна)";
+"cost_estimate_hint" = "Оцінка з місцевих журналів · може відрізнятися від вашого рахунку";
+"No JetBrains IDE with AI Assistant detected. Install a JetBrains IDE and enable AI Assistant." = "Не виявлено JetBrains IDE з AI Assistant. Встановіть JetBrains IDE і ввімкніть AI Assistant.";
+"OpenRouter API token not configured. Set OPENROUTER_API_KEY environment variable or configure in Settings." = "Маркер OpenRouter API не налаштовано. Установіть змінну середовища OPENROUTER_API_KEY або налаштуйте її в налаштуваннях.";
+"z.ai API token not found. Set apiKey in ~/.codexbar/config.json or Z_AI_API_KEY." = "Маркер API z.ai не знайдено. Установіть apiKey у ~/.codexbar/config.json або Z_AI_API_KEY.";
+"Missing DeepSeek API key." = "Відсутній ключ API DeepSeek.";
+"%@ is unavailable in the current environment." = "%@ недоступний у поточному середовищі.";
+"All Systems Operational" = "Всі системи працюють";
+"Last 30 days" = "Останні 30 днів";
+"Last 30 days:" = "Останні 30 днів:";
+"This month" = "Цей місяць";
+"Store multiple OpenAI API keys." = "Зберігайте кілька ключів OpenAI API.";
+"Admin API key" = "Ключ API адміністратора";
+"Open billing" = "Відкритий білінг";
+"Google accounts" = "облікові записи Google";
+"Store multiple Antigravity Google OAuth accounts for quick switching." = "Зберігайте кілька облікових записів Antigravity Google OAuth для швидкого перемикання.";
+"Add Google Account" = "Додайте обліковий запис Google";
+"Open Token Plan" = "Відкритий план токенів";
+"Text Generation" = "Генерація тексту";
+"Text to Speech" = "Перетворення тексту в мовлення";
+"Music Generation" = "Музичне покоління";
+"Image Generation" = "Генерація зображень";
+"No local data found" = "Немає локальних даних";
+"Credits unavailable; keep Codex running to refresh." = "Кредити недоступні; продовжуйте працювати Codex для оновлення.";
+"No available fetch strategy for minimax." = "Немає доступної стратегії вибірки для minimax.";
+"No Cursor session found. Please log in to cursor.com in Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX, or Edge Canary. If you use Safari, grant CodexBar Full Disk Access in System Settings ▸ Privacy & Security. You can also sign in to Cursor from the CodexBar menu (Add / switch account)." = "Сеанс курсору не знайдено. Увійдіть на cursor.com у Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX або Edge Canary. Якщо ви користуєтеся Safari, надайте CodexBar повний доступ до диска в системних параметрах ▸ Конфіденційність і безпека. Ви також можете ввійти в Cursor з меню CodexBar (Додати/змінити обліковий запис).";
+"No OpenCode session cookies found in browsers." = "У браузерах не знайдено сеансових файлів cookie OpenCode.";
+"No available fetch strategy for %@." = "Немає доступної стратегії отримання для %@.";
+"Today" = "Сьогодні";
+"Today tokens" = "Сьогодні жетони";
+"30d cost" = "Вартість 30д";
+"30d tokens" = "30d жетонів";
+"Latest tokens" = "Останні жетони";
+"Top model" = "Топ модель";
+"Storage" = "Зберігання";
+"Add Account..." = "Додати обліковий запис...";
+"Usage Dashboard" = "Панель використання";
+"Status Page" = "Сторінка стану";
+"Settings..." = "Налаштування...";
+"About CodexBar" = "Про CodexBar";
+"Quit" = "Вийти";
+"Last %d day" = "Останній %d день";
+"Last %d days" = "Останні %d днів";
+"%@ tokens" = "%@ токенів";
+"Latest billing day" = "Останній розрахунковий день";
+"Latest billing day (%@)" = "Останній розрахунковий день (%@)";
+"%@ left" = "Залишилося %@";
+"Resets %@" = "Скидання %@";
+"Resets in %@" = "Скидання через %@";
+"Resets now" = "Скидає зараз";
+"reset_tomorrow_format" = "завтра, %@";
+"Lasts until reset" = "Триває до скидання";
+"Updated %@" = "Оновлено %@";
+"Updated %@h ago" = "Оновлено %@ год тому";
+"Updated %@m ago" = "Оновлено %@хв тому";
+"Updated just now" = "Оновлено щойно";
+"Projected empty in %@" = "Передбачається порожній у %@";
+"Runs out in %@" = "Закінчується за %@";
+"Pace: %@" = "Темп: %@";
+"Pace: %@ · %@" = "Темп: %@ · %@";
+"%@ · %@" = "%@ · %@";
+"≈ %d%% run-out risk" = "≈ %d%% ризик вичерпання";
+"%d%% in deficit" = "%d%% в дефіциті";
+"%d%% in reserve" = "%d%% в резерві";
+"usage_percent_suffix_left" = "зліва";
+"usage_percent_suffix_used" = "використовується";
+"Store multiple DeepSeek API keys." = "Зберігайте кілька ключів DeepSeek API.";
+"This week" = "Цього тижня";
+"Week" = "тиждень";
+"Month" = "місяць";
+"Models" = "Моделі";
+"24h tokens" = "24-годинні жетони";
+"Latest hour" = "Остання година";
+"Peak hour" = "Година пік";
+"Top method" = "Топовий спосіб";
+"30d cash" = "30д готівкою";
+"30d billing history from MiniMax web session" = "30-денна історія платежів з веб-сесії MiniMax";
+"AWS Cost Explorer billing can lag." = "Виставлення рахунків AWS Cost Explorer може затримуватися.";
+"Rate limit: %d / %@" = "Ліміт швидкості: %d / %@";
+"Key remaining" = "Ключ залишився";
+"No limit set for the API key" = "Для ключа API не встановлено обмежень";
+"API key limit unavailable right now" = "Ліміт ключів API зараз недоступний";
+"This month: %@ tokens" = "Цей місяць: %@ токенів";
+"No utilization data yet." = "Даних про використання ще немає.";
+"No %@ utilization data yet." = "Ще немає даних про використання %@.";
+"%@: %@%% used" = "%@: використано %@%%.";
+"%dd" = "%dд";
+"today" = "сьогодні";
+"just now" = "тільки зараз";
+"On pace" = "В темпі";
+"Runs out now" = "Зараз закінчується";
+"Projected empty now" = "Зараз проектується порожнім";
+"Switch Account..." = "Змінити обліковий запис...";
+"Update ready, restart now?" = "Оновлення готове, перезапустити?";
+"Daily" = "Щодня";
+"Hourly Tokens" = "Погодинні жетони";
+"No data" = "Немає даних";
+"No usage breakdown data available." = "Немає даних про розподіл використання.";
+
+"Today: %@ · %@ tokens" = "Сьогодні: %@ · %@ токенів";
+"Today: %@" = "Сьогодні: %@";
+"Today: %@ tokens" = "Сьогодні: %@ токенів";
+"Last 30 days: %@ · %@ tokens" = "Останні 30 днів: %@ · %@ токенів";
+"Last 30 days: %@" = "Останні 30 днів: %@";
+"Est. total (30d): %@" = "Приблизно всього (30 днів): %@";
+"Est. total (%@): %@" = "Приблизно всього (%@): %@";
+"Hover a bar for details" = "Щоб переглянути деталі, наведіть курсор на панель";
+"%@: %@ · %@ tokens" = "%@: %@ · %@ токенів";
+"No providers selected for Overview." = "Для огляду не вибрано жодного постачальника.";
+"No overview data available." = "Немає оглядових даних.";
+"Auto uses the local IDE API first, then Google OAuth when the IDE is closed." = "Auto спочатку використовує локальний API IDE, а потім Google OAuth, коли IDE закрито.";
+"Login with Google" = "Увійти через Google";
+
+/* Popup panels */
+"No usage configured." = "Використання не налаштовано.";
+"Quota" = "Квота";
+"tokens" = "жетони";
+"requests" = "запити";
+"Latest" = "Останній";
+"Monthly" = "Щомісяця";
+"Sonnet" = "Сонет";
+"Overages" = "Надлишки";
+"Activity" = "діяльність";
+"Copied" = "Скопійовано";
+"Copy error" = "Помилка копіювання";
+"Copy path" = "Копіювати шлях";
+"Extra usage spent" = "Витрачено додаткове використання";
+"Credits remaining" = "Залишок кредитів";
+"Using CLI fallback" = "Використання запасного CLI";
+"Balance updates in near-real time (up to 5 min lag)" = "Оновлення балансу майже в реальному часі (затримка до 5 хвилин)";
+"Daily billing data finalizes at 07:00 UTC" = "Щоденні платіжні дані завершуються о 07:00 UTC";
+"%@ of %@ credits left" = "Залишилося %@ з %@ кредитів";
+"%@ of %@ bonus credits left" = "Залишилося %@ з %@ бонусних кредитів";
+"%@ / %@ (%@ remaining)" = "%@ / %@ (залишилося %@)";
+"%@/%@ left" = "Залишилося %@/%@";
+"Gemini Flash" = "Gemini Флеш";
+"Regenerates %@" = "Регенерує %@";
+"used after next regen" = "використовується після наступної регенерації";
+"after next regen" = "після наступної реген";
+"Near full" = "Майже повний";
+"Full in ~1 regen" = "Повний за ~1 регенерацію";
+"Full in ~%.0f regens" = "Повний ~%.0f регенерацій";
+"Overage usage" = "Надмірне використання";
+"Overage cost" = "Перевищення вартості";
+"credits" = "кредити";
+"Zen balance" = "Дзен баланс";
+"API spend" = "Витрати API";
+"Extra usage" = "Додаткове використання";
+"Quota usage" = "Використання квоти";
+"Your spend" = "Ваші витрати";
+"%.0f%% used" = "Використано %.0f%%.";
+"Usage history (today)" = "Історія використання (сьогодні)";
+"Usage history (%d days)" = "Історія використання (%d днів)";
+"%d percent remaining" = "Залишилося %d відсотків";
+"Unknown" = "Невідомо";
+"stale data" = "застарілі дані";
+"No credits history data." = "Немає даних про кредитну історію.";
+"No credits history data available." = "Немає даних про кредитну історію.";
+"Credits history chart" = "Графік кредитної історії";
+"%d days of credits data" = "Дані кредитів за %d днів";
+"Usage breakdown chart" = "Діаграма розподілу використання";
+"%d days of usage data across %d services" = "%d днів використання даних у %d службах";
+"Cost history chart" = "Графік історії витрат";
+"%d days of cost data" = "Дані про витрати за %d днів";
+"Plan utilization chart" = "Графік використання плану";
+"%d utilization samples" = "%d зразки використання";
+"Hourly Usage" = "Погодинне використання";
+"Usage remaining" = "Залишилося використання";
+"Usage used" = "Використання використано";
+"API key verified. Ollama does not expose Cloud quota limits through the API." = "Ключ API перевірено. Ollama не розкриває обмеження квот Cloud через API.";
+"Last 30 days: %@ tokens" = "Останні 30 днів: %@ токенів";
+"7d spend" = "7д витратити";
+"30d spend" = "витратити 30 днів";
+"Cache read" = "Читання кешу";
+"Claude Admin API 30 day spend trend" = "Claude Admin API 30-денна тенденція витрат";
+"OpenRouter API key spend trend" = "Тенденція витрат на ключ OpenRouter API";
+"z.ai hourly token trend" = "погодинний тренд токена z.ai";
+"MiniMax 30 day token usage trend" = "Тенденція використання токенів MiniMax за 30 днів";
+"Today cash" = "Сьогодні готівкою";
+"DeepSeek 30 day token usage trend" = "30-денна тенденція використання токенів DeepSeek";
+"cache-hit input" = "введення кешу";
+"cache-miss input" = "cache-miss input";
+"output" = "вихід";
+"Requests" = "Запити";
+"Reported by OpenAI Admin API organization usage." = "Повідомлено про використання організацією OpenAI Admin API.";
+"Reported by Mistral billing usage." = "Повідомлено Mistral billing usage.";
+"Google OAuth" = "Google OAuth";
+"Add accounts via GitHub OAuth Device Flow on the selected host." = "Додайте облікові записи через GitHub OAuth Device Flow на вибраному хості.";
+"Stores each signed-in Google account for quick Antigravity switching. Uses Antigravity.app OAuth when available, or ANTIGRAVITY_OAUTH_CLIENT_ID and ANTIGRAVITY_OAUTH_CLIENT_SECRET as an override." = "Зберігає кожен обліковий запис Google, у який ви ввійшли, для швидкого перемикання Antigravity. Використовує OAuth Antigravity.app, якщо доступний, або ANTIGRAVITY_OAUTH_CLIENT_ID і ANTIGRAVITY_OAUTH_CLIENT_SECRET як заміну.";
+"Manual cleanup: past sessions" = "Очищення вручну: минулі сесії";
+"Clearing removes past resume, continue, and rewind history." = "Очищення видаляє історію відновлення, продовження та перемотування назад.";
+"Manual cleanup: file checkpoints" = "Ручне очищення: контрольні точки файлів";
+"Clearing removes checkpoint restore data for previous edits." = "Очищення видаляє дані відновлення контрольної точки для попередніх змін.";
+"Manual cleanup: saved plans" = "Ручне очищення: збережені плани";
+"Clearing removes old plan-mode files." = "Очищення видаляє старі файли планового режиму.";
+"Manual cleanup: debug logs" = "Ручне очищення: журнали налагодження";
+"Clearing removes past debug logs." = "Очищення видаляє попередні журнали налагодження.";
+"Manual cleanup: attachment cache" = "Очищення вручну: кеш вкладень";
+"Clearing removes cached large pastes or attached images." = "Очищення видаляє кешовані великі вставки або прикріплені зображення.";
+"Manual cleanup: session metadata" = "Очищення вручну: метадані сеансу";
+"Clearing removes per-session environment metadata." = "Очищення видаляє метадані середовища для кожного сеансу.";
+"Manual cleanup: shell snapshots" = "Ручне очищення: знімки оболонки";
+"Clearing removes leftover runtime shell snapshot files." = "Очищення видаляє залишкові файли знімків оболонки виконання.";
+"Manual cleanup: legacy todos" = "Очищення вручну: застарілі завдання";
+"Clearing removes legacy per-session task lists." = "Очищення видаляє застарілі списки сеансових завдань.";
+"Manual cleanup: sessions" = "Ручне очищення: сесії";
+"Clearing removes past Codex session history." = "Очищення видаляє минулу історію сеансів Codex.";
+"Manual cleanup: archived sessions" = "Очищення вручну: заархівовані сеанси";
+"Clearing removes archived Codex session history." = "Очищення видаляє архівну історію сеансів Codex.";
+"Manual cleanup: cache" = "Очищення вручну: кеш";
+"Clearing removes provider-owned cached data." = "Очищення видаляє кешовані дані постачальника.";
+"Manual cleanup: logs" = "Ручне очищення: журнали";
+"Clearing removes local diagnostic logs." = "Очищення видаляє локальні журнали діагностики.";
+"Manual cleanup: file history" = "Ручне очищення: історія файлів";
+"Clearing removes local edit checkpoint history." = "Очищення видаляє локальну історію контрольних точок редагування.";
+"Manual cleanup: temporary data" = "Очищення вручну: тимчасові дані";
+"Clearing removes local temporary provider data." = "Очищення видаляє локальні тимчасові дані постачальника.";
+"Total: %@" = "Усього: %@";
+"%d more items" = "ще %d елементів";
+"Cleanup ideas" = "Ідеї ​​очищення";
+"%d unreadable item(s) skipped" = "%d нечитабельних елементів пропущено";
+
+"API key limit" = "Обмеження ключа API";
+"Auth" = "Авт";
+"Auto" = "Авто";
+"Disabled — no recent data" = "Вимкнено — немає останніх даних";
+"Limits not available" = "Обмеження недоступні";
+"No usage yet" = "Поки що не використовується";
+"Not fetched yet" = "Ще не отримано";
+"Refreshing" = "Освіжаючий";
+"Session" = "Сесія";
+"Source" = "Джерело";
+"State" = "Держава";
+"Unavailable" = "Недоступний";
+"Weekly" = "Щотижня";
+"not detected" = "не виявлено";
+"Estimated from local Codex logs for the selected account." = "Оцінено з локальних журналів Codex для вибраного облікового запису.";
+"minimax_usage_amount_format" = "Використання: %@ / %@";
+"minimax_used_percent_format" = "Використаний %@";
+"minimax_service_text_generation" = "Генерація тексту";
+"minimax_service_text_to_speech" = "Перетворення тексту в мовлення";
+"minimax_service_music_generation" = "Музичне покоління";
+"minimax_service_image_generation" = "Генерація зображень";
+"minimax_service_lyrics_generation" = "Генерація пісень";
+"minimax_service_coding_plan_vlm" = "План кодування VLM";
+"minimax_service_coding_plan_search" = "Пошук плану кодування";
+
+/* Additional provider settings and alerts */
+"%@ is waiting for permission" = "%@ чекає на дозвіл";
+"%@ requests" = "%@ запитів";
+"%@: %@ credits" = "%@: %@ кредитів";
+"30d requests" = "30d запитів";
+"4 days" = "4 дні";
+"5 days" = "5 днів";
+"7 days" = "7 днів";
+"API key verifies Ollama Cloud access; cookies still expose quota limits." = "Ключ API перевіряє доступ до Ollama Cloud; файли cookie все ще розкривають обмеження квоти.";
+"AWS access key ID. Can also be set with AWS_ACCESS_KEY_ID." = "Ідентифікатор ключа доступу до AWS. Також можна встановити за допомогою AWS_ACCESS_KEY_ID.";
+"AWS region. Can also be set with AWS_REGION." = "Регіон AWS. Також можна встановити за допомогою AWS_REGION.";
+"AWS secret access key. Can also be set with AWS_SECRET_ACCESS_KEY." = "Секретний ключ доступу до AWS. Також можна встановити за допомогою AWS_SECRET_ACCESS_KEY.";
+"Access key ID" = "Ідентифікатор ключа доступу";
+"Add Account" = "Додати обліковий запис";
+"Adding Account…" = "Додавання облікового запису…";
+"Antigravity login failed" = "Помилка входу в Antigravity";
+"Antigravity login timed out" = "Час очікування входу в антигравітацію минув";
+"Auth source" = "Джерело авторизації";
+"Automatic imports browser cookies from Xiaomi MiMo." = "Автоматично імпортує файли cookie браузера з Xiaomi MiMo.";
+"Automatic imports Windsurf session data from Chromium browser localStorage." = "Автоматично імпортує дані сесії Windsurf із локального сховища браузера Chromium.";
+"Automatic imports browser cookies from Bailian." = "Автоматично імпортує файли cookie браузера з Bailian.";
+"Automatically imports browser cookies." = "Автоматично імпортує файли cookie браузера.";
+"Automatically imports browser session cookies." = "Автоматично імпортує файли cookie сеансу браузера.";
+"Azure OpenAI deployment name. AZURE_OPENAI_DEPLOYMENT_NAME is also supported." = "Назва розгортання Azure OpenAI. AZURE_OPENAI_DEPLOYMENT_NAME також підтримується.";
+"Azure OpenAI key" = "Ключ Azure OpenAI";
+"Azure OpenAI resource endpoint. AZURE_OPENAI_ENDPOINT is also supported." = "Кінцева точка ресурсу Azure OpenAI. AZURE_OPENAI_ENDPOINT також підтримується.";
+"Base URL" = "Базовий URL";
+"Base URL for the LLM-API-Key-Proxy instance." = "Базова URL-адреса для примірника LLM-API-Key-Proxy.";
+"Browser cookies" = "Файли cookie браузера";
+"Cap end" = "Кінець кришки";
+"Cap start" = "Початок шапки";
+"Capacity End" = "Кінець ємності";
+"Capacity Start" = "Ємність Старт";
+"Changelog" = "Журнал змін";
+"Choose the Moonshot/Kimi API host for international or China mainland accounts." = "Виберіть хост API Moonshot/Kimi для міжнародних або материкового Китаю облікових записів.";
+"CodexBar can't replace a system account that is signed in with an API key only setup." = "CodexBar не може замінити системний обліковий запис, який увійшов лише за допомогою ключа API.";
+"CodexBar could not find saved auth for that account. Re-authenticate it and try again." = "CodexBar не може знайти збережену авторизацію для цього облікового запису. Повторно автентифікуйте його та повторіть спробу.";
+"CodexBar could not read managed account storage. Recover the store before adding another account." = "CodexBar не вдалося прочитати сховище керованого облікового запису. Відновіть магазин перед додаванням іншого облікового запису.";
+"CodexBar could not read saved auth for that account. Re-authenticate it and try again." = "CodexBar не зміг прочитати збережену авторизацію для цього облікового запису. Повторно автентифікуйте його та повторіть спробу.";
+"CodexBar could not read the current system account on this Mac." = "CodexBar не вдалося прочитати поточний обліковий запис системи на цьому Mac.";
+"CodexBar could not replace the live Codex auth on this Mac." = "CodexBar не зміг замінити поточну автентифікацію Codex на цьому Mac.";
+"CodexBar could not safely preserve the current system account before switching." = "CodexBar не зміг безпечно зберегти поточний обліковий запис системи перед перемиканням.";
+"CodexBar could not save the current system account before switching." = "CodexBar не зміг зберегти поточний обліковий запис системи перед перемиканням.";
+"CodexBar could not update managed account storage." = "CodexBar не вдалося оновити сховище керованого облікового запису.";
+"CodexBar found another managed account that already uses the current system account. Resolve the duplicate account before switching." = "CodexBar знайшов інший керований обліковий запис, який уже використовує поточний системний обліковий запис. Усуньте дублікат облікового запису перед переходом.";
+"CodexBar will ask macOS Keychain for “%@” so it can decrypt browser cookies and authenticate your account. Click OK to continue." = "CodexBar запитає у macOS Keychain «%@», щоб він міг розшифрувати файли cookie браузера та автентифікувати ваш обліковий запис. Натисніть OK, щоб продовжити.";
+"CodexBar will ask macOS Keychain for the Claude Code OAuth token so it can fetch your Claude usage. Click OK to continue." = "CodexBar запитає у macOS Keychain маркер Claude Code OAuth, щоб отримати дані про використання Claude. Натисніть OK, щоб продовжити.";
+"CodexBar will ask macOS Keychain for your Amp cookie header so it can fetch usage. Click OK to continue." = "CodexBar запитає у macOS Keychain ваш заголовок cookie Amp, щоб отримати інформацію про використання. Натисніть OK, щоб продовжити.";
+"CodexBar will ask macOS Keychain for your Augment cookie header so it can fetch usage. Click OK to continue." = "CodexBar запитає у macOS Keychain ваш заголовок файлу cookie Augment, щоб отримати інформацію про використання. Натисніть OK, щоб продовжити.";
+"CodexBar will ask macOS Keychain for your Claude cookie header so it can fetch Claude web usage. Click OK to continue." = "CodexBar запитає у macOS Keychain ваш заголовок файлу cookie Claude, щоб отримати інформацію про використання веб-сайту Claude. Натисніть OK, щоб продовжити.";
+"CodexBar will ask macOS Keychain for your Cursor cookie header so it can fetch usage. Click OK to continue." = "CodexBar запитає у macOS Keychain ваш заголовок cookie Cursor, щоб отримати інформацію про використання. Натисніть OK, щоб продовжити.";
+"CodexBar will ask macOS Keychain for your Factory cookie header so it can fetch usage. Click OK to continue." = "CodexBar запитає у macOS Keychain ваш заголовок Factory cookie, щоб отримати дані про використання. Натисніть OK, щоб продовжити.";
+"CodexBar will ask macOS Keychain for your GitHub Copilot token so it can fetch usage. Click OK to continue." = "CodexBar запитає у macOS Keychain ваш маркер GitHub Copilot, щоб отримати інформацію про використання. Натисніть OK, щоб продовжити.";
+"CodexBar will ask macOS Keychain for your Kimi K2 API key so it can fetch usage. Click OK to continue." = "CodexBar запитає у macOS Keychain ваш ключ API Kimi K2, щоб він міг отримати дані про використання. Натисніть OK, щоб продовжити.";
+"CodexBar will ask macOS Keychain for your Kimi auth token so it can fetch usage. Click OK to continue." = "CodexBar запитає у macOS Keychain ваш токен автентифікації Kimi, щоб отримати інформацію про використання. Натисніть OK, щоб продовжити.";
+"CodexBar will ask macOS Keychain for your MiniMax API token so it can fetch usage. Click OK to continue." = "CodexBar запитає у macOS Keychain ваш токен MiniMax API, щоб отримати інформацію про використання. Натисніть OK, щоб продовжити.";
+"CodexBar will ask macOS Keychain for your MiniMax cookie header so it can fetch usage. Click OK to continue." = "CodexBar запитає у macOS Keychain ваш заголовок cookie MiniMax, щоб отримати інформацію про використання. Натисніть OK, щоб продовжити.";
+"CodexBar will ask macOS Keychain for your OpenAI cookie header so it can fetch Codex dashboard extras. Click OK to continue." = "CodexBar запитає у macOS Keychain ваш заголовок файлів cookie OpenAI, щоб він міг отримати додаткові елементи панелі інструментів Codex. Натисніть OK, щоб продовжити.";
+"CodexBar will ask macOS Keychain for your OpenCode cookie header so it can fetch usage. Click OK to continue." = "CodexBar запитає у macOS Keychain ваш заголовок файлу cookie OpenCode, щоб отримати інформацію про використання. Натисніть OK, щоб продовжити.";
+"CodexBar will ask macOS Keychain for your Synthetic API key so it can fetch usage. Click OK to continue." = "CodexBar запитає у macOS Keychain ваш синтетичний ключ API, щоб отримати дані про використання. Натисніть OK, щоб продовжити.";
+"CodexBar will ask macOS Keychain for your z.ai API token so it can fetch usage. Click OK to continue." = "CodexBar запитає у macOS Keychain ваш токен API z.ai, щоб отримати інформацію про використання. Натисніть OK, щоб продовжити.";
+"Could not open Cursor login in your browser." = "Не вдалося відкрити Cursor login у вашому браузері.";
+"Could not open browser for Antigravity" = "Не вдалося відкрити браузер для Антигравітації";
+"Credits used" = "Використані кредити";
+"Day" = "День";
+"Deployment" = "Розгортання";
+"Drag to reorder" = "Перетягніть, щоб змінити порядок";
+"Sort providers alphabetically" = "Сортувати постачальників за алфавітом";
+"Sort providers alphabetically (enabled first)" = "Сортувати постачальників за алфавітом (увімкнені спочатку)";
+"Sorted alphabetically (enabled first) — click to use your custom order" = "Відсортовано за алфавітом (увімкнені спочатку) — натисніть, щоб використати власний порядок";
+"Endpoint" = "Кінцева точка";
+"Enterprise host" = "Корпоративний хост";
+"Extra usage balance: %@" = "Баланс додаткового використання: %@";
+"Keychain Access Required" = "Потрібен доступ до брелка";
+"Kiro menu bar value" = "Значення панелі меню Kiro";
+"Label" = "Мітка";
+"No organizations loaded. Click Refresh after setting your API key." = "Організації не завантажено. Натисніть «Оновити» після встановлення ключа API.";
+"No output captured." = "Немає вихідних даних.";
+"No system account" = "Немає системного облікового запису";
+"Oasis-Token" = "Oasis-Token";
+"Open Augment (Log Out & Back In)" = "Відкрити доповнення (вийти та повернутися)";
+"Open Codebuff Dashboard" = "Відкрийте інформаційну панель Codebuff";
+"Open Command Code Settings" = "Відкрийте налаштування коду команди";
+"Open Crof dashboard" = "Відкрийте інформаційну панель Crof";
+"Open Manus" = "Відкрийте Manus";
+"Open MiMo Balance" = "Відкрийте MiMo Balance";
+"Open Moonshot Console" = "Відкрийте консоль Moonshot";
+"Open Ollama API Keys" = "Відкрийте ключі Ollama API";
+"Open StepFun Platform" = "Відкрийте платформу StepFun";
+"Open T3 Chat Settings" = "Відкрийте налаштування чату T3";
+"Open Volcengine Ark Console" = "Відкрийте консоль Volcengine Ark";
+"Open legacy provider docs" = "Відкрити застарілі документи постачальника";
+"Open projects" = "Відкриті проекти";
+"Open this URL manually to continue login:\n\n%@" = "Відкрийте цю URL-адресу вручну, щоб продовжити вхід: \n\n%@";
+"Optional organization ID for accounts linked to multiple Anthropic organizations." = "Додатковий ідентифікатор організації для облікових записів, пов’язаних із кількома організаціями Anthropic.";
+"Optional. Applies to the configured Admin API key; selected token accounts do not inherit OPENAI_PROJECT_ID." = "Додатково. Застосовується до налаштованого ключа API адміністратора; вибрані облікові записи маркерів не успадковують OPENAI_PROJECT_ID.";
+"Optional. Enter your GitHub Enterprise host, for example octocorp.ghe.com. Leave blank for github.com." = "Додатково. Введіть свій хост GitHub Enterprise, наприклад octocorp.ghe.com. Залиште поле порожнім для github.com.";
+"Optional. Leave blank to discover and aggregate projects visible to the API key." = "Додатково. Залиште поле порожнім, щоб виявити та об’єднати проекти, видимі для ключа API.";
+"Org ID (optional)" = "Ідентифікатор організації (необов’язково)";
+"Organizations" = "організації";
+"Password" = "Пароль";
+"%@ authentication is disabled." = "Автентифікацію %@ вимкнено.";
+"%@ cookies are disabled." = "Файли cookie %@ вимкнено.";
+"%@ web API access is disabled." = "Доступ до веб-API %@ вимкнено.";
+"Disable %@ dashboard cookie usage." = "Вимкнути використання файлів cookie панелі інструментів %@.";
+"Keychain access is disabled in Advanced, so browser cookie import is unavailable." = "Доступ Keychain вимкнено в Advanced, тому імпорт файлів cookie браузера недоступний.";
+"Manually paste an %@ from a browser session." = "Вручну вставте %@ із сеансу браузера.";
+"Paste a Cookie header captured from %@." = "Вставте заголовок файлу cookie, отриманий із %@.";
+"Paste a Cookie header from %@." = "Вставте заголовок файлу cookie з %@.";
+"Paste a Cookie header or cURL capture from %@." = "Вставте заголовок файлу cookie або запис cURL із %@.";
+"Paste a Cookie header or full cURL capture from %@." = "Вставте заголовок файлу cookie або повний запис cURL із %@.";
+"Paste a Cookie or Authorization header from %@." = "Вставте файл cookie або заголовок авторизації з %@.";
+"Paste a full cookie header or the %@ value." = "Вставте повний заголовок cookie або значення %@.";
+"Paste a Cookie header or full cURL capture from T3 Chat settings." = "Вставте заголовок файлу cookie або повний запис cURL із налаштувань T3 Chat.";
+"Paste the Cookie header from a request to admin.mistral.ai. Must contain an ory_session_* cookie." = "Вставте заголовок Cookie із запиту до admin.mistral.ai. Має містити файл cookie ory_session_*.";
+"Paste the Oasis-Token from a logged-in browser session on platform.stepfun.com." = "Вставте Oasis-Token із сеансу браузера, у якому ви ввійшли в систему, на platform.stepfun.com.";
+"Paste the %@ JSON bundle from %@." = "Вставте пакет JSON %@ з %@.";
+"Paste the %@ value or a full Cookie header." = "Вставте значення %@ або повний заголовок файлу cookie.";
+"Personal account" = "Особистий рахунок";
+"Project ID" = "ID проекту";
+"Re-auth" = "Повторна авторизація";
+"Re-login at claude.ai" = "Повторно увійти на claude.ai";
+"Re-authenticating…" = "Повторна автентифікація…";
+"Refresh Session" = "Оновити сеанс";
+"Refresh organizations" = "Оновити організації";
+"Region" = "Регіон";
+"Reload" = "Перезавантажити";
+"Reorder" = "Змінити порядок";
+"Secret access key" = "Секретний ключ доступу";
+"Series" = "Серія";
+"Service" = "Сервіс";
+"Show or hide Kiro credits, percent, or both next to the menu bar icon." = "Показати або приховати кредити Kiro, відсотки або обидва поряд із піктограмою панелі меню.";
+"Show usage for organizations you belong to. Personal account is always shown." = "Показати використання для організацій, до яких ви належите. Особистий рахунок відображається завжди.";
+"Sign in to cursor.com in your browser, then refresh Cursor in CodexBar." = "Увійдіть на cursor.com у своєму браузері, а потім оновіть курсор у CodexBar.";
+"Simulated error text" = "Змодельований текст помилки";
+"StepFun platform account (phone number or email)." = "Обліковий запис на платформі StepFun (номер телефону або електронна пошта).";
+"Stored in ~/.codexbar/config.json." = "Зберігається в ~/.codexbar/config.json.";
+"Stored in ~/.codexbar/config.json. AZURE_OPENAI_API_KEY is also supported." = "Зберігається в ~/.codexbar/config.json. Також підтримується AZURE_OPENAI_API_KEY.";
+"Stored in ~/.codexbar/config.json. For the official Kimi API, use Moonshot / Kimi API." = "Зберігається в ~/.codexbar/config.json. Для офіційного Kimi API використовуйте Moonshot / Kimi API.";
+"Stored in ~/.codexbar/config.json. Get your API key from the Volcengine Ark console." = "Зберігається в ~/.codexbar/config.json. Отримайте ключ API з консолі Volcengine Ark.";
+"Stored in ~/.codexbar/config.json. Get your key from Ollama settings." = "Зберігається в ~/.codexbar/config.json. Отримайте ключ із налаштувань Ollama.";
+"Stored in ~/.codexbar/config.json. Get your key from console.deepgram.com." = "Зберігається в ~/.codexbar/config.json. Отримайте ключ на console.deepgram.com.";
+"Stored in ~/.codexbar/config.json. Get your key from elevenlabs.io/app/settings/api-keys." = "Зберігається в ~/.codexbar/config.json. Отримайте свій ключ на сайті elevenlabs.io/app/settings/api-keys.";
+"Stored in ~/.codexbar/config.json. Get your key from openrouter.ai/settings/keys and set a key spending limit there to enable API key quota tracking." = "Зберігається в ~/.codexbar/config.json. Отримайте свій ключ із openrouter.ai/settings/keys і встановіть там ліміт витрат на ключ, щоб увімкнути відстеження квоти ключів API.";
+"Stored in ~/.codexbar/config.json. In Warp, open Settings > Platform > API Keys, then create one." = "Зберігається в ~/.codexbar/config.json. У Warp відкрийте Налаштування > Платформа > Ключі API, а потім створіть один.";
+"Stored in ~/.codexbar/config.json. Metrics require Groq Enterprise Prometheus access." = "Зберігається в ~/.codexbar/config.json. Метрики потребують доступу до Groq Enterprise Prometheus.";
+"Stored in ~/.codexbar/config.json. OPENAI_ADMIN_KEY is preferred; OPENAI_API_KEY still works." = "Зберігається в ~/.codexbar/config.json. OPENAI_ADMIN_KEY є кращим; OPENAI_API_KEY все ще працює.";
+"Stored in ~/.codexbar/config.json. Requires an Anthropic Admin API key." = "Зберігається в ~/.codexbar/config.json. Потрібен ключ API адміністратора Anthropic.";
+"Stored in ~/.codexbar/config.json. Used for /v1/quota-stats." = "Зберігається в ~/.codexbar/config.json. Використовується для /v1/quota-stats.";
+"Stored in ~/.codexbar/config.json. You can also provide CODEBUFF_API_KEY or let CodexBar read ~/.config/manicode/credentials.json (created by `codebuff login`)." = "Зберігається в ~/.codexbar/config.json. Ви також можете надати CODEBUFF_API_KEY або дозволити CodexBar читати ~/.config/manicode/credentials.json (створений `codebuff login`).";
+"Stored in ~/.codexbar/config.json. You can also provide CROF_API_KEY." = "Зберігається в ~/.codexbar/config.json. Ви також можете надати CROF_API_KEY.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or ~/.local/share/kilo/auth.json (kilo.access)." = "Зберігається в ~/.codexbar/config.json. Ви також можете надати KILO_API_KEY або ~/.local/share/kilo/auth.json (kilo.access).";
+"T3 Chat cookie" = "T3 Чат cookie";
+"That account is no longer available in CodexBar. Refresh the account list and try again." = "Цей обліковий запис більше не доступний у CodexBar. Оновіть список облікових записів і повторіть спробу.";
+"The browser login did not complete in time. Try Antigravity login again." = "Вхід у браузер не завершено вчасно. Спробуйте ще раз увійти в Antigravity.";
+"Timed out waiting for Cursor login. %@" = "Минув час очікування входу курсору. %@";
+"Timed out waiting for Cursor login. %@ Last error: %@" = "Минув час очікування входу курсору. %@ Остання помилка: %@";
+"Today requests" = "Сьогоднішні запити";
+"Total (30d): %@ credits" = "Усього (30 днів): %@ кредитів";
+"Username" = "Ім'я користувача";
+"Uses username + password to login and obtain an Oasis-Token automatically." = "Використовує ім’я користувача + пароль для входу та автоматичного отримання Oasis-Token.";
+"Uses username + password to login and obtain an %@ automatically." = "Використовує ім’я користувача + пароль для входу та автоматичного отримання %@.";
+"Utilization End" = "Кінець використання";
+"Utilization Start" = "Початок використання";
+"Verbosity" = "Багатослівність";
+"Windsurf session JSON bundle" = "Пакет JSON сеансу віндсерфінгу";
+"Workspace ID" = "Ідентифікатор робочої області";
+"Your StepFun platform password. Used to login and obtain a session token." = "Ваш пароль платформи StepFun. Використовується для входу та отримання маркера сесії.";
+"claude /login exited with status %d." = "claude /login вийшов зі статусом %d.";
+"codex login exited with status %d." = "вихід із входу в кодек із статусом %d.";
+"Cookie: …\n\nor paste a cURL capture from the Abacus AI dashboard" = "Файл cookie: …\n\nабо вставте запис cURL із інформаційної панелі Abacus AI";
+"Cookie: …\n\nor paste the __Secure-next-auth.session-token value" = "Файл cookie: …\n\nабо вставте значення __Secure-next-auth.session-token";
+"Cookie: …\n\nor paste the kimi-auth token value" = "Файл cookie: …\n\nабо вставте значення маркера kimi-auth";
+"session_id=...\n\nor paste just the session_id value" = "session_id=...\n\nабо вставте лише значення session_id";
+"Clear" = "ясно";
+"No matching providers" = "Немає відповідних постачальників";
+"Search providers" = "Пошук провайдерів";
+"language_arabic" = "العربية";
+"language_persian" = "فارسی";
+"language_thai" = "ไทย";
+"Limit Reset Credits" = "Кредити скидання ліміту";
+"1 manual reset available" = "Доступне 1 ручне скидання";
+"%d manual resets available" = "Доступно ручних скидань: %d";
+"Next expires %@" = "Наступне спливає %@";
+"Other (%d items)" = "Інше (%d елементів)";
+"Expand" = "Розгорнути";
+"Collapse" = "Згорнути";
+"byte_unit_byte" = "байт";
+"byte_unit_bytes" = "байти";
+"byte_unit_kilobyte" = "кілобайт";
+"byte_unit_kilobytes" = "кілобайти";
+"byte_unit_megabyte" = "мегабайт";
+"byte_unit_megabytes" = "мегабайти";
+"byte_unit_gigabyte" = "гігабайт";
+"byte_unit_gigabytes" = "гігабайти";
diff --git a/Sources/CodexBar/Resources/vi.lproj/Localizable.strings b/Sources/CodexBar/Resources/vi.lproj/Localizable.strings
new file mode 100644
index 0000000000..47724b65a8
--- /dev/null
+++ b/Sources/CodexBar/Resources/vi.lproj/Localizable.strings
@@ -0,0 +1,1106 @@
+/* English localization for CodexBar (base/fallback) */
+
+" providers" = "nhà cung cấp";
+"(System)" = "(Hệ thống)";
+"30d" = "30d";
+"A managed Codex login is already running. Wait for it to finish before adding " = "Đăng nhập Codex được quản lý đã chạy. Đợi quá trình này hoàn tất trước khi thêm";
+"API key" = "API khóa";
+"API region" = "API khu vực";
+"API token" = "API token";
+"API tokens" = "API mã thông báo";
+"About" = "Giới thiệu về";
+"Account" = "Tài khoản";
+"Accounts" = "Tài khoản";
+"Accounts subtitle" = "Phụ đề tài khoản";
+"Active" = "Đang hoạt động";
+"Add" = "Thêm";
+"Add Workspace" = "Thêm không gian làm việc";
+"Advanced" = "Nâng cao";
+"All" = "Tất cả";
+"Always allow prompts" = "Luôn cho phép lời nhắc";
+"Animation pattern" = "Mẫu hoạt ảnh";
+"Antigravity login is managed in the app" = "Đăng nhập chống trọng lực được quản lý trong ứng dụng";
+"Applies only to the Security.framework OAuth keychain reader." = "Chỉ áp dụng cho trình đọc chuỗi khóa Security.framework OAuth.";
+"Auto falls back to the next source if the preferred one fails." = "Tự động quay lại nguồn tiếp theo nếu nguồn ưa thích không thành công.";
+"Auto uses API first, then falls back to CLI on auth failures." = "Tự động sử dụng API trước, sau đó quay lại CLI khi xác thực không thành công.";
+"Auto-detect" = "Tự động phát hiện";
+"Auto-refresh is off; use the menu's Refresh command." = "Tự động làm mới bị tắt; sử dụng lệnh Làm mới của menu.";
+"Auto-refresh: hourly · Timeout: 10m" = "Tự động làm mới: hàng giờ · Thời gian chờ: 10 phút";
+"Automatic" = "Tự động";
+"Automatic imports browser cookies and WorkOS tokens." = "Tự động nhập cookie trình duyệt và mã thông báo WorkOS.";
+"Automatic imports browser cookies and local storage tokens." = "Tự động nhập cookie trình duyệt và mã thông báo lưu trữ cục bộ.";
+"Automatic imports browser cookies for dashboard extras." = "Tự động nhập cookie trình duyệt cho các tính năng bổ sung của trang tổng quan.";
+"Automatic imports browser cookies for the web API." = "Tự động nhập cookie trình duyệt cho web API .";
+"Automatic imports browser cookies from Model Studio/Bailian." = "Tự động nhập cookie trình duyệt từ Model Studio/Bailian.";
+"Automatic imports browser cookies from admin.mistral.ai." = "Tự động nhập cookie trình duyệt từ admin.mistral.ai.";
+"Automatic imports browser cookies from opencode.ai." = "Tự động nhập cookie trình duyệt từ opencode.ai.";
+"Automatic imports browser cookies or stored sessions." = "Tự động nhập cookie trình duyệt hoặc các phiên được lưu trữ.";
+"Automatic imports browser cookies." = "Tự động nhập cookie trình duyệt.";
+"Automatically imports browser session cookie." = "Tự động nhập cookie phiên trình duyệt.";
+"Automatically opens CodexBar when you start your Mac." = "Tự động mở CodexBar khi bạn khởi động máy Mac.";
+"Automation" = "Tự động hóa";
+"Average (\\(label1) + \\(label2))" = "Trung bình (\\(label1) + \\(label2))";
+"Average (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))" = "Trung bình (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))";
+"Avoid Keychain prompts" = "Tránh Keychain lời nhắc";
+"Balance" = "Số dư";
+"Battery Saver" = "Trình tiết kiệm pin";
+"Bordered" = "Có viền";
+"Build" = "Xây dựng";
+"Built \\(buildTimestamp)" = "Đã xây dựng \\(buildTimestamp)";
+"Buy Credits..." = "Mua tín dụng...";
+"Buy Credits…" = "Mua tín dụng... Đường dẫn";
+"CLI paths" = "CLI";
+"CLI sessions" = "CLI phiên";
+"Caches" = "Bộ nhớ đệm";
+"Cancel" = "Hủy";
+"Check for Updates…" = "Kiểm tra cập nhật…";
+"Check for updates automatically" = "Tự động kiểm tra cập nhật";
+"Check if you like your agents having some fun up there." = "Kiểm tra xem bạn có muốn nhân viên của mình vui vẻ ở đó không.";
+"Check provider status" = "Kiểm tra Nhà cung cấp trạng thái";
+"Choose Codex workspace" = "Chọn không gian làm việc Codex";
+"Choose the MiniMax host (global .io or China mainland .com)." = "Chọn máy chủ MiniMax (toàn cầu .io hoặc Trung Quốc đại lục .com).";
+"Choose up to " = "Chọn tối đa";
+"Choose up to \\(Self.maxOverviewProviders) providers" = "Chọn tối đa nhà cung cấp \\(Self.maxOverviewProviders)";
+"Choose up to \\(count) providers" = "Chọn tối đa \\(count) nhà cung cấp";
+"Choose what to show in the menu bar (Pace shows usage vs. expected)." = "Chọn nội dung sẽ hiển thị trong thanh menu (Tốc độ hiển thị Mức sử dụng so với dự kiến).";
+"Choose which Codex account CodexBar should follow." = "Chọn tài khoản Codex mà CodexBar sẽ tuân theo.";
+"Choose which window drives the menu bar percent." = "Chọn cửa sổ nào điều khiển phần trăm thanh menu.";
+"Chrome" = "Chrome";
+"Claude CLI not found" = "Claude CLI không tìm thấy";
+"Claude binary" = "Claude nhị phân";
+"Claude cookies" = "Claude cookie";
+"Claude login failed" = "Claude đăng nhập không thành công";
+"Claude login timed out" = "Claude hết thời gian đăng nhập";
+"Close" = "Đóng";
+"Code review" = "Xem xét mã";
+"Codex CLI not found" = "Không tìm thấy Codex CLI";
+"Codex account login already running" = "Đăng nhập tài khoản Codex đã chạy";
+"Codex binary" = "Codex nhị phân";
+"Codex login failed" = "Đăng nhập Codex không thành công";
+"Codex login timed out" = "Đăng nhập Codex đã hết thời gian chờ";
+"CodexBar Lifecycle Keepalive" = "CodexBar Lifecycle Keepalive";
+"CodexBar can't show its menu bar icon" = "CodexBar không thể hiển thị biểu tượng thanh menu";
+"CodexBar could not read managed account storage. " = "CodexBar không thể đọc bộ nhớ tài khoản được quản lý.";
+"Configure…" = "Định cấu hình…";
+"Connected" = "Đã kết nối";
+"Controls how much detail is logged." = "Kiểm soát lượng chi tiết được ghi lại.";
+"Cookie header" = "Tiêu đề cookie";
+"Cookie source" = "Nguồn cookie";
+"Cookie: ..." = "Cookie: ...";
+"Cookie: \\u{2026}\\\n\\\nor paste a cURL capture from the Abacus AI dashboard" = "Cookie: \\u{2026}\\\n\\\nhoặc dán bản chụp cURL từ bảng điều khiển Abacus AI";
+"Cookie: \\u{2026}\\\n\\\nor paste the __Secure-next-auth.session-token value" = "Cookie: \\u{2026}\\\n\\\nor paste the __Secure-next-auth.session-token value";
+"Cookie: \\u{2026}\\\n\\\nor paste the kimi-auth token value" = "Cookie: \\u{2026}\\\n\\\nhoặc dán giá trị kimi-auth token";
+"Cookie: …" = "Cookie: …";
+"CopilotDeviceFlow" = "CopilotDeviceFlow";
+"Cost" = "Chi phí";
+"Could not add Codex account" = "Không thể thêm tài khoản Codex";
+"Could not open Terminal for Gemini" = "Không thể mở Terminal cho Gemini";
+"Could not start claude /login" = "Không thể bắt đầu claude /đăng nhập";
+"Could not start codex login" = "Không thể bắt đầu đăng nhập codex";
+"Could not switch system account" = "Không thể không chuyển đổi tài khoản hệ thống";
+"Credits" = "Tín dụng";
+"Individual credits" = "Tín dụng cá nhân";
+"Workspace" = "Không gian làm việc";
+"Credits history" = "Lịch sử tín dụng";
+"Cursor login failed" = "Đăng nhập con trỏ không thành công";
+"Custom" = "Tùy chỉnh";
+"Custom Path" = "Đường dẫn tùy chỉnh";
+"Daily Routines" = "Quy trình hàng ngày";
+"Debug" = "Gỡ lỗi";
+"Default" = "Mặc định";
+"Disable Keychain access" = "Tắt quyền truy cập Keychain";
+"Disabled" = "Đã tắt";
+"Dismiss" = "Loại bỏ";
+"Disconnected" = "Đã ngắt kết nối";
+"Display" = "Hiển thị";
+"Display mode" = "Chế độ hiển thị";
+"Display reset times as absolute clock values instead of countdowns." = "Hiển thị Đặt lại thời gian dưới dạng giá trị đồng hồ tuyệt đối thay vì đếm ngược.";
+"Done" = "Xong";
+"Effective PATH" = "PATH hiệu quả";
+"Email" = "Email";
+"Enable Merge Icons to configure Overview tab providers." = "Bật Biểu tượng Hợp nhất để định cấu hình nhà cung cấp tab Tổng quan.";
+"Enable file logging" = "Bật ghi nhật ký tệp";
+"Enabled" = "Đã bật";
+"Error" = "Lỗi";
+"Error simulation" = "Mô phỏng lỗi";
+"Expose troubleshooting tools in the Debug tab." = "Hiển thị các công cụ khắc phục sự cố trong tab Gỡ lỗi.";
+"Failed" = "Không thành công";
+"False" = "Sai";
+"Fetch strategy attempts" = "Thử tìm nạp chiến lược";
+"Fetching" = "Đang tìm nạp";
+"Field" = "Trường";
+"Field subtitle" = "Tiêu đề phụ của trường";
+"Finish the current managed account change before switching the system account." = "Hoàn tất thay đổi tài khoản được quản lý hiện tại trước khi chuyển đổi tài khoản hệ thống.";
+"Force animation on next refresh" = "Không tìm thấy hoạt ảnh bắt buộc trong lần làm mới tiếp theo";
+"Gateway region" = "Vùng cổng";
+"Gemini CLI not found" = "Gemini CLI";
+"Gemini/Antigravity, surfacing incidents in the icon and menu." = "Gemini /Phản trọng lực, xuất hiện các sự cố trong biểu tượng và menu.";
+"General" = "Chung";
+"GitHub" = "GitHub";
+"GitHub Copilot Login" = "Đăng nhập GitHub Copilot";
+"GitHub Login" = "Đăng nhập GitHub";
+"Hide details" = "Ẩn chi tiết";
+"Hide personal information" = "Ẩn thông tin cá nhân";
+"Historical tracking" = "Theo dõi lịch sử";
+"How often CodexBar polls providers in the background." = "Tần suất CodexBar thăm dò ý kiến ​​các nhà cung cấp trong nền.";
+"Inactive" = "Không hoạt động";
+"Install CLI" = "Cài đặt CLI";
+"Install the Claude CLI (npm i -g @anthropic-ai/claude-code) and try again." = "Cài đặt Claude CLI (npm i -g @anthropic-ai/claude-code) và thử lại.";
+"Install the Codex CLI (npm i -g @openai/codex) and try again." = "Cài đặt Codex CLI (npm i -g @openai/codex) và thử lại.";
+"Install the Gemini CLI (npm i -g @google/gemini-cli) and try again." = "Cài đặt Gemini CLI (npm i -g @google/gemini-cli) và thử lại.";
+"JetBrains AI is ready" = "JetBrains AI đã sẵn sàng";
+"JetBrains IDE" = "JetBrains IDE";
+"Keep CLI sessions alive" = "Duy trì CLI phiên hoạt động";
+"Keyboard shortcut" = "Phím tắt";
+"Keychain access" = "Keychain truy cập";
+"Keychain prompt policy" = "Keychain chính sách nhắc";
+"Last \\(name) fetch failed:" = "Tìm nạp \\(name) lần cuối không thành công:";
+"Last \\(self.store.metadata(for: self.provider).displayName) fetch failed:" = "Lần tìm nạp \\(self.store.metadata(for: self.provider).displayName) lần cuối không thành công:";
+"Last attempt" = "Lần thử cuối cùng";
+"Link" = "Liên kết";
+"Loading animations" = "Đang tải hình động";
+"Loading…" = "Đang tải…";
+"Local" = "Cục bộ";
+"Logging" = "Ghi nhật ký";
+"Login failed" = "Đăng nhập không thành công";
+"Login shell PATH (startup capture)" = "Shell đăng nhập PATH (chụp khởi động)";
+"Login timed out" = "Đã hết thời gian đăng nhập";
+"MCP details" = "Chi tiết MCP";
+"Managed Codex accounts unavailable" = "Tài khoản Codex được quản lý không khả dụng";
+"Managed account storage is unreadable. Live account access is still available, " = "Không thể đọc được bộ nhớ tài khoản được quản lý. Quyền truy cập tài khoản trực tiếp vẫn khả dụng,";
+"Manual" = "Thủ công";
+"May your tokens never run out—keep agent limits in view." = "Cầu mong mã thông báo của bạn không bao giờ hết—luôn theo dõi giới hạn đại lý.";
+"Menu bar" = "thanh menu";
+"Menu bar auto-shows the provider closest to its rate limit." = "thanh menu tự động hiển thị Nhà cung cấp gần nhất với giới hạn tốc độ của nó.";
+"Menu bar metric" = "thanh menu số liệu";
+"Menu bar shows percent" = "thanh menu hiển thị phần trăm";
+"Menu content" = "Nội dung menu";
+"Merge Icons" = "Hợp nhất các biểu tượng";
+"Never prompt" = "Không bao giờ nhắc";
+"No" = "Không có";
+"No Codex accounts detected yet." = "Chưa phát hiện thấy tài khoản Codex nào.";
+"No JetBrains IDE detected" = "Không phát hiện thấy JetBrains IDE";
+"No cost history data." = "Không có dữ liệu lịch sử chi phí.";
+"No data available" = "Không có dữ liệu";
+"No data yet" = "Chưa có dữ liệu";
+"No enabled providers available for Overview." = "Không có nhà cung cấp nào được bật cho Tổng quan.";
+"No providers selected" = "Chưa có nhà cung cấp nào được chọn";
+"No token accounts yet." = "Chưa có tài khoản token.";
+"No usage breakdown data." = "Không có dữ liệu phân tích Mức sử dụng.";
+"None" = "Không có";
+"Notifications" = "Thông báo";
+"Notifies when the 5-hour session quota hits 0% and when it becomes " = "Thông báo khi phiên 5 giờ Hạn mức đạt 0% và khi nó trở thành";
+"OK" = "OK";
+"Obscure email addresses in the menu bar and menu UI." = "Ẩn địa chỉ email trong thanh menu và giao diện người dùng menu.";
+"Off" = "Tắt";
+"Offline" = "Ngoại tuyến";
+"On" = "Bật";
+"Online" = "Trực tuyến";
+"Only on user action" = "Chỉ khi hành động của người dùng";
+"Open" = "Mở";
+"Open API Keys" = "Mở API Phím";
+"Open Amp Settings" = "Mở Amp Cài đặt";
+"Open Antigravity to sign in, then refresh CodexBar." = "Mở Chống trọng lực để đăng nhập, sau đó làm mới CodexBar .";
+"Open Browser" = "Mở trình duyệt";
+"Open Coding Plan" = "Mở kế hoạch mã hóa";
+"Open Console" = "Mở bảng điều khiển";
+"Open Dashboard" = "Mở bảng điều khiển";
+"Open Mistral Admin" = "Mở quản trị viên Mistral";
+"Open Menu Bar Settings" = "Mở thanh menu Cài đặt";
+"Open Ollama Settings" = "Mở Ollama Cài đặt";
+"Open Terminal" = "Mở Terminal";
+"Open Usage Page" = "Mở Mức sử dụng Trang";
+"Open Warp API Key Guide" = "Hướng dẫn chính về Open Warp API";
+"Open menu" = "Mở menu";
+"Open token file" = "Mở token tệp";
+"OpenAI cookies" = "OpenAI cookie";
+"OpenAI web extras" = "OpenAI phần bổ sung web";
+"Option A" = "Tùy chọn A";
+"Option B" = "Tùy chọn B";
+"Optional override if workspace lookup fails." = "Ghi đè tùy chọn nếu tra cứu không gian làm việc không thành công.";
+"Options" = "Tùy chọn";
+"Override auto-detection with a custom IDE base path" = "Ghi đè tính năng tự động phát hiện bằng đường dẫn cơ sở IDE tùy chỉnh";
+"Overview" = "Tổng quan";
+"Overview rows always follow provider order." = "Các hàng tổng quan luôn tuân theo thứ tự Nhà cung cấp.";
+"Overview tab providers" = "Nhà cung cấp tab tổng quan";
+"Paste API key…" = "Dán API key…";
+"Paste API token…" = "Dán API token …";
+"Paste key…" = "Dán khóa…";
+"Paste sessionKey or OAuth token…" = "Dán sessionKey hoặc OAuth token …";
+"Paste the Cookie header from a request to admin.mistral.ai. " = "Dán tiêu đề Cookie từ yêu cầu tới admin.mistral.ai.";
+"Paste token…" = "Dán token …";
+"Personal" = "Cá nhân";
+"Picker" = "Bộ chọn";
+"Picker subtitle" = "Tiêu đề phụ của bộ chọn";
+"Placeholder" = "Trình giữ chỗ";
+"Plan" = "Kế hoạch";
+"Play full-screen confetti when weekly usage resets." = "Phát hoa giấy toàn màn hình khi đặt lại Mức sử dụng hàng tuần.";
+"Polls OpenAI/Claude status pages and Google Workspace for " = "Cuộc thăm dò ý kiến ​​OpenAI / Claude trang trạng thái và Google Không gian làm việc dành cho";
+"Prevents any Keychain access while enabled." = "Ngăn chặn mọi quyền truy cập Keychain khi được bật.";
+"Primary (API key limit)" = "Chính ( API giới hạn khóa)";
+"Primary (\\(label))" = "Chính (\\(label))";
+"Primary (\\(metadata.sessionLabel))" = "Chính (\\(metadata.sessionLabel))";
+"Probe logs" = "Nhật ký thăm dò";
+"Progress bars fill as you consume quota (instead of showing remaining)." = "Thanh tiến trình sẽ lấp đầy khi bạn sử dụng Hạn mức (thay vì hiển thị phần còn lại).";
+"Provider" = "Nhà cung cấp";
+"Providers" = "Nhà cung cấp";
+"Quit CodexBar" = "Thoát CodexBar";
+"Random (default)" = "Ngẫu nhiên (mặc định)";
+"Reads local usage logs. Shows today + last 30 days cost in the menu." = "Đọc nhật ký Mức sử dụng cục bộ. Hiển thị hôm nay + cửa sổ lịch sử đã chọn trong menu.";
+"Refresh" = "Làm mới";
+"Refresh cadence" = "Nhịp làm mới";
+"Remote" = "Từ xa";
+"Remove" = "Xóa";
+"Remove Codex account?" = "Xóa tài khoản Codex?";
+"Remove \\(account.email) from CodexBar? Its managed Codex home will be deleted." = "Xóa \\(account.email) khỏi CodexBar ? Trang chủ Codex được quản lý của nó sẽ bị xóa.";
+"Remove \\(email) from CodexBar? Its managed Codex home will be deleted." = "Xóa \\(email) khỏi CodexBar ? Trang chủ Codex được quản lý của nó sẽ bị xóa.";
+"Remove selected account" = "Xóa tài khoản đã chọn";
+"Replace critter bars with provider branding icons and a percentage." = "Thay thế các thanh sinh vật bằng Nhà cung cấp biểu tượng nhãn hiệu và tỷ lệ phần trăm.";
+"Replay selected animation" = "Phát lại hoạt ảnh đã chọn";
+"Requires authentication via GitHub Device Flow." = "Yêu cầu xác thực thông qua GitHub Device Flow.";
+"Resets: \\(reset)" = "Đặt lại: \\(reset)";
+"Rolling five-hour limit" = "Giới hạn 5 giờ liên tục";
+"Search hourly" = "Tìm kiếm hàng giờ";
+"Secondary (\\(label))" = "Phụ (\\(label))";
+"Secondary (\\(metadata.weeklyLabel))" = "Phụ (\\(metadata.weeklyLabel))";
+"Select a provider" = "Chọn một Nhà cung cấp";
+"Select the IDE to monitor" = "Chọn IDE để giám sát";
+"Session quota notifications" = "Thông báo phiên Hạn mức";
+"Session tokens" = "Mã thông báo phiên";
+"Settings" = "Cài đặt";
+"Show Codex Credits and Claude Extra usage sections in the menu." = "Hiển thị Tín dụng Codex và Claude Các phần Mức sử dụng bổ sung trong menu.";
+"Show Debug Settings" = "Hiển thị gỡ lỗi Cài đặt";
+"Show all token accounts" = "Hiển thị tất cả token tài khoản";
+"Show cost summary" = "Hiển thị tóm tắt chi phí";
+"Show credits + extra usage" = "Hiển thị tín dụng + bổ sung Mức sử dụng";
+"Show details" = "Hiển thị chi tiết";
+"Show most-used provider" = "Hiển thị Nhà cung cấp";
+"Show provider icons in the switcher (otherwise show a weekly progress line)." = "được sử dụng nhiều nhất Hiển thị các biểu tượng Nhà cung cấp trong trình chuyển đổi (nếu không thì hiển thị dòng tiến trình hàng tuần).";
+"Show reset time as clock" = "Hiển thị thời gian Đặt lại dưới dạng đồng hồ";
+"Show usage as used" = "Hiển thị Mức sử dụng như đã sử dụng";
+"Sign in via button below" = "Đăng nhập bằng nút bên dưới";
+"Skip teardown between probes (debug-only)." = "Bỏ qua việc phân tích giữa các thăm dò (chỉ dành cho gỡ lỗi).";
+"Stack token accounts in the menu (otherwise show an account switcher bar)." = "Xếp chồng các tài khoản token trong menu (nếu không sẽ hiển thị thanh trình chuyển đổi tài khoản).";
+"Start at Login" = "Bắt đầu khi đăng nhập";
+"Status" = "Trạng thái";
+"Store Claude sessionKey cookies or OAuth access tokens." = "Lưu trữ Claude cookie sessionKey hoặc OAuth mã thông báo truy cập.";
+"Store multiple Abacus AI Cookie headers." = "Lưu trữ nhiều tiêu đề Cookie Abacus AI.";
+"Store multiple Augment Cookie headers." = "Lưu trữ nhiều tiêu đề Cookie tăng cường.";
+"Store multiple Cursor Cookie headers." = "Lưu trữ nhiều tiêu đề Cookie con trỏ.";
+"Store multiple Factory Cookie headers." = "Lưu trữ nhiều tiêu đề Cookie gốc.";
+"Store multiple MiniMax Cookie headers." = "Lưu trữ nhiều tiêu đề cookie MiniMax.";
+"Store multiple Mistral Cookie headers." = "Lưu trữ nhiều tiêu đề Mistral Cookie.";
+"Store multiple Ollama Cookie headers." = "Lưu trữ nhiều tiêu đề Cookie Ollama.";
+"Store multiple OpenCode Cookie headers." = "Lưu trữ nhiều tiêu đề Cookie OpenCode.";
+"Store multiple OpenCode Go Cookie headers." = "Lưu trữ nhiều tiêu đề Cookie OpenCode Go.";
+"Stored in the CodexBar config file." = "Được lưu trữ trong tệp cấu hình CodexBar.";
+"Stored in ~/.codexbar/config.json. " = "Được lưu trữ trong ~/.codexbar/config.json.";
+"Stored in ~/.codexbar/config.json. Generate one at kimi-k2.ai." = "Được lưu trữ trong ~/.codexbar/config.json. Tạo một cái tại kimi-k2.ai.";
+"Stored in ~/.codexbar/config.json. Paste the key from the Synthetic dashboard." = "Được lưu trữ trong ~/.codexbar/config.json. Dán khóa từ bảng điều khiển Tổng hợp.";
+"Stored in ~/.codexbar/config.json. Paste your Coding Plan API key from Model Studio." = "Được lưu trữ trong ~/.codexbar/config.json. Dán khóa Kế hoạch mã hóa API của bạn từ Model Studio.";
+"Stored in ~/.codexbar/config.json. Paste your MiniMax API key." = "Được lưu trữ trong ~/.codexbar/config.json. Dán khóa MiniMax API của bạn.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or " = "Được lưu trữ trong ~/.codexbar/config.json. Bạn cũng có thể cung cấp lịch sử KILO_API_KEY hoặc";
+"Stores local Codex usage history (8 weeks) to personalize Pace predictions." = "Stores Codex cục bộ Mức sử dụng (8 tuần) để cá nhân hóa dự đoán Pace.";
+"Subscription Utilization" = "Gói đăng ký Mức sử dụng";
+"Surprise me" = "Làm tôi ngạc nhiên";
+"Switcher shows icons" = "Trình chuyển đổi hiển thị các biểu tượng";
+"Symlink CodexBarCLI to /usr/local/bin and /opt/homebrew/bin as codexbar." = "Symlink CodexBarCLI tới /usr/local/bin và /opt/homebrew/bin dưới dạng codexbar.";
+"System" = "Hệ thống";
+"Temporarily shows the loading animation after the next refresh." = "Tạm thời hiển thị hoạt ảnh đang tải sau lần làm mới tiếp theo.";
+"Tertiary (\\(label))" = "Cấp ba (\\(label))";
+"Tertiary (\\(tertiaryTitle))" = "Cấp ba (\\(tertiaryTitle))";
+"The default Codex account on this Mac." = "Tài khoản Codex mặc định trên máy Mac này.";
+"Toggle" = "Chuyển đổi";
+"Toggle subtitle" = "Chuyển đổi phụ đề";
+"Token" = "token";
+"Trigger the menu bar menu from anywhere." = "Kích hoạt menu thanh menu từ mọi nơi.";
+"True" = "Đúng";
+"Twitter" = "Twitter";
+"Unsupported" = "Không được hỗ trợ";
+"Update Channel" = "Kênh cập nhật";
+"Updated" = "Đã cập nhật";
+"Updates unavailable in this build." = "Các bản cập nhật không có sẵn trong bản dựng này.";
+"Usage" = "Mức sử dụng";
+"Usage breakdown" = "Mức sử dụng sự cố";
+"Usage history (30 days)" = "Mức sử dụng lịch sử";
+"Usage source" = "Mức sử dụng nguồn";
+"Use BigModel for the China mainland endpoints (open.bigmodel.cn)." = "Sử dụng BigModel cho các điểm cuối ở Trung Quốc đại lục (open.bigmodel.cn).";
+"Use a single menu bar icon with a provider switcher." = "Sử dụng một biểu tượng thanh menu duy nhất với trình chuyển đổi Nhà cung cấp.";
+"Use international or China mainland console gateways for quota fetches." = "Sử dụng cổng bảng điều khiển quốc tế hoặc Trung Quốc đại lục để tìm nạp Hạn mức.";
+"Version" = "Phiên bản";
+"Version \\(self.versionString)" = "Phiên bản \\(self.versionString)";
+"Version \\(version)" = "Phiên bản \\(version)";
+"Version \\(versionString)" = "Phiên bản \\(versionString)";
+"Vertex AI Login" = "Vertex AI Đăng nhập";
+"Wait for the current managed Codex login to finish before adding another account." = "Đợi quá trình đăng nhập Codex được quản lý hiện tại hoàn tất trước khi thêm tài khoản khác.";
+"Waiting for Authentication..." = "Đang chờ xác thực...";
+"Website" = "Trang web";
+"Weekly limit confetti" = "Hoa giấy giới hạn hàng tuần";
+"Weekly token limit" = "token giới hạn";
+"Weekly usage" = "Hàng tuần Mức sử dụng";
+"Weekly usage unavailable for this account." = "Hàng tuần Mức sử dụng không khả dụng cho tài khoản này.";
+"Window: \\(window)" = "Cửa sổ: \\(window)";
+"Write logs to \\(self.fileLogPath) for debugging." = "Ghi nhật ký vào \\(self.fileLogPath) để gỡ lỗi.";
+"Yes" = "Có";
+"\\(detail.modelCode): \\(usage)" = "\\(detail.modelCode): \\(usage)";
+"\\(name): \\(truncated)" = "\\(name): \\(truncated)";
+"\\(name): \\(updated) · 30d \\(cost)" = "\\(name): \\(updated) · 30d \\(cost)";
+"\\(name): fetching…\\(elapsed)" = "\\(name): đang tìm nạp…\\(elapsed)";
+"\\(name): last attempt \\(when)" = "\\(name): lần thử cuối cùng \\(when)";
+"\\(name): no data yet" = "\\(name): chưa có dữ liệu";
+"\\(name): unsupported" = "\\(name): không được hỗ trợ";
+"all browsers" = "tất cả các trình duyệt";
+"available again." = "khả dụng trở lại.";
+"built_format" = "Đã xây dựng %@";
+"copilot_complete_in_browser" = "Hoàn tất đăng nhập vào trình duyệt của bạn.";
+"copilot_device_code" = "Mã thiết bị được sao chép vào bảng nhớ tạm: %1$@\n\nXác minh tại: %2$@";
+"copilot_device_code_copied" = "Đã sao chép mã thiết bị.";
+"copilot_verify_at" = "Xác minh tại %@";
+"copilot_waiting_text" = "Hoàn tất đăng nhập vào trình duyệt của bạn.\nCửa sổ này tự động đóng khi quá trình đăng nhập hoàn tất.";
+"copilot_window_closes_auto" = "Cửa sổ này tự động đóng khi quá trình đăng nhập hoàn tất.";
+"cost_status_error" = "%1$@ : %2$@";
+"cost_status_fetching" = "%1$@ : đang tìm nạp… %2$@";
+"cost_status_last_attempt" = "%1$@ : lần thử cuối cùng %2$@";
+"cost_status_no_data" = "%@ : không có dữ liệu chưa";
+"cost_status_snapshot" = "%1$@ : %2$@ · %3$@ %4$@";
+"cost_status_unsupported" = "%@ : không được hỗ trợ";
+"credits_remaining" = "Tín dụng: %@";
+"cursor_on_demand" = "Theo yêu cầu: %@";
+"cursor_on_demand_with_limit" = "Theo yêu cầu: %1$@ / %2$@";
+"extra_usage_format" = "Mức sử dụng bổ sung : %1$@ / %2$@";
+"jetbrains_detected_generate" = "Đã phát hiện: %@ . Sử dụng trợ lý AI một lần để tạo dữ liệu Hạn mức, sau đó làm mới CodexBar .";
+"jetbrains_detected_select" = "Đã phát hiện: %@ . Chọn IDE ưa thích của bạn trong Cài đặt , sau đó làm mới CodexBar .";
+"last_fetch_failed_with_provider" = "Tìm nạp %@ lần cuối không thành công:";
+"last_spend" = "Chi tiêu lần cuối: %@";
+"mcp_model_usage" = "%1$@ : %2$@";
+"mcp_resets" = "Đặt lại: %@";
+"mcp_window" = "Cửa sổ: %@";
+"metric_average" = "Trung bình ( %1$@ + %2$@ )";
+"metric_primary" = "Sơ cấp ( %@ )";
+"metric_secondary" = "Trung học ( %@ )";
+"metric_tertiary" = "Cấp ba ( %@ )";
+"multiple_workspaces_found" = "CodexBar đã tìm thấy nhiều không gian làm việc cho %@ . Vui lòng chọn không gian làm việc để thêm.";
+"ory_session_…=…; csrftoken=…" = "ory_session_…=…; csrftoken=…";
+"overview_choose_providers" = "Chọn tối đa %@ nhà cung cấp";
+"remove_account_message" = "Xóa %@ khỏi CodexBar ? Trang chủ Codex được quản lý của nó sẽ bị xóa.";
+"version_format" = "Phiên bản %@";
+"vertex_ai_login_instructions" = "Để theo dõi Vertex AI Mức sử dụng , hãy xác thực bằng Google Cloud.\n\n1. Mở Terminal\n2. Chạy: gcloud auth application-default login\n3. Làm theo lời nhắc của trình duyệt để đăng nhập\n4. Đặt dự án của bạn: gcloud config set project PROJECT_ID\n\nMở Thiết bị đầu cuối bây giờ?";
+"workspaceID is set but only opencode, opencodego, and deepgram support workspaceID." = "ID không gian làm việc được đặt nhưng chỉ có mã mở, opencodego và deepgram hỗ trợ ID không gian làm việc.";
+"© 2026 Peter Steinberger. MIT License." = "© 2026 Peter Steinberger. Giấy phép MIT.";
+
+/* General Pane */
+"section_system" = "Hệ thống";
+"section_usage" = "Mức sử dụng";
+"section_automation" = "Tự động hóa";
+"language_title" = "Ngôn ngữ";
+"language_subtitle" = "Thay đổi ngôn ngữ hiển thị. Yêu cầu khởi động lại ứng dụng để có hiệu lực đầy đủ.";
+"language_system" = "Hệ thống";
+"language_english" = "Tiếng Anh";
+"language_spanish" = "Español";
+"language_catalan" = "Català";
+"language_chinese_simplified" = "简体中文";
+"language_chinese_traditional" = "繁體中文";
+"language_portuguese_brazilian" = "Português (Brasil)";
+"language_german" = "Deutsch";
+"language_swedish" = "Svenska";
+"language_french" = "Tiếng Pháp";
+"language_dutch" = "Tiếng Hà Lan";
+"language_ukrainian" = "Tiếng Ukraina";
+"language_japanese" = "Tiếng Nhật";
+"language_korean" = "Tiếng Hàn";
+"language_italian" = "Italiano";
+"start_at_login_title" = "Bắt đầu khi đăng nhập";
+"start_at_login_subtitle" = "Tự động mở CodexBar khi bạn khởi động máy Mac.";
+"show_cost_summary" = "Hiển thị tóm tắt chi phí";
+"show_cost_summary_subtitle" = "Đọc nhật ký Mức sử dụng cục bộ. Hiển thị hôm nay + cửa sổ lịch sử đã chọn trong menu.";
+"cost_history_days_title" = "Cửa sổ lịch sử: %d ngày";
+"cost_auto_refresh_info" = "Tự động làm mới: hàng giờ · Thời gian chờ: 10 phút";
+"refresh_cadence_title" = "Nhịp làm mới";
+"refresh_cadence_subtitle" = "Tần suất CodexBar thăm dò ý kiến ​​các nhà cung cấp trong nền.";
+"manual_refresh_hint" = "Tính năng tự động làm mới bị tắt; sử dụng lệnh Làm mới của menu.";
+"check_provider_status_title" = "Kiểm tra Nhà cung cấp trạng thái";
+"check_provider_status_subtitle" = "Thăm dò ý kiến ​​OpenAI / Claude các trang trạng thái và Google Không gian làm việc dành cho Gemini /AntiGravity, phát hiện các sự cố trong biểu tượng và menu.";
+"session_quota_notifications_title" = "Thông báo về phiên Hạn mức";
+"session_quota_notifications_subtitle" = "Thông báo khi phiên 5 giờ Hạn mức đạt 0% và khi phiên này khả dụng trở lại.";
+"quota_warning_notifications_title" = "Hạn mức thông báo cảnh báo";
+"quota_warning_notifications_subtitle" = "Cảnh báo khi phiên hoặc Hạn mức còn lại hàng tuần vượt qua ngưỡng được định cấu hình.";
+"quota_warnings_title" = "Hạn mức cảnh báo";
+"quota_warning_session" = "phiên";
+"quota_warning_session_capitalized" = "Phiên";
+"quota_warning_weekly" = "hàng tuần";
+"quota_warning_weekly_capitalized" = "Hàng tuần";
+"quota_warning_notification_title" = "%1$@ %2$@ Hạn mức thấp";
+"quota_warning_notification_body" = "%1$@ left. Reached your %2$d%% %3$@ warning threshold.";
+"quota_warning_notification_body_with_account" = "Tài khoản %1$@ . Còn lại %2$@. Đã đạt đến ngưỡng cảnh báo %3$d %% %4$@ của bạn.";
+"session_depleted_notification_title" = "%@ phiên đã hết";
+"session_depleted_notification_body" = "còn lại 0%. Sẽ thông báo khi có lại.";
+"session_restored_notification_title" = "%@ phiên đã được khôi phục";
+"session_restored_notification_body" = "Phiên Hạn mức đã có sẵn trở lại.";
+"quota_warning_warn_at" = "Cảnh báo ở";
+"quota_warning_global_threshold_subtitle" = "Tỷ lệ phần trăm còn lại cho phiên và thời lượng hàng tuần trừ khi Nhà cung cấp ghi đè chúng.";
+"quota_warning_sound" = "Phát âm thanh thông báo";
+"quota_warning_provider_inherits" = "Sử dụng cảnh báo Hạn mức toàn cầu Cài đặt trừ khi một cửa sổ được tùy chỉnh tại đây.";
+"quota_warning_customize_thresholds" = "Tùy chỉnh %@ ngưỡng";
+"quota_warning_enable_warnings" = "Bật %@ cảnh báo";
+"quota_warning_window_warn_at" = "%@ cảnh báo lúc";
+"quota_warning_off" = "Tắt";
+"quota_warning_inherited" = "Đã kế thừa: %@";
+"quota_warning_depleted_only" = "chỉ đã cạn";
+"quota_warning_upper" = "Thượng";
+"quota_warning_lower" = "Hạ";
+"apply" = "Áp dụng";
+"quit_app" = "Thoát CodexBar";
+
+/* Tab titles */
+"tab_general" = "Chung";
+"tab_providers" = "Nhà cung cấp";
+"tab_display" = "Hiển thị";
+"tab_advanced" = "Nâng cao";
+"tab_about" = "Giới thiệu về";
+"tab_debug" = "Gỡ lỗi";
+
+/* Providers Pane */
+"select_a_provider" = "Chọn một Nhà cung cấp";
+"cancel" = "Hủy";
+"last_fetch_failed" = "lần tìm nạp cuối cùng không thành công";
+"usage_not_fetched_yet" = "Mức sử dụng chưa được tìm nạp";
+"managed_account_storage_unreadable" = "Bộ nhớ tài khoản được quản lý không thể đọc được. Quyền truy cập tài khoản trực tiếp vẫn khả dụng nhưng các hành động thêm, xác thực lại và xóa được quản lý sẽ bị vô hiệu hóa cho đến khi có thể khôi phục được cửa hàng.";
+"remove_codex_account_title" = "Xóa tài khoản Codex?";
+"remove" = "Xóa";
+"managed_login_already_running" = "Đăng nhập Codex được quản lý đã chạy. Đợi quá trình hoàn tất trước khi thêm hoặc xác thực lại tài khoản khác.";
+"managed_login_failed" = "Đăng nhập Codex được quản lý không hoàn tất. Xác minh rằng `codex --version` hoạt động trong Terminal. Nếu macOS đã chặn hoặc di chuyển `codex` vào Thùng rác, hãy xóa các bản cài đặt trùng lặp cũ, chạy `npm install -g --include=Optional @openai/codex@latest`, sau đó thử lại.";
+"codex_login_output" = "đầu ra đăng nhập codex:";
+"managed_login_missing_email" = "Đăng nhập Codex đã hoàn tất nhưng không có email tài khoản. Hãy thử lại sau khi xác nhận tài khoản đã đăng nhập đầy đủ.";
+"login_success_notification_title" = "%@ đăng nhập thành công";
+"login_success_notification_body" = "Bạn có thể quay lại ứng dụng; xác thực xong.";
+"workspace_selection_cancelled" = "CodexBar đã tìm thấy nhiều không gian làm việc nhưng không có không gian làm việc nào được chọn.";
+"unsafe_managed_home" = "CodexBar từ chối sửa đổi đường dẫn chính được quản lý không mong muốn: %@";
+"menu_bar_metric_title" = "thanh menu chỉ số";
+"menu_bar_metric_subtitle" = "Chọn cửa sổ nào thúc đẩy phần trăm thanh menu.";
+"menu_bar_metric_subtitle_deepseek" = "Hiển thị số dư DeepSeek trong thanh menu .";
+"menu_bar_metric_subtitle_moonshot" = "Hiển thị số dư Moonshot / Kimi API trong thanh menu .";
+"menu_bar_metric_subtitle_mistral" = "Hiển thị mức chi tiêu API của Mistral trong tháng hiện tại trong thanh menu .";
+"menu_bar_metric_subtitle_kimik2" = "Hiển thị Kimi K2 API -các khoản tín dụng chính trong thanh menu .";
+"automatic" = "Tự động";
+"primary_api_key_limit" = "Chính ( API giới hạn khóa)";
+
+/* Display Pane */
+"section_menu_bar" = "thanh menu";
+"merge_icons_title" = "Hợp nhất các biểu tượng";
+"merge_icons_subtitle" = "Sử dụng một biểu tượng thanh menu duy nhất với trình chuyển đổi Nhà cung cấp.";
+"switcher_shows_icons_title" = "Trình chuyển đổi hiển thị các biểu tượng";
+"switcher_shows_icons_subtitle" = "Hiển thị các biểu tượng Nhà cung cấp trong trình chuyển đổi (nếu không thì hiển thị dòng tiến trình hàng tuần).";
+"show_most_used_provider_title" = "Hiển thị Nhà cung cấp";
+"show_most_used_provider_subtitle" = "thanh menu được sử dụng nhiều nhất tự động hiển thị Nhà cung cấp gần nhất với giới hạn tốc độ của nó.";
+"menu_bar_shows_percent_title" = "thanh menu hiển thị phần trăm";
+"menu_bar_shows_percent_subtitle" = "Thay thế thanh sinh vật bằng Nhà cung cấp biểu tượng thương hiệu và tỷ lệ phần trăm.";
+"hide_critters_title" = "Ẩn sinh vật";
+"hide_critters_subtitle" = "Hiển thị thanh đo đơn giản không có khuôn mặt và trang trí.";
+"display_mode_title" = "Chế độ hiển thị";
+"display_mode_subtitle" = "Chọn nội dung sẽ hiển thị trong thanh menu (Tốc độ hiển thị Mức sử dụng so với dự kiến).";
+"section_menu_content" = "Nội dung menu";
+"show_usage_as_used_title" = "Hiển thị Mức sử dụng dưới dạng đã sử dụng";
+"show_usage_as_used_subtitle" = "Thanh tiến trình sẽ lấp đầy khi bạn sử dụng Hạn mức (thay vì hiển thị phần còn lại).";
+"show_quota_warning_markers_title" = "Hiển thị Hạn mức dấu cảnh báo";
+"show_quota_warning_markers_subtitle" = "Vẽ dấu kiểm ngưỡng trên thanh Mức sử dụng khi cảnh báo Hạn mức được định cấu hình.";
+"weekly_progress_work_days_title" = "Tiến độ ngày làm việc hàng tuần";
+"weekly_progress_work_days_subtitle" = "Đặt ngày làm việc cho các vạch trên thanh sử dụng hằng tuần và phép tính nhịp độ.";
+"show_reset_time_as_clock_title" = "Hiển thị Đặt lại thời gian dưới dạng đồng hồ";
+"show_reset_time_as_clock_subtitle" = "Hiển thị Đặt lại thời gian dưới dạng giá trị đồng hồ tuyệt đối thay vì đếm ngược.";
+"show_provider_changelog_links_title" = "Hiển thị Nhà cung cấp liên kết nhật ký thay đổi";
+"show_provider_changelog_links_subtitle" = "Thêm liên kết ghi chú phát hành cho các nhà cung cấp được hỗ trợ CLI vào menu.";
+"show_credits_extra_usage_title" = "Hiển thị tín dụng + phần Mức sử dụng";
+"show_credits_extra_usage_subtitle" = "Hiển thị tín dụng Codex và Claude Các phần Mức sử dụng bổ sung trong menu.";
+"show_all_token_accounts_title" = "Hiển thị tất cả các tài khoản token";
+"show_all_token_accounts_subtitle" = "Xếp chồng các tài khoản token trong menu (nếu không thì hiển thị thanh trình chuyển đổi tài khoản).";
+"multi_account_layout_title" = "Bố cục nhiều tài khoản";
+"multi_account_layout_subtitle" = "Chọn thẻ tài khoản chuyển đổi phân đoạn hoặc thẻ tài khoản xếp chồng.";
+"multi_account_layout_segmented" = "Được phân đoạn";
+"multi_account_layout_stacked" = "Xếp chồng";
+"overview_tab_providers_title" = "Nhà cung cấp tab tổng quan";
+"configure" = "Định cấu hình…";
+"overview_enable_merge_icons_hint" = "Bật Hợp nhất Biểu tượng để định cấu hình nhà cung cấp tab Tổng quan.";
+"overview_no_providers_hint" = "Không có nhà cung cấp nào được bật cho phần Tổng quan.";
+"overview_rows_follow_order" = "Các hàng tổng quan luôn tuân theo thứ tự Nhà cung cấp.";
+"overview_no_providers_selected" = "Không có nhà cung cấp nào được chọn";
+
+/* Advanced Pane */
+"section_keyboard_shortcut" = "Phím tắt";
+"open_menu_shortcut_title" = "Mở menu";
+"open_menu_shortcut_subtitle" = "Kích hoạt menu thanh menu từ mọi nơi.";
+"install_cli" = "Cài đặt CLI";
+"install_cli_subtitle" = "Liên kết tượng trưng CodexBarCLI tới /usr/local/bin và /opt/homebrew/bin dưới dạng codexbar.";
+"cli_not_found" = "Không tìm thấy CodexBarCLI trong gói ứng dụng.";
+"no_writable_bin_dirs" = "Không tìm thấy thư mục bin có thể ghi.";
+"show_debug_settings_title" = "Hiển thị gỡ lỗi Cài đặt";
+"show_debug_settings_subtitle" = "Hiển thị các công cụ khắc phục sự cố trong tab Gỡ lỗi.";
+"surprise_me_title" = "Làm tôi ngạc nhiên";
+"surprise_me_subtitle" = "Kiểm tra xem bạn có thích các đại lý của mình vui vẻ ở đó không.";
+"weekly_limit_confetti_title" = "Hoa giấy giới hạn hàng tuần";
+"weekly_limit_confetti_subtitle" = "Phát hoa giấy toàn màn hình khi đặt lại Mức sử dụng hàng tuần.";
+"hide_personal_info_title" = "Ẩn thông tin cá nhân";
+"hide_personal_info_subtitle" = "Địa chỉ email tối nghĩa trong thanh menu và giao diện người dùng menu.";
+"show_provider_storage_usage_title" = "Hiển thị Nhà cung cấp bộ nhớ Mức sử dụng";
+"show_provider_storage_usage_subtitle" = "Hiển thị ổ đĩa cục bộ Mức sử dụng trong menu. Quét các đường dẫn thuộc quyền sở hữu của Nhà cung cấp đã biết ở chế độ nền.";
+"section_keychain_access" = "Keychain quyền truy cập";
+"keychain_access_caption" = "Tắt tất cả Keychain đọc và ghi. Hãy sử dụng tùy chọn này nếu macOS liên tục nhắc về ' Chrome /Brave/Edge Safe Storage' ngay cả sau khi nhấp vào Luôn cho phép. Nhập cookie trình duyệt không khả dụng khi được bật; dán tiêu đề Cookie theo cách thủ công vào Nhà cung cấp. Claude /Codex OAuth thông qua CLI vẫn hoạt động.";
+"disable_keychain_access_title" = "Vô hiệu hóa quyền truy cập Keychain";
+"disable_keychain_access_subtitle" = "Ngăn chặn mọi quyền truy cập Keychain khi được bật.";
+
+/* About Pane */
+"about_tagline" = "Cầu mong mã thông báo của bạn không bao giờ hết—giữ giới hạn đại lý trong tầm mắt.";
+"link_github" = "GitHub";
+"link_website" = "Trang web";
+"link_twitter" = "Twitter";
+"link_email" = "Email";
+"check_updates_auto" = "Tự động kiểm tra các bản cập nhật";
+"update_channel" = "Kênh cập nhật";
+"check_for_updates" = "Kiểm tra các bản cập nhật…";
+"updates_unavailable" = "Các bản cập nhật không có sẵn trong bản dựng này.";
+"copyright" = "© 2026 Peter Steinberger. Giấy phép MIT.";
+
+/* Debug Pane */
+"section_logging" = "Ghi nhật ký";
+"enable_file_logging" = "Cho phép ghi nhật ký tệp";
+"enable_file_logging_subtitle" = "Ghi nhật ký vào %@ để gỡ lỗi.";
+"verbosity_title" = "Độ chi tiết";
+"verbosity_subtitle" = "Kiểm soát lượng chi tiết được ghi lại.";
+"open_log_file" = "Mở tệp nhật ký";
+"force_animation_next_refresh" = "Buộc hoạt ảnh vào lần làm mới tiếp theo";
+"force_animation_next_refresh_subtitle" = "Tạm thời hiển thị hoạt ảnh đang tải sau lần làm mới tiếp theo.";
+"section_loading_animations" = "Đang tải hình động";
+"loading_animations_caption" = "Chọn một mẫu và phát lại nó trong thanh menu . \" Ngẫu nhiên \" giữ nguyên hành vi hiện có.";
+"animation_random_default" = "Ngẫu nhiên (mặc định)";
+"replay_selected_animation" = "Phát lại hoạt ảnh đã chọn";
+"blink_now" = "Nhấp nháy ngay";
+"section_probe_logs" = "Nhật ký thăm dò";
+"probe_logs_caption" = "Tìm nạp đầu ra thăm dò mới nhất để gỡ lỗi; Sao chép giữ toàn bộ văn bản.";
+"fetch_log" = "Nhật ký tìm nạp";
+"copy" = "Sao chép";
+"save_to_file" = "Lưu vào tệp";
+"load_parse_dump" = "Tải kết xuất phân tích cú pháp";
+"rerun_provider_autodetect" = "Chạy lại Nhà cung cấp tự động phát hiện";
+"loading" = "Đang tải…";
+"no_log_yet_fetch" = "Chưa có nhật ký nào. Tìm nạp để tải.";
+"section_fetch_strategy" = "Lần thử chiến lược tìm nạp";
+"fetch_strategy_caption" = "Tìm nạp lần cuối các quyết định và lỗi về đường dẫn cho Nhà cung cấp .";
+"section_openai_cookies" = "OpenAI cookie";
+"openai_cookies_caption" = "Nhập cookie + nhật ký trích xuất WebKit từ lần thử cookie OpenAI gần đây nhất.";
+"no_log_yet" = "Chưa có nhật ký nào. Cập nhật cookie OpenAI trong Nhà cung cấp → Codex để chạy quá trình nhập.";
+"section_caches" = "Bộ nhớ đệm";
+"caches_caption" = "Xóa kết quả quét chi phí được lưu trong bộ nhớ đệm hoặc bộ nhớ đệm cookie của trình duyệt.";
+"clear_cookie_cache" = "Xóa bộ nhớ đệm cookie";
+"clear_cost_cache" = "Xóa bộ nhớ đệm chi phí";
+"section_notifications" = "Thông báo";
+"notifications_caption" = "Kích hoạt thông báo kiểm tra cho khoảng thời gian phiên 5 giờ (đã cạn/được khôi phục).";
+"post_depleted" = "Đã hết bài đăng";
+"post_restored" = "Đã khôi phục bài đăng";
+"section_cli_sessions" = "CLI phiên";
+"cli_sessions_caption" = "Giữ cho các phiên Codex/ Claude CLI vẫn tồn tại sau khi thăm dò. Thoát mặc định sau khi dữ liệu được ghi lại.";
+"keep_cli_sessions_alive" = "Duy trì CLI phiên";
+"keep_cli_sessions_alive_subtitle" = "Bỏ qua việc phân tích giữa các lần thăm dò (chỉ gỡ lỗi).";
+"reset_cli_sessions" = "Đặt lại CLI phiên";
+"section_error_simulation" = "Mô phỏng lỗi";
+"error_simulation_caption" = "Đưa thông báo lỗi giả vào thẻ menu để kiểm tra bố cục.";
+"set_menu_error" = "Đặt lỗi menu";
+"clear_menu_error" = "Xóa lỗi menu";
+"set_cost_error" = "Lỗi đặt chi phí";
+"clear_cost_error" = "Xóa lỗi chi phí";
+"section_cli_paths" = "CLI đường dẫn";
+"cli_paths_caption" = "Đã giải quyết các lớp nhị phân Codex và PATH; chụp PATH đăng nhập khởi động (thời gian chờ ngắn).";
+"codex_binary" = "Codex nhị phân";
+"claude_binary" = "Claude nhị phân";
+"effective_path" = "PATH hiệu quả";
+"unavailable" = "Không khả dụng";
+"login_shell_path" = "Shell đăng nhập PATH (chụp khởi động)";
+"cleared" = "Đã xóa.";
+"no_fetch_attempts" = "Chưa có lần tìm nạp nào.";
+"macOS Tahoe can block menu bar apps in System Settings → Menu Bar → Allow in the Menu Bar. CodexBar is running, but macOS may be hiding its icon. Open Menu Bar settings and turn CodexBar on." = "macOS Tahoe có thể chặn thanh menu ứng dụng trong Hệ thống Cài đặt → thanh menu → Cho phép trong thanh menu . CodexBar đang chạy nhưng macOS có thể đang ẩn biểu tượng của nó. Mở thanh menu Cài đặt và bật CodexBar.";
+
+/* Metric preferences */
+"metric_pref_automatic" = "Tự động";
+"metric_pref_primary" = "Chính";
+"metric_pref_secondary" = "Trung học";
+"metric_pref_tertiary" = "Đại học";
+"metric_pref_extra_usage" = "Bổ sung Mức sử dụng";
+"metric_pref_average" = "Trung bình";
+"metric_mistral_payg" = "Pay-as-you-go";
+"metric_mistral_monthly_plan" = "Monthly Plan";
+
+/* Display modes */
+"display_mode_percent" = "Phần trăm";
+"display_mode_pace" = "Tốc độ";
+"display_mode_both" = "Cả hai";
+"display_mode_reset_time" = "Thời gian đặt lại";
+"display_mode_percent_desc" = "Hiển thị phần trăm còn lại/đã sử dụng (ví dụ: 45%)";
+"display_mode_pace_desc" = "Hiển thị chỉ báo tốc độ (ví dụ: +5%)";
+"display_mode_both_desc" = "Hiển thị cả phần trăm và tốc độ (ví dụ: 45% · +5%)";
+"display_mode_reset_time_desc" = "Hiển thị thời gian đặt lại của chỉ số đã chọn (ví dụ: ↻ 15:56)";
+
+/* Provider status */
+"status_operational" = "Hoạt động";
+"status_partial_outage" = "Mất điện một phần";
+"status_major_outage" = "Mất điện lớn";
+"status_critical_issue" = "Sự cố nghiêm trọng";
+"status_maintenance" = "Bảo trì";
+"status_unknown" = "Trạng thái không xác định";
+
+/* Refresh frequency */
+"refresh_manual" = "Thủ công";
+"refresh_1min" = "1 phút";
+"refresh_2min" = "2 phút";
+"refresh_5min" = "5 phút";
+"refresh_15min" = "15 phút";
+"refresh_30min" = "30 phút";
+
+/* Additional keys */
+"not_found" = "Không tìm thấy";
+
+/* Cost estimation */
+"cost_header_estimated" = "Chi phí (ước tính)";
+"cost_estimate_hint" = "Ước tính từ nhật ký cục bộ · có thể khác với hóa đơn của bạn";
+"No JetBrains IDE with AI Assistant detected. Install a JetBrains IDE and enable AI Assistant." = "Không phát hiện thấy IDE JetBrains nào có Trợ lý AI. Cài đặt JetBrains IDE và bật Trợ lý AI.";
+"OpenRouter API token not configured. Set OPENROUTER_API_KEY environment variable or configure in Settings." = "OpenRouter API token chưa được định cấu hình. Đặt biến môi trường OPENROUTER_API_KEY hoặc định cấu hình trong Cài đặt .";
+"z.ai API token not found. Set apiKey in ~/.codexbar/config.json or Z_AI_API_KEY." = "không tìm thấy z.ai API token. Đặt apiKey trong ~/.codexbar/config.json hoặc Z_AI_API_KEY.";
+"Missing DeepSeek API key." = "Thiếu khóa DeepSeek API.";
+"%@ is unavailable in the current environment." = "%@ không khả dụng trong môi trường hiện tại.";
+"All Systems Operational" = "Tất cả hệ thống đều hoạt động";
+"Last 30 days" = "30 ngày qua";
+"Last 30 days:" = "30 ngày qua:";
+"This month" = "Tháng này";
+"Store multiple OpenAI API keys." = "Lưu trữ nhiều khóa OpenAI API.";
+"Admin API key" = "Khóa quản trị API";
+"Open billing" = "Mở thanh toán";
+"Google accounts" = "Google tài khoản";
+"Store multiple Antigravity Google OAuth accounts for quick switching." = "Lưu trữ nhiều tài khoản AntiGravity Google OAuth để chuyển đổi nhanh chóng.";
+"Add Google Account" = "Thêm Google Tài khoản";
+"Open Token Plan" = "Mở token Kế hoạch";
+"Text Generation" = "Tạo văn bản";
+"Text to Speech" = "Chuyển văn bản thành giọng nói";
+"Music Generation" = "Tạo nhạc";
+"Image Generation" = "Tạo hình ảnh";
+"No local data found" = "Không tìm thấy dữ liệu cục bộ";
+"Credits unavailable; keep Codex running to refresh." = "Không có tín dụng; giữ Codex chạy để làm mới.";
+"No available fetch strategy for minimax." = "Không có chiến lược tìm nạp nào cho minimax.";
+"No Cursor session found. Please log in to cursor.com in Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX, or Edge Canary. If you use Safari, grant CodexBar Full Disk Access in System Settings ▸ Privacy & Security. You can also sign in to Cursor from the CodexBar menu (Add / switch account)." = "Không tìm thấy phiên Con trỏ. Vui lòng đăng nhập vào con trỏ.com bằng Safari , Chrome , Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chrome, Helium, Vivaldi, Yandex Browser, Firefox , Zen, Colibri, Sidekick, Opera, Opera GX hoặc Edge Canary. Nếu bạn sử dụng Safari , hãy cấp cho CodexBar Quyền truy cập toàn bộ đĩa trong Hệ thống Cài đặt ▸ Quyền riêng tư & Bảo mật. Bạn cũng có thể đăng nhập vào Cursor từ menu CodexBar (Thêm/chuyển đổi tài khoản).";
+"No OpenCode session cookies found in browsers." = "Không tìm thấy cookie phiên OpenCode trong trình duyệt.";
+"No available fetch strategy for %@." = "Không có chiến lược tìm nạp nào cho %@ .";
+"Today" = "Hôm nay";
+"Today tokens" = "Mã thông báo hôm nay";
+"30d cost" = "giá 30d";
+"30d tokens" = "mã thông báo 30d";
+"Latest tokens" = "Mã thông báo mới nhất";
+"Top model" = "Mô hình hàng đầu";
+"Storage" = "Bộ nhớ";
+"Add Account..." = "Thêm tài khoản...";
+"Usage Dashboard" = "Mức sử dụng Trang tổng quan";
+"Status Page" = "Trang trạng thái";
+"Settings..." = "Cài đặt ...";
+"About CodexBar" = "Giới thiệu về CodexBar";
+"Quit" = "Thoát";
+"Last %d day" = "Ngày %d cuối cùng";
+"Last %d days" = "%d ngày cuối cùng";
+"%@ tokens" = "%@ mã thông báo";
+"Latest billing day" = "Ngày thanh toán muộn nhất";
+"Latest billing day (%@)" = "Ngày thanh toán muộn nhất ( %@ )";
+"%@ left" = "còn lại %@";
+"Resets %@" = "Đặt lại %@";
+"Resets in %@" = "Đặt lại sau %@";
+"Resets now" = "Đặt lại ngay";
+"reset_tomorrow_format" = "ngày mai, %@";
+"Lasts until reset" = "Kéo dài cho đến Đặt lại";
+"Updated %@" = "Đã cập nhật %@";
+"Updated %@h ago" = "Đã cập nhật %@ h trước";
+"Updated %@m ago" = "Đã cập nhật %@ tháng trước";
+"Updated just now" = "Vừa cập nhật";
+"Projected empty in %@" = "Dự kiến trống trong %@";
+"Runs out in %@" = "Hết trong %@";
+"Pace: %@" = "Tốc độ: %@";
+"Pace: %@ · %@" = "Pace: %@ · %@";
+"%@ · %@" = "%@ · %@";
+"≈ %d%% run-out risk" = "≈ %d %% rủi ro cạn kiệt";
+"%d%% in deficit" = "%d %% thâm hụt";
+"%d%% in reserve" = "%d %% dự trữ";
+"usage_percent_suffix_left" = "left";
+"usage_percent_suffix_used" = "đã sử dụng";
+"Store multiple DeepSeek API keys." = "Lưu trữ nhiều khóa DeepSeek API.";
+"This week" = "Tuần này";
+"Week" = "Tuần";
+"Month" = "Tháng";
+"Models" = "Mô hình";
+"24h tokens" = "Token 24 giờ";
+"Latest hour" = "Giờ mới nhất";
+"Peak hour" = "Giờ cao điểm";
+"Top method" = "Phương thức hàng đầu";
+"30d cash" = "tiền mặt 30d";
+"30d billing history from MiniMax web session" = "Thanh toán 30 ngày lịch sử từ MiniMax phiên web";
+"AWS Cost Explorer billing can lag." = "Việc thanh toán AWS Cost Explorer có thể bị trễ.";
+"Rate limit: %d / %@" = "Giới hạn tốc độ: %d / %@";
+"Key remaining" = "Khóa còn lại";
+"No limit set for the API key" = "Không có giới hạn nào được đặt cho khóa API";
+"API key limit unavailable right now" = "Giới hạn khóa API hiện không khả dụng";
+"This month: %@ tokens" = "Tháng này: mã thông báo %@";
+"No utilization data yet." = "Chưa có dữ liệu sử dụng.";
+"No %@ utilization data yet." = "Chưa có dữ liệu sử dụng %@.";
+"%@: %@%% used" = "%@ : %@ %% đã sử dụng";
+"%dd" = "%d d";
+"today" = "hôm nay";
+"just now" = "vừa rồi";
+"On pace" = "Đang tiến hành";
+"Runs out now" = "Sắp hết";
+"Projected empty now" = "Dự kiến trống";
+"Switch Account..." = "Chuyển tài khoản...";
+"Update ready, restart now?" = "Cập nhật đã sẵn sàng, khởi động lại ngay bây giờ?";
+"Daily" = "Hàng ngày";
+"Hourly Tokens" = "Mã thông báo hàng giờ";
+"No data" = "Không có dữ liệu";
+"No usage breakdown data available." = "Không có dữ liệu phân tích Mức sử dụng.";
+
+"Today: %@ · %@ tokens" = "Hôm nay: %@ · %@ mã thông báo";
+"Today: %@" = "Hôm nay: %@";
+"Today: %@ tokens" = "Hôm nay: %@ mã thông báo";
+"Last 30 days: %@ · %@ tokens" = "30 ngày qua: %@ · %@ mã thông báo";
+"Last 30 days: %@" = "30 ngày qua: %@";
+"Est. total (30d): %@" = "Ước tính tổng cộng (30 ngày): %@";
+"Est. total (%@): %@" = "Ước tính tổng ( %@ ): %@";
+"Hover a bar for details" = "Di chuột qua thanh để biết thông tin chi tiết";
+"%@: %@ · %@ tokens" = "%@ : %@ · %@ mã thông báo";
+"No providers selected for Overview." = "Không có nhà cung cấp nào được chọn cho Tổng quan.";
+"No overview data available." = "Không có dữ liệu tổng quan.";
+"Auto uses the local IDE API first, then Google OAuth when the IDE is closed." = "Tự động sử dụng IDE cục bộ API trước, sau đó là Google OAuth khi IDE đóng.";
+"Login with Google" = "Đăng nhập bằng Google";
+
+/* Popup panels */
+"No usage configured." = "Chưa định cấu hình Mức sử dụng.";
+"Quota" = "Hạn mức";
+"tokens" = "mã thông báo";
+"requests" = "yêu cầu";
+"Latest" = "";
+"Monthly" = "Mới nhất";
+"Sonnet" = "Sonnet";
+"Overages" = "Quá tải";
+"Activity" = "Hoạt động";
+"Copied" = "Đã sao chép";
+"Copy error" = "Lỗi sao chép";
+"Copy path" = "Sao chép đường dẫn";
+"Extra usage spent" = "Thêm Mức sử dụng đã chi tiêu";
+"Credits remaining" = "Tín dụng còn lại";
+"Using CLI fallback" = "Sử dụng CLI dự phòng";
+"Balance updates in near-real time (up to 5 min lag)" = "Cập nhật số dư trong thời gian gần như thực (độ trễ tối đa 5 phút)";
+"Daily billing data finalizes at 07:00 UTC" = "Dữ liệu thanh toán hàng ngày sẽ hoàn tất lúc 07:00 UTC";
+"%@ of %@ credits left" = "%@ trong số %@ tín dụng còn lại";
+"%@ of %@ bonus credits left" = "%@ trong số %@ tín dụng thưởng còn lại";
+"%@ / %@ (%@ remaining)" = "%@ / %@ ( %@ còn lại)";
+"%@/%@ left" = "%@ / %@ left";
+"Gemini Flash" = "Gemini Flash";
+"Regenerates %@" = "Tái tạo %@";
+"used after next regen" = "được sử dụng sau lần tái sinh tiếp theo";
+"after next regen" = "sau đợt regen tiếp theo";
+"Near full" = "Gần đầy";
+"Full in ~1 regen" = "Đầy đủ trong ~1 regen";
+"Full in ~%.0f regens" = "Đầy đủ trong ~%.0f regens";
+"Overage usage" = "Quá mức Mức sử dụng";
+"Overage cost" = "Chi phí quá mức";
+"credits" = "tín dụng";
+"Zen balance" = "Số dư Zen";
+"API spend" = "API chi tiêu";
+"Extra usage" = "Thêm Mức sử dụng";
+"Quota usage" = "Hạn mức Mức sử dụng";
+"Your spend" = "Chi tiêu của bạn";
+"%.0f%% used" = "%.0f%% đã sử dụng";
+"Usage history (today)" = "Mức sử dụng lịch sử (hôm nay)";
+"Usage history (%d days)" = "Mức sử dụng lịch sử ( %d ngày)";
+"%d percent remaining" = "%d phần trăm còn lại";
+"Unknown" = "Không xác định";
+"stale data" = "dữ liệu cũ";
+"No credits history data." = "Không có dữ liệu lịch sử tín dụng.";
+"No credits history data available." = "Không có dữ liệu lịch sử tín dụng.";
+"Credits history chart" = "Biểu đồ lịch sử tín dụng";
+"%d days of credits data" = "%d ngày dữ liệu tín dụng";
+"Usage breakdown chart" = "Mức sử dụng biểu đồ phân tích";
+"%d days of usage data across %d services" = "%d ngày của dữ liệu Mức sử dụng trên %d dịch vụ";
+"Cost history chart" = "Biểu đồ lịch sử chi phí";
+"%d days of cost data" = "%d ngày của dữ liệu chi phí";
+"Plan utilization chart" = "Biểu đồ sử dụng kế hoạch";
+"%d utilization samples" = "%d mẫu sử dụng";
+"Hourly Usage" = "Hàng giờ Mức sử dụng";
+"Usage remaining" = "Mức sử dụng";
+"Usage used" = "Mức sử dụng đã sử dụng khóa";
+"API key verified. Ollama does not expose Cloud quota limits through the API." = "API đã được xác minh. Ollama không đưa ra các giới hạn Hạn mức của Đám mây thông qua API .";
+"Last 30 days: %@ tokens" = "30 ngày qua: %@ mã thông báo";
+"7d spend" = "chi tiêu 7 ngày";
+"30d spend" = "chi tiêu 30 ngày";
+"Cache read" = "Đọc bộ nhớ đệm";
+"Claude Admin API 30 day spend trend" = "Claude Quản trị viên API Xu hướng chi tiêu 30 ngày";
+"OpenRouter API key spend trend" = "Xu hướng chi tiêu khóa API OpenRouter";
+"z.ai hourly token trend" = "z.ai hàng giờ token xu hướng";
+"MiniMax 30 day token usage trend" = "MiniMax 30 ngày token Mức sử dụng xu hướng";
+"Today cash" = "Tiền mặt hôm nay";
+"DeepSeek 30 day token usage trend" = "DeepSeek 30 ngày token Mức sử dụng xu hướng";
+"cache-hit input" = "đầu vào truy cập bộ đệm";
+"cache-miss input" = "đầu vào bỏ lỡ bộ đệm";
+"output" = "đầu ra";
+"Requests" = "Yêu cầu";
+"Reported by OpenAI Admin API organization usage." = "Được báo cáo bởi OpenAI Quản trị viên API tổ chức Mức sử dụng .";
+"Reported by Mistral billing usage." = "Được báo cáo bởi thanh toán Mistral Mức sử dụng .";
+"Google OAuth" = "Google OAuth";
+"Add accounts via GitHub OAuth Device Flow on the selected host." = "Thêm tài khoản qua GitHub OAuth Luồng thiết bị trên máy chủ đã chọn.";
+"Stores each signed-in Google account for quick Antigravity switching. Uses Antigravity.app OAuth when available, or ANTIGRAVITY_OAUTH_CLIENT_ID and ANTIGRAVITY_OAUTH_CLIENT_SECRET as an override." = "Lưu trữ từng tài khoản Google đã đăng nhập để chuyển đổi Chống hấp dẫn nhanh chóng. Sử dụng AntiGravity.app OAuth khi có sẵn hoặc ANTIGRAVITY_OAUTH_CLIENT_ID và ANTIGRAVITY_OAUTH_CLIENT_SECRET làm ghi đè.";
+"Manual cleanup: past sessions" = "Dọn dẹp thủ công: các phiên trước đây";
+"Clearing removes past resume, continue, and rewind history." = "Việc xóa sẽ xóa lịch sử tiếp tục, tiếp tục và tua lại trong quá khứ.";
+"Manual cleanup: file checkpoints" = "Dọn dẹp thủ công: điểm kiểm tra tệp";
+"Clearing removes checkpoint restore data for previous edits." = "Việc xóa sẽ xóa dữ liệu khôi phục điểm kiểm tra cho các chỉnh sửa trước đó.";
+"Manual cleanup: saved plans" = "Dọn dẹp thủ công: các gói đã lưu";
+"Clearing removes old plan-mode files." = "Việc xóa sẽ xóa các tệp chế độ gói cũ.";
+"Manual cleanup: debug logs" = "Dọn dẹp thủ công: nhật ký gỡ lỗi";
+"Clearing removes past debug logs." = "Việc xóa sẽ xóa nhật ký gỡ lỗi trước đây.";
+"Manual cleanup: attachment cache" = "Dọn dẹp thủ công: bộ đệm đính kèm";
+"Clearing removes cached large pastes or attached images." = "Việc xóa sẽ xóa các miếng dán lớn hoặc hình ảnh đính kèm được lưu trong bộ nhớ đệm.";
+"Manual cleanup: session metadata" = "Dọn dẹp thủ công: siêu dữ liệu phiên";
+"Clearing removes per-session environment metadata." = "Việc xóa sẽ xóa siêu dữ liệu môi trường mỗi phiên.";
+"Manual cleanup: shell snapshots" = "Dọn dẹp thủ công: ảnh chụp nhanh shell";
+"Clearing removes leftover runtime shell snapshot files." = "Việc xóa sẽ xóa các tệp ảnh chụp nhanh shell thời gian chạy còn sót lại.";
+"Manual cleanup: legacy todos" = "Dọn dẹp thủ công: việc cần làm cũ";
+"Clearing removes legacy per-session task lists." = "Việc xóa sẽ xóa danh sách nhiệm vụ cũ mỗi phiên.";
+"Manual cleanup: sessions" = "Dọn dẹp thủ công: phiên";
+"Clearing removes past Codex session history." = "Việc xóa sẽ xóa lịch sử phiên Codex trước đây.";
+"Manual cleanup: archived sessions" = "Dọn dẹp thủ công: các phiên đã lưu trữ";
+"Clearing removes archived Codex session history." = "Việc xóa sẽ xóa lịch sử phiên Codex đã lưu trữ.";
+"Manual cleanup: cache" = "Dọn dẹp thủ công: bộ đệm";
+"Clearing removes provider-owned cached data." = "Việc xóa sẽ xóa dữ liệu được lưu trong bộ nhớ đệm thuộc quyền sở hữu của Nhà cung cấp.";
+"Manual cleanup: logs" = "Dọn dẹp thủ công: nhật ký";
+"Clearing removes local diagnostic logs." = "Việc xóa sẽ xóa nhật ký chẩn đoán cục bộ.";
+"Manual cleanup: file history" = "Dọn dẹp thủ công: lịch sử tệp";
+"Clearing removes local edit checkpoint history." = "Việc xóa sẽ xóa lịch sử điểm kiểm tra chỉnh sửa cục bộ.";
+"Manual cleanup: temporary data" = "Dọn dẹp thủ công: dữ liệu tạm thời";
+"Clearing removes local temporary provider data." = "Việc xóa sẽ xóa dữ liệu Nhà cung cấp tạm thời cục bộ.";
+"Total: %@" = "Tổng cộng: %@";
+"%d more items" = "%d mục khác";
+"Cleanup ideas" = "Ý tưởng dọn dẹp";
+"%d unreadable item(s) skipped" = "%d (các) mục không thể đọc được đã bỏ qua";
+
+"API key limit" = "API giới hạn khóa";
+"Auth" = "Xác thực";
+"Auto" = "Tự động";
+"Disabled — no recent data" = "Đã tắt — không có dữ liệu gần đây";
+"Limits not available" = "Không có giới hạn";
+"No usage yet" = "Chưa có Mức sử dụng";
+"Not fetched yet" = "Chưa được tìm nạp";
+"Refreshing" = "Đang làm mới";
+"Session" = "Phiên";
+"Source" = "Nguồn";
+"State" = "Trạng thái";
+"Unavailable" = "Không có sẵn";
+"Weekly" = "Không phát hiện được";
+"not detected" = "hàng tuần";
+"Estimated from local Codex logs for the selected account." = "Được ước tính từ nhật ký Codex cục bộ cho tài khoản đã chọn.";
+"minimax_usage_amount_format" = "Mức sử dụng : %@ / %@";
+"minimax_used_percent_format" = "Đã sử dụng %@";
+"minimax_service_text_generation" = "Tạo văn bản";
+"minimax_service_text_to_speech" = "Chuyển văn bản thành giọng nói";
+"minimax_service_music_generation" = "Tạo nhạc";
+"minimax_service_image_generation" = "Tạo hình ảnh";
+"minimax_service_lyrics_generation" = "Tạo lời bài hát";
+"minimax_service_coding_plan_vlm" = "Kế hoạch mã hóa VLM";
+"minimax_service_coding_plan_search" = "Tìm kiếm kế hoạch mã hóa";
+
+/* Additional provider settings and alerts */
+"%@ is waiting for permission" = "%@ đang chờ cấp phép";
+"%@ requests" = "%@ yêu cầu";
+"%@: %@ credits" = "%@: %@ credits";
+"30d requests" = "yêu cầu 30 ngày";
+"4 days" = "4 ngày";
+"5 days" = "5 ngày";
+"7 days" = "7 ngày";
+"API key verifies Ollama Cloud access; cookies still expose quota limits." = "API khóa xác minh quyền truy cập vào Đám mây Ollama; cookie vẫn hiển thị giới hạn Hạn mức.";
+"AWS access key ID. Can also be set with AWS_ACCESS_KEY_ID." = "ID khóa truy cập AWS. Cũng có thể được đặt bằng AWS_ACCESS_KEY_ID.";
+"AWS region. Can also be set with AWS_REGION." = "Khu vực AWS. Cũng có thể được đặt bằng AWS_REGION.";
+"AWS secret access key. Can also be set with AWS_SECRET_ACCESS_KEY." = "Khóa truy cập bí mật AWS. Cũng có thể được đặt bằng AWS_SECRET_ACCESS_KEY.";
+"Access key ID" = "ID khóa truy cập";
+"Add Account" = "Thêm tài khoản";
+"Adding Account…" = "Đang thêm tài khoản…";
+"Antigravity login failed" = "Đăng nhập chống trọng lực không thành công";
+"Antigravity login timed out" = "Đã hết thời gian đăng nhập chống trọng lực";
+"Auth source" = "Nguồn xác thực";
+"Automatic imports browser cookies from Xiaomi MiMo." = "Tự động nhập cookie trình duyệt từ Xiaomi MiMo.";
+"Automatic imports Windsurf session data from Chromium browser localStorage." = "Tự động nhập dữ liệu phiên Windsurf từ localStorage của trình duyệt Chrome.";
+"Automatic imports browser cookies from Bailian." = "Tự động nhập cookie trình duyệt từ Bailian.";
+"Automatically imports browser cookies." = "Tự động nhập cookie trình duyệt.";
+"Automatically imports browser session cookies." = "Tự động nhập cookie phiên trình duyệt.";
+"Azure OpenAI deployment name. AZURE_OPENAI_DEPLOYMENT_NAME is also supported." = "tên triển khai Azure OpenAI. AZURE_OPENAI_DEPLOYMENT_NAME cũng được hỗ trợ.";
+"Azure OpenAI key" = "Khóa Azure OpenAI";
+"Azure OpenAI resource endpoint. AZURE_OPENAI_ENDPOINT is also supported." = "Điểm cuối tài nguyên Azure OpenAI. AZURE_OPENAI_ENDPOINT cũng được hỗ trợ.";
+"Base URL" = "Base URL";
+"Base URL for the LLM-API-Key-Proxy instance." = "Base URL cho phiên bản LLM- API -Key-Proxy.";
+"Browser cookies" = "Cookie trình duyệt";
+"Cap end" = "Cap end";
+"Cap start" = "Cap start";
+"Capacity End" = "Dung lượng End";
+"Capacity Start" = "Dung lượng Start";
+"Changelog" = "Changelog";
+"Choose the Moonshot/Kimi API host for international or China mainland accounts." = "Chọn máy chủ Moonshot/Kimi API cho các tài khoản quốc tế hoặc Trung Quốc đại lục.";
+"CodexBar can't replace a system account that is signed in with an API key only setup." = "CodexBar không thể thay thế tài khoản hệ thống được đăng nhập bằng thiết lập chỉ khóa API.";
+"CodexBar could not find saved auth for that account. Re-authenticate it and try again." = "CodexBar không thể tìm thấy xác thực đã lưu cho tài khoản đó. Xác thực lại nó và thử lại.";
+"CodexBar could not read managed account storage. Recover the store before adding another account." = "CodexBar không thể đọc bộ nhớ tài khoản được quản lý. Khôi phục cửa hàng trước khi thêm tài khoản khác.";
+"CodexBar could not read saved auth for that account. Re-authenticate it and try again." = "CodexBar không thể đọc xác thực đã lưu cho tài khoản đó. Xác thực lại nó và thử lại.";
+"CodexBar could not read the current system account on this Mac." = "CodexBar không thể đọc tài khoản hệ thống hiện tại trên máy Mac này.";
+"CodexBar could not replace the live Codex auth on this Mac." = "CodexBar không thể thay thế xác thực Codex trực tiếp trên máy Mac này.";
+"CodexBar could not safely preserve the current system account before switching." = "CodexBar không thể bảo toàn tài khoản hệ thống hiện tại một cách an toàn trước khi chuyển đổi.";
+"CodexBar could not save the current system account before switching." = "CodexBar không thể lưu tài khoản hệ thống hiện tại trước khi chuyển đổi.";
+"CodexBar could not update managed account storage." = "CodexBar không thể cập nhật bộ nhớ tài khoản được quản lý.";
+"CodexBar found another managed account that already uses the current system account. Resolve the duplicate account before switching." = "CodexBar đã tìm thấy một tài khoản được quản lý khác đã sử dụng tài khoản hệ thống hiện tại. Giải quyết tài khoản trùng lặp trước khi chuyển đổi.";
+"CodexBar will ask macOS Keychain for “%@” so it can decrypt browser cookies and authenticate your account. Click OK to continue." = "CodexBar sẽ yêu cầu macOS Keychain cho “ %@ ” để nó có thể giải mã cookie của trình duyệt và xác thực tài khoản của bạn. Nhấn OK để tiếp tục.";
+"CodexBar will ask macOS Keychain for the Claude Code OAuth token so it can fetch your Claude usage. Click OK to continue." = "CodexBar sẽ yêu cầu macOS Keychain cung cấp Claude Mã OAuth token để nó có thể tìm nạp Claude Mức sử dụng của bạn. Nhấn OK để tiếp tục.";
+"CodexBar will ask macOS Keychain for your Amp cookie header so it can fetch usage. Click OK to continue." = "CodexBar sẽ yêu cầu macOS Keychain cho tiêu đề cookie Amp của bạn để nó có thể tìm nạp Mức sử dụng . Nhấn OK để tiếp tục.";
+"CodexBar will ask macOS Keychain for your Augment cookie header so it can fetch usage. Click OK to continue." = "CodexBar sẽ yêu cầu macOS Keychain cho tiêu đề cookie Augment của bạn để nó có thể tìm nạp Mức sử dụng . Nhấn OK để tiếp tục.";
+"CodexBar will ask macOS Keychain for your Claude cookie header so it can fetch Claude web usage. Click OK to continue." = "CodexBar sẽ yêu cầu macOS Keychain về tiêu đề cookie Claude của bạn để nó có thể tìm nạp Claude web Mức sử dụng . Nhấn OK để tiếp tục.";
+"CodexBar will ask macOS Keychain for your Cursor cookie header so it can fetch usage. Click OK to continue." = "CodexBar sẽ yêu cầu macOS Keychain cho tiêu đề cookie Con trỏ của bạn để nó có thể tìm nạp Mức sử dụng . Nhấn OK để tiếp tục.";
+"CodexBar will ask macOS Keychain for your Factory cookie header so it can fetch usage. Click OK to continue." = "CodexBar sẽ yêu cầu macOS Keychain cho tiêu đề cookie Factory của bạn để nó có thể tìm nạp Mức sử dụng . Nhấn OK để tiếp tục.";
+"CodexBar will ask macOS Keychain for your GitHub Copilot token so it can fetch usage. Click OK to continue." = "CodexBar sẽ yêu cầu macOS Keychain cho GitHub Copilot token của bạn để nó có thể tìm nạp Mức sử dụng . Nhấn OK để tiếp tục.";
+"CodexBar will ask macOS Keychain for your Kimi K2 API key so it can fetch usage. Click OK to continue." = "CodexBar sẽ yêu cầu macOS Keychain cung cấp khóa Kimi K2 API của bạn để nó có thể tìm nạp Mức sử dụng . Nhấn OK để tiếp tục.";
+"CodexBar will ask macOS Keychain for your Kimi auth token so it can fetch usage. Click OK to continue." = "CodexBar sẽ yêu cầu macOS Keychain cho Kimi auth token của bạn để nó có thể tìm nạp Mức sử dụng . Nhấn OK để tiếp tục.";
+"CodexBar will ask macOS Keychain for your MiniMax API token so it can fetch usage. Click OK to continue." = "CodexBar sẽ yêu cầu macOS Keychain cung cấp MiniMax API token của bạn để nó có thể tìm nạp Mức sử dụng . Nhấn OK để tiếp tục.";
+"CodexBar will ask macOS Keychain for your MiniMax cookie header so it can fetch usage. Click OK to continue." = "CodexBar sẽ yêu cầu macOS Keychain cho tiêu đề cookie MiniMax của bạn để nó có thể tìm nạp Mức sử dụng . Nhấn OK để tiếp tục.";
+"CodexBar will ask macOS Keychain for your OpenAI cookie header so it can fetch Codex dashboard extras. Click OK to continue." = "CodexBar sẽ yêu cầu macOS Keychain cho tiêu đề cookie OpenAI của bạn để nó có thể tìm nạp các tính năng bổ sung của trang tổng quan Codex. Nhấn OK để tiếp tục.";
+"CodexBar will ask macOS Keychain for your OpenCode cookie header so it can fetch usage. Click OK to continue." = "CodexBar sẽ yêu cầu macOS Keychain cho tiêu đề cookie OpenCode của bạn để nó có thể tìm nạp Mức sử dụng . Nhấn OK để tiếp tục.";
+"CodexBar will ask macOS Keychain for your Synthetic API key so it can fetch usage. Click OK to continue." = "CodexBar sẽ yêu cầu macOS Keychain cung cấp khóa Tổng hợp API của bạn để nó có thể tìm nạp Mức sử dụng . Nhấn OK để tiếp tục.";
+"CodexBar will ask macOS Keychain for your z.ai API token so it can fetch usage. Click OK to continue." = "CodexBar sẽ yêu cầu macOS Keychain cung cấp z.ai API token của bạn để nó có thể tìm nạp Mức sử dụng . Nhấn OK để tiếp tục.";
+"Could not open Cursor login in your browser." = "Không thể mở đăng nhập Con trỏ trong trình duyệt của bạn.";
+"Could not open browser for Antigravity" = "Không thể mở trình duyệt cho AntiGravity";
+"Credits used" = "Tín dụng đã sử dụng";
+"Day" = "Ngày";
+"Deployment" = "Triển khai";
+"Drag to reorder" = "Kéo để sắp xếp lại";
+"Sort providers alphabetically" = "Sắp xếp nhà cung cấp theo bảng chữ cái";
+"Sort providers alphabetically (enabled first)" = "Sắp xếp nhà cung cấp theo bảng chữ cái (đã bật trước)";
+"Sorted alphabetically (enabled first) — click to use your custom order" = "Đã sắp xếp theo bảng chữ cái (đã bật trước) — nhấp để dùng thứ tự tùy chỉnh";
+"Endpoint" = "Điểm cuối";
+"Enterprise host" = "Máy chủ doanh nghiệp";
+"Extra usage balance: %@" = "Extra usage balance: %@";
+"Keychain Access Required" = "Keychain Yêu cầu quyền truy cập";
+"Kiro menu bar value" = "Kiro thanh menu value";
+"Label" = "Nhãn";
+"No organizations loaded. Click Refresh after setting your API key." = "Chưa có tổ chức nào được tải. Nhấp vào Làm mới sau khi đặt khóa API của bạn.";
+"No output captured." = "Không ghi được đầu ra nào.";
+"No system account" = "Không có tài khoản hệ thống";
+"Oasis-Token" = "Oasis- token";
+"Open Augment (Log Out & Back In)" = "Mở phần mở rộng (Đăng xuất và quay lại)";
+"Open Codebuff Dashboard" = "Mở bảng điều khiển Codebuff";
+"Open Command Code Settings" = "Mở mã lệnh Cài đặt";
+"Open Crof dashboard" = "Mở bảng điều khiển Crof";
+"Open Manus" = "Mở Manus";
+"Open MiMo Balance" = "Mở MiMo Balance";
+"Open Moonshot Console" = "Mở Bảng điều khiển Moonshot";
+"Open Ollama API Keys" = "Mở Ollama API Phím";
+"Open StepFun Platform" = "Mở Nền tảng StepFun";
+"Open T3 Chat Settings" = "Mở Trò chuyện T3 Cài đặt";
+"Open Volcengine Ark Console" = "Mở Bảng điều khiển Volcengine Ark";
+"Open legacy provider docs" = "Mở di sản Nhà cung cấp docs";
+"Open projects" = "Mở dự án";
+"Open this URL manually to continue login:\n\n%@" = "Open this URL manually to continue login:\n\n%@";
+"Optional organization ID for accounts linked to multiple Anthropic organizations." = "ID tổ chức tùy chọn cho các tài khoản được liên kết với nhiều tổ chức Anthropic.";
+"Optional. Applies to the configured Admin API key; selected token accounts do not inherit OPENAI_PROJECT_ID." = "Tùy chọn. Áp dụng cho khóa Quản trị viên API đã định cấu hình; tài khoản token đã chọn không kế thừa OPENAI_PROJECT_ID.";
+"Optional. Enter your GitHub Enterprise host, for example octocorp.ghe.com. Leave blank for github.com." = "Tùy chọn. Nhập máy chủ GitHub Enterprise của bạn, ví dụ: octocorp.ghe.com. Để trống cho github.com.";
+"Optional. Leave blank to discover and aggregate projects visible to the API key." = "Tùy chọn. Để trống để khám phá và tổng hợp các dự án hiển thị với khóa API.";
+"Org ID (optional)" = "ID tổ chức (tùy chọn)";
+"Organizations" = "Tổ chức";
+"Password" = "Mật khẩu";
+"%@ authentication is disabled." = "%@ xác thực bị tắt. Cookie";
+"%@ cookies are disabled." = "%@ bị tắt. Quyền truy cập";
+"%@ web API access is disabled." = "%@ web API bị vô hiệu hóa.";
+"Disable %@ dashboard cookie usage." = "Tắt %@ cookie trang tổng quan Mức sử dụng . Quyền truy cập";
+"Keychain access is disabled in Advanced, so browser cookie import is unavailable." = "Keychain bị vô hiệu hóa trong Nâng cao, do đó, tính năng nhập cookie trình duyệt không khả dụng.";
+"Manually paste an %@ from a browser session." = "Dán %@ theo cách thủ công từ phiên trình duyệt.";
+"Paste a Cookie header captured from %@." = "Dán tiêu đề Cookie được lấy từ %@ .";
+"Paste a Cookie header from %@." = "Dán tiêu đề Cookie từ %@ .";
+"Paste a Cookie header or cURL capture from %@." = "Dán tiêu đề Cookie hoặc chụp cURL từ %@ .";
+"Paste a Cookie header or full cURL capture from %@." = "Dán tiêu đề Cookie hoặc chụp cURL đầy đủ từ %@ .";
+"Paste a Cookie or Authorization header from %@." = "Dán tiêu đề Cookie hoặc Ủy quyền từ %@ .";
+"Paste a full cookie header or the %@ value." = "Dán tiêu đề cookie đầy đủ hoặc giá trị %@.";
+"Paste a Cookie header or full cURL capture from T3 Chat settings." = "Dán tiêu đề Cookie hoặc chụp cURL đầy đủ từ Trò chuyện T3 Cài đặt .";
+"Paste the Cookie header from a request to admin.mistral.ai. Must contain an ory_session_* cookie." = "Dán tiêu đề Cookie từ yêu cầu tới admin.mistral.ai. Phải chứa cookie ory_session_*.";
+"Paste the Oasis-Token from a logged-in browser session on platform.stepfun.com." = "Dán Oasis- token từ phiên trình duyệt đã đăng nhập trên platform.stepfun.com.";
+"Paste the %@ JSON bundle from %@." = "Dán gói %@ JSON từ %@ .";
+"Paste the %@ value or a full Cookie header." = "Dán giá trị %@ hoặc tiêu đề Cookie đầy đủ.";
+"Personal account" = "Tài khoản cá nhân";
+"Project ID" = "ID dự án";
+"Re-auth" = "Xác thực lại";
+"Re-login at claude.ai" = "Đăng nhập lại vào claude.ai";
+"Re-authenticating…" = "Xác thực lại…";
+"Refresh Session" = "Làm mới phiên";
+"Refresh organizations" = "Làm mới tổ chức";
+"Region" = "Khu vực";
+"Reload" = "Tải lại";
+"Reorder" = "Sắp xếp lại";
+"Secret access key" = "Khóa truy cập bí mật";
+"Series" = "Chuỗi";
+"Service" = "Dịch vụ";
+"Show or hide Kiro credits, percent, or both next to the menu bar icon." = "Hiển thị hoặc ẩn tín dụng Kiro, phần trăm hoặc cả hai bên cạnh biểu tượng thanh menu.";
+"Show usage for organizations you belong to. Personal account is always shown." = "Hiển thị Mức sử dụng cho các tổ chức mà bạn là thành viên. Tài khoản cá nhân luôn được hiển thị.";
+"Sign in to cursor.com in your browser, then refresh Cursor in CodexBar." = "Đăng nhập vào con trỏ.com trong trình duyệt của bạn, sau đó làm mới Con trỏ trong CodexBar .";
+"Simulated error text" = "Văn bản lỗi mô phỏng";
+"StepFun platform account (phone number or email)." = "Tài khoản nền tảng StepFun (số điện thoại hoặc email).";
+"Stored in ~/.codexbar/config.json." = "Được lưu trữ trong ~/.codexbar/config.json.";
+"Stored in ~/.codexbar/config.json. AZURE_OPENAI_API_KEY is also supported." = "Được lưu trữ trong ~/.codexbar/config.json. AZURE_OPENAI_API_KEY cũng được hỗ trợ.";
+"Stored in ~/.codexbar/config.json. For the official Kimi API, use Moonshot / Kimi API." = "Được lưu trữ trong ~/.codexbar/config.json. Đối với Kimi API chính thức, hãy sử dụng Moonshot / Kimi API .";
+"Stored in ~/.codexbar/config.json. Get your API key from the Volcengine Ark console." = "Được lưu trữ trong ~/.codexbar/config.json. Nhận khóa API của bạn từ bảng điều khiển Volcengine Ark.";
+"Stored in ~/.codexbar/config.json. Get your key from Ollama settings." = "Được lưu trữ trong ~/.codexbar/config.json. Nhận chìa khóa của bạn từ Ollama Cài đặt .";
+"Stored in ~/.codexbar/config.json. Get your key from console.deepgram.com." = "Được lưu trữ trong ~/.codexbar/config.json. Nhận chìa khóa của bạn từ console.deepgram.com.";
+"Stored in ~/.codexbar/config.json. Get your key from elevenlabs.io/app/settings/api-keys." = "Được lưu trữ trong ~/.codexbar/config.json. Nhận khóa của bạn từ Elevenlabs.io/app/ Cài đặt /api-keys.";
+"Stored in ~/.codexbar/config.json. Get your key from openrouter.ai/settings/keys and set a key spending limit there to enable API key quota tracking." = "Được lưu trữ trong ~/.codexbar/config.json. Nhận khóa của bạn từ openrouter.ai/ Cài đặt /keys và đặt giới hạn chi tiêu cho khóa ở đó để cho phép theo dõi API khóa Hạn mức.";
+"Stored in ~/.codexbar/config.json. In Warp, open Settings > Platform > API Keys, then create one." = "Được lưu trữ trong ~/.codexbar/config.json. Trong Warp, hãy mở Khóa Cài đặt > Nền tảng > API, sau đó tạo một khóa.";
+"Stored in ~/.codexbar/config.json. Metrics require Groq Enterprise Prometheus access." = "Được lưu trữ trong ~/.codexbar/config.json. Các số liệu yêu cầu quyền truy cập Groq Enterprise Prometheus.";
+"Stored in ~/.codexbar/config.json. OPENAI_ADMIN_KEY is preferred; OPENAI_API_KEY still works." = "Được lưu trữ trong ~/.codexbar/config.json. OPENAI_ADMIN_KEY được ưu tiên; OPENAI_API_KEY vẫn hoạt động.";
+"Stored in ~/.codexbar/config.json. Requires an Anthropic Admin API key." = "Được lưu trữ trong ~/.codexbar/config.json. Yêu cầu khóa Anthropic Quản trị viên API.";
+"Stored in ~/.codexbar/config.json. Used for /v1/quota-stats." = "Được lưu trữ trong ~/.codexbar/config.json. Được sử dụng cho /v1/ Hạn mức -stats.";
+"Stored in ~/.codexbar/config.json. You can also provide CODEBUFF_API_KEY or let CodexBar read ~/.config/manicode/credentials.json (created by `codebuff login`)." = "Được lưu trữ trong ~/.codexbar/config.json. Bạn cũng có thể cung cấp CODEBUFF_API_KEY hoặc để CodexBar đọc ~/.config/manicode/credentials.json (được tạo bởi `codebuff login`).";
+"Stored in ~/.codexbar/config.json. You can also provide CROF_API_KEY." = "Được lưu trữ trong ~/.codexbar/config.json. Bạn cũng có thể cung cấp CROF_API_KEY.";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or ~/.local/share/kilo/auth.json (kilo.access)." = "Được lưu trữ trong ~/.codexbar/config.json. Bạn cũng có thể cung cấp KILO_API_KEY hoặc ~/.local/share/kilo/auth.json (kilo.access).";
+"T3 Chat cookie" = "Cookie trò chuyện T3";
+"That account is no longer available in CodexBar. Refresh the account list and try again." = "Tài khoản đó không còn khả dụng trong CodexBar . Hãy làm mới danh sách tài khoản và thử lại.";
+"The browser login did not complete in time. Try Antigravity login again." = "Quá trình đăng nhập trình duyệt không hoàn tất kịp thời. Hãy thử đăng nhập lại bằng AntiGravity.";
+"Timed out waiting for Cursor login. %@" = "Đã hết thời gian chờ đăng nhập Con trỏ. %@";
+"Timed out waiting for Cursor login. %@ Last error: %@" = "Đã hết thời gian chờ đăng nhập Con trỏ. %@ Lỗi cuối cùng: %@";
+"Today requests" = "Hôm nay yêu cầu";
+"Total (30d): %@ credits" = "Tổng cộng (30d): %@ tín dụng";
+"Username" = "Tên người dùng";
+"Uses username + password to login and obtain an Oasis-Token automatically." = "Sử dụng tên người dùng + mật khẩu để đăng nhập và nhận Oasis- token một cách tự động.";
+"Uses username + password to login and obtain an %@ automatically." = "Sử dụng tên người dùng + mật khẩu để đăng nhập và tự động nhận được %@.";
+"Utilization End" = "Kết thúc sử dụng";
+"Utilization Start" = "Bắt đầu sử dụng";
+"Verbosity" = "Độ chi tiết";
+"Windsurf session JSON bundle" = "Phiên lướt ván buồm JSON gói";
+"Workspace ID" = "ID không gian làm việc";
+"Your StepFun platform password. Used to login and obtain a session token." = "Mật khẩu nền tảng StepFun của bạn. Được sử dụng để đăng nhập và nhận phiên token .";
+"claude /login exited with status %d." = "claude /đăng nhập đã thoát với trạng thái %d .";
+"codex login exited with status %d." = "đăng nhập codex đã thoát với trạng thái %d .";
+"Cookie: …\n\nor paste a cURL capture from the Abacus AI dashboard" = "Cookie: …\n\nhoặc dán bản chụp cURL từ bảng thông tin Abacus AI";
+"Cookie: …\n\nor paste the __Secure-next-auth.session-token value" = "Cookie: …\n\nhoặc dán giá trị __Secure-next-auth.session- token";
+"Cookie: …\n\nor paste the kimi-auth token value" = "Cookie: …\n\nhoặc dán giá trị kimi-auth token";
+"session_id=...\n\nor paste just the session_id value" = "session_id=...\n\nhoặc chỉ dán giá trị session_id";
+"Clear" = "Xóa";
+"No matching providers" = "Không có nhà cung cấp phù hợp";
+"Search providers" = "Tìm kiếm nhà cung cấp";
+
+"language_vietnamese" = "Tiếng Việt";
+"language_turkish" = "Türkçe";
+"language_indonesian" = "Tiếng Indonesia";
+"language_polish" = "Tiếng Ba Lan";
+"language_arabic" = "العربية";
+"language_persian" = "فارسی";
+"language_thai" = "ไทย";
+"Limit Reset Credits" = "Lượt đặt lại giới hạn";
+"1 manual reset available" = "Có 1 lần đặt lại thủ công";
+"%d manual resets available" = "Có %d lần đặt lại thủ công";
+"Next expires %@" = "Lượt tiếp theo hết hạn %@";
+"Other (%d items)" = "Khác (%d mục)";
+"Expand" = "Mở rộng";
+"Collapse" = "Thu gọn";
+"byte_unit_byte" = "byte";
+"byte_unit_bytes" = "byte";
+"byte_unit_kilobyte" = "kilobyte";
+"byte_unit_kilobytes" = "kilobyte";
+"byte_unit_megabyte" = "megabyte";
+"byte_unit_megabytes" = "megabyte";
+"byte_unit_gigabyte" = "gigabyte";
+"byte_unit_gigabytes" = "gigabyte";
diff --git a/Sources/CodexBar/Resources/zh-Hans.lproj/Localizable.strings b/Sources/CodexBar/Resources/zh-Hans.lproj/Localizable.strings
new file mode 100644
index 0000000000..ed10dfb73d
--- /dev/null
+++ b/Sources/CodexBar/Resources/zh-Hans.lproj/Localizable.strings
@@ -0,0 +1,1082 @@
+/* Chinese (Simplified) localization for CodexBar */
+
+" providers" = " 提供商";
+"(System)" = "（System）";
+"30d" = "30 天";
+"A managed Codex login is already running. Wait for it to finish before adding " = "托管 Codex 登录已在运行。请等待其完成后再添加 ";
+"API key" = "API 密钥";
+"API key limit" = "API 密钥限制";
+"API region" = "API 区域";
+"API token" = "API 令牌";
+"API tokens" = "API 令牌";
+"About" = "关于";
+"Account" = "账户";
+"Accounts" = "账户";
+"Accounts subtitle" = "账户副标题";
+"Active" = "活跃";
+"Add" = "添加";
+"Add Workspace" = "添加工作区";
+"Advanced" = "高级";
+"All" = "全部";
+"Always allow prompts" = "始终允许提示";
+"Animation pattern" = "动画模式";
+"Antigravity login is managed in the app" = "Antigravity 登录由应用管理";
+"Applies only to the Security.framework OAuth keychain reader." = "仅适用于 Security.framework OAuth 钥匙串读取器。";
+"Auth" = "认证";
+"Auto" = "自动";
+"Auto falls back to the next source if the preferred one fails." = "如果首选来源失败，自动回退到下一个来源。";
+"Auto uses API first, then falls back to CLI on auth failures." = "自动优先使用 API，认证失败时回退到 CLI。";
+"Auto-detect" = "自动检测";
+"Auto-refresh is off; use the menu's Refresh command." = "自动刷新已关闭；请使用菜单中的“刷新”命令。";
+"Auto-refresh: hourly · Timeout: 10m" = "自动刷新：每小时 · 超时：10 分钟";
+"Automatic" = "自动";
+"Automatic imports browser cookies and WorkOS tokens." = "自动导入浏览器 Cookie 和 WorkOS 令牌。";
+"Automatic imports browser cookies and local storage tokens." = "自动导入浏览器 Cookie 和本地存储令牌。";
+"Automatic imports browser cookies for dashboard extras." = "自动导入用于仪表盘附加功能的浏览器 Cookie。";
+"Automatic imports browser cookies for the web API." = "自动导入用于 Web API 的浏览器 Cookie。";
+"Automatic imports browser cookies from Model Studio/Bailian." = "自动从 Model Studio/百炼导入浏览器 Cookie。";
+"Automatic imports browser cookies from admin.mistral.ai." = "自动从 admin.mistral.ai 导入浏览器 Cookie。";
+"Automatic imports browser cookies from opencode.ai." = "自动从 opencode.ai 导入浏览器 Cookie。";
+"Automatic imports browser cookies or stored sessions." = "自动导入浏览器 Cookie 或已存储的会话。";
+"Automatic imports browser cookies." = "自动导入浏览器 Cookie。";
+"Automatically imports browser session cookie." = "自动导入浏览器会话 Cookie。";
+"Automatically opens CodexBar when you start your Mac." = "启动 Mac 时自动打开 CodexBar。";
+"Automation" = "自动化";
+"Average (\\(label1) + \\(label2))" = "平均（\\(label1) + \\(label2)）";
+"Average (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))" = "平均（\\(metadata.sessionLabel) + \\(metadata.weeklyLabel)）";
+"Avoid Keychain prompts" = "避免钥匙串提示";
+"Balance" = "余额";
+"Battery Saver" = "省电模式";
+"Bordered" = "带边框";
+"Build" = "构建";
+"Built \\(buildTimestamp)" = "构建于 \\(buildTimestamp)";
+"Buy Credits..." = "购买额度…";
+"Buy Credits…" = "购买额度…";
+"CLI paths" = "CLI 路径";
+"CLI sessions" = "CLI 会话";
+"Caches" = "缓存";
+"Cancel" = "取消";
+"Check for Updates…" = "检查更新…";
+"Check for updates automatically" = "自动检查更新";
+"Check if you like your agents having some fun up there." = "看看你是否喜欢你的智能体在上面找点乐子。";
+"Check provider status" = "检查提供商状态";
+"Choose Codex workspace" = "选择 Codex 工作区";
+"Choose the MiniMax host (global .io or China mainland .com)." = "选择 MiniMax 主机（全球 .io 或中国大陆 .com）。";
+"Choose up to " = "选择至多 ";
+"Choose up to \\(Self.maxOverviewProviders) providers" = "选择至多 \\(Self.maxOverviewProviders) 个提供商";
+"Choose up to \\(count) providers" = "选择至多 \\(count) 个提供商";
+"Choose what to show in the menu bar (Pace shows usage vs. expected)." = "选择菜单栏中显示的内容（进度会显示实际用量与预期的对比）。";
+"Choose which Codex account CodexBar should follow." = "选择 CodexBar 要跟随的 Codex 账户。";
+"Choose which window drives the menu bar percent." = "选择用于驱动菜单栏百分比的窗口。";
+"Chrome" = "Chrome";
+"Claude CLI not found" = "未找到 Claude CLI";
+"Claude binary" = "Claude 二进制文件";
+"Claude cookies" = "Claude Cookie";
+"Claude login failed" = "Claude 登录失败";
+"Claude login timed out" = "Claude 登录超时";
+"Close" = "关闭";
+"Code review" = "代码审查";
+"Codex CLI not found" = "未找到 Codex CLI";
+"Codex account login already running" = "Codex 账户登录已在运行";
+"Codex binary" = "Codex 二进制文件";
+"Codex login failed" = "Codex 登录失败";
+"Codex login timed out" = "Codex 登录超时";
+"CodexBar Lifecycle Keepalive" = "CodexBar 生命周期保活";
+"CodexBar could not read managed account storage. " = "CodexBar 无法读取托管账户存储。";
+"Configure…" = "配置…";
+"Connected" = "已连接";
+"Controls how much detail is logged." = "控制日志记录的详细程度。";
+"Cookie header" = "Cookie 标头";
+"Cookie source" = "Cookie 来源";
+"Cookie: ..." = "Cookie：...";
+"Cookie: \\u{2026}\\\n\\\nor paste a cURL capture from the Abacus AI dashboard" = "Cookie：\\u{2026}\\\n\\\n或粘贴来自 Abacus AI 仪表盘的 cURL 捕获内容";
+"Cookie: \\u{2026}\\\n\\\nor paste the __Secure-next-auth.session-token value" = "Cookie：\\u{2026}\\\n\\\n或粘贴 __Secure-next-auth.session-token 的值";
+"Cookie: \\u{2026}\\\n\\\nor paste the kimi-auth token value" = "Cookie：\\u{2026}\\\n\\\n或粘贴 kimi-auth 令牌值";
+"Cookie: …" = "Cookie：…";
+"CopilotDeviceFlow" = "Copilot 设备流程";
+"Cost" = "费用";
+"Could not add Codex account" = "无法添加 Codex 账户";
+"Could not open Terminal for Gemini" = "无法为 Gemini 打开终端";
+"Could not start claude /login" = "无法启动 claude /login";
+"Could not start codex login" = "无法启动 codex login";
+"Could not switch system account" = "无法切换系统账户";
+"Credits" = "额度";
+"Individual credits" = "个人额度";
+"Workspace" = "工作区";
+"Credits history" = "额度记录";
+"Cursor login failed" = "Cursor 登录失败";
+"Custom" = "自定义";
+"Custom Path" = "自定义路径";
+"Daily Routines" = "日常任务";
+"Debug" = "调试";
+"Default" = "默认";
+"Disable Keychain access" = "禁用钥匙串访问";
+"Disabled" = "已禁用";
+"Disabled — no recent data" = "已禁用 — 无近期数据";
+"Disconnected" = "已断开连接";
+"Display" = "显示";
+"Display mode" = "显示模式";
+"Display reset times as absolute clock values instead of countdowns." = "将重置时间显示为绝对时钟值，而不是倒计时。";
+"Done" = "完成";
+"Effective PATH" = "有效 PATH";
+"Email" = "电子邮件";
+"Enable Merge Icons to configure Overview tab providers." = "启用“合并图标”以配置“概览”标签中的提供商。";
+"Enable file logging" = "启用文件日志";
+"Enabled" = "已启用";
+"Error" = "错误";
+"Error simulation" = "错误模拟";
+"Expose troubleshooting tools in the Debug tab." = "在“调试”标签中显示故障排除工具。";
+"Failed" = "失败";
+"False" = "假";
+"Fetch strategy attempts" = "获取策略尝试";
+"Fetching" = "获取中";
+"Field" = "字段";
+"Field subtitle" = "字段副标题";
+"Finish the current managed account change before switching the system account." = "请先完成当前托管账户变更，再切换系统账户。";
+"Force animation on next refresh" = "下次刷新时强制动画";
+"Gateway region" = "网关区域";
+"Gemini CLI not found" = "未找到 Gemini CLI";
+"Gemini/Antigravity, surfacing incidents in the icon and menu." = "Gemini/Antigravity，并在图标和菜单中显示故障事件。";
+"General" = "通用";
+"GitHub" = "GitHub";
+"GitHub Copilot Login" = "GitHub Copilot 登录";
+"GitHub Login" = "GitHub 登录";
+"Hide details" = "隐藏详情";
+"Hide personal information" = "隐藏个人信息";
+"Historical tracking" = "历史跟踪";
+"How often CodexBar polls providers in the background." = "CodexBar 在后台轮询提供商的频率。";
+"Inactive" = "非活跃";
+"Install CLI" = "安装 CLI";
+"Install the Claude CLI (npm i -g @anthropic-ai/claude-code) and try again." = "安装 Claude CLI（npm i -g @anthropic-ai/claude-code）后重试。";
+"Install the Codex CLI (npm i -g @openai/codex) and try again." = "安装 Codex CLI（npm i -g @openai/codex）后重试。";
+"Install the Gemini CLI (npm i -g @google/gemini-cli) and try again." = "安装 Gemini CLI（npm i -g @google/gemini-cli）后重试。";
+"JetBrains AI is ready" = "JetBrains AI 已就绪";
+"JetBrains IDE" = "JetBrains IDE";
+"Keep CLI sessions alive" = "保持 CLI 会话存活";
+"Keyboard shortcut" = "快捷键";
+"Keychain access" = "钥匙串访问";
+"Keychain prompt policy" = "钥匙串提示策略";
+"Last \\(name) fetch failed:" = "上次获取 \\(name) 失败：";
+"Last \\(self.store.metadata(for: self.provider).displayName) fetch failed:" = "上次获取 \\(self.store.metadata(for: self.provider).displayName) 失败：";
+"Last attempt" = "上次尝试";
+"Limits not available" = "限制不可用";
+"Link" = "链接";
+"Loading animations" = "加载动画";
+"Loading…" = "加载中…";
+"Local" = "本地";
+"Logging" = "日志";
+"Login failed" = "登录失败";
+"Login shell PATH (startup capture)" = "登录 shell PATH（启动时捕获）";
+"Login timed out" = "登录超时";
+"MCP details" = "MCP 详情";
+"Managed Codex accounts unavailable" = "托管 Codex 账户不可用";
+"Managed account storage is unreadable. Live account access is still available, " = "托管账户存储不可读。实时账户访问仍可用，";
+"Manual" = "手动";
+"May your tokens never run out—keep agent limits in view." = "愿你的 token 永不耗尽——随时关注智能体额度。";
+"Menu bar" = "菜单栏";
+"Menu bar auto-shows the provider closest to its rate limit." = "菜单栏会自动显示最接近速率限制的提供商。";
+"Menu bar metric" = "菜单栏指标";
+"Menu bar shows percent" = "菜单栏显示百分比";
+"Menu content" = "菜单内容";
+"Merge Icons" = "合并图标";
+"Never prompt" = "从不提示";
+"No" = "否";
+"No Codex accounts detected yet." = "未检测到 Codex 账户。";
+"No JetBrains IDE detected" = "未检测到 JetBrains IDE";
+"No cost history data." = "暂无费用历史数据。";
+"No usage yet" = "尚无用量";
+"Not fetched yet" = "尚未获取";
+"No credits history data." = "暂无额度记录。";
+"No data available" = "无可用数据";
+"No data yet" = "暂无数据";
+"No enabled providers available for Overview." = "“概览”中没有可用的已启用提供商。";
+"No providers selected" = "未选择提供商";
+"No token accounts yet." = "尚无令牌账户。";
+"No usage breakdown data." = "暂无用量明细数据。";
+"None" = "无";
+"Notifications" = "通知";
+"Notifies when the 5-hour session quota hits 0% and when it becomes " = "当 5 小时会话配额降至 0% 以及重新";
+"OK" = "确定";
+"Obscure email addresses in the menu bar and menu UI." = "在菜单栏和菜单界面中隐藏电子邮件地址。";
+"Off" = "关闭";
+"Offline" = "离线";
+"On" = "开启";
+"Online" = "在线";
+"Only on user action" = "仅在用户操作时";
+"Open" = "打开";
+"Open API Keys" = "打开 API 密钥";
+"Open Amp Settings" = "打开 Amp 设置";
+"Open Antigravity to sign in, then refresh CodexBar." = "打开 Antigravity 登录，然后刷新 CodexBar。";
+"Open Browser" = "打开浏览器";
+"Open Coding Plan" = "打开 Coding Plan";
+"Open Console" = "打开控制台";
+"Open Dashboard" = "打开仪表盘";
+"Open Mistral Admin" = "打开 Mistral 管理后台";
+"Open Ollama Settings" = "打开 Ollama 设置";
+"Open Terminal" = "打开终端";
+"Open Usage Page" = "打开用量页面";
+"Open Warp API Key Guide" = "打开 Warp API 密钥指南";
+"Open menu" = "打开菜单";
+"Open token file" = "打开令牌文件";
+"OpenAI cookies" = "OpenAI Cookie";
+"OpenAI web extras" = "OpenAI Web 附加功能";
+"Option A" = "选项 A";
+"Option B" = "选项 B";
+"Optional override if workspace lookup fails." = "工作区查找失败时可选的覆盖项。";
+"Options" = "选项";
+"Override auto-detection with a custom IDE base path" = "使用自定义 IDE 基础路径覆盖自动检测";
+"Overview" = "概览";
+"Overview rows always follow provider order." = "概览行始终遵循提供商顺序。";
+"Overview tab providers" = "概览标签提供商";
+"Paste API key…" = "粘贴 API 密钥…";
+"Paste API token…" = "粘贴 API 令牌…";
+"Paste key…" = "粘贴密钥…";
+"Paste sessionKey or OAuth token…" = "粘贴 sessionKey 或 OAuth 令牌…";
+"Paste the Cookie header from a request to admin.mistral.ai. " = "粘贴发往 admin.mistral.ai 请求中的 Cookie 标头。";
+"Paste token…" = "粘贴令牌…";
+"Personal" = "个人";
+"Picker" = "选择器";
+"Picker subtitle" = "选择器副标题";
+"Placeholder" = "占位符";
+"Plan" = "套餐";
+"Play full-screen confetti when weekly usage resets." = "当每周用量重置时播放全屏彩纸。";
+"Polls OpenAI/Claude status pages and Google Workspace for " = "轮询 OpenAI/Claude 状态页面和 Google Workspace，以检查";
+"Prevents any Keychain access while enabled." = "启用时阻止任何钥匙串访问。";
+"Primary (API key limit)" = "主要（API 密钥限制）";
+"Primary (\\(label))" = "主要（\\(label)）";
+"Primary (\\(metadata.sessionLabel))" = "主要（\\(metadata.sessionLabel)）";
+"Probe logs" = "探测日志";
+"Progress bars fill as you consume quota (instead of showing remaining)." = "进度条会随配额消耗而填充（而不是显示剩余量）。";
+"Provider" = "提供商";
+"Providers" = "提供商";
+"Quit CodexBar" = "退出 CodexBar";
+"Random (default)" = "随机（默认）";
+"Reads local usage logs. Shows today + last 30 days cost in the menu." = "读取本地用量日志。在菜单中显示今天及所选历史窗口的费用。";
+"Refresh" = "刷新";
+"Refreshing" = "正在刷新";
+"Refresh cadence" = "刷新频率";
+"Remote" = "远程";
+"Remove" = "移除";
+"Remove Codex account?" = "移除 Codex 账户？";
+"Remove \\(account.email) from CodexBar? Its managed Codex home will be deleted." = "要从 CodexBar 中移除 \\(account.email) 吗？其托管的 Codex 主目录将被删除。";
+"Remove \\(email) from CodexBar? Its managed Codex home will be deleted." = "要从 CodexBar 中移除 \\(email) 吗？其托管的 Codex 主目录将被删除。";
+"Remove selected account" = "移除所选账户";
+"Replace critter bars with provider branding icons and a percentage." = "将小动物进度条替换为提供商品牌图标和百分比。";
+"Replay selected animation" = "重放选中的动画";
+"Requires authentication via GitHub Device Flow." = "需要通过 GitHub 设备流程进行认证。";
+"Resets: \\(reset)" = "重置：\\(reset)";
+"Rolling five-hour limit" = "滚动 5 小时限制";
+"Search hourly" = "每小时搜索";
+"Secondary (\\(label))" = "次要（\\(label)）";
+"Secondary (\\(metadata.weeklyLabel))" = "次要（\\(metadata.weeklyLabel)）";
+"Select a provider" = "选择一个提供商";
+"Select the IDE to monitor" = "选择要监控的 IDE";
+"Session" = "会话";
+"Session quota notifications" = "会话配额通知";
+"Session tokens" = "会话令牌";
+"Settings" = "设置";
+"Show Codex Credits and Claude Extra usage sections in the menu." = "在菜单中显示 Codex 额度和 Claude 额外用量部分。";
+"Show Debug Settings" = "显示调试设置";
+"Show all token accounts" = "显示所有令牌账户";
+"Show cost summary" = "显示费用摘要";
+"Show credits + extra usage" = "显示额度 + 额外用量";
+"Show details" = "显示详情";
+"Show most-used provider" = "显示用量最高的提供商";
+"Show provider icons in the switcher (otherwise show a weekly progress line)." = "在切换器中显示提供商图标（否则显示每周进度线）。";
+"Show reset time as clock" = "将重置时间显示为时钟";
+"Show usage as used" = "显示已使用用量";
+"Sign in via button below" = "通过下方按钮登录";
+"Skip teardown between probes (debug-only)." = "探测之间跳过清理（仅限调试）。";
+"Source" = "来源";
+"Stack token accounts in the menu (otherwise show an account switcher bar)." = "在菜单中堆叠令牌账户（否则显示账户切换栏）。";
+"Start at Login" = "开机启动";
+"State" = "状态";
+"Status" = "状态";
+"Store Claude sessionKey cookies or OAuth access tokens." = "存储 Claude sessionKey Cookie 或 OAuth 访问令牌。";
+"Store multiple Abacus AI Cookie headers." = "存储多个 Abacus AI Cookie 标头。";
+"Store multiple Augment Cookie headers." = "存储多个 Augment Cookie 标头。";
+"Store multiple Cursor Cookie headers." = "存储多个 Cursor Cookie 标头。";
+"Store multiple Factory Cookie headers." = "存储多个 Factory Cookie 标头。";
+"Store multiple MiniMax Cookie headers." = "存储多个 MiniMax Cookie 标头。";
+"Store multiple Mistral Cookie headers." = "存储多个 Mistral Cookie 标头。";
+"Store multiple Ollama Cookie headers." = "存储多个 Ollama Cookie 标头。";
+"Store multiple OpenCode Cookie headers." = "存储多个 OpenCode Cookie 标头。";
+"Store multiple OpenCode Go Cookie headers." = "存储多个 OpenCode Go Cookie 标头。";
+"Stored in the CodexBar config file." = "存储在 CodexBar 配置文件中。";
+"Stored in ~/.codexbar/config.json. " = "存储在 ~/.codexbar/config.json 中。";
+"Stored in ~/.codexbar/config.json. Generate one at kimi-k2.ai." = "存储在 ~/.codexbar/config.json 中。可在 kimi-k2.ai 生成。";
+"Stored in ~/.codexbar/config.json. Paste the key from the Synthetic dashboard." = "存储在 ~/.codexbar/config.json 中。请粘贴来自 Synthetic 仪表盘的密钥。";
+"Stored in ~/.codexbar/config.json. Paste your Coding Plan API key from Model Studio." = "存储在 ~/.codexbar/config.json 中。请粘贴来自 Model Studio 的 Coding Plan API 密钥。";
+"Stored in ~/.codexbar/config.json. Paste your MiniMax API key." = "存储在 ~/.codexbar/config.json 中。请粘贴你的 MiniMax API 密钥。";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or " = "存储在 ~/.codexbar/config.json 中。你也可以提供 KILO_API_KEY 或";
+"Stores local Codex usage history (8 weeks) to personalize Pace predictions." = "存储本地 Codex 用量历史（8 周），用于个性化进度预测。";
+"Subscription Utilization" = "订阅使用率";
+"Surprise me" = "给我惊喜";
+"Switcher shows icons" = "切换器显示图标";
+"Symlink CodexBarCLI to /usr/local/bin and /opt/homebrew/bin as codexbar." = "将 CodexBarCLI 作为 codexbar 符号链接到 /usr/local/bin 和 /opt/homebrew/bin。";
+"System" = "系统";
+"Temporarily shows the loading animation after the next refresh." = "下次刷新后临时显示加载动画。";
+"Tertiary (\\(label))" = "第三（\\(label)）";
+"Tertiary (\\(tertiaryTitle))" = "第三（\\(tertiaryTitle)）";
+"The default Codex account on this Mac." = "此 Mac 上的默认 Codex 账户。";
+"Toggle" = "切换";
+"Toggle subtitle" = "切换副标题";
+"Token" = "token";
+"Trigger the menu bar menu from anywhere." = "从任意位置触发菜单栏菜单。";
+"True" = "真";
+"Twitter" = "Twitter";
+"Unsupported" = "不支持";
+"Unavailable" = "不可用";
+"Update Channel" = "更新频道";
+"Updated" = "已更新";
+"Updates unavailable in this build." = "此构建中更新不可用。";
+"Usage" = "用量";
+"Usage breakdown" = "用量明细";
+"Usage history (30 days)" = "用量历史";
+"Usage source" = "用量来源";
+"Use BigModel for the China mainland endpoints (open.bigmodel.cn)." = "中国大陆端点使用 BigModel（open.bigmodel.cn）。";
+"Use a single menu bar icon with a provider switcher." = "使用单个菜单栏图标并带提供商切换器。";
+"Use international or China mainland console gateways for quota fetches." = "使用国际或中国大陆控制台网关获取配额。";
+"Version" = "版本";
+"Version \\(self.versionString)" = "版本 \\(self.versionString)";
+"Version \\(version)" = "版本 \\(version)";
+"Version \\(versionString)" = "版本 \\(versionString)";
+"Vertex AI Login" = "Vertex AI 登录";
+"Wait for the current managed Codex login to finish before adding another account." = "请等待当前托管 Codex 登录完成后再添加其他账户。";
+"Waiting for Authentication..." = "等待认证…";
+"Website" = "网站";
+"Weekly" = "每周";
+"Weekly limit confetti" = "每周限制彩纸";
+"Weekly token limit" = "每周 token 限制";
+"Weekly usage" = "每周用量";
+"Weekly usage unavailable for this account." = "此账户的每周用量不可用。";
+"Window: \\(window)" = "窗口：\\(window)";
+"Write logs to \\(self.fileLogPath) for debugging." = "将日志写入 \\(self.fileLogPath) 以进行调试。";
+"Yes" = "是";
+"not detected" = "未检测到";
+"\\(detail.modelCode): \\(usage)" = "\\(detail.modelCode)：\\(usage)";
+"\\(name): \\(truncated)" = "\\(name)：\\(truncated)";
+"\\(name): \\(updated) · 30d \\(cost)" = "\\(name)：\\(updated) · 30 天 \\(cost)";
+"\\(name): fetching…\\(elapsed)" = "\\(name)：获取中…\\(elapsed)";
+"\\(name): last attempt \\(when)" = "\\(name)：上次尝试 \\(when)";
+"\\(name): no data yet" = "\\(name)：暂无数据";
+"\\(name): unsupported" = "\\(name)：不支持";
+"all browsers" = "所有浏览器";
+"available again." = "可用时发送通知。";
+"built_format" = "构建于 %@";
+"copilot_complete_in_browser" = "请在浏览器中完成登录。";
+"copilot_device_code_copied" = "设备代码已复制。";
+"copilot_verify_at" = "请在 %@ 验证";
+"copilot_window_closes_auto" = "登录完成后，此窗口会自动关闭。";
+"cost_status_error" = "%1$@：%2$@";
+"cost_status_fetching" = "%1$@：获取中… %2$@";
+"cost_status_last_attempt" = "%1$@：上次尝试 %2$@";
+"cost_status_no_data" = "%@：暂无数据";
+"cost_status_snapshot" = "%1$@：%2$@ · %3$@ %4$@";
+"cost_status_unsupported" = "%@：不支持";
+"credits_remaining" = "额度：%@";
+"cursor_on_demand" = "按需计费：%@";
+"cursor_on_demand_with_limit" = "按需计费：%1$@ / %2$@";
+"extra_usage_format" = "额外用量：%1$@ / %2$@";
+"jetbrains_detected_generate" = "检测到：%@。使用一次 AI 助手以生成配额数据，然后刷新 CodexBar。";
+"jetbrains_detected_select" = "检测到：%@。在设置中选择你偏好的 IDE，然后刷新 CodexBar。";
+"last_fetch_failed_with_provider" = "上次获取 %@ 失败：";
+"last_spend" = "上次支出：%@";
+"mcp_model_usage" = "%1$@：%2$@";
+"mcp_resets" = "重置：%@";
+"mcp_window" = "窗口：%@";
+"metric_average" = "平均（%1$@ + %2$@）";
+"metric_primary" = "主要（%@）";
+"metric_secondary" = "次要（%@）";
+"metric_tertiary" = "第三（%@）";
+"multiple_workspaces_found" = "CodexBar 发现 %@ 有多个工作区。请选择要添加的工作区。";
+"ory_session_…=…; csrftoken=…" = "ory_session_…=…; csrftoken=…";
+"overview_choose_providers" = "最多选择 %@ 个提供商";
+"remove_account_message" = "要从 CodexBar 中移除 %@ 吗？其托管的 Codex 主目录将被删除。";
+"version_format" = "版本 %@";
+"workspaceID is set but only opencode, opencodego, and deepgram support workspaceID." = "已设置 workspaceID，但只有 opencode、opencodego 和 deepgram 支持 workspaceID。";
+"© 2026 Peter Steinberger. MIT License." = "© 2026 Peter Steinberger。MIT 许可证。";
+"section_system" = "系统";
+"section_usage" = "用量";
+"section_automation" = "自动化";
+"language_title" = "语言";
+"language_subtitle" = "更改显示语言。需要重启应用才能完全生效。";
+"language_system" = "跟随系统";
+"language_english" = "English";
+"language_spanish" = "Español";
+"language_catalan" = "Català";
+"language_chinese_simplified" = "简体中文";
+"language_chinese_traditional" = "繁體中文";
+"language_portuguese_brazilian" = "Português (Brasil)";
+"language_swedish" = "瑞典语";
+"language_dutch" = "Nederlands";
+"language_german" = "Deutsch";
+"language_french" = "法语";
+"language_ukrainian" = "乌克兰语";
+"language_japanese" = "日语";
+"language_korean" = "韩语";
+"language_italian" = "Italiano";
+"language_polish" = "Polski";
+"start_at_login_title" = "开机启动";
+"start_at_login_subtitle" = "启动 Mac 时自动打开 CodexBar。";
+"show_cost_summary" = "显示费用摘要";
+"show_cost_summary_subtitle" = "读取本地用量日志。在菜单中显示今天及所选历史窗口的费用。";
+"cost_history_days_title" = "历史窗口：%d 天";
+"cost_auto_refresh_info" = "自动刷新：每小时 · 超时：10 分钟";
+"refresh_cadence_title" = "刷新频率";
+"refresh_cadence_subtitle" = "CodexBar 在后台轮询提供商的频率。";
+"manual_refresh_hint" = "自动刷新已关闭；请使用菜单中的“刷新”命令。";
+"check_provider_status_title" = "检查提供商状态";
+"check_provider_status_subtitle" = "轮询 OpenAI/Claude 状态页面和 Google Workspace 的 Gemini/Antigravity，在图标和菜单中显示故障信息。";
+"session_quota_notifications_title" = "会话配额通知";
+"session_quota_notifications_subtitle" = "当 5 小时会话配额用完及恢复时发送通知。";
+"quota_warning_notifications_title" = "配额预警通知";
+"quota_warning_notifications_subtitle" = "当会话或每周剩余配额低于设置的阈值时提醒。";
+"quota_warnings_title" = "配额预警";
+"quota_warning_session" = "会话";
+"quota_warning_session_capitalized" = "会话";
+"quota_warning_weekly" = "每周";
+"quota_warning_weekly_capitalized" = "每周";
+"quota_warning_warn_at" = "预警阈值";
+"quota_warning_global_threshold_subtitle" = "会话和每周窗口的剩余百分比，除非提供商单独覆盖。";
+"quota_warning_sound" = "播放通知声音";
+"quota_warning_provider_inherits" = "默认使用全局配额预警设置，除非在这里自定义窗口。";
+"quota_warning_customize_thresholds" = "自定义 %@ 阈值";
+"quota_warning_enable_warnings" = "启用 %@ 预警";
+"quota_warning_window_warn_at" = "%@ 预警阈值";
+"quota_warning_off" = "关闭";
+"quota_warning_inherited" = "继承：%@";
+"quota_warning_depleted_only" = "仅耗尽时";
+"quota_warning_upper" = "上限";
+"quota_warning_lower" = "下限";
+"apply" = "应用";
+"quit_app" = "退出 CodexBar";
+"tab_general" = "通用";
+"tab_providers" = "提供商";
+"tab_display" = "显示";
+"tab_advanced" = "高级";
+"tab_about" = "关于";
+"tab_debug" = "调试";
+"select_a_provider" = "选择一个提供商";
+"cancel" = "取消";
+"last_fetch_failed" = "上次获取失败";
+"usage_not_fetched_yet" = "尚未获取用量";
+"managed_account_storage_unreadable" = "托管账户存储不可读。实时账户访问仍可用，但托管添加、重新认证和移除操作已被禁用，直到存储恢复。";
+"remove_codex_account_title" = "移除 Codex 账户？";
+"remove" = "移除";
+"managed_login_already_running" = "托管 Codex 登录已在运行。请等待完成后再添加或重新认证其他账户。";
+"managed_login_failed" = "托管 Codex 登录未完成。请先在终端确认 `codex --version` 可以运行。如果 macOS 阻止了 `codex` 或将它移到废纸篓，请移除旧的重复安装，运行 `npm install -g --include=optional @openai/codex@latest`，然后重试。";
+"codex_login_output" = "codex login 输出：";
+"managed_login_missing_email" = "Codex 登录已完成，但无法获取账户邮箱。请在确认账户已完全登录后重试。";
+"workspace_selection_cancelled" = "CodexBar 发现多个工作区，但未选择任何工作区。";
+"unsafe_managed_home" = "CodexBar 拒绝修改意外的托管主目录路径：%@";
+"menu_bar_metric_title" = "菜单栏指标";
+"menu_bar_metric_subtitle" = "选择哪个窗口驱动菜单栏百分比。";
+"menu_bar_metric_subtitle_deepseek" = "在菜单栏显示 DeepSeek 余额。";
+"menu_bar_metric_subtitle_moonshot" = "在菜单栏显示 Moonshot / Kimi API 余额。";
+"menu_bar_metric_subtitle_mistral" = "在菜单栏显示 Mistral API 本月支出。";
+"menu_bar_metric_subtitle_kimik2" = "在菜单栏显示 Kimi K2 API 密钥额度。";
+"automatic" = "自动";
+"primary_api_key_limit" = "主要（API 密钥限制）";
+"section_menu_bar" = "菜单栏";
+"merge_icons_title" = "合并图标";
+"merge_icons_subtitle" = "使用单个菜单栏图标并带提供商切换器。";
+"switcher_shows_icons_title" = "切换器显示图标";
+"switcher_shows_icons_subtitle" = "在切换器中显示提供商图标（否则显示每周进度线）。";
+"show_most_used_provider_title" = "显示用量最高的提供商";
+"show_most_used_provider_subtitle" = "菜单栏会自动显示最接近速率限制的提供商。";
+"menu_bar_shows_percent_title" = "菜单栏显示百分比";
+"menu_bar_shows_percent_subtitle" = "将小动物进度条替换为提供商品牌图标和百分比。";
+"hide_critters_title" = "隐藏小动物";
+"hide_critters_subtitle" = "显示不带表情和装饰的简洁进度条。";
+"display_mode_title" = "显示模式";
+"display_mode_subtitle" = "选择菜单栏中显示的内容（进度会显示实际用量与预期的对比）。";
+"section_menu_content" = "菜单内容";
+"show_usage_as_used_title" = "显示已使用用量";
+"show_usage_as_used_subtitle" = "进度条会随配额消耗而填充（而不是显示剩余量）。";
+"show_quota_warning_markers_title" = "显示配额预警标记";
+"show_quota_warning_markers_subtitle" = "配置配额预警后，在用量条上绘制阈值刻度标记。";
+"show_reset_time_as_clock_title" = "将重置时间显示为时钟";
+"show_reset_time_as_clock_subtitle" = "将重置时间显示为绝对时钟值，而不是倒计时。";
+"show_provider_changelog_links_title" = "显示提供商变更日志链接";
+"show_provider_changelog_links_subtitle" = "在菜单中为支持的 CLI 提供商添加发布说明链接。";
+"show_credits_extra_usage_title" = "显示额度 + 额外用量";
+"show_credits_extra_usage_subtitle" = "在菜单中显示 Codex 额度和 Claude 额外用量部分。";
+"show_all_token_accounts_title" = "显示所有令牌账户";
+"show_all_token_accounts_subtitle" = "在菜单中堆叠令牌账户（否则显示账户切换栏）。";
+"multi_account_layout_title" = "多账户布局";
+"multi_account_layout_subtitle" = "选择分段账户切换或堆叠账户卡片。";
+"multi_account_layout_segmented" = "分段";
+"multi_account_layout_stacked" = "堆叠";
+"overview_tab_providers_title" = "概览标签提供商";
+"configure" = "配置…";
+"overview_enable_merge_icons_hint" = "启用“合并图标”以配置“概览”标签中的提供商。";
+"overview_no_providers_hint" = "“概览”中没有可用的已启用提供商。";
+"overview_rows_follow_order" = "概览行始终遵循提供商顺序。";
+"overview_no_providers_selected" = "未选择提供商";
+"section_keyboard_shortcut" = "快捷键";
+"open_menu_shortcut_title" = "打开菜单";
+"open_menu_shortcut_subtitle" = "从任意位置触发菜单栏菜单。";
+"install_cli" = "安装 CLI";
+"install_cli_subtitle" = "将 CodexBarCLI 作为 codexbar 符号链接到 /usr/local/bin 和 /opt/homebrew/bin。";
+"cli_not_found" = "在应用包中未找到 CodexBarCLI。";
+"no_writable_bin_dirs" = "未找到可写的 bin 目录。";
+"show_debug_settings_title" = "显示调试设置";
+"show_debug_settings_subtitle" = "在“调试”标签中显示故障排除工具。";
+"surprise_me_title" = "给我惊喜";
+"surprise_me_subtitle" = "看看你是否喜欢你的智能体在上面找点乐子。";
+"weekly_limit_confetti_title" = "每周限制彩纸";
+"weekly_limit_confetti_subtitle" = "当每周用量重置时播放全屏彩纸。";
+"hide_personal_info_title" = "隐藏个人信息";
+"hide_personal_info_subtitle" = "在菜单栏和菜单界面中隐藏电子邮件地址。";
+"show_provider_storage_usage_title" = "显示提供商存储用量";
+"show_provider_storage_usage_subtitle" = "在菜单中显示本地磁盘用量。会在后台扫描已知的提供商自有路径。";
+"section_keychain_access" = "钥匙串访问";
+"keychain_access_caption" = "禁用所有钥匙串读写。浏览器 Cookie 导入不可用；请在“提供商”中手动粘贴 Cookie 标头。";
+"disable_keychain_access_title" = "禁用钥匙串访问";
+"disable_keychain_access_subtitle" = "启用时阻止任何钥匙串访问。";
+"about_tagline" = "愿你的 token 永不耗尽——随时关注智能体额度。";
+"link_github" = "GitHub";
+"link_website" = "网站";
+"link_twitter" = "Twitter";
+"link_email" = "电子邮件";
+"check_updates_auto" = "自动检查更新";
+"update_channel" = "更新频道";
+"check_for_updates" = "检查更新…";
+"updates_unavailable" = "此构建中更新不可用。";
+"copyright" = "© 2026 Peter Steinberger。MIT 许可证。";
+"section_logging" = "日志";
+"enable_file_logging" = "启用文件日志";
+"enable_file_logging_subtitle" = "将日志写入 %@ 以进行调试。";
+"verbosity_title" = "详细程度";
+"verbosity_subtitle" = "控制日志记录的详细程度。";
+"open_log_file" = "打开日志文件";
+"force_animation_next_refresh" = "下次刷新时强制动画";
+"force_animation_next_refresh_subtitle" = "下次刷新后临时显示加载动画。";
+"section_loading_animations" = "加载动画";
+"loading_animations_caption" = "选择一个模式并在菜单栏中重放。“随机”保持现有行为。";
+"animation_random_default" = "随机（默认）";
+"replay_selected_animation" = "重放选中的动画";
+"blink_now" = "立即闪烁";
+"section_probe_logs" = "探测日志";
+"probe_logs_caption" = "获取最新的探测输出以进行调试；复制会保留完整文本。";
+"fetch_log" = "获取日志";
+"copy" = "复制";
+"save_to_file" = "保存到文件";
+"load_parse_dump" = "加载解析转储";
+"rerun_provider_autodetect" = "重新运行提供商自动检测";
+"loading" = "加载中…";
+"no_log_yet_fetch" = "尚无日志。获取后加载。";
+"section_fetch_strategy" = "获取策略尝试";
+"fetch_strategy_caption" = "提供商上次获取流程中的决策和错误。";
+"section_openai_cookies" = "OpenAI Cookie";
+"openai_cookies_caption" = "上次 OpenAI Cookie 尝试中的 Cookie 导入和 WebKit 抓取日志。";
+"no_log_yet" = "尚无日志。请在“提供商”→“Codex”中更新 OpenAI Cookie 以运行导入。";
+"section_caches" = "缓存";
+"caches_caption" = "清除缓存的费用扫描结果或浏览器 Cookie 缓存。";
+"clear_cookie_cache" = "清除 Cookie 缓存";
+"clear_cost_cache" = "清除费用缓存";
+"section_notifications" = "通知";
+"notifications_caption" = "触发 5 小时会话窗口的测试通知（耗尽/恢复）。";
+"post_depleted" = "发布耗尽通知";
+"post_restored" = "发布恢复通知";
+"section_cli_sessions" = "CLI 会话";
+"cli_sessions_caption" = "探测后保持 Codex/Claude CLI 会话存活。默认在捕获数据后退出。";
+"keep_cli_sessions_alive" = "保持 CLI 会话存活";
+"keep_cli_sessions_alive_subtitle" = "探测之间跳过清理（仅限调试）。";
+"reset_cli_sessions" = "重置 CLI 会话";
+"section_error_simulation" = "错误模拟";
+"error_simulation_caption" = "将模拟错误消息注入菜单卡片以进行布局测试。";
+"set_menu_error" = "设置菜单错误";
+"clear_menu_error" = "清除菜单错误";
+"set_cost_error" = "设置费用错误";
+"clear_cost_error" = "清除费用错误";
+"section_cli_paths" = "CLI 路径";
+"cli_paths_caption" = "解析到的 Codex 二进制文件和 PATH 层；启动时捕获登录 PATH（短超时）。";
+"codex_binary" = "Codex 二进制文件";
+"claude_binary" = "Claude 二进制文件";
+"effective_path" = "有效 PATH";
+"unavailable" = "不可用";
+"login_shell_path" = "登录 shell PATH（启动时捕获）";
+"cleared" = "已清除。";
+"no_fetch_attempts" = "尚无获取尝试。";
+"metric_pref_automatic" = "自动";
+"metric_pref_primary" = "主要";
+"metric_pref_secondary" = "次要";
+"metric_pref_tertiary" = "第三";
+"metric_pref_extra_usage" = "额外用量";
+"metric_pref_average" = "平均";
+"metric_mistral_payg" = "Pay-as-you-go";
+"metric_mistral_monthly_plan" = "Monthly Plan";
+"display_mode_percent" = "百分比";
+"display_mode_pace" = "进度";
+"display_mode_both" = "两者";
+"display_mode_reset_time" = "重置时间";
+"display_mode_percent_desc" = "显示剩余/已使用百分比（例如 45%）";
+"display_mode_pace_desc" = "显示进度指示器（例如 +5%）";
+"display_mode_both_desc" = "同时显示百分比和进度（例如 45% · +5%）";
+"display_mode_reset_time_desc" = "显示所选指标的重置时间（例如 ↻ 3:56 PM）";
+"status_operational" = "正常运行";
+"status_partial_outage" = "部分中断";
+"status_major_outage" = "重大中断";
+"status_critical_issue" = "严重问题";
+"status_maintenance" = "维护中";
+"status_unknown" = "状态未知";
+"refresh_manual" = "手动";
+"refresh_1min" = "1 分钟";
+"refresh_2min" = "2 分钟";
+"refresh_5min" = "5 分钟";
+"refresh_15min" = "15 分钟";
+"refresh_30min" = "30 分钟";
+"not_found" = "未找到";
+"CodexBar can't show its menu bar icon" = "CodexBar 无法显示菜单栏图标";
+"Dismiss" = "关闭";
+"Open Menu Bar Settings" = "打开菜单栏设置";
+"macOS Tahoe can block menu bar apps in System Settings → Menu Bar → Allow in the Menu Bar. CodexBar is running, but macOS may be hiding its icon. Open Menu Bar settings and turn CodexBar on." = "macOS Tahoe 可能会在“系统设置”→“菜单栏”→“允许显示在菜单栏”中阻止菜单栏应用。CodexBar 正在运行，但 macOS 可能隐藏了它的图标。请打开菜单栏设置并启用 CodexBar。";
+"cost_header_estimated" = "费用（估算）";
+"cost_estimate_hint" = "根据本地日志估算 · 可能与账单不同";
+"Estimated from local Codex logs for the selected account." = "根据所选账户的本地 Codex 日志估算。";
+"No JetBrains IDE with AI Assistant detected. Install a JetBrains IDE and enable AI Assistant." = "未检测到启用 AI Assistant 的 JetBrains IDE。请安装 JetBrains IDE 并启用 AI Assistant。";
+"OpenRouter API token not configured. Set OPENROUTER_API_KEY environment variable or configure in Settings." = "未配置 OpenRouter API 令牌。请设置 OPENROUTER_API_KEY 环境变量，或在“设置”中配置。";
+"z.ai API token not found. Set apiKey in ~/.codexbar/config.json or Z_AI_API_KEY." = "未找到 z.ai API 令牌。请在 ~/.codexbar/config.json 中设置 apiKey，或设置 Z_AI_API_KEY。";
+"Missing DeepSeek API key." = "缺少 DeepSeek API 密钥。";
+"%@ is unavailable in the current environment." = "%@ 在当前环境不可用。";
+"All Systems Operational" = "系统全部正常";
+"Last 30 days" = "近 30 天";
+"Last 30 days:" = "近 30 天：";
+"This month" = "本月";
+"Store multiple OpenAI API keys." = "存储多个 OpenAI API 密钥。";
+"Admin API key" = "管理员 API 密钥";
+"Open billing" = "打开账单";
+"Google accounts" = "Google 账户";
+"Store multiple Antigravity Google OAuth accounts for quick switching." = "存储多个 Antigravity Google OAuth 账户以便快速切换。";
+"Stores each signed-in Google account for quick Antigravity switching. Uses Antigravity.app OAuth when available, or ANTIGRAVITY_OAUTH_CLIENT_ID and ANTIGRAVITY_OAUTH_CLIENT_SECRET as an override." = "保存每个已登录的 Google 账户，便于快速切换 Antigravity。优先使用 Antigravity.app OAuth；也可使用 ANTIGRAVITY_OAUTH_CLIENT_ID 和 ANTIGRAVITY_OAUTH_CLIENT_SECRET 作为覆盖。";
+"Add Google Account" = "添加 Google 账户";
+"Open Token Plan" = "打开 Token 套餐页";
+"Text Generation" = "文本生成";
+"Text to Speech" = "文本转语音";
+"Music Generation" = "音乐生成";
+"Image Generation" = "图像生成";
+"No local data found" = "未找到本地数据";
+"Credits unavailable; keep Codex running to refresh." = "额度暂不可用；请保持 Codex 运行后再刷新。";
+"No available fetch strategy for minimax." = "没有可用的 MiniMax 抓取策略。";
+"No Cursor session found. Please log in to cursor.com in Safari, Chrome, Microsoft Edge, Brave, Arc, Dia, ChatGPT Atlas, Chromium, Helium, Vivaldi, Yandex Browser, Firefox, Zen, Colibri, Sidekick, Opera, Opera GX, or Edge Canary. If you use Safari, grant CodexBar Full Disk Access in System Settings ▸ Privacy & Security. You can also sign in to Cursor from the CodexBar menu (Add / switch account)." = "未找到 Cursor 会话。请在 Safari、Chrome、Microsoft Edge、Brave、Arc、Dia、ChatGPT Atlas、Chromium、Helium、Vivaldi、Yandex Browser、Firefox、Zen、Colibri、Sidekick、Opera、Opera GX 或 Edge Canary 中登录 cursor.com。若使用 Safari，请在“系统设置 ▸ 隐私与安全性”中授予 CodexBar“完全磁盘访问权限”。你也可以在 CodexBar 菜单中登录 Cursor（添加/切换账户）。";
+"No OpenCode session cookies found in browsers." = "在浏览器中未找到 OpenCode 会话 Cookie。";
+"No available fetch strategy for %@." = "%@ 暂无可用的获取策略。";
+"Today" = "今日";
+"Today tokens" = "今日 token 用量";
+"30d cost" = "近 30 天费用";
+"30d tokens" = "近 30 天 token 用量";
+"Latest tokens" = "最近 token 用量";
+"Top model" = "最常用模型";
+"Storage" = "存储";
+"Add Account..." = "添加账户…";
+"Usage Dashboard" = "用量仪表盘";
+"Status Page" = "状态页";
+"Settings..." = "设置…";
+"About CodexBar" = "关于 CodexBar";
+"Quit" = "退出";
+"Last %d day" = "近 %d 天";
+"Last %d days" = "近 %d 天";
+"%@ tokens" = "%@ token 用量";
+"Latest billing day" = "最近结算日";
+"Latest billing day (%@)" = "最近结算日（%@）";
+"%@ left" = "%@ 剩余";
+"Resets %@" = "重置于 %@";
+"Resets in %@" = "%@后重置";
+"Resets now" = "立即重置";
+"reset_tomorrow_format" = "明天 %@";
+"Lasts until reset" = "持续到重置";
+"Updated %@" = "更新于 %@";
+"Updated %@h ago" = "%@ 小时前更新";
+"Updated %@m ago" = "%@ 分钟前更新";
+"Updated just now" = "刚刚更新";
+"Projected empty in %@" = "预计 %@ 后耗尽";
+"Runs out in %@" = "预计 %@ 后耗尽";
+"Pace: %@" = "节奏：%@";
+"Pace: %@ · %@" = "节奏：%@ · %@";
+"%@ · %@" = "%@ · %@";
+"≈ %d%% run-out risk" = "≈ %d%% 耗尽风险";
+"%d%% in deficit" = "超额 %d%%";
+"%d%% in reserve" = "余量 %d%%";
+"usage_percent_suffix_left" = "剩余";
+"usage_percent_suffix_used" = "已使用";
+"Store multiple DeepSeek API keys." = "存储多个 DeepSeek API 密钥。";
+"This week" = "本周";
+"Week" = "本周";
+"Month" = "本月";
+"Models" = "模型数";
+"24h tokens" = "24 小时 token 用量";
+"Latest hour" = "最近 1 小时";
+"Peak hour" = "峰值小时";
+"Top method" = "主要方法";
+"30d cash" = "近 30 天费用";
+"30d billing history from MiniMax web session" = "来自 MiniMax Web 会话的近 30 天账单历史";
+"AWS Cost Explorer billing can lag." = "AWS Cost Explorer 账单数据可能延迟。";
+"Rate limit: %d / %@" = "速率限制：%d / %@";
+"Key remaining" = "密钥剩余额度";
+"No limit set for the API key" = "该 API 密钥未设置上限";
+"API key limit unavailable right now" = "当前无法获取 API 密钥上限";
+"This month: %@ tokens" = "本月：%@ token";
+"No utilization data yet." = "暂无使用率数据。";
+"No %@ utilization data yet." = "暂无 %@ 使用率数据。";
+"%@: %@%% used" = "%@：已用 %@%%";
+"%dd" = "%d 天";
+"today" = "今天";
+"just now" = "刚刚";
+"On pace" = "节奏正常";
+"Runs out now" = "即将耗尽";
+"Projected empty now" = "即将耗尽";
+"Switch Account..." = "切换账户…";
+"Update ready, restart now?" = "更新已就绪，是否立即重启？";
+"Daily" = "每日";
+"Hourly Tokens" = "每小时 token 用量";
+"No data" = "暂无数据";
+"No usage breakdown data available." = "暂无可用用量明细数据。";
+"Today: %@ · %@ tokens" = "今日：%@ · %@ token";
+"Today: %@" = "今日：%@";
+"Today: %@ tokens" = "今日：%@ token";
+"Last 30 days: %@ · %@ tokens" = "近 30 天：%@ · %@ token";
+"Last 30 days: %@" = "近 30 天：%@";
+"Est. total (30d): %@" = "近 30 天估算总计：%@";
+"Est. total (%@): %@" = "估算总计（%@）：%@";
+"Hover a bar for details" = "悬停在柱形图上查看详情";
+"%@: %@ · %@ tokens" = "%@：%@ · %@ token";
+"No providers selected for Overview." = "概览中尚未选择提供商。";
+"No overview data available." = "概览暂无可用数据。";
+"Auto uses the local IDE API first, then Google OAuth when the IDE is closed." = "自动模式会优先使用本地 IDE API；当 IDE 关闭时再使用 Google OAuth。";
+"Login with Google" = "使用 Google 登录";
+"Google OAuth" = "Google OAuth";
+"Add accounts via GitHub OAuth Device Flow on the selected host." = "通过所选主机的 GitHub OAuth 设备流程添加账户。";
+"Manual cleanup: past sessions" = "手动清理：历史会话";
+"Clearing removes past resume, continue, and rewind history." = "清理后将移除历史恢复、继续和回退记录。";
+"Manual cleanup: file checkpoints" = "手动清理：文件检查点";
+
+/* Popup panels */
+"No usage configured." = "尚未配置用量。";
+"Quota" = "配额";
+"tokens" = "token";
+"requests" = "请求";
+"Latest" = "最新";
+"Monthly" = "每月";
+"Sonnet" = "Sonnet";
+"Overages" = "超额";
+"Activity" = "活动";
+"Copied" = "已复制";
+"Copy error" = "复制错误";
+"Copy path" = "复制路径";
+"Extra usage spent" = "额外用量支出";
+"Credits remaining" = "剩余额度";
+"Using CLI fallback" = "使用 CLI 回退";
+"Balance updates in near-real time (up to 5 min lag)" = "余额接近实时更新（最多延迟 5 分钟）";
+"Daily billing data finalizes at 07:00 UTC" = "每日账单数据会在 UTC 07:00 完成结算";
+"%@ of %@ credits left" = "剩余 %@ / %@ 点额度";
+"%@ of %@ bonus credits left" = "剩余 %@ / %@ 点奖励额度";
+"%@ / %@ (%@ remaining)" = "%@ / %@（剩余 %@）";
+"%@/%@ left" = "剩余 %@ / %@";
+"Gemini Flash" = "Gemini Flash";
+"Regenerates %@" = "%@后恢复";
+"used after next regen" = "下次恢复后已使用";
+"after next regen" = "下次恢复后";
+"Near full" = "接近全满";
+"Full in ~1 regen" = "约 1 次恢复后全满";
+"Full in ~%.0f regens" = "约 %.0f 次恢复后全满";
+"Overage usage" = "超额用量";
+"Overage cost" = "超额费用";
+"credits" = "额度";
+"Zen balance" = "Zen 余额";
+"API spend" = "API 支出";
+"Extra usage" = "额外用量";
+"Quota usage" = "配额用量";
+"Your spend" = "您的支出";
+"%.0f%% used" = "已使用 %.0f%%";
+"Usage history (today)" = "用量记录（今天）";
+"Usage history (%d days)" = "用量记录（%d 天）";
+"%d percent remaining" = "剩余 %d%%";
+"Unknown" = "未知";
+"stale data" = "数据过旧";
+"No credits history data available." = "暂无可用额度记录数据。";
+"Credits history chart" = "额度记录图表";
+"%d days of credits data" = "%d 天额度数据";
+"Usage breakdown chart" = "用量明细图表";
+"%d days of usage data across %d services" = "%d 天用量数据，涵盖 %d 个服务";
+"Cost history chart" = "费用记录图表";
+"%d days of cost data" = "%d 天费用数据";
+"Plan utilization chart" = "套餐使用率图表";
+"%d utilization samples" = "%d 条使用率样本";
+"Hourly Usage" = "每小时用量";
+"Usage remaining" = "剩余用量";
+"Usage used" = "已使用用量";
+"API key verified. Ollama does not expose Cloud quota limits through the API." = "API 密钥已验证。Ollama 不会通过 API 暴露 Cloud 配额限制。";
+"Last 30 days: %@ tokens" = "近 30 天：%@ token";
+"7d spend" = "7 天支出";
+"30d spend" = "30 天支出";
+"Cache read" = "缓存读取";
+"Claude Admin API 30 day spend trend" = "Claude Admin API 30 天支出趋势";
+"OpenRouter API key spend trend" = "OpenRouter API 密钥支出趋势";
+"z.ai hourly token trend" = "z.ai 每小时 token 趋势";
+"MiniMax 30 day token usage trend" = "MiniMax 30 天 token 用量趋势";
+"Today cash" = "今日现金";
+"DeepSeek 30 day token usage trend" = "DeepSeek 30 天 token 用量趋势";
+"cache-hit input" = "缓存命中输入";
+"cache-miss input" = "缓存未命中输入";
+"output" = "输出";
+"Requests" = "请求";
+"Reported by OpenAI Admin API organization usage." = "由 OpenAI Admin API 组织用量报告。";
+"Reported by Mistral billing usage." = "由 Mistral 账单用量报告。";
+"Clearing removes checkpoint restore data for previous edits." = "清理后将移除以往编辑的检查点恢复数据。";
+"Manual cleanup: saved plans" = "手动清理：已保存计划";
+"Clearing removes old plan-mode files." = "清理后将移除旧的计划模式文件。";
+"Manual cleanup: debug logs" = "手动清理：调试日志";
+"Clearing removes past debug logs." = "清理后会移除历史调试日志。";
+"Manual cleanup: attachment cache" = "手动清理：附件缓存";
+"Clearing removes cached large pastes or attached images." = "清理后会移除缓存的大段粘贴内容或附件图片。";
+"Manual cleanup: session metadata" = "手动清理：会话元数据";
+"Clearing removes per-session environment metadata." = "清理后会移除每个会话的环境元数据。";
+"Manual cleanup: shell snapshots" = "手动清理：Shell 快照";
+"Clearing removes leftover runtime shell snapshot files." = "清理后会移除遗留的运行时 Shell 快照文件。";
+"Manual cleanup: legacy todos" = "手动清理：旧版待办";
+"Clearing removes legacy per-session task lists." = "清理后会移除旧版的每会话任务列表。";
+"Manual cleanup: sessions" = "手动清理：会话";
+"Clearing removes past Codex session history." = "清理后将移除历史 Codex 会话记录。";
+"Manual cleanup: archived sessions" = "手动清理：归档会话";
+"Clearing removes archived Codex session history." = "清理后会移除已归档的 Codex 会话记录。";
+"Manual cleanup: cache" = "手动清理：缓存";
+"Clearing removes provider-owned cached data." = "清理后将移除提供商缓存数据。";
+"Manual cleanup: logs" = "手动清理：日志";
+"Clearing removes local diagnostic logs." = "清理后将移除本地诊断日志。";
+"Manual cleanup: file history" = "手动清理：文件历史";
+"Clearing removes local edit checkpoint history." = "清理后会移除本地编辑检查点历史。";
+"Manual cleanup: temporary data" = "手动清理：临时数据";
+"Clearing removes local temporary provider data." = "清理后会移除本地临时提供商数据。";
+"Total: %@" = "总计：%@";
+"%d more items" = "另有 %d 项";
+"Cleanup ideas" = "清理建议";
+"%d unreadable item(s) skipped" = "已跳过 %d 个不可读项目";
+"weekly_progress_work_days_title" = "工作日刻度线";
+"weekly_progress_work_days_subtitle" = "设置用于每周用量条刻度和进度计算的工作日。";
+"copilot_device_code" = "设备代码已复制到剪贴板：%1$@\n\n请在以下地址验证：%2$@";
+"copilot_waiting_text" = "请在浏览器中完成登录。\n登录完成后，此窗口会自动关闭。";
+"vertex_ai_login_instructions" = "要跟踪 Vertex AI 用量，请通过 Google Cloud 进行认证。\n\n1. 打开终端\n2. 运行：gcloud auth application-default login\n3. 按照浏览器提示登录\n4. 设置你的项目：gcloud config set project PROJECT_ID\n\n是否现在打开终端？";
+"minimax_usage_amount_format" = "用量：%@ / %@";
+"minimax_used_percent_format" = "已使用 %@";
+"minimax_service_text_generation" = "文本生成";
+"minimax_service_text_to_speech" = "文本转语音";
+"minimax_service_music_generation" = "音乐生成";
+"minimax_service_image_generation" = "图像生成";
+"minimax_service_lyrics_generation" = "歌词生成";
+"minimax_service_coding_plan_vlm" = "视觉编码计划";
+"minimax_service_coding_plan_search" = "搜索编码计划";
+
+/* Notification strings */
+"login_success_notification_title" = "%@ 登录成功";
+"login_success_notification_body" = "可以返回应用了，认证已完成。";
+"session_depleted_notification_title" = "%@ 会话额度已用尽";
+"session_depleted_notification_body" = "剩余 0%。可用时会通知你。";
+"session_restored_notification_title" = "%@ 会话已恢复";
+"session_restored_notification_body" = "会话额度已重新可用。";
+"quota_warning_notification_title" = "%1$@ 的 %2$@ 额度偏低";
+"quota_warning_notification_body" = "剩余 %1$@。已达到 %2$d%% 的 %3$@ 预警阈值。";
+"quota_warning_notification_body_with_account" = "账户 %1$@。剩余 %2$@。已达到 %3$d%% 的 %4$@ 预警阈值。";
+
+/* Additional provider settings and alerts */
+"%@ is waiting for permission" = "%@ 正在等待权限";
+"%@ requests" = "%@ 个请求";
+"%@: %@ credits" = "%@：%@ 额度";
+"30d requests" = "近 30 天请求";
+"4 days" = "4 天";
+"5 days" = "5 天";
+"7 days" = "7 天";
+"API key verifies Ollama Cloud access; cookies still expose quota limits." = "API 密钥会验证 Ollama Cloud 访问权限；Cookie 仍会提供配额限制。";
+"AWS access key ID. Can also be set with AWS_ACCESS_KEY_ID." = "AWS 访问密钥 ID。也可以用 AWS_ACCESS_KEY_ID 设置。";
+"AWS region. Can also be set with AWS_REGION." = "AWS 区域。也可以用 AWS_REGION 设置。";
+"AWS secret access key. Can also be set with AWS_SECRET_ACCESS_KEY." = "AWS 秘密访问密钥。也可以用 AWS_SECRET_ACCESS_KEY 设置。";
+"Access key ID" = "访问密钥 ID";
+"Add Account" = "添加账号";
+"Adding Account…" = "正在添加账号…";
+"Antigravity login failed" = "Antigravity 登录失败";
+"Antigravity login timed out" = "Antigravity 登录超时";
+"Auth source" = "认证来源";
+"Automatic imports browser cookies from Xiaomi MiMo." = "自动导入 Xiaomi MiMo 的浏览器 Cookie。";
+"Automatic imports Windsurf session data from Chromium browser localStorage." = "自动从 Chromium 浏览器 localStorage 导入 Windsurf 会话数据。";
+"Automatic imports browser cookies from Bailian." = "自动导入 Bailian 的浏览器 Cookie。";
+"Automatically imports browser cookies." = "自动导入浏览器 Cookie。";
+"Automatically imports browser session cookies." = "自动导入浏览器会话 Cookie。";
+"Azure OpenAI deployment name. AZURE_OPENAI_DEPLOYMENT_NAME is also supported." = "Azure OpenAI 部署名称。也支持 AZURE_OPENAI_DEPLOYMENT_NAME。";
+"Azure OpenAI key" = "Azure OpenAI 密钥";
+"Azure OpenAI resource endpoint. AZURE_OPENAI_ENDPOINT is also supported." = "Azure OpenAI 资源端点。也支持 AZURE_OPENAI_ENDPOINT。";
+"Base URL" = "Base URL";
+"Base URL for the LLM-API-Key-Proxy instance." = "LLM-API-Key-Proxy 实例的 Base URL。";
+"Browser cookies" = "浏览器 Cookie";
+"Cap end" = "上限终点";
+"Cap start" = "上限起点";
+"Capacity End" = "容量终点";
+"Capacity Start" = "容量起点";
+"Changelog" = "变更记录";
+"Choose the Moonshot/Kimi API host for international or China mainland accounts." = "选择国际或中国大陆账号使用的 Moonshot/Kimi API 主机。";
+"CodexBar can't replace a system account that is signed in with an API key only setup." = "CodexBar 无法替换仅使用 API 密钥登录设置的系统账号。";
+"CodexBar could not find saved auth for that account. Re-authenticate it and try again." = "CodexBar 找不到该账号已保存的认证。请重新认证后再试。";
+"CodexBar could not read managed account storage. Recover the store before adding another account." = "CodexBar 无法读取托管账号存储区。请先修复存储区，再添加其他账号。";
+"CodexBar could not read saved auth for that account. Re-authenticate it and try again." = "CodexBar 无法读取该账号已保存的认证。请重新认证后再试。";
+"CodexBar could not read the current system account on this Mac." = "CodexBar 无法读取此 Mac 上当前的系统账号。";
+"CodexBar could not replace the live Codex auth on this Mac." = "CodexBar 无法替换此 Mac 上当前的 Codex 认证。";
+"CodexBar could not safely preserve the current system account before switching." = "CodexBar 无法在切换前安全保留当前的系统账号。";
+"CodexBar could not save the current system account before switching." = "CodexBar 无法在切换前保存当前的系统账号。";
+"CodexBar could not update managed account storage." = "CodexBar 无法更新托管账号存储区。";
+"CodexBar found another managed account that already uses the current system account. Resolve the duplicate account before switching." = "CodexBar 发现另一个托管账号已使用当前的系统账号。请先解决重复账号，再进行切换。";
+"CodexBar will ask macOS Keychain for “%@” so it can decrypt browser cookies and authenticate your account. Click OK to continue." = "CodexBar 将向 macOS 钥匙串请求“%@”，以解密浏览器 Cookie 并认证你的账号。点击“确定”继续。";
+"CodexBar will ask macOS Keychain for the Claude Code OAuth token so it can fetch your Claude usage. Click OK to continue." = "CodexBar 将向 macOS 钥匙串请求 Claude Code OAuth token，以获取你的 Claude 用量。点击“确定”继续。";
+"CodexBar will ask macOS Keychain for your Amp cookie header so it can fetch usage. Click OK to continue." = "CodexBar 将向 macOS 钥匙串请求你的 Amp Cookie 标头，以获取用量。点击“确定”继续。";
+"CodexBar will ask macOS Keychain for your Augment cookie header so it can fetch usage. Click OK to continue." = "CodexBar 将向 macOS 钥匙串请求你的 Augment Cookie 标头，以获取用量。点击“确定”继续。";
+"CodexBar will ask macOS Keychain for your Claude cookie header so it can fetch Claude web usage. Click OK to continue." = "CodexBar 将向 macOS 钥匙串请求你的 Claude Cookie 标头，以获取 Claude 网页用量。点击“确定”继续。";
+"CodexBar will ask macOS Keychain for your Cursor cookie header so it can fetch usage. Click OK to continue." = "CodexBar 将向 macOS 钥匙串请求你的 Cursor Cookie 标头，以获取用量。点击“确定”继续。";
+"CodexBar will ask macOS Keychain for your Factory cookie header so it can fetch usage. Click OK to continue." = "CodexBar 将向 macOS 钥匙串请求你的 Factory Cookie 标头，以获取用量。点击“确定”继续。";
+"CodexBar will ask macOS Keychain for your GitHub Copilot token so it can fetch usage. Click OK to continue." = "CodexBar 将向 macOS 钥匙串请求你的 GitHub Copilot token，以获取用量。点击“确定”继续。";
+"CodexBar will ask macOS Keychain for your Kimi K2 API key so it can fetch usage. Click OK to continue." = "CodexBar 将向 macOS 钥匙串请求你的 Kimi K2 API 密钥，以获取用量。点击“确定”继续。";
+"CodexBar will ask macOS Keychain for your Kimi auth token so it can fetch usage. Click OK to continue." = "CodexBar 将向 macOS 钥匙串请求你的 Kimi 认证 token，以获取用量。点击“确定”继续。";
+"CodexBar will ask macOS Keychain for your MiniMax API token so it can fetch usage. Click OK to continue." = "CodexBar 将向 macOS 钥匙串请求你的 MiniMax API token，以获取用量。点击“确定”继续。";
+"CodexBar will ask macOS Keychain for your MiniMax cookie header so it can fetch usage. Click OK to continue." = "CodexBar 将向 macOS 钥匙串请求你的 MiniMax Cookie 标头，以获取用量。点击“确定”继续。";
+"CodexBar will ask macOS Keychain for your OpenAI cookie header so it can fetch Codex dashboard extras. Click OK to continue." = "CodexBar 将向 macOS 钥匙串请求你的 OpenAI Cookie 标头，以获取 Codex 仪表盘额外数据。点击“确定”继续。";
+"CodexBar will ask macOS Keychain for your OpenCode cookie header so it can fetch usage. Click OK to continue." = "CodexBar 将向 macOS 钥匙串请求你的 OpenCode Cookie 标头，以获取用量。点击“确定”继续。";
+"CodexBar will ask macOS Keychain for your Synthetic API key so it can fetch usage. Click OK to continue." = "CodexBar 将向 macOS 钥匙串请求你的 Synthetic API 密钥，以获取用量。点击“确定”继续。";
+"CodexBar will ask macOS Keychain for your z.ai API token so it can fetch usage. Click OK to continue." = "CodexBar 将向 macOS 钥匙串请求你的 z.ai API token，以获取用量。点击“确定”继续。";
+"Could not open Cursor login in your browser." = "无法在浏览器中打开 Cursor 登录。";
+"Could not open browser for Antigravity" = "无法为 Antigravity 打开浏览器";
+"Credits used" = "已用额度";
+"Day" = "日期";
+"Deployment" = "部署";
+"Drag to reorder" = "拖动以重新排序";
+"Sort providers alphabetically" = "按字母顺序排列提供商";
+"Sort providers alphabetically (enabled first)" = "按字母顺序排列提供商（已启用的优先）";
+"Sorted alphabetically (enabled first) — click to use your custom order" = "已按字母顺序排列（已启用的优先）— 点击使用自定义顺序";
+"Endpoint" = "端点";
+"Enterprise host" = "Enterprise 主机";
+"Extra usage balance: %@" = "额外使用量余额：%@";
+"Keychain Access Required" = "需要钥匙串访问权限";
+"Kiro menu bar value" = "Kiro 菜单栏数值";
+"Label" = "标签";
+"No organizations loaded. Click Refresh after setting your API key." = "尚未加载组织。设置 API 密钥后点击“刷新”。";
+"No output captured." = "未捕获到输出。";
+"No system account" = "没有系统账号";
+"Oasis-Token" = "Oasis-Token";
+"Open Augment (Log Out & Back In)" = "打开 Augment（退出后重新登录）";
+"Open Codebuff Dashboard" = "打开 Codebuff 仪表盘";
+"Open Command Code Settings" = "打开 Command Code 设置";
+"Open Crof dashboard" = "打开 Crof 仪表盘";
+"Open Manus" = "打开 Manus";
+"Open MiMo Balance" = "打开 MiMo 余额";
+"Open Moonshot Console" = "打开 Moonshot 控制台";
+"Open Ollama API Keys" = "打开 Ollama API 密钥";
+"Open StepFun Platform" = "打开 StepFun 平台";
+"Open T3 Chat Settings" = "打开 T3 Chat 设置";
+"Open Volcengine Ark Console" = "打开 Volcengine Ark 控制台";
+"Open legacy provider docs" = "打开旧版提供商文档";
+"Open projects" = "打开项目";
+"Open this URL manually to continue login:\n\n%@" = "手动打开此 URL 以继续登录：\n\n%@";
+"Optional organization ID for accounts linked to multiple Anthropic organizations." = "适用于关联多个 Anthropic 组织的账号，可选填组织 ID。";
+"Optional. Applies to the configured Admin API key; selected token accounts do not inherit OPENAI_PROJECT_ID." = "选填。应用到已设置的 Admin API 密钥；选中的 token 账号不会继承 OPENAI_PROJECT_ID。";
+"Optional. Enter your GitHub Enterprise host, for example octocorp.ghe.com. Leave blank for github.com." = "选填。输入你的 GitHub Enterprise 主机，例如 octocorp.ghe.com。留空则使用 github.com。";
+"Optional. Leave blank to discover and aggregate projects visible to the API key." = "选填。留空会发现并汇总 API 密钥可见的项目。";
+"Org ID (optional)" = "组织 ID（选填）";
+"Organizations" = "组织";
+"Password" = "密码";
+"%@ authentication is disabled." = "%@ 认证已禁用。";
+"%@ cookies are disabled." = "%@ Cookie 已禁用。";
+"%@ web API access is disabled." = "%@ Web API 访问已禁用。";
+"Disable %@ dashboard cookie usage." = "禁用 %@ 仪表盘 Cookie 用法。";
+"Keychain access is disabled in Advanced, so browser cookie import is unavailable." = "高级设置中已禁用钥匙串访问，因此无法导入浏览器 Cookie。";
+"Manually paste an %@ from a browser session." = "从浏览器会话中手动粘贴 %@。";
+"Paste a Cookie header captured from %@." = "粘贴从 %@ 捕获的 Cookie 标头。";
+"Paste a Cookie header from %@." = "粘贴来自 %@ 的 Cookie 标头。";
+"Paste a Cookie header or cURL capture from %@." = "粘贴来自 %@ 的 Cookie 标头或 cURL 捕获内容。";
+"Paste a Cookie header or full cURL capture from %@." = "粘贴来自 %@ 的 Cookie 标头或完整 cURL 捕获内容。";
+"Paste a Cookie or Authorization header from %@." = "粘贴来自 %@ 的 Cookie 或 Authorization 标头。";
+"Paste a full cookie header or the %@ value." = "粘贴完整 Cookie 标头或 %@ 值。";
+"Paste a Cookie header or full cURL capture from T3 Chat settings." = "粘贴 T3 Chat 设置中的 Cookie 标头或完整 cURL 捕获内容。";
+"Paste the Cookie header from a request to admin.mistral.ai. Must contain an ory_session_* cookie." = "粘贴发往 admin.mistral.ai 请求中的 Cookie 标头。必须包含 ory_session_* Cookie。";
+"Paste the Oasis-Token from a logged-in browser session on platform.stepfun.com." = "粘贴 platform.stepfun.com 已登录浏览器会话中的 Oasis-Token。";
+"Paste the %@ JSON bundle from %@." = "粘贴来自 %2$@ 的 %1$@ JSON 包。";
+"Paste the %@ value or a full Cookie header." = "粘贴 %@ 值或完整 Cookie 标头。";
+"Personal account" = "个人账号";
+"Project ID" = "项目 ID";
+"Re-auth" = "重新认证";
+"Re-login at claude.ai" = "重新登录 claude.ai";
+"Re-authenticating…" = "正在重新认证…";
+"Refresh Session" = "刷新会话";
+"Refresh organizations" = "刷新组织";
+"Region" = "区域";
+"Reload" = "重新加载";
+"Reorder" = "重新排序";
+"Secret access key" = "秘密访问密钥";
+"Series" = "序列";
+"Service" = "服务";
+"Show or hide Kiro credits, percent, or both next to the menu bar icon." = "在菜单栏图标旁显示或隐藏 Kiro 额度、百分比，或两者都显示。";
+"Show usage for organizations you belong to. Personal account is always shown." = "显示你所属组织的用量。个人账号始终显示。";
+"Sign in to cursor.com in your browser, then refresh Cursor in CodexBar." = "请在浏览器中登录 cursor.com，然后在 CodexBar 刷新 Cursor。";
+"Simulated error text" = "模拟错误文字";
+"StepFun platform account (phone number or email)." = "StepFun 平台账号（手机号或电子邮件）。";
+"Stored in ~/.codexbar/config.json." = "存储在 ~/.codexbar/config.json 中。";
+"Stored in ~/.codexbar/config.json. AZURE_OPENAI_API_KEY is also supported." = "存储在 ~/.codexbar/config.json 中。也支持 AZURE_OPENAI_API_KEY。";
+"Stored in ~/.codexbar/config.json. For the official Kimi API, use Moonshot / Kimi API." = "存储在 ~/.codexbar/config.json 中。官方 Kimi API 请使用 Moonshot / Kimi API。";
+"Stored in ~/.codexbar/config.json. Get your API key from the Volcengine Ark console." = "存储在 ~/.codexbar/config.json 中。请从 Volcengine Ark 控制台获取 API 密钥。";
+"Stored in ~/.codexbar/config.json. Get your key from Ollama settings." = "存储在 ~/.codexbar/config.json 中。请从 Ollama 设置获取密钥。";
+"Stored in ~/.codexbar/config.json. Get your key from console.deepgram.com." = "存储在 ~/.codexbar/config.json 中。请从 console.deepgram.com 获取密钥。";
+"Stored in ~/.codexbar/config.json. Get your key from elevenlabs.io/app/settings/api-keys." = "存储在 ~/.codexbar/config.json 中。请从 elevenlabs.io/app/settings/api-keys 获取密钥。";
+"Stored in ~/.codexbar/config.json. Get your key from openrouter.ai/settings/keys and set a key spending limit there to enable API key quota tracking." = "存储在 ~/.codexbar/config.json 中。请从 openrouter.ai/settings/keys 获取密钥，并在那里设置密钥支出上限以启用 API 密钥配额跟踪。";
+"Stored in ~/.codexbar/config.json. In Warp, open Settings > Platform > API Keys, then create one." = "存储在 ~/.codexbar/config.json 中。在 Warp 中打开 Settings > Platform > API Keys，然后创建一个。";
+"Stored in ~/.codexbar/config.json. Metrics require Groq Enterprise Prometheus access." = "存储在 ~/.codexbar/config.json 中。指标需要 Groq Enterprise Prometheus 访问权限。";
+"Stored in ~/.codexbar/config.json. OPENAI_ADMIN_KEY is preferred; OPENAI_API_KEY still works." = "存储在 ~/.codexbar/config.json 中。优先使用 OPENAI_ADMIN_KEY；OPENAI_API_KEY 仍可使用。";
+"Stored in ~/.codexbar/config.json. Requires an Anthropic Admin API key." = "存储在 ~/.codexbar/config.json 中。需要 Anthropic Admin API 密钥。";
+"Stored in ~/.codexbar/config.json. Used for /v1/quota-stats." = "存储在 ~/.codexbar/config.json 中。用于 /v1/quota-stats。";
+"Stored in ~/.codexbar/config.json. You can also provide CODEBUFF_API_KEY or let CodexBar read ~/.config/manicode/credentials.json (created by `codebuff login`)." = "存储在 ~/.codexbar/config.json 中。你也可以提供 CODEBUFF_API_KEY，或让 CodexBar 读取由 `codebuff login` 创建的 ~/.config/manicode/credentials.json。";
+"Stored in ~/.codexbar/config.json. You can also provide CROF_API_KEY." = "存储在 ~/.codexbar/config.json 中。你也可以提供 CROF_API_KEY。";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or ~/.local/share/kilo/auth.json (kilo.access)." = "存储在 ~/.codexbar/config.json 中。你也可以提供 KILO_API_KEY 或 ~/.local/share/kilo/auth.json（kilo.access）。";
+"T3 Chat cookie" = "T3 Chat Cookie";
+"That account is no longer available in CodexBar. Refresh the account list and try again." = "该账号已无法在 CodexBar 中使用。请刷新账号列表后再试。";
+"The browser login did not complete in time. Try Antigravity login again." = "浏览器登录未在时限内完成。请再次尝试 Antigravity 登录。";
+"Timed out waiting for Cursor login. %@" = "等待 Cursor 登录超时。%@";
+"Timed out waiting for Cursor login. %@ Last error: %@" = "等待 Cursor 登录超时。%@ 最后错误：%@";
+"Today requests" = "今日请求";
+"Total (30d): %@ credits" = "总计（30 天）：%@ 额度";
+"Username" = "用户名";
+"Uses username + password to login and obtain an Oasis-Token automatically." = "使用用户名与密码登录，并自动获取 Oasis-Token。";
+"Uses username + password to login and obtain an %@ automatically." = "使用用户名与密码登录，并自动获取 %@。";
+"Utilization End" = "使用率终点";
+"Utilization Start" = "使用率起点";
+"Verbosity" = "详细程度";
+"Windsurf session JSON bundle" = "Windsurf 会话 JSON 包";
+"Workspace ID" = "工作区 ID";
+"Your StepFun platform password. Used to login and obtain a session token." = "你的 StepFun 平台密码。用于登录并获取会话 token。";
+"claude /login exited with status %d." = "claude /login 以状态 %d 结束。";
+"codex login exited with status %d." = "codex login 以状态 %d 结束。";
+"Cookie: …\n\nor paste a cURL capture from the Abacus AI dashboard" = "Cookie: …\n\n或粘贴 Abacus AI 仪表盘的 cURL 捕获内容";
+"Cookie: …\n\nor paste the __Secure-next-auth.session-token value" = "Cookie: …\n\n或粘贴 __Secure-next-auth.session-token 值";
+"Cookie: …\n\nor paste the kimi-auth token value" = "Cookie: …\n\n或粘贴 kimi-auth token 值";
+"session_id=...\n\nor paste just the session_id value" = "session_id=...\n\n或只粘贴 session_id 值";
+"Clear" = "清除";
+"No matching providers" = "没有匹配的提供商";
+"Search providers" = "搜索提供商";
+
+"language_vietnamese" = "越南语";
+
+"Request quota: %@ / %@" = "请求额度：%@ / %@";
+"language_turkish" = "Türkçe";
+"language_indonesian" = "印度尼西亚语";
+"language_arabic" = "العربية";
+"language_persian" = "فارسی";
+"language_thai" = "ไทย";
+"Limit Reset Credits" = "限额重置额度";
+"1 manual reset available" = "1 次手动重置可用";
+"%d manual resets available" = "%d 次手动重置可用";
+"Next expires %@" = "下一个将于 %@ 到期";
+"Other (%d items)" = "其他（%d 项）";
+"Expand" = "展开";
+"Collapse" = "收起";
+"byte_unit_byte" = "字节";
+"byte_unit_bytes" = "字节";
+"byte_unit_kilobyte" = "千字节";
+"byte_unit_kilobytes" = "千字节";
+"byte_unit_megabyte" = "兆字节";
+"byte_unit_megabytes" = "兆字节";
+"byte_unit_gigabyte" = "吉字节";
+"byte_unit_gigabytes" = "吉字节";
diff --git a/Sources/CodexBar/Resources/zh-Hant.lproj/Localizable.strings b/Sources/CodexBar/Resources/zh-Hant.lproj/Localizable.strings
new file mode 100644
index 0000000000..ebde59b026
--- /dev/null
+++ b/Sources/CodexBar/Resources/zh-Hant.lproj/Localizable.strings
@@ -0,0 +1,978 @@
+/* Chinese (Traditional) localization for CodexBar */
+
+" providers" = " 提供者";
+"(System)" = "(System)";
+"30d" = "30 天";
+"A managed Codex login is already running. Wait for it to finish before adding " = "託管 Codex 登入已在執行。請等待其完成後再新增 ";
+"API key" = "API 金鑰";
+"API key limit" = "API 金鑰限制";
+"API region" = "API 區域";
+"API token" = "API token";
+"API tokens" = "API token";
+"About" = "關於";
+"Account" = "帳號";
+"Accounts" = "帳號";
+"Accounts subtitle" = "帳號副標題";
+"Active" = "作用中";
+"Add" = "新增";
+"Add Workspace" = "新增工作區";
+"Advanced" = "進階";
+"All" = "全部";
+"Always allow prompts" = "一律允許提示";
+"Animation pattern" = "動畫模式";
+"Antigravity login is managed in the app" = "Antigravity 登入由 App 管理";
+"Applies only to the Security.framework OAuth keychain reader." = "僅適用於 Security.framework OAuth 鑰匙圈讀取器。";
+"Auth" = "認證";
+"Auto" = "自動";
+"Auto falls back to the next source if the preferred one fails." = "如果偏好的來源失敗，自動改用下一個來源。";
+"Auto uses API first, then falls back to CLI on auth failures." = "自動優先使用 API，認證失敗時改用 CLI。";
+"Auto-detect" = "自動偵測";
+"Auto-refresh is off; use the menu's Refresh command." = "自動重新整理已關閉；請使用選單中的「重新整理」指令。";
+"Auto-refresh: hourly · Timeout: 10m" = "自動重新整理：每小時 · 逾時：10 分鐘";
+"Automatic" = "自動";
+"Automatic imports browser cookies and WorkOS tokens." = "自動匯入瀏覽器 Cookie 和 WorkOS token。";
+"Automatic imports browser cookies and local storage tokens." = "自動匯入瀏覽器 Cookie 和本機儲存 token。";
+"Automatic imports browser cookies for dashboard extras." = "自動匯入用於儀表板附加功能的瀏覽器 Cookie。";
+"Automatic imports browser cookies for the web API." = "自動匯入用於 Web API 的瀏覽器 Cookie。";
+"Automatic imports browser cookies from Model Studio/Bailian." = "自動從 Model Studio/Bailian 匯入瀏覽器 Cookie。";
+"Automatic imports browser cookies from admin.mistral.ai." = "自動從 admin.mistral.ai 匯入瀏覽器 Cookie。";
+"Automatic imports browser cookies from opencode.ai." = "自動從 opencode.ai 匯入瀏覽器 Cookie。";
+"Automatic imports browser cookies or stored sessions." = "自動匯入瀏覽器 Cookie 或已儲存的工作階段。";
+"Automatic imports browser cookies." = "自動匯入瀏覽器 Cookie。";
+"Automatically imports browser session cookie." = "自動匯入瀏覽器工作階段 Cookie。";
+"Automatically opens CodexBar when you start your Mac." = "登入 Mac 時自動開啟 CodexBar。";
+"Automation" = "自動化";
+"Average (\\(label1) + \\(label2))" = "平均（\\(label1) + \\(label2)）";
+"Average (\\(metadata.sessionLabel) + \\(metadata.weeklyLabel))" = "平均（\\(metadata.sessionLabel) + \\(metadata.weeklyLabel)）";
+"Avoid Keychain prompts" = "避免鑰匙圈提示";
+"Balance" = "餘額";
+"Battery Saver" = "省電模式";
+"Bordered" = "有邊框";
+"Build" = "建置";
+"Built \\(buildTimestamp)" = "建置於 \\(buildTimestamp)";
+"Buy Credits..." = "購買額度...";
+"Buy Credits…" = "購買額度…";
+"CLI paths" = "CLI 路徑";
+"CLI sessions" = "CLI 工作階段";
+"Caches" = "快取";
+"Cancel" = "取消";
+"Check for Updates…" = "檢查更新…";
+"Check for updates automatically" = "自動檢查更新";
+"Check if you like your agents having some fun up there." = "讓選單列上的 Agent 多一點變化。";
+"Check provider status" = "檢查提供者狀態";
+"Choose Codex workspace" = "選擇 Codex 工作區";
+"Choose the MiniMax host (global .io or China mainland .com)." = "選擇 MiniMax 主機（全球 .io 或中國大陸 .com）。";
+"Choose up to " = "選擇最多 ";
+"Choose up to \\(Self.maxOverviewProviders) providers" = "選擇最多 \\(Self.maxOverviewProviders) 個提供者";
+"Choose up to \\(count) providers" = "選擇最多 \\(count) 個提供者";
+"Choose what to show in the menu bar (Pace shows usage vs. expected)." = "選擇選單列中顯示的內容（進度會比較實際與預期使用量）。";
+"Choose which Codex account CodexBar should follow." = "選擇 CodexBar 要追蹤的 Codex 帳號。";
+"Choose which window drives the menu bar percent." = "選擇用於驅動選單列百分比的時段。";
+"Chrome" = "Chrome";
+"Claude CLI not found" = "找不到 Claude CLI";
+"Claude binary" = "Claude 二進位檔案";
+"Claude cookies" = "Claude Cookie";
+"Claude login failed" = "Claude 登入失敗";
+"Claude login timed out" = "Claude 登入逾時";
+"Close" = "關閉";
+"Code review" = "程式碼審查";
+"Codex CLI not found" = "找不到 Codex CLI";
+"Codex account login already running" = "Codex 帳號登入已在執行";
+"Codex binary" = "Codex 二進位檔案";
+"Codex login failed" = "Codex 登入失敗";
+"Codex login timed out" = "Codex 登入逾時";
+"CodexBar Lifecycle Keepalive" = "CodexBar 生命週期維持";
+"CodexBar could not read managed account storage. " = "CodexBar 無法讀取託管帳號儲存。";
+"Configure…" = "設定…";
+"Connected" = "已連線";
+"Controls how much detail is logged." = "控制記錄詳細程度。";
+"Cookie header" = "Cookie 標頭";
+"Cookie source" = "Cookie 來源";
+"Cookie: ..." = "Cookie：...";
+"Cookie: \\u{2026}\\\n\\\nor paste a cURL capture from the Abacus AI dashboard" = "Cookie：\\u{2026}\\\n\\\n或貼上來自 Abacus AI 儀表板的 cURL 擷取內容";
+"Cookie: \\u{2026}\\\n\\\nor paste the __Secure-next-auth.session-token value" = "Cookie：\\u{2026}\\\n\\\n或貼上 __Secure-next-auth.session-token 的值";
+"Cookie: \\u{2026}\\\n\\\nor paste the kimi-auth token value" = "Cookie：\\u{2026}\\\n\\\n或貼上 kimi-auth token 值";
+"Cookie: …" = "Cookie：…";
+"CopilotDeviceFlow" = "Copilot 裝置流程";
+"Cost" = "費用";
+"Could not add Codex account" = "無法新增 Codex 帳號";
+"Could not open Terminal for Gemini" = "無法為 Gemini 開啟終端";
+"Could not start claude /login" = "無法啟動 claude /login";
+"Could not start codex login" = "無法啟動 codex login";
+"Could not switch system account" = "無法切換系統帳號";
+"Credits" = "額度";
+"Individual credits" = "個人額度";
+"Workspace" = "工作區";
+"Credits history" = "額度歷史";
+"Cursor login failed" = "Cursor 登入失敗";
+"Custom" = "自訂";
+"Custom Path" = "自訂路徑";
+"Daily Routines" = "每日例行工作";
+"Debug" = "除錯";
+"Default" = "預設";
+"Disable Keychain access" = "停用鑰匙圈存取";
+"Disabled" = "已停用";
+"Disabled — no recent data" = "已停用 — 無近期資料";
+"Disconnected" = "已中斷連線";
+"Display" = "顯示";
+"Display mode" = "顯示模式";
+"Display reset times as absolute clock values instead of countdowns." = "將重置時間顯示為絕對時鐘值，而不是倒數計時。";
+"Done" = "完成";
+"Effective PATH" = "有效 PATH";
+"Email" = "電子郵件";
+"Enable Merge Icons to configure Overview tab providers." = "啟用「合併圖示」以設定「概覽」標籤中的提供者。";
+"Enable file logging" = "啟用檔案記錄";
+"Enabled" = "已啟用";
+"Error" = "錯誤";
+"Error simulation" = "錯誤模擬";
+"Expose troubleshooting tools in the Debug tab." = "在「除錯」標籤中顯示疑難排解工具。";
+"Failed" = "失敗";
+"False" = "假";
+"Fetch strategy attempts" = "取得策略嘗試";
+"Fetching" = "取得中";
+"Field" = "欄位";
+"Field subtitle" = "欄位副標題";
+"Finish the current managed account change before switching the system account." = "請先完成目前託管帳號變更，再切換系統帳號。";
+"Force animation on next refresh" = "下次重新整理時強制動畫";
+"Gateway region" = "閘道區域";
+"Gemini CLI not found" = "找不到 Gemini CLI";
+"Gemini/Antigravity, surfacing incidents in the icon and menu." = "Gemini/Antigravity，並在圖示和選單中顯示服務異常。";
+"General" = "一般";
+"GitHub" = "GitHub";
+"GitHub Copilot Login" = "GitHub Copilot 登入";
+"GitHub Login" = "GitHub 登入";
+"Hide details" = "隱藏詳細資訊";
+"Hide personal information" = "隱藏個人資訊";
+"Historical tracking" = "歷史追蹤";
+"How often CodexBar polls providers in the background." = "CodexBar 在背景輪詢提供者的頻率。";
+"Inactive" = "非作用中";
+"Install CLI" = "安裝 CLI";
+"Install the Claude CLI (npm i -g @anthropic-ai/claude-code) and try again." = "安裝 Claude CLI（npm i -g @anthropic-ai/claude-code）後重試。";
+"Install the Codex CLI (npm i -g @openai/codex) and try again." = "安裝 Codex CLI（npm i -g @openai/codex）後重試。";
+"Install the Gemini CLI (npm i -g @google/gemini-cli) and try again." = "安裝 Gemini CLI（npm i -g @google/gemini-cli）後重試。";
+"JetBrains AI is ready" = "JetBrains AI 已就緒";
+"JetBrains IDE" = "JetBrains IDE";
+"Keep CLI sessions alive" = "保持 CLI 工作階段存活";
+"Keyboard shortcut" = "快速鍵";
+"Keychain access" = "鑰匙圈存取";
+"Keychain prompt policy" = "鑰匙圈提示策略";
+"Last \\(name) fetch failed:" = "上次取得 \\(name) 失敗：";
+"Last \\(self.store.metadata(for: self.provider).displayName) fetch failed:" = "上次取得 \\(self.store.metadata(for: self.provider).displayName) 失敗：";
+"Last attempt" = "上次嘗試";
+"Limits not available" = "無法取得限制資料";
+"Link" = "連結";
+"Loading animations" = "載入動畫";
+"Loading…" = "載入中…";
+"Local" = "本機";
+"Logging" = "記錄";
+"Login failed" = "登入失敗";
+"Login shell PATH (startup capture)" = "登入 shell PATH（啟動時擷取）";
+"Login timed out" = "登入逾時";
+"MCP details" = "MCP 詳細資訊";
+"Managed Codex accounts unavailable" = "無法使用託管 Codex 帳號";
+"Managed account storage is unreadable. Live account access is still available, " = "託管帳號儲存區無法讀取。即時帳號仍可存取，";
+"Manual" = "手動";
+"May your tokens never run out—keep agent limits in view." = "願你的 token 永不用完，隨時掌握 Agent 限制。";
+"Menu bar" = "選單列";
+"Menu bar auto-shows the provider closest to its rate limit." = "選單列會自動顯示最接近速率限制的提供者。";
+"Menu bar metric" = "選單列指標";
+"Menu bar shows percent" = "選單列顯示百分比";
+"Menu content" = "選單內容";
+"Merge Icons" = "合併圖示";
+"Never prompt" = "永不提示";
+"No" = "否";
+"No Codex accounts detected yet." = "未偵測到 Codex 帳號。";
+"No JetBrains IDE detected" = "未偵測到 JetBrains IDE";
+"No cost history data." = "尚無費用歷史資料。";
+"No usage yet" = "尚無使用量";
+"Not fetched yet" = "尚未取得";
+"No credits history data." = "尚無額度歷史資料。";
+"No data available" = "沒有可用資料";
+"No data yet" = "尚無資料";
+"No enabled providers available for Overview." = "「概覽」中沒有可用的已啟用提供者。";
+"No providers selected" = "未選擇提供者";
+"No token accounts yet." = "尚無 token 帳號。";
+"No usage breakdown data." = "尚無使用量明細資料。";
+"None" = "無";
+"Notifications" = "通知";
+"Notifies when the 5-hour session quota hits 0% and when it becomes " = "當 5 小時工作階段配額降至 0% 或";
+"OK" = "好";
+"Obscure email addresses in the menu bar and menu UI." = "在選單列和選單介面中隱藏電子郵件地址。";
+"Off" = "關閉";
+"Offline" = "離線";
+"On" = "開啟";
+"Online" = "線上";
+"Only on user action" = "僅在使用者操作時";
+"Open" = "開啟";
+"Open API Keys" = "開啟 API 金鑰";
+"Open Amp Settings" = "開啟 Amp 設定";
+"Open Antigravity to sign in, then refresh CodexBar." = "開啟 Antigravity 登入，然後重新整理 CodexBar。";
+"Open Browser" = "開啟瀏覽器";
+"Open Coding Plan" = "開啟 Coding Plan";
+"Open Console" = "開啟主控台";
+"Open Dashboard" = "開啟儀表板";
+"Open Mistral Admin" = "開啟 Mistral 管理頁面";
+"Open Ollama Settings" = "開啟 Ollama 設定";
+"Open Terminal" = "開啟終端";
+"Open Usage Page" = "開啟使用量頁面";
+"Open Warp API Key Guide" = "開啟 Warp API 金鑰指南";
+"Open menu" = "開啟選單";
+"Open token file" = "開啟 token 檔案";
+"OpenAI cookies" = "OpenAI Cookie";
+"OpenAI web extras" = "OpenAI Web 附加功能";
+"Option A" = "選項 A";
+"Option B" = "選項 B";
+"Optional override if workspace lookup fails." = "找不到工作區時可選的覆寫值。";
+"Options" = "選項";
+"Override auto-detection with a custom IDE base path" = "使用自訂 IDE 基礎路徑覆蓋自動偵測";
+"Overview" = "概覽";
+"Overview rows always follow provider order." = "概覽列一律依提供者順序排列。";
+"Overview tab providers" = "概覽標籤提供者";
+"Paste API key…" = "貼上 API 金鑰…";
+"Paste API token…" = "貼上 API token…";
+"Paste key…" = "貼上金鑰…";
+"Paste sessionKey or OAuth token…" = "貼上 sessionKey 或 OAuth token…";
+"Paste the Cookie header from a request to admin.mistral.ai. " = "貼上發往 admin.mistral.ai 請求中的 Cookie 標頭。";
+"Paste token…" = "貼上 token…";
+"Personal" = "個人";
+"Picker" = "選擇器";
+"Picker subtitle" = "選擇器副標題";
+"Placeholder" = "預留位置";
+"Plan" = "方案";
+"Play full-screen confetti when weekly usage resets." = "每週使用量重置時播放全螢幕慶祝動畫。";
+"Polls OpenAI/Claude status pages and Google Workspace for " = "輪詢 OpenAI/Claude 狀態頁面和 Google Workspace，以檢查";
+"Prevents any Keychain access while enabled." = "啟用時封鎖任何鑰匙圈存取。";
+"Primary (API key limit)" = "主要（API 金鑰限制）";
+"Primary (\\(label))" = "主要（\\(label)）";
+"Primary (\\(metadata.sessionLabel))" = "主要（\\(metadata.sessionLabel)）";
+"Probe logs" = "探測記錄";
+"Progress bars fill as you consume quota (instead of showing remaining)." = "進度條會隨配額消耗而填滿（而不是顯示剩餘量）。";
+"Provider" = "提供者";
+"Providers" = "提供者";
+"Quit CodexBar" = "結束 CodexBar";
+"Random (default)" = "隨機（預設）";
+"Reads local usage logs. Shows today + last 30 days cost in the menu." = "讀取本機使用量記錄。在選單中顯示今天及所選歷史時段的費用。";
+"Refresh" = "重新整理";
+"Refreshing" = "正在重新整理";
+"Refresh cadence" = "重新整理頻率";
+"Remote" = "遠端";
+"Remove" = "移除";
+"Remove Codex account?" = "移除 Codex 帳號？";
+"Remove \\(account.email) from CodexBar? Its managed Codex home will be deleted." = "要從 CodexBar 中移除 \\(account.email) 嗎？其託管的 Codex 主目錄將被刪除。";
+"Remove \\(email) from CodexBar? Its managed Codex home will be deleted." = "要從 CodexBar 中移除 \\(email) 嗎？其託管的 Codex 主目錄將被刪除。";
+"Remove selected account" = "移除所選帳號";
+"Replace critter bars with provider branding icons and a percentage." = "將小動物進度條替換為提供者品牌圖示和百分比。";
+"Replay selected animation" = "重播選取的動畫";
+"Requires authentication via GitHub Device Flow." = "需要透過 GitHub 裝置流程進行認證。";
+"Resets: \\(reset)" = "重置：\\(reset)";
+"Rolling five-hour limit" = "滾動式 5 小時限制";
+"Search hourly" = "每小時搜尋";
+"Secondary (\\(label))" = "次要（\\(label)）";
+"Secondary (\\(metadata.weeklyLabel))" = "次要（\\(metadata.weeklyLabel)）";
+"Select a provider" = "選擇提供者";
+"Select the IDE to monitor" = "選擇要監控的 IDE";
+"Session" = "工作階段";
+"Session quota notifications" = "工作階段配額通知";
+"Session tokens" = "工作階段 token";
+"Settings" = "設定";
+"Show Codex Credits and Claude Extra usage sections in the menu." = "在選單中顯示 Codex 額度和 Claude 額外使用量部分。";
+"Show Debug Settings" = "顯示除錯設定";
+"Show all token accounts" = "顯示所有 token 帳號";
+"Show cost summary" = "顯示費用摘要";
+"Show credits + extra usage" = "顯示額度 + 額外使用量";
+"Show details" = "顯示詳細資訊";
+"Show most-used provider" = "顯示使用量最高的提供者";
+"Show provider icons in the switcher (otherwise show a weekly progress line)." = "在切換器中顯示提供者圖示（否則顯示每週進度線）。";
+"Show reset time as clock" = "以時鐘時間顯示重置時間";
+"Show usage as used" = "以已用量顯示";
+"Sign in via button below" = "透過下方按鈕登入";
+"Skip teardown between probes (debug-only)." = "探測之間跳過清理（僅限除錯）。";
+"Source" = "來源";
+"Stack token accounts in the menu (otherwise show an account switcher bar)." = "在選單中堆疊 token 帳號（否則顯示帳號切換欄）。";
+"Start at Login" = "登入時啟動";
+"State" = "狀態";
+"Status" = "狀態";
+"Store Claude sessionKey cookies or OAuth access tokens." = "儲存 Claude sessionKey Cookie 或 OAuth 存取 token。";
+"Store multiple Abacus AI Cookie headers." = "儲存多個 Abacus AI Cookie 標頭。";
+"Store multiple Augment Cookie headers." = "儲存多個 Augment Cookie 標頭。";
+"Store multiple Cursor Cookie headers." = "儲存多個 Cursor Cookie 標頭。";
+"Store multiple Factory Cookie headers." = "儲存多個 Factory Cookie 標頭。";
+"Store multiple MiniMax Cookie headers." = "儲存多個 MiniMax Cookie 標頭。";
+"Store multiple Mistral Cookie headers." = "儲存多個 Mistral Cookie 標頭。";
+"Store multiple Ollama Cookie headers." = "儲存多個 Ollama Cookie 標頭。";
+"Store multiple OpenCode Cookie headers." = "儲存多個 OpenCode Cookie 標頭。";
+"Store multiple OpenCode Go Cookie headers." = "儲存多個 OpenCode Go Cookie 標頭。";
+"Stored in the CodexBar config file." = "儲存在 CodexBar 設定檔中。";
+"Stored in ~/.codexbar/config.json. " = "儲存在 ~/.codexbar/config.json 中。";
+"Stored in ~/.codexbar/config.json. Generate one at kimi-k2.ai." = "儲存在 ~/.codexbar/config.json 中。可在 kimi-k2.ai 產生。";
+"Stored in ~/.codexbar/config.json. Paste the key from the Synthetic dashboard." = "儲存在 ~/.codexbar/config.json 中。請貼上來自 Synthetic 儀表板的金鑰。";
+"Stored in ~/.codexbar/config.json. Paste your Coding Plan API key from Model Studio." = "儲存在 ~/.codexbar/config.json 中。請貼上來自 Model Studio 的 Coding Plan API 金鑰。";
+"Stored in ~/.codexbar/config.json. Paste your MiniMax API key." = "儲存在 ~/.codexbar/config.json 中。請貼上你的 MiniMax API 金鑰。";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or " = "儲存在 ~/.codexbar/config.json 中。你也可以提供 KILO_API_KEY 或";
+"Stores local Codex usage history (8 weeks) to personalize Pace predictions." = "儲存本機 Codex 使用量歷史（8 週），用於個人化進度預測。";
+"Subscription Utilization" = "訂閱使用率";
+"Surprise me" = "給我驚喜";
+"Switcher shows icons" = "切換器顯示圖示";
+"Symlink CodexBarCLI to /usr/local/bin and /opt/homebrew/bin as codexbar." = "將 CodexBarCLI 作為 codexbar 符號連結到 /usr/local/bin 和 /opt/homebrew/bin。";
+"System" = "系統";
+"Temporarily shows the loading animation after the next refresh." = "下次重新整理後暫時顯示載入動畫。";
+"Tertiary (\\(label))" = "第三（\\(label)）";
+"Tertiary (\\(tertiaryTitle))" = "第三（\\(tertiaryTitle)）";
+"The default Codex account on this Mac." = "此 Mac 上的預設 Codex 帳號。";
+"Toggle" = "切換";
+"Toggle subtitle" = "切換副標題";
+"Token" = "token";
+"Trigger the menu bar menu from anywhere." = "可從任何位置開啟選單列選單。";
+"True" = "真";
+"Twitter" = "Twitter";
+"Unsupported" = "不支援";
+"Unavailable" = "無法使用";
+"Update Channel" = "更新頻道";
+"Updated" = "已更新";
+"Updates unavailable in this build." = "此建置無法使用更新功能。";
+"Usage" = "使用量";
+"Usage breakdown" = "使用量明細";
+"Usage history (30 days)" = "使用量歷史";
+"Usage source" = "使用量來源";
+"Use BigModel for the China mainland endpoints (open.bigmodel.cn)." = "中國大陸端點使用 BigModel（open.bigmodel.cn）。";
+"Use a single menu bar icon with a provider switcher." = "使用單一選單列圖示並帶提供者切換器。";
+"Use international or China mainland console gateways for quota fetches." = "使用國際或中國大陸主控台閘道取得配額資料。";
+"Version" = "版本";
+"Version \\(self.versionString)" = "版本 \\(self.versionString)";
+"Version \\(version)" = "版本 \\(version)";
+"Version \\(versionString)" = "版本 \\(versionString)";
+"Vertex AI Login" = "Vertex AI 登入";
+"Wait for the current managed Codex login to finish before adding another account." = "請等待目前託管 Codex 登入完成後再新增其他帳號。";
+"Waiting for Authentication..." = "等待認證…";
+"Website" = "網站";
+"Weekly" = "每週";
+"Weekly limit confetti" = "每週重置慶祝動畫";
+"Weekly token limit" = "每週 token 限制";
+"Weekly usage" = "每週使用量";
+"Weekly usage unavailable for this account." = "此帳號無法取得每週使用量。";
+"Window: \\(window)" = "時段：\\(window)";
+"Write logs to \\(self.fileLogPath) for debugging." = "將記錄寫入 \\(self.fileLogPath) 以進行除錯。";
+"Yes" = "是";
+"not detected" = "未偵測到";
+"\\(detail.modelCode): \\(usage)" = "\\(detail.modelCode)：\\(usage)";
+"\\(name): \\(truncated)" = "\\(name)：\\(truncated)";
+"\\(name): \\(updated) · 30d \\(cost)" = "\\(name)：\\(updated) · 30 天 \\(cost)";
+"\\(name): fetching…\\(elapsed)" = "\\(name)：取得中…\\(elapsed)";
+"\\(name): last attempt \\(when)" = "\\(name)：上次嘗試 \\(when)";
+"\\(name): no data yet" = "\\(name)：尚無資料";
+"\\(name): unsupported" = "\\(name)：不支援";
+"all browsers" = "所有瀏覽器";
+"available again." = "恢復可用時傳送通知。";
+"built_format" = "建置於 %@";
+"copilot_complete_in_browser" = "請在瀏覽器中完成登入。";
+"copilot_device_code_copied" = "裝置代碼已複製。";
+"copilot_verify_at" = "請在 %@ 驗證";
+"copilot_window_closes_auto" = "登入完成後，此視窗會自動關閉。";
+"cost_status_error" = "%1$@：%2$@";
+"cost_status_fetching" = "%1$@：取得中… %2$@";
+"cost_status_last_attempt" = "%1$@：上次嘗試 %2$@";
+"cost_status_no_data" = "%@：尚無資料";
+"cost_status_snapshot" = "%1$@：%2$@ · %3$@ %4$@";
+"cost_status_unsupported" = "%@：不支援";
+"credits_remaining" = "額度：%@";
+"cursor_on_demand" = "隨用隨付：%@";
+"cursor_on_demand_with_limit" = "隨用隨付：%1$@ / %2$@";
+"extra_usage_format" = "額外使用量：%1$@ / %2$@";
+"jetbrains_detected_generate" = "偵測到：%@。使用一次 AI 助手以產生配額資料，然後重新整理 CodexBar。";
+"jetbrains_detected_select" = "偵測到：%@。在設定中選擇你偏好的 IDE，然後重新整理 CodexBar。";
+"last_fetch_failed_with_provider" = "上次取得 %@ 失敗：";
+"last_spend" = "上次支出：%@";
+"mcp_model_usage" = "%1$@：%2$@";
+"mcp_resets" = "重置：%@";
+"mcp_window" = "時段：%@";
+"metric_average" = "平均（%1$@ + %2$@）";
+"metric_primary" = "主要（%@）";
+"metric_secondary" = "次要（%@）";
+"metric_tertiary" = "第三（%@）";
+"multiple_workspaces_found" = "CodexBar 發現 %@ 有多個工作區。請選擇要新增的工作區。";
+"ory_session_…=…; csrftoken=…" = "ory_session_…=…; csrftoken=…";
+"overview_choose_providers" = "最多選擇 %@ 個提供者";
+"remove_account_message" = "要從 CodexBar 中移除 %@ 嗎？其託管的 Codex 主目錄將被刪除。";
+"version_format" = "版本 %@";
+"workspaceID is set but only opencode, opencodego, and deepgram support workspaceID." = "已設定 workspaceID，但只有 opencode、opencodego 和 deepgram 支援 workspaceID。";
+"© 2026 Peter Steinberger. MIT License." = "© 2026 Peter Steinberger。MIT 許可證。";
+"section_system" = "系統";
+"section_usage" = "使用量";
+"section_automation" = "自動化";
+"language_title" = "語言";
+"language_subtitle" = "更改顯示語言。需要重新啟動 App 才會完全生效。";
+"language_system" = "依照系統";
+"language_english" = "English";
+"language_spanish" = "Español";
+"language_catalan" = "Català";
+"language_chinese_simplified" = "简体中文";
+"language_chinese_traditional" = "繁體中文";
+"language_portuguese_brazilian" = "Português (Brasil)";
+"language_swedish" = "瑞典語";
+"language_dutch" = "Nederlands";
+"language_german" = "Deutsch";
+"language_french" = "法語";
+"language_ukrainian" = "烏克蘭語";
+"language_japanese" = "日語";
+"language_korean" = "韓語";
+"language_italian" = "Italiano";
+"language_polish" = "Polski";
+"start_at_login_title" = "登入時啟動";
+"start_at_login_subtitle" = "登入 Mac 時自動開啟 CodexBar。";
+"show_cost_summary" = "顯示費用摘要";
+"show_cost_summary_subtitle" = "讀取本機使用量記錄。在選單中顯示今天及所選歷史時段的費用。";
+"cost_history_days_title" = "歷史時段：%d 天";
+"cost_auto_refresh_info" = "自動重新整理：每小時 · 逾時：10 分鐘";
+"refresh_cadence_title" = "重新整理頻率";
+"refresh_cadence_subtitle" = "CodexBar 在背景輪詢提供者的頻率。";
+"manual_refresh_hint" = "自動重新整理已關閉；請使用選單中的「重新整理」指令。";
+"check_provider_status_title" = "檢查提供者狀態";
+"check_provider_status_subtitle" = "輪詢 OpenAI/Claude 狀態頁面和 Google Workspace 的 Gemini/Antigravity，並在圖示和選單中顯示服務異常資訊。";
+"session_quota_notifications_title" = "工作階段配額通知";
+"session_quota_notifications_subtitle" = "當 5 小時工作階段配額用完或恢復可用時傳送通知。";
+"quota_warning_notifications_title" = "配額提醒通知";
+"quota_warning_notifications_subtitle" = "當工作階段或每週剩餘配額達到設定門檻時提醒。";
+"quota_warnings_title" = "配額提醒";
+"quota_warning_session" = "工作階段";
+"quota_warning_session_capitalized" = "工作階段";
+"quota_warning_weekly" = "每週";
+"quota_warning_weekly_capitalized" = "每週";
+"quota_warning_notification_title" = "%1$@ %2$@配額偏低";
+"quota_warning_notification_body" = "剩餘 %1$@。已達到 %2$d%% %3$@提醒門檻。";
+"quota_warning_notification_body_with_account" = "帳號 %1$@。剩餘 %2$@。已達到 %3$d%% %4$@提醒門檻。";
+"session_depleted_notification_title" = "%@ 工作階段已用完";
+"session_depleted_notification_body" = "剩餘 0%。恢復可用時會再通知。";
+"session_restored_notification_title" = "%@ 工作階段已恢復";
+"session_restored_notification_body" = "工作階段配額已恢復可用。";
+"quota_warning_warn_at" = "提醒門檻";
+"quota_warning_global_threshold_subtitle" = "工作階段和每週時段的剩餘百分比，除非提供者另有設定。";
+"quota_warning_sound" = "播放通知音效";
+"quota_warning_provider_inherits" = "預設使用全域配額提醒設定，除非在此自訂時段。";
+"quota_warning_customize_thresholds" = "自訂 %@ 門檻";
+"quota_warning_enable_warnings" = "啟用 %@ 提醒";
+"quota_warning_window_warn_at" = "%@ 提醒門檻";
+"quota_warning_off" = "關閉";
+"quota_warning_inherited" = "繼承：%@";
+"quota_warning_depleted_only" = "僅用完時";
+"quota_warning_upper" = "上限";
+"quota_warning_lower" = "下限";
+"apply" = "套用";
+"quit_app" = "結束 CodexBar";
+"tab_general" = "一般";
+"tab_providers" = "提供者";
+"tab_display" = "顯示";
+"tab_advanced" = "進階";
+"tab_about" = "關於";
+"tab_debug" = "除錯";
+"select_a_provider" = "選擇提供者";
+"cancel" = "取消";
+"last_fetch_failed" = "上次取得失敗";
+"usage_not_fetched_yet" = "尚未取得使用量";
+"managed_account_storage_unreadable" = "託管帳號儲存區無法讀取。即時帳號仍可存取，但託管新增、重新認證和移除操作已被停用，直到儲存區恢復。";
+"remove_codex_account_title" = "移除 Codex 帳號？";
+"remove" = "移除";
+"managed_login_already_running" = "託管 Codex 登入已在執行。請等待完成後再新增或重新認證其他帳號。";
+"managed_login_failed" = "託管 Codex 登入未完成。請先在終端確認 `codex --version` 可以執行。如果 macOS 封鎖了 `codex` 或將它移到垃圾桶，請移除舊的重複安裝，執行 `npm install -g --include=optional @openai/codex@latest`，然後重試。";
+"codex_login_output" = "codex login 輸出：";
+"managed_login_missing_email" = "Codex 登入已完成，但無法取得帳號電子郵件。請在確認帳號已完全登入後重試。";
+"login_success_notification_title" = "%@ 登入成功";
+"login_success_notification_body" = "你可以回到 App；認證已完成。";
+"workspace_selection_cancelled" = "CodexBar 發現多個工作區，但未選擇任何工作區。";
+"unsafe_managed_home" = "CodexBar 拒絕修改意外的託管主目錄路徑：%@";
+"menu_bar_metric_title" = "選單列指標";
+"menu_bar_metric_subtitle" = "選擇哪個時段驅動選單列百分比。";
+"menu_bar_metric_subtitle_deepseek" = "在選單列顯示 DeepSeek 餘額。";
+"menu_bar_metric_subtitle_moonshot" = "在選單列顯示 Moonshot / Kimi API 餘額。";
+"menu_bar_metric_subtitle_mistral" = "在選單列顯示 Mistral API 本月支出。";
+"menu_bar_metric_subtitle_kimik2" = "在選單列顯示 Kimi K2 API 金鑰額度。";
+"automatic" = "自動";
+"primary_api_key_limit" = "主要（API 金鑰限制）";
+"section_menu_bar" = "選單列";
+"merge_icons_title" = "合併圖示";
+"merge_icons_subtitle" = "使用單一選單列圖示並帶提供者切換器。";
+"switcher_shows_icons_title" = "切換器顯示圖示";
+"switcher_shows_icons_subtitle" = "在切換器中顯示提供者圖示（否則顯示每週進度線）。";
+"show_most_used_provider_title" = "顯示使用量最高的提供者";
+"show_most_used_provider_subtitle" = "選單列會自動顯示最接近速率限制的提供者。";
+"menu_bar_shows_percent_title" = "選單列顯示百分比";
+"menu_bar_shows_percent_subtitle" = "將小動物進度條替換為提供者品牌圖示和百分比。";
+"hide_critters_title" = "隱藏小動物";
+"hide_critters_subtitle" = "顯示不帶表情和裝飾的簡潔進度條。";
+"display_mode_title" = "顯示模式";
+"display_mode_subtitle" = "選擇選單列中顯示的內容（進度會比較實際與預期使用量）。";
+"section_menu_content" = "選單內容";
+"show_usage_as_used_title" = "以已用量顯示";
+"show_usage_as_used_subtitle" = "進度條會隨配額消耗而填滿（而不是顯示剩餘量）。";
+"show_quota_warning_markers_title" = "顯示配額提醒標記";
+"show_quota_warning_markers_subtitle" = "設定配額提醒後，在使用量條上繪製門檻刻度標記。";
+"weekly_progress_work_days_title" = "每週進度工作日標記";
+"weekly_progress_work_days_subtitle" = "設定用於每週用量條刻度與進度計算的工作日。";
+"show_reset_time_as_clock_title" = "以時鐘時間顯示重置時間";
+"show_reset_time_as_clock_subtitle" = "將重置時間顯示為絕對時鐘值，而不是倒數計時。";
+"show_provider_changelog_links_title" = "顯示提供者版本資訊連結";
+"show_provider_changelog_links_subtitle" = "在選單中為支援的 CLI 提供者新增發行說明連結。";
+"show_credits_extra_usage_title" = "顯示額度 + 額外使用量";
+"show_credits_extra_usage_subtitle" = "在選單中顯示 Codex 額度和 Claude 額外使用量部分。";
+"show_all_token_accounts_title" = "顯示所有 token 帳號";
+"show_all_token_accounts_subtitle" = "在選單中堆疊 token 帳號（否則顯示帳號切換欄）。";
+"multi_account_layout_title" = "多帳號版面配置";
+"multi_account_layout_subtitle" = "選擇分段帳號切換或堆疊帳號卡片。";
+"multi_account_layout_segmented" = "分段";
+"multi_account_layout_stacked" = "堆疊";
+"overview_tab_providers_title" = "概覽標籤提供者";
+"configure" = "設定…";
+"overview_enable_merge_icons_hint" = "啟用「合併圖示」以設定「概覽」標籤中的提供者。";
+"overview_no_providers_hint" = "「概覽」中沒有可用的已啟用提供者。";
+"overview_rows_follow_order" = "概覽列一律依提供者順序排列。";
+"overview_no_providers_selected" = "未選擇提供者";
+"section_keyboard_shortcut" = "快速鍵";
+"open_menu_shortcut_title" = "開啟選單";
+"open_menu_shortcut_subtitle" = "從任意位置觸發選單列選單。";
+"install_cli" = "安裝 CLI";
+"install_cli_subtitle" = "將 CodexBarCLI 作為 codexbar 符號連結到 /usr/local/bin 和 /opt/homebrew/bin。";
+"cli_not_found" = "在 App 套件中找不到 CodexBarCLI。";
+"no_writable_bin_dirs" = "找不到可寫的 bin 目錄。";
+"show_debug_settings_title" = "顯示除錯設定";
+"show_debug_settings_subtitle" = "在「除錯」標籤中顯示疑難排解工具。";
+"surprise_me_title" = "給我驚喜";
+"surprise_me_subtitle" = "讓選單列上的 Agent 多一點變化。";
+"weekly_limit_confetti_title" = "每週重置慶祝動畫";
+"weekly_limit_confetti_subtitle" = "每週使用量重置時播放全螢幕慶祝動畫。";
+"hide_personal_info_title" = "隱藏個人資訊";
+"hide_personal_info_subtitle" = "在選單列和選單介面中隱藏電子郵件地址。";
+"show_provider_storage_usage_title" = "顯示提供者儲存使用量";
+"show_provider_storage_usage_subtitle" = "在選單中顯示本機磁碟使用量。會在背景掃描已知的提供者自有路徑。";
+"section_keychain_access" = "鑰匙圈存取";
+"keychain_access_caption" = "停用所有鑰匙圈讀寫。如果 macOS 在你按下一律允許後仍持續要求存取「Chrome/Brave/Edge Safe Storage」，可使用此選項。啟用時無法匯入瀏覽器 Cookie；請在「提供者」中手動貼上 Cookie 標頭。透過 CLI 的 Claude/Codex OAuth 仍可使用。";
+"disable_keychain_access_title" = "停用鑰匙圈存取";
+"disable_keychain_access_subtitle" = "啟用時封鎖任何鑰匙圈存取。";
+"about_tagline" = "願你的 token 永不用完，隨時掌握 Agent 限制。";
+"link_github" = "GitHub";
+"link_website" = "網站";
+"link_twitter" = "Twitter";
+"link_email" = "電子郵件";
+"check_updates_auto" = "自動檢查更新";
+"update_channel" = "更新頻道";
+"check_for_updates" = "檢查更新…";
+"updates_unavailable" = "此建置無法使用更新功能。";
+"copyright" = "© 2026 Peter Steinberger。MIT 許可證。";
+"section_logging" = "記錄";
+"enable_file_logging" = "啟用檔案記錄";
+"enable_file_logging_subtitle" = "將記錄寫入 %@ 以進行除錯。";
+"verbosity_title" = "詳細程度";
+"verbosity_subtitle" = "控制記錄詳細程度。";
+"open_log_file" = "開啟記錄檔";
+"force_animation_next_refresh" = "下次重新整理時強制動畫";
+"force_animation_next_refresh_subtitle" = "下次重新整理後暫時顯示載入動畫。";
+"section_loading_animations" = "載入動畫";
+"loading_animations_caption" = "選擇一個模式並在選單列中重播。「隨機」保持現有行為。";
+"animation_random_default" = "隨機（預設）";
+"replay_selected_animation" = "重播選取的動畫";
+"blink_now" = "立即閃爍";
+"section_probe_logs" = "探測記錄";
+"probe_logs_caption" = "取得最新的探測輸出以進行除錯；複製會保留完整文字。";
+"fetch_log" = "取得記錄";
+"copy" = "複製";
+"save_to_file" = "儲存到檔案";
+"load_parse_dump" = "載入解析 dump";
+"rerun_provider_autodetect" = "重新執行提供者自動偵測";
+"loading" = "載入中…";
+"no_log_yet_fetch" = "尚無記錄。取得後載入。";
+"section_fetch_strategy" = "取得策略嘗試";
+"fetch_strategy_caption" = "提供者上次取得流程中的決策和錯誤。";
+"section_openai_cookies" = "OpenAI Cookie";
+"openai_cookies_caption" = "上次 OpenAI Cookie 嘗試中的 Cookie 匯入和 WebKit 抓取記錄。";
+"no_log_yet" = "尚無記錄。請在「提供者」→「Codex」中更新 OpenAI Cookie 以執行匯入。";
+"section_caches" = "快取";
+"caches_caption" = "清除快取的費用掃描結果或瀏覽器 Cookie 快取。";
+"clear_cookie_cache" = "清除 Cookie 快取";
+"clear_cost_cache" = "清除費用快取";
+"section_notifications" = "通知";
+"notifications_caption" = "觸發 5 小時工作階段時段的測試通知（用完/恢復）。";
+"post_depleted" = "傳送用完通知";
+"post_restored" = "傳送恢復通知";
+"section_cli_sessions" = "CLI 工作階段";
+"cli_sessions_caption" = "探測後保持 Codex/Claude CLI 工作階段存活。預設在擷取資料後結束。";
+"keep_cli_sessions_alive" = "保持 CLI 工作階段存活";
+"keep_cli_sessions_alive_subtitle" = "探測之間跳過關閉流程（僅限除錯）。";
+"reset_cli_sessions" = "重置 CLI 工作階段";
+"section_error_simulation" = "錯誤模擬";
+"error_simulation_caption" = "將模擬錯誤訊息注入選單卡片以進行版面配置測試。";
+"set_menu_error" = "設定選單錯誤";
+"clear_menu_error" = "清除選單錯誤";
+"set_cost_error" = "設定費用錯誤";
+"clear_cost_error" = "清除費用錯誤";
+"section_cli_paths" = "CLI 路徑";
+"cli_paths_caption" = "解析到的 Codex 二進位檔案和 PATH 層；啟動時擷取登入 PATH（短逾時）。";
+"codex_binary" = "Codex 二進位檔案";
+"claude_binary" = "Claude 二進位檔案";
+"effective_path" = "有效 PATH";
+"unavailable" = "無法使用";
+"login_shell_path" = "登入 shell PATH（啟動時擷取）";
+"cleared" = "已清除。";
+"no_fetch_attempts" = "尚無取得嘗試。";
+"metric_pref_automatic" = "自動";
+"metric_pref_primary" = "主要";
+"metric_pref_secondary" = "次要";
+"metric_pref_tertiary" = "第三";
+"metric_pref_extra_usage" = "額外使用量";
+"metric_pref_average" = "平均";
+"metric_mistral_payg" = "Pay-as-you-go";
+"metric_mistral_monthly_plan" = "Monthly Plan";
+"display_mode_percent" = "百分比";
+"display_mode_pace" = "進度";
+"display_mode_both" = "兩者";
+"display_mode_reset_time" = "重置時間";
+"display_mode_percent_desc" = "顯示剩餘/已使用百分比（例如 45%）";
+"display_mode_pace_desc" = "顯示進度指示器（例如 +5%）";
+"display_mode_both_desc" = "同時顯示百分比和進度（例如 45% · +5%）";
+"display_mode_reset_time_desc" = "顯示所選指標的重置時間（例如 ↻ 3:56 PM）";
+"status_operational" = "運作正常";
+"status_partial_outage" = "部分服務中斷";
+"status_major_outage" = "重大服務中斷";
+"status_critical_issue" = "嚴重問題";
+"status_maintenance" = "維護中";
+"status_unknown" = "狀態未知";
+"refresh_manual" = "手動";
+"refresh_1min" = "1 分鐘";
+"refresh_2min" = "2 分鐘";
+"refresh_5min" = "5 分鐘";
+"refresh_15min" = "15 分鐘";
+"refresh_30min" = "30 分鐘";
+"not_found" = "找不到";
+"CodexBar can't show its menu bar icon" = "CodexBar 無法顯示選單列圖示";
+"Dismiss" = "關閉";
+"Open Menu Bar Settings" = "開啟選單列設定";
+"macOS Tahoe can block menu bar apps in System Settings → Menu Bar → Allow in the Menu Bar. CodexBar is running, but macOS may be hiding its icon. Open Menu Bar settings and turn CodexBar on." = "macOS Tahoe 可能會在「系統設定」→「選單列」→「允許顯示在選單列」中封鎖選單列 App。CodexBar 正在執行，但 macOS 可能隱藏了它的圖示。請開啟選單列設定並啟用 CodexBar。";
+"cost_header_estimated" = "費用（估算）";
+"cost_estimate_hint" = "根據本機記錄估算 · 可能與帳單不同";
+"copilot_device_code" = "裝置代碼已複製到剪貼簿：%1$@\n\n請到以下網址驗證：%2$@";
+"copilot_waiting_text" = "請在瀏覽器中完成登入。\n登入完成後，此視窗會自動關閉。";
+"vertex_ai_login_instructions" = "要追蹤 Vertex AI 使用量，請透過 Google Cloud 進行認證。\n\n1. 開啟終端\n2. 執行：gcloud auth application-default login\n3. 依照瀏覽器提示登入\n4. 設定你的專案：gcloud config set project PROJECT_ID\n\n要現在開啟終端嗎？";
+
+/* Popup panels */
+"No usage configured." = "尚未設定使用量。";
+"Quota" = "配額";
+"tokens" = "token";
+"requests" = "請求";
+"Latest" = "最新";
+"Monthly" = "每月";
+"Sonnet" = "Sonnet";
+"Overages" = "超額";
+"Activity" = "活動";
+"Copied" = "已複製";
+"Copy error" = "複製錯誤";
+"Copy path" = "複製路徑";
+"Extra usage spent" = "額外使用量支出";
+"Credits remaining" = "剩餘額度";
+"Using CLI fallback" = "使用 CLI 備援";
+"Balance updates in near-real time (up to 5 min lag)" = "餘額接近即時更新（最多延遲 5 分鐘）";
+"Daily billing data finalizes at 07:00 UTC" = "每日帳單資料會在 UTC 07:00 完成結算";
+"%@ of %@ credits left" = "剩餘 %@ / %@ 點額度";
+"%@ of %@ bonus credits left" = "剩餘 %@ / %@ 點獎勵額度";
+"%@ / %@ (%@ remaining)" = "%@ / %@（剩餘 %@）";
+"%@/%@ left" = "剩餘 %@ / %@";
+"Gemini Flash" = "Gemini Flash";
+"Regenerates %@" = "%@後恢復";
+"used after next regen" = "下次恢復後已使用";
+"after next regen" = "下次恢復後";
+"Near full" = "接近全滿";
+"Full in ~1 regen" = "約 1 次恢復後全滿";
+"Full in ~%.0f regens" = "約 %.0f 次恢復後全滿";
+"Overage usage" = "超額使用量";
+"Overage cost" = "超額費用";
+"credits" = "額度";
+"Zen balance" = "Zen 餘額";
+"API spend" = "API 支出";
+"Extra usage" = "額外使用量";
+"Quota usage" = "配額使用量";
+"Your spend" = "您的支出";
+"%.0f%% used" = "已使用 %.0f%%";
+"Usage history (today)" = "使用量記錄（今天）";
+"Usage history (%d days)" = "使用量記錄（%d 天）";
+"%d percent remaining" = "剩餘 %d%%";
+"Unknown" = "未知";
+"stale data" = "資料過舊";
+"No credits history data available." = "尚無可用的額度記錄資料。";
+"Credits history chart" = "額度記錄圖表";
+"%d days of credits data" = "%d 天額度資料";
+"Usage breakdown chart" = "使用量明細圖表";
+"%d days of usage data across %d services" = "%d 天使用量資料，涵蓋 %d 個服務";
+"Cost history chart" = "費用記錄圖表";
+"%d days of cost data" = "%d 天費用資料";
+"Plan utilization chart" = "方案使用率圖表";
+"%d utilization samples" = "%d 筆使用率樣本";
+"Hourly Usage" = "每小時使用量";
+"Usage remaining" = "剩餘使用量";
+"Usage used" = "已使用使用量";
+"API key verified. Ollama does not expose Cloud quota limits through the API." = "API 金鑰已驗證。Ollama 不會透過 API 暴露 Cloud 配額限制。";
+"Last 30 days: %@ tokens" = "近 30 天：%@ token";
+"7d spend" = "7 天支出";
+"30d spend" = "30 天支出";
+"Cache read" = "快取讀取";
+"Claude Admin API 30 day spend trend" = "Claude Admin API 30 天支出趨勢";
+"OpenRouter API key spend trend" = "OpenRouter API 金鑰支出趨勢";
+"z.ai hourly token trend" = "z.ai 每小時 token 趨勢";
+"MiniMax 30 day token usage trend" = "MiniMax 30 天 token 使用量趨勢";
+"Today cash" = "今日現金";
+"DeepSeek 30 day token usage trend" = "DeepSeek 30 天 token 使用量趨勢";
+"cache-hit input" = "快取命中輸入";
+"cache-miss input" = "快取未命中輸入";
+"output" = "輸出";
+"Requests" = "請求";
+"Reported by OpenAI Admin API organization usage." = "由 OpenAI Admin API 組織使用量回報。";
+"Reported by Mistral billing usage." = "由 Mistral 帳單使用量回報。";
+"Today" = "今天";
+"Today tokens" = "今日 token";
+"30d cost" = "近 30 天費用";
+"30d tokens" = "近 30 天 token";
+"Latest tokens" = "最新 token";
+"Top model" = "主要模型";
+"Storage" = "儲存空間";
+"Add Account..." = "新增帳號…";
+"Usage Dashboard" = "使用量儀表板";
+"Status Page" = "狀態頁";
+"Settings..." = "設定…";
+"About CodexBar" = "關於 CodexBar";
+"Quit" = "結束";
+"Last %d day" = "近 %d 天";
+"Last %d days" = "近 %d 天";
+"%@ tokens" = "%@ token";
+"Latest billing day" = "最新帳單日";
+"Latest billing day (%@)" = "最新帳單日（%@）";
+"This week" = "本週";
+"Week" = "週";
+"Month" = "月";
+"Models" = "模型數";
+"24h tokens" = "24 小時 token";
+"Latest hour" = "最新小時";
+"Peak hour" = "尖峰小時";
+"Top method" = "主要方法";
+"30d cash" = "30 天現金";
+"30d billing history from MiniMax web session" = "來自 MiniMax 網頁工作階段的 30 天帳單記錄";
+"AWS Cost Explorer billing can lag." = "AWS Cost Explorer 帳單資料可能延遲。";
+"Rate limit: %d / %@" = "速率限制: %d / %@";
+"Key remaining" = "金鑰剩餘額度";
+"No limit set for the API key" = "此 API 金鑰未設定限制";
+"API key limit unavailable right now" = "目前無法取得 API 金鑰限制";
+"This month: %@ tokens" = "本月：%@ token";
+"Switch Account..." = "切換帳號…";
+"Update ready, restart now?" = "更新已就緒，要立即重新啟動嗎？";
+"Daily" = "每日";
+"Hourly Tokens" = "每小時 token";
+"No data" = "無資料";
+"No usage breakdown data available." = "尚無可用的使用量明細資料。";
+"Today: %@ · %@ tokens" = "今天：%@ · %@ token";
+"Today: %@" = "今天：%@";
+"Today: %@ tokens" = "今天：%@ token";
+"Last 30 days: %@ · %@ tokens" = "近 30 天：%@ · %@ token";
+"Last 30 days: %@" = "近 30 天：%@";
+"Est. total (30d): %@" = "估計總計（30 天）：%@";
+"Est. total (%@): %@" = "估計總計（%@）：%@";
+"Hover a bar for details" = "停留在長條上查看詳細資料";
+"%@: %@ · %@ tokens" = "%@：%@ · %@ token";
+"No providers selected for Overview." = "概覽尚未選擇提供者。";
+"No overview data available." = "概覽尚無可用資料。";
+
+/* Additional provider settings and alerts */
+"%@ is waiting for permission" = "%@ 正在等待權限";
+"%@ requests" = "%@ 個請求";
+"%@: %@ credits" = "%@：%@ 額度";
+"30d requests" = "近 30 天請求";
+"4 days" = "4 天";
+"5 days" = "5 天";
+"7 days" = "7 天";
+"API key verifies Ollama Cloud access; cookies still expose quota limits." = "API 金鑰會驗證 Ollama Cloud 存取；Cookie 仍會提供配額限制。";
+"AWS access key ID. Can also be set with AWS_ACCESS_KEY_ID." = "AWS 存取金鑰 ID。也可以用 AWS_ACCESS_KEY_ID 設定。";
+"AWS region. Can also be set with AWS_REGION." = "AWS 區域。也可以用 AWS_REGION 設定。";
+"AWS secret access key. Can also be set with AWS_SECRET_ACCESS_KEY." = "AWS 秘密存取金鑰。也可以用 AWS_SECRET_ACCESS_KEY 設定。";
+"Access key ID" = "存取金鑰 ID";
+"Add Account" = "新增帳號";
+"Adding Account…" = "正在新增帳號…";
+"Antigravity login failed" = "Antigravity 登入失敗";
+"Antigravity login timed out" = "Antigravity 登入逾時";
+"Auth source" = "認證來源";
+"Automatic imports browser cookies from Xiaomi MiMo." = "自動匯入 Xiaomi MiMo 的瀏覽器 Cookie。";
+"Automatic imports Windsurf session data from Chromium browser localStorage." = "自動從 Chromium 瀏覽器 localStorage 匯入 Windsurf 工作階段資料。";
+"Automatic imports browser cookies from Bailian." = "自動匯入 Bailian 的瀏覽器 Cookie。";
+"Automatically imports browser cookies." = "自動匯入瀏覽器 Cookie。";
+"Automatically imports browser session cookies." = "自動匯入瀏覽器工作階段 Cookie。";
+"Azure OpenAI deployment name. AZURE_OPENAI_DEPLOYMENT_NAME is also supported." = "Azure OpenAI 部署名稱。也支援 AZURE_OPENAI_DEPLOYMENT_NAME。";
+"Azure OpenAI key" = "Azure OpenAI 金鑰";
+"Azure OpenAI resource endpoint. AZURE_OPENAI_ENDPOINT is also supported." = "Azure OpenAI 資源端點。也支援 AZURE_OPENAI_ENDPOINT。";
+"Base URL" = "Base URL";
+"Base URL for the LLM-API-Key-Proxy instance." = "LLM-API-Key-Proxy 實例的 Base URL。";
+"Browser cookies" = "瀏覽器 Cookie";
+"Cap end" = "上限終點";
+"Cap start" = "上限起點";
+"Capacity End" = "容量終點";
+"Capacity Start" = "容量起點";
+"Changelog" = "變更記錄";
+"Choose the Moonshot/Kimi API host for international or China mainland accounts." = "選擇國際或中國大陸帳號使用的 Moonshot/Kimi API 主機。";
+"CodexBar can't replace a system account that is signed in with an API key only setup." = "CodexBar 無法取代僅使用 API 金鑰登入設定的系統帳號。";
+"CodexBar could not find saved auth for that account. Re-authenticate it and try again." = "CodexBar 找不到該帳號已儲存的認證。請重新認證後再試。";
+"CodexBar could not read managed account storage. Recover the store before adding another account." = "CodexBar 無法讀取受管理帳號儲存區。請先修復儲存區，再新增其他帳號。";
+"CodexBar could not read saved auth for that account. Re-authenticate it and try again." = "CodexBar 無法讀取該帳號已儲存的認證。請重新認證後再試。";
+"CodexBar could not read the current system account on this Mac." = "CodexBar 無法讀取此 Mac 上目前的系統帳號。";
+"CodexBar could not replace the live Codex auth on this Mac." = "CodexBar 無法取代此 Mac 上的目前 Codex 認證。";
+"CodexBar could not safely preserve the current system account before switching." = "CodexBar 無法在切換前安全保留目前的系統帳號。";
+"CodexBar could not save the current system account before switching." = "CodexBar 無法在切換前儲存目前的系統帳號。";
+"CodexBar could not update managed account storage." = "CodexBar 無法更新受管理帳號儲存區。";
+"CodexBar found another managed account that already uses the current system account. Resolve the duplicate account before switching." = "CodexBar 發現另一個受管理帳號已使用目前的系統帳號。請先解決重複帳號，再進行切換。";
+"CodexBar will ask macOS Keychain for “%@” so it can decrypt browser cookies and authenticate your account. Click OK to continue." = "CodexBar 將向 macOS 鑰匙圈要求「%@」，以解密瀏覽器 Cookie 並認證你的帳號。按一下「確定」繼續。";
+"CodexBar will ask macOS Keychain for the Claude Code OAuth token so it can fetch your Claude usage. Click OK to continue." = "CodexBar 將向 macOS 鑰匙圈要求 Claude Code OAuth token，以取得你的 Claude 使用量。按一下「確定」繼續。";
+"CodexBar will ask macOS Keychain for your Amp cookie header so it can fetch usage. Click OK to continue." = "CodexBar 將向 macOS 鑰匙圈要求你的 Amp Cookie 標頭，以取得使用量。按一下「確定」繼續。";
+"CodexBar will ask macOS Keychain for your Augment cookie header so it can fetch usage. Click OK to continue." = "CodexBar 將向 macOS 鑰匙圈要求你的 Augment Cookie 標頭，以取得使用量。按一下「確定」繼續。";
+"CodexBar will ask macOS Keychain for your Claude cookie header so it can fetch Claude web usage. Click OK to continue." = "CodexBar 將向 macOS 鑰匙圈要求你的 Claude Cookie 標頭，以取得 Claude 網頁使用量。按一下「確定」繼續。";
+"CodexBar will ask macOS Keychain for your Cursor cookie header so it can fetch usage. Click OK to continue." = "CodexBar 將向 macOS 鑰匙圈要求你的 Cursor Cookie 標頭，以取得使用量。按一下「確定」繼續。";
+"CodexBar will ask macOS Keychain for your Factory cookie header so it can fetch usage. Click OK to continue." = "CodexBar 將向 macOS 鑰匙圈要求你的 Factory Cookie 標頭，以取得使用量。按一下「確定」繼續。";
+"CodexBar will ask macOS Keychain for your GitHub Copilot token so it can fetch usage. Click OK to continue." = "CodexBar 將向 macOS 鑰匙圈要求你的 GitHub Copilot token，以取得使用量。按一下「確定」繼續。";
+"CodexBar will ask macOS Keychain for your Kimi K2 API key so it can fetch usage. Click OK to continue." = "CodexBar 將向 macOS 鑰匙圈要求你的 Kimi K2 API 金鑰，以取得使用量。按一下「確定」繼續。";
+"CodexBar will ask macOS Keychain for your Kimi auth token so it can fetch usage. Click OK to continue." = "CodexBar 將向 macOS 鑰匙圈要求你的 Kimi 認證 token，以取得使用量。按一下「確定」繼續。";
+"CodexBar will ask macOS Keychain for your MiniMax API token so it can fetch usage. Click OK to continue." = "CodexBar 將向 macOS 鑰匙圈要求你的 MiniMax API token，以取得使用量。按一下「確定」繼續。";
+"CodexBar will ask macOS Keychain for your MiniMax cookie header so it can fetch usage. Click OK to continue." = "CodexBar 將向 macOS 鑰匙圈要求你的 MiniMax Cookie 標頭，以取得使用量。按一下「確定」繼續。";
+"CodexBar will ask macOS Keychain for your OpenAI cookie header so it can fetch Codex dashboard extras. Click OK to continue." = "CodexBar 將向 macOS 鑰匙圈要求你的 OpenAI Cookie 標頭，以取得 Codex 儀表板額外資料。按一下「確定」繼續。";
+"CodexBar will ask macOS Keychain for your OpenCode cookie header so it can fetch usage. Click OK to continue." = "CodexBar 將向 macOS 鑰匙圈要求你的 OpenCode Cookie 標頭，以取得使用量。按一下「確定」繼續。";
+"CodexBar will ask macOS Keychain for your Synthetic API key so it can fetch usage. Click OK to continue." = "CodexBar 將向 macOS 鑰匙圈要求你的 Synthetic API 金鑰，以取得使用量。按一下「確定」繼續。";
+"CodexBar will ask macOS Keychain for your z.ai API token so it can fetch usage. Click OK to continue." = "CodexBar 將向 macOS 鑰匙圈要求你的 z.ai API token，以取得使用量。按一下「確定」繼續。";
+"Could not open Cursor login in your browser." = "無法在瀏覽器中開啟 Cursor 登入。";
+"Could not open browser for Antigravity" = "無法為 Antigravity 開啟瀏覽器";
+"Credits used" = "已用額度";
+"Day" = "日期";
+"Deployment" = "部署";
+"Drag to reorder" = "拖曳以重新排序";
+"Sort providers alphabetically" = "依字母順序排列供應商";
+"Sort providers alphabetically (enabled first)" = "依字母順序排列供應商（已啟用的優先）";
+"Sorted alphabetically (enabled first) — click to use your custom order" = "已依字母順序排列（已啟用的優先）— 按一下使用自訂順序";
+"Endpoint" = "端點";
+"Enterprise host" = "Enterprise 主機";
+"Extra usage balance: %@" = "額外使用量餘額：%@";
+"Keychain Access Required" = "需要鑰匙圈存取權";
+"Kiro menu bar value" = "Kiro 選單列數值";
+"Label" = "標籤";
+"No organizations loaded. Click Refresh after setting your API key." = "尚未載入組織。設定 API 金鑰後按一下「重新整理」。";
+"No output captured." = "未擷取到輸出。";
+"No system account" = "沒有系統帳號";
+"Oasis-Token" = "Oasis-Token";
+"Open Augment (Log Out & Back In)" = "開啟 Augment（登出後重新登入）";
+"Open Codebuff Dashboard" = "開啟 Codebuff 儀表板";
+"Open Command Code Settings" = "開啟 Command Code 設定";
+"Open Crof dashboard" = "開啟 Crof 儀表板";
+"Open Manus" = "開啟 Manus";
+"Open MiMo Balance" = "開啟 MiMo 餘額";
+"Open Moonshot Console" = "開啟 Moonshot 主控台";
+"Open Ollama API Keys" = "開啟 Ollama API 金鑰";
+"Open StepFun Platform" = "開啟 StepFun 平台";
+"Open T3 Chat Settings" = "開啟 T3 Chat 設定";
+"Open Volcengine Ark Console" = "開啟 Volcengine Ark 主控台";
+"Open legacy provider docs" = "開啟舊版提供者文件";
+"Open projects" = "開啟專案";
+"Open this URL manually to continue login:\n\n%@" = "手動開啟此 URL 以繼續登入：\n\n%@";
+"Optional organization ID for accounts linked to multiple Anthropic organizations." = "適用於連結多個 Anthropic 組織的帳號，可選填組織 ID。";
+"Optional. Applies to the configured Admin API key; selected token accounts do not inherit OPENAI_PROJECT_ID." = "選填。套用到已設定的 Admin API 金鑰；選取的 token 帳號不會繼承 OPENAI_PROJECT_ID。";
+"Optional. Enter your GitHub Enterprise host, for example octocorp.ghe.com. Leave blank for github.com." = "選填。輸入你的 GitHub Enterprise 主機，例如 octocorp.ghe.com。留空則使用 github.com。";
+"Optional. Leave blank to discover and aggregate projects visible to the API key." = "選填。留空會探索並彙總 API 金鑰可見的專案。";
+"Org ID (optional)" = "組織 ID（選填）";
+"Organizations" = "組織";
+"Password" = "密碼";
+"%@ authentication is disabled." = "%@ 認證已停用。";
+"%@ cookies are disabled." = "%@ Cookie 已停用。";
+"%@ web API access is disabled." = "%@ Web API 存取已停用。";
+"Disable %@ dashboard cookie usage." = "停用 %@ 儀表板 Cookie 用法。";
+"Keychain access is disabled in Advanced, so browser cookie import is unavailable." = "進階設定中已停用鑰匙圈存取，因此無法匯入瀏覽器 Cookie。";
+"Manually paste an %@ from a browser session." = "從瀏覽器工作階段中手動貼上 %@。";
+"Paste a Cookie header captured from %@." = "貼上從 %@ 擷取的 Cookie 標頭。";
+"Paste a Cookie header from %@." = "貼上來自 %@ 的 Cookie 標頭。";
+"Paste a Cookie header or cURL capture from %@." = "貼上來自 %@ 的 Cookie 標頭或 cURL 擷取內容。";
+"Paste a Cookie header or full cURL capture from %@." = "貼上來自 %@ 的 Cookie 標頭或完整 cURL 擷取內容。";
+"Paste a Cookie or Authorization header from %@." = "貼上來自 %@ 的 Cookie 或 Authorization 標頭。";
+"Paste a full cookie header or the %@ value." = "貼上完整 Cookie 標頭或 %@ 值。";
+"Paste a Cookie header or full cURL capture from T3 Chat settings." = "貼上 T3 Chat 設定中的 Cookie 標頭或完整 cURL 擷取內容。";
+"Paste the Cookie header from a request to admin.mistral.ai. Must contain an ory_session_* cookie." = "貼上發往 admin.mistral.ai 請求中的 Cookie 標頭。必須包含 ory_session_* Cookie。";
+"Paste the Oasis-Token from a logged-in browser session on platform.stepfun.com." = "貼上 platform.stepfun.com 已登入瀏覽器工作階段中的 Oasis-Token。";
+"Paste the %@ JSON bundle from %@." = "貼上來自 %2$@ 的 %1$@ JSON 組合。";
+"Paste the %@ value or a full Cookie header." = "貼上 %@ 值或完整 Cookie 標頭。";
+"Personal account" = "個人帳號";
+"Project ID" = "專案 ID";
+"Re-auth" = "重新認證";
+"Re-login at claude.ai" = "重新登入 claude.ai";
+"Re-authenticating…" = "正在重新認證…";
+"Refresh Session" = "重新整理工作階段";
+"Refresh organizations" = "重新整理組織";
+"Region" = "區域";
+"Reload" = "重新載入";
+"Reorder" = "重新排序";
+"Secret access key" = "秘密存取金鑰";
+"Series" = "序列";
+"Service" = "服務";
+"Show or hide Kiro credits, percent, or both next to the menu bar icon." = "在選單列圖示旁顯示或隱藏 Kiro 額度、百分比，或兩者都顯示。";
+"Show usage for organizations you belong to. Personal account is always shown." = "顯示你所屬組織的使用量。個人帳號一律顯示。";
+"Sign in to cursor.com in your browser, then refresh Cursor in CodexBar." = "請在瀏覽器中登入 cursor.com，然後在 CodexBar 重新整理 Cursor。";
+"Simulated error text" = "模擬錯誤文字";
+"StepFun platform account (phone number or email)." = "StepFun 平台帳號（電話號碼或電子郵件）。";
+"Stored in ~/.codexbar/config.json." = "儲存在 ~/.codexbar/config.json 中。";
+"Stored in ~/.codexbar/config.json. AZURE_OPENAI_API_KEY is also supported." = "儲存在 ~/.codexbar/config.json 中。也支援 AZURE_OPENAI_API_KEY。";
+"Stored in ~/.codexbar/config.json. For the official Kimi API, use Moonshot / Kimi API." = "儲存在 ~/.codexbar/config.json 中。官方 Kimi API 請使用 Moonshot / Kimi API。";
+"Stored in ~/.codexbar/config.json. Get your API key from the Volcengine Ark console." = "儲存在 ~/.codexbar/config.json 中。請從 Volcengine Ark 主控台取得 API 金鑰。";
+"Stored in ~/.codexbar/config.json. Get your key from Ollama settings." = "儲存在 ~/.codexbar/config.json 中。請從 Ollama 設定取得金鑰。";
+"Stored in ~/.codexbar/config.json. Get your key from console.deepgram.com." = "儲存在 ~/.codexbar/config.json 中。請從 console.deepgram.com 取得金鑰。";
+"Stored in ~/.codexbar/config.json. Get your key from elevenlabs.io/app/settings/api-keys." = "儲存在 ~/.codexbar/config.json 中。請從 elevenlabs.io/app/settings/api-keys 取得金鑰。";
+"Stored in ~/.codexbar/config.json. Get your key from openrouter.ai/settings/keys and set a key spending limit there to enable API key quota tracking." = "儲存在 ~/.codexbar/config.json 中。請從 openrouter.ai/settings/keys 取得金鑰，並在該處設定金鑰支出上限以啟用 API 金鑰配額追蹤。";
+"Stored in ~/.codexbar/config.json. In Warp, open Settings > Platform > API Keys, then create one." = "儲存在 ~/.codexbar/config.json 中。在 Warp 中開啟 Settings > Platform > API Keys，然後建立金鑰。";
+"Stored in ~/.codexbar/config.json. Metrics require Groq Enterprise Prometheus access." = "儲存在 ~/.codexbar/config.json 中。指標需要 Groq Enterprise Prometheus 存取權。";
+"Stored in ~/.codexbar/config.json. OPENAI_ADMIN_KEY is preferred; OPENAI_API_KEY still works." = "儲存在 ~/.codexbar/config.json 中。優先使用 OPENAI_ADMIN_KEY；OPENAI_API_KEY 仍可使用。";
+"Stored in ~/.codexbar/config.json. Requires an Anthropic Admin API key." = "儲存在 ~/.codexbar/config.json 中。需要 Anthropic Admin API 金鑰。";
+"Stored in ~/.codexbar/config.json. Used for /v1/quota-stats." = "儲存在 ~/.codexbar/config.json 中。用於 /v1/quota-stats。";
+"Stored in ~/.codexbar/config.json. You can also provide CODEBUFF_API_KEY or let CodexBar read ~/.config/manicode/credentials.json (created by `codebuff login`)." = "儲存在 ~/.codexbar/config.json 中。你也可以提供 CODEBUFF_API_KEY，或讓 CodexBar 讀取 `codebuff login` 建立的 ~/.config/manicode/credentials.json。";
+"Stored in ~/.codexbar/config.json. You can also provide CROF_API_KEY." = "儲存在 ~/.codexbar/config.json 中。你也可以提供 CROF_API_KEY。";
+"Stored in ~/.codexbar/config.json. You can also provide KILO_API_KEY or ~/.local/share/kilo/auth.json (kilo.access)." = "儲存在 ~/.codexbar/config.json 中。你也可以提供 KILO_API_KEY 或 ~/.local/share/kilo/auth.json（kilo.access）。";
+"T3 Chat cookie" = "T3 Chat Cookie";
+"That account is no longer available in CodexBar. Refresh the account list and try again." = "該帳號已無法在 CodexBar 中使用。請重新整理帳號列表後再試。";
+"The browser login did not complete in time. Try Antigravity login again." = "瀏覽器登入未在時限內完成。請再次嘗試 Antigravity 登入。";
+"Timed out waiting for Cursor login. %@" = "等待 Cursor 登入逾時。%@";
+"Timed out waiting for Cursor login. %@ Last error: %@" = "等待 Cursor 登入逾時。%@ 最後錯誤：%@";
+"Today requests" = "今日請求";
+"Total (30d): %@ credits" = "總計（30 天）：%@ 額度";
+"Username" = "使用者名稱";
+"Uses username + password to login and obtain an Oasis-Token automatically." = "使用使用者名稱與密碼登入，並自動取得 Oasis-Token。";
+"Uses username + password to login and obtain an %@ automatically." = "使用使用者名稱與密碼登入，並自動取得 %@。";
+"Utilization End" = "使用率終點";
+"Utilization Start" = "使用率起點";
+"Verbosity" = "詳細程度";
+"Windsurf session JSON bundle" = "Windsurf 工作階段 JSON 組合";
+"Workspace ID" = "工作區 ID";
+"Your StepFun platform password. Used to login and obtain a session token." = "你的 StepFun 平台密碼。用於登入並取得工作階段 token。";
+"claude /login exited with status %d." = "claude /login 以狀態 %d 結束。";
+"codex login exited with status %d." = "codex login 以狀態 %d 結束。";
+"Cookie: …\n\nor paste a cURL capture from the Abacus AI dashboard" = "Cookie: …\n\n或貼上 Abacus AI 儀表板的 cURL 擷取內容";
+"Cookie: …\n\nor paste the __Secure-next-auth.session-token value" = "Cookie: …\n\n或貼上 __Secure-next-auth.session-token 值";
+"Cookie: …\n\nor paste the kimi-auth token value" = "Cookie: …\n\n或貼上 kimi-auth token 值";
+"session_id=...\n\nor paste just the session_id value" = "session_id=...\n\n或只貼上 session_id 值";
+"Clear" = "清除";
+"No matching providers" = "沒有相符的提供者";
+"Search providers" = "搜尋提供者";
+
+"language_vietnamese" = "越南語";
+"reset_tomorrow_format" = "明天 %@";
+
+"Request quota: %@ / %@" = "請求額度：%@ / %@";
+"language_turkish" = "Türkçe";
+"language_indonesian" = "印尼語";
+"language_arabic" = "العربية";
+"language_persian" = "فارسی";
+"language_thai" = "ไทย";
+"Limit Reset Credits" = "限額重設額度";
+"1 manual reset available" = "可使用 1 次手動重設";
+"%d manual resets available" = "可使用 %d 次手動重設";
+"Next expires %@" = "下一個將於 %@ 到期";
+"Other (%d items)" = "其他（%d 個項目）";
+"Expand" = "展開";
+"Collapse" = "收合";
+"byte_unit_byte" = "位元組";
+"byte_unit_bytes" = "位元組";
+"byte_unit_kilobyte" = "千位元組";
+"byte_unit_kilobytes" = "千位元組";
+"byte_unit_megabyte" = "百萬位元組";
+"byte_unit_megabytes" = "百萬位元組";
+"byte_unit_gigabyte" = "十億位元組";
+"byte_unit_gigabytes" = "十億位元組";
diff --git a/Sources/CodexBar/ScreenConfettiOverlayController.swift b/Sources/CodexBar/ScreenConfettiOverlayController.swift
new file mode 100644
index 0000000000..acacceb5e7
--- /dev/null
+++ b/Sources/CodexBar/ScreenConfettiOverlayController.swift
@@ -0,0 +1,290 @@
+import AppKit
+import CodexBarCore
+import SwiftUI
+import Vortex
+
+@MainActor
+final class ScreenConfettiOverlayController {
+    private static let overlayLifetime: TimeInterval = 5
+
+    private let logger = CodexBarLog.logger(LogCategories.confetti)
+    private var windows: [NSWindow] = []
+    private var dismissalTask: Task<Void, Never>?
+
+    func play(originInScreen origin: CGPoint?) {
+        guard self.windows.isEmpty else {
+            self.logger.debug("Ignoring confetti trigger while overlay is already active")
+            return
+        }
+
+        let screens = NSScreen.screens
+        guard !screens.isEmpty else {
+            self.logger.error("Cannot present confetti overlay because no screens were found")
+            return
+        }
+
+        let palette = Self.randomPalette()
+        self.windows = screens.map { screen in
+            let frame = screen.frame
+            let localOrigin = Self.localOrigin(in: frame, from: origin)
+            let contentView = ScreenConfettiOverlayView(origin: localOrigin, colors: palette)
+                .allowsHitTesting(false)
+            let hostingView = NSHostingView(rootView: contentView)
+            hostingView.wantsLayer = true
+            hostingView.layer?.backgroundColor = NSColor.clear.cgColor
+
+            let window = ClickThroughOverlayPanel(
+                contentRect: frame,
+                styleMask: [.borderless, .nonactivatingPanel],
+                backing: .buffered,
+                defer: false,
+                screen: screen)
+            window.contentView = hostingView
+            window.level = .statusBar
+            window.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary, .ignoresCycle, .stationary]
+            window.backgroundColor = .clear
+            window.isOpaque = false
+            window.hasShadow = false
+            window.ignoresMouseEvents = true
+            window.acceptsMouseMovedEvents = false
+            window.isMovable = false
+            window.isReleasedWhenClosed = false
+            window.canHide = false
+            window.hidesOnDeactivate = false
+            window.becomesKeyOnlyIfNeeded = false
+            window.isExcludedFromWindowsMenu = true
+            window.setFrame(frame, display: false)
+            return window
+        }
+
+        self.logger.info(
+            "Presenting confetti overlay",
+            metadata: [
+                "screenCount": "\(self.windows.count)",
+                "originKnown": origin == nil ? "0" : "1",
+            ])
+
+        for window in self.windows {
+            window.orderFrontRegardless()
+        }
+
+        self.dismissalTask = Task { @MainActor [weak self] in
+            try? await Task.sleep(for: .seconds(Self.overlayLifetime))
+            self?.dismiss()
+        }
+    }
+
+    func dismiss() {
+        self.dismissalTask?.cancel()
+        self.dismissalTask = nil
+
+        guard !self.windows.isEmpty else { return }
+        for window in self.windows {
+            window.orderOut(nil)
+            window.close()
+        }
+        self.windows.removeAll(keepingCapacity: true)
+    }
+
+    private static func localOrigin(in screenFrame: CGRect, from globalOrigin: CGPoint?) -> CGPoint {
+        let fallback = CGPoint(x: screenFrame.maxX - 28, y: screenFrame.maxY - 8)
+        let resolved: CGPoint = if let globalOrigin, screenFrame.contains(globalOrigin) {
+            globalOrigin
+        } else {
+            fallback
+        }
+
+        let insetFrame = screenFrame.insetBy(dx: 8, dy: 8)
+        return CGPoint(
+            x: min(max(resolved.x, insetFrame.minX), insetFrame.maxX) - screenFrame.minX,
+            y: min(max(resolved.y, insetFrame.minY), insetFrame.maxY) - screenFrame.minY)
+    }
+
+    private static func randomPalette() -> [Color] {
+        let hue = Double.random(in: 0...1)
+        let hueOffsets = [0.0, 0.08, 0.16, 0.5, 0.66, 0.83]
+        return hueOffsets.map { offset in
+            Color(
+                hue: (hue + offset).truncatingRemainder(dividingBy: 1),
+                saturation: Double.random(in: 0.55...0.95),
+                brightness: Double.random(in: 0.85...1))
+        }
+    }
+}
+
+private final class ClickThroughOverlayPanel: NSPanel {
+    override var canBecomeKey: Bool {
+        false
+    }
+
+    override var canBecomeMain: Bool {
+        false
+    }
+
+    override var acceptsFirstResponder: Bool {
+        false
+    }
+}
+
+private struct ScreenConfettiOverlayView: View {
+    private static let clockwiseRotationAngles: [Double] = [270, 234, 198, 162, 126, 90]
+    private static let counterclockwiseRotationAngles: [Double] = [90, 126, 162, 198, 234, 270]
+
+    let origin: CGPoint
+    let colors: [Color]
+
+    @Environment(\.self) private var environment
+    @State private var visiblePhaseCount = 0
+
+    var body: some View {
+        GeometryReader { proxy in
+            let clockwiseAngles = Array(Self.clockwiseRotationAngles.prefix(self.visiblePhaseCount).enumerated())
+            let counterclockwiseAngles = Array(
+                Self.counterclockwiseRotationAngles.prefix(self.visiblePhaseCount).enumerated())
+            ZStack {
+                ForEach(clockwiseAngles, id: \.offset) { index, angle in
+                    VortexView(self.makeFireworkConfettiSystem(
+                        in: proxy.size,
+                        launchAngle: angle,
+                        phaseIndex: index,
+                        lateralOffset: -12))
+                    {
+                        RoundedRectangle(cornerRadius: 2, style: .continuous)
+                            .fill(.white)
+                            .frame(width: 10, height: 20)
+                            .tag("confetti-bar")
+
+                        Circle()
+                            .fill(.white)
+                            .frame(width: 9, height: 9)
+                            .tag("confetti-dot")
+
+                        Capsule(style: .continuous)
+                            .fill(.white)
+                            .frame(width: 8, height: 16)
+                            .rotationEffect(.degrees(30))
+                            .tag("confetti-pill")
+
+                        Circle()
+                            .fill(.white)
+                            .frame(width: 6, height: 6)
+                            .blur(radius: 1)
+                            .tag("confetti-tracer")
+                    }
+                }
+
+                ForEach(counterclockwiseAngles, id: \.offset) { index, angle in
+                    VortexView(self.makeFireworkConfettiSystem(
+                        in: proxy.size,
+                        launchAngle: angle,
+                        phaseIndex: index,
+                        lateralOffset: 12))
+                    {
+                        RoundedRectangle(cornerRadius: 2, style: .continuous)
+                            .fill(.white)
+                            .frame(width: 10, height: 20)
+                            .tag("confetti-bar")
+
+                        Circle()
+                            .fill(.white)
+                            .frame(width: 9, height: 9)
+                            .tag("confetti-dot")
+
+                        Capsule(style: .continuous)
+                            .fill(.white)
+                            .frame(width: 8, height: 16)
+                            .rotationEffect(.degrees(30))
+                            .tag("confetti-pill")
+
+                        Circle()
+                            .fill(.white)
+                            .frame(width: 6, height: 6)
+                            .blur(radius: 1)
+                            .tag("confetti-tracer")
+                    }
+                }
+            }
+            .ignoresSafeArea()
+            .allowsHitTesting(false)
+            .task {
+                self.visiblePhaseCount = 1
+                for phaseCount in 2...Self.clockwiseRotationAngles.count {
+                    try? await Task.sleep(for: .milliseconds(60))
+                    self.visiblePhaseCount = phaseCount
+                }
+            }
+        }
+    }
+
+    private func makeFireworkConfettiSystem(
+        in size: CGSize,
+        launchAngle: Double,
+        phaseIndex: Int,
+        lateralOffset: CGFloat)
+        -> VortexSystem
+    {
+        let canvasOrigin = self.canvasOrigin(in: size, lateralOffset: lateralOffset)
+        let normalizedX = size.width > 0 ? canvasOrigin.x / size.width : 1
+        let normalizedY = size.height > 0 ? canvasOrigin.y / size.height : 0
+        let resolvedColors = self.colors.map { color -> VortexSystem.Color in
+            let components = color.resolve(in: self.environment)
+            return VortexSystem.Color(
+                red: Double(components.red),
+                green: Double(components.green),
+                blue: Double(components.blue),
+                opacity: Double(components.opacity))
+        }
+
+        let explosion = VortexSystem(
+            tags: ["confetti-bar", "confetti-dot", "confetti-pill"],
+            spawnOccasion: .onDeath,
+            shape: .point,
+            birthRate: 24000,
+            emissionLimit: 42,
+            emissionDuration: 0.08,
+            idleDuration: 10,
+            lifespan: 4.2,
+            speed: 0.72,
+            speedVariation: 0.44,
+            angleRange: .degrees(360),
+            acceleration: [0, 0.32],
+            dampingFactor: 0.18,
+            angularSpeed: [0, 0, 3],
+            angularSpeedVariation: [2, 2, 14],
+            colors: .random(resolvedColors),
+            size: 0.74,
+            sizeVariation: 0.26,
+            sizeMultiplierAtDeath: 0.94,
+            stretchFactor: 0.82)
+
+        return VortexSystem(
+            tags: ["confetti-tracer"],
+            secondarySystems: [explosion],
+            position: [normalizedX, normalizedY],
+            shape: .point,
+            birthRate: 18,
+            emissionLimit: 4,
+            emissionDuration: 0.22,
+            idleDuration: 10,
+            lifespan: 0.58 + (Double(phaseIndex) * 0.03),
+            speed: 1.36 + (Double(phaseIndex) * 0.04),
+            speedVariation: 0.12,
+            angle: .degrees(launchAngle),
+            angleRange: .degrees(12),
+            acceleration: [0, 0.12],
+            dampingFactor: 0.06,
+            angularSpeed: [0, 0, 6],
+            angularSpeedVariation: [1, 1, 8],
+            colors: .single(.white),
+            size: 0.34,
+            sizeVariation: 0.08,
+            sizeMultiplierAtDeath: 0.4,
+            stretchFactor: 1.3)
+    }
+
+    private func canvasOrigin(in size: CGSize, lateralOffset: CGFloat = 0) -> CGPoint {
+        CGPoint(
+            x: min(max(self.origin.x + lateralOffset, 0), size.width),
+            y: min(max(size.height - self.origin.y + 18, 0), size.height))
+    }
+}
diff --git a/Sources/CodexBar/SessionQuotaNotifications.swift b/Sources/CodexBar/SessionQuotaNotifications.swift
index 5b0ed851c8..6dd197e486 100644
--- a/Sources/CodexBar/SessionQuotaNotifications.swift
+++ b/Sources/CodexBar/SessionQuotaNotifications.swift
@@ -1,13 +1,33 @@
+import AppKit
 import CodexBarCore
 import Foundation
 @preconcurrency import UserNotifications
 
-enum SessionQuotaTransition: Equatable, Sendable {
+enum SessionQuotaTransition: Equatable {
     case none
     case depleted
     case restored
 }
 
+struct QuotaWarningEvent: Equatable {
+    let window: QuotaWarningWindow
+    let threshold: Int
+    let currentRemaining: Double
+    let accountDisplayName: String?
+
+    init(
+        window: QuotaWarningWindow,
+        threshold: Int,
+        currentRemaining: Double,
+        accountDisplayName: String? = nil)
+    {
+        self.window = window
+        self.threshold = threshold
+        self.currentRemaining = currentRemaining
+        self.accountDisplayName = accountDisplayName
+    }
+}
+
 enum SessionQuotaNotificationLogic {
     static let depletedThreshold: Double = 0.0001
 
@@ -27,11 +47,154 @@ enum SessionQuotaNotificationLogic {
         if wasDepleted, !isDepleted { return .restored }
         return .none
     }
+
+    static func notificationCopy(
+        transition: SessionQuotaTransition,
+        providerName: String) -> (title: String, body: String)
+    {
+        switch transition {
+        case .none:
+            ("", "")
+        case .depleted:
+            (
+                L("session_depleted_notification_title", providerName),
+                L("session_depleted_notification_body"))
+        case .restored:
+            (
+                L("session_restored_notification_title", providerName),
+                L("session_restored_notification_body"))
+        }
+    }
+}
+
+enum QuotaWarningNotificationLogic {
+    static func notificationCopy(
+        providerName: String,
+        window: QuotaWarningWindow,
+        threshold: Int,
+        currentRemaining: Double,
+        accountDisplayName: String? = nil) -> (title: String, body: String)
+    {
+        let windowLabel = window.localizedNotificationDisplayName
+        let remainingText = Self.percentText(currentRemaining)
+        let title = L("quota_warning_notification_title", providerName, windowLabel)
+        let body = if let accountDisplayName {
+            L(
+                "quota_warning_notification_body_with_account",
+                accountDisplayName,
+                remainingText,
+                threshold,
+                windowLabel)
+        } else {
+            L(
+                "quota_warning_notification_body",
+                remainingText,
+                threshold,
+                windowLabel)
+        }
+        return (title, body)
+    }
+
+    static func crossedThreshold(
+        previousRemaining: Double?,
+        currentRemaining: Double,
+        thresholds: [Int],
+        alreadyFired: Set<Int>) -> Int?
+    {
+        let sanitized = QuotaWarningThresholds.active(thresholds)
+        let eligible = sanitized.filter { threshold in
+            currentRemaining <= Double(threshold) && !alreadyFired.contains(threshold)
+        }
+        guard !eligible.isEmpty else { return nil }
+
+        if let previousRemaining {
+            let crossed = eligible.filter { previousRemaining > Double($0) }
+            return crossed.min()
+        }
+
+        return eligible.min()
+    }
+
+    static func firedThresholdsAfterWarning(threshold: Int, thresholds: [Int]) -> Set<Int> {
+        Set(QuotaWarningThresholds.active(thresholds).filter { $0 >= threshold })
+    }
+
+    static func thresholdsToClear(currentRemaining: Double, alreadyFired: Set<Int>) -> Set<Int> {
+        Set(alreadyFired.filter { currentRemaining > Double($0) })
+    }
+
+    private static func percentText(_ value: Double) -> String {
+        "\(Int(min(100, max(0, value)).rounded()))%"
+    }
+}
+
+@MainActor
+extension UsageStore {
+    func sessionQuotaWindow(
+        provider: UsageProvider,
+        snapshot: UsageSnapshot) -> (window: RateWindow, source: SessionQuotaWindowSource)?
+    {
+        guard provider != .mimo else { return nil }
+        if provider == .antigravity {
+            guard let window = Self.antigravityWindow(snapshot: snapshot, windowMinutes: 5 * 60) else {
+                return nil
+            }
+            let source: SessionQuotaWindowSource = Self.hasAntigravityQuotaSummaryWindows(snapshot: snapshot)
+                ? .antigravityQuotaSummary
+                : .antigravityLegacy
+            return (window, source)
+        }
+        if let primary = snapshot.primary, Self.isSessionWindow(primary) {
+            return (primary, .primary)
+        }
+        if provider == .copilot, let secondary = snapshot.secondary {
+            return (secondary, .copilotSecondaryFallback)
+        }
+        return nil
+    }
+
+    private static func isSessionWindow(_ window: RateWindow) -> Bool {
+        guard let minutes = window.windowMinutes else { return true }
+        return minutes <= 6 * 60
+    }
+
+    private static let antigravityQuotaSummaryWindowIDPrefix = "antigravity-quota-summary-"
+
+    static func hasAntigravityQuotaSummaryWindows(snapshot: UsageSnapshot) -> Bool {
+        snapshot.extraRateWindows?.contains {
+            $0.id.hasPrefix(Self.antigravityQuotaSummaryWindowIDPrefix)
+        } == true
+    }
+
+    static func antigravityWindow(
+        snapshot: UsageSnapshot,
+        windowMinutes: Int) -> RateWindow?
+    {
+        let windows: [RateWindow] = if Self.hasAntigravityQuotaSummaryWindows(snapshot: snapshot) {
+            snapshot.extraRateWindows?
+                .filter {
+                    $0.usageKnown
+                        && $0.id.hasPrefix(Self.antigravityQuotaSummaryWindowIDPrefix)
+                        && $0.window.windowMinutes == windowMinutes
+                }
+                .map(\.window) ?? []
+        } else {
+            [snapshot.primary, snapshot.secondary, snapshot.tertiary]
+                .compactMap(\.self)
+                .filter {
+                    // Legacy Antigravity family lanes historically drive session notifications.
+                    $0.windowMinutes == windowMinutes
+                        || (windowMinutes == 5 * 60 && $0.windowMinutes == nil)
+                }
+        }
+        return windows.max { $0.usedPercent < $1.usedPercent }
+    }
 }
 
 @MainActor
 protocol SessionQuotaNotifying: AnyObject {
     func post(transition: SessionQuotaTransition, provider: UsageProvider, badge: NSNumber?)
+    func postQuotaWarning(event: QuotaWarningEvent, provider: UsageProvider, soundEnabled: Bool)
 }
 
 @MainActor
@@ -45,14 +208,9 @@ final class SessionQuotaNotifier: SessionQuotaNotifying {
 
         let providerName = ProviderDescriptorRegistry.descriptor(for: provider).metadata.displayName
 
-        let (title, body) = switch transition {
-        case .none:
-            ("", "")
-        case .depleted:
-            ("\(providerName) session depleted", "0% left. Will notify when it's available again.")
-        case .restored:
-            ("\(providerName) session restored", "Session quota is available again.")
-        }
+        let (title, body) = SessionQuotaNotificationLogic.notificationCopy(
+            transition: transition,
+            providerName: providerName)
 
         let providerText = provider.rawValue
         let transitionText = String(describing: transition)
@@ -60,4 +218,37 @@ final class SessionQuotaNotifier: SessionQuotaNotifying {
         self.logger.info("enqueuing", metadata: ["prefix": idPrefix])
         AppNotifications.shared.post(idPrefix: idPrefix, title: title, body: body, badge: badge)
     }
+
+    func postQuotaWarning(event: QuotaWarningEvent, provider: UsageProvider, soundEnabled: Bool = true) {
+        let providerName = ProviderDescriptorRegistry.descriptor(for: provider).metadata.displayName
+        let threshold = event.threshold
+        let copy = QuotaWarningNotificationLogic.notificationCopy(
+            providerName: providerName,
+            window: event.window,
+            threshold: threshold,
+            currentRemaining: event.currentRemaining,
+            accountDisplayName: event.accountDisplayName)
+        let idPrefix = "quota-warning-\(provider.rawValue)-\(event.window.rawValue)-\(threshold)"
+        self.logger.info("enqueuing", metadata: ["prefix": idPrefix])
+        if soundEnabled {
+            (NSSound(named: "Glass") ?? NSSound(named: "Ping"))?.play()
+        }
+        NotificationCenter.default.post(
+            name: .codexbarQuotaWarningDidPost,
+            object: QuotaWarningPostedEvent(
+                provider: provider,
+                window: event.window,
+                threshold: threshold,
+                postedAt: Date()))
+        AppNotifications.shared.post(idPrefix: idPrefix, title: copy.title, body: copy.body, soundEnabled: false)
+    }
+}
+
+extension QuotaWarningWindow {
+    fileprivate var localizedNotificationDisplayName: String {
+        switch self {
+        case .session: L("quota_warning_session")
+        case .weekly: L("quota_warning_weekly")
+        }
+    }
 }
diff --git a/Sources/CodexBar/SettingsStore+Config.swift b/Sources/CodexBar/SettingsStore+Config.swift
index 8195200e0f..e4ef5d2aa3 100644
--- a/Sources/CodexBar/SettingsStore+Config.swift
+++ b/Sources/CodexBar/SettingsStore+Config.swift
@@ -6,6 +6,84 @@ extension SettingsStore {
         self.configSnapshot.providerConfig(for: provider)
     }
 
+    func quotaWarningConfig(for provider: UsageProvider) -> QuotaWarningConfig {
+        self.configSnapshot.providerConfig(for: provider)?.quotaWarnings ?? QuotaWarningConfig()
+    }
+
+    func resolvedQuotaWarningThresholds(provider: UsageProvider, window: QuotaWarningWindow) -> [Int] {
+        self.quotaWarningConfig(for: provider).thresholds(
+            for: window,
+            global: self.quotaWarningThresholds(window))
+    }
+
+    func quotaWarningEnabled(provider: UsageProvider, window: QuotaWarningWindow) -> Bool {
+        self.quotaWarningConfig(for: provider).isEnabled(
+            for: window,
+            global: self.quotaWarningWindowEnabled(window))
+    }
+
+    func hasQuotaWarningOverride(provider: UsageProvider, window: QuotaWarningWindow) -> Bool {
+        self.quotaWarningConfig(for: provider).hasOverride(for: window)
+    }
+
+    func setQuotaWarningThresholds(provider: UsageProvider, window: QuotaWarningWindow, thresholds: [Int]?) {
+        self.updateProviderConfig(provider: provider) { entry in
+            var config = entry.quotaWarnings ?? QuotaWarningConfig()
+            switch window {
+            case .session:
+                var windowConfig = config.session ?? QuotaWarningWindowConfig()
+                windowConfig.thresholds = thresholds.map(QuotaWarningThresholds.sanitized)
+                config.session = windowConfig.hasOverride ? windowConfig : nil
+            case .weekly:
+                var windowConfig = config.weekly ?? QuotaWarningWindowConfig()
+                windowConfig.thresholds = thresholds.map(QuotaWarningThresholds.sanitized)
+                config.weekly = windowConfig.hasOverride ? windowConfig : nil
+            }
+            entry.quotaWarnings = config.isEmpty ? nil : config
+        }
+    }
+
+    func setQuotaWarningOverride(
+        provider: UsageProvider,
+        window: QuotaWarningWindow,
+        thresholds: [Int]?,
+        enabled: Bool?)
+    {
+        self.updateProviderConfig(provider: provider) { entry in
+            var config = entry.quotaWarnings ?? QuotaWarningConfig()
+            switch window {
+            case .session:
+                var windowConfig = config.session ?? QuotaWarningWindowConfig()
+                windowConfig.thresholds = thresholds.map(QuotaWarningThresholds.sanitized)
+                windowConfig.enabled = enabled
+                config.session = windowConfig.hasOverride ? windowConfig : nil
+            case .weekly:
+                var windowConfig = config.weekly ?? QuotaWarningWindowConfig()
+                windowConfig.thresholds = thresholds.map(QuotaWarningThresholds.sanitized)
+                windowConfig.enabled = enabled
+                config.weekly = windowConfig.hasOverride ? windowConfig : nil
+            }
+            entry.quotaWarnings = config.isEmpty ? nil : config
+        }
+    }
+
+    func setQuotaWarningWindowEnabled(provider: UsageProvider, window: QuotaWarningWindow, enabled: Bool?) {
+        self.updateProviderConfig(provider: provider) { entry in
+            var config = entry.quotaWarnings ?? QuotaWarningConfig()
+            switch window {
+            case .session:
+                var windowConfig = config.session ?? QuotaWarningWindowConfig()
+                windowConfig.enabled = enabled
+                config.session = windowConfig.hasOverride ? windowConfig : nil
+            case .weekly:
+                var windowConfig = config.weekly ?? QuotaWarningWindowConfig()
+                windowConfig.enabled = enabled
+                config.weekly = windowConfig.hasOverride ? windowConfig : nil
+            }
+            entry.quotaWarnings = config.isEmpty ? nil : config
+        }
+    }
+
     var tokenAccountsByProvider: [UsageProvider: ProviderTokenAccountData] {
         get {
             Dictionary(uniqueKeysWithValues: self.configSnapshot.providers.compactMap { entry in
diff --git a/Sources/CodexBar/SettingsStore+ConfigPersistence.swift b/Sources/CodexBar/SettingsStore+ConfigPersistence.swift
index 5b17761dd3..ca7edfaa57 100644
--- a/Sources/CodexBar/SettingsStore+ConfigPersistence.swift
+++ b/Sources/CodexBar/SettingsStore+ConfigPersistence.swift
@@ -123,6 +123,10 @@ extension SettingsStore {
     }
 
     private func bumpConfigRevision(_ context: ConfigChangeContext) {
+        // Account routing derives from config paths and source selection. Never let an old
+        // reconciliation snapshot survive a config reload, even when another provider changed.
+        self.invalidateCodexAccountReconciliationSnapshotCache()
+        self.cachedCodexAccountMenuProjection = nil
         self.configRevision &+= 1
         CodexBarLog.logger(LogCategories.settings)
             .debug("Config revision bumped (\(context.reason)) -> \(self.configRevision)")
diff --git a/Sources/CodexBar/SettingsStore+Defaults.swift b/Sources/CodexBar/SettingsStore+Defaults.swift
index 44d83a023f..c10b5592e5 100644
--- a/Sources/CodexBar/SettingsStore+Defaults.swift
+++ b/Sources/CodexBar/SettingsStore+Defaults.swift
@@ -35,7 +35,9 @@ extension SettingsStore {
         set {
             self.defaultsState.debugDisableKeychainAccess = newValue
             self.userDefaults.set(newValue, forKey: "debugDisableKeychainAccess")
-            Self.sharedDefaults?.set(newValue, forKey: "debugDisableKeychainAccess")
+            if Self.shouldBridgeSharedDefaults(for: self.userDefaults) {
+                Self.sharedDefaults?.set(newValue, forKey: "debugDisableKeychainAccess")
+            }
             KeychainAccessGate.isDisabled = newValue
         }
     }
@@ -101,6 +103,96 @@ extension SettingsStore {
         }
     }
 
+    var quotaWarningNotificationsEnabled: Bool {
+        get { self.defaultsState.quotaWarningNotificationsEnabled }
+        set {
+            self.defaultsState.quotaWarningNotificationsEnabled = newValue
+            self.userDefaults.set(newValue, forKey: "quotaWarningNotificationsEnabled")
+        }
+    }
+
+    var quotaWarningThresholds: [Int] {
+        get { QuotaWarningThresholds.sanitized(self.defaultsState.quotaWarningThresholdsRaw) }
+        set {
+            let sanitized = QuotaWarningThresholds.sanitized(newValue)
+            self.defaultsState.quotaWarningThresholdsRaw = sanitized
+            self.defaultsState.quotaWarningSessionThresholdsRaw = sanitized
+            self.defaultsState.quotaWarningWeeklyThresholdsRaw = sanitized
+            self.userDefaults.set(sanitized, forKey: "quotaWarningThresholds")
+            self.userDefaults.set(sanitized, forKey: "quotaWarningSessionThresholds")
+            self.userDefaults.set(sanitized, forKey: "quotaWarningWeeklyThresholds")
+        }
+    }
+
+    func quotaWarningThresholds(_ window: QuotaWarningWindow) -> [Int] {
+        switch window {
+        case .session:
+            QuotaWarningThresholds.sanitized(self.defaultsState.quotaWarningSessionThresholdsRaw)
+        case .weekly:
+            QuotaWarningThresholds.sanitized(self.defaultsState.quotaWarningWeeklyThresholdsRaw)
+        }
+    }
+
+    func setQuotaWarningThresholds(_ window: QuotaWarningWindow, thresholds: [Int]) {
+        let sanitized = QuotaWarningThresholds.sanitized(thresholds)
+        switch window {
+        case .session:
+            self.defaultsState.quotaWarningSessionThresholdsRaw = sanitized
+            self.userDefaults.set(sanitized, forKey: "quotaWarningSessionThresholds")
+        case .weekly:
+            self.defaultsState.quotaWarningWeeklyThresholdsRaw = sanitized
+            self.userDefaults.set(sanitized, forKey: "quotaWarningWeeklyThresholds")
+        }
+    }
+
+    func quotaWarningWindowEnabled(_ window: QuotaWarningWindow) -> Bool {
+        switch window {
+        case .session:
+            self.defaultsState.quotaWarningSessionEnabled
+        case .weekly:
+            self.defaultsState.quotaWarningWeeklyEnabled
+        }
+    }
+
+    func setQuotaWarningWindowEnabled(_ window: QuotaWarningWindow, enabled: Bool) {
+        switch window {
+        case .session:
+            self.defaultsState.quotaWarningSessionEnabled = enabled
+            self.userDefaults.set(enabled, forKey: "quotaWarningSessionEnabled")
+        case .weekly:
+            self.defaultsState.quotaWarningWeeklyEnabled = enabled
+            self.userDefaults.set(enabled, forKey: "quotaWarningWeeklyEnabled")
+        }
+    }
+
+    var quotaWarningSoundEnabled: Bool {
+        get { self.defaultsState.quotaWarningSoundEnabled }
+        set {
+            self.defaultsState.quotaWarningSoundEnabled = newValue
+            self.userDefaults.set(newValue, forKey: "quotaWarningSoundEnabled")
+        }
+    }
+
+    var quotaWarningMarkersVisible: Bool {
+        get { self.defaultsState.quotaWarningMarkersVisible }
+        set {
+            self.defaultsState.quotaWarningMarkersVisible = newValue
+            self.userDefaults.set(newValue, forKey: "quotaWarningMarkersVisible")
+        }
+    }
+
+    var weeklyProgressWorkDays: Int? {
+        get { self.defaultsState.weeklyProgressWorkDays }
+        set {
+            self.defaultsState.weeklyProgressWorkDays = newValue
+            if let newValue {
+                self.userDefaults.set(newValue, forKey: "weeklyProgressWorkDays")
+            } else {
+                self.userDefaults.removeObject(forKey: "weeklyProgressWorkDays")
+            }
+        }
+    }
+
     var usageBarsShowUsed: Bool {
         get { self.defaultsState.usageBarsShowUsed }
         set {
@@ -117,6 +209,14 @@ extension SettingsStore {
         }
     }
 
+    var providerChangelogLinksEnabled: Bool {
+        get { self.defaultsState.providerChangelogLinksEnabled }
+        set {
+            self.defaultsState.providerChangelogLinksEnabled = newValue
+            self.userDefaults.set(newValue, forKey: "providerChangelogLinksEnabled")
+        }
+    }
+
     var menuBarShowsBrandIconWithPercent: Bool {
         get { self.defaultsState.menuBarShowsBrandIconWithPercent }
         set {
@@ -125,6 +225,14 @@ extension SettingsStore {
         }
     }
 
+    var menuBarHidesCritters: Bool {
+        get { self.defaultsState.menuBarHidesCritters }
+        set {
+            self.defaultsState.menuBarHidesCritters = newValue
+            self.userDefaults.set(newValue, forKey: "menuBarHidesCritters")
+        }
+    }
+
     private var menuBarDisplayModeRaw: String? {
         get { self.defaultsState.menuBarDisplayModeRaw }
         set {
@@ -142,14 +250,36 @@ extension SettingsStore {
         set { self.menuBarDisplayModeRaw = newValue.rawValue }
     }
 
-    var showAllTokenAccountsInMenu: Bool {
-        get { self.defaultsState.showAllTokenAccountsInMenu }
+    private var kiroMenuBarDisplayModeRaw: String? {
+        get { self.defaultsState.kiroMenuBarDisplayModeRaw }
+        set {
+            self.defaultsState.kiroMenuBarDisplayModeRaw = newValue
+            if let raw = newValue {
+                self.userDefaults.set(raw, forKey: "kiroMenuBarDisplayMode")
+            } else {
+                self.userDefaults.removeObject(forKey: "kiroMenuBarDisplayMode")
+            }
+        }
+    }
+
+    var kiroMenuBarDisplayMode: KiroMenuBarDisplayMode {
+        get { KiroMenuBarDisplayMode(rawValue: self.kiroMenuBarDisplayModeRaw ?? "") ?? .automatic }
+        set { self.kiroMenuBarDisplayModeRaw = newValue.rawValue }
+    }
+
+    var multiAccountMenuLayout: MultiAccountMenuLayout {
+        get { MultiAccountMenuLayout(rawValue: self.defaultsState.multiAccountMenuLayoutRaw) ?? .segmented }
         set {
-            self.defaultsState.showAllTokenAccountsInMenu = newValue
-            self.userDefaults.set(newValue, forKey: "showAllTokenAccountsInMenu")
+            self.defaultsState.multiAccountMenuLayoutRaw = newValue.rawValue
+            self.userDefaults.set(newValue.rawValue, forKey: "multiAccountMenuLayout")
         }
     }
 
+    var showAllTokenAccountsInMenu: Bool {
+        get { self.multiAccountMenuLayout == .stacked }
+        set { self.multiAccountMenuLayout = newValue ? .stacked : .segmented }
+    }
+
     var historicalTrackingEnabled: Bool {
         get { self.defaultsState.historicalTrackingEnabled }
         set {
@@ -166,6 +296,14 @@ extension SettingsStore {
         }
     }
 
+    var copilotIconSecondaryWindowIDRaw: String {
+        get { self.defaultsState.copilotIconSecondaryWindowIDRaw }
+        set {
+            self.defaultsState.copilotIconSecondaryWindowIDRaw = newValue
+            self.userDefaults.set(newValue, forKey: "copilotIconSecondaryWindowID")
+        }
+    }
+
     var costUsageEnabled: Bool {
         get { self.defaultsState.costUsageEnabled }
         set {
@@ -174,6 +312,15 @@ extension SettingsStore {
         }
     }
 
+    var costUsageHistoryDays: Int {
+        get { self.defaultsState.costUsageHistoryDays }
+        set {
+            let clamped = max(1, min(365, newValue))
+            self.defaultsState.costUsageHistoryDays = clamped
+            self.userDefaults.set(clamped, forKey: "tokenCostUsageHistoryDays")
+        }
+    }
+
     var hidePersonalInfo: Bool {
         get { self.defaultsState.hidePersonalInfo }
         set {
@@ -190,6 +337,14 @@ extension SettingsStore {
         }
     }
 
+    var confettiOnWeeklyLimitResetsEnabled: Bool {
+        get { self.defaultsState.confettiOnWeeklyLimitResetsEnabled }
+        set {
+            self.defaultsState.confettiOnWeeklyLimitResetsEnabled = newValue
+            self.userDefaults.set(newValue, forKey: "confettiOnWeeklyLimitResetsEnabled")
+        }
+    }
+
     var menuBarShowsHighestUsage: Bool {
         get { self.defaultsState.menuBarShowsHighestUsage }
         set {
@@ -211,8 +366,10 @@ extension SettingsStore {
 
     var claudeOAuthKeychainReadStrategy: ClaudeOAuthKeychainReadStrategy {
         get {
-            let raw = self.defaultsState.claudeOAuthKeychainReadStrategyRaw
-            return ClaudeOAuthKeychainReadStrategy(rawValue: raw ?? "") ?? .securityFramework
+            guard let raw = self.defaultsState.claudeOAuthKeychainReadStrategyRaw else {
+                return .securityCLIExperimental
+            }
+            return ClaudeOAuthKeychainReadStrategy(rawValue: raw) ?? .securityFramework
         }
         set {
             self.defaultsState.claudeOAuthKeychainReadStrategyRaw = newValue.rawValue
@@ -234,6 +391,17 @@ extension SettingsStore {
         set { self.claudeWebExtrasEnabledRaw = newValue }
     }
 
+    var copilotBudgetExtrasEnabled: Bool {
+        get { self.defaultsState.copilotBudgetExtrasEnabled }
+        set {
+            self.defaultsState.copilotBudgetExtrasEnabled = newValue
+            self.userDefaults.set(newValue, forKey: "copilotBudgetExtrasEnabled")
+            CodexBarLog.logger(LogCategories.settings).info(
+                "Copilot budget extras updated",
+                metadata: ["enabled": newValue ? "1" : "0"])
+        }
+    }
+
     private var claudeWebExtrasEnabledRaw: Bool {
         get { self.defaultsState.claudeWebExtrasEnabledRaw }
         set {
@@ -264,6 +432,28 @@ extension SettingsStore {
         }
     }
 
+    var openAIWebBatterySaverEnabled: Bool {
+        get { self.defaultsState.openAIWebBatterySaverEnabled }
+        set {
+            self.defaultsState.openAIWebBatterySaverEnabled = newValue
+            self.userDefaults.set(newValue, forKey: "openAIWebBatterySaverEnabled")
+            CodexBarLog.logger(LogCategories.settings).info(
+                "OpenAI web battery saver updated",
+                metadata: ["enabled": newValue ? "1" : "0"])
+        }
+    }
+
+    var providerStorageFootprintsEnabled: Bool {
+        get { self.defaultsState.providerStorageFootprintsEnabled }
+        set {
+            self.defaultsState.providerStorageFootprintsEnabled = newValue
+            self.userDefaults.set(newValue, forKey: "providerStorageFootprintsEnabled")
+            CodexBarLog.logger(LogCategories.settings).info(
+                "Provider storage footprints updated",
+                metadata: ["enabled": newValue ? "1" : "0"])
+        }
+    }
+
     var jetbrainsIDEBasePath: String {
         get { self.defaultsState.jetbrainsIDEBasePath }
         set {
@@ -289,9 +479,9 @@ extension SettingsStore {
     }
 
     var mergedMenuLastSelectedWasOverview: Bool {
-        get { self.defaultsState.mergedMenuLastSelectedWasOverview }
+        get { self.mergedMenuLastSelectedWasOverviewStorage }
         set {
-            self.defaultsState.mergedMenuLastSelectedWasOverview = newValue
+            self.mergedMenuLastSelectedWasOverviewStorage = newValue
             self.userDefaults.set(newValue, forKey: "mergedMenuLastSelectedWasOverview")
         }
     }
@@ -305,9 +495,9 @@ extension SettingsStore {
     }
 
     private var selectedMenuProviderRaw: String? {
-        get { self.defaultsState.selectedMenuProviderRaw }
+        get { self.selectedMenuProviderRawStorage }
         set {
-            self.defaultsState.selectedMenuProviderRaw = newValue
+            self.selectedMenuProviderRawStorage = newValue
             if let raw = newValue {
                 self.userDefaults.set(raw, forKey: "selectedMenuProvider")
             } else {
@@ -474,10 +664,50 @@ extension SettingsStore {
         }
     }
 
+    /// Whether the Providers settings pane displays providers sorted alphabetically (enabled on
+    /// top). Defaults to `false`. Purely a display preference — it never rewrites the stored manual
+    /// order, so turning it on sorts the display without losing the user's hand-arranged sequence.
+    var providersSortedAlphabetically: Bool {
+        get { self.defaultsState.providersSortedAlphabetically }
+        set {
+            self.defaultsState.providersSortedAlphabetically = newValue
+            self.userDefaults.set(newValue, forKey: "providersSortedAlphabetically")
+        }
+    }
+
+    var appLanguage: String {
+        get { self.defaultsState.appLanguageRaw ?? "" }
+        set {
+            let stored = newValue.isEmpty ? nil : newValue
+            self.defaultsState.appLanguageRaw = stored
+            if let stored {
+                self.userDefaults.set(stored, forKey: "appLanguage")
+                if self.userDefaults !== UserDefaults.standard {
+                    UserDefaults.standard.set(stored, forKey: "appLanguage")
+                }
+                UserDefaults.standard.set([stored], forKey: "AppleLanguages")
+            } else {
+                self.userDefaults.removeObject(forKey: "appLanguage")
+                if self.userDefaults !== UserDefaults.standard {
+                    UserDefaults.standard.removeObject(forKey: "appLanguage")
+                }
+                UserDefaults.standard.removeObject(forKey: "AppleLanguages")
+            }
+        }
+    }
+
     var debugLoadingPattern: LoadingPattern? {
         get { self.debugLoadingPatternRaw.flatMap(LoadingPattern.init(rawValue:)) }
         set { self.debugLoadingPatternRaw = newValue?.rawValue }
     }
+
+    var terminalApp: TerminalApp {
+        get { TerminalApp(rawValue: self.defaultsState.terminalAppRaw ?? "") ?? .terminal }
+        set {
+            self.defaultsState.terminalAppRaw = newValue.rawValue
+            self.userDefaults.set(newValue.rawValue, forKey: "terminalApp")
+        }
+    }
 }
 
 extension SettingsStore {
diff --git a/Sources/CodexBar/SettingsStore+MenuObservation.swift b/Sources/CodexBar/SettingsStore+MenuObservation.swift
index f01cc49fa3..e688237df7 100644
--- a/Sources/CodexBar/SettingsStore+MenuObservation.swift
+++ b/Sources/CodexBar/SettingsStore+MenuObservation.swift
@@ -11,23 +11,43 @@ extension SettingsStore {
         _ = self.debugKeepCLISessionsAlive
         _ = self.statusChecksEnabled
         _ = self.sessionQuotaNotificationsEnabled
+        _ = self.quotaWarningNotificationsEnabled
+        _ = self.quotaWarningThresholds
+        _ = self.quotaWarningThresholds(.session)
+        _ = self.quotaWarningThresholds(.weekly)
+        _ = self.quotaWarningWindowEnabled(.session)
+        _ = self.quotaWarningWindowEnabled(.weekly)
+        _ = self.quotaWarningSoundEnabled
+        _ = self.quotaWarningMarkersVisible
+        _ = self.weeklyProgressWorkDays
         _ = self.usageBarsShowUsed
         _ = self.resetTimesShowAbsolute
+        _ = self.providerChangelogLinksEnabled
         _ = self.menuBarShowsBrandIconWithPercent
+        _ = self.menuBarHidesCritters
         _ = self.menuBarShowsHighestUsage
         _ = self.menuBarDisplayMode
+        _ = self.kiroMenuBarDisplayMode
         _ = self.historicalTrackingEnabled
-        _ = self.showAllTokenAccountsInMenu
+        _ = self.multiAccountMenuLayout
         _ = self.menuBarMetricPreferencesRaw
+        _ = self.copilotIconSecondaryWindowIDRaw
         _ = self.costUsageEnabled
+        _ = self.costUsageHistoryDays
+        _ = self.appLanguage
         _ = self.hidePersonalInfo
         _ = self.randomBlinkEnabled
+        _ = self.confettiOnWeeklyLimitResetsEnabled
         _ = self.claudeOAuthKeychainPromptMode
         _ = self.claudeOAuthKeychainReadStrategy
         _ = self.claudeWebExtrasEnabled
+        _ = self.copilotBudgetExtrasEnabled
         _ = self.showOptionalCreditsAndExtraUsage
         _ = self.openAIWebAccessEnabled
+        _ = self.openAIWebBatterySaverEnabled
+        _ = self.providerStorageFootprintsEnabled
         _ = self.codexUsageDataSource
+        _ = self.codexActiveSource
         _ = self.claudeUsageDataSource
         _ = self.kiloUsageDataSource
         _ = self.kiloExtrasEnabled
@@ -35,16 +55,17 @@ extension SettingsStore {
         _ = self.claudeCookieSource
         _ = self.cursorCookieSource
         _ = self.opencodeCookieSource
+        _ = self.opencodegoCookieSource
         _ = self.factoryCookieSource
         _ = self.minimaxCookieSource
         _ = self.minimaxAPIRegion
         _ = self.kimiCookieSource
         _ = self.augmentCookieSource
         _ = self.ampCookieSource
+        _ = self.t3ChatCookieSource
         _ = self.ollamaCookieSource
         _ = self.mergeIcons
         _ = self.switcherShowsIcons
-        _ = self.mergedMenuLastSelectedWasOverview
         _ = self.mergedOverviewSelectedProviders
         _ = self.zaiAPIToken
         _ = self.syntheticAPIToken
@@ -53,6 +74,8 @@ extension SettingsStore {
         _ = self.cursorCookieHeader
         _ = self.opencodeCookieHeader
         _ = self.opencodeWorkspaceID
+        _ = self.opencodegoCookieHeader
+        _ = self.opencodegoWorkspaceID
         _ = self.factoryCookieHeader
         _ = self.minimaxCookieHeader
         _ = self.minimaxAPIToken
@@ -61,12 +84,12 @@ extension SettingsStore {
         _ = self.kiloAPIToken
         _ = self.augmentCookieHeader
         _ = self.ampCookieHeader
+        _ = self.t3ChatCookieHeader
         _ = self.ollamaCookieHeader
         _ = self.copilotAPIToken
         _ = self.warpAPIToken
         _ = self.tokenAccountsByProvider
         _ = self.debugLoadingPattern
-        _ = self.selectedMenuProvider
         _ = self.configRevision
         return 0
     }
diff --git a/Sources/CodexBar/SettingsStore+MenuPreferences.swift b/Sources/CodexBar/SettingsStore+MenuPreferences.swift
index 210a286d44..9e644794b4 100644
--- a/Sources/CodexBar/SettingsStore+MenuPreferences.swift
+++ b/Sources/CodexBar/SettingsStore+MenuPreferences.swift
@@ -3,14 +3,26 @@ import Foundation
 
 extension SettingsStore {
     func menuBarMetricPreference(for provider: UsageProvider) -> MenuBarMetricPreference {
-        if provider == .zai { return .primary }
+        if Self.isBalanceOnlyProvider(provider), provider != .mistral {
+            return .automatic
+        }
+        if provider == .mistral {
+            let raw = self.menuBarMetricPreferencesRaw[provider.rawValue] ?? ""
+            let preference = MenuBarMetricPreference(rawValue: raw) ?? .automatic
+            switch preference {
+            case .automatic, .monthlyPlan:
+                return preference
+            case .primary, .secondary, .primaryAndSecondary, .tertiary, .extraUsage, .average:
+                return .automatic
+            }
+        }
         if provider == .openrouter {
             let raw = self.menuBarMetricPreferencesRaw[provider.rawValue] ?? ""
             let preference = MenuBarMetricPreference(rawValue: raw) ?? .automatic
             switch preference {
             case .automatic, .primary:
                 return preference
-            case .secondary, .average:
+            case .secondary, .primaryAndSecondary, .average, .tertiary, .extraUsage, .monthlyPlan:
                 return .automatic
             }
         }
@@ -19,23 +31,60 @@ extension SettingsStore {
         if preference == .average, !self.menuBarMetricSupportsAverage(for: provider) {
             return .automatic
         }
+        if preference == .primaryAndSecondary, !self.menuBarMetricSupportsPrimaryAndSecondary(for: provider) {
+            return .automatic
+        }
+        if preference == .tertiary, !self.menuBarMetricSupportsTertiary(for: provider) {
+            return .automatic
+        }
+        if preference == .extraUsage, !self.menuBarMetricSupportsExtraUsage(for: provider) {
+            return .automatic
+        }
+        if preference == .monthlyPlan {
+            return .automatic
+        }
         return preference
     }
 
     func setMenuBarMetricPreference(_ preference: MenuBarMetricPreference, for provider: UsageProvider) {
-        if provider == .zai {
-            self.menuBarMetricPreferencesRaw[provider.rawValue] = MenuBarMetricPreference.primary.rawValue
+        if Self.isBalanceOnlyProvider(provider), provider != .mistral {
+            self.menuBarMetricPreferencesRaw[provider.rawValue] = MenuBarMetricPreference.automatic.rawValue
+            return
+        }
+        if provider == .mistral {
+            switch preference {
+            case .automatic, .monthlyPlan:
+                self.menuBarMetricPreferencesRaw[provider.rawValue] = preference.rawValue
+            case .primary, .secondary, .primaryAndSecondary, .tertiary, .extraUsage, .average:
+                self.menuBarMetricPreferencesRaw[provider.rawValue] = MenuBarMetricPreference.automatic.rawValue
+            }
             return
         }
         if provider == .openrouter {
             switch preference {
             case .automatic, .primary:
                 self.menuBarMetricPreferencesRaw[provider.rawValue] = preference.rawValue
-            case .secondary, .average:
+            case .secondary, .primaryAndSecondary, .average, .tertiary, .extraUsage, .monthlyPlan:
                 self.menuBarMetricPreferencesRaw[provider.rawValue] = MenuBarMetricPreference.automatic.rawValue
             }
             return
         }
+        if preference == .primaryAndSecondary, !self.menuBarMetricSupportsPrimaryAndSecondary(for: provider) {
+            self.menuBarMetricPreferencesRaw[provider.rawValue] = MenuBarMetricPreference.automatic.rawValue
+            return
+        }
+        if preference == .tertiary, !self.menuBarMetricSupportsTertiary(for: provider) {
+            self.menuBarMetricPreferencesRaw[provider.rawValue] = MenuBarMetricPreference.automatic.rawValue
+            return
+        }
+        if preference == .extraUsage, !self.menuBarMetricSupportsExtraUsage(for: provider) {
+            self.menuBarMetricPreferencesRaw[provider.rawValue] = MenuBarMetricPreference.automatic.rawValue
+            return
+        }
+        if preference == .monthlyPlan {
+            self.menuBarMetricPreferencesRaw[provider.rawValue] = MenuBarMetricPreference.automatic.rawValue
+            return
+        }
         self.menuBarMetricPreferencesRaw[provider.rawValue] = preference.rawValue
     }
 
@@ -43,6 +92,46 @@ extension SettingsStore {
         provider == .gemini
     }
 
+    func menuBarMetricSupportsPrimaryAndSecondary(for provider: UsageProvider) -> Bool {
+        provider == .codex
+    }
+
+    func menuBarMetricSupportsTertiary(for provider: UsageProvider) -> Bool {
+        provider == .cursor || provider == .perplexity || provider == .zai
+    }
+
+    func menuBarMetricSupportsTertiary(for provider: UsageProvider, snapshot: UsageSnapshot?) -> Bool {
+        if provider == .cursor || provider == .zai {
+            return snapshot?.tertiary != nil
+        }
+        return self.menuBarMetricSupportsTertiary(for: provider)
+    }
+
+    func menuBarMetricSupportsExtraUsage(for provider: UsageProvider) -> Bool {
+        provider == .cursor || provider == .claude
+    }
+
+    func menuBarMetricSupportsExtraUsage(for provider: UsageProvider, snapshot: UsageSnapshot?) -> Bool {
+        guard self.menuBarMetricSupportsExtraUsage(for: provider) else { return false }
+        guard let cost = snapshot?.providerCost else { return false }
+        return cost.limit > 0
+    }
+
+    func menuBarMetricPreference(for provider: UsageProvider, snapshot: UsageSnapshot?) -> MenuBarMetricPreference {
+        let preference = self.menuBarMetricPreference(for: provider)
+        if preference == .tertiary,
+           !self.menuBarMetricSupportsTertiary(for: provider, snapshot: snapshot)
+        {
+            return .automatic
+        }
+        if preference == .extraUsage,
+           !self.menuBarMetricSupportsExtraUsage(for: provider, snapshot: snapshot)
+        {
+            return .automatic
+        }
+        return preference
+    }
+
     func isCostUsageEffectivelyEnabled(for provider: UsageProvider) -> Bool {
         self.costUsageEnabled
             && ProviderDescriptorRegistry.descriptor(for: provider).tokenCost.supportsTokenCost
@@ -51,4 +140,13 @@ extension SettingsStore {
     var resetTimeDisplayStyle: ResetTimeDisplayStyle {
         self.resetTimesShowAbsolute ? .absolute : .countdown
     }
+
+    static func isBalanceOnlyProvider(_ provider: UsageProvider) -> Bool {
+        switch provider {
+        case .deepseek, .mistral, .kimik2, .moonshot, .poe:
+            true
+        default:
+            false
+        }
+    }
 }
diff --git a/Sources/CodexBar/SettingsStore+ProviderDetection.swift b/Sources/CodexBar/SettingsStore+ProviderDetection.swift
index b8534276c0..d4efded24a 100644
--- a/Sources/CodexBar/SettingsStore+ProviderDetection.swift
+++ b/Sources/CodexBar/SettingsStore+ProviderDetection.swift
@@ -17,14 +17,17 @@ extension SettingsStore {
         let claudeInstalled = BinaryLocator.resolveClaudeBinary() != nil
         let geminiInstalled = BinaryLocator.resolveGeminiBinary() != nil
         let antigravityRunning = await AntigravityStatusProbe.isRunning()
+        let antigravityLoggedIn = FileManager.default.fileExists(
+            atPath: AntigravityOAuthCredentialsStore().fileURL.path)
         let logger = CodexBarLog.logger(LogCategories.providerDetection)
 
         // If none installed, keep Codex enabled to match previous behavior.
-        let noneInstalled = !codexInstalled && !claudeInstalled && !geminiInstalled && !antigravityRunning
+        let noneInstalled = !codexInstalled && !claudeInstalled && !geminiInstalled && !antigravityRunning &&
+            !antigravityLoggedIn
         let enableCodex = codexInstalled || noneInstalled
         let enableClaude = claudeInstalled
         let enableGemini = geminiInstalled
-        let enableAntigravity = antigravityRunning
+        let enableAntigravity = antigravityRunning || antigravityLoggedIn
 
         logger.info(
             "Provider detection results",
@@ -33,6 +36,7 @@ extension SettingsStore {
                 "claudeInstalled": claudeInstalled ? "1" : "0",
                 "geminiInstalled": geminiInstalled ? "1" : "0",
                 "antigravityRunning": antigravityRunning ? "1" : "0",
+                "antigravityLoggedIn": antigravityLoggedIn ? "1" : "0",
             ])
         logger.info(
             "Provider detection enablement",
diff --git a/Sources/CodexBar/SettingsStore+TokenAccounts.swift b/Sources/CodexBar/SettingsStore+TokenAccounts.swift
index 1f8a0277be..11acbb83d7 100644
--- a/Sources/CodexBar/SettingsStore+TokenAccounts.swift
+++ b/Sources/CodexBar/SettingsStore+TokenAccounts.swift
@@ -36,11 +36,21 @@ extension SettingsStore {
             ])
     }
 
-    func addTokenAccount(provider: UsageProvider, label: String, token: String) {
+    func addTokenAccount(
+        provider: UsageProvider,
+        label: String,
+        token: String,
+        externalIdentifier: String? = nil,
+        organizationID: String? = nil)
+    {
         guard TokenAccountSupportCatalog.support(for: provider) != nil else { return }
         let trimmedToken = token.trimmingCharacters(in: .whitespacesAndNewlines)
         guard !trimmedToken.isEmpty else { return }
         let trimmedLabel = label.trimmingCharacters(in: .whitespacesAndNewlines)
+        let trimmedIdentifier = externalIdentifier?.trimmingCharacters(in: .whitespacesAndNewlines)
+        let normalisedIdentifier = (trimmedIdentifier?.isEmpty ?? true) ? nil : trimmedIdentifier
+        let trimmedOrganizationID = organizationID?.trimmingCharacters(in: .whitespacesAndNewlines)
+        let normalisedOrganizationID = (trimmedOrganizationID?.isEmpty ?? true) ? nil : trimmedOrganizationID
         let existing = self.tokenAccountsData(for: provider)
         let accounts = existing?.accounts ?? []
         let fallbackLabel = trimmedLabel.isEmpty ? "Account \(accounts.count + 1)" : trimmedLabel
@@ -49,13 +59,18 @@ extension SettingsStore {
             label: fallbackLabel,
             token: trimmedToken,
             addedAt: Date().timeIntervalSince1970,
-            lastUsed: nil)
+            lastUsed: nil,
+            externalIdentifier: normalisedIdentifier,
+            organizationID: normalisedOrganizationID)
         let updated = ProviderTokenAccountData(
             version: existing?.version ?? 1,
             accounts: accounts + [account],
             activeIndex: accounts.count)
         self.updateProviderConfig(provider: provider) { entry in
             entry.tokenAccounts = updated
+            if provider == .copilot {
+                entry.apiKey = nil
+            }
         }
         self.applyTokenAccountCookieSourceIfNeeded(provider: provider)
         CodexBarLog.logger(LogCategories.tokenAccounts).info(
@@ -66,20 +81,96 @@ extension SettingsStore {
             ])
     }
 
+    func updateTokenAccount(
+        provider: UsageProvider,
+        accountID: UUID,
+        label: String? = nil,
+        token: String? = nil,
+        externalIdentifier: String?? = nil,
+        organizationID: String?? = nil)
+    {
+        guard let data = self.tokenAccountsData(for: provider), !data.accounts.isEmpty else { return }
+        guard let index = data.accounts.firstIndex(where: { $0.id == accountID }) else { return }
+
+        let trimmedLabel = label?.trimmingCharacters(in: .whitespacesAndNewlines)
+        let trimmedToken = token?.trimmingCharacters(in: .whitespacesAndNewlines)
+        if let trimmedToken, trimmedToken.isEmpty { return }
+
+        let existing = data.accounts[index]
+        let resolvedIdentifier: String?
+        if let externalIdentifier {
+            let trimmed = externalIdentifier?.trimmingCharacters(in: .whitespacesAndNewlines)
+            resolvedIdentifier = (trimmed?.isEmpty ?? true) ? nil : trimmed
+        } else {
+            resolvedIdentifier = existing.externalIdentifier
+        }
+        let resolvedOrganizationID: String?
+        if let organizationID {
+            let trimmed = organizationID?.trimmingCharacters(in: .whitespacesAndNewlines)
+            resolvedOrganizationID = (trimmed?.isEmpty ?? true) ? nil : trimmed
+        } else {
+            resolvedOrganizationID = existing.organizationID
+        }
+        let updatedAccount = ProviderTokenAccount(
+            id: existing.id,
+            label: (trimmedLabel?.isEmpty == false) ? trimmedLabel! : existing.label,
+            token: trimmedToken ?? existing.token,
+            addedAt: existing.addedAt,
+            lastUsed: existing.lastUsed,
+            externalIdentifier: resolvedIdentifier,
+            organizationID: resolvedOrganizationID)
+
+        var accounts = data.accounts
+        accounts[index] = updatedAccount
+        let updated = ProviderTokenAccountData(
+            version: data.version,
+            accounts: accounts,
+            activeIndex: data.clampedActiveIndex())
+        self.updateProviderConfig(provider: provider) { entry in
+            entry.tokenAccounts = updated
+            if provider == .copilot {
+                entry.apiKey = nil
+            }
+        }
+        self.applyTokenAccountCookieSourceIfNeeded(provider: provider)
+        CodexBarLog.logger(LogCategories.tokenAccounts).info(
+            "Token account updated",
+            metadata: [
+                "provider": provider.rawValue,
+                "count": "\(updated.accounts.count)",
+            ])
+    }
+
     func removeTokenAccount(provider: UsageProvider, accountID: UUID) {
         guard let data = self.tokenAccountsData(for: provider), !data.accounts.isEmpty else { return }
+        let activeAccountID = data.accounts[data.clampedActiveIndex()].id
+        guard let removedIndex = data.accounts.firstIndex(where: { $0.id == accountID }) else { return }
+        let removedAccount = data.accounts[removedIndex]
         let filtered = data.accounts.filter { $0.id != accountID }
         self.updateProviderConfig(provider: provider) { entry in
             if filtered.isEmpty {
                 entry.tokenAccounts = nil
             } else {
-                let clamped = min(max(data.activeIndex, 0), filtered.count - 1)
+                let nextActiveIndex = if activeAccountID != accountID,
+                                         let preservedIndex = filtered.firstIndex(where: { $0.id == activeAccountID })
+                {
+                    preservedIndex
+                } else {
+                    min(removedIndex, filtered.count - 1)
+                }
                 entry.tokenAccounts = ProviderTokenAccountData(
                     version: data.version,
                     accounts: filtered,
-                    activeIndex: clamped)
+                    activeIndex: nextActiveIndex)
+            }
+            if provider == .copilot {
+                entry.apiKey = nil
             }
         }
+        self.applyTokenAccountRemovalSideEffectsIfNeeded(
+            provider: provider,
+            removedAccount: removedAccount,
+            remainingAccounts: filtered)
         CodexBarLog.logger(LogCategories.tokenAccounts).info(
             "Token account removed",
             metadata: [
@@ -126,4 +217,111 @@ extension SettingsStore {
         else { return }
         ProviderCatalog.implementation(for: provider)?.applyTokenAccountCookieSource(settings: self)
     }
+
+    private func applyTokenAccountRemovalSideEffectsIfNeeded(
+        provider: UsageProvider,
+        removedAccount: ProviderTokenAccount,
+        remainingAccounts: [ProviderTokenAccount])
+    {
+        guard provider == .antigravity else { return }
+        guard let removedCredentials = AntigravityOAuthCredentialsStore.credentials(
+            fromTokenAccountValue: removedAccount.token)
+        else {
+            return
+        }
+        let hasMatchingRemainingAccount = remainingAccounts.contains { account in
+            guard let credentials = AntigravityOAuthCredentialsStore.credentials(fromTokenAccountValue: account.token)
+            else {
+                return false
+            }
+            return Self.antigravityCredentialsMatchAccount(credentials, removedCredentials)
+        }
+        guard !hasMatchingRemainingAccount else { return }
+
+        Self.clearMatchingAntigravitySharedCredentials(
+            store: self.antigravityOAuthCredentialsStore,
+            removedCredentials: removedCredentials)
+    }
+
+    private nonisolated static func clearMatchingAntigravitySharedCredentials(
+        store: AntigravityOAuthCredentialsStore,
+        removedCredentials: AntigravityOAuthCredentials)
+    {
+        do {
+            try store.deleteIfPresent { sharedCredentials in
+                self.antigravitySharedCredentialsMatchRemovedAccount(
+                    sharedCredentials,
+                    removedCredentials)
+            }
+        } catch {
+            CodexBarLog.logger(LogCategories.tokenAccounts).warning(
+                "Failed to clear Antigravity OAuth cache after account removal",
+                metadata: ["error": error.localizedDescription])
+        }
+    }
+
+    private nonisolated static func antigravitySharedCredentialsMatchRemovedAccount(
+        _ shared: AntigravityOAuthCredentials,
+        _ removed: AntigravityOAuthCredentials) -> Bool
+    {
+        if let sharedRefreshToken = self.normalizedAntigravityCredentialToken(shared.refreshToken),
+           let removedRefreshToken = self.normalizedAntigravityCredentialToken(removed.refreshToken)
+        {
+            return sharedRefreshToken == removedRefreshToken
+        }
+        if let sharedAccessToken = self.normalizedAntigravityCredentialToken(shared.accessToken),
+           let removedAccessToken = self.normalizedAntigravityCredentialToken(removed.accessToken)
+        {
+            return sharedAccessToken == removedAccessToken
+        }
+        guard self.normalizedAntigravityCredentialToken(shared.refreshToken) == nil,
+              self.normalizedAntigravityCredentialToken(removed.refreshToken) == nil,
+              self.normalizedAntigravityCredentialToken(shared.accessToken) == nil,
+              self.normalizedAntigravityCredentialToken(removed.accessToken) == nil
+        else {
+            return false
+        }
+        return self.normalizedAntigravityAccountEmail(shared.resolvedAccountEmail)
+            == self.normalizedAntigravityAccountEmail(removed.resolvedAccountEmail)
+    }
+
+    private nonisolated static func antigravityCredentialsMatchAccount(
+        _ lhs: AntigravityOAuthCredentials,
+        _ rhs: AntigravityOAuthCredentials) -> Bool
+    {
+        if let lhsEmail = self.normalizedAntigravityAccountEmail(lhs.resolvedAccountEmail),
+           let rhsEmail = self.normalizedAntigravityAccountEmail(rhs.resolvedAccountEmail)
+        {
+            return lhsEmail == rhsEmail
+        }
+        if let lhsRefreshToken = self.normalizedAntigravityCredentialToken(lhs.refreshToken),
+           let rhsRefreshToken = self.normalizedAntigravityCredentialToken(rhs.refreshToken)
+        {
+            return lhsRefreshToken == rhsRefreshToken
+        }
+        if let lhsAccessToken = self.normalizedAntigravityCredentialToken(lhs.accessToken),
+           let rhsAccessToken = self.normalizedAntigravityCredentialToken(rhs.accessToken)
+        {
+            return lhsAccessToken == rhsAccessToken
+        }
+        return false
+    }
+
+    private nonisolated static func normalizedAntigravityAccountEmail(_ email: String?) -> String? {
+        guard let value = email?.trimmingCharacters(in: .whitespacesAndNewlines).lowercased(),
+              !value.isEmpty
+        else {
+            return nil
+        }
+        return value
+    }
+
+    private nonisolated static func normalizedAntigravityCredentialToken(_ token: String?) -> String? {
+        guard let value = token?.trimmingCharacters(in: .whitespacesAndNewlines),
+              !value.isEmpty
+        else {
+            return nil
+        }
+        return value
+    }
 }
diff --git a/Sources/CodexBar/SettingsStore.swift b/Sources/CodexBar/SettingsStore.swift
index 09f3e3caa8..e9a087ca1d 100644
--- a/Sources/CodexBar/SettingsStore.swift
+++ b/Sources/CodexBar/SettingsStore.swift
@@ -28,12 +28,12 @@ enum RefreshFrequency: String, CaseIterable, Identifiable {
 
     var label: String {
         switch self {
-        case .manual: "Manual"
-        case .oneMinute: "1 min"
-        case .twoMinutes: "2 min"
-        case .fiveMinutes: "5 min"
-        case .fifteenMinutes: "15 min"
-        case .thirtyMinutes: "30 min"
+        case .manual: L("refresh_manual")
+        case .oneMinute: L("refresh_1min")
+        case .twoMinutes: L("refresh_2min")
+        case .fiveMinutes: L("refresh_5min")
+        case .fifteenMinutes: L("refresh_15min")
+        case .thirtyMinutes: L("refresh_30min")
         }
     }
 }
@@ -42,7 +42,40 @@ enum MenuBarMetricPreference: String, CaseIterable, Identifiable {
     case automatic
     case primary
     case secondary
+    case primaryAndSecondary
+    case tertiary
+    case extraUsage
     case average
+    case monthlyPlan
+
+    var id: String {
+        self.rawValue
+    }
+
+    var label: String {
+        switch self {
+        case .automatic: L("metric_pref_automatic")
+        case .primary: L("metric_pref_primary")
+        case .secondary: L("metric_pref_secondary")
+        case .primaryAndSecondary: "\(L("metric_pref_primary")) + \(L("metric_pref_secondary"))"
+        case .tertiary: L("metric_pref_tertiary")
+        case .extraUsage: L("metric_pref_extra_usage")
+        case .average: L("metric_pref_average")
+        case .monthlyPlan: L("metric_mistral_monthly_plan")
+        }
+    }
+}
+
+enum KiroMenuBarDisplayMode: String, CaseIterable, Identifiable {
+    case automatic
+    case hidden
+    case creditsLeft
+    case percentLeft
+    case creditsAndPercent
+    case usedAndTotal
+    case overageCreditsWhenExhausted
+    case overageCostWhenExhausted
+    case overageCreditsAndCostWhenExhausted
 
     var id: String {
         self.rawValue
@@ -51,18 +84,59 @@ enum MenuBarMetricPreference: String, CaseIterable, Identifiable {
     var label: String {
         switch self {
         case .automatic: "Automatic"
-        case .primary: "Primary"
-        case .secondary: "Secondary"
-        case .average: "Average"
+        case .hidden: "Hidden"
+        case .creditsLeft: "Credits left"
+        case .percentLeft: "Percent left"
+        case .creditsAndPercent: "Credits + percent"
+        case .usedAndTotal: "Used / total"
+        case .overageCreditsWhenExhausted: "Overage credits at zero"
+        case .overageCostWhenExhausted: "Overage cost at zero"
+        case .overageCreditsAndCostWhenExhausted: "Overage credits + cost at zero"
         }
     }
 }
 
+enum MultiAccountMenuLayout: String, CaseIterable, Identifiable {
+    case segmented
+    case stacked
+
+    var id: String {
+        self.rawValue
+    }
+
+    var label: String {
+        switch self {
+        case .segmented: L("multi_account_layout_segmented")
+        case .stacked: L("multi_account_layout_stacked")
+        }
+    }
+}
+
+struct CachedCodexAccountReconciliationSnapshot {
+    let activeSource: CodexActiveSource
+    let loadedAt: Date
+    let snapshot: CodexAccountReconciliationSnapshot
+}
+
+struct CachedCodexAccountMenuProjection: Equatable {
+    let activeSource: CodexActiveSource
+    let loadedAt: Date
+    let projection: CodexVisibleAccountProjection
+}
+
+enum CodexAccountMenuProjectionRevalidationResult: Equatable {
+    case skipped
+    case discarded
+    case unchanged
+    case updated
+}
+
 @MainActor
 @Observable
 final class SettingsStore {
-    static let sharedDefaults = UserDefaults(suiteName: "group.com.steipete.codexbar")
+    static let sharedDefaults = AppGroupSupport.sharedDefaults()
     static let mergedOverviewProviderLimit = 3
+    static let productionCodexAccountReconciliationSnapshotCacheInterval: TimeInterval = 2
     static let isRunningTests: Bool = {
         let env = ProcessInfo.processInfo.environment
         if env["XCTestConfigurationFilePath"] != nil { return true }
@@ -71,17 +145,39 @@ final class SettingsStore {
         return NSClassFromString("XCTestCase") != nil
     }()
 
+    #if DEBUG
+    static var codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting: TimeInterval?
+    #endif
+
     @ObservationIgnored let userDefaults: UserDefaults
     @ObservationIgnored let configStore: CodexBarConfigStore
+    @ObservationIgnored let antigravityOAuthCredentialsStore: AntigravityOAuthCredentialsStore
     @ObservationIgnored var config: CodexBarConfig
     @ObservationIgnored var configPersistTask: Task<Void, Never>?
     @ObservationIgnored var configLoading = false
     @ObservationIgnored var tokenAccountsLoaded = false
+    @ObservationIgnored var cachedCodexAccountReconciliationSnapshot:
+        CachedCodexAccountReconciliationSnapshot?
+    @ObservationIgnored var cachedCodexAccountMenuProjection: CachedCodexAccountMenuProjection?
+    @ObservationIgnored var codexAccountReconciliationGeneration: UInt = 0
+    #if DEBUG
+    @ObservationIgnored var _test_codexAccountSnapshotLoader:
+        (@Sendable (CodexActiveSource) -> CodexAccountReconciliationSnapshot)?
+    #endif
+    @ObservationIgnored var mergedMenuLastSelectedWasOverviewStorage = false
+    @ObservationIgnored var selectedMenuProviderRawStorage: String?
     var defaultsState: SettingsDefaultsState
     var configRevision: Int = 0
     var providerOrder: [UsageProvider] = []
     var providerEnablement: [UsageProvider: Bool] = [:]
 
+    static func shouldBridgeSharedDefaults(for userDefaults: UserDefaults) -> Bool {
+        if !self.isRunningTests { return true }
+        if userDefaults === UserDefaults.standard { return true }
+        if let shared = sharedDefaults, userDefaults === shared { return true }
+        return false
+    }
+
     init(
         userDefaults: UserDefaults = .standard,
         configStore: CodexBarConfigStore = CodexBarConfigStore(),
@@ -113,8 +209,38 @@ final class SettingsStore {
             account: "amp-cookie",
             promptKind: .ampCookie),
         copilotTokenStore: any CopilotTokenStoring = KeychainCopilotTokenStore(),
-        tokenAccountStore: any ProviderTokenAccountStoring = FileTokenAccountStore())
+        tokenAccountStore: any ProviderTokenAccountStoring = FileTokenAccountStore(),
+        antigravityOAuthCredentialsStore: AntigravityOAuthCredentialsStore = AntigravityOAuthCredentialsStore(),
+        performInitialProviderDetection: Bool = !SettingsStore.isRunningTests)
     {
+        let appGroupID = AppGroupSupport.currentGroupID()
+        let appGroupMigration: AppGroupSupport.MigrationResult
+        if Self.isRunningTests {
+            appGroupMigration = AppGroupSupport.migrateLegacyDataIfNeeded(standardDefaults: userDefaults)
+        } else {
+            Self.scheduleAppGroupMigration()
+            appGroupMigration = AppGroupSupport.MigrationResult(status: .targetUnavailable)
+        }
+        let sharedDefaultsAvailable = Self.sharedDefaults != nil
+        if !Self.isRunningTests {
+            CodexBarLog.logger(LogCategories.settings).info(
+                "App group resolved",
+                metadata: [
+                    "groupID": appGroupID,
+                    "sharedDefaultsAvailable": sharedDefaultsAvailable ? "1" : "0",
+                    "migrationStatus": appGroupMigration.status.rawValue,
+                    "migratedSnapshot": appGroupMigration.copiedSnapshot ? "1" : "0",
+                    "migratedDefaults": "\(appGroupMigration.copiedDefaults)",
+                ])
+        }
+
+        if userDefaults.object(forKey: "openAIWebAccessEnabled") == nil,
+           let legacyOpenAIWebAccess = userDefaults.object(forKey: "openAIWebAccess") as? Bool
+        {
+            userDefaults.set(legacyOpenAIWebAccess, forKey: "openAIWebAccessEnabled")
+        }
+        let hasStoredOpenAIWebAccessPreference = userDefaults.object(forKey: "openAIWebAccessEnabled") != nil
+        let hadExistingConfig = (try? configStore.load()) != nil
         let legacyStores = CodexBarConfigMigrator.LegacyStores(
             zaiTokenStore: zaiTokenStore,
             syntheticTokenStore: syntheticTokenStore,
@@ -137,43 +263,84 @@ final class SettingsStore {
             stores: legacyStores)
         self.userDefaults = userDefaults
         self.configStore = configStore
+        self.antigravityOAuthCredentialsStore = antigravityOAuthCredentialsStore
         self.config = config
         self.configLoading = true
-        self.defaultsState = Self.loadDefaultsState(userDefaults: userDefaults)
+        let defaultsState = Self.loadDefaultsState(userDefaults: userDefaults)
+        self.defaultsState = defaultsState
+        self.mergedMenuLastSelectedWasOverviewStorage = defaultsState.mergedMenuLastSelectedWasOverview
+        self.selectedMenuProviderRawStorage = defaultsState.selectedMenuProviderRaw
         self.updateProviderState(config: config)
         self.configLoading = false
         CodexBarLog.setFileLoggingEnabled(self.debugFileLoggingEnabled)
         userDefaults.removeObject(forKey: "showCodexUsage")
         userDefaults.removeObject(forKey: "showClaudeUsage")
         LaunchAtLoginManager.setEnabled(self.launchAtLogin)
-        self.runInitialProviderDetectionIfNeeded()
+        if performInitialProviderDetection {
+            self.runInitialProviderDetectionIfNeeded()
+        }
+        self.ensureAlibabaProviderAutoEnabledIfNeeded()
         self.applyTokenCostDefaultIfNeeded()
-        if self.claudeUsageDataSource != .cli { self.claudeWebExtrasEnabled = false }
-        self.openAIWebAccessEnabled = self.codexCookieSource.isEnabled
-        Self.sharedDefaults?.set(self.debugDisableKeychainAccess, forKey: "debugDisableKeychainAccess")
+        if self.claudeUsageDataSource != .cli {
+            if Self.isRunningTests {
+                self.claudeWebExtrasEnabled = false
+            } else {
+                self.defaultsState.claudeWebExtrasEnabledRaw = false
+            }
+        }
+        let resolvedOpenAIWebAccessEnabled = if hasStoredOpenAIWebAccessPreference {
+            self.defaultsState.openAIWebAccessEnabled
+        } else {
+            Self.inferredInitialOpenAIWebAccessEnabled(
+                config: config,
+                hadExistingConfig: hadExistingConfig)
+        }
+        if Self.isRunningTests {
+            self.openAIWebAccessEnabled = resolvedOpenAIWebAccessEnabled
+        } else {
+            self.defaultsState.openAIWebAccessEnabled = resolvedOpenAIWebAccessEnabled
+        }
         KeychainAccessGate.isDisabled = self.debugDisableKeychainAccess
     }
 }
 
 extension SettingsStore {
+    private static func scheduleAppGroupMigration() {
+        Task.detached(priority: .utility) {
+            let result = AppGroupSupport.migrateLegacyDataIfNeeded()
+            CodexBarLog.logger(LogCategories.settings).info(
+                "App group migration completed",
+                metadata: [
+                    "migrationStatus": result.status.rawValue,
+                    "migratedSnapshot": result.copiedSnapshot ? "1" : "0",
+                    "migratedDefaults": "\(result.copiedDefaults)",
+                ])
+        }
+    }
+
+    private static func inferredInitialOpenAIWebAccessEnabled(
+        config: CodexBarConfig,
+        hadExistingConfig: Bool) -> Bool
+    {
+        guard let codex = config.providerConfig(for: .codex) else { return false }
+        if let cookieSource = codex.cookieSource { return cookieSource.isEnabled }
+        if codex.sanitizedCookieHeader != nil { return true }
+        return hadExistingConfig
+    }
+
     private static func loadDefaultsState(userDefaults: UserDefaults) -> SettingsDefaultsState {
-        let refreshRaw = userDefaults.string(forKey: "refreshFrequency") ?? RefreshFrequency.fiveMinutes.rawValue
-        let refreshFrequency = RefreshFrequency(rawValue: refreshRaw) ?? .fiveMinutes
+        let refreshDefault = userDefaults.string(forKey: "refreshFrequency")
+            .flatMap(RefreshFrequency.init(rawValue:))
+        let refreshFrequency = refreshDefault ?? .fiveMinutes
+        if Self.isRunningTests, refreshDefault == nil {
+            userDefaults.set(refreshFrequency.rawValue, forKey: "refreshFrequency")
+        }
         let launchAtLogin = userDefaults.object(forKey: "launchAtLogin") as? Bool ?? false
         let debugMenuEnabled = userDefaults.object(forKey: "debugMenuEnabled") as? Bool ?? false
-        let debugDisableKeychainAccess: Bool = {
-            if let stored = userDefaults.object(forKey: "debugDisableKeychainAccess") as? Bool {
-                return stored
-            }
-            if let shared = Self.sharedDefaults?.object(forKey: "debugDisableKeychainAccess") as? Bool {
-                userDefaults.set(shared, forKey: "debugDisableKeychainAccess")
-                return shared
-            }
-            return false
-        }()
+        let debugDisableKeychainAccess = Self.loadDebugDisableKeychainAccess(userDefaults: userDefaults)
         let debugFileLoggingEnabled = userDefaults.object(forKey: "debugFileLoggingEnabled") as? Bool ?? false
         let debugLogLevelRaw = userDefaults.string(forKey: "debugLogLevel") ?? CodexBarLog.Level.verbose.rawValue
-        if userDefaults.string(forKey: "debugLogLevel") == nil {
+        if Self.isRunningTests, userDefaults.string(forKey: "debugLogLevel") == nil {
             userDefaults.set(debugLogLevelRaw, forKey: "debugLogLevel")
         }
         let debugLoadingPatternRaw = userDefaults.string(forKey: "debugLoadingPattern")
@@ -181,39 +348,63 @@ extension SettingsStore {
         let statusChecksEnabled = userDefaults.object(forKey: "statusChecksEnabled") as? Bool ?? true
         let sessionQuotaDefault = userDefaults.object(forKey: "sessionQuotaNotificationsEnabled") as? Bool
         let sessionQuotaNotificationsEnabled = sessionQuotaDefault ?? true
-        if sessionQuotaDefault == nil {
+        if Self.isRunningTests, sessionQuotaDefault == nil {
             userDefaults.set(true, forKey: "sessionQuotaNotificationsEnabled")
         }
+        let quotaWarnings = Self.loadQuotaWarningDefaults(userDefaults: userDefaults)
+        let quotaWarningMarkersVisibleDefault = userDefaults.object(forKey: "quotaWarningMarkersVisible") as? Bool
+        let quotaWarningMarkersVisible = quotaWarningMarkersVisibleDefault ?? true
+        if Self.isRunningTests, quotaWarningMarkersVisibleDefault == nil {
+            userDefaults.set(true, forKey: "quotaWarningMarkersVisible")
+        }
+        let weeklyProgressWorkDays = userDefaults.object(forKey: "weeklyProgressWorkDays") as? Int
         let usageBarsShowUsed = userDefaults.object(forKey: "usageBarsShowUsed") as? Bool ?? false
         let resetTimesShowAbsolute = userDefaults.object(forKey: "resetTimesShowAbsolute") as? Bool ?? false
+        let providerChangelogLinksEnabled = userDefaults.object(
+            forKey: "providerChangelogLinksEnabled") as? Bool ?? false
         let menuBarShowsBrandIconWithPercent = userDefaults.object(
             forKey: "menuBarShowsBrandIconWithPercent") as? Bool ?? false
+        let menuBarHidesCritters = userDefaults.object(forKey: "menuBarHidesCritters") as? Bool ?? false
         let menuBarDisplayModeRaw = userDefaults.string(forKey: "menuBarDisplayMode")
             ?? MenuBarDisplayMode.percent.rawValue
+        let kiroMenuBarDisplayModeRaw = userDefaults.string(forKey: "kiroMenuBarDisplayMode")
+            ?? KiroMenuBarDisplayMode.automatic.rawValue
         let historicalTrackingEnabled = userDefaults.object(forKey: "historicalTrackingEnabled") as? Bool ?? false
-        let showAllTokenAccountsInMenu = userDefaults.object(forKey: "showAllTokenAccountsInMenu") as? Bool ?? false
-        let storedPreferences = userDefaults.dictionary(forKey: "menuBarMetricPreferences") as? [String: String] ?? [:]
-        var resolvedPreferences = storedPreferences
-        if resolvedPreferences.isEmpty,
-           let menuBarMetricRaw = userDefaults.string(forKey: "menuBarMetricPreference"),
-           let legacyPreference = MenuBarMetricPreference(rawValue: menuBarMetricRaw)
-        {
-            resolvedPreferences = Dictionary(
-                uniqueKeysWithValues: UsageProvider.allCases.map { ($0.rawValue, legacyPreference.rawValue) })
-        }
+        let multiAccountMenuLayoutRaw = Self.loadMultiAccountMenuLayoutRaw(userDefaults: userDefaults)
+        let resolvedPreferences = Self.loadMenuBarMetricPreferences(userDefaults: userDefaults)
+        let copilotBudgetExtrasEnabled = userDefaults.object(forKey: "copilotBudgetExtrasEnabled") as? Bool ?? false
+        let copilotIconSecondaryWindowIDRaw = Self.loadCopilotIconSecondaryWindowIDRaw(userDefaults: userDefaults)
         let costUsageEnabled = userDefaults.object(forKey: "tokenCostUsageEnabled") as? Bool ?? false
+        let rawCostUsageHistoryDays = userDefaults.object(forKey: "tokenCostUsageHistoryDays") as? Int ?? 30
+        let costUsageHistoryDays = max(1, min(365, rawCostUsageHistoryDays))
         let hidePersonalInfo = userDefaults.object(forKey: "hidePersonalInfo") as? Bool ?? false
         let randomBlinkEnabled = userDefaults.object(forKey: "randomBlinkEnabled") as? Bool ?? false
+        let confettiOnWeeklyLimitResetsEnabled = userDefaults.object(
+            forKey: "confettiOnWeeklyLimitResetsEnabled") as? Bool ?? false
         let menuBarShowsHighestUsage = userDefaults.object(forKey: "menuBarShowsHighestUsage") as? Bool ?? false
         let claudeOAuthKeychainPromptModeRaw = userDefaults.string(forKey: "claudeOAuthKeychainPromptMode")
         let claudeOAuthKeychainReadStrategyRaw = userDefaults.string(forKey: "claudeOAuthKeychainReadStrategy")
         let claudeWebExtrasEnabledRaw = userDefaults.object(forKey: "claudeWebExtrasEnabled") as? Bool ?? false
         let creditsExtrasDefault = userDefaults.object(forKey: "showOptionalCreditsAndExtraUsage") as? Bool
         let showOptionalCreditsAndExtraUsage = creditsExtrasDefault ?? true
-        if creditsExtrasDefault == nil { userDefaults.set(true, forKey: "showOptionalCreditsAndExtraUsage") }
+        if Self.isRunningTests, creditsExtrasDefault == nil {
+            userDefaults.set(true, forKey: "showOptionalCreditsAndExtraUsage")
+        }
         let openAIWebAccessDefault = userDefaults.object(forKey: "openAIWebAccessEnabled") as? Bool
-        let openAIWebAccessEnabled = openAIWebAccessDefault ?? true
-        if openAIWebAccessDefault == nil { userDefaults.set(true, forKey: "openAIWebAccessEnabled") }
+        let openAIWebAccessEnabled = openAIWebAccessDefault ?? false
+        if Self.isRunningTests, openAIWebAccessDefault == nil {
+            userDefaults.set(false, forKey: "openAIWebAccessEnabled")
+        }
+        let openAIWebBatterySaverDefault = userDefaults.object(forKey: "openAIWebBatterySaverEnabled") as? Bool
+        let openAIWebBatterySaverEnabled = openAIWebBatterySaverDefault ?? false
+        if Self.isRunningTests, openAIWebBatterySaverDefault == nil {
+            userDefaults.set(false, forKey: "openAIWebBatterySaverEnabled")
+        }
+        let providerStorageFootprintsDefault = userDefaults.object(forKey: "providerStorageFootprintsEnabled") as? Bool
+        let providerStorageFootprintsEnabled = providerStorageFootprintsDefault ?? false
+        if Self.isRunningTests, providerStorageFootprintsDefault == nil {
+            userDefaults.set(false, forKey: "providerStorageFootprintsEnabled")
+        }
         let jetbrainsIDEBasePath = userDefaults.string(forKey: "jetbrainsIDEBasePath") ?? ""
         let mergeIcons = userDefaults.object(forKey: "mergeIcons") as? Bool ?? true
         let switcherShowsIcons = userDefaults.object(forKey: "switcherShowsIcons") as? Bool ?? true
@@ -223,7 +414,9 @@ extension SettingsStore {
             forKey: "mergedOverviewSelectedProviders") as? [String] ?? []
         let selectedMenuProviderRaw = userDefaults.string(forKey: "selectedMenuProvider")
         let providerDetectionCompleted = userDefaults.object(forKey: "providerDetectionCompleted") as? Bool ?? false
-
+        let providersSortedAlphabetically = userDefaults.object(
+            forKey: "providersSortedAlphabetically") as? Bool ?? false
+        let appLanguageRaw = userDefaults.string(forKey: "appLanguage")
         return SettingsDefaultsState(
             refreshFrequency: refreshFrequency,
             launchAtLogin: launchAtLogin,
@@ -235,29 +428,167 @@ extension SettingsStore {
             debugKeepCLISessionsAlive: debugKeepCLISessionsAlive,
             statusChecksEnabled: statusChecksEnabled,
             sessionQuotaNotificationsEnabled: sessionQuotaNotificationsEnabled,
+            quotaWarningNotificationsEnabled: quotaWarnings.notificationsEnabled,
+            quotaWarningThresholdsRaw: quotaWarnings.thresholdsRaw,
+            quotaWarningSessionThresholdsRaw: quotaWarnings.sessionThresholdsRaw,
+            quotaWarningWeeklyThresholdsRaw: quotaWarnings.weeklyThresholdsRaw,
+            quotaWarningSessionEnabled: quotaWarnings.sessionEnabled,
+            quotaWarningWeeklyEnabled: quotaWarnings.weeklyEnabled,
+            quotaWarningSoundEnabled: quotaWarnings.soundEnabled,
+            quotaWarningMarkersVisible: quotaWarningMarkersVisible,
+            weeklyProgressWorkDays: weeklyProgressWorkDays,
             usageBarsShowUsed: usageBarsShowUsed,
             resetTimesShowAbsolute: resetTimesShowAbsolute,
+            providerChangelogLinksEnabled: providerChangelogLinksEnabled,
             menuBarShowsBrandIconWithPercent: menuBarShowsBrandIconWithPercent,
+            menuBarHidesCritters: menuBarHidesCritters,
             menuBarDisplayModeRaw: menuBarDisplayModeRaw,
+            kiroMenuBarDisplayModeRaw: kiroMenuBarDisplayModeRaw,
             historicalTrackingEnabled: historicalTrackingEnabled,
-            showAllTokenAccountsInMenu: showAllTokenAccountsInMenu,
+            multiAccountMenuLayoutRaw: multiAccountMenuLayoutRaw,
             menuBarMetricPreferencesRaw: resolvedPreferences,
+            copilotBudgetExtrasEnabled: copilotBudgetExtrasEnabled,
+            copilotIconSecondaryWindowIDRaw: copilotIconSecondaryWindowIDRaw,
             costUsageEnabled: costUsageEnabled,
+            costUsageHistoryDays: costUsageHistoryDays,
             hidePersonalInfo: hidePersonalInfo,
             randomBlinkEnabled: randomBlinkEnabled,
+            confettiOnWeeklyLimitResetsEnabled: confettiOnWeeklyLimitResetsEnabled,
             menuBarShowsHighestUsage: menuBarShowsHighestUsage,
             claudeOAuthKeychainPromptModeRaw: claudeOAuthKeychainPromptModeRaw,
             claudeOAuthKeychainReadStrategyRaw: claudeOAuthKeychainReadStrategyRaw,
             claudeWebExtrasEnabledRaw: claudeWebExtrasEnabledRaw,
             showOptionalCreditsAndExtraUsage: showOptionalCreditsAndExtraUsage,
             openAIWebAccessEnabled: openAIWebAccessEnabled,
+            openAIWebBatterySaverEnabled: openAIWebBatterySaverEnabled,
+            providerStorageFootprintsEnabled: providerStorageFootprintsEnabled,
             jetbrainsIDEBasePath: jetbrainsIDEBasePath,
             mergeIcons: mergeIcons,
             switcherShowsIcons: switcherShowsIcons,
             mergedMenuLastSelectedWasOverview: mergedMenuLastSelectedWasOverview,
             mergedOverviewSelectedProvidersRaw: mergedOverviewSelectedProvidersRaw,
             selectedMenuProviderRaw: selectedMenuProviderRaw,
-            providerDetectionCompleted: providerDetectionCompleted)
+            providerDetectionCompleted: providerDetectionCompleted,
+            providersSortedAlphabetically: providersSortedAlphabetically,
+            appLanguageRaw: appLanguageRaw,
+            terminalAppRaw: userDefaults.string(forKey: "terminalApp"))
+    }
+
+    private static func loadMenuBarMetricPreferences(userDefaults: UserDefaults) -> [String: String] {
+        let storedPreferences = userDefaults.dictionary(forKey: "menuBarMetricPreferences") as? [String: String] ?? [:]
+        let preferences: [String: String] = if !storedPreferences.isEmpty {
+            storedPreferences
+        } else if let menuBarMetricRaw = userDefaults.string(forKey: "menuBarMetricPreference"),
+                  let legacyPreference = MenuBarMetricPreference(rawValue: menuBarMetricRaw)
+        {
+            Dictionary(
+                uniqueKeysWithValues: UsageProvider.allCases.map { ($0.rawValue, legacyPreference.rawValue) })
+        } else {
+            [:]
+        }
+
+        let migrationKey = "antigravityTwoPoolMetricPreferenceMigrated"
+        guard !userDefaults.bool(forKey: migrationKey) else { return preferences }
+
+        // Tagged builds through v0.35 used primary=Claude, secondary=Gemini Pro,
+        // and tertiary=Gemini Flash. Remap those meanings once to the two-pool schema.
+        var migrated = preferences
+        switch MenuBarMetricPreference(rawValue: migrated[UsageProvider.antigravity.rawValue] ?? "") {
+        case .primary:
+            migrated[UsageProvider.antigravity.rawValue] = MenuBarMetricPreference.secondary.rawValue
+        case .secondary:
+            migrated[UsageProvider.antigravity.rawValue] = MenuBarMetricPreference.primary.rawValue
+        case .tertiary:
+            migrated[UsageProvider.antigravity.rawValue] = MenuBarMetricPreference.primary.rawValue
+        case .automatic, .primaryAndSecondary, .extraUsage, .average, .monthlyPlan, .none:
+            break
+        }
+        userDefaults.set(migrated, forKey: "menuBarMetricPreferences")
+        userDefaults.set(true, forKey: migrationKey)
+        return migrated
+    }
+
+    private static func loadMultiAccountMenuLayoutRaw(userDefaults: UserDefaults) -> String {
+        if let layout = userDefaults.string(forKey: "multiAccountMenuLayout") {
+            return layout
+        }
+        let legacyShowAll = userDefaults.object(forKey: "showAllTokenAccountsInMenu") as? Bool ?? false
+        return legacyShowAll ? MultiAccountMenuLayout.stacked.rawValue : MultiAccountMenuLayout.segmented.rawValue
+    }
+
+    private static func loadCopilotIconSecondaryWindowIDRaw(userDefaults: UserDefaults) -> String {
+        userDefaults.string(forKey: "copilotIconSecondaryWindowID") ?? CopilotIconSecondaryWindowSelection.chat
+    }
+
+    private static func loadDebugDisableKeychainAccess(userDefaults: UserDefaults) -> Bool {
+        if let stored = userDefaults.object(forKey: "debugDisableKeychainAccess") as? Bool {
+            return stored
+        }
+        if Self.shouldBridgeSharedDefaults(for: userDefaults),
+           let shared = Self.sharedDefaults?.object(forKey: "debugDisableKeychainAccess") as? Bool
+        {
+            if Self.isRunningTests {
+                userDefaults.set(shared, forKey: "debugDisableKeychainAccess")
+            }
+            return shared
+        }
+        return false
+    }
+
+    private struct LoadedQuotaWarningDefaults {
+        var notificationsEnabled: Bool
+        var thresholdsRaw: [Int]
+        var sessionThresholdsRaw: [Int]
+        var weeklyThresholdsRaw: [Int]
+        var sessionEnabled: Bool
+        var weeklyEnabled: Bool
+        var soundEnabled: Bool
+    }
+
+    private static func loadQuotaWarningDefaults(userDefaults: UserDefaults) -> LoadedQuotaWarningDefaults {
+        let notificationsEnabled = userDefaults.object(forKey: "quotaWarningNotificationsEnabled") as? Bool ?? false
+        let rawThresholds = userDefaults.array(forKey: "quotaWarningThresholds") as? [Int]
+        let thresholdsRaw = QuotaWarningThresholds.sanitized(rawThresholds ?? QuotaWarningThresholds.defaults)
+        if Self.isRunningTests, rawThresholds != thresholdsRaw {
+            userDefaults.set(thresholdsRaw, forKey: "quotaWarningThresholds")
+        }
+        let rawSessionThresholds = userDefaults.array(forKey: "quotaWarningSessionThresholds") as? [Int]
+        let sessionThresholdsRaw = QuotaWarningThresholds.sanitized(rawSessionThresholds ?? thresholdsRaw)
+        if Self.isRunningTests, rawSessionThresholds != sessionThresholdsRaw {
+            userDefaults.set(sessionThresholdsRaw, forKey: "quotaWarningSessionThresholds")
+        }
+        let rawWeeklyThresholds = userDefaults.array(forKey: "quotaWarningWeeklyThresholds") as? [Int]
+        let weeklyThresholdsRaw = QuotaWarningThresholds.sanitized(rawWeeklyThresholds ?? thresholdsRaw)
+        if Self.isRunningTests, rawWeeklyThresholds != weeklyThresholdsRaw {
+            userDefaults.set(weeklyThresholdsRaw, forKey: "quotaWarningWeeklyThresholds")
+        }
+
+        let sessionDefault = userDefaults.object(forKey: "quotaWarningSessionEnabled") as? Bool
+        let sessionEnabled = sessionDefault ?? true
+        if Self.isRunningTests, sessionDefault == nil {
+            userDefaults.set(true, forKey: "quotaWarningSessionEnabled")
+        }
+
+        let weeklyDefault = userDefaults.object(forKey: "quotaWarningWeeklyEnabled") as? Bool
+        let weeklyEnabled = weeklyDefault ?? true
+        if Self.isRunningTests, weeklyDefault == nil {
+            userDefaults.set(true, forKey: "quotaWarningWeeklyEnabled")
+        }
+
+        let soundDefault = userDefaults.object(forKey: "quotaWarningSoundEnabled") as? Bool
+        let soundEnabled = soundDefault ?? true
+        if Self.isRunningTests, soundDefault == nil {
+            userDefaults.set(true, forKey: "quotaWarningSoundEnabled")
+        }
+
+        return LoadedQuotaWarningDefaults(
+            notificationsEnabled: notificationsEnabled,
+            thresholdsRaw: thresholdsRaw,
+            sessionThresholdsRaw: sessionThresholdsRaw,
+            weeklyThresholdsRaw: weeklyThresholdsRaw,
+            sessionEnabled: sessionEnabled,
+            weeklyEnabled: weeklyEnabled,
+            soundEnabled: soundEnabled)
     }
 }
 
@@ -317,6 +648,9 @@ extension SettingsStore {
         self.updateProviderConfig(provider: provider) { entry in
             entry.enabled = enabled
         }
+        if !enabled, self.selectedMenuProvider == provider {
+            self.selectedMenuProvider = nil
+        }
     }
 
     func rerunProviderDetection() {
diff --git a/Sources/CodexBar/SettingsStoreState.swift b/Sources/CodexBar/SettingsStoreState.swift
index ff3d640bd2..58f7a02af4 100644
--- a/Sources/CodexBar/SettingsStoreState.swift
+++ b/Sources/CodexBar/SettingsStoreState.swift
@@ -1,6 +1,6 @@
 import Foundation
 
-struct SettingsDefaultsState: Sendable {
+struct SettingsDefaultsState {
     var refreshFrequency: RefreshFrequency
     var launchAtLogin: Bool
     var debugMenuEnabled: Bool
@@ -11,22 +11,40 @@ struct SettingsDefaultsState: Sendable {
     var debugKeepCLISessionsAlive: Bool
     var statusChecksEnabled: Bool
     var sessionQuotaNotificationsEnabled: Bool
+    var quotaWarningNotificationsEnabled: Bool
+    var quotaWarningThresholdsRaw: [Int]
+    var quotaWarningSessionThresholdsRaw: [Int]
+    var quotaWarningWeeklyThresholdsRaw: [Int]
+    var quotaWarningSessionEnabled: Bool
+    var quotaWarningWeeklyEnabled: Bool
+    var quotaWarningSoundEnabled: Bool
+    var quotaWarningMarkersVisible: Bool
+    var weeklyProgressWorkDays: Int?
     var usageBarsShowUsed: Bool
     var resetTimesShowAbsolute: Bool
+    var providerChangelogLinksEnabled: Bool
     var menuBarShowsBrandIconWithPercent: Bool
+    var menuBarHidesCritters: Bool
     var menuBarDisplayModeRaw: String?
+    var kiroMenuBarDisplayModeRaw: String?
     var historicalTrackingEnabled: Bool
-    var showAllTokenAccountsInMenu: Bool
+    var multiAccountMenuLayoutRaw: String
     var menuBarMetricPreferencesRaw: [String: String]
+    var copilotBudgetExtrasEnabled: Bool
+    var copilotIconSecondaryWindowIDRaw: String
     var costUsageEnabled: Bool
+    var costUsageHistoryDays: Int
     var hidePersonalInfo: Bool
     var randomBlinkEnabled: Bool
+    var confettiOnWeeklyLimitResetsEnabled: Bool
     var menuBarShowsHighestUsage: Bool
     var claudeOAuthKeychainPromptModeRaw: String?
     var claudeOAuthKeychainReadStrategyRaw: String?
     var claudeWebExtrasEnabledRaw: Bool
     var showOptionalCreditsAndExtraUsage: Bool
     var openAIWebAccessEnabled: Bool
+    var openAIWebBatterySaverEnabled: Bool
+    var providerStorageFootprintsEnabled: Bool
     var jetbrainsIDEBasePath: String
     var mergeIcons: Bool
     var switcherShowsIcons: Bool
@@ -34,4 +52,7 @@ struct SettingsDefaultsState: Sendable {
     var mergedOverviewSelectedProvidersRaw: [String]
     var selectedMenuProviderRaw: String?
     var providerDetectionCompleted: Bool
+    var providersSortedAlphabetically: Bool
+    var appLanguageRaw: String?
+    var terminalAppRaw: String?
 }
diff --git a/Sources/CodexBar/StatusItemController+AccountMenuDisplay.swift b/Sources/CodexBar/StatusItemController+AccountMenuDisplay.swift
new file mode 100644
index 0000000000..2c268511f4
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+AccountMenuDisplay.swift
@@ -0,0 +1,124 @@
+import AppKit
+import CodexBarCore
+
+extension StatusItemController {
+    private static let defaultCodexAccountMenuProjectionRevalidationEnabled = !SettingsStore.isRunningTests
+
+    #if DEBUG
+    private static var codexAccountMenuProjectionRevalidationEnabledForTesting =
+        defaultCodexAccountMenuProjectionRevalidationEnabled
+
+    static func setCodexAccountMenuProjectionRevalidationEnabledForTesting(_ enabled: Bool) {
+        self.codexAccountMenuProjectionRevalidationEnabledForTesting = enabled
+    }
+
+    static func resetCodexAccountMenuProjectionRevalidationEnabledForTesting() {
+        self.codexAccountMenuProjectionRevalidationEnabledForTesting =
+            self.defaultCodexAccountMenuProjectionRevalidationEnabled
+    }
+    #endif
+
+    private static var codexAccountMenuProjectionRevalidationEnabled: Bool {
+        #if DEBUG
+        self.codexAccountMenuProjectionRevalidationEnabledForTesting
+        #else
+        self.defaultCodexAccountMenuProjectionRevalidationEnabled
+        #endif
+    }
+
+    func tokenAccountMenuDisplay(for provider: UsageProvider) -> TokenAccountMenuDisplay? {
+        guard TokenAccountSupportCatalog.support(for: provider) != nil else { return nil }
+        let accounts = self.settings.tokenAccounts(for: provider)
+        guard accounts.count > 1 else { return nil }
+        let activeIndex = self.settings.tokenAccountsData(for: provider)?.clampedActiveIndex() ?? 0
+        let showAll = self.settings.multiAccountMenuLayout == .stacked
+        let displayAccounts = showAll
+            ? self.store.limitedTokenAccounts(accounts, selected: self.settings.selectedTokenAccount(for: provider))
+            : accounts
+        let snapshots = showAll
+            ? self.tokenAccountSnapshots(for: provider, matching: displayAccounts)
+            : []
+        return TokenAccountMenuDisplay(
+            provider: provider,
+            accounts: displayAccounts,
+            snapshots: snapshots,
+            activeIndex: activeIndex,
+            layout: showAll ? .stacked : .segmented)
+    }
+
+    private func tokenAccountSnapshots(
+        for provider: UsageProvider,
+        matching accounts: [ProviderTokenAccount]) -> [TokenAccountUsageSnapshot]
+    {
+        var snapshotsByID: [UUID: TokenAccountUsageSnapshot] = [:]
+        for snapshot in self.store.accountSnapshots[provider] ?? [] {
+            snapshotsByID[snapshot.account.id] = snapshot
+        }
+        return accounts.compactMap { snapshotsByID[$0.id] }
+    }
+
+    func codexAccountMenuDisplay(for provider: UsageProvider) -> CodexAccountMenuDisplay? {
+        guard provider == .codex else { return nil }
+        guard let projection = self.settings.codexVisibleAccountProjectionForMenuDisplay else { return nil }
+        guard projection.visibleAccounts.count > 1 else { return nil }
+        let showAll = self.settings.multiAccountMenuLayout == .stacked
+        let accounts = showAll
+            ? self.store.limitedCodexVisibleAccounts(
+                projection.visibleAccounts,
+                snapshots: self.store.codexAccountSnapshots,
+                activeVisibleAccountID: projection.activeVisibleAccountID)
+            : projection.visibleAccounts
+        let snapshots = showAll ? self.codexAccountSnapshots(matching: accounts) : []
+        return CodexAccountMenuDisplay(
+            accounts: accounts,
+            snapshots: snapshots,
+            activeVisibleAccountID: projection.activeVisibleAccountID,
+            layout: showAll ? .stacked : .segmented)
+    }
+
+    func scheduleCodexAccountMenuProjectionRevalidationIfNeeded(for providers: [UsageProvider]) {
+        guard Self.codexAccountMenuProjectionRevalidationEnabled else { return }
+        guard providers.contains(.codex) else { return }
+        guard self.settings.codexAccountMenuProjectionNeedsRevalidation else { return }
+        guard self.codexAccountMenuProjectionRevalidationTask == nil else { return }
+
+        self.codexAccountMenuProjectionRevalidationTask = Task { @MainActor [weak self] in
+            guard let settings = self?.settings else { return }
+            let result = await settings.revalidateCodexAccountMenuProjection()
+            guard let self else { return }
+            guard !Task.isCancelled else {
+                self.codexAccountMenuProjectionRevalidationTask = nil
+                return
+            }
+            self.codexAccountMenuProjectionRevalidationTask = nil
+
+            switch result {
+            case .updated:
+                self.invalidateMenus(refreshOpenMenus: false)
+            case .discarded, .skipped, .unchanged:
+                break
+            }
+        }
+    }
+
+    private func codexAccountSnapshots(matching accounts: [CodexVisibleAccount]) -> [CodexAccountUsageSnapshot] {
+        var snapshotsByID: [String: CodexAccountUsageSnapshot] = [:]
+        for snapshot in self.store.codexAccountSnapshots {
+            snapshotsByID[snapshot.id] = snapshot
+        }
+        return accounts.compactMap { snapshotsByID[$0.id] }
+    }
+
+    func stableCodexAccountMenuDisplay(
+        _ display: CodexAccountMenuDisplay?,
+        menu: NSMenu,
+        provider: UsageProvider) -> CodexAccountMenuDisplay?
+    {
+        guard provider == .codex else { return display }
+        guard display == nil else { return display }
+        guard self.openMenus[ObjectIdentifier(menu)] != nil else { return display }
+        guard menu.items.contains(where: { $0.view is CodexAccountSwitcherView }) else { return display }
+        guard let previous = self.lastCodexAccountMenuDisplay, previous.showSwitcher else { return display }
+        return previous
+    }
+}
diff --git a/Sources/CodexBar/StatusItemController+Actions.swift b/Sources/CodexBar/StatusItemController+Actions.swift
index efe63ffd86..cb4653c3f4 100644
--- a/Sources/CodexBar/StatusItemController+Actions.swift
+++ b/Sources/CodexBar/StatusItemController+Actions.swift
@@ -1,19 +1,220 @@
 import AppKit
 import CodexBarCore
 
-extension StatusItemController {
+enum LoginNotificationLogic {
+    static func notificationCopy(providerName: String) -> (title: String, body: String) {
+        (
+            L("login_success_notification_title", providerName),
+            L("login_success_notification_body"))
+    }
+}
+
+extension StatusItemController: StatusItemMenuPersistentActionDelegate {
     // MARK: - Actions reachable from menus
 
-    func refreshStore(forceTokenUsage: Bool) {
+    func refreshStore(
+        forceTokenUsage: Bool,
+        refreshOpenMenusWhenComplete: Bool = true,
+        interaction: ProviderInteraction = .userInitiated)
+    {
         Task {
-            await ProviderInteractionContext.$current.withValue(.userInitiated) {
-                await self.store.refresh(forceTokenUsage: forceTokenUsage)
+            await self.performStoreRefresh(
+                forceTokenUsage: forceTokenUsage,
+                refreshOpenMenusWhenComplete: refreshOpenMenusWhenComplete,
+                interaction: interaction)
+        }
+    }
+
+    func performStoreRefresh(
+        forceTokenUsage: Bool,
+        refreshOpenMenusWhenComplete: Bool,
+        interaction: ProviderInteraction) async
+    {
+        await ProviderInteractionContext.$current.withValue(interaction) {
+            await self.store.refresh(forceTokenUsage: forceTokenUsage)
+            guard !Task.isCancelled, !self.hasPreparedForAppShutdown else { return }
+            self.store.scheduleStorageFootprintRefreshForOverview(force: true)
+            if refreshOpenMenusWhenComplete {
+                self.refreshOpenMenusAfterExplicitStoreAction()
+            } else {
+                self.invalidateMenus()
             }
         }
     }
 
+    func performStoreRefresh(
+        for provider: UsageProvider,
+        refreshOpenMenusWhenComplete: Bool,
+        interaction: ProviderInteraction) async
+    {
+        await ProviderInteractionContext.$current.withValue(interaction) {
+            let refreshStartedAt = Date()
+            await self.store.refreshProvider(provider)
+            guard !Task.isCancelled, !self.hasPreparedForAppShutdown else { return }
+            await self.store.refreshProviderStatus(provider)
+            guard !Task.isCancelled, !self.hasPreparedForAppShutdown else { return }
+            await self.store.refreshTokenUsageNow(for: provider, force: true)
+            guard !Task.isCancelled, !self.hasPreparedForAppShutdown else { return }
+            if provider == .codex {
+                await self.store.refreshCreditsNow(minimumSnapshotUpdatedAt: refreshStartedAt)
+                guard !Task.isCancelled, !self.hasPreparedForAppShutdown else { return }
+                await self.store.refreshOpenAIDashboardIfNeeded(
+                    force: true,
+                    expectedGuard: self.store.freshCodexOpenAIWebRefreshGuard())
+                guard !Task.isCancelled, !self.hasPreparedForAppShutdown else { return }
+                if self.store.openAIDashboardRequiresLogin {
+                    await self.store.refreshProvider(.codex)
+                    guard !Task.isCancelled, !self.hasPreparedForAppShutdown else { return }
+                    await self.store.refreshCreditsNow(minimumSnapshotUpdatedAt: refreshStartedAt)
+                    guard !Task.isCancelled, !self.hasPreparedForAppShutdown else { return }
+                }
+            }
+            self.store.scheduleStorageFootprintRefresh(for: [provider], force: true)
+            self.store.persistWidgetSnapshot(reason: "provider-refresh")
+            if refreshOpenMenusWhenComplete {
+                self.refreshOpenMenusAfterExplicitStoreAction()
+            } else {
+                self.invalidateMenus()
+            }
+        }
+    }
+
+    func refreshOpenMenusAfterExplicitStoreAction() {
+        self.invalidateMenus(
+            refreshOpenMenus: true,
+            deferOpenParentMenuRebuild: true)
+    }
+
     @objc func refreshNow() {
-        self.refreshStore(forceTokenUsage: true)
+        self.startManualRefresh(for: nil)
+    }
+
+    @objc func refreshMenuItem(_ sender: NSMenuItem) {
+        self.refreshMenuProviderNow(in: sender.menu)
+    }
+
+    func refreshMenuProviderNow(in menu: NSMenu?) {
+        guard let provider = self.manualRefreshProvider(for: menu) else {
+            self.startManualRefresh(for: nil)
+            return
+        }
+        self.startManualRefresh(for: provider)
+    }
+
+    private func refreshMenuProviderNow(menuID: ObjectIdentifier) {
+        if let menu = self.openMenus[menuID] {
+            self.refreshMenuProviderNow(in: menu)
+        } else if let mergedMenu = self.mergedMenu, ObjectIdentifier(mergedMenu) == menuID {
+            self.refreshMenuProviderNow(in: mergedMenu)
+        } else if let provider = self.menuProviders[menuID] {
+            self.startManualRefresh(for: provider)
+        } else {
+            self.startManualRefresh(for: nil)
+        }
+    }
+
+    private func startManualRefresh(for provider: UsageProvider?) {
+        let scopedRefreshInFlight = provider.map { self.store.refreshingProviders.contains($0) }
+            ?? !self.store.refreshingProviders.isEmpty
+        guard !self.hasPreparedForAppShutdown,
+              self.manualRefreshTask == nil,
+              !self.store.isRefreshing,
+              !scopedRefreshInFlight
+        else { return }
+
+        let frozenModels = self.frozenManualRefreshMenuCardModels()
+        let task = Task { @MainActor [weak self] in
+            guard let self else { return }
+            defer {
+                self.manualRefreshTask = nil
+                self.manualRefreshProvider = nil
+                self.menuCardRefreshMonitor.endManualRefresh()
+                self.updatePersistentRefreshItemsEnabled()
+                self.prepareAttachedClosedMenusIfNeeded()
+            }
+            guard !Task.isCancelled, !self.hasPreparedForAppShutdown else { return }
+            #if DEBUG
+            if let operation = self._test_manualRefreshOperation {
+                await operation()
+                guard !Task.isCancelled, !self.hasPreparedForAppShutdown else { return }
+                return
+            }
+            #endif
+            if let provider {
+                await self.performStoreRefresh(
+                    for: provider,
+                    refreshOpenMenusWhenComplete: true,
+                    interaction: .userInitiated)
+            } else {
+                await self.performStoreRefresh(
+                    forceTokenUsage: true,
+                    refreshOpenMenusWhenComplete: true,
+                    interaction: .userInitiated)
+            }
+        }
+        self.manualRefreshProvider = provider
+        self.manualRefreshTask = task
+        self.menuCardRefreshMonitor.beginManualRefresh(frozenModels: frozenModels, provider: provider)
+        self.updatePersistentRefreshItemsEnabled()
+    }
+
+    private func manualRefreshProvider(for menu: NSMenu?) -> UsageProvider? {
+        guard let menu else { return nil }
+        if self.shouldMergeIcons {
+            guard self.mergedMenu == nil || menu === self.mergedMenu else { return nil }
+            guard !self.isMergedOverviewSelected(in: menu) else { return nil }
+            return self.resolvedMenuProvider()
+        }
+        return self.menuProviders[ObjectIdentifier(menu)]
+    }
+
+    private func frozenManualRefreshMenuCardModels() -> [UsageProvider: UsageMenuCardView.Model] {
+        var providers = self.store.enabledProvidersForDisplay()
+        if let lastMenuProvider,
+           !providers.contains(lastMenuProvider)
+        {
+            providers.append(lastMenuProvider)
+        }
+        if providers.isEmpty,
+           let defaultProvider = self.settings.orderedProviders().first ?? UsageProvider.allCases.first
+        {
+            providers.append(defaultProvider)
+        }
+
+        var models: [UsageProvider: UsageMenuCardView.Model] = [:]
+        for provider in providers {
+            models[provider] = self.menuCardModel(for: provider)
+        }
+        return models
+    }
+
+    nonisolated func performPersistentRefreshAction(in menuID: ObjectIdentifier) {
+        Task { @MainActor [weak self] in
+            guard let self else { return }
+            self.refreshMenuProviderNow(menuID: menuID)
+        }
+    }
+
+    nonisolated func performPersistentSettingsAction() {
+        Task { @MainActor [weak self] in
+            guard let self else { return }
+            self.closeOpenMenusFromShortcutIfNeeded()
+            self.showSettingsGeneral()
+        }
+    }
+
+    nonisolated func performPersistentQuitAction() {
+        Task { @MainActor [weak self] in
+            guard let self else { return }
+            self.closeOpenMenusFromShortcutIfNeeded()
+            self.quit()
+        }
+    }
+
+    nonisolated func performProviderNavigation(_ direction: StatusItemMenuProviderNavigationDirection) {
+        Task { @MainActor [weak self] in
+            self?.navigateProviderSwitcher(direction)
+        }
     }
 
     @objc func refreshAugmentSession() {
@@ -23,11 +224,12 @@ extension StatusItemController {
             await ProviderInteractionContext.$current.withValue(.userInitiated) {
                 await self.store.refresh(forceTokenUsage: false)
             }
+            self.refreshOpenMenusAfterExplicitStoreAction()
         }
     }
 
     @objc func installUpdate() {
-        self.updater.checkForUpdates(nil)
+        self.updater.installUpdate()
     }
 
     @objc func openDashboard() {
@@ -35,17 +237,40 @@ extension StatusItemController {
             ?? (self.store.isEnabled(.codex) ? .codex : self.store.enabledProviders().first)
 
         let provider = preferred ?? .codex
-        let meta = self.store.metadata(for: provider)
+        guard let url = self.dashboardURL(for: provider) else { return }
+        NSWorkspace.shared.open(url)
+    }
+
+    func dashboardURL(
+        for provider: UsageProvider,
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> URL?
+    {
+        if provider == .alibaba {
+            return self.settings.alibabaCodingPlanAPIRegion.dashboardURL
+        }
+        if provider == .minimax {
+            return self.settings.minimaxAPIRegion.dashboardURL
+        }
+
+        if provider == .opencodego {
+            return self.settings.opencodegoDashboardURL
+        }
 
-        // For Claude, route subscription users to claude.ai/settings/usage instead of console billing
+        if provider == .zai {
+            return ZaiUsageFetcher.resolveDashboardURL(
+                region: self.settings.zaiAPIRegion,
+                environment: environment)
+        }
+
+        let meta = self.store.metadata(for: provider)
         let urlString: String? = if provider == .claude, self.store.isClaudeSubscription() {
             meta.subscriptionDashboardURL ?? meta.dashboardURL
         } else {
             meta.dashboardURL
         }
 
-        guard let urlString, let url = URL(string: urlString) else { return }
-        NSWorkspace.shared.open(url)
+        guard let urlString else { return nil }
+        return URL(string: urlString)
     }
 
     @objc func openCreditsPurchase() {
@@ -62,18 +287,40 @@ extension StatusItemController {
 
         let autoStart = true
         let accountEmail = self.store.codexAccountEmailForOpenAIDashboard()
+        let cacheScope = self.store.codexCookieCacheScopeForOpenAIWeb()
+        guard OpenAICreditsPurchaseWindowController.canOpenPurchaseWindow(
+            accountEmail: accountEmail,
+            cacheScope: cacheScope)
+        else {
+            self.creditsPurchaseWindow?.close()
+            self.creditsPurchaseWindow = nil
+            return
+        }
         let controller = self.creditsPurchaseWindow ?? OpenAICreditsPurchaseWindowController()
-        controller.show(purchaseURL: url, accountEmail: accountEmail, autoStartPurchase: autoStart)
+        controller.show(
+            purchaseURL: url,
+            accountEmail: accountEmail,
+            cacheScope: cacheScope,
+            autoStartPurchase: autoStart)
         self.creditsPurchaseWindow = controller
     }
 
-    private static func sanitizedCreditsPurchaseURL(_ raw: String?) -> String? {
+    static func sanitizedCreditsPurchaseURL(_ raw: String?) -> String? {
         guard let raw, let url = URL(string: raw) else { return nil }
-        guard let host = url.host?.lowercased(), host.contains("chatgpt.com") else { return nil }
-        let path = url.path.lowercased()
+        guard Self.isAllowedChatGPTPurchaseHost(url) else { return nil }
+        let pathComponents = url.pathComponents.map { $0.lowercased() }
         let allowed = ["settings", "usage", "billing", "credits"]
-        guard allowed.contains(where: { path.contains($0) }) else { return nil }
-        return url.absoluteString
+        guard pathComponents.contains(where: { allowed.contains($0) }) else { return nil }
+        var components = URLComponents(url: url, resolvingAgainstBaseURL: false)
+        components?.query = nil
+        components?.fragment = nil
+        return components?.url?.absoluteString ?? url.absoluteString
+    }
+
+    private static func isAllowedChatGPTPurchaseHost(_ url: URL) -> Bool {
+        guard url.scheme?.lowercased() == "https" else { return false }
+        guard let host = url.host?.lowercased() else { return false }
+        return host == "chatgpt.com" || host.hasSuffix(".chatgpt.com")
     }
 
     @objc func openStatusPage() {
@@ -87,9 +334,19 @@ extension StatusItemController {
         NSWorkspace.shared.open(url)
     }
 
+    @objc func openChangelog() {
+        let preferred = self.lastMenuProvider
+            ?? (self.store.isEnabled(.codex) ? .codex : self.store.enabledProviders().first)
+
+        let provider = preferred ?? .codex
+        let meta = self.store.metadata(for: provider)
+        guard let urlString = meta.changelogURL, let url = URL(string: urlString) else { return }
+        NSWorkspace.shared.open(url)
+    }
+
     @objc func openTerminalCommand(_ sender: NSMenuItem) {
         let command = sender.representedObject as? String ?? "claude"
-        Self.openTerminal(command: command)
+        self.openTerminal(command: command)
     }
 
     @objc func openLoginToProvider(_ sender: NSMenuItem) {
@@ -98,6 +355,50 @@ extension StatusItemController {
         NSWorkspace.shared.open(url)
     }
 
+    @objc func addManagedCodexAccountFromMenu(_: NSMenuItem) {
+        guard self.codexAccountPromotionCoordinator.isInteractionBlocked() == false else {
+            self.loginLogger.info("Add Account tap ignored: Codex account change already in-flight")
+            return
+        }
+        guard self.settings.hasUnreadableManagedCodexAccountStore == false else {
+            self.presentLoginAlert(
+                title: L("Managed Codex accounts unavailable"),
+                message: L(
+                    "CodexBar could not read managed account storage. " +
+                        "Recover the store before adding another account."))
+            return
+        }
+
+        Task { @MainActor [weak self] in
+            guard let self else { return }
+            do {
+                let account = try await self.managedCodexAccountCoordinator.authenticateManagedAccount()
+                self.settings.selectAuthenticatedManagedCodexAccount(account)
+                await ProviderInteractionContext.$current.withValue(.userInitiated) {
+                    await self.store.refreshCodexAccountScopedState(allowDisabled: true)
+                }
+            } catch {
+                self.presentManagedCodexAccountError(error)
+            }
+        }
+    }
+
+    @objc func requestCodexSystemPromotionFromMenu(_ sender: NSMenuItem) {
+        guard let rawManagedAccountID = sender.representedObject as? String,
+              let managedAccountID = UUID(uuidString: rawManagedAccountID)
+        else {
+            return
+        }
+
+        Task { @MainActor [weak self] in
+            guard let self else { return }
+            let result = await self.codexAccountPromotionCoordinator.promote(managedAccountID: managedAccountID)
+            if case let .failure(error) = result {
+                self.presentLoginAlert(title: error.title, message: error.message)
+            }
+        }
+    }
+
     @objc func runSwitchAccount(_ sender: NSMenuItem) {
         if self.loginTask != nil {
             self.loginLogger.info("Switch Account tap ignored: login already in-flight")
@@ -107,25 +408,18 @@ extension StatusItemController {
         let rawProvider = sender.representedObject as? String
         let provider = rawProvider.flatMap(UsageProvider.init(rawValue:)) ?? self.lastMenuProvider ?? .codex
         self.loginLogger.info("Switch Account tapped", metadata: ["provider": provider.rawValue])
+        self.startLoginFlow(provider: provider)
+    }
 
-        self.loginTask = Task { @MainActor [weak self] in
-            guard let self else { return }
-            defer {
-                self.activeLoginProvider = nil
-                self.loginTask = nil
-            }
-            self.activeLoginProvider = provider
-            self.loginPhase = .requesting
-            self.loginLogger.info("Starting login task", metadata: ["provider": provider.rawValue])
-
-            let shouldRefresh = await self.runLoginFlow(provider: provider)
-            if shouldRefresh {
-                await ProviderInteractionContext.$current.withValue(.userInitiated) {
-                    await self.store.refresh()
-                }
-                self.loginLogger.info("Triggered refresh after login", metadata: ["provider": provider.rawValue])
-            }
+    func runLoginFlowFromSettings(provider: UsageProvider) async {
+        guard self.loginTask == nil else {
+            self.loginLogger.info(
+                "Settings login tap ignored: login already in-flight",
+                metadata: ["provider": provider.rawValue])
+            return
         }
+        self.startLoginFlow(provider: provider)
+        await self.loginTask?.value
     }
 
     @objc func showSettingsGeneral() {
@@ -137,6 +431,10 @@ extension StatusItemController {
     }
 
     func openMenuFromShortcut() {
+        if self.closeOpenMenusFromShortcutIfNeeded() {
+            return
+        }
+
         if self.shouldMergeIcons {
             self.statusItem.button?.performClick(nil)
             return
@@ -148,6 +446,38 @@ extension StatusItemController {
         item.button?.performClick(nil)
     }
 
+    @discardableResult
+    func closeOpenMenusFromShortcutIfNeeded() -> Bool {
+        guard !self.openMenus.isEmpty else { return false }
+
+        let menus = Array(self.openMenus.values)
+        for menu in menus {
+            menu.cancelTrackingWithoutAnimation()
+            self.forgetClosedMenu(menu)
+        }
+        return true
+    }
+
+    func celebrationOriginPoint(for provider: UsageProvider?) -> CGPoint? {
+        let item: NSStatusItem = if self.shouldMergeIcons {
+            self.statusItem
+        } else if let provider, let existing = self.statusItems[provider], existing.isVisible {
+            existing
+        } else {
+            self.lazyStatusItem(for: provider ?? .codex)
+        }
+
+        guard let button = item.button,
+              let window = button.window
+        else {
+            return nil
+        }
+
+        let buttonFrameInWindow = button.convert(button.bounds, to: nil)
+        let screenFrame = window.convertToScreen(buttonFrameInWindow)
+        return CGPoint(x: screenFrame.midX, y: screenFrame.midY)
+    }
+
     private func openSettings(tab: PreferencesTab) {
         DispatchQueue.main.async {
             self.preferencesSelection.tab = tab
@@ -160,7 +490,16 @@ extension StatusItemController {
     }
 
     @objc func quit() {
-        NSApp.terminate(nil)
+        let openMenus = Array(self.openMenus.values)
+        for menu in openMenus {
+            menu.cancelTrackingWithoutAnimation()
+        }
+
+        self.scheduleQuitTermination { [weak self] in
+            guard let self else { return }
+            self.prepareForAppShutdown()
+            self.terminateApplicationForQuit()
+        }
     }
 
     @objc func copyError(_ sender: NSMenuItem) {
@@ -171,25 +510,48 @@ extension StatusItemController {
         }
     }
 
-    private static func openTerminal(command: String) {
-        let escaped = command
-            .replacingOccurrences(of: "\\\\", with: "\\\\\\\\")
-            .replacingOccurrences(of: "\"", with: "\\\"")
-        let script = """
-        tell application "Terminal"
-            activate
-            do script "\(escaped)"
-        end tell
-        """
-        if let appleScript = NSAppleScript(source: script) {
+    func openTerminal(command: String) {
+        let terminal = self.settings.terminalApp
+
+        if terminal == .iTerm, !terminal.isInstalled {
+            CodexBarLog.logger(LogCategories.terminal).warning(
+                "iTerm is not installed, falling back to Terminal.app",
+                metadata: ["terminal": terminal.rawValue])
+            Self.openTerminalInDefaultTerminal(command: command)
+            return
+        }
+
+        if Self.executeAppleScript(terminal.appleScript(command: command)) {
+            return
+        }
+        guard terminal != .terminal else { return }
+
+        CodexBarLog.logger(LogCategories.terminal).warning(
+            "\(terminal.label) AppleScript failed, falling back to Terminal.app",
+            metadata: ["terminal": terminal.rawValue])
+        Self.openTerminalInDefaultTerminal(command: command)
+    }
+
+    private static func openTerminalInDefaultTerminal(command: String) {
+        self.executeAppleScript(TerminalApp.terminal.appleScript(command: command))
+    }
+
+    /// Executes an AppleScript and returns `true` on success, `false` on failure.
+    @discardableResult
+    private static func executeAppleScript(_ source: String) -> Bool {
+        if let appleScript = NSAppleScript(source: source) {
             var error: NSDictionary?
             appleScript.executeAndReturnError(&error)
             if let error {
                 CodexBarLog.logger(LogCategories.terminal).error(
-                    "Failed to open Terminal",
+                    "Failed to execute AppleScript",
                     metadata: ["error": String(describing: error)])
+                return false
             }
+            return true
         }
+        CodexBarLog.logger(LogCategories.terminal).error("Failed to compile AppleScript")
+        return false
     }
 
     private func resolvedShortcutProvider() -> UsageProvider {
@@ -202,25 +564,46 @@ extension StatusItemController {
         return .codex
     }
 
+    private func startLoginFlow(provider: UsageProvider) {
+        self.loginTask = Task { @MainActor [weak self] in
+            guard let self else { return }
+            defer {
+                self.activeLoginProvider = nil
+                self.loginTask = nil
+            }
+            self.activeLoginProvider = provider
+            self.loginPhase = .requesting
+            self.loginLogger.info("Starting login task", metadata: ["provider": provider.rawValue])
+
+            let shouldRefresh = await self.runLoginFlow(provider: provider)
+            if shouldRefresh {
+                await ProviderInteractionContext.$current.withValue(.userInitiated) {
+                    await self.store.refresh()
+                }
+                self.loginLogger.info("Triggered refresh after login", metadata: ["provider": provider.rawValue])
+            }
+        }
+    }
+
     func presentCodexLoginResult(_ result: CodexLoginRunner.Result) {
-        switch result.outcome {
-        case .success:
-            return
-        case .missingBinary:
-            self.presentLoginAlert(
-                title: "Codex CLI not found",
-                message: "Install the Codex CLI (npm i -g @openai/codex) and try again.")
-        case let .launchFailed(message):
-            self.presentLoginAlert(title: "Could not start codex login", message: message)
-        case .timedOut:
-            self.presentLoginAlert(
-                title: "Codex login timed out",
-                message: self.trimmedLoginOutput(result.output))
-        case let .failed(status):
-            let statusLine = "codex login exited with status \(status)."
-            let message = self.trimmedLoginOutput(result.output.isEmpty ? statusLine : result.output)
-            self.presentLoginAlert(title: "Codex login failed", message: message)
+        guard let info = CodexLoginAlertPresentation.alertInfo(for: result) else { return }
+        self.presentLoginAlert(title: info.title, message: info.message)
+    }
+
+    private func presentManagedCodexAccountError(_ error: Error) {
+        let info = if let error = error as? ManagedCodexAccountCoordinatorError,
+                      error == .authenticationInProgress
+        {
+            LoginAlertInfo(
+                title: L("Codex account login already running"),
+                message: L("Wait for the current managed Codex login to finish before adding another account."))
+        } else if let error = error as? ManagedCodexAccountServiceError {
+            LoginAlertInfo(title: L("Could not add Codex account"), message: error.userFacingMessage)
+        } else {
+            LoginAlertInfo(title: L("Could not add Codex account"), message: error.localizedDescription)
         }
+
+        self.presentLoginAlert(title: info.title, message: info.message)
     }
 
     func presentClaudeLoginResult(_ result: ClaudeLoginRunner.Result) {
@@ -229,18 +612,18 @@ extension StatusItemController {
             return
         case .missingBinary:
             self.presentLoginAlert(
-                title: "Claude CLI not found",
-                message: "Install the Claude CLI (npm i -g @anthropic-ai/claude-code) and try again.")
+                title: L("Claude CLI not found"),
+                message: L("Install the Claude CLI (npm i -g @anthropic-ai/claude-code) and try again."))
         case let .launchFailed(message):
-            self.presentLoginAlert(title: "Could not start claude /login", message: message)
+            self.presentLoginAlert(title: L("Could not start claude /login"), message: message)
         case .timedOut:
             self.presentLoginAlert(
-                title: "Claude login timed out",
+                title: L("Claude login timed out"),
                 message: self.trimmedLoginOutput(result.output))
         case let .failed(status):
-            let statusLine = "claude /login exited with status \(status)."
+            let statusLine = String(format: L("claude /login exited with status %d."), status)
             let message = self.trimmedLoginOutput(result.output.isEmpty ? statusLine : result.output)
-            self.presentLoginAlert(title: "Claude login failed", message: message)
+            self.presentLoginAlert(title: L("Claude login failed"), message: message)
         }
     }
 
@@ -272,12 +655,32 @@ extension StatusItemController {
         }
     }
 
+    func describe(_ outcome: AntigravityLoginRunner.Result.Outcome) -> String {
+        switch outcome {
+        case let .success(email):
+            "success(email: \(email ?? "nil"))"
+        case .cancelled:
+            "cancelled"
+        case .timedOut:
+            "timedOut"
+        case let .launchFailed(message):
+            "launchFailed(\(message))"
+        case let .failed(message):
+            "failed(\(message))"
+        }
+    }
+
     func presentGeminiLoginResult(_ result: GeminiLoginRunner.Result) {
         guard let info = Self.geminiLoginAlertInfo(for: result) else { return }
         self.presentLoginAlert(title: info.title, message: info.message)
     }
 
-    struct LoginAlertInfo: Equatable, Sendable {
+    func presentAntigravityLoginResult(_ result: AntigravityLoginRunner.Result) {
+        guard let info = Self.antigravityLoginAlertInfo(for: result) else { return }
+        self.presentLoginAlert(title: info.title, message: info.message)
+    }
+
+    struct LoginAlertInfo: Equatable {
         let title: String
         let message: String
     }
@@ -288,17 +691,34 @@ extension StatusItemController {
             nil
         case .missingBinary:
             LoginAlertInfo(
-                title: "Gemini CLI not found",
-                message: "Install the Gemini CLI (npm i -g @google/gemini-cli) and try again.")
+                title: L("Gemini CLI not found"),
+                message: L("Install the Gemini CLI (npm i -g @google/gemini-cli) and try again."))
         case let .launchFailed(message):
-            LoginAlertInfo(title: "Could not open Terminal for Gemini", message: message)
+            LoginAlertInfo(title: L("Could not open Terminal for Gemini"), message: message)
+        }
+    }
+
+    nonisolated static func antigravityLoginAlertInfo(for result: AntigravityLoginRunner.Result) -> LoginAlertInfo? {
+        switch result.outcome {
+        case .success, .cancelled:
+            nil
+        case .timedOut:
+            LoginAlertInfo(
+                title: L("Antigravity login timed out"),
+                message: L("The browser login did not complete in time. Try Antigravity login again."))
+        case let .launchFailed(message):
+            LoginAlertInfo(
+                title: L("Could not open browser for Antigravity"),
+                message: String(format: L("Open this URL manually to continue login:\n\n%@"), message))
+        case let .failed(message):
+            LoginAlertInfo(title: L("Antigravity login failed"), message: message)
         }
     }
 
     func presentLoginAlert(title: String, message: String) {
         let alert = NSAlert()
-        alert.messageText = title
-        alert.informativeText = message
+        alert.messageText = L(title)
+        alert.informativeText = L(message)
         alert.alertStyle = .warning
         alert.runModal()
     }
@@ -306,7 +726,7 @@ extension StatusItemController {
     private func trimmedLoginOutput(_ text: String) -> String {
         let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
         let limit = 600
-        if trimmed.isEmpty { return "No output captured." }
+        if trimmed.isEmpty { return L("No output captured.") }
         if trimmed.count <= limit { return trimmed }
         let idx = trimmed.index(trimmed.startIndex, offsetBy: limit)
         return "\(trimmed[..<idx])…"
@@ -314,8 +734,7 @@ extension StatusItemController {
 
     func postLoginNotification(for provider: UsageProvider) {
         let name = ProviderDescriptorRegistry.descriptor(for: provider).metadata.displayName
-        let title = "\(name) login successful"
-        let body = "You can return to the app; authentication finished."
+        let (title, body) = LoginNotificationLogic.notificationCopy(providerName: name)
         AppNotifications.shared.post(idPrefix: "login-\(provider.rawValue)", title: title, body: body)
     }
 
@@ -327,7 +746,7 @@ extension StatusItemController {
             // User closed the window; no alert needed
             return
         case let .failed(message):
-            self.presentLoginAlert(title: "Cursor login failed", message: message)
+            self.presentLoginAlert(title: L("Cursor login failed"), message: message)
         }
     }
 
diff --git a/Sources/CodexBar/StatusItemController+Animation.swift b/Sources/CodexBar/StatusItemController+Animation.swift
index 960d9cf6ac..7e0d4c3d21 100644
--- a/Sources/CodexBar/StatusItemController+Animation.swift
+++ b/Sources/CodexBar/StatusItemController+Animation.swift
@@ -6,7 +6,10 @@ extension StatusItemController {
     private static let loadingPercentEpsilon = 0.0001
     private static let blinkActiveTickInterval: Duration = .milliseconds(75)
     private static let blinkIdleFallbackInterval: Duration = .seconds(1)
-
+    static let loadingAnimationFPS: Double = 30.0
+    static let loadingAnimationPhaseIncrement: Double =
+        2.7 / StatusItemController.loadingAnimationFPS
+    private static let loadingAnimationMaxContinuousDuration: TimeInterval = 30.0
     func needsMenuBarIconAnimation() -> Bool {
         if self.shouldMergeIcons {
             let primaryProvider = self.primaryProviderForUnifiedIcon()
@@ -16,6 +19,9 @@ extension StatusItemController {
     }
 
     func updateBlinkingState() {
+        #if DEBUG
+        guard !self.isReleasedForTesting else { return }
+        #endif
         // During the loading animation, blink ticks can overwrite the animated menu bar icon and cause flicker.
         if self.needsMenuBarIconAnimation() {
             self.stopBlinking()
@@ -23,11 +29,11 @@ extension StatusItemController {
         }
 
         let blinkingEnabled = self.isBlinkingAllowed()
-        // Cache enabled providers to avoid repeated enablement lookups.
-        let enabledProviders = self.store.enabledProviders()
-        let anyEnabled = !enabledProviders.isEmpty || self.store.debugForceAnimation
+        // Use display list so merged-mode visibility stays consistent with shouldMergeIcons.
+        let displayProviders = self.store.enabledProvidersForDisplay()
+        let anyEnabled = !displayProviders.isEmpty || self.store.debugForceAnimation
         let anyVisible = UsageProvider.allCases.contains { self.isVisible($0) }
-        let mergeIcons = self.settings.mergeIcons && enabledProviders.count > 1
+        let mergeIcons = self.shouldMergeIcons
         let shouldBlink = mergeIcons ? anyEnabled : anyVisible
         if blinkingEnabled, shouldBlink {
             if self.blinkTask == nil {
@@ -35,7 +41,8 @@ extension StatusItemController {
                 self.blinkTask = Task { [weak self] in
                     while !Task.isCancelled {
                         let delay = await MainActor.run {
-                            self?.blinkTickSleepDuration(now: Date()) ?? Self.blinkIdleFallbackInterval
+                            self?.blinkTickSleepDuration(now: Date())
+                                ?? Self.blinkIdleFallbackInterval
                         }
                         try? await Task.sleep(for: delay)
                         await MainActor.run { self?.tickBlink() }
@@ -50,7 +57,8 @@ extension StatusItemController {
     private func seedBlinkStatesIfNeeded() {
         let now = Date()
         for provider in UsageProvider.allCases where self.blinkStates[provider] == nil {
-            self.blinkStates[provider] = BlinkState(nextBlink: now.addingTimeInterval(BlinkState.randomDelay()))
+            self.blinkStates[provider] = BlinkState(
+                nextBlink: now.addingTimeInterval(BlinkState.randomDelay()))
         }
     }
 
@@ -74,10 +82,13 @@ extension StatusItemController {
 
         for provider in UsageProvider.allCases {
             let shouldRender = mergeIcons ? self.isEnabled(provider) : self.isVisible(provider)
-            guard shouldRender, !self.shouldAnimate(provider: provider, mergeIcons: mergeIcons) else { continue }
+            guard shouldRender, !self.shouldAnimate(provider: provider, mergeIcons: mergeIcons)
+            else { continue }
 
-            let state = self
-                .blinkStates[provider] ?? BlinkState(nextBlink: now.addingTimeInterval(BlinkState.randomDelay()))
+            let state =
+                self
+                    .blinkStates[provider]
+                    ?? BlinkState(nextBlink: now.addingTimeInterval(BlinkState.randomDelay()))
             if state.blinkStart != nil {
                 return Self.blinkActiveTickInterval
             }
@@ -112,13 +123,16 @@ extension StatusItemController {
 
         for provider in UsageProvider.allCases {
             let shouldRender = mergeIcons ? self.isEnabled(provider) : self.isVisible(provider)
-            guard shouldRender, !self.shouldAnimate(provider: provider, mergeIcons: mergeIcons) else {
+            guard shouldRender, !self.shouldAnimate(provider: provider, mergeIcons: mergeIcons)
+            else {
                 self.clearMotion(for: provider)
                 continue
             }
 
-            var state = self
-                .blinkStates[provider] ?? BlinkState(nextBlink: now.addingTimeInterval(BlinkState.randomDelay()))
+            var state =
+                self
+                    .blinkStates[provider]
+                    ?? BlinkState(nextBlink: now.addingTimeInterval(BlinkState.randomDelay()))
 
             if let pendingSecond = state.pendingSecondStart, now >= pendingSecond {
                 state.blinkStart = now
@@ -146,7 +160,8 @@ extension StatusItemController {
                 state.blinkStart = now
                 state.effect = self.randomEffect(for: provider)
                 if state.effect == .blink, Double.random(in: 0...1) < doubleBlinkChance {
-                    state.pendingSecondStart = now.addingTimeInterval(Double.random(in: doubleDelayRange))
+                    state.pendingSecondStart = now.addingTimeInterval(
+                        Double.random(in: doubleDelayRange))
                 }
                 self.clearMotion(for: provider)
             } else {
@@ -159,8 +174,7 @@ extension StatusItemController {
             }
         }
         if mergeIcons {
-            let phase: Double? = self.needsMenuBarIconAnimation() ? self.animationPhase : nil
-            self.applyIcon(phase: phase)
+            self.applyIcon(phase: nil)
         }
     }
 
@@ -217,37 +231,36 @@ extension StatusItemController {
         return false
     }
 
-    func applyIcon(phase: Double?) {
-        guard let button = self.statusItem.button else { return }
+    @discardableResult
+    func applyIcon(
+        phase: Double?,
+        bypassMergedMenuTrackingDeferral: Bool = false) -> Bool
+    {
+        guard let button = self.statusItem.button else { return false }
+        if !bypassMergedMenuTrackingDeferral,
+           self.deferMergedIconRenderDuringMenuTrackingIfNeeded() { return true }
 
         let style = self.store.iconStyle
         let showUsed = self.settings.usageBarsShowUsed
         let showBrandPercent = self.settings.menuBarShowsBrandIconWithPercent
         let primaryProvider = self.primaryProviderForUnifiedIcon()
+        let resolverStyle = self.store.style(for: primaryProvider)
         let snapshot = self.store.snapshot(for: primaryProvider)
+        let warningFlash = self.quotaWarningFlashActive(provider: primaryProvider)
 
         // IconRenderer treats these values as a left-to-right "progress fill" percentage; depending on the
         // user setting we pass either "percent left" or "percent used".
-        var primary = showUsed ? snapshot?.primary?.usedPercent : snapshot?.primary?.remainingPercent
-        var weekly = showUsed ? snapshot?.secondary?.usedPercent : snapshot?.secondary?.remainingPercent
-        if showUsed,
-           primaryProvider == .warp,
-           let remaining = snapshot?.secondary?.remainingPercent,
-           remaining <= 0
-        {
-            // Preserve Warp "no bonus/exhausted bonus" layout even in show-used mode.
-            weekly = 0
-        }
-        if showUsed,
-           primaryProvider == .warp,
-           let remaining = snapshot?.secondary?.remainingPercent,
-           remaining > 0,
-           weekly == 0
-        {
-            // In show-used mode, `0` means "unused", not "missing". Keep the weekly lane present.
-            weekly = Self.loadingPercentEpsilon
+        let resolved = snapshot.map {
+            IconRemainingResolver.resolvedPercents(
+                snapshot: $0,
+                style: resolverStyle,
+                showUsed: showUsed,
+                renderingStyle: style,
+                secondaryOverrideWindowID: self.settings.copilotIconSecondaryWindowOverrideID(snapshot: $0))
         }
-        var credits: Double? = primaryProvider == .codex ? self.store.credits?.remaining : nil
+        var primary = resolved?.primary
+        var weekly = resolved?.secondary
+        var credits = self.menuBarCreditsRemainingForIcon(provider: primaryProvider, snapshot: snapshot)
         var stale = self.store.isStale(provider: primaryProvider)
         var morphProgress: Double?
 
@@ -267,7 +280,9 @@ extension StatusItemController {
                 // Keep loading animation layout stable: IconRenderer uses `weeklyRemaining > 0` to switch layouts,
                 // so hitting an exact 0 would flip between "normal" and "weekly exhausted" rendering.
                 primary = max(pattern.value(phase: phase), Self.loadingPercentEpsilon)
-                weekly = max(pattern.value(phase: phase + pattern.secondaryOffset), Self.loadingPercentEpsilon)
+                weekly = max(
+                    pattern.value(phase: phase + pattern.secondaryOffset),
+                    Self.loadingPercentEpsilon)
                 credits = nil
                 stale = false
             }
@@ -275,40 +290,85 @@ extension StatusItemController {
 
         let blink: CGFloat = style == .combined ? 0 : self.blinkAmount(for: primaryProvider)
         let wiggle: CGFloat = style == .combined ? 0 : self.wiggleAmount(for: primaryProvider)
-        let tilt: CGFloat = style == .combined ? 0 : self.tiltAmount(for: primaryProvider) * .pi / 28
-
-        let statusIndicator: ProviderStatusIndicator = {
-            for provider in self.store.enabledProviders() {
-                let indicator = self.store.statusIndicator(for: provider)
-                if indicator.hasIssue { return indicator }
-            }
-            return .none
-        }()
+        let tilt: CGFloat =
+            style == .combined ? 0 : self.tiltAmount(for: primaryProvider) * .pi / 28
 
+        let statusIndicator = self.store.statusIndicator(for: primaryProvider)
         if showBrandPercent,
            let brand = ProviderBrandIcon.image(for: primaryProvider)
         {
             let displayText = self.menuBarDisplayText(for: primaryProvider, snapshot: snapshot)
-            self.setButtonImage(brand, for: button)
-            self.setButtonTitle(displayText, for: button)
-            return
-        }
-
-        if Self.shouldUseOpenRouterBrandFallback(provider: primaryProvider, snapshot: snapshot),
-           let brand = ProviderBrandIcon.image(for: primaryProvider)
-        {
-            self.setButtonTitle(nil, for: button)
+            let signature = [
+                "mode=brandPercent",
+                "provider=\(primaryProvider.rawValue)",
+                "style=\(String(describing: style))",
+                "primary=\(Self.iconSignatureValue(primary))",
+                "weekly=\(Self.iconSignatureValue(weekly))",
+                "credits=\(Self.iconSignatureValue(credits))",
+                "stale=\(stale ? "1" : "0")",
+                "status=\(statusIndicator.rawValue)",
+                "text=\(displayText ?? "nil")",
+                "warningFlash=\(warningFlash ? "1" : "0")",
+                "anim=\(needsAnimation ? "1" : "0")",
+                "hideCritters=\(self.settings.menuBarHidesCritters ? "1" : "0")",
+            ].joined(separator: "|")
+            if self.shouldSkipMergedIconRender(signature) {
+                // AppKit can lose button title/image-position state independently of the cached render signature.
+                // Keep the cheap title path self-healing even when the icon image itself can be skipped.
+                self.setButtonTitle(displayText, for: button)
+                self.noteIconPerfRender(skipped: true)
+                return true
+            }
             self.setButtonImage(
-                Self.brandImageWithStatusOverlay(brand: brand, statusIndicator: statusIndicator),
-                for: button)
-            return
+                warningFlash ? Self.quotaWarningFlashImage(base: brand) : brand, for: button)
+            self.setButtonTitle(displayText, for: button)
+            self.noteIconPerfRender(skipped: false)
+            return false
         }
 
         self.setButtonTitle(nil, for: button)
         if let morphProgress {
-            let image = IconRenderer.makeMorphIcon(progress: morphProgress, style: style)
-            self.setButtonImage(image, for: button)
+            let signature = [
+                "mode=morph",
+                "provider=\(primaryProvider.rawValue)",
+                "style=\(String(describing: style))",
+                "morph=\(Self.iconSignatureValue(morphProgress))",
+                "status=\(statusIndicator.rawValue)",
+                "warningFlash=\(warningFlash ? "1" : "0")",
+                "anim=\(needsAnimation ? "1" : "0")",
+                "hideCritters=\(self.settings.menuBarHidesCritters ? "1" : "0")",
+            ].joined(separator: "|")
+            if self.shouldSkipMergedIconRender(signature) {
+                self.noteIconPerfRender(skipped: true)
+                return true
+            }
+            let image = IconRenderer.makeMorphIcon(
+                progress: morphProgress,
+                style: style,
+                hideCritters: self.settings.menuBarHidesCritters)
+            self.setButtonImage(
+                warningFlash ? Self.quotaWarningFlashImage(base: image) : image, for: button)
         } else {
+            let signature = [
+                "mode=icon",
+                "provider=\(primaryProvider.rawValue)",
+                "style=\(String(describing: style))",
+                "primary=\(Self.iconSignatureValue(primary))",
+                "weekly=\(Self.iconSignatureValue(weekly))",
+                "credits=\(Self.iconSignatureValue(credits))",
+                "stale=\(stale ? "1" : "0")",
+                "status=\(statusIndicator.rawValue)",
+                "blink=\(Self.iconSignatureValue(Double(blink)))",
+                "wiggle=\(Self.iconSignatureValue(Double(wiggle)))",
+                "tilt=\(Self.iconSignatureValue(Double(tilt)))",
+                "warningFlash=\(warningFlash ? "1" : "0")",
+                "anim=\(needsAnimation ? "1" : "0")",
+                "hideCritters=\(self.settings.menuBarHidesCritters ? "1" : "0")",
+            ].joined(separator: "|")
+            if self.shouldSkipMergedIconRender(signature) {
+                self.noteIconPerfRender(skipped: true)
+                return true
+            }
             let image = IconRenderer.makeIcon(
                 primaryRemaining: primary,
                 weeklyRemaining: weekly,
@@ -318,59 +378,100 @@ extension StatusItemController {
                 blink: blink,
                 wiggle: wiggle,
                 tilt: tilt,
-                statusIndicator: statusIndicator)
-            self.setButtonImage(image, for: button)
+                statusIndicator: statusIndicator,
+                hideCritters: self.settings.menuBarHidesCritters)
+            self.setButtonImage(
+                warningFlash ? Self.quotaWarningFlashImage(base: image) : image, for: button)
+        }
+        self.noteIconPerfRender(skipped: false)
+        return false
+    }
+
+    private func deferMergedIconRenderDuringMenuTrackingIfNeeded() -> Bool {
+        guard self.shouldMergeIcons, self.isMergedMenuOpen else { return false }
+        self.deferredMergedIconRenderAfterTracking = true
+        self.noteIconPerfRender(skipped: true)
+        return true
+    }
+
+    func applyDeferredMergedIconRenderAfterTrackingIfNeeded() {
+        guard self.deferredMergedIconRenderAfterTracking else { return }
+        guard self.shouldMergeIcons else {
+            self.deferredMergedIconRenderAfterTracking = false
+            return
         }
+        guard !self.isMergedMenuOpen else { return }
+        self.deferredMergedIconRenderAfterTracking = false
+        let phase: Double? = self.animationDriver == nil ? nil : self.animationPhase
+        self.applyIcon(phase: phase)
+    }
+
+    private func shouldSkipMergedIconRender(_ signature: String) -> Bool {
+        guard self.shouldMergeIcons else {
+            self.lastAppliedMergedIconRenderSignature = signature
+            return false
+        }
+        if self.lastAppliedMergedIconRenderSignature == signature {
+            return true
+        }
+        self.lastAppliedMergedIconRenderSignature = signature
+        return false
     }
 
-    func applyIcon(for provider: UsageProvider, phase: Double?) {
-        guard let button = self.statusItems[provider]?.button else { return }
+    private func shouldSkipProviderIconRender(provider: UsageProvider, signature: String) -> Bool {
+        if self.lastAppliedProviderIconRenderSignatures[provider] == signature {
+            return true
+        }
+        self.lastAppliedProviderIconRenderSignatures[provider] = signature
+        return false
+    }
+
+    @discardableResult
+    func applyIcon(for provider: UsageProvider, phase: Double?) -> Bool {
+        guard let button = self.statusItems[provider]?.button else { return false }
         let snapshot = self.store.snapshot(for: provider)
         // IconRenderer treats these values as a left-to-right "progress fill" percentage; depending on the
         // user setting we pass either "percent left" or "percent used".
         let showUsed = self.settings.usageBarsShowUsed
         let showBrandPercent = self.settings.menuBarShowsBrandIconWithPercent
+        let style: IconStyle = self.store.style(for: provider)
+        let warningFlash = self.quotaWarningFlashActive(provider: provider)
 
         if showBrandPercent,
            let brand = ProviderBrandIcon.image(for: provider)
         {
             let displayText = self.menuBarDisplayText(for: provider, snapshot: snapshot)
-            self.setButtonImage(brand, for: button)
+            let signature = [
+                "mode=brandPercent",
+                "provider=\(provider.rawValue)",
+                "style=\(String(describing: style))",
+                "text=\(displayText ?? "nil")",
+                "warningFlash=\(warningFlash ? "1" : "0")",
+            ].joined(separator: "|")
+            if self.shouldSkipProviderIconRender(provider: provider, signature: signature) {
+                self.noteIconPerfRender(skipped: true)
+                return true
+            }
+            self.setButtonImage(
+                warningFlash ? Self.quotaWarningFlashImage(base: brand) : brand, for: button)
             self.setButtonTitle(displayText, for: button)
-            return
+            self.noteIconPerfRender(skipped: false)
+            return false
         }
 
-        if Self.shouldUseOpenRouterBrandFallback(provider: provider, snapshot: snapshot),
-           let brand = ProviderBrandIcon.image(for: provider)
-        {
-            self.setButtonTitle(nil, for: button)
-            self.setButtonImage(
-                Self.brandImageWithStatusOverlay(
-                    brand: brand,
-                    statusIndicator: self.store.statusIndicator(for: provider)),
-                for: button)
-            return
-        }
-        var primary = showUsed ? snapshot?.primary?.usedPercent : snapshot?.primary?.remainingPercent
-        var weekly = showUsed ? snapshot?.secondary?.usedPercent : snapshot?.secondary?.remainingPercent
-        if showUsed,
-           provider == .warp,
-           let remaining = snapshot?.secondary?.remainingPercent,
-           remaining <= 0
-        {
-            // Preserve Warp "no bonus/exhausted bonus" layout even in show-used mode.
-            weekly = 0
-        }
-        if showUsed,
-           provider == .warp,
-           let remaining = snapshot?.secondary?.remainingPercent,
-           remaining > 0,
-           weekly == 0
-        {
-            // In show-used mode, `0` means "unused", not "missing". Keep the weekly lane present.
-            weekly = Self.loadingPercentEpsilon
+        self.setButtonTitle(nil, for: button)
+
+        // OpenRouter always gets a meter here — the brand-logo fallback was removed on purpose.
+        let resolved = snapshot.map {
+            IconRemainingResolver.resolvedPercents(
+                snapshot: $0,
+                style: style,
+                showUsed: showUsed,
+                secondaryOverrideWindowID: self.settings.copilotIconSecondaryWindowOverrideID(snapshot: $0))
         }
-        var credits: Double? = provider == .codex ? self.store.credits?.remaining : nil
+        var primary = resolved?.primary
+        var weekly = resolved?.secondary
+        var credits = self.menuBarCreditsRemainingForIcon(provider: provider, snapshot: snapshot)
         var stale = self.store.isStale(provider: provider)
         var morphProgress: Double?
 
@@ -388,13 +489,14 @@ extension StatusItemController {
             } else {
                 // Keep loading animation layout stable: IconRenderer switches layouts at `weeklyRemaining == 0`.
                 primary = max(pattern.value(phase: phase), Self.loadingPercentEpsilon)
-                weekly = max(pattern.value(phase: phase + pattern.secondaryOffset), Self.loadingPercentEpsilon)
+                weekly = max(
+                    pattern.value(phase: phase + pattern.secondaryOffset),
+                    Self.loadingPercentEpsilon)
                 credits = nil
                 stale = false
             }
         }
 
-        let style: IconStyle = self.store.style(for: provider)
         let isLoading = phase != nil && self.shouldAnimate(provider: provider)
         let blink: CGFloat = {
             guard isLoading, style == .warp, let phase else {
@@ -405,11 +507,49 @@ extension StatusItemController {
         }()
         let wiggle = self.wiggleAmount(for: provider)
         let tilt = self.tiltAmount(for: provider) * .pi / 28 // limit to ~6.4°
+        let statusIndicator = self.store.statusIndicator(for: provider)
         if let morphProgress {
-            let image = IconRenderer.makeMorphIcon(progress: morphProgress, style: style)
-            self.setButtonImage(image, for: button)
+            let signature = [
+                "mode=morph",
+                "provider=\(provider.rawValue)",
+                "style=\(String(describing: style))",
+                "morph=\(Self.iconSignatureValue(morphProgress))",
+                "status=\(statusIndicator.rawValue)",
+                "warningFlash=\(warningFlash ? "1" : "0")",
+                "loading=\(isLoading ? "1" : "0")",
+                "hideCritters=\(self.settings.menuBarHidesCritters ? "1" : "0")",
+            ].joined(separator: "|")
+            if self.shouldSkipProviderIconRender(provider: provider, signature: signature) {
+                self.noteIconPerfRender(skipped: true)
+                return true
+            }
+            let image = IconRenderer.makeMorphIcon(
+                progress: morphProgress,
+                style: style,
+                hideCritters: self.settings.menuBarHidesCritters)
+            self.setButtonImage(
+                warningFlash ? Self.quotaWarningFlashImage(base: image) : image, for: button)
         } else {
-            self.setButtonTitle(nil, for: button)
+            let signature = [
+                "mode=icon",
+                "provider=\(provider.rawValue)",
+                "style=\(String(describing: style))",
+                "primary=\(Self.iconSignatureValue(primary))",
+                "weekly=\(Self.iconSignatureValue(weekly))",
+                "credits=\(Self.iconSignatureValue(credits))",
+                "stale=\(stale ? "1" : "0")",
+                "status=\(statusIndicator.rawValue)",
+                "blink=\(Self.iconSignatureValue(Double(blink)))",
+                "wiggle=\(Self.iconSignatureValue(Double(wiggle)))",
+                "tilt=\(Self.iconSignatureValue(Double(tilt)))",
+                "warningFlash=\(warningFlash ? "1" : "0")",
+                "loading=\(isLoading ? "1" : "0")",
+                "hideCritters=\(self.settings.menuBarHidesCritters ? "1" : "0")",
+            ].joined(separator: "|")
+            if self.shouldSkipProviderIconRender(provider: provider, signature: signature) {
+                self.noteIconPerfRender(skipped: true)
+                return true
+            }
             let image = IconRenderer.makeIcon(
                 primaryRemaining: primary,
                 weeklyRemaining: weekly,
@@ -419,9 +559,91 @@ extension StatusItemController {
                 blink: blink,
                 wiggle: wiggle,
                 tilt: tilt,
-                statusIndicator: self.store.statusIndicator(for: provider))
-            self.setButtonImage(image, for: button)
+                statusIndicator: statusIndicator,
+                hideCritters: self.settings.menuBarHidesCritters)
+            self.setButtonImage(
+                warningFlash ? Self.quotaWarningFlashImage(base: image) : image, for: button)
         }
+        self.noteIconPerfRender(skipped: false)
+        return false
+    }
+
+    static func iconSignatureValue(_ value: Double?) -> String {
+        guard let value else { return "nil" }
+        return String(format: "%.3f", value)
+    }
+
+    func menuBarCreditsRemainingForIcon(provider: UsageProvider, snapshot: UsageSnapshot?) -> Double? {
+        // Derive the menu-bar credits fallback from the same Codex projection path the rendered
+        // icon and menu use (`codexConsumerProjection` -> `menuBarFallback`), instead of a
+        // hand-rolled rate-window predicate. The projection is pure value composition over
+        // already-loaded snapshot/credits state (no IO), so this stays cheap while keeping the
+        // icon render, this signature input, and the menu-bar fallback semantics on a single
+        // source of truth — a hand-rolled approximation can silently drift from the projection
+        // as its fallback logic evolves.
+        guard provider == .codex else { return nil }
+        return self.store.codexMenuBarCreditsRemaining(
+            snapshotOverride: snapshot,
+            now: snapshot?.updatedAt ?? Date())
+    }
+
+    func quotaWarningFlashActive(provider: UsageProvider, now: Date = Date()) -> Bool {
+        guard let until = self.quotaWarningFlashUntil[provider] else { return false }
+        if until > now { return true }
+        self.quotaWarningFlashUntil.removeValue(forKey: provider)
+        self.quotaWarningFlashTasks[provider]?.cancel()
+        self.quotaWarningFlashTasks.removeValue(forKey: provider)
+        return false
+    }
+
+    func startQuotaWarningFlash(provider: UsageProvider, postedAt: Date = Date()) {
+        let until = postedAt.addingTimeInterval(Self.quotaWarningFlashDuration)
+        self.quotaWarningFlashUntil[provider] = until
+        self.quotaWarningFlashTasks[provider]?.cancel()
+        self.updateIcons()
+        self.applyQuotaWarningIconDuringMergedMenuTrackingIfNeeded()
+        self.quotaWarningFlashTasks[provider] = Task { [weak self] in
+            try? await Task.sleep(for: .seconds(Self.quotaWarningFlashDuration))
+            await MainActor.run { [weak self] in
+                self?.clearExpiredQuotaWarningFlash(provider: provider)
+            }
+        }
+    }
+
+    func clearExpiredQuotaWarningFlash(provider: UsageProvider, now: Date = Date()) {
+        guard let currentUntil = self.quotaWarningFlashUntil[provider],
+              currentUntil <= now
+        else {
+            return
+        }
+        self.quotaWarningFlashUntil.removeValue(forKey: provider)
+        self.quotaWarningFlashTasks.removeValue(forKey: provider)
+        self.updateIcons()
+        self.applyQuotaWarningIconDuringMergedMenuTrackingIfNeeded()
+    }
+
+    private func applyQuotaWarningIconDuringMergedMenuTrackingIfNeeded() {
+        guard self.shouldMergeIcons,
+              self.isMergedMenuOpen
+        else {
+            return
+        }
+        let phase: Double? = self.animationDriver == nil ? nil : self.animationPhase
+        self.applyIcon(phase: phase, bypassMergedMenuTrackingDeferral: true)
+    }
+
+    static func quotaWarningFlashImage(base: NSImage) -> NSImage {
+        let image = NSImage(size: base.size)
+        image.lockFocus()
+        let rect = NSRect(origin: .zero, size: base.size)
+        NSColor.systemRed.withAlphaComponent(0.22).setFill()
+        NSBezierPath(roundedRect: rect.insetBy(dx: 1, dy: 1), xRadius: 4, yRadius: 4).fill()
+        base.draw(in: rect, from: .zero, operation: .sourceOver, fraction: 1)
+        NSColor.systemRed.withAlphaComponent(0.28).setFill()
+        NSBezierPath(rect: rect).fill()
+        image.unlockFocus()
+        image.isTemplate = false
+        return image
     }
 
     private func setButtonImage(_ image: NSImage, for button: NSStatusBarButton) {
@@ -430,7 +652,7 @@ extension StatusItemController {
     }
 
     private func setButtonTitle(_ title: String?, for button: NSStatusBarButton) {
-        let value = title ?? ""
+        let value = Self.buttonTitle(title, hasImage: button.image != nil)
         if button.title != value {
             button.title = value
         }
@@ -440,47 +662,338 @@ extension StatusItemController {
         }
     }
 
+    nonisolated static func buttonTitle(_ title: String?, hasImage: Bool) -> String {
+        guard let title, !title.isEmpty else { return "" }
+        return hasImage ? " \(title)" : title
+    }
+
     func menuBarDisplayText(for provider: UsageProvider, snapshot: UsageSnapshot?) -> String? {
-        let percentWindow = self.menuBarPercentWindow(for: provider, snapshot: snapshot)
         let mode = self.settings.menuBarDisplayMode
+        if provider == .openrouter,
+           self.settings.menuBarMetricPreference(for: provider, snapshot: snapshot) == .automatic,
+           let balance = snapshot?.openRouterUsage?.balance
+        {
+            return UsageFormatter.usdString(balance)
+        }
+        if provider == .opencodego,
+           let balance = Self.openCodeGoZenBalanceDisplayText(snapshot: snapshot)
+        {
+            return balance
+        }
+        if provider == .deepseek,
+           let balance = Self.deepSeekBalanceDisplayText(snapshot: snapshot)
+        {
+            return balance
+        }
+        if provider == .mimo,
+           let balance = Self.miMoBalanceDisplayText(
+               snapshot: snapshot,
+               preference: self.settings.menuBarMetricPreference(for: provider, snapshot: snapshot))
+        {
+            return balance
+        }
+        if provider == .moonshot,
+           let balance = Self.moonshotBalanceDisplayText(snapshot: snapshot)
+        {
+            return balance
+        }
+        if provider == .poe,
+           let balance = Self.poeBalanceDisplayText(snapshot: snapshot)
+        {
+            return balance
+        }
+        if provider == .mistral {
+            let preference = self.settings.menuBarMetricPreference(for: provider, snapshot: snapshot)
+            let hasMonthlyWindow = snapshot?.extraRateWindows?.contains { $0.id == "mistral-monthly-plan" } == true
+            if preference != .monthlyPlan || !hasMonthlyWindow,
+               let spend = Self.mistralSpendDisplayText(snapshot: snapshot)
+            {
+                return spend
+            }
+        }
+        if provider == .kimik2,
+           let credits = Self.kimiK2CreditsDisplayText(snapshot: snapshot)
+        {
+            return credits
+        }
+        if provider == .kiro {
+            return Self.kiroDisplayText(
+                snapshot: snapshot,
+                mode: self.settings.kiroMenuBarDisplayMode,
+                showUsed: self.settings.usageBarsShowUsed)
+        }
+        if mode != .resetTime,
+           self.settings.menuBarMetricPreference(for: provider, snapshot: snapshot) == .extraUsage,
+           provider != .cursor || mode == .pace,
+           let spend = Self.extraUsageSpendDisplayText(snapshot: snapshot)
+        {
+            return spend
+        }
+
+        let percentWindow = self.menuBarPercentWindow(for: provider, snapshot: snapshot)
         let now = Date()
-        let pace: UsagePace? = switch mode {
+        let codexProjection = self.store.codexConsumerProjectionIfNeeded(
+            for: provider,
+            surface: .menuBar,
+            snapshotOverride: snapshot,
+            now: now)
+        let pace: UsagePace?
+        switch mode {
         case .percent:
-            nil
+            pace = nil
         case .pace, .both:
-            snapshot?.secondary.flatMap { window in
+            let paceWindow: RateWindow? = if let codexProjection {
+                codexProjection.rateWindow(for: .weekly)
+            } else if provider == .abacus {
+                // Abacus has no secondary window; pace is computed on primary monthly credits
+                snapshot?.primary
+            } else {
+                percentWindow
+            }
+            pace = paceWindow.flatMap { window in
                 self.store.weeklyPace(provider: provider, window: window, now: now)
             }
+        case .resetTime:
+            return MenuBarDisplayText.displayText(
+                mode: mode,
+                percentWindow: percentWindow,
+                showUsed: self.settings.usageBarsShowUsed,
+                resetTimeDisplayStyle: self.settings.resetTimeDisplayStyle,
+                now: now)
+        }
+        if mode == .percent,
+           !self.settings.usageBarsShowUsed,
+           codexProjection?.menuBarFallback == .creditsBalance,
+           let creditsRemaining = codexProjection?.credits?.remaining,
+           creditsRemaining > 0
+        {
+            return
+                UsageFormatter
+                    .creditsString(from: creditsRemaining)
+                    .replacingOccurrences(of: " left", with: "")
         }
-        let displayText = MenuBarDisplayText.displayText(
+        if provider == .codex,
+           mode == .percent,
+           self.settings.menuBarMetricPreference(for: .codex, snapshot: snapshot) == .primaryAndSecondary,
+           let combinedText = MenuBarDisplayText.codexCombinedPercentText(
+               sessionWindow: codexProjection?.rateWindow(for: .session),
+               weeklyWindow: codexProjection?.rateWindow(for: .weekly),
+               showUsed: self.settings.usageBarsShowUsed)
+        {
+            return combinedText
+        }
+        return MenuBarDisplayText.displayText(
             mode: mode,
             percentWindow: percentWindow,
             pace: pace,
             showUsed: self.settings.usageBarsShowUsed)
+    }
 
-        let sessionExhausted = (snapshot?.primary?.remainingPercent ?? 100) <= 0
-        let weeklyExhausted = (snapshot?.secondary?.remainingPercent ?? 100) <= 0
+    nonisolated static func deepSeekBalanceDisplayText(snapshot: UsageSnapshot?) -> String? {
+        guard
+            let rawValue = snapshot?.primary?.resetDescription?
+                .trimmingCharacters(in: .whitespacesAndNewlines),
+                !rawValue.isEmpty,
+                rawValue.hasPrefix("$") || rawValue.hasPrefix("¥")
+        else {
+            return nil
+        }
 
-        if provider == .codex,
-           mode == .percent,
-           !self.settings.usageBarsShowUsed,
-           sessionExhausted || weeklyExhausted,
-           let creditsRemaining = self.store.credits?.remaining,
-           creditsRemaining > 0
-        {
-            return UsageFormatter
-                .creditsString(from: creditsRemaining)
-                .replacingOccurrences(of: " left", with: "")
+        let balance = rawValue.split(separator: " ", maxSplits: 1).first
+        return balance.map(String.init)
+    }
+
+    nonisolated static func miMoBalanceDisplayText(
+        snapshot: UsageSnapshot?,
+        preference: MenuBarMetricPreference) -> String?
+    {
+        guard let snapshot, let mimoUsage = snapshot.mimoUsage else { return nil }
+        if snapshot.primary != nil, preference != .secondary { return nil }
+        let detail = mimoUsage.balanceDetail
+        return detail.components(separatedBy: " (Paid:").first
+    }
+
+    nonisolated static func poeBalanceDisplayText(snapshot: UsageSnapshot?) -> String? {
+        self.displayValue(
+            from: snapshot?.loginMethod(for: .poe),
+            prefix: "Balance:",
+            removingSuffix: "")
+    }
+
+    nonisolated static func moonshotBalanceDisplayText(snapshot: UsageSnapshot?) -> String? {
+        self.displayValue(
+            from: snapshot?.loginMethod(for: .moonshot),
+            prefix: "Balance:",
+            removingSuffix: "")
+            .flatMap { value in
+                value
+                    .split(separator: "·", maxSplits: 1)
+                    .first?
+                    .trimmingCharacters(in: .whitespacesAndNewlines)
+            }
+    }
+
+    nonisolated static func mistralSpendDisplayText(snapshot: UsageSnapshot?) -> String? {
+        self.displayValue(
+            from: snapshot?.identity?.loginMethod,
+            prefix: "API spend:",
+            removingSuffix: " this month")
+    }
+
+    nonisolated static func kimiK2CreditsDisplayText(snapshot: UsageSnapshot?) -> String? {
+        self.displayValue(
+            from: snapshot?.identity?.loginMethod,
+            prefix: "Credits:",
+            removingSuffix: " left")
+    }
+
+    nonisolated static func extraUsageSpendDisplayText(snapshot: UsageSnapshot?) -> String? {
+        guard let cost = snapshot?.providerCost,
+              cost.limit > 0,
+              cost.used >= 0
+        else {
+            return nil
         }
+        return UsageFormatter.currencyString(cost.used, currencyCode: cost.currencyCode)
+    }
 
-        return displayText
+    nonisolated static func openCodeGoZenBalanceDisplayText(snapshot: UsageSnapshot?) -> String? {
+        guard snapshot?.primary == nil,
+              snapshot?.secondary == nil,
+              let cost = snapshot?.providerCost,
+              cost.period == "Zen balance"
+        else {
+            return nil
+        }
+        return UsageFormatter.currencyString(cost.used, currencyCode: cost.currencyCode)
     }
 
-    private func menuBarPercentWindow(for provider: UsageProvider, snapshot: UsageSnapshot?) -> RateWindow? {
+    nonisolated static func kiroDisplayText(
+        snapshot: UsageSnapshot?,
+        mode: KiroMenuBarDisplayMode,
+        showUsed: Bool)
+        -> String?
+    {
+        guard mode != .hidden else { return nil }
+        guard let usage = snapshot?.kiroUsage else {
+            return MenuBarDisplayText.percentText(window: snapshot?.primary, showUsed: showUsed)
+        }
+        let percentText = MenuBarDisplayText.percentText(
+            window: snapshot?.primary,
+            showUsed: showUsed)
+        let creditsLeft = UsageFormatter.kiroCreditNumber(usage.creditsRemaining)
+        let usedTotal = [
+            UsageFormatter.kiroCreditNumber(usage.creditsUsed),
+            UsageFormatter.kiroCreditNumber(usage.creditsTotal),
+        ].joined(separator: " / ")
+
+        switch mode {
+        case .automatic, .creditsLeft:
+            if usage.creditsTotal > 0 {
+                return creditsLeft
+            }
+            return percentText
+        case .hidden:
+            return nil
+        case .percentLeft:
+            return MenuBarDisplayText.percentText(window: snapshot?.primary, showUsed: false)
+        case .creditsAndPercent:
+            guard usage.creditsTotal > 0 else { return percentText }
+            guard let percentText else { return creditsLeft }
+            return "\(creditsLeft) · \(percentText)"
+        case .usedAndTotal:
+            guard usage.creditsTotal > 0 else { return percentText }
+            return usedTotal
+        case .overageCreditsWhenExhausted:
+            return self.kiroOverageDisplayText(
+                usage: usage,
+                format: .credits,
+                fallback: creditsLeft,
+                percentFallback: percentText)
+        case .overageCostWhenExhausted:
+            return self.kiroOverageDisplayText(
+                usage: usage,
+                format: .cost,
+                fallback: creditsLeft,
+                percentFallback: percentText)
+        case .overageCreditsAndCostWhenExhausted:
+            return self.kiroOverageDisplayText(
+                usage: usage,
+                format: .creditsAndCost,
+                fallback: creditsLeft,
+                percentFallback: percentText)
+        }
+    }
+
+    private enum KiroOverageDisplayFormat {
+        case credits
+        case cost
+        case creditsAndCost
+    }
+
+    private nonisolated static func kiroOverageDisplayText(
+        usage: KiroUsageDetails,
+        format: KiroOverageDisplayFormat,
+        fallback: String,
+        percentFallback: String?)
+        -> String?
+    {
+        guard usage.creditsTotal > 0 else { return percentFallback }
+        guard usage.creditsRemaining <= 0 else { return fallback }
+        guard
+            usage.overagesStatus?
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+                .lowercased()
+                .hasPrefix("enabled") == true
+        else {
+            return fallback
+        }
+
+        let credits = usage.overageCreditsUsed.map { "\(UsageFormatter.kiroCreditNumber($0)) over" }
+        let cost = usage.estimatedOverageCostUSD.map { "\(UsageFormatter.usdString($0)) over" }
+
+        switch format {
+        case .credits:
+            return credits ?? cost ?? fallback
+        case .cost:
+            return cost ?? credits ?? fallback
+        case .creditsAndCost:
+            if let credits, let cost {
+                let creditsValue = credits.replacingOccurrences(of: " over", with: "")
+                let costValue = cost.replacingOccurrences(of: " over", with: "")
+                return "\(creditsValue) · \(costValue)"
+            }
+            return credits ?? cost ?? fallback
+        }
+    }
+
+    private nonisolated static func displayValue(
+        from text: String?,
+        prefix: String,
+        removingSuffix suffix: String)
+        -> String?
+    {
+        guard let rawValue = text?.trimmingCharacters(in: .whitespacesAndNewlines),
+              rawValue.hasPrefix(prefix)
+        else {
+            return nil
+        }
+        let valueStart = rawValue.index(rawValue.startIndex, offsetBy: prefix.count)
+        var value = rawValue[valueStart...].trimmingCharacters(in: .whitespacesAndNewlines)
+        if !suffix.isEmpty, value.hasSuffix(suffix) {
+            value = String(value.dropLast(suffix.count)).trimmingCharacters(
+                in: .whitespacesAndNewlines)
+        }
+        return value.isEmpty ? nil : value
+    }
+
+    private func menuBarPercentWindow(for provider: UsageProvider, snapshot: UsageSnapshot?)
+        -> RateWindow?
+    {
         self.menuBarMetricWindow(for: provider, snapshot: snapshot)
     }
 
-    private func primaryProviderForUnifiedIcon() -> UsageProvider {
+    func primaryProviderForUnifiedIcon() -> UsageProvider {
         // When "show highest usage" is enabled, auto-select the provider closest to rate limit.
         if self.settings.menuBarShowsHighestUsage,
            self.shouldMergeIcons,
@@ -488,17 +1001,28 @@ extension StatusItemController {
         {
             return highest.provider
         }
+        if self.shouldMergeIcons, self.settings.mergedMenuLastSelectedWasOverview {
+            let enabledProviders = self.store.enabledProvidersForDisplay()
+            let overviewProviders = self.settings.resolvedMergedOverviewProviders(
+                activeProviders: enabledProviders,
+                maxVisibleProviders: SettingsStore.mergedOverviewProviderLimit)
+            if let provider = overviewProviders.first(where: { self.store.isEnabled($0) }) {
+                return provider
+            }
+        }
         if self.shouldMergeIcons,
            let selected = self.selectedMenuProvider,
            self.store.isEnabled(selected)
         {
             return selected
         }
-        for provider in UsageProvider.allCases {
+        for provider in self.store.enabledProviders() {
             if self.store.isEnabled(provider), self.store.snapshot(for: provider) != nil {
                 return provider
             }
         }
+        // Use availability-filtered list: fallback must pick a provider that can
+        // actually animate, otherwise shouldAnimate() fails on credential-less providers.
         if let enabled = self.store.enabledProviders().first {
             return enabled
         }
@@ -506,6 +1030,9 @@ extension StatusItemController {
     }
 
     @objc func handleDebugBlinkNotification() {
+        #if DEBUG
+        guard !self.isReleasedForTesting else { return }
+        #endif
         self.forceBlinkNow()
     }
 
@@ -515,10 +1042,13 @@ extension StatusItemController {
         self.seedBlinkStatesIfNeeded()
 
         for provider in UsageProvider.allCases {
-            let shouldBlink = self.shouldMergeIcons ? self.isEnabled(provider) : self.isVisible(provider)
+            let shouldBlink =
+                self.shouldMergeIcons ? self.isEnabled(provider) : self.isVisible(provider)
             guard shouldBlink, !self.shouldAnimate(provider: provider) else { continue }
-            var state = self
-                .blinkStates[provider] ?? BlinkState(nextBlink: now.addingTimeInterval(BlinkState.randomDelay()))
+            var state =
+                self
+                    .blinkStates[provider]
+                    ?? BlinkState(nextBlink: now.addingTimeInterval(BlinkState.randomDelay()))
             state.blinkStart = now
             state.pendingSecondStart = nil
             state.effect = self.randomEffect(for: provider)
@@ -535,7 +1065,7 @@ extension StatusItemController {
         self.tickBlink(now: now)
     }
 
-    private func shouldAnimate(provider: UsageProvider, mergeIcons: Bool? = nil) -> Bool {
+    func shouldAnimate(provider: UsageProvider, mergeIcons: Bool? = nil) -> Bool {
         if self.store.debugForceAnimation { return true }
 
         let isMerged = mergeIcons ?? self.shouldMergeIcons
@@ -566,46 +1096,51 @@ extension StatusItemController {
                     self.animationPattern = .knightRider
                 }
                 self.animationPhase = 0
+                self.animationStartedAt = Date()
                 let driver = DisplayLinkDriver(onTick: { [weak self] in
                     self?.updateAnimationFrame()
                 })
                 self.animationDriver = driver
-                driver.start(fps: 60)
-            } else if let forced = self.settings.debugLoadingPattern, forced != self.animationPattern {
+                driver.start(fps: Self.loadingAnimationFPS)
+            } else if let forced = self.settings.debugLoadingPattern,
+                      forced != self.animationPattern
+            {
                 self.animationPattern = forced
                 self.animationPhase = 0
             }
         } else {
-            self.animationDriver?.stop()
-            self.animationDriver = nil
-            self.animationPhase = 0
-            if self.shouldMergeIcons {
-                self.applyIcon(phase: nil)
-            } else {
-                UsageProvider.allCases.forEach { self.applyIcon(for: $0, phase: nil) }
-            }
+            self.stopLoadingAnimation()
         }
     }
 
-    private func updateAnimationFrame() {
-        self.animationPhase += 0.045 // half-speed animation
+    private func stopLoadingAnimation() {
+        self.animationDriver?.stop()
+        self.animationDriver = nil
+        self.animationPhase = 0
+        self.animationStartedAt = nil
         if self.shouldMergeIcons {
-            self.applyIcon(phase: self.animationPhase)
+            self.applyIcon(phase: nil)
         } else {
-            UsageProvider.allCases.forEach { self.applyIcon(for: $0, phase: self.animationPhase) }
+            UsageProvider.allCases.forEach { self.applyIcon(for: $0, phase: nil) }
         }
     }
 
-    nonisolated static func shouldUseOpenRouterBrandFallback(
-        provider: UsageProvider,
-        snapshot: UsageSnapshot?) -> Bool
-    {
-        guard provider == .openrouter,
-              let openRouterUsage = snapshot?.openRouterUsage
-        else {
-            return false
+    private func updateAnimationFrame() {
+        #if DEBUG
+        guard !self.isReleasedForTesting else { return }
+        #endif
+        if let startedAt = self.animationStartedAt,
+           Date().timeIntervalSince(startedAt) > Self.loadingAnimationMaxContinuousDuration
+        {
+            self.stopLoadingAnimation()
+            return
+        }
+        self.animationPhase += Self.loadingAnimationPhaseIncrement
+        if self.shouldMergeIcons {
+            self.applyIcon(phase: self.animationPhase)
+        } else {
+            UsageProvider.allCases.forEach { self.applyIcon(for: $0, phase: self.animationPhase) }
         }
-        return openRouterUsage.keyQuotaStatus == .noLimitConfigured
     }
 
     nonisolated static func brandImageWithStatusOverlay(
@@ -627,7 +1162,9 @@ extension StatusItemController {
         return image
     }
 
-    private nonisolated static func drawBrandStatusOverlay(indicator: ProviderStatusIndicator, size: NSSize) {
+    private nonisolated static func drawBrandStatusOverlay(
+        indicator: ProviderStatusIndicator, size: NSSize)
+    {
         guard indicator.hasIssue else { return }
 
         let color = NSColor.labelColor
@@ -659,6 +1196,9 @@ extension StatusItemController {
     }
 
     @objc func handleDebugReplayNotification(_ notification: Notification) {
+        #if DEBUG
+        guard !self.isReleasedForTesting else { return }
+        #endif
         if let raw = notification.userInfo?["pattern"] as? String,
            let selected = LoadingPattern(rawValue: raw)
         {
diff --git a/Sources/CodexBar/StatusItemController+CodexStackedMenu.swift b/Sources/CodexBar/StatusItemController+CodexStackedMenu.swift
new file mode 100644
index 0000000000..257d48ea1f
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+CodexStackedMenu.swift
@@ -0,0 +1,75 @@
+import AppKit
+
+extension StatusItemController {
+    func addStackedCodexMenuCards(
+        _ display: CodexAccountMenuDisplay,
+        to menu: NSMenu,
+        context: MenuCardContext)
+    {
+        let snapshotsByAccountID = Dictionary(uniqueKeysWithValues: display.snapshots.map {
+            ($0.account.id, $0)
+        })
+        var cardIndex = 0
+        let sections = display.showsWorkspaceGroups ? display.workspaceSections : [
+            CodexAccountWorkspaceSection(title: "", accounts: display.accounts),
+        ]
+
+        for (sectionIndex, section) in sections.enumerated() {
+            if display.showsWorkspaceGroups {
+                self.addCodexWorkspaceHeader(section.title, index: sectionIndex, to: menu)
+            }
+
+            for account in section.accounts {
+                let accountSnapshot = snapshotsByAccountID[account.id]
+                let health = CodexAccountHealth.status(for: account, error: accountSnapshot?.error)
+                let model = self.menuCardModel(
+                    for: .codex,
+                    snapshotOverride: accountSnapshot?.snapshot,
+                    errorOverride: health.label,
+                    forceOverrideCard: accountSnapshot == nil,
+                    accountOverride: self.accountInfo(for: account))
+                guard let model else { continue }
+                menu.addItem(self.makeMenuCardItem(
+                    UsageMenuCardView(model: model, width: context.menuWidth),
+                    id: "menuCard-\(cardIndex)",
+                    width: context.menuWidth,
+                    heightCacheScope: account.id,
+                    heightCacheFingerprint: model.heightFingerprint(section: "card"),
+                    containsInteractiveControls: true))
+                cardIndex += 1
+                if account.id != section.accounts.last?.id {
+                    menu.addItem(.separator())
+                }
+            }
+
+            if sectionIndex < sections.count - 1 {
+                menu.addItem(.separator())
+            }
+        }
+
+        if cardIndex == 0, let model = self.menuCardModel(for: context.selectedProvider) {
+            menu.addItem(self.makeMenuCardItem(
+                UsageMenuCardView(model: model, width: context.menuWidth),
+                id: "menuCard",
+                width: context.menuWidth,
+                heightCacheScope: context.currentProvider.rawValue,
+                heightCacheFingerprint: model.heightFingerprint(section: "card"),
+                containsInteractiveControls: true))
+        }
+        menu.addItem(.separator())
+        if self.addStorageMenuCardSection(to: menu, provider: context.currentProvider, width: context.menuWidth) {
+            menu.addItem(.separator())
+        }
+    }
+
+    private func addCodexWorkspaceHeader(_ title: String, index: Int, to menu: NSMenu) {
+        let header = NSMenuItem(title: title, action: nil, keyEquivalent: "")
+        header.isEnabled = false
+        header.representedObject = "codexWorkspace-\(index)"
+        let font = NSFont.systemFont(ofSize: NSFont.smallSystemFontSize, weight: .semibold)
+        header.attributedTitle = NSAttributedString(
+            string: title,
+            attributes: [.font: font, .foregroundColor: NSColor.secondaryLabelColor])
+        menu.addItem(header)
+    }
+}
diff --git a/Sources/CodexBar/StatusItemController+CostMenuCard.swift b/Sources/CodexBar/StatusItemController+CostMenuCard.swift
new file mode 100644
index 0000000000..05424c8d50
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+CostMenuCard.swift
@@ -0,0 +1,136 @@
+import AppKit
+import SwiftUI
+
+private struct CostMenuCardRowView: View {
+    let title: String
+    let detailLines: [String]
+    let width: CGFloat
+    @Environment(\.menuItemHighlighted) private var isHighlighted
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 2) {
+            Text(self.title)
+                .font(.system(size: NSFont.menuFont(ofSize: 0).pointSize))
+                .lineLimit(1)
+            ForEach(self.detailLines.indices, id: \.self) { index in
+                Text(self.detailLines[index])
+                    .font(.system(size: NSFont.smallSystemFontSize))
+                    .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
+                    .lineLimit(1)
+                    .truncationMode(.tail)
+            }
+        }
+        .padding(.leading, 20)
+        .padding(.trailing, 28)
+        .padding(.vertical, 6)
+        .frame(width: self.width, alignment: .leading)
+    }
+}
+
+extension StatusItemController {
+    static var costMenuTitle: String {
+        L("Cost")
+    }
+
+    func makeCostMenuCardItem(
+        model: UsageMenuCardView.Model,
+        submenu: NSMenu?,
+        width: CGFloat) -> NSMenuItem
+    {
+        let tooltipLines = Self.costMenuTooltipLines(tokenUsage: model.tokenUsage)
+        let visibleDetailLines = Self.costMenuVisibleDetailLines(
+            tokenUsage: model.tokenUsage,
+            hasSubmenu: submenu != nil)
+        guard visibleDetailLines.isEmpty == false, self.menuCardRenderingEnabledForController else {
+            return Self.makeNativeCostMenuCardItem(
+                visibleDetailLines: visibleDetailLines,
+                tooltipLines: tooltipLines,
+                submenu: submenu)
+        }
+
+        let item = self.makeMenuCardItem(
+            CostMenuCardRowView(
+                title: Self.costMenuTitle,
+                detailLines: visibleDetailLines,
+                width: width),
+            id: "menuCardCost",
+            width: width,
+            heightCacheScope: model.provider.rawValue,
+            heightCacheFingerprint: "costMenuRow:\(visibleDetailLines.count)",
+            submenu: submenu,
+            submenuIndicatorAlignment: .trailing,
+            submenuIndicatorTopPadding: 0)
+        item.title = Self.costMenuTitle
+        item.toolTip = tooltipLines.joined(separator: "\n")
+        return item
+    }
+
+    private static func makeNativeCostMenuCardItem(
+        visibleDetailLines: [String],
+        tooltipLines: [String],
+        submenu: NSMenu?) -> NSMenuItem
+    {
+        let item = NSMenuItem(title: Self.costMenuTitle, action: nil, keyEquivalent: "")
+        item.isEnabled = true
+        item.representedObject = "menuCardCost"
+        item.submenu = submenu
+        // Submenu cost rows already show these details; keep tooltips only for inline rows
+        // where they reveal truncated text and avoid flashes during in-place menu refreshes.
+        if submenu == nil {
+            item.toolTip = tooltipLines.joined(separator: "\n")
+        }
+        if #available(macOS 14.4, *) {
+            item.subtitle = visibleDetailLines.joined(separator: "\n")
+        } else if !visibleDetailLines.isEmpty {
+            item.attributedTitle = Self.costMenuFallbackAttributedTitle(visibleDetailLines: visibleDetailLines)
+        }
+        return item
+    }
+
+    static func costMenuTooltipLines(tokenUsage: UsageMenuCardView.Model.TokenUsageSection?) -> [String] {
+        [
+            tokenUsage?.sessionLine,
+            tokenUsage?.monthLine,
+            tokenUsage?.hintLine,
+            tokenUsage?.errorLine,
+        ]
+            .compactMap(\.self)
+            .filter { !$0.isEmpty }
+    }
+
+    static func costMenuVisibleDetailLines(
+        tokenUsage: UsageMenuCardView.Model.TokenUsageSection?,
+        hasSubmenu: Bool) -> [String]
+    {
+        guard !hasSubmenu else { return [] }
+        let primaryLines = [
+            tokenUsage?.sessionLine,
+            tokenUsage?.monthLine,
+            tokenUsage?.errorLine,
+        ]
+            .compactMap(\.self)
+            .filter { !$0.isEmpty }
+        guard primaryLines.isEmpty else { return primaryLines }
+        return [tokenUsage?.hintLine]
+            .compactMap(\.self)
+            .filter { !$0.isEmpty }
+    }
+
+    static func costMenuFallbackAttributedTitle(visibleDetailLines: [String]) -> NSAttributedString {
+        let detailText = visibleDetailLines.joined(separator: " | ")
+        let title = detailText.isEmpty ? self.costMenuTitle : "\(self.costMenuTitle)  \(detailText)"
+        let attributedTitle = NSMutableAttributedString(
+            string: title,
+            attributes: [.font: NSFont.menuFont(ofSize: NSFont.systemFontSize)])
+        guard !detailText.isEmpty else { return attributedTitle }
+
+        let detailRange = (title as NSString).range(of: detailText)
+        attributedTitle.addAttributes(
+            [
+                .font: NSFont.menuFont(ofSize: NSFont.smallSystemFontSize),
+                .foregroundColor: NSColor.secondaryLabelColor,
+            ],
+            range: detailRange)
+        return attributedTitle
+    }
+}
diff --git a/Sources/CodexBar/StatusItemController+CountdownRefresh.swift b/Sources/CodexBar/StatusItemController+CountdownRefresh.swift
new file mode 100644
index 0000000000..50820ec0a1
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+CountdownRefresh.swift
@@ -0,0 +1,67 @@
+import CodexBarCore
+import Foundation
+
+extension StatusItemController {
+    private nonisolated static let menuBarCountdownRefreshEpsilon: TimeInterval = 0.05
+
+    func scheduleMenuBarCountdownRefreshIfNeeded(now: Date = .init()) {
+        self.menuBarCountdownRefreshTask?.cancel()
+        self.menuBarCountdownRefreshTask = nil
+
+        guard self.settings.menuBarShowsBrandIconWithPercent,
+              self.settings.menuBarDisplayMode == .resetTime,
+              self.settings.resetTimeDisplayStyle == .countdown
+        else {
+            return
+        }
+
+        let resetDates = self.menuBarCountdownProviders().compactMap { provider in
+            self.menuBarMetricWindow(
+                for: provider,
+                snapshot: self.store.snapshot(for: provider))?.resetsAt
+        }
+        guard let delay = Self.menuBarCountdownRefreshDelay(resetDates: resetDates, now: now) else {
+            return
+        }
+
+        self.menuBarCountdownRefreshTask = Task { @MainActor [weak self] in
+            do {
+                try await Task.sleep(for: .seconds(delay))
+            } catch {
+                return
+            }
+            guard let self, !Task.isCancelled else { return }
+            self.menuBarCountdownRefreshTask = nil
+            self.updateIcons()
+        }
+    }
+
+    nonisolated static func menuBarCountdownRefreshDelay(
+        resetDates: [Date],
+        now: Date)
+        -> TimeInterval?
+    {
+        resetDates.compactMap { resetDate -> TimeInterval? in
+            let remaining = resetDate.timeIntervalSince(now)
+            guard remaining > 0 else { return nil }
+            let displayedMinutes = ceil(remaining / 60)
+            let nextBoundaryRemaining = max(0, displayedMinutes - 1) * 60
+            return max(
+                self.menuBarCountdownRefreshEpsilon,
+                remaining - nextBoundaryRemaining + self.menuBarCountdownRefreshEpsilon)
+        }.min()
+    }
+
+    private func menuBarCountdownProviders() -> [UsageProvider] {
+        if self.shouldMergeIcons {
+            return [self.primaryProviderForUnifiedIcon()]
+        }
+        return UsageProvider.allCases.filter(self.isVisible)
+    }
+
+    #if DEBUG
+    func _test_isMenuBarCountdownRefreshScheduled() -> Bool {
+        self.menuBarCountdownRefreshTask != nil
+    }
+    #endif
+}
diff --git a/Sources/CodexBar/StatusItemController+HostedSubmenus.swift b/Sources/CodexBar/StatusItemController+HostedSubmenus.swift
new file mode 100644
index 0000000000..b5506fae38
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+HostedSubmenus.swift
@@ -0,0 +1,509 @@
+import AppKit
+import CodexBarCore
+import QuartzCore
+import SwiftUI
+
+extension StatusItemController {
+    private struct HostedSubviewIdentity {
+        let chartID: String
+        let provider: UsageProvider?
+        let providerRawValue: String?
+    }
+
+    func isHostedSubviewMenu(_ menu: NSMenu) -> Bool {
+        let ids: Set = [
+            Self.usageBreakdownChartID,
+            Self.creditsHistoryChartID,
+            Self.costHistoryChartID,
+            Self.usageHistoryChartID,
+            Self.storageBreakdownID,
+            Self.zaiHourlyUsageChartID,
+        ]
+        return menu.items.contains { item in
+            guard let id = item.representedObject as? String else { return false }
+            return ids.contains(id)
+        }
+    }
+
+    func makeHostedSubviewPlaceholderMenu(
+        chartID: String,
+        provider: UsageProvider? = nil,
+        width: CGFloat? = nil) -> NSMenu
+    {
+        let submenu = NSMenu()
+        submenu.autoenablesItems = false
+        if let width {
+            submenu.minimumWidth = width
+        }
+        submenu.delegate = self
+        let chartItem = NSMenuItem()
+        chartItem.isEnabled = true
+        chartItem.representedObject = chartID
+        chartItem.toolTip = provider?.rawValue
+        submenu.addItem(chartItem)
+        return submenu
+    }
+
+    @discardableResult
+    func hydrateHostedSubviewMenuIfNeeded(_ menu: NSMenu, width requestedWidth: CGFloat? = nil) -> Bool {
+        guard let placeholder = menu.items.first,
+              menu.items.count == 1,
+              placeholder.view == nil,
+              let chartID = placeholder.representedObject as? String
+        else {
+            return false
+        }
+
+        let width = requestedWidth ?? self.renderedMenuWidth(for: menu.supermenu ?? menu)
+        let identity = HostedSubviewIdentity(
+            chartID: chartID,
+            provider: placeholder.toolTip.flatMap(UsageProvider.init(rawValue:)),
+            providerRawValue: placeholder.toolTip)
+        menu.removeAllItems()
+
+        let t0 = CACurrentMediaTime()
+        MainThreadActivityBreadcrumb.push("hydrateChart:\(chartID)")
+        defer { MainThreadActivityBreadcrumb.pop() }
+        let didHydrate: Bool = switch chartID {
+        case Self.usageBreakdownChartID:
+            self.appendUsageBreakdownChartItem(to: menu, width: width)
+        case Self.creditsHistoryChartID:
+            self.appendCreditsHistoryChartItem(to: menu, width: width)
+        case Self.costHistoryChartID:
+            if let providerRawValue = placeholder.toolTip,
+               let provider = UsageProvider(rawValue: providerRawValue)
+            {
+                self.appendCostHistoryChartItem(to: menu, provider: provider, width: width)
+            } else {
+                false
+            }
+        case Self.usageHistoryChartID:
+            if let providerRawValue = placeholder.toolTip,
+               let provider = UsageProvider(rawValue: providerRawValue)
+            {
+                self.appendUsageHistoryChartItem(to: menu, provider: provider, width: width)
+            } else {
+                false
+            }
+        case Self.storageBreakdownID:
+            if let providerRawValue = placeholder.toolTip,
+               let provider = UsageProvider(rawValue: providerRawValue)
+            {
+                self.appendStorageBreakdownItem(to: menu, provider: provider, width: width)
+            } else {
+                false
+            }
+        case Self.zaiHourlyUsageChartID:
+            if let providerRawValue = placeholder.toolTip,
+               let provider = UsageProvider(rawValue: providerRawValue)
+            {
+                self.appendZaiHourlyUsageChartItem(to: menu, provider: provider, width: width)
+            } else {
+                false
+            }
+        default:
+            false
+        }
+        self.logChartRenderDurationIfSlow("hydrateHostedSubview:\(chartID)", startedAt: t0)
+
+        if !didHydrate {
+            self.appendHostedSubviewUnavailableItem(
+                to: menu,
+                chartID: chartID,
+                providerRawValue: placeholder.toolTip)
+        }
+        self.recordHostedSubviewRenderSignature(for: menu, identity: identity, width: width)
+        return true
+    }
+
+    func refreshHostedSubviewMenu(_ menu: NSMenu) {
+        let width = self.renderedMenuWidth(for: menu)
+        guard let identity = self.hostedSubviewIdentity(for: menu) else {
+            self.refreshHostedSubviewHeights(in: menu)
+            return
+        }
+        let signature = self.hostedSubviewRenderSignature(identity: identity, width: width)
+        if self.hostedSubviewRenderSignatures.object(forKey: menu) as String? == signature {
+            if identity.chartID == Self.zaiHourlyUsageChartID {
+                self.refreshHostedSubviewHeights(in: menu)
+            }
+            return
+        }
+
+        menu.removeAllItems()
+        let t0 = CACurrentMediaTime()
+        MainThreadActivityBreadcrumb.push("refreshChart:\(identity.chartID)")
+        defer { MainThreadActivityBreadcrumb.pop() }
+        let didHydrate: Bool = switch identity.chartID {
+        case Self.usageBreakdownChartID:
+            self.appendUsageBreakdownChartItem(to: menu, width: width)
+        case Self.creditsHistoryChartID:
+            self.appendCreditsHistoryChartItem(to: menu, width: width)
+        case Self.costHistoryChartID:
+            if let provider = identity.provider {
+                self.appendCostHistoryChartItem(to: menu, provider: provider, width: width)
+            } else {
+                false
+            }
+        case Self.usageHistoryChartID:
+            if let provider = identity.provider {
+                self.appendUsageHistoryChartItem(to: menu, provider: provider, width: width)
+            } else {
+                false
+            }
+        case Self.storageBreakdownID:
+            if let provider = identity.provider {
+                self.appendStorageBreakdownItem(to: menu, provider: provider, width: width)
+            } else {
+                false
+            }
+        case Self.zaiHourlyUsageChartID:
+            if let provider = identity.provider {
+                self.appendZaiHourlyUsageChartItem(to: menu, provider: provider, width: width)
+            } else {
+                false
+            }
+        default:
+            false
+        }
+        self.logChartRenderDurationIfSlow("refreshHostedSubview:\(identity.chartID)", startedAt: t0)
+
+        if !didHydrate {
+            self.appendHostedSubviewUnavailableItem(
+                to: menu,
+                chartID: identity.chartID,
+                providerRawValue: identity.provider?.rawValue ?? identity.providerRawValue)
+        }
+        self.hostedSubviewRenderSignatures.setObject(signature as NSString, forKey: menu)
+    }
+
+    private func hostedSubviewIdentity(for menu: NSMenu)
+    -> HostedSubviewIdentity? {
+        for item in menu.items {
+            guard let chartID = item.representedObject as? String else { continue }
+            let providerRawValue = item.toolTip
+            return HostedSubviewIdentity(
+                chartID: chartID,
+                provider: providerRawValue.flatMap(UsageProvider.init(rawValue:)),
+                providerRawValue: providerRawValue)
+        }
+        return nil
+    }
+
+    private func recordHostedSubviewRenderSignature(
+        for menu: NSMenu,
+        identity: HostedSubviewIdentity,
+        width: CGFloat)
+    {
+        let signature = self.hostedSubviewRenderSignature(identity: identity, width: width)
+        self.hostedSubviewRenderSignatures.setObject(signature as NSString, forKey: menu)
+    }
+
+    private func hostedSubviewRenderSignature(
+        identity: HostedSubviewIdentity,
+        width: CGFloat) -> String
+    {
+        let contentSignature: String = switch identity.chartID {
+        case Self.usageBreakdownChartID:
+            Self.dashboardBreakdownReadinessSignature(
+                OpenAIDashboardDailyBreakdown.removingSkillUsageServices(
+                    from: self.store.openAIDashboard?.usageBreakdown ?? []))
+        case Self.creditsHistoryChartID:
+            Self.dashboardBreakdownReadinessSignature(self.store.openAIDashboard?.dailyBreakdown ?? [])
+        case Self.costHistoryChartID:
+            identity.provider.map(self.costHistoryRenderSignature(for:)) ?? "missing-provider"
+        case Self.usageHistoryChartID:
+            identity.provider.map(self.usageHistoryRenderSignature(for:)) ?? "missing-provider"
+        case Self.storageBreakdownID:
+            identity.provider.map(self.storageBreakdownRenderSignature(for:)) ?? "missing-provider"
+        case Self.zaiHourlyUsageChartID:
+            identity.provider.map(self.zaiHourlyUsageRenderSignature(for:)) ?? "missing-provider"
+        default:
+            "unknown"
+        }
+        return [
+            identity.chartID,
+            identity.providerRawValue ?? "",
+            String(Double(width).bitPattern, radix: 16),
+            contentSignature,
+        ].joined(separator: "|")
+    }
+
+    private func costHistoryRenderSignature(for provider: UsageProvider) -> String {
+        guard let snapshot = self.tokenSnapshotForCostHistorySubmenu(provider: provider) else { return "none" }
+        return [
+            snapshot.currencyCode,
+            "\(snapshot.historyDays)",
+            snapshot.historyLabel ?? "",
+            snapshot.last30DaysCostUSD.map { String($0.bitPattern, radix: 16) } ?? "nil",
+            String(reflecting: snapshot.daily),
+        ].joined(separator: "|")
+    }
+
+    private func usageHistoryRenderSignature(for provider: UsageProvider) -> String {
+        let snapshot = self.store.snapshot(for: provider)
+        let selection = self.store.planUtilizationHistorySelection(for: provider)
+        return [
+            "\(self.store.planUtilizationHistoryRevision)",
+            "\(Int(Date().timeIntervalSince1970 / 60))",
+            selection.accountKey ?? "unscoped",
+            snapshot?.primary == nil ? "0" : "1",
+            snapshot?.secondary == nil ? "0" : "1",
+            snapshot?.tertiary == nil ? "0" : "1",
+        ].joined(separator: "|")
+    }
+
+    private func storageBreakdownRenderSignature(for provider: UsageProvider) -> String {
+        guard let footprint = self.store.storageFootprint(for: provider) else { return "none" }
+        let components = footprint.components
+            .map { "\($0.path)=\($0.totalBytes)" }
+            .joined(separator: ";")
+        return [
+            "\(footprint.totalBytes)",
+            footprint.paths.joined(separator: ";"),
+            footprint.missingPaths.joined(separator: ";"),
+            footprint.unreadablePaths.joined(separator: ";"),
+            components,
+            String(Double(self.storageBreakdownMenuMaxHeight()).bitPattern, radix: 16),
+        ].joined(separator: "|")
+    }
+
+    private func zaiHourlyUsageRenderSignature(for provider: UsageProvider) -> String {
+        guard let modelUsage = self.store.snapshot(for: provider)?.zaiUsage?.modelUsage else { return "none" }
+        return Self.zaiHourlyUsageRenderSignature(modelUsage: modelUsage, now: Date())
+    }
+
+    static func zaiHourlyUsageRenderSignature(modelUsage: ZaiModelUsageData, now: Date) -> String {
+        let models = modelUsage.modelDataList
+            .map { model in
+                let usage = model.tokensUsage
+                    .map { $0.map(String.init) ?? "nil" }
+                    .joined(separator: ",")
+                return "\(model.modelName ?? "")=\(usage)"
+            }
+            .joined(separator: ";")
+        let ranges: [ZaiHourlyRange] = [.today(referenceDate: now), .last24h]
+        let visibleBars = ranges
+            .map { range in
+                ZaiHourlyBars.from(modelData: modelUsage, range: range, now: now)
+                    .map { bar in
+                        let segments = bar.segments
+                            .map { "\($0.model)=\($0.tokens)" }
+                            .joined(separator: ",")
+                        return "\(bar.label):\(segments)"
+                    }
+                    .joined(separator: ";")
+            }
+        return [
+            modelUsage.xTime.joined(separator: ","),
+            models,
+            visibleBars.joined(separator: "|"),
+        ].joined(separator: "|")
+    }
+
+    private func appendHostedSubviewUnavailableItem(
+        to menu: NSMenu,
+        chartID: String,
+        providerRawValue: String?)
+    {
+        let unavailableItem = NSMenuItem(title: L("No data available"), action: nil, keyEquivalent: "")
+        unavailableItem.isEnabled = false
+        unavailableItem.representedObject = chartID
+        unavailableItem.toolTip = providerRawValue
+        menu.addItem(unavailableItem)
+    }
+
+    @discardableResult
+    func appendUsageBreakdownChartItem(to submenu: NSMenu, width: CGFloat) -> Bool {
+        let breakdown = OpenAIDashboardDailyBreakdown.removingSkillUsageServices(
+            from: self.store.openAIDashboard?.usageBreakdown ?? [])
+        guard !breakdown.isEmpty else { return false }
+
+        if !self.menuCardRenderingEnabledForController {
+            let chartItem = NSMenuItem()
+            chartItem.isEnabled = true
+            chartItem.representedObject = Self.usageBreakdownChartID
+            submenu.addItem(chartItem)
+            return true
+        }
+
+        let chartView = UsageBreakdownChartMenuView(breakdown: breakdown, width: width)
+        let hosting = MenuHostingView(rootView: chartView)
+        hosting.frame = NSRect(
+            origin: .zero,
+            size: NSSize(width: width, height: self.hostedSubviewFittingHeight(for: hosting, width: width)))
+
+        let chartItem = NSMenuItem()
+        chartItem.view = hosting
+        chartItem.isEnabled = true
+        chartItem.representedObject = Self.usageBreakdownChartID
+        submenu.addItem(chartItem)
+        return true
+    }
+
+    @discardableResult
+    func appendCreditsHistoryChartItem(to submenu: NSMenu, width: CGFloat) -> Bool {
+        let breakdown = self.store.openAIDashboard?.dailyBreakdown ?? []
+        guard !breakdown.isEmpty else { return false }
+
+        if !self.menuCardRenderingEnabledForController {
+            let chartItem = NSMenuItem()
+            chartItem.isEnabled = true
+            chartItem.representedObject = Self.creditsHistoryChartID
+            submenu.addItem(chartItem)
+            return true
+        }
+
+        let chartView = CreditsHistoryChartMenuView(breakdown: breakdown, width: width)
+        let hosting = MenuHostingView(rootView: chartView)
+        hosting.frame = NSRect(
+            origin: .zero,
+            size: NSSize(width: width, height: self.hostedSubviewFittingHeight(for: hosting, width: width)))
+
+        let chartItem = NSMenuItem()
+        chartItem.view = hosting
+        chartItem.isEnabled = true
+        chartItem.representedObject = Self.creditsHistoryChartID
+        submenu.addItem(chartItem)
+        return true
+    }
+
+    @discardableResult
+    func appendCostHistoryChartItem(
+        to submenu: NSMenu,
+        provider: UsageProvider,
+        width: CGFloat) -> Bool
+    {
+        guard let tokenSnapshot = self.tokenSnapshotForCostHistorySubmenu(provider: provider) else { return false }
+        guard !tokenSnapshot.daily.isEmpty else { return false }
+
+        if !self.menuCardRenderingEnabledForController {
+            let chartItem = NSMenuItem()
+            chartItem.isEnabled = true
+            chartItem.representedObject = Self.costHistoryChartID
+            chartItem.toolTip = provider.rawValue
+            submenu.addItem(chartItem)
+            return true
+        }
+
+        // The SwiftUI view needs the callback at init, but the hosting view doesn't exist yet.
+        // A relay breaks the cycle: the closure captures relay strongly, relay holds the view weakly.
+        final class HostingRelay {
+            weak var hosting: MenuHostingView<CostHistoryChartMenuView>?
+        }
+        let relay = HostingRelay()
+        let chartView = CostHistoryChartMenuView(
+            provider: provider,
+            daily: tokenSnapshot.daily,
+            totalCostUSD: tokenSnapshot.last30DaysCostUSD,
+            currencyCode: tokenSnapshot.currencyCode,
+            historyDays: tokenSnapshot.historyDays,
+            windowLabel: tokenSnapshot.historyLabel,
+            onHeightChange: { height in
+                relay.hosting?.applyMeasuredHeight(width: width, height: height)
+            },
+            width: width)
+        let resolvedHosting = MenuHostingView(rootView: chartView)
+        relay.hosting = resolvedHosting
+        resolvedHosting.applyMeasuredHeight(
+            width: width,
+            height: self.hostedSubviewFittingHeight(for: resolvedHosting, width: width))
+
+        let chartItem = NSMenuItem()
+        chartItem.view = resolvedHosting
+        chartItem.isEnabled = true
+        chartItem.representedObject = Self.costHistoryChartID
+        chartItem.toolTip = provider.rawValue
+        submenu.addItem(chartItem)
+        return true
+    }
+
+    @discardableResult
+    func appendStorageBreakdownItem(
+        to submenu: NSMenu,
+        provider: UsageProvider,
+        width: CGFloat)
+        -> Bool
+    {
+        guard let footprint = self.store.storageFootprint(for: provider),
+              !footprint.components.isEmpty
+        else { return false }
+
+        if !self.menuCardRenderingEnabledForController {
+            let item = NSMenuItem()
+            item.isEnabled = true
+            item.representedObject = Self.storageBreakdownID
+            item.toolTip = provider.rawValue
+            submenu.addItem(item)
+            return true
+        }
+
+        let maxHeight = self.storageBreakdownMenuMaxHeight()
+        final class HostingRelay {
+            weak var hosting: MenuHostingView<StorageBreakdownMenuView>?
+            var collapsedHeight: CGFloat = 1
+        }
+        let relay = HostingRelay()
+        let view = StorageBreakdownMenuView(
+            footprint: footprint,
+            width: width,
+            maxHeight: maxHeight,
+            onExpansionHeightChange: { additionalHeight in
+                relay.hosting?.applyMeasuredHeight(
+                    width: width,
+                    height: min(maxHeight, relay.collapsedHeight + additionalHeight))
+            })
+        let hosting = MenuHostingView(rootView: view)
+        relay.hosting = hosting
+        relay.collapsedHeight = self.hostedSubviewFittingHeight(for: hosting, width: width)
+        hosting.applyMeasuredHeight(width: width, height: relay.collapsedHeight)
+
+        let item = NSMenuItem()
+        item.view = hosting
+        item.isEnabled = true
+        item.representedObject = Self.storageBreakdownID
+        item.toolTip = provider.rawValue
+        submenu.addItem(item)
+        return true
+    }
+
+    private func storageBreakdownMenuMaxHeight() -> CGFloat {
+        let visibleHeight = NSScreen.main?.visibleFrame.height ?? 900
+        return min(620, max(360, floor(visibleHeight * 0.72)))
+    }
+
+    @discardableResult
+    func appendZaiHourlyUsageChartItem(
+        to submenu: NSMenu,
+        provider: UsageProvider,
+        width: CGFloat) -> Bool
+    {
+        guard provider == .zai,
+              let snapshot = self.store.snapshot(for: provider),
+              let modelUsage = snapshot.zaiUsage?.modelUsage
+        else { return false }
+
+        if !self.menuCardRenderingEnabledForController {
+            let chartItem = NSMenuItem()
+            chartItem.isEnabled = false
+            chartItem.representedObject = Self.zaiHourlyUsageChartID
+            chartItem.toolTip = provider.rawValue
+            submenu.addItem(chartItem)
+            return true
+        }
+
+        let chartView = ZaiHourlyUsageChartMenuView(modelUsage: modelUsage, width: width)
+        let hosting = MenuHostingView(rootView: chartView)
+        hosting.frame = NSRect(
+            origin: .zero,
+            size: NSSize(width: width, height: self.hostedSubviewFittingHeight(for: hosting, width: width)))
+
+        let chartItem = NSMenuItem()
+        chartItem.view = hosting
+        chartItem.isEnabled = false
+        chartItem.representedObject = Self.zaiHourlyUsageChartID
+        chartItem.toolTip = provider.rawValue
+        submenu.addItem(chartItem)
+        return true
+    }
+}
diff --git a/Sources/CodexBar/StatusItemController+IconObservation.swift b/Sources/CodexBar/StatusItemController+IconObservation.swift
new file mode 100644
index 0000000000..f0a92a700c
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+IconObservation.swift
@@ -0,0 +1,63 @@
+import CodexBarCore
+import Foundation
+
+extension StatusItemController {
+    func storeIconObservationSignature() -> String {
+        let showBrandPercent = self.settings.menuBarShowsBrandIconWithPercent
+        let mergeIcons = self.shouldMergeIcons
+        let visibleProviders = self.store.enabledProvidersForDisplay().map(\.rawValue).sorted().joined(separator: ",")
+        let providerSignatures: String
+        let primaryProvider: UsageProvider?
+        if mergeIcons {
+            let primary = self.primaryProviderForUnifiedIcon()
+            primaryProvider = primary
+            providerSignatures = self.providerStoreIconObservationSignature(
+                for: primary,
+                showBrandPercent: showBrandPercent)
+        } else {
+            primaryProvider = nil
+            providerSignatures = UsageProvider.allCases
+                .filter { self.isVisible($0) }
+                .map { self.providerStoreIconObservationSignature(for: $0, showBrandPercent: showBrandPercent) }
+                .joined(separator: "||")
+        }
+        return [
+            "merge=\(mergeIcons ? "1" : "0")",
+            "visible=\(visibleProviders)",
+            "primary=\(primaryProvider?.rawValue ?? "nil")",
+            "iconStyle=\(self.store.iconStyle.rawValue)",
+            "showUsed=\(self.settings.usageBarsShowUsed ? "1" : "0")",
+            "brandPercent=\(showBrandPercent ? "1" : "0")",
+            "hideCritters=\(self.settings.menuBarHidesCritters ? "1" : "0")",
+            "needsAnimation=\(self.needsMenuBarIconAnimation() ? "1" : "0")",
+            providerSignatures,
+        ].joined(separator: "|")
+    }
+
+    private func providerStoreIconObservationSignature(for provider: UsageProvider, showBrandPercent: Bool) -> String {
+        let snapshot = self.store.snapshot(for: provider)
+        let style = self.store.style(for: provider)
+        let resolved = snapshot.map {
+            IconRemainingResolver.resolvedPercents(
+                snapshot: $0,
+                style: style,
+                showUsed: self.settings.usageBarsShowUsed,
+                secondaryOverrideWindowID: self.settings.copilotIconSecondaryWindowOverrideID(snapshot: $0))
+        }
+        let creditsRemaining = self.menuBarCreditsRemainingForIcon(provider: provider, snapshot: snapshot)
+        let displayText = showBrandPercent ? self.menuBarDisplayText(for: provider, snapshot: snapshot) : nil
+
+        return [
+            provider.rawValue,
+            "style=\(style.rawValue)",
+            "primary=\(Self.iconSignatureValue(resolved?.primary))",
+            "weekly=\(Self.iconSignatureValue(resolved?.secondary))",
+            "credits=\(Self.iconSignatureValue(creditsRemaining))",
+            "stale=\(self.store.isStale(provider: provider) ? "1" : "0")",
+            "status=\(self.store.statusIndicator(for: provider).rawValue)",
+            "anim=\(self.shouldAnimate(provider: provider) ? "1" : "0")",
+            "refreshing=\(self.store.refreshingProviders.contains(provider) ? "1" : "0")",
+            "text=\(displayText ?? "nil")",
+        ].joined(separator: "|")
+    }
+}
diff --git a/Sources/CodexBar/StatusItemController+IconPerf.swift b/Sources/CodexBar/StatusItemController+IconPerf.swift
new file mode 100644
index 0000000000..80ed9b0dbf
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+IconPerf.swift
@@ -0,0 +1,69 @@
+import Observation
+
+struct IconPerfRefreshCycleMetrics {
+    var updateIconsCalls = 0
+    var renderedCalls = 0
+    var skippedCalls = 0
+}
+
+extension StatusItemController {
+    func observeIconPerfRefreshCycleChanges() {
+        withObservationTracking {
+            _ = self.store.isRefreshing
+            _ = self.settings.debugLogLevel
+        } onChange: { [weak self] in
+            Task { @MainActor [weak self] in
+                guard let self else { return }
+                self.observeIconPerfRefreshCycleChanges()
+                self.handleIconPerfRefreshCycleChange()
+            }
+        }
+        self.handleIconPerfRefreshCycleChange()
+    }
+
+    func handleIconPerfRefreshCycleChange() {
+        guard self.settings.isVerboseLoggingEnabled else {
+            self.iconPerfRefreshCycleMetrics = nil
+            self.iconPerfUpdatePassActive = false
+            return
+        }
+        guard !self.store.isRefreshing else { return }
+        self.logIconPerfRefreshCycleIfNeeded()
+    }
+
+    func beginIconPerfUpdatePass() {
+        self.iconPerfUpdatePassActive = false
+        guard self.settings.isVerboseLoggingEnabled, self.store.isRefreshing else { return }
+        if self.iconPerfRefreshCycleMetrics == nil {
+            self.iconPerfRefreshCycleMetrics = IconPerfRefreshCycleMetrics()
+        }
+        self.iconPerfRefreshCycleMetrics?.updateIconsCalls += 1
+        self.iconPerfUpdatePassActive = true
+    }
+
+    func endIconPerfUpdatePass() {
+        self.iconPerfUpdatePassActive = false
+    }
+
+    func noteIconPerfRender(skipped: Bool) {
+        guard self.iconPerfUpdatePassActive else { return }
+        if skipped {
+            self.iconPerfRefreshCycleMetrics?.skippedCalls += 1
+        } else {
+            self.iconPerfRefreshCycleMetrics?.renderedCalls += 1
+        }
+    }
+
+    func logIconPerfRefreshCycleIfNeeded() {
+        guard let metrics = self.iconPerfRefreshCycleMetrics,
+              metrics.updateIconsCalls > 0
+        else {
+            self.iconPerfRefreshCycleMetrics = nil
+            return
+        }
+        let message = "[perf] refresh cycle: updateIcons() called \(metrics.updateIconsCalls) times "
+            + "(\(metrics.renderedCalls) rendered, \(metrics.skippedCalls) skipped)"
+        self.menuLogger.verbose(message)
+        self.iconPerfRefreshCycleMetrics = nil
+    }
+}
diff --git a/Sources/CodexBar/StatusItemController+MemoryPressure.swift b/Sources/CodexBar/StatusItemController+MemoryPressure.swift
new file mode 100644
index 0000000000..c4224b1091
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+MemoryPressure.swift
@@ -0,0 +1,49 @@
+import AppKit
+import CodexBarCore
+
+extension StatusItemController {
+    func trimRebuildableCachesForMemoryPressure() -> MemoryPressureCacheTrimSummary {
+        let mergedSwitcherSelectionCount = self.mergedSwitcherContentCaches.values.reduce(0) { total, entries in
+            total + entries.count
+        }
+        let summary = MemoryPressureCacheTrimSummary(
+            menuCardHeights: self.menuCardHeightCache.count,
+            menuWidths: self.measuredStandardMenuWidthCache.count,
+            mergedSwitcherSelections: mergedSwitcherSelectionCount,
+            recycledMenuCardViews: self.menuCardViewRecyclePool.count)
+
+        self.menuCardHeightCache.removeAll(keepingCapacity: false)
+        self.measuredStandardMenuWidthCache.removeAll(keepingCapacity: false)
+        self.mergedSwitcherContentCaches.removeAll(keepingCapacity: false)
+        self.menuCardViewRecyclePool.removeAll(keepingCapacity: false)
+
+        return summary
+    }
+
+    #if DEBUG
+    func seedRebuildableCachesForMemoryPressureProof() {
+        let menu = NSMenu()
+        let cacheEntry = CachedMergedSwitcherMenuContent(
+            requiredMenuContentVersion: self.menuSession.contentVersion,
+            menuWidth: 300,
+            codexAccountDisplay: nil,
+            tokenAccountDisplay: nil,
+            localizationSignature: self.menuLocalizationSignature(),
+            items: [])
+        self.menuCardHeightCache[
+            MenuCardHeightCacheKey(
+                id: "debug-memory-pressure-card",
+                scope: UsageProvider.codex.rawValue,
+                width: 30000,
+                textScale: Self.menuCardHeightTextScaleToken(),
+                fingerprint: "debug-memory-pressure"),
+        ] = 44
+        self.measuredStandardMenuWidthCache["debug-memory-pressure-width"] = 300
+        self.mergedSwitcherContentCaches[ObjectIdentifier(menu)] = [
+            .overview: cacheEntry,
+            .provider(.codex): cacheEntry,
+        ]
+        self.menuCardViewRecyclePool["debug-memory-pressure-card"] = NSView()
+    }
+    #endif
+}
diff --git a/Sources/CodexBar/StatusItemController+Menu.swift b/Sources/CodexBar/StatusItemController+Menu.swift
index 5d91736244..96baea2e15 100644
--- a/Sources/CodexBar/StatusItemController+Menu.swift
+++ b/Sources/CodexBar/StatusItemController+Menu.swift
@@ -4,87 +4,97 @@ import Observation
 import QuartzCore
 import SwiftUI
 
-extension ProviderSwitcherSelection {
-    fileprivate var provider: UsageProvider? {
-        switch self {
-        case .overview:
-            nil
-        case let .provider(provider):
-            provider
-        }
-    }
-}
+// MARK: - NSMenu construction
 
-private struct OverviewMenuCardRowView: View {
-    let model: UsageMenuCardView.Model
-    let width: CGFloat
-
-    var body: some View {
-        VStack(alignment: .leading, spacing: 0) {
-            UsageMenuCardHeaderSectionView(
-                model: self.model,
-                showDivider: self.hasUsageBlock,
-                width: self.width)
-            if self.hasUsageBlock {
-                UsageMenuCardUsageSectionView(
-                    model: self.model,
-                    showBottomDivider: false,
-                    bottomPadding: 6,
-                    width: self.width)
-            }
-        }
-        .frame(width: self.width, alignment: .leading)
+extension StatusItemController {
+    static let menuCardBaseWidth: CGFloat = 310
+    private static let maxOverviewProviders = SettingsStore.mergedOverviewProviderLimit
+    static let overviewRowIdentifierPrefix = "overviewRow-"
+    static let persistentRefreshMenuItemID = "persistentRefreshAction"
+    private static let defaultMenuOpenRefreshDelay: Duration = .seconds(1.2)
+    #if DEBUG
+    private static var menuOpenRefreshDelayForTesting: Duration = .seconds(1.2)
+    static func setMenuOpenRefreshDelayForTesting(_ delay: Duration) {
+        self.menuOpenRefreshDelayForTesting = delay
     }
 
-    private var hasUsageBlock: Bool {
-        !self.model.metrics.isEmpty || !self.model.usageNotes.isEmpty || self.model.placeholder != nil
+    static func resetMenuOpenRefreshDelayForTesting() {
+        self.menuOpenRefreshDelayForTesting = self.defaultMenuOpenRefreshDelay
     }
-}
-
-// MARK: - NSMenu construction
+    #endif
 
-extension StatusItemController {
-    private static let menuCardBaseWidth: CGFloat = 310
-    private static let maxOverviewProviders = SettingsStore.mergedOverviewProviderLimit
-    private static let overviewRowIdentifierPrefix = "overviewRow-"
-    private static let menuOpenRefreshDelay: Duration = .seconds(1.2)
-    private struct OpenAIWebMenuItems {
-        let hasUsageBreakdown: Bool
-        let hasCreditsHistory: Bool
-        let hasCostHistory: Bool
+    private static var menuOpenRefreshDelay: Duration {
+        #if DEBUG
+        menuOpenRefreshDelayForTesting
+        #else
+        defaultMenuOpenRefreshDelay
+        #endif
     }
 
-    private struct TokenAccountMenuDisplay {
-        let provider: UsageProvider
-        let accounts: [ProviderTokenAccount]
-        let snapshots: [TokenAccountUsageSnapshot]
-        let activeIndex: Int
-        let showAll: Bool
-        let showSwitcher: Bool
+    static let usageBreakdownChartID = "usageBreakdownChart"
+    static let creditsHistoryChartID = "creditsHistoryChart"
+    static let costHistoryChartID = "costHistoryChart"
+    static let usageHistoryChartID = "usageHistoryChart"
+    static let storageBreakdownID = "storageBreakdown"
+
+    private func shortcut(for action: MenuDescriptor.MenuAction) -> (key: String, modifiers: NSEvent.ModifierFlags)? {
+        switch action {
+        case .settings:
+            (",", [.command])
+        case .quit:
+            ("q", [.command])
+        default:
+            nil
+        }
     }
 
-    private func menuCardWidth(for providers: [UsageProvider], menu: NSMenu? = nil) -> CGFloat {
-        _ = menu
-        return Self.menuCardBaseWidth
+    func isPersistentRefreshItem(_ item: NSMenuItem) -> Bool {
+        item.representedObject as? String == Self.persistentRefreshMenuItemID
     }
 
     func makeMenu() -> NSMenu {
         guard self.shouldMergeIcons else {
             return self.makeMenu(for: nil)
         }
-        let menu = NSMenu()
-        menu.autoenablesItems = false
-        menu.delegate = self
-        return menu
+        return self.makeBaseMenu()
+    }
+
+    func menuNeedsUpdate(_ menu: NSMenu) {
+        guard self.shouldMergeIcons, menu === self.mergedMenu else { return }
+        self.refreshMenuForOpenIfNeeded(menu, provider: self.resolvedMenuProvider())
     }
 
     func menuWillOpen(_ menu: NSMenu) {
+        let trace = self.beginMenuOperationTrace("menuWillOpen", breadcrumb: "menuWillOpen")
+        defer { self.endMenuOperationTrace(trace, menu: menu, provider: self.menuProvider(for: menu)) }
+
+        // Keep the menu drawing in the current system appearance rather than the menu bar's
+        // (possibly dark) vibrant appearance. Done before any early return so submenus match too.
+        StatusMenuAppearance.pin(menu)
+
+        self.cancelDeferredMenuInteractionRefreshTask()
+        self.cancelClosedMenuRebuild(menu)
+
+        // Track whether this is the root menu opening (no menus were open). Only the root open rebuilds
+        // all content from current data, so the readiness baseline is re-anchored only here — re-anchoring
+        // on a nested submenu open could mask a pending refresh for the already-open parent menu.
+        let menuTrackingWasIdle = self.openMenus.isEmpty
+
         if self.isHostedSubviewMenu(menu) {
-            self.refreshHostedSubviewHeights(in: menu)
-            if Self.menuRefreshEnabled, self.isOpenAIWebSubviewMenu(menu) {
-                self.store.requestOpenAIDashboardRefreshIfStale(reason: "submenu open")
+            if !self.hydrateHostedSubviewMenuIfNeeded(menu) {
+                self.refreshHostedSubviewMenu(menu)
+            }
+            if self.isMenuRefreshEnabled, self.isOpenAIWebSubviewMenu(menu) {
+                self.deferOpenAIDashboardRefreshUntilMenuCloses(reason: "submenu open")
+            }
+            if self.isMenuRefreshEnabled {
+                // Intentionally skip open-menu tracking when refresh is disabled (tests).
+                // If refresh is re-enabled while this menu stays open, it will not be backfilled until next open.
+                self.openMenus[ObjectIdentifier(menu)] = menu
+                if menuTrackingWasIdle {
+                    self.resyncMenuAdjunctReadinessBaseline()
+                }
             }
-            self.openMenus[ObjectIdentifier(menu)] = menu
             // Removed redundant async refresh - single pass is sufficient after initial layout
             return
         }
@@ -99,55 +109,116 @@ extension StatusItemController {
                 self.lastMenuProvider = menuProvider
                 provider = menuProvider
             } else if menu === self.fallbackMenu {
-                self.lastMenuProvider = self.store.enabledProviders().first ?? .codex
+                self.lastMenuProvider = self.store.enabledProvidersForDisplay().first ?? .codex
                 provider = nil
             } else {
-                let resolved = self.store.enabledProviders().first ?? .codex
+                let resolved = self.store.enabledProvidersForDisplay().first ?? .codex
                 self.lastMenuProvider = resolved
                 provider = resolved
             }
         }
 
-        let didRefresh = self.menuNeedsRefresh(menu)
-        if didRefresh {
-            self.populateMenu(menu, provider: provider)
-            self.markMenuFresh(menu)
-            // Heights are already set during populateMenu, no need to remeasure
+        if self.isMenuRefreshEnabled, (provider ?? self.lastMenuProvider) == .codex {
+            self.deferOpenAIDashboardRefreshUntilMenuCloses(reason: "parent menu open")
         }
-        self.openMenus[ObjectIdentifier(menu)] = menu
-        // Only schedule refresh after menu is registered as open - refreshNow is called async
-        if Self.menuRefreshEnabled {
+        if self.settings.providerStorageFootprintsEnabled {
+            self.store.refreshStorageFootprintsForOverview()
+        }
+
+        let menuWasFreshBeforeOpen = !self.menuNeedsRefresh(menu)
+        self.refreshMenuForOpenIfNeeded(menu, provider: provider)
+        self.scheduleCodexAccountMenuProjectionRevalidationIfNeeded(
+            for: self.renderedProviders(for: menu))
+        if self.isMenuRefreshEnabled {
+            // Intentionally skip open-menu tracking when refresh is disabled (tests).
+            // If refresh is re-enabled while this menu stays open, it will not be backfilled until next open.
+            self.openMenus[ObjectIdentifier(menu)] = menu
+            // Only re-anchor when the opened menu actually shows current data. During an in-flight provider
+            // refresh `refreshMenuForOpenIfNeeded` can preserve stale content; resyncing the baseline to
+            // live store data in that case would mask the refresh-completion update (#1351).
+            if menuTrackingWasIdle, !self.menuNeedsRefresh(menu) {
+                self.resyncMenuAdjunctReadinessBaselineForRootOpen(
+                    menu,
+                    provider: provider,
+                    menuWasFreshBeforeOpen: menuWasFreshBeforeOpen)
+            }
+            self.installProviderSwitcherShortcutMonitorIfNeeded(for: menu)
+            // Only schedule refresh after menu is registered as open - refreshNow is called async
             self.scheduleOpenMenuRefresh(for: menu)
         }
     }
 
     func menuDidClose(_ menu: NSMenu) {
+        let wasHostedSubviewMenu = self.isHostedSubviewMenu(menu)
+        self.forgetClosedMenu(menu)
+        if wasHostedSubviewMenu {
+            self.refreshOpenMenusAfterHostedSubviewClose()
+        }
+    }
+
+    func forgetClosedMenu(_ menu: NSMenu) {
         let key = ObjectIdentifier(menu)
+        let wasMergedMenu = menu === self.mergedMenu
 
-        self.openMenus.removeValue(forKey: key)
-        self.menuRefreshTasks.removeValue(forKey: key)?.cancel()
+        if key == self.providerSwitcherShortcutMenuID {
+            self.removeProviderSwitcherShortcutMonitor()
+        }
+
+        self.clearMergedSwitcherContentCache(for: menu)
+        let wasTracked = self.openMenus.removeValue(forKey: key) != nil
+        let menuTrackingEnded = wasTracked && self.openMenus.isEmpty
+        if self.openMenus.isEmpty {
+            self.parentMenuRebuildPendingAfterHostedSubviewClose = false
+        }
+        self.cancelMenuWork(key)
+        self.clearMenuHighlight(key)
 
         let isPersistentMenu = menu === self.mergedMenu ||
             menu === self.fallbackMenu ||
             self.providerMenus.values.contains { $0 === menu }
         if !isPersistentMenu {
-            self.menuProviders.removeValue(forKey: key)
-            self.menuVersions.removeValue(forKey: key)
+            self.removeMenuTrackingState(key)
+        } else if self.menuNeedsRefresh(menu) {
+            self.handleClosedPersistentMenuNeedingRefresh(menu)
+        }
+        self.menuSession.clearParentRebuildDeferral(key)
+        self.scheduleDeferredMenuInteractionRefreshIfNeeded()
+        if wasMergedMenu {
+            self.applyDeferredMergedIconRenderAfterTrackingIfNeeded()
         }
-        for menuItem in menu.items {
-            (menuItem.view as? MenuCardHighlighting)?.setHighlighted(false)
+        if menuTrackingEnded {
+            self.prepareAttachedClosedMenusIfNeeded()
         }
     }
 
     func menu(_ menu: NSMenu, willHighlight item: NSMenuItem?) {
-        for menuItem in menu.items {
-            let highlighted = menuItem == item && menuItem.isEnabled
-            (menuItem.view as? MenuCardHighlighting)?.setHighlighted(highlighted)
+        let key = ObjectIdentifier(menu)
+        let previous = self.highlightedMenuItems[key]
+        guard previous !== item else { return }
+
+        if let previous {
+            (previous.view as? MenuCardHighlighting)?.setHighlighted(false)
+        }
+
+        if let item,
+           item.isEnabled,
+           (item.view as? MenuCardHighlighting)?.allowsMenuHighlight != false
+        {
+            self.highlightedMenuItems[key] = item
+            (item.view as? MenuCardHighlighting)?.setHighlighted(true)
+        } else {
+            self.highlightedMenuItems.removeValue(forKey: key)
         }
     }
 
-    private func populateMenu(_ menu: NSMenu, provider: UsageProvider?) {
-        let enabledProviders = self.store.enabledProviders()
+    func populateMenu(_ menu: NSMenu, provider: UsageProvider?) {
+        let trace = self.beginMenuOperationTrace(
+            "populateMenu",
+            breadcrumb: "populateMenu:\(provider?.rawValue ?? "merged")")
+        defer { self.endMenuOperationTrace(trace, menu: menu, provider: provider) }
+        defer { self.refreshMenuCardHeights(in: menu) }
+
+        let enabledProviders = self.store.enabledProvidersForDisplay()
         let includesOverview = self.includesOverviewTab(enabledProviders: enabledProviders)
         let switcherSelection = self.shouldMergeIcons && enabledProviders.count > 1
             ? self.resolvedSwitcherSelection(
@@ -160,19 +231,47 @@ extension StatusItemController {
         } else {
             switcherSelection?.provider ?? provider
         }
-        let menuWidth = self.menuCardWidth(for: enabledProviders, menu: menu)
         let currentProvider = selectedProvider ?? enabledProviders.first ?? .codex
+        let rawCodexAccountDisplay = isOverviewSelected ? nil : self.codexAccountMenuDisplay(for: currentProvider)
+        let codexAccountDisplay = isOverviewSelected
+            ? nil
+            : self.stableCodexAccountMenuDisplay(
+                rawCodexAccountDisplay,
+                menu: menu,
+                provider: currentProvider)
         let tokenAccountDisplay = isOverviewSelected ? nil : self.tokenAccountMenuDisplay(for: currentProvider)
-        let showAllTokenAccounts = tokenAccountDisplay?.showAll ?? false
+        let showAllAccounts = (tokenAccountDisplay?.showAll ?? false) || (codexAccountDisplay?.showAll ?? false)
         let openAIContext = self.openAIWebContext(
             currentProvider: currentProvider,
-            showAllTokenAccounts: showAllTokenAccounts)
+            showAllAccounts: showAllAccounts)
+        let descriptor = self.makeMenuDescriptor(
+            provider: selectedProvider,
+            includeContextualActions: !isOverviewSelected)
+        let menuWidth = self.menuCardWidth(
+            for: enabledProviders,
+            selectedProvider: selectedProvider,
+            descriptor: descriptor)
 
-        let hasTokenAccountSwitcher = menu.items.contains { $0.view is TokenAccountSwitcherView }
+        let hasTokenSwitcher = menu.items.contains { $0.view is TokenAccountSwitcherView }
+        let hasCodexSwitcher = menu.items.contains { $0.view is CodexAccountSwitcherView }
         let switcherProvidersMatch = enabledProviders == self.lastSwitcherProviders
         let switcherUsageBarsShowUsedMatch = self.settings.usageBarsShowUsed == self.lastSwitcherUsageBarsShowUsed
         let switcherSelectionMatches = switcherSelection == self.lastMergedSwitcherSelection
         let switcherOverviewAvailabilityMatches = includesOverview == self.lastSwitcherIncludesOverview
+        let menuLocalizationMatches = self.menuLocalizationSignature() == self.lastMenuLocalizationSignature
+        let tokenSwitcherCompatible = tokenAccountDisplay == self.lastTokenAccountMenuDisplay &&
+            ((tokenAccountDisplay?.showSwitcher == true && hasTokenSwitcher) ||
+                (tokenAccountDisplay?.showSwitcher != true && !hasTokenSwitcher))
+        let codexSwitcherCompatible = codexAccountDisplay == self.lastCodexAccountMenuDisplay &&
+            ((codexAccountDisplay?.showSwitcher == true && hasCodexSwitcher) ||
+                (codexAccountDisplay?.showSwitcher != true && !hasCodexSwitcher))
+        let reusableRowWidthsMatch = self.reusableFixedWidthRows(in: menu).allSatisfy { item in
+            guard let view = item.view else { return false }
+            return abs(view.frame.width - menuWidth) <= 0.5
+        }
+        let providerSwitcherWidthMatches = (menu.items.first?.view as? ProviderSwitcherView).map { view in
+            abs(view.frame.width - menuWidth) <= 0.5
+        } ?? false
         let canSmartUpdate = self.shouldMergeIcons &&
             enabledProviders.count > 1 &&
             !isOverviewSelected &&
@@ -180,153 +279,201 @@ extension StatusItemController {
             switcherUsageBarsShowUsedMatch &&
             switcherSelectionMatches &&
             switcherOverviewAvailabilityMatches &&
-            tokenAccountDisplay == nil &&
-            !hasTokenAccountSwitcher &&
+            menuLocalizationMatches &&
+            tokenSwitcherCompatible &&
+            codexSwitcherCompatible &&
+            reusableRowWidthsMatch &&
             !menu.items.isEmpty &&
             menu.items.first?.view is ProviderSwitcherView
 
+        #if DEBUG
+        if self.openMenus[ObjectIdentifier(menu)] != nil {
+            self.menuLogger.debug(
+                "populateMenu(open): provider=\(String(describing: provider)) " +
+                    "display=\(enabledProviders.map(\.rawValue)) " +
+                    "available=\(self.store.enabledProviders().map(\.rawValue)) " +
+                    "selection=\(String(describing: switcherSelection)) " +
+                    "last=\(String(describing: self.lastMergedSwitcherSelection)) " +
+                    "smart=\(canSmartUpdate)")
+        }
+        #endif
+
         if canSmartUpdate {
-            self.updateMenuContent(
+            self.updateMenuContentPreservingSwitcher(
                 menu,
-                provider: selectedProvider,
-                currentProvider: currentProvider,
-                menuWidth: menuWidth,
-                openAIContext: openAIContext)
+                context: MenuUpdateContext(
+                    provider: selectedProvider,
+                    currentProvider: currentProvider,
+                    switcherSelection: switcherSelection ?? .provider(currentProvider),
+                    menuWidth: menuWidth,
+                    codexAccountDisplay: codexAccountDisplay,
+                    tokenAccountDisplay: tokenAccountDisplay,
+                    openAIContext: openAIContext,
+                    descriptor: descriptor))
             return
         }
 
-        menu.removeAllItems()
+        let canPreserveProviderSwitcher = self.shouldMergeIcons &&
+            enabledProviders.count > 1 &&
+            switcherProvidersMatch &&
+            switcherUsageBarsShowUsedMatch &&
+            switcherOverviewAvailabilityMatches &&
+            menuLocalizationMatches &&
+            providerSwitcherWidthMatches &&
+            !menu.items.isEmpty &&
+            menu.items.first?.view is ProviderSwitcherView
+
+        #if DEBUG
+        if self.openMenus[ObjectIdentifier(menu)] != nil {
+            self.menuLogger.debug(
+                "populateMenu(open): preserveSwitcher=\(canPreserveProviderSwitcher) " +
+                    "widthMatch=\(providerSwitcherWidthMatches)")
+        }
+        #endif
 
-        let descriptor = MenuDescriptor.build(
-            provider: selectedProvider,
-            store: self.store,
-            settings: self.settings,
-            account: self.account,
-            updateReady: self.updater.updateStatus.isUpdateReady,
-            includeContextualActions: !isOverviewSelected)
+        if canPreserveProviderSwitcher {
+            self.updateMenuContentPreservingSwitcher(
+                menu,
+                context: MenuUpdateContext(
+                    provider: selectedProvider,
+                    currentProvider: currentProvider,
+                    switcherSelection: switcherSelection ?? .provider(currentProvider),
+                    menuWidth: menuWidth,
+                    codexAccountDisplay: codexAccountDisplay,
+                    tokenAccountDisplay: tokenAccountDisplay,
+                    openAIContext: openAIContext,
+                    descriptor: descriptor))
+            return
+        }
 
-        self.addProviderSwitcherIfNeeded(
-            to: menu,
-            enabledProviders: enabledProviders,
-            includesOverview: includesOverview,
-            selection: switcherSelection ?? .provider(currentProvider))
-        // Track which providers the switcher was built with for smart update detection
-        if self.shouldMergeIcons, enabledProviders.count > 1 {
-            self.lastSwitcherProviders = enabledProviders
-            self.lastSwitcherUsageBarsShowUsed = self.settings.usageBarsShowUsed
-            self.lastMergedSwitcherSelection = switcherSelection
-            self.lastSwitcherIncludesOverview = includesOverview
-        }
-        self.addTokenAccountSwitcherIfNeeded(to: menu, display: tokenAccountDisplay)
-        let menuContext = MenuCardContext(
-            currentProvider: currentProvider,
-            selectedProvider: selectedProvider,
-            menuWidth: menuWidth,
-            tokenAccountDisplay: tokenAccountDisplay,
-            openAIContext: openAIContext)
-        if isOverviewSelected {
-            if self.addOverviewRows(
-                to: menu,
+        #if DEBUG
+        if self.openMenus[ObjectIdentifier(menu)] != nil, menu.items.first?.view is ProviderSwitcherView {
+            self.menuLogger.debug("populateMenu(open): rebuilding whole menu and replacing provider switcher")
+        }
+        #endif
+        self.rebuildMenuContent(
+            menu,
+            context: MenuRebuildContext(
                 enabledProviders: enabledProviders,
-                menuWidth: menuWidth)
-            {
-                menu.addItem(.separator())
-            } else {
-                self.addOverviewEmptyState(to: menu, enabledProviders: enabledProviders)
-                menu.addItem(.separator())
-            }
-        } else {
-            let addedOpenAIWebItems = self.addMenuCards(to: menu, context: menuContext)
-            self.addOpenAIWebItemsIfNeeded(
-                to: menu,
+                includesOverview: includesOverview,
+                switcherSelection: switcherSelection,
                 currentProvider: currentProvider,
-                context: openAIContext,
-                addedOpenAIWebItems: addedOpenAIWebItems)
-        }
-        self.addActionableSections(descriptor.sections, to: menu)
+                selectedProvider: selectedProvider,
+                menuWidth: menuWidth,
+                codexAccountDisplay: codexAccountDisplay,
+                tokenAccountDisplay: tokenAccountDisplay,
+                openAIContext: openAIContext,
+                descriptor: descriptor))
     }
 
-    /// Smart update: only rebuild content sections when switching providers (keep the switcher intact).
-    private func updateMenuContent(
-        _ menu: NSMenu,
-        provider: UsageProvider?,
-        currentProvider: UsageProvider,
-        menuWidth: CGFloat,
-        openAIContext: OpenAIWebContext)
-    {
-        // Batch menu updates to prevent visual flickering during provider switch.
-        CATransaction.begin()
-        CATransaction.setDisableActions(true)
-        defer { CATransaction.commit() }
+    private func reusableFixedWidthRows(in menu: NSMenu) -> [NSMenuItem] {
+        guard !menu.items.isEmpty else { return [] }
 
-        var contentStartIndex = 0
-        if menu.items.first?.view is ProviderSwitcherView {
-            contentStartIndex = 2
+        var reusableRows: [NSMenuItem] = []
+        var index = self.providerSwitcherContentStartIndex(in: menu)
+        if index > 0 {
+            reusableRows.append(menu.items[0])
         }
-        if menu.items.count > contentStartIndex,
-           menu.items[contentStartIndex].view is TokenAccountSwitcherView
+        if menu.items.count > index,
+           menu.items[index].view is CodexAccountSwitcherView
         {
-            contentStartIndex += 2
+            reusableRows.append(menu.items[index])
+            index += 2
         }
-        while menu.items.count > contentStartIndex {
-            menu.removeItem(at: contentStartIndex)
+        if menu.items.count > index,
+           menu.items[index].view is TokenAccountSwitcherView
+        {
+            reusableRows.append(menu.items[index])
         }
-
-        let descriptor = MenuDescriptor.build(
-            provider: provider,
-            store: self.store,
-            settings: self.settings,
-            account: self.account,
-            updateReady: self.updater.updateStatus.isUpdateReady)
-
-        let menuContext = MenuCardContext(
-            currentProvider: currentProvider,
-            selectedProvider: provider,
-            menuWidth: menuWidth,
-            tokenAccountDisplay: nil,
-            openAIContext: openAIContext)
-        let addedOpenAIWebItems = self.addMenuCards(to: menu, context: menuContext)
-        self.addOpenAIWebItemsIfNeeded(
-            to: menu,
-            currentProvider: currentProvider,
-            context: openAIContext,
-            addedOpenAIWebItems: addedOpenAIWebItems)
-        self.addActionableSections(descriptor.sections, to: menu)
+        return reusableRows
     }
 
-    private struct OpenAIWebContext {
-        let hasUsageBreakdown: Bool
-        let hasCreditsHistory: Bool
-        let hasCostHistory: Bool
-        let hasOpenAIWebMenuItems: Bool
-    }
-
-    private struct MenuCardContext {
-        let currentProvider: UsageProvider
-        let selectedProvider: UsageProvider?
-        let menuWidth: CGFloat
-        let tokenAccountDisplay: TokenAccountMenuDisplay?
-        let openAIContext: OpenAIWebContext
+    private func rebuildMenuContent(
+        _ menu: NSMenu,
+        context: MenuRebuildContext)
+    {
+        self.performMenuMutationWithoutAnimation {
+            let displacedSelection = self.lastMergedMenuContentSelection
+            self.lastMergedMenuContentSelection = nil
+            self.harvestRecyclableMenuCardViews(in: menu, fromIndex: 0, displacedSelection: displacedSelection)
+            defer { self.clearMenuCardViewRecyclePool() }
+            menu.removeAllItems()
+            let contentSelection = context.switcherSelection ?? .provider(context.currentProvider)
+            self.addProviderSwitcherIfNeeded(
+                to: menu,
+                enabledProviders: context.enabledProviders,
+                includesOverview: context.includesOverview,
+                selection: context.switcherSelection ?? .provider(context.currentProvider),
+                width: context.menuWidth)
+            // Track which providers the switcher was built with for smart update detection
+            if self.shouldMergeIcons, context.enabledProviders.count > 1 {
+                self.rememberMergedSwitcherState(
+                    context.enabledProviders,
+                    context.switcherSelection,
+                    context.includesOverview)
+            }
+            if self.shouldMergeIcons,
+               context.enabledProviders.count > 1,
+               self.addCachedMergedSwitcherContent(
+                   for: contentSelection,
+                   to: menu,
+                   menuWidth: context.menuWidth,
+                   codexAccountDisplay: context.codexAccountDisplay,
+                   tokenAccountDisplay: context.tokenAccountDisplay)
+            {
+                return
+            }
+            self.addCodexAccountSwitcherIfNeeded(
+                to: menu,
+                display: context.codexAccountDisplay,
+                width: context.menuWidth)
+            self.lastCodexAccountMenuDisplay = context.codexAccountDisplay
+            self.addTokenAccountSwitcherIfNeeded(
+                to: menu,
+                display: context.tokenAccountDisplay,
+                width: context.menuWidth)
+            self.lastTokenAccountMenuDisplay = context.tokenAccountDisplay
+            let menuContext = MenuCardContext(
+                currentProvider: context.currentProvider,
+                selectedProvider: context.selectedProvider,
+                menuWidth: context.menuWidth,
+                codexAccountDisplay: context.codexAccountDisplay,
+                tokenAccountDisplay: context.tokenAccountDisplay,
+                openAIContext: context.openAIContext)
+            self.addPrimaryMenuContent(
+                to: menu,
+                context: menuContext,
+                switcherSelection: contentSelection)
+            self.addActionableSections(context.descriptor.sections, to: menu, width: context.menuWidth)
+            self.cacheVisibleMergedSwitcherContent(
+                in: menu,
+                selection: contentSelection,
+                contentStartIndex: self.providerSwitcherContentStartIndex(in: menu),
+                menuWidth: context.menuWidth,
+                contentVersion: self.menuSession.contentVersion)
+        }
     }
 
     private func openAIWebContext(
         currentProvider: UsageProvider,
-        showAllTokenAccounts: Bool) -> OpenAIWebContext
+        showAllAccounts: Bool) -> OpenAIWebContext
     {
-        let dashboard = self.store.openAIDashboard
-        let openAIWebEligible = currentProvider == .codex &&
-            self.store.openAIDashboardRequiresLogin == false &&
-            dashboard != nil
-        let hasCreditsHistory = openAIWebEligible && !(dashboard?.dailyBreakdown ?? []).isEmpty
-        let hasUsageBreakdown = openAIWebEligible && !(dashboard?.usageBreakdown ?? []).isEmpty
+        let codexProjection = self.store.codexConsumerProjectionIfNeeded(
+            for: currentProvider,
+            surface: .liveCard)
+        let hasCreditsHistory = codexProjection?.hasCreditsHistory == true
+        let hasUsageBreakdown = codexProjection?.hasUsageBreakdown == true
         let hasCostHistory = self.settings.isCostUsageEffectivelyEnabled(for: currentProvider) &&
             (self.store.tokenSnapshot(for: currentProvider)?.daily.isEmpty == false)
-        let hasOpenAIWebMenuItems = !showAllTokenAccounts &&
+        let canShowBuyCredits = self.settings.showOptionalCreditsAndExtraUsage &&
+            codexProjection?.canShowBuyCredits == true
+        let hasOpenAIWebMenuItems = !showAllAccounts &&
             (hasCreditsHistory || hasUsageBreakdown || hasCostHistory)
         return OpenAIWebContext(
             hasUsageBreakdown: hasUsageBreakdown,
             hasCreditsHistory: hasCreditsHistory,
             hasCostHistory: hasCostHistory,
+            canShowBuyCredits: canShowBuyCredits,
             hasOpenAIWebMenuItems: hasOpenAIWebMenuItems)
     }
 
@@ -334,21 +481,46 @@ extension StatusItemController {
         to menu: NSMenu,
         enabledProviders: [UsageProvider],
         includesOverview: Bool,
-        selection: ProviderSwitcherSelection)
+        selection: ProviderSwitcherSelection,
+        width: CGFloat)
     {
         guard self.shouldMergeIcons, enabledProviders.count > 1 else { return }
         let switcherItem = self.makeProviderSwitcherItem(
             providers: enabledProviders,
             includesOverview: includesOverview,
             selected: selection,
-            menu: menu)
+            menu: menu,
+            width: width)
+        menu.addItem(switcherItem)
+        menu.addItem(.separator())
+    }
+
+    func addTokenAccountSwitcherIfNeeded(
+        to menu: NSMenu,
+        display: TokenAccountMenuDisplay?,
+        width: CGFloat,
+        captureMenu: NSMenu? = nil)
+    {
+        guard let display, display.showSwitcher else { return }
+        let switcherItem = self.makeTokenAccountSwitcherItem(
+            display: display,
+            menu: captureMenu ?? menu,
+            width: width)
         menu.addItem(switcherItem)
         menu.addItem(.separator())
     }
 
-    private func addTokenAccountSwitcherIfNeeded(to menu: NSMenu, display: TokenAccountMenuDisplay?) {
+    func addCodexAccountSwitcherIfNeeded(
+        to menu: NSMenu,
+        display: CodexAccountMenuDisplay?,
+        width: CGFloat,
+        captureMenu: NSMenu? = nil)
+    {
         guard let display, display.showSwitcher else { return }
-        let switcherItem = self.makeTokenAccountSwitcherItem(display: display, menu: menu)
+        let switcherItem = self.makeCodexAccountSwitcherItem(
+            display: display,
+            menu: captureMenu ?? menu,
+            width: width)
         menu.addItem(switcherItem)
         menu.addItem(.separator())
     }
@@ -357,30 +529,50 @@ extension StatusItemController {
     private func addOverviewRows(
         to menu: NSMenu,
         enabledProviders: [UsageProvider],
-        menuWidth: CGFloat) -> Bool
+        menuWidth: CGFloat,
+        captureMenu: NSMenu? = nil) -> Bool
     {
+        // Rows may be built into a detached scratch menu for in-place reconciliation;
+        // interaction closures must always reference the live menu they end up serving.
+        let interactionMenu = captureMenu ?? menu
         let overviewProviders = self.settings.reconcileMergedOverviewSelectedProviders(
             activeProviders: enabledProviders)
         let rows: [(provider: UsageProvider, model: UsageMenuCardView.Model)] = overviewProviders
             .compactMap { provider in
                 guard let model = self.menuCardModel(for: provider) else { return nil }
+                guard !model.isOverviewErrorOnly else { return nil }
                 return (provider: provider, model: model)
             }
         guard !rows.isEmpty else { return false }
 
+        let t0 = CACurrentMediaTime()
+        defer { self.logChartRenderDurationIfSlow("addOverviewRows(\(rows.count))", startedAt: t0) }
+
         for (index, row) in rows.enumerated() {
             let identifier = "\(Self.overviewRowIdentifierPrefix)\(row.provider.rawValue)"
+            let storageText = self.store.storageFootprintText(for: row.provider)
+            let submenu = self.makeOverviewRowSubmenu(
+                provider: row.provider,
+                model: row.model,
+                width: menuWidth)
             let item = self.makeMenuCardItem(
-                OverviewMenuCardRowView(model: row.model, width: menuWidth),
+                OverviewMenuCardRowView(model: row.model, storageText: storageText, width: menuWidth),
                 id: identifier,
                 width: menuWidth,
-                onClick: { [weak self, weak menu] in
-                    guard let self, let menu else { return }
-                    self.selectOverviewProvider(row.provider, menu: menu)
+                heightCacheScope: row.provider.rawValue,
+                heightCacheFingerprint: row.model.heightFingerprint(
+                    section: "overview",
+                    additional: [UsageMenuCardView.Model.heightFingerprintField("storage", storageText)]),
+                submenu: submenu,
+                onClick: { [weak self, weak interactionMenu] in
+                    guard let self, let interactionMenu else { return }
+                    self.selectOverviewProvider(row.provider, menu: interactionMenu)
                 })
-            // Keep menu item action wired for keyboard activation and accessibility action paths.
-            item.target = self
-            item.action = #selector(self.selectOverviewProvider(_:))
+            if submenu == nil {
+                // Keep plain rows wired for keyboard activation and accessibility action paths.
+                item.target = self
+                item.action = #selector(self.selectOverviewProvider(_:))
+            }
             menu.addItem(item)
             if index < rows.count - 1 {
                 menu.addItem(.separator())
@@ -393,11 +585,9 @@ extension StatusItemController {
         let resolvedProviders = self.settings.resolvedMergedOverviewProviders(
             activeProviders: enabledProviders,
             maxVisibleProviders: Self.maxOverviewProviders)
-        let message = if resolvedProviders.isEmpty {
-            "No providers selected for Overview."
-        } else {
-            "No overview data available."
-        }
+        let message = resolvedProviders.isEmpty
+            ? L("No providers selected for Overview.")
+            : L("No overview data available.")
         let item = NSMenuItem(title: message, action: nil, keyEquivalent: "")
         item.isEnabled = false
         item.representedObject = "overviewEmptyState"
@@ -405,6 +595,11 @@ extension StatusItemController {
     }
 
     private func addMenuCards(to menu: NSMenu, context: MenuCardContext) -> Bool {
+        if let codexAccountDisplay = context.codexAccountDisplay, codexAccountDisplay.showAll {
+            self.addStackedCodexMenuCards(codexAccountDisplay, to: menu, context: context)
+            return false
+        }
+
         if let tokenAccountDisplay = context.tokenAccountDisplay, tokenAccountDisplay.showAll {
             let accountSnapshots = tokenAccountDisplay.snapshots
             let cards = accountSnapshots.isEmpty
@@ -415,55 +610,95 @@ extension StatusItemController {
                         snapshotOverride: accountSnapshot.snapshot,
                         errorOverride: accountSnapshot.error)
                 }
-            if cards.isEmpty, let model = self.menuCardModel(for: context.selectedProvider) {
-                menu.addItem(self.makeMenuCardItem(
-                    UsageMenuCardView(model: model, width: context.menuWidth),
-                    id: "menuCard",
-                    width: context.menuWidth))
-                menu.addItem(.separator())
-            } else {
-                for (index, model) in cards.enumerated() {
-                    menu.addItem(self.makeMenuCardItem(
-                        UsageMenuCardView(model: model, width: context.menuWidth),
-                        id: "menuCard-\(index)",
-                        width: context.menuWidth))
-                    if index < cards.count - 1 {
-                        menu.addItem(.separator())
-                    }
-                }
-                if !cards.isEmpty {
-                    menu.addItem(.separator())
-                }
+            self.addStackedMenuCards(cards, to: menu, context: context)
+            return false
+        }
+
+        if context.currentProvider == .kilo, self.store.kiloScopeSnapshots.count > 1 {
+            let cards = self.store.kiloScopeSnapshots.compactMap { scope in
+                self.menuCardModel(
+                    for: .kilo,
+                    snapshotOverride: scope.snapshot,
+                    errorOverride: scope.errorMessage,
+                    forceOverrideCard: scope.snapshot == nil)
             }
+            self.addStackedMenuCards(cards, to: menu, context: context)
             return false
         }
 
         guard let model = self.menuCardModel(for: context.selectedProvider) else { return false }
-        if context.openAIContext.hasOpenAIWebMenuItems {
+        let renderedModel = self.menuCardRefreshMonitor.model(for: model.provider, fallback: model)
+        if context.openAIContext.hasOpenAIWebMenuItems || self
+            .hasOpenAIAPIUsageSubmenu(provider: context.currentProvider)
+        {
             let webItems = OpenAIWebMenuItems(
                 hasUsageBreakdown: context.openAIContext.hasUsageBreakdown,
                 hasCreditsHistory: context.openAIContext.hasCreditsHistory,
-                hasCostHistory: context.openAIContext.hasCostHistory)
+                hasCostHistory: context.openAIContext.hasCostHistory,
+                canShowBuyCredits: context.openAIContext.canShowBuyCredits)
             self.addMenuCardSections(
                 to: menu,
                 model: model,
-                provider: context.currentProvider,
+                layoutModel: renderedModel,
                 width: context.menuWidth,
                 webItems: webItems)
             return true
         }
 
         menu.addItem(self.makeMenuCardItem(
-            UsageMenuCardView(model: model, width: context.menuWidth),
+            UsageMenuCardView(model: model, layoutModel: renderedModel, width: context.menuWidth),
             id: "menuCard",
-            width: context.menuWidth))
-        if context.currentProvider == .codex, model.creditsText != nil {
+            width: context.menuWidth,
+            heightCacheScope: context.currentProvider.rawValue,
+            heightCacheFingerprint: renderedModel.heightFingerprint(section: "card"),
+            containsInteractiveControls: true))
+        if self.addStorageMenuCardSection(to: menu, provider: context.currentProvider, width: context.menuWidth) {
+            menu.addItem(.separator())
+        }
+        if context.openAIContext.canShowBuyCredits {
             menu.addItem(self.makeBuyCreditsItem())
         }
         menu.addItem(.separator())
         return false
     }
 
+    private func addStackedMenuCards(
+        _ cards: [UsageMenuCardView.Model],
+        to menu: NSMenu,
+        context: MenuCardContext)
+    {
+        if cards.isEmpty, let model = self.menuCardModel(for: context.selectedProvider) {
+            let renderedModel = self.menuCardRefreshMonitor.model(for: model.provider, fallback: model)
+            menu.addItem(self.makeMenuCardItem(
+                UsageMenuCardView(model: model, layoutModel: renderedModel, width: context.menuWidth),
+                id: "menuCard",
+                width: context.menuWidth,
+                heightCacheScope: context.currentProvider.rawValue,
+                heightCacheFingerprint: renderedModel.heightFingerprint(section: "card"),
+                containsInteractiveControls: true))
+            menu.addItem(.separator())
+        } else {
+            for (index, model) in cards.enumerated() {
+                menu.addItem(self.makeMenuCardItem(
+                    UsageMenuCardView(model: model, width: context.menuWidth),
+                    id: "menuCard-\(index)",
+                    width: context.menuWidth,
+                    heightCacheScope: "\(context.currentProvider.rawValue)-\(index)",
+                    heightCacheFingerprint: model.heightFingerprint(section: "card"),
+                    containsInteractiveControls: true))
+                if index < cards.count - 1 {
+                    menu.addItem(.separator())
+                }
+            }
+            if !cards.isEmpty {
+                menu.addItem(.separator())
+            }
+        }
+        if self.addStorageMenuCardSection(to: menu, provider: context.currentProvider, width: context.menuWidth) {
+            menu.addItem(.separator())
+        }
+    }
+
     private func addOpenAIWebItemsIfNeeded(
         to menu: NSMenu,
         currentProvider: UsageProvider,
@@ -483,13 +718,64 @@ extension StatusItemController {
                 _ = self.addCostHistorySubmenu(to: menu, provider: currentProvider)
             }
         }
-        menu.addItem(.separator())
+        if menu.items.last?.isSeparatorItem != true {
+            menu.addItem(.separator())
+        }
+    }
+
+    func addPrimaryMenuContent(
+        to menu: NSMenu,
+        context: MenuCardContext,
+        switcherSelection: ProviderSwitcherSelection,
+        captureMenu: NSMenu? = nil)
+    {
+        if switcherSelection == .overview {
+            let enabledProviders = self.store.enabledProvidersForDisplay()
+            if self.addOverviewRows(
+                to: menu,
+                enabledProviders: enabledProviders,
+                menuWidth: context.menuWidth,
+                captureMenu: captureMenu)
+            {
+                menu.addItem(.separator())
+            } else {
+                self.addOverviewEmptyState(to: menu, enabledProviders: enabledProviders)
+                menu.addItem(.separator())
+            }
+        } else {
+            let addedOpenAIWebItems = self.addMenuCards(to: menu, context: context)
+            self.addOpenAIWebItemsIfNeeded(
+                to: menu,
+                currentProvider: context.currentProvider,
+                context: context.openAIContext,
+                addedOpenAIWebItems: addedOpenAIWebItems)
+            if self.addUsageHistoryMenuItemIfNeeded(
+                to: menu,
+                provider: context.currentProvider,
+                width: context.menuWidth)
+            {
+                menu.addItem(.separator())
+            }
+            if self.addZaiHourlyUsageMenuItemIfNeeded(
+                to: menu,
+                provider: context.currentProvider,
+                width: context.menuWidth)
+            {
+                menu.addItem(.separator())
+            }
+        }
     }
 
-    private func addActionableSections(_ sections: [MenuDescriptor.Section], to menu: NSMenu) {
+    func addActionableSections(
+        _ sections: [MenuDescriptor.Section],
+        to menu: NSMenu,
+        width: CGFloat,
+        captureMenu: NSMenu? = nil)
+    {
         let actionableSections = sections.filter { section in
             section.entries.contains { entry in
                 if case .action = entry { return true }
+                if case .submenu = entry { return true }
                 return false
             }
         }
@@ -497,6 +783,10 @@ extension StatusItemController {
             for entry in section.entries {
                 switch entry {
                 case let .text(text, style):
+                    if style == .secondary {
+                        menu.addItem(self.makeWrappedSecondaryTextItem(text: text, width: width))
+                        continue
+                    }
                     let item = NSMenuItem(title: text, action: nil, keyEquivalent: "")
                     item.isEnabled = false
                     if style == .headline {
@@ -510,10 +800,25 @@ extension StatusItemController {
                     }
                     menu.addItem(item)
                 case let .action(title, action):
+                    if action == .refresh {
+                        let item = self.makePersistentRefreshItem(
+                            title: L(title),
+                            action: action,
+                            menu: captureMenu ?? menu,
+                            width: width)
+                        menu.addItem(item)
+                        self.persistentRefreshItems.add(item)
+                        continue
+                    }
+                    let localizedTitle = L(title)
                     let (selector, represented) = self.selector(for: action)
-                    let item = NSMenuItem(title: title, action: selector, keyEquivalent: "")
+                    let item = NSMenuItem(title: localizedTitle, action: selector, keyEquivalent: "")
                     item.target = self
                     item.representedObject = represented
+                    if let shortcut = self.shortcut(for: action) {
+                        item.keyEquivalent = shortcut.key
+                        item.keyEquivalentModifierMask = shortcut.modifiers
+                    }
                     if let iconName = action.systemImageName,
                        let image = NSImage(systemSymbolName: iconName, accessibilityDescription: nil)
                     {
@@ -525,8 +830,38 @@ extension StatusItemController {
                        let subtitle = self.switchAccountSubtitle(for: targetProvider)
                     {
                         item.isEnabled = false
-                        self.applySubtitle(subtitle, to: item, title: title)
+                        self.applySubtitle(subtitle, to: item, title: localizedTitle)
+                    } else if case .addCodexAccount = action,
+                              let subtitle = self.codexAddAccountSubtitle()
+                    {
+                        item.isEnabled = false
+                        self.applySubtitle(subtitle, to: item, title: localizedTitle)
+                    }
+                    menu.addItem(item)
+                case let .submenu(title, systemImageName, submenuItems):
+                    let item = NSMenuItem(title: title, action: nil, keyEquivalent: "")
+                    if let systemImageName,
+                       let image = NSImage(systemSymbolName: systemImageName, accessibilityDescription: nil)
+                    {
+                        image.isTemplate = true
+                        image.size = NSSize(width: 16, height: 16)
+                        item.image = image
                     }
+                    let submenu = NSMenu(title: title)
+                    submenu.autoenablesItems = false
+                    for submenuItem in submenuItems {
+                        let child = NSMenuItem(title: submenuItem.title, action: nil, keyEquivalent: "")
+                        child.state = submenuItem.isChecked ? .on : .off
+                        child.isEnabled = submenuItem.isEnabled
+                        if let action = submenuItem.action {
+                            let (selector, represented) = self.selector(for: action)
+                            child.action = selector
+                            child.target = self
+                            child.representedObject = represented
+                        }
+                        submenu.addItem(child)
+                    }
+                    item.submenu = submenu
                     menu.addItem(item)
                 case .divider:
                     menu.addItem(.separator())
@@ -538,27 +873,98 @@ extension StatusItemController {
         }
     }
 
+    private func makePersistentRefreshItem(
+        title: String,
+        action: MenuDescriptor.MenuAction,
+        menu: NSMenu,
+        width: CGFloat) -> NSMenuItem
+    {
+        let item = self.makeMenuCardItem(
+            PersistentMenuActionRowView(
+                title: title,
+                systemImageName: action.systemImageName),
+            id: Self.persistentRefreshMenuItemID,
+            width: width,
+            heightCacheFingerprint: "persistentRefreshAction:\(action.systemImageName ?? "")|\(title)",
+            onClick: { [weak self, weak menu] in
+                guard let self, let menu else { return }
+                self.performPersistentRefreshAction(in: ObjectIdentifier(menu))
+            })
+        item.title = title
+        item.isEnabled = !self.isRefreshActionInFlight(for: menu)
+        return item
+    }
+
+    private func makeWrappedSecondaryTextItem(text: String, width: CGFloat) -> NSMenuItem {
+        let item = NSMenuItem(title: "", action: nil, keyEquivalent: "")
+        let view = self.makeWrappedSecondaryTextView(text: text)
+        let height = self.menuTextItemHeight(for: view, width: width)
+        view.frame = NSRect(origin: .zero, size: NSSize(width: width, height: height))
+        item.view = view
+        item.isEnabled = false
+        item.toolTip = text
+        return item
+    }
+
+    private func makeWrappedSecondaryTextView(text: String) -> NSView {
+        let container = NSView()
+        container.translatesAutoresizingMaskIntoConstraints = false
+
+        let textField = NSTextField(wrappingLabelWithString: text)
+        textField.font = NSFont.menuFont(ofSize: NSFont.smallSystemFontSize)
+        textField.textColor = NSColor.secondaryLabelColor
+        textField.lineBreakMode = .byWordWrapping
+        textField.maximumNumberOfLines = 0
+        textField.setContentCompressionResistancePriority(.defaultLow, for: .horizontal)
+        textField.translatesAutoresizingMaskIntoConstraints = false
+
+        container.addSubview(textField)
+        // macos-smell:disable MACOS005
+        NSLayoutConstraint.activate([
+            textField.leadingAnchor.constraint(equalTo: container.leadingAnchor, constant: 18),
+            textField.trailingAnchor.constraint(equalTo: container.trailingAnchor, constant: -10),
+            textField.topAnchor.constraint(equalTo: container.topAnchor, constant: 2),
+            textField.bottomAnchor.constraint(equalTo: container.bottomAnchor, constant: -2),
+        ])
+
+        return container
+    }
+
+    private func menuTextItemHeight(for view: NSView, width: CGFloat) -> CGFloat {
+        view.frame = NSRect(origin: .zero, size: NSSize(width: width, height: 1))
+        view.layoutSubtreeIfNeeded()
+        return max(1, ceil(view.fittingSize.height))
+    }
+
     func makeMenu(for provider: UsageProvider?) -> NSMenu {
-        let menu = NSMenu()
-        menu.autoenablesItems = false
-        menu.delegate = self
+        let menu = self.makeBaseMenu()
         if let provider {
             self.menuProviders[ObjectIdentifier(menu)] = provider
         }
         return menu
     }
 
+    private func makeBaseMenu() -> NSMenu {
+        let menu = StatusItemMenu()
+        menu.autoenablesItems = false
+        menu.delegate = self
+        menu.persistentActionDelegate = self
+        StatusMenuAppearance.pin(menu)
+        return menu
+    }
+
     private func makeProviderSwitcherItem(
         providers: [UsageProvider],
         includesOverview: Bool,
         selected: ProviderSwitcherSelection,
-        menu: NSMenu) -> NSMenuItem
+        menu: NSMenu,
+        width: CGFloat) -> NSMenuItem
     {
         let view = ProviderSwitcherView(
             providers: providers,
             selected: selected,
             includesOverview: includesOverview,
-            width: self.menuCardWidth(for: providers, menu: menu),
+            width: width,
             showsIcons: self.settings.switcherShowsIcons,
             iconProvider: { [weak self] provider in
                 self?.switcherIcon(for: provider) ?? NSImage()
@@ -568,22 +974,27 @@ extension StatusItemController {
             },
             onSelect: { [weak self, weak menu] selection in
                 guard let self, let menu else { return }
-                switch selection {
-                case .overview:
-                    self.settings.mergedMenuLastSelectedWasOverview = true
-                    self.lastMergedSwitcherSelection = .overview
-                    let provider = self.resolvedMenuProvider()
-                    self.lastMenuProvider = provider ?? .codex
-                    self.populateMenu(menu, provider: provider)
-                case let .provider(provider):
-                    self.settings.mergedMenuLastSelectedWasOverview = false
-                    self.lastMergedSwitcherSelection = .provider(provider)
-                    self.selectedMenuProvider = provider
-                    self.lastMenuProvider = provider
-                    self.populateMenu(menu, provider: provider)
+                var provider: UsageProvider?
+                self.preservingMergedSwitcherContentCachesDuringInvalidation {
+                    switch selection {
+                    case .overview:
+                        self.settings.mergedMenuLastSelectedWasOverview = true
+                        provider = self.resolvedMenuProvider()
+                    case let .provider(selectedProvider):
+                        self.settings.mergedMenuLastSelectedWasOverview = false
+                        self.selectedMenuProvider = selectedProvider
+                        provider = selectedProvider
+                    }
+                    switch selection {
+                    case .overview:
+                        self.lastMenuProvider = provider ?? .codex
+                    case let .provider(provider):
+                        self.lastMenuProvider = provider
+                    }
+                    self.lastMergedSwitcherSelection = selection
+                    self.refreshProviderSelectionDependentUI(deferRendering: true)
                 }
-                self.markMenuFresh(menu)
-                self.applyIcon(phase: nil)
+                self.requestProviderSwitcherMenuRebuild(menu, provider: provider)
             })
         let item = NSMenuItem()
         item.view = view
@@ -593,23 +1004,31 @@ extension StatusItemController {
 
     private func makeTokenAccountSwitcherItem(
         display: TokenAccountMenuDisplay,
-        menu: NSMenu) -> NSMenuItem
+        menu: NSMenu,
+        width: CGFloat) -> NSMenuItem
     {
         let view = TokenAccountSwitcherView(
             accounts: display.accounts,
             selectedIndex: display.activeIndex,
-            width: self.menuCardWidth(for: self.store.enabledProviders(), menu: menu),
-            onSelect: { [weak self, weak menu] index in
-                guard let self, let menu else { return }
+            width: width,
+            onSelect: { [weak self, weak menu] index -> Task<Void, Never>? in
+                guard let self, let menu else { return nil }
+                guard display.accounts.indices.contains(index) else { return nil }
+                let selectedAccount = display.accounts[index]
                 self.settings.setActiveTokenAccountIndex(index, for: display.provider)
-                Task { @MainActor in
+                self.store.activateCachedTokenAccountSnapshot(
+                    provider: display.provider,
+                    accountID: selectedAccount.id)
+                self.applyIcon(phase: nil)
+                self.deferSwitcherMenuRebuildIfStillVisible(menu, provider: display.provider)
+                return Task { @MainActor [weak self, weak menu] in
+                    guard let self else { return }
                     await ProviderInteractionContext.$current.withValue(.userInitiated) {
-                        await self.store.refresh()
+                        await self.store.refreshProvider(display.provider)
                     }
+                    guard let menu else { return }
+                    self.deferSwitcherMenuRebuildIfStillVisible(menu, provider: display.provider)
                 }
-                self.populateMenu(menu, provider: display.provider)
-                self.markMenuFresh(menu)
-                self.applyIcon(phase: nil)
             })
         let item = NSMenuItem()
         item.view = view
@@ -617,13 +1036,60 @@ extension StatusItemController {
         return item
     }
 
-    private func resolvedMenuProvider(enabledProviders: [UsageProvider]? = nil) -> UsageProvider? {
-        let enabled = enabledProviders ?? self.store.enabledProviders()
+    private func makeCodexAccountSwitcherItem(
+        display: CodexAccountMenuDisplay,
+        menu: NSMenu,
+        width: CGFloat) -> NSMenuItem
+    {
+        let view = CodexAccountSwitcherView(
+            accounts: display.accounts,
+            selectedAccountID: display.activeVisibleAccountID,
+            width: width,
+            onSelect: { [weak self, weak menu] account in
+                guard let self else { return }
+                self.handleCodexVisibleAccountSelection(account, menu: menu)
+            })
+        let item = NSMenuItem()
+        item.view = view
+        item.isEnabled = false
+        return item
+    }
+
+    @discardableResult
+    private func handleCodexVisibleAccountSelection(_ account: CodexVisibleAccount, menu: NSMenu?) -> Bool {
+        let visibleAccountID = account.id
+        self.settings.selectDisplayedCodexVisibleAccount(account)
+        if self.store.prepareCodexAccountScopedRefreshIfNeeded(), let menu {
+            self.deferSwitcherMenuRebuildIfStillVisible(menu, provider: .codex)
+        }
+        let store = self.store
+        let settings = self.settings
+        Task { @MainActor [weak controller = self, weak menu, store, settings] in
+            await ProviderInteractionContext.$current.withValue(.userInitiated) {
+                await store.refreshCodexAccountScopedState(
+                    allowDisabled: true,
+                    phaseDidChange: { [weak controller, weak menu, settings] _ in
+                        guard let controller, let menu else { return }
+                        guard settings.codexVisibleAccountProjection.activeVisibleAccountID == visibleAccountID
+                        else {
+                            return
+                        }
+                        controller.refreshOpenMenuIfStillVisible(menu, provider: .codex)
+                    })
+            }
+        }
+        return true
+    }
+
+    func resolvedMenuProvider(enabledProviders: [UsageProvider]? = nil) -> UsageProvider? {
+        let enabled = enabledProviders ?? self.store.enabledProvidersForDisplay()
         if enabled.isEmpty { return .codex }
         if let selected = self.selectedMenuProvider, enabled.contains(selected) {
             return selected
         }
-        return enabled.first
+        // Prefer an available provider so the default menu content matches the status icon.
+        // Falls back to first display provider when all lack credentials.
+        return enabled.first(where: { self.store.isProviderAvailable($0) }) ?? enabled.first
     }
 
     private func includesOverviewTab(enabledProviders: [UsageProvider]) -> Bool {
@@ -642,59 +1108,7 @@ extension StatusItemController {
         return .provider(self.resolvedMenuProvider(enabledProviders: enabledProviders) ?? .codex)
     }
 
-    private func tokenAccountMenuDisplay(for provider: UsageProvider) -> TokenAccountMenuDisplay? {
-        guard TokenAccountSupportCatalog.support(for: provider) != nil else { return nil }
-        let accounts = self.settings.tokenAccounts(for: provider)
-        guard accounts.count > 1 else { return nil }
-        let activeIndex = self.settings.tokenAccountsData(for: provider)?.clampedActiveIndex() ?? 0
-        let showAll = self.settings.showAllTokenAccountsInMenu
-        let snapshots = showAll ? (self.store.accountSnapshots[provider] ?? []) : []
-        return TokenAccountMenuDisplay(
-            provider: provider,
-            accounts: accounts,
-            snapshots: snapshots,
-            activeIndex: activeIndex,
-            showAll: showAll,
-            showSwitcher: !showAll)
-    }
-
-    private func menuNeedsRefresh(_ menu: NSMenu) -> Bool {
-        let key = ObjectIdentifier(menu)
-        return self.menuVersions[key] != self.menuContentVersion
-    }
-
-    private func markMenuFresh(_ menu: NSMenu) {
-        let key = ObjectIdentifier(menu)
-        self.menuVersions[key] = self.menuContentVersion
-    }
-
-    func refreshOpenMenusIfNeeded() {
-        guard !self.openMenus.isEmpty else { return }
-        for (key, menu) in self.openMenus {
-            guard key == ObjectIdentifier(menu) else {
-                // Clean up orphaned menu entries from all tracking dictionaries
-                self.openMenus.removeValue(forKey: key)
-                self.menuRefreshTasks.removeValue(forKey: key)?.cancel()
-                self.menuProviders.removeValue(forKey: key)
-                self.menuVersions.removeValue(forKey: key)
-                continue
-            }
-
-            if self.isHostedSubviewMenu(menu) {
-                self.refreshHostedSubviewHeights(in: menu)
-                continue
-            }
-
-            if self.menuNeedsRefresh(menu) {
-                let provider = self.menuProvider(for: menu)
-                self.populateMenu(menu, provider: provider)
-                self.markMenuFresh(menu)
-                // Heights are already set during populateMenu, no need to remeasure
-            }
-        }
-    }
-
-    private func menuProvider(for menu: NSMenu) -> UsageProvider? {
+    func menuProvider(for menu: NSMenu) -> UsageProvider? {
         if self.shouldMergeIcons {
             return self.resolvedMenuProvider()
         }
@@ -704,14 +1118,19 @@ extension StatusItemController {
         if menu === self.fallbackMenu {
             return nil
         }
-        return self.store.enabledProviders().first ?? .codex
+        return self.store.enabledProvidersForDisplay().first ?? .codex
     }
 
     private func scheduleOpenMenuRefresh(for menu: NSMenu) {
-        // Kick off a user-initiated refresh on open (non-forced) and re-check after a delay.
-        // NEVER block menu opening with network requests.
-        if !self.store.isRefreshing {
-            self.refreshStore(forceTokenUsage: false)
+        // Queue refresh work only when visible menu data is missing or stale. Here "stale" means the last
+        // provider fetch failed and needs a retry; periodic freshness is handled by the refresh timer.
+        // AppKit menu tracking is modal, so starting provider refreshes while it is active can make the menu
+        // feel frozen and can block keyboard focus from returning.
+        let providersNeedingRetryAtOpen = self.delayedRefreshRetryProviders(for: menu).filter {
+            self.store.isStale(provider: $0) || self.store.snapshot(for: $0) == nil
+        }
+        if !providersNeedingRetryAtOpen.isEmpty {
+            self.deferMenuInteractionRefreshIfNeeded(providers: providersNeedingRetryAtOpen)
         }
         let key = ObjectIdentifier(menu)
         self.menuRefreshTasks[key]?.cancel()
@@ -719,10 +1138,50 @@ extension StatusItemController {
             guard let self, let menu else { return }
             try? await Task.sleep(for: Self.menuOpenRefreshDelay)
             guard !Task.isCancelled else { return }
+            guard self.isMenuRefreshEnabled else { return }
+            #if DEBUG
+            self.onDelayedMenuRefreshAttemptForTesting?()
+            #endif
+            guard self.openMenus[ObjectIdentifier(menu)] != nil else { return }
+            let availableProviders = Set(self.store.enabledProvidersForBackgroundWork())
+            let retryProviders = self.delayedRefreshRetryProviders(for: menu).filter {
+                availableProviders.contains($0) &&
+                    (self.store.refreshingProviders.contains($0) ||
+                        self.store.isStale(provider: $0) ||
+                        self.store.snapshot(for: $0) == nil)
+            }
+            guard !retryProviders.isEmpty else {
+                self.clearSatisfiedDeferredMenuInteractionRefreshes(
+                    for: self.delayedRefreshRetryProviders(for: menu))
+                // Ordinary store changes intentionally stay queued until the next open. Rebuilding here
+                // made first-open work such as the storage scan flash the visible menu after 1.2 seconds.
+                if !providersNeedingRetryAtOpen.isEmpty, self.menuNeedsRefresh(menu) {
+                    self.scheduleOpenMenuRebuildIfStillVisible(
+                        menu,
+                        provider: self.menuProvider(for: menu),
+                        resyncReadinessBaselineAfterRebuild: self.openMenus.count == 1)
+                }
+                return
+            }
+            self.deferMenuInteractionRefreshIfNeeded(providers: retryProviders)
+            await ProviderInteractionContext.$current.withValue(.background) {
+                for provider in retryProviders {
+                    guard !Task.isCancelled else { return }
+                    await self.store.refreshProvider(provider, coalesceIfRefreshing: true)
+                }
+            }
+            let stillNeedsRetry = retryProviders.contains {
+                self.store.isStale(provider: $0) || self.store.snapshot(for: $0) == nil
+            }
+            if !stillNeedsRetry {
+                self.clearSatisfiedDeferredMenuInteractionRefreshes(for: retryProviders)
+            }
+            guard !Task.isCancelled else { return }
             guard self.openMenus[ObjectIdentifier(menu)] != nil else { return }
-            guard !self.store.isRefreshing else { return }
-            guard self.menuNeedsDelayedRefreshRetry(for: menu) else { return }
-            self.refreshStore(forceTokenUsage: false)
+            self.invalidateMenus(
+                refreshOpenMenus: true,
+                deferOpenParentMenuRebuild: false,
+                allowStaleContentDuringDataRefresh: true)
         }
     }
 
@@ -735,7 +1194,11 @@ extension StatusItemController {
     }
 
     private func delayedRefreshRetryProviders(for menu: NSMenu) -> [UsageProvider] {
-        let enabledProviders = self.store.enabledProviders()
+        self.renderedProviders(for: menu)
+    }
+
+    func renderedProviders(for menu: NSMenu) -> [UsageProvider] {
+        let enabledProviders = self.store.enabledProvidersForDisplay()
         guard !enabledProviders.isEmpty else { return [] }
         let includesOverview = self.includesOverviewTab(enabledProviders: enabledProviders)
 
@@ -758,128 +1221,74 @@ extension StatusItemController {
         return enabledProviders
     }
 
-    private func refreshMenuCardHeights(in menu: NSMenu) {
-        // Re-measure the menu card height right before display to avoid stale/incorrect sizing when content
-        // changes (e.g. dashboard error lines causing wrapping).
-        let cardItems = menu.items.filter { item in
-            (item.representedObject as? String)?.hasPrefix("menuCard") == true
-        }
-        for item in cardItems {
-            guard let view = item.view else { continue }
-            let width = self.menuCardWidth(for: self.store.enabledProviders(), menu: menu)
-            let height = self.menuCardHeight(for: view, width: width)
-            view.frame = NSRect(
-                origin: .zero,
-                size: NSSize(width: width, height: height))
-        }
-    }
-
-    private func makeMenuCardItem(
-        _ view: some View,
-        id: String,
-        width: CGFloat,
-        submenu: NSMenu? = nil,
-        onClick: (() -> Void)? = nil) -> NSMenuItem
-    {
-        if !Self.menuCardRenderingEnabled {
-            let item = NSMenuItem()
-            item.isEnabled = true
-            item.representedObject = id
-            item.submenu = submenu
-            if submenu != nil {
-                item.target = self
-                item.action = #selector(self.menuCardNoOp(_:))
-            }
-            return item
-        }
-
-        let highlightState = MenuCardHighlightState()
-        let wrapped = MenuCardSectionContainerView(
-            highlightState: highlightState,
-            showsSubmenuIndicator: submenu != nil)
-        {
-            view
-        }
-        let hosting = MenuCardItemHostingView(rootView: wrapped, highlightState: highlightState, onClick: onClick)
-        // Set frame with target width immediately
-        let height = self.menuCardHeight(for: hosting, width: width)
-        hosting.frame = NSRect(origin: .zero, size: NSSize(width: width, height: height))
-        let item = NSMenuItem()
-        item.view = hosting
-        item.isEnabled = true
-        item.representedObject = id
-        item.submenu = submenu
-        if submenu != nil {
-            item.target = self
-            item.action = #selector(self.menuCardNoOp(_:))
-        }
-        return item
-    }
-
-    private func menuCardHeight(for view: NSView, width: CGFloat) -> CGFloat {
-        let basePadding: CGFloat = 6
-        let descenderSafety: CGFloat = 1
-
-        // Fast path: use protocol-based measurement when available (avoids layout passes)
-        if let measured = view as? MenuCardMeasuring {
-            return max(1, ceil(measured.measuredHeight(width: width) + basePadding + descenderSafety))
-        }
-
-        // Set frame with target width before measuring.
-        view.frame = NSRect(origin: .zero, size: NSSize(width: width, height: 1))
-
-        // Use fittingSize directly - SwiftUI hosting views respect the frame width for wrapping
-        let fitted = view.fittingSize
-
-        return max(1, ceil(fitted.height + basePadding + descenderSafety))
-    }
-
     private func addMenuCardSections(
         to menu: NSMenu,
         model: UsageMenuCardView.Model,
-        provider: UsageProvider,
+        layoutModel: UsageMenuCardView.Model,
         width: CGFloat,
         webItems: OpenAIWebMenuItems)
     {
-        let hasUsageBlock = !model.metrics.isEmpty || model.placeholder != nil
-        let hasCredits = model.creditsText != nil
-        let hasExtraUsage = model.providerCost != nil
-        let hasCost = model.tokenUsage != nil
+        let provider = layoutModel.provider
+        let hasUsageBlock = layoutModel.hasUsageContent
+        let hasCredits = layoutModel.creditsText != nil
+        let hasExtraUsage = layoutModel.providerCost != nil
+        let hasCost = layoutModel.tokenUsage != nil
+        let hasStorage = self.store.storageFootprintText(for: provider) != nil
         let bottomPadding = CGFloat(hasCredits ? 4 : 6)
         let sectionSpacing = CGFloat(6)
         let usageBottomPadding = bottomPadding
         let creditsBottomPadding = bottomPadding
-
-        let headerView = UsageMenuCardHeaderSectionView(
-            model: model,
-            showDivider: hasUsageBlock,
-            width: width)
-        menu.addItem(self.makeMenuCardItem(headerView, id: "menuCardHeader", width: width))
+        func addSectionSeparator() {
+            guard menu.items.last?.isSeparatorItem != true else { return }
+            menu.addItem(.separator())
+        }
 
         if hasUsageBlock {
-            let usageView = UsageMenuCardUsageSectionView(
+            let usageView = UsageMenuCardHeaderAndUsageSectionView(
                 model: model,
-                showBottomDivider: false,
+                layoutModel: layoutModel,
                 bottomPadding: usageBottomPadding,
                 width: width)
             let usageSubmenu = self.makeUsageSubmenu(
                 provider: provider,
                 snapshot: self.store.snapshot(for: provider),
-                webItems: webItems)
+                webItems: webItems,
+                width: width)
             menu.addItem(self.makeMenuCardItem(
                 usageView,
                 id: "menuCardUsage",
                 width: width,
-                submenu: usageSubmenu))
+                heightCacheScope: provider.rawValue,
+                heightCacheFingerprint: layoutModel.heightFingerprint(section: "usage"),
+                submenu: usageSubmenu,
+                containsInteractiveControls: true))
+        } else {
+            let headerView = UsageMenuCardHeaderSectionView(
+                model: layoutModel,
+                showDivider: false,
+                width: width)
+            menu.addItem(self.makeMenuCardItem(
+                headerView,
+                id: "menuCardHeader",
+                width: width,
+                heightCacheScope: provider.rawValue,
+                heightCacheFingerprint: layoutModel.heightFingerprint(section: "header"),
+                containsInteractiveControls: true))
         }
 
-        if hasCredits || hasExtraUsage || hasCost {
-            menu.addItem(.separator())
+        if hasStorage || hasCredits || hasExtraUsage || hasCost {
+            addSectionSeparator()
+        }
+
+        if self.addStorageMenuCardSection(to: menu, provider: provider, width: width),
+           hasCredits || hasExtraUsage
+        {
+            addSectionSeparator()
         }
 
         if hasCredits {
             if hasExtraUsage || hasCost {
-                menu.addItem(.separator())
+                addSectionSeparator()
             }
             let creditsView = UsageMenuCardCreditsSectionView(
                 model: model,
@@ -887,20 +1296,23 @@ extension StatusItemController {
                 topPadding: sectionSpacing,
                 bottomPadding: creditsBottomPadding,
                 width: width)
-            let creditsSubmenu = webItems.hasCreditsHistory ? self.makeCreditsHistorySubmenu() : nil
+            let creditsSubmenu = webItems.hasCreditsHistory ? self.makeCreditsHistorySubmenu(width: width) : nil
             menu.addItem(self.makeMenuCardItem(
                 creditsView,
                 id: "menuCardCredits",
                 width: width,
+                heightCacheScope: provider.rawValue,
+                heightCacheFingerprint: layoutModel.heightFingerprint(section: "credits"),
                 submenu: creditsSubmenu))
-            if provider == .codex {
+            if webItems.canShowBuyCredits {
                 menu.addItem(self.makeBuyCreditsItem())
             }
         }
         if hasExtraUsage {
             if hasCredits {
-                menu.addItem(.separator())
+                addSectionSeparator()
             }
+            let extraUsageSubmenu = self.makeOpenAIAPIUsageSubmenu(provider: provider, width: width)
             let extraUsageView = UsageMenuCardExtraUsageSectionView(
                 model: model,
                 topPadding: sectionSpacing,
@@ -909,26 +1321,42 @@ extension StatusItemController {
             menu.addItem(self.makeMenuCardItem(
                 extraUsageView,
                 id: "menuCardExtraUsage",
-                width: width))
+                width: width,
+                heightCacheScope: provider.rawValue,
+                heightCacheFingerprint: layoutModel.heightFingerprint(section: "extraUsage"),
+                submenu: extraUsageSubmenu))
         }
         if hasCost {
             if hasCredits || hasExtraUsage {
-                menu.addItem(.separator())
+                addSectionSeparator()
             }
-            let costView = UsageMenuCardCostSectionView(
+            let costSubmenu = webItems.hasCostHistory ? self
+                .makeCostHistorySubmenu(provider: provider, width: width) : nil
+            menu.addItem(self.makeCostMenuCardItem(
                 model: model,
-                topPadding: sectionSpacing,
-                bottomPadding: bottomPadding,
-                width: width)
-            let costSubmenu = webItems.hasCostHistory ? self.makeCostHistorySubmenu(provider: provider) : nil
-            menu.addItem(self.makeMenuCardItem(
-                costView,
-                id: "menuCardCost",
-                width: width,
-                submenu: costSubmenu))
+                submenu: costSubmenu,
+                width: width))
         }
     }
 
+    @discardableResult
+    func addStorageMenuCardSection(to menu: NSMenu, provider: UsageProvider, width: CGFloat) -> Bool {
+        guard let storageText = self.store.storageFootprintText(for: provider) else { return false }
+        let storageSubmenu = self.makeStorageBreakdownSubmenu(provider: provider, width: width)
+        let menuFont = NSFont.menuFont(ofSize: 0)
+        let title = NSMutableAttributedString(string: L("Storage"), attributes: [.font: menuFont])
+        title.append(NSAttributedString(
+            string: "  \(storageText)",
+            attributes: [.font: menuFont, .foregroundColor: NSColor.secondaryLabelColor]))
+        let item = NSMenuItem(title: L("Storage"), action: nil, keyEquivalent: "")
+        item.attributedTitle = title
+        item.isEnabled = storageSubmenu != nil
+        item.representedObject = "menuCardStorage"
+        item.submenu = storageSubmenu
+        menu.addItem(item)
+        return true
+    }
+
     private func switcherIcon(for provider: UsageProvider) -> NSImage {
         if let brand = ProviderBrandIcon.image(for: provider) {
             return brand
@@ -937,28 +1365,27 @@ extension StatusItemController {
         // Fallback to the dynamic icon renderer if resources are missing (e.g. dev bundle mismatch).
         let snapshot = self.store.snapshot(for: provider)
         let showUsed = self.settings.usageBarsShowUsed
-        let primary = showUsed ? snapshot?.primary?.usedPercent : snapshot?.primary?.remainingPercent
-        var weekly = showUsed ? snapshot?.secondary?.usedPercent : snapshot?.secondary?.remainingPercent
-        if showUsed,
-           provider == .warp,
-           let remaining = snapshot?.secondary?.remainingPercent,
-           remaining <= 0
-        {
-            // Preserve Warp "no bonus/exhausted bonus" layout even in show-used mode.
-            weekly = 0
-        }
-        if showUsed,
-           provider == .warp,
-           let remaining = snapshot?.secondary?.remainingPercent,
-           remaining > 0,
-           weekly == 0
-        {
-            // In show-used mode, `0` means "unused", not "missing". Keep the weekly lane present.
-            weekly = 0.0001
-        }
-        let credits = provider == .codex ? self.store.credits?.remaining : nil
-        let stale = self.store.isStale(provider: provider)
         let style = self.store.style(for: provider)
+        let resolved = snapshot.map {
+            IconRemainingResolver.resolvedPercents(
+                snapshot: $0,
+                style: style,
+                showUsed: showUsed,
+                secondaryOverrideWindowID: self.settings.copilotIconSecondaryWindowOverrideID(snapshot: $0))
+        }
+        let primary = resolved?.primary
+        let weekly = resolved?.secondary
+        let creditsProjection = self.store.codexConsumerProjectionIfNeeded(
+            for: provider,
+            surface: .menuBar,
+            snapshotOverride: snapshot,
+            now: snapshot?.updatedAt ?? Date())
+        let credits = creditsProjection?.menuBarFallback == .creditsBalance
+            ? self.store.codexMenuBarCreditsRemaining(
+                snapshotOverride: snapshot,
+                now: snapshot?.updatedAt ?? Date())
+            : nil
+        let stale = self.store.isStale(provider: provider)
         let indicator = self.store.statusIndicator(for: provider)
         let image = IconRenderer.makeIcon(
             primaryRemaining: primary,
@@ -969,166 +1396,17 @@ extension StatusItemController {
             blink: 0,
             wiggle: 0,
             tilt: 0,
-            statusIndicator: indicator)
+            statusIndicator: indicator,
+            hideCritters: self.settings.menuBarHidesCritters)
         image.isTemplate = true
         return image
     }
 
-    nonisolated static func switcherWeeklyMetricPercent(
-        for provider: UsageProvider,
-        snapshot: UsageSnapshot?,
-        showUsed: Bool) -> Double?
-    {
-        let window = snapshot?.switcherWeeklyWindow(for: provider, showUsed: showUsed)
-        guard let window else { return nil }
-        return showUsed ? window.usedPercent : window.remainingPercent
-    }
-
-    private func switcherWeeklyRemaining(for provider: UsageProvider) -> Double? {
-        Self.switcherWeeklyMetricPercent(
-            for: provider,
-            snapshot: self.store.snapshot(for: provider),
-            showUsed: self.settings.usageBarsShowUsed)
-    }
-
-    private func selector(for action: MenuDescriptor.MenuAction) -> (Selector, Any?) {
-        switch action {
-        case .installUpdate: (#selector(self.installUpdate), nil)
-        case .refresh: (#selector(self.refreshNow), nil)
-        case .refreshAugmentSession: (#selector(self.refreshAugmentSession), nil)
-        case .dashboard: (#selector(self.openDashboard), nil)
-        case .statusPage: (#selector(self.openStatusPage), nil)
-        case let .switchAccount(provider): (#selector(self.runSwitchAccount(_:)), provider.rawValue)
-        case let .openTerminal(command): (#selector(self.openTerminalCommand(_:)), command)
-        case let .loginToProvider(url): (#selector(self.openLoginToProvider(_:)), url)
-        case .settings: (#selector(self.showSettingsGeneral), nil)
-        case .about: (#selector(self.showSettingsAbout), nil)
-        case .quit: (#selector(self.quit), nil)
-        case let .copyError(message): (#selector(self.copyError(_:)), message)
-        }
-    }
-
-    @MainActor
-    private protocol MenuCardHighlighting: AnyObject {
-        func setHighlighted(_ highlighted: Bool)
-    }
-
-    @MainActor
-    private protocol MenuCardMeasuring: AnyObject {
-        func measuredHeight(width: CGFloat) -> CGFloat
-    }
-
-    @MainActor
-    @Observable
-    fileprivate final class MenuCardHighlightState {
-        var isHighlighted = false
-    }
-
-    private final class MenuHostingView<Content: View>: NSHostingView<Content> {
-        override var allowsVibrancy: Bool {
-            true
-        }
-    }
-
-    @MainActor
-    private final class MenuCardItemHostingView<Content: View>: NSHostingView<Content>, MenuCardHighlighting,
-    MenuCardMeasuring {
-        private let highlightState: MenuCardHighlightState
-        private let onClick: (() -> Void)?
-        override var allowsVibrancy: Bool {
-            true
-        }
-
-        override var intrinsicContentSize: NSSize {
-            let size = super.intrinsicContentSize
-            guard self.frame.width > 0 else { return size }
-            return NSSize(width: self.frame.width, height: size.height)
-        }
-
-        init(rootView: Content, highlightState: MenuCardHighlightState, onClick: (() -> Void)? = nil) {
-            self.highlightState = highlightState
-            self.onClick = onClick
-            super.init(rootView: rootView)
-            if onClick != nil {
-                let recognizer = NSClickGestureRecognizer(target: self, action: #selector(self.handlePrimaryClick(_:)))
-                recognizer.buttonMask = 0x1
-                self.addGestureRecognizer(recognizer)
-            }
-        }
-
-        required init(rootView: Content) {
-            self.highlightState = MenuCardHighlightState()
-            self.onClick = nil
-            super.init(rootView: rootView)
-        }
-
-        @available(*, unavailable)
-        required init?(coder: NSCoder) {
-            fatalError("init(coder:) has not been implemented")
-        }
-
-        override func acceptsFirstMouse(for event: NSEvent?) -> Bool {
-            true
-        }
-
-        @objc private func handlePrimaryClick(_ recognizer: NSClickGestureRecognizer) {
-            guard recognizer.state == .ended else { return }
-            self.onClick?()
-        }
-
-        func measuredHeight(width: CGFloat) -> CGFloat {
-            let controller = NSHostingController(rootView: self.rootView)
-            let measured = controller.sizeThatFits(in: CGSize(width: width, height: .greatestFiniteMagnitude))
-            return measured.height
-        }
-
-        func setHighlighted(_ highlighted: Bool) {
-            guard self.highlightState.isHighlighted != highlighted else { return }
-            self.highlightState.isHighlighted = highlighted
-        }
-    }
-
-    private struct MenuCardSectionContainerView<Content: View>: View {
-        @Bindable var highlightState: MenuCardHighlightState
-        let showsSubmenuIndicator: Bool
-        let content: Content
-
-        init(
-            highlightState: MenuCardHighlightState,
-            showsSubmenuIndicator: Bool,
-            @ViewBuilder content: () -> Content)
-        {
-            self.highlightState = highlightState
-            self.showsSubmenuIndicator = showsSubmenuIndicator
-            self.content = content()
-        }
-
-        var body: some View {
-            self.content
-                .environment(\.menuItemHighlighted, self.highlightState.isHighlighted)
-                .foregroundStyle(MenuHighlightStyle.primary(self.highlightState.isHighlighted))
-                .background(alignment: .topLeading) {
-                    if self.highlightState.isHighlighted {
-                        RoundedRectangle(cornerRadius: 6, style: .continuous)
-                            .fill(MenuHighlightStyle.selectionBackground(true))
-                            .padding(.horizontal, 6)
-                            .padding(.vertical, 2)
-                    }
-                }
-                .overlay(alignment: .topTrailing) {
-                    if self.showsSubmenuIndicator {
-                        Image(systemName: "chevron.right")
-                            .font(.caption2.weight(.semibold))
-                            .foregroundStyle(MenuHighlightStyle.secondary(self.highlightState.isHighlighted))
-                            .padding(.top, 8)
-                            .padding(.trailing, 10)
-                    }
-                }
-        }
-    }
-
     private func makeBuyCreditsItem() -> NSMenuItem {
-        let item = NSMenuItem(title: "Buy Credits...", action: #selector(self.openCreditsPurchase), keyEquivalent: "")
+        let item = NSMenuItem(
+            title: L("Buy Credits..."),
+            action: #selector(self.openCreditsPurchase),
+            keyEquivalent: "")
         item.target = self
         if let image = NSImage(systemSymbolName: "plus.circle", accessibilityDescription: nil) {
             image.isTemplate = true
@@ -1140,8 +1418,9 @@ extension StatusItemController {
 
     @discardableResult
     private func addCreditsHistorySubmenu(to menu: NSMenu) -> Bool {
-        guard let submenu = self.makeCreditsHistorySubmenu() else { return false }
-        let item = NSMenuItem(title: "Credits history", action: nil, keyEquivalent: "")
+        guard let submenu = self.makeCreditsHistorySubmenu(width: self.renderedMenuWidth(for: menu))
+        else { return false }
+        let item = NSMenuItem(title: L("Credits history"), action: nil, keyEquivalent: "")
         item.isEnabled = true
         item.submenu = submenu
         menu.addItem(item)
@@ -1150,8 +1429,9 @@ extension StatusItemController {
 
     @discardableResult
     private func addUsageBreakdownSubmenu(to menu: NSMenu) -> Bool {
-        guard let submenu = self.makeUsageBreakdownSubmenu() else { return false }
-        let item = NSMenuItem(title: "Usage breakdown", action: nil, keyEquivalent: "")
+        guard let submenu = self.makeUsageBreakdownSubmenu(width: self.renderedMenuWidth(for: menu))
+        else { return false }
+        let item = NSMenuItem(title: L("Usage breakdown"), action: nil, keyEquivalent: "")
         item.isEnabled = true
         item.submenu = submenu
         menu.addItem(item)
@@ -1160,8 +1440,11 @@ extension StatusItemController {
 
     @discardableResult
     private func addCostHistorySubmenu(to menu: NSMenu, provider: UsageProvider) -> Bool {
-        guard let submenu = self.makeCostHistorySubmenu(provider: provider) else { return false }
-        let item = NSMenuItem(title: "Usage history (30 days)", action: nil, keyEquivalent: "")
+        guard let submenu = self.makeCostHistorySubmenu(provider: provider, width: self.renderedMenuWidth(for: menu))
+        else { return false }
+        let days = self.store.settings.costUsageHistoryDays
+        let title = days == 1 ? L("Usage history (today)") : String(format: L("Usage history (%d days)"), days)
+        let item = NSMenuItem(title: title, action: nil, keyEquivalent: "")
         item.isEnabled = true
         item.submenu = submenu
         menu.addItem(item)
@@ -1171,10 +1454,14 @@ extension StatusItemController {
     private func makeUsageSubmenu(
         provider: UsageProvider,
         snapshot: UsageSnapshot?,
-        webItems: OpenAIWebMenuItems) -> NSMenu?
+        webItems: OpenAIWebMenuItems,
+        width: CGFloat? = nil) -> NSMenu?
     {
-        if provider == .codex, webItems.hasUsageBreakdown {
-            return self.makeUsageBreakdownSubmenu()
+        if webItems.hasUsageBreakdown {
+            return self.makeUsageBreakdownSubmenu(width: width)
+        }
+        if provider == .openai {
+            return self.makeOpenAIAPIUsageSubmenu(provider: provider, width: width)
         }
         if provider == .zai {
             return self.makeZaiUsageDetailsSubmenu(snapshot: snapshot)
@@ -1182,18 +1469,18 @@ extension StatusItemController {
         return nil
     }
 
-    private func makeZaiUsageDetailsSubmenu(snapshot: UsageSnapshot?) -> NSMenu? {
+    func makeZaiUsageDetailsSubmenu(snapshot: UsageSnapshot?) -> NSMenu? {
         guard let timeLimit = snapshot?.zaiUsage?.timeLimit else { return nil }
         guard !timeLimit.usageDetails.isEmpty else { return nil }
 
         let submenu = NSMenu()
         submenu.delegate = self
-        let titleItem = NSMenuItem(title: "MCP details", action: nil, keyEquivalent: "")
+        let titleItem = NSMenuItem(title: L("MCP details"), action: nil, keyEquivalent: "")
         titleItem.isEnabled = false
         submenu.addItem(titleItem)
 
         if let window = timeLimit.windowLabel {
-            let item = NSMenuItem(title: "Window: \(window)", action: nil, keyEquivalent: "")
+            let item = NSMenuItem(title: String(format: L("mcp_window"), window), action: nil, keyEquivalent: "")
             item.isEnabled = false
             submenu.addItem(item)
         }
@@ -1201,7 +1488,7 @@ extension StatusItemController {
             let reset = self.settings.resetTimeDisplayStyle == .absolute
                 ? UsageFormatter.resetDescription(from: resetTime)
                 : UsageFormatter.resetCountdownDescription(from: resetTime)
-            let item = NSMenuItem(title: "Resets: \(reset)", action: nil, keyEquivalent: "")
+            let item = NSMenuItem(title: String(format: L("mcp_resets"), reset), action: nil, keyEquivalent: "")
             item.isEnabled = false
             submenu.addItem(item)
         }
@@ -1212,129 +1499,79 @@ extension StatusItemController {
         }
         for detail in sortedDetails {
             let usage = UsageFormatter.tokenCountString(detail.usage)
-            let item = NSMenuItem(title: "\(detail.modelCode): \(usage)", action: nil, keyEquivalent: "")
+            let item = NSMenuItem(
+                title: String(format: L("mcp_model_usage"), detail.modelCode, usage),
+                action: nil,
+                keyEquivalent: "")
             submenu.addItem(item)
         }
         return submenu
     }
 
-    private func makeUsageBreakdownSubmenu() -> NSMenu? {
-        let breakdown = self.store.openAIDashboard?.usageBreakdown ?? []
-        let width = Self.menuCardBaseWidth
+    private func makeUsageBreakdownSubmenu(width: CGFloat? = nil) -> NSMenu? {
+        let breakdown = OpenAIDashboardDailyBreakdown.removingSkillUsageServices(
+            from: self.store.openAIDashboard?.usageBreakdown ?? [])
         guard !breakdown.isEmpty else { return nil }
-
-        if !Self.menuCardRenderingEnabled {
-            let submenu = NSMenu()
-            submenu.delegate = self
-            let chartItem = NSMenuItem()
-            chartItem.isEnabled = false
-            chartItem.representedObject = "usageBreakdownChart"
-            submenu.addItem(chartItem)
-            return submenu
+        if let width {
+            return self.makeHostedSubviewPlaceholderMenu(chartID: Self.usageBreakdownChartID, width: width)
         }
-
-        let submenu = NSMenu()
-        submenu.delegate = self
-        let chartView = UsageBreakdownChartMenuView(breakdown: breakdown, width: width)
-        let hosting = MenuHostingView(rootView: chartView)
-        // Use NSHostingController for efficient size calculation without multiple layout passes
-        let controller = NSHostingController(rootView: chartView)
-        let size = controller.sizeThatFits(in: CGSize(width: width, height: .greatestFiniteMagnitude))
-        hosting.frame = NSRect(origin: .zero, size: NSSize(width: width, height: size.height))
-
-        let chartItem = NSMenuItem()
-        chartItem.view = hosting
-        chartItem.isEnabled = false
-        chartItem.representedObject = "usageBreakdownChart"
-        submenu.addItem(chartItem)
-        return submenu
+        return self.makeHostedSubviewPlaceholderMenu(chartID: Self.usageBreakdownChartID)
     }
 
-    private func makeCreditsHistorySubmenu() -> NSMenu? {
-        let breakdown = self.store.openAIDashboard?.dailyBreakdown ?? []
-        let width = Self.menuCardBaseWidth
-        guard !breakdown.isEmpty else { return nil }
-
-        if !Self.menuCardRenderingEnabled {
-            let submenu = NSMenu()
-            submenu.delegate = self
-            let chartItem = NSMenuItem()
-            chartItem.isEnabled = false
-            chartItem.representedObject = "creditsHistoryChart"
-            submenu.addItem(chartItem)
-            return submenu
+    private func makeCreditsHistorySubmenu(width: CGFloat? = nil) -> NSMenu? {
+        guard !(self.store.openAIDashboard?.dailyBreakdown ?? []).isEmpty else { return nil }
+        if let width {
+            return self.makeHostedSubviewPlaceholderMenu(chartID: Self.creditsHistoryChartID, width: width)
         }
-
-        let submenu = NSMenu()
-        submenu.delegate = self
-        let chartView = CreditsHistoryChartMenuView(breakdown: breakdown, width: width)
-        let hosting = MenuHostingView(rootView: chartView)
-        // Use NSHostingController for efficient size calculation without multiple layout passes
-        let controller = NSHostingController(rootView: chartView)
-        let size = controller.sizeThatFits(in: CGSize(width: width, height: .greatestFiniteMagnitude))
-        hosting.frame = NSRect(origin: .zero, size: NSSize(width: width, height: size.height))
-
-        let chartItem = NSMenuItem()
-        chartItem.view = hosting
-        chartItem.isEnabled = false
-        chartItem.representedObject = "creditsHistoryChart"
-        submenu.addItem(chartItem)
-        return submenu
+        return self.makeHostedSubviewPlaceholderMenu(chartID: Self.creditsHistoryChartID)
     }
 
-    private func makeCostHistorySubmenu(provider: UsageProvider) -> NSMenu? {
-        guard provider == .codex || provider == .claude || provider == .vertexai else { return nil }
-        let width = Self.menuCardBaseWidth
-        guard let tokenSnapshot = self.store.tokenSnapshot(for: provider) else { return nil }
-        guard !tokenSnapshot.daily.isEmpty else { return nil }
+    func makeCostHistorySubmenu(provider: UsageProvider, width: CGFloat? = nil) -> NSMenu? {
+        guard ProviderDescriptorRegistry.descriptor(for: provider).tokenCost.supportsTokenCost else { return nil }
+        guard self.tokenSnapshotForCostHistorySubmenu(provider: provider)?.daily.isEmpty == false else { return nil }
+        if let width {
+            return self.makeHostedSubviewPlaceholderMenu(
+                chartID: Self.costHistoryChartID,
+                provider: provider,
+                width: width)
+        }
+        return self.makeHostedSubviewPlaceholderMenu(chartID: Self.costHistoryChartID, provider: provider)
+    }
 
-        if !Self.menuCardRenderingEnabled {
-            let submenu = NSMenu()
-            submenu.delegate = self
-            let chartItem = NSMenuItem()
-            chartItem.isEnabled = false
-            chartItem.representedObject = "costHistoryChart"
-            submenu.addItem(chartItem)
-            return submenu
+    func tokenSnapshotForCostHistorySubmenu(provider: UsageProvider) -> CostUsageTokenSnapshot? {
+        let projected = self.store.tokenSnapshot(
+            fromProviderSnapshot: self.store.snapshot(for: provider),
+            provider: provider)
+        if UsageStore.tokenCostRequiresProviderSnapshot(provider) {
+            return projected
         }
+        return projected ?? self.store.tokenSnapshot(for: provider)
+    }
 
-        let submenu = NSMenu()
-        submenu.delegate = self
-        let chartView = CostHistoryChartMenuView(
-            provider: provider,
-            daily: tokenSnapshot.daily,
-            totalCostUSD: tokenSnapshot.last30DaysCostUSD,
-            width: width)
-        let hosting = MenuHostingView(rootView: chartView)
-        // Use NSHostingController for efficient size calculation without multiple layout passes
-        let controller = NSHostingController(rootView: chartView)
-        let size = controller.sizeThatFits(in: CGSize(width: width, height: .greatestFiniteMagnitude))
-        hosting.frame = NSRect(origin: .zero, size: NSSize(width: width, height: size.height))
-
-        let chartItem = NSMenuItem()
-        chartItem.view = hosting
-        chartItem.isEnabled = false
-        chartItem.representedObject = "costHistoryChart"
-        submenu.addItem(chartItem)
-        return submenu
+    func makeOpenAIAPIUsageSubmenu(provider: UsageProvider, width: CGFloat? = nil) -> NSMenu? {
+        guard self.hasOpenAIAPIUsageSubmenu(provider: provider) else { return nil }
+        return self.makeCostHistorySubmenu(provider: provider, width: width)
     }
 
-    private func isHostedSubviewMenu(_ menu: NSMenu) -> Bool {
-        let ids: Set<String> = [
-            "usageBreakdownChart",
-            "creditsHistoryChart",
-            "costHistoryChart",
-        ]
-        return menu.items.contains { item in
-            guard let id = item.representedObject as? String else { return false }
-            return ids.contains(id)
+    private func hasOpenAIAPIUsageSubmenu(provider: UsageProvider) -> Bool {
+        provider == .openai && self.tokenSnapshotForCostHistorySubmenu(provider: provider)?.daily.isEmpty == false
+    }
+
+    func makeStorageBreakdownSubmenu(provider: UsageProvider, width: CGFloat? = nil) -> NSMenu? {
+        guard self.store.storageFootprint(for: provider)?.components.isEmpty == false else { return nil }
+        if let width {
+            return self.makeHostedSubviewPlaceholderMenu(
+                chartID: Self.storageBreakdownID,
+                provider: provider,
+                width: width)
         }
+        return self.makeHostedSubviewPlaceholderMenu(chartID: Self.storageBreakdownID, provider: provider)
     }
 
     private func isOpenAIWebSubviewMenu(_ menu: NSMenu) -> Bool {
-        let ids: Set<String> = [
-            "usageBreakdownChart",
-            "creditsHistoryChart",
+        let ids: Set = [
+            Self.usageBreakdownChartID,
+            Self.creditsHistoryChartID,
         ]
         return menu.items.contains { item in
             guard let id = item.representedObject as? String else { return false }
@@ -1342,162 +1579,28 @@ extension StatusItemController {
         }
     }
 
-    private func refreshHostedSubviewHeights(in menu: NSMenu) {
-        let enabledProviders = self.store.enabledProviders()
-        let width = self.menuCardWidth(for: enabledProviders, menu: menu)
+    func refreshHostedSubviewHeights(in menu: NSMenu) {
+        let width = self.renderedMenuWidth(for: menu)
 
         for item in menu.items {
             guard let view = item.view else { continue }
-            view.frame = NSRect(origin: .zero, size: NSSize(width: width, height: 1))
-            view.layoutSubtreeIfNeeded()
-            let height = view.fittingSize.height
+            let height = self.hostedSubviewFittingHeight(for: view, width: width)
             view.frame = NSRect(origin: .zero, size: NSSize(width: width, height: height))
         }
     }
 
-    private func menuCardModel(
-        for provider: UsageProvider?,
-        snapshotOverride: UsageSnapshot? = nil,
-        errorOverride: String? = nil) -> UsageMenuCardView.Model?
-    {
-        let target = provider ?? self.store.enabledProviders().first ?? .codex
-        let metadata = self.store.metadata(for: target)
-
-        let snapshot = snapshotOverride ?? self.store.snapshot(for: target)
-        let credits: CreditsSnapshot?
-        let creditsError: String?
-        let dashboard: OpenAIDashboardSnapshot?
-        let dashboardError: String?
-        let tokenSnapshot: CostUsageTokenSnapshot?
-        let tokenError: String?
-        if target == .codex, snapshotOverride == nil {
-            credits = self.store.credits
-            creditsError = self.store.lastCreditsError
-            dashboard = self.store.openAIDashboardRequiresLogin ? nil : self.store.openAIDashboard
-            dashboardError = self.store.lastOpenAIDashboardError
-            tokenSnapshot = self.store.tokenSnapshot(for: target)
-            tokenError = self.store.tokenError(for: target)
-        } else if target == .claude || target == .vertexai, snapshotOverride == nil {
-            credits = nil
-            creditsError = nil
-            dashboard = nil
-            dashboardError = nil
-            tokenSnapshot = self.store.tokenSnapshot(for: target)
-            tokenError = self.store.tokenError(for: target)
-        } else {
-            credits = nil
-            creditsError = nil
-            dashboard = nil
-            dashboardError = nil
-            tokenSnapshot = nil
-            tokenError = nil
-        }
-
-        let sourceLabel = snapshotOverride == nil ? self.store.sourceLabel(for: target) : nil
-        let kiloAutoMode = target == .kilo && self.settings.kiloUsageDataSource == .auto
-        let now = Date()
-        let weeklyPace = snapshot?.secondary.flatMap { window in
-            self.store.weeklyPace(provider: target, window: window, now: now)
-        }
-        let input = UsageMenuCardView.Model.Input(
-            provider: target,
-            metadata: metadata,
-            snapshot: snapshot,
-            credits: credits,
-            creditsError: creditsError,
-            dashboard: dashboard,
-            dashboardError: dashboardError,
-            tokenSnapshot: tokenSnapshot,
-            tokenError: tokenError,
-            account: self.account,
-            isRefreshing: self.store.isRefreshing,
-            lastError: errorOverride ?? self.store.error(for: target),
-            usageBarsShowUsed: self.settings.usageBarsShowUsed,
-            resetTimeDisplayStyle: self.settings.resetTimeDisplayStyle,
-            tokenCostUsageEnabled: self.settings.isCostUsageEffectivelyEnabled(for: target),
-            showOptionalCreditsAndExtraUsage: self.settings.showOptionalCreditsAndExtraUsage,
-            sourceLabel: sourceLabel,
-            kiloAutoMode: kiloAutoMode,
-            hidePersonalInfo: self.settings.hidePersonalInfo,
-            weeklyPace: weeklyPace,
-            now: now)
-        return UsageMenuCardView.Model.make(input)
+    /// Measures the natural height of a hosted submenu view at the given width using the live
+    /// view that will actually be displayed. Hosted chart items used to spin up a second,
+    /// throwaway `NSHostingController` purely to size the chart even though every build path
+    /// immediately re-measures the live view via `fittingSize`; that extra SwiftUI hierarchy was
+    /// pure overhead on a popup-menu hot path, so callers now size the displayed view directly.
+    func hostedSubviewFittingHeight(for view: NSView, width: CGFloat) -> CGFloat {
+        view.frame = NSRect(origin: .zero, size: NSSize(width: width, height: 1))
+        view.layoutSubtreeIfNeeded()
+        return view.fittingSize.height
     }
 
-    @objc private func menuCardNoOp(_ sender: NSMenuItem) {
+    @objc func menuCardNoOp(_ sender: NSMenuItem) {
         _ = sender
     }
-
-    @objc private func selectOverviewProvider(_ sender: NSMenuItem) {
-        guard let represented = sender.representedObject as? String,
-              represented.hasPrefix(Self.overviewRowIdentifierPrefix)
-        else {
-            return
-        }
-        let rawProvider = String(represented.dropFirst(Self.overviewRowIdentifierPrefix.count))
-        guard let provider = UsageProvider(rawValue: rawProvider),
-              let menu = sender.menu
-        else {
-            return
-        }
-
-        self.selectOverviewProvider(provider, menu: menu)
-    }
-
-    private func selectOverviewProvider(_ provider: UsageProvider, menu: NSMenu) {
-        if !self.settings.mergedMenuLastSelectedWasOverview, self.selectedMenuProvider == provider { return }
-        self.settings.mergedMenuLastSelectedWasOverview = false
-        self.lastMergedSwitcherSelection = nil
-        self.selectedMenuProvider = provider
-        self.lastMenuProvider = provider
-        self.populateMenu(menu, provider: provider)
-        self.markMenuFresh(menu)
-        self.applyIcon(phase: nil)
-    }
-
-    private func applySubtitle(_ subtitle: String, to item: NSMenuItem, title: String) {
-        if #available(macOS 14.4, *) {
-            // NSMenuItem.subtitle is only available on macOS 14.4+.
-            item.subtitle = subtitle
-        } else {
-            item.view = self.makeMenuSubtitleView(title: title, subtitle: subtitle, isEnabled: item.isEnabled)
-            item.toolTip = "\(title) — \(subtitle)"
-        }
-    }
-
-    private func makeMenuSubtitleView(title: String, subtitle: String, isEnabled: Bool) -> NSView {
-        let container = NSView()
-        container.translatesAutoresizingMaskIntoConstraints = false
-        container.alphaValue = isEnabled ? 1.0 : 0.7
-
-        let titleField = NSTextField(labelWithString: title)
-        titleField.font = NSFont.menuFont(ofSize: NSFont.systemFontSize)
-        titleField.textColor = NSColor.labelColor
-        titleField.lineBreakMode = .byTruncatingTail
-        titleField.maximumNumberOfLines = 1
-        titleField.setContentCompressionResistancePriority(.defaultLow, for: .horizontal)
-
-        let subtitleField = NSTextField(labelWithString: subtitle)
-        subtitleField.font = NSFont.menuFont(ofSize: NSFont.smallSystemFontSize)
-        subtitleField.textColor = NSColor.secondaryLabelColor
-        subtitleField.lineBreakMode = .byTruncatingTail
-        subtitleField.maximumNumberOfLines = 1
-        subtitleField.setContentCompressionResistancePriority(.defaultLow, for: .horizontal)
-
-        let stack = NSStackView(views: [titleField, subtitleField])
-        stack.orientation = .vertical
-        stack.alignment = .leading
-        stack.spacing = 1
-        stack.translatesAutoresizingMaskIntoConstraints = false
-        container.addSubview(stack)
-
-        NSLayoutConstraint.activate([
-            stack.leadingAnchor.constraint(equalTo: container.leadingAnchor, constant: 18),
-            stack.trailingAnchor.constraint(equalTo: container.trailingAnchor, constant: -10),
-            stack.topAnchor.constraint(equalTo: container.topAnchor, constant: 2),
-            stack.bottomAnchor.constraint(equalTo: container.bottomAnchor, constant: -2),
-        ])
-
-        return container
-    }
 }
diff --git a/Sources/CodexBar/StatusItemController+MenuActionMapping.swift b/Sources/CodexBar/StatusItemController+MenuActionMapping.swift
new file mode 100644
index 0000000000..f889207928
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+MenuActionMapping.swift
@@ -0,0 +1,33 @@
+import AppKit
+
+extension StatusItemController {
+    func selector(for action: MenuDescriptor.MenuAction) -> (Selector, Any?) {
+        switch action {
+        case .installUpdate: (#selector(self.installUpdate), nil)
+        case .refresh: (#selector(self.refreshMenuItem(_:)), nil)
+        case .refreshAugmentSession: (#selector(self.refreshAugmentSession), nil)
+        case .dashboard: (#selector(self.openDashboard), nil)
+        case .statusPage: (#selector(self.openStatusPage), nil)
+        case .changelog: (#selector(self.openChangelog), nil)
+        case .addCodexAccount: (#selector(self.addManagedCodexAccountFromMenu(_:)), nil)
+        case let .addProviderAccount(provider): (#selector(self.runSwitchAccount(_:)), provider.rawValue)
+        case let .requestCodexSystemPromotion(managedAccountID):
+            (#selector(self.requestCodexSystemPromotionFromMenu(_:)), managedAccountID.uuidString)
+        case let .switchAccount(provider): (#selector(self.runSwitchAccount(_:)), provider.rawValue)
+        case let .openTerminal(command): (#selector(self.openTerminalCommand(_:)), command)
+        case let .loginToProvider(url): (#selector(self.openLoginToProvider(_:)), url)
+        case .settings: (#selector(self.showSettingsGeneral), nil)
+        case .about: (#selector(self.showSettingsAbout), nil)
+        case .quit: (#selector(self.quit), nil)
+        case let .copyError(message): (#selector(self.copyError(_:)), message)
+        }
+    }
+
+    func codexAddAccountSubtitle() -> String? {
+        if self.settings.hasUnreadableManagedCodexAccountStore {
+            return "Managed account storage unavailable"
+        }
+        guard self.managedCodexAccountCoordinator.isAuthenticatingManagedAccount else { return nil }
+        return "Managed Codex login in progress…"
+    }
+}
diff --git a/Sources/CodexBar/StatusItemController+MenuAppearance.swift b/Sources/CodexBar/StatusItemController+MenuAppearance.swift
new file mode 100644
index 0000000000..c83ddad62f
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+MenuAppearance.swift
@@ -0,0 +1,13 @@
+import AppKit
+
+@MainActor
+enum StatusMenuAppearance {
+    static func pin(_ menu: NSMenu) {
+        self.pin(menu, to: NSApplication.shared.effectiveAppearance)
+    }
+
+    static func pin(_ menu: NSMenu, to appearance: NSAppearance) {
+        // The exact effective appearance carries accessibility attributes that its name can omit.
+        menu.appearance = appearance
+    }
+}
diff --git a/Sources/CodexBar/StatusItemController+MenuCardHeightCache.swift b/Sources/CodexBar/StatusItemController+MenuCardHeightCache.swift
new file mode 100644
index 0000000000..5f1bd162b5
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+MenuCardHeightCache.swift
@@ -0,0 +1,54 @@
+import AppKit
+
+extension StatusItemController {
+    struct MenuCardHeightCacheKey: Hashable {
+        let id: String
+        let scope: String
+        let width: Int
+        let textScale: Int
+        let fingerprint: String
+    }
+
+    /// Measured card height also depends on the resolved font sizes, which the menu cards
+    /// derive from semantic text styles (`.body`, `.footnote`, …). Those scale with the
+    /// macOS system text-size / Dynamic Type setting, which is neither part of the content
+    /// fingerprint nor invalidated on rebuild. Fold the current resolved scale into the key
+    /// so a runtime text-size change forces a fresh measurement instead of returning a
+    /// height measured at the old scale (clipped / over-tall cards).
+    static func menuCardHeightTextScaleToken() -> Int {
+        Int((NSFont.preferredFont(forTextStyle: .body).pointSize * 100).rounded())
+    }
+
+    func cachedMenuCardHeight(
+        for id: String,
+        scope: String,
+        width: CGFloat,
+        fingerprint: String? = nil,
+        measure: () -> CGFloat) -> CGFloat
+    {
+        let key = MenuCardHeightCacheKey(
+            id: id,
+            scope: scope,
+            width: Int((width * 100).rounded()),
+            textScale: Self.menuCardHeightTextScaleToken(),
+            fingerprint: fingerprint ?? "version:\(self.menuSession.contentVersion)")
+        if let cached = self.menuCardHeightCache[key] {
+            return cached
+        }
+        let height = measure()
+        if self.menuCardHeightCache.count > 256 {
+            self.menuCardHeightCache.removeAll(keepingCapacity: true)
+        }
+        self.menuCardHeightCache[key] = height
+        return height
+    }
+
+    func pruneVersionScopedMenuCardHeightCache() {
+        let currentVersionFingerprint = "version:\(self.menuSession.contentVersion)"
+        for key in self.menuCardHeightCache.keys
+            where key.fingerprint.hasPrefix("version:") && key.fingerprint != currentVersionFingerprint
+        {
+            self.menuCardHeightCache.removeValue(forKey: key)
+        }
+    }
+}
diff --git a/Sources/CodexBar/StatusItemController+MenuCardItems.swift b/Sources/CodexBar/StatusItemController+MenuCardItems.swift
new file mode 100644
index 0000000000..eb7b0e5173
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+MenuCardItems.swift
@@ -0,0 +1,116 @@
+import AppKit
+import SwiftUI
+
+extension StatusItemController {
+    func refreshMenuCardHeights(in menu: NSMenu) {
+        let width = self.renderedMenuWidth(for: menu)
+        for item in menu.items {
+            guard let view = item.view, view is any MenuCardMeasuring else { continue }
+            guard abs(view.frame.width - width) > 0.5 else { continue }
+            let id = item.representedObject as? String ?? "menuCard"
+            let scope = self.menuProvider(for: menu)?.rawValue ?? id
+            let height = self.cachedMenuCardHeight(for: id, scope: scope, width: width) {
+                self.menuCardHeight(for: view, width: width)
+            }
+            view.frame = NSRect(
+                origin: .zero,
+                size: NSSize(width: width, height: height))
+        }
+    }
+
+    func makeMenuCardItem<CardContent: View>(
+        _ view: CardContent,
+        id: String,
+        width: CGFloat,
+        heightCacheScope: String? = nil,
+        heightCacheFingerprint: String? = nil,
+        submenu: NSMenu? = nil,
+        submenuIndicatorAlignment: Alignment = .topTrailing,
+        submenuIndicatorTopPadding: CGFloat = 8,
+        containsInteractiveControls: Bool = false,
+        onClick: (() -> Void)? = nil) -> NSMenuItem
+    {
+        let allowsMenuHighlight = submenu != nil || onClick != nil
+        if !self.menuCardRenderingEnabledForController {
+            let item = NSMenuItem()
+            item.isEnabled = allowsMenuHighlight
+            item.representedObject = id
+            item.submenu = submenu
+            if submenu != nil {
+                item.target = self
+                item.action = #selector(self.menuCardNoOp(_:))
+            }
+            return item
+        }
+
+        let hosting: MenuCardItemHostingView<MenuCardSectionContainerView<CardContent>>
+        if let recycled = self.takeRecyclableMenuCardView(
+            for: id,
+            as: MenuCardItemHostingView<MenuCardSectionContainerView<CardContent>>.self)
+        {
+            let wrapped = MenuCardSectionContainerView(
+                highlightState: recycled.highlightState,
+                showsSubmenuIndicator: submenu != nil,
+                submenuIndicatorAlignment: submenuIndicatorAlignment,
+                submenuIndicatorTopPadding: submenuIndicatorTopPadding,
+                refreshMonitor: self.menuCardRefreshMonitor)
+            {
+                view
+            }
+            recycled.prepareForReuse(
+                rootView: wrapped,
+                allowsMenuHighlight: allowsMenuHighlight,
+                onClick: onClick)
+            hosting = recycled
+        } else {
+            let highlightState = MenuCardHighlightState()
+            let wrapped = MenuCardSectionContainerView(
+                highlightState: highlightState,
+                showsSubmenuIndicator: submenu != nil,
+                submenuIndicatorAlignment: submenuIndicatorAlignment,
+                submenuIndicatorTopPadding: submenuIndicatorTopPadding,
+                refreshMonitor: self.menuCardRefreshMonitor)
+            {
+                view
+            }
+            hosting = MenuCardItemHostingView(
+                rootView: wrapped,
+                highlightState: highlightState,
+                allowsMenuHighlight: allowsMenuHighlight,
+                onClick: onClick)
+        }
+        let height = self.cachedMenuCardHeight(
+            for: id,
+            scope: heightCacheScope ?? id,
+            width: width,
+            fingerprint: heightCacheFingerprint)
+        {
+            self.menuCardHeight(for: hosting, width: width)
+        }
+        hosting.frame = NSRect(origin: .zero, size: NSSize(width: width, height: height))
+
+        let item = NSMenuItem()
+        item.view = hosting
+        item.isEnabled = allowsMenuHighlight || containsInteractiveControls
+        item.representedObject = id
+        item.submenu = submenu
+        if submenu != nil {
+            item.target = self
+            item.action = #selector(self.menuCardNoOp(_:))
+        }
+        return item
+    }
+
+    private func menuCardHeight(for view: NSView, width: CGFloat) -> CGFloat {
+        let basePadding: CGFloat = 6
+        let descenderSafety: CGFloat = 1
+
+        if let measured = view as? MenuCardMeasuring {
+            return max(1, ceil(measured.measuredHeight(width: width) + basePadding + descenderSafety))
+        }
+
+        view.frame = NSRect(origin: .zero, size: NSSize(width: width, height: 1))
+        let fitted = view.fittingSize
+        return max(1, ceil(fitted.height + basePadding + descenderSafety))
+    }
+}
diff --git a/Sources/CodexBar/StatusItemController+MenuCardModel.swift b/Sources/CodexBar/StatusItemController+MenuCardModel.swift
new file mode 100644
index 0000000000..adbc71d3c3
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+MenuCardModel.swift
@@ -0,0 +1,136 @@
+import CodexBarCore
+import Foundation
+
+extension StatusItemController {
+    func menuCardModel(
+        for provider: UsageProvider?,
+        snapshotOverride: UsageSnapshot? = nil,
+        errorOverride: String? = nil,
+        forceOverrideCard: Bool = false,
+        accountOverride: AccountInfo? = nil) -> UsageMenuCardView.Model?
+    {
+        let target = provider ?? self.store.enabledProvidersForDisplay().first ?? .codex
+        let metadata = self.store.metadata(for: target)
+
+        let usesOverrideCard = forceOverrideCard || snapshotOverride != nil || errorOverride != nil
+        let surface: CodexConsumerProjection.Surface = if usesOverrideCard {
+            .overrideCard
+        } else {
+            .liveCard
+        }
+        // Override cards belong to a specific account/context. Never fall back to
+        // provider-level live data here; that can belong to a different account.
+        let snapshot: UsageSnapshot? = if surface == .overrideCard {
+            snapshotOverride
+        } else {
+            snapshotOverride ?? self.store.snapshot(for: target)
+        }
+        let projectedTokenSnapshot = self.store.tokenSnapshot(fromProviderSnapshot: snapshot, provider: target)
+        let storedTokenSnapshot = UsageStore.tokenCostRequiresProviderSnapshot(target)
+            ? nil
+            : self.store.tokenSnapshot(for: target)
+        let now = Date()
+        let codexProjection = self.store.codexConsumerProjectionIfNeeded(
+            for: target,
+            surface: surface,
+            snapshotOverride: snapshotOverride,
+            errorOverride: errorOverride,
+            now: now)
+        let credits: CreditsSnapshot?
+        let creditsError: String?
+        let dashboard: OpenAIDashboardSnapshot?
+        let dashboardError: String?
+        let tokenSnapshot: CostUsageTokenSnapshot?
+        let tokenError: String?
+        if let codexProjection {
+            credits = codexProjection.credits?.snapshot
+            creditsError = codexProjection.credits?.userFacingError
+            dashboard = nil
+            dashboardError = codexProjection.userFacingErrors.dashboard
+            if surface == .liveCard {
+                tokenSnapshot = projectedTokenSnapshot ?? storedTokenSnapshot
+                tokenError = self.store.tokenError(for: target)
+            } else {
+                tokenSnapshot = projectedTokenSnapshot
+                tokenError = nil
+            }
+        } else if ProviderDescriptorRegistry.descriptor(for: target).tokenCost.supportsTokenCost,
+                  snapshotOverride == nil
+        {
+            credits = nil
+            creditsError = nil
+            dashboard = nil
+            dashboardError = nil
+            tokenSnapshot = projectedTokenSnapshot ?? storedTokenSnapshot
+            tokenError = self.store.tokenError(for: target)
+        } else {
+            credits = nil
+            creditsError = nil
+            dashboard = nil
+            dashboardError = nil
+            tokenSnapshot = projectedTokenSnapshot
+            tokenError = nil
+        }
+
+        let sourceLabel = snapshotOverride == nil ? self.store.sourceLabel(for: target) : nil
+        let kiloAutoMode = target == .kilo && self.settings.kiloUsageDataSource == .auto
+        // Abacus uses primary for monthly credits (no secondary window)
+        let paceWindow = target == .abacus ? snapshot?.primary : snapshot?.secondary
+        let weeklyPace = if let codexProjection,
+                            let weekly = codexProjection.rateWindow(for: .weekly)
+        {
+            self.store.weeklyPace(provider: target, window: weekly, now: now)
+        } else {
+            paceWindow.flatMap { window in
+                self.store.weeklyPace(provider: target, window: window, now: now)
+            }
+        }
+        let fallbackAccount = accountOverride
+            ?? (metadata.usesAccountFallback
+                ? self.store.accountInfo(for: target)
+                : AccountInfo(email: nil, plan: nil))
+        let input = UsageMenuCardView.Model.Input(
+            provider: target,
+            metadata: metadata,
+            snapshot: snapshot,
+            codexProjection: codexProjection,
+            credits: credits,
+            creditsError: creditsError,
+            dashboard: dashboard,
+            dashboardError: dashboardError,
+            tokenSnapshot: tokenSnapshot,
+            tokenError: tokenError,
+            account: fallbackAccount,
+            isRefreshing: self.store.shouldShowRefreshingMenuCardIndicator(for: target),
+            lastError: errorOverride
+                ?? codexProjection?.userFacingErrors.usage
+                ?? self.store.userFacingError(for: target),
+            usageBarsShowUsed: self.settings.usageBarsShowUsed,
+            resetTimeDisplayStyle: self.settings.resetTimeDisplayStyle,
+            tokenCostUsageEnabled: self.settings.isCostUsageEffectivelyEnabled(for: target),
+            showOptionalCreditsAndExtraUsage: self.settings.showOptionalCreditsAndExtraUsage,
+            copilotBudgetExtrasEnabled: self.settings.copilotBudgetExtrasEnabled,
+            sourceLabel: sourceLabel,
+            kiloAutoMode: kiloAutoMode,
+            hidePersonalInfo: self.settings.hidePersonalInfo,
+            weeklyPace: weeklyPace,
+            quotaWarningThresholds: [
+                .session: self.quotaWarningMarkerThresholds(provider: target, window: .session),
+                .weekly: self.quotaWarningMarkerThresholds(provider: target, window: .weekly),
+            ],
+            workDaysPerWeek: self.settings.weeklyProgressWorkDays,
+            usesLiveSubtitle: surface == .liveCard,
+            now: now)
+        return UsageMenuCardView.Model.make(input)
+    }
+
+    func accountInfo(for account: CodexVisibleAccount) -> AccountInfo {
+        AccountInfo(email: account.email, plan: account.workspaceLabel)
+    }
+
+    private func quotaWarningMarkerThresholds(provider: UsageProvider, window: QuotaWarningWindow) -> [Int] {
+        guard self.settings.quotaWarningMarkersVisible else { return [] }
+        guard self.settings.quotaWarningEnabled(provider: provider, window: window) else { return [] }
+        return self.settings.resolvedQuotaWarningThresholds(provider: provider, window: window)
+    }
+}
diff --git a/Sources/CodexBar/StatusItemController+MenuCardRecycling.swift b/Sources/CodexBar/StatusItemController+MenuCardRecycling.swift
new file mode 100644
index 0000000000..6430984a1f
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+MenuCardRecycling.swift
@@ -0,0 +1,69 @@
+import AppKit
+
+extension StatusItemController {
+    /// Collects the card hosting views of items the current populate pass is about to discard
+    /// so `makeMenuCardItem` can reuse them for cards with the same identifier (or, failing
+    /// that, the same content type) instead of building fresh hosting views.
+    ///
+    /// Safety: live menu items can alias one merged-switcher cache entry — the one for the
+    /// selection currently displayed, re-cached at the end of every populate. Consuming that
+    /// entry up front (`displacedSelection`) guarantees no cache entry can still reference a
+    /// harvested view; entries for other selections only hold items already detached from the
+    /// menu. Harvested views are detached from their outgoing items; whatever the pass does
+    /// not consume is released by `clearMenuCardViewRecyclePool`.
+    func harvestRecyclableMenuCardViews(
+        in menu: NSMenu,
+        fromIndex: Int,
+        displacedSelection: ProviderSwitcherSelection?,
+        preserveHighlightedItem: Bool = false)
+    {
+        self.menuCardViewRecyclePool.removeAll(keepingCapacity: true)
+        let menuKey = ObjectIdentifier(menu)
+        if let displacedSelection {
+            self.mergedSwitcherContentCaches[menuKey]?.removeValue(forKey: displacedSelection)
+        }
+        guard self.menuCardRenderingEnabledForController else { return }
+        guard fromIndex >= 0, fromIndex < menu.items.count else { return }
+        for item in menu.items[fromIndex...] {
+            guard let id = item.representedObject as? String else { continue }
+            guard let view = item.view, view is any MenuCardMeasuring else { continue }
+            guard self.menuCardViewRecyclePool[id] == nil else { continue }
+            // Unhighlight before detaching: the highlight tracker unwinds through the
+            // outgoing item's `view`, which is about to become nil, so a recycled view
+            // would otherwise re-attach visibly highlighted with no path to clear it.
+            if self.highlightedMenuItems[menuKey] === item {
+                if !preserveHighlightedItem {
+                    self.highlightedMenuItems.removeValue(forKey: menuKey)
+                }
+            }
+            (view as? MenuCardHighlighting)?.setHighlighted(false)
+            item.view = nil
+            self.menuCardViewRecyclePool[id] = view
+        }
+    }
+
+    /// Pops a pool entry adoptable as `ViewType`: the same card identifier when its view
+    /// matches, otherwise the first type-compatible leftover. The fallback is what makes
+    /// provider switches cheap — a different provider's card with a different identifier but
+    /// the same SwiftUI content type (for example two providers' usage cards) is repainted
+    /// in place instead of being rebuilt.
+    func takeRecyclableMenuCardView<ViewType: NSView>(for id: String, as type: ViewType.Type) -> ViewType? {
+        if let candidate = self.menuCardViewRecyclePool.removeValue(forKey: id) {
+            if let adopted = candidate as? ViewType {
+                return adopted
+            }
+            // A same-id view of an incompatible shape can never be adopted later in this
+            // pass; dropping it restores the build-fresh behavior.
+            return nil
+        }
+        guard let match = self.menuCardViewRecyclePool.first(where: { $0.value is ViewType }) else {
+            return nil
+        }
+        self.menuCardViewRecyclePool.removeValue(forKey: match.key)
+        return match.value as? ViewType
+    }
+
+    func clearMenuCardViewRecyclePool() {
+        self.menuCardViewRecyclePool.removeAll(keepingCapacity: true)
+    }
+}
diff --git a/Sources/CodexBar/StatusItemController+MenuContexts.swift b/Sources/CodexBar/StatusItemController+MenuContexts.swift
new file mode 100644
index 0000000000..1091374281
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+MenuContexts.swift
@@ -0,0 +1,34 @@
+import AppKit
+import CodexBarCore
+
+extension StatusItemController {
+    struct OpenAIWebContext {
+        let hasUsageBreakdown: Bool
+        let hasCreditsHistory: Bool
+        let hasCostHistory: Bool
+        let canShowBuyCredits: Bool
+        let hasOpenAIWebMenuItems: Bool
+    }
+
+    struct MenuCardContext {
+        let currentProvider: UsageProvider
+        let selectedProvider: UsageProvider?
+        let menuWidth: CGFloat
+        let codexAccountDisplay: CodexAccountMenuDisplay?
+        let tokenAccountDisplay: TokenAccountMenuDisplay?
+        let openAIContext: OpenAIWebContext
+    }
+
+    struct MenuRebuildContext {
+        let enabledProviders: [UsageProvider]
+        let includesOverview: Bool
+        let switcherSelection: ProviderSwitcherSelection?
+        let currentProvider: UsageProvider
+        let selectedProvider: UsageProvider?
+        let menuWidth: CGFloat
+        let codexAccountDisplay: CodexAccountMenuDisplay?
+        let tokenAccountDisplay: TokenAccountMenuDisplay?
+        let openAIContext: OpenAIWebContext
+        let descriptor: MenuDescriptor
+    }
+}
diff --git a/Sources/CodexBar/StatusItemController+MenuInteractionRefresh.swift b/Sources/CodexBar/StatusItemController+MenuInteractionRefresh.swift
new file mode 100644
index 0000000000..b7272a91c9
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+MenuInteractionRefresh.swift
@@ -0,0 +1,172 @@
+import AppKit
+import CodexBarCore
+import QuartzCore
+
+extension StatusItemController {
+    private static let defaultDeferredMenuInteractionRefreshDelay: Duration = .milliseconds(250)
+    private static let slowMenuOperationThreshold: TimeInterval = 0.15
+    private static let slowChartRenderThreshold: TimeInterval = 0.050
+
+    #if DEBUG
+    private static var deferredMenuInteractionRefreshDelayForTesting: Duration = .milliseconds(250)
+
+    static func setDeferredMenuInteractionRefreshDelayForTesting(_ delay: Duration) {
+        self.deferredMenuInteractionRefreshDelayForTesting = delay
+    }
+
+    static func resetDeferredMenuInteractionRefreshDelayForTesting() {
+        self.deferredMenuInteractionRefreshDelayForTesting = self.defaultDeferredMenuInteractionRefreshDelay
+    }
+    #endif
+
+    private static var deferredMenuInteractionRefreshDelay: Duration {
+        #if DEBUG
+        deferredMenuInteractionRefreshDelayForTesting
+        #else
+        defaultDeferredMenuInteractionRefreshDelay
+        #endif
+    }
+
+    struct MenuOperationTrace {
+        let operation: String
+        let startedAt: CFTimeInterval
+    }
+
+    /// Pairs the slow-operation timing log with a watchdog breadcrumb so a hang during
+    /// the operation is attributed to it even when the operation never finishes logging.
+    func beginMenuOperationTrace(
+        _ operation: String,
+        breadcrumb: @autoclosure () -> String) -> MenuOperationTrace
+    {
+        MainThreadActivityBreadcrumb.push(breadcrumb())
+        return MenuOperationTrace(operation: operation, startedAt: CACurrentMediaTime())
+    }
+
+    func endMenuOperationTrace(_ trace: MenuOperationTrace, menu: NSMenu, provider: UsageProvider?) {
+        MainThreadActivityBreadcrumb.pop()
+        self.logMenuOperationDurationIfSlow(
+            trace.operation,
+            startedAt: trace.startedAt,
+            menu: menu,
+            provider: provider)
+    }
+
+    func logMenuOperationDurationIfSlow(
+        _ operation: String,
+        startedAt: CFTimeInterval,
+        menu: NSMenu,
+        provider: UsageProvider?)
+    {
+        let elapsed = CACurrentMediaTime() - startedAt
+        guard elapsed >= Self.slowMenuOperationThreshold else { return }
+        self.menuLogger.warning(
+            "slow menu operation",
+            metadata: [
+                "operation": operation,
+                "durationMs": String(format: "%.1f", elapsed * 1000),
+                "items": "\(menu.items.count)",
+                "provider": provider?.rawValue ?? "nil",
+                "openMenus": "\(self.openMenus.count)",
+                "storeRefreshing": self.store.isRefreshing ? "1" : "0",
+            ])
+    }
+
+    func logChartRenderDurationIfSlow(_ label: String, startedAt: CFTimeInterval) {
+        let elapsed = CACurrentMediaTime() - startedAt
+        guard elapsed >= Self.slowChartRenderThreshold else { return }
+        self.menuLogger.warning(
+            "slow chart render",
+            metadata: [
+                "section": label,
+                "durationMs": String(format: "%.1f", elapsed * 1000),
+            ])
+    }
+
+    func deferMenuInteractionRefreshIfNeeded(providers: [UsageProvider]) {
+        guard !self.store.isRefreshing else { return }
+        self.deferredMenuInteractionRefreshProviders.formUnion(providers)
+    }
+
+    func clearSatisfiedDeferredMenuInteractionRefreshes(for providers: [UsageProvider]) {
+        for provider in providers
+            where !self.store.isStale(provider: provider) && self.store.snapshot(for: provider) != nil
+        {
+            self.deferredMenuInteractionRefreshProviders.remove(provider)
+        }
+    }
+
+    func deferOpenAIDashboardRefreshUntilMenuCloses(reason: String) {
+        if let existingReason = self.deferredOpenAIDashboardRefreshReason {
+            self.deferredOpenAIDashboardRefreshReason = "\(existingReason), \(reason)"
+        } else {
+            self.deferredOpenAIDashboardRefreshReason = reason
+        }
+    }
+
+    func cancelDeferredMenuInteractionRefreshTask() {
+        self.deferredMenuInteractionRefreshTask?.cancel()
+        self.deferredMenuInteractionRefreshTask = nil
+    }
+
+    func scheduleDeferredMenuInteractionRefreshIfNeeded(delay: Duration? = nil) {
+        guard self.openMenus.isEmpty else { return }
+        guard self.deferredMenuInteractionRefreshPending || self.deferredOpenAIDashboardRefreshReason != nil else {
+            return
+        }
+        guard !self.hasPreparedForAppShutdown else { return }
+
+        self.cancelDeferredMenuInteractionRefreshTask()
+        let delay = delay ?? Self.deferredMenuInteractionRefreshDelay
+        self.deferredMenuInteractionRefreshTask = Task { @MainActor [weak self] in
+            try? await Task.sleep(for: delay)
+            guard let self, !Task.isCancelled else { return }
+            guard self.openMenus.isEmpty else {
+                self.deferredMenuInteractionRefreshTask = nil
+                return
+            }
+            let pendingProviders = self.deferredMenuInteractionRefreshProviders
+            let hasProviderRefreshInFlight = pendingProviders.contains {
+                self.store.refreshingProviders.contains($0)
+            }
+            guard !self.store.isRefreshing, !hasProviderRefreshInFlight else {
+                self.deferredMenuInteractionRefreshTask = nil
+                self.scheduleDeferredMenuInteractionRefreshIfNeeded(
+                    delay: Self.defaultDeferredMenuInteractionRefreshDelay)
+                return
+            }
+            self.clearSatisfiedDeferredMenuInteractionRefreshes(for: Array(pendingProviders))
+            let shouldRefreshStore = self.deferredMenuInteractionRefreshPending
+            let openAIDashboardRefreshReason = self.deferredOpenAIDashboardRefreshReason
+            guard shouldRefreshStore || openAIDashboardRefreshReason != nil else {
+                self.deferredMenuInteractionRefreshTask = nil
+                return
+            }
+            guard !self.hasPreparedForAppShutdown else {
+                self.deferredMenuInteractionRefreshTask = nil
+                return
+            }
+            self.deferredMenuInteractionRefreshTask = nil
+            self.deferredMenuInteractionRefreshProviders.removeAll()
+            self.deferredOpenAIDashboardRefreshReason = nil
+            #if DEBUG
+            self.onDeferredMenuInteractionRefreshForTesting?()
+            #endif
+            if shouldRefreshStore {
+                await self.performStoreRefresh(
+                    forceTokenUsage: false,
+                    refreshOpenMenusWhenComplete: false,
+                    interaction: .background)
+                guard !Task.isCancelled else { return }
+            }
+            if let openAIDashboardRefreshReason {
+                guard self.openMenus.isEmpty else {
+                    self.deferOpenAIDashboardRefreshUntilMenuCloses(reason: openAIDashboardRefreshReason)
+                    return
+                }
+                // Keep menu-originated automatic dashboard refreshes non-interactive:
+                // opening a menu is not consent to show macOS Keychain prompts.
+                self.store.requestOpenAIDashboardRefreshIfStale(reason: openAIDashboardRefreshReason)
+            }
+        }
+    }
+}
diff --git a/Sources/CodexBar/StatusItemController+MenuLocalization.swift b/Sources/CodexBar/StatusItemController+MenuLocalization.swift
new file mode 100644
index 0000000000..abad4320d1
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+MenuLocalization.swift
@@ -0,0 +1,38 @@
+import CodexBarCore
+
+extension StatusItemController {
+    func menuLocalizationSignature() -> String {
+        [
+            codexBarLocalizationSignature(),
+            self.settings.hidePersonalInfo ? "hide-personal-info" : "show-personal-info",
+            L("Overview"),
+            L("Cost"),
+        ].joined(separator: "|")
+    }
+
+    func rememberMergedSwitcherState(_ providers: [UsageProvider], _ selection: ProviderSwitcherSelection?) {
+        self.rememberMergedSwitcherState(
+            providers,
+            selection,
+            self.includesOverviewTab(for: providers))
+    }
+
+    func rememberMergedSwitcherState(
+        _ providers: [UsageProvider],
+        _ selection: ProviderSwitcherSelection?,
+        _ includesOverview: Bool)
+    {
+        self.lastSwitcherProviders = providers
+        self.lastSwitcherUsageBarsShowUsed = self.settings.usageBarsShowUsed
+        self.lastMergedSwitcherSelection = selection
+        self.lastMergedMenuContentSelection = selection
+        self.lastSwitcherIncludesOverview = includesOverview
+        self.lastMenuLocalizationSignature = self.menuLocalizationSignature()
+    }
+
+    private func includesOverviewTab(for providers: [UsageProvider]) -> Bool {
+        !self.settings.resolvedMergedOverviewProviders(
+            activeProviders: providers,
+            maxVisibleProviders: SettingsStore.mergedOverviewProviderLimit).isEmpty
+    }
+}
diff --git a/Sources/CodexBar/StatusItemController+MenuPresentation.swift b/Sources/CodexBar/StatusItemController+MenuPresentation.swift
new file mode 100644
index 0000000000..9cc24972d4
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+MenuPresentation.swift
@@ -0,0 +1,247 @@
+import AppKit
+import CodexBarCore
+import Observation
+import SwiftUI
+
+extension StatusItemController {
+    func switcherWeeklyRemaining(for provider: UsageProvider) -> Double? {
+        Self.switcherWeeklyMetricPercent(
+            for: provider,
+            snapshot: self.store.snapshot(for: provider),
+            showUsed: self.settings.usageBarsShowUsed)
+    }
+
+    func applySubtitle(_ subtitle: String, to item: NSMenuItem, title: String) {
+        if #available(macOS 14.4, *) {
+            // NSMenuItem.subtitle is only available on macOS 14.4+.
+            item.subtitle = subtitle
+        } else {
+            item.view = self.makeMenuSubtitleView(title: title, subtitle: subtitle, isEnabled: item.isEnabled)
+            item.toolTip = "\(title) — \(subtitle)"
+        }
+    }
+
+    func makeMenuSubtitleView(title: String, subtitle: String, isEnabled: Bool) -> NSView {
+        let container = NSView()
+        container.translatesAutoresizingMaskIntoConstraints = false
+        container.alphaValue = isEnabled ? 1.0 : 0.7
+
+        let titleField = NSTextField(labelWithString: title)
+        titleField.font = NSFont.menuFont(ofSize: NSFont.systemFontSize)
+        titleField.textColor = NSColor.labelColor
+        titleField.lineBreakMode = .byTruncatingTail
+        titleField.maximumNumberOfLines = 1
+        titleField.setContentCompressionResistancePriority(.defaultLow, for: .horizontal)
+
+        let subtitleField = NSTextField(labelWithString: subtitle)
+        subtitleField.font = NSFont.menuFont(ofSize: NSFont.smallSystemFontSize)
+        subtitleField.textColor = NSColor.secondaryLabelColor
+        subtitleField.lineBreakMode = .byTruncatingTail
+        subtitleField.maximumNumberOfLines = 1
+        subtitleField.setContentCompressionResistancePriority(.defaultLow, for: .horizontal)
+
+        let stack = NSStackView(views: [titleField, subtitleField])
+        stack.orientation = .vertical
+        stack.alignment = .leading
+        stack.spacing = 1
+        stack.translatesAutoresizingMaskIntoConstraints = false
+        container.addSubview(stack)
+
+        NSLayoutConstraint.activate([
+            stack.leadingAnchor.constraint(equalTo: container.leadingAnchor, constant: 18),
+            stack.trailingAnchor.constraint(equalTo: container.trailingAnchor, constant: -10),
+            stack.topAnchor.constraint(equalTo: container.topAnchor, constant: 2),
+            stack.bottomAnchor.constraint(equalTo: container.bottomAnchor, constant: -2),
+        ])
+
+        return container
+    }
+}
+
+@MainActor
+protocol MenuCardHighlighting: AnyObject {
+    var allowsMenuHighlight: Bool { get }
+    func setHighlighted(_ highlighted: Bool)
+}
+
+extension MenuCardHighlighting {
+    var allowsMenuHighlight: Bool {
+        true
+    }
+}
+
+@MainActor
+protocol MenuCardMeasuring: AnyObject {
+    func measuredHeight(width: CGFloat) -> CGFloat
+}
+
+@MainActor
+@Observable
+final class MenuCardHighlightState {
+    var isHighlighted = false
+}
+
+final class MenuHostingView<Content: View>: NSHostingView<Content> {
+    /// The height AppKit should give this item's menu row. NSMenu reads `intrinsicContentSize`
+    /// (not the explicit `frame`) when it lays out custom-view rows, so a measured height that
+    /// only lives in `frame` is silently reverted to the open-time row height — leaving the
+    /// SwiftUI content centered in a stale, oversized row. Routing the height through the
+    /// intrinsic size is the channel the menu actually honors.
+    private var measuredHeight: CGFloat?
+
+    override var allowsVibrancy: Bool {
+        true
+    }
+
+    override var intrinsicContentSize: NSSize {
+        guard let measuredHeight else { return super.intrinsicContentSize }
+        return NSSize(width: NSView.noIntrinsicMetric, height: measuredHeight)
+    }
+
+    func applyMeasuredHeight(width: CGFloat, height: CGFloat) {
+        let resolvedHeight = max(1, ceil(height))
+        guard self.measuredHeight != resolvedHeight || self.frame.height != resolvedHeight else { return }
+
+        self.measuredHeight = resolvedHeight
+        self.frame = NSRect(
+            origin: self.frame.origin,
+            size: NSSize(width: width, height: resolvedHeight))
+        self.invalidateIntrinsicContentSize()
+        self.layoutSubtreeIfNeeded()
+        self.superview?.layoutSubtreeIfNeeded()
+    }
+}
+
+@MainActor
+final class MenuCardItemHostingView<Content: View>: NSHostingView<Content>, MenuCardHighlighting, MenuCardMeasuring {
+    let highlightState: MenuCardHighlightState
+    private(set) var allowsMenuHighlight: Bool
+    private var onClick: (() -> Void)?
+    private var hasClickRecognizer = false
+
+    override var allowsVibrancy: Bool {
+        true
+    }
+
+    override var intrinsicContentSize: NSSize {
+        let size = super.intrinsicContentSize
+        guard self.frame.width > 0 else { return size }
+        return NSSize(width: self.frame.width, height: size.height)
+    }
+
+    init(
+        rootView: Content,
+        highlightState: MenuCardHighlightState,
+        allowsMenuHighlight: Bool,
+        onClick: (() -> Void)? = nil)
+    {
+        self.highlightState = highlightState
+        self.allowsMenuHighlight = allowsMenuHighlight
+        self.onClick = onClick
+        super.init(rootView: rootView)
+        if onClick != nil {
+            self.installClickRecognizer()
+        }
+    }
+
+    /// Reuses this hosting view for a rebuilt card with the same identity: the replaced
+    /// `rootView` is diffed in place by SwiftUI instead of tearing down and recreating the
+    /// hosting view and its graph. Callers must construct `rootView` around this view's own
+    /// `highlightState` so menu hover highlighting keeps driving the rendered content.
+    func prepareForReuse(rootView: Content, allowsMenuHighlight: Bool, onClick: (() -> Void)?) {
+        self.rootView = rootView
+        self.allowsMenuHighlight = allowsMenuHighlight
+        self.onClick = onClick
+        if onClick != nil, !self.hasClickRecognizer {
+            self.installClickRecognizer()
+        }
+    }
+
+    /// `NSMenu` tracking consumes keyboard events before they reach a menu item's custom view, so
+    /// the pointer `onClick` path has no native counterpart for assistive tech. Expose the row as an
+    /// accessibility button whose press mirrors a click, giving VoiceOver an activation path that runs
+    /// `onClick` (and therefore keeps the menu open) instead of regressing to mouse-only.
+    override func accessibilityRole() -> NSAccessibility.Role? {
+        self.onClick == nil ? super.accessibilityRole() : .button
+    }
+
+    override func accessibilityPerformPress() -> Bool {
+        guard let onClick = self.onClick else {
+            return super.accessibilityPerformPress()
+        }
+        onClick()
+        return true
+    }
+
+    private func installClickRecognizer() {
+        let recognizer = NSClickGestureRecognizer(target: self, action: #selector(self.handlePrimaryClick(_:)))
+        recognizer.buttonMask = 0x1
+        self.addGestureRecognizer(recognizer)
+        self.hasClickRecognizer = true
+    }
+
+    required init(rootView: Content) {
+        self.highlightState = MenuCardHighlightState()
+        self.allowsMenuHighlight = false
+        self.onClick = nil
+        super.init(rootView: rootView)
+    }
+
+    @available(*, unavailable)
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    override func acceptsFirstMouse(for event: NSEvent?) -> Bool {
+        true
+    }
+
+    @objc private func handlePrimaryClick(_ recognizer: NSClickGestureRecognizer) {
+        guard recognizer.state == .ended else { return }
+        self.onClick?()
+    }
+
+    func measuredHeight(width: CGFloat) -> CGFloat {
+        self.frame = NSRect(origin: self.frame.origin, size: NSSize(width: width, height: 1))
+        self.layoutSubtreeIfNeeded()
+        return self.fittingSize.height
+    }
+
+    func setHighlighted(_ highlighted: Bool) {
+        guard self.highlightState.isHighlighted != highlighted else { return }
+        self.highlightState.isHighlighted = highlighted
+    }
+}
+
+struct MenuCardSectionContainerView<Content: View>: View {
+    @Bindable var highlightState: MenuCardHighlightState
+    let showsSubmenuIndicator: Bool
+    let submenuIndicatorAlignment: Alignment
+    let submenuIndicatorTopPadding: CGFloat
+    var refreshMonitor: MenuCardRefreshMonitor?
+    @ViewBuilder let content: () -> Content
+
+    var body: some View {
+        self.content()
+            .environment(\.menuItemHighlighted, self.highlightState.isHighlighted)
+            .environment(\.menuCardRefreshMonitor, self.refreshMonitor)
+            .foregroundStyle(MenuHighlightStyle.primary(self.highlightState.isHighlighted))
+            .background(alignment: .topLeading) {
+                if self.highlightState.isHighlighted {
+                    RoundedRectangle(cornerRadius: 6, style: .continuous)
+                        .fill(MenuHighlightStyle.selectionBackground(true))
+                        .padding(.horizontal, 6)
+                        .padding(.vertical, 2)
+                }
+            }
+            .overlay(alignment: self.submenuIndicatorAlignment) {
+                if self.showsSubmenuIndicator {
+                    Image(systemName: "chevron.right")
+                        .font(.caption2.weight(.semibold))
+                        .foregroundStyle(MenuHighlightStyle.secondary(self.highlightState.isHighlighted))
+                        .padding(.top, self.submenuIndicatorTopPadding)
+                        .padding(.trailing, 10)
+                }
+            }
+    }
+}
diff --git a/Sources/CodexBar/StatusItemController+MenuReconcile.swift b/Sources/CodexBar/StatusItemController+MenuReconcile.swift
new file mode 100644
index 0000000000..6fc7cb02b4
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+MenuReconcile.swift
@@ -0,0 +1,221 @@
+import AppKit
+
+/// Pre-harvest snapshot of one live content row, captured before card views are detached
+/// into the recycle pool so reconciliation can still compare row shapes afterwards.
+struct MenuRowShape {
+    let isSeparator: Bool
+    let requiresNativeImageReplacement: Bool
+    let id: String?
+    let viewClassName: String?
+}
+
+extension StatusItemController {
+    func menuContentShapes(in menu: NSMenu, fromIndex: Int) -> [MenuRowShape] {
+        guard fromIndex >= 0, fromIndex <= menu.items.count else { return [] }
+        return menu.items[fromIndex...].map { item in
+            MenuRowShape(
+                isSeparator: item.isSeparatorItem,
+                requiresNativeImageReplacement: self.shouldReplaceNativeImageItemDuringReconcile(item),
+                id: item.representedObject as? String,
+                viewClassName: item.view.map { String(describing: type(of: $0)) })
+        }
+    }
+
+    /// Identifies leaf AppKit image items that should be replaced instead of updated in place.
+    ///
+    /// AppKit can retain stale layout state for standard image-backed menu items after repeated
+    /// in-place updates, which makes rows such as "Status Page" drift horizontally. Submenu rows
+    /// stay on the normal reconciliation path because replacing their parent item can disturb an
+    /// active submenu.
+    private func shouldReplaceNativeImageItemDuringReconcile(_ item: NSMenuItem) -> Bool {
+        !item.isSeparatorItem && item.view == nil && item.image != nil && item.submenu == nil
+    }
+
+    /// Position-wise in-place reconciliation: live rows whose shape matches the freshly
+    /// built content (separator placement, card identifier, view class) are updated in
+    /// place — views transplanted, plain rows recopied — and only the mismatched middle
+    /// span is removed and reinserted. Matching runs from both ends, so the expensive card
+    /// rows at the top and the shared action rows at the bottom survive even a provider
+    /// switch whose middle sections differ; AppKit then relayouts the open tracked menu for
+    /// the few changed rows instead of once per row.
+    func reconcileMenuContent(
+        _ menu: NSMenu,
+        fromIndex: Int,
+        shapes: [MenuRowShape],
+        with scratch: NSMenu)
+    {
+        defer { self.finishReconciledHighlightTracking(in: menu) }
+        let newItems = scratch.items
+        scratch.removeAllItems()
+        guard menu.items.count - fromIndex == shapes.count else {
+            // The live region changed underneath the snapshot; replace it wholesale.
+            self.replaceMenuContent(menu, fromIndex: fromIndex, with: newItems)
+            return
+        }
+
+        func updatable(_ shape: MenuRowShape, _ newItem: NSMenuItem) -> Bool {
+            guard shape.isSeparator == newItem.isSeparatorItem else { return false }
+            if shape.isSeparator { return true }
+            guard !shape.requiresNativeImageReplacement,
+                  !self.shouldReplaceNativeImageItemDuringReconcile(newItem)
+            else { return false }
+            guard shape.id == newItem.representedObject as? String else { return false }
+            return shape.viewClassName == newItem.view.map { String(describing: type(of: $0)) }
+        }
+
+        var prefix = 0
+        while prefix < min(shapes.count, newItems.count), updatable(shapes[prefix], newItems[prefix]) {
+            prefix += 1
+        }
+        var suffix = 0
+        while suffix < min(shapes.count, newItems.count) - prefix,
+              updatable(shapes[shapes.count - 1 - suffix], newItems[newItems.count - 1 - suffix])
+        {
+            suffix += 1
+        }
+
+        for offset in 0..<prefix {
+            self.updateMenuItemInPlace(menu.items[fromIndex + offset], from: newItems[offset])
+        }
+        for offset in 0..<suffix {
+            self.updateMenuItemInPlace(
+                menu.items[menu.items.count - 1 - offset],
+                from: newItems[newItems.count - 1 - offset])
+        }
+
+        let liveMiddleCount = shapes.count - prefix - suffix
+        let insertionIndex = fromIndex + prefix
+        for _ in 0..<liveMiddleCount {
+            menu.removeItem(at: insertionIndex)
+        }
+        let newMiddle = newItems[prefix..<(newItems.count - suffix)]
+        for (offset, item) in newMiddle.enumerated() {
+            menu.insertItem(item, at: insertionIndex + offset)
+        }
+    }
+
+    /// Replaces cached content without first emptying the tracked menu. Compatible item shells
+    /// stay attached while their payloads swap; only separator or row-count differences cause
+    /// structural mutations.
+    func replaceMenuContentKeepingRowsVisible(
+        _ menu: NSMenu,
+        fromIndex: Int,
+        with newItems: [NSMenuItem])
+        -> [NSMenuItem]
+    {
+        guard fromIndex >= 0, fromIndex <= menu.items.count else { return [] }
+        defer { self.finishReconciledHighlightTracking(in: menu) }
+
+        let liveItems = Array(menu.items[fromIndex...])
+        let liveCount = liveItems.count
+        let sharedCount = min(liveCount, newItems.count)
+        var displacedItems: [NSMenuItem] = []
+        displacedItems.reserveCapacity(liveCount)
+        for offset in 0..<sharedCount {
+            let index = fromIndex + offset
+            let liveItem = liveItems[offset]
+            let newItem = newItems[offset]
+            let requiresNativeImageReplacement =
+                self.shouldReplaceNativeImageItemDuringReconcile(liveItem) ||
+                self.shouldReplaceNativeImageItemDuringReconcile(newItem)
+            if liveItem.isSeparatorItem == newItem.isSeparatorItem, !requiresNativeImageReplacement {
+                if !liveItem.isSeparatorItem {
+                    self.swapMenuItemContents(liveItem, newItem)
+                }
+                displacedItems.append(newItem)
+            } else {
+                menu.insertItem(newItem, at: index)
+                menu.removeItem(liveItem)
+                displacedItems.append(liveItem)
+            }
+        }
+        if newItems.count > liveCount {
+            for offset in liveCount..<newItems.count {
+                menu.insertItem(newItems[offset], at: fromIndex + offset)
+            }
+        } else if liveCount > newItems.count {
+            for offset in newItems.count..<liveCount {
+                menu.removeItem(liveItems[offset])
+                displacedItems.append(liveItems[offset])
+            }
+        }
+        return displacedItems
+    }
+
+    private func finishReconciledHighlightTracking(in menu: NSMenu) {
+        let menuKey = ObjectIdentifier(menu)
+        guard let highlightedItem = self.highlightedMenuItems[menuKey] else { return }
+        guard highlightedItem.menu === menu else {
+            self.highlightedMenuItems.removeValue(forKey: menuKey)
+            (highlightedItem.view as? MenuCardHighlighting)?.setHighlighted(false)
+            return
+        }
+        guard highlightedItem.isEnabled,
+              (highlightedItem.view as? MenuCardHighlighting)?.allowsMenuHighlight != false
+        else {
+            self.highlightedMenuItems.removeValue(forKey: menuKey)
+            (highlightedItem.view as? MenuCardHighlighting)?.setHighlighted(false)
+            return
+        }
+        (highlightedItem.view as? MenuCardHighlighting)?.setHighlighted(true)
+    }
+
+    private func replaceMenuContent(_ menu: NSMenu, fromIndex: Int, with newItems: [NSMenuItem]) {
+        while menu.items.count > fromIndex {
+            menu.removeItem(at: fromIndex)
+        }
+        for item in newItems {
+            menu.addItem(item)
+        }
+    }
+
+    private func updateMenuItemInPlace(_ liveItem: NSMenuItem, from newItem: NSMenuItem) {
+        if liveItem.isSeparatorItem { return }
+        let remainsHighlighted = liveItem.menu.map {
+            self.highlightedMenuItems[ObjectIdentifier($0)] === liveItem
+        } ?? false
+        // Detach from the scratch item first so a view or submenu is never referenced by
+        // two menu items at once.
+        let view = newItem.view
+        newItem.view = nil
+        let submenu = newItem.submenu
+        newItem.submenu = nil
+        liveItem.view = view
+        liveItem.submenu = submenu
+        liveItem.title = newItem.title
+        liveItem.attributedTitle = newItem.attributedTitle
+        liveItem.action = newItem.action
+        liveItem.target = newItem.target
+        liveItem.representedObject = newItem.representedObject
+        liveItem.state = newItem.state
+        liveItem.isEnabled = newItem.isEnabled
+        let allowsHighlight = (view as? MenuCardHighlighting)?.allowsMenuHighlight != false
+        (view as? MenuCardHighlighting)?.setHighlighted(newItem.isEnabled && allowsHighlight && remainsHighlighted)
+        liveItem.image = newItem.image
+        liveItem.toolTip = newItem.toolTip
+        liveItem.keyEquivalent = newItem.keyEquivalent
+        liveItem.keyEquivalentModifierMask = newItem.keyEquivalentModifierMask
+        liveItem.indentationLevel = newItem.indentationLevel
+        liveItem.tag = newItem.tag
+        liveItem.identifier = newItem.identifier
+        liveItem.isHidden = newItem.isHidden
+        liveItem.isAlternate = newItem.isAlternate
+        liveItem.allowsKeyEquivalentWhenHidden = newItem.allowsKeyEquivalentWhenHidden
+        liveItem.onStateImage = newItem.onStateImage
+        liveItem.offStateImage = newItem.offStateImage
+        liveItem.mixedStateImage = newItem.mixedStateImage
+        if #available(macOS 14.4, *) {
+            liveItem.subtitle = newItem.subtitle
+        }
+        if self.isPersistentRefreshItem(liveItem) {
+            self.persistentRefreshItems.add(liveItem)
+        }
+    }
+
+    private func swapMenuItemContents(_ liveItem: NSMenuItem, _ cachedItem: NSMenuItem) {
+        let holder = NSMenuItem()
+        self.updateMenuItemInPlace(holder, from: liveItem)
+        self.updateMenuItemInPlace(liveItem, from: cachedItem)
+        self.updateMenuItemInPlace(cachedItem, from: holder)
+    }
+}
diff --git a/Sources/CodexBar/StatusItemController+MenuRefreshScheduling.swift b/Sources/CodexBar/StatusItemController+MenuRefreshScheduling.swift
new file mode 100644
index 0000000000..251ca63a10
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+MenuRefreshScheduling.swift
@@ -0,0 +1,335 @@
+import AppKit
+import CodexBarCore
+import QuartzCore
+
+extension StatusItemController {
+    private static let providerSwitcherMenuRebuildDebounceNanoseconds: UInt64 = 0
+
+    private struct ScheduledOpenMenuRebuild {
+        let provider: UsageProvider?
+        let shouldCloseHostedSubviewMenus: Bool
+        let resyncReadinessBaselineAfterRebuild: Bool
+        let beforeRebuild: (@MainActor () -> Bool)?
+    }
+
+    func didMenuAdjunctReadinessChange() -> Bool {
+        let signature = self.menuAdjunctReadinessSignature()
+        defer { self.recordMenuAdjunctReadinessBaseline(signature) }
+        return signature != self.lastMenuAdjunctReadinessSignature
+    }
+
+    /// Resyncs the readiness baseline to the data the menu was just built from.
+    ///
+    /// Because the baseline is no longer recomputed on every store change while all menus are closed,
+    /// it can drift from the live store state. When a root menu opens and is actually rebuilt (or is
+    /// already fresh for the current `menuContentVersion`), the baseline must be re-anchored here;
+    /// otherwise a later open-menu store change that happens to revert to the stale baseline value would
+    /// be treated as "unchanged" and skip a needed rebuild, leaving the visible menu showing the older
+    /// content. Callers must **not** invoke this when `refreshMenuForOpenIfNeeded` preserved stale
+    /// content during an in-flight refresh — that would record live store data while the visible menu
+    /// still shows older content and mask the refresh-completion update.
+    func resyncMenuAdjunctReadinessBaseline() {
+        self.recordMenuAdjunctReadinessBaseline(self.menuAdjunctReadinessSignature())
+    }
+
+    /// Resyncs a root-menu baseline after open and handles the narrow race where a store change
+    /// has updated live data but its deferred observation task has not invalidated menus yet.
+    ///
+    /// If a previously fresh menu sees new live data before the observer version tick, invalidate all
+    /// menus first and rebuild only the opened menu. The matching observer can then skip the expensive
+    /// readiness comparison while still invalidating menu-observed state that is not in the signature.
+    func resyncMenuAdjunctReadinessBaselineForRootOpen(
+        _ menu: NSMenu,
+        provider: UsageProvider?,
+        menuWasFreshBeforeOpen: Bool)
+    {
+        let signature = self.menuAdjunctReadinessSignature()
+        let menuKey = ObjectIdentifier(menu)
+        let menuRenderedCurrentSignature =
+            self.menuSession.renderedVersion(for: menuKey) == self.menuSession.contentVersion &&
+            self.menuReadinessSignatures[menuKey] == signature
+        guard signature != self.lastMenuAdjunctReadinessSignature else {
+            guard menuWasFreshBeforeOpen, !menuRenderedCurrentSignature else {
+                self.lastMenuAdjunctReadinessBaselineVersion = self.menuSession.contentVersion
+                return
+            }
+            guard !self.isMenuDataRefreshInFlight else { return }
+            self.invalidateMenus()
+            self.populateMenu(menu, provider: provider)
+            self.markMenuFresh(menu)
+            self.rememberRootOpenHandledMenuObservation(signature: signature)
+            self.recordMenuAdjunctReadinessBaseline(signature)
+            return
+        }
+
+        if menuWasFreshBeforeOpen {
+            if self.isMenuDataRefreshInFlight, !menuRenderedCurrentSignature {
+                return
+            }
+            if menuRenderedCurrentSignature {
+                self.recordMenuAdjunctReadinessBaseline(signature)
+                return
+            }
+            self.invalidateMenus()
+            self.populateMenu(menu, provider: provider)
+            self.markMenuFresh(menu)
+            self.rememberRootOpenHandledMenuObservation(signature: signature)
+        }
+        self.recordMenuAdjunctReadinessBaseline(signature)
+    }
+
+    private func recordMenuAdjunctReadinessBaseline(_ signature: String) {
+        self.lastMenuAdjunctReadinessSignature = signature
+        self.lastMenuAdjunctReadinessBaselineVersion = self.menuSession.contentVersion
+    }
+
+    private func rememberRootOpenHandledMenuObservation(signature: String) {
+        self.rootOpenHandledMenuObservationSignature = signature
+        Task { @MainActor [weak self] in
+            await Task.yield()
+            if self?.rootOpenHandledMenuObservationSignature == signature {
+                self?.rootOpenHandledMenuObservationSignature = nil
+            }
+        }
+    }
+
+    func consumeRootOpenHandledMenuObservationIfNeeded() -> Bool {
+        guard let handledSignature = self.rootOpenHandledMenuObservationSignature else { return false }
+        let signature = self.menuAdjunctReadinessSignature()
+        guard signature == handledSignature else {
+            self.rootOpenHandledMenuObservationSignature = nil
+            return false
+        }
+        self.rootOpenHandledMenuObservationSignature = nil
+        self.recordMenuAdjunctReadinessBaseline(signature)
+        return true
+    }
+
+    func menuAdjunctReadinessSignature() -> String {
+        let dashboard = self.store.openAIDashboard
+        let dashboardUsageBreakdown = OpenAIDashboardDailyBreakdown.removingSkillUsageServices(
+            from: dashboard?.usageBreakdown ?? [])
+        var parts = [
+            "costEnabled=\(self.settings.costUsageEnabled ? "1" : "0")",
+            "openAIAttached=\(self.store.openAIDashboardAttachmentAuthorized ? "1" : "0")",
+            "openAILogin=\(self.store.openAIDashboardRequiresLogin ? "1" : "0")",
+            "openAIUpdated=\(Self.millisecondsSinceEpoch(dashboard?.updatedAt))",
+            "openAIDaily=\(Self.dashboardBreakdownReadinessSignature(dashboard?.dailyBreakdown ?? []))",
+            "openAIUsage=\(Self.dashboardBreakdownReadinessSignature(dashboardUsageBreakdown))",
+            "credits=\(self.store.credits == nil ? "0" : "1")",
+            "planHistoryRevision=\(self.store.planUtilizationHistoryRevision)",
+        ]
+
+        for provider in self.store.enabledProvidersForDisplay() {
+            let tokenSignature = self.tokenSnapshotReadinessSignature(for: provider)
+            let usageHistoryVisible = self.store.supportsPlanUtilizationHistory(for: provider) &&
+                !self.store.shouldHidePlanUtilizationMenuItem(for: provider)
+            parts.append(
+                [
+                    provider.rawValue,
+                    "token=\(tokenSignature)",
+                    "refreshing=\(self.store.shouldShowRefreshingMenuCardIndicator(for: provider) ? "1" : "0")",
+                    "usageHistory=\(usageHistoryVisible ? "1" : "0")",
+                ].joined(separator: ":"))
+        }
+
+        return parts.joined(separator: "|")
+    }
+
+    static func dashboardBreakdownReadinessSignature(
+        _ breakdown: [OpenAIDashboardDailyBreakdown]) -> String
+    {
+        breakdown
+            .map { day in
+                let services = day.services
+                    .map { "\($0.service)=\(Self.formatDoubleForSignature($0.creditsUsed))" }
+                    .joined(separator: ",")
+                return [
+                    day.day,
+                    Self.formatDoubleForSignature(day.totalCreditsUsed),
+                    services,
+                ].joined(separator: ":")
+            }
+            .joined(separator: ";")
+    }
+
+    private func tokenSnapshotReadinessSignature(for provider: UsageProvider) -> String {
+        guard let snapshot = self.store.tokenSnapshot(for: provider) else { return "none" }
+        let daily = snapshot.daily
+            .map { entry in
+                [
+                    entry.date,
+                    "\(entry.totalTokens ?? -1)",
+                    Self.formatOptionalDoubleForSignature(entry.costUSD),
+                ].joined(separator: ",")
+            }
+            .joined(separator: ";")
+        return [
+            "sessionTokens=\(snapshot.sessionTokens ?? -1)",
+            "sessionCost=\(Self.formatOptionalDoubleForSignature(snapshot.sessionCostUSD))",
+            "lastTokens=\(snapshot.last30DaysTokens ?? -1)",
+            "lastCost=\(Self.formatOptionalDoubleForSignature(snapshot.last30DaysCostUSD))",
+            "updated=\(Int(snapshot.updatedAt.timeIntervalSince1970 * 1000))",
+            "daily=\(daily)",
+        ].joined(separator: ",")
+    }
+
+    private static func millisecondsSinceEpoch(_ date: Date?) -> Int {
+        guard let date else { return -1 }
+        return Int(date.timeIntervalSince1970 * 1000)
+    }
+
+    private static func formatOptionalDoubleForSignature(_ value: Double?) -> String {
+        guard let value else { return "nil" }
+        return self.formatDoubleForSignature(value)
+    }
+
+    /// The signature is only ever compared for equality against the previous signature, so it does
+    /// not need a human-readable decimal form. `String(format: "%.8f", …)` is a surprisingly hot
+    /// cost here because it runs for every daily/service value across every enabled provider on each
+    /// store mutation. The raw bit pattern is both exact (no rounding collisions) and far cheaper.
+    private static func formatDoubleForSignature(_ value: Double) -> String {
+        String(value.bitPattern, radix: 16)
+    }
+
+    func performMenuMutationWithoutAnimation(_ updates: () -> Void) {
+        CATransaction.begin()
+        CATransaction.setDisableActions(true)
+        defer { CATransaction.commit() }
+        updates()
+    }
+
+    func deferSwitcherMenuRebuildIfStillVisible(_ menu: NSMenu, provider: UsageProvider?) {
+        self.providerSwitcherUpdateToken &+= 1
+        let updateToken = self.providerSwitcherUpdateToken
+        #if DEBUG
+        let debounceNanoseconds = self._test_providerSwitcherMenuRebuildDebounceNanoseconds ?? (
+            self._test_openMenuRebuildObserver == nil ? Self.providerSwitcherMenuRebuildDebounceNanoseconds : 0)
+        #else
+        let debounceNanoseconds = Self.providerSwitcherMenuRebuildDebounceNanoseconds
+        #endif
+        #if DEBUG
+        let usesTaskSchedulerForTesting = self._test_openMenuRefreshYieldOverride != nil
+            || self._test_openMenuRebuildObserver != nil
+        #else
+        let usesTaskSchedulerForTesting = false
+        #endif
+        if debounceNanoseconds == 0, !usesTaskSchedulerForTesting {
+            self.scheduleProviderSwitcherTrackingMenuRebuildIfStillVisible(
+                menu,
+                provider: provider)
+            { [weak self] in
+                guard let self else { return false }
+                return self.providerSwitcherUpdateToken == updateToken
+            }
+            return
+        }
+        self.scheduleOpenMenuRebuildIfStillVisible(
+            menu,
+            provider: provider,
+            closeHostedSubviewMenusBeforeRebuild: true,
+            debounceNanoseconds: debounceNanoseconds)
+        { [weak self] in
+            guard let self else { return false }
+            return self.providerSwitcherUpdateToken == updateToken
+        }
+    }
+
+    private func scheduleProviderSwitcherTrackingMenuRebuildIfStillVisible(
+        _ menu: NSMenu,
+        provider: UsageProvider?,
+        beforeRebuild: @escaping @MainActor () -> Bool)
+    {
+        let key = ObjectIdentifier(menu)
+        self.openMenuRebuildsClosingHostedSubviewMenus.insert(key)
+        let rebuildToken = self.openMenuRebuildRequests.replaceRequest(for: key)
+        self.openMenuRebuildTasks.removeValue(forKey: key)?.cancel()
+
+        ProviderSwitcherTrackingRunLoopScheduler.schedule { [weak self, weak menu] in
+            guard let self, let menu else { return }
+            self.performScheduledOpenMenuRebuild(
+                menu,
+                key: key,
+                rebuildToken: rebuildToken,
+                request: ScheduledOpenMenuRebuild(
+                    provider: provider,
+                    shouldCloseHostedSubviewMenus: true,
+                    resyncReadinessBaselineAfterRebuild: false,
+                    beforeRebuild: beforeRebuild))
+        }
+    }
+
+    func scheduleOpenMenuRebuildIfStillVisible(
+        _ menu: NSMenu,
+        provider: UsageProvider?,
+        closeHostedSubviewMenusBeforeRebuild: Bool = false,
+        resyncReadinessBaselineAfterRebuild: Bool = false,
+        debounceNanoseconds: UInt64 = 0,
+        beforeRebuild: (@MainActor () -> Bool)? = nil)
+    {
+        let key = ObjectIdentifier(menu)
+        if closeHostedSubviewMenusBeforeRebuild {
+            self.openMenuRebuildsClosingHostedSubviewMenus.insert(key)
+        }
+        let shouldCloseHostedSubviewMenus = self.openMenuRebuildsClosingHostedSubviewMenus.contains(key)
+        let rebuildToken = self.openMenuRebuildRequests.replaceRequest(for: key)
+        self.openMenuRebuildTasks[key]?.cancel()
+        self.openMenuRebuildTasks[key] = Task { @MainActor [weak self, weak menu] in
+            guard let self, let menu else { return }
+            #if DEBUG
+            if let override = self._test_openMenuRefreshYieldOverride {
+                await override()
+            } else {
+                await Task.yield()
+            }
+            #else
+            await Task.yield()
+            #endif
+            if debounceNanoseconds > 0 {
+                try? await Task.sleep(nanoseconds: debounceNanoseconds)
+            }
+            guard !Task.isCancelled else { return }
+            self.performScheduledOpenMenuRebuild(
+                menu,
+                key: key,
+                rebuildToken: rebuildToken,
+                request: ScheduledOpenMenuRebuild(
+                    provider: provider,
+                    shouldCloseHostedSubviewMenus: shouldCloseHostedSubviewMenus,
+                    resyncReadinessBaselineAfterRebuild: resyncReadinessBaselineAfterRebuild,
+                    beforeRebuild: beforeRebuild))
+        }
+    }
+
+    private func performScheduledOpenMenuRebuild(
+        _ menu: NSMenu,
+        key: ObjectIdentifier,
+        rebuildToken: Int,
+        request: ScheduledOpenMenuRebuild)
+    {
+        guard self.openMenuRebuildRequests.isCurrent(rebuildToken, for: key) else { return }
+        defer {
+            if self.openMenuRebuildRequests.finish(rebuildToken, for: key) {
+                self.openMenuRebuildTasks.removeValue(forKey: key)
+                self.openMenuRebuildsClosingHostedSubviewMenus.remove(key)
+            }
+        }
+        guard self.openMenus[key] != nil else { return }
+        guard request.beforeRebuild?() ?? true else { return }
+        if request.shouldCloseHostedSubviewMenus {
+            self.closeHostedSubviewMenusForParentSwitch()
+        }
+        self.rebuildOpenMenuIfStillVisible(menu, provider: request.provider)
+        if request.resyncReadinessBaselineAfterRebuild, !self.menuNeedsRefresh(menu) {
+            self.resyncMenuAdjunctReadinessBaseline()
+        }
+    }
+
+    private func closeHostedSubviewMenusForParentSwitch() {
+        let hostedMenus = self.openMenus.values.filter { self.isHostedSubviewMenu($0) }
+        for hostedMenu in hostedMenus {
+            hostedMenu.cancelTrackingWithoutAnimation()
+            self.forgetClosedMenu(hostedMenu)
+        }
+    }
+}
diff --git a/Sources/CodexBar/StatusItemController+MenuSmartUpdate.swift b/Sources/CodexBar/StatusItemController+MenuSmartUpdate.swift
new file mode 100644
index 0000000000..16336dd4c2
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+MenuSmartUpdate.swift
@@ -0,0 +1,139 @@
+import AppKit
+import CodexBarCore
+import SwiftUI
+
+extension StatusItemController {
+    /// Smart update: rebuild everything below the provider switcher while keeping the switcher view intact.
+    struct MenuUpdateContext {
+        let provider: UsageProvider?
+        let currentProvider: UsageProvider
+        let switcherSelection: ProviderSwitcherSelection
+        let menuWidth: CGFloat
+        let codexAccountDisplay: CodexAccountMenuDisplay?
+        let tokenAccountDisplay: TokenAccountMenuDisplay?
+        let openAIContext: OpenAIWebContext
+        let descriptor: MenuDescriptor
+    }
+
+    /// Smart update: rebuild everything below the provider switcher while keeping the switcher view intact.
+    func updateMenuContentPreservingSwitcher(
+        _ menu: NSMenu,
+        context: MenuUpdateContext)
+    {
+        self.performMenuMutationWithoutAnimation {
+            let contentStartIndex = self.providerSwitcherContentStartIndex(in: menu)
+            if let switcherView = menu.items.first?.view as? ProviderSwitcherView {
+                switcherView.updateSelection(context.switcherSelection)
+                switcherView.updateQuotaIndicators()
+            }
+            let outgoingSelection = self.lastMergedMenuContentSelection
+            let isSelectionSwitch = outgoingSelection != nil && outgoingSelection != context.switcherSelection
+            let enabledProviders = self.store.enabledProvidersForDisplay()
+
+            if isSelectionSwitch,
+               let outgoingSelection,
+               let cachedItems = self.reusableMergedSwitcherContent(
+                   for: context.switcherSelection,
+                   in: menu,
+                   menuWidth: context.menuWidth,
+                   codexAccountDisplay: context.codexAccountDisplay,
+                   tokenAccountDisplay: context.tokenAccountDisplay)
+            {
+                // Park the outgoing payloads for an equally instant switch-back. Compatible
+                // menu-item shells stay attached, avoiding the empty intermediate layout that
+                // AppKit can visibly render when the whole content block is removed first.
+                let outgoingCodexAccountDisplay = self.lastCodexAccountMenuDisplay
+                let outgoingTokenAccountDisplay = self.lastTokenAccountMenuDisplay
+                self.rememberMergedSwitcherState(enabledProviders, context.switcherSelection)
+                let displacedItems = self.replaceMenuContentKeepingRowsVisible(
+                    menu,
+                    fromIndex: contentStartIndex,
+                    with: cachedItems)
+                // Cached items may have changed refresh state while detached from a menu.
+                self.updatePersistentRefreshItemsEnabled()
+                self.cacheMergedSwitcherContent(
+                    displacedItems,
+                    in: menu,
+                    selection: outgoingSelection,
+                    context: MergedSwitcherContentCacheContext(
+                        menuWidth: context.menuWidth,
+                        codexAccountDisplay: outgoingCodexAccountDisplay,
+                        tokenAccountDisplay: outgoingTokenAccountDisplay,
+                        contentVersion: nil))
+                self.lastCodexAccountMenuDisplay = context.codexAccountDisplay
+                self.lastTokenAccountMenuDisplay = context.tokenAccountDisplay
+                self.cacheVisibleMergedSwitcherContent(
+                    in: menu,
+                    selection: context.switcherSelection,
+                    contentStartIndex: contentStartIndex,
+                    menuWidth: context.menuWidth,
+                    contentVersion: self.menuSession.contentVersion)
+                return
+            }
+
+            // Rebuild path (data tick, or switch whose incoming tab must be built): recycle
+            // the outgoing hosting views and reconcile in place when the row skeleton is
+            // unchanged, so an open tracked menu sees content mutations instead of item
+            // churn. The fresh content is built into a detached scratch menu while its
+            // interaction closures capture the live menu they will serve.
+            let shapes = self.menuContentShapes(in: menu, fromIndex: contentStartIndex)
+            self.harvestRecyclableMenuCardViews(
+                in: menu,
+                fromIndex: contentStartIndex,
+                displacedSelection: outgoingSelection,
+                preserveHighlightedItem: true)
+            defer { self.clearMenuCardViewRecyclePool() }
+            self.rememberMergedSwitcherState(enabledProviders, context.switcherSelection)
+            let scratch = NSMenu()
+            scratch.autoenablesItems = false
+            self.addSwitcherScopedMenuContent(into: scratch, captureMenu: menu, context: context)
+            self.reconcileMenuContent(menu, fromIndex: contentStartIndex, shapes: shapes, with: scratch)
+            self.cacheVisibleMergedSwitcherContent(
+                in: menu,
+                selection: context.switcherSelection,
+                contentStartIndex: contentStartIndex,
+                menuWidth: context.menuWidth,
+                contentVersion: self.menuSession.contentVersion)
+        }
+    }
+
+    /// Adds everything below the provider switcher (account switchers, card content, and
+    /// actionable sections) to `target`, which may be a detached scratch menu; interaction
+    /// closures always capture `captureMenu`, the live menu the rows will serve.
+    private func addSwitcherScopedMenuContent(
+        into target: NSMenu,
+        captureMenu: NSMenu,
+        context: MenuUpdateContext)
+    {
+        self.addCodexAccountSwitcherIfNeeded(
+            to: target,
+            display: context.codexAccountDisplay,
+            width: context.menuWidth,
+            captureMenu: captureMenu)
+        self.lastCodexAccountMenuDisplay = context.codexAccountDisplay
+        self.addTokenAccountSwitcherIfNeeded(
+            to: target,
+            display: context.tokenAccountDisplay,
+            width: context.menuWidth,
+            captureMenu: captureMenu)
+        self.lastTokenAccountMenuDisplay = context.tokenAccountDisplay
+
+        let menuContext = MenuCardContext(
+            currentProvider: context.currentProvider,
+            selectedProvider: context.provider,
+            menuWidth: context.menuWidth,
+            codexAccountDisplay: context.codexAccountDisplay,
+            tokenAccountDisplay: context.tokenAccountDisplay,
+            openAIContext: context.openAIContext)
+        self.addPrimaryMenuContent(
+            to: target,
+            context: menuContext,
+            switcherSelection: context.switcherSelection,
+            captureMenu: captureMenu)
+        self.addActionableSections(
+            context.descriptor.sections,
+            to: target,
+            width: context.menuWidth,
+            captureMenu: captureMenu)
+    }
+}
diff --git a/Sources/CodexBar/StatusItemController+MenuTracking.swift b/Sources/CodexBar/StatusItemController+MenuTracking.swift
new file mode 100644
index 0000000000..751d19ef00
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+MenuTracking.swift
@@ -0,0 +1,505 @@
+import AppKit
+import CodexBarCore
+
+extension StatusItemController {
+    private static let defaultClosedMenuPreparationDelay: Duration = .milliseconds(350)
+
+    var isMenuRefreshEnabled: Bool {
+        #if DEBUG
+        if let menuRefreshEnabledOverrideForTesting {
+            return menuRefreshEnabledOverrideForTesting
+        }
+        #endif
+        return self.menuRefreshEnabledForController
+    }
+
+    #if DEBUG
+    private static var closedMenuPreparationDelayForTesting: Duration = defaultClosedMenuPreparationDelay
+    static func setClosedMenuPreparationDelayForTesting(_ delay: Duration) {
+        self.closedMenuPreparationDelayForTesting = delay
+    }
+
+    static func resetClosedMenuPreparationDelayForTesting() {
+        self.closedMenuPreparationDelayForTesting = self.defaultClosedMenuPreparationDelay
+    }
+    #endif
+
+    private static var closedMenuPreparationDelay: Duration {
+        #if DEBUG
+        closedMenuPreparationDelayForTesting
+        #else
+        defaultClosedMenuPreparationDelay
+        #endif
+    }
+
+    func invalidateMenus(
+        refreshOpenMenus: Bool = false,
+        deferOpenParentMenuRebuild: Bool = false,
+        allowStaleContentDuringDataRefresh: Bool = false)
+    {
+        #if DEBUG
+        guard !self.isReleasedForTesting else { return }
+        #endif
+        let preservesMergedSwitcherContentCaches = self.preservesMergedSwitcherContentCachesDuringInvalidation
+        self.menuSession.invalidate(
+            allowsStaleContent: allowStaleContentDuringDataRefresh,
+            requiresRebuild: !preservesMergedSwitcherContentCaches)
+        if !preservesMergedSwitcherContentCaches {
+            self.clearMergedSwitcherContentCaches()
+        }
+        self.pruneVersionScopedMenuCardHeightCache()
+        guard self.isMenuRefreshEnabled else { return }
+        if !self.openMenus.isEmpty {
+            guard refreshOpenMenus else { return }
+            self.refreshOpenMenusAllowingParentRebuild(
+                deferParentRebuildDuringTracking: deferOpenParentMenuRebuild)
+            self.scheduleOpenMenuInvalidationRetry(
+                deferParentRebuildDuringTracking: deferOpenParentMenuRebuild)
+            return
+        }
+        if allowStaleContentDuringDataRefresh {
+            if !self.cancelNonRequiredClosedMenuPreparation() {
+                self.prepareAttachedClosedMenusIfNeeded()
+            }
+            return
+        }
+        self.prepareAttachedClosedMenusIfNeeded()
+    }
+
+    @discardableResult
+    private func cancelNonRequiredClosedMenuPreparation() -> Bool {
+        let menus = self.attachedMenusForClosedPreparation()
+        let menuIDs = menus.map(ObjectIdentifier.init)
+        guard !self.menuSession.hasRequiredClosedPreparation(for: menuIDs) else { return false }
+        self.cancelAllClosedMenuRebuilds()
+        for menuID in menuIDs {
+            self.menuSession.clearNextOpenDeferral(menuID)
+        }
+        return true
+    }
+
+    func prepareAttachedClosedMenusIfNeeded() {
+        guard self.isMenuRefreshEnabled else { return }
+        guard self.openMenus.isEmpty else { return }
+        guard !self.isMenuDataRefreshInFlight else { return }
+        let menus = self.attachedMenusForClosedPreparation()
+        let preparationPlan = self.menuSession.closedPreparationPlan(
+            for: menus.lazy.map(ObjectIdentifier.init))
+        guard preparationPlan != .none else { return }
+        for menu in menus {
+            let key = ObjectIdentifier(menu)
+            switch preparationPlan {
+            case .none:
+                return
+            case .nonDeferred:
+                guard !self.menuSession.isDeferredUntilNextOpen(key) else { continue }
+            case let .required(requiredVersion):
+                self.menuSession.clearNextOpenDeferral(key)
+                guard self.menuSession.isRenderedVersion(key, olderThan: requiredVersion) else { continue }
+            }
+            // Pre-warming the merged menu while it is closed runs a full main-thread populateMenu
+            // (incl. SwiftUI hosting-view layout) that menuWillOpen redoes synchronously on display
+            // anyway. In Merge Icons mode it is the only attached menu, so this just relocates that
+            // work into a background freeze on every store tick (#1274). Defer it until next open.
+            if menu === self.mergedMenu {
+                self.menuSession.deferUntilNextOpen(key)
+                continue
+            }
+            self.rebuildClosedMenuIfNeeded(menu)
+        }
+    }
+
+    var isMenuDataRefreshInFlight: Bool {
+        self.store.isRefreshing ||
+            self.manualRefreshTask != nil ||
+            !self.store.refreshingProviders.isEmpty ||
+            UsageProvider.allCases.contains { self.store.isTokenRefreshInFlight(for: $0) }
+    }
+
+    func removeMenuTrackingState(_ key: ObjectIdentifier) {
+        self.menuProviders.removeValue(forKey: key)
+        self.menuSession.removeMenu(key)
+        self.menuReadinessSignatures.removeValue(forKey: key)
+        self.menuIdentitySignatures.removeValue(forKey: key)
+    }
+
+    func cancelMenuWork(_ key: ObjectIdentifier) {
+        self.menuRefreshTasks.removeValue(forKey: key)?.cancel()
+        self.closedMenuRebuildTasks.removeValue(forKey: key)?.cancel()
+        self.closedMenuRebuildRequests.cancel(for: key)
+        self.openMenuRebuildTasks.removeValue(forKey: key)?.cancel()
+        self.openMenuRebuildRequests.cancel(for: key)
+        self.openMenuRebuildsClosingHostedSubviewMenus.remove(key)
+    }
+
+    func clearMenuHighlight(_ key: ObjectIdentifier) {
+        if let highlightedView = self.highlightedMenuItems.removeValue(forKey: key)?.view {
+            (highlightedView as? MenuCardHighlighting)?.setHighlighted(false)
+        }
+    }
+
+    func removeMenuLifecycleState(_ key: ObjectIdentifier) {
+        self.openMenus.removeValue(forKey: key)
+        self.cancelMenuWork(key)
+        self.clearMenuHighlight(key)
+        self.removeMenuTrackingState(key)
+    }
+
+    func handleClosedPersistentMenuNeedingRefresh(_ menu: NSMenu) {
+        if menu === self.mergedMenu {
+            // Closing the merged menu is on the user's dismiss path. Leave stale content attached and let
+            // menuWillOpen rebuild it, while other closed-menu invalidations can still prepare in the background.
+            self.menuSession.deferUntilNextOpen(ObjectIdentifier(menu))
+        } else {
+            self.rebuildClosedMenuIfNeeded(menu)
+        }
+    }
+
+    func refreshMenuForOpenIfNeeded(_ menu: NSMenu, provider: UsageProvider?) {
+        self.menuSession.clearNextOpenDeferral(ObjectIdentifier(menu))
+        guard self.menuNeedsRefresh(menu) else { return }
+        if self.canPreserveStaleMenuContentForInstantOpen(menu) {
+            #if DEBUG
+            self.menuLogger.debug(
+                "menu open kept existing content for instant render",
+                metadata: [
+                    "items": "\(menu.items.count)",
+                    "provider": provider?.rawValue ?? "nil",
+                    "storeRefreshing": self.store.isRefreshing ? "1" : "0",
+                ])
+            #endif
+            if self.isMenuRefreshEnabled, !self.isMenuDataRefreshInFlight {
+                self.scheduleOpenMenuRebuildIfStillVisible(
+                    menu,
+                    provider: provider,
+                    resyncReadinessBaselineAfterRebuild: self.openMenus.isEmpty)
+            }
+            return
+        }
+        self.populateMenu(menu, provider: provider)
+        self.markMenuFresh(menu)
+    }
+
+    private func canPreserveStaleMenuContentForInstantOpen(_ menu: NSMenu) -> Bool {
+        guard !menu.items.isEmpty else { return false }
+        let key = ObjectIdentifier(menu)
+        return self.menuSession.canPreserveStaleContent(for: key) &&
+            self.menuIdentitySignatures[key] == self.menuIdentitySignature(
+                for: self.renderedProviders(for: menu))
+    }
+
+    private func attachedMenusForClosedPreparation() -> [NSMenu] {
+        var menus: [NSMenu] = []
+        var seen = Set<ObjectIdentifier>()
+
+        func append(_ menu: NSMenu?) {
+            guard let menu else { return }
+            let key = ObjectIdentifier(menu)
+            guard seen.insert(key).inserted else { return }
+            menus.append(menu)
+        }
+
+        append(self.statusItem.menu)
+        append(self.mergedMenu)
+        append(self.fallbackMenu)
+        for item in self.statusItems.values {
+            append(item.menu)
+        }
+        for menu in self.providerMenus.values {
+            append(menu)
+        }
+        return menus
+    }
+
+    func renderedMenuWidth(for menu: NSMenu) -> CGFloat {
+        let menuKey = ObjectIdentifier(menu)
+        let trackedWindowWidth: CGFloat? = if self.openMenus[menuKey] != nil {
+            menu.items.lazy.compactMap { item -> CGFloat? in
+                guard let window = item.view?.window else { return nil }
+                let contentWidth = window.contentLayoutRect.width
+                return contentWidth > 0 ? contentWidth : window.frame.width
+            }.first
+        } else {
+            nil
+        }
+        return Self.resolvedRenderedMenuWidth(
+            menuWidth: menu.size.width,
+            trackedWindowWidth: trackedWindowWidth)
+    }
+
+    static func resolvedRenderedMenuWidth(
+        menuWidth: CGFloat,
+        trackedWindowWidth: CGFloat?) -> CGFloat
+    {
+        max(
+            ceil(menuWidth),
+            ceil(trackedWindowWidth ?? 0),
+            menuCardBaseWidth)
+    }
+
+    func rebuildClosedMenuIfNeeded(_ menu: NSMenu) {
+        guard !self.hasPreparedForAppShutdown else { return }
+        guard !self.isMenuDataRefreshInFlight else { return }
+        let key = ObjectIdentifier(menu)
+        let provider = self.menuProvider(for: menu)
+        let rebuildToken = self.closedMenuRebuildRequests.replaceRequest(for: key)
+        self.closedMenuRebuildTasks[key]?.cancel()
+        self.closedMenuRebuildTasks[key] = Task { @MainActor [weak self, weak menu] in
+            let delay = Self.closedMenuPreparationDelay
+            if delay > .zero {
+                try? await Task.sleep(for: delay)
+            }
+            guard !Task.isCancelled else { return }
+            await Task.yield()
+            guard !Task.isCancelled else { return }
+            guard let self else { return }
+            defer {
+                if self.closedMenuRebuildRequests.finish(rebuildToken, for: key) {
+                    self.closedMenuRebuildTasks.removeValue(forKey: key)
+                }
+            }
+            guard let menu else { return }
+            guard self.closedMenuRebuildRequests.isCurrent(rebuildToken, for: key) else { return }
+            guard !self.hasPreparedForAppShutdown else { return }
+            guard !self.isMenuDataRefreshInFlight else { return }
+            // A delayed prewarm for one menu must never populate while another menu is tracking.
+            guard self.openMenus.isEmpty else { return }
+            guard self.menuNeedsRefresh(menu) else { return }
+            self.populateMenu(menu, provider: provider)
+            self.markMenuFresh(menu)
+            #if DEBUG
+            if self.lastLoggedClosedMenuRebuildVersion != self.menuSession.contentVersion {
+                self.lastLoggedClosedMenuRebuildVersion = self.menuSession.contentVersion
+                self.menuLogger.debug(
+                    "closed menu rebuild completed",
+                    metadata: [
+                        "items": "\(menu.items.count)",
+                        "provider": provider?.rawValue ?? "nil",
+                    ])
+            }
+            #endif
+        }
+    }
+
+    func cancelClosedMenuRebuild(_ menu: NSMenu) {
+        let key = ObjectIdentifier(menu)
+        self.closedMenuRebuildTasks.removeValue(forKey: key)?.cancel()
+        self.closedMenuRebuildRequests.cancel(for: key)
+    }
+
+    func cancelAllClosedMenuRebuilds() {
+        for task in self.closedMenuRebuildTasks.values {
+            task.cancel()
+        }
+        self.closedMenuRebuildTasks.removeAll(keepingCapacity: false)
+        self.closedMenuRebuildRequests.cancelAll()
+    }
+
+    func menuNeedsRefresh(_ menu: NSMenu) -> Bool {
+        self.menuSession.needsRefresh(ObjectIdentifier(menu))
+    }
+
+    func markMenuFresh(_ menu: NSMenu) {
+        let key = ObjectIdentifier(menu)
+        self.menuSession.markFresh(key)
+        self.menuReadinessSignatures[key] = self.menuAdjunctReadinessSignature()
+        self.menuIdentitySignatures[key] = self.menuIdentitySignature(
+            for: self.renderedProviders(for: menu))
+    }
+
+    private func menuIdentitySignature(for providers: [UsageProvider]) -> String {
+        var parts: [String] = []
+        for target in providers {
+            parts.append(target.rawValue)
+            parts.append(self.providerIdentitySignature(self.store.snapshot(for: target)?.identity(for: target)))
+
+            if target != .codex, self.store.metadata(for: target).usesAccountFallback {
+                let account = self.store.accountInfo(for: target)
+                parts.append(Self.menuIdentityField(account.email))
+                parts.append(Self.menuIdentityField(account.plan))
+            }
+
+            for accountSnapshot in self.store.accountSnapshots[target] ?? [] {
+                parts.append(accountSnapshot.account.id.uuidString)
+                parts.append(Self.menuIdentityField(accountSnapshot.account.label))
+                parts.append(self.providerIdentitySignature(accountSnapshot.snapshot?.identity(for: target)))
+            }
+
+            if target == .codex {
+                parts.append(Self.menuIdentityField(self.account.email))
+                parts.append(Self.menuIdentityField(self.account.plan))
+                for account in self.settings.codexVisibleAccountProjectionForMenuDisplay?.visibleAccounts ?? [] {
+                    parts.append(Self.menuIdentityField(account.id))
+                    parts.append(Self.menuIdentityField(account.email))
+                    parts.append(Self.menuIdentityField(account.workspaceLabel))
+                    parts.append(account.isActive ? "active" : "inactive")
+                    parts.append(account.isLive ? "live" : "stored")
+                }
+                for accountSnapshot in self.store.codexAccountSnapshots {
+                    parts.append(Self.menuIdentityField(accountSnapshot.id))
+                    parts.append(self.providerIdentitySignature(accountSnapshot.snapshot?.identity(for: target)))
+                }
+            }
+
+            if target == .kilo {
+                for scopeSnapshot in self.store.kiloScopeSnapshots {
+                    parts.append(Self.menuIdentityField(scopeSnapshot.id))
+                    parts.append(self.providerIdentitySignature(scopeSnapshot.snapshot?.identity(for: target)))
+                }
+            }
+        }
+        return parts.joined(separator: "|")
+    }
+
+    private func providerIdentitySignature(_ identity: ProviderIdentitySnapshot?) -> String {
+        [
+            identity?.providerID?.rawValue ?? "",
+            Self.menuIdentityField(identity?.accountEmail),
+            Self.menuIdentityField(identity?.accountOrganization),
+            Self.menuIdentityField(identity?.loginMethod),
+        ].joined(separator: ":")
+    }
+
+    private static func menuIdentityField(_ value: String?) -> String {
+        let value = value ?? ""
+        return "\(value.utf8.count):\(value)"
+    }
+
+    func hasOpenHostedSubviewMenu() -> Bool {
+        self.openMenus.values.contains { self.isHostedSubviewMenu($0) }
+    }
+
+    func refreshOpenMenuIfStillVisible(_ menu: NSMenu, provider: UsageProvider?) {
+        let key = ObjectIdentifier(menu)
+        guard self.openMenus[key] != nil else { return }
+        if self.isHostedSubviewMenu(menu) {
+            self.scheduleOpenMenuRebuildIfStillVisible(menu, provider: provider)
+            return
+        }
+        self.invalidateMenus(
+            refreshOpenMenus: true,
+            deferOpenParentMenuRebuild: true,
+            allowStaleContentDuringDataRefresh: true)
+    }
+
+    func rebuildOpenMenuIfStillVisible(_ menu: NSMenu, provider: UsageProvider?) {
+        let key = ObjectIdentifier(menu)
+        guard self.openMenus[key] != nil else { return }
+        guard self.isHostedSubviewMenu(menu) || !self.hasOpenHostedSubviewMenu() else { return }
+        self.populateMenu(menu, provider: provider)
+        self.markMenuFresh(menu)
+        self.menuSession.clearParentRebuildDeferral(key)
+        self.applyIcon(phase: nil)
+        #if DEBUG
+        self._test_openMenuRebuildObserver?(menu)
+        #endif
+    }
+
+    func refreshOpenMenusIfNeeded() {
+        guard self.isMenuRefreshEnabled else { return }
+        guard !self.openMenus.isEmpty else { return }
+        self.refreshOpenMenusIfNeeded(allowsParentRebuild: false)
+    }
+
+    func refreshOpenMenusForStructureChange() {
+        self.refreshOpenMenusAllowingParentRebuild()
+    }
+
+    func refreshOpenMenusAfterHostedSubviewClose() {
+        guard self.isMenuRefreshEnabled else { return }
+        guard !self.openMenus.isEmpty else { return }
+        if self.isMenuDataRefreshInFlight {
+            self.parentMenuRebuildPendingAfterHostedSubviewClose = true
+            return
+        }
+        self.parentMenuRebuildPendingAfterHostedSubviewClose = false
+        self.refreshOpenMenusIfNeeded(allowsParentRebuild: true)
+    }
+
+    func completeParentMenuRebuildAfterHostedSubviewCloseIfNeeded() {
+        guard self.parentMenuRebuildPendingAfterHostedSubviewClose else { return }
+        guard !self.isMenuDataRefreshInFlight else { return }
+        guard !self.hasOpenHostedSubviewMenu() else { return }
+        self.refreshOpenMenusAfterHostedSubviewClose()
+    }
+
+    func refreshOpenMenusAllowingParentRebuild(deferParentRebuildDuringTracking: Bool = false) {
+        guard self.isMenuRefreshEnabled else { return }
+        guard !self.openMenus.isEmpty else { return }
+        self.refreshOpenMenusIfNeeded(
+            allowsParentRebuild: true,
+            deferParentRebuildDuringTracking: deferParentRebuildDuringTracking)
+    }
+
+    func scheduleOpenMenuInvalidationRetry(deferParentRebuildDuringTracking: Bool = false) {
+        self.openMenuInvalidationRetryTask?.cancel()
+        self.openMenuInvalidationRetryTask = Task { @MainActor [weak self] in
+            guard let self else { return }
+            await Task.yield()
+            guard !Task.isCancelled else { return }
+            #if DEBUG
+            self.onOpenMenuInvalidationRetryForTesting?()
+            #endif
+            self.refreshOpenMenusAllowingParentRebuild(
+                deferParentRebuildDuringTracking: deferParentRebuildDuringTracking)
+            self.openMenuInvalidationRetryTask = nil
+        }
+    }
+
+    private func refreshOpenMenusIfNeeded(
+        allowsParentRebuild: Bool,
+        deferParentRebuildDuringTracking: Bool = false,
+        respectsParentRebuildDeferral: Bool = false)
+    {
+        var orphanedKeys: [ObjectIdentifier] = []
+        let hasOpenHostedSubviewMenu = self.hasOpenHostedSubviewMenu()
+        for (key, menu) in self.openMenus {
+            guard key == ObjectIdentifier(menu) else {
+                orphanedKeys.append(key)
+                continue
+            }
+            self.refreshOpenMenuIfNeeded(
+                menu,
+                allowsParentRebuild: allowsParentRebuild,
+                deferParentRebuildDuringTracking: deferParentRebuildDuringTracking,
+                respectsParentRebuildDeferral: respectsParentRebuildDeferral,
+                hasOpenHostedSubviewMenu: hasOpenHostedSubviewMenu)
+        }
+        self.removeOrphanedOpenMenuEntries(orphanedKeys)
+    }
+
+    private func refreshOpenMenuIfNeeded(
+        _ menu: NSMenu,
+        allowsParentRebuild: Bool,
+        deferParentRebuildDuringTracking: Bool,
+        respectsParentRebuildDeferral: Bool,
+        hasOpenHostedSubviewMenu: Bool)
+    {
+        if self.isHostedSubviewMenu(menu) {
+            self.refreshHostedSubviewMenu(menu)
+            return
+        }
+        guard allowsParentRebuild else { return }
+        guard self.menuNeedsRefresh(menu) else { return }
+        let key = ObjectIdentifier(menu)
+
+        if deferParentRebuildDuringTracking {
+            self.menuSession.deferParentRebuild(key)
+            return
+        }
+        if respectsParentRebuildDeferral, self.menuSession.isParentRebuildDeferred(key) {
+            return
+        }
+        self.menuSession.clearParentRebuildDeferral(key)
+        guard !hasOpenHostedSubviewMenu else { return }
+
+        let provider = self.menuProvider(for: menu)
+        self.scheduleOpenMenuRebuildIfStillVisible(menu, provider: provider)
+    }
+
+    private func removeOrphanedOpenMenuEntries(_ keys: [ObjectIdentifier]) {
+        for key in keys {
+            self.removeMenuLifecycleState(key)
+        }
+    }
+}
diff --git a/Sources/CodexBar/StatusItemController+MenuTypes.swift b/Sources/CodexBar/StatusItemController+MenuTypes.swift
new file mode 100644
index 0000000000..03fc1785a0
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+MenuTypes.swift
@@ -0,0 +1,170 @@
+import AppKit
+import CodexBarCore
+import SwiftUI
+
+extension ProviderSwitcherSelection {
+    var provider: UsageProvider? {
+        switch self {
+        case .overview:
+            nil
+        case let .provider(provider):
+            provider
+        }
+    }
+}
+
+struct OverviewMenuCardRowView: View {
+    let model: UsageMenuCardView.Model
+    let storageText: String?
+    let width: CGFloat
+    @Environment(\.menuItemHighlighted) private var isHighlighted
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 0) {
+            UsageMenuCardHeaderSectionView(
+                model: self.model,
+                showDivider: self.hasUsageBlock,
+                width: self.width)
+            if self.hasUsageBlock {
+                UsageMenuCardUsageSectionView(
+                    model: self.model,
+                    showBottomDivider: false,
+                    bottomPadding: 6,
+                    width: self.width)
+            }
+            if let storageText {
+                HStack(alignment: .firstTextBaseline, spacing: 4) {
+                    Text("\(L("Storage")):")
+                        .font(.footnote)
+                        .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
+                    Text(storageText)
+                        .font(.footnote)
+                        .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
+                        .lineLimit(1)
+                    Spacer()
+                }
+                .padding(.horizontal, UsageMenuCardLayout.horizontalPadding)
+                .padding(.top, self.hasUsageBlock ? 0 : 8)
+                .padding(.bottom, 6)
+                .frame(width: self.width, alignment: .leading)
+            }
+        }
+        .frame(width: self.width, alignment: .leading)
+    }
+
+    private var hasUsageBlock: Bool {
+        self.model.hasUsageContent
+    }
+}
+
+struct OpenAIWebMenuItems {
+    let hasUsageBreakdown: Bool
+    let hasCreditsHistory: Bool
+    let hasCostHistory: Bool
+    let canShowBuyCredits: Bool
+}
+
+struct TokenAccountMenuDisplay: Equatable {
+    let provider: UsageProvider
+    let accounts: [ProviderTokenAccount]
+    let snapshots: [TokenAccountUsageSnapshot]
+    let activeIndex: Int
+    let layout: MultiAccountMenuLayout
+
+    var showAll: Bool {
+        self.layout == .stacked
+    }
+
+    var showSwitcher: Bool {
+        self.layout == .segmented
+    }
+
+    static func == (lhs: TokenAccountMenuDisplay, rhs: TokenAccountMenuDisplay) -> Bool {
+        lhs.provider == rhs.provider &&
+            lhs.accountIdentity == rhs.accountIdentity &&
+            lhs.activeIndex == rhs.activeIndex &&
+            lhs.layout == rhs.layout &&
+            lhs.snapshotIdentity == rhs.snapshotIdentity
+    }
+
+    private var accountIdentity: [AccountIdentity] {
+        self.accounts.map { account in
+            AccountIdentity(
+                id: account.id,
+                label: account.label,
+                externalIdentifier: account.externalIdentifier,
+                organizationID: account.organizationID)
+        }
+    }
+
+    private var snapshotIdentity: [SnapshotIdentity] {
+        self.snapshots.map { snapshot in
+            SnapshotIdentity(
+                id: snapshot.id,
+                hasSnapshot: snapshot.snapshot != nil,
+                error: snapshot.error,
+                sourceLabel: snapshot.sourceLabel)
+        }
+    }
+
+    private struct AccountIdentity: Equatable {
+        let id: UUID
+        let label: String
+        let externalIdentifier: String?
+        let organizationID: String?
+    }
+
+    private struct SnapshotIdentity: Equatable {
+        let id: UUID
+        let hasSnapshot: Bool
+        let error: String?
+        let sourceLabel: String?
+    }
+}
+
+struct CodexAccountMenuDisplay: Equatable {
+    let accounts: [CodexVisibleAccount]
+    let snapshots: [CodexAccountUsageSnapshot]
+    let activeVisibleAccountID: String?
+    let layout: MultiAccountMenuLayout
+
+    var showAll: Bool {
+        self.layout == .stacked
+    }
+
+    var showSwitcher: Bool {
+        self.layout == .segmented
+    }
+
+    var workspaceSections: [CodexAccountWorkspaceSection] {
+        self.accounts.codexWorkspaceSections()
+    }
+
+    var showsWorkspaceGroups: Bool {
+        Set(self.workspaceSections.map(\.title)).count > 1
+    }
+
+    static func == (lhs: CodexAccountMenuDisplay, rhs: CodexAccountMenuDisplay) -> Bool {
+        lhs.accounts == rhs.accounts &&
+            lhs.activeVisibleAccountID == rhs.activeVisibleAccountID &&
+            lhs.layout == rhs.layout &&
+            lhs.snapshotIdentity == rhs.snapshotIdentity
+    }
+
+    private var snapshotIdentity: [SnapshotIdentity] {
+        self.snapshots.map { snapshot in
+            SnapshotIdentity(
+                id: snapshot.id,
+                hasSnapshot: snapshot.snapshot != nil,
+                error: snapshot.error,
+                sourceLabel: snapshot.sourceLabel)
+        }
+    }
+
+    private struct SnapshotIdentity: Equatable {
+        let id: String
+        let hasSnapshot: Bool
+        let error: String?
+        let sourceLabel: String?
+    }
+}
diff --git a/Sources/CodexBar/StatusItemController+MenuWidthCache.swift b/Sources/CodexBar/StatusItemController+MenuWidthCache.swift
new file mode 100644
index 0000000000..8f18e5266a
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+MenuWidthCache.swift
@@ -0,0 +1,141 @@
+import AppKit
+import CodexBarCore
+
+extension StatusItemController {
+    private static let measuredStandardMenuWidthCacheLimit = 96
+
+    func menuCardWidth(
+        for providers: [UsageProvider],
+        selectedProvider: UsageProvider?,
+        descriptor: MenuDescriptor) -> CGFloat
+    {
+        let sectionSets: [[MenuDescriptor.Section]] = if self.shouldMergeIcons, providers.count > 1 {
+            providers.map { provider in
+                if provider == selectedProvider {
+                    return descriptor.sections
+                }
+                return self.makeMenuDescriptor(
+                    provider: provider,
+                    includeContextualActions: true).sections
+            }
+        } else {
+            [descriptor.sections]
+        }
+        return self.measuredMenuCardWidth(for: sectionSets)
+    }
+
+    func measuredMenuCardWidth(for sectionSets: [[MenuDescriptor.Section]]) -> CGFloat {
+        let baselineWidth = Self.menuCardBaseWidth
+        return sectionSets.reduce(baselineWidth) { width, sections in
+            max(width, self.measuredStandardMenuWidth(for: sections, baseWidth: baselineWidth))
+        }
+    }
+
+    func makeMenuDescriptor(
+        provider: UsageProvider?,
+        includeContextualActions: Bool) -> MenuDescriptor
+    {
+        MenuDescriptor.build(
+            provider: provider,
+            store: self.store,
+            settings: self.settings,
+            account: self.account,
+            managedCodexAccountCoordinator: self.managedCodexAccountCoordinator,
+            codexAccountPromotionCoordinator: self.codexAccountPromotionCoordinator,
+            updateReady: self.updater.updateStatus.isUpdateReady,
+            includeContextualActions: includeContextualActions)
+    }
+
+    func measuredStandardMenuWidth(for sections: [MenuDescriptor.Section], baseWidth: CGFloat) -> CGFloat {
+        let cacheKey = self.measuredStandardMenuWidthCacheKey(for: sections, baseWidth: baseWidth)
+        if let cached = self.measuredStandardMenuWidthCache[cacheKey] {
+            return cached
+        }
+
+        let measuringMenu = NSMenu()
+        measuringMenu.autoenablesItems = false
+        self.addActionableSections(sections, to: measuringMenu, width: baseWidth)
+        let measured = ceil(measuringMenu.size.width)
+        if self.measuredStandardMenuWidthCache.count >= Self.measuredStandardMenuWidthCacheLimit {
+            self.measuredStandardMenuWidthCache.removeAll(keepingCapacity: true)
+        }
+        self.measuredStandardMenuWidthCache[cacheKey] = measured
+        return measured
+    }
+
+    private func measuredStandardMenuWidthCacheKey(
+        for sections: [MenuDescriptor.Section],
+        baseWidth: CGFloat) -> String
+    {
+        var parts = [
+            "base=\(Int((baseWidth * 100).rounded()))",
+            "font=\(Self.menuCardHeightTextScaleToken())",
+            self.menuLocalizationSignature(),
+        ]
+        for section in sections {
+            parts.append("[")
+            for entry in section.entries {
+                parts.append(self.measuredStandardMenuWidthCacheToken(for: entry))
+            }
+            parts.append("]")
+        }
+        return parts.joined(separator: "\u{1f}")
+    }
+
+    private func measuredStandardMenuWidthCacheToken(for entry: MenuDescriptor.Entry) -> String {
+        switch entry {
+        case let .text(text, style):
+            "text:\(style):\(text)"
+        case let .action(title, action):
+            "action:\(title):\(self.measuredStandardMenuWidthCacheToken(for: action))"
+        case let .submenu(title, systemImageName, submenuItems):
+            "submenu:\(title):\(systemImageName ?? ""):" + submenuItems.map { item in
+                [
+                    item.title,
+                    item.isEnabled ? "1" : "0",
+                    item.isChecked ? "1" : "0",
+                    item.action.map(self.measuredStandardMenuWidthCacheToken(for:)) ?? "",
+                ].joined(separator: ":")
+            }.joined(separator: ",")
+        case .divider:
+            "divider"
+        }
+    }
+
+    private func measuredStandardMenuWidthCacheToken(for action: MenuDescriptor.MenuAction) -> String {
+        switch action {
+        case .installUpdate:
+            "installUpdate"
+        case .refresh:
+            "refresh"
+        case .refreshAugmentSession:
+            "refreshAugmentSession"
+        case .dashboard:
+            "dashboard"
+        case .statusPage:
+            "statusPage"
+        case .changelog:
+            "changelog"
+        case .addCodexAccount:
+            "addCodexAccount:\(self.codexAddAccountSubtitle() ?? "")"
+        case let .requestCodexSystemPromotion(id):
+            "requestCodexSystemPromotion:\(id)"
+        case let .addProviderAccount(provider):
+            "addProviderAccount:\(provider.rawValue)"
+        case let .switchAccount(provider):
+            "switchAccount:\(provider.rawValue):\(self.switchAccountSubtitle(for: provider) ?? "")"
+        case let .openTerminal(command):
+            "openTerminal:\(command)"
+        case let .loginToProvider(url):
+            "loginToProvider:\(url)"
+        case .settings:
+            "settings"
+        case .about:
+            "about"
+        case .quit:
+            "quit"
+        case let .copyError(message):
+            "copyError:\(message)"
+        }
+    }
+}
diff --git a/Sources/CodexBar/StatusItemController+MergedSwitcherContentCache.swift b/Sources/CodexBar/StatusItemController+MergedSwitcherContentCache.swift
new file mode 100644
index 0000000000..f060a53edf
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+MergedSwitcherContentCache.swift
@@ -0,0 +1,142 @@
+import AppKit
+
+struct CachedMergedSwitcherMenuContent {
+    let requiredMenuContentVersion: Int
+    let menuWidth: CGFloat
+    let codexAccountDisplay: CodexAccountMenuDisplay?
+    let tokenAccountDisplay: TokenAccountMenuDisplay?
+    let localizationSignature: String
+    let items: [NSMenuItem]
+
+    func matches(
+        requiredMenuContentVersion: Int,
+        menuWidth: CGFloat,
+        codexAccountDisplay: CodexAccountMenuDisplay?,
+        tokenAccountDisplay: TokenAccountMenuDisplay?,
+        localizationSignature: String)
+        -> Bool
+    {
+        self.requiredMenuContentVersion >= requiredMenuContentVersion &&
+            abs(self.menuWidth - menuWidth) <= 0.5 &&
+            self.codexAccountDisplay == codexAccountDisplay &&
+            self.tokenAccountDisplay == tokenAccountDisplay &&
+            self.localizationSignature == localizationSignature
+    }
+}
+
+struct MergedSwitcherContentCacheContext {
+    let menuWidth: CGFloat
+    let codexAccountDisplay: CodexAccountMenuDisplay?
+    let tokenAccountDisplay: TokenAccountMenuDisplay?
+    let contentVersion: Int?
+}
+
+extension StatusItemController {
+    func preservingMergedSwitcherContentCachesDuringInvalidation(_ body: () -> Void) {
+        let previous = self.preservesMergedSwitcherContentCachesDuringInvalidation
+        self.preservesMergedSwitcherContentCachesDuringInvalidation = true
+        defer { self.preservesMergedSwitcherContentCachesDuringInvalidation = previous }
+        body()
+    }
+
+    func clearMergedSwitcherContentCaches() {
+        self.mergedSwitcherContentCaches.removeAll(keepingCapacity: true)
+    }
+
+    func clearMergedSwitcherContentCache(for menu: NSMenu) {
+        self.mergedSwitcherContentCaches.removeValue(forKey: ObjectIdentifier(menu))
+    }
+
+    func cacheVisibleMergedSwitcherContent(
+        in menu: NSMenu,
+        selection: ProviderSwitcherSelection,
+        contentStartIndex: Int,
+        menuWidth: CGFloat,
+        contentVersion: Int? = nil)
+    {
+        guard self.shouldMergeIcons else { return }
+        guard menu.items.first?.view is ProviderSwitcherView else { return }
+        guard contentStartIndex < menu.items.count else { return }
+        let items = Array(menu.items[contentStartIndex...])
+        self.cacheMergedSwitcherContent(
+            items,
+            in: menu,
+            selection: selection,
+            context: MergedSwitcherContentCacheContext(
+                menuWidth: menuWidth,
+                codexAccountDisplay: self.lastCodexAccountMenuDisplay,
+                tokenAccountDisplay: self.lastTokenAccountMenuDisplay,
+                contentVersion: contentVersion))
+    }
+
+    func cacheMergedSwitcherContent(
+        _ items: [NSMenuItem],
+        in menu: NSMenu,
+        selection: ProviderSwitcherSelection,
+        context: MergedSwitcherContentCacheContext)
+    {
+        guard !items.isEmpty else { return }
+
+        let entry = CachedMergedSwitcherMenuContent(
+            requiredMenuContentVersion: context.contentVersion ??
+                self.menuSession.renderedVersion(for: ObjectIdentifier(menu)) ??
+                self.menuSession.latestRequiredRebuildVersion,
+            menuWidth: context.menuWidth,
+            codexAccountDisplay: context.codexAccountDisplay,
+            tokenAccountDisplay: context.tokenAccountDisplay,
+            localizationSignature: self.lastMenuLocalizationSignature,
+            items: items)
+        self.mergedSwitcherContentCaches[ObjectIdentifier(menu), default: [:]][selection] = entry
+    }
+
+    /// Returns a reusable cached content block, evicting stale entries without attaching them.
+    func reusableMergedSwitcherContent(
+        for selection: ProviderSwitcherSelection,
+        in menu: NSMenu,
+        menuWidth: CGFloat,
+        codexAccountDisplay: CodexAccountMenuDisplay?,
+        tokenAccountDisplay: TokenAccountMenuDisplay?)
+        -> [NSMenuItem]?
+    {
+        let key = ObjectIdentifier(menu)
+        guard let entry = self.mergedSwitcherContentCaches[key]?[selection] else { return nil }
+        guard entry.matches(
+            requiredMenuContentVersion: self.menuSession.latestRequiredRebuildVersion,
+            menuWidth: menuWidth,
+            codexAccountDisplay: codexAccountDisplay,
+            tokenAccountDisplay: tokenAccountDisplay,
+            localizationSignature: self.menuLocalizationSignature())
+        else {
+            self.mergedSwitcherContentCaches[key]?.removeValue(forKey: selection)
+            return nil
+        }
+        return entry.items
+    }
+
+    func addCachedMergedSwitcherContent(
+        for selection: ProviderSwitcherSelection,
+        to menu: NSMenu,
+        menuWidth: CGFloat,
+        codexAccountDisplay: CodexAccountMenuDisplay?,
+        tokenAccountDisplay: TokenAccountMenuDisplay?)
+        -> Bool
+    {
+        guard let items = self.reusableMergedSwitcherContent(
+            for: selection,
+            in: menu,
+            menuWidth: menuWidth,
+            codexAccountDisplay: codexAccountDisplay,
+            tokenAccountDisplay: tokenAccountDisplay)
+        else { return false }
+
+        self.lastCodexAccountMenuDisplay = codexAccountDisplay
+        self.lastTokenAccountMenuDisplay = tokenAccountDisplay
+        for item in items {
+            menu.addItem(item)
+        }
+        // Detached Refresh items cannot observe a completed manual refresh. Recompute only
+        // after AppKit has restored their menu so provider-scoped busy state is available.
+        self.updatePersistentRefreshItemsEnabled()
+        return true
+    }
+}
diff --git a/Sources/CodexBar/StatusItemController+OverviewScroll.swift b/Sources/CodexBar/StatusItemController+OverviewScroll.swift
new file mode 100644
index 0000000000..b8ab54281c
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+OverviewScroll.swift
@@ -0,0 +1,125 @@
+import AppKit
+
+enum OverviewScrollStep {
+    case up
+    case down
+}
+
+extension StatusItemController {
+    /// Pixel distance per highlight step for trackpads and other precise devices.
+    private static let preciseScrollStepThreshold: CGFloat = 24
+    /// Line distance per highlight step for classic scroll wheels.
+    private static let lineScrollStepThreshold: CGFloat = 0.9
+    /// A single fast flick should not race the highlight through the whole list.
+    private static let maxScrollStepsPerEvent = 3
+
+    /// Scrolling the wheel while the overview tab is open moves the row highlight up/down.
+    /// Steps are delivered as mouse-move events over the custom card views so AppKit's
+    /// native menu highlight and submenu behavior stay intact.
+    @discardableResult
+    func handleOverviewScrollWheel(_ event: NSEvent, menu: NSMenu) -> Bool {
+        guard self.menuHasOverviewRows(menu) else {
+            self.overviewScrollAccumulatedDelta = 0
+            return false
+        }
+        // Leave the wheel alone while a row submenu is open (e.g. scrollable charts);
+        // only the root overview list translates scrolling into highlight movement.
+        guard self.openMenus.count <= 1 else {
+            self.overviewScrollAccumulatedDelta = 0
+            return false
+        }
+        // Momentum-phase events after a flick would keep moving the highlight long after
+        // the fingers left the trackpad; swallow them without stepping.
+        guard event.momentumPhase.isEmpty else { return true }
+        let delta = event.scrollingDeltaY
+        guard delta != 0 else { return false }
+
+        if self.overviewScrollAccumulatedDelta != 0,
+           (delta > 0) != (self.overviewScrollAccumulatedDelta > 0)
+        {
+            self.overviewScrollAccumulatedDelta = 0
+        }
+        self.overviewScrollAccumulatedDelta += delta
+
+        let threshold = event.hasPreciseScrollingDeltas
+            ? Self.preciseScrollStepThreshold
+            : Self.lineScrollStepThreshold
+        var steps = 0
+        while abs(self.overviewScrollAccumulatedDelta) >= threshold, steps < Self.maxScrollStepsPerEvent {
+            let movingUp = self.overviewScrollAccumulatedDelta > 0
+            self.overviewScrollAccumulatedDelta += movingUp ? -threshold : threshold
+            self.postOverviewScrollNavigation(movingUp ? .up : .down, menu: menu)
+            steps += 1
+        }
+        // Discard the remainder once the cap is hit, otherwise the leftover delta from a
+        // fast flick would keep emitting capped batches on the next small scroll.
+        if steps == Self.maxScrollStepsPerEvent {
+            self.overviewScrollAccumulatedDelta = 0
+        }
+        return true
+    }
+
+    func menuHasOverviewRows(_ menu: NSMenu) -> Bool {
+        menu.items.contains { item in
+            (item.representedObject as? String)?.hasPrefix(Self.overviewRowIdentifierPrefix) == true
+        }
+    }
+
+    func resetOverviewScrollAccumulation() {
+        self.overviewScrollAccumulatedDelta = 0
+    }
+
+    private func postOverviewScrollNavigation(_ step: OverviewScrollStep, menu: NSMenu) {
+        if let handler = self.overviewScrollNavigationHandlerForTesting {
+            handler(step)
+            return
+        }
+        guard let target = self.overviewScrollTargetItem(in: menu, step: step) else { return }
+        let menuID = ObjectIdentifier(menu)
+        guard self.highlightedMenuItems[menuID] !== target else { return }
+
+        // Advance local state immediately so a capped multi-step flick can target successive rows
+        // before AppKit drains the synthetic mouse-move events.
+        self.menu(menu, willHighlight: target)
+
+        guard let view = target.view,
+              let window = view.window
+        else { return }
+        let location = view.convert(
+            NSPoint(x: view.bounds.midX, y: view.bounds.midY),
+            to: nil)
+        guard let event = NSEvent.mouseEvent(
+            with: .mouseMoved,
+            location: location,
+            modifierFlags: [],
+            timestamp: ProcessInfo.processInfo.systemUptime,
+            windowNumber: window.windowNumber,
+            context: nil,
+            eventNumber: 0,
+            clickCount: 0,
+            pressure: 0)
+        else { return }
+        NSApp.postEvent(event, atStart: false)
+    }
+
+    func overviewScrollTargetItem(in menu: NSMenu, step: OverviewScrollStep) -> NSMenuItem? {
+        let rows = menu.items.filter { item in
+            (item.representedObject as? String)?.hasPrefix(Self.overviewRowIdentifierPrefix) == true
+        }
+        guard !rows.isEmpty else { return nil }
+
+        guard let current = self.highlightedMenuItems[ObjectIdentifier(menu)],
+              let currentIndex = rows.firstIndex(where: { $0 === current })
+        else {
+            return step == .down ? rows.first : rows.last
+        }
+
+        let targetIndex: Int = switch step {
+        case .up:
+            max(0, currentIndex - 1)
+        case .down:
+            min(rows.count - 1, currentIndex + 1)
+        }
+        return rows[targetIndex]
+    }
+}
diff --git a/Sources/CodexBar/StatusItemController+OverviewSubmenus.swift b/Sources/CodexBar/StatusItemController+OverviewSubmenus.swift
new file mode 100644
index 0000000000..ef9a6667c7
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+OverviewSubmenus.swift
@@ -0,0 +1,60 @@
+import AppKit
+import CodexBarCore
+
+extension StatusItemController {
+    func makeOverviewRowSubmenu(
+        provider: UsageProvider,
+        model: UsageMenuCardView.Model,
+        width: CGFloat) -> NSMenu?
+    {
+        if provider == .openai,
+           let submenu = self.makeOpenAIAPIUsageSubmenu(provider: provider, width: width)
+        {
+            return submenu
+        }
+        if provider == .zai,
+           let submenu = self.makeZaiUsageDetailsSubmenu(snapshot: self.store.snapshot(for: provider))
+        {
+            return submenu
+        }
+        if model.tokenUsage != nil,
+           let submenu = self.makeCostHistorySubmenu(provider: provider, width: width)
+        {
+            return submenu
+        }
+        if let submenu = self.makeUsageHistorySubmenu(provider: provider, width: width) {
+            return submenu
+        }
+        return self.makeStorageBreakdownSubmenu(provider: provider, width: width)
+    }
+
+    @objc func selectOverviewProvider(_ sender: NSMenuItem) {
+        guard let represented = sender.representedObject as? String,
+              represented.hasPrefix(Self.overviewRowIdentifierPrefix)
+        else {
+            return
+        }
+        let rawProvider = String(represented.dropFirst(Self.overviewRowIdentifierPrefix.count))
+        guard let provider = UsageProvider(rawValue: rawProvider),
+              let menu = sender.menu
+        else {
+            return
+        }
+
+        self.selectOverviewProvider(provider, menu: menu)
+    }
+
+    func selectOverviewProvider(_ provider: UsageProvider, menu: NSMenu) {
+        if !self.settings.mergedMenuLastSelectedWasOverview, self.selectedMenuProvider == provider { return }
+        self.preservingMergedSwitcherContentCachesDuringInvalidation {
+            self.settings.mergedMenuLastSelectedWasOverview = false
+            self.lastMergedSwitcherSelection = .provider(provider)
+            self.selectedMenuProvider = provider
+            self.lastMenuProvider = provider
+            self.refreshProviderSelectionDependentUI(deferRendering: true)
+        }
+        // Custom-view clicks stay open and rebuild next turn. Standard menu-item activation can close;
+        // menuWillOpen then renders the saved provider without doing structural work inside the action.
+        self.requestProviderSwitcherMenuRebuild(menu, provider: provider)
+    }
+}
diff --git a/Sources/CodexBar/StatusItemController+PersistentMenuActions.swift b/Sources/CodexBar/StatusItemController+PersistentMenuActions.swift
new file mode 100644
index 0000000000..901f367b3f
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+PersistentMenuActions.swift
@@ -0,0 +1,40 @@
+import AppKit
+
+extension StatusItemController {
+    /// Updates persistent Refresh rows in place while their menus are tracking.
+    func updatePersistentRefreshItemsEnabled() {
+        for item in self.persistentRefreshItems.allObjects {
+            guard self.isPersistentRefreshItem(item) else {
+                self.persistentRefreshItems.remove(item)
+                continue
+            }
+            guard let menu = item.menu else { continue }
+            let enabled = !self.isRefreshActionInFlight(for: menu)
+            item.isEnabled = enabled
+        }
+    }
+
+    func isRefreshActionInFlight(for menu: NSMenu) -> Bool {
+        if self.manualRefreshTask != nil {
+            return true
+        }
+
+        if self.isMergedOverviewSelected(in: menu) {
+            // Overview refresh is global, so its busy state must mirror the global manual-refresh gate.
+            return self.store.isRefreshing || !self.store.refreshingProviders.isEmpty
+        }
+        if let provider = self.menuProvider(for: menu) {
+            return self.store.isRefreshing || self.store.refreshingProviders.contains(provider)
+        }
+        return self.store.isRefreshing || !self.store.refreshingProviders.isEmpty
+    }
+
+    func isMergedOverviewSelected(in menu: NSMenu) -> Bool {
+        guard self.shouldMergeIcons else { return false }
+        if let mergedMenu = self.mergedMenu, menu !== mergedMenu { return false }
+        let providers = self.settings.resolvedMergedOverviewProviders(
+            activeProviders: self.store.enabledProvidersForDisplay(),
+            maxVisibleProviders: SettingsStore.mergedOverviewProviderLimit)
+        return !providers.isEmpty && self.settings.mergedMenuLastSelectedWasOverview
+    }
+}
diff --git a/Sources/CodexBar/StatusItemController+ProviderNavigation.swift b/Sources/CodexBar/StatusItemController+ProviderNavigation.swift
new file mode 100644
index 0000000000..812d866cd7
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+ProviderNavigation.swift
@@ -0,0 +1,99 @@
+import AppKit
+import CodexBarCore
+
+extension StatusItemController {
+    func refreshProviderSelectionDependentUI(
+        refreshOpenMenus: Bool = false,
+        deferRendering: Bool = false)
+    {
+        #if DEBUG
+        guard !self.isReleasedForTesting else { return }
+        #endif
+        self.invalidateMenus(refreshOpenMenus: refreshOpenMenus)
+        if deferRendering {
+            self.scheduleProviderSelectionUIRefresh()
+            return
+        }
+        self.refreshProviderSelectionRendering()
+    }
+
+    private func scheduleProviderSelectionUIRefresh() {
+        self.providerSelectionUIRefreshTask?.cancel()
+        self.providerSelectionUIRefreshTask = Task { @MainActor [weak self] in
+            await Task.yield()
+            guard !Task.isCancelled, let self else { return }
+            self.refreshProviderSelectionRendering()
+            self.providerSelectionUIRefreshTask = nil
+        }
+    }
+
+    private func refreshProviderSelectionRendering() {
+        self.updateAnimationState()
+        self.updateBlinkingState()
+        let phase: Double? = self.needsMenuBarIconAnimation() ? self.animationPhase : nil
+        self.applyIcon(phase: phase)
+    }
+
+    func navigateProviderSwitcher(
+        _ direction: StatusItemMenuProviderNavigationDirection,
+        menu: NSMenu? = nil)
+    {
+        guard self.shouldMergeIcons else { return }
+        let enabledProviders = self.store.enabledProvidersForDisplay()
+        guard enabledProviders.count > 1 else { return }
+
+        let includesOverview = !self.settings.resolvedMergedOverviewProviders(
+            activeProviders: enabledProviders,
+            maxVisibleProviders: SettingsStore.mergedOverviewProviderLimit).isEmpty
+        var selections = enabledProviders.map(ProviderSwitcherSelection.provider)
+        if includesOverview {
+            selections.insert(.overview, at: 0)
+        }
+
+        let current: ProviderSwitcherSelection = if includesOverview,
+                                                    self.settings.mergedMenuLastSelectedWasOverview
+        {
+            .overview
+        } else {
+            .provider(self.navigationResolvedProvider(enabledProviders: enabledProviders) ?? .codex)
+        }
+        guard let currentIndex = selections.firstIndex(of: current) else { return }
+
+        let delta = direction == .next ? 1 : -1
+        let nextIndex = (currentIndex + delta + selections.count) % selections.count
+        let selection = selections[nextIndex]
+        let menuProvider: UsageProvider = switch selection {
+        case .overview:
+            self.navigationResolvedProvider(enabledProviders: enabledProviders) ?? .codex
+        case let .provider(provider):
+            provider
+        }
+        self.preservingMergedSwitcherContentCachesDuringInvalidation {
+            switch selection {
+            case .overview:
+                self.settings.mergedMenuLastSelectedWasOverview = true
+                self.lastMenuProvider = self.navigationResolvedProvider(enabledProviders: enabledProviders) ?? .codex
+            case let .provider(provider):
+                self.settings.mergedMenuLastSelectedWasOverview = false
+                self.selectedMenuProvider = provider
+                self.lastMenuProvider = provider
+            }
+            self.lastMergedSwitcherSelection = selection
+            self.refreshProviderSelectionDependentUI(deferRendering: true)
+        }
+        let trackedMenu = menu ?? self.providerSwitcherShortcutMenuID.flatMap { self.openMenus[$0] }
+        if let trackedMenu {
+            self.requestProviderSwitcherMenuRebuild(
+                trackedMenu,
+                provider: menuProvider)
+        }
+    }
+
+    private func navigationResolvedProvider(enabledProviders: [UsageProvider]) -> UsageProvider? {
+        if enabledProviders.isEmpty { return .codex }
+        if let selected = self.selectedMenuProvider, enabledProviders.contains(selected) {
+            return selected
+        }
+        return enabledProviders.first(where: { self.store.isProviderAvailable($0) }) ?? enabledProviders.first
+    }
+}
diff --git a/Sources/CodexBar/StatusItemController+ProviderSwitcher.swift b/Sources/CodexBar/StatusItemController+ProviderSwitcher.swift
new file mode 100644
index 0000000000..c304e748a3
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+ProviderSwitcher.swift
@@ -0,0 +1,361 @@
+import AppKit
+import CodexBarCore
+
+struct PendingProviderSwitcherRebuild {
+    let menu: NSMenu
+    let provider: UsageProvider?
+}
+
+/// Skips the event-queue peek on run-loop passes where no event of the monitored kinds
+/// can possibly be pending. The menu-tracking run loop spins on every mouse move, and the
+/// session-wide event counters for keys and clicks are far cheaper to read than
+/// `NSApp.nextEvent` is to call, so gating on them removes the per-pass peek cost from
+/// hover-heavy menu interaction (mouse moves never advance these counters).
+@MainActor
+final class ProviderSwitcherEventPeekGate {
+    private let eventTypes: [CGEventType]
+    private let counterProvider: (CGEventType) -> UInt32
+    private var lastCounters: [UInt32]?
+    private var heldKeyCodes: Set<UInt16> = []
+    private var emptyPeekBudget = 0
+
+    init(
+        eventTypes: [CGEventType],
+        counterProvider: @escaping (CGEventType) -> UInt32 = { type in
+            CGEventSource.counterForEventType(.combinedSessionState, eventType: type)
+        })
+    {
+        self.eventTypes = eventTypes
+        self.counterProvider = counterProvider
+    }
+
+    /// True when an event of a monitored kind may have been posted since the last check.
+    func shouldPeek() -> Bool {
+        let counters = self.eventTypes.map(self.counterProvider)
+        let countersChanged = self.lastCounters.map { counters != $0 } ?? true
+        self.lastCounters = counters
+        if countersChanged {
+            // The observer runs before run-loop sources. WindowServer can advance a counter
+            // one pass before AppKit queues the NSEvent, so require two empty peeks before
+            // considering the queue caught up.
+            self.emptyPeekBudget = max(self.emptyPeekBudget, 2)
+        }
+        // CoreGraphics does not count key autorepeat events. Keep peeking while a key is
+        // held so repeated provider-navigation events are still handled.
+        if !self.heldKeyCodes.isEmpty { return true }
+        return self.emptyPeekBudget > 0
+    }
+
+    func observe(_ event: NSEvent) {
+        // An unhandled event stays queued until AppKit processes it after this observer.
+        // Keep peeking until a later pass proves the matching queue is empty.
+        self.emptyPeekBudget = max(self.emptyPeekBudget, 1)
+        switch event.type {
+        case .keyDown:
+            self.heldKeyCodes.insert(event.keyCode)
+        case .keyUp:
+            self.heldKeyCodes.remove(event.keyCode)
+        default:
+            break
+        }
+    }
+
+    func observeQueueEmpty(afterFindingEvent: Bool) {
+        if afterFindingEvent {
+            // A counter snapshot can represent multiple events that AppKit delivers across
+            // run-loop passes. Keep one empty proof pending after draining available events.
+            self.emptyPeekBudget = max(self.emptyPeekBudget - 1, 1)
+        } else if self.emptyPeekBudget > 0 {
+            self.emptyPeekBudget -= 1
+        }
+    }
+}
+
+/// Handles provider-switcher keyboard shortcuts and overview scrolling while the merged
+/// status menu is open. `NSMenu` tracking pulls events itself, so local event monitors,
+/// Carbon dispatcher handlers, registered hot keys (tracking pushes a hotkey-disable mode),
+/// and `menuHasKeyEquivalent` never see these events — peeking the queue from a run-loop
+/// observer is the only delivery path.
+///
+/// The peek itself must not disturb the tracking session: `NSApp.nextEvent` re-enters the
+/// event loop in the mode it is given, and re-entering `.eventTracking` dispatches the menu
+/// session's own timers and sources mid-observer. When that landed during menu setup or amid
+/// rapid claimed key repeats, it killed the session and left a zombie menu on screen that no
+/// longer dequeued events: clicks sat in the queue for tens of seconds while the cursor
+/// beach-balled. Three guards prevent that: peeks run in a private run-loop mode with no
+/// sources or timers registered (the queue is mode-agnostic, so matching still works), the
+/// peek only starts once the tracking loop is confirmed pumping, and mouse clicks are not
+/// monitored at all (`ProviderSwitcherView` handles those via its own `mouseDown`/`mouseUp`
+/// overrides), so the monitor never dequeues a click meant for AppKit.
+@MainActor
+final class ProviderSwitcherShortcutEventMonitor {
+    private let callback: @MainActor (NSEvent) -> Bool
+    private let observer: CFRunLoopObserver
+    private let trackingState = ProviderSwitcherMenuTrackingState()
+    private var isActive = false
+
+    /// A run-loop mode nothing else registers sources or timers in, so running the loop in
+    /// this mode while polling the event queue cannot dispatch menu-session work re-entrantly.
+    private static let peekMode = RunLoop.Mode("com.steipete.codexbar.switcher-peek")
+
+    init(
+        events: NSEvent.EventTypeMask,
+        peekGate: ProviderSwitcherEventPeekGate = ProviderSwitcherEventPeekGate(
+            eventTypes: [.keyDown, .keyUp, .scrollWheel]),
+        callback: @escaping @MainActor (NSEvent) -> Bool)
+    {
+        self.callback = callback
+        let trackingState = self.trackingState
+
+        self.observer = CFRunLoopObserverCreateWithHandler(
+            nil,
+            CFRunLoopActivity.beforeSources.rawValue,
+            true,
+            0)
+        { [events, peekGate, callback, trackingState] _, _ in
+            MainActor.assumeIsolated {
+                guard trackingState.isTrackingActive else { return }
+                guard peekGate.shouldPeek() else { return }
+                var foundEvent = false
+                var blockedByUnhandledEvent = false
+                while let event = NSApp.nextEvent(
+                    matching: events,
+                    until: .distantPast,
+                    inMode: Self.peekMode,
+                    dequeue: false)
+                {
+                    foundEvent = true
+                    peekGate.observe(event)
+                    guard callback(event) else {
+                        blockedByUnhandledEvent = true
+                        break
+                    }
+                    _ = NSApp.nextEvent(
+                        matching: events,
+                        until: .distantPast,
+                        inMode: Self.peekMode,
+                        dequeue: true)
+                }
+                if !blockedByUnhandledEvent {
+                    peekGate.observeQueueEmpty(afterFindingEvent: foundEvent)
+                }
+            }
+        }
+    }
+
+    deinit {
+        MainActor.assumeIsolated {
+            self.stop()
+        }
+    }
+
+    func start() {
+        guard !self.isActive else { return }
+        CFRunLoopAddObserver(
+            RunLoop.main.getCFRunLoop(),
+            self.observer,
+            CFRunLoopMode(RunLoop.Mode.eventTracking.rawValue as CFString))
+        self.isActive = true
+        // The menus this monitors are shown via `popUpMenuPositioningItem`, which posts no
+        // NSMenu tracking notifications. Arm the gate from a block queued in the tracking
+        // run-loop mode instead: it can only execute once the menu's tracking session is alive
+        // and pumping the run loop, which keeps peeks away from menu setup.
+        let trackingState = self.trackingState
+        RunLoop.main.perform(inModes: [.eventTracking]) {
+            MainActor.assumeIsolated {
+                trackingState.isTrackingActive = true
+            }
+        }
+        CFRunLoopWakeUp(CFRunLoopGetMain())
+    }
+
+    func stop() {
+        self.trackingState.isTrackingActive = false
+        guard self.isActive else { return }
+        CFRunLoopRemoveObserver(
+            RunLoop.main.getCFRunLoop(),
+            self.observer,
+            CFRunLoopMode(RunLoop.Mode.eventTracking.rawValue as CFString))
+        self.isActive = false
+    }
+}
+
+/// Tracks whether an `NSMenu` tracking session is currently alive, so the shortcut monitor
+/// only touches the event queue while AppKit is actually pumping it.
+@MainActor
+private final class ProviderSwitcherMenuTrackingState {
+    var isTrackingActive = false
+}
+
+@MainActor
+private final class ProviderSwitcherTrackingRunLoopOperation {
+    private var operation: (@MainActor () -> Void)?
+
+    init(operation: @escaping @MainActor () -> Void) {
+        self.operation = operation
+    }
+
+    func run() {
+        guard let operation = self.operation else { return }
+        self.operation = nil
+        operation()
+    }
+}
+
+@MainActor
+enum ProviderSwitcherTrackingRunLoopScheduler {
+    static func schedule(_ operation: @escaping @MainActor () -> Void) {
+        let pending = ProviderSwitcherTrackingRunLoopOperation(operation: operation)
+        let runLoop = CFRunLoopGetMain()
+        // Main-actor tasks can starve while AppKit owns the modal menu loop. Queue in both modes so the
+        // rebuild runs during tracking, with the default mode as a fallback if tracking ends first.
+        let modes = [
+            RunLoop.Mode.eventTracking.rawValue,
+            RunLoop.Mode.default.rawValue,
+        ]
+        for mode in modes {
+            CFRunLoopPerformBlock(runLoop, mode as CFString) {
+                MainActor.assumeIsolated {
+                    pending.run()
+                }
+            }
+        }
+        CFRunLoopWakeUp(runLoop)
+    }
+}
+
+extension StatusItemController {
+    func installProviderSwitcherShortcutMonitorIfNeeded(for menu: NSMenu) {
+        guard self.isMenuRefreshEnabled,
+              self.shouldMergeIcons,
+              menu.items.first?.view is ProviderSwitcherView
+        else {
+            return
+        }
+
+        self.removeProviderSwitcherShortcutMonitor()
+        self.resetOverviewScrollAccumulation()
+        let monitor = ProviderSwitcherShortcutEventMonitor(
+            events: [.keyDown, .keyUp, .scrollWheel])
+        { [weak self, weak menu] event in
+            guard let self,
+                  let menu,
+                  self.openMenus[ObjectIdentifier(menu)] != nil,
+                  menu.items.first?.view is ProviderSwitcherView
+            else {
+                return false
+            }
+
+            return self.handleProviderSwitcherTrackingEvent(event, menu: menu)
+        }
+        monitor.start()
+        self.providerSwitcherShortcutEventMonitor = monitor
+        self.providerSwitcherShortcutMenuID = ObjectIdentifier(menu)
+    }
+
+    func removeProviderSwitcherShortcutMonitor() {
+        self.providerSwitcherShortcutEventMonitor?.stop()
+        self.providerSwitcherShortcutEventMonitor = nil
+        self.providerSwitcherShortcutMenuID = nil
+        self.clearProviderSwitcherPointerInteraction()
+    }
+
+    func providerSwitcherContentStartIndex(in menu: NSMenu) -> Int {
+        menu.items.first?.view is ProviderSwitcherView ? 2 : 0
+    }
+
+    @discardableResult
+    func handleProviderSwitcherShortcut(_ event: NSEvent, menu: NSMenu) -> Bool {
+        if let index = StatusItemMenu.providerSelectionIndex(for: event) {
+            return self.selectProviderSwitcherSegment(at: index, menu: menu)
+        }
+        if let direction = StatusItemMenu.providerNavigationDirection(for: event) {
+            self.navigateProviderSwitcher(direction, menu: menu)
+            return true
+        }
+        return false
+    }
+
+    @discardableResult
+    func handleProviderSwitcherTrackingEvent(_ event: NSEvent, menu: NSMenu) -> Bool {
+        switch event.type {
+        case .keyDown:
+            return self.handleProviderSwitcherShortcut(event, menu: menu)
+        case .leftMouseDown:
+            guard let switcher = menu.items.first?.view as? ProviderSwitcherView else { return false }
+            self.beginProviderSwitcherPointerInteraction(in: menu)
+            let handled = switcher.handleMenuTrackingMouseDown(event)
+            if !handled {
+                self.clearProviderSwitcherPointerInteraction(in: menu)
+            }
+            return handled
+        case .leftMouseUp:
+            guard self.providerSwitcherPointerInteractionMenuID == ObjectIdentifier(menu) else {
+                return false
+            }
+            guard let switcher = menu.items.first?.view as? ProviderSwitcherView else {
+                self.clearProviderSwitcherPointerInteraction(in: menu)
+                return true
+            }
+            _ = switcher.handleMenuTrackingMouseUp(event)
+            self.finishProviderSwitcherPointerInteraction(in: menu)
+            return true
+        case .scrollWheel:
+            return self.handleOverviewScrollWheel(event, menu: menu)
+        default:
+            return false
+        }
+    }
+
+    func requestProviderSwitcherMenuRebuild(_ menu: NSMenu, provider: UsageProvider?) {
+        guard self.providerSwitcherPointerInteractionMenuID == ObjectIdentifier(menu) else {
+            self.deferSwitcherMenuRebuildIfStillVisible(menu, provider: provider)
+            return
+        }
+        self.pendingProviderSwitcherPointerRebuild = PendingProviderSwitcherRebuild(
+            menu: menu,
+            provider: provider)
+    }
+
+    private func beginProviderSwitcherPointerInteraction(in menu: NSMenu) {
+        let menuID = ObjectIdentifier(menu)
+        if self.providerSwitcherPointerInteractionMenuID != menuID {
+            self.pendingProviderSwitcherPointerRebuild = nil
+        }
+        self.providerSwitcherPointerInteractionMenuID = menuID
+    }
+
+    private func finishProviderSwitcherPointerInteraction(in menu: NSMenu) {
+        let menuID = ObjectIdentifier(menu)
+        guard self.providerSwitcherPointerInteractionMenuID == menuID else { return }
+        self.providerSwitcherPointerInteractionMenuID = nil
+        guard let pending = self.pendingProviderSwitcherPointerRebuild,
+              pending.menu === menu
+        else {
+            self.pendingProviderSwitcherPointerRebuild = nil
+            return
+        }
+        self.pendingProviderSwitcherPointerRebuild = nil
+        self.deferSwitcherMenuRebuildIfStillVisible(menu, provider: pending.provider)
+    }
+
+    private func clearProviderSwitcherPointerInteraction(in menu: NSMenu? = nil) {
+        if let menu,
+           self.providerSwitcherPointerInteractionMenuID != ObjectIdentifier(menu)
+        {
+            return
+        }
+        self.providerSwitcherPointerInteractionMenuID = nil
+        self.pendingProviderSwitcherPointerRebuild = nil
+    }
+
+    @discardableResult
+    private func selectProviderSwitcherSegment(at index: Int, menu: NSMenu) -> Bool {
+        guard let switcherView = menu.items.first?.view as? ProviderSwitcherView,
+              switcherView.handleKeyboardSelection(at: index)
+        else {
+            return false
+        }
+        return true
+    }
+}
diff --git a/Sources/CodexBar/StatusItemController+Shutdown.swift b/Sources/CodexBar/StatusItemController+Shutdown.swift
new file mode 100644
index 0000000000..e7b7a0b664
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+Shutdown.swift
@@ -0,0 +1,109 @@
+import AppKit
+
+extension StatusItemController {
+    func prepareForAppShutdown() {
+        guard !self.hasPreparedForAppShutdown else { return }
+        self.hasPreparedForAppShutdown = true
+        #if DEBUG
+        self.isReleasedForTesting = true
+        #endif
+
+        let openMenus = Array(self.openMenus.values)
+        for menu in openMenus {
+            menu.cancelTrackingWithoutAnimation()
+            self.forgetClosedMenu(menu)
+        }
+
+        self.cancelShutdownTasks()
+        self.clearShutdownMenuState()
+        self.removeShutdownStatusItems()
+        self.creditsPurchaseWindow?.close()
+        self.creditsPurchaseWindow = nil
+    }
+
+    private func cancelShutdownTasks() {
+        self.blinkTask?.cancel()
+        self.blinkTask = nil
+        self.menuBarCountdownRefreshTask?.cancel()
+        self.menuBarCountdownRefreshTask = nil
+        self.loginTask?.cancel()
+        self.loginTask = nil
+        self.manualRefreshTask?.cancel()
+        self.manualRefreshTask = nil
+        self.manualRefreshProvider = nil
+        self.menuCardRefreshMonitor.endManualRefresh()
+        self.screenChangeVisibilityTask?.cancel()
+        self.screenChangeVisibilityTask = nil
+        self.pendingScreenChangePreviousCount = nil
+        self.animationDriver?.stop()
+        self.animationDriver = nil
+        self.animationPhase = 0
+        self.blinkForceUntil = nil
+        self.blinkStates.removeAll(keepingCapacity: false)
+        self.blinkAmounts.removeAll(keepingCapacity: false)
+        self.wiggleAmounts.removeAll(keepingCapacity: false)
+        self.tiltAmounts.removeAll(keepingCapacity: false)
+        self.quotaWarningFlashUntil.removeAll(keepingCapacity: false)
+        for task in self.quotaWarningFlashTasks.values {
+            task.cancel()
+        }
+        self.quotaWarningFlashTasks.removeAll(keepingCapacity: false)
+
+        for task in self.menuRefreshTasks.values {
+            task.cancel()
+        }
+        self.cancelAllClosedMenuRebuilds()
+        for task in self.openMenuRebuildTasks.values {
+            task.cancel()
+        }
+        self.openMenuInvalidationRetryTask?.cancel()
+        self.openMenuInvalidationRetryTask = nil
+        self.codexAccountMenuProjectionRevalidationTask?.cancel()
+        self.codexAccountMenuProjectionRevalidationTask = nil
+        self.providerSelectionUIRefreshTask?.cancel()
+        self.providerSelectionUIRefreshTask = nil
+        self.deferredMergedIconRenderAfterTracking = false
+        self.providerSwitcherPointerInteractionMenuID = nil
+        self.pendingProviderSwitcherPointerRebuild = nil
+    }
+
+    private func clearShutdownMenuState() {
+        self.removeProviderSwitcherShortcutMonitor()
+        self.menuRefreshTasks.removeAll(keepingCapacity: false)
+        self.closedMenuRebuildTasks.removeAll(keepingCapacity: false)
+        self.closedMenuRebuildRequests.cancelAll()
+        self.openMenuRebuildTasks.removeAll(keepingCapacity: false)
+        self.openMenuRebuildRequests.cancelAll()
+        self.openMenuRebuildsClosingHostedSubviewMenus.removeAll(keepingCapacity: false)
+        self.menuSession.clearMenuTracking()
+        self.openMenus.removeAll(keepingCapacity: false)
+        self.highlightedMenuItems.removeAll(keepingCapacity: false)
+        self.menuCardHeightCache.removeAll(keepingCapacity: false)
+        self.measuredStandardMenuWidthCache.removeAll(keepingCapacity: false)
+        self.mergedSwitcherContentCaches.removeAll(keepingCapacity: false)
+        self.menuProviders.removeAll(keepingCapacity: false)
+        self.menuReadinessSignatures.removeAll(keepingCapacity: false)
+        self.menuIdentitySignatures.removeAll(keepingCapacity: false)
+        self.providerMenus.removeAll(keepingCapacity: false)
+        self.mergedMenu = nil
+        self.fallbackMenu = nil
+    }
+
+    private func removeShutdownStatusItems() {
+        self.statusItem.menu = nil
+        self.statusBar.removeStatusItem(self.statusItem)
+
+        for item in self.statusItems.values {
+            item.menu = nil
+            self.statusBar.removeStatusItem(item)
+        }
+        self.statusItems.removeAll(keepingCapacity: false)
+        self.lastAppliedProviderIconRenderSignatures.removeAll(keepingCapacity: false)
+    }
+
+    #if DEBUG
+    func releaseStatusItemsForTesting() {
+        self.prepareForAppShutdown()
+    }
+    #endif
+}
diff --git a/Sources/CodexBar/StatusItemController+SwitcherMetrics.swift b/Sources/CodexBar/StatusItemController+SwitcherMetrics.swift
new file mode 100644
index 0000000000..d078111143
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+SwitcherMetrics.swift
@@ -0,0 +1,13 @@
+import CodexBarCore
+
+extension StatusItemController {
+    nonisolated static func switcherWeeklyMetricPercent(
+        for provider: UsageProvider,
+        snapshot: UsageSnapshot?,
+        showUsed: Bool) -> Double?
+    {
+        let window = snapshot?.switcherWeeklyWindow(for: provider, showUsed: showUsed)
+        guard let window else { return nil }
+        return showUsed ? window.usedPercent : window.remainingPercent
+    }
+}
diff --git a/Sources/CodexBar/StatusItemController+SwitcherViews.swift b/Sources/CodexBar/StatusItemController+SwitcherViews.swift
index 92c334231a..9bcef6a293 100644
--- a/Sources/CodexBar/StatusItemController+SwitcherViews.swift
+++ b/Sources/CodexBar/StatusItemController+SwitcherViews.swift
@@ -1,7 +1,8 @@
 import AppKit
 import CodexBarCore
+import QuartzCore
 
-enum ProviderSwitcherSelection: Equatable {
+enum ProviderSwitcherSelection: Hashable {
     case overview
     case provider(UsageProvider)
 }
@@ -13,9 +14,11 @@ final class ProviderSwitcherView: NSView {
         let title: String
     }
 
-    private struct WeeklyIndicator {
+    fileprivate struct QuotaIndicator {
         let track: NSView
         let fill: NSView
+        var fillWidthConstraint: NSLayoutConstraint
+        var fillRatio: CGFloat
     }
 
     private let segments: [Segment]
@@ -23,7 +26,7 @@ final class ProviderSwitcherView: NSView {
     private let showsIcons: Bool
     private let weeklyRemainingProvider: (UsageProvider) -> Double?
     private var buttons: [NSButton] = []
-    private var weeklyIndicators: [ObjectIdentifier: WeeklyIndicator] = [:]
+    private var quotaIndicators: [ObjectIdentifier: QuotaIndicator] = [:]
     private var hoverTrackingArea: NSTrackingArea?
     private var segmentWidths: [CGFloat] = []
     private let selectedBackground = NSColor.controlAccentColor.cgColor
@@ -36,7 +39,11 @@ final class ProviderSwitcherView: NSView {
     private let rowHeight: CGFloat
     private var preferredWidth: CGFloat = 0
     private var hoveredButtonTag: Int?
-    private let lightModeOverlayLayer = CALayer()
+    private var pressedButtonTag: Int?
+    private var selectedSegmentIndex: Int?
+    private static let quotaIndicatorHeight: CGFloat = 2
+    private static let quotaIndicatorBottomInset: CGFloat = 2
+    private static let quotaIndicatorHorizontalInset: CGFloat = 8
 
     init(
         providers: [UsageProvider],
@@ -68,7 +75,7 @@ final class ProviderSwitcherView: NSView {
                 Segment(
                     selection: .overview,
                     image: overviewIcon,
-                    title: "Overview"),
+                    title: L("Overview")),
                 at: 0)
         }
         self.segments = segments
@@ -91,11 +98,7 @@ final class ProviderSwitcherView: NSView {
             maxAllowedSegmentWidth: initialMaxAllowedSegmentWidth,
             stackedIcons: self.stackedIcons)
         self.rowSpacing = self.stackedIcons ? 4 : 2
-        if self.stackedIcons && self.rowCount >= 3 {
-            self.rowHeight = 40
-        } else {
-            self.rowHeight = self.stackedIcons ? 36 : 30
-        }
+        self.rowHeight = Self.switcherButtonHeight(stackedIcons: self.stackedIcons, rowCount: self.rowCount)
         let height: CGFloat = self.rowHeight * CGFloat(self.rowCount)
             + self.rowSpacing * CGFloat(max(0, self.rowCount - 1))
         self.preferredWidth = width
@@ -103,20 +106,6 @@ final class ProviderSwitcherView: NSView {
         Self.clearButtonWidthCache()
         self.wantsLayer = true
         self.layer?.masksToBounds = false
-        self.lightModeOverlayLayer.masksToBounds = false
-        self.layer?.insertSublayer(self.lightModeOverlayLayer, at: 0)
-        self.updateLightModeStyling()
-
-        let layoutCount = Self.layoutCount(for: self.segments.count, rows: self.rowCount)
-        let outerPadding: CGFloat = Self.switcherOuterPadding(
-            for: width,
-            count: layoutCount,
-            minimumGap: minimumGap)
-        let maxAllowedSegmentWidth = Self.maxAllowedUniformSegmentWidth(
-            for: width,
-            count: layoutCount,
-            outerPadding: outerPadding,
-            minimumGap: minimumGap)
 
         func makeButton(index: Int, segment: Segment) -> NSButton {
             let button: NSButton
@@ -156,13 +145,6 @@ final class ProviderSwitcherView: NSView {
                 button.imagePosition = .noImage
             }
 
-            let remaining: Double? = switch segment.selection {
-            case let .provider(provider):
-                self.weeklyRemainingProvider(provider)
-            case .overview:
-                nil
-            }
-            self.addWeeklyIndicator(to: button, selection: segment.selection, remainingPercent: remaining)
             button.bezelStyle = .regularSquare
             button.isBordered = false
             button.controlSize = .small
@@ -175,6 +157,7 @@ final class ProviderSwitcherView: NSView {
             button.state = (selected == segment.selection) ? .on : .off
             button.toolTip = nil
             button.translatesAutoresizingMaskIntoConstraints = false
+            button.heightAnchor.constraint(equalToConstant: self.rowHeight).isActive = true
             self.buttons.append(button)
             return button
         }
@@ -182,24 +165,41 @@ final class ProviderSwitcherView: NSView {
         for (index, segment) in self.segments.enumerated() {
             let button = makeButton(index: index, segment: segment)
             self.addSubview(button)
+            self.addQuotaIndicator(
+                to: button,
+                selection: segment.selection,
+                remainingPercent: self.remainingPercent(for: segment.selection))
+        }
+        self.selectedSegmentIndex = selected.flatMap { selected in
+            self.segments.firstIndex { $0.selection == selected }
         }
 
+        let layoutCount = Self.layoutCount(for: self.segments.count, rows: self.rowCount)
+        let requiredUniformWidth = self.stackedIcons
+            ? nil
+            : self.buttons.map(Self.maxToggleWidth(for:)).max()
+        let layoutMetrics = Self.switcherLayoutMetrics(
+            for: width,
+            count: layoutCount,
+            minimumGap: minimumGap,
+            requiredSegmentWidth: requiredUniformWidth)
+
         let uniformWidth: CGFloat
         if self.rowCount > 1 || !self.stackedIcons {
-            uniformWidth = self.applyUniformSegmentWidth(maxAllowedWidth: maxAllowedSegmentWidth)
+            uniformWidth = self.applyUniformSegmentWidth(maxAllowedWidth: layoutMetrics.maxAllowedSegmentWidth)
             if uniformWidth > 0 {
                 self.segmentWidths = Array(repeating: uniformWidth, count: self.buttons.count)
             }
         } else {
             self.segmentWidths = self.applyNonUniformSegmentWidths(
                 totalWidth: width,
-                outerPadding: outerPadding,
+                outerPadding: layoutMetrics.outerPadding,
                 minimumGap: minimumGap)
             uniformWidth = 0
         }
 
         self.applyLayout(
-            outerPadding: outerPadding,
+            outerPadding: layoutMetrics.outerPadding,
             minimumGap: minimumGap,
             uniformWidth: uniformWidth)
         if width > 0 {
@@ -210,20 +210,19 @@ final class ProviderSwitcherView: NSView {
         self.updateButtonStyles()
     }
 
-    override func layout() {
-        super.layout()
-        self.lightModeOverlayLayer.frame = self.bounds
-    }
-
     override func viewDidChangeEffectiveAppearance() {
         super.viewDidChangeEffectiveAppearance()
-        self.updateLightModeStyling()
         self.updateButtonStyles()
     }
 
     override func viewDidMoveToWindow() {
         super.viewDidMoveToWindow()
-        self.window?.acceptsMouseMovedEvents = true
+        if let window = self.window {
+            window.acceptsMouseMovedEvents = true
+        } else if self.hoveredButtonTag != nil {
+            self.hoveredButtonTag = nil
+            self.updateButtonStyles()
+        }
     }
 
     override func updateTrackingAreas() {
@@ -249,7 +248,7 @@ final class ProviderSwitcherView: NSView {
 
     override func mouseMoved(with event: NSEvent) {
         let location = self.convert(event.locationInWindow, from: nil)
-        let hoveredTag = self.buttons.first(where: { $0.frame.contains(location) })?.tag
+        let hoveredTag = self.button(at: location)?.tag
         guard hoveredTag != self.hoveredButtonTag else { return }
         self.hoveredButtonTag = hoveredTag
         self.updateButtonStyles()
@@ -261,6 +260,91 @@ final class ProviderSwitcherView: NSView {
         self.updateButtonStyles()
     }
 
+    // MARK: - Click handling
+
+    override func acceptsFirstMouse(for event: NSEvent?) -> Bool {
+        // NSMenu's tracking run loop occasionally drops NSButton target-action dispatch when the
+        // menu is rebuilt under the cursor (e.g. after switching back from a provider tab to
+        // Overview). The overrides in this section hit-test the parent view, then drive
+        // selection from mouseDown/mouseUp here so the click never has to round-trip through
+        // NSButton's tracking loop. See issue #867.
+        true
+    }
+
+    override func hitTest(_ point: NSPoint) -> NSView? {
+        let descendant = super.hitTest(point)
+        if descendant != nil, descendant !== self {
+            // Swallow any hit on a child NSButton so its tracking loop never sees the click.
+            return self
+        }
+        return descendant
+    }
+
+    override func mouseDown(with event: NSEvent) {
+        _ = self.handleMenuTrackingMouseDown(event)
+    }
+
+    override func mouseUp(with event: NSEvent) {
+        _ = self.handleMenuTrackingMouseUp(event)
+    }
+
+    @discardableResult
+    func handleMenuTrackingMouseDown(_ event: NSEvent) -> Bool {
+        guard event.type == .leftMouseDown else { return false }
+        let location = self.locationInView(for: event)
+        guard let pressedTag = self.button(at: location)?.tag,
+              self.segments.indices.contains(pressedTag)
+        else {
+            return false
+        }
+        self.pressedButtonTag = pressedTag
+        return true
+    }
+
+    @discardableResult
+    func handleMenuTrackingMouseUp(_ event: NSEvent) -> Bool {
+        guard event.type == .leftMouseUp else { return false }
+        defer { self.pressedButtonTag = nil }
+        guard let pressedTag = self.pressedButtonTag else { return false }
+        let location = self.locationInView(for: event)
+        guard let releasedTag = self.button(at: location)?.tag,
+              releasedTag == pressedTag
+        else {
+            return true
+        }
+        // Commit only after the matching release. The controller schedules structural menu
+        // replacement after this callback returns so AppKit can finish the tracking transaction.
+        self.applySelection(at: pressedTag)
+        return true
+    }
+
+    private func locationInView(for event: NSEvent) -> NSPoint {
+        guard let eventWindow = event.window,
+              let viewWindow = self.window,
+              eventWindow !== viewWindow
+        else {
+            return self.convert(event.locationInWindow, from: nil)
+        }
+        let screenLocation = eventWindow.convertPoint(toScreen: event.locationInWindow)
+        return self.convert(viewWindow.convertPoint(fromScreen: screenLocation), from: nil)
+    }
+
+    func handleKeyboardSelection(at index: Int) -> Bool {
+        guard self.segments.indices.contains(index) else { return false }
+        self.applySelection(at: index)
+        return true
+    }
+
+    private func applySelection(at index: Int) {
+        let selection = self.segments[index].selection
+        guard self.selectedSegmentIndex != index else {
+            self.updateSelection(selection)
+            return
+        }
+        self.updateSelection(selection)
+        self.onSelect(selection)
+    }
+
     private func applyLayout(
         outerPadding: CGFloat,
         minimumGap: CGFloat,
@@ -479,7 +563,17 @@ final class ProviderSwitcherView: NSView {
         return rows
     }
 
-    private static func switcherOuterPadding(for width: CGFloat, count: Int, minimumGap: CGFloat) -> CGFloat {
+    private static func switcherButtonHeight(stackedIcons: Bool, rowCount: Int) -> CGFloat {
+        guard stackedIcons else { return 30 }
+        return rowCount >= 3 ? 39 : 36
+    }
+
+    private static func switcherOuterPadding(
+        for width: CGFloat,
+        count: Int,
+        minimumGap: CGFloat,
+        requiredSegmentWidth: CGFloat? = nil) -> CGFloat
+    {
         // Align with the card's left/right content grid when possible.
         let preferred: CGFloat = 16
         let reduced: CGFloat = 10
@@ -494,8 +588,27 @@ final class ProviderSwitcherView: NSView {
         // Only sacrifice padding when we'd otherwise squeeze buttons into unreadable widths.
         let minimumComfortableAverage: CGFloat = count >= 5 ? 50 : 54
 
-        if averageButtonWidth(outerPadding: preferred) >= minimumComfortableAverage { return preferred }
-        if averageButtonWidth(outerPadding: reduced) >= minimumComfortableAverage { return reduced }
+        func fits(outerPadding: CGFloat) -> Bool {
+            if let requiredSegmentWidth {
+                let allowedWidth = self.maxAllowedUniformSegmentWidth(
+                    for: width,
+                    count: count,
+                    outerPadding: outerPadding,
+                    minimumGap: minimumGap)
+                let evenAllowedWidth = allowedWidth.truncatingRemainder(dividingBy: 2) == 0
+                    ? allowedWidth
+                    : allowedWidth - 1
+                let desiredWidth = ceil(requiredSegmentWidth)
+                let evenDesiredWidth = desiredWidth.truncatingRemainder(dividingBy: 2) == 0
+                    ? desiredWidth
+                    : desiredWidth + 1
+                return evenAllowedWidth >= evenDesiredWidth
+            }
+            return averageButtonWidth(outerPadding: outerPadding) >= minimumComfortableAverage
+        }
+
+        if fits(outerPadding: preferred) { return preferred }
+        if fits(outerPadding: reduced) { return reduced }
         return minimal
     }
 
@@ -508,17 +621,71 @@ final class ProviderSwitcherView: NSView {
         NSSize(width: self.preferredWidth, height: self.frame.size.height)
     }
 
+    func updateSelection(_ selection: ProviderSwitcherSelection) {
+        var selectedIndex: Int?
+        for (index, button) in self.buttons.enumerated() {
+            let isSelected = self.segments.indices.contains(index) && self.segments[index].selection == selection
+            if isSelected {
+                selectedIndex = index
+            }
+            button.state = isSelected ? .on : .off
+        }
+        self.selectedSegmentIndex = selectedIndex
+        self.updateButtonStyles()
+    }
+
+    func updateQuotaIndicators() {
+        CATransaction.begin()
+        CATransaction.setDisableActions(true)
+        defer { CATransaction.commit() }
+
+        for (index, button) in self.buttons.enumerated() {
+            guard self.segments.indices.contains(index) else { continue }
+            let segment = self.segments[index]
+            let remaining = self.remainingPercent(for: segment.selection)
+
+            let key = ObjectIdentifier(button)
+            if let remaining {
+                if var indicator = self.quotaIndicators[key] {
+                    let newRatio = Self.quotaIndicatorRatio(remainingPercent: remaining)
+                    if newRatio != indicator.fillRatio {
+                        Self.updateQuotaIndicatorFill(
+                            indicator: &indicator,
+                            remainingPercent: remaining,
+                            selection: segment.selection)
+                        self.quotaIndicators[key] = indicator
+                    }
+                } else {
+                    self.addQuotaIndicator(to: button, selection: segment.selection, remainingPercent: remaining)
+                }
+            } else if let indicator = self.quotaIndicators.removeValue(forKey: key) {
+                indicator.track.removeFromSuperview()
+                continue
+            }
+            self.updateQuotaIndicatorVisibility(for: button)
+        }
+    }
+
+    private func remainingPercent(for selection: ProviderSwitcherSelection) -> Double? {
+        switch selection {
+        case let .provider(provider):
+            self.weeklyRemainingProvider(provider)
+        case .overview:
+            nil
+        }
+    }
+
     @objc private func handleSelection(_ sender: NSButton) {
         let index = sender.tag
         guard self.segments.indices.contains(index) else { return }
-        for (idx, button) in self.buttons.enumerated() {
-            button.state = (idx == index) ? .on : .off
-        }
-        self.updateButtonStyles()
-        self.onSelect(self.segments[index].selection)
+        self.applySelection(at: index)
     }
 
     private func updateButtonStyles() {
+        CATransaction.begin()
+        CATransaction.setDisableActions(true)
+        defer { CATransaction.commit() }
+
         for button in self.buttons {
             let isSelected = button.state == .on
             let isHovered = self.hoveredButtonTag == button.tag
@@ -530,7 +697,7 @@ final class ProviderSwitcherView: NSView {
             } else {
                 self.unselectedBackground
             }
-            self.updateWeeklyIndicatorVisibility(for: button)
+            self.updateQuotaIndicatorVisibility(for: button)
             (button as? StackedToggleButton)?.setContentTintColor(button.contentTintColor)
             (button as? InlineIconToggleButton)?.setContentTintColor(button.contentTintColor)
         }
@@ -540,15 +707,6 @@ final class ProviderSwitcherView: NSView {
         self.effectiveAppearance.bestMatch(from: [.aqua, .darkAqua]) == .aqua
     }
 
-    private func updateLightModeStyling() {
-        guard self.isLightMode() else {
-            self.lightModeOverlayLayer.backgroundColor = nil
-            return
-        }
-        // The menu card background is very bright in light mode; add a subtle neutral wash to ground the switcher.
-        self.lightModeOverlayLayer.backgroundColor = NSColor.black.withAlphaComponent(0.035).cgColor
-    }
-
     private func hoverPlateColor() -> CGColor {
         if self.isLightMode() {
             return NSColor.black.withAlphaComponent(0.095).cgColor
@@ -727,50 +885,265 @@ final class ProviderSwitcherView: NSView {
         return newImage
     }
 
-    private func addWeeklyIndicator(to view: NSView, selection: ProviderSwitcherSelection, remainingPercent: Double?) {
+    private static func overviewIcon() -> NSImage {
+        if let symbol = NSImage(systemSymbolName: "square.grid.2x2", accessibilityDescription: nil) {
+            return symbol
+        }
+        return NSImage(size: NSSize(width: 16, height: 16))
+    }
+
+    private static func switcherTitle(for provider: UsageProvider) -> String {
+        ProviderDescriptorRegistry.descriptor(for: provider).metadata.displayName
+    }
+}
+
+extension ProviderSwitcherView {
+    private static func switcherLayoutMetrics(
+        for width: CGFloat,
+        count: Int,
+        minimumGap: CGFloat,
+        requiredSegmentWidth: CGFloat?) -> (outerPadding: CGFloat, maxAllowedSegmentWidth: CGFloat)
+    {
+        let outerPadding = self.switcherOuterPadding(
+            for: width,
+            count: count,
+            minimumGap: minimumGap,
+            requiredSegmentWidth: requiredSegmentWidth)
+        let maxAllowedSegmentWidth = self.maxAllowedUniformSegmentWidth(
+            for: width,
+            count: count,
+            outerPadding: outerPadding,
+            minimumGap: minimumGap)
+        return (outerPadding, maxAllowedSegmentWidth)
+    }
+}
+
+extension ProviderSwitcherView {
+    fileprivate func button(at location: NSPoint) -> NSButton? {
+        self.buttons.first { $0.frame.contains(location) }
+    }
+}
+
+#if DEBUG
+extension ProviderSwitcherView {
+    func _test_mouseDownEvent(buttonTag: Int) -> NSEvent? {
+        self._test_mouseEvent(buttonTag: buttonTag, type: .leftMouseDown)
+    }
+
+    func _test_mouseUpEvent(buttonTag: Int) -> NSEvent? {
+        self._test_mouseEvent(buttonTag: buttonTag, type: .leftMouseUp)
+    }
+
+    func _test_quotaIndicatorMouseEvent(buttonTag: Int, type: NSEvent.EventType) -> NSEvent? {
+        guard let button = self.buttons.first(where: { $0.tag == buttonTag }),
+              let track = self.quotaIndicators[ObjectIdentifier(button)]?.track
+        else {
+            return nil
+        }
+        self.updateConstraintsForSubtreeIfNeeded()
+        self.layoutSubtreeIfNeeded()
+        let point = self.convert(NSPoint(x: track.bounds.midX, y: track.bounds.midY), from: track)
+        return self._test_mouseEvent(at: point, type: type)
+    }
+
+    private func _test_mouseEvent(buttonTag: Int, type: NSEvent.EventType) -> NSEvent? {
+        guard let button = self.buttons.first(where: { $0.tag == buttonTag }) else { return nil }
+        self.updateConstraintsForSubtreeIfNeeded()
+        self.layoutSubtreeIfNeeded()
+        let point = self.convert(NSPoint(x: button.bounds.midX, y: button.bounds.midY), from: button)
+        return self._test_mouseEvent(at: point, type: type)
+    }
+
+    private func _test_mouseEvent(at point: NSPoint, type: NSEvent.EventType) -> NSEvent? {
+        NSEvent.mouseEvent(
+            with: type,
+            location: point,
+            modifierFlags: [],
+            timestamp: 0,
+            windowNumber: 0,
+            context: nil,
+            eventNumber: type == .leftMouseDown ? 1 : 2,
+            clickCount: 1,
+            pressure: type == .leftMouseDown ? 1 : 0)
+    }
+
+    @discardableResult
+    func _test_simulateMouseDown(buttonTag: Int) -> Bool {
+        guard let event = self._test_mouseDownEvent(buttonTag: buttonTag) else { return false }
+        return self.handleMenuTrackingMouseDown(event)
+    }
+
+    /// Simulates the parent-view event path used while NSMenu owns mouse tracking.
+    @discardableResult
+    func _test_simulateRuntimeClick(buttonTag: Int) -> Bool {
+        guard self._test_simulateMouseDown(buttonTag: buttonTag) else { return false }
+        guard let event = self._test_mouseUpEvent(buttonTag: buttonTag) else { return false }
+        guard self.handleMenuTrackingMouseUp(event) else { return false }
+        return self.selectedSegmentIndex == buttonTag
+    }
+
+    @discardableResult
+    func _test_simulateRuntimeClickOnQuotaIndicator(buttonTag: Int) -> Bool {
+        guard let mouseDown = self._test_quotaIndicatorMouseEvent(buttonTag: buttonTag, type: .leftMouseDown),
+              self.handleMenuTrackingMouseDown(mouseDown),
+              let mouseUp = self._test_quotaIndicatorMouseEvent(buttonTag: buttonTag, type: .leftMouseUp),
+              self.handleMenuTrackingMouseUp(mouseUp)
+        else {
+            return false
+        }
+        return self.selectedSegmentIndex == buttonTag
+    }
+
+    @discardableResult
+    func _test_simulateNativeAction(buttonTag: Int, state: NSControl.StateValue) -> Bool {
+        guard let button = self.buttons.first(where: { $0.tag == buttonTag }) else { return false }
+        button.state = state
+        self.handleSelection(button)
+        return true
+    }
+
+    func _test_buttonFrames() -> [NSRect] {
+        self.buttons.map(\.frame)
+    }
+
+    func _test_buttonFittingSizes() -> [NSSize] {
+        self.buttons.map(\.fittingSize)
+    }
+
+    func _test_buttonDesiredWidths() -> [CGFloat] {
+        self.buttons.map(Self.maxToggleWidth(for:))
+    }
+
+    func _test_buttonContentFrames() -> [NSRect?] {
+        self.buttons.map { button in
+            button.subviews.first(where: { $0 is NSStackView })?.frame
+        }
+    }
+
+    func _test_rowCount() -> Int {
+        self.rowCount
+    }
+
+    func _test_rowHeight() -> CGFloat {
+        self.rowHeight
+    }
+
+    func _test_setHoveredButtonTag(_ tag: Int?) {
+        self.hoveredButtonTag = tag
+        self.updateButtonStyles()
+    }
+
+    func _test_quotaIndicatorFillRatios() -> [CGFloat] {
+        self.buttons.compactMap { button in
+            self.quotaIndicators[ObjectIdentifier(button)]?.fillRatio
+        }
+    }
+
+    func _test_quotaIndicatorFillFrames() -> [NSRect] {
+        self.buttons.compactMap { button in
+            self.quotaIndicators[ObjectIdentifier(button)]?.fill.frame
+        }
+    }
+
+    func _test_quotaIndicatorTrackFrames() -> [NSRect] {
+        self.buttons.compactMap { button in
+            guard let track = self.quotaIndicators[ObjectIdentifier(button)]?.track else { return nil }
+            return self.convert(track.bounds, from: track)
+        }
+    }
+
+    func _test_quotaIndicatorConstraintIdentifiers() -> [ObjectIdentifier] {
+        self.buttons.compactMap { button in
+            self.quotaIndicators[ObjectIdentifier(button)].map { ObjectIdentifier($0.fillWidthConstraint) }
+        }
+    }
+}
+#endif
+
+extension ProviderSwitcherView {
+    private func addQuotaIndicator(to view: NSView, selection: ProviderSwitcherSelection, remainingPercent: Double?) {
         guard let remainingPercent else { return }
 
         let track = NSView()
         track.wantsLayer = true
         track.layer?.backgroundColor = NSColor.tertiaryLabelColor.withAlphaComponent(0.22).cgColor
-        track.layer?.cornerRadius = 2
+        track.layer?.cornerRadius = Self.quotaIndicatorHeight / 2
         track.layer?.masksToBounds = true
         track.translatesAutoresizingMaskIntoConstraints = false
         view.addSubview(track)
 
         let fill = NSView()
         fill.wantsLayer = true
-        fill.layer?.backgroundColor = Self.weeklyIndicatorColor(for: selection).cgColor
-        fill.layer?.cornerRadius = 2
+        fill.layer?.backgroundColor = Self.quotaIndicatorColor(
+            for: selection,
+            remainingPercent: remainingPercent).cgColor
+        fill.layer?.cornerRadius = Self.quotaIndicatorHeight / 2
+        fill.layer?.maskedCorners = [.layerMinXMinYCorner, .layerMinXMaxYCorner]
         fill.translatesAutoresizingMaskIntoConstraints = false
         track.addSubview(fill)
 
-        let ratio = CGFloat(max(0, min(1, remainingPercent / 100)))
+        let ratio = Self.quotaIndicatorRatio(remainingPercent: remainingPercent)
+        let fillWidthConstraint = Self.quotaIndicatorFillWidthConstraint(fill: fill, track: track, ratio: ratio)
 
         NSLayoutConstraint.activate([
-            track.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 6),
-            track.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -6),
-            track.bottomAnchor.constraint(equalTo: view.bottomAnchor, constant: -1),
-            track.heightAnchor.constraint(equalToConstant: 4),
+            track.leadingAnchor.constraint(
+                equalTo: view.leadingAnchor,
+                constant: Self.quotaIndicatorHorizontalInset),
+            track.trailingAnchor.constraint(
+                equalTo: view.trailingAnchor,
+                constant: -Self.quotaIndicatorHorizontalInset),
+            track.bottomAnchor.constraint(
+                equalTo: view.bottomAnchor,
+                constant: -Self.quotaIndicatorBottomInset),
+            track.heightAnchor.constraint(equalToConstant: Self.quotaIndicatorHeight),
             fill.leadingAnchor.constraint(equalTo: track.leadingAnchor),
             fill.topAnchor.constraint(equalTo: track.topAnchor),
             fill.bottomAnchor.constraint(equalTo: track.bottomAnchor),
+            fillWidthConstraint,
         ])
 
-        fill.widthAnchor.constraint(equalTo: track.widthAnchor, multiplier: ratio).isActive = true
-
-        self.weeklyIndicators[ObjectIdentifier(view)] = WeeklyIndicator(track: track, fill: fill)
-        self.updateWeeklyIndicatorVisibility(for: view)
+        self.quotaIndicators[ObjectIdentifier(view)] = QuotaIndicator(
+            track: track,
+            fill: fill,
+            fillWidthConstraint: fillWidthConstraint,
+            fillRatio: ratio)
+        self.updateQuotaIndicatorVisibility(for: view)
     }
 
-    private func updateWeeklyIndicatorVisibility(for view: NSView) {
-        guard let indicator = self.weeklyIndicators[ObjectIdentifier(view)] else { return }
+    private func updateQuotaIndicatorVisibility(for view: NSView) {
+        guard let indicator = self.quotaIndicators[ObjectIdentifier(view)] else { return }
         let isSelected = (view as? NSButton)?.state == .on
         indicator.track.isHidden = isSelected
-        indicator.fill.isHidden = isSelected
+        indicator.fill.isHidden = isSelected || indicator.fillRatio <= 0
+    }
+
+    fileprivate static func updateQuotaIndicatorFill(
+        indicator: inout QuotaIndicator,
+        remainingPercent: Double,
+        selection: ProviderSwitcherSelection)
+    {
+        let ratio = Self.quotaIndicatorRatio(remainingPercent: remainingPercent)
+        indicator.fillWidthConstraint.isActive = false
+        let fillWidthConstraint = Self.quotaIndicatorFillWidthConstraint(
+            fill: indicator.fill,
+            track: indicator.track,
+            ratio: ratio)
+        fillWidthConstraint.isActive = true
+        indicator.fillWidthConstraint = fillWidthConstraint
+        indicator.fillRatio = ratio
+        indicator.fill.layer?.backgroundColor = Self.quotaIndicatorColor(
+            for: selection,
+            remainingPercent: remainingPercent).cgColor
+        indicator.fill.layer?.cornerRadius = Self.quotaIndicatorHeight / 2
+        indicator.fill.layer?.maskedCorners = [.layerMinXMinYCorner, .layerMinXMaxYCorner]
+        indicator.track.isHidden = false
+        indicator.fill.isHidden = ratio <= 0
     }
 
-    private static func weeklyIndicatorColor(for selection: ProviderSwitcherSelection) -> NSColor {
+    fileprivate static func quotaIndicatorColor(
+        for selection: ProviderSwitcherSelection,
+        remainingPercent _: Double) -> NSColor
+    {
         switch selection {
         case let .provider(provider):
             let color = ProviderDescriptorRegistry.descriptor(for: provider).branding.color
@@ -780,23 +1153,29 @@ final class ProviderSwitcherView: NSView {
         }
     }
 
-    private static func overviewIcon() -> NSImage {
-        if let symbol = NSImage(systemSymbolName: "square.grid.2x2", accessibilityDescription: nil) {
-            return symbol
-        }
-        return NSImage(size: NSSize(width: 16, height: 16))
+    fileprivate static func quotaIndicatorRatio(remainingPercent: Double) -> CGFloat {
+        CGFloat(max(0, min(1, remainingPercent / 100)))
     }
 
-    private static func switcherTitle(for provider: UsageProvider) -> String {
-        ProviderDescriptorRegistry.descriptor(for: provider).metadata.displayName
+    private static func quotaIndicatorFillWidthConstraint(
+        fill: NSView,
+        track: NSView,
+        ratio: CGFloat)
+        -> NSLayoutConstraint
+    {
+        guard ratio > 0 else {
+            return fill.widthAnchor.constraint(equalToConstant: 0)
+        }
+        return fill.widthAnchor.constraint(equalTo: track.widthAnchor, multiplier: ratio)
     }
 }
 
 final class TokenAccountSwitcherView: NSView {
     private let accounts: [ProviderTokenAccount]
-    private let onSelect: (Int) -> Void
+    private let onSelect: (Int) -> Task<Void, Never>?
     private var selectedIndex: Int
     private var buttons: [NSButton] = []
+    private let preferredSize: NSSize
     private let rowSpacing: CGFloat = 4
     private let rowHeight: CGFloat = 26
     private let selectedBackground = NSColor.controlAccentColor.cgColor
@@ -804,13 +1183,19 @@ final class TokenAccountSwitcherView: NSView {
     private let selectedTextColor = NSColor.white
     private let unselectedTextColor = NSColor.secondaryLabelColor
 
-    init(accounts: [ProviderTokenAccount], selectedIndex: Int, width: CGFloat, onSelect: @escaping (Int) -> Void) {
+    init(
+        accounts: [ProviderTokenAccount],
+        selectedIndex: Int,
+        width: CGFloat,
+        onSelect: @escaping (Int) -> Task<Void, Never>?)
+    {
         self.accounts = accounts
         self.onSelect = onSelect
         self.selectedIndex = min(max(selectedIndex, 0), max(0, accounts.count - 1))
         let useTwoRows = accounts.count > 3
         let rows = useTwoRows ? 2 : 1
         let height = self.rowHeight * CGFloat(rows) + (useTwoRows ? self.rowSpacing : 0)
+        self.preferredSize = NSSize(width: width, height: height)
         super.init(frame: NSRect(x: 0, y: 0, width: width, height: height))
         self.wantsLayer = true
         self.buildButtons(useTwoRows: useTwoRows)
@@ -822,6 +1207,14 @@ final class TokenAccountSwitcherView: NSView {
         nil
     }
 
+    override var intrinsicContentSize: NSSize {
+        self.preferredSize
+    }
+
+    override var fittingSize: NSSize {
+        self.preferredSize
+    }
+
     private func buildButtons(useTwoRows: Bool) {
         let perRow = useTwoRows ? Int(ceil(Double(self.accounts.count) / 2.0)) : self.accounts.count
         let rows: [[ProviderTokenAccount]] = {
@@ -833,7 +1226,7 @@ final class TokenAccountSwitcherView: NSView {
 
         let stack = NSStackView()
         stack.orientation = .vertical
-        stack.alignment = .centerX
+        stack.alignment = .width
         stack.spacing = self.rowSpacing
         stack.translatesAutoresizingMaskIntoConstraints = false
 
@@ -857,6 +1250,8 @@ final class TokenAccountSwitcherView: NSView {
                 button.setButtonType(.toggle)
                 button.controlSize = .small
                 button.font = NSFont.systemFont(ofSize: NSFont.smallSystemFontSize)
+                button.cell?.lineBreakMode = account.displayName.contains("@") ? .byTruncatingMiddle : .byTruncatingTail
+                button.setContentCompressionResistancePriority(.defaultLow, for: .horizontal)
                 button.wantsLayer = true
                 button.layer?.cornerRadius = 6
                 row.addArrangedSubview(button)
@@ -865,6 +1260,7 @@ final class TokenAccountSwitcherView: NSView {
             }
 
             stack.addArrangedSubview(row)
+            row.widthAnchor.constraint(equalTo: stack.widthAnchor).isActive = true
         }
 
         self.addSubview(stack)
@@ -888,10 +1284,386 @@ final class TokenAccountSwitcherView: NSView {
     }
 
     @objc private func handleSelect(_ sender: NSButton) {
-        let index = sender.tag
-        guard index >= 0, index < self.accounts.count else { return }
+        _ = self.select(index: sender.tag)
+    }
+
+    @discardableResult
+    private func select(index: Int) -> Task<Void, Never>? {
+        guard index >= 0, index < self.accounts.count else { return nil }
         self.selectedIndex = index
         self.updateButtonStyles()
-        self.onSelect(index)
+        return self.onSelect(index)
+    }
+
+    #if DEBUG
+    func _test_select(index: Int) -> Task<Void, Never>? {
+        guard let button = self.buttons.first(where: { $0.tag == index }) else { return nil }
+        return self.select(index: button.tag)
+    }
+
+    func _test_buttonTitles() -> [String] {
+        self.buttons.map(\.title)
+    }
+    #endif
+}
+
+final class CodexAccountSwitcherView: NSView {
+    private let accounts: [CodexVisibleAccount]
+    private let onSelect: (CodexVisibleAccount) -> Void
+    private var selectedAccountID: String
+    private var pressedAccountID: String?
+    private var buttons: [NSButton] = []
+    private let preferredSize: NSSize
+    private let rowSpacing: CGFloat = 4
+    private let rowHeight: CGFloat = 26
+    private let selectedBackground = NSColor.controlAccentColor.cgColor
+    private let unselectedBackground = NSColor.clear.cgColor
+    private let selectedTextColor = NSColor.white
+    private let unselectedTextColor = NSColor.secondaryLabelColor
+    private let buttonFont = NSFont.systemFont(ofSize: NSFont.smallSystemFontSize)
+    private let buttonHorizontalPadding: CGFloat = 14
+    private let buttonSideInset: CGFloat = 6
+
+    init(
+        accounts: [CodexVisibleAccount],
+        selectedAccountID: String?,
+        width: CGFloat,
+        onSelect: @escaping (CodexVisibleAccount) -> Void)
+    {
+        self.accounts = accounts
+        self.onSelect = onSelect
+        self.selectedAccountID = selectedAccountID ?? accounts.first?.id ?? ""
+        let useTwoRows = accounts.count > 3
+        let rows = useTwoRows ? 2 : 1
+        let height = self.rowHeight * CGFloat(rows) + (useTwoRows ? self.rowSpacing : 0)
+        self.preferredSize = NSSize(width: width, height: height)
+        super.init(frame: NSRect(x: 0, y: 0, width: width, height: height))
+        self.wantsLayer = true
+        self.buildButtons(useTwoRows: useTwoRows)
+        self.updateButtonStyles()
+    }
+
+    @available(*, unavailable)
+    required init?(coder: NSCoder) {
+        nil
+    }
+
+    override var intrinsicContentSize: NSSize {
+        self.preferredSize
+    }
+
+    override var fittingSize: NSSize {
+        self.preferredSize
+    }
+
+    private func buildButtons(useTwoRows: Bool) {
+        let perRow = useTwoRows ? Int(ceil(Double(self.accounts.count) / 2.0)) : self.accounts.count
+        let rows: [[CodexVisibleAccount]] = {
+            if !useTwoRows { return [self.accounts] }
+            let first = Array(self.accounts.prefix(perRow))
+            let second = Array(self.accounts.dropFirst(perRow))
+            return [first, second]
+        }()
+        let stack = NSStackView()
+        stack.orientation = .vertical
+        stack.alignment = .width
+        stack.spacing = self.rowSpacing
+        stack.translatesAutoresizingMaskIntoConstraints = false
+
+        for rowAccounts in rows {
+            let row = NSStackView()
+            row.orientation = .horizontal
+            row.alignment = .centerY
+            row.distribution = .fillEqually
+            row.spacing = self.rowSpacing
+            row.translatesAutoresizingMaskIntoConstraints = false
+
+            let buttonWidth = self.buttonWidth(for: rowAccounts.count)
+            for account in rowAccounts {
+                let title = self.compactButtonTitle(for: account, buttonWidth: buttonWidth)
+                let button = PaddedToggleButton(
+                    title: title,
+                    target: self,
+                    action: #selector(self.handleSelect))
+                button.identifier = NSUserInterfaceItemIdentifier(account.id)
+                button.toolTip = account.menuDisplayName
+                button.isBordered = false
+                button.setButtonType(.toggle)
+                button.controlSize = .small
+                button.font = self.buttonFont
+                button.cell?.lineBreakMode = .byTruncatingTail
+                button.setContentCompressionResistancePriority(.defaultLow, for: .horizontal)
+                button.wantsLayer = true
+                button.layer?.cornerRadius = 6
+                row.addArrangedSubview(button)
+                self.buttons.append(button)
+            }
+
+            stack.addArrangedSubview(row)
+            row.widthAnchor.constraint(equalTo: stack.widthAnchor).isActive = true
+        }
+
+        self.addSubview(stack)
+        NSLayoutConstraint.activate([
+            stack.leadingAnchor.constraint(equalTo: self.leadingAnchor, constant: self.buttonSideInset),
+            stack.trailingAnchor.constraint(equalTo: self.trailingAnchor, constant: -self.buttonSideInset),
+            stack.topAnchor.constraint(equalTo: self.topAnchor),
+            stack.bottomAnchor.constraint(equalTo: self.bottomAnchor),
+            stack.heightAnchor.constraint(equalToConstant: self.rowHeight * CGFloat(rows.count) +
+                (useTwoRows ? self.rowSpacing : 0)),
+        ])
+    }
+
+    private func buttonWidth(for count: Int) -> CGFloat {
+        let contentWidth = self.bounds.width - (self.buttonSideInset * 2)
+        let spacing = self.rowSpacing * CGFloat(max(0, count - 1))
+        guard count > 0 else { return contentWidth }
+        return max(44, floor((contentWidth - spacing) / CGFloat(count)))
+    }
+
+    private func compactButtonTitle(for account: CodexVisibleAccount, buttonWidth: CGFloat) -> String {
+        let availableTextWidth = max(24, buttonWidth - self.buttonHorizontalPadding)
+        if self.textWidth(account.menuDisplayName) <= availableTextWidth {
+            return account.menuDisplayName
+        }
+
+        guard let workspace = account.menuWorkspaceLabel else {
+            return self.truncateMiddle(account.email, toFit: availableTextWidth)
+        }
+
+        let separator = "|"
+        let separatorWidth = self.textWidth(separator)
+        let contentWidth = max(24, availableTextWidth - separatorWidth)
+        let minimumEmailWidth = min(contentWidth * 0.45, max(18, contentWidth * 0.3))
+        let minimumWorkspaceWidth = min(contentWidth * 0.4, max(18, contentWidth * 0.25))
+        var emailWidth = max(minimumEmailWidth, contentWidth * 0.58)
+        var workspaceWidth = max(minimumWorkspaceWidth, contentWidth - emailWidth)
+
+        func makeTitle() -> String {
+            let email = self.truncateMiddle(account.email, toFit: emailWidth)
+            let workspace = self.truncateTail(workspace, toFit: workspaceWidth)
+            return "\(email)\(separator)\(workspace)"
+        }
+
+        var title = makeTitle()
+        var attempts = 0
+        while self.textWidth(title) > availableTextWidth, attempts < 16 {
+            let emailText = self.truncateMiddle(account.email, toFit: emailWidth)
+            let workspaceText = self.truncateTail(workspace, toFit: workspaceWidth)
+            let emailRenderedWidth = self.textWidth(emailText)
+            let workspaceRenderedWidth = self.textWidth(workspaceText)
+
+            if emailRenderedWidth >= workspaceRenderedWidth, emailWidth > minimumEmailWidth {
+                emailWidth = max(minimumEmailWidth, emailWidth - 6)
+            } else if workspaceWidth > minimumWorkspaceWidth {
+                workspaceWidth = max(minimumWorkspaceWidth, workspaceWidth - 6)
+            } else {
+                break
+            }
+
+            title = makeTitle()
+            attempts += 1
+        }
+
+        return title
+    }
+
+    private func truncateTail(_ text: String, toFit width: CGFloat) -> String {
+        let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else { return text }
+        if self.textWidth(trimmed) <= width {
+            return trimmed
+        }
+
+        let ellipsis = "…"
+        let ellipsisWidth = self.textWidth(ellipsis)
+        guard ellipsisWidth < width else { return ellipsis }
+
+        var candidate = ""
+        for character in trimmed {
+            let next = candidate + String(character)
+            if self.textWidth(next + ellipsis) > width {
+                break
+            }
+            candidate = next
+        }
+
+        if candidate.isEmpty {
+            return ellipsis
+        }
+        return candidate + ellipsis
+    }
+
+    private func truncateMiddle(_ text: String, toFit width: CGFloat) -> String {
+        let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else { return text }
+        if self.textWidth(trimmed) <= width {
+            return trimmed
+        }
+
+        let ellipsis = "…"
+        let ellipsisWidth = self.textWidth(ellipsis)
+        guard ellipsisWidth < width else { return ellipsis }
+
+        var prefix = ""
+        var suffix = ""
+        var prefixIndex = trimmed.startIndex
+        var suffixIndex = trimmed.endIndex
+        var best = ellipsis
+        var takeSuffixNext = true
+
+        while prefixIndex < suffixIndex {
+            let nextPrefix: String
+            let nextSuffix: String
+            if takeSuffixNext {
+                let previousIndex = trimmed.index(before: suffixIndex)
+                nextPrefix = prefix
+                nextSuffix = String(trimmed[previousIndex]) + suffix
+                suffixIndex = previousIndex
+            } else {
+                nextPrefix = prefix + String(trimmed[prefixIndex])
+                nextSuffix = suffix
+                prefixIndex = trimmed.index(after: prefixIndex)
+            }
+
+            let candidate = nextPrefix + ellipsis + nextSuffix
+            if self.textWidth(candidate) > width {
+                break
+            }
+
+            prefix = nextPrefix
+            suffix = nextSuffix
+            best = candidate
+            takeSuffixNext.toggle()
+        }
+
+        return best
+    }
+
+    private func textWidth(_ text: String) -> CGFloat {
+        let attributes: [NSAttributedString.Key: Any] = [.font: self.buttonFont]
+        return ceil((text as NSString).size(withAttributes: attributes).width)
+    }
+
+    private func updateButtonStyles() {
+        for button in self.buttons {
+            let selected = button.identifier?.rawValue == self.selectedAccountID
+            button.state = selected ? .on : .off
+            button.layer?.backgroundColor = selected ? self.selectedBackground : self.unselectedBackground
+            button.contentTintColor = selected ? self.selectedTextColor : self.unselectedTextColor
+        }
+    }
+
+    override func acceptsFirstMouse(for event: NSEvent?) -> Bool {
+        true
+    }
+
+    override func hitTest(_ point: NSPoint) -> NSView? {
+        let descendant = super.hitTest(point)
+        if descendant != nil, descendant !== self {
+            self.toolTip = (descendant as? NSButton)?.toolTip
+            return self
+        }
+        self.toolTip = nil
+        return descendant
+    }
+
+    override func mouseDown(with event: NSEvent) {
+        let location = self.convert(event.locationInWindow, from: nil)
+        self.pressedAccountID = self.accountID(at: location)
+    }
+
+    override func mouseUp(with event: NSEvent) {
+        defer { self.pressedAccountID = nil }
+        guard let pressedAccountID = self.pressedAccountID else { return }
+        let location = self.convert(event.locationInWindow, from: nil)
+        guard let releasedAccountID = self.accountID(at: location),
+              releasedAccountID == pressedAccountID,
+              let account = self.accounts.first(where: { $0.id == pressedAccountID })
+        else {
+            return
+        }
+        self.applySelection(account)
+    }
+
+    private func accountID(at pointInSelf: NSPoint) -> String? {
+        self.buttons.first(where: { self.convert($0.bounds, from: $0).contains(pointInSelf) })?.identifier?.rawValue
+    }
+
+    @objc private func handleSelect(_ sender: NSButton) {
+        guard let accountID = sender.identifier?.rawValue,
+              let account = self.accounts.first(where: { $0.id == accountID }) else { return }
+        self.applySelection(account)
+    }
+
+    private func applySelection(_ account: CodexVisibleAccount) {
+        self.selectedAccountID = account.id
+        self.updateButtonStyles()
+        self.onSelect(account)
+    }
+
+    #if DEBUG
+    func _test_buttonTitles() -> [String] {
+        self.buttons.map(\.title)
+    }
+
+    func _test_buttonToolTips() -> [String?] {
+        self.buttons.map(\.toolTip)
+    }
+
+    func _test_selectAccount(id: String) {
+        guard let account = self.accounts.first(where: { $0.id == id }) else { return }
+        self.applySelection(account)
+    }
+
+    func _test_simulateRuntimeClick(id: String) -> Bool {
+        guard let button = self.buttons.first(where: { $0.identifier?.rawValue == id }) else { return false }
+        self.updateConstraintsForSubtreeIfNeeded()
+        self.layoutSubtreeIfNeeded()
+        let point = self.convert(NSPoint(x: button.bounds.midX, y: button.bounds.midY), from: button)
+        guard let mouseDownEvent = NSEvent.mouseEvent(
+            with: .leftMouseDown,
+            location: point,
+            modifierFlags: [],
+            timestamp: 0,
+            windowNumber: 0,
+            context: nil,
+            eventNumber: 1,
+            clickCount: 1,
+            pressure: 1),
+            let mouseUpEvent = NSEvent.mouseEvent(
+                with: .leftMouseUp,
+                location: point,
+                modifierFlags: [],
+                timestamp: 0,
+                windowNumber: 0,
+                context: nil,
+                eventNumber: 2,
+                clickCount: 1,
+                pressure: 0)
+        else {
+            return false
+        }
+        self.mouseDown(with: mouseDownEvent)
+        self.mouseUp(with: mouseUpEvent)
+        return self.selectedAccountID == id
+    }
+
+    func _test_hitTestSwallowsChildButton(id: String) -> Bool {
+        guard let button = self.buttons.first(where: { $0.identifier?.rawValue == id }) else { return false }
+        self.updateConstraintsForSubtreeIfNeeded()
+        self.layoutSubtreeIfNeeded()
+        let point = self.convert(NSPoint(x: button.bounds.midX, y: button.bounds.midY), from: button)
+        return self.hitTest(point) === self
+    }
+
+    func _test_toolTipAfterHitTest(id: String) -> String? {
+        guard let button = self.buttons.first(where: { $0.identifier?.rawValue == id }) else { return nil }
+        self.updateConstraintsForSubtreeIfNeeded()
+        self.layoutSubtreeIfNeeded()
+        let point = self.convert(NSPoint(x: button.bounds.midX, y: button.bounds.midY), from: button)
+        _ = self.hitTest(point)
+        return self.toolTip
     }
+    #endif
 }
diff --git a/Sources/CodexBar/StatusItemController+UsageHistoryMenu.swift b/Sources/CodexBar/StatusItemController+UsageHistoryMenu.swift
new file mode 100644
index 0000000000..75e8c0cac8
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+UsageHistoryMenu.swift
@@ -0,0 +1,70 @@
+import AppKit
+import CodexBarCore
+import SwiftUI
+
+private final class UsageHistoryMenuHostingView<Content: View>: NSHostingView<Content> {
+    override var allowsVibrancy: Bool {
+        true
+    }
+}
+
+extension StatusItemController {
+    @discardableResult
+    func addUsageHistoryMenuItemIfNeeded(to menu: NSMenu, provider: UsageProvider, width: CGFloat) -> Bool {
+        guard let submenu = self.makeUsageHistorySubmenu(provider: provider, width: width) else { return false }
+        let item = NSMenuItem(title: L("Subscription Utilization"), action: nil, keyEquivalent: "")
+        item.isEnabled = true
+        item.representedObject = "usageHistorySubmenu"
+        item.submenu = submenu
+        menu.addItem(item)
+        return true
+    }
+
+    func makeUsageHistorySubmenu(provider: UsageProvider, width: CGFloat? = nil) -> NSMenu? {
+        guard self.store.supportsPlanUtilizationHistory(for: provider) else { return nil }
+        guard !self.store.shouldHidePlanUtilizationMenuItem(for: provider) else { return nil }
+        if let width {
+            return self.makeHostedSubviewPlaceholderMenu(
+                chartID: Self.usageHistoryChartID,
+                provider: provider,
+                width: width)
+        }
+        return self.makeHostedSubviewPlaceholderMenu(chartID: Self.usageHistoryChartID, provider: provider)
+    }
+
+    func appendUsageHistoryChartItem(
+        to submenu: NSMenu,
+        provider: UsageProvider,
+        width: CGFloat) -> Bool
+    {
+        let histories = self.store.planUtilizationHistory(for: provider)
+        let snapshot = self.store.snapshot(for: provider)
+
+        if !self.menuCardRenderingEnabledForController {
+            let chartItem = NSMenuItem()
+            chartItem.isEnabled = true
+            chartItem.representedObject = Self.usageHistoryChartID
+            chartItem.toolTip = provider.rawValue
+            submenu.addItem(chartItem)
+            return true
+        }
+
+        let chartView = PlanUtilizationHistoryChartMenuView(
+            provider: provider,
+            histories: histories,
+            snapshot: snapshot,
+            width: width)
+        let hosting = UsageHistoryMenuHostingView(rootView: chartView)
+        hosting.frame = NSRect(
+            origin: .zero,
+            size: NSSize(width: width, height: self.hostedSubviewFittingHeight(for: hosting, width: width)))
+
+        let chartItem = NSMenuItem()
+        chartItem.view = hosting
+        chartItem.isEnabled = true
+        chartItem.representedObject = Self.usageHistoryChartID
+        chartItem.toolTip = provider.rawValue
+        submenu.addItem(chartItem)
+        return true
+    }
+}
diff --git a/Sources/CodexBar/StatusItemController+ZaiHourlyChartMenu.swift b/Sources/CodexBar/StatusItemController+ZaiHourlyChartMenu.swift
new file mode 100644
index 0000000000..712fb31371
--- /dev/null
+++ b/Sources/CodexBar/StatusItemController+ZaiHourlyChartMenu.swift
@@ -0,0 +1,35 @@
+import AppKit
+import CodexBarCore
+import SwiftUI
+
+extension StatusItemController {
+    static let zaiHourlyUsageChartID = "zaiHourlyUsageChart"
+
+    @discardableResult
+    func addZaiHourlyUsageMenuItemIfNeeded(to menu: NSMenu, provider: UsageProvider, width: CGFloat) -> Bool {
+        guard provider == .zai else { return false }
+        guard let snapshot = self.store.snapshot(for: provider),
+              snapshot.zaiUsage?.modelUsage != nil
+        else { return false }
+        let submenu = self.makeHostedSubviewPlaceholderMenu(chartID: Self.zaiHourlyUsageChartID, provider: provider)
+        let item = self.makeMenuCardItem(
+            HStack(spacing: 0) {
+                Text(L("Hourly Usage"))
+                    .font(.system(size: NSFont.menuFont(ofSize: 0).pointSize))
+                    .lineLimit(1)
+                    .frame(maxWidth: .infinity, alignment: .leading)
+                    .padding(.leading, 14)
+                    .padding(.trailing, 28)
+                    .padding(.vertical, 8)
+            },
+            id: "zaiHourlyUsageSubmenu",
+            width: width,
+            heightCacheScope: provider.rawValue,
+            heightCacheFingerprint: "zaiHourlyUsageSubmenu:\(provider.rawValue)",
+            submenu: submenu,
+            submenuIndicatorAlignment: .trailing,
+            submenuIndicatorTopPadding: 0)
+        menu.addItem(item)
+        return true
+    }
+}
diff --git a/Sources/CodexBar/StatusItemController.swift b/Sources/CodexBar/StatusItemController.swift
index 5ccf8ab38c..51afbae380 100644
--- a/Sources/CodexBar/StatusItemController.swift
+++ b/Sources/CodexBar/StatusItemController.swift
@@ -2,50 +2,195 @@ import AppKit
 import CodexBarCore
 import Observation
 import QuartzCore
-import SwiftUI
 
 // MARK: - Status item controller (AppKit-hosted icons, SwiftUI popovers)
 
 @MainActor
 protocol StatusItemControlling: AnyObject {
     func openMenuFromShortcut()
+    func runLoginFlowFromSettings(provider: UsageProvider) async
+    func celebrationOriginPoint(for provider: UsageProvider?) -> CGPoint?
+    func trimRebuildableCachesForMemoryPressure() -> MemoryPressureCacheTrimSummary
+    #if DEBUG
+    func seedRebuildableCachesForMemoryPressureProof()
+    #endif
+    func prepareForAppShutdown()
+}
+
+extension StatusItemControlling {
+    func celebrationOriginPoint(for provider: UsageProvider?) -> CGPoint? {
+        nil
+    }
+
+    func trimRebuildableCachesForMemoryPressure() -> MemoryPressureCacheTrimSummary {
+        MemoryPressureCacheTrimSummary()
+    }
+
+    #if DEBUG
+    func seedRebuildableCachesForMemoryPressureProof() {}
+    #endif
+
+    func prepareForAppShutdown() {}
 }
 
 @MainActor
 final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControlling {
     // Disable SwiftUI menu cards + menu refresh work in tests to avoid swiftpm-testing-helper crashes.
     static var menuCardRenderingEnabled = !SettingsStore.isRunningTests
-    static var menuRefreshEnabled = !SettingsStore.isRunningTests
-    typealias Factory = (UsageStore, SettingsStore, AccountInfo, UpdaterProviding, PreferencesSelection)
+    private static let defaultMenuRefreshEnabled = !SettingsStore.isRunningTests
+    private(set) static var menuRefreshEnabled = !SettingsStore.isRunningTests
+    static let quotaWarningFlashDuration: TimeInterval = 60
+    private nonisolated static let statusItemAccessibilityTitle = "CodexBar"
+    private nonisolated static let statusItemAccessibilityIdentifierPrefix = "CodexBar.StatusItem"
+    private nonisolated static let mergedLegacyDefaultItemIndex = 0
+
+    enum StatusItemIdentity {
+        case merged
+        case provider(UsageProvider)
+
+        var autosaveName: String {
+            switch self {
+            case .merged:
+                "codexbar-merged"
+            case let .provider(provider):
+                "codexbar-\(provider.rawValue)"
+            }
+        }
+
+        var accessibilityIdentifier: String {
+            switch self {
+            case .merged:
+                StatusItemController.statusItemAccessibilityIdentifierPrefix
+            case let .provider(provider):
+                "\(StatusItemController.statusItemAccessibilityIdentifierPrefix).\(provider.rawValue)"
+            }
+        }
+    }
+
+    #if DEBUG
+    var menuRefreshEnabledOverrideForTesting: Bool?
+    #endif
+
+    typealias Factory =
+        @MainActor (
+            UsageStore,
+            SettingsStore,
+            AccountInfo,
+            UpdaterProviding,
+            PreferencesSelection,
+            ManagedCodexAccountCoordinator,
+            CodexAccountPromotionCoordinator)
         -> StatusItemControlling
-    static let defaultFactory: Factory = { store, settings, account, updater, selection in
+    // swiftlint:disable:next function_parameter_count
+    static func makeDefaultController(
+        store: UsageStore,
+        settings: SettingsStore,
+        account: AccountInfo,
+        updater: UpdaterProviding,
+        selection: PreferencesSelection,
+        managedCodexAccountCoordinator: ManagedCodexAccountCoordinator,
+        codexAccountPromotionCoordinator: CodexAccountPromotionCoordinator)
+        -> StatusItemControlling
+    {
         StatusItemController(
             store: store,
             settings: settings,
             account: account,
             updater: updater,
-            preferencesSelection: selection)
+            preferencesSelection: selection,
+            managedCodexAccountCoordinator: managedCodexAccountCoordinator,
+            codexAccountPromotionCoordinator: codexAccountPromotionCoordinator)
     }
 
+    static let defaultFactory: Factory = StatusItemController.makeDefaultController
+
     static var factory: Factory = StatusItemController.defaultFactory
 
     let store: UsageStore
     let settings: SettingsStore
+    lazy var menuCardRefreshMonitor = MenuCardRefreshMonitor { [weak self] provider in
+        self?.menuCardModel(for: provider)
+    }
+
     let account: AccountInfo
     let updater: UpdaterProviding
-    private let statusBar: NSStatusBar
+    let managedCodexAccountCoordinator: ManagedCodexAccountCoordinator
+    let codexAccountPromotionCoordinator: CodexAccountPromotionCoordinator
+    let statusBar: NSStatusBar
+    let menuCardRenderingEnabledForController: Bool
+    let menuRefreshEnabledForController: Bool
     var statusItem: NSStatusItem
     var statusItems: [UsageProvider: NSStatusItem] = [:]
     var lastMenuProvider: UsageProvider?
     var menuProviders: [ObjectIdentifier: UsageProvider] = [:]
-    var menuContentVersion: Int = 0
-    var menuVersions: [ObjectIdentifier: Int] = [:]
+    var menuSession = MenuSessionCoordinator<ObjectIdentifier>()
+    var menuReadinessSignatures: [ObjectIdentifier: String] = [:]
+    let hostedSubviewRenderSignatures = NSMapTable<NSMenu, NSString>.weakToStrongObjects()
+    /// Persistent Refresh rows are weakly tracked so their enabled state can change during menu tracking.
+    let persistentRefreshItems = NSHashTable<NSMenuItem>.weakObjects()
+    var menuCardHeightCache: [MenuCardHeightCacheKey: CGFloat] = [:]
+    var measuredStandardMenuWidthCache: [String: CGFloat] = [:]
+    var lastMenuAdjunctReadinessSignature = ""
+    var lastMenuAdjunctReadinessBaselineVersion = 0
+    var rootOpenHandledMenuObservationSignature: String?
     var mergedMenu: NSMenu?
     var providerMenus: [UsageProvider: NSMenu] = [:]
     var fallbackMenu: NSMenu?
     var openMenus: [ObjectIdentifier: NSMenu] = [:]
     var menuRefreshTasks: [ObjectIdentifier: Task<Void, Never>] = [:]
+    var manualRefreshTask: Task<Void, Never>?
+    var manualRefreshProvider: UsageProvider?
+    var closedMenuRebuildTasks: [ObjectIdentifier: Task<Void, Never>] = [:]
+    var closedMenuRebuildRequests = MenuRebuildRequestRegistry<ObjectIdentifier>()
+    var openMenuRebuildTasks: [ObjectIdentifier: Task<Void, Never>] = [:]
+    var openMenuRebuildRequests = MenuRebuildRequestRegistry<ObjectIdentifier>()
+    var menuIdentitySignatures: [ObjectIdentifier: String] = [:]
+    var codexAccountMenuProjectionRevalidationTask: Task<Void, Never>?
+    var openMenuRebuildsClosingHostedSubviewMenus: Set<ObjectIdentifier> = []
+    var parentMenuRebuildPendingAfterHostedSubviewClose = false
+    var deferredMenuInteractionRefreshProviders: Set<UsageProvider> = []
+    var deferredMenuInteractionRefreshPending: Bool {
+        !self.deferredMenuInteractionRefreshProviders.isEmpty
+    }
+
+    var deferredOpenAIDashboardRefreshReason: String?
+    var deferredMenuInteractionRefreshTask: Task<Void, Never>?
+    var highlightedMenuItems: [ObjectIdentifier: NSMenuItem] = [:]
+    var providerSwitcherShortcutEventMonitor: ProviderSwitcherShortcutEventMonitor?
+    var providerSwitcherShortcutMenuID: ObjectIdentifier?
+    var providerSwitcherPointerInteractionMenuID: ObjectIdentifier?
+    var pendingProviderSwitcherPointerRebuild: PendingProviderSwitcherRebuild?
+    var overviewScrollAccumulatedDelta: CGFloat = 0
+    var overviewScrollNavigationHandlerForTesting: ((OverviewScrollStep) -> Void)?
+    var hasPreparedForAppShutdown = false
+    var scheduleQuitTermination: (@escaping @MainActor () -> Void) -> Void = { operation in
+        DispatchQueue.main.async {
+            Task { @MainActor in
+                operation()
+            }
+        }
+    }
+
+    var terminateApplicationForQuit: @MainActor () -> Void = {
+        NSApp.terminate(nil)
+    }
+
+    var openMenuInvalidationRetryTask: Task<Void, Never>?
+    #if DEBUG
+    var onDelayedMenuRefreshAttemptForTesting: (() -> Void)?
+    var onDeferredMenuInteractionRefreshForTesting: (() -> Void)?
+    var onOpenMenuInvalidationRetryForTesting: (() -> Void)?
+    var isReleasedForTesting = false
+    var lastLoggedClosedMenuRebuildVersion: Int?
+    var _test_openMenuRefreshYieldOverride: (@MainActor () async -> Void)?
+    var _test_openMenuRebuildObserver: (@MainActor (NSMenu) -> Void)?
+    var _test_providerSwitcherMenuRebuildDebounceNanoseconds: UInt64?
+    var _test_codexAmbientLoginRunnerOverride:
+        (@MainActor (TimeInterval) async -> CodexLoginRunner.Result)?
+    var _test_manualRefreshOperation: (@MainActor () async -> Void)?
+    #endif
     var blinkTask: Task<Void, Never>?
+    var menuBarCountdownRefreshTask: Task<Void, Never>?
     var loginTask: Task<Void, Never>? {
         didSet { self.refreshMenusForLoginStateChange() }
     }
@@ -64,6 +209,8 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin
     var blinkAmounts: [UsageProvider: CGFloat] = [:]
     var wiggleAmounts: [UsageProvider: CGFloat] = [:]
     var tiltAmounts: [UsageProvider: CGFloat] = [:]
+    var quotaWarningFlashUntil: [UsageProvider: Date] = [:]
+    var quotaWarningFlashTasks: [UsageProvider: Task<Void, Never>] = [:]
     var blinkForceUntil: Date?
     var loginPhase: LoginPhase = .idle {
         didSet {
@@ -77,6 +224,7 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin
     var animationDriver: DisplayLinkDriver?
     var animationPhase: Double = 0
     var animationPattern: LoadingPattern = .knightRider
+    var animationStartedAt: Date?
     private var lastConfigRevision: Int
     private var lastProviderOrder: [UsageProvider]
     private var lastMergeIcons: Bool
@@ -88,16 +236,69 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin
     /// Tracks whether the merged-menu switcher was built with the Overview tab visible.
     /// Used to force switcher rebuilds when Overview availability toggles.
     var lastSwitcherIncludesOverview: Bool = false
+    /// Tracks localization-sensitive labels used by the merged menu.
+    /// Used to force menu rebuilds when app language changes.
+    var lastMenuLocalizationSignature: String = ""
     /// Tracks which providers the merged menu's switcher was built with, to detect when it needs full rebuild.
     var lastSwitcherProviders: [UsageProvider] = []
     /// Tracks which switcher tab state was used for the current merged-menu switcher instance.
     var lastMergedSwitcherSelection: ProviderSwitcherSelection?
+    /// Tracks which provider/overview content is currently attached below the merged-menu switcher.
+    var lastMergedMenuContentSelection: ProviderSwitcherSelection?
+    /// Tracks the visible Codex account switcher contents for merged-menu smart updates.
+    var lastCodexAccountMenuDisplay: CodexAccountMenuDisplay?
+    /// Tracks the visible token account switcher contents for merged-menu smart updates.
+    var lastTokenAccountMenuDisplay: TokenAccountMenuDisplay?
+    /// Keeps detached merged-menu tab content reusable while the same menu remains open.
+    var mergedSwitcherContentCaches: [ObjectIdentifier: [ProviderSwitcherSelection: CachedMergedSwitcherMenuContent]]
+        = [:]
+    var preservesMergedSwitcherContentCachesDuringInvalidation = false
+    /// Card hosting views harvested from items about to be discarded by the current populate
+    /// pass, keyed by card identifier; consumed by `makeMenuCardItem` and cleared when the
+    /// pass finishes. Never outlives a single synchronous menu population.
+    var menuCardViewRecyclePool: [String: NSView] = [:]
+    /// Monotonic token used to ignore stale deferred provider-switcher menu rebuilds.
+    var providerSwitcherUpdateToken = 0
+    var providerSelectionUIRefreshTask: Task<Void, Never>?
+    var deferredMergedIconRenderAfterTracking = false
+    var lastAppliedMergedIconRenderSignature: String?
+    var lastAppliedProviderIconRenderSignatures: [UsageProvider: String] = [:]
+    var lastObservedStoreIconWorkSignature: String?
+    var iconPerfRefreshCycleMetrics: IconPerfRefreshCycleMetrics?
+    var iconPerfUpdatePassActive = false
+    var lastKnownScreenCount: Int
+    var pendingScreenChangePreviousCount: Int?
+    var screenChangeVisibilityTask: Task<Void, Never>?
     let loginLogger = CodexBarLog.logger(LogCategories.login)
+    let menuLogger = CodexBarLog.logger(LogCategories.app)
     var selectedMenuProvider: UsageProvider? {
         get { self.settings.selectedMenuProvider }
         set { self.settings.selectedMenuProvider = newValue }
     }
 
+    private static func makeStatusItem(
+        statusBar: NSStatusBar,
+        identity: StatusItemIdentity,
+        defaults: UserDefaults,
+        legacyDefaultItemIndex: Int?)
+        -> NSStatusItem
+    {
+        MenuBarStatusItemPlacementPreflight.prepare(
+            defaults: defaults,
+            autosaveName: identity.autosaveName,
+            legacyDefaultItemIndex: legacyDefaultItemIndex)
+        let item = statusBar.statusItem(withLength: NSStatusItem.variableLength)
+        item.autosaveName = identity.autosaveName
+        if let button = item.button {
+            // Ensure the icon is rendered at 1:1 without resampling (crisper edges for template images).
+            button.imageScaling = .scaleNone
+            button.setAccessibilityIdentifier(identity.accessibilityIdentifier)
+            button.setAccessibilityTitle(self.statusItemAccessibilityTitle)
+            button.toolTip = self.statusItemAccessibilityTitle
+        }
+        return item
+    }
+
     struct BlinkState {
         var nextBlink: Date
         var blinkStart: Date?
@@ -122,29 +323,54 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin
     }
 
     func menuBarMetricWindow(for provider: UsageProvider, snapshot: UsageSnapshot?) -> RateWindow? {
-        switch self.settings.menuBarMetricPreference(for: provider) {
-        case .primary:
-            return snapshot?.primary ?? snapshot?.secondary
-        case .secondary:
-            return snapshot?.secondary ?? snapshot?.primary
+        if provider == .codex {
+            return self.codexMenuBarMetricWindow(snapshot: snapshot)
+        }
+        return MenuBarMetricWindowResolver.rateWindow(
+            preference: self.settings.menuBarMetricPreference(for: provider, snapshot: snapshot),
+            provider: provider,
+            snapshot: snapshot,
+            supportsAverage: self.settings.menuBarMetricSupportsAverage(for: provider))
+    }
+
+    private func codexMenuBarMetricWindow(snapshot: UsageSnapshot?) -> RateWindow? {
+        guard let snapshot else { return nil }
+        let projection = CodexConsumerProjection.make(
+            surface: .menuBar,
+            context: CodexConsumerProjection.Context(
+                snapshot: snapshot,
+                rawUsageError: nil,
+                liveCredits: self.store.credits,
+                rawCreditsError: self.store.lastCreditsError,
+                liveDashboard: self.store.openAIDashboard,
+                rawDashboardError: self.store.lastOpenAIDashboardError,
+                dashboardAttachmentAuthorized: self.store.openAIDashboardAttachmentAuthorized,
+                dashboardRequiresLogin: self.store.openAIDashboardRequiresLogin,
+                now: snapshot.updatedAt))
+        let lanes = projection.visibleRateLanes
+        let first = lanes.first.flatMap { projection.rateWindow(for: $0) }
+        let second = lanes.dropFirst().first.flatMap { projection.rateWindow(for: $0) }
+        let preference = self.settings.menuBarMetricPreference(for: .codex, snapshot: snapshot)
+
+        switch preference {
+        case .secondary, .tertiary:
+            return second ?? first
+        case .extraUsage:
+            return first
         case .average:
-            guard let primary = snapshot?.primary, let secondary = snapshot?.secondary else {
-                return snapshot?.primary ?? snapshot?.secondary
+            guard self.settings.menuBarMetricSupportsAverage(for: .codex),
+                  let primary = first,
+                  let secondary = second
+            else {
+                return first
             }
             let usedPercent = (primary.usedPercent + secondary.usedPercent) / 2
-            return RateWindow(usedPercent: usedPercent, windowMinutes: nil, resetsAt: nil, resetDescription: nil)
-        case .automatic:
-            if provider == .factory || provider == .kimi {
-                return snapshot?.secondary ?? snapshot?.primary
-            }
-            if provider == .copilot,
-               let primary = snapshot?.primary,
-               let secondary = snapshot?.secondary
-            {
-                // Copilot can expose chat + completions quotas; show the more constrained one by default.
-                return primary.usedPercent >= secondary.usedPercent ? primary : secondary
-            }
-            return snapshot?.primary ?? snapshot?.secondary
+            return RateWindow(
+                usedPercent: usedPercent, windowMinutes: nil, resetsAt: nil, resetDescription: nil)
+        case .primaryAndSecondary:
+            return [first, second].compactMap(\.self).max(by: { $0.usedPercent < $1.usedPercent })
+        case .automatic, .primary, .monthlyPlan:
+            return first
         }
     }
 
@@ -154,7 +380,13 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin
         account: AccountInfo,
         updater: UpdaterProviding,
         preferencesSelection: PreferencesSelection,
-        statusBar: NSStatusBar = .system)
+        managedCodexAccountCoordinator: ManagedCodexAccountCoordinator =
+            ManagedCodexAccountCoordinator(),
+        codexAccountPromotionCoordinator: CodexAccountPromotionCoordinator? = nil,
+        statusBar: NSStatusBar = .system,
+        menuCardRenderingEnabled: Bool = StatusItemController.menuCardRenderingEnabled,
+        menuRefreshEnabled: Bool = StatusItemController.menuRefreshEnabled,
+        observeProviderConfigNotifications: Bool = !SettingsStore.isRunningTests)
     {
         if SettingsStore.isRunningTests {
             _ = NSApplication.shared
@@ -164,22 +396,45 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin
         self.account = account
         self.updater = updater
         self.preferencesSelection = preferencesSelection
+        self.managedCodexAccountCoordinator = managedCodexAccountCoordinator
+        self.codexAccountPromotionCoordinator =
+            codexAccountPromotionCoordinator
+                ?? CodexAccountPromotionCoordinator(
+                    settingsStore: settings,
+                    usageStore: store,
+                    managedAccountCoordinator: managedCodexAccountCoordinator)
         self.lastConfigRevision = settings.configRevision
         self.lastProviderOrder = settings.providerOrder
         self.lastMergeIcons = settings.mergeIcons
         self.lastSwitcherShowsIcons = settings.switcherShowsIcons
         self.lastObservedUsageBarsShowUsed = settings.usageBarsShowUsed
         self.lastSwitcherUsageBarsShowUsed = settings.usageBarsShowUsed
+        self.menuCardRenderingEnabledForController = menuCardRenderingEnabled
+        self.menuRefreshEnabledForController = menuRefreshEnabled
+        let repairedStatusItemVisibilityKeys = MenuBarStatusItemDefaultsRepair
+            .repairHiddenVisibilityDefaultsIfNeeded(defaults: settings.userDefaults)
         self.statusBar = statusBar
-        let item = statusBar.statusItem(withLength: NSStatusItem.variableLength)
-        // Ensure the icon is rendered at 1:1 without resampling (crisper edges for template images).
-        item.button?.imageScaling = .scaleNone
-        self.statusItem = item
+        self.statusItem = Self.makeStatusItem(
+            statusBar: statusBar,
+            identity: .merged,
+            defaults: settings.userDefaults,
+            legacyDefaultItemIndex: Self.mergedLegacyDefaultItemIndex)
+        self.lastKnownScreenCount = NSScreen.screens.count
         // Status items for individual providers are now created lazily in updateVisibility()
         super.init()
+        if !repairedStatusItemVisibilityKeys.isEmpty {
+            self.menuLogger.info(
+                "Repaired hidden macOS status-item visibility defaults",
+                metadata: ["keys": repairedStatusItemVisibilityKeys.joined(separator: ",")])
+        }
+        self.lastMenuAdjunctReadinessSignature = self.menuAdjunctReadinessSignature()
+        self.lastMenuAdjunctReadinessBaselineVersion = self.menuSession.contentVersion
         self.wireBindings()
-        self.updateIcons()
         self.updateVisibility()
+        self.updateIcons()
+        self.scheduleCodexAccountMenuProjectionRevalidationIfNeeded(
+            for: self.store.enabledProvidersForDisplay())
+        self.scheduleStartupStatusItemVisibilityCheck()
         NotificationCenter.default.addObserver(
             self,
             selector: #selector(self.handleDebugReplayNotification(_:)),
@@ -192,16 +447,56 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin
             object: nil)
         NotificationCenter.default.addObserver(
             self,
-            selector: #selector(self.handleProviderConfigDidChange),
-            name: .codexbarProviderConfigDidChange,
+            selector: #selector(self.handleQuotaWarningPosted(_:)),
+            name: .codexbarQuotaWarningDidPost,
+            object: nil)
+        if observeProviderConfigNotifications {
+            NotificationCenter.default.addObserver(
+                self,
+                selector: #selector(self.handleProviderConfigDidChange),
+                name: .codexbarProviderConfigDidChange,
+                object: nil)
+        }
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(self.handleScreenParametersDidChange(_:)),
+            name: NSApplication.didChangeScreenParametersNotification,
             object: nil)
     }
 
+    convenience init(
+        store: UsageStore,
+        settings: SettingsStore,
+        account: AccountInfo,
+        updater: UpdaterProviding,
+        preferencesSelection: PreferencesSelection,
+        statusBar: NSStatusBar = .system,
+        menuCardRenderingEnabled: Bool = StatusItemController.menuCardRenderingEnabled,
+        menuRefreshEnabled: Bool = StatusItemController.menuRefreshEnabled,
+        observeProviderConfigNotifications: Bool = !SettingsStore.isRunningTests)
+    {
+        self.init(
+            store: store,
+            settings: settings,
+            account: account,
+            updater: updater,
+            preferencesSelection: preferencesSelection,
+            managedCodexAccountCoordinator: ManagedCodexAccountCoordinator(),
+            codexAccountPromotionCoordinator: nil,
+            statusBar: statusBar,
+            menuCardRenderingEnabled: menuCardRenderingEnabled,
+            menuRefreshEnabled: menuRefreshEnabled,
+            observeProviderConfigNotifications: observeProviderConfigNotifications)
+    }
+
     private func wireBindings() {
         self.observeStoreChanges()
+        self.observeStoreIconChanges()
+        self.observeIconPerfRefreshCycleChanges()
         self.observeDebugForceAnimation()
         self.observeSettingsChanges()
         self.observeUpdaterChanges()
+        self.observeManagedCodexCoordinatorChanges()
     }
 
     private func observeStoreChanges() {
@@ -210,10 +505,41 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin
         } onChange: { [weak self] in
             Task { @MainActor [weak self] in
                 guard let self else { return }
-                self.observeStoreChanges()
-                self.invalidateMenus()
-                self.updateIcons()
-                self.updateBlinkingState()
+                self.handleObservedStoreMenuChange()
+            }
+        }
+    }
+
+    func handleObservedStoreMenuChange() {
+        self.observeStoreChanges()
+        self.updatePersistentRefreshItemsEnabled()
+        let rootOpenHandledReadiness = self.consumeRootOpenHandledMenuObservationIfNeeded()
+        // `refreshOpenMenus` is only consulted when a menu is currently open.
+        // Computing the readiness signature serializes every enabled provider's
+        // token snapshot and 30-day daily breakdown, which is wasted main-thread
+        // work on the common path where no menu is open (background refresh ticks).
+        let refreshOpenMenus = self.openMenus.isEmpty
+            ? false
+            : rootOpenHandledReadiness || self.didMenuAdjunctReadinessChange()
+        self.invalidateMenus(
+            refreshOpenMenus: refreshOpenMenus,
+            deferOpenParentMenuRebuild: true,
+            allowStaleContentDuringDataRefresh: true)
+        self.completeParentMenuRebuildAfterHostedSubviewCloseIfNeeded()
+    }
+
+    private func observeStoreIconChanges() {
+        withObservationTracking {
+            _ = self.store.iconObservationToken
+        } onChange: { [weak self] in
+            Task { @MainActor [weak self] in
+                guard let self else { return }
+                self.observeStoreIconChanges()
+                let signature = self.storeIconObservationSignature()
+                guard signature != self.lastObservedStoreIconWorkSignature else { return }
+                // Reuse the signature we just computed for the change check; `updateIcons` would
+                // otherwise recompute the identical value on the same main-actor turn.
+                self.updateIcons(precomputedStoreIconSignature: signature)
             }
         }
     }
@@ -248,6 +574,9 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin
     }
 
     @objc private func handleProviderConfigDidChange(_ notification: Notification) {
+        #if DEBUG
+        guard !self.isReleasedForTesting else { return }
+        #endif
         let reason = notification.userInfo?["reason"] as? String ?? "unknown"
         if let source = notification.object as? SettingsStore,
            source !== self.settings
@@ -261,6 +590,11 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin
         self.handleProviderConfigChange(reason: "notification:\(reason)")
     }
 
+    @objc private func handleQuotaWarningPosted(_ notification: Notification) {
+        guard let event = notification.object as? QuotaWarningPostedEvent else { return }
+        self.startQuotaWarningFlash(provider: event.provider, postedAt: event.postedAt)
+    }
+
     private func observeUpdaterChanges() {
         withObservationTracking {
             _ = self.updater.updateStatus.isUpdateReady
@@ -273,17 +607,20 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin
         }
     }
 
-    private func invalidateMenus() {
-        self.menuContentVersion &+= 1
-        // Don't refresh menus while they're open - wait until they close and reopen
-        // This prevents expensive rebuilds while user is navigating the menu
-        guard self.openMenus.isEmpty else { return }
-        self.refreshOpenMenusIfNeeded()
-        Task { @MainActor in
-            // AppKit can ignore menu mutations while tracking; retry on the next run loop.
-            await Task.yield()
-            guard self.openMenus.isEmpty else { return }
-            self.refreshOpenMenusIfNeeded()
+    private func observeManagedCodexCoordinatorChanges() {
+        withObservationTracking {
+            _ = self.managedCodexAccountCoordinator.isAuthenticatingManagedAccount
+            _ = self.managedCodexAccountCoordinator.authenticatingManagedAccountID
+            _ = self.managedCodexAccountCoordinator.isRemovingManagedAccount
+            _ = self.managedCodexAccountCoordinator.removingManagedAccountID
+            _ = self.codexAccountPromotionCoordinator.isAuthenticatingLiveAccount
+            _ = self.codexAccountPromotionCoordinator.isPromotingSystemAccount
+        } onChange: { [weak self] in
+            Task { @MainActor [weak self] in
+                guard let self else { return }
+                self.observeManagedCodexCoordinatorChanges()
+                self.refreshMenusForLoginStateChange()
+            }
         }
     }
 
@@ -314,12 +651,19 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin
             self.lastObservedUsageBarsShowUsed = usageBarsShowUsed
             shouldRefresh = true
         }
+        if self.menuLocalizationSignature() != self.lastMenuLocalizationSignature {
+            shouldRefresh = true
+        }
         return shouldRefresh
     }
 
     private func handleSettingsChange(reason: String) {
+        #if DEBUG
+        guard !self.isReleasedForTesting else { return }
+        #endif
         let configChanged = self.settings.configRevision != self.lastConfigRevision
         let orderChanged = self.settings.providerOrder != self.lastProviderOrder
+        let localizationChanged = self.menuLocalizationSignature() != self.lastMenuLocalizationSignature
         let shouldRefreshOpenMenus = self.shouldRefreshOpenMenusForProviderSwitcher()
         self.invalidateMenus()
         if orderChanged || configChanged {
@@ -328,16 +672,45 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin
         self.updateVisibility()
         self.updateIcons()
         if shouldRefreshOpenMenus {
-            self.refreshOpenMenusIfNeeded()
+            self.refreshOpenMenusAllowingParentRebuild(
+                deferParentRebuildDuringTracking: !localizationChanged)
         }
     }
 
-    private func updateIcons() {
+    /// Updates the menu bar icons.
+    ///
+    /// The store-icon observer already computes `storeIconObservationSignature()` to decide whether any
+    /// icon work is needed, so it passes that value in via `precomputedStoreIconSignature` to avoid
+    /// recomputing the identical signature on the same main-actor turn. Other callers omit it and let the
+    /// signature refresh here, keeping `lastObservedStoreIconWorkSignature` current as the change gate.
+    func updateIcons(precomputedStoreIconSignature: String? = nil) {
+        #if DEBUG
+        guard !self.isReleasedForTesting else { return }
+        #endif
+        MainThreadActivityBreadcrumb.push("updateIcons")
+        self.scheduleMenuBarCountdownRefreshIfNeeded()
+        self.lastObservedStoreIconWorkSignature = precomputedStoreIconSignature ?? self.storeIconObservationSignature()
+        self.beginIconPerfUpdatePass()
+        defer {
+            self.endIconPerfUpdatePass()
+            MainThreadActivityBreadcrumb.pop()
+        }
         // Avoid flicker: when an animation driver is active, store updates can call `updateIcons()` and
         // briefly overwrite the animated frame with the static (phase=nil) icon.
         let phase: Double? = self.needsMenuBarIconAnimation() ? self.animationPhase : nil
         if self.shouldMergeIcons {
-            self.applyIcon(phase: phase)
+            let skippedMergedRender = self.applyIcon(phase: phase)
+            if skippedMergedRender,
+               !self.deferredMergedIconRenderAfterTracking,
+               self.mergedMenu != nil
+            {
+                return
+            }
+            guard !self.isMergedMenuOpen else {
+                self.updateAnimationState()
+                self.updateBlinkingState()
+                return
+            }
             self.attachMenus()
         } else {
             UsageProvider.allCases.forEach { self.applyIcon(for: $0, phase: phase) }
@@ -347,38 +720,69 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin
         self.updateBlinkingState()
     }
 
+    var isMergedMenuOpen: Bool {
+        guard let mergedMenu else { return false }
+        return self.openMenus[ObjectIdentifier(mergedMenu)] != nil
+    }
+
     /// Lazily retrieves or creates a status item for the given provider
     func lazyStatusItem(for provider: UsageProvider) -> NSStatusItem {
         if let existing = self.statusItems[provider] {
             return existing
         }
-        let item = self.statusBar.statusItem(withLength: NSStatusItem.variableLength)
-        item.button?.imageScaling = .scaleNone
+        let item = Self.makeStatusItem(
+            statusBar: self.statusBar,
+            identity: .provider(provider),
+            defaults: self.settings.userDefaults,
+            legacyDefaultItemIndex: self.legacyDefaultItemIndex(forNewProvider: provider))
         self.statusItems[provider] = item
         return item
     }
 
+    func recreateStatusItemsForVisibilityRecovery() {
+        #if DEBUG
+        guard !self.isReleasedForTesting else { return }
+        #endif
+        self.statusItem.menu = nil
+        self.statusBar.removeStatusItem(self.statusItem)
+        self.statusItem = Self.makeStatusItem(
+            statusBar: self.statusBar,
+            identity: .merged,
+            defaults: self.settings.userDefaults,
+            legacyDefaultItemIndex: Self.mergedLegacyDefaultItemIndex)
+        for provider in Array(self.statusItems.keys) {
+            self.removeProviderStatusItem(for: provider)
+        }
+        self.lastAppliedMergedIconRenderSignature = nil
+        self.lastAppliedProviderIconRenderSignatures.removeAll()
+        self.updateVisibility()
+        self.updateIcons()
+    }
+
     private func updateVisibility() {
-        let anyEnabled = !self.store.enabledProviders().isEmpty
+        #if DEBUG
+        guard !self.isReleasedForTesting else { return }
+        #endif
+        let anyEnabled = !self.store.enabledProvidersForDisplay().isEmpty
         let force = self.store.debugForceAnimation
         let mergeIcons = self.shouldMergeIcons
         if mergeIcons {
             self.statusItem.isVisible = anyEnabled || force
-            for item in self.statusItems.values {
-                item.isVisible = false
+            for provider in Array(self.statusItems.keys) {
+                self.removeProviderStatusItem(for: provider)
             }
             self.attachMenus()
         } else {
             self.statusItem.isVisible = false
             let fallback = self.fallbackProvider
-            for provider in UsageProvider.allCases {
+            for provider in self.settings.orderedProviders() {
                 let isEnabled = self.isEnabled(provider)
                 let shouldBeVisible = isEnabled || fallback == provider || force
                 if shouldBeVisible {
                     let item = self.lazyStatusItem(for: provider)
                     item.isVisible = true
-                } else if let item = self.statusItems[provider] {
-                    item.isVisible = false
+                } else {
+                    self.removeProviderStatusItem(for: provider)
                 }
             }
             self.attachMenus(fallback: fallback)
@@ -388,6 +792,8 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin
     }
 
     var fallbackProvider: UsageProvider? {
+        // Intentionally uses availability-filtered list: fallback activates when no provider
+        // can actually work, ensuring at least a codex icon is always visible.
         self.store.enabledProviders().isEmpty ? .codex : nil
     }
 
@@ -396,8 +802,12 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin
     }
 
     private func refreshMenusForLoginStateChange() {
+        #if DEBUG
+        guard !self.isReleasedForTesting else { return }
+        #endif
         self.invalidateMenus()
         if self.shouldMergeIcons {
+            guard !self.isMergedMenuOpen else { return }
             self.attachMenus()
         } else {
             self.attachMenus(fallback: self.fallbackProvider)
@@ -411,6 +821,7 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin
         if self.statusItem.menu !== self.mergedMenu {
             self.statusItem.menu = self.mergedMenu
         }
+        self.prepareAttachedClosedMenusIfNeeded()
     }
 
     private func attachMenus(fallback: UsageProvider? = nil) {
@@ -438,37 +849,58 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin
                     }
                 }
             } else if let item = self.statusItems[provider] {
-                // Item exists but is no longer needed - clear its menu
-                if item.menu != nil {
-                    item.menu = nil
-                }
+                item.menu = nil
             }
         }
+        self.prepareAttachedClosedMenusIfNeeded()
     }
 
     private func rebuildProviderStatusItems() {
-        for item in self.statusItems.values {
-            self.statusBar.removeStatusItem(item)
+        #if DEBUG
+        guard !self.isReleasedForTesting else { return }
+        #endif
+        let ordered = self.settings.orderedProviders()
+        let desired = Set(ordered)
+        for provider in Array(self.statusItems.keys) where !desired.contains(provider) {
+            self.removeProviderStatusItem(for: provider)
         }
-        self.statusItems.removeAll(keepingCapacity: true)
 
-        for provider in self.settings.orderedProviders() {
-            let item = self.statusBar.statusItem(withLength: NSStatusItem.variableLength)
-            item.button?.imageScaling = .scaleNone
-            self.statusItems[provider] = item
+        guard !self.shouldMergeIcons else { return }
+        let fallback = self.fallbackProvider
+        let force = self.store.debugForceAnimation
+        for provider in ordered where self.isEnabled(provider) || fallback == provider || force {
+            _ = self.lazyStatusItem(for: provider)
+        }
+    }
+
+    private func removeProviderStatusItem(for provider: UsageProvider) {
+        if let menu = self.providerMenus.removeValue(forKey: provider) {
+            let menuID = ObjectIdentifier(menu)
+            if menuID == self.providerSwitcherShortcutMenuID {
+                self.removeProviderSwitcherShortcutMonitor()
+            }
+            self.clearMergedSwitcherContentCache(for: menu)
+            self.removeMenuLifecycleState(menuID)
         }
+
+        guard let item = self.statusItems.removeValue(forKey: provider) else { return }
+        item.menu = nil
+        self.lastAppliedProviderIconRenderSignatures.removeValue(forKey: provider)
+        self.statusBar.removeStatusItem(item)
     }
 
     func isVisible(_ provider: UsageProvider) -> Bool {
-        self.store.debugForceAnimation || self.isEnabled(provider) || self.fallbackProvider == provider
+        self.store.debugForceAnimation || self.isEnabled(provider)
+            || self.fallbackProvider == provider
     }
 
     var shouldMergeIcons: Bool {
-        self.settings.mergeIcons && self.store.enabledProviders().count > 1
+        self.settings.mergeIcons && self.store.enabledProvidersForDisplay().count > 1
     }
 
     func switchAccountSubtitle(for target: UsageProvider) -> String? {
-        guard self.loginTask != nil, let provider = self.activeLoginProvider, provider == target else { return nil }
+        guard self.loginTask != nil, let provider = self.activeLoginProvider, provider == target
+        else { return nil }
         let base: String
         switch self.loginPhase {
         case .idle: return nil
@@ -480,8 +912,89 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin
     }
 
     deinit {
+        let animationDriver = self.animationDriver
+        Task { @MainActor in
+            animationDriver?.stop()
+        }
         self.blinkTask?.cancel()
+        self.menuBarCountdownRefreshTask?.cancel()
         self.loginTask?.cancel()
+        self.screenChangeVisibilityTask?.cancel()
+        self.pendingScreenChangePreviousCount = nil
         NotificationCenter.default.removeObserver(self)
     }
 }
+
+#if DEBUG
+extension StatusItemController {
+    var menuContentVersion: Int {
+        get { self.menuSession.contentVersion }
+        set { self.menuSession.replaceContentVersionForTesting(newValue) }
+    }
+
+    var latestRequiredMenuRebuildVersion: Int {
+        self.menuSession.latestRequiredRebuildVersion
+    }
+
+    var latestDataOnlyMenuContentVersion: Int {
+        self.menuSession.latestDataOnlyContentVersion
+    }
+
+    var latestStructuralMenuContentVersion: Int {
+        self.menuSession.latestStructuralContentVersion
+    }
+
+    var menuVersions: [ObjectIdentifier: Int] {
+        get { self.menuSession.renderedVersions }
+        set { self.menuSession.replaceRenderedVersionsForTesting(newValue) }
+    }
+
+    var closedMenusDeferredUntilNextOpen: Set<ObjectIdentifier> {
+        get { self.menuSession.deferredUntilNextOpen }
+        set { self.menuSession.replaceDeferredMenusForTesting(newValue) }
+    }
+
+    var parentMenuRebuildsDeferredDuringTracking: Set<ObjectIdentifier> {
+        self.menuSession.parentRebuildsDeferredDuringTracking
+    }
+
+    var closedMenuRebuildTokens: [ObjectIdentifier: Int] {
+        self.closedMenuRebuildRequests.tokens
+    }
+}
+#endif
+
+#if DEBUG
+extension StatusItemController {
+    static func setMenuRefreshEnabledForTesting(_ enabled: Bool) {
+        self.menuRefreshEnabled = enabled
+    }
+
+    static func resetMenuRefreshEnabledForTesting() {
+        self.menuRefreshEnabled = self.defaultMenuRefreshEnabled
+    }
+}
+#endif
+
+extension StatusItemController {
+    private func legacyDefaultItemIndex(forNewProvider provider: UsageProvider) -> Int? {
+        let visibleProviders = self.settings.orderedProviders().filter { self.isVisible($0) }
+        guard let providerOffset = visibleProviders.firstIndex(of: provider) else { return nil }
+        return Self.mergedLegacyDefaultItemIndex + 1 + providerOffset
+    }
+
+    func refreshExistingStatusItemsForVisibilityRecovery() {
+        #if DEBUG
+        guard !self.isReleasedForTesting else { return }
+        #endif
+        let visibleItems = ([self.statusItem] + Array(self.statusItems.values)).filter(\.isVisible)
+        for item in visibleItems {
+            item.isVisible = false
+        }
+        for item in visibleItems {
+            item.isVisible = true
+        }
+        self.updateVisibility()
+        self.updateIcons()
+    }
+}
diff --git a/Sources/CodexBar/StatusItemMenu.swift b/Sources/CodexBar/StatusItemMenu.swift
new file mode 100644
index 0000000000..d9c899e464
--- /dev/null
+++ b/Sources/CodexBar/StatusItemMenu.swift
@@ -0,0 +1,93 @@
+import AppKit
+
+enum StatusItemMenuProviderNavigationDirection {
+    case previous
+    case next
+}
+
+protocol StatusItemMenuPersistentActionDelegate: AnyObject {
+    func performPersistentRefreshAction(in menuID: ObjectIdentifier)
+    func performPersistentSettingsAction()
+    func performPersistentQuitAction()
+    func performProviderNavigation(_ direction: StatusItemMenuProviderNavigationDirection)
+}
+
+final class StatusItemMenu: NSMenu {
+    weak var persistentActionDelegate: StatusItemMenuPersistentActionDelegate?
+
+    override func performKeyEquivalent(with event: NSEvent) -> Bool {
+        if let action = Self.persistentAction(for: event) {
+            switch action {
+            case .refresh:
+                self.persistentActionDelegate?.performPersistentRefreshAction(in: ObjectIdentifier(self))
+            case .settings:
+                self.persistentActionDelegate?.performPersistentSettingsAction()
+            case .quit:
+                self.persistentActionDelegate?.performPersistentQuitAction()
+            }
+            return true
+        }
+        if let direction = Self.providerNavigationDirection(for: event),
+           self.items.first?.view is ProviderSwitcherView
+        {
+            self.persistentActionDelegate?.performProviderNavigation(direction)
+            return true
+        }
+
+        return super.performKeyEquivalent(with: event)
+    }
+
+    private enum PersistentAction {
+        case refresh
+        case settings
+        case quit
+    }
+
+    private nonisolated static func persistentAction(for event: NSEvent) -> PersistentAction? {
+        guard event.type == .keyDown else { return nil }
+
+        let relevantModifiers = event.modifierFlags.intersection([.command, .option, .control, .shift])
+        guard relevantModifiers == .command else { return nil }
+
+        switch event.charactersIgnoringModifiers?.lowercased() {
+        case "r":
+            return .refresh
+        case ",":
+            return .settings
+        case "q":
+            return .quit
+        default:
+            return nil
+        }
+    }
+
+    nonisolated static func providerNavigationDirection(
+        for event: NSEvent) -> StatusItemMenuProviderNavigationDirection?
+    {
+        guard event.type == .keyDown else { return nil }
+        let relevantModifiers = event.modifierFlags.intersection([.command, .option, .control, .shift])
+        guard relevantModifiers.isEmpty else { return nil }
+        switch event.keyCode {
+        case 123:
+            return .previous
+        case 124:
+            return .next
+        default:
+            return nil
+        }
+    }
+
+    nonisolated static func providerSelectionIndex(for event: NSEvent) -> Int? {
+        guard event.type == .keyDown else { return nil }
+        let relevantModifiers = event.modifierFlags.intersection([.command, .option, .control, .shift])
+        guard relevantModifiers == .command,
+              let characters = event.charactersIgnoringModifiers,
+              characters.count == 1,
+              let number = Int(characters),
+              (1...9).contains(number)
+        else {
+            return nil
+        }
+        return number - 1
+    }
+}
diff --git a/Sources/CodexBar/StorageBreakdownMenuView.swift b/Sources/CodexBar/StorageBreakdownMenuView.swift
new file mode 100644
index 0000000000..94de6a1fe8
--- /dev/null
+++ b/Sources/CodexBar/StorageBreakdownMenuView.swift
@@ -0,0 +1,367 @@
+import AppKit
+import CodexBarCore
+import SwiftUI
+
+struct StorageBreakdownMenuView: View {
+    let footprint: ProviderStorageFootprint
+    let width: CGFloat
+    let maxHeight: CGFloat
+    let onExpansionHeightChange: ((CGFloat) -> Void)?
+
+    @State private var otherExpanded = false
+
+    init(
+        footprint: ProviderStorageFootprint,
+        width: CGFloat,
+        maxHeight: CGFloat = 560,
+        onExpansionHeightChange: ((CGFloat) -> Void)? = nil)
+    {
+        self.footprint = footprint
+        self.width = width
+        self.maxHeight = maxHeight
+        self.onExpansionHeightChange = onExpansionHeightChange
+    }
+
+    /// One entry in the segmented bar and its matching legend row. Overflow components past the row
+    /// budget collapse into a single trailing "Other" segment with no copyable path of its own.
+    private struct Segment: Identifiable {
+        let id: String
+        let name: String
+        let bytes: Int64
+        let color: Color
+        let path: String?
+    }
+
+    /// How many legend rows we let the breakdown show before collapsing the tail into "Other".
+    private static let maxRows = 8
+
+    private static let segmentPalette: [Color] = [
+        Color(red: 0.20, green: 0.51, blue: 0.96),
+        Color(red: 0.96, green: 0.55, blue: 0.20),
+        Color(red: 0.30, green: 0.78, blue: 0.47),
+        Color(red: 0.66, green: 0.42, blue: 0.93),
+        Color(red: 0.95, green: 0.74, blue: 0.22),
+        Color(red: 0.92, green: 0.36, blue: 0.55),
+        Color(red: 0.27, green: 0.76, blue: 0.82),
+    ]
+
+    private static let otherColor = Color(nsColor: .tertiaryLabelColor)
+    private static let overflowRowHeight: CGFloat = 18
+    private static let overflowRowSpacing: CGFloat = 4
+    private static let overflowTopSpacing: CGFloat = 6
+
+    var cleanupRecommendations: [ProviderStorageRecommendation] {
+        self.footprint.cleanupRecommendations
+    }
+
+    var copyablePaths: [String] {
+        let recommendationPaths = self.cleanupRecommendations.map(\.path)
+        return self.footprint.components.map(\.path) + recommendationPaths
+    }
+
+    /// Visible components mapped to colored segments, with any tail beyond `maxRows` folded into a
+    /// single "Other" entry so the bar and legend never exceed the row budget.
+    private var segments: [Segment] {
+        let components = self.footprint.components
+        guard !components.isEmpty else { return [] }
+
+        func color(_ index: Int) -> Color {
+            Self.segmentPalette[index % Self.segmentPalette.count]
+        }
+
+        func segment(_ component: ProviderStorageFootprint.Component, _ index: Int) -> Segment {
+            Segment(
+                id: component.id,
+                name: component.name,
+                bytes: max(component.totalBytes, 0),
+                color: color(index),
+                path: component.path)
+        }
+
+        if components.count <= Self.maxRows {
+            return components.enumerated().map { segment($1, $0) }
+        }
+
+        let visible = components.prefix(Self.maxRows - 1)
+        let overflow = components.dropFirst(Self.maxRows - 1)
+        let otherBytes = overflow.reduce(Int64(0)) { partial, component in
+            let bytes = max(component.totalBytes, 0)
+            let (sum, overflowed) = partial.addingReportingOverflow(bytes)
+            return overflowed ? .max : sum
+        }
+        return visible.enumerated().map { segment($1, $0) } + [
+            Segment(
+                id: "__other__",
+                name: String(format: L("Other (%d items)"), overflow.count),
+                bytes: otherBytes,
+                color: Self.otherColor,
+                path: nil),
+        ]
+    }
+
+    private var segmentTotalBytes: Double {
+        self.segments.reduce(0) { $0 + Double($1.bytes) }
+    }
+
+    /// The components folded into the trailing "Other" segment, revealed when it is expanded.
+    private var overflowComponents: [ProviderStorageFootprint.Component] {
+        let components = self.footprint.components
+        guard components.count > Self.maxRows else { return [] }
+        return Array(components.dropFirst(Self.maxRows - 1))
+    }
+
+    private var overflowExpansionHeight: CGFloat {
+        let count = CGFloat(self.overflowComponents.count)
+        guard count > 0 else { return 0 }
+        return Self.overflowTopSpacing
+            + count * Self.overflowRowHeight
+            + (count - 1) * Self.overflowRowSpacing
+    }
+
+    var body: some View {
+        ScrollView(.vertical) {
+            self.content
+        }
+        .scrollIndicators(.visible)
+        .frame(
+            minWidth: self.width,
+            idealWidth: self.width,
+            maxWidth: self.width,
+            maxHeight: self.maxHeight,
+            alignment: .topLeading)
+    }
+
+    private var content: some View {
+        VStack(alignment: .leading, spacing: 10) {
+            VStack(alignment: .leading, spacing: 3) {
+                Text(L("Storage"))
+                    .font(.body)
+                    .fontWeight(.medium)
+                Text(String(format: L("Total: %@"), UsageFormatter.byteCountStringLong(self.footprint.totalBytes)))
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+            }
+
+            if self.segments.isEmpty {
+                Text(L("No local data found"))
+                    .font(.footnote)
+                    .foregroundStyle(.secondary)
+            } else {
+                self.segmentedBar
+                VStack(alignment: .leading, spacing: 6) {
+                    ForEach(self.segments) { segment in
+                        self.legendRow(segment)
+                    }
+                }
+            }
+
+            if !self.cleanupRecommendations.isEmpty {
+                Divider()
+                    .padding(.vertical, 2)
+                VStack(alignment: .leading, spacing: 8) {
+                    Text(L("Cleanup ideas"))
+                        .font(.body)
+                        .fontWeight(.medium)
+                    ForEach(self.cleanupRecommendations) { recommendation in
+                        self.recommendationRow(recommendation)
+                    }
+                }
+            }
+            if !self.footprint.unreadablePaths.isEmpty {
+                Text(String(format: L("%d unreadable item(s) skipped"), self.footprint.unreadablePaths.count))
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+            }
+        }
+        .padding(.horizontal, 16)
+        .padding(.vertical, 10)
+        .frame(width: self.width, alignment: .leading)
+    }
+
+    private var segmentedBar: some View {
+        GeometryReader { proxy in
+            ZStack(alignment: .leading) {
+                Capsule()
+                    .fill(Color(nsColor: .quaternaryLabelColor))
+                HStack(spacing: 0) {
+                    ForEach(self.segments) { segment in
+                        Rectangle()
+                            .fill(segment.color)
+                            .frame(width: self.segmentWidth(segment, barWidth: proxy.size.width))
+                    }
+                }
+            }
+            .clipShape(Capsule())
+        }
+        .frame(height: 5)
+    }
+
+    /// Each segment gets at least `minWidth` so tiny components stay visible, with the remaining width
+    /// shared by byte proportion. Reserving the minimums (rather than flooring each width with `max`)
+    /// keeps the segments summing to exactly `barWidth`, so none get clipped off the capsule's end.
+    private func segmentWidth(_ segment: Segment, barWidth: CGFloat) -> CGFloat {
+        let minWidth: CGFloat = 2
+        let count = CGFloat(self.segments.count)
+        guard self.segmentTotalBytes > 0 else { return barWidth / max(count, 1) }
+        let reserved = minWidth * count
+        guard barWidth > reserved else { return barWidth / max(count, 1) }
+        let remainder = barWidth - reserved
+        let proportion = CGFloat(Double(segment.bytes) / self.segmentTotalBytes)
+        return minWidth + remainder * proportion
+    }
+
+    private func legendRow(_ segment: Segment) -> some View {
+        let isOther = segment.path == nil
+        return VStack(alignment: .leading, spacing: 6) {
+            HStack(spacing: 8) {
+                Circle()
+                    .fill(segment.color)
+                    .frame(width: 9, height: 9)
+                Text(segment.name)
+                    .font(.caption)
+                    .foregroundStyle(.primary)
+                    .lineLimit(1)
+                    .truncationMode(.middle)
+                    .help(segment.path ?? segment.name)
+                    .layoutPriority(1)
+                Spacer()
+                if let path = segment.path {
+                    StoragePathCopyButton(path: path)
+                } else {
+                    self.otherExpandButton
+                }
+                Text(UsageFormatter.byteCountString(segment.bytes))
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+                    .lineLimit(1)
+            }
+            if isOther, self.otherExpanded {
+                self.overflowList
+            }
+        }
+    }
+
+    private var otherExpandButton: some View {
+        Button {
+            self.otherExpanded.toggle()
+            self.onExpansionHeightChange?(self.otherExpanded ? self.overflowExpansionHeight : 0)
+        } label: {
+            Image(systemName: self.otherExpanded ? "chevron.down" : "chevron.right")
+                .font(.caption2.weight(.semibold))
+                .foregroundStyle(.secondary)
+                .frame(width: 18, height: 18)
+                .contentShape(Rectangle())
+        }
+        .buttonStyle(.plain)
+        .help(self.otherExpanded ? L("Collapse") : L("Expand"))
+        .accessibilityLabel(self.otherExpanded ? L("Collapse") : L("Expand"))
+    }
+
+    /// Plain name + size rows for the items folded into "Other" — no colors, indented under its name.
+    private var overflowList: some View {
+        VStack(alignment: .leading, spacing: 4) {
+            ForEach(self.overflowComponents) { component in
+                HStack(spacing: 8) {
+                    Text(component.name)
+                        .font(.caption)
+                        .foregroundStyle(.secondary)
+                        .lineLimit(1)
+                        .truncationMode(.middle)
+                        .help(component.path)
+                    Spacer()
+                    StoragePathCopyButton(path: component.path)
+                    Text(UsageFormatter.byteCountString(component.totalBytes))
+                        .font(.caption)
+                        .foregroundStyle(.secondary)
+                        .lineLimit(1)
+                }
+            }
+        }
+        .padding(.leading, 17)
+    }
+
+    private func recommendationRow(_ recommendation: ProviderStorageRecommendation) -> some View {
+        VStack(alignment: .leading, spacing: 3) {
+            HStack(alignment: .firstTextBaseline) {
+                Text(L(recommendation.title))
+                    .font(.caption)
+                    .fontWeight(.medium)
+                    .lineLimit(1)
+                Spacer()
+                Text(UsageFormatter.byteCountString(recommendation.bytes))
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+                    .lineLimit(1)
+            }
+            HStack(spacing: 4) {
+                Text(recommendation.path)
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+                    .lineLimit(1)
+                    .truncationMode(.middle)
+                    .help(recommendation.path)
+                    .layoutPriority(1)
+                Spacer()
+                StoragePathCopyButton(path: recommendation.path)
+            }
+            Text(L(recommendation.consequence))
+                .font(.caption)
+                .foregroundStyle(.secondary)
+                .lineLimit(3)
+                .fixedSize(horizontal: false, vertical: true)
+        }
+    }
+}
+
+#if DEBUG
+extension StorageBreakdownMenuView {
+    var _segmentNamesForTesting: [String] {
+        self.segments.map(\.name)
+    }
+
+    var _segmentBytesForTesting: [Int64] {
+        self.segments.map(\.bytes)
+    }
+
+    var _overflowNamesForTesting: [String] {
+        self.overflowComponents.map(\.name)
+    }
+
+    var _overflowExpansionHeightForTesting: CGFloat {
+        self.overflowExpansionHeight
+    }
+
+    func _segmentWidthsForTesting(barWidth: CGFloat) -> [CGFloat] {
+        self.segments.map { self.segmentWidth($0, barWidth: barWidth) }
+    }
+}
+#endif
+
+struct StoragePathCopyButton: View {
+    let path: String
+
+    @State private var didCopy = false
+    @State private var resetTask: Task<Void, Never>?
+
+    var body: some View {
+        Button {
+            self.resetTask?.cancel()
+            MenuPasteboardCopy.perform(self.path, completion: {
+                self.didCopy = true
+                self.resetTask = Task { @MainActor in
+                    try? await Task.sleep(for: .seconds(0.9))
+                    self.didCopy = false
+                }
+            })
+        } label: {
+            Image(systemName: self.didCopy ? "checkmark" : "doc.on.doc")
+                .font(.caption2.weight(.semibold))
+                .foregroundStyle(.secondary)
+                .frame(width: 18, height: 18)
+                .contentShape(Rectangle())
+        }
+        .buttonStyle(.plain)
+        .help(self.didCopy ? L("Copied") : L("Copy path"))
+        .accessibilityLabel(self.didCopy ? L("Copied") : L("Copy path"))
+    }
+}
diff --git a/Sources/CodexBar/TerminalApp.swift b/Sources/CodexBar/TerminalApp.swift
new file mode 100644
index 0000000000..2db1fdd524
--- /dev/null
+++ b/Sources/CodexBar/TerminalApp.swift
@@ -0,0 +1,57 @@
+import AppKit
+
+enum TerminalApp: String, CaseIterable, Identifiable {
+    case terminal
+    case iTerm
+
+    var id: String {
+        self.rawValue
+    }
+
+    var label: String {
+        switch self {
+        case .terminal: "Terminal"
+        case .iTerm: "iTerm"
+        }
+    }
+
+    var bundleIdentifier: String {
+        switch self {
+        case .terminal: "com.apple.Terminal"
+        case .iTerm: "com.googlecode.iterm2"
+        }
+    }
+
+    var isInstalled: Bool {
+        NSWorkspace.shared.urlForApplication(withBundleIdentifier: self.bundleIdentifier) != nil
+    }
+
+    func appleScript(command: String) -> String {
+        let escaped = Self.escapeForAppleScript(command)
+        return switch self {
+        case .terminal:
+            """
+            tell application "Terminal"
+                activate
+                do script "\(escaped)"
+            end tell
+            """
+        case .iTerm:
+            """
+            tell application "iTerm"
+                activate
+                set newWindow to (create window with default profile)
+                tell current session of newWindow
+                    write text "\(escaped)"
+                end tell
+            end tell
+            """
+        }
+    }
+
+    static func escapeForAppleScript(_ command: String) -> String {
+        command
+            .replacingOccurrences(of: "\\", with: "\\\\")
+            .replacingOccurrences(of: "\"", with: "\\\"")
+    }
+}
diff --git a/Sources/CodexBar/UpdateChannel.swift b/Sources/CodexBar/UpdateChannel.swift
index d2b0a74df6..aabf87bc6b 100644
--- a/Sources/CodexBar/UpdateChannel.swift
+++ b/Sources/CodexBar/UpdateChannel.swift
@@ -1,6 +1,6 @@
 import Foundation
 
-enum UpdateChannel: String, CaseIterable, Codable, Sendable {
+enum UpdateChannel: String, CaseIterable, Codable {
     case stable
     case beta
 
diff --git a/Sources/CodexBar/UsageBreakdownChartMenuView.swift b/Sources/CodexBar/UsageBreakdownChartMenuView.swift
index ee0ccaa65f..83a31f30d0 100644
--- a/Sources/CodexBar/UsageBreakdownChartMenuView.swift
+++ b/Sources/CodexBar/UsageBreakdownChartMenuView.swift
@@ -31,23 +31,24 @@ struct UsageBreakdownChartMenuView: View {
         let model = Self.makeModel(from: self.breakdown)
         VStack(alignment: .leading, spacing: 10) {
             if model.points.isEmpty {
-                Text("No usage breakdown data.")
+                Text(L("No usage breakdown data."))
                     .font(.footnote)
                     .foregroundStyle(.secondary)
+                    .accessibilityLabel(L("No usage breakdown data available."))
             } else {
                 Chart {
                     ForEach(model.points) { point in
                         BarMark(
-                            x: .value("Day", point.date, unit: .day),
-                            y: .value("Credits used", point.creditsUsed))
-                            .foregroundStyle(by: .value("Service", point.service))
+                            x: .value(L("Day"), point.date, unit: .day),
+                            y: .value(L("Credits used"), point.creditsUsed))
+                            .foregroundStyle(by: .value(L("Service"), point.service))
                     }
                     if let peak = model.peakPoint {
                         let capStart = max(peak.creditsUsed - Self.capHeight(maxValue: model.maxCreditsUsed), 0)
                         BarMark(
-                            x: .value("Day", peak.date, unit: .day),
-                            yStart: .value("Cap start", capStart),
-                            yEnd: .value("Cap end", peak.creditsUsed))
+                            x: .value(L("Day"), peak.date, unit: .day),
+                            yStart: .value(L("Cap start"), capStart),
+                            yEnd: .value(L("Cap end"), peak.creditsUsed))
                             .foregroundStyle(Color(nsColor: .systemYellow))
                     }
                 }
@@ -64,6 +65,14 @@ struct UsageBreakdownChartMenuView: View {
                 }
                 .chartLegend(.hidden)
                 .frame(height: 130)
+                .accessibilityLabel(L("Usage breakdown chart"))
+                .accessibilityValue(
+                    model.points.isEmpty
+                        ? L("No data")
+                        : String(
+                            format: L("%d days of usage data across %d services"),
+                            model.points.count,
+                            model.services.count))
                 .chartOverlay { proxy in
                     GeometryReader { geo in
                         ZStack(alignment: .topLeading) {
@@ -146,7 +155,7 @@ struct UsageBreakdownChartMenuView: View {
     private static let selectionBandColor = Color(nsColor: .labelColor).opacity(0.1)
 
     private static func makeModel(from breakdown: [OpenAIDashboardDailyBreakdown]) -> Model {
-        let sorted = breakdown
+        let sorted = OpenAIDashboardDailyBreakdown.removingSkillUsageServices(from: breakdown)
             .sorted { lhs, rhs in lhs.day < rhs.day }
 
         var points: [Point] = []
@@ -282,14 +291,6 @@ struct UsageBreakdownChartMenuView: View {
         let date = model.dayDates[index].date
         guard let x = proxy.position(forX: date) else { return nil }
 
-        func xForIndex(_ idx: Int) -> CGFloat? {
-            guard idx >= 0, idx < model.dayDates.count else { return nil }
-            return proxy.position(forX: model.dayDates[idx].date)
-        }
-
-        let xPrev = xForIndex(index - 1)
-        let xNext = xForIndex(index + 1)
-
         if model.dayDates.count <= 1 {
             return CGRect(
                 x: plotFrame.origin.x,
@@ -298,24 +299,14 @@ struct UsageBreakdownChartMenuView: View {
                 height: plotFrame.height)
         }
 
-        let leftInPlot: CGFloat = if let xPrev {
-            (xPrev + x) / 2
-        } else if let xNext {
-            x - (xNext - x) / 2
-        } else {
-            x - 8
-        }
-
-        let rightInPlot: CGFloat = if let xNext {
-            (xNext + x) / 2
-        } else if let xPrev {
-            x + (x - xPrev) / 2
-        } else {
-            x + 8
-        }
+        // Use the calendar day slot width (always 1 day on the time axis) so the band is the
+        // same size for every bar regardless of gaps in the data.
+        let nextDayX = proxy.position(forX: ChartBarHoverSelection.nextCalendarDay(after: date)) ?? (x + 20)
+        let slotWidth = abs(nextDayX - x)
+        let barHalfWidth = slotWidth * 0.25 + 2
 
-        let left = plotFrame.origin.x + min(leftInPlot, rightInPlot)
-        let right = plotFrame.origin.x + max(leftInPlot, rightInPlot)
+        let left = plotFrame.origin.x + x - barHalfWidth
+        let right = plotFrame.origin.x + x + barHalfWidth
         return CGRect(x: left, y: plotFrame.origin.y, width: right - left, height: plotFrame.height)
     }
 
@@ -338,6 +329,24 @@ struct UsageBreakdownChartMenuView: View {
         guard let date: Date = proxy.value(atX: xInPlot) else { return }
         guard let nearest = self.nearestDayKey(to: date, model: model) else { return }
 
+        // Stay on the last selected bar when cursor is in the gap between bars; only switch
+        // selection when the cursor is over the bar's own visual body.
+        // Skip this gate for single-day charts: no gap exists, and selectionBandRect
+        // already covers the full plot width in that case.
+        if model.selectableDayDates.count > 1,
+           let nearestEntry = model.selectableDayDates.first(where: { $0.dayKey == nearest }),
+           let barX = proxy.position(forX: nearestEntry.date)
+        {
+            let nextDayX = proxy.position(forX: ChartBarHoverSelection.nextCalendarDay(after: nearestEntry.date)) ??
+                (barX + 20)
+            let slotWidth = abs(nextDayX - barX)
+            guard ChartBarHoverSelection.accepts(
+                distanceFromBarCenter: abs(location.x - (plotFrame.origin.x + barX)),
+                barHalfWidth: slotWidth * 0.25 + 2,
+                selectableCount: model.selectableDayDates.count)
+            else { return }
+        }
+
         if self.selectedDayKey != nearest {
             self.selectedDayKey = nearest
         }
@@ -362,7 +371,7 @@ struct UsageBreakdownChartMenuView: View {
               let day = model.breakdownByDayKey[key],
               let date = Self.dateFromDayKey(key)
         else {
-            return ("Hover a bar for details", nil)
+            return (L("Hover a bar for details"), nil)
         }
 
         let dayLabel = date.formatted(.dateTime.month(.abbreviated).day())
diff --git a/Sources/CodexBar/UsageMenuCardHeaderAndUsageSectionView.swift b/Sources/CodexBar/UsageMenuCardHeaderAndUsageSectionView.swift
new file mode 100644
index 0000000000..72e341d135
--- /dev/null
+++ b/Sources/CodexBar/UsageMenuCardHeaderAndUsageSectionView.swift
@@ -0,0 +1,23 @@
+import SwiftUI
+
+struct UsageMenuCardHeaderAndUsageSectionView: View {
+    let model: UsageMenuCardView.Model
+    let layoutModel: UsageMenuCardView.Model
+    let bottomPadding: CGFloat
+    let width: CGFloat
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 0) {
+            UsageMenuCardHeaderSectionView(
+                model: self.layoutModel,
+                showDivider: true,
+                width: self.width)
+            UsageMenuCardUsageSectionView(
+                model: self.model,
+                showBottomDivider: false,
+                bottomPadding: self.bottomPadding,
+                width: self.width)
+        }
+        .frame(width: self.width, alignment: .leading)
+    }
+}
diff --git a/Sources/CodexBar/UsageMenuCardLayout.swift b/Sources/CodexBar/UsageMenuCardLayout.swift
new file mode 100644
index 0000000000..8814a37cc6
--- /dev/null
+++ b/Sources/CodexBar/UsageMenuCardLayout.swift
@@ -0,0 +1,17 @@
+import CoreGraphics
+
+enum UsageMenuCardLayout {
+    static let horizontalPadding: CGFloat = 20
+    static let headerOnlyVerticalPadding: CGFloat = 6
+    static let headerContentSpacing: CGFloat = 6
+    static let sectionTopPadding: CGFloat = 6
+    static let usageSectionTopPadding: CGFloat = 10
+    static let sectionBottomPadding: CGFloat = 6
+    static let headerLineSpacing: CGFloat = 4
+    static let headerColumnSpacing: CGFloat = 12
+
+    static var postHeaderDividerContentSpacing: CGFloat {
+        // Reproduces Overview's header-bottom + usage-top gap so full cards align.
+        sectionBottomPadding + usageSectionTopPadding
+    }
+}
diff --git a/Sources/CodexBar/UsagePaceText.swift b/Sources/CodexBar/UsagePaceText.swift
index f533d636f0..5a57483109 100644
--- a/Sources/CodexBar/UsagePaceText.swift
+++ b/Sources/CodexBar/UsagePaceText.swift
@@ -2,25 +2,30 @@ import CodexBarCore
 import Foundation
 
 enum UsagePaceText {
-    struct WeeklyDetail: Sendable {
+    struct WeeklyDetail {
         let leftLabel: String
         let rightLabel: String?
         let expectedUsedPercent: Double
         let stage: UsagePace.Stage
     }
 
+    private enum DetailContext {
+        case session
+        case weekly
+    }
+
     static func weeklySummary(pace: UsagePace, now: Date = .init()) -> String {
         let detail = self.weeklyDetail(pace: pace, now: now)
         if let rightLabel = detail.rightLabel {
-            return "Pace: \(detail.leftLabel) · \(rightLabel)"
+            return L("Pace: %@ · %@", detail.leftLabel, rightLabel)
         }
-        return "Pace: \(detail.leftLabel)"
+        return L("Pace: %@", detail.leftLabel)
     }
 
     static func weeklyDetail(pace: UsagePace, now: Date = .init()) -> WeeklyDetail {
         WeeklyDetail(
             leftLabel: self.detailLeftLabel(for: pace),
-            rightLabel: self.detailRightLabel(for: pace, now: now),
+            rightLabel: self.detailRightLabel(for: pace, context: .weekly, now: now),
             expectedUsedPercent: pace.expectedUsedPercent,
             stage: pace.stage)
     }
@@ -29,30 +34,37 @@ enum UsagePaceText {
         let deltaValue = Int(abs(pace.deltaPercent).rounded())
         switch pace.stage {
         case .onTrack:
-            return "On pace"
+            return L("On pace")
         case .slightlyAhead, .ahead, .farAhead:
-            return "\(deltaValue)% in deficit"
+            return L("%d%% in deficit", deltaValue)
         case .slightlyBehind, .behind, .farBehind:
-            return "\(deltaValue)% in reserve"
+            return L("%d%% in reserve", deltaValue)
         }
     }
 
-    private static func detailRightLabel(for pace: UsagePace, now: Date) -> String? {
+    private static func detailRightLabel(for pace: UsagePace, context: DetailContext, now: Date) -> String? {
         let etaLabel: String?
         if pace.willLastToReset {
-            etaLabel = "Lasts until reset"
+            etaLabel = L("Lasts until reset")
         } else if let etaSeconds = pace.etaSeconds {
             let etaText = Self.durationText(seconds: etaSeconds, now: now)
-            etaLabel = etaText == "now" ? "Runs out now" : "Runs out in \(etaText)"
+            if context == .session {
+                etaLabel = etaText == "now" ? L("Projected empty now") : L("Projected empty in %@", etaText)
+            } else {
+                etaLabel = etaText == "now" ? L("Runs out now") : L("Runs out in %@", etaText)
+            }
         } else {
             etaLabel = nil
         }
 
         guard let runOutProbability = pace.runOutProbability else { return etaLabel }
         let roundedRisk = self.roundedRiskPercent(runOutProbability)
-        let riskLabel = "≈ \(roundedRisk)% run-out risk"
+        let riskLabel = L("≈ %d%% run-out risk", roundedRisk)
+        if pace.willLastToReset, roundedRisk > 0 {
+            return riskLabel
+        }
         if let etaLabel {
-            return "\(etaLabel) · \(riskLabel)"
+            return L("%@ · %@", etaLabel, riskLabel)
         }
         return riskLabel
     }
@@ -70,4 +82,30 @@ enum UsagePaceText {
         let rounded = (percent / 5).rounded() * 5
         return Int(rounded)
     }
+
+    static func sessionPace(provider: UsageProvider, window: RateWindow, now: Date) -> UsagePace? {
+        guard provider == .codex || provider == .claude || provider == .ollama else { return nil }
+        if provider == .ollama, window.windowMinutes == nil { return nil }
+        guard window.remainingPercent > 0 else { return nil }
+        guard let pace = UsagePace.weekly(window: window, now: now, defaultWindowMinutes: 300) else { return nil }
+        guard pace.expectedUsedPercent >= 3 else { return nil }
+        return pace
+    }
+
+    static func sessionDetail(provider: UsageProvider, window: RateWindow, now: Date = .init()) -> WeeklyDetail? {
+        guard let pace = sessionPace(provider: provider, window: window, now: now) else { return nil }
+        return WeeklyDetail(
+            leftLabel: Self.detailLeftLabel(for: pace),
+            rightLabel: Self.detailRightLabel(for: pace, context: .session, now: now),
+            expectedUsedPercent: pace.expectedUsedPercent,
+            stage: pace.stage)
+    }
+
+    static func sessionSummary(provider: UsageProvider, window: RateWindow, now: Date = .init()) -> String? {
+        guard let detail = sessionDetail(provider: provider, window: window, now: now) else { return nil }
+        if let rightLabel = detail.rightLabel {
+            return L("Pace: %@ · %@", detail.leftLabel, rightLabel)
+        }
+        return L("Pace: %@", detail.leftLabel)
+    }
 }
diff --git a/Sources/CodexBar/UsageProgressBar.swift b/Sources/CodexBar/UsageProgressBar.swift
index 28b467b867..f8dcd559bc 100644
--- a/Sources/CodexBar/UsageProgressBar.swift
+++ b/Sources/CodexBar/UsageProgressBar.swift
@@ -17,6 +17,7 @@ struct UsageProgressBar: View {
     let accessibilityLabel: String
     let pacePercent: Double?
     let paceOnTop: Bool
+    let warningMarkerPercents: [Double]
     @Environment(\.menuItemHighlighted) private var isHighlighted
     @Environment(\.displayScale) private var displayScale
 
@@ -25,13 +26,15 @@ struct UsageProgressBar: View {
         tint: Color,
         accessibilityLabel: String,
         pacePercent: Double? = nil,
-        paceOnTop: Bool = true)
+        paceOnTop: Bool = true,
+        warningMarkerPercents: [Double] = [])
     {
         self.percent = percent
         self.tint = tint
         self.accessibilityLabel = accessibilityLabel
         self.pacePercent = pacePercent
         self.paceOnTop = paceOnTop
+        self.warningMarkerPercents = warningMarkerPercents
     }
 
     private var clamped: Double {
@@ -39,81 +42,93 @@ struct UsageProgressBar: View {
     }
 
     var body: some View {
-        GeometryReader { proxy in
+        // Draw the entire progress bar — track, fill, and pace-tip punch-out — in a single Canvas.
+        // A single Canvas uses Core Graphics internally and avoids the SwiftUI compositing modifiers
+        // (.compositingGroup, .blendMode) that trigger Metal/RenderBox shader compilation on macOS 26.x,
+        // which caused the status item icon to disappear (issue #805).
+        Canvas { context, size in
             let scale = max(self.displayScale, 1)
-            let fillWidth = proxy.size.width * self.clamped / 100
-            let paceWidth = proxy.size.width * Self.clampedPercent(self.pacePercent) / 100
-            let tipWidth = max(25, proxy.size.height * 6.5)
+            let fillPercent = Self.renderedFillPercent(self.clamped)
+            let fillWidth = size.width * fillPercent / 100
+            let paceWidth = size.width * Self.clampedPercent(self.pacePercent) / 100
+            let tipWidth = max(25, size.height * 6.5)
             let stripeInset = 1 / scale
             let tipOffset = paceWidth - tipWidth + (Self.paceStripeSpan(for: scale) / 2) + stripeInset
             let showTip = self.pacePercent != nil && tipWidth > 0.5
-            let needsPunchCompositing = showTip
-            let bar = ZStack(alignment: .leading) {
-                Capsule()
-                    .fill(MenuHighlightStyle.progressTrack(self.isHighlighted))
-                self.actualBar(width: fillWidth)
-                if showTip {
-                    self.paceTip(width: tipWidth)
-                        .offset(x: tipOffset)
-                }
-            }
-            .clipped()
-            if self.isHighlighted {
-                bar
-                    .compositingGroup()
-                    .drawingGroup()
-            } else if needsPunchCompositing {
-                bar
-                    .compositingGroup()
-            } else {
-                bar
-            }
-        }
-        .frame(height: 6)
-        .accessibilityLabel(self.accessibilityLabel)
-        .accessibilityValue("\(Int(self.clamped)) percent")
-    }
-
-    private func actualBar(width: CGFloat) -> some View {
-        Capsule()
-            .fill(MenuHighlightStyle.progressTint(self.isHighlighted, fallback: self.tint))
-            .frame(width: width)
-            .contentShape(Rectangle())
-            .allowsHitTesting(false)
-    }
+            let markerPercents = self.warningMarkerPercents
+                .map(Self.clampedPercent)
+                .filter { $0 > 0 && $0 < 100 }
 
-    private func paceTip(width: CGFloat) -> some View {
-        let isDeficit = self.paceOnTop == false
-        let useDeficitRed = isDeficit && self.isHighlighted == false
-        return GeometryReader { proxy in
-            let size = proxy.size
+            let cornerRadius = size.height / 2
+            let cornerSize = CGSize(width: cornerRadius, height: cornerRadius)
             let rect = CGRect(origin: .zero, size: size)
-            let scale = max(self.displayScale, 1)
-            let stripes = Self.paceStripePaths(size: size, scale: scale)
-            let stripeColor: Color = if self.isHighlighted {
-                .white
-            } else if useDeficitRed {
-                .red
-            } else {
-                .green
+
+            context.clip(to: Path(rect))
+
+            // Track
+            let trackPath = Path { p in p.addRoundedRect(in: rect, cornerSize: cornerSize) }
+            context.fill(trackPath, with: .color(MenuHighlightStyle.progressTrack(self.isHighlighted)))
+
+            // Fill
+            if fillWidth > 0 {
+                let fillRect = CGRect(x: 0, y: 0, width: min(fillWidth, size.width), height: size.height)
+                let fillPath = Path { p in p.addRoundedRect(in: fillRect, cornerSize: cornerSize) }
+                context.fill(
+                    fillPath,
+                    with: .color(MenuHighlightStyle.progressTint(self.isHighlighted, fallback: self.tint)))
             }
 
-            ZStack {
-                Canvas { context, _ in
-                    context.clip(to: Path(rect))
-                    context.fill(stripes.punched, with: .color(.white.opacity(0.9)))
+            if !markerPercents.isEmpty {
+                let markerColor = Self.warningMarkerColor(isHighlighted: self.isHighlighted)
+                for markerPercent in markerPercents {
+                    let x = size.width * markerPercent / 100
+                    let markerRect = Self.warningMarkerRect(x: x, size: size, scale: scale)
+                    let markerPath = Path { p in
+                        p.addRoundedRect(
+                            in: markerRect,
+                            cornerSize: CGSize(width: markerRect.width / 2, height: markerRect.width / 2))
+                    }
+                    context.fill(markerPath, with: .color(markerColor))
                 }
-                .blendMode(.destinationOut)
+            }
 
-                Canvas { context, _ in
-                    context.clip(to: Path(rect))
-                    context.fill(stripes.center, with: .color(stripeColor))
+            // Pace tip: punch-out + center stripe drawn within the canvas context using Core Graphics
+            // blend modes so no SwiftUI compositing modifier (.blendMode, .compositingGroup) is needed.
+            if showTip {
+                let isDeficit = self.paceOnTop == false
+                let useDeficitRed = isDeficit && self.isHighlighted == false
+                let stripeColor: Color = if self.isHighlighted {
+                    .white
+                } else if useDeficitRed {
+                    .red
+                } else {
+                    .green
                 }
+
+                let tipSize = CGSize(width: tipWidth, height: size.height)
+                let stripes = Self.paceStripePaths(size: tipSize, scale: scale)
+                let shift = CGAffineTransform(translationX: tipOffset, y: 0)
+
+                // Punch out of the accumulated track+fill pixels.
+                context.blendMode = .destinationOut
+                context.fill(stripes.punched.applying(shift), with: .color(.white.opacity(0.9)))
+                context.blendMode = .normal
+
+                context.fill(stripes.center.applying(shift), with: .color(stripeColor))
             }
         }
-        .frame(width: width)
-        .contentShape(Rectangle())
-        .allowsHitTesting(false)
+        .frame(height: 6)
+        .accessibilityLabel(self.accessibilityLabel)
+        .accessibilityValue("\(Self.displayPercent(self.clamped)) percent")
+    }
+
+    /// Aligns edge rendering with the rounded percent label: sub-0.5% is empty and 99.5%+ is full.
+    nonisolated static func renderedFillPercent(_ percent: Double) -> Double {
+        let clamped = Self.clampedPercent(percent)
+        let displayPercent = Self.displayPercent(clamped)
+        if displayPercent <= 0 { return 0 }
+        if displayPercent >= 100 { return 100 }
+        return clamped
     }
 
     private static func paceStripePaths(size: CGSize, scale: CGFloat) -> (punched: Path, center: Path) {
@@ -164,7 +179,30 @@ struct UsageProgressBar: View {
         return (punchedStripe, centerStripe)
     }
 
-    private static func clampedPercent(_ value: Double?) -> Double {
+    nonisolated static func warningMarkerRect(x: CGFloat, size: CGSize, scale rawScale: CGFloat) -> CGRect {
+        let scale = max(rawScale, 1)
+        let width = max(1 / scale, 1)
+        let height = min(size.height, max(1 / scale, size.height * 0.55))
+        let align: (CGFloat) -> CGFloat = { value in
+            (value * scale).rounded() / scale
+        }
+
+        return CGRect(
+            x: align(x - width / 2),
+            y: align((size.height - height) / 2),
+            width: width,
+            height: align(height))
+    }
+
+    nonisolated static func warningMarkerColor(isHighlighted: Bool) -> Color {
+        isHighlighted ? .white.opacity(0.72) : .primary.opacity(0.32)
+    }
+
+    private nonisolated static func displayPercent(_ percent: Double) -> Int {
+        Int(self.clampedPercent(percent).rounded())
+    }
+
+    private nonisolated static func clampedPercent(_ value: Double?) -> Double {
         guard let value else { return 0 }
         return min(100, max(0, value))
     }
diff --git a/Sources/CodexBar/UsageStore+Accessors.swift b/Sources/CodexBar/UsageStore+Accessors.swift
index 98d77c6d8d..ccdec060b9 100644
--- a/Sources/CodexBar/UsageStore+Accessors.swift
+++ b/Sources/CodexBar/UsageStore+Accessors.swift
@@ -14,6 +14,18 @@ extension UsageStore {
         self.errors[.codex]
     }
 
+    var userFacingLastCodexError: String? {
+        self.userFacingError(for: .codex)
+    }
+
+    var userFacingLastCreditsError: String? {
+        CodexUIErrorMapper.userFacingMessage(self.lastCreditsError)
+    }
+
+    var userFacingLastOpenAIDashboardError: String? {
+        CodexUIErrorMapper.userFacingMessage(self.lastOpenAIDashboardError)
+    }
+
     var lastClaudeError: String? {
         self.errors[.claude]
     }
@@ -22,6 +34,45 @@ extension UsageStore {
         self.errors[provider]
     }
 
+    func userFacingError(for provider: UsageProvider) -> String? {
+        if let raw = self.errors[provider] {
+            guard provider == .codex else { return raw }
+            return CodexUIErrorMapper.userFacingMessage(raw)
+        }
+        return self.unavailableMessage(for: provider)
+    }
+
+    func unavailableMessage(for provider: UsageProvider) -> String? {
+        guard self.enabledProvidersForDisplay().contains(provider),
+              !self.isProviderAvailable(provider)
+        else {
+            return nil
+        }
+
+        switch provider {
+        case .synthetic:
+            return SyntheticSettingsError.missingToken.errorDescription
+        case .zai:
+            return ZaiSettingsError.missingToken.errorDescription
+        case .openrouter:
+            return OpenRouterSettingsError.missingToken.errorDescription
+        case .azureopenai:
+            return AzureOpenAISettingsError.missingAPIKey.errorDescription
+        case .elevenlabs:
+            return ElevenLabsUsageError.missingCredentials.errorDescription
+        case .deepseek:
+            return DeepSeekUsageError.missingCredentials.errorDescription
+        case .perplexity:
+            return PerplexityAPIError.missingToken.errorDescription
+        case .minimax:
+            return MiniMaxAPISettingsError.missingToken.errorDescription
+        case .kimi:
+            return KimiAPIError.missingToken.errorDescription
+        default:
+            return "\(self.metadata(for: provider).displayName) is unavailable in the current environment."
+        }
+    }
+
     func status(for provider: UsageProvider) -> ProviderStatus? {
         guard self.statusChecksEnabled else { return nil }
         return self.statuses[provider]
@@ -31,7 +82,31 @@ extension UsageStore {
         self.status(for: provider)?.indicator ?? .none
     }
 
-    func accountInfo() -> AccountInfo {
-        self.codexFetcher.loadAccountInfo()
+    func accountInfo(for provider: UsageProvider) -> AccountInfo {
+        let now = Date()
+        let configRevision = self.settings.configRevision
+        if let cached = self.accountInfoCache[provider],
+           cached.isValid(now: now, configRevision: configRevision)
+        {
+            return cached.account
+        }
+
+        let account: AccountInfo
+        if provider == .codex {
+            let env = ProviderRegistry.makeEnvironment(
+                base: self.environmentBase,
+                provider: .codex,
+                settings: self.settings,
+                tokenOverride: nil)
+            let fetcher = ProviderRegistry.makeFetcher(base: self.codexFetcher, provider: .codex, env: env)
+            account = fetcher.loadAccountInfo()
+        } else {
+            account = self.codexFetcher.loadAccountInfo()
+        }
+        self.accountInfoCache[provider] = AccountInfoCacheEntry(
+            account: account,
+            configRevision: configRevision,
+            expiresAt: now.addingTimeInterval(self.accountInfoCacheTTL))
+        return account
     }
 }
diff --git a/Sources/CodexBar/UsageStore+BackgroundRefresh.swift b/Sources/CodexBar/UsageStore+BackgroundRefresh.swift
new file mode 100644
index 0000000000..b892b0b5a3
--- /dev/null
+++ b/Sources/CodexBar/UsageStore+BackgroundRefresh.swift
@@ -0,0 +1,38 @@
+import CodexBarCore
+import Foundation
+
+@MainActor
+extension UsageStore {
+    private func clearProviderState(_ provider: UsageProvider) {
+        self.refreshingProviders.remove(provider)
+        self.snapshots.removeValue(forKey: provider)
+        self.errors[provider] = nil
+        self.lastSourceLabels.removeValue(forKey: provider)
+        self.lastFetchAttempts.removeValue(forKey: provider)
+        self.accountSnapshots.removeValue(forKey: provider)
+        self.tokenSnapshots.removeValue(forKey: provider)
+        self.tokenErrors[provider] = nil
+        self.providerStorageFootprints.removeValue(forKey: provider)
+        self.failureGates[provider]?.reset()
+        self.tokenFailureGates[provider]?.reset()
+        self.statuses.removeValue(forKey: provider)
+        self.lastKnownSessionRemaining.removeValue(forKey: provider)
+        self.lastKnownSessionWindowSource.removeValue(forKey: provider)
+        self.lastTokenFetchAt.removeValue(forKey: provider)
+    }
+
+    func clearDisabledProviderState(enabledProviders: Set<UsageProvider>) {
+        for provider in UsageProvider.allCases where !enabledProviders.contains(provider) {
+            self.clearProviderState(provider)
+        }
+    }
+
+    func clearUnavailableProviderState(
+        displayEnabledProviders: Set<UsageProvider>,
+        availableProviders: Set<UsageProvider>)
+    {
+        for provider in displayEnabledProviders where !availableProviders.contains(provider) {
+            self.clearProviderState(provider)
+        }
+    }
+}
diff --git a/Sources/CodexBar/UsageStore+ClaudeDebug.swift b/Sources/CodexBar/UsageStore+ClaudeDebug.swift
new file mode 100644
index 0000000000..f836953fa8
--- /dev/null
+++ b/Sources/CodexBar/UsageStore+ClaudeDebug.swift
@@ -0,0 +1,174 @@
+import CodexBarCore
+import Foundation
+import SweetCookieKit
+
+@MainActor
+extension UsageStore {
+    func debugClaudeDump() async -> String {
+        await ClaudeStatusProbe.latestDumps()
+    }
+}
+
+extension UsageStore {
+    struct ClaudeDebugLogConfiguration {
+        let runtime: CodexBarCore.ProviderRuntime
+        let sourceMode: ProviderSourceMode
+        let environment: [String: String]
+        let webExtrasEnabled: Bool
+        let usageDataSource: ClaudeUsageDataSource
+        let cookieSource: ProviderCookieSource
+        let cookieHeader: String
+        let keepCLISessionsAlive: Bool
+    }
+
+    static func debugClaudeLog(
+        browserDetection: BrowserDetection,
+        configuration: ClaudeDebugLogConfiguration) async -> String
+    {
+        struct OAuthDebugProbe: Sendable {
+            let hasCredentials: Bool
+            let ownerRawValue: String
+            let sourceRawValue: String
+            let isExpired: Bool
+        }
+
+        return await runWithTimeout(seconds: 15) {
+            var lines: [String] = []
+            let manualHeader = configuration.cookieSource == .manual
+                ? CookieHeaderNormalizer.normalize(configuration.cookieHeader)
+                : nil
+            let hasKey = if configuration.cookieSource == .off {
+                false
+            } else if let manualHeader {
+                ClaudeWebAPIFetcher.hasSessionKey(cookieHeader: manualHeader)
+            } else {
+                ClaudeWebAPIFetcher.hasSessionKey(browserDetection: browserDetection) { msg in lines.append(msg) }
+            }
+            let oauthProbe = await withTaskGroup(of: OAuthDebugProbe.self) { group in
+                // Preserve task-local test overrides while keeping the keychain read off the calling task.
+                group.addTask(priority: .utility) {
+                    let oauthRecord = try? ClaudeOAuthCredentialsStore.loadRecord(
+                        environment: configuration.environment,
+                        allowKeychainPrompt: false,
+                        respectKeychainPromptCooldown: true,
+                        allowClaudeKeychainRepairWithoutPrompt: false)
+                    return OAuthDebugProbe(
+                        hasCredentials: oauthRecord?.credentials.scopes.contains("user:profile") == true,
+                        ownerRawValue: oauthRecord?.owner.rawValue ?? "none",
+                        sourceRawValue: oauthRecord?.source.rawValue ?? "none",
+                        isExpired: oauthRecord?.credentials.isExpired ?? false)
+                }
+                return await group.next() ?? OAuthDebugProbe(
+                    hasCredentials: false,
+                    ownerRawValue: "none",
+                    sourceRawValue: "none",
+                    isExpired: false)
+            }
+            let hasOAuthCredentials = ClaudeOAuthPlanningAvailability.isAvailable(
+                runtime: configuration.runtime,
+                sourceMode: configuration.sourceMode,
+                environment: configuration.environment)
+            let hasClaudeBinary = ClaudeCLIResolver.isAvailable(environment: configuration.environment)
+            let delegatedCooldownSeconds = ClaudeOAuthDelegatedRefreshCoordinator.cooldownRemainingSeconds()
+            let planningInput = ClaudeSourcePlanningInput(
+                runtime: configuration.runtime,
+                selectedDataSource: configuration.usageDataSource,
+                webExtrasEnabled: configuration.webExtrasEnabled,
+                hasWebSession: hasKey,
+                hasCLI: hasClaudeBinary,
+                hasOAuthCredentials: hasOAuthCredentials)
+            let plan = ClaudeSourcePlanner.resolve(input: planningInput)
+            let strategy = plan.compatibilityStrategy
+
+            lines.append(contentsOf: plan.debugLines())
+            lines.append("hasSessionKey=\(hasKey)")
+            lines.append("hasOAuthCredentials=\(hasOAuthCredentials)")
+            lines.append("oauthCredentialOwner=\(oauthProbe.ownerRawValue)")
+            lines.append("oauthCredentialSource=\(oauthProbe.sourceRawValue)")
+            lines.append("oauthCredentialExpired=\(oauthProbe.isExpired)")
+            lines.append("delegatedRefreshCLIAvailable=\(hasClaudeBinary)")
+            lines.append("delegatedRefreshCooldownActive=\(delegatedCooldownSeconds != nil)")
+            if let delegatedCooldownSeconds {
+                lines.append("delegatedRefreshCooldownSeconds=\(delegatedCooldownSeconds)")
+            }
+            lines.append("hasClaudeBinary=\(hasClaudeBinary)")
+            if strategy?.useWebExtras == true {
+                lines.append("web_extras=enabled")
+            }
+            lines.append("")
+
+            guard let strategy else {
+                lines.append("No planner-selected Claude source.")
+                return lines.joined(separator: "\n")
+            }
+
+            switch strategy.dataSource {
+            case .auto:
+                lines.append("Auto source selected.")
+                return lines.joined(separator: "\n")
+            case .api:
+                let hasAdminKey = ProviderTokenResolver.claudeAdminAPIToken(
+                    environment: configuration.environment) != nil
+                lines.append("Admin API source selected.")
+                lines.append("hasAdminAPIKey=\(hasAdminKey)")
+                return lines.joined(separator: "\n")
+            case .web:
+                do {
+                    let web: ClaudeWebAPIFetcher.WebUsageData =
+                        if let manualHeader {
+                            try await ClaudeWebAPIFetcher.fetchUsage(cookieHeader: manualHeader) { msg in
+                                lines.append(msg)
+                            }
+                        } else {
+                            try await ClaudeWebAPIFetcher.fetchUsage(browserDetection: browserDetection) { msg in
+                                lines.append(msg)
+                            }
+                        }
+                    lines.append("")
+                    lines.append("Web API summary:")
+
+                    let sessionReset = web.sessionResetsAt?.description ?? "nil"
+                    lines.append("session_used=\(web.sessionPercentUsed)% resetsAt=\(sessionReset)")
+
+                    if let weekly = web.weeklyPercentUsed {
+                        let weeklyReset = web.weeklyResetsAt?.description ?? "nil"
+                        lines.append("weekly_used=\(weekly)% resetsAt=\(weeklyReset)")
+                    } else {
+                        lines.append("weekly_used=nil")
+                    }
+
+                    lines.append("opus_used=\(web.opusPercentUsed?.description ?? "nil")")
+
+                    if let extra = web.extraUsageCost {
+                        let resetsAt = extra.resetsAt?.description ?? "nil"
+                        let period = extra.period ?? "nil"
+                        let line =
+                            "extra_usage used=\(extra.used) limit=\(extra.limit) " +
+                            "currency=\(extra.currencyCode) period=\(period) resetsAt=\(resetsAt)"
+                        lines.append(line)
+                    } else {
+                        lines.append("extra_usage=nil")
+                    }
+
+                    return lines.joined(separator: "\n")
+                } catch {
+                    lines.append("Web API failed: \(error.localizedDescription)")
+                    return lines.joined(separator: "\n")
+                }
+            case .cli:
+                let fetcher = ClaudeUsageFetcher(
+                    browserDetection: browserDetection,
+                    environment: configuration.environment,
+                    runtime: configuration.runtime,
+                    dataSource: configuration.usageDataSource,
+                    keepCLISessionsAlive: configuration.keepCLISessionsAlive)
+                let cli = await fetcher.debugRawProbe(model: "sonnet")
+                lines.append(cli)
+                return lines.joined(separator: "\n")
+            case .oauth:
+                lines.append("OAuth source selected.")
+                return lines.joined(separator: "\n")
+            }
+        }
+    }
+}
diff --git a/Sources/CodexBar/UsageStore+HighestUsage.swift b/Sources/CodexBar/UsageStore+HighestUsage.swift
index 2a46df393b..3b51034f1e 100644
--- a/Sources/CodexBar/UsageStore+HighestUsage.swift
+++ b/Sources/CodexBar/UsageStore+HighestUsage.swift
@@ -9,8 +9,10 @@ extension UsageStore {
         var highest: (provider: UsageProvider, usedPercent: Double)?
         for provider in self.enabledProviders() {
             guard let snapshot = self.snapshots[provider] else { continue }
-            let window = self.menuBarMetricWindowForHighestUsage(provider: provider, snapshot: snapshot)
-            let percent = window?.usedPercent ?? 0
+            guard let window = self.menuBarMetricWindowForHighestUsage(provider: provider, snapshot: snapshot) else {
+                continue
+            }
+            let percent = window.usedPercent
             guard !self.shouldExcludeFromHighestUsage(
                 provider: provider,
                 snapshot: snapshot,
@@ -26,30 +28,18 @@ extension UsageStore {
     }
 
     private func menuBarMetricWindowForHighestUsage(provider: UsageProvider, snapshot: UsageSnapshot) -> RateWindow? {
-        switch self.settings.menuBarMetricPreference(for: provider) {
-        case .primary:
-            return snapshot.primary ?? snapshot.secondary
-        case .secondary:
-            return snapshot.secondary ?? snapshot.primary
-        case .average:
-            guard let primary = snapshot.primary, let secondary = snapshot.secondary else {
-                return snapshot.primary ?? snapshot.secondary
-            }
-            let usedPercent = (primary.usedPercent + secondary.usedPercent) / 2
-            return RateWindow(usedPercent: usedPercent, windowMinutes: nil, resetsAt: nil, resetDescription: nil)
-        case .automatic:
-            if provider == .factory || provider == .kimi {
-                return snapshot.secondary ?? snapshot.primary
-            }
-            if provider == .copilot,
-               let primary = snapshot.primary,
-               let secondary = snapshot.secondary
-            {
-                // Copilot can expose chat + completions quotas; rank by the more constrained one.
-                return primary.usedPercent >= secondary.usedPercent ? primary : secondary
-            }
-            return snapshot.primary ?? snapshot.secondary
+        let effectivePreference = self.settings.menuBarMetricPreference(for: provider, snapshot: snapshot)
+        if provider == .antigravity, effectivePreference == .automatic {
+            let windows = IconRemainingResolver.resolvedWindows(snapshot: snapshot, style: .antigravity)
+            return [windows.primary, windows.secondary]
+                .compactMap(\.self)
+                .max(by: { $0.usedPercent < $1.usedPercent })
         }
+        return MenuBarMetricWindowResolver.rateWindow(
+            preference: effectivePreference,
+            provider: provider,
+            snapshot: snapshot,
+            supportsAverage: self.settings.menuBarMetricSupportsAverage(for: provider))
     }
 
     private func shouldExcludeFromHighestUsage(
@@ -58,15 +48,38 @@ extension UsageStore {
         metricPercent: Double)
         -> Bool
     {
+        let effectivePreference = self.settings.menuBarMetricPreference(for: provider, snapshot: snapshot)
         guard metricPercent >= 100 else { return false }
+        if provider == .codex, effectivePreference == .primaryAndSecondary {
+            let percents = [snapshot.primary?.usedPercent, snapshot.secondary?.usedPercent].compactMap(\.self)
+            guard !percents.isEmpty else { return true }
+            return percents.allSatisfy { $0 >= 100 }
+        }
+        if provider == .antigravity, effectivePreference == .automatic {
+            let windows = IconRemainingResolver.resolvedWindows(snapshot: snapshot, style: .antigravity)
+            let percents = [windows.primary?.usedPercent, windows.secondary?.usedPercent].compactMap(\.self)
+            return percents.allSatisfy { $0 >= 100 }
+        }
         if provider == .copilot,
-           self.settings.menuBarMetricPreference(for: provider) == .automatic,
+           effectivePreference == .automatic,
            let primary = snapshot.primary,
            let secondary = snapshot.secondary
         {
             // In automatic mode Copilot can have one depleted lane while another still has quota.
             return primary.usedPercent >= 100 && secondary.usedPercent >= 100
         }
+        if provider == .cursor,
+           effectivePreference == .automatic
+        {
+            let percents = [
+                snapshot.primary?.usedPercent,
+                snapshot.secondary?.usedPercent,
+                snapshot.tertiary?.usedPercent,
+            ].compactMap(\.self)
+            guard !percents.isEmpty else { return true }
+            return percents.allSatisfy { $0 >= 100 }
+        }
+
         return true
     }
 }
diff --git a/Sources/CodexBar/UsageStore+HistoricalPace.swift b/Sources/CodexBar/UsageStore+HistoricalPace.swift
index e228025f3a..cda21506b2 100644
--- a/Sources/CodexBar/UsageStore+HistoricalPace.swift
+++ b/Sources/CodexBar/UsageStore+HistoricalPace.swift
@@ -1,5 +1,4 @@
 import CodexBarCore
-import CryptoKit
 import Foundation
 
 @MainActor
@@ -8,11 +7,14 @@ extension UsageStore {
     private static let backfillMaxTimestampMismatch: TimeInterval = 5 * 60
 
     func weeklyPace(provider: UsageProvider, window: RateWindow, now: Date = .init()) -> UsagePace? {
-        guard provider == .codex || provider == .claude else { return nil }
         guard window.remainingPercent > 0 else { return nil }
         let resolved: UsagePace?
+        let workDays = self.settings.weeklyProgressWorkDays
+        // Codex can refine pace with historical samples because its dashboard exposes enough weekly history to build
+        // an account-scoped usage curve. Other providers should not need a hard-coded allowlist: if their RateWindow
+        // includes a reset time and window duration, the generic linear pace calculation is already defensible.
         if provider == .codex, self.settings.historicalTrackingEnabled {
-            let codexAccountKey = self.codexHistoricalAccountKey()
+            let codexAccountKey = self.codexOwnershipContext().canonicalKey
             if self.codexHistoricalDatasetAccountKey == codexAccountKey,
                let historical = CodexHistoricalPaceEvaluator.evaluate(
                    window: window,
@@ -21,10 +23,14 @@ extension UsageStore {
             {
                 resolved = historical
             } else {
-                resolved = UsagePace.weekly(window: window, now: now, defaultWindowMinutes: 10080)
+                resolved = UsagePace.weekly(window: window, now: now, defaultWindowMinutes: 10080, workDays: workDays)
             }
         } else {
-            resolved = UsagePace.weekly(window: window, now: now, defaultWindowMinutes: 10080)
+            // Generic providers must carry an explicit window duration. Using the 10080-minute fallback for
+            // windows without windowMinutes would fabricate a weekly pace for non-weekly windows
+            // (e.g. Factory monthly with only resetsAt).
+            guard window.windowMinutes != nil else { return nil }
+            resolved = UsagePace.weekly(window: window, now: now, defaultWindowMinutes: 10080, workDays: workDays)
         }
 
         guard let resolved else { return nil }
@@ -34,18 +40,27 @@ extension UsageStore {
 
     func recordCodexHistoricalSampleIfNeeded(snapshot: UsageSnapshot) {
         guard self.settings.historicalTrackingEnabled else { return }
-        guard let weekly = snapshot.secondary else { return }
+        let projection = self.codexConsumerProjection(
+            surface: .liveCard,
+            snapshotOverride: snapshot,
+            now: snapshot.updatedAt)
+        guard let weekly = projection.rateWindow(for: .weekly) else { return }
 
         let sampledAt = snapshot.updatedAt
-        let accountKey = self.codexHistoricalAccountKey(preferredEmail: snapshot.accountEmail(for: .codex))
+        let ownership = self.codexOwnershipContext(preferredEmail: snapshot.accountEmail(for: .codex))
         let historyStore = self.historicalUsageHistoryStore
         Task.detached(priority: .utility) { [weak self] in
-            let dataset = await historyStore.recordCodexWeekly(
+            _ = await historyStore.recordCodexWeekly(
                 window: weekly,
                 sampledAt: sampledAt,
-                accountKey: accountKey)
+                accountKey: ownership.canonicalKey)
+            let dataset = await historyStore.loadCodexDataset(
+                canonicalAccountKey: ownership.canonicalKey,
+                canonicalEmailHashKey: ownership.canonicalEmailHashKey,
+                legacyEmailHash: ownership.historicalLegacyEmailHash,
+                hasAdjacentMultiAccountVeto: ownership.hasAdjacentMultiAccountVeto)
             await MainActor.run { [weak self] in
-                self?.setCodexHistoricalDataset(dataset, accountKey: accountKey)
+                self?.setCodexHistoricalDataset(dataset, accountKey: ownership.canonicalKey)
             }
         }
     }
@@ -55,28 +70,55 @@ extension UsageStore {
             self.setCodexHistoricalDataset(nil, accountKey: nil)
             return
         }
-        let accountKey = self.codexHistoricalAccountKey(dashboard: self.openAIDashboard)
-        let dataset = await self.historicalUsageHistoryStore.loadCodexDataset(accountKey: accountKey)
-        self.setCodexHistoricalDataset(dataset, accountKey: accountKey)
+        let ownership = self.codexOwnershipContext()
+        let dataset = await self.historicalUsageHistoryStore.loadCodexDataset(
+            canonicalAccountKey: ownership.canonicalKey,
+            canonicalEmailHashKey: ownership.canonicalEmailHashKey,
+            legacyEmailHash: ownership.historicalLegacyEmailHash,
+            hasAdjacentMultiAccountVeto: ownership.hasAdjacentMultiAccountVeto)
+        self.setCodexHistoricalDataset(dataset, accountKey: ownership.canonicalKey)
         if let dashboard = self.openAIDashboard {
-            self.backfillCodexHistoricalFromDashboardIfNeeded(dashboard)
+            let authority = self.evaluateCodexDashboardAuthority(
+                dashboard: dashboard,
+                sourceKind: .liveWeb,
+                routingTargetEmail: self.lastOpenAIDashboardTargetEmail)
+            self.backfillCodexHistoricalFromDashboardIfNeeded(
+                dashboard,
+                authorityDecision: authority.decision,
+                attachedAccountEmail: self.codexDashboardAttachmentEmail(from: authority.input))
         }
     }
 
-    func backfillCodexHistoricalFromDashboardIfNeeded(_ dashboard: OpenAIDashboardSnapshot) {
+    func backfillCodexHistoricalFromDashboardIfNeeded(
+        _ dashboard: OpenAIDashboardSnapshot,
+        authorityDecision: CodexDashboardAuthorityDecision,
+        attachedAccountEmail: String?)
+    {
         guard self.settings.historicalTrackingEnabled else { return }
-        guard !dashboard.usageBreakdown.isEmpty else { return }
+        guard authorityDecision.allowedEffects.contains(.historicalBackfill) else { return }
+        let usageBreakdown = OpenAIDashboardDailyBreakdown.removingSkillUsageServices(
+            from: dashboard.usageBreakdown)
+        guard !usageBreakdown.isEmpty else { return }
 
         let codexSnapshot = self.snapshots[.codex]
-        let accountKey = self.codexHistoricalAccountKey(
-            preferredEmail: codexSnapshot?.accountEmail(for: .codex),
-            dashboard: dashboard)
+        let ownership = self.codexOwnershipContext(preferredEmail: attachedAccountEmail)
         let referenceWindow: RateWindow
         let calibrationAt: Date
-        if let dashboardWeekly = dashboard.secondaryLimit {
+        if let dashboardWeekly = CodexReconciledState.fromAttachedDashboard(
+            snapshot: dashboard,
+            provider: .codex,
+            accountEmail: attachedAccountEmail,
+            accountPlan: nil)?
+            .weekly
+        {
             referenceWindow = dashboardWeekly
             calibrationAt = dashboard.updatedAt
-        } else if let codexSnapshot, let snapshotWeekly = codexSnapshot.secondary {
+        } else if let codexSnapshot,
+                  let snapshotWeekly = self.codexConsumerProjection(
+                      surface: .liveCard,
+                      snapshotOverride: codexSnapshot,
+                      now: codexSnapshot.updatedAt).rateWindow(for: .weekly)
+        {
             let mismatch = abs(codexSnapshot.updatedAt.timeIntervalSince(dashboard.updatedAt))
             guard mismatch <= Self.backfillMaxTimestampMismatch else { return }
             referenceWindow = snapshotWeekly
@@ -86,15 +128,19 @@ extension UsageStore {
         }
 
         let historyStore = self.historicalUsageHistoryStore
-        let usageBreakdown = dashboard.usageBreakdown
         Task.detached(priority: .utility) { [weak self] in
-            let dataset = await historyStore.backfillCodexWeeklyFromUsageBreakdown(
+            _ = await historyStore.backfillCodexWeeklyFromUsageBreakdown(
                 usageBreakdown,
                 referenceWindow: referenceWindow,
                 now: calibrationAt,
-                accountKey: accountKey)
+                accountKey: ownership.canonicalKey)
+            let dataset = await historyStore.loadCodexDataset(
+                canonicalAccountKey: ownership.canonicalKey,
+                canonicalEmailHashKey: ownership.canonicalEmailHashKey,
+                legacyEmailHash: ownership.historicalLegacyEmailHash,
+                hasAdjacentMultiAccountVeto: ownership.hasAdjacentMultiAccountVeto)
             await MainActor.run { [weak self] in
-                self?.setCodexHistoricalDataset(dataset, accountKey: accountKey)
+                self?.setCodexHistoricalDataset(dataset, accountKey: ownership.canonicalKey)
             }
         }
     }
@@ -104,25 +150,4 @@ extension UsageStore {
         self.codexHistoricalDatasetAccountKey = accountKey
         self.historicalPaceRevision += 1
     }
-
-    private func codexHistoricalAccountKey(
-        preferredEmail: String? = nil,
-        dashboard: OpenAIDashboardSnapshot? = nil) -> String?
-    {
-        let sourceEmail = preferredEmail ??
-            self.snapshots[.codex]?.accountEmail(for: .codex) ??
-            dashboard?.signedInEmail ??
-            self.codexAccountEmailForOpenAIDashboard()
-        guard let sourceEmail else { return nil }
-        let normalized = sourceEmail
-            .trimmingCharacters(in: .whitespacesAndNewlines)
-            .lowercased()
-        guard !normalized.isEmpty else { return nil }
-        return Self.sha256Hex(normalized)
-    }
-
-    private static func sha256Hex(_ input: String) -> String {
-        let digest = SHA256.hash(data: Data(input.utf8))
-        return digest.map { String(format: "%02x", $0) }.joined()
-    }
 }
diff --git a/Sources/CodexBar/UsageStore+Logging.swift b/Sources/CodexBar/UsageStore+Logging.swift
index a598da99a4..7b4ff0826b 100644
--- a/Sources/CodexBar/UsageStore+Logging.swift
+++ b/Sources/CodexBar/UsageStore+Logging.swift
@@ -10,13 +10,16 @@ extension UsageStore {
             "claudeCookieSource": self.settings.claudeCookieSource.rawValue,
             "cursorCookieSource": self.settings.cursorCookieSource.rawValue,
             "opencodeCookieSource": self.settings.opencodeCookieSource.rawValue,
+            "opencodegoCookieSource": self.settings.opencodegoCookieSource.rawValue,
             "factoryCookieSource": self.settings.factoryCookieSource.rawValue,
             "minimaxCookieSource": self.settings.minimaxCookieSource.rawValue,
             "kimiCookieSource": self.settings.kimiCookieSource.rawValue,
             "augmentCookieSource": self.settings.augmentCookieSource.rawValue,
             "ampCookieSource": self.settings.ampCookieSource.rawValue,
+            "t3ChatCookieSource": self.settings.t3ChatCookieSource.rawValue,
             "ollamaCookieSource": self.settings.ollamaCookieSource.rawValue,
             "openAIWebAccess": self.settings.openAIWebAccessEnabled ? "1" : "0",
+            "openAIWebBatterySaver": self.settings.openAIWebBatterySaverEnabled ? "1" : "0",
             "claudeWebExtras": self.settings.claudeWebExtrasEnabled ? "1" : "0",
             "kiloExtras": self.settings.kiloExtrasEnabled ? "1" : "0",
         ]
diff --git a/Sources/CodexBar/UsageStore+MemoryPressure.swift b/Sources/CodexBar/UsageStore+MemoryPressure.swift
new file mode 100644
index 0000000000..c21829e28b
--- /dev/null
+++ b/Sources/CodexBar/UsageStore+MemoryPressure.swift
@@ -0,0 +1,39 @@
+import Foundation
+
+@MainActor
+extension UsageStore {
+    func scheduleMemoryPressureRelief() {
+        guard self.memoryPressureReliefTask == nil else { return }
+
+        self.memoryPressureReliefTask = Task.detached(priority: .utility) { [weak self] in
+            for delay in [Duration.seconds(2), .seconds(8), .seconds(20)] {
+                try? await Task.sleep(for: delay)
+                guard !Task.isCancelled else { return }
+                MemoryPressureRelief.releaseFreeMallocPages()
+            }
+            await MainActor.run { [weak self] in
+                self?.memoryPressureReliefTask = nil
+            }
+        }
+    }
+
+    func trimRebuildableCachesForMemoryPressure() -> MemoryPressureCacheTrimSummary {
+        let openAIWebDebugLineCount = self.openAIWebDebugLines.count
+        let summary = MemoryPressureCacheTrimSummary(openAIWebDebugLines: openAIWebDebugLineCount)
+
+        self.openAIWebDebugLines.removeAll(keepingCapacity: false)
+        self.openAIDashboardCookieImportDebugLog = nil
+
+        return summary
+    }
+
+    #if DEBUG
+    func seedRebuildableCachesForMemoryPressureProof() {
+        self.openAIWebDebugLines = [
+            "debug memory pressure line 1",
+            "debug memory pressure line 2",
+        ]
+        self.openAIDashboardCookieImportDebugLog = self.openAIWebDebugLines.joined(separator: "\n")
+    }
+    #endif
+}
diff --git a/Sources/CodexBar/UsageStore+OpenAIWeb.swift b/Sources/CodexBar/UsageStore+OpenAIWeb.swift
index af164cc627..1d4a27a26a 100644
--- a/Sources/CodexBar/UsageStore+OpenAIWeb.swift
+++ b/Sources/CodexBar/UsageStore+OpenAIWeb.swift
@@ -1,8 +1,1466 @@
+import CodexBarCore
 import Foundation
 
+struct OpenAIWebRefreshGateContext {
+    let force: Bool
+    let accountDidChange: Bool
+    let lastError: String?
+    let lastSnapshotAt: Date?
+    let lastAttemptAt: Date?
+    let now: Date
+    let refreshInterval: TimeInterval
+}
+
+struct OpenAIWebRefreshPolicyContext {
+    let accessEnabled: Bool
+    let batterySaverEnabled: Bool
+    let force: Bool
+    let refreshPhase: ProviderRefreshPhase
+}
+
+// MARK: - OpenAI web lifecycle
+
+extension UsageStore {
+    private struct OpenAIDashboardRefreshContext {
+        let targetEmail: String?
+        let allowCurrentSnapshotFallback: Bool
+        let expectedGuard: CodexAccountScopedRefreshGuard?
+        let refreshTaskToken: UUID
+        let allowCodexUsageBackfill: Bool
+        let force: Bool
+    }
+
+    private struct OpenAIDashboardCookieImportRequest {
+        let normalizedTarget: String?
+        let allowAnyAccount: Bool
+        let cookieSource: ProviderCookieSource
+        let cacheScope: CookieHeaderCache.Scope?
+        let preferCachedCookieHeader: Bool?
+        let force: Bool
+    }
+
+    private static let openAIWebRefreshMultiplier: TimeInterval = 5
+    private static let openAIWebPrimaryFetchTimeout: TimeInterval = 25
+    private static let openAIWebRetryFetchTimeout: TimeInterval = 8
+    private static let openAIWebPostImportFetchTimeout: TimeInterval = 25
+
+    static func openAIWebDashboardFetchTimeout(didImportCookies: Bool) -> TimeInterval {
+        didImportCookies ? self.openAIWebPostImportFetchTimeout : self.openAIWebPrimaryFetchTimeout
+    }
+
+    static func openAIWebRetryDashboardFetchTimeout(afterCookieImport: Bool) -> TimeInterval {
+        afterCookieImport ? self.openAIWebPostImportFetchTimeout : self.openAIWebRetryFetchTimeout
+    }
+
+    nonisolated static func refreshPhase(
+        hasCompletedInitialRefresh: Bool) -> ProviderRefreshPhase
+    {
+        hasCompletedInitialRefresh ? .regular : .startup
+    }
+
+    nonisolated static func openAIWebRefreshPhase(
+        providerRefreshPhase: ProviderRefreshPhase,
+        startupConnectivityRetryAttempt: Int?) -> ProviderRefreshPhase
+    {
+        startupConnectivityRetryAttempt == nil ? providerRefreshPhase : .startup
+    }
+
+    private func openAIWebRefreshIntervalSeconds() -> TimeInterval {
+        let base = max(self.settings.refreshFrequency.seconds ?? 0, 120)
+        return base * Self.openAIWebRefreshMultiplier
+    }
+
+    func requestOpenAIDashboardRefreshIfStale(reason: String) {
+        guard self.isEnabled(.codex),
+              self.settings.openAIWebAccessEnabled,
+              self.settings.codexCookieSource.isEnabled
+        else { return }
+        let now = Date()
+        let refreshInterval = self.openAIWebRefreshIntervalSeconds()
+        let dashboard = self.openAIDashboard ?? self.lastOpenAIDashboardSnapshot
+        let lastUpdatedAt = dashboard?.updatedAt
+        let needsMenuHistoryRefresh = dashboard?.dailyBreakdown.isEmpty == true &&
+            dashboard?.usageBreakdown.isEmpty == true
+        if needsMenuHistoryRefresh,
+           Self.shouldSkipOpenAIWebEmptyHistoryRetry(.init(
+               force: false,
+               accountDidChange: self.openAIWebAccountDidChange,
+               lastError: self.lastOpenAIDashboardError,
+               lastSnapshotAt: lastUpdatedAt,
+               lastAttemptAt: self.lastOpenAIDashboardAttemptAt,
+               now: now,
+               refreshInterval: refreshInterval))
+        {
+            return
+        }
+        if let lastUpdatedAt, now.timeIntervalSince(lastUpdatedAt) < refreshInterval, !needsMenuHistoryRefresh {
+            return
+        }
+        let stamp = now.formatted(date: .abbreviated, time: .shortened)
+        self.logOpenAIWeb("[\(stamp)] OpenAI web refresh request: \(reason)")
+        let forceRefresh = Self.forceOpenAIWebRefreshForStaleRequest(
+            batterySaverEnabled: self.settings.openAIWebBatterySaverEnabled) || needsMenuHistoryRefresh
+        self.openAIWebLogger.info(
+            "OpenAI web stale refresh gate",
+            metadata: [
+                "reason": reason,
+                "force": forceRefresh ? "1" : "0",
+                "batterySaverEnabled": self.settings.openAIWebBatterySaverEnabled ? "1" : "0",
+                "interaction": ProviderInteractionContext.current == .userInitiated ? "user" : "background",
+            ])
+        let expectedGuard = self.freshCodexOpenAIWebRefreshGuard()
+        Task { await self.refreshOpenAIDashboardIfNeeded(force: forceRefresh, expectedGuard: expectedGuard) }
+    }
+
+    func applyOpenAIDashboard(
+        _ dash: OpenAIDashboardSnapshot,
+        targetEmail: String?,
+        expectedGuard: CodexAccountScopedRefreshGuard? = nil,
+        refreshTaskToken: UUID? = nil,
+        allowCodexUsageBackfill: Bool = true) async
+    {
+        guard self.shouldApplyOpenAIDashboardRefreshTask(token: refreshTaskToken) else { return }
+        self.settings.invalidateCodexAccountReconciliationSnapshotCache()
+        let authority = self.evaluateCodexDashboardAuthority(
+            dashboard: dash,
+            sourceKind: .liveWeb,
+            routingTargetEmail: targetEmail)
+        if let expectedGuard {
+            let shouldApply = switch authority.decision.disposition {
+            case .attach:
+                self.shouldApplyOpenAIDashboardRefreshGuard(
+                    expectedGuard: expectedGuard,
+                    routingTargetEmail: targetEmail)
+            case .displayOnly, .failClosed:
+                self.shouldApplyOpenAIDashboardPolicyResult(
+                    expectedGuard: expectedGuard,
+                    routingTargetEmail: targetEmail)
+            }
+            guard shouldApply else { return }
+        }
+
+        let attachedAccountEmail = self.codexDashboardAttachmentEmail(from: authority.input)
+
+        await self.applyOpenAIDashboardAuthorityDecision(
+            authority.decision,
+            dashboard: dash,
+            authorityInput: authority.input,
+            attachedAccountEmail: attachedAccountEmail,
+            allowCodexUsageBackfill: allowCodexUsageBackfill)
+    }
+
+    func applyOpenAIDashboardFailure(
+        message: String,
+        expectedGuard: CodexAccountScopedRefreshGuard? = nil,
+        refreshTaskToken: UUID? = nil,
+        routingTargetEmail: String? = nil) async
+    {
+        guard self.shouldApplyOpenAIDashboardRefreshTask(token: refreshTaskToken) else { return }
+        if let expectedGuard,
+           !self.shouldApplyOpenAIWebNonSuccessResult(
+               expectedGuard: expectedGuard,
+               routingTargetEmail: routingTargetEmail)
+        {
+            return
+        }
+        if self.openAIWebManagedTargetStoreIsUnreadable() {
+            await self.failClosedRefreshForUnreadableManagedCodexStore()
+            return
+        }
+        if self.openAIWebManagedTargetIsMissing() {
+            await self.failClosedRefreshForMissingManagedCodexTarget()
+            return
+        }
+        if self.openAIWebProfileTargetEmailIsMissing() {
+            await self.failClosedRefreshForMissingProfileCodexTarget()
+            return
+        }
+
+        OpenAIDashboardFetcher.evictAllCachedWebViews()
+        await MainActor.run {
+            if let cached = self.lastOpenAIDashboardSnapshot {
+                self.openAIDashboard = cached
+                self.openAIDashboardAttachmentAuthorized = self.lastOpenAIDashboardAttachmentAuthorized
+                let stamp = cached.updatedAt.formatted(date: .abbreviated, time: .shortened)
+                self.lastOpenAIDashboardError =
+                    "Last OpenAI dashboard refresh failed: \(message). Cached values from \(stamp)."
+            } else {
+                self.lastOpenAIDashboardError = message
+                self.openAIDashboard = nil
+                self.openAIDashboardAttachmentAuthorized = false
+            }
+        }
+    }
+
+    func applyOpenAIDashboardLoginRequiredFailure(
+        expectedGuard: CodexAccountScopedRefreshGuard? = nil,
+        refreshTaskToken: UUID? = nil,
+        routingTargetEmail: String? = nil) async
+    {
+        guard self.shouldApplyOpenAIDashboardRefreshTask(token: refreshTaskToken) else { return }
+        if let expectedGuard,
+           !self.shouldApplyOpenAIWebNonSuccessResult(
+               expectedGuard: expectedGuard,
+               routingTargetEmail: routingTargetEmail)
+        {
+            return
+        }
+        if self.openAIWebManagedTargetStoreIsUnreadable() {
+            await self.failClosedRefreshForUnreadableManagedCodexStore()
+            return
+        }
+        if self.openAIWebManagedTargetIsMissing() {
+            await self.failClosedRefreshForMissingManagedCodexTarget()
+            return
+        }
+        if self.openAIWebProfileTargetEmailIsMissing() {
+            await self.failClosedRefreshForMissingProfileCodexTarget()
+            return
+        }
+
+        OpenAIDashboardFetcher.evictAllCachedWebViews()
+        await MainActor.run {
+            self.lastOpenAIDashboardError = [
+                "OpenAI web access requires a signed-in chatgpt.com session.",
+                "Sign in using \(self.codexBrowserCookieOrder.loginHint), " +
+                    "then update OpenAI cookies in Providers → Codex.",
+            ].joined(separator: " ")
+            self.openAIDashboard = self.lastOpenAIDashboardSnapshot
+            self.openAIDashboardAttachmentAuthorized = self.lastOpenAIDashboardAttachmentAuthorized
+            self.openAIDashboardRequiresLogin = true
+        }
+    }
+
+    private func failClosedOpenAIDashboardSnapshot() {
+        self.applyOpenAIDashboardCleanup(Set(CodexDashboardCleanup.allCases), preserveVisibleDashboard: false)
+        self.openAIDashboardRequiresLogin = true
+    }
+
+    private func applyOpenAIDashboardAuthorityDecision(
+        _ decision: CodexDashboardAuthorityDecision,
+        dashboard: OpenAIDashboardSnapshot,
+        authorityInput: CodexDashboardAuthorityInput,
+        attachedAccountEmail: String?,
+        allowCodexUsageBackfill: Bool) async
+    {
+        switch decision.disposition {
+        case .attach:
+            self.openAIDashboard = dashboard
+            self.openAIDashboardAttachmentAuthorized = true
+            self.lastOpenAIDashboardSnapshot = dashboard
+            self.lastOpenAIDashboardAttachmentAuthorized = true
+            self.lastOpenAIDashboardError = nil
+            self.openAIDashboardRequiresLogin = false
+
+            if decision.allowedEffects.contains(.usageBackfill),
+               allowCodexUsageBackfill,
+               self.snapshots[.codex] == nil,
+               let usage = dashboard.toUsageSnapshot(provider: .codex, accountEmail: attachedAccountEmail)
+            {
+                self.snapshots[.codex] = usage
+                self.errors[.codex] = nil
+                self.failureGates[.codex]?.recordSuccess()
+                self.lastSourceLabels[.codex] = "openai-web"
+            }
+
+            if decision.allowedEffects.contains(.creditsAttachment),
+               self.credits == nil,
+               let credits = dashboard.toCreditsSnapshot()
+            {
+                self.credits = credits
+                self.lastCreditsSnapshot = credits
+                self.lastCreditsSnapshotAccountKey = Self.normalizeCodexAccountScopedKey(attachedAccountEmail)
+                self.lastCreditsSource = .dashboardWeb
+                self.lastCreditsError = nil
+                self.creditsFailureStreak = 0
+            }
+
+            if decision.allowedEffects.contains(.refreshGuardSeed) {
+                self.seedCodexAccountScopedRefreshGuard(accountEmail: attachedAccountEmail)
+            }
+
+            if let attachedAccountEmail, !attachedAccountEmail.isEmpty {
+                OpenAIDashboardCacheStore.save(OpenAIDashboardCache(
+                    accountEmail: attachedAccountEmail,
+                    snapshot: dashboard))
+            }
+
+            if decision.allowedEffects.contains(.historicalBackfill) {
+                self.backfillCodexHistoricalFromDashboardIfNeeded(
+                    dashboard,
+                    authorityDecision: decision,
+                    attachedAccountEmail: attachedAccountEmail)
+            }
+
+        case .displayOnly:
+            self.applyOpenAIDashboardCleanup(decision.cleanup, preserveVisibleDashboard: true)
+            self.openAIDashboard = dashboard
+            self.openAIDashboardAttachmentAuthorized = false
+            self.lastOpenAIDashboardSnapshot = dashboard
+            self.lastOpenAIDashboardAttachmentAuthorized = false
+            self.lastOpenAIDashboardError = nil
+            self.openAIDashboardRequiresLogin = false
+
+        case .failClosed:
+            self.applyOpenAIDashboardCleanup(decision.cleanup, preserveVisibleDashboard: false)
+            self.lastOpenAIDashboardError = self.openAIDashboardPolicyFailureMessage(
+                for: decision,
+                authorityInput: authorityInput)
+            self.openAIDashboardRequiresLogin = true
+        }
+    }
+
+    private func applyOpenAIDashboardCleanup(
+        _ cleanup: Set<CodexDashboardCleanup>,
+        preserveVisibleDashboard: Bool)
+    {
+        if cleanup.contains(.dashboardDerivedUsage) {
+            self.clearDashboardDerivedCodexUsageIfNeeded()
+        }
+        if cleanup.contains(.dashboardDerivedCredits) {
+            self.clearDashboardDerivedCreditsIfNeeded()
+        }
+        if cleanup.contains(.dashboardRefreshGuardSeed) {
+            self.clearDashboardRefreshGuardSeedIfNeeded()
+        }
+        if cleanup.contains(.dashboardCache) {
+            OpenAIDashboardCacheStore.clear()
+        }
+        if cleanup.contains(.dashboardSnapshot), !preserveVisibleDashboard {
+            self.openAIDashboard = nil
+            self.openAIDashboardAttachmentAuthorized = false
+            self.lastOpenAIDashboardSnapshot = nil
+            self.lastOpenAIDashboardAttachmentAuthorized = false
+        }
+    }
+
+    private func clearDashboardDerivedCodexUsageIfNeeded() {
+        guard self.lastSourceLabels[.codex] == "openai-web" else { return }
+        self.snapshots.removeValue(forKey: .codex)
+        self.errors[.codex] = nil
+        self.lastSourceLabels.removeValue(forKey: .codex)
+        self.lastFetchAttempts.removeValue(forKey: .codex)
+        self.accountSnapshots.removeValue(forKey: .codex)
+        self.codexAccountSnapshots = []
+        self.failureGates[.codex]?.reset()
+        self.lastKnownSessionRemaining.removeValue(forKey: .codex)
+        self.lastKnownSessionWindowSource.removeValue(forKey: .codex)
+    }
+
+    private func clearDashboardDerivedCreditsIfNeeded() {
+        guard self.lastCreditsSource == .dashboardWeb else { return }
+        self.credits = nil
+        self.lastCreditsError = nil
+        self.lastCreditsSnapshot = nil
+        self.lastCreditsSnapshotAccountKey = nil
+        self.lastCreditsSource = .none
+        self.creditsFailureStreak = 0
+    }
+
+    private func clearDashboardRefreshGuardSeedIfNeeded() {
+        self.lastCodexAccountScopedRefreshGuard = self.currentCodexAccountScopedRefreshGuard(
+            preferCurrentSnapshot: false,
+            allowLastKnownLiveFallback: false)
+    }
+
+    private func openAIDashboardPolicyFailureMessage(
+        for decision: CodexDashboardAuthorityDecision,
+        authorityInput: CodexDashboardAuthorityInput) -> String
+    {
+        switch decision.reason {
+        case let .wrongEmail(expected, actual):
+            [
+                "OpenAI dashboard signed in as \(actual ?? "unknown"), but Codex uses \(expected ?? "unknown").",
+                "Switch accounts in your browser and update OpenAI cookies in Providers → Codex.",
+            ].joined(separator: " ")
+        case let .sameEmailAmbiguity(email):
+            "OpenAI dashboard ownership is ambiguous for \(email); Codex will not attach dashboard data."
+        case .missingDashboardSignedInEmail:
+            "OpenAI dashboard did not report a signed-in account. Refresh OpenAI cookies and try again."
+        case .unresolvedWithoutTrustedEvidence:
+            "OpenAI dashboard ownership could not be verified for the active Codex account."
+        case .providerAccountMissingScopedEmail:
+            "Codex account ownership could not be verified because the scoped email is unavailable."
+        case .providerAccountLacksExactOwnershipProof:
+            [
+                "OpenAI dashboard ownership could not be matched to the active Codex account.",
+                "Refresh Codex account data, then retry OpenAI web access.",
+            ].joined(separator: " ")
+        case .exactProviderAccountMatch,
+             .trustedEmailMatchNoCompetingOwner,
+             .trustedContinuityNoCompetingOwner:
+            "OpenAI dashboard ownership policy blocked this dashboard."
+        }
+    }
+
+    func refreshOpenAIDashboardIfNeeded(
+        force: Bool = false,
+        expectedGuard: CodexAccountScopedRefreshGuard? = nil,
+        bypassCoalescing: Bool = false,
+        allowCodexUsageBackfill: Bool = true) async
+    {
+        self.syncOpenAIWebState()
+        guard self.isEnabled(.codex),
+              self.settings.openAIWebAccessEnabled,
+              self.settings.codexCookieSource.isEnabled
+        else { return }
+        if self.openAIWebManagedTargetStoreIsUnreadable() {
+            await self.failClosedRefreshForUnreadableManagedCodexStore()
+            return
+        }
+        if self.openAIWebManagedTargetIsMissing() {
+            await self.failClosedRefreshForMissingManagedCodexTarget()
+            return
+        }
+        if self.openAIWebProfileTargetEmailIsMissing() {
+            await self.failClosedRefreshForMissingProfileCodexTarget()
+            return
+        }
+
+        let allowCurrentSnapshotFallback = expectedGuard?.source == .liveSystem && expectedGuard?
+            .identity == .unresolved
+        let targetEmail = self.currentCodexOpenAIWebTargetEmail(
+            allowCurrentSnapshotFallback: allowCurrentSnapshotFallback,
+            allowLastKnownLiveFallback: expectedGuard?.identity != .unresolved)
+        let refreshKey = self.openAIDashboardRefreshKey(targetEmail: targetEmail, expectedGuard: expectedGuard)
+        if !bypassCoalescing,
+           let task = self.openAIDashboardRefreshTask,
+           self.openAIDashboardRefreshTaskKey == refreshKey
+        {
+            await task.value
+            return
+        }
+        self.handleOpenAIWebTargetEmailChangeIfNeeded(
+            targetEmail: targetEmail,
+            targetScope: self.codexCookieCacheScopeForOpenAIWeb())
+
+        let now = Date()
+        let minInterval = self.openAIWebRefreshIntervalSeconds()
+        let refreshGate = OpenAIWebRefreshGateContext(
+            force: force,
+            accountDidChange: self.openAIWebAccountDidChange,
+            lastError: self.lastOpenAIDashboardError,
+            lastSnapshotAt: self.lastOpenAIDashboardSnapshot?.updatedAt,
+            lastAttemptAt: self.lastOpenAIDashboardAttemptAt,
+            now: now,
+            refreshInterval: minInterval)
+        if Self.shouldSkipOpenAIWebRefresh(refreshGate) {
+            return
+        }
+        self.lastOpenAIDashboardAttemptAt = now
+
+        let taskToken = UUID()
+        let context = OpenAIDashboardRefreshContext(
+            targetEmail: targetEmail,
+            allowCurrentSnapshotFallback: allowCurrentSnapshotFallback,
+            expectedGuard: expectedGuard,
+            refreshTaskToken: taskToken,
+            allowCodexUsageBackfill: allowCodexUsageBackfill,
+            force: force)
+        let task = Task { [weak self] in
+            guard let self else { return }
+            await self.performOpenAIDashboardRefreshIfNeeded(context)
+        }
+        self.openAIDashboardRefreshTask = task
+        self.openAIDashboardRefreshTaskKey = refreshKey
+        self.openAIDashboardRefreshTaskToken = taskToken
+        await task.value
+        if self.openAIDashboardRefreshTaskToken == taskToken {
+            self.openAIDashboardRefreshTask = nil
+            self.openAIDashboardRefreshTaskKey = nil
+            self.openAIDashboardRefreshTaskToken = nil
+        }
+    }
+
+    func scheduleOpenAIDashboardRefreshIfNeeded(expectedGuard: CodexAccountScopedRefreshGuard? = nil) {
+        self.syncOpenAIWebState()
+        let allowCurrentSnapshotFallback = expectedGuard?.source == .liveSystem && expectedGuard?
+            .identity == .unresolved
+        let targetEmail = self.currentCodexOpenAIWebTargetEmail(
+            allowCurrentSnapshotFallback: allowCurrentSnapshotFallback,
+            allowLastKnownLiveFallback: expectedGuard?.identity != .unresolved)
+        let refreshKey = self.openAIDashboardRefreshKey(targetEmail: targetEmail, expectedGuard: expectedGuard)
+        if let task = self.openAIDashboardBackgroundRefreshTask,
+           !task.isCancelled,
+           self.openAIDashboardBackgroundRefreshTaskKey == refreshKey
+        {
+            return
+        }
+
+        if self.openAIDashboardBackgroundRefreshTaskKey != nil,
+           self.openAIDashboardBackgroundRefreshTaskKey != refreshKey
+        {
+            self.invalidateOpenAIDashboardRefreshTask()
+        }
+        self.openAIDashboardBackgroundRefreshTask?.cancel()
+        self.openAIDashboardBackgroundRefreshTaskKey = refreshKey
+        self.openAIDashboardBackgroundRefreshTask = Task(priority: .utility) { @MainActor [weak self] in
+            guard let self else { return }
+            defer {
+                if self.openAIDashboardBackgroundRefreshTaskKey == refreshKey {
+                    self.openAIDashboardBackgroundRefreshTask = nil
+                    self.openAIDashboardBackgroundRefreshTaskKey = nil
+                }
+            }
+
+            await self.refreshOpenAIDashboardIfNeeded(force: false, expectedGuard: expectedGuard)
+            guard !Task.isCancelled else { return }
+            self.persistWidgetSnapshot(reason: "dashboard")
+        }
+    }
+
+    private func performOpenAIDashboardRefreshIfNeeded(_ context: OpenAIDashboardRefreshContext) async {
+        guard self.shouldContinueOpenAIDashboardRefresh(token: context.refreshTaskToken) else { return }
+        self.openAIDashboardCookieImportStatus = nil
+        var latestCookieImportStatus: String?
+        if self.openAIWebDebugLines.isEmpty {
+            self.resetOpenAIWebDebugLog(context: "refresh")
+        } else {
+            let stamp = Date().formatted(date: .abbreviated, time: .shortened)
+            self.logOpenAIWeb("[\(stamp)] OpenAI web refresh start")
+        }
+        let log: (String) -> Void = { [weak self] line in
+            guard let self else { return }
+            self.logOpenAIWeb(line)
+        }
+
+        do {
+            let normalized = context.targetEmail?
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+                .lowercased()
+            var effectiveEmail = context.targetEmail
+
+            // Use a per-email persistent `WKWebsiteDataStore` so multiple dashboard sessions can coexist.
+            // Strategy:
+            // - Try the existing per-email WebKit cookie store first (fast; avoids Keychain prompts).
+            // - On login-required or account mismatch, import cookies from the configured browser order and retry once.
+            var didImportCookiesForRefresh = false
+            if self.openAIWebAccountDidChange, let targetEmail = context.targetEmail, !targetEmail.isEmpty {
+                // On account switches, proactively re-import cookies so we don't show stale data from the previous
+                // user.
+                let imported = await self.importOpenAIDashboardCookiesIfNeeded(
+                    targetEmail: targetEmail,
+                    force: true)
+                guard self.shouldContinueOpenAIDashboardRefresh(token: context.refreshTaskToken) else { return }
+                didImportCookiesForRefresh = true
+                latestCookieImportStatus = self.currentOpenAIDashboardCookieImportStatus()
+                if await self.abortOpenAIDashboardRetryAfterImportFailure(
+                    importedEmail: imported,
+                    targetEmail: targetEmail,
+                    expectedGuard: context.expectedGuard,
+                    cookieImportStatus: latestCookieImportStatus,
+                    refreshTaskToken: context.refreshTaskToken)
+                {
+                    self.openAIWebAccountDidChange = false
+                    return
+                }
+                if let imported {
+                    effectiveEmail = imported
+                }
+                self.openAIWebAccountDidChange = false
+            }
+
+            var dash = try await self.loadLatestOpenAIDashboard(
+                accountEmail: effectiveEmail,
+                logger: log,
+                allowNavigationTimeoutRetry: context.force,
+                timeout: Self.openAIWebDashboardFetchTimeout(didImportCookies: didImportCookiesForRefresh))
+            guard self.shouldContinueOpenAIDashboardRefresh(token: context.refreshTaskToken) else { return }
+
+            if self.dashboardEmailMismatch(expected: normalized, actual: dash.signedInEmail) {
+                if let imported = await self.importOpenAIDashboardCookiesIfNeeded(
+                    targetEmail: context.targetEmail,
+                    force: true)
+                {
+                    guard self.shouldContinueOpenAIDashboardRefresh(token: context.refreshTaskToken) else { return }
+                    effectiveEmail = imported
+                }
+                latestCookieImportStatus = self.currentOpenAIDashboardCookieImportStatus()
+                dash = try await self.loadLatestOpenAIDashboard(
+                    accountEmail: effectiveEmail,
+                    logger: log,
+                    allowNavigationTimeoutRetry: context.force,
+                    timeout: Self.openAIWebRetryDashboardFetchTimeout(afterCookieImport: true))
+                guard self.shouldContinueOpenAIDashboardRefresh(token: context.refreshTaskToken) else { return }
+            }
+
+            await self.applyOpenAIDashboard(
+                dash,
+                targetEmail: effectiveEmail,
+                expectedGuard: context.expectedGuard,
+                refreshTaskToken: context.refreshTaskToken,
+                allowCodexUsageBackfill: context.allowCodexUsageBackfill)
+        } catch let OpenAIDashboardFetcher.FetchError.noDashboardData(body) {
+            guard self.shouldContinueOpenAIDashboardRefresh(token: context.refreshTaskToken) else { return }
+            await self.retryOpenAIDashboardAfterNoData(
+                body: body,
+                context: context,
+                latestCookieImportStatus: &latestCookieImportStatus,
+                logger: log)
+        } catch OpenAIDashboardFetcher.FetchError.loginRequired {
+            guard self.shouldContinueOpenAIDashboardRefresh(token: context.refreshTaskToken) else { return }
+            await self.retryOpenAIDashboardAfterLoginRequired(
+                context: context,
+                latestCookieImportStatus: &latestCookieImportStatus,
+                logger: log)
+        } catch {
+            guard self.shouldContinueOpenAIDashboardRefresh(token: context.refreshTaskToken) else { return }
+            if Self.isOpenAIDashboardTimeout(error) {
+                await self.retryOpenAIDashboardAfterTimeout(
+                    context: context,
+                    latestCookieImportStatus: &latestCookieImportStatus,
+                    logger: log)
+                return
+            }
+            let message = self.preferredOpenAIDashboardFailureMessage(
+                error: error,
+                targetEmail: context.targetEmail,
+                cookieImportStatus: latestCookieImportStatus)
+            await self.applyOpenAIDashboardFailure(
+                message: message,
+                expectedGuard: context.expectedGuard,
+                refreshTaskToken: context.refreshTaskToken,
+                routingTargetEmail: context.targetEmail)
+        }
+    }
+
+    private func retryOpenAIDashboardAfterTimeout(
+        context: OpenAIDashboardRefreshContext,
+        latestCookieImportStatus: inout String?,
+        logger: @escaping (String) -> Void) async
+    {
+        if !context.force {
+            OpenAIDashboardFetcher.evictAllCachedWebViews()
+            logger("OpenAI web refresh timed out; skipping immediate background retry.")
+            await self.applyOpenAIDashboardFailure(
+                message: "OpenAI web dashboard refresh timed out. CodexBar will retry after the refresh cooldown.",
+                expectedGuard: context.expectedGuard,
+                refreshTaskToken: context.refreshTaskToken,
+                routingTargetEmail: context.targetEmail)
+            return
+        }
+
+        let targetEmail = self.currentCodexOpenAIWebTargetEmail(
+            allowCurrentSnapshotFallback: context.allowCurrentSnapshotFallback,
+            allowLastKnownLiveFallback: context.expectedGuard?.identity != .unresolved)
+        var effectiveEmail = targetEmail
+        let imported = await self.importOpenAIDashboardCookiesIfNeeded(
+            targetEmail: targetEmail,
+            force: true,
+            preferCachedCookieHeader: true)
+        guard self.shouldContinueOpenAIDashboardRefresh(token: context.refreshTaskToken) else { return }
+        latestCookieImportStatus = self.currentOpenAIDashboardCookieImportStatus()
+        if await self.abortOpenAIDashboardRetryAfterImportFailure(
+            importedEmail: imported,
+            targetEmail: targetEmail,
+            expectedGuard: context.expectedGuard,
+            cookieImportStatus: latestCookieImportStatus,
+            refreshTaskToken: context.refreshTaskToken)
+        {
+            return
+        }
+        if let imported {
+            effectiveEmail = imported
+        }
+        do {
+            let dash = try await self.loadLatestOpenAIDashboard(
+                accountEmail: effectiveEmail,
+                logger: logger,
+                allowNavigationTimeoutRetry: context.force,
+                timeout: Self.openAIWebRetryDashboardFetchTimeout(afterCookieImport: true))
+            guard self.shouldContinueOpenAIDashboardRefresh(token: context.refreshTaskToken) else { return }
+            await self.applyOpenAIDashboard(
+                dash,
+                targetEmail: effectiveEmail,
+                expectedGuard: context.expectedGuard,
+                refreshTaskToken: context.refreshTaskToken,
+                allowCodexUsageBackfill: context.allowCodexUsageBackfill)
+        } catch {
+            guard self.shouldContinueOpenAIDashboardRefresh(token: context.refreshTaskToken) else { return }
+            let message = self.preferredOpenAIDashboardFailureMessage(
+                error: error,
+                targetEmail: targetEmail,
+                cookieImportStatus: latestCookieImportStatus)
+            await self.applyOpenAIDashboardFailure(
+                message: message,
+                expectedGuard: context.expectedGuard,
+                refreshTaskToken: context.refreshTaskToken,
+                routingTargetEmail: targetEmail)
+        }
+    }
+
+    private func retryOpenAIDashboardAfterNoData(
+        body: String,
+        context: OpenAIDashboardRefreshContext,
+        latestCookieImportStatus: inout String?,
+        logger: @escaping (String) -> Void) async
+    {
+        let targetEmail = self.currentCodexOpenAIWebTargetEmail(
+            allowCurrentSnapshotFallback: context.allowCurrentSnapshotFallback,
+            allowLastKnownLiveFallback: context.expectedGuard?.identity != .unresolved)
+        var effectiveEmail = targetEmail
+        let imported = await self.importOpenAIDashboardCookiesIfNeeded(targetEmail: targetEmail, force: true)
+        guard self.shouldContinueOpenAIDashboardRefresh(token: context.refreshTaskToken) else { return }
+        latestCookieImportStatus = self.currentOpenAIDashboardCookieImportStatus()
+        if await self.abortOpenAIDashboardRetryAfterImportFailure(
+            importedEmail: imported,
+            targetEmail: targetEmail,
+            expectedGuard: context.expectedGuard,
+            cookieImportStatus: latestCookieImportStatus,
+            refreshTaskToken: context.refreshTaskToken)
+        {
+            return
+        }
+        if let imported {
+            effectiveEmail = imported
+        }
+        do {
+            let dash = try await self.loadLatestOpenAIDashboard(
+                accountEmail: effectiveEmail,
+                logger: logger,
+                allowNavigationTimeoutRetry: context.force,
+                timeout: Self.openAIWebRetryDashboardFetchTimeout(afterCookieImport: true))
+            guard self.shouldContinueOpenAIDashboardRefresh(token: context.refreshTaskToken) else { return }
+            await self.applyOpenAIDashboard(
+                dash,
+                targetEmail: effectiveEmail,
+                expectedGuard: context.expectedGuard,
+                refreshTaskToken: context.refreshTaskToken,
+                allowCodexUsageBackfill: context.allowCodexUsageBackfill)
+        } catch let OpenAIDashboardFetcher.FetchError.noDashboardData(retryBody) {
+            guard self.shouldContinueOpenAIDashboardRefresh(token: context.refreshTaskToken) else { return }
+            let finalBody = retryBody.isEmpty ? body : retryBody
+            let message = self.openAIDashboardFriendlyError(
+                body: finalBody,
+                targetEmail: targetEmail,
+                cookieImportStatus: latestCookieImportStatus)
+                ?? OpenAIDashboardFetcher.FetchError.noDashboardData(body: finalBody).localizedDescription
+            await self.applyOpenAIDashboardFailure(
+                message: message,
+                expectedGuard: context.expectedGuard,
+                refreshTaskToken: context.refreshTaskToken,
+                routingTargetEmail: targetEmail)
+        } catch {
+            guard self.shouldContinueOpenAIDashboardRefresh(token: context.refreshTaskToken) else { return }
+            let message = self.preferredOpenAIDashboardFailureMessage(
+                error: error,
+                targetEmail: targetEmail,
+                cookieImportStatus: latestCookieImportStatus)
+            await self.applyOpenAIDashboardFailure(
+                message: message,
+                expectedGuard: context.expectedGuard,
+                refreshTaskToken: context.refreshTaskToken,
+                routingTargetEmail: targetEmail)
+        }
+    }
+
+    private func retryOpenAIDashboardAfterLoginRequired(
+        context: OpenAIDashboardRefreshContext,
+        latestCookieImportStatus: inout String?,
+        logger: @escaping (String) -> Void) async
+    {
+        let targetEmail = self.currentCodexOpenAIWebTargetEmail(
+            allowCurrentSnapshotFallback: context.allowCurrentSnapshotFallback,
+            allowLastKnownLiveFallback: context.expectedGuard?.identity != .unresolved)
+        var effectiveEmail = targetEmail
+        let imported = await self.importOpenAIDashboardCookiesIfNeeded(targetEmail: targetEmail, force: true)
+        guard self.shouldContinueOpenAIDashboardRefresh(token: context.refreshTaskToken) else { return }
+        latestCookieImportStatus = self.currentOpenAIDashboardCookieImportStatus()
+        if await self.abortOpenAIDashboardRetryAfterImportFailure(
+            importedEmail: imported,
+            targetEmail: targetEmail,
+            expectedGuard: context.expectedGuard,
+            cookieImportStatus: latestCookieImportStatus,
+            refreshTaskToken: context.refreshTaskToken)
+        {
+            return
+        }
+        if let imported {
+            effectiveEmail = imported
+        }
+        do {
+            let dash = try await self.loadLatestOpenAIDashboard(
+                accountEmail: effectiveEmail,
+                logger: logger,
+                allowNavigationTimeoutRetry: context.force,
+                timeout: Self.openAIWebRetryDashboardFetchTimeout(afterCookieImport: true))
+            guard self.shouldContinueOpenAIDashboardRefresh(token: context.refreshTaskToken) else { return }
+            await self.applyOpenAIDashboard(
+                dash,
+                targetEmail: effectiveEmail,
+                expectedGuard: context.expectedGuard,
+                refreshTaskToken: context.refreshTaskToken,
+                allowCodexUsageBackfill: context.allowCodexUsageBackfill)
+        } catch OpenAIDashboardFetcher.FetchError.loginRequired {
+            guard self.shouldContinueOpenAIDashboardRefresh(token: context.refreshTaskToken) else { return }
+            await self.applyOpenAIDashboardLoginRequiredFailure(
+                expectedGuard: context.expectedGuard,
+                refreshTaskToken: context.refreshTaskToken,
+                routingTargetEmail: targetEmail)
+        } catch {
+            guard self.shouldContinueOpenAIDashboardRefresh(token: context.refreshTaskToken) else { return }
+            let message = self.preferredOpenAIDashboardFailureMessage(
+                error: error,
+                targetEmail: targetEmail,
+                cookieImportStatus: latestCookieImportStatus)
+            await self.applyOpenAIDashboardFailure(
+                message: message,
+                expectedGuard: context.expectedGuard,
+                refreshTaskToken: context.refreshTaskToken,
+                routingTargetEmail: targetEmail)
+        }
+    }
+
+    // MARK: - OpenAI web account switching
+
+    /// Detect Codex account-source changes and clear stale OpenAI web state so the UI can't show the wrong user.
+    /// This does not delete other isolated WebKit cookie stores (we keep multiple accounts around).
+    func handleOpenAIWebTargetEmailChangeIfNeeded(
+        targetEmail: String?,
+        targetScope: CookieHeaderCache.Scope? = nil)
+    {
+        let normalized = targetEmail?
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .lowercased()
+
+        guard let normalized, !normalized.isEmpty else { return }
+
+        let isolationKey = Self.openAIWebTargetIsolationKey(email: normalized, scope: targetScope)
+        let previousIsolationKey = self.lastOpenAIDashboardTargetIsolationKey
+        self.lastOpenAIDashboardTargetEmail = normalized
+        self.lastOpenAIDashboardTargetIsolationKey = isolationKey
+
+        if let previousIsolationKey,
+           previousIsolationKey != isolationKey
+        {
+            let stamp = Date().formatted(date: .abbreviated, time: .shortened)
+            self.logOpenAIWeb(
+                "[\(stamp)] Codex account source changed; clearing OpenAI web snapshot")
+            self.openAIWebAccountDidChange = true
+            self.openAIDashboard = nil
+            self.openAIDashboardAttachmentAuthorized = false
+            self.lastOpenAIDashboardSnapshot = nil
+            self.lastOpenAIDashboardAttachmentAuthorized = false
+            self.lastOpenAIDashboardError = nil
+            self.lastOpenAIDashboardAttemptAt = nil
+            self.openAIDashboardRequiresLogin = true
+            self.openAIDashboardCookieImportStatus = "Codex account changed; importing browser cookies…"
+            self.lastOpenAIDashboardCookieImportAttemptAt = nil
+            self.lastOpenAIDashboardCookieImportEmail = nil
+        }
+    }
+
+    nonisolated static func openAIWebTargetIsolationKey(
+        email: String,
+        scope: CookieHeaderCache.Scope?) -> String
+    {
+        "\(email.lowercased())|\(scope?.isolationIdentifier ?? "live")"
+    }
+
+    func importOpenAIDashboardBrowserCookiesNow() async {
+        self.resetOpenAIWebDebugLog(context: "manual import")
+        let targetEmail = self.currentCodexOpenAIWebTargetEmail(
+            allowCurrentSnapshotFallback: true,
+            allowLastKnownLiveFallback: false)
+        _ = await self.importOpenAIDashboardCookiesIfNeeded(targetEmail: targetEmail, force: true)
+        let expectedGuard = self.freshCodexOpenAIWebRefreshGuard()
+        await self.refreshOpenAIDashboardIfNeeded(
+            force: true,
+            expectedGuard: expectedGuard,
+            bypassCoalescing: true)
+    }
+
+    func currentCodexOpenAIWebTargetEmail(
+        allowCurrentSnapshotFallback: Bool,
+        allowLastKnownLiveFallback: Bool) -> String?
+    {
+        switch self.settings.codexResolvedActiveSource {
+        case .liveSystem:
+            let liveSystem = self.settings.codexAccountReconciliationSnapshot.liveSystemAccount?.email
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+            if let liveSystem, !liveSystem.isEmpty {
+                self.lastKnownLiveSystemCodexEmail = liveSystem
+                return liveSystem
+            }
+
+            if allowCurrentSnapshotFallback,
+               let snapshotEmail = self.snapshots[.codex]?.accountEmail(for: .codex)?
+                   .trimmingCharacters(in: .whitespacesAndNewlines),
+                   !snapshotEmail.isEmpty
+            {
+                self.lastKnownLiveSystemCodexEmail = snapshotEmail
+                return snapshotEmail
+            }
+
+            if allowLastKnownLiveFallback {
+                let lastKnown = self.lastKnownLiveSystemCodexEmail?.trimmingCharacters(in: .whitespacesAndNewlines)
+                if let lastKnown, !lastKnown.isEmpty { return lastKnown }
+            }
+            return nil
+        case .managedAccount:
+            return self.codexAccountEmailForOpenAIDashboard()
+        case let .profileHome(path):
+            return self.currentProfileCodexRuntimeEmail(path: path)
+        }
+    }
+
+    private func openAIDashboardRefreshKey(
+        targetEmail: String?,
+        expectedGuard: CodexAccountScopedRefreshGuard?) -> String
+    {
+        let source = String(describing: expectedGuard?.source ?? self.settings.codexResolvedActiveSource)
+        let identityKey = Self.codexIdentityGuardKey(expectedGuard?.identity ?? .unresolved) ?? "unresolved"
+        let accountKey = Self.normalizeCodexAccountScopedKey(targetEmail) ?? "unknown"
+        let authFingerprint = CodexAuthFingerprint.normalize(expectedGuard?.authFingerprint) ?? "nil"
+        return "\(source)|\(identityKey)|\(accountKey)|auth:\(authFingerprint)"
+    }
+
+    private func actionableOpenAIDashboardImportFailure(targetEmail: String?) -> String? {
+        self.actionableOpenAIDashboardImportFailure(
+            targetEmail: targetEmail,
+            cookieImportStatus: self.openAIDashboardCookieImportStatus)
+    }
+
+    private func actionableOpenAIDashboardImportFailure(
+        targetEmail: String?,
+        cookieImportStatus: String?) -> String?
+    {
+        let status = cookieImportStatus?.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard let status, !status.isEmpty else { return nil }
+
+        if status.localizedCaseInsensitiveContains("openai cookies are for") {
+            return "\(status) Switch chatgpt.com account, then refresh OpenAI cookies."
+        }
+        if status.localizedCaseInsensitiveContains("no signed-in openai web session found")
+            || status.localizedCaseInsensitiveContains("no matching openai web session found")
+        {
+            let targetLabel = targetEmail?.trimmingCharacters(in: .whitespacesAndNewlines)
+            let accountLabel = (targetLabel?.isEmpty == false) ? targetLabel! : "your OpenAI account"
+            return "\(status) Sign in to chatgpt.com as \(accountLabel), then refresh OpenAI cookies."
+        }
+        if status.localizedCaseInsensitiveContains("openai cookie import failed")
+            || status.localizedCaseInsensitiveContains("browser cookie import failed")
+        {
+            return status
+        }
+        return nil
+    }
+
+    private func preferredOpenAIDashboardFailureMessage(
+        error: Error,
+        targetEmail: String?,
+        cookieImportStatus: String?) -> String
+    {
+        if let actionable = self.actionableOpenAIDashboardImportFailure(
+            targetEmail: targetEmail,
+            cookieImportStatus: cookieImportStatus)
+        {
+            return actionable
+        }
+        return error.localizedDescription
+    }
+
+    private static func isOpenAIDashboardTimeout(_ error: Error) -> Bool {
+        let nsError = error as NSError
+        return nsError.domain == NSURLErrorDomain && nsError.code == NSURLErrorTimedOut
+    }
+
+    private func abortOpenAIDashboardRetryAfterImportFailure(
+        importedEmail: String?,
+        targetEmail: String?,
+        expectedGuard: CodexAccountScopedRefreshGuard?,
+        cookieImportStatus: String?,
+        refreshTaskToken: UUID) async -> Bool
+    {
+        guard importedEmail == nil,
+              let message = self.actionableOpenAIDashboardImportFailure(
+                  targetEmail: targetEmail,
+                  cookieImportStatus: cookieImportStatus)
+        else {
+            return false
+        }
+        await self.applyOpenAIDashboardFailure(
+            message: message,
+            expectedGuard: expectedGuard,
+            refreshTaskToken: refreshTaskToken,
+            routingTargetEmail: targetEmail)
+        return true
+    }
+
+    private func shouldApplyOpenAIDashboardRefreshTask(token: UUID?) -> Bool {
+        guard let token else { return true }
+        return self.openAIDashboardRefreshTaskToken == token
+    }
+
+    private func shouldContinueOpenAIDashboardRefresh(token: UUID?) -> Bool {
+        !Task.isCancelled && self.shouldApplyOpenAIDashboardRefreshTask(token: token)
+    }
+
+    func invalidateOpenAIDashboardRefreshTask() {
+        self.openAIDashboardBackgroundRefreshTask?.cancel()
+        self.openAIDashboardBackgroundRefreshTask = nil
+        self.openAIDashboardBackgroundRefreshTaskKey = nil
+        self.openAIDashboardRefreshTask?.cancel()
+        self.openAIDashboardRefreshTask = nil
+        self.openAIDashboardRefreshTaskKey = nil
+        self.openAIDashboardRefreshTaskToken = nil
+    }
+
+    private func currentOpenAIDashboardCookieImportStatus() -> String? {
+        self.openAIDashboardCookieImportStatus
+    }
+
+    private func loadLatestOpenAIDashboard(
+        accountEmail: String?,
+        logger: @escaping (String) -> Void,
+        allowNavigationTimeoutRetry: Bool,
+        timeout: TimeInterval) async throws -> OpenAIDashboardSnapshot
+    {
+        if let override = self._test_openAIDashboardLoaderOverride {
+            return try await override(accountEmail, logger, allowNavigationTimeoutRetry, timeout)
+        }
+        return try await OpenAIDashboardFetcher().loadLatestDashboard(
+            accountEmail: accountEmail,
+            cacheScope: self.codexCookieCacheScopeForOpenAIWeb(),
+            logger: logger,
+            debugDumpHTML: timeout != Self.openAIWebPrimaryFetchTimeout,
+            allowNavigationTimeoutRetry: allowNavigationTimeoutRetry,
+            timeout: timeout)
+    }
+
+    private func failClosedForUnreadableManagedCodexStore() async -> String? {
+        self.applyOpenAIDashboardCleanup(Set(CodexDashboardCleanup.allCases), preserveVisibleDashboard: false)
+        self.openAIDashboardRequiresLogin = true
+        self.openAIDashboardCookieImportStatus = [
+            "Managed Codex account data is unavailable.",
+            "Fix the managed account store before importing OpenAI cookies.",
+        ].joined(separator: " ")
+        return nil
+    }
+
+    private func failClosedRefreshForUnreadableManagedCodexStore() async {
+        self.applyOpenAIDashboardCleanup(Set(CodexDashboardCleanup.allCases), preserveVisibleDashboard: false)
+        self.openAIDashboardRequiresLogin = true
+        self.lastOpenAIDashboardError = [
+            "Managed Codex account data is unavailable.",
+            "Fix the managed account store before refreshing OpenAI web data.",
+        ].joined(separator: " ")
+    }
+
+    private func failClosedForMissingManagedCodexTarget() async -> String? {
+        self.applyOpenAIDashboardCleanup(Set(CodexDashboardCleanup.allCases), preserveVisibleDashboard: false)
+        self.openAIDashboardRequiresLogin = true
+        self.openAIDashboardCookieImportStatus = [
+            "The selected managed Codex account is unavailable.",
+            "Pick another Codex account before importing OpenAI cookies.",
+        ].joined(separator: " ")
+        return nil
+    }
+
+    private func failClosedRefreshForMissingManagedCodexTarget() async {
+        self.applyOpenAIDashboardCleanup(Set(CodexDashboardCleanup.allCases), preserveVisibleDashboard: false)
+        self.openAIDashboardRequiresLogin = true
+        self.lastOpenAIDashboardError = [
+            "The selected managed Codex account is unavailable.",
+            "Pick another Codex account before refreshing OpenAI web data.",
+        ].joined(separator: " ")
+    }
+
+    private func failClosedForMissingProfileCodexTarget() async -> String? {
+        self.applyOpenAIDashboardCleanup(Set(CodexDashboardCleanup.allCases), preserveVisibleDashboard: false)
+        self.openAIDashboardRequiresLogin = true
+        self.openAIDashboardCookieImportStatus = [
+            "The selected Codex profile has no verified account email.",
+            "Refresh the profile before importing OpenAI cookies.",
+        ].joined(separator: " ")
+        return nil
+    }
+
+    private func failClosedRefreshForMissingProfileCodexTarget() async {
+        self.applyOpenAIDashboardCleanup(Set(CodexDashboardCleanup.allCases), preserveVisibleDashboard: false)
+        self.openAIDashboardRequiresLogin = true
+        self.lastOpenAIDashboardError = [
+            "The selected Codex profile has no verified account email.",
+            "Refresh the profile before refreshing OpenAI web data.",
+        ].joined(separator: " ")
+    }
+
+    private func openAIWebCookieImportShouldFailClosed() async -> Bool {
+        if self.openAIWebManagedTargetStoreIsUnreadable() {
+            _ = await self.failClosedForUnreadableManagedCodexStore()
+            return true
+        }
+        if self.openAIWebManagedTargetIsMissing() {
+            _ = await self.failClosedForMissingManagedCodexTarget()
+            return true
+        }
+        if self.openAIWebProfileTargetEmailIsMissing() {
+            _ = await self.failClosedForMissingProfileCodexTarget()
+            return true
+        }
+        return false
+    }
+
+    private func openAIDashboardCookieImportResult(
+        request: OpenAIDashboardCookieImportRequest,
+        logger: @escaping (String) -> Void) async throws -> OpenAIDashboardBrowserCookieImporter.ImportResult
+    {
+        if let override = self._test_openAIDashboardCookieImportOverride {
+            return try await override(
+                request.normalizedTarget,
+                request.allowAnyAccount,
+                request.cookieSource,
+                request.cacheScope,
+                logger)
+        }
+
+        let importer = OpenAIDashboardBrowserCookieImporter(browserDetection: self.browserDetection)
+        switch request.cookieSource {
+        case .manual:
+            self.settings.ensureCodexCookieLoaded()
+            // Manual OpenAI cookies still come from one provider-level setting. Auto-imported cookies are
+            // isolated per managed account, but a manual header is an explicit override owned by settings,
+            // so switching managed accounts does not currently swap it underneath the user.
+            let manualHeader = self.settings.codexCookieHeader
+            guard CookieHeaderNormalizer.normalize(manualHeader) != nil else {
+                throw OpenAIDashboardBrowserCookieImporter.ImportError.manualCookieHeaderInvalid
+            }
+            return try await importer.importManualCookies(
+                cookieHeader: manualHeader,
+                intoAccountEmail: request.normalizedTarget,
+                allowAnyAccount: request.allowAnyAccount,
+                cacheScope: request.cacheScope,
+                logger: logger)
+        case .auto:
+            return try await importer.importBestCookies(
+                intoAccountEmail: request.normalizedTarget,
+                allowAnyAccount: request.allowAnyAccount,
+                preferCachedCookieHeader: request.preferCachedCookieHeader ?? !request.force,
+                cacheScope: request.cacheScope,
+                logger: logger)
+        case .off:
+            return OpenAIDashboardBrowserCookieImporter.ImportResult(
+                sourceLabel: "Off",
+                cookieCount: 0,
+                signedInEmail: request.normalizedTarget,
+                matchesCodexEmail: true)
+        }
+    }
+
+    func importOpenAIDashboardCookiesIfNeeded(
+        targetEmail: String?,
+        force: Bool,
+        preferCachedCookieHeader: Bool? = nil) async -> String?
+    {
+        guard !Task.isCancelled else { return nil }
+        if await self.openAIWebCookieImportShouldFailClosed() {
+            return nil
+        }
+        guard !Task.isCancelled else { return nil }
+
+        let normalizedTarget = targetEmail?.trimmingCharacters(in: .whitespacesAndNewlines)
+        let allowAnyAccount = normalizedTarget == nil || normalizedTarget?.isEmpty == true
+        let cookieSource = self.settings.codexCookieSource
+        let cacheScope = self.codexCookieCacheScopeForOpenAIWeb()
+
+        let now = Date()
+        let lastEmail = self.lastOpenAIDashboardCookieImportEmail
+        let lastAttempt = self.lastOpenAIDashboardCookieImportAttemptAt ?? .distantPast
+
+        let shouldAttempt: Bool = if force {
+            true
+        } else {
+            if allowAnyAccount {
+                now.timeIntervalSince(lastAttempt) > 300
+            } else {
+                self.openAIDashboardRequiresLogin &&
+                    (
+                        lastEmail?.lowercased() != normalizedTarget?.lowercased() || now
+                            .timeIntervalSince(lastAttempt) > 300)
+            }
+        }
+
+        guard shouldAttempt else { return normalizedTarget }
+        self.lastOpenAIDashboardCookieImportEmail = normalizedTarget
+        self.lastOpenAIDashboardCookieImportAttemptAt = now
+
+        let stamp = now.formatted(date: .abbreviated, time: .shortened)
+        let targetLabel = normalizedTarget ?? "unknown"
+        self.logOpenAIWeb("[\(stamp)] import start (target=\(targetLabel))")
+
+        do {
+            let log: (String) -> Void = { [weak self] message in
+                guard let self else { return }
+                self.logOpenAIWeb(message)
+            }
+
+            let request = OpenAIDashboardCookieImportRequest(
+                normalizedTarget: normalizedTarget,
+                allowAnyAccount: allowAnyAccount,
+                cookieSource: cookieSource,
+                cacheScope: cacheScope,
+                preferCachedCookieHeader: preferCachedCookieHeader,
+                force: force)
+            let result = try await self.openAIDashboardCookieImportResult(
+                request: request,
+                logger: log)
+            guard !Task.isCancelled else { return nil }
+            let effectiveEmail = result.signedInEmail?
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+                .isEmpty == false
+                ? result.signedInEmail?.trimmingCharacters(in: .whitespacesAndNewlines)
+                : normalizedTarget
+            self.lastOpenAIDashboardCookieImportEmail = effectiveEmail ?? normalizedTarget
+            await MainActor.run {
+                let signed = result.signedInEmail?.trimmingCharacters(in: .whitespacesAndNewlines)
+                let matchText = result.matchesCodexEmail ? "matches Codex" : "does not match Codex"
+                let sourceLabel = switch cookieSource {
+                case .manual:
+                    "Manual cookie header"
+                case .auto:
+                    "\(result.sourceLabel) cookies"
+                case .off:
+                    "OpenAI cookies disabled"
+                }
+                if let signed, !signed.isEmpty {
+                    self.openAIDashboardCookieImportStatus =
+                        allowAnyAccount
+                            ? [
+                                "Using \(sourceLabel) (\(result.cookieCount)).",
+                                "Signed in as \(signed).",
+                            ].joined(separator: " ")
+                            : [
+                                "Using \(sourceLabel) (\(result.cookieCount)).",
+                                "Signed in as \(signed) (\(matchText)).",
+                            ].joined(separator: " ")
+                } else {
+                    self.openAIDashboardCookieImportStatus =
+                        "Using \(sourceLabel) (\(result.cookieCount))."
+                }
+            }
+            return effectiveEmail
+        } catch let err as OpenAIDashboardBrowserCookieImporter.ImportError {
+            guard !Task.isCancelled else { return nil }
+            switch err {
+            case let .noMatchingAccount(found):
+                let foundText: String = if found.isEmpty {
+                    "no signed-in session detected in \(self.codexBrowserCookieOrder.loginHint)"
+                } else {
+                    found
+                        .sorted { lhs, rhs in
+                            if lhs.sourceLabel == rhs.sourceLabel { return lhs.email < rhs.email }
+                            return lhs.sourceLabel < rhs.sourceLabel
+                        }
+                        .map { "\($0.sourceLabel): \($0.email)" }
+                        .joined(separator: " • ")
+                }
+                self.logOpenAIWeb("[\(stamp)] import mismatch: \(foundText)")
+                await MainActor.run {
+                    self.openAIDashboardCookieImportStatus = allowAnyAccount
+                        ? [
+                            "No signed-in OpenAI web session found.",
+                            "Found \(foundText).",
+                        ].joined(separator: " ")
+                        : Self.conciseOpenAICookieMismatchStatus(
+                            found: found.map(\.email),
+                            targetEmail: normalizedTarget)
+                    self.failClosedOpenAIDashboardSnapshot()
+                }
+            case .noCookiesFound,
+                 .browserAccessDenied,
+                 .dashboardStillRequiresLogin,
+                 .manualCookieHeaderInvalid:
+                self.logOpenAIWeb("[\(stamp)] import failed: \(err.localizedDescription)")
+                await MainActor.run {
+                    self.openAIDashboardCookieImportStatus =
+                        "OpenAI cookie import failed: \(err.localizedDescription)"
+                    self.openAIDashboardRequiresLogin = true
+                }
+            }
+        } catch {
+            guard !Task.isCancelled else { return nil }
+            self.logOpenAIWeb("[\(stamp)] import failed: \(error.localizedDescription)")
+            await MainActor.run {
+                self.openAIDashboardCookieImportStatus =
+                    "Browser cookie import failed: \(error.localizedDescription)"
+            }
+        }
+        return nil
+    }
+
+    private func resetOpenAIWebDebugLog(context: String) {
+        let stamp = Date().formatted(date: .abbreviated, time: .shortened)
+        self.openAIWebDebugLines.removeAll(keepingCapacity: true)
+        self.openAIDashboardCookieImportDebugLog = nil
+        self.logOpenAIWeb("[\(stamp)] OpenAI web \(context) start")
+    }
+
+    private func logOpenAIWeb(_ message: String) {
+        let safeMessage = LogRedactor.redact(message)
+        self.openAIWebLogger.debug(safeMessage)
+        self.openAIWebDebugLines.append(safeMessage)
+        if self.openAIWebDebugLines.count > 240 {
+            self.openAIWebDebugLines.removeFirst(self.openAIWebDebugLines.count - 240)
+        }
+        self.openAIDashboardCookieImportDebugLog = self.openAIWebDebugLines.joined(separator: "\n")
+    }
+
+    func resetOpenAIWebState() {
+        self.invalidateOpenAIDashboardRefreshTask()
+        OpenAIDashboardFetcher.evictAllCachedWebViews()
+        self.openAIDashboard = nil
+        self.openAIDashboardAttachmentAuthorized = false
+        self.lastOpenAIDashboardError = nil
+        self.lastOpenAIDashboardSnapshot = nil
+        self.lastOpenAIDashboardAttachmentAuthorized = false
+        self.lastOpenAIDashboardTargetEmail = nil
+        self.lastOpenAIDashboardTargetIsolationKey = nil
+        self.lastOpenAIDashboardAttemptAt = nil
+        self.openAIDashboardRequiresLogin = false
+        self.openAIDashboardCookieImportStatus = nil
+        self.openAIDashboardCookieImportDebugLog = nil
+        self.lastOpenAIDashboardCookieImportAttemptAt = nil
+        self.lastOpenAIDashboardCookieImportEmail = nil
+        self.lastKnownLiveSystemCodexEmail = nil
+    }
+
+    /// Routing-only optimization: this detects whether the fetched browser session appears to be for a
+    /// different account than the route target, so we can retry after cookie import. Ownership proof
+    /// happens exclusively through CodexDashboardAuthority.
+    private func dashboardEmailMismatch(expected: String?, actual: String?) -> Bool {
+        guard let expected, !expected.isEmpty else { return false }
+        guard let raw = actual?.trimmingCharacters(in: .whitespacesAndNewlines), !raw.isEmpty else { return false }
+        return raw.lowercased() != expected.lowercased()
+    }
+
+    private func openAIWebManagedTargetStoreIsUnreadable() -> Bool {
+        guard case .managedAccount = self.settings.codexResolvedActiveSource else {
+            return false
+        }
+        return self.settings.codexSettingsSnapshot(tokenOverride: nil).managedAccountStoreUnreadable
+    }
+
+    private func openAIWebManagedTargetIsMissing() -> Bool {
+        guard case .managedAccount = self.settings.codexResolvedActiveSource else {
+            return false
+        }
+        return self.selectedManagedCodexAccountForOpenAIWeb() == nil
+    }
+
+    private func openAIWebProfileTargetEmailIsMissing() -> Bool {
+        guard case let .profileHome(path) = self.settings.codexResolvedActiveSource else {
+            return false
+        }
+        return self.currentProfileCodexRuntimeEmail(path: path) == nil
+    }
+
+    private func selectedManagedCodexAccountForOpenAIWeb() -> ManagedCodexAccount? {
+        guard case let .managedAccount(id) = self.settings.codexResolvedActiveSource else {
+            return nil
+        }
+
+        let snapshot = self.settings.codexAccountReconciliationSnapshot
+        return snapshot.storedAccounts.first { $0.id == id }
+    }
+
+    func codexAccountEmailForOpenAIDashboard(allowLastKnownLiveFallback: Bool = true) -> String? {
+        switch self.settings.codexResolvedActiveSource {
+        case .liveSystem:
+            let liveSystem = self.settings.codexAccountReconciliationSnapshot.liveSystemAccount?.email
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+            if let liveSystem, !liveSystem.isEmpty {
+                self.lastKnownLiveSystemCodexEmail = liveSystem
+                return liveSystem
+            }
+
+            guard allowLastKnownLiveFallback else { return nil }
+            let lastKnown = self.lastKnownLiveSystemCodexEmail?.trimmingCharacters(in: .whitespacesAndNewlines)
+            if let lastKnown, !lastKnown.isEmpty { return lastKnown }
+            return nil
+        case .managedAccount:
+            if self.openAIWebManagedTargetStoreIsUnreadable() {
+                return nil
+            }
+
+            let managed = self.currentManagedCodexRuntimeEmail()?
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+            if let managed, !managed.isEmpty { return managed }
+            return nil
+        case let .profileHome(path):
+            let profile = self.currentProfileCodexRuntimeEmail(path: path)?
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+            if let profile, !profile.isEmpty { return profile }
+            return nil
+        }
+    }
+
+    func codexCookieCacheScopeForOpenAIWeb() -> CookieHeaderCache.Scope? {
+        switch self.settings.codexResolvedActiveSource {
+        case .liveSystem:
+            nil
+        case let .managedAccount(id):
+            self.openAIWebManagedTargetStoreIsUnreadable() ? .managedStoreUnreadable : .managedAccount(id)
+        case let .profileHome(path):
+            .profileHome(path)
+        }
+    }
+}
+
 // MARK: - OpenAI web error messaging
 
 extension UsageStore {
+    nonisolated static func shouldRunOpenAIWebRefresh(_ context: OpenAIWebRefreshPolicyContext) -> Bool {
+        guard context.accessEnabled else { return false }
+        guard context.force || context.refreshPhase != .startup else { return false }
+        return context.force || !context.batterySaverEnabled
+    }
+
+    nonisolated static func forceOpenAIWebRefreshForStaleRequest(batterySaverEnabled: Bool) -> Bool {
+        !batterySaverEnabled
+    }
+
+    nonisolated static func shouldSkipOpenAIWebRefresh(_ context: OpenAIWebRefreshGateContext) -> Bool {
+        if context.force || context.accountDidChange { return false }
+        if let lastAttemptAt = context.lastAttemptAt,
+           context.now.timeIntervalSince(lastAttemptAt) < context.refreshInterval
+        {
+            return true
+        }
+        if context.lastError == nil,
+           let lastSnapshotAt = context.lastSnapshotAt,
+           context.now.timeIntervalSince(lastSnapshotAt) < context.refreshInterval
+        {
+            return true
+        }
+        return false
+    }
+
+    nonisolated static func shouldSkipOpenAIWebEmptyHistoryRetry(_ context: OpenAIWebRefreshGateContext) -> Bool {
+        if context.force || context.accountDidChange { return false }
+        guard let lastAttemptAt = context.lastAttemptAt,
+              context.now.timeIntervalSince(lastAttemptAt) < context.refreshInterval
+        else { return false }
+        guard let lastSnapshotAt = context.lastSnapshotAt else { return true }
+        return lastAttemptAt >= lastSnapshotAt
+    }
+
+    func syncOpenAIWebState() {
+        guard self.isEnabled(.codex),
+              self.settings.openAIWebAccessEnabled,
+              self.settings.codexCookieSource.isEnabled
+        else {
+            self.resetOpenAIWebState()
+            return
+        }
+
+        let targetEmail = self.currentCodexOpenAIWebTargetEmail(
+            allowCurrentSnapshotFallback: true,
+            allowLastKnownLiveFallback: true)
+        self.handleOpenAIWebTargetEmailChangeIfNeeded(
+            targetEmail: targetEmail,
+            targetScope: self.codexCookieCacheScopeForOpenAIWeb())
+    }
+
     func openAIDashboardFriendlyError(
         body: String,
         targetEmail: String?,
@@ -32,12 +1490,10 @@ extension UsageStore {
         let targetLabel = (emailLabel?.isEmpty == false) ? emailLabel! : "your OpenAI account"
         if let status, !status.isEmpty {
             if status.contains("cookies do not match Codex account")
+                || status.localizedCaseInsensitiveContains("openai cookies are for")
                 || status.localizedCaseInsensitiveContains("cookie import failed")
             {
-                return [
-                    status,
-                    "Sign in to chatgpt.com as \(targetLabel), then update OpenAI cookies in Providers → Codex.",
-                ].joined(separator: " ")
+                return "\(status) Switch chatgpt.com account, then refresh OpenAI cookies."
             }
         }
         return [
@@ -45,4 +1501,39 @@ extension UsageStore {
             "Sign in to chatgpt.com as \(targetLabel), then update OpenAI cookies in Providers → Codex.",
         ].joined(separator: " ")
     }
+
+    private static func conciseOpenAICookieMismatchStatus(
+        found: [String],
+        targetEmail: String?)
+        -> String
+    {
+        let normalizedFound = Array(Set(
+            found
+                .map { $0.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() }
+                .filter { !$0.isEmpty }))
+            .sorted()
+
+        let foundLabel: String = switch normalizedFound.count {
+        case 0:
+            ""
+        case 1:
+            normalizedFound[0]
+        case 2:
+            "\(normalizedFound[0]) or \(normalizedFound[1])"
+        default:
+            "\(normalizedFound[0]) or \(normalizedFound.count - 1) other accounts"
+        }
+
+        let targetLabel = targetEmail?.trimmingCharacters(in: .whitespacesAndNewlines)
+        if normalizedFound.isEmpty {
+            guard let targetLabel, !targetLabel.isEmpty else {
+                return "No matching OpenAI web session found."
+            }
+            return "No matching OpenAI web session found for \(targetLabel)."
+        }
+        guard let targetLabel, !targetLabel.isEmpty else {
+            return "OpenAI cookies are for \(foundLabel)."
+        }
+        return "OpenAI cookies are for \(foundLabel), not \(targetLabel)."
+    }
 }
diff --git a/Sources/CodexBar/UsageStore+PlanUtilization.swift b/Sources/CodexBar/UsageStore+PlanUtilization.swift
new file mode 100644
index 0000000000..f40f8115f1
--- /dev/null
+++ b/Sources/CodexBar/UsageStore+PlanUtilization.swift
@@ -0,0 +1,1204 @@
+import CodexBarCore
+import Foundation
+
+extension UsageStore {
+    private nonisolated static let weeklyLimitResetThreshold = 1.0
+    private nonisolated static let weeklyLimitResetDetectorDefaultsKey = "weeklyLimitResetDetectorStates"
+    private nonisolated static let weeklyWindowMinutes = 7 * 24 * 60
+
+    struct WeeklyLimitResetDetectorState: Codable, Equatable {
+        let wasAboveThreshold: Bool
+        let lastObservedAt: Date
+    }
+
+    func supportsPlanUtilizationHistory(for provider: UsageProvider) -> Bool {
+        switch provider {
+        case .codex, .claude:
+            true
+        default:
+            if self.planUtilizationHistory[provider]?.isEmpty == false {
+                true
+            } else if self.settings.historicalTrackingEnabled, let snapshot = self.snapshots[provider] {
+                !self.planUtilizationSeriesSamples(
+                    provider: provider,
+                    snapshot: snapshot,
+                    capturedAt: snapshot.updatedAt).isEmpty
+            } else {
+                false
+            }
+        }
+    }
+
+    private nonisolated static let planUtilizationMinSampleIntervalSeconds: TimeInterval = 60 * 60
+    private nonisolated static let planUtilizationResetEquivalenceToleranceSeconds: TimeInterval = 2 * 60
+    private nonisolated static let planUtilizationMaxSamples: Int = 24 * 730
+
+    private struct PlanUtilizationSeriesKey: Hashable {
+        let name: PlanUtilizationSeriesName
+        let windowMinutes: Int
+    }
+
+    private struct PlanUtilizationSeriesSample {
+        let name: PlanUtilizationSeriesName
+        let windowMinutes: Int
+        let entry: PlanUtilizationHistoryEntry
+    }
+
+    func planUtilizationHistory(for provider: UsageProvider) -> [PlanUtilizationSeriesHistory] {
+        self.planUtilizationHistorySelection(for: provider).histories
+    }
+
+    func planUtilizationHistorySelection(for provider: UsageProvider)
+        -> (accountKey: String?, histories: [PlanUtilizationSeriesHistory])
+    {
+        var providerBuckets = self.planUtilizationHistory[provider] ?? PlanUtilizationHistoryBuckets()
+        let originalProviderBuckets = providerBuckets
+        let accountKey = self.resolvePlanUtilizationAccountKey(
+            provider: provider,
+            snapshot: self.snapshots[provider],
+            preferredAccount: nil,
+            providerBuckets: &providerBuckets)
+        self.planUtilizationHistory[provider] = providerBuckets
+        if providerBuckets != originalProviderBuckets {
+            let snapshotToPersist = self.planUtilizationHistory
+            Task {
+                await self.planUtilizationPersistenceCoordinator.enqueue(snapshotToPersist)
+            }
+        }
+        return (accountKey, providerBuckets.histories(for: accountKey))
+    }
+
+    func codexPlanUtilizationHistories(forVisibleAccount account: CodexVisibleAccount)
+        -> [PlanUtilizationSeriesHistory]
+    {
+        var providerBuckets = self.planUtilizationHistory[.codex] ?? PlanUtilizationHistoryBuckets()
+        let originalProviderBuckets = providerBuckets
+        let ownership = self.codexOwnershipContext(forVisibleAccount: account)
+        guard let canonicalKey = ownership.canonicalKey else { return [] }
+
+        if ownership.hasAdjacentEmailScopeAmbiguity {
+            guard canonicalKey != ownership.canonicalEmailHashKey else { return [] }
+            return providerBuckets.histories(for: canonicalKey)
+        }
+
+        let accountKey = self.materializeCodexPlanUtilizationHistoryIfNeeded(
+            into: canonicalKey,
+            ownership: ownership,
+            shouldAdoptUnscopedHistory: true,
+            providerBuckets: &providerBuckets)
+        self.planUtilizationHistory[.codex] = providerBuckets
+        if providerBuckets != originalProviderBuckets {
+            let snapshotToPersist = self.planUtilizationHistory
+            Task {
+                await self.planUtilizationPersistenceCoordinator.enqueue(snapshotToPersist)
+            }
+        }
+        return providerBuckets.histories(for: accountKey)
+    }
+
+    func shouldShowRefreshingMenuCard(for provider: UsageProvider) -> Bool {
+        let isRefreshing = self.isRefreshing || self.refreshingProviders.contains(provider)
+        return isRefreshing
+            && self.snapshots[provider] == nil
+            && self.error(for: provider) == nil
+    }
+
+    func shouldShowRefreshingMenuCardIndicator(for provider: UsageProvider) -> Bool {
+        let isRefreshing = self.isRefreshing || self.refreshingProviders.contains(provider)
+        return isRefreshing && self.error(for: provider) == nil
+    }
+
+    func shouldHidePlanUtilizationMenuItem(for provider: UsageProvider) -> Bool {
+        guard self.supportsPlanUtilizationHistory(for: provider) else { return true }
+        return self.shouldShowRefreshingMenuCard(for: provider)
+    }
+
+    func recordPlanUtilizationHistorySample(
+        provider: UsageProvider,
+        snapshot: UsageSnapshot,
+        account: ProviderTokenAccount? = nil,
+        shouldUpdatePreferredAccountKey: Bool = true,
+        shouldAdoptUnscopedHistory: Bool = true,
+        now: Date = Date())
+        async
+    {
+        let samples = self.planUtilizationSeriesSamples(provider: provider, snapshot: snapshot, capturedAt: now)
+        guard !samples.isEmpty else { return }
+
+        let detectorAccountKey = self.planUtilizationAccountKey(
+            for: provider,
+            snapshot: snapshot,
+            preferredAccount: account)
+        await MainActor.run {
+            self.postWeeklyLimitResetCelebrationIfNeeded(
+                provider: provider,
+                account: account,
+                snapshot: snapshot,
+                accountKey: detectorAccountKey,
+                samples: samples)
+        }
+
+        guard self.shouldRecordPlanUtilizationHistory(for: provider) else { return }
+        guard !self.shouldDeferClaudePlanUtilizationHistory(provider: provider) else { return }
+
+        var snapshotToPersist: [UsageProvider: PlanUtilizationHistoryBuckets]?
+        await MainActor.run {
+            var providerBuckets = self.planUtilizationHistory[provider] ?? PlanUtilizationHistoryBuckets()
+            let preferredAccount = account ?? self.settings.selectedTokenAccount(for: provider)
+            let accountKey = self.resolvePlanUtilizationAccountKey(
+                provider: provider,
+                snapshot: snapshot,
+                preferredAccount: preferredAccount,
+                shouldUpdatePreferredAccountKey: shouldUpdatePreferredAccountKey,
+                shouldAdoptUnscopedHistory: shouldAdoptUnscopedHistory,
+                providerBuckets: &providerBuckets)
+            let histories = providerBuckets.histories(for: accountKey)
+
+            guard let updatedHistories = Self.updatedPlanUtilizationHistories(
+                existingHistories: histories,
+                samples: samples)
+            else {
+                return
+            }
+
+            providerBuckets.setHistories(updatedHistories, for: accountKey)
+            self.planUtilizationHistory[provider] = providerBuckets
+            self.planUtilizationHistoryRevision &+= 1
+            snapshotToPersist = self.planUtilizationHistory
+        }
+
+        guard let snapshotToPersist else { return }
+        await self.planUtilizationPersistenceCoordinator.enqueue(snapshotToPersist)
+    }
+
+    private func shouldRecordPlanUtilizationHistory(for provider: UsageProvider) -> Bool {
+        switch provider {
+        case .codex, .claude:
+            true
+        default:
+            self.settings.historicalTrackingEnabled
+        }
+    }
+
+    private nonisolated static func updatedPlanUtilizationHistories(
+        existingHistories: [PlanUtilizationSeriesHistory],
+        samples: [PlanUtilizationSeriesSample]) -> [PlanUtilizationSeriesHistory]?
+    {
+        guard !samples.isEmpty else { return nil }
+
+        var historiesByKey: [PlanUtilizationSeriesKey: PlanUtilizationSeriesHistory] = [:]
+        var didChange = false
+        for history in existingHistories {
+            let canonicalWindowMinutes = history.name.canonicalWindowMinutes(history.windowMinutes)
+            let key = PlanUtilizationSeriesKey(name: history.name, windowMinutes: canonicalWindowMinutes)
+            let canonicalHistory = PlanUtilizationSeriesHistory(
+                name: history.name,
+                windowMinutes: canonicalWindowMinutes,
+                entries: history.entries)
+            if let existingHistory = historiesByKey[key] {
+                historiesByKey[key] = PlanUtilizationSeriesHistory(
+                    name: history.name,
+                    windowMinutes: canonicalWindowMinutes,
+                    entries: self.mergedPlanUtilizationEntries(existingHistory.entries + canonicalHistory.entries))
+                didChange = true
+            } else {
+                historiesByKey[key] = canonicalHistory
+                didChange = didChange || canonicalWindowMinutes != history.windowMinutes
+            }
+        }
+
+        for sample in samples {
+            let canonicalWindowMinutes = sample.name.canonicalWindowMinutes(sample.windowMinutes)
+            let key = PlanUtilizationSeriesKey(name: sample.name, windowMinutes: canonicalWindowMinutes)
+            if let existingHistory = historiesByKey[key] {
+                guard let updatedEntries = self.updatedPlanUtilizationEntries(
+                    existingEntries: existingHistory.entries,
+                    entry: sample.entry)
+                else {
+                    continue
+                }
+                historiesByKey[key] = PlanUtilizationSeriesHistory(
+                    name: sample.name,
+                    windowMinutes: canonicalWindowMinutes,
+                    entries: updatedEntries)
+            } else {
+                historiesByKey[key] = PlanUtilizationSeriesHistory(
+                    name: sample.name,
+                    windowMinutes: canonicalWindowMinutes,
+                    entries: [sample.entry])
+            }
+            didChange = true
+        }
+
+        guard didChange else { return nil }
+        return historiesByKey.values.sorted { lhs, rhs in
+            if lhs.windowMinutes != rhs.windowMinutes {
+                return lhs.windowMinutes < rhs.windowMinutes
+            }
+            return lhs.name.rawValue < rhs.name.rawValue
+        }
+    }
+
+    private nonisolated static func mergedPlanUtilizationEntries(
+        _ entries: [PlanUtilizationHistoryEntry]) -> [PlanUtilizationHistoryEntry]
+    {
+        entries.reduce(into: []) { result, entry in
+            guard !result.contains(entry) else { return }
+            result.append(entry)
+        }
+    }
+
+    private nonisolated static func updatedPlanUtilizationEntries(
+        existingEntries: [PlanUtilizationHistoryEntry],
+        entry: PlanUtilizationHistoryEntry) -> [PlanUtilizationHistoryEntry]?
+    {
+        var entries = existingEntries
+        let insertionIndex = entries.firstIndex(where: { $0.capturedAt > entry.capturedAt }) ?? entries.endIndex
+        let sampleHourBucket = self.planUtilizationHourBucket(for: entry.capturedAt)
+        let sameHourRange = self.planUtilizationHourRange(
+            entries: entries,
+            insertionIndex: insertionIndex,
+            hourBucket: sampleHourBucket)
+        let existingHourEntries = Array(entries[sameHourRange])
+        let canonicalHourEntries = self.canonicalPlanUtilizationHourEntries(
+            existingHourEntries: existingHourEntries,
+            incomingEntry: entry)
+
+        guard canonicalHourEntries != existingHourEntries else { return nil }
+        entries.replaceSubrange(sameHourRange, with: canonicalHourEntries)
+
+        if entries.count > self.planUtilizationMaxSamples {
+            entries.removeFirst(entries.count - self.planUtilizationMaxSamples)
+        }
+        return entries
+    }
+
+    #if DEBUG
+    nonisolated static func _updatedPlanUtilizationEntriesForTesting(
+        existingEntries: [PlanUtilizationHistoryEntry],
+        entry: PlanUtilizationHistoryEntry) -> [PlanUtilizationHistoryEntry]?
+    {
+        self.updatedPlanUtilizationEntries(existingEntries: existingEntries, entry: entry)
+    }
+
+    nonisolated static func _updatedPlanUtilizationHistoriesForTesting(
+        existingHistories: [PlanUtilizationSeriesHistory],
+        samples: [PlanUtilizationSeriesHistory]) -> [PlanUtilizationSeriesHistory]?
+    {
+        let normalized = samples.flatMap { history in
+            history.entries.map { entry in
+                PlanUtilizationSeriesSample(name: history.name, windowMinutes: history.windowMinutes, entry: entry)
+            }
+        }
+        return self.updatedPlanUtilizationHistories(existingHistories: existingHistories, samples: normalized)
+    }
+
+    nonisolated static var _planUtilizationMaxSamplesForTesting: Int {
+        self.planUtilizationMaxSamples
+    }
+    #endif
+
+    private nonisolated static func clampedPercent(_ value: Double?) -> Double? {
+        guard let value else { return nil }
+        return max(0, min(100, value))
+    }
+
+    private func postWeeklyLimitResetCelebrationIfNeeded(
+        provider: UsageProvider,
+        account: ProviderTokenAccount?,
+        snapshot: UsageSnapshot,
+        accountKey: String?,
+        samples: [PlanUtilizationSeriesSample])
+    {
+        guard let weeklySample = samples.last(where: { $0.name == .weekly }) else { return }
+
+        let accountIdentifier = self.weeklyLimitResetAccountIdentifier(
+            provider: provider,
+            account: account,
+            snapshot: snapshot,
+            accountKey: accountKey)
+        let detectorKey = Self.weeklyLimitResetDetectorStateKey(
+            provider: provider,
+            accountIdentifier: accountIdentifier)
+        let currentUsed = weeklySample.entry.usedPercent
+        let currentObservedAt = weeklySample.entry.capturedAt
+        let wasAboveThreshold = currentUsed > Self.weeklyLimitResetThreshold
+        if let existingState = self.weeklyLimitResetDetectorStates[detectorKey],
+           currentObservedAt <= existingState.lastObservedAt
+        {
+            return
+        }
+
+        let shouldPost = self.weeklyLimitResetDetectorStates[detectorKey]?.wasAboveThreshold == true
+            && !wasAboveThreshold
+        self.weeklyLimitResetDetectorStates[detectorKey] = WeeklyLimitResetDetectorState(
+            wasAboveThreshold: wasAboveThreshold,
+            lastObservedAt: currentObservedAt)
+        self.persistWeeklyLimitResetDetectorStates()
+
+        guard shouldPost else { return }
+        let accountLabel = self.weeklyLimitResetAccountLabel(
+            provider: provider,
+            account: account,
+            snapshot: snapshot)
+        let event = WeeklyLimitResetEvent(
+            provider: provider,
+            accountIdentifier: accountIdentifier,
+            accountLabel: accountLabel,
+            usedPercent: currentUsed)
+
+        CodexBarLog.logger(LogCategories.confetti).info(
+            "Weekly limit reset",
+            metadata: [
+                "provider": provider.rawValue,
+                "accountIdentifier": accountIdentifier,
+                "accountLabel": accountLabel ?? "",
+                "usedPercent": String(format: "%.2f", currentUsed),
+                "observedAt": String(format: "%.0f", currentObservedAt.timeIntervalSince1970),
+            ])
+        NotificationCenter.default.post(name: .codexbarWeeklyLimitReset, object: event)
+    }
+
+    private func planUtilizationSeriesSamples(
+        provider: UsageProvider,
+        snapshot: UsageSnapshot,
+        capturedAt: Date) -> [PlanUtilizationSeriesSample]
+    {
+        var samplesByKey: [PlanUtilizationSeriesKey: PlanUtilizationSeriesSample] = [:]
+
+        func appendWindow(_ window: RateWindow?, name: PlanUtilizationSeriesName?) {
+            guard let name,
+                  let window,
+                  let windowMinutes = window.windowMinutes,
+                  windowMinutes > 0,
+                  let usedPercent = Self.clampedPercent(window.usedPercent)
+            else {
+                return
+            }
+
+            let canonicalWindowMinutes = name.canonicalWindowMinutes(windowMinutes)
+            let key = PlanUtilizationSeriesKey(name: name, windowMinutes: canonicalWindowMinutes)
+            samplesByKey[key] = PlanUtilizationSeriesSample(
+                name: name,
+                windowMinutes: canonicalWindowMinutes,
+                entry: PlanUtilizationHistoryEntry(
+                    capturedAt: capturedAt,
+                    usedPercent: usedPercent,
+                    resetsAt: window.resetsAt))
+        }
+
+        switch provider {
+        case .codex:
+            let projection = self.codexConsumerProjection(
+                surface: .liveCard,
+                snapshotOverride: snapshot,
+                now: capturedAt)
+            for lane in projection.planUtilizationLanes {
+                appendWindow(lane.window, name: lane.role)
+            }
+        case .claude:
+            appendWindow(snapshot.primary, name: .session)
+            appendWindow(snapshot.secondary, name: .weekly)
+            appendWindow(snapshot.tertiary, name: .opus)
+        case .antigravity:
+            let namedWeeklyWindows = snapshot.extraRateWindows?
+                .filter {
+                    $0.usageKnown
+                        && $0.id.hasPrefix("antigravity-quota-summary-")
+                        && $0.window.windowMinutes == Self.weeklyWindowMinutes
+                }
+                .map(\.window) ?? []
+            if let mostUsedWeeklyWindow = namedWeeklyWindows.max(by: { $0.usedPercent < $1.usedPercent }) {
+                appendWindow(mostUsedWeeklyWindow, name: .weekly)
+            } else {
+                for window in [snapshot.primary, snapshot.secondary, snapshot.tertiary] {
+                    guard let window, window.windowMinutes == Self.weeklyWindowMinutes else { continue }
+                    appendWindow(window, name: .weekly)
+                }
+            }
+        default:
+            let standardWeeklyWindow = [snapshot.primary, snapshot.secondary, snapshot.tertiary]
+                .compactMap(\.self)
+                .first { $0.windowMinutes == Self.weeklyWindowMinutes }
+            let extraWeeklyWindow = snapshot.extraRateWindows?
+                .lazy
+                .first { $0.usageKnown && $0.window.windowMinutes == Self.weeklyWindowMinutes }?
+                .window
+            if let weeklyWindow = standardWeeklyWindow ?? extraWeeklyWindow {
+                appendWindow(weeklyWindow, name: .weekly)
+            }
+        }
+
+        return samplesByKey.values.sorted { lhs, rhs in
+            if lhs.windowMinutes != rhs.windowMinutes {
+                return lhs.windowMinutes < rhs.windowMinutes
+            }
+            return lhs.name.rawValue < rhs.name.rawValue
+        }
+    }
+
+    private nonisolated static func planUtilizationHourBucket(for date: Date) -> Int64 {
+        Int64(floor(date.timeIntervalSince1970 / self.planUtilizationMinSampleIntervalSeconds))
+    }
+
+    private nonisolated static func planUtilizationHourRange(
+        entries: [PlanUtilizationHistoryEntry],
+        insertionIndex: Int,
+        hourBucket: Int64) -> Range<Int>
+    {
+        var lowerBound = insertionIndex
+        while lowerBound > entries.startIndex {
+            let previousIndex = lowerBound - 1
+            let previousHourBucket = self.planUtilizationHourBucket(for: entries[previousIndex].capturedAt)
+            guard previousHourBucket == hourBucket else { break }
+            lowerBound = previousIndex
+        }
+
+        var upperBound = insertionIndex
+        while upperBound < entries.endIndex {
+            let currentHourBucket = self.planUtilizationHourBucket(for: entries[upperBound].capturedAt)
+            guard currentHourBucket == hourBucket else { break }
+            upperBound += 1
+        }
+
+        return lowerBound..<upperBound
+    }
+
+    private nonisolated static func canonicalPlanUtilizationHourEntries(
+        existingHourEntries: [PlanUtilizationHistoryEntry],
+        incomingEntry: PlanUtilizationHistoryEntry) -> [PlanUtilizationHistoryEntry]
+    {
+        let hourlyObservations = (existingHourEntries + [incomingEntry]).sorted { lhs, rhs in
+            if lhs.capturedAt != rhs.capturedAt {
+                return lhs.capturedAt < rhs.capturedAt
+            }
+            if lhs.usedPercent != rhs.usedPercent {
+                return lhs.usedPercent < rhs.usedPercent
+            }
+            let lhsReset = lhs.resetsAt?.timeIntervalSince1970 ?? Date.distantPast.timeIntervalSince1970
+            let rhsReset = rhs.resetsAt?.timeIntervalSince1970 ?? Date.distantPast.timeIntervalSince1970
+            return lhsReset < rhsReset
+        }
+        guard var activeSegmentPeak = hourlyObservations.first else { return [] }
+
+        var peakBeforeLatestReset: PlanUtilizationHistoryEntry?
+
+        for observation in hourlyObservations.dropFirst() {
+            if self.startsNewPlanUtilizationResetSegment(
+                activeSegmentPeak: activeSegmentPeak,
+                observation: observation)
+            {
+                if peakBeforeLatestReset == nil {
+                    peakBeforeLatestReset = activeSegmentPeak
+                }
+                activeSegmentPeak = observation
+                continue
+            }
+
+            activeSegmentPeak = self.segmentPeakEntry(
+                existingPeak: activeSegmentPeak,
+                observation: observation)
+        }
+
+        if let peakBeforeLatestReset {
+            return [peakBeforeLatestReset, activeSegmentPeak]
+        }
+        return [activeSegmentPeak]
+    }
+
+    private nonisolated static func startsNewPlanUtilizationResetSegment(
+        activeSegmentPeak: PlanUtilizationHistoryEntry,
+        observation: PlanUtilizationHistoryEntry) -> Bool
+    {
+        self.haveMeaningfullyDifferentResetBoundaries(
+            activeSegmentPeak.resetsAt,
+            observation.resetsAt)
+    }
+
+    private nonisolated static func segmentPeakEntry(
+        existingPeak: PlanUtilizationHistoryEntry,
+        observation: PlanUtilizationHistoryEntry) -> PlanUtilizationHistoryEntry
+    {
+        if existingPeak.resetsAt == nil, observation.resetsAt != nil {
+            return observation
+        }
+
+        let hasHigherUsage = observation.usedPercent > existingPeak.usedPercent
+        let tiesUsageAndIsMoreRecent = observation.usedPercent == existingPeak.usedPercent
+            && observation.capturedAt >= existingPeak.capturedAt
+        let observationShouldReplacePeak = hasHigherUsage || tiesUsageAndIsMoreRecent
+        let peakSource = observationShouldReplacePeak ? observation : existingPeak
+        let preferObservationMetadata = observation.capturedAt >= existingPeak.capturedAt
+
+        return PlanUtilizationHistoryEntry(
+            capturedAt: peakSource.capturedAt,
+            usedPercent: peakSource.usedPercent,
+            resetsAt: self.preferredResetBoundary(
+                existing: existingPeak.resetsAt,
+                incoming: observation.resetsAt,
+                preferIncoming: preferObservationMetadata))
+    }
+
+    private nonisolated static func haveMeaningfullyDifferentResetBoundaries(_ lhs: Date?, _ rhs: Date?) -> Bool {
+        switch (lhs, rhs) {
+        case let (lhs?, rhs?):
+            abs(lhs.timeIntervalSince(rhs)) >= self.planUtilizationResetEquivalenceToleranceSeconds
+        case (.none, .none):
+            false
+        default:
+            false
+        }
+    }
+
+    private nonisolated static func preferredResetBoundary(
+        existing: Date?,
+        incoming: Date?,
+        preferIncoming: Bool) -> Date?
+    {
+        if preferIncoming {
+            return incoming ?? existing
+        }
+        return existing ?? incoming
+    }
+
+    private func planUtilizationAccountKey(
+        for provider: UsageProvider,
+        snapshot: UsageSnapshot? = nil,
+        preferredAccount: ProviderTokenAccount? = nil) -> String?
+    {
+        let account = preferredAccount ?? self.settings.selectedTokenAccount(for: provider)
+        let accountKey = Self.planUtilizationAccountKey(provider: provider, account: account)
+        if let accountKey {
+            return accountKey
+        }
+        let resolvedSnapshot = snapshot ?? self.snapshots[provider]
+        return resolvedSnapshot.flatMap { Self.planUtilizationIdentityAccountKey(provider: provider, snapshot: $0) }
+    }
+
+    private nonisolated static func planUtilizationAccountKey(
+        provider: UsageProvider,
+        account: ProviderTokenAccount?) -> String?
+    {
+        guard let account else { return nil }
+        return self.sha256Hex("\(provider.rawValue):token-account:\(account.id.uuidString.lowercased())")
+    }
+
+    private nonisolated static func planUtilizationIdentityAccountKey(
+        provider: UsageProvider,
+        snapshot: UsageSnapshot) -> String?
+    {
+        guard let identity = snapshot.identity(for: provider) else { return nil }
+
+        let normalizedEmail = identity.accountEmail?
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .lowercased()
+        if let normalizedEmail, !normalizedEmail.isEmpty {
+            if provider == .codex {
+                return CodexHistoryOwnership.canonicalEmailHashKey(for: normalizedEmail)
+            }
+            if provider == .claude {
+                let normalizedOrganization = identity.accountOrganization?
+                    .trimmingCharacters(in: .whitespacesAndNewlines)
+                    .lowercased()
+                let normalizedLoginMethod = identity.loginMethod?
+                    .trimmingCharacters(in: .whitespacesAndNewlines)
+                    .lowercased()
+                let normalizedPlan = ClaudePlan.fromCompatibilityLoginMethod(identity.loginMethod)?.rawValue
+                let organizationDiscriminator: String? =
+                    if let normalizedOrganization, !normalizedOrganization.isEmpty {
+                        "org:\(normalizedOrganization)"
+                    } else {
+                        nil
+                    }
+                let planDiscriminator = normalizedPlan.map { "plan:\($0)" }
+                let loginMethodDiscriminator: String? =
+                    if let normalizedLoginMethod, !normalizedLoginMethod.isEmpty {
+                        "plan:\(normalizedLoginMethod)"
+                    } else {
+                        nil
+                    }
+                let discriminator = organizationDiscriminator ?? planDiscriminator ?? loginMethodDiscriminator
+                guard let discriminator else {
+                    return self.sha256Hex("claude:email:\(normalizedEmail)")
+                }
+                return self.sha256Hex("\(provider.rawValue):email:\(normalizedEmail):\(discriminator)")
+            }
+            return self.sha256Hex("\(provider.rawValue):email:\(normalizedEmail)")
+        }
+
+        if provider == .claude {
+            return nil
+        }
+
+        let normalizedOrganization = identity.accountOrganization?
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .lowercased()
+        if let normalizedOrganization, !normalizedOrganization.isEmpty {
+            return self.sha256Hex("\(provider.rawValue):organization:\(normalizedOrganization)")
+        }
+
+        return nil
+    }
+
+    private nonisolated static func legacyClaudePlanUtilizationEmailAccountKey(snapshot: UsageSnapshot) -> String? {
+        guard let identity = snapshot.identity(for: .claude) else { return nil }
+        let normalizedEmail = identity.accountEmail?
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .lowercased()
+        guard let normalizedEmail, !normalizedEmail.isEmpty else { return nil }
+        return self.sha256Hex("claude:email:\(normalizedEmail)")
+    }
+
+    private func shouldDeferClaudePlanUtilizationHistory(provider: UsageProvider) -> Bool {
+        provider == .claude && self.shouldHidePlanUtilizationMenuItem(for: .claude)
+    }
+
+    private func weeklyLimitResetAccountIdentifier(
+        provider: UsageProvider,
+        account: ProviderTokenAccount?,
+        snapshot: UsageSnapshot,
+        accountKey: String?) -> String
+    {
+        let identity = snapshot.identity(for: provider)
+        return account?.id.uuidString.lowercased()
+            ?? accountKey
+            ?? identity?.accountEmail
+            ?? identity?.accountOrganization
+            ?? provider.rawValue
+    }
+
+    private func weeklyLimitResetAccountLabel(
+        provider: UsageProvider,
+        account: ProviderTokenAccount?,
+        snapshot: UsageSnapshot) -> String?
+    {
+        let identity = snapshot.identity(for: provider)
+        return account?.label
+            ?? identity?.accountEmail
+            ?? identity?.accountOrganization
+    }
+
+    private nonisolated static func weeklyLimitResetDetectorStateKey(
+        provider: UsageProvider,
+        accountIdentifier: String) -> String
+    {
+        "\(provider.rawValue):\(accountIdentifier)"
+    }
+
+    nonisolated static func loadWeeklyLimitResetDetectorStates(from userDefaults: UserDefaults)
+        -> [String: WeeklyLimitResetDetectorState]
+    {
+        guard let data = userDefaults.data(forKey: self.weeklyLimitResetDetectorDefaultsKey) else { return [:] }
+        do {
+            return try JSONDecoder().decode([String: WeeklyLimitResetDetectorState].self, from: data)
+        } catch {
+            CodexBarLog.logger(LogCategories.confetti).error(
+                "Failed to decode weekly limit reset detector state",
+                metadata: ["error": String(describing: error)])
+            return [:]
+        }
+    }
+
+    private func persistWeeklyLimitResetDetectorStates() {
+        do {
+            let data = try JSONEncoder().encode(self.weeklyLimitResetDetectorStates)
+            self.settings.userDefaults.set(data, forKey: Self.weeklyLimitResetDetectorDefaultsKey)
+        } catch {
+            CodexBarLog.logger(LogCategories.confetti).error(
+                "Failed to encode weekly limit reset detector state",
+                metadata: ["error": String(describing: error)])
+        }
+    }
+
+    private func resolvePlanUtilizationAccountKey(
+        provider: UsageProvider,
+        snapshot: UsageSnapshot?,
+        preferredAccount: ProviderTokenAccount?,
+        shouldUpdatePreferredAccountKey: Bool = true,
+        shouldAdoptUnscopedHistory: Bool = true,
+        providerBuckets: inout PlanUtilizationHistoryBuckets) -> String?
+    {
+        if provider == .codex {
+            return self.resolveCodexPlanUtilizationAccountKey(
+                snapshot: snapshot,
+                shouldUpdatePreferredAccountKey: shouldUpdatePreferredAccountKey,
+                shouldAdoptUnscopedHistory: shouldAdoptUnscopedHistory,
+                providerBuckets: &providerBuckets)
+        }
+
+        let resolvedAccount = preferredAccount ?? self.settings.selectedTokenAccount(for: provider)
+        if let tokenAccountKey = Self.planUtilizationAccountKey(provider: provider, account: resolvedAccount) {
+            if shouldUpdatePreferredAccountKey {
+                providerBuckets.preferredAccountKey = tokenAccountKey
+            }
+            if shouldAdoptUnscopedHistory {
+                self.adoptPlanUtilizationUnscopedHistoryIfNeeded(
+                    into: tokenAccountKey,
+                    provider: provider,
+                    providerBuckets: &providerBuckets)
+            }
+            return tokenAccountKey
+        }
+
+        if let snapshot,
+           let identityAccountKey = Self.planUtilizationIdentityAccountKey(provider: provider, snapshot: snapshot)
+        {
+            let resolvedIdentityAccountKey = self.materializeLegacyClaudePlanUtilizationHistoryIfNeeded(
+                into: identityAccountKey,
+                provider: provider,
+                snapshot: snapshot,
+                providerBuckets: &providerBuckets)
+            if shouldUpdatePreferredAccountKey {
+                providerBuckets.preferredAccountKey = resolvedIdentityAccountKey
+            }
+            if shouldAdoptUnscopedHistory {
+                self.adoptPlanUtilizationUnscopedHistoryIfNeeded(
+                    into: resolvedIdentityAccountKey,
+                    provider: provider,
+                    providerBuckets: &providerBuckets)
+            }
+            return resolvedIdentityAccountKey
+        }
+
+        if let stickyAccountKey = self.stickyPlanUtilizationAccountKey(providerBuckets: providerBuckets) {
+            return stickyAccountKey
+        }
+
+        return nil
+    }
+
+    private func resolveCodexPlanUtilizationAccountKey(
+        snapshot: UsageSnapshot?,
+        shouldUpdatePreferredAccountKey: Bool,
+        shouldAdoptUnscopedHistory: Bool,
+        providerBuckets: inout PlanUtilizationHistoryBuckets) -> String?
+    {
+        let ownership = self.codexOwnershipContext(snapshot: snapshot, includeDashboardFallback: true)
+        if let canonicalKey = ownership.canonicalKey {
+            let resolvedAccountKey = self.materializeCodexPlanUtilizationHistoryIfNeeded(
+                into: canonicalKey,
+                ownership: ownership,
+                shouldAdoptUnscopedHistory: shouldAdoptUnscopedHistory,
+                providerBuckets: &providerBuckets)
+            if shouldUpdatePreferredAccountKey {
+                providerBuckets.preferredAccountKey = resolvedAccountKey
+            }
+            return resolvedAccountKey
+        }
+
+        if let stickyAccountKey = self.stickyPlanUtilizationAccountKey(providerBuckets: providerBuckets) {
+            return stickyAccountKey
+        }
+
+        return nil
+    }
+
+    private func materializeCodexPlanUtilizationHistoryIfNeeded(
+        into canonicalKey: String,
+        ownership: CodexOwnershipContext,
+        shouldAdoptUnscopedHistory: Bool,
+        providerBuckets: inout PlanUtilizationHistoryBuckets) -> String
+    {
+        var historiesToMerge: [[PlanUtilizationSeriesHistory]] = []
+        let scopedRawKeys = Array(providerBuckets.accounts.keys)
+        var legacyRawKeysToRemove: [String] = []
+
+        for rawKey in scopedRawKeys {
+            let owner = CodexHistoryOwnership.classifyPersistedKey(
+                rawKey,
+                legacyEmailHash: ownership.planUtilizationLegacyEmailHash)
+            let matchesTargetContinuity = CodexHistoryOwnership.belongsToTargetContinuity(
+                owner,
+                targetCanonicalKey: canonicalKey,
+                canonicalEmailHashKey: ownership.canonicalEmailHashKey)
+            if matchesTargetContinuity,
+               !Self.codexPlanHistoryOwnerIsAmbiguousEmailScope(owner, ownership: ownership),
+               let accountHistories = providerBuckets.accounts[rawKey],
+               !accountHistories.isEmpty
+            {
+                historiesToMerge.append(accountHistories)
+                if rawKey != canonicalKey {
+                    legacyRawKeysToRemove.append(rawKey)
+                }
+            }
+        }
+
+        if let recoverableOpaqueRawKey = self.recoverableCodexOpaquePlanHistoryRawKey(
+            targetCanonicalKey: canonicalKey,
+            ownership: ownership,
+            providerBuckets: providerBuckets),
+            let opaqueHistories = providerBuckets.accounts[recoverableOpaqueRawKey],
+            !opaqueHistories.isEmpty
+        {
+            historiesToMerge.append(opaqueHistories)
+            legacyRawKeysToRemove.append(recoverableOpaqueRawKey)
+        }
+
+        if shouldAdoptUnscopedHistory,
+           !providerBuckets.unscoped.isEmpty,
+           CodexHistoryOwnership.hasStrictSingleAccountContinuity(
+               scopedRawKeys: Self.scopedRawKeysRelevantToCodexUnscopedPlanHistory(providerBuckets),
+               targetCanonicalKey: canonicalKey,
+               canonicalEmailHashKey: ownership.canonicalEmailHashKey,
+               legacyEmailHash: ownership.planUtilizationLegacyEmailHash,
+               hasAdjacentMultiAccountVeto: ownership.hasAdjacentMultiAccountVeto)
+        {
+            historiesToMerge.append(providerBuckets.unscoped)
+            providerBuckets.unscoped = []
+        }
+
+        guard !historiesToMerge.isEmpty else { return canonicalKey }
+        for rawKey in legacyRawKeysToRemove {
+            providerBuckets.accounts.removeValue(forKey: rawKey)
+        }
+        let mergedHistory = Self.mergedPlanUtilizationHistories(provider: .codex, histories: historiesToMerge)
+        providerBuckets.setHistories(mergedHistory, for: canonicalKey)
+        return canonicalKey
+    }
+
+    private static func codexPlanHistoryOwnerIsAmbiguousEmailScope(
+        _ owner: CodexHistoryPersistedOwner,
+        ownership: CodexOwnershipContext) -> Bool
+    {
+        guard ownership.hasAdjacentEmailScopeAmbiguity else { return false }
+        return switch owner {
+        case let .canonical(key):
+            key == ownership.canonicalEmailHashKey
+        case .legacyEmailHash:
+            true
+        case .legacyOpaqueScoped, .legacyUnscoped:
+            false
+        }
+    }
+
+    private func materializeLegacyClaudePlanUtilizationHistoryIfNeeded(
+        into accountKey: String,
+        provider: UsageProvider,
+        snapshot: UsageSnapshot,
+        providerBuckets: inout PlanUtilizationHistoryBuckets) -> String
+    {
+        guard provider == .claude,
+              let legacyAccountKey = Self.legacyClaudePlanUtilizationEmailAccountKey(snapshot: snapshot),
+              legacyAccountKey != accountKey,
+              let legacyHistories = providerBuckets.accounts[legacyAccountKey],
+              !legacyHistories.isEmpty
+        else {
+            return accountKey
+        }
+
+        let existingHistories = providerBuckets.accounts[accountKey] ?? []
+        let mergedHistory = Self.mergedPlanUtilizationHistories(provider: provider, histories: [
+            existingHistories,
+            legacyHistories,
+        ])
+        providerBuckets.accounts.removeValue(forKey: legacyAccountKey)
+        providerBuckets.setHistories(mergedHistory, for: accountKey)
+        if providerBuckets.preferredAccountKey == legacyAccountKey {
+            providerBuckets.preferredAccountKey = accountKey
+        }
+        return accountKey
+    }
+
+    private func adoptPlanUtilizationUnscopedHistoryIfNeeded(
+        into accountKey: String,
+        provider: UsageProvider,
+        providerBuckets: inout PlanUtilizationHistoryBuckets)
+    {
+        guard !providerBuckets.unscoped.isEmpty else { return }
+
+        let existingHistory = providerBuckets.accounts[accountKey] ?? []
+        let mergedHistory = Self.mergedPlanUtilizationHistories(provider: provider, histories: [
+            existingHistory,
+            providerBuckets.unscoped,
+        ])
+        providerBuckets.setHistories(mergedHistory, for: accountKey)
+        providerBuckets.setHistories([], for: nil)
+    }
+
+    private func stickyPlanUtilizationAccountKey(
+        providerBuckets: PlanUtilizationHistoryBuckets) -> String?
+    {
+        let knownAccountKeys = self.knownPlanUtilizationAccountKeys(providerBuckets: providerBuckets)
+        guard !knownAccountKeys.isEmpty else { return nil }
+
+        if let preferredAccountKey = providerBuckets.preferredAccountKey,
+           knownAccountKeys.contains(preferredAccountKey)
+        {
+            return preferredAccountKey
+        }
+
+        if knownAccountKeys.count == 1 {
+            return knownAccountKeys[0]
+        }
+
+        return knownAccountKeys.max { lhs, rhs in
+            let lhsDate = providerBuckets.accounts[lhs]?.compactMap(\.latestCapturedAt).max() ?? .distantPast
+            let rhsDate = providerBuckets.accounts[rhs]?.compactMap(\.latestCapturedAt).max() ?? .distantPast
+            if lhsDate == rhsDate {
+                return lhs > rhs
+            }
+            return lhsDate < rhsDate
+        }
+    }
+
+    private func knownPlanUtilizationAccountKeys(providerBuckets: PlanUtilizationHistoryBuckets) -> [String] {
+        providerBuckets.accounts.keys
+            .sorted()
+    }
+
+    private func recoverableCodexOpaquePlanHistoryRawKey(
+        targetCanonicalKey: String,
+        ownership: CodexOwnershipContext,
+        providerBuckets: PlanUtilizationHistoryBuckets) -> String?
+    {
+        guard !ownership.hasAdjacentMultiAccountVeto,
+              let targetWeeklyResetAt = ownership.currentWeeklyResetAt
+        else {
+            return nil
+        }
+
+        let candidates = providerBuckets.accounts.compactMap { rawKey, histories -> String? in
+            let owner = CodexHistoryOwnership.classifyPersistedKey(
+                rawKey,
+                legacyEmailHash: ownership.planUtilizationLegacyEmailHash)
+            guard case .legacyOpaqueScoped = owner else { return nil }
+            guard Self.isRecoverableCodexOpaquePlanHistory(
+                histories,
+                targetWeeklyResetAt: targetWeeklyResetAt)
+            else {
+                return nil
+            }
+            return rawKey
+        }
+
+        guard candidates.count == 1,
+              let recoverableRawKey = candidates.first,
+              let targetWeeklyResetAt = ownership.currentWeeklyResetAt
+        else {
+            return nil
+        }
+
+        guard !Self.hasConflictingScopedCodexPlanHistory(
+            recoverableRawKey: recoverableRawKey,
+            targetWeeklyResetAt: targetWeeklyResetAt,
+            targetCanonicalKey: targetCanonicalKey,
+            ownership: ownership,
+            providerBuckets: providerBuckets)
+        else {
+            return nil
+        }
+
+        return recoverableRawKey
+    }
+
+    private nonisolated static func isRecoverableCodexOpaquePlanHistory(
+        _ histories: [PlanUtilizationSeriesHistory],
+        targetWeeklyResetAt: Date) -> Bool
+    {
+        guard let weekly = histories.first(where: { $0.name == .weekly && $0.windowMinutes == 10080 }),
+              let session = histories.first(where: { $0.name == .session && $0.windowMinutes == 300 }),
+              !session.entries.isEmpty
+        else {
+            return false
+        }
+
+        let distinctWeeklyResets = Set(weekly.entries.compactMap(\.resetsAt))
+        guard distinctWeeklyResets.count >= 2 else { return false }
+        guard weekly.entries.contains(where: { entry in
+            Self.areEquivalentPlanUtilizationResetBoundaries(entry.resetsAt, targetWeeklyResetAt)
+        }) else {
+            return false
+        }
+        guard weekly.entries.contains(where: { entry in
+            guard let reset = entry.resetsAt else { return false }
+            return !Self.areEquivalentPlanUtilizationResetBoundaries(reset, targetWeeklyResetAt)
+        }) else {
+            return false
+        }
+        return true
+    }
+
+    private nonisolated static func areEquivalentPlanUtilizationResetBoundaries(_ lhs: Date?, _ rhs: Date?) -> Bool {
+        guard let lhs, let rhs else { return false }
+        return abs(lhs.timeIntervalSince(rhs)) < self.planUtilizationResetEquivalenceToleranceSeconds
+    }
+
+    private nonisolated static func scopedRawKeysRelevantToCodexUnscopedPlanHistory(
+        _ providerBuckets: PlanUtilizationHistoryBuckets) -> [String]
+    {
+        guard let continuityWindow = self.planUtilizationContinuityWindow(for: providerBuckets) else {
+            return []
+        }
+
+        return providerBuckets.accounts.compactMap { rawKey, histories in
+            guard self.planUtilizationHistories(histories, overlap: continuityWindow) else {
+                return nil
+            }
+            return rawKey
+        }
+    }
+
+    private nonisolated static func planUtilizationContinuityWindow(
+        for providerBuckets: PlanUtilizationHistoryBuckets) -> ClosedRange<Date>?
+    {
+        let capturedDates = providerBuckets.unscoped.flatMap(\.entries).map(\.capturedAt)
+        guard let lowerBound = capturedDates.min(),
+              let upperBound = capturedDates.max()
+        else {
+            return nil
+        }
+        let allHistories = providerBuckets.unscoped + providerBuckets.accounts.values.flatMap(\.self)
+        let expansionMinutes = allHistories.map(\.windowMinutes).max() ?? 0
+        let expansion = TimeInterval(expansionMinutes) * 60
+        return lowerBound.addingTimeInterval(-expansion)...upperBound.addingTimeInterval(expansion)
+    }
+
+    private nonisolated static func planUtilizationHistories(
+        _ histories: [PlanUtilizationSeriesHistory],
+        overlap continuityWindow: ClosedRange<Date>) -> Bool
+    {
+        histories.contains { history in
+            history.entries.contains { continuityWindow.contains($0.capturedAt) }
+        }
+    }
+
+    private nonisolated static func hasConflictingScopedCodexPlanHistory(
+        recoverableRawKey: String,
+        targetWeeklyResetAt: Date,
+        targetCanonicalKey: String,
+        ownership: CodexOwnershipContext,
+        providerBuckets: PlanUtilizationHistoryBuckets) -> Bool
+    {
+        providerBuckets.accounts.contains { rawKey, histories in
+            guard rawKey != recoverableRawKey else { return false }
+            guard self.historiesContainEquivalentWeeklyResetBoundary(
+                histories,
+                targetWeeklyResetAt: targetWeeklyResetAt)
+            else {
+                return false
+            }
+
+            let owner = CodexHistoryOwnership.classifyPersistedKey(
+                rawKey,
+                legacyEmailHash: ownership.planUtilizationLegacyEmailHash)
+            switch owner {
+            case .legacyOpaqueScoped:
+                return false
+            case .canonical, .legacyEmailHash:
+                return !CodexHistoryOwnership.belongsToTargetContinuity(
+                    owner,
+                    targetCanonicalKey: targetCanonicalKey,
+                    canonicalEmailHashKey: ownership.canonicalEmailHashKey)
+            case .legacyUnscoped:
+                return false
+            }
+        }
+    }
+
+    private nonisolated static func historiesContainEquivalentWeeklyResetBoundary(
+        _ histories: [PlanUtilizationSeriesHistory],
+        targetWeeklyResetAt: Date) -> Bool
+    {
+        histories.contains { history in
+            history.entries.contains { entry in
+                self.areEquivalentPlanUtilizationResetBoundaries(entry.resetsAt, targetWeeklyResetAt)
+            }
+        }
+    }
+
+    private nonisolated static func mergedPlanUtilizationHistories(
+        provider _: UsageProvider,
+        histories: [[PlanUtilizationSeriesHistory]]) -> [PlanUtilizationSeriesHistory]
+    {
+        var mergedByKey: [PlanUtilizationSeriesKey: PlanUtilizationSeriesHistory] = [:]
+
+        for historyGroup in histories {
+            for history in historyGroup {
+                let key = PlanUtilizationSeriesKey(name: history.name, windowMinutes: history.windowMinutes)
+                let existingEntries = mergedByKey[key]?.entries ?? []
+                var mergedEntries = existingEntries
+                for entry in history.entries.sorted(by: { $0.capturedAt < $1.capturedAt }) {
+                    if let updatedEntries = self.updatedPlanUtilizationEntries(
+                        existingEntries: mergedEntries,
+                        entry: entry)
+                    {
+                        mergedEntries = updatedEntries
+                    }
+                }
+                mergedByKey[key] = PlanUtilizationSeriesHistory(
+                    name: history.name,
+                    windowMinutes: history.windowMinutes,
+                    entries: mergedEntries)
+            }
+        }
+
+        return mergedByKey.values.sorted { lhs, rhs in
+            if lhs.windowMinutes != rhs.windowMinutes {
+                return lhs.windowMinutes < rhs.windowMinutes
+            }
+            return lhs.name.rawValue < rhs.name.rawValue
+        }
+    }
+
+    #if DEBUG
+    nonisolated static func _planUtilizationAccountKeyForTesting(
+        provider: UsageProvider,
+        snapshot: UsageSnapshot) -> String?
+    {
+        self.planUtilizationIdentityAccountKey(provider: provider, snapshot: snapshot)
+    }
+
+    nonisolated static func _planUtilizationTokenAccountKeyForTesting(
+        provider: UsageProvider,
+        account: ProviderTokenAccount) -> String?
+    {
+        self.planUtilizationAccountKey(provider: provider, account: account)
+    }
+
+    nonisolated static func _legacyClaudePlanUtilizationEmailAccountKeyForTesting(snapshot: UsageSnapshot) -> String? {
+        self.legacyClaudePlanUtilizationEmailAccountKey(snapshot: snapshot)
+    }
+
+    nonisolated static func _codexLegacyPlanUtilizationEmailHashKeyForTesting(
+        normalizedEmail: String) -> String
+    {
+        self.codexLegacyPlanUtilizationEmailHashKey(for: normalizedEmail)
+    }
+    #endif
+}
+
+actor PlanUtilizationHistoryPersistenceCoordinator {
+    private let store: PlanUtilizationHistoryStore
+    private var pendingSnapshot: [UsageProvider: PlanUtilizationHistoryBuckets]?
+    private var isPersisting: Bool = false
+
+    init(store: PlanUtilizationHistoryStore) {
+        self.store = store
+    }
+
+    func enqueue(_ snapshot: [UsageProvider: PlanUtilizationHistoryBuckets]) {
+        self.pendingSnapshot = snapshot
+        guard !self.isPersisting else { return }
+        self.isPersisting = true
+
+        Task(priority: .utility) {
+            await self.persistLoop()
+        }
+    }
+
+    private func persistLoop() async {
+        while let nextSnapshot = self.pendingSnapshot {
+            self.pendingSnapshot = nil
+            await self.saveAsync(nextSnapshot)
+        }
+
+        self.isPersisting = false
+    }
+
+    private func saveAsync(_ snapshot: [UsageProvider: PlanUtilizationHistoryBuckets]) async {
+        let store = self.store
+        await Task.detached(priority: .utility) {
+            store.save(snapshot)
+        }.value
+    }
+}
diff --git a/Sources/CodexBar/UsageStore+ProviderStorage.swift b/Sources/CodexBar/UsageStore+ProviderStorage.swift
new file mode 100644
index 0000000000..826ab19907
--- /dev/null
+++ b/Sources/CodexBar/UsageStore+ProviderStorage.swift
@@ -0,0 +1,300 @@
+import CodexBarCore
+import Foundation
+
+@MainActor
+extension UsageStore {
+    private struct StorageRefreshRequest {
+        let providers: [UsageProvider]
+        let candidatePathsByProvider: [UsageProvider: [String]]
+        let signature: String
+    }
+
+    private static let automaticStorageRefreshInterval: TimeInterval = 5 * 60
+
+    var isStorageRefreshInFlight: Bool {
+        self.storageRefreshTask != nil
+    }
+
+    func storageFootprint(for provider: UsageProvider) -> ProviderStorageFootprint? {
+        guard self.settings.providerStorageFootprintsEnabled else { return nil }
+        return self.providerStorageFootprints[provider]
+    }
+
+    func storageFootprintText(for provider: UsageProvider) -> String? {
+        guard let footprint = self.storageFootprint(for: provider) else { return nil }
+        if footprint.hasLocalData {
+            return UsageFormatter.byteCountString(footprint.totalBytes)
+        }
+        return "No local data found"
+    }
+
+    func refreshStorageFootprintsForOverview() {
+        self.scheduleStorageFootprintRefresh(for: self.enabledProvidersForDisplay())
+    }
+
+    func refreshStorageFootprintsForOverviewNow() async {
+        await self.refreshStorageFootprintsNow(for: self.enabledProvidersForDisplay())
+    }
+
+    func scheduleStorageFootprintRefreshForOverview(force: Bool = false) {
+        self.scheduleStorageFootprintRefresh(for: self.enabledProvidersForDisplay(), force: force)
+    }
+
+    func refreshStorageFootprintsNow(for providers: [UsageProvider]) async {
+        guard self.settings.providerStorageFootprintsEnabled else {
+            self.clearStorageFootprints()
+            return
+        }
+        let environment = self.environmentBase
+        let managedAccountsOverride = self.managedCodexAccountsForStorageOverride
+        let request = await Task.detached(priority: .utility) {
+            let managedAccounts = Self.loadManagedCodexAccountsForStorage(override: managedAccountsOverride)
+            return Self.makeStorageRefreshRequest(
+                for: providers,
+                environment: environment,
+                managedAccounts: managedAccounts)
+        }.value
+        guard let request else {
+            self.clearStorageFootprints()
+            return
+        }
+
+        self.storageRefreshTask?.cancel()
+        self.storageRefreshGeneration &+= 1
+        let generation = self.storageRefreshGeneration
+        self.storageRefreshInFlightSignature = request.signature
+
+        let footprints = await Task.detached(priority: .utility) {
+            Self.scanStorageFootprints(candidatePathsByProvider: request.candidatePathsByProvider)
+        }.value
+
+        guard generation == self.storageRefreshGeneration else { return }
+        self.applyStorageFootprints(
+            footprints,
+            providers: request.providers,
+            signature: request.signature,
+            updatedAt: Date())
+        self.storageRefreshTask = nil
+        self.storageRefreshInFlightSignature = nil
+        self.storageRefreshInFlightRequestKey = nil
+    }
+
+    func scheduleStorageFootprintRefresh(for providers: [UsageProvider], force: Bool = false) {
+        guard self.settings.providerStorageFootprintsEnabled else {
+            self.clearStorageFootprints()
+            return
+        }
+        let managedAccountsOverride = self.managedCodexAccountsForStorageOverride
+        let requestKey = Self.storageRefreshRequestKey(
+            for: providers,
+            managedAccountsOverride: managedAccountsOverride)
+        guard !requestKey.isEmpty else {
+            self.clearStorageFootprints()
+            return
+        }
+
+        let now = Date()
+        if self.storageRefreshTask != nil,
+           self.storageRefreshInFlightRequestKey == nil || self.storageRefreshInFlightRequestKey == requestKey
+        {
+            return
+        }
+        if !force {
+            if self.lastStorageRefreshRequestKey == requestKey,
+               let lastStorageRefreshAt,
+               now.timeIntervalSince(lastStorageRefreshAt) < Self.automaticStorageRefreshInterval
+            {
+                return
+            }
+        }
+
+        self.storageRefreshTask?.cancel()
+        self.storageRefreshGeneration &+= 1
+        let generation = self.storageRefreshGeneration
+        self.storageRefreshInFlightSignature = nil
+        self.storageRefreshInFlightRequestKey = requestKey
+        let environment = self.environmentBase
+
+        self.storageRefreshTask = Task.detached(priority: .utility) { [weak self] in
+            let managedAccounts = Self.loadManagedCodexAccountsForStorage(override: managedAccountsOverride)
+            guard let request = Self.makeStorageRefreshRequest(
+                for: providers,
+                environment: environment,
+                managedAccounts: managedAccounts)
+            else {
+                await MainActor.run { [weak self] in
+                    guard let self,
+                          !Task.isCancelled,
+                          generation == self.storageRefreshGeneration
+                    else { return }
+                    self.providerStorageFootprints.removeAll()
+                    self.storageRefreshTask = nil
+                    self.storageRefreshInFlightSignature = nil
+                    self.storageRefreshInFlightRequestKey = nil
+                    self.lastStorageRefreshSignature = nil
+                    self.lastStorageRefreshRequestKey = requestKey
+                    self.lastStorageRefreshAt = Date()
+                }
+                return
+            }
+            let footprints = Self.scanStorageFootprints(candidatePathsByProvider: request.candidatePathsByProvider)
+
+            await MainActor.run { [weak self] in
+                guard let self,
+                      !Task.isCancelled,
+                      generation == self.storageRefreshGeneration
+                else { return }
+
+                self.applyStorageFootprints(
+                    footprints,
+                    providers: request.providers,
+                    signature: request.signature,
+                    requestKey: requestKey,
+                    updatedAt: Date())
+                self.storageRefreshTask = nil
+                self.storageRefreshInFlightSignature = nil
+                self.storageRefreshInFlightRequestKey = nil
+            }
+        }
+    }
+
+    private func clearStorageFootprints() {
+        self.storageRefreshTask?.cancel()
+        self.storageRefreshTask = nil
+        self.storageRefreshInFlightSignature = nil
+        self.storageRefreshInFlightRequestKey = nil
+        self.lastStorageRefreshSignature = nil
+        self.lastStorageRefreshRequestKey = nil
+        self.lastStorageRefreshAt = nil
+        self.providerStorageFootprints.removeAll()
+    }
+
+    private func applyStorageFootprints(
+        _ footprints: [UsageProvider: ProviderStorageFootprint],
+        providers: [UsageProvider],
+        signature: String,
+        requestKey: String? = nil,
+        updatedAt: Date)
+    {
+        let providerSet = Set(providers)
+        var updated = self.providerStorageFootprints.filter { !providerSet.contains($0.key) }
+        for provider in providers {
+            // Reuse the existing footprint when only its scan timestamp would change, so the equality
+            // guard below treats an unchanged scan as a no-op.
+            if let incoming = footprints[provider],
+               let existing = self.providerStorageFootprints[provider],
+               existing.hasSameContents(as: incoming)
+            {
+                updated[provider] = existing
+            } else {
+                updated[provider] = footprints[provider]
+            }
+        }
+        // Only republish the observable footprints when a value actually changed. Storage scans run
+        // on every menu open and roughly every 5 minutes; an unconditional re-assignment wakes
+        // `menuObservationToken` -> `invalidateMenus` churn (clearing menu caches) even when the
+        // scanned bytes are identical.
+        if updated != self.providerStorageFootprints {
+            self.providerStorageFootprints = updated
+        }
+        self.lastStorageRefreshSignature = signature
+        self.lastStorageRefreshRequestKey = requestKey ?? signature
+        self.lastStorageRefreshAt = updatedAt
+    }
+
+    private nonisolated static func makeStorageRefreshRequest(
+        for providers: [UsageProvider],
+        environment: [String: String],
+        managedAccounts: [ManagedCodexAccount])
+        -> StorageRefreshRequest?
+    {
+        let uniqueProviders = Array(Set(providers)).sorted { $0.rawValue < $1.rawValue }
+        guard !uniqueProviders.isEmpty else { return nil }
+
+        var candidatePathsByProvider: [UsageProvider: [String]] = [:]
+
+        for provider in uniqueProviders {
+            let candidatePaths = ProviderStoragePathCatalog.candidatePaths(
+                for: provider,
+                environment: environment,
+                managedCodexAccounts: managedAccounts)
+            guard !candidatePaths.isEmpty else { continue }
+            candidatePathsByProvider[provider] = candidatePaths
+        }
+
+        let providersWithPaths = uniqueProviders.filter { candidatePathsByProvider[$0] != nil }
+        guard !providersWithPaths.isEmpty else { return nil }
+
+        let signature = providersWithPaths
+            .map { provider in
+                let paths = candidatePathsByProvider[provider]?.joined(separator: "\u{1f}") ?? ""
+                return "\(provider.rawValue)=\(paths)"
+            }
+            .joined(separator: "\u{1e}")
+        return StorageRefreshRequest(
+            providers: providersWithPaths,
+            candidatePathsByProvider: candidatePathsByProvider,
+            signature: signature)
+    }
+
+    private nonisolated static func storageRefreshRequestKey(
+        for providers: [UsageProvider],
+        managedAccountsOverride: [ManagedCodexAccount]?)
+        -> String
+    {
+        let uniqueProviders = Array(Set(providers))
+            .sorted { $0.rawValue < $1.rawValue }
+        let providerKey = uniqueProviders.map(\.rawValue).joined(separator: ",")
+        guard uniqueProviders.contains(.codex) else { return providerKey }
+
+        let managedAccountsRevision: String
+        if let managedAccountsOverride {
+            managedAccountsRevision = Array(Set(managedAccountsOverride.map(\.managedHomePath)))
+                .sorted()
+                .joined(separator: "\u{1f}")
+        } else {
+            let fileURL = FileManagedCodexAccountStore.defaultURL()
+            let attributes = try? FileManager.default.attributesOfItem(atPath: fileURL.path)
+            let modificationDate = (attributes?[.modificationDate] as? Date)?
+                .timeIntervalSinceReferenceDate.bitPattern ?? 0
+            let fileNumber = (attributes?[.systemFileNumber] as? NSNumber)?.uint64Value ?? 0
+            let fileSize = (attributes?[.size] as? NSNumber)?.uint64Value ?? 0
+            managedAccountsRevision = "\(fileNumber):\(modificationDate):\(fileSize)"
+        }
+        return "\(providerKey)\u{1e}\(managedAccountsRevision)"
+    }
+
+    private nonisolated static func loadManagedCodexAccountsForStorage(
+        override: [ManagedCodexAccount]?)
+        -> [ManagedCodexAccount]
+    {
+        if let override {
+            return override
+        }
+        return (try? FileManagedCodexAccountStore().loadAccounts().accounts) ?? []
+    }
+
+    private nonisolated static func scanStorageFootprints(
+        candidatePathsByProvider: [UsageProvider: [String]])
+        -> [UsageProvider: ProviderStorageFootprint]
+    {
+        let scanner = ProviderStorageScanner()
+        var footprints: [UsageProvider: ProviderStorageFootprint] = [:]
+        var pathCache: [String: ProviderStorageFootprint] = [:]
+
+        for provider in candidatePathsByProvider.keys.sorted(by: { $0.rawValue < $1.rawValue }) {
+            if Task.isCancelled { return footprints }
+            guard let candidatePaths = candidatePathsByProvider[provider] else { continue }
+            let pathKey = candidatePaths.joined(separator: "\u{1f}")
+            if let cached = pathCache[pathKey] {
+                footprints[provider] = cached.replacingProvider(provider)
+                continue
+            }
+            let footprint = scanner.scan(provider: provider, candidatePaths: candidatePaths)
+            pathCache[pathKey] = footprint
+            footprints[provider] = footprint
+        }
+
+        return footprints
+    }
+}
diff --git a/Sources/CodexBar/UsageStore+QuotaWarnings.swift b/Sources/CodexBar/UsageStore+QuotaWarnings.swift
new file mode 100644
index 0000000000..bc373b6127
--- /dev/null
+++ b/Sources/CodexBar/UsageStore+QuotaWarnings.swift
@@ -0,0 +1,102 @@
+import CodexBarCore
+import Foundation
+
+@MainActor
+extension UsageStore {
+    func handleQuotaWarningTransitions(provider: UsageProvider, snapshot: UsageSnapshot) {
+        guard self.settings.quotaWarningNotificationsEnabled else { return }
+        if provider == .commandcode, snapshot.commandCodeSubscriptionEnrichmentUnavailable { return }
+
+        let accountDisplayName = self.quotaWarningAccountDisplayName(provider: provider, snapshot: snapshot)
+        let source: SessionQuotaWindowSource? = if provider == .antigravity {
+            Self.hasAntigravityQuotaSummaryWindows(snapshot: snapshot)
+                ? .antigravityQuotaSummary
+                : .antigravityLegacy
+        } else {
+            nil
+        }
+        let primaryWindow: RateWindow?
+        let secondaryWindow: RateWindow?
+        if provider == .antigravity {
+            primaryWindow = Self.antigravityWindow(snapshot: snapshot, windowMinutes: 5 * 60)
+            secondaryWindow = Self.antigravityWindow(snapshot: snapshot, windowMinutes: 7 * 24 * 60)
+        } else {
+            primaryWindow = provider == .mimo ? nil : snapshot.primary
+            secondaryWindow = provider == .mimo ? nil : snapshot.secondary
+        }
+        self.handleQuotaWarningTransition(
+            provider: provider,
+            window: .session,
+            rateWindow: primaryWindow,
+            source: source,
+            accountDisplayName: accountDisplayName)
+        self.handleQuotaWarningTransition(
+            provider: provider,
+            window: .weekly,
+            rateWindow: secondaryWindow,
+            source: source,
+            accountDisplayName: accountDisplayName)
+    }
+
+    private func handleQuotaWarningTransition(
+        provider: UsageProvider,
+        window: QuotaWarningWindow,
+        rateWindow: RateWindow?,
+        source: SessionQuotaWindowSource?,
+        accountDisplayName: String?)
+    {
+        let key = QuotaWarningStateKey(provider: provider, window: window)
+        guard self.settings.quotaWarningEnabled(provider: provider, window: window) else {
+            self.quotaWarningState.removeValue(forKey: key)
+            return
+        }
+        guard let rateWindow else {
+            self.quotaWarningState.removeValue(forKey: key)
+            return
+        }
+
+        let thresholds = self.settings.resolvedQuotaWarningThresholds(provider: provider, window: window)
+        let currentRemaining = rateWindow.remainingPercent
+        let previousState = self.quotaWarningState[key]
+        if let previousState, previousState.source != source {
+            self.quotaWarningState[key] = QuotaWarningState(
+                lastRemaining: currentRemaining,
+                source: source)
+            return
+        }
+        var state = previousState ?? QuotaWarningState(source: source)
+        let cleared = QuotaWarningNotificationLogic.thresholdsToClear(
+            currentRemaining: currentRemaining,
+            alreadyFired: state.firedThresholds)
+        state.firedThresholds.subtract(cleared)
+
+        if let threshold = QuotaWarningNotificationLogic.crossedThreshold(
+            previousRemaining: state.lastRemaining,
+            currentRemaining: currentRemaining,
+            thresholds: thresholds,
+            alreadyFired: state.firedThresholds)
+        {
+            state.firedThresholds.formUnion(QuotaWarningNotificationLogic.firedThresholdsAfterWarning(
+                threshold: threshold,
+                thresholds: thresholds))
+            self.postQuotaWarning(
+                QuotaWarningEvent(
+                    window: window,
+                    threshold: threshold,
+                    currentRemaining: currentRemaining,
+                    accountDisplayName: accountDisplayName),
+                provider: provider)
+        }
+
+        state.lastRemaining = currentRemaining
+        self.quotaWarningState[key] = state
+    }
+
+    private func quotaWarningAccountDisplayName(provider: UsageProvider, snapshot: UsageSnapshot) -> String? {
+        guard !self.settings.hidePersonalInfo else { return nil }
+        let account = snapshot.accountEmail(for: provider)?
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+        guard let account, !account.isEmpty else { return nil }
+        return account
+    }
+}
diff --git a/Sources/CodexBar/UsageStore+Refresh.swift b/Sources/CodexBar/UsageStore+Refresh.swift
index 1e60dfb379..4a28057a9f 100644
--- a/Sources/CodexBar/UsageStore+Refresh.swift
+++ b/Sources/CodexBar/UsageStore+Refresh.swift
@@ -2,40 +2,169 @@ import CodexBarCore
 import Foundation
 
 extension UsageStore {
+    private struct ProviderRefreshOutcomeContext {
+        let generation: UInt64
+        let codexExpectedGuard: CodexAccountScopedRefreshGuard?
+        let claudeCredentialsChanged: Bool
+        let shouldConsumeClaudeKeychainFingerprint: Bool
+    }
+
+    static func commandCodeSnapshotResolvingDepletionOnEnrichmentFailure(
+        current: UsageSnapshot,
+        previous: UsageSnapshot?) -> UsageSnapshot
+    {
+        let previousProvesPaidDepletion = previous?.commandCodeHasSubscriptionPlan == true ||
+            (previous?.commandCodeSubscriptionEnrichmentUnavailable == true &&
+                previous?.commandCodeMonthlyGrantDepleted == true &&
+                previous?.primary?.usedPercent == 100)
+        guard current.commandCodeSubscriptionEnrichmentUnavailable,
+              current.commandCodeMonthlyGrantDepleted,
+              previousProvesPaidDepletion,
+              let previousPrimary = previous?.primary
+        else {
+            return current
+        }
+        let depleted = RateWindow(
+            usedPercent: 100,
+            windowMinutes: previousPrimary.windowMinutes,
+            resetsAt: previousPrimary.resetsAt,
+            resetDescription: previousPrimary.resetDescription)
+        return current.with(primary: depleted, secondary: current.secondary)
+    }
+
+    func refreshForSettingsChange() async {
+        await self.runRefresh(
+            startupConnectivityRetryAttempt: nil,
+            coalesceProviderRefreshesOverride: false)
+    }
+
+    func prepareRefreshState(for provider: UsageProvider? = nil) {
+        guard provider == nil || provider == .codex else { return }
+        _ = self.settings.persistResolvedCodexActiveSourceCorrectionIfNeeded()
+    }
+
     /// Force refresh Augment session (called from UI button)
     func forceRefreshAugmentSession() async {
         await self.performRuntimeAction(.forceSessionRefresh, for: .augment)
     }
 
-    func refreshProvider(_ provider: UsageProvider, allowDisabled: Bool = false) async {
-        guard let spec = self.providerSpecs[provider] else { return }
+    private func providerRefreshSpec(_ provider: UsageProvider) async -> ProviderSpec? {
+        if let override = self._test_providerRefreshOverride {
+            await override(provider)
+            return nil
+        }
+        return self.providerSpecs[provider]
+    }
 
-        if !spec.isEnabled(), !allowDisabled {
-            self.refreshingProviders.remove(provider)
-            await MainActor.run {
-                self.snapshots.removeValue(forKey: provider)
-                self.errors[provider] = nil
-                self.lastSourceLabels.removeValue(forKey: provider)
-                self.lastFetchAttempts.removeValue(forKey: provider)
-                self.accountSnapshots.removeValue(forKey: provider)
-                self.tokenSnapshots.removeValue(forKey: provider)
-                self.tokenErrors[provider] = nil
-                self.failureGates[provider]?.reset()
-                self.tokenFailureGates[provider]?.reset()
-                self.statuses.removeValue(forKey: provider)
-                self.lastKnownSessionRemaining.removeValue(forKey: provider)
-                self.lastKnownSessionWindowSource.removeValue(forKey: provider)
-                self.lastTokenFetchAt.removeValue(forKey: provider)
+    func refreshProvider(
+        _ provider: UsageProvider,
+        allowDisabled: Bool = false,
+        coalesceIfRefreshing: Bool = false) async
+    {
+        while coalesceIfRefreshing,
+              let existingState = self.providerRefreshCoordinator.coalescingState(for: provider)
+        {
+            switch await self.providerRefreshCoordinator.wait(for: provider, state: existingState) {
+            case .cancelled:
+                return
+            case .retryRequired:
+                self.providerRefreshCoordinator.remove(existingState, for: provider)
+                continue
+            case .completed:
+                return
+            }
+        }
+
+        let request = self.providerRefreshCoordinator.beginReplacingRequest(for: provider)
+        let task = Task { @MainActor [weak self] in
+            guard let self else { return }
+            var snapshotUpdatedAtBeforeRefresh: Date?
+            var didStartRefresh = false
+            for predecessorState in request.predecessorStates {
+                await predecessorState.waitForTaskCompletion()
             }
+            if !Task.isCancelled, self.isCurrentProviderRefreshGeneration(provider, generation: request.generation) {
+                snapshotUpdatedAtBeforeRefresh = self.snapshot(for: provider)?.updatedAt
+                didStartRefresh = true
+                await self.refreshProviderTracked(
+                    provider,
+                    allowDisabled: allowDisabled,
+                    generation: request.generation)
+            }
+            let publishedNewSnapshot = didStartRefresh &&
+                self.snapshot(for: provider)?.updatedAt != snapshotUpdatedAtBeforeRefresh
+            let retryRequired = Task.isCancelled && !publishedNewSnapshot
+            self.providerRefreshCoordinator.complete(
+                request.state,
+                for: provider,
+                retryRequired: retryRequired)
+        }
+        request.state.install(task: task)
+        _ = await self.providerRefreshCoordinator.wait(for: provider, state: request.state)
+    }
+
+    func isCurrentProviderRefreshGeneration(_ provider: UsageProvider, generation: UInt64?) -> Bool {
+        guard let generation else { return true }
+        return self.providerRefreshCoordinator.isCurrent(generation, for: provider)
+    }
+
+    private func refreshProviderTracked(
+        _ provider: UsageProvider,
+        allowDisabled: Bool,
+        generation: UInt64) async
+    {
+        if self.providerRefreshCoordinator.beginActivity(for: provider) {
+            self.refreshingProviders.insert(provider)
+        }
+        defer {
+            if self.providerRefreshCoordinator.endActivity(for: provider) {
+                self.refreshingProviders.remove(provider)
+            }
+        }
+        await self.refreshProviderNow(
+            provider,
+            allowDisabled: allowDisabled,
+            generation: generation)
+    }
+
+    private func refreshProviderNow(
+        _ provider: UsageProvider,
+        allowDisabled: Bool,
+        generation: UInt64) async
+    {
+        self.prepareRefreshState(for: provider)
+        guard let spec = await self.providerRefreshSpec(provider) else { return }
+        guard self.isCurrentProviderRefreshGeneration(provider, generation: generation) else { return }
+        let codexExpectedGuard = provider == .codex ? self.freshCodexAccountScopedRefreshGuard() : nil
+
+        if !spec.isEnabled(), !allowDisabled {
+            await self.clearDisabledProviderRefreshState(provider)
             return
         }
 
-        self.refreshingProviders.insert(provider)
-        defer { self.refreshingProviders.remove(provider) }
+        if provider == .codex, self.shouldFetchAllCodexVisibleAccounts() {
+            await self.refreshCodexVisibleAccountsForMenu(generation: generation)
+            return
+        } else if provider == .codex {
+            self.codexAccountSnapshots = []
+        }
+
+        if provider == .kilo, self.shouldFanOutKiloScopes() {
+            await self.refreshKiloScopes(generation: generation)
+            guard self.isCurrentProviderRefreshGeneration(provider, generation: generation) else { return }
+            // Continue to also fetch the personal snapshot through the regular path
+            // so the existing single-card render keeps working when only personal is shown.
+            // The presence of multi-element kiloScopeSnapshots triggers stacked rendering.
+        } else if provider == .kilo {
+            await MainActor.run { self.kiloScopeSnapshots = [] }
+        }
 
         let tokenAccounts = self.tokenAccounts(for: provider)
         if self.shouldFetchAllTokenAccounts(provider: provider, accounts: tokenAccounts) {
-            await self.refreshTokenAccounts(provider: provider, accounts: tokenAccounts)
+            await self.refreshTokenAccounts(
+                provider: provider,
+                accounts: tokenAccounts,
+                generation: generation)
             return
         } else {
             _ = await MainActor.run {
@@ -43,7 +172,10 @@ extension UsageStore {
             }
         }
 
-        let fetchContext = spec.makeFetchContext()
+        let claudeAuthStateBeforeFetch = provider == .claude
+            ? await Self.captureClaudeRefreshAuthState(invalidateCredentialsFile: true)
+            : nil
+        let fetchContext = self.makeFetchContext(provider: provider, override: nil)
         let descriptor = spec.descriptor
         // Keep provider fetch work off MainActor so slow keychain/process reads don't stall menu/UI responsiveness.
         let outcome = await withTaskGroup(
@@ -55,22 +187,37 @@ extension UsageStore {
             }
             return await group.next()!
         }
-        if provider == .claude,
-           ClaudeOAuthCredentialsStore.invalidateCacheIfCredentialsFileChanged()
-        {
-            await MainActor.run {
-                self.snapshots.removeValue(forKey: .claude)
-                self.errors[.claude] = nil
-                self.lastSourceLabels.removeValue(forKey: .claude)
-                self.lastFetchAttempts.removeValue(forKey: .claude)
-                self.accountSnapshots.removeValue(forKey: .claude)
-                self.tokenSnapshots.removeValue(forKey: .claude)
-                self.tokenErrors[.claude] = nil
-                self.failureGates[.claude]?.reset()
-                self.tokenFailureGates[.claude]?.reset()
-                self.lastTokenFetchAt.removeValue(forKey: .claude)
-            }
-        }
+        guard self.isCurrentProviderRefreshGeneration(provider, generation: generation) else { return }
+        let claudeAuthFingerprintAfterFetch = provider == .claude
+            ? await Self.captureClaudeAuthFingerprintToken()
+            : nil
+        let claudeAuthChangedDuringFetch = Self.claudeAuthChangedDuringFetch(
+            provider: provider,
+            beforeFetch: claudeAuthStateBeforeFetch,
+            afterFetchFingerprintToken: claudeAuthFingerprintAfterFetch)
+        await Self.invalidateClaudeCredentialsFileCacheIfNeeded(changedDuringFetch: claudeAuthChangedDuringFetch)
+        let claudeCredentialsChanged = Self.claudeCredentialsChanged(
+            beforeFetch: claudeAuthStateBeforeFetch,
+            changedDuringFetch: claudeAuthChangedDuringFetch)
+        let shouldConsumeClaudeKeychainFingerprint = Self.shouldConsumeClaudeKeychainFingerprintChange(
+            beforeFetch: claudeAuthStateBeforeFetch,
+            changedDuringFetch: claudeAuthChangedDuringFetch)
+        guard self.isCurrentProviderRefreshGeneration(provider, generation: generation) else { return }
+        await self.applyProviderRefreshOutcome(
+            provider: provider,
+            outcome: outcome,
+            context: ProviderRefreshOutcomeContext(
+                generation: generation,
+                codexExpectedGuard: codexExpectedGuard,
+                claudeCredentialsChanged: claudeCredentialsChanged,
+                shouldConsumeClaudeKeychainFingerprint: shouldConsumeClaudeKeychainFingerprint))
+    }
+
+    private func applyProviderRefreshOutcome(
+        provider: UsageProvider,
+        outcome: ProviderFetchOutcome,
+        context: ProviderRefreshOutcomeContext) async
+    {
         await MainActor.run {
             self.lastFetchAttempts[provider] = outcome.attempts
         }
@@ -78,39 +225,373 @@ extension UsageStore {
         switch outcome.result {
         case let .success(result):
             let scoped = result.usage.scoped(to: provider)
-            await MainActor.run {
-                self.handleSessionQuotaTransition(provider: provider, snapshot: scoped)
-                self.snapshots[provider] = scoped
+            if provider == .codex,
+               let codexExpectedGuard = context.codexExpectedGuard,
+               !self.shouldApplyCodexUsageResult(expectedGuard: codexExpectedGuard, usage: scoped)
+            {
+                return
+            }
+            let backfilled = await MainActor.run { () -> UsageSnapshot? in
+                guard self.isCurrentProviderRefreshGeneration(provider, generation: context.generation) else {
+                    return nil
+                }
+                if context.claudeCredentialsChanged {
+                    self.clearClaudeCredentialDerivedStateForCredentialSwapNow()
+                }
+                let resetBackfillSource = provider == .codex
+                    ? self.codexLastKnownResetSnapshot(matching: context.codexExpectedGuard)
+                    : self.lastKnownResetSnapshots[provider]
+                let stabilized = Self.commandCodeSnapshotResolvingDepletionOnEnrichmentFailure(
+                    current: scoped,
+                    previous: self.snapshots[provider])
+                let backfilled = stabilized.backfillingResetTimes(from: resetBackfillSource)
+                self.handleQuotaWarningTransitions(provider: provider, snapshot: backfilled)
+                self.handleSessionQuotaTransition(provider: provider, snapshot: backfilled)
+                self.lastKnownResetSnapshots[provider] = backfilled
+                self.snapshots[provider] = backfilled
+                if let tokenSnapshot = self.tokenSnapshot(fromProviderSnapshot: backfilled, provider: provider) {
+                    self.tokenSnapshots[provider] = tokenSnapshot
+                    self.tokenErrors[provider] = nil
+                    self.tokenFailureGates[provider]?.recordSuccess()
+                } else if Self.tokenCostRequiresProviderSnapshot(provider) {
+                    self.tokenSnapshots.removeValue(forKey: provider)
+                    self.tokenErrors[provider] = nil
+                }
                 self.lastSourceLabels[provider] = result.sourceLabel
                 self.errors[provider] = nil
                 self.failureGates[provider]?.recordSuccess()
+                if provider == .codex {
+                    self.rememberLiveSystemCodexEmailIfNeeded(scoped.accountEmail(for: .codex))
+                    self.seedCodexAccountScopedRefreshGuard(accountEmail: scoped.accountEmail(for: .codex))
+                }
+                return backfilled
+            }
+            guard let backfilled else { return }
+            if context.shouldConsumeClaudeKeychainFingerprint {
+                _ = await Self.consumeClaudeKeychainFingerprintChangeWithoutPrompt()
             }
+            await self.recordPlanUtilizationHistorySample(
+                provider: provider,
+                snapshot: backfilled)
+            guard self.isCurrentProviderRefreshGeneration(provider, generation: context.generation) else { return }
             if let runtime = self.providerRuntimes[provider] {
                 let context = ProviderRuntimeContext(
                     provider: provider, settings: self.settings, store: self)
                 runtime.providerDidRefresh(context: context, provider: provider)
             }
             if provider == .codex {
-                self.recordCodexHistoricalSampleIfNeeded(snapshot: scoped)
+                self.recordCodexHistoricalSampleIfNeeded(snapshot: backfilled)
             }
         case let .failure(error):
-            await MainActor.run {
-                let hadPriorData = self.snapshots[provider] != nil
-                let shouldSurface =
-                    self.failureGates[provider]?
-                        .shouldSurfaceError(onFailureWithPriorData: hadPriorData) ?? true
-                if shouldSurface {
-                    self.errors[provider] = error.localizedDescription
+            if provider == .codex,
+               let codexExpectedGuard = context.codexExpectedGuard,
+               !self.shouldApplyCodexScopedFailure(expectedGuard: codexExpectedGuard)
+            {
+                return
+            }
+            guard self.isCurrentProviderRefreshGeneration(provider, generation: context.generation) else { return }
+            self.recordStartupConnectivityRetryableFailure(error)
+            if context.claudeCredentialsChanged {
+                await self.clearClaudeCredentialDerivedStateForCredentialSwap()
+            }
+            if context.shouldConsumeClaudeKeychainFingerprint {
+                _ = await Self.consumeClaudeKeychainFingerprintChangeWithoutPrompt()
+            }
+            await self.handleProviderFetchFailure(
+                provider: provider,
+                error: error,
+                generation: context.generation)
+        }
+    }
+
+    private func clearDisabledProviderRefreshState(_ provider: UsageProvider) async {
+        self.refreshingProviders.remove(provider)
+        await MainActor.run {
+            self.snapshots.removeValue(forKey: provider)
+            self.lastKnownResetSnapshots.removeValue(forKey: provider)
+            self.errors[provider] = nil
+            self.lastSourceLabels.removeValue(forKey: provider)
+            self.lastFetchAttempts.removeValue(forKey: provider)
+            self.accountSnapshots.removeValue(forKey: provider)
+            if provider == .codex {
+                self.codexAccountSnapshots = []
+            }
+            if provider == .kilo {
+                self.kiloScopeSnapshots = []
+            }
+            self.tokenSnapshots.removeValue(forKey: provider)
+            self.tokenErrors[provider] = nil
+            self.failureGates[provider]?.reset()
+            self.tokenFailureGates[provider]?.reset()
+            self.statuses.removeValue(forKey: provider)
+            self.lastKnownSessionRemaining.removeValue(forKey: provider)
+            self.lastKnownSessionWindowSource.removeValue(forKey: provider)
+            self.quotaWarningState = self.quotaWarningState.filter { $0.key.provider != provider }
+            self.lastTokenFetchAt.removeValue(forKey: provider)
+        }
+    }
+
+    private struct ClaudeRefreshAuthState {
+        let fingerprintToken: String
+        let credentialsFileChanged: Bool
+        let keychainFingerprintChanged: Bool
+    }
+
+    private nonisolated static func claudeCredentialsChanged(
+        beforeFetch: ClaudeRefreshAuthState?,
+        changedDuringFetch: Bool) -> Bool
+    {
+        beforeFetch?.credentialsFileChanged == true ||
+            beforeFetch?.keychainFingerprintChanged == true ||
+            changedDuringFetch
+    }
+
+    private nonisolated static func shouldConsumeClaudeKeychainFingerprintChange(
+        beforeFetch: ClaudeRefreshAuthState?,
+        changedDuringFetch: Bool) -> Bool
+    {
+        beforeFetch?.keychainFingerprintChanged == true || changedDuringFetch
+    }
+
+    private nonisolated static func claudeAuthChangedDuringFetch(
+        provider: UsageProvider,
+        beforeFetch: ClaudeRefreshAuthState?,
+        afterFetchFingerprintToken: String?) -> Bool
+    {
+        provider == .claude && afterFetchFingerprintToken != beforeFetch?.fingerprintToken
+    }
+
+    private nonisolated static func captureClaudeRefreshAuthState(
+        invalidateCredentialsFile: Bool) async -> ClaudeRefreshAuthState
+    {
+        await withTaskGroup(of: ClaudeRefreshAuthState.self, returning: ClaudeRefreshAuthState.self) { group in
+            group.addTask {
+                let fingerprintToken = ClaudeOAuthCredentialsStore.authFingerprintToken()
+                let credentialsFileChanged = invalidateCredentialsFile
+                    ? ClaudeOAuthCredentialsStore.invalidateCacheIfCredentialsFileChanged()
+                    : false
+                let keychainFingerprintChanged = ClaudeOAuthCredentialsStore
+                    .claudeKeychainFingerprintChangedWithoutConsuming()
+                return ClaudeRefreshAuthState(
+                    fingerprintToken: fingerprintToken,
+                    credentialsFileChanged: credentialsFileChanged,
+                    keychainFingerprintChanged: keychainFingerprintChanged)
+            }
+            return await group.next()!
+        }
+    }
+
+    private nonisolated static func captureClaudeAuthFingerprintToken() async -> String {
+        await withTaskGroup(of: String.self, returning: String.self) { group in
+            group.addTask {
+                ClaudeOAuthCredentialsStore.authFingerprintToken()
+            }
+            return await group.next()!
+        }
+    }
+
+    private nonisolated static func invalidateClaudeCredentialsFileCacheIfChanged() async -> Bool {
+        await withTaskGroup(of: Bool.self, returning: Bool.self) { group in
+            group.addTask {
+                ClaudeOAuthCredentialsStore.invalidateCacheIfCredentialsFileChanged()
+            }
+            return await group.next()!
+        }
+    }
+
+    private nonisolated static func invalidateClaudeCredentialsFileCacheIfNeeded(changedDuringFetch: Bool) async {
+        guard changedDuringFetch else { return }
+        _ = await self.invalidateClaudeCredentialsFileCacheIfChanged()
+    }
+
+    private nonisolated static func consumeClaudeKeychainFingerprintChangeWithoutPrompt() async -> Bool {
+        await withTaskGroup(of: Bool.self, returning: Bool.self) { group in
+            group.addTask {
+                ClaudeOAuthCredentialsStore.consumeClaudeKeychainFingerprintChangeWithoutPrompt()
+            }
+            return await group.next()!
+        }
+    }
+
+    private func clearClaudeCredentialDerivedStateForCredentialSwap() async {
+        await MainActor.run {
+            self.clearClaudeCredentialDerivedStateForCredentialSwapNow()
+        }
+    }
+
+    private func clearClaudeCredentialDerivedStateForCredentialSwapNow() {
+        self.snapshots.removeValue(forKey: .claude)
+        self.lastKnownResetSnapshots.removeValue(forKey: .claude)
+        self.errors[.claude] = nil
+        self.lastSourceLabels.removeValue(forKey: .claude)
+        self.accountSnapshots.removeValue(forKey: .claude)
+        self.tokenSnapshots.removeValue(forKey: .claude)
+        self.tokenErrors[.claude] = nil
+        self.failureGates[.claude]?.reset()
+        self.tokenFailureGates[.claude]?.reset()
+        self.lastKnownSessionRemaining.removeValue(forKey: .claude)
+        self.lastKnownSessionWindowSource.removeValue(forKey: .claude)
+        self.quotaWarningState = self.quotaWarningState.filter { $0.key.provider != .claude }
+        self.lastTokenFetchAt.removeValue(forKey: .claude)
+    }
+
+    private func handleProviderFetchFailure(
+        provider: UsageProvider,
+        error: Error,
+        generation: UInt64) async
+    {
+        let shouldNotifyPermissionPrompt = Self.isPermissionPromptWaiting(error)
+        await MainActor.run {
+            guard self.isCurrentProviderRefreshGeneration(provider, generation: generation) else { return }
+            let hadPriorData = self.snapshots[provider] != nil
+            let preservesPriorData = Self.shouldPreservePriorSnapshot(
+                after: error,
+                hadPriorData: hadPriorData) ||
+                (provider == .claude &&
+                    hadPriorData &&
+                    Self.isClaudeCLIRateLimitFailure(error))
+            let shouldSurface =
+                self.failureGates[provider]?
+                    .shouldSurfaceError(onFailureWithPriorData: hadPriorData) ?? true
+            let preservesClaudeWebSessionFailure =
+                provider == .claude &&
+                hadPriorData &&
+                Self.isClaudeWebSessionRefreshFailure(error)
+            if preservesClaudeWebSessionFailure,
+               !shouldSurface
+            {
+                self.errors[provider] = nil
+                return
+            }
+            if provider == .claude,
+               preservesPriorData,
+               Self.isClaudeUsageProbeTimeout(error) || Self.isClaudeCLIRateLimitFailure(error)
+            {
+                self.errors[provider] = nil
+                return
+            }
+            if preservesPriorData, !shouldSurface {
+                self.errors[provider] = nil
+                return
+            }
+            if shouldSurface {
+                self.errors[provider] = error.localizedDescription
+                if !preservesPriorData, !preservesClaudeWebSessionFailure {
                     self.snapshots.removeValue(forKey: provider)
-                } else {
-                    self.errors[provider] = nil
                 }
+            } else {
+                self.errors[provider] = nil
             }
-            if let runtime = self.providerRuntimes[provider] {
-                let context = ProviderRuntimeContext(
-                    provider: provider, settings: self.settings, store: self)
-                runtime.providerDidFail(context: context, provider: provider, error: error)
+            if shouldNotifyPermissionPrompt {
+                self.postPermissionPromptNotificationIfNeeded(provider: provider, error: error)
+            }
+        }
+        guard self.isCurrentProviderRefreshGeneration(provider, generation: generation) else { return }
+        if let runtime = self.providerRuntimes[provider] {
+            let context = ProviderRuntimeContext(
+                provider: provider, settings: self.settings, store: self)
+            runtime.providerDidFail(context: context, provider: provider, error: error)
+        }
+    }
+
+    private static func shouldPreservePriorSnapshot(after error: Error, hadPriorData: Bool) -> Bool {
+        guard hadPriorData else { return false }
+        if error is CancellationError { return true }
+        if self.isPreservableNetworkTransportError(error) { return true }
+
+        let message = error.localizedDescription.lowercased()
+        return message.contains("timed out") ||
+            message.contains("timeout") ||
+            message.contains("cancelled") ||
+            message.contains("network connection was lost") ||
+            message.contains("not connected to the internet")
+    }
+
+    static func isPreservableNetworkTransportError(_ error: Error) -> Bool {
+        let nsError = error as NSError
+        guard nsError.domain == NSURLErrorDomain else { return false }
+        switch nsError.code {
+        case NSURLErrorTimedOut,
+             NSURLErrorCancelled,
+             NSURLErrorNetworkConnectionLost,
+             NSURLErrorNotConnectedToInternet,
+             NSURLErrorCannotFindHost,
+             NSURLErrorCannotConnectToHost,
+             NSURLErrorDNSLookupFailed:
+            return true
+        default:
+            return false
+        }
+    }
+
+    static func startupConnectivityRetryDelay(forAttempt attempt: Int) -> TimeInterval? {
+        let delays: [TimeInterval] = [15, 45, 120, 300]
+        guard attempt >= 1, attempt <= delays.count else { return nil }
+        return delays[attempt - 1]
+    }
+
+    static func isStartupConnectivityRetryableError(_ error: Error) -> Bool {
+        if error is CancellationError { return false }
+
+        let nsError = error as NSError
+        if nsError.domain == NSURLErrorDomain {
+            switch nsError.code {
+            case NSURLErrorTimedOut,
+                 NSURLErrorNetworkConnectionLost,
+                 NSURLErrorNotConnectedToInternet,
+                 NSURLErrorCannotFindHost,
+                 NSURLErrorCannotConnectToHost,
+                 NSURLErrorDNSLookupFailed:
+                return true
+            default:
+                return false
             }
         }
+
+        let message = error.localizedDescription.lowercased()
+        return message.contains("timed out") ||
+            message.contains("timeout") ||
+            message.contains("network connection was lost") ||
+            message.contains("not connected to the internet") ||
+            message.contains("cannot find host") ||
+            message.contains("cannot connect to host") ||
+            message.contains("dns lookup")
+    }
+
+    private static func isClaudeUsageProbeTimeout(_ error: Error) -> Bool {
+        if case ClaudeStatusProbeError.timedOut = error { return true }
+        return error.localizedDescription == ClaudeStatusProbeError.timedOut.localizedDescription
+    }
+
+    private static func isClaudeCLIRateLimitFailure(_ error: Error) -> Bool {
+        ClaudeUsageFetcher.isCLIRateLimitError(error)
+    }
+
+    private static func isClaudeWebSessionRefreshFailure(_ error: Error) -> Bool {
+        if case ClaudeWebAPIFetcher.FetchError.unauthorized = error { return true }
+        return error.localizedDescription == ClaudeWebAPIFetcher.FetchError.unauthorized.localizedDescription
+    }
+
+    nonisolated static func isPermissionPromptWaiting(_ error: Error) -> Bool {
+        let message = error.localizedDescription.lowercased()
+        return (message.contains("prompt") && message.contains("waiting")) ||
+            message.contains("permission prompt") ||
+            message.contains("folder trust prompt")
+    }
+
+    private func postPermissionPromptNotificationIfNeeded(provider: UsageProvider, error: Error) {
+        let now = Date()
+        if let last = self.lastPermissionPromptNotificationAt[provider],
+           now.timeIntervalSince(last) < 10 * 60
+        {
+            return
+        }
+        self.lastPermissionPromptNotificationAt[provider] = now
+        let providerName = ProviderDescriptorRegistry.descriptor(for: provider).metadata.displayName
+        AppNotifications.shared.post(
+            idPrefix: "permission-prompt-\(provider.rawValue)",
+            title: L("%@ is waiting for permission", providerName),
+            body: error.localizedDescription,
+            soundEnabled: false)
     }
 }
diff --git a/Sources/CodexBar/UsageStore+StartupConnectivityRetry.swift b/Sources/CodexBar/UsageStore+StartupConnectivityRetry.swift
new file mode 100644
index 0000000000..aceceb48d9
--- /dev/null
+++ b/Sources/CodexBar/UsageStore+StartupConnectivityRetry.swift
@@ -0,0 +1,83 @@
+import Foundation
+
+extension UsageStore {
+    enum StartupBehavior {
+        case automatic
+        case full
+        case testing
+
+        var automaticallyStartsBackgroundWork: Bool {
+            switch self {
+            case .automatic, .full:
+                true
+            case .testing:
+                false
+            }
+        }
+
+        func resolved(isRunningTests: Bool) -> StartupBehavior {
+            switch self {
+            case .automatic:
+                isRunningTests ? .testing : .full
+            case .full, .testing:
+                self
+            }
+        }
+    }
+
+    func recordStartupConnectivityRetryableFailure(_ error: Error) {
+        guard self.startupConnectivityRetryRefreshActive else { return }
+        guard Self.isStartupConnectivityRetryableError(error) else { return }
+        self.startupConnectivityRetryNeeded = true
+    }
+
+    func completeStartupConnectivityRetryPass(currentAttempt: Int) {
+        guard self.startupConnectivityRetryNeeded else {
+            self.cancelStartupConnectivityRetry()
+            return
+        }
+
+        let nextAttempt = currentAttempt + 1
+        guard let delay = Self.startupConnectivityRetryDelay(forAttempt: nextAttempt) else {
+            self.cancelStartupConnectivityRetry()
+            return
+        }
+
+        self.scheduleStartupConnectivityRetry(attempt: nextAttempt, delay: delay)
+    }
+
+    private func scheduleStartupConnectivityRetry(attempt: Int, delay: TimeInterval) {
+        guard self.startupBehavior.automaticallyStartsBackgroundWork ||
+            self._test_startupConnectivityRetryScheduled != nil ||
+            self._test_startupConnectivityRetrySleepOverride != nil
+        else {
+            return
+        }
+
+        self.startupConnectivityRetryTask?.cancel()
+        self._test_startupConnectivityRetryScheduled?(attempt, delay)
+        self.startupConnectivityRetryTask = Task { @MainActor [weak self] in
+            guard let self else { return }
+            do {
+                try await self.sleepForStartupConnectivityRetry(delay)
+                guard !Task.isCancelled else { return }
+                await self.runRefresh(startupConnectivityRetryAttempt: attempt)
+            } catch {
+                return
+            }
+        }
+    }
+
+    private func cancelStartupConnectivityRetry() {
+        self.startupConnectivityRetryTask?.cancel()
+        self.startupConnectivityRetryTask = nil
+    }
+
+    private func sleepForStartupConnectivityRetry(_ delay: TimeInterval) async throws {
+        if let override = self._test_startupConnectivityRetrySleepOverride {
+            try await override(delay)
+            return
+        }
+        try await Task.sleep(nanoseconds: UInt64(delay * 1_000_000_000))
+    }
+}
diff --git a/Sources/CodexBar/UsageStore+Status.swift b/Sources/CodexBar/UsageStore+Status.swift
index abf7aee47a..c1bd9b3fbd 100644
--- a/Sources/CodexBar/UsageStore+Status.swift
+++ b/Sources/CodexBar/UsageStore+Status.swift
@@ -1,12 +1,60 @@
+import CodexBarCore
 import Foundation
 
+/// Shared, lock-guarded ISO8601 formatters for status feeds. Allocating a fresh
+/// `ISO8601DateFormatter` per decoded date field is a measurable share of decoding the
+/// Google Workspace incidents feed, which can run to hundreds of kilobytes (#1399).
+private final class StatusISO8601FormatterBox: @unchecked Sendable {
+    let lock = NSLock()
+    let withFractional: ISO8601DateFormatter = {
+        let fmt = ISO8601DateFormatter()
+        fmt.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        return fmt
+    }()
+
+    let plain: ISO8601DateFormatter = {
+        let fmt = ISO8601DateFormatter()
+        fmt.formatOptions = [.withInternetDateTime]
+        return fmt
+    }()
+}
+
+private enum StatusFeedDateParser {
+    static let box = StatusISO8601FormatterBox()
+
+    static func parse(_ text: String) -> Date? {
+        self.box.lock.lock()
+        defer { self.box.lock.unlock() }
+        return self.box.withFractional.date(from: text) ?? self.box.plain.date(from: text)
+    }
+
+    static func decodingStrategy() -> JSONDecoder.DateDecodingStrategy {
+        .custom { decoder in
+            let container = try decoder.singleValueContainer()
+            let raw = try container.decode(String.self)
+            guard let date = StatusFeedDateParser.parse(raw) else {
+                throw DecodingError.dataCorruptedError(in: container, debugDescription: "Invalid ISO8601 date")
+            }
+            return date
+        }
+    }
+}
+
 extension UsageStore {
-    static func fetchStatus(from baseURL: URL) async throws -> ProviderStatus {
+    /// Status feeds decode off the main actor: the Google Workspace incidents payload alone
+    /// can be hundreds of kilobytes and cost 150-340ms to decode (#1399), and these helpers
+    /// touch no store state.
+    @concurrent
+    nonisolated static func fetchStatus(
+        from baseURL: URL,
+        transport: any ProviderHTTPTransport = ProviderHTTPClient.shared)
+        async throws -> ProviderStatus
+    {
         let apiURL = baseURL.appendingPathComponent("api/v2/status.json")
         var request = URLRequest(url: apiURL)
         request.timeoutInterval = 10
 
-        let (data, _) = try await URLSession.shared.data(for: request, delegate: nil)
+        let (data, _) = try await transport.data(for: request)
 
         struct Response: Decodable {
             struct Status: Decodable {
@@ -27,16 +75,7 @@ extension UsageStore {
         }
 
         let decoder = JSONDecoder()
-        decoder.dateDecodingStrategy = .custom { decoder in
-            let container = try decoder.singleValueContainer()
-            let raw = try container.decode(String.self)
-            let formatter = ISO8601DateFormatter()
-            formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
-            if let date = formatter.date(from: raw) { return date }
-            formatter.formatOptions = [.withInternetDateTime]
-            if let date = formatter.date(from: raw) { return date }
-            throw DecodingError.dataCorruptedError(in: container, debugDescription: "Invalid ISO8601 date")
-        }
+        decoder.dateDecodingStrategy = StatusFeedDateParser.decodingStrategy()
 
         let response = try decoder.decode(Response.self, from: data)
         let indicator = ProviderStatusIndicator(rawValue: response.status.indicator) ?? .unknown
@@ -46,29 +85,27 @@ extension UsageStore {
             updatedAt: response.page?.updatedAt)
     }
 
-    static func fetchWorkspaceStatus(productID: String) async throws -> ProviderStatus {
+    @concurrent
+    nonisolated static func fetchWorkspaceStatus(
+        productID: String,
+        transport: any ProviderHTTPTransport = ProviderHTTPClient.shared,
+        beforeDecoding: (@Sendable () -> Void)? = nil)
+        async throws -> ProviderStatus
+    {
         guard let url = URL(string: "https://www.google.com/appsstatus/dashboard/incidents.json") else {
             throw URLError(.badURL)
         }
         var request = URLRequest(url: url)
         request.timeoutInterval = 10
-        let (data, _) = try await URLSession.shared.data(for: request, delegate: nil)
+        let (data, _) = try await transport.data(for: request)
+        beforeDecoding?()
         return try Self.parseGoogleWorkspaceStatus(data: data, productID: productID)
     }
 
-    static func parseGoogleWorkspaceStatus(data: Data, productID: String) throws -> ProviderStatus {
+    nonisolated static func parseGoogleWorkspaceStatus(data: Data, productID: String) throws -> ProviderStatus {
         let decoder = JSONDecoder()
         decoder.keyDecodingStrategy = .convertFromSnakeCase
-        decoder.dateDecodingStrategy = .custom { decoder in
-            let container = try decoder.singleValueContainer()
-            let raw = try container.decode(String.self)
-            let formatter = ISO8601DateFormatter()
-            formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
-            if let date = formatter.date(from: raw) { return date }
-            formatter.formatOptions = [.withInternetDateTime]
-            if let date = formatter.date(from: raw) { return date }
-            throw DecodingError.dataCorruptedError(in: container, debugDescription: "Invalid ISO8601 date")
-        }
+        decoder.dateDecodingStrategy = StatusFeedDateParser.decodingStrategy()
 
         let incidents = try decoder.decode([GoogleWorkspaceIncident].self, from: data)
         let active = incidents.filter { $0.isRelevant(productID: productID) && $0.isActive }
@@ -96,7 +133,7 @@ extension UsageStore {
         return ProviderStatus(indicator: best.indicator, description: description, updatedAt: updatedAt)
     }
 
-    private static func indicatorRank(_ indicator: ProviderStatusIndicator) -> Int {
+    private nonisolated static func indicatorRank(_ indicator: ProviderStatusIndicator) -> Int {
         switch indicator {
         case .none: 0
         case .maintenance: 1
@@ -107,7 +144,7 @@ extension UsageStore {
         }
     }
 
-    private static func workspaceIndicator(status: String?, severity: String?) -> ProviderStatusIndicator {
+    private nonisolated static func workspaceIndicator(status: String?, severity: String?) -> ProviderStatusIndicator {
         switch status?.uppercased() {
         case "AVAILABLE": return .none
         case "SERVICE_INFORMATION": return .minor
@@ -125,7 +162,7 @@ extension UsageStore {
         }
     }
 
-    private static func workspaceSummary(from text: String?) -> String? {
+    private nonisolated static func workspaceSummary(from text: String?) -> String? {
         guard let text else { return nil }
         let normalized = text
             .replacingOccurrences(of: "\r\n", with: "\n")
diff --git a/Sources/CodexBar/UsageStore+Timeout.swift b/Sources/CodexBar/UsageStore+Timeout.swift
new file mode 100644
index 0000000000..bd10e88dee
--- /dev/null
+++ b/Sources/CodexBar/UsageStore+Timeout.swift
@@ -0,0 +1,97 @@
+import Foundation
+
+extension UsageStore {
+    private nonisolated static let probeTimeoutQueue = DispatchQueue(
+        label: "com.steipete.codexbar.probe-timeouts",
+        qos: .userInitiated)
+
+    private final class ProbeTimeoutRace: @unchecked Sendable {
+        private let lock = NSLock()
+        private var continuation: CheckedContinuation<String, Never>?
+        private var result: String?
+        private var cancellations: [() -> Void] = []
+
+        func install(_ continuation: CheckedContinuation<String, Never>) {
+            let result: String? = self.lock.withLock {
+                if let result = self.result {
+                    return result
+                }
+                self.continuation = continuation
+                return nil
+            }
+            if let result {
+                continuation.resume(returning: result)
+            }
+        }
+
+        func install(_ task: Task<Void, Never>) {
+            self.installCancellation {
+                task.cancel()
+            }
+        }
+
+        func install(_ workItem: DispatchWorkItem) {
+            self.installCancellation {
+                workItem.cancel()
+            }
+        }
+
+        private func installCancellation(_ cancellation: @escaping () -> Void) {
+            let shouldCancel = self.lock.withLock {
+                guard self.result == nil else { return true }
+                self.cancellations.append(cancellation)
+                return false
+            }
+            if shouldCancel {
+                cancellation()
+            }
+        }
+
+        func complete(with result: String) {
+            let completion = self.lock.withLock {
+                guard self.result == nil else {
+                    return (nil as CheckedContinuation<String, Never>?, [] as [() -> Void])
+                }
+                self.result = result
+                let continuation = self.continuation
+                self.continuation = nil
+                let cancellations = self.cancellations
+                self.cancellations.removeAll()
+                return (continuation, cancellations)
+            }
+            completion.1.forEach { $0() }
+            completion.0?.resume(returning: result)
+        }
+    }
+
+    nonisolated static func runWithTimeout(
+        seconds: Double,
+        operation: @escaping @Sendable () async -> String) async -> String
+    {
+        let timeoutMessage = "Probe timed out after \(Int(seconds))s"
+        let race = ProbeTimeoutRace()
+
+        return await withTaskCancellationHandler {
+            await withCheckedContinuation { continuation in
+                race.install(continuation)
+
+                race.install(Task {
+                    let result = await operation()
+                    race.complete(with: result)
+                })
+
+                // A Swift task-based timer can be delayed when the cooperative pool is
+                // saturated by blocking probes. Dispatch keeps the timeout wall-clock bounded.
+                let timeoutWorkItem = DispatchWorkItem {
+                    race.complete(with: timeoutMessage)
+                }
+                race.install(timeoutWorkItem)
+                Self.probeTimeoutQueue.asyncAfter(
+                    deadline: .now() + max(seconds, 0),
+                    execute: timeoutWorkItem)
+            }
+        } onCancel: {
+            race.complete(with: timeoutMessage)
+        }
+    }
+}
diff --git a/Sources/CodexBar/UsageStore+TokenAccounts.swift b/Sources/CodexBar/UsageStore+TokenAccounts.swift
index 3e55ffa9ff..3d84aa2835 100644
--- a/Sources/CodexBar/UsageStore+TokenAccounts.swift
+++ b/Sources/CodexBar/UsageStore+TokenAccounts.swift
@@ -1,7 +1,7 @@
 import CodexBarCore
 import Foundation
 
-struct TokenAccountUsageSnapshot: Identifiable, Sendable {
+struct TokenAccountUsageSnapshot: Identifiable {
     let id: UUID
     let account: ProviderTokenAccount
     let snapshot: UsageSnapshot?
@@ -17,7 +17,74 @@ struct TokenAccountUsageSnapshot: Identifiable, Sendable {
     }
 }
 
+struct CodexAccountUsageSnapshot: Identifiable {
+    let id: String
+    let account: CodexVisibleAccount
+    let snapshot: UsageSnapshot?
+    let error: String?
+    let sourceLabel: String?
+
+    init(account: CodexVisibleAccount, snapshot: UsageSnapshot?, error: String?, sourceLabel: String?) {
+        self.id = account.id
+        self.account = account
+        self.snapshot = snapshot
+        self.error = error
+        self.sourceLabel = sourceLabel
+    }
+}
+
 extension UsageStore {
+    func activateCachedTokenAccountSnapshot(provider: UsageProvider, accountID: UUID) {
+        guard let cached = self.accountSnapshots[provider]?.first(where: { $0.account.id == accountID }) else {
+            self.snapshots.removeValue(forKey: provider)
+            self.errors.removeValue(forKey: provider)
+            self.lastSourceLabels.removeValue(forKey: provider)
+            self.lastKnownResetSnapshots.removeValue(forKey: provider)
+            return
+        }
+
+        if let snapshot = cached.snapshot {
+            self.snapshots[provider] = snapshot
+            self.lastKnownResetSnapshots[provider] = snapshot
+        } else {
+            self.snapshots.removeValue(forKey: provider)
+            self.lastKnownResetSnapshots.removeValue(forKey: provider)
+        }
+        self.errors[provider] = cached.error
+        if let sourceLabel = cached.sourceLabel {
+            self.lastSourceLabels[provider] = sourceLabel
+        } else {
+            self.lastSourceLabels.removeValue(forKey: provider)
+        }
+    }
+}
+
+private struct TokenAccountFetchResult {
+    let index: Int
+    let account: ProviderTokenAccount
+    let outcome: ProviderFetchOutcome
+}
+
+private struct CodexAccountFetchResult {
+    let index: Int
+    let account: CodexVisibleAccount
+    let outcome: ProviderFetchOutcome
+}
+
+private struct CodexManagedVisibleAccountRuntimeState {
+    let authFingerprint: String?
+    let workspaceAccountID: String?
+}
+
+extension UsageStore {
+    static let tokenAccountMenuSnapshotLimit = 6
+    private static let codexSessionWindowMinutes = 5 * 60
+    private static let codexWeeklyWindowMinutes = 7 * 24 * 60
+
+    func freshCodexVisibleAccountsForSnapshotHydration() -> [CodexVisibleAccount] {
+        self.freshCodexVisibleAccountProjectionForAccountRefresh().visibleAccounts
+    }
+
     func tokenAccounts(for provider: UsageProvider) -> [ProviderTokenAccount] {
         guard TokenAccountSupportCatalog.support(for: provider) != nil else { return [] }
         return self.settings.tokenAccounts(for: provider)
@@ -25,30 +92,390 @@ extension UsageStore {
 
     func shouldFetchAllTokenAccounts(provider: UsageProvider, accounts: [ProviderTokenAccount]) -> Bool {
         guard TokenAccountSupportCatalog.support(for: provider) != nil else { return false }
-        return self.settings.showAllTokenAccountsInMenu && accounts.count > 1
+        return self.settings.multiAccountMenuLayout == .stacked && accounts.count > 1
+    }
+
+    func shouldFetchAllCodexVisibleAccounts() -> Bool {
+        let projection = self.freshCodexVisibleAccountProjectionForAccountRefresh()
+        return self.settings.multiAccountMenuLayout == .stacked &&
+            projection.visibleAccounts.count > 1
+    }
+
+    func refreshCodexVisibleAccountsForMenu(generation: UInt64? = nil) async {
+        let projection = self.freshCodexVisibleAccountProjectionForAccountRefresh()
+        let accounts = self.limitedCodexVisibleAccounts(
+            projection.visibleAccounts,
+            snapshots: self.codexAccountSnapshots,
+            activeVisibleAccountID: projection.activeVisibleAccountID)
+        guard accounts.count > 1 else {
+            self.codexAccountSnapshots = []
+            return
+        }
+        let managedAccountIDsWithReadableAuthAtStart = self.codexManagedAccountIDsWithReadableAuth()
+
+        let originalVisibleAccountID = projection.activeVisibleAccountID
+        let originalSelectionSource = originalVisibleAccountID.flatMap {
+            projection.source(forVisibleAccountID: $0)
+        }
+        let originalVisibleAccount = originalVisibleAccountID.flatMap { id in
+            accounts.first { $0.id == id }
+        }
+        let priorByAccountID = Dictionary(uniqueKeysWithValues: self.codexAccountSnapshots.map { ($0.id, $0) })
+        var snapshots: [CodexAccountUsageSnapshot] = []
+        var selectedOutcome: ProviderFetchOutcome?
+        var selectedAccount: CodexVisibleAccount?
+        var selectedSnapshot: UsageSnapshot?
+        var selectedSourceLabel: String?
+        var sawAnyNonCancellationOutcome = false
+
+        let results = await self.fetchCodexVisibleAccountOutcomes(accounts)
+        for result in results {
+            let account = result.account
+            let outcome = result.outcome
+            let isCancellation = Self.outcomeIsCancellation(outcome)
+            if !isCancellation {
+                sawAnyNonCancellationOutcome = true
+            }
+            let resolved = self.resolveCodexAccountOutcome(
+                outcome,
+                account: account,
+                priorSnapshot: priorByAccountID[account.id],
+                resetBackfillSnapshots: self.codexResetBackfillSnapshots(
+                    for: account,
+                    priorSnapshot: priorByAccountID[account.id],
+                    activeVisibleAccountID: originalVisibleAccountID))
+            if let snapshot = resolved.snapshot {
+                snapshots.append(snapshot)
+            }
+            if account.id == originalVisibleAccountID {
+                selectedOutcome = outcome
+                selectedAccount = account
+                selectedSnapshot = resolved.usage
+                selectedSourceLabel = resolved.sourceLabel
+            }
+        }
+
+        let currentProjection = self.freshCodexVisibleAccountProjectionForAccountRefresh(
+            requireLiveManagedAuthFor: managedAccountIDsWithReadableAuthAtStart)
+        guard self.isCurrentProviderRefreshGeneration(.codex, generation: generation) else { return }
+        let currentSnapshots = snapshots.compactMap { snapshot -> CodexAccountUsageSnapshot? in
+            guard let currentAccount = Self.currentCodexVisibleAccount(
+                matching: snapshot.account,
+                projection: currentProjection,
+                allowProviderAccountAuthFingerprintMismatch: snapshot.error == nil)
+            else {
+                return nil
+            }
+            guard currentAccount != snapshot.account else { return snapshot }
+            return CodexAccountUsageSnapshot(
+                account: currentAccount,
+                snapshot: Self.codexVisibleAccountSnapshotRelabeledForCurrentProjection(
+                    snapshot.snapshot,
+                    account: currentAccount),
+                error: snapshot.error,
+                sourceLabel: snapshot.sourceLabel)
+        }
+        let shouldPreservePriorState = !sawAnyNonCancellationOutcome &&
+            currentSnapshots.allSatisfy { $0.snapshot == nil }
+        if !shouldPreservePriorState {
+            self.codexAccountSnapshots = currentSnapshots
+            self.codexAccountUsageSnapshotStore?.store(currentSnapshots)
+        }
+
+        let selectionStillMatches = self.codexVisibleSelectionStillMatches(
+            originalVisibleAccountID: originalVisibleAccountID,
+            originalSelectionSource: originalSelectionSource,
+            originalAccount: originalVisibleAccount,
+            currentProjection: currentProjection)
+        guard let selectedOutcome, let selectedAccount else { return }
+        guard selectionStillMatches else {
+            _ = self.prepareCodexAccountScopedRefreshIfNeeded()
+            return
+        }
+
+        let allowSelectedAuthFingerprintMismatch = switch selectedOutcome.result {
+        case .success:
+            true
+        case .failure:
+            false
+        }
+        let currentSelectedAccount = Self.currentCodexVisibleAccount(
+            matching: selectedAccount,
+            projection: currentProjection,
+            allowProviderAccountAuthFingerprintMismatch: allowSelectedAuthFingerprintMismatch)
+        if let currentSelectedAccount {
+            let currentSelectedSnapshot = Self.codexVisibleAccountSnapshotRelabeledForCurrentProjection(
+                selectedSnapshot,
+                account: currentSelectedAccount)
+            if self.shouldApplySelectedCodexVisibleAccountOutcome(
+                selectedOutcome,
+                snapshot: currentSelectedSnapshot)
+            {
+                await self.applySelectedCodexVisibleAccountOutcome(
+                    selectedOutcome,
+                    account: currentSelectedAccount,
+                    snapshot: currentSelectedSnapshot,
+                    sourceLabel: selectedSourceLabel,
+                    generation: generation)
+            }
+        } else {
+            _ = self.prepareCodexAccountScopedRefreshIfNeeded()
+        }
     }
 
-    func refreshTokenAccounts(provider: UsageProvider, accounts: [ProviderTokenAccount]) async {
+    func codexVisibleSelectionStillMatches(
+        originalVisibleAccountID: String?,
+        originalSelectionSource: CodexActiveSource?,
+        originalAccount: CodexVisibleAccount? = nil,
+        currentProjection: CodexVisibleAccountProjection? = nil) -> Bool
+    {
+        let currentProjection = currentProjection ?? self.settings.codexVisibleAccountProjection
+        let currentActiveAccount = currentProjection.activeVisibleAccountID.flatMap { id in
+            currentProjection.visibleAccounts.first { $0.id == id }
+        }
+        let currentSelectionSource = currentActiveAccount?.selectionSource
+        if currentProjection.activeVisibleAccountID == originalVisibleAccountID,
+           currentSelectionSource == originalSelectionSource
+        {
+            return true
+        }
+        guard let originalAccount, let currentActiveAccount, currentSelectionSource == originalSelectionSource else {
+            return false
+        }
+        return Self.codexVisibleAccountMatchesCurrentProjection(originalAccount, account: currentActiveAccount)
+    }
+
+    private func freshCodexVisibleAccountProjectionForAccountRefresh(
+        requireLiveManagedAuthFor accountIDs: Set<UUID> = []) -> CodexVisibleAccountProjection
+    {
+        // Auth files can change while account fetches are in flight, so account refreshes bypass the
+        // short-lived reconciliation cache used for normal menu rendering and stale-result guards.
+        self.settings.invalidateCodexAccountReconciliationSnapshotCache()
+        let snapshot = self.settings.codexAccountReconciliationSnapshot
+        return Self.codexVisibleAccountProjectionWithFreshManagedAuthFingerprints(
+            CodexVisibleAccountProjection.make(from: snapshot),
+            snapshot: snapshot,
+            requireLiveManagedAuthFor: accountIDs)
+    }
+
+    private func codexManagedAccountIDsWithReadableAuth() -> Set<UUID> {
+        Set(self.settings.codexAccountReconciliationSnapshot.storedAccounts.compactMap { account in
+            CodexAuthFingerprint.fingerprint(homePath: account.managedHomePath) == nil ? nil : account.id
+        })
+    }
+
+    private nonisolated static func codexVisibleAccountProjectionWithFreshManagedAuthFingerprints(
+        _ projection: CodexVisibleAccountProjection,
+        snapshot: CodexAccountReconciliationSnapshot,
+        requireLiveManagedAuthFor accountIDs: Set<UUID> = []) -> CodexVisibleAccountProjection
+    {
+        let managedRuntimeStates = Dictionary(
+            uniqueKeysWithValues: snapshot.storedAccounts.map { account in
+                let workspaceAccountID: String? = switch snapshot.runtimeIdentity(for: account) {
+                case let .providerAccount(id):
+                    id
+                case .emailOnly, .unresolved:
+                    nil
+                }
+                let authFingerprint = CodexAuthFingerprint.fingerprint(homePath: account.managedHomePath)
+                let requiresLiveAuth = accountIDs.contains(account.id)
+                return (account.id, CodexManagedVisibleAccountRuntimeState(
+                    authFingerprint: authFingerprint ?? (requiresLiveAuth ? nil : account.authFingerprint),
+                    workspaceAccountID: authFingerprint == nil && requiresLiveAuth
+                        ? nil
+                        : (workspaceAccountID ?? account.workspaceAccountID)))
+            })
+        let visibleAccounts = projection.visibleAccounts.map { account in
+            guard case let .managedAccount(id) = account.selectionSource else { return account }
+            let accountWorkspaceAccountID = account.workspaceAccountID
+                .map(CodexOpenAIWorkspaceIdentity.normalizeWorkspaceAccountID)
+            let runtimeWorkspaceAccountID = managedRuntimeStates[id]?.workspaceAccountID
+                .map(CodexOpenAIWorkspaceIdentity.normalizeWorkspaceAccountID)
+            guard let runtimeState = managedRuntimeStates[id],
+                  runtimeState.authFingerprint != account.authFingerprint ||
+                  runtimeWorkspaceAccountID != accountWorkspaceAccountID
+            else {
+                return account
+            }
+            return CodexVisibleAccount(
+                id: account.id,
+                email: account.email,
+                workspaceLabel: account.workspaceLabel,
+                workspaceAccountID: runtimeState.workspaceAccountID,
+                authFingerprint: runtimeState.authFingerprint,
+                storedAccountID: account.storedAccountID,
+                selectionSource: account.selectionSource,
+                isActive: account.isActive,
+                isLive: account.isLive,
+                canReauthenticate: account.canReauthenticate,
+                canRemove: account.canRemove)
+        }
+        return CodexVisibleAccountProjection(
+            visibleAccounts: visibleAccounts,
+            activeVisibleAccountID: projection.activeVisibleAccountID,
+            liveVisibleAccountID: projection.liveVisibleAccountID,
+            hasUnreadableAddedAccountStore: projection.hasUnreadableAddedAccountStore)
+    }
+
+    private static func currentCodexVisibleAccount(
+        matching account: CodexVisibleAccount,
+        projection: CodexVisibleAccountProjection,
+        allowProviderAccountAuthFingerprintMismatch: Bool = true) -> CodexVisibleAccount?
+    {
+        if let currentAccount = projection.visibleAccounts.first(where: { $0.id == account.id }),
+           self.codexVisibleAccountMatchesCurrentProjection(
+               account,
+               account: currentAccount,
+               allowProviderAccountAuthFingerprintMismatch: allowProviderAccountAuthFingerprintMismatch)
+        {
+            return currentAccount
+        }
+        return projection.visibleAccounts.first {
+            self.codexVisibleAccountMatchesCurrentProjection(
+                account,
+                account: $0,
+                allowProviderAccountAuthFingerprintMismatch: allowProviderAccountAuthFingerprintMismatch)
+        }
+    }
+
+    private static func codexVisibleAccountSnapshotRelabeledForCurrentProjection(
+        _ snapshot: UsageSnapshot?,
+        account: CodexVisibleAccount) -> UsageSnapshot?
+    {
+        guard let snapshot else { return nil }
+        let existing = snapshot.identity(for: .codex)
+        return snapshot.withIdentity(ProviderIdentitySnapshot(
+            providerID: .codex,
+            accountEmail: account.email,
+            accountOrganization: existing?.accountOrganization,
+            loginMethod: existing?.loginMethod ?? account.workspaceLabel))
+    }
+
+    private static func codexVisibleAccountMatchesCurrentProjection(
+        _ prior: CodexVisibleAccount,
+        account: CodexVisibleAccount,
+        allowProviderAccountAuthFingerprintMismatch: Bool = true) -> Bool
+    {
+        guard prior.selectionSource == account.selectionSource else { return false }
+
+        let priorEmail = CodexIdentityResolver.normalizeEmail(prior.email)
+        let accountEmail = CodexIdentityResolver.normalizeEmail(account.email)
+
+        let priorWorkspaceID = self.normalizedCodexVisibleAccountText(prior.workspaceAccountID)
+            .map(CodexOpenAIWorkspaceIdentity.normalizeWorkspaceAccountID)
+        let accountWorkspaceID = self.normalizedCodexVisibleAccountText(account.workspaceAccountID)
+            .map(CodexOpenAIWorkspaceIdentity.normalizeWorkspaceAccountID)
+        if priorWorkspaceID != nil || accountWorkspaceID != nil {
+            guard priorWorkspaceID == accountWorkspaceID else { return false }
+            if !allowProviderAccountAuthFingerprintMismatch {
+                guard self.codexVisibleAccountAuthFingerprintMatches(prior, account: account) else { return false }
+            }
+            switch account.selectionSource {
+            case .managedAccount:
+                if !self.codexVisibleAccountAuthFingerprintMatches(prior, account: account) {
+                    return priorEmail != nil && priorEmail == accountEmail
+                }
+                return true
+            case .liveSystem:
+                return priorEmail != nil && priorEmail == accountEmail
+            case .profileHome:
+                if !allowProviderAccountAuthFingerprintMismatch {
+                    guard self.codexVisibleAccountAuthFingerprintMatches(prior, account: account) else { return false }
+                }
+                return priorEmail != nil && priorEmail == accountEmail
+            }
+        }
+
+        let priorAuthFingerprint = CodexAuthFingerprint.normalize(prior.authFingerprint)
+        let accountAuthFingerprint = CodexAuthFingerprint.normalize(account.authFingerprint)
+        if priorAuthFingerprint != nil || accountAuthFingerprint != nil {
+            guard priorAuthFingerprint == accountAuthFingerprint else { return false }
+        }
+
+        return priorEmail != nil && priorEmail == accountEmail
+    }
+
+    private static func codexVisibleAccountAuthFingerprintMatches(
+        _ prior: CodexVisibleAccount,
+        account: CodexVisibleAccount) -> Bool
+    {
+        let priorAuthFingerprint = CodexAuthFingerprint.normalize(prior.authFingerprint)
+        let accountAuthFingerprint = CodexAuthFingerprint.normalize(account.authFingerprint)
+        if priorAuthFingerprint != nil || accountAuthFingerprint != nil {
+            return priorAuthFingerprint == accountAuthFingerprint
+        }
+        return true
+    }
+
+    func shouldApplySelectedCodexVisibleAccountOutcome(
+        _ outcome: ProviderFetchOutcome,
+        snapshot: UsageSnapshot?) -> Bool
+    {
+        switch outcome.result {
+        case .success:
+            snapshot != nil
+        case .failure:
+            true
+        }
+    }
+
+    func refreshTokenAccounts(
+        provider: UsageProvider,
+        accounts: [ProviderTokenAccount],
+        generation: UInt64? = nil) async
+    {
         let selectedAccount = self.settings.selectedTokenAccount(for: provider)
         let limitedAccounts = self.limitedTokenAccounts(accounts, selected: selectedAccount)
         let effectiveSelected = selectedAccount ?? limitedAccounts.first
+
+        // Capture the prior per-account snapshot state so we can preserve last-good
+        // data when an in-flight refresh is cancelled (e.g. menu tab switches). Without
+        // this, cancellation produces empty/error snapshots and the menu briefly shows
+        // misleading cards for accounts that previously had valid data.
+        let priorSnapshots = await MainActor.run { self.accountSnapshots[provider] ?? [] }
+        let priorByAccountID = Dictionary(uniqueKeysWithValues: priorSnapshots.map { ($0.account.id, $0) })
+
         var snapshots: [TokenAccountUsageSnapshot] = []
+        var historySamples: [(account: ProviderTokenAccount, snapshot: UsageSnapshot)] = []
         var selectedOutcome: ProviderFetchOutcome?
         var selectedSnapshot: UsageSnapshot?
+        var sawAnyNonCancellationOutcome = false
 
-        for account in limitedAccounts {
-            let override = TokenAccountOverride(provider: provider, account: account)
-            let outcome = await self.fetchOutcome(provider: provider, override: override)
-            let resolved = self.resolveAccountOutcome(outcome, provider: provider, account: account)
-            snapshots.append(resolved.snapshot)
+        let results = await self.fetchTokenAccountOutcomes(provider: provider, accounts: limitedAccounts)
+        guard self.isCurrentProviderRefreshGeneration(provider, generation: generation) else { return }
+        for result in results {
+            let account = result.account
+            let outcome = result.outcome
+            let isCancellation = Self.outcomeIsCancellation(outcome)
+            if !isCancellation {
+                sawAnyNonCancellationOutcome = true
+            }
+            let resolved = self.resolveAccountOutcome(
+                outcome,
+                provider: provider,
+                account: account,
+                priorSnapshot: priorByAccountID[account.id])
+            if let snapshot = resolved.snapshot {
+                snapshots.append(snapshot)
+            }
+            if let usage = resolved.usage {
+                historySamples.append((account: account, snapshot: usage))
+            }
             if account.id == effectiveSelected?.id {
                 selectedOutcome = outcome
                 selectedSnapshot = resolved.usage
             }
         }
 
-        await MainActor.run {
-            self.accountSnapshots[provider] = snapshots
+        // If every fetch was cancelled (e.g. the user closed/reopened the menu mid-flight)
+        // and we have no usable snapshots, leave the prior per-account state alone.
+        // Wiping it would produce a menu of useless "cancelled" placeholders.
+        let shouldPreservePriorState = !sawAnyNonCancellationOutcome &&
+            snapshots.allSatisfy { $0.snapshot == nil }
+        if !shouldPreservePriorState {
+            await MainActor.run {
+                self.accountSnapshots[provider] = snapshots
+            }
         }
 
         if let selectedOutcome {
@@ -56,15 +483,47 @@ extension UsageStore {
                 selectedOutcome,
                 provider: provider,
                 account: effectiveSelected,
-                fallbackSnapshot: selectedSnapshot)
+                fallbackSnapshot: selectedSnapshot,
+                generation: generation)
+        }
+
+        guard self.isCurrentProviderRefreshGeneration(provider, generation: generation) else { return }
+        await self.recordFetchedTokenAccountPlanUtilizationHistory(
+            provider: provider,
+            samples: historySamples,
+            selectedAccount: effectiveSelected)
+    }
+
+    private static func outcomeIsCancellation(_ outcome: ProviderFetchOutcome) -> Bool {
+        if case let .failure(error) = outcome.result, error is CancellationError {
+            return true
         }
+        if case let .failure(error) = outcome.result {
+            return self.errorIsCancellation(error)
+        }
+        return false
+    }
+
+    private static func errorIsCancellation(_ error: any Error) -> Bool {
+        if error is CancellationError {
+            return true
+        }
+        if let urlError = error as? URLError, urlError.code == .cancelled {
+            return true
+        }
+        let message = error.localizedDescription
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .lowercased()
+        return message == "cancelled" ||
+            message.contains("cancellationerror") ||
+            message.contains("cancelled")
     }
 
     func limitedTokenAccounts(
         _ accounts: [ProviderTokenAccount],
         selected: ProviderTokenAccount?) -> [ProviderTokenAccount]
     {
-        let limit = 6
+        let limit = Self.tokenAccountMenuSnapshotLimit
         if accounts.count <= limit { return accounts }
         var limited = Array(accounts.prefix(limit))
         if let selected, !limited.contains(where: { $0.id == selected.id }) {
@@ -74,32 +533,188 @@ extension UsageStore {
         return limited
     }
 
+    func limitedCodexVisibleAccounts(
+        _ accounts: [CodexVisibleAccount],
+        snapshots: [CodexAccountUsageSnapshot] = [],
+        activeVisibleAccountID: String?) -> [CodexVisibleAccount]
+    {
+        let accounts = CodexAccountPresentationOrdering.orderedAccounts(
+            accounts,
+            snapshots: snapshots,
+            activeVisibleAccountID: activeVisibleAccountID)
+        let limit = Self.tokenAccountMenuSnapshotLimit
+        if accounts.count <= limit { return accounts }
+        var limited = Array(accounts.prefix(limit))
+        if let activeVisibleAccountID,
+           let active = accounts.first(where: { $0.id == activeVisibleAccountID }),
+           !limited.contains(where: { $0.id == activeVisibleAccountID })
+        {
+            limited.removeLast()
+            limited.append(active)
+        }
+        return limited
+    }
+
     func fetchOutcome(
         provider: UsageProvider,
-        override: TokenAccountOverride?) async -> ProviderFetchOutcome
+        override: TokenAccountOverride?,
+        codexActiveSourceOverride: CodexActiveSource? = nil) async -> ProviderFetchOutcome
+    {
+        let descriptor = self.providerSpecs[provider]?.descriptor ?? ProviderDescriptorRegistry
+            .descriptor(for: provider)
+        let context = self.makeFetchContext(
+            provider: provider,
+            override: override,
+            codexActiveSourceOverride: codexActiveSourceOverride)
+        return await descriptor.fetchOutcome(context: context)
+    }
+
+    private func fetchTokenAccountOutcomes(
+        provider: UsageProvider,
+        accounts: [ProviderTokenAccount]) async -> [TokenAccountFetchResult]
+    {
+        let requests: [(
+            index: Int,
+            account: ProviderTokenAccount,
+            descriptor: ProviderDescriptor,
+            context: ProviderFetchContext)] =
+            accounts.enumerated().map { index, account in
+                let override = TokenAccountOverride(provider: provider, account: account)
+                let descriptor = self.providerSpecs[provider]?.descriptor ?? ProviderDescriptorRegistry
+                    .descriptor(for: provider)
+                let context = self.makeFetchContext(provider: provider, override: override)
+                return (index, account, descriptor, context)
+            }
+
+        return await withTaskGroup(
+            of: TokenAccountFetchResult.self,
+            returning: [TokenAccountFetchResult].self)
+        { group in
+            for request in requests {
+                group.addTask {
+                    let outcome = await request.descriptor.fetchOutcome(context: request.context)
+                    return TokenAccountFetchResult(
+                        index: request.index,
+                        account: request.account,
+                        outcome: outcome)
+                }
+            }
+
+            var results: [TokenAccountFetchResult] = []
+            results.reserveCapacity(requests.count)
+            for await result in group {
+                results.append(result)
+            }
+            return results.sorted { $0.index < $1.index }
+        }
+    }
+
+    private func fetchCodexVisibleAccountOutcomes(_ accounts: [CodexVisibleAccount]) async
+    -> [CodexAccountFetchResult] {
+        let requests: [(
+            index: Int,
+            account: CodexVisibleAccount,
+            descriptor: ProviderDescriptor,
+            context: ProviderFetchContext)] =
+            accounts.enumerated().map { index, account in
+                let descriptor = self.providerSpecs[.codex]?.descriptor ?? ProviderDescriptorRegistry
+                    .descriptor(for: .codex)
+                let context = self.makeFetchContext(
+                    provider: .codex,
+                    override: nil,
+                    codexActiveSourceOverride: account.selectionSource)
+                return (index, account, descriptor, context)
+            }
+
+        return await withTaskGroup(
+            of: CodexAccountFetchResult.self,
+            returning: [CodexAccountFetchResult].self)
+        { group in
+            for request in requests {
+                group.addTask {
+                    let outcome = await request.descriptor.fetchOutcome(context: request.context)
+                    return CodexAccountFetchResult(
+                        index: request.index,
+                        account: request.account,
+                        outcome: outcome)
+                }
+            }
+
+            var results: [CodexAccountFetchResult] = []
+            results.reserveCapacity(requests.count)
+            for await result in group {
+                results.append(result)
+            }
+            return results.sorted { $0.index < $1.index }
+        }
+    }
+
+    func makeFetchContext(
+        provider: UsageProvider,
+        override: TokenAccountOverride?,
+        codexActiveSourceOverride: CodexActiveSource? = nil,
+        includeCredits: Bool = false) -> ProviderFetchContext
     {
-        let descriptor = ProviderDescriptorRegistry.descriptor(for: provider)
+        let account = ProviderTokenAccountSelection.selectedAccount(
+            provider: provider,
+            settings: self.settings,
+            override: override)
         let sourceMode = self.sourceMode(for: provider)
-        let snapshot = ProviderRegistry.makeSettingsSnapshot(settings: self.settings, tokenOverride: override)
+        let snapshot = ProviderRegistry.makeSettingsSnapshot(
+            settings: self.settings,
+            tokenOverride: override,
+            codexActiveSourceOverride: codexActiveSourceOverride)
         let env = ProviderRegistry.makeEnvironment(
-            base: ProcessInfo.processInfo.environment,
+            base: self.environmentBase,
             provider: provider,
             settings: self.settings,
-            tokenOverride: override)
+            tokenOverride: override,
+            codexActiveSourceOverride: codexActiveSourceOverride)
+        let fetcher = ProviderRegistry.makeFetcher(base: self.codexFetcher, provider: provider, env: env)
         let verbose = self.settings.isVerboseLoggingEnabled
-        let context = ProviderFetchContext(
+        let contextProvider = provider
+        let originalAccountToken = account?.token
+        let originalManualToken = provider == .stepfun ? self.settings.stepfunToken : nil
+        return ProviderFetchContext(
             runtime: .app,
             sourceMode: sourceMode,
-            includeCredits: false,
+            includeCredits: includeCredits,
+            includeOptionalUsage: self.settings.showOptionalCreditsAndExtraUsage,
             webTimeout: 60,
             webDebugDumpHTML: false,
             verbose: verbose,
             env: env,
             settings: snapshot,
-            fetcher: self.codexFetcher,
+            fetcher: fetcher,
             claudeFetcher: self.claudeFetcher,
-            browserDetection: self.browserDetection)
-        return await descriptor.fetchOutcome(context: context)
+            browserDetection: self.browserDetection,
+            selectedTokenAccountID: account?.id,
+            tokenAccountTokenUpdater: { [weak self] provider, accountID, token in
+                await MainActor.run {
+                    guard let self, provider == contextProvider,
+                          self.settings.tokenAccounts(for: provider)
+                              .first(where: { $0.id == accountID })?.token == originalAccountToken
+                    else {
+                        return
+                    }
+                    self.settings.updateTokenAccount(
+                        provider: provider,
+                        accountID: accountID,
+                        token: token)
+                }
+            },
+            providerManualTokenUpdater: { [weak self] provider, token in
+                await MainActor.run {
+                    guard let self, provider == .stepfun,
+                          self.settings.stepfunToken == originalManualToken
+                    else { return }
+                    self.settings.stepfunToken = token
+                }
+            },
+            costUsageHistoryDays: self.settings.costUsageHistoryDays,
+            persistsCLISessions: true,
+            persistentCLISessionIdleWindow: ProviderRegistry.persistentCLISessionIdleWindow(
+                refreshInterval: self.settings.refreshFrequency.seconds))
     }
 
     func sourceMode(for provider: UsageProvider) -> ProviderSourceMode {
@@ -109,14 +724,350 @@ extension UsageStore {
     }
 
     private struct ResolvedAccountOutcome {
-        let snapshot: TokenAccountUsageSnapshot
+        let snapshot: TokenAccountUsageSnapshot?
         let usage: UsageSnapshot?
     }
 
+    private struct ResolvedCodexAccountOutcome {
+        let snapshot: CodexAccountUsageSnapshot?
+        let usage: UsageSnapshot?
+        let sourceLabel: String?
+    }
+
+    private struct CodexResetBackfillWindowCandidate {
+        let window: RateWindow
+        let capturedAt: Date
+    }
+
+    func tokenAccountErrorMessage(_ error: any Error) -> String? {
+        guard !Self.errorIsCancellation(error) else { return nil }
+        let message = error.localizedDescription.trimmingCharacters(in: .whitespacesAndNewlines)
+        return message.isEmpty ? nil : message
+    }
+
+    /// Per-account snapshot error text. Cancellation is handled before this path so
+    /// transient menu refresh cancellation does not render as a user-facing error.
+    func tokenAccountSnapshotErrorMessage(_ error: any Error) -> String {
+        let message = error.localizedDescription.trimmingCharacters(in: .whitespacesAndNewlines)
+        return message.isEmpty ? "Refresh failed" : message
+    }
+
+    private func codexResetBackfillSnapshots(
+        for account: CodexVisibleAccount,
+        priorSnapshot: CodexAccountUsageSnapshot?,
+        activeVisibleAccountID: String?) -> [UsageSnapshot]
+    {
+        var snapshots: [UsageSnapshot] = []
+        if let priorSnapshot,
+           Self.codexPriorSnapshotAccountMatches(priorSnapshot.account, account: account),
+           let prior = priorSnapshot.snapshot
+        {
+            snapshots.append(prior)
+        }
+        if account.id == activeVisibleAccountID,
+           let lastKnown = self.codexLastKnownResetSnapshot(for: account)
+        {
+            snapshots.append(lastKnown)
+        }
+        if account.id != activeVisibleAccountID || self.codexCanUseHistoricalResetBackfill(for: account),
+           let history = self.codexPlanHistoryResetBackfillSnapshot(for: account)
+        {
+            snapshots.append(history)
+        }
+        return snapshots
+    }
+
+    private func codexCanUseHistoricalResetBackfill(for account: CodexVisibleAccount) -> Bool {
+        let authFingerprint = CodexAuthFingerprint.normalize(account.authFingerprint)
+        let workspaceAccountID = Self.normalizedCodexVisibleAccountText(account.workspaceAccountID)
+            .map(CodexOpenAIWorkspaceIdentity.normalizeWorkspaceAccountID)
+        guard authFingerprint != nil, workspaceAccountID == nil else { return true }
+        return Self.codexScopedGuard(self.lastCodexAccountScopedRefreshGuard, matches: account)
+    }
+
+    private func codexPlanHistoryResetBackfillSnapshot(for account: CodexVisibleAccount) -> UsageSnapshot? {
+        let histories = self.codexPlanUtilizationHistories(forVisibleAccount: account)
+        guard !histories.isEmpty
+        else {
+            return nil
+        }
+
+        let now = Date()
+        let primaryCandidate = Self.codexResetBackfillWindowCandidate(
+            from: histories,
+            name: .session,
+            windowMinutes: Self.codexSessionWindowMinutes,
+            now: now)
+        let secondaryCandidate = Self.codexResetBackfillWindowCandidate(
+            from: histories,
+            name: .weekly,
+            windowMinutes: Self.codexWeeklyWindowMinutes,
+            now: now)
+        let primary = primaryCandidate?.window
+        let secondary = secondaryCandidate?.window
+        guard primary != nil || secondary != nil else { return nil }
+
+        return UsageSnapshot(
+            primary: primary,
+            secondary: secondary,
+            updatedAt: [primaryCandidate?.capturedAt, secondaryCandidate?.capturedAt].compactMap(\.self).max() ?? now,
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: account.email,
+                accountOrganization: nil,
+                loginMethod: account.workspaceLabel))
+    }
+
+    private func codexLastKnownResetSnapshot(for account: CodexVisibleAccount) -> UsageSnapshot? {
+        guard let snapshot = self.lastKnownResetSnapshots[.codex],
+              Self.codexVisibleAccountEmailMatches(snapshot: snapshot, account: account),
+              Self.codexScopedGuard(self.lastCodexAccountScopedRefreshGuard, matches: account)
+        else {
+            return nil
+        }
+        return snapshot
+    }
+
+    func codexLastKnownResetSnapshot(matching guardValue: CodexAccountScopedRefreshGuard?) -> UsageSnapshot? {
+        guard let guardValue,
+              let lastGuard = self.lastCodexAccountScopedRefreshGuard,
+              Self.codexScopedRefreshGuardAllowsResetBackfill(lastGuard, matching: guardValue)
+        else {
+            return nil
+        }
+        return self.lastKnownResetSnapshots[.codex]
+    }
+
+    private nonisolated static func codexVisibleAccountEmailMatches(
+        snapshot: UsageSnapshot,
+        account: CodexVisibleAccount) -> Bool
+    {
+        guard let identity = snapshot.identity(for: .codex),
+              let identityEmail = CodexIdentityResolver.normalizeEmail(identity.accountEmail),
+              let accountEmail = CodexIdentityResolver.normalizeEmail(account.email),
+              identityEmail == accountEmail
+        else {
+            return false
+        }
+        return true
+    }
+
+    private nonisolated static func codexPriorSnapshotAccountMatches(
+        _ prior: CodexVisibleAccount,
+        account: CodexVisibleAccount) -> Bool
+    {
+        guard let priorEmail = CodexIdentityResolver.normalizeEmail(prior.email),
+              let accountEmail = CodexIdentityResolver.normalizeEmail(account.email),
+              priorEmail == accountEmail
+        else {
+            return false
+        }
+
+        let priorWorkspaceID = self.normalizedCodexVisibleAccountText(prior.workspaceAccountID)
+            .map(CodexOpenAIWorkspaceIdentity.normalizeWorkspaceAccountID)
+        let accountWorkspaceID = self.normalizedCodexVisibleAccountText(account.workspaceAccountID)
+            .map(CodexOpenAIWorkspaceIdentity.normalizeWorkspaceAccountID)
+        if priorWorkspaceID != nil || accountWorkspaceID != nil {
+            return priorWorkspaceID == accountWorkspaceID
+        }
+
+        let priorAuthFingerprint = CodexAuthFingerprint.normalize(prior.authFingerprint)
+        let accountAuthFingerprint = CodexAuthFingerprint.normalize(account.authFingerprint)
+        if priorAuthFingerprint != nil || accountAuthFingerprint != nil {
+            guard priorAuthFingerprint == accountAuthFingerprint else { return false }
+        }
+
+        if prior.selectionSource == account.selectionSource {
+            switch account.selectionSource {
+            case .managedAccount:
+                return true
+            case .liveSystem:
+                return prior.id == account.id
+            case .profileHome:
+                return true
+            }
+        }
+
+        guard prior.id != prior.email, account.id != account.email else { return false }
+        return prior.id == account.id
+    }
+
+    private nonisolated static func codexScopedGuard(
+        _ guardValue: CodexAccountScopedRefreshGuard?,
+        matches account: CodexVisibleAccount) -> Bool
+    {
+        guard let guardValue, guardValue.source == account.selectionSource else { return false }
+        let guardAuthFingerprint = CodexAuthFingerprint.normalize(guardValue.authFingerprint)
+        let accountAuthFingerprint = CodexAuthFingerprint.normalize(account.authFingerprint)
+        if guardAuthFingerprint != nil || accountAuthFingerprint != nil {
+            guard guardAuthFingerprint == accountAuthFingerprint else { return false }
+        }
+        let identity = self.codexVisibleAccountIdentity(for: account)
+        if identity != .unresolved {
+            return guardValue.identity == identity
+        }
+        guard let accountKey = CodexIdentityResolver.normalizeEmail(account.email) else { return false }
+        return guardValue.accountKey == accountKey
+    }
+
+    private nonisolated static func codexScopedRefreshGuardAllowsResetBackfill(
+        _ lastGuard: CodexAccountScopedRefreshGuard,
+        matching expectedGuard: CodexAccountScopedRefreshGuard) -> Bool
+    {
+        self.codexScopedRefreshGuardsMatchAccount(lastGuard, expectedGuard)
+    }
+
+    private nonisolated static func codexScopedRefreshGuard(for account: CodexVisibleAccount)
+        -> CodexAccountScopedRefreshGuard
+    {
+        let accountEmail = CodexIdentityResolver.normalizeEmail(account.email)
+        return CodexAccountScopedRefreshGuard(
+            source: account.selectionSource,
+            identity: self.codexVisibleAccountIdentity(for: account),
+            accountKey: accountEmail,
+            authFingerprint: account.authFingerprint)
+    }
+
+    private nonisolated static func codexVisibleAccountIdentity(for account: CodexVisibleAccount) -> CodexIdentity {
+        if let workspaceAccountID = self.normalizedCodexVisibleAccountText(account.workspaceAccountID) {
+            return .providerAccount(id: CodexOpenAIWorkspaceIdentity.normalizeWorkspaceAccountID(workspaceAccountID))
+        }
+        return CodexIdentityResolver.resolve(accountId: nil, email: account.email)
+    }
+
+    private nonisolated static func normalizedCodexVisibleAccountText(_ text: String?) -> String? {
+        guard let trimmed = text?.trimmingCharacters(in: .whitespacesAndNewlines), !trimmed.isEmpty else {
+            return nil
+        }
+        return trimmed
+    }
+
+    private nonisolated static func codexResetBackfillWindowCandidate(
+        from histories: [PlanUtilizationSeriesHistory],
+        name: PlanUtilizationSeriesName,
+        windowMinutes: Int,
+        now: Date) -> CodexResetBackfillWindowCandidate?
+    {
+        let candidate = histories.lazy
+            .filter { $0.name == name && name.canonicalWindowMinutes($0.windowMinutes) == windowMinutes }
+            .flatMap { history in
+                history.entries.map { entry in
+                    (capturedAt: entry.capturedAt, usedPercent: entry.usedPercent, resetsAt: entry.resetsAt)
+                }
+            }
+            .filter { $0.resetsAt.map { $0 > now } ?? false }
+            .max { lhs, rhs in
+                if lhs.capturedAt != rhs.capturedAt {
+                    return lhs.capturedAt < rhs.capturedAt
+                }
+                return (lhs.resetsAt ?? .distantPast) < (rhs.resetsAt ?? .distantPast)
+            }
+
+        guard let candidate, let resetsAt = candidate.resetsAt else { return nil }
+        return CodexResetBackfillWindowCandidate(
+            window: RateWindow(
+                usedPercent: candidate.usedPercent,
+                windowMinutes: windowMinutes,
+                resetsAt: resetsAt,
+                resetDescription: nil),
+            capturedAt: candidate.capturedAt)
+    }
+
+    private nonisolated static func codexBackfillingResetWindows(
+        _ snapshot: UsageSnapshot,
+        from cached: UsageSnapshot) -> UsageSnapshot
+    {
+        let primary = self.codexBackfillingResetWindow(snapshot.primary, from: cached.primary)
+        let secondary = self.codexBackfillingResetWindow(snapshot.secondary, from: cached.secondary)
+        guard primary != snapshot.primary || secondary != snapshot.secondary else { return snapshot }
+        return snapshot.with(primary: primary, secondary: secondary)
+    }
+
+    private nonisolated static func codexMergedResetBackfillSnapshot(
+        _ snapshots: [UsageSnapshot],
+        now: Date = Date()) -> UsageSnapshot?
+    {
+        let primary = self.codexPreferredResetBackfillWindow(
+            snapshots.enumerated().compactMap { index, snapshot in
+                snapshot.primary.map { (window: $0, updatedAt: snapshot.updatedAt, priority: index) }
+            },
+            now: now)
+        let secondary = self.codexPreferredResetBackfillWindow(
+            snapshots.enumerated().compactMap { index, snapshot in
+                snapshot.secondary.map { (window: $0, updatedAt: snapshot.updatedAt, priority: index) }
+            },
+            now: now)
+        guard primary != nil || secondary != nil else { return nil }
+        return UsageSnapshot(
+            primary: primary,
+            secondary: secondary,
+            updatedAt: snapshots.map(\.updatedAt).max() ?? now)
+    }
+
+    private nonisolated static func codexPreferredResetBackfillWindow(
+        _ windows: [(window: RateWindow, updatedAt: Date, priority: Int)],
+        now: Date) -> RateWindow?
+    {
+        windows
+            .filter { ($0.window.resetsAt ?? .distantPast) > now }
+            .max { lhs, rhs in
+                if lhs.updatedAt != rhs.updatedAt {
+                    return lhs.updatedAt < rhs.updatedAt
+                }
+                if lhs.priority != rhs.priority {
+                    return lhs.priority < rhs.priority
+                }
+                let lhsReset = lhs.window.resetsAt ?? .distantPast
+                let rhsReset = rhs.window.resetsAt ?? .distantPast
+                if lhsReset != rhsReset {
+                    return lhsReset < rhsReset
+                }
+                return (lhs.window.windowMinutes ?? 0) < (rhs.window.windowMinutes ?? 0)
+            }
+            .map(\.window)
+    }
+
+    private nonisolated static func codexBackfillingResetWindow(
+        _ window: RateWindow?,
+        from cached: RateWindow?) -> RateWindow?
+    {
+        guard let cached,
+              let resetsAt = cached.resetsAt,
+              resetsAt > Date()
+        else {
+            return window
+        }
+        if let window {
+            return window.backfillingResetTime(from: cached)
+        }
+        guard let windowMinutes = cached.windowMinutes, windowMinutes > 0 else { return nil }
+        return RateWindow(
+            usedPercent: cached.usedPercent,
+            windowMinutes: windowMinutes,
+            resetsAt: resetsAt,
+            resetDescription: cached.resetDescription)
+    }
+
+    func recordFetchedTokenAccountPlanUtilizationHistory(
+        provider: UsageProvider,
+        samples: [(account: ProviderTokenAccount, snapshot: UsageSnapshot)],
+        selectedAccount: ProviderTokenAccount?) async
+    {
+        for sample in samples where sample.account.id != selectedAccount?.id {
+            await self.recordPlanUtilizationHistorySample(
+                provider: provider,
+                snapshot: sample.snapshot,
+                account: sample.account,
+                shouldUpdatePreferredAccountKey: false,
+                shouldAdoptUnscopedHistory: false)
+        }
+    }
+
     private func resolveAccountOutcome(
         _ outcome: ProviderFetchOutcome,
         provider: UsageProvider,
-        account: ProviderTokenAccount) -> ResolvedAccountOutcome
+        account: ProviderTokenAccount,
+        priorSnapshot: TokenAccountUsageSnapshot? = nil) -> ResolvedAccountOutcome
     {
         switch outcome.result {
         case let .success(result):
@@ -129,24 +1080,155 @@ extension UsageStore {
                 sourceLabel: result.sourceLabel)
             return ResolvedAccountOutcome(snapshot: snapshot, usage: labeled)
         case let .failure(error):
+            // Preserve the last-good snapshot when the refresh was cancelled (e.g. the
+            // user switched menu tabs mid-flight). Without this the per-account list
+            // would briefly render error chips for accounts that already had data.
+            if Self.errorIsCancellation(error) {
+                if let priorSnapshot, priorSnapshot.snapshot != nil {
+                    return ResolvedAccountOutcome(snapshot: priorSnapshot, usage: priorSnapshot.snapshot)
+                }
+                // No usable prior data: skip this row entirely. The caller will
+                // either preserve the existing per-account state or fall back to
+                // the single live card. Rendering a "cancelled" placeholder here
+                // produces visually duplicate cards with no useful data.
+                return ResolvedAccountOutcome(snapshot: nil, usage: nil)
+            }
             let snapshot = TokenAccountUsageSnapshot(
                 account: account,
                 snapshot: nil,
-                error: error.localizedDescription,
+                error: self.tokenAccountSnapshotErrorMessage(error),
                 sourceLabel: nil)
             return ResolvedAccountOutcome(snapshot: snapshot, usage: nil)
         }
     }
 
+    private func resolveCodexAccountOutcome(
+        _ outcome: ProviderFetchOutcome,
+        account: CodexVisibleAccount,
+        priorSnapshot: CodexAccountUsageSnapshot? = nil,
+        resetBackfillSnapshots: [UsageSnapshot] = []) -> ResolvedCodexAccountOutcome
+    {
+        switch outcome.result {
+        case let .success(result):
+            let scoped = result.usage.scoped(to: .codex)
+            let labeled = self.applyCodexVisibleAccountLabel(scoped, account: account)
+            let backfilled = Self.codexMergedResetBackfillSnapshot(resetBackfillSnapshots)
+                .map { Self.codexBackfillingResetWindows(labeled, from: $0) } ?? labeled
+            let snapshot = CodexAccountUsageSnapshot(
+                account: account,
+                snapshot: backfilled,
+                error: nil,
+                sourceLabel: result.sourceLabel)
+            return ResolvedCodexAccountOutcome(
+                snapshot: snapshot,
+                usage: backfilled,
+                sourceLabel: result.sourceLabel)
+        case let .failure(error):
+            if Self.errorIsCancellation(error) {
+                if let priorSnapshot, priorSnapshot.snapshot != nil {
+                    return ResolvedCodexAccountOutcome(
+                        snapshot: priorSnapshot,
+                        usage: priorSnapshot.snapshot,
+                        sourceLabel: priorSnapshot.sourceLabel)
+                }
+                return ResolvedCodexAccountOutcome(snapshot: nil, usage: nil, sourceLabel: nil)
+            }
+            let errorMessage = self.tokenAccountSnapshotErrorMessage(error)
+            if Self.shouldPreserveCodexAccountSnapshotOnFailure(errorMessage),
+               let priorSnapshot,
+               let priorUsage = priorSnapshot.snapshot
+            {
+                let snapshot = CodexAccountUsageSnapshot(
+                    account: account,
+                    snapshot: priorUsage,
+                    error: errorMessage,
+                    sourceLabel: priorSnapshot.sourceLabel)
+                return ResolvedCodexAccountOutcome(
+                    snapshot: snapshot,
+                    usage: priorUsage,
+                    sourceLabel: priorSnapshot.sourceLabel)
+            }
+            let snapshot = CodexAccountUsageSnapshot(
+                account: account,
+                snapshot: nil,
+                error: errorMessage,
+                sourceLabel: nil)
+            return ResolvedCodexAccountOutcome(snapshot: snapshot, usage: nil, sourceLabel: nil)
+        }
+    }
+
+    private static func shouldPreserveCodexAccountSnapshotOnFailure(_ message: String) -> Bool {
+        guard CodexAccountHealth.status(forError: message) == .unavailable else { return false }
+        let normalized = message.lowercased()
+        return normalized.contains("network") ||
+            normalized.contains("internet connection") ||
+            normalized.contains("offline") ||
+            normalized.contains("timed out") ||
+            normalized.contains("timeout") ||
+            normalized.contains("connection was lost") ||
+            normalized.contains("could not connect") ||
+            normalized.contains("not connected") ||
+            normalized.contains("hostname") ||
+            normalized.contains("dns") ||
+            normalized.contains("temporarily unavailable")
+    }
+
+    func applySelectedCodexVisibleAccountOutcome(
+        _ outcome: ProviderFetchOutcome,
+        account: CodexVisibleAccount,
+        snapshot: UsageSnapshot?,
+        sourceLabel: String?,
+        generation: UInt64? = nil) async
+    {
+        guard self.isCurrentProviderRefreshGeneration(.codex, generation: generation) else { return }
+        self.lastFetchAttempts[.codex] = outcome.attempts
+        switch outcome.result {
+        case .success:
+            guard let snapshot else { return }
+            self.handleSessionQuotaTransition(provider: .codex, snapshot: snapshot)
+            self.lastKnownResetSnapshots[.codex] = snapshot
+            self.lastCodexAccountScopedRefreshGuard = Self.codexScopedRefreshGuard(for: account)
+            self.snapshots[.codex] = snapshot
+            if let sourceLabel {
+                self.lastSourceLabels[.codex] = sourceLabel
+            }
+            self.errors[.codex] = nil
+            self.failureGates[.codex]?.recordSuccess()
+            self.rememberLiveSystemCodexEmailIfNeeded(snapshot.accountEmail(for: .codex))
+            self.seedCodexAccountScopedRefreshGuard(accountEmail: account.email)
+            await self.recordPlanUtilizationHistorySample(provider: .codex, snapshot: snapshot)
+            guard self.isCurrentProviderRefreshGeneration(.codex, generation: generation) else { return }
+            self.recordCodexHistoricalSampleIfNeeded(snapshot: snapshot)
+        case let .failure(error):
+            guard let message = self.tokenAccountErrorMessage(error) else {
+                self.errors[.codex] = nil
+                return
+            }
+            let hadPriorData = self.snapshots[.codex] != nil
+            let shouldSurface =
+                self.failureGates[.codex]?
+                    .shouldSurfaceError(onFailureWithPriorData: hadPriorData) ?? true
+            if shouldSurface {
+                self.errors[.codex] = message
+                self.snapshots.removeValue(forKey: .codex)
+            } else {
+                self.errors[.codex] = nil
+            }
+        }
+    }
+
     func applySelectedOutcome(
         _ outcome: ProviderFetchOutcome,
         provider: UsageProvider,
         account: ProviderTokenAccount?,
-        fallbackSnapshot: UsageSnapshot?) async
+        fallbackSnapshot: UsageSnapshot?,
+        generation: UInt64? = nil) async
     {
         await MainActor.run {
+            guard self.isCurrentProviderRefreshGeneration(provider, generation: generation) else { return }
             self.lastFetchAttempts[provider] = outcome.attempts
         }
+        guard self.isCurrentProviderRefreshGeneration(provider, generation: generation) else { return }
         switch outcome.result {
         case let .success(result):
             let scoped = result.usage.scoped(to: provider)
@@ -155,20 +1237,36 @@ extension UsageStore {
             } else {
                 scoped
             }
-            await MainActor.run {
-                self.handleSessionQuotaTransition(provider: provider, snapshot: labeled)
-                self.snapshots[provider] = labeled
+            let backfilled = await MainActor.run {
+                guard self.isCurrentProviderRefreshGeneration(provider, generation: generation) else {
+                    return nil as UsageSnapshot?
+                }
+                let backfilled = labeled.backfillingResetTimes(from: self.lastKnownResetSnapshots[provider])
+                self.handleQuotaWarningTransitions(provider: provider, snapshot: backfilled)
+                self.handleSessionQuotaTransition(provider: provider, snapshot: backfilled)
+                self.lastKnownResetSnapshots[provider] = backfilled
+                self.snapshots[provider] = backfilled
                 self.lastSourceLabels[provider] = result.sourceLabel
                 self.errors[provider] = nil
                 self.failureGates[provider]?.recordSuccess()
+                return backfilled
             }
+            guard let backfilled else { return }
+            await self.recordPlanUtilizationHistorySample(
+                provider: provider,
+                snapshot: backfilled,
+                account: account)
         case let .failure(error):
             await MainActor.run {
+                guard let message = self.tokenAccountErrorMessage(error) else {
+                    self.errors[provider] = nil
+                    return
+                }
                 let hadPriorData = self.snapshots[provider] != nil || fallbackSnapshot != nil
                 let shouldSurface = self.failureGates[provider]?
                     .shouldSurfaceError(onFailureWithPriorData: hadPriorData) ?? true
                 if shouldSurface {
-                    self.errors[provider] = error.localizedDescription
+                    self.errors[provider] = message
                     self.snapshots.removeValue(forKey: provider)
                 } else {
                     self.errors[provider] = nil
@@ -194,4 +1292,17 @@ extension UsageStore {
             loginMethod: existing?.loginMethod)
         return snapshot.withIdentity(identity)
     }
+
+    func applyCodexVisibleAccountLabel(_ snapshot: UsageSnapshot, account: CodexVisibleAccount) -> UsageSnapshot {
+        let existing = snapshot.identity(for: .codex)
+        let email = existing?.accountEmail?.trimmingCharacters(in: .whitespacesAndNewlines)
+        let resolvedEmail = (email?.isEmpty ?? true) ? account.email : email
+        let loginMethod = existing?.loginMethod ?? account.workspaceLabel
+        let identity = ProviderIdentitySnapshot(
+            providerID: .codex,
+            accountEmail: resolvedEmail,
+            accountOrganization: existing?.accountOrganization,
+            loginMethod: loginMethod)
+        return snapshot.withIdentity(identity)
+    }
 }
diff --git a/Sources/CodexBar/UsageStore+TokenCost.swift b/Sources/CodexBar/UsageStore+TokenCost.swift
index f00f14504d..44d2e4e646 100644
--- a/Sources/CodexBar/UsageStore+TokenCost.swift
+++ b/Sources/CodexBar/UsageStore+TokenCost.swift
@@ -14,10 +14,76 @@ extension UsageStore {
         self.lastTokenFetchAt[provider]
     }
 
+    func hydrateCachedTokenSnapshots(now: Date = Date()) {
+        guard self.settings.costUsageEnabled else { return }
+        guard self.settings.enabledProvidersOrdered(metadataByProvider: self.providerMetadata).contains(.codex) else {
+            return
+        }
+
+        let scope = self.tokenCostScope(for: .codex)
+        let historyDays = self.settings.costUsageHistoryDays
+        Task { @MainActor [weak self] in
+            guard let self else { return }
+            guard self.tokenSnapshots[.codex] == nil else { return }
+            guard let snapshot = await self.costUsageFetcher.loadCachedCodexTokenSnapshot(
+                now: now,
+                codexHomePath: scope.codexHomePath,
+                historyDays: historyDays)
+            else {
+                return
+            }
+            guard self.settings.costUsageEnabled,
+                  self.isEnabled(.codex),
+                  self.tokenCostScope(for: .codex).signature == scope.signature,
+                  self.tokenSnapshots[.codex] == nil
+            else {
+                return
+            }
+            self.tokenSnapshots[.codex] = snapshot
+            self.tokenErrors[.codex] = nil
+        }
+    }
+
     func isTokenRefreshInFlight(for provider: UsageProvider) -> Bool {
         self.tokenRefreshInFlight.contains(provider)
     }
 
+    func tokenCostScope(for provider: UsageProvider) -> (codexHomePath: String?, signature: String) {
+        guard provider == .codex else {
+            return (nil, provider.rawValue)
+        }
+        let homePath = self.settings.activeManagedCodexRemoteHomePath?
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+        guard let homePath, !homePath.isEmpty else {
+            return (nil, "codex:ambient")
+        }
+        return (homePath, "codex:managed:\(homePath)")
+    }
+
+    func tokenSnapshot(
+        fromProviderSnapshot snapshot: UsageSnapshot?,
+        provider: UsageProvider)
+        -> CostUsageTokenSnapshot?
+    {
+        switch provider {
+        case .openai:
+            snapshot?.openAIAPIUsage?.toCostUsageTokenSnapshot()
+        case .mistral:
+            snapshot?.mistralUsage?.toCostUsageTokenSnapshot(historyDays: self.settings.costUsageHistoryDays)
+        default:
+            nil
+        }
+    }
+
+    nonisolated static func tokenCostRequiresProviderSnapshot(_ provider: UsageProvider) -> Bool {
+        switch provider {
+        case .mistral, .openai:
+            true
+        default:
+            false
+        }
+    }
+
     nonisolated static func costUsageCacheDirectory(
         fileManager: FileManager = .default) -> URL
     {
@@ -27,6 +93,35 @@ extension UsageStore {
             .appendingPathComponent("cost-usage", isDirectory: true)
     }
 
+    func clearCostUsageCache() async -> String? {
+        let errorMessage: String? = await Task.detached(priority: .utility) {
+            let fm = FileManager.default
+            let cacheDirs = [
+                Self.costUsageCacheDirectory(fileManager: fm),
+            ]
+
+            for cacheDir in cacheDirs {
+                do {
+                    try fm.removeItem(at: cacheDir)
+                } catch let error as NSError {
+                    if error.domain == NSCocoaErrorDomain, error.code == NSFileNoSuchFileError { continue }
+                    return error.localizedDescription
+                }
+            }
+            return nil
+        }.value
+
+        guard errorMessage == nil else { return errorMessage }
+
+        self.tokenSnapshots.removeAll()
+        self.tokenErrors.removeAll()
+        self.lastTokenFetchAt.removeAll()
+        self.lastTokenFetchScope.removeAll()
+        self.tokenFailureGates[.codex]?.reset()
+        self.tokenFailureGates[.claude]?.reset()
+        return nil
+    }
+
     nonisolated static func tokenCostNoDataMessage(for provider: UsageProvider) -> String {
         ProviderDescriptorRegistry.descriptor(for: provider).tokenCost.noDataMessage()
     }
diff --git a/Sources/CodexBar/UsageStore+WidgetSnapshot.swift b/Sources/CodexBar/UsageStore+WidgetSnapshot.swift
index f8699128db..7e943bddb1 100644
--- a/Sources/CodexBar/UsageStore+WidgetSnapshot.swift
+++ b/Sources/CodexBar/UsageStore+WidgetSnapshot.swift
@@ -7,12 +7,20 @@ import WidgetKit
 extension UsageStore {
     func persistWidgetSnapshot(reason: String) {
         let snapshot = self.makeWidgetSnapshot()
-        Task.detached(priority: .utility) {
-            WidgetSnapshotStore.save(snapshot)
-            #if canImport(WidgetKit)
-            await MainActor.run {
-                WidgetCenter.shared.reloadAllTimelines()
+        let previousTask = self.widgetSnapshotPersistTask
+        self.widgetSnapshotPersistTask = Task { @MainActor in
+            _ = await previousTask?.result
+
+            if let override = self._test_widgetSnapshotSaveOverride {
+                await override(snapshot)
+                return
             }
+
+            await Task.detached(priority: .utility) {
+                WidgetSnapshotStore.save(snapshot)
+            }.value
+            #if canImport(WidgetKit)
+            WidgetCenter.shared.reloadAllTimelines()
             #endif
         }
     }
@@ -28,7 +36,8 @@ extension UsageStore {
     private func makeWidgetEntry(for provider: UsageProvider) -> WidgetSnapshot.ProviderEntry? {
         guard let snapshot = self.snapshots[provider] else { return nil }
 
-        let tokenSnapshot = self.tokenSnapshots[provider]
+        let tokenSnapshot = self.tokenSnapshot(fromProviderSnapshot: snapshot, provider: provider) ?? self
+            .tokenSnapshots[provider]
         let dailyUsage = tokenSnapshot?.daily.map { entry in
             WidgetSnapshot.DailyUsagePoint(
                 dayKey: entry.date,
@@ -36,9 +45,23 @@ extension UsageStore {
                 costUSD: entry.costUSD)
         } ?? []
 
-        let tokenUsage = Self.widgetTokenUsageSummary(from: tokenSnapshot)
-        let creditsRemaining = provider == .codex ? self.credits?.remaining : nil
-        let codeReviewRemaining = provider == .codex ? self.openAIDashboard?.codeReviewRemainingPercent : nil
+        let tokenUsage = Self.widgetTokenUsageSummary(from: tokenSnapshot, provider: provider)
+        let usageRows = self.widgetUsageRows(provider: provider, snapshot: snapshot)
+
+        let creditsRemaining: Double?
+        let codeReviewRemaining: Double?
+        if provider == .codex {
+            let projection = self.codexConsumerProjection(
+                surface: .widget,
+                snapshotOverride: snapshot,
+                now: snapshot.updatedAt)
+            let displayOnlyExtrasHidden = projection.dashboardVisibility == .displayOnly
+            creditsRemaining = displayOnlyExtrasHidden ? nil : projection.credits?.remaining
+            codeReviewRemaining = displayOnlyExtrasHidden ? nil : projection.remainingPercent(for: .codeReview)
+        } else {
+            creditsRemaining = nil
+            codeReviewRemaining = nil
+        }
 
         return WidgetSnapshot.ProviderEntry(
             provider: provider,
@@ -46,6 +69,7 @@ extension UsageStore {
             primary: snapshot.primary,
             secondary: snapshot.secondary,
             tertiary: snapshot.tertiary,
+            usageRows: usageRows,
             creditsRemaining: creditsRemaining,
             codeReviewRemainingPercent: codeReviewRemaining,
             tokenUsage: tokenUsage,
@@ -53,15 +77,121 @@ extension UsageStore {
     }
 
     private nonisolated static func widgetTokenUsageSummary(
-        from snapshot: CostUsageTokenSnapshot?) -> WidgetSnapshot.TokenUsageSummary?
+        from snapshot: CostUsageTokenSnapshot?,
+        provider: UsageProvider) -> WidgetSnapshot.TokenUsageSummary?
     {
         guard let snapshot else { return nil }
         let fallbackTokens = snapshot.daily.compactMap(\.totalTokens).reduce(0, +)
         let monthTokensValue = snapshot.last30DaysTokens ?? (fallbackTokens > 0 ? fallbackTokens : nil)
+        let sessionLabel = provider == .bedrock || provider == .mistral ? "Latest billing day" : "Today"
+        let monthLabel = snapshot.historyLabel ?? (snapshot.historyDays == 1 ? "Today" : "\(snapshot.historyDays)d")
         return WidgetSnapshot.TokenUsageSummary(
             sessionCostUSD: snapshot.sessionCostUSD,
             sessionTokens: snapshot.sessionTokens,
             last30DaysCostUSD: snapshot.last30DaysCostUSD,
-            last30DaysTokens: monthTokensValue)
+            last30DaysTokens: monthTokensValue,
+            currencyCode: snapshot.currencyCode,
+            sessionLabel: sessionLabel,
+            last30DaysLabel: monthLabel)
+    }
+
+    private func widgetUsageRows(
+        provider: UsageProvider,
+        snapshot: UsageSnapshot) -> [WidgetSnapshot.WidgetUsageRowSnapshot]
+    {
+        let metadata = ProviderDefaults.metadata[provider]
+        if provider == .codex {
+            let projection = self.codexConsumerProjection(
+                surface: .widget,
+                snapshotOverride: snapshot,
+                now: snapshot.updatedAt)
+            return projection.visibleRateLanes.compactMap { lane in
+                guard let window = projection.rateWindow(for: lane) else { return nil }
+                let title = switch lane {
+                case .session:
+                    metadata?.sessionLabel ?? "Session"
+                case .weekly:
+                    metadata?.weeklyLabel ?? "Weekly"
+                }
+                return WidgetSnapshot.WidgetUsageRowSnapshot(
+                    id: lane.rawValue,
+                    title: title,
+                    percentLeft: window.remainingPercent)
+            }
+        }
+        if provider == .antigravity,
+           let rows = Self.antigravityQuotaSummaryWidgetRows(snapshot: snapshot),
+           !rows.isEmpty
+        {
+            return rows
+        }
+        if provider == .antigravity,
+           snapshot.primary == nil,
+           snapshot.secondary == nil,
+           let rows = Self.antigravityLegacyExtraWidgetRows(snapshot: snapshot),
+           !rows.isEmpty
+        {
+            return rows
+        }
+
+        let primaryTitle: String = {
+            if provider == .grok,
+               let dyn = GrokProviderDescriptor.primaryLabel(window: snapshot.primary)
+            {
+                return dyn
+            }
+            return metadata?.sessionLabel ?? "Session"
+        }()
+
+        var rows: [WidgetSnapshot.WidgetUsageRowSnapshot] = [
+            WidgetSnapshot.WidgetUsageRowSnapshot(
+                id: "primary",
+                title: primaryTitle,
+                percentLeft: snapshot.primary?.remainingPercent),
+            WidgetSnapshot.WidgetUsageRowSnapshot(
+                id: "secondary",
+                title: metadata?.weeklyLabel ?? "Weekly",
+                percentLeft: snapshot.secondary?.remainingPercent),
+        ]
+        if metadata?.supportsOpus == true {
+            rows.append(WidgetSnapshot.WidgetUsageRowSnapshot(
+                id: "tertiary",
+                title: metadata?.opusLabel ?? "Opus",
+                percentLeft: snapshot.tertiary?.remainingPercent))
+        }
+        return rows.filter { $0.percentLeft != nil }
+    }
+
+    private nonisolated static let antigravityQuotaSummaryWindowIDPrefix = "antigravity-quota-summary-"
+    private nonisolated static let antigravityCompactFallbackWindowIDPrefix = "antigravity-compact-fallback-"
+
+    private nonisolated static func antigravityQuotaSummaryWidgetRows(
+        snapshot: UsageSnapshot) -> [WidgetSnapshot.WidgetUsageRowSnapshot]?
+    {
+        guard let windows = snapshot.extraRateWindows?.filter({
+            $0.id.hasPrefix(Self.antigravityQuotaSummaryWindowIDPrefix)
+        }), !windows.isEmpty else {
+            return nil
+        }
+        return windows.map { namedWindow in
+            WidgetSnapshot.WidgetUsageRowSnapshot(
+                id: namedWindow.id,
+                title: namedWindow.title,
+                percentLeft: namedWindow.usageKnown ? namedWindow.window.remainingPercent : nil)
+        }
+    }
+
+    private nonisolated static func antigravityLegacyExtraWidgetRows(
+        snapshot: UsageSnapshot) -> [WidgetSnapshot.WidgetUsageRowSnapshot]?
+    {
+        let windows = snapshot.extraRateWindows?
+            .filter { $0.id.hasPrefix(Self.antigravityCompactFallbackWindowIDPrefix) && $0.usageKnown }
+        guard let windows, !windows.isEmpty else { return nil }
+        return windows.map { namedWindow in
+            WidgetSnapshot.WidgetUsageRowSnapshot(
+                id: namedWindow.id,
+                title: namedWindow.title,
+                percentLeft: namedWindow.window.remainingPercent)
+        }
     }
 }
diff --git a/Sources/CodexBar/UsageStore.swift b/Sources/CodexBar/UsageStore.swift
index e3f0bcae4f..6c41431886 100644
--- a/Sources/CodexBar/UsageStore.swift
+++ b/Sources/CodexBar/UsageStore.swift
@@ -14,6 +14,8 @@ extension UsageStore {
         _ = self.lastSourceLabels
         _ = self.lastFetchAttempts
         _ = self.accountSnapshots
+        _ = self.codexAccountSnapshots
+        _ = self.kiloScopeSnapshots
         _ = self.tokenSnapshots
         _ = self.tokenErrors
         _ = self.tokenRefreshInFlight
@@ -22,8 +24,7 @@ extension UsageStore {
         _ = self.openAIDashboard
         _ = self.lastOpenAIDashboardError
         _ = self.openAIDashboardRequiresLogin
-        _ = self.openAIDashboardCookieImportStatus
-        _ = self.openAIDashboardCookieImportDebugLog
+        _ = self.openAIDashboardAttachmentRevision
         _ = self.versions
         _ = self.isRefreshing
         _ = self.refreshingProviders
@@ -31,74 +32,112 @@ extension UsageStore {
         _ = self.statuses
         _ = self.probeLogs
         _ = self.historicalPaceRevision
+        _ = self.planUtilizationHistoryRevision
+        _ = self.providerStorageFootprints
+        return 0
+    }
+
+    var iconObservationToken: Int {
+        _ = self.snapshots
+        _ = self.errors
+        _ = self.credits
+        _ = self.lastCreditsError
+        _ = self.openAIDashboard
+        _ = self.lastOpenAIDashboardError
+        _ = self.openAIDashboardRequiresLogin
+        _ = self.refreshingProviders
+        _ = self.statuses
+        _ = self.historicalPaceRevision
         return 0
     }
 
     func observeSettingsChanges() {
         withObservationTracking {
-            _ = self.settings.refreshFrequency
-            _ = self.settings.statusChecksEnabled
-            _ = self.settings.sessionQuotaNotificationsEnabled
-            _ = self.settings.usageBarsShowUsed
-            _ = self.settings.costUsageEnabled
-            _ = self.settings.randomBlinkEnabled
-            _ = self.settings.configRevision
-            for implementation in ProviderCatalog.all {
-                implementation.observeSettings(self.settings)
-            }
-            _ = self.settings.showAllTokenAccountsInMenu
-            _ = self.settings.tokenAccountsByProvider
-            _ = self.settings.mergeIcons
-            _ = self.settings.selectedMenuProvider
-            _ = self.settings.debugLoadingPattern
-            _ = self.settings.debugKeepCLISessionsAlive
-            _ = self.settings.historicalTrackingEnabled
+            _ = self.backgroundWorkSettingsObservationToken
         } onChange: { [weak self] in
             Task { @MainActor [weak self] in
                 guard let self else { return }
                 self.observeSettingsChanges()
+                self.invalidateProviderAvailabilityCache()
+                self.probeLogs = [:]
                 guard self.startupBehavior.automaticallyStartsBackgroundWork else { return }
                 self.startTimer()
                 self.updateProviderRuntimes()
                 await self.refreshHistoricalDatasetIfNeeded()
-                await self.refresh()
+                await self.refreshForSettingsChange()
             }
         }
     }
+
+    var backgroundWorkSettingsObservationToken: Int {
+        _ = self.settings.refreshFrequency
+        _ = self.settings.statusChecksEnabled
+        _ = self.settings.sessionQuotaNotificationsEnabled
+        _ = self.settings.quotaWarningNotificationsEnabled
+        _ = self.settings.quotaWarningThresholds
+        _ = self.settings.quotaWarningThresholds(.session)
+        _ = self.settings.quotaWarningThresholds(.weekly)
+        _ = self.settings.quotaWarningSoundEnabled
+        _ = self.settings.usageBarsShowUsed
+        _ = self.settings.costUsageEnabled
+        _ = self.settings.costUsageHistoryDays
+        _ = self.settings.randomBlinkEnabled
+        _ = self.settings.configRevision
+        for implementation in ProviderCatalog.all {
+            implementation.observeSettings(self.settings)
+        }
+        _ = self.settings.multiAccountMenuLayout
+        _ = self.settings.tokenAccountsByProvider
+        _ = self.settings.mergeIcons
+        _ = self.settings.debugLoadingPattern
+        _ = self.settings.debugKeepCLISessionsAlive
+        _ = self.settings.historicalTrackingEnabled
+        _ = self.settings.providerStorageFootprintsEnabled
+        return 0
+    }
+
+    var attachedOpenAIDashboardSnapshot: OpenAIDashboardSnapshot? {
+        guard self.openAIDashboardAttachmentAuthorized else { return nil }
+        return self.openAIDashboard
+    }
 }
 
 @MainActor
 @Observable
 final class UsageStore {
-    enum StartupBehavior: Sendable {
-        case automatic
-        case full
-        case testing
-
-        var automaticallyStartsBackgroundWork: Bool {
-            switch self {
-            case .automatic, .full:
-                true
-            case .testing:
-                false
-            }
+    private struct ProviderAvailabilityCacheEntry {
+        let available: Bool
+        let configRevision: Int
+        let expiresAt: Date
+
+        func isValid(now: Date, configRevision: Int) -> Bool {
+            self.configRevision == configRevision && self.expiresAt > now
         }
+    }
 
-        func resolved(isRunningTests: Bool) -> StartupBehavior {
-            switch self {
-            case .automatic:
-                isRunningTests ? .testing : .full
-            case .full, .testing:
-                self
-            }
+    struct AccountInfoCacheEntry {
+        let account: AccountInfo
+        let configRevision: Int
+        let expiresAt: Date
+
+        func isValid(now: Date, configRevision: Int) -> Bool {
+            self.configRevision == configRevision && self.expiresAt > now
         }
     }
 
+    enum CodexCreditsSource {
+        case none
+        case api
+        case dashboardWeb
+    }
+
     var snapshots: [UsageProvider: UsageSnapshot] = [:]
     var errors: [UsageProvider: String] = [:]
     var lastSourceLabels: [UsageProvider: String] = [:]
     var lastFetchAttempts: [UsageProvider: [ProviderFetchAttempt]] = [:]
     var accountSnapshots: [UsageProvider: [TokenAccountUsageSnapshot]] = [:]
+    var codexAccountSnapshots: [CodexAccountUsageSnapshot] = []
+    var kiloScopeSnapshots: [KiloScopeSnapshot] = []
     var tokenSnapshots: [UsageProvider: CostUsageTokenSnapshot] = [:]
     var tokenErrors: [UsageProvider: String] = [:]
     var tokenRefreshInFlight: Set<UsageProvider> = []
@@ -117,46 +156,120 @@ final class UsageStore {
     var statuses: [UsageProvider: ProviderStatus] = [:]
     var probeLogs: [UsageProvider: String] = [:]
     var historicalPaceRevision: Int = 0
-    @ObservationIgnored private var lastCreditsSnapshot: CreditsSnapshot?
-    @ObservationIgnored private var creditsFailureStreak: Int = 0
-    @ObservationIgnored private var lastOpenAIDashboardSnapshot: OpenAIDashboardSnapshot?
-    @ObservationIgnored private var lastOpenAIDashboardTargetEmail: String?
-    @ObservationIgnored private var lastOpenAIDashboardCookieImportAttemptAt: Date?
-    @ObservationIgnored private var lastOpenAIDashboardCookieImportEmail: String?
-    @ObservationIgnored private var openAIWebAccountDidChange: Bool = false
+    var planUtilizationHistoryRevision: Int = 0
+    var providerStorageFootprints: [UsageProvider: ProviderStorageFootprint] = [:]
+    @ObservationIgnored var lastCreditsSnapshot: CreditsSnapshot?
+    @ObservationIgnored var lastCreditsSnapshotAccountKey: String?
+    @ObservationIgnored var lastCreditsSource: CodexCreditsSource = .none
+    @ObservationIgnored var creditsFailureStreak: Int = 0
+    @ObservationIgnored var openAIDashboardAttachmentAuthorized: Bool = false {
+        didSet {
+            guard self.openAIDashboardAttachmentAuthorized != oldValue else { return }
+            self.openAIDashboardAttachmentRevision &+= 1
+        }
+    }
+
+    var openAIDashboardAttachmentRevision = 0
+    @ObservationIgnored var lastOpenAIDashboardSnapshot: OpenAIDashboardSnapshot?
+    @ObservationIgnored var lastOpenAIDashboardAttachmentAuthorized: Bool = false
+    @ObservationIgnored var lastOpenAIDashboardTargetEmail: String?
+    @ObservationIgnored var lastOpenAIDashboardTargetIsolationKey: String?
+    @ObservationIgnored var lastOpenAIDashboardAttemptAt: Date?
+    @ObservationIgnored var lastOpenAIDashboardCookieImportAttemptAt: Date?
+    @ObservationIgnored var lastOpenAIDashboardCookieImportEmail: String?
+    @ObservationIgnored var lastCodexAccountScopedRefreshGuard: CodexAccountScopedRefreshGuard?
+    @ObservationIgnored var lastKnownLiveSystemCodexEmail: String?
+    @ObservationIgnored var openAIWebAccountDidChange: Bool = false
+    @ObservationIgnored var creditsRefreshTask: Task<Void, Never>?
+    @ObservationIgnored var creditsRefreshTaskKey: String?
+    @ObservationIgnored var openAIDashboardBackgroundRefreshTask: Task<Void, Never>?
+    @ObservationIgnored var openAIDashboardBackgroundRefreshTaskKey: String?
+    @ObservationIgnored var openAIDashboardRefreshTask: Task<Void, Never>?
+    @ObservationIgnored var openAIDashboardRefreshTaskKey: String?
+    @ObservationIgnored var openAIDashboardRefreshTaskToken: UUID?
+    @ObservationIgnored var _test_openAIDashboardCookieImportOverride: (@MainActor (
+        String?,
+        Bool,
+        ProviderCookieSource,
+        CookieHeaderCache.Scope?,
+        @escaping (String) -> Void) async throws -> OpenAIDashboardBrowserCookieImporter.ImportResult)?
+    @ObservationIgnored var _test_openAIDashboardLoaderOverride: (@MainActor (
+        String?,
+        @escaping (String) -> Void,
+        Bool,
+        TimeInterval) async throws -> OpenAIDashboardSnapshot)?
+    @ObservationIgnored var _test_codexCreditsLoaderOverride: (@MainActor () async throws -> CreditsSnapshot)?
+    @ObservationIgnored var _test_widgetSnapshotSaveOverride: (@MainActor (WidgetSnapshot) async -> Void)?
+    @ObservationIgnored var _test_providerRefreshOverride: (@MainActor (UsageProvider) async -> Void)?
+    @ObservationIgnored var _test_tokenUsageRefreshOverride: (@MainActor (UsageProvider, Bool) async -> Void)?
+    @ObservationIgnored var _test_providerStatusFetchOverride: (@MainActor (
+        UsageProvider) async throws -> ProviderStatus)?
+    @ObservationIgnored var _test_startupConnectivityRetryScheduled: (@MainActor (Int, TimeInterval) -> Void)?
+    @ObservationIgnored var _test_startupConnectivityRetrySleepOverride: (@MainActor (
+        TimeInterval) async throws -> Void)?
+    @ObservationIgnored var widgetSnapshotPersistTask: Task<Void, Never>?
 
     @ObservationIgnored let codexFetcher: UsageFetcher
     @ObservationIgnored let claudeFetcher: any ClaudeUsageFetching
-    @ObservationIgnored private let costUsageFetcher: CostUsageFetcher
+    @ObservationIgnored let costUsageFetcher: CostUsageFetcher
     @ObservationIgnored let browserDetection: BrowserDetection
     @ObservationIgnored private let registry: ProviderRegistry
     @ObservationIgnored let settings: SettingsStore
+    @ObservationIgnored let environmentBase: [String: String]
     @ObservationIgnored private let sessionQuotaNotifier: any SessionQuotaNotifying
     @ObservationIgnored private let sessionQuotaLogger = CodexBarLog.logger(LogCategories.sessionQuota)
-    @ObservationIgnored private let openAIWebLogger = CodexBarLog.logger(LogCategories.openAIWeb)
+    @ObservationIgnored let openAIWebLogger = CodexBarLog.logger(LogCategories.openAIWeb)
     @ObservationIgnored private let tokenCostLogger = CodexBarLog.logger(LogCategories.tokenCost)
     @ObservationIgnored let augmentLogger = CodexBarLog.logger(LogCategories.augment)
     @ObservationIgnored let providerLogger = CodexBarLog.logger(LogCategories.providers)
-    @ObservationIgnored private var openAIWebDebugLines: [String] = []
+    @ObservationIgnored var openAIWebDebugLines: [String] = []
     @ObservationIgnored var failureGates: [UsageProvider: ConsecutiveFailureGate] = [:]
     @ObservationIgnored var tokenFailureGates: [UsageProvider: ConsecutiveFailureGate] = [:]
     @ObservationIgnored var providerSpecs: [UsageProvider: ProviderSpec] = [:]
     @ObservationIgnored let providerMetadata: [UsageProvider: ProviderMetadata]
     @ObservationIgnored var providerRuntimes: [UsageProvider: any ProviderRuntime] = [:]
+    @ObservationIgnored var providerRefreshCoordinator = ProviderRefreshCoordinator<UsageProvider>()
+    @ObservationIgnored private var providerAvailabilityCache: [UsageProvider: ProviderAvailabilityCacheEntry] = [:]
+    @ObservationIgnored var accountInfoCache: [UsageProvider: AccountInfoCacheEntry] = [:]
     @ObservationIgnored private var timerTask: Task<Void, Never>?
     @ObservationIgnored private var tokenTimerTask: Task<Void, Never>?
     @ObservationIgnored private var tokenRefreshSequenceTask: Task<Void, Never>?
+    @ObservationIgnored private var tokenRefreshSequenceProvider: UsageProvider?
+    @ObservationIgnored var memoryPressureReliefTask: Task<Void, Never>?
+    @ObservationIgnored var startupConnectivityRetryTask: Task<Void, Never>?
+    @ObservationIgnored var startupConnectivityRetryNeeded = false
+    @ObservationIgnored var startupConnectivityRetryRefreshActive = false
+    @ObservationIgnored var storageRefreshTask: Task<Void, Never>?
+    @ObservationIgnored var storageRefreshGeneration: UInt64 = 0
+    @ObservationIgnored var storageRefreshInFlightSignature: String?
+    @ObservationIgnored var storageRefreshInFlightRequestKey: String?
+    @ObservationIgnored var lastStorageRefreshSignature: String?
+    @ObservationIgnored var lastStorageRefreshRequestKey: String?
+    @ObservationIgnored var lastStorageRefreshAt: Date?
+    @ObservationIgnored var managedCodexAccountsForStorageOverride: [ManagedCodexAccount]?
     @ObservationIgnored private var pathDebugRefreshTask: Task<Void, Never>?
+    @ObservationIgnored var codexPlanHistoryBackfillTask: Task<Void, Never>?
     @ObservationIgnored let historicalUsageHistoryStore: HistoricalUsageHistoryStore
+    @ObservationIgnored let planUtilizationHistoryStore: PlanUtilizationHistoryStore
+    @ObservationIgnored let codexAccountUsageSnapshotStore: (any CodexAccountUsageSnapshotStoring)?
     @ObservationIgnored var codexHistoricalDataset: CodexHistoricalDataset?
     @ObservationIgnored var codexHistoricalDatasetAccountKey: String?
+    @ObservationIgnored var lastKnownResetSnapshots: [UsageProvider: UsageSnapshot] = [:]
     @ObservationIgnored var lastKnownSessionRemaining: [UsageProvider: Double] = [:]
     @ObservationIgnored var lastKnownSessionWindowSource: [UsageProvider: SessionQuotaWindowSource] = [:]
+    @ObservationIgnored var quotaWarningState: [QuotaWarningStateKey: QuotaWarningState] = [:]
+    @ObservationIgnored var lastPermissionPromptNotificationAt: [UsageProvider: Date] = [:]
     @ObservationIgnored var lastTokenFetchAt: [UsageProvider: Date] = [:]
+    @ObservationIgnored var lastTokenFetchScope: [UsageProvider: String] = [:]
+    @ObservationIgnored var planUtilizationHistory: [UsageProvider: PlanUtilizationHistoryBuckets] = [:]
+    @ObservationIgnored var weeklyLimitResetDetectorStates: [String: WeeklyLimitResetDetectorState] = [:]
     @ObservationIgnored private var hasCompletedInitialRefresh: Bool = false
+    @ObservationIgnored private let providerAvailabilityCacheTTL: TimeInterval = 1
+    @ObservationIgnored let accountInfoCacheTTL: TimeInterval = 30
     @ObservationIgnored private let tokenFetchTTL: TimeInterval = 60 * 60
     @ObservationIgnored private let tokenFetchTimeout: TimeInterval = 10 * 60
-    @ObservationIgnored private let startupBehavior: StartupBehavior
+    @ObservationIgnored let startupBehavior: StartupBehavior
+    @ObservationIgnored let planUtilizationPersistenceCoordinator: PlanUtilizationHistoryPersistenceCoordinator
 
     init(
         fetcher: UsageFetcher,
@@ -166,8 +279,11 @@ final class UsageStore {
         settings: SettingsStore,
         registry: ProviderRegistry = .shared,
         historicalUsageHistoryStore: HistoricalUsageHistoryStore = HistoricalUsageHistoryStore(),
+        planUtilizationHistoryStore: PlanUtilizationHistoryStore = .defaultAppSupport(),
+        codexAccountUsageSnapshotStore: (any CodexAccountUsageSnapshotStoring)? = nil,
         sessionQuotaNotifier: any SessionQuotaNotifying = SessionQuotaNotifier(),
-        startupBehavior: StartupBehavior = .automatic)
+        startupBehavior: StartupBehavior = .automatic,
+        environmentBase: [String: String] = ProcessInfo.processInfo.environment)
     {
         self.codexFetcher = fetcher
         self.browserDetection = browserDetection
@@ -175,9 +291,15 @@ final class UsageStore {
         self.costUsageFetcher = costUsageFetcher
         self.settings = settings
         self.registry = registry
+        self.environmentBase = environmentBase
         self.historicalUsageHistoryStore = historicalUsageHistoryStore
+        self.planUtilizationHistoryStore = planUtilizationHistoryStore
         self.sessionQuotaNotifier = sessionQuotaNotifier
         self.startupBehavior = startupBehavior.resolved(isRunningTests: Self.isRunningTestsProcess())
+        self.codexAccountUsageSnapshotStore = codexAccountUsageSnapshotStore ??
+            (self.startupBehavior.automaticallyStartsBackgroundWork ? FileCodexAccountUsageSnapshotStore() : nil)
+        self.planUtilizationPersistenceCoordinator = PlanUtilizationHistoryPersistenceCoordinator(
+            store: planUtilizationHistoryStore)
         self.providerMetadata = registry.metadata
         self
             .failureGates = Dictionary(
@@ -191,10 +313,17 @@ final class UsageStore {
             metadata: self.providerMetadata,
             codexFetcher: fetcher,
             claudeFetcher: self.claudeFetcher,
-            browserDetection: browserDetection)
+            browserDetection: browserDetection,
+            environmentBase: environmentBase)
         self.providerRuntimes = Dictionary(uniqueKeysWithValues: ProviderCatalog.all.compactMap { implementation in
             implementation.makeRuntime().map { (implementation.id, $0) }
         })
+        self.planUtilizationHistory = planUtilizationHistoryStore.load()
+        self.weeklyLimitResetDetectorStates = Self.loadWeeklyLimitResetDetectorStates(from: settings.userDefaults)
+        if let codexAccountUsageSnapshotStore = self.codexAccountUsageSnapshotStore {
+            self.codexAccountSnapshots = codexAccountUsageSnapshotStore.load(
+                for: self.freshCodexVisibleAccountsForSnapshotHydration())
+        }
         self.logStartupState()
         self.bindSettings()
         self.pathDebugInfo = PathDebugSnapshot(
@@ -204,6 +333,7 @@ final class UsageStore {
             effectivePATH: PathBuilder.effectivePATH(purposes: [.rpc, .tty, .nodeTooling]),
             loginShellPATH: LoginShellPathCache.shared.current?.joined(separator: ":"))
         guard self.startupBehavior.automaticallyStartsBackgroundWork else { return }
+        self.hydrateCachedTokenSnapshots()
         self.detectVersions()
         self.updateProviderRuntimes()
         Task { @MainActor [weak self] in
@@ -246,11 +376,7 @@ final class UsageStore {
     /// Determines if a login method string indicates a Claude subscription plan.
     /// Known subscription indicators: Max, Pro, Ultra, Team (case-insensitive).
     nonisolated static func isSubscriptionPlan(_ loginMethod: String?) -> Bool {
-        guard let method = loginMethod?.lowercased(), !method.isEmpty else {
-            return false
-        }
-        let subscriptionIndicators = ["max", "pro", "ultra", "team"]
-        return subscriptionIndicators.contains { method.contains($0) }
+        ClaudePlan.isSubscriptionLoginMethod(loginMethod)
     }
 
     func version(for provider: UsageProvider) -> String? {
@@ -283,7 +409,18 @@ final class UsageStore {
     func enabledProviders() -> [UsageProvider] {
         // Use cached enablement to avoid repeated UserDefaults lookups in animation ticks.
         let enabled = self.settings.enabledProvidersOrdered(metadataByProvider: self.providerMetadata)
-        return enabled.filter { self.isProviderAvailable($0) }
+        let now = Date()
+        return enabled.filter { self.isProviderAvailable($0, now: now) }
+    }
+
+    /// Enabled providers without availability filtering. Used for display (switcher, merge-icons).
+    func enabledProvidersForDisplay() -> [UsageProvider] {
+        self.settings.enabledProvidersOrdered(metadataByProvider: self.providerMetadata)
+    }
+
+    /// Providers that should actually participate in background refresh/status/token work.
+    func enabledProvidersForBackgroundWork() -> [UsageProvider] {
+        self.enabledProviders()
     }
 
     var statusChecksEnabled: Bool {
@@ -294,7 +431,7 @@ final class UsageStore {
         self.providerMetadata[provider]!
     }
 
-    private var codexBrowserCookieOrder: BrowserCookieImportOrder {
+    var codexBrowserCookieOrder: BrowserCookieImportOrder {
         self.metadata(for: .codex).browserCookieOrder ?? Browser.defaultImportOrder
     }
 
@@ -352,11 +489,24 @@ final class UsageStore {
     }
 
     func isProviderAvailable(_ provider: UsageProvider) -> Bool {
+        self.isProviderAvailable(provider, now: Date())
+    }
+
+    private func isProviderAvailable(_ provider: UsageProvider, now: Date) -> Bool {
+        guard provider != .codex else { return true }
+
+        let configRevision = self.settings.configRevision
+        if let cached = self.providerAvailabilityCache[provider],
+           cached.isValid(now: now, configRevision: configRevision)
+        {
+            return cached.available
+        }
+
         // Availability should mirror the effective fetch environment, including token-account overrides.
         // Otherwise providers (notably token-account-backed API providers) can fetch successfully but be
         // hidden from the menu because their credentials are not in ProcessInfo's environment.
         let environment = ProviderRegistry.makeEnvironment(
-            base: ProcessInfo.processInfo.environment,
+            base: self.environmentBase,
             provider: provider,
             settings: self.settings,
             tokenOverride: nil)
@@ -364,9 +514,18 @@ final class UsageStore {
             provider: provider,
             settings: self.settings,
             environment: environment)
-        return ProviderCatalog.implementation(for: provider)?
+        let available = ProviderCatalog.implementation(for: provider)?
             .isAvailable(context: context)
             ?? true
+        self.providerAvailabilityCache[provider] = ProviderAvailabilityCacheEntry(
+            available: available,
+            configRevision: configRevision,
+            expiresAt: now.addingTimeInterval(self.providerAvailabilityCacheTTL))
+        return available
+    }
+
+    private func invalidateProviderAvailabilityCache() {
+        self.providerAvailabilityCache.removeAll(keepingCapacity: true)
     }
 
     func performRuntimeAction(_ action: ProviderRuntimeAction, for provider: UsageProvider) async {
@@ -388,38 +547,117 @@ final class UsageStore {
     }
 
     func refresh(forceTokenUsage: Bool = false) async {
+        await self.runRefresh(forceTokenUsage: forceTokenUsage, startupConnectivityRetryAttempt: nil)
+    }
+
+    func runRefresh(
+        forceTokenUsage: Bool = false,
+        startupConnectivityRetryAttempt: Int?,
+        coalesceProviderRefreshesOverride: Bool? = nil) async
+    {
         guard !self.isRefreshing else { return }
-        let refreshPhase: ProviderRefreshPhase = self.hasCompletedInitialRefresh ? .regular : .startup
+        self.prepareRefreshState()
+        let refreshPhase = Self.refreshPhase(hasCompletedInitialRefresh: self.hasCompletedInitialRefresh)
+        let openAIWebRefreshPhase = Self.openAIWebRefreshPhase(
+            providerRefreshPhase: refreshPhase,
+            startupConnectivityRetryAttempt: startupConnectivityRetryAttempt)
+        let allowsStartupConnectivityRetry = refreshPhase == .startup || startupConnectivityRetryAttempt != nil
+        self.startupConnectivityRetryRefreshActive = allowsStartupConnectivityRetry
+        self.startupConnectivityRetryNeeded = false
+        let displayEnabledProviders = self.enabledProvidersForDisplay()
+        let enabledProviderSet = Set(displayEnabledProviders)
+        let refreshProviders = self.enabledProvidersForBackgroundWork()
+        let availableRefreshProviders = Set(self.enabledProviders())
+        let refreshStartedAt = Date()
 
         await ProviderRefreshContext.$current.withValue(refreshPhase) {
             self.isRefreshing = true
             defer {
                 self.isRefreshing = false
                 self.hasCompletedInitialRefresh = true
+                self.startupConnectivityRetryRefreshActive = false
             }
 
+            self.clearDisabledProviderState(enabledProviders: enabledProviderSet)
+            self.clearUnavailableProviderState(
+                displayEnabledProviders: enabledProviderSet,
+                availableProviders: availableRefreshProviders)
+            self.scheduleStorageFootprintRefresh(for: displayEnabledProviders)
+
             await withTaskGroup(of: Void.self) { group in
-                for provider in UsageProvider.allCases {
-                    group.addTask { await self.refreshProvider(provider) }
-                    group.addTask { await self.refreshStatus(provider) }
+                for provider in refreshProviders {
+                    group.addTask {
+                        await self.refreshProvider(
+                            provider,
+                            coalesceIfRefreshing: coalesceProviderRefreshesOverride ??
+                                (ProviderInteractionContext.current == .background))
+                    }
+                    if availableRefreshProviders.contains(provider) {
+                        group.addTask { await self.refreshProviderStatus(provider) }
+                    }
+                }
+                if forceTokenUsage {
+                    group.addTask { await self.refreshCreditsNow(minimumSnapshotUpdatedAt: refreshStartedAt) }
                 }
-                group.addTask { await self.refreshCreditsIfNeeded() }
             }
 
-            // Token-cost usage can be slow; run it outside the refresh group so we don't block menu updates.
-            self.scheduleTokenRefresh(force: forceTokenUsage)
+            if !forceTokenUsage {
+                self.scheduleCreditsRefreshIfNeeded(minimumSnapshotUpdatedAt: refreshStartedAt)
+            }
+
+            if forceTokenUsage {
+                await self.refreshTokenUsageSequenceNow(force: true)
+            } else {
+                // Token-cost usage can be slow; run it outside regular/menu-open refreshes so we don't block UI.
+                self.scheduleTokenRefresh(force: false)
+            }
 
             // OpenAI web scrape depends on the current Codex account email (which can change after login/account
             // switch). Run this after Codex usage refresh so we don't accidentally scrape with stale credentials.
-            await self.refreshOpenAIDashboardIfNeeded(force: forceTokenUsage)
+            self.syncOpenAIWebState()
+            let refreshPolicy = OpenAIWebRefreshPolicyContext(
+                accessEnabled: self.isEnabled(.codex) &&
+                    self.settings.openAIWebAccessEnabled &&
+                    self.settings.codexCookieSource.isEnabled,
+                batterySaverEnabled: self.settings.openAIWebBatterySaverEnabled,
+                force: forceTokenUsage,
+                refreshPhase: openAIWebRefreshPhase)
+            let shouldRefreshOpenAIWeb = Self.shouldRunOpenAIWebRefresh(refreshPolicy)
+            self.openAIWebLogger.debug(
+                "OpenAI web refresh gate",
+                metadata: [
+                    "allowed": shouldRefreshOpenAIWeb ? "1" : "0",
+                    "accessEnabled": refreshPolicy.accessEnabled ? "1" : "0",
+                    "batterySaverEnabled": refreshPolicy.batterySaverEnabled ? "1" : "0",
+                    "force": refreshPolicy.force ? "1" : "0",
+                    "interaction": ProviderInteractionContext.current == .userInitiated ? "user" : "background",
+                    "phase": openAIWebRefreshPhase == .startup ? "startup" : "regular",
+                ])
+            if shouldRefreshOpenAIWeb {
+                let codexDashboardGuard = self.freshCodexOpenAIWebRefreshGuard()
+                if forceTokenUsage {
+                    await self.refreshOpenAIDashboardIfNeeded(
+                        force: true,
+                        expectedGuard: codexDashboardGuard)
+                } else {
+                    self.scheduleOpenAIDashboardRefreshIfNeeded(expectedGuard: codexDashboardGuard)
+                }
+            }
 
-            if self.openAIDashboardRequiresLogin {
+            if forceTokenUsage, self.openAIDashboardRequiresLogin {
                 await self.refreshProvider(.codex)
-                await self.refreshCreditsIfNeeded()
+                await self.refreshCreditsNow(minimumSnapshotUpdatedAt: refreshStartedAt)
             }
 
             self.persistWidgetSnapshot(reason: "refresh")
         }
+
+        if allowsStartupConnectivityRetry {
+            self.completeStartupConnectivityRetryPass(currentAttempt: startupConnectivityRetryAttempt ?? 0)
+        }
+        if refreshPhase == .startup {
+            self.scheduleMemoryPressureRelief()
+        }
     }
 
     /// For demo/testing: drop the snapshot so the loading animation plays, then restore the last snapshot.
@@ -481,41 +719,88 @@ final class UsageStore {
                     self?.tokenRefreshSequenceTask = nil
                 }
             }
-            for provider in UsageProvider.allCases {
-                if Task.isCancelled { break }
-                await self.refreshTokenUsage(provider, force: force)
-            }
+            await self.refreshTokenUsageSequence(force: force)
+        }
+    }
+
+    private func refreshTokenUsageSequenceNow(force: Bool) async {
+        await self.drainScheduledTokenRefreshIfNeeded(force: force, scopedTo: nil)
+        await self.refreshTokenUsageSequence(force: force)
+    }
+
+    func refreshTokenUsageNow(for provider: UsageProvider, force: Bool) async {
+        await self.drainScheduledTokenRefreshIfNeeded(force: force, scopedTo: provider)
+        await self.refreshTokenUsage(provider, force: force)
+        self.scheduleMemoryPressureRelief()
+    }
+
+    private func drainScheduledTokenRefreshIfNeeded(force: Bool, scopedTo provider: UsageProvider?) async {
+        guard force, let existing = self.tokenRefreshSequenceTask else { return }
+        if let provider, self.tokenRefreshSequenceProvider != provider { return }
+        existing.cancel()
+        await existing.value
+        self.tokenRefreshSequenceTask = nil
+    }
+
+    private func refreshTokenUsageSequence(force: Bool) async {
+        defer { self.tokenRefreshSequenceProvider = nil }
+        for provider in self.enabledProvidersForBackgroundWork() {
+            if Task.isCancelled { break }
+            self.tokenRefreshSequenceProvider = provider
+            await self.refreshTokenUsage(provider, force: force)
+            self.tokenRefreshSequenceProvider = nil
         }
+        self.scheduleMemoryPressureRelief()
     }
 
     deinit {
         self.timerTask?.cancel()
         self.tokenTimerTask?.cancel()
         self.tokenRefreshSequenceTask?.cancel()
+        self.memoryPressureReliefTask?.cancel()
+        self.startupConnectivityRetryTask?.cancel()
+        self.storageRefreshTask?.cancel()
+        self.codexPlanHistoryBackfillTask?.cancel()
     }
 
     enum SessionQuotaWindowSource: String {
         case primary
         case copilotSecondaryFallback
+        case antigravityQuotaSummary
+        case antigravityLegacy
     }
 
-    private func sessionQuotaWindow(
-        provider: UsageProvider,
-        snapshot: UsageSnapshot) -> (window: RateWindow, source: SessionQuotaWindowSource)?
-    {
-        if let primary = snapshot.primary {
-            return (primary, .primary)
-        }
-        if provider == .copilot, let secondary = snapshot.secondary {
-            return (secondary, .copilotSecondaryFallback)
-        }
-        return nil
+    struct QuotaWarningStateKey: Hashable {
+        let provider: UsageProvider
+        let window: QuotaWarningWindow
+    }
+
+    struct QuotaWarningState {
+        var lastRemaining: Double?
+        var firedThresholds: Set<Int> = []
+        var source: SessionQuotaWindowSource?
+    }
+
+    func postQuotaWarning(_ event: QuotaWarningEvent, provider: UsageProvider) {
+        self.sessionQuotaNotifier.postQuotaWarning(
+            event: event,
+            provider: provider,
+            soundEnabled: self.settings.quotaWarningSoundEnabled)
     }
 
     func handleSessionQuotaTransition(provider: UsageProvider, snapshot: UsageSnapshot) {
         // Session quota notifications are tied to the primary session window. Copilot free plans can
         // expose only chat quota, so allow Copilot to fall back to secondary for transition tracking.
+        // Command Code synthesizes a depleted primary while subscription enrichment is unavailable.
+        // Preserve the prior notification state for that placeholder, but accept positive credit data.
+        if provider == .commandcode,
+           snapshot.commandCodeSubscriptionEnrichmentUnavailable,
+           SessionQuotaNotificationLogic.isDepleted(snapshot.primary?.remainingPercent)
+        {
+            return
+        }
         guard let sessionWindow = self.sessionQuotaWindow(provider: provider, snapshot: snapshot) else {
+            if provider == .commandcode, snapshot.commandCodeSubscriptionEnrichmentUnavailable { return }
             self.lastKnownSessionRemaining.removeValue(forKey: provider)
             self.lastKnownSessionWindowSource.removeValue(forKey: provider)
             return
@@ -589,13 +874,15 @@ final class UsageStore {
         self.sessionQuotaNotifier.post(transition: transition, provider: provider, badge: nil)
     }
 
-    private func refreshStatus(_ provider: UsageProvider) async {
+    func refreshProviderStatus(_ provider: UsageProvider) async {
         guard self.settings.statusChecksEnabled else { return }
         guard let meta = self.providerMetadata[provider] else { return }
 
         do {
             let status: ProviderStatus
-            if let urlString = meta.statusPageURL, let baseURL = URL(string: urlString) {
+            if let override = self._test_providerStatusFetchOverride {
+                status = try await override(provider)
+            } else if let urlString = meta.statusPageURL, let baseURL = URL(string: urlString) {
                 status = try await Self.fetchStatus(from: baseURL)
             } else if let productID = meta.statusWorkspaceProductID {
                 status = try await Self.fetchWorkspaceStatus(productID: productID)
@@ -604,6 +891,7 @@ final class UsageStore {
             }
             await MainActor.run { self.statuses[provider] = status }
         } catch {
+            self.recordStartupConnectivityRetryableFailure(error)
             // Keep the previous status to avoid flapping when the API hiccups.
             await MainActor.run {
                 if self.statuses[provider] == nil {
@@ -615,490 +903,6 @@ final class UsageStore {
             }
         }
     }
-
-    private func refreshCreditsIfNeeded() async {
-        guard self.isEnabled(.codex) else { return }
-        do {
-            let credits = try await self.codexFetcher.loadLatestCredits(
-                keepCLISessionsAlive: self.settings.debugKeepCLISessionsAlive)
-            await MainActor.run {
-                self.credits = credits
-                self.lastCreditsError = nil
-                self.lastCreditsSnapshot = credits
-                self.creditsFailureStreak = 0
-            }
-        } catch {
-            let message = error.localizedDescription
-            if message.localizedCaseInsensitiveContains("data not available yet") {
-                await MainActor.run {
-                    if let cached = self.lastCreditsSnapshot {
-                        self.credits = cached
-                        self.lastCreditsError = nil
-                    } else {
-                        self.credits = nil
-                        self.lastCreditsError = "Codex credits are still loading; will retry shortly."
-                    }
-                }
-                return
-            }
-
-            await MainActor.run {
-                self.creditsFailureStreak += 1
-                if let cached = self.lastCreditsSnapshot {
-                    self.credits = cached
-                    let stamp = cached.updatedAt.formatted(date: .abbreviated, time: .shortened)
-                    self.lastCreditsError =
-                        "Last Codex credits refresh failed: \(message). Cached values from \(stamp)."
-                } else {
-                    self.lastCreditsError = message
-                    self.credits = nil
-                }
-            }
-        }
-    }
-}
-
-extension UsageStore {
-    private static let openAIWebRefreshMultiplier: TimeInterval = 5
-    private static let openAIWebPrimaryFetchTimeout: TimeInterval = 15
-    private static let openAIWebRetryFetchTimeout: TimeInterval = 8
-
-    private func openAIWebRefreshIntervalSeconds() -> TimeInterval {
-        let base = max(self.settings.refreshFrequency.seconds ?? 0, 120)
-        return base * Self.openAIWebRefreshMultiplier
-    }
-
-    func requestOpenAIDashboardRefreshIfStale(reason: String) {
-        guard self.isEnabled(.codex), self.settings.codexCookieSource.isEnabled else { return }
-        let now = Date()
-        let refreshInterval = self.openAIWebRefreshIntervalSeconds()
-        let lastUpdatedAt = self.openAIDashboard?.updatedAt ?? self.lastOpenAIDashboardSnapshot?.updatedAt
-        if let lastUpdatedAt, now.timeIntervalSince(lastUpdatedAt) < refreshInterval { return }
-        let stamp = now.formatted(date: .abbreviated, time: .shortened)
-        self.logOpenAIWeb("[\(stamp)] OpenAI web refresh request: \(reason)")
-        Task { await self.refreshOpenAIDashboardIfNeeded(force: true) }
-    }
-
-    private func applyOpenAIDashboard(_ dash: OpenAIDashboardSnapshot, targetEmail: String?) async {
-        await MainActor.run {
-            self.openAIDashboard = dash
-            self.lastOpenAIDashboardError = nil
-            self.lastOpenAIDashboardSnapshot = dash
-            self.openAIDashboardRequiresLogin = false
-            // Only fill gaps; OAuth/CLI remain the primary sources for usage + credits.
-            if self.snapshots[.codex] == nil,
-               let usage = dash.toUsageSnapshot(provider: .codex, accountEmail: targetEmail)
-            {
-                self.snapshots[.codex] = usage
-                self.errors[.codex] = nil
-                self.failureGates[.codex]?.recordSuccess()
-                self.lastSourceLabels[.codex] = "openai-web"
-            }
-            if self.credits == nil, let credits = dash.toCreditsSnapshot() {
-                self.credits = credits
-                self.lastCreditsSnapshot = credits
-                self.lastCreditsError = nil
-                self.creditsFailureStreak = 0
-            }
-        }
-
-        if let email = targetEmail, !email.isEmpty {
-            OpenAIDashboardCacheStore.save(OpenAIDashboardCache(accountEmail: email, snapshot: dash))
-        }
-        self.backfillCodexHistoricalFromDashboardIfNeeded(dash)
-    }
-
-    private func applyOpenAIDashboardFailure(message: String) async {
-        await MainActor.run {
-            if let cached = self.lastOpenAIDashboardSnapshot {
-                self.openAIDashboard = cached
-                let stamp = cached.updatedAt.formatted(date: .abbreviated, time: .shortened)
-                self.lastOpenAIDashboardError =
-                    "Last OpenAI dashboard refresh failed: \(message). Cached values from \(stamp)."
-            } else {
-                self.lastOpenAIDashboardError = message
-                self.openAIDashboard = nil
-            }
-        }
-    }
-
-    private func refreshOpenAIDashboardIfNeeded(force: Bool = false) async {
-        guard self.isEnabled(.codex), self.settings.codexCookieSource.isEnabled else {
-            self.resetOpenAIWebState()
-            return
-        }
-
-        let targetEmail = self.codexAccountEmailForOpenAIDashboard()
-        self.handleOpenAIWebTargetEmailChangeIfNeeded(targetEmail: targetEmail)
-
-        let now = Date()
-        let minInterval = self.openAIWebRefreshIntervalSeconds()
-        if !force,
-           !self.openAIWebAccountDidChange,
-           self.lastOpenAIDashboardError == nil,
-           let snapshot = self.lastOpenAIDashboardSnapshot,
-           now.timeIntervalSince(snapshot.updatedAt) < minInterval
-        {
-            return
-        }
-
-        if self.openAIWebDebugLines.isEmpty {
-            self.resetOpenAIWebDebugLog(context: "refresh")
-        } else {
-            let stamp = Date().formatted(date: .abbreviated, time: .shortened)
-            self.logOpenAIWeb("[\(stamp)] OpenAI web refresh start")
-        }
-        let log: (String) -> Void = { [weak self] line in
-            guard let self else { return }
-            self.logOpenAIWeb(line)
-        }
-
-        do {
-            let normalized = targetEmail?
-                .trimmingCharacters(in: .whitespacesAndNewlines)
-                .lowercased()
-            var effectiveEmail = targetEmail
-
-            // Use a per-email persistent `WKWebsiteDataStore` so multiple dashboard sessions can coexist.
-            // Strategy:
-            // - Try the existing per-email WebKit cookie store first (fast; avoids Keychain prompts).
-            // - On login-required or account mismatch, import cookies from the configured browser order and retry once.
-            if self.openAIWebAccountDidChange, let targetEmail, !targetEmail.isEmpty {
-                // On account switches, proactively re-import cookies so we don't show stale data from the previous
-                // user.
-                if let imported = await self.importOpenAIDashboardCookiesIfNeeded(
-                    targetEmail: targetEmail,
-                    force: true)
-                {
-                    effectiveEmail = imported
-                }
-                self.openAIWebAccountDidChange = false
-            }
-
-            var dash = try await OpenAIDashboardFetcher().loadLatestDashboard(
-                accountEmail: effectiveEmail,
-                logger: log,
-                debugDumpHTML: false,
-                timeout: Self.openAIWebPrimaryFetchTimeout)
-
-            if self.dashboardEmailMismatch(expected: normalized, actual: dash.signedInEmail) {
-                if let imported = await self.importOpenAIDashboardCookiesIfNeeded(
-                    targetEmail: targetEmail,
-                    force: true)
-                {
-                    effectiveEmail = imported
-                }
-                dash = try await OpenAIDashboardFetcher().loadLatestDashboard(
-                    accountEmail: effectiveEmail,
-                    logger: log,
-                    debugDumpHTML: false,
-                    timeout: Self.openAIWebRetryFetchTimeout)
-            }
-
-            if self.dashboardEmailMismatch(expected: normalized, actual: dash.signedInEmail) {
-                let signedIn = dash.signedInEmail?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "unknown"
-                await MainActor.run {
-                    self.openAIDashboard = nil
-                    self.lastOpenAIDashboardError = [
-                        "OpenAI dashboard signed in as \(signedIn), but Codex uses \(normalized ?? "unknown").",
-                        "Switch accounts in your browser and update OpenAI cookies in Providers → Codex.",
-                    ].joined(separator: " ")
-                    self.openAIDashboardRequiresLogin = true
-                }
-                return
-            }
-
-            await self.applyOpenAIDashboard(dash, targetEmail: effectiveEmail)
-        } catch let OpenAIDashboardFetcher.FetchError.noDashboardData(body) {
-            // Often indicates a missing/stale session without an obvious login prompt. Retry once after
-            // importing cookies from the user's browser.
-            let targetEmail = self.codexAccountEmailForOpenAIDashboard()
-            var effectiveEmail = targetEmail
-            if let imported = await self.importOpenAIDashboardCookiesIfNeeded(targetEmail: targetEmail, force: true) {
-                effectiveEmail = imported
-            }
-            do {
-                let dash = try await OpenAIDashboardFetcher().loadLatestDashboard(
-                    accountEmail: effectiveEmail,
-                    logger: log,
-                    debugDumpHTML: true,
-                    timeout: Self.openAIWebRetryFetchTimeout)
-                await self.applyOpenAIDashboard(dash, targetEmail: effectiveEmail)
-            } catch let OpenAIDashboardFetcher.FetchError.noDashboardData(retryBody) {
-                let finalBody = retryBody.isEmpty ? body : retryBody
-                let message = self.openAIDashboardFriendlyError(
-                    body: finalBody,
-                    targetEmail: targetEmail,
-                    cookieImportStatus: self.openAIDashboardCookieImportStatus)
-                    ?? OpenAIDashboardFetcher.FetchError.noDashboardData(body: finalBody).localizedDescription
-                await self.applyOpenAIDashboardFailure(message: message)
-            } catch {
-                await self.applyOpenAIDashboardFailure(message: error.localizedDescription)
-            }
-        } catch OpenAIDashboardFetcher.FetchError.loginRequired {
-            let targetEmail = self.codexAccountEmailForOpenAIDashboard()
-            var effectiveEmail = targetEmail
-            if let imported = await self.importOpenAIDashboardCookiesIfNeeded(targetEmail: targetEmail, force: true) {
-                effectiveEmail = imported
-            }
-            do {
-                let dash = try await OpenAIDashboardFetcher().loadLatestDashboard(
-                    accountEmail: effectiveEmail,
-                    logger: log,
-                    debugDumpHTML: true,
-                    timeout: Self.openAIWebRetryFetchTimeout)
-                await self.applyOpenAIDashboard(dash, targetEmail: effectiveEmail)
-            } catch OpenAIDashboardFetcher.FetchError.loginRequired {
-                await MainActor.run {
-                    self.lastOpenAIDashboardError = [
-                        "OpenAI web access requires a signed-in chatgpt.com session.",
-                        "Sign in using \(self.codexBrowserCookieOrder.loginHint), " +
-                            "then update OpenAI cookies in Providers → Codex.",
-                    ].joined(separator: " ")
-                    self.openAIDashboard = self.lastOpenAIDashboardSnapshot
-                    self.openAIDashboardRequiresLogin = true
-                }
-            } catch {
-                await self.applyOpenAIDashboardFailure(message: error.localizedDescription)
-            }
-        } catch {
-            await self.applyOpenAIDashboardFailure(message: error.localizedDescription)
-        }
-    }
-
-    // MARK: - OpenAI web account switching
-
-    /// Detect Codex account email changes and clear stale OpenAI web state so the UI can't show the wrong user.
-    /// This does not delete other per-email WebKit cookie stores (we keep multiple accounts around).
-    func handleOpenAIWebTargetEmailChangeIfNeeded(targetEmail: String?) {
-        let normalized = targetEmail?
-            .trimmingCharacters(in: .whitespacesAndNewlines)
-            .lowercased()
-
-        guard let normalized, !normalized.isEmpty else { return }
-
-        let previous = self.lastOpenAIDashboardTargetEmail
-        self.lastOpenAIDashboardTargetEmail = normalized
-
-        if let previous,
-           !previous.isEmpty,
-           previous != normalized
-        {
-            let stamp = Date().formatted(date: .abbreviated, time: .shortened)
-            self.logOpenAIWeb(
-                "[\(stamp)] Codex account changed: \(previous) → \(normalized); " +
-                    "clearing OpenAI web snapshot")
-            self.openAIWebAccountDidChange = true
-            self.openAIDashboard = nil
-            self.lastOpenAIDashboardSnapshot = nil
-            self.lastOpenAIDashboardError = nil
-            self.openAIDashboardRequiresLogin = true
-            self.openAIDashboardCookieImportStatus = "Codex account changed; importing browser cookies…"
-            self.lastOpenAIDashboardCookieImportAttemptAt = nil
-            self.lastOpenAIDashboardCookieImportEmail = nil
-        }
-    }
-
-    func importOpenAIDashboardBrowserCookiesNow() async {
-        self.resetOpenAIWebDebugLog(context: "manual import")
-        let targetEmail = self.codexAccountEmailForOpenAIDashboard()
-        _ = await self.importOpenAIDashboardCookiesIfNeeded(targetEmail: targetEmail, force: true)
-        await self.refreshOpenAIDashboardIfNeeded(force: true)
-    }
-
-    private func importOpenAIDashboardCookiesIfNeeded(targetEmail: String?, force: Bool) async -> String? {
-        let normalizedTarget = targetEmail?.trimmingCharacters(in: .whitespacesAndNewlines)
-        let allowAnyAccount = normalizedTarget == nil || normalizedTarget?.isEmpty == true
-        let cookieSource = self.settings.codexCookieSource
-
-        let now = Date()
-        let lastEmail = self.lastOpenAIDashboardCookieImportEmail
-        let lastAttempt = self.lastOpenAIDashboardCookieImportAttemptAt ?? .distantPast
-
-        let shouldAttempt: Bool = if force {
-            true
-        } else {
-            if allowAnyAccount {
-                now.timeIntervalSince(lastAttempt) > 300
-            } else {
-                self.openAIDashboardRequiresLogin &&
-                    (
-                        lastEmail?.lowercased() != normalizedTarget?.lowercased() || now
-                            .timeIntervalSince(lastAttempt) > 300)
-            }
-        }
-
-        guard shouldAttempt else { return normalizedTarget }
-        self.lastOpenAIDashboardCookieImportEmail = normalizedTarget
-        self.lastOpenAIDashboardCookieImportAttemptAt = now
-
-        let stamp = now.formatted(date: .abbreviated, time: .shortened)
-        let targetLabel = normalizedTarget ?? "unknown"
-        self.logOpenAIWeb("[\(stamp)] import start (target=\(targetLabel))")
-
-        do {
-            let log: (String) -> Void = { [weak self] message in
-                guard let self else { return }
-                self.logOpenAIWeb(message)
-            }
-
-            let importer = OpenAIDashboardBrowserCookieImporter(browserDetection: self.browserDetection)
-            let result: OpenAIDashboardBrowserCookieImporter.ImportResult
-            switch cookieSource {
-            case .manual:
-                self.settings.ensureCodexCookieLoaded()
-                let manualHeader = self.settings.codexCookieHeader
-                guard CookieHeaderNormalizer.normalize(manualHeader) != nil else {
-                    throw OpenAIDashboardBrowserCookieImporter.ImportError.manualCookieHeaderInvalid
-                }
-                result = try await importer.importManualCookies(
-                    cookieHeader: manualHeader,
-                    intoAccountEmail: normalizedTarget,
-                    allowAnyAccount: allowAnyAccount,
-                    logger: log)
-            case .auto:
-                result = try await importer.importBestCookies(
-                    intoAccountEmail: normalizedTarget,
-                    allowAnyAccount: allowAnyAccount,
-                    logger: log)
-            case .off:
-                result = OpenAIDashboardBrowserCookieImporter.ImportResult(
-                    sourceLabel: "Off",
-                    cookieCount: 0,
-                    signedInEmail: normalizedTarget,
-                    matchesCodexEmail: true)
-            }
-            let effectiveEmail = result.signedInEmail?
-                .trimmingCharacters(in: .whitespacesAndNewlines)
-                .isEmpty == false
-                ? result.signedInEmail?.trimmingCharacters(in: .whitespacesAndNewlines)
-                : normalizedTarget
-            self.lastOpenAIDashboardCookieImportEmail = effectiveEmail ?? normalizedTarget
-            await MainActor.run {
-                let signed = result.signedInEmail?.trimmingCharacters(in: .whitespacesAndNewlines)
-                let matchText = result.matchesCodexEmail ? "matches Codex" : "does not match Codex"
-                let sourceLabel = switch cookieSource {
-                case .manual:
-                    "Manual cookie header"
-                case .auto:
-                    "\(result.sourceLabel) cookies"
-                case .off:
-                    "OpenAI cookies disabled"
-                }
-                if let signed, !signed.isEmpty {
-                    self.openAIDashboardCookieImportStatus =
-                        allowAnyAccount
-                            ? [
-                                "Using \(sourceLabel) (\(result.cookieCount)).",
-                                "Signed in as \(signed).",
-                            ].joined(separator: " ")
-                            : [
-                                "Using \(sourceLabel) (\(result.cookieCount)).",
-                                "Signed in as \(signed) (\(matchText)).",
-                            ].joined(separator: " ")
-                } else {
-                    self.openAIDashboardCookieImportStatus =
-                        "Using \(sourceLabel) (\(result.cookieCount))."
-                }
-            }
-            return effectiveEmail
-        } catch let err as OpenAIDashboardBrowserCookieImporter.ImportError {
-            switch err {
-            case let .noMatchingAccount(found):
-                let foundText: String = if found.isEmpty {
-                    "no signed-in session detected in \(self.codexBrowserCookieOrder.loginHint)"
-                } else {
-                    found
-                        .sorted { lhs, rhs in
-                            if lhs.sourceLabel == rhs.sourceLabel { return lhs.email < rhs.email }
-                            return lhs.sourceLabel < rhs.sourceLabel
-                        }
-                        .map { "\($0.sourceLabel): \($0.email)" }
-                        .joined(separator: " • ")
-                }
-                self.logOpenAIWeb("[\(stamp)] import mismatch: \(foundText)")
-                await MainActor.run {
-                    self.openAIDashboardCookieImportStatus = allowAnyAccount
-                        ? [
-                            "No signed-in OpenAI web session found.",
-                            "Found \(foundText).",
-                        ].joined(separator: " ")
-                        : [
-                            "Browser cookies do not match Codex account (\(normalizedTarget ?? "unknown")).",
-                            "Found \(foundText).",
-                        ].joined(separator: " ")
-                    // Treat mismatch like "not logged in" for the current Codex account.
-                    self.openAIDashboardRequiresLogin = true
-                    self.openAIDashboard = nil
-                }
-            case .noCookiesFound,
-                 .browserAccessDenied,
-                 .dashboardStillRequiresLogin,
-                 .manualCookieHeaderInvalid:
-                self.logOpenAIWeb("[\(stamp)] import failed: \(err.localizedDescription)")
-                await MainActor.run {
-                    self.openAIDashboardCookieImportStatus =
-                        "OpenAI cookie import failed: \(err.localizedDescription)"
-                    self.openAIDashboardRequiresLogin = true
-                }
-            }
-        } catch {
-            self.logOpenAIWeb("[\(stamp)] import failed: \(error.localizedDescription)")
-            await MainActor.run {
-                self.openAIDashboardCookieImportStatus =
-                    "Browser cookie import failed: \(error.localizedDescription)"
-            }
-        }
-        return nil
-    }
-
-    private func resetOpenAIWebDebugLog(context: String) {
-        let stamp = Date().formatted(date: .abbreviated, time: .shortened)
-        self.openAIWebDebugLines.removeAll(keepingCapacity: true)
-        self.openAIDashboardCookieImportDebugLog = nil
-        self.logOpenAIWeb("[\(stamp)] OpenAI web \(context) start")
-    }
-
-    private func logOpenAIWeb(_ message: String) {
-        let safeMessage = LogRedactor.redact(message)
-        self.openAIWebLogger.debug(safeMessage)
-        self.openAIWebDebugLines.append(safeMessage)
-        if self.openAIWebDebugLines.count > 240 {
-            self.openAIWebDebugLines.removeFirst(self.openAIWebDebugLines.count - 240)
-        }
-        self.openAIDashboardCookieImportDebugLog = self.openAIWebDebugLines.joined(separator: "\n")
-    }
-
-    func resetOpenAIWebState() {
-        self.openAIDashboard = nil
-        self.lastOpenAIDashboardError = nil
-        self.lastOpenAIDashboardSnapshot = nil
-        self.lastOpenAIDashboardTargetEmail = nil
-        self.openAIDashboardRequiresLogin = false
-        self.openAIDashboardCookieImportStatus = nil
-        self.openAIDashboardCookieImportDebugLog = nil
-        self.lastOpenAIDashboardCookieImportAttemptAt = nil
-        self.lastOpenAIDashboardCookieImportEmail = nil
-    }
-
-    private func dashboardEmailMismatch(expected: String?, actual: String?) -> Bool {
-        guard let expected, !expected.isEmpty else { return false }
-        guard let raw = actual?.trimmingCharacters(in: .whitespacesAndNewlines), !raw.isEmpty else { return false }
-        return raw.lowercased() != expected.lowercased()
-    }
-
-    func codexAccountEmailForOpenAIDashboard() -> String? {
-        let direct = self.snapshots[.codex]?.accountEmail(for: .codex)?
-            .trimmingCharacters(in: .whitespacesAndNewlines)
-        if let direct, !direct.isEmpty { return direct }
-        let fallback = self.codexFetcher.loadAccountInfo().email?.trimmingCharacters(in: .whitespacesAndNewlines)
-        if let fallback, !fallback.isEmpty { return fallback }
-        let cached = self.openAIDashboard?.signedInEmail?.trimmingCharacters(in: .whitespacesAndNewlines)
-        if let cached, !cached.isEmpty { return cached }
-        let imported = self.lastOpenAIDashboardCookieImportEmail?.trimmingCharacters(in: .whitespacesAndNewlines)
-        if let imported, !imported.isEmpty { return imported }
-        return nil
-    }
 }
 
 extension UsageStore {
@@ -1132,14 +936,11 @@ extension UsageStore {
         }
     }
 
-    func debugClaudeDump() async -> String {
-        await ClaudeStatusProbe.latestDumps()
-    }
-
     func debugAugmentDump() async -> String {
         await AugmentStatusProbe.latestDumps()
     }
 
+    // swiftlint:disable:next function_body_length
     func debugLog(for provider: UsageProvider) async -> String {
         if let cached = self.probeLogs[provider], !cached.isEmpty {
             return cached
@@ -1149,239 +950,371 @@ extension UsageStore {
         let claudeUsageDataSource = self.settings.claudeUsageDataSource
         let claudeCookieSource = self.settings.claudeCookieSource
         let claudeCookieHeader = self.settings.claudeCookieHeader
-        let keepCLISessionsAlive = self.settings.debugKeepCLISessionsAlive
+        let claudeDebugConfiguration: ClaudeDebugLogConfiguration? = if provider == .claude {
+            await self.makeClaudeDebugConfiguration(
+                fallbackUsageDataSource: claudeUsageDataSource,
+                fallbackWebExtrasEnabled: claudeWebExtrasEnabled,
+                fallbackCookieSource: claudeCookieSource,
+                fallbackCookieHeader: claudeCookieHeader)
+        } else {
+            nil
+        }
         let cursorCookieSource = self.settings.cursorCookieSource
         let cursorCookieHeader = self.settings.cursorCookieHeader
         let ampCookieSource = self.settings.ampCookieSource
         let ampCookieHeader = self.settings.ampCookieHeader
         let ollamaCookieSource = self.settings.ollamaCookieSource
         let ollamaCookieHeader = self.settings.ollamaCookieHeader
-        let processEnvironment = ProcessInfo.processInfo.environment
-        let openRouterConfigToken = self.settings.providerConfig(for: .openrouter)?.sanitizedAPIKey
-        let openRouterHasConfigToken = !(openRouterConfigToken?.trimmingCharacters(in: .whitespacesAndNewlines)
-            .isEmpty ?? true)
-        let openRouterHasEnvToken = OpenRouterSettingsReader.apiToken(environment: processEnvironment) != nil
-        let openRouterEnvironment = ProviderConfigEnvironment.applyAPIKeyOverride(
+        let processEnvironment = self.environmentBase
+        let openAIDebugContext = self.openAIAPIKeyDebugContext(processEnvironment: processEnvironment)
+        let azureOpenAIDebugContext = self.azureOpenAIAPIKeyDebugContext(processEnvironment: processEnvironment)
+        let openRouterDebugContext = self.openRouterAPIKeyDebugContext(processEnvironment: processEnvironment)
+        let elevenLabsDebugContext = self.elevenLabsAPIKeyDebugContext(processEnvironment: processEnvironment)
+        let deepSeekHasEnvToken = DeepSeekSettingsReader.apiKey(environment: processEnvironment) != nil
+        let deepSeekHasTokenAccount = self.settings.selectedTokenAccount(for: .deepseek) != nil
+        let deepSeekEnvironment = ProviderRegistry.makeEnvironment(
             base: processEnvironment,
-            provider: .openrouter,
-            config: self.settings.providerConfig(for: .openrouter))
-        return await Task.detached(priority: .utility) { () -> String in
+            provider: .deepseek,
+            settings: self.settings,
+            tokenOverride: nil)
+        let codexFetcher = self.codexFetcher
+        let browserDetection = self.browserDetection
+        let claudeDebugExecutionContext = self.currentClaudeDebugExecutionContext()
+        let text = await Task.detached(priority: .utility) { () -> String in
             let unimplementedDebugLogMessages: [UsageProvider: String] = [
                 .gemini: "Gemini debug log not yet implemented",
                 .antigravity: "Antigravity debug log not yet implemented",
                 .opencode: "OpenCode debug log not yet implemented",
+                .alibaba: "Alibaba Coding Plan debug log not yet implemented",
+                .alibabatokenplan: "Alibaba Token Plan debug log not yet implemented",
                 .factory: "Droid debug log not yet implemented",
                 .copilot: "Copilot debug log not yet implemented",
+                .manus: "Manus debug log not yet implemented",
                 .vertexai: "Vertex AI debug log not yet implemented",
                 .kilo: "Kilo debug log not yet implemented",
                 .kiro: "Kiro debug log not yet implemented",
                 .kimi: "Kimi debug log not yet implemented",
                 .kimik2: "Kimi K2 debug log not yet implemented",
                 .jetbrains: "JetBrains AI debug log not yet implemented",
+                .mimo: "Xiaomi MiMo debug log not yet implemented",
+                .doubao: "Doubao debug log not yet implemented",
+                .venice: "Venice debug log not yet implemented",
+                .commandcode: "Command Code debug log not yet implemented",
+                .stepfun: "StepFun debug log not yet implemented",
+                .bedrock: "Bedrock debug log not yet implemented",
+                .grok: "Grok debug log not yet implemented",
+                .groq: "Groq debug log not yet implemented",
+                .t3chat: "T3 Chat debug log not yet implemented",
+                .llmproxy: "LLM Proxy debug log not yet implemented",
+                .litellm: "LiteLLM debug log not yet implemented",
+                .deepgram: "Deepgram debug log not yet implemented",
+                .chutes: "Chutes debug log not yet implemented",
             ]
-            let text: String
-            switch provider {
-            case .codex:
-                text = await self.codexFetcher.debugRawRateLimits()
-            case .claude:
-                text = await self.debugClaudeLog(
-                    claudeWebExtrasEnabled: claudeWebExtrasEnabled,
-                    claudeUsageDataSource: claudeUsageDataSource,
-                    claudeCookieSource: claudeCookieSource,
-                    claudeCookieHeader: claudeCookieHeader,
-                    keepCLISessionsAlive: keepCLISessionsAlive)
-            case .zai:
-                let resolution = ProviderTokenResolver.zaiResolution()
-                let hasAny = resolution != nil
-                let source = resolution?.source.rawValue ?? "none"
-                text = "Z_AI_API_KEY=\(hasAny ? "present" : "missing") source=\(source)"
-            case .synthetic:
-                let resolution = ProviderTokenResolver.syntheticResolution()
-                let hasAny = resolution != nil
-                let source = resolution?.source.rawValue ?? "none"
-                text = "SYNTHETIC_API_KEY=\(hasAny ? "present" : "missing") source=\(source)"
-            case .cursor:
-                text = await self.debugCursorLog(
-                    cursorCookieSource: cursorCookieSource,
-                    cursorCookieHeader: cursorCookieHeader)
-            case .minimax:
-                let tokenResolution = ProviderTokenResolver.minimaxTokenResolution()
-                let cookieResolution = ProviderTokenResolver.minimaxCookieResolution()
-                let tokenSource = tokenResolution?.source.rawValue ?? "none"
-                let cookieSource = cookieResolution?.source.rawValue ?? "none"
-                text = "MINIMAX_API_KEY=\(tokenResolution == nil ? "missing" : "present") " +
-                    "source=\(tokenSource) MINIMAX_COOKIE=\(cookieResolution == nil ? "missing" : "present") " +
-                    "source=\(cookieSource)"
-            case .augment:
-                text = await self.debugAugmentLog()
-            case .amp:
-                text = await self.debugAmpLog(
-                    ampCookieSource: ampCookieSource,
-                    ampCookieHeader: ampCookieHeader)
-            case .ollama:
-                text = await self.debugOllamaLog(
-                    ollamaCookieSource: ollamaCookieSource,
-                    ollamaCookieHeader: ollamaCookieHeader)
-            case .openrouter:
-                let resolution = ProviderTokenResolver.openRouterResolution(environment: openRouterEnvironment)
-                let hasAny = resolution != nil
-                let source: String = if resolution == nil {
-                    "none"
-                } else if openRouterHasConfigToken, openRouterHasEnvToken {
-                    "settings-config (overrides env)"
-                } else if openRouterHasConfigToken {
-                    "settings-config"
-                } else {
-                    resolution?.source.rawValue ?? "environment"
+            let buildText = {
+                switch provider {
+                case .codex:
+                    return await codexFetcher.debugRawRateLimits()
+                case .openai:
+                    return Self.apiKeyDebugLine(openAIDebugContext)
+                case .azureopenai:
+                    return Self.apiKeyDebugLine(azureOpenAIDebugContext)
+                case .claude:
+                    guard let claudeDebugConfiguration else {
+                        return "Claude debug log configuration unavailable"
+                    }
+                    return await claudeDebugExecutionContext.apply {
+                        await Self.debugClaudeLog(
+                            browserDetection: browserDetection,
+                            configuration: claudeDebugConfiguration)
+                    }
+                case .zai:
+                    let resolution = ProviderTokenResolver.zaiResolution()
+                    let hasAny = resolution != nil
+                    let source = resolution?.source.rawValue ?? "none"
+                    return "Z_AI_API_KEY=\(hasAny ? "present" : "missing") source=\(source)"
+                case .synthetic:
+                    let resolution = ProviderTokenResolver.syntheticResolution()
+                    let hasAny = resolution != nil
+                    let source = resolution?.source.rawValue ?? "none"
+                    return "SYNTHETIC_API_KEY=\(hasAny ? "present" : "missing") source=\(source)"
+                case .cursor:
+                    return await Self.debugCursorLog(
+                        browserDetection: browserDetection,
+                        cursorCookieSource: cursorCookieSource,
+                        cursorCookieHeader: cursorCookieHeader)
+                case .minimax:
+                    let tokenResolution = ProviderTokenResolver.minimaxTokenResolution()
+                    let cookieResolution = ProviderTokenResolver.minimaxCookieResolution()
+                    let tokenSource = tokenResolution?.source.rawValue ?? "none"
+                    let cookieSource = cookieResolution?.source.rawValue ?? "none"
+                    return "MINIMAX_API_KEY=\(tokenResolution == nil ? "missing" : "present") " +
+                        "source=\(tokenSource) MINIMAX_COOKIE=\(cookieResolution == nil ? "missing" : "present") " +
+                        "source=\(cookieSource)"
+                case .alibaba:
+                    let resolution = ProviderTokenResolver.alibabaTokenResolution()
+                    let hasAny = resolution != nil
+                    let source = resolution?.source.rawValue ?? "none"
+                    return "ALIBABA_CODING_PLAN_API_KEY=\(hasAny ? "present" : "missing") source=\(source)"
+                case .augment:
+                    return await Self.debugAugmentLog()
+                case .amp:
+                    return await Self.debugAmpLog(
+                        browserDetection: browserDetection,
+                        ampCookieSource: ampCookieSource,
+                        ampCookieHeader: ampCookieHeader)
+                case .ollama:
+                    return await Self.debugOllamaLog(
+                        browserDetection: browserDetection,
+                        ollamaCookieSource: ollamaCookieSource,
+                        ollamaCookieHeader: ollamaCookieHeader)
+                case .openrouter:
+                    return Self.apiKeyDebugLine(openRouterDebugContext)
+                case .elevenlabs:
+                    return Self.apiKeyDebugLine(elevenLabsDebugContext)
+                case .warp:
+                    let resolution = ProviderTokenResolver.warpResolution()
+                    let hasAny = resolution != nil
+                    let source = resolution?.source.rawValue ?? "none"
+                    return "WARP_API_KEY=\(hasAny ? "present" : "missing") source=\(source)"
+                case .deepseek:
+                    return Self.apiKeyDebugLine(
+                        label: "DEEPSEEK_API_KEY",
+                        resolution: ProviderTokenResolver.deepseekResolution(environment: deepSeekEnvironment),
+                        configToken: nil,
+                        hasEnvToken: deepSeekHasEnvToken,
+                        hasTokenAccount: deepSeekHasTokenAccount)
+                case .gemini, .antigravity, .opencode, .opencodego, .alibabatokenplan, .factory, .copilot, .devin,
+                     .vertexai, .kilo, .kiro, .kimi, .kimik2, .moonshot, .jetbrains, .perplexity, .mimo, .doubao,
+                     .abacus, .mistral, .codebuff, .crof, .windsurf, .venice, .manus, .commandcode, .stepfun, .bedrock,
+                     .grok, .groq, .t3chat, .llmproxy, .litellm, .zed, .deepgram, .poe, .chutes:
+                    return unimplementedDebugLogMessages[provider] ?? "Debug log not yet implemented"
                 }
-                text = "OPENROUTER_API_KEY=\(hasAny ? "present" : "missing") source=\(source)"
-            case .warp:
-                let resolution = ProviderTokenResolver.warpResolution()
-                let hasAny = resolution != nil
-                let source = resolution?.source.rawValue ?? "none"
-                text = "WARP_API_KEY=\(hasAny ? "present" : "missing") source=\(source)"
-            case .gemini, .antigravity, .opencode, .factory, .copilot, .vertexai, .kilo, .kiro, .kimi, .kimik2,
-                 .jetbrains:
-                text = unimplementedDebugLogMessages[provider] ?? "Debug log not yet implemented"
             }
-
-            await MainActor.run { self.probeLogs[provider] = text }
-            return text
+            return await claudeDebugExecutionContext.apply {
+                await buildText()
+            }
         }.value
+        self.probeLogs[provider] = text
+        return text
     }
 
-    private func debugClaudeLog(
-        claudeWebExtrasEnabled: Bool,
-        claudeUsageDataSource: ClaudeUsageDataSource,
-        claudeCookieSource: ProviderCookieSource,
-        claudeCookieHeader: String,
-        keepCLISessionsAlive: Bool) async -> String
+    private func makeClaudeDebugConfiguration(
+        fallbackUsageDataSource: ClaudeUsageDataSource,
+        fallbackWebExtrasEnabled: Bool,
+        fallbackCookieSource: ProviderCookieSource,
+        fallbackCookieHeader: String) async -> ClaudeDebugLogConfiguration
     {
-        struct OAuthDebugProbe: Sendable {
-            let hasCredentials: Bool
-            let ownerRawValue: String
-            let sourceRawValue: String
-            let isExpired: Bool
+        await MainActor.run {
+            let sourceMode = self.sourceMode(for: .claude)
+            let snapshot = ProviderRegistry.makeSettingsSnapshot(settings: self.settings, tokenOverride: nil)
+            let environment = ProviderRegistry.makeEnvironment(
+                base: self.environmentBase,
+                provider: .claude,
+                settings: self.settings,
+                tokenOverride: nil)
+            let claudeSettings = snapshot.claude ?? ProviderSettingsSnapshot.ClaudeProviderSettings(
+                usageDataSource: fallbackUsageDataSource,
+                webExtrasEnabled: fallbackWebExtrasEnabled,
+                cookieSource: fallbackCookieSource,
+                manualCookieHeader: fallbackCookieHeader)
+            return ClaudeDebugLogConfiguration(
+                runtime: CodexBarCore.ProviderRuntime.app,
+                sourceMode: sourceMode,
+                environment: environment,
+                webExtrasEnabled: claudeSettings.webExtrasEnabled,
+                usageDataSource: claudeSettings.usageDataSource,
+                cookieSource: claudeSettings.cookieSource,
+                cookieHeader: claudeSettings.manualCookieHeader ?? "",
+                keepCLISessionsAlive: snapshot.debugKeepCLISessionsAlive)
         }
+    }
 
-        return await self.runWithTimeout(seconds: 15) {
-            var lines: [String] = []
-            let manualHeader = claudeCookieSource == .manual
-                ? CookieHeaderNormalizer.normalize(claudeCookieHeader)
-                : nil
-            let hasKey = if let manualHeader {
-                ClaudeWebAPIFetcher.hasSessionKey(cookieHeader: manualHeader)
-            } else {
-                ClaudeWebAPIFetcher.hasSessionKey(browserDetection: self.browserDetection) { msg in lines.append(msg) }
-            }
-            // Run potentially blocking keychain probes off MainActor so debug dumps don't stall UI rendering.
-            let oauthProbe = await Task.detached(priority: .utility) {
-                // Don't prompt for keychain access during debug dump.
-                let oauthRecord = try? ClaudeOAuthCredentialsStore.loadRecord(
-                    allowKeychainPrompt: false,
-                    respectKeychainPromptCooldown: true,
-                    allowClaudeKeychainRepairWithoutPrompt: false)
-                return OAuthDebugProbe(
-                    hasCredentials: oauthRecord?.credentials.scopes.contains("user:profile") == true,
-                    ownerRawValue: oauthRecord?.owner.rawValue ?? "none",
-                    sourceRawValue: oauthRecord?.source.rawValue ?? "none",
-                    isExpired: oauthRecord?.credentials.isExpired ?? false)
-            }.value
-            let hasOAuthCredentials = oauthProbe.hasCredentials
-            let hasClaudeBinary = ClaudeOAuthDelegatedRefreshCoordinator.isClaudeCLIAvailable()
-            let delegatedCooldownSeconds = ClaudeOAuthDelegatedRefreshCoordinator.cooldownRemainingSeconds()
-
-            let strategy = ClaudeProviderDescriptor.resolveUsageStrategy(
-                selectedDataSource: claudeUsageDataSource,
-                webExtrasEnabled: claudeWebExtrasEnabled,
-                hasWebSession: hasKey,
-                hasCLI: hasClaudeBinary,
-                hasOAuthCredentials: hasOAuthCredentials)
-
-            if claudeUsageDataSource == .auto {
-                lines.append("pipeline_order=oauth→cli→web")
-                lines.append("auto_heuristic=\(strategy.dataSource.rawValue)")
-            } else {
-                lines.append("strategy=\(strategy.dataSource.rawValue)")
-            }
-            lines.append("hasSessionKey=\(hasKey)")
-            lines.append("hasOAuthCredentials=\(hasOAuthCredentials)")
-            lines.append("oauthCredentialOwner=\(oauthProbe.ownerRawValue)")
-            lines.append("oauthCredentialSource=\(oauthProbe.sourceRawValue)")
-            lines.append("oauthCredentialExpired=\(oauthProbe.isExpired)")
-            lines.append("delegatedRefreshCLIAvailable=\(hasClaudeBinary)")
-            lines.append("delegatedRefreshCooldownActive=\(delegatedCooldownSeconds != nil)")
-            if let delegatedCooldownSeconds {
-                lines.append("delegatedRefreshCooldownSeconds=\(delegatedCooldownSeconds)")
-            }
-            lines.append("hasClaudeBinary=\(hasClaudeBinary)")
-            if strategy.useWebExtras {
-                lines.append("web_extras=enabled")
-            }
-            lines.append("")
-
-            switch strategy.dataSource {
-            case .auto:
-                lines.append("Auto source selected.")
-                return lines.joined(separator: "\n")
-            case .web:
-                do {
-                    let web = try await ClaudeWebAPIFetcher
-                        .fetchUsage(browserDetection: self.browserDetection) { msg in lines.append(msg) }
-                    lines.append("")
-                    lines.append("Web API summary:")
-
-                    let sessionReset = web.sessionResetsAt?.description ?? "nil"
-                    lines.append("session_used=\(web.sessionPercentUsed)% resetsAt=\(sessionReset)")
-
-                    if let weekly = web.weeklyPercentUsed {
-                        let weeklyReset = web.weeklyResetsAt?.description ?? "nil"
-                        lines.append("weekly_used=\(weekly)% resetsAt=\(weeklyReset)")
-                    } else {
-                        lines.append("weekly_used=nil")
-                    }
-
-                    lines.append("opus_used=\(web.opusPercentUsed?.description ?? "nil")")
-
-                    if let extra = web.extraUsageCost {
-                        let resetsAt = extra.resetsAt?.description ?? "nil"
-                        let period = extra.period ?? "nil"
-                        let line =
-                            "extra_usage used=\(extra.used) limit=\(extra.limit) " +
-                            "currency=\(extra.currencyCode) period=\(period) resetsAt=\(resetsAt)"
-                        lines.append(line)
-                    } else {
-                        lines.append("extra_usage=nil")
+    private struct ClaudeDebugExecutionContext {
+        let interaction: ProviderInteraction
+        let refreshPhase: ProviderRefreshPhase
+        #if DEBUG
+        let keychainServiceOverride: String?
+        let credentialsURLOverride: URL?
+        let testingOverrides: ClaudeOAuthCredentialsStore.TestingOverridesSnapshot
+        let keychainDeniedUntilStoreOverride: ClaudeOAuthKeychainAccessGate.DeniedUntilStore?
+        let keychainPromptModeOverride: ClaudeOAuthKeychainPromptMode?
+        let keychainReadStrategyOverride: ClaudeOAuthKeychainReadStrategy?
+        let cliPathOverride: String?
+        let statusFetchOverride: ClaudeStatusProbe.FetchOverride?
+        #endif
+
+        func apply<T>(_ operation: () async -> T) async -> T {
+            await ProviderInteractionContext.$current.withValue(self.interaction) {
+                await ProviderRefreshContext.$current.withValue(self.refreshPhase) {
+                    #if DEBUG
+                    return await KeychainCacheStore.withServiceOverrideForTesting(self.keychainServiceOverride) {
+                        await ClaudeOAuthCredentialsStore
+                            .withCredentialsURLOverrideForTesting(self.credentialsURLOverride) {
+                                await ClaudeOAuthCredentialsStore
+                                    .withTestingOverridesSnapshotForTask(self.testingOverrides) {
+                                        await ClaudeOAuthKeychainAccessGate
+                                            .withDeniedUntilStoreOverrideForTesting(self
+                                                .keychainDeniedUntilStoreOverride)
+                                            {
+                                                await ClaudeOAuthKeychainPromptPreference
+                                                    .withTaskOverrideForTesting(self.keychainPromptModeOverride) {
+                                                        await ClaudeOAuthKeychainReadStrategyPreference
+                                                            .withTaskOverrideForTesting(self
+                                                                .keychainReadStrategyOverride)
+                                                            {
+                                                                await ClaudeCLIResolver
+                                                                    .withResolvedBinaryPathOverrideForTesting(self
+                                                                        .cliPathOverride)
+                                                                    {
+                                                                        await ClaudeStatusProbe
+                                                                            .withFetchOverrideForTesting(self
+                                                                                .statusFetchOverride)
+                                                                            {
+                                                                                await operation()
+                                                                            }
+                                                                    }
+                                                            }
+                                                    }
+                                            }
+                                    }
+                            }
                     }
-
-                    return lines.joined(separator: "\n")
-                } catch {
-                    lines.append("Web API failed: \(error.localizedDescription)")
-                    return lines.joined(separator: "\n")
+                    #else
+                    return await operation()
+                    #endif
                 }
-            case .cli:
-                let fetcher = ClaudeUsageFetcher(
-                    browserDetection: self.browserDetection,
-                    keepCLISessionsAlive: keepCLISessionsAlive)
-                let cli = await fetcher.debugRawProbe(model: "sonnet")
-                lines.append(cli)
-                return lines.joined(separator: "\n")
-            case .oauth:
-                lines.append("OAuth source selected.")
-                return lines.joined(separator: "\n")
             }
         }
     }
 
-    private func debugCursorLog(
+    private func currentClaudeDebugExecutionContext() -> ClaudeDebugExecutionContext {
+        #if DEBUG
+        ClaudeDebugExecutionContext(
+            interaction: ProviderInteractionContext.current,
+            refreshPhase: ProviderRefreshContext.current,
+            keychainServiceOverride: KeychainCacheStore.currentServiceOverrideForTesting,
+            credentialsURLOverride: ClaudeOAuthCredentialsStore.currentCredentialsURLOverrideForTesting,
+            testingOverrides: ClaudeOAuthCredentialsStore.currentTestingOverridesSnapshotForTask,
+            keychainDeniedUntilStoreOverride: ClaudeOAuthKeychainAccessGate.currentDeniedUntilStoreOverrideForTesting,
+            keychainPromptModeOverride: ClaudeOAuthKeychainPromptPreference.currentTaskOverrideForTesting,
+            keychainReadStrategyOverride: ClaudeOAuthKeychainReadStrategyPreference.currentTaskOverrideForTesting,
+            cliPathOverride: ClaudeCLIResolver.currentResolvedBinaryPathOverrideForTesting,
+            statusFetchOverride: ClaudeStatusProbe.currentFetchOverrideForTesting)
+        #else
+        ClaudeDebugExecutionContext(
+            interaction: ProviderInteractionContext.current,
+            refreshPhase: ProviderRefreshContext.current)
+        #endif
+    }
+
+    private struct APIKeyDebugContext {
+        let label: String
+        let resolution: ProviderTokenResolution?
+        let configToken: String?
+        let hasEnvToken: Bool
+        let hasTokenAccount: Bool
+    }
+
+    private func openAIAPIKeyDebugContext(processEnvironment: [String: String]) -> APIKeyDebugContext {
+        let config = self.settings.providerConfig(for: .openai)
+        let environment = ProviderConfigEnvironment.applyAPIKeyOverride(
+            base: processEnvironment,
+            provider: .openai,
+            config: config)
+        return APIKeyDebugContext(
+            label: "OPENAI_API_KEY",
+            resolution: ProviderTokenResolver.openAIAPIResolution(environment: environment),
+            configToken: config?.sanitizedAPIKey,
+            hasEnvToken: OpenAIAPISettingsReader.apiKey(environment: processEnvironment) != nil,
+            hasTokenAccount: false)
+    }
+
+    private func azureOpenAIAPIKeyDebugContext(processEnvironment: [String: String]) -> APIKeyDebugContext {
+        let config = self.settings.providerConfig(for: .azureopenai)
+        let environment = ProviderConfigEnvironment.applyProviderConfigOverrides(
+            base: processEnvironment,
+            provider: .azureopenai,
+            config: config)
+        return APIKeyDebugContext(
+            label: "AZURE_OPENAI_API_KEY",
+            resolution: ProviderTokenResolver.azureOpenAIResolution(environment: environment),
+            configToken: config?.sanitizedAPIKey,
+            hasEnvToken: AzureOpenAISettingsReader.apiKey(environment: processEnvironment) != nil,
+            hasTokenAccount: false)
+    }
+
+    private func openRouterAPIKeyDebugContext(processEnvironment: [String: String]) -> APIKeyDebugContext {
+        let config = self.settings.providerConfig(for: .openrouter)
+        let environment = ProviderConfigEnvironment.applyAPIKeyOverride(
+            base: processEnvironment,
+            provider: .openrouter,
+            config: config)
+        return APIKeyDebugContext(
+            label: "OPENROUTER_API_KEY",
+            resolution: ProviderTokenResolver.openRouterResolution(environment: environment),
+            configToken: config?.sanitizedAPIKey,
+            hasEnvToken: OpenRouterSettingsReader.apiToken(environment: processEnvironment) != nil,
+            hasTokenAccount: false)
+    }
+
+    private func elevenLabsAPIKeyDebugContext(processEnvironment: [String: String]) -> APIKeyDebugContext {
+        let config = self.settings.providerConfig(for: .elevenlabs)
+        let environment = ProviderConfigEnvironment.applyAPIKeyOverride(
+            base: processEnvironment,
+            provider: .elevenlabs,
+            config: config)
+        return APIKeyDebugContext(
+            label: "ELEVENLABS_API_KEY",
+            resolution: ProviderTokenResolver.elevenLabsResolution(environment: environment),
+            configToken: config?.sanitizedAPIKey,
+            hasEnvToken: ElevenLabsSettingsReader.apiKey(environment: processEnvironment) != nil,
+            hasTokenAccount: false)
+    }
+
+    private nonisolated static func apiKeyDebugLine(_ context: APIKeyDebugContext) -> String {
+        self.apiKeyDebugLine(
+            label: context.label,
+            resolution: context.resolution,
+            configToken: context.configToken,
+            hasEnvToken: context.hasEnvToken,
+            hasTokenAccount: context.hasTokenAccount)
+    }
+
+    private nonisolated static func apiKeyDebugLine(
+        label: String,
+        resolution: ProviderTokenResolution?,
+        configToken: String?,
+        hasEnvToken: Bool,
+        hasTokenAccount: Bool = false) -> String
+    {
+        let hasAny = resolution != nil
+        let hasConfigToken = !(configToken?.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty ?? true)
+        let source: String = if resolution == nil {
+            "none"
+        } else if hasTokenAccount, hasEnvToken {
+            "settings-token-account (overrides env)"
+        } else if hasTokenAccount {
+            "settings-token-account"
+        } else if hasConfigToken, hasEnvToken {
+            "settings-config (overrides env)"
+        } else if hasConfigToken {
+            "settings-config"
+        } else {
+            resolution?.source.rawValue ?? "environment"
+        }
+        return "\(label)=\(hasAny ? "present" : "missing") source=\(source)"
+    }
+
+    private static func debugCursorLog(
+        browserDetection: BrowserDetection,
         cursorCookieSource: ProviderCookieSource,
         cursorCookieHeader: String) async -> String
     {
-        await self.runWithTimeout(seconds: 15) {
+        await runWithTimeout(seconds: 15) {
             var lines: [String] = []
 
             do {
-                let probe = CursorStatusProbe(browserDetection: self.browserDetection)
+                let probe = CursorStatusProbe(browserDetection: browserDetection)
                 let snapshot: CursorStatusSnapshot = if cursorCookieSource == .manual,
                                                         let normalizedHeader = CookieHeaderNormalizer
                                                             .normalize(cursorCookieHeader)
@@ -1423,19 +1356,20 @@ extension UsageStore {
         }
     }
 
-    private func debugAugmentLog() async -> String {
-        await self.runWithTimeout(seconds: 15) {
+    private static func debugAugmentLog() async -> String {
+        await runWithTimeout(seconds: 15) {
             let probe = AugmentStatusProbe()
             return await probe.debugRawProbe()
         }
     }
 
-    private func debugAmpLog(
+    private static func debugAmpLog(
+        browserDetection: BrowserDetection,
         ampCookieSource: ProviderCookieSource,
         ampCookieHeader: String) async -> String
     {
-        await self.runWithTimeout(seconds: 15) {
-            let fetcher = AmpUsageFetcher(browserDetection: self.browserDetection)
+        await runWithTimeout(seconds: 15) {
+            let fetcher = AmpUsageFetcher(browserDetection: browserDetection)
             let manualHeader = ampCookieSource == .manual
                 ? CookieHeaderNormalizer.normalize(ampCookieHeader)
                 : nil
@@ -1443,12 +1377,13 @@ extension UsageStore {
         }
     }
 
-    private func debugOllamaLog(
+    private static func debugOllamaLog(
+        browserDetection: BrowserDetection,
         ollamaCookieSource: ProviderCookieSource,
         ollamaCookieHeader: String) async -> String
     {
-        await self.runWithTimeout(seconds: 15) {
-            let fetcher = OllamaUsageFetcher(browserDetection: self.browserDetection)
+        await runWithTimeout(seconds: 15) {
+            let fetcher = OllamaUsageFetcher(browserDetection: browserDetection)
             let manualHeader = ollamaCookieSource == .manual
                 ? CookieHeaderNormalizer.normalize(ollamaCookieHeader)
                 : nil
@@ -1458,19 +1393,6 @@ extension UsageStore {
         }
     }
 
-    private func runWithTimeout(seconds: Double, operation: @escaping @Sendable () async -> String) async -> String {
-        await withTaskGroup(of: String?.self) { group -> String in
-            group.addTask { await operation() }
-            group.addTask {
-                try? await Task.sleep(nanoseconds: UInt64(seconds * 1_000_000_000))
-                return nil
-            }
-            let result = await group.next()?.flatMap(\.self)
-            group.cancelAll()
-            return result ?? "Probe timed out after \(Int(seconds))s"
-        }
-    }
-
     private func detectVersions() {
         let implementations = ProviderCatalog.all
         let browserDetection = self.browserDetection
@@ -1525,40 +1447,27 @@ extension UsageStore {
         }
     }
 
-    func clearCostUsageCache() async -> String? {
-        let errorMessage: String? = await Task.detached(priority: .utility) {
-            let fm = FileManager.default
-            let cacheDirs = [
-                Self.costUsageCacheDirectory(fileManager: fm),
-            ]
-
-            for cacheDir in cacheDirs {
-                do {
-                    try fm.removeItem(at: cacheDir)
-                } catch let error as NSError {
-                    if error.domain == NSCocoaErrorDomain, error.code == NSFileNoSuchFileError { continue }
-                    return error.localizedDescription
-                }
-            }
-            return nil
-        }.value
-
-        guard errorMessage == nil else { return errorMessage }
-
-        self.tokenSnapshots.removeAll()
-        self.tokenErrors.removeAll()
-        self.lastTokenFetchAt.removeAll()
-        self.tokenFailureGates[.codex]?.reset()
-        self.tokenFailureGates[.claude]?.reset()
-        return nil
-    }
-
     private func refreshTokenUsage(_ provider: UsageProvider, force: Bool) async {
-        guard provider == .codex || provider == .claude || provider == .vertexai else {
+        guard ProviderDescriptorRegistry.descriptor(for: provider).tokenCost.supportsTokenCost else {
             self.tokenSnapshots.removeValue(forKey: provider)
             self.tokenErrors[provider] = nil
             self.tokenFailureGates[provider]?.reset()
             self.lastTokenFetchAt.removeValue(forKey: provider)
+            self.lastTokenFetchScope.removeValue(forKey: provider)
+            return
+        }
+
+        if Self.tokenCostRequiresProviderSnapshot(provider) {
+            if let snapshot = self.tokenSnapshot(fromProviderSnapshot: self.snapshots[provider], provider: provider) {
+                self.tokenSnapshots[provider] = snapshot
+                self.tokenErrors[provider] = nil
+                self.tokenFailureGates[provider]?.recordSuccess()
+                self.persistWidgetSnapshot(reason: "token-usage")
+            } else {
+                self.tokenSnapshots.removeValue(forKey: provider)
+                self.tokenErrors[provider] = nil
+                self.tokenFailureGates[provider]?.reset()
+            }
             return
         }
 
@@ -1567,6 +1476,7 @@ extension UsageStore {
             self.tokenErrors[provider] = nil
             self.tokenFailureGates[provider]?.reset()
             self.lastTokenFetchAt.removeValue(forKey: provider)
+            self.lastTokenFetchScope.removeValue(forKey: provider)
             return
         }
 
@@ -1575,22 +1485,37 @@ extension UsageStore {
             self.tokenErrors[provider] = nil
             self.tokenFailureGates[provider]?.reset()
             self.lastTokenFetchAt.removeValue(forKey: provider)
+            self.lastTokenFetchScope.removeValue(forKey: provider)
             return
         }
 
         guard !self.tokenRefreshInFlight.contains(provider) else { return }
 
         let now = Date()
+        let historyDays = self.settings.costUsageHistoryDays
+        let costScope = self.tokenCostScope(for: provider)
+        let costScopeSignature = "\(costScope.signature)|historyDays=\(historyDays)"
         if !force,
            let last = self.lastTokenFetchAt[provider],
+           self.lastTokenFetchScope[provider] == costScopeSignature,
            now.timeIntervalSince(last) < self.tokenFetchTTL
         {
             return
         }
         self.lastTokenFetchAt[provider] = now
+        self.lastTokenFetchScope[provider] = costScopeSignature
         self.tokenRefreshInFlight.insert(provider)
         defer { self.tokenRefreshInFlight.remove(provider) }
 
+        if let override = self._test_tokenUsageRefreshOverride {
+            await override(provider, force)
+            if Task.isCancelled {
+                self.lastTokenFetchAt.removeValue(forKey: provider)
+                self.lastTokenFetchScope.removeValue(forKey: provider)
+            }
+            return
+        }
+
         let startedAt = Date()
         let providerText = provider.rawValue
         self.tokenCostLogger
@@ -1599,13 +1524,28 @@ extension UsageStore {
         do {
             let fetcher = self.costUsageFetcher
             let timeoutSeconds = self.tokenFetchTimeout
+            let environment = provider == .bedrock
+                ? ProviderRegistry.makeEnvironment(
+                    base: self.environmentBase,
+                    provider: provider,
+                    settings: self.settings,
+                    tokenOverride: nil)
+                : self.environmentBase
+            // Codex cost usage scans local session logs from this machine. That data is
+            // intentionally presented as provider-level local telemetry rather than managed-account
+            // remote state, so managed Codex account selection does not retarget that fetch.
+            // If the UI later needs account-scoped token history, it should label and source that
+            // separately instead of silently changing the meaning of this section.
             let snapshot = try await withThrowingTaskGroup(of: CostUsageTokenSnapshot.self) { group in
                 group.addTask(priority: .utility) {
                     try await fetcher.loadTokenSnapshot(
                         provider: provider,
+                        environment: environment,
                         now: now,
                         forceRefresh: force,
-                        allowVertexClaudeFallback: !self.isEnabled(.claude))
+                        allowVertexClaudeFallback: !self.isEnabled(.claude),
+                        codexHomePath: costScope.codexHomePath,
+                        historyDays: historyDays)
                 }
                 group.addTask {
                     try await Task.sleep(nanoseconds: UInt64(timeoutSeconds * 1_000_000_000))
@@ -1615,6 +1555,7 @@ extension UsageStore {
                 guard let snapshot = try await group.next() else { throw CancellationError() }
                 return snapshot
             }
+            try Task.checkCancellation()
 
             guard !snapshot.daily.isEmpty else {
                 self.tokenSnapshots.removeValue(forKey: provider)
@@ -1623,21 +1564,27 @@ extension UsageStore {
                 return
             }
             let duration = Date().timeIntervalSince(startedAt)
-            let sessionCost = snapshot.sessionCostUSD.map(UsageFormatter.usdString) ?? "—"
-            let monthCost = snapshot.last30DaysCostUSD.map(UsageFormatter.usdString) ?? "—"
+            let sessionCost = snapshot.sessionCostUSD
+                .map { UsageFormatter.currencyString($0, currencyCode: snapshot.currencyCode) } ?? "—"
+            let monthCost = snapshot.last30DaysCostUSD
+                .map { UsageFormatter.currencyString($0, currencyCode: snapshot.currencyCode) } ?? "—"
             let durationText = String(format: "%.2f", duration)
             let message =
                 "cost usage success provider=\(providerText) " +
                 "duration=\(durationText)s " +
                 "today=\(sessionCost) " +
-                "30d=\(monthCost)"
+                "historyDays=\(historyDays) windowCost=\(monthCost)"
             self.tokenCostLogger.info(message)
             self.tokenSnapshots[provider] = snapshot
             self.tokenErrors[provider] = nil
             self.tokenFailureGates[provider]?.recordSuccess()
             self.persistWidgetSnapshot(reason: "token-usage")
         } catch {
-            if error is CancellationError { return }
+            if error is CancellationError {
+                self.lastTokenFetchAt.removeValue(forKey: provider)
+                self.lastTokenFetchScope.removeValue(forKey: provider)
+                return
+            }
             let duration = Date().timeIntervalSince(startedAt)
             let msg = error.localizedDescription
             let durationText = String(format: "%.2f", duration)
diff --git a/Sources/CodexBar/UsageStoreSupport.swift b/Sources/CodexBar/UsageStoreSupport.swift
index 522416898a..3ac92fc59e 100644
--- a/Sources/CodexBar/UsageStoreSupport.swift
+++ b/Sources/CodexBar/UsageStoreSupport.swift
@@ -18,12 +18,12 @@ enum ProviderStatusIndicator: String {
 
     var label: String {
         switch self {
-        case .none: "Operational"
-        case .minor: "Partial outage"
-        case .major: "Major outage"
-        case .critical: "Critical issue"
-        case .maintenance: "Maintenance"
-        case .unknown: "Status unknown"
+        case .none: L("status_operational")
+        case .minor: L("status_partial_outage")
+        case .major: L("status_major_outage")
+        case .critical: L("status_critical_issue")
+        case .maintenance: L("status_maintenance")
+        case .unknown: L("status_unknown")
         }
     }
 }
diff --git a/Sources/CodexBar/ZaiHourlyUsageChartMenuView.swift b/Sources/CodexBar/ZaiHourlyUsageChartMenuView.swift
new file mode 100644
index 0000000000..4e1ec437c4
--- /dev/null
+++ b/Sources/CodexBar/ZaiHourlyUsageChartMenuView.swift
@@ -0,0 +1,251 @@
+import CodexBarCore
+import SwiftUI
+
+@MainActor
+struct ZaiHourlyUsageChartMenuView: View {
+    private let modelUsage: ZaiModelUsageData
+    private let width: CGFloat
+
+    @State private var selectedRange: RangeOption = .today
+    @State private var isExpanded = true
+    @State private var hoveredBarIndex: Int?
+
+    private enum RangeOption: Int, CaseIterable {
+        case today = 0
+        case last24h = 1
+    }
+
+    private let barHeight: CGFloat = 60
+    private let barGap: CGFloat = 2
+    private let maxLabelCount = 5
+
+    private let colorPalette: [Color] = [
+        Color(red: 10 / 255, green: 132 / 255, blue: 1),
+        Color(red: 255 / 255, green: 159 / 255, blue: 10 / 255),
+        Color(red: 48 / 255, green: 209 / 255, blue: 88 / 255),
+        Color(red: 94 / 255, green: 92 / 255, blue: 230 / 255),
+        Color(red: 100 / 255, green: 210 / 255, blue: 255 / 255),
+        Color(red: 255 / 255, green: 55 / 255, blue: 95 / 255),
+    ]
+
+    init(modelUsage: ZaiModelUsageData, width: CGFloat) {
+        self.modelUsage = modelUsage
+        self.width = width
+    }
+
+    private var range: ZaiHourlyRange {
+        switch self.selectedRange {
+        case .today: .today(referenceDate: Date())
+        case .last24h: .last24h
+        }
+    }
+
+    private var bars: [ZaiHourlyBar] {
+        ZaiHourlyBars.from(modelData: self.modelUsage, range: self.range)
+    }
+
+    private var modelNames: [String] {
+        self.modelUsage.modelNames
+    }
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 0) {
+            HStack(spacing: 4) {
+                Button(
+                    action: { withAnimation(.easeInOut(duration: 0.2)) { self.isExpanded.toggle() } },
+                    label: {
+                        Image(systemName: self.isExpanded ? "chevron.down" : "chevron.right")
+                            .font(.system(size: 8))
+                            .foregroundColor(.secondary)
+                            .frame(width: 10)
+                    })
+                    .buttonStyle(.plain)
+
+                Text(L("Hourly Tokens"))
+                    .font(.system(size: 11, weight: .semibold))
+                    .foregroundColor(.primary)
+
+                Spacer()
+
+                if self.isExpanded {
+                    self.rangeToggle
+                }
+            }
+
+            if self.isExpanded {
+                VStack(alignment: .leading, spacing: 4) {
+                    if self.bars.isEmpty {
+                        Text(L("No data"))
+                            .font(.system(size: 10))
+                            .foregroundColor(.secondary)
+                            .frame(maxWidth: .infinity, alignment: .center)
+                            .padding(.vertical, 16)
+                    } else {
+                        GeometryReader { geometry in
+                            let barWidth = max(
+                                (geometry.size.width - self.barGap * CGFloat(max(self.bars.count - 1, 0)))
+                                    / CGFloat(self.bars.count),
+                                2)
+                            HStack(alignment: .bottom, spacing: self.barGap) {
+                                ForEach(Array(self.bars.enumerated()), id: \.offset) { index, bar in
+                                    VStack(spacing: 0) {
+                                        Spacer(minLength: 0)
+                                        self.barStack(bar: bar, barWidth: barWidth, maxTotal: self.maxTotal)
+                                    }
+                                    .frame(width: barWidth, height: self.barHeight)
+                                    .contentShape(Rectangle())
+                                    .onHover { hovering in
+                                        self.hoveredBarIndex = hovering ? index : nil
+                                    }
+                                    .overlay(alignment: .bottom) {
+                                        if self.hoveredBarIndex == index {
+                                            self.tooltipOverlay(bar: bar)
+                                        }
+                                    }
+                                }
+                            }
+                            .frame(height: self.barHeight)
+                        }
+                        .frame(height: self.barHeight)
+
+                        self.legend
+                        self.xAxisLabels
+                    }
+                }
+                .padding(.top, 6)
+                .transition(.opacity.combined(with: .move(edge: .top)))
+            }
+        }
+        .padding(.horizontal, 16)
+        .padding(.vertical, 10)
+        .frame(minWidth: self.width, maxWidth: .infinity, alignment: .topLeading)
+        .animation(.easeInOut(duration: 0.2), value: self.isExpanded)
+    }
+
+    private var maxTotal: Int {
+        self.bars.map(\.totalTokens).max() ?? 1
+    }
+
+    private var rangeToggle: some View {
+        Picker("", selection: Binding(
+            get: { self.selectedRange.rawValue },
+            set: { self.selectedRange = RangeOption(rawValue: $0) ?? .today }))
+        {
+            Text(L("Today")).tag(RangeOption.today.rawValue)
+            Text("24h").tag(RangeOption.last24h.rawValue)
+        }
+        .pickerStyle(.segmented)
+        .frame(width: 100)
+        .scaleEffect(0.8)
+        .frame(width: 80, height: 16)
+    }
+
+    @ViewBuilder
+    private func barStack(bar: ZaiHourlyBar, barWidth: CGFloat, maxTotal: Int) -> some View {
+        let scaleFactor = CGFloat(bar.totalTokens) / CGFloat(max(maxTotal, 1))
+
+        VStack(spacing: 0) {
+            ForEach(Array(bar.segments.enumerated()), id: \.offset) { segIndex, segment in
+                let segFraction = CGFloat(segment.tokens) / CGFloat(max(bar.totalTokens, 1))
+                let segHeight = max(
+                    self.barHeight * scaleFactor * segFraction,
+                    segment.tokens > 0 ? 1 : 0)
+                RoundedRectangle(cornerRadius: segIndex == bar.segments.count - 1 ? 2 : 0)
+                    .fill(self.colorForModel(segment.model))
+                    .frame(height: segHeight)
+            }
+        }
+        .clipShape(RoundedRectangle(cornerRadius: 2))
+    }
+
+    private func tooltipOverlay(bar: ZaiHourlyBar) -> some View {
+        VStack(alignment: .leading, spacing: 1) {
+            Text(bar.label + ":00")
+                .font(.system(size: 10, weight: .semibold))
+                .foregroundColor(.primary)
+            ForEach(Array(bar.segments.enumerated()), id: \.offset) { _, segment in
+                HStack(spacing: 3) {
+                    Circle()
+                        .fill(self.colorForModel(segment.model))
+                        .frame(width: 5, height: 5)
+                    Text(segment.model)
+                        .font(.system(size: 9))
+                        .foregroundColor(.primary)
+                        .lineLimit(1)
+                        .layoutPriority(1)
+                    Text(self.formatTokenCount(segment.tokens))
+                        .font(.system(size: 9, weight: .medium))
+                        .foregroundColor(.primary)
+                }
+            }
+            Divider()
+                .background(Color.primary.opacity(0.15))
+            Text(self.formatTokenCount(bar.totalTokens))
+                .font(.system(size: 10, weight: .bold))
+                .foregroundColor(.primary)
+        }
+        .padding(6)
+        .frame(minWidth: 90, maxWidth: 140)
+        .background(Color(nsColor: .controlBackgroundColor).opacity(0.95))
+        .background(.ultraThinMaterial)
+        .cornerRadius(6)
+        .shadow(color: .black.opacity(0.2), radius: 4, y: 2)
+        .offset(y: -self.barHeight - 8)
+    }
+
+    private var legend: some View {
+        ScrollView(.horizontal, showsIndicators: false) {
+            HStack(spacing: 8) {
+                ForEach(self.modelNames, id: \.self) { name in
+                    HStack(spacing: 2) {
+                        Circle()
+                            .fill(self.colorForModel(name))
+                            .frame(width: 6, height: 6)
+                        Text(name)
+                            .font(.system(size: 9))
+                            .foregroundColor(.secondary)
+                            .lineLimit(1)
+                    }
+                }
+            }
+        }
+    }
+
+    private var xAxisLabels: some View {
+        HStack(spacing: 0) {
+            ForEach(Array(self.labelIndices.enumerated()), id: \.offset) { _, index in
+                if index < self.bars.count {
+                    Text(self.bars[index].label)
+                        .font(.system(size: 9))
+                        .foregroundColor(.secondary)
+                        .frame(maxWidth: .infinity)
+                }
+            }
+        }
+    }
+
+    private var labelIndices: [Int] {
+        guard self.bars.count > self.maxLabelCount else { return Array(0..<self.bars.count) }
+        let step = max(1, self.bars.count / (self.maxLabelCount - 1))
+        var indices = stride(from: 0, to: self.bars.count, by: step).map(\.self)
+        if indices.last != self.bars.count - 1 {
+            indices.append(self.bars.count - 1)
+        }
+        return indices
+    }
+
+    private func colorForModel(_ name: String) -> Color {
+        let index = self.modelNames.firstIndex(of: name) ?? 0
+        return self.colorPalette[index % self.colorPalette.count]
+    }
+
+    private func formatTokenCount(_ count: Int) -> String {
+        if count >= 1_000_000 {
+            String(format: "%.1fM", Double(count) / 1_000_000)
+        } else if count >= 1000 {
+            String(format: "%.1fk", Double(count) / 1000)
+        } else {
+            "\(count)"
+        }
+    }
+}
diff --git a/Sources/CodexBarCLI/CLICacheCommand.swift b/Sources/CodexBarCLI/CLICacheCommand.swift
new file mode 100644
index 0000000000..78d63e96ec
--- /dev/null
+++ b/Sources/CodexBarCLI/CLICacheCommand.swift
@@ -0,0 +1,152 @@
+import CodexBarCore
+import Commander
+import Foundation
+
+extension CodexBarCLI {
+    static func runCacheClear(_ values: ParsedValues) {
+        let output = CLIOutputPreferences.from(values: values)
+        let cookies = values.flags.contains("cookies")
+        let cost = values.flags.contains("cost")
+        let all = values.flags.contains("all")
+        let rawProvider = values.options["provider"]?.last
+
+        let clearCookies = cookies || all
+        let clearCost = cost || all
+
+        if !clearCookies, !clearCost {
+            Self.exit(
+                code: .failure,
+                message: "Specify --cookies, --cost, or --all.",
+                output: output,
+                kind: .args)
+        }
+        if let error = Self.cacheClearProviderScopeError(rawProvider: rawProvider, clearCost: clearCost) {
+            Self.exit(code: .failure, message: error, output: output, kind: .args)
+        }
+
+        var results: [CacheClearResult] = []
+
+        if clearCookies {
+            if let rawProvider {
+                if let provider = ProviderDescriptorRegistry.cliNameMap[rawProvider.lowercased()] {
+                    let summary = CookieHeaderCache.clearAllScopesDetailed(provider: provider)
+                    results.append(CacheClearResult(
+                        cache: "cookies",
+                        provider: provider.rawValue,
+                        cleared: summary.clearedCount,
+                        error: Self.cookieClearError(failedCount: summary.failedCount)))
+                } else {
+                    Self.exit(
+                        code: .failure,
+                        message: "Unknown provider: \(rawProvider)",
+                        output: output,
+                        kind: .args)
+                }
+            } else {
+                let summary = CookieHeaderCache.clearAllDetailed()
+                results.append(CacheClearResult(
+                    cache: "cookies",
+                    provider: nil,
+                    cleared: summary.clearedCount,
+                    error: Self.cookieClearError(failedCount: summary.failedCount)))
+            }
+        }
+
+        if clearCost {
+            let fm = FileManager.default
+            let cacheDir = Self.costUsageCacheDirectory(fileManager: fm)
+            var cleared = 0
+            var costError: String?
+            if fm.fileExists(atPath: cacheDir.path) {
+                do {
+                    try fm.removeItem(at: cacheDir)
+                    cleared = 1
+                } catch {
+                    costError = error.localizedDescription
+                }
+            }
+            results.append(CacheClearResult(cache: "cost", provider: nil, cleared: cleared, error: costError))
+        }
+
+        switch output.format {
+        case .text:
+            for result in results {
+                let scope = result.provider ?? "all providers"
+                if let error = result.error {
+                    print("\(result.cache): failed to clear (\(scope)) - \(error)")
+                } else if result.cleared > 0 {
+                    print("\(result.cache): cleared (\(scope))")
+                } else {
+                    print("\(result.cache): nothing to clear (\(scope))")
+                }
+            }
+        case .json:
+            Self.printJSON(results, pretty: output.pretty)
+        }
+
+        let hasErrors = results.contains(where: { $0.error != nil })
+        Self.exit(code: hasErrors ? .failure : .success, output: output, kind: .runtime)
+    }
+
+    static func cacheClearProviderScopeError(rawProvider: String?, clearCost: Bool) -> String? {
+        guard rawProvider != nil, clearCost else { return nil }
+        return "--provider only scopes cookie caches. Use --cookies --provider <name>, or omit --provider."
+    }
+
+    private static func cookieClearError(failedCount: Int) -> String? {
+        guard failedCount > 0 else { return nil }
+        return "Cookie cache cleanup failed for \(failedCount) operation\(failedCount == 1 ? "" : "s")"
+    }
+}
+
+struct CacheOptions: CommanderParsable {
+    @Flag(names: [.short("v"), .long("verbose")], help: "Enable verbose logging")
+    var verbose: Bool = false
+
+    @Flag(name: .long("json-output"), help: "Emit machine-readable logs")
+    var jsonOutput: Bool = false
+
+    @Option(name: .long("log-level"), help: "Set log level (trace|verbose|debug|info|warning|error|critical)")
+    var logLevel: String?
+
+    @Option(name: .long("format"), help: "Output format: text | json")
+    var format: OutputFormat?
+
+    @Flag(name: .long("json"), help: "")
+    var jsonShortcut: Bool = false
+
+    @Flag(name: .long("json-only"), help: "Emit JSON only (suppress non-JSON output)")
+    var jsonOnly: Bool = false
+
+    @Flag(name: .long("pretty"), help: "Pretty-print JSON output")
+    var pretty: Bool = false
+
+    @Flag(name: .long("cookies"), help: "Clear browser cookie caches")
+    var cookies: Bool = false
+
+    @Flag(name: .long("cost"), help: "Clear cost usage caches")
+    var cost: Bool = false
+
+    @Flag(name: .long("all"), help: "Clear all caches")
+    var all: Bool = false
+
+    @Option(name: .long("provider"), help: "Clear cache for a specific provider only")
+    var provider: String?
+}
+
+private struct CacheClearResult: Encodable {
+    let cache: String
+    let provider: String?
+    let cleared: Int
+    var error: String?
+}
+
+extension CodexBarCLI {
+    /// Mirrors the cost usage cache directory used by the app (UsageStore.costUsageCacheDirectory).
+    static func costUsageCacheDirectory(fileManager: FileManager = .default) -> URL {
+        let root = fileManager.urls(for: .cachesDirectory, in: .userDomainMask).first!
+        return root
+            .appendingPathComponent("CodexBar", isDirectory: true)
+            .appendingPathComponent("cost-usage", isDirectory: true)
+    }
+}
diff --git a/Sources/CodexBarCLI/CLIConfigCommand.swift b/Sources/CodexBarCLI/CLIConfigCommand.swift
index edc013874e..380dc8bde3 100644
--- a/Sources/CodexBarCLI/CLIConfigCommand.swift
+++ b/Sources/CodexBarCLI/CLIConfigCommand.swift
@@ -35,6 +35,197 @@ extension CodexBarCLI {
         Self.printJSON(config, pretty: output.pretty)
         Self.exit(code: .success, output: output, kind: .config)
     }
+
+    static func runConfigProviders(_ values: ParsedValues) {
+        let output = CLIOutputPreferences.from(values: values)
+        let config = Self.loadConfig(output: output)
+        let results = Self.configProviderStatuses(config)
+
+        switch output.format {
+        case .text:
+            for result in results {
+                let state = result.enabled ? "enabled" : "disabled"
+                let marker = result.defaultEnabled ? " default" : ""
+                print("\(result.provider): \(state)\(marker) (\(result.displayName))")
+            }
+        case .json:
+            Self.printJSON(results, pretty: output.pretty)
+        }
+
+        Self.exit(code: .success, output: output, kind: .config)
+    }
+
+    static func runConfigSetProviderEnabled(_ values: ParsedValues, enabled: Bool) {
+        let output = CLIOutputPreferences.from(values: values)
+        guard let rawProvider = values.options["provider"]?.last,
+              let provider = ProviderDescriptorRegistry.cliNameMap[rawProvider.lowercased()]
+        else {
+            Self.exit(
+                code: .failure,
+                message: "Unknown or missing provider. Use --provider <name>.",
+                output: output,
+                kind: .args)
+        }
+
+        let store = CodexBarConfigStore()
+        var config = Self.loadConfig(output: output)
+        config = Self.configSettingProviderEnabled(config, provider: provider, enabled: enabled)
+
+        do {
+            try store.save(config)
+        } catch {
+            Self.exit(code: .failure, message: error.localizedDescription, output: output, kind: .config)
+        }
+
+        let metadata = ProviderDescriptorRegistry.descriptor(for: provider).metadata
+        let result = ConfigProviderToggleResult(
+            provider: provider.rawValue,
+            displayName: metadata.displayName,
+            enabled: enabled,
+            configPath: store.fileURL.path)
+
+        switch output.format {
+        case .text:
+            let state = enabled ? "enabled" : "disabled"
+            print("Config: \(state) \(metadata.displayName)")
+        case .json:
+            Self.printJSON(result, pretty: output.pretty)
+        }
+
+        Self.exit(code: .success, output: output, kind: .config)
+    }
+
+    static func runConfigSetAPIKey(_ values: ParsedValues) {
+        let output = CLIOutputPreferences.from(values: values)
+
+        guard let rawProvider = values.options["provider"]?.last,
+              let provider = ProviderDescriptorRegistry.cliNameMap[rawProvider.lowercased()]
+        else {
+            Self.exit(
+                code: .failure,
+                message: "Unknown or missing provider. Use --provider <name>.",
+                output: output,
+                kind: .args)
+        }
+        guard ProviderConfigEnvironment.supportsAPIKeyOverride(for: provider) else {
+            Self.exit(
+                code: .failure,
+                message: "\(rawProvider) does not support config API keys.",
+                output: output,
+                kind: .args)
+        }
+
+        let apiKey: String
+        do {
+            apiKey = try Self.resolveConfigAPIKeyInput(
+                apiKey: values.options["apiKey"]?.last,
+                readFromStdin: values.flags.contains("stdin"))
+        } catch {
+            Self.exit(code: .failure, message: error.localizedDescription, output: output, kind: .args)
+        }
+
+        let enableProvider = !values.flags.contains("noEnable")
+        let store = CodexBarConfigStore()
+        var config = Self.loadConfig(output: output)
+        config = Self.configSettingAPIKey(
+            config,
+            provider: provider,
+            apiKey: apiKey,
+            enableProvider: enableProvider)
+
+        do {
+            try store.save(config)
+        } catch {
+            Self.exit(code: .failure, message: error.localizedDescription, output: output, kind: .config)
+        }
+
+        let result = ConfigSetAPIKeyResult(
+            provider: provider.rawValue,
+            enabled: config.providerConfig(for: provider)?.enabled ?? false,
+            configPath: store.fileURL.path)
+
+        switch output.format {
+        case .text:
+            let name = ProviderDescriptorRegistry.descriptor(for: provider).metadata.displayName
+            let suffix = result.enabled ? " and enabled" : ""
+            print("Config: stored API key for \(name)\(suffix)")
+        case .json:
+            Self.printJSON(result, pretty: output.pretty)
+        }
+
+        Self.exit(code: .success, output: output, kind: .config)
+    }
+
+    static func resolveConfigAPIKeyInput(apiKey: String?, readFromStdin: Bool) throws -> String {
+        if apiKey != nil, readFromStdin {
+            throw CLIArgumentError("Use either --api-key or --stdin, not both.")
+        }
+
+        let raw: String? = if readFromStdin {
+            String(data: FileHandle.standardInput.readDataToEndOfFile(), encoding: .utf8)
+        } else {
+            apiKey
+        }
+
+        guard let value = Self.cleanConfigSecret(raw) else {
+            throw CLIArgumentError("Missing API key. Pass --api-key <key> or pipe it with --stdin.")
+        }
+        return value
+    }
+
+    static func configSettingAPIKey(
+        _ config: CodexBarConfig,
+        provider: UsageProvider,
+        apiKey: String,
+        enableProvider: Bool) -> CodexBarConfig
+    {
+        var updated = config.normalized()
+        var providerConfig = updated.providerConfig(for: provider) ?? ProviderConfig(id: provider)
+        providerConfig.apiKey = apiKey
+        if enableProvider {
+            providerConfig.enabled = true
+        }
+        updated.setProviderConfig(providerConfig)
+        return updated
+    }
+
+    static func configSettingProviderEnabled(
+        _ config: CodexBarConfig,
+        provider: UsageProvider,
+        enabled: Bool) -> CodexBarConfig
+    {
+        var updated = config.normalized()
+        var providerConfig = updated.providerConfig(for: provider) ?? ProviderConfig(id: provider)
+        providerConfig.enabled = enabled
+        updated.setProviderConfig(providerConfig)
+        return updated
+    }
+
+    static func configProviderStatuses(_ config: CodexBarConfig) -> [ConfigProviderStatusResult] {
+        let metadata = ProviderDescriptorRegistry.metadata
+        return config.normalized().providers.map { providerConfig in
+            let meta = metadata[providerConfig.id]
+            let defaultEnabled = meta?.defaultEnabled ?? false
+            return ConfigProviderStatusResult(
+                provider: providerConfig.id.rawValue,
+                displayName: meta?.displayName ?? providerConfig.id.rawValue,
+                enabled: providerConfig.enabled ?? defaultEnabled,
+                defaultEnabled: defaultEnabled)
+        }
+    }
+
+    private static func cleanConfigSecret(_ raw: String?) -> String? {
+        guard var value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
+            return nil
+        }
+        if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
+            (value.hasPrefix("'") && value.hasSuffix("'"))
+        {
+            value = String(value.dropFirst().dropLast())
+        }
+        value = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        return value.isEmpty ? nil : value
+    }
 }
 
 struct ConfigOptions: CommanderParsable {
@@ -59,3 +250,84 @@ struct ConfigOptions: CommanderParsable {
     @Flag(name: .long("pretty"), help: "Pretty-print JSON output")
     var pretty: Bool = false
 }
+
+struct ConfigSetAPIKeyOptions: CommanderParsable {
+    @Flag(names: [.short("v"), .long("verbose")], help: "Enable verbose logging")
+    var verbose: Bool = false
+
+    @Flag(name: .long("json-output"), help: "Emit machine-readable logs")
+    var jsonOutput: Bool = false
+
+    @Option(name: .long("log-level"), help: "Set log level (trace|verbose|debug|info|warning|error|critical)")
+    var logLevel: String?
+
+    @Option(name: .long("format"), help: "Output format: text | json")
+    var format: OutputFormat?
+
+    @Flag(name: .long("json"), help: "")
+    var jsonShortcut: Bool = false
+
+    @Flag(name: .long("json-only"), help: "Emit JSON only (suppress non-JSON output)")
+    var jsonOnly: Bool = false
+
+    @Flag(name: .long("pretty"), help: "Pretty-print JSON output")
+    var pretty: Bool = false
+
+    @Option(name: .long("provider"), help: ProviderHelp.optionHelp)
+    var provider: String?
+
+    @Option(name: .long("api-key"), help: "API key to store")
+    var apiKey: String?
+
+    @Flag(name: .long("stdin"), help: "Read API key from stdin")
+    var stdin: Bool = false
+
+    @Flag(name: .long("no-enable"), help: "Store the key without enabling the provider")
+    var noEnable: Bool = false
+}
+
+struct ConfigProviderToggleOptions: CommanderParsable {
+    @Flag(names: [.short("v"), .long("verbose")], help: "Enable verbose logging")
+    var verbose: Bool = false
+
+    @Flag(name: .long("json-output"), help: "Emit machine-readable logs")
+    var jsonOutput: Bool = false
+
+    @Option(name: .long("log-level"), help: "Set log level (trace|verbose|debug|info|warning|error|critical)")
+    var logLevel: String?
+
+    @Option(name: .long("format"), help: "Output format: text | json")
+    var format: OutputFormat?
+
+    @Flag(name: .long("json"), help: "")
+    var jsonShortcut: Bool = false
+
+    @Flag(name: .long("json-only"), help: "Emit JSON only (suppress non-JSON output)")
+    var jsonOnly: Bool = false
+
+    @Flag(name: .long("pretty"), help: "Pretty-print JSON output")
+    var pretty: Bool = false
+
+    @Option(name: .long("provider"), help: ProviderHelp.optionHelp)
+    var provider: String?
+}
+
+private struct ConfigSetAPIKeyResult: Encodable {
+    let provider: String
+    let enabled: Bool
+    let configPath: String
+}
+
+struct ConfigProviderStatusResult: Encodable, Equatable {
+    let provider: String
+    let displayName: String
+    let enabled: Bool
+    let defaultEnabled: Bool
+}
+
+private struct ConfigProviderToggleResult: Encodable {
+    let provider: String
+    let displayName: String
+    let enabled: Bool
+    let configPath: String
+}
diff --git a/Sources/CodexBarCLI/CLICostCommand.swift b/Sources/CodexBarCLI/CLICostCommand.swift
index 665f0977df..7f63b24129 100644
--- a/Sources/CodexBarCLI/CLICostCommand.swift
+++ b/Sources/CodexBarCLI/CLICostCommand.swift
@@ -31,6 +31,7 @@ extension CodexBarCLI {
         let format = output.format
         let forceRefresh = values.flags.contains("refresh")
         let useColor = Self.shouldUseColor(noColor: values.flags.contains("noColor"), format: format)
+        let historyDays = Self.decodeCostHistoryDays(from: values)
 
         let fetcher = CostUsageFetcher()
         var sections: [String] = []
@@ -42,7 +43,9 @@ extension CodexBarCLI {
                 // Cost usage is local-only; it does not require web/CLI provider fetches.
                 let snapshot = try await fetcher.loadTokenSnapshot(
                     provider: provider,
-                    forceRefresh: forceRefresh)
+                    forceRefresh: forceRefresh,
+                    historyDays: historyDays,
+                    refreshPricingInBackground: false)
                 switch format {
                 case .text:
                     sections.append(Self.renderCostText(provider: provider, snapshot: snapshot, useColor: useColor))
@@ -79,17 +82,24 @@ extension CodexBarCLI {
         useColor: Bool) -> String
     {
         let name = ProviderDescriptorRegistry.descriptor(for: provider).metadata.displayName
-        let header = Self.costHeaderLine("\(name) Cost (local)", useColor: useColor)
+        let header = Self.costHeaderLine("\(name) Cost (API-rate estimate)", useColor: useColor)
 
-        let todayCost = snapshot.sessionCostUSD.map { UsageFormatter.usdString($0) } ?? "—"
+        let todayCost = snapshot.sessionCostUSD
+            .map { UsageFormatter.currencyString($0, currencyCode: snapshot.currencyCode) } ?? "—"
         let todayTokens = snapshot.sessionTokens.map { UsageFormatter.tokenCountString($0) }
         let todayLine = todayTokens.map { "Today: \(todayCost) · \($0) tokens" } ?? "Today: \(todayCost)"
 
-        let monthCost = snapshot.last30DaysCostUSD.map { UsageFormatter.usdString($0) } ?? "—"
+        let monthCost = snapshot.last30DaysCostUSD
+            .map { UsageFormatter.currencyString($0, currencyCode: snapshot.currencyCode) } ?? "—"
         let monthTokens = snapshot.last30DaysTokens.map { UsageFormatter.tokenCountString($0) }
-        let monthLine = monthTokens.map { "Last 30 days: \(monthCost) · \($0) tokens" } ?? "Last 30 days: \(monthCost)"
-
-        return [header, todayLine, monthLine].joined(separator: "\n")
+        let historyLabel = snapshot.historyLabel
+            ?? (snapshot.historyDays == 1 ? "Today" : "Last \(snapshot.historyDays) days")
+        let monthLine = monthTokens.map {
+            "\(historyLabel): \(monthCost) · \($0) tokens"
+        } ?? "\(historyLabel): \(monthCost)"
+
+        let hintLine = UsageFormatter.costEstimateHint(provider: provider)
+        return [header, todayLine, monthLine, hintLine].joined(separator: "\n")
     }
 
     private static func costHeaderLine(_ header: String, useColor: Bool) -> String {
@@ -97,11 +107,11 @@ extension CodexBarCLI {
         return "\u{001B}[1;36m\(header)\u{001B}[0m"
     }
 
-    private static func costProviders(from selection: ProviderSelection) -> [UsageProvider] {
+    static func costProviders(from selection: ProviderSelection) -> [UsageProvider] {
         selection.asList.filter { Self.costSupportedProviders.contains($0) }
     }
 
-    private static func makeCostPayload(
+    static func makeCostPayload(
         provider: UsageProvider,
         snapshot: CostUsageTokenSnapshot?,
         error: Error?) -> CostPayload
@@ -117,7 +127,10 @@ extension CodexBarCLI {
                 costUSD: entry.costUSD,
                 modelsUsed: entry.modelsUsed,
                 modelBreakdowns: entry.modelBreakdowns?.map { breakdown in
-                    CostModelBreakdownPayload(modelName: breakdown.modelName, costUSD: breakdown.costUSD)
+                    CostModelBreakdownPayload(
+                        modelName: breakdown.modelName,
+                        costUSD: breakdown.costUSD,
+                        totalTokens: breakdown.totalTokens)
                 })
         } ?? []
 
@@ -125,8 +138,10 @@ extension CodexBarCLI {
             provider: provider.rawValue,
             source: "local",
             updatedAt: snapshot?.updatedAt ?? (error == nil ? nil : Date()),
+            currencyCode: snapshot?.currencyCode,
             sessionTokens: snapshot?.sessionTokens,
             sessionCostUSD: snapshot?.sessionCostUSD,
+            historyDays: snapshot?.historyDays,
             last30DaysTokens: snapshot?.last30DaysTokens,
             last30DaysCostUSD: snapshot?.last30DaysCostUSD,
             daily: daily,
@@ -196,6 +211,13 @@ extension CodexBarCLI {
             totalTokens: sawTokens ? totalTokens : snapshot.last30DaysTokens,
             totalCostUSD: sawCost ? totalCost : snapshot.last30DaysCostUSD)
     }
+
+    private static func decodeCostHistoryDays(from values: ParsedValues) -> Int {
+        guard let raw = values.options["days"]?.last,
+              let parsed = Int(raw)
+        else { return 30 }
+        return max(1, min(365, parsed))
+    }
 }
 
 struct CostOptions: CommanderParsable {
@@ -230,19 +252,52 @@ struct CostOptions: CommanderParsable {
 
     @Flag(name: .long("refresh"), help: "Force refresh by ignoring cached scans")
     var refresh: Bool = false
+
+    @Option(name: .long("days"), help: "Cost history window in days (1...365)")
+    var days: Int?
 }
 
 struct CostPayload: Encodable {
     let provider: String
     let source: String
     let updatedAt: Date?
+    let currencyCode: String?
     let sessionTokens: Int?
     let sessionCostUSD: Double?
+    let historyDays: Int?
     let last30DaysTokens: Int?
     let last30DaysCostUSD: Double?
     let daily: [CostDailyEntryPayload]
     let totals: CostTotalsPayload?
     let error: ProviderErrorPayload?
+
+    init(
+        provider: String,
+        source: String,
+        updatedAt: Date?,
+        currencyCode: String? = nil,
+        sessionTokens: Int?,
+        sessionCostUSD: Double?,
+        historyDays: Int?,
+        last30DaysTokens: Int?,
+        last30DaysCostUSD: Double?,
+        daily: [CostDailyEntryPayload],
+        totals: CostTotalsPayload?,
+        error: ProviderErrorPayload?)
+    {
+        self.provider = provider
+        self.source = source
+        self.updatedAt = updatedAt
+        self.currencyCode = currencyCode
+        self.sessionTokens = sessionTokens
+        self.sessionCostUSD = sessionCostUSD
+        self.historyDays = historyDays
+        self.last30DaysTokens = last30DaysTokens
+        self.last30DaysCostUSD = last30DaysCostUSD
+        self.daily = daily
+        self.totals = totals
+        self.error = error
+    }
 }
 
 struct CostDailyEntryPayload: Encodable {
@@ -272,10 +327,12 @@ struct CostDailyEntryPayload: Encodable {
 struct CostModelBreakdownPayload: Encodable {
     let modelName: String
     let costUSD: Double?
+    let totalTokens: Int?
 
     private enum CodingKeys: String, CodingKey {
         case modelName
         case costUSD = "cost"
+        case totalTokens
     }
 }
 
diff --git a/Sources/CodexBarCLI/CLIDiagnoseCommand.swift b/Sources/CodexBarCLI/CLIDiagnoseCommand.swift
new file mode 100644
index 0000000000..c5337d4d5b
--- /dev/null
+++ b/Sources/CodexBarCLI/CLIDiagnoseCommand.swift
@@ -0,0 +1,333 @@
+import CodexBarCore
+import Commander
+import Foundation
+
+extension CodexBarCLI {
+    static func runDiagnose(_ values: ParsedValues) async {
+        let output = CLIOutputPreferences.from(values: values)
+        let config = Self.loadConfig(output: output)
+
+        let format = Self.decodeFormat(from: values)
+        guard format == .json else {
+            Self.exit(
+                code: .failure,
+                message: "Error: only JSON format is supported for diagnose",
+                output: output,
+                kind: .args)
+        }
+
+        let providerSelection: ProviderSelection
+        if let rawProvider = values.options["provider"]?.last {
+            guard let parsed = ProviderSelection(argument: rawProvider) else {
+                Self.exit(
+                    code: .failure,
+                    message: "Error: unknown provider '\(rawProvider)'",
+                    output: output,
+                    kind: .args)
+            }
+            providerSelection = parsed
+        } else {
+            providerSelection = Self.providerSelection(rawOverride: nil, enabled: config.enabledProviders())
+        }
+
+        let providers = providerSelection.asList
+        let pretty = values.flags.contains("pretty")
+        let verbose = values.flags.contains("verbose")
+        let outputPath = values.options["output"]?.last
+        let browserDetection = BrowserDetection()
+        let baseFetcher = UsageFetcher()
+
+        let tokenSelection = TokenAccountCLISelection(label: nil, index: nil, allAccounts: false)
+        let tokenContext: TokenAccountCLIContext
+        do {
+            tokenContext = try TokenAccountCLIContext(
+                selection: tokenSelection,
+                config: config,
+                verbose: verbose)
+        } catch {
+            Self.exit(code: .failure, message: "Error: \(error.localizedDescription)", output: output, kind: .config)
+        }
+
+        var diagnostics: [ProviderDiagnosticExport] = []
+        diagnostics.reserveCapacity(providers.count)
+        for provider in providers {
+            await diagnostics.append(Self.makeDiagnosticExport(
+                provider: provider,
+                tokenContext: tokenContext,
+                baseFetcher: baseFetcher,
+                browserDetection: browserDetection,
+                verbose: verbose))
+        }
+
+        let encoder = JSONEncoder()
+        encoder.dateEncodingStrategy = .iso8601
+        encoder.outputFormatting = pretty ? [.prettyPrinted, .sortedKeys] : .sortedKeys
+
+        do {
+            let data: Data = if diagnostics.count == 1, let diagnostic = diagnostics.first {
+                try encoder.encode(diagnostic)
+            } else {
+                try encoder.encode(ProviderDiagnosticBatchExport(
+                    timestamp: Date(),
+                    diagnostics: diagnostics))
+            }
+            var jsonString = String(data: data, encoding: .utf8) ?? "{}"
+            jsonString = LogRedactor.redact(jsonString)
+            if let outputPath, !outputPath.isEmpty {
+                try Self.writeDiagnosticExport(jsonString, to: outputPath)
+            } else {
+                print(jsonString)
+            }
+        } catch {
+            Self.exit(
+                code: .failure,
+                message: "Error encoding diagnostic: \(error.localizedDescription)",
+                output: output,
+                kind: .runtime)
+        }
+
+        Self.exit(code: .success, output: output, kind: .runtime)
+    }
+
+    static func writeDiagnosticExport(_ jsonString: String, to path: String) throws {
+        let url = URL(fileURLWithPath: path)
+        let parent = url.deletingLastPathComponent()
+        if !parent.path.isEmpty {
+            try FileManager.default.createDirectory(
+                at: parent,
+                withIntermediateDirectories: true)
+        }
+        try jsonString.write(to: url, atomically: true, encoding: .utf8)
+    }
+}
+
+extension CodexBarCLI {
+    private static func makeDiagnosticExport(
+        provider: UsageProvider,
+        tokenContext: TokenAccountCLIContext,
+        baseFetcher: UsageFetcher,
+        browserDetection: BrowserDetection,
+        verbose: Bool) async -> ProviderDiagnosticExport
+    {
+        let account = ((try? tokenContext.resolvedAccounts(for: provider)) ?? []).first
+        let env = tokenContext.environment(
+            base: ProcessInfo.processInfo.environment,
+            provider: provider,
+            account: account,
+            codexActiveSourceOverride: nil)
+        let settings = tokenContext.settingsSnapshot(
+            for: provider,
+            account: account,
+            codexActiveSourceOverride: nil)
+        let preferredSourceMode = tokenContext.preferredSourceMode(for: provider)
+        let sourceMode = tokenContext.effectiveSourceMode(
+            base: preferredSourceMode,
+            provider: provider,
+            account: account)
+        let fetcher = tokenContext.fetcher(base: baseFetcher, provider: provider, env: env)
+        let fetchContext = ProviderFetchContext(
+            runtime: .cli,
+            sourceMode: sourceMode,
+            includeCredits: true,
+            includeOptionalUsage: true,
+            webTimeout: 60,
+            webDebugDumpHTML: false,
+            verbose: verbose,
+            env: env,
+            settings: settings,
+            fetcher: fetcher,
+            claudeFetcher: ClaudeUsageFetcher(browserDetection: browserDetection),
+            browserDetection: browserDetection,
+            selectedTokenAccountID: account?.id,
+            tokenAccountTokenUpdater: tokenContext.tokenUpdater(for: account),
+            providerManualTokenUpdater: tokenContext.manualTokenUpdater())
+        let descriptor = ProviderDescriptorRegistry.descriptor(for: provider)
+        let outcome = await Self.fetchProviderUsage(provider: provider, context: fetchContext)
+        return ProviderDiagnosticExportBuilder.build(.init(
+            provider: provider,
+            descriptor: descriptor,
+            outcome: outcome,
+            sourceMode: sourceMode,
+            settings: settings,
+            auth: Self.diagnosticAuthSummary(
+                provider: provider,
+                account: account,
+                config: tokenContext.config.providerConfig(for: provider),
+                environment: env,
+                settings: settings),
+            appVersion: Self.currentVersion()))
+    }
+
+    static func diagnosticAuthSummary(
+        provider: UsageProvider,
+        account: ProviderTokenAccount?,
+        config: ProviderConfig?,
+        environment: [String: String],
+        settings: ProviderSettingsSnapshot?) -> ProviderDiagnosticAuthSummary
+    {
+        if provider == .minimax {
+            let authMode = self.resolveMiniMaxAuthMode(environment: environment, settings: settings)
+            return ProviderDiagnosticAuthSummary(
+                configured: authMode.usesAPIToken || authMode.usesCookie,
+                modes: authMode == .none ? [] : [authMode.description])
+        }
+
+        var modes: [String] = []
+        if account != nil {
+            modes.append("tokenAccount")
+        }
+        let hasConfigAPIAuth = if provider == .bedrock {
+            config?.sanitizedAPIKey != nil && config?.sanitizedSecretKey != nil
+        } else {
+            config?.sanitizedAPIKey != nil || config?.sanitizedSecretKey != nil
+        }
+        if hasConfigAPIAuth {
+            modes.append("api")
+        }
+        if Self.environmentAPIAuthConfigured(provider: provider, environment: environment), !modes.contains("api") {
+            modes.append("api")
+        }
+        if config?.sanitizedCookieHeader != nil {
+            modes.append("web")
+        }
+        if Self.environmentWebAuthConfigured(provider: provider, environment: environment), !modes.contains("web") {
+            modes.append("web")
+        }
+        return ProviderDiagnosticAuthSummary(
+            configured: !modes.isEmpty,
+            modes: modes)
+    }
+
+    private static func environmentAPIAuthConfigured(
+        provider: UsageProvider,
+        environment: [String: String]) -> Bool
+    {
+        self.environmentCoreAPIAuthConfigured(provider: provider, environment: environment) ||
+            self.environmentExtendedAPIAuthConfigured(provider: provider, environment: environment)
+    }
+
+    private static func environmentCoreAPIAuthConfigured(
+        provider: UsageProvider,
+        environment: [String: String]) -> Bool
+    {
+        switch provider {
+        case .alibaba:
+            AlibabaCodingPlanSettingsReader.apiToken(environment: environment) != nil
+        case .azureopenai:
+            AzureOpenAISettingsReader.apiKey(environment: environment) != nil
+        case .bedrock:
+            BedrockSettingsReader.hasCredentials(environment: environment)
+        case .claude:
+            ClaudeAdminAPISettingsReader.apiKey(environment: environment) != nil
+        case .codebuff:
+            CodebuffSettingsReader.apiKey(environment: environment) != nil
+        case .chutes:
+            ChutesSettingsReader.apiKey(environment: environment) != nil
+        case .crof:
+            CrofSettingsReader.apiKey(environment: environment) != nil
+        case .deepgram:
+            DeepgramSettingsReader.apiKey(environment: environment) != nil
+        case .deepseek:
+            DeepSeekSettingsReader.apiKey(environment: environment) != nil
+        case .doubao:
+            DoubaoSettingsReader.apiKey(environment: environment) != nil
+        case .elevenlabs:
+            ElevenLabsSettingsReader.apiKey(environment: environment) != nil
+        case .groq:
+            GroqSettingsReader.apiKey(environment: environment) != nil
+        case .kilo:
+            KiloSettingsReader.apiKey(environment: environment) != nil
+        default:
+            false
+        }
+    }
+
+    private static func environmentExtendedAPIAuthConfigured(
+        provider: UsageProvider,
+        environment: [String: String]) -> Bool
+    {
+        switch provider {
+        case .kimi:
+            KimiSettingsReader.apiKey(environment: environment) != nil
+        case .kimik2:
+            KimiK2SettingsReader.apiKey(environment: environment) != nil
+        case .llmproxy:
+            LLMProxySettingsReader.apiKey(environment: environment) != nil
+        case .moonshot:
+            MoonshotSettingsReader.apiKey(environment: environment) != nil
+        case .ollama:
+            OllamaAPISettingsReader.apiKey(environment: environment) != nil
+        case .openai:
+            OpenAIAPISettingsReader.apiKey(environment: environment) != nil
+        case .openrouter:
+            OpenRouterSettingsReader.apiToken(environment: environment) != nil
+        case .stepfun:
+            StepFunSettingsReader.token(environment: environment) != nil
+        case .synthetic:
+            SyntheticSettingsReader.apiKey(environment: environment) != nil
+        case .venice:
+            VeniceSettingsReader.apiKey(environment: environment) != nil
+        case .warp:
+            WarpSettingsReader.apiKey(environment: environment) != nil
+        case .zai:
+            ZaiSettingsReader.apiToken(environment: environment) != nil
+        default:
+            false
+        }
+    }
+
+    private static func environmentWebAuthConfigured(
+        provider: UsageProvider,
+        environment: [String: String]) -> Bool
+    {
+        switch provider {
+        case .alibabatokenplan:
+            AlibabaTokenPlanSettingsReader.cookieHeader(environment: environment) != nil
+        case .kimi:
+            KimiSettingsReader.authToken(environment: environment) != nil
+        case .manus:
+            ManusSettingsReader.sessionToken(environment: environment) != nil
+        case .perplexity:
+            PerplexitySettingsReader.sessionToken(environment: environment) != nil
+        default:
+            false
+        }
+    }
+
+    static func resolveMiniMaxAuthMode(
+        environment: [String: String],
+        settings: ProviderSettingsSnapshot?) -> MiniMaxAuthMode
+    {
+        let apiToken = ProviderTokenResolver.minimaxToken(environment: environment)
+        let envCookieHeader = ProviderTokenResolver.minimaxCookie(environment: environment)
+        let settingsCookieHeader = CookieHeaderNormalizer.normalize(settings?.minimax?.manualCookieHeader)
+        let cookieHeader = envCookieHeader ?? settingsCookieHeader
+        return MiniMaxAuthMode.resolve(apiToken: apiToken, cookieHeader: cookieHeader)
+    }
+}
+
+#if DEBUG
+extension CodexBarCLI {
+    static func _diagnosticAuthSummaryForTesting(
+        provider: UsageProvider,
+        account: ProviderTokenAccount?,
+        config: ProviderConfig?,
+        environment: [String: String],
+        settings: ProviderSettingsSnapshot?) -> ProviderDiagnosticAuthSummary
+    {
+        self.diagnosticAuthSummary(
+            provider: provider,
+            account: account,
+            config: config,
+            environment: environment,
+            settings: settings)
+    }
+
+    static func _resolveMiniMaxAuthModeForTesting(
+        environment: [String: String],
+        settings: ProviderSettingsSnapshot?) -> MiniMaxAuthMode
+    {
+        self.resolveMiniMaxAuthMode(environment: environment, settings: settings)
+    }
+}
+#endif
diff --git a/Sources/CodexBarCLI/CLIEntry.swift b/Sources/CodexBarCLI/CLIEntry.swift
index 42957f717e..ce2cc281b5 100644
--- a/Sources/CodexBarCLI/CLIEntry.swift
+++ b/Sources/CodexBarCLI/CLIEntry.swift
@@ -1,12 +1,11 @@
 import CodexBarCore
 import Commander
-#if canImport(AppKit)
-import AppKit
-#endif
 #if canImport(Darwin)
 import Darwin
-#else
+#elseif canImport(Glibc)
 import Glibc
+#elseif canImport(Musl)
+import Musl
 #endif
 import Foundation
 #if canImport(FoundationNetworking)
@@ -33,16 +32,38 @@ enum CodexBarCLI {
 
         do {
             let invocation = try program.resolve(argv: argv)
-            Self.bootstrapLogging(values: invocation.parsedValues)
+            Self.bootstrapLogging(path: invocation.path, values: invocation.parsedValues)
             switch invocation.path {
             case ["usage"]:
+                let signalMonitor = CLITerminationSignalMonitor { signalNumber in
+                    CLITerminationSignalMonitor.terminateActiveHelpersAndReraise(signalNumber)
+                }
+                defer { signalMonitor.cancel() }
                 await self.runUsage(invocation.parsedValues)
             case ["cost"]:
                 await self.runCost(invocation.parsedValues)
+            case ["serve"]:
+                await self.runServe(invocation.parsedValues)
             case ["config", "validate"]:
                 self.runConfigValidate(invocation.parsedValues)
             case ["config", "dump"]:
                 self.runConfigDump(invocation.parsedValues)
+            case ["config", "providers"]:
+                self.runConfigProviders(invocation.parsedValues)
+            case ["config", "enable"]:
+                self.runConfigSetProviderEnabled(invocation.parsedValues, enabled: true)
+            case ["config", "disable"]:
+                self.runConfigSetProviderEnabled(invocation.parsedValues, enabled: false)
+            case ["config", "set-api-key"]:
+                self.runConfigSetAPIKey(invocation.parsedValues)
+            case ["cache", "clear"]:
+                self.runCacheClear(invocation.parsedValues)
+            case ["diagnose"]:
+                let signalMonitor = CLITerminationSignalMonitor { signalNumber in
+                    CLITerminationSignalMonitor.terminateActiveHelpersAndReraise(signalNumber)
+                }
+                defer { signalMonitor.cancel() }
+                await self.runDiagnose(invocation.parsedValues)
             default:
                 Self.exit(
                     code: .failure,
@@ -60,7 +81,12 @@ enum CodexBarCLI {
     private static func commandDescriptors() -> [CommandDescriptor] {
         let usageSignature = CommandSignature.describe(UsageOptions())
         let costSignature = CommandSignature.describe(CostOptions())
+        let serveSignature = CommandSignature.describe(ServeOptions())
         let configSignature = CommandSignature.describe(ConfigOptions())
+        let configProviderToggleSignature = CommandSignature.describe(ConfigProviderToggleOptions())
+        let configSetAPIKeySignature = CommandSignature.describe(ConfigSetAPIKeyOptions())
+        let cacheSignature = CommandSignature.describe(CacheOptions())
+        let diagnoseSignature = CommandSignature.describe(DiagnoseOptions())
 
         return [
             CommandDescriptor(
@@ -73,6 +99,11 @@ enum CodexBarCLI {
                 abstract: "Print local cost usage as text or JSON",
                 discussion: nil,
                 signature: costSignature),
+            CommandDescriptor(
+                name: "serve",
+                abstract: "Serve usage and cost JSON over localhost HTTP",
+                discussion: nil,
+                signature: serveSignature),
             CommandDescriptor(
                 name: "config",
                 abstract: "Config utilities",
@@ -89,19 +120,62 @@ enum CodexBarCLI {
                         abstract: "Print normalized config JSON",
                         discussion: nil,
                         signature: configSignature),
+                    CommandDescriptor(
+                        name: "providers",
+                        abstract: "List provider enablement",
+                        discussion: nil,
+                        signature: configSignature),
+                    CommandDescriptor(
+                        name: "enable",
+                        abstract: "Enable a provider",
+                        discussion: nil,
+                        signature: configProviderToggleSignature),
+                    CommandDescriptor(
+                        name: "disable",
+                        abstract: "Disable a provider",
+                        discussion: nil,
+                        signature: configProviderToggleSignature),
+                    CommandDescriptor(
+                        name: "set-api-key",
+                        abstract: "Store a provider API key",
+                        discussion: nil,
+                        signature: configSetAPIKeySignature),
                 ],
                 defaultSubcommandName: "validate"),
+            CommandDescriptor(
+                name: "cache",
+                abstract: "Cache management",
+                discussion: nil,
+                signature: CommandSignature(),
+                subcommands: [
+                    CommandDescriptor(
+                        name: "clear",
+                        abstract: "Clear cached data (cookies, cost, or all)",
+                        discussion: nil,
+                        signature: cacheSignature),
+                ],
+                defaultSubcommandName: "clear"),
+            CommandDescriptor(
+                name: "diagnose",
+                abstract: "Run provider diagnostic and emit safe JSON export",
+                discussion: nil,
+                signature: diagnoseSignature),
         ]
     }
 
     // MARK: - Helpers
 
-    private static func bootstrapLogging(values: ParsedValues) {
+    private static func bootstrapLogging(path: [String], values: ParsedValues) {
+        CodexBarLog.bootstrapIfNeeded(self.loggingConfiguration(path: path, values: values))
+    }
+
+    static func loggingConfiguration(path: [String], values: ParsedValues) -> CodexBarLog.Configuration {
         let isJSON = values.flags.contains("jsonOutput") || values.flags.contains("jsonOnly")
         let verbose = values.flags.contains("verbose")
         let rawLevel = values.options["logLevel"]?.last
         let level = Self.resolvedLogLevel(verbose: verbose, rawLevel: rawLevel)
-        CodexBarLog.bootstrapIfNeeded(.init(destination: .stderr, level: level, json: isJSON))
+        let destination: CodexBarLog.Destination = path == ["diagnose"] ? .discard : .stderr
+        return .init(destination: destination, level: level, json: isJSON)
     }
 
     static func resolvedLogLevel(verbose: Bool, rawLevel: String?) -> CodexBarLog.Level {
diff --git a/Sources/CodexBarCLI/CLIErrorReporting.swift b/Sources/CodexBarCLI/CLIErrorReporting.swift
index f3599e037f..d6004ef208 100644
--- a/Sources/CodexBarCLI/CLIErrorReporting.swift
+++ b/Sources/CodexBarCLI/CLIErrorReporting.swift
@@ -49,6 +49,7 @@ extension CodexBarCLI {
     static func makeProviderErrorPayload(
         provider: UsageProvider,
         account: String?,
+        cacheAccountKey: String? = nil,
         source: String,
         status: ProviderStatusPayload?,
         error: Error,
@@ -57,6 +58,7 @@ extension CodexBarCLI {
         ProviderPayload(
             provider: provider,
             account: account,
+            cacheAccountKey: cacheAccountKey,
             version: nil,
             source: source,
             status: status,
@@ -87,10 +89,10 @@ extension CodexBarCLI {
         output: CLIOutputPreferences? = nil,
         kind: CLIErrorKind = .runtime) -> Never
     {
-        if code != .success {
+        if self.shouldPrintExitError(code: code, message: message) {
             if let output, output.usesJSONOutput {
                 let payload = self.makeCLIErrorPayload(
-                    message: message ?? "Error",
+                    message: message ?? "",
                     code: code,
                     kind: kind,
                     pretty: output.pretty)
@@ -104,6 +106,10 @@ extension CodexBarCLI {
         platformExit(code.rawValue)
     }
 
+    static func shouldPrintExitError(code: ExitCode, message: String?) -> Bool {
+        code != .success && message != nil
+    }
+
     static func printError(_ error: Error, output: CLIOutputPreferences, kind: CLIErrorKind = .runtime) {
         if output.usesJSONOutput {
             let payload = ProviderPayload(
diff --git a/Sources/CodexBarCLI/CLIExitCode.swift b/Sources/CodexBarCLI/CLIExitCode.swift
index c8ca4a9256..d658552d4f 100644
--- a/Sources/CodexBarCLI/CLIExitCode.swift
+++ b/Sources/CodexBarCLI/CLIExitCode.swift
@@ -1,4 +1,4 @@
-enum ExitCode: Int32, Sendable {
+enum ExitCode: Int32 {
     case success = 0
     case failure = 1
     case binaryNotFound = 2
diff --git a/Sources/CodexBarCLI/CLIHelp.swift b/Sources/CodexBarCLI/CLIHelp.swift
index 41ba926754..d215b56b36 100644
--- a/Sources/CodexBarCLI/CLIHelp.swift
+++ b/Sources/CodexBarCLI/CLIHelp.swift
@@ -26,8 +26,9 @@ extension CodexBarCLI {
             Auto falls back to Claude CLI only when cookies are missing.
           - Kilo: app.kilo.ai API.
             Auto falls back to Kilo CLI when API credentials are missing or unauthorized.
-          Token accounts are loaded from ~/.codexbar/config.json.
-          Use --account or --account-index to select a specific token account, or --all-accounts to fetch all.
+          Token accounts are loaded from the resolved CodexBar config file.
+          Use --account or --account-index to select a specific token account.
+          Use --all-accounts to fetch every token account, or every visible Codex account for Codex.
           Account selection requires a single provider.
 
         Global flags:
@@ -62,8 +63,8 @@ extension CodexBarCLI {
                        [--no-color] [--pretty] [--refresh]
 
         Description:
-          Print local token cost usage from Claude/Codex JSONL logs. This does not require web or CLI access.
-          Uses cached scan results unless --refresh is provided.
+          Print local token cost usage from Claude/Codex native logs plus supported pi sessions.
+          This does not require web or CLI access and uses cached scan results unless --refresh is provided.
 
         Examples:
           codexbar cost
@@ -71,6 +72,35 @@ extension CodexBarCLI {
         """
     }
 
+    static func serveHelp(version: String) -> String {
+        """
+        CodexBar \(version)
+
+        Usage:
+          codexbar serve [--port <port>] [--refresh-interval <seconds>]
+                         [--request-timeout <seconds>]
+                         [--json-output] [--log-level <trace|verbose|debug|info|warning|error|critical>]
+                         [-v|--verbose]
+
+        Description:
+          Start a foreground localhost-only HTTP server that exposes existing CLI JSON payloads.
+          The server binds to 127.0.0.1 only in this initial version.
+
+        Endpoints:
+          GET /health
+          GET /usage
+          GET /usage?provider=claude
+          GET /usage?provider=all
+          GET /cost
+          GET /cost?provider=codex
+
+        Examples:
+          codexbar serve
+          codexbar serve --port 8080 --refresh-interval 60 --request-timeout 30
+          curl http://127.0.0.1:8080/usage?provider=all
+        """
+    }
+
     static func configHelp(version: String) -> String {
         """
         CodexBar \(version)
@@ -88,13 +118,78 @@ extension CodexBarCLI {
                              [--json-output] [--log-level <trace|verbose|debug|info|warning|error|critical>]
                              [-v|--verbose]
                              [--pretty]
+          codexbar config providers [--format text|json] [--json] [--json-only] [--pretty]
+          codexbar config enable --provider <name> [--format text|json] [--json] [--json-only] [--pretty]
+          codexbar config disable --provider <name> [--format text|json] [--json] [--json-only] [--pretty]
+          codexbar config set-api-key --provider <name> (--api-key <key>|--stdin)
+                                    [--no-enable]
+                                    [--format text|json] [--json] [--json-only] [--pretty]
 
         Description:
           Validate or print the CodexBar config file (default: validate).
+          providers lists persistent provider enablement.
+          enable/disable updates the same provider toggle used by Settings.
+          set-api-key stores a provider API key in the resolved config file and enables that provider by default.
 
         Examples:
           codexbar config validate --format json --pretty
           codexbar config dump --pretty
+          codexbar config providers
+          codexbar config enable --provider grok
+          codexbar config disable --provider cursor
+          printf '%s' "$ELEVENLABS_API_KEY" | codexbar config set-api-key --provider elevenlabs --stdin
+        """
+    }
+
+    static func cacheHelp(version: String) -> String {
+        """
+        CodexBar \(version)
+
+        Usage:
+          codexbar cache clear <--cookies|--cost|--all>
+                              [--provider <name>]
+                              [--format text|json]
+                              [--json]
+                              [--json-only]
+                              [--json-output] [--log-level <trace|verbose|debug|info|warning|error|critical>]
+                              [-v|--verbose]
+                              [--pretty]
+
+        Description:
+          Clear cached data. Use --cookies to clear browser cookie caches (stored in Keychain),
+          --cost to clear cost usage scan caches, or --all for both.
+          Optionally specify --provider with --cookies to clear cookies for a single provider only.
+
+        Examples:
+          codexbar cache clear --cookies
+          codexbar cache clear --cookies --provider claude
+          codexbar cache clear --cost
+          codexbar cache clear --all
+          codexbar cache clear --all --format json --pretty
+        """
+    }
+
+    static func diagnoseHelp(version: String) -> String {
+        """
+        CodexBar \(version)
+
+        Usage:
+          codexbar diagnose --provider <name|all> --format json
+                           [--json-output] [--log-level <trace|verbose|debug|info|warning|error|critical>]
+                           [-v|--verbose]
+                           [--redact] [--output <path>]
+                           [--pretty]
+
+        Description:
+          Run provider diagnostic fetches and print a safe JSON export for issue reporting.
+          The export is redacted and omits raw API tokens, cookies, auth headers, emails,
+          account IDs, org IDs, raw responses, and billing-history records.
+
+        Examples:
+          codexbar diagnose --provider minimax --format json --redact --output diagnostic.json
+          codexbar diagnose --provider minimax --format json --pretty
+          codexbar diagnose --provider claude --format json --pretty
+          codexbar diagnose --provider all --format json
         """
     }
 
@@ -116,12 +211,20 @@ extension CodexBarCLI {
                        [--json-only]
                        [--json-output] [--log-level <trace|verbose|debug|info|warning|error|critical>] [-v|--verbose]
                        [--provider \(ProviderHelp.list)] [--no-color] [--pretty] [--refresh]
-          codexbar config <validate|dump> [--format text|json]
+          codexbar serve [--port <port>] [--refresh-interval <seconds>]
+                       [--request-timeout <seconds>]
+                       [--json-output] [--log-level <trace|verbose|debug|info|warning|error|critical>] [-v|--verbose]
+          codexbar config <validate|dump|providers> [--format text|json]
                                         [--json]
                                         [--json-only]
                                         [--json-output] [--log-level <trace|verbose|debug|info|warning|error|critical>]
                                         [-v|--verbose]
                                         [--pretty]
+          codexbar config enable --provider <name>
+          codexbar config disable --provider <name>
+          codexbar config set-api-key --provider <name> (--api-key <key>|--stdin)
+          codexbar cache clear <--cookies|--cost|--all> [--provider <name>]
+          codexbar diagnose --provider <name|all> --format json [--redact] [--output <path>] [--pretty]
 
         Global flags:
           -h, --help      Show help
@@ -137,7 +240,14 @@ extension CodexBarCLI {
           codexbar --provider all --json
           codexbar --provider gemini
           codexbar cost --provider claude --format json --pretty
+          codexbar serve --port 8080
           codexbar config validate --format json --pretty
+          codexbar config enable --provider grok
+          codexbar config set-api-key --provider elevenlabs --stdin
+          codexbar cache clear --cookies
+          codexbar diagnose --provider minimax --format json --redact --output diagnostic.json
+          codexbar diagnose --provider minimax --format json --pretty
+          codexbar diagnose --provider all --format json
         """
     }
 }
diff --git a/Sources/CodexBarCLI/CLIHelpers.swift b/Sources/CodexBarCLI/CLIHelpers.swift
index 4edfd7c64c..8958463ade 100644
--- a/Sources/CodexBarCLI/CLIHelpers.swift
+++ b/Sources/CodexBarCLI/CLIHelpers.swift
@@ -2,8 +2,10 @@ import CodexBarCore
 import Commander
 #if canImport(Darwin)
 import Darwin
-#else
+#elseif canImport(Glibc)
 import Glibc
+#elseif canImport(Musl)
+import Musl
 #endif
 import Foundation
 
@@ -17,7 +19,6 @@ extension CodexBarCLI {
         if let rawOverride, let parsed = ProviderSelection(argument: rawOverride) {
             return parsed
         }
-        if enabled.count >= 3 { return .all }
         if enabled.count == 2 {
             let enabledSet = Set(enabled)
             let primary = Set(ProviderDescriptorRegistry.all.filter(\ .metadata.isPrimaryProvider).map(\ .id))
@@ -26,8 +27,9 @@ extension CodexBarCLI {
             }
             return .custom(enabled)
         }
+        if enabled.count >= 3 { return .custom(enabled) }
         if let first = enabled.first { return ProviderSelection(provider: first) }
-        return .single(.codex)
+        return .custom([])
     }
 
     static func decodeFormat(from values: ParsedValues) -> OutputFormat {
@@ -195,17 +197,17 @@ extension CodexBarCLI {
 
     static func loadOpenAIDashboardIfAvailable(
         usage: UsageSnapshot,
-        fetcher: UsageFetcher) -> OpenAIDashboardSnapshot?
+        sourceLabel: String,
+        context: ProviderFetchContext) -> OpenAIDashboardSnapshot?
     {
         guard let cache = OpenAIDashboardCacheStore.load() else { return nil }
-        let codexEmail = (usage.accountEmail(for: .codex) ?? fetcher.loadAccountInfo().email)?
-            .trimmingCharacters(in: .whitespacesAndNewlines)
-        guard let codexEmail, !codexEmail.isEmpty else { return nil }
-        if cache.accountEmail.lowercased() != codexEmail.lowercased() { return nil }
-        if cache.snapshot.dailyBreakdown.isEmpty, !cache.snapshot.creditEvents.isEmpty {
-            return OpenAIDashboardSnapshot(
+        let snapshot: OpenAIDashboardSnapshot = if cache.snapshot.dailyBreakdown.isEmpty,
+                                                   !cache.snapshot.creditEvents.isEmpty
+        {
+            OpenAIDashboardSnapshot(
                 signedInEmail: cache.snapshot.signedInEmail,
                 codeReviewRemainingPercent: cache.snapshot.codeReviewRemainingPercent,
+                codeReviewLimit: cache.snapshot.codeReviewLimit,
                 creditEvents: cache.snapshot.creditEvents,
                 dailyBreakdown: OpenAIDashboardSnapshot.makeDailyBreakdown(
                     from: cache.snapshot.creditEvents,
@@ -213,8 +215,24 @@ extension CodexBarCLI {
                 usageBreakdown: cache.snapshot.usageBreakdown,
                 creditsPurchaseURL: cache.snapshot.creditsPurchaseURL,
                 updatedAt: cache.snapshot.updatedAt)
+        } else {
+            cache.snapshot
+        }
+
+        let input = CodexCLIDashboardAuthorityContext.makeCachedDashboardInput(
+            dashboard: snapshot,
+            cachedAccountEmail: cache.accountEmail,
+            usage: usage,
+            sourceLabel: sourceLabel,
+            context: context)
+        let decision = CodexDashboardAuthority.evaluate(input)
+        if decision.allowedEffects.contains(.cachedDashboardReuse) {
+            return snapshot
+        }
+        if decision.cleanup.contains(.dashboardCache) {
+            OpenAIDashboardCacheStore.clear()
         }
-        return cache.snapshot
+        return nil
     }
 
     static func decodeWebTimeout(from values: ParsedValues) -> TimeInterval? {
@@ -239,7 +257,13 @@ extension CodexBarCLI {
         }
         if let remaining = dash.codeReviewRemainingPercent {
             let percent = Int(remaining.rounded())
-            lines.append("Code review: \(percent)% remaining")
+            if let limit = dash.codeReviewLimit,
+               let reset = UsageFormatter.resetLine(for: limit, style: .countdown)
+            {
+                lines.append("Code review: \(percent)% remaining (\(reset))")
+            } else {
+                lines.append("Code review: \(percent)% remaining")
+            }
         }
         if let first = dash.creditEvents.first {
             let day = first.date.formatted(date: .abbreviated, time: .omitted)
@@ -340,6 +364,22 @@ extension CodexBarCLI {
         CommandSignature.describe(CostOptions())
     }
 
+    static func _cacheSignatureForTesting() -> CommandSignature {
+        CommandSignature.describe(CacheOptions())
+    }
+
+    static func _diagnoseSignatureForTesting() -> CommandSignature {
+        CommandSignature.describe(DiagnoseOptions())
+    }
+
+    static func _configSetAPIKeySignatureForTesting() -> CommandSignature {
+        CommandSignature.describe(ConfigSetAPIKeyOptions())
+    }
+
+    static func _configProviderToggleSignatureForTesting() -> CommandSignature {
+        CommandSignature.describe(ConfigProviderToggleOptions())
+    }
+
     static func _decodeFormatForTesting(from values: ParsedValues) -> OutputFormat {
         self.decodeFormat(from: values)
     }
diff --git a/Sources/CodexBarCLI/CLIIO.swift b/Sources/CodexBarCLI/CLIIO.swift
index fe42751cbd..0861b9b491 100644
--- a/Sources/CodexBarCLI/CLIIO.swift
+++ b/Sources/CodexBarCLI/CLIIO.swift
@@ -1,7 +1,9 @@
 #if canImport(Darwin)
 import Darwin
-#else
+#elseif canImport(Glibc)
 import Glibc
+#elseif canImport(Musl)
+import Musl
 #endif
 import Foundation
 
@@ -12,7 +14,7 @@ extension CodexBarCLI {
     }
 
     static func printVersion() -> Never {
-        if let version = Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String {
+        if let version = currentVersion() {
             print("CodexBar \(version)")
         } else {
             print("CodexBar")
@@ -21,25 +23,101 @@ extension CodexBarCLI {
     }
 
     static func printHelp(for command: String?) -> Never {
-        let version = Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "unknown"
+        let version = self.currentVersion() ?? "unknown"
         switch command {
         case "usage":
             print(Self.usageHelp(version: version))
         case "cost":
             print(Self.costHelp(version: version))
+        case "serve":
+            print(Self.serveHelp(version: version))
         case "config", "validate", "dump":
             print(Self.configHelp(version: version))
+        case "cache", "clear":
+            print(Self.cacheHelp(version: version))
+        case "diagnose":
+            print(Self.diagnoseHelp(version: version))
         default:
             print(Self.rootHelp(version: version))
         }
         Self.platformExit(0)
     }
 
+    static func currentVersion(
+        bundle: Bundle = .main,
+        executablePath: String? = CommandLine.arguments.first) -> String?
+    {
+        if let version = self.currentVersion(bundleVersion: nil, executablePath: executablePath) {
+            return version
+        }
+        return self.currentVersion(
+            bundleVersion: bundle.infoDictionary?["CFBundleShortVersionString"] as? String,
+            executablePath: nil)
+    }
+
+    static func currentVersion(bundleVersion: String?, executablePath: String?) -> String? {
+        if let executablePath, !executablePath.isEmpty {
+            let executableURL = URL(fileURLWithPath: executablePath).resolvingSymlinksInPath()
+            if let version = Self.adjacentVersionFileVersion(for: executableURL) {
+                return version
+            }
+            if let version = Self.containingAppVersion(for: executableURL) {
+                return version
+            }
+        }
+        return Self.normalizedBundleVersion(bundleVersion)
+    }
+
+    static func containingAppVersion(for executableURL: URL) -> String? {
+        var currentURL = executableURL.deletingLastPathComponent()
+        let fileManager = FileManager.default
+
+        while currentURL.path != currentURL.deletingLastPathComponent().path {
+            if currentURL.pathExtension == "app" {
+                let infoURL = currentURL
+                    .appendingPathComponent("Contents")
+                    .appendingPathComponent("Info.plist")
+                guard let data = fileManager.contents(atPath: infoURL.path),
+                      let plist = try? PropertyListSerialization.propertyList(from: data, format: nil) as? [String: Any]
+                else { return nil }
+                return plist["CFBundleShortVersionString"] as? String
+            }
+            currentURL.deleteLastPathComponent()
+        }
+
+        return nil
+    }
+
+    static func adjacentVersionFileVersion(for executableURL: URL) -> String? {
+        let versionURL = executableURL
+            .deletingLastPathComponent()
+            .appendingPathComponent("VERSION")
+        guard let raw = try? String(contentsOf: versionURL, encoding: .utf8) else {
+            return nil
+        }
+        let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else { return nil }
+        if trimmed.hasPrefix("v"), trimmed.dropFirst().first?.isNumber == true {
+            return String(trimmed.dropFirst())
+        }
+        return trimmed
+    }
+
+    static func normalizedBundleVersion(_ raw: String?) -> String? {
+        guard let trimmed = raw?.trimmingCharacters(in: .whitespacesAndNewlines),
+              !trimmed.isEmpty,
+              trimmed != "CodexBar"
+        else { return nil }
+        return trimmed
+    }
+
     static func platformExit(_ code: Int32) -> Never {
         #if canImport(Darwin)
         Darwin.exit(code)
-        #else
+        #elseif canImport(Glibc)
         Glibc.exit(code)
+        #elseif canImport(Musl)
+        Musl.exit(code)
         #endif
     }
 }
diff --git a/Sources/CodexBarCLI/CLILocalHTTPServer.swift b/Sources/CodexBarCLI/CLILocalHTTPServer.swift
new file mode 100644
index 0000000000..9d39e159f0
--- /dev/null
+++ b/Sources/CodexBarCLI/CLILocalHTTPServer.swift
@@ -0,0 +1,433 @@
+import Foundation
+#if canImport(Darwin)
+import Darwin
+#elseif canImport(Glibc)
+import Glibc
+#elseif canImport(Musl)
+import Musl
+#endif
+
+private let requestReadTimeoutMilliseconds: Int32 = 5000
+
+struct CLILocalHTTPRequest {
+    let method: String
+    let target: String
+    let host: String
+    let path: String
+    let queryItems: [String: String]
+
+    static func parse(_ data: Data) -> Result<CLILocalHTTPRequest, CLILocalHTTPRequestParseError> {
+        guard let raw = String(data: data, encoding: .utf8),
+              let firstLine = raw.components(separatedBy: "\r\n").first
+        else {
+            return .failure(.invalidRequest)
+        }
+
+        let parts = firstLine.split(separator: " ")
+        guard parts.count >= 3 else { return .failure(.invalidRequest) }
+
+        let method = String(parts[0]).uppercased()
+        let target = String(parts[1])
+        guard target.hasPrefix("/") else { return .failure(.invalidRequest) }
+
+        let headerResult = Self.parseHeaders(raw)
+        let host: String
+        switch headerResult {
+        case let .success(headers):
+            let hosts = headers.compactMap { name, value in
+                name.lowercased() == "host" ? value : nil
+            }
+            guard let candidate = hosts.first else { return .failure(.missingHost) }
+            guard hosts.count == 1 else { return .failure(.duplicateHost) }
+            guard Self.isAllowedLoopbackHost(candidate) else { return .failure(.disallowedHost) }
+            host = candidate
+        case let .failure(error):
+            return .failure(error)
+        }
+
+        let components = URLComponents(string: "http://localhost\(target)")
+        let path = components?.path ?? target
+        var queryItems: [String: String] = [:]
+        for item in components?.queryItems ?? [] {
+            if let value = item.value {
+                queryItems[item.name] = value
+            }
+        }
+
+        return .success(CLILocalHTTPRequest(
+            method: method,
+            target: target,
+            host: host,
+            path: path,
+            queryItems: queryItems))
+    }
+
+    private static func parseHeaders(_ raw: String) -> Result<[(String, String)], CLILocalHTTPRequestParseError> {
+        let lines = raw.components(separatedBy: "\r\n")
+        var headers: [(String, String)] = []
+
+        for line in lines.dropFirst() {
+            if line.isEmpty { break }
+            guard let separator = line.firstIndex(of: ":") else {
+                return .failure(.invalidRequest)
+            }
+            let name = String(line[..<separator]).trimmingCharacters(in: .whitespacesAndNewlines)
+            let value = String(line[line.index(after: separator)...]).trimmingCharacters(in: .whitespacesAndNewlines)
+            guard !name.isEmpty else { return .failure(.invalidRequest) }
+            headers.append((name, value))
+        }
+
+        return .success(headers)
+    }
+
+    private static func isAllowedLoopbackHost(_ host: String) -> Bool {
+        let trimmed = host.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty, !trimmed.contains(",") else { return false }
+
+        let hostWithoutPort: String
+        if trimmed.hasPrefix("[") {
+            guard let closingBracket = trimmed.firstIndex(of: "]") else { return false }
+            hostWithoutPort = String(trimmed[...closingBracket])
+            let remainder = trimmed[trimmed.index(after: closingBracket)...]
+            guard remainder.isEmpty || Self.isValidPortSuffix(String(remainder)) else { return false }
+        } else {
+            let segments = trimmed.split(separator: ":", omittingEmptySubsequences: false)
+            switch segments.count {
+            case 1:
+                hostWithoutPort = String(segments[0])
+            case 2:
+                guard Self.isValidPort(String(segments[1])) else { return false }
+                hostWithoutPort = String(segments[0])
+            default:
+                return false
+            }
+        }
+
+        switch hostWithoutPort.lowercased() {
+        case "127.0.0.1", "localhost", "localhost.", "[::1]":
+            return true
+        default:
+            return false
+        }
+    }
+
+    private static func isValidPortSuffix(_ raw: String) -> Bool {
+        guard raw.hasPrefix(":") else { return false }
+        return self.isValidPort(String(raw.dropFirst()))
+    }
+
+    private static func isValidPort(_ raw: String) -> Bool {
+        guard let port = Int(raw), port > 0, port <= Int(UInt16.max) else { return false }
+        return true
+    }
+}
+
+enum CLILocalHTTPRequestParseError: Error, Equatable {
+    case invalidRequest
+    case missingHost
+    case duplicateHost
+    case disallowedHost
+}
+
+enum CLIHTTPStatus {
+    case ok
+    case badRequest
+    case forbidden
+    case notFound
+    case methodNotAllowed
+    case internalServerError
+    case gatewayTimeout
+    var code: Int {
+        switch self {
+        case .ok: 200
+        case .badRequest: 400
+        case .forbidden: 403
+        case .notFound: 404
+        case .methodNotAllowed: 405
+        case .internalServerError: 500
+        case .gatewayTimeout: 504
+        }
+    }
+
+    var reason: String {
+        switch self {
+        case .ok: "OK"
+        case .badRequest: "Bad Request"
+        case .forbidden: "Forbidden"
+        case .notFound: "Not Found"
+        case .methodNotAllowed: "Method Not Allowed"
+        case .internalServerError: "Internal Server Error"
+        case .gatewayTimeout: "Gateway Timeout"
+        }
+    }
+}
+
+struct CLILocalHTTPResponse {
+    let status: CLIHTTPStatus
+    let body: Data
+    let contentType: String
+    let usageCacheKeys: [String?]?
+
+    init(
+        status: CLIHTTPStatus,
+        body: Data,
+        contentType: String = "application/json; charset=utf-8",
+        usageCacheKeys: [String?]? = nil)
+    {
+        self.status = status
+        self.body = body
+        self.contentType = contentType
+        self.usageCacheKeys = usageCacheKeys
+    }
+
+    var serialized: Data {
+        var headers = "HTTP/1.1 \(self.status.code) \(self.status.reason)\r\n"
+        headers += "Content-Type: \(self.contentType)\r\n"
+        headers += "Content-Length: \(self.body.count)\r\n"
+        headers += "Connection: close\r\n"
+        headers += "\r\n"
+
+        var data = Data(headers.utf8)
+        data.append(self.body)
+        return data
+    }
+}
+
+final class CLILocalHTTPServer: @unchecked Sendable {
+    typealias Handler = @Sendable (CLILocalHTTPRequest) async -> CLILocalHTTPResponse
+
+    private let host: String
+    private let port: UInt16
+    private let handler: Handler
+    private let stateLock = NSLock()
+    private var listeningFD: Int32?
+    private var stopRequested = false
+
+    init(host: String, port: UInt16, handler: @escaping Handler) {
+        self.host = host
+        self.port = port
+        self.handler = handler
+    }
+
+    func stop() {
+        self.stateLock.lock()
+        self.stopRequested = true
+        self.stateLock.unlock()
+    }
+
+    func run(onListening: @Sendable () -> Void = {}) async throws {
+        ignoreSIGPIPE()
+
+        #if canImport(Darwin)
+        let streamType = SOCK_STREAM
+        #elseif canImport(Glibc)
+        let streamType = Int32(SOCK_STREAM.rawValue)
+        #elseif canImport(Musl)
+        let streamType = Int32(SOCK_STREAM)
+        #endif
+
+        let serverFD = socket(AF_INET, streamType, 0)
+        guard serverFD >= 0 else {
+            throw POSIXError(POSIXErrorCode(rawValue: errno) ?? .EIO)
+        }
+        var ownsServerFD = true
+        defer {
+            if ownsServerFD {
+                closeSocket(serverFD)
+            }
+        }
+
+        var reuse: Int32 = 1
+        setsockopt(
+            serverFD,
+            SOL_SOCKET,
+            SO_REUSEADDR,
+            &reuse,
+            socklen_t(MemoryLayout<Int32>.size))
+
+        var address = sockaddr_in()
+        #if canImport(Darwin)
+        address.sin_len = UInt8(MemoryLayout<sockaddr_in>.size)
+        #endif
+        address.sin_family = sa_family_t(AF_INET)
+        address.sin_port = self.port.bigEndian
+        guard inet_pton(AF_INET, self.host, &address.sin_addr) == 1 else {
+            throw POSIXError(.EADDRNOTAVAIL)
+        }
+
+        let bound = withUnsafePointer(to: &address) { pointer in
+            pointer.withMemoryRebound(to: sockaddr.self, capacity: 1) { socketAddress in
+                bind(serverFD, socketAddress, socklen_t(MemoryLayout<sockaddr_in>.size))
+            }
+        }
+        guard bound == 0 else {
+            throw POSIXError(POSIXErrorCode(rawValue: errno) ?? .EIO)
+        }
+
+        guard listen(serverFD, 16) == 0 else {
+            throw POSIXError(POSIXErrorCode(rawValue: errno) ?? .EIO)
+        }
+        guard self.installListeningFD(serverFD) else {
+            return
+        }
+        ownsServerFD = false
+        defer {
+            if self.releaseListeningFD(serverFD) {
+                closeSocket(serverFD)
+            }
+        }
+        onListening()
+
+        while !self.isStopRequested {
+            guard waitForReadable(serverFD, timeoutMilliseconds: 250) else {
+                continue
+            }
+            var clientAddress = sockaddr()
+            var clientLength = socklen_t(MemoryLayout<sockaddr>.size)
+            let clientFD = accept(serverFD, &clientAddress, &clientLength)
+            guard clientFD >= 0 else {
+                if self.isStopRequested { return }
+                if errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK || errno == ECONNABORTED {
+                    continue
+                }
+                throw POSIXError(POSIXErrorCode(rawValue: errno) ?? .EIO)
+            }
+            let handler = self.handler
+            Task {
+                defer { closeSocket(clientFD) }
+                await handleClient(clientFD, handler: handler)
+            }
+        }
+    }
+
+    private var isStopRequested: Bool {
+        self.stateLock.lock()
+        let value = self.stopRequested
+        self.stateLock.unlock()
+        return value
+    }
+
+    private func installListeningFD(_ fd: Int32) -> Bool {
+        self.stateLock.lock()
+        defer { self.stateLock.unlock() }
+        guard !self.stopRequested else { return false }
+        self.listeningFD = fd
+        return true
+    }
+
+    private func releaseListeningFD(_ fd: Int32) -> Bool {
+        self.stateLock.lock()
+        defer { self.stateLock.unlock() }
+        guard self.listeningFD == fd else { return false }
+        self.listeningFD = nil
+        return true
+    }
+}
+
+private func handleClient(
+    _ clientFD: Int32,
+    handler: @Sendable (CLILocalHTTPRequest) async -> CLILocalHTTPResponse) async
+{
+    let request: CLILocalHTTPRequest
+    switch readRequest(clientFD) {
+    case let .success(parsedRequest):
+        request = parsedRequest
+    case .failure(.disallowedHost):
+        sendResponse(
+            CLILocalHTTPResponse(
+                status: .forbidden,
+                body: Data(#"{"error":"forbidden host"}"#.utf8)),
+            to: clientFD)
+        return
+    case .failure:
+        sendResponse(
+            CLILocalHTTPResponse(
+                status: .badRequest,
+                body: Data(#"{"error":"invalid request"}"#.utf8)),
+            to: clientFD)
+        return
+    }
+
+    let response = await handler(request)
+    sendResponse(response, to: clientFD)
+}
+
+private func readRequest(_ fd: Int32) -> Result<CLILocalHTTPRequest, CLILocalHTTPRequestParseError> {
+    var data = Data()
+    var buffer = [UInt8](repeating: 0, count: 4096)
+    let bufferSize = buffer.count
+    var sawHeaderEnd = false
+
+    while data.count < 16384 {
+        guard waitForReadable(fd, timeoutMilliseconds: requestReadTimeoutMilliseconds) else {
+            return .failure(.invalidRequest)
+        }
+        let count = buffer.withUnsafeMutableBytes { rawBuffer in
+            recv(fd, rawBuffer.baseAddress, bufferSize, 0)
+        }
+        guard count > 0 else { break }
+        data.append(buffer, count: count)
+        if data.range(of: Data("\r\n\r\n".utf8)) != nil {
+            sawHeaderEnd = true
+            break
+        }
+    }
+
+    guard sawHeaderEnd else { return .failure(.invalidRequest) }
+    return CLILocalHTTPRequest.parse(data)
+}
+
+private func sendResponse(_ response: CLILocalHTTPResponse, to fd: Int32) {
+    let data = response.serialized
+    data.withUnsafeBytes { rawBuffer in
+        guard let base = rawBuffer.baseAddress else { return }
+        var sent = 0
+        while sent < data.count {
+            let count = send(fd, base.advanced(by: sent), data.count - sent, sendNoSignalFlags())
+            guard count > 0 else { break }
+            sent += count
+        }
+    }
+}
+
+private func waitForReadable(_ fd: Int32, timeoutMilliseconds: Int32) -> Bool {
+    var pollFD = pollfd(fd: fd, events: Int16(POLLIN), revents: 0)
+    while true {
+        let result = poll(&pollFD, 1, timeoutMilliseconds)
+        if result > 0 {
+            return (pollFD.revents & Int16(POLLIN)) != 0
+        }
+        if result == -1, errno == EINTR {
+            continue
+        }
+        return false
+    }
+}
+
+private func sendNoSignalFlags() -> Int32 {
+    #if canImport(Darwin)
+    0
+    #else
+    Int32(MSG_NOSIGNAL)
+    #endif
+}
+
+private func ignoreSIGPIPE() {
+    #if canImport(Darwin)
+    _ = Darwin.signal(SIGPIPE, SIG_IGN)
+    #elseif canImport(Glibc)
+    _ = Glibc.signal(SIGPIPE, SIG_IGN)
+    #elseif canImport(Musl)
+    _ = Musl.signal(SIGPIPE, SIG_IGN)
+    #endif
+}
+
+private func closeSocket(_ fd: Int32) {
+    #if canImport(Darwin)
+    Darwin.close(fd)
+    #elseif canImport(Glibc)
+    Glibc.close(fd)
+    #elseif canImport(Musl)
+    Musl.close(fd)
+    #endif
+}
diff --git a/Sources/CodexBarCLI/CLIOptions.swift b/Sources/CodexBarCLI/CLIOptions.swift
index ae057cf7b6..27364b669a 100644
--- a/Sources/CodexBarCLI/CLIOptions.swift
+++ b/Sources/CodexBarCLI/CLIOptions.swift
@@ -33,7 +33,7 @@ struct UsageOptions: CommanderParsable {
     @Option(name: .long("account-index"), help: "Token account index (1-based)")
     var accountIndex: Int?
 
-    @Flag(name: .long("all-accounts"), help: "Fetch all token accounts for the provider")
+    @Flag(name: .long("all-accounts"), help: "Fetch all token accounts, or all visible Codex accounts")
     var allAccounts: Bool = false
 
     @Option(name: .long("format"), help: "Output format: text | json")
@@ -63,7 +63,7 @@ struct UsageOptions: CommanderParsable {
     @Option(name: .long("source"), help: Self.sourceHelp)
     var source: String?
 
-    @Option(name: .long("web-timeout"), help: "Web fetch timeout (seconds) (Codex only; source=auto|web)")
+    @Option(name: .long("web-timeout"), help: "Web fetch timeout (seconds) (Codex only; source=web)")
     var webTimeout: Double?
 
     @Flag(name: .long("web-debug-dump-html"), help: "Dump HTML snapshots to /tmp when Codex dashboard data is missing")
@@ -76,7 +76,7 @@ struct UsageOptions: CommanderParsable {
     var augmentDebug: Bool = false
 }
 
-enum ProviderSelection: Sendable, ExpressibleFromArgument {
+enum ProviderSelection: ExpressibleFromArgument {
     case single(UsageProvider)
     case both
     case all
@@ -120,7 +120,7 @@ enum ProviderSelection: Sendable, ExpressibleFromArgument {
     }
 }
 
-enum OutputFormat: String, Sendable, ExpressibleFromArgument {
+enum OutputFormat: String, ExpressibleFromArgument {
     case text
     case json
 
diff --git a/Sources/CodexBarCLI/CLIOutputPreferences.swift b/Sources/CodexBarCLI/CLIOutputPreferences.swift
index e1e517319b..50f8bdd1d5 100644
--- a/Sources/CodexBarCLI/CLIOutputPreferences.swift
+++ b/Sources/CodexBarCLI/CLIOutputPreferences.swift
@@ -1,7 +1,7 @@
 import Commander
 import Foundation
 
-struct CLIOutputPreferences: Sendable {
+struct CLIOutputPreferences {
     let format: OutputFormat
     let jsonOnly: Bool
     let pretty: Bool
diff --git a/Sources/CodexBarCLI/CLIPayloads.swift b/Sources/CodexBarCLI/CLIPayloads.swift
index 6f4a96728f..e36972c50a 100644
--- a/Sources/CodexBarCLI/CLIPayloads.swift
+++ b/Sources/CodexBarCLI/CLIPayloads.swift
@@ -7,6 +7,7 @@ import FoundationNetworking
 struct ProviderPayload: Encodable {
     let provider: String
     let account: String?
+    let cacheAccountKey: String?
     let version: String?
     let source: String
     let status: ProviderStatusPayload?
@@ -15,10 +16,26 @@ struct ProviderPayload: Encodable {
     let antigravityPlanInfo: AntigravityPlanInfoSummary?
     let openaiDashboard: OpenAIDashboardSnapshot?
     let error: ProviderErrorPayload?
+    let pace: ProviderPacePayload?
+
+    private enum CodingKeys: String, CodingKey {
+        case provider
+        case account
+        case version
+        case source
+        case status
+        case usage
+        case credits
+        case antigravityPlanInfo
+        case openaiDashboard
+        case error
+        case pace
+    }
 
     init(
         provider: UsageProvider,
         account: String?,
+        cacheAccountKey: String? = nil,
         version: String?,
         source: String,
         status: ProviderStatusPayload?,
@@ -26,10 +43,12 @@ struct ProviderPayload: Encodable {
         credits: CreditsSnapshot?,
         antigravityPlanInfo: AntigravityPlanInfoSummary?,
         openaiDashboard: OpenAIDashboardSnapshot?,
-        error: ProviderErrorPayload?)
+        error: ProviderErrorPayload?,
+        pace: ProviderPacePayload? = nil)
     {
         self.provider = provider.rawValue
         self.account = account
+        self.cacheAccountKey = cacheAccountKey
         self.version = version
         self.source = source
         self.status = status
@@ -38,11 +57,13 @@ struct ProviderPayload: Encodable {
         self.antigravityPlanInfo = antigravityPlanInfo
         self.openaiDashboard = openaiDashboard
         self.error = error
+        self.pace = pace
     }
 
     init(
         providerID: String,
         account: String?,
+        cacheAccountKey: String? = nil,
         version: String?,
         source: String,
         status: ProviderStatusPayload?,
@@ -50,10 +71,12 @@ struct ProviderPayload: Encodable {
         credits: CreditsSnapshot?,
         antigravityPlanInfo: AntigravityPlanInfoSummary?,
         openaiDashboard: OpenAIDashboardSnapshot?,
-        error: ProviderErrorPayload?)
+        error: ProviderErrorPayload?,
+        pace: ProviderPacePayload? = nil)
     {
         self.provider = providerID
         self.account = account
+        self.cacheAccountKey = cacheAccountKey
         self.version = version
         self.source = source
         self.status = status
@@ -62,9 +85,33 @@ struct ProviderPayload: Encodable {
         self.antigravityPlanInfo = antigravityPlanInfo
         self.openaiDashboard = openaiDashboard
         self.error = error
+        self.pace = pace
     }
 }
 
+/// Derived pace data for the `--format json` payload. Mirrors the text renderer's session/weekly
+/// Pace lines: `primary` is the session window, `secondary` is the weekly window. A key is present
+/// only when the corresponding text Pace line would render; otherwise it is omitted.
+struct ProviderPacePayload: Encodable {
+    let primary: PacePayload?
+    let secondary: PacePayload?
+}
+
+struct PacePayload: Encodable {
+    /// Raw `UsagePace.Stage`: onTrack / slightlyAhead / ahead / farAhead / slightlyBehind / behind / farBehind.
+    let stage: String
+    /// actualUsedPercent − expectedUsedPercent. Positive = ahead of pace (deficit); negative = behind (reserve).
+    let deltaPercent: Double
+    let expectedUsedPercent: Double
+    let actualUsedPercent: Double
+    let willLastToReset: Bool
+    /// Seconds until the window is projected to be exhausted. Omitted when it lasts to reset or is unknown.
+    let etaSeconds: TimeInterval?
+    let runOutProbability: Double?
+    /// Human-readable line identical to the text renderer's Pace content (without the "Pace:" label).
+    let summary: String
+}
+
 struct ProviderStatusPayload: Encodable {
     let indicator: ProviderStatusIndicator
     let description: String?
diff --git a/Sources/CodexBarCLI/CLIRenderer.swift b/Sources/CodexBarCLI/CLIRenderer.swift
index 357c815bcc..f823992583 100644
--- a/Sources/CodexBarCLI/CLIRenderer.swift
+++ b/Sources/CodexBarCLI/CLIRenderer.swift
@@ -15,25 +15,40 @@ enum CLIRenderer {
         context: RenderContext) -> String
     {
         let meta = ProviderDescriptorRegistry.descriptor(for: provider).metadata
+        let labels = self.rateWindowLabels(provider: provider, metadata: meta, snapshot: snapshot)
         let now = Date()
         var lines: [String] = []
         lines.append(self.headerLine(context.header, useColor: context.useColor))
         self.appendPrimaryLines(
             provider: provider,
             snapshot: snapshot,
-            metadata: meta,
+            labels: labels,
             context: context,
             now: now,
             lines: &lines)
         self.appendSecondaryLines(
             provider: provider,
             snapshot: snapshot,
-            metadata: meta,
+            labels: labels,
             context: context,
             now: now,
             lines: &lines)
-        self.appendTertiaryLines(snapshot: snapshot, metadata: meta, context: context, now: now, lines: &lines)
+        self.appendTertiaryLines(snapshot: snapshot, labels: labels, context: context, now: now, lines: &lines)
+        self.appendMiMoBalanceLine(snapshot: snapshot, useColor: context.useColor, lines: &lines)
+        self.appendDeepgramLines(snapshot: snapshot, useColor: context.useColor, lines: &lines)
+        self.appendAmpBalanceLines(snapshot: snapshot, useColor: context.useColor, lines: &lines)
+        self.appendLimitsUnavailableLine(
+            provider: provider,
+            snapshot: snapshot,
+            useColor: context.useColor,
+            lines: &lines)
         self.appendCreditsLine(provider: provider, credits: credits, useColor: context.useColor, lines: &lines)
+        self.appendCodexResetCreditsLine(
+            provider: provider,
+            snapshot: snapshot,
+            now: now,
+            useColor: context.useColor,
+            lines: &lines)
         self.appendIdentityAndNotes(
             provider: provider,
             snapshot: snapshot,
@@ -48,6 +63,23 @@ enum CLIRenderer {
         return lines.joined(separator: "\n")
     }
 
+    /// Builds the derived pace payload for the JSON output, mirroring the text renderer's
+    /// session (primary) and weekly (secondary) Pace lines.
+    static func providerPacePayload(
+        provider: UsageProvider,
+        snapshot: UsageSnapshot,
+        now: Date = Date()) -> ProviderPacePayload?
+    {
+        let primary = snapshot.primary.flatMap {
+            self.pacePayload(provider: provider, window: $0, kind: .session, now: now)
+        }
+        let secondary = snapshot.secondary.flatMap {
+            self.pacePayload(provider: provider, window: $0, kind: .weekly, now: now)
+        }
+        guard primary != nil || secondary != nil else { return nil }
+        return ProviderPacePayload(primary: primary, secondary: secondary)
+    }
+
     static func rateLine(title: String, window: RateWindow, useColor: Bool) -> String {
         let text = UsageFormatter.usageLine(
             remaining: window.remainingPercent,
@@ -62,7 +94,7 @@ enum CLIRenderer {
     private static func appendPrimaryLines(
         provider: UsageProvider,
         snapshot: UsageSnapshot,
-        metadata: ProviderMetadata,
+        labels: RateWindowLabels,
         context: RenderContext,
         now: Date,
         lines: inout [String])
@@ -70,9 +102,9 @@ enum CLIRenderer {
         if let primary = snapshot.primary {
             self.appendRateWindowLines(
                 provider: provider,
-                title: metadata.sessionLabel,
+                title: labels.primary,
                 window: primary,
-                includePace: false,
+                paceKind: .session,
                 context: context,
                 now: now,
                 lines: &lines)
@@ -90,7 +122,7 @@ enum CLIRenderer {
     private static func appendSecondaryLines(
         provider: UsageProvider,
         snapshot: UsageSnapshot,
-        metadata: ProviderMetadata,
+        labels: RateWindowLabels,
         context: RenderContext,
         now: Date,
         lines: inout [String])
@@ -98,28 +130,105 @@ enum CLIRenderer {
         guard let weekly = snapshot.secondary else { return }
         self.appendRateWindowLines(
             provider: provider,
-            title: metadata.weeklyLabel,
+            title: labels.secondary,
             window: weekly,
-            includePace: true,
+            paceKind: .weekly,
             context: context,
             now: now,
             lines: &lines)
     }
 
+    private static func appendMiMoBalanceLine(
+        snapshot: UsageSnapshot,
+        useColor: Bool,
+        lines: inout [String])
+    {
+        guard let usage = snapshot.mimoUsage else { return }
+        lines.append(self.labelValueLine("Balance", value: usage.balanceDetail, useColor: useColor))
+    }
+
     private static func appendTertiaryLines(
         snapshot: UsageSnapshot,
-        metadata: ProviderMetadata,
+        labels: RateWindowLabels,
         context: RenderContext,
         now: Date,
         lines: inout [String])
     {
-        guard metadata.supportsOpus, let opus = snapshot.tertiary else { return }
-        lines.append(self.rateLine(title: metadata.opusLabel ?? "Sonnet", window: opus, useColor: context.useColor))
+        guard labels.showsTertiary, let opus = snapshot.tertiary else { return }
+        lines.append(self.rateLine(title: labels.tertiary, window: opus, useColor: context.useColor))
         if let reset = self.resetLine(for: opus, style: context.resetStyle, now: now) {
             lines.append(self.subtleLine(reset, useColor: context.useColor))
         }
     }
 
+    private static func appendDeepgramLines(
+        snapshot: UsageSnapshot,
+        useColor: Bool,
+        lines: inout [String])
+    {
+        guard let usage = snapshot.deepgramUsage else { return }
+        for line in usage.displayLines {
+            let parts = line.split(separator: ":", maxSplits: 1).map(String.init)
+            if parts.count == 2 {
+                lines.append(self.labelValueLine(
+                    parts[0].trimmingCharacters(in: .whitespacesAndNewlines),
+                    value: parts[1].trimmingCharacters(in: .whitespacesAndNewlines),
+                    useColor: useColor))
+            } else {
+                lines.append(self.labelValueLine("Usage", value: line, useColor: useColor))
+            }
+        }
+    }
+
+    private static func appendAmpBalanceLines(
+        snapshot: UsageSnapshot,
+        useColor: Bool,
+        lines: inout [String])
+    {
+        guard let usage = snapshot.ampUsage else { return }
+        if let individualCredits = usage.individualCredits {
+            lines.append(self.labelValueLine(
+                "Individual credits",
+                value: UsageFormatter.currencyString(individualCredits, currencyCode: "USD"),
+                useColor: useColor))
+        }
+        for workspace in usage.workspaceBalances {
+            lines.append(self.labelValueLine(
+                "Workspace \(workspace.name)",
+                value: UsageFormatter.currencyString(workspace.remaining, currencyCode: "USD"),
+                useColor: useColor))
+        }
+    }
+
+    private struct RateWindowLabels {
+        let primary: String
+        let secondary: String
+        let tertiary: String
+        let showsTertiary: Bool
+    }
+
+    private static func rateWindowLabels(
+        provider: UsageProvider,
+        metadata: ProviderMetadata,
+        snapshot: UsageSnapshot) -> RateWindowLabels
+    {
+        if provider == .factory, snapshot.tertiary != nil {
+            return RateWindowLabels(
+                primary: "5-hour",
+                secondary: "Weekly",
+                tertiary: "Monthly",
+                showsTertiary: true)
+        }
+        let primaryLabel = provider == .grok
+            ? GrokProviderDescriptor.primaryLabel(window: snapshot.primary) ?? metadata.sessionLabel
+            : metadata.sessionLabel
+        return RateWindowLabels(
+            primary: primaryLabel,
+            secondary: metadata.weeklyLabel,
+            tertiary: metadata.opusLabel ?? "Sonnet",
+            showsTertiary: metadata.supportsOpus)
+    }
+
     private static func appendCreditsLine(
         provider: UsageProvider,
         credits: CreditsSnapshot?,
@@ -133,6 +242,39 @@ enum CLIRenderer {
             useColor: useColor))
     }
 
+    private static func appendCodexResetCreditsLine(
+        provider: UsageProvider,
+        snapshot: UsageSnapshot,
+        now: Date,
+        useColor: Bool,
+        lines: inout [String])
+    {
+        guard provider == .codex, let resetCredits = snapshot.codexResetCredits else { return }
+        let value = if resetCredits.availableCount == 1 {
+            "1 available"
+        } else {
+            "\(resetCredits.availableCount) available"
+        }
+        lines.append(self.labelValueLine("Limit Reset Credits", value: value, useColor: useColor))
+        guard resetCredits.availableCount > 0,
+              let expiresAt = resetCredits.nextExpiringAvailableCredit?.expiresAt
+        else {
+            return
+        }
+        let expiry = UsageFormatter.resetCountdownDescription(from: expiresAt, now: now)
+        lines.append(self.subtleLine("Next reset credit expires \(expiry)", useColor: useColor))
+    }
+
+    private static func appendLimitsUnavailableLine(
+        provider: UsageProvider,
+        snapshot: UsageSnapshot,
+        useColor: Bool,
+        lines: inout [String])
+    {
+        guard snapshot.rateLimitsUnavailable(for: provider) else { return }
+        lines.append(self.labelValueLine("Limits", value: "not available", useColor: useColor))
+    }
+
     private static func appendIdentityAndNotes(
         provider: UsageProvider,
         snapshot: UsageSnapshot,
@@ -152,8 +294,16 @@ enum CLIRenderer {
             for detail in kiloLogin.details {
                 lines.append(self.labelValueLine("Activity", value: detail, useColor: context.useColor))
             }
-        } else if let plan = snapshot.loginMethod(for: provider), !plan.isEmpty {
-            lines.append(self.labelValueLine("Plan", value: plan.capitalized, useColor: context.useColor))
+        } else if let plan = snapshot.loginMethod(for: provider),
+                  !plan.isEmpty,
+                  provider != .mimo || !plan.localizedCaseInsensitiveContains("balance:")
+        {
+            let displayPlan = if provider == .codex {
+                CodexPlanFormatting.displayName(plan) ?? plan
+            } else {
+                plan.capitalized
+            }
+            lines.append(self.labelValueLine("Plan", value: displayPlan, useColor: context.useColor))
         }
 
         for note in context.notes {
@@ -168,14 +318,19 @@ enum CLIRenderer {
         provider: UsageProvider,
         title: String,
         window: RateWindow,
-        includePace: Bool,
+        paceKind: PaceKind?,
         context: RenderContext,
         now: Date,
         lines: inout [String])
     {
         lines.append(self.rateLine(title: title, window: window, useColor: context.useColor))
-        if includePace,
-           let pace = self.paceLine(provider: provider, window: window, useColor: context.useColor, now: now)
+        if let paceKind,
+           let pace = self.paceLine(
+               provider: provider,
+               window: window,
+               kind: paceKind,
+               useColor: context.useColor,
+               now: now)
         {
             lines.append(pace)
         }
@@ -194,7 +349,9 @@ enum CLIRenderer {
         now: Date,
         lines: inout [String])
     {
-        if provider == .warp || provider == .kilo {
+        if provider == .warp || provider == .kilo || provider == .mistral || provider == .deepseek ||
+            provider == .crof
+        {
             if let reset = self.resetLineForDetailBackedWindow(window: window, style: context.resetStyle, now: now) {
                 lines.append(self.subtleLine(reset, useColor: context.useColor))
             }
@@ -218,7 +375,7 @@ enum CLIRenderer {
         style: ResetTimeDisplayStyle,
         now: Date) -> String?
     {
-        // Warp/Kilo use resetDescription for non-reset detail.
+        // Some provider snapshots use resetDescription for non-reset detail.
         // Only render "Resets ..." when a concrete reset date exists.
         guard window.resetsAt != nil else { return nil }
         let resetOnlyWindow = RateWindow(
@@ -289,26 +446,104 @@ enum CLIRenderer {
         return self.ansi(self.accentColor, bar)
     }
 
-    private static func paceLine(
+    /// Distinguishes the session (5-hour) and weekly pace windows so the CLI mirrors the GUI's
+    /// `UsagePaceText.sessionPace` / weekly pace calculations (same machinery, different window length).
+    private enum PaceKind {
+        case session
+        case weekly
+
+        var defaultWindowMinutes: Int {
+            switch self {
+            case .session: 300
+            case .weekly: 10080
+            }
+        }
+
+        func supports(provider: UsageProvider) -> Bool {
+            switch self {
+            case .session:
+                provider == .codex || provider == .claude || provider == .ollama
+            case .weekly:
+                provider == .codex || provider == .claude || provider == .opencode || provider == .ollama
+            }
+        }
+    }
+
+    /// Computes the pace for a window using the same guards/window length as the GUI, or nil when no
+    /// Pace line should be shown. Shared by the text renderer and the JSON payload so they stay in sync.
+    private static func computePace(
         provider: UsageProvider,
         window: RateWindow,
-        useColor: Bool,
-        now: Date) -> String?
+        kind: PaceKind,
+        now: Date) -> UsagePace?
     {
-        guard provider == .codex || provider == .claude else { return nil }
+        guard kind.supports(provider: provider) else { return nil }
+        if provider == .ollama, window.windowMinutes == nil { return nil }
         guard window.remainingPercent > 0 else { return nil }
-        guard let pace = UsagePace.weekly(window: window, now: now, defaultWindowMinutes: 10080) else { return nil }
+        guard let pace = UsagePace.weekly(
+            window: window,
+            now: now,
+            defaultWindowMinutes: kind.defaultWindowMinutes) else { return nil }
         guard pace.expectedUsedPercent >= Self.paceMinimumExpectedPercent else { return nil }
+        return pace
+    }
 
+    /// The Pace content shared by text and JSON output (without the "Pace:" label or color).
+    private static func paceSummary(for pace: UsagePace, kind: PaceKind, now: Date) -> String {
         let expected = Int(pace.expectedUsedPercent.rounded())
         var parts: [String] = []
         parts.append(Self.paceLeftLabel(for: pace))
         parts.append("Expected \(expected)% used")
-        if let rightLabel = Self.paceRightLabel(for: pace, now: now) {
+        if let rightLabel = Self.paceRightLabel(for: pace, kind: kind, now: now) {
             parts.append(rightLabel)
         }
+        return parts.joined(separator: " | ")
+    }
+
+    private static func paceLine(
+        provider: UsageProvider,
+        window: RateWindow,
+        kind: PaceKind,
+        useColor: Bool,
+        now: Date) -> String?
+    {
+        guard let pace = self.computePace(provider: provider, window: window, kind: kind, now: now) else {
+            return nil
+        }
         let label = self.label("Pace", useColor: useColor)
-        return "\(label): \(parts.joined(separator: " | "))"
+        return "\(label): \(self.paceSummary(for: pace, kind: kind, now: now))"
+    }
+
+    private static func pacePayload(
+        provider: UsageProvider,
+        window: RateWindow,
+        kind: PaceKind,
+        now: Date) -> PacePayload?
+    {
+        guard let pace = self.computePace(provider: provider, window: window, kind: kind, now: now) else {
+            return nil
+        }
+        return PacePayload(
+            stage: Self.stageString(pace.stage),
+            deltaPercent: pace.deltaPercent,
+            expectedUsedPercent: pace.expectedUsedPercent,
+            actualUsedPercent: pace.actualUsedPercent,
+            willLastToReset: pace.willLastToReset,
+            etaSeconds: pace.etaSeconds,
+            runOutProbability: pace.runOutProbability,
+            summary: self.paceSummary(for: pace, kind: kind, now: now))
+    }
+
+    private static func stageString(_ stage: UsagePace.Stage) -> String {
+        switch stage {
+        case .onTrack: "onTrack"
+        case .slightlyAhead: "slightlyAhead"
+        case .ahead: "ahead"
+        case .farAhead: "farAhead"
+        case .slightlyBehind: "slightlyBehind"
+        case .behind: "behind"
+        case .farBehind: "farBehind"
+        }
     }
 
     private static func paceLeftLabel(for pace: UsagePace) -> String {
@@ -323,12 +558,17 @@ enum CLIRenderer {
         }
     }
 
-    private static func paceRightLabel(for pace: UsagePace, now: Date) -> String? {
+    private static func paceRightLabel(for pace: UsagePace, kind: PaceKind, now: Date) -> String? {
         if pace.willLastToReset { return "Lasts until reset" }
         guard let etaSeconds = pace.etaSeconds else { return nil }
         let etaText = Self.paceDurationText(seconds: etaSeconds, now: now)
-        if etaText == "now" { return "Runs out now" }
-        return "Runs out in \(etaText)"
+        // Session mirrors the GUI's "Projected empty" wording; weekly keeps "Runs out".
+        switch kind {
+        case .session:
+            return etaText == "now" ? "Projected empty now" : "Projected empty in \(etaText)"
+        case .weekly:
+            return etaText == "now" ? "Runs out now" : "Runs out in \(etaText)"
+        }
     }
 
     private static func paceDurationText(seconds: TimeInterval, now: Date) -> String {
diff --git a/Sources/CodexBarCLI/CLIServeCommand.swift b/Sources/CodexBarCLI/CLIServeCommand.swift
new file mode 100644
index 0000000000..651f7b2d39
--- /dev/null
+++ b/Sources/CodexBarCLI/CLIServeCommand.swift
@@ -0,0 +1,811 @@
+import CodexBarCore
+import Commander
+import Foundation
+
+struct ServeOptions: CommanderParsable {
+    @Flag(names: [.short("v"), .long("verbose")], help: "Enable verbose logging")
+    var verbose: Bool = false
+
+    @Flag(name: .long("json-output"), help: "Emit machine-readable logs")
+    var jsonOutput: Bool = false
+
+    @Option(name: .long("log-level"), help: "Set log level (trace|verbose|debug|info|warning|error|critical)")
+    var logLevel: String?
+
+    @Option(name: .long("port"), help: "Local HTTP port (default: 8080)")
+    var port: Int?
+
+    @Option(name: .long("refresh-interval"), help: "Response cache TTL in seconds (default: 60)")
+    var refreshInterval: Double?
+
+    @Option(
+        name: .long("request-timeout"),
+        help: "Total per-request deadline in seconds; 0 disables (default: 30)")
+    var requestTimeout: Double?
+}
+
+enum CLIServeRoute: Equatable {
+    case health
+    case usage(provider: String?)
+    case cost(provider: String?)
+}
+
+enum CLIServeRouteError: Error, Equatable {
+    case methodNotAllowed
+    case notFound
+}
+
+enum CLIServeRouter {
+    static func route(method: String, path: String, queryItems: [String: String]) throws -> CLIServeRoute {
+        guard method.uppercased() == "GET" else {
+            throw CLIServeRouteError.methodNotAllowed
+        }
+
+        let provider = queryItems["provider"]?.trimmingCharacters(in: .whitespacesAndNewlines)
+        let normalizedProvider = provider?.isEmpty == false ? provider : nil
+
+        switch path {
+        case "/health":
+            return .health
+        case "/usage":
+            return .usage(provider: normalizedProvider)
+        case "/cost":
+            return .cost(provider: normalizedProvider)
+        default:
+            throw CLIServeRouteError.notFound
+        }
+    }
+}
+
+private struct ServeErrorPayload: Encodable {
+    let error: String
+}
+
+private struct ServeHealthPayload: Encodable {
+    let status: String
+    let version: String?
+
+    private enum CodingKeys: String, CodingKey {
+        case status
+        case version
+    }
+
+    func encode(to encoder: any Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encode(self.status, forKey: .status)
+        try container.encodeIfPresent(self.version, forKey: .version)
+    }
+}
+
+struct CLIServeConfigSnapshot {
+    let config: CodexBarConfig
+    let cacheToken: String
+}
+
+private struct ServeRuntime {
+    let configStore: CodexBarConfigStore
+    let cache: CLIServeResponseCache
+    let refreshInterval: TimeInterval
+    let requestTimeout: TimeInterval
+    let healthVersion: String?
+}
+
+private final class CLIServeDeadlineState: @unchecked Sendable {
+    private let lock = NSLock()
+    private var continuation: CheckedContinuation<CLILocalHTTPResponse, Never>?
+    private var workTask: Task<Void, Never>?
+    private var timeoutTask: Task<Void, Never>?
+
+    init(continuation: CheckedContinuation<CLILocalHTTPResponse, Never>) {
+        self.continuation = continuation
+    }
+
+    func setWorkTask(_ task: Task<Void, Never>) {
+        var shouldCancel = false
+        self.lock.lock()
+        if self.continuation == nil {
+            shouldCancel = true
+        } else {
+            self.workTask = task
+        }
+        self.lock.unlock()
+
+        if shouldCancel {
+            task.cancel()
+        }
+    }
+
+    func setTimeoutTask(_ task: Task<Void, Never>) {
+        var shouldCancel = false
+        self.lock.lock()
+        if self.continuation == nil {
+            shouldCancel = true
+        } else {
+            self.timeoutTask = task
+        }
+        self.lock.unlock()
+
+        if shouldCancel {
+            task.cancel()
+        }
+    }
+
+    func finish(_ response: CLILocalHTTPResponse, cancelWork: Bool, cancelTimeout: Bool) {
+        let continuation: CheckedContinuation<CLILocalHTTPResponse, Never>?
+        let workTask: Task<Void, Never>?
+        let timeoutTask: Task<Void, Never>?
+
+        self.lock.lock()
+        continuation = self.continuation
+        self.continuation = nil
+        workTask = cancelWork ? self.workTask : nil
+        timeoutTask = cancelTimeout ? self.timeoutTask : nil
+        self.workTask = nil
+        self.timeoutTask = nil
+        self.lock.unlock()
+
+        workTask?.cancel()
+        timeoutTask?.cancel()
+        continuation?.resume(returning: response)
+    }
+}
+
+enum CLIServeCacheLookup {
+    case response(CLILocalHTTPResponse)
+    case miss
+}
+
+actor CLIServeResponseCache {
+    static let maximumStaleTTL: TimeInterval = 3600
+
+    private struct Entry {
+        let expiresAt: Date
+        let response: CLILocalHTTPResponse
+    }
+
+    struct CachePolicy {
+        /// How long a successful response stays fresh.
+        let ttl: TimeInterval
+        /// How long a last-good response may stand in for a failed refresh.
+        let staleTTL: TimeInterval
+    }
+
+    private struct LastGoodEntry {
+        let recordedAt: Date
+        let response: CLILocalHTTPResponse
+    }
+
+    private struct UsageItemKey: Hashable {
+        let provider: String
+        let accountID: String
+    }
+
+    private struct LastGoodUsageItem {
+        let recordedAt: Date
+        let data: Data
+    }
+
+    private struct UsageMergeResult {
+        let response: CLILocalHTTPResponse
+    }
+
+    private var entries: [String: Entry] = [:]
+    private var lastGood: [String: LastGoodEntry] = [:]
+    private var lastGoodUsageItems: [String: [UsageItemKey: LastGoodUsageItem]] = [:]
+    private var inFlightKeys: Set<String> = []
+    private var waiters: [String: [CheckedContinuation<CLIServeCacheLookup, Never>]] = [:]
+
+    private func pruneExpiredEntries(now: Date) {
+        self.entries = self.entries.filter { $0.value.expiresAt > now }
+        self.lastGood = self.lastGood.filter {
+            now.timeIntervalSince($0.value.recordedAt) <= Self.maximumStaleTTL
+        }
+        self.lastGoodUsageItems = self.lastGoodUsageItems.compactMapValues { items in
+            let retained = items.filter {
+                now.timeIntervalSince($0.value.recordedAt) <= Self.maximumStaleTTL
+            }
+            return retained.isEmpty ? nil : retained
+        }
+    }
+
+    private func response(for key: String) -> CLILocalHTTPResponse? {
+        guard let entry = self.entries[key] else { return nil }
+        return entry.response
+    }
+
+    func responseOrStartFetch(for key: String, now: Date) async -> CLIServeCacheLookup {
+        self.pruneExpiredEntries(now: now)
+        if let cached = self.response(for: key) {
+            return .response(cached)
+        }
+
+        if self.inFlightKeys.contains(key) {
+            return await withCheckedContinuation { continuation in
+                self.waiters[key, default: []].append(continuation)
+            }
+        }
+
+        self.inFlightKeys.insert(key)
+        return .miss
+    }
+
+    /// Completes an in-flight fetch and returns the response delivered to
+    /// waiters. Successful responses are cached normally. Failed non-usage
+    /// fetches may use a whole-response fallback within `staleTTL`; usage
+    /// responses only replace keyed error rows from the same identified account.
+    func completeFetch(
+        _ response: CLILocalHTTPResponse,
+        for key: String,
+        policy: CachePolicy,
+        now: Date,
+        shouldCache: Bool) -> CLILocalHTTPResponse
+    {
+        let delivered: CLILocalHTTPResponse
+        let staleResponse = self.staleResponse(for: key, staleTTL: policy.staleTTL, now: now)
+        let usageMerge = self.mergeLastGoodUsageItems(
+            into: response,
+            for: key,
+            staleTTL: policy.staleTTL,
+            now: now,
+            replaceCachedItems: shouldCache)
+        if shouldCache {
+            self.store(response, for: key, ttl: policy.ttl, now: now)
+            if key.hasPrefix("usage:") {
+                self.lastGood[key] = nil
+            } else {
+                self.lastGood[key] = LastGoodEntry(recordedAt: now, response: response)
+            }
+            delivered = response
+        } else if let usageMerge {
+            delivered = usageMerge.response
+            self.lastGood[key] = nil
+        } else {
+            delivered = staleResponse ?? response
+        }
+        self.inFlightKeys.remove(key)
+        let waiters = self.waiters.removeValue(forKey: key) ?? []
+        for waiter in waiters {
+            waiter.resume(returning: .response(delivered))
+        }
+        return delivered
+    }
+
+    private func staleResponse(
+        for key: String,
+        staleTTL: TimeInterval,
+        now: Date) -> CLILocalHTTPResponse?
+    {
+        guard staleTTL > 0 else { return nil }
+        // A timeout cannot prove which usage account is currently active.
+        if key.hasPrefix("usage:") {
+            return nil
+        }
+        if let entry = self.lastGood[key],
+           now.timeIntervalSince(entry.recordedAt) <= staleTTL
+        {
+            return entry.response
+        }
+        if self.lastGood[key] != nil {
+            self.lastGood[key] = nil
+        }
+        return nil
+    }
+
+    private func mergeLastGoodUsageItems(
+        into response: CLILocalHTTPResponse,
+        for key: String,
+        staleTTL: TimeInterval,
+        now: Date,
+        replaceCachedItems: Bool) -> UsageMergeResult?
+    {
+        guard key.hasPrefix("usage:"),
+              response.status == .ok,
+              staleTTL > 0,
+              var items = try? JSONSerialization.jsonObject(with: response.body) as? [[String: Any]]
+        else {
+            return nil
+        }
+
+        var cachedItems = replaceCachedItems ? [:] : self.lastGoodUsageItems[key] ?? [:]
+        if !replaceCachedItems {
+            cachedItems = cachedItems.filter { now.timeIntervalSince($0.value.recordedAt) <= staleTTL }
+        }
+        let itemKeys = items.indices.compactMap { index in
+            Self.usageItemKey(
+                items[index],
+                accountID: Self.cacheAccountKey(at: index, in: response.usageCacheKeys))
+        }
+        let duplicateKeys = Set(
+            Dictionary(grouping: itemKeys, by: { $0 })
+                .filter { $0.value.count > 1 }
+                .map(\.key))
+        for duplicateKey in duplicateKeys {
+            cachedItems[duplicateKey] = nil
+        }
+        var replacedError = false
+
+        for index in items.indices {
+            let item = items[index]
+            guard let itemKey = Self.usageItemKey(
+                item,
+                accountID: Self.cacheAccountKey(at: index, in: response.usageCacheKeys))
+            else {
+                continue
+            }
+            guard !duplicateKeys.contains(itemKey) else {
+                continue
+            }
+
+            if Self.hasError(item) {
+                if let cached = cachedItems[itemKey],
+                   let cachedItem = try? JSONSerialization.jsonObject(with: cached.data) as? [String: Any]
+                {
+                    items[index] = cachedItem
+                    replacedError = true
+                }
+            } else {
+                if let data = try? JSONSerialization.data(withJSONObject: item, options: [.sortedKeys]) {
+                    cachedItems[itemKey] = LastGoodUsageItem(recordedAt: now, data: data)
+                }
+            }
+        }
+        self.lastGoodUsageItems[key] = cachedItems
+
+        guard replacedError,
+              let body = try? JSONSerialization.data(withJSONObject: items, options: [.sortedKeys])
+        else {
+            return UsageMergeResult(response: response)
+        }
+        return UsageMergeResult(
+            response: CLILocalHTTPResponse(
+                status: response.status,
+                body: body,
+                contentType: response.contentType,
+                usageCacheKeys: response.usageCacheKeys))
+    }
+
+    private static func usageItemKey(_ item: [String: Any], accountID: String?) -> UsageItemKey? {
+        guard let provider = item["provider"] as? String,
+              !provider.isEmpty,
+              let accountID,
+              !accountID.isEmpty
+        else {
+            return nil
+        }
+        return UsageItemKey(provider: provider, accountID: accountID)
+    }
+
+    private static func cacheAccountKey(at index: Int, in keys: [String?]?) -> String? {
+        guard let keys, keys.indices.contains(index) else { return nil }
+        return keys[index]
+    }
+
+    private static func hasError(_ item: [String: Any]) -> Bool {
+        guard let error = item["error"] else { return false }
+        return !(error is NSNull)
+    }
+
+    private func store(_ response: CLILocalHTTPResponse, for key: String, ttl: TimeInterval, now: Date) {
+        guard ttl > 0, response.status == .ok else { return }
+        self.entries[key] = Entry(expiresAt: now.addingTimeInterval(ttl), response: response)
+    }
+
+    func cachedEntryCount() -> Int {
+        self.entries.count
+    }
+
+    func cachedStaleVariantCount() -> Int {
+        self.lastGood.count + self.lastGoodUsageItems.count
+    }
+}
+
+private enum CLIServeArgumentError: LocalizedError {
+    case invalidPort
+    case invalidRefreshInterval
+    case invalidRequestTimeout
+    case invalidProvider(String)
+
+    var errorDescription: String? {
+        switch self {
+        case .invalidPort:
+            "--port must be between 1 and 65535."
+        case .invalidRefreshInterval:
+            "--refresh-interval must be zero or greater."
+        case .invalidRequestTimeout:
+            "--request-timeout must be zero or greater."
+        case let .invalidProvider(provider):
+            "Unknown provider '\(provider)'."
+        }
+    }
+}
+
+extension CodexBarCLI {
+    static let defaultServeRequestTimeout: TimeInterval = 30
+
+    static func runServe(_ values: ParsedValues) async {
+        let output = CLIOutputPreferences(format: .json, jsonOnly: true, pretty: false)
+        let port = Self.decodeServePort(from: values)
+        let refreshInterval = Self.decodeServeRefreshInterval(from: values)
+        let requestTimeout = Self.decodeServeRequestTimeout(from: values)
+
+        guard let port else {
+            Self.exit(
+                code: .failure,
+                message: CLIServeArgumentError.invalidPort.localizedDescription,
+                output: output,
+                kind: .args)
+        }
+
+        guard let refreshInterval else {
+            Self.exit(
+                code: .failure,
+                message: CLIServeArgumentError.invalidRefreshInterval.localizedDescription,
+                output: output,
+                kind: .args)
+        }
+
+        guard let requestTimeout else {
+            Self.exit(
+                code: .failure,
+                message: CLIServeArgumentError.invalidRequestTimeout.localizedDescription,
+                output: output,
+                kind: .args)
+        }
+
+        // Resolve the running build version once, at startup, before an in-place
+        // app/tarball update can replace the on-disk binary. Resolving it lazily
+        // per request would let a stale serve report the newly installed version
+        // and defeat the client stale-process detection this field exists for.
+        let runtime = ServeRuntime(
+            configStore: CodexBarConfigStore(),
+            cache: CLIServeResponseCache(),
+            refreshInterval: refreshInterval,
+            requestTimeout: requestTimeout,
+            healthVersion: Self.currentVersion())
+        let server = CLILocalHTTPServer(host: "127.0.0.1", port: port) { request in
+            await Self.handleServeRequest(request, runtime: runtime)
+        }
+        let signalMonitor = CLITerminationSignalMonitor { _ in
+            TTYCommandRunner.terminateActiveProcessesForAppShutdown()
+            server.stop()
+        }
+        defer { signalMonitor.cancel() }
+
+        do {
+            try await server.run {
+                Self.writeStderr("CodexBar server listening on http://127.0.0.1:\(port)\n")
+            }
+        } catch {
+            await Self.shutdownServeSessions()
+            Self.exit(code: .failure, message: error.localizedDescription, output: output, kind: .runtime)
+        }
+        await Self.shutdownServeSessions()
+    }
+
+    private static func shutdownServeSessions() async {
+        await ProviderCLISessionLifecycle.shutdownPersistentSessions()
+        TTYCommandRunner.terminateActiveProcessesForAppShutdown()
+    }
+
+    static func decodeServePort(from values: ParsedValues) -> UInt16? {
+        let raw = values.options["port"]?.last
+        let parsed: Int
+        if let raw {
+            guard let value = Int(raw) else { return nil }
+            parsed = value
+        } else {
+            parsed = 8080
+        }
+        guard parsed > 0, parsed <= Int(UInt16.max) else { return nil }
+        return UInt16(parsed)
+    }
+
+    static func decodeServeRefreshInterval(from values: ParsedValues) -> TimeInterval? {
+        let raw = values.options["refreshInterval"]?.last
+        let parsed: Double
+        if let raw {
+            guard let value = Double(raw) else { return nil }
+            parsed = value
+        } else {
+            parsed = 60
+        }
+        guard parsed.isFinite, parsed >= 0 else { return nil }
+        return parsed
+    }
+
+    static func decodeServeRequestTimeout(from values: ParsedValues) -> TimeInterval? {
+        let raw = values.options["requestTimeout"]?.last
+        let parsed: Double
+        if let raw {
+            guard let value = Double(raw) else { return nil }
+            parsed = value
+        } else {
+            parsed = Self.defaultServeRequestTimeout
+        }
+        guard parsed >= 0 else { return nil }
+        return parsed
+    }
+
+    private static func handleServeRequest(
+        _ request: CLILocalHTTPRequest,
+        runtime: ServeRuntime) async -> CLILocalHTTPResponse
+    {
+        let route: CLIServeRoute
+        do {
+            route = try CLIServeRouter.route(
+                method: request.method,
+                path: request.path,
+                queryItems: request.queryItems)
+        } catch CLIServeRouteError.methodNotAllowed {
+            return Self.serveError(status: .methodNotAllowed, message: "method not allowed")
+        } catch {
+            return Self.serveError(status: .notFound, message: "not found")
+        }
+
+        switch route {
+        case .health:
+            return Self.serveHealthResponse(version: runtime.healthVersion)
+        case let .usage(provider):
+            let snapshot: CLIServeConfigSnapshot
+            do {
+                snapshot = try Self.loadServeConfigSnapshot(configStore: runtime.configStore)
+            } catch {
+                return Self.serveError(status: .internalServerError, message: error.localizedDescription)
+            }
+            return await Self.cachedServeResponse(
+                key: Self.serveCacheKey(kind: "usage", provider: provider, configToken: snapshot.cacheToken),
+                cache: runtime.cache,
+                refreshInterval: runtime.refreshInterval,
+                requestTimeout: runtime.requestTimeout)
+            {
+                await Self.serveUsage(
+                    provider: provider,
+                    config: snapshot.config,
+                    refreshInterval: runtime.refreshInterval)
+            }
+        case let .cost(provider):
+            let snapshot: CLIServeConfigSnapshot
+            do {
+                snapshot = try Self.loadServeConfigSnapshot(configStore: runtime.configStore)
+            } catch {
+                return Self.serveError(status: .internalServerError, message: error.localizedDescription)
+            }
+            return await Self.cachedServeResponse(
+                key: Self.serveCacheKey(kind: "cost", provider: provider, configToken: snapshot.cacheToken),
+                cache: runtime.cache,
+                refreshInterval: runtime.refreshInterval,
+                requestTimeout: runtime.requestTimeout)
+            {
+                await Self.serveCost(provider: provider, config: snapshot.config)
+            }
+        }
+    }
+
+    static func loadServeConfigSnapshot(
+        configStore: CodexBarConfigStore = CodexBarConfigStore()) throws -> CLIServeConfigSnapshot
+    {
+        let config = try configStore.load() ?? CodexBarConfig.makeDefault()
+        return try CLIServeConfigSnapshot(
+            config: config,
+            cacheToken: Self.serveConfigCacheToken(for: config))
+    }
+
+    static func serveCacheKey(kind: String, provider: String?, configToken: String) -> String {
+        "\(kind):\(provider ?? ""):\(configToken)"
+    }
+
+    static func serveConfigCacheToken(for config: CodexBarConfig) throws -> String {
+        let encoder = JSONEncoder()
+        encoder.outputFormatting = [.sortedKeys]
+        let data = try encoder.encode(config.normalized())
+        var hash: UInt64 = 14_695_981_039_346_656_037
+        for byte in data {
+            hash ^= UInt64(byte)
+            hash = hash &* 1_099_511_628_211
+        }
+        return String(hash, radix: 16)
+    }
+
+    static func cachedServeResponse(
+        key: String,
+        cache: CLIServeResponseCache,
+        refreshInterval: TimeInterval,
+        requestTimeout: TimeInterval = CodexBarCLI.defaultServeRequestTimeout,
+        makeResponse: @Sendable @escaping () async -> CLILocalHTTPResponse) async -> CLILocalHTTPResponse
+    {
+        switch await cache.responseOrStartFetch(for: key, now: Date()) {
+        case let .response(response):
+            return response
+        case .miss:
+            let response = await Self.serveResponseWithDeadline(seconds: requestTimeout) {
+                await makeResponse()
+            }
+            return await cache.completeFetch(
+                response,
+                for: key,
+                policy: CLIServeResponseCache.CachePolicy(
+                    ttl: refreshInterval,
+                    staleTTL: Self.serveStaleTTL(refreshInterval: refreshInterval)),
+                now: Date(),
+                shouldCache: Self.shouldCacheServeResponse(response))
+        }
+    }
+
+    private static func serveResponseWithDeadline(
+        seconds timeout: TimeInterval,
+        makeResponse: @Sendable @escaping () async -> CLILocalHTTPResponse) async -> CLILocalHTTPResponse
+    {
+        let clampedTimeout = min(max(timeout, 0), 86400)
+        guard clampedTimeout > 0 else {
+            return await makeResponse()
+        }
+        let nanoseconds = max(1, UInt64((clampedTimeout * 1_000_000_000).rounded(.up)))
+
+        return await withCheckedContinuation { continuation in
+            let state = CLIServeDeadlineState(continuation: continuation)
+            let workTask = Task {
+                let response = await makeResponse()
+                state.finish(response, cancelWork: false, cancelTimeout: true)
+            }
+            state.setWorkTask(workTask)
+
+            let timeoutTask = Task {
+                do {
+                    try await Task.sleep(nanoseconds: nanoseconds)
+                } catch {
+                    return
+                }
+                state.finish(
+                    Self.serveError(status: .gatewayTimeout, message: "request timed out"),
+                    cancelWork: true,
+                    cancelTimeout: false)
+            }
+            state.setTimeoutTask(timeoutTask)
+        }
+    }
+
+    /// How long a last-good response may be served in place of a failed
+    /// refresh. Ten refresh intervals, with a five-minute floor and one-hour
+    /// ceiling. Zero (stale fallback disabled) when response caching is disabled.
+    static func serveStaleTTL(refreshInterval: TimeInterval) -> TimeInterval {
+        guard refreshInterval > 0 else { return 0 }
+        guard refreshInterval.isFinite else { return CLIServeResponseCache.maximumStaleTTL }
+        return min(max(refreshInterval * 10, 300), CLIServeResponseCache.maximumStaleTTL)
+    }
+
+    static func serveCLISessionIdleWindow(refreshInterval: TimeInterval) -> TimeInterval {
+        max(180, refreshInterval + 60)
+    }
+
+    static func shouldCacheServeResponse(_ response: CLILocalHTTPResponse) -> Bool {
+        guard response.status == .ok else { return false }
+        guard let payload = try? JSONSerialization.jsonObject(with: response.body) as? [[String: Any]] else {
+            return true
+        }
+        return !payload.contains { item in
+            guard let error = item["error"] else { return false }
+            return !(error is NSNull)
+        }
+    }
+
+    private static func serveUsage(
+        provider rawProvider: String?,
+        config: CodexBarConfig,
+        refreshInterval: TimeInterval) async -> CLILocalHTTPResponse
+    {
+        let selection: ProviderSelection
+        do {
+            selection = try Self.serveProviderSelection(rawProvider: rawProvider, config: config)
+        } catch {
+            return Self.serveError(status: .badRequest, message: error.localizedDescription)
+        }
+
+        let tokenContext: TokenAccountCLIContext
+        do {
+            tokenContext = try TokenAccountCLIContext(
+                selection: TokenAccountCLISelection(label: nil, index: nil, allAccounts: false),
+                config: config,
+                verbose: false)
+        } catch {
+            return Self.serveError(status: .internalServerError, message: error.localizedDescription)
+        }
+
+        let browserDetection = BrowserDetection()
+        let command = UsageCommandContext(
+            format: .json,
+            includeCredits: true,
+            sourceModeOverride: nil,
+            antigravityPlanDebug: false,
+            augmentDebug: false,
+            webDebugDumpHTML: false,
+            webTimeout: 60,
+            verbose: false,
+            useColor: false,
+            resetStyle: Self.resetTimeDisplayStyleFromDefaults(),
+            jsonOnly: true,
+            includeAllCodexAccounts: true,
+            fetcher: UsageFetcher(),
+            claudeFetcher: ClaudeUsageFetcher(browserDetection: browserDetection),
+            browserDetection: browserDetection,
+            persistCLISessions: true,
+            persistentCLISessionIdleWindow: Self.serveCLISessionIdleWindow(refreshInterval: refreshInterval))
+
+        var output = UsageCommandOutput()
+        for provider in selection.asList {
+            let providerOutput = await ProviderInteractionContext.$current.withValue(.background) {
+                await Self.fetchUsageOutputs(
+                    provider: provider,
+                    status: nil,
+                    tokenContext: tokenContext,
+                    command: command)
+            }
+            output.merge(providerOutput)
+        }
+
+        return Self.serveJSON(
+            output.payload,
+            usageCacheKeys: output.payload.map(\.cacheAccountKey))
+    }
+
+    private static func serveCost(provider rawProvider: String?, config: CodexBarConfig) async -> CLILocalHTTPResponse {
+        let selection: ProviderSelection
+        do {
+            selection = try Self.serveProviderSelection(rawProvider: rawProvider, config: config)
+        } catch {
+            return Self.serveError(status: .badRequest, message: error.localizedDescription)
+        }
+
+        let providers = Self.costProviders(from: selection)
+        guard !providers.isEmpty else {
+            return Self.serveError(status: .badRequest, message: "cost is only supported for Claude and Codex")
+        }
+
+        let fetcher = CostUsageFetcher()
+        var payload: [CostPayload] = []
+        for provider in providers {
+            do {
+                let snapshot = try await fetcher.loadTokenSnapshot(
+                    provider: provider,
+                    forceRefresh: false)
+                payload.append(Self.makeCostPayload(provider: provider, snapshot: snapshot, error: nil))
+            } catch {
+                payload.append(Self.makeCostPayload(provider: provider, snapshot: nil, error: error))
+            }
+        }
+
+        return Self.serveJSON(payload)
+    }
+
+    private static func serveProviderSelection(
+        rawProvider: String?,
+        config: CodexBarConfig) throws -> ProviderSelection
+    {
+        guard let rawProvider, !rawProvider.isEmpty else {
+            return providerSelection(rawOverride: nil, enabled: config.enabledProviders())
+        }
+        guard let selection = ProviderSelection(argument: rawProvider) else {
+            throw CLIServeArgumentError.invalidProvider(rawProvider)
+        }
+        return selection
+    }
+
+    static func serveHealthResponse(version: String?) -> CLILocalHTTPResponse {
+        self.serveJSON(ServeHealthPayload(status: "ok", version: version))
+    }
+
+    private static func serveJSON(
+        _ payload: some Encodable,
+        status: CLIHTTPStatus = .ok,
+        usageCacheKeys: [String?]? = nil) -> CLILocalHTTPResponse
+    {
+        let json = Self.encodeJSON(payload, pretty: false) ?? "{}"
+        return CLILocalHTTPResponse(
+            status: status,
+            body: Data(json.utf8),
+            usageCacheKeys: usageCacheKeys)
+    }
+
+    private static func serveError(status: CLIHTTPStatus, message: String) -> CLILocalHTTPResponse {
+        self.serveJSON(ServeErrorPayload(error: message), status: status)
+    }
+}
diff --git a/Sources/CodexBarCLI/CLITerminationSignalMonitor.swift b/Sources/CodexBarCLI/CLITerminationSignalMonitor.swift
new file mode 100644
index 0000000000..61dc2f48b9
--- /dev/null
+++ b/Sources/CodexBarCLI/CLITerminationSignalMonitor.swift
@@ -0,0 +1,79 @@
+import CodexBarCore
+import Dispatch
+import Foundation
+#if canImport(Darwin)
+import Darwin
+#elseif canImport(Glibc)
+import Glibc
+#elseif canImport(Musl)
+import Musl
+#endif
+
+private func handleCLITerminationSignal(_: Int32) {}
+
+final class CLITerminationSignalMonitor: @unchecked Sendable {
+    static let signalNumbers = [SIGINT, SIGTERM, SIGHUP]
+
+    private let lock = NSLock()
+    private let sources: [DispatchSourceSignal]
+    private var isCancelled = false
+
+    init(onSignal: @escaping @Sendable (Int32) -> Void) {
+        self.sources = Self.signalNumbers.map { signalNumber in
+            Self.installCaptureHandler(for: signalNumber)
+            let source = DispatchSource.makeSignalSource(signal: signalNumber, queue: .global(qos: .utility))
+            source.setEventHandler {
+                onSignal(signalNumber)
+            }
+            source.resume()
+            return source
+        }
+    }
+
+    func cancel() {
+        self.lock.lock()
+        guard !self.isCancelled else {
+            self.lock.unlock()
+            return
+        }
+        self.isCancelled = true
+        self.lock.unlock()
+
+        for source in self.sources {
+            source.cancel()
+        }
+        for signalNumber in Self.signalNumbers {
+            Self.restoreDefaultHandler(for: signalNumber)
+        }
+    }
+
+    deinit {
+        self.cancel()
+    }
+
+    static func terminateActiveHelpersAndReraise(_ signalNumber: Int32) {
+        TTYCommandRunner.terminateActiveProcessesForAppShutdown()
+        self.restoreDefaultHandler(for: signalNumber)
+        _ = kill(getpid(), signalNumber)
+    }
+
+    private static func installCaptureHandler(for signalNumber: Int32) {
+        #if canImport(Darwin)
+        _ = Darwin.signal(signalNumber, handleCLITerminationSignal)
+        #elseif canImport(Glibc)
+        _ = Glibc.signal(signalNumber, handleCLITerminationSignal)
+        #elseif canImport(Musl)
+        _ = Musl.signal(signalNumber, handleCLITerminationSignal)
+        #endif
+    }
+
+    private static func restoreDefaultHandler(for signalNumber: Int32) {
+        #if canImport(Darwin)
+        _ = Darwin.signal(signalNumber, SIG_DFL)
+        #elseif canImport(Glibc)
+        _ = Glibc.signal(signalNumber, SIG_DFL)
+        #elseif canImport(Musl)
+        _ = Musl.signal(signalNumber, SIG_DFL)
+        #endif
+    }
+}
diff --git a/Sources/CodexBarCLI/CLIUsageCommand.swift b/Sources/CodexBarCLI/CLIUsageCommand.swift
index 491ad50242..62d527a32c 100644
--- a/Sources/CodexBarCLI/CLIUsageCommand.swift
+++ b/Sources/CodexBarCLI/CLIUsageCommand.swift
@@ -14,9 +14,15 @@ struct UsageCommandContext {
     let useColor: Bool
     let resetStyle: ResetTimeDisplayStyle
     let jsonOnly: Bool
+    let includeAllCodexAccounts: Bool
     let fetcher: UsageFetcher
     let claudeFetcher: ClaudeUsageFetcher
     let browserDetection: BrowserDetection
+    /// True for long-lived hosts (`codexbar serve`) that keep warm provider
+    /// helper sessions (such as the managed Antigravity `agy` process) alive
+    /// between fetches instead of resetting after each one-shot fetch.
+    var persistCLISessions: Bool = false
+    var persistentCLISessionIdleWindow: TimeInterval?
 }
 
 struct UsageCommandOutput {
@@ -85,7 +91,11 @@ extension CodexBarCLI {
                     output: output,
                     kind: .args)
             }
-            guard TokenAccountSupportCatalog.support(for: providerList[0]) != nil else {
+            let supportsAllCodexAccounts = providerList[0] == .codex
+                && tokenSelection.allAccounts
+                && tokenSelection.label == nil
+                && tokenSelection.index == nil
+            guard supportsAllCodexAccounts || TokenAccountSupportCatalog.support(for: providerList[0]) != nil else {
                 Self.exit(
                     code: .failure,
                     message: "Error: \(providerList[0].rawValue) does not support token accounts.",
@@ -94,21 +104,6 @@ extension CodexBarCLI {
             }
         }
 
-        #if !os(macOS)
-        if let parsedSourceMode {
-            let requiresWeb = providerList.contains { selectedProvider in
-                Self.sourceModeRequiresWebSupport(parsedSourceMode, provider: selectedProvider)
-            }
-            if requiresWeb {
-                Self.exit(
-                    code: .failure,
-                    message: "Error: selected source requires web support and is only supported on macOS.",
-                    output: output,
-                    kind: .runtime)
-            }
-        }
-        #endif
-
         let browserDetection = BrowserDetection()
         let fetcher = UsageFetcher()
         let claudeFetcher = ClaudeUsageFetcher(browserDetection: browserDetection)
@@ -137,6 +132,7 @@ extension CodexBarCLI {
             useColor: useColor,
             resetStyle: resetStyle,
             jsonOnly: output.jsonOnly,
+            includeAllCodexAccounts: tokenSelection.allAccounts && providerList == [.codex],
             fetcher: fetcher,
             claudeFetcher: claudeFetcher,
             browserDetection: browserDetection)
@@ -164,9 +160,7 @@ extension CodexBarCLI {
                 print(sections.joined(separator: "\n\n"))
             }
         case .json:
-            if !payload.isEmpty {
-                Self.printJSON(payload, pretty: output.pretty)
-            }
+            Self.printJSON(payload, pretty: output.pretty)
         }
 
         Self.exit(code: exitCode, output: output, kind: exitCode == .success ? .runtime : .provider)
@@ -178,6 +172,23 @@ extension CodexBarCLI {
         tokenContext: TokenAccountCLIContext,
         command: UsageCommandContext) async -> UsageCommandOutput
     {
+        if provider == .codex, command.includeAllCodexAccounts {
+            var output = UsageCommandOutput()
+            let accounts = tokenContext.visibleCodexAccounts().visibleAccounts
+            let selections: [CodexVisibleAccount?] = accounts.isEmpty ? [nil] : accounts.map { Optional($0) }
+            for visibleAccount in selections {
+                let result = await Self.fetchUsageOutput(
+                    provider: provider,
+                    account: nil,
+                    codexVisibleAccount: visibleAccount,
+                    status: status,
+                    tokenContext: tokenContext,
+                    command: command)
+                output.merge(result)
+            }
+            return output
+        }
+
         let accounts: [ProviderTokenAccount]
         do {
             accounts = try tokenContext.resolvedAccounts(for: provider)
@@ -233,6 +244,7 @@ extension CodexBarCLI {
     private static func fetchUsageOutput(
         provider: UsageProvider,
         account: ProviderTokenAccount?,
+        codexVisibleAccount: CodexVisibleAccount? = nil,
         status: ProviderStatusPayload?,
         tokenContext: TokenAccountCLIContext,
         command: UsageCommandContext) async -> UsageCommandOutput
@@ -241,20 +253,35 @@ extension CodexBarCLI {
         let env = tokenContext.environment(
             base: ProcessInfo.processInfo.environment,
             provider: provider,
-            account: account)
-        let settings = tokenContext.settingsSnapshot(for: provider, account: account)
+            account: account,
+            codexActiveSourceOverride: codexVisibleAccount?.selectionSource)
+        let settings = tokenContext.settingsSnapshot(
+            for: provider,
+            account: account,
+            codexActiveSourceOverride: codexVisibleAccount?.selectionSource)
         let configSource = tokenContext.preferredSourceMode(for: provider)
         let baseSource = command.sourceModeOverride ?? configSource
         let effectiveSourceMode = tokenContext.effectiveSourceMode(
             base: baseSource,
             provider: provider,
             account: account)
+        let cacheAccountKey = Self.usageCacheAccountKey(
+            provider: provider,
+            account: account,
+            codexVisibleAccount: codexVisibleAccount)
 
         #if !os(macOS)
-        if Self.sourceModeRequiresWebSupport(effectiveSourceMode, provider: provider) {
+        if Self.sourceModeRequiresWebSupport(
+            effectiveSourceMode,
+            provider: provider,
+            environment: env,
+            settings: settings)
+        {
             return Self.webSourceUnsupportedOutput(
                 provider: provider,
-                account: account,
+                account: (
+                    label: account?.label ?? codexVisibleAccount?.menuDisplayName,
+                    cacheKey: cacheAccountKey),
                 source: effectiveSourceMode.rawValue,
                 status: status,
                 command: command)
@@ -270,9 +297,14 @@ extension CodexBarCLI {
             verbose: command.verbose,
             env: env,
             settings: settings,
-            fetcher: command.fetcher,
+            fetcher: tokenContext.fetcher(base: command.fetcher, provider: provider, env: env),
             claudeFetcher: command.claudeFetcher,
-            browserDetection: command.browserDetection)
+            browserDetection: command.browserDetection,
+            selectedTokenAccountID: account?.id,
+            tokenAccountTokenUpdater: tokenContext.tokenUpdater(for: account),
+            providerManualTokenUpdater: tokenContext.manualTokenUpdater(),
+            persistsCLISessions: Self.persistsCLISessions(provider: provider, command: command),
+            persistentCLISessionIdleWindow: command.persistentCLISessionIdleWindow)
         let outcome = await Self.fetchProviderUsage(
             provider: provider,
             context: fetchContext)
@@ -290,11 +322,16 @@ extension CodexBarCLI {
             var usage = result.usage.scoped(to: provider)
             if let account {
                 usage = tokenContext.applyAccountLabel(usage, provider: provider, account: account)
+            } else if let codexVisibleAccount {
+                usage = tokenContext.applyCodexVisibleAccountLabel(usage, account: codexVisibleAccount)
             }
 
             var dashboard = result.dashboard
             if dashboard == nil, command.format == .json, provider == .codex {
-                dashboard = Self.loadOpenAIDashboardIfAvailable(usage: usage, fetcher: command.fetcher)
+                dashboard = Self.loadOpenAIDashboardIfAvailable(
+                    usage: usage,
+                    sourceLabel: result.sourceLabel,
+                    context: fetchContext)
             }
 
             let descriptor = ProviderDescriptorRegistry.descriptor(for: provider)
@@ -330,7 +367,8 @@ extension CodexBarCLI {
             case .json:
                 output.payload.append(ProviderPayload(
                     provider: provider,
-                    account: account?.label,
+                    account: account?.label ?? codexVisibleAccount?.menuDisplayName,
+                    cacheAccountKey: cacheAccountKey,
                     version: version,
                     source: source,
                     status: status,
@@ -338,22 +376,24 @@ extension CodexBarCLI {
                     credits: result.credits,
                     antigravityPlanInfo: antigravityPlanInfo,
                     openaiDashboard: dashboard,
-                    error: nil))
+                    error: nil,
+                    pace: CLIRenderer.providerPacePayload(provider: provider, snapshot: usage)))
             }
         case let .failure(error):
             output.exitCode = Self.mapError(error)
             if command.format == .json {
                 output.payload.append(Self.makeProviderErrorPayload(
                     provider: provider,
-                    account: account?.label,
+                    account: account?.label ?? codexVisibleAccount?.menuDisplayName,
+                    cacheAccountKey: cacheAccountKey,
                     source: effectiveSourceMode.rawValue,
                     status: status,
                     error: error,
                     kind: .provider))
             } else if !command.jsonOnly {
-                if let account {
+                if let accountLabel = account?.label ?? codexVisibleAccount?.menuDisplayName {
                     Self.writeStderr(
-                        "Error (\(provider.rawValue) - \(account.label)): \(error.localizedDescription)\n")
+                        "Error (\(provider.rawValue) - \(accountLabel)): \(error.localizedDescription)\n")
                 } else {
                     Self.writeStderr("Error: \(error.localizedDescription)\n")
                 }
@@ -367,6 +407,47 @@ extension CodexBarCLI {
             }
         }
 
+        return await Self.finishUsageOutput(output, provider: provider, command: command)
+    }
+
+    private static func holdsAntigravitySession(
+        provider: UsageProvider,
+        command: UsageCommandContext) -> Bool
+    {
+        self.holdsAntigravityCLISessionForPlanDebug(
+            provider: provider,
+            planDebugEnabled: command.antigravityPlanDebug,
+            jsonOnly: command.jsonOnly,
+            persistsCLISessions: command.persistCLISessions)
+    }
+
+    private static func persistsCLISessions(
+        provider: UsageProvider,
+        command: UsageCommandContext) -> Bool
+    {
+        command.persistCLISessions || self.holdsAntigravitySession(provider: provider, command: command)
+    }
+
+    static func holdsAntigravityCLISessionForPlanDebug(
+        provider: UsageProvider,
+        planDebugEnabled: Bool,
+        jsonOnly: Bool,
+        persistsCLISessions: Bool) -> Bool
+    {
+        provider == .antigravity
+            && planDebugEnabled
+            && !jsonOnly
+            && !persistsCLISessions
+    }
+
+    private static func finishUsageOutput(
+        _ output: UsageCommandOutput,
+        provider: UsageProvider,
+        command: UsageCommandContext) async -> UsageCommandOutput
+    {
+        if self.holdsAntigravitySession(provider: provider, command: command) {
+            await ProviderCLISessionLifecycle.shutdownPersistentSessions()
+        }
         return output
     }
 
@@ -402,7 +483,7 @@ extension CodexBarCLI {
 
     private static func webSourceUnsupportedOutput(
         provider: UsageProvider,
-        account: ProviderTokenAccount?,
+        account: (label: String?, cacheKey: String?),
         source: String,
         status: ProviderStatusPayload?,
         command: UsageCommandContext) -> UsageCommandOutput
@@ -417,7 +498,8 @@ extension CodexBarCLI {
         if command.format == .json {
             output.payload.append(Self.makeProviderErrorPayload(
                 provider: provider,
-                account: account?.label,
+                account: account.label,
+                cacheAccountKey: account.cacheKey,
                 source: source,
                 status: status,
                 error: error,
@@ -428,8 +510,82 @@ extension CodexBarCLI {
         return output
     }
 
-    static func sourceModeRequiresWebSupport(_ sourceMode: ProviderSourceMode, provider: UsageProvider) -> Bool {
-        switch sourceMode {
+    static func usageCacheAccountKey(
+        provider _: UsageProvider,
+        account: ProviderTokenAccount?,
+        codexVisibleAccount: CodexVisibleAccount?) -> String?
+    {
+        if let account {
+            return "token:\(account.id.uuidString.lowercased())"
+        }
+        if let codexVisibleAccount {
+            if let workspaceAccountID = codexVisibleAccount.workspaceAccountID?
+                .trimmingCharacters(in: .whitespacesAndNewlines),
+                !workspaceAccountID.isEmpty,
+                !codexVisibleAccount.email.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+            {
+                let email = codexVisibleAccount.email
+                    .trimmingCharacters(in: .whitespacesAndNewlines)
+                    .lowercased()
+                return "codex:workspace:\(workspaceAccountID):email:\(email)"
+            }
+            if let storedAccountID = codexVisibleAccount.storedAccountID {
+                return "codex:stored:\(storedAccountID.uuidString.lowercased())"
+            }
+            if let authFingerprint = codexVisibleAccount.authFingerprint {
+                return "codex:auth:\(authFingerprint)"
+            }
+            return nil
+        }
+        return nil
+    }
+
+    static func sourceModeRequiresWebSupport(
+        _ sourceMode: ProviderSourceMode,
+        provider: UsageProvider,
+        environment: [String: String]? = nil,
+        settings: ProviderSettingsSnapshot? = nil) -> Bool
+    {
+        guard provider != .grok, provider != .amp else {
+            return false
+        }
+        if provider == .codex, sourceMode == .auto {
+            return false
+        }
+        if provider == .opencodego {
+            if sourceMode == .auto || settings?.opencodego?.cookieSource == .manual {
+                return false
+            }
+        }
+        if provider == .commandcode,
+           settings?.commandcode?.cookieSource == .manual
+        {
+            return false
+        }
+        if provider == .ollama,
+           sourceMode == .auto
+        {
+            let hasEnvironmentToken = environment.map {
+                ProviderTokenResolver.ollamaToken(environment: $0) != nil
+            } == true
+            if settings?.ollama?.cookieSource == .off || hasEnvironmentToken {
+                return false
+            }
+        }
+        if provider == .kimi,
+           sourceMode == .auto,
+           environment.map({ ProviderTokenResolver.kimiAPIToken(environment: $0) != nil }) == true
+        {
+            return false
+        }
+        if provider == .mimo,
+           sourceMode == .auto,
+           let environment,
+           MiMoLocalUsageFallback.cacheExists(environment: environment)
+        {
+            return false
+        }
+        return switch sourceMode {
         case .web:
             true
         case .auto:
diff --git a/Sources/CodexBarCLI/DiagnoseOptions.swift b/Sources/CodexBarCLI/DiagnoseOptions.swift
new file mode 100644
index 0000000000..b47222c3f7
--- /dev/null
+++ b/Sources/CodexBarCLI/DiagnoseOptions.swift
@@ -0,0 +1,29 @@
+import CodexBarCore
+import Commander
+import Foundation
+
+struct DiagnoseOptions: CommanderParsable {
+    @Flag(names: [.short("v"), .long("verbose")], help: "Enable verbose logging")
+    var verbose: Bool = false
+
+    @Flag(name: .long("json-output"), help: "Emit machine-readable logs")
+    var jsonOutput: Bool = false
+
+    @Option(name: .long("log-level"), help: "Set log level (trace|verbose|debug|info|warning|error|critical)")
+    var logLevel: String?
+
+    @Option(name: .long("provider"), help: ProviderHelp.optionHelp)
+    var provider: String?
+
+    @Option(name: .long("format"), help: "Output format: json")
+    var format: String?
+
+    @Flag(name: .long("redact"), help: "Explicitly redact sensitive values (always enabled for diagnose)")
+    var redact: Bool = false
+
+    @Option(name: .long("output"), help: "Write redacted JSON diagnostic export to a file")
+    var output: String?
+
+    @Flag(name: .long("pretty"), help: "Pretty-print JSON output")
+    var pretty: Bool = false
+}
diff --git a/Sources/CodexBarCLI/TokenAccountCLI.swift b/Sources/CodexBarCLI/TokenAccountCLI.swift
index 7324fa8374..ad7ecb73ac 100644
--- a/Sources/CodexBarCLI/TokenAccountCLI.swift
+++ b/Sources/CodexBarCLI/TokenAccountCLI.swift
@@ -2,7 +2,7 @@ import CodexBarCore
 import Commander
 import Foundation
 
-struct TokenAccountCLISelection: Sendable {
+struct TokenAccountCLISelection {
     let label: String?
     let index: Int?
     let allAccounts: Bool
@@ -33,10 +33,20 @@ struct TokenAccountCLIContext {
     let selection: TokenAccountCLISelection
     let config: CodexBarConfig
     let accountsByProvider: [UsageProvider: ProviderTokenAccountData]
+    private let baseEnvironment: [String: String]
+    private let managedCodexAccountStoreURL: URL?
 
-    init(selection: TokenAccountCLISelection, config: CodexBarConfig, verbose _: Bool) throws {
+    init(
+        selection: TokenAccountCLISelection,
+        config: CodexBarConfig,
+        verbose _: Bool,
+        baseEnvironment: [String: String] = ProcessInfo.processInfo.environment,
+        managedCodexAccountStoreURL: URL? = nil) throws
+    {
         self.selection = selection
         self.config = config
+        self.baseEnvironment = baseEnvironment
+        self.managedCodexAccountStoreURL = managedCodexAccountStoreURL
         self.accountsByProvider = Dictionary(uniqueKeysWithValues: config.providers.compactMap { provider in
             guard let accounts = provider.tokenAccounts else { return nil }
             return (provider.id, accounts)
@@ -75,89 +85,134 @@ struct TokenAccountCLIContext {
         return [data.accounts[clamped]]
     }
 
-    func settingsSnapshot(for provider: UsageProvider, account: ProviderTokenAccount?) -> ProviderSettingsSnapshot? {
+    func settingsSnapshot(
+        for provider: UsageProvider,
+        account: ProviderTokenAccount?,
+        codexActiveSourceOverride: CodexActiveSource? = nil) -> ProviderSettingsSnapshot?
+    {
         let config = self.providerConfig(for: provider)
-        let cookieHeader = self.manualCookieHeader(provider: provider, account: account, config: config)
-        let cookieSource = self.cookieSource(provider: provider, account: account, config: config)
+        if let snapshot = self.makeCookieBackedSnapshot(provider: provider, account: account, config: config) {
+            return snapshot
+        }
 
         switch provider {
         case .codex:
-            return self.makeSnapshot(
-                codex: ProviderSettingsSnapshot.CodexProviderSettings(
-                    usageDataSource: .auto,
-                    cookieSource: cookieSource,
-                    manualCookieHeader: cookieHeader))
+            return self.makeSnapshot(codex: self.makeCodexSettingsSnapshot(
+                account: account,
+                codexActiveSourceOverride: codexActiveSourceOverride))
         case .claude:
-            let claudeSource: ClaudeUsageDataSource = if provider == .claude,
-                                                         let account,
-                                                         TokenAccountSupportCatalog.isClaudeOAuthToken(account.token)
-            {
+            let routing = self.claudeCredentialRouting(account: account, config: config)
+            let claudeSource: ClaudeUsageDataSource = if routing.adminAPIKey != nil {
+                .api
+            } else if routing.isOAuth {
                 .oauth
             } else {
                 .auto
             }
-            let effectiveSource = (claudeSource == .oauth) ? ProviderCookieSource.off : cookieSource
+            let cookieSource = routing.isOAuth || routing.adminAPIKey != nil
+                ? ProviderCookieSource.off
+                : self.cookieSource(provider: provider, account: account, config: config)
             return self.makeSnapshot(
                 claude: ProviderSettingsSnapshot.ClaudeProviderSettings(
                     usageDataSource: claudeSource,
                     webExtrasEnabled: false,
-                    cookieSource: effectiveSource,
-                    manualCookieHeader: claudeSource == .oauth ? nil : cookieHeader))
-        case .cursor:
-            return self.makeSnapshot(
-                cursor: ProviderSettingsSnapshot.CursorProviderSettings(
                     cookieSource: cookieSource,
-                    manualCookieHeader: cookieHeader))
+                    manualCookieHeader: routing.manualCookieHeader,
+                    organizationID: account?.sanitizedOrganizationID))
+        case .zai:
+            return self.makeSnapshot(
+                zai: ProviderSettingsSnapshot.ZaiProviderSettings(apiRegion: self.resolveZaiRegion(config)))
+        case .moonshot:
+            return self.makeSnapshot(
+                moonshot: ProviderSettingsSnapshot.MoonshotProviderSettings(
+                    region: self.resolveMoonshotRegion(config)))
+        case .kilo:
+            return self.makeSnapshot(
+                kilo: ProviderSettingsSnapshot.KiloProviderSettings(
+                    usageDataSource: Self.kiloUsageDataSource(from: config?.source),
+                    extrasEnabled: Self.kiloExtrasEnabled(from: config)))
+        case .jetbrains:
+            return self.makeSnapshot(
+                jetbrains: ProviderSettingsSnapshot.JetBrainsProviderSettings(
+                    ideBasePath: nil))
+        default:
+            return nil
+        }
+    }
+
+    private func makeCookieBackedSnapshot(
+        provider: UsageProvider,
+        account: ProviderTokenAccount?,
+        config: ProviderConfig?) -> ProviderSettingsSnapshot?
+    {
+        let cookieSettings = self.cookieSettings(provider: provider, account: account, config: config)
+
+        switch provider {
+        case .cursor:
+            return self.makeSnapshot(cursor: self.makeProviderCookieSettings(cookieSettings))
         case .opencode:
             return self.makeSnapshot(
                 opencode: ProviderSettingsSnapshot.OpenCodeProviderSettings(
-                    cookieSource: cookieSource,
-                    manualCookieHeader: cookieHeader,
+                    cookieSource: cookieSettings.cookieSource,
+                    manualCookieHeader: cookieSettings.manualCookieHeader,
                     workspaceID: config?.workspaceID))
-        case .factory:
+        case .opencodego:
             return self.makeSnapshot(
-                factory: ProviderSettingsSnapshot.FactoryProviderSettings(
-                    cookieSource: cookieSource,
-                    manualCookieHeader: cookieHeader))
+                opencodego: ProviderSettingsSnapshot.OpenCodeProviderSettings(
+                    cookieSource: cookieSettings.cookieSource,
+                    manualCookieHeader: cookieSettings.manualCookieHeader,
+                    workspaceID: config?.workspaceID))
+        case .commandcode:
+            return self.makeSnapshot(commandcode: self.makeProviderCookieSettings(cookieSettings))
+        case .alibaba:
+            return self.makeSnapshot(
+                alibaba: ProviderSettingsSnapshot.AlibabaCodingPlanProviderSettings(
+                    cookieSource: cookieSettings.cookieSource,
+                    manualCookieHeader: cookieSettings.manualCookieHeader,
+                    apiRegion: self.resolveAlibabaCodingPlanRegion(config)))
+        case .alibabatokenplan:
+            return self.makeSnapshot(alibabaTokenPlan: self.makeProviderCookieSettings(cookieSettings))
+        case .factory:
+            return self.makeSnapshot(factory: self.makeProviderCookieSettings(cookieSettings))
         case .minimax:
             return self.makeSnapshot(
                 minimax: ProviderSettingsSnapshot.MiniMaxProviderSettings(
-                    cookieSource: cookieSource,
-                    manualCookieHeader: cookieHeader,
+                    cookieSource: cookieSettings.cookieSource,
+                    manualCookieHeader: cookieSettings.manualCookieHeader,
                     apiRegion: self.resolveMiniMaxRegion(config)))
+        case .manus:
+            return self.makeSnapshot(manus: self.makeProviderCookieSettings(cookieSettings))
         case .augment:
-            return self.makeSnapshot(
-                augment: ProviderSettingsSnapshot.AugmentProviderSettings(
-                    cookieSource: cookieSource,
-                    manualCookieHeader: cookieHeader))
+            return self.makeSnapshot(augment: self.makeProviderCookieSettings(cookieSettings))
         case .amp:
-            return self.makeSnapshot(
-                amp: ProviderSettingsSnapshot.AmpProviderSettings(
-                    cookieSource: cookieSource,
-                    manualCookieHeader: cookieHeader))
+            return self.makeSnapshot(amp: self.makeProviderCookieSettings(cookieSettings))
         case .ollama:
-            return self.makeSnapshot(
-                ollama: ProviderSettingsSnapshot.OllamaProviderSettings(
-                    cookieSource: cookieSource,
-                    manualCookieHeader: cookieHeader))
+            return self.makeSnapshot(ollama: self.makeProviderCookieSettings(cookieSettings))
         case .kimi:
+            return self.makeSnapshot(kimi: self.makeProviderCookieSettings(cookieSettings))
+        case .perplexity:
+            return self.makeSnapshot(perplexity: self.makeProviderCookieSettings(cookieSettings))
+        case .mimo:
+            return self.makeSnapshot(mimo: self.makeProviderCookieSettings(cookieSettings))
+        case .doubao:
+            return nil
+        case .abacus:
+            return self.makeSnapshot(abacus: self.makeProviderCookieSettings(cookieSettings))
+        case .mistral:
+            return self.makeSnapshot(mistral: self.makeProviderCookieSettings(cookieSettings))
+        case .stepfun:
+            let stepfunSettings = self.cookieSettings(
+                provider: provider,
+                account: account,
+                config: config,
+                configuredHeader: config?.sanitizedRegion ?? config?.sanitizedCookieHeader)
             return self.makeSnapshot(
-                kimi: ProviderSettingsSnapshot.KimiProviderSettings(
-                    cookieSource: cookieSource,
-                    manualCookieHeader: cookieHeader))
-        case .zai:
-            return self.makeSnapshot(
-                zai: ProviderSettingsSnapshot.ZaiProviderSettings(apiRegion: self.resolveZaiRegion(config)))
-        case .kilo:
-            return self.makeSnapshot(
-                kilo: ProviderSettingsSnapshot.KiloProviderSettings(
-                    usageDataSource: Self.kiloUsageDataSource(from: config?.source),
-                    extrasEnabled: Self.kiloExtrasEnabled(from: config)))
-        case .jetbrains:
-            return self.makeSnapshot(
-                jetbrains: ProviderSettingsSnapshot.JetBrainsProviderSettings(
-                    ideBasePath: nil))
-        case .gemini, .antigravity, .copilot, .kiro, .vertexai, .kimik2, .synthetic, .openrouter, .warp:
+                stepfun: ProviderSettingsSnapshot.StepFunProviderSettings(
+                    cookieSource: stepfunSettings.cookieSource,
+                    manualToken: stepfunSettings.manualCookieHeader ?? "",
+                    username: config?.sanitizedAPIKey ?? "",
+                    password: ""))
+        default:
             return nil
         }
     }
@@ -167,53 +222,162 @@ struct TokenAccountCLIContext {
         claude: ProviderSettingsSnapshot.ClaudeProviderSettings? = nil,
         cursor: ProviderSettingsSnapshot.CursorProviderSettings? = nil,
         opencode: ProviderSettingsSnapshot.OpenCodeProviderSettings? = nil,
+        opencodego: ProviderSettingsSnapshot.OpenCodeProviderSettings? = nil,
+        alibaba: ProviderSettingsSnapshot.AlibabaCodingPlanProviderSettings? = nil,
+        alibabaTokenPlan: ProviderSettingsSnapshot.AlibabaTokenPlanProviderSettings? = nil,
         factory: ProviderSettingsSnapshot.FactoryProviderSettings? = nil,
         minimax: ProviderSettingsSnapshot.MiniMaxProviderSettings? = nil,
+        manus: ProviderSettingsSnapshot.ManusProviderSettings? = nil,
         zai: ProviderSettingsSnapshot.ZaiProviderSettings? = nil,
+        moonshot: ProviderSettingsSnapshot.MoonshotProviderSettings? = nil,
         kilo: ProviderSettingsSnapshot.KiloProviderSettings? = nil,
         kimi: ProviderSettingsSnapshot.KimiProviderSettings? = nil,
         augment: ProviderSettingsSnapshot.AugmentProviderSettings? = nil,
         amp: ProviderSettingsSnapshot.AmpProviderSettings? = nil,
+        commandcode: ProviderSettingsSnapshot.CommandCodeProviderSettings? = nil,
         ollama: ProviderSettingsSnapshot.OllamaProviderSettings? = nil,
-        jetbrains: ProviderSettingsSnapshot.JetBrainsProviderSettings? = nil) -> ProviderSettingsSnapshot
+        jetbrains: ProviderSettingsSnapshot.JetBrainsProviderSettings? = nil,
+        perplexity: ProviderSettingsSnapshot.PerplexityProviderSettings? = nil,
+        mimo: ProviderSettingsSnapshot.MiMoProviderSettings? = nil,
+        abacus: ProviderSettingsSnapshot.AbacusProviderSettings? = nil,
+        mistral: ProviderSettingsSnapshot.MistralProviderSettings? = nil,
+        stepfun: ProviderSettingsSnapshot.StepFunProviderSettings? = nil) -> ProviderSettingsSnapshot
     {
         ProviderSettingsSnapshot.make(
             codex: codex,
             claude: claude,
             cursor: cursor,
             opencode: opencode,
+            opencodego: opencodego,
+            alibaba: alibaba,
+            alibabaTokenPlan: alibabaTokenPlan,
             factory: factory,
             minimax: minimax,
+            manus: manus,
             zai: zai,
             kilo: kilo,
             kimi: kimi,
             augment: augment,
+            moonshot: moonshot,
             amp: amp,
+            commandcode: commandcode,
             ollama: ollama,
-            jetbrains: jetbrains)
+            jetbrains: jetbrains,
+            perplexity: perplexity,
+            mimo: mimo,
+            abacus: abacus,
+            mistral: mistral,
+            stepfun: stepfun)
+    }
+
+    private func makeCodexSettingsSnapshot(
+        account: ProviderTokenAccount?,
+        codexActiveSourceOverride: CodexActiveSource? = nil) ->
+        ProviderSettingsSnapshot.CodexProviderSettings
+    {
+        let config = self.providerConfig(for: .codex)
+        let reconciliationSnapshot = self.codexAccountReconciler(
+            activeSource: codexActiveSourceOverride).loadSnapshot()
+        let resolvedActiveSource = CodexActiveSourceResolver.resolve(from: reconciliationSnapshot)
+        return CodexProviderSettingsBuilder.make(input: CodexProviderSettingsBuilderInput(
+            usageDataSource: .auto,
+            cookieSource: self.cookieSource(provider: .codex, account: account, config: config),
+            manualCookieHeader: self.manualCookieHeader(provider: .codex, account: account, config: config),
+            reconciliationSnapshot: reconciliationSnapshot,
+            resolvedActiveSource: resolvedActiveSource))
     }
 
     func environment(
         base: [String: String],
         provider: UsageProvider,
-        account: ProviderTokenAccount?) -> [String: String]
+        account: ProviderTokenAccount?,
+        codexActiveSourceOverride: CodexActiveSource? = nil) -> [String: String]
     {
         let providerConfig = self.providerConfig(for: provider)
-        var env = ProviderConfigEnvironment.applyAPIKeyOverride(
+        var env = ProviderEnvironmentResolver.resolve(
             base: base,
             provider: provider,
-            config: providerConfig)
-        // If token account is selected, use its token instead of config's apiKey
-        if let account,
-           let override = TokenAccountSupportCatalog.envOverride(for: provider, token: account.token)
+            config: providerConfig,
+            selectedAccount: account)
+        if provider == .codex,
+           let codexHomePath = self.codexHomePath(for: codexActiveSourceOverride)
         {
-            for (key, value) in override {
-                env[key] = value
-            }
+            env = CodexHomeScope.scopedEnvironment(base: env, codexHome: codexHomePath)
         }
         return env
     }
 
+    func tokenUpdater(for account: ProviderTokenAccount?) -> ProviderFetchContext.TokenAccountTokenUpdater? {
+        guard let account else { return nil }
+        return { provider, accountID, token in
+            guard accountID == account.id else { return }
+            try? Self.updateStoredTokenAccount(provider: provider, accountID: accountID, token: token)
+        }
+    }
+
+    func manualTokenUpdater() -> ProviderFetchContext.ProviderManualTokenUpdater {
+        { provider, token in
+            try? Self.updateStoredManualToken(provider: provider, token: token)
+        }
+    }
+
+    private static func updateStoredManualToken(provider: UsageProvider, token: String) throws {
+        guard provider == .stepfun else { return }
+        let trimmed = token.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else { return }
+
+        let store = CodexBarConfigStore()
+        var config = try store.load() ?? .makeDefault()
+        var providerConfig = config.providerConfig(for: provider) ?? ProviderConfig(id: provider)
+        providerConfig.region = trimmed
+        config.setProviderConfig(providerConfig)
+        try store.save(config)
+    }
+
+    private static func updateStoredTokenAccount(
+        provider: UsageProvider,
+        accountID: UUID,
+        token: String) throws
+    {
+        let trimmed = token.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else { return }
+
+        let store = CodexBarConfigStore()
+        guard var config = try store.load() else { return }
+        guard var providerConfig = config.providerConfig(for: provider),
+              let data = providerConfig.tokenAccounts,
+              let index = data.accounts.firstIndex(where: { $0.id == accountID })
+        else {
+            return
+        }
+
+        let existing = data.accounts[index]
+        var accounts = data.accounts
+        accounts[index] = ProviderTokenAccount(
+            id: existing.id,
+            label: existing.label,
+            token: trimmed,
+            addedAt: existing.addedAt,
+            lastUsed: existing.lastUsed,
+            externalIdentifier: existing.externalIdentifier,
+            organizationID: existing.organizationID)
+        providerConfig.tokenAccounts = ProviderTokenAccountData(
+            version: data.version,
+            accounts: accounts,
+            activeIndex: data.clampedActiveIndex())
+        config.setProviderConfig(providerConfig)
+        try store.save(config)
+    }
+
+    func fetcher(base: UsageFetcher, provider: UsageProvider, env: [String: String]) -> UsageFetcher {
+        guard provider == .codex else { return base }
+        return UsageFetcher(environment: env)
+    }
+
+    func visibleCodexAccounts() -> CodexVisibleAccountProjection {
+        self.codexAccountReconciler().loadVisibleAccounts()
+    }
+
     func applyAccountLabel(
         _ snapshot: UsageSnapshot,
         provider: UsageProvider,
@@ -232,19 +396,49 @@ struct TokenAccountCLIContext {
         return snapshot.withIdentity(identity)
     }
 
+    func applyCodexVisibleAccountLabel(_ snapshot: UsageSnapshot, account: CodexVisibleAccount) -> UsageSnapshot {
+        let existing = snapshot.identity(for: .codex)
+        let identity = ProviderIdentitySnapshot(
+            providerID: .codex,
+            accountEmail: account.email,
+            accountOrganization: account.workspaceLabel ?? existing?.accountOrganization,
+            loginMethod: existing?.loginMethod)
+        return snapshot.withIdentity(identity)
+    }
+
     func effectiveSourceMode(
         base: ProviderSourceMode,
         provider: UsageProvider,
         account: ProviderTokenAccount?) -> ProviderSourceMode
     {
-        guard base == .auto,
-              provider == .claude,
-              let account,
-              TokenAccountSupportCatalog.isClaudeOAuthToken(account.token)
-        else {
+        guard provider == .claude else {
+            return base
+        }
+        let config = self.providerConfig(for: provider)
+        let routing = self.claudeCredentialRouting(account: account, config: config)
+
+        if base == .auto {
+            if routing.adminAPIKey != nil { return .api }
+            return routing.isOAuth ? .oauth : base
+        }
+
+        guard base == .cli, account != nil else {
+            return base
+        }
+
+        // Claude CLI usage is ambient to the active local CLI profile, so per-token-account
+        // CLI reads can be mislabeled as separate accounts. Use the selected account's
+        // routable credential instead.
+        switch routing {
+        case .adminAPIKey:
+            return .api
+        case .oauth:
+            return .oauth
+        case .webCookie:
+            return .web
+        case .none:
             return base
         }
-        return .oauth
     }
 
     func preferredSourceMode(for provider: UsageProvider) -> ProviderSourceMode {
@@ -256,22 +450,59 @@ struct TokenAccountCLIContext {
         self.config.providerConfig(for: provider)
     }
 
+    private func codexAccountReconciler(activeSource: CodexActiveSource? = nil) -> DefaultCodexAccountReconciler {
+        let storeLoader: @Sendable () throws -> ManagedCodexAccountSet = if let managedCodexAccountStoreURL {
+            {
+                try FileManagedCodexAccountStore(fileURL: managedCodexAccountStoreURL).loadAccounts()
+            }
+        } else {
+            {
+                try FileManagedCodexAccountStore().loadAccounts()
+            }
+        }
+        return DefaultCodexAccountReconciler(
+            storeLoader: storeLoader,
+            activeSource: activeSource ?? self.providerConfig(for: .codex)?.codexActiveSource ?? .liveSystem,
+            baseEnvironment: self.baseEnvironment,
+            profileHomePaths: self.providerConfig(for: .codex)?.codexProfileHomePaths ?? [],
+            managedEnvironmentBuilder: { environment, account in
+                CodexHomeScope.scopedEnvironment(base: environment, codexHome: account.managedHomePath)
+            })
+    }
+
+    private func codexHomePath(for activeSourceOverride: CodexActiveSource?) -> String? {
+        let activeSource: CodexActiveSource = if let activeSourceOverride {
+            activeSourceOverride
+        } else {
+            CodexActiveSourceResolver.resolve(from: self.codexAccountReconciler().loadSnapshot())
+                .resolvedSource
+        }
+
+        switch activeSource {
+        case .liveSystem:
+            return nil
+        case let .managedAccount(id):
+            let accounts: ManagedCodexAccountSet? = if let managedCodexAccountStoreURL {
+                try? FileManagedCodexAccountStore(fileURL: managedCodexAccountStoreURL).loadAccounts()
+            } else {
+                try? FileManagedCodexAccountStore().loadAccounts()
+            }
+            return accounts?.account(id: id)?.managedHomePath
+        case let .profileHome(path):
+            guard let normalizedPath = CodexHomeScope.normalizedHomePath(path) else { return nil }
+            let configuredPaths = self.providerConfig(for: .codex)?.codexProfileHomePaths ?? []
+            return configuredPaths.contains {
+                CodexHomeScope.normalizedHomePath($0) == normalizedPath
+            } ? normalizedPath : nil
+        }
+    }
+
     private func manualCookieHeader(
         provider: UsageProvider,
         account: ProviderTokenAccount?,
         config: ProviderConfig?) -> String?
     {
-        if let account,
-           let support = TokenAccountSupportCatalog.support(for: provider),
-           case .cookieHeader = support.injection
-        {
-            if provider == .claude, TokenAccountSupportCatalog.isClaudeOAuthToken(account.token) {
-                return nil
-            }
-            let header = TokenAccountSupportCatalog.normalizedCookieHeader(account.token, support: support)
-            return header.isEmpty ? nil : header
-        }
-        return config?.sanitizedCookieHeader
+        self.cookieSettings(provider: provider, account: account, config: config).manualCookieHeader
     }
 
     private func cookieSource(
@@ -279,17 +510,37 @@ struct TokenAccountCLIContext {
         account: ProviderTokenAccount?,
         config: ProviderConfig?) -> ProviderCookieSource
     {
-        if let account, TokenAccountSupportCatalog.support(for: provider)?.requiresManualCookieSource == true {
-            if provider == .claude, TokenAccountSupportCatalog.isClaudeOAuthToken(account.token) {
-                return .off
-            }
-            return .manual
-        }
-        if let override = config?.cookieSource { return override }
-        if config?.sanitizedCookieHeader != nil {
-            return .manual
+        self.cookieSettings(provider: provider, account: account, config: config).cookieSource
+    }
+
+    private func cookieSettings(
+        provider: UsageProvider,
+        account: ProviderTokenAccount?,
+        config: ProviderConfig?,
+        configuredHeader: String? = nil) -> ProviderSettingsSnapshot.CookieProviderSettings
+    {
+        let configuredSource: ProviderCookieSource = if let override = config?.cookieSource {
+            override
+        } else if provider == .stepfun, config?.sanitizedRegion != nil {
+            .manual
+        } else if config?.sanitizedCookieHeader != nil {
+            .manual
+        } else {
+            .auto
         }
-        return .auto
+        return ProviderCookieSettingsResolver.resolve(
+            provider: provider,
+            configuredSource: configuredSource,
+            configuredHeader: configuredHeader ?? config?.sanitizedCookieHeader,
+            selectedAccount: account)
+    }
+
+    private func makeProviderCookieSettings<Settings: ProviderCookieSettings>(
+        _ resolved: ProviderSettingsSnapshot.CookieProviderSettings) -> Settings
+    {
+        Settings(
+            cookieSource: resolved.cookieSource,
+            manualCookieHeader: resolved.manualCookieHeader)
     }
 
     private func resolveZaiRegion(_ config: ProviderConfig?) -> ZaiAPIRegion {
@@ -310,6 +561,24 @@ struct TokenAccountCLIContext {
         return MiniMaxAPIRegion(rawValue: raw) ?? .global
     }
 
+    private func resolveMoonshotRegion(_ config: ProviderConfig?) -> MoonshotRegion? {
+        guard let raw = config?.region?.trimmingCharacters(in: .whitespacesAndNewlines),
+              !raw.isEmpty
+        else {
+            return nil
+        }
+        return MoonshotRegion(rawValue: raw) ?? .international
+    }
+
+    private func resolveAlibabaCodingPlanRegion(_ config: ProviderConfig?) -> AlibabaCodingPlanAPIRegion {
+        guard let raw = config?.region?.trimmingCharacters(in: .whitespacesAndNewlines),
+              !raw.isEmpty
+        else {
+            return .international
+        }
+        return AlibabaCodingPlanAPIRegion(rawValue: raw) ?? .international
+    }
+
     private static func kiloUsageDataSource(from source: ProviderSourceMode?) -> KiloUsageDataSource {
         guard let source else { return .auto }
         switch source {
@@ -326,4 +595,14 @@ struct TokenAccountCLIContext {
         guard self.kiloUsageDataSource(from: config?.source) == .auto else { return false }
         return config?.extrasEnabled ?? false
     }
+
+    private func claudeCredentialRouting(
+        account: ProviderTokenAccount?,
+        config: ProviderConfig?) -> ClaudeCredentialRouting
+    {
+        let manualCookieHeader = account == nil ? config?.sanitizedCookieHeader : nil
+        return ClaudeCredentialRouting.resolve(
+            tokenAccountToken: account?.token,
+            manualCookieHeader: manualCookieHeader)
+    }
 }
diff --git a/Sources/CodexBarClaudeWebProbe/main.swift b/Sources/CodexBarClaudeWebProbe/ClaudeWebProbeEntry.swift
similarity index 100%
rename from Sources/CodexBarClaudeWebProbe/main.swift
rename to Sources/CodexBarClaudeWebProbe/ClaudeWebProbeEntry.swift
diff --git a/Sources/CodexBarCore/AppGroupSupport.swift b/Sources/CodexBarCore/AppGroupSupport.swift
new file mode 100644
index 0000000000..b1b346d346
--- /dev/null
+++ b/Sources/CodexBarCore/AppGroupSupport.swift
@@ -0,0 +1,247 @@
+import Foundation
+#if os(macOS)
+import Security
+#endif
+
+public enum AppGroupSupport {
+    public static let defaultTeamID = "Y5PE65HELJ"
+    public static let teamIDInfoKey = "CodexBarTeamID"
+    public static let legacyReleaseGroupID = "group.com.steipete.codexbar"
+    public static let legacyDebugGroupID = "group.com.steipete.codexbar.debug"
+    public static let widgetSnapshotFilename = "widget-snapshot.json"
+    public static let migrationVersion = 1
+    public static let migrationVersionKey = "appGroupMigrationVersion"
+    private static let sharedDefaultsMigrationKeys = [
+        "debugDisableKeychainAccess",
+        "widgetSelectedProvider",
+    ]
+
+    public struct MigrationResult: Sendable {
+        public enum Status: String, Sendable {
+            case alreadyCompleted
+            case targetUnavailable
+            case noChangesNeeded
+            case migrated
+        }
+
+        public let status: Status
+        public let copiedSnapshot: Bool
+        public let copiedDefaults: Int
+
+        public init(status: Status, copiedSnapshot: Bool = false, copiedDefaults: Int = 0) {
+            self.status = status
+            self.copiedSnapshot = copiedSnapshot
+            self.copiedDefaults = copiedDefaults
+        }
+    }
+
+    public static func currentGroupID(for bundleID: String? = Bundle.main.bundleIdentifier) -> String {
+        self.currentGroupID(teamID: self.resolvedTeamID(), bundleID: bundleID)
+    }
+
+    static func currentGroupID(teamID: String, bundleID: String?) -> String {
+        let base = "\(teamID).com.steipete.codexbar"
+        return self.isDebugBundleID(bundleID) ? "\(base).debug" : base
+    }
+
+    public static func resolvedTeamID(bundle: Bundle = .main) -> String {
+        self.resolvedTeamID(
+            infoDictionaryOverride: bundle.infoDictionary,
+            bundleURLOverride: bundle.bundleURL)
+    }
+
+    static func resolvedTeamID(
+        infoDictionaryOverride: [String: Any]?,
+        bundleURLOverride: URL?) -> String
+    {
+        if let teamID = self.codeSignatureTeamID(bundleURL: bundleURLOverride) {
+            return teamID
+        }
+        if let teamID = infoDictionaryOverride?[self.teamIDInfoKey] as? String,
+           !teamID.isEmpty
+        {
+            return teamID
+        }
+        return self.defaultTeamID
+    }
+
+    public static func legacyGroupID(for bundleID: String? = Bundle.main.bundleIdentifier) -> String {
+        self.isDebugBundleID(bundleID) ? self.legacyDebugGroupID : self.legacyReleaseGroupID
+    }
+
+    public static func sharedDefaults(
+        bundleID: String? = Bundle.main.bundleIdentifier,
+        fileManager: FileManager = .default)
+        -> UserDefaults?
+    {
+        guard self.currentContainerURL(bundleID: bundleID, fileManager: fileManager) != nil else { return nil }
+        return UserDefaults(suiteName: self.currentGroupID(for: bundleID))
+    }
+
+    public static func currentContainerURL(
+        bundleID: String? = Bundle.main.bundleIdentifier,
+        fileManager: FileManager = .default)
+        -> URL?
+    {
+        #if os(macOS)
+        fileManager.containerURL(forSecurityApplicationGroupIdentifier: self.currentGroupID(for: bundleID))
+        #else
+        nil
+        #endif
+    }
+
+    public static func snapshotURL(
+        bundleID: String? = Bundle.main.bundleIdentifier,
+        fileManager: FileManager = .default,
+        homeDirectory: URL = FileManager.default.homeDirectoryForCurrentUser)
+        -> URL
+    {
+        if let container = self.currentContainerURL(bundleID: bundleID, fileManager: fileManager) {
+            return container.appendingPathComponent(self.widgetSnapshotFilename, isDirectory: false)
+        }
+
+        let directory = self.localFallbackDirectory(fileManager: fileManager, homeDirectory: homeDirectory)
+        return directory.appendingPathComponent(self.widgetSnapshotFilename, isDirectory: false)
+    }
+
+    public static func localFallbackDirectory(
+        fileManager: FileManager = .default,
+        homeDirectory _: URL = FileManager.default.homeDirectoryForCurrentUser)
+        -> URL
+    {
+        let base = fileManager.urls(for: .applicationSupportDirectory, in: .userDomainMask).first
+            ?? fileManager.temporaryDirectory
+        let directory = base.appendingPathComponent("CodexBar", isDirectory: true)
+        try? fileManager.createDirectory(at: directory, withIntermediateDirectories: true)
+        return directory
+    }
+
+    public static func legacyContainerCandidateURL(
+        bundleID: String? = Bundle.main.bundleIdentifier,
+        homeDirectory: URL = FileManager.default.homeDirectoryForCurrentUser)
+        -> URL
+    {
+        homeDirectory
+            .appendingPathComponent("Library", isDirectory: true)
+            .appendingPathComponent("Group Containers", isDirectory: true)
+            .appendingPathComponent(self.legacyGroupID(for: bundleID), isDirectory: true)
+    }
+
+    public static func migrateLegacyDataIfNeeded(
+        bundleID: String? = Bundle.main.bundleIdentifier,
+        standardDefaults: UserDefaults = .standard,
+        fileManager: FileManager = .default,
+        homeDirectory: URL = FileManager.default.homeDirectoryForCurrentUser,
+        currentDefaultsOverride: UserDefaults? = nil,
+        legacyDefaultsOverride: UserDefaults? = nil,
+        currentSnapshotURLOverride: URL? = nil,
+        legacySnapshotURLOverride: URL? = nil)
+        -> MigrationResult
+    {
+        if standardDefaults.integer(forKey: self.migrationVersionKey) >= self.migrationVersion {
+            return MigrationResult(status: .alreadyCompleted)
+        }
+
+        guard let currentDefaults = currentDefaultsOverride ?? self.sharedDefaults(
+            bundleID: bundleID,
+            fileManager: fileManager)
+        else {
+            return MigrationResult(status: .targetUnavailable)
+        }
+
+        let legacyDefaults = legacyDefaultsOverride ?? UserDefaults(suiteName: self.legacyGroupID(for: bundleID))
+        let currentSnapshotURL = currentSnapshotURLOverride
+            ?? self.currentContainerURL(bundleID: bundleID, fileManager: fileManager)?
+            .appendingPathComponent(self.widgetSnapshotFilename, isDirectory: false)
+        let legacySnapshotURL = legacySnapshotURLOverride
+            ?? self.legacyContainerCandidateURL(bundleID: bundleID, homeDirectory: homeDirectory)
+            .appendingPathComponent(self.widgetSnapshotFilename, isDirectory: false)
+
+        let copiedSnapshot = {
+            guard let currentSnapshotURL else { return false }
+            guard !fileManager.fileExists(atPath: currentSnapshotURL.path),
+                  fileManager.fileExists(atPath: legacySnapshotURL.path)
+            else {
+                return false
+            }
+            do {
+                try fileManager.createDirectory(
+                    at: currentSnapshotURL.deletingLastPathComponent(),
+                    withIntermediateDirectories: true)
+                try fileManager.copyItem(at: legacySnapshotURL, to: currentSnapshotURL)
+                return true
+            } catch {
+                return false
+            }
+        }()
+
+        let copiedDefaults = self.copyLegacySharedDefaults(
+            from: legacyDefaults,
+            to: currentDefaults)
+
+        let result = if copiedSnapshot || copiedDefaults > 0 {
+            MigrationResult(
+                status: .migrated,
+                copiedSnapshot: copiedSnapshot,
+                copiedDefaults: copiedDefaults)
+        } else {
+            MigrationResult(status: .noChangesNeeded)
+        }
+
+        standardDefaults.set(self.migrationVersion, forKey: self.migrationVersionKey)
+        return result
+    }
+
+    private static func copyLegacySharedDefaults(
+        from legacyDefaults: UserDefaults?,
+        to currentDefaults: UserDefaults) -> Int
+    {
+        guard let legacyDefaults else { return 0 }
+
+        var copied = 0
+        for key in self.sharedDefaultsMigrationKeys {
+            guard currentDefaults.object(forKey: key) == nil,
+                  let legacyValue = legacyDefaults.object(forKey: key)
+            else {
+                continue
+            }
+            currentDefaults.set(legacyValue, forKey: key)
+            copied += 1
+        }
+        return copied
+    }
+
+    private static func isDebugBundleID(_ bundleID: String?) -> Bool {
+        guard let bundleID, !bundleID.isEmpty else { return false }
+        return bundleID.contains(".debug")
+    }
+
+    private static func codeSignatureTeamID(bundleURL: URL?) -> String? {
+        #if os(macOS)
+        guard let bundleURL else { return nil }
+
+        var staticCode: SecStaticCode?
+        guard SecStaticCodeCreateWithPath(bundleURL as CFURL, SecCSFlags(), &staticCode) == errSecSuccess,
+              let code = staticCode
+        else {
+            return nil
+        }
+
+        var infoCF: CFDictionary?
+        guard SecCodeCopySigningInformation(
+            code,
+            SecCSFlags(rawValue: kSecCSSigningInformation),
+            &infoCF) == errSecSuccess,
+            let info = infoCF as? [String: Any],
+            let teamID = info[kSecCodeInfoTeamIdentifier as String] as? String,
+            !teamID.isEmpty
+        else {
+            return nil
+        }
+        return teamID
+        #else
+        _ = bundleURL
+        return nil
+        #endif
+    }
+}
diff --git a/Sources/CodexBarCore/AutoreleasePoolCompat.swift b/Sources/CodexBarCore/AutoreleasePoolCompat.swift
new file mode 100644
index 0000000000..7d0d32c4df
--- /dev/null
+++ b/Sources/CodexBarCore/AutoreleasePoolCompat.swift
@@ -0,0 +1,8 @@
+import Foundation
+
+#if os(Linux)
+@discardableResult
+func autoreleasepool<Result>(_ work: () throws -> Result) rethrows -> Result {
+    try work()
+}
+#endif
diff --git a/Sources/CodexBarCore/BoundedTaskJoin.swift b/Sources/CodexBarCore/BoundedTaskJoin.swift
new file mode 100644
index 0000000000..4054b4195c
--- /dev/null
+++ b/Sources/CodexBarCore/BoundedTaskJoin.swift
@@ -0,0 +1,81 @@
+import Foundation
+
+package enum BoundedTaskJoinOutcome<Value: Sendable> {
+    case value(Value)
+    case failure(any Error)
+    case timedOut
+}
+
+package final class BoundedTaskJoin<Value: Sendable>: @unchecked Sendable {
+    private let lock = NSLock()
+    private let sourceTask: Task<Value, Error>
+    private var outcome: BoundedTaskJoinOutcome<Value>?
+    private var continuation: CheckedContinuation<BoundedTaskJoinOutcome<Value>, Never>?
+    private var observerTask: Task<Void, Never>?
+    private var timeoutTask: Task<Void, Never>?
+
+    package init(sourceTask: Task<Value, Error>) {
+        self.sourceTask = sourceTask
+    }
+
+    package func value(joinGrace: Duration) async -> BoundedTaskJoinOutcome<Value> {
+        await withTaskCancellationHandler {
+            await withCheckedContinuation { continuation in
+                self.lock.lock()
+                if let outcome = self.outcome {
+                    self.lock.unlock()
+                    continuation.resume(returning: outcome)
+                    return
+                }
+
+                self.continuation = continuation
+                let sourceTask = self.sourceTask
+                self.observerTask = Task { [weak self] in
+                    do {
+                        let value = try await sourceTask.value
+                        self?.resolve(.value(value), cancelSource: false)
+                    } catch {
+                        self?.resolve(.failure(error), cancelSource: false)
+                    }
+                }
+                self.timeoutTask = Task { [weak self] in
+                    do {
+                        if joinGrace > .zero {
+                            try await Task.sleep(for: joinGrace)
+                        }
+                        self?.resolve(.timedOut, cancelSource: true)
+                    } catch {
+                        // The source completed or the caller canceled the race.
+                    }
+                }
+                self.lock.unlock()
+            }
+        } onCancel: {
+            self.resolve(.failure(CancellationError()), cancelSource: true)
+        }
+    }
+
+    private func resolve(_ outcome: BoundedTaskJoinOutcome<Value>, cancelSource: Bool) {
+        self.lock.lock()
+        guard self.outcome == nil else {
+            self.lock.unlock()
+            return
+        }
+
+        self.outcome = outcome
+        let continuation = self.continuation
+        self.continuation = nil
+        let observerTask = self.observerTask
+        let timeoutTask = self.timeoutTask
+        self.observerTask = nil
+        self.timeoutTask = nil
+        self.lock.unlock()
+
+        if cancelSource {
+            self.sourceTask.cancel()
+        }
+        observerTask?.cancel()
+        timeoutTask?.cancel()
+        continuation?.resume(returning: outcome)
+    }
+}
diff --git a/Sources/CodexBarCore/BrowserCookieAccessGate.swift b/Sources/CodexBarCore/BrowserCookieAccessGate.swift
index db0de16b62..0265079706 100644
--- a/Sources/CodexBarCore/BrowserCookieAccessGate.swift
+++ b/Sources/CodexBarCore/BrowserCookieAccessGate.swift
@@ -4,6 +4,17 @@ import Foundation
 import os.lock
 import SweetCookieKit
 
+enum BrowserCookieStoreAccessDecision: Equatable {
+    case allowed
+    case suppressed
+}
+
+struct BrowserCookieStoreAccessSuppressedError: LocalizedError {
+    var errorDescription: String? {
+        "Browser cookie store access is suppressed for this process."
+    }
+}
+
 public enum BrowserCookieAccessGate {
     private struct State {
         var loaded = false
@@ -15,10 +26,28 @@ public enum BrowserCookieAccessGate {
     private static let cooldownInterval: TimeInterval = 60 * 60 * 6
     private static let log = CodexBarLog.logger(LogCategories.browserCookieGate)
 
+    static let allowTestCookieAccessEnvironmentKey = "CODEXBAR_ALLOW_TEST_BROWSER_COOKIE_ACCESS"
+
+    static func cookieStoreAccessDecision(
+        homeDirectories: [URL],
+        processName: String = ProcessInfo.processInfo.processName,
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> BrowserCookieStoreAccessDecision
+    {
+        guard self.isRunningUnderTests(processName: processName, environment: environment),
+              environment[self.allowTestCookieAccessEnvironmentKey] != "1"
+        else {
+            return .allowed
+        }
+
+        let defaultHomes = Set(BrowserCookieClient.defaultHomeDirectories().map(Self.normalizedPath))
+        let usesDefaultHome = homeDirectories.contains { defaultHomes.contains(Self.normalizedPath($0)) }
+        return usesDefaultHome ? .suppressed : .allowed
+    }
+
     public static func shouldAttempt(_ browser: Browser, now: Date = Date()) -> Bool {
         guard browser.usesKeychainForCookieDecryption else { return true }
         guard !KeychainAccessGate.isDisabled else { return false }
-        return self.lock.withLock { state in
+        let shouldCheckKeychain = self.lock.withLock { state in
             self.loadIfNeeded(&state)
             if let blockedUntil = state.deniedUntilByBrowser[browser.rawValue] {
                 if blockedUntil > now {
@@ -30,7 +59,14 @@ public enum BrowserCookieAccessGate {
                 state.deniedUntilByBrowser.removeValue(forKey: browser.rawValue)
                 self.persist(state)
             }
-            if self.chromiumKeychainRequiresInteraction() {
+            return true
+        }
+        guard shouldCheckKeychain else { return false }
+
+        let requiresInteraction = self.chromiumKeychainRequiresInteraction()
+        return self.lock.withLock { state in
+            self.loadIfNeeded(&state)
+            if requiresInteraction {
                 state.deniedUntilByBrowser[browser.rawValue] = now.addingTimeInterval(self.cooldownInterval)
                 self.persist(state)
                 self.log.info(
@@ -90,6 +126,20 @@ public enum BrowserCookieAccessGate {
 
     private static let safeStorageLabels: [(service: String, account: String)] = Browser.safeStorageLabels
 
+    private static func isRunningUnderTests(
+        processName: String,
+        environment: [String: String]) -> Bool
+    {
+        processName == "swiftpm-testing-helper"
+            || processName.hasSuffix("PackageTests")
+            || environment["XCTestConfigurationFilePath"] != nil
+            || environment["SWIFT_TESTING"] != nil
+    }
+
+    private static func normalizedPath(_ url: URL) -> String {
+        url.standardizedFileURL.resolvingSymlinksInPath().path
+    }
+
     private static func loadIfNeeded(_ state: inout State) {
         guard !state.loaded else { return }
         state.loaded = true
@@ -104,6 +154,32 @@ public enum BrowserCookieAccessGate {
         UserDefaults.standard.set(raw, forKey: self.defaultsKey)
     }
 }
+
+extension BrowserCookieClient {
+    public func codexBarStores(for browser: Browser) throws -> [BrowserCookieStore] {
+        guard BrowserCookieAccessGate.cookieStoreAccessDecision(
+            homeDirectories: self.configuration.homeDirectories) == .allowed
+        else {
+            throw BrowserCookieStoreAccessSuppressedError()
+        }
+        guard BrowserCookieAccessGate.shouldAttempt(browser) else { return [] }
+        return self.stores(for: browser)
+    }
+
+    public func codexBarRecords(
+        matching query: BrowserCookieQuery,
+        in browser: Browser,
+        logger: ((String) -> Void)? = nil) throws -> [BrowserCookieStoreRecords]
+    {
+        guard BrowserCookieAccessGate.cookieStoreAccessDecision(
+            homeDirectories: self.configuration.homeDirectories) == .allowed
+        else {
+            throw BrowserCookieStoreAccessSuppressedError()
+        }
+        guard BrowserCookieAccessGate.shouldAttempt(browser) else { return [] }
+        return try self.records(matching: query, in: browser, logger: logger)
+    }
+}
 #else
 public enum BrowserCookieAccessGate {
     public static func shouldAttempt(_ browser: Browser, now: Date = Date()) -> Bool {
diff --git a/Sources/CodexBarCore/BrowserCookieImportOrder.swift b/Sources/CodexBarCore/BrowserCookieImportOrder.swift
index 32549a13bc..d1081f81f8 100644
--- a/Sources/CodexBarCore/BrowserCookieImportOrder.swift
+++ b/Sources/CodexBarCore/BrowserCookieImportOrder.swift
@@ -44,7 +44,9 @@ extension Browser {
              .edge, .edgeBeta, .edgeCanary,
              .helium,
              .vivaldi,
-             .dia:
+             .dia,
+             .yandex,
+             .comet:
             return true
         @unknown default:
             return true
diff --git a/Sources/CodexBarCore/BrowserDetection.swift b/Sources/CodexBarCore/BrowserDetection.swift
index 4cd2721ac9..1299c85f98 100644
--- a/Sources/CodexBarCore/BrowserDetection.swift
+++ b/Sources/CodexBarCore/BrowserDetection.swift
@@ -22,13 +22,13 @@ public final class BrowserDetection: Sendable {
         let timestamp: Date
     }
 
-    private enum ProbeKind: Int, Hashable, Sendable {
+    private enum ProbeKind: Int, Hashable {
         case appInstalled
         case usableProfileData
         case usableCookieStore
     }
 
-    private struct CacheKey: Hashable, Sendable {
+    private struct CacheKey: Hashable {
         let browser: Browser
         let kind: ProbeKind
     }
@@ -65,8 +65,12 @@ public final class BrowserDetection: Sendable {
     /// This is intentionally stricter than `isAppInstalled`: for Chromium browsers, we only return true
     /// when profile data exists (to avoid unnecessary Keychain prompts).
     public func isCookieSourceAvailable(_ browser: Browser) -> Bool {
-        // We always allow Safari cookie attempts: no Keychain prompts, and it can still yield cookies
-        // even if the on-disk location changes across macOS versions.
+        let homeURL = URL(fileURLWithPath: self.homeDirectory, isDirectory: true)
+        guard BrowserCookieAccessGate.cookieStoreAccessDecision(homeDirectories: [homeURL]) == .allowed else {
+            return false
+        }
+
+        // Safari does not need Keychain decryption and can still yield cookies if its storage path changes.
         if browser == .safari {
             return true
         }
diff --git a/Sources/CodexBarCore/CodexHomeScope.swift b/Sources/CodexBarCore/CodexHomeScope.swift
new file mode 100644
index 0000000000..2e48d92b4e
--- /dev/null
+++ b/Sources/CodexBarCore/CodexHomeScope.swift
@@ -0,0 +1,42 @@
+import Foundation
+
+public enum CodexHomeScope {
+    public static func normalizedHomePath(
+        _ rawPath: String?,
+        fileManager: FileManager = .default)
+        -> String?
+    {
+        guard var path = rawPath?.trimmingCharacters(in: .whitespacesAndNewlines), !path.isEmpty else {
+            return nil
+        }
+        if path == "~" {
+            path = fileManager.homeDirectoryForCurrentUser.path
+        } else if path.hasPrefix("~/") {
+            path = fileManager.homeDirectoryForCurrentUser
+                .appendingPathComponent(String(path.dropFirst(2)), isDirectory: true)
+                .path
+        } else if path.hasPrefix("~") {
+            return nil
+        }
+        guard (path as NSString).isAbsolutePath else { return nil }
+        return URL(fileURLWithPath: path, isDirectory: true).standardizedFileURL.path
+    }
+
+    public static func ambientHomeURL(
+        env: [String: String],
+        fileManager: FileManager = .default)
+        -> URL
+    {
+        if let raw = env["CODEX_HOME"]?.trimmingCharacters(in: .whitespacesAndNewlines), !raw.isEmpty {
+            return URL(fileURLWithPath: raw, isDirectory: true)
+        }
+        return fileManager.homeDirectoryForCurrentUser.appendingPathComponent(".codex", isDirectory: true)
+    }
+
+    public static func scopedEnvironment(base: [String: String], codexHome: String?) -> [String: String] {
+        guard let codexHome, !codexHome.isEmpty else { return base }
+        var env = base
+        env["CODEX_HOME"] = codexHome
+        return env
+    }
+}
diff --git a/Sources/CodexBarCore/CodexManagedAccounts.swift b/Sources/CodexBarCore/CodexManagedAccounts.swift
new file mode 100644
index 0000000000..f9190d22b6
--- /dev/null
+++ b/Sources/CodexBarCore/CodexManagedAccounts.swift
@@ -0,0 +1,169 @@
+import Crypto
+import Foundation
+
+public struct ManagedCodexAccount: Codable, Identifiable, Sendable {
+    public let id: UUID
+    public let email: String
+    public let providerAccountID: String?
+    public let workspaceLabel: String?
+    public let workspaceAccountID: String?
+    public let authFingerprint: String?
+    public let managedHomePath: String
+    public let createdAt: TimeInterval
+    public let updatedAt: TimeInterval
+    public let lastAuthenticatedAt: TimeInterval?
+
+    public init(
+        id: UUID,
+        email: String,
+        providerAccountID: String? = nil,
+        workspaceLabel: String? = nil,
+        workspaceAccountID: String? = nil,
+        authFingerprint: String? = nil,
+        managedHomePath: String,
+        createdAt: TimeInterval,
+        updatedAt: TimeInterval,
+        lastAuthenticatedAt: TimeInterval?)
+    {
+        self.id = id
+        self.email = Self.normalizeEmail(email)
+        self.providerAccountID = Self.normalizeProviderAccountID(providerAccountID)
+        self.workspaceLabel = Self.normalizeWorkspaceLabel(workspaceLabel)
+        self.workspaceAccountID = Self.normalizeWorkspaceAccountID(workspaceAccountID)
+        self.authFingerprint = CodexAuthFingerprint.normalize(authFingerprint)
+        self.managedHomePath = managedHomePath
+        self.createdAt = createdAt
+        self.updatedAt = updatedAt
+        self.lastAuthenticatedAt = lastAuthenticatedAt
+    }
+
+    static func normalizeEmail(_ email: String) -> String {
+        email.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+    }
+
+    public static func normalizeProviderAccountID(_ providerAccountID: String?) -> String? {
+        CodexIdentityResolver.normalizeAccountID(providerAccountID)
+    }
+
+    public static func normalizeWorkspaceLabel(_ workspaceLabel: String?) -> String? {
+        guard let trimmed = workspaceLabel?.trimmingCharacters(in: .whitespacesAndNewlines), !trimmed.isEmpty else {
+            return nil
+        }
+        return trimmed
+    }
+
+    public static func normalizeWorkspaceAccountID(_ workspaceAccountID: String?) -> String? {
+        guard let trimmed = workspaceAccountID?.trimmingCharacters(in: .whitespacesAndNewlines), !trimmed.isEmpty else {
+            return nil
+        }
+        return trimmed.lowercased()
+    }
+
+    public init(from decoder: any Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        try self.init(
+            id: container.decode(UUID.self, forKey: .id),
+            email: container.decode(String.self, forKey: .email),
+            providerAccountID: container.decodeIfPresent(String.self, forKey: .providerAccountID),
+            workspaceLabel: container.decodeIfPresent(String.self, forKey: .workspaceLabel),
+            workspaceAccountID: container.decodeIfPresent(String.self, forKey: .workspaceAccountID),
+            authFingerprint: container.decodeIfPresent(String.self, forKey: .authFingerprint),
+            managedHomePath: container.decode(String.self, forKey: .managedHomePath),
+            createdAt: container.decode(TimeInterval.self, forKey: .createdAt),
+            updatedAt: container.decode(TimeInterval.self, forKey: .updatedAt),
+            lastAuthenticatedAt: container.decodeIfPresent(TimeInterval.self, forKey: .lastAuthenticatedAt))
+    }
+}
+
+public enum CodexAuthFingerprint {
+    public static func authFileURL(homePath: String) -> URL {
+        URL(fileURLWithPath: homePath, isDirectory: true)
+            .appendingPathComponent("auth.json", isDirectory: false)
+    }
+
+    public static func fingerprint(homePath: String, fileManager: FileManager = .default) -> String? {
+        let url = self.authFileURL(homePath: homePath)
+        guard fileManager.fileExists(atPath: url.path),
+              let data = try? Data(contentsOf: url)
+        else {
+            return nil
+        }
+        return self.fingerprint(data: data)
+    }
+
+    public static func fingerprint(env: [String: String], fileManager: FileManager = .default) -> String? {
+        self.fingerprint(
+            homePath: CodexHomeScope.ambientHomeURL(env: env, fileManager: fileManager).path,
+            fileManager: fileManager)
+    }
+
+    public static func fingerprint(data: Data) -> String {
+        SHA256.hash(data: data).map { String(format: "%02x", $0) }.joined()
+    }
+
+    public static func normalize(_ fingerprint: String?) -> String? {
+        guard let trimmed = fingerprint?.trimmingCharacters(in: .whitespacesAndNewlines).lowercased(),
+              !trimmed.isEmpty
+        else {
+            return nil
+        }
+        return trimmed
+    }
+}
+
+public struct ManagedCodexAccountSet: Codable, Sendable {
+    public let version: Int
+    public let accounts: [ManagedCodexAccount]
+
+    public init(version: Int, accounts: [ManagedCodexAccount]) {
+        self.version = version
+        self.accounts = Self.sanitizedAccounts(accounts)
+    }
+
+    public func account(id: UUID) -> ManagedCodexAccount? {
+        self.accounts.first { $0.id == id }
+    }
+
+    public func account(email: String, providerAccountID: String? = nil) -> ManagedCodexAccount? {
+        let normalizedEmail = ManagedCodexAccount.normalizeEmail(email)
+        if let normalizedProviderAccountID = ManagedCodexAccount.normalizeProviderAccountID(providerAccountID),
+           let exactMatch = self.accounts.first(where: {
+               $0.email == normalizedEmail && $0.providerAccountID == normalizedProviderAccountID
+           })
+        {
+            return exactMatch
+        }
+        if providerAccountID != nil {
+            return self.accounts.first { $0.email == normalizedEmail && $0.providerAccountID == nil }
+        }
+        return self.accounts.first { $0.email == normalizedEmail }
+    }
+
+    public init(from decoder: any Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.version = try container.decode(Int.self, forKey: .version)
+        self.accounts = try container.decode([ManagedCodexAccount].self, forKey: .accounts)
+    }
+
+    private static func sanitizedAccounts(_ accounts: [ManagedCodexAccount]) -> [ManagedCodexAccount] {
+        var seenIDs: Set<UUID> = []
+        var seenProviderAccountKeys: Set<String> = []
+        var seenLegacyEmails: Set<String> = []
+        var sanitized: [ManagedCodexAccount] = []
+        sanitized.reserveCapacity(accounts.count)
+
+        for account in accounts {
+            guard seenIDs.insert(account.id).inserted else { continue }
+            if let providerAccountID = account.providerAccountID {
+                guard seenProviderAccountKeys.insert("\(account.email)\u{0}\(providerAccountID)").inserted else {
+                    continue
+                }
+            } else {
+                guard seenLegacyEmails.insert(account.email).inserted else { continue }
+            }
+            sanitized.append(account)
+        }
+
+        return sanitized
+    }
+}
diff --git a/Sources/CodexBarCore/Config/CodexActiveSource.swift b/Sources/CodexBarCore/Config/CodexActiveSource.swift
new file mode 100644
index 0000000000..eb361d0c04
--- /dev/null
+++ b/Sources/CodexBarCore/Config/CodexActiveSource.swift
@@ -0,0 +1,59 @@
+import Foundation
+
+public enum CodexActiveSource: Codable, Equatable, Sendable {
+    case liveSystem
+    case managedAccount(id: UUID)
+    case profileHome(path: String)
+
+    private enum CodingKeys: String, CodingKey {
+        case kind
+        case accountID
+        case homePath
+    }
+
+    private enum Kind: String, Codable {
+        case liveSystem
+        case managedAccount
+        case profileHome
+    }
+
+    public init(from decoder: any Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        switch try container.decode(Kind.self, forKey: .kind) {
+        case .liveSystem:
+            if let path = try container.decodeIfPresent(String.self, forKey: .homePath),
+               !path.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+            {
+                self = .profileHome(path: path)
+            } else {
+                self = .liveSystem
+            }
+        case .managedAccount:
+            let id = try container.decode(UUID.self, forKey: .accountID)
+            self = .managedAccount(id: id)
+        case .profileHome:
+            let path = try container.decode(String.self, forKey: .homePath)
+            if path.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
+                self = .liveSystem
+            } else {
+                self = .profileHome(path: path)
+            }
+        }
+    }
+
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        switch self {
+        case .liveSystem:
+            try container.encode(Kind.liveSystem, forKey: .kind)
+        case let .managedAccount(id):
+            try container.encode(Kind.managedAccount, forKey: .kind)
+            try container.encode(id, forKey: .accountID)
+        case let .profileHome(path):
+            // Released builds only understand liveSystem/managedAccount. Keep the envelope
+            // downgrade-readable while newer builds recover the profile selection from homePath.
+            try container.encode(Kind.liveSystem, forKey: .kind)
+            try container.encode(path, forKey: .homePath)
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Config/CodexBarConfig.swift b/Sources/CodexBarCore/Config/CodexBarConfig.swift
index 04c85409d3..999be2cc01 100644
--- a/Sources/CodexBarCore/Config/CodexBarConfig.swift
+++ b/Sources/CodexBarCore/Config/CodexBarConfig.swift
@@ -22,6 +22,27 @@ public struct CodexBarConfig: Codable, Sendable {
         return CodexBarConfig(version: Self.currentVersion, providers: providers)
     }
 
+    /// Alphabetical provider ordering with enabled providers on top: enabled first, then disabled,
+    /// each group sorted case-insensitively by display name. Used by the Providers settings pane's
+    /// alphabetical sort toggle; it never mutates the user's stored manual order.
+    public static func alphabeticalProviderOrder(
+        metadata: [UsageProvider: ProviderMetadata] = ProviderDescriptorRegistry.metadata,
+        enablement: (UsageProvider) -> Bool) -> [UsageProvider]
+    {
+        UsageProvider.allCases.sorted { lhs, rhs in
+            let lhsEnabled = enablement(lhs)
+            let rhsEnabled = enablement(rhs)
+            if lhsEnabled != rhsEnabled { return lhsEnabled }
+            let lhsName = metadata[lhs]?.displayName ?? lhs.rawValue
+            let rhsName = metadata[rhs]?.displayName ?? rhs.rawValue
+            switch lhsName.localizedCaseInsensitiveCompare(rhsName) {
+            case .orderedAscending: return true
+            case .orderedDescending: return false
+            case .orderedSame: return lhs.rawValue < rhs.rawValue
+            }
+        }
+    }
+
     public func normalized(
         metadata: [UsageProvider: ProviderMetadata] = ProviderDescriptorRegistry.metadata) -> CodexBarConfig
     {
@@ -78,11 +99,20 @@ public struct ProviderConfig: Codable, Sendable, Identifiable {
     public var source: ProviderSourceMode?
     public var extrasEnabled: Bool?
     public var apiKey: String?
+    public var secretKey: String?
     public var cookieHeader: String?
     public var cookieSource: ProviderCookieSource?
     public var region: String?
     public var workspaceID: String?
+    public var enterpriseHost: String?
     public var tokenAccounts: ProviderTokenAccountData?
+    public var codexActiveSource: CodexActiveSource?
+    public var codexProfileHomePaths: [String]?
+    public var quotaWarnings: QuotaWarningConfig?
+    public var kiloKnownOrganizations: [KiloOrganization]?
+    public var kiloEnabledOrganizationIDs: [String]?
+    public var awsProfile: String?
+    public var awsAuthMode: String?
 
     public init(
         id: UsageProvider,
@@ -90,32 +120,74 @@ public struct ProviderConfig: Codable, Sendable, Identifiable {
         source: ProviderSourceMode? = nil,
         extrasEnabled: Bool? = nil,
         apiKey: String? = nil,
+        secretKey: String? = nil,
         cookieHeader: String? = nil,
         cookieSource: ProviderCookieSource? = nil,
         region: String? = nil,
         workspaceID: String? = nil,
-        tokenAccounts: ProviderTokenAccountData? = nil)
+        enterpriseHost: String? = nil,
+        tokenAccounts: ProviderTokenAccountData? = nil,
+        codexActiveSource: CodexActiveSource? = nil,
+        codexProfileHomePaths: [String]? = nil,
+        quotaWarnings: QuotaWarningConfig? = nil,
+        kiloKnownOrganizations: [KiloOrganization]? = nil,
+        kiloEnabledOrganizationIDs: [String]? = nil,
+        awsProfile: String? = nil,
+        awsAuthMode: String? = nil)
     {
         self.id = id
         self.enabled = enabled
         self.source = source
         self.extrasEnabled = extrasEnabled
         self.apiKey = apiKey
+        self.secretKey = secretKey
         self.cookieHeader = cookieHeader
         self.cookieSource = cookieSource
         self.region = region
         self.workspaceID = workspaceID
+        self.enterpriseHost = enterpriseHost
         self.tokenAccounts = tokenAccounts
+        self.codexActiveSource = codexActiveSource
+        self.codexProfileHomePaths = codexProfileHomePaths
+        self.quotaWarnings = quotaWarnings
+        self.kiloKnownOrganizations = kiloKnownOrganizations
+        self.kiloEnabledOrganizationIDs = kiloEnabledOrganizationIDs
+        self.awsProfile = awsProfile
+        self.awsAuthMode = awsAuthMode
     }
 
     public var sanitizedAPIKey: String? {
         Self.clean(self.apiKey)
     }
 
+    public var sanitizedSecretKey: String? {
+        Self.clean(self.secretKey)
+    }
+
     public var sanitizedCookieHeader: String? {
         Self.clean(self.cookieHeader)
     }
 
+    public var sanitizedRegion: String? {
+        Self.clean(self.region)
+    }
+
+    public var sanitizedWorkspaceID: String? {
+        Self.clean(self.workspaceID)
+    }
+
+    public var sanitizedEnterpriseHost: String? {
+        Self.clean(self.enterpriseHost)
+    }
+
+    public var sanitizedAWSProfile: String? {
+        Self.clean(self.awsProfile)
+    }
+
+    public var sanitizedAWSAuthMode: String? {
+        Self.clean(self.awsAuthMode)
+    }
+
     private static func clean(_ raw: String?) -> String? {
         guard var value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
             return nil
@@ -123,10 +195,115 @@ public struct ProviderConfig: Codable, Sendable, Identifiable {
         if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
             (value.hasPrefix("'") && value.hasSuffix("'"))
         {
-            value.removeFirst()
-            value.removeLast()
+            value = String(value.dropFirst().dropLast())
         }
         value = value.trimmingCharacters(in: .whitespacesAndNewlines)
         return value.isEmpty ? nil : value
     }
 }
+
+public enum QuotaWarningWindow: String, Codable, Sendable, CaseIterable {
+    case session
+    case weekly
+
+    public var displayName: String {
+        switch self {
+        case .session:
+            "session"
+        case .weekly:
+            "weekly"
+        }
+    }
+}
+
+public struct QuotaWarningWindowConfig: Codable, Sendable, Equatable {
+    public var thresholds: [Int]?
+    public var enabled: Bool?
+
+    public init(thresholds: [Int]? = nil, enabled: Bool? = nil) {
+        self.thresholds = thresholds.map(QuotaWarningThresholds.sanitized)
+        self.enabled = enabled
+    }
+
+    public var hasOverride: Bool {
+        self.thresholds != nil || self.enabled != nil
+    }
+
+    public func isEnabled(global: Bool) -> Bool {
+        self.enabled ?? (self.thresholds != nil ? true : global)
+    }
+}
+
+public struct QuotaWarningConfig: Codable, Sendable, Equatable {
+    public var session: QuotaWarningWindowConfig?
+    public var weekly: QuotaWarningWindowConfig?
+
+    public init(
+        session: QuotaWarningWindowConfig? = nil,
+        weekly: QuotaWarningWindowConfig? = nil)
+    {
+        self.session = session
+        self.weekly = weekly
+    }
+
+    public func thresholds(for window: QuotaWarningWindow, global: [Int]) -> [Int] {
+        switch window {
+        case .session:
+            QuotaWarningThresholds.sanitized(self.session?.thresholds ?? global)
+        case .weekly:
+            QuotaWarningThresholds.sanitized(self.weekly?.thresholds ?? global)
+        }
+    }
+
+    public func isEnabled(for window: QuotaWarningWindow, global: Bool) -> Bool {
+        switch window {
+        case .session:
+            self.session?.isEnabled(global: global) ?? global
+        case .weekly:
+            self.weekly?.isEnabled(global: global) ?? global
+        }
+    }
+
+    public func hasOverride(for window: QuotaWarningWindow) -> Bool {
+        switch window {
+        case .session:
+            self.session?.hasOverride ?? false
+        case .weekly:
+            self.weekly?.hasOverride ?? false
+        }
+    }
+
+    public var isEmpty: Bool {
+        self.session?.hasOverride != true && self.weekly?.hasOverride != true
+    }
+}
+
+public enum QuotaWarningThresholds {
+    public static let defaults = [50, 20]
+    public static let allowedRange = 0...99
+
+    public static func sanitized(_ raw: [Int]) -> [Int] {
+        guard !raw.isEmpty else { return self.defaults }
+
+        let unique = Set(raw.map(self.clamped))
+        let sorted = unique.sorted(by: >)
+        return sorted.isEmpty ? self.defaults : sorted
+    }
+
+    public static func active(_ raw: [Int]) -> [Int] {
+        self.sanitized(raw).filter { $0 > 0 }
+    }
+
+    public static func resolved(upper: Int?, lower: Int?) -> [Int] {
+        guard upper != nil || lower != nil else { return self.defaults }
+
+        let resolvedUpper = self.clamped(upper ?? self.defaults[0])
+        let lowerDefault = resolvedUpper < self.defaults[1] ? 0 : self.defaults[1]
+        let resolvedLower = self.clamped(lower ?? lowerDefault)
+        return self.sanitized([resolvedUpper, resolvedLower])
+    }
+
+    public static func clamped(_ value: Int) -> Int {
+        min(max(value, self.allowedRange.lowerBound), self.allowedRange.upperBound)
+    }
+}
diff --git a/Sources/CodexBarCore/Config/CodexBarConfigStore.swift b/Sources/CodexBarCore/Config/CodexBarConfigStore.swift
index e22c974a6c..401f3c8041 100644
--- a/Sources/CodexBarCore/Config/CodexBarConfigStore.swift
+++ b/Sources/CodexBarCore/Config/CodexBarConfigStore.swift
@@ -18,6 +18,9 @@ public enum CodexBarConfigStoreError: LocalizedError {
 }
 
 public struct CodexBarConfigStore: @unchecked Sendable {
+    public static let pathEnvironmentKey = "CODEXBAR_CONFIG"
+    public static let xdgConfigHomeEnvironmentKey = "XDG_CONFIG_HOME"
+
     public let fileURL: URL
     private let fileManager: FileManager
 
@@ -70,10 +73,46 @@ public struct CodexBarConfigStore: @unchecked Sendable {
         try self.fileManager.removeItem(at: self.fileURL)
     }
 
-    public static func defaultURL(home: URL = FileManager.default.homeDirectoryForCurrentUser) -> URL {
-        home
+    public static func defaultURL(
+        home: URL = FileManager.default.homeDirectoryForCurrentUser,
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        fileManager: FileManager = .default) -> URL
+    {
+        if let override = environment[pathEnvironmentKey]?.trimmingCharacters(in: .whitespacesAndNewlines),
+           !override.isEmpty
+        {
+            let expanded = (override as NSString).expandingTildeInPath
+            return URL(fileURLWithPath: expanded)
+        }
+
+        if let xdgConfigHome = environment[xdgConfigHomeEnvironmentKey]?
+            .trimmingCharacters(in: .whitespacesAndNewlines),
+            !xdgConfigHome.isEmpty
+        {
+            let expanded = (xdgConfigHome as NSString).expandingTildeInPath
+            if (expanded as NSString).isAbsolutePath {
+                return URL(fileURLWithPath: expanded, isDirectory: true)
+                    .appendingPathComponent("codexbar", isDirectory: true)
+                    .appendingPathComponent("config.json")
+            }
+        }
+
+        let xdgDefault = home
+            .appendingPathComponent(".config", isDirectory: true)
+            .appendingPathComponent("codexbar", isDirectory: true)
+            .appendingPathComponent("config.json")
+        if fileManager.fileExists(atPath: xdgDefault.path) {
+            return xdgDefault
+        }
+
+        let legacy = home
             .appendingPathComponent(".codexbar", isDirectory: true)
             .appendingPathComponent("config.json")
+        if fileManager.fileExists(atPath: legacy.path) {
+            return legacy
+        }
+
+        return xdgDefault
     }
 
     private func applySecurePermissionsIfNeeded() throws {
diff --git a/Sources/CodexBarCore/Config/CodexBarConfigValidation.swift b/Sources/CodexBarCore/Config/CodexBarConfigValidation.swift
index d435a28f63..7d45cffc6c 100644
--- a/Sources/CodexBarCore/Config/CodexBarConfigValidation.swift
+++ b/Sources/CodexBarCore/Config/CodexBarConfigValidation.swift
@@ -28,6 +28,15 @@ public struct CodexBarConfigIssue: Codable, Sendable, Equatable {
 }
 
 public enum CodexBarConfigValidator {
+    private static let workspaceIDProviders: [UsageProvider] = [
+        .azureopenai,
+        .openai,
+        .opencode,
+        .opencodego,
+        .devin,
+        .deepgram,
+    ]
+
     public static func validate(_ config: CodexBarConfig) -> [CodexBarConfigIssue] {
         var issues: [CodexBarConfigIssue] = []
 
@@ -125,46 +134,33 @@ public enum CodexBarConfigValidator {
                 message: "cookieSource manual is set but cookieHeader is missing for \(provider.rawValue)."))
         }
 
-        if let region = entry.region, !region.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
-            switch provider {
-            case .minimax:
-                if MiniMaxAPIRegion(rawValue: region) == nil {
-                    issues.append(CodexBarConfigIssue(
-                        severity: .error,
-                        provider: provider,
-                        field: "region",
-                        code: "invalid_region",
-                        message: "Region \(region) is not a valid MiniMax region."))
-                }
-            case .zai:
-                if ZaiAPIRegion(rawValue: region) == nil {
-                    issues.append(CodexBarConfigIssue(
-                        severity: .error,
-                        provider: provider,
-                        field: "region",
-                        code: "invalid_region",
-                        message: "Region \(region) is not a valid z.ai region."))
-                }
-            default:
-                issues.append(CodexBarConfigIssue(
-                    severity: .warning,
-                    provider: provider,
-                    field: "region",
-                    code: "region_unused",
-                    message: "region is set but \(provider.rawValue) does not use regions."))
-            }
-        }
+        self.validateSecretKey(entry, issues: &issues)
+
+        self.validateRegion(entry, issues: &issues)
 
         if let workspaceID = entry.workspaceID,
            !workspaceID.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty,
-           provider != .opencode
+           !self.providerSupportsWorkspaceID(provider)
         {
             issues.append(CodexBarConfigIssue(
                 severity: .warning,
                 provider: provider,
                 field: "workspaceID",
                 code: "workspace_unused",
-                message: "workspaceID is set but only opencode supports workspaceID."))
+                message: "workspaceID is set but only \(self.workspaceIDProviderList) support workspaceID."))
+        }
+
+        if let enterpriseHost = entry.enterpriseHost,
+           !enterpriseHost.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty,
+           !self.providerSupportsEnterpriseHost(provider)
+        {
+            issues.append(CodexBarConfigIssue(
+                severity: .warning,
+                provider: provider,
+                field: "enterpriseHost",
+                code: "enterprise_host_unused",
+                message: "enterpriseHost is set but only azureopenai, copilot, kimi, " +
+                    "llmproxy, and litellm support enterpriseHost."))
         }
 
         if let tokenAccounts = entry.tokenAccounts, !tokenAccounts.accounts.isEmpty,
@@ -178,4 +174,109 @@ public enum CodexBarConfigValidator {
                 message: "tokenAccounts are set but \(provider.rawValue) does not support token accounts."))
         }
     }
+
+    private static func validateSecretKey(_ entry: ProviderConfig, issues: inout [CodexBarConfigIssue]) {
+        guard let secretKey = entry.secretKey,
+              !secretKey.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty,
+              entry.id != .bedrock
+        else {
+            return
+        }
+
+        issues.append(CodexBarConfigIssue(
+            severity: .warning,
+            provider: entry.id,
+            field: "secretKey",
+            code: "secret_key_unused",
+            message: "secretKey is set but only bedrock uses secretKey."))
+    }
+
+    private static func providerSupportsWorkspaceID(_ provider: UsageProvider) -> Bool {
+        self.workspaceIDProviders.contains(provider)
+    }
+
+    private static var workspaceIDProviderList: String {
+        self.formattedProviderList(self.workspaceIDProviders)
+    }
+
+    private static func formattedProviderList(_ providers: [UsageProvider]) -> String {
+        let names = providers.map(\.rawValue)
+        guard let last = names.last else { return "" }
+        guard names.count > 1 else { return last }
+        return "\(names.dropLast().joined(separator: ", ")), and \(last)"
+    }
+
+    private static func providerSupportsEnterpriseHost(_ provider: UsageProvider) -> Bool {
+        switch provider {
+        case .azureopenai, .copilot, .kimi, .llmproxy, .litellm:
+            true
+        default:
+            false
+        }
+    }
+
+    private static func validateRegion(_ entry: ProviderConfig, issues: inout [CodexBarConfigIssue]) {
+        let provider = entry.id
+        guard let region = entry.region?.trimmingCharacters(in: .whitespacesAndNewlines),
+              !region.isEmpty
+        else {
+            return
+        }
+
+        switch provider {
+        case .minimax:
+            self.validateKnownRegion(
+                region,
+                provider: provider,
+                isValid: MiniMaxAPIRegion(rawValue: region) != nil,
+                displayName: "MiniMax",
+                issues: &issues)
+        case .zai:
+            self.validateKnownRegion(
+                region,
+                provider: provider,
+                isValid: ZaiAPIRegion(rawValue: region) != nil,
+                displayName: "z.ai",
+                issues: &issues)
+        case .alibaba:
+            self.validateKnownRegion(
+                region,
+                provider: provider,
+                isValid: AlibabaCodingPlanAPIRegion(rawValue: region) != nil,
+                displayName: "Alibaba Coding Plan",
+                issues: &issues)
+        case .moonshot:
+            self.validateKnownRegion(
+                region,
+                provider: provider,
+                isValid: MoonshotRegion(rawValue: region) != nil,
+                displayName: "Moonshot",
+                issues: &issues)
+        case .bedrock:
+            break
+        default:
+            issues.append(CodexBarConfigIssue(
+                severity: .warning,
+                provider: provider,
+                field: "region",
+                code: "region_unused",
+                message: "region is set but \(provider.rawValue) does not use regions."))
+        }
+    }
+
+    private static func validateKnownRegion(
+        _ region: String,
+        provider: UsageProvider,
+        isValid: Bool,
+        displayName: String,
+        issues: inout [CodexBarConfigIssue])
+    {
+        guard !isValid else { return }
+        issues.append(CodexBarConfigIssue(
+            severity: .error,
+            provider: provider,
+            field: "region",
+            code: "invalid_region",
+            message: "Region \(region) is not a valid \(displayName) region."))
+    }
 }
diff --git a/Sources/CodexBarCore/Config/ProviderConfigEnvironment.swift b/Sources/CodexBarCore/Config/ProviderConfigEnvironment.swift
index 9fabc4b806..e157db62b0 100644
--- a/Sources/CodexBarCore/Config/ProviderConfigEnvironment.swift
+++ b/Sources/CodexBarCore/Config/ProviderConfigEnvironment.swift
@@ -6,32 +6,308 @@ public enum ProviderConfigEnvironment {
         provider: UsageProvider,
         config: ProviderConfig?) -> [String: String]
     {
+        if let env = self.applyDedicatedProviderOverrides(base: base, provider: provider, config: config) {
+            return env
+        }
         guard let apiKey = config?.sanitizedAPIKey, !apiKey.isEmpty else { return base }
         var env = base
+        if let key = self.directAPIKeyEnvironmentKey(for: provider) {
+            env[key] = apiKey
+            return env
+        }
+
         switch provider {
-        case .zai:
-            env[ZaiSettingsReader.apiTokenKey] = apiKey
         case .copilot:
             env["COPILOT_API_TOKEN"] = apiKey
-        case .minimax:
-            env[MiniMaxAPISettingsReader.apiTokenKey] = apiKey
-        case .kilo:
-            env[KiloSettingsReader.apiTokenKey] = apiKey
         case .kimik2:
             if let key = KimiK2SettingsReader.apiKeyEnvironmentKeys.first {
                 env[key] = apiKey
             }
-        case .synthetic:
-            env[SyntheticSettingsReader.apiKeyKey] = apiKey
         case .warp:
             if let key = WarpSettingsReader.apiKeyEnvironmentKeys.first {
                 env[key] = apiKey
             }
-        case .openrouter:
-            env[OpenRouterSettingsReader.envKey] = apiKey
+        case .codebuff:
+            // Preserve a token already present in the process environment so that
+            // runtime/CI overrides win over a key saved in Settings (matches the
+            // precedence used by `ProviderTokenResolver.codebuffResolution`).
+            if CodebuffSettingsReader.apiKey(environment: base) == nil {
+                env[CodebuffSettingsReader.apiTokenKey] = apiKey
+            }
+        case .crof:
+            if CrofSettingsReader.apiKey(environment: base) == nil,
+               let key = CrofSettingsReader.apiKeyEnvironmentKeys.first
+            {
+                env[key] = apiKey
+            }
+        case .doubao:
+            if let key = DoubaoSettingsReader.apiKeyEnvironmentKeys.first {
+                env[key] = apiKey
+            }
         default:
             break
         }
         return env
     }
+
+    public static func supportsAPIKeyOverride(for provider: UsageProvider) -> Bool {
+        if self.directAPIKeyEnvironmentKey(for: provider) != nil { return true }
+        switch provider {
+        case .copilot, .kimik2, .warp, .codebuff, .crof, .doubao:
+            return true
+        case .azureopenai:
+            return true
+        default:
+            return false
+        }
+    }
+
+    private static func baseURLEnvironmentKey(for provider: UsageProvider) -> String? {
+        switch provider {
+        case .llmproxy:
+            LLMProxySettingsReader.baseURLEnvironmentKey
+        case .litellm:
+            LiteLLMSettingsReader.baseURLEnvironmentKey
+        default:
+            nil
+        }
+    }
+
+    private static func supportsAPIKeyAndBaseURLOverride(_ provider: UsageProvider) -> Bool {
+        self.baseURLEnvironmentKey(for: provider) != nil
+    }
+
+    private static func applyDedicatedProviderOverrides(
+        base: [String: String],
+        provider: UsageProvider,
+        config: ProviderConfig?) -> [String: String]?
+    {
+        switch provider {
+        case .openai:
+            self.applyOpenAIOverrides(base: base, config: config)
+        case .bedrock:
+            self.applyBedrockOverrides(base: base, config: config)
+        case .deepgram:
+            self.applyDeepgramOverrides(base: base, config: config)
+        case .llmproxy, .litellm:
+            self.applyAPIKeyAndBaseURLOverrides(base: base, provider: provider, config: config)
+        case .azureopenai:
+            self.applyAzureOpenAIOverrides(base: base, config: config)
+        case .kimi:
+            self.applyKimiOverrides(base: base, config: config)
+        default:
+            nil
+        }
+    }
+
+    private static func directAPIKeyEnvironmentKey(for provider: UsageProvider) -> String? {
+        switch provider {
+        case .amp:
+            AmpSettingsReader.apiTokenKey
+        case .openai:
+            OpenAIAPISettingsReader.adminAPIKeyEnvironmentKey
+        case .azureopenai:
+            AzureOpenAISettingsReader.apiKeyEnvironmentKey
+        case .claude:
+            ClaudeAdminAPISettingsReader.adminAPIKeyEnvironmentKey
+        case .zai:
+            ZaiSettingsReader.apiTokenKey
+        case .minimax:
+            MiniMaxAPISettingsReader.apiTokenKey
+        case .alibaba:
+            AlibabaCodingPlanSettingsReader.apiTokenKey
+        case .kilo:
+            KiloSettingsReader.apiTokenKey
+        case .synthetic:
+            SyntheticSettingsReader.apiKeyKey
+        case .openrouter:
+            OpenRouterSettingsReader.envKey
+        case .elevenlabs:
+            ElevenLabsSettingsReader.apiKeyEnvironmentKey
+        case .moonshot:
+            MoonshotSettingsReader.apiKeyEnvironmentKeys.first
+        case .kimi:
+            KimiSettingsReader.apiKeyEnvironmentKeys.first
+        case .ollama:
+            OllamaAPISettingsReader.apiKeyEnvironmentKeys.first
+        case .venice:
+            VeniceSettingsReader.apiKeyEnvironmentKey
+        case .deepgram:
+            DeepgramSettingsReader.apiKeyEnvironmentKey
+        case .groq:
+            GroqSettingsReader.apiKeyEnvironmentKey
+        case .llmproxy:
+            LLMProxySettingsReader.apiKeyEnvironmentKey
+        case .chutes, .poe, .litellm:
+            self.additionalAPIKeyEnvironmentKey(for: provider)
+        default:
+            nil
+        }
+    }
+
+    private static func additionalAPIKeyEnvironmentKey(for provider: UsageProvider) -> String? {
+        switch provider {
+        case .chutes:
+            ChutesSettingsReader.apiKeyEnvironmentKey
+        case .poe:
+            PoeSettingsReader.apiKeyEnvironmentKey
+        case .litellm:
+            LiteLLMSettingsReader.apiKeyEnvironmentKey
+        default:
+            nil
+        }
+    }
+
+    private static func applyOpenAIOverrides(
+        base: [String: String],
+        config: ProviderConfig?) -> [String: String]
+    {
+        guard let config else { return base }
+        var env = base
+        if let apiKey = config.sanitizedAPIKey {
+            env[OpenAIAPISettingsReader.adminAPIKeyEnvironmentKey] = apiKey
+        }
+        if let projectID = config.sanitizedWorkspaceID {
+            env[OpenAIAPISettingsReader.projectIDEnvironmentKey] = projectID
+        }
+        return env
+    }
+
+    private static func applyBedrockOverrides(
+        base: [String: String],
+        config: ProviderConfig?) -> [String: String]
+    {
+        guard let config else { return base }
+        var env = base
+
+        // Only project an explicit auth-mode selection. When the config does not
+        // specify one, leave the base environment untouched so an env-driven setup
+        // (AWS_PROFILE or CODEXBAR_BEDROCK_AUTH_MODE from the launch environment) is
+        // still inferred by BedrockSettingsReader instead of being forced to `keys`.
+        let configMode = config.sanitizedAWSAuthMode.flatMap(BedrockAuthMode.init(rawValue:))
+        if let configMode {
+            env[BedrockSettingsReader.authModeKey] = configMode.rawValue
+        }
+        let baseMode = BedrockSettingsReader
+            .cleaned(base[BedrockSettingsReader.authModeKey])
+            .flatMap { BedrockAuthMode(rawValue: $0.lowercased()) }
+
+        let mergedAccessKey = config.sanitizedAPIKey ?? BedrockSettingsReader.accessKeyID(environment: base)
+        let mergedSecretKey = config.sanitizedSecretKey ?? BedrockSettingsReader.secretAccessKey(environment: base)
+        let hasMergedStaticKeys = mergedAccessKey != nil && mergedSecretKey != nil
+        let effectiveMode: BedrockAuthMode = if let configMode {
+            configMode
+        } else if let baseMode {
+            baseMode
+        } else if hasMergedStaticKeys {
+            // Upgrade path: a config saved before auth modes existed keeps using
+            // static credentials (including env+config layering) even if AWS_PROFILE
+            // is present in the base environment, so existing users are never
+            // silently switched to a profile/account.
+            .keys
+        } else {
+            BedrockSettingsReader.authMode(environment: base)
+        }
+
+        switch effectiveMode {
+        case .profile:
+            if let profile = config.sanitizedAWSProfile {
+                env[BedrockSettingsReader.profileKey] = profile
+            }
+        case .keys:
+            if let accessKeyID = config.sanitizedAPIKey {
+                env[BedrockSettingsReader.accessKeyIDKey] = accessKeyID
+            }
+            if let secretAccessKey = config.sanitizedSecretKey {
+                env[BedrockSettingsReader.secretAccessKeyKey] = secretAccessKey
+            }
+        }
+
+        if let region = config.sanitizedRegion {
+            env[BedrockSettingsReader.regionKeys[0]] = region
+        }
+
+        return env
+    }
+
+    private static func applyDeepgramOverrides(
+        base: [String: String],
+        config: ProviderConfig?) -> [String: String]
+    {
+        guard let config else { return base }
+
+        var env = base
+
+        if let apiKey = config.sanitizedAPIKey {
+            env[DeepgramSettingsReader.apiKeyEnvironmentKey] = apiKey
+        }
+
+        if let projectID = config.sanitizedWorkspaceID {
+            env[DeepgramSettingsReader.projectIDEnvironmentKey] = projectID
+        }
+
+        return env
+    }
+
+    private static func applyAPIKeyAndBaseURLOverrides(
+        base: [String: String],
+        provider: UsageProvider,
+        config: ProviderConfig?) -> [String: String]
+    {
+        var env = base
+        if let apiKey = config?.sanitizedAPIKey,
+           let key = self.directAPIKeyEnvironmentKey(for: provider)
+        {
+            env[key] = apiKey
+        }
+        if let baseURL = config?.sanitizedEnterpriseHost,
+           let key = self.baseURLEnvironmentKey(for: provider)
+        {
+            env[key] = baseURL
+        }
+        return env
+    }
+
+    private static func applyKimiOverrides(
+        base: [String: String],
+        config: ProviderConfig?) -> [String: String]
+    {
+        guard let config else { return base }
+        var env = base
+        if let apiKey = config.sanitizedAPIKey,
+           let key = KimiSettingsReader.apiKeyEnvironmentKeys.first
+        {
+            env[key] = apiKey
+        }
+        if let baseURL = config.sanitizedEnterpriseHost {
+            env[KimiSettingsReader.codeAPIBaseURLEnvironmentKey] = baseURL
+        }
+        return env
+    }
+
+    private static func applyAzureOpenAIOverrides(
+        base: [String: String],
+        config: ProviderConfig?) -> [String: String]
+    {
+        guard let config else { return base }
+        var env = base
+        if let apiKey = config.sanitizedAPIKey {
+            env[AzureOpenAISettingsReader.apiKeyEnvironmentKey] = apiKey
+        }
+        if let endpoint = config.sanitizedEnterpriseHost {
+            env[AzureOpenAISettingsReader.endpointEnvironmentKey] = endpoint
+        }
+        if let deploymentName = config.sanitizedWorkspaceID {
+            env[AzureOpenAISettingsReader.deploymentNameEnvironmentKey] = deploymentName
+        }
+        return env
+    }
+
+    public static func applyProviderConfigOverrides(
+        base: [String: String],
+        provider: UsageProvider,
+        config: ProviderConfig?) -> [String: String]
+    {
+        self.applyAPIKeyOverride(base: base, provider: provider, config: config)
+    }
 }
diff --git a/Sources/CodexBarCore/CookieHeaderCache.swift b/Sources/CodexBarCore/CookieHeaderCache.swift
index c006100701..f1b84d5a93 100644
--- a/Sources/CodexBarCore/CookieHeaderCache.swift
+++ b/Sources/CodexBarCore/CookieHeaderCache.swift
@@ -1,6 +1,51 @@
 import Foundation
+#if canImport(CryptoKit)
+import CryptoKit
+#endif
+#if canImport(Darwin)
+import Darwin
+#elseif canImport(Glibc)
+import Glibc
+#elseif canImport(Musl)
+import Musl
+#endif
 
 public enum CookieHeaderCache {
+    public enum Scope: Sendable, Equatable {
+        case managedAccount(UUID)
+        case managedStoreUnreadable
+        case profileHome(String)
+
+        public var isolationIdentifier: String {
+            switch self {
+            case let .managedAccount(accountID):
+                "managed.\(accountID.uuidString.lowercased())"
+            case .managedStoreUnreadable:
+                "managed-store-unreadable"
+            case let .profileHome(path):
+                "profile-home.\(Self.profileHomeDigest(path))"
+            }
+        }
+
+        fileprivate var keychainIdentifier: String {
+            self.isolationIdentifier
+        }
+
+        private static func profileHomeDigest(_ path: String) -> String {
+            let standardized = URL(fileURLWithPath: path, isDirectory: true).standardizedFileURL.path
+            #if canImport(CryptoKit)
+            return SHA256.hash(data: Data(standardized.utf8))
+                .map { String(format: "%02x", $0) }
+                .joined()
+            #else
+            let digest = standardized.utf8.reduce(UInt64(14_695_981_039_346_656_037)) { partial, byte in
+                (partial ^ UInt64(byte)) &* 1_099_511_628_211
+            }
+            return String(digest, radix: 16)
+            #endif
+        }
+    }
+
     public struct Entry: Codable, Sendable {
         public let cookieHeader: String
         public let storedAt: Date
@@ -13,15 +58,308 @@ public enum CookieHeaderCache {
         }
     }
 
+    public struct ClearSummary: Equatable, Sendable {
+        public let clearedCount: Int
+        public let failedCount: Int
+
+        public init(clearedCount: Int, failedCount: Int) {
+            self.clearedCount = clearedCount
+            self.failedCount = failedCount
+        }
+    }
+
     private static let log = CodexBarLog.logger(LogCategories.cookieCache)
+    private static let legacyBaseURLOverrideLock = NSLock()
     private nonisolated(unsafe) static var legacyBaseURLOverride: URL?
 
-    public static func load(provider: UsageProvider) -> Entry? {
-        let key = KeychainCacheStore.Key.cookie(provider: provider)
+    private struct DisplaySnapshot {
+        let entry: Entry?
+        let refreshAfter: Date
+    }
+
+    private enum LoadOutcome {
+        case authoritative(Entry?, loadedFromLegacy: Bool)
+        case temporarilyUnavailable
+    }
+
+    private static let legacyMutationLock = NSLock()
+    private static let displayCacheLock = NSLock()
+    private nonisolated(unsafe) static var displayCache: [KeychainCacheStore.Key: DisplaySnapshot] = [:]
+    private nonisolated(unsafe) static var displayGenerations: [KeychainCacheStore.Key: UInt64] = [:]
+    private nonisolated(unsafe) static var displayRevalidationsInFlight: Set<KeychainCacheStore.Key> = []
+    private nonisolated(unsafe) static var legacyMigrationsInFlight: Set<UsageProvider> = []
+    private nonisolated(unsafe) static var displayStalenessIntervalOverride: TimeInterval?
+    private nonisolated(unsafe) static var displayUnavailableRetryIntervalOverride: TimeInterval?
+    private static let displayStalenessInterval: TimeInterval = 30
+    private static let displayUnavailableRetryInterval: TimeInterval = 1
+    #if DEBUG
+    @TaskLocal private static var taskLegacyBaseURLOverride: URL?
+    @TaskLocal private static var legacyRemovalFailureOverride = false
+    #endif
+
+    private enum LegacyRemovalResult: Equatable {
+        case removed
+        case missing
+        case failed
+    }
+
+    /// Settings rows render the "Cached: …" cookie label inside SwiftUI body evaluations, which
+    /// run repeatedly within a single AppKit layout pass. Each `load` pays a synchronous
+    /// securityd round-trip and decrypt, so display paths use this memoized variant instead: it
+    /// returns the last known entry immediately and revalidates a stale snapshot off the calling
+    /// path. In-process `store` and `clear` calls update the snapshot synchronously; only the
+    /// first lookup per key pays the keychain read.
+    public static func loadForDisplay(provider: UsageProvider, scope: Scope? = nil) -> Entry? {
+        let key = self.key(for: provider, scope: scope)
+        let (cached, generation) = self.beginDisplayRead(key: key)
+        guard let cached else {
+            switch self.loadOutcome(provider: provider, scope: scope, migrateLegacy: false) {
+            case let .authoritative(entry, loadedFromLegacy):
+                let committed = self.commitDisplaySnapshotIfCurrent(key: key, entry: entry, generation: generation)
+                if loadedFromLegacy {
+                    self.scheduleLegacyMigration(provider: provider)
+                }
+                return committed
+            case .temporarilyUnavailable:
+                return self.commitTemporaryDisplaySnapshotIfCurrent(key: key, generation: generation)
+            }
+        }
+        if Date() >= cached.refreshAfter {
+            self.scheduleDisplayRevalidation(provider: provider, scope: scope, key: key, generation: generation)
+        }
+        return cached.entry
+    }
+
+    /// Registers the key before the Keychain read starts so `clearAll` can invalidate an
+    /// in-flight first population even when no display snapshot exists yet.
+    private static func beginDisplayRead(key: KeychainCacheStore.Key) -> (DisplaySnapshot?, UInt64) {
+        self.displayCacheLock.lock()
+        defer { self.displayCacheLock.unlock() }
+        let generation = self.displayGenerations[key] ?? 0
+        self.displayGenerations[key] = generation
+        return (self.displayCache[key], generation)
+    }
+
+    private static func scheduleDisplayRevalidation(
+        provider: UsageProvider,
+        scope: Scope?,
+        key: KeychainCacheStore.Key,
+        generation: UInt64)
+    {
+        self.displayCacheLock.lock()
+        let inserted = self.displayRevalidationsInFlight.insert(key).inserted
+        self.displayCacheLock.unlock()
+        guard inserted else { return }
+        Task(priority: .utility) {
+            self.revalidateDisplaySnapshot(provider: provider, scope: scope, key: key, generation: generation)
+        }
+    }
+
+    private static func revalidateDisplaySnapshot(
+        provider: UsageProvider,
+        scope: Scope?,
+        key: KeychainCacheStore.Key,
+        generation: UInt64)
+    {
+        switch self.loadOutcome(provider: provider, scope: scope, migrateLegacy: false) {
+        case let .authoritative(entry, loadedFromLegacy):
+            _ = self.commitDisplaySnapshotIfCurrent(key: key, entry: entry, generation: generation)
+            if loadedFromLegacy {
+                self.scheduleLegacyMigration(provider: provider)
+            }
+        case .temporarilyUnavailable:
+            self.deferDisplayRetryIfCurrent(key: key, generation: generation)
+        }
+        self.displayCacheLock.lock()
+        self.displayRevalidationsInFlight.remove(key)
+        self.displayCacheLock.unlock()
+    }
+
+    private static func scheduleLegacyMigration(provider: UsageProvider) {
+        self.displayCacheLock.lock()
+        let inserted = self.legacyMigrationsInFlight.insert(provider).inserted
+        self.displayCacheLock.unlock()
+        guard inserted else { return }
+        Task(priority: .utility) {
+            _ = self.migrateLegacyEntryIfNeeded(provider: provider)
+            _ = self.displayCacheLock.withLock {
+                self.legacyMigrationsInFlight.remove(provider)
+            }
+        }
+    }
+
+    /// Keychain reads for the display cache happen outside the lock, so a concurrent `store` or
+    /// `clear` can publish newer state before the read commits. Each mutation bumps the per-key
+    /// generation; a read only commits if the generation it started from is still current, and
+    /// otherwise returns whatever newer snapshot won the race.
+    private static func commitDisplaySnapshotIfCurrent(
+        key: KeychainCacheStore.Key,
+        entry: Entry?,
+        generation: UInt64) -> Entry?
+    {
+        self.displayCacheLock.lock()
+        defer { self.displayCacheLock.unlock() }
+        guard self.displayGenerations[key, default: 0] == generation else {
+            return self.displayCache[key]?.entry
+        }
+        self.displayCache[key] = self.authoritativeDisplaySnapshot(entry: entry)
+        return entry
+    }
+
+    private static func commitTemporaryDisplaySnapshotIfCurrent(
+        key: KeychainCacheStore.Key,
+        generation: UInt64) -> Entry?
+    {
+        self.displayCacheLock.lock()
+        defer { self.displayCacheLock.unlock() }
+        guard self.displayGenerations[key, default: 0] == generation else {
+            return self.displayCache[key]?.entry
+        }
+        if let current = self.displayCache[key] {
+            return current.entry
+        }
+        self.displayCache[key] = self.temporaryDisplaySnapshot(entry: nil)
+        return nil
+    }
+
+    private static func deferDisplayRetryIfCurrent(key: KeychainCacheStore.Key, generation: UInt64) {
+        self.displayCacheLock.lock()
+        defer { self.displayCacheLock.unlock() }
+        guard self.displayGenerations[key, default: 0] == generation,
+              let current = self.displayCache[key]
+        else { return }
+        self.displayCache[key] = self.temporaryDisplaySnapshot(entry: current.entry)
+    }
+
+    private static func updateDisplaySnapshot(key: KeychainCacheStore.Key, entry: Entry?) {
+        self.displayCacheLock.lock()
+        self.displayCache[key] = self.authoritativeDisplaySnapshot(entry: entry)
+        self.displayGenerations[key, default: 0] += 1
+        self.displayCacheLock.unlock()
+    }
+
+    private static func invalidateDisplaySnapshot(key: KeychainCacheStore.Key) {
+        self.displayCacheLock.lock()
+        self.displayCache.removeValue(forKey: key)
+        self.displayGenerations[key, default: 0] += 1
+        self.displayCacheLock.unlock()
+    }
+
+    private static func currentDisplayEntry(key: KeychainCacheStore.Key) -> Entry? {
+        self.displayCacheLock.lock()
+        defer { self.displayCacheLock.unlock() }
+        return self.displayCache[key]?.entry
+    }
+
+    private static func authoritativeDisplaySnapshot(entry: Entry?) -> DisplaySnapshot {
+        DisplaySnapshot(entry: entry, refreshAfter: Date().addingTimeInterval(self.currentDisplayStalenessInterval))
+    }
+
+    private static func temporaryDisplaySnapshot(entry: Entry?) -> DisplaySnapshot {
+        DisplaySnapshot(
+            entry: entry,
+            refreshAfter: Date().addingTimeInterval(self.currentDisplayUnavailableRetryInterval))
+    }
+
+    private static var currentDisplayStalenessInterval: TimeInterval {
+        self.displayStalenessIntervalOverride ?? self.displayStalenessInterval
+    }
+
+    private static var currentDisplayUnavailableRetryInterval: TimeInterval {
+        self.displayUnavailableRetryIntervalOverride ?? self.displayUnavailableRetryInterval
+    }
+
+    static func setDisplayStalenessIntervalOverrideForTesting(_ interval: TimeInterval?) {
+        self.displayStalenessIntervalOverride = interval
+    }
+
+    static func setDisplayUnavailableRetryIntervalOverrideForTesting(_ interval: TimeInterval?) {
+        self.displayUnavailableRetryIntervalOverride = interval
+    }
+
+    static func resetDisplayCacheForTesting() {
+        self.displayCacheLock.lock()
+        self.displayCache.removeAll()
+        self.displayGenerations.removeAll()
+        self.displayRevalidationsInFlight.removeAll()
+        self.legacyMigrationsInFlight.removeAll()
+        self.displayCacheLock.unlock()
+    }
+
+    static func beginDisplayReadGenerationForTesting(provider: UsageProvider, scope: Scope? = nil) -> UInt64 {
+        self.beginDisplayRead(key: self.key(for: provider, scope: scope)).1
+    }
+
+    static func currentDisplayEntryForTesting(provider: UsageProvider, scope: Scope? = nil) -> Entry? {
+        self.currentDisplayEntry(key: self.key(for: provider, scope: scope))
+    }
+
+    #if DEBUG
+    static func withLegacyRemovalFailureForTesting<T>(_ operation: () throws -> T) rethrows -> T {
+        try self.$legacyRemovalFailureOverride.withValue(true) {
+            try operation()
+        }
+    }
+    #endif
+
+    @discardableResult
+    static func commitDisplaySnapshotIfCurrentForTesting(
+        provider: UsageProvider,
+        scope: Scope? = nil,
+        entry: Entry?,
+        generation: UInt64) -> Entry?
+    {
+        self.commitDisplaySnapshotIfCurrent(
+            key: self.key(for: provider, scope: scope),
+            entry: entry,
+            generation: generation)
+    }
+
+    public static func load(provider: UsageProvider, scope: Scope? = nil) -> Entry? {
+        switch self.loadOutcome(provider: provider, scope: scope, migrateLegacy: true) {
+        case let .authoritative(entry, _):
+            entry
+        case .temporarilyUnavailable:
+            nil
+        }
+    }
+
+    static func loadSerialized(provider: UsageProvider, scope: Scope? = nil) -> Entry? {
+        do {
+            return try self.withLegacyMutationLock {
+                let key = self.key(for: provider, scope: scope)
+                switch KeychainCacheStore.load(key: key, as: Entry.self) {
+                case let .found(entry):
+                    return entry
+                case .temporarilyUnavailable:
+                    return nil
+                case .invalid:
+                    KeychainCacheStore.clear(key: key)
+                case .missing:
+                    break
+                }
+                guard scope == nil else { return nil }
+                return self.migrateLegacyEntryIfNeededLocked(provider: provider)
+            }
+        } catch {
+            self.log.error("Cookie cache serialized load failed: \(error)")
+            return nil
+        }
+    }
+
+    private static func loadOutcome(
+        provider: UsageProvider,
+        scope: Scope?,
+        migrateLegacy: Bool) -> LoadOutcome
+    {
+        let key = self.key(for: provider, scope: scope)
         switch KeychainCacheStore.load(key: key, as: Entry.self) {
         case let .found(entry):
             self.log.debug("Cookie cache hit", metadata: ["provider": provider.rawValue])
-            return entry
+            return .authoritative(entry, loadedFromLegacy: false)
+        case .temporarilyUnavailable:
+            self.log.debug("Cookie cache temporarily unavailable", metadata: ["provider": provider.rawValue])
+            return .temporarilyUnavailable
         case .invalid:
             self.log.warning("Cookie cache invalid; clearing", metadata: ["provider": provider.rawValue])
             KeychainCacheStore.clear(key: key)
@@ -29,36 +367,356 @@ public enum CookieHeaderCache {
             self.log.debug("Cookie cache miss", metadata: ["provider": provider.rawValue])
         }
 
+        guard scope == nil else { return .authoritative(nil, loadedFromLegacy: false) }
+        if migrateLegacy {
+            return .authoritative(
+                self.migrateLegacyEntryIfNeeded(provider: provider),
+                loadedFromLegacy: false)
+        }
+        guard let legacy = self.loadLegacyEntry(for: provider) else {
+            return .authoritative(nil, loadedFromLegacy: false)
+        }
+        return .authoritative(legacy, loadedFromLegacy: true)
+    }
+
+    /// Re-reads both stores while serialized with global cookie mutations. A display-triggered
+    /// migration may be queued before a clear, so using the captured legacy entry here would
+    /// otherwise allow the delayed task to restore credentials the user just removed.
+    private static func migrateLegacyEntryIfNeeded(provider: UsageProvider) -> Entry? {
+        do {
+            return try self.withLegacyMutationLock {
+                self.migrateLegacyEntryIfNeededLocked(provider: provider)
+            }
+        } catch {
+            self.log.error("Cookie cache migration lock failed: \(error)")
+            return nil
+        }
+    }
+
+    private static func migrateLegacyEntryIfNeededLocked(provider: UsageProvider) -> Entry? {
+        let key = self.key(for: provider, scope: nil)
+        switch KeychainCacheStore.load(key: key, as: Entry.self) {
+        case let .found(entry):
+            _ = self.removeLegacyEntry(for: provider)
+            return entry
+        case .temporarilyUnavailable:
+            return nil
+        case .invalid:
+            KeychainCacheStore.clear(key: key)
+        case .missing:
+            break
+        }
+
         guard let legacy = self.loadLegacyEntry(for: provider) else { return nil }
-        KeychainCacheStore.store(key: key, entry: legacy)
-        self.removeLegacyEntry(for: provider)
-        self.log.debug("Cookie cache migrated from legacy store", metadata: ["provider": provider.rawValue])
+        if KeychainCacheStore.storeResult(key: key, entry: legacy),
+           self.removeLegacyEntry(for: provider) == .removed
+        {
+            self.log.debug("Cookie cache migrated from legacy store", metadata: ["provider": provider.rawValue])
+        }
         return legacy
     }
 
     public static func store(
         provider: UsageProvider,
+        scope: Scope? = nil,
         cookieHeader: String,
         sourceLabel: String,
         now: Date = Date())
     {
         let trimmed = cookieHeader.trimmingCharacters(in: .whitespacesAndNewlines)
         guard let normalized = CookieHeaderNormalizer.normalize(trimmed), !normalized.isEmpty else {
-            self.clear(provider: provider)
+            self.clear(provider: provider, scope: scope)
             return
         }
         let entry = Entry(cookieHeader: normalized, storedAt: now, sourceLabel: sourceLabel)
-        let key = KeychainCacheStore.Key.cookie(provider: provider)
-        KeychainCacheStore.store(key: key, entry: entry)
-        self.removeLegacyEntry(for: provider)
+        do {
+            try self.withLegacyMutationLock {
+                _ = self.store(entry: entry, provider: provider, scope: scope, sourceLabel: sourceLabel)
+            }
+        } catch {
+            self.log.error("Cookie cache store lock failed: \(error)")
+        }
+    }
+
+    /// Stores only while the cache still matches the entry observed before an asynchronous refresh.
+    /// A nil expected entry means the cache must still be empty.
+    @discardableResult
+    static func storeIfCurrent(
+        provider: UsageProvider,
+        scope: Scope? = nil,
+        expected: Entry?,
+        cookieHeader: String,
+        sourceLabel: String,
+        now: Date = Date()) -> Bool
+    {
+        let trimmed = cookieHeader.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard let normalized = CookieHeaderNormalizer.normalize(trimmed), !normalized.isEmpty else { return false }
+        let entry = Entry(cookieHeader: normalized, storedAt: now, sourceLabel: sourceLabel)
+        do {
+            return try self.withLegacyMutationLock {
+                guard self.currentEntryMatches(expected, provider: provider, scope: scope) else { return false }
+                return self.store(entry: entry, provider: provider, scope: scope, sourceLabel: sourceLabel)
+            }
+        } catch {
+            self.log.error("Cookie cache conditional store lock failed: \(error)")
+            return false
+        }
+    }
+
+    /// Clears only while the cache still matches the entry that produced a failed asynchronous refresh.
+    @discardableResult
+    static func clearIfCurrent(
+        provider: UsageProvider,
+        scope: Scope? = nil,
+        expected: Entry?) -> Bool
+    {
+        do {
+            return try self.withLegacyMutationLock {
+                guard self.currentEntryMatches(expected, provider: provider, scope: scope) else { return false }
+                // Keep the expected Keychain row intact when legacy cleanup fails so fallback can replace it.
+                if scope == nil, self.removeLegacyEntry(for: provider) == .failed {
+                    return false
+                }
+                let key = self.key(for: provider, scope: scope)
+                let result = KeychainCacheStore.clearResult(key: key)
+                guard result != .failed else { return false }
+                self.updateDisplaySnapshot(key: key, entry: nil)
+                return true
+            }
+        } catch {
+            self.log.error("Cookie cache conditional clear lock failed: \(error)")
+            return false
+        }
+    }
+
+    private static func currentEntryMatches(
+        _ expected: Entry?,
+        provider: UsageProvider,
+        scope: Scope?) -> Bool
+    {
+        let key = self.key(for: provider, scope: scope)
+        switch KeychainCacheStore.load(key: key, as: Entry.self) {
+        case let .found(current):
+            return self.entriesMatch(current, expected)
+        case .missing:
+            if scope == nil, let legacy = self.loadLegacyEntry(for: provider) {
+                return self.entriesMatch(legacy, expected)
+            }
+            return expected == nil
+        case .invalid, .temporarilyUnavailable:
+            return false
+        }
+    }
+
+    private static func entriesMatch(_ current: Entry, _ expected: Entry?) -> Bool {
+        guard let expected else { return false }
+        return current.cookieHeader == expected.cookieHeader
+            && current.storedAt == expected.storedAt
+            && current.sourceLabel == expected.sourceLabel
+    }
+
+    @discardableResult
+    private static func store(
+        entry: Entry,
+        provider: UsageProvider,
+        scope: Scope?,
+        sourceLabel: String) -> Bool
+    {
+        let key = self.key(for: provider, scope: scope)
+        guard KeychainCacheStore.storeResult(key: key, entry: entry) else { return false }
+        self.updateDisplaySnapshot(key: key, entry: entry)
+        if scope == nil {
+            _ = self.removeLegacyEntry(for: provider)
+        }
         self.log.debug("Cookie cache stored", metadata: ["provider": provider.rawValue, "source": sourceLabel])
+        return true
     }
 
-    public static func clear(provider: UsageProvider) {
-        let key = KeychainCacheStore.Key.cookie(provider: provider)
-        KeychainCacheStore.clear(key: key)
-        self.removeLegacyEntry(for: provider)
+    @discardableResult
+    public static func clear(provider: UsageProvider, scope: Scope? = nil) -> Int {
+        self.clearDetailed(provider: provider, scope: scope).clearedCount
+    }
+
+    public static func clearDetailed(provider: UsageProvider, scope: Scope? = nil) -> ClearSummary {
+        do {
+            return try self.withLegacyMutationLock {
+                self.clearDetailedLocked(provider: provider, scope: scope)
+            }
+        } catch {
+            self.log.error("Cookie cache clear lock failed: \(error)")
+            return ClearSummary(clearedCount: 0, failedCount: 1)
+        }
+    }
+
+    private static func clearDetailedLocked(provider: UsageProvider, scope: Scope?) -> ClearSummary {
+        let key = self.key(for: provider, scope: scope)
+        let result = KeychainCacheStore.clearResult(key: key)
+        var cleared = result == .removed ? 1 : 0
+        var failed = result == .failed ? 1 : 0
+        if result != .failed {
+            self.updateDisplaySnapshot(key: key, entry: nil)
+        }
+        let legacyResult: LegacyRemovalResult = if scope == nil {
+            self.removeLegacyEntry(for: provider)
+        } else {
+            .missing
+        }
+        if legacyResult == .removed {
+            cleared += 1
+            if result == .failed {
+                self.invalidateDisplaySnapshot(key: key)
+            }
+        } else if legacyResult == .failed {
+            failed += 1
+        }
         self.log.debug("Cookie cache cleared", metadata: ["provider": provider.rawValue])
+        return ClearSummary(clearedCount: cleared, failedCount: failed)
+    }
+
+    /// Clears all cookie cache scopes for one provider, including managed Codex account scopes.
+    /// Returns keychain/legacy removal and failure counts.
+    @discardableResult
+    public static func clearAllScopes(provider: UsageProvider) -> Int {
+        self.clearAllScopesDetailed(provider: provider).clearedCount
+    }
+
+    public static func clearAllScopesDetailed(provider: UsageProvider) -> ClearSummary {
+        do {
+            return try self.withLegacyMutationLock {
+                self.clearAllScopesDetailedLocked(provider: provider)
+            }
+        } catch {
+            self.log.error("Cookie cache clearAllScopes lock failed: \(error)")
+            return ClearSummary(clearedCount: 0, failedCount: 1)
+        }
+    }
+
+    private static func clearAllScopesDetailedLocked(provider: UsageProvider) -> ClearSummary {
+        let (keys, enumerationFailed) = self.cookieKeysResult(for: provider)
+        var cleared = 0
+        var failedKeys = Set<KeychainCacheStore.Key>()
+        for key in keys {
+            let result = KeychainCacheStore.clearResult(key: key)
+            if result == .removed {
+                cleared += 1
+            }
+            if result != .failed {
+                self.updateDisplaySnapshot(key: key, entry: nil)
+            } else {
+                failedKeys.insert(key)
+            }
+        }
+        let legacyResult = self.removeLegacyEntry(for: provider)
+        if legacyResult == .removed {
+            cleared += 1
+            let globalKey = self.key(for: provider, scope: nil)
+            if failedKeys.contains(globalKey) {
+                self.invalidateDisplaySnapshot(key: globalKey)
+            }
+        }
+        let failedCount = failedKeys.count + (enumerationFailed ? 1 : 0) + (legacyResult == .failed ? 1 : 0)
+        self.log.debug("Cookie cache clearAllScopes completed", metadata: [
+            "provider": provider.rawValue,
+            "cleared": "\(cleared)",
+        ])
+        return ClearSummary(clearedCount: cleared, failedCount: failedCount)
+    }
+
+    /// Clears cookie caches for all providers, including corrupt/invalid entries.
+    /// Returns keychain/legacy removal and failure counts.
+    @discardableResult
+    public static func clearAll() -> Int {
+        self.clearAllDetailed().clearedCount
+    }
+
+    public static func clearAllDetailed() -> ClearSummary {
+        do {
+            return try self.withLegacyMutationLock {
+                self.clearAllDetailedLocked()
+            }
+        } catch {
+            self.log.error("Cookie cache clearAll lock failed: \(error)")
+            return ClearSummary(clearedCount: 0, failedCount: 1)
+        }
+    }
+
+    private static func clearAllDetailedLocked() -> ClearSummary {
+        self.displayCacheLock.lock()
+        let knownDisplayKeys = Set(self.displayCache.keys).union(self.displayGenerations.keys)
+        self.displayCacheLock.unlock()
+        let enumeratedKeys: [KeychainCacheStore.Key]
+        let enumerationFailed: Bool
+        switch KeychainCacheStore.keysResult(category: "cookie") {
+        case let .found(keys):
+            enumeratedKeys = keys
+            enumerationFailed = false
+        case .temporarilyUnavailable, .failed:
+            enumeratedKeys = []
+            enumerationFailed = true
+        }
+        let keys = Set(enumeratedKeys).union(knownDisplayKeys)
+        var cleared = 0
+        var failedKeys = Set<KeychainCacheStore.Key>()
+        for key in keys {
+            let result = KeychainCacheStore.clearResult(key: key)
+            if result == .removed {
+                cleared += 1
+            }
+            if result != .failed {
+                self.updateDisplaySnapshot(key: key, entry: nil)
+            } else {
+                failedKeys.insert(key)
+            }
+        }
+        var legacyFailures = 0
+        for provider in UsageProvider.allCases {
+            switch self.removeLegacyEntry(for: provider) {
+            case .removed:
+                cleared += 1
+                let globalKey = self.key(for: provider, scope: nil)
+                if failedKeys.contains(globalKey) {
+                    self.invalidateDisplaySnapshot(key: globalKey)
+                }
+            case .failed:
+                legacyFailures += 1
+            case .missing:
+                break
+            }
+        }
+        self.log.debug("Cookie cache clearAll completed", metadata: ["cleared": "\(cleared)"])
+        return ClearSummary(
+            clearedCount: cleared,
+            failedCount: failedKeys.count + (enumerationFailed ? 1 : 0) + legacyFailures)
+    }
+
+    private static func cookieKeysResult(for provider: UsageProvider) -> ([KeychainCacheStore.Key], Bool) {
+        let exactIdentifier = provider.rawValue
+        let scopedPrefix = "\(provider.rawValue)."
+        var seen = Set<KeychainCacheStore.Key>()
+        var keys: [KeychainCacheStore.Key] = []
+        let enumeratedKeys: [KeychainCacheStore.Key]
+        let enumerationFailed: Bool
+        switch KeychainCacheStore.keysResult(category: "cookie") {
+        case let .found(keys):
+            enumeratedKeys = keys
+            enumerationFailed = false
+        case .temporarilyUnavailable, .failed:
+            enumeratedKeys = []
+            enumerationFailed = true
+        }
+        for key in enumeratedKeys {
+            guard key.identifier == exactIdentifier || key.identifier.hasPrefix(scopedPrefix) else {
+                continue
+            }
+            if seen.insert(key).inserted {
+                keys.append(key)
+            }
+        }
+        let global = self.key(for: provider, scope: nil)
+        if seen.insert(global).inserted {
+            keys.append(global)
+        }
+        return (keys, enumerationFailed)
     }
 
     static func load(from url: URL) -> Entry? {
@@ -82,32 +740,227 @@ public enum CookieHeaderCache {
     }
 
     static func setLegacyBaseURLOverrideForTesting(_ url: URL?) {
-        self.legacyBaseURLOverride = url
+        self.legacyBaseURLOverrideLock.withLock {
+            self.legacyBaseURLOverride = url
+        }
     }
 
-    private static func loadLegacyEntry(for provider: UsageProvider) -> Entry? {
-        self.load(from: self.legacyURL(for: provider))
+    #if DEBUG
+    static func withLegacyBaseURLOverrideForTesting<T>(
+        _ url: URL?,
+        operation: () throws -> T) rethrows -> T
+    {
+        try self.$taskLegacyBaseURLOverride.withValue(url) {
+            try operation()
+        }
+    }
+
+    static func withLegacyBaseURLOverrideForTesting<T>(
+        _ url: URL?,
+        operation: () async throws -> T) async rethrows -> T
+    {
+        try await self.$taskLegacyBaseURLOverride.withValue(url) {
+            try await operation()
+        }
+    }
+    #endif
+
+    static func hasLegacyEntryForTesting(provider: UsageProvider) -> Bool {
+        self.loadLegacyEntry(for: provider) != nil
+    }
+
+    static func legacyURLForTesting(provider: UsageProvider) -> URL {
+        self.legacyURL(for: provider)
+    }
+
+    private static func hasKeychainEntry(provider: UsageProvider, scope: Scope?) -> Bool {
+        let key = self.key(for: provider, scope: scope)
+        switch KeychainCacheStore.load(key: key, as: Entry.self) {
+        case .found, .invalid:
+            return true
+        case .missing, .temporarilyUnavailable:
+            return false
+        }
     }
 
-    private static func removeLegacyEntry(for provider: UsageProvider) {
+    static func hasKeychainEntryForTesting(provider: UsageProvider, scope: Scope? = nil) -> Bool {
+        self.hasKeychainEntry(provider: provider, scope: scope)
+    }
+
+    static func migrateLegacyEntryIfNeededForTesting(provider: UsageProvider) -> Entry? {
+        self.migrateLegacyEntryIfNeeded(provider: provider)
+    }
+
+    private static func withLegacyMutationLock<T>(_ operation: () throws -> T) throws -> T {
+        try self.legacyMutationLock.withLock {
+            let lockURL = self.legacyMutationLockURL
+            try FileManager.default.createDirectory(
+                at: lockURL.deletingLastPathComponent(),
+                withIntermediateDirectories: true)
+            let fd = open(lockURL.path, O_CREAT | O_RDWR | O_CLOEXEC, S_IRUSR | S_IWUSR)
+            guard fd >= 0 else {
+                throw POSIXError(POSIXErrorCode(rawValue: errno) ?? .EIO)
+            }
+            defer {
+                _ = flock(fd, LOCK_UN)
+                close(fd)
+            }
+            while flock(fd, LOCK_EX) != 0 {
+                guard errno == EINTR else {
+                    throw POSIXError(POSIXErrorCode(rawValue: errno) ?? .EIO)
+                }
+            }
+            return try operation()
+        }
+    }
+
+    private static var legacyMutationLockURL: URL {
+        let base = self.currentLegacyBaseURLOverride ?? self.defaultLegacyBaseURL
+        return base.appendingPathComponent("cookie-cache.lock")
+    }
+
+    private static func removeLegacyEntry(for provider: UsageProvider) -> LegacyRemovalResult {
         let url = self.legacyURL(for: provider)
+        #if DEBUG
+        if self.legacyRemovalFailureOverride {
+            return .failed
+        }
+        #endif
+        let existed = FileManager.default.fileExists(atPath: url.path)
         do {
             try FileManager.default.removeItem(at: url)
+            return existed ? .removed : .missing
         } catch {
             if (error as NSError).code != NSFileNoSuchFileError {
                 Self.log.error("Failed to remove cookie cache (\(provider.rawValue)): \(error)")
+                return .failed
             }
+            return .missing
         }
     }
 
+    private static func loadLegacyEntry(for provider: UsageProvider) -> Entry? {
+        self.load(from: self.legacyURL(for: provider))
+    }
+
     private static func legacyURL(for provider: UsageProvider) -> URL {
-        if let override = self.legacyBaseURLOverride {
+        if let override = self.currentLegacyBaseURLOverride {
             return override.appendingPathComponent("\(provider.rawValue)-cookie.json")
         }
+        return self.defaultLegacyBaseURL.appendingPathComponent("\(provider.rawValue)-cookie.json")
+    }
+
+    private static var currentLegacyBaseURLOverride: URL? {
+        #if DEBUG
+        if let taskOverride = self.taskLegacyBaseURLOverride {
+            return taskOverride
+        }
+        #endif
+        return self.legacyBaseURLOverrideLock.withLock {
+            self.legacyBaseURLOverride
+        }
+    }
+
+    private static var defaultLegacyBaseURL: URL {
         let fm = FileManager.default
         let base = fm.urls(for: .applicationSupportDirectory, in: .userDomainMask).first
             ?? fm.temporaryDirectory
         return base.appendingPathComponent("CodexBar", isDirectory: true)
-            .appendingPathComponent("\(provider.rawValue)-cookie.json")
+    }
+
+    private static func key(for provider: UsageProvider, scope: Scope?) -> KeychainCacheStore.Key {
+        KeychainCacheStore.Key.cookie(provider: provider, scopeIdentifier: scope?.keychainIdentifier)
+    }
+}
+
+extension CookieHeaderCache {
+    enum ConditionalMutationObservation {
+        case authoritative(Entry?)
+        case keychainTemporarilyUnavailable(legacyEntry: Entry?)
+
+        var entry: Entry? {
+            switch self {
+            case let .authoritative(entry): entry
+            case .keychainTemporarilyUnavailable: nil
+            }
+        }
+    }
+
+    /// Captures enough state to conditionally persist an asynchronous refresh after a transient
+    /// Keychain read failure without mistaking an untouched legacy entry for a concurrent write.
+    static func observeForConditionalMutation(
+        provider: UsageProvider,
+        scope: Scope? = nil) -> ConditionalMutationObservation
+    {
+        do {
+            return try self.withLegacyMutationLock {
+                let key = self.key(for: provider, scope: scope)
+                switch KeychainCacheStore.load(key: key, as: Entry.self) {
+                case let .found(entry):
+                    return .authoritative(entry)
+                case .temporarilyUnavailable:
+                    let legacyEntry = scope == nil ? self.loadLegacyEntry(for: provider) : nil
+                    return .keychainTemporarilyUnavailable(legacyEntry: legacyEntry)
+                case .invalid:
+                    KeychainCacheStore.clear(key: key)
+                case .missing:
+                    break
+                }
+                guard scope == nil else { return .authoritative(nil) }
+                return .authoritative(self.migrateLegacyEntryIfNeededLocked(provider: provider))
+            }
+        } catch {
+            self.log.error("Cookie cache observation lock failed: \(error)")
+            return .keychainTemporarilyUnavailable(legacyEntry: nil)
+        }
+    }
+
+    /// Stores against a state captured by `observeForConditionalMutation`. A transient initial
+    /// Keychain failure may proceed only after Keychain recovers as missing and legacy state is unchanged.
+    @discardableResult
+    static func storeIfObservationCurrent(
+        provider: UsageProvider,
+        scope: Scope? = nil,
+        expected: ConditionalMutationObservation,
+        cookieHeader: String,
+        sourceLabel: String,
+        now: Date = Date()) -> Bool
+    {
+        let trimmed = cookieHeader.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard let normalized = CookieHeaderNormalizer.normalize(trimmed), !normalized.isEmpty else { return false }
+        let entry = Entry(cookieHeader: normalized, storedAt: now, sourceLabel: sourceLabel)
+        do {
+            return try self.withLegacyMutationLock {
+                guard self.currentStateMatches(expected, provider: provider, scope: scope) else { return false }
+                return self.store(entry: entry, provider: provider, scope: scope, sourceLabel: sourceLabel)
+            }
+        } catch {
+            self.log.error("Cookie cache observed store lock failed: \(error)")
+            return false
+        }
+    }
+
+    private static func currentStateMatches(
+        _ expected: ConditionalMutationObservation,
+        provider: UsageProvider,
+        scope: Scope?) -> Bool
+    {
+        switch expected {
+        case let .authoritative(entry):
+            return self.currentEntryMatches(entry, provider: provider, scope: scope)
+        case let .keychainTemporarilyUnavailable(expectedLegacyEntry):
+            let key = self.key(for: provider, scope: scope)
+            guard case .missing = KeychainCacheStore.load(key: key, as: Entry.self) else { return false }
+            guard scope == nil else { return true }
+            return self.optionalEntriesMatch(self.loadLegacyEntry(for: provider), expectedLegacyEntry)
+        }
+    }
+
+    private static func optionalEntriesMatch(_ current: Entry?, _ expected: Entry?) -> Bool {
+        switch (current, expected) {
+        case (nil, nil): true
+        case let (current?, expected?): self.entriesMatch(current, expected)
+        default: false
+        }
     }
 }
diff --git a/Sources/CodexBarCore/CookieHeaderNormalizer.swift b/Sources/CodexBarCore/CookieHeaderNormalizer.swift
index c984eb2b6c..c84251fb48 100644
--- a/Sources/CodexBarCore/CookieHeaderNormalizer.swift
+++ b/Sources/CodexBarCore/CookieHeaderNormalizer.swift
@@ -7,9 +7,10 @@ public enum CookieHeaderNormalizer {
         #"(?i)\bcookie:\s*'([^']+)'"#,
         #"(?i)\bcookie:\s*\"([^\"]+)\""#,
         #"(?i)\bcookie:\s*([^\r\n]+)"#,
-        #"(?i)(?:--cookie|-b)\s*'([^']+)'"#,
-        #"(?i)(?:--cookie|-b)\s*\"([^\"]+)\""#,
-        #"(?i)(?:--cookie|-b)\s*([^\s]+)"#,
+        #"(?i)(?:^|\s)(?:--cookie|-b)\s*'([^']+)'"#,
+        #"(?i)(?:^|\s)(?:--cookie|-b)\s*\"([^\"]+)\""#,
+        #"(?i)(?:^|\s)-b([^\s=]+=[^\s]+)"#,
+        #"(?i)(?:^|\s)(?:--cookie|-b)\s+([^\s]+)"#,
     ]
 
     public static func normalize(_ raw: String?) -> String? {
@@ -50,6 +51,12 @@ public enum CookieHeaderNormalizer {
         return results
     }
 
+    public static func filteredHeader(from raw: String?, allowedNames: Set<String>) -> String? {
+        let filtered = self.pairs(from: raw ?? "").filter { allowedNames.contains($0.name) }
+        guard !filtered.isEmpty else { return nil }
+        return filtered.map { "\($0.name)=\($0.value)" }.joined(separator: "; ")
+    }
+
     private static func extractHeader(from raw: String) -> String? {
         for pattern in self.headerPatterns {
             guard let regex = try? NSRegularExpression(pattern: pattern, options: []) else { continue }
diff --git a/Sources/CodexBarCore/CopilotUsageModels.swift b/Sources/CodexBarCore/CopilotUsageModels.swift
index fef52b64c9..d9597f1967 100644
--- a/Sources/CodexBarCore/CopilotUsageModels.swift
+++ b/Sources/CodexBarCore/CopilotUsageModels.swift
@@ -22,8 +22,37 @@ public struct CopilotUsageResponse: Sendable, Decodable {
         public let percentRemaining: Double
         public let quotaId: String
         public let hasPercentRemaining: Bool
+        public let unlimited: Bool
+        private let entitlementWasDecoded: Bool
+        private let remainingWasDecoded: Bool
+        public var usedPercent: Double {
+            max(0, 100 - self.percentRemaining)
+        }
+
+        public var overQuotaUsedPercent: Double? {
+            self.usedPercent > 100 ? self.usedPercent : nil
+        }
+
         public var isPlaceholder: Bool {
-            self.entitlement == 0 && self.remaining == 0 && self.percentRemaining == 0 && self.quotaId.isEmpty
+            if self.unlimited {
+                return false
+            }
+
+            if self.entitlement == 0,
+               self.remaining == 0,
+               self.percentRemaining == 0,
+               !self.hasPercentRemaining
+            {
+                return true
+            }
+
+            // An explicit zero-entitlement, zero-remaining snapshot carries no usable quota signal.
+            // GitHub returns this shape for token-based billing / Copilot Business seats,
+            // sometimes as percent_remaining=100 with a non-empty quota_id, which would
+            // otherwise render as a misleading "0% used" (100 - 100). Treat it as a
+            // placeholder so the usual handling drops it instead of showing fake usage.
+            return self.entitlementWasDecoded && self.remainingWasDecoded && self.entitlement == 0 && self
+                .remaining == 0
         }
 
         private enum CodingKeys: String, CodingKey {
@@ -31,6 +60,7 @@ public struct CopilotUsageResponse: Sendable, Decodable {
             case remaining
             case percentRemaining = "percent_remaining"
             case quotaId = "quota_id"
+            case unlimited
         }
 
         public init(
@@ -38,13 +68,17 @@ public struct CopilotUsageResponse: Sendable, Decodable {
             remaining: Double,
             percentRemaining: Double,
             quotaId: String,
-            hasPercentRemaining: Bool = true)
+            hasPercentRemaining: Bool = true,
+            unlimited: Bool = false)
         {
             self.entitlement = entitlement
             self.remaining = remaining
-            self.percentRemaining = percentRemaining
+            self.percentRemaining = unlimited ? 100 : percentRemaining
             self.quotaId = quotaId
-            self.hasPercentRemaining = hasPercentRemaining
+            self.hasPercentRemaining = unlimited || hasPercentRemaining
+            self.unlimited = unlimited
+            self.entitlementWasDecoded = true
+            self.remainingWasDecoded = true
         }
 
         public init(from decoder: any Decoder) throws {
@@ -53,16 +87,22 @@ public struct CopilotUsageResponse: Sendable, Decodable {
             let decodedRemaining = Self.decodeNumberIfPresent(container: container, key: .remaining)
             self.entitlement = decodedEntitlement ?? 0
             self.remaining = decodedRemaining ?? 0
+            self.entitlementWasDecoded = decodedEntitlement != nil
+            self.remainingWasDecoded = decodedRemaining != nil
+            let decodedUnlimited = try container.decodeIfPresent(Bool.self, forKey: .unlimited) ?? false
             let decodedPercent = Self.decodeNumberIfPresent(container: container, key: .percentRemaining)
-            if let decodedPercent {
-                self.percentRemaining = max(0, min(100, decodedPercent))
+            if decodedUnlimited {
+                self.percentRemaining = 100
+                self.hasPercentRemaining = true
+            } else if let decodedPercent {
+                self.percentRemaining = decodedPercent
                 self.hasPercentRemaining = true
             } else if let entitlement = decodedEntitlement,
                       entitlement > 0,
                       let remaining = decodedRemaining
             {
                 let derived = (remaining / entitlement) * 100
-                self.percentRemaining = max(0, min(100, derived))
+                self.percentRemaining = derived
                 self.hasPercentRemaining = true
             } else {
                 // Without percent_remaining and both inputs for derivation, the percent is unknown.
@@ -70,6 +110,7 @@ public struct CopilotUsageResponse: Sendable, Decodable {
                 self.hasPercentRemaining = false
             }
             self.quotaId = try container.decodeIfPresent(String.self, forKey: .quotaId) ?? ""
+            self.unlimited = decodedUnlimited
         }
 
         private static func decodeNumberIfPresent(
@@ -205,12 +246,14 @@ public struct CopilotUsageResponse: Sendable, Decodable {
 
     public let quotaSnapshots: QuotaSnapshots
     public let copilotPlan: String
+    public let tokenBasedBilling: Bool
     public let assignedDate: String?
     public let quotaResetDate: String?
 
     private enum CodingKeys: String, CodingKey {
         case quotaSnapshots = "quota_snapshots"
         case copilotPlan = "copilot_plan"
+        case tokenBasedBilling = "token_based_billing"
         case assignedDate = "assigned_date"
         case quotaResetDate = "quota_reset_date"
         case monthlyQuotas = "monthly_quotas"
@@ -220,11 +263,13 @@ public struct CopilotUsageResponse: Sendable, Decodable {
     public init(
         quotaSnapshots: QuotaSnapshots,
         copilotPlan: String,
+        tokenBasedBilling: Bool = false,
         assignedDate: String?,
         quotaResetDate: String?)
     {
         self.quotaSnapshots = quotaSnapshots
         self.copilotPlan = copilotPlan
+        self.tokenBasedBilling = tokenBasedBilling
         self.assignedDate = assignedDate
         self.quotaResetDate = quotaResetDate
     }
@@ -245,6 +290,7 @@ public struct CopilotUsageResponse: Sendable, Decodable {
             self.quotaSnapshots = directSnapshots ?? QuotaSnapshots(premiumInteractions: nil, chat: nil)
         }
         self.copilotPlan = try container.decodeIfPresent(String.self, forKey: .copilotPlan) ?? "unknown"
+        self.tokenBasedBilling = try container.decodeIfPresent(Bool.self, forKey: .tokenBasedBilling) ?? false
         self.assignedDate = try container.decodeIfPresent(String.self, forKey: .assignedDate)
         self.quotaResetDate = try container.decodeIfPresent(String.self, forKey: .quotaResetDate)
     }
diff --git a/Sources/CodexBarCore/CostUsageFetcher.swift b/Sources/CodexBarCore/CostUsageFetcher.swift
index 2243d5218a..e019ff608e 100644
--- a/Sources/CodexBarCore/CostUsageFetcher.swift
+++ b/Sources/CodexBarCore/CostUsageFetcher.swift
@@ -18,23 +18,126 @@ public enum CostUsageError: LocalizedError, Sendable {
 }
 
 public struct CostUsageFetcher: Sendable {
-    public init() {}
+    private let scannerOptions: CostUsageScanner.Options?
 
+    public init(cacheRoot: URL? = nil) {
+        self.scannerOptions = cacheRoot.map { CostUsageScanner.Options(cacheRoot: $0) }
+    }
+
+    init(scannerOptions: CostUsageScanner.Options) {
+        self.scannerOptions = scannerOptions
+    }
+
+    public func loadCachedCodexTokenSnapshot(
+        now: Date = Date(),
+        codexHomePath: String? = nil,
+        historyDays: Int = 30) async -> CostUsageTokenSnapshot?
+    {
+        await Self.loadCachedCodexTokenSnapshot(
+            now: now,
+            codexHomePath: codexHomePath,
+            historyDays: historyDays,
+            scannerOptions: self.scannerOptionsOverride())
+    }
+
+    public func loadTokenSnapshot(
+        provider: UsageProvider,
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        now: Date = Date(),
+        forceRefresh: Bool = false,
+        allowVertexClaudeFallback: Bool = false,
+        codexHomePath: String? = nil,
+        historyDays: Int = 30,
+        refreshPricingInBackground: Bool = true) async throws -> CostUsageTokenSnapshot
+    {
+        try await Self.loadTokenSnapshot(
+            provider: provider,
+            environment: environment,
+            now: now,
+            forceRefresh: forceRefresh,
+            allowVertexClaudeFallback: allowVertexClaudeFallback,
+            codexHomePath: codexHomePath,
+            historyDays: historyDays,
+            refreshPricingInBackground: refreshPricingInBackground,
+            scannerOptions: self.scannerOptionsOverride())
+    }
+
+    @available(*, deprecated, message: "Codex token-cost scans are uncapped; this limit is ignored.")
     public func loadTokenSnapshot(
         provider: UsageProvider,
+        environment: [String: String] = ProcessInfo.processInfo.environment,
         now: Date = Date(),
         forceRefresh: Bool = false,
-        allowVertexClaudeFallback: Bool = false) async throws -> CostUsageTokenSnapshot
+        allowVertexClaudeFallback: Bool = false,
+        codexHomePath: String? = nil,
+        historyDays: Int = 30,
+        refreshPricingInBackground: Bool = true,
+        automaticCodexScanByteLimit _: Int64?) async throws -> CostUsageTokenSnapshot
     {
-        guard provider == .codex || provider == .claude || provider == .vertexai else {
+        try await self.loadTokenSnapshot(
+            provider: provider,
+            environment: environment,
+            now: now,
+            forceRefresh: forceRefresh,
+            allowVertexClaudeFallback: allowVertexClaudeFallback,
+            codexHomePath: codexHomePath,
+            historyDays: historyDays,
+            refreshPricingInBackground: refreshPricingInBackground)
+    }
+
+    private func scannerOptionsOverride() -> CostUsageScanner.Options? {
+        self.scannerOptions
+    }
+
+    static func loadTokenSnapshot(
+        provider: UsageProvider,
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        now: Date = Date(),
+        forceRefresh: Bool = false,
+        allowVertexClaudeFallback: Bool = false,
+        codexHomePath: String? = nil,
+        historyDays: Int = 30,
+        refreshPricingInBackground: Bool = true,
+        scannerOptions overrideScannerOptions: CostUsageScanner.Options? = nil,
+        piScannerOptions overridePiScannerOptions: PiSessionCostScanner
+            .Options? = nil) async throws -> CostUsageTokenSnapshot
+    {
+        guard provider == .codex || provider == .claude || provider == .vertexai || provider == .bedrock else {
             throw CostUsageError.unsupportedProvider(provider)
         }
 
         let until = now
-        // Rolling window: last 30 days (inclusive). Use -29 for inclusive boundaries.
-        let since = Calendar.current.date(byAdding: .day, value: -29, to: now) ?? now
+        let clampedHistoryDays = max(1, min(365, historyDays))
+        // Rolling window is inclusive, so a 30-day display starts 29 days before `now`.
+        let since = Calendar.current.date(byAdding: .day, value: -(clampedHistoryDays - 1), to: now) ?? now
+
+        if provider == .bedrock {
+            let daily = try await Self.loadBedrockDailyReport(
+                environment: environment,
+                since: since,
+                until: until)
+            return Self.tokenSnapshot(from: daily, now: now, historyDays: clampedHistoryDays)
+        }
+
+        var options = overrideScannerOptions ?? CostUsageScanner.Options()
+        if provider == .codex,
+           let codexHomePath = codexHomePath?.trimmingCharacters(in: .whitespacesAndNewlines),
+           !codexHomePath.isEmpty
+        {
+            options.codexSessionsRoot = URL(fileURLWithPath: codexHomePath, isDirectory: true)
+                .appendingPathComponent("sessions", isDirectory: true)
+        }
+        if provider == .codex || provider == .claude {
+            let pricingCacheRoot = options.cacheRoot
+            if refreshPricingInBackground {
+                Task.detached(priority: .utility) {
+                    await ModelsDevPricingPipeline.refreshIfNeeded(now: now, cacheRoot: pricingCacheRoot)
+                }
+            } else {
+                await ModelsDevPricingPipeline.refreshIfNeeded(now: now, cacheRoot: pricingCacheRoot)
+            }
+        }
 
-        var options = CostUsageScanner.Options()
         if provider == .vertexai {
             options.claudeLogProviderFilter = allowVertexClaudeFallback ? .all : .vertexAIOnly
         } else if provider == .claude {
@@ -42,47 +145,154 @@ public struct CostUsageFetcher: Sendable {
         }
         if forceRefresh {
             options.refreshMinIntervalSeconds = 0
-            options.forceRescan = true
         }
-        var daily = CostUsageScanner.loadDailyReport(
-            provider: provider,
-            since: since,
-            until: until,
-            now: now,
-            options: options)
+        var resolvedPiOptions = overridePiScannerOptions ?? PiSessionCostScanner.Options()
+        if resolvedPiOptions.cacheRoot == nil {
+            resolvedPiOptions.cacheRoot = options.cacheRoot
+        }
+        if forceRefresh {
+            resolvedPiOptions.refreshMinIntervalSeconds = 0
+        }
+        let piOptions = resolvedPiOptions
 
-        if provider == .vertexai,
-           !allowVertexClaudeFallback,
-           options.claudeLogProviderFilter == .vertexAIOnly,
-           daily.data.isEmpty
-        {
-            var fallback = options
-            fallback.claudeLogProviderFilter = .all
-            daily = CostUsageScanner.loadDailyReport(
+        try Task.checkCancellation()
+        // The corpus scans below are synchronous and can run for minutes on large session
+        // archives. They execute on the dedicated scan queue so they never occupy a cooperative
+        // pool thread; CostUsageScanExecutor bridges this task's cancellation into the
+        // scanner-level checks.
+        let scanOptions = options
+        let daily = try await CostUsageScanExecutor.run { checkCancellation in
+            var daily = try CostUsageScanner.loadDailyReportCancellable(
                 provider: provider,
                 since: since,
                 until: until,
                 now: now,
-                options: fallback)
+                options: scanOptions,
+                checkCancellation: checkCancellation)
+            try checkCancellation()
+
+            if provider == .vertexai,
+               !allowVertexClaudeFallback,
+               scanOptions.claudeLogProviderFilter == .vertexAIOnly,
+               daily.data.isEmpty
+            {
+                var fallback = scanOptions
+                fallback.claudeLogProviderFilter = .all
+                daily = try CostUsageScanner.loadDailyReportCancellable(
+                    provider: provider,
+                    since: since,
+                    until: until,
+                    now: now,
+                    options: fallback,
+                    checkCancellation: checkCancellation)
+                try checkCancellation()
+            }
+
+            if provider == .codex || provider == .claude {
+                let piReport = try PiSessionCostScanner.loadDailyReportCancellable(
+                    provider: provider,
+                    since: since,
+                    until: until,
+                    now: now,
+                    options: piOptions,
+                    checkCancellation: checkCancellation)
+                try checkCancellation()
+                daily = CostUsageDailyReport.merged([daily, piReport])
+            }
+            return daily
         }
 
-        return Self.tokenSnapshot(from: daily, now: now)
+        return Self.tokenSnapshot(from: daily, now: now, historyDays: clampedHistoryDays)
     }
 
-    static func tokenSnapshot(from daily: CostUsageDailyReport, now: Date) -> CostUsageTokenSnapshot {
+    static func loadCachedCodexTokenSnapshot(
+        now: Date = Date(),
+        codexHomePath: String? = nil,
+        historyDays: Int = 30,
+        scannerOptions overrideScannerOptions: CostUsageScanner.Options? = nil) async -> CostUsageTokenSnapshot?
+    {
+        if let codexHomePath = codexHomePath?.trimmingCharacters(in: .whitespacesAndNewlines),
+           !codexHomePath.isEmpty
+        {
+            return nil
+        }
+
+        // Decoding the persisted scan cache parses multi-megabyte JSON; keep it off the
+        // cooperative pool alongside the scans themselves.
+        let cachedSnapshot: CostUsageTokenSnapshot?? = try? await CostUsageScanExecutor.run { _ in
+            let clampedHistoryDays = max(1, min(365, historyDays))
+            let until = now
+            let since = Calendar.current.date(byAdding: .day, value: -(clampedHistoryDays - 1), to: now) ?? now
+            let range = CostUsageScanner.CostUsageDayRange(since: since, until: until)
+            let options = overrideScannerOptions ?? CostUsageScanner.Options()
+            let cache = CostUsageCacheIO.load(provider: .codex, cacheRoot: options.cacheRoot)
+            var reports: [CostUsageDailyReport] = []
+
+            if !cache.days.isEmpty,
+               cache.roots == CostUsageScanner.codexRootsFingerprint(options: options),
+               !CostUsageScanner.requestedWindowExpandsCache(range: range, cache: cache)
+            {
+                let daily = CostUsageScanner.buildCodexReportFromCache(
+                    cache: cache,
+                    range: range,
+                    modelsDevCacheRoot: options.cacheRoot)
+                if !daily.data.isEmpty {
+                    reports.append(daily)
+                }
+            }
+
+            if let piDaily = PiSessionCostScanner.loadCachedDailyReport(
+                provider: .codex,
+                since: since,
+                until: until,
+                now: now,
+                cacheRoot: options.cacheRoot)
+            {
+                reports.append(piDaily)
+            }
+
+            guard !reports.isEmpty else { return nil }
+            return Self.tokenSnapshot(
+                from: CostUsageDailyReport.merged(reports),
+                now: now,
+                historyDays: clampedHistoryDays)
+        }
+        return cachedSnapshot.flatMap(\.self)
+    }
+
+    private static func loadBedrockDailyReport(
+        environment: [String: String],
+        since: Date,
+        until: Date) async throws -> CostUsageDailyReport
+    {
+        let resolved = try await BedrockCredentialResolver.resolve(environment: environment)
+        return try await BedrockUsageFetcher.fetchDailyReport(
+            credentials: resolved.credentials,
+            since: since,
+            until: until,
+            environment: environment)
+    }
+
+    static func tokenSnapshot(
+        from daily: CostUsageDailyReport,
+        now: Date,
+        historyDays: Int = 30) -> CostUsageTokenSnapshot
+    {
         // Pick the most recent day; break ties by cost/tokens to keep a stable "session" row.
-        let currentDay = daily.data.max { lhs, rhs in
-            let lDate = CostUsageDateParser.parse(lhs.date) ?? .distantPast
-            let rDate = CostUsageDateParser.parse(rhs.date) ?? .distantPast
-            if lDate != rDate { return lDate < rDate }
-            let lCost = lhs.costUSD ?? -1
-            let rCost = rhs.costUSD ?? -1
+        let currentDay = daily.data.compactMap { entry -> (entry: CostUsageDailyReport.Entry, date: Date)? in
+            guard let date = CostUsageDateParser.parse(entry.date) else { return nil }
+            return (entry, date)
+        }
+        .max { lhs, rhs in
+            if lhs.date != rhs.date { return lhs.date < rhs.date }
+            let lCost = lhs.entry.costUSD ?? -1
+            let rCost = rhs.entry.costUSD ?? -1
             if lCost != rCost { return lCost < rCost }
-            let lTokens = lhs.totalTokens ?? -1
-            let rTokens = rhs.totalTokens ?? -1
+            let lTokens = lhs.entry.totalTokens ?? -1
+            let rTokens = rhs.entry.totalTokens ?? -1
             if lTokens != rTokens { return lTokens < rTokens }
-            return lhs.date < rhs.date
-        }
+            return lhs.entry.date < rhs.entry.date
+        }?.entry
         // Prefer summary totals when present; fall back to summing daily entries.
         let totalFromSummary = daily.summary?.totalCostUSD
         let totalFromEntries = daily.data.compactMap(\.costUSD).reduce(0, +)
@@ -96,6 +306,7 @@ public struct CostUsageFetcher: Sendable {
             sessionCostUSD: currentDay?.costUSD,
             last30DaysTokens: last30DaysTokens,
             last30DaysCostUSD: last30DaysCostUSD,
+            historyDays: historyDays,
             daily: daily.data,
             updatedAt: now)
     }
diff --git a/Sources/CodexBarCore/CostUsageModels.swift b/Sources/CodexBarCore/CostUsageModels.swift
index 60f5e75981..30dcbb7012 100644
--- a/Sources/CodexBarCore/CostUsageModels.swift
+++ b/Sources/CodexBarCore/CostUsageModels.swift
@@ -3,23 +3,40 @@ import Foundation
 public struct CostUsageTokenSnapshot: Sendable, Equatable {
     public let sessionTokens: Int?
     public let sessionCostUSD: Double?
+    public let sessionRequests: Int?
     public let last30DaysTokens: Int?
     public let last30DaysCostUSD: Double?
+    public let last30DaysRequests: Int?
+    public let currencyCode: String
+    public let historyDays: Int
+    public let historyLabel: String?
     public let daily: [CostUsageDailyReport.Entry]
     public let updatedAt: Date
 
     public init(
         sessionTokens: Int?,
         sessionCostUSD: Double?,
+        sessionRequests: Int? = nil,
         last30DaysTokens: Int?,
         last30DaysCostUSD: Double?,
+        last30DaysRequests: Int? = nil,
+        currencyCode: String = "USD",
+        historyDays: Int = 30,
+        historyLabel: String? = nil,
         daily: [CostUsageDailyReport.Entry],
         updatedAt: Date)
     {
         self.sessionTokens = sessionTokens
         self.sessionCostUSD = sessionCostUSD
+        self.sessionRequests = sessionRequests
         self.last30DaysTokens = last30DaysTokens
         self.last30DaysCostUSD = last30DaysCostUSD
+        self.last30DaysRequests = last30DaysRequests
+        self.currencyCode = currencyCode.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+            ? "USD"
+            : currencyCode.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()
+        self.historyDays = historyDays
+        self.historyLabel = historyLabel
         self.daily = daily
         self.updatedAt = updatedAt
     }
@@ -29,11 +46,24 @@ public struct CostUsageDailyReport: Sendable, Decodable {
     public struct ModelBreakdown: Sendable, Decodable, Equatable {
         public let modelName: String
         public let costUSD: Double?
+        public let totalTokens: Int?
+        public let requestCount: Int?
+        public let standardCostUSD: Double?
+        public let priorityCostUSD: Double?
+        public let standardTokens: Int?
+        public let priorityTokens: Int?
 
         private enum CodingKeys: String, CodingKey {
             case modelName
             case costUSD
             case cost
+            case totalTokens
+            case requestCount
+            case requests
+            case standardCostUSD
+            case priorityCostUSD
+            case standardTokens
+            case priorityTokens
         }
 
         public init(from decoder: Decoder) throws {
@@ -42,11 +72,34 @@ public struct CostUsageDailyReport: Sendable, Decodable {
             self.costUSD =
                 try container.decodeIfPresent(Double.self, forKey: .costUSD)
                 ?? container.decodeIfPresent(Double.self, forKey: .cost)
+            self.totalTokens = try container.decodeIfPresent(Int.self, forKey: .totalTokens)
+            self.requestCount =
+                try container.decodeIfPresent(Int.self, forKey: .requestCount)
+                ?? container.decodeIfPresent(Int.self, forKey: .requests)
+            self.standardCostUSD = try container.decodeIfPresent(Double.self, forKey: .standardCostUSD)
+            self.priorityCostUSD = try container.decodeIfPresent(Double.self, forKey: .priorityCostUSD)
+            self.standardTokens = try container.decodeIfPresent(Int.self, forKey: .standardTokens)
+            self.priorityTokens = try container.decodeIfPresent(Int.self, forKey: .priorityTokens)
         }
 
-        public init(modelName: String, costUSD: Double?) {
+        public init(
+            modelName: String,
+            costUSD: Double?,
+            totalTokens: Int? = nil,
+            requestCount: Int? = nil,
+            standardCostUSD: Double? = nil,
+            priorityCostUSD: Double? = nil,
+            standardTokens: Int? = nil,
+            priorityTokens: Int? = nil)
+        {
             self.modelName = modelName
             self.costUSD = costUSD
+            self.totalTokens = totalTokens
+            self.requestCount = requestCount
+            self.standardCostUSD = standardCostUSD
+            self.priorityCostUSD = priorityCostUSD
+            self.standardTokens = standardTokens
+            self.priorityTokens = priorityTokens
         }
     }
 
@@ -57,6 +110,7 @@ public struct CostUsageDailyReport: Sendable, Decodable {
         public let cacheCreationTokens: Int?
         public let outputTokens: Int?
         public let totalTokens: Int?
+        public let requestCount: Int?
         public let costUSD: Double?
         public let modelsUsed: [String]?
         public let modelBreakdowns: [ModelBreakdown]?
@@ -70,6 +124,8 @@ public struct CostUsageDailyReport: Sendable, Decodable {
             case cacheCreationInputTokens
             case outputTokens
             case totalTokens
+            case requestCount
+            case requests
             case costUSD
             case totalCost
             case modelsUsed
@@ -89,6 +145,9 @@ public struct CostUsageDailyReport: Sendable, Decodable {
                 ?? container.decodeIfPresent(Int.self, forKey: .cacheCreationInputTokens)
             self.outputTokens = try container.decodeIfPresent(Int.self, forKey: .outputTokens)
             self.totalTokens = try container.decodeIfPresent(Int.self, forKey: .totalTokens)
+            self.requestCount =
+                try container.decodeIfPresent(Int.self, forKey: .requestCount)
+                ?? container.decodeIfPresent(Int.self, forKey: .requests)
             self.costUSD =
                 try container.decodeIfPresent(Double.self, forKey: .costUSD)
                 ?? container.decodeIfPresent(Double.self, forKey: .totalCost)
@@ -103,6 +162,7 @@ public struct CostUsageDailyReport: Sendable, Decodable {
             cacheReadTokens: Int? = nil,
             cacheCreationTokens: Int? = nil,
             totalTokens: Int?,
+            requestCount: Int? = nil,
             costUSD: Double?,
             modelsUsed: [String]?,
             modelBreakdowns: [ModelBreakdown]?)
@@ -113,6 +173,7 @@ public struct CostUsageDailyReport: Sendable, Decodable {
             self.cacheReadTokens = cacheReadTokens
             self.cacheCreationTokens = cacheCreationTokens
             self.totalTokens = totalTokens
+            self.requestCount = requestCount
             self.costUSD = costUSD
             self.modelsUsed = modelsUsed
             self.modelBreakdowns = modelBreakdowns
@@ -231,6 +292,252 @@ public struct CostUsageDailyReport: Sendable, Decodable {
     }
 }
 
+extension CostUsageDailyReport {
+    private struct BreakdownAccumulator {
+        var totalTokens: Int = 0
+        var sawTotalTokens = false
+        var costUSD: Double = 0
+        var sawCost = false
+        var standardCostUSD: Double = 0
+        var sawStandardCost = false
+        var priorityCostUSD: Double = 0
+        var sawPriorityCost = false
+        var standardTokens: Int = 0
+        var sawStandardTokens = false
+        var priorityTokens: Int = 0
+        var sawPriorityTokens = false
+
+        mutating func add(_ breakdown: ModelBreakdown) {
+            if let totalTokens = breakdown.totalTokens {
+                self.totalTokens += totalTokens
+                self.sawTotalTokens = true
+            }
+            if let costUSD = breakdown.costUSD {
+                self.costUSD += costUSD
+                self.sawCost = true
+            }
+            if let standardCostUSD = breakdown.standardCostUSD {
+                self.standardCostUSD += standardCostUSD
+                self.sawStandardCost = true
+            }
+            if let priorityCostUSD = breakdown.priorityCostUSD {
+                self.priorityCostUSD += priorityCostUSD
+                self.sawPriorityCost = true
+            }
+            if let standardTokens = breakdown.standardTokens {
+                self.standardTokens += standardTokens
+                self.sawStandardTokens = true
+            }
+            if let priorityTokens = breakdown.priorityTokens {
+                self.priorityTokens += priorityTokens
+                self.sawPriorityTokens = true
+            }
+        }
+
+        func build(modelName: String) -> ModelBreakdown {
+            ModelBreakdown(
+                modelName: modelName,
+                costUSD: self.sawCost ? self.costUSD : nil,
+                totalTokens: self.sawTotalTokens ? self.totalTokens : nil,
+                standardCostUSD: self.sawStandardCost ? self.standardCostUSD : nil,
+                priorityCostUSD: self.sawPriorityCost ? self.priorityCostUSD : nil,
+                standardTokens: self.sawStandardTokens ? self.standardTokens : nil,
+                priorityTokens: self.sawPriorityTokens ? self.priorityTokens : nil)
+        }
+    }
+
+    private struct EntryAccumulator {
+        var inputTokens: Int = 0
+        var sawInputTokens = false
+        var cacheReadTokens: Int = 0
+        var sawCacheReadTokens = false
+        var cacheCreationTokens: Int = 0
+        var sawCacheCreationTokens = false
+        var outputTokens: Int = 0
+        var sawOutputTokens = false
+        var totalTokens: Int = 0
+        var sawTotalTokens = false
+        var derivedTotalTokensWithoutExplicitTotal: Int = 0
+        var costUSD: Double = 0
+        var sawCost = false
+        var modelsUsed: Set<String> = []
+        var breakdowns: [String: BreakdownAccumulator] = [:]
+
+        mutating func add(_ entry: Entry) {
+            let entryDerivedTotalTokens = (entry.inputTokens ?? 0)
+                + (entry.cacheReadTokens ?? 0)
+                + (entry.cacheCreationTokens ?? 0)
+                + (entry.outputTokens ?? 0)
+            if let inputTokens = entry.inputTokens {
+                self.inputTokens += inputTokens
+                self.sawInputTokens = true
+            }
+            if let cacheReadTokens = entry.cacheReadTokens {
+                self.cacheReadTokens += cacheReadTokens
+                self.sawCacheReadTokens = true
+            }
+            if let cacheCreationTokens = entry.cacheCreationTokens {
+                self.cacheCreationTokens += cacheCreationTokens
+                self.sawCacheCreationTokens = true
+            }
+            if let outputTokens = entry.outputTokens {
+                self.outputTokens += outputTokens
+                self.sawOutputTokens = true
+            }
+            if let totalTokens = entry.totalTokens {
+                self.totalTokens += totalTokens
+                self.sawTotalTokens = true
+            } else if entryDerivedTotalTokens > 0 {
+                self.derivedTotalTokensWithoutExplicitTotal += entryDerivedTotalTokens
+            }
+            if let costUSD = entry.costUSD {
+                self.costUSD += costUSD
+                self.sawCost = true
+            }
+            if let modelsUsed = entry.modelsUsed {
+                self.modelsUsed.formUnion(modelsUsed)
+            }
+            if let modelBreakdowns = entry.modelBreakdowns {
+                for breakdown in modelBreakdowns {
+                    var accumulator = self.breakdowns[breakdown.modelName] ?? BreakdownAccumulator()
+                    accumulator.add(breakdown)
+                    self.breakdowns[breakdown.modelName] = accumulator
+                    self.modelsUsed.insert(breakdown.modelName)
+                }
+            }
+        }
+
+        func build(date: String) -> Entry {
+            let derivedTotalTokens = self.inputTokens
+                + self.cacheReadTokens
+                + self.cacheCreationTokens
+                + self.outputTokens
+            let totalTokens: Int? = if self.sawTotalTokens {
+                self.totalTokens + self.derivedTotalTokensWithoutExplicitTotal
+            } else if derivedTotalTokens > 0 {
+                derivedTotalTokens
+            } else {
+                nil
+            }
+            let modelBreakdowns: [ModelBreakdown]? = {
+                guard !self.breakdowns.isEmpty else { return nil }
+                return CostUsageDailyReport.sortedModelBreakdowns(
+                    self.breakdowns
+                        .map { modelName, accumulator in
+                            accumulator.build(modelName: modelName)
+                        })
+            }()
+            let modelsUsed = self.modelsUsed.isEmpty ? nil : self.modelsUsed.sorted()
+            return Entry(
+                date: date,
+                inputTokens: self.sawInputTokens ? self.inputTokens : nil,
+                outputTokens: self.sawOutputTokens ? self.outputTokens : nil,
+                cacheReadTokens: self.sawCacheReadTokens ? self.cacheReadTokens : nil,
+                cacheCreationTokens: self.sawCacheCreationTokens ? self.cacheCreationTokens : nil,
+                totalTokens: totalTokens,
+                costUSD: self.sawCost ? self.costUSD : nil,
+                modelsUsed: modelsUsed,
+                modelBreakdowns: modelBreakdowns)
+        }
+    }
+
+    public func merged(with other: CostUsageDailyReport) -> CostUsageDailyReport {
+        Self.merged([self, other])
+    }
+
+    public static func merged(_ reports: [CostUsageDailyReport]) -> CostUsageDailyReport {
+        let entries = self.mergedEntries(from: reports)
+        guard !entries.isEmpty else { return CostUsageDailyReport(data: [], summary: nil) }
+        return CostUsageDailyReport(data: entries, summary: self.mergedSummary(from: entries))
+    }
+
+    private static func mergedEntries(from reports: [CostUsageDailyReport]) -> [Entry] {
+        var dayAccumulators: [String: EntryAccumulator] = [:]
+        for report in reports {
+            for entry in report.data {
+                var accumulator = dayAccumulators[entry.date] ?? EntryAccumulator()
+                accumulator.add(entry)
+                dayAccumulators[entry.date] = accumulator
+            }
+        }
+
+        return dayAccumulators
+            .keys
+            .sorted()
+            .map { date in
+                dayAccumulators[date, default: EntryAccumulator()].build(date: date)
+            }
+    }
+
+    private static func mergedSummary(from entries: [Entry]) -> Summary {
+        var totalInputTokens = 0
+        var sawTotalInputTokens = false
+        var totalOutputTokens = 0
+        var sawTotalOutputTokens = false
+        var totalCacheReadTokens = 0
+        var sawTotalCacheReadTokens = false
+        var totalCacheCreationTokens = 0
+        var sawTotalCacheCreationTokens = false
+        var totalTokens = 0
+        var sawTotalTokens = false
+        var totalCostUSD = 0.0
+        var sawTotalCostUSD = false
+
+        for entry in entries {
+            if let inputTokens = entry.inputTokens {
+                totalInputTokens += inputTokens
+                sawTotalInputTokens = true
+            }
+            if let outputTokens = entry.outputTokens {
+                totalOutputTokens += outputTokens
+                sawTotalOutputTokens = true
+            }
+            if let cacheReadTokens = entry.cacheReadTokens {
+                totalCacheReadTokens += cacheReadTokens
+                sawTotalCacheReadTokens = true
+            }
+            if let cacheCreationTokens = entry.cacheCreationTokens {
+                totalCacheCreationTokens += cacheCreationTokens
+                sawTotalCacheCreationTokens = true
+            }
+            if let entryTotalTokens = entry.totalTokens {
+                totalTokens += entryTotalTokens
+                sawTotalTokens = true
+            }
+            if let costUSD = entry.costUSD {
+                totalCostUSD += costUSD
+                sawTotalCostUSD = true
+            }
+        }
+
+        return Summary(
+            totalInputTokens: sawTotalInputTokens ? totalInputTokens : nil,
+            totalOutputTokens: sawTotalOutputTokens ? totalOutputTokens : nil,
+            cacheReadTokens: sawTotalCacheReadTokens ? totalCacheReadTokens : nil,
+            cacheCreationTokens: sawTotalCacheCreationTokens ? totalCacheCreationTokens : nil,
+            totalTokens: sawTotalTokens ? totalTokens : nil,
+            totalCostUSD: sawTotalCostUSD ? totalCostUSD : nil)
+    }
+
+    private static func sortedModelBreakdowns(_ breakdowns: [ModelBreakdown]) -> [ModelBreakdown] {
+        breakdowns.sorted { lhs, rhs in
+            let lhsCost = lhs.costUSD ?? -1
+            let rhsCost = rhs.costUSD ?? -1
+            if lhsCost != rhsCost {
+                return lhsCost > rhsCost
+            }
+
+            let lhsTokens = lhs.totalTokens ?? -1
+            let rhsTokens = rhs.totalTokens ?? -1
+            if lhsTokens != rhsTokens {
+                return lhsTokens > rhsTokens
+            }
+
+            return lhs.modelName > rhs.modelName
+        }
+    }
+}
+
 public struct CostUsageSessionReport: Sendable, Decodable {
     public struct Entry: Sendable, Decodable, Equatable {
         public let session: String
@@ -377,7 +684,7 @@ public struct CostUsageMonthlyReport: Sendable, Decodable {
     }
 }
 
-private struct CostUsageLegacyTotals: Sendable, Decodable {
+private struct CostUsageLegacyTotals: Decodable {
     let totalInputTokens: Int?
     let totalOutputTokens: Int?
     let cacheReadTokens: Int?
@@ -427,27 +734,32 @@ private struct CostUsageAnyCodingKey: CodingKey {
 }
 
 enum CostUsageDateParser {
+    private static let isoWithFractionalSecondsKey = "CostUsageDateParser.isoWithFractionalSeconds"
+    private static let isoInternetDateTimeKey = "CostUsageDateParser.isoInternetDateTime"
+    private static let dayFormatterKey = "CostUsageDateParser.dayFormatter"
+    private static let monthDayYearFormatterKey = "CostUsageDateParser.monthDayYearFormatter"
+    private static let monthYearFormatterKey = "CostUsageDateParser.monthYearFormatter"
+    private static let fullMonthYearFormatterKey = "CostUsageDateParser.fullMonthYearFormatter"
+    private static let yearMonthFormatterKey = "CostUsageDateParser.yearMonthFormatter"
+
     static func parse(_ text: String?) -> Date? {
         guard let text, !text.isEmpty else { return nil }
         let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
 
-        let iso = ISO8601DateFormatter()
-        iso.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
-        if let d = iso.date(from: trimmed) { return d }
-        iso.formatOptions = [.withInternetDateTime]
-        if let d = iso.date(from: trimmed) { return d }
-
-        let day = DateFormatter()
-        day.locale = Locale(identifier: "en_US_POSIX")
-        day.timeZone = TimeZone.current
-        day.dateFormat = "yyyy-MM-dd"
-        if let d = day.date(from: trimmed) { return d }
-
-        let monthDayYear = DateFormatter()
-        monthDayYear.locale = Locale(identifier: "en_US_POSIX")
-        monthDayYear.timeZone = TimeZone.current
-        monthDayYear.dateFormat = "MMM d, yyyy"
-        if let d = monthDayYear.date(from: trimmed) { return d }
+        if let d = self.isoFormatter(
+            key: self.isoWithFractionalSecondsKey,
+            options: [.withInternetDateTime, .withFractionalSeconds])
+            .date(from: trimmed)
+        { return d }
+        if let d = self.isoFormatter(key: self.isoInternetDateTimeKey, options: [.withInternetDateTime])
+            .date(from: trimmed)
+        { return d }
+        if let d = self.dateFormatter(key: self.dayFormatterKey, format: "yyyy-MM-dd").date(from: trimmed) {
+            return d
+        }
+        if let d = self.dateFormatter(key: self.monthDayYearFormatterKey, format: "MMM d, yyyy")
+            .date(from: trimmed)
+        { return d }
 
         return nil
     }
@@ -456,24 +768,45 @@ enum CostUsageDateParser {
         guard let text, !text.isEmpty else { return nil }
         let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
 
-        let monthYear = DateFormatter()
-        monthYear.locale = Locale(identifier: "en_US_POSIX")
-        monthYear.timeZone = TimeZone.current
-        monthYear.dateFormat = "MMM yyyy"
-        if let d = monthYear.date(from: trimmed) { return d }
+        if let d = self.dateFormatter(key: self.monthYearFormatterKey, format: "MMM yyyy").date(from: trimmed) {
+            return d
+        }
+        if let d = self.dateFormatter(key: self.fullMonthYearFormatterKey, format: "MMMM yyyy").date(from: trimmed) {
+            return d
+        }
+        if let d = self.dateFormatter(key: self.yearMonthFormatterKey, format: "yyyy-MM").date(from: trimmed) {
+            return d
+        }
 
-        let fullMonthYear = DateFormatter()
-        fullMonthYear.locale = Locale(identifier: "en_US_POSIX")
-        fullMonthYear.timeZone = TimeZone.current
-        fullMonthYear.dateFormat = "MMMM yyyy"
-        if let d = fullMonthYear.date(from: trimmed) { return d }
+        return nil
+    }
 
-        let ym = DateFormatter()
-        ym.locale = Locale(identifier: "en_US_POSIX")
-        ym.timeZone = TimeZone.current
-        ym.dateFormat = "yyyy-MM"
-        if let d = ym.date(from: trimmed) { return d }
+    private static func isoFormatter(
+        key: String,
+        options: ISO8601DateFormatter.Options) -> ISO8601DateFormatter
+    {
+        let threadDict = Thread.current.threadDictionary
+        if let cached = threadDict[key] as? ISO8601DateFormatter {
+            return cached
+        }
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = options
+        threadDict[key] = formatter
+        return formatter
+    }
 
-        return nil
+    private static func dateFormatter(key: String, format: String) -> DateFormatter {
+        let threadDict = Thread.current.threadDictionary
+        let timeZone = TimeZone.current
+        let cacheKey = "\(key).\(timeZone.identifier)"
+        if let cached = threadDict[cacheKey] as? DateFormatter {
+            return cached
+        }
+        let formatter = DateFormatter()
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        formatter.timeZone = timeZone
+        formatter.dateFormat = format
+        threadDict[cacheKey] = formatter
+        return formatter
     }
 }
diff --git a/Sources/CodexBarCore/CostUsageScanExecutor.swift b/Sources/CodexBarCore/CostUsageScanExecutor.swift
new file mode 100644
index 0000000000..aef8b2b78d
--- /dev/null
+++ b/Sources/CodexBarCore/CostUsageScanExecutor.swift
@@ -0,0 +1,130 @@
+import Foundation
+
+/// Cost-usage scans read and parse the full local session corpus synchronously and can run for
+/// minutes on large archives. Executing that work inline on Swift's cooperative thread pool
+/// starves every other async task in the process — menus freeze while the main thread sits idle —
+/// and overlapping provider scans multiply both the pool pressure and the disk load. This
+/// executor pins all corpus scans to a single serial utility queue off the cooperative pool, so
+/// long scans cost one dedicated thread instead of the app's async runtime.
+public enum CostUsageScanExecutor {
+    public static let queueLabel = "com.steipete.codexbar.cost-usage-scan"
+
+    private static let queue = DispatchQueue(label: queueLabel, qos: .utility)
+
+    private final class RunState<Value: Sendable>: @unchecked Sendable {
+        private enum Phase {
+            case initial
+            case queued
+            case running
+            case completed
+        }
+
+        private let lock = NSLock()
+        private var phase: Phase = .initial
+        private var cancellationRequested = false
+        private var continuation: CheckedContinuation<Value, Error>?
+
+        func install(_ continuation: CheckedContinuation<Value, Error>) -> Bool {
+            let shouldEnqueue: Bool
+            let shouldResumeCancellation: Bool
+            self.lock.lock()
+            if self.cancellationRequested {
+                self.phase = .completed
+                shouldEnqueue = false
+                shouldResumeCancellation = true
+            } else {
+                self.phase = .queued
+                self.continuation = continuation
+                shouldEnqueue = true
+                shouldResumeCancellation = false
+            }
+            self.lock.unlock()
+
+            if shouldResumeCancellation {
+                continuation.resume(throwing: CancellationError())
+            }
+            return shouldEnqueue
+        }
+
+        func begin() -> Bool {
+            self.lock.lock()
+            defer { self.lock.unlock() }
+            guard self.phase == .queued else { return false }
+            self.phase = .running
+            return true
+        }
+
+        func cancel() {
+            let continuation: CheckedContinuation<Value, Error>?
+            self.lock.lock()
+            self.cancellationRequested = true
+            if self.phase == .queued {
+                self.phase = .completed
+                continuation = self.continuation
+                self.continuation = nil
+            } else {
+                continuation = nil
+            }
+            self.lock.unlock()
+            continuation?.resume(throwing: CancellationError())
+        }
+
+        func checkCancellation() throws {
+            self.lock.lock()
+            let cancellationRequested = self.cancellationRequested
+            self.lock.unlock()
+            if cancellationRequested {
+                throw CancellationError()
+            }
+        }
+
+        func complete(with result: Result<Value, Error>) {
+            let continuation: CheckedContinuation<Value, Error>?
+            let resolvedResult: Result<Value, Error>
+            self.lock.lock()
+            guard self.phase == .running else {
+                self.lock.unlock()
+                return
+            }
+            self.phase = .completed
+            continuation = self.continuation
+            self.continuation = nil
+            resolvedResult = self.cancellationRequested ? .failure(CancellationError()) : result
+            self.lock.unlock()
+            continuation?.resume(with: resolvedResult)
+        }
+    }
+
+    /// Runs `work` on the serial scan queue and bridges Swift task cancellation into the
+    /// scanner's cooperative `checkCancellation` callbacks. Work that is still queued when the
+    /// awaiting task is cancelled resumes immediately with `CancellationError` instead of
+    /// waiting behind an in-flight scan.
+    public static func run<T: Sendable>(
+        _ work: @escaping @Sendable (_ checkCancellation: @escaping @Sendable () throws -> Void) throws -> T)
+        async throws -> T
+    {
+        try await self.run(on: self.queue, work)
+    }
+
+    static func run<T: Sendable>(
+        on queue: DispatchQueue,
+        _ work: @escaping @Sendable (_ checkCancellation: @escaping @Sendable () throws -> Void) throws -> T)
+        async throws -> T
+    {
+        let state = RunState<T>()
+        let checkCancellation: @Sendable () throws -> Void = {
+            try state.checkCancellation()
+        }
+        return try await withTaskCancellationHandler {
+            try await withCheckedThrowingContinuation { continuation in
+                guard state.install(continuation) else { return }
+                queue.async {
+                    guard state.begin() else { return }
+                    state.complete(with: Result { try work(checkCancellation) })
+                }
+            }
+        } onCancel: {
+            state.cancel()
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/CreditsModels.swift b/Sources/CodexBarCore/CreditsModels.swift
index 69d04425fe..7db2cef820 100644
--- a/Sources/CodexBarCore/CreditsModels.swift
+++ b/Sources/CodexBarCore/CreditsModels.swift
@@ -48,3 +48,118 @@ public struct CreditsSnapshot: Equatable, Codable, Sendable {
         self.updatedAt = updatedAt
     }
 }
+
+public struct CodexRateLimitResetCreditsSnapshot: Equatable, Codable, Sendable {
+    public let credits: [CodexRateLimitResetCredit]
+    public let availableCount: Int
+    public let updatedAt: Date
+
+    public init(credits: [CodexRateLimitResetCredit], availableCount: Int, updatedAt: Date) {
+        self.credits = credits
+        self.availableCount = availableCount
+        self.updatedAt = updatedAt
+    }
+
+    public var nextExpiringAvailableCredit: CodexRateLimitResetCredit? {
+        self.credits
+            .filter { credit in
+                credit.status == .available && (credit.expiresAt ?? .distantPast) > self.updatedAt
+            }
+            .min { lhs, rhs in
+                guard let lhsExpiresAt = lhs.expiresAt else { return false }
+                guard let rhsExpiresAt = rhs.expiresAt else { return true }
+                return lhsExpiresAt < rhsExpiresAt
+            }
+    }
+}
+
+public struct CodexRateLimitResetCredit: Equatable, Codable, Sendable, Identifiable {
+    public let id: String
+    public let resetType: String
+    public let status: CodexRateLimitResetCreditStatus
+    public let grantedAt: Date
+    public let expiresAt: Date?
+    public let redeemStartedAt: Date?
+    public let redeemedAt: Date?
+    public let title: String?
+    public let description: String?
+
+    private enum CodingKeys: String, CodingKey {
+        case id
+        case resetType = "reset_type"
+        case status
+        case grantedAt = "granted_at"
+        case expiresAt = "expires_at"
+        case redeemStartedAt = "redeem_started_at"
+        case redeemedAt = "redeemed_at"
+        case title
+        case description
+    }
+
+    public init(
+        id: String,
+        resetType: String,
+        status: CodexRateLimitResetCreditStatus,
+        grantedAt: Date,
+        expiresAt: Date?,
+        redeemStartedAt: Date?,
+        redeemedAt: Date?,
+        title: String?,
+        description: String?)
+    {
+        self.id = id
+        self.resetType = resetType
+        self.status = status
+        self.grantedAt = grantedAt
+        self.expiresAt = expiresAt
+        self.redeemStartedAt = redeemStartedAt
+        self.redeemedAt = redeemedAt
+        self.title = title
+        self.description = description
+    }
+}
+
+public enum CodexRateLimitResetCreditStatus: Equatable, Codable, Sendable {
+    case available
+    case redeeming
+    case redeemed
+    case expired
+    case unknown(String)
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        let value = try container.decode(String.self)
+        switch value {
+        case "available":
+            self = .available
+        case "redeeming":
+            self = .redeeming
+        case "redeemed":
+            self = .redeemed
+        case "expired":
+            self = .expired
+        default:
+            self = .unknown(value)
+        }
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+        try container.encode(self.rawValue)
+    }
+
+    public var rawValue: String {
+        switch self {
+        case .available:
+            "available"
+        case .redeeming:
+            "redeeming"
+        case .redeemed:
+            "redeemed"
+        case .expired:
+            "expired"
+        case let .unknown(value):
+            value
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Generated/CodexParserHash.generated.swift b/Sources/CodexBarCore/Generated/CodexParserHash.generated.swift
new file mode 100644
index 0000000000..4b866f2df3
--- /dev/null
+++ b/Sources/CodexBarCore/Generated/CodexParserHash.generated.swift
@@ -0,0 +1,5 @@
+// Generated by Scripts/regenerate-codex-parser-hash.sh. Do not edit by hand.
+
+enum CodexParserHash {
+    static let value = "800a06dead603ea7"
+}
diff --git a/Sources/CodexBarCore/Host/PTY/TTYCommandRunner.swift b/Sources/CodexBarCore/Host/PTY/TTYCommandRunner.swift
index 7208cfb135..00bd5a4f3e 100644
--- a/Sources/CodexBarCore/Host/PTY/TTYCommandRunner.swift
+++ b/Sources/CodexBarCore/Host/PTY/TTYCommandRunner.swift
@@ -1,14 +1,17 @@
 #if canImport(Darwin)
 import Darwin
-#else
+#elseif canImport(Glibc)
 import Glibc
+#elseif canImport(Musl)
+import Musl
 #endif
 import Foundation
 
 private enum TTYCommandRunnerActiveProcessRegistry {
-    private static let lock = NSLock()
+    private static let condition = NSCondition()
     private nonisolated(unsafe) static var processes: [pid_t: ProcessInfo] = [:]
     private nonisolated(unsafe) static var isShuttingDown = false
+    private nonisolated(unsafe) static var launchesInProgress = 0
 
     private struct ProcessInfo {
         let binary: String
@@ -18,62 +21,188 @@ private enum TTYCommandRunnerActiveProcessRegistry {
     @discardableResult
     static func register(pid: pid_t, binary: String) -> Bool {
         guard pid > 0 else { return false }
-        self.lock.lock()
-        defer { self.lock.unlock() }
+        self.condition.lock()
+        defer { self.condition.unlock() }
         guard !self.isShuttingDown else { return false }
         self.processes[pid] = ProcessInfo(binary: binary, processGroup: nil)
         return true
     }
 
+    static func beginLaunch() -> Bool {
+        self.condition.lock()
+        defer { self.condition.unlock() }
+        guard !self.isShuttingDown else { return false }
+        self.launchesInProgress += 1
+        return true
+    }
+
+    static func endLaunch() {
+        self.condition.lock()
+        self.launchesInProgress = max(0, self.launchesInProgress - 1)
+        if self.launchesInProgress == 0 {
+            self.condition.broadcast()
+        }
+        self.condition.unlock()
+    }
+
     static func updateProcessGroup(pid: pid_t, processGroup: pid_t?) {
         guard pid > 0 else { return }
-        self.lock.lock()
+        self.condition.lock()
         guard var existing = self.processes[pid] else {
-            self.lock.unlock()
+            self.condition.unlock()
             return
         }
         existing.processGroup = processGroup
         self.processes[pid] = existing
-        self.lock.unlock()
+        self.condition.unlock()
     }
 
     static func unregister(pid: pid_t) {
         guard pid > 0 else { return }
-        self.lock.lock()
+        self.condition.lock()
         self.processes.removeValue(forKey: pid)
-        self.lock.unlock()
+        self.condition.unlock()
     }
 
-    static func drainForShutdown() -> [(pid: pid_t, binary: String, processGroup: pid_t?)] {
-        self.lock.lock()
+    static func drainForShutdown(
+        onFenceSet: (() -> Void)? = nil)
+        -> [(pid: pid_t, binary: String, processGroup: pid_t?)]
+    {
+        self.condition.lock()
         self.isShuttingDown = true
+        onFenceSet?()
+        while self.launchesInProgress > 0 {
+            self.condition.wait()
+        }
         let drained = self.processes.map {
             (pid: $0.key, binary: $0.value.binary, processGroup: $0.value.processGroup)
         }
         self.processes.removeAll()
-        self.lock.unlock()
+        self.condition.unlock()
         return drained
     }
 
     static func reset() {
-        self.lock.lock()
+        self.condition.lock()
         self.processes.removeAll()
         self.isShuttingDown = false
-        self.lock.unlock()
+        self.launchesInProgress = 0
+        self.condition.broadcast()
+        self.condition.unlock()
     }
 
     static func count() -> Int {
-        self.lock.lock()
+        self.condition.lock()
         let count = self.processes.count
-        self.lock.unlock()
+        self.condition.unlock()
         return count
     }
 
     static func testTrackProcess(pid: pid_t, binary: String, processGroup: pid_t?) {
         guard pid > 0 else { return }
-        self.lock.lock()
+        self.condition.lock()
         self.processes[pid] = ProcessInfo(binary: binary, processGroup: processGroup)
-        self.lock.unlock()
+        self.condition.unlock()
+    }
+}
+
+enum TTYProcessTreeTerminator {
+    struct ProcessIdentity: Hashable {
+        let pid: pid_t
+        let startToken: UInt64
+    }
+
+    static func descendantPIDs(
+        of rootPID: pid_t,
+        childResolver: (pid_t) -> [pid_t] = Self.currentChildPIDs(of:)) -> [pid_t]
+    {
+        guard rootPID > 0 else { return [] }
+
+        var seen: Set<pid_t> = [rootPID]
+        var pending = childResolver(rootPID)
+        var descendants: [pid_t] = []
+
+        while let pid = pending.popLast() {
+            guard pid > 0, seen.insert(pid).inserted else { continue }
+            descendants.append(pid)
+            pending.append(contentsOf: childResolver(pid))
+        }
+
+        return descendants
+    }
+
+    static func currentChildPIDs(of parentPID: pid_t) -> [pid_t] {
+        guard parentPID > 0 else { return [] }
+
+        #if canImport(Darwin)
+        var pids = [pid_t](repeating: 0, count: 128)
+        let byteCount = Int32(pids.count * MemoryLayout<pid_t>.stride)
+        let childCount = proc_listchildpids(parentPID, &pids, byteCount)
+        guard childCount > 0 else { return [] }
+        return Array(pids.prefix(min(Int(childCount), pids.count))).filter { $0 > 0 }
+        #else
+        let taskPath = "/proc/\(parentPID)/task"
+        guard let taskIDs = try? FileManager.default.contentsOfDirectory(atPath: taskPath) else { return [] }
+
+        var children: Set<pid_t> = []
+        for taskID in taskIDs {
+            let childrenPath = "\(taskPath)/\(taskID)/children"
+            guard let text = try? String(contentsOfFile: childrenPath, encoding: .utf8) else { continue }
+            children.formUnion(text.split(whereSeparator: \.isWhitespace).compactMap { pid_t($0) })
+        }
+        return children.sorted()
+        #endif
+    }
+
+    static func processIdentity(for pid: pid_t) -> ProcessIdentity? {
+        guard pid > 0 else { return nil }
+
+        #if canImport(Darwin)
+        var info = proc_bsdinfo()
+        let size = proc_pidinfo(
+            pid,
+            PROC_PIDTBSDINFO,
+            0,
+            &info,
+            Int32(MemoryLayout<proc_bsdinfo>.stride))
+        guard size == Int32(MemoryLayout<proc_bsdinfo>.stride) else { return nil }
+        let startToken = UInt64(info.pbi_start_tvsec) * 1_000_000 + UInt64(info.pbi_start_tvusec)
+        return ProcessIdentity(pid: pid, startToken: startToken)
+        #else
+        guard let stat = try? String(contentsOfFile: "/proc/\(pid)/stat", encoding: .utf8),
+              let commandEnd = stat.lastIndex(of: ")")
+        else {
+            return nil
+        }
+        let fields = stat[stat.index(after: commandEnd)...].split(whereSeparator: \.isWhitespace)
+        guard fields.count > 19, let startToken = UInt64(fields[19]) else { return nil }
+        return ProcessIdentity(pid: pid, startToken: startToken)
+        #endif
+    }
+
+    static func isCurrent(_ identity: ProcessIdentity) -> Bool {
+        self.processIdentity(for: identity.pid) == identity
+    }
+
+    static func terminateProcessTree(
+        rootPID: pid_t,
+        processGroup: pid_t?,
+        signal: Int32,
+        knownDescendants: [pid_t] = [],
+        childResolver: (pid_t) -> [pid_t] = Self.currentChildPIDs(of:),
+        signalSender: (pid_t, Int32) -> Void = { kill($0, $1) })
+    {
+        guard rootPID > 0 else { return }
+
+        var seen: Set<pid_t> = [rootPID]
+        let descendants = knownDescendants + self.descendantPIDs(of: rootPID, childResolver: childResolver)
+        for pid in descendants where pid > 0 && seen.insert(pid).inserted {
+            signalSender(pid, signal)
+        }
+        if let processGroup {
+            signalSender(-processGroup, signal)
+        }
+        signalSender(rootPID, signal)
     }
 }
 
@@ -95,12 +224,15 @@ public struct TTYCommandRunner {
         public var idleTimeout: TimeInterval?
         public var workingDirectory: URL?
         public var extraArgs: [String] = []
+        public var baseEnvironment: [String: String]?
         public var initialDelay: TimeInterval = 0.4
         public var sendEnterEvery: TimeInterval?
         public var sendOnSubstrings: [String: String]
         public var stopOnURL: Bool
         public var stopOnSubstrings: [String]
         public var settleAfterStop: TimeInterval
+        public var forceCodexStatusMode: Bool
+        public var useClaudeProbeWorkingDirectory: Bool
 
         public init(
             rows: UInt16 = 50,
@@ -109,12 +241,15 @@ public struct TTYCommandRunner {
             idleTimeout: TimeInterval? = nil,
             workingDirectory: URL? = nil,
             extraArgs: [String] = [],
+            baseEnvironment: [String: String]? = nil,
             initialDelay: TimeInterval = 0.4,
             sendEnterEvery: TimeInterval? = nil,
             sendOnSubstrings: [String: String] = [:],
             stopOnURL: Bool = false,
             stopOnSubstrings: [String] = [],
-            settleAfterStop: TimeInterval = 0.25)
+            settleAfterStop: TimeInterval = 0.25,
+            forceCodexStatusMode: Bool = false,
+            useClaudeProbeWorkingDirectory: Bool = false)
         {
             self.rows = rows
             self.cols = cols
@@ -122,12 +257,15 @@ public struct TTYCommandRunner {
             self.idleTimeout = idleTimeout
             self.workingDirectory = workingDirectory
             self.extraArgs = extraArgs
+            self.baseEnvironment = baseEnvironment
             self.initialDelay = initialDelay
             self.sendEnterEvery = sendEnterEvery
             self.sendOnSubstrings = sendOnSubstrings
             self.stopOnURL = stopOnURL
             self.stopOnSubstrings = stopOnSubstrings
             self.settleAfterStop = settleAfterStop
+            self.forceCodexStatusMode = forceCodexStatusMode
+            self.useClaudeProbeWorkingDirectory = useClaudeProbeWorkingDirectory
         }
     }
 
@@ -158,17 +296,17 @@ public struct TTYCommandRunner {
             groupResolver: { getpgid($0) })
 
         for target in resolvedTargets where target.pid > 0 {
-            if let pgid = target.processGroup {
-                kill(-pgid, SIGTERM)
-            }
-            kill(target.pid, SIGTERM)
+            TTYProcessTreeTerminator.terminateProcessTree(
+                rootPID: target.pid,
+                processGroup: target.processGroup,
+                signal: SIGTERM)
         }
 
         for target in resolvedTargets where target.pid > 0 {
-            if let pgid = target.processGroup {
-                kill(-pgid, SIGKILL)
-            }
-            kill(target.pid, SIGKILL)
+            TTYProcessTreeTerminator.terminateProcessTree(
+                rootPID: target.pid,
+                processGroup: target.processGroup,
+                signal: SIGKILL)
         }
     }
 
@@ -196,7 +334,7 @@ public struct TTYCommandRunner {
         return resolvedTargets
     }
 
-    struct RollingBuffer: Sendable {
+    struct RollingBuffer {
         private let maxNeedle: Int
         private var tail = Data()
 
@@ -230,6 +368,12 @@ public struct TTYCommandRunner {
         }
     }
 
+    enum DrainReadResult {
+        case data(Data)
+        case wouldBlock
+        case closed
+    }
+
     static func lowercasedASCII(_ data: Data) -> Data {
         guard !data.isEmpty else { return data }
         var out = Data(count: data.count)
@@ -247,6 +391,43 @@ public struct TTYCommandRunner {
         return out
     }
 
+    static func drainRemainingOutput(
+        until drainDeadline: Date,
+        readChunk: () -> DrainReadResult,
+        processChunk: (Data) -> Void,
+        sleep: (UInt32) -> Void = { usleep($0) })
+    {
+        while Date() < drainDeadline {
+            switch readChunk() {
+            case let .data(newData):
+                processChunk(newData)
+            case .wouldBlock:
+                sleep(20000)
+            case .closed:
+                return
+            }
+        }
+    }
+
+    static func drainReadResult(for data: Data, terminalRead: Int, errno err: Int32) -> DrainReadResult {
+        if !data.isEmpty { return .data(data) }
+
+        if terminalRead == 0 {
+            return .closed
+        }
+
+        if terminalRead < 0 {
+            if err == EAGAIN || err == EWOULDBLOCK || err == EINTR {
+                return .wouldBlock
+            }
+            if err == EIO {
+                return .closed
+            }
+        }
+
+        return .closed
+    }
+
     static func locateBundledHelper(_ name: String) -> String? {
         let fm = FileManager.default
 
@@ -359,9 +540,11 @@ public struct TTYCommandRunner {
             }
         }
 
+        let baseEnv = options.baseEnvironment ?? ProcessInfo.processInfo.environment
         let proc = Process()
         let resolvedURL = URL(fileURLWithPath: resolved)
-        if resolvedURL.lastPathComponent == "claude",
+        let isClaudeCLI = Self.isClaudeBinary(requested: binary, resolved: resolved, environment: baseEnv)
+        if isClaudeCLI,
            let watchdog = Self.locateBundledHelper("CodexBarClaudeWatchdog")
         {
             proc.executableURL = URL(fileURLWithPath: watchdog)
@@ -375,8 +558,12 @@ public struct TTYCommandRunner {
         proc.standardError = secondaryHandle
         // Use login-shell PATH when available, but keep the caller’s environment (HOME, LANG, etc.) so
         // the CLIs can find their auth/config files.
-        var env = Self.enrichedEnvironment()
-        if let workingDirectory = options.workingDirectory {
+        var env = Self.enrichedEnvironment(baseEnv: baseEnv, home: baseEnv["HOME"] ?? NSHomeDirectory())
+        let workingDirectory = options.workingDirectory
+            ?? (options.useClaudeProbeWorkingDirectory && isClaudeCLI
+                ? ClaudeStatusProbe.preparedProbeWorkingDirectoryURL()
+                : nil)
+        if let workingDirectory {
             proc.currentDirectoryURL = workingDirectory
             env["PWD"] = workingDirectory.path
         }
@@ -401,21 +588,29 @@ public struct TTYCommandRunner {
 
             guard didLaunch else { return }
 
+            let descendants = TTYProcessTreeTerminator.descendantPIDs(of: proc.processIdentifier)
             if proc.isRunning {
                 proc.terminate()
             }
-            if let pgid = processGroup {
-                kill(-pgid, SIGTERM)
-            }
+            TTYProcessTreeTerminator.terminateProcessTree(
+                rootPID: proc.processIdentifier,
+                processGroup: processGroup,
+                signal: SIGTERM,
+                knownDescendants: descendants)
             let waitDeadline = Date().addingTimeInterval(2.0)
             while proc.isRunning, Date() < waitDeadline {
                 usleep(100_000)
             }
             if proc.isRunning {
-                if let pgid = processGroup {
-                    kill(-pgid, SIGKILL)
+                TTYProcessTreeTerminator.terminateProcessTree(
+                    rootPID: proc.processIdentifier,
+                    processGroup: processGroup,
+                    signal: SIGKILL,
+                    knownDescendants: descendants)
+            } else {
+                for pid in descendants where pid > 0 {
+                    kill(pid, SIGKILL)
                 }
-                kill(proc.processIdentifier, SIGKILL)
             }
             if didLaunch {
                 proc.waitUntilExit()
@@ -427,6 +622,17 @@ public struct TTYCommandRunner {
             }
         }
 
+        guard TTYCommandRunnerActiveProcessRegistry.beginLaunch() else {
+            cleanup()
+            throw Error.launchFailed("App shutdown in progress")
+        }
+        var launchReservationHeld = true
+        defer {
+            if launchReservationHeld {
+                TTYCommandRunnerActiveProcessRegistry.endLaunch()
+            }
+        }
+
         // Ensure the PTY process is always torn down, even when we throw early (e.g. login prompt).
         defer { cleanup() }
 
@@ -454,6 +660,8 @@ public struct TTYCommandRunner {
         if let processGroup {
             TTYCommandRunnerActiveProcessRegistry.updateProcessGroup(pid: pid, processGroup: processGroup)
         }
+        TTYCommandRunnerActiveProcessRegistry.endLaunch()
+        launchReservationHeld = false
         Self.log.debug("PTY launched", metadata: ["binary": binaryName])
 
         func send(_ text: String) throws {
@@ -463,14 +671,17 @@ public struct TTYCommandRunner {
 
         let deadline = Date().addingTimeInterval(options.timeout)
         let trimmed = script.trimmingCharacters(in: .whitespacesAndNewlines)
-        let isCodex = (binaryName == "codex")
+        let isCodex = (binaryName == "codex") || options.forceCodexStatusMode
         let isCodexStatus = isCodex && trimmed == "/status"
 
         var buffer = Data()
-        func readChunk() -> Data {
+        func readChunkResult() -> (data: Data, terminalRead: Int, errno: Int32) {
             var appended = Data()
+            var terminalRead = 0
+            var terminalErrno: Int32 = 0
             while true {
                 var tmp = [UInt8](repeating: 0, count: 8192)
+                errno = 0
                 let n = read(primaryFD, &tmp, tmp.count)
                 if n > 0 {
                     let slice = tmp.prefix(n)
@@ -478,9 +689,20 @@ public struct TTYCommandRunner {
                     appended.append(contentsOf: slice)
                     continue
                 }
+                terminalRead = Int(n)
+                terminalErrno = errno
                 break
             }
-            return appended
+            return (appended, terminalRead, terminalErrno)
+        }
+
+        func readChunk() -> Data {
+            readChunkResult().data
+        }
+
+        func readDrainChunk() -> DrainReadResult {
+            let result = readChunkResult()
+            return Self.drainReadResult(for: result.data, terminalRead: result.terminalRead, errno: result.errno)
         }
 
         func firstLink(in data: Data) -> String? {
@@ -532,27 +754,26 @@ public struct TTYCommandRunner {
             var recentText = ""
             var lastOutputAt = Date()
 
-            while Date() < deadline {
-                let newData = readChunk()
-                if !newData.isEmpty {
-                    lastOutputAt = Date()
-                    if let chunkText = String(bytes: newData, encoding: .utf8) {
-                        recentText += chunkText
-                        if recentText.count > 8192 {
-                            recentText.removeFirst(recentText.count - 8192)
-                        }
+            func processNonCodexChunk(_ newData: Data, allowSends: Bool, allowStop: Bool) -> Bool {
+                guard !newData.isEmpty else { return false }
+
+                lastOutputAt = Date()
+                if let chunkText = String(bytes: newData, encoding: .utf8) {
+                    recentText += chunkText
+                    if recentText.count > 8192 {
+                        recentText.removeFirst(recentText.count - 8192)
                     }
                 }
+
                 let scanData = scanBuffer.append(newData)
                 if Date() >= nextCursorCheckAt,
-                   !scanData.isEmpty,
                    scanData.range(of: cursorQuery) != nil
                 {
                     try? send("\u{1b}[1;1R")
                     nextCursorCheckAt = Date().addingTimeInterval(1.0)
                 }
 
-                if !sendNeedles.isEmpty {
+                if allowSends, !sendNeedles.isEmpty {
                     let recentTextCollapsed = recentText.replacingOccurrences(of: "\r", with: "")
                     for item in sendNeedles where !triggeredSends.contains(item.needle) {
                         let matched = scanData.range(of: item.needle) != nil ||
@@ -570,16 +791,31 @@ public struct TTYCommandRunner {
                 }
 
                 if urlNeedles.contains(where: { scanData.range(of: $0) != nil }) {
-                    urlSeen = true
-                    if urlSeen {
+                    if !urlSeen {
+                        urlSeen = true
                         onURLDetected?()
                     }
-                    if options.stopOnURL {
-                        stoppedEarly = true
-                        break
+                    if allowStop, options.stopOnURL {
+                        return true
                     }
                 }
-                if !stopNeedles.isEmpty, stopNeedles.contains(where: { scanData.range(of: $0) != nil }) {
+
+                if allowStop, !stopNeedles.isEmpty, stopNeedles.contains(where: { scanData.range(of: $0) != nil }) {
+                    return true
+                }
+
+                return false
+            }
+
+            while Date() < deadline {
+                let readResult = readDrainChunk()
+                let newData = switch readResult {
+                case let .data(data):
+                    data
+                case .wouldBlock, .closed:
+                    Data()
+                }
+                if processNonCodexChunk(newData, allowSends: true, allowStop: true) {
                     stoppedEarly = true
                     break
                 }
@@ -596,6 +832,7 @@ public struct TTYCommandRunner {
                     lastEnter = Date()
                 }
 
+                if case .closed = readResult, !proc.isRunning { break }
                 if !proc.isRunning { break }
                 usleep(60000)
             }
@@ -617,6 +854,16 @@ public struct TTYCommandRunner {
                         usleep(50000)
                     }
                 }
+            } else if !proc.isRunning {
+                // PTY-backed scripts can exit before their final echo becomes readable on the parent side.
+                // Give the kernel a brief non-blocking drain window so we don't lose the last line of output.
+                let drainFor = max(0, min(0.2, deadline.timeIntervalSinceNow))
+                if drainFor > 0 {
+                    Self.drainRemainingOutput(
+                        until: Date().addingTimeInterval(drainFor),
+                        readChunk: readDrainChunk,
+                        processChunk: { _ = processNonCodexChunk($0, allowSends: false, allowStop: false) })
+                }
             }
 
             let text = String(data: buffer, encoding: .utf8) ?? ""
@@ -777,12 +1024,41 @@ public struct TTYCommandRunner {
         return self.runWhich(tool)
     }
 
+    private static func isClaudeBinary(requested: String, resolved: String, environment: [String: String]) -> Bool {
+        let requestedName = URL(fileURLWithPath: requested).lastPathComponent
+        let resolvedName = URL(fileURLWithPath: resolved).lastPathComponent
+        if requested == "claude" || requestedName == "claude" || resolvedName == "claude" {
+            return true
+        }
+
+        guard let override = environment["CLAUDE_CLI_PATH"], !override.isEmpty else { return false }
+        let normalizedOverride = self.normalizedExecutablePath(override)
+        return self.normalizedExecutablePath(resolved) == normalizedOverride
+            || self.normalizedExecutablePath(requested) == normalizedOverride
+    }
+
+    private static func normalizedExecutablePath(_ path: String) -> String {
+        let expanded = NSString(string: path).expandingTildeInPath
+        var buffer = [CChar](repeating: 0, count: Int(PATH_MAX))
+        if realpath(expanded, &buffer) != nil {
+            return buffer.withUnsafeBufferPointer { rawBuffer in
+                guard let baseAddress = rawBuffer.baseAddress else { return expanded }
+                return String(cString: baseAddress)
+            }
+        }
+        return URL(fileURLWithPath: expanded).standardizedFileURL.path
+    }
+
     private static func runWhich(_ tool: String) -> String? {
         let proc = Process()
         proc.executableURL = URL(fileURLWithPath: "/usr/bin/which")
         proc.arguments = [tool]
         var env = ProcessInfo.processInfo.environment
-        env["PATH"] = PathBuilder.effectivePATH(purposes: [.tty, .nodeTooling], env: env)
+        let loginPATH = LoginShellPathCache.shared.currentOrCapture()
+        env["PATH"] = PathBuilder.effectivePATH(
+            purposes: [.tty, .nodeTooling],
+            env: env,
+            loginPATH: loginPATH)
         proc.environment = env
         let pipe = Pipe()
         proc.standardOutput = pipe
@@ -831,6 +1107,29 @@ public struct TTYCommandRunner {
         }
         return env
     }
+}
+
+extension TTYCommandRunner {
+    @discardableResult
+    static func registerActiveProcessForAppShutdown(pid: pid_t, binary: String) -> Bool {
+        TTYCommandRunnerActiveProcessRegistry.register(pid: pid, binary: binary)
+    }
+
+    static func beginActiveProcessLaunchForAppShutdown() -> Bool {
+        TTYCommandRunnerActiveProcessRegistry.beginLaunch()
+    }
+
+    static func endActiveProcessLaunchForAppShutdown() {
+        TTYCommandRunnerActiveProcessRegistry.endLaunch()
+    }
+
+    static func updateActiveProcessGroupForAppShutdown(pid: pid_t, processGroup: pid_t?) {
+        TTYCommandRunnerActiveProcessRegistry.updateProcessGroup(pid: pid, processGroup: processGroup)
+    }
+
+    static func unregisterActiveProcessForAppShutdown(pid: pid_t) {
+        TTYCommandRunnerActiveProcessRegistry.unregister(pid: pid)
+    }
 
     static func _test_resetTrackedProcesses() {
         TTYCommandRunnerActiveProcessRegistry.reset()
@@ -852,8 +1151,19 @@ public struct TTYCommandRunner {
         TTYCommandRunnerActiveProcessRegistry.count()
     }
 
-    static func _test_drainTrackedProcessesForShutdown() -> [(pid: pid_t, binary: String, processGroup: pid_t?)] {
-        TTYCommandRunnerActiveProcessRegistry.drainForShutdown()
+    static func _test_beginTrackedProcessLaunch() -> Bool {
+        TTYCommandRunnerActiveProcessRegistry.beginLaunch()
+    }
+
+    static func _test_endTrackedProcessLaunch() {
+        TTYCommandRunnerActiveProcessRegistry.endLaunch()
+    }
+
+    static func _test_drainTrackedProcessesForShutdown(
+        onFenceSet: (() -> Void)? = nil)
+        -> [(pid: pid_t, binary: String, processGroup: pid_t?)]
+    {
+        TTYCommandRunnerActiveProcessRegistry.drainForShutdown(onFenceSet: onFenceSet)
     }
 
     static func _test_resolveShutdownTargets(
diff --git a/Sources/CodexBarCore/Host/Process/PosixSpawnFileActionsCloseFrom.swift b/Sources/CodexBarCore/Host/Process/PosixSpawnFileActionsCloseFrom.swift
new file mode 100644
index 0000000000..b0efc45f73
--- /dev/null
+++ b/Sources/CodexBarCore/Host/Process/PosixSpawnFileActionsCloseFrom.swift
@@ -0,0 +1,61 @@
+#if canImport(Darwin)
+import Darwin
+#elseif canImport(Glibc)
+import Glibc
+#elseif canImport(Musl)
+import Musl
+#endif
+import Foundation
+
+enum PosixSpawnFileActionsCloseFrom {
+    enum CloseFromError: LocalizedError {
+        case descriptorEnumerationFailed(String)
+        case actionFailed(Int32)
+
+        var errorDescription: String? {
+            switch self {
+            case let .descriptorEnumerationFailed(details):
+                "Could not enumerate /proc/self/fd: \(details)"
+            case let .actionFailed(code):
+                "Could not configure descriptor cleanup: \(String(cString: strerror(code))) (\(code))"
+            }
+        }
+    }
+
+    static func descriptorsToClose(
+        startingAt minimumFileDescriptor: Int32,
+        contentsOfDirectory: (String) throws -> [String] = FileManager.default.contentsOfDirectory(atPath:)) throws
+        -> [Int32]
+    {
+        let entries: [String]
+        do {
+            entries = try contentsOfDirectory("/proc/self/fd")
+        } catch {
+            throw CloseFromError.descriptorEnumerationFailed(error.localizedDescription)
+        }
+        return entries.compactMap(Int32.init)
+            .filter { $0 >= minimumFileDescriptor }
+            .sorted()
+    }
+
+    #if canImport(Glibc) || canImport(Musl)
+    static func addCloseFrom(
+        _ fileActions: inout posix_spawn_file_actions_t,
+        startingAt minimumFileDescriptor: Int32) throws
+    {
+        #if canImport(Glibc)
+        try self.check(posix_spawn_file_actions_addclosefrom_np(&fileActions, minimumFileDescriptor))
+        #else
+        for descriptor in try self.descriptorsToClose(startingAt: minimumFileDescriptor) {
+            try self.check(posix_spawn_file_actions_addclose(&fileActions, descriptor))
+        }
+        #endif
+    }
+
+    private static func check(_ result: Int32) throws {
+        guard result == 0 else {
+            throw CloseFromError.actionFailed(result)
+        }
+    }
+    #endif
+}
diff --git a/Sources/CodexBarCore/Host/Process/ProcessPipeCapture.swift b/Sources/CodexBarCore/Host/Process/ProcessPipeCapture.swift
new file mode 100644
index 0000000000..affc29111a
--- /dev/null
+++ b/Sources/CodexBarCore/Host/Process/ProcessPipeCapture.swift
@@ -0,0 +1,138 @@
+import Foundation
+
+package final class ProcessPipeCapture: @unchecked Sendable {
+    package static let defaultMaxBytes = 1 * 1024 * 1024
+
+    private let handle: FileHandle
+    private let onData: (@Sendable () -> Void)?
+    private let maxBytes: Int
+    private let condition = NSCondition()
+    private var data = Data()
+    private var activeCallbacks = 0
+    private var isFinished = false
+    private var didReachEOF = false
+    private var isStopping = false
+    private var continuation: CheckedContinuation<Void, Never>?
+
+    package init(
+        pipe: Pipe,
+        maxBytes: Int = ProcessPipeCapture.defaultMaxBytes,
+        onData: (@Sendable () -> Void)? = nil)
+    {
+        self.handle = pipe.fileHandleForReading
+        self.maxBytes = max(0, maxBytes)
+        self.onData = onData
+    }
+
+    package func start() {
+        self.handle.readabilityHandler = { [weak self] handle in
+            self?.handleReadableData(from: handle)
+        }
+    }
+
+    package func finish(timeout: Duration) async -> Data {
+        let drainTask = Task<Void, Error> {
+            await self.waitUntilFinished()
+        }
+        let join = BoundedTaskJoin(sourceTask: drainTask)
+        _ = await join.value(joinGrace: timeout)
+        return self.stopAndSnapshot()
+    }
+
+    package func finishSynchronously(timeout: TimeInterval) -> Data {
+        let deadline = Date().addingTimeInterval(max(0, timeout))
+        self.condition.lock()
+        while !self.isFinished, !self.isStopping {
+            guard self.condition.wait(until: deadline) else { break }
+        }
+        self.condition.unlock()
+        return self.stopAndSnapshot()
+    }
+
+    package func stop() {
+        _ = self.stopAndSnapshot()
+    }
+
+    package var reachedEOF: Bool {
+        self.condition.lock()
+        defer { self.condition.unlock() }
+        return self.didReachEOF
+    }
+
+    package static func decodeUTF8(_ data: Data) -> String {
+        // A byte cap can split the final scalar; lossy decoding preserves the valid captured prefix.
+        // swiftlint:disable:next optional_data_string_conversion
+        String(decoding: data, as: UTF8.self)
+    }
+
+    private func handleReadableData(from handle: FileHandle) {
+        self.condition.lock()
+        guard !self.isStopping else {
+            self.condition.unlock()
+            return
+        }
+        self.activeCallbacks += 1
+        self.condition.unlock()
+
+        let chunk = handle.availableData
+        var continuation: CheckedContinuation<Void, Never>?
+
+        self.condition.lock()
+        if chunk.isEmpty {
+            self.isFinished = true
+            self.didReachEOF = true
+            continuation = self.continuation
+            self.continuation = nil
+        } else {
+            let remainingBytes = max(0, self.maxBytes - self.data.count)
+            if remainingBytes > 0 {
+                self.data.append(chunk.prefix(remainingBytes))
+            }
+        }
+        self.activeCallbacks -= 1
+        if self.activeCallbacks == 0 {
+            self.condition.broadcast()
+        }
+        self.condition.unlock()
+
+        if chunk.isEmpty {
+            handle.readabilityHandler = nil
+        } else {
+            self.onData?()
+        }
+        continuation?.resume()
+    }
+
+    private func waitUntilFinished() async {
+        await withCheckedContinuation { continuation in
+            self.condition.lock()
+            if self.isFinished || self.isStopping {
+                self.condition.unlock()
+                continuation.resume()
+                return
+            }
+            self.continuation = continuation
+            self.condition.unlock()
+        }
+    }
+
+    private func stopAndSnapshot() -> Data {
+        self.handle.readabilityHandler = nil
+
+        let continuation: CheckedContinuation<Void, Never>?
+        let snapshot: Data
+        self.condition.lock()
+        self.isStopping = true
+        while self.activeCallbacks > 0 {
+            self.condition.wait()
+        }
+        self.isFinished = true
+        continuation = self.continuation
+        self.continuation = nil
+        snapshot = self.data
+        self.condition.unlock()
+
+        continuation?.resume()
+        return snapshot
+    }
+}
diff --git a/Sources/CodexBarCore/Host/Process/SpawnedProcessGroup.swift b/Sources/CodexBarCore/Host/Process/SpawnedProcessGroup.swift
new file mode 100644
index 0000000000..d402c6fc93
--- /dev/null
+++ b/Sources/CodexBarCore/Host/Process/SpawnedProcessGroup.swift
@@ -0,0 +1,568 @@
+#if canImport(Darwin)
+import Darwin
+#elseif canImport(Glibc)
+import Glibc
+#elseif canImport(Musl)
+import Musl
+#endif
+import Foundation
+
+package final class SpawnedProcessGroup: @unchecked Sendable {
+    package enum LaunchError: LocalizedError {
+        case setupFailed(String)
+        case spawnFailed(String)
+
+        package var errorDescription: String? {
+            switch self {
+            case let .setupFailed(details):
+                "Failed to prepare process: \(details)"
+            case let .spawnFailed(details):
+                "Failed to launch process: \(details)"
+            }
+        }
+    }
+
+    private final class TerminationState: @unchecked Sendable {
+        private let condition = NSCondition()
+        private var exitObserved = false
+        private var reapRequested = false
+        private var status: Int32?
+
+        var hasObservedExit: Bool {
+            self.condition.withLock { self.exitObserved }
+        }
+
+        var value: Int32? {
+            self.condition.withLock { self.status }
+        }
+
+        func observeExit() {
+            self.condition.withLock {
+                self.exitObserved = true
+                self.condition.broadcast()
+            }
+        }
+
+        func requestReap() {
+            self.condition.withLock {
+                self.reapRequested = true
+                self.condition.broadcast()
+            }
+        }
+
+        func waitForReapRequest(timeout: TimeInterval) {
+            let deadline = Date().addingTimeInterval(timeout)
+            self.condition.lock()
+            while !self.reapRequested, self.condition.wait(until: deadline) {}
+            self.condition.unlock()
+        }
+
+        func resolve(_ status: Int32) {
+            self.condition.withLock {
+                guard self.status == nil else { return }
+                self.status = status
+                self.condition.broadcast()
+            }
+        }
+    }
+
+    private final class ProcessIdentityState: @unchecked Sendable {
+        private let lock = NSLock()
+        private var identities: Set<TTYProcessTreeTerminator.ProcessIdentity> = []
+
+        var snapshot: Set<TTYProcessTreeTerminator.ProcessIdentity> {
+            self.lock.withLock { self.identities }
+        }
+
+        func formUnion(_ identities: Set<TTYProcessTreeTerminator.ProcessIdentity>) {
+            self.lock.withLock {
+                self.identities.formUnion(identities)
+            }
+        }
+    }
+
+    private struct OutputPipeIdentity: Hashable {
+        #if canImport(Darwin)
+        let firstHandle: UInt64
+        let secondHandle: UInt64
+        #else
+        let inode: UInt64
+        #endif
+
+        static func resolve(fileDescriptor: Int32) -> OutputPipeIdentity? {
+            #if canImport(Darwin)
+            var info = pipe_fdinfo()
+            let byteCount = proc_pidfdinfo(
+                getpid(),
+                fileDescriptor,
+                PROC_PIDFDPIPEINFO,
+                &info,
+                Int32(MemoryLayout<pipe_fdinfo>.size))
+            guard byteCount == MemoryLayout<pipe_fdinfo>.size else { return nil }
+            let handles = [info.pipeinfo.pipe_handle, info.pipeinfo.pipe_peerhandle].sorted()
+            guard handles[0] != 0, handles[1] != 0 else { return nil }
+            return OutputPipeIdentity(firstHandle: handles[0], secondHandle: handles[1])
+            #else
+            var info = stat()
+            guard fstat(fileDescriptor, &info) == 0 else { return nil }
+            return OutputPipeIdentity(inode: UInt64(info.st_ino))
+            #endif
+        }
+
+        static func holderPIDs(for pipes: Set<OutputPipeIdentity>) -> Set<pid_t> {
+            guard !pipes.isEmpty else { return [] }
+            #if canImport(Darwin)
+            return Set(SpawnedProcessGroup.allProcessIDs().filter { self.process(pid: $0, holdsAny: pipes) })
+            #else
+            let targets = Set(pipes.map { "pipe:[\($0.inode)]" })
+            return Set(SpawnedProcessGroup.allProcessIDs().filter { pid in
+                let directory = "/proc/\(pid)/fd"
+                guard let descriptors = try? FileManager.default.contentsOfDirectory(atPath: directory) else {
+                    return false
+                }
+                return descriptors.contains { descriptor in
+                    let path = "\(directory)/\(descriptor)"
+                    guard let target = try? FileManager.default.destinationOfSymbolicLink(atPath: path) else {
+                        return false
+                    }
+                    return targets.contains(target)
+                }
+            })
+            #endif
+        }
+
+        #if canImport(Darwin)
+        private static func process(pid: pid_t, holdsAny pipes: Set<OutputPipeIdentity>) -> Bool {
+            let requiredBytes = proc_pidinfo(pid, PROC_PIDLISTFDS, 0, nil, 0)
+            guard requiredBytes > 0 else { return false }
+            let stride = MemoryLayout<proc_fdinfo>.stride
+            var descriptors = [proc_fdinfo](
+                repeating: proc_fdinfo(),
+                count: Int(requiredBytes) / stride + 8)
+            let actualBytes = descriptors.withUnsafeMutableBytes { buffer in
+                proc_pidinfo(
+                    pid,
+                    PROC_PIDLISTFDS,
+                    0,
+                    buffer.baseAddress,
+                    Int32(buffer.count))
+            }
+            guard actualBytes > 0 else { return false }
+
+            for descriptor in descriptors.prefix(Int(actualBytes) / stride)
+                where descriptor.proc_fdtype == PROX_FDTYPE_PIPE
+            {
+                var info = pipe_fdinfo()
+                let byteCount = proc_pidfdinfo(
+                    pid,
+                    descriptor.proc_fd,
+                    PROC_PIDFDPIPEINFO,
+                    &info,
+                    Int32(MemoryLayout<pipe_fdinfo>.size))
+                guard byteCount == MemoryLayout<pipe_fdinfo>.size else { continue }
+                let handles = [info.pipeinfo.pipe_handle, info.pipeinfo.pipe_peerhandle].sorted()
+                let identity = OutputPipeIdentity(firstHandle: handles[0], secondHandle: handles[1])
+                if pipes.contains(identity) {
+                    return true
+                }
+            }
+            return false
+        }
+        #endif
+    }
+
+    private static func allProcessIDs() -> [pid_t] {
+        #if canImport(Darwin)
+        return self.processIDs(type: UInt32(PROC_ALL_PIDS), typeInfo: 0)
+        #else
+        guard let entries = try? FileManager.default.contentsOfDirectory(atPath: "/proc") else { return [] }
+        return entries.compactMap(pid_t.init)
+        #endif
+    }
+
+    private static func processIDs(inProcessGroup processGroup: pid_t) -> [pid_t] {
+        #if canImport(Darwin)
+        return self.processIDs(type: UInt32(PROC_PGRP_ONLY), typeInfo: UInt32(bitPattern: processGroup))
+        #else
+        return self.allProcessIDs().filter { getpgid($0) == processGroup }
+        #endif
+    }
+
+    #if canImport(Darwin)
+    private static func processIDs(type: UInt32, typeInfo: UInt32) -> [pid_t] {
+        let requiredBytes = proc_listpids(type, typeInfo, nil, 0)
+        guard requiredBytes > 0 else { return [] }
+        let stride = MemoryLayout<pid_t>.stride
+        var pids = [pid_t](repeating: 0, count: Int(requiredBytes) / stride + 32)
+        let actualBytes = pids.withUnsafeMutableBytes { buffer in
+            proc_listpids(
+                type,
+                typeInfo,
+                buffer.baseAddress,
+                Int32(buffer.count))
+        }
+        guard actualBytes > 0 else { return [] }
+        return Array(pids.prefix(Int(actualBytes) / stride)).filter { $0 > 0 }
+    }
+    #endif
+
+    package let pid: pid_t
+    package let processGroup: pid_t
+    private let termination = TerminationState()
+    private let observedProcessGroupMembers = ProcessIdentityState()
+    private let outputPipes: Set<OutputPipeIdentity>
+    private let rootIdentity: TTYProcessTreeTerminator.ProcessIdentity?
+
+    private init(pid: pid_t, outputPipes: Set<OutputPipeIdentity>) {
+        self.pid = pid
+        self.processGroup = pid
+        self.outputPipes = outputPipes
+        self.rootIdentity = TTYProcessTreeTerminator.processIdentity(for: pid)
+        self.startWaiter()
+    }
+
+    package static func launch(
+        binary: String,
+        arguments: [String],
+        environment: [String: String],
+        stdoutPipe: Pipe,
+        stderrPipe: Pipe) throws -> SpawnedProcessGroup
+    {
+        #if canImport(Darwin)
+        var fileActions: posix_spawn_file_actions_t?
+        #else
+        var fileActions = posix_spawn_file_actions_t()
+        #endif
+        guard posix_spawn_file_actions_init(&fileActions) == 0 else {
+            throw LaunchError.setupFailed("posix_spawn_file_actions_init")
+        }
+        defer { posix_spawn_file_actions_destroy(&fileActions) }
+
+        let stdoutRead = stdoutPipe.fileHandleForReading.fileDescriptor
+        let stdoutWrite = stdoutPipe.fileHandleForWriting.fileDescriptor
+        let stderrRead = stderrPipe.fileHandleForReading.fileDescriptor
+        let stderrWrite = stderrPipe.fileHandleForWriting.fileDescriptor
+        let outputPipes = Set(
+            [stdoutRead, stderrRead].compactMap(OutputPipeIdentity.resolve(fileDescriptor:)))
+        var fileActionResults = [
+            posix_spawn_file_actions_addopen(&fileActions, STDIN_FILENO, "/dev/null", O_RDONLY, 0),
+            posix_spawn_file_actions_adddup2(&fileActions, stdoutWrite, STDOUT_FILENO),
+            posix_spawn_file_actions_adddup2(&fileActions, stderrWrite, STDERR_FILENO),
+        ]
+        for descriptor in Self.pipeDescriptorsToClose([stdoutRead, stdoutWrite, stderrRead, stderrWrite]) {
+            fileActionResults.append(posix_spawn_file_actions_addclose(&fileActions, descriptor))
+        }
+        #if canImport(Glibc) || canImport(Musl)
+        do {
+            try PosixSpawnFileActionsCloseFrom.addCloseFrom(
+                &fileActions,
+                startingAt: STDERR_FILENO + 1)
+        } catch {
+            throw LaunchError.setupFailed(error.localizedDescription)
+        }
+        #endif
+        guard fileActionResults.allSatisfy({ $0 == 0 }) else {
+            throw LaunchError.setupFailed("posix_spawn file actions")
+        }
+
+        #if canImport(Darwin)
+        var attributes: posix_spawnattr_t?
+        #else
+        var attributes = posix_spawnattr_t()
+        #endif
+        guard posix_spawnattr_init(&attributes) == 0 else {
+            throw LaunchError.setupFailed("posix_spawnattr_init")
+        }
+        defer { posix_spawnattr_destroy(&attributes) }
+
+        #if canImport(Darwin)
+        let flags = POSIX_SPAWN_SETPGROUP | POSIX_SPAWN_CLOEXEC_DEFAULT
+        #else
+        let flags = POSIX_SPAWN_SETPGROUP
+        #endif
+        guard posix_spawnattr_setflags(&attributes, Int16(flags)) == 0,
+              posix_spawnattr_setpgroup(&attributes, 0) == 0
+        else {
+            throw LaunchError.setupFailed("posix_spawn process group")
+        }
+
+        var cArguments: [UnsafeMutablePointer<CChar>?] = ([binary] + arguments).map { strdup($0) }
+        cArguments.append(nil)
+        defer {
+            for argument in cArguments {
+                free(argument)
+            }
+        }
+
+        var cEnvironment: [UnsafeMutablePointer<CChar>?] = environment.map { key, value in
+            strdup("\(key)=\(value)")
+        }
+        cEnvironment.append(nil)
+        defer {
+            for entry in cEnvironment {
+                free(entry)
+            }
+        }
+
+        var pid: pid_t = 0
+        let spawnResult = binary.withCString { path in
+            posix_spawn(&pid, path, &fileActions, &attributes, cArguments, cEnvironment)
+        }
+        stdoutPipe.fileHandleForWriting.closeFile()
+        stderrPipe.fileHandleForWriting.closeFile()
+        guard spawnResult == 0 else {
+            throw LaunchError.spawnFailed(String(cString: strerror(spawnResult)))
+        }
+        return SpawnedProcessGroup(pid: pid, outputPipes: outputPipes)
+    }
+
+    package var isRunning: Bool {
+        !self.termination.hasObservedExit
+    }
+
+    package var terminationStatus: Int32? {
+        self.termination.value
+    }
+
+    package var hasResidualProcessGroup: Bool {
+        Self.processGroupExists(self.processGroup)
+    }
+
+    @discardableResult
+    package func terminate(grace: TimeInterval = 0.4) async -> Int32? {
+        if self.isRunning {
+            let killDeadline = Date().addingTimeInterval(max(0, grace))
+            var processIdentities = self.currentResidualProcessIdentities(includeDescendants: true)
+            processIdentities.formUnion(self.currentProcessGroupMemberIdentities())
+            if let rootIdentity = TTYProcessTreeTerminator.processIdentity(for: self.pid) {
+                processIdentities.insert(rootIdentity)
+            }
+            Self.signal(processIdentities: processIdentities, signal: SIGTERM)
+            _ = await self.waitForExit(timeout: max(0, killDeadline.timeIntervalSinceNow))
+            while processIdentities.contains(where: TTYProcessTreeTerminator.isCurrent(_:)),
+                  Date() < killDeadline
+            {
+                try? await Task.sleep(for: .milliseconds(20))
+            }
+
+            processIdentities.formUnion(self.currentResidualProcessIdentities(includeDescendants: false))
+            processIdentities.formUnion(self.currentProcessGroupMemberIdentities())
+            if self.isRunning {
+                processIdentities.formUnion(self.currentResidualProcessIdentities(includeDescendants: true))
+                if let rootIdentity = TTYProcessTreeTerminator.processIdentity(for: self.pid) {
+                    processIdentities.insert(rootIdentity)
+                }
+                Self.signal(processIdentities: processIdentities, signal: SIGKILL)
+                _ = await self.waitForExit(timeout: grace)
+            } else {
+                Self.signal(processIdentities: processIdentities, signal: SIGKILL)
+            }
+            _ = await self.waitForResidualProcessesExit(processIdentities, timeout: grace)
+            await self.finish()
+            return self.terminationStatus
+        }
+        await self.terminateResidualProcesses(grace: grace)
+        await self.finish()
+        return self.terminationStatus
+    }
+
+    package func terminateResidualProcesses(grace: TimeInterval = 0.4) async {
+        let deadline = Date().addingTimeInterval(max(0, grace))
+        var processIdentities = self.currentResidualProcessIdentities(includeDescendants: false)
+        processIdentities.formUnion(self.currentProcessGroupMemberIdentities())
+        if self.isRunning {
+            processIdentities.formUnion(self.currentResidualProcessIdentities(includeDescendants: true))
+            if let rootIdentity = TTYProcessTreeTerminator.processIdentity(for: self.pid) {
+                processIdentities.insert(rootIdentity)
+            }
+        }
+        Self.signal(processIdentities: processIdentities, signal: SIGTERM)
+
+        while processIdentities.contains(where: TTYProcessTreeTerminator.isCurrent(_:)) {
+            guard Date() < deadline else { break }
+            try? await Task.sleep(for: .milliseconds(20))
+        }
+
+        processIdentities.formUnion(self.currentResidualProcessIdentities(includeDescendants: false))
+        processIdentities.formUnion(self.currentProcessGroupMemberIdentities())
+        if self.isRunning {
+            processIdentities.formUnion(self.currentResidualProcessIdentities(includeDescendants: true))
+            if let rootIdentity = TTYProcessTreeTerminator.processIdentity(for: self.pid) {
+                processIdentities.insert(rootIdentity)
+            }
+        }
+        guard processIdentities.contains(where: TTYProcessTreeTerminator.isCurrent(_:)) else {
+            return
+        }
+        Self.signal(processIdentities: processIdentities, signal: SIGKILL)
+        _ = await self.waitForResidualProcessesExit(processIdentities, timeout: grace)
+    }
+
+    package func finish() async {
+        self.termination.requestReap()
+        _ = await self.waitForTerminationStatus(timeout: 1)
+    }
+
+    private func startWaiter() {
+        let pid = self.pid
+        let processGroup = self.processGroup
+        let observedProcessGroupMembers = self.observedProcessGroupMembers
+        let termination = self.termination
+        DispatchQueue.global(qos: .userInitiated).async {
+            var info = siginfo_t()
+            var waitResult: Int32
+            repeat {
+                waitResult = waitid(P_PID, id_t(pid), &info, WEXITED | WNOWAIT)
+            } while waitResult == -1 && errno == EINTR
+            guard waitResult == 0 else {
+                termination.observeExit()
+                termination.resolve(1)
+                return
+            }
+
+            // The exited root remains unreaped here, so its PID cannot yet be reused as
+            // an unrelated process-group ID.
+            observedProcessGroupMembers.formUnion(
+                Self.processGroupMemberIdentities(processGroup: processGroup, excluding: pid))
+            termination.observeExit()
+            termination.waitForReapRequest(timeout: 30)
+
+            var rawStatus: Int32 = 0
+            var result: pid_t
+            repeat {
+                result = waitpid(pid, &rawStatus, 0)
+            } while result == -1 && errno == EINTR
+
+            let status = result == pid ? Self.exitStatus(from: rawStatus) : 1
+            termination.resolve(status)
+        }
+    }
+
+    private func waitForExit(timeout: TimeInterval) async -> Int32? {
+        let deadline = Date().addingTimeInterval(max(0, timeout))
+        while self.isRunning, Date() < deadline {
+            try? await Task.sleep(for: .milliseconds(20))
+        }
+        return self.terminationStatus
+    }
+
+    private func waitForTerminationStatus(timeout: TimeInterval) async -> Int32? {
+        let deadline = Date().addingTimeInterval(max(0, timeout))
+        while self.terminationStatus == nil, Date() < deadline {
+            try? await Task.sleep(for: .milliseconds(20))
+        }
+        return self.terminationStatus
+    }
+
+    private func waitForResidualProcessesExit(
+        _ processIdentities: Set<TTYProcessTreeTerminator.ProcessIdentity>,
+        timeout: TimeInterval) async -> Bool
+    {
+        let deadline = Date().addingTimeInterval(max(0, timeout))
+        while Date() < deadline {
+            guard processIdentities.contains(where: TTYProcessTreeTerminator.isCurrent(_:)) else {
+                return true
+            }
+            try? await Task.sleep(for: .milliseconds(20))
+        }
+        return !processIdentities.contains(where: TTYProcessTreeTerminator.isCurrent(_:))
+    }
+
+    private func currentResidualProcessIdentities(
+        includeDescendants: Bool) -> Set<TTYProcessTreeTerminator.ProcessIdentity>
+    {
+        var identities = self.currentOutputPipeHolderIdentities()
+        identities.formUnion(self.observedProcessGroupMembers.snapshot)
+        if includeDescendants {
+            identities.formUnion(
+                TTYProcessTreeTerminator.descendantPIDs(of: self.pid)
+                    .compactMap(TTYProcessTreeTerminator.processIdentity(for:)))
+        }
+        return identities
+    }
+
+    private func currentOutputPipeHolderIdentities() -> Set<TTYProcessTreeTerminator.ProcessIdentity> {
+        let excludedPIDs: Set<pid_t> = [getpid(), self.pid]
+        let holderPIDs = OutputPipeIdentity.holderPIDs(for: self.outputPipes)
+        return Set(holderPIDs.subtracting(excludedPIDs).compactMap(TTYProcessTreeTerminator.processIdentity(for:)))
+    }
+
+    private func currentProcessGroupMemberIdentities() -> Set<TTYProcessTreeTerminator.ProcessIdentity> {
+        if self.termination.hasObservedExit, self.termination.value == nil {
+            let identities = Self.processGroupMemberIdentities(
+                processGroup: self.processGroup,
+                excluding: self.pid)
+            self.observedProcessGroupMembers.formUnion(identities)
+            return identities
+        }
+
+        guard let rootIdentity = self.rootIdentity
+        else {
+            return []
+        }
+
+        let identities = Self.processGroupMemberIdentities(
+            processGroup: self.processGroup,
+            rootIdentity: rootIdentity,
+            excluding: self.pid)
+        self.observedProcessGroupMembers.formUnion(identities)
+        return identities
+    }
+
+    private static func processGroupMemberIdentities(
+        processGroup: pid_t,
+        rootIdentity: TTYProcessTreeTerminator.ProcessIdentity,
+        excluding excludedPID: pid_t)
+        -> Set<TTYProcessTreeTerminator.ProcessIdentity>
+    {
+        guard TTYProcessTreeTerminator.isCurrent(rootIdentity) else { return [] }
+
+        let identities = Self.processGroupMemberIdentities(
+            processGroup: processGroup,
+            excluding: excludedPID)
+        guard TTYProcessTreeTerminator.isCurrent(rootIdentity) else { return [] }
+        return identities
+    }
+
+    private static func processGroupMemberIdentities(
+        processGroup: pid_t,
+        excluding excludedPID: pid_t)
+        -> Set<TTYProcessTreeTerminator.ProcessIdentity>
+    {
+        Set(self.processIDs(inProcessGroup: processGroup)
+            .compactMap { pid -> TTYProcessTreeTerminator.ProcessIdentity? in
+                guard pid != getpid(),
+                      pid != excludedPID,
+                      let identity = TTYProcessTreeTerminator.processIdentity(for: pid),
+                      getpgid(pid) == processGroup,
+                      TTYProcessTreeTerminator.isCurrent(identity)
+                else {
+                    return nil
+                }
+                return identity
+            })
+    }
+
+    private static func processGroupExists(_ processGroup: pid_t) -> Bool {
+        errno = 0
+        return kill(-processGroup, 0) == 0 || errno == EPERM
+    }
+
+    private static func signal(
+        processIdentities: Set<TTYProcessTreeTerminator.ProcessIdentity>,
+        signal: Int32)
+    {
+        for identity in processIdentities where TTYProcessTreeTerminator.isCurrent(identity) {
+            _ = kill(identity.pid, signal)
+        }
+    }
+
+    package static func pipeDescriptorsToClose(_ descriptors: [Int32]) -> [Int32] {
+        Array(Set(descriptors.filter { $0 > STDERR_FILENO })).sorted()
+    }
+
+    private static func exitStatus(from rawStatus: Int32) -> Int32 {
+        let signal = rawStatus & 0x7F
+        return signal == 0 ? (rawStatus >> 8) & 0xFF : signal
+    }
+}
diff --git a/Sources/CodexBarCore/Host/Process/SubprocessRunner.swift b/Sources/CodexBarCore/Host/Process/SubprocessRunner.swift
index 19bf476391..193b6f6278 100644
--- a/Sources/CodexBarCore/Host/Process/SubprocessRunner.swift
+++ b/Sources/CodexBarCore/Host/Process/SubprocessRunner.swift
@@ -1,7 +1,9 @@
 #if canImport(Darwin)
 import Darwin
-#else
+#elseif canImport(Glibc)
 import Glibc
+#elseif canImport(Musl)
+import Musl
 #endif
 import Foundation
 
@@ -36,12 +38,123 @@ public struct SubprocessResult: Sendable {
 
 public enum SubprocessRunner {
     private static let log = CodexBarLog.logger(LogCategories.subprocess)
+    private static let timeoutQueue = DispatchQueue(
+        label: "com.steipete.codexbar.subprocess.timeout",
+        qos: .userInitiated,
+        attributes: .concurrent)
+
+    /// Thread-safe flag for communicating between concurrent tasks (e.g. timeout → caller).
+    private final class KillFlag: @unchecked Sendable {
+        private let lock = NSLock()
+        private var value = false
+
+        func set() {
+            self.lock.withLock { self.value = true }
+        }
+
+        var isSet: Bool {
+            self.lock.withLock { self.value }
+        }
+    }
+
+    private final class TimeoutTimer: @unchecked Sendable {
+        private let timer: any DispatchSourceTimer
+
+        init(timer: any DispatchSourceTimer) {
+            self.timer = timer
+        }
+
+        func cancel() {
+            self.timer.cancel()
+        }
+    }
+
+    private static func timeoutInterval(_ timeout: TimeInterval) -> DispatchTimeInterval {
+        guard timeout.isFinite else {
+            return .seconds(Int.max)
+        }
+        let nanoseconds = max(0, min(timeout * 1_000_000_000, Double(Int.max)))
+        return .nanoseconds(Int(nanoseconds))
+    }
+
+    private final class ProcessTermination: @unchecked Sendable {
+        private let lock = NSLock()
+        private var status: Int32?
+        private var continuation: CheckedContinuation<Int32, Never>?
+
+        func resolve(_ status: Int32) {
+            let continuation: CheckedContinuation<Int32, Never>?
+            self.lock.lock()
+            self.status = status
+            continuation = self.continuation
+            self.continuation = nil
+            self.lock.unlock()
+            continuation?.resume(returning: status)
+        }
+
+        func wait() async -> Int32 {
+            await withCheckedContinuation { continuation in
+                let status: Int32?
+                self.lock.lock()
+                status = self.status
+                if status == nil {
+                    self.continuation = continuation
+                }
+                self.lock.unlock()
+
+                if let status {
+                    continuation.resume(returning: status)
+                }
+            }
+        }
+    }
+
+    /// Terminates a process and its process group, escalating from SIGTERM to SIGKILL.
+    /// Returns `true` if the process was actually killed, `false` if it had already exited.
+    @discardableResult
+    package static func terminateProcess(_ process: Process, processGroup: pid_t?) -> Bool {
+        guard process.isRunning else { return false }
+        let descendants = TTYProcessTreeTerminator.descendantPIDs(of: process.processIdentifier)
+        let descendantIdentities = descendants.compactMap(TTYProcessTreeTerminator.processIdentity(for:))
+        TTYProcessTreeTerminator.terminateProcessTree(
+            rootPID: process.processIdentifier,
+            processGroup: processGroup,
+            signal: SIGTERM,
+            knownDescendants: descendants)
+        let killDeadline = Date().addingTimeInterval(0.4)
+        while process.isRunning, Date() < killDeadline {
+            usleep(50000)
+        }
+        if process.isRunning {
+            let currentDescendants = descendantIdentities
+                .filter(TTYProcessTreeTerminator.isCurrent(_:))
+                .map(\.pid)
+            TTYProcessTreeTerminator.terminateProcessTree(
+                rootPID: process.processIdentifier,
+                processGroup: processGroup,
+                signal: SIGKILL,
+                knownDescendants: currentDescendants)
+            let reapDeadline = Date().addingTimeInterval(0.4)
+            while process.isRunning, Date() < reapDeadline {
+                usleep(50000)
+            }
+        } else {
+            for identity in descendantIdentities where TTYProcessTreeTerminator.isCurrent(identity) {
+                kill(identity.pid, SIGKILL)
+            }
+        }
+        return true
+    }
+
+    // MARK: - Public API
 
     public static func run(
         binary: String,
         arguments: [String],
         environment: [String: String],
         timeout: TimeInterval,
+        standardInput: Any? = nil,
+        currentDirectoryURL: URL? = nil,
         label: String) async throws -> SubprocessResult
     {
         guard FileManager.default.isExecutableFile(atPath: binary) else {
@@ -58,57 +171,83 @@ public enum SubprocessRunner {
         process.executableURL = URL(fileURLWithPath: binary)
         process.arguments = arguments
         process.environment = environment
+        process.currentDirectoryURL = currentDirectoryURL
 
         let stdoutPipe = Pipe()
         let stderrPipe = Pipe()
         process.standardOutput = stdoutPipe
         process.standardError = stderrPipe
-        process.standardInput = nil
+        process.standardInput = standardInput
+        let stdoutCapture = ProcessPipeCapture(pipe: stdoutPipe)
+        let stderrCapture = ProcessPipeCapture(pipe: stderrPipe)
 
-        let stdoutTask = Task<Data, Never> {
-            stdoutPipe.fileHandleForReading.readDataToEndOfFile()
-        }
-        let stderrTask = Task<Data, Never> {
-            stderrPipe.fileHandleForReading.readDataToEndOfFile()
+        let termination = ProcessTermination()
+        process.terminationHandler = { process in
+            termination.resolve(process.terminationStatus)
         }
 
         do {
             try process.run()
         } catch {
-            stdoutTask.cancel()
-            stderrTask.cancel()
-            stdoutPipe.fileHandleForReading.closeFile()
-            stderrPipe.fileHandleForReading.closeFile()
+            process.terminationHandler = nil
+            stdoutCapture.stop()
+            stdoutPipe.fileHandleForWriting.closeFile()
+            stderrCapture.stop()
+            stderrPipe.fileHandleForWriting.closeFile()
             throw SubprocessRunnerError.launchFailed(error.localizedDescription)
         }
+        stdoutCapture.start()
+        stderrCapture.start()
 
-        var processGroup: pid_t?
         let pid = process.processIdentifier
-        if setpgid(pid, pid) == 0 {
-            processGroup = pid
-        }
+        let processGroup: pid_t? = setpgid(pid, pid) == 0 ? pid : nil
 
         let exitCodeTask = Task<Int32, Never> {
-            process.waitUntilExit()
-            return process.terminationStatus
+            await termination.wait()
+        }
+
+        let killedByTimeout = KillFlag()
+        let timeoutTimer = DispatchSource.makeTimerSource(queue: self.timeoutQueue)
+        timeoutTimer.schedule(deadline: .now() + self.timeoutInterval(timeout))
+        timeoutTimer.setEventHandler {
+            guard process.isRunning else { return }
+            killedByTimeout.set()
+            self.terminateProcess(process, processGroup: processGroup)
         }
+        timeoutTimer.resume()
+        let timeoutTimerBox = TimeoutTimer(timer: timeoutTimer)
 
         do {
-            let exitCode = try await withThrowingTaskGroup(of: Int32.self) { group in
-                group.addTask { await exitCodeTask.value }
-                group.addTask {
-                    try await Task.sleep(for: .seconds(timeout))
-                    throw SubprocessRunnerError.timedOut(label)
-                }
-                let code = try await group.next()!
-                group.cancelAll()
+            let exitCode = try await withTaskCancellationHandler {
+                try Task.checkCancellation()
+                let code = await exitCodeTask.value
+                try Task.checkCancellation()
                 return code
+            } onCancel: {
+                timeoutTimerBox.cancel()
+                self.terminateProcess(process, processGroup: processGroup)
             }
+            timeoutTimerBox.cancel()
 
-            let stdoutData = await stdoutTask.value
-            let stderrData = await stderrTask.value
-            let stdout = String(data: stdoutData, encoding: .utf8) ?? ""
-            let stderr = String(data: stderrData, encoding: .utf8) ?? ""
+            let duration = Date().timeIntervalSince(start)
+            // Race guard: the timeout timer may kill the process just before the
+            // exit code arrives. Key off the explicit kill flag so a completed
+            // process is not misclassified when the awaiting task resumes late.
+            if killedByTimeout.isSet {
+                self.log.warning(
+                    "Subprocess timed out",
+                    metadata: [
+                        "label": label,
+                        "binary": binaryName,
+                        "duration_ms": "\(Int(duration * 1000))",
+                    ])
+                throw SubprocessRunnerError.timedOut(label)
+            }
+
+            async let stdoutData = stdoutCapture.finish(timeout: .seconds(1))
+            async let stderrData = stderrCapture.finish(timeout: .seconds(1))
+            let stdout = await ProcessPipeCapture.decodeUTF8(stdoutData)
+            let stderr = await ProcessPipeCapture.decodeUTF8(stderrData)
 
             if exitCode != 0 {
                 let duration = Date().timeIntervalSince(start)
@@ -123,7 +262,6 @@ public enum SubprocessRunner {
                 throw SubprocessRunnerError.nonZeroExit(code: exitCode, stderr: stderr)
             }
 
-            let duration = Date().timeIntervalSince(start)
             self.log.debug(
                 "Subprocess exit",
                 metadata: [
@@ -142,27 +280,11 @@ public enum SubprocessRunner {
                     "binary": binaryName,
                     "duration_ms": "\(Int(duration * 1000))",
                 ])
-            if process.isRunning {
-                process.terminate()
-                if let pgid = processGroup {
-                    kill(-pgid, SIGTERM)
-                }
-                let killDeadline = Date().addingTimeInterval(0.4)
-                while process.isRunning, Date() < killDeadline {
-                    usleep(50000)
-                }
-                if process.isRunning {
-                    if let pgid = processGroup {
-                        kill(-pgid, SIGKILL)
-                    }
-                    kill(process.processIdentifier, SIGKILL)
-                }
-            }
+            // Safety net: ensure the process is dead (may already be killed by timeout timer).
+            self.terminateProcess(process, processGroup: processGroup)
             exitCodeTask.cancel()
-            stdoutTask.cancel()
-            stderrTask.cancel()
-            stdoutPipe.fileHandleForReading.closeFile()
-            stderrPipe.fileHandleForReading.closeFile()
+            stdoutCapture.stop()
+            stderrCapture.stop()
             throw error
         }
     }
diff --git a/Sources/CodexBarCore/KeychainAccessGate.swift b/Sources/CodexBarCore/KeychainAccessGate.swift
index 6984d6280f..0e44c5f0fe 100644
--- a/Sources/CodexBarCore/KeychainAccessGate.swift
+++ b/Sources/CodexBarCore/KeychainAccessGate.swift
@@ -5,18 +5,23 @@ import SweetCookieKit
 
 public enum KeychainAccessGate {
     private static let flagKey = "debugDisableKeychainAccess"
-    private static let appGroupID = "group.com.steipete.codexbar"
     @TaskLocal private static var taskOverrideValue: Bool?
     private nonisolated(unsafe) static var overrideValue: Bool?
+    private static let processForceDisabledLock = NSLock()
+    private nonisolated(unsafe) static var processForceDisabledReason: String?
 
     public nonisolated(unsafe) static var isDisabled: Bool {
         get {
             if let taskOverrideValue { return taskOverrideValue }
+            #if DEBUG
+            if Self.forcesDisabledUnderTests {
+                return true
+            }
+            #endif
+            if self.processDisableReason != nil { return true }
             if let overrideValue { return overrideValue }
             if UserDefaults.standard.bool(forKey: Self.flagKey) { return true }
-            if let shared = UserDefaults(suiteName: Self.appGroupID),
-               shared.bool(forKey: Self.flagKey)
-            {
+            if let shared = AppGroupSupport.sharedDefaults(), shared.bool(forKey: Self.flagKey) {
                 return true
             }
             return false
@@ -24,11 +29,40 @@ public enum KeychainAccessGate {
         set {
             overrideValue = newValue
             #if os(macOS) && canImport(SweetCookieKit)
-            BrowserCookieKeychainAccessGate.isDisabled = newValue
+            BrowserCookieKeychainAccessGate.isDisabled = self.isDisabled
             #endif
         }
     }
 
+    public static func forceDisabledForProcess(reason: String) {
+        self.processForceDisabledLock.lock()
+        self.processForceDisabledReason = reason
+        self.processForceDisabledLock.unlock()
+        #if os(macOS) && canImport(SweetCookieKit)
+        BrowserCookieKeychainAccessGate.isDisabled = self.isDisabled
+        #endif
+    }
+
+    public static var processDisableReason: String? {
+        self.processForceDisabledLock.lock()
+        defer { self.processForceDisabledLock.unlock() }
+        return self.processForceDisabledReason
+    }
+
+    #if DEBUG
+    private nonisolated(unsafe) static var forcesDisabledUnderTests: Bool {
+        self.isRunningUnderTests
+            && ProcessInfo.processInfo.environment["CODEXBAR_ALLOW_TEST_KEYCHAIN_ACCESS"] != "1"
+    }
+
+    private nonisolated(unsafe) static var isRunningUnderTests: Bool {
+        let processName = ProcessInfo.processInfo.processName
+        return processName == "swiftpm-testing-helper"
+            || processName.hasSuffix("PackageTests")
+            || ProcessInfo.processInfo.environment["XCTestConfigurationFilePath"] != nil
+    }
+    #endif
+
     static func withTaskOverrideForTesting<T>(
         _ disabled: Bool?,
         operation: () throws -> T) rethrows -> T
@@ -46,4 +80,20 @@ public enum KeychainAccessGate {
             try await operation()
         }
     }
+
+    static var currentOverrideForTesting: Bool? {
+        self.taskOverrideValue ?? self.overrideValue
+    }
+
+    #if DEBUG
+    static func resetOverrideForTesting() {
+        self.overrideValue = nil
+        self.processForceDisabledLock.lock()
+        self.processForceDisabledReason = nil
+        self.processForceDisabledLock.unlock()
+        #if os(macOS) && canImport(SweetCookieKit)
+        BrowserCookieKeychainAccessGate.isDisabled = self.isDisabled
+        #endif
+    }
+    #endif
 }
diff --git a/Sources/CodexBarCore/KeychainAccessPreflight.swift b/Sources/CodexBarCore/KeychainAccessPreflight.swift
index 0ca26604ee..9c335d76c5 100644
--- a/Sources/CodexBarCore/KeychainAccessPreflight.swift
+++ b/Sources/CodexBarCore/KeychainAccessPreflight.swift
@@ -134,19 +134,7 @@ public enum KeychainAccessPreflight {
         }
         #endif
         guard !KeychainAccessGate.isDisabled else { return .notFound }
-        var query: [String: Any] = [
-            kSecClass as String: kSecClassGenericPassword,
-            kSecAttrService as String: service,
-            kSecMatchLimit as String: kSecMatchLimitOne,
-            // Preflight should never trigger UI. Avoid requesting the secret payload (`kSecReturnData`) because
-            // some macOS configurations have been observed to show the legacy keychain prompt even when
-            // `kSecUseAuthenticationUIFail` is set.
-            kSecReturnAttributes as String: true,
-        ]
-        KeychainNoUIQuery.apply(to: &query)
-        if let account {
-            query[kSecAttrAccount as String] = account
-        }
+        let query = self.makeGenericPasswordPreflightQuery(service: service, account: account)
 
         var result: AnyObject?
         let status = SecItemCopyMatching(query as CFDictionary, &result)
@@ -174,4 +162,23 @@ public enum KeychainAccessPreflight {
         return .notFound
         #endif
     }
+
+    #if os(macOS)
+    static func makeGenericPasswordPreflightQuery(service: String, account: String?) -> [String: Any] {
+        var query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: service,
+            kSecMatchLimit as String: kSecMatchLimitOne,
+            // Preflight should never trigger UI. Avoid requesting the secret payload (`kSecReturnData`) because
+            // some macOS configurations have been observed to show the legacy keychain prompt unless the query
+            // is strictly non-interactive.
+            kSecReturnAttributes as String: true,
+        ]
+        KeychainNoUIQuery.apply(to: &query)
+        if let account {
+            query[kSecAttrAccount as String] = account
+        }
+        return query
+    }
+    #endif
 }
diff --git a/Sources/CodexBarCore/KeychainCacheStore.swift b/Sources/CodexBarCore/KeychainCacheStore.swift
index 563e07343a..c43f02e111 100644
--- a/Sources/CodexBarCore/KeychainCacheStore.swift
+++ b/Sources/CodexBarCore/KeychainCacheStore.swift
@@ -1,5 +1,6 @@
 import Foundation
 #if os(macOS)
+import Darwin
 import Security
 #endif
 
@@ -21,14 +22,33 @@ public enum KeychainCacheStore {
     public enum LoadResult<Entry> {
         case found(Entry)
         case missing
+        case temporarilyUnavailable
         case invalid
     }
 
+    public enum ClearResult: Equatable, Sendable {
+        case removed
+        case missing
+        case failed
+    }
+
+    public enum KeysResult: Equatable, Sendable {
+        case found([Key])
+        case temporarilyUnavailable
+        case failed
+    }
+
     private static let log = CodexBarLog.logger(LogCategories.keychainCache)
     private static let cacheService = "com.steipete.codexbar.cache"
     private static let cacheLabel = "CodexBar Cache"
     private nonisolated(unsafe) static var globalServiceOverride: String?
     @TaskLocal private static var serviceOverride: String?
+    #if DEBUG && os(macOS)
+    @TaskLocal private static var loadFailureStatusOverride: OSStatus?
+    @TaskLocal private static var storeFailureStatusOverride: OSStatus?
+    @TaskLocal private static var clearFailureStatusOverride: OSStatus?
+    @TaskLocal private static var keysFailureStatusOverride: OSStatus?
+    #endif
     private static let testStoreLock = NSLock()
     private struct TestStoreKey: Hashable {
         let service: String
@@ -36,23 +56,31 @@ public enum KeychainCacheStore {
     }
 
     private nonisolated(unsafe) static var testStore: [TestStoreKey: Data]?
+    private nonisolated(unsafe) static var implicitTestStore: [TestStoreKey: Data] = [:]
     private nonisolated(unsafe) static var testStoreRefCount = 0
 
     public static func load<Entry: Codable>(
         key: Key,
         as type: Entry.Type = Entry.self) -> LoadResult<Entry>
     {
+        #if DEBUG && os(macOS)
+        if let status = self.loadFailureStatusOverride {
+            return self.loadResultForKeychainReadFailure(status: status, key: key)
+        }
+        #endif
         if let testResult = loadFromTestStore(key: key, as: type) {
             return testResult
         }
+        guard self.canUseRealKeychain else { return .missing }
         #if os(macOS)
-        let query: [String: Any] = [
+        var query: [String: Any] = [
             kSecClass as String: kSecClassGenericPassword,
             kSecAttrService as String: self.serviceName,
             kSecAttrAccount as String: key.account,
             kSecMatchLimit as String: kSecMatchLimitOne,
             kSecReturnData as String: true,
         ]
+        KeychainNoUIQuery.apply(to: &query)
 
         var result: AnyObject?
         let status = SecItemCopyMatching(query as CFDictionary, &result)
@@ -68,11 +96,8 @@ public enum KeychainCacheStore {
                 return .invalid
             }
             return .found(decoded)
-        case errSecItemNotFound:
-            return .missing
         default:
-            self.log.error("Keychain cache read failed (\(key.account)): \(status)")
-            return .invalid
+            return self.loadResultForKeychainReadFailure(status: status, key: key)
         }
         #else
         return .missing
@@ -80,68 +105,133 @@ public enum KeychainCacheStore {
     }
 
     public static func store(key: Key, entry: some Codable) {
-        if self.storeInTestStore(key: key, entry: entry) {
-            return
+        _ = self.storeResult(key: key, entry: entry)
+    }
+
+    @discardableResult
+    public static func storeResult(key: Key, entry: some Codable) -> Bool {
+        #if DEBUG && os(macOS)
+        if let status = self.storeFailureStatusOverride {
+            self.log.error("Keychain cache store failed (\(key.account)): \(status)")
+            return false
+        }
+        #endif
+        if let stored = self.storeInTestStore(key: key, entry: entry) {
+            return stored
         }
+        guard self.canUseRealKeychain else { return false }
         #if os(macOS)
         let encoder = Self.makeEncoder()
         guard let data = try? encoder.encode(entry) else {
             self.log.error("Failed to encode keychain cache (\(key.account))")
-            return
+            return false
         }
 
-        let query: [String: Any] = [
+        var query: [String: Any] = [
             kSecClass as String: kSecClassGenericPassword,
             kSecAttrService as String: self.serviceName,
             kSecAttrAccount as String: key.account,
         ]
-        let updateAttrs: [String: Any] = [
-            kSecValueData as String: data,
-        ]
+        KeychainNoUIQuery.apply(to: &query)
 
-        let updateStatus = SecItemUpdate(query as CFDictionary, updateAttrs as CFDictionary)
+        let updateStatus = SecItemUpdate(
+            query as CFDictionary,
+            [kSecValueData as String: data] as CFDictionary)
         if updateStatus == errSecSuccess {
-            return
+            return true
         }
         if updateStatus != errSecItemNotFound {
             self.log.error("Keychain cache update failed (\(key.account)): \(updateStatus)")
-            return
+            return false
         }
 
         var addQuery = query
         addQuery[kSecValueData as String] = data
         addQuery[kSecAttrLabel as String] = self.cacheLabel
         addQuery[kSecAttrAccessible as String] = kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly
+        if let access = self.cacheAccessControl() {
+            addQuery[kSecAttrAccess as String] = access
+        }
 
         let addStatus = SecItemAdd(addQuery as CFDictionary, nil)
         if addStatus != errSecSuccess {
             self.log.error("Keychain cache add failed (\(key.account)): \(addStatus)")
         }
+        return addStatus == errSecSuccess
+        #else
+        return false
         #endif
     }
 
-    public static func clear(key: Key) {
-        if self.clearTestStore(key: key) {
-            return
+    @discardableResult
+    public static func clear(key: Key) -> Bool {
+        self.clearResult(key: key) == .removed
+    }
+
+    public static func clearResult(key: Key) -> ClearResult {
+        #if DEBUG && os(macOS)
+        if let status = self.clearFailureStatusOverride {
+            return self.clearResultForKeychainDeleteStatus(status, key: key)
         }
+        #endif
+        if let removed = self.clearTestStore(key: key) {
+            return removed ? .removed : .missing
+        }
+        guard self.canUseRealKeychain else { return .failed }
         #if os(macOS)
-        let query: [String: Any] = [
+        var query: [String: Any] = [
             kSecClass as String: kSecClassGenericPassword,
             kSecAttrService as String: self.serviceName,
             kSecAttrAccount as String: key.account,
         ]
-        let status = SecItemDelete(query as CFDictionary)
-        if status != errSecSuccess, status != errSecItemNotFound {
-            self.log.error("Keychain cache delete failed (\(key.account)): \(status)")
+        KeychainNoUIQuery.apply(to: &query)
+        return self.clearResultForKeychainDeleteStatus(SecItemDelete(query as CFDictionary), key: key)
+        #else
+        return .failed
+        #endif
+    }
+
+    public static func keys(category: String) -> [Key] {
+        switch self.keysResult(category: category) {
+        case let .found(keys):
+            keys
+        case .temporarilyUnavailable, .failed:
+            []
+        }
+    }
+
+    public static func keysResult(category: String) -> KeysResult {
+        #if DEBUG && os(macOS)
+        if let status = self.keysFailureStatusOverride {
+            return self.keysResultForKeychainStatus(status, category: category, result: nil)
         }
         #endif
+        if let keys = self.keysFromTestStore(category: category) {
+            return .found(keys)
+        }
+        guard self.canUseRealKeychain else { return .failed }
+        #if os(macOS)
+        var query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: self.serviceName,
+            kSecMatchLimit as String: kSecMatchLimitAll,
+            kSecReturnAttributes as String: true,
+        ]
+        KeychainNoUIQuery.apply(to: &query)
+
+        var result: AnyObject?
+        let status = SecItemCopyMatching(query as CFDictionary, &result)
+        return self.keysResultForKeychainStatus(status, category: category, result: result)
+        #else
+        return .failed
+        #endif
     }
 
     static func setServiceOverrideForTesting(_ service: String?) {
         self.globalServiceOverride = service
     }
 
-    static func withServiceOverrideForTesting<T>(
+    public static func withServiceOverrideForTesting<T>(
         _ service: String?,
         operation: () throws -> T) rethrows -> T
     {
@@ -150,7 +240,7 @@ public enum KeychainCacheStore {
         }
     }
 
-    static func withServiceOverrideForTesting<T>(
+    public static func withServiceOverrideForTesting<T>(
         _ service: String?,
         operation: () async throws -> T) async rethrows -> T
     {
@@ -159,6 +249,74 @@ public enum KeychainCacheStore {
         }
     }
 
+    public static func withCurrentServiceOverrideForTesting<T>(
+        operation: () async throws -> T) async rethrows -> T
+    {
+        let service = self.serviceOverride
+        return try await self.$serviceOverride.withValue(service) {
+            try await operation()
+        }
+    }
+
+    public static var currentServiceOverrideForTesting: String? {
+        self.serviceOverride
+    }
+
+    static var canUseRealKeychainForTesting: Bool {
+        self.canUseRealKeychain
+    }
+
+    static var canEnumerateOrDeleteRealKeychainForTesting: Bool {
+        self.canUseRealKeychain
+    }
+
+    #if DEBUG && os(macOS)
+    public static func withLoadFailureStatusOverrideForTesting<T>(
+        _ status: OSStatus?,
+        operation: () throws -> T) rethrows -> T
+    {
+        try self.$loadFailureStatusOverride.withValue(status) {
+            try operation()
+        }
+    }
+
+    public static func withStoreFailureStatusOverrideForTesting<T>(
+        _ status: OSStatus?,
+        operation: () throws -> T) rethrows -> T
+    {
+        try self.$storeFailureStatusOverride.withValue(status) {
+            try operation()
+        }
+    }
+
+    public static func withClearFailureStatusOverrideForTesting<T>(
+        _ status: OSStatus?,
+        operation: () throws -> T) rethrows -> T
+    {
+        try self.$clearFailureStatusOverride.withValue(status) {
+            try operation()
+        }
+    }
+
+    public static func withClearFailureStatusOverrideForTesting<T>(
+        _ status: OSStatus?,
+        operation: () async throws -> T) async rethrows -> T
+    {
+        try await self.$clearFailureStatusOverride.withValue(status) {
+            try await operation()
+        }
+    }
+
+    public static func withKeysFailureStatusOverrideForTesting<T>(
+        _ status: OSStatus?,
+        operation: () throws -> T) rethrows -> T
+    {
+        try self.$keysFailureStatusOverride.withValue(status) {
+            try operation()
+        }
+    }
+    #endif
+
     static func setTestStoreForTesting(_ enabled: Bool) {
         self.testStoreLock.lock()
         defer { self.testStoreLock.unlock() }
@@ -179,6 +337,27 @@ public enum KeychainCacheStore {
         serviceOverride ?? self.globalServiceOverride ?? self.cacheService
     }
 
+    private static var canUseRealKeychain: Bool {
+        !KeychainAccessGate.isDisabled
+    }
+
+    #if DEBUG
+    private static var shouldUseImplicitTestStore: Bool {
+        self.isRunningUnderTests && !self.canUseRealKeychain
+    }
+
+    private static var isRunningUnderTests: Bool {
+        let processName = ProcessInfo.processInfo.processName
+        return processName == "swiftpm-testing-helper"
+            || processName.hasSuffix("PackageTests")
+            || ProcessInfo.processInfo.environment["XCTestConfigurationFilePath"] != nil
+    }
+    #else
+    private static var shouldUseImplicitTestStore: Bool {
+        false
+    }
+    #endif
+
     private static func makeEncoder() -> JSONEncoder {
         let encoder = JSONEncoder()
         encoder.dateEncodingStrategy = .iso8601
@@ -191,13 +370,171 @@ public enum KeychainCacheStore {
         return decoder
     }
 
+    #if os(macOS)
+    static func loadResultForKeychainReadFailure<Entry>(
+        status: OSStatus,
+        key: Key) -> LoadResult<Entry>
+    {
+        switch status {
+        case errSecItemNotFound:
+            return .missing
+        case errSecInteractionNotAllowed:
+            // Keychain is temporarily locked, e.g. immediately after wake from sleep.
+            self.log.info("Keychain cache temporarily locked (\(key.account)), will retry on next access")
+            return .temporarilyUnavailable
+        default:
+            self.log.error("Keychain cache read failed (\(key.account)): \(status)")
+            return .invalid
+        }
+    }
+
+    static func clearResultForKeychainDeleteStatus(_ status: OSStatus, key: Key) -> ClearResult {
+        switch status {
+        case errSecSuccess:
+            return .removed
+        case errSecItemNotFound:
+            return .missing
+        case errSecInteractionNotAllowed:
+            self.log.info("Keychain cache delete temporarily unavailable (\(key.account))")
+            return .failed
+        default:
+            self.log.error("Keychain cache delete failed (\(key.account)): \(status)")
+            return .failed
+        }
+    }
+
+    private static func keysResultForKeychainStatus(
+        _ status: OSStatus,
+        category: String,
+        result: AnyObject?) -> KeysResult
+    {
+        switch status {
+        case errSecSuccess:
+            guard let rows = result as? [[String: Any]] else { return .failed }
+            let keys: [Key] = rows.compactMap { row in
+                guard let account = row[kSecAttrAccount as String] as? String else { return nil }
+                return self.key(fromAccount: account, category: category)
+            }
+            return .found(keys)
+        case errSecItemNotFound:
+            return .found([])
+        case errSecInteractionNotAllowed:
+            self.log.info("Keychain cache keys temporarily unavailable (\(category))")
+            return .temporarilyUnavailable
+        default:
+            self.log.error("Keychain cache key listing failed (\(category)): \(status)")
+            return .failed
+        }
+    }
+
+    static func trustedApplicationPathsForCacheAccess(
+        bundleURL: URL = Bundle.main.bundleURL,
+        executableURL: URL? = Bundle.main.executableURL,
+        fileExists: (String) -> Bool = { FileManager.default.fileExists(atPath: $0) }) -> [String]
+    {
+        var paths: [String] = []
+        func append(_ path: String) {
+            guard !path.isEmpty, fileExists(path), !paths.contains(path) else { return }
+            paths.append(path)
+        }
+
+        let appBundle = self.appBundleURL(containing: bundleURL)
+            ?? executableURL.flatMap(self.appBundleURL(containing:))
+        if let appBundle {
+            append(appBundle.path)
+            append(appBundle.appendingPathComponent("Contents/Helpers/CodexBarCLI").path)
+        }
+        if let executableURL {
+            append(executableURL.path)
+        }
+        return paths
+    }
+
+    private static func appBundleURL(containing url: URL) -> URL? {
+        var current = url.standardizedFileURL
+        while current.path != "/" {
+            if current.pathExtension == "app" {
+                return current
+            }
+            current.deleteLastPathComponent()
+        }
+        return nil
+    }
+
+    private static func cacheAccessControl() -> SecAccess? {
+        let trustedPaths = self.trustedApplicationPathsForCacheAccess()
+        guard !trustedPaths.isEmpty else { return nil }
+
+        var trustedApplications: [SecTrustedApplication] = []
+        for path in trustedPaths {
+            let (status, application) = self.createTrustedApplication(path: path)
+            if status == errSecSuccess, let application {
+                trustedApplications.append(application)
+            } else {
+                self.log.error("Keychain cache trusted app creation failed (\(path)): \(status)")
+            }
+        }
+        guard !trustedApplications.isEmpty else { return nil }
+
+        let (status, access) = self.createAccessControl(trustedApplications: trustedApplications)
+        if status != errSecSuccess {
+            self.log.error("Keychain cache access control creation failed: \(status)")
+            return nil
+        }
+        return access
+    }
+
+    private typealias SecTrustedApplicationCreateFromPathFunction = @convention(c) (
+        UnsafePointer<CChar>?,
+        UnsafeMutablePointer<SecTrustedApplication?>?) -> OSStatus
+    private typealias SecAccessCreateFunction = @convention(c) (
+        CFString,
+        CFArray,
+        UnsafeMutablePointer<SecAccess?>?) -> OSStatus
+
+    private static func createTrustedApplication(path: String) -> (OSStatus, SecTrustedApplication?) {
+        guard let symbol = self.securitySymbol(named: "SecTrustedApplicationCreateFromPath") else {
+            return (errSecInternalComponent, nil)
+        }
+        let function = unsafeBitCast(symbol, to: SecTrustedApplicationCreateFromPathFunction.self)
+        var application: SecTrustedApplication?
+        let status = path.withCString { cPath in
+            function(cPath, &application)
+        }
+        return (status, application)
+    }
+
+    private static func createAccessControl(trustedApplications: [SecTrustedApplication]) -> (OSStatus, SecAccess?) {
+        guard let symbol = self.securitySymbol(named: "SecAccessCreate") else {
+            return (errSecInternalComponent, nil)
+        }
+        let function = unsafeBitCast(symbol, to: SecAccessCreateFunction.self)
+        var access: SecAccess?
+        let status = function(self.cacheLabel as CFString, trustedApplications as CFArray, &access)
+        return (status, access)
+    }
+
+    private nonisolated(unsafe) static let securityFrameworkHandle: UnsafeMutableRawPointer? = {
+        let securityPath = "/System/Library/Frameworks/Security.framework/Security"
+        return dlopen(securityPath, RTLD_NOW)
+    }()
+
+    private static func securitySymbol(named name: String) -> UnsafeMutableRawPointer? {
+        // Resolve deprecated SecKeychain ACL helpers at runtime so release builds stay warning-free
+        // while still granting the app bundle and bundled CLI prompt-free access to cache entries.
+        guard let securityFrameworkHandle else { return nil }
+        return dlsym(securityFrameworkHandle, name)
+    }
+    #endif
+
     private static func loadFromTestStore<Entry: Codable>(
         key: Key,
         as type: Entry.Type) -> LoadResult<Entry>?
     {
         self.testStoreLock.lock()
         defer { self.testStoreLock.unlock() }
-        guard let store = self.testStore else { return nil }
+        guard let store = self.testStore ?? (self.shouldUseImplicitTestStore ? self.implicitTestStore : nil)
+        else { return nil }
         let testKey = TestStoreKey(service: self.serviceName, account: key.account)
         guard let data = store[testKey] else { return .missing }
         let decoder = Self.makeDecoder()
@@ -207,32 +544,67 @@ public enum KeychainCacheStore {
         return .found(decoded)
     }
 
-    private static func storeInTestStore(key: Key, entry: some Codable) -> Bool {
+    private static func storeInTestStore(key: Key, entry: some Codable) -> Bool? {
         self.testStoreLock.lock()
         defer { self.testStoreLock.unlock() }
-        guard var store = self.testStore else { return false }
         let encoder = Self.makeEncoder()
-        guard let data = try? encoder.encode(entry) else { return true }
+        guard let data = try? encoder.encode(entry) else { return false }
         let testKey = TestStoreKey(service: self.serviceName, account: key.account)
-        store[testKey] = data
-        self.testStore = store
-        return true
+        if var store = self.testStore {
+            store[testKey] = data
+            self.testStore = store
+            return true
+        }
+        if self.shouldUseImplicitTestStore {
+            self.implicitTestStore[testKey] = data
+            return true
+        }
+        return nil
     }
 
-    private static func clearTestStore(key: Key) -> Bool {
+    private static func clearTestStore(key: Key) -> Bool? {
         self.testStoreLock.lock()
         defer { self.testStoreLock.unlock() }
-        guard var store = self.testStore else { return false }
         let testKey = TestStoreKey(service: self.serviceName, account: key.account)
-        store.removeValue(forKey: testKey)
-        self.testStore = store
-        return true
+        if var store = self.testStore {
+            let removed = store.removeValue(forKey: testKey) != nil
+            self.testStore = store
+            return removed
+        }
+        if self.shouldUseImplicitTestStore {
+            return self.implicitTestStore.removeValue(forKey: testKey) != nil
+        }
+        return nil
+    }
+
+    private static func keysFromTestStore(category: String) -> [Key]? {
+        self.testStoreLock.lock()
+        defer { self.testStoreLock.unlock() }
+        guard let store = self.testStore ?? (self.shouldUseImplicitTestStore ? self.implicitTestStore : nil)
+        else { return nil }
+        return store.keys
+            .filter { $0.service == self.serviceName }
+            .compactMap { self.key(fromAccount: $0.account, category: category) }
+            .sorted { $0.identifier < $1.identifier }
+    }
+
+    private static func key(fromAccount account: String, category: String) -> Key? {
+        let prefix = "\(category)."
+        guard account.hasPrefix(prefix) else { return nil }
+        let identifier = String(account.dropFirst(prefix.count))
+        guard !identifier.isEmpty else { return nil }
+        return Key(category: category, identifier: identifier)
     }
 }
 
 extension KeychainCacheStore.Key {
-    public static func cookie(provider: UsageProvider) -> Self {
-        Self(category: "cookie", identifier: provider.rawValue)
+    public static func cookie(provider: UsageProvider, scopeIdentifier: String? = nil) -> Self {
+        let identifier: String = if let scopeIdentifier, !scopeIdentifier.isEmpty {
+            "\(provider.rawValue).\(scopeIdentifier)"
+        } else {
+            provider.rawValue
+        }
+        return Self(category: "cookie", identifier: identifier)
     }
 
     public static func oauth(provider: UsageProvider) -> Self {
diff --git a/Sources/CodexBarCore/KeychainNoUIQuery.swift b/Sources/CodexBarCore/KeychainNoUIQuery.swift
index 29ef456a74..58df3e0855 100644
--- a/Sources/CodexBarCore/KeychainNoUIQuery.swift
+++ b/Sources/CodexBarCore/KeychainNoUIQuery.swift
@@ -1,19 +1,41 @@
 import Foundation
 
 #if os(macOS)
+import Darwin
 import LocalAuthentication
 import Security
 
 enum KeychainNoUIQuery {
+    private static let uiFailPolicy = KeychainNoUIQuery.resolveUIFailPolicy()
+
     static func apply(to query: inout [String: Any]) {
         let context = LAContext()
         context.interactionNotAllowed = true
         query[kSecUseAuthenticationContext as String] = context
 
-        // NOTE: While Apple recommends using LAContext.interactionNotAllowed, that alone is not sufficient to
-        // prevent the legacy keychain "Allow/Deny" prompt on some configurations. We also set the UI policy to fail
-        // so SecItemCopyMatching returns errSecInteractionNotAllowed instead of showing UI.
-        query[kSecUseAuthenticationUI as String] = kSecUseAuthenticationUIFail
+        // Keep explicit UI-fail policy for legacy keychain behavior on macOS where
+        // `interactionNotAllowed` alone can still surface Allow/Deny prompts.
+        query[kSecUseAuthenticationUI as String] = self.uiFailPolicy as CFString
+    }
+
+    static func uiFailPolicyForTesting() -> String {
+        self.uiFailPolicy
+    }
+
+    private static func resolveUIFailPolicy() -> String {
+        // Resolve the Security symbol at runtime to preserve the true constant value
+        // without directly referencing deprecated API at compile time.
+        let securityPath = "/System/Library/Frameworks/Security.framework/Security"
+        guard let handle = dlopen(securityPath, RTLD_NOW) else {
+            return "u_AuthUIF"
+        }
+        defer { dlclose(handle) }
+
+        guard let symbol = dlsym(handle, "kSecUseAuthenticationUIFail") else {
+            return "u_AuthUIF"
+        }
+        let valuePointer = symbol.assumingMemoryBound(to: CFString?.self)
+        return (valuePointer.pointee as String?) ?? "u_AuthUIF"
     }
 }
 #endif
diff --git a/Sources/CodexBarCore/Logging/CodexBarLog.swift b/Sources/CodexBarCore/Logging/CodexBarLog.swift
index 2f9db069c4..b8dc2ff4db 100644
--- a/Sources/CodexBarCore/Logging/CodexBarLog.swift
+++ b/Sources/CodexBarCore/Logging/CodexBarLog.swift
@@ -4,6 +4,7 @@ import Logging
 public enum CodexBarLog {
     public enum Destination: Sendable {
         case stderr
+        case discard
         case oslog(subsystem: String)
     }
 
@@ -85,6 +86,8 @@ public enum CodexBarLog {
             case .stderr:
                 if config.json { return JSONStderrLogHandler(label: label) }
                 return StreamLogHandler.standardError(label: label)
+            case .discard:
+                return DiscardLogHandler()
             case let .oslog(subsystem):
                 #if canImport(os)
                 return OSLogLogHandler(label: label, subsystem: subsystem)
@@ -108,15 +111,16 @@ public enum CodexBarLog {
 
     public static func logger(_ category: String) -> CodexBarLogger {
         let logger = Logger(label: "com.steipete.codexbar.\(category)")
-        return CodexBarLogger { level, message, metadata in
-            guard self.shouldLog(level) else { return }
+        return CodexBarLogger(isEnabled: { level in
+            self.shouldLog(level)
+        }, log: { level, message, metadata in
             let swiftLogLevel = level.asSwiftLogLevel
             let safeMessage = LogRedactor.redact(message)
             let meta = metadata?.reduce(into: Logger.Metadata()) { partial, entry in
                 partial[entry.key] = .string(LogRedactor.redact(entry.value))
             }
             logger.log(level: swiftLogLevel, "\(safeMessage)", metadata: meta)
-        }
+        })
     }
 
     public static func parseLevel(_ raw: String?) -> Level? {
@@ -154,38 +158,72 @@ public enum CodexBarLog {
     }
 }
 
+private struct DiscardLogHandler: LogHandler {
+    var metadata: Logger.Metadata = [:]
+    var logLevel: Logger.Level = .critical
+
+    subscript(metadataKey metadataKey: String) -> Logger.Metadata.Value? {
+        get { self.metadata[metadataKey] }
+        set { self.metadata[metadataKey] = newValue }
+    }
+
+    func log(event _: LogEvent) {}
+}
+
 public struct CodexBarLogger: Sendable {
+    private let isEnabled: @Sendable (CodexBarLog.Level) -> Bool
     private let logFn: @Sendable (CodexBarLog.Level, String, [String: String]?) -> Void
 
-    fileprivate init(_ logFn: @escaping @Sendable (CodexBarLog.Level, String, [String: String]?) -> Void) {
-        self.logFn = logFn
+    fileprivate init(
+        isEnabled: @escaping @Sendable (CodexBarLog.Level) -> Bool,
+        log: @escaping @Sendable (CodexBarLog.Level, String, [String: String]?) -> Void)
+    {
+        self.isEnabled = isEnabled
+        self.logFn = log
+    }
+
+    init(
+        minimumLevel: CodexBarLog.Level,
+        log: @escaping @Sendable (CodexBarLog.Level, String, [String: String]?) -> Void)
+    {
+        self.isEnabled = { level in level.rank >= minimumLevel.rank }
+        self.logFn = log
+    }
+
+    private func log(
+        _ level: CodexBarLog.Level,
+        _ message: @autoclosure () -> String,
+        metadata: [String: String]?)
+    {
+        guard self.isEnabled(level) else { return }
+        self.logFn(level, message(), metadata)
     }
 
     public func trace(_ message: @autoclosure () -> String, metadata: [String: String]? = nil) {
-        self.logFn(.trace, message(), metadata)
+        self.log(.trace, message(), metadata: metadata)
     }
 
     public func verbose(_ message: @autoclosure () -> String, metadata: [String: String]? = nil) {
-        self.logFn(.verbose, message(), metadata)
+        self.log(.verbose, message(), metadata: metadata)
     }
 
     public func debug(_ message: @autoclosure () -> String, metadata: [String: String]? = nil) {
-        self.logFn(.debug, message(), metadata)
+        self.log(.debug, message(), metadata: metadata)
     }
 
     public func info(_ message: @autoclosure () -> String, metadata: [String: String]? = nil) {
-        self.logFn(.info, message(), metadata)
+        self.log(.info, message(), metadata: metadata)
     }
 
     public func warning(_ message: @autoclosure () -> String, metadata: [String: String]? = nil) {
-        self.logFn(.warning, message(), metadata)
+        self.log(.warning, message(), metadata: metadata)
     }
 
     public func error(_ message: @autoclosure () -> String, metadata: [String: String]? = nil) {
-        self.logFn(.error, message(), metadata)
+        self.log(.error, message(), metadata: metadata)
     }
 
     public func critical(_ message: @autoclosure () -> String, metadata: [String: String]? = nil) {
-        self.logFn(.critical, message(), metadata)
+        self.log(.critical, message(), metadata: metadata)
     }
 }
diff --git a/Sources/CodexBarCore/Logging/CompositeLogHandler.swift b/Sources/CodexBarCore/Logging/CompositeLogHandler.swift
index f86aebc1c6..51f989ea1c 100644
--- a/Sources/CodexBarCore/Logging/CompositeLogHandler.swift
+++ b/Sources/CodexBarCore/Logging/CompositeLogHandler.swift
@@ -33,31 +33,8 @@ struct CompositeLogHandler: LogHandler {
         }
     }
 
-    // swiftlint:disable:next function_parameter_count
-    func log(
-        level: Logger.Level,
-        message: Logger.Message,
-        metadata: Logger.Metadata?,
-        source: String,
-        file: String,
-        function: String,
-        line: UInt)
-    {
-        self.primary.log(
-            level: level,
-            message: message,
-            metadata: metadata,
-            source: source,
-            file: file,
-            function: function,
-            line: line)
-        self.secondary.log(
-            level: level,
-            message: message,
-            metadata: metadata,
-            source: source,
-            file: file,
-            function: function,
-            line: line)
+    func log(event: LogEvent) {
+        self.primary.log(event: event)
+        self.secondary.log(event: event)
     }
 }
diff --git a/Sources/CodexBarCore/Logging/FileLogHandler.swift b/Sources/CodexBarCore/Logging/FileLogHandler.swift
index effe9ff5cc..f5a8f56814 100644
--- a/Sources/CodexBarCore/Logging/FileLogHandler.swift
+++ b/Sources/CodexBarCore/Logging/FileLogHandler.swift
@@ -39,6 +39,10 @@ final class FileLogSink: @unchecked Sendable {
         self.queue.sync { self.fileURL }
     }
 
+    func isWriteEnabled() -> Bool {
+        self.queue.sync { self.isEnabled }
+    }
+
     func write(_ text: String) {
         self.queue.async {
             guard self.isEnabled else { return }
@@ -103,19 +107,11 @@ struct FileLogHandler: LogHandler {
         set { self.metadata[metadataKey] = newValue }
     }
 
-    // swiftlint:disable:next function_parameter_count
-    func log(
-        level: Logger.Level,
-        message: Logger.Message,
-        metadata: Logger.Metadata?,
-        source: String,
-        file: String,
-        function: String,
-        line: UInt)
-    {
+    func log(event: LogEvent) {
+        guard self.sink.isWriteEnabled() else { return }
         let ts = Self.timestamp()
         var combined = self.metadata
-        if let metadata { combined.merge(metadata, uniquingKeysWith: { _, new in new }) }
+        if let metadata = event.metadata { combined.merge(metadata, uniquingKeysWith: { _, new in new }) }
         var metaText = ""
         if !combined.isEmpty {
             let pairs = combined
@@ -128,12 +124,12 @@ struct FileLogHandler: LogHandler {
                 .joined(separator: " ")
             metaText = " \(pairs)"
         }
-        let safeMessage = LogRedactor.redact("\(message)")
-        let lineText = "[\(ts)] [\(level.rawValue.uppercased())] \(self.label): \(safeMessage)\(metaText)\n"
-        _ = source
-        _ = file
-        _ = function
-        _ = line
+        let safeMessage = LogRedactor.redact("\(event.message)")
+        let lineText = "[\(ts)] [\(event.level.rawValue.uppercased())] \(self.label): \(safeMessage)\(metaText)\n"
+        _ = event.source
+        _ = event.file
+        _ = event.function
+        _ = event.line
         self.sink.write(lineText)
     }
 
diff --git a/Sources/CodexBarCore/Logging/JSONStderrLogHandler.swift b/Sources/CodexBarCore/Logging/JSONStderrLogHandler.swift
index 6c02e745e3..2caff24159 100644
--- a/Sources/CodexBarCore/Logging/JSONStderrLogHandler.swift
+++ b/Sources/CodexBarCore/Logging/JSONStderrLogHandler.swift
@@ -2,8 +2,10 @@ import Foundation
 import Logging
 #if canImport(Darwin)
 import Darwin
-#else
+#elseif canImport(Glibc)
 import Glibc
+#elseif canImport(Musl)
+import Musl
 #endif
 
 struct JSONStderrLogHandler: LogHandler {
@@ -25,29 +27,20 @@ struct JSONStderrLogHandler: LogHandler {
         set { self.metadata[metadataKey] = newValue }
     }
 
-    // swiftlint:disable:next function_parameter_count
-    func log(
-        level: Logger.Level,
-        message: Logger.Message,
-        metadata: Logger.Metadata?,
-        source: String,
-        file: String,
-        function: String,
-        line: UInt)
-    {
+    func log(event: LogEvent) {
         let ts = Date()
         var combined = self.metadata
-        if let metadata { combined.merge(metadata, uniquingKeysWith: { _, new in new }) }
+        if let metadata = event.metadata { combined.merge(metadata, uniquingKeysWith: { _, new in new }) }
 
         let payload = JSONLogLine(
             timestamp: ts,
-            level: level.rawValue,
+            level: event.level.rawValue,
             label: self.label,
-            message: message.description,
-            source: source,
-            file: file,
-            function: function,
-            line: line,
+            message: event.message.description,
+            source: event.source,
+            file: event.file,
+            function: event.function,
+            line: event.line,
             metadata: combined.isEmpty ? nil : combined.mapValues(\.description))
 
         guard let data = try? self.encoder.encode(payload),
diff --git a/Sources/CodexBarCore/Logging/LogCategories.swift b/Sources/CodexBarCore/Logging/LogCategories.swift
index 37a7726ef7..f0321295ec 100644
--- a/Sources/CodexBarCore/Logging/LogCategories.swift
+++ b/Sources/CodexBarCore/Logging/LogCategories.swift
@@ -1,23 +1,36 @@
 public enum LogCategories {
+    public static let abacusCookie = "abacus-cookie"
+    public static let abacusUsage = "abacus-usage"
     public static let amp = "amp"
     public static let antigravity = "antigravity"
     public static let app = "app"
     public static let auggieCLI = "auggie-cli"
     public static let augment = "augment"
     public static let augmentKeepalive = "augment-keepalive"
+    public static let bedrockUsage = "bedrock-usage"
     public static let browserCookieGate = "browser-cookie-gate"
     public static let claudeCLI = "claude-cli"
     public static let claudeProbe = "claude-probe"
     public static let claudeUsage = "claude-usage"
     public static let codexRPC = "codex-rpc"
+    public static let commandcodeCookie = "commandcode-cookie"
+    public static let commandcodeUsage = "commandcode-usage"
     public static let configMigration = "config-migration"
     public static let configStore = "config-store"
+    public static let confetti = "confetti"
     public static let cookieCache = "cookie-cache"
     public static let cookieHeaderStore = "cookie-header-store"
     public static let copilotTokenStore = "copilot-token-store"
     public static let creditsPurchase = "creditsPurchase"
     public static let cursorLogin = "cursor-login"
+    public static let deepSeekSettings = "deepseek-settings"
+    public static let deepSeekUsage = "deepseek-usage"
+    public static let deepgramUsage = "deepgram-usage"
+    public static let devin = "devin"
+    public static let doubaoUsage = "doubao-usage"
+    public static let elevenLabsUsage = "elevenlabs-usage"
     public static let geminiProbe = "gemini-probe"
+    public static let grok = "grok"
     public static let keychainCache = "keychain-cache"
     public static let keychainMigration = "keychain-migration"
     public static let keychainPreflight = "keychain-preflight"
@@ -32,33 +45,48 @@ public enum LogCategories {
     public static let launchAtLogin = "launch-at-login"
     public static let login = "login"
     public static let logging = "logging"
+    public static let manusAPI = "manus-api"
+    public static let manusCookie = "manus-cookie"
+    public static let manusWeb = "manus-web"
+    public static let memoryPressure = "memory-pressure"
     public static let minimaxAPITokenStore = "minimax-api-token-store"
     public static let minimaxCookie = "minimax-cookie"
     public static let minimaxCookieStore = "minimax-cookie-store"
     public static let minimaxUsage = "minimax-usage"
     public static let minimaxWeb = "minimax-web"
+    public static let moonshotUsage = "moonshot-usage"
     public static let notifications = "notifications"
     public static let openAIWeb = "openai-web"
     public static let openAIWebview = "openai-webview"
     public static let ollama = "ollama"
     public static let opencodeUsage = "opencode-usage"
+    public static let opencodeGoUsage = "opencode-go-usage"
     public static let openRouterUsage = "openrouter-usage"
+    public static let perplexityAPI = "perplexity-api"
+    public static let perplexityCookie = "perplexity-cookie"
+    public static let perplexityWeb = "perplexity-web"
+    public static let poeUsage = "poe-usage"
     public static let providerDetection = "provider-detection"
     public static let providers = "providers"
+    public static let quotaWarningNotifications = "quotaWarningNotifications"
     public static let sessionQuota = "sessionQuota"
     public static let sessionQuotaNotifications = "sessionQuotaNotifications"
     public static let settings = "settings"
     public static let subprocess = "subprocess"
     public static let syntheticTokenStore = "synthetic-token-store"
     public static let syntheticUsage = "synthetic-usage"
+    public static let t3chat = "t3chat"
     public static let terminal = "terminal"
     public static let tokenAccounts = "token-accounts"
     public static let tokenCost = "token-cost"
     public static let ttyRunner = "tty-runner"
+    public static let veniceUsage = "venice-usage"
     public static let vertexAIFetcher = "vertexai-fetcher"
     public static let warpUsage = "warp-usage"
+    public static let zed = "zed"
     public static let webkitTeardown = "webkit-teardown"
     public static let zaiSettings = "zai-settings"
     public static let zaiTokenStore = "zai-token-store"
     public static let zaiUsage = "zai-usage"
+    public static let stepfunUsage = "stepfun-usage"
 }
diff --git a/Sources/CodexBarCore/Logging/LogRedactor.swift b/Sources/CodexBarCore/Logging/LogRedactor.swift
index 02cf42c404..2fce2eaac6 100644
--- a/Sources/CodexBarCore/Logging/LogRedactor.swift
+++ b/Sources/CodexBarCore/Logging/LogRedactor.swift
@@ -18,16 +18,38 @@ public enum LogRedactor {
         pattern: #"(?i)(authorization\s*:\s*)([^\r\n]+)"#)
     private static let bearerRegex = Self.makeRegex(
         pattern: #"(?i)\bbearer\s+[a-z0-9._\-]+=*\b"#)
+    private static let minimaxCodingPlanTokenRegex = Self.makeRegex(
+        pattern: #"sk-cp-[^\s"'`;,)>\]]+"#)
+    private static let minimaxApiTokenRegex = Self.makeRegex(
+        pattern: #"sk-api-[^\s"'`;,)>\]]+"#)
 
     public static func redact(_ text: String) -> String {
+        guard self.mayContainSensitiveValue(text) else { return text }
+
         var output = text
+        // Email is broad and safe first
         output = self.replace(self.emailRegex, in: output, with: "<redacted-email>")
+        // MiniMax tokens before broader rules catch them
+        output = self.replace(self.minimaxCodingPlanTokenRegex, in: output, with: "<redacted-minimax-token>")
+        output = self.replace(self.minimaxApiTokenRegex, in: output, with: "<redacted-minimax-token>")
+        // Bearer catches "bearer <token>" before authorization wraps it
+        output = self.replace(self.bearerRegex, in: output, with: "Bearer <redacted>")
+        // Authorization catches the rest (already-redacted content)
         output = self.replace(self.cookieHeaderRegex, in: output, with: "$1<redacted>")
         output = self.replace(self.authorizationRegex, in: output, with: "$1<redacted>")
-        output = self.replace(self.bearerRegex, in: output, with: "Bearer <redacted>")
         return output
     }
 
+    private static func mayContainSensitiveValue(_ text: String) -> Bool {
+        if text.range(of: "@") != nil { return true }
+        if text.range(of: "sk-cp-", options: [.caseInsensitive]) != nil { return true }
+        if text.range(of: "sk-api-", options: [.caseInsensitive]) != nil { return true }
+        if text.range(of: "bearer", options: [.caseInsensitive]) != nil { return true }
+        if text.range(of: "cookie", options: [.caseInsensitive]) != nil { return true }
+        if text.range(of: "authorization", options: [.caseInsensitive]) != nil { return true }
+        return false
+    }
+
     private static func makeRegex(pattern: String, options: NSRegularExpression.Options = []) -> NSRegularExpression {
         (try? NSRegularExpression(pattern: pattern, options: options)) ?? self.fallbackRegex
     }
diff --git a/Sources/CodexBarCore/Logging/OSLogLogHandler.swift b/Sources/CodexBarCore/Logging/OSLogLogHandler.swift
index 3a1b28754e..be0dc25094 100644
--- a/Sources/CodexBarCore/Logging/OSLogLogHandler.swift
+++ b/Sources/CodexBarCore/Logging/OSLogLogHandler.swift
@@ -23,24 +23,15 @@ struct OSLogLogHandler: LogHandler {
         set { self.metadata[metadataKey] = newValue }
     }
 
-    // swiftlint:disable:next function_parameter_count
-    func log(
-        level: Logging.Logger.Level,
-        message: Logging.Logger.Message,
-        metadata: Logging.Logger.Metadata?,
-        source: String,
-        file: String,
-        function: String,
-        line: UInt)
-    {
+    func log(event: LogEvent) {
         let msg = Self.decorate(
-            message: message.description,
+            message: event.message.description,
             label: self.label,
             subsystem: self.subsystem,
             metadata: self.metadata,
-            extraMetadata: metadata)
+            extraMetadata: event.metadata)
 
-        switch level {
+        switch event.level {
         case .trace:
             self.logger.debug("\(msg, privacy: .public)")
         case .debug:
diff --git a/Sources/CodexBarCore/ManagedCodexAccountStore.swift b/Sources/CodexBarCore/ManagedCodexAccountStore.swift
new file mode 100644
index 0000000000..060b303f43
--- /dev/null
+++ b/Sources/CodexBarCore/ManagedCodexAccountStore.swift
@@ -0,0 +1,115 @@
+import Foundation
+
+public enum FileManagedCodexAccountStoreError: Error, Equatable, Sendable {
+    case unsupportedVersion(Int)
+}
+
+public protocol ManagedCodexAccountStoring: Sendable {
+    func loadAccounts() throws -> ManagedCodexAccountSet
+    func storeAccounts(_ accounts: ManagedCodexAccountSet) throws
+    func ensureFileExists() throws -> URL
+}
+
+public struct FileManagedCodexAccountStore: ManagedCodexAccountStoring, @unchecked Sendable {
+    public static let currentVersion = 3
+
+    private let fileURL: URL
+    private let fileManager: FileManager
+
+    public init(fileURL: URL = Self.defaultURL(), fileManager: FileManager = .default) {
+        self.fileURL = fileURL
+        self.fileManager = fileManager
+    }
+
+    public func loadAccounts() throws -> ManagedCodexAccountSet {
+        guard self.fileManager.fileExists(atPath: self.fileURL.path) else {
+            return Self.emptyAccountSet()
+        }
+
+        let data = try Data(contentsOf: self.fileURL)
+        let decoder = JSONDecoder()
+        let accounts = try decoder.decode(ManagedCodexAccountSet.self, from: data)
+        guard (1...Self.currentVersion).contains(accounts.version) else {
+            throw FileManagedCodexAccountStoreError.unsupportedVersion(accounts.version)
+        }
+        if accounts.version == Self.currentVersion {
+            return ManagedCodexAccountSet(version: Self.currentVersion, accounts: accounts.accounts)
+        }
+        return self.migrateLegacyAccounts(accounts)
+    }
+
+    public func storeAccounts(_ accounts: ManagedCodexAccountSet) throws {
+        let normalizedAccounts = ManagedCodexAccountSet(
+            version: Self.currentVersion,
+            accounts: accounts.accounts)
+        let encoder = JSONEncoder()
+        encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
+        let data = try encoder.encode(normalizedAccounts)
+        let directory = self.fileURL.deletingLastPathComponent()
+        if !self.fileManager.fileExists(atPath: directory.path) {
+            try self.fileManager.createDirectory(at: directory, withIntermediateDirectories: true)
+        }
+        try data.write(to: self.fileURL, options: [.atomic])
+        try self.applySecurePermissionsIfNeeded()
+    }
+
+    public func ensureFileExists() throws -> URL {
+        if self.fileManager.fileExists(atPath: self.fileURL.path) { return self.fileURL }
+        try self.storeAccounts(Self.emptyAccountSet())
+        return self.fileURL
+    }
+
+    private func applySecurePermissionsIfNeeded() throws {
+        #if os(macOS)
+        try self.fileManager.setAttributes([
+            .posixPermissions: NSNumber(value: Int16(0o600)),
+        ], ofItemAtPath: self.fileURL.path)
+        #endif
+    }
+
+    private static func emptyAccountSet() -> ManagedCodexAccountSet {
+        ManagedCodexAccountSet(version: self.currentVersion, accounts: [])
+    }
+
+    private func migrateLegacyAccounts(_ accounts: ManagedCodexAccountSet) -> ManagedCodexAccountSet {
+        let migratedAccounts = accounts.accounts.map { account in
+            let hydratedProviderAccountID = account.providerAccountID ?? self.hydrateProviderAccountID(for: account)
+            return ManagedCodexAccount(
+                id: account.id,
+                email: account.email,
+                providerAccountID: hydratedProviderAccountID,
+                workspaceLabel: account.workspaceLabel,
+                workspaceAccountID: account.workspaceAccountID,
+                authFingerprint: account.authFingerprint ?? CodexAuthFingerprint.fingerprint(
+                    homePath: account.managedHomePath,
+                    fileManager: self.fileManager),
+                managedHomePath: account.managedHomePath,
+                createdAt: account.createdAt,
+                updatedAt: account.updatedAt,
+                lastAuthenticatedAt: account.lastAuthenticatedAt)
+        }
+        return ManagedCodexAccountSet(version: Self.currentVersion, accounts: migratedAccounts)
+    }
+
+    private func hydrateProviderAccountID(for account: ManagedCodexAccount) -> String? {
+        guard let credentials = try? CodexOAuthCredentialsStore.load(
+            env: ["CODEX_HOME": account.managedHomePath])
+        else {
+            return nil
+        }
+        let payload = credentials.idToken.flatMap(UsageFetcher.parseJWT)
+        let authDict = payload?["https://api.openai.com/auth"] as? [String: Any]
+        let providerAccountID = credentials.accountId
+            ?? (authDict?["chatgpt_account_id"] as? String)
+            ?? (payload?["chatgpt_account_id"] as? String)
+        return ManagedCodexAccount.normalizeProviderAccountID(providerAccountID)
+    }
+
+    public static func defaultURL() -> URL {
+        let base = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask).first
+            ?? FileManager.default.homeDirectoryForCurrentUser
+        return base
+            .appendingPathComponent("CodexBar", isDirectory: true)
+            .appendingPathComponent("managed-codex-accounts.json")
+    }
+}
diff --git a/Sources/CodexBarCore/OpenAIDashboardModels.swift b/Sources/CodexBarCore/OpenAIDashboardModels.swift
index 367223a96d..c070a7ee55 100644
--- a/Sources/CodexBarCore/OpenAIDashboardModels.swift
+++ b/Sources/CodexBarCore/OpenAIDashboardModels.swift
@@ -3,6 +3,7 @@ import Foundation
 public struct OpenAIDashboardSnapshot: Codable, Equatable, Sendable {
     public let signedInEmail: String?
     public let codeReviewRemainingPercent: Double?
+    public let codeReviewLimit: RateWindow?
     public let creditEvents: [CreditEvent]
     public let dailyBreakdown: [OpenAIDashboardDailyBreakdown]
     /// Usage breakdown time series from the Codex dashboard chart ("Usage breakdown", 30 days).
@@ -12,6 +13,9 @@ public struct OpenAIDashboardSnapshot: Codable, Equatable, Sendable {
     public let creditsPurchaseURL: String?
     public let primaryLimit: RateWindow?
     public let secondaryLimit: RateWindow?
+    /// Named model-specific limits (e.g. Codex Spark) decoded from the dashboard
+    /// `wham/usage` response's `additional_rate_limits` array.
+    public let extraRateWindows: [NamedRateWindow]?
     public let creditsRemaining: Double?
     public let accountPlan: String?
     public let updatedAt: Date
@@ -19,24 +23,28 @@ public struct OpenAIDashboardSnapshot: Codable, Equatable, Sendable {
     public init(
         signedInEmail: String?,
         codeReviewRemainingPercent: Double?,
+        codeReviewLimit: RateWindow? = nil,
         creditEvents: [CreditEvent],
         dailyBreakdown: [OpenAIDashboardDailyBreakdown],
         usageBreakdown: [OpenAIDashboardDailyBreakdown],
         creditsPurchaseURL: String?,
         primaryLimit: RateWindow? = nil,
         secondaryLimit: RateWindow? = nil,
+        extraRateWindows: [NamedRateWindow]? = nil,
         creditsRemaining: Double? = nil,
         accountPlan: String? = nil,
         updatedAt: Date)
     {
         self.signedInEmail = signedInEmail
         self.codeReviewRemainingPercent = codeReviewRemainingPercent
+        self.codeReviewLimit = codeReviewLimit
         self.creditEvents = creditEvents
         self.dailyBreakdown = dailyBreakdown
-        self.usageBreakdown = usageBreakdown
+        self.usageBreakdown = OpenAIDashboardDailyBreakdown.removingSkillUsageServices(from: usageBreakdown)
         self.creditsPurchaseURL = creditsPurchaseURL
         self.primaryLimit = primaryLimit
         self.secondaryLimit = secondaryLimit
+        self.extraRateWindows = extraRateWindows
         self.creditsRemaining = creditsRemaining
         self.accountPlan = accountPlan
         self.updatedAt = updatedAt
@@ -45,12 +53,14 @@ public struct OpenAIDashboardSnapshot: Codable, Equatable, Sendable {
     private enum CodingKeys: String, CodingKey {
         case signedInEmail
         case codeReviewRemainingPercent
+        case codeReviewLimit
         case creditEvents
         case dailyBreakdown
         case usageBreakdown
         case creditsPurchaseURL
         case primaryLimit
         case secondaryLimit
+        case extraRateWindows
         case creditsRemaining
         case accountPlan
         case updatedAt
@@ -62,17 +72,24 @@ public struct OpenAIDashboardSnapshot: Codable, Equatable, Sendable {
         self.codeReviewRemainingPercent = try container.decodeIfPresent(
             Double.self,
             forKey: .codeReviewRemainingPercent)
+        self.codeReviewLimit = try container.decodeIfPresent(RateWindow.self, forKey: .codeReviewLimit)
         self.creditEvents = try container.decodeIfPresent([CreditEvent].self, forKey: .creditEvents) ?? []
         self.dailyBreakdown = try container.decodeIfPresent(
             [OpenAIDashboardDailyBreakdown].self,
             forKey: .dailyBreakdown)
             ?? Self.makeDailyBreakdown(from: self.creditEvents, maxDays: 30)
-        self.usageBreakdown = try container.decodeIfPresent(
+        let decodedUsageBreakdown = try container.decodeIfPresent(
             [OpenAIDashboardDailyBreakdown].self,
             forKey: .usageBreakdown) ?? []
+        self.usageBreakdown = OpenAIDashboardDailyBreakdown.removingSkillUsageServices(
+            from: decodedUsageBreakdown)
         self.creditsPurchaseURL = try container.decodeIfPresent(String.self, forKey: .creditsPurchaseURL)
         self.primaryLimit = try container.decodeIfPresent(RateWindow.self, forKey: .primaryLimit)
         self.secondaryLimit = try container.decodeIfPresent(RateWindow.self, forKey: .secondaryLimit)
+        // Backward-compatible: older cached snapshots simply lack the key and decode to nil.
+        self.extraRateWindows = try container.decodeIfPresent(
+            [NamedRateWindow].self,
+            forKey: .extraRateWindows)
         self.creditsRemaining = try container.decodeIfPresent(Double.self, forKey: .creditsRemaining)
         self.accountPlan = try container.decodeIfPresent(String.self, forKey: .accountPlan)
         self.updatedAt = try container.decode(Date.self, forKey: .updatedAt)
@@ -115,21 +132,12 @@ extension OpenAIDashboardSnapshot {
         accountEmail: String? = nil,
         accountPlan: String? = nil) -> UsageSnapshot?
     {
-        guard let primaryLimit else { return nil }
-        let resolvedEmail = accountEmail ?? self.signedInEmail
-        let resolvedPlan = accountPlan ?? self.accountPlan
-        let identity = ProviderIdentitySnapshot(
-            providerID: provider,
-            accountEmail: resolvedEmail,
-            accountOrganization: nil,
-            loginMethod: resolvedPlan)
-        return UsageSnapshot(
-            primary: primaryLimit,
-            secondary: self.secondaryLimit,
-            tertiary: nil,
-            providerCost: nil,
-            updatedAt: self.updatedAt,
-            identity: identity)
+        CodexReconciledState.fromAttachedDashboard(
+            snapshot: self,
+            provider: provider,
+            accountEmail: accountEmail,
+            accountPlan: accountPlan)?
+            .toUsageSnapshot()
     }
 
     public func toCreditsSnapshot() -> CreditsSnapshot? {
@@ -149,6 +157,33 @@ public struct OpenAIDashboardDailyBreakdown: Codable, Equatable, Sendable {
         self.services = services
         self.totalCreditsUsed = totalCreditsUsed
     }
+
+    public static func isSkillUsageService(_ service: String) -> Bool {
+        service
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .lowercased()
+            .hasPrefix("skillusage:")
+    }
+
+    public static func removingSkillUsageServices(
+        from breakdown: [OpenAIDashboardDailyBreakdown])
+        -> [OpenAIDashboardDailyBreakdown]
+    {
+        breakdown.compactMap { day in
+            guard !day.services.isEmpty else {
+                return day.totalCreditsUsed > 0 ? day : nil
+            }
+
+            let services = day.services.filter { !self.isSkillUsageService($0.service) }
+            guard !services.isEmpty else { return nil }
+
+            let total = services.reduce(0) { $0 + $1.creditsUsed }
+            return OpenAIDashboardDailyBreakdown(
+                day: day.day,
+                services: services,
+                totalCreditsUsed: total)
+        }
+    }
 }
 
 public struct OpenAIDashboardServiceUsage: Codable, Equatable, Sendable {
@@ -172,6 +207,8 @@ public struct OpenAIDashboardCache: Codable, Equatable, Sendable {
 }
 
 public enum OpenAIDashboardCacheStore {
+    @TaskLocal static var cacheURLOverride: URL?
+
     public static func load() -> OpenAIDashboardCache? {
         guard let url = self.cacheURL else { return nil }
         guard let data = try? Data(contentsOf: url) else { return nil }
@@ -201,6 +238,9 @@ public enum OpenAIDashboardCacheStore {
     }
 
     private static var cacheURL: URL? {
+        if let cacheURLOverride {
+            return cacheURLOverride
+        }
         guard let root = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask).first else {
             return nil
         }
diff --git a/Sources/CodexBarCore/OpenAIWeb/OpenAIDashboardBrowserCookieImporter+Deadline.swift b/Sources/CodexBarCore/OpenAIWeb/OpenAIDashboardBrowserCookieImporter+Deadline.swift
new file mode 100644
index 0000000000..751c4dacd7
--- /dev/null
+++ b/Sources/CodexBarCore/OpenAIWeb/OpenAIDashboardBrowserCookieImporter+Deadline.swift
@@ -0,0 +1,188 @@
+#if os(macOS)
+import Foundation
+
+extension OpenAIDashboardBrowserCookieImporter {
+    private struct PendingCookieStoreMutation {
+        let token: UUID
+        let task: Task<Void, Never>
+    }
+
+    @MainActor private static var pendingCookieStoreMutations: [ObjectIdentifier: PendingCookieStoreMutation] = [:]
+    private nonisolated static let cookieCacheQueue = DispatchQueue(
+        label: "com.steipete.codexbar.openai-cookie-cache")
+    private nonisolated static let deadlineQueue = DispatchQueue(
+        label: "com.steipete.codexbar.openai-cookie-deadline",
+        qos: .userInitiated)
+
+    private final class CookieLoadCompletion: @unchecked Sendable {
+        private let lock = NSLock()
+        private var didFinish = false
+
+        func finish(_ action: () -> Void) {
+            let shouldFinish = self.lock.withLock {
+                guard !self.didFinish else { return false }
+                self.didFinish = true
+                return true
+            }
+            if shouldFinish { action() }
+        }
+    }
+
+    nonisolated static func remainingTimeout(
+        until deadline: Date?,
+        cappedAt localLimit: TimeInterval? = nil,
+        now: Date = Date()) throws -> TimeInterval
+    {
+        guard let deadline else {
+            return localLimit.map(OpenAIDashboardFetcher.sanitizedTimeout) ?? .greatestFiniteMagnitude
+        }
+        let remaining = deadline.timeIntervalSince(now)
+        guard remaining > 0 else { throw URLError(.timedOut) }
+        guard let localLimit else { return remaining }
+        return min(OpenAIDashboardFetcher.sanitizedTimeout(localLimit), remaining)
+    }
+
+    nonisolated static func runBoundedCookieLoad<T: Sendable>(
+        deadline: Date?,
+        timeoutObserver: (@Sendable () -> Void)? = nil,
+        operation: @escaping @Sendable () throws -> T) async throws -> T
+    {
+        guard let deadline else {
+            return try await Task.detached(priority: .userInitiated, operation: operation).value
+        }
+        let timeout = try self.remainingTimeout(until: deadline)
+        let completion = CookieLoadCompletion()
+        return try await withCheckedThrowingContinuation { continuation in
+            DispatchQueue.global(qos: .userInitiated).async {
+                let result = Result(catching: operation)
+                completion.finish { continuation.resume(with: result) }
+            }
+            self.deadlineQueue.asyncAfter(deadline: .now() + timeout) {
+                completion.finish {
+                    timeoutObserver?()
+                    continuation.resume(throwing: URLError(.timedOut))
+                }
+            }
+        }
+    }
+
+    nonisolated static func runBoundedCookieCacheOperation<T: Sendable>(
+        deadline: Date?,
+        operation: @escaping @Sendable () throws -> T) async throws -> T
+    {
+        guard let deadline else {
+            return try await withCheckedThrowingContinuation { continuation in
+                self.cookieCacheQueue.async {
+                    continuation.resume(with: Result(catching: operation))
+                }
+            }
+        }
+
+        let timeout = try self.remainingTimeout(until: deadline)
+        let completion = CookieLoadCompletion()
+        return try await withCheckedThrowingContinuation { continuation in
+            self.cookieCacheQueue.async {
+                let result = Result(catching: operation)
+                completion.finish { continuation.resume(with: result) }
+            }
+            self.deadlineQueue.asyncAfter(deadline: .now() + timeout) {
+                completion.finish { continuation.resume(throwing: URLError(.timedOut)) }
+            }
+        }
+    }
+
+    static func runBoundedCallback(
+        deadline: Date?,
+        timeoutObserver: (@Sendable () -> Void)? = nil,
+        start: (@escaping @Sendable () -> Void) -> Void) async throws
+    {
+        let completion = CookieLoadCompletion()
+        guard let deadline else {
+            await withCheckedContinuation { continuation in
+                start {
+                    completion.finish { continuation.resume() }
+                }
+            }
+            return
+        }
+
+        let timeout = try self.remainingTimeout(until: deadline)
+        try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in
+            start {
+                completion.finish { continuation.resume() }
+            }
+            self.deadlineQueue.asyncAfter(deadline: .now() + timeout) {
+                completion.finish {
+                    timeoutObserver?()
+                    continuation.resume(throwing: URLError(.timedOut))
+                }
+            }
+        }
+    }
+
+    static func runBoundedValueCallback<T: Sendable>(
+        deadline: Date?,
+        timeoutObserver: (@Sendable () -> Void)? = nil,
+        start: (@escaping @Sendable (T) -> Void) -> Void) async throws -> T
+    {
+        let completion = CookieLoadCompletion()
+        guard let deadline else {
+            return await withCheckedContinuation { continuation in
+                start { value in
+                    completion.finish { continuation.resume(returning: value) }
+                }
+            }
+        }
+
+        let timeout = try self.remainingTimeout(until: deadline)
+        return try await withCheckedThrowingContinuation { continuation in
+            start { value in
+                completion.finish { continuation.resume(returning: value) }
+            }
+            self.deadlineQueue.asyncAfter(deadline: .now() + timeout) {
+                completion.finish {
+                    timeoutObserver?()
+                    continuation.resume(throwing: URLError(.timedOut))
+                }
+            }
+        }
+    }
+
+    static func runSerializedCallback(
+        key: ObjectIdentifier,
+        deadline: Date?,
+        start: @escaping (@escaping @Sendable () -> Void) -> Void) async throws
+    {
+        while let pending = self.pendingCookieStoreMutations[key] {
+            try await self.waitForMutation(pending.task, deadline: deadline)
+            if self.pendingCookieStoreMutations[key]?.token == pending.token {
+                self.pendingCookieStoreMutations[key] = nil
+            }
+        }
+
+        let token = UUID()
+        let task = Task { @MainActor in
+            await withCheckedContinuation { continuation in
+                start { continuation.resume() }
+            }
+        }
+        self.pendingCookieStoreMutations[key] = PendingCookieStoreMutation(token: token, task: task)
+        Task { @MainActor in
+            await task.value
+            if self.pendingCookieStoreMutations[key]?.token == token {
+                self.pendingCookieStoreMutations[key] = nil
+            }
+        }
+        try await self.waitForMutation(task, deadline: deadline)
+    }
+
+    private static func waitForMutation(_ task: Task<Void, Never>, deadline: Date?) async throws {
+        try await self.runBoundedCallback(deadline: deadline) { completion in
+            Task { @MainActor in
+                await task.value
+                completion()
+            }
+        }
+    }
+}
+#endif
diff --git a/Sources/CodexBarCore/OpenAIWeb/OpenAIDashboardBrowserCookieImporter.swift b/Sources/CodexBarCore/OpenAIWeb/OpenAIDashboardBrowserCookieImporter.swift
index 8f211c5c3d..1f7d79f5ee 100644
--- a/Sources/CodexBarCore/OpenAIWeb/OpenAIDashboardBrowserCookieImporter.swift
+++ b/Sources/CodexBarCore/OpenAIWeb/OpenAIDashboardBrowserCookieImporter.swift
@@ -4,6 +4,7 @@ import SweetCookieKit
 import WebKit
 
 @MainActor
+// swiftlint:disable:next type_body_length
 public struct OpenAIDashboardBrowserCookieImporter {
     public struct FoundAccount: Sendable, Hashable {
         public let sourceLabel: String
@@ -71,6 +72,18 @@ public struct OpenAIDashboardBrowserCookieImporter {
 
     private let browserDetection: BrowserDetection
 
+    struct PersistentValidationTimeout: Error {}
+
+    nonisolated static func shouldTrustVerifiedSession(afterPersistFailure error: Error) -> Bool {
+        error is PersistentValidationTimeout
+    }
+
+    nonisolated static func persistentValidationFailure(_ error: Error) -> Error {
+        let nsError = error as NSError
+        guard nsError.domain == NSURLErrorDomain, nsError.code == NSURLErrorTimedOut else { return error }
+        return PersistentValidationTimeout()
+    }
+
     private struct ImportDiagnostics {
         var mismatches: [FoundAccount] = []
         var foundAnyCookies: Bool = false
@@ -78,8 +91,15 @@ public struct OpenAIDashboardBrowserCookieImporter {
         var accessDeniedHints: [String] = []
     }
 
+    private struct ImportContext {
+        let targetEmail: String?
+        let allowAnyAccount: Bool
+        let cacheScope: CookieHeaderCache.Scope?
+        let deadline: Date?
+    }
+
     private static let cookieDomains = ["chatgpt.com", "openai.com"]
-    private static let cookieClient = BrowserCookieClient()
+    private nonisolated static let cookieClient = BrowserCookieClient()
     private static let cookieImportOrder: BrowserCookieImportOrder =
         ProviderDefaults.metadata[.codex]?.browserCookieOrder ?? Browser.defaultImportOrder
 
@@ -94,6 +114,9 @@ public struct OpenAIDashboardBrowserCookieImporter {
     public func importBestCookies(
         intoAccountEmail targetEmail: String?,
         allowAnyAccount: Bool = false,
+        preferCachedCookieHeader: Bool = true,
+        cacheScope: CookieHeaderCache.Scope? = nil,
+        deadline: Date? = nil,
         logger: ((String) -> Void)? = nil) async throws -> ImportResult
     {
         let log: (String) -> Void = { message in
@@ -102,11 +125,16 @@ public struct OpenAIDashboardBrowserCookieImporter {
 
         let targetEmail = targetEmail?.trimmingCharacters(in: .whitespacesAndNewlines)
         let normalizedTarget = targetEmail?.isEmpty == false ? targetEmail : nil
+        let context = ImportContext(
+            targetEmail: normalizedTarget,
+            allowAnyAccount: allowAnyAccount,
+            cacheScope: cacheScope,
+            deadline: deadline)
 
         if normalizedTarget != nil {
             log("Codex email known; matching required.")
         } else {
-            guard allowAnyAccount else {
+            guard context.allowAnyAccount else {
                 throw ImportError.noCookiesFound
             }
             log("Codex email unknown; importing any signed-in session.")
@@ -114,41 +142,58 @@ public struct OpenAIDashboardBrowserCookieImporter {
 
         var diagnostics = ImportDiagnostics()
 
-        if let cached = CookieHeaderCache.load(provider: .codex),
-           !cached.cookieHeader.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
-        {
-            log("Using cached cookie header from \(cached.sourceLabel)")
-            do {
-                return try await self.importManualCookies(
-                    cookieHeader: cached.cookieHeader,
-                    intoAccountEmail: normalizedTarget,
-                    allowAnyAccount: allowAnyAccount,
-                    logger: log)
-            } catch let error as ImportError {
-                switch error {
-                case .manualCookieHeaderInvalid, .noMatchingAccount, .dashboardStillRequiresLogin:
-                    CookieHeaderCache.clear(provider: .codex)
-                default:
+        if preferCachedCookieHeader {
+            let cached = try await Self.runBoundedCookieCacheOperation(deadline: deadline) {
+                CookieHeaderCache.loadSerialized(provider: .codex, scope: cacheScope)
+            }
+            if let cached,
+               !cached.cookieHeader.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+            {
+                log("Using cached cookie header from \(cached.sourceLabel)")
+                do {
+                    return try await self.importManualCookies(
+                        cookieHeader: cached.cookieHeader,
+                        intoAccountEmail: context.targetEmail,
+                        allowAnyAccount: context.allowAnyAccount,
+                        cacheScope: cacheScope,
+                        deadline: deadline,
+                        logger: log)
+                } catch let error as ImportError {
+                    switch error {
+                    case .manualCookieHeaderInvalid, .noMatchingAccount, .dashboardStillRequiresLogin:
+                        do {
+                            _ = try await Self.runBoundedCookieCacheOperation(deadline: deadline) {
+                                CookieHeaderCache.clear(provider: .codex, scope: cacheScope)
+                            }
+                        } catch {
+                            log("Stale cookie cache cleanup did not finish before the web deadline.")
+                        }
+                    default:
+                        throw error
+                    }
+                } catch {
                     throw error
                 }
-            } catch {
-                throw error
             }
+        } else {
+            log("Skipping cached cookie header; forcing fresh browser import")
         }
 
         // Filter to cookie-eligible browsers to avoid unnecessary keychain prompts
         let installedBrowsers = Self.cookieImportOrder.cookieImportCandidates(using: self.browserDetection)
         for browserSource in installedBrowsers {
-            if let match = await self.trySource(
+            _ = try Self.remainingTimeout(until: deadline)
+            if let match = try await self.trySource(
                 browserSource,
-                targetEmail: normalizedTarget,
-                allowAnyAccount: allowAnyAccount,
+                context: context,
+                deadline: deadline,
                 log: log,
                 diagnostics: &diagnostics)
             {
                 return match
             }
         }
+        _ = try Self.remainingTimeout(until: deadline)
 
         if !diagnostics.mismatches.isEmpty {
             let found = Array(Set(diagnostics.mismatches)).sorted { lhs, rhs in
@@ -177,6 +222,8 @@ public struct OpenAIDashboardBrowserCookieImporter {
         cookieHeader: String,
         intoAccountEmail targetEmail: String?,
         allowAnyAccount: Bool = false,
+        cacheScope: CookieHeaderCache.Scope? = nil,
+        deadline: Date? = nil,
         logger: ((String) -> Void)? = nil) async throws -> ImportResult
     {
         let log: (String) -> Void = { message in
@@ -194,21 +241,35 @@ public struct OpenAIDashboardBrowserCookieImporter {
         guard !cookies.isEmpty else { throw ImportError.manualCookieHeaderInvalid }
 
         let candidate = Candidate(label: "Manual", cookies: cookies)
-        switch await self.evaluateCandidate(
+        switch try await self.evaluateCandidate(
             candidate,
             targetEmail: normalizedTarget,
             allowAnyAccount: allowAnyAccount,
+            deadline: deadline,
             log: log)
         {
         case let .match(_, signedInEmail):
-            return try await self.persist(candidate: candidate, targetEmail: signedInEmail, logger: log)
+            return try await self.persistVerifiedCandidate(
+                candidate: candidate,
+                targetEmail: signedInEmail,
+                cacheScope: cacheScope,
+                deadline: deadline,
+                logger: log)
         case let .loggedIn(_, signedInEmail):
-            return try await self.persist(candidate: candidate, targetEmail: signedInEmail, logger: log)
+            return try await self.persistVerifiedCandidate(
+                candidate: candidate,
+                targetEmail: signedInEmail,
+                cacheScope: cacheScope,
+                deadline: deadline,
+                logger: log)
         case let .mismatch(_, signedInEmail):
             throw ImportError.noMatchingAccount(found: [FoundAccount(sourceLabel: "Manual", email: signedInEmail)])
         case .unknown:
             if allowAnyAccount {
-                return try await self.persistToDefaultStore(candidate: candidate, logger: log)
+                return try await self.persistToDefaultStore(
+                    candidate: candidate,
+                    deadline: deadline,
+                    logger: log)
             }
             throw ImportError.noMatchingAccount(found: [])
         case .loginRequired:
@@ -217,23 +278,24 @@ public struct OpenAIDashboardBrowserCookieImporter {
     }
 
     private func trySafari(
-        targetEmail: String?,
-        allowAnyAccount: Bool,
+        context: ImportContext,
+        deadline: Date?,
         log: @escaping (String) -> Void,
-        diagnostics: inout ImportDiagnostics) async -> ImportResult?
+        diagnostics: inout ImportDiagnostics) async throws -> ImportResult?
     {
         // Safari first: avoids touching Keychain ("Chrome Safe Storage") when Safari already matches.
         do {
             let query = BrowserCookieQuery(domains: Self.cookieDomains)
-            let sources = try Self.cookieClient.records(
-                matching: query,
-                in: .safari,
-                logger: log)
+            let sources = try await Self.runBoundedCookieLoad(deadline: deadline) {
+                try Self.cookieClient.codexBarRecords(matching: query, in: .safari)
+            }
+            _ = try Self.remainingTimeout(until: deadline)
             guard !sources.isEmpty else {
                 log("Safari contained 0 matching records.")
                 return nil
             }
             for source in sources {
+                _ = try Self.remainingTimeout(until: deadline)
                 let cookies = BrowserCookieClient.makeHTTPCookies(source.records, origin: query.origin)
                 guard !cookies.isEmpty else {
                     log("\(source.label) produced 0 HTTPCookies.")
@@ -243,10 +305,10 @@ public struct OpenAIDashboardBrowserCookieImporter {
                 diagnostics.foundAnyCookies = true
                 log("Loaded \(cookies.count) cookies from \(source.label) (\(self.cookieSummary(cookies)))")
                 let candidate = Candidate(label: source.label, cookies: cookies)
-                if let match = await self.applyCandidate(
+                if let match = try await self.applyCandidate(
                     candidate,
-                    targetEmail: targetEmail,
-                    allowAnyAccount: allowAnyAccount,
+                    context: context,
+                    deadline: deadline,
                     log: log,
                     diagnostics: &diagnostics)
                 {
@@ -254,6 +316,8 @@ public struct OpenAIDashboardBrowserCookieImporter {
                 }
             }
             return nil
+        } catch let error as URLError where error.code == .timedOut {
+            throw error
         } catch let error as BrowserCookieError {
             BrowserCookieAccessGate.recordIfNeeded(error)
             if let hint = error.accessDeniedHint {
@@ -267,76 +331,39 @@ public struct OpenAIDashboardBrowserCookieImporter {
         }
     }
 
-    private func tryChrome(
-        targetEmail: String?,
-        allowAnyAccount: Bool,
+    /// Generic cookie loader for any non-Safari browser (Chrome, Edge, Firefox, Brave, Arc, etc.).
+    /// SweetCookieKit handles engine-specific decryption internally.
+    private func tryBrowser(
+        _ browser: Browser,
+        context: ImportContext,
+        deadline: Date?,
         log: @escaping (String) -> Void,
-        diagnostics: inout ImportDiagnostics) async -> ImportResult?
+        diagnostics: inout ImportDiagnostics) async throws -> ImportResult?
     {
-        // Chrome fallback: may trigger Keychain prompt. Only do this if Safari didn't match.
         do {
             let query = BrowserCookieQuery(domains: Self.cookieDomains)
-            let chromeSources = try Self.cookieClient.records(
-                matching: query,
-                in: .chrome)
-            for source in chromeSources {
-                let cookies = BrowserCookieClient.makeHTTPCookies(source.records, origin: query.origin)
-                if cookies.isEmpty {
-                    log("\(source.label) produced 0 HTTPCookies.")
-                    continue
-                }
-                diagnostics.foundAnyCookies = true
-                log("Loaded \(cookies.count) cookies from \(source.label) (\(self.cookieSummary(cookies)))")
-                let candidate = Candidate(label: source.label, cookies: cookies)
-                if let match = await self.applyCandidate(
-                    candidate,
-                    targetEmail: targetEmail,
-                    allowAnyAccount: allowAnyAccount,
-                    log: log,
-                    diagnostics: &diagnostics)
-                {
-                    return match
-                }
+            let sources = try await Self.runBoundedCookieLoad(deadline: deadline) {
+                try Self.cookieClient.codexBarRecords(matching: query, in: browser)
             }
-            return nil
-        } catch let error as BrowserCookieError {
-            BrowserCookieAccessGate.recordIfNeeded(error)
-            if let hint = error.accessDeniedHint {
-                diagnostics.accessDeniedHints.append(hint)
+            _ = try Self.remainingTimeout(until: deadline)
+            guard !sources.isEmpty else {
+                log("\(browser.displayName) contained 0 matching records.")
+                return nil
             }
-            log("Chrome cookie load failed: \(error.localizedDescription)")
-            return nil
-        } catch {
-            log("Chrome cookie load failed: \(error.localizedDescription)")
-            return nil
-        }
-    }
-
-    private func tryFirefox(
-        targetEmail: String?,
-        allowAnyAccount: Bool,
-        log: @escaping (String) -> Void,
-        diagnostics: inout ImportDiagnostics) async -> ImportResult?
-    {
-        // Firefox fallback: no Keychain, but still only after Safari/Chrome.
-        do {
-            let query = BrowserCookieQuery(domains: Self.cookieDomains)
-            let firefoxSources = try Self.cookieClient.records(
-                matching: query,
-                in: .firefox)
-            for source in firefoxSources {
+            for source in sources {
+                _ = try Self.remainingTimeout(until: deadline)
                 let cookies = BrowserCookieClient.makeHTTPCookies(source.records, origin: query.origin)
-                if cookies.isEmpty {
+                guard !cookies.isEmpty else {
                     log("\(source.label) produced 0 HTTPCookies.")
                     continue
                 }
                 diagnostics.foundAnyCookies = true
                 log("Loaded \(cookies.count) cookies from \(source.label) (\(self.cookieSummary(cookies)))")
                 let candidate = Candidate(label: source.label, cookies: cookies)
-                if let match = await self.applyCandidate(
+                if let match = try await self.applyCandidate(
                     candidate,
-                    targetEmail: targetEmail,
-                    allowAnyAccount: allowAnyAccount,
+                    context: context,
+                    deadline: deadline,
                     log: log,
                     diagnostics: &diagnostics)
                 {
@@ -344,92 +371,123 @@ public struct OpenAIDashboardBrowserCookieImporter {
                 }
             }
             return nil
+        } catch let error as URLError where error.code == .timedOut {
+            throw error
         } catch let error as BrowserCookieError {
             BrowserCookieAccessGate.recordIfNeeded(error)
             if let hint = error.accessDeniedHint {
                 diagnostics.accessDeniedHints.append(hint)
             }
-            log("Firefox cookie load failed: \(error.localizedDescription)")
+            log("\(browser.displayName) cookie load failed: \(error.localizedDescription)")
             return nil
         } catch {
-            log("Firefox cookie load failed: \(error.localizedDescription)")
+            log("\(browser.displayName) cookie load failed: \(error.localizedDescription)")
             return nil
         }
     }
 
     private func trySource(
         _ source: Browser,
-        targetEmail: String?,
-        allowAnyAccount: Bool,
+        context: ImportContext,
+        deadline: Date?,
         log: @escaping (String) -> Void,
-        diagnostics: inout ImportDiagnostics) async -> ImportResult?
+        diagnostics: inout ImportDiagnostics) async throws -> ImportResult?
     {
         switch source {
         case .safari:
-            await self.trySafari(
-                targetEmail: targetEmail,
-                allowAnyAccount: allowAnyAccount,
-                log: log,
-                diagnostics: &diagnostics)
-        case .chrome:
-            await self.tryChrome(
-                targetEmail: targetEmail,
-                allowAnyAccount: allowAnyAccount,
+            try await self.trySafari(
+                context: context,
+                deadline: deadline,
                 log: log,
                 diagnostics: &diagnostics)
-        case .firefox:
-            await self.tryFirefox(
-                targetEmail: targetEmail,
-                allowAnyAccount: allowAnyAccount,
+        default:
+            // All non-Safari browsers (Chrome, Edge, Firefox, Brave, Arc, etc.)
+            // share the same cookie loading path via SweetCookieKit.
+            try await self.tryBrowser(
+                source,
+                context: context,
+                deadline: deadline,
                 log: log,
                 diagnostics: &diagnostics)
-        default:
-            nil
         }
     }
 
     private func applyCandidate(
         _ candidate: Candidate,
-        targetEmail: String?,
-        allowAnyAccount: Bool,
+        context: ImportContext,
+        deadline: Date?,
         log: @escaping (String) -> Void,
-        diagnostics: inout ImportDiagnostics) async -> ImportResult?
+        diagnostics: inout ImportDiagnostics) async throws -> ImportResult?
     {
-        switch await self.evaluateCandidate(
+        switch try await self.evaluateCandidate(
             candidate,
-            targetEmail: targetEmail,
-            allowAnyAccount: allowAnyAccount,
+            targetEmail: context.targetEmail,
+            allowAnyAccount: context.allowAnyAccount,
+            deadline: deadline,
             log: log)
         {
         case let .match(candidate, signedInEmail):
             log("Selected \(candidate.label) (matches Codex: \(signedInEmail))")
-            guard let targetEmail else { return nil }
-            if let result = try? await self.persist(candidate: candidate, targetEmail: targetEmail, logger: log) {
-                self.cacheCookies(candidate: candidate)
+            guard let targetEmail = context.targetEmail else { return nil }
+            if let result = try? await self.persistVerifiedCandidate(
+                candidate: candidate,
+                targetEmail: targetEmail,
+                cacheScope: context.cacheScope,
+                deadline: deadline,
+                logger: log)
+            {
+                await self.cacheCookies(
+                    candidate: candidate,
+                    scope: context.cacheScope,
+                    deadline: deadline,
+                    logger: log)
                 return result
             }
+            _ = try Self.remainingTimeout(until: deadline)
             return nil
         case let .mismatch(candidate, signedInEmail):
-            await self.handleMismatch(
+            try await self.handleMismatch(
                 candidate: candidate,
                 signedInEmail: signedInEmail,
+                context: context,
                 log: log,
                 diagnostics: &diagnostics)
+            _ = try Self.remainingTimeout(until: deadline)
             return nil
         case let .loggedIn(candidate, signedInEmail):
             log("Selected \(candidate.label) (signed in: \(signedInEmail))")
-            if let result = try? await self.persist(candidate: candidate, targetEmail: signedInEmail, logger: log) {
-                self.cacheCookies(candidate: candidate)
+            if let result = try? await self.persistVerifiedCandidate(
+                candidate: candidate,
+                targetEmail: signedInEmail,
+                cacheScope: context.cacheScope,
+                deadline: deadline,
+                logger: log)
+            {
+                await self.cacheCookies(
+                    candidate: candidate,
+                    scope: context.cacheScope,
+                    deadline: deadline,
+                    logger: log)
                 return result
             }
+            _ = try Self.remainingTimeout(until: deadline)
             return nil
         case .unknown:
-            if allowAnyAccount {
+            if context.allowAnyAccount {
                 log("Selected \(candidate.label) (signed in: unknown)")
-                if let result = try? await self.persistToDefaultStore(candidate: candidate, logger: log) {
-                    self.cacheCookies(candidate: candidate)
+                if let result = try? await self.persistToDefaultStore(
+                    candidate: candidate,
+                    deadline: deadline,
+                    logger: log)
+                {
+                    await self.cacheCookies(
+                        candidate: candidate,
+                        scope: context.cacheScope,
+                        deadline: deadline,
+                        logger: log)
                     return result
                 }
+                _ = try Self.remainingTimeout(until: deadline)
                 return nil
             }
             diagnostics.foundUnknownEmail = true
@@ -443,11 +501,15 @@ public struct OpenAIDashboardBrowserCookieImporter {
         _ candidate: Candidate,
         targetEmail: String?,
         allowAnyAccount: Bool,
-        log: @escaping (String) -> Void) async -> CandidateEvaluation
+        deadline: Date?,
+        log: @escaping (String) -> Void) async throws -> CandidateEvaluation
     {
         log("Trying candidate \(candidate.label) (\(candidate.cookies.count) cookies)")
 
-        let apiEmail = await self.fetchSignedInEmailFromAPI(cookies: candidate.cookies, logger: log)
+        let apiEmail = try await self.fetchSignedInEmailFromAPI(
+            cookies: candidate.cookies,
+            deadline: deadline,
+            logger: log)
         if let apiEmail {
             log("Candidate \(candidate.label) API email: \(apiEmail)")
         }
@@ -469,13 +531,13 @@ public struct OpenAIDashboardBrowserCookieImporter {
         }
 
         let scratch = WKWebsiteDataStore.nonPersistent()
-        await self.setCookies(candidate.cookies, into: scratch)
+        try await self.setCookies(candidate.cookies, into: scratch, deadline: deadline)
 
         do {
             let probe = try await OpenAIDashboardFetcher().probeUsagePage(
                 websiteDataStore: scratch,
                 logger: log,
-                timeout: 25)
+                timeout: Self.remainingTimeout(until: deadline, cappedAt: 25))
             let signedInEmail = probe.signedInEmail?.trimmingCharacters(in: .whitespacesAndNewlines)
             log("Candidate \(candidate.label) DOM email: \(signedInEmail ?? "unknown")")
 
@@ -495,6 +557,7 @@ public struct OpenAIDashboardBrowserCookieImporter {
             log("Candidate \(candidate.label) requires login.")
             return .loginRequired(candidate: candidate)
         } catch {
+            _ = try Self.remainingTimeout(until: deadline)
             log("Candidate \(candidate.label) probe error: \(error.localizedDescription)")
             return .unknown(candidate: candidate)
         }
@@ -514,20 +577,31 @@ public struct OpenAIDashboardBrowserCookieImporter {
     private func handleMismatch(
         candidate: Candidate,
         signedInEmail: String,
+        context: ImportContext,
         log: @escaping (String) -> Void,
-        diagnostics: inout ImportDiagnostics) async
+        diagnostics: inout ImportDiagnostics) async throws
     {
         log("Candidate \(candidate.label) mismatch (\(signedInEmail)); continuing browser search")
         diagnostics.mismatches.append(FoundAccount(sourceLabel: candidate.label, email: signedInEmail))
-        // Mismatch still means we found a valid signed-in session. Persist it keyed by its email so if
-        // the user switches Codex accounts later, we can reuse this session immediately without another
-        // Keychain prompt.
-        await self.persistCookies(candidate: candidate, accountEmail: signedInEmail, logger: log)
+        // Mismatch still means we found a valid signed-in session. Keep it inside the active source scope;
+        // a profile import must never populate the live account or another profile's WebKit store.
+        do {
+            try await self.persistCookies(
+                candidate: candidate,
+                accountEmail: signedInEmail,
+                cacheScope: context.cacheScope,
+                deadline: context.deadline,
+                logger: log)
+        } catch {
+            log("Could not cache mismatched session: \(error.localizedDescription)")
+            _ = try Self.remainingTimeout(until: context.deadline)
+        }
     }
 
     private func fetchSignedInEmailFromAPI(
         cookies: [HTTPCookie],
-        logger: (String) -> Void) async -> String?
+        deadline: Date?,
+        logger: (String) -> Void) async throws -> String?
     {
         let chatgptCookies = cookies.filter { $0.domain.lowercased().contains("chatgpt.com") }
         guard !chatgptCookies.isEmpty else { return nil }
@@ -542,15 +616,16 @@ public struct OpenAIDashboardBrowserCookieImporter {
         ]
 
         for urlString in endpoints {
+            let requestTimeout = try Self.remainingTimeout(until: deadline, cappedAt: 10)
             guard let url = URL(string: urlString) else { continue }
             var request = URLRequest(url: url)
             request.httpMethod = "GET"
-            request.timeoutInterval = 10
+            request.timeoutInterval = requestTimeout
             request.setValue(cookieHeader, forHTTPHeaderField: "Cookie")
             request.setValue("application/json", forHTTPHeaderField: "Accept")
 
             do {
-                let (data, response) = try await URLSession.shared.data(for: request)
+                let (data, response) = try await ProviderHTTPClient.shared.data(for: request)
                 let status = (response as? HTTPURLResponse)?.statusCode ?? -1
                 logger("API \(url.host ?? "chatgpt.com") \(url.path) status=\(status)")
                 guard status >= 200, status < 300 else { continue }
@@ -558,6 +633,7 @@ public struct OpenAIDashboardBrowserCookieImporter {
                     return email.trimmingCharacters(in: .whitespacesAndNewlines)
                 }
             } catch {
+                _ = try Self.remainingTimeout(until: deadline)
                 logger("API request failed: \(error.localizedDescription)")
             }
         }
@@ -587,21 +663,57 @@ public struct OpenAIDashboardBrowserCookieImporter {
         return nil
     }
 
+    private func persistVerifiedCandidate(
+        candidate: Candidate,
+        targetEmail: String,
+        cacheScope: CookieHeaderCache.Scope?,
+        deadline: Date?,
+        logger: @escaping (String) -> Void) async throws -> ImportResult
+    {
+        do {
+            return try await self.persist(
+                candidate: candidate,
+                targetEmail: targetEmail,
+                cacheScope: cacheScope,
+                deadline: deadline,
+                logger: logger)
+        } catch {
+            guard Self.shouldTrustVerifiedSession(afterPersistFailure: error) else {
+                throw error
+            }
+
+            let signedInEmail = targetEmail.trimmingCharacters(in: .whitespacesAndNewlines)
+            logger(
+                "Persistent validation timed out after session verification; " +
+                    "keeping \(candidate.label) cookies for \(signedInEmail).")
+            return ImportResult(
+                sourceLabel: candidate.label,
+                cookieCount: candidate.cookies.count,
+                signedInEmail: signedInEmail,
+                matchesCodexEmail: signedInEmail.lowercased() == targetEmail.lowercased())
+        }
+    }
+
     private func persist(
         candidate: Candidate,
         targetEmail: String,
+        cacheScope: CookieHeaderCache.Scope?,
+        deadline: Date?,
         logger: @escaping (String) -> Void) async throws -> ImportResult
     {
-        let persistent = OpenAIDashboardWebsiteDataStore.store(forAccountEmail: targetEmail)
-        await self.clearChatGPTCookies(in: persistent)
-        await self.setCookies(candidate.cookies, into: persistent)
+        let persistent = OpenAIDashboardWebsiteDataStore.store(
+            forAccountEmail: targetEmail,
+            scope: cacheScope)
+        try await self.clearChatGPTCookies(in: persistent, deadline: deadline)
+        try await self.setCookies(candidate.cookies, into: persistent, deadline: deadline)
 
         // Validate against the persistent store (login + email sync).
         do {
             let probe = try await OpenAIDashboardFetcher().probeUsagePage(
                 websiteDataStore: persistent,
                 logger: logger,
-                timeout: 20)
+                timeout: Self.remainingTimeout(until: deadline, cappedAt: 20),
+                preserveLoadedPageForReuse: true)
             let signed = probe.signedInEmail?.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines)
             let matches = signed?.lowercased() == targetEmail.lowercased()
             logger("Persistent session signed in as: \(signed ?? "unknown")")
@@ -617,24 +729,30 @@ public struct OpenAIDashboardBrowserCookieImporter {
                 signedInEmail: signed,
                 matchesCodexEmail: matches)
         } catch OpenAIDashboardFetcher.FetchError.loginRequired {
+            OpenAIDashboardWebViewCache.shared.evict(websiteDataStore: persistent)
             logger("Selected \(candidate.label) but dashboard still requires login.")
             throw ImportError.dashboardStillRequiresLogin
+        } catch {
+            OpenAIDashboardWebViewCache.shared.evict(websiteDataStore: persistent)
+            throw Self.persistentValidationFailure(error)
         }
     }
 
     private func persistToDefaultStore(
         candidate: Candidate,
+        deadline: Date?,
         logger: @escaping (String) -> Void) async throws -> ImportResult
     {
         let persistent = OpenAIDashboardWebsiteDataStore.store(forAccountEmail: nil)
-        await self.clearChatGPTCookies(in: persistent)
-        await self.setCookies(candidate.cookies, into: persistent)
+        try await self.clearChatGPTCookies(in: persistent, deadline: deadline)
+        try await self.setCookies(candidate.cookies, into: persistent, deadline: deadline)
 
         do {
             let probe = try await OpenAIDashboardFetcher().probeUsagePage(
                 websiteDataStore: persistent,
                 logger: logger,
-                timeout: 20)
+                timeout: Self.remainingTimeout(until: deadline, cappedAt: 20),
+                preserveLoadedPageForReuse: true)
             let signed = probe.signedInEmail?.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines)
             logger("Persistent session signed in as: \(signed ?? "unknown")")
             return ImportResult(
@@ -643,8 +761,12 @@ public struct OpenAIDashboardBrowserCookieImporter {
                 signedInEmail: signed,
                 matchesCodexEmail: false)
         } catch OpenAIDashboardFetcher.FetchError.loginRequired {
+            OpenAIDashboardWebViewCache.shared.evict(websiteDataStore: persistent)
             logger("Selected \(candidate.label) but dashboard still requires login.")
             throw ImportError.dashboardStillRequiresLogin
+        } catch {
+            OpenAIDashboardWebViewCache.shared.evict(websiteDataStore: persistent)
+            throw error
         }
     }
 
@@ -669,48 +791,80 @@ public struct OpenAIDashboardBrowserCookieImporter {
         return cookies
     }
 
-    private func cacheCookies(candidate: Candidate) {
+    private func cacheCookies(
+        candidate: Candidate,
+        scope: CookieHeaderCache.Scope?,
+        deadline: Date?,
+        logger: @escaping (String) -> Void) async
+    {
         let header = self.cookieHeader(from: candidate.cookies)
         guard !header.isEmpty else { return }
-        CookieHeaderCache.store(provider: .codex, cookieHeader: header, sourceLabel: candidate.label)
+        do {
+            _ = try await Self.runBoundedCookieCacheOperation(deadline: deadline) {
+                CookieHeaderCache.store(
+                    provider: .codex,
+                    scope: scope,
+                    cookieHeader: header,
+                    sourceLabel: candidate.label)
+                return true
+            }
+        } catch {
+            logger("Cookie cache write did not finish before the web deadline.")
+        }
     }
 
     private func cookieHeader(from cookies: [HTTPCookie]) -> String {
         cookies.map { "\($0.name)=\($0.value)" }.joined(separator: "; ")
     }
 
-    private struct Candidate: Sendable {
+    private struct Candidate {
         let label: String
         let cookies: [HTTPCookie]
     }
 
     // MARK: - WebKit cookie store
 
-    private func persistCookies(candidate: Candidate, accountEmail: String, logger: (String) -> Void) async {
-        let store = OpenAIDashboardWebsiteDataStore.store(forAccountEmail: accountEmail)
-        await self.clearChatGPTCookies(in: store)
-        await self.setCookies(candidate.cookies, into: store)
+    private func persistCookies(
+        candidate: Candidate,
+        accountEmail: String,
+        cacheScope: CookieHeaderCache.Scope?,
+        deadline: Date?,
+        logger: (String) -> Void) async throws
+    {
+        let store = OpenAIDashboardWebsiteDataStore.store(forAccountEmail: accountEmail, scope: cacheScope)
+        try await self.clearChatGPTCookies(in: store, deadline: deadline)
+        try await self.setCookies(candidate.cookies, into: store, deadline: deadline)
         logger("Persisted cookies for \(accountEmail) (source=\(candidate.label))")
     }
 
-    private func clearChatGPTCookies(in store: WKWebsiteDataStore) async {
-        await withCheckedContinuation { cont in
+    private func clearChatGPTCookies(in store: WKWebsiteDataStore, deadline: Date?) async throws {
+        try await Self.runSerializedCallback(
+            key: ObjectIdentifier(store),
+            deadline: deadline)
+        { completion in
             store.fetchDataRecords(ofTypes: WKWebsiteDataStore.allWebsiteDataTypes()) { records in
                 let filtered = records.filter { record in
                     let name = record.displayName.lowercased()
                     return name.contains("chatgpt.com") || name.contains("openai.com")
                 }
                 store.removeData(ofTypes: WKWebsiteDataStore.allWebsiteDataTypes(), for: filtered) {
-                    cont.resume()
+                    completion()
                 }
             }
         }
     }
 
-    private func setCookies(_ cookies: [HTTPCookie], into store: WKWebsiteDataStore) async {
+    private func setCookies(
+        _ cookies: [HTTPCookie],
+        into store: WKWebsiteDataStore,
+        deadline: Date?) async throws
+    {
         for cookie in cookies {
-            await withCheckedContinuation { cont in
-                store.httpCookieStore.setCookie(cookie) { cont.resume() }
+            try await Self.runSerializedCallback(
+                key: ObjectIdentifier(store),
+                deadline: deadline)
+            { completion in
+                store.httpCookieStore.setCookie(cookie, completionHandler: completion)
             }
         }
     }
@@ -798,6 +952,9 @@ public struct OpenAIDashboardBrowserCookieImporter {
     public func importBestCookies(
         intoAccountEmail _: String?,
         allowAnyAccount _: Bool = false,
+        preferCachedCookieHeader _: Bool = true,
+        cacheScope _: CookieHeaderCache.Scope? = nil,
+        deadline _: Date? = nil,
         logger _: ((String) -> Void)? = nil) async throws -> ImportResult
     {
         throw ImportError.browserAccessDenied(details: "OpenAI web cookie import is only supported on macOS.")
@@ -807,6 +964,8 @@ public struct OpenAIDashboardBrowserCookieImporter {
         cookieHeader _: String,
         intoAccountEmail _: String?,
         allowAnyAccount _: Bool = false,
+        cacheScope _: CookieHeaderCache.Scope? = nil,
+        deadline _: Date? = nil,
         logger _: ((String) -> Void)? = nil) async throws -> ImportResult
     {
         throw ImportError.browserAccessDenied(details: "OpenAI web cookie import is only supported on macOS.")
diff --git a/Sources/CodexBarCore/OpenAIWeb/OpenAIDashboardFetcher.swift b/Sources/CodexBarCore/OpenAIWeb/OpenAIDashboardFetcher.swift
index 04cdca243e..b3e389221b 100644
--- a/Sources/CodexBarCore/OpenAIWeb/OpenAIDashboardFetcher.swift
+++ b/Sources/CodexBarCore/OpenAIWeb/OpenAIDashboardFetcher.swift
@@ -19,7 +19,9 @@ public struct OpenAIDashboardFetcher {
         }
     }
 
-    private let usageURL = URL(string: "https://chatgpt.com/codex/settings/usage")!
+    private let usageURL = URL(string: "https://chatgpt.com/codex/cloud/settings/analytics#usage")!
+    private nonisolated static let dashboardAcceptLanguage = "en-US,en;q=0.9"
+    private nonisolated static let dashboardUsageAPIURL = URL(string: "https://chatgpt.com/backend-api/wham/usage")!
 
     public init() {}
 
@@ -42,6 +44,119 @@ public struct OpenAIDashboardFetcher {
         0.001
     }
 
+    private struct DashboardSnapshotComponents {
+        let signedInEmail: String?
+        let scrape: ScrapeResult
+        let codeReview: Double?
+        let codeReviewLimit: RateWindow?
+        let events: [CreditEvent]
+        let breakdown: [OpenAIDashboardDailyBreakdown]
+        let usageBreakdown: [OpenAIDashboardDailyBreakdown]
+        let rateLimits: (primary: RateWindow?, secondary: RateWindow?)
+        let extraRateWindows: [NamedRateWindow]
+        let creditsRemaining: Double?
+        let accountPlan: String?
+    }
+
+    private struct DashboardScrapeData {
+        let signedInEmail: String?
+        let codeReview: Double?
+        let codeReviewLimit: RateWindow?
+        let events: [CreditEvent]
+        let breakdown: [OpenAIDashboardDailyBreakdown]
+        let usageBreakdown: [OpenAIDashboardDailyBreakdown]
+        let rateLimits: (primary: RateWindow?, secondary: RateWindow?)
+        let extraRateWindows: [NamedRateWindow]
+        let creditsRemaining: Double?
+        let accountPlan: String?
+        let hasDashboardPageSignal: Bool
+        let hasReturnableData: Bool
+    }
+
+    private nonisolated static func makeDashboardSnapshot(_ components: DashboardSnapshotComponents)
+        -> OpenAIDashboardSnapshot
+    {
+        OpenAIDashboardSnapshot(
+            signedInEmail: components.signedInEmail,
+            codeReviewRemainingPercent: components.codeReview,
+            codeReviewLimit: components.codeReviewLimit,
+            creditEvents: components.events,
+            dailyBreakdown: components.breakdown,
+            usageBreakdown: components.usageBreakdown,
+            creditsPurchaseURL: components.scrape.creditsPurchaseURL,
+            primaryLimit: components.rateLimits.primary,
+            secondaryLimit: components.rateLimits.secondary,
+            extraRateWindows: components.extraRateWindows.isEmpty ? nil : components.extraRateWindows,
+            creditsRemaining: components.creditsRemaining,
+            accountPlan: components.accountPlan,
+            updatedAt: Date())
+    }
+
+    private static func parseDashboardScrape(
+        _ scrape: ScrapeResult,
+        apiData: DashboardAPIData?,
+        verifiedSignedInEmail: String?) -> DashboardScrapeData
+    {
+        let bodyText = scrape.bodyText ?? ""
+        let codeReview = OpenAIDashboardParser.parseCodeReviewRemainingPercent(bodyText: bodyText)
+        let events = OpenAIDashboardParser.parseCreditEvents(rows: scrape.rows)
+        let breakdown = OpenAIDashboardSnapshot.makeDailyBreakdown(from: events, maxDays: 30)
+        let usageBreakdown = scrape.usageBreakdown
+        let parsedRateLimits = OpenAIDashboardParser.parseRateLimits(bodyText: bodyText)
+        let rateLimits = (
+            primary: apiData?.primaryLimit ?? parsedRateLimits.primary,
+            secondary: apiData?.secondaryLimit ?? parsedRateLimits.secondary)
+        let codeReviewLimit = OpenAIDashboardParser.parseCodeReviewLimit(bodyText: bodyText)
+        let parsedCreditsRemaining = OpenAIDashboardParser.parseCreditsRemaining(bodyText: bodyText)
+        let creditsRemaining = apiData?.creditsRemaining ?? parsedCreditsRemaining
+        let accountPlan = scrape.accountPlan ?? apiData?.accountPlan
+        let hasParsedUsageLimits = parsedRateLimits.primary != nil || parsedRateLimits.secondary != nil
+        let hasUsageLimits = rateLimits.primary != nil || rateLimits.secondary != nil
+        let hasDashboardPageData = self.hasReturnableDashboardData(
+            codeReview: codeReview,
+            events: events,
+            usageBreakdown: usageBreakdown,
+            hasUsageLimits: hasParsedUsageLimits,
+            creditsRemaining: parsedCreditsRemaining)
+        let hasReturnableData = self.hasReturnableDashboardData(
+            codeReview: codeReview,
+            events: events,
+            usageBreakdown: usageBreakdown,
+            hasUsageLimits: hasUsageLimits,
+            creditsRemaining: creditsRemaining)
+
+        // Codex `additional_rate_limits` (e.g. Codex Spark) only ship over the JSON usage API, so the
+        // dashboard HTML scrape never contributes here; we just forward what the apiData decoded.
+        let extraRateWindows = apiData?.extraRateWindows ?? []
+        return DashboardScrapeData(
+            signedInEmail: self.firstNonEmpty(scrape.signedInEmail, verifiedSignedInEmail),
+            codeReview: codeReview,
+            codeReviewLimit: codeReviewLimit,
+            events: events,
+            breakdown: breakdown,
+            usageBreakdown: usageBreakdown,
+            rateLimits: rateLimits,
+            extraRateWindows: extraRateWindows,
+            creditsRemaining: creditsRemaining,
+            accountPlan: accountPlan,
+            hasDashboardPageSignal: self.hasAnyDashboardSignal(
+                hasReturnableData: hasDashboardPageData,
+                creditsHeaderPresent: scrape.creditsHeaderPresent),
+            hasReturnableData: hasReturnableData)
+    }
+
+    struct DashboardAPIData {
+        let primaryLimit: RateWindow?
+        let secondaryLimit: RateWindow?
+        let extraRateWindows: [NamedRateWindow]
+        let creditsRemaining: Double?
+        let accountPlan: String?
+
+        var hasUsageData: Bool {
+            self.primaryLimit != nil || self.secondaryLimit != nil || self.creditsRemaining != nil
+        }
+    }
+
     public struct ProbeResult: Sendable {
         public let href: String?
         public let loginRequired: Bool
@@ -67,17 +182,41 @@ public struct OpenAIDashboardFetcher {
         }
     }
 
+    nonisolated static func shouldPreserveLoadedPageAfterProbe(_ result: ProbeResult) -> Bool {
+        guard !result.loginRequired, !result.workspacePicker, !result.cloudflareInterstitial else {
+            return false
+        }
+
+        guard self.isUsageRoute(result.href) else { return false }
+
+        guard let signedInEmail = result.signedInEmail?.trimmingCharacters(in: .whitespacesAndNewlines),
+              !signedInEmail.isEmpty
+        else {
+            return false
+        }
+
+        return true
+    }
+
+    private nonisolated static func sleepForDashboardPoll(_ duration: Duration) async throws {
+        try? await Task.sleep(for: duration)
+        try Task.checkCancellation()
+    }
+
     public func loadLatestDashboard(
         accountEmail: String?,
+        cacheScope: CookieHeaderCache.Scope? = nil,
         logger: ((String) -> Void)? = nil,
         debugDumpHTML: Bool = false,
+        allowNavigationTimeoutRetry: Bool = true,
         timeout: TimeInterval = 60) async throws -> OpenAIDashboardSnapshot
     {
-        let store = OpenAIDashboardWebsiteDataStore.store(forAccountEmail: accountEmail)
+        let store = OpenAIDashboardWebsiteDataStore.store(forAccountEmail: accountEmail, scope: cacheScope)
         return try await self.loadLatestDashboard(
             websiteDataStore: store,
             logger: logger,
             debugDumpHTML: debugDumpHTML,
+            allowNavigationTimeoutRetry: allowNavigationTimeoutRetry,
             timeout: timeout)
     }
 
@@ -85,31 +224,41 @@ public struct OpenAIDashboardFetcher {
         websiteDataStore: WKWebsiteDataStore,
         logger: ((String) -> Void)? = nil,
         debugDumpHTML: Bool = false,
+        allowNavigationTimeoutRetry: Bool = true,
         timeout: TimeInterval = 60) async throws -> OpenAIDashboardSnapshot
     {
         let deadline = Self.deadline(startingAt: Date(), timeout: timeout)
+        let preflight = try await Self.fetchDashboardAPIPreflight(
+            websiteDataStore: websiteDataStore,
+            deadline: deadline,
+            logger: { logger?($0) })
+        try Task.checkCancellation()
+        let (apiData, verifiedSignedInEmail) = (preflight.apiData, preflight.verifiedSignedInEmail)
+        let remainingTimeout = try Self.requiredRemainingTimeout(until: deadline)
+
         let lease = try await self.makeWebView(
             websiteDataStore: websiteDataStore,
             logger: logger,
-            timeout: Self.remainingTimeout(until: deadline))
+            timeout: remainingTimeout,
+            allowNavigationTimeoutRetry: allowNavigationTimeoutRetry)
         defer { lease.release() }
         let webView = lease.webView
         let log = lease.log
 
         var lastBody: String?
-        var lastHTML: String?
         var lastHref: String?
         var lastFlags: (loginRequired: Bool, workspacePicker: Bool, cloudflare: Bool)?
         var codeReviewFirstSeenAt: Date?
         var anyDashboardSignalAt: Date?
         var creditsHeaderVisibleAt: Date?
+        var usageBreakdownErrorFirstSeenAt: Date?
         var lastUsageBreakdownDebug: String?
+        var lastUsageBreakdownError: String?
         var lastCreditsPurchaseURL: String?
-
         while Date() < deadline {
+            try Task.checkCancellation()
             let scrape = try await self.scrape(webView: webView)
             lastBody = scrape.bodyText ?? lastBody
-            lastHTML = scrape.bodyHTML ?? lastHTML
 
             if scrape.href != lastHref
                 || lastFlags?.loginRequired != scrape.loginRequired
@@ -125,46 +274,35 @@ public struct OpenAIDashboardFetcher {
             }
 
             if scrape.workspacePicker {
-                try? await Task.sleep(for: .milliseconds(500))
+                try await Self.sleepForDashboardPoll(.milliseconds(500))
                 continue
             }
 
+            try await self.handleBlockingScrapeState(
+                scrape,
+                webView: webView,
+                debugDumpHTML: debugDumpHTML,
+                logger: log)
+
             // The page is a SPA and can land on ChatGPT UI or other routes; keep forcing the usage URL.
-            if let href = scrape.href, !href.contains("/codex/settings/usage") {
-                _ = webView.load(URLRequest(url: self.usageURL))
-                try? await Task.sleep(for: .milliseconds(500))
+            if Self.shouldReloadUsageRoute(scrape) {
+                _ = webView.load(Self.usageURLRequest(url: self.usageURL))
+                try await Self.sleepForDashboardPoll(.milliseconds(500))
                 continue
             }
 
-            if scrape.loginRequired {
-                if debugDumpHTML, let html = scrape.bodyHTML {
-                    Self.writeDebugArtifacts(html: html, bodyText: scrape.bodyText, logger: log)
-                }
-                throw FetchError.loginRequired
-            }
-
-            if scrape.cloudflareInterstitial {
-                if debugDumpHTML, let html = scrape.bodyHTML {
-                    Self.writeDebugArtifacts(html: html, bodyText: scrape.bodyText, logger: log)
-                }
-                throw FetchError.noDashboardData(body: "Cloudflare challenge detected in WebView.")
-            }
-
-            let bodyText = scrape.bodyText ?? ""
-            let codeReview = OpenAIDashboardParser.parseCodeReviewRemainingPercent(bodyText: bodyText)
-            let events = OpenAIDashboardParser.parseCreditEvents(rows: scrape.rows)
-            let breakdown = OpenAIDashboardSnapshot.makeDailyBreakdown(from: events, maxDays: 30)
-            let usageBreakdown = scrape.usageBreakdown
-            let rateLimits = OpenAIDashboardParser.parseRateLimits(bodyText: bodyText)
-            let creditsRemaining = OpenAIDashboardParser.parseCreditsRemaining(bodyText: bodyText)
-            let accountPlan = scrape.bodyHTML.flatMap(OpenAIDashboardParser.parsePlanFromHTML)
-            let hasUsageLimits = rateLimits.primary != nil || rateLimits.secondary != nil
+            let dashboardData = Self.parseDashboardScrape(
+                scrape,
+                apiData: apiData,
+                verifiedSignedInEmail: verifiedSignedInEmail)
+            let codeReview = dashboardData.codeReview
+            let events = dashboardData.events
+            let usageBreakdown = dashboardData.usageBreakdown
+            let hasDashboardPageSignal = dashboardData.hasDashboardPageSignal
+            let hasReturnableData = dashboardData.hasReturnableData
 
             if codeReview != nil, codeReviewFirstSeenAt == nil { codeReviewFirstSeenAt = Date() }
-            if anyDashboardSignalAt == nil,
-               codeReview != nil || !usageBreakdown.isEmpty || scrape.creditsHeaderPresent ||
-               hasUsageLimits || creditsRemaining != nil
-            {
+            if anyDashboardSignalAt == nil, hasDashboardPageSignal {
                 anyDashboardSignalAt = Date()
             }
             if codeReview != nil, usageBreakdown.isEmpty,
@@ -174,12 +312,19 @@ public struct OpenAIDashboardFetcher {
                 lastUsageBreakdownDebug = debug
                 log("usage breakdown debug: \(debug)")
             }
+            Self.updateUsageBreakdownErrorState(
+                usageBreakdown: usageBreakdown,
+                error: scrape.usageBreakdownError,
+                firstSeenAt: &usageBreakdownErrorFirstSeenAt,
+                lastError: &lastUsageBreakdownError,
+                logger: log)
             if let purchaseURL = scrape.creditsPurchaseURL, purchaseURL != lastCreditsPurchaseURL {
                 lastCreditsPurchaseURL = purchaseURL
                 log("credits purchase url: \(purchaseURL)")
             }
             if events.isEmpty,
-               codeReview != nil || !usageBreakdown.isEmpty || hasUsageLimits || creditsRemaining != nil
+               hasReturnableData,
+               hasDashboardPageSignal
             {
                 log(
                     "credits header present=\(scrape.creditsHeaderPresent) " +
@@ -187,7 +332,7 @@ public struct OpenAIDashboardFetcher {
                         "rows=\(scrape.rows.count)")
                 if scrape.didScrollToCredits {
                     log("scrollIntoView(Credits usage history) requested; waiting…")
-                    try? await Task.sleep(for: .milliseconds(600))
+                    try await Self.sleepForDashboardPoll(.milliseconds(600))
                     continue
                 }
 
@@ -204,135 +349,194 @@ public struct OpenAIDashboardFetcher {
                     creditsHeaderInViewport: scrape.creditsHeaderInViewport,
                     didScrollToCredits: scrape.didScrollToCredits))
                 {
-                    try? await Task.sleep(for: .milliseconds(400))
+                    try await Self.sleepForDashboardPoll(.milliseconds(400))
                     continue
                 }
             }
 
-            if codeReview != nil || !events.isEmpty || !usageBreakdown
-                .isEmpty || hasUsageLimits || creditsRemaining != nil
-            {
+            if hasReturnableData, hasDashboardPageSignal {
+                if usageBreakdown.isEmpty,
+                   let error = scrape.usageBreakdownError, !error.isEmpty,
+                   Self.shouldWaitForUsageBreakdownRecovery(.init(
+                       now: Date(),
+                       errorFirstSeenAt: usageBreakdownErrorFirstSeenAt))
+                {
+                    try await Self.sleepForDashboardPoll(.milliseconds(400))
+                    continue
+                }
+
                 // The usage breakdown chart is hydrated asynchronously. When code review is already present,
                 // give it a moment to populate so the menu can show it.
                 if codeReview != nil, usageBreakdown.isEmpty {
                     let elapsed = Date().timeIntervalSince(codeReviewFirstSeenAt ?? Date())
                     if elapsed < 6 {
-                        try? await Task.sleep(for: .milliseconds(400))
+                        try await Self.sleepForDashboardPoll(.milliseconds(400))
                         continue
                     }
                 }
-                return OpenAIDashboardSnapshot(
-                    signedInEmail: scrape.signedInEmail,
-                    codeReviewRemainingPercent: codeReview,
-                    creditEvents: events,
-                    dailyBreakdown: breakdown,
+                return Self.makeDashboardSnapshot(.init(
+                    signedInEmail: dashboardData.signedInEmail,
+                    scrape: scrape,
+                    codeReview: codeReview,
+                    codeReviewLimit: dashboardData.codeReviewLimit,
+                    events: events,
+                    breakdown: dashboardData.breakdown,
                     usageBreakdown: usageBreakdown,
-                    creditsPurchaseURL: scrape.creditsPurchaseURL,
-                    primaryLimit: rateLimits.primary,
-                    secondaryLimit: rateLimits.secondary,
-                    creditsRemaining: creditsRemaining,
-                    accountPlan: accountPlan,
-                    updatedAt: Date())
+                    rateLimits: dashboardData.rateLimits,
+                    extraRateWindows: dashboardData.extraRateWindows,
+                    creditsRemaining: dashboardData.creditsRemaining,
+                    accountPlan: dashboardData.accountPlan))
             }
 
-            try? await Task.sleep(for: .milliseconds(500))
+            try await Self.sleepForDashboardPoll(.milliseconds(500))
         }
 
-        if debugDumpHTML, let html = lastHTML {
+        if debugDumpHTML, let html = try? await self.fetchDebugHTML(webView: webView) {
             Self.writeDebugArtifacts(html: html, bodyText: lastBody, logger: log)
         }
-        throw FetchError.noDashboardData(body: lastBody ?? "")
+        throw FetchError.noDashboardData(body: lastUsageBreakdownError ?? lastBody ?? "")
     }
 
-    struct CreditsHistoryWaitContext: Sendable {
-        let now: Date
-        let anyDashboardSignalAt: Date?
-        let creditsHeaderVisibleAt: Date?
-        let creditsHeaderPresent: Bool
-        let creditsHeaderInViewport: Bool
-        let didScrollToCredits: Bool
+    nonisolated static func hasReturnableDashboardData(
+        codeReview: Double?,
+        events: [CreditEvent],
+        usageBreakdown: [OpenAIDashboardDailyBreakdown],
+        hasUsageLimits: Bool,
+        creditsRemaining: Double?) -> Bool
+    {
+        codeReview != nil || !events.isEmpty || !usageBreakdown.isEmpty || hasUsageLimits || creditsRemaining != nil
     }
 
-    nonisolated static func shouldWaitForCreditsHistory(_ context: CreditsHistoryWaitContext) -> Bool {
-        if context.didScrollToCredits { return true }
+    nonisolated static func hasAnyDashboardSignal(
+        hasReturnableData: Bool,
+        creditsHeaderPresent: Bool) -> Bool
+    {
+        hasReturnableData || creditsHeaderPresent
+    }
 
-        // When the header is visible but rows are still empty, wait briefly for the table to render.
-        if context.creditsHeaderPresent, context.creditsHeaderInViewport {
-            if let creditsHeaderVisibleAt = context.creditsHeaderVisibleAt {
-                return context.now.timeIntervalSince(creditsHeaderVisibleAt) < 2.5
-            }
-            return true
-        }
+    public func clearSessionData(
+        accountEmail: String?,
+        cacheScope: CookieHeaderCache.Scope? = nil) async
+    {
+        let store = OpenAIDashboardWebsiteDataStore.store(forAccountEmail: accountEmail, scope: cacheScope)
+        OpenAIDashboardWebViewCache.shared.evict(websiteDataStore: store)
+        await OpenAIDashboardWebsiteDataStore.clearStore(forAccountEmail: accountEmail, scope: cacheScope)
+    }
 
-        // Header not in view yet: allow a short grace period after we first detect any dashboard signal so
-        // a scroll (or hydration) can bring the credits section into the DOM.
-        if let anyDashboardSignalAt = context.anyDashboardSignalAt {
-            return context.now.timeIntervalSince(anyDashboardSignalAt) < 6.5
-        }
-        return false
+    public static func evictAllCachedWebViews() {
+        OpenAIDashboardWebViewCache.shared.evictAll()
     }
 
-    public func clearSessionData(accountEmail: String?) async {
-        let store = OpenAIDashboardWebsiteDataStore.store(forAccountEmail: accountEmail)
-        OpenAIDashboardWebViewCache.shared.evict(websiteDataStore: store)
-        await OpenAIDashboardWebsiteDataStore.clearStore(forAccountEmail: accountEmail)
+    public static func evictIdleCachedWebViews() {
+        OpenAIDashboardWebViewCache.shared.evictIdle()
+    }
+
+    #if DEBUG
+    public static func seedCachedWebViewsForMemoryPressureProof() {
+        OpenAIDashboardWebViewCache.shared.clearAllForTesting()
+        OpenAIDashboardWebViewCache.shared.cacheEntryForTesting(websiteDataStore: .nonPersistent())
+        OpenAIDashboardWebViewCache.shared.cacheEntryForTesting(websiteDataStore: .nonPersistent(), isBusy: true)
+    }
+
+    public static func cachedWebViewCountForTesting() -> Int {
+        OpenAIDashboardWebViewCache.shared.entryCount
     }
+    #endif
 
     public func probeUsagePage(
         websiteDataStore: WKWebsiteDataStore,
         logger: ((String) -> Void)? = nil,
-        timeout: TimeInterval = 30) async throws -> ProbeResult
+        timeout: TimeInterval = 30,
+        preserveLoadedPageForReuse: Bool = false) async throws -> ProbeResult
     {
         let deadline = Self.deadline(startingAt: Date(), timeout: timeout)
         let lease = try await self.makeWebView(
             websiteDataStore: websiteDataStore,
             logger: logger,
-            timeout: Self.remainingTimeout(until: deadline))
+            timeout: Self.remainingTimeout(until: deadline),
+            preserveLoadedPageOnRelease: preserveLoadedPageForReuse)
         defer { lease.release() }
         let webView = lease.webView
         let log = lease.log
 
         var lastBody: String?
         var lastHref: String?
+        var usageRouteSeenAt: Date?
+        var dashboardSignalSeenAt: Date?
 
         while Date() < deadline {
+            try Task.checkCancellation()
             let scrape = try await self.scrape(webView: webView)
             lastBody = scrape.bodyText ?? lastBody
             lastHref = scrape.href ?? lastHref
 
             if scrape.workspacePicker {
-                try? await Task.sleep(for: .milliseconds(500))
+                try await Self.sleepForDashboardPoll(.milliseconds(500))
                 continue
             }
 
-            if let href = scrape.href, !href.contains("/codex/settings/usage") {
-                _ = webView.load(URLRequest(url: self.usageURL))
-                try? await Task.sleep(for: .milliseconds(500))
+            Self.logBlockingStateIfNeeded(scrape, logger: log)
+            try Self.throwIfBlockingScrapeState(scrape)
+
+            if Self.shouldReloadUsageRoute(scrape) {
+                usageRouteSeenAt = nil
+                dashboardSignalSeenAt = nil
+                _ = webView.load(Self.usageURLRequest(url: self.usageURL))
+                try await Self.sleepForDashboardPoll(.milliseconds(500))
                 continue
             }
 
-            if scrape.loginRequired { throw FetchError.loginRequired }
-            if scrape.cloudflareInterstitial {
-                throw FetchError.noDashboardData(body: "Cloudflare challenge detected in WebView.")
+            let normalizedEmail = scrape.signedInEmail?.trimmingCharacters(in: .whitespacesAndNewlines)
+            let bodyText = scrape.bodyText ?? ""
+            let rateLimits = OpenAIDashboardParser.parseRateLimits(bodyText: bodyText)
+            let hasDashboardSignal = normalizedEmail?.isEmpty == false ||
+                !scrape.rows.isEmpty ||
+                !scrape.usageBreakdown.isEmpty ||
+                scrape.creditsHeaderPresent ||
+                OpenAIDashboardParser.parseCodeReviewRemainingPercent(bodyText: bodyText) != nil ||
+                OpenAIDashboardParser.parseCreditsRemaining(bodyText: bodyText) != nil ||
+                rateLimits.primary != nil ||
+                rateLimits.secondary != nil
+
+            if usageRouteSeenAt == nil {
+                usageRouteSeenAt = Date()
+            }
+            if hasDashboardSignal, dashboardSignalSeenAt == nil {
+                dashboardSignalSeenAt = Date()
+            }
+            if Self.shouldWaitForProbeReadiness(.init(
+                now: Date(),
+                usageRouteSeenAt: usageRouteSeenAt,
+                dashboardSignalSeenAt: dashboardSignalSeenAt,
+                signedInEmail: normalizedEmail,
+                hasDashboardSignal: hasDashboardSignal))
+            {
+                try await Self.sleepForDashboardPoll(.milliseconds(400))
+                continue
             }
 
-            return ProbeResult(
+            let result = ProbeResult(
                 href: scrape.href,
                 loginRequired: scrape.loginRequired,
                 workspacePicker: scrape.workspacePicker,
                 cloudflareInterstitial: scrape.cloudflareInterstitial,
-                signedInEmail: scrape.signedInEmail?.trimmingCharacters(in: .whitespacesAndNewlines),
+                signedInEmail: normalizedEmail,
                 bodyText: scrape.bodyText)
+            lease.setPreserveLoadedPageOnRelease(
+                preserveLoadedPageForReuse && Self.shouldPreserveLoadedPageAfterProbe(result))
+            return result
         }
 
         log("Probe timed out (href=\(lastHref ?? "nil"))")
-        return ProbeResult(
+        let result = ProbeResult(
             href: lastHref,
             loginRequired: false,
             workspacePicker: false,
             cloudflareInterstitial: false,
             signedInEmail: nil,
             bodyText: lastBody)
+        lease.setPreserveLoadedPageOnRelease(false)
+        return result
     }
 
     // MARK: - JS scrape
@@ -343,12 +547,14 @@ public struct OpenAIDashboardFetcher {
         let cloudflareInterstitial: Bool
         let href: String?
         let bodyText: String?
-        let bodyHTML: String?
         let signedInEmail: String?
+        let authStatus: String?
+        let accountPlan: String?
         let creditsPurchaseURL: String?
         let rows: [[String]]
         let usageBreakdown: [OpenAIDashboardDailyBreakdown]
         let usageBreakdownDebug: String?
+        let usageBreakdownError: String?
         let scrollY: Double
         let scrollHeight: Double
         let viewportHeight: Double
@@ -366,12 +572,14 @@ public struct OpenAIDashboardFetcher {
                 cloudflareInterstitial: false,
                 href: nil,
                 bodyText: nil,
-                bodyHTML: nil,
                 signedInEmail: nil,
+                authStatus: nil,
+                accountPlan: nil,
                 creditsPurchaseURL: nil,
                 rows: [],
                 usageBreakdown: [],
                 usageBreakdownDebug: nil,
+                usageBreakdownError: nil,
                 scrollY: 0,
                 scrollHeight: 0,
                 viewportHeight: 0,
@@ -384,14 +592,15 @@ public struct OpenAIDashboardFetcher {
         let workspacePicker = (dict["workspacePicker"] as? Bool) ?? false
         let cloudflareInterstitial = (dict["cloudflareInterstitial"] as? Bool) ?? false
         let rows = (dict["rows"] as? [[String]]) ?? []
-        let bodyHTML = dict["bodyHTML"] as? String
 
         var usageBreakdown: [OpenAIDashboardDailyBreakdown] = []
         let usageBreakdownDebug = dict["usageBreakdownDebug"] as? String
+        let usageBreakdownError = dict["usageBreakdownError"] as? String
         if let raw = dict["usageBreakdownJSON"] as? String, !raw.isEmpty {
             do {
                 let decoder = JSONDecoder()
-                usageBreakdown = try decoder.decode([OpenAIDashboardDailyBreakdown].self, from: Data(raw.utf8))
+                let decoded = try decoder.decode([OpenAIDashboardDailyBreakdown].self, from: Data(raw.utf8))
+                usageBreakdown = OpenAIDashboardDailyBreakdown.removingSkillUsageServices(from: decoded)
             } catch {
                 // Best-effort parse; ignore errors to avoid blocking other dashboard data.
                 usageBreakdown = []
@@ -399,18 +608,14 @@ public struct OpenAIDashboardFetcher {
         }
 
         var signedInEmail = dict["signedInEmail"] as? String
-        if let bodyHTML,
-           signedInEmail == nil || signedInEmail?.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty == true
-        {
-            signedInEmail = OpenAIDashboardParser.parseSignedInEmailFromClientBootstrap(html: bodyHTML)
-        }
+        signedInEmail = signedInEmail?.trimmingCharacters(in: .whitespacesAndNewlines)
+        let authStatus = (dict["authStatus"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines)
+        let accountPlan = (dict["accountPlan"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines)
 
-        if let bodyHTML, let authStatus = OpenAIDashboardParser.parseAuthStatusFromClientBootstrap(html: bodyHTML) {
-            if authStatus.lowercased() != "logged_in" {
-                // When logged out, the SPA can render a generic landing shell without obvious auth inputs,
-                // so treat it as login-required and let the caller retry cookie import.
-                loginRequired = true
-            }
+        if let authStatus, !authStatus.isEmpty, authStatus.lowercased() != "logged_in" {
+            // When logged out, the SPA can render a generic landing shell without obvious auth inputs,
+            // so treat it as login-required and let the caller retry cookie import.
+            loginRequired = true
         }
 
         return ScrapeResult(
@@ -419,12 +624,14 @@ public struct OpenAIDashboardFetcher {
             cloudflareInterstitial: cloudflareInterstitial,
             href: dict["href"] as? String,
             bodyText: dict["bodyText"] as? String,
-            bodyHTML: bodyHTML,
             signedInEmail: signedInEmail,
+            authStatus: authStatus,
+            accountPlan: accountPlan,
             creditsPurchaseURL: dict["creditsPurchaseURL"] as? String,
             rows: rows,
             usageBreakdown: usageBreakdown,
             usageBreakdownDebug: usageBreakdownDebug,
+            usageBreakdownError: usageBreakdownError,
             scrollY: (dict["scrollY"] as? NSNumber)?.doubleValue ?? 0,
             scrollHeight: (dict["scrollHeight"] as? NSNumber)?.doubleValue ?? 0,
             viewportHeight: (dict["viewportHeight"] as? NSNumber)?.doubleValue ?? 0,
@@ -433,16 +640,35 @@ public struct OpenAIDashboardFetcher {
             didScrollToCredits: (dict["didScrollToCredits"] as? Bool) ?? false)
     }
 
+    private static func throwIfBlockingScrapeState(_ scrape: ScrapeResult) throws {
+        if scrape.loginRequired {
+            throw FetchError.loginRequired
+        }
+
+        if scrape.cloudflareInterstitial {
+            throw FetchError.noDashboardData(body: "Cloudflare challenge detected in WebView.")
+        }
+    }
+
+    private func fetchDebugHTML(webView: WKWebView) async throws -> String? {
+        try await webView.evaluateJavaScript(
+            "document.documentElement ? String(document.documentElement.outerHTML || '') : ''") as? String
+    }
+
     private func makeWebView(
         websiteDataStore: WKWebsiteDataStore,
         logger: ((String) -> Void)?,
-        timeout: TimeInterval) async throws -> OpenAIDashboardWebViewLease
+        timeout: TimeInterval,
+        allowNavigationTimeoutRetry: Bool = true,
+        preserveLoadedPageOnRelease: Bool = false) async throws -> OpenAIDashboardWebViewLease
     {
         try await OpenAIDashboardWebViewCache.shared.acquire(
             websiteDataStore: websiteDataStore,
             usageURL: self.usageURL,
             logger: logger,
-            navigationTimeout: timeout)
+            navigationTimeout: timeout,
+            allowTimeoutRetry: allowNavigationTimeoutRetry,
+            preserveLoadedPageOnRelease: preserveLoadedPageOnRelease)
     }
 
     nonisolated static func sanitizedTimeout(_ timeout: TimeInterval) -> TimeInterval {
@@ -458,6 +684,207 @@ public struct OpenAIDashboardFetcher {
         max(0, deadline.timeIntervalSince(now))
     }
 
+    nonisolated static func isUsageRoute(_ href: String?) -> Bool {
+        guard let href, !href.isEmpty else { return false }
+        let path = (URL(string: href)?.path ?? href)
+            .trimmingCharacters(in: CharacterSet(charactersIn: "/"))
+        return path.hasSuffix("codex/settings/usage")
+            || path.hasSuffix("codex/cloud/settings/usage")
+            || path.hasSuffix("codex/settings/analytics")
+            || path.hasSuffix("codex/cloud/settings/analytics")
+    }
+
+    nonisolated static func shouldReloadUsageRoute(
+        href: String?,
+        loginRequired: Bool,
+        workspacePicker: Bool,
+        cloudflareInterstitial: Bool) -> Bool
+    {
+        guard !workspacePicker, !loginRequired, !cloudflareInterstitial else { return false }
+        guard let href else { return false }
+        return !self.isUsageRoute(href)
+    }
+
+    private nonisolated static func shouldReloadUsageRoute(_ scrape: ScrapeResult) -> Bool {
+        self.shouldReloadUsageRoute(
+            href: scrape.href,
+            loginRequired: scrape.loginRequired,
+            workspacePicker: scrape.workspacePicker,
+            cloudflareInterstitial: scrape.cloudflareInterstitial)
+    }
+
+    nonisolated static func usageURLRequest(url: URL) -> URLRequest {
+        var request = URLRequest(url: url)
+        request.setValue(Self.dashboardAcceptLanguage, forHTTPHeaderField: "Accept-Language")
+        return request
+    }
+
+    nonisolated static func dashboardAPIData(from response: CodexUsageResponse) -> DashboardAPIData {
+        DashboardAPIData(
+            primaryLimit: self.rateWindow(from: response.rateLimit?.primaryWindow),
+            secondaryLimit: self.rateWindow(from: response.rateLimit?.secondaryWindow),
+            extraRateWindows: CodexAdditionalRateLimitMapper.extraRateWindows(
+                from: response.additionalRateLimits),
+            creditsRemaining: response.credits?.balance,
+            accountPlan: response.planType?.rawValue)
+    }
+
+    private static func fetchDashboardAPIPreflight(
+        websiteDataStore: WKWebsiteDataStore,
+        deadline: Date,
+        logger: @escaping (String) -> Void)
+        async throws -> (apiData: DashboardAPIData?, verifiedSignedInEmail: String?)
+    {
+        let cookieHeader = try await self.chatGPTCookieHeader(in: websiteDataStore, deadline: deadline)
+        let apiData = await self.fetchDashboardUsageAPI(
+            cookieHeader: cookieHeader,
+            deadline: deadline,
+            logger: logger)
+        let verifiedEmail: String? = if apiData?.hasUsageData == true {
+            await self.fetchSignedInEmailFromAPI(
+                cookieHeader: cookieHeader,
+                deadline: deadline,
+                logger: logger)
+        } else {
+            nil
+        }
+
+        if apiData?.hasUsageData == true, verifiedEmail != nil {
+            logger("usage api supplied verified dashboard data; continuing WebView scrape")
+        }
+        return (apiData, verifiedEmail)
+    }
+
+    private static func fetchDashboardUsageAPI(
+        websiteDataStore: WKWebsiteDataStore,
+        logger: @escaping (String) -> Void) async -> DashboardAPIData?
+    {
+        guard let cookieHeader = try? await self.chatGPTCookieHeader(in: websiteDataStore, deadline: nil) else {
+            return nil
+        }
+        return await self.fetchDashboardUsageAPI(cookieHeader: cookieHeader, deadline: nil, logger: logger)
+    }
+
+    private static func fetchDashboardUsageAPI(
+        cookieHeader: String,
+        deadline: Date?,
+        logger: @escaping (String) -> Void) async -> DashboardAPIData?
+    {
+        guard !cookieHeader.isEmpty else { return nil }
+        let remaining = deadline.map { self.remainingTimeout(until: $0) } ?? 4
+        guard remaining > 0 else { return nil }
+
+        do {
+            let (data, response) = try await ProviderHTTPClient.shared.data(
+                for: self.dashboardUsageAPIRequest(cookieHeader: cookieHeader, timeout: min(4, remaining)))
+            let status = (response as? HTTPURLResponse)?.statusCode ?? -1
+            logger("usage api status=\(status)")
+            guard status >= 200, status < 300 else { return nil }
+            let decoded = try JSONDecoder().decode(CodexUsageResponse.self, from: data)
+            let result = self.dashboardAPIData(from: decoded)
+            if result.hasUsageData {
+                logger("usage api supplied language-independent rate/credit data")
+            }
+            return result
+        } catch {
+            logger("usage api unavailable: \(error.localizedDescription)")
+            return nil
+        }
+    }
+
+    private static func fetchSignedInEmailFromAPI(
+        cookieHeader: String,
+        deadline: Date?,
+        logger: @escaping (String) -> Void) async -> String?
+    {
+        guard !cookieHeader.isEmpty else { return nil }
+
+        let endpoints = [
+            URL(string: "https://chatgpt.com/backend-api/me"),
+            URL(string: "https://chatgpt.com/api/auth/session"),
+        ].compactMap(\.self)
+
+        for url in endpoints {
+            let remaining = deadline.map { self.remainingTimeout(until: $0) } ?? 2
+            guard remaining > 0 else { return nil }
+            do {
+                let (data, response) = try await ProviderHTTPClient.shared.data(
+                    for: self.dashboardIdentityAPIRequest(
+                        url: url,
+                        cookieHeader: cookieHeader,
+                        timeout: min(2, remaining)))
+                let status = (response as? HTTPURLResponse)?.statusCode ?? -1
+                logger("identity api \(url.path) status=\(status)")
+                guard status >= 200, status < 300 else { continue }
+                if let email = self.findFirstEmail(inJSONData: data) {
+                    return email.trimmingCharacters(in: .whitespacesAndNewlines)
+                }
+            } catch {
+                logger("identity api \(url.path) unavailable: \(error.localizedDescription)")
+            }
+        }
+
+        return nil
+    }
+
+    private static func chatGPTCookieHeader(in store: WKWebsiteDataStore, deadline: Date?) async throws -> String {
+        let cookies = try await OpenAIDashboardBrowserCookieImporter.runBoundedValueCallback(
+            deadline: deadline)
+        { completion in
+            store.httpCookieStore.getAllCookies(completion)
+        }
+
+        return cookies
+            .filter { $0.domain.lowercased().contains("chatgpt.com") }
+            .map { "\($0.name)=\($0.value)" }
+            .joined(separator: "; ")
+    }
+
+    nonisolated static func findFirstEmail(inJSONData data: Data) -> String? {
+        guard let json = try? JSONSerialization.jsonObject(with: data, options: []) else { return nil }
+        var queue: [Any] = [json]
+        var seen = 0
+        while !queue.isEmpty, seen < 2000 {
+            let current = queue.removeFirst()
+            seen += 1
+            if let string = current as? String, string.contains("@") {
+                return string
+            }
+            if let dictionary = current as? [String: Any] {
+                for (key, value) in dictionary {
+                    if key.lowercased() == "email",
+                       let string = value as? String,
+                       string.contains("@")
+                    {
+                        return string
+                    }
+                    queue.append(value)
+                }
+            } else if let array = current as? [Any] {
+                queue.append(contentsOf: array)
+            }
+        }
+        return nil
+    }
+
+    private nonisolated static func rateWindow(from window: CodexUsageResponse.WindowSnapshot?) -> RateWindow? {
+        guard let window else { return nil }
+        let resetDate = Date(timeIntervalSince1970: TimeInterval(window.resetAt))
+        return RateWindow(
+            usedPercent: Double(window.usedPercent),
+            windowMinutes: window.limitWindowSeconds / 60,
+            resetsAt: resetDate,
+            resetDescription: UsageFormatter.resetDescription(from: resetDate))
+    }
+
+    private nonisolated static func firstNonEmpty(_ candidates: String?...) -> String? {
+        for candidate in candidates {
+            let trimmed = candidate?.trimmingCharacters(in: .whitespacesAndNewlines)
+            if trimmed?.isEmpty == false { return trimmed }
+        }
+        return nil
+    }
+
     private static func writeDebugArtifacts(html: String, bodyText: String?, logger: (String) -> Void) {
         let stamp = Int(Date().timeIntervalSince1970)
         let dir = URL(fileURLWithPath: NSTemporaryDirectory(), isDirectory: true)
@@ -480,6 +907,157 @@ public struct OpenAIDashboardFetcher {
         }
     }
 }
+
+extension OpenAIDashboardFetcher {
+    struct CreditsHistoryWaitContext {
+        let now: Date
+        let anyDashboardSignalAt: Date?
+        let creditsHeaderVisibleAt: Date?
+        let creditsHeaderPresent: Bool
+        let creditsHeaderInViewport: Bool
+        let didScrollToCredits: Bool
+    }
+
+    nonisolated static func shouldWaitForCreditsHistory(_ context: CreditsHistoryWaitContext) -> Bool {
+        if context.didScrollToCredits { return true }
+
+        // When the header is visible but rows are still empty, wait briefly for the table to render.
+        if context.creditsHeaderPresent, context.creditsHeaderInViewport {
+            if let creditsHeaderVisibleAt = context.creditsHeaderVisibleAt {
+                return context.now.timeIntervalSince(creditsHeaderVisibleAt) < 2.5
+            }
+            return true
+        }
+
+        // Header not in view yet: allow a short grace period after we first detect any dashboard signal so
+        // a scroll (or hydration) can bring the credits section into the DOM.
+        if let anyDashboardSignalAt = context.anyDashboardSignalAt {
+            return context.now.timeIntervalSince(anyDashboardSignalAt) < 6.5
+        }
+        return false
+    }
+
+    struct ProbeReadinessContext {
+        let now: Date
+        let usageRouteSeenAt: Date?
+        let dashboardSignalSeenAt: Date?
+        let signedInEmail: String?
+        let hasDashboardSignal: Bool
+    }
+
+    struct UsageBreakdownRecoveryContext {
+        let now: Date
+        let errorFirstSeenAt: Date?
+    }
+
+    nonisolated static func shouldWaitForUsageBreakdownRecovery(_ context: UsageBreakdownRecoveryContext) -> Bool {
+        guard let errorFirstSeenAt = context.errorFirstSeenAt else { return true }
+        return context.now.timeIntervalSince(errorFirstSeenAt) < 4.0
+    }
+
+    nonisolated static func shouldWaitForProbeReadiness(_ context: ProbeReadinessContext) -> Bool {
+        if let signedInEmail = context.signedInEmail?.trimmingCharacters(in: .whitespacesAndNewlines),
+           !signedInEmail.isEmpty
+        {
+            return false
+        }
+
+        if context.hasDashboardSignal {
+            if let dashboardSignalSeenAt = context.dashboardSignalSeenAt {
+                return context.now.timeIntervalSince(dashboardSignalSeenAt) < 2.0
+            }
+            return true
+        }
+
+        if let usageRouteSeenAt = context.usageRouteSeenAt {
+            return context.now.timeIntervalSince(usageRouteSeenAt) < 2.0
+        }
+
+        return false
+    }
+
+    nonisolated static func updateUsageBreakdownErrorState(
+        usageBreakdown: [OpenAIDashboardDailyBreakdown],
+        error: String?,
+        firstSeenAt: inout Date?,
+        lastError: inout String?,
+        now: Date = Date(),
+        logger: (String) -> Void)
+    {
+        guard usageBreakdown.isEmpty, let error, !error.isEmpty else {
+            firstSeenAt = nil
+            return
+        }
+        if firstSeenAt == nil { firstSeenAt = now }
+        guard error != lastError else { return }
+        lastError = error
+        logger("usage breakdown error: \(error)")
+    }
+}
+
+extension OpenAIDashboardFetcher {
+    nonisolated static func requiredRemainingTimeout(
+        until deadline: Date,
+        now: Date = Date()) throws -> TimeInterval
+    {
+        let remaining = self.remainingTimeout(until: deadline, now: now)
+        guard remaining > 0 else { throw URLError(.timedOut) }
+        return remaining
+    }
+
+    nonisolated static func dashboardUsageAPIRequest(
+        cookieHeader: String,
+        timeout: TimeInterval = 4) -> URLRequest
+    {
+        var request = URLRequest(url: Self.dashboardUsageAPIURL)
+        request.httpMethod = "GET"
+        request.timeoutInterval = timeout
+        request.setValue(cookieHeader, forHTTPHeaderField: "Cookie")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        request.setValue(Self.dashboardAcceptLanguage, forHTTPHeaderField: "Accept-Language")
+        request.setValue("CodexBar", forHTTPHeaderField: "User-Agent")
+        return request
+    }
+
+    nonisolated static func dashboardIdentityAPIRequest(
+        url: URL,
+        cookieHeader: String,
+        timeout: TimeInterval = 2) -> URLRequest
+    {
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.timeoutInterval = timeout
+        request.setValue(cookieHeader, forHTTPHeaderField: "Cookie")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        request.setValue(Self.dashboardAcceptLanguage, forHTTPHeaderField: "Accept-Language")
+        request.setValue("CodexBar", forHTTPHeaderField: "User-Agent")
+        return request
+    }
+
+    private static func logBlockingStateIfNeeded(_ scrape: ScrapeResult, logger: (String) -> Void) {
+        guard scrape.loginRequired || scrape.cloudflareInterstitial else { return }
+        let route = self.isUsageRoute(scrape.href) ? "usage" : "other"
+        logger(
+            "blocking state before route reload route=\(route) " +
+                "login=\(scrape.loginRequired) cloudflare=\(scrape.cloudflareInterstitial)")
+    }
+
+    private func handleBlockingScrapeState(
+        _ scrape: ScrapeResult,
+        webView: WKWebView,
+        debugDumpHTML: Bool,
+        logger: (String) -> Void) async throws
+    {
+        if debugDumpHTML,
+           scrape.loginRequired || scrape.cloudflareInterstitial,
+           let html = try? await self.fetchDebugHTML(webView: webView)
+        {
+            Self.writeDebugArtifacts(html: html, bodyText: scrape.bodyText, logger: logger)
+        }
+        Self.logBlockingStateIfNeeded(scrape, logger: logger)
+        try Self.throwIfBlockingScrapeState(scrape)
+    }
+}
 #else
 import Foundation
 
@@ -503,8 +1081,10 @@ public struct OpenAIDashboardFetcher {
 
     public func loadLatestDashboard(
         accountEmail _: String?,
+        cacheScope _: CookieHeaderCache.Scope? = nil,
         logger _: ((String) -> Void)? = nil,
         debugDumpHTML _: Bool = false,
+        allowNavigationTimeoutRetry _: Bool = true,
         timeout _: TimeInterval = 60) async throws -> OpenAIDashboardSnapshot
     {
         throw FetchError.noDashboardData(body: "OpenAI web dashboard fetch is only supported on macOS.")
diff --git a/Sources/CodexBarCore/OpenAIWeb/OpenAIDashboardNavigationDelegate.swift b/Sources/CodexBarCore/OpenAIWeb/OpenAIDashboardNavigationDelegate.swift
index cc7d937091..7162666973 100644
--- a/Sources/CodexBarCore/OpenAIWeb/OpenAIDashboardNavigationDelegate.swift
+++ b/Sources/CodexBarCore/OpenAIWeb/OpenAIDashboardNavigationDelegate.swift
@@ -8,27 +8,47 @@ import WebKit
 final class NavigationDelegate: NSObject, WKNavigationDelegate {
     private let completion: (Result<Void, Error>) -> Void
     private var hasCompleted: Bool = false
-    private var timeoutTask: Task<Void, Never>?
+    private var timeoutWorkItem: DispatchWorkItem?
+    private var postCommitWorkItem: DispatchWorkItem?
     static var associationKey: UInt8 = 0
+    nonisolated static let postCommitSuccessDelay: TimeInterval = 0.75
 
     init(completion: @escaping (Result<Void, Error>) -> Void) {
         self.completion = completion
     }
 
     func armTimeout(seconds: TimeInterval) {
-        self.timeoutTask?.cancel()
-        self.timeoutTask = Task { @MainActor [weak self] in
-            guard let self else { return }
-            let nanoseconds = UInt64(max(seconds, 0) * 1_000_000_000)
-            try? await Task.sleep(nanoseconds: nanoseconds)
-            self.completeOnce(.failure(URLError(.timedOut)))
+        self.timeoutWorkItem?.cancel()
+        let delay = max(seconds, 0)
+        let workItem = DispatchWorkItem { [weak self] in
+            MainActor.assumeIsolated {
+                self?.completeOnce(.failure(URLError(.timedOut)))
+            }
         }
+        self.timeoutWorkItem = workItem
+        DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: workItem)
+    }
+
+    func cancel() {
+        self.completeOnce(.failure(CancellationError()))
     }
 
     func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {
         self.completeOnce(.success(()))
     }
 
+    func webView(_ webView: WKWebView, didCommit navigation: WKNavigation!) {
+        guard !self.hasCompleted else { return }
+        self.postCommitWorkItem?.cancel()
+        let workItem = DispatchWorkItem { [weak self] in
+            MainActor.assumeIsolated {
+                self?.completeOnce(.success(()))
+            }
+        }
+        self.postCommitWorkItem = workItem
+        DispatchQueue.main.asyncAfter(deadline: .now() + Self.postCommitSuccessDelay, execute: workItem)
+    }
+
     func webView(_ webView: WKWebView, didFail navigation: WKNavigation!, withError error: Error) {
         if Self.shouldIgnoreNavigationError(error) { return }
         self.completeOnce(.failure(error))
@@ -41,14 +61,24 @@ final class NavigationDelegate: NSObject, WKNavigationDelegate {
 
     nonisolated static func shouldIgnoreNavigationError(_ error: Error) -> Bool {
         let nsError = error as NSError
-        return nsError.domain == NSURLErrorDomain && nsError.code == NSURLErrorCancelled
+        if nsError.domain == NSURLErrorDomain, nsError.code == NSURLErrorCancelled {
+            return true
+        }
+
+        if nsError.domain == "WebKitErrorDomain", nsError.code == 102 {
+            return true
+        }
+
+        return false
     }
 
     private func completeOnce(_ result: Result<Void, Error>) {
         guard !self.hasCompleted else { return }
         self.hasCompleted = true
-        self.timeoutTask?.cancel()
-        self.timeoutTask = nil
+        self.timeoutWorkItem?.cancel()
+        self.timeoutWorkItem = nil
+        self.postCommitWorkItem?.cancel()
+        self.postCommitWorkItem = nil
         self.completion(result)
     }
 }
diff --git a/Sources/CodexBarCore/OpenAIWeb/OpenAIDashboardParser.swift b/Sources/CodexBarCore/OpenAIWeb/OpenAIDashboardParser.swift
index 88f9373e34..b2137f1706 100644
--- a/Sources/CodexBarCore/OpenAIWeb/OpenAIDashboardParser.swift
+++ b/Sources/CodexBarCore/OpenAIWeb/OpenAIDashboardParser.swift
@@ -109,6 +109,20 @@ public enum OpenAIDashboardParser {
         return (primary, secondary)
     }
 
+    public static func parseCodeReviewLimit(bodyText: String, now: Date = .init()) -> RateWindow? {
+        let cleaned = bodyText.replacingOccurrences(of: "\r", with: "\n")
+        let lines = cleaned
+            .split(whereSeparator: \.isNewline)
+            .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
+            .filter { !$0.isEmpty }
+
+        return self.parseRateWindow(
+            lines: lines,
+            match: self.isCodeReviewLimitLine,
+            windowMinutes: nil,
+            now: now)
+    }
+
     public static func parsePlanFromHTML(html: String) -> String? {
         if let data = self.clientBootstrapJSONData(fromHTML: html),
            let plan = self.findPlan(in: data)
@@ -139,11 +153,49 @@ public enum OpenAIDashboardParser {
     }
 
     private static func parseCreditsUsed(_ text: String) -> Double {
-        let cleaned = text
-            .replacingOccurrences(of: ",", with: "")
-            .replacingOccurrences(of: "credits", with: "", options: .caseInsensitive)
-            .trimmingCharacters(in: .whitespacesAndNewlines)
-        return Double(cleaned) ?? 0
+        guard let raw = self.firstNumberToken(in: text) else { return 0 }
+        let token = raw
+            .replacingOccurrences(of: "\u{00A0}", with: "")
+            .replacingOccurrences(of: "\u{202F}", with: "")
+            .replacingOccurrences(of: " ", with: "")
+        let hasComma = token.contains(",")
+        let hasDot = token.contains(".")
+        if hasComma, hasDot {
+            return TextParsing.firstNumber(pattern: #"([0-9][0-9.,\s\p{Zs}]*)"#, text: token) ?? 0
+        }
+        if hasComma {
+            if self.usesLocalizedDecimalCommaCreditLabel(text) {
+                return Double(token.replacingOccurrences(of: ",", with: ".")) ?? 0
+            }
+            if token.range(of: #"^\d{1,3}(,\d{3})+$"#, options: .regularExpression) != nil {
+                return Double(token.replacingOccurrences(of: ",", with: "")) ?? 0
+            }
+            return Double(token.replacingOccurrences(of: ",", with: ".")) ?? 0
+        }
+        return Double(token) ?? 0
+    }
+
+    private static func usesLocalizedDecimalCommaCreditLabel(_ text: String) -> Bool {
+        text
+            .lowercased()
+            .contains("crédit")
+    }
+
+    private static func firstNumberToken(in text: String) -> String? {
+        guard let regex = try? NSRegularExpression(
+            pattern: #"([0-9][0-9.,\s\p{Zs}]*)"#,
+            options: [])
+        else {
+            return nil
+        }
+        let range = NSRange(text.startIndex..<text.endIndex, in: text)
+        guard let match = regex.firstMatch(in: text, options: [], range: range),
+              match.numberOfRanges >= 2,
+              let tokenRange = Range(match.range(at: 1), in: text)
+        else {
+            return nil
+        }
+        return String(text[tokenRange])
     }
 
     // MARK: - Private
@@ -233,36 +285,38 @@ public enum OpenAIDashboardParser {
     private static func parseRateWindow(
         lines: [String],
         match: (String) -> Bool,
-        windowMinutes: Int,
+        windowMinutes: Int?,
         now: Date) -> RateWindow?
     {
-        guard let idx = lines.firstIndex(where: match) else { return nil }
-        let end = min(lines.count - 1, idx + 5)
-        let windowLines = Array(lines[idx...end])
-
-        var percentValue: Double?
-        var isRemaining = true
-        for line in windowLines {
-            if let percent = self.parsePercent(from: line) {
-                percentValue = percent.value
-                isRemaining = percent.isRemaining
-                break
+        for idx in lines.indices where match(lines[idx]) {
+            let end = min(lines.count - 1, idx + 5)
+            let windowLines = Array(lines[idx...end])
+
+            var percentValue: Double?
+            var isRemaining = true
+            for line in windowLines {
+                if let percent = self.parsePercent(from: line) {
+                    percentValue = percent.value
+                    isRemaining = percent.isRemaining
+                    break
+                }
             }
-        }
 
-        guard let percentValue else { return nil }
-        let usedPercent = isRemaining ? max(0, min(100, 100 - percentValue)) : max(0, min(100, percentValue))
+            guard let percentValue else { continue }
+            let usedPercent = isRemaining ? max(0, min(100, 100 - percentValue)) : max(0, min(100, percentValue))
 
-        let resetLine = windowLines.first { $0.localizedCaseInsensitiveContains("reset") }
-        let resetDescription = resetLine?.trimmingCharacters(in: .whitespacesAndNewlines)
-        let resetsAt = resetLine.flatMap { self.parseResetDate(from: $0, now: now) }
-        let fallbackDescription = resetsAt.map { UsageFormatter.resetDescription(from: $0) }
+            let resetLine = windowLines.first { $0.localizedCaseInsensitiveContains("reset") }
+            let resetDescription = resetLine?.trimmingCharacters(in: .whitespacesAndNewlines)
+            let resetsAt = resetLine.flatMap { self.parseResetDate(from: $0, now: now) }
+            let fallbackDescription = resetsAt.map { UsageFormatter.resetDescription(from: $0) }
 
-        return RateWindow(
-            usedPercent: usedPercent,
-            windowMinutes: windowMinutes,
-            resetsAt: resetsAt,
-            resetDescription: resetDescription ?? fallbackDescription)
+            return RateWindow(
+                usedPercent: usedPercent,
+                windowMinutes: windowMinutes,
+                resetsAt: resetsAt,
+                resetDescription: resetDescription ?? fallbackDescription)
+        }
+        return nil
     }
 
     private static func parsePercent(from line: String) -> (value: Double, isRemaining: Bool)? {
@@ -278,6 +332,7 @@ public enum OpenAIDashboardParser {
     private static func isFiveHourLimitLine(_ line: String) -> Bool {
         let lower = line.lowercased()
         if lower.contains("5h") { return true }
+        if lower.range(of: #"\b5\s*h\b"#, options: .regularExpression) != nil { return true }
         if lower.contains("5-hour") { return true }
         if lower.contains("5 hour") { return true }
         return false
@@ -289,9 +344,17 @@ public enum OpenAIDashboardParser {
         if lower.contains("7-day") { return true }
         if lower.contains("7 day") { return true }
         if lower.contains("7d") { return true }
+        if lower.range(of: #"\b7\s*d\b"#, options: .regularExpression) != nil { return true }
         return false
     }
 
+    private static func isCodeReviewLimitLine(_ line: String) -> Bool {
+        let lower = line.lowercased()
+        guard lower.contains("code review") || lower.contains("core review") else { return false }
+        if lower.contains("github code review") { return false }
+        return true
+    }
+
     private static func parseResetDate(from line: String, now: Date) -> Date? {
         var raw = line.trimmingCharacters(in: .whitespacesAndNewlines)
         raw = raw.replacingOccurrences(of: #"(?i)^resets?:?\s*"#, with: "", options: .regularExpression)
@@ -380,7 +443,12 @@ public enum OpenAIDashboardParser {
     }
 
     private static func weekdayMatch(in text: String) -> WeekdayMatch? {
-        let pattern = #"\b(mon|tue|tues|wed|thu|thur|thurs|fri|sat|sun)(day)?\b"#
+        // The optional "(day)?" suffix requires each alternative to be long enough that
+        // adding "day" reproduces the full weekday name. "wed"+"day"="wedday" and
+        // "sat"+"day"="satday", so the longer prefixes "wednes" and "satur" are needed
+        // to cover the full "Wednesday" and "Saturday" forms — mirroring how the existing
+        // "tue|tues" and "thu|thur|thurs" alternatives layer up to "tuesday"/"thursday".
+        let pattern = #"\b(mon|tue|tues|wed|wednes|thu|thur|thurs|fri|sat|satur|sun)(day)?\b"#
         guard let regex = try? NSRegularExpression(pattern: pattern, options: [.caseInsensitive]) else { return nil }
         let range = NSRange(text.startIndex..<text.endIndex, in: text)
         guard let match = regex.firstMatch(in: text, options: [], range: range),
@@ -469,7 +537,7 @@ public enum OpenAIDashboardParser {
             "essential",
         ]
         guard allowed.contains(where: { lower.contains($0) }) else { return nil }
-        return UsageFormatter.cleanPlanName(trimmed)
+        return CodexPlanFormatting.displayName(trimmed) ?? UsageFormatter.cleanPlanName(trimmed)
     }
 }
 
diff --git a/Sources/CodexBarCore/OpenAIWeb/OpenAIDashboardScrapeScript.swift b/Sources/CodexBarCore/OpenAIWeb/OpenAIDashboardScrapeScript.swift
index 25f32a4560..b45d573c8a 100644
--- a/Sources/CodexBarCore/OpenAIWeb/OpenAIDashboardScrapeScript.swift
+++ b/Sources/CodexBarCore/OpenAIWeb/OpenAIDashboardScrapeScript.swift
@@ -175,6 +175,105 @@ let openAIDashboardScrapeScript = """
         const normalized = normalizeHref(anchorHref || dataHref || propHref);
         return normalized && isLikelyCreditsURL(normalized) ? normalized : null;
       };
+      const cleanPlanName = (raw) => String(raw || '')
+        .replace(/\\b(claude|codex|account|plan)\\b/gi, ' ')
+        .replace(/_/g, ' ')
+        .replace(/-/g, ' ')
+        .replace(/\\s+/g, ' ')
+        .trim();
+      const codexPlanDisplayName = (raw) => {
+        const trimmed = String(raw || '').trim();
+        if (!trimmed) return null;
+        const lower = trimmed.toLowerCase();
+        const exact = {
+          pro: 'Pro 20x',
+          prolite: 'Pro 5x',
+          'pro_lite': 'Pro 5x',
+          'pro-lite': 'Pro 5x',
+          'pro lite': 'Pro 5x'
+        };
+        if (exact[lower]) return exact[lower];
+        const cleaned = cleanPlanName(trimmed);
+        if (!cleaned) return trimmed;
+        if (exact[cleaned.toLowerCase()]) return exact[cleaned.toLowerCase()];
+        return cleaned.split(' ')
+          .filter(Boolean)
+          .map(word => {
+            const wordLower = word.toLowerCase();
+            if (wordLower === 'cbp' || wordLower === 'k12') return wordLower.toUpperCase();
+            if (word === word.toUpperCase() && /[a-z]/i.test(word)) return word;
+            return word.charAt(0).toUpperCase() + word.slice(1);
+          })
+          .join(' ') || cleaned;
+      };
+      const normalizePlanValue = (value) => {
+        const trimmed = String(value || '').trim();
+        if (!trimmed) return null;
+        const lower = trimmed.toLowerCase();
+        const allowed = [
+          'free',
+          'plus',
+          'pro',
+          'team',
+          'enterprise',
+          'business',
+          'edu',
+          'education',
+          'gov',
+          'premium',
+          'essential'
+        ];
+        if (!allowed.some(token => lower.includes(token))) return null;
+        return codexPlanDisplayName(trimmed) || cleanPlanName(trimmed);
+      };
+      const planCandidate = (key, value) => {
+        const lower = String(key || '').toLowerCase();
+        if (!lower.includes('plan') && !lower.includes('tier') && !lower.includes('subscription')) return null;
+        if (typeof value === 'string') return normalizePlanValue(value);
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+          return normalizePlanValue(value.name) ||
+            normalizePlanValue(value.displayName) ||
+            normalizePlanValue(value.tier);
+        }
+        return null;
+      };
+      const findPlan = (root) => {
+        if (!root || typeof root !== 'object') return null;
+        const queue = [root];
+        const seenObjects = typeof WeakSet !== 'undefined' ? new WeakSet() : null;
+        let index = 0;
+        let seen = 0;
+        while (index < queue.length && seen < 6000) {
+          const cur = queue[index++];
+          seen++;
+          if (!cur || typeof cur !== 'object') continue;
+          if (seenObjects) {
+            if (seenObjects.has(cur)) continue;
+            seenObjects.add(cur);
+          }
+          if (Array.isArray(cur)) {
+            for (const v of cur) {
+              if (v && typeof v === 'object') queue.push(v);
+            }
+            continue;
+          }
+          for (const [k, v] of Object.entries(cur)) {
+            const plan = planCandidate(k, v);
+            if (plan) return plan;
+            if (v && typeof v === 'object') queue.push(v);
+          }
+        }
+        return null;
+      };
+      const parseJSONScript = (id) => {
+        try {
+          const node = document.getElementById(id);
+          const raw = node && node.textContent ? String(node.textContent) : '';
+          return raw ? JSON.parse(raw) : null;
+        } catch {
+          return null;
+        }
+      };
       const pickLikelyPurchaseButton = (buttons) => {
         if (!buttons || buttons.length === 0) return null;
         const labeled = buttons.find(btn => {
@@ -203,6 +302,12 @@ let openAIDashboardScrapeScript = """
       };
       const dayKeyFromPayload = (payload) => {
         if (!payload || typeof payload !== 'object') return null;
+        const localDayKeyForDate = (date) => {
+          const year = date.getFullYear();
+          const month = String(date.getMonth() + 1).padStart(2, '0');
+          const day = String(date.getDate()).padStart(2, '0');
+          return `${year}-${month}-${day}`;
+        };
         const keys = ['day', 'date', 'name', 'label', 'x', 'time', 'timestamp'];
         for (const k of keys) {
           const v = payload[k];
@@ -215,15 +320,20 @@ let openAIDashboardScrapeScript = """
           if (typeof v === 'number' && Number.isFinite(v) && (k === 'timestamp' || k === 'time' || k === 'x')) {
             try {
               const d = new Date(v);
-              if (!isNaN(d.getTime())) return d.toISOString().slice(0, 10);
+              if (!isNaN(d.getTime())) return localDayKeyForDate(d);
             } catch {}
           }
         }
         return null;
       };
+      const isSkillUsageServiceKey = (raw) => {
+        const key = raw === null || raw === undefined ? '' : String(raw).trim().toLowerCase();
+        return key.startsWith('skillusage:');
+      };
       const displayNameForUsageServiceKey = (raw) => {
         const key = raw === null || raw === undefined ? '' : String(raw).trim();
         if (!key) return key;
+        if (isSkillUsageServiceKey(key)) return null;
         if (key.toUpperCase() === key && key.length <= 6) return key;
         const lower = key.toLowerCase();
         if (lower === 'cli') return 'CLI';
@@ -231,20 +341,136 @@ let openAIDashboardScrapeScript = """
         const words = lower.replace(/[_-]+/g, ' ').split(' ').filter(Boolean);
         return words.map(w => w.length <= 2 ? w.toUpperCase() : w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
       };
-      const usageBreakdownJSON = (() => {
+      const isLikelyCodexUsageService = (raw) => {
+        const service = raw === null || raw === undefined ? '' : String(raw).trim().toLowerCase();
+        return (
+          service === 'cli' ||
+          service === 'desktop' ||
+          service === 'desktop app' ||
+          service === 'vscode' ||
+          service === 'vs code' ||
+          service === 'unknown' ||
+          (service.includes('github') && service.includes('review'))
+        );
+      };
+      const usageChartRootForPath = (path) => {
+        if (!path || !path.closest) return null;
+        return (
+          path.closest('.recharts-wrapper') ||
+          path.closest('svg.recharts-surface') ||
+          path.closest('section') ||
+          path.parentElement ||
+          null
+        );
+      };
+      const uniqueUsageChartRoots = (paths) => {
+        const roots = [];
+        for (const path of paths) {
+          const root = usageChartRootForPath(path);
+          if (root && !roots.includes(root)) roots.push(root);
+        }
+        return roots;
+      };
+      const usageBreakdownTitleScore = (title) => {
+        const lower = String(title || '').trim().toLowerCase().replace(/\\s+/g, ' ');
+        if (!lower) return 0;
+        if (lower === 'usage breakdown') return 1000000;
+        if (lower.includes('usage breakdown')) return 900000;
+        if (lower === 'personal usage') return 800000;
+        if (lower.includes('threads') ||
+          lower.includes('turns') ||
+          lower.includes('client') ||
+          lower.includes('skill') ||
+          lower.includes('invocation')) return -1000000;
+        return 0;
+      };
+      const titleLikeElements = (scope) => {
         try {
-          if (window.__codexbarUsageBreakdownJSON) return window.__codexbarUsageBreakdownJSON;
-
-          const sections = Array.from(document.querySelectorAll('section'));
-          const usageSection = sections.find(s => {
-            const h2 = s.querySelector('h2');
-            return h2 && textOf(h2).toLowerCase().startsWith('usage breakdown');
-          });
-          if (!usageSection) return null;
+          return Array.from(scope.querySelectorAll('h1,h2,h3,[role=\"heading\"],div,span,p'))
+            .filter(el => {
+              const title = textOf(el);
+              const lower = title.toLowerCase();
+              const tag = el.tagName ? el.tagName.toLowerCase() : '';
+              const isHeading = tag === 'h1' ||
+                tag === 'h2' ||
+                tag === 'h3' ||
+                String(el.getAttribute('role') || '').toLowerCase() === 'heading';
+              return title.length > 0 &&
+                title.length <= 80 &&
+                (
+                  isHeading ||
+                  usageBreakdownTitleScore(title) !== 0 ||
+                  lower.includes('usage breakdown') ||
+                  lower.includes('threads') ||
+                  lower.includes('turns') ||
+                  lower.includes('client') ||
+                  lower.includes('skill') ||
+                  lower.includes('invocation')
+                );
+            });
+        } catch {
+          return [];
+        }
+      };
+      const titleNodePrecedesRoot = (titleNode, root) => {
+        if (!titleNode || titleNode === root || root.contains(titleNode) || titleNode.contains(root)) return false;
+        const relation = titleNode.compareDocumentPosition(root);
+        return Boolean(relation & Node.DOCUMENT_POSITION_FOLLOWING);
+      };
+      const nearestScoredChartTitleInScope = (scope, root) => {
+        let best = null;
+        for (const titleNode of titleLikeElements(scope)) {
+          if (!titleNodePrecedesRoot(titleNode, root)) continue;
+          const title = textOf(titleNode);
+          const score = usageBreakdownTitleScore(title);
+          if (score === 0) continue;
+          if (!best || score >= best.score) best = { title, score };
+        }
+        return best ? best.title : '';
+      };
+      const chartTitleBoundaryForRoot = (root) => {
+        if (!root) return null;
+        try {
+          return root.closest('section,[role=\"region\"],article') || root.parentElement || null;
+        } catch {
+          return root.parentElement || null;
+        }
+      };
+      const nearestTitleTextInScope = (scope, root) => {
+        if (!scope) return '';
+        let nearest = null;
+        for (const titleNode of titleLikeElements(scope)) {
+          if (titleNodePrecedesRoot(titleNode, root)) nearest = titleNode;
+        }
+        return textOf(nearest);
+      };
+      const nearestChartTitleTextForRoot = (root) => {
+        if (!root) return '';
+        try {
+          const boundary = chartTitleBoundaryForRoot(root) || root.parentElement || null;
+          let ancestor = root.parentElement || null;
+          for (let i = 0; i < 8 && ancestor; i++) {
+            const scoredTitle = nearestScoredChartTitleInScope(ancestor, root);
+            if (scoredTitle) return scoredTitle;
+            if (ancestor === boundary) break;
+            ancestor = ancestor.parentElement || null;
+          }
 
-          const legendMap = {};
+          return nearestTitleTextInScope(boundary, root);
+        } catch {
+          return '';
+        }
+      };
+      const legendMapForUsageChartRoot = (root) => {
+        const legendMap = {};
+        const scopes = [
+          root,
+          root && root.parentElement,
+          root && root.closest ? root.closest('section') : null
+        ].filter(Boolean);
+        for (const scope of scopes) {
           try {
-            const legendItems = Array.from(usageSection.querySelectorAll('div[title]'));
+            const legendItems = Array.from(scope.querySelectorAll('div[title]'));
             for (const item of legendItems) {
               const title = item.getAttribute('title') ? String(item.getAttribute('title')).trim() : '';
               const square = item.querySelector('div[style*=\"background-color\"]');
@@ -255,11 +481,92 @@ let openAIDashboardScrapeScript = """
               if (title && hex) legendMap[hex] = title;
             }
           } catch {}
+          if (Object.keys(legendMap).length > 0) break;
+        }
+        return legendMap;
+      };
+      const parseUsageBreakdownFromChartPaths = (paths, legendMap) => {
+        const totalsByDay = {}; // day -> service -> value
+        const addValue = (day, service, value) => {
+          if (!day || !service || isSkillUsageServiceKey(service)) return false;
+          if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0) return false;
+          if (!totalsByDay[day]) totalsByDay[day] = {};
+          totalsByDay[day][service] = (totalsByDay[day][service] || 0) + value;
+          return true;
+        };
+        let pointCount = 0;
+        for (const path of paths) {
+          const meta = barMetaFromElement(path) || barMetaFromElement(path.parentElement) || null;
+          if (!meta) continue;
+
+          const payload = meta.payload || null;
+          const day = dayKeyFromPayload(payload);
+          if (!day) continue;
+
+          const valuesObj = (payload && payload.values && typeof payload.values === 'object') ? payload.values : null;
+          if (valuesObj) {
+            for (const [k, v] of Object.entries(valuesObj)) {
+              const service = displayNameForUsageServiceKey(k);
+              if (addValue(day, service, v)) pointCount++;
+            }
+            continue;
+          }
 
-          const totalsByDay = {}; // day -> service -> value
-          const paths = Array.from(usageSection.querySelectorAll('g.recharts-bar-rectangle path.recharts-rectangle'));
+          let value = null;
+          if (typeof meta.value === 'number' && Number.isFinite(meta.value)) value = meta.value;
+          if (value === null && typeof meta.value === 'string') {
+            const v = parseFloat(meta.value.replace(/,/g, ''));
+            if (Number.isFinite(v)) value = v;
+          }
+          if (value === null) continue;
+
+          const fill = parseHexColor(meta.fill || path.getAttribute('fill'));
+          const service =
+            (fill && legendMap[fill]) ||
+            (typeof meta.name === 'string' && meta.name) ||
+            null;
+          if (addValue(day, service, value)) pointCount++;
+        }
+
+        const dayKeys = Object.keys(totalsByDay)
+          .filter(day => Object.keys(totalsByDay[day] || {}).length > 0)
+          .sort((a, b) => b.localeCompare(a))
+          .slice(0, 30);
+        const breakdown = dayKeys.map(day => {
+          const servicesMap = totalsByDay[day] || {};
+          const services = Object.keys(servicesMap).map(service => ({
+            service,
+            creditsUsed: servicesMap[service]
+          })).sort((a, b) => {
+            if (a.creditsUsed === b.creditsUsed) return a.service.localeCompare(b.service);
+            return b.creditsUsed - a.creditsUsed;
+          });
+          const totalCreditsUsed = services.reduce((sum, s) => sum + (Number(s.creditsUsed) || 0), 0);
+          return { day, services, totalCreditsUsed };
+        });
+        const services = Array.from(new Set(breakdown.flatMap(day => day.services.map(service => service.service))));
+        const totalCreditsUsed = breakdown.reduce((sum, day) => sum + (Number(day.totalCreditsUsed) || 0), 0);
+        const likelyCodexServiceCount = services.filter(isLikelyCodexUsageService).length;
+        return {
+          breakdown,
+          pointCount,
+          services,
+          totalCreditsUsed,
+          likelyCodexServiceCount,
+          score: likelyCodexServiceCount * 1000 + services.length * 100 + pointCount + totalCreditsUsed / 1000
+        };
+      };
+      const usageBreakdownJSON = (() => {
+        try {
+          if (window.__codexbarUsageBreakdownJSON) return window.__codexbarUsageBreakdownJSON;
+
+          const paths = Array.from(document.querySelectorAll('g.recharts-bar-rectangle path.recharts-rectangle'));
           let debug = {
             pathCount: paths.length,
+            chartCount: 0,
+            eligibleCandidateCount: 0,
+            selectedCandidateTitle: null,
+            candidateSummaries: [],
             sampleReactKeys: null,
             sampleMetaKeys: null,
             samplePayloadKeys: null,
@@ -286,59 +593,51 @@ let openAIDashboardScrapeScript = """
               }
             }
           } catch {}
-          for (const path of paths) {
-            const meta = barMetaFromElement(path) || barMetaFromElement(path.parentElement) || null;
-            if (!meta) continue;
-
-            const payload = meta.payload || null;
-            const day = dayKeyFromPayload(payload);
-            if (!day) continue;
 
-            const valuesObj = (payload && payload.values && typeof payload.values === 'object') ? payload.values : null;
-            if (valuesObj) {
-              if (!totalsByDay[day]) totalsByDay[day] = {};
-              for (const [k, v] of Object.entries(valuesObj)) {
-                if (typeof v !== 'number' || !Number.isFinite(v) || v <= 0) continue;
-                const service = displayNameForUsageServiceKey(k);
-                if (!service) continue;
-                totalsByDay[day][service] = (totalsByDay[day][service] || 0) + v;
-              }
-              continue;
+          const roots = uniqueUsageChartRoots(paths);
+          debug.chartCount = roots.length;
+          const candidates = roots.map(root => {
+            const chartPaths = paths.filter(path => usageChartRootForPath(path) === root);
+            const title = nearestChartTitleTextForRoot(root);
+            const titleScore = usageBreakdownTitleScore(title);
+            const parsed = parseUsageBreakdownFromChartPaths(chartPaths, legendMapForUsageChartRoot(root));
+            return {
+              root,
+              title,
+              titleScore,
+              pathCount: chartPaths.length,
+              ...parsed,
+              score: titleScore + parsed.score
+            };
+          }).filter(candidate => candidate.breakdown.length > 0);
+          const rejectedTitleCandidates = candidates.filter(candidate => candidate.titleScore < 0);
+          const titledCandidates = candidates.filter(candidate => candidate.titleScore > 0);
+          const unknownTitleCandidates = candidates.filter(candidate => candidate.titleScore === 0);
+          const eligibleCandidates = titledCandidates;
+          eligibleCandidates.sort((a, b) => b.score - a.score);
+          debug.eligibleCandidateCount = eligibleCandidates.length;
+          debug.selectedCandidateTitle = eligibleCandidates[0] ? eligibleCandidates[0].title : null;
+          if (eligibleCandidates.length === 0 && candidates.length > 0) {
+            if (unknownTitleCandidates.length > 0) {
+              debug.error = 'No English usage breakdown chart title found. Candidate titles: ' +
+                candidates.map(candidate => candidate.title || 'Untitled chart').join(', ');
+            } else if (rejectedTitleCandidates.length > 0) {
+              debug.error = 'Only non-usage chart candidates found: ' +
+                rejectedTitleCandidates.map(candidate => candidate.title || 'Untitled chart').join(', ');
             }
-
-            let value = null;
-            if (typeof meta.value === 'number' && Number.isFinite(meta.value)) value = meta.value;
-            if (value === null && typeof meta.value === 'string') {
-              const v = parseFloat(meta.value.replace(/,/g, ''));
-              if (Number.isFinite(v)) value = v;
-            }
-            if (value === null) continue;
-
-            const fill = parseHexColor(meta.fill || path.getAttribute('fill'));
-            const service =
-              (fill && legendMap[fill]) ||
-              (typeof meta.name === 'string' && meta.name) ||
-              null;
-            if (!service) continue;
-
-            if (!totalsByDay[day]) totalsByDay[day] = {};
-            totalsByDay[day][service] = (totalsByDay[day][service] || 0) + value;
           }
+          debug.candidateSummaries = candidates.slice(0, 6).map(candidate => ({
+            title: candidate.title,
+            titleScore: candidate.titleScore,
+            pathCount: candidate.pathCount,
+            dayCount: candidate.breakdown.length,
+            pointCount: candidate.pointCount,
+            serviceCount: candidate.services.length,
+            likelyCodexServiceCount: candidate.likelyCodexServiceCount,
+            services: candidate.services.slice(0, 8)
+          }));
 
-          const dayKeys = Object.keys(totalsByDay).sort((a, b) => b.localeCompare(a)).slice(0, 30);
-          const breakdown = dayKeys.map(day => {
-            const servicesMap = totalsByDay[day] || {};
-            const services = Object.keys(servicesMap).map(service => ({
-              service,
-              creditsUsed: servicesMap[service]
-            })).sort((a, b) => {
-              if (a.creditsUsed === b.creditsUsed) return a.service.localeCompare(b.service);
-              return b.creditsUsed - a.creditsUsed;
-            });
-            const totalCreditsUsed = services.reduce((sum, s) => sum + (Number(s.creditsUsed) || 0), 0);
-            return { day, services, totalCreditsUsed };
-          });
-
+          const breakdown = eligibleCandidates[0] ? eligibleCandidates[0].breakdown : [];
           const json = (breakdown.length > 0) ? JSON.stringify(breakdown) : null;
           window.__codexbarUsageBreakdownJSON = json;
           window.__codexbarUsageBreakdownDebug = json ? null : JSON.stringify(debug);
@@ -354,6 +653,15 @@ let openAIDashboardScrapeScript = """
           return null;
         }
       })();
+      const usageBreakdownError = (() => {
+        try {
+          if (!usageBreakdownDebug) return null;
+          const parsed = JSON.parse(usageBreakdownDebug);
+          return parsed && parsed.error ? String(parsed.error) : null;
+        } catch {
+          return null;
+        }
+      })();
       const bodyText = document.body ? String(document.body.innerText || '').trim() : '';
       const href = window.location ? String(window.location.href || '') : '';
       const workspacePicker = bodyText.includes('Select a workspace');
@@ -389,6 +697,16 @@ let openAIDashboardScrapeScript = """
       let didScrollToCredits = false;
       let rows = [];
       try {
+        const looksLikeCreditsEventRow = (cells) => {
+          if (!cells || cells.length < 3) return false;
+          const first = String(cells[0] || '');
+          const amount = String(cells[2] || '');
+          return /\\d{4}|\\d{1,2}[\\/.\\-]\\d{1,2}/.test(first) && /\\d/.test(amount);
+        };
+        const allTableRows = () => Array.from(document.querySelectorAll('tbody tr')).map(tr => {
+          const cells = Array.from(tr.querySelectorAll('td')).map(td => textOf(td));
+          return cells;
+        }).filter(looksLikeCreditsEventRow);
         const headings = Array.from(document.querySelectorAll('h1,h2,h3'));
         const header = headings.find(h => textOf(h).toLowerCase() === 'credits usage history');
         if (header) {
@@ -405,6 +723,9 @@ let openAIDashboardScrapeScript = """
             const cells = Array.from(tr.querySelectorAll('td')).map(td => textOf(td));
             return cells;
           }).filter(r => r.length >= 3);
+          if (rows.length === 0) {
+            rows = allTableRows();
+          }
           if (rows.length === 0 && !window.__codexbarDidScrollToCredits) {
             window.__codexbarDidScrollToCredits = true;
             // If the table is virtualized/lazy-loaded, we need to scroll to trigger rendering even if the
@@ -416,6 +737,13 @@ let openAIDashboardScrapeScript = """
             didScrollToCredits = true;
           }
         } else if (rows.length === 0 && !window.__codexbarDidScrollToCredits && scrollHeight > viewportHeight * 1.5) {
+          rows = allTableRows();
+          if (rows.length > 0) {
+            creditsHeaderPresent = true;
+            creditsHeaderInViewport = true;
+          }
+        }
+        if (rows.length === 0 && !window.__codexbarDidScrollToCredits && scrollHeight > viewportHeight * 1.5) {
           // The credits history section often isn't part of the DOM until you scroll down. Nudge the page
           // once so subsequent scrapes can find the header and rows.
           window.__codexbarDidScrollToCredits = true;
@@ -458,6 +786,8 @@ let openAIDashboardScrapeScript = """
       } catch {}
 
       let signedInEmail = null;
+      let authStatus = null;
+      let accountPlan = null;
       try {
         const next = window.__NEXT_DATA__ || null;
         const props = (next && next.props && next.props.pageProps) ? next.props.pageProps : null;
@@ -466,12 +796,29 @@ let openAIDashboardScrapeScript = """
         signedInEmail = userEmail || sessionEmail || null;
       } catch {}
 
+      const clientBootstrap = parseJSONScript('client-bootstrap');
+      if (clientBootstrap) {
+        try {
+          authStatus = typeof clientBootstrap.authStatus === 'string' ? clientBootstrap.authStatus : null;
+          if (!signedInEmail) {
+            const session = clientBootstrap.session || null;
+            const user = (session && session.user) || clientBootstrap.user || null;
+            const email = user && typeof user.email === 'string' ? user.email : null;
+            if (email && email.includes('@')) signedInEmail = email;
+          }
+          if (!accountPlan) accountPlan = findPlan(clientBootstrap);
+        } catch {}
+      }
+      if (!accountPlan) {
+        try {
+          accountPlan = findPlan(window.__NEXT_DATA__ || parseJSONScript('__NEXT_DATA__'));
+        } catch {}
+      }
+
       if (!signedInEmail) {
         try {
-          const node = document.getElementById('__NEXT_DATA__');
-          const raw = node && node.textContent ? String(node.textContent) : '';
-          if (raw) {
-            const obj = JSON.parse(raw);
+          const obj = parseJSONScript('__NEXT_DATA__');
+          if (obj) {
             const queue = [obj];
             let seen = 0;
             while (queue.length && seen < 2000 && !signedInEmail) {
@@ -539,12 +886,14 @@ let openAIDashboardScrapeScript = """
         cloudflareInterstitial,
         href,
         bodyText,
-        bodyHTML: document.documentElement ? String(document.documentElement.outerHTML || '') : '',
         signedInEmail,
+        authStatus,
+        accountPlan,
         creditsPurchaseURL,
         rows,
         usageBreakdownJSON,
         usageBreakdownDebug,
+        usageBreakdownError,
         scrollY,
         scrollHeight,
         viewportHeight,
diff --git a/Sources/CodexBarCore/OpenAIWeb/OpenAIDashboardWebViewCache.swift b/Sources/CodexBarCore/OpenAIWeb/OpenAIDashboardWebViewCache.swift
index 49e6a92804..c406e99bd8 100644
--- a/Sources/CodexBarCore/OpenAIWeb/OpenAIDashboardWebViewCache.swift
+++ b/Sources/CodexBarCore/OpenAIWeb/OpenAIDashboardWebViewCache.swift
@@ -6,6 +6,7 @@ import WebKit
 struct OpenAIDashboardWebViewLease {
     let webView: WKWebView
     let log: (String) -> Void
+    let setPreserveLoadedPageOnRelease: (Bool) -> Void
     let release: () -> Void
 }
 
@@ -14,22 +15,187 @@ final class OpenAIDashboardWebViewCache {
     static let shared = OpenAIDashboardWebViewCache()
     fileprivate static let log = CodexBarLog.logger(LogCategories.openAIWebview)
 
+    private final class ReleaseState {
+        var preserveLoadedPageOnRelease: Bool
+
+        init(preserveLoadedPageOnRelease: Bool) {
+            self.preserveLoadedPageOnRelease = preserveLoadedPageOnRelease
+        }
+    }
+
+    private struct AcquireOptions {
+        let allowTimeoutRetry: Bool
+        let preserveLoadedPageOnRelease: Bool
+    }
+
+    @MainActor
+    private final class NavigationCancellationState {
+        private weak var webView: WKWebView?
+        private var delegate: NavigationDelegate?
+        private var isCancelled = false
+
+        func install(webView: WKWebView, delegate: NavigationDelegate) {
+            self.webView = webView
+            self.delegate = delegate
+            if self.isCancelled {
+                self.cancel()
+            }
+        }
+
+        func cancel() {
+            self.isCancelled = true
+            guard let webView, let delegate else { return }
+            delegate.cancel()
+            if webView.codexNavigationDelegate === delegate {
+                webView.stopLoading()
+                webView.navigationDelegate = nil
+                webView.codexNavigationDelegate = nil
+            }
+            self.delegate = nil
+            self.webView = nil
+        }
+    }
+
     private final class Entry {
         let webView: WKWebView
         let host: OffscreenWebViewHost
         var lastUsedAt: Date
         var isBusy: Bool
+        var preservedPageExpiresAt: Date?
+        var preservedPageExpiryWorkItem: DispatchWorkItem?
 
-        init(webView: WKWebView, host: OffscreenWebViewHost, lastUsedAt: Date, isBusy: Bool) {
+        init(
+            webView: WKWebView,
+            host: OffscreenWebViewHost,
+            lastUsedAt: Date,
+            isBusy: Bool,
+            preservedPageExpiresAt: Date? = nil)
+        {
             self.webView = webView
             self.host = host
             self.lastUsedAt = lastUsedAt
             self.isBusy = isBusy
+            self.preservedPageExpiresAt = preservedPageExpiresAt
+        }
+
+        func armPreservedPage(until expiry: Date) {
+            self.preservedPageExpiresAt = expiry
+        }
+
+        func setPreservedPageExpiryWorkItem(_ workItem: DispatchWorkItem?) {
+            self.preservedPageExpiryWorkItem?.cancel()
+            self.preservedPageExpiryWorkItem = workItem
+        }
+
+        func clearPreservedPage() {
+            self.preservedPageExpiresAt = nil
+            self.preservedPageExpiryWorkItem?.cancel()
+            self.preservedPageExpiryWorkItem = nil
+        }
+
+        func consumePreservedPageReuseIfAvailable(now: Date) -> Bool {
+            guard let preservedPageExpiresAt else { return false }
+            self.preservedPageExpiresAt = nil
+            self.preservedPageExpiryWorkItem?.cancel()
+            self.preservedPageExpiryWorkItem = nil
+            return preservedPageExpiresAt > now
+        }
+
+        func hasExpiredPreservedPage(now: Date) -> Bool {
+            guard let preservedPageExpiresAt else { return false }
+            return preservedPageExpiresAt <= now
         }
     }
 
     private var entries: [ObjectIdentifier: Entry] = [:]
-    private let idleTimeout: TimeInterval = 10 * 60
+    /// Keep the WebView alive only long enough for immediate retries/menu reopens.
+    /// Long-lived hidden ChatGPT tabs still consume noticeable energy on some setups.
+    private let idleTimeout: TimeInterval
+    private var idlePruneWorkItem: DispatchWorkItem?
+    private var idlePruneGeneration = 0
+    #if DEBUG
+    private(set) var idlePruneDeadlineForTesting: Date?
+    #endif
+    /// Reuse the validated analytics page only for the immediate next handoff.
+    private let preservedPageHandoffTimeout: TimeInterval = 5
+    private let blankURL = URL(string: "about:blank")!
+    private let idlePageClearScript = """
+    (() => {
+      try {
+        document.documentElement.innerHTML = '';
+        return true;
+      } catch {
+        return false;
+      }
+    })();
+    """
+    private let reusablePageResetScript = """
+    (() => {
+      try {
+        delete window.__codexbarDidScrollToCredits;
+        delete window.__codexbarUsageBreakdownJSON;
+        delete window.__codexbarUsageBreakdownDebug;
+        return true;
+      } catch {
+        return false;
+      }
+    })();
+    """
+    private let preferredLanguageScript = """
+    (() => {
+      const define = (target, name, value) => {
+        try {
+          Object.defineProperty(target, name, {
+            get: () => value,
+            configurable: true
+          });
+        } catch {}
+      };
+      define(Navigator.prototype, 'language', 'en-US');
+      define(Navigator.prototype, 'languages', ['en-US', 'en']);
+      define(navigator, 'language', 'en-US');
+      define(navigator, 'languages', ['en-US', 'en']);
+    })();
+    """
+
+    init(idleTimeout: TimeInterval = 60) {
+        self.idleTimeout = idleTimeout
+    }
+
+    nonisolated static func remainingNavigationTimeout(
+        until deadline: Date,
+        now: Date = Date()) throws -> TimeInterval
+    {
+        let remaining = deadline.timeIntervalSince(now)
+        guard remaining > 0 else { throw URLError(.timedOut) }
+        return remaining
+    }
+
+    private func releaseCachedEntry(_ entry: Entry, preserveLoadedPage: Bool) {
+        entry.isBusy = false
+        let now = Date()
+        entry.lastUsedAt = now
+        self.updatePreservedPageState(for: entry, preserveLoadedPage: preserveLoadedPage)
+        self.prepareCachedWebViewForIdle(
+            entry.webView,
+            host: entry.host,
+            preserveLoadedPage: preserveLoadedPage)
+        self.prune(now: now)
+        self.scheduleNextIdlePrune(now: now)
+    }
+
+    private func releaseNewEntry(_ entry: Entry, webView: WKWebView, preserveLoadedPage: Bool) {
+        entry.isBusy = false
+        let now = Date()
+        entry.lastUsedAt = now
+        self.updatePreservedPageState(for: entry, preserveLoadedPage: preserveLoadedPage)
+        self.prepareCachedWebViewForIdle(
+            webView,
+            host: entry.host,
+            preserveLoadedPage: preserveLoadedPage)
+        self.prune(now: now)
+        self.scheduleNextIdlePrune(now: now)
+    }
 
     // MARK: - Testing support
 
@@ -50,20 +216,98 @@ final class OpenAIDashboardWebViewCache {
         self.prune(now: now)
     }
 
+    var idleTimeoutForTesting: TimeInterval {
+        self.idleTimeout
+    }
+
+    var preservedPageHandoffTimeoutForTesting: TimeInterval {
+        self.preservedPageHandoffTimeout
+    }
+
+    func hasPreservedPageForTesting(for websiteDataStore: WKWebsiteDataStore) -> Bool {
+        let key = ObjectIdentifier(websiteDataStore)
+        return self.entries[key]?.preservedPageExpiresAt != nil
+    }
+
+    func markPreservedPageForTesting(
+        websiteDataStore: WKWebsiteDataStore,
+        expiresAt: Date = .init().addingTimeInterval(5))
+    {
+        let key = ObjectIdentifier(websiteDataStore)
+        guard let entry = self.entries[key] else { return }
+        entry.armPreservedPage(until: expiresAt)
+        self.schedulePreservedPageExpiry(for: key, entry: entry, expiresAt: expiresAt)
+    }
+
+    func consumePreservedPageForTesting(websiteDataStore: WKWebsiteDataStore, now: Date = Date()) -> Bool {
+        let key = ObjectIdentifier(websiteDataStore)
+        guard let entry = self.entries[key] else { return false }
+        return entry.consumePreservedPageReuseIfAvailable(now: now)
+    }
+
+    /// Seed a cached entry without navigating a real page (for test stability).
+    @discardableResult
+    func cacheEntryForTesting(
+        websiteDataStore: WKWebsiteDataStore,
+        lastUsedAt: Date = Date(),
+        isBusy: Bool = false) -> WKWebView
+    {
+        let key = ObjectIdentifier(websiteDataStore)
+        if let existing = self.entries.removeValue(forKey: key) {
+            existing.host.close()
+        }
+
+        let (webView, host) = self.makeWebView(websiteDataStore: websiteDataStore)
+        let entry = Entry(webView: webView, host: host, lastUsedAt: lastUsedAt, isBusy: isBusy)
+        self.entries[key] = entry
+        if isBusy {
+            host.show()
+        } else {
+            host.hide()
+        }
+        return webView
+    }
+
     /// Clear all cached entries (for test isolation).
     func clearAllForTesting() {
+        self.cancelIdlePrune()
         for (_, entry) in self.entries {
+            entry.clearPreservedPage()
             entry.host.close()
         }
         self.entries.removeAll()
     }
+
+    func resetReusablePageStateForTesting(_ webView: WKWebView) async -> Bool {
+        await self.resetReusablePageState(webView)
+    }
     #endif
 
     func acquire(
         websiteDataStore: WKWebsiteDataStore,
         usageURL: URL,
         logger: ((String) -> Void)?,
-        navigationTimeout: TimeInterval = 15) async throws -> OpenAIDashboardWebViewLease
+        navigationTimeout: TimeInterval = 15,
+        allowTimeoutRetry: Bool = true,
+        preserveLoadedPageOnRelease: Bool = false) async throws -> OpenAIDashboardWebViewLease
+    {
+        let deadline = Date().addingTimeInterval(max(navigationTimeout, 0.01))
+        return try await self.acquire(
+            websiteDataStore: websiteDataStore,
+            usageURL: usageURL,
+            logger: logger,
+            deadline: deadline,
+            options: .init(
+                allowTimeoutRetry: allowTimeoutRetry,
+                preserveLoadedPageOnRelease: preserveLoadedPageOnRelease))
+    }
+
+    private func acquire(
+        websiteDataStore: WKWebsiteDataStore,
+        usageURL: URL,
+        logger: ((String) -> Void)?,
+        deadline: Date,
+        options: AcquireOptions) async throws -> OpenAIDashboardWebViewLease
     {
         let now = Date()
         self.prune(now: now)
@@ -72,6 +316,7 @@ final class OpenAIDashboardWebViewCache {
             logger?("[webview] \(message)")
         }
         let key = ObjectIdentifier(websiteDataStore)
+        let remainingTimeout = try Self.remainingNavigationTimeout(until: deadline, now: now)
 
         if let entry = self.entries[key] {
             if entry.isBusy {
@@ -79,25 +324,62 @@ final class OpenAIDashboardWebViewCache {
                 let (webView, host) = self.makeWebView(websiteDataStore: websiteDataStore)
                 host.show()
                 do {
-                    try await self.prepareWebView(webView, usageURL: usageURL, timeout: navigationTimeout)
+                    try await self.prepareWebView(
+                        webView,
+                        usageURL: usageURL,
+                        timeout: remainingTimeout,
+                        canReuseLoadedPage: false)
                 } catch {
+                    if options.allowTimeoutRetry, Self.isPrepareTimeout(error) {
+                        host.close()
+                        log("Temporary OpenAI WebView timed out; retrying with a fresh WebView.")
+                        return try await self.acquireTemporaryWebView(
+                            websiteDataStore: websiteDataStore,
+                            usageURL: usageURL,
+                            log: log,
+                            deadline: deadline)
+                    }
                     host.close()
                     throw error
                 }
                 return OpenAIDashboardWebViewLease(
                     webView: webView,
                     log: log,
+                    setPreserveLoadedPageOnRelease: { _ in },
                     release: { host.close() })
             }
 
             entry.isBusy = true
             entry.lastUsedAt = now
+            let canReuseLoadedPage = entry.consumePreservedPageReuseIfAvailable(now: now)
+            let releaseState = ReleaseState(preserveLoadedPageOnRelease: options.preserveLoadedPageOnRelease)
             entry.host.show()
             do {
-                try await self.prepareWebView(entry.webView, usageURL: usageURL, timeout: navigationTimeout)
+                try await self.prepareWebView(
+                    entry.webView,
+                    usageURL: usageURL,
+                    timeout: remainingTimeout,
+                    canReuseLoadedPage: canReuseLoadedPage)
             } catch {
+                if options.allowTimeoutRetry, Self.isPrepareTimeout(error) {
+                    entry.isBusy = false
+                    entry.lastUsedAt = Date()
+                    entry.clearPreservedPage()
+                    entry.host.close()
+                    self.entries.removeValue(forKey: key)
+                    log("Cached OpenAI WebView timed out; recreating it.")
+                    return try await self.acquire(
+                        websiteDataStore: websiteDataStore,
+                        usageURL: usageURL,
+                        logger: logger,
+                        deadline: deadline,
+                        options: .init(
+                            allowTimeoutRetry: false,
+                            preserveLoadedPageOnRelease: options.preserveLoadedPageOnRelease))
+                }
                 entry.isBusy = false
                 entry.lastUsedAt = Date()
+                entry.clearPreservedPage()
                 entry.host.close()
                 self.entries.removeValue(forKey: key)
                 Self.log.warning("OpenAI webview prepare failed")
@@ -107,15 +389,14 @@ final class OpenAIDashboardWebViewCache {
             return OpenAIDashboardWebViewLease(
                 webView: entry.webView,
                 log: log,
+                setPreserveLoadedPageOnRelease: { preserveLoadedPageOnRelease in
+                    releaseState.preserveLoadedPageOnRelease = preserveLoadedPageOnRelease
+                },
                 release: { [weak self, weak entry] in
                     guard let self, let entry else { return }
-                    entry.isBusy = false
-                    entry.lastUsedAt = Date()
-                    // Hide instead of close - keep WebView cached for reuse.
-                    // This avoids re-downloading the ChatGPT SPA bundle on every refresh,
-                    // saving significant network bandwidth. See GitHub issues #269, #251.
-                    entry.host.hide()
-                    self.prune(now: Date())
+                    self.releaseCachedEntry(
+                        entry,
+                        preserveLoadedPage: releaseState.preserveLoadedPageOnRelease)
                 })
         }
 
@@ -123,10 +404,28 @@ final class OpenAIDashboardWebViewCache {
         let entry = Entry(webView: webView, host: host, lastUsedAt: now, isBusy: true)
         self.entries[key] = entry
         host.show()
+        let releaseState = ReleaseState(preserveLoadedPageOnRelease: options.preserveLoadedPageOnRelease)
 
         do {
-            try await self.prepareWebView(webView, usageURL: usageURL, timeout: navigationTimeout)
+            try await self.prepareWebView(
+                webView,
+                usageURL: usageURL,
+                timeout: remainingTimeout,
+                canReuseLoadedPage: false)
         } catch {
+            if options.allowTimeoutRetry, Self.isPrepareTimeout(error) {
+                self.entries.removeValue(forKey: key)
+                host.close()
+                log("OpenAI WebView timed out during prepare; retrying once.")
+                return try await self.acquire(
+                    websiteDataStore: websiteDataStore,
+                    usageURL: usageURL,
+                    logger: logger,
+                    deadline: deadline,
+                    options: .init(
+                        allowTimeoutRetry: false,
+                        preserveLoadedPageOnRelease: options.preserveLoadedPageOnRelease))
+            }
             self.entries.removeValue(forKey: key)
             host.close()
             Self.log.warning("OpenAI webview prepare failed")
@@ -136,28 +435,127 @@ final class OpenAIDashboardWebViewCache {
         return OpenAIDashboardWebViewLease(
             webView: webView,
             log: log,
+            setPreserveLoadedPageOnRelease: { preserveLoadedPageOnRelease in
+                releaseState.preserveLoadedPageOnRelease = preserveLoadedPageOnRelease
+            },
             release: { [weak self, weak entry] in
                 guard let self, let entry else { return }
-                entry.isBusy = false
-                entry.lastUsedAt = Date()
-                // Hide instead of close - keep WebView cached for reuse.
-                // This avoids re-downloading the ChatGPT SPA bundle on every refresh,
-                // saving significant network bandwidth. See GitHub issues #269, #251.
-                entry.host.hide()
-                self.prune(now: Date())
+                self.releaseNewEntry(
+                    entry,
+                    webView: webView,
+                    preserveLoadedPage: releaseState.preserveLoadedPageOnRelease)
             })
     }
 
     func evict(websiteDataStore: WKWebsiteDataStore) {
         let key = ObjectIdentifier(websiteDataStore)
         guard let entry = self.entries.removeValue(forKey: key) else { return }
+        entry.clearPreservedPage()
         Self.log.debug("OpenAI webview evicted")
         entry.host.close()
+        self.scheduleNextIdlePrune()
+    }
+
+    func evictAll() {
+        self.cancelIdlePrune()
+        let existing = self.entries
+        self.entries.removeAll()
+        for (_, entry) in existing {
+            entry.clearPreservedPage()
+            entry.host.close()
+        }
+        if !existing.isEmpty {
+            Self.log.debug("OpenAI webview evicted all")
+        }
+    }
+
+    func evictIdle() {
+        let idleEntries = self.entries.filter { _, entry in
+            !entry.isBusy
+        }
+        guard !idleEntries.isEmpty else { return }
+
+        for (key, entry) in idleEntries {
+            entry.clearPreservedPage()
+            entry.host.close()
+            self.entries.removeValue(forKey: key)
+        }
+        Self.log.debug("OpenAI idle webviews evicted", metadata: ["count": "\(idleEntries.count)"])
+        self.scheduleNextIdlePrune()
+    }
+
+    private func prepareCachedWebViewForIdle(
+        _ webView: WKWebView,
+        host: OffscreenWebViewHost,
+        preserveLoadedPage: Bool)
+    {
+        webView.navigationDelegate = nil
+        webView.codexNavigationDelegate = nil
+        if preserveLoadedPage {
+            host.hide()
+            return
+        }
+
+        // Detach the heavyweight ChatGPT SPA as soon as a scrape completes. Keeping the WebView object around
+        // still helps with immediate reuse, but letting chatgpt.com remain the active document is too expensive.
+        webView.stopLoading()
+        webView.evaluateJavaScript(self.idlePageClearScript, completionHandler: nil)
+        _ = webView.load(URLRequest(url: self.blankURL))
+        host.hide()
+    }
+
+    /// Schedule against the oldest idle entry so later releases cannot postpone its eviction.
+    private func scheduleNextIdlePrune(now: Date = Date()) {
+        self.cancelIdlePrune()
+
+        guard let nextExpiry = self.entries.values
+            .filter({ !$0.isBusy })
+            .map({ $0.lastUsedAt.addingTimeInterval(self.idleTimeout) })
+            .min()
+        else { return }
+
+        let generation = self.idlePruneGeneration
+        let workItem = DispatchWorkItem { [weak self] in
+            MainActor.assumeIsolated {
+                guard let self, self.idlePruneGeneration == generation else { return }
+                self.idlePruneWorkItem = nil
+                #if DEBUG
+                self.idlePruneDeadlineForTesting = nil
+                #endif
+                let pruneTime = Date()
+                self.prune(now: pruneTime)
+                self.scheduleNextIdlePrune(now: pruneTime)
+            }
+        }
+        self.idlePruneWorkItem = workItem
+        #if DEBUG
+        self.idlePruneDeadlineForTesting = nextExpiry
+        #endif
+        let delay = max(0, nextExpiry.timeIntervalSince(now)) + 0.01
+        DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: workItem)
+    }
+
+    private func cancelIdlePrune() {
+        self.idlePruneGeneration &+= 1
+        self.idlePruneWorkItem?.cancel()
+        self.idlePruneWorkItem = nil
+        #if DEBUG
+        self.idlePruneDeadlineForTesting = nil
+        #endif
     }
 
     private func prune(now: Date) {
+        for entry in self.entries.values where !entry.isBusy && entry.hasExpiredPreservedPage(now: now) {
+            entry.clearPreservedPage()
+            self.prepareCachedWebViewForIdle(
+                entry.webView,
+                host: entry.host,
+                preserveLoadedPage: false)
+            Self.log.debug("OpenAI webview preserved page expired")
+        }
+
         let expired = self.entries.filter { _, entry in
-            !entry.isBusy && now.timeIntervalSince(entry.lastUsedAt) > self.idleTimeout
+            !entry.isBusy && now.timeIntervalSince(entry.lastUsedAt) >= self.idleTimeout
         }
         for (key, entry) in expired {
             entry.host.close()
@@ -169,6 +567,12 @@ final class OpenAIDashboardWebViewCache {
     private func makeWebView(websiteDataStore: WKWebsiteDataStore) -> (WKWebView, OffscreenWebViewHost) {
         let config = WKWebViewConfiguration()
         config.websiteDataStore = websiteDataStore
+        let userContentController = WKUserContentController()
+        userContentController.addUserScript(WKUserScript(
+            source: self.preferredLanguageScript,
+            injectionTime: .atDocumentStart,
+            forMainFrameOnly: false))
+        config.userContentController = userContentController
         if #available(macOS 14.0, *) {
             config.preferences.inactiveSchedulingPolicy = .suspend
         }
@@ -178,15 +582,136 @@ final class OpenAIDashboardWebViewCache {
         return (webView, host)
     }
 
-    private func prepareWebView(_ webView: WKWebView, usageURL: URL, timeout: TimeInterval) async throws {
-        try await withCheckedThrowingContinuation { (cont: CheckedContinuation<Void, Error>) in
-            let delegate = NavigationDelegate { result in
-                cont.resume(with: result)
+    private func prepareWebView(
+        _ webView: WKWebView,
+        usageURL: URL,
+        timeout: TimeInterval,
+        canReuseLoadedPage: Bool) async throws
+    {
+        #if DEBUG
+        if usageURL.absoluteString == "about:blank" {
+            _ = webView.loadHTMLString("", baseURL: nil)
+            return
+        }
+        #endif
+
+        if canReuseLoadedPage,
+           let currentURL = webView.url?.absoluteString,
+           OpenAIDashboardFetcher.isUsageRoute(currentURL)
+        {
+            if await self.resetReusablePageState(webView) {
+                return
+            }
+
+            Self.log.debug("OpenAI preserved page reset failed; reloading usage URL")
+        }
+
+        try Task.checkCancellation()
+        let cancellationState = NavigationCancellationState()
+        try await withTaskCancellationHandler {
+            try await withCheckedThrowingContinuation { (cont: CheckedContinuation<Void, Error>) in
+                let delegate = NavigationDelegate { result in
+                    cont.resume(with: result)
+                }
+                webView.navigationDelegate = delegate
+                webView.codexNavigationDelegate = delegate
+                cancellationState.install(webView: webView, delegate: delegate)
+                delegate.armTimeout(seconds: timeout)
+                _ = webView.load(OpenAIDashboardFetcher.usageURLRequest(url: usageURL))
+                if Task.isCancelled {
+                    cancellationState.cancel()
+                }
+            }
+        } onCancel: {
+            Task { @MainActor in
+                cancellationState.cancel()
+            }
+        }
+    }
+
+    private func acquireTemporaryWebView(
+        websiteDataStore: WKWebsiteDataStore,
+        usageURL: URL,
+        log: @escaping (String) -> Void,
+        deadline: Date) async throws -> OpenAIDashboardWebViewLease
+    {
+        let remainingTimeout = try Self.remainingNavigationTimeout(until: deadline)
+        let (webView, host) = self.makeWebView(websiteDataStore: websiteDataStore)
+        host.show()
+        do {
+            try await self.prepareWebView(
+                webView,
+                usageURL: usageURL,
+                timeout: remainingTimeout,
+                canReuseLoadedPage: false)
+        } catch {
+            host.close()
+            throw error
+        }
+        return OpenAIDashboardWebViewLease(
+            webView: webView,
+            log: log,
+            setPreserveLoadedPageOnRelease: { _ in },
+            release: { host.close() })
+    }
+
+    private static func isPrepareTimeout(_ error: Error) -> Bool {
+        let nsError = error as NSError
+        return nsError.domain == NSURLErrorDomain && nsError.code == NSURLErrorTimedOut
+    }
+
+    private func updatePreservedPageState(for entry: Entry, preserveLoadedPage: Bool) {
+        if preserveLoadedPage {
+            let expiresAt = Date().addingTimeInterval(self.preservedPageHandoffTimeout)
+            entry.armPreservedPage(until: expiresAt)
+            if let key = self.entries.first(where: { $0.value === entry })?.key {
+                self.schedulePreservedPageExpiry(for: key, entry: entry, expiresAt: expiresAt)
+            }
+        } else {
+            entry.clearPreservedPage()
+        }
+    }
+
+    private func schedulePreservedPageExpiry(
+        for key: ObjectIdentifier,
+        entry: Entry,
+        expiresAt: Date)
+    {
+        let delay = max(0, expiresAt.timeIntervalSinceNow)
+        let workItem = DispatchWorkItem { [weak self] in
+            MainActor.assumeIsolated {
+                self?.expirePreservedPageIfNeeded(for: key, expectedExpiry: expiresAt)
             }
-            webView.navigationDelegate = delegate
-            webView.codexNavigationDelegate = delegate
-            delegate.armTimeout(seconds: timeout)
-            _ = webView.load(URLRequest(url: usageURL))
+        }
+        entry.setPreservedPageExpiryWorkItem(workItem)
+        DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: workItem)
+    }
+
+    private func expirePreservedPageIfNeeded(for key: ObjectIdentifier, expectedExpiry: Date) {
+        guard let entry = self.entries[key],
+              !entry.isBusy,
+              let preservedPageExpiresAt = entry.preservedPageExpiresAt,
+              preservedPageExpiresAt == expectedExpiry,
+              preservedPageExpiresAt <= Date()
+        else {
+            return
+        }
+
+        entry.clearPreservedPage()
+        self.prepareCachedWebViewForIdle(
+            entry.webView,
+            host: entry.host,
+            preserveLoadedPage: false)
+        Self.log.debug("OpenAI webview preserved page expired")
+        self.prune(now: Date())
+    }
+
+    private func resetReusablePageState(_ webView: WKWebView) async -> Bool {
+        do {
+            let any = try await webView.evaluateJavaScript(self.reusablePageResetScript)
+            return (any as? Bool) ?? true
+        } catch {
+            return false
         }
     }
 }
diff --git a/Sources/CodexBarCore/OpenAIWeb/OpenAIDashboardWebsiteDataStore.swift b/Sources/CodexBarCore/OpenAIWeb/OpenAIDashboardWebsiteDataStore.swift
index e23ef66a1f..a868996f76 100644
--- a/Sources/CodexBarCore/OpenAIWeb/OpenAIDashboardWebsiteDataStore.swift
+++ b/Sources/CodexBarCore/OpenAIWeb/OpenAIDashboardWebsiteDataStore.swift
@@ -9,28 +9,32 @@ import WebKit
 /// we want to keep multiple signed-in dashboard sessions around (one per email) without clearing cookies.
 ///
 /// Implementation detail: macOS 14+ supports `WKWebsiteDataStore.dataStore(forIdentifier:)`, which creates
-/// persistent isolated stores keyed by an identifier. We derive a stable UUID from the email so the same
-/// account always maps to the same cookie store.
+/// persistent isolated stores keyed by an identifier. We derive a stable UUID from the email and optional
+/// Codex source scope so distinct profiles with the same email never share a cookie store.
 ///
 /// Important: We cache the `WKWebsiteDataStore` instances so the same object is returned for the same
 /// account email. This ensures `OpenAIDashboardWebViewCache` can use object identity for cache lookups.
 @MainActor
 public enum OpenAIDashboardWebsiteDataStore {
-    /// Cached data store instances keyed by normalized email.
+    /// Cached data store instances keyed by normalized email and optional Codex source scope.
     /// Using the same instance ensures stable object identity for WebView cache lookups.
     private static var cachedStores: [String: WKWebsiteDataStore] = [:]
 
-    public static func store(forAccountEmail email: String?) -> WKWebsiteDataStore {
+    public static func store(
+        forAccountEmail email: String?,
+        scope: CookieHeaderCache.Scope? = nil) -> WKWebsiteDataStore
+    {
         guard let normalized = normalizeEmail(email) else { return .default() }
+        let storageKey = self.storageKey(normalizedEmail: normalized, scope: scope)
 
         // Return cached instance if available to maintain stable object identity
-        if let cached = cachedStores[normalized] {
+        if let cached = cachedStores[storageKey] {
             return cached
         }
 
-        let id = Self.identifier(forNormalizedEmail: normalized)
+        let id = Self.identifier(forStorageKey: storageKey)
         let store = WKWebsiteDataStore(forIdentifier: id)
-        self.cachedStores[normalized] = store
+        self.cachedStores[storageKey] = store
         return store
     }
 
@@ -38,10 +42,13 @@ public enum OpenAIDashboardWebsiteDataStore {
     ///
     /// Note: this does *not* impact other accounts, and is safe to use when the stored session is "stuck"
     /// or signed in to a different account than expected.
-    public static func clearStore(forAccountEmail email: String?) async {
+    public static func clearStore(
+        forAccountEmail email: String?,
+        scope: CookieHeaderCache.Scope? = nil) async
+    {
         // Clear only ChatGPT/OpenAI domain data for the per-account store.
         // Avoid deleting the entire persistent store (WebKit requires all WKWebViews using it to be released).
-        let store = self.store(forAccountEmail: email)
+        let store = self.store(forAccountEmail: email, scope: scope)
         await withCheckedContinuation { cont in
             store.fetchDataRecords(ofTypes: WKWebsiteDataStore.allWebsiteDataTypes()) { records in
                 let filtered = records.filter { record in
@@ -56,7 +63,7 @@ public enum OpenAIDashboardWebsiteDataStore {
 
         // Remove from cache so a fresh instance is created on next access
         if let normalized = normalizeEmail(email) {
-            self.cachedStores.removeValue(forKey: normalized)
+            self.cachedStores.removeValue(forKey: self.storageKey(normalizedEmail: normalized, scope: scope))
         }
     }
 
@@ -65,6 +72,7 @@ public enum OpenAIDashboardWebsiteDataStore {
     public static func clearCacheForTesting() {
         self.cachedStores.removeAll()
     }
+
     #endif
 
     // MARK: - Private
@@ -74,8 +82,13 @@ public enum OpenAIDashboardWebsiteDataStore {
         return raw.lowercased()
     }
 
-    private static func identifier(forNormalizedEmail email: String) -> UUID {
-        let digest = SHA256.hash(data: Data(email.utf8))
+    private static func storageKey(normalizedEmail: String, scope: CookieHeaderCache.Scope?) -> String {
+        guard let scope else { return normalizedEmail }
+        return "\(normalizedEmail)|\(scope.isolationIdentifier)"
+    }
+
+    private static func identifier(forStorageKey storageKey: String) -> UUID {
+        let digest = SHA256.hash(data: Data(storageKey.utf8))
         var bytes = Array(digest.prefix(16))
 
         // Make it a well-formed UUID (v4 + RFC4122 variant) while staying deterministic.
diff --git a/Sources/CodexBarCore/PathEnvironment.swift b/Sources/CodexBarCore/PathEnvironment.swift
index ece93eda2b..e006bddad0 100644
--- a/Sources/CodexBarCore/PathEnvironment.swift
+++ b/Sources/CodexBarCore/PathEnvironment.swift
@@ -1,4 +1,11 @@
 import Foundation
+#if canImport(Darwin)
+import Darwin
+#elseif canImport(Glibc)
+import Glibc
+#elseif canImport(Musl)
+import Musl
+#endif
 
 public enum PathPurpose: Hashable, Sendable {
     case rpc
@@ -52,6 +59,47 @@ public enum BinaryLocator {
             loginPATH: loginPATH,
             commandV: commandV,
             aliasResolver: aliasResolver,
+            wellKnownPaths: self.claudeWellKnownPaths(home: home),
+            fileManager: fileManager,
+            home: home)
+    }
+
+    /// Well-known installation paths for the Claude CLI binary.
+    /// Covers Anthropic's native installer (`~/.local/bin`), the `claude migrate-installer`
+    /// self-updating location (`~/.claude/local`), the legacy per-user installer
+    /// (`~/.claude/bin`), Homebrew, and the macOS Terminal installer (cmux.app).
+    static func claudeWellKnownPaths(home: String) -> [String] {
+        [
+            "\(home)/.local/bin/claude",
+            "\(home)/.claude/local/claude",
+            "\(home)/.claude/bin/claude",
+            "/opt/homebrew/bin/claude",
+            "/usr/local/bin/claude",
+            "/Applications/cmux.app/Contents/Resources/bin/claude",
+        ]
+    }
+
+    public static func resolveAntigravityBinary(
+        env: [String: String] = ProcessInfo.processInfo.environment,
+        loginPATH: [String]? = LoginShellPathCache.shared.current,
+        commandV: (String, String?, TimeInterval, FileManager) -> String? = ShellCommandLocator.commandV,
+        aliasResolver: (String, String?, TimeInterval, FileManager, String) -> String? = ShellCommandLocator
+            .resolveAlias,
+        fileManager: FileManager = .default,
+        home: String = NSHomeDirectory()) -> String?
+    {
+        self.resolveBinary(
+            name: "agy",
+            overrideKey: "ANTIGRAVITY_CLI_PATH",
+            env: env,
+            loginPATH: loginPATH,
+            commandV: commandV,
+            aliasResolver: aliasResolver,
+            wellKnownPaths: [
+                "\(home)/.local/bin/agy",
+                "/opt/homebrew/bin/agy",
+                "/usr/local/bin/agy",
+            ],
             fileManager: fileManager,
             home: home)
     }
@@ -62,6 +110,7 @@ public enum BinaryLocator {
         commandV: (String, String?, TimeInterval, FileManager) -> String? = ShellCommandLocator.commandV,
         aliasResolver: (String, String?, TimeInterval, FileManager, String) -> String? = ShellCommandLocator
             .resolveAlias,
+        launchCandidateFilter: (String, FileManager) -> Bool = CodexLaunchPreflight.isLaunchCandidateAllowed,
         fileManager: FileManager = .default,
         home: String = NSHomeDirectory()) -> String?
     {
@@ -72,10 +121,25 @@ public enum BinaryLocator {
             loginPATH: loginPATH,
             commandV: commandV,
             aliasResolver: aliasResolver,
+            wellKnownPaths: self.codexWellKnownPaths(home: home),
+            launchCandidateFilter: launchCandidateFilter,
             fileManager: fileManager,
             home: home)
     }
 
+    /// Well-known installation paths for the signed Codex desktop app CLI.
+    /// Keep these after PATH lookups, but use them as a safe fallback when a PATH shim is blocked.
+    static func codexWellKnownPaths(home: String) -> [String] {
+        #if os(macOS)
+        [
+            "\(home)/Applications/Codex.app/Contents/Resources/codex",
+            "/Applications/Codex.app/Contents/Resources/codex",
+        ]
+        #else
+        []
+        #endif
+    }
+
     public static func resolveGeminiBinary(
         env: [String: String] = ProcessInfo.processInfo.environment,
         loginPATH: [String]? = LoginShellPathCache.shared.current,
@@ -96,6 +160,100 @@ public enum BinaryLocator {
             home: home)
     }
 
+    public static func resolveGrokBinary(
+        env: [String: String] = ProcessInfo.processInfo.environment,
+        loginPATH: [String]? = LoginShellPathCache.shared.current,
+        commandV: (String, String?, TimeInterval, FileManager) -> String? = ShellCommandLocator.commandV,
+        aliasResolver: (String, String?, TimeInterval, FileManager, String) -> String? = ShellCommandLocator
+            .resolveAlias,
+        fileManager: FileManager = .default,
+        home: String = NSHomeDirectory()) -> String?
+    {
+        self.resolveBinary(
+            name: "grok",
+            overrideKey: "GROK_CLI_PATH",
+            env: env,
+            loginPATH: loginPATH,
+            commandV: commandV,
+            aliasResolver: aliasResolver,
+            wellKnownPaths: self.grokWellKnownPaths(home: home),
+            fileManager: fileManager,
+            home: home)
+    }
+
+    public static func resolveAmpBinary(
+        env: [String: String] = ProcessInfo.processInfo.environment,
+        loginPATH: [String]? = LoginShellPathCache.shared.current,
+        commandV: (String, String?, TimeInterval, FileManager) -> String? = ShellCommandLocator.commandV,
+        aliasResolver: (String, String?, TimeInterval, FileManager, String) -> String? = ShellCommandLocator
+            .resolveAlias,
+        fileManager: FileManager = .default,
+        home: String = NSHomeDirectory()) -> String?
+    {
+        self.resolveBinary(
+            name: "amp",
+            overrideKey: "AMP_CLI_PATH",
+            env: env,
+            loginPATH: loginPATH,
+            commandV: commandV,
+            aliasResolver: aliasResolver,
+            wellKnownPaths: self.ampWellKnownPaths(home: home),
+            fileManager: fileManager,
+            home: home)
+    }
+
+    static func ampWellKnownPaths(home: String) -> [String] {
+        [
+            "\(home)/.local/bin/amp",
+            "\(home)/.amp/bin/amp",
+            "/opt/homebrew/bin/amp",
+            "/usr/local/bin/amp",
+        ]
+    }
+
+    /// Well-known install locations for the Grok Build CLI binary.
+    /// Covers the installer's default (`~/.grok/bin/grok`) and the symlinks it sometimes
+    /// creates into `~/.local/bin` and `/usr/local/bin`.
+    static func grokWellKnownPaths(home: String) -> [String] {
+        [
+            "\(home)/.grok/bin/grok",
+            "\(home)/.local/bin/grok",
+            "/usr/local/bin/grok",
+            "/opt/homebrew/bin/grok",
+        ]
+    }
+
+    public static func resolveAWSBinary(
+        env: [String: String] = ProcessInfo.processInfo.environment,
+        loginPATH: [String]? = LoginShellPathCache.shared.current,
+        commandV: (String, String?, TimeInterval, FileManager) -> String? = ShellCommandLocator.commandV,
+        aliasResolver: (String, String?, TimeInterval, FileManager, String) -> String? = ShellCommandLocator
+            .resolveAlias,
+        fileManager: FileManager = .default,
+        home: String = NSHomeDirectory()) -> String?
+    {
+        self.resolveBinary(
+            name: "aws",
+            overrideKey: "AWS_CLI_PATH",
+            env: env,
+            loginPATH: loginPATH,
+            commandV: commandV,
+            aliasResolver: aliasResolver,
+            wellKnownPaths: self.awsWellKnownPaths(home: home),
+            fileManager: fileManager,
+            home: home)
+    }
+
+    /// Well-known install locations for the AWS CLI v2 (`aws`).
+    /// Covers Homebrew (Apple Silicon + Intel) and the per-user pip/uv install path.
+    static func awsWellKnownPaths(home: String) -> [String] {
+        [
+            "/opt/homebrew/bin/aws",
+            "/usr/local/bin/aws",
+            "\(home)/.local/bin/aws",
+        ]
+    }
+
     public static func resolveAuggieBinary(
         env: [String: String] = ProcessInfo.processInfo.environment,
         loginPATH: [String]? = LoginShellPathCache.shared.current,
@@ -124,6 +282,8 @@ public enum BinaryLocator {
         loginPATH: [String]?,
         commandV: (String, String?, TimeInterval, FileManager) -> String?,
         aliasResolver: (String, String?, TimeInterval, FileManager, String) -> String?,
+        wellKnownPaths: [String] = [],
+        launchCandidateFilter: (String, FileManager) -> Bool = { _, _ in true },
         fileManager: FileManager,
         home: String) -> String?
     {
@@ -135,7 +295,11 @@ public enum BinaryLocator {
 
         // 2) Login-shell PATH (captured once per launch)
         if let loginPATH,
-           let pathHit = self.find(name, in: loginPATH, fileManager: fileManager)
+           let pathHit = self.find(
+               name,
+               in: loginPATH,
+               fileManager: fileManager,
+               launchCandidateFilter: launchCandidateFilter)
         {
             return pathHit
         }
@@ -145,38 +309,59 @@ public enum BinaryLocator {
            let pathHit = self.find(
                name,
                in: existingPATH.split(separator: ":").map(String.init),
-               fileManager: fileManager)
+               fileManager: fileManager,
+               launchCandidateFilter: launchCandidateFilter)
         {
             return pathHit
         }
 
-        // 4) Interactive login shell lookup (captures nvm/fnm/mise paths from .zshrc/.bashrc)
+        // 4) Well-known installation paths (e.g. Homebrew, cmux.app bundle, ~/.claude/bin).
+        // Prefer these before shell probing to avoid running interactive shell init for common installs.
+        for candidate in wellKnownPaths
+            where fileManager.isExecutableFile(atPath: candidate) && launchCandidateFilter(candidate, fileManager)
+        {
+            return candidate
+        }
+
+        // 5) Interactive login shell lookup (captures nvm/fnm/mise paths from .zshrc/.bashrc)
         if let shellHit = commandV(name, env["SHELL"], 2.0, fileManager),
-           fileManager.isExecutableFile(atPath: shellHit)
+           fileManager.isExecutableFile(atPath: shellHit),
+           launchCandidateFilter(shellHit, fileManager)
         {
             return shellHit
         }
 
-        // 4b) Alias fallback (login shell); only attempt after all standard lookups fail.
+        // 5b) Alias fallback (login shell); only attempt after all standard lookups fail.
         if let aliasHit = aliasResolver(name, env["SHELL"], 2.0, fileManager, home),
-           fileManager.isExecutableFile(atPath: aliasHit)
+           fileManager.isExecutableFile(atPath: aliasHit),
+           launchCandidateFilter(aliasHit, fileManager)
         {
             return aliasHit
         }
 
-        // 5) Minimal fallback
+        // 6) Minimal fallback
         let fallback = ["/usr/bin", "/bin", "/usr/sbin", "/sbin"]
-        if let pathHit = self.find(name, in: fallback, fileManager: fileManager) {
+        if let pathHit = self.find(
+            name,
+            in: fallback,
+            fileManager: fileManager,
+            launchCandidateFilter: launchCandidateFilter)
+        {
             return pathHit
         }
 
         return nil
     }
 
-    private static func find(_ binary: String, in paths: [String], fileManager: FileManager) -> String? {
+    private static func find(
+        _ binary: String,
+        in paths: [String],
+        fileManager: FileManager,
+        launchCandidateFilter: (String, FileManager) -> Bool = { _, _ in true }) -> String?
+    {
         for path in paths where !path.isEmpty {
             let candidate = "\(path.hasSuffix("/") ? String(path.dropLast()) : path)/\(binary)"
-            if fileManager.isExecutableFile(atPath: candidate) {
+            if fileManager.isExecutableFile(atPath: candidate), launchCandidateFilter(candidate, fileManager) {
                 return candidate
             }
         }
@@ -184,7 +369,188 @@ public enum BinaryLocator {
     }
 }
 
+public enum CodexLaunchPreflight {
+    public static func isLaunchCandidateAllowed(path: String, fileManager: FileManager = .default) -> Bool {
+        #if os(macOS)
+        self.isLaunchCandidateAllowed(
+            path: path,
+            fileManager: fileManager,
+            hasExtendedAttribute: self.hasExtendedAttribute,
+            spctlAssessment: { self.spctlAssessment(path: $0) },
+            isMachOExecutable: self.isMachOExecutable)
+        #else
+        _ = path
+        _ = fileManager
+        return true
+        #endif
+    }
+
+    #if os(macOS)
+    static func isLaunchCandidateAllowed(
+        path: String,
+        fileManager: FileManager,
+        hasExtendedAttribute: (String, String) -> Bool,
+        spctlAssessment: (String) -> String?,
+        isMachOExecutable: (String) -> Bool) -> Bool
+    {
+        let realPath = URL(fileURLWithPath: path).resolvingSymlinksInPath().path
+        let pathsToCheck = [path, realPath] + self.nativeCodexExecutableCandidates(
+            for: realPath,
+            fileManager: fileManager)
+
+        for candidate in Set(pathsToCheck) where hasExtendedAttribute(candidate, "com.apple.malware") {
+            return false
+        }
+
+        let hasQuarantine = Set(pathsToCheck).contains { hasExtendedAttribute($0, "com.apple.quarantine") }
+        guard let native = pathsToCheck.first(where: isMachOExecutable) else {
+            return !hasQuarantine
+        }
+
+        guard let assessment = spctlAssessment(native)
+        else {
+            return !hasQuarantine
+        }
+
+        return !self.isExplicitlyBlockedAssessment(assessment, path: native)
+    }
+
+    private static func nativeCodexExecutableCandidates(for path: String, fileManager: FileManager) -> [String] {
+        let url = URL(fileURLWithPath: path)
+        guard url.lastPathComponent == "codex.js" else { return [] }
+
+        let packageRoot = url.deletingLastPathComponent().deletingLastPathComponent()
+        return self.npmNativeCodexCandidates(packageRoot: packageRoot)
+            .map(\.path)
+            .filter { fileManager.isExecutableFile(atPath: $0) }
+    }
+
+    private static func npmNativeCodexCandidates(packageRoot: URL) -> [URL] {
+        guard let target = self.darwinCodexTarget else { return [] }
+        let optionalPackage = packageRoot
+            .appendingPathComponent("node_modules")
+            .appendingPathComponent("@openai")
+            .appendingPathComponent(target.packageName)
+
+        return [
+            optionalPackage,
+            packageRoot,
+        ].map {
+            $0.appendingPathComponent("vendor")
+                .appendingPathComponent(target.triple)
+                .appendingPathComponent("codex")
+                .appendingPathComponent("codex")
+        }
+    }
+
+    private static var darwinCodexTarget: (packageName: String, triple: String)? {
+        #if arch(arm64)
+        ("codex-darwin-arm64", "aarch64-apple-darwin")
+        #elseif arch(x86_64)
+        ("codex-darwin-x64", "x86_64-apple-darwin")
+        #else
+        nil
+        #endif
+    }
+
+    private static func hasExtendedAttribute(path: String, name: String) -> Bool {
+        path.withCString { pathPointer in
+            name.withCString { namePointer in
+                getxattr(pathPointer, namePointer, nil, 0, 0, 0) >= 0
+            }
+        }
+    }
+
+    private static func isMachOExecutable(path: String) -> Bool {
+        guard let handle = try? FileHandle(forReadingFrom: URL(fileURLWithPath: path)) else { return false }
+        defer { try? handle.close() }
+
+        guard let data = try? handle.read(upToCount: 4), data.count == 4 else { return false }
+        let bytes = [UInt8](data)
+        return bytes == [0xFE, 0xED, 0xFA, 0xCE] ||
+            bytes == [0xCE, 0xFA, 0xED, 0xFE] ||
+            bytes == [0xFE, 0xED, 0xFA, 0xCF] ||
+            bytes == [0xCF, 0xFA, 0xED, 0xFE] ||
+            bytes == [0xCA, 0xFE, 0xBA, 0xBE] ||
+            bytes == [0xCA, 0xFE, 0xBA, 0xBF]
+    }
+
+    private static func spctlAssessment(path: String, timeout: TimeInterval = 2.0) -> String? {
+        let spctlPath = "/usr/sbin/spctl"
+        guard FileManager.default.isExecutableFile(atPath: spctlPath) else { return nil }
+
+        let process = Process()
+        process.executableURL = URL(fileURLWithPath: spctlPath)
+        process.arguments = ["--assess", "--type", "execute", "--verbose=4", path]
+
+        let output = Pipe()
+        process.standardOutput = output
+        process.standardError = output
+
+        let finished = DispatchSemaphore(value: 0)
+        process.terminationHandler = { _ in finished.signal() }
+
+        do {
+            try process.run()
+        } catch {
+            return nil
+        }
+
+        if finished.wait(timeout: .now() + timeout) != .success {
+            process.terminate()
+            return nil
+        }
+
+        let data = output.fileHandleForReading.readDataToEndOfFile()
+        return String(data: data, encoding: .utf8)
+    }
+
+    private static func isExplicitlyBlockedAssessment(_ assessment: String, path: String) -> Bool {
+        let lower = self.assessmentDiagnosticText(assessment, path: path).lowercased()
+        if lower.contains("denied") ||
+            lower.contains("cssmerr_tp_cert_revoked") ||
+            lower.contains("revoked") ||
+            lower.contains("malware") ||
+            lower.contains("quarantine")
+        {
+            return true
+        }
+        if lower.contains("rejected") {
+            return !lower.contains("code is valid but does not seem to be an app")
+        }
+        return false
+    }
+
+    private static func assessmentDiagnosticText(_ assessment: String, path: String) -> String {
+        assessment
+            .split(whereSeparator: \.isNewline)
+            .enumerated()
+            .compactMap { offset, line -> String? in
+                var text = line.trimmingCharacters(in: .whitespacesAndNewlines)
+                if offset == 0, text.hasPrefix("\(path):") {
+                    text = String(text.dropFirst(path.count + 1))
+                        .trimmingCharacters(in: .whitespacesAndNewlines)
+                }
+                let lower = text.lowercased()
+                guard !lower.hasPrefix("source="), !lower.hasPrefix("origin=") else {
+                    return nil
+                }
+                return text
+            }
+            .joined(separator: "\n")
+    }
+    #endif
+}
+
 public enum ShellCommandLocator {
+    static func test_runShellCommand(
+        shell: String,
+        arguments: [String],
+        timeout: TimeInterval) -> Data?
+    {
+        self.runShellCommand(shell: shell, arguments: arguments, timeout: timeout)
+    }
+
     public static func commandV(
         _ tool: String,
         _ shell: String?,
@@ -232,34 +598,242 @@ public enum ShellCommandLocator {
         return nil
     }
 
-    private static func runShellCapture(_ shell: String?, _ timeout: TimeInterval, _ command: String) -> String? {
-        let shellPath = (shell?.isEmpty == false) ? shell! : "/bin/zsh"
-        let isCI = ["1", "true"].contains(ProcessInfo.processInfo.environment["CI"]?.lowercased())
-        let process = Process()
-        process.executableURL = URL(fileURLWithPath: shellPath)
-        // Interactive login shell to pick up PATH mutations from shell init (nvm/fnm/mise).
-        // CI runners can have shell init hooks that emit missing CLI errors; avoid them in CI.
-        process.arguments = isCI ? ["-c", command] : ["-l", "-i", "-c", command]
-        let stdout = Pipe()
-        process.standardOutput = stdout
-        process.standardError = Pipe()
-        do {
-            try process.run()
-        } catch {
+    /// Thread-safe buffer for collecting pipe output from a readability handler.
+    private final class CapturedData: @unchecked Sendable {
+        private let lock = NSLock()
+        private var data = Data()
+
+        func append(_ other: Data) {
+            self.lock.lock()
+            self.data.append(other)
+            self.lock.unlock()
+        }
+
+        func drain() -> Data {
+            self.lock.lock()
+            let result = self.data
+            self.lock.unlock()
+            return result
+        }
+    }
+
+    /// Idempotent one-shot flag — `fire()` returns true exactly once.
+    /// Used to make `DispatchGroup.leave()` safe to attempt from multiple paths.
+    private final class OnceFlag: @unchecked Sendable {
+        private let lock = NSLock()
+        private var fired = false
+
+        func fire() -> Bool {
+            self.lock.lock()
+            defer { self.lock.unlock() }
+            if self.fired { return false }
+            self.fired = true
+            return true
+        }
+    }
+
+    // swiftlint:disable cyclomatic_complexity
+    /// Runs a shell command, draining both stdout and stderr concurrently so that
+    /// verbose shell init scripts (oh-my-zsh, nvm, pyenv, etc.) cannot deadlock on
+    /// a full pipe buffer.  The child is launched via `posix_spawn` with
+    /// `POSIX_SPAWN_SETPGROUP` so it becomes its own process-group leader *before*
+    /// `exec`, which guarantees that subsequent `kill(-pgid, ...)` calls reach any
+    /// background helpers spawned by shell init, on both the timeout-kill path and
+    /// after normal completion.
+    fileprivate static func runShellCommand(
+        shell: String,
+        arguments: [String],
+        timeout: TimeInterval) -> Data?
+    {
+        // Pipes for stdout/stderr.  stdin is redirected from /dev/null in the child
+        // via posix_spawn_file_actions_addopen below.
+        var stdoutFds: (read: Int32, write: Int32) = (-1, -1)
+        var stderrFds: (read: Int32, write: Int32) = (-1, -1)
+        guard withUnsafeMutablePointer(to: &stdoutFds, {
+            $0.withMemoryRebound(to: Int32.self, capacity: 2) { pipe($0) == 0 }
+        }) else { return nil }
+        guard withUnsafeMutablePointer(to: &stderrFds, {
+            $0.withMemoryRebound(to: Int32.self, capacity: 2) { pipe($0) == 0 }
+        }) else {
+            close(stdoutFds.read); close(stdoutFds.write)
             return nil
         }
 
-        let deadline = Date().addingTimeInterval(timeout)
-        while process.isRunning, Date() < deadline {
-            Thread.sleep(forTimeInterval: 0.05)
+        // Build file actions: redirect stdin from /dev/null, dup pipe write ends to
+        // fds 1 and 2, and close every pipe fd in the child.  The init pattern
+        // differs between platforms because the typedef is an opaque pointer on
+        // Darwin and a struct on Linux C modules.
+        #if canImport(Darwin)
+        var fileActions: posix_spawn_file_actions_t?
+        #else
+        var fileActions = posix_spawn_file_actions_t()
+        #endif
+        guard posix_spawn_file_actions_init(&fileActions) == 0 else {
+            close(stdoutFds.read); close(stdoutFds.write)
+            close(stderrFds.read); close(stderrFds.write)
+            return nil
         }
+        defer { posix_spawn_file_actions_destroy(&fileActions) }
+        posix_spawn_file_actions_addopen(&fileActions, 0, "/dev/null", O_RDONLY, 0)
+        posix_spawn_file_actions_adddup2(&fileActions, stdoutFds.write, 1)
+        posix_spawn_file_actions_adddup2(&fileActions, stderrFds.write, 2)
+        posix_spawn_file_actions_addclose(&fileActions, stdoutFds.read)
+        posix_spawn_file_actions_addclose(&fileActions, stdoutFds.write)
+        posix_spawn_file_actions_addclose(&fileActions, stderrFds.read)
+        posix_spawn_file_actions_addclose(&fileActions, stderrFds.write)
 
-        if process.isRunning {
-            process.terminate()
+        // Build attributes: set the child's process group to itself in the child,
+        // before exec, eliminating the race that an after-launch setpgid(2) has.
+        #if canImport(Darwin)
+        var attr: posix_spawnattr_t?
+        #else
+        var attr = posix_spawnattr_t()
+        #endif
+        guard posix_spawnattr_init(&attr) == 0 else {
+            close(stdoutFds.read); close(stdoutFds.write)
+            close(stderrFds.read); close(stderrFds.write)
+            return nil
+        }
+        defer { posix_spawnattr_destroy(&attr) }
+        posix_spawnattr_setflags(&attr, Int16(POSIX_SPAWN_SETPGROUP))
+        posix_spawnattr_setpgroup(&attr, 0) // 0 = child becomes its own pgid leader
+
+        // Build argv (argv[0] is conventionally the executable path).
+        var cArgs: [UnsafeMutablePointer<CChar>?] = []
+        cArgs.append(strdup(shell))
+        for arg in arguments {
+            cArgs.append(strdup(arg))
+        }
+        cArgs.append(nil)
+        defer {
+            for p in cArgs {
+                if let p {
+                    free(p)
+                }
+            }
+        }
+
+        // Inherit the parent environment.  Build a NULL-terminated `KEY=VALUE`
+        // array since `extern char **environ` isn't directly visible from Swift.
+        var cEnv: [UnsafeMutablePointer<CChar>?] = []
+        for (key, value) in ProcessInfo.processInfo.environment {
+            cEnv.append(strdup("\(key)=\(value)"))
+        }
+        cEnv.append(nil)
+        defer {
+            for p in cEnv {
+                if let p {
+                    free(p)
+                }
+            }
+        }
+
+        var pid: pid_t = 0
+        let spawnResult = shell.withCString { execPath in
+            posix_spawn(&pid, execPath, &fileActions, &attr, cArgs, cEnv)
+        }
+
+        // Close the write ends in the parent so EOF will arrive on the read ends
+        // once every descendant in the process group also closes them.
+        close(stdoutFds.write)
+        close(stderrFds.write)
+
+        guard spawnResult == 0 else {
+            close(stdoutFds.read); close(stderrFds.read)
+            return nil
+        }
+
+        // POSIX_SPAWN_SETPGROUP with pgroup=0 guarantees the child's pgid == its pid.
+        let pgid: pid_t = pid
+
+        // Track EOF on each pipe so we can wait for full drain instead of sleeping.
+        // The readability handler fires with empty data when every writer end is
+        // closed (i.e. the child *and* any inheriting background helpers are gone).
+        let drainGroup = DispatchGroup()
+        drainGroup.enter()
+        drainGroup.enter()
+        let stdoutDone = OnceFlag()
+        let stderrDone = OnceFlag()
+
+        let stdoutCollector = CapturedData()
+        let stdoutHandle = FileHandle(fileDescriptor: stdoutFds.read, closeOnDealloc: true)
+        stdoutHandle.readabilityHandler = { handle in
+            let data = handle.availableData
+            if data.isEmpty {
+                handle.readabilityHandler = nil
+                if stdoutDone.fire() { drainGroup.leave() }
+            } else {
+                stdoutCollector.append(data)
+            }
+        }
+
+        let stderrHandle = FileHandle(fileDescriptor: stderrFds.read, closeOnDealloc: true)
+        stderrHandle.readabilityHandler = { handle in
+            let data = handle.availableData
+            if data.isEmpty {
+                handle.readabilityHandler = nil
+                if stderrDone.fire() { drainGroup.leave() }
+            }
+        }
+
+        // Reap the child on a background queue and signal a semaphore on exit.
+        let exitSemaphore = DispatchSemaphore(value: 0)
+        let waitPid = pid
+        DispatchQueue.global(qos: .userInitiated).async {
+            var status: Int32 = 0
+            while waitpid(waitPid, &status, 0) == -1, errno == EINTR {
+                // retry
+            }
+            exitSemaphore.signal()
+        }
+
+        let finishedInTime = exitSemaphore.wait(timeout: .now() + timeout) == .success
+
+        if !finishedInTime {
+            kill(-pgid, SIGTERM)
+            kill(pid, SIGTERM)
+            if exitSemaphore.wait(timeout: .now() + 0.4) != .success {
+                kill(-pgid, SIGKILL)
+                kill(pid, SIGKILL)
+                _ = exitSemaphore.wait(timeout: .now() + 1.0)
+            }
+            stdoutHandle.readabilityHandler = nil
+            stderrHandle.readabilityHandler = nil
+            if stdoutDone.fire() { drainGroup.leave() }
+            if stderrDone.fire() { drainGroup.leave() }
             return nil
         }
 
-        let data = stdout.fileHandleForReading.readDataToEndOfFile()
+        // Normal completion — clean up any background children spawned by shell init.
+        // Without this, helpers that inherited stdout/stderr keep the pipe write ends
+        // open and we never see EOF on the read ends.
+        kill(-pgid, SIGTERM)
+
+        // Wait for both pipes to deliver EOF so no buffered bytes are lost.
+        // Bounded so a stuck handler can't hang the caller indefinitely.
+        if drainGroup.wait(timeout: .now() + 0.4) != .success {
+            kill(-pgid, SIGKILL)
+        }
+        if drainGroup.wait(timeout: .now() + 0.6) != .success {
+            stdoutHandle.readabilityHandler = nil
+            stderrHandle.readabilityHandler = nil
+            if stdoutDone.fire() { drainGroup.leave() }
+            if stderrDone.fire() { drainGroup.leave() }
+        }
+        return stdoutCollector.drain()
+    }
+
+    // swiftlint:enable cyclomatic_complexity
+
+    private static func runShellCapture(_ shell: String?, _ timeout: TimeInterval, _ command: String) -> String? {
+        let shellPath = (shell?.isEmpty == false) ? shell! : "/bin/zsh"
+        let isCI = ["1", "true"].contains(ProcessInfo.processInfo.environment["CI"]?.lowercased())
+        // Interactive login shell to pick up PATH mutations from shell init (nvm/fnm/mise).
+        // CI runners can have shell init hooks that emit missing CLI errors; avoid them in CI.
+        let args = isCI ? ["-c", command] : ["-l", "-i", "-c", command]
+        guard let data = runShellCommand(shell: shellPath, arguments: args, timeout: timeout) else {
+            return nil
+        }
         return String(data: data, encoding: .utf8)
     }
 
@@ -388,41 +962,26 @@ public enum PathBuilder {
 }
 
 enum LoginShellPathCapturer {
+    static let defaultTimeout: TimeInterval = 6.0
+
     static func capture(
         shell: String? = ProcessInfo.processInfo.environment["SHELL"],
-        timeout: TimeInterval = 2.0) -> [String]?
+        timeout: TimeInterval = Self.defaultTimeout) -> [String]?
     {
         let shellPath = (shell?.isEmpty == false) ? shell! : "/bin/zsh"
         let isCI = ["1", "true"].contains(ProcessInfo.processInfo.environment["CI"]?.lowercased())
         let marker = "__CODEXBAR_PATH__"
-        let process = Process()
-        process.executableURL = URL(fileURLWithPath: shellPath)
         // Skip interactive login shells in CI to avoid noisy init hooks.
-        process.arguments = isCI
+        let args = isCI
             ? ["-c", "printf '\(marker)%s\(marker)' \"$PATH\""]
             : ["-l", "-i", "-c", "printf '\(marker)%s\(marker)' \"$PATH\""]
-        let stdout = Pipe()
-        process.standardOutput = stdout
-        process.standardError = Pipe()
-        do {
-            try process.run()
-        } catch {
-            return nil
-        }
-
-        let deadline = Date().addingTimeInterval(timeout)
-        while process.isRunning, Date() < deadline {
-            Thread.sleep(forTimeInterval: 0.05)
-        }
-
-        if process.isRunning {
-            process.terminate()
-            return nil
-        }
-
-        let data = stdout.fileHandleForReading.readDataToEndOfFile()
-        guard let raw = String(data: data, encoding: .utf8),
-              !raw.isEmpty else { return nil }
+        guard let data = ShellCommandLocator.runShellCommand(
+            shell: shellPath,
+            arguments: args,
+            timeout: timeout),
+            let raw = String(data: data, encoding: .utf8),
+            !raw.isEmpty
+        else { return nil }
 
         let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines)
         let extracted = if let start = trimmed.range(of: marker),
@@ -444,10 +1003,15 @@ public final class LoginShellPathCache: @unchecked Sendable {
     public static let shared = LoginShellPathCache()
 
     private let lock = NSLock()
+    private let capture: @Sendable (String?, TimeInterval) -> [String]?
     private var captured: [String]?
     private var isCapturing = false
     private var callbacks: [([String]?) -> Void] = []
 
+    init(capture: @escaping @Sendable (String?, TimeInterval) -> [String]? = LoginShellPathCapturer.capture) {
+        self.capture = capture
+    }
+
     public var current: [String]? {
         self.lock.lock()
         let value = self.captured
@@ -457,7 +1021,7 @@ public final class LoginShellPathCache: @unchecked Sendable {
 
     public func captureOnce(
         shell: String? = ProcessInfo.processInfo.environment["SHELL"],
-        timeout: TimeInterval = 2.0,
+        timeout: TimeInterval = 6.0,
         onFinish: (([String]?) -> Void)? = nil)
     {
         self.lock.lock()
@@ -479,8 +1043,9 @@ public final class LoginShellPathCache: @unchecked Sendable {
         self.isCapturing = true
         self.lock.unlock()
 
+        let capture = self.capture
         DispatchQueue.global(qos: .utility).async { [weak self] in
-            let result = LoginShellPathCapturer.capture(shell: shell, timeout: timeout)
+            let result = capture(shell, timeout)
             guard let self else { return }
 
             self.lock.lock()
@@ -493,4 +1058,42 @@ public final class LoginShellPathCache: @unchecked Sendable {
             callbacks.forEach { $0(result) }
         }
     }
+
+    public func currentOrCapture(
+        shell: String? = ProcessInfo.processInfo.environment["SHELL"],
+        timeout: TimeInterval = 6.0) -> [String]?
+    {
+        self.lock.lock()
+        if let captured {
+            self.lock.unlock()
+            return captured
+        }
+
+        if self.isCapturing {
+            let semaphore = DispatchSemaphore(value: 0)
+            var callbackResult: [String]?
+            self.callbacks.append { result in
+                callbackResult = result
+                semaphore.signal()
+            }
+            self.lock.unlock()
+            let deadline = DispatchTime.now() + timeout
+            _ = semaphore.wait(timeout: deadline)
+            return callbackResult ?? self.current
+        }
+
+        self.isCapturing = true
+        self.lock.unlock()
+
+        let result = self.capture(shell, timeout)
+        self.lock.lock()
+        self.captured = result
+        self.isCapturing = false
+        let callbacks = self.callbacks
+        self.callbacks.removeAll()
+        self.lock.unlock()
+
+        callbacks.forEach { $0(result) }
+        return result
+    }
 }
diff --git a/Sources/CodexBarCore/PiSessionCostCache.swift b/Sources/CodexBarCore/PiSessionCostCache.swift
new file mode 100644
index 0000000000..60abcae518
--- /dev/null
+++ b/Sources/CodexBarCore/PiSessionCostCache.swift
@@ -0,0 +1,95 @@
+import Foundation
+
+enum PiSessionCostCacheIO {
+    private static let artifactVersion = 3
+
+    private static func defaultCacheRoot() -> URL {
+        let root = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first!
+        return root.appendingPathComponent("CodexBar", isDirectory: true)
+    }
+
+    static func cacheFileURL(cacheRoot: URL? = nil) -> URL {
+        let root = cacheRoot ?? self.defaultCacheRoot()
+        return root
+            .appendingPathComponent("cost-usage", isDirectory: true)
+            .appendingPathComponent("pi-sessions-v\(Self.artifactVersion).json", isDirectory: false)
+    }
+
+    static func load(cacheRoot: URL? = nil) -> PiSessionCostCache {
+        let url = self.cacheFileURL(cacheRoot: cacheRoot)
+        guard let data = try? Data(contentsOf: url),
+              let decoded = try? JSONDecoder().decode(PiSessionCostCache.self, from: data),
+              decoded.version == Self.artifactVersion
+        else {
+            return PiSessionCostCache(version: Self.artifactVersion)
+        }
+        return decoded
+    }
+
+    static func save(cache: PiSessionCostCache, cacheRoot: URL? = nil) {
+        let url = self.cacheFileURL(cacheRoot: cacheRoot)
+        let dir = url.deletingLastPathComponent()
+        try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+
+        let tmp = dir.appendingPathComponent(".tmp-\(UUID().uuidString).json", isDirectory: false)
+        let data = (try? JSONEncoder().encode(cache)) ?? Data()
+        do {
+            try data.write(to: tmp, options: [.atomic])
+            if FileManager.default.fileExists(atPath: url.path) {
+                _ = try FileManager.default.replaceItemAt(url, withItemAt: tmp)
+            } else {
+                try FileManager.default.moveItem(at: tmp, to: url)
+            }
+        } catch {
+            try? FileManager.default.removeItem(at: tmp)
+        }
+    }
+}
+
+struct PiSessionCostCache: Codable {
+    var version: Int
+    var lastScanUnixMs: Int64 = 0
+    var scanSinceKey: String?
+    var scanUntilKey: String?
+    var daysByProvider: [String: [String: [String: PiPackedUsage]]] = [:]
+    var files: [String: PiSessionFileUsage] = [:]
+
+    init(version: Int = 3) {
+        self.version = version
+    }
+}
+
+struct PiSessionFileUsage: Codable {
+    var mtimeUnixMs: Int64
+    var size: Int64
+    var parsedBytes: Int64
+    var lastModelContext: PiModelContext?
+    var contributions: [String: [String: [String: PiPackedUsage]]]
+}
+
+struct PiModelContext: Codable, Equatable {
+    var providerRawValue: String
+    var modelName: String
+}
+
+struct PiPackedUsage: Codable, Equatable {
+    var inputTokens: Int = 0
+    var cacheReadTokens: Int = 0
+    var cacheWriteTokens: Int = 0
+    var outputTokens: Int = 0
+    var totalTokens: Int = 0
+    var costNanos: Int64 = 0
+    var costSampleCount: Int = 0
+    var usageSampleCount: Int?
+
+    var isZero: Bool {
+        self.inputTokens == 0
+            && self.cacheReadTokens == 0
+            && self.cacheWriteTokens == 0
+            && self.outputTokens == 0
+            && self.totalTokens == 0
+            && self.costNanos == 0
+            && self.costSampleCount == 0
+            && (self.usageSampleCount ?? 0) == 0
+    }
+}
diff --git a/Sources/CodexBarCore/PiSessionCostScanner.swift b/Sources/CodexBarCore/PiSessionCostScanner.swift
new file mode 100644
index 0000000000..8b031e2010
--- /dev/null
+++ b/Sources/CodexBarCore/PiSessionCostScanner.swift
@@ -0,0 +1,900 @@
+import Foundation
+
+private final class PiSessionISO8601FormatterBox: @unchecked Sendable {
+    let lock = NSLock()
+    let withFractional: ISO8601DateFormatter = {
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        return formatter
+    }()
+
+    let plain: ISO8601DateFormatter = {
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime]
+        return formatter
+    }()
+}
+
+enum PiSessionCostScanner {
+    struct Options {
+        var piSessionsRoot: URL?
+        var cacheRoot: URL?
+        var refreshMinIntervalSeconds: TimeInterval = 60
+        var forceRescan: Bool = false
+
+        init(
+            piSessionsRoot: URL? = nil,
+            cacheRoot: URL? = nil,
+            refreshMinIntervalSeconds: TimeInterval = 60,
+            forceRescan: Bool = false)
+        {
+            self.piSessionsRoot = piSessionsRoot
+            self.cacheRoot = cacheRoot
+            self.refreshMinIntervalSeconds = refreshMinIntervalSeconds
+            self.forceRescan = forceRescan
+        }
+    }
+
+    private struct ParseResult {
+        let contributions: [String: [String: [String: PiPackedUsage]]]
+        let parsedBytes: Int64
+        let lastModelContext: PiModelContext?
+    }
+
+    private struct AssistantIdentity {
+        let provider: UsageProvider
+        let modelName: String
+    }
+
+    private struct ModelsDevPricingContext {
+        let catalog: ModelsDevCatalog?
+        let cacheRoot: URL?
+    }
+
+    private struct ScanContext {
+        let range: CostUsageScanner.CostUsageDayRange
+        let forceRescan: Bool
+        let pricingContext: ModelsDevPricingContext
+        let checkCancellation: CostUsageScanner.CancellationCheck?
+    }
+
+    private static let costScale = 1_000_000_000.0
+    private static let maxLineBytes = 16 * 1024 * 1024
+    private static let maxSafeRoundedInt = Double(Int.max) - 1
+    private static let sessionStartFilenameRegex = try? NSRegularExpression(
+        pattern: "^(\\d{4}-\\d{2}-\\d{2})T(\\d{2})-(\\d{2})-(\\d{2})-(\\d{3})Z_")
+    private static let isoFormatterBox = PiSessionISO8601FormatterBox()
+
+    static func loadDailyReport(
+        provider: UsageProvider,
+        since: Date,
+        until: Date,
+        now: Date = Date(),
+        options: Options = Options()) -> CostUsageDailyReport
+    {
+        (
+            try? self.loadDailyReportCancellable(
+                provider: provider,
+                since: since,
+                until: until,
+                now: now,
+                options: options,
+                checkCancellation: nil)) ?? CostUsageDailyReport(data: [], summary: nil)
+    }
+
+    static func loadDailyReportCancellable(
+        provider: UsageProvider,
+        since: Date,
+        until: Date,
+        now: Date = Date(),
+        options: Options = Options(),
+        checkCancellation: CostUsageScanner.CancellationCheck?) throws -> CostUsageDailyReport
+    {
+        guard provider == .codex || provider == .claude else {
+            return CostUsageDailyReport(data: [], summary: nil)
+        }
+
+        let range = CostUsageScanner.CostUsageDayRange(since: since, until: until)
+        var cache = PiSessionCostCacheIO.load(cacheRoot: options.cacheRoot)
+        let nowMs = Int64(now.timeIntervalSince1970 * 1000)
+        let refreshMs = Int64(max(0, options.refreshMinIntervalSeconds) * 1000)
+        let pricingContext = ModelsDevPricingContext(
+            catalog: CostUsagePricing.modelsDevCatalog(now: now, cacheRoot: options.cacheRoot),
+            cacheRoot: options.cacheRoot)
+        let windowExpanded = self.requestedWindowExpandsCache(range: range, cache: cache)
+        let shouldRefresh = options.forceRescan
+            || windowExpanded
+            || refreshMs == 0
+            || cache.lastScanUnixMs == 0
+            || nowMs - cache.lastScanUnixMs > refreshMs
+
+        if shouldRefresh {
+            try checkCancellation?()
+            let root = self.defaultPiSessionsRoot(options: options)
+            let startCutoff = self.dateFromDayKey(range.scanSinceKey) ?? since
+            let files = self.listPiSessionFiles(root: root, startCutoffLocal: startCutoff)
+            let filePathsInScan = Set(files.map(\.path))
+
+            for fileURL in files {
+                try self.scanPiSessionFile(
+                    fileURL: fileURL,
+                    cache: &cache,
+                    context: ScanContext(
+                        range: range,
+                        forceRescan: options.forceRescan || windowExpanded,
+                        pricingContext: pricingContext,
+                        checkCancellation: checkCancellation))
+            }
+            try checkCancellation?()
+
+            for key in cache.files.keys where !filePathsInScan.contains(key) {
+                if let old = cache.files[key] {
+                    self.applyContributions(
+                        daysByProvider: &cache.daysByProvider,
+                        contributions: old.contributions,
+                        sign: -1)
+                }
+                cache.files.removeValue(forKey: key)
+            }
+
+            cache.scanSinceKey = range.scanSinceKey
+            cache.scanUntilKey = range.scanUntilKey
+            cache.lastScanUnixMs = nowMs
+            try checkCancellation?()
+            PiSessionCostCacheIO.save(cache: cache, cacheRoot: options.cacheRoot)
+        }
+
+        return self.buildReport(
+            provider: provider,
+            cache: cache,
+            range: range,
+            pricingContext: pricingContext)
+    }
+
+    static func loadCachedDailyReport(
+        provider: UsageProvider,
+        since: Date,
+        until: Date,
+        now: Date = Date(),
+        cacheRoot: URL? = nil) -> CostUsageDailyReport?
+    {
+        guard provider == .codex || provider == .claude else { return nil }
+
+        let range = CostUsageScanner.CostUsageDayRange(since: since, until: until)
+        let cache = PiSessionCostCacheIO.load(cacheRoot: cacheRoot)
+        guard !cache.daysByProvider.isEmpty else { return nil }
+        guard !self.requestedWindowExpandsCache(range: range, cache: cache) else { return nil }
+
+        let pricingContext = ModelsDevPricingContext(
+            catalog: CostUsagePricing.modelsDevCatalog(now: now, cacheRoot: cacheRoot),
+            cacheRoot: cacheRoot)
+        let report = self.buildReport(
+            provider: provider,
+            cache: cache,
+            range: range,
+            pricingContext: pricingContext)
+        return report.data.isEmpty ? nil : report
+    }
+
+    private static func requestedWindowExpandsCache(
+        range: CostUsageScanner.CostUsageDayRange,
+        cache: PiSessionCostCache) -> Bool
+    {
+        guard let cachedSince = cache.scanSinceKey,
+              let cachedUntil = cache.scanUntilKey
+        else {
+            return true
+        }
+
+        if range.scanSinceKey < cachedSince {
+            return true
+        }
+        if range.scanUntilKey > cachedUntil {
+            return true
+        }
+        return false
+    }
+
+    private static func defaultPiSessionsRoot(options: Options) -> URL {
+        if let override = options.piSessionsRoot { return override }
+        return FileManager.default.homeDirectoryForCurrentUser
+            .appendingPathComponent(".pi", isDirectory: true)
+            .appendingPathComponent("agent", isDirectory: true)
+            .appendingPathComponent("sessions", isDirectory: true)
+    }
+
+    private static func listPiSessionFiles(root: URL, startCutoffLocal: Date) -> [URL] {
+        guard FileManager.default.fileExists(atPath: root.path) else { return [] }
+
+        let keys: Set<URLResourceKey> = [.isRegularFileKey, .contentModificationDateKey]
+        guard let enumerator = FileManager.default.enumerator(
+            at: root,
+            includingPropertiesForKeys: Array(keys),
+            options: [.skipsHiddenFiles])
+        else {
+            return []
+        }
+
+        var output: [URL] = []
+        while let item = enumerator.nextObject() as? URL {
+            guard item.pathExtension.lowercased() == "jsonl" else { continue }
+            let values = try? item.resourceValues(forKeys: keys)
+            guard values?.isRegularFile == true else { continue }
+
+            let startedAt = self.parseSessionStartFromFilename(item.lastPathComponent)
+            let modifiedAt = values?.contentModificationDate
+            if self
+                .shouldIncludeFile(startedAt: startedAt, modifiedAt: modifiedAt, startCutoffLocal: startCutoffLocal)
+            {
+                output.append(item)
+            }
+        }
+
+        return output.sorted(by: { $0.path < $1.path })
+    }
+
+    private static func shouldIncludeFile(
+        startedAt: Date?,
+        modifiedAt: Date?,
+        startCutoffLocal: Date) -> Bool
+    {
+        if let modifiedAt, self.localMidnight(modifiedAt) >= startCutoffLocal {
+            return true
+        }
+        if let startedAt, self.localMidnight(startedAt) >= startCutoffLocal {
+            return true
+        }
+        return false
+    }
+
+    private static func scanPiSessionFile(
+        fileURL: URL,
+        cache: inout PiSessionCostCache,
+        context: ScanContext)
+        throws
+    {
+        try context.checkCancellation?()
+        let path = fileURL.path
+        let attrs = (try? FileManager.default.attributesOfItem(atPath: path)) ?? [:]
+        let mtime = (attrs[.modificationDate] as? Date)?.timeIntervalSince1970 ?? 0
+        let size = (attrs[.size] as? NSNumber)?.int64Value ?? 0
+        let mtimeMs = Int64(mtime * 1000)
+
+        func storeFileUsage(_ usage: PiSessionFileUsage) {
+            cache.files[path] = usage
+        }
+
+        let cached = cache.files[path]
+        if !context.forceRescan,
+           let cached,
+           cached.mtimeUnixMs == mtimeMs,
+           cached.size == size
+        {
+            return
+        }
+
+        if !context.forceRescan,
+           let cached,
+           size > cached.size,
+           cached.parsedBytes > 0,
+           cached.parsedBytes <= size
+        {
+            let delta = try self.parsePiSessionFile(
+                fileURL: fileURL,
+                range: context.range,
+                startOffset: cached.parsedBytes,
+                initialModelContext: cached.lastModelContext,
+                pricingContext: context.pricingContext,
+                checkCancellation: context.checkCancellation)
+            if !delta.contributions.isEmpty {
+                self.applyContributions(
+                    daysByProvider: &cache.daysByProvider,
+                    contributions: delta.contributions,
+                    sign: 1)
+            }
+            let merged = self.mergedContributions(existing: cached.contributions, delta: delta.contributions)
+            storeFileUsage(PiSessionFileUsage(
+                mtimeUnixMs: mtimeMs,
+                size: size,
+                parsedBytes: delta.parsedBytes,
+                lastModelContext: delta.lastModelContext,
+                contributions: merged))
+            return
+        }
+
+        if let cached {
+            self.applyContributions(
+                daysByProvider: &cache.daysByProvider,
+                contributions: cached.contributions,
+                sign: -1)
+        }
+
+        let parsed = try self.parsePiSessionFile(
+            fileURL: fileURL,
+            range: context.range,
+            pricingContext: context.pricingContext,
+            checkCancellation: context.checkCancellation)
+        if !parsed.contributions.isEmpty {
+            self.applyContributions(daysByProvider: &cache.daysByProvider, contributions: parsed.contributions, sign: 1)
+        }
+
+        storeFileUsage(PiSessionFileUsage(
+            mtimeUnixMs: mtimeMs,
+            size: size,
+            parsedBytes: parsed.parsedBytes,
+            lastModelContext: parsed.lastModelContext,
+            contributions: parsed.contributions))
+    }
+
+    private static func parsePiSessionFile(
+        fileURL: URL,
+        range: CostUsageScanner.CostUsageDayRange,
+        startOffset: Int64 = 0,
+        initialModelContext: PiModelContext? = nil,
+        pricingContext: ModelsDevPricingContext? = nil,
+        checkCancellation: CostUsageScanner.CancellationCheck? = nil) throws -> ParseResult
+    {
+        var currentModelContext = initialModelContext
+        var contributions: [String: [String: [String: PiPackedUsage]]] = [:]
+
+        func add(provider: UsageProvider, dayKey: String, modelName: String, usage: PiPackedUsage) {
+            guard !usage.isZero else { return }
+            guard CostUsageScanner.CostUsageDayRange.isInRange(
+                dayKey: dayKey,
+                since: range.scanSinceKey,
+                until: range.scanUntilKey)
+            else {
+                return
+            }
+
+            let providerKey = provider.rawValue
+            var providerDays = contributions[providerKey] ?? [:]
+            var dayModels = providerDays[dayKey] ?? [:]
+            let merged = self.addPacked(a: dayModels[modelName] ?? PiPackedUsage(), b: usage, sign: 1)
+            if merged.isZero {
+                dayModels.removeValue(forKey: modelName)
+            } else {
+                dayModels[modelName] = merged
+            }
+            if dayModels.isEmpty {
+                providerDays.removeValue(forKey: dayKey)
+            } else {
+                providerDays[dayKey] = dayModels
+            }
+            if providerDays.isEmpty {
+                contributions.removeValue(forKey: providerKey)
+            } else {
+                contributions[providerKey] = providerDays
+            }
+        }
+
+        let parsedBytes: Int64
+        do {
+            parsedBytes = try CostUsageJsonl.scan(
+                fileURL: fileURL,
+                offset: startOffset,
+                maxLineBytes: Self.maxLineBytes,
+                prefixBytes: Self.maxLineBytes,
+                checkCancellation: checkCancellation,
+                onLine: { line in
+                    guard !line.bytes.isEmpty, !line.wasTruncated else { return }
+                    autoreleasepool {
+                        guard let object = (try? JSONSerialization.jsonObject(with: line.bytes)) as? [String: Any]
+                        else { return }
+                        guard let type = object["type"] as? String else { return }
+
+                        if type == "model_change" {
+                            currentModelContext = self.modelContext(from: object)
+                            return
+                        }
+
+                        guard type == "message", let message = object["message"] as? [String: Any] else { return }
+                        guard (message["role"] as? String) == "assistant" else { return }
+
+                        let identity = self.resolveAssistantIdentity(
+                            entry: object,
+                            message: message,
+                            fallback: currentModelContext)
+                        guard let identity else { return }
+                        guard let date = self.timestampDate(entry: object, message: message) else { return }
+                        let dayKey = CostUsageScanner.CostUsageDayRange.dayKey(from: date)
+                        let usage = self.extractUsage(
+                            provider: identity.provider,
+                            modelName: identity.modelName,
+                            message: message,
+                            pricingDate: date,
+                            pricingContext: pricingContext)
+                        add(provider: identity.provider, dayKey: dayKey, modelName: identity.modelName, usage: usage)
+                    }
+                })
+        } catch is CancellationError {
+            throw CancellationError()
+        } catch {
+            parsedBytes = startOffset
+        }
+
+        return ParseResult(
+            contributions: contributions,
+            parsedBytes: parsedBytes,
+            lastModelContext: currentModelContext)
+    }
+
+    private static func modelContext(from object: [String: Any]) -> PiModelContext? {
+        guard let providerText = object["provider"] as? String,
+              let provider = self.mappedProvider(fromPiProvider: providerText)
+        else {
+            return nil
+        }
+        let rawModelName = (object["modelId"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+        guard let modelName = self.normalizeModelName(rawModelName, provider: provider) else { return nil }
+        return PiModelContext(providerRawValue: provider.rawValue, modelName: modelName)
+    }
+
+    private static func resolveAssistantIdentity(
+        entry: [String: Any],
+        message: [String: Any],
+        fallback: PiModelContext?) -> AssistantIdentity?
+    {
+        let explicitProviderText = self.extractProviderText(entry: entry, message: message)
+        let explicitProvider = explicitProviderText.flatMap(self.mappedProvider(fromPiProvider:))
+        let explicitModelText = self.extractModelText(entry: entry, message: message)
+
+        if explicitProviderText != nil, explicitProvider == nil {
+            return nil
+        }
+
+        if let explicitProvider,
+           let explicitModelText,
+           let explicitModel = self.normalizeModelName(explicitModelText, provider: explicitProvider)
+        {
+            return AssistantIdentity(provider: explicitProvider, modelName: explicitModel)
+        }
+
+        if let explicitProvider,
+           let fallback,
+           fallback.providerRawValue == explicitProvider.rawValue
+        {
+            return AssistantIdentity(provider: explicitProvider, modelName: fallback.modelName)
+        }
+
+        if explicitProviderText == nil,
+           let explicitModelText,
+           let fallbackProvider = fallback.flatMap({ UsageProvider(rawValue: $0.providerRawValue) }),
+           let explicitModel = self.normalizeModelName(explicitModelText, provider: fallbackProvider)
+        {
+            return AssistantIdentity(provider: fallbackProvider, modelName: explicitModel)
+        }
+
+        if explicitProviderText == nil,
+           let fallback,
+           let provider = UsageProvider(rawValue: fallback.providerRawValue)
+        {
+            return AssistantIdentity(provider: provider, modelName: fallback.modelName)
+        }
+
+        return nil
+    }
+
+    private static func extractProviderText(entry: [String: Any], message: [String: Any]) -> String? {
+        if let provider = (message["provider"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines),
+           !provider.isEmpty
+        {
+            return provider
+        }
+        if let provider = (entry["provider"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines),
+           !provider.isEmpty
+        {
+            return provider
+        }
+        return nil
+    }
+
+    private static func extractModelText(entry: [String: Any], message: [String: Any]) -> String? {
+        for value in [message["model"], entry["model"], message["modelId"], entry["modelId"]] {
+            if let model = (value as? String)?.trimmingCharacters(in: .whitespacesAndNewlines), !model.isEmpty {
+                return model
+            }
+        }
+        return nil
+    }
+
+    private static func normalizeModelName(_ raw: String, provider: UsageProvider) -> String? {
+        let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else { return nil }
+        return switch provider {
+        case .codex:
+            CostUsagePricing.normalizeCodexModel(trimmed)
+        case .claude:
+            CostUsagePricing.normalizeClaudeModel(trimmed)
+        default:
+            trimmed
+        }
+    }
+
+    private static func timestampDate(entry: [String: Any], message: [String: Any]) -> Date? {
+        self.parseTimestampValue(message["timestamp"])
+            ?? self.parseTimestampValue(entry["timestamp"])
+    }
+
+    private static func parseTimestampValue(_ value: Any?) -> Date? {
+        if let number = value as? NSNumber {
+            let raw = number.doubleValue
+            guard raw.isFinite else { return nil }
+            if raw > 1_000_000_000_000 {
+                return Date(timeIntervalSince1970: raw / 1000)
+            }
+            return Date(timeIntervalSince1970: raw)
+        }
+
+        if let string = value as? String {
+            if let numeric = Double(string), numeric.isFinite {
+                if numeric > 1_000_000_000_000 {
+                    return Date(timeIntervalSince1970: numeric / 1000)
+                }
+                return Date(timeIntervalSince1970: numeric)
+            }
+            return self.parseISO(string)
+        }
+
+        return nil
+    }
+
+    private static func extractUsage(
+        provider: UsageProvider,
+        modelName: String,
+        message: [String: Any],
+        pricingDate: Date? = nil,
+        pricingContext: ModelsDevPricingContext? = nil) -> PiPackedUsage
+    {
+        let usage = (message["usage"] as? [String: Any]) ?? [:]
+        let input = self.readNonNegativeInt(
+            usage["input"]
+                ?? usage["inputTokens"]
+                ?? usage["input_tokens"]
+                ?? usage["promptTokens"]
+                ?? usage["prompt_tokens"])
+        let cacheRead = self.readNonNegativeInt(
+            usage["cacheRead"]
+                ?? usage["cacheReadTokens"]
+                ?? usage["cache_read"]
+                ?? usage["cache_read_tokens"]
+                ?? usage["cacheReadInputTokens"]
+                ?? usage["cache_read_input_tokens"])
+        let cacheWrite = self.readNonNegativeInt(
+            usage["cacheWrite"]
+                ?? usage["cacheWriteTokens"]
+                ?? usage["cache_write"]
+                ?? usage["cache_write_tokens"]
+                ?? usage["cacheCreationTokens"]
+                ?? usage["cache_creation_tokens"]
+                ?? usage["cacheCreationInputTokens"]
+                ?? usage["cache_creation_input_tokens"])
+        let output = self.readNonNegativeInt(
+            usage["output"]
+                ?? usage["outputTokens"]
+                ?? usage["output_tokens"]
+                ?? usage["completionTokens"]
+                ?? usage["completion_tokens"])
+
+        let directTotal = self.readNonNegativeInt(
+            usage["totalTokens"]
+                ?? usage["total_tokens"]
+                ?? usage["tokenCount"]
+                ?? usage["token_count"]
+                ?? usage["tokens"])
+        let derivedTotal = input + cacheRead + cacheWrite + output
+        let totalTokens = max(directTotal, derivedTotal)
+
+        let rawUsage = PiPackedUsage(
+            inputTokens: input,
+            cacheReadTokens: cacheRead,
+            cacheWriteTokens: cacheWrite,
+            outputTokens: output,
+            totalTokens: totalTokens)
+        // Pi JSONL does not record Anthropic cache retention, so use Pi's persisted default tariff.
+        let costUSD = self.computedCostUSD(
+            provider: provider,
+            modelName: modelName,
+            usage: rawUsage,
+            pricingDate: pricingDate,
+            pricingContext: pricingContext)
+        let costNanos = costUSD.map { Int64(($0 * self.costScale).rounded()) } ?? 0
+
+        return PiPackedUsage(
+            inputTokens: rawUsage.inputTokens,
+            cacheReadTokens: rawUsage.cacheReadTokens,
+            cacheWriteTokens: rawUsage.cacheWriteTokens,
+            outputTokens: rawUsage.outputTokens,
+            totalTokens: rawUsage.totalTokens,
+            costNanos: costNanos,
+            costSampleCount: costUSD == nil ? 0 : 1,
+            usageSampleCount: 1)
+    }
+
+    private static func computedCostUSD(
+        provider: UsageProvider,
+        modelName: String,
+        usage: PiPackedUsage,
+        pricingDate: Date? = nil,
+        pricingContext: ModelsDevPricingContext? = nil) -> Double?
+    {
+        switch provider {
+        case .codex:
+            CostUsagePricing.codexCostUSD(
+                model: modelName,
+                inputTokens: usage.inputTokens + usage.cacheReadTokens + usage.cacheWriteTokens,
+                cachedInputTokens: usage.cacheReadTokens,
+                outputTokens: usage.outputTokens,
+                modelsDevCatalog: pricingContext?.catalog,
+                modelsDevCacheRoot: pricingContext?.cacheRoot)
+        case .claude:
+            CostUsagePricing.claudeCostUSD(
+                model: modelName,
+                inputTokens: usage.inputTokens,
+                cacheReadInputTokens: usage.cacheReadTokens,
+                cacheCreationInputTokens: usage.cacheWriteTokens,
+                outputTokens: usage.outputTokens,
+                pricingDate: pricingDate,
+                modelsDevCatalog: pricingContext?.catalog,
+                modelsDevCacheRoot: pricingContext?.cacheRoot)
+        default:
+            nil
+        }
+    }
+
+    private static func readNonNegativeInt(_ value: Any?) -> Int {
+        if let number = value as? NSNumber {
+            let numeric = number.doubleValue
+            guard numeric.isFinite, numeric >= 0, numeric <= self.maxSafeRoundedInt else { return 0 }
+            return Int(numeric.rounded())
+        }
+        if let string = value as? String,
+           let numeric = Double(string),
+           numeric.isFinite,
+           numeric >= 0,
+           numeric <= self.maxSafeRoundedInt
+        {
+            return Int(numeric.rounded())
+        }
+        return 0
+    }
+}
+
+extension PiSessionCostScanner {
+    private static func mappedProvider(fromPiProvider provider: String) -> UsageProvider? {
+        switch provider.lowercased() {
+        case "openai-codex":
+            .codex
+        case "anthropic":
+            .claude
+        default:
+            nil
+        }
+    }
+
+    private static func buildReport(
+        provider: UsageProvider,
+        cache: PiSessionCostCache,
+        range: CostUsageScanner.CostUsageDayRange,
+        pricingContext: ModelsDevPricingContext? = nil) -> CostUsageDailyReport
+    {
+        guard let providerDays = cache.daysByProvider[provider.rawValue] else {
+            return CostUsageDailyReport(data: [], summary: nil)
+        }
+
+        let dayKeys = providerDays.keys.sorted().filter {
+            CostUsageScanner.CostUsageDayRange.isInRange(dayKey: $0, since: range.sinceKey, until: range.untilKey)
+        }
+
+        var entries: [CostUsageDailyReport.Entry] = []
+        var totalInput = 0
+        var totalOutput = 0
+        var totalCacheRead = 0
+        var totalCacheWrite = 0
+        var totalTokens = 0
+        var totalCostNanos: Int64 = 0
+        var totalCostSamples = 0
+
+        for dayKey in dayKeys {
+            guard let models = providerDays[dayKey] else { continue }
+            let modelNames = models.keys.sorted()
+
+            var dayInput = 0
+            var dayOutput = 0
+            var dayCacheRead = 0
+            var dayCacheWrite = 0
+            var dayTotalTokens = 0
+            var dayCostNanos: Int64 = 0
+            var dayCostSamples = 0
+            var breakdown: [CostUsageDailyReport.ModelBreakdown] = []
+
+            for modelName in modelNames {
+                let packed = models[modelName] ?? PiPackedUsage()
+                let modelTotalTokens = max(
+                    packed.totalTokens,
+                    packed.inputTokens + packed.cacheReadTokens + packed.cacheWriteTokens + packed.outputTokens)
+                let currentPricingCost = self.computedCostUSD(
+                    provider: provider,
+                    modelName: modelName,
+                    usage: packed,
+                    pricingContext: pricingContext)
+                let usageSampleCount = packed.usageSampleCount
+                let hasCompleteCachedCost = (usageSampleCount ?? 0) > 0
+                    && packed.costSampleCount == usageSampleCount
+                // Cached costs are accumulated per message, which preserves Claude long-context threshold boundaries.
+                let costNanos = hasCompleteCachedCost
+                    ? packed.costNanos
+                    : currentPricingCost.map { Int64(($0 * self.costScale).rounded()) }
+                breakdown.append(CostUsageDailyReport.ModelBreakdown(
+                    modelName: modelName,
+                    costUSD: costNanos.map { Double($0) / Self.costScale },
+                    totalTokens: modelTotalTokens > 0 ? modelTotalTokens : nil))
+                dayInput += packed.inputTokens
+                dayOutput += packed.outputTokens
+                dayCacheRead += packed.cacheReadTokens
+                dayCacheWrite += packed.cacheWriteTokens
+                dayTotalTokens += modelTotalTokens
+                if let costNanos {
+                    dayCostNanos += costNanos
+                    dayCostSamples += 1
+                }
+            }
+
+            let sortedBreakdown = self.sortedModelBreakdowns(breakdown)
+            entries.append(CostUsageDailyReport.Entry(
+                date: dayKey,
+                inputTokens: dayInput > 0 ? dayInput : nil,
+                outputTokens: dayOutput > 0 ? dayOutput : nil,
+                cacheReadTokens: dayCacheRead > 0 ? dayCacheRead : nil,
+                cacheCreationTokens: dayCacheWrite > 0 ? dayCacheWrite : nil,
+                totalTokens: dayTotalTokens > 0 ? dayTotalTokens : nil,
+                costUSD: dayCostSamples > 0 ? Double(dayCostNanos) / Self.costScale : nil,
+                modelsUsed: modelNames,
+                modelBreakdowns: sortedBreakdown))
+
+            totalInput += dayInput
+            totalOutput += dayOutput
+            totalCacheRead += dayCacheRead
+            totalCacheWrite += dayCacheWrite
+            totalTokens += dayTotalTokens
+            totalCostNanos += dayCostNanos
+            totalCostSamples += dayCostSamples
+        }
+
+        guard !entries.isEmpty else { return CostUsageDailyReport(data: [], summary: nil) }
+        return CostUsageDailyReport(
+            data: entries,
+            summary: CostUsageDailyReport.Summary(
+                totalInputTokens: totalInput > 0 ? totalInput : nil,
+                totalOutputTokens: totalOutput > 0 ? totalOutput : nil,
+                cacheReadTokens: totalCacheRead > 0 ? totalCacheRead : nil,
+                cacheCreationTokens: totalCacheWrite > 0 ? totalCacheWrite : nil,
+                totalTokens: totalTokens > 0 ? totalTokens : nil,
+                totalCostUSD: totalCostSamples > 0 ? Double(totalCostNanos) / Self.costScale : nil))
+    }
+
+    private static func mergedContributions(
+        existing: [String: [String: [String: PiPackedUsage]]],
+        delta: [String: [String: [String: PiPackedUsage]]]) -> [String: [String: [String: PiPackedUsage]]]
+    {
+        var merged = existing
+        self.applyContributions(daysByProvider: &merged, contributions: delta, sign: 1)
+        return merged
+    }
+
+    private static func applyContributions(
+        daysByProvider: inout [String: [String: [String: PiPackedUsage]]],
+        contributions: [String: [String: [String: PiPackedUsage]]],
+        sign: Int)
+    {
+        for (providerKey, providerDays) in contributions {
+            var mergedProviderDays = daysByProvider[providerKey] ?? [:]
+            for (dayKey, dayModels) in providerDays {
+                var mergedDayModels = mergedProviderDays[dayKey] ?? [:]
+                for (modelName, packed) in dayModels {
+                    let updated = self.addPacked(
+                        a: mergedDayModels[modelName] ?? PiPackedUsage(),
+                        b: packed,
+                        sign: sign)
+                    if updated.isZero {
+                        mergedDayModels.removeValue(forKey: modelName)
+                    } else {
+                        mergedDayModels[modelName] = updated
+                    }
+                }
+                if mergedDayModels.isEmpty {
+                    mergedProviderDays.removeValue(forKey: dayKey)
+                } else {
+                    mergedProviderDays[dayKey] = mergedDayModels
+                }
+            }
+            if mergedProviderDays.isEmpty {
+                daysByProvider.removeValue(forKey: providerKey)
+            } else {
+                daysByProvider[providerKey] = mergedProviderDays
+            }
+        }
+    }
+
+    private static func addPacked(a: PiPackedUsage, b: PiPackedUsage, sign: Int) -> PiPackedUsage {
+        let aUsageSampleCount = a.usageSampleCount ?? (a.isZero ? 0 : nil)
+        let bUsageSampleCount = b.usageSampleCount ?? (b.isZero ? 0 : nil)
+        let usageSampleCount: Int? = if let aCount = aUsageSampleCount, let bCount = bUsageSampleCount {
+            max(0, aCount + sign * bCount)
+        } else {
+            nil
+        }
+
+        return PiPackedUsage(
+            inputTokens: max(0, a.inputTokens + sign * b.inputTokens),
+            cacheReadTokens: max(0, a.cacheReadTokens + sign * b.cacheReadTokens),
+            cacheWriteTokens: max(0, a.cacheWriteTokens + sign * b.cacheWriteTokens),
+            outputTokens: max(0, a.outputTokens + sign * b.outputTokens),
+            totalTokens: max(0, a.totalTokens + sign * b.totalTokens),
+            costNanos: max(0, a.costNanos + Int64(sign) * b.costNanos),
+            costSampleCount: max(0, a.costSampleCount + sign * b.costSampleCount),
+            usageSampleCount: usageSampleCount)
+    }
+
+    private static func parseSessionStartFromFilename(_ filename: String) -> Date? {
+        guard let regex = self.sessionStartFilenameRegex else { return nil }
+        let range = NSRange(filename.startIndex..<filename.endIndex, in: filename)
+        guard let match = regex.firstMatch(in: filename, range: range) else { return nil }
+        guard (1...5).allSatisfy({ Range(match.range(at: $0), in: filename) != nil }) else { return nil }
+        let date = String(filename[Range(match.range(at: 1), in: filename)!])
+        let hour = String(filename[Range(match.range(at: 2), in: filename)!])
+        let minute = String(filename[Range(match.range(at: 3), in: filename)!])
+        let second = String(filename[Range(match.range(at: 4), in: filename)!])
+        let millis = String(filename[Range(match.range(at: 5), in: filename)!])
+        return self.parseISO("\(date)T\(hour):\(minute):\(second).\(millis)Z")
+    }
+
+    private static func parseISO(_ text: String) -> Date? {
+        self.isoFormatterBox.lock.lock()
+        defer { self.isoFormatterBox.lock.unlock() }
+        return self.isoFormatterBox.withFractional.date(from: text)
+            ?? self.isoFormatterBox.plain.date(from: text)
+    }
+
+    private static func localMidnight(_ date: Date) -> Date {
+        let components = Calendar.current.dateComponents([.year, .month, .day], from: date)
+        return Calendar.current.date(from: components) ?? date
+    }
+
+    private static func dateFromDayKey(_ key: String) -> Date? {
+        let parts = key.split(separator: "-")
+        guard parts.count == 3,
+              let year = Int(parts[0]),
+              let month = Int(parts[1]),
+              let day = Int(parts[2]) else { return nil }
+
+        var components = DateComponents()
+        components.calendar = Calendar.current
+        components.timeZone = TimeZone.current
+        components.year = year
+        components.month = month
+        components.day = day
+        components.hour = 0
+        return components.date
+    }
+
+    private static func sortedModelBreakdowns(_ breakdowns: [CostUsageDailyReport.ModelBreakdown])
+        -> [CostUsageDailyReport.ModelBreakdown]
+    {
+        breakdowns.sorted { lhs, rhs in
+            let lhsCost = lhs.costUSD ?? -1
+            let rhsCost = rhs.costUSD ?? -1
+            if lhsCost != rhsCost {
+                return lhsCost > rhsCost
+            }
+
+            let lhsTokens = lhs.totalTokens ?? -1
+            let rhsTokens = rhs.totalTokens ?? -1
+            if lhsTokens != rhsTokens {
+                return lhsTokens > rhsTokens
+            }
+
+            return lhs.modelName > rhs.modelName
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/ProviderCostSnapshot.swift b/Sources/CodexBarCore/ProviderCostSnapshot.swift
index c3d25af493..5d838d5932 100644
--- a/Sources/CodexBarCore/ProviderCostSnapshot.swift
+++ b/Sources/CodexBarCore/ProviderCostSnapshot.swift
@@ -9,6 +9,11 @@ public struct ProviderCostSnapshot: Equatable, Codable, Sendable {
     public let period: String?
     /// Optional renewal/reset timestamp for the period.
     public let resetsAt: Date?
+    /// Optional amount restored on the next regeneration tick for providers with rolling credit recovery.
+    public let nextRegenAmount: Double?
+    /// This account's own contribution when `used`/`limit` describe a shared/pooled budget
+    /// (e.g. Cursor team on-demand pool). nil when the budget is already personal.
+    public let personalUsed: Double?
     public let updatedAt: Date
 
     public init(
@@ -17,6 +22,8 @@ public struct ProviderCostSnapshot: Equatable, Codable, Sendable {
         currencyCode: String,
         period: String? = nil,
         resetsAt: Date? = nil,
+        nextRegenAmount: Double? = nil,
+        personalUsed: Double? = nil,
         updatedAt: Date)
     {
         self.used = used
@@ -24,6 +31,8 @@ public struct ProviderCostSnapshot: Equatable, Codable, Sendable {
         self.currencyCode = currencyCode
         self.period = period
         self.resetsAt = resetsAt
+        self.nextRegenAmount = nextRegenAmount
+        self.personalUsed = personalUsed
         self.updatedAt = updatedAt
     }
 }
diff --git a/Sources/CodexBarCore/ProviderEndpointOverrideValidator.swift b/Sources/CodexBarCore/ProviderEndpointOverrideValidator.swift
new file mode 100644
index 0000000000..6b4ee4a68d
--- /dev/null
+++ b/Sources/CodexBarCore/ProviderEndpointOverrideValidator.swift
@@ -0,0 +1,170 @@
+import Foundation
+
+enum ProviderEndpointOverrideError: LocalizedError, Equatable {
+    case minimax(String)
+    case alibabaCodingPlan(String)
+
+    var errorDescription: String? {
+        switch self {
+        case let .minimax(key):
+            "MiniMax endpoint override \(key) is not allowed. " +
+                "Use an HTTPS endpoint without user info or encoded host tricks. " +
+                "If MINIMAX_REQUIRE_PROVIDER_ENDPOINT_OVERRIDES=true is set, the endpoint must also be MiniMax-owned."
+        case let .alibabaCodingPlan(key):
+            "Alibaba Coding Plan endpoint override \(key) is not allowed. " +
+                "Use an HTTPS endpoint without user info or encoded host tricks. " +
+                "If ALIBABA_CODING_PLAN_REQUIRE_PROVIDER_ENDPOINT_OVERRIDES=true is set, " +
+                "the endpoint must also be Alibaba-owned."
+        }
+    }
+}
+
+struct ProviderEndpointOverrideValidator {
+    enum HostPolicy {
+        case allowAnyHTTPSHost
+        case providerOwnedOnly
+    }
+
+    private let allowedHosts: Set<String>
+    private let allowedDomainSuffixes: Set<String>
+
+    init(allowedHosts: [String] = [], allowedDomainSuffixes: [String] = []) {
+        self.allowedHosts = Set(allowedHosts.map { $0.lowercased() })
+        self.allowedDomainSuffixes = Set(allowedDomainSuffixes.map { $0.lowercased() })
+    }
+
+    func validatedHost(_ raw: String?, policy: HostPolicy = .allowAnyHTTPSHost) -> String? {
+        guard let raw,
+              let url = self.url(from: raw),
+              let host = self.validatedDecodedHost(for: url, policy: policy)
+        else { return nil }
+        return self.hostAuthority(host: host, port: url.port)
+    }
+
+    func validatedURL(_ raw: String?, policy: HostPolicy = .allowAnyHTTPSHost) -> URL? {
+        guard let raw,
+              let url = self.url(from: raw),
+              self.validatedDecodedHost(for: url, policy: policy) != nil
+        else { return nil }
+        return url
+    }
+
+    func validatedURLAllowingLoopbackHTTP(_ raw: String?) -> URL? {
+        guard let raw,
+              Self.hasExplicitURLScheme(raw),
+              let url = URL(string: raw),
+              let scheme = url.scheme?.lowercased(),
+              scheme == "https" || scheme == "http",
+              url.user == nil,
+              url.password == nil,
+              let host = self.validatedDecodedHost(for: url, policy: .allowAnyHTTPSHost),
+              scheme == "https" || Self.isLoopbackHost(host)
+        else { return nil }
+        return url
+    }
+
+    static func normalizedHTTPSURL(from raw: String) -> URL? {
+        let url = if Self.hasExplicitURLScheme(raw) {
+            URL(string: raw)
+        } else {
+            URL(string: "https://\(raw)")
+        }
+        guard let url else { return nil }
+        guard let scheme = url.scheme?.lowercased(), scheme == "https" else { return nil }
+        guard url.user == nil, url.password == nil else { return nil }
+        guard let decodedHost = url.host(percentEncoded: false)?.lowercased(),
+              !decodedHost.isEmpty,
+              !decodedHost.contains("%"),
+              decodedHost.rangeOfCharacter(from: .whitespacesAndNewlines) == nil,
+              decodedHost.rangeOfCharacter(from: .controlCharacters) == nil,
+              let encodedHost = url.host(percentEncoded: true)?.lowercased(),
+              Self.hostHasNoEncodedDelimiters(encodedHost, decodedHost: decodedHost, url: url)
+        else { return nil }
+        return url
+    }
+
+    private func url(from raw: String) -> URL? {
+        Self.normalizedHTTPSURL(from: raw)
+    }
+
+    private static func hasExplicitURLScheme(_ raw: String) -> Bool {
+        guard let colonIndex = raw.firstIndex(of: ":") else { return false }
+        if raw[colonIndex...].hasPrefix("://") { return true }
+
+        if let authorityEnd = raw.firstIndex(where: { ["/", "?", "#"].contains($0) }),
+           colonIndex > authorityEnd
+        {
+            return false
+        }
+
+        let afterColon = raw.index(after: colonIndex)
+        guard afterColon < raw.endIndex else { return true }
+        let portEnd = raw[afterColon...].firstIndex { Set<Character>(["/", "?", "#"]).contains($0) } ?? raw.endIndex
+        let suffix = raw[afterColon..<portEnd]
+        if !suffix.isEmpty, suffix.allSatisfy(\.isNumber) {
+            return false
+        }
+
+        let scheme = raw[..<colonIndex]
+        guard let first = scheme.first, first.isLetter else { return false }
+        return scheme.dropFirst().allSatisfy { $0.isLetter || $0.isNumber || ["+", "-", "."].contains($0) }
+    }
+
+    private static func isLoopbackHost(_ host: String) -> Bool {
+        if host == "localhost" || host == "::1" { return true }
+        let octets = host.split(separator: ".", omittingEmptySubsequences: false)
+        guard octets.count == 4,
+              let first = UInt8(octets[0]),
+              octets.dropFirst().allSatisfy({ UInt8($0) != nil })
+        else { return false }
+        return first == 127
+    }
+
+    private func hostAuthority(host: String, port: Int?) -> String {
+        let authorityHost = host.contains(":") ? "[\(host)]" : host
+        guard let port else { return authorityHost }
+        return "\(authorityHost):\(port)"
+    }
+
+    private func validatedDecodedHost(for url: URL, policy: HostPolicy) -> String? {
+        guard let decodedHost = url.host(percentEncoded: false)?.lowercased(),
+              !decodedHost.isEmpty,
+              !decodedHost.contains("%"),
+              decodedHost.rangeOfCharacter(from: .whitespacesAndNewlines) == nil,
+              decodedHost.rangeOfCharacter(from: .controlCharacters) == nil,
+              let encodedHost = url.host(percentEncoded: true)?.lowercased(),
+              Self.hostHasNoEncodedDelimiters(encodedHost, decodedHost: decodedHost, url: url)
+        else { return nil }
+
+        switch policy {
+        case .allowAnyHTTPSHost:
+            return decodedHost
+        case .providerOwnedOnly:
+            let isAllowedHost = self.allowedHosts.contains(decodedHost)
+            let isAllowedSuffix = self.allowedDomainSuffixes.contains { suffix in
+                decodedHost == suffix || decodedHost.hasSuffix(".\(suffix)")
+            }
+            guard isAllowedHost || isAllowedSuffix else { return nil }
+            return decodedHost
+        }
+    }
+
+    private static func hostHasNoEncodedDelimiters(_ encodedHost: String, decodedHost: String, url: URL) -> Bool {
+        if decodedHost.contains(":") {
+            guard encodedHost == decodedHost,
+                  let componentHost = URLComponents(url: url, resolvingAgainstBaseURL: false)?.host,
+                  componentHost.hasPrefix("["),
+                  componentHost.hasSuffix("]")
+            else { return false }
+
+            let address = componentHost.dropFirst().dropLast()
+            return !address.isEmpty && address.allSatisfy { $0.isHexDigit || $0 == ":" || $0 == "." }
+        }
+
+        let decodedDelimiters = CharacterSet(charactersIn: "/\\?#@:")
+        guard decodedHost.rangeOfCharacter(from: decodedDelimiters) == nil else { return false }
+
+        let encodedDelimiters = ["%2f", "%5c", "%3f", "%23", "%40", "%3a"]
+        return !encodedDelimiters.contains { encodedHost.contains($0) }
+    }
+}
diff --git a/Sources/CodexBarCore/ProviderHTTPClient.swift b/Sources/CodexBarCore/ProviderHTTPClient.swift
new file mode 100644
index 0000000000..68b8b383ee
--- /dev/null
+++ b/Sources/CodexBarCore/ProviderHTTPClient.swift
@@ -0,0 +1,253 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public protocol ProviderHTTPTransport: Sendable {
+    func data(for request: URLRequest) async throws -> (Data, URLResponse)
+}
+
+#if !os(Linux)
+extension URLSession: ProviderHTTPTransport {}
+#endif
+
+extension URLSession {
+    public func response(for request: URLRequest) async throws -> ProviderHTTPResponse {
+        let (data, response) = try await self.data(for: request)
+        guard let httpResponse = response as? HTTPURLResponse else {
+            throw URLError(.badServerResponse)
+        }
+        return ProviderHTTPResponse(data: data, response: httpResponse)
+    }
+}
+
+public struct ProviderHTTPResponse: Sendable {
+    public let data: Data
+    public let response: HTTPURLResponse
+
+    public init(data: Data, response: HTTPURLResponse) {
+        self.data = data
+        self.response = response
+    }
+
+    public var statusCode: Int {
+        self.response.statusCode
+    }
+}
+
+public struct ProviderHTTPRetryPolicy: Sendable {
+    public let maxRetries: Int
+    public let retryableStatusCodes: Set<Int>
+    public let retryableURLErrorCodes: Set<URLError.Code>
+    public let retryableMethods: Set<String>
+    public let baseDelaySeconds: TimeInterval
+    public let maxDelaySeconds: TimeInterval
+
+    public init(
+        maxRetries: Int,
+        retryableStatusCodes: Set<Int> = [408, 429, 500, 502, 503, 504],
+        retryableURLErrorCodes: Set<URLError.Code> = [
+            .timedOut,
+            .networkConnectionLost,
+            .cannotConnectToHost,
+            .cannotFindHost,
+            .dnsLookupFailed,
+        ],
+        retryableMethods: Set<String> = ["GET", "HEAD", "OPTIONS"],
+        baseDelaySeconds: TimeInterval = 1,
+        maxDelaySeconds: TimeInterval = 10)
+    {
+        self.maxRetries = max(0, maxRetries)
+        self.retryableStatusCodes = retryableStatusCodes
+        self.retryableURLErrorCodes = retryableURLErrorCodes
+        self.retryableMethods = retryableMethods
+        self.baseDelaySeconds = max(0, baseDelaySeconds)
+        self.maxDelaySeconds = max(0, maxDelaySeconds)
+    }
+
+    public static let disabled = ProviderHTTPRetryPolicy(
+        maxRetries: 0,
+        retryableStatusCodes: [],
+        retryableURLErrorCodes: [],
+        baseDelaySeconds: 0,
+        maxDelaySeconds: 0)
+
+    public static let transientIdempotent = ProviderHTTPRetryPolicy(maxRetries: 1)
+
+    func shouldRetry(request: URLRequest, attempt: Int, statusCode: Int) -> Bool {
+        self.canRetry(request: request, attempt: attempt)
+            && self.retryableStatusCodes.contains(statusCode)
+    }
+
+    func shouldRetry(request: URLRequest, attempt: Int, error: Error) -> Bool {
+        guard self.canRetry(request: request, attempt: attempt) else { return false }
+        guard let urlError = error as? URLError else { return false }
+        return self.retryableURLErrorCodes.contains(urlError.code)
+    }
+
+    func delaySeconds(attempt: Int, response: HTTPURLResponse?) -> TimeInterval {
+        if let retryAfter = response?.value(forHTTPHeaderField: "Retry-After"),
+           let seconds = TimeInterval(retryAfter.trimmingCharacters(in: .whitespacesAndNewlines)),
+           seconds >= 0
+        {
+            return min(seconds, self.maxDelaySeconds)
+        }
+
+        guard self.baseDelaySeconds > 0 else { return 0 }
+        let multiplier = pow(2, Double(max(0, attempt)))
+        return min(self.baseDelaySeconds * multiplier, self.maxDelaySeconds)
+    }
+
+    private func canRetry(request: URLRequest, attempt: Int) -> Bool {
+        guard attempt < self.maxRetries else { return false }
+        let method = request.httpMethod?.uppercased() ?? "GET"
+        return self.retryableMethods.contains(method)
+    }
+}
+
+public struct ProviderHTTPTransportHandler: ProviderHTTPTransport {
+    private let handler: @Sendable (URLRequest) async throws -> (Data, URLResponse)
+
+    public init(_ handler: @escaping @Sendable (URLRequest) async throws -> (Data, URLResponse)) {
+        self.handler = handler
+    }
+
+    public func data(for request: URLRequest) async throws -> (Data, URLResponse) {
+        try await self.handler(request)
+    }
+}
+
+extension ProviderHTTPTransport {
+    public func response(for request: URLRequest) async throws -> ProviderHTTPResponse {
+        try await self.response(for: request, retryPolicy: .disabled)
+    }
+
+    public func response(
+        for request: URLRequest,
+        retryPolicy: ProviderHTTPRetryPolicy) async throws -> ProviderHTTPResponse
+    {
+        var attempt = 0
+
+        while true {
+            do {
+                let (data, response) = try await self.data(for: request)
+                guard let httpResponse = response as? HTTPURLResponse else {
+                    throw URLError(.badServerResponse)
+                }
+                let providerResponse = ProviderHTTPResponse(data: data, response: httpResponse)
+                guard retryPolicy.shouldRetry(
+                    request: request,
+                    attempt: attempt,
+                    statusCode: providerResponse.statusCode)
+                else {
+                    return providerResponse
+                }
+                try await Self.sleepBeforeRetry(policy: retryPolicy, attempt: attempt, response: httpResponse)
+                attempt += 1
+            } catch {
+                guard retryPolicy.shouldRetry(request: request, attempt: attempt, error: error) else {
+                    throw error
+                }
+                try await Self.sleepBeforeRetry(policy: retryPolicy, attempt: attempt, response: nil)
+                attempt += 1
+            }
+        }
+    }
+
+    private static func sleepBeforeRetry(
+        policy: ProviderHTTPRetryPolicy,
+        attempt: Int,
+        response: HTTPURLResponse?) async throws
+    {
+        let delay = policy.delaySeconds(attempt: attempt, response: response)
+        guard delay > 0 else { return }
+        try await Task.sleep(nanoseconds: UInt64(delay * 1_000_000_000))
+    }
+}
+
+public final class ProviderHTTPClient: ProviderHTTPTransport, @unchecked Sendable {
+    public static let shared = ProviderHTTPClient(session: ProviderHTTPClient.sharedSession())
+
+    private let session: URLSession
+
+    public init(session: URLSession? = nil) {
+        self.session = session ?? Self.redirectGuardedSession()
+    }
+
+    static func defaultConfiguration() -> URLSessionConfiguration {
+        let configuration = URLSessionConfiguration.default
+        configuration.timeoutIntervalForRequest = 30
+        configuration.timeoutIntervalForResource = 90
+        #if !os(Linux)
+        configuration.waitsForConnectivity = false
+        #endif
+        return configuration
+    }
+
+    private static func sharedSession() -> URLSession {
+        if self.isRunningTests {
+            // XCTest URLProtocol.registerClass stubs only intercept URLSession.shared on macOS.
+            return .shared
+        }
+        return self.redirectGuardedSession()
+    }
+
+    static func redirectGuardedSession(
+        configuration: URLSessionConfiguration = ProviderHTTPClient.defaultConfiguration()) -> URLSession
+    {
+        URLSession(
+            configuration: configuration,
+            delegate: ProviderHTTPRedirectGuardDelegate(),
+            delegateQueue: nil)
+    }
+
+    private static var isRunningTests: Bool {
+        let environment = ProcessInfo.processInfo.environment
+        if environment["XCTestConfigurationFilePath"] != nil || environment["XCTestBundlePath"] != nil {
+            return true
+        }
+        if ProcessInfo.processInfo.processName.lowercased().contains("xctest") {
+            return true
+        }
+        return CommandLine.arguments.contains { $0.lowercased().contains(".xctest") }
+    }
+
+    public func data(for request: URLRequest) async throws -> (Data, URLResponse) {
+        try await self.session.data(for: request)
+    }
+}
+
+final class ProviderHTTPRedirectGuardDelegate: NSObject, URLSessionTaskDelegate, @unchecked Sendable {
+    func urlSession(
+        _: URLSession,
+        task: URLSessionTask,
+        willPerformHTTPRedirection _: HTTPURLResponse,
+        newRequest request: URLRequest,
+        completionHandler: @escaping @Sendable (URLRequest?) -> Void)
+    {
+        completionHandler(Self.guardedRedirectRequest(originalURL: task.originalRequest?.url, redirectRequest: request))
+    }
+
+    static func guardedRedirectRequest(originalURL: URL?, redirectRequest request: URLRequest) -> URLRequest? {
+        guard let originalURL, let redirectedURL = request.url else { return nil }
+        guard originalURL.scheme?.caseInsensitiveCompare("https") == .orderedSame else { return nil }
+        guard redirectedURL.scheme?.caseInsensitiveCompare("https") == .orderedSame else { return nil }
+        guard self.isSameOrigin(originalURL, redirectedURL) else { return nil }
+        return request
+    }
+
+    private static func isSameOrigin(_ lhs: URL, _ rhs: URL) -> Bool {
+        lhs.scheme?.lowercased() == rhs.scheme?.lowercased()
+            && lhs.host?.lowercased() == rhs.host?.lowercased()
+            && self.normalizedPort(lhs) == self.normalizedPort(rhs)
+    }
+
+    private static func normalizedPort(_ url: URL) -> Int? {
+        if let port = url.port { return port }
+        switch url.scheme?.lowercased() {
+        case "http": return 80
+        case "https": return 443
+        default: return nil
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/ProviderStorageFootprint.swift b/Sources/CodexBarCore/ProviderStorageFootprint.swift
new file mode 100644
index 0000000000..75feb7a366
--- /dev/null
+++ b/Sources/CodexBarCore/ProviderStorageFootprint.swift
@@ -0,0 +1,543 @@
+import Foundation
+
+public struct ProviderStorageFootprint: Sendable, Equatable {
+    public struct Component: Sendable, Equatable, Identifiable {
+        public let id: String
+        public let path: String
+        public let totalBytes: Int64
+
+        public init(path: String, totalBytes: Int64) {
+            self.id = path
+            self.path = path
+            self.totalBytes = totalBytes
+        }
+
+        public var name: String {
+            let url = URL(fileURLWithPath: self.path)
+            let last = url.lastPathComponent
+            if last.isEmpty { return self.path }
+            return last
+        }
+    }
+
+    public let provider: UsageProvider
+    public let totalBytes: Int64
+    public let paths: [String]
+    public let missingPaths: [String]
+    public let unreadablePaths: [String]
+    public let components: [Component]
+    public let updatedAt: Date
+
+    public init(
+        provider: UsageProvider,
+        totalBytes: Int64,
+        paths: [String],
+        missingPaths: [String],
+        unreadablePaths: [String],
+        components: [Component] = [],
+        updatedAt: Date)
+    {
+        self.provider = provider
+        self.totalBytes = totalBytes
+        self.paths = paths
+        self.missingPaths = missingPaths
+        self.unreadablePaths = unreadablePaths
+        self.components = components
+        self.updatedAt = updatedAt
+    }
+
+    public var hasLocalData: Bool {
+        self.totalBytes > 0
+    }
+
+    /// Value equality that ignores `updatedAt`. Two scans of identical on-disk data differ only by
+    /// their scan timestamp, so callers use this to avoid re-publishing observable state (and the
+    /// menu-invalidation churn that follows) when nothing the user sees has actually changed.
+    public func hasSameContents(as other: ProviderStorageFootprint) -> Bool {
+        self.provider == other.provider &&
+            self.totalBytes == other.totalBytes &&
+            self.paths == other.paths &&
+            self.missingPaths == other.missingPaths &&
+            self.unreadablePaths == other.unreadablePaths &&
+            self.components == other.components
+    }
+
+    public var cleanupRecommendations: [ProviderStorageRecommendation] {
+        ProviderStorageRecommendation.recommendations(for: self)
+    }
+
+    public func replacingProvider(_ provider: UsageProvider) -> ProviderStorageFootprint {
+        ProviderStorageFootprint(
+            provider: provider,
+            totalBytes: self.totalBytes,
+            paths: self.paths,
+            missingPaths: self.missingPaths,
+            unreadablePaths: self.unreadablePaths,
+            components: self.components,
+            updatedAt: self.updatedAt)
+    }
+}
+
+public struct ProviderStorageRecommendation: Sendable, Equatable, Identifiable {
+    public enum RiskLevel: String, Sendable {
+        case informational
+        case manualCleanup
+    }
+
+    public let id: String
+    public let provider: UsageProvider
+    public let path: String
+    public let bytes: Int64
+    public let title: String
+    public let riskLevel: RiskLevel
+    public let consequence: String
+    public let sortPriority: Int
+
+    public init(
+        provider: UsageProvider,
+        path: String,
+        bytes: Int64,
+        title: String,
+        riskLevel: RiskLevel,
+        consequence: String,
+        sortPriority: Int)
+    {
+        self.id = path
+        self.provider = provider
+        self.path = path
+        self.bytes = bytes
+        self.title = title
+        self.riskLevel = riskLevel
+        self.consequence = consequence
+        self.sortPriority = sortPriority
+    }
+
+    public static func recommendations(for footprint: ProviderStorageFootprint) -> [ProviderStorageRecommendation] {
+        let candidates: [ProviderStorageRecommendation] = footprint.components.compactMap { component in
+            switch footprint.provider {
+            case .claude:
+                self.claudeRecommendation(for: component)
+            case .codex:
+                self.codexRecommendation(for: component, roots: footprint.paths)
+            default:
+                nil
+            }
+        }
+
+        return candidates.sorted { lhs, rhs in
+            if lhs.sortPriority == rhs.sortPriority {
+                if lhs.bytes == rhs.bytes {
+                    return lhs.path.localizedCaseInsensitiveCompare(rhs.path) == .orderedAscending
+                }
+                return lhs.bytes > rhs.bytes
+            }
+            return lhs.sortPriority < rhs.sortPriority
+        }
+    }
+
+    private static func claudeRecommendation(
+        for component: ProviderStorageFootprint.Component)
+        -> ProviderStorageRecommendation?
+    {
+        switch component.name {
+        case "projects":
+            self.make(
+                provider: .claude,
+                component: component,
+                title: "Manual cleanup: past sessions",
+                consequence: "Clearing removes past resume, continue, and rewind history.",
+                priority: 10)
+        case "file-history":
+            self.make(
+                provider: .claude,
+                component: component,
+                title: "Manual cleanup: file checkpoints",
+                consequence: "Clearing removes checkpoint restore data for previous edits.",
+                priority: 20)
+        case "plans":
+            self.make(
+                provider: .claude,
+                component: component,
+                title: "Manual cleanup: saved plans",
+                consequence: "Clearing removes old plan-mode files.",
+                priority: 30)
+        case "debug":
+            self.make(
+                provider: .claude,
+                component: component,
+                title: "Manual cleanup: debug logs",
+                consequence: "Clearing removes past debug logs.",
+                priority: 40)
+        case "paste-cache", "image-cache":
+            self.make(
+                provider: .claude,
+                component: component,
+                title: "Manual cleanup: attachment cache",
+                consequence: "Clearing removes cached large pastes or attached images.",
+                priority: 50)
+        case "session-env":
+            self.make(
+                provider: .claude,
+                component: component,
+                title: "Manual cleanup: session metadata",
+                consequence: "Clearing removes per-session environment metadata.",
+                priority: 60)
+        case "shell-snapshots":
+            self.make(
+                provider: .claude,
+                component: component,
+                title: "Manual cleanup: shell snapshots",
+                consequence: "Clearing removes leftover runtime shell snapshot files.",
+                priority: 70)
+        case "todos":
+            self.make(
+                provider: .claude,
+                component: component,
+                title: "Manual cleanup: legacy todos",
+                consequence: "Clearing removes legacy per-session task lists.",
+                priority: 80)
+        default:
+            nil
+        }
+    }
+
+    private static func codexRecommendation(
+        for component: ProviderStorageFootprint.Component,
+        roots: [String])
+        -> ProviderStorageRecommendation?
+    {
+        guard self.path(component.path, isContainedIn: roots) else { return nil }
+
+        return switch component.name {
+        case "sessions":
+            self.make(
+                provider: .codex,
+                component: component,
+                title: "Manual cleanup: sessions",
+                consequence: "Clearing removes past Codex session history.",
+                priority: 10)
+        case "archived_sessions":
+            self.make(
+                provider: .codex,
+                component: component,
+                title: "Manual cleanup: archived sessions",
+                consequence: "Clearing removes archived Codex session history.",
+                priority: 20)
+        case "cache", "caches", "Cache", "Caches":
+            self.make(
+                provider: .codex,
+                component: component,
+                title: "Manual cleanup: cache",
+                consequence: "Clearing removes provider-owned cached data.",
+                priority: 30)
+        case "log", "logs", "debug":
+            self.make(
+                provider: .codex,
+                component: component,
+                title: "Manual cleanup: logs",
+                consequence: "Clearing removes local diagnostic logs.",
+                priority: 40)
+        case let name where name.hasPrefix("logs_") && name.hasSuffix(".sqlite"):
+            self.make(
+                provider: .codex,
+                component: component,
+                title: "Manual cleanup: logs",
+                consequence: "Clearing removes local diagnostic logs.",
+                priority: 40)
+        case "file-history":
+            self.make(
+                provider: .codex,
+                component: component,
+                title: "Manual cleanup: file history",
+                consequence: "Clearing removes local edit checkpoint history.",
+                priority: 50)
+        case "paste-cache", "image-cache", "session-env", "shell-snapshots", "shell_snapshots", "tmp", "temp", ".tmp":
+            self.make(
+                provider: .codex,
+                component: component,
+                title: "Manual cleanup: temporary data",
+                consequence: "Clearing removes local temporary provider data.",
+                priority: 60)
+        default:
+            nil
+        }
+    }
+
+    private static func make(
+        provider: UsageProvider,
+        component: ProviderStorageFootprint.Component,
+        title: String,
+        consequence: String,
+        priority: Int)
+        -> ProviderStorageRecommendation
+    {
+        ProviderStorageRecommendation(
+            provider: provider,
+            path: component.path,
+            bytes: component.totalBytes,
+            title: title,
+            riskLevel: .manualCleanup,
+            consequence: consequence,
+            sortPriority: priority)
+    }
+
+    private static func path(_ path: String, isContainedIn roots: [String]) -> Bool {
+        let standardizedPath = URL(fileURLWithPath: path).standardizedFileURL.path
+        return roots.contains { root in
+            let standardizedRoot = URL(fileURLWithPath: root, isDirectory: true).standardizedFileURL.path
+            return standardizedPath == standardizedRoot || standardizedPath.hasPrefix(standardizedRoot + "/")
+        }
+    }
+}
+
+public enum ProviderStoragePathCatalog {
+    public static func candidatePaths(
+        for provider: UsageProvider,
+        environment: [String: String],
+        managedCodexAccounts: [ManagedCodexAccount] = [],
+        fileManager: FileManager = .default)
+        -> [String]
+    {
+        let home = fileManager.homeDirectoryForCurrentUser
+
+        func homePath(_ relativePath: String) -> String {
+            home.appendingPathComponent(relativePath, isDirectory: true).path
+        }
+
+        let candidates: [String] = switch provider {
+        case .codex:
+            [CodexHomeScope.ambientHomeURL(env: environment, fileManager: fileManager).path] +
+                managedCodexAccounts.map(\.managedHomePath)
+        case .claude:
+            [
+                homePath(".claude"),
+                homePath(".config/claude"),
+                home
+                    .appendingPathComponent("Library/Application Support/CodexBar/ClaudeProbe", isDirectory: true)
+                    .path,
+            ]
+        case .gemini:
+            [
+                homePath(".gemini"),
+                homePath(".config/gemini"),
+            ]
+        case .opencode, .opencodego:
+            [
+                homePath(".config/opencode"),
+            ]
+        case .copilot:
+            [
+                homePath(".config/github-copilot"),
+            ]
+        case .cursor:
+            [
+                homePath("Library/Application Support/Cursor"),
+                homePath("Library/Application Support/Caches/cursor-updater"),
+                homePath(".cursor"),
+                homePath("Library/Caches/Cursor"),
+                homePath("Library/Caches/com.todesktop.230313mzl4w4u92"),
+                homePath("Library/Caches/com.todesktop.230313mzl4w4u92.ShipIt"),
+                homePath("Library/Caches/cursor-compile-cache"),
+                homePath("Library/HTTPStorages/com.todesktop.230313mzl4w4u92"),
+            ]
+        default:
+            []
+        }
+
+        return Self.uniqueStandardizedPaths(candidates)
+    }
+
+    private static func uniqueStandardizedPaths(_ paths: [String]) -> [String] {
+        var seen: Set<String> = []
+        var result: [String] = []
+        for path in paths {
+            let trimmed = path.trimmingCharacters(in: .whitespacesAndNewlines)
+            guard !trimmed.isEmpty else { continue }
+            let standardized = URL(fileURLWithPath: trimmed, isDirectory: true).standardizedFileURL.path
+            guard seen.insert(standardized).inserted else { continue }
+            result.append(standardized)
+        }
+        return result
+    }
+}
+
+public struct ProviderStorageScanner: @unchecked Sendable {
+    private struct DirectoryScanResult {
+        var bytes: Int64 = 0
+        var unreadablePaths: [String] = []
+        var componentBytes: [String: Int64] = [:]
+    }
+
+    private let fileManager: FileManager
+
+    public init(fileManager: FileManager = .default) {
+        self.fileManager = fileManager
+    }
+
+    public func scan(
+        provider: UsageProvider,
+        candidatePaths: [String],
+        now: Date = Date())
+        -> ProviderStorageFootprint
+    {
+        var totalBytes: Int64 = 0
+        var existingPaths: [String] = []
+        var missingPaths: [String] = []
+        var unreadablePaths: [String] = []
+        var components: [ProviderStorageFootprint.Component] = []
+
+        for path in candidatePaths {
+            if Task.isCancelled { break }
+            var isDirectory: ObjCBool = false
+            guard self.fileManager.fileExists(atPath: path, isDirectory: &isDirectory) else {
+                missingPaths.append(path)
+                continue
+            }
+
+            existingPaths.append(path)
+            let url = URL(fileURLWithPath: path, isDirectory: isDirectory.boolValue)
+            if self.isSymbolicLink(at: url) {
+                continue
+            }
+            if isDirectory.boolValue {
+                let result = self.scanDirectory(at: url)
+                if Task.isCancelled { break }
+                totalBytes += result.bytes
+                unreadablePaths.append(contentsOf: result.unreadablePaths)
+                components.append(contentsOf: result.componentBytes.map {
+                    ProviderStorageFootprint.Component(path: $0.key, totalBytes: $0.value)
+                })
+            } else {
+                let result = self.sizeOfFile(at: url)
+                totalBytes += result.bytes
+                unreadablePaths.append(contentsOf: result.unreadablePaths)
+                if result.bytes > 0 {
+                    components.append(.init(path: url.path, totalBytes: result.bytes))
+                }
+            }
+        }
+
+        return ProviderStorageFootprint(
+            provider: provider,
+            totalBytes: totalBytes,
+            paths: existingPaths,
+            missingPaths: missingPaths,
+            unreadablePaths: unreadablePaths,
+            components: components.sorted { lhs, rhs in
+                if lhs.totalBytes == rhs.totalBytes {
+                    return lhs.path.localizedCaseInsensitiveCompare(rhs.path) == .orderedAscending
+                }
+                return lhs.totalBytes > rhs.totalBytes
+            },
+            updatedAt: now)
+    }
+
+    private func isSymbolicLink(at url: URL) -> Bool {
+        (try? url.resourceValues(forKeys: [.isSymbolicLinkKey]).isSymbolicLink) == true
+    }
+
+    private func sizeOfFile(at url: URL) -> (bytes: Int64, unreadablePaths: [String]) {
+        if Task.isCancelled { return (0, []) }
+        let keys: Set<URLResourceKey> = [
+            .isRegularFileKey,
+            .isSymbolicLinkKey,
+            .fileSizeKey,
+        ]
+
+        guard let values = try? url.resourceValues(forKeys: keys) else {
+            return (0, [url.path])
+        }
+
+        if values.isSymbolicLink == true {
+            return (0, [])
+        }
+
+        if values.isRegularFile == true {
+            return (Int64(values.fileSize ?? 0), [])
+        }
+
+        return (0, [])
+    }
+
+    private func scanDirectory(at url: URL) -> DirectoryScanResult {
+        if Task.isCancelled { return DirectoryScanResult() }
+        let keys: Set<URLResourceKey> = [
+            .isDirectoryKey,
+            .isRegularFileKey,
+            .isSymbolicLinkKey,
+            .fileSizeKey,
+        ]
+
+        let unreadableCollector = ProviderStorageUnreadablePathCollector()
+        guard let enumerator = self.fileManager.enumerator(
+            at: url,
+            includingPropertiesForKeys: Array(keys),
+            options: [.skipsPackageDescendants],
+            errorHandler: { url, _ in
+                unreadableCollector.append(url.path)
+                return true
+            })
+        else {
+            return DirectoryScanResult(unreadablePaths: [url.path])
+        }
+
+        var result = DirectoryScanResult()
+        let rootPath = url.standardizedFileURL.path
+        for case let itemURL as URL in enumerator {
+            if Task.isCancelled {
+                enumerator.skipDescendants()
+                break
+            }
+            guard let itemValues = try? itemURL.resourceValues(forKeys: keys) else {
+                unreadableCollector.append(itemURL.path)
+                continue
+            }
+            if itemValues.isSymbolicLink == true {
+                if itemValues.isDirectory == true {
+                    enumerator.skipDescendants()
+                }
+                continue
+            }
+            if itemValues.isRegularFile == true {
+                let bytes = Int64(itemValues.fileSize ?? 0)
+                result.bytes += bytes
+                if bytes > 0, let componentPath = self.topLevelComponentPath(for: itemURL, rootPath: rootPath) {
+                    result.componentBytes[componentPath, default: 0] += bytes
+                }
+            }
+        }
+        result.unreadablePaths = unreadableCollector.paths
+        return result
+    }
+
+    private func topLevelComponentPath(for url: URL, rootPath: String) -> String? {
+        let itemPath = url.standardizedFileURL.path
+        let pathPrefix = rootPath.hasSuffix("/") ? rootPath : "\(rootPath)/"
+        guard itemPath.hasPrefix(pathPrefix) else { return nil }
+        let suffix = itemPath.dropFirst(pathPrefix.count)
+        let relative = suffix.drop { $0 == "/" }
+        guard let first = relative.split(separator: "/", maxSplits: 1, omittingEmptySubsequences: true).first else {
+            return nil
+        }
+        return URL(fileURLWithPath: rootPath, isDirectory: true)
+            .appendingPathComponent(String(first))
+            .path
+    }
+}
+
+private final class ProviderStorageUnreadablePathCollector: @unchecked Sendable {
+    private let lock = NSLock()
+    private var storage: [String] = []
+
+    var paths: [String] {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        return self.storage
+    }
+
+    func append(_ path: String) {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        self.storage.append(path)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/APITokenFetchStrategy.swift b/Sources/CodexBarCore/Providers/APITokenFetchStrategy.swift
new file mode 100644
index 0000000000..b3c5be10d5
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/APITokenFetchStrategy.swift
@@ -0,0 +1,67 @@
+import Foundation
+
+public struct APITokenFetchStrategy: ProviderFetchStrategy {
+    public typealias TokenResolver = @Sendable ([String: String]) -> String?
+    public typealias MissingCredentialsError = @Sendable () -> (any Error & Sendable)
+    public typealias UsageLoader = @Sendable (String, ProviderFetchContext) async throws -> UsageSnapshot
+
+    public let id: String
+    public let kind: ProviderFetchKind = .apiToken
+
+    private let sourceLabel: String
+    private let resolveToken: TokenResolver
+    private let missingCredentialsError: MissingCredentialsError
+    private let loadUsage: UsageLoader
+
+    public init(
+        id: String,
+        sourceLabel: String = "api",
+        resolveToken: @escaping TokenResolver,
+        missingCredentialsError: @escaping MissingCredentialsError,
+        loadUsage: @escaping UsageLoader)
+    {
+        self.id = id
+        self.sourceLabel = sourceLabel
+        self.resolveToken = resolveToken
+        self.missingCredentialsError = missingCredentialsError
+        self.loadUsage = loadUsage
+    }
+
+    public func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        self.resolveToken(context.env) != nil
+    }
+
+    public func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        guard let token = self.resolveToken(context.env) else {
+            throw self.missingCredentialsError()
+        }
+        return try await self.makeResult(
+            usage: self.loadUsage(token, context),
+            sourceLabel: self.sourceLabel)
+    }
+
+    public func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+}
+
+extension ProviderFetchPlan {
+    public static func apiToken(
+        strategyID: String,
+        sourceLabel: String = "api",
+        resolveToken: @escaping APITokenFetchStrategy.TokenResolver,
+        missingCredentialsError: @escaping APITokenFetchStrategy.MissingCredentialsError,
+        loadUsage: @escaping APITokenFetchStrategy.UsageLoader) -> ProviderFetchPlan
+    {
+        ProviderFetchPlan(
+            sourceModes: [.auto, .api],
+            pipeline: ProviderFetchPipeline(resolveStrategies: { _ in
+                [APITokenFetchStrategy(
+                    id: strategyID,
+                    sourceLabel: sourceLabel,
+                    resolveToken: resolveToken,
+                    missingCredentialsError: missingCredentialsError,
+                    loadUsage: loadUsage)]
+            }))
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Abacus/AbacusCookieImporter.swift b/Sources/CodexBarCore/Providers/Abacus/AbacusCookieImporter.swift
new file mode 100644
index 0000000000..c32c8bbb39
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Abacus/AbacusCookieImporter.swift
@@ -0,0 +1,134 @@
+import Foundation
+
+#if os(macOS)
+import SweetCookieKit
+
+// MARK: - Abacus Cookie Importer
+
+public enum AbacusCookieImporter {
+    private static let log = CodexBarLog.logger(LogCategories.abacusCookie)
+    private static let cookieClient = BrowserCookieClient()
+    private static let cookieDomains = ["abacus.ai", "apps.abacus.ai"]
+    private static let cookieImportOrder: BrowserCookieImportOrder =
+        ProviderDefaults.metadata[.abacus]?.browserCookieOrder ?? Browser.defaultImportOrder
+
+    /// Exact cookie names known to carry Abacus session state.
+    /// CSRF tokens are deliberately excluded — they are present in anonymous
+    /// jars and do not indicate an authenticated session.
+    private static let knownSessionCookieNames: Set<String> = [
+        "sessionid", "session_id", "session_token",
+        "auth_token", "access_token",
+    ]
+
+    /// Substrings that indicate a session or auth cookie (applied only when
+    /// no exact-name match is found). Deliberately excludes overly broad
+    /// patterns like "id" and "token" that match analytics/CSRF cookies.
+    private static let sessionCookieSubstrings = ["session", "auth", "sid", "jwt"]
+
+    /// Cookie name prefixes that indicate a non-session cookie even when a
+    /// substring match would otherwise accept it (e.g. "csrftoken").
+    private static let excludedCookiePrefixes = ["csrf", "_ga", "_gid", "tracking", "analytics"]
+
+    public struct SessionInfo: Sendable {
+        public let cookies: [HTTPCookie]
+        public let sourceLabel: String
+
+        public init(cookies: [HTTPCookie], sourceLabel: String) {
+            self.cookies = cookies
+            self.sourceLabel = sourceLabel
+        }
+
+        public var cookieHeader: String {
+            self.cookies.map { "\($0.name)=\($0.value)" }.joined(separator: "; ")
+        }
+    }
+
+    /// Returns all candidate sessions across browsers/profiles, ordered by
+    /// import priority.  Callers should try each in turn so that a stale
+    /// session in the first source doesn't block a valid one further down.
+    ///
+    /// Defaults to Chrome-only per AGENTS.md guideline. Pass an empty
+    /// `preferredBrowsers` list to fall back to the full descriptor-defined
+    /// import order (Safari, Firefox, etc.) when Chrome has no cookies.
+    public static func importSessions(
+        browserDetection: BrowserDetection = BrowserDetection(),
+        preferredBrowsers: [Browser] = [.chrome],
+        logger: ((String) -> Void)? = nil) throws -> [SessionInfo]
+    {
+        var candidates: [SessionInfo] = []
+        let installedBrowsers = preferredBrowsers.isEmpty
+            ? self.cookieImportOrder.cookieImportCandidates(using: browserDetection)
+            : preferredBrowsers.cookieImportCandidates(using: browserDetection)
+
+        for browserSource in installedBrowsers {
+            do {
+                let query = BrowserCookieQuery(domains: self.cookieDomains)
+                let sources = try Self.cookieClient.codexBarRecords(
+                    matching: query,
+                    in: browserSource,
+                    logger: { msg in self.emit(msg, logger: logger) })
+                for source in sources where !source.records.isEmpty {
+                    let httpCookies = BrowserCookieClient.makeHTTPCookies(source.records, origin: query.origin)
+                    guard !httpCookies.isEmpty else { continue }
+
+                    guard Self.containsSessionCookie(httpCookies) else {
+                        self.emit(
+                            "Skipping \(source.label): no session cookie found",
+                            logger: logger)
+                        continue
+                    }
+
+                    self.emit(
+                        "Found \(httpCookies.count) session cookies in \(source.label)",
+                        logger: logger)
+                    candidates.append(SessionInfo(cookies: httpCookies, sourceLabel: source.label))
+                }
+            } catch {
+                BrowserCookieAccessGate.recordIfNeeded(error)
+                self.emit(
+                    "\(browserSource.displayName) cookie import failed: \(error.localizedDescription)",
+                    logger: logger)
+            }
+        }
+
+        guard !candidates.isEmpty else {
+            throw AbacusUsageError.noSessionCookie
+        }
+        return candidates
+    }
+
+    /// Cheap check for whether any browser has an Abacus session cookie,
+    /// used by the fetch strategy's `isAvailable()`.
+    public static func hasSession(
+        browserDetection: BrowserDetection = BrowserDetection(),
+        preferredBrowsers: [Browser] = [.chrome],
+        logger: ((String) -> Void)? = nil) -> Bool
+    {
+        do {
+            return try !self.importSessions(
+                browserDetection: browserDetection,
+                preferredBrowsers: preferredBrowsers,
+                logger: logger).isEmpty
+        } catch {
+            return false
+        }
+    }
+
+    /// Returns `true` if the cookie set contains at least one cookie whose name
+    /// indicates session or authentication state.  Checks exact known names
+    /// first, then falls back to conservative substring matching.
+    private static func containsSessionCookie(_ cookies: [HTTPCookie]) -> Bool {
+        cookies.contains { cookie in
+            let lower = cookie.name.lowercased()
+            if self.knownSessionCookieNames.contains(lower) { return true }
+            if self.excludedCookiePrefixes.contains(where: { lower.hasPrefix($0) }) { return false }
+            return self.sessionCookieSubstrings.contains { lower.contains($0) }
+        }
+    }
+
+    private static func emit(_ message: String, logger: ((String) -> Void)?) {
+        logger?("[abacus-cookie] \(message)")
+        self.log.debug(message)
+    }
+}
+#endif
diff --git a/Sources/CodexBarCore/Providers/Abacus/AbacusProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Abacus/AbacusProviderDescriptor.swift
new file mode 100644
index 0000000000..2afe1dd9a8
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Abacus/AbacusProviderDescriptor.swift
@@ -0,0 +1,91 @@
+import Foundation
+
+#if os(macOS)
+import SweetCookieKit
+#endif
+
+public enum AbacusProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .abacus,
+            metadata: ProviderMetadata(
+                id: .abacus,
+                displayName: "Abacus AI",
+                sessionLabel: "Credits",
+                weeklyLabel: "Weekly",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "",
+                toggleTitle: "Show Abacus AI usage",
+                cliName: "abacusai",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                browserCookieOrder: ProviderBrowserCookieDefaults.defaultImportOrder,
+                dashboardURL: "https://apps.abacus.ai/chatllm/admin/compute-points-usage",
+                statusPageURL: nil,
+                statusLinkURL: nil),
+            branding: ProviderBranding(
+                iconStyle: .abacus,
+                iconResourceName: "ProviderIcon-abacus",
+                color: ProviderColor(red: 56 / 255, green: 189 / 255, blue: 248 / 255)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "Abacus AI cost summary is not supported." }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .web],
+                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in
+                    [AbacusWebFetchStrategy()]
+                })),
+            cli: ProviderCLIConfig(
+                name: "abacusai",
+                aliases: ["abacus-ai"],
+                versionDetector: nil))
+    }
+}
+
+// MARK: - Fetch Strategy
+
+struct AbacusWebFetchStrategy: ProviderFetchStrategy {
+    let id: String = "abacus.web"
+    let kind: ProviderFetchKind = .web
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        context.settings?.abacus?.cookieSource != .off
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        let manual: String?
+        if context.settings?.abacus?.cookieSource == .manual {
+            guard let header = Self.manualCookieHeader(from: context) else {
+                throw AbacusUsageError.noSessionCookie
+            }
+            manual = header
+        } else {
+            manual = nil
+        }
+        let logger: ((String) -> Void)? = context.verbose
+            ? { msg in CodexBarLog.logger(LogCategories.abacusUsage).verbose(msg) }
+            : nil
+        let snap = try await AbacusUsageFetcher.fetchUsage(
+            cookieHeaderOverride: manual,
+            browserDetection: context.browserDetection,
+            timeout: context.webTimeout,
+            logger: logger)
+        return self.makeResult(
+            usage: snap.toUsageSnapshot(),
+            sourceLabel: "web")
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+
+    private static func manualCookieHeader(from context: ProviderFetchContext) -> String? {
+        guard context.settings?.abacus?.cookieSource == .manual else { return nil }
+        return CookieHeaderNormalizer.normalize(context.settings?.abacus?.manualCookieHeader)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Abacus/AbacusUsageError.swift b/Sources/CodexBarCore/Providers/Abacus/AbacusUsageError.swift
new file mode 100644
index 0000000000..0f5c6cc532
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Abacus/AbacusUsageError.swift
@@ -0,0 +1,67 @@
+import Foundation
+
+// MARK: - Abacus Usage Error
+
+public enum AbacusUsageError: LocalizedError, Sendable, Equatable {
+    case noSessionCookie
+    case sessionExpired
+    case networkError(String)
+    case parseFailed(String)
+    case unauthorized
+
+    /// Whether this error indicates an authentication/session problem that
+    /// should trigger cache eviction.
+    public var isRecoverable: Bool {
+        switch self {
+        case .unauthorized, .sessionExpired: true
+        default: false
+        }
+    }
+
+    public var isAuthRelated: Bool {
+        self.isRecoverable
+    }
+
+    /// Whether browser-import scanning should continue to later sessions after
+    /// this failure. Imported sessions can differ by profile/browser, so we keep
+    /// scanning on per-session fetch failures and surface the first one only if
+    /// every candidate is exhausted.
+    var shouldTryNextImportedSession: Bool {
+        switch self {
+        case .unauthorized, .sessionExpired, .networkError, .parseFailed: true
+        case .noSessionCookie: false
+        }
+    }
+
+    /// Whether a cached cookie header should be evicted before falling back to
+    /// a fresh browser import. Parse/auth failures usually indicate that the
+    /// cached session is stale or no longer accepted.
+    var shouldClearCachedCookie: Bool {
+        switch self {
+        case .unauthorized, .sessionExpired, .parseFailed: true
+        case .networkError, .noSessionCookie: false
+        }
+    }
+
+    public var errorDescription: String? {
+        switch self {
+        case .noSessionCookie:
+            "No Abacus AI session found. Please log in to apps.abacus.ai in your browser "
+                + "or paste a Cookie header in manual mode."
+        case .sessionExpired:
+            "Abacus AI session expired. Please log in again."
+        case let .networkError(msg):
+            "Abacus AI API error: \(msg)"
+        case let .parseFailed(msg):
+            "Could not parse Abacus AI usage: \(msg)"
+        case .unauthorized:
+            "Unauthorized. Please log in to Abacus AI."
+        }
+    }
+}
+
+#if !os(macOS)
+extension AbacusUsageError {
+    public static let notSupported = AbacusUsageError.networkError("Abacus AI is only supported on macOS.")
+}
+#endif
diff --git a/Sources/CodexBarCore/Providers/Abacus/AbacusUsageFetcher.swift b/Sources/CodexBarCore/Providers/Abacus/AbacusUsageFetcher.swift
new file mode 100644
index 0000000000..1c449d4fa6
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Abacus/AbacusUsageFetcher.swift
@@ -0,0 +1,336 @@
+import Foundation
+
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+#if os(macOS)
+import SweetCookieKit
+
+// MARK: - Abacus Usage Fetcher
+
+public enum AbacusUsageFetcher {
+    private struct BrowserFetchRequest {
+        let browserDetection: BrowserDetection
+        let preferredBrowsers: [Browser]
+        let label: String
+        let timeout: TimeInterval
+        let logger: ((String) -> Void)?
+    }
+
+    /// Parsed JSON dictionaries are treated as immutable snapshots here and are
+    /// only moved between sibling fetch tasks before being consumed locally.
+    private struct JSONDictionaryBox: @unchecked Sendable {
+        let value: [String: Any]
+    }
+
+    private static let log = CodexBarLog.logger(LogCategories.abacusUsage)
+    private static let computePointsURL =
+        URL(string: "https://apps.abacus.ai/api/_getOrganizationComputePoints")!
+    private static let billingInfoURL =
+        URL(string: "https://apps.abacus.ai/api/_getBillingInfo")!
+
+    public static func fetchUsage(
+        cookieHeaderOverride: String? = nil,
+        browserDetection: BrowserDetection = BrowserDetection(),
+        timeout: TimeInterval = 15.0,
+        logger: ((String) -> Void)? = nil) async throws -> AbacusUsageSnapshot
+    {
+        // Manual cookie header — no fallback, errors propagate directly
+        if let override = CookieHeaderNormalizer.normalize(cookieHeaderOverride) {
+            self.emit("Using manual cookie header", logger: logger)
+            return try await self.fetchWithCookieHeader(override, timeout: timeout, logger: logger)
+        }
+
+        // Cached cookie header — fall back to a fresh browser import when the
+        // cached session is rejected or looks stale.
+        if let cached = CookieHeaderCache.load(provider: .abacus),
+           !cached.cookieHeader.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+        {
+            self.emit("Using cached cookie header from \(cached.sourceLabel)", logger: logger)
+            do {
+                return try await self.fetchWithCookieHeader(
+                    cached.cookieHeader, timeout: timeout, logger: logger)
+            } catch let error as AbacusUsageError where error.shouldTryNextImportedSession {
+                if error.shouldClearCachedCookie {
+                    CookieHeaderCache.clear(provider: .abacus)
+                    self.emit(
+                        "Cached cookie failed (\(error.localizedDescription)); cleared, trying fresh import",
+                        logger: logger)
+                } else {
+                    self.emit(
+                        "Cached cookie failed (\(error.localizedDescription)); trying fresh import",
+                        logger: logger)
+                }
+            }
+        }
+
+        // Fresh browser import — try Chrome first (AGENTS.md default), then broaden
+        // to all browsers if Chrome has no sessions OR if every imported Chrome
+        // session is exhausted without a successful fetch.
+        var lastError: AbacusUsageError = .noSessionCookie
+        if let snapshot = try await self.tryFetchFromBrowsers(
+            BrowserFetchRequest(
+                browserDetection: browserDetection,
+                preferredBrowsers: [.chrome],
+                label: "Chrome",
+                timeout: timeout,
+                logger: logger),
+            lastError: &lastError)
+        {
+            return snapshot
+        }
+
+        self.emit("Chrome sessions exhausted; falling back to all browsers", logger: logger)
+        if let snapshot = try await self.tryFetchFromBrowsers(
+            BrowserFetchRequest(
+                browserDetection: browserDetection,
+                preferredBrowsers: [],
+                label: "all browsers",
+                timeout: timeout,
+                logger: logger),
+            lastError: &lastError)
+        {
+            return snapshot
+        }
+
+        throw lastError
+    }
+
+    /// Tries to import sessions from `preferredBrowsers` and fetch usage. Returns
+    /// the snapshot on success, nil if no sessions were available or every
+    /// imported session was exhausted without success.
+    private static func tryFetchFromBrowsers(
+        _ request: BrowserFetchRequest,
+        lastError: inout AbacusUsageError) async throws -> AbacusUsageSnapshot?
+    {
+        let sessions: [AbacusCookieImporter.SessionInfo]
+        do {
+            sessions = try AbacusCookieImporter.importSessions(
+                browserDetection: request.browserDetection,
+                preferredBrowsers: request.preferredBrowsers,
+                logger: request.logger)
+        } catch {
+            BrowserCookieAccessGate.recordIfNeeded(error)
+            self.emit(
+                "\(request.label) cookie import failed: \(error.localizedDescription)",
+                logger: request.logger)
+            return nil
+        }
+
+        for session in sessions {
+            self.emit("Trying cookies from \(session.sourceLabel)", logger: request.logger)
+            do {
+                let snapshot = try await self.fetchWithCookieHeader(
+                    session.cookieHeader,
+                    timeout: request.timeout,
+                    logger: request.logger)
+                CookieHeaderCache.store(
+                    provider: .abacus,
+                    cookieHeader: session.cookieHeader,
+                    sourceLabel: session.sourceLabel)
+                return snapshot
+            } catch let error as AbacusUsageError where error.shouldTryNextImportedSession {
+                self.emit(
+                    "\(session.sourceLabel): \(error.localizedDescription), trying next source",
+                    logger: request.logger)
+                lastError = error
+                continue
+            } catch {
+                self.emit(
+                    "\(session.sourceLabel): \(error.localizedDescription), trying next source",
+                    logger: request.logger)
+                lastError = .networkError(error.localizedDescription)
+                continue
+            }
+        }
+        return nil
+    }
+
+    // MARK: - API Requests
+
+    private static func fetchWithCookieHeader(
+        _ cookieHeader: String,
+        timeout: TimeInterval,
+        logger: ((String) -> Void)? = nil) async throws -> AbacusUsageSnapshot
+    {
+        enum FetchPart: Sendable {
+            case computePoints(JSONDictionaryBox)
+            case billingInfoSuccess(JSONDictionaryBox)
+            case billingInfoFailure(String)
+        }
+
+        // Fetch compute points (required, full timeout) and billing info
+        // (optional, shorter budget) concurrently. Billing is bounded so a
+        // slow/flaky billing endpoint can't delay credit rendering.
+        let billingBudget = min(timeout, 5.0)
+
+        var computePointsResult: [String: Any]?
+        var billingInfoResult: [String: Any] = [:]
+
+        try await withThrowingTaskGroup(of: FetchPart.self) { group in
+            group.addTask {
+                let result = try await self.fetchJSON(
+                    url: self.computePointsURL,
+                    method: "GET",
+                    cookieHeader: cookieHeader,
+                    timeout: timeout)
+                return .computePoints(JSONDictionaryBox(value: result))
+            }
+            group.addTask {
+                do {
+                    let result = try await self.fetchJSON(
+                        url: self.billingInfoURL,
+                        method: "POST",
+                        cookieHeader: cookieHeader,
+                        timeout: billingBudget)
+                    return .billingInfoSuccess(JSONDictionaryBox(value: result))
+                } catch {
+                    return .billingInfoFailure(error.localizedDescription)
+                }
+            }
+
+            while let result = try await group.next() {
+                switch result {
+                case let .computePoints(value):
+                    computePointsResult = value.value
+                case let .billingInfoSuccess(value):
+                    billingInfoResult = value.value
+                case let .billingInfoFailure(message):
+                    self.emit(
+                        "Billing info fetch failed: \(message); credits shown without plan/reset",
+                        logger: logger)
+                }
+            }
+        }
+
+        guard let computePointsResult else {
+            throw AbacusUsageError.networkError("Abacus compute points fetch did not complete")
+        }
+
+        return try self.parseResults(computePoints: computePointsResult, billingInfo: billingInfoResult)
+    }
+
+    private static func fetchJSON(
+        url: URL, method: String, cookieHeader: String, timeout: TimeInterval) async throws -> [String: Any]
+    {
+        var request = URLRequest(url: url)
+        request.httpMethod = method
+        request.timeoutInterval = timeout
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        request.setValue(cookieHeader, forHTTPHeaderField: "Cookie")
+        if method == "POST" {
+            request.httpBody = Data("{}".utf8)
+        }
+
+        let response = try await ProviderHTTPClient.shared.response(for: request)
+        let data = response.data
+        let statusCode = response.statusCode
+
+        if statusCode == 401 || statusCode == 403 {
+            throw AbacusUsageError.unauthorized
+        }
+
+        guard statusCode == 200 else {
+            let body = String(data: data.prefix(200), encoding: .utf8) ?? ""
+            throw AbacusUsageError.networkError("HTTP \(statusCode): \(body)")
+        }
+
+        let parsed: Any
+        do {
+            parsed = try JSONSerialization.jsonObject(with: data)
+        } catch {
+            let preview = String(data: data.prefix(200), encoding: .utf8) ?? "<non-UTF8>"
+            throw AbacusUsageError.parseFailed(
+                "\(url.lastPathComponent): \(error.localizedDescription) — preview: \(preview)")
+        }
+
+        guard let root = parsed as? [String: Any] else {
+            throw AbacusUsageError.parseFailed("\(url.lastPathComponent): top-level JSON is not a dictionary")
+        }
+
+        guard root["success"] as? Bool == true,
+              let result = root["result"] as? [String: Any]
+        else {
+            let errorMsg = (root["error"] as? String ?? "Unknown error").lowercased()
+            if errorMsg.contains("expired") || errorMsg.contains("session")
+                || errorMsg.contains("login") || errorMsg.contains("authenticate")
+                || errorMsg.contains("unauthorized") || errorMsg.contains("unauthenticated")
+                || errorMsg.contains("forbidden")
+            {
+                throw AbacusUsageError.unauthorized
+            }
+            throw AbacusUsageError.parseFailed("\(url.lastPathComponent): \(errorMsg)")
+        }
+
+        return result
+    }
+
+    // MARK: - Parsing
+
+    private static func parseResults(
+        computePoints: [String: Any], billingInfo: [String: Any]) throws -> AbacusUsageSnapshot
+    {
+        let totalCredits = self.double(from: computePoints["totalComputePoints"])
+        let creditsLeft = self.double(from: computePoints["computePointsLeft"])
+
+        guard let totalCredits, let creditsLeft else {
+            let keys = computePoints.keys.sorted().joined(separator: ", ")
+            throw AbacusUsageError.parseFailed(
+                "Missing credit fields in compute points response. Keys: [\(keys)]")
+        }
+
+        let creditsUsed = totalCredits - creditsLeft
+
+        let nextBillingDate = billingInfo["nextBillingDate"] as? String
+        let currentTier = billingInfo["currentTier"] as? String
+        let resetsAt = self.parseDate(nextBillingDate)
+
+        return AbacusUsageSnapshot(
+            creditsUsed: creditsUsed,
+            creditsTotal: totalCredits,
+            resetsAt: resetsAt,
+            planName: currentTier)
+    }
+
+    private static func double(from value: Any?) -> Double? {
+        if let d = value as? Double { return d }
+        if let i = value as? Int { return Double(i) }
+        if let n = value as? NSNumber { return n.doubleValue }
+        return nil
+    }
+
+    private static func parseDate(_ isoString: String?) -> Date? {
+        guard let isoString else { return nil }
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        if let date = formatter.date(from: isoString) { return date }
+        formatter.formatOptions = [.withInternetDateTime]
+        return formatter.date(from: isoString)
+    }
+
+    // MARK: - Logging
+
+    private static func emit(_ message: String, logger: ((String) -> Void)?) {
+        logger?("[abacus] \(message)")
+        self.log.debug(message)
+    }
+}
+
+#else
+
+// MARK: - Abacus (Unsupported)
+
+public enum AbacusUsageFetcher {
+    public static func fetchUsage(
+        cookieHeaderOverride _: String? = nil,
+        browserDetection _: BrowserDetection = BrowserDetection(),
+        timeout _: TimeInterval = 15.0,
+        logger _: ((String) -> Void)? = nil) async throws -> AbacusUsageSnapshot
+    {
+        throw AbacusUsageError.notSupported
+    }
+}
+
+#endif
diff --git a/Sources/CodexBarCore/Providers/Abacus/AbacusUsageSnapshot.swift b/Sources/CodexBarCore/Providers/Abacus/AbacusUsageSnapshot.swift
new file mode 100644
index 0000000000..018684487a
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Abacus/AbacusUsageSnapshot.swift
@@ -0,0 +1,77 @@
+import Foundation
+
+// MARK: - Abacus Usage Snapshot
+
+public struct AbacusUsageSnapshot: Sendable {
+    public let creditsUsed: Double?
+    public let creditsTotal: Double?
+    public let resetsAt: Date?
+    public let planName: String?
+
+    public init(
+        creditsUsed: Double? = nil,
+        creditsTotal: Double? = nil,
+        resetsAt: Date? = nil,
+        planName: String? = nil)
+    {
+        self.creditsUsed = creditsUsed
+        self.creditsTotal = creditsTotal
+        self.resetsAt = resetsAt
+        self.planName = planName
+    }
+
+    public func toUsageSnapshot() -> UsageSnapshot {
+        let percentUsed: Double = if let used = self.creditsUsed, let total = self.creditsTotal, total > 0 {
+            (used / total) * 100.0
+        } else {
+            0
+        }
+
+        let resetDesc: String? = if let used = self.creditsUsed, let total = self.creditsTotal {
+            "\(Self.formatCredits(used)) / \(Self.formatCredits(total)) credits"
+        } else {
+            nil
+        }
+
+        // Derive window from actual billing cycle when possible.
+        // Assume the cycle started one calendar month before resetsAt.
+        let windowMinutes: Int = if let resetDate = self.resetsAt,
+                                    let cycleStart = Calendar.current.date(byAdding: .month, value: -1, to: resetDate)
+        {
+            max(1, Int(resetDate.timeIntervalSince(cycleStart) / 60))
+        } else {
+            30 * 24 * 60
+        }
+
+        let primary = RateWindow(
+            usedPercent: percentUsed,
+            windowMinutes: windowMinutes,
+            resetsAt: self.resetsAt,
+            resetDescription: resetDesc)
+
+        let identity = ProviderIdentitySnapshot(
+            providerID: .abacus,
+            accountEmail: nil,
+            accountOrganization: nil,
+            loginMethod: self.planName)
+
+        return UsageSnapshot(
+            primary: primary,
+            secondary: nil,
+            tertiary: nil,
+            providerCost: nil,
+            updatedAt: Date(),
+            identity: identity)
+    }
+
+    // MARK: - Formatting
+
+    /// Thread-safe credit formatting — allocates per call to avoid shared mutable state.
+    private static func formatCredits(_ value: Double) -> String {
+        let formatter = NumberFormatter()
+        formatter.numberStyle = .decimal
+        formatter.locale = Locale(identifier: "en_US")
+        formatter.maximumFractionDigits = value >= 1000 ? 0 : 1
+        return formatter.string(from: NSNumber(value: value)) ?? String(format: "%.0f", value)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Alibaba/AlibabaCodingPlanAPIRegion.swift b/Sources/CodexBarCore/Providers/Alibaba/AlibabaCodingPlanAPIRegion.swift
new file mode 100644
index 0000000000..d86585a1f6
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Alibaba/AlibabaCodingPlanAPIRegion.swift
@@ -0,0 +1,133 @@
+import Foundation
+
+public enum AlibabaCodingPlanAPIRegion: String, CaseIterable, Sendable {
+    case international = "intl"
+    case chinaMainland = "cn"
+
+    private static let endpointPath = "data/api.json"
+
+    public var displayName: String {
+        switch self {
+        case .international:
+            "International (modelstudio.console.alibabacloud.com)"
+        case .chinaMainland:
+            "China mainland (bailian.console.aliyun.com)"
+        }
+    }
+
+    public var gatewayBaseURLString: String {
+        switch self {
+        case .international:
+            "https://modelstudio.console.alibabacloud.com"
+        case .chinaMainland:
+            "https://bailian.console.aliyun.com"
+        }
+    }
+
+    public var dashboardURL: URL {
+        switch self {
+        case .international:
+            URL(
+                string: "https://modelstudio.console.alibabacloud.com/ap-southeast-1/?tab=coding-plan#/efm/coding_plan")!
+        case .chinaMainland:
+            URL(string: "https://bailian.console.aliyun.com/cn-beijing/?tab=model#/efm/coding_plan")!
+        }
+    }
+
+    public var consoleDomain: String {
+        switch self {
+        case .international:
+            "modelstudio.console.alibabacloud.com"
+        case .chinaMainland:
+            "bailian.console.aliyun.com"
+        }
+    }
+
+    public var consoleSite: String {
+        switch self {
+        case .international:
+            "MODELSTUDIO_ALIBABACLOUD"
+        case .chinaMainland:
+            "BAILIAN_ALIYUN"
+        }
+    }
+
+    public var consoleRefererURL: URL {
+        switch self {
+        case .international:
+            URL(string: "https://modelstudio.console.alibabacloud.com/ap-southeast-1/?tab=coding-plan")!
+        case .chinaMainland:
+            URL(string: "https://bailian.console.aliyun.com/cn-beijing/?tab=model")!
+        }
+    }
+
+    public var quotaURL: URL {
+        var components = URLComponents(string: self.gatewayBaseURLString)!
+        components.path = "/" + Self.endpointPath
+        components.queryItems = [
+            URLQueryItem(
+                name: "action",
+                value: "zeldaEasy.broadscope-bailian.codingPlan.queryCodingPlanInstanceInfoV2"),
+            URLQueryItem(name: "product", value: "broadscope-bailian"),
+            URLQueryItem(name: "api", value: "queryCodingPlanInstanceInfoV2"),
+            URLQueryItem(name: "currentRegionId", value: self.currentRegionID),
+        ]
+        return components.url!
+    }
+
+    public var consoleRPCBaseURLString: String {
+        switch self {
+        case .international:
+            "https://bailian-singapore-cs.alibabacloud.com"
+        case .chinaMainland:
+            "https://bailian-cs.console.aliyun.com"
+        }
+    }
+
+    public var consoleRPCURL: URL {
+        var components = URLComponents(string: self.consoleRPCBaseURLString)!
+        components.path = "/" + Self.endpointPath
+        components.queryItems = [
+            URLQueryItem(name: "action", value: self.consoleRPCAction),
+            URLQueryItem(name: "product", value: self.consoleRPCProduct),
+            URLQueryItem(name: "api", value: self.consoleQuotaAPIName),
+            URLQueryItem(name: "_v", value: "undefined"),
+        ]
+        return components.url!
+    }
+
+    public var consoleRPCAction: String {
+        switch self {
+        case .international:
+            "IntlBroadScopeAspnGateway"
+        case .chinaMainland:
+            "BroadScopeAspnGateway"
+        }
+    }
+
+    public var consoleRPCProduct: String {
+        "sfm_bailian"
+    }
+
+    public var consoleQuotaAPIName: String {
+        "zeldaEasy.broadscope-bailian.codingPlan.queryCodingPlanInstanceInfoV2"
+    }
+
+    public var commodityCode: String {
+        switch self {
+        case .international:
+            "sfm_codingplan_public_intl"
+        case .chinaMainland:
+            "sfm_codingplan_public_cn"
+        }
+    }
+
+    public var currentRegionID: String {
+        switch self {
+        case .international:
+            "ap-southeast-1"
+        case .chinaMainland:
+            "cn-beijing"
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Alibaba/AlibabaCodingPlanCookieImporter.swift b/Sources/CodexBarCore/Providers/Alibaba/AlibabaCodingPlanCookieImporter.swift
new file mode 100644
index 0000000000..608991c0dc
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Alibaba/AlibabaCodingPlanCookieImporter.swift
@@ -0,0 +1,505 @@
+import Foundation
+
+#if os(macOS)
+import CommonCrypto
+import Security
+import SQLite3
+import SweetCookieKit
+
+private let alibabaCookieImportOrder: BrowserCookieImportOrder =
+    ProviderDefaults.metadata[.alibaba]?.browserCookieOrder ?? Browser.defaultImportOrder
+
+public enum AlibabaCodingPlanCookieImporter {
+    private static let cookieClient = BrowserCookieClient()
+    private static let cookieDomains = [
+        "bailian-singapore-cs.alibabacloud.com",
+        "bailian-cs.console.aliyun.com",
+        "bailian-beijing-cs.aliyuncs.com",
+        "modelstudio.console.alibabacloud.com",
+        "bailian.console.aliyun.com",
+        "free.aliyun.com",
+        "account.aliyun.com",
+        "signin.aliyun.com",
+        "passport.alibabacloud.com",
+        "console.alibabacloud.com",
+        "console.aliyun.com",
+        "alibabacloud.com",
+        "aliyun.com",
+    ]
+
+    public struct SessionInfo: Sendable {
+        public let cookies: [HTTPCookie]
+        public let sourceLabel: String
+
+        public init(cookies: [HTTPCookie], sourceLabel: String) {
+            self.cookies = cookies
+            self.sourceLabel = sourceLabel
+        }
+
+        public var cookieHeader: String {
+            var byName: [String: HTTPCookie] = [:]
+            byName.reserveCapacity(self.cookies.count)
+
+            for cookie in self.cookies {
+                if let expiry = cookie.expiresDate, expiry < Date() {
+                    continue
+                }
+                guard !cookie.value.isEmpty else { continue }
+                if let existing = byName[cookie.name] {
+                    let existingExpiry = existing.expiresDate ?? .distantPast
+                    let candidateExpiry = cookie.expiresDate ?? .distantPast
+                    if candidateExpiry >= existingExpiry {
+                        byName[cookie.name] = cookie
+                    }
+                } else {
+                    byName[cookie.name] = cookie
+                }
+            }
+
+            return byName.keys.sorted().compactMap { name in
+                guard let cookie = byName[name] else { return nil }
+                return "\(cookie.name)=\(cookie.value)"
+            }.joined(separator: "; ")
+        }
+    }
+
+    nonisolated(unsafe) static var importSessionOverrideForTesting:
+        ((BrowserDetection, ((String) -> Void)?) throws -> SessionInfo)?
+
+    public static func importSession(
+        browserDetection: BrowserDetection,
+        logger: ((String) -> Void)? = nil) throws -> SessionInfo
+    {
+        if let override = self.importSessionOverrideForTesting {
+            return try override(browserDetection, logger)
+        }
+        let log: (String) -> Void = { msg in logger?("[alibaba-cookie] \(msg)") }
+        var accessDeniedHints: [String] = []
+        var failureDetails: [String] = []
+        let installedBrowsers = self.cookieImportCandidates(browserDetection: browserDetection)
+        log("Cookie import candidates: \(installedBrowsers.map(\.displayName).joined(separator: ", "))")
+
+        for browserSource in installedBrowsers {
+            do {
+                log("Checking \(browserSource.displayName)")
+                let query = BrowserCookieQuery(domains: self.cookieDomains)
+                let sources = try Self.cookieClient.codexBarRecords(
+                    matching: query,
+                    in: browserSource,
+                    logger: log)
+                if sources.isEmpty {
+                    log("No matching cookie records in \(browserSource.displayName)")
+                    if let fallbackSession = try Self.importChromiumFallbackSession(
+                        browser: browserSource,
+                        logger: log)
+                    {
+                        return fallbackSession
+                    }
+                }
+                for source in sources where !source.records.isEmpty {
+                    let httpCookies = BrowserCookieClient.makeHTTPCookies(source.records, origin: query.origin)
+                    if self.isAuthenticatedSession(cookies: httpCookies) {
+                        log("Found \(httpCookies.count) Alibaba cookies in \(source.label)")
+                        return SessionInfo(cookies: httpCookies, sourceLabel: source.label)
+                    }
+                    let cookieNames = Set(httpCookies.map(\.name))
+                    let hasTicket = cookieNames.contains("login_aliyunid_ticket")
+                    let hasAccount =
+                        cookieNames.contains("login_aliyunid_pk") ||
+                        cookieNames.contains("login_current_pk") ||
+                        cookieNames.contains("login_aliyunid")
+                    log("Skipping \(source.label): missing auth cookies (ticket=\(hasTicket), account=\(hasAccount))")
+                }
+                if let fallbackSession = try Self.importChromiumFallbackSession(browser: browserSource, logger: log) {
+                    return fallbackSession
+                }
+            } catch let error as BrowserCookieError {
+                BrowserCookieAccessGate.recordIfNeeded(error)
+                if let hint = error.accessDeniedHint {
+                    accessDeniedHints.append(hint)
+                }
+                failureDetails.append("\(browserSource.displayName): \(error.localizedDescription)")
+                log("\(browserSource.displayName) cookie import failed: \(error.localizedDescription)")
+            } catch {
+                failureDetails.append("\(browserSource.displayName): \(error.localizedDescription)")
+                log("\(browserSource.displayName) cookie import failed: \(error.localizedDescription)")
+            }
+        }
+
+        let details = (Array(Set(accessDeniedHints)).sorted() + Array(Set(failureDetails)).sorted())
+            .joined(separator: " ")
+        throw AlibabaCodingPlanSettingsError.missingCookie(details: details.isEmpty ? nil : details)
+    }
+
+    private static func isAuthenticatedSession(cookies: [HTTPCookie]) -> Bool {
+        guard !cookies.isEmpty else { return false }
+        let names = Set(cookies.map(\.name))
+        let hasTicket = names.contains("login_aliyunid_ticket")
+        let hasAccount =
+            names.contains("login_aliyunid_pk") ||
+            names.contains("login_current_pk") ||
+            names.contains("login_aliyunid")
+        return hasTicket && hasAccount
+    }
+
+    public static func hasSession(
+        browserDetection: BrowserDetection,
+        logger: ((String) -> Void)? = nil) -> Bool
+    {
+        do {
+            _ = try self.importSession(browserDetection: browserDetection, logger: logger)
+            return true
+        } catch {
+            return false
+        }
+    }
+
+    private static func importChromiumFallbackSession(
+        browser: Browser,
+        logger: ((String) -> Void)? = nil) throws -> SessionInfo?
+    {
+        guard browser.usesChromiumProfileStore else { return nil }
+        return try AlibabaChromiumCookieFallbackImporter.importSession(
+            browser: browser,
+            domains: self.cookieDomains,
+            logger: logger)
+    }
+
+    static func cookieImportCandidates(
+        browserDetection: BrowserDetection,
+        importOrder: BrowserCookieImportOrder = alibabaCookieImportOrder) -> [Browser]
+    {
+        importOrder.cookieImportCandidates(using: browserDetection)
+    }
+
+    static func matchesCookieDomain(_ domain: String, patterns: [String] = Self.cookieDomains) -> Bool {
+        let normalized = self.normalizeCookieDomain(domain)
+        return patterns.contains { pattern in
+            let normalizedPattern = self.normalizeCookieDomain(pattern)
+            return normalized == normalizedPattern || normalized.hasSuffix(".\(normalizedPattern)")
+        }
+    }
+
+    static func normalizeCookieDomain(_ domain: String) -> String {
+        let trimmed = domain.trimmingCharacters(in: .whitespacesAndNewlines)
+        let normalized = trimmed.hasPrefix(".") ? String(trimmed.dropFirst()) : trimmed
+        return normalized.lowercased()
+    }
+}
+
+enum AlibabaChromiumCookieFallbackImporter {
+    private struct ChromiumCookieRecord {
+        let domain: String
+        let name: String
+        let path: String
+        let value: String
+        let expires: Date?
+        let isSecure: Bool
+    }
+
+    enum ImportError: LocalizedError {
+        case keyUnavailable(browser: Browser)
+        case keychainDenied(browser: Browser)
+        case sqliteFailed(label: String, details: String)
+
+        var errorDescription: String? {
+            switch self {
+            case let .keyUnavailable(browser):
+                "\(browser.displayName) Safe Storage key not found."
+            case let .keychainDenied(browser):
+                "macOS Keychain denied access to \(browser.displayName) Safe Storage."
+            case let .sqliteFailed(label, details):
+                "\(label) cookie fallback failed: \(details)"
+            }
+        }
+    }
+
+    static func importSession(
+        browser: Browser,
+        domains: [String],
+        cookieClient: BrowserCookieClient = BrowserCookieClient(),
+        logger: ((String) -> Void)? = nil) throws -> AlibabaCodingPlanCookieImporter.SessionInfo?
+    {
+        let stores = try cookieClient.codexBarStores(for: browser).filter { $0.databaseURL != nil }
+        guard !stores.isEmpty else { return nil }
+
+        logger?("[alibaba-cookie] Trying \(browser.displayName) Chromium fallback")
+        let keys = try self.derivedKeys(for: browser)
+        for store in stores {
+            let cookies = try self.loadCookies(from: store, domains: domains, keys: keys)
+            guard !cookies.isEmpty else { continue }
+            if self.isAuthenticatedSession(cookies) {
+                logger?("[alibaba-cookie] Found \(cookies.count) Alibaba cookies via \(store.label) fallback")
+                return AlibabaCodingPlanCookieImporter.SessionInfo(cookies: cookies, sourceLabel: store.label)
+            }
+        }
+        return nil
+    }
+
+    private static func isAuthenticatedSession(_ cookies: [HTTPCookie]) -> Bool {
+        let names = Set(cookies.map(\.name))
+        let hasTicket = names.contains("login_aliyunid_ticket")
+        let hasAccount =
+            names.contains("login_aliyunid_pk") ||
+            names.contains("login_current_pk") ||
+            names.contains("login_aliyunid")
+        return hasTicket && hasAccount
+    }
+
+    private static func loadCookies(
+        from store: BrowserCookieStore,
+        domains: [String],
+        keys: [Data]) throws -> [HTTPCookie]
+    {
+        guard let sourceDB = store.databaseURL else { return [] }
+        let records = try self.readCookiesFromLockedDB(
+            sourceDB: sourceDB,
+            domains: domains,
+            keys: keys,
+            label: store.label)
+        return records.compactMap(self.makeCookie)
+    }
+
+    private static func readCookiesFromLockedDB(
+        sourceDB: URL,
+        domains: [String],
+        keys: [Data],
+        label: String) throws -> [ChromiumCookieRecord]
+    {
+        let tempDir = FileManager.default.temporaryDirectory
+            .appendingPathComponent("alibaba-chromium-cookies-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+
+        let copiedDB = tempDir.appendingPathComponent("Cookies")
+        try FileManager.default.copyItem(at: sourceDB, to: copiedDB)
+        for suffix in ["-wal", "-shm"] {
+            let src = URL(fileURLWithPath: sourceDB.path + suffix)
+            if FileManager.default.fileExists(atPath: src.path) {
+                let dst = URL(fileURLWithPath: copiedDB.path + suffix)
+                try? FileManager.default.copyItem(at: src, to: dst)
+            }
+        }
+        defer { try? FileManager.default.removeItem(at: tempDir) }
+
+        return try self.readCookies(fromDB: copiedDB.path, domains: domains, keys: keys, label: label)
+    }
+
+    private static func readCookies(
+        fromDB path: String,
+        domains: [String],
+        keys: [Data],
+        label: String) throws -> [ChromiumCookieRecord]
+    {
+        var db: OpaquePointer?
+        guard sqlite3_open_v2(path, &db, SQLITE_OPEN_READONLY, nil) == SQLITE_OK else {
+            throw ImportError.sqliteFailed(label: label, details: String(cString: sqlite3_errmsg(db)))
+        }
+        defer { sqlite3_close(db) }
+
+        let sql = "SELECT host_key, name, path, expires_utc, is_secure, value, encrypted_value FROM cookies"
+        var stmt: OpaquePointer?
+        guard sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK else {
+            throw ImportError.sqliteFailed(label: label, details: String(cString: sqlite3_errmsg(db)))
+        }
+        defer { sqlite3_finalize(stmt) }
+
+        var records: [ChromiumCookieRecord] = []
+        while sqlite3_step(stmt) == SQLITE_ROW {
+            guard let hostKey = self.readText(stmt, index: 0), self.matches(domain: hostKey, patterns: domains) else {
+                continue
+            }
+            guard let name = self.readText(stmt, index: 1), let path = self.readText(stmt, index: 2) else {
+                continue
+            }
+
+            let value: String? = if let plain = self.readText(stmt, index: 5), !plain.isEmpty {
+                plain
+            } else if let encrypted = self.readBlob(stmt, index: 6) {
+                self.decrypt(encrypted, usingAnyOf: keys)
+            } else {
+                nil
+            }
+            guard let value, !value.isEmpty else { continue }
+
+            records.append(ChromiumCookieRecord(
+                domain: AlibabaCodingPlanCookieImporter.normalizeCookieDomain(hostKey),
+                name: name,
+                path: path,
+                value: value,
+                expires: self.chromiumExpiry(sqlite3_column_int64(stmt, 3)),
+                isSecure: sqlite3_column_int(stmt, 4) != 0))
+        }
+
+        return records.filter { record in
+            guard let expires = record.expires else { return true }
+            return expires >= Date()
+        }
+    }
+
+    private static func derivedKeys(for browser: Browser) throws -> [Data] {
+        var keys: [Data] = []
+        var sawDenied = false
+
+        for label in browser.safeStorageLabels {
+            switch KeychainAccessPreflight.checkGenericPassword(service: label.service, account: label.account) {
+            case .interactionRequired:
+                sawDenied = true
+                continue
+            case .allowed, .notFound, .failure:
+                break
+            }
+
+            if let password = self.safeStoragePassword(service: label.service, account: label.account) {
+                keys.append(self.deriveKey(from: password))
+            }
+        }
+
+        if !keys.isEmpty {
+            return keys
+        }
+        if sawDenied {
+            throw ImportError.keychainDenied(browser: browser)
+        }
+        throw ImportError.keyUnavailable(browser: browser)
+    }
+
+    private static func safeStoragePassword(service: String, account: String) -> String? {
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: service,
+            kSecAttrAccount as String: account,
+            kSecMatchLimit as String: kSecMatchLimitOne,
+            kSecReturnData as String: true,
+        ]
+
+        var result: AnyObject?
+        let status = SecItemCopyMatching(query as CFDictionary, &result)
+        guard status == errSecSuccess, let data = result as? Data else { return nil }
+        return String(data: data, encoding: .utf8)
+    }
+
+    private static func deriveKey(from password: String) -> Data {
+        let salt = Data("saltysalt".utf8)
+        var key = Data(count: kCCKeySizeAES128)
+        let keyLength = key.count
+        _ = key.withUnsafeMutableBytes { keyBytes in
+            password.utf8CString.withUnsafeBytes { passBytes in
+                salt.withUnsafeBytes { saltBytes in
+                    CCKeyDerivationPBKDF(
+                        CCPBKDFAlgorithm(kCCPBKDF2),
+                        passBytes.bindMemory(to: Int8.self).baseAddress,
+                        passBytes.count - 1,
+                        saltBytes.bindMemory(to: UInt8.self).baseAddress,
+                        salt.count,
+                        CCPseudoRandomAlgorithm(kCCPRFHmacAlgSHA1),
+                        1003,
+                        keyBytes.bindMemory(to: UInt8.self).baseAddress,
+                        keyLength)
+                }
+            }
+        }
+        return key
+    }
+
+    private static func decrypt(_ encryptedValue: Data, usingAnyOf keys: [Data]) -> String? {
+        for key in keys {
+            if let value = self.decrypt(encryptedValue, key: key) {
+                return value
+            }
+        }
+        return nil
+    }
+
+    private static func decrypt(_ encryptedValue: Data, key: Data) -> String? {
+        guard encryptedValue.count > 3 else { return nil }
+        let prefix = String(data: encryptedValue.prefix(3), encoding: .utf8)
+        guard prefix == "v10" else { return nil }
+
+        let payload = Data(encryptedValue.dropFirst(3))
+        let iv = Data(repeating: 0x20, count: kCCBlockSizeAES128)
+        var outLength = 0
+        var out = Data(count: payload.count + kCCBlockSizeAES128)
+        let outCapacity = out.count
+
+        let status = out.withUnsafeMutableBytes { outBytes in
+            payload.withUnsafeBytes { payloadBytes in
+                key.withUnsafeBytes { keyBytes in
+                    iv.withUnsafeBytes { ivBytes in
+                        CCCrypt(
+                            CCOperation(kCCDecrypt),
+                            CCAlgorithm(kCCAlgorithmAES),
+                            CCOptions(kCCOptionPKCS7Padding),
+                            keyBytes.baseAddress,
+                            key.count,
+                            ivBytes.baseAddress,
+                            payloadBytes.baseAddress,
+                            payload.count,
+                            outBytes.baseAddress,
+                            outCapacity,
+                            &outLength)
+                    }
+                }
+            }
+        }
+
+        guard status == kCCSuccess else { return nil }
+        out.count = outLength
+
+        if let value = String(data: out, encoding: .utf8), !value.isEmpty {
+            return value
+        }
+        if out.count > 32 {
+            let trimmed = out.dropFirst(32)
+            if let value = String(data: trimmed, encoding: .utf8), !value.isEmpty {
+                return value
+            }
+        }
+        return nil
+    }
+
+    private static func makeCookie(from record: ChromiumCookieRecord) -> HTTPCookie? {
+        var properties: [HTTPCookiePropertyKey: Any] = [
+            .domain: record.domain,
+            .path: record.path,
+            .name: record.name,
+            .value: record.value,
+        ]
+        if record.isSecure {
+            properties[.secure] = true
+        }
+        if let expires = record.expires {
+            properties[.expires] = expires
+        }
+        return HTTPCookie(properties: properties)
+    }
+
+    private static func readText(_ stmt: OpaquePointer?, index: Int32) -> String? {
+        guard sqlite3_column_type(stmt, index) != SQLITE_NULL,
+              let value = sqlite3_column_text(stmt, index)
+        else {
+            return nil
+        }
+        return String(cString: value)
+    }
+
+    private static func readBlob(_ stmt: OpaquePointer?, index: Int32) -> Data? {
+        guard sqlite3_column_type(stmt, index) != SQLITE_NULL,
+              let bytes = sqlite3_column_blob(stmt, index)
+        else {
+            return nil
+        }
+        return Data(bytes: bytes, count: Int(sqlite3_column_bytes(stmt, index)))
+    }
+
+    private static func matches(domain: String, patterns: [String]) -> Bool {
+        AlibabaCodingPlanCookieImporter.matchesCookieDomain(domain, patterns: patterns)
+    }
+
+    private static func chromiumExpiry(_ expiresUTC: Int64) -> Date? {
+        guard expiresUTC > 0 else { return nil }
+        let seconds = (Double(expiresUTC) / 1_000_000.0) - 11_644_473_600.0
+        guard seconds > 0 else { return nil }
+        return Date(timeIntervalSince1970: seconds)
+    }
+}
+#endif
diff --git a/Sources/CodexBarCore/Providers/Alibaba/AlibabaCodingPlanProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Alibaba/AlibabaCodingPlanProviderDescriptor.swift
new file mode 100644
index 0000000000..39586646b3
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Alibaba/AlibabaCodingPlanProviderDescriptor.swift
@@ -0,0 +1,266 @@
+import Foundation
+
+#if os(macOS)
+import SweetCookieKit
+#endif
+
+public enum AlibabaCodingPlanProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
+    static func makeDescriptor() -> ProviderDescriptor {
+        #if os(macOS)
+        let browserOrder: BrowserCookieImportOrder = [
+            .chrome,
+            .chromeBeta,
+            .brave,
+            .edge,
+            .arc,
+            .firefox,
+            .safari,
+        ]
+        #else
+        let browserOrder: BrowserCookieImportOrder? = nil
+        #endif
+
+        return ProviderDescriptor(
+            id: .alibaba,
+            metadata: ProviderMetadata(
+                id: .alibaba,
+                displayName: "Alibaba",
+                sessionLabel: "5-hour",
+                weeklyLabel: "Weekly",
+                opusLabel: "Monthly",
+                supportsOpus: true,
+                supportsCredits: false,
+                creditsHint: "",
+                toggleTitle: "Show Alibaba usage",
+                cliName: "alibaba-coding-plan",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                browserCookieOrder: browserOrder,
+                dashboardURL: AlibabaCodingPlanAPIRegion.international.dashboardURL.absoluteString,
+                statusPageURL: nil,
+                statusLinkURL: "https://status.aliyun.com"),
+            branding: ProviderBranding(
+                iconStyle: .alibaba,
+                iconResourceName: "ProviderIcon-alibaba",
+                color: ProviderColor(red: 1.0, green: 106 / 255, blue: 0)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "Alibaba Coding Plan cost summary is not supported." }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .web, .api],
+                pipeline: ProviderFetchPipeline(resolveStrategies: self.resolveStrategies)),
+            cli: ProviderCLIConfig(
+                name: "alibaba-coding-plan",
+                aliases: ["alibaba", "bailian"],
+                versionDetector: nil))
+    }
+
+    private static func resolveStrategies(context: ProviderFetchContext) async -> [any ProviderFetchStrategy] {
+        switch context.sourceMode {
+        case .web:
+            return [AlibabaCodingPlanWebFetchStrategy()]
+        case .api:
+            return [AlibabaCodingPlanAPIFetchStrategy()]
+        case .cli, .oauth:
+            return []
+        case .auto:
+            break
+        }
+
+        if context.settings?.alibaba?.cookieSource == .off {
+            return [AlibabaCodingPlanAPIFetchStrategy()]
+        }
+
+        return [AlibabaCodingPlanWebFetchStrategy(), AlibabaCodingPlanAPIFetchStrategy()]
+    }
+}
+
+struct AlibabaCodingPlanWebFetchStrategy: ProviderFetchStrategy {
+    let id: String = "alibaba-coding-plan.web"
+    let kind: ProviderFetchKind = .web
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        guard context.settings?.alibaba?.cookieSource != .off else { return false }
+
+        if AlibabaCodingPlanSettingsReader.cookieHeader(environment: context.env) != nil {
+            return true
+        }
+
+        if let settings = context.settings?.alibaba,
+           settings.cookieSource == .manual
+        {
+            return CookieHeaderNormalizer.normalize(settings.manualCookieHeader) != nil
+        }
+
+        #if os(macOS)
+        if let cached = CookieHeaderCache.load(provider: .alibaba),
+           !cached.cookieHeader.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+        {
+            return true
+        }
+        if AlibabaCodingPlanCookieImporter.hasSession(browserDetection: context.browserDetection) {
+            return true
+        }
+        return false
+        #else
+        return false
+        #endif
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        let cookieSource = context.settings?.alibaba?.cookieSource ?? .auto
+        let cookieHeader = try Self.resolveCookieHeader(context: context, allowCached: true)
+        do {
+            let region = context.settings?.alibaba?.apiRegion ?? .international
+            let usage = try await AlibabaCodingPlanUsageFetcher.fetchUsage(
+                cookieHeader: cookieHeader,
+                region: region,
+                environment: context.env)
+            return self.makeResult(usage: usage.toUsageSnapshot(), sourceLabel: "web")
+        } catch let error as AlibabaCodingPlanUsageError
+            where (error == .invalidCredentials || error == .loginRequired) && cookieSource != .manual
+        {
+            #if os(macOS)
+            CookieHeaderCache.clear(provider: .alibaba)
+            let refreshedHeader = try Self.resolveCookieHeader(context: context, allowCached: false)
+            let region = context.settings?.alibaba?.apiRegion ?? .international
+            let usage = try await AlibabaCodingPlanUsageFetcher.fetchUsage(
+                cookieHeader: refreshedHeader,
+                region: region,
+                environment: context.env)
+            return self.makeResult(usage: usage.toUsageSnapshot(), sourceLabel: "web")
+            #else
+            throw AlibabaCodingPlanUsageError.invalidCredentials
+            #endif
+        }
+    }
+
+    func shouldFallback(on error: Error, context: ProviderFetchContext) -> Bool {
+        guard context.sourceMode == .auto else { return false }
+
+        if let urlError = error as? URLError {
+            switch urlError.code {
+            case .timedOut,
+                 .cannotFindHost,
+                 .cannotConnectToHost,
+                 .networkConnectionLost,
+                 .dnsLookupFailed,
+                 .secureConnectionFailed,
+                 .serverCertificateHasBadDate,
+                 .serverCertificateUntrusted,
+                 .serverCertificateHasUnknownRoot,
+                 .serverCertificateNotYetValid,
+                 .clientCertificateRejected,
+                 .clientCertificateRequired,
+                 .cannotLoadFromNetwork,
+                 .internationalRoamingOff,
+                 .callIsActive,
+                 .dataNotAllowed,
+                 .requestBodyStreamExhausted,
+                 .resourceUnavailable,
+                 .notConnectedToInternet:
+                return true
+            default:
+                break
+            }
+        }
+
+        if let settingsError = error as? AlibabaCodingPlanSettingsError {
+            switch settingsError {
+            case .missingCookie, .invalidCookie:
+                return true
+            case .missingToken:
+                return false
+            }
+        }
+
+        guard let alibabaError = error as? AlibabaCodingPlanUsageError else { return false }
+        switch alibabaError {
+        case .loginRequired:
+            return true
+        case .invalidCredentials:
+            return true
+        case .apiKeyUnavailableInRegion:
+            return false
+        case let .apiError(message):
+            return message.contains("HTTP 404") || message.contains("HTTP 403")
+        case .networkError:
+            return true
+        case .parseFailed:
+            return false
+        }
+    }
+
+    static func resolveCookieHeader(context: ProviderFetchContext, allowCached: Bool) throws -> String {
+        if let settings = context.settings?.alibaba,
+           settings.cookieSource == .manual
+        {
+            guard let header = CookieHeaderNormalizer.normalize(settings.manualCookieHeader) else {
+                throw AlibabaCodingPlanSettingsError.invalidCookie
+            }
+            return header
+        }
+
+        if let envCookie = AlibabaCodingPlanSettingsReader.cookieHeader(environment: context.env),
+           let normalized = CookieHeaderNormalizer.normalize(envCookie)
+        {
+            return normalized
+        }
+
+        #if os(macOS)
+        if allowCached,
+           let cached = CookieHeaderCache.load(provider: .alibaba),
+           !cached.cookieHeader.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+        {
+            return cached.cookieHeader
+        }
+
+        do {
+            let session = try AlibabaCodingPlanCookieImporter.importSession(browserDetection: context.browserDetection)
+            CookieHeaderCache.store(
+                provider: .alibaba,
+                cookieHeader: session.cookieHeader,
+                sourceLabel: session.sourceLabel)
+            return session.cookieHeader
+        } catch {
+            throw error
+        }
+        #else
+        throw AlibabaCodingPlanSettingsError.missingCookie()
+        #endif
+    }
+}
+
+struct AlibabaCodingPlanAPIFetchStrategy: ProviderFetchStrategy {
+    let id: String = "alibaba-coding-plan.api"
+    let kind: ProviderFetchKind = .apiToken
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        Self.resolveToken(environment: context.env) != nil
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        guard let apiKey = Self.resolveToken(environment: context.env) else {
+            throw AlibabaCodingPlanSettingsError.missingToken
+        }
+        let region = context.settings?.alibaba?.apiRegion ?? .international
+        let usage = try await AlibabaCodingPlanUsageFetcher.fetchUsage(
+            apiKey: apiKey,
+            region: region,
+            environment: context.env)
+        return self.makeResult(
+            usage: usage.toUsageSnapshot(),
+            sourceLabel: "api")
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+
+    private static func resolveToken(environment: [String: String]) -> String? {
+        ProviderTokenResolver.alibabaToken(environment: environment)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Alibaba/AlibabaCodingPlanSettingsReader.swift b/Sources/CodexBarCore/Providers/Alibaba/AlibabaCodingPlanSettingsReader.swift
new file mode 100644
index 0000000000..c0824774eb
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Alibaba/AlibabaCodingPlanSettingsReader.swift
@@ -0,0 +1,118 @@
+import Foundation
+
+public struct AlibabaCodingPlanSettingsReader: Sendable {
+    private static let endpointValidator = ProviderEndpointOverrideValidator(
+        allowedHosts: [
+            "modelstudio.console.alibabacloud.com",
+            "bailian-singapore-cs.alibabacloud.com",
+            "bailian.console.aliyun.com",
+            "bailian-cs.console.aliyun.com",
+            "bailian-beijing-cs.aliyuncs.com",
+        ])
+
+    public static let apiTokenKey = "ALIBABA_CODING_PLAN_API_KEY"
+    public static let qwenAPITokenKey = "ALIBABA_QWEN_API_KEY"
+    public static let dashScopeAPITokenKey = "DASHSCOPE_API_KEY"
+    public static let apiTokenEnvironmentKeys = [
+        Self.apiTokenKey,
+        Self.qwenAPITokenKey,
+        Self.dashScopeAPITokenKey,
+    ]
+    public static let cookieHeaderKey = "ALIBABA_CODING_PLAN_COOKIE"
+    public static let hostKey = "ALIBABA_CODING_PLAN_HOST"
+    public static let quotaURLKey = "ALIBABA_CODING_PLAN_QUOTA_URL"
+    public static let requireProviderEndpointOverridesKey = "ALIBABA_CODING_PLAN_REQUIRE_PROVIDER_ENDPOINT_OVERRIDES"
+    private static let endpointOverrideKeys = [
+        Self.hostKey,
+        Self.quotaURLKey,
+    ]
+
+    public static func apiToken(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        for key in self.apiTokenEnvironmentKeys {
+            if let token = self.cleaned(environment[key]) { return token }
+        }
+        return nil
+    }
+
+    public static func hostOverride(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.endpointValidator.validatedHost(
+            self.cleaned(environment[self.hostKey]),
+            policy: self.endpointOverrideHostPolicy(environment: environment))
+    }
+
+    public static func rejectedEndpointOverrideKey(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        let policy = self.endpointOverrideHostPolicy(environment: environment)
+        return self.endpointOverrideKeys.first { key in
+            guard let value = self.cleaned(environment[key]) else { return false }
+            if key == Self.hostKey {
+                return self.endpointValidator.validatedHost(value, policy: policy) == nil
+            }
+            return self.endpointValidator.validatedURL(value, policy: policy) == nil
+        }
+    }
+
+    public static func cookieHeader(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.cleaned(environment[self.cookieHeaderKey])
+    }
+
+    public static func quotaURL(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> URL?
+    {
+        self.endpointValidator.validatedURL(
+            self.cleaned(environment[self.quotaURLKey]),
+            policy: self.endpointOverrideHostPolicy(environment: environment))
+    }
+
+    static func endpointOverrideHostPolicy(environment: [String: String]) -> ProviderEndpointOverrideValidator
+    .HostPolicy {
+        guard let value = self.cleaned(environment[self.requireProviderEndpointOverridesKey])?.lowercased(),
+              ["1", "true", "yes", "on"].contains(value)
+        else { return .allowAnyHTTPSHost }
+        return .providerOwnedOnly
+    }
+
+    static func cleaned(_ raw: String?) -> String? {
+        guard var value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
+            return nil
+        }
+
+        if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
+            (value.hasPrefix("'") && value.hasSuffix("'"))
+        {
+            value = String(value.dropFirst().dropLast())
+        }
+
+        value = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        return value.isEmpty ? nil : value
+    }
+}
+
+public enum AlibabaCodingPlanSettingsError: LocalizedError, Sendable {
+    case missingToken
+    case missingCookie(details: String? = nil)
+    case invalidCookie
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingToken:
+            return "Alibaba Coding Plan API key not found. " +
+                "Set apiKey in ~/.codexbar/config.json, ALIBABA_CODING_PLAN_API_KEY, " +
+                "ALIBABA_QWEN_API_KEY, or DASHSCOPE_API_KEY."
+        case let .missingCookie(details):
+            let base = "No Alibaba Coding Plan session cookies found in browsers. " +
+                "If you use Safari, enable Full Disk Access for CodexBar/Terminal or paste a manual Cookie header."
+            guard let details, !details.isEmpty else { return base }
+            return "\(base) \(details)"
+        case .invalidCookie:
+            return "Alibaba Coding Plan cookie header is invalid."
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Alibaba/AlibabaCodingPlanUsageFetcher.swift b/Sources/CodexBarCore/Providers/Alibaba/AlibabaCodingPlanUsageFetcher.swift
new file mode 100644
index 0000000000..2eb7918ee9
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Alibaba/AlibabaCodingPlanUsageFetcher.swift
@@ -0,0 +1,1121 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+// swiftlint:disable type_body_length
+public struct AlibabaCodingPlanUsageFetcher: Sendable {
+    private static let log = CodexBarLog.logger("alibaba-coding-plan")
+    private static let browserLikeUserAgent =
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) " +
+        "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36"
+    private static let safariLikeUserAgent =
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) " +
+        "AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1.15"
+
+    enum AuthMode {
+        case apiKey
+        case webSession
+    }
+
+    public static func fetchUsage(
+        apiKey: String,
+        region: AlibabaCodingPlanAPIRegion = .international,
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        now: Date = Date(),
+        transport: any ProviderHTTPTransport = ProviderHTTPClient.shared) async throws -> AlibabaCodingPlanUsageSnapshot
+    {
+        let cleanedKey = apiKey.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !cleanedKey.isEmpty else {
+            throw AlibabaCodingPlanUsageError.invalidCredentials
+        }
+        if let rejectedKey = AlibabaCodingPlanSettingsReader.rejectedEndpointOverrideKey(environment: environment) {
+            throw ProviderEndpointOverrideError.alibabaCodingPlan(rejectedKey)
+        }
+
+        if region != .international {
+            return try await self.fetchUsageOnce(
+                apiKey: cleanedKey,
+                region: region,
+                environment: environment,
+                now: now,
+                transport: transport)
+        }
+
+        do {
+            return try await self.fetchUsageOnce(
+                apiKey: cleanedKey,
+                region: .international,
+                environment: environment,
+                now: now,
+                transport: transport)
+        } catch let error as AlibabaCodingPlanUsageError {
+            guard error.shouldRetryOnAlternateRegion else { throw error }
+            Self.log.debug("Alibaba Coding Plan request failed on intl host; retrying cn host")
+            return try await self.fetchUsageOnce(
+                apiKey: cleanedKey,
+                region: .chinaMainland,
+                environment: environment,
+                now: now,
+                transport: transport)
+        }
+    }
+
+    public static func fetchUsage(
+        cookieHeader: String,
+        region: AlibabaCodingPlanAPIRegion = .international,
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        now: Date = Date(),
+        transport: any ProviderHTTPTransport = ProviderHTTPClient.shared) async throws -> AlibabaCodingPlanUsageSnapshot
+    {
+        guard let normalizedCookie = CookieHeaderNormalizer.normalize(cookieHeader) else {
+            throw AlibabaCodingPlanSettingsError.invalidCookie
+        }
+        if let rejectedKey = AlibabaCodingPlanSettingsReader.rejectedEndpointOverrideKey(environment: environment) {
+            throw ProviderEndpointOverrideError.alibabaCodingPlan(rejectedKey)
+        }
+
+        if region != .international {
+            return try await self.fetchUsageOnce(
+                cookieHeader: normalizedCookie,
+                region: region,
+                environment: environment,
+                now: now,
+                transport: transport)
+        }
+
+        do {
+            return try await self.fetchUsageOnce(
+                cookieHeader: normalizedCookie,
+                region: .international,
+                environment: environment,
+                now: now,
+                transport: transport)
+        } catch let error as AlibabaCodingPlanUsageError {
+            guard error.shouldRetryOnAlternateRegion else { throw error }
+            Self.log.debug("Alibaba Coding Plan cookie request failed on intl host; retrying cn host")
+            return try await self.fetchUsageOnce(
+                cookieHeader: normalizedCookie,
+                region: .chinaMainland,
+                environment: environment,
+                now: now,
+                transport: transport)
+        }
+    }
+
+    private static func fetchUsageOnce(
+        apiKey: String,
+        region: AlibabaCodingPlanAPIRegion,
+        environment: [String: String],
+        now: Date,
+        transport: any ProviderHTTPTransport) async throws -> AlibabaCodingPlanUsageSnapshot
+    {
+        let url = self.resolveQuotaURL(region: region, environment: environment)
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.httpBody = self.queryCodingPlanAPIRequestBody(region: region)
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
+        request.setValue(apiKey, forHTTPHeaderField: "x-api-key")
+        request.setValue(apiKey, forHTTPHeaderField: "X-DashScope-API-Key")
+        request.setValue(Self.browserLikeUserAgent, forHTTPHeaderField: "User-Agent")
+        request.setValue(region.gatewayBaseURLString, forHTTPHeaderField: "Origin")
+        request.setValue(region.dashboardURL.absoluteString, forHTTPHeaderField: "Referer")
+
+        let response = try await transport.response(for: request)
+        let data = response.data
+        guard response.statusCode == 200 else {
+            if response.statusCode == 401 || response.statusCode == 403 {
+                throw AlibabaCodingPlanUsageError.invalidCredentials
+            }
+            let body = String(data: data, encoding: .utf8) ?? ""
+            Self.log.error("Alibaba Coding Plan returned \(response.statusCode): \(body)")
+            throw AlibabaCodingPlanUsageError.apiError("HTTP \(response.statusCode)")
+        }
+
+        return try self.parseUsageSnapshot(from: data, now: now, authMode: .apiKey)
+    }
+
+    private static func fetchUsageOnce(
+        cookieHeader: String,
+        region: AlibabaCodingPlanAPIRegion,
+        environment: [String: String],
+        now: Date,
+        transport: any ProviderHTTPTransport) async throws -> AlibabaCodingPlanUsageSnapshot
+    {
+        let url = self.resolveConsoleQuotaURL(region: region, environment: environment)
+        let secToken = try await self.resolveConsoleSECToken(
+            cookieHeader: cookieHeader,
+            region: region,
+            environment: environment,
+            transport: transport)
+        let anonymousID = self.extractCookieValue(name: "cna", from: cookieHeader)
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.httpBody = self.queryCodingPlanConsoleRequestBody(
+            region: region,
+            secToken: secToken,
+            anonymousID: anonymousID)
+        request.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
+        request.setValue("*/*", forHTTPHeaderField: "Accept")
+        request.setValue(cookieHeader, forHTTPHeaderField: "Cookie")
+        if let csrf = self.extractCookieValue(name: "login_aliyunid_csrf", from: cookieHeader) ??
+            self.extractCookieValue(name: "csrf", from: cookieHeader)
+        {
+            request.setValue(csrf, forHTTPHeaderField: "x-xsrf-token")
+            request.setValue(csrf, forHTTPHeaderField: "x-csrf-token")
+        }
+        request.setValue("XMLHttpRequest", forHTTPHeaderField: "X-Requested-With")
+        request.setValue(Self.browserLikeUserAgent, forHTTPHeaderField: "User-Agent")
+        request.setValue(region.gatewayBaseURLString, forHTTPHeaderField: "Origin")
+        request.setValue(region.consoleRefererURL.absoluteString, forHTTPHeaderField: "Referer")
+
+        let response = try await transport.response(for: request)
+        let data = response.data
+        guard response.statusCode == 200 else {
+            if response.statusCode == 401 || response.statusCode == 403 {
+                throw AlibabaCodingPlanUsageError.loginRequired
+            }
+            let body = String(data: data, encoding: .utf8) ?? ""
+            Self.log.error("Alibaba Coding Plan returned \(response.statusCode): \(body)")
+            throw AlibabaCodingPlanUsageError.apiError("HTTP \(response.statusCode)")
+        }
+
+        return try self.parseUsageSnapshot(from: data, now: now, authMode: .webSession)
+    }
+
+    private static func queryCodingPlanAPIRequestBody(region: AlibabaCodingPlanAPIRegion) -> Data {
+        let payload: [String: Any] = [
+            "queryCodingPlanInstanceInfoRequest": [
+                "commodityCode": region.commodityCode,
+            ],
+        ]
+        return (try? JSONSerialization.data(withJSONObject: payload, options: [])) ?? Data("{}".utf8)
+    }
+
+    private static func queryCodingPlanConsoleRequestBody(
+        region: AlibabaCodingPlanAPIRegion,
+        secToken: String,
+        anonymousID: String?) -> Data
+    {
+        let traceID = UUID().uuidString.lowercased()
+        var cornerstoneParam: [String: Any] = [
+            "feTraceId": traceID,
+            "feURL": region.dashboardURL.absoluteString,
+            "protocol": "V2",
+            "console": "ONE_CONSOLE",
+            "productCode": "p_efm",
+            "domain": region.consoleDomain,
+            "consoleSite": region.consoleSite,
+            "userNickName": "",
+            "userPrincipalName": "",
+            "xsp_lang": "en-US",
+        ]
+        if let anonymousID, !anonymousID.isEmpty {
+            cornerstoneParam["X-Anonymous-Id"] = anonymousID
+        }
+
+        let paramsObject: [String: Any] = [
+            "Api": region.consoleQuotaAPIName,
+            "V": "1.0",
+            "Data": [
+                "queryCodingPlanInstanceInfoRequest": [
+                    "commodityCode": region.commodityCode,
+                    "onlyLatestOne": true,
+                ],
+                "cornerstoneParam": cornerstoneParam,
+            ],
+        ]
+
+        guard let paramsData = try? JSONSerialization.data(withJSONObject: paramsObject, options: []),
+              let paramsString = String(data: paramsData, encoding: .utf8)
+        else {
+            return Data()
+        }
+
+        var components = URLComponents()
+        components.queryItems = [
+            URLQueryItem(name: "params", value: paramsString),
+            URLQueryItem(name: "region", value: region.currentRegionID),
+            URLQueryItem(name: "sec_token", value: secToken),
+        ]
+        return Data((components.percentEncodedQuery ?? "").utf8)
+    }
+
+    static func resolveConsoleQuotaURL(
+        region: AlibabaCodingPlanAPIRegion,
+        environment: [String: String]) -> URL
+    {
+        if let override = AlibabaCodingPlanSettingsReader.quotaURL(environment: environment) {
+            return override
+        }
+        if let host = AlibabaCodingPlanSettingsReader.hostOverride(environment: environment),
+           let hostURL = self.consoleURL(from: host, region: region)
+        {
+            return hostURL
+        }
+        return region.consoleRPCURL
+    }
+
+    static func resolveQuotaURL(
+        region: AlibabaCodingPlanAPIRegion,
+        environment: [String: String]) -> URL
+    {
+        if let override = AlibabaCodingPlanSettingsReader.quotaURL(environment: environment) {
+            return override
+        }
+        if let host = AlibabaCodingPlanSettingsReader.hostOverride(environment: environment),
+           let hostURL = self.url(from: host, region: region)
+        {
+            return hostURL
+        }
+        return region.quotaURL
+    }
+
+    static func resolveConsoleDashboardURL(
+        region: AlibabaCodingPlanAPIRegion,
+        environment: [String: String]) -> URL
+    {
+        if let override = AlibabaCodingPlanSettingsReader.hostOverride(environment: environment),
+           let hostURL = self.dashboardURL(from: override, region: region)
+        {
+            return hostURL
+        }
+        return region.dashboardURL
+    }
+
+    static func url(from rawHost: String, region: AlibabaCodingPlanAPIRegion) -> URL? {
+        let cleaned = AlibabaCodingPlanSettingsReader.cleaned(rawHost)
+        guard let cleaned else { return nil }
+
+        let base = ProviderEndpointOverrideValidator.normalizedHTTPSURL(from: cleaned)
+        guard let base else { return nil }
+
+        var components = URLComponents(url: base, resolvingAgainstBaseURL: false)
+        components?.path = "/data/api.json"
+        components?.queryItems = [
+            URLQueryItem(
+                name: "action",
+                value: "zeldaEasy.broadscope-bailian.codingPlan.queryCodingPlanInstanceInfoV2"),
+            URLQueryItem(name: "product", value: "broadscope-bailian"),
+            URLQueryItem(name: "api", value: "queryCodingPlanInstanceInfoV2"),
+            URLQueryItem(name: "currentRegionId", value: region.currentRegionID),
+        ]
+        return components?.url
+    }
+
+    static func consoleURL(from rawHost: String, region: AlibabaCodingPlanAPIRegion) -> URL? {
+        let cleaned = AlibabaCodingPlanSettingsReader.cleaned(rawHost)
+        guard let cleaned else { return nil }
+
+        let base = ProviderEndpointOverrideValidator.normalizedHTTPSURL(from: cleaned)
+        guard let base else { return nil }
+
+        var components = URLComponents(url: base, resolvingAgainstBaseURL: false)
+        components?.path = "/data/api.json"
+        components?.queryItems = [
+            URLQueryItem(name: "action", value: region.consoleRPCAction),
+            URLQueryItem(name: "product", value: region.consoleRPCProduct),
+            URLQueryItem(name: "api", value: region.consoleQuotaAPIName),
+            URLQueryItem(name: "_v", value: "undefined"),
+        ]
+        return components?.url
+    }
+
+    private static func resolveConsoleSECToken(
+        cookieHeader: String,
+        region: AlibabaCodingPlanAPIRegion,
+        environment: [String: String],
+        transport: any ProviderHTTPTransport) async throws -> String
+    {
+        let cookieSECToken = self.extractCookieValue(name: "sec_token", from: cookieHeader)
+
+        let dashboardURL = self.resolveConsoleDashboardURL(region: region, environment: environment)
+
+        var request = URLRequest(url: dashboardURL)
+        request.httpMethod = "GET"
+        request.setValue(cookieHeader, forHTTPHeaderField: "Cookie")
+        request.setValue(Self.safariLikeUserAgent, forHTTPHeaderField: "User-Agent")
+        request.setValue(
+            "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+            forHTTPHeaderField: "Accept")
+
+        if let response = try? await transport.response(for: request),
+           response.statusCode == 200,
+           let html = String(data: response.data, encoding: .utf8),
+           let token = self.extractConsoleSECToken(from: html),
+           !token.isEmpty
+        {
+            return token
+        }
+
+        if let token = try? await self.fetchSECTokenFromUserInfo(
+            cookieHeader: cookieHeader,
+            region: region,
+            environment: environment,
+            transport: transport)
+        {
+            return token
+        }
+
+        if let cookieSECToken, !cookieSECToken.isEmpty {
+            return cookieSECToken
+        }
+
+        throw AlibabaCodingPlanUsageError.loginRequired
+    }
+
+    static func dashboardURL(from rawHost: String, region: AlibabaCodingPlanAPIRegion) -> URL? {
+        let cleaned = AlibabaCodingPlanSettingsReader.cleaned(rawHost)
+        guard let cleaned else { return nil }
+
+        let base = ProviderEndpointOverrideValidator.normalizedHTTPSURL(from: cleaned)
+        guard let base else { return nil }
+
+        guard var components = URLComponents(url: base, resolvingAgainstBaseURL: false),
+              let dashboardComponents = URLComponents(
+                  url: region.dashboardURL,
+                  resolvingAgainstBaseURL: false)
+        else {
+            return nil
+        }
+
+        components.path = dashboardComponents.path
+        components.percentEncodedQuery = dashboardComponents.percentEncodedQuery
+        components.fragment = dashboardComponents.fragment
+        return components.url
+    }
+
+    private static func fetchSECTokenFromUserInfo(
+        cookieHeader: String,
+        region: AlibabaCodingPlanAPIRegion,
+        environment: [String: String],
+        transport: any ProviderHTTPTransport) async throws -> String?
+    {
+        let gatewayBaseURL = self.resolveConsoleGatewayBaseURL(region: region, environment: environment)
+        let userInfoURL = gatewayBaseURL.appendingPathComponent("tool/user/info.json")
+        var request = URLRequest(url: userInfoURL)
+        request.httpMethod = "GET"
+        request.setValue(cookieHeader, forHTTPHeaderField: "Cookie")
+        request.setValue(Self.safariLikeUserAgent, forHTTPHeaderField: "User-Agent")
+        request.setValue("application/json, text/plain, */*", forHTTPHeaderField: "Accept")
+        let referer = gatewayBaseURL.absoluteString.hasSuffix("/") ? gatewayBaseURL.absoluteString : gatewayBaseURL
+            .absoluteString + "/"
+        request.setValue(referer, forHTTPHeaderField: "Referer")
+
+        let response = try await transport.response(for: request)
+        guard response.statusCode == 200 else {
+            return nil
+        }
+
+        let object = try JSONSerialization.jsonObject(with: response.data, options: [])
+        let expanded = self.expandedJSON(object)
+        return self.findFirstString(forKeys: ["secToken", "sec_token"], in: expanded)
+    }
+
+    private static func resolveConsoleGatewayBaseURL(
+        region: AlibabaCodingPlanAPIRegion,
+        environment: [String: String]) -> URL
+    {
+        if let host = AlibabaCodingPlanSettingsReader.hostOverride(environment: environment),
+           let hostURL = self.baseURL(from: host)
+        {
+            return hostURL
+        }
+        return URL(string: region.gatewayBaseURLString)!
+    }
+
+    private static func baseURL(from rawHost: String) -> URL? {
+        let cleaned = AlibabaCodingPlanSettingsReader.cleaned(rawHost)
+        guard let cleaned else { return nil }
+
+        let base = ProviderEndpointOverrideValidator.normalizedHTTPSURL(from: cleaned)
+        guard let base else { return nil }
+
+        guard var components = URLComponents(url: base, resolvingAgainstBaseURL: false) else {
+            return nil
+        }
+        components.path = ""
+        components.query = nil
+        components.fragment = nil
+        return components.url
+    }
+
+    static func parseUsageSnapshot(
+        from data: Data,
+        now: Date = Date(),
+        authMode: AuthMode = .webSession) throws -> AlibabaCodingPlanUsageSnapshot
+    {
+        guard !data.isEmpty else {
+            throw AlibabaCodingPlanUsageError.parseFailed("Empty response body")
+        }
+
+        let object = try JSONSerialization.jsonObject(with: data, options: [])
+        let expanded = self.expandedJSON(object)
+        guard let dictionary = expanded as? [String: Any] else {
+            throw AlibabaCodingPlanUsageError.parseFailed("Unexpected payload")
+        }
+
+        if let statusCode = self.findFirstInt(forKeys: ["statusCode", "status_code", "code"], in: dictionary),
+           statusCode != 0,
+           statusCode != 200
+        {
+            let message = self.findFirstString(
+                forKeys: ["statusMessage", "status_msg", "message", "msg"],
+                in: dictionary)
+                ?? "status code \(statusCode)"
+            let lower = message.lowercased()
+            if statusCode == 401 || statusCode == 403 || lower.contains("api key") || lower.contains("unauthorized") {
+                throw AlibabaCodingPlanUsageError.invalidCredentials
+            }
+            throw AlibabaCodingPlanUsageError.apiError(message)
+        }
+
+        if let codeText = self.findFirstString(forKeys: ["code", "status", "statusCode"], in: dictionary) {
+            let normalizedCode = codeText.lowercased()
+            if normalizedCode.contains("needlogin") || normalizedCode.contains("login") {
+                if authMode == .apiKey {
+                    throw AlibabaCodingPlanUsageError.apiKeyUnavailableInRegion
+                }
+                throw AlibabaCodingPlanUsageError.loginRequired
+            }
+        }
+        if let messageText = self.findFirstString(forKeys: ["message", "msg", "statusMessage"], in: dictionary) {
+            let normalizedMessage = messageText.lowercased()
+            if normalizedMessage.contains("log in") || normalizedMessage.contains("login") {
+                if authMode == .apiKey {
+                    throw AlibabaCodingPlanUsageError.apiKeyUnavailableInRegion
+                }
+                throw AlibabaCodingPlanUsageError.loginRequired
+            }
+            if authMode == .apiKey,
+               normalizedMessage.contains("console session") ||
+               normalizedMessage.contains("api key mode may be unavailable")
+            {
+                throw AlibabaCodingPlanUsageError.apiKeyUnavailableInRegion
+            }
+        }
+
+        let instanceInfo = self.findActiveInstanceInfo(in: dictionary, now: now)
+        let instanceCount = self.findFirstArray(
+            forKeys: ["codingPlanInstanceInfos", "coding_plan_instance_infos"],
+            in: dictionary)?
+            .compactMap { $0 as? [String: Any] }
+            .count ?? 0
+        let shouldScopeQuotaToSelectedInstance =
+            instanceCount > 1 &&
+            (instanceInfo.map { self.activeSignalScore(in: $0, now: now) > 0 } ?? false)
+        let quota = if shouldScopeQuotaToSelectedInstance, let instanceInfo {
+            self.findQuotaInfo(in: instanceInfo)
+        } else {
+            self.findQuotaInfo(in: instanceInfo ?? [:]) ?? self.findQuotaInfo(in: dictionary)
+        }
+        guard let quota else {
+            if let fallback = self.parsePlanVisibleActiveFallback(
+                payload: dictionary,
+                instanceInfo: instanceInfo,
+                now: now)
+            {
+                return fallback
+            }
+            let diagnostics = self.payloadDiagnostics(payload: dictionary)
+            Self.log.error("Alibaba coding plan quota payload missing expected fields: \(diagnostics)")
+            throw AlibabaCodingPlanUsageError.parseFailed("Missing coding plan quota data (\(diagnostics))")
+        }
+
+        let planName = self.findPlanName(in: instanceInfo ?? [:]) ?? self.findPlanName(in: dictionary)
+
+        let snapshot = AlibabaCodingPlanUsageSnapshot(
+            planName: planName,
+            fiveHourUsedQuota: self.anyInt(for: ["per5HourUsedQuota", "perFiveHourUsedQuota"], in: quota),
+            fiveHourTotalQuota: self.anyInt(for: ["per5HourTotalQuota", "perFiveHourTotalQuota"], in: quota),
+            fiveHourNextRefreshTime: self.anyDate(
+                for: ["per5HourQuotaNextRefreshTime", "perFiveHourQuotaNextRefreshTime"],
+                in: quota),
+            weeklyUsedQuota: self.anyInt(for: ["perWeekUsedQuota"], in: quota),
+            weeklyTotalQuota: self.anyInt(for: ["perWeekTotalQuota"], in: quota),
+            weeklyNextRefreshTime: self.anyDate(for: ["perWeekQuotaNextRefreshTime"], in: quota),
+            monthlyUsedQuota: self.anyInt(for: ["perBillMonthUsedQuota", "perMonthUsedQuota"], in: quota),
+            monthlyTotalQuota: self.anyInt(for: ["perBillMonthTotalQuota", "perMonthTotalQuota"], in: quota),
+            monthlyNextRefreshTime: self.anyDate(
+                for: ["perBillMonthQuotaNextRefreshTime", "perMonthQuotaNextRefreshTime"],
+                in: quota),
+            updatedAt: now)
+
+        if snapshot.fiveHourTotalQuota == nil,
+           snapshot.weeklyTotalQuota == nil,
+           snapshot.monthlyTotalQuota == nil
+        {
+            if let fallback = self.parsePlanVisibleActiveFallback(
+                payload: dictionary,
+                instanceInfo: instanceInfo,
+                now: now)
+            {
+                return fallback
+            }
+            let diagnostics = self.payloadDiagnostics(payload: dictionary)
+            Self.log.error("Alibaba coding plan payload had no usable windows: \(diagnostics)")
+            throw AlibabaCodingPlanUsageError.parseFailed("No quota windows found in payload (\(diagnostics))")
+        }
+
+        return snapshot
+    }
+
+    private static func findPlanName(in payload: [String: Any]) -> String? {
+        if let infos = self.findFirstArray(
+            forKeys: ["codingPlanInstanceInfos", "coding_plan_instance_infos"],
+            in: payload)
+        {
+            for item in infos {
+                guard let info = item as? [String: Any] else { continue }
+                let candidates = [
+                    self.anyString(for: ["planName", "plan_name"], in: info),
+                    self.anyString(for: ["instanceName", "instance_name"], in: info),
+                    self.anyString(for: ["packageName", "package_name"], in: info),
+                ]
+                for candidate in candidates {
+                    if let candidate, !candidate.isEmpty {
+                        return candidate
+                    }
+                }
+            }
+        }
+        return self.findFirstString(forKeys: ["planName", "plan_name", "packageName", "package_name"], in: payload)
+    }
+
+    private static func findActiveInstanceInfo(in payload: [String: Any], now: Date = Date()) -> [String: Any]? {
+        guard let infos = self.findFirstArray(
+            forKeys: ["codingPlanInstanceInfos", "coding_plan_instance_infos"],
+            in: payload)
+        else {
+            return nil
+        }
+
+        var first: [String: Any]?
+        var best: [String: Any]?
+        var bestScore = Int.min
+        for item in infos {
+            guard let info = item as? [String: Any] else { continue }
+            first = first ?? info
+            let score = self.activeSignalScore(in: info, now: now)
+            if score > bestScore {
+                best = info
+                bestScore = score
+            }
+        }
+        if bestScore > 0 {
+            return best
+        }
+        return first
+    }
+
+    private static func parsePlanVisibleActiveFallback(
+        payload: [String: Any],
+        instanceInfo: [String: Any]?,
+        now: Date) -> AlibabaCodingPlanUsageSnapshot?
+    {
+        let source = instanceInfo ?? payload
+        guard self.hasPositiveActivePlanSignal(in: source, payload: payload, now: now),
+              let planName = self.findPlanName(in: source) ?? self.findPlanName(in: payload)
+        else {
+            return nil
+        }
+
+        return AlibabaCodingPlanUsageSnapshot(
+            planName: planName,
+            fiveHourUsedQuota: nil,
+            fiveHourTotalQuota: nil,
+            fiveHourNextRefreshTime: nil,
+            weeklyUsedQuota: nil,
+            weeklyTotalQuota: nil,
+            weeklyNextRefreshTime: nil,
+            monthlyUsedQuota: nil,
+            monthlyTotalQuota: nil,
+            monthlyNextRefreshTime: nil,
+            updatedAt: now)
+    }
+
+    private static func hasPositiveActivePlanSignal(
+        in source: [String: Any],
+        payload: [String: Any],
+        now: Date) -> Bool
+    {
+        if self.containsPlanInstances(in: payload) {
+            return self.activeSignalScore(in: source, now: now) > 0
+        }
+        return self.activeSignalScore(in: source, now: now) > 0 || self.activeSignalScore(in: payload, now: now) > 0
+    }
+
+    private static func containsPlanInstances(in payload: [String: Any]) -> Bool {
+        guard let infos = self.findFirstArray(
+            forKeys: ["codingPlanInstanceInfos", "coding_plan_instance_infos"],
+            in: payload)
+        else {
+            return false
+        }
+        return infos.contains { $0 is [String: Any] }
+    }
+
+    private static func activeSignalScore(in source: [String: Any], now: Date) -> Int {
+        if let status = self.anyString(for: ["status", "instanceStatus"], in: source)?.uppercased() {
+            if ["VALID", "ACTIVE"].contains(status) {
+                return 3
+            }
+            if ["EXPIRED", "INVALID", "INACTIVE", "DISABLED", "TERMINATED", "STOPPED"].contains(status) {
+                return -1
+            }
+        }
+
+        if let isActive = self.anyBool(for: ["isActive", "active"], in: source) {
+            return isActive ? 3 : -1
+        }
+
+        if let expiry = self.anyDate(for: ["endTime", "periodEndTime", "expireTime", "expirationTime"], in: source),
+           expiry.timeIntervalSince(now) > 0
+        {
+            return 1
+        }
+
+        return 0
+    }
+
+    private static func payloadDiagnostics(payload: [String: Any]) -> String {
+        let topKeys = payload.keys.sorted()
+        let dataDict = self.findFirstDictionary(forKeys: ["data", "successResponse", "success_response"], in: payload)
+        let dataKeys = dataDict?.keys.sorted() ?? []
+        let instanceInfo = self.findActiveInstanceInfo(in: payload)
+        let instanceKeys = instanceInfo?.keys.sorted() ?? []
+        let hasQuota = self.findQuotaInfo(in: payload) != nil
+        let planUsage =
+            self.anyString(for: ["planUsage", "usageRate", "usage", "usageValue"], in: instanceInfo ?? [:]) ??
+            self.findFirstString(forKeys: ["planUsage", "usageRate", "usage", "usageValue"], in: payload)
+        let compactPlanUsage = planUsage?.replacingOccurrences(of: "\n", with: " ") ?? "none"
+        let status = self.anyString(for: ["status", "instanceStatus"], in: instanceInfo ?? [:]) ?? "none"
+
+        return "topKeys=\(topKeys.joined(separator: ",")) dataKeys=\(dataKeys.joined(separator: ",")) " +
+            "instanceKeys=\(instanceKeys.joined(separator: ",")) hasQuota=\(hasQuota ? "1" : "0") " +
+            "status=\(status) planUsage=\(compactPlanUsage)"
+    }
+
+    private static func findQuotaInfo(in payload: [String: Any]) -> [String: Any]? {
+        if let direct = self.findFirstDictionary(
+            forKeys: ["codingPlanQuotaInfo", "coding_plan_quota_info"],
+            in: payload)
+        {
+            return direct
+        }
+        return self.findFirstDictionary(
+            matchingAnyKey: [
+                "per5HourUsedQuota",
+                "per5HourTotalQuota",
+                "perWeekUsedQuota",
+                "perWeekTotalQuota",
+                "perBillMonthUsedQuota",
+                "perBillMonthTotalQuota",
+            ],
+            in: payload)
+    }
+
+    private static func findFirstDictionary(forKeys keys: [String], in value: Any) -> [String: Any]? {
+        guard let dict = value as? [String: Any] else { return nil }
+        for key in keys {
+            if let nested = dict[key] as? [String: Any] {
+                return nested
+            }
+        }
+        for nestedValue in dict.values {
+            if let nested = self.findFirstDictionary(forKeys: keys, in: nestedValue) {
+                return nested
+            }
+        }
+        if let array = value as? [Any] {
+            for item in array {
+                if let nested = self.findFirstDictionary(forKeys: keys, in: item) {
+                    return nested
+                }
+            }
+        }
+        return nil
+    }
+
+    private static func findFirstDictionary(matchingAnyKey keys: [String], in value: Any) -> [String: Any]? {
+        if let dict = value as? [String: Any] {
+            if keys.contains(where: { dict[$0] != nil }) {
+                return dict
+            }
+            for nestedValue in dict.values {
+                if let nested = self.findFirstDictionary(matchingAnyKey: keys, in: nestedValue) {
+                    return nested
+                }
+            }
+            return nil
+        }
+        if let array = value as? [Any] {
+            for item in array {
+                if let nested = self.findFirstDictionary(matchingAnyKey: keys, in: item) {
+                    return nested
+                }
+            }
+        }
+        return nil
+    }
+
+    private static func findFirstArray(forKeys keys: [String], in value: Any) -> [Any]? {
+        guard let dict = value as? [String: Any] else {
+            if let array = value as? [Any] {
+                for item in array {
+                    if let found = self.findFirstArray(forKeys: keys, in: item) {
+                        return found
+                    }
+                }
+            }
+            return nil
+        }
+        for key in keys {
+            if let array = dict[key] as? [Any] {
+                return array
+            }
+        }
+        for nested in dict.values {
+            if let found = self.findFirstArray(forKeys: keys, in: nested) {
+                return found
+            }
+        }
+        return nil
+    }
+
+    private static func findFirstInt(forKeys keys: [String], in value: Any) -> Int? {
+        if let dict = value as? [String: Any] {
+            for key in keys {
+                if let parsed = self.parseInt(dict[key]) {
+                    return parsed
+                }
+            }
+            for nested in dict.values {
+                if let parsed = self.findFirstInt(forKeys: keys, in: nested) {
+                    return parsed
+                }
+            }
+            return nil
+        }
+        if let array = value as? [Any] {
+            for item in array {
+                if let parsed = self.findFirstInt(forKeys: keys, in: item) {
+                    return parsed
+                }
+            }
+        }
+        return nil
+    }
+
+    private static func findFirstString(forKeys keys: [String], in value: Any) -> String? {
+        if let dict = value as? [String: Any] {
+            for key in keys {
+                if let parsed = self.parseString(dict[key]) {
+                    return parsed
+                }
+            }
+            for nested in dict.values {
+                if let parsed = self.findFirstString(forKeys: keys, in: nested) {
+                    return parsed
+                }
+            }
+            return nil
+        }
+        if let array = value as? [Any] {
+            for item in array {
+                if let parsed = self.findFirstString(forKeys: keys, in: item) {
+                    return parsed
+                }
+            }
+        }
+        return nil
+    }
+
+    private static func findFirstDate(forKeys keys: [String], in value: Any) -> Date? {
+        if let dict = value as? [String: Any] {
+            for key in keys {
+                if let parsed = self.parseDate(dict[key]) {
+                    return parsed
+                }
+            }
+            for nested in dict.values {
+                if let parsed = self.findFirstDate(forKeys: keys, in: nested) {
+                    return parsed
+                }
+            }
+            return nil
+        }
+        if let array = value as? [Any] {
+            for item in array {
+                if let parsed = self.findFirstDate(forKeys: keys, in: item) {
+                    return parsed
+                }
+            }
+        }
+        return nil
+    }
+
+    private static func expandedJSON(_ value: Any) -> Any {
+        if let dict = value as? [String: Any] {
+            var expanded: [String: Any] = [:]
+            expanded.reserveCapacity(dict.count)
+            for (key, nested) in dict {
+                expanded[key] = self.expandedJSON(nested)
+            }
+            return expanded
+        }
+        if let array = value as? [Any] {
+            return array.map { self.expandedJSON($0) }
+        }
+        if let string = value as? String,
+           let data = string.data(using: .utf8),
+           let nested = try? JSONSerialization.jsonObject(with: data, options: []),
+           nested is [String: Any] || nested is [Any]
+        {
+            return self.expandedJSON(nested)
+        }
+        return value
+    }
+
+    private static func anyInt(for keys: [String], in dict: [String: Any]) -> Int? {
+        for key in keys {
+            if let value = self.parseInt(dict[key]) {
+                return value
+            }
+        }
+        return nil
+    }
+
+    private static func anyString(for keys: [String], in dict: [String: Any]) -> String? {
+        for key in keys {
+            if let value = self.parseString(dict[key]) {
+                return value
+            }
+        }
+        return nil
+    }
+
+    private static func anyDate(for keys: [String], in dict: [String: Any]) -> Date? {
+        for key in keys {
+            if let value = self.parseDate(dict[key]) {
+                return value
+            }
+        }
+        return nil
+    }
+
+    private static func anyPercent(for keys: [String], in dict: [String: Any]) -> Double? {
+        for key in keys {
+            if let value = self.parsePercent(dict[key]) {
+                return value
+            }
+        }
+        return nil
+    }
+
+    private static func anyBool(for keys: [String], in dict: [String: Any]) -> Bool? {
+        for key in keys {
+            if let value = self.parseBool(dict[key]) {
+                return value
+            }
+        }
+        return nil
+    }
+
+    private static func findFirstPercent(forKeys keys: [String], in value: Any) -> Double? {
+        if let dict = value as? [String: Any] {
+            for key in keys {
+                if let parsed = self.parsePercent(dict[key]) {
+                    return parsed
+                }
+            }
+            for nested in dict.values {
+                if let parsed = self.findFirstPercent(forKeys: keys, in: nested) {
+                    return parsed
+                }
+            }
+            return nil
+        }
+        if let array = value as? [Any] {
+            for item in array {
+                if let parsed = self.findFirstPercent(forKeys: keys, in: item) {
+                    return parsed
+                }
+            }
+        }
+        return nil
+    }
+
+    private static func parseDate(_ raw: Any?) -> Date? {
+        if let intValue = self.parseInt(raw) {
+            if intValue > 1_000_000_000_000 {
+                return Date(timeIntervalSince1970: TimeInterval(intValue) / 1000)
+            }
+            if intValue > 1_000_000_000 {
+                return Date(timeIntervalSince1970: TimeInterval(intValue))
+            }
+        }
+        if let string = self.parseString(raw) {
+            let formatter = ISO8601DateFormatter()
+            if let date = formatter.date(from: string) {
+                return date
+            }
+            let dateFormatter = DateFormatter()
+            dateFormatter.locale = Locale(identifier: "en_US_POSIX")
+            for format in ["yyyy-MM-dd HH:mm", "yyyy-MM-dd HH:mm:ss"] {
+                dateFormatter.dateFormat = format
+                if let date = dateFormatter.date(from: string) {
+                    return date
+                }
+            }
+        }
+        return nil
+    }
+
+    private static func parseInt(_ raw: Any?) -> Int? {
+        if let value = raw as? Int { return value }
+        if let value = raw as? Int64 { return Int(value) }
+        if let value = raw as? Double { return Int(value) }
+        if let value = raw as? NSNumber { return value.intValue }
+        if let value = raw as? String {
+            let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
+            return Int(trimmed)
+        }
+        return nil
+    }
+
+    private static func parseString(_ raw: Any?) -> String? {
+        guard let value = raw as? String else { return nil }
+        let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        return trimmed.isEmpty ? nil : trimmed
+    }
+
+    private static func parsePercent(_ raw: Any?) -> Double? {
+        if let intValue = self.parseInt(raw) {
+            return max(0, min(Double(intValue), 100))
+        }
+        guard let rawString = self.parseString(raw) else { return nil }
+        let cleaned = rawString
+            .replacingOccurrences(of: "%", with: "")
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+        guard let parsed = Double(cleaned) else { return nil }
+        return max(0, min(parsed, 100))
+    }
+
+    private static func parseBool(_ raw: Any?) -> Bool? {
+        if let value = raw as? Bool {
+            return value
+        }
+        if let number = raw as? NSNumber {
+            return number.boolValue
+        }
+        guard let string = self.parseString(raw)?.lowercased() else { return nil }
+        switch string {
+        case "true", "1", "yes", "active", "valid":
+            return true
+        case "false", "0", "no", "inactive", "invalid", "expired":
+            return false
+        default:
+            return nil
+        }
+    }
+
+    private static func matchFirstGroup(pattern: String, in text: String) -> String? {
+        guard let regex = try? NSRegularExpression(pattern: pattern, options: []) else {
+            return nil
+        }
+        let range = NSRange(text.startIndex..<text.endIndex, in: text)
+        guard let match = regex.firstMatch(in: text, options: [], range: range),
+              match.numberOfRanges > 1,
+              let valueRange = Range(match.range(at: 1), in: text)
+        else {
+            return nil
+        }
+        let value = text[valueRange].trimmingCharacters(in: .whitespacesAndNewlines)
+        return value.isEmpty ? nil : String(value)
+    }
+
+    private static func extractConsoleSECToken(from html: String) -> String? {
+        let patterns = [
+            #"SEC_TOKEN\s*:\s*\"([^\"]+)\""#,
+            #"SEC_TOKEN\s*:\s*'([^']+)'"#,
+            #"secToken\s*:\s*\"([^\"]+)\""#,
+            #"sec_token\s*:\s*\"([^\"]+)\""#,
+            #"sec_token\s*:\s*'([^']+)'"#,
+            #"\"SEC_TOKEN\"\s*:\s*\"([^\"]+)\""#,
+            #"\"sec_token\"\s*:\s*\"([^\"]+)\""#,
+        ]
+
+        for pattern in patterns {
+            if let token = self.matchFirstGroup(pattern: pattern, in: html), !token.isEmpty {
+                return token
+            }
+        }
+        return nil
+    }
+
+    private static func extractCookieValue(name: String, from cookieHeader: String) -> String? {
+        let segments = cookieHeader.split(separator: ";")
+        for segment in segments {
+            let part = segment.trimmingCharacters(in: .whitespacesAndNewlines)
+            guard let index = part.firstIndex(of: "=") else { continue }
+            let key = String(part[..<index]).trimmingCharacters(in: .whitespacesAndNewlines)
+            if key == name {
+                let value = String(part[part.index(after: index)...]).trimmingCharacters(in: .whitespacesAndNewlines)
+                return value.isEmpty ? nil : value
+            }
+        }
+        return nil
+    }
+}
+
+public enum AlibabaCodingPlanUsageError: LocalizedError, Sendable, Equatable {
+    case loginRequired
+    case invalidCredentials
+    case networkError(String)
+    case apiError(String)
+    case parseFailed(String)
+    case apiKeyUnavailableInRegion
+
+    var shouldRetryOnAlternateRegion: Bool {
+        switch self {
+        case .loginRequired:
+            true
+        case .invalidCredentials:
+            true
+        case .apiKeyUnavailableInRegion:
+            false
+        case let .apiError(message):
+            message.contains("HTTP 404") || message.contains("HTTP 403")
+        case let .parseFailed(message):
+            message.contains("Missing coding plan quota data") || message.contains("No quota windows found")
+        case .networkError:
+            false
+        }
+    }
+
+    public var errorDescription: String? {
+        switch self {
+        case .loginRequired:
+            "Alibaba Coding Plan console login is required. " +
+                "Sign in to Model Studio/Bailian in a supported browser or paste a Cookie header."
+        case .invalidCredentials:
+            "Alibaba Coding Plan API credentials are invalid or expired."
+        case .apiKeyUnavailableInRegion:
+            "Alibaba Coding Plan quota is not available through Coding Plan API keys for this account/region. " +
+                "Use cookie authentication in Settings -> Providers -> Alibaba if the Alibaba console exposes a " +
+                "compatible session, or switch regions if quota API access is available there."
+        case let .networkError(message):
+            "Alibaba Coding Plan network error: \(message)"
+        case let .apiError(message):
+            "Alibaba Coding Plan API error: \(message)"
+        case let .parseFailed(message):
+            "Failed to parse Alibaba Coding Plan response: \(message)"
+        }
+    }
+}
+
+// swiftlint:enable type_body_length
diff --git a/Sources/CodexBarCore/Providers/Alibaba/AlibabaCodingPlanUsageSnapshot.swift b/Sources/CodexBarCore/Providers/Alibaba/AlibabaCodingPlanUsageSnapshot.swift
new file mode 100644
index 0000000000..2385b9b7dc
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Alibaba/AlibabaCodingPlanUsageSnapshot.swift
@@ -0,0 +1,126 @@
+import Foundation
+
+public struct AlibabaCodingPlanUsageSnapshot: Sendable {
+    public let planName: String?
+    public let fiveHourUsedQuota: Int?
+    public let fiveHourTotalQuota: Int?
+    public let fiveHourNextRefreshTime: Date?
+    public let weeklyUsedQuota: Int?
+    public let weeklyTotalQuota: Int?
+    public let weeklyNextRefreshTime: Date?
+    public let monthlyUsedQuota: Int?
+    public let monthlyTotalQuota: Int?
+    public let monthlyNextRefreshTime: Date?
+    public let updatedAt: Date
+
+    public init(
+        planName: String?,
+        fiveHourUsedQuota: Int?,
+        fiveHourTotalQuota: Int?,
+        fiveHourNextRefreshTime: Date?,
+        weeklyUsedQuota: Int?,
+        weeklyTotalQuota: Int?,
+        weeklyNextRefreshTime: Date?,
+        monthlyUsedQuota: Int?,
+        monthlyTotalQuota: Int?,
+        monthlyNextRefreshTime: Date?,
+        updatedAt: Date)
+    {
+        self.planName = planName
+        self.fiveHourUsedQuota = fiveHourUsedQuota
+        self.fiveHourTotalQuota = fiveHourTotalQuota
+        self.fiveHourNextRefreshTime = fiveHourNextRefreshTime
+        self.weeklyUsedQuota = weeklyUsedQuota
+        self.weeklyTotalQuota = weeklyTotalQuota
+        self.weeklyNextRefreshTime = weeklyNextRefreshTime
+        self.monthlyUsedQuota = monthlyUsedQuota
+        self.monthlyTotalQuota = monthlyTotalQuota
+        self.monthlyNextRefreshTime = monthlyNextRefreshTime
+        self.updatedAt = updatedAt
+    }
+}
+
+extension AlibabaCodingPlanUsageSnapshot {
+    public func toUsageSnapshot() -> UsageSnapshot {
+        let primaryPercent = Self.usedPercent(used: self.fiveHourUsedQuota, total: self.fiveHourTotalQuota)
+        let secondaryPercent = Self.usedPercent(used: self.weeklyUsedQuota, total: self.weeklyTotalQuota)
+        let tertiaryPercent = Self.usedPercent(used: self.monthlyUsedQuota, total: self.monthlyTotalQuota)
+
+        let primary: RateWindow? = if let primaryPercent {
+            RateWindow(
+                usedPercent: primaryPercent,
+                windowMinutes: 5 * 60,
+                resetsAt: Self.normalizedFiveHourReset(
+                    self.fiveHourNextRefreshTime,
+                    updatedAt: self.updatedAt),
+                resetDescription: Self.usageDetail(used: self.fiveHourUsedQuota, total: self.fiveHourTotalQuota))
+        } else {
+            nil
+        }
+
+        let secondary: RateWindow? = if let secondaryPercent {
+            RateWindow(
+                usedPercent: secondaryPercent,
+                windowMinutes: 7 * 24 * 60,
+                resetsAt: self.weeklyNextRefreshTime,
+                resetDescription: Self.usageDetail(used: self.weeklyUsedQuota, total: self.weeklyTotalQuota))
+        } else {
+            nil
+        }
+
+        let tertiary: RateWindow? = if let tertiaryPercent {
+            RateWindow(
+                usedPercent: tertiaryPercent,
+                windowMinutes: 30 * 24 * 60,
+                resetsAt: self.monthlyNextRefreshTime,
+                resetDescription: Self.usageDetail(used: self.monthlyUsedQuota, total: self.monthlyTotalQuota))
+        } else {
+            nil
+        }
+
+        let loginMethod = self.planName?.trimmingCharacters(in: .whitespacesAndNewlines)
+        let identity = ProviderIdentitySnapshot(
+            providerID: .alibaba,
+            accountEmail: nil,
+            accountOrganization: nil,
+            loginMethod: loginMethod)
+
+        return UsageSnapshot(
+            primary: primary,
+            secondary: secondary,
+            tertiary: tertiary,
+            providerCost: nil,
+            updatedAt: self.updatedAt,
+            identity: identity)
+    }
+
+    private static func usedPercent(used: Int?, total: Int?) -> Double? {
+        guard let used, let total, total > 0 else { return nil }
+        let normalizedUsed = max(0, min(used, total))
+        return Double(normalizedUsed) / Double(total) * 100
+    }
+
+    private static func limitDescription(total: Int?, label: String) -> String? {
+        guard let total, total > 0 else { return nil }
+        return "\(total) requests / \(label)"
+    }
+
+    private static func usageDetail(used: Int?, total: Int?) -> String? {
+        guard let used, let total, total > 0 else { return nil }
+        return "\(used) / \(total) used"
+    }
+
+    private static func normalizedFiveHourReset(_ raw: Date?, updatedAt: Date) -> Date? {
+        guard let raw else { return nil }
+        if raw.timeIntervalSince(updatedAt) >= 60 {
+            return raw
+        }
+
+        let shifted = raw.addingTimeInterval(TimeInterval(5 * 60 * 60))
+        if shifted.timeIntervalSince(updatedAt) >= 60 {
+            return shifted
+        }
+
+        return updatedAt.addingTimeInterval(TimeInterval(5 * 60 * 60))
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Alibaba/AlibabaTokenPlanCookieHeader.swift b/Sources/CodexBarCore/Providers/Alibaba/AlibabaTokenPlanCookieHeader.swift
new file mode 100644
index 0000000000..11f515028c
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Alibaba/AlibabaTokenPlanCookieHeader.swift
@@ -0,0 +1,162 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+struct AlibabaTokenPlanCookieHeaders {
+    private static let cachedAPIHeaderName = "__codexbar_alibaba_token_plan_api"
+    private static let cachedDashboardHeaderName = "__codexbar_alibaba_token_plan_dashboard"
+
+    let apiCookieHeader: String
+    let dashboardCookieHeader: String
+
+    init(apiCookieHeader: String, dashboardCookieHeader: String) {
+        self.apiCookieHeader = apiCookieHeader
+        self.dashboardCookieHeader = dashboardCookieHeader
+    }
+
+    init?(singleHeader raw: String?) {
+        guard let normalized = CookieHeaderNormalizer.normalize(raw) else { return nil }
+        self.apiCookieHeader = normalized
+        self.dashboardCookieHeader = normalized
+    }
+
+    init?(cachedHeader raw: String?) {
+        var valuesByName: [String: String] = [:]
+        for pair in CookieHeaderNormalizer.pairs(from: raw ?? "") {
+            valuesByName[pair.name] = pair.value
+        }
+        if let encodedAPI = valuesByName[Self.cachedAPIHeaderName],
+           let encodedDashboard = valuesByName[Self.cachedDashboardHeaderName],
+           let apiHeader = Self.decodeCachedHeader(encodedAPI),
+           let dashboardHeader = Self.decodeCachedHeader(encodedDashboard),
+           let normalizedAPI = CookieHeaderNormalizer.normalize(apiHeader),
+           let normalizedDashboard = CookieHeaderNormalizer.normalize(dashboardHeader)
+        {
+            self.init(apiCookieHeader: normalizedAPI, dashboardCookieHeader: normalizedDashboard)
+            return
+        }
+
+        self.init(singleHeader: raw)
+    }
+
+    var cacheCookieHeader: String {
+        [
+            "\(Self.cachedAPIHeaderName)=\(Self.encodeCachedHeader(self.apiCookieHeader))",
+            "\(Self.cachedDashboardHeaderName)=\(Self.encodeCachedHeader(self.dashboardCookieHeader))",
+        ].joined(separator: "; ")
+    }
+
+    var apiCookieNames: [String] {
+        Self.cookieNames(from: self.apiCookieHeader)
+    }
+
+    var dashboardCookieNames: [String] {
+        Self.cookieNames(from: self.dashboardCookieHeader)
+    }
+
+    func hasCookie(named name: String) -> Bool {
+        Self.cookieNames(from: self.apiCookieHeader).contains(name) ||
+            Self.cookieNames(from: self.dashboardCookieHeader).contains(name)
+    }
+
+    private static func cookieNames(from header: String) -> [String] {
+        CookieHeaderNormalizer.pairs(from: header)
+            .map(\.name)
+            .filter { !$0.isEmpty }
+            .uniquedSorted()
+    }
+
+    private static func encodeCachedHeader(_ header: String) -> String {
+        Data(header.utf8).base64EncodedString()
+    }
+
+    private static func decodeCachedHeader(_ encoded: String) -> String? {
+        guard let data = Data(base64Encoded: encoded) else { return nil }
+        return String(data: data, encoding: .utf8)
+    }
+}
+
+enum AlibabaTokenPlanCookieHeader {
+    static func headers(
+        from cookies: [HTTPCookie],
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> AlibabaTokenPlanCookieHeaders?
+    {
+        guard let apiHeader = self.header(
+            from: cookies,
+            targetURL: AlibabaTokenPlanUsageFetcher.resolveQuotaURL(environment: environment)),
+            let dashboardHeader = self.header(
+                from: cookies,
+                targetURL: AlibabaTokenPlanUsageFetcher.dashboardURL(environment: environment))
+        else {
+            return nil
+        }
+        return AlibabaTokenPlanCookieHeaders(apiCookieHeader: apiHeader, dashboardCookieHeader: dashboardHeader)
+    }
+
+    static func header(from cookies: [HTTPCookie], targetURL: URL) -> String? {
+        var byName: [String: HTTPCookie] = [:]
+        for cookie in cookies {
+            guard !cookie.name.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else { continue }
+            guard !cookie.value.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else { continue }
+            if let expiry = cookie.expiresDate, expiry < Date() { continue }
+            guard self.matchesRequestURL(cookie: cookie, url: targetURL) else { continue }
+
+            if let existing = byName[cookie.name] {
+                if self.cookieSortKey(for: cookie) >= self.cookieSortKey(for: existing) {
+                    byName[cookie.name] = cookie
+                }
+            } else {
+                byName[cookie.name] = cookie
+            }
+        }
+
+        guard !byName.isEmpty else { return nil }
+        return byName.keys.sorted().compactMap { name in
+            guard let cookie = byName[name] else { return nil }
+            return "\(cookie.name)=\(cookie.value)"
+        }.joined(separator: "; ")
+    }
+
+    private static func matchesRequestURL(cookie: HTTPCookie, url: URL) -> Bool {
+        guard let host = url.host?.lowercased() else { return false }
+        let normalizedDomain = cookie.domain.lowercased().trimmingCharacters(in: CharacterSet(charactersIn: "."))
+        guard !normalizedDomain.isEmpty else { return false }
+        guard host == normalizedDomain || host.hasSuffix(".\(normalizedDomain)") else { return false }
+
+        let cookiePath = cookie.path.isEmpty ? "/" : cookie.path
+        let requestPath = url.path.isEmpty ? "/" : url.path
+        if requestPath == cookiePath {
+            return true
+        }
+        guard requestPath.hasPrefix(cookiePath) else { return false }
+        guard cookiePath != "/" else { return true }
+        if cookiePath.hasSuffix("/") {
+            return true
+        }
+        guard
+            let boundaryIndex = requestPath.index(
+                requestPath.startIndex,
+                offsetBy: cookiePath.count,
+                limitedBy: requestPath.endIndex),
+            boundaryIndex < requestPath.endIndex
+        else {
+            return true
+        }
+        return requestPath[boundaryIndex] == "/"
+    }
+
+    private static func cookieSortKey(for cookie: HTTPCookie) -> (Int, Int, Date) {
+        let pathLength = cookie.path.count
+        let normalizedDomain = cookie.domain.lowercased().trimmingCharacters(in: CharacterSet(charactersIn: "."))
+        let domainLength = normalizedDomain.count
+        let expiry = cookie.expiresDate ?? .distantPast
+        return (pathLength, domainLength, expiry)
+    }
+}
+
+extension [String] {
+    fileprivate func uniquedSorted() -> [String] {
+        Array(Set(self)).sorted()
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Alibaba/AlibabaTokenPlanProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Alibaba/AlibabaTokenPlanProviderDescriptor.swift
new file mode 100644
index 0000000000..3f47d549a2
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Alibaba/AlibabaTokenPlanProviderDescriptor.swift
@@ -0,0 +1,256 @@
+import Foundation
+
+#if os(macOS)
+import SweetCookieKit
+#endif
+
+public enum AlibabaTokenPlanProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
+    static func makeDescriptor() -> ProviderDescriptor {
+        #if os(macOS)
+        let browserOrder: BrowserCookieImportOrder = [
+            .chrome,
+            .chromeBeta,
+            .brave,
+            .edge,
+            .arc,
+            .firefox,
+            .safari,
+        ]
+        #else
+        let browserOrder: BrowserCookieImportOrder? = nil
+        #endif
+
+        return ProviderDescriptor(
+            id: .alibabatokenplan,
+            metadata: ProviderMetadata(
+                id: .alibabatokenplan,
+                displayName: "Alibaba Token Plan",
+                sessionLabel: "Credits",
+                weeklyLabel: "Usage",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "",
+                toggleTitle: "Show Alibaba Token Plan usage",
+                cliName: "alibaba-token-plan",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                browserCookieOrder: browserOrder,
+                dashboardURL: AlibabaTokenPlanUsageFetcher.dashboardURL.absoluteString,
+                statusPageURL: nil,
+                statusLinkURL: "https://status.aliyun.com"),
+            branding: ProviderBranding(
+                iconStyle: .alibaba,
+                iconResourceName: "ProviderIcon-alibaba",
+                color: ProviderColor(red: 1.0, green: 106 / 255, blue: 0)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "Alibaba Token Plan cost summary is not supported." }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .web],
+                pipeline: ProviderFetchPipeline(resolveStrategies: self.resolveStrategies)),
+            cli: ProviderCLIConfig(
+                name: "alibaba-token-plan",
+                aliases: ["alibaba-token", "bailian-token-plan"],
+                versionDetector: nil))
+    }
+
+    private static func resolveStrategies(context: ProviderFetchContext) async -> [any ProviderFetchStrategy] {
+        guard context.settings?.alibabaTokenPlan?.cookieSource != .off else { return [] }
+        switch context.sourceMode {
+        case .auto, .web:
+            return [AlibabaTokenPlanWebFetchStrategy()]
+        case .api, .cli, .oauth:
+            return []
+        }
+    }
+}
+
+struct AlibabaTokenPlanWebFetchStrategy: ProviderFetchStrategy {
+    private static let log = CodexBarLog.logger("alibaba-token-plan")
+
+    let id: String = "alibaba-token-plan.web"
+    let kind: ProviderFetchKind = .web
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        guard context.settings?.alibabaTokenPlan?.cookieSource != .off else { return false }
+
+        if AlibabaTokenPlanSettingsReader.cookieHeader(environment: context.env) != nil {
+            return true
+        }
+
+        if let settings = context.settings?.alibabaTokenPlan,
+           settings.cookieSource == .manual
+        {
+            return CookieHeaderNormalizer.normalize(settings.manualCookieHeader) != nil
+        }
+
+        #if os(macOS)
+        if let cached = CookieHeaderCache.load(provider: .alibabatokenplan),
+           !cached.cookieHeader.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+        {
+            return true
+        }
+        return true
+        #else
+        return false
+        #endif
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        let cookieSource = context.settings?.alibabaTokenPlan?.cookieSource ?? .auto
+        let cookieHeaders = try Self.resolveCookieHeaders(context: context, allowCached: true)
+        do {
+            let usage = try await AlibabaTokenPlanUsageFetcher.fetchUsage(
+                apiCookieHeader: cookieHeaders.apiCookieHeader,
+                dashboardCookieHeader: cookieHeaders.dashboardCookieHeader,
+                environment: context.env)
+            return self.makeResult(usage: usage.toUsageSnapshot(), sourceLabel: "web")
+        } catch let error as AlibabaTokenPlanUsageError
+            where error.isCredentialFailure && cookieSource != .manual
+        {
+            #if os(macOS)
+            CookieHeaderCache.clear(provider: .alibabatokenplan)
+            let refreshedHeaders = try Self.resolveCookieHeaders(context: context, allowCached: false)
+            let usage = try await AlibabaTokenPlanUsageFetcher.fetchUsage(
+                apiCookieHeader: refreshedHeaders.apiCookieHeader,
+                dashboardCookieHeader: refreshedHeaders.dashboardCookieHeader,
+                environment: context.env)
+            return self.makeResult(usage: usage.toUsageSnapshot(), sourceLabel: "web")
+            #else
+            throw error
+            #endif
+        }
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+
+    static func resolveCookieHeader(context: ProviderFetchContext, allowCached: Bool) throws -> String {
+        try self.resolveCookieHeaders(context: context, allowCached: allowCached).apiCookieHeader
+    }
+
+    static func resolveCookieHeaders(
+        context: ProviderFetchContext,
+        allowCached: Bool) throws -> AlibabaTokenPlanCookieHeaders
+    {
+        if let settings = context.settings?.alibabaTokenPlan,
+           settings.cookieSource == .manual
+        {
+            guard let headers = AlibabaTokenPlanCookieHeaders(singleHeader: settings.manualCookieHeader) else {
+                self.log.warning("Alibaba Token Plan manual cookie header is invalid")
+                throw AlibabaTokenPlanSettingsError.invalidCookie
+            }
+            Self.log.info(
+                "Alibaba Token Plan using manual cookie header",
+                metadata: [
+                    "apiCookieNames": headers.apiCookieNames.joined(separator: ","),
+                    "dashboardCookieNames": headers.dashboardCookieNames.joined(separator: ","),
+                    "hasSecToken": headers.hasCookie(named: "sec_token") ? "1" : "0",
+                ])
+            return headers
+        }
+
+        if let envCookie = AlibabaTokenPlanSettingsReader.cookieHeader(environment: context.env),
+           let headers = AlibabaTokenPlanCookieHeaders(singleHeader: envCookie)
+        {
+            Self.log.info(
+                "Alibaba Token Plan using environment cookie header",
+                metadata: [
+                    "apiCookieNames": headers.apiCookieNames.joined(separator: ","),
+                    "dashboardCookieNames": headers.dashboardCookieNames.joined(separator: ","),
+                    "hasSecToken": headers.hasCookie(named: "sec_token") ? "1" : "0",
+                ])
+            return headers
+        }
+
+        #if os(macOS)
+        if allowCached,
+           let cached = CookieHeaderCache.load(provider: .alibabatokenplan),
+           let headers = AlibabaTokenPlanCookieHeaders(cachedHeader: cached.cookieHeader)
+        {
+            Self.log.info(
+                "Alibaba Token Plan using cached browser cookie header",
+                metadata: [
+                    "source": cached.sourceLabel,
+                    "apiCookieNames": headers.apiCookieNames.joined(separator: ","),
+                    "dashboardCookieNames": headers.dashboardCookieNames.joined(separator: ","),
+                    "hasSecToken": headers.hasCookie(named: "sec_token") ? "1" : "0",
+                ])
+            return headers
+        }
+
+        do {
+            var importLog: [String] = []
+            let session = try AlibabaCodingPlanCookieImporter.importSession(
+                browserDetection: context.browserDetection,
+                logger: { importLog.append($0) })
+            let rawCookieNames = session.cookies.map(\.name).filter { !$0.isEmpty }.uniquedSorted()
+            guard let headers = AlibabaTokenPlanCookieHeader.headers(
+                from: session.cookies,
+                environment: context.env)
+            else {
+                Self.log.warning(
+                    "Alibaba Token Plan browser cookie header was empty",
+                    metadata: [
+                        "source": session.sourceLabel,
+                        "rawCookieNames": rawCookieNames.joined(separator: ","),
+                    ])
+                throw AlibabaTokenPlanSettingsError.missingCookie(
+                    details: "No Alibaba Token Plan browser cookies were available after import.")
+            }
+            CookieHeaderCache.store(
+                provider: .alibabatokenplan,
+                cookieHeader: headers.cacheCookieHeader,
+                sourceLabel: session.sourceLabel)
+            Self.log.info(
+                "Alibaba Token Plan imported browser cookies",
+                metadata: [
+                    "source": session.sourceLabel,
+                    "rawCookieNames": rawCookieNames.joined(separator: ","),
+                    "apiCookieNames": headers.apiCookieNames.joined(separator: ","),
+                    "dashboardCookieNames": headers.dashboardCookieNames.joined(separator: ","),
+                    "hasSecToken": headers.hasCookie(named: "sec_token") ? "1" : "0",
+                    "importLogLines": "\(importLog.count)",
+                ])
+            return headers
+        } catch {
+            Self.log.warning(
+                "Alibaba Token Plan cookie resolution failed",
+                metadata: ["error": error.localizedDescription])
+            throw AlibabaTokenPlanSettingsError.missingCookie(details: Self.missingCookieDetails(from: error))
+        }
+        #else
+        throw AlibabaTokenPlanSettingsError.missingCookie()
+        #endif
+    }
+
+    private static func missingCookieDetails(from error: Error) -> String? {
+        if case let AlibabaCodingPlanSettingsError.missingCookie(details) = error {
+            return details
+        }
+        let message = error.localizedDescription.trimmingCharacters(in: .whitespacesAndNewlines)
+        return message.isEmpty ? nil : message
+    }
+}
+
+extension [String] {
+    fileprivate func uniquedSorted() -> [String] {
+        Array(Set(self)).sorted()
+    }
+}
+
+extension AlibabaTokenPlanUsageError {
+    fileprivate var isCredentialFailure: Bool {
+        switch self {
+        case .loginRequired, .invalidCredentials:
+            true
+        case .apiError, .networkError, .parseFailed:
+            false
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Alibaba/AlibabaTokenPlanSettingsReader.swift b/Sources/CodexBarCore/Providers/Alibaba/AlibabaTokenPlanSettingsReader.swift
new file mode 100644
index 0000000000..8a0f6c1dad
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Alibaba/AlibabaTokenPlanSettingsReader.swift
@@ -0,0 +1,64 @@
+import Foundation
+
+public struct AlibabaTokenPlanSettingsReader: Sendable {
+    public static let cookieHeaderKey = "ALIBABA_TOKEN_PLAN_COOKIE"
+    public static let hostKey = "ALIBABA_TOKEN_PLAN_HOST"
+    public static let quotaURLKey = "ALIBABA_TOKEN_PLAN_QUOTA_URL"
+
+    public static func cookieHeader(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.cleaned(environment[self.cookieHeaderKey])
+    }
+
+    public static func hostOverride(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        guard let raw = self.cleaned(environment[self.hostKey]) else { return nil }
+        if let scheme = URL(string: raw)?.scheme {
+            return scheme.lowercased() == "https" ? raw : nil
+        }
+        return raw
+    }
+
+    public static func quotaURL(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> URL?
+    {
+        guard let raw = self.cleaned(environment[self.quotaURLKey]) else { return nil }
+        if let url = URL(string: raw), let scheme = url.scheme {
+            return scheme.lowercased() == "https" ? url : nil
+        }
+        return URL(string: "https://\(raw)")
+    }
+
+    static func cleaned(_ raw: String?) -> String? {
+        guard var value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
+            return nil
+        }
+        if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
+            (value.hasPrefix("'") && value.hasSuffix("'"))
+        {
+            value = String(value.dropFirst().dropLast())
+        }
+        value = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        return value.isEmpty ? nil : value
+    }
+}
+
+public enum AlibabaTokenPlanSettingsError: LocalizedError, Sendable {
+    case missingCookie(details: String? = nil)
+    case invalidCookie
+
+    public var errorDescription: String? {
+        switch self {
+        case let .missingCookie(details):
+            let base = "No Alibaba Token Plan session cookies found in browsers. " +
+                "Sign in to Bailian in Chrome, allow CodexBar to access Chrome Safe Storage in Keychain Access, " +
+                "or paste a manual Cookie header."
+            guard let details, !details.isEmpty else { return base }
+            return "\(base) \(details)"
+        case .invalidCookie:
+            return "Alibaba Token Plan cookie header is invalid."
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Alibaba/AlibabaTokenPlanUsageFetcher.swift b/Sources/CodexBarCore/Providers/Alibaba/AlibabaTokenPlanUsageFetcher.swift
new file mode 100644
index 0000000000..93bc5d93ab
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Alibaba/AlibabaTokenPlanUsageFetcher.swift
@@ -0,0 +1,977 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public enum AlibabaTokenPlanUsageError: LocalizedError, Sendable, Equatable {
+    case loginRequired
+    case invalidCredentials
+    case apiError(String)
+    case networkError(String)
+    case parseFailed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .loginRequired:
+            "Alibaba Token Plan login required."
+        case .invalidCredentials:
+            "Alibaba Token Plan credentials are invalid."
+        case let .apiError(message):
+            "Alibaba Token Plan API error: \(message)"
+        case let .networkError(message):
+            "Alibaba Token Plan network error: \(message)"
+        case let .parseFailed(message):
+            "Could not parse Alibaba Token Plan usage: \(message)"
+        }
+    }
+}
+
+// swiftlint:disable:next type_body_length
+public struct AlibabaTokenPlanUsageFetcher: Sendable {
+    private static let log = CodexBarLog.logger("alibaba-token-plan")
+    private static let gatewayBaseURLString = "https://bailian.console.aliyun.com"
+    private static let dashboardOriginURLString = "https://bailian.console.aliyun.com"
+    private static let currentRegionID = "cn-beijing"
+    private static let bssServiceCode = "BssOpenAPI-V3"
+    private static let subscriptionSummaryAction = "GetSubscriptionSummary"
+    private static let tokenPlanProductCode = "sfm_tokenplanteams_dp_cn"
+    private static let browserLikeUserAgent =
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) " +
+        "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36"
+    private static let safariLikeUserAgent =
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) " +
+        "AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1.15"
+
+    public static var dashboardURL: URL {
+        URL(string: "https://bailian.console.aliyun.com/cn-beijing?tab=plan#/efm/subscription/token-plan")!
+    }
+
+    public static func fetchUsage(
+        cookieHeader: String,
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        now: Date = Date()) async throws -> AlibabaTokenPlanUsageSnapshot
+    {
+        guard let headers = AlibabaTokenPlanCookieHeaders(singleHeader: cookieHeader) else {
+            throw AlibabaTokenPlanSettingsError.invalidCookie
+        }
+        return try await self.fetchUsage(
+            apiCookieHeader: headers.apiCookieHeader,
+            dashboardCookieHeader: headers.dashboardCookieHeader,
+            environment: environment,
+            now: now)
+    }
+
+    static func fetchUsage(
+        apiCookieHeader: String,
+        dashboardCookieHeader: String,
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        now: Date = Date(),
+        session overrideSession: URLSession? = nil) async throws -> AlibabaTokenPlanUsageSnapshot
+    {
+        guard let normalizedAPIHeader = CookieHeaderNormalizer.normalize(apiCookieHeader),
+              let normalizedDashboardHeader = CookieHeaderNormalizer.normalize(dashboardCookieHeader)
+        else {
+            throw AlibabaTokenPlanSettingsError.invalidCookie
+        }
+
+        let url = self.resolveQuotaURL(environment: environment)
+        let apiRedirectDiagnostics = RedirectDiagnostics(cookieHeader: normalizedAPIHeader)
+        let dashboardRedirectDiagnostics: RedirectDiagnostics?
+        let apiSession: URLSession
+        let dashboardSession: URLSession
+        if let overrideSession {
+            apiSession = overrideSession
+            dashboardSession = overrideSession
+            dashboardRedirectDiagnostics = nil
+        } else {
+            let dashboardDiagnostics = RedirectDiagnostics(cookieHeader: normalizedDashboardHeader)
+            apiSession = URLSession(
+                configuration: .default,
+                delegate: apiRedirectDiagnostics,
+                delegateQueue: nil)
+            dashboardSession = URLSession(
+                configuration: .default,
+                delegate: dashboardDiagnostics,
+                delegateQueue: nil)
+            dashboardRedirectDiagnostics = dashboardDiagnostics
+        }
+        defer {
+            if overrideSession == nil {
+                apiSession.invalidateAndCancel()
+                dashboardSession.invalidateAndCancel()
+            }
+        }
+        let secToken = await self.resolveSECToken(
+            dashboardCookieHeader: normalizedDashboardHeader,
+            apiCookieHeader: normalizedAPIHeader,
+            environment: environment,
+            session: dashboardSession)
+        Self.log.info(
+            "Fetching Alibaba Token Plan usage",
+            metadata: [
+                "apiHost": url.host ?? "unknown",
+                "apiCookieNames": self.cookieNamesDescription(from: normalizedAPIHeader),
+                "dashboardCookieNames": self.cookieNamesDescription(from: normalizedDashboardHeader),
+                "hasCSRF": self.hasCSRF(in: normalizedAPIHeader) ? "1" : "0",
+                "secTokenSource": secToken == nil ? "missing" : "resolved",
+            ])
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.timeoutInterval = 20
+        request.httpBody = self.subscriptionSummaryRequestBody(secToken: secToken)
+        request.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
+        request.setValue("*/*", forHTTPHeaderField: "Accept")
+        request.setValue(normalizedAPIHeader, forHTTPHeaderField: "Cookie")
+        if let csrf = self.extractCookieValue(name: "login_aliyunid_csrf", from: normalizedAPIHeader) ??
+            self.extractCookieValue(name: "csrf", from: normalizedAPIHeader)
+        {
+            request.setValue(csrf, forHTTPHeaderField: "x-xsrf-token")
+            request.setValue(csrf, forHTTPHeaderField: "x-csrf-token")
+        }
+        request.setValue("XMLHttpRequest", forHTTPHeaderField: "X-Requested-With")
+        request.setValue(Self.browserLikeUserAgent, forHTTPHeaderField: "User-Agent")
+        request.setValue(Self.dashboardOriginURLString, forHTTPHeaderField: "Origin")
+        request.setValue(Self.dashboardURL.absoluteString, forHTTPHeaderField: "Referer")
+
+        let data: Data
+        let response: URLResponse
+        do {
+            (data, response) = try await apiSession.data(for: request)
+        } catch {
+            Self.log.error(
+                "Alibaba Token Plan request failed",
+                metadata: [
+                    "apiHost": url.host ?? "unknown",
+                    "error": error.localizedDescription,
+                ])
+            throw AlibabaTokenPlanUsageError.networkError(error.localizedDescription)
+        }
+        if let dashboardRedirectDiagnostics, !dashboardRedirectDiagnostics.redirects.isEmpty {
+            Self.log.info(
+                "Alibaba Token Plan dashboard redirects",
+                metadata: [
+                    "count": "\(dashboardRedirectDiagnostics.redirects.count)",
+                    "items": dashboardRedirectDiagnostics.redirects.joined(separator: " | "),
+                ])
+        }
+        if !apiRedirectDiagnostics.redirects.isEmpty {
+            Self.log.info(
+                "Alibaba Token Plan redirects",
+                metadata: [
+                    "count": "\(apiRedirectDiagnostics.redirects.count)",
+                    "items": apiRedirectDiagnostics.redirects.joined(separator: " | "),
+                ])
+        }
+        guard let httpResponse = response as? HTTPURLResponse else {
+            Self.log.error("Alibaba Token Plan response was not HTTP")
+            throw AlibabaTokenPlanUsageError.networkError("Invalid response")
+        }
+        Self.log.info(
+            "Alibaba Token Plan HTTP response",
+            metadata: [
+                "status": "\(httpResponse.statusCode)",
+                "bodyBytes": "\(data.count)",
+                "contentType": httpResponse.value(forHTTPHeaderField: "Content-Type") ?? "none",
+            ])
+        guard httpResponse.statusCode == 200 else {
+            if httpResponse.statusCode == 401 || httpResponse.statusCode == 403 {
+                throw AlibabaTokenPlanUsageError.loginRequired
+            }
+            Self.log.error("Alibaba Token Plan returned HTTP \(httpResponse.statusCode)")
+            throw AlibabaTokenPlanUsageError.apiError("HTTP \(httpResponse.statusCode)")
+        }
+
+        return try self.parseUsageSnapshot(from: data, now: now)
+    }
+
+    static func resolveQuotaURL(environment: [String: String]) -> URL {
+        if let override = AlibabaTokenPlanSettingsReader.quotaURL(environment: environment) {
+            return override
+        }
+        if let host = AlibabaTokenPlanSettingsReader.hostOverride(environment: environment),
+           let hostURL = self.quotaURL(from: host)
+        {
+            return hostURL
+        }
+        return self.defaultQuotaURL
+    }
+
+    static var defaultQuotaURL: URL {
+        var components = URLComponents(string: Self.gatewayBaseURLString)!
+        components.path = "/data/api.json"
+        components.queryItems = [
+            URLQueryItem(name: "action", value: Self.subscriptionSummaryAction),
+            URLQueryItem(name: "product", value: Self.bssServiceCode),
+            URLQueryItem(name: "_tag", value: ""),
+        ]
+        return components.url!
+    }
+
+    static func parseUsageSnapshot(from data: Data, now: Date = Date()) throws -> AlibabaTokenPlanUsageSnapshot {
+        guard !data.isEmpty else {
+            throw AlibabaTokenPlanUsageError.parseFailed("Empty response body")
+        }
+
+        let object: Any
+        do {
+            object = try JSONSerialization.jsonObject(with: data, options: [])
+        } catch {
+            if self.isLikelyLoginHTML(data) {
+                throw AlibabaTokenPlanUsageError.loginRequired
+            }
+            throw AlibabaTokenPlanUsageError.parseFailed("Invalid JSON response")
+        }
+        let expanded = self.expandedJSON(object)
+        guard let dictionary = expanded as? [String: Any] else {
+            throw AlibabaTokenPlanUsageError.parseFailed("Unexpected payload")
+        }
+
+        try self.throwIfErrorPayload(dictionary)
+
+        let summary = self.findSubscriptionSummary(in: dictionary) ?? dictionary
+        let total = self.anyDouble(for: Self.totalQuotaKeys, in: summary)
+        let remaining = self.anyDouble(for: Self.remainingQuotaKeys, in: summary)
+        let used = self.anyDouble(for: Self.usedQuotaKeys, in: summary) ??
+            total.flatMap { total in remaining.map { max(0, total - $0) } }
+        let resetsAt = self.findResetDate(in: summary) ?? self.findResetDate(in: dictionary)
+        let totalCount = self.anyDouble(for: Self.subscriptionCountKeys, in: summary)
+        let planName = self.findPlanName(in: summary) ?? ((totalCount ?? 0) > 0 || total != nil ? "TOKEN PLAN" : nil)
+
+        if planName == nil, total == nil, used == nil, remaining == nil, totalCount == nil {
+            let diagnostics = self.payloadDiagnostics(payload: dictionary)
+            Self.log.error("Alibaba Token Plan payload missing expected fields: \(diagnostics)")
+            throw AlibabaTokenPlanUsageError.parseFailed("Missing token plan data (\(diagnostics))")
+        }
+
+        return AlibabaTokenPlanUsageSnapshot(
+            planName: planName,
+            usedQuota: used,
+            totalQuota: total,
+            remainingQuota: remaining,
+            resetsAt: resetsAt,
+            updatedAt: now)
+    }
+
+    private static func subscriptionSummaryRequestBody(secToken: String?) -> Data {
+        let paramsObject = ["ProductCode": Self.tokenPlanProductCode]
+        guard let paramsData = try? JSONSerialization.data(withJSONObject: paramsObject, options: []),
+              let paramsString = String(data: paramsData, encoding: .utf8)
+        else {
+            return Data()
+        }
+
+        var components = URLComponents()
+        var queryItems = [
+            URLQueryItem(name: "product", value: Self.bssServiceCode),
+            URLQueryItem(name: "action", value: Self.subscriptionSummaryAction),
+            URLQueryItem(name: "params", value: paramsString),
+            URLQueryItem(name: "region", value: Self.currentRegionID),
+        ]
+        if let secToken, !secToken.isEmpty {
+            queryItems.append(URLQueryItem(name: "sec_token", value: secToken))
+        }
+        components.queryItems = queryItems
+        return Data((components.percentEncodedQuery ?? "").utf8)
+    }
+
+    private static func resolveSECToken(
+        dashboardCookieHeader: String,
+        apiCookieHeader: String,
+        environment: [String: String],
+        session: URLSession) async -> String?
+    {
+        let cookieSECToken = self.extractCookieValue(name: "sec_token", from: dashboardCookieHeader) ??
+            self.extractCookieValue(name: "sec_token", from: apiCookieHeader)
+        var request = URLRequest(url: self.dashboardURL(environment: environment))
+        request.httpMethod = "GET"
+        request.timeoutInterval = 10
+        request.setValue(dashboardCookieHeader, forHTTPHeaderField: "Cookie")
+        request.setValue(Self.safariLikeUserAgent, forHTTPHeaderField: "User-Agent")
+        request.setValue(
+            "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+            forHTTPHeaderField: "Accept")
+
+        if let (data, response) = try? await session.data(for: request),
+           let httpResponse = response as? HTTPURLResponse,
+           httpResponse.statusCode == 200,
+           let html = String(data: data, encoding: .utf8),
+           let token = self.extractSECToken(from: html)
+        {
+            Self.log.info(
+                "Resolved Alibaba Token Plan sec_token from dashboard HTML",
+                metadata: [
+                    "dashboardHost": request.url?.host ?? "unknown",
+                    "htmlBytes": "\(data.count)",
+                ])
+            return token
+        }
+
+        if let token = await self.fetchSECTokenFromUserInfo(
+            cookieHeader: dashboardCookieHeader,
+            environment: environment,
+            session: session)
+        {
+            return token
+        }
+
+        if let cookieSECToken, !cookieSECToken.isEmpty {
+            Self.log.info("Resolved Alibaba Token Plan sec_token from cookies")
+            return cookieSECToken
+        }
+
+        Self.log.info(
+            "Alibaba Token Plan sec_token missing; continuing with cookie-only request",
+            metadata: [
+                "dashboardCookieNames": self.cookieNamesDescription(from: dashboardCookieHeader),
+                "apiCookieNames": self.cookieNamesDescription(from: apiCookieHeader),
+            ])
+        return nil
+    }
+
+    private static func fetchSECTokenFromUserInfo(
+        cookieHeader: String,
+        environment: [String: String],
+        session: URLSession) async -> String?
+    {
+        let baseURL = self.consoleBaseURL(environment: environment)
+        let userInfoURL = baseURL.appendingPathComponent("tool/user/info.json")
+        var request = URLRequest(url: userInfoURL)
+        request.httpMethod = "GET"
+        request.timeoutInterval = 10
+        request.setValue(cookieHeader, forHTTPHeaderField: "Cookie")
+        request.setValue(Self.safariLikeUserAgent, forHTTPHeaderField: "User-Agent")
+        request.setValue("application/json, text/plain, */*", forHTTPHeaderField: "Accept")
+        let referer = baseURL.absoluteString.hasSuffix("/") ? baseURL.absoluteString : "\(baseURL.absoluteString)/"
+        request.setValue(referer, forHTTPHeaderField: "Referer")
+
+        guard let (data, response) = try? await session.data(for: request),
+              let httpResponse = response as? HTTPURLResponse,
+              httpResponse.statusCode == 200,
+              let object = try? JSONSerialization.jsonObject(with: data, options: [])
+        else {
+            return nil
+        }
+
+        let expanded = self.expandedJSON(object)
+        guard let token = self.findFirstString(forKeys: ["secToken", "sec_token"], in: expanded),
+              !token.isEmpty
+        else {
+            return nil
+        }
+
+        Self.log.info(
+            "Resolved Alibaba Token Plan sec_token from user info",
+            metadata: [
+                "userInfoHost": userInfoURL.host ?? "unknown",
+                "bodyBytes": "\(data.count)",
+            ])
+        return token
+    }
+
+    private static func consoleBaseURL(environment: [String: String]) -> URL {
+        let dashboard = self.dashboardURL(environment: environment)
+        var components = URLComponents()
+        components.scheme = dashboard.scheme
+        components.host = dashboard.host
+        components.port = dashboard.port
+        return components.url ?? URL(string: Self.dashboardOriginURLString)!
+    }
+
+    private static func quotaURL(from rawHost: String) -> URL? {
+        let cleaned = AlibabaTokenPlanSettingsReader.cleaned(rawHost)
+        guard let cleaned else { return nil }
+        let base = URL(string: cleaned)?.scheme == nil ? URL(string: "https://\(cleaned)") : URL(string: cleaned)
+        guard let base else { return nil }
+        var components = URLComponents(url: base, resolvingAgainstBaseURL: false)
+        let defaultComponents = URLComponents(url: Self.defaultQuotaURL, resolvingAgainstBaseURL: false)
+        components?.path = "/data/api.json"
+        components?.queryItems = defaultComponents?.queryItems
+        return components?.url
+    }
+
+    static func dashboardURL(environment: [String: String]) -> URL {
+        if let host = AlibabaTokenPlanSettingsReader.hostOverride(environment: environment),
+           let base = URL(string: host)?.scheme == nil ? URL(string: "https://\(host)") : URL(string: host),
+           var components = URLComponents(url: base, resolvingAgainstBaseURL: false),
+           let dashboardComponents = URLComponents(url: dashboardURL, resolvingAgainstBaseURL: false)
+        {
+            components.path = dashboardComponents.path
+            components.percentEncodedQuery = dashboardComponents.percentEncodedQuery
+            components.fragment = dashboardComponents.fragment
+            return components.url ?? self.dashboardURL
+        }
+        return Self.dashboardURL
+    }
+
+    private final class RedirectDiagnostics: NSObject, URLSessionTaskDelegate, @unchecked Sendable {
+        private let cookieHeader: String
+        var redirects: [String] = []
+
+        init(cookieHeader: String) {
+            self.cookieHeader = cookieHeader
+        }
+
+        func urlSession(
+            _: URLSession,
+            task _: URLSessionTask,
+            willPerformHTTPRedirection response: HTTPURLResponse,
+            newRequest request: URLRequest,
+            completionHandler: @escaping (URLRequest?) -> Void)
+        {
+            let from = AlibabaTokenPlanUsageFetcher.redactedURLDescription(response.url)
+            let to = AlibabaTokenPlanUsageFetcher.redactedURLDescription(request.url)
+            self.redirects.append("\(response.statusCode) \(from) -> \(to)")
+
+            completionHandler(AlibabaTokenPlanUsageFetcher.redirectedRequest(
+                response: response,
+                request: request,
+                cookieHeader: self.cookieHeader))
+        }
+    }
+
+    private static func redactedURLDescription(_ url: URL?) -> String {
+        guard let url else { return "unknown" }
+        var components = URLComponents(url: url, resolvingAgainstBaseURL: false)
+        components?.query = nil
+        components?.fragment = nil
+        return components?.string ?? "\(url.scheme ?? "unknown")://\(url.host ?? "unknown")"
+    }
+
+    static func redirectedRequest(
+        response: HTTPURLResponse,
+        request: URLRequest,
+        cookieHeader: String) -> URLRequest?
+    {
+        guard request.url?.scheme?.lowercased() == "https" else {
+            return nil
+        }
+
+        var updated = request
+        if self.shouldForwardRedirectCookies(from: response.url, to: request.url) {
+            updated.setValue(cookieHeader, forHTTPHeaderField: "Cookie")
+        } else {
+            updated.setValue(nil, forHTTPHeaderField: "Cookie")
+        }
+        return updated
+    }
+
+    private static func shouldForwardRedirectCookies(from sourceURL: URL?, to targetURL: URL?) -> Bool {
+        guard let sourceHost = sourceURL?.host?.lowercased(),
+              let targetHost = targetURL?.host?.lowercased()
+        else {
+            return false
+        }
+        return sourceHost == targetHost
+    }
+
+    private static func throwIfErrorPayload(_ dictionary: [String: Any]) throws {
+        if self.parseBool(dictionary["successResponse"]) == false {
+            if let statusCode = self.findFirstInt(forKeys: ["statusCode", "status_code", "code"], in: dictionary),
+               statusCode == 401 || statusCode == 403
+            {
+                throw AlibabaTokenPlanUsageError.invalidCredentials
+            }
+            let code = self.findFirstString(forKeys: ["code", "status", "statusCode"], in: dictionary)
+            let message = self.findFirstString(forKeys: ["message", "msg", "statusMessage"], in: dictionary) ??
+                code ??
+                "request was not successful"
+            if self.isLoginOrTokenError(code: code, message: message) {
+                throw AlibabaTokenPlanUsageError.loginRequired
+            }
+            throw AlibabaTokenPlanUsageError.apiError(message)
+        }
+
+        if self.findBoolValues(forKeys: ["Success", "success"], in: dictionary).contains(false) {
+            let code = self.findFirstString(forKeys: ["Code", "code"], in: dictionary)
+            let message = self.findFirstString(forKeys: ["Message", "message", "msg", "Code", "code"], in: dictionary)
+                ?? "request was not successful"
+            if self.isLoginOrTokenError(code: code, message: message) {
+                throw AlibabaTokenPlanUsageError.loginRequired
+            }
+            throw AlibabaTokenPlanUsageError.apiError(message)
+        }
+
+        if let statusCode = self.findFirstInt(forKeys: ["statusCode", "status_code", "code"], in: dictionary),
+           statusCode != 0,
+           statusCode != 200
+        {
+            let message = self.findFirstString(
+                forKeys: ["statusMessage", "status_msg", "message", "msg"],
+                in: dictionary)
+                ?? "status code \(statusCode)"
+            if statusCode == 401 || statusCode == 403 {
+                throw AlibabaTokenPlanUsageError.invalidCredentials
+            }
+            throw AlibabaTokenPlanUsageError.apiError(message)
+        }
+
+        let codeText = self.findFirstString(forKeys: ["code", "status", "statusCode"], in: dictionary)?.lowercased()
+        let messageText = self.findFirstString(forKeys: ["message", "msg", "statusMessage"], in: dictionary)?
+            .lowercased()
+        if self.isLoginOrTokenError(code: codeText, message: messageText) {
+            throw AlibabaTokenPlanUsageError.loginRequired
+        }
+    }
+
+    private static func isLoginOrTokenError(code: String?, message: String?) -> Bool {
+        let combined = [code, message]
+            .compactMap { $0?.lowercased() }
+            .joined(separator: " ")
+        return combined.contains("needlogin") ||
+            combined.contains("login") ||
+            combined.contains("postonlyortokenerror") ||
+            combined.contains("tokenerror") ||
+            combined.contains("request has expired") ||
+            combined.contains("refresh page") ||
+            combined.contains("请求已经过期")
+    }
+
+    private static let planNameKeys = [
+        "planName",
+        "plan_name",
+        "packageName",
+        "package_name",
+        "commodityName",
+        "commodity_name",
+        "instanceName",
+        "instance_name",
+        "displayName",
+        "display_name",
+        "ProductName",
+        "productName",
+        "name",
+        "title",
+        "planType",
+        "plan_type",
+    ]
+    private static let usedQuotaKeys = [
+        "usedQuota",
+        "used_quota",
+        "usedCredits",
+        "usedCredit",
+        "consumedCredits",
+        "usage",
+        "used",
+        "usedAmount",
+        "consumeAmount",
+        "usedValue",
+        "UsedValue",
+        "consumedValue",
+        "ConsumedValue",
+    ]
+    private static let totalQuotaKeys = [
+        "totalQuota",
+        "total_quota",
+        "totalCredits",
+        "totalCredit",
+        "quota",
+        "creditLimit",
+        "creditsTotal",
+        "monthlyTotalQuota",
+        "amount",
+        "totalValue",
+        "TotalValue",
+    ]
+    private static let remainingQuotaKeys = [
+        "remainingQuota",
+        "remainQuota",
+        "remainingCredits",
+        "remainingCredit",
+        "availableCredits",
+        "balance",
+        "remaining",
+        "availableAmount",
+        "remainAmount",
+        "totalSurplusValue",
+        "TotalSurplusValue",
+        "surplusValue",
+        "SurplusValue",
+    ]
+    private static let subscriptionCountKeys = [
+        "totalCount",
+        "TotalCount",
+        "subscriptionTotalNumber",
+        "SubscriptionTotalNumber",
+    ]
+    private static let resetDateKeys = [
+        "nextRefreshTime",
+        "resetTime",
+        "periodEndTime",
+        "billingCycleEnd",
+        "billCycleEndTime",
+        "expireTime",
+        "expirationTime",
+        "endTime",
+        "validEndTime",
+        "instanceEndTime",
+        "nearestExpireDate",
+        "NearestExpireDate",
+    ]
+
+    private static func findSubscriptionSummary(in payload: [String: Any]) -> [String: Any]? {
+        if let data = self.findFirstDictionary(
+            forKeys: ["Data", "data", "successResponse", "success_response"],
+            in: payload),
+            self.containsSubscriptionSummaryFields(data)
+        {
+            return data
+        }
+        return self.findFirstDictionary(
+            matchingAnyKey: Self.usedQuotaKeys + Self.totalQuotaKeys + Self.remainingQuotaKeys +
+                Self.subscriptionCountKeys,
+            in: payload)
+    }
+
+    private static func containsSubscriptionSummaryFields(_ payload: [String: Any]) -> Bool {
+        let keys = self.usedQuotaKeys + self.totalQuotaKeys + self.remainingQuotaKeys + self.subscriptionCountKeys
+        return keys.contains { payload[$0] != nil }
+    }
+
+    private static func findPlanName(in payload: [String: Any]) -> String? {
+        self.anyString(for: self.planNameKeys, in: payload) ??
+            self.findFirstString(forKeys: self.planNameKeys, in: payload)
+    }
+
+    private static func findResetDate(in payload: [String: Any]) -> Date? {
+        self.anyDate(for: self.resetDateKeys, in: payload) ??
+            self.findFirstDate(forKeys: self.resetDateKeys, in: payload)
+    }
+
+    private static func payloadDiagnostics(payload: [String: Any]) -> String {
+        let topKeys = payload.keys.sorted()
+        let dataDict = self.findFirstDictionary(
+            forKeys: ["Data", "data", "successResponse", "success_response"],
+            in: payload)
+        let dataKeys = dataDict?.keys.sorted() ?? []
+        return "topKeys=\(topKeys.joined(separator: ",")) dataKeys=\(dataKeys.joined(separator: ","))"
+    }
+
+    private static func isLikelyLoginHTML(_ data: Data) -> Bool {
+        guard let text = String(data: data, encoding: .utf8)?.lowercased() else { return false }
+        return text.contains("<html") &&
+            (text.contains("login") || text.contains("sign in") || text.contains("signin"))
+    }
+
+    private static func findFirstDictionary(forKeys keys: [String], in value: Any) -> [String: Any]? {
+        if let dict = value as? [String: Any] {
+            for key in keys {
+                if let nested = dict[key] as? [String: Any] {
+                    return nested
+                }
+            }
+            for nestedValue in dict.values {
+                if let nested = self.findFirstDictionary(forKeys: keys, in: nestedValue) {
+                    return nested
+                }
+            }
+            return nil
+        }
+        if let array = value as? [Any] {
+            for item in array {
+                if let nested = self.findFirstDictionary(forKeys: keys, in: item) {
+                    return nested
+                }
+            }
+        }
+        return nil
+    }
+
+    private static func findFirstDictionary(matchingAnyKey keys: [String], in value: Any) -> [String: Any]? {
+        if let dict = value as? [String: Any] {
+            if keys.contains(where: { dict[$0] != nil }) {
+                return dict
+            }
+            for nestedValue in dict.values {
+                if let nested = self.findFirstDictionary(matchingAnyKey: keys, in: nestedValue) {
+                    return nested
+                }
+            }
+            return nil
+        }
+        if let array = value as? [Any] {
+            for item in array {
+                if let nested = self.findFirstDictionary(matchingAnyKey: keys, in: item) {
+                    return nested
+                }
+            }
+        }
+        return nil
+    }
+
+    private static func findFirstString(forKeys keys: [String], in value: Any) -> String? {
+        if let dict = value as? [String: Any] {
+            for key in keys {
+                if let parsed = self.parseString(dict[key]) {
+                    return parsed
+                }
+            }
+            for nestedValue in dict.values {
+                if let parsed = self.findFirstString(forKeys: keys, in: nestedValue) {
+                    return parsed
+                }
+            }
+            return nil
+        }
+        if let array = value as? [Any] {
+            for item in array {
+                if let parsed = self.findFirstString(forKeys: keys, in: item) {
+                    return parsed
+                }
+            }
+        }
+        return nil
+    }
+
+    private static func findBoolValues(forKeys keys: [String], in value: Any) -> [Bool] {
+        if let dict = value as? [String: Any] {
+            let directValues = keys.compactMap { self.parseBool(dict[$0]) }
+            let nestedValues = dict.values.flatMap { self.findBoolValues(forKeys: keys, in: $0) }
+            return directValues + nestedValues
+        }
+        if let array = value as? [Any] {
+            return array.flatMap { self.findBoolValues(forKeys: keys, in: $0) }
+        }
+        return []
+    }
+
+    private static func findFirstInt(forKeys keys: [String], in value: Any) -> Int? {
+        if let dict = value as? [String: Any] {
+            for key in keys {
+                if let parsed = self.parseInt(dict[key]) {
+                    return parsed
+                }
+            }
+            for nestedValue in dict.values {
+                if let parsed = self.findFirstInt(forKeys: keys, in: nestedValue) {
+                    return parsed
+                }
+            }
+            return nil
+        }
+        if let array = value as? [Any] {
+            for item in array {
+                if let parsed = self.findFirstInt(forKeys: keys, in: item) {
+                    return parsed
+                }
+            }
+        }
+        return nil
+    }
+
+    private static func findFirstDate(forKeys keys: [String], in value: Any) -> Date? {
+        if let dict = value as? [String: Any] {
+            for key in keys {
+                if let parsed = self.parseDate(dict[key]) {
+                    return parsed
+                }
+            }
+            for nestedValue in dict.values {
+                if let parsed = self.findFirstDate(forKeys: keys, in: nestedValue) {
+                    return parsed
+                }
+            }
+            return nil
+        }
+        if let array = value as? [Any] {
+            for item in array {
+                if let parsed = self.findFirstDate(forKeys: keys, in: item) {
+                    return parsed
+                }
+            }
+        }
+        return nil
+    }
+
+    private static func expandedJSON(_ value: Any) -> Any {
+        if let dict = value as? [String: Any] {
+            var expanded: [String: Any] = [:]
+            expanded.reserveCapacity(dict.count)
+            for (key, nested) in dict {
+                expanded[key] = self.expandedJSON(nested)
+            }
+            return expanded
+        }
+        if let array = value as? [Any] {
+            return array.map { self.expandedJSON($0) }
+        }
+        if let string = value as? String,
+           let data = string.data(using: .utf8),
+           let nested = try? JSONSerialization.jsonObject(with: data, options: []),
+           nested is [String: Any] || nested is [Any]
+        {
+            return self.expandedJSON(nested)
+        }
+        return value
+    }
+
+    private static func anyString(for keys: [String], in dict: [String: Any]) -> String? {
+        for key in keys {
+            if let value = self.parseString(dict[key]) {
+                return value
+            }
+        }
+        return nil
+    }
+
+    private static func anyDouble(for keys: [String], in dict: [String: Any]) -> Double? {
+        for key in keys {
+            if let value = self.parseDouble(dict[key]) {
+                return value
+            }
+        }
+        return nil
+    }
+
+    private static func anyDate(for keys: [String], in dict: [String: Any]) -> Date? {
+        for key in keys {
+            if let value = self.parseDate(dict[key]) {
+                return value
+            }
+        }
+        return nil
+    }
+
+    private static func anyBool(for keys: [String], in dict: [String: Any]) -> Bool? {
+        for key in keys {
+            if let value = self.parseBool(dict[key]) {
+                return value
+            }
+        }
+        return nil
+    }
+
+    private static func parseInt(_ raw: Any?) -> Int? {
+        if let value = raw as? Int { return value }
+        if let value = raw as? Int64 { return Int(value) }
+        if let value = raw as? Double { return Int(value) }
+        if let value = raw as? NSNumber { return value.intValue }
+        if let value = self.parseString(raw) { return Int(value) }
+        return nil
+    }
+
+    private static func parseDouble(_ raw: Any?) -> Double? {
+        if let value = raw as? Double { return value }
+        if let value = raw as? Int { return Double(value) }
+        if let value = raw as? Int64 { return Double(value) }
+        if let value = raw as? NSNumber { return value.doubleValue }
+        if let value = self.parseString(raw) {
+            let cleaned = value.replacingOccurrences(of: ",", with: "")
+            return Double(cleaned)
+        }
+        return nil
+    }
+
+    private static func parseString(_ raw: Any?) -> String? {
+        guard let value = raw as? String else { return nil }
+        let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        return trimmed.isEmpty ? nil : trimmed
+    }
+
+    private static func parseDate(_ raw: Any?) -> Date? {
+        if let intValue = self.parseInt(raw) {
+            if intValue > 1_000_000_000_000 {
+                return Date(timeIntervalSince1970: TimeInterval(intValue) / 1000)
+            }
+            if intValue > 1_000_000_000 {
+                return Date(timeIntervalSince1970: TimeInterval(intValue))
+            }
+        }
+        if let string = self.parseString(raw) {
+            let formatter = ISO8601DateFormatter()
+            if let date = formatter.date(from: string) {
+                return date
+            }
+            let dateFormatter = DateFormatter()
+            dateFormatter.locale = Locale(identifier: "en_US_POSIX")
+            for format in ["yyyy-MM-dd", "yyyy-MM-dd HH:mm", "yyyy-MM-dd HH:mm:ss"] {
+                dateFormatter.dateFormat = format
+                if let date = dateFormatter.date(from: string) {
+                    return date
+                }
+            }
+        }
+        return nil
+    }
+
+    private static func parseBool(_ raw: Any?) -> Bool? {
+        if let value = raw as? Bool { return value }
+        if let number = raw as? NSNumber { return number.boolValue }
+        guard let string = self.parseString(raw)?.lowercased() else { return nil }
+        switch string {
+        case "true", "1", "yes", "active", "valid", "normal":
+            return true
+        case "false", "0", "no", "inactive", "invalid", "expired":
+            return false
+        default:
+            return nil
+        }
+    }
+
+    private static func extractCookieValue(name: String, from cookieHeader: String) -> String? {
+        cookieHeader
+            .split(separator: ";")
+            .compactMap { part -> (String, String)? in
+                let pieces = part.split(separator: "=", maxSplits: 1).map {
+                    $0.trimmingCharacters(in: .whitespacesAndNewlines)
+                }
+                guard pieces.count == 2 else { return nil }
+                return (pieces[0], pieces[1])
+            }
+            .first { $0.0 == name }?
+            .1
+    }
+
+    private static func hasCSRF(in cookieHeader: String) -> Bool {
+        self.extractCookieValue(name: "login_aliyunid_csrf", from: cookieHeader) != nil ||
+            self.extractCookieValue(name: "csrf", from: cookieHeader) != nil
+    }
+
+    static func cookieNames(from cookieHeader: String) -> [String] {
+        CookieHeaderNormalizer.pairs(from: cookieHeader)
+            .map(\.name)
+            .filter { !$0.isEmpty }
+            .uniquedSorted()
+    }
+
+    static func cookieNamesDescription(from cookieHeader: String) -> String {
+        let names = self.cookieNames(from: cookieHeader)
+        return names.isEmpty ? "none" : names.joined(separator: ",")
+    }
+
+    private static func extractSECToken(from html: String) -> String? {
+        let patterns = [
+            #""secToken"\s*:\s*"([^"]+)""#,
+            #""sec_token"\s*:\s*"([^"]+)""#,
+            #"secToken['"]?\s*[:=]\s*['"]([^'"]+)['"]"#,
+            #"sec_token['"]?\s*[:=]\s*['"]([^'"]+)['"]"#,
+        ]
+        for pattern in patterns {
+            if let token = self.matchFirstGroup(pattern: pattern, in: html), !token.isEmpty {
+                return token
+            }
+        }
+        return nil
+    }
+
+    private static func matchFirstGroup(pattern: String, in text: String) -> String? {
+        guard let regex = try? NSRegularExpression(pattern: pattern, options: []) else {
+            return nil
+        }
+        let range = NSRange(text.startIndex..<text.endIndex, in: text)
+        guard let match = regex.firstMatch(in: text, options: [], range: range),
+              match.numberOfRanges > 1,
+              let valueRange = Range(match.range(at: 1), in: text)
+        else {
+            return nil
+        }
+        let value = text[valueRange].trimmingCharacters(in: .whitespacesAndNewlines)
+        return value.isEmpty ? nil : String(value)
+    }
+}
+
+extension [String] {
+    fileprivate func uniquedSorted() -> [String] {
+        Array(Set(self)).sorted()
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Alibaba/AlibabaTokenPlanUsageSnapshot.swift b/Sources/CodexBarCore/Providers/Alibaba/AlibabaTokenPlanUsageSnapshot.swift
new file mode 100644
index 0000000000..36cee2a2b2
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Alibaba/AlibabaTokenPlanUsageSnapshot.swift
@@ -0,0 +1,96 @@
+import Foundation
+
+public struct AlibabaTokenPlanUsageSnapshot: Sendable {
+    public let planName: String?
+    public let usedQuota: Double?
+    public let totalQuota: Double?
+    public let remainingQuota: Double?
+    public let resetsAt: Date?
+    public let updatedAt: Date
+
+    public init(
+        planName: String?,
+        usedQuota: Double?,
+        totalQuota: Double?,
+        remainingQuota: Double?,
+        resetsAt: Date?,
+        updatedAt: Date)
+    {
+        self.planName = planName
+        self.usedQuota = usedQuota
+        self.totalQuota = totalQuota
+        self.remainingQuota = remainingQuota
+        self.resetsAt = resetsAt
+        self.updatedAt = updatedAt
+    }
+}
+
+extension AlibabaTokenPlanUsageSnapshot {
+    public func toUsageSnapshot() -> UsageSnapshot {
+        let primary: RateWindow? = Self.usedPercent(
+            used: self.usedQuota,
+            total: self.totalQuota,
+            remaining: self.remainingQuota).map {
+            RateWindow(
+                usedPercent: $0,
+                windowMinutes: 30 * 24 * 60,
+                resetsAt: self.resetsAt,
+                resetDescription: Self.quotaDetail(
+                    used: self.usedQuota,
+                    total: self.totalQuota,
+                    remaining: self.remainingQuota))
+        }
+
+        let planName = self.planName?.trimmingCharacters(in: .whitespacesAndNewlines)
+        let loginMethod = (planName?.isEmpty ?? true) ? nil : planName
+        let identity = ProviderIdentitySnapshot(
+            providerID: .alibabatokenplan,
+            accountEmail: nil,
+            accountOrganization: nil,
+            loginMethod: loginMethod)
+
+        return UsageSnapshot(
+            primary: primary,
+            secondary: nil,
+            tertiary: nil,
+            providerCost: nil,
+            updatedAt: self.updatedAt,
+            identity: identity)
+    }
+
+    private static func usedPercent(used: Double?, total: Double?, remaining: Double?) -> Double? {
+        guard let total, total > 0 else { return nil }
+        let usedValue: Double? = if let used {
+            used
+        } else if let remaining {
+            total - remaining
+        } else {
+            nil
+        }
+        guard let usedValue else { return nil }
+        let normalizedUsed = max(0, min(usedValue, total))
+        return normalizedUsed / total * 100
+    }
+
+    private static func quotaDetail(used: Double?, total: Double?, remaining: Double?) -> String? {
+        if let used, let total, total > 0 {
+            return "\(self.format(used)) / \(self.format(total)) credits used"
+        }
+        if let remaining, let total, total > 0 {
+            return "\(Self.format(remaining)) / \(Self.format(total)) credits left"
+        }
+        if let remaining {
+            return "\(Self.format(remaining)) credits left"
+        }
+        return nil
+    }
+
+    private static func format(_ value: Double) -> String {
+        let formatter = NumberFormatter()
+        formatter.numberStyle = .decimal
+        formatter.usesGroupingSeparator = true
+        formatter.maximumFractionDigits = value.rounded() == value ? 0 : 2
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        return formatter.string(from: NSNumber(value: value)) ?? String(format: "%.2f", value)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Amp/AmpCLIProbe.swift b/Sources/CodexBarCore/Providers/Amp/AmpCLIProbe.swift
new file mode 100644
index 0000000000..ab995dd65b
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Amp/AmpCLIProbe.swift
@@ -0,0 +1,46 @@
+import Foundation
+
+public struct AmpCLIProbe: Sendable {
+    private static let commandTimeout: TimeInterval = 15
+    private let arguments: [String]
+
+    public init() {
+        self.arguments = ["usage"]
+    }
+
+    init(arguments: [String]) {
+        self.arguments = arguments
+    }
+
+    public func fetch(
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        now: Date = Date()) async throws -> AmpUsageSnapshot
+    {
+        let loginPATH = LoginShellPathCache.shared.current
+        guard let executable = BinaryLocator.resolveAmpBinary(env: environment, loginPATH: loginPATH) else {
+            throw SubprocessRunnerError.binaryNotFound("amp")
+        }
+
+        var commandEnvironment = environment
+        commandEnvironment["NO_COLOR"] = "1"
+        commandEnvironment["PATH"] = PathBuilder.effectivePATH(
+            purposes: [.tty, .nodeTooling],
+            env: environment,
+            loginPATH: loginPATH)
+
+        let result = try await SubprocessRunner.run(
+            binary: executable,
+            arguments: self.arguments,
+            environment: commandEnvironment,
+            timeout: Self.commandTimeout,
+            standardInput: FileHandle.nullDevice,
+            label: "amp-usage")
+        let output = result.stdout.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+            ? result.stderr
+            : result.stdout
+        guard !output.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+            throw AmpUsageError.parseFailed("The Amp CLI returned no usage data.")
+        }
+        return try AmpUsageParser.parse(displayText: output, now: now)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Amp/AmpProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Amp/AmpProviderDescriptor.swift
index bfe1bee0e2..e6295cb718 100644
--- a/Sources/CodexBarCore/Providers/Amp/AmpProviderDescriptor.swift
+++ b/Sources/CodexBarCore/Providers/Amp/AmpProviderDescriptor.swift
@@ -1,9 +1,8 @@
-import CodexBarMacroSupport
 import Foundation
 
-@ProviderDescriptorRegistration
-@ProviderDescriptorDefinition
 public enum AmpProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
     static func makeDescriptor() -> ProviderDescriptor {
         ProviderDescriptor(
             id: .amp,
@@ -14,15 +13,15 @@ public enum AmpProviderDescriptor {
                 weeklyLabel: "Balance",
                 opusLabel: nil,
                 supportsOpus: false,
-                supportsCredits: false,
-                creditsHint: "",
+                supportsCredits: true,
+                creditsHint: "Individual and workspace credit balances from Amp.",
                 toggleTitle: "Show Amp usage",
                 cliName: "amp",
                 defaultEnabled: false,
                 isPrimaryProvider: false,
                 usesAccountFallback: false,
                 browserCookieOrder: ProviderBrowserCookieDefaults.defaultImportOrder,
-                dashboardURL: "https://ampcode.com/settings",
+                dashboardURL: "https://ampcode.com/settings#billing",
                 statusPageURL: nil),
             branding: ProviderBranding(
                 iconStyle: .amp,
@@ -32,12 +31,81 @@ public enum AmpProviderDescriptor {
                 supportsTokenCost: false,
                 noDataMessage: { "Amp cost summary is not supported." }),
             fetchPlan: ProviderFetchPlan(
-                sourceModes: [.auto, .web],
-                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [AmpStatusFetchStrategy()] })),
+                sourceModes: [.auto, .api, .web, .cli],
+                pipeline: ProviderFetchPipeline(resolveStrategies: self.resolveStrategies)),
             cli: ProviderCLIConfig(
                 name: "amp",
                 versionDetector: nil))
     }
+
+    private static func resolveStrategies(context: ProviderFetchContext) async -> [any ProviderFetchStrategy] {
+        switch context.sourceMode {
+        case .auto:
+            [AmpCLIFetchStrategy(), AmpAPIFetchStrategy(), AmpStatusFetchStrategy()]
+        case .cli:
+            [AmpCLIFetchStrategy()]
+        case .api:
+            [AmpAPIFetchStrategy()]
+        case .web:
+            [AmpStatusFetchStrategy()]
+        case .oauth:
+            []
+        }
+    }
+}
+
+struct AmpCLIFetchStrategy: ProviderFetchStrategy {
+    let id: String = "amp.cli"
+    let kind: ProviderFetchKind = .cli
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        BinaryLocator.resolveAmpBinary(
+            env: context.env,
+            loginPATH: LoginShellPathCache.shared.current) != nil
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        let snapshot = try await AmpCLIProbe().fetch(environment: context.env)
+        return self.makeResult(
+            usage: snapshot.toUsageSnapshot(now: snapshot.updatedAt),
+            sourceLabel: "cli")
+    }
+
+    func shouldFallback(on error: Error, context: ProviderFetchContext) -> Bool {
+        if error is CancellationError || (error as? URLError)?.code == .cancelled {
+            return false
+        }
+        return context.sourceMode == .auto
+    }
+}
+
+struct AmpAPIFetchStrategy: ProviderFetchStrategy {
+    let id: String = "amp.api"
+    let kind: ProviderFetchKind = .apiToken
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        _ = context
+        return true
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        guard let token = ProviderTokenResolver.ampToken(environment: context.env) else {
+            throw AmpUsageError.missingAPIToken
+        }
+        let logger: ((String) -> Void)? = context.verbose
+            ? { msg in CodexBarLog.logger(LogCategories.amp).verbose(msg) }
+            : nil
+        let snapshot = try await AmpUsageFetcher(browserDetection: context.browserDetection)
+            .fetch(apiToken: token, logger: logger)
+        return self.makeResult(
+            usage: snapshot.toUsageSnapshot(now: snapshot.updatedAt),
+            sourceLabel: "api")
+    }
+
+    func shouldFallback(on error: Error, context: ProviderFetchContext) -> Bool {
+        guard context.sourceMode == .auto else { return false }
+        return !(error is CancellationError) && (error as? URLError)?.code != .cancelled
+    }
 }
 
 struct AmpStatusFetchStrategy: ProviderFetchStrategy {
@@ -45,8 +113,15 @@ struct AmpStatusFetchStrategy: ProviderFetchStrategy {
     let kind: ProviderFetchKind = .web
 
     func isAvailable(_ context: ProviderFetchContext) async -> Bool {
-        guard context.settings?.amp?.cookieSource != .off else { return false }
-        return true
+        guard context.sourceMode.usesWeb else { return false }
+        #if os(macOS)
+        let canImportBrowserCookies = true
+        #else
+        let canImportBrowserCookies = false
+        #endif
+        return Self.canUseWebFallback(
+            settings: context.settings?.amp,
+            canImportBrowserCookies: canImportBrowserCookies)
     }
 
     func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
@@ -65,8 +140,30 @@ struct AmpStatusFetchStrategy: ProviderFetchStrategy {
         false
     }
 
+    static func canUseWebFallback(
+        settings: ProviderSettingsSnapshot.AmpProviderSettings?,
+        canImportBrowserCookies: Bool) -> Bool
+    {
+        guard let settings else { return canImportBrowserCookies }
+        switch settings.cookieSource {
+        case .auto:
+            return canImportBrowserCookies
+        case .manual:
+            return Self.manualCookieHeader(from: settings.manualCookieHeader) != nil
+        case .off:
+            return false
+        }
+    }
+
     private static func manualCookieHeader(from context: ProviderFetchContext) -> String? {
-        guard context.settings?.amp?.cookieSource == .manual else { return nil }
-        return CookieHeaderNormalizer.normalize(context.settings?.amp?.manualCookieHeader)
+        guard let settings = context.settings?.amp, settings.cookieSource == .manual else { return nil }
+        return Self.manualCookieHeader(from: settings.manualCookieHeader)
+    }
+
+    private static func manualCookieHeader(from rawHeader: String?) -> String? {
+        guard let header = CookieHeaderNormalizer.normalize(rawHeader),
+              CookieHeaderNormalizer.pairs(from: header).contains(where: { $0.name == "session" })
+        else { return nil }
+        return header
     }
 }
diff --git a/Sources/CodexBarCore/Providers/Amp/AmpSettingsReader.swift b/Sources/CodexBarCore/Providers/Amp/AmpSettingsReader.swift
new file mode 100644
index 0000000000..5997e3505a
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Amp/AmpSettingsReader.swift
@@ -0,0 +1,22 @@
+import Foundation
+
+public enum AmpSettingsReader {
+    public static let apiTokenKey = "AMP_API_KEY"
+
+    public static func apiToken(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        self.cleaned(environment[self.apiTokenKey])
+    }
+
+    static func cleaned(_ raw: String?) -> String? {
+        guard var value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
+            return nil
+        }
+        if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
+            (value.hasPrefix("'") && value.hasSuffix("'"))
+        {
+            value = String(value.dropFirst().dropLast())
+        }
+        value = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        return value.isEmpty ? nil : value
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Amp/AmpUsageFetcher.swift b/Sources/CodexBarCore/Providers/Amp/AmpUsageFetcher.swift
index 3ef31c4cb7..17d9c29e52 100644
--- a/Sources/CodexBarCore/Providers/Amp/AmpUsageFetcher.swift
+++ b/Sources/CodexBarCore/Providers/Amp/AmpUsageFetcher.swift
@@ -10,6 +10,8 @@ import SweetCookieKit
 public enum AmpUsageError: LocalizedError, Sendable {
     case notLoggedIn
     case invalidCredentials
+    case missingAPIToken
+    case invalidAPIToken
     case parseFailed(String)
     case networkError(String)
     case noSessionCookie
@@ -20,6 +22,10 @@ public enum AmpUsageError: LocalizedError, Sendable {
             "Not logged in to Amp. Please log in via ampcode.com."
         case .invalidCredentials:
             "Amp session cookie expired. Please log in again."
+        case .missingAPIToken:
+            "Amp access token not configured. Set AMP_API_KEY or add it in Settings."
+        case .invalidAPIToken:
+            "Amp access token is invalid or expired."
         case let .parseFailed(message):
             "Could not parse Amp usage: \(message)"
         case let .networkError(message):
@@ -65,7 +71,7 @@ public enum AmpCookieImporter {
         for browserSource in installed {
             do {
                 let query = BrowserCookieQuery(domains: self.cookieDomains)
-                let sources = try Self.cookieClient.records(
+                let sources = try Self.cookieClient.codexBarRecords(
                     matching: query,
                     in: browserSource,
                     logger: log)
@@ -95,6 +101,7 @@ public enum AmpCookieImporter {
 
 public struct AmpUsageFetcher: Sendable {
     private static let settingsURL = URL(string: "https://ampcode.com/settings")!
+    static let usageURL = URL(string: "https://ampcode.com/api/internal?userDisplayBalanceInfo")!
     @MainActor private static var recentDumps: [String] = []
 
     public let browserDetection: BrowserDetection
@@ -118,30 +125,43 @@ public struct AmpUsageFetcher: Sendable {
             }
             let diagnostics = RedirectDiagnostics(cookieHeader: cookieHeader, logger: logger)
             do {
-                let (html, responseInfo) = try await self.fetchHTMLWithDiagnostics(
+                let (html, responseInfo) = try await self.fetchLegacyHTMLWithDiagnostics(
                     cookieHeader: cookieHeader,
                     diagnostics: diagnostics)
                 self.logDiagnostics(responseInfo: responseInfo, diagnostics: diagnostics, logger: logger)
-                do {
-                    return try AmpUsageParser.parse(html: html, now: now)
-                } catch {
-                    logger("[amp] Parse failed: \(error.localizedDescription)")
-                    self.logHTMLHints(html: html, logger: logger)
-                    throw error
-                }
+                return try AmpUsageParser.parse(html: html, now: now)
             } catch {
                 self.logDiagnostics(responseInfo: nil, diagnostics: diagnostics, logger: logger)
+                logger("[amp] Fetch failed: \(error.localizedDescription)")
                 throw error
             }
         }
 
         let diagnostics = RedirectDiagnostics(cookieHeader: cookieHeader, logger: nil)
-        let (html, _) = try await self.fetchHTMLWithDiagnostics(
+        let (html, _) = try await self.fetchLegacyHTMLWithDiagnostics(
             cookieHeader: cookieHeader,
             diagnostics: diagnostics)
         return try AmpUsageParser.parse(html: html, now: now)
     }
 
+    public func fetch(
+        apiToken: String,
+        logger: ((String) -> Void)? = nil,
+        now: Date = Date()) async throws -> AmpUsageSnapshot
+    {
+        guard let token = AmpSettingsReader.cleaned(apiToken) else {
+            throw AmpUsageError.missingAPIToken
+        }
+        let request = try Self.makeUsageAPIRequest(apiToken: token)
+        let diagnostics = APIRedirectDiagnostics(logger: logger)
+        let session = URLSession(configuration: .ephemeral, delegate: diagnostics, delegateQueue: nil)
+        let httpResponse = try await session.response(for: request)
+        logger?("[amp] API response: \(httpResponse.statusCode) " +
+            "\(httpResponse.response.url?.absoluteString ?? "unknown")")
+        try Self.validateAPIResponse(httpResponse)
+        return try Self.parseUsageAPIResponse(httpResponse.data, now: now)
+    }
+
     public func debugRawProbe(cookieHeaderOverride: String? = nil) async -> String {
         let stamp = ISO8601DateFormatter().string(from: Date())
         var lines: [String] = []
@@ -156,9 +176,10 @@ public struct AmpUsageFetcher: Sendable {
             let cookieNames = CookieHeaderNormalizer.pairs(from: cookieHeader).map(\.name)
             lines.append("Cookie names: \(cookieNames.joined(separator: ", "))")
 
-            let (snapshot, responseInfo) = try await self.fetchWithDiagnostics(
+            let (html, responseInfo) = try await self.fetchLegacyHTMLWithDiagnostics(
                 cookieHeader: cookieHeader,
                 diagnostics: diagnostics)
+            let snapshot = try AmpUsageParser.parse(html: html)
 
             lines.append("")
             lines.append("Fetch Success")
@@ -174,10 +195,14 @@ public struct AmpUsageFetcher: Sendable {
 
             lines.append("")
             lines.append("Amp Free:")
-            lines.append("  quota=\(snapshot.freeQuota)")
-            lines.append("  used=\(snapshot.freeUsed)")
-            lines.append("  hourlyReplenishment=\(snapshot.hourlyReplenishment)")
+            lines.append("  quota=\(snapshot.freeQuota?.description ?? "nil")")
+            lines.append("  used=\(snapshot.freeUsed?.description ?? "nil")")
+            lines.append("  hourlyReplenishment=\(snapshot.hourlyReplenishment?.description ?? "nil")")
             lines.append("  windowHours=\(snapshot.windowHours?.description ?? "nil")")
+            lines.append("  individualCredits=\(snapshot.individualCredits?.description ?? "nil")")
+            for workspace in snapshot.workspaceBalances {
+                lines.append("  workspace[\(workspace.name)]=\(workspace.remaining)")
+            }
 
             let output = lines.joined(separator: "\n")
             Task { @MainActor in Self.recordDump(output) }
@@ -218,19 +243,20 @@ public struct AmpUsageFetcher: Sendable {
         #endif
     }
 
-    private func fetchWithDiagnostics(
-        cookieHeader: String,
-        diagnostics: RedirectDiagnostics,
-        now: Date = Date()) async throws -> (AmpUsageSnapshot, ResponseInfo)
-    {
-        let (html, responseInfo) = try await self.fetchHTMLWithDiagnostics(
-            cookieHeader: cookieHeader,
-            diagnostics: diagnostics)
-        let snapshot = try AmpUsageParser.parse(html: html, now: now)
-        return (snapshot, responseInfo)
+    static func makeUsageAPIRequest(apiToken: String) throws -> URLRequest {
+        var request = URLRequest(url: Self.usageURL)
+        request.httpMethod = "POST"
+        request.httpBody = try JSONSerialization.data(withJSONObject: [
+            "method": "userDisplayBalanceInfo",
+            "params": [:],
+        ])
+        request.setValue("Bearer \(apiToken)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "accept")
+        request.setValue("application/json", forHTTPHeaderField: "content-type")
+        return request
     }
 
-    private func fetchHTMLWithDiagnostics(
+    private func fetchLegacyHTMLWithDiagnostics(
         cookieHeader: String,
         diagnostics: RedirectDiagnostics) async throws -> (String, ResponseInfo)
     {
@@ -240,35 +266,68 @@ public struct AmpUsageFetcher: Sendable {
         request.setValue(
             "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
             forHTTPHeaderField: "accept")
+        Self.applyBrowserHeaders(to: &request)
+
+        let session = URLSession(configuration: .ephemeral, delegate: diagnostics, delegateQueue: nil)
+        let httpResponse = try await session.response(for: request)
+        let responseInfo = ResponseInfo(
+            statusCode: httpResponse.statusCode,
+            url: httpResponse.response.url?.absoluteString ?? "unknown")
+        try Self.validateBrowserResponse(response: httpResponse, diagnostics: diagnostics)
+
+        let html = String(data: httpResponse.data, encoding: .utf8) ?? ""
+        return (html, responseInfo)
+    }
+
+    static func parseUsageAPIResponse(_ data: Data, now: Date = Date()) throws -> AmpUsageSnapshot {
+        let response: UsageAPIResponse
+        do {
+            response = try JSONDecoder().decode(UsageAPIResponse.self, from: data)
+        } catch {
+            throw AmpUsageError.parseFailed("Invalid Amp usage API response.")
+        }
+
+        guard response.ok else {
+            if response.error?.code == "auth-required" {
+                throw AmpUsageError.invalidAPIToken
+            }
+            throw AmpUsageError.networkError(response.error?.message ?? "Amp usage API returned an error.")
+        }
+        guard let displayText = response.result?.displayText, !displayText.isEmpty else {
+            throw AmpUsageError.parseFailed("Missing Amp usage display text.")
+        }
+        return try AmpUsageParser.parse(displayText: displayText, now: now)
+    }
+
+    private static func applyBrowserHeaders(to request: inout URLRequest) {
         request.setValue(
             "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) " +
                 "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36",
             forHTTPHeaderField: "user-agent")
         request.setValue("en-US,en;q=0.9", forHTTPHeaderField: "accept-language")
         request.setValue("https://ampcode.com", forHTTPHeaderField: "origin")
-        request.setValue(Self.settingsURL.absoluteString, forHTTPHeaderField: "referer")
-
-        let session = URLSession(configuration: .ephemeral, delegate: diagnostics, delegateQueue: nil)
-        let (data, response) = try await session.data(for: request)
-        guard let httpResponse = response as? HTTPURLResponse else {
-            throw AmpUsageError.networkError("Invalid response")
-        }
-        let responseInfo = ResponseInfo(
-            statusCode: httpResponse.statusCode,
-            url: httpResponse.url?.absoluteString ?? "unknown")
+        request.setValue(self.settingsURL.absoluteString, forHTTPHeaderField: "referer")
+    }
 
-        guard httpResponse.statusCode == 200 else {
-            if httpResponse.statusCode == 401 || httpResponse.statusCode == 403 {
-                throw AmpUsageError.invalidCredentials
-            }
-            if diagnostics.detectedLoginRedirect {
+    private static func validateBrowserResponse(
+        response: ProviderHTTPResponse,
+        diagnostics: RedirectDiagnostics) throws
+    {
+        guard response.statusCode == 200 else {
+            if response.statusCode == 401 || response.statusCode == 403 || diagnostics.detectedLoginRedirect {
                 throw AmpUsageError.invalidCredentials
             }
-            throw AmpUsageError.networkError("HTTP \(httpResponse.statusCode)")
+            throw AmpUsageError.networkError("HTTP \(response.statusCode)")
         }
+    }
 
-        let html = String(data: data, encoding: .utf8) ?? ""
-        return (html, responseInfo)
+    private static func validateAPIResponse(_ response: ProviderHTTPResponse) throws {
+        guard response.statusCode == 200 else {
+            if response.statusCode == 401 || response.statusCode == 403 {
+                throw AmpUsageError.invalidAPIToken
+            }
+            throw AmpUsageError.networkError("HTTP \(response.statusCode)")
+        }
     }
 
     @MainActor private static func recordDump(_ text: String) {
@@ -323,11 +382,48 @@ public struct AmpUsageFetcher: Sendable {
         }
     }
 
-    private struct ResponseInfo: Sendable {
+    /// Amp's balance RPC should not redirect. Refusing redirects guarantees the bearer token cannot cross hosts.
+    private final class APIRedirectDiagnostics: NSObject, URLSessionTaskDelegate, @unchecked Sendable {
+        private let logger: ((String) -> Void)?
+
+        init(logger: ((String) -> Void)?) {
+            self.logger = logger
+        }
+
+        func urlSession(
+            _: URLSession,
+            task _: URLSessionTask,
+            willPerformHTTPRedirection response: HTTPURLResponse,
+            newRequest request: URLRequest,
+            completionHandler: @escaping (URLRequest?) -> Void)
+        {
+            let from = response.url?.absoluteString ?? "unknown"
+            let to = request.url?.absoluteString ?? "unknown"
+            self.logger?("[amp] API redirect blocked: \(response.statusCode) \(from) -> \(to)")
+            completionHandler(nil)
+        }
+    }
+
+    private struct ResponseInfo {
         let statusCode: Int
         let url: String
     }
 
+    private struct UsageAPIResponse: Decodable {
+        let ok: Bool
+        let result: Result?
+        let error: APIError?
+
+        struct Result: Decodable {
+            let displayText: String
+        }
+
+        struct APIError: Decodable {
+            let code: String?
+            let message: String?
+        }
+    }
+
     private func logDiagnostics(
         responseInfo: ResponseInfo?,
         diagnostics: RedirectDiagnostics,
@@ -344,19 +440,6 @@ public struct AmpUsageFetcher: Sendable {
         }
     }
 
-    private func logHTMLHints(html: String, logger: (String) -> Void) {
-        let trimmed = html
-            .replacingOccurrences(of: "\n", with: " ")
-            .replacingOccurrences(of: "\t", with: " ")
-            .trimmingCharacters(in: .whitespacesAndNewlines)
-        if !trimmed.isEmpty {
-            let snippet = trimmed.prefix(240)
-            logger("[amp] HTML snippet: \(snippet)")
-        }
-        logger("[amp] Contains freeTierUsage: \(html.contains("freeTierUsage"))")
-        logger("[amp] Contains getFreeTierUsage: \(html.contains("getFreeTierUsage"))")
-    }
-
     private func cookieNames(from header: String) -> [String] {
         header.split(separator: ";").compactMap { part in
             let trimmed = part.trimmingCharacters(in: .whitespacesAndNewlines)
@@ -374,13 +457,19 @@ public struct AmpUsageFetcher: Sendable {
     }
 
     static func shouldAttachCookie(to url: URL?) -> Bool {
+        guard url?.scheme?.lowercased() == "https" else { return false }
+        return self.isAmpHost(url)
+    }
+
+    private static func isAmpHost(_ url: URL?) -> Bool {
         guard let host = url?.host?.lowercased() else { return false }
         if host == "ampcode.com" || host == "www.ampcode.com" { return true }
         return host.hasSuffix(".ampcode.com")
     }
 
     static func isLoginRedirect(_ url: URL) -> Bool {
-        guard self.shouldAttachCookie(to: url) else { return false }
+        guard self.isAmpHost(url) else { return false }
+        if url.host?.lowercased() == "auth.ampcode.com" { return true }
 
         let path = url.path.lowercased()
         let components = path.split(separator: "/").map(String.init)
diff --git a/Sources/CodexBarCore/Providers/Amp/AmpUsageParser.swift b/Sources/CodexBarCore/Providers/Amp/AmpUsageParser.swift
index d0a68fca34..e933807d71 100644
--- a/Sources/CodexBarCore/Providers/Amp/AmpUsageParser.swift
+++ b/Sources/CodexBarCore/Providers/Amp/AmpUsageParser.swift
@@ -17,7 +17,63 @@ enum AmpUsageParser {
             updatedAt: now)
     }
 
-    private struct FreeTierUsage: Sendable {
+    static func parse(displayText: String, now: Date = Date()) throws -> AmpUsageSnapshot {
+        let text = TextParsing.stripANSICodes(displayText)
+        let identityPattern = #"(?im)^\s*Signed in as\s+([^\s(]+)(?:\s+\(([^\r\n)]+)\))?\s*$"#
+        let identity = self.captures(in: text, pattern: identityPattern)
+        if identity == nil, self.looksSignedOut(text) {
+            throw AmpUsageError.notLoggedIn
+        }
+
+        let amountPattern = #"([0-9][0-9,]*(?:\.[0-9]+)?)"#
+        let freePattern = #"(?im)^\s*Amp Free:\s*\$?"# + amountPattern +
+            #"\s*/\s*\$?"# + amountPattern +
+            #"\s+remaining(?:\s*\(replenishes\s*\+\$?"# + amountPattern + #"\s*/\s*hour\))?"#
+        let creditsPattern = #"(?im)^\s*Individual credits:\s*\$?"# + amountPattern + #"\s+remaining"#
+        let individualCredits = self.captures(in: text, pattern: creditsPattern)?.first
+            .flatMap(self.number(from:))
+        let workspacePattern = #"(?im)^\s*Workspace\s+(.+?):\s*\$?"# + amountPattern + #"\s+remaining"#
+        let workspaceBalances: [AmpWorkspaceBalance] = self.allCaptures(
+            in: text,
+            pattern: workspacePattern).compactMap { captures -> AmpWorkspaceBalance? in
+            guard captures.count == 2,
+                  let name = self.nonEmpty(captures[0]),
+                  let remaining = self.number(from: captures[1])
+            else { return nil }
+            return AmpWorkspaceBalance(name: name, remaining: remaining)
+        }
+        let freeUsage: FreeTierUsage? = {
+            guard let free = self.captures(in: text, pattern: freePattern),
+                  let remaining = self.number(from: free[0]),
+                  let quota = self.number(from: free[1])
+            else { return nil }
+            let hourlyReplenishment = self.number(from: free[2]) ?? 0
+            let windowHours = hourlyReplenishment > 0
+                ? max(1, (quota / hourlyReplenishment).rounded())
+                : nil
+            return FreeTierUsage(
+                quota: quota,
+                used: max(0, quota - remaining),
+                hourlyReplenishment: hourlyReplenishment,
+                windowHours: windowHours)
+        }()
+        guard freeUsage != nil || individualCredits != nil || !workspaceBalances.isEmpty else {
+            throw AmpUsageError.parseFailed("Missing Amp usage data.")
+        }
+
+        return AmpUsageSnapshot(
+            freeQuota: freeUsage?.quota,
+            freeUsed: freeUsage?.used,
+            hourlyReplenishment: freeUsage?.hourlyReplenishment,
+            windowHours: freeUsage?.windowHours,
+            individualCredits: individualCredits,
+            workspaceBalances: workspaceBalances,
+            accountEmail: self.nonEmpty(identity?[0]),
+            accountOrganization: self.nonEmpty(identity?[1]),
+            updatedAt: now)
+    }
+
+    private struct FreeTierUsage {
         let quota: Double
         let used: Double
         let hourlyReplenishment: Double
@@ -98,6 +154,41 @@ enum AmpUsageParser {
         return Double(text[valueRange])
     }
 
+    private static func captures(in text: String, pattern: String) -> [String]? {
+        guard let regex = try? NSRegularExpression(pattern: pattern) else { return nil }
+        let range = NSRange(text.startIndex..<text.endIndex, in: text)
+        guard let match = regex.firstMatch(in: text, options: [], range: range) else { return nil }
+
+        return self.captures(in: text, match: match)
+    }
+
+    private static func allCaptures(in text: String, pattern: String) -> [[String]] {
+        guard let regex = try? NSRegularExpression(pattern: pattern) else { return [] }
+        let range = NSRange(text.startIndex..<text.endIndex, in: text)
+        return regex.matches(in: text, options: [], range: range).map { match in
+            self.captures(in: text, match: match)
+        }
+    }
+
+    private static func captures(in text: String, match: NSTextCheckingResult) -> [String] {
+        (1..<match.numberOfRanges).map { index in
+            let captureRange = match.range(at: index)
+            guard captureRange.location != NSNotFound,
+                  let range = Range(captureRange, in: text)
+            else { return "" }
+            return String(text[range]).trimmingCharacters(in: .whitespacesAndNewlines)
+        }
+    }
+
+    private static func number(from text: String) -> Double? {
+        Double(text.replacingOccurrences(of: ",", with: ""))
+    }
+
+    private static func nonEmpty(_ text: String?) -> String? {
+        guard let text, !text.isEmpty else { return nil }
+        return text
+    }
+
     private static func looksSignedOut(_ html: String) -> Bool {
         let lower = html.lowercased()
         if lower.contains("sign in") || lower.contains("log in") || lower.contains("login") {
diff --git a/Sources/CodexBarCore/Providers/Amp/AmpUsageSnapshot.swift b/Sources/CodexBarCore/Providers/Amp/AmpUsageSnapshot.swift
index 034fe6f9cb..b81624f304 100644
--- a/Sources/CodexBarCore/Providers/Amp/AmpUsageSnapshot.swift
+++ b/Sources/CodexBarCore/Providers/Amp/AmpUsageSnapshot.swift
@@ -1,66 +1,104 @@
 import Foundation
 
+public struct AmpWorkspaceBalance: Codable, Equatable, Sendable {
+    public let name: String
+    public let remaining: Double
+
+    public init(name: String, remaining: Double) {
+        self.name = name
+        self.remaining = remaining
+    }
+}
+
+public struct AmpUsageDetails: Codable, Equatable, Sendable {
+    public let individualCredits: Double?
+    public let workspaceBalances: [AmpWorkspaceBalance]
+
+    public init(individualCredits: Double?, workspaceBalances: [AmpWorkspaceBalance]) {
+        self.individualCredits = individualCredits
+        self.workspaceBalances = workspaceBalances
+    }
+}
+
 public struct AmpUsageSnapshot: Sendable {
-    public let freeQuota: Double
-    public let freeUsed: Double
-    public let hourlyReplenishment: Double
+    public let freeQuota: Double?
+    public let freeUsed: Double?
+    public let hourlyReplenishment: Double?
     public let windowHours: Double?
+    public let individualCredits: Double?
+    public let workspaceBalances: [AmpWorkspaceBalance]
+    public let accountEmail: String?
+    public let accountOrganization: String?
     public let updatedAt: Date
 
     public init(
-        freeQuota: Double,
-        freeUsed: Double,
-        hourlyReplenishment: Double,
+        freeQuota: Double?,
+        freeUsed: Double?,
+        hourlyReplenishment: Double?,
         windowHours: Double?,
+        individualCredits: Double? = nil,
+        workspaceBalances: [AmpWorkspaceBalance] = [],
+        accountEmail: String? = nil,
+        accountOrganization: String? = nil,
         updatedAt: Date)
     {
         self.freeQuota = freeQuota
         self.freeUsed = freeUsed
         self.hourlyReplenishment = hourlyReplenishment
         self.windowHours = windowHours
+        self.individualCredits = individualCredits
+        self.workspaceBalances = workspaceBalances
+        self.accountEmail = accountEmail
+        self.accountOrganization = accountOrganization
         self.updatedAt = updatedAt
     }
 }
 
 extension AmpUsageSnapshot {
     public func toUsageSnapshot(now: Date = Date()) -> UsageSnapshot {
-        let quota = max(0, self.freeQuota)
-        let used = max(0, self.freeUsed)
-        let percent: Double = if quota > 0 {
-            min(100, (used / quota) * 100)
-        } else {
-            0
-        }
-
-        let windowMinutes: Int? = if let hours = self.windowHours, hours > 0 {
-            Int((hours * 60).rounded())
+        let primary: RateWindow? = if let freeQuota, let freeUsed {
+            {
+                let quota = max(0, freeQuota)
+                let used = max(0, freeUsed)
+                let percent = quota > 0 ? min(100, (used / quota) * 100) : 0
+                let windowMinutes: Int? = if let hours = self.windowHours, hours > 0 {
+                    Int((hours * 60).rounded())
+                } else {
+                    nil
+                }
+                let resetsAt: Date? = {
+                    guard quota > 0, let hourlyReplenishment, hourlyReplenishment > 0 else { return nil }
+                    return now.addingTimeInterval(max(0, used / hourlyReplenishment * 3600))
+                }()
+                return RateWindow(
+                    usedPercent: percent,
+                    windowMinutes: windowMinutes,
+                    resetsAt: resetsAt,
+                    resetDescription: nil)
+            }()
         } else {
             nil
         }
 
-        let resetsAt: Date? = {
-            guard quota > 0, self.hourlyReplenishment > 0 else { return nil }
-            let hoursToFull = used / self.hourlyReplenishment
-            let seconds = max(0, hoursToFull * 3600)
-            return now.addingTimeInterval(seconds)
-        }()
-
-        let primary = RateWindow(
-            usedPercent: percent,
-            windowMinutes: windowMinutes,
-            resetsAt: resetsAt,
-            resetDescription: nil)
-
         let identity = ProviderIdentitySnapshot(
             providerID: .amp,
-            accountEmail: nil,
-            accountOrganization: nil,
-            loginMethod: "Amp Free")
+            accountEmail: self.accountEmail,
+            accountOrganization: self.accountOrganization,
+            loginMethod: primary == nil ? "Amp" : "Amp Free")
+
+        let ampUsage: AmpUsageDetails? = if self.individualCredits != nil || !self.workspaceBalances.isEmpty {
+            AmpUsageDetails(
+                individualCredits: self.individualCredits,
+                workspaceBalances: self.workspaceBalances)
+        } else {
+            nil
+        }
 
         return UsageSnapshot(
             primary: primary,
             secondary: nil,
             tertiary: nil,
+            ampUsage: ampUsage,
             providerCost: nil,
             updatedAt: self.updatedAt,
             identity: identity)
diff --git a/Sources/CodexBarCore/Providers/Antigravity/AntigravityCLISession.swift b/Sources/CodexBarCore/Providers/Antigravity/AntigravityCLISession.swift
new file mode 100644
index 0000000000..997ba351f5
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Antigravity/AntigravityCLISession.swift
@@ -0,0 +1,1270 @@
+#if canImport(Darwin)
+import Darwin
+#elseif canImport(Glibc)
+import Glibc
+#elseif canImport(Musl)
+import Musl
+#endif
+import Foundation
+
+// MARK: - Antigravity CLI Process Abstractions
+
+protocol AntigravityCLIProcessHandle: AnyObject, Sendable {
+    var pid: pid_t { get }
+    var isRunning: Bool { get }
+    var processGroup: pid_t? { get }
+
+    func assignProcessGroup() -> pid_t?
+    func sendExit() throws
+    func closePTY()
+    func terminateRoot()
+    func killRoot()
+    func descendantPIDs() -> [pid_t]
+    func terminateTree(signal: Int32, knownDescendants: [pid_t])
+    func killDescendants(_ descendants: [pid_t])
+    func drainOutput() -> Data
+}
+
+protocol AntigravityCLIProcessLaunching: Sendable {
+    func launch(binary: String) throws -> any AntigravityCLIProcessHandle
+}
+
+enum AntigravityCLIAuthenticationPrompt {
+    static let evidence = Data("Select login method:".utf8)
+    private static let promptPattern = #"select\s+login\s+method\s*:?"#
+
+    static func contains(_ output: Data) -> Bool {
+        // `agy` briefly prints "You are currently not signed in" before it
+        // auto-refreshes an existing login. The actual blocking state is the
+        // interactive login-method prompt. The exact prompt is a CLI-owned TUI
+        // string, so keep matching tolerant to casing and whitespace changes.
+        if output.range(of: self.evidence) != nil {
+            return true
+        }
+        let asciiBytes = output.map { $0 < 0x80 ? $0 : 0x20 }
+        let text = String(bytes: asciiBytes, encoding: .utf8) ?? ""
+        return text.range(
+            of: self.promptPattern,
+            options: [.regularExpression, .caseInsensitive]) != nil
+    }
+}
+
+struct AntigravityCLIProcessIdentity: Equatable {
+    let executablePath: String
+    let startEpoch: TimeInterval
+}
+
+protocol AntigravityCLIProcessIdentityProviding: Sendable {
+    func identity(for pid: pid_t) -> AntigravityCLIProcessIdentity?
+}
+
+struct AntigravityCLISessionRecord: Codable, Equatable {
+    let pid: pid_t
+    let requestedBinaryPath: String
+    let executablePath: String
+    let startEpoch: TimeInterval
+    let processGroup: pid_t?
+    let ownerPID: pid_t?
+    let ownerExecutablePath: String?
+    let ownerStartEpoch: TimeInterval?
+
+    init(
+        pid: pid_t,
+        requestedBinaryPath: String,
+        executablePath: String,
+        startEpoch: TimeInterval,
+        processGroup: pid_t?,
+        ownerPID: pid_t? = nil,
+        ownerExecutablePath: String? = nil,
+        ownerStartEpoch: TimeInterval? = nil)
+    {
+        self.pid = pid
+        self.requestedBinaryPath = requestedBinaryPath
+        self.executablePath = executablePath
+        self.startEpoch = startEpoch
+        self.processGroup = processGroup
+        self.ownerPID = ownerPID
+        self.ownerExecutablePath = ownerExecutablePath
+        self.ownerStartEpoch = ownerStartEpoch
+    }
+}
+
+protocol AntigravityCLISessionRecordStoring: Sendable {
+    func load() throws -> [AntigravityCLISessionRecord]
+    func save(_ record: AntigravityCLISessionRecord) throws
+    func remove(_ record: AntigravityCLISessionRecord) throws
+}
+
+protocol AntigravityCLISessionLaunchLocking: Sendable {
+    func withLock<T>(_ operation: () throws -> T) throws -> T
+}
+
+// MARK: - AntigravityCLISession
+
+/// Manages a bounded background ``agy`` process whose embedded localhost server
+/// provides the same ``GetUserStatus`` endpoint as the desktop Antigravity app's
+/// ``language_server``. The CLI is kept alive in a PTY so its daemon stays bound
+/// to a local port - this lets CodexBar read Claude + Gemini quotas even when
+/// the desktop Antigravity app is closed.
+///
+/// The session intentionally does not scrape TUI output. It only launches and
+/// keeps the process reachable for HTTPS probing, drains discarded PTY output so
+/// the CLI cannot block on a full terminal buffer, and bounds the warm lifetime
+/// with an idle timer so CodexBar does not run an IDE backend forever.
+actor AntigravityCLISession {
+    static let shared = AntigravityCLISession()
+    private static let log = CodexBarLog.logger(LogCategories.antigravity)
+
+    enum ResetCause: Int {
+        case deferred
+        case oneShotCLI
+        case unhealthy
+        case authentication
+
+        var message: String {
+            switch self {
+            case .deferred: "deferred reset"
+            case .oneShotCLI: "one-shot CLI fetch"
+            case .unhealthy: "unhealthy CLI HTTPS session"
+            case .authentication: "authentication required"
+            }
+        }
+    }
+
+    private struct LaunchOutcome {
+        let pid: pid_t
+        let rejectedProcess: (any AntigravityCLIProcessHandle)?
+        let rejectionMessage: String?
+        let holdsLaunchReservation: Bool
+    }
+
+    struct Dependencies {
+        var launcher: any AntigravityCLIProcessLaunching
+        var identityProvider: any AntigravityCLIProcessIdentityProviding
+        var recordStore: any AntigravityCLISessionRecordStoring
+        var launchLock: any AntigravityCLISessionLaunchLocking
+        var beginAppShutdownTrackedLaunch: @Sendable () -> Bool
+        var endAppShutdownTrackedLaunch: @Sendable () -> Void
+        var registerForAppShutdown: @Sendable (pid_t, String) -> Bool
+        var updateAppShutdownProcessGroup: @Sendable (pid_t, pid_t?) -> Void
+        var unregisterForAppShutdown: @Sendable (pid_t) -> Void
+        var descendantPIDs: @Sendable (pid_t) -> [pid_t]
+        var terminateProcessTree: @Sendable (pid_t, pid_t?, Int32, [pid_t]) -> Void
+        var currentProcessID: @Sendable () -> pid_t
+        var now: @Sendable () -> Date
+        var sleep: @Sendable (UInt64) async throws -> Void
+        var idleWindow: TimeInterval
+        var failureRelaunchThreshold: Int
+        var terminationGracePeriod: TimeInterval
+
+        static func live() -> Self {
+            Self(
+                launcher: AntigravityPTYProcessLauncher(),
+                identityProvider: AntigravityProcessIdentityProvider(),
+                recordStore: AntigravityFileCLISessionRecordStore(),
+                launchLock: AntigravityFileCLISessionLaunchLock(),
+                beginAppShutdownTrackedLaunch: {
+                    TTYCommandRunner.beginActiveProcessLaunchForAppShutdown()
+                },
+                endAppShutdownTrackedLaunch: {
+                    TTYCommandRunner.endActiveProcessLaunchForAppShutdown()
+                },
+                registerForAppShutdown: { pid, binary in
+                    TTYCommandRunner.registerActiveProcessForAppShutdown(pid: pid, binary: binary)
+                },
+                updateAppShutdownProcessGroup: { pid, group in
+                    TTYCommandRunner.updateActiveProcessGroupForAppShutdown(pid: pid, processGroup: group)
+                },
+                unregisterForAppShutdown: { pid in
+                    TTYCommandRunner.unregisterActiveProcessForAppShutdown(pid: pid)
+                },
+                descendantPIDs: { pid in
+                    TTYProcessTreeTerminator.descendantPIDs(of: pid)
+                },
+                terminateProcessTree: { pid, group, signal, knownDescendants in
+                    TTYProcessTreeTerminator.terminateProcessTree(
+                        rootPID: pid,
+                        processGroup: group,
+                        signal: signal,
+                        knownDescendants: knownDescendants)
+                },
+                currentProcessID: getpid,
+                now: Date.init,
+                sleep: { nanoseconds in
+                    try await Task.sleep(nanoseconds: nanoseconds)
+                },
+                idleWindow: 180,
+                failureRelaunchThreshold: 2,
+                terminationGracePeriod: 1)
+        }
+    }
+
+    // MARK: State
+
+    private let dependencies: Dependencies
+    private var process: (any AntigravityCLIProcessHandle)?
+    private var binaryPath: String?
+    private var sessionIdleWindow: TimeInterval
+    private var activeProbeCount = 0
+    private var activeSessionProbeCount = 0
+    private var resetRequestedWhenIdle = false
+    private var hardResetRequestedWhenIdle = false
+    private var pendingResetCause: ResetCause?
+    private var idleTask: Task<Void, Never>?
+    private var sessionGeneration: UInt64 = 0
+    private var consecutiveProbeFailures = 0
+    private var persistedProcessIdentity: AntigravityCLIProcessIdentity?
+    private var recentOutput = Data()
+    private var authenticationPromptObserved = false
+    private var lastStopReason: String?
+    private var lifecycleOperationInProgress = false
+    private var lifecycleWaiters: [CheckedContinuation<Void, Never>] = []
+    private var exclusiveProbeWaiters: [CheckedContinuation<Void, Never>] = []
+
+    init(dependencies: Dependencies = .live()) {
+        self.dependencies = dependencies
+        self.sessionIdleWindow = dependencies.idleWindow
+    }
+
+    /// The pid of the running ``agy`` process, exposed so callers can discover
+    /// its listening ports via `lsof`.
+    var pid: pid_t? {
+        guard let proc = self.process, proc.isRunning else { return nil }
+        return proc.pid
+    }
+
+    /// Whether the managed process is alive and matches ``binaryPath``.
+    var isRunning: Bool {
+        guard let proc = self.process, proc.isRunning, self.binaryPath != nil else { return false }
+        return true
+    }
+
+    var failureCountForTesting: Int {
+        self.consecutiveProbeFailures
+    }
+
+    var idleWindowForTesting: TimeInterval {
+        self.sessionIdleWindow
+    }
+
+    var activeProbeCountForTesting: Int {
+        self.activeProbeCount
+    }
+
+    var lastStopReasonForTesting: String? {
+        self.lastStopReason
+    }
+
+    // MARK: Lifecycle
+
+    /// Mark a probe as active and ensure a warm ``agy`` is running on the given binary path.
+    ///
+    /// Callers must balance this with ``finishProbe(success:resetAfterFetch:)`` so
+    /// idle/reset cleanup cannot kill the process while its ports are being probed.
+    /// If previous probes repeatedly failed while the process stayed alive, this
+    /// force-relaunches instead of reusing a wedged HTTPS server forever.
+    func beginProbe(binary: String, idleWindow: TimeInterval? = nil) async throws -> pid_t {
+        self.activeProbeCount += 1
+        if let idleWindow, idleWindow > 0 {
+            self.sessionIdleWindow = max(self.dependencies.idleWindow, idleWindow)
+        }
+        self.cancelIdleTimer()
+        do {
+            return try await self.withLifecycleOperation {
+                let pid = try await self.ensureStartedLocked(binary: binary)
+                self.activeSessionProbeCount += 1
+                return pid
+            }
+        } catch {
+            self.activeProbeCount = max(0, self.activeProbeCount - 1)
+            self.notifyExclusiveProbeWaitersIfNeeded()
+            if self.activeProbeCount == 0, self.resetRequestedWhenIdle {
+                await self.withLifecycleOperation {
+                    guard self.activeProbeCount == 0 else {
+                        self.resetRequestedWhenIdle = true
+                        return
+                    }
+                    let forceTerminate = self.hardResetRequestedWhenIdle || self.consecutiveProbeFailures > 0
+                    self.resetRequestedWhenIdle = false
+                    self.hardResetRequestedWhenIdle = false
+                    await self.stopCurrentSessionLocked(
+                        reason: "deferred reset after failed begin",
+                        clearRecord: true,
+                        graceful: !forceTerminate)
+                }
+            }
+            throw error
+        }
+    }
+
+    /// Record probe completion and either keep the session warm for the bounded
+    /// idle window or tear it down immediately for one-shot CLI invocations.
+    func finishProbe(success: Bool, resetAfterFetch: Bool, forceTerminate: Bool = false) async {
+        if success {
+            self.consecutiveProbeFailures = 0
+        } else {
+            self.consecutiveProbeFailures += 1
+        }
+
+        self.activeProbeCount = max(0, self.activeProbeCount - 1)
+        self.activeSessionProbeCount = max(0, self.activeSessionProbeCount - 1)
+        self.notifyExclusiveProbeWaitersIfNeeded()
+        let shouldForceStopUnhealthy = !success &&
+            self.consecutiveProbeFailures >= max(1, self.dependencies.failureRelaunchThreshold)
+        let shouldReset = forceTerminate || resetAfterFetch || self.resetRequestedWhenIdle || shouldForceStopUnhealthy
+        let currentResetCause = Self.resetCause(
+            authenticationRequired: forceTerminate,
+            resetAfterFetch: resetAfterFetch,
+            shouldForceStopUnhealthy: shouldForceStopUnhealthy)
+
+        guard self.activeProbeCount == 0 else {
+            if shouldReset {
+                self.resetRequestedWhenIdle = true
+                self.pendingResetCause = Self.strongestResetCause(self.pendingResetCause, currentResetCause)
+            }
+            if shouldReset, !success || forceTerminate {
+                self.hardResetRequestedWhenIdle = true
+            }
+            return
+        }
+
+        if shouldReset {
+            let shouldForceTerminate = !success || forceTerminate || self.hardResetRequestedWhenIdle
+            let resetCause = Self.strongestResetCause(self.pendingResetCause, currentResetCause)
+            await self.withLifecycleOperation {
+                guard self.activeProbeCount == 0 else {
+                    self.resetRequestedWhenIdle = true
+                    self.pendingResetCause = Self.strongestResetCause(self.pendingResetCause, resetCause)
+                    if shouldForceTerminate {
+                        self.hardResetRequestedWhenIdle = true
+                    }
+                    return
+                }
+                self.resetRequestedWhenIdle = false
+                self.hardResetRequestedWhenIdle = false
+                self.pendingResetCause = nil
+                await self.stopCurrentSessionLocked(
+                    reason: resetCause.message,
+                    clearRecord: true,
+                    graceful: !shouldForceTerminate)
+            }
+        } else {
+            self.armIdleTimer()
+        }
+    }
+
+    static func resetCause(
+        authenticationRequired: Bool,
+        resetAfterFetch: Bool,
+        shouldForceStopUnhealthy: Bool) -> ResetCause
+    {
+        if authenticationRequired {
+            .authentication
+        } else if shouldForceStopUnhealthy {
+            .unhealthy
+        } else if resetAfterFetch {
+            .oneShotCLI
+        } else {
+            .deferred
+        }
+    }
+
+    static func strongestResetCause(_ existing: ResetCause?, _ incoming: ResetCause) -> ResetCause {
+        guard let existing else { return incoming }
+        return existing.rawValue >= incoming.rawValue ? existing : incoming
+    }
+
+    /// Ensure a warm ``agy`` is running on the given binary path.
+    ///
+    /// - If the process is already alive with the same binary, this returns immediately.
+    /// - If the process died, the binary changed, or repeated probes failed, it tears down the old one first.
+    /// - Returns the process identifier for port discovery.
+    func ensureStarted(binary: String) async throws -> pid_t {
+        try await self.withLifecycleOperation {
+            try await self.ensureStartedLocked(binary: binary)
+        }
+    }
+
+    /// Request teardown. If a probe is in flight, cleanup is deferred until the
+    /// matching ``finishProbe(success:resetAfterFetch:)`` call.
+    func reset() async {
+        self.cancelIdleTimer()
+        guard self.activeProbeCount == 0 else {
+            self.resetRequestedWhenIdle = true
+            return
+        }
+        await self.withLifecycleOperation {
+            guard self.activeProbeCount == 0 else {
+                self.resetRequestedWhenIdle = true
+                return
+            }
+            self.resetRequestedWhenIdle = false
+            let forceTerminate = self.hardResetRequestedWhenIdle || self.consecutiveProbeFailures > 0
+            self.hardResetRequestedWhenIdle = false
+            await self.stopCurrentSessionLocked(
+                reason: "manual reset",
+                clearRecord: true,
+                graceful: !forceTerminate)
+        }
+    }
+
+    /// Drain PTY output into one rolling buffer shared by concurrent probes.
+    func drainOutput() -> Data {
+        var searchableOutput = self.recentOutput
+        if let output = self.process?.drainOutput(), !output.isEmpty {
+            searchableOutput.append(output)
+            self.recentOutput = Data(searchableOutput.suffix(4096))
+        }
+
+        if !self.authenticationPromptObserved,
+           AntigravityCLIAuthenticationPrompt.contains(searchableOutput)
+        {
+            self.authenticationPromptObserved = true
+        }
+        if self.authenticationPromptObserved,
+           !AntigravityCLIAuthenticationPrompt.contains(searchableOutput)
+        {
+            searchableOutput.append(AntigravityCLIAuthenticationPrompt.evidence)
+        }
+        return searchableOutput
+    }
+
+    // MARK: Errors
+
+    enum SessionError: LocalizedError {
+        case launchFailed(String)
+
+        var errorDescription: String? {
+            switch self {
+            case let .launchFailed(msg): "Failed to launch Antigravity CLI session: \(msg)"
+            }
+        }
+    }
+
+    // MARK: Private
+
+    private func withLifecycleOperation<T>(_ operation: () async throws -> T) async throws -> T {
+        await self.acquireLifecycleOperation()
+        defer { self.releaseLifecycleOperation() }
+        return try await operation()
+    }
+
+    private func withLifecycleOperation(_ operation: () async -> Void) async {
+        await self.acquireLifecycleOperation()
+        defer { self.releaseLifecycleOperation() }
+        await operation()
+    }
+
+    private func acquireLifecycleOperation() async {
+        guard self.lifecycleOperationInProgress else {
+            self.lifecycleOperationInProgress = true
+            return
+        }
+        await withCheckedContinuation { continuation in
+            self.lifecycleWaiters.append(continuation)
+        }
+    }
+
+    private func releaseLifecycleOperation() {
+        guard !self.lifecycleWaiters.isEmpty else {
+            self.lifecycleOperationInProgress = false
+            return
+        }
+        let next = self.lifecycleWaiters.removeFirst()
+        next.resume()
+    }
+
+    private func waitForExclusiveProbeIfNeeded() async {
+        while self.activeSessionProbeCount > 0 {
+            await withCheckedContinuation { continuation in
+                self.exclusiveProbeWaiters.append(continuation)
+            }
+        }
+    }
+
+    private func notifyExclusiveProbeWaitersIfNeeded() {
+        guard self.activeSessionProbeCount == 0, !self.exclusiveProbeWaiters.isEmpty else { return }
+        let waiters = self.exclusiveProbeWaiters
+        self.exclusiveProbeWaiters.removeAll()
+        for waiter in waiters {
+            waiter.resume()
+        }
+    }
+
+    private func ensureStartedLocked(binary: String) async throws -> pid_t {
+        while true {
+            if let proc = self.process,
+               proc.isRunning,
+               self.binaryPath == binary,
+               !self.resetRequestedWhenIdle,
+               !self.hardResetRequestedWhenIdle,
+               self.consecutiveProbeFailures < max(1, self.dependencies.failureRelaunchThreshold)
+            {
+                try? self.dependencies.launchLock.withLock {
+                    self.reapRecordedSessionsIfNeeded()
+                }
+                self.persistCurrentRecordIfNeeded(proc, binary: binary)
+                Self.log.debug("Antigravity CLI session reused", metadata: ["pid": "\(proc.pid)"])
+                return proc.pid
+            }
+
+            if self.process != nil {
+                if self.activeSessionProbeCount > 0 {
+                    await self.waitForExclusiveProbeIfNeeded()
+                    continue
+                }
+
+                let reason = self.consecutiveProbeFailures >= max(1, self.dependencies.failureRelaunchThreshold)
+                    ? "relaunching unhealthy session"
+                    : "replacing stale session"
+                let forceTerminate = self.hardResetRequestedWhenIdle || self.consecutiveProbeFailures > 0
+                self.resetRequestedWhenIdle = false
+                self.hardResetRequestedWhenIdle = false
+                await self.stopCurrentSessionLocked(
+                    reason: reason,
+                    clearRecord: true,
+                    graceful: !forceTerminate)
+            }
+
+            let binaryName = URL(fileURLWithPath: binary).lastPathComponent
+            let launch: (Bool) throws -> LaunchOutcome = { canPersistRecord in
+                if canPersistRecord {
+                    self.prepareRecordStoreForLaunch()
+                }
+                guard self.dependencies.beginAppShutdownTrackedLaunch() else {
+                    throw SessionError.launchFailed("App shutdown in progress")
+                }
+                let launched: any AntigravityCLIProcessHandle
+                do {
+                    launched = try self.dependencies.launcher.launch(binary: binary)
+                } catch {
+                    self.dependencies.endAppShutdownTrackedLaunch()
+                    throw error
+                }
+                let launchedPID = launched.pid
+                guard self.dependencies.registerForAppShutdown(launchedPID, binaryName) else {
+                    return LaunchOutcome(
+                        pid: launchedPID,
+                        rejectedProcess: launched,
+                        rejectionMessage: "App shutdown in progress",
+                        holdsLaunchReservation: true)
+                }
+
+                let processGroup = launched.processGroup ?? launched.assignProcessGroup()
+                self.dependencies.updateAppShutdownProcessGroup(launchedPID, processGroup)
+
+                self.process = launched
+                self.binaryPath = binary
+                self.recentOutput.removeAll(keepingCapacity: true)
+                self.authenticationPromptObserved = false
+                self.consecutiveProbeFailures = 0
+                self.sessionGeneration &+= 1
+                if canPersistRecord {
+                    _ = self.persistRecord(pid: launchedPID, binary: binary, processGroup: processGroup)
+                } else {
+                    self.persistedProcessIdentity = nil
+                }
+                self.dependencies.endAppShutdownTrackedLaunch()
+                return LaunchOutcome(
+                    pid: launchedPID,
+                    rejectedProcess: nil,
+                    rejectionMessage: nil,
+                    holdsLaunchReservation: false)
+            }
+
+            var lockedLaunch: Result<LaunchOutcome, Error>?
+            var lockFailure: Error?
+            do {
+                try self.dependencies.launchLock.withLock {
+                    lockedLaunch = Result { try launch(true) }
+                }
+            } catch {
+                lockFailure = error
+            }
+
+            let outcome: LaunchOutcome
+            if let lockFailure {
+                Self.log.warning(
+                    "Antigravity CLI session coordination unavailable",
+                    metadata: ["error": lockFailure.localizedDescription])
+                outcome = try launch(false)
+            } else if let lockedLaunch {
+                outcome = try lockedLaunch.get()
+            } else {
+                throw SessionError.launchFailed("CLI session launch did not complete")
+            }
+            if let rejectedProcess = outcome.rejectedProcess {
+                await self.terminateLaunchedProcess(rejectedProcess, graceful: false)
+                if outcome.holdsLaunchReservation {
+                    self.dependencies.endAppShutdownTrackedLaunch()
+                }
+                throw SessionError.launchFailed(outcome.rejectionMessage ?? "App shutdown in progress")
+            }
+
+            Self.log.debug(
+                "Antigravity CLI session started",
+                metadata: [
+                    "binary": binaryName,
+                    "pid": "\(outcome.pid)",
+                ])
+            return outcome.pid
+        }
+    }
+
+    private func prepareRecordStoreForLaunch() {
+        guard self.process == nil || self.persistedProcessIdentity == nil else { return }
+        self.reapRecordedSessionsIfNeeded()
+    }
+
+    private func persistCurrentRecordIfNeeded(_ proc: any AntigravityCLIProcessHandle, binary: String) {
+        guard self.persistedProcessIdentity == nil else { return }
+        try? self.dependencies.launchLock.withLock {
+            self.prepareRecordStoreForLaunch()
+            _ = self.persistRecord(pid: proc.pid, binary: binary, processGroup: proc.processGroup)
+        }
+    }
+
+    private func cancelIdleTimer() {
+        self.idleTask?.cancel()
+        self.idleTask = nil
+    }
+
+    private func armIdleTimer() {
+        guard self.process != nil, self.sessionIdleWindow > 0 else { return }
+        self.cancelIdleTimer()
+        let generation = self.sessionGeneration
+        let nanoseconds = Self.nanoseconds(from: self.sessionIdleWindow)
+        let sleep = self.dependencies.sleep
+        self.idleTask = Task { [weak self] in
+            do {
+                try await sleep(nanoseconds)
+                await self?.stopIfIdle(generation: generation)
+            } catch {
+                // Cancellation is the normal path when a refresh reuses the warm session.
+            }
+        }
+    }
+
+    private func stopIfIdle(generation: UInt64) async {
+        await self.withLifecycleOperation {
+            guard generation == self.sessionGeneration else { return }
+            guard self.activeProbeCount == 0 else {
+                self.armIdleTimer()
+                return
+            }
+            let forceTerminate = self.hardResetRequestedWhenIdle || self.consecutiveProbeFailures > 0
+            self.resetRequestedWhenIdle = false
+            self.hardResetRequestedWhenIdle = false
+            await self.stopCurrentSessionLocked(
+                reason: "idle timeout",
+                clearRecord: true,
+                graceful: !forceTerminate)
+        }
+    }
+
+    private func stopCurrentSessionLocked(reason: String, clearRecord: Bool, graceful: Bool = true) async {
+        self.cancelIdleTimer()
+        let effectiveReason = self.pendingResetCause?.message ?? reason
+        self.pendingResetCause = nil
+        self.lastStopReason = effectiveReason
+        guard let proc = self.process else {
+            if clearRecord {
+                try? self.dependencies.launchLock.withLock {
+                    self.reapRecordedSessionsIfNeeded()
+                }
+            }
+            self.sessionIdleWindow = self.dependencies.idleWindow
+            self.recentOutput.removeAll(keepingCapacity: true)
+            self.authenticationPromptObserved = false
+            return
+        }
+
+        let pid = proc.pid
+        let identity = self.persistedProcessIdentity
+        Self.log.debug("Antigravity CLI session stopping", metadata: ["pid": "\(pid)", "reason": "\(effectiveReason)"])
+
+        self.process = nil
+        self.binaryPath = nil
+        self.persistedProcessIdentity = nil
+        self.sessionIdleWindow = self.dependencies.idleWindow
+        self.recentOutput.removeAll(keepingCapacity: true)
+        self.authenticationPromptObserved = false
+        self.sessionGeneration &+= 1
+
+        await self.terminateLaunchedProcess(proc, graceful: graceful)
+        self.dependencies.unregisterForAppShutdown(pid)
+        if clearRecord {
+            self.removeRecordIfMatches(pid: pid, identity: identity)
+        }
+    }
+
+    private func terminateLaunchedProcess(
+        _ proc: any AntigravityCLIProcessHandle,
+        graceful: Bool = true) async
+    {
+        if graceful {
+            try? proc.sendExit()
+        }
+        proc.closePTY()
+
+        let descendants = proc.descendantPIDs()
+        if proc.isRunning {
+            proc.terminateRoot()
+        }
+        proc.terminateTree(signal: SIGTERM, knownDescendants: descendants)
+
+        let gracePeriod = self.dependencies.terminationGracePeriod
+        if gracePeriod > 0 {
+            let deadline = self.dependencies.now().addingTimeInterval(gracePeriod)
+            while proc.isRunning, self.dependencies.now() < deadline {
+                try? await self.dependencies.sleep(100_000_000)
+            }
+        }
+
+        if proc.isRunning {
+            proc.terminateTree(signal: SIGKILL, knownDescendants: descendants)
+            await self.waitUntilProcessExits(proc, timeout: 1)
+        } else {
+            proc.killDescendants(descendants)
+        }
+    }
+
+    private func waitUntilProcessExits(_ proc: any AntigravityCLIProcessHandle, timeout: TimeInterval) async {
+        let deadline = self.dependencies.now().addingTimeInterval(timeout)
+        while proc.isRunning, self.dependencies.now() < deadline {
+            try? await self.dependencies.sleep(50_000_000)
+        }
+        _ = proc.isRunning
+    }
+
+    @discardableResult
+    private func persistRecord(pid: pid_t, binary: String, processGroup: pid_t?) -> Bool {
+        guard let identity = self.dependencies.identityProvider.identity(for: pid) else {
+            self.persistedProcessIdentity = nil
+            return false
+        }
+        let ownerPID = self.dependencies.currentProcessID()
+        let ownerIdentity = self.dependencies.identityProvider.identity(for: ownerPID)
+        let record = AntigravityCLISessionRecord(
+            pid: pid,
+            requestedBinaryPath: binary,
+            executablePath: identity.executablePath,
+            startEpoch: identity.startEpoch,
+            processGroup: processGroup,
+            ownerPID: ownerPID,
+            ownerExecutablePath: ownerIdentity?.executablePath,
+            ownerStartEpoch: ownerIdentity?.startEpoch)
+        do {
+            try self.dependencies.recordStore.save(record)
+            self.persistedProcessIdentity = identity
+            return true
+        } catch {
+            self.persistedProcessIdentity = nil
+            return false
+        }
+    }
+
+    private func reapRecordedSessionsIfNeeded() {
+        guard let records = try? self.dependencies.recordStore.load() else { return }
+        for record in records {
+            guard let liveIdentity = self.dependencies.identityProvider.identity(for: record.pid),
+                  liveIdentity.executablePath == record.executablePath,
+                  abs(liveIdentity.startEpoch - record.startEpoch) < 0.001
+            else {
+                try? self.dependencies.recordStore.remove(record)
+                continue
+            }
+            if let proc = self.process, proc.pid == record.pid {
+                self.persistedProcessIdentity = liveIdentity
+                continue
+            }
+            if let ownerPID = record.ownerPID,
+               ownerPID != self.dependencies.currentProcessID(),
+               let ownerExecutablePath = record.ownerExecutablePath,
+               let ownerStartEpoch = record.ownerStartEpoch,
+               let liveOwnerIdentity = self.dependencies.identityProvider.identity(for: ownerPID),
+               liveOwnerIdentity.executablePath == ownerExecutablePath,
+               abs(liveOwnerIdentity.startEpoch - ownerStartEpoch) < 0.001
+            {
+                continue
+            }
+
+            let knownDescendants = self.dependencies.descendantPIDs(record.pid)
+            Self.log.debug("Reaping stale Antigravity CLI session", metadata: ["pid": "\(record.pid)"])
+            self.dependencies.terminateProcessTree(record.pid, record.processGroup, SIGTERM, knownDescendants)
+            self.dependencies.terminateProcessTree(record.pid, record.processGroup, SIGKILL, knownDescendants)
+            try? self.dependencies.recordStore.remove(record)
+        }
+    }
+
+    private func removeRecordIfMatches(pid: pid_t, identity: AntigravityCLIProcessIdentity?) {
+        try? self.dependencies.launchLock.withLock {
+            guard let identity, let records = try? self.dependencies.recordStore.load() else { return }
+            for record in records
+                where record.pid == pid &&
+                record.executablePath == identity.executablePath &&
+                abs(record.startEpoch - identity.startEpoch) < 0.001
+            {
+                try? self.dependencies.recordStore.remove(record)
+            }
+        }
+    }
+
+    private static func nanoseconds(from interval: TimeInterval) -> UInt64 {
+        guard interval > 0 else { return 0 }
+        guard interval.isFinite else { return UInt64.max }
+        let nanoseconds = interval * 1_000_000_000
+        guard nanoseconds < TimeInterval(UInt64.max) else { return UInt64.max }
+        return UInt64(nanoseconds)
+    }
+}
+
+// MARK: - Production Process Implementation
+
+struct AntigravityPTYProcessLauncher: AntigravityCLIProcessLaunching {
+    static func defaultSignalsForSpawn() -> sigset_t {
+        var signals = sigset_t()
+        sigemptyset(&signals)
+        sigaddset(&signals, SIGINT)
+        sigaddset(&signals, SIGTERM)
+        sigaddset(&signals, SIGHUP)
+        return signals
+    }
+
+    static func spawnWithTextBusyRetry(
+        maxAttempts: Int = 3,
+        retryDelay: TimeInterval = 0.01,
+        spawn: () -> Int32) -> Int32
+    {
+        var result = spawn()
+        guard maxAttempts > 1 else { return result }
+
+        for _ in 1..<maxAttempts where result == ETXTBSY {
+            if retryDelay > 0 {
+                Thread.sleep(forTimeInterval: retryDelay)
+            }
+            result = spawn()
+        }
+        return result
+    }
+
+    func launch(binary: String) throws -> any AntigravityCLIProcessHandle {
+        try self.launch(binary: binary, arguments: [])
+    }
+
+    func launch(binary: String, arguments: [String]) throws -> any AntigravityCLIProcessHandle {
+        var primaryFD: Int32 = -1
+        var secondaryFD: Int32 = -1
+        var win = winsize(ws_row: 50, ws_col: 160, ws_xpixel: 0, ws_ypixel: 0)
+        guard openpty(&primaryFD, &secondaryFD, nil, nil, &win) == 0 else {
+            throw AntigravityCLISession.SessionError.launchFailed("openpty failed")
+        }
+        _ = fcntl(primaryFD, F_SETFL, O_NONBLOCK)
+
+        let primaryHandle = FileHandle(fileDescriptor: primaryFD, closeOnDealloc: true)
+        let secondaryHandle = FileHandle(fileDescriptor: secondaryFD, closeOnDealloc: true)
+
+        #if canImport(Darwin)
+        var fileActions: posix_spawn_file_actions_t?
+        #else
+        var fileActions = posix_spawn_file_actions_t()
+        #endif
+        guard posix_spawn_file_actions_init(&fileActions) == 0 else {
+            try? primaryHandle.close()
+            try? secondaryHandle.close()
+            throw AntigravityCLISession.SessionError.launchFailed("posix_spawn_file_actions_init failed")
+        }
+        defer { posix_spawn_file_actions_destroy(&fileActions) }
+
+        posix_spawn_file_actions_adddup2(&fileActions, secondaryFD, 0)
+        posix_spawn_file_actions_adddup2(&fileActions, secondaryFD, 1)
+        posix_spawn_file_actions_adddup2(&fileActions, secondaryFD, 2)
+        posix_spawn_file_actions_addclose(&fileActions, primaryFD)
+        posix_spawn_file_actions_addclose(&fileActions, secondaryFD)
+
+        let homeDirectory = NSHomeDirectory()
+        _ = homeDirectory.withCString { path in
+            posix_spawn_file_actions_addchdir_np(&fileActions, path)
+        }
+        #if canImport(Glibc) || canImport(Musl)
+        do {
+            try PosixSpawnFileActionsCloseFrom.addCloseFrom(&fileActions, startingAt: 3)
+        } catch {
+            try? primaryHandle.close()
+            try? secondaryHandle.close()
+            throw AntigravityCLISession.SessionError.launchFailed(error.localizedDescription)
+        }
+        #endif
+
+        #if canImport(Darwin)
+        var attr: posix_spawnattr_t?
+        #else
+        var attr = posix_spawnattr_t()
+        #endif
+        guard posix_spawnattr_init(&attr) == 0 else {
+            try? primaryHandle.close()
+            try? secondaryHandle.close()
+            throw AntigravityCLISession.SessionError.launchFailed("posix_spawnattr_init failed")
+        }
+        defer { posix_spawnattr_destroy(&attr) }
+        var defaultSignals = Self.defaultSignalsForSpawn()
+        posix_spawnattr_setsigdefault(&attr, &defaultSignals)
+        #if canImport(Darwin)
+        let spawnFlags = POSIX_SPAWN_SETPGROUP | POSIX_SPAWN_SETSIGDEF | POSIX_SPAWN_CLOEXEC_DEFAULT
+        #else
+        let spawnFlags = POSIX_SPAWN_SETPGROUP | POSIX_SPAWN_SETSIGDEF
+        #endif
+        posix_spawnattr_setflags(&attr, Int16(spawnFlags))
+        posix_spawnattr_setpgroup(&attr, 0)
+
+        var env = TTYCommandRunner.enrichedEnvironment()
+        env["PWD"] = NSHomeDirectory()
+        env["TERM"] = "xterm-256color"
+
+        var cArgs = ([binary] + arguments).map { strdup($0) as UnsafeMutablePointer<CChar>? }
+        cArgs.append(nil)
+        defer {
+            for arg in cArgs {
+                if let arg {
+                    free(arg)
+                }
+            }
+        }
+
+        var cEnv: [UnsafeMutablePointer<CChar>?] = env.map { key, value in
+            strdup("\(key)=\(value)")
+        }
+        cEnv.append(nil)
+        defer {
+            for entry in cEnv {
+                if let entry {
+                    free(entry)
+                }
+            }
+        }
+
+        var pid: pid_t = 0
+        let spawnResult = Self.spawnWithTextBusyRetry {
+            binary.withCString { execPath in
+                posix_spawn(&pid, execPath, &fileActions, &attr, cArgs, cEnv)
+            }
+        }
+        guard spawnResult == 0 else {
+            try? primaryHandle.close()
+            try? secondaryHandle.close()
+            throw AntigravityCLISession.SessionError.launchFailed(String(cString: strerror(spawnResult)))
+        }
+
+        return AntigravitySpawnedPTYProcessHandle(
+            pid: pid,
+            processGroup: pid,
+            primaryFD: primaryFD,
+            primaryHandle: primaryHandle,
+            secondaryHandle: secondaryHandle)
+    }
+}
+
+final class AntigravitySpawnedPTYProcessHandle: AntigravityCLIProcessHandle, @unchecked Sendable {
+    private let lock = NSLock()
+    private let processPID: pid_t
+    private let processGroupID: pid_t
+    private let primaryFD: Int32
+    private let primaryHandle: FileHandle
+    private let secondaryHandle: FileHandle
+    private var reaped = false
+
+    init(
+        pid: pid_t,
+        processGroup: pid_t,
+        primaryFD: Int32,
+        primaryHandle: FileHandle,
+        secondaryHandle: FileHandle)
+    {
+        self.processPID = pid
+        self.processGroupID = processGroup
+        self.primaryFD = primaryFD
+        self.primaryHandle = primaryHandle
+        self.secondaryHandle = secondaryHandle
+    }
+
+    var pid: pid_t {
+        self.processPID
+    }
+
+    var isRunning: Bool {
+        self.lock.lock()
+        if self.reaped {
+            self.lock.unlock()
+            return false
+        }
+        self.lock.unlock()
+
+        var status: Int32 = 0
+        let result = waitpid(self.processPID, &status, WNOHANG)
+
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        switch result {
+        case 0:
+            return true
+        case self.processPID:
+            self.reaped = true
+            return false
+        case -1 where errno == ECHILD:
+            self.reaped = true
+            return false
+        default:
+            return kill(self.processPID, 0) == 0 || errno == EPERM
+        }
+    }
+
+    var processGroup: pid_t? {
+        self.processGroupID
+    }
+
+    func assignProcessGroup() -> pid_t? {
+        self.processGroupID
+    }
+
+    func sendExit() throws {
+        try self.writeAllToPrimary(Data("/exit\r".utf8))
+    }
+
+    func closePTY() {
+        try? self.primaryHandle.close()
+        try? self.secondaryHandle.close()
+    }
+
+    func terminateRoot() {
+        kill(self.processPID, SIGTERM)
+    }
+
+    func killRoot() {
+        kill(self.processPID, SIGKILL)
+    }
+
+    func descendantPIDs() -> [pid_t] {
+        TTYProcessTreeTerminator.descendantPIDs(of: self.processPID)
+    }
+
+    func terminateTree(signal: Int32, knownDescendants: [pid_t]) {
+        TTYProcessTreeTerminator.terminateProcessTree(
+            rootPID: self.processPID,
+            processGroup: self.processGroupID,
+            signal: signal,
+            knownDescendants: knownDescendants)
+    }
+
+    func killDescendants(_ descendants: [pid_t]) {
+        for pid in descendants where pid > 0 {
+            kill(pid, SIGKILL)
+        }
+    }
+
+    func drainOutput() -> Data {
+        var tmp = [UInt8](repeating: 0, count: 8192)
+        var output: [UInt8] = []
+        for _ in 0..<64 {
+            let n = read(self.primaryFD, &tmp, tmp.count)
+            if n > 0 {
+                output.append(contentsOf: tmp.prefix(n))
+                continue
+            }
+            break
+        }
+        return Data(output)
+    }
+
+    private func writeAllToPrimary(_ data: Data) throws {
+        data.withUnsafeBytes { rawBytes in
+            guard let baseAddress = rawBytes.baseAddress else { return }
+            var offset = 0
+            var retries = 0
+            while offset < rawBytes.count {
+                let written = write(self.primaryFD, baseAddress.advanced(by: offset), rawBytes.count - offset)
+                if written > 0 {
+                    offset += written
+                    retries = 0
+                    continue
+                }
+                if written == 0 { break }
+
+                let err = errno
+                if err == EINTR || err == EAGAIN || err == EWOULDBLOCK {
+                    retries += 1
+                    if retries > 200 { return }
+                    usleep(5000)
+                    continue
+                }
+                return
+            }
+        }
+    }
+}
+
+// MARK: - Production Stale Session Identity + Storage
+
+struct AntigravityProcessIdentityProvider: AntigravityCLIProcessIdentityProviding {
+    func identity(for pid: pid_t) -> AntigravityCLIProcessIdentity? {
+        #if canImport(Darwin)
+        var pathBuffer = [CChar](repeating: 0, count: 4096)
+        let pathLength = proc_pidpath(pid, &pathBuffer, UInt32(pathBuffer.count))
+        guard pathLength > 0 else { return nil }
+        let executablePath = pathBuffer.withUnsafeBufferPointer { buffer -> String? in
+            let rawBytes = UnsafeRawBufferPointer(start: buffer.baseAddress, count: Int(pathLength))
+            return String(bytes: rawBytes.prefix { $0 != 0 }, encoding: .utf8)
+        }
+        guard let executablePath, !executablePath.isEmpty else { return nil }
+
+        var info = proc_bsdinfo()
+        let size = proc_pidinfo(
+            pid,
+            PROC_PIDTBSDINFO,
+            0,
+            &info,
+            Int32(MemoryLayout<proc_bsdinfo>.stride))
+        guard size == Int32(MemoryLayout<proc_bsdinfo>.stride) else { return nil }
+        let startEpoch = TimeInterval(info.pbi_start_tvsec) + (TimeInterval(info.pbi_start_tvusec) / 1_000_000)
+        return AntigravityCLIProcessIdentity(executablePath: executablePath, startEpoch: startEpoch)
+        #else
+        let procDirectory = "/proc/\(pid)"
+        guard let executablePath = try? FileManager.default.destinationOfSymbolicLink(
+            atPath: "\(procDirectory)/exe"),
+            let stat = try? String(contentsOfFile: "\(procDirectory)/stat", encoding: .utf8),
+            let closeParen = stat.lastIndex(of: ")")
+        else {
+            return nil
+        }
+        let fields = stat[stat.index(after: closeParen)...].split(whereSeparator: \.isWhitespace)
+        let clockTicksPerSecond = sysconf(Int32(_SC_CLK_TCK))
+        let systemStat = try? String(contentsOfFile: "/proc/stat", encoding: .utf8)
+        let bootEpoch = systemStat?
+            .split(separator: "\n")
+            .first { $0.hasPrefix("btime ") }?
+            .split(whereSeparator: \.isWhitespace)
+            .dropFirst()
+            .first
+            .flatMap { TimeInterval($0) }
+        guard fields.count > 19,
+              let startTicks = TimeInterval(fields[19]),
+              clockTicksPerSecond > 0,
+              let bootEpoch
+        else {
+            return nil
+        }
+        let startEpoch = bootEpoch + (startTicks / TimeInterval(clockTicksPerSecond))
+        return AntigravityCLIProcessIdentity(executablePath: executablePath, startEpoch: startEpoch)
+        #endif
+    }
+}
+
+final class AntigravityFileCLISessionRecordStore: AntigravityCLISessionRecordStoring, @unchecked Sendable {
+    private let fileURL: URL
+    private let fileManager: FileManager
+
+    init(
+        fileURL: URL = URL(fileURLWithPath: NSHomeDirectory(), isDirectory: true)
+            .appendingPathComponent(".codexbar", isDirectory: true)
+            .appendingPathComponent("antigravity", isDirectory: true)
+            .appendingPathComponent("agy-session.json"),
+        fileManager: FileManager = .default)
+    {
+        self.fileURL = fileURL
+        self.fileManager = fileManager
+    }
+
+    func load() throws -> [AntigravityCLISessionRecord] {
+        guard self.fileManager.fileExists(atPath: self.fileURL.path) else { return [] }
+        let data = try Data(contentsOf: self.fileURL)
+        let decoder = JSONDecoder()
+        if let records = try? decoder.decode([AntigravityCLISessionRecord].self, from: data) {
+            return records
+        }
+        return try [decoder.decode(AntigravityCLISessionRecord.self, from: data)]
+    }
+
+    func save(_ record: AntigravityCLISessionRecord) throws {
+        var records = (try? self.load()) ?? []
+        records.removeAll { Self.sameOwner($0, record) }
+        records.append(record)
+        try self.write(records)
+    }
+
+    func remove(_ record: AntigravityCLISessionRecord) throws {
+        var records = try self.load()
+        records.removeAll {
+            $0.pid == record.pid &&
+                $0.executablePath == record.executablePath &&
+                abs($0.startEpoch - record.startEpoch) < 0.001
+        }
+        if records.isEmpty {
+            guard self.fileManager.fileExists(atPath: self.fileURL.path) else { return }
+            try self.fileManager.removeItem(at: self.fileURL)
+        } else {
+            try self.write(records)
+        }
+    }
+
+    private func write(_ records: [AntigravityCLISessionRecord]) throws {
+        let directory = self.fileURL.deletingLastPathComponent()
+        try self.fileManager.createDirectory(at: directory, withIntermediateDirectories: true)
+        let data = try JSONEncoder().encode(records)
+        try data.write(to: self.fileURL, options: [.atomic])
+    }
+
+    private static func sameOwner(
+        _ lhs: AntigravityCLISessionRecord,
+        _ rhs: AntigravityCLISessionRecord) -> Bool
+    {
+        if let lhsOwnerPID = lhs.ownerPID,
+           let rhsOwnerPID = rhs.ownerPID,
+           let lhsOwnerPath = lhs.ownerExecutablePath,
+           let rhsOwnerPath = rhs.ownerExecutablePath,
+           let lhsOwnerStart = lhs.ownerStartEpoch,
+           let rhsOwnerStart = rhs.ownerStartEpoch
+        {
+            return lhsOwnerPID == rhsOwnerPID &&
+                lhsOwnerPath == rhsOwnerPath &&
+                abs(lhsOwnerStart - rhsOwnerStart) < 0.001
+        }
+        return lhs.pid == rhs.pid &&
+            lhs.executablePath == rhs.executablePath &&
+            abs(lhs.startEpoch - rhs.startEpoch) < 0.001
+    }
+}
+
+final class AntigravityFileCLISessionLaunchLock: AntigravityCLISessionLaunchLocking, @unchecked Sendable {
+    private let fileURL: URL
+    private let fileManager: FileManager
+
+    init(
+        fileURL: URL = URL(fileURLWithPath: NSHomeDirectory(), isDirectory: true)
+            .appendingPathComponent(".codexbar", isDirectory: true)
+            .appendingPathComponent("antigravity", isDirectory: true)
+            .appendingPathComponent("agy-session.lock"),
+        fileManager: FileManager = .default)
+    {
+        self.fileURL = fileURL
+        self.fileManager = fileManager
+    }
+
+    func withLock<T>(_ operation: () throws -> T) throws -> T {
+        let directory = self.fileURL.deletingLastPathComponent()
+        try self.fileManager.createDirectory(at: directory, withIntermediateDirectories: true)
+        let fd = open(self.fileURL.path, O_CREAT | O_RDWR | O_CLOEXEC, S_IRUSR | S_IWUSR)
+        guard fd >= 0 else {
+            throw POSIXError(POSIXErrorCode(rawValue: errno) ?? .EIO)
+        }
+        defer {
+            _ = flock(fd, LOCK_UN)
+            close(fd)
+        }
+
+        while flock(fd, LOCK_EX) != 0 {
+            guard errno == EINTR else {
+                throw POSIXError(POSIXErrorCode(rawValue: errno) ?? .EIO)
+            }
+        }
+        return try operation()
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Antigravity/AntigravityLocalSnapshotSelection.swift b/Sources/CodexBarCore/Providers/Antigravity/AntigravityLocalSnapshotSelection.swift
new file mode 100644
index 0000000000..83785a198c
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Antigravity/AntigravityLocalSnapshotSelection.swift
@@ -0,0 +1,37 @@
+import Foundation
+
+extension AntigravityStatusProbe {
+    static func preferredLocalSnapshot(
+        _ snapshots: [AntigravityStatusSnapshot],
+        matchingAccountEmail expectedAccountEmail: String?) -> AntigravityStatusSnapshot?
+    {
+        var candidates = snapshots
+        if let expected = self.normalizedAccountEmail(expectedAccountEmail) {
+            let matches = snapshots.filter {
+                guard let found = self.normalizedAccountEmail($0.accountEmail) else { return false }
+                return found.caseInsensitiveCompare(expected) == .orderedSame
+            }
+            if !matches.isEmpty {
+                candidates = matches
+            }
+        }
+
+        var bestSnapshot: AntigravityStatusSnapshot?
+        var bestScore = Int.min
+        for snapshot in candidates {
+            let score = self.localSnapshotScore(snapshot)
+            if score > bestScore {
+                bestSnapshot = snapshot
+                bestScore = score
+            }
+        }
+        return bestSnapshot
+    }
+
+    private static func normalizedAccountEmail(_ email: String?) -> String? {
+        guard let trimmed = email?.trimmingCharacters(in: .whitespacesAndNewlines), !trimmed.isEmpty else {
+            return nil
+        }
+        return trimmed
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Antigravity/AntigravityLocalhostSession.swift b/Sources/CodexBarCore/Providers/Antigravity/AntigravityLocalhostSession.swift
new file mode 100644
index 0000000000..5a372eaf1f
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Antigravity/AntigravityLocalhostSession.swift
@@ -0,0 +1,109 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+enum LocalhostTrustPolicy {
+    static func shouldAcceptServerTrust(
+        host: String,
+        authenticationMethod: String,
+        hasServerTrust: Bool) -> Bool
+    {
+        #if !os(Linux)
+        guard authenticationMethod == NSURLAuthenticationMethodServerTrust else { return false }
+        #endif
+        let normalizedHost = host.lowercased()
+        guard normalizedHost == "127.0.0.1" || normalizedHost == "localhost" else { return false }
+        return hasServerTrust
+    }
+}
+
+final class LocalhostSessionDelegate: NSObject {
+    func data(for request: URLRequest, session: URLSession) async throws -> (Data, URLResponse) {
+        let state = LocalhostSessionTaskState()
+        return try await withTaskCancellationHandler {
+            try await withCheckedThrowingContinuation { continuation in
+                let task = session.dataTask(with: request) { data, response, error in
+                    if let error {
+                        continuation.resume(throwing: error)
+                        return
+                    }
+                    guard let data, let response else {
+                        continuation.resume(throwing: AntigravityStatusProbeError.apiError("Invalid response"))
+                        return
+                    }
+                    continuation.resume(returning: (data, response))
+                }
+                state.setTask(task)
+                task.resume()
+            }
+        } onCancel: {
+            state.cancel()
+        }
+    }
+
+    private func challengeResult(_ challenge: URLAuthenticationChallenge) -> (
+        disposition: URLSession.AuthChallengeDisposition,
+        credential: URLCredential?)
+    {
+        #if os(Linux)
+        return (.performDefaultHandling, nil)
+        #else
+        let protectionSpace = challenge.protectionSpace
+        let trust = protectionSpace.serverTrust
+        guard LocalhostTrustPolicy.shouldAcceptServerTrust(
+            host: protectionSpace.host,
+            authenticationMethod: protectionSpace.authenticationMethod,
+            hasServerTrust: trust != nil),
+            let trust
+        else {
+            return (.performDefaultHandling, nil)
+        }
+        return (.useCredential, URLCredential(trust: trust))
+        #endif
+    }
+}
+
+extension LocalhostSessionDelegate: URLSessionDelegate {
+    func urlSession(
+        _ session: URLSession,
+        didReceive challenge: URLAuthenticationChallenge) async -> (URLSession.AuthChallengeDisposition, URLCredential?)
+    {
+        self.challengeResult(challenge)
+    }
+}
+
+extension LocalhostSessionDelegate: URLSessionTaskDelegate {
+    func urlSession(
+        _ session: URLSession,
+        task: URLSessionTask,
+        didReceive challenge: URLAuthenticationChallenge) async -> (URLSession.AuthChallengeDisposition, URLCredential?)
+    {
+        self.challengeResult(challenge)
+    }
+}
+
+private final class LocalhostSessionTaskState: @unchecked Sendable {
+    private let lock = NSLock()
+    private var task: URLSessionDataTask?
+    private var isCancelled = false
+
+    func setTask(_ task: URLSessionDataTask) {
+        self.lock.lock()
+        self.task = task
+        let shouldCancel = self.isCancelled
+        self.lock.unlock()
+
+        if shouldCancel {
+            task.cancel()
+        }
+    }
+
+    func cancel() {
+        self.lock.lock()
+        self.isCancelled = true
+        let task = self.task
+        self.lock.unlock()
+        task?.cancel()
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Antigravity/AntigravityOAuthCredentialsStore.swift b/Sources/CodexBarCore/Providers/Antigravity/AntigravityOAuthCredentialsStore.swift
new file mode 100644
index 0000000000..06819e0463
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Antigravity/AntigravityOAuthCredentialsStore.swift
@@ -0,0 +1,516 @@
+import Foundation
+
+public struct AntigravityOAuthCredentials: Codable, Sendable, Equatable {
+    public var accessToken: String?
+    public var refreshToken: String?
+    public var expiryDateMilliseconds: Double?
+    public var idToken: String?
+    public var email: String?
+    public var projectID: String?
+    public var clientID: String?
+    public var clientSecret: String?
+
+    public init(
+        accessToken: String?,
+        refreshToken: String?,
+        expiryDate: Date?,
+        idToken: String? = nil,
+        email: String? = nil,
+        projectID: String? = nil,
+        clientID: String? = nil,
+        clientSecret: String? = nil)
+    {
+        self.accessToken = accessToken
+        self.refreshToken = refreshToken
+        self.expiryDateMilliseconds = expiryDate.map { $0.timeIntervalSince1970 * 1000 }
+        self.idToken = idToken
+        self.email = email
+        self.projectID = projectID
+        self.clientID = clientID
+        self.clientSecret = clientSecret
+    }
+
+    public var expiryDate: Date? {
+        guard let expiryDateMilliseconds else { return nil }
+        return Date(timeIntervalSince1970: expiryDateMilliseconds / 1000)
+    }
+
+    /// Email of the Google account these credentials authenticate, preferring the
+    /// signed `id_token` claim (what the remote OAuth fetcher reports) and falling
+    /// back to the stored `email` field. Used to verify that an ambient local/CLI
+    /// Antigravity snapshot belongs to the account the user explicitly selected.
+    public var resolvedAccountEmail: String? {
+        Self.email(fromIDToken: self.idToken) ?? self.email?.trimmedNonEmptyEmail
+    }
+
+    static func email(fromIDToken idToken: String?) -> String? {
+        guard let idToken else { return nil }
+        let parts = idToken.components(separatedBy: ".")
+        guard parts.count >= 2 else { return nil }
+        var payload = parts[1]
+            .replacingOccurrences(of: "-", with: "+")
+            .replacingOccurrences(of: "_", with: "/")
+        let remainder = payload.count % 4
+        if remainder > 0 {
+            payload += String(repeating: "=", count: 4 - remainder)
+        }
+        guard let data = Data(base64Encoded: payload, options: .ignoreUnknownCharacters),
+              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+        else {
+            return nil
+        }
+        return (json["email"] as? String)?.trimmedNonEmptyEmail
+    }
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.accessToken =
+            try container.decodeIfPresent(String.self, forKey: .accessTokenSnake)
+            ?? container.decodeIfPresent(String.self, forKey: .accessTokenCamel)
+        self.refreshToken =
+            try container.decodeIfPresent(String.self, forKey: .refreshTokenSnake)
+            ?? container.decodeIfPresent(String.self, forKey: .refreshTokenCamel)
+        self.idToken =
+            try container.decodeIfPresent(String.self, forKey: .idTokenSnake)
+            ?? container.decodeIfPresent(String.self, forKey: .idTokenCamel)
+        self.email = try container.decodeIfPresent(String.self, forKey: .email)
+        self.projectID =
+            try container.decodeIfPresent(String.self, forKey: .projectIDSnake)
+            ?? container.decodeIfPresent(String.self, forKey: .projectIDCamel)
+        self.clientID =
+            try container.decodeIfPresent(String.self, forKey: .clientIDSnake)
+            ?? container.decodeIfPresent(String.self, forKey: .clientIDCamel)
+        self.clientSecret =
+            try container.decodeIfPresent(String.self, forKey: .clientSecretSnake)
+            ?? container.decodeIfPresent(String.self, forKey: .clientSecretCamel)
+
+        if let expiryDateMilliseconds = try container.decodeIfPresent(Double.self, forKey: .expiryDateSnake)
+            ?? container.decodeIfPresent(Double.self, forKey: .expiresAtCamel)
+        {
+            self.expiryDateMilliseconds = expiryDateMilliseconds
+        } else if let expiryDateMilliseconds = try container.decodeIfPresent(Int.self, forKey: .expiryDateSnake)
+            ?? container.decodeIfPresent(Int.self, forKey: .expiresAtCamel)
+        {
+            self.expiryDateMilliseconds = Double(expiryDateMilliseconds)
+        } else {
+            self.expiryDateMilliseconds = nil
+        }
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encodeIfPresent(self.accessToken, forKey: .accessTokenSnake)
+        try container.encodeIfPresent(self.refreshToken, forKey: .refreshTokenSnake)
+        try container.encodeIfPresent(self.expiryDateMilliseconds, forKey: .expiryDateSnake)
+        try container.encodeIfPresent(self.idToken, forKey: .idTokenSnake)
+        try container.encodeIfPresent(self.email, forKey: .email)
+        try container.encodeIfPresent(self.projectID, forKey: .projectIDSnake)
+        try container.encodeIfPresent(self.clientID, forKey: .clientIDSnake)
+        try container.encodeIfPresent(self.clientSecret, forKey: .clientSecretSnake)
+    }
+
+    enum CodingKeys: String, CodingKey {
+        case accessTokenSnake = "access_token"
+        case accessTokenCamel = "accessToken"
+        case refreshTokenSnake = "refresh_token"
+        case refreshTokenCamel = "refreshToken"
+        case expiryDateSnake = "expiry_date"
+        case expiresAtCamel = "expiresAt"
+        case idTokenSnake = "id_token"
+        case idTokenCamel = "idToken"
+        case email
+        case projectIDSnake = "project_id"
+        case projectIDCamel = "projectId"
+        case clientIDSnake = "client_id"
+        case clientIDCamel = "clientId"
+        case clientSecretSnake = "client_secret"
+        case clientSecretCamel = "clientSecret"
+    }
+}
+
+public struct AntigravityOAuthClient: Sendable, Equatable {
+    public let clientID: String
+    public let clientSecret: String
+
+    public init(clientID: String, clientSecret: String) {
+        self.clientID = clientID
+        self.clientSecret = clientSecret
+    }
+}
+
+public enum AntigravityOAuthConfig {
+    public static var configuredClientID: String? {
+        let value = ProcessInfo.processInfo.environment["ANTIGRAVITY_OAUTH_CLIENT_ID"]
+        return value?.trimmingCharacters(in: .whitespacesAndNewlines).nilIfEmpty
+    }
+
+    public static var configuredClientSecret: String? {
+        let value = ProcessInfo.processInfo.environment["ANTIGRAVITY_OAUTH_CLIENT_SECRET"]
+        return value?.trimmingCharacters(in: .whitespacesAndNewlines).nilIfEmpty
+    }
+
+    public static let authURL = URL(string: "https://accounts.google.com/o/oauth2/v2/auth")!
+    public static let tokenURL = URL(string: "https://oauth2.googleapis.com/token")!
+    public static let userInfoURL = URL(string: "https://www.googleapis.com/oauth2/v2/userinfo")!
+    public static let scopes = [
+        "https://www.googleapis.com/auth/cloud-platform",
+        "https://www.googleapis.com/auth/userinfo.email",
+    ]
+
+    public static let missingCredentialsMessage =
+        """
+        Antigravity OAuth client is not configured. Install Antigravity.app or set \
+        ANTIGRAVITY_OAUTH_CLIENT_ID and ANTIGRAVITY_OAUTH_CLIENT_SECRET before logging in.
+        """
+
+    public static func resolvedClient() -> AntigravityOAuthClient? {
+        if let client = environmentClient() {
+            return client
+        }
+        return Self.discoverClientFromInstalledApp()
+    }
+
+    private static func environmentClient() -> AntigravityOAuthClient? {
+        guard let clientID = configuredClientID,
+              let clientSecret = configuredClientSecret
+        else {
+            return nil
+        }
+        return AntigravityOAuthClient(clientID: clientID, clientSecret: clientSecret)
+    }
+
+    static func discoverClientFromInstalledApp(
+        applicationRoots: [URL]? = nil,
+        fileManager: FileManager = .default) -> AntigravityOAuthClient?
+    {
+        for url in self.candidateOAuthClientArtifactURLs(
+            applicationRoots: applicationRoots,
+            fileManager: fileManager)
+            where fileManager.fileExists(atPath: url.path)
+        {
+            guard let data = try? Data(contentsOf: url),
+                  let client = Self.parseClient(fromInstalledArtifactData: data)
+            else {
+                continue
+            }
+            return client
+        }
+        return nil
+    }
+
+    static func candidateOAuthClientArtifactURLs(
+        applicationRoots: [URL]? = nil,
+        fileManager: FileManager = .default) -> [URL]
+    {
+        let roots = [
+            URL(fileURLWithPath: "/Applications", isDirectory: true),
+            fileManager.homeDirectoryForCurrentUser.appendingPathComponent("Applications", isDirectory: true),
+        ]
+        let applicationRoots = applicationRoots ?? roots
+        let appBundleURLs = self.candidateAntigravityAppBundleURLs(
+            applicationRoots: applicationRoots,
+            fileManager: fileManager)
+        let relativePaths = [
+            "Contents/Resources/app/extensions/antigravity/bin/language_server_macos_arm",
+            "Contents/Resources/app/extensions/antigravity/bin/language_server_macos_x64",
+            "Contents/Resources/app/extensions/antigravity/bin/language_server_macos",
+            "Contents/Resources/app/out/main.js",
+            "Contents/Resources/bin/language_server",
+            "Contents/Resources/bin/language_server_macos",
+        ]
+        return appBundleURLs.flatMap { bundleURL in
+            relativePaths.map { bundleURL.appendingPathComponent($0) }
+        }
+    }
+
+    private static func candidateAntigravityAppBundleURLs(
+        applicationRoots: [URL],
+        fileManager: FileManager) -> [URL]
+    {
+        var urls: [URL] = []
+
+        for root in applicationRoots {
+            urls.append(root.appendingPathComponent("Antigravity.app", isDirectory: true))
+
+            let appURLs = (try? fileManager.contentsOfDirectory(
+                at: root,
+                includingPropertiesForKeys: [.isDirectoryKey],
+                options: [.skipsHiddenFiles])) ?? []
+            for appURL in appURLs where appURL.pathExtension == "app" {
+                guard self.isAntigravityAppBundle(appURL) else { continue }
+                urls.append(appURL)
+            }
+        }
+
+        var seen = Set<String>()
+        return urls.filter { url in
+            let key = url.standardizedFileURL.path
+            guard !seen.contains(key) else { return false }
+            seen.insert(key)
+            return true
+        }
+    }
+
+    private static func isAntigravityAppBundle(_ url: URL) -> Bool {
+        switch Bundle(url: url)?.bundleIdentifier {
+        case "com.google.antigravity", "com.google.antigravity-ide":
+            true
+        default:
+            false
+        }
+    }
+
+    static func parseClient(fromInstalledArtifactData data: Data) -> AntigravityOAuthClient? {
+        if let content = String(data: data, encoding: .utf8),
+           let client = parseClient(fromInstalledArtifactText: content)
+        {
+            return client
+        }
+
+        let clientIDs = Self.clientIDs(in: data)
+        let clientSecrets = Self.clientSecrets(in: data)
+        guard let client = Self.preferredBinaryClient(
+            clientIDs: clientIDs,
+            clientSecrets: clientSecrets)
+        else {
+            return nil
+        }
+
+        return client
+    }
+
+    static func parseClient(fromInstalledArtifactText content: String) -> AntigravityOAuthClient? {
+        let marker = "vs/platform/cloudCode/common/oauthClient.js"
+        let searchStart = content.range(of: marker)?.lowerBound ?? content.startIndex
+        let searchEnd = content.index(searchStart, offsetBy: 4000, limitedBy: content.endIndex) ?? content.endIndex
+        let haystack = String(content[searchStart..<searchEnd])
+
+        guard let clientID = Self.firstMatch(
+            pattern: #"[0-9]+-[A-Za-z0-9_-]+\.apps\.googleusercontent\.com"#,
+            in: haystack),
+            let clientSecret = Self.firstMatch(
+                pattern: #"GOCSPX-[A-Za-z0-9_-]{28}"#,
+                in: haystack)
+        else {
+            return nil
+        }
+
+        return AntigravityOAuthClient(clientID: clientID, clientSecret: clientSecret)
+    }
+
+    private static func clientIDs(in data: Data) -> [String] {
+        let suffix = Data(".apps.googleusercontent.com".utf8)
+        var searchRange = data.startIndex..<data.endIndex
+        var values: [String] = []
+
+        while let range = data.range(of: suffix, options: [], in: searchRange) {
+            var start = range.lowerBound
+            while start > data.startIndex {
+                let previous = data.index(before: start)
+                guard Self.isOAuthClientIDPrefixByte(data[previous]) else { break }
+                start = previous
+            }
+
+            let candidateData = Data(data[start..<range.upperBound])
+            if let candidate = String(data: candidateData, encoding: .ascii),
+               let clientID = Self.firstMatch(
+                   pattern: #"[0-9]+-[A-Za-z0-9_-]+\.apps\.googleusercontent\.com"#,
+                   in: candidate)
+            {
+                values.append(clientID)
+            }
+
+            searchRange = range.upperBound..<data.endIndex
+        }
+
+        return self.unique(values)
+    }
+
+    private static func clientSecrets(in data: Data) -> [String] {
+        let prefix = Data("GOCSPX-".utf8)
+        let secretLength = 35
+        var searchRange = data.startIndex..<data.endIndex
+        var values: [String] = []
+
+        while let range = data.range(of: prefix, options: [], in: searchRange) {
+            let end = range.lowerBound + secretLength
+            if end <= data.endIndex {
+                let candidateData = Data(data[range.lowerBound..<end])
+                if candidateData.dropFirst(prefix.count).allSatisfy(Self.isOAuthClientSecretByte),
+                   let candidate = String(data: candidateData, encoding: .ascii)
+                {
+                    values.append(candidate)
+                }
+            }
+
+            searchRange = range.upperBound..<data.endIndex
+        }
+
+        return self.unique(values)
+    }
+
+    private static func preferredBinaryClient(
+        clientIDs: [String],
+        clientSecrets: [String]) -> AntigravityOAuthClient?
+    {
+        guard !clientIDs.isEmpty,
+              !clientSecrets.isEmpty
+        else {
+            return nil
+        }
+
+        if clientSecrets.count == 1, clientIDs.count > 1 {
+            return AntigravityOAuthClient(clientID: clientIDs[clientIDs.count - 1], clientSecret: clientSecrets[0])
+        }
+
+        let clientSecret: String = if clientSecrets.count == clientIDs.count, clientSecrets.count > 1 {
+            // Antigravity 2's language_server binary stores the secret table before the client id table.
+            clientSecrets[clientSecrets.count - 1]
+        } else {
+            clientSecrets[0]
+        }
+
+        return AntigravityOAuthClient(clientID: clientIDs[0], clientSecret: clientSecret)
+    }
+
+    private static func isOAuthClientIDPrefixByte(_ byte: UInt8) -> Bool {
+        (byte >= 48 && byte <= 57)
+            || (byte >= 65 && byte <= 90)
+            || (byte >= 97 && byte <= 122)
+            || byte == 45
+            || byte == 95
+    }
+
+    private static func isOAuthClientSecretByte(_ byte: UInt8) -> Bool {
+        self.isOAuthClientIDPrefixByte(byte)
+    }
+
+    private static func firstMatch(pattern: String, in text: String) -> String? {
+        guard let regex = try? NSRegularExpression(pattern: pattern) else { return nil }
+        let range = NSRange(text.startIndex..<text.endIndex, in: text)
+        guard let match = regex.firstMatch(in: text, range: range),
+              let swiftRange = Range(match.range, in: text)
+        else {
+            return nil
+        }
+        return String(text[swiftRange])
+    }
+
+    private static func unique(_ values: [String]) -> [String] {
+        var seen = Set<String>()
+        return values.filter { value in
+            guard !seen.contains(value) else { return false }
+            seen.insert(value)
+            return true
+        }
+    }
+}
+
+public struct AntigravityOAuthCredentialsStore: @unchecked Sendable {
+    public static let environmentCredentialsKey = "ANTIGRAVITY_OAUTH_CREDENTIALS_JSON"
+    private static let fileLock = NSLock()
+
+    public let fileURL: URL
+    private let fileManager: FileManager
+
+    public init(fileURL: URL = Self.defaultURL(), fileManager: FileManager = .default) {
+        self.fileURL = fileURL
+        self.fileManager = fileManager
+    }
+
+    public func load() throws -> AntigravityOAuthCredentials? {
+        try Self.fileLock.withLock {
+            try self.loadUnlocked()
+        }
+    }
+
+    private func loadUnlocked() throws -> AntigravityOAuthCredentials? {
+        guard self.fileManager.fileExists(atPath: self.fileURL.path) else { return nil }
+        let data = try Data(contentsOf: self.fileURL)
+        return try JSONDecoder().decode(AntigravityOAuthCredentials.self, from: data)
+    }
+
+    public func save(_ credentials: AntigravityOAuthCredentials) throws {
+        try Self.fileLock.withLock {
+            let data = try JSONEncoder.antigravityCredentials.encode(credentials)
+            let directory = self.fileURL.deletingLastPathComponent()
+            if !self.fileManager.fileExists(atPath: directory.path) {
+                try self.fileManager.createDirectory(at: directory, withIntermediateDirectories: true)
+            }
+            try data.write(to: self.fileURL, options: [.atomic])
+            try self.applySecurePermissionsIfNeeded()
+        }
+    }
+
+    public func deleteIfPresent() throws {
+        try Self.fileLock.withLock {
+            try self.deleteIfPresentUnlocked()
+        }
+    }
+
+    public func deleteIfPresent(
+        matching predicate: (AntigravityOAuthCredentials) -> Bool) throws
+    {
+        try Self.fileLock.withLock {
+            guard let credentials = try self.loadUnlocked(), predicate(credentials) else { return }
+            try self.deleteIfPresentUnlocked()
+        }
+    }
+
+    private func deleteIfPresentUnlocked() throws {
+        guard self.fileManager.fileExists(atPath: self.fileURL.path) else { return }
+        try self.fileManager.removeItem(at: self.fileURL)
+    }
+
+    public static func defaultDirectoryURL(home: URL = FileManager.default.homeDirectoryForCurrentUser) -> URL {
+        home
+            .appendingPathComponent(".codexbar", isDirectory: true)
+            .appendingPathComponent("antigravity", isDirectory: true)
+    }
+
+    public static func defaultURL(home: URL = FileManager.default.homeDirectoryForCurrentUser) -> URL {
+        self.defaultDirectoryURL(home: home)
+            .appendingPathComponent("oauth_creds.json")
+    }
+
+    public static func tokenAccountValue(for credentials: AntigravityOAuthCredentials) throws -> String {
+        let data = try JSONEncoder.antigravityCredentials.encode(credentials)
+        guard let value = String(data: data, encoding: .utf8) else {
+            throw CocoaError(.coderInvalidValue)
+        }
+        return value
+    }
+
+    public static func credentials(fromTokenAccountValue value: String) -> AntigravityOAuthCredentials? {
+        let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty, let data = trimmed.data(using: .utf8) else { return nil }
+        return try? JSONDecoder().decode(AntigravityOAuthCredentials.self, from: data)
+    }
+
+    private func applySecurePermissionsIfNeeded() throws {
+        #if os(macOS) || os(Linux)
+        try self.fileManager.setAttributes([
+            .posixPermissions: NSNumber(value: Int16(0o600)),
+        ], ofItemAtPath: self.fileURL.path)
+        #endif
+    }
+}
+
+extension JSONEncoder {
+    fileprivate static let antigravityCredentials: JSONEncoder = {
+        let encoder = JSONEncoder()
+        encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
+        return encoder
+    }()
+}
+
+extension String {
+    fileprivate var nilIfEmpty: String? {
+        self.isEmpty ? nil : self
+    }
+
+    fileprivate var trimmedNonEmptyEmail: String? {
+        let trimmed = self.trimmingCharacters(in: .whitespacesAndNewlines)
+        return trimmed.isEmpty ? nil : trimmed
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Antigravity/AntigravityProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Antigravity/AntigravityProviderDescriptor.swift
index 1e59964b09..b00184af74 100644
--- a/Sources/CodexBarCore/Providers/Antigravity/AntigravityProviderDescriptor.swift
+++ b/Sources/CodexBarCore/Providers/Antigravity/AntigravityProviderDescriptor.swift
@@ -1,19 +1,18 @@
-import CodexBarMacroSupport
 import Foundation
 
-@ProviderDescriptorRegistration
-@ProviderDescriptorDefinition
 public enum AntigravityProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
     static func makeDescriptor() -> ProviderDescriptor {
         ProviderDescriptor(
             id: .antigravity,
             metadata: ProviderMetadata(
                 id: .antigravity,
                 displayName: "Antigravity",
-                sessionLabel: "Claude",
-                weeklyLabel: "Gemini Pro",
-                opusLabel: "Gemini Flash",
-                supportsOpus: true,
+                sessionLabel: "Gemini Models",
+                weeklyLabel: "Claude and GPT",
+                opusLabel: nil,
+                supportsOpus: false,
                 supportsCredits: false,
                 creditsHint: "",
                 toggleTitle: "Show Antigravity usage (experimental)",
@@ -33,32 +32,379 @@ public enum AntigravityProviderDescriptor {
                 supportsTokenCost: false,
                 noDataMessage: { "Antigravity cost summary is not supported." }),
             fetchPlan: ProviderFetchPlan(
-                sourceModes: [.auto, .cli],
-                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [AntigravityStatusFetchStrategy()] })),
+                sourceModes: [.auto, .cli, .oauth],
+                pipeline: ProviderFetchPipeline(resolveStrategies: self.resolveStrategies)),
             cli: ProviderCLIConfig(
                 name: "antigravity",
                 versionDetector: nil))
     }
+
+    private static func resolveStrategies(context: ProviderFetchContext) async -> [any ProviderFetchStrategy] {
+        let app = AntigravityStatusFetchStrategy(source: .app)
+        let cli = AntigravityCLIHTTPSFetchStrategy()
+        let ide = AntigravityStatusFetchStrategy(source: .ide)
+        let oauth = AntigravityOAuthFetchStrategy()
+        switch context.sourceMode {
+        case .cli:
+            return [app, cli, ide]
+        case .oauth:
+            return [oauth]
+        case .auto:
+            if context.selectedTokenAccountID != nil ||
+                context.env[AntigravityOAuthCredentialsStore.environmentCredentialsKey] != nil ||
+                self.hasSharedOAuthCredentials(context: context)
+            {
+                return [app, cli, ide, oauth]
+            }
+            return [app, cli, ide]
+        case .web, .api:
+            return []
+        }
+    }
+
+    private static func hasSharedOAuthCredentials(context: ProviderFetchContext) -> Bool {
+        let homeURL = context.env["HOME"]
+            .flatMap { $0.isEmpty ? nil : URL(fileURLWithPath: $0, isDirectory: true) }
+            ?? FileManager.default.homeDirectoryForCurrentUser
+        let fileURL = AntigravityOAuthCredentialsStore.defaultURL(home: homeURL)
+        return FileManager.default.fileExists(atPath: fileURL.path)
+    }
 }
 
 struct AntigravityStatusFetchStrategy: ProviderFetchStrategy {
-    let id: String = "antigravity.local"
+    enum Source {
+        case app
+        case ide
+
+        var id: String {
+            switch self {
+            case .app: "antigravity.app-local"
+            case .ide: "antigravity.ide-local"
+            }
+        }
+
+        var processScope: AntigravityStatusProbe.ProcessScope {
+            switch self {
+            case .app: .appOnly
+            case .ide: .ideOnly
+            }
+        }
+
+        var sourceLabel: String {
+            switch self {
+            case .app: "app"
+            case .ide: "ide"
+            }
+        }
+    }
+
+    let source: Source
+    var id: String {
+        self.source.id
+    }
+
     let kind: ProviderFetchKind = .localProbe
 
+    init(source: Source = .app) {
+        self.source = source
+    }
+
     func isAvailable(_: ProviderFetchContext) async -> Bool {
         true
     }
 
-    func fetch(_: ProviderFetchContext) async throws -> ProviderFetchResult {
-        let probe = AntigravityStatusProbe()
-        let snap = try await probe.fetch()
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        let probe = AntigravityStatusProbe(processScope: self.source.processScope)
+        let selectedAccountEmail: String? = if context.sourceMode == .auto, context.selectedTokenAccountID != nil {
+            AntigravitySelectedAccountGuard.selectedAccountEmail(context: context)
+        } else {
+            nil
+        }
+        let snap = try await probe.fetch(matchingAccountEmail: selectedAccountEmail)
         let usage = try snap.toUsageSnapshot()
+        try AntigravitySelectedAccountGuard.validate(usage, context: context)
+        return self.makeResult(
+            usage: usage,
+            sourceLabel: self.source.sourceLabel)
+    }
+
+    func shouldFallback(on _: Error, context: ProviderFetchContext) -> Bool {
+        context.sourceMode == .auto || context.sourceMode == .cli
+    }
+}
+
+/// When the Antigravity 2.0 app is closed or unavailable, this strategy spawns
+/// or reuses ``agy`` and talks to the localhost server embedded in that CLI
+/// process. ``agy`` is an interactive REPL, not a query command, so CodexBar
+/// never scrapes TUI output here; it only keeps the process alive long enough
+/// for the server to answer quota endpoints.
+struct AntigravityCLIHTTPSFetchStrategy: ProviderFetchStrategy {
+    static let sourceLabel = "cli"
+    let id: String = "antigravity.cli-https"
+    let kind: ProviderFetchKind = .cli
+    private static let log = CodexBarLog.logger(LogCategories.antigravity)
+
+    struct SnapshotWaitDependencies {
+        let pollIntervalNanoseconds: UInt64
+        let listeningPorts: @Sendable (Int, TimeInterval) async throws -> [Int]
+        let drainOutput: @Sendable () async -> Data
+        let fetchSnapshot: @Sendable ([Int]) async throws -> AntigravityStatusSnapshot
+        let now: @Sendable () -> Date
+
+        init(
+            pollIntervalNanoseconds: UInt64,
+            listeningPorts: @escaping @Sendable (Int, TimeInterval) async throws -> [Int],
+            drainOutput: @escaping @Sendable () async -> Data,
+            fetchSnapshot: @escaping @Sendable ([Int]) async throws -> AntigravityStatusSnapshot,
+            now: @escaping @Sendable () -> Date = Date.init)
+        {
+            self.pollIntervalNanoseconds = pollIntervalNanoseconds
+            self.listeningPorts = listeningPorts
+            self.drainOutput = drainOutput
+            self.fetchSnapshot = fetchSnapshot
+            self.now = now
+        }
+    }
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        BinaryLocator.resolveAntigravityBinary(env: context.env) != nil
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        guard let binary = BinaryLocator.resolveAntigravityBinary(env: context.env) else {
+            throw AntigravityStatusProbeError.notRunning
+        }
+        let result = try await self.fetchUsingWarmSession(
+            binary: binary,
+            idleWindow: context.persistentCLISessionIdleWindow,
+            resetAfterFetch: Self.shouldResetSessionAfterFetch(context))
+        try AntigravitySelectedAccountGuard.validate(result.usage, context: context)
+        return result
+    }
+
+    private func fetchUsingWarmSession(
+        binary: String,
+        idleWindow: TimeInterval?,
+        resetAfterFetch: Bool) async throws -> ProviderFetchResult
+    {
+        let session = AntigravityCLISession.shared
+        let pid = try await session.beginProbe(binary: binary, idleWindow: idleWindow)
+        let deadline = Date().addingTimeInterval(5.0)
+        let snap: AntigravityStatusSnapshot
+        let usage: UsageSnapshot
+        do {
+            snap = try await Self.waitForSnapshot(
+                pid: pid,
+                deadline: deadline,
+                dependencies: SnapshotWaitDependencies(
+                    pollIntervalNanoseconds: 200_000_000,
+                    listeningPorts: { pid, timeout in
+                        try await AntigravityStatusProbe.listeningPorts(pid: pid, timeout: timeout)
+                    },
+                    drainOutput: {
+                        await session.drainOutput()
+                    },
+                    fetchSnapshot: { ports in
+                        let timeout = min(2.0, max(0.2, deadline.timeIntervalSinceNow))
+                        return try await AntigravityStatusProbe(timeout: timeout)
+                            .fetchFromPorts(ports, deadline: deadline)
+                    }))
+            usage = try snap.toUsageSnapshot()
+            await session.finishProbe(success: true, resetAfterFetch: resetAfterFetch)
+        } catch {
+            let authenticationRequired = (error as? AntigravityStatusProbeError) == .authenticationRequired
+            await session.finishProbe(
+                success: false,
+                resetAfterFetch: resetAfterFetch || authenticationRequired,
+                forceTerminate: authenticationRequired)
+            throw error
+        }
+
         return self.makeResult(
             usage: usage,
-            sourceLabel: "local")
+            sourceLabel: Self.sourceLabel)
+    }
+
+    static func shouldResetSessionAfterFetch(_ context: ProviderFetchContext) -> Bool {
+        // Long-lived hosts (the app, `codexbar serve`) keep the warm `agy`
+        // session between fetches; only one-shot CLI invocations reset it.
+        context.runtime == .cli && !context.persistsCLISessions
+    }
+
+    /// Waits for real API readiness, not just socket readiness. Fresh ``agy``
+    /// processes bind ports quickly, but ``GetUserStatus`` can return transient
+    /// initialization failures for a few seconds after the port appears.
+    static func waitForSnapshot(
+        pid: pid_t,
+        deadline: Date,
+        dependencies: SnapshotWaitDependencies) async throws -> AntigravityStatusSnapshot
+    {
+        var lastFetchError: Error?
+        while dependencies.now() < deadline {
+            try await Self.checkAuthenticationPrompt(dependencies)
+            let remaining = deadline.timeIntervalSince(dependencies.now())
+            let portProbeTimeout = min(2.0, max(0.2, remaining))
+            let ports: [Int]
+            do {
+                ports = try await dependencies.listeningPorts(Int(pid), portProbeTimeout)
+            } catch {
+                guard Self.isNoListeningPortsError(error) else {
+                    try await Self.checkAuthenticationPrompt(dependencies)
+                    throw error
+                }
+                ports = []
+            }
+            if !ports.isEmpty {
+                var readySnapshot: AntigravityStatusSnapshot?
+                do {
+                    let snapshot = try await dependencies.fetchSnapshot(ports)
+                    _ = try snapshot.toUsageSnapshot()
+                    readySnapshot = snapshot
+                } catch {
+                    try await Self.checkAuthenticationPrompt(dependencies)
+                    lastFetchError = error
+                    Self.log.debug("Antigravity CLI HTTPS endpoint not ready", metadata: [
+                        "pid": "\(pid)",
+                        "ports": ports.map(String.init).joined(separator: ","),
+                        "error": error.localizedDescription,
+                    ])
+                }
+                if let readySnapshot {
+                    try await Self.checkAuthenticationPrompt(dependencies)
+                    return readySnapshot
+                }
+            }
+
+            let remainingNanoseconds = UInt64(
+                max(0, deadline.timeIntervalSince(dependencies.now())) * 1_000_000_000)
+            guard remainingNanoseconds > 0 else { break }
+            let sleepNanoseconds = min(dependencies.pollIntervalNanoseconds, remainingNanoseconds)
+            if sleepNanoseconds > 0 {
+                try await Task.sleep(nanoseconds: sleepNanoseconds)
+            }
+        }
+
+        try await Self.checkAuthenticationPrompt(dependencies)
+        if let lastFetchError {
+            throw lastFetchError
+        }
+        Self.log.warning("Antigravity CLI HTTPS: no ports found for pid \(pid)")
+        throw AntigravityStatusProbeError.portDetectionFailed(
+            "Antigravity CLI started but no listening ports found")
+    }
+
+    static func containsAuthenticationPrompt(_ output: Data) -> Bool {
+        AntigravityCLIAuthenticationPrompt.contains(output)
+    }
+
+    private static func checkAuthenticationPrompt(_ dependencies: SnapshotWaitDependencies) async throws {
+        let terminalOutput = await dependencies.drainOutput()
+        if Self.containsAuthenticationPrompt(terminalOutput) {
+            throw AntigravityStatusProbeError.authenticationRequired
+        }
+    }
+
+    private static func isNoListeningPortsError(_ error: Error) -> Bool {
+        if case let AntigravityStatusProbeError.portDetectionFailed(message) = error {
+            return message == "no listening ports found"
+        }
+        if case let SubprocessRunnerError.nonZeroExit(code, stderr) = error {
+            return code == 1 && stderr.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+        }
+        return false
+    }
+
+    func shouldFallback(on _: Error, context: ProviderFetchContext) -> Bool {
+        context.sourceMode == .auto || context.sourceMode == .cli
+    }
+}
+
+struct AntigravityOAuthFetchStrategy: ProviderFetchStrategy {
+    let id: String = "antigravity.oauth"
+    let kind: ProviderFetchKind = .oauth
+
+    func isAvailable(_: ProviderFetchContext) async -> Bool {
+        true
+    }
+
+    static func usageSnapshot(
+        from snapshot: AntigravityStatusSnapshot,
+        updatedAt: Date = Date()) throws -> UsageSnapshot
+    {
+        if snapshot.modelQuotas.isEmpty {
+            return UsageSnapshot(
+                primary: nil,
+                secondary: nil,
+                tertiary: nil,
+                updatedAt: updatedAt,
+                identity: ProviderIdentitySnapshot(
+                    providerID: .antigravity,
+                    accountEmail: snapshot.accountEmail,
+                    accountOrganization: nil,
+                    loginMethod: snapshot.accountPlan))
+        }
+        return try snapshot.toUsageSnapshot()
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        let fetcher = AntigravityRemoteUsageFetcher(
+            environment: context.env,
+            credentialsUpdateHandler: { credentials in
+                guard let accountID = context.selectedTokenAccountID,
+                      let updater = context.tokenAccountTokenUpdater
+                else {
+                    return
+                }
+                let token = try AntigravityOAuthCredentialsStore.tokenAccountValue(for: credentials)
+                await updater(.antigravity, accountID, token)
+            })
+        let snapshot = try await fetcher.fetch()
+        let usage = try Self.usageSnapshot(from: snapshot)
+        return self.makeResult(
+            usage: usage,
+            sourceLabel: "oauth")
     }
 
     func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
         false
     }
 }
+
+/// Guards ambient Antigravity snapshots against the explicitly selected account.
+///
+/// The local desktop probe and the ``agy`` CLI HTTPS server report whichever
+/// Antigravity account is signed into the local session. When the user has
+/// selected a specific saved Google account, an ambient probe can return a
+/// *different* account's quota. Only the OAuth strategy is account-scoped (it
+/// fetches with the selected account's injected credentials), so in ``auto``
+/// mode we reject a snapshot whose identity does not match the selected account
+/// and let the pipeline fall through to OAuth. Explicit ``cli``/``oauth`` source
+/// modes stay authoritative and are never second-guessed here.
+enum AntigravitySelectedAccountGuard {
+    static func validate(_ usage: UsageSnapshot, context: ProviderFetchContext) throws {
+        guard context.sourceMode == .auto, context.selectedTokenAccountID != nil else { return }
+        let expected = self.selectedAccountEmail(context: context)
+        let found = self.normalizedEmail(usage.identity?.accountEmail)
+        guard let expected, let found, found.caseInsensitiveCompare(expected) == .orderedSame else {
+            throw AntigravityStatusProbeError.accountMismatch(expected: expected, found: found)
+        }
+    }
+
+    /// Email of the selected token account, read from the same injected
+    /// credentials the OAuth strategy would use (`ANTIGRAVITY_OAUTH_CREDENTIALS_JSON`).
+    static func selectedAccountEmail(context: ProviderFetchContext) -> String? {
+        guard let value = context.env[AntigravityOAuthCredentialsStore.environmentCredentialsKey],
+              let credentials = AntigravityOAuthCredentialsStore.credentials(fromTokenAccountValue: value)
+        else {
+            return nil
+        }
+        return credentials.resolvedAccountEmail
+    }
+
+    private static func normalizedEmail(_ email: String?) -> String? {
+        guard let trimmed = email?.trimmingCharacters(in: .whitespacesAndNewlines), !trimmed.isEmpty else {
+            return nil
+        }
+        return trimmed
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Antigravity/AntigravityQuotaSummaryParser.swift b/Sources/CodexBarCore/Providers/Antigravity/AntigravityQuotaSummaryParser.swift
new file mode 100644
index 0000000000..9928f7605d
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Antigravity/AntigravityQuotaSummaryParser.swift
@@ -0,0 +1,173 @@
+import Foundation
+
+// swiftformat:disable:next redundantSendable
+struct AntigravityQuotaSummary: Sendable, Equatable {
+    let description: String?
+    let groups: [AntigravityQuotaSummaryGroup]
+}
+
+// swiftformat:disable:next redundantSendable
+struct AntigravityQuotaSummaryGroup: Sendable, Equatable {
+    let displayName: String
+    let description: String?
+    let buckets: [AntigravityQuotaSummaryBucket]
+}
+
+// swiftformat:disable:next redundantSendable
+struct AntigravityQuotaSummaryBucket: Sendable, Equatable {
+    let bucketId: String
+    let displayName: String
+    let remainingFraction: Double?
+    let resetTime: Date?
+    let resetDescription: String?
+    let disabled: Bool
+
+    init(
+        bucketId: String,
+        displayName: String,
+        remainingFraction: Double?,
+        resetTime: Date? = nil,
+        resetDescription: String?,
+        disabled: Bool)
+    {
+        self.bucketId = bucketId
+        self.displayName = displayName
+        self.remainingFraction = remainingFraction
+        self.resetTime = resetTime
+        self.resetDescription = resetDescription
+        self.disabled = disabled
+    }
+}
+
+extension AntigravityStatusProbe {
+    static func parseQuotaSummaryResponse(_ data: Data) throws -> AntigravityStatusSnapshot {
+        let decoder = JSONDecoder()
+        let response = try decoder.decode(QuotaSummaryResponse.self, from: data)
+        if let invalid = Self.invalidCode(response.code) {
+            throw AntigravityStatusProbeError.apiError(invalid)
+        }
+        let payload = response.response ?? response.summary ?? response.rootPayload
+        guard let payload else {
+            throw AntigravityStatusProbeError.parseFailed("Missing quota summary")
+        }
+        let groups = payload.groups.compactMap(self.quotaSummaryGroup(from:))
+        guard !groups.isEmpty else {
+            throw AntigravityStatusProbeError.parseFailed("Missing quota groups")
+        }
+        return AntigravityStatusSnapshot(
+            quotaSummary: AntigravityQuotaSummary(
+                description: payload.description,
+                groups: groups),
+            accountEmail: nil,
+            accountPlan: nil,
+            source: .local)
+    }
+
+    private static func quotaSummaryGroup(from payload: QuotaSummaryGroupPayload) -> AntigravityQuotaSummaryGroup? {
+        let displayName = payload.displayName?.trimmingCharacters(in: .whitespacesAndNewlines)
+        let buckets = (payload.buckets ?? []).compactMap(self.quotaSummaryBucket(from:))
+        guard !buckets.isEmpty else { return nil }
+        return AntigravityQuotaSummaryGroup(
+            displayName: self.nonEmpty(displayName) ?? "Quota",
+            description: payload.description,
+            buckets: buckets)
+    }
+
+    private static func quotaSummaryBucket(from payload: QuotaSummaryBucketPayload) -> AntigravityQuotaSummaryBucket? {
+        let bucketId = payload.bucketId?.trimmingCharacters(in: .whitespacesAndNewlines)
+        let displayName = payload.displayName?.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard let resolvedBucketId = bucketId, !resolvedBucketId.isEmpty else { return nil }
+        let resetTime = payload.resetTime.flatMap { Self.parseDate($0) }
+        return AntigravityQuotaSummaryBucket(
+            bucketId: resolvedBucketId,
+            displayName: self.nonEmpty(displayName) ?? resolvedBucketId,
+            remainingFraction: payload.resolvedRemainingFraction,
+            resetTime: resetTime,
+            resetDescription: payload.description,
+            disabled: payload.disabled ?? false)
+    }
+
+    private static func nonEmpty(_ value: String?) -> String? {
+        guard let value, !value.isEmpty else { return nil }
+        return value
+    }
+}
+
+private struct QuotaSummaryResponse: Decodable {
+    let code: CodeValue?
+    let message: String?
+    let response: QuotaSummaryPayload?
+    let summary: QuotaSummaryPayload?
+    let description: String?
+    let groups: [QuotaSummaryGroupPayload]?
+
+    var rootPayload: QuotaSummaryPayload? {
+        guard let groups else { return nil }
+        return QuotaSummaryPayload(description: self.description, groups: groups)
+    }
+}
+
+private struct QuotaSummaryPayload: Decodable {
+    let description: String?
+    let groups: [QuotaSummaryGroupPayload]
+
+    init(description: String?, groups: [QuotaSummaryGroupPayload]) {
+        self.description = description
+        self.groups = groups
+    }
+
+    private enum CodingKeys: String, CodingKey {
+        case description
+        case groups
+    }
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.description = try container.decodeIfPresent(String.self, forKey: .description)
+        self.groups = try container.decodeIfPresent([QuotaSummaryGroupPayload].self, forKey: .groups) ?? []
+    }
+}
+
+private struct QuotaSummaryGroupPayload: Decodable {
+    let displayName: String?
+    let description: String?
+    let buckets: [QuotaSummaryBucketPayload]?
+}
+
+private struct QuotaSummaryBucketPayload: Decodable {
+    let bucketId: String?
+    let displayName: String?
+    let description: String?
+    let disabled: Bool?
+    let remainingFraction: Double?
+    let remaining: QuotaSummaryRemainingPayload?
+    let resetTime: String?
+
+    var resolvedRemainingFraction: Double? {
+        self.remainingFraction ?? self.remaining?.remainingFraction
+    }
+}
+
+private struct QuotaSummaryRemainingPayload: Decodable {
+    let remainingFraction: Double?
+
+    private enum CodingKeys: String, CodingKey {
+        case remainingFraction
+        case oneofCase = "case"
+        case value
+    }
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        if let remainingFraction = try container.decodeIfPresent(Double.self, forKey: .remainingFraction) {
+            self.remainingFraction = remainingFraction
+            return
+        }
+        let oneofCase = try container.decodeIfPresent(String.self, forKey: .oneofCase)
+        if oneofCase == "remainingFraction" {
+            self.remainingFraction = try container.decodeIfPresent(Double.self, forKey: .value)
+        } else {
+            self.remainingFraction = nil
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Antigravity/AntigravityRemoteUsageFetcher.swift b/Sources/CodexBarCore/Providers/Antigravity/AntigravityRemoteUsageFetcher.swift
new file mode 100644
index 0000000000..536e1e0f38
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Antigravity/AntigravityRemoteUsageFetcher.swift
@@ -0,0 +1,777 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public enum AntigravityRemoteFetchError: LocalizedError, Sendable, Equatable {
+    case notLoggedIn
+    case permissionDenied(String)
+    case apiError(String)
+    case parseFailed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .notLoggedIn:
+            "Antigravity Google auth not found. Use Antigravity login to authenticate."
+        case let .permissionDenied(message):
+            "Antigravity remote API permission denied: \(message)"
+        case let .apiError(message):
+            "Antigravity remote API error: \(message)"
+        case let .parseFailed(message):
+            "Could not parse Antigravity remote usage: \(message)"
+        }
+    }
+}
+
+public struct AntigravityRemoteUsageFetcher: Sendable {
+    public var timeout: TimeInterval = 10.0
+    public var homeDirectory: String
+    public var environment: [String: String]
+    public var dataLoader: @Sendable (URLRequest) async throws -> (Data, URLResponse)
+    public var oauthClientResolver: @Sendable () -> AntigravityOAuthClient?
+    public var credentialsUpdateHandler: @Sendable (AntigravityOAuthCredentials) async throws -> Void
+
+    private static let log = CodexBarLog.logger(LogCategories.antigravity)
+    private static let userAgent = "antigravity"
+    private static let baseURL = "https://cloudcode-pa.googleapis.com"
+    private static let loadCodeAssistEndpoint = "\(baseURL)/v1internal:loadCodeAssist"
+    private static let onboardUserEndpoint = "\(baseURL)/v1internal:onboardUser"
+    private static let fetchAvailableModelsEndpoint = "\(baseURL)/v1internal:fetchAvailableModels"
+    private static let retrieveUserQuotaEndpoint = "\(baseURL)/v1internal:retrieveUserQuota"
+    private static let refreshSafetyWindow: TimeInterval = 60
+
+    private struct FetchContext {
+        let timeout: TimeInterval
+        let store: AntigravityOAuthCredentialsStore?
+        let dataLoader: @Sendable (URLRequest) async throws -> (Data, URLResponse)
+        let oauthClientResolver: @Sendable () -> AntigravityOAuthClient?
+        let credentialsUpdateHandler: @Sendable (AntigravityOAuthCredentials) async throws -> Void
+
+        func persistCredentials(_ credentials: AntigravityOAuthCredentials) async throws {
+            if let store {
+                try store.save(credentials)
+            } else {
+                try await self.credentialsUpdateHandler(credentials)
+            }
+        }
+    }
+
+    public init(
+        timeout: TimeInterval = 10.0,
+        homeDirectory: String = NSHomeDirectory(),
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        dataLoader: @escaping @Sendable (URLRequest) async throws -> (Data, URLResponse) = { request in
+            try await ProviderHTTPClient.shared.data(for: request)
+        },
+        oauthClientResolver: @escaping @Sendable () -> AntigravityOAuthClient? = {
+            AntigravityOAuthConfig.resolvedClient()
+        },
+        credentialsUpdateHandler: @escaping @Sendable (AntigravityOAuthCredentials) async throws -> Void = { _ in })
+    {
+        self.timeout = timeout
+        self.homeDirectory = homeDirectory
+        self.environment = environment
+        self.dataLoader = dataLoader
+        self.oauthClientResolver = oauthClientResolver
+        self.credentialsUpdateHandler = credentialsUpdateHandler
+    }
+
+    public func fetch() async throws -> AntigravityStatusSnapshot {
+        let source = try Self.resolveCredentialSource(homeDirectory: self.homeDirectory, environment: self.environment)
+        guard let credentials = source.credentials else {
+            throw AntigravityRemoteFetchError.notLoggedIn
+        }
+        return try await self.fetchSnapshot(
+            using: credentials,
+            store: source.store)
+    }
+
+    private func fetchSnapshot(
+        using initialCredentials: AntigravityOAuthCredentials,
+        store: AntigravityOAuthCredentialsStore?) async throws
+        -> AntigravityStatusSnapshot
+    {
+        guard let storedAccessToken = initialCredentials.accessToken?.trimmedNonEmpty else {
+            throw AntigravityRemoteFetchError.notLoggedIn
+        }
+
+        var credentials = initialCredentials
+        var accessToken = storedAccessToken
+        let context = FetchContext(
+            timeout: self.timeout,
+            store: store,
+            dataLoader: self.dataLoader,
+            oauthClientResolver: self.oauthClientResolver,
+            credentialsUpdateHandler: self.credentialsUpdateHandler)
+        if Self.shouldRefresh(expiryDate: credentials.expiryDate, now: Date()) {
+            guard let refreshToken = credentials.refreshToken?.trimmedNonEmpty else {
+                throw AntigravityRemoteFetchError.notLoggedIn
+            }
+            let refreshed = try await Self.refreshAccessToken(
+                credentials: credentials,
+                refreshToken: refreshToken,
+                context: context)
+            accessToken = refreshed.accessToken
+            credentials = refreshed.credentials
+            if let store {
+                credentials = try store.load() ?? credentials
+            }
+            credentials.accessToken = credentials.accessToken?.trimmedNonEmpty ?? accessToken
+        }
+
+        let claims = Self.extractClaims(from: credentials)
+        let codeAssist = try await Self.loadCodeAssist(
+            accessToken: accessToken,
+            timeout: self.timeout,
+            dataLoader: self.dataLoader)
+        let projectId = try await Self.resolveProjectID(
+            accessToken: accessToken,
+            storedProjectID: credentials.projectID?.trimmedNonEmpty,
+            initialResponse: codeAssist,
+            context: context)
+        if let projectId, credentials.projectID?.trimmedNonEmpty != projectId {
+            credentials.projectID = projectId
+            do {
+                try await context.persistCredentials(credentials)
+            } catch {
+                Self.log.warning("Could not persist Antigravity project ID: \(error.localizedDescription)")
+            }
+        }
+        let models = try await Self.fetchModelQuotas(
+            accessToken: accessToken,
+            projectId: projectId,
+            timeout: self.timeout,
+            dataLoader: self.dataLoader)
+
+        return AntigravityStatusSnapshot(
+            modelQuotas: models,
+            accountEmail: claims.email,
+            accountPlan: Self.resolvePlan(response: codeAssist, claims: claims),
+            source: .remote)
+    }
+
+    private static func shouldRefresh(expiryDate: Date?, now: Date) -> Bool {
+        guard let expiryDate else { return false }
+        return expiryDate.timeIntervalSince(now) <= Self.refreshSafetyWindow
+    }
+
+    private static func loadCodeAssist(
+        accessToken: String,
+        timeout: TimeInterval,
+        dataLoader: @escaping @Sendable (URLRequest) async throws -> (Data, URLResponse)) async throws
+        -> CodeAssistResponse
+    {
+        let body = [
+            "metadata": [
+                "ideType": "ANTIGRAVITY",
+                "platform": "PLATFORM_UNSPECIFIED",
+                "pluginType": "GEMINI",
+            ],
+        ]
+        return try await Self.sendRequest(
+            endpoint: Self.loadCodeAssistEndpoint,
+            accessToken: accessToken,
+            body: body,
+            timeout: timeout,
+            dataLoader: dataLoader)
+    }
+
+    private static func fetchAvailableModels(
+        accessToken: String,
+        projectId: String?,
+        timeout: TimeInterval,
+        dataLoader: @escaping @Sendable (URLRequest) async throws -> (Data, URLResponse)) async throws
+        -> FetchAvailableModelsResponse
+    {
+        let body: [String: Any] = if let projectId = projectId?.trimmedNonEmpty {
+            ["project": projectId]
+        } else {
+            [:]
+        }
+        return try await Self.sendRequest(
+            endpoint: Self.fetchAvailableModelsEndpoint,
+            accessToken: accessToken,
+            body: body,
+            timeout: timeout,
+            dataLoader: dataLoader)
+    }
+
+    private static func fetchModelQuotas(
+        accessToken: String,
+        projectId: String?,
+        timeout: TimeInterval,
+        dataLoader: @escaping @Sendable (URLRequest) async throws -> (Data, URLResponse)) async throws
+        -> [AntigravityModelQuota]
+    {
+        do {
+            let response = try await Self.fetchAvailableModels(
+                accessToken: accessToken,
+                projectId: projectId,
+                timeout: timeout,
+                dataLoader: dataLoader)
+            let modelQuotas = try Self.parseModelQuotas(response)
+            if Self.shouldVerifyFullRemoteQuotas(modelQuotas) {
+                let quotaBuckets = try await Self.fetchQuotaBucketsIfPermitted(
+                    accessToken: accessToken,
+                    projectId: projectId,
+                    timeout: timeout,
+                    dataLoader: dataLoader)
+                guard let quotaBuckets, Self.hasQuotaFractionData(quotaBuckets) else {
+                    return []
+                }
+                return Self.mergeVerifiedQuotas(modelQuotas: modelQuotas, verifiedQuotas: quotaBuckets)
+            }
+            return modelQuotas
+        } catch let error as AntigravityRemoteFetchError {
+            guard case .permissionDenied = error else {
+                throw error
+            }
+            Self.log.info("Falling back to retrieveUserQuota for Antigravity remote usage")
+            return try await Self.fetchQuotaBucketsIfPermitted(
+                accessToken: accessToken,
+                projectId: projectId,
+                timeout: timeout,
+                dataLoader: dataLoader) ?? []
+        }
+    }
+
+    private static func mergeVerifiedQuotas(
+        modelQuotas: [AntigravityModelQuota],
+        verifiedQuotas: [AntigravityModelQuota]) -> [AntigravityModelQuota]
+    {
+        var verifiedByModelID = Dictionary(
+            uniqueKeysWithValues: verifiedQuotas.map { (Self.quotaKey($0), $0) })
+        var merged = modelQuotas.compactMap { modelQuota -> AntigravityModelQuota? in
+            guard let verifiedQuota = verifiedByModelID.removeValue(forKey: Self.quotaKey(modelQuota)) else {
+                return nil
+            }
+            let resetTime = verifiedQuota.resetTime ?? modelQuota.resetTime
+            return AntigravityModelQuota(
+                label: modelQuota.label,
+                modelId: modelQuota.modelId,
+                remainingFraction: verifiedQuota.remainingFraction ?? modelQuota.remainingFraction,
+                resetTime: resetTime,
+                resetDescription: resetTime.map { UsageFormatter.resetDescription(from: $0) })
+        }
+        let unmatchedVerifiedQuotas = verifiedByModelID.values
+            .filter { $0.remainingFraction != nil }
+            .sorted { lhs, rhs in
+                lhs.modelId.localizedCaseInsensitiveCompare(rhs.modelId) == .orderedAscending
+            }
+        merged.append(contentsOf: unmatchedVerifiedQuotas)
+        return merged
+    }
+
+    private static func quotaKey(_ quota: AntigravityModelQuota) -> String {
+        quota.modelId.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+    }
+
+    private static func shouldVerifyFullRemoteQuotas(_ quotas: [AntigravityModelQuota]) -> Bool {
+        guard !quotas.isEmpty else { return false }
+        return quotas.allSatisfy { quota in
+            guard let remaining = quota.remainingFraction else { return false }
+            return remaining >= 0.999
+        }
+    }
+
+    private static func hasQuotaFractionData(_ quotas: [AntigravityModelQuota]) -> Bool {
+        quotas.contains { quota in
+            quota.remainingFraction != nil
+        }
+    }
+
+    private static func fetchQuotaBucketsIfPermitted(
+        accessToken: String,
+        projectId: String?,
+        timeout: TimeInterval,
+        dataLoader: @escaping @Sendable (URLRequest) async throws -> (Data, URLResponse)) async throws
+        -> [AntigravityModelQuota]?
+    {
+        do {
+            let response = try await Self.retrieveUserQuota(
+                accessToken: accessToken,
+                projectId: projectId,
+                timeout: timeout,
+                dataLoader: dataLoader)
+            return try Self.parseQuotaBuckets(response)
+        } catch let quotaError as AntigravityRemoteFetchError {
+            guard case .permissionDenied = quotaError else {
+                throw quotaError
+            }
+            Self.log.info("Antigravity remote quota endpoint is not permitted for this account")
+            return nil
+        }
+    }
+
+    private static func retrieveUserQuota(
+        accessToken: String,
+        projectId: String?,
+        timeout: TimeInterval,
+        dataLoader: @escaping @Sendable (URLRequest) async throws -> (Data, URLResponse)) async throws
+        -> RetrieveUserQuotaResponse
+    {
+        let body: [String: Any] = if let projectId = projectId?.trimmedNonEmpty {
+            ["project": projectId]
+        } else {
+            [:]
+        }
+        return try await Self.sendRequest(
+            endpoint: Self.retrieveUserQuotaEndpoint,
+            accessToken: accessToken,
+            body: body,
+            timeout: timeout,
+            dataLoader: dataLoader)
+    }
+
+    private static func resolveProjectID(
+        accessToken: String,
+        storedProjectID: String?,
+        initialResponse: CodeAssistResponse,
+        context: FetchContext) async throws
+        -> String?
+    {
+        if let storedProjectID {
+            return storedProjectID
+        }
+
+        if let projectID = initialResponse.projectID {
+            return projectID
+        }
+
+        guard let tierID = Self.pickOnboardTier(from: initialResponse) else {
+            return nil
+        }
+
+        let onboardBody: [String: Any] = [
+            "tierId": tierID,
+            "metadata": [
+                "ideType": "ANTIGRAVITY",
+                "platform": "PLATFORM_UNSPECIFIED",
+                "pluginType": "GEMINI",
+            ],
+        ]
+
+        do {
+            let onboardResponse: OnboardResponse = try await Self.sendRequest(
+                endpoint: Self.onboardUserEndpoint,
+                accessToken: accessToken,
+                body: onboardBody,
+                timeout: context.timeout,
+                dataLoader: context.dataLoader)
+            if let projectID = onboardResponse.projectID {
+                return projectID
+            }
+        } catch {
+            Self.log.warning("Antigravity onboarding request failed", metadata: [
+                "error": "\(error.localizedDescription)",
+            ])
+        }
+
+        for _ in 0..<5 {
+            try? await Task.sleep(for: .milliseconds(2000))
+            let refreshed = try await Self.loadCodeAssist(
+                accessToken: accessToken,
+                timeout: context.timeout,
+                dataLoader: context.dataLoader)
+            if let projectID = refreshed.projectID {
+                return projectID
+            }
+        }
+
+        return nil
+    }
+
+    private static func sendRequest<Response: Decodable>(
+        endpoint: String,
+        accessToken: String,
+        body: [String: Any],
+        timeout: TimeInterval,
+        dataLoader: @escaping @Sendable (URLRequest) async throws -> (Data, URLResponse)) async throws
+        -> Response
+    {
+        guard let url = URL(string: endpoint) else {
+            throw AntigravityRemoteFetchError.apiError("Invalid endpoint URL")
+        }
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.timeoutInterval = timeout
+        request.setValue("Bearer \(accessToken)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.setValue(Self.userAgent, forHTTPHeaderField: "User-Agent")
+        request.httpBody = try JSONSerialization.data(withJSONObject: body)
+
+        let httpResponse = try await ProviderHTTPTransportHandler(dataLoader).response(for: request)
+
+        switch httpResponse.statusCode {
+        case 200:
+            break
+        case 401:
+            throw AntigravityRemoteFetchError.notLoggedIn
+        case 403:
+            let message = String(data: httpResponse.data, encoding: .utf8)?.trimmedNonEmpty ?? "HTTP 403"
+            throw AntigravityRemoteFetchError.permissionDenied(message)
+        default:
+            let message = String(data: httpResponse.data, encoding: .utf8)?.trimmedNonEmpty
+                ?? "HTTP \(httpResponse.statusCode)"
+            throw AntigravityRemoteFetchError.apiError("HTTP \(httpResponse.statusCode): \(message)")
+        }
+
+        do {
+            return try JSONDecoder().decode(Response.self, from: httpResponse.data)
+        } catch {
+            throw AntigravityRemoteFetchError.parseFailed(error.localizedDescription)
+        }
+    }
+
+    private static func parseModelQuotas(_ response: FetchAvailableModelsResponse) throws -> [AntigravityModelQuota] {
+        let models = response.models ?? [:]
+        return models.compactMap { modelID, model in
+            guard let quotaInfo = model.quotaInfo else { return nil }
+            let resetTime = quotaInfo.resetTime.flatMap(Self.parseResetTime(_:))
+            let label = model.displayName?.trimmedNonEmpty
+                ?? model.label?.trimmedNonEmpty
+                ?? modelID
+            return AntigravityModelQuota(
+                label: label,
+                modelId: modelID,
+                remainingFraction: quotaInfo.remainingFraction,
+                resetTime: resetTime,
+                resetDescription: resetTime.map { UsageFormatter.resetDescription(from: $0) })
+        }
+    }
+
+    private static func parseQuotaBuckets(_ response: RetrieveUserQuotaResponse) throws -> [AntigravityModelQuota] {
+        guard let buckets = response.buckets else {
+            throw AntigravityRemoteFetchError.parseFailed("No quota buckets in response")
+        }
+        guard !buckets.isEmpty else { return [] }
+
+        var modelQuotaMap: [String: (fraction: Double?, resetTime: String?)] = [:]
+        for bucket in buckets {
+            guard let modelID = bucket.modelId?.trimmedNonEmpty else { continue }
+            let next = (bucket.remainingFraction, bucket.resetTime)
+            if let existing = modelQuotaMap[modelID] {
+                let existingValue = existing.fraction ?? Double.greatestFiniteMagnitude
+                let nextValue = next.0 ?? Double.greatestFiniteMagnitude
+                if nextValue < existingValue {
+                    modelQuotaMap[modelID] = next
+                }
+            } else {
+                modelQuotaMap[modelID] = next
+            }
+        }
+
+        return modelQuotaMap.keys.sorted().compactMap { modelID in
+            guard let info = modelQuotaMap[modelID] else { return nil }
+            let resetTime = info.resetTime.flatMap(Self.parseResetTime(_:))
+            return AntigravityModelQuota(
+                label: modelID,
+                modelId: modelID,
+                remainingFraction: info.fraction,
+                resetTime: resetTime,
+                resetDescription: resetTime.map { UsageFormatter.resetDescription(from: $0) })
+        }
+    }
+
+    private static func resolvePlan(response: CodeAssistResponse, claims: TokenClaims) -> String? {
+        if let planType = response.planInfo?.planType?.trimmedNonEmpty {
+            return planType
+        }
+
+        switch (response.currentTier?.id?.trimmedNonEmpty, claims.hostedDomain) {
+        case ("standard-tier", _):
+            return "Paid"
+        case ("free-tier", .some):
+            return "Workspace"
+        case ("free-tier", .none):
+            return "Free"
+        case ("legacy-tier", _):
+            return "Legacy"
+        default:
+            return response.currentTier?.name?.trimmedNonEmpty
+        }
+    }
+
+    private static func pickOnboardTier(from response: CodeAssistResponse) -> String? {
+        if let defaultTier = response.allowedTiers?
+            .first(where: { $0.isDefault == true && $0.id?.trimmedNonEmpty != nil })?.id?.trimmedNonEmpty
+        {
+            return defaultTier
+        }
+        if let firstTier = response.allowedTiers?
+            .first(where: { $0.id?.trimmedNonEmpty != nil })?.id?.trimmedNonEmpty
+        {
+            return firstTier
+        }
+        if let paidTier = response.paidTier?.id?.trimmedNonEmpty {
+            return paidTier
+        }
+        if let currentTier = response.currentTier?.id?.trimmedNonEmpty {
+            return currentTier
+        }
+        return nil
+    }
+
+    private static func parseResetTime(_ value: String) -> Date? {
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        if let date = formatter.date(from: value) {
+            return date
+        }
+        formatter.formatOptions = [.withInternetDateTime]
+        return formatter.date(from: value)
+    }
+
+    private static func credentialsStore(homeDirectory: String) -> AntigravityOAuthCredentialsStore {
+        let homeURL = URL(fileURLWithPath: homeDirectory, isDirectory: true)
+        return AntigravityOAuthCredentialsStore(fileURL: AntigravityOAuthCredentialsStore.defaultURL(home: homeURL))
+    }
+
+    private static func resolveCredentialSource(
+        homeDirectory: String,
+        environment: [String: String]) throws -> (
+        credentials: AntigravityOAuthCredentials?,
+        store: AntigravityOAuthCredentialsStore?)
+    {
+        let primaryStore = Self.credentialsStore(homeDirectory: homeDirectory)
+        if let tokenValue = environment[AntigravityOAuthCredentialsStore.environmentCredentialsKey] {
+            guard let credentials = AntigravityOAuthCredentialsStore.credentials(fromTokenAccountValue: tokenValue)
+            else {
+                throw AntigravityRemoteFetchError.parseFailed("Could not decode selected account credentials.")
+            }
+            return (credentials, nil)
+        }
+        return try (primaryStore.load(), primaryStore)
+    }
+
+    private struct RefreshResult {
+        let accessToken: String
+        let credentials: AntigravityOAuthCredentials
+    }
+
+    private static func refreshAccessToken(
+        credentials: AntigravityOAuthCredentials,
+        refreshToken: String,
+        context: FetchContext) async throws
+        -> RefreshResult
+    {
+        let oauthClient = try Self.refreshOAuthClient(
+            from: credentials,
+            oauthClientResolver: context.oauthClientResolver)
+
+        var request = URLRequest(url: AntigravityOAuthConfig.tokenURL)
+        request.httpMethod = "POST"
+        request.timeoutInterval = context.timeout
+        request.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
+        request.httpBody = Self.formBody([
+            "client_id": oauthClient.clientID,
+            "client_secret": oauthClient.clientSecret,
+            "refresh_token": refreshToken,
+            "grant_type": "refresh_token",
+        ])
+
+        let httpResponse = try await ProviderHTTPTransportHandler(context.dataLoader).response(for: request)
+        guard httpResponse.statusCode == 200 else {
+            throw AntigravityRemoteFetchError.notLoggedIn
+        }
+        guard let json = try JSONSerialization.jsonObject(with: httpResponse.data) as? [String: Any],
+              let accessToken = json["access_token"] as? String
+        else {
+            throw AntigravityRemoteFetchError.parseFailed("Could not parse refresh response")
+        }
+
+        let updatedCredentials = Self.updatedCredentials(credentials, refreshResponse: json)
+        try await context.persistCredentials(updatedCredentials)
+        return RefreshResult(accessToken: accessToken, credentials: updatedCredentials)
+    }
+
+    private static func refreshOAuthClient(
+        from credentials: AntigravityOAuthCredentials,
+        oauthClientResolver: @escaping @Sendable () -> AntigravityOAuthClient?) throws
+        -> AntigravityOAuthClient
+    {
+        if let clientID = credentials.clientID?.trimmedNonEmpty,
+           let clientSecret = credentials.clientSecret?.trimmedNonEmpty
+        {
+            return AntigravityOAuthClient(clientID: clientID, clientSecret: clientSecret)
+        }
+
+        guard let client = oauthClientResolver() else {
+            throw AntigravityRemoteFetchError.apiError(AntigravityOAuthConfig.missingCredentialsMessage)
+        }
+        return client
+    }
+
+    private static func updatedCredentials(
+        _ credentials: AntigravityOAuthCredentials,
+        refreshResponse: [String: Any]) -> AntigravityOAuthCredentials
+    {
+        var credentials = credentials
+        if let accessToken = refreshResponse["access_token"] as? String {
+            credentials.accessToken = accessToken
+        }
+        if let expiresIn = refreshResponse["expires_in"] as? Double {
+            credentials.expiryDateMilliseconds = (Date().timeIntervalSince1970 + expiresIn) * 1000
+        }
+        if let expiresIn = refreshResponse["expires_in"] as? Int {
+            credentials.expiryDateMilliseconds = (Date().timeIntervalSince1970 + Double(expiresIn)) * 1000
+        }
+        if let idToken = refreshResponse["id_token"] as? String {
+            credentials.idToken = idToken
+        }
+        return credentials
+    }
+
+    private static func formBody(_ values: [String: String]) -> Data? {
+        var components = URLComponents()
+        components.queryItems = values.map { key, value in
+            URLQueryItem(name: key, value: value)
+        }
+        return components.query?.data(using: .utf8)
+    }
+
+    private struct TokenClaims {
+        let email: String?
+        let hostedDomain: String?
+    }
+
+    private static func extractClaims(from credentials: AntigravityOAuthCredentials) -> TokenClaims {
+        let tokenClaims = Self.extractClaimsFromToken(credentials.idToken)
+        return TokenClaims(
+            email: tokenClaims.email ?? credentials.email?.trimmedNonEmpty,
+            hostedDomain: tokenClaims.hostedDomain)
+    }
+
+    private static func extractClaimsFromToken(_ idToken: String?) -> TokenClaims {
+        guard let idToken else {
+            return TokenClaims(email: nil, hostedDomain: nil)
+        }
+
+        let parts = idToken.components(separatedBy: ".")
+        guard parts.count >= 2 else {
+            return TokenClaims(email: nil, hostedDomain: nil)
+        }
+
+        var payload = parts[1]
+            .replacingOccurrences(of: "-", with: "+")
+            .replacingOccurrences(of: "_", with: "/")
+        let remainder = payload.count % 4
+        if remainder > 0 {
+            payload += String(repeating: "=", count: 4 - remainder)
+        }
+
+        guard let data = Data(base64Encoded: payload, options: .ignoreUnknownCharacters),
+              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+        else {
+            return TokenClaims(email: nil, hostedDomain: nil)
+        }
+
+        return TokenClaims(
+            email: (json["email"] as? String)?.trimmedNonEmpty,
+            hostedDomain: (json["hd"] as? String)?.trimmedNonEmpty)
+    }
+}
+
+extension String {
+    fileprivate var trimmedNonEmpty: String? {
+        let trimmed = self.trimmingCharacters(in: .whitespacesAndNewlines)
+        return trimmed.isEmpty ? nil : trimmed
+    }
+}
+
+private struct ProjectReference: Decodable {
+    let value: String?
+
+    init(from decoder: Decoder) throws {
+        let single = try decoder.singleValueContainer()
+        if let stringValue = try? single.decode(String.self) {
+            self.value = stringValue
+            return
+        }
+
+        let keyed = try decoder.container(keyedBy: CodingKeys.self)
+        self.value = try keyed.decodeIfPresent(String.self, forKey: .id)
+            ?? keyed.decodeIfPresent(String.self, forKey: .projectID)
+    }
+
+    private enum CodingKeys: String, CodingKey {
+        case id
+        case projectID = "projectId"
+    }
+}
+
+private struct CodeAssistResponse: Decodable {
+    let planInfo: CodeAssistPlanInfo?
+    let currentTier: TierInfo?
+    let paidTier: TierInfo?
+    let allowedTiers: [AllowedTier]?
+    let cloudaicompanionProject: ProjectReference?
+
+    var projectID: String? {
+        self.cloudaicompanionProject?.value?.trimmingCharacters(in: .whitespacesAndNewlines).nilIfEmpty
+    }
+}
+
+private struct CodeAssistPlanInfo: Decodable {
+    let planType: String?
+}
+
+private struct TierInfo: Decodable {
+    let id: String?
+    let name: String?
+}
+
+private struct AllowedTier: Decodable {
+    let id: String?
+    let isDefault: Bool?
+}
+
+private struct OnboardResponse: Decodable {
+    let response: OnboardInnerResponse?
+
+    var projectID: String? {
+        self.response?.cloudaicompanionProject?.value?.trimmingCharacters(in: .whitespacesAndNewlines).nilIfEmpty
+    }
+}
+
+private struct OnboardInnerResponse: Decodable {
+    let cloudaicompanionProject: ProjectReference?
+}
+
+private struct FetchAvailableModelsResponse: Decodable {
+    let models: [String: AntigravityRemoteModel]?
+}
+
+private struct RetrieveUserQuotaResponse: Decodable {
+    let buckets: [RetrieveUserQuotaBucket]?
+}
+
+private struct RetrieveUserQuotaBucket: Decodable {
+    let modelId: String?
+    let remainingFraction: Double?
+    let resetTime: String?
+}
+
+private struct AntigravityRemoteModel: Decodable {
+    let displayName: String?
+    let label: String?
+    let quotaInfo: AntigravityRemoteQuotaInfo?
+}
+
+private struct AntigravityRemoteQuotaInfo: Decodable {
+    let remainingFraction: Double?
+    let resetTime: String?
+}
+
+extension String? {
+    fileprivate var trimmedNonEmpty: String? {
+        self?.trimmingCharacters(in: .whitespacesAndNewlines).nilIfEmpty
+    }
+}
+
+extension String {
+    fileprivate var nilIfEmpty: String? {
+        self.isEmpty ? nil : self
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Antigravity/AntigravityStatusProbe+Deadline.swift b/Sources/CodexBarCore/Providers/Antigravity/AntigravityStatusProbe+Deadline.swift
new file mode 100644
index 0000000000..da86b634ac
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Antigravity/AntigravityStatusProbe+Deadline.swift
@@ -0,0 +1,128 @@
+import Foundation
+
+extension AntigravityStatusProbe {
+    private static let processProbeLog = CodexBarLog.logger(LogCategories.antigravity)
+
+    private enum ProcessSnapshotFetchFailure {
+        case antigravity(AntigravityStatusProbeError)
+        case url(URLError)
+        case cancellation
+        case other(String)
+
+        init(_ error: Error) {
+            if let error = error as? AntigravityStatusProbeError {
+                self = .antigravity(error)
+            } else if let error = error as? URLError, error.code == .cancelled {
+                self = .cancellation
+            } else if let error = error as? URLError {
+                self = .url(error)
+            } else if error is CancellationError {
+                self = .cancellation
+            } else {
+                self = .other(error.localizedDescription)
+            }
+        }
+
+        var error: Error {
+            switch self {
+            case let .antigravity(error):
+                error
+            case let .url(error):
+                error
+            case .cancellation:
+                CancellationError()
+            case let .other(message):
+                AntigravityStatusProbeError.apiError(message)
+            }
+        }
+    }
+
+    private enum ProcessSnapshotFetchOutcome {
+        case success(index: Int, snapshot: AntigravityStatusSnapshot)
+        case failure(index: Int, pid: Int, failure: ProcessSnapshotFetchFailure)
+    }
+
+    static func fetchProcessSnapshots(
+        processInfos: [ProcessInfoResult],
+        fetch: @escaping @Sendable (ProcessInfoResult) async throws -> AntigravityStatusSnapshot)
+        async throws -> (snapshots: [AntigravityStatusSnapshot], lastError: Error?)
+    {
+        let outcomes = await withTaskGroup(of: ProcessSnapshotFetchOutcome.self) { group in
+            for (index, processInfo) in processInfos.enumerated() {
+                group.addTask {
+                    do {
+                        return try await .success(index: index, snapshot: fetch(processInfo))
+                    } catch {
+                        return .failure(index: index, pid: processInfo.pid, failure: .init(error))
+                    }
+                }
+            }
+
+            var ordered = [ProcessSnapshotFetchOutcome?](repeating: nil, count: processInfos.count)
+            for await outcome in group {
+                switch outcome {
+                case let .success(index, _), let .failure(index, _, _):
+                    ordered[index] = outcome
+                }
+            }
+            return ordered.compactMap(\.self)
+        }
+
+        var snapshots: [AntigravityStatusSnapshot] = []
+        var lastError: Error?
+        for outcome in outcomes {
+            switch outcome {
+            case let .success(_, snapshot):
+                snapshots.append(snapshot)
+            case let .failure(_, pid, failure):
+                if case .cancellation = failure {
+                    throw CancellationError()
+                }
+                let error = failure.error
+                lastError = error
+                Self.processProbeLog.debug("Antigravity local process probe failed", metadata: [
+                    "pid": "\(pid)",
+                    "error": error.localizedDescription,
+                ])
+            }
+        }
+        return (snapshots, lastError)
+    }
+
+    static func fetch(
+        processInfo: ProcessInfoResult,
+        timeout: TimeInterval,
+        deadline: Date) async throws -> AntigravityStatusSnapshot
+    {
+        guard let portTimeout = timeoutForNextAttempt(timeout: timeout, deadline: deadline) else {
+            throw AntigravityStatusProbeError.timedOut
+        }
+        let ports = try await Self.listeningPorts(pid: processInfo.pid, timeout: portTimeout)
+        let endpoint = try await Self.resolveWorkingEndpoint(
+            candidateEndpoints: Self.connectionCandidates(
+                listeningPorts: ports,
+                languageServerCSRFToken: processInfo.csrfToken,
+                extensionServerPort: processInfo.extensionPort,
+                extensionServerCSRFToken: processInfo.extensionServerCSRFToken),
+            timeout: timeout,
+            deadline: deadline)
+        let context = RequestContext(
+            endpoints: Self.requestEndpoints(
+                resolvedEndpoint: endpoint,
+                listeningPorts: ports,
+                languageServerCSRFToken: processInfo.csrfToken,
+                extensionServerPort: processInfo.extensionPort,
+                extensionServerCSRFToken: processInfo.extensionServerCSRFToken),
+            timeout: timeout,
+            deadline: deadline)
+
+        return try await Self.fetchSnapshot(context: context)
+    }
+
+    static func timeoutForNextAttempt(timeout: TimeInterval, deadline: Date?) -> TimeInterval? {
+        guard let deadline else { return timeout }
+        let remaining = deadline.timeIntervalSinceNow
+        guard remaining > 0 else { return nil }
+        return min(timeout, remaining)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Antigravity/AntigravityStatusProbe+LocalEndpoints.swift b/Sources/CodexBarCore/Providers/Antigravity/AntigravityStatusProbe+LocalEndpoints.swift
new file mode 100644
index 0000000000..fdb4ff6af1
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Antigravity/AntigravityStatusProbe+LocalEndpoints.swift
@@ -0,0 +1,23 @@
+extension AntigravityStatusProbe {
+    static func cliEndpoints(ports: [Int]) -> [AntigravityConnectionEndpoint] {
+        ports.flatMap { port in
+            self.localProbeSchemes.map { scheme in
+                AntigravityConnectionEndpoint(
+                    scheme: scheme,
+                    port: port,
+                    csrfToken: "",
+                    source: .cliHTTPS)
+            }
+        }
+    }
+
+    static var localProbeSchemes: [String] {
+        #if os(Linux)
+        // FoundationNetworking cannot trust Antigravity's self-signed TLS cert.
+        // Requests remain pinned to 127.0.0.1 in makeRequest.
+        ["https", "http"]
+        #else
+        ["https"]
+        #endif
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Antigravity/AntigravityStatusProbe+ResponseModels.swift b/Sources/CodexBarCore/Providers/Antigravity/AntigravityStatusProbe+ResponseModels.swift
new file mode 100644
index 0000000000..275b9d3655
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Antigravity/AntigravityStatusProbe+ResponseModels.swift
@@ -0,0 +1,111 @@
+import Foundation
+
+struct UserStatusResponse: Decodable {
+    let code: CodeValue?
+    let message: String?
+    let userStatus: UserStatus?
+}
+
+struct CommandModelConfigResponse: Decodable {
+    let code: CodeValue?
+    let message: String?
+    let clientModelConfigs: [ModelConfig]?
+}
+
+struct UserStatus: Decodable {
+    let email: String?
+    let planStatus: PlanStatus?
+    let cascadeModelConfigData: ModelConfigData?
+    let userTier: UserTier?
+}
+
+struct UserTier: Decodable {
+    let id: String?
+    let name: String?
+    let description: String?
+
+    var preferredName: String? {
+        guard let value = self.name?.trimmingCharacters(in: .whitespacesAndNewlines) else { return nil }
+        return value.isEmpty ? nil : value
+    }
+}
+
+struct PlanStatus: Decodable {
+    let planInfo: PlanInfo?
+}
+
+struct PlanInfo: Decodable {
+    let planName: String?
+    let planDisplayName: String?
+    let displayName: String?
+    let productName: String?
+    let planShortName: String?
+
+    var preferredName: String? {
+        let candidates = [
+            self.planDisplayName,
+            self.displayName,
+            self.productName,
+            self.planName,
+            self.planShortName,
+        ]
+        for candidate in candidates {
+            guard let value = candidate?.trimmingCharacters(in: .whitespacesAndNewlines) else { continue }
+            if !value.isEmpty { return value }
+        }
+        return nil
+    }
+}
+
+struct ModelConfigData: Decodable {
+    let clientModelConfigs: [ModelConfig]?
+}
+
+struct ModelConfig: Decodable {
+    let label: String
+    let modelOrAlias: ModelAlias
+    let quotaInfo: QuotaInfo?
+}
+
+struct ModelAlias: Decodable {
+    let model: String
+}
+
+struct QuotaInfo: Decodable {
+    let remainingFraction: Double?
+    let resetTime: String?
+}
+
+enum CodeValue: Decodable {
+    case int(Int)
+    case string(String)
+
+    var isOK: Bool {
+        switch self {
+        case let .int(value):
+            value == 0
+        case let .string(value):
+            value.lowercased() == "ok" || value.lowercased() == "success" || value == "0"
+        }
+    }
+
+    var rawValue: String {
+        switch self {
+        case let .int(value): "\(value)"
+        case let .string(value): value
+        }
+    }
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        if let value = try? container.decode(Int.self) {
+            self = .int(value)
+            return
+        }
+        if let value = try? container.decode(String.self) {
+            self = .string(value)
+            return
+        }
+        throw DecodingError.dataCorruptedError(in: container, debugDescription: "Unsupported code type")
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Antigravity/AntigravityStatusProbe.swift b/Sources/CodexBarCore/Providers/Antigravity/AntigravityStatusProbe.swift
index b4452b4c88..1a4168b90f 100644
--- a/Sources/CodexBarCore/Providers/Antigravity/AntigravityStatusProbe.swift
+++ b/Sources/CodexBarCore/Providers/Antigravity/AntigravityStatusProbe.swift
@@ -10,26 +10,160 @@ public struct AntigravityModelQuota: Sendable {
     public let resetTime: Date?
     public let resetDescription: String?
 
+    public init(
+        label: String,
+        modelId: String,
+        remainingFraction: Double?,
+        resetTime: Date?,
+        resetDescription: String?)
+    {
+        self.label = label
+        self.modelId = modelId
+        self.remainingFraction = remainingFraction
+        self.resetTime = resetTime
+        self.resetDescription = resetDescription
+    }
+
     public var remainingPercent: Double {
         guard let remainingFraction else { return 0 }
         return max(0, min(100, remainingFraction * 100))
     }
 }
 
+private enum AntigravityModelFamily {
+    case claude
+    case gpt
+    case geminiPro
+    case geminiFlash
+    case unknown
+}
+
+private enum AntigravityUsagePool: Hashable {
+    case gemini
+    case claudeGPT
+
+    var id: String {
+        switch self {
+        case .gemini: "antigravity-gemini"
+        case .claudeGPT: "antigravity-claude-gpt"
+        }
+    }
+
+    var title: String {
+        switch self {
+        case .gemini: "Gemini Models"
+        case .claudeGPT: "Claude and GPT models"
+        }
+    }
+
+    var sortRank: Int {
+        switch self {
+        case .gemini: 0
+        case .claudeGPT: 1
+        }
+    }
+}
+
+private struct AntigravityModelVersion: Comparable {
+    let major: Int
+    let minor: Int
+
+    static func < (lhs: AntigravityModelVersion, rhs: AntigravityModelVersion) -> Bool {
+        if lhs.major != rhs.major { return lhs.major < rhs.major }
+        return lhs.minor < rhs.minor
+    }
+}
+
+private struct AntigravityNormalizedModel {
+    let quota: AntigravityModelQuota
+    let family: AntigravityModelFamily
+    let selectionPriority: Int?
+    let isImage: Bool
+    let isLite: Bool
+    let isAutocomplete: Bool
+    let version: AntigravityModelVersion?
+    let tier: Int
+}
+
+public enum AntigravityModelQuotaSource: Sendable {
+    case local
+    case remote
+}
+
 public struct AntigravityStatusSnapshot: Sendable {
     public let modelQuotas: [AntigravityModelQuota]
     public let accountEmail: String?
     public let accountPlan: String?
+    public let source: AntigravityModelQuotaSource
+    let quotaSummary: AntigravityQuotaSummary?
+
+    public init(
+        modelQuotas: [AntigravityModelQuota],
+        accountEmail: String?,
+        accountPlan: String?,
+        source: AntigravityModelQuotaSource = .remote)
+    {
+        self.modelQuotas = modelQuotas
+        self.accountEmail = accountEmail
+        self.accountPlan = accountPlan
+        self.source = source
+        self.quotaSummary = nil
+    }
+
+    init(
+        quotaSummary: AntigravityQuotaSummary,
+        accountEmail: String?,
+        accountPlan: String?,
+        source: AntigravityModelQuotaSource = .local)
+    {
+        self.modelQuotas = []
+        self.accountEmail = accountEmail
+        self.accountPlan = accountPlan
+        self.source = source
+        self.quotaSummary = quotaSummary
+    }
 
     public func toUsageSnapshot() throws -> UsageSnapshot {
-        let ordered = Self.selectModels(self.modelQuotas)
-        guard let primaryQuota = ordered.first else {
+        if let quotaSummary {
+            return try Self.usageSnapshot(
+                from: quotaSummary,
+                accountEmail: self.accountEmail,
+                accountPlan: self.accountPlan)
+        }
+
+        guard !self.modelQuotas.isEmpty else {
             throw AntigravityStatusProbeError.parseFailed("No quota models available")
         }
 
-        let primary = Self.rateWindow(for: primaryQuota)
-        let secondary = ordered.count > 1 ? Self.rateWindow(for: ordered[1]) : nil
-        let tertiary = ordered.count > 2 ? Self.rateWindow(for: ordered[2]) : nil
+        let normalized = Self.normalizedModels(self.modelQuotas)
+        let summaryCandidates = normalized.filter(Self.isSummaryCandidate)
+        let primaryQuota = Self.representative(for: .gemini, in: summaryCandidates)
+        let secondaryQuota = Self.representative(for: .claudeGPT, in: summaryCandidates)
+        let fallbackQuota: AntigravityModelQuota? = if primaryQuota == nil, secondaryQuota == nil {
+            switch self.source {
+            case .local:
+                Self.fallbackRepresentative(in: normalized.filter {
+                    $0.family == .unknown &&
+                        Self.isSelectableTextModel($0) &&
+                        $0.quota.remainingFraction != nil
+                })
+            case .remote:
+                nil
+            }
+        } else {
+            nil
+        }
+
+        let primary = primaryQuota.map(Self.rateWindow(for:))
+        let secondary = secondaryQuota.map(Self.rateWindow(for:))
+        let extraWindows = Self.extraRateWindows(
+            from: normalized,
+            summaryCandidates: summaryCandidates,
+            compactFallbackModelID: fallbackQuota?.modelId,
+            representedPools: Set([
+                primaryQuota.map { _ in AntigravityUsagePool.gemini },
+                secondaryQuota.map { _ in AntigravityUsagePool.claudeGPT },
+            ].compactMap(\.self)))
 
         let identity = ProviderIdentitySnapshot(
             providerID: .antigravity,
@@ -39,11 +173,232 @@ public struct AntigravityStatusSnapshot: Sendable {
         return UsageSnapshot(
             primary: primary,
             secondary: secondary,
-            tertiary: tertiary,
+            tertiary: nil,
+            extraRateWindows: extraWindows.isEmpty ? nil : extraWindows,
+            updatedAt: Date(),
+            identity: identity)
+    }
+
+    func withIdentity(from snapshot: AntigravityStatusSnapshot?) -> AntigravityStatusSnapshot {
+        guard let snapshot else { return self }
+        let accountEmail = snapshot.accountEmail ?? self.accountEmail
+        let accountPlan = snapshot.accountPlan ?? self.accountPlan
+        if let quotaSummary {
+            return AntigravityStatusSnapshot(
+                quotaSummary: quotaSummary,
+                accountEmail: accountEmail,
+                accountPlan: accountPlan,
+                source: self.source)
+        }
+        return AntigravityStatusSnapshot(
+            modelQuotas: self.modelQuotas,
+            accountEmail: accountEmail,
+            accountPlan: accountPlan,
+            source: self.source)
+    }
+
+    private static func usageSnapshot(
+        from quotaSummary: AntigravityQuotaSummary,
+        accountEmail: String?,
+        accountPlan: String?) throws -> UsageSnapshot
+    {
+        let namedWindows = Self.quotaSummaryWindows(from: quotaSummary)
+        guard !namedWindows.isEmpty else {
+            throw AntigravityStatusProbeError.parseFailed("No quota buckets available")
+        }
+
+        let primary = Self.quotaSummaryRepresentative(
+            matching: { $0.lowercased().contains("gemini") },
+            in: namedWindows)
+        let secondary = Self.quotaSummaryRepresentative(
+            matching: { $0.lowercased().contains("claude") || $0.lowercased().contains("gpt") },
+            in: namedWindows)
+
+        let identity = ProviderIdentitySnapshot(
+            providerID: .antigravity,
+            accountEmail: accountEmail,
+            accountOrganization: nil,
+            loginMethod: accountPlan)
+        return UsageSnapshot(
+            primary: primary,
+            secondary: secondary,
+            tertiary: nil,
+            extraRateWindows: namedWindows,
             updatedAt: Date(),
             identity: identity)
     }
 
+    private static func quotaSummaryRepresentative(
+        matching predicate: (String) -> Bool,
+        in windows: [NamedRateWindow]) -> RateWindow?
+    {
+        windows
+            .filter { $0.usageKnown && predicate($0.title) }
+            .max { lhs, rhs in
+                if lhs.window.usedPercent != rhs.window.usedPercent {
+                    return lhs.window.usedPercent < rhs.window.usedPercent
+                }
+                return lhs.title.localizedCaseInsensitiveCompare(rhs.title) == .orderedDescending
+            }?
+            .window
+    }
+
+    private static func quotaSummaryWindows(from quotaSummary: AntigravityQuotaSummary) -> [NamedRateWindow] {
+        let sortedGroups = quotaSummary.groups.enumerated().sorted { lhs, rhs in
+            let lhsRank = Self.quotaGroupSortRank(lhs.element)
+            let rhsRank = Self.quotaGroupSortRank(rhs.element)
+            if lhsRank != rhsRank {
+                return lhsRank < rhsRank
+            }
+            return lhs.offset < rhs.offset
+        }.map(\.element)
+
+        return sortedGroups.flatMap { group in
+            let groupTitle = Self.displayTitle(forQuotaGroup: group)
+            let sortedBuckets = group.buckets.enumerated().sorted { lhs, rhs in
+                let lhsRank = Self.quotaBucketSortRank(lhs.element)
+                let rhsRank = Self.quotaBucketSortRank(rhs.element)
+                if lhsRank != rhsRank {
+                    return lhsRank < rhsRank
+                }
+                return lhs.offset < rhs.offset
+            }.map(\.element)
+
+            return sortedBuckets.map { bucket in
+                let bucketTitle = Self.displayTitle(forQuotaBucket: bucket)
+                let remainingPercent = Self.remainingPercent(from: bucket.remainingFraction)
+                let usedPercent = remainingPercent.map { 100 - $0 } ?? 0
+                let window = RateWindow(
+                    usedPercent: usedPercent,
+                    windowMinutes: Self.windowMinutes(forQuotaBucket: bucket),
+                    resetsAt: bucket.resetTime,
+                    resetDescription: bucket.resetDescription)
+                return NamedRateWindow(
+                    id: Self.quotaSummaryWindowID(for: bucket),
+                    title: "\(groupTitle) \(bucketTitle)",
+                    window: window,
+                    usageKnown: !bucket.disabled && bucket.remainingFraction != nil)
+            }
+        }
+    }
+
+    static func isQuotaSummaryWindowID(_ id: String) -> Bool {
+        id.hasPrefix(self.quotaSummaryWindowIDPrefix)
+    }
+
+    private static let quotaSummaryWindowIDPrefix = "antigravity-quota-summary-"
+
+    private static func quotaSummaryWindowID(for bucket: AntigravityQuotaSummaryBucket) -> String {
+        self.quotaSummaryWindowIDPrefix + bucket.bucketId
+    }
+
+    private static func remainingPercent(from remainingFraction: Double?) -> Double? {
+        guard let remainingFraction else { return nil }
+        return max(0, min(100, remainingFraction * 100))
+    }
+
+    private static func displayTitle(forQuotaGroup group: AntigravityQuotaSummaryGroup) -> String {
+        let title = group.displayName.trimmingCharacters(in: .whitespacesAndNewlines)
+        return title.isEmpty ? "Quota" : title
+    }
+
+    private static func displayTitle(forQuotaBucket bucket: AntigravityQuotaSummaryBucket) -> String {
+        bucket.displayName
+    }
+
+    private static func windowMinutes(forQuotaBucket bucket: AntigravityQuotaSummaryBucket) -> Int? {
+        switch self.quotaBucketKind(for: bucket) {
+        case .session:
+            300
+        case .weekly:
+            10080
+        case .other:
+            nil
+        }
+    }
+
+    private enum QuotaBucketKind {
+        case session
+        case weekly
+        case other
+    }
+
+    private static func quotaGroupSortRank(_ group: AntigravityQuotaSummaryGroup) -> Int {
+        let title = group.displayName.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+        if title.contains("gemini") {
+            return 0
+        }
+        if title.contains("claude") || title.contains("gpt") {
+            return 1
+        }
+        return 2
+    }
+
+    private static func quotaBucketSortRank(_ bucket: AntigravityQuotaSummaryBucket) -> Int {
+        switch self.quotaBucketKind(for: bucket) {
+        case .session:
+            0
+        case .weekly:
+            1
+        case .other:
+            2
+        }
+    }
+
+    private static func quotaBucketKind(for bucket: AntigravityQuotaSummaryBucket) -> QuotaBucketKind {
+        let combined = "\(bucket.bucketId) \(bucket.displayName)".lowercased()
+        if combined.contains("5h") || combined.contains("5-hour") || combined.contains("five hour") {
+            return .session
+        }
+        if combined.contains("weekly") {
+            return .weekly
+        }
+        return .other
+    }
+
+    static func quotaDisplayLabel(_ quota: AntigravityModelQuota) -> String {
+        let trimmed = quota.label.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard trimmed.isEmpty || trimmed == quota.modelId else { return quota.label }
+        return Self.humanizedModelID(quota.modelId)
+    }
+
+    static func humanizedModelID(_ modelId: String) -> String {
+        let parts = modelId.split(separator: "-").map(String.init)
+        var words: [String] = []
+        var index = 0
+
+        while index < parts.count {
+            let part = parts[index]
+            if Self.isSingleDigit(part), index + 1 < parts.count, Self.isSingleDigit(parts[index + 1]) {
+                var versionParts = [part]
+                index += 1
+                while index < parts.count, Self.isSingleDigit(parts[index]) {
+                    versionParts.append(parts[index])
+                    index += 1
+                }
+                words.append(versionParts.joined(separator: "."))
+                continue
+            }
+
+            if part.allSatisfy({ $0.isNumber || $0 == "." }) {
+                words.append(part)
+            } else if Self.modelLabelAcronyms.contains(part.lowercased()) {
+                words.append(part.uppercased())
+            } else {
+                words.append(part.prefix(1).uppercased() + part.dropFirst())
+            }
+            index += 1
+        }
+
+        return words.joined(separator: " ")
+    }
+
+    private static let modelLabelAcronyms: Set<String> = ["ai", "api", "gpt", "oss"]
+
+    private static func isSingleDigit(_ value: String) -> Bool {
+        value.count == 1 && value.allSatisfy(\.isNumber)
+    }
+
     private static func rateWindow(for quota: AntigravityModelQuota) -> RateWindow {
         RateWindow(
             usedPercent: 100 - quota.remainingPercent,
@@ -52,40 +407,268 @@ public struct AntigravityStatusSnapshot: Sendable {
             resetDescription: quota.resetDescription)
     }
 
-    private static func selectModels(_ models: [AntigravityModelQuota]) -> [AntigravityModelQuota] {
-        var ordered: [AntigravityModelQuota] = []
-        if let claude = models.first(where: { Self.isClaudeWithoutThinking($0.label) }) {
-            ordered.append(claude)
+    private static func modelOrderPrecedes(
+        _ lhs: AntigravityNormalizedModel,
+        _ rhs: AntigravityNormalizedModel) -> Bool
+    {
+        // 1. Family rank: claude=0, geminiPro=1, geminiFlash=2, unknown=3
+        let lhsFamilyRank = Self.familyRank(lhs.family)
+        let rhsFamilyRank = Self.familyRank(rhs.family)
+        if lhsFamilyRank != rhsFamilyRank {
+            return lhsFamilyRank < rhsFamilyRank
         }
-        if let pro = models.first(where: { Self.isGeminiProLow($0.label) }),
-           !ordered.contains(where: { $0.label == pro.label })
-        {
-            ordered.append(pro)
+
+        // 2. Version descending (newer first); nil version sorts after non-nil
+        switch (lhs.version, rhs.version) {
+        case let (.some(lv), .some(rv)):
+            if lv != rv {
+                return lv > rv
+            }
+        case (.some, .none):
+            return true
+        case (.none, .some):
+            return false
+        case (.none, .none):
+            break
         }
-        if let flash = models.first(where: { Self.isGeminiFlash($0.label) }),
-           !ordered.contains(where: { $0.label == flash.label })
+
+        // 3. Tier ascending: High(0) < Medium(1) < Low(2)
+        if lhs.tier != rhs.tier {
+            return lhs.tier < rhs.tier
+        }
+
+        // 4. Label tiebreaker
+        return lhs.quota.label.localizedCaseInsensitiveCompare(rhs.quota.label) == .orderedAscending
+    }
+
+    private static func familyRank(_ family: AntigravityModelFamily) -> Int {
+        switch family {
+        case .claude: 0
+        case .gpt: 1
+        case .geminiPro: 2
+        case .geminiFlash: 3
+        case .unknown: 4
+        }
+    }
+
+    private static func isSummaryCandidate(_ model: AntigravityNormalizedModel) -> Bool {
+        self.usagePool(for: model) != nil && self.isSelectableTextModel(model)
+    }
+
+    private static func isSelectableTextModel(_ model: AntigravityNormalizedModel) -> Bool {
+        !model.isLite && !model.isAutocomplete && !model.isImage
+    }
+
+    private static func normalizedModels(_ models: [AntigravityModelQuota]) -> [AntigravityNormalizedModel] {
+        models.map { self.normalizeModel($0) }
+    }
+
+    private static func normalizeModel(_ quota: AntigravityModelQuota) -> AntigravityNormalizedModel {
+        let modelId = quota.modelId.lowercased()
+        let label = quota.label.lowercased()
+        let family = Self.family(forModelID: modelId, label: label)
+
+        let isLite = modelId.contains("lite") || label.contains("lite")
+        let isAutocomplete = modelId.contains("autocomplete") || label.contains("autocomplete") || modelId
+            .hasPrefix("tab_")
+        let isImage = modelId.contains("image") || label.contains("image")
+        let isSelectableTextModel = !isLite && !isAutocomplete && !isImage
+        let isLowPriorityGeminiPro = modelId.contains("pro-low")
+            || (label.contains("pro") && label.contains("low"))
+
+        let selectionPriority: Int? = switch family {
+        case .claude, .gpt:
+            0
+        case .geminiPro:
+            if isLowPriorityGeminiPro, isSelectableTextModel {
+                0
+            } else if isSelectableTextModel {
+                1
+            } else {
+                nil
+            }
+        case .geminiFlash:
+            isSelectableTextModel ? 0 : nil
+        case .unknown:
+            nil
+        }
+
+        let version = Self.parseVersion(from: label)
+        let tier = Self.parseTier(from: label, modelId: modelId)
+
+        return AntigravityNormalizedModel(
+            quota: quota,
+            family: family,
+            selectionPriority: selectionPriority,
+            isImage: isImage,
+            isLite: isLite,
+            isAutocomplete: isAutocomplete,
+            version: version,
+            tier: tier)
+    }
+
+    private static func parseVersion(from label: String) -> AntigravityModelVersion? {
+        // Accept either "." or "-" between major and minor so a raw model id used as the
+        // label when displayName is missing (e.g. "gemini-3-1-pro-low") still parses 3.1.
+        guard let regex = try? NSRegularExpression(pattern: #"(\d+)(?:[.\-](\d+))?"#) else { return nil }
+        let nsLabel = label as NSString
+        let range = NSRange(location: 0, length: nsLabel.length)
+        guard let match = regex.firstMatch(in: label, options: [], range: range) else { return nil }
+        let majorRange = Range(match.range(at: 1), in: label)
+        guard let majorRange, let major = Int(label[majorRange]) else { return nil }
+        let minor: Int = if match.range(at: 2).location != NSNotFound,
+                            let minorRange = Range(match.range(at: 2), in: label),
+                            let parsed = Int(label[minorRange])
         {
-            ordered.append(flash)
+            parsed
+        } else {
+            0
+        }
+        return AntigravityModelVersion(major: major, minor: minor)
+    }
+
+    private static func parseTier(from label: String, modelId: String) -> Int {
+        let combined = label + " " + modelId
+        if combined.contains("high") { return 0 }
+        if combined.contains("medium") { return 1 }
+        if combined.contains("low") { return 2 }
+        return 1
+    }
+
+    private static func representative(
+        for pool: AntigravityUsagePool,
+        in models: [AntigravityNormalizedModel]) -> AntigravityModelQuota?
+    {
+        let candidates = models.filter {
+            Self.usagePool(for: $0) == pool && $0.quota.remainingFraction != nil
         }
-        if ordered.isEmpty {
-            ordered.append(contentsOf: models.sorted(by: { $0.remainingPercent < $1.remainingPercent }))
+        guard !candidates.isEmpty else { return nil }
+        return candidates.min { lhs, rhs in
+            if lhs.quota.remainingPercent != rhs.quota.remainingPercent {
+                return lhs.quota.remainingPercent < rhs.quota.remainingPercent
+            }
+            switch (lhs.quota.resetTime, rhs.quota.resetTime) {
+            case let (.some(left), .some(right)) where left != right:
+                return left < right
+            case (.some, .none):
+                return true
+            case (.none, .some):
+                return false
+            default:
+                return lhs.quota.label.localizedCaseInsensitiveCompare(rhs.quota.label) == .orderedAscending
+            }
+        }?.quota
+    }
+
+    private static func fallbackRepresentative(in models: [AntigravityNormalizedModel]) -> AntigravityModelQuota? {
+        models.min { lhs, rhs in
+            if lhs.quota.remainingPercent != rhs.quota.remainingPercent {
+                return lhs.quota.remainingPercent < rhs.quota.remainingPercent
+            }
+            return lhs.quota.label.localizedCaseInsensitiveCompare(rhs.quota.label) == .orderedAscending
+        }?.quota
+    }
+
+    private static func extraRateWindows(
+        from models: [AntigravityNormalizedModel],
+        summaryCandidates: [AntigravityNormalizedModel],
+        compactFallbackModelID: String?,
+        representedPools: Set<AntigravityUsagePool>) -> [NamedRateWindow]
+    {
+        let resetOnlyPoolWindows = [AntigravityUsagePool.gemini, .claudeGPT].compactMap { pool -> NamedRateWindow? in
+            guard !representedPools.contains(pool) else { return nil }
+            let candidates = summaryCandidates.filter { Self.usagePool(for: $0) == pool }
+            guard let resetOnly = candidates.first(where: { model in
+                model.quota.remainingFraction == nil &&
+                    (model.quota.resetTime != nil || model.quota.resetDescription != nil)
+            }) else {
+                return nil
+            }
+            return NamedRateWindow(
+                id: pool.id,
+                title: pool.title,
+                window: Self.rateWindow(for: resetOnly.quota),
+                usageKnown: false)
         }
-        return ordered
+
+        let distinctWindows = models
+            .filter {
+                $0.quota.modelId == compactFallbackModelID || Self.shouldShowDistinctExtraWindow($0)
+            }
+            .sorted(by: Self.modelOrderPrecedes)
+            .map { m in
+                NamedRateWindow(
+                    id: m.quota.modelId == compactFallbackModelID
+                        ? Self.compactFallbackWindowID(modelID: m.quota.modelId)
+                        : m.quota.modelId,
+                    title: Self.quotaDisplayLabel(m.quota),
+                    window: Self.rateWindow(for: m.quota),
+                    usageKnown: m.quota.remainingFraction != nil)
+            }
+
+        return resetOnlyPoolWindows.sorted { lhs, rhs in
+            guard let lhsPool = Self.pool(forExtraWindowID: lhs.id),
+                  let rhsPool = Self.pool(forExtraWindowID: rhs.id)
+            else {
+                return lhs.title.localizedCaseInsensitiveCompare(rhs.title) == .orderedAscending
+            }
+            return lhsPool.sortRank < rhsPool.sortRank
+        } + distinctWindows
     }
 
-    private static func isClaudeWithoutThinking(_ label: String) -> Bool {
-        let lower = label.lowercased()
-        return lower.contains("claude") && !lower.contains("thinking")
+    private static func compactFallbackWindowID(modelID: String) -> String {
+        "antigravity-compact-fallback-\(modelID)"
     }
 
-    private static func isGeminiProLow(_ label: String) -> Bool {
-        let lower = label.lowercased()
-        return lower.contains("pro") && lower.contains("low")
+    private static func shouldShowDistinctExtraWindow(_ model: AntigravityNormalizedModel) -> Bool {
+        guard !self.isSummaryCandidate(model) else { return false }
+        if model.quota.remainingFraction == nil {
+            return model.quota.resetTime != nil || model.quota.resetDescription != nil
+        }
+        return model.quota.remainingPercent < 99.9
     }
 
-    private static func isGeminiFlash(_ label: String) -> Bool {
-        let lower = label.lowercased()
-        return lower.contains("gemini") && lower.contains("flash")
+    private static func pool(forExtraWindowID id: String) -> AntigravityUsagePool? {
+        switch id {
+        case AntigravityUsagePool.gemini.id: .gemini
+        case AntigravityUsagePool.claudeGPT.id: .claudeGPT
+        default: nil
+        }
+    }
+
+    private static func usagePool(for model: AntigravityNormalizedModel) -> AntigravityUsagePool? {
+        switch model.family {
+        case .geminiPro, .geminiFlash:
+            .gemini
+        case .claude, .gpt:
+            .claudeGPT
+        case .unknown:
+            nil
+        }
+    }
+
+    private static func family(forModelID modelId: String, label: String) -> AntigravityModelFamily {
+        let modelIDFamily = Self.family(from: modelId)
+        if modelIDFamily != .unknown {
+            return modelIDFamily
+        }
+        return Self.family(from: label)
+    }
+
+    private static func family(from text: String) -> AntigravityModelFamily {
+        if text.contains("claude") {
+            return .claude
+        }
+        if text.contains("gpt") || text.contains("openai") {
+            return .gpt
+        }
+        if text.contains("gemini"), text.contains("pro") {
+            return .geminiPro
+        }
+        if text.contains("gemini"), text.contains("flash") {
+            return .geminiFlash
+        }
+        return .unknown
     }
 }
 
@@ -104,6 +687,8 @@ public enum AntigravityStatusProbeError: LocalizedError, Sendable, Equatable {
     case apiError(String)
     case parseFailed(String)
     case timedOut
+    case authenticationRequired
+    case accountMismatch(expected: String?, found: String?)
 
     public var errorDescription: String? {
         switch self {
@@ -119,9 +704,23 @@ public enum AntigravityStatusProbeError: LocalizedError, Sendable, Equatable {
             "Could not parse Antigravity quota: \(message)"
         case .timedOut:
             "Antigravity quota request timed out."
+        case .authenticationRequired:
+            "Antigravity CLI is signed out. Run agy in a terminal to sign in, then retry."
+        case let .accountMismatch(expected, found):
+            Self.accountMismatchDescription(expected: expected, found: found)
         }
     }
 
+    private static func accountMismatchDescription(expected: String?, found: String?) -> String {
+        let selected = expected ?? "the selected account"
+        if let found {
+            return "Antigravity local session is signed in as \(found), not \(selected); "
+                + "using the selected account's OAuth data instead."
+        }
+        return "Antigravity local session did not report an account matching \(selected); "
+            + "using the selected account's OAuth data instead."
+    }
+
     private static func portDetectionDescription(_ message: String) -> String {
         switch message {
         case "lsof not available":
@@ -142,66 +741,99 @@ public enum AntigravityStatusProbeError: LocalizedError, Sendable, Equatable {
 }
 
 public struct AntigravityStatusProbe: Sendable {
+    /// Which local Antigravity processes the probe may attach to.
+    public enum ProcessScope: Sendable {
+        /// Match Antigravity app, Antigravity IDE, and the `agy` CLI language server.
+        case ideAndCLI
+        /// Match only the Antigravity 2.0 app language server.
+        case appOnly
+        /// Match only the Antigravity IDE extension language server.
+        case ideOnly
+    }
+
     public var timeout: TimeInterval = 8.0
+    public var processScope: ProcessScope = .ideAndCLI
 
-    private static let processName = "language_server_macos"
     private static let getUserStatusPath = "/exa.language_server_pb.LanguageServerService/GetUserStatus"
     private static let commandModelConfigPath =
         "/exa.language_server_pb.LanguageServerService/GetCommandModelConfigs"
+    private static let quotaSummaryPath =
+        "/exa.language_server_pb.LanguageServerService/RetrieveUserQuotaSummary"
     private static let unleashPath = "/exa.language_server_pb.LanguageServerService/GetUnleashData"
     private static let log = CodexBarLog.logger(LogCategories.antigravity)
 
-    public init(timeout: TimeInterval = 8.0) {
+    public init(timeout: TimeInterval = 8.0, processScope: ProcessScope = .ideAndCLI) {
         self.timeout = timeout
+        self.processScope = processScope
     }
 
-    public func fetch() async throws -> AntigravityStatusSnapshot {
-        let processInfo = try await Self.detectProcessInfo(timeout: self.timeout)
-        let ports = try await Self.listeningPorts(pid: processInfo.pid, timeout: self.timeout)
-        let connectPort = try await Self.findWorkingPort(
-            ports: ports,
-            csrfToken: processInfo.csrfToken,
-            timeout: self.timeout)
-        let context = RequestContext(
-            httpsPort: connectPort,
-            httpPort: processInfo.extensionPort,
-            csrfToken: processInfo.csrfToken,
-            timeout: self.timeout)
+    public func fetch(matchingAccountEmail expectedAccountEmail: String? = nil) async throws
+        -> AntigravityStatusSnapshot
+    {
+        let deadline = Date().addingTimeInterval(self.timeout)
+        let processInfos = try await Self.detectProcessInfos(timeout: self.timeout, scope: self.processScope)
+        let result = try await Self.fetchProcessSnapshots(processInfos: processInfos) { processInfo in
+            try await Self.fetch(
+                processInfo: processInfo,
+                timeout: self.timeout,
+                deadline: deadline)
+        }
 
-        do {
-            let response = try await Self.makeRequest(
-                payload: RequestPayload(
-                    path: Self.getUserStatusPath,
-                    body: Self.defaultRequestBody()),
-                context: context)
-            return try Self.parseUserStatusResponse(response)
-        } catch {
-            let response = try await Self.makeRequest(
-                payload: RequestPayload(
-                    path: Self.commandModelConfigPath,
-                    body: Self.defaultRequestBody()),
-                context: context)
-            return try Self.parseCommandModelResponse(response)
+        if let bestSnapshot = Self.preferredLocalSnapshot(
+            result.snapshots,
+            matchingAccountEmail: expectedAccountEmail)
+        {
+            return bestSnapshot
         }
+        throw result.lastError ?? AntigravityStatusProbeError.notRunning
     }
 
     public func fetchPlanInfoSummary() async throws -> AntigravityPlanInfoSummary? {
         let processInfo = try await Self.detectProcessInfo(timeout: self.timeout)
         let ports = try await Self.listeningPorts(pid: processInfo.pid, timeout: self.timeout)
-        let connectPort = try await Self.findWorkingPort(
-            ports: ports,
-            csrfToken: processInfo.csrfToken,
+        let endpoint = try await Self.resolveWorkingEndpoint(
+            candidateEndpoints: Self.connectionCandidates(
+                listeningPorts: ports,
+                languageServerCSRFToken: processInfo.csrfToken,
+                extensionServerPort: processInfo.extensionPort,
+                extensionServerCSRFToken: processInfo.extensionServerCSRFToken),
             timeout: self.timeout)
-        let response = try await Self.makeRequest(
+        return try await Self.makeParsedRequest(
             payload: RequestPayload(
                 path: Self.getUserStatusPath,
                 body: Self.defaultRequestBody()),
             context: RequestContext(
-                httpsPort: connectPort,
-                httpPort: processInfo.extensionPort,
-                csrfToken: processInfo.csrfToken,
-                timeout: self.timeout))
-        return try Self.parsePlanInfoSummary(response)
+                endpoints: Self.requestEndpoints(
+                    resolvedEndpoint: endpoint,
+                    listeningPorts: ports,
+                    languageServerCSRFToken: processInfo.csrfToken,
+                    extensionServerPort: processInfo.extensionPort,
+                    extensionServerCSRFToken: processInfo.extensionServerCSRFToken),
+                timeout: self.timeout),
+            parse: Self.parsePlanInfoSummary)
+    }
+
+    static func localSnapshotScore(_ snapshot: AntigravityStatusSnapshot) -> Int {
+        var score = 0
+        if let quotaSummary = snapshot.quotaSummary {
+            let buckets = quotaSummary.groups.flatMap(\.buckets)
+            let knownBuckets = buckets.count(where: { !$0.disabled && $0.remainingFraction != nil })
+            score += 1000
+            score += quotaSummary.groups.count * 10
+            score += buckets.count
+            score += knownBuckets * 20
+        } else {
+            let knownRows = snapshot.modelQuotas.count(where: { $0.remainingFraction != nil })
+            score += snapshot.modelQuotas.count
+            score += knownRows * 10
+        }
+        if snapshot.accountEmail != nil {
+            score += 2
+        }
+        if snapshot.accountPlan != nil {
+            score += 1
+        }
+        return score
     }
 
     public static func isRunning(timeout: TimeInterval = 4.0) async -> Bool {
@@ -213,6 +845,24 @@ public struct AntigravityStatusProbe: Sendable {
         return running ? "running" : nil
     }
 
+    // MARK: - CLI Local Fetch
+
+    /// Fetch usage data from a known set of local ports (discovered via
+    /// ``AntigravityCLISession``'s ``pid``), without requiring a running
+    /// ``language_server`` process or CSRF token.
+    ///
+    /// The ``agy`` CLI exposes the same ``GetUserStatus`` gRPC-web endpoint as
+    /// the desktop ``language_server``. Unlike the desktop endpoint, it does
+    /// not require a CSRF token header.
+    public func fetchFromPorts(_ ports: [Int], deadline: Date? = nil) async throws -> AntigravityStatusSnapshot {
+        guard !ports.isEmpty else {
+            throw AntigravityStatusProbeError.portDetectionFailed("no listening ports found")
+        }
+        let endpoints = Self.cliEndpoints(ports: ports)
+        let context = RequestContext(endpoints: endpoints, timeout: self.timeout, deadline: deadline)
+        return try await Self.fetchSnapshot(context: context)
+    }
+
     // MARK: - Parsing
 
     public static func parseUserStatusResponse(_ data: Data) throws -> AntigravityStatusSnapshot {
@@ -228,12 +878,14 @@ public struct AntigravityStatusProbe: Sendable {
         let modelConfigs = userStatus.cascadeModelConfigData?.clientModelConfigs ?? []
         let models = modelConfigs.compactMap(Self.quotaFromConfig(_:))
         let email = userStatus.email
-        let planName = userStatus.planStatus?.planInfo?.preferredName
+        // Prefer userTier.name (actual subscription tier) over planInfo (shows "Pro" for Ultra users)
+        let planName = userStatus.userTier?.preferredName ?? userStatus.planStatus?.planInfo?.preferredName
 
         return AntigravityStatusSnapshot(
             modelQuotas: models,
             accountEmail: email,
-            accountPlan: planName)
+            accountPlan: planName,
+            source: .local)
     }
 
     static func parsePlanInfoSummary(_ data: Data) throws -> AntigravityPlanInfoSummary? {
@@ -262,7 +914,7 @@ public struct AntigravityStatusProbe: Sendable {
         }
         let modelConfigs = response.clientModelConfigs ?? []
         let models = modelConfigs.compactMap(Self.quotaFromConfig(_:))
-        return AntigravityStatusSnapshot(modelQuotas: models, accountEmail: nil, accountPlan: nil)
+        return AntigravityStatusSnapshot(modelQuotas: models, accountEmail: nil, accountPlan: nil, source: .local)
     }
 
     private static func quotaFromConfig(_ config: ModelConfig) -> AntigravityModelQuota? {
@@ -276,13 +928,13 @@ public struct AntigravityStatusProbe: Sendable {
             resetDescription: nil)
     }
 
-    private static func invalidCode(_ code: CodeValue?) -> String? {
+    static func invalidCode(_ code: CodeValue?) -> String? {
         guard let code else { return nil }
         if code.isOK { return nil }
         return "\(code.rawValue)"
     }
 
-    private static func parseDate(_ value: String) -> Date? {
+    static func parseDate(_ value: String) -> Date? {
         if let date = ISO8601DateFormatter().date(from: value) {
             return date
         }
@@ -294,14 +946,55 @@ public struct AntigravityStatusProbe: Sendable {
 
     // MARK: - Port detection
 
-    private struct ProcessInfoResult: Sendable {
+    struct ProcessInfoResult {
         let pid: Int
         let extensionPort: Int?
+        let extensionServerCSRFToken: String?
         let csrfToken: String
         let commandLine: String
     }
 
-    private static func detectProcessInfo(timeout: TimeInterval) async throws -> ProcessInfoResult {
+    struct AntigravityConnectionEndpoint: Equatable {
+        enum Source: String {
+            case languageServer = "language-server"
+            case extensionServer = "extension-server"
+            case cliHTTPS = "cli-https"
+        }
+
+        let scheme: String
+        let port: Int
+        let csrfToken: String
+        let source: Source
+        /// Whether this endpoint needs a CSRF token header.
+        /// The CLI HTTPS endpoint (``Source/cliHTTPS``) speaks the same HTTP API
+        /// but does not require a CSRF token.
+        var requiresCSRFToken: Bool {
+            switch self.source {
+            case .languageServer, .extensionServer: true
+            case .cliHTTPS: false
+            }
+        }
+
+        func matchesRequestTarget(_ other: Self) -> Bool {
+            self.scheme == other.scheme && self.port == other.port && self.csrfToken == other.csrfToken
+        }
+    }
+
+    private static func detectProcessInfo(
+        timeout: TimeInterval,
+        scope: ProcessScope = .ideAndCLI) async throws -> ProcessInfoResult
+    {
+        let processInfos = try await self.detectProcessInfos(timeout: timeout, scope: scope)
+        guard let first = processInfos.first else {
+            throw AntigravityStatusProbeError.notRunning
+        }
+        return first
+    }
+
+    private static func detectProcessInfos(
+        timeout: TimeInterval,
+        scope: ProcessScope = .ideAndCLI) async throws -> [ProcessInfoResult]
+    {
         let env = ProcessInfo.processInfo.environment
         let result = try await SubprocessRunner.run(
             binary: "/bin/ps",
@@ -310,21 +1003,55 @@ public struct AntigravityStatusProbe: Sendable {
             timeout: timeout,
             label: "antigravity-ps")
 
-        let lines = result.stdout.split(separator: "\n")
-        var sawAntigravity = false
+        return try Self.processInfos(fromProcessListOutput: result.stdout, scope: scope)
+    }
+
+    static func processInfo(
+        fromProcessListOutput output: String,
+        scope: ProcessScope = .ideAndCLI) throws -> ProcessInfoResult
+    {
+        let processInfos = try self.processInfos(fromProcessListOutput: output, scope: scope)
+        guard let first = processInfos.first else {
+            throw AntigravityStatusProbeError.notRunning
+        }
+        return first
+    }
+
+    static func processInfos(
+        fromProcessListOutput output: String,
+        scope: ProcessScope = .ideAndCLI) throws -> [ProcessInfoResult]
+    {
+        let lines = output.split(separator: "\n")
+        var sawTokenlessIDE = false
+        var results: [ProcessInfoResult] = []
         for line in lines {
             let text = String(line)
             guard let match = Self.matchProcessLine(text) else { continue }
-            let lower = match.command.lowercased()
-            guard lower.contains(Self.processName) else { continue }
-            guard Self.isAntigravityCommandLine(lower) else { continue }
-            sawAntigravity = true
-            guard let token = Self.extractFlag("--csrf_token", from: match.command) else { continue }
+            guard let kind = Self.antigravityProcessKind(match.command) else { continue }
+            if !Self.processKind(kind, matches: scope) { continue }
+            // The IDE language server authenticates local requests with a
+            // `--csrf_token` and must keep requiring it: skip a tokenless IDE
+            // or app match so a later valid server can still be found (and surface
+            // `missingCSRFToken` if none is). The CLI's language server exposes
+            // no token flag and needs none, so an empty token is allowed there.
+            guard let token = Self.resolvedCSRFToken(forKind: kind, command: match.command) else {
+                sawTokenlessIDE = true
+                continue
+            }
             let port = Self.extractPort("--extension_server_port", from: match.command)
-            return ProcessInfoResult(pid: match.pid, extensionPort: port, csrfToken: token, commandLine: match.command)
+            let extensionServerCSRFToken = Self.extractFlag("--extension_server_csrf_token", from: match.command)
+            results.append(ProcessInfoResult(
+                pid: match.pid,
+                extensionPort: port,
+                extensionServerCSRFToken: extensionServerCSRFToken,
+                csrfToken: token,
+                commandLine: match.command))
         }
 
-        if sawAntigravity {
+        if !results.isEmpty {
+            return results
+        }
+        if sawTokenlessIDE {
             throw AntigravityStatusProbeError.missingCSRFToken
         }
         throw AntigravityStatusProbeError.notRunning
@@ -343,12 +1070,96 @@ public struct AntigravityStatusProbe: Sendable {
         return ProcessLineMatch(pid: pid, command: String(parts[1]))
     }
 
+    enum AntigravityProcessKind: Equatable {
+        /// Antigravity 2.0 app language server. Requires a `--csrf_token`.
+        case app
+        /// Antigravity IDE extension language server. Requires a `--csrf_token`.
+        case ide
+        /// CLI language server (`agy` / `antigravity-cli`). Needs no CSRF token.
+        case cli
+    }
+
+    static func isAntigravityLanguageServerCommandLine(_ command: String) -> Bool {
+        self.antigravityProcessKind(command) != nil
+    }
+
+    /// Classify a process command line as the Antigravity app language server,
+    /// the Antigravity IDE language server, the Antigravity CLI language server,
+    /// or neither. Desktop language servers take precedence so their CSRF-token
+    /// requirement is preserved.
+    static func antigravityProcessKind(_ command: String) -> AntigravityProcessKind? {
+        let lower = command.lowercased()
+        if Self.isLanguageServerCommandLine(lower), Self.isAntigravityCommandLine(lower) {
+            return Self.isAntigravityIDECommandLine(lower) ? .ide : .app
+        }
+        if Self.isAntigravityCLICommandLine(lower) {
+            return .cli
+        }
+        return nil
+    }
+
+    private static func processKind(_ kind: AntigravityProcessKind, matches scope: ProcessScope) -> Bool {
+        switch scope {
+        case .ideAndCLI:
+            true
+        case .appOnly:
+            kind == .app
+        case .ideOnly:
+            kind == .ide
+        }
+    }
+
+    /// Resolve the CSRF token to use for a matched process, or `nil` when the
+    /// match must be skipped. IDE matches keep requiring `--csrf_token`
+    /// (tokenless IDE matches are skipped). CLI matches accept an empty token
+    /// because the CLI's language server requires none.
+    static func resolvedCSRFToken(forKind kind: AntigravityProcessKind, command: String) -> String? {
+        if let token = extractFlag("--csrf_token", from: command) {
+            return token
+        }
+        switch kind {
+        case .app, .ide: return nil
+        case .cli: return ""
+        }
+    }
+
+    private static func isLanguageServerCommandLine(_ lowerCommand: String) -> Bool {
+        let pattern = #"(^|[/\\])language(?:_|-)server(?:[_-][a-z0-9]+)*(?:\.exe)?(\s|$)"#
+        return lowerCommand.range(of: pattern, options: .regularExpression) != nil
+    }
+
+    /// The Antigravity CLI (`agy` / `antigravity-cli`) hosts the same language
+    /// server locally as the IDE, but launches it without a `--csrf_token` flag
+    /// and under a different process name. Match it so usage can be probed when
+    /// only the CLI is running.
+    private static func isAntigravityCLICommandLine(_ lowerCommand: String) -> Bool {
+        let cliPathPattern = #"(^|[/\\])(antigravity-cli|antigravity_cli)([\s/\\]|$)"#
+        if lowerCommand.range(of: cliPathPattern, options: .regularExpression) != nil {
+            return true
+        }
+        let agyPattern = #"(^|[/\\])agy(\s|$)"#
+        return lowerCommand.range(of: agyPattern, options: .regularExpression) != nil
+    }
+
     private static func isAntigravityCommandLine(_ command: String) -> Bool {
         if command.contains("--app_data_dir") && command.contains("antigravity") { return true }
+        if command.contains("antigravity.app/") || command.contains("antigravity.app\\") { return true }
+        if command.contains("antigravity ide.app/") || command.contains("antigravity ide.app\\") { return true }
         if command.contains("/antigravity/") || command.contains("\\antigravity\\") { return true }
         return false
     }
 
+    private static func isAntigravityIDECommandLine(_ lowerCommand: String) -> Bool {
+        [
+            "antigravity ide.app/",
+            "antigravity ide.app\\",
+            "--app_data_dir antigravity-ide",
+            "--app_data_dir=antigravity-ide",
+            "/extensions/antigravity/bin/language_server",
+            "\\extensions\\antigravity\\bin\\language_server",
+        ].contains { lowerCommand.contains($0) }
+    }
+
     private static func extractFlag(_ flag: String, from command: String) -> String? {
         let pattern = "\(NSRegularExpression.escapedPattern(for: flag))[=\\s]+([^\\s]+)"
         guard let regex = try? NSRegularExpression(pattern: pattern, options: .caseInsensitive) else { return nil }
@@ -363,7 +1174,7 @@ public struct AntigravityStatusProbe: Sendable {
         return Int(raw)
     }
 
-    private static func listeningPorts(pid: Int, timeout: TimeInterval) async throws -> [Int] {
+    static func listeningPorts(pid: Int, timeout: TimeInterval) async throws -> [Int] {
         let lsof = ["/usr/sbin/lsof", "/usr/bin/lsof"].first(where: {
             FileManager.default.isExecutableFile(atPath: $0)
         })
@@ -373,13 +1184,19 @@ public struct AntigravityStatusProbe: Sendable {
         }
 
         let env = ProcessInfo.processInfo.environment
-        let result = try await SubprocessRunner.run(
-            binary: lsof,
-            arguments: ["-nP", "-iTCP", "-sTCP:LISTEN", "-a", "-p", String(pid)],
-            environment: env,
-            timeout: timeout,
-            label: "antigravity-lsof")
-
+        let result: SubprocessResult
+        do {
+            result = try await SubprocessRunner.run(
+                binary: lsof,
+                arguments: ["-nP", "-iTCP", "-sTCP:LISTEN", "-a", "-p", String(pid)],
+                environment: env,
+                timeout: timeout,
+                label: "antigravity-lsof")
+        } catch let SubprocessRunnerError.nonZeroExit(code, stderr)
+            where code == 1 && stderr.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+        {
+            throw AntigravityStatusProbeError.portDetectionFailed("no listening ports found")
+        }
         let ports = Self.parseListeningPorts(result.stdout)
         if ports.isEmpty {
             throw AntigravityStatusProbeError.portDetectionFailed("no listening ports found")
@@ -400,21 +1217,187 @@ public struct AntigravityStatusProbe: Sendable {
         return ports.sorted()
     }
 
-    private static func findWorkingPort(
-        ports: [Int],
-        csrfToken: String,
-        timeout: TimeInterval) async throws -> Int
+    static func connectionCandidates(
+        listeningPorts: [Int],
+        languageServerCSRFToken: String,
+        extensionServerPort: Int?,
+        extensionServerCSRFToken: String?) -> [AntigravityConnectionEndpoint]
+    {
+        var endpoints = Self.languageServerEndpoints(
+            listeningPorts: listeningPorts,
+            languageServerCSRFToken: languageServerCSRFToken)
+
+        for endpoint in Self.extensionServerEndpoints(
+            extensionServerPort: extensionServerPort,
+            languageServerCSRFToken: languageServerCSRFToken,
+            extensionServerCSRFToken: extensionServerCSRFToken)
+        {
+            guard !endpoints.contains(where: { $0.matchesRequestTarget(endpoint) }) else { continue }
+            endpoints.append(endpoint)
+        }
+
+        return endpoints
+    }
+
+    static func requestEndpoints(
+        resolvedEndpoint: AntigravityConnectionEndpoint,
+        listeningPorts: [Int],
+        languageServerCSRFToken: String,
+        extensionServerPort: Int?,
+        extensionServerCSRFToken: String?) -> [AntigravityConnectionEndpoint]
+    {
+        var endpoints = [resolvedEndpoint]
+
+        if resolvedEndpoint.source == .extensionServer {
+            Self.appendUniqueRequestTargets(
+                from: Self.extensionServerEndpoints(
+                    extensionServerPort: extensionServerPort,
+                    languageServerCSRFToken: languageServerCSRFToken,
+                    extensionServerCSRFToken: extensionServerCSRFToken),
+                to: &endpoints)
+            Self.appendUniqueRequestTargets(
+                from: Self.languageServerEndpoints(
+                    listeningPorts: listeningPorts,
+                    languageServerCSRFToken: languageServerCSRFToken),
+                to: &endpoints)
+        } else {
+            Self.appendUniqueRequestTargets(
+                from: Self.languageServerEndpoints(
+                    listeningPorts: listeningPorts,
+                    languageServerCSRFToken: languageServerCSRFToken),
+                to: &endpoints)
+            Self.appendUniqueRequestTargets(
+                from: Self.extensionServerEndpoints(
+                    extensionServerPort: extensionServerPort,
+                    languageServerCSRFToken: languageServerCSRFToken,
+                    extensionServerCSRFToken: extensionServerCSRFToken),
+                to: &endpoints)
+        }
+
+        return endpoints
+    }
+
+    private static func languageServerEndpoints(
+        listeningPorts: [Int],
+        languageServerCSRFToken: String) -> [AntigravityConnectionEndpoint]
+    {
+        listeningPorts.flatMap { port in
+            self.localProbeSchemes.map { scheme in
+                AntigravityConnectionEndpoint(
+                    scheme: scheme,
+                    port: port,
+                    csrfToken: languageServerCSRFToken,
+                    source: .languageServer)
+            }
+        }
+    }
+
+    private static func extensionServerEndpoints(
+        extensionServerPort: Int?,
+        languageServerCSRFToken: String,
+        extensionServerCSRFToken: String?) -> [AntigravityConnectionEndpoint]
+    {
+        guard let extensionServerPort else { return [] }
+
+        var endpoints: [AntigravityConnectionEndpoint] = []
+        if let extensionServerCSRFToken {
+            endpoints.append(
+                AntigravityConnectionEndpoint(
+                    scheme: "http",
+                    port: extensionServerPort,
+                    csrfToken: extensionServerCSRFToken,
+                    source: .extensionServer))
+        }
+
+        if extensionServerCSRFToken != languageServerCSRFToken {
+            endpoints.append(
+                AntigravityConnectionEndpoint(
+                    scheme: "http",
+                    port: extensionServerPort,
+                    csrfToken: languageServerCSRFToken,
+                    source: .extensionServer))
+        }
+
+        return endpoints
+    }
+
+    private static func appendUniqueRequestTargets(
+        from candidates: [AntigravityConnectionEndpoint],
+        to endpoints: inout [AntigravityConnectionEndpoint])
     {
-        for port in ports {
-            let ok = await Self.testPortConnectivity(port: port, csrfToken: csrfToken, timeout: timeout)
-            if ok { return port }
+        for endpoint in candidates {
+            guard !endpoints.contains(where: { $0.matchesRequestTarget(endpoint) }) else { continue }
+            endpoints.append(endpoint)
+        }
+    }
+
+    static func resolveWorkingEndpoint(
+        candidateEndpoints: [AntigravityConnectionEndpoint],
+        timeout: TimeInterval,
+        deadline: Date? = nil,
+        testConnectivity: @escaping @Sendable (AntigravityConnectionEndpoint, TimeInterval) async -> Bool = Self
+            .testEndpointConnectivity) async throws -> AntigravityConnectionEndpoint
+    {
+        for (index, endpoint) in candidateEndpoints.enumerated() {
+            let remainingAttemptCount = candidateEndpoints.count - index
+            guard let attemptTimeout = timeoutForEndpointAttempt(
+                timeout: timeout,
+                deadline: deadline,
+                remainingAttemptCount: remainingAttemptCount)
+            else {
+                throw AntigravityStatusProbeError.timedOut
+            }
+            let ok = await testConnectivity(endpoint, attemptTimeout)
+            if ok { return endpoint }
+        }
+        if let fallback = fallbackProbeEndpoint(candidateEndpoints) {
+            self.log.debug("Port probe fell back to best-effort endpoint", metadata: [
+                "source": fallback.source.rawValue,
+                "scheme": fallback.scheme,
+                "port": "\(fallback.port)",
+            ])
+            return fallback
         }
         throw AntigravityStatusProbeError.portDetectionFailed("no working API port found")
     }
 
-    private static func testPortConnectivity(
-        port: Int,
-        csrfToken: String,
+    private static func timeoutForEndpointAttempt(
+        timeout: TimeInterval,
+        deadline: Date?,
+        remainingAttemptCount: Int) -> TimeInterval?
+    {
+        guard let deadline else { return timeout }
+        let remaining = deadline.timeIntervalSinceNow
+        guard remaining > 0 else { return nil }
+        return min(timeout, remaining / Double(max(1, remainingAttemptCount)))
+    }
+
+    static func fallbackProbePort(ports: [Int], extensionPort: Int?) -> Int? {
+        if let nonExtension = ports.first(where: { $0 != extensionPort }) {
+            return nonExtension
+        }
+        if let extensionPort {
+            return extensionPort
+        }
+        return ports.first
+    }
+
+    static func isReachableProbeError(_ error: Error) -> Bool {
+        guard case let AntigravityStatusProbeError.apiError(message) = error else { return false }
+        return message.hasPrefix("HTTP ")
+    }
+
+    private static func fallbackProbeEndpoint(
+        _ endpoints: [AntigravityConnectionEndpoint]) -> AntigravityConnectionEndpoint?
+    {
+        if let languageServerEndpoint = endpoints.first(where: { $0.source == .languageServer }) {
+            return languageServerEndpoint
+        }
+        return endpoints.first
+    }
+
+    private static func testEndpointConnectivity(
+        _ endpoint: AntigravityConnectionEndpoint,
         timeout: TimeInterval) async -> Bool
     {
         do {
@@ -422,15 +1405,22 @@ public struct AntigravityStatusProbe: Sendable {
                 payload: RequestPayload(
                     path: self.unleashPath,
                     body: self.unleashRequestBody()),
-                context: RequestContext(
-                    httpsPort: port,
-                    httpPort: nil,
-                    csrfToken: csrfToken,
-                    timeout: timeout))
+                context: RequestContext(endpoints: [endpoint], timeout: timeout))
             return true
         } catch {
+            if self.isReachableProbeError(error) {
+                self.log.debug("Port probe received HTTP response; treating endpoint as reachable", metadata: [
+                    "source": endpoint.source.rawValue,
+                    "scheme": endpoint.scheme,
+                    "port": "\(endpoint.port)",
+                    "error": error.localizedDescription,
+                ])
+                return true
+            }
             self.log.debug("Port probe failed", metadata: [
-                "port": "\(port)",
+                "source": endpoint.source.rawValue,
+                "scheme": endpoint.scheme,
+                "port": "\(endpoint.port)",
                 "error": error.localizedDescription,
             ])
             return false
@@ -439,16 +1429,25 @@ public struct AntigravityStatusProbe: Sendable {
 
     // MARK: - HTTP
 
-    private struct RequestPayload {
+    struct RequestPayload {
         let path: String
         let body: [String: Any]
     }
 
-    private struct RequestContext: Sendable {
-        let httpsPort: Int
-        let httpPort: Int?
-        let csrfToken: String
+    struct RequestContext {
+        let endpoints: [AntigravityConnectionEndpoint]
         let timeout: TimeInterval
+        let deadline: Date?
+
+        init(endpoints: [AntigravityConnectionEndpoint], timeout: TimeInterval, deadline: Date? = nil) {
+            self.endpoints = endpoints
+            self.timeout = timeout
+            self.deadline = deadline
+        }
+
+        func timeoutForNextAttempt() -> TimeInterval? {
+            AntigravityStatusProbe.timeoutForNextAttempt(timeout: self.timeout, deadline: self.deadline)
+        }
     }
 
     private static func defaultRequestBody() -> [String: Any] {
@@ -480,33 +1479,157 @@ public struct AntigravityStatusProbe: Sendable {
         ]
     }
 
+    static func fetchSnapshot(
+        context: RequestContext,
+        send: @escaping @Sendable (RequestPayload, AntigravityConnectionEndpoint, TimeInterval) async throws -> Data =
+            sendRequest) async throws -> AntigravityStatusSnapshot
+    {
+        do {
+            let quotaSummary = try await self.makeParsedRequest(
+                payload: RequestPayload(
+                    path: self.quotaSummaryPath,
+                    body: ["forceRefresh": true]),
+                context: self.quotaSummaryRequestContext(from: context),
+                send: send,
+                parse: self.parseQuotaSummaryResponse)
+            guard quotaSummary.quotaSummary?.groups.contains(where: { group in
+                group.buckets.contains { !$0.disabled && $0.remainingFraction != nil }
+            }) == true else {
+                throw AntigravityStatusProbeError.parseFailed("Quota summary has no usable quota buckets")
+            }
+            let identity = try? await self.makeParsedRequest(
+                payload: RequestPayload(
+                    path: self.getUserStatusPath,
+                    body: self.defaultRequestBody()),
+                context: self.identityRequestContext(from: context),
+                send: send,
+                parse: self.parseUserStatusResponse)
+            return quotaSummary.withIdentity(from: identity)
+        } catch {
+            self.log.debug("Antigravity quota summary unavailable; falling back to model quotas", metadata: [
+                "error": error.localizedDescription,
+            ])
+        }
+
+        do {
+            return try await self.makeParsedRequest(
+                payload: RequestPayload(
+                    path: self.getUserStatusPath,
+                    body: self.defaultRequestBody()),
+                context: self.legacyUserStatusRequestContext(from: context),
+                send: send,
+                parse: self.parseUserStatusResponse)
+        } catch {
+            return try await self.makeParsedRequest(
+                payload: RequestPayload(
+                    path: self.commandModelConfigPath,
+                    body: self.defaultRequestBody()),
+                context: context,
+                send: send,
+                parse: self.parseCommandModelResponse)
+        }
+    }
+
+    private static func legacyUserStatusRequestContext(from context: RequestContext) -> RequestContext {
+        guard let deadline = context.deadline else { return context }
+        let remaining = max(0, deadline.timeIntervalSinceNow)
+        let userStatusBudget = remaining / 2
+        return RequestContext(
+            endpoints: context.endpoints,
+            timeout: min(context.timeout, userStatusBudget),
+            deadline: Date().addingTimeInterval(userStatusBudget))
+    }
+
+    private static func quotaSummaryRequestContext(from context: RequestContext) -> RequestContext {
+        guard let deadline = context.deadline else { return context }
+        let remaining = max(0, deadline.timeIntervalSinceNow)
+        let quotaSummaryBudget = remaining / 2
+        return RequestContext(
+            endpoints: context.endpoints,
+            timeout: min(context.timeout, quotaSummaryBudget),
+            deadline: Date().addingTimeInterval(quotaSummaryBudget))
+    }
+
+    private static func identityRequestContext(from context: RequestContext) -> RequestContext {
+        RequestContext(
+            endpoints: context.endpoints,
+            timeout: min(context.timeout, 1),
+            deadline: context.deadline)
+    }
+
     private static func makeRequest(
         payload: RequestPayload,
         context: RequestContext) async throws -> Data
     {
-        do {
-            return try await self.sendRequest(
-                scheme: "https",
-                port: context.httpsPort,
-                payload: payload,
-                context: context)
-        } catch {
-            guard let httpPort = context.httpPort, httpPort != context.httpsPort else { throw error }
-            return try await Self.sendRequest(
-                scheme: "http",
-                port: httpPort,
-                payload: payload,
-                context: context)
+        try await self.sendRequest(payload: payload, context: context)
+    }
+
+    static func makeParsedRequest<T>(
+        payload: RequestPayload,
+        context: RequestContext,
+        send: @escaping @Sendable (RequestPayload, AntigravityConnectionEndpoint, TimeInterval) async throws -> Data =
+            sendRequest,
+        parse: @escaping @Sendable (Data) throws -> T) async throws -> T
+    {
+        var lastError: Error?
+
+        for endpoint in context.endpoints {
+            guard let timeout = context.timeoutForNextAttempt() else {
+                lastError = lastError ?? AntigravityStatusProbeError.timedOut
+                break
+            }
+            do {
+                let data = try await send(payload, endpoint, timeout)
+                return try parse(data)
+            } catch {
+                lastError = error
+                Self.log.debug("Antigravity request/parse attempt failed", metadata: [
+                    "path": payload.path,
+                    "source": endpoint.source.rawValue,
+                    "scheme": endpoint.scheme,
+                    "port": "\(endpoint.port)",
+                    "error": error.localizedDescription,
+                ])
+            }
         }
+
+        throw lastError ?? AntigravityStatusProbeError.apiError("Invalid response")
     }
 
     private static func sendRequest(
-        scheme: String,
-        port: Int,
         payload: RequestPayload,
         context: RequestContext) async throws -> Data
     {
-        guard let url = URL(string: "\(scheme)://127.0.0.1:\(port)\(payload.path)") else {
+        var lastError: Error?
+
+        for endpoint in context.endpoints {
+            guard let timeout = context.timeoutForNextAttempt() else {
+                lastError = lastError ?? AntigravityStatusProbeError.timedOut
+                break
+            }
+            do {
+                return try await Self.sendRequest(payload: payload, endpoint: endpoint, timeout: timeout)
+            } catch {
+                lastError = error
+                Self.log.debug("Antigravity request attempt failed", metadata: [
+                    "path": payload.path,
+                    "source": endpoint.source.rawValue,
+                    "scheme": endpoint.scheme,
+                    "port": "\(endpoint.port)",
+                    "error": error.localizedDescription,
+                ])
+            }
+        }
+
+        throw lastError ?? AntigravityStatusProbeError.apiError("Invalid URL")
+    }
+
+    private static func sendRequest(
+        payload: RequestPayload,
+        endpoint: AntigravityConnectionEndpoint,
+        timeout: TimeInterval) async throws -> Data
+    {
+        guard let url = URL(string: "\(endpoint.scheme)://127.0.0.1:\(endpoint.port)\(payload.path)") else {
             throw AntigravityStatusProbeError.apiError("Invalid URL")
         }
 
@@ -514,19 +1637,26 @@ public struct AntigravityStatusProbe: Sendable {
         var request = URLRequest(url: url)
         request.httpMethod = "POST"
         request.httpBody = body
-        request.timeoutInterval = context.timeout
+        request.timeoutInterval = timeout
         request.setValue("application/json", forHTTPHeaderField: "Content-Type")
         request.setValue(String(body.count), forHTTPHeaderField: "Content-Length")
         request.setValue("1", forHTTPHeaderField: "Connect-Protocol-Version")
-        request.setValue(context.csrfToken, forHTTPHeaderField: "X-Codeium-Csrf-Token")
+        if endpoint.requiresCSRFToken {
+            request.setValue(endpoint.csrfToken, forHTTPHeaderField: "X-Codeium-Csrf-Token")
+        }
 
         let config = URLSessionConfiguration.ephemeral
-        config.timeoutIntervalForRequest = context.timeout
-        config.timeoutIntervalForResource = context.timeout
-        let session = URLSession(configuration: config, delegate: InsecureSessionDelegate(), delegateQueue: nil)
+        config.timeoutIntervalForRequest = timeout
+        config.timeoutIntervalForResource = timeout
+        #if !os(Linux)
+        config.waitsForConnectivity = false
+        #endif
+
+        let delegate = LocalhostSessionDelegate()
+        let session = URLSession(configuration: config, delegate: delegate, delegateQueue: nil)
         defer { session.invalidateAndCancel() }
 
-        let (data, response) = try await session.data(for: request)
+        let (data, response) = try await delegate.data(for: request, session: session)
         guard let http = response as? HTTPURLResponse else {
             throw AntigravityStatusProbeError.apiError("Invalid response")
         }
@@ -537,134 +1667,3 @@ public struct AntigravityStatusProbe: Sendable {
         return data
     }
 }
-
-private final class InsecureSessionDelegate: NSObject {}
-
-extension InsecureSessionDelegate: URLSessionTaskDelegate {}
-
-extension InsecureSessionDelegate {
-    func urlSession(
-        _ session: URLSession,
-        task: URLSessionTask,
-        didReceive challenge: URLAuthenticationChallenge,
-        completionHandler: @escaping @MainActor @Sendable (URLSession.AuthChallengeDisposition, URLCredential?) -> Void)
-    {
-        let result = self.challengeResult(challenge)
-        Task { @MainActor in
-            completionHandler(result.disposition, result.credential)
-        }
-    }
-
-    private func challengeResult(_ challenge: URLAuthenticationChallenge) -> (
-        disposition: URLSession.AuthChallengeDisposition,
-        credential: URLCredential?)
-    {
-        #if canImport(FoundationNetworking)
-        return (.performDefaultHandling, nil)
-        #else
-        if let trust = challenge.protectionSpace.serverTrust {
-            return (.useCredential, URLCredential(trust: trust))
-        }
-        return (.performDefaultHandling, nil)
-        #endif
-    }
-}
-
-private struct UserStatusResponse: Decodable {
-    let code: CodeValue?
-    let message: String?
-    let userStatus: UserStatus?
-}
-
-private struct CommandModelConfigResponse: Decodable {
-    let code: CodeValue?
-    let message: String?
-    let clientModelConfigs: [ModelConfig]?
-}
-
-private struct UserStatus: Decodable {
-    let email: String?
-    let planStatus: PlanStatus?
-    let cascadeModelConfigData: ModelConfigData?
-}
-
-private struct PlanStatus: Decodable {
-    let planInfo: PlanInfo?
-}
-
-private struct PlanInfo: Decodable {
-    let planName: String?
-    let planDisplayName: String?
-    let displayName: String?
-    let productName: String?
-    let planShortName: String?
-
-    var preferredName: String? {
-        let candidates = [
-            planDisplayName,
-            displayName,
-            productName,
-            planName,
-            planShortName,
-        ]
-        for candidate in candidates {
-            guard let value = candidate?.trimmingCharacters(in: .whitespacesAndNewlines) else { continue }
-            if !value.isEmpty { return value }
-        }
-        return nil
-    }
-}
-
-private struct ModelConfigData: Decodable {
-    let clientModelConfigs: [ModelConfig]?
-}
-
-private struct ModelConfig: Decodable {
-    let label: String
-    let modelOrAlias: ModelAlias
-    let quotaInfo: QuotaInfo?
-}
-
-private struct ModelAlias: Decodable {
-    let model: String
-}
-
-private struct QuotaInfo: Decodable {
-    let remainingFraction: Double?
-    let resetTime: String?
-}
-
-private enum CodeValue: Decodable {
-    case int(Int)
-    case string(String)
-
-    var isOK: Bool {
-        switch self {
-        case let .int(value):
-            return value == 0
-        case let .string(value):
-            let lower = value.lowercased()
-            return lower == "ok" || lower == "success" || value == "0"
-        }
-    }
-
-    var rawValue: String {
-        switch self {
-        case let .int(value): "\(value)"
-        case let .string(value): value
-        }
-    }
-
-    init(from decoder: Decoder) throws {
-        let container = try decoder.singleValueContainer()
-        if let value = try? container.decode(Int.self) {
-            self = .int(value)
-            return
-        }
-        if let value = try? container.decode(String.self) {
-            self = .string(value)
-            return
-        }
-        throw DecodingError.dataCorruptedError(in: container, debugDescription: "Unsupported code type")
-    }
-}
diff --git a/Sources/CodexBarCore/Providers/Antigravity/AntigravityUsageDataSource.swift b/Sources/CodexBarCore/Providers/Antigravity/AntigravityUsageDataSource.swift
new file mode 100644
index 0000000000..60136c66e0
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Antigravity/AntigravityUsageDataSource.swift
@@ -0,0 +1,30 @@
+import Foundation
+
+public enum AntigravityUsageDataSource: String, CaseIterable, Identifiable, Sendable {
+    case auto
+    case oauth
+    case cli
+
+    public var id: String {
+        self.rawValue
+    }
+
+    public var displayName: String {
+        switch self {
+        case .auto: "Auto"
+        case .oauth: "Google OAuth"
+        case .cli: "Local API / agy CLI"
+        }
+    }
+
+    public var sourceLabel: String {
+        switch self {
+        case .auto:
+            "auto"
+        case .oauth:
+            "oauth"
+        case .cli:
+            "cli"
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Augment/AuggieCLIProbe.swift b/Sources/CodexBarCore/Providers/Augment/AuggieCLIProbe.swift
index 23c31b2936..ddbb6de2aa 100644
--- a/Sources/CodexBarCore/Providers/Augment/AuggieCLIProbe.swift
+++ b/Sources/CodexBarCore/Providers/Augment/AuggieCLIProbe.swift
@@ -13,6 +13,9 @@ public struct AuggieCLIProbe: Sendable {
         return try self.parse(output)
     }
 
+    /// Timeout for the `auggie account status` command.
+    private static let commandTimeout: TimeInterval = 15
+
     private func runAuggieAccountStatus() async throws -> String {
         let env = ProcessInfo.processInfo.environment
         let loginPATH = LoginShellPathCache.shared.current
@@ -24,24 +27,15 @@ public struct AuggieCLIProbe: Sendable {
             env: env,
             loginPATH: loginPATH)
 
-        let process = Process()
-        process.executableURL = URL(fileURLWithPath: executable)
-        process.arguments = ["account", "status"]
-        process.environment = pathEnv
-
-        let stdout = Pipe()
-        let stderr = Pipe()
-        process.standardOutput = stdout
-        process.standardError = stderr
-
-        try process.run()
-        process.waitUntilExit()
+        let result = try await SubprocessRunner.run(
+            binary: executable,
+            arguments: ["account", "status"],
+            environment: pathEnv,
+            timeout: Self.commandTimeout,
+            label: "auggie-account-status")
 
-        let outputData = stdout.fileHandleForReading.readDataToEndOfFile()
-        let errorData = stderr.fileHandleForReading.readDataToEndOfFile()
-
-        let output = String(data: outputData, encoding: .utf8) ?? ""
-        let errorOutput = String(data: errorData, encoding: .utf8) ?? ""
+        let output = result.stdout
+        let errorOutput = result.stderr
 
         guard !output.isEmpty else {
             if !errorOutput.isEmpty {
@@ -58,11 +52,16 @@ public struct AuggieCLIProbe: Sendable {
         return output
     }
 
-    private func parse(_ output: String) throws -> AugmentStatusSnapshot {
-        // Parse output like:
+    func parse(_ output: String) throws -> AugmentStatusSnapshot {
+        // Legacy output:
         // Max Plan 450,000 credits / month
         // 11,657 remaining · 953,170 / 964,827 credits used
         // 2 days remaining in this billing cycle (ends 1/8/2026)
+        //
+        // Current output (2026+):
+        // 319,054 credits remaining                     Max Plan
+        // 450,000 credits / month
+        // 9 days remaining in this billing cycle (ends 6/9/2026)
 
         var maxCredits: Int?
         var remaining: Int?
@@ -73,8 +72,15 @@ public struct AuggieCLIProbe: Sendable {
         for line in output.split(separator: "\n") {
             let trimmed = line.trimmingCharacters(in: .whitespaces)
 
-            // Parse "Max Plan 450,000 credits / month"
-            if trimmed.contains("Max Plan"), trimmed.contains("credits") {
+            if trimmed.contains("credits / month") {
+                if let match = trimmed.range(of: #"([\d,]+)\s+credits\s*/\s*month"#, options: .regularExpression) {
+                    let numberStr = String(trimmed[match]).replacingOccurrences(of: ",", with: "")
+                        .replacingOccurrences(of: " credits", with: "")
+                        .replacingOccurrences(of: " / month", with: "")
+                    maxCredits = Int(numberStr)
+                    total = total ?? Int(numberStr)
+                }
+            } else if trimmed.contains("Max Plan"), trimmed.contains("credits"), !trimmed.contains("remaining") {
                 if let match = trimmed.range(of: #"([\d,]+)\s+credits"#, options: .regularExpression) {
                     let numberStr = String(trimmed[match]).replacingOccurrences(of: ",", with: "")
                         .replacingOccurrences(of: " credits", with: "")
@@ -82,9 +88,17 @@ public struct AuggieCLIProbe: Sendable {
                 }
             }
 
+            if trimmed.contains("credits remaining"), !trimmed.contains("billing cycle") {
+                if let match = trimmed.range(of: #"([\d,]+)\s+credits\s+remaining"#, options: .regularExpression) {
+                    let numberStr = String(trimmed[match]).replacingOccurrences(of: ",", with: "")
+                        .replacingOccurrences(of: " credits", with: "")
+                        .replacingOccurrences(of: " remaining", with: "")
+                    remaining = Int(numberStr)
+                }
+            }
+
             // Parse "11,657 remaining · 953,170 / 964,827 credits used"
             if trimmed.contains("remaining"), trimmed.contains("credits used") {
-                // Extract remaining
                 if let remMatch = trimmed.range(of: #"([\d,]+)\s+remaining"#, options: .regularExpression) {
                     let numStr = String(trimmed[remMatch])
                         .replacingOccurrences(of: ",", with: "")
@@ -92,7 +106,6 @@ public struct AuggieCLIProbe: Sendable {
                     remaining = Int(numStr)
                 }
 
-                // Extract used / total
                 if let usedMatch = trimmed.range(
                     of: #"([\d,]+)\s*/\s*([\d,]+)\s+credits used"#,
                     options: .regularExpression)
@@ -109,15 +122,12 @@ public struct AuggieCLIProbe: Sendable {
                 }
             }
 
-            // Parse "2 days remaining in this billing cycle (ends 1/8/2026)"
             if trimmed.contains("billing cycle"), trimmed.contains("ends") {
-                // Extract date from "(ends 1/8/2026)"
                 if let dateMatch = trimmed.range(of: #"ends\s+([\d/]+)"#, options: .regularExpression) {
                     let dateStr = String(trimmed[dateMatch])
                         .replacingOccurrences(of: "ends", with: "")
                         .trimmingCharacters(in: .whitespaces)
 
-                    // Parse date like "1/8/2026"
                     let formatter = DateFormatter()
                     formatter.dateFormat = "M/d/yyyy"
                     formatter.locale = Locale(identifier: "en_US_POSIX")
@@ -127,11 +137,19 @@ public struct AuggieCLIProbe: Sendable {
             }
         }
 
-        guard let finalRemaining = remaining, let finalUsed = used, let finalTotal = total else {
+        guard let finalRemaining = remaining else {
             Self.log.error("Failed to parse auggie output: \(output)")
             throw AuggieCLIError.parseError("Could not extract credits from output")
         }
 
+        let finalTotal = total ?? maxCredits
+        guard let finalTotal else {
+            Self.log.error("Failed to parse auggie output: \(output)")
+            throw AuggieCLIError.parseError("Could not extract credits from output")
+        }
+
+        let finalUsed = used ?? max(0, finalTotal - finalRemaining)
+
         return AugmentStatusSnapshot(
             creditsRemaining: Double(finalRemaining),
             creditsUsed: Double(finalUsed),
diff --git a/Sources/CodexBarCore/Providers/Augment/AugmentProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Augment/AugmentProviderDescriptor.swift
index 4ccb0987fa..71cabf92eb 100644
--- a/Sources/CodexBarCore/Providers/Augment/AugmentProviderDescriptor.swift
+++ b/Sources/CodexBarCore/Providers/Augment/AugmentProviderDescriptor.swift
@@ -1,13 +1,12 @@
-import CodexBarMacroSupport
 import Foundation
 
 #if os(macOS)
 import SweetCookieKit
 #endif
 
-@ProviderDescriptorRegistration
-@ProviderDescriptorDefinition
 public enum AugmentProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
     static func makeDescriptor() -> ProviderDescriptor {
         #if os(macOS)
         // Custom browser order that includes Chrome Beta and other variants
@@ -95,10 +94,8 @@ struct AugmentCLIFetchStrategy: ProviderFetchStrategy {
         // Fallback to web if CLI fails (not authenticated, etc.)
         if let cliError = error as? AuggieCLIError {
             switch cliError {
-            case .notAuthenticated, .noOutput:
+            case .notAuthenticated, .noOutput, .parseError:
                 return true
-            case .parseError:
-                return false // Don't fallback on parse errors - something is wrong
             }
         }
         return true
diff --git a/Sources/CodexBarCore/Providers/Augment/AugmentSessionKeepalive.swift b/Sources/CodexBarCore/Providers/Augment/AugmentSessionKeepalive.swift
index 9485c8ef71..7ffa2aeae0 100644
--- a/Sources/CodexBarCore/Providers/Augment/AugmentSessionKeepalive.swift
+++ b/Sources/CodexBarCore/Providers/Augment/AugmentSessionKeepalive.swift
@@ -59,9 +59,15 @@ public final class AugmentSessionKeepalive {
         }
 
         self.log("🚀 Starting Augment session keepalive")
-        self.log("   - Check interval: \(Int(self.checkInterval))s (every 5 minutes)")
-        self.log("   - Refresh buffer: \(Int(self.refreshBufferSeconds))s (5 minutes before expiry)")
-        self.log("   - Min refresh interval: \(Int(self.minRefreshInterval))s (2 minutes)")
+        self.log(
+            "   - Check interval: \(Int(self.checkInterval))s "
+                + "(\(Self.durationDescription(seconds: self.checkInterval)))")
+        self.log(
+            "   - Refresh buffer: \(Int(self.refreshBufferSeconds))s "
+                + "(\(Self.durationDescription(seconds: self.refreshBufferSeconds)) before expiry)")
+        self.log(
+            "   - Min refresh interval: \(Int(self.minRefreshInterval))s "
+                + "(\(Self.durationDescription(seconds: self.minRefreshInterval)))")
 
         self.timerTask = Task.detached(priority: .utility) { [weak self] in
             while !Task.isCancelled {
@@ -206,6 +212,12 @@ public final class AugmentSessionKeepalive {
                 try await Task.sleep(for: .seconds(1)) // Brief delay for browser to update cookies
                 let newSession = try AugmentCookieImporter.importSession(logger: self.logger)
 
+                await AugmentSessionStore.shared.setCookies(newSession.cookies)
+                CookieHeaderCache.store(
+                    provider: .augment,
+                    cookieHeader: newSession.cookieHeader,
+                    sourceLabel: newSession.sourceLabel)
+
                 self.log(
                     "✅ Session refresh successful - imported \(newSession.cookies.count) cookies " +
                         "from \(newSession.sourceLabel)")
@@ -214,6 +226,11 @@ public final class AugmentSessionKeepalive {
                 // Reset failure tracking on success
                 self.consecutiveFailures = 0
                 self.hasGivenUp = false
+
+                if let callback = self.onSessionRecovered {
+                    self.log("🔄 Triggering usage refresh after session refresh")
+                    await callback()
+                }
             } else {
                 self.log("⚠️ Session refresh returned no new cookies")
                 self.consecutiveFailures += 1
@@ -371,7 +388,7 @@ public final class AugmentSessionKeepalive {
             request.setValue("https://app.augmentcode.com", forHTTPHeaderField: "Referer")
 
             do {
-                let (data, response) = try await URLSession.shared.data(for: request)
+                let (data, response) = try await ProviderHTTPClient.shared.data(for: request)
 
                 guard let httpResponse = response as? HTTPURLResponse else {
                     self.log("   ✗ Invalid response type")
@@ -435,6 +452,15 @@ public final class AugmentSessionKeepalive {
 
     private static let log = CodexBarLog.logger(LogCategories.augmentKeepalive)
 
+    private static func durationDescription(seconds: TimeInterval) -> String {
+        let totalSeconds = max(0, Int(seconds.rounded()))
+        if totalSeconds >= 60, totalSeconds % 60 == 0 {
+            let minutes = totalSeconds / 60
+            return "\(minutes) minute\(minutes == 1 ? "" : "s")"
+        }
+        return "\(totalSeconds) second\(totalSeconds == 1 ? "" : "s")"
+    }
+
     private func log(_ message: String) {
         let timestamp = Date().formatted(date: .omitted, time: .standard)
         let fullMessage = "[\(timestamp)] [AugmentKeepalive] \(message)"
diff --git a/Sources/CodexBarCore/Providers/Augment/AugmentStatusProbe.swift b/Sources/CodexBarCore/Providers/Augment/AugmentStatusProbe.swift
index 43459fd1f1..52ae33aebd 100644
--- a/Sources/CodexBarCore/Providers/Augment/AugmentStatusProbe.swift
+++ b/Sources/CodexBarCore/Providers/Augment/AugmentStatusProbe.swift
@@ -15,12 +15,15 @@ public enum AugmentCookieImporter {
     /// NOTE: This list may not be exhaustive. If authentication fails with cookies present,
     /// check debug logs for cookie names and report them.
     private static let sessionCookieNames: Set<String> = [
-        "_session", // Legacy session cookie
+        "session", // Augment auth session (auth.augmentcode.com)
+        "_session", // Legacy session cookie (app.augmentcode.com)
+        "web_rpc_proxy_session", // Augment RPC proxy session
         "auth0", // Auth0 session
         "auth0.is.authenticated", // Auth0 authentication flag
         "a0.spajs.txs", // Auth0 SPA transaction state
         "__Secure-next-auth.session-token", // NextAuth secure session
         "next-auth.session-token", // NextAuth session
+        "__Secure-authjs.session-token", // AuthJS secure session
         "__Host-authjs.csrf-token", // AuthJS CSRF token
         "authjs.session-token", // AuthJS session
     ]
@@ -67,7 +70,7 @@ public enum AugmentCookieImporter {
         for browserSource in augmentCookieImportOrder {
             do {
                 let query = BrowserCookieQuery(domains: cookieDomains)
-                let sources = try Self.cookieClient.records(
+                let sources = try Self.cookieClient.codexBarRecords(
                     matching: query,
                     in: browserSource,
                     logger: log)
@@ -131,6 +134,10 @@ public struct AugmentCreditsResponse: Codable, Sendable {
     }
 
     public var creditsLimit: Double? {
+        if let available = self.usageUnitsAvailable, available > 0 {
+            return available
+        }
+
         guard let remaining = self.usageUnitsRemaining,
               let consumed = self.usageUnitsConsumedThisBillingCycle
         else {
@@ -222,6 +229,7 @@ public struct AugmentStatusSnapshot: Sendable {
 
     private static func formatResetDate(_ date: Date) -> String {
         let formatter = RelativeDateTimeFormatter()
+        formatter.locale = Locale(identifier: "en_US")
         formatter.unitsStyle = .full
         return formatter.localizedString(for: date, relativeTo: Date())
     }
@@ -492,7 +500,7 @@ public struct AugmentStatusProbe: Sendable {
         request.setValue("application/json", forHTTPHeaderField: "Accept")
         request.setValue(cookieHeader, forHTTPHeaderField: "Cookie")
 
-        let (data, response) = try await URLSession.shared.data(for: request)
+        let (data, response) = try await ProviderHTTPClient.shared.data(for: request)
 
         guard let httpResponse = response as? HTTPURLResponse else {
             throw AugmentStatusProbeError.networkError("Invalid response")
@@ -530,7 +538,7 @@ public struct AugmentStatusProbe: Sendable {
         request.setValue("application/json", forHTTPHeaderField: "Accept")
         request.setValue(cookieHeader, forHTTPHeaderField: "Cookie")
 
-        let (data, response) = try await URLSession.shared.data(for: request)
+        let (data, response) = try await ProviderHTTPClient.shared.data(for: request)
 
         guard let httpResponse = response as? HTTPURLResponse else {
             throw AugmentStatusProbeError.networkError("Invalid response")
@@ -589,14 +597,16 @@ public struct AugmentStatusProbe: Sendable {
     }
 
     /// Debug probe that returns raw API responses
-    public func debugRawProbe() async -> String {
+    public func debugRawProbe(cookieHeaderOverride: String? = nil) async -> String {
         let stamp = ISO8601DateFormatter().string(from: Date())
         var lines: [String] = []
         lines.append("=== Augment Debug Probe @ \(stamp) ===")
         lines.append("")
 
         do {
-            let snapshot = try await self.fetch(logger: { msg in lines.append("[log] \(msg)") })
+            let snapshot = try await self.fetch(
+                cookieHeaderOverride: cookieHeaderOverride,
+                logger: { msg in lines.append("[log] \(msg)") })
             lines.append("")
             lines.append("Probe Success")
             lines.append("")
@@ -616,13 +626,13 @@ public struct AugmentStatusProbe: Sendable {
             }
 
             let output = lines.joined(separator: "\n")
-            Task { @MainActor in Self.recordDump(output) }
+            await MainActor.run { Self.recordDump(output) }
             return output
         } catch {
             lines.append("")
             lines.append("Probe Failed: \(error.localizedDescription)")
             let output = lines.joined(separator: "\n")
-            Task { @MainActor in Self.recordDump(output) }
+            await MainActor.run { Self.recordDump(output) }
             return output
         }
     }
diff --git a/Sources/CodexBarCore/Providers/AzureOpenAI/AzureOpenAIProviderDescriptor.swift b/Sources/CodexBarCore/Providers/AzureOpenAI/AzureOpenAIProviderDescriptor.swift
new file mode 100644
index 0000000000..52859faeca
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/AzureOpenAI/AzureOpenAIProviderDescriptor.swift
@@ -0,0 +1,92 @@
+import Foundation
+
+public enum AzureOpenAIProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .azureopenai,
+            metadata: ProviderMetadata(
+                id: .azureopenai,
+                displayName: "Azure OpenAI",
+                sessionLabel: "Status",
+                weeklyLabel: "Deployment",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "",
+                toggleTitle: "Show Azure OpenAI status",
+                cliName: "azure-openai",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                browserCookieOrder: nil,
+                dashboardURL: "https://ai.azure.com",
+                statusPageURL: nil,
+                statusLinkURL: "https://azure.status.microsoft/en-us/status"),
+            branding: ProviderBranding(
+                iconStyle: .openai,
+                iconResourceName: "ProviderIcon-codex",
+                color: ProviderColor(red: 0, green: 120 / 255, blue: 212 / 255)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "Azure OpenAI usage history is not exposed by the deployment validation probe." }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .api],
+                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [AzureOpenAIAPIFetchStrategy()] })),
+            cli: ProviderCLIConfig(
+                name: "azure-openai",
+                aliases: ["azureopenai", "aoai"],
+                versionDetector: nil))
+    }
+}
+
+struct AzureOpenAIAPIFetchStrategy: ProviderFetchStrategy {
+    let id: String = "azureopenai.api"
+    let kind: ProviderFetchKind = .apiToken
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        _ = context
+        // Keep the strategy available so missing partial configuration surfaces
+        // as a precise settings error instead of a generic no-strategy failure.
+        return true
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        guard let apiKey = Self.resolveAPIKey(environment: context.env) else {
+            throw AzureOpenAIUsageError.missingAPIKey
+        }
+        try AzureOpenAISettingsReader.validateEndpointOverrides(environment: context.env)
+        guard let endpoint = Self.resolveEndpoint(environment: context.env) else {
+            throw AzureOpenAIUsageError.missingEndpoint
+        }
+        guard let deploymentName = Self.resolveDeploymentName(environment: context.env) else {
+            throw AzureOpenAIUsageError.missingDeploymentName
+        }
+
+        let usage = try await AzureOpenAIUsageFetcher.fetchUsage(
+            apiKey: apiKey,
+            endpoint: endpoint,
+            deploymentName: deploymentName,
+            apiVersion: AzureOpenAISettingsReader.apiVersion(environment: context.env))
+        return self.makeResult(
+            usage: usage.toUsageSnapshot(),
+            sourceLabel: "deployment")
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+
+    private static func resolveAPIKey(environment: [String: String]) -> String? {
+        ProviderTokenResolver.azureOpenAIToken(environment: environment)
+    }
+
+    private static func resolveEndpoint(environment: [String: String]) -> URL? {
+        AzureOpenAISettingsReader.endpoint(environment: environment)
+    }
+
+    private static func resolveDeploymentName(environment: [String: String]) -> String? {
+        AzureOpenAISettingsReader.deploymentName(environment: environment)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/AzureOpenAI/AzureOpenAISettingsReader.swift b/Sources/CodexBarCore/Providers/AzureOpenAI/AzureOpenAISettingsReader.swift
new file mode 100644
index 0000000000..53706dd8c6
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/AzureOpenAI/AzureOpenAISettingsReader.swift
@@ -0,0 +1,82 @@
+import Foundation
+
+public enum AzureOpenAISettingsReader {
+    public static let apiKeyEnvironmentKey = "AZURE_OPENAI_API_KEY"
+    public static let endpointEnvironmentKey = "AZURE_OPENAI_ENDPOINT"
+    public static let deploymentNameEnvironmentKey = "AZURE_OPENAI_DEPLOYMENT_NAME"
+    public static let apiVersionEnvironmentKey = "AZURE_OPENAI_API_VERSION"
+    public static let defaultAPIVersion = "2024-10-21"
+
+    public static func apiKey(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        self.cleaned(environment[self.apiKeyEnvironmentKey])
+    }
+
+    public static func endpoint(environment: [String: String] = ProcessInfo.processInfo.environment) -> URL? {
+        guard let rawEndpoint = self.rawEndpoint(environment: environment) else { return nil }
+        return self.endpointURL(from: rawEndpoint)
+    }
+
+    public static func rawEndpoint(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        self.cleaned(environment[self.endpointEnvironmentKey])
+    }
+
+    public static func deploymentName(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        self.cleaned(environment[self.deploymentNameEnvironmentKey])
+    }
+
+    public static func apiVersion(environment: [String: String] = ProcessInfo.processInfo.environment) -> String {
+        self.cleaned(environment[self.apiVersionEnvironmentKey]) ?? self.defaultAPIVersion
+    }
+
+    public static func endpointURL(from rawEndpoint: String) -> URL? {
+        let trimmed = rawEndpoint.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else { return nil }
+        return ProviderEndpointOverrideValidator.normalizedHTTPSURL(from: trimmed)
+    }
+
+    public static func validateEndpointOverrides(
+        environment: [String: String] = ProcessInfo.processInfo.environment) throws
+    {
+        guard let rawEndpoint = self.rawEndpoint(environment: environment) else { return }
+        guard self.endpointURL(from: rawEndpoint) != nil else {
+            throw AzureOpenAISettingsError.invalidEndpointOverride(self.endpointEnvironmentKey)
+        }
+    }
+
+    static func cleaned(_ raw: String?) -> String? {
+        guard var value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
+            return nil
+        }
+
+        if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
+            (value.hasPrefix("'") && value.hasSuffix("'"))
+        {
+            value = String(value.dropFirst().dropLast())
+        }
+
+        value = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        return value.isEmpty ? nil : value
+    }
+}
+
+public enum AzureOpenAISettingsError: LocalizedError, Sendable, Equatable {
+    case missingAPIKey
+    case missingEndpoint
+    case missingDeploymentName
+    case invalidEndpointOverride(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingAPIKey:
+            "Azure OpenAI API key not configured. Set AZURE_OPENAI_API_KEY or configure an API key in Settings."
+        case .missingEndpoint:
+            "Azure OpenAI endpoint not configured. Set AZURE_OPENAI_ENDPOINT or configure an endpoint in Settings."
+        case .missingDeploymentName:
+            "Azure OpenAI deployment not configured. Set AZURE_OPENAI_DEPLOYMENT_NAME or configure a deployment " +
+                "in Settings."
+        case let .invalidEndpointOverride(key):
+            "Azure OpenAI endpoint override \(key) is not allowed. " +
+                "Use an HTTPS endpoint without user info or encoded host tricks."
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/AzureOpenAI/AzureOpenAIUsageFetcher.swift b/Sources/CodexBarCore/Providers/AzureOpenAI/AzureOpenAIUsageFetcher.swift
new file mode 100644
index 0000000000..716d75c234
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/AzureOpenAI/AzureOpenAIUsageFetcher.swift
@@ -0,0 +1,244 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public struct AzureOpenAIUsageSnapshot: Codable, Sendable, Equatable {
+    public let endpointHost: String
+    public let deploymentName: String
+    public let model: String?
+    public let apiVersion: String
+    public let updatedAt: Date
+
+    public init(
+        endpointHost: String,
+        deploymentName: String,
+        model: String?,
+        apiVersion: String,
+        updatedAt: Date)
+    {
+        self.endpointHost = endpointHost
+        self.deploymentName = deploymentName
+        self.model = model
+        self.apiVersion = apiVersion
+        self.updatedAt = updatedAt
+    }
+
+    public func toUsageSnapshot() -> UsageSnapshot {
+        let detail = Self.detailText(deploymentName: self.deploymentName, model: self.model)
+        return UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 0,
+                windowMinutes: nil,
+                resetsAt: nil,
+                resetDescription: detail),
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: self.updatedAt,
+            identity: ProviderIdentitySnapshot(
+                providerID: .azureopenai,
+                accountEmail: nil,
+                accountOrganization: self.endpointHost,
+                loginMethod: "Deployment: \(self.deploymentName)"))
+    }
+
+    private static func detailText(deploymentName: String, model: String?) -> String {
+        let cleanedModel = model?.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard let cleanedModel, !cleanedModel.isEmpty else {
+            return "Deployment: \(deploymentName)"
+        }
+        return "Deployment: \(deploymentName) · Model: \(cleanedModel)"
+    }
+}
+
+public enum AzureOpenAIUsageError: LocalizedError, Sendable, Equatable {
+    case missingAPIKey
+    case missingEndpoint
+    case missingDeploymentName
+    case invalidEndpointOverride(String)
+    case invalidURL
+    case networkError(String)
+    case apiError(statusCode: Int, message: String)
+    case parseFailed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingAPIKey:
+            AzureOpenAISettingsError.missingAPIKey.errorDescription
+        case .missingEndpoint:
+            AzureOpenAISettingsError.missingEndpoint.errorDescription
+        case .missingDeploymentName:
+            AzureOpenAISettingsError.missingDeploymentName.errorDescription
+        case let .invalidEndpointOverride(key):
+            AzureOpenAISettingsError.invalidEndpointOverride(key).errorDescription
+        case .invalidURL:
+            "Azure OpenAI validation URL is invalid."
+        case let .networkError(message):
+            "Azure OpenAI network error: \(message)"
+        case let .apiError(statusCode, message):
+            if message.isEmpty {
+                "Azure OpenAI API error: HTTP \(statusCode)"
+            } else {
+                "Azure OpenAI API error: HTTP \(statusCode): \(message)"
+            }
+        case let .parseFailed(message):
+            "Azure OpenAI response parse error: \(message)"
+        }
+    }
+}
+
+private struct AzureOpenAIChatCompletionResponse: Decodable {
+    let model: String?
+}
+
+public enum AzureOpenAIUsageFetcher {
+    private static let timeoutSeconds: TimeInterval = 20
+    private static let maxErrorBodyLength = 240
+
+    public static func fetchUsage(
+        apiKey: String,
+        endpoint: URL,
+        deploymentName: String,
+        apiVersion: String = AzureOpenAISettingsReader.defaultAPIVersion,
+        transport: any ProviderHTTPTransport = ProviderHTTPClient.shared,
+        updatedAt: Date = Date()) async throws -> AzureOpenAIUsageSnapshot
+    {
+        let apiKey = apiKey.trimmingCharacters(in: .whitespacesAndNewlines)
+        let deploymentName = deploymentName.trimmingCharacters(in: .whitespacesAndNewlines)
+        let apiVersion = apiVersion.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !apiKey.isEmpty else { throw AzureOpenAIUsageError.missingAPIKey }
+        guard !deploymentName.isEmpty else { throw AzureOpenAIUsageError.missingDeploymentName }
+        guard let endpoint = ProviderEndpointOverrideValidator.normalizedHTTPSURL(from: endpoint.absoluteString) else {
+            throw AzureOpenAIUsageError.invalidEndpointOverride(AzureOpenAISettingsReader.endpointEnvironmentKey)
+        }
+        let effectiveAPIVersion = apiVersion.isEmpty ? AzureOpenAISettingsReader.defaultAPIVersion : apiVersion
+
+        var request = try URLRequest(url: self.chatCompletionsURL(
+            endpoint: endpoint,
+            deploymentName: deploymentName,
+            apiVersion: effectiveAPIVersion))
+        request.httpMethod = "POST"
+        request.timeoutInterval = Self.timeoutSeconds
+        request.setValue(apiKey, forHTTPHeaderField: "api-key")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.httpBody = try self.validationRequestBody(
+            deploymentName: deploymentName,
+            apiVersion: effectiveAPIVersion)
+
+        let response: ProviderHTTPResponse
+        do {
+            response = try await transport.response(for: request)
+        } catch {
+            throw AzureOpenAIUsageError.networkError(error.localizedDescription)
+        }
+
+        guard (200..<300).contains(response.statusCode) else {
+            throw AzureOpenAIUsageError.apiError(
+                statusCode: response.statusCode,
+                message: self.responseSummary(response.data))
+        }
+
+        let model: String?
+        do {
+            model = try JSONDecoder().decode(AzureOpenAIChatCompletionResponse.self, from: response.data).model
+        } catch {
+            throw AzureOpenAIUsageError.parseFailed(error.localizedDescription)
+        }
+
+        return AzureOpenAIUsageSnapshot(
+            endpointHost: endpoint.host ?? endpoint.absoluteString,
+            deploymentName: deploymentName,
+            model: model,
+            apiVersion: effectiveAPIVersion,
+            updatedAt: updatedAt)
+    }
+
+    public static func _chatCompletionsURLForTesting(
+        endpoint: URL,
+        deploymentName: String,
+        apiVersion: String) throws -> URL
+    {
+        try self.chatCompletionsURL(endpoint: endpoint, deploymentName: deploymentName, apiVersion: apiVersion)
+    }
+
+    private static func chatCompletionsURL(
+        endpoint: URL,
+        deploymentName: String,
+        apiVersion: String) throws -> URL
+    {
+        if self.usesV1API(apiVersion) {
+            let base = self.apiRoot(endpoint: endpoint, pathComponents: ["openai", "v1"])
+                .appendingPathComponent("chat")
+                .appendingPathComponent("completions")
+            guard let url = URLComponents(url: base, resolvingAgainstBaseURL: false)?.url else {
+                throw AzureOpenAIUsageError.invalidURL
+            }
+            return url
+        }
+
+        let base = self.apiRoot(endpoint: endpoint, pathComponents: ["openai"])
+            .appendingPathComponent("deployments")
+            .appendingPathComponent(deploymentName)
+            .appendingPathComponent("chat")
+            .appendingPathComponent("completions")
+        guard var components = URLComponents(url: base, resolvingAgainstBaseURL: false) else {
+            throw AzureOpenAIUsageError.invalidURL
+        }
+        components.queryItems = [URLQueryItem(name: "api-version", value: apiVersion)]
+        guard let url = components.url else { throw AzureOpenAIUsageError.invalidURL }
+        return url
+    }
+
+    private static func apiRoot(endpoint: URL, pathComponents expectedComponents: [String]) -> URL {
+        let existingComponents = endpoint.pathComponents
+            .filter { $0 != "/" }
+            .map { $0.lowercased() }
+        let expectedComponents = expectedComponents.map { $0.lowercased() }
+        let sharedCount = stride(
+            from: min(existingComponents.count, expectedComponents.count),
+            through: 0,
+            by: -1)
+            .first { count in
+                count == 0 || Array(existingComponents.suffix(count)) == Array(expectedComponents.prefix(count))
+            } ?? 0
+        return expectedComponents.dropFirst(sharedCount).reduce(endpoint) { url, component in
+            url.appendingPathComponent(component)
+        }
+    }
+
+    private static func validationRequestBody(
+        deploymentName: String,
+        apiVersion: String) throws -> Data
+    {
+        var payload: [String: Any] = [
+            "messages": [
+                ["role": "user", "content": "ping"],
+            ],
+        ]
+        if self.usesV1API(apiVersion) {
+            payload["model"] = deploymentName
+            payload["max_completion_tokens"] = 1
+        } else {
+            payload["max_tokens"] = 1
+        }
+        return try JSONSerialization.data(withJSONObject: payload, options: [])
+    }
+
+    private static func usesV1API(_ apiVersion: String) -> Bool {
+        apiVersion.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() == "v1"
+    }
+
+    private static func responseSummary(_ data: Data) -> String {
+        guard let body = String(data: data, encoding: .utf8)?
+            .replacingOccurrences(of: #"\s+"#, with: " ", options: .regularExpression)
+            .trimmingCharacters(in: .whitespacesAndNewlines),
+            !body.isEmpty
+        else {
+            return ""
+        }
+        guard body.count > Self.maxErrorBodyLength else { return body }
+        let index = body.index(body.startIndex, offsetBy: Self.maxErrorBodyLength)
+        return "\(body[..<index])… [truncated]"
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Bedrock/BedrockAWSSigner.swift b/Sources/CodexBarCore/Providers/Bedrock/BedrockAWSSigner.swift
new file mode 100644
index 0000000000..360ac9ee05
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Bedrock/BedrockAWSSigner.swift
@@ -0,0 +1,179 @@
+#if canImport(CryptoKit)
+import CryptoKit
+#else
+import Crypto
+#endif
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+enum BedrockAWSSigner {
+    struct Credentials {
+        let accessKeyID: String
+        let secretAccessKey: String
+        let sessionToken: String?
+    }
+
+    static func sign(
+        request: inout URLRequest,
+        credentials: Credentials,
+        region: String,
+        service: String,
+        date: Date = Date())
+    {
+        let dateFormatter = Self.dateFormatter()
+        let dateStamp = Self.dateStamp(date: date)
+        let amzDate = dateFormatter.string(from: date)
+
+        request.setValue(amzDate, forHTTPHeaderField: "X-Amz-Date")
+        if let sessionToken = credentials.sessionToken {
+            request.setValue(sessionToken, forHTTPHeaderField: "X-Amz-Security-Token")
+        }
+
+        let host = request.url?.host ?? ""
+        request.setValue(host, forHTTPHeaderField: "Host")
+
+        let bodyHash = Self.sha256Hex(request.httpBody ?? Data())
+        request.setValue(bodyHash, forHTTPHeaderField: "x-amz-content-sha256")
+
+        let signedHeaders = Self.signedHeaders(request: request)
+        let canonicalRequest = Self.canonicalRequest(
+            request: request,
+            signedHeaders: signedHeaders,
+            bodyHash: bodyHash)
+
+        let credentialScope = "\(dateStamp)/\(region)/\(service)/aws4_request"
+        let stringToSign = [
+            "AWS4-HMAC-SHA256",
+            amzDate,
+            credentialScope,
+            Self.sha256Hex(Data(canonicalRequest.utf8)),
+        ].joined(separator: "\n")
+
+        let signature = Self.calculateSignature(
+            secretKey: credentials.secretAccessKey,
+            dateStamp: dateStamp,
+            region: region,
+            service: service,
+            stringToSign: stringToSign)
+
+        let authorization = "AWS4-HMAC-SHA256 "
+            + "Credential=\(credentials.accessKeyID)/\(credentialScope), "
+            + "SignedHeaders=\(signedHeaders.keys), "
+            + "Signature=\(signature)"
+
+        request.setValue(authorization, forHTTPHeaderField: "Authorization")
+    }
+
+    private struct SignedHeadersInfo {
+        let keys: String
+        let canonical: String
+    }
+
+    private static func signedHeaders(request: URLRequest) -> SignedHeadersInfo {
+        var headers: [(String, String)] = []
+        if let allHeaders = request.allHTTPHeaderFields {
+            for (key, value) in allHeaders {
+                headers.append((key.lowercased(), value.trimmingCharacters(in: .whitespaces)))
+            }
+        }
+        headers.sort { $0.0 < $1.0 }
+
+        let keys = headers.map(\.0).joined(separator: ";")
+        let canonical = headers.map { "\($0.0):\($0.1)" }.joined(separator: "\n")
+        return SignedHeadersInfo(keys: keys, canonical: canonical)
+    }
+
+    private static func canonicalRequest(
+        request: URLRequest,
+        signedHeaders: SignedHeadersInfo,
+        bodyHash: String) -> String
+    {
+        let method = request.httpMethod ?? "GET"
+        let url = request.url!
+        let path = url.path.isEmpty ? "/" : url.path
+        let query = Self.canonicalQueryString(url: url)
+
+        return [
+            method,
+            Self.uriEncodePath(path),
+            query,
+            signedHeaders.canonical + "\n",
+            signedHeaders.keys,
+            bodyHash,
+        ].joined(separator: "\n")
+    }
+
+    private static func canonicalQueryString(url: URL) -> String {
+        guard let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
+              let queryItems = components.queryItems,
+              !queryItems.isEmpty
+        else {
+            return ""
+        }
+
+        return queryItems
+            .map { item in
+                let key = Self.uriEncode(item.name)
+                let value = Self.uriEncode(item.value ?? "")
+                return "\(key)=\(value)"
+            }
+            .sorted()
+            .joined(separator: "&")
+    }
+
+    private static func calculateSignature(
+        secretKey: String,
+        dateStamp: String,
+        region: String,
+        service: String,
+        stringToSign: String) -> String
+    {
+        let kDate = Self.hmacSHA256(key: Data("AWS4\(secretKey)".utf8), data: Data(dateStamp.utf8))
+        let kRegion = Self.hmacSHA256(key: kDate, data: Data(region.utf8))
+        let kService = Self.hmacSHA256(key: kRegion, data: Data(service.utf8))
+        let kSigning = Self.hmacSHA256(key: kService, data: Data("aws4_request".utf8))
+        let signature = Self.hmacSHA256(key: kSigning, data: Data(stringToSign.utf8))
+        return signature.map { String(format: "%02x", $0) }.joined()
+    }
+
+    private static func hmacSHA256(key: Data, data: Data) -> Data {
+        let symmetricKey = SymmetricKey(data: key)
+        let mac = HMAC<SHA256>.authenticationCode(for: data, using: symmetricKey)
+        return Data(mac)
+    }
+
+    private static func sha256Hex(_ data: Data) -> String {
+        let digest = SHA256.hash(data: data)
+        return digest.map { String(format: "%02x", $0) }.joined()
+    }
+
+    private static func dateFormatter() -> DateFormatter {
+        let formatter = DateFormatter()
+        formatter.dateFormat = "yyyyMMdd'T'HHmmss'Z'"
+        formatter.timeZone = TimeZone(identifier: "UTC")
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        return formatter
+    }
+
+    private static func dateStamp(date: Date) -> String {
+        let formatter = DateFormatter()
+        formatter.dateFormat = "yyyyMMdd"
+        formatter.timeZone = TimeZone(identifier: "UTC")
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        return formatter.string(from: date)
+    }
+
+    private static func uriEncode(_ string: String) -> String {
+        var allowed = CharacterSet.alphanumerics
+        allowed.insert(charactersIn: "-._~")
+        return string.addingPercentEncoding(withAllowedCharacters: allowed) ?? string
+    }
+
+    private static func uriEncodePath(_ path: String) -> String {
+        path.split(separator: "/", omittingEmptySubsequences: false)
+            .map { self.uriEncode(String($0)) }
+            .joined(separator: "/")
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Bedrock/BedrockCloudWatchUsage.swift b/Sources/CodexBarCore/Providers/Bedrock/BedrockCloudWatchUsage.swift
new file mode 100644
index 0000000000..98c8bc3298
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Bedrock/BedrockCloudWatchUsage.swift
@@ -0,0 +1,231 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+struct BedrockClaudeActivity: Equatable {
+    let inputTokens: Int
+    let outputTokens: Int
+    let requestCount: Int
+}
+
+enum BedrockCloudWatchUsageFetcher {
+    static let lookbackDays = 14
+
+    private static let maxResponseBytes = 4 * 1024 * 1024
+    private static let maxPages = 20
+    private static let requestTimeoutSeconds: TimeInterval = 15
+
+    private enum Metric: String, CaseIterable {
+        case inputTokens
+        case outputTokens
+        case requests
+
+        var cloudWatchName: String {
+            switch self {
+            case .inputTokens: "InputTokenCount"
+            case .outputTokens: "OutputTokenCount"
+            case .requests: "Invocations"
+            }
+        }
+    }
+
+    private struct RequestContext {
+        let credentials: BedrockAWSSigner.Credentials
+        let region: String
+        let now: Date
+        let endpoint: URL
+        let transport: any ProviderHTTPTransport
+    }
+
+    static func fetch(
+        credentials: BedrockAWSSigner.Credentials,
+        region: String,
+        now: Date,
+        endpointOverride: String?,
+        transport: any ProviderHTTPTransport) async throws -> BedrockClaudeActivity
+    {
+        let totals = try await self.fetchTotals(
+            credentials: credentials,
+            region: region,
+            now: now,
+            endpointOverride: endpointOverride,
+            transport: transport)
+
+        return BedrockClaudeActivity(
+            inputTokens: totals[.inputTokens] ?? 0,
+            outputTokens: totals[.outputTokens] ?? 0,
+            requestCount: totals[.requests] ?? 0)
+    }
+
+    private static func fetchTotals(
+        credentials: BedrockAWSSigner.Credentials,
+        region: String,
+        now: Date,
+        endpointOverride: String?,
+        transport: any ProviderHTTPTransport) async throws -> [Metric: Int]
+    {
+        let context = try RequestContext(
+            credentials: credentials,
+            region: region,
+            now: now,
+            endpoint: self.endpoint(region: region, override: endpointOverride),
+            transport: transport)
+        var totals: [Metric: Double] = [:]
+        var nextToken: String?
+        var seenTokens: Set<String> = []
+        var pageCount = 0
+
+        repeat {
+            pageCount += 1
+            guard pageCount <= self.maxPages else {
+                throw BedrockUsageError.cloudWatchParseFailed("too many response pages")
+            }
+
+            let response = try await self.callPage(
+                context: context,
+                nextToken: nextToken)
+            for (metric, value) in response.totals {
+                totals[metric, default: 0] += value
+            }
+            nextToken = response.nextToken
+            if let nextToken, !seenTokens.insert(nextToken).inserted {
+                throw BedrockUsageError.cloudWatchParseFailed("repeated NextToken")
+            }
+        } while nextToken != nil
+
+        var converted: [Metric: Int] = [:]
+        for metric in Metric.allCases {
+            let total = totals[metric] ?? 0
+            guard total.isFinite, total >= 0, total <= Double(Int.max) else {
+                throw BedrockUsageError.cloudWatchParseFailed("invalid metric total")
+            }
+            converted[metric] = Int(total.rounded())
+        }
+        return converted
+    }
+
+    private static func callPage(
+        context: RequestContext,
+        nextToken: String?) async throws
+        -> (totals: [Metric: Double], nextToken: String?)
+    {
+        let start = context.now.addingTimeInterval(-Double(self.lookbackDays) * 24 * 60 * 60)
+        let queries: [[String: Any]] = Metric.allCases.map { metric in
+            let search = "SEARCH('{AWS/Bedrock,ModelId} "
+                + "MetricName=\"\(metric.cloudWatchName)\" claude', 'Sum', 86400)"
+            return [
+                "Id": metric.rawValue,
+                "Expression": "SUM(\(search))",
+                "ReturnData": true,
+            ]
+        }
+        var payload: [String: Any] = [
+            "StartTime": start.timeIntervalSince1970,
+            "EndTime": context.now.timeIntervalSince1970,
+            "ScanBy": "TimestampAscending",
+            "MetricDataQueries": queries,
+        ]
+        if let nextToken {
+            payload["NextToken"] = nextToken
+        }
+
+        var request = URLRequest(url: context.endpoint)
+        request.httpMethod = "POST"
+        request.httpBody = try JSONSerialization.data(withJSONObject: payload)
+        request.timeoutInterval = self.requestTimeoutSeconds
+        request.setValue("application/x-amz-json-1.0", forHTTPHeaderField: "Content-Type")
+        request.setValue(
+            "GraniteServiceVersion20100801.GetMetricData",
+            forHTTPHeaderField: "X-Amz-Target")
+        BedrockAWSSigner.sign(
+            request: &request,
+            credentials: context.credentials,
+            region: context.region,
+            service: "monitoring")
+
+        let response = try await context.transport.response(for: request)
+        guard response.statusCode == 200 else {
+            throw BedrockUsageError.cloudWatchAPIError("HTTP \(response.statusCode)")
+        }
+        guard response.data.count <= self.maxResponseBytes else {
+            throw BedrockUsageError.cloudWatchParseFailed("response exceeds 4 MiB")
+        }
+        return try self.parsePage(response.data)
+    }
+
+    private static func endpoint(region: String, override: String?) throws -> URL {
+        if override != nil {
+            guard let override = BedrockSettingsReader.cleaned(override),
+                  let url = ProviderEndpointOverrideValidator()
+                      .validatedURLAllowingLoopbackHTTP(override)
+            else {
+                throw BedrockUsageError.cloudWatchParseFailed("invalid endpoint override")
+            }
+            return url
+        }
+        guard region.range(
+            of: #"^[a-z0-9]+(?:-[a-z0-9]+)+-[0-9]+$"#,
+            options: .regularExpression) != nil
+        else {
+            throw BedrockUsageError.cloudWatchParseFailed("invalid region endpoint")
+        }
+        // Match the CloudWatch partition suffixes published by the AWS SDK endpoint resolver.
+        let suffix = switch region {
+        case let region where region.hasPrefix("cn-"):
+            "amazonaws.com.cn"
+        case let region where region.hasPrefix("eusc-"):
+            "amazonaws.eu"
+        case let region where region.hasPrefix("us-iso-"):
+            "c2s.ic.gov"
+        case let region where region.hasPrefix("us-isob-"):
+            "sc2s.sgov.gov"
+        case let region where region.hasPrefix("eu-isoe-"):
+            "cloud.adc-e.uk"
+        case let region where region.hasPrefix("us-isof-"):
+            "csp.hci.ic.gov"
+        default:
+            "amazonaws.com"
+        }
+        guard let url = URL(string: "https://monitoring.\(region).\(suffix)") else {
+            throw BedrockUsageError.cloudWatchParseFailed("invalid region endpoint")
+        }
+        return url
+    }
+
+    private static func parsePage(_ data: Data) throws
+        -> (totals: [Metric: Double], nextToken: String?)
+    {
+        guard let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+            throw BedrockUsageError.cloudWatchParseFailed("invalid JSON response")
+        }
+
+        if let messages = json["Messages"] as? [[String: Any]], !messages.isEmpty {
+            throw BedrockUsageError.cloudWatchParseFailed("CloudWatch reported incomplete results")
+        }
+
+        let results = json["MetricDataResults"] as? [[String: Any]] ?? []
+        var totals: [Metric: Double] = [:]
+        for result in results {
+            guard let id = result["Id"] as? String, let metric = Metric(rawValue: id) else {
+                throw BedrockUsageError.cloudWatchParseFailed("metric result had an unknown ID")
+            }
+            guard result["StatusCode"] as? String == "Complete" else {
+                throw BedrockUsageError.cloudWatchParseFailed("metric result was incomplete")
+            }
+            guard let values = result["Values"] as? [Any] else { continue }
+            for value in values {
+                guard let number = value as? NSNumber else {
+                    throw BedrockUsageError.cloudWatchParseFailed("metric value was not numeric")
+                }
+                let double = number.doubleValue
+                guard double.isFinite, double >= 0 else {
+                    throw BedrockUsageError.cloudWatchParseFailed("metric value was invalid")
+                }
+                totals[metric, default: 0] += double
+            }
+        }
+
+        return (totals, BedrockSettingsReader.cleaned(json["NextToken"] as? String))
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Bedrock/BedrockCredentialResolver.swift b/Sources/CodexBarCore/Providers/Bedrock/BedrockCredentialResolver.swift
new file mode 100644
index 0000000000..c5f3cac136
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Bedrock/BedrockCredentialResolver.swift
@@ -0,0 +1,78 @@
+import Foundation
+
+/// Resolves Bedrock signing credentials + region for the configured auth mode.
+///
+/// Shared by the main usage fetch (`BedrockAPIFetchStrategy`) and the daily
+/// cost-history refresh (`CostUsageFetcher`) so both honor AWS-profile auth
+/// identically instead of the history path silently requiring static keys.
+enum BedrockCredentialResolver {
+    struct Resolved {
+        let credentials: BedrockAWSSigner.Credentials
+        let region: String
+    }
+
+    static func resolve(
+        environment: [String: String],
+        resolveAWSBinary: ([String: String]) -> String? = { BinaryLocator.resolveAWSBinary(env: $0) },
+        makeProvider: (String) -> BedrockProfileCredentialProvider = {
+            BedrockProfileCredentialProvider.live(awsBinaryPath: $0)
+        }) async throws -> Resolved
+    {
+        switch BedrockSettingsReader.authMode(environment: environment) {
+        case .keys:
+            guard let accessKeyID = BedrockSettingsReader.accessKeyID(environment: environment),
+                  let secretAccessKey = BedrockSettingsReader.secretAccessKey(environment: environment)
+            else {
+                throw BedrockUsageError.missingCredentials
+            }
+            let credentials = BedrockAWSSigner.Credentials(
+                accessKeyID: accessKeyID,
+                secretAccessKey: secretAccessKey,
+                sessionToken: BedrockSettingsReader.sessionToken(environment: environment))
+            return Resolved(
+                credentials: credentials,
+                region: BedrockSettingsReader.region(environment: environment))
+
+        case .profile:
+            guard let profile = BedrockSettingsReader.profile(environment: environment) else {
+                throw BedrockUsageError.missingCredentials
+            }
+            guard let awsBinary = resolveAWSBinary(environment) else {
+                throw BedrockUsageError.awsCLINotFound
+            }
+            let cliEnvironment = Self.profileCLIEnvironment(environment)
+            let provider = makeProvider(awsBinary)
+            let credentials = try await provider.exportCredentials(profile: profile, environment: cliEnvironment)
+            let region = try await Self.resolveRegion(
+                provider: provider,
+                profile: profile,
+                environment: cliEnvironment)
+            return Resolved(credentials: credentials, region: region)
+        }
+    }
+
+    private static func profileCLIEnvironment(_ environment: [String: String]) -> [String: String] {
+        var cliEnvironment = environment
+        // `--profile` selects the requested profile. Leaving AWS_PROFILE set can
+        // break assume-role profiles that use `credential_source = Environment`;
+        // keep the source credential variables themselves available.
+        cliEnvironment[BedrockSettingsReader.profileKey] = nil
+        return cliEnvironment
+    }
+
+    private static func resolveRegion(
+        provider: BedrockProfileCredentialProvider,
+        profile: String,
+        environment: [String: String]) async throws -> String
+    {
+        if let explicit = BedrockSettingsReader.cleaned(environment[BedrockSettingsReader.regionKeys[0]])
+            ?? BedrockSettingsReader.cleaned(environment[BedrockSettingsReader.regionKeys[1]])
+        {
+            return explicit
+        }
+        if let derived = try await provider.resolveRegion(profile: profile, environment: environment) {
+            return derived
+        }
+        return BedrockSettingsReader.defaultRegion
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Bedrock/BedrockProfileCredentialProvider.swift b/Sources/CodexBarCore/Providers/Bedrock/BedrockProfileCredentialProvider.swift
new file mode 100644
index 0000000000..1f692f9a98
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Bedrock/BedrockProfileCredentialProvider.swift
@@ -0,0 +1,87 @@
+import Foundation
+
+/// Resolves AWS credentials for a named profile by shelling out to the AWS CLI.
+///
+/// Uses `aws configure export-credentials`, which transparently resolves static
+/// credentials, SSO sessions, assume-role chains, and `credential_process` profiles.
+/// The runner is injected so tests never invoke a real `aws` binary.
+struct BedrockProfileCredentialProvider {
+    typealias Runner = @Sendable (
+        _ arguments: [String],
+        _ environment: [String: String]) async throws -> SubprocessResult
+
+    let awsBinaryPath: String
+    let run: Runner
+
+    /// Production provider that drives the real `aws` binary via `SubprocessRunner`.
+    static func live(awsBinaryPath: String) -> BedrockProfileCredentialProvider {
+        BedrockProfileCredentialProvider(awsBinaryPath: awsBinaryPath) { arguments, environment in
+            try await SubprocessRunner.run(
+                binary: awsBinaryPath,
+                arguments: arguments,
+                environment: environment,
+                timeout: 20,
+                label: "aws-bedrock-credentials")
+        }
+    }
+
+    func exportCredentials(
+        profile: String,
+        environment: [String: String] = [:]) async throws -> BedrockAWSSigner.Credentials
+    {
+        let result: SubprocessResult
+        do {
+            result = try await self.run(
+                ["configure", "export-credentials", "--profile", profile, "--format", "process"],
+                environment)
+        } catch let SubprocessRunnerError.nonZeroExit(_, stderr) {
+            throw Self.mapExportError(stderr: stderr, profile: profile)
+        }
+
+        guard let data = result.stdout.data(using: .utf8),
+              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+              let accessKeyID = Self.nonEmpty(json["AccessKeyId"] as? String),
+              let secretAccessKey = Self.nonEmpty(json["SecretAccessKey"] as? String)
+        else {
+            throw BedrockUsageError.parseFailed("Could not parse AWS CLI export-credentials output")
+        }
+
+        return BedrockAWSSigner.Credentials(
+            accessKeyID: accessKeyID,
+            secretAccessKey: secretAccessKey,
+            sessionToken: Self.nonEmpty(json["SessionToken"] as? String))
+    }
+
+    /// Returns the profile's configured region, or `nil` when unset.
+    /// `aws configure get region` exits non-zero when the value is not configured,
+    /// which is a normal case rather than an error.
+    func resolveRegion(
+        profile: String,
+        environment: [String: String] = [:]) async throws -> String?
+    {
+        do {
+            let result = try await self.run(
+                ["configure", "get", "region", "--profile", profile],
+                environment)
+            return Self.nonEmpty(result.stdout)
+        } catch SubprocessRunnerError.nonZeroExit {
+            return nil
+        }
+    }
+
+    static func mapExportError(stderr: String, profile: String) -> BedrockUsageError {
+        let lower = stderr.lowercased()
+        if lower.contains("sso login") || lower.contains("expired") || lower.contains("token has expired") {
+            return .profileSessionExpired(profile)
+        }
+        let trimmed = stderr.trimmingCharacters(in: .whitespacesAndNewlines)
+        return .apiError(trimmed.isEmpty ? "AWS CLI failed to export credentials" : trimmed)
+    }
+
+    private static func nonEmpty(_ raw: String?) -> String? {
+        guard let value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
+            return nil
+        }
+        return value
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Bedrock/BedrockProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Bedrock/BedrockProviderDescriptor.swift
new file mode 100644
index 0000000000..d0e3310edb
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Bedrock/BedrockProviderDescriptor.swift
@@ -0,0 +1,74 @@
+import Foundation
+
+public enum BedrockProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .bedrock,
+            metadata: ProviderMetadata(
+                id: .bedrock,
+                displayName: "AWS Bedrock",
+                sessionLabel: "Budget",
+                weeklyLabel: "Cost",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "",
+                toggleTitle: "Show AWS Bedrock usage",
+                cliName: "bedrock",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                dashboardURL: "https://console.aws.amazon.com/bedrock",
+                statusPageURL: nil,
+                statusLinkURL: "https://health.aws.amazon.com/health/status"),
+            branding: ProviderBranding(
+                iconStyle: .bedrock,
+                iconResourceName: "ProviderIcon-bedrock",
+                color: ProviderColor(red: 1, green: 0.6, blue: 0)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: true,
+                noDataMessage: { "No AWS Bedrock cost data available. Check your AWS access keys "
+                    + "or profile, and that the AWS CLI is installed for profile auth."
+                }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .api],
+                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [BedrockAPIFetchStrategy()] })),
+            cli: ProviderCLIConfig(
+                name: "bedrock",
+                aliases: ["aws-bedrock"],
+                versionDetector: nil))
+    }
+}
+
+struct BedrockAPIFetchStrategy: ProviderFetchStrategy {
+    let id: String = "bedrock.api"
+    let kind: ProviderFetchKind = .apiToken
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        switch BedrockSettingsReader.authMode(environment: context.env) {
+        case .keys:
+            BedrockSettingsReader.hasCredentials(environment: context.env)
+        case .profile:
+            BedrockSettingsReader.profile(environment: context.env) != nil
+        }
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        let resolved = try await BedrockCredentialResolver.resolve(environment: context.env)
+        let budget = BedrockSettingsReader.budget(environment: context.env)
+        let usage = try await BedrockUsageFetcher.fetchUsage(
+            credentials: resolved.credentials,
+            region: resolved.region,
+            budget: budget,
+            environment: context.env)
+        return self.makeResult(
+            usage: usage.toUsageSnapshot(),
+            sourceLabel: "api")
+    }
+
+    func shouldFallback(on _: any Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Bedrock/BedrockSettingsReader.swift b/Sources/CodexBarCore/Providers/Bedrock/BedrockSettingsReader.swift
new file mode 100644
index 0000000000..406a8b5544
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Bedrock/BedrockSettingsReader.swift
@@ -0,0 +1,107 @@
+import Foundation
+
+public enum BedrockAuthMode: String, Codable, Sendable, CaseIterable {
+    case keys
+    case profile
+}
+
+public enum BedrockSettingsReader {
+    public static let accessKeyIDKey = "AWS_ACCESS_KEY_ID"
+    public static let secretAccessKeyKey = "AWS_SECRET_ACCESS_KEY"
+    public static let sessionTokenKey = "AWS_SESSION_TOKEN"
+    public static let regionKeys = ["AWS_REGION", "AWS_DEFAULT_REGION"]
+    public static let budgetKey = "CODEXBAR_BEDROCK_BUDGET"
+    public static let apiURLKey = "CODEXBAR_BEDROCK_API_URL"
+    public static let cloudWatchAPIURLKey = "CODEXBAR_BEDROCK_CLOUDWATCH_API_URL"
+    public static let profileKey = "AWS_PROFILE"
+    public static let authModeKey = "CODEXBAR_BEDROCK_AUTH_MODE"
+    public static let defaultRegion = "us-east-1"
+
+    public static func accessKeyID(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        self.cleaned(environment[self.accessKeyIDKey])
+    }
+
+    public static func secretAccessKey(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.cleaned(environment[self.secretAccessKeyKey])
+    }
+
+    public static func sessionToken(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.cleaned(environment[self.sessionTokenKey])
+    }
+
+    public static func region(environment: [String: String] = ProcessInfo.processInfo.environment) -> String {
+        for key in self.regionKeys {
+            if let value = self.cleaned(environment[key]) {
+                return value
+            }
+        }
+        return self.defaultRegion
+    }
+
+    public static func budget(environment: [String: String] = ProcessInfo.processInfo.environment) -> Double? {
+        guard let raw = self.cleaned(environment[self.budgetKey]),
+              let value = Double(raw),
+              value > 0
+        else {
+            return nil
+        }
+        return value
+    }
+
+    public static func profile(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.cleaned(environment[self.profileKey])
+    }
+
+    public static func authMode(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> BedrockAuthMode
+    {
+        if let raw = self.cleaned(environment[self.authModeKey])?.lowercased(),
+           let mode = BedrockAuthMode(rawValue: raw)
+        {
+            return mode
+        }
+        if self.profile(environment: environment) != nil,
+           !self.hasStaticKeys(environment: environment)
+        {
+            return .profile
+        }
+        return .keys
+    }
+
+    static func hasStaticKeys(environment: [String: String]) -> Bool {
+        self.accessKeyID(environment: environment) != nil &&
+            self.secretAccessKey(environment: environment) != nil
+    }
+
+    public static func hasCredentials(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> Bool
+    {
+        switch self.authMode(environment: environment) {
+        case .keys:
+            self.hasStaticKeys(environment: environment)
+        case .profile:
+            self.profile(environment: environment) != nil
+        }
+    }
+
+    static func cleaned(_ raw: String?) -> String? {
+        guard var value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
+            return nil
+        }
+
+        if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
+            (value.hasPrefix("'") && value.hasSuffix("'"))
+        {
+            value = String(value.dropFirst().dropLast())
+        }
+
+        value = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        return value.isEmpty ? nil : value
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Bedrock/BedrockUsageStats.swift b/Sources/CodexBarCore/Providers/Bedrock/BedrockUsageStats.swift
new file mode 100644
index 0000000000..58521691c1
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Bedrock/BedrockUsageStats.swift
@@ -0,0 +1,503 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public struct BedrockUsageSnapshot: Codable, Sendable {
+    public let monthlySpend: Double
+    public let monthlyBudget: Double?
+    public let inputTokens: Int?
+    public let outputTokens: Int?
+    public let requestCount: Int?
+    public let region: String
+    public let updatedAt: Date
+
+    public init(
+        monthlySpend: Double,
+        monthlyBudget: Double?,
+        inputTokens: Int? = nil,
+        outputTokens: Int? = nil,
+        requestCount: Int? = nil,
+        region: String,
+        updatedAt: Date)
+    {
+        self.monthlySpend = monthlySpend
+        self.monthlyBudget = monthlyBudget
+        self.inputTokens = inputTokens
+        self.outputTokens = outputTokens
+        self.requestCount = requestCount
+        self.region = region
+        self.updatedAt = updatedAt
+    }
+
+    public var budgetUsedPercent: Double? {
+        guard let budget = self.monthlyBudget, budget > 0 else { return nil }
+        return min(100, max(0, (self.monthlySpend / budget) * 100))
+    }
+
+    public var totalTokens: Int? {
+        guard let input = self.inputTokens, let output = self.outputTokens else { return nil }
+        return input + output
+    }
+}
+
+extension BedrockUsageSnapshot {
+    public func toUsageSnapshot() -> UsageSnapshot {
+        let primary: RateWindow? = if let usedPercent = self.budgetUsedPercent {
+            RateWindow(
+                usedPercent: usedPercent,
+                windowMinutes: nil,
+                resetsAt: Self.endOfCurrentMonth(),
+                resetDescription: "Monthly budget")
+        } else {
+            nil
+        }
+
+        let cost = ProviderCostSnapshot(
+            used: self.monthlySpend,
+            limit: self.monthlyBudget ?? 0,
+            currencyCode: "USD",
+            period: "Monthly",
+            resetsAt: Self.endOfCurrentMonth(),
+            updatedAt: self.updatedAt)
+
+        var loginParts: [String] = []
+        loginParts.append(String(format: "Spend: $%.2f", self.monthlySpend))
+        if let budget = self.monthlyBudget {
+            loginParts.append(String(format: "Budget: $%.2f", budget))
+        }
+        if let total = self.totalTokens {
+            loginParts.append("Claude 14d: \(Self.formattedTokenCount(total)) tokens")
+        }
+        if let requestCount = self.requestCount {
+            loginParts.append("Requests: \(Self.formattedTokenCount(requestCount))")
+        }
+
+        let identity = ProviderIdentitySnapshot(
+            providerID: .bedrock,
+            accountEmail: nil,
+            accountOrganization: nil,
+            loginMethod: loginParts.joined(separator: " - "))
+
+        return UsageSnapshot(
+            primary: primary,
+            secondary: nil,
+            tertiary: nil,
+            providerCost: cost,
+            updatedAt: self.updatedAt,
+            identity: identity)
+    }
+
+    private static func endOfCurrentMonth() -> Date? {
+        let calendar = Calendar.current
+        guard let range = calendar.range(of: .day, in: .month, for: Date()) else { return nil }
+        let components = calendar.dateComponents([.year, .month], from: Date())
+        guard let startOfMonth = calendar.date(from: components) else { return nil }
+        return calendar.date(byAdding: .day, value: range.count, to: startOfMonth)
+    }
+
+    static func formattedTokenCount(_ count: Int) -> String {
+        if count >= 1_000_000 {
+            return String(format: "%.1fM", Double(count) / 1_000_000)
+        } else if count >= 1000 {
+            return String(format: "%.1fK", Double(count) / 1000)
+        }
+        return "\(count)"
+    }
+}
+
+enum BedrockUsageFetcher {
+    private static let log = CodexBarLog.logger(LogCategories.bedrockUsage)
+    private static let requestTimeoutSeconds: TimeInterval = 15
+
+    private struct CostExplorerQuery {
+        let startDate: String
+        let endDate: String
+        let granularity: String
+        let nextPageToken: String?
+    }
+
+    static func fetchUsage(
+        credentials: BedrockAWSSigner.Credentials,
+        region: String,
+        budget: Double?,
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        now: Date = Date(),
+        cloudWatchTransport: any ProviderHTTPTransport = ProviderHTTPClient.shared) async throws
+        -> BedrockUsageSnapshot
+    {
+        let spend = try await Self.fetchMonthlyCost(
+            credentials: credentials,
+            environment: environment)
+
+        var activity: BedrockClaudeActivity?
+        let cloudWatchOverride = environment[BedrockSettingsReader.cloudWatchAPIURLKey]
+        let shouldFetchCloudWatch = environment[BedrockSettingsReader.apiURLKey] == nil || cloudWatchOverride != nil
+        if shouldFetchCloudWatch {
+            do {
+                activity = try await BedrockCloudWatchUsageFetcher.fetch(
+                    credentials: credentials,
+                    region: region,
+                    now: now,
+                    endpointOverride: cloudWatchOverride,
+                    transport: cloudWatchTransport)
+            } catch {
+                if Task.isCancelled { throw error }
+                Self.log.debug("AWS CloudWatch Claude activity unavailable; keeping Cost Explorer usage.")
+            }
+        }
+
+        return BedrockUsageSnapshot(
+            monthlySpend: spend,
+            monthlyBudget: budget,
+            inputTokens: activity?.inputTokens,
+            outputTokens: activity?.outputTokens,
+            requestCount: activity?.requestCount,
+            region: region,
+            updatedAt: now)
+    }
+
+    static func fetchDailyReport(
+        credentials: BedrockAWSSigner.Credentials,
+        since: Date,
+        until: Date,
+        environment: [String: String] = ProcessInfo.processInfo.environment) async throws
+        -> CostUsageDailyReport
+    {
+        let formatter = Self.dateFormatter()
+        let startDate = formatter.string(from: since)
+        let inclusiveEnd = Self.utcCalendar().date(byAdding: .day, value: 1, to: until) ?? until
+        let endDate = formatter.string(from: inclusiveEnd)
+
+        let pages = try await Self.callCostExplorerPages(
+            startDate: startDate,
+            endDate: endDate,
+            granularity: "DAILY",
+            credentials: credentials,
+            environment: environment)
+
+        let entries = try Self.parseDailyResponses(pages)
+        return CostUsageDailyReport(data: entries, summary: nil)
+    }
+
+    private static func fetchMonthlyCost(
+        credentials: BedrockAWSSigner.Credentials,
+        environment: [String: String]) async throws -> Double
+    {
+        let (startDate, endDate) = Self.currentMonthRange()
+
+        let pages = try await Self.callCostExplorerPages(
+            startDate: startDate,
+            endDate: endDate,
+            granularity: "MONTHLY",
+            credentials: credentials,
+            environment: environment)
+
+        return try Self.parseTotalCost(pages)
+    }
+
+    private static func callCostExplorerPages(
+        startDate: String,
+        endDate: String,
+        granularity: String,
+        credentials: BedrockAWSSigner.Credentials,
+        environment: [String: String]) async throws -> [Data]
+    {
+        var pages: [Data] = []
+        var nextPageToken: String?
+        var seenPageTokens: Set<String> = []
+
+        repeat {
+            let page = try await Self.callCostExplorerPage(
+                query: CostExplorerQuery(
+                    startDate: startDate,
+                    endDate: endDate,
+                    granularity: granularity,
+                    nextPageToken: nextPageToken),
+                credentials: credentials,
+                environment: environment)
+            pages.append(page)
+            nextPageToken = try Self.nextPageToken(from: page)
+            if let nextPageToken, !seenPageTokens.insert(nextPageToken).inserted {
+                throw BedrockUsageError.parseFailed("Cost Explorer returned repeated NextPageToken")
+            }
+        } while nextPageToken != nil
+
+        return pages
+    }
+
+    private static func callCostExplorerPage(
+        query: CostExplorerQuery,
+        credentials: BedrockAWSSigner.Credentials,
+        environment: [String: String]) async throws -> Data
+    {
+        let ceRegion = "us-east-1"
+        let baseURL: URL = if environment[BedrockSettingsReader.apiURLKey] != nil {
+            if let override = BedrockSettingsReader.cleaned(environment[BedrockSettingsReader.apiURLKey]),
+               let url = ProviderEndpointOverrideValidator().validatedURLAllowingLoopbackHTTP(override)
+            {
+                url
+            } else {
+                throw BedrockUsageError.parseFailed("invalid endpoint override")
+            }
+        } else {
+            URL(string: "https://ce.\(ceRegion).amazonaws.com")!
+        }
+
+        var requestBody: [String: Any] = [
+            "TimePeriod": [
+                "Start": query.startDate,
+                "End": query.endDate,
+            ],
+            "Granularity": query.granularity,
+            "Metrics": ["UnblendedCost"],
+            "GroupBy": [
+                ["Type": "DIMENSION", "Key": "SERVICE"],
+            ],
+        ]
+        if let nextPageToken = query.nextPageToken {
+            requestBody["NextPageToken"] = nextPageToken
+        }
+
+        let bodyData = try JSONSerialization.data(withJSONObject: requestBody)
+
+        var request = URLRequest(url: baseURL)
+        request.httpMethod = "POST"
+        request.httpBody = bodyData
+        request.setValue("application/x-amz-json-1.1", forHTTPHeaderField: "Content-Type")
+        request.setValue(
+            "AWSInsightsIndexService.GetCostAndUsage",
+            forHTTPHeaderField: "X-Amz-Target")
+        request.timeoutInterval = Self.requestTimeoutSeconds
+
+        BedrockAWSSigner.sign(
+            request: &request,
+            credentials: credentials,
+            region: ceRegion,
+            service: "ce")
+
+        let response = try await ProviderHTTPClient.shared.response(for: request)
+        guard response.statusCode == 200 else {
+            if Self.isDataUnavailableResponse(statusCode: response.statusCode, data: response.data) {
+                Self.log.info("AWS Cost Explorer data unavailable, assuming zero usage.")
+                return Data(#"{"ResultsByTime":[]}"#.utf8)
+            }
+            let summary = Self.sanitizedResponseBody(response.data)
+            Self.log.error("AWS Cost Explorer returned \(response.statusCode): \(summary)")
+            throw BedrockUsageError.apiError("HTTP \(response.statusCode)")
+        }
+
+        return response.data
+    }
+
+    private static func nextPageToken(from data: Data) throws -> String? {
+        guard let json = try JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+            throw BedrockUsageError.parseFailed("Invalid Cost Explorer response")
+        }
+        return BedrockSettingsReader.cleaned(json["NextPageToken"] as? String)
+    }
+
+    private static func parseTotalCost(_ pages: [Data]) throws -> Double {
+        var total = 0.0
+        for page in pages {
+            total += try Self.parseTotalCost(page)
+        }
+        return total
+    }
+
+    private static func parseTotalCost(_ data: Data) throws -> Double {
+        var total = 0.0
+        for (_, cost, _) in try Self.parseGroupedResults(data) {
+            total += cost
+        }
+        return total
+    }
+
+    private static func parseDailyResponses(_ pages: [Data]) throws -> [CostUsageDailyReport.Entry] {
+        let reports = try pages.map { page in
+            try CostUsageDailyReport(data: Self.parseDailyResponse(page), summary: nil)
+        }
+        return CostUsageDailyReport.merged(reports).data
+    }
+
+    private static func parseDailyResponse(_ data: Data) throws -> [CostUsageDailyReport.Entry] {
+        guard let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+              let results = json["ResultsByTime"] as? [[String: Any]]
+        else {
+            throw BedrockUsageError.parseFailed("Missing ResultsByTime in Cost Explorer response")
+        }
+
+        var entries: [CostUsageDailyReport.Entry] = []
+        for result in results {
+            guard let timePeriod = result["TimePeriod"] as? [String: String],
+                  let dateStr = timePeriod["Start"]
+            else { continue }
+
+            var dayCost = 0.0
+            var breakdowns: [CostUsageDailyReport.ModelBreakdown] = []
+
+            if let groups = result["Groups"] as? [[String: Any]] {
+                for group in groups {
+                    guard let keys = group["Keys"] as? [String],
+                          let serviceName = keys.first,
+                          serviceName.localizedCaseInsensitiveContains("Bedrock")
+                    else { continue }
+
+                    if let metrics = group["Metrics"] as? [String: Any],
+                       let unblended = metrics["UnblendedCost"] as? [String: Any],
+                       let amountStr = unblended["Amount"] as? String,
+                       let amount = Double(amountStr),
+                       amount > 0
+                    {
+                        dayCost += amount
+                        breakdowns.append(CostUsageDailyReport.ModelBreakdown(
+                            modelName: serviceName,
+                            costUSD: amount))
+                    }
+                }
+            }
+
+            guard dayCost > 0 else { continue }
+
+            entries.append(CostUsageDailyReport.Entry(
+                date: dateStr,
+                inputTokens: nil,
+                outputTokens: nil,
+                totalTokens: nil,
+                costUSD: dayCost,
+                modelsUsed: breakdowns.map(\.modelName),
+                modelBreakdowns: breakdowns.isEmpty ? nil : breakdowns))
+        }
+
+        return entries
+    }
+
+    private static func parseGroupedResults(_ data: Data) throws
+        -> [(service: String, cost: Double, date: String)]
+    {
+        guard let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+              let results = json["ResultsByTime"] as? [[String: Any]]
+        else {
+            throw BedrockUsageError.parseFailed("Missing ResultsByTime in Cost Explorer response")
+        }
+
+        var items: [(service: String, cost: Double, date: String)] = []
+        for result in results {
+            let dateStr = (result["TimePeriod"] as? [String: String])?["Start"] ?? ""
+            guard let groups = result["Groups"] as? [[String: Any]] else { continue }
+            for group in groups {
+                guard let keys = group["Keys"] as? [String],
+                      let serviceName = keys.first,
+                      serviceName.localizedCaseInsensitiveContains("Bedrock")
+                else { continue }
+
+                if let metrics = group["Metrics"] as? [String: Any],
+                   let unblended = metrics["UnblendedCost"] as? [String: Any],
+                   let amountStr = unblended["Amount"] as? String,
+                   let amount = Double(amountStr)
+                {
+                    items.append((serviceName, amount, dateStr))
+                }
+            }
+        }
+        return items
+    }
+
+    private static func dateFormatter() -> DateFormatter {
+        let formatter = DateFormatter()
+        formatter.dateFormat = "yyyy-MM-dd"
+        formatter.timeZone = TimeZone(identifier: "UTC")
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        return formatter
+    }
+
+    private static func utcCalendar() -> Calendar {
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = TimeZone(secondsFromGMT: 0)!
+        return calendar
+    }
+
+    static func currentMonthRange(now: Date = Date()) -> (start: String, end: String) {
+        let calendar = Self.utcCalendar()
+        let components = calendar.dateComponents([.year, .month], from: now)
+        let startOfMonth = calendar.date(from: components)!
+
+        let formatter = Self.dateFormatter()
+        let startOfToday = calendar.startOfDay(for: now)
+        let tomorrow = calendar.date(byAdding: .day, value: 1, to: startOfToday)!
+        return (formatter.string(from: startOfMonth), formatter.string(from: tomorrow))
+    }
+
+    private static func isDataUnavailableResponse(statusCode: Int, data: Data) -> Bool {
+        guard statusCode == 400,
+              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+        else {
+            return false
+        }
+
+        let nestedError = json["Error"] as? [String: Any]
+        let candidates = [
+            json["__type"],
+            json["code"],
+            json["Code"],
+            nestedError?["Code"],
+        ]
+        return candidates.compactMap { $0 as? String }.contains { rawCode in
+            rawCode.split(separator: "#").last == "DataUnavailableException"
+        }
+    }
+
+    private static func sanitizedResponseBody(_ data: Data) -> String {
+        guard !data.isEmpty,
+              let body = String(bytes: data, encoding: .utf8)
+        else {
+            return "empty body"
+        }
+
+        let trimmed = body.replacingOccurrences(
+            of: #"\s+"#,
+            with: " ",
+            options: .regularExpression)
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+
+        if trimmed.count > 240 {
+            let index = trimmed.index(trimmed.startIndex, offsetBy: 240)
+            return "\(trimmed[..<index])... [truncated]"
+        }
+
+        return trimmed
+    }
+}
+
+public enum BedrockUsageError: LocalizedError, Sendable, Equatable {
+    case missingCredentials
+    case awsCLINotFound
+    case profileSessionExpired(String)
+    case networkError(String)
+    case apiError(String)
+    case parseFailed(String)
+    case cloudWatchAPIError(String)
+    case cloudWatchParseFailed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingCredentials:
+            "AWS credentials not configured. Set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY " +
+                "or configure Bedrock in Settings."
+        case .awsCLINotFound:
+            "AWS CLI not found. Install the AWS CLI (v2) or set AWS_CLI_PATH to its location."
+        case let .profileSessionExpired(profile):
+            "AWS profile session expired. Run `aws sso login --profile \(profile)` and try again."
+        case let .networkError(message):
+            "AWS Bedrock network error: \(message)"
+        case let .apiError(message):
+            "AWS Cost Explorer API error: \(message)"
+        case let .parseFailed(message):
+            "Failed to parse AWS Cost Explorer response: \(message)"
+        case let .cloudWatchAPIError(message):
+            "AWS CloudWatch API error: \(message)"
+        case let .cloudWatchParseFailed(message):
+            "Failed to parse AWS CloudWatch response: \(message)"
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/CLIProbeSessionResetter.swift b/Sources/CodexBarCore/Providers/CLIProbeSessionResetter.swift
index fd33006539..a6d1df5786 100644
--- a/Sources/CodexBarCore/Providers/CLIProbeSessionResetter.swift
+++ b/Sources/CodexBarCore/Providers/CLIProbeSessionResetter.swift
@@ -4,5 +4,6 @@ public enum CLIProbeSessionResetter {
     public static func resetAll() async {
         await ClaudeCLISession.shared.reset()
         await CodexCLISession.shared.reset()
+        await AntigravityCLISession.shared.reset()
     }
 }
diff --git a/Sources/CodexBarCore/Providers/Chutes/ChutesProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Chutes/ChutesProviderDescriptor.swift
new file mode 100644
index 0000000000..55ff94d0d6
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Chutes/ChutesProviderDescriptor.swift
@@ -0,0 +1,68 @@
+import Foundation
+
+public enum ChutesProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .chutes,
+            metadata: ProviderMetadata(
+                id: .chutes,
+                displayName: "Chutes",
+                sessionLabel: "4-hour quota",
+                weeklyLabel: "Monthly quota",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "Subscription usage from the Chutes API.",
+                toggleTitle: "Show Chutes usage",
+                cliName: "chutes",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                browserCookieOrder: nil,
+                dashboardURL: "https://chutes.ai",
+                statusPageURL: nil),
+            branding: ProviderBranding(
+                iconStyle: .chutes,
+                iconResourceName: "ProviderIcon-chutes",
+                color: ProviderColor(red: 49 / 255, green: 132 / 255, blue: 255 / 255)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "Chutes cost history is not available from CodexBar." }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .api],
+                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [ChutesAPIFetchStrategy()] })),
+            cli: ProviderCLIConfig(
+                name: "chutes",
+                aliases: ["chutes.ai"],
+                versionDetector: nil))
+    }
+}
+
+struct ChutesAPIFetchStrategy: ProviderFetchStrategy {
+    let id: String = "chutes.api"
+    let kind: ProviderFetchKind = .apiToken
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        ChutesSettingsReader.apiKey(environment: context.env) != nil
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        guard let apiKey = ChutesSettingsReader.apiKey(environment: context.env) else {
+            throw ChutesSettingsError.missingToken
+        }
+
+        let usage = try await ChutesUsageFetcher.fetchUsage(
+            apiKey: apiKey,
+            environment: context.env)
+
+        return self.makeResult(
+            usage: usage.toUsageSnapshot(),
+            sourceLabel: "api")
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Chutes/ChutesSettingsReader.swift b/Sources/CodexBarCore/Providers/Chutes/ChutesSettingsReader.swift
new file mode 100644
index 0000000000..f1bb5aff8d
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Chutes/ChutesSettingsReader.swift
@@ -0,0 +1,63 @@
+import Foundation
+
+public struct ChutesSettingsReader: Sendable {
+    public static let apiKeyEnvironmentKey = "CHUTES_API_KEY"
+    public static let apiURLEnvironmentKey = "CHUTES_API_URL"
+
+    public static func apiKey(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.cleaned(environment[self.apiKeyEnvironmentKey])
+    }
+
+    public static func apiURL(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> URL
+    {
+        if let override = self.validAPIURL(environment: environment) {
+            return override
+        }
+        return URL(string: "https://api.chutes.ai")!
+    }
+
+    public static func validateEndpointOverrides(
+        environment: [String: String] = ProcessInfo.processInfo.environment) throws
+    {
+        guard let raw = self.cleaned(environment[self.apiURLEnvironmentKey]) else { return }
+        guard ProviderEndpointOverrideValidator.normalizedHTTPSURL(from: raw) == nil else { return }
+        throw ChutesSettingsError.invalidEndpointOverride(self.apiURLEnvironmentKey)
+    }
+
+    static func cleaned(_ raw: String?) -> String? {
+        guard var value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
+            return nil
+        }
+
+        if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
+            (value.hasPrefix("'") && value.hasSuffix("'"))
+        {
+            value = String(value.dropFirst().dropLast())
+        }
+
+        value = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        return value.isEmpty ? nil : value
+    }
+
+    private static func validAPIURL(environment: [String: String]) -> URL? {
+        guard let raw = self.cleaned(environment[self.apiURLEnvironmentKey]) else { return nil }
+        return ProviderEndpointOverrideValidator.normalizedHTTPSURL(from: raw)
+    }
+}
+
+public enum ChutesSettingsError: LocalizedError, Sendable, Equatable {
+    case missingToken
+    case invalidEndpointOverride(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingToken:
+            "Chutes API key not found. Set apiKey in ~/.codexbar/config.json or CHUTES_API_KEY."
+        case let .invalidEndpointOverride(key):
+            "Chutes endpoint override \(key) must use HTTPS or a bare host."
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Chutes/ChutesUsageStats.swift b/Sources/CodexBarCore/Providers/Chutes/ChutesUsageStats.swift
new file mode 100644
index 0000000000..3dd9a88575
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Chutes/ChutesUsageStats.swift
@@ -0,0 +1,1045 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public enum ChutesUsageError: LocalizedError, Sendable {
+    case missingCredentials
+    case invalidCredentials
+    case invalidURL
+    case apiError(String)
+    case parseFailed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingCredentials:
+            "Missing Chutes API key. Set apiKey in ~/.codexbar/config.json or CHUTES_API_KEY."
+        case .invalidCredentials:
+            "Chutes API key was rejected. Check the API key in Settings."
+        case .invalidURL:
+            "Chutes usage URL is invalid."
+        case let .apiError(message):
+            "Chutes usage API error: \(message)"
+        case let .parseFailed(message):
+            "Chutes usage parse error: \(message)"
+        }
+    }
+}
+
+public enum ChutesSubscriptionState: String, Sendable, Codable {
+    case active
+    case inactive
+    case unknown
+}
+
+public struct ChutesQuotaWindow: Sendable, Equatable {
+    public let label: String?
+    public let used: Double?
+    public let limit: Double?
+    public let remaining: Double?
+    public let usedPercent: Double?
+    public let windowMinutes: Int?
+    public let resetsAt: Date?
+    public let unit: String?
+
+    public init(
+        label: String?,
+        used: Double?,
+        limit: Double?,
+        remaining: Double?,
+        usedPercent: Double?,
+        windowMinutes: Int?,
+        resetsAt: Date?,
+        unit: String? = nil)
+    {
+        self.label = label
+        self.used = used
+        self.limit = limit
+        self.remaining = remaining
+        self.usedPercent = usedPercent
+        self.windowMinutes = windowMinutes
+        self.resetsAt = resetsAt
+        self.unit = unit
+    }
+
+    public func rateWindow(defaultWindowMinutes: Int?) -> RateWindow? {
+        guard let percent = self.usagePercent else { return nil }
+        return RateWindow(
+            usedPercent: max(0, min(percent, 100)),
+            windowMinutes: self.windowMinutes ?? defaultWindowMinutes,
+            resetsAt: self.resetsAt,
+            resetDescription: self.usageDescription)
+    }
+
+    public var usagePercent: Double? {
+        if let usedPercent { return max(0, min(usedPercent, 100)) }
+
+        var used = self.used
+        var limit = self.limit
+        var remaining = self.remaining
+
+        if limit == nil, let used, let remaining {
+            limit = used + remaining
+        }
+        if used == nil, let limit, let remaining {
+            used = limit - remaining
+        }
+        if remaining == nil, let limit, let used {
+            remaining = max(0, limit - used)
+        }
+
+        guard let used, let limit, limit > 0 else { return nil }
+        return (used / limit) * 100
+    }
+
+    private var usageDescription: String? {
+        guard let limit, limit > 0 else { return nil }
+
+        let used: Double
+        if let explicitUsed = self.used {
+            used = explicitUsed
+        } else if let remaining {
+            used = max(0, limit - remaining)
+        } else {
+            return nil
+        }
+
+        let unit = self.unit?.trimmingCharacters(in: .whitespacesAndNewlines)
+        let suffix = if let unit, !unit.isEmpty {
+            " \(unit)"
+        } else {
+            ""
+        }
+        return "\(Self.formatAmount(used))/\(Self.formatAmount(limit))\(suffix)"
+    }
+
+    private static func formatAmount(_ value: Double) -> String {
+        let rounded = value.rounded()
+        if abs(value - rounded) < 0.0001 {
+            return String(Int(rounded))
+        }
+
+        var text = String(format: "%.2f", value)
+        while text.contains("."), text.hasSuffix("0") {
+            text.removeLast()
+        }
+        if text.hasSuffix(".") {
+            text.removeLast()
+        }
+        return text
+    }
+}
+
+public struct ChutesUsageSnapshot: Sendable, Equatable {
+    public let rollingWindow: ChutesQuotaWindow?
+    public let monthlyWindow: ChutesQuotaWindow?
+    public let fallbackWindows: [ChutesQuotaWindow]
+    public let subscriptionState: ChutesSubscriptionState
+    public let planName: String?
+    public let subscriptionRenewsAt: Date?
+    public let updatedAt: Date
+
+    public init(
+        rollingWindow: ChutesQuotaWindow?,
+        monthlyWindow: ChutesQuotaWindow?,
+        fallbackWindows: [ChutesQuotaWindow] = [],
+        subscriptionState: ChutesSubscriptionState,
+        planName: String?,
+        subscriptionRenewsAt: Date?,
+        updatedAt: Date)
+    {
+        self.rollingWindow = rollingWindow
+        self.monthlyWindow = monthlyWindow
+        self.fallbackWindows = fallbackWindows
+        self.subscriptionState = subscriptionState
+        self.planName = planName
+        self.subscriptionRenewsAt = subscriptionRenewsAt
+        self.updatedAt = updatedAt
+    }
+
+    public var hasUsageData: Bool {
+        self.toUsageSnapshot().hasRateLimitWindows
+    }
+
+    public func toUsageSnapshot() -> UsageSnapshot {
+        let fallbackRateWindows = self.fallbackWindows.compactMap {
+            $0.rateWindow(defaultWindowMinutes: $0.windowMinutes)
+        }
+        let monthly = self.monthlyWindow?.rateWindow(defaultWindowMinutes: Self.monthlyWindowMinutes)
+        let rolling = self.rollingWindow?.rateWindow(defaultWindowMinutes: Self.rollingWindowMinutes)
+
+        let primary = rolling ?? (monthly == nil ? fallbackRateWindows.first : nil)
+        let secondary: RateWindow? = if let monthly {
+            monthly
+        } else if rolling != nil {
+            fallbackRateWindows.first
+        } else if primary != nil {
+            fallbackRateWindows.dropFirst().first
+        } else {
+            nil
+        }
+
+        let identity = ProviderIdentitySnapshot(
+            providerID: .chutes,
+            accountEmail: nil,
+            accountOrganization: nil,
+            loginMethod: self.loginMethod(hasWindows: primary != nil || secondary != nil))
+
+        return UsageSnapshot(
+            primary: primary,
+            secondary: secondary,
+            tertiary: nil,
+            providerCost: nil,
+            subscriptionRenewsAt: self.subscriptionRenewsAt ?? monthly?.resetsAt,
+            updatedAt: self.updatedAt,
+            identity: identity)
+    }
+
+    func preservingSubscriptionContext(from fallback: ChutesUsageSnapshot) -> ChutesUsageSnapshot {
+        ChutesUsageSnapshot(
+            rollingWindow: fallback.rollingWindow ?? self.rollingWindow,
+            monthlyWindow: fallback.monthlyWindow ?? self.monthlyWindow,
+            fallbackWindows: fallback.fallbackWindows + self.fallbackWindows,
+            subscriptionState: fallback.subscriptionState,
+            planName: fallback.planName,
+            subscriptionRenewsAt: fallback.subscriptionRenewsAt,
+            updatedAt: fallback.updatedAt)
+    }
+
+    private func loginMethod(hasWindows: Bool) -> String? {
+        if let planName = self.planName?.trimmingCharacters(in: .whitespacesAndNewlines), !planName.isEmpty {
+            return planName
+        }
+        switch self.subscriptionState {
+        case .active:
+            return nil
+        case .inactive:
+            return "No active subscription"
+        case .unknown:
+            return hasWindows ? nil : "No usage data"
+        }
+    }
+
+    static let rollingWindowMinutes = 4 * 60
+    static let monthlyWindowMinutes = 30 * 24 * 60
+}
+
+public struct ChutesUsageFetcher: Sendable {
+    private static let requestTimeoutSeconds: TimeInterval = 15
+
+    public static func fetchUsage(
+        apiKey: String,
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        transport: any ProviderHTTPTransport = ProviderHTTPClient.shared,
+        now: Date = Date()) async throws -> ChutesUsageSnapshot
+    {
+        guard let token = ChutesSettingsReader.cleaned(apiKey) else {
+            throw ChutesUsageError.missingCredentials
+        }
+        try ChutesSettingsReader.validateEndpointOverrides(environment: environment)
+
+        let baseURL = ChutesSettingsReader.apiURL(environment: environment)
+        let subscription = try await self.fetchSnapshot(
+            pathComponents: ["users", "me", "subscription_usage"],
+            apiKey: token,
+            baseURL: baseURL,
+            transport: transport,
+            now: now)
+
+        guard subscription.rollingWindow == nil || subscription.monthlyWindow == nil else {
+            return subscription
+        }
+
+        do {
+            let quotas = try await self.fetchQuotaSnapshot(
+                apiKey: token,
+                baseURL: baseURL,
+                transport: transport,
+                now: now)
+            return quotas.hasUsageData ? quotas.preservingSubscriptionContext(from: subscription) : subscription
+        } catch ChutesUsageError.invalidCredentials {
+            throw ChutesUsageError.invalidCredentials
+        } catch {
+            return subscription
+        }
+    }
+
+    private static func fetchSnapshot(
+        pathComponents: [String],
+        apiKey: String,
+        baseURL: URL,
+        transport: any ProviderHTTPTransport,
+        now: Date) async throws -> ChutesUsageSnapshot
+    {
+        let data = try await self.fetchData(
+            pathComponents: pathComponents,
+            apiKey: apiKey,
+            baseURL: baseURL,
+            transport: transport)
+        do {
+            return try ChutesUsageParser.parse(data: data, now: now)
+        } catch let error as ChutesUsageError {
+            throw error
+        } catch {
+            throw ChutesUsageError.parseFailed(error.localizedDescription)
+        }
+    }
+
+    private static func fetchQuotaSnapshot(
+        apiKey: String,
+        baseURL: URL,
+        transport: any ProviderHTTPTransport,
+        now: Date) async throws -> ChutesUsageSnapshot
+    {
+        let data = try await self.fetchData(
+            pathComponents: ["users", "me", "quotas"],
+            apiKey: apiKey,
+            baseURL: baseURL,
+            transport: transport)
+        let fallback = try ChutesUsageParser.parse(data: data, now: now)
+        let definitions = try self.quotaDefinitions(from: data)
+        guard !definitions.isEmpty else { return fallback }
+
+        var enrichedDefinitions: [[String: Any]] = []
+        for definition in definitions {
+            guard let identifier = self.quotaIdentifier(from: definition) else {
+                enrichedDefinitions.append(definition)
+                continue
+            }
+
+            do {
+                let usageData = try await self.fetchData(
+                    pathComponents: ["users", "me", "quota_usage", identifier],
+                    apiKey: apiKey,
+                    baseURL: baseURL,
+                    transport: transport)
+                guard let usage = try self.responseDictionary(from: usageData) else {
+                    enrichedDefinitions.append(definition)
+                    continue
+                }
+                enrichedDefinitions.append(definition.merging(usage) { _, usageValue in usageValue })
+            } catch ChutesUsageError.invalidCredentials {
+                throw ChutesUsageError.invalidCredentials
+            } catch {
+                enrichedDefinitions.append(definition)
+            }
+        }
+
+        let enrichedData = try JSONSerialization.data(
+            withJSONObject: ["quotas": enrichedDefinitions],
+            options: [])
+        let enriched = try ChutesUsageParser.parse(data: enrichedData, now: now)
+        return enriched.hasUsageData ? enriched : fallback
+    }
+
+    private static func fetchData(
+        pathComponents: [String],
+        apiKey: String,
+        baseURL: URL,
+        transport: any ProviderHTTPTransport) async throws -> Data
+    {
+        let url = pathComponents.reduce(baseURL) { partial, component in
+            partial.appendingPathComponent(component)
+        }
+        guard url.scheme?.lowercased() == "https" else {
+            throw ChutesUsageError.invalidURL
+        }
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        request.timeoutInterval = Self.requestTimeoutSeconds
+
+        let response = try await transport.response(for: request)
+        guard (200..<300).contains(response.statusCode) else {
+            if response.statusCode == 401 || response.statusCode == 403 {
+                throw ChutesUsageError.invalidCredentials
+            }
+            throw ChutesUsageError.apiError("HTTP \(response.statusCode): \(Self.responseSummary(response.data))")
+        }
+        return response.data
+    }
+
+    private static func quotaDefinitions(from data: Data) throws -> [[String: Any]] {
+        let object = try JSONSerialization.jsonObject(with: data, options: [])
+        if let array = object as? [Any] {
+            return array.compactMap { $0 as? [String: Any] }
+        }
+        guard let dictionary = object as? [String: Any] else { return [] }
+        if let quotas = dictionary["quotas"] as? [Any] {
+            return quotas.compactMap { $0 as? [String: Any] }
+        }
+        if let data = dictionary["data"] as? [Any] {
+            return data.compactMap { $0 as? [String: Any] }
+        }
+        if let data = dictionary["data"] as? [String: Any],
+           let quotas = data["quotas"] as? [Any]
+        {
+            return quotas.compactMap { $0 as? [String: Any] }
+        }
+        return []
+    }
+
+    private static func quotaIdentifier(from definition: [String: Any]) -> String? {
+        for key in ["chute_id", "chuteId", "id"] {
+            if let value = definition[key] as? String {
+                let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
+                if !trimmed.isEmpty { return trimmed }
+            }
+            if let value = definition[key] as? NSNumber {
+                return value.stringValue
+            }
+        }
+        return nil
+    }
+
+    private static func responseDictionary(from data: Data) throws -> [String: Any]? {
+        guard let dictionary = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any] else {
+            return nil
+        }
+        return dictionary["data"] as? [String: Any]
+            ?? dictionary["result"] as? [String: Any]
+            ?? dictionary
+    }
+
+    private static func responseSummary(_ data: Data) -> String {
+        String(bytes: data.prefix(240), encoding: .utf8)?
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            ?? ""
+    }
+}
+
+private final class ChutesISO8601FormatterBox: @unchecked Sendable {
+    let lock = NSLock()
+    let withFractional: ISO8601DateFormatter = {
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        return formatter
+    }()
+
+    let plain: ISO8601DateFormatter = {
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime]
+        return formatter
+    }()
+}
+
+private enum ChutesTimestampParser {
+    static let box = ChutesISO8601FormatterBox()
+
+    static func parse(_ value: Any?) -> Date? {
+        switch value {
+        case let date as Date:
+            date
+        case let number as NSNumber:
+            self.date(fromEpochValue: number.doubleValue)
+        case let text as String:
+            self.parseString(text)
+        default:
+            nil
+        }
+    }
+
+    private static func parseString(_ raw: String) -> Date? {
+        let text = raw.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !text.isEmpty else { return nil }
+        if let number = Double(text) {
+            return self.date(fromEpochValue: number)
+        }
+
+        self.box.lock.lock()
+        defer { self.box.lock.unlock() }
+        return self.box.withFractional.date(from: text) ?? self.box.plain.date(from: text)
+    }
+
+    private static func date(fromEpochValue value: Double) -> Date? {
+        guard value.isFinite, value > 0 else { return nil }
+        let seconds = value > 10_000_000_000 ? value / 1000 : value
+        return Date(timeIntervalSince1970: seconds)
+    }
+}
+
+enum ChutesUsageParser {
+    static func parse(data: Data, now: Date = Date()) throws -> ChutesUsageSnapshot {
+        let object = try JSONSerialization.jsonObject(with: data, options: [])
+        return self.parse(object: object, now: now)
+    }
+
+    private static func parse(object: Any, now: Date) -> ChutesUsageSnapshot {
+        let root: [String: Any] = {
+            if let dict = object as? [String: Any] { return dict }
+            if let array = object as? [Any] { return ["quotas": array] }
+            return [:]
+        }()
+        let dataRoot = self.dictionaryValue(self.value(in: root, keys: ["data", "result"])) ?? root
+        let subscription = self.subscriptionPayload(root: root, dataRoot: dataRoot)
+
+        let explicitRolling = self.firstDictionary(
+            in: root,
+            dataRoot: dataRoot,
+            keys: self.rollingPayloadKeys)
+            .flatMap {
+                self.parseQuota(
+                    $0,
+                    defaultLabel: "4-hour quota",
+                    defaultWindowMinutes: ChutesUsageSnapshot.rollingWindowMinutes)
+            }
+        let explicitMonthly = self.firstDictionary(
+            in: root,
+            dataRoot: dataRoot,
+            keys: self.monthlyPayloadKeys)
+            .flatMap {
+                self.parseQuota(
+                    $0,
+                    defaultLabel: "Monthly quota",
+                    defaultWindowMinutes: ChutesUsageSnapshot.monthlyWindowMinutes)
+            }
+
+        let quotaWindows = self.fallbackQuotaObjects(from: root, dataRoot: dataRoot).compactMap {
+            self.parseQuota($0, defaultLabel: nil, defaultWindowMinutes: nil)
+        }
+        let classifiedRolling = explicitRolling ?? quotaWindows.first { self.kind(for: $0) == .rolling }
+        let classifiedMonthly = explicitMonthly ?? quotaWindows.first { self.kind(for: $0) == .monthly }
+
+        let fallbackWindows = quotaWindows.filter { window in
+            Optional.some(window) != classifiedRolling && Optional.some(window) != classifiedMonthly
+        }
+
+        return ChutesUsageSnapshot(
+            rollingWindow: classifiedRolling,
+            monthlyWindow: classifiedMonthly,
+            fallbackWindows: fallbackWindows,
+            subscriptionState: self.subscriptionState(root: root, dataRoot: dataRoot, subscription: subscription),
+            planName: self.planName(root: root, dataRoot: dataRoot, subscription: subscription),
+            subscriptionRenewsAt: self.subscriptionRenewsAt(
+                root: root,
+                dataRoot: dataRoot,
+                subscription: subscription),
+            updatedAt: now)
+    }
+
+    private enum WindowKind {
+        case rolling
+        case monthly
+    }
+
+    private static func parseQuota(
+        _ payload: [String: Any],
+        defaultLabel: String?,
+        defaultWindowMinutes: Int?) -> ChutesQuotaWindow?
+    {
+        let label = self.firstString(in: payload, keys: self.labelKeys) ?? defaultLabel
+        let limit = self.firstDouble(in: payload, keys: self.limitKeys)
+        let used = self.firstDouble(in: payload, keys: self.usedKeys)
+        let remaining = self.firstDouble(in: payload, keys: self.remainingKeys)
+        var usedPercent = self.normalizedPercent(self.firstDouble(in: payload, keys: self.percentUsedKeys))
+        if usedPercent == nil,
+           let remainingPercent = self.normalizedPercent(self.firstDouble(in: payload, keys: percentRemainingKeys))
+        {
+            usedPercent = 100 - remainingPercent
+        }
+
+        let window = self.windowMinutes(from: payload) ?? defaultWindowMinutes
+        let resetsAt = self.firstDate(in: payload, keys: self.resetKeys)
+        let unit = self.firstString(in: payload, keys: self.unitKeys) ?? "credits"
+
+        let quota = ChutesQuotaWindow(
+            label: label,
+            used: used,
+            limit: limit,
+            remaining: remaining,
+            usedPercent: usedPercent,
+            windowMinutes: window,
+            resetsAt: resetsAt,
+            unit: unit)
+        return quota.usagePercent == nil ? nil : quota
+    }
+
+    private static func subscriptionPayload(root: [String: Any], dataRoot: [String: Any]) -> [String: Any]? {
+        self.firstDictionary(in: root, dataRoot: dataRoot, keys: [
+            "subscription",
+            "subscription_usage",
+            "subscriptionUsage",
+            "current_subscription",
+            "currentSubscription",
+            "plan",
+        ])
+    }
+
+    private static func subscriptionState(
+        root: [String: Any],
+        dataRoot: [String: Any],
+        subscription: [String: Any]?) -> ChutesSubscriptionState
+    {
+        if let active = self.firstBool(in: root, keys: activeKeys)
+            ?? self.firstBool(in: dataRoot, keys: activeKeys)
+            ?? subscription.flatMap({ self.firstBool(in: $0, keys: activeKeys) })
+        {
+            return active ? .active : .inactive
+        }
+
+        let status = self.firstString(in: root, keys: self.statusKeys)
+            ?? self.firstString(in: dataRoot, keys: self.statusKeys)
+            ?? subscription.flatMap { self.firstString(in: $0, keys: self.statusKeys) }
+        let normalizedStatus = status?.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+        guard let normalizedStatus, !normalizedStatus.isEmpty else { return .unknown }
+        if normalizedStatus.contains("active") && !normalizedStatus.contains("inactive") {
+            return .active
+        }
+        if normalizedStatus.contains("free") ||
+            normalizedStatus.contains("inactive") ||
+            normalizedStatus.contains("cancel") ||
+            normalizedStatus.contains("none") ||
+            normalizedStatus.contains("expired")
+        {
+            return .inactive
+        }
+        return .unknown
+    }
+
+    private static func planName(
+        root: [String: Any],
+        dataRoot: [String: Any],
+        subscription: [String: Any]?) -> String?
+    {
+        self.firstString(in: root, keys: self.planKeys)
+            ?? self.firstString(in: dataRoot, keys: self.planKeys)
+            ?? subscription.flatMap { self.firstString(in: $0, keys: self.planKeys) }
+    }
+
+    private static func subscriptionRenewsAt(
+        root: [String: Any],
+        dataRoot: [String: Any],
+        subscription: [String: Any]?) -> Date?
+    {
+        self.firstDate(in: root, keys: self.resetKeys)
+            ?? self.firstDate(in: dataRoot, keys: self.resetKeys)
+            ?? subscription.flatMap { self.firstDate(in: $0, keys: self.resetKeys) }
+    }
+
+    private static func firstDictionary(
+        in root: [String: Any],
+        dataRoot: [String: Any],
+        keys: [String]) -> [String: Any]?
+    {
+        self.dictionaryValue(self.value(in: root, keys: keys))
+            ?? self.dictionaryValue(self.value(in: dataRoot, keys: keys))
+    }
+
+    private static func fallbackQuotaObjects(from root: [String: Any], dataRoot: [String: Any]) -> [[String: Any]] {
+        let candidates: [Any?] = [
+            self.value(in: root, keys: self.quotaContainerKeys),
+            self.value(in: dataRoot, keys: self.quotaContainerKeys),
+            dataRoot,
+            root,
+        ]
+
+        var results: [[String: Any]] = []
+        for candidate in candidates {
+            results.append(contentsOf: self.extractQuotaObjects(from: candidate))
+        }
+        return self.deduplicated(results)
+    }
+
+    private static func extractQuotaObjects(from candidate: Any?) -> [[String: Any]] {
+        if let array = candidate as? [Any] {
+            return array.flatMap { self.extractQuotaObjects(from: $0) }
+        }
+
+        guard let dict = self.dictionaryValue(candidate) else { return [] }
+        var results: [[String: Any]] = self.isQuotaPayload(dict) ? [dict] : []
+        for value in dict.values {
+            results.append(contentsOf: self.extractQuotaObjects(from: value))
+        }
+        return results
+    }
+
+    private static func deduplicated(_ objects: [[String: Any]]) -> [[String: Any]] {
+        var seen: Set<Data> = []
+        var unique: [[String: Any]] = []
+        for object in objects {
+            guard let key = try? JSONSerialization.data(withJSONObject: object, options: [.sortedKeys]) else {
+                unique.append(object)
+                continue
+            }
+            guard seen.insert(key).inserted else { continue }
+            unique.append(object)
+        }
+        return unique
+    }
+
+    private static func isQuotaPayload(_ payload: [String: Any]) -> Bool {
+        self.firstDouble(in: payload, keys: self.limitKeys) != nil ||
+            self.firstDouble(in: payload, keys: self.usedKeys) != nil ||
+            self.firstDouble(in: payload, keys: self.remainingKeys) != nil ||
+            self.firstDouble(in: payload, keys: self.percentUsedKeys) != nil ||
+            self.firstDouble(in: payload, keys: self.percentRemainingKeys) != nil
+    }
+
+    private static func kind(for window: ChutesQuotaWindow) -> WindowKind? {
+        let label = [
+            window.label,
+            window.unit,
+        ]
+            .compactMap { $0?.lowercased() }
+            .joined(separator: " ")
+
+        if label.contains("rolling") ||
+            label.contains("4h") ||
+            label.contains("4 h") ||
+            label.contains("4-hour") ||
+            label.contains("four hour") ||
+            label.contains("four-hour") ||
+            window.windowMinutes == ChutesUsageSnapshot.rollingWindowMinutes
+        {
+            return .rolling
+        }
+
+        if label.contains("month") ||
+            label.contains("billing") ||
+            label.contains("subscription") ||
+            (window.windowMinutes ?? 0) >= 28 * 24 * 60
+        {
+            return .monthly
+        }
+
+        return nil
+    }
+
+    private static func windowMinutes(from payload: [String: Any]) -> Int? {
+        if let minutes = self.firstDouble(in: payload, keys: windowMinuteKeys) {
+            return Int(minutes.rounded())
+        }
+        if let hours = self.firstDouble(in: payload, keys: windowHourKeys) {
+            return Int((hours * 60).rounded())
+        }
+        if let days = self.firstDouble(in: payload, keys: windowDayKeys) {
+            return Int((days * 24 * 60).rounded())
+        }
+        if let seconds = self.firstDouble(in: payload, keys: windowSecondKeys) {
+            return Int((seconds / 60).rounded())
+        }
+        if let text = self.firstString(in: payload, keys: windowStringKeys) {
+            return self.windowMinutes(fromText: text)
+        }
+        return nil
+    }
+
+    static func windowMinutes(fromText raw: String) -> Int? {
+        let text = raw.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+        guard !text.isEmpty else { return nil }
+        let compact = text.replacingOccurrences(of: " ", with: "")
+        let scanner = Scanner(string: compact)
+        guard let value = scanner.scanDouble(), value > 0 else { return nil }
+        let suffix = String(compact[scanner.currentIndex...])
+        if suffix.hasPrefix("min") || suffix == "m" {
+            return Int(value.rounded())
+        }
+        if suffix.hasPrefix("hour") || suffix.hasPrefix("hr") || suffix == "h" {
+            return Int((value * 60).rounded())
+        }
+        if suffix.hasPrefix("day") || suffix == "d" {
+            return Int((value * 24 * 60).rounded())
+        }
+        if suffix.hasPrefix("month") || suffix == "mo" {
+            return Int((value * 30 * 24 * 60).rounded())
+        }
+        return nil
+    }
+
+    private static func firstString(in dict: [String: Any], keys: [String]) -> String? {
+        guard let value = self.value(in: dict, keys: keys) else { return nil }
+        if let string = value as? String {
+            let cleaned = string.trimmingCharacters(in: .whitespacesAndNewlines)
+            return cleaned.isEmpty ? nil : cleaned
+        }
+        if let number = value as? NSNumber {
+            return number.stringValue
+        }
+        return nil
+    }
+
+    private static func firstBool(in dict: [String: Any], keys: [String]) -> Bool? {
+        guard let value = self.value(in: dict, keys: keys) else { return nil }
+        if let bool = value as? Bool { return bool }
+        if let number = value as? NSNumber { return number.boolValue }
+        if let string = value as? String {
+            switch string.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() {
+            case "true", "1", "yes", "active":
+                return true
+            case "false", "0", "no", "inactive", "none":
+                return false
+            default:
+                return nil
+            }
+        }
+        return nil
+    }
+
+    private static func firstDouble(in dict: [String: Any], keys: [String]) -> Double? {
+        self.doubleValue(self.value(in: dict, keys: keys))
+    }
+
+    private static func firstDate(in dict: [String: Any], keys: [String]) -> Date? {
+        ChutesTimestampParser.parse(self.value(in: dict, keys: keys))
+    }
+
+    private static func normalizedPercent(_ value: Double?) -> Double? {
+        guard let value, value.isFinite else { return nil }
+        let percent = abs(value) < 1 ? value * 100 : value
+        return max(0, min(percent, 100))
+    }
+
+    private static func value(in dict: [String: Any], keys: [String]) -> Any? {
+        for key in keys {
+            let normalized = self.normalizedKey(key)
+            for (candidateKey, value) in dict where self.normalizedKey(candidateKey) == normalized {
+                return value
+            }
+        }
+        return nil
+    }
+
+    private static func dictionaryValue(_ value: Any?) -> [String: Any]? {
+        value as? [String: Any]
+    }
+
+    private static func doubleValue(_ value: Any?) -> Double? {
+        switch value {
+        case let double as Double:
+            double.isFinite ? double : nil
+        case let int as Int:
+            Double(int)
+        case let number as NSNumber:
+            number.doubleValue.isFinite ? number.doubleValue : nil
+        case let string as String:
+            self.doubleValue(from: string)
+        default:
+            nil
+        }
+    }
+
+    private static func doubleValue(from raw: String) -> Double? {
+        let text = raw.trimmingCharacters(in: .whitespacesAndNewlines)
+            .replacingOccurrences(of: ",", with: "")
+            .replacingOccurrences(of: "$", with: "")
+            .replacingOccurrences(of: "%", with: "")
+        guard !text.isEmpty, let value = Double(text), value.isFinite else { return nil }
+        return value
+    }
+
+    private static func normalizedKey(_ key: String) -> String {
+        key.lowercased().filter { $0.isLetter || $0.isNumber }
+    }
+
+    private static let rollingPayloadKeys = [
+        "rolling",
+        "rolling_window",
+        "rollingWindow",
+        "rolling_4h",
+        "rolling4h",
+        "four_hour",
+        "fourHour",
+        "four_hour_usage",
+        "fourHourUsage",
+        "window_4h",
+        "window4h",
+    ]
+    private static let monthlyPayloadKeys = [
+        "monthly",
+        "monthly_usage",
+        "monthlyUsage",
+        "subscription",
+        "subscription_usage",
+        "subscriptionUsage",
+        "billing_period",
+        "billingPeriod",
+    ]
+    private static let quotaContainerKeys = [
+        "quotas",
+        "quota",
+        "quota_usage",
+        "quotaUsage",
+        "limits",
+        "usage",
+        "entries",
+        "subscription_usage",
+        "subscriptionUsage",
+    ]
+    private static let labelKeys = [
+        "label",
+        "name",
+        "title",
+        "type",
+        "quota_type",
+        "quotaType",
+        "period",
+        "window",
+        "window_name",
+        "windowName",
+        "chute_id",
+        "chuteId",
+    ]
+    private static let limitKeys = [
+        "limit",
+        "cap",
+        "max",
+        "maximum",
+        "quota",
+        "quota_limit",
+        "quotaLimit",
+        "monthly_cap",
+        "monthlyCap",
+        "monthly_limit",
+        "monthlyLimit",
+        "request_limit",
+        "requestLimit",
+        "token_limit",
+        "tokenLimit",
+        "hard_limit",
+        "hardLimit",
+        "total",
+    ]
+    private static let usedKeys = [
+        "used",
+        "usage",
+        "used_amount",
+        "usedAmount",
+        "consumed",
+        "consumed_amount",
+        "consumedAmount",
+        "current",
+        "current_usage",
+        "currentUsage",
+        "requests",
+        "request_count",
+        "requestCount",
+        "tokens",
+        "token_usage",
+        "tokenUsage",
+        "monthly_usage",
+        "monthlyUsage",
+    ]
+    private static let remainingKeys = [
+        "remaining",
+        "available",
+        "balance",
+        "left",
+        "remaining_amount",
+        "remainingAmount",
+        "available_amount",
+        "availableAmount",
+    ]
+    private static let percentUsedKeys = [
+        "percent_used",
+        "percentUsed",
+        "usage_percent",
+        "usagePercent",
+        "used_percent",
+        "usedPercent",
+        "utilization",
+        "utilization_percent",
+        "utilizationPercent",
+    ]
+    private static let percentRemainingKeys = [
+        "percent_remaining",
+        "percentRemaining",
+        "remaining_percent",
+        "remainingPercent",
+    ]
+    private static let resetKeys = [
+        "reset_at",
+        "resetAt",
+        "resets_at",
+        "resetsAt",
+        "reset_time",
+        "resetTime",
+        "next_reset_at",
+        "nextResetAt",
+        "renews_at",
+        "renewsAt",
+        "renewal_at",
+        "renewalAt",
+        "period_end",
+        "periodEnd",
+        "current_period_end",
+        "currentPeriodEnd",
+        "expires_at",
+        "expiresAt",
+        "window_end",
+        "windowEnd",
+        "end_time",
+        "endTime",
+    ]
+    private static let unitKeys = [
+        "unit",
+        "units",
+        "currency",
+        "quota_unit",
+        "quotaUnit",
+    ]
+    private static let activeKeys = [
+        "active",
+        "is_active",
+        "isActive",
+        "subscription_active",
+        "subscriptionActive",
+        "has_subscription",
+        "hasSubscription",
+    ]
+    private static let statusKeys = [
+        "status",
+        "state",
+        "subscription_status",
+        "subscriptionStatus",
+    ]
+    private static let planKeys = [
+        "plan_name",
+        "planName",
+        "plan",
+        "tier",
+        "subscription_plan",
+        "subscriptionPlan",
+        "subscription_tier",
+        "subscriptionTier",
+    ]
+    private static let windowMinuteKeys = [
+        "window_minutes",
+        "windowMinutes",
+        "period_minutes",
+        "periodMinutes",
+        "duration_minutes",
+        "durationMinutes",
+    ]
+    private static let windowHourKeys = [
+        "window_hours",
+        "windowHours",
+        "period_hours",
+        "periodHours",
+        "duration_hours",
+        "durationHours",
+    ]
+    private static let windowDayKeys = [
+        "window_days",
+        "windowDays",
+        "period_days",
+        "periodDays",
+        "duration_days",
+        "durationDays",
+    ]
+    private static let windowSecondKeys = [
+        "window_seconds",
+        "windowSeconds",
+        "period_seconds",
+        "periodSeconds",
+        "duration_seconds",
+        "durationSeconds",
+    ]
+    private static let windowStringKeys = [
+        "window",
+        "period",
+        "interval",
+        "duration",
+    ]
+}
diff --git a/Sources/CodexBarCore/Providers/Claude/ClaudeAdminAPISettingsReader.swift b/Sources/CodexBarCore/Providers/Claude/ClaudeAdminAPISettingsReader.swift
new file mode 100644
index 0000000000..cbb1791141
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Claude/ClaudeAdminAPISettingsReader.swift
@@ -0,0 +1,43 @@
+import Foundation
+
+public enum ClaudeAdminAPISettingsReader {
+    public static let adminAPIKeyEnvironmentKey = "ANTHROPIC_ADMIN_KEY"
+    public static let alternateAdminAPIKeyEnvironmentKey = "ANTHROPIC_ADMIN_API_KEY"
+    public static let apiKeyEnvironmentKeys = [
+        Self.adminAPIKeyEnvironmentKey,
+        Self.alternateAdminAPIKeyEnvironmentKey,
+    ]
+
+    public static func apiKey(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        for key in self.apiKeyEnvironmentKeys {
+            if let token = self.cleaned(environment[key]) { return token }
+        }
+        return nil
+    }
+
+    public static func cleaned(_ raw: String?) -> String? {
+        guard var value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
+            return nil
+        }
+
+        if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
+            (value.hasPrefix("'") && value.hasSuffix("'"))
+        {
+            value = String(value.dropFirst().dropLast())
+        }
+
+        value = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        return value.isEmpty ? nil : value
+    }
+}
+
+public enum ClaudeAdminAPISettingsError: LocalizedError, Sendable {
+    case missingToken
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingToken:
+            "Claude API usage needs an Anthropic Admin API key."
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Claude/ClaudeAdminAPIUsageFetcher.swift b/Sources/CodexBarCore/Providers/Claude/ClaudeAdminAPIUsageFetcher.swift
new file mode 100644
index 0000000000..37df52a035
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Claude/ClaudeAdminAPIUsageFetcher.swift
@@ -0,0 +1,432 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public enum ClaudeAdminAPIUsageError: LocalizedError, Sendable, Equatable {
+    case missingCredentials
+    case networkError(String)
+    case apiError(endpoint: String, statusCode: Int)
+    case parseFailed(endpoint: String, message: String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingCredentials:
+            "Missing Anthropic Admin API key."
+        case let .networkError(message):
+            "Claude API usage network error: \(message)"
+        case let .apiError(endpoint, statusCode):
+            "Claude API usage \(endpoint) error: HTTP \(statusCode)"
+        case let .parseFailed(endpoint, message):
+            "Failed to parse Claude API usage \(endpoint): \(message)"
+        }
+    }
+}
+
+public enum ClaudeAdminAPIUsageFetcher {
+    public static let costReportURL = URL(string: "https://api.anthropic.com/v1/organizations/cost_report")!
+    public static let messagesUsageURL =
+        URL(string: "https://api.anthropic.com/v1/organizations/usage_report/messages")!
+
+    private static let anthropicVersion = "2023-06-01"
+    private static let timeoutSeconds: TimeInterval = 20
+    private static let maxDailyBuckets = 31
+
+    public static func fetchUsage(
+        apiKey: String,
+        costURL: URL = Self.costReportURL,
+        messagesURL: URL = Self.messagesUsageURL,
+        session transport: any ProviderHTTPTransport = ProviderHTTPClient.shared,
+        now: Date = Date()) async throws -> ClaudeAdminAPIUsageSnapshot
+    {
+        let trimmed = apiKey.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else {
+            throw ClaudeAdminAPIUsageError.missingCredentials
+        }
+
+        let calendar = Self.utcCalendar
+        let range = Self.dailyRange(now: now, calendar: calendar)
+        let costs = try await Self.fetchCostReport(
+            apiKey: trimmed,
+            baseURL: costURL,
+            range: range,
+            transport: transport)
+        let messages = try await Self.fetchMessagesUsage(
+            apiKey: trimmed,
+            baseURL: messagesURL,
+            range: range,
+            transport: transport)
+
+        return Self.makeSnapshot(costs: costs, messages: messages, now: now, calendar: calendar)
+    }
+
+    static func _parseSnapshotForTesting(
+        costs: Data,
+        messages: Data,
+        now: Date,
+        calendar: Calendar = Self.utcCalendar) throws -> ClaudeAdminAPIUsageSnapshot
+    {
+        let costs = try Self.decodeCosts(costs)
+        let messages = try Self.decodeMessages(messages)
+        return Self.makeSnapshot(costs: costs, messages: messages, now: now, calendar: calendar)
+    }
+
+    private static func fetchCostReport(
+        apiKey: String,
+        baseURL: URL,
+        range: DateRange,
+        transport: any ProviderHTTPTransport) async throws -> CostReportResponse
+    {
+        let url = Self.url(
+            baseURL: baseURL,
+            range: range,
+            queryItems: [
+                URLQueryItem(name: "group_by[]", value: "description"),
+            ])
+        let data = try await Self.fetchData(url: url, apiKey: apiKey, endpoint: "cost_report", transport: transport)
+        return try Self.decodeCosts(data)
+    }
+
+    private static func fetchMessagesUsage(
+        apiKey: String,
+        baseURL: URL,
+        range: DateRange,
+        transport: any ProviderHTTPTransport) async throws -> MessagesUsageResponse
+    {
+        let url = Self.url(
+            baseURL: baseURL,
+            range: range,
+            queryItems: [
+                URLQueryItem(name: "group_by[]", value: "model"),
+            ])
+        let data = try await Self.fetchData(url: url, apiKey: apiKey, endpoint: "messages", transport: transport)
+        return try Self.decodeMessages(data)
+    }
+
+    private static func fetchData(
+        url: URL,
+        apiKey: String,
+        endpoint: String,
+        transport: any ProviderHTTPTransport) async throws -> Data
+    {
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.timeoutInterval = Self.timeoutSeconds
+        request.setValue(Self.anthropicVersion, forHTTPHeaderField: "anthropic-version")
+        request.setValue(apiKey, forHTTPHeaderField: "x-api-key")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        request.setValue("CodexBar/1.0", forHTTPHeaderField: "User-Agent")
+
+        let response: ProviderHTTPResponse
+        do {
+            response = try await transport.response(for: request)
+        } catch {
+            throw ClaudeAdminAPIUsageError.networkError(error.localizedDescription)
+        }
+
+        guard response.statusCode == 200 else {
+            throw ClaudeAdminAPIUsageError.apiError(endpoint: endpoint, statusCode: response.statusCode)
+        }
+        return response.data
+    }
+
+    private static func decodeCosts(_ data: Data) throws -> CostReportResponse {
+        do {
+            return try JSONDecoder().decode(CostReportResponse.self, from: data)
+        } catch {
+            throw ClaudeAdminAPIUsageError.parseFailed(endpoint: "cost_report", message: error.localizedDescription)
+        }
+    }
+
+    private static func decodeMessages(_ data: Data) throws -> MessagesUsageResponse {
+        do {
+            return try JSONDecoder().decode(MessagesUsageResponse.self, from: data)
+        } catch {
+            throw ClaudeAdminAPIUsageError.parseFailed(endpoint: "messages", message: error.localizedDescription)
+        }
+    }
+
+    private static func makeSnapshot(
+        costs: CostReportResponse,
+        messages: MessagesUsageResponse,
+        now: Date,
+        calendar: Calendar) -> ClaudeAdminAPIUsageSnapshot
+    {
+        var accumulators: [String: DailyAccumulator] = [:]
+
+        for bucket in costs.data {
+            var accumulator = accumulators[bucket.startingAt] ?? DailyAccumulator(
+                startingAt: bucket.startingAt,
+                endingAt: bucket.endingAt)
+            for result in bucket.results {
+                // Anthropic Usage & Cost API docs define `amount` as a decimal string in lowest USD units.
+                let value = Self.usdFromAnthropicLowestUnitAmount(result.amount)
+                accumulator.costUSD += value
+                let item = Self.displayName(result.description ?? result.costType, fallback: "Claude API")
+                accumulator.costItems[item, default: 0] += value
+            }
+            accumulators[bucket.startingAt] = accumulator
+        }
+
+        for bucket in messages.data {
+            var accumulator = accumulators[bucket.startingAt] ?? DailyAccumulator(
+                startingAt: bucket.startingAt,
+                endingAt: bucket.endingAt)
+            for result in bucket.results {
+                let input = result.uncachedInputTokens ?? 0
+                let cacheCreation = result.cacheCreation?.totalInputTokens ?? 0
+                let cacheRead = result.cacheReadInputTokens ?? 0
+                let output = result.outputTokens ?? 0
+                let total = input + cacheCreation + cacheRead + output
+                accumulator.inputTokens += input
+                accumulator.cacheCreationInputTokens += cacheCreation
+                accumulator.cacheReadInputTokens += cacheRead
+                accumulator.outputTokens += output
+                accumulator.totalTokens += total
+                let modelName = Self.displayName(result.model, fallback: "Claude API")
+                accumulator.models[modelName, default: ModelAccumulator()].add(
+                    inputTokens: input,
+                    cacheCreationInputTokens: cacheCreation,
+                    cacheReadInputTokens: cacheRead,
+                    outputTokens: output,
+                    totalTokens: total)
+            }
+            accumulators[bucket.startingAt] = accumulator
+        }
+
+        let daily = accumulators.values
+            .compactMap { $0.makeBucket(calendar: calendar) }
+            .filter { $0.startTime <= now }
+            .sorted { $0.startTime < $1.startTime }
+        return ClaudeAdminAPIUsageSnapshot(daily: daily, updatedAt: now)
+    }
+
+    private static func displayName(_ raw: String?, fallback: String) -> String {
+        guard let trimmed = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !trimmed.isEmpty else {
+            return fallback
+        }
+        return trimmed
+    }
+
+    private static func usdFromAnthropicLowestUnitAmount(_ raw: String) -> Double {
+        (Double(raw) ?? 0) / 100
+    }
+
+    private static func url(baseURL: URL, range: DateRange, queryItems extraItems: [URLQueryItem]) -> URL {
+        var components = URLComponents(url: baseURL, resolvingAgainstBaseURL: false)!
+        components.queryItems = [
+            URLQueryItem(name: "starting_at", value: Self.rfc3339String(from: range.start)),
+            URLQueryItem(name: "ending_at", value: Self.rfc3339String(from: range.end)),
+            URLQueryItem(name: "bucket_width", value: "1d"),
+            URLQueryItem(name: "limit", value: String(Self.maxDailyBuckets)),
+        ] + extraItems
+        return components.url!
+    }
+
+    private static func dailyRange(now: Date, calendar: Calendar) -> DateRange {
+        let today = calendar.startOfDay(for: now)
+        let start = calendar.date(byAdding: .day, value: -(Self.maxDailyBuckets - 1), to: today) ?? today
+        let end = calendar.date(byAdding: .day, value: 1, to: today) ?? now
+        return DateRange(start: start, end: end)
+    }
+
+    private static var utcCalendar: Calendar {
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.locale = Locale(identifier: "en_US_POSIX")
+        calendar.timeZone = TimeZone(secondsFromGMT: 0)!
+        return calendar
+    }
+
+    private static func rfc3339Formatter() -> ISO8601DateFormatter {
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime]
+        formatter.timeZone = TimeZone(secondsFromGMT: 0)
+        return formatter
+    }
+
+    private static func rfc3339String(from date: Date) -> String {
+        self.rfc3339Formatter().string(from: date)
+    }
+
+    fileprivate static func dayKey(from date: Date, calendar: Calendar) -> String {
+        let formatter = DateFormatter()
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        formatter.timeZone = calendar.timeZone
+        formatter.dateFormat = "yyyy-MM-dd"
+        return formatter.string(from: date)
+    }
+
+    fileprivate static func parseDate(_ raw: String) -> Date? {
+        self.rfc3339Formatter().date(from: raw)
+    }
+}
+
+private struct DateRange {
+    let start: Date
+    let end: Date
+}
+
+private struct DailyAccumulator {
+    let startingAt: String
+    let endingAt: String
+    var costUSD: Double = 0
+    var inputTokens: Int = 0
+    var cacheCreationInputTokens: Int = 0
+    var cacheReadInputTokens: Int = 0
+    var outputTokens: Int = 0
+    var totalTokens: Int = 0
+    var costItems: [String: Double] = [:]
+    var models: [String: ModelAccumulator] = [:]
+
+    func makeBucket(calendar: Calendar) -> ClaudeAdminAPIUsageSnapshot.DailyBucket? {
+        guard let start = ClaudeAdminAPIUsageFetcher.parseDate(self.startingAt),
+              let end = ClaudeAdminAPIUsageFetcher.parseDate(self.endingAt)
+        else { return nil }
+        return ClaudeAdminAPIUsageSnapshot.DailyBucket(
+            day: ClaudeAdminAPIUsageFetcher.dayKey(from: start, calendar: calendar),
+            startTime: start,
+            endTime: end,
+            costUSD: self.costUSD,
+            inputTokens: self.inputTokens,
+            cacheCreationInputTokens: self.cacheCreationInputTokens,
+            cacheReadInputTokens: self.cacheReadInputTokens,
+            outputTokens: self.outputTokens,
+            totalTokens: self.totalTokens,
+            costItems: self.costItems
+                .map { ClaudeAdminAPIUsageSnapshot.CostBreakdown(name: $0.key, costUSD: $0.value) }
+                .sorted {
+                    if $0.costUSD == $1.costUSD { return $0.name < $1.name }
+                    return $0.costUSD > $1.costUSD
+                },
+            models: self.models
+                .map { name, total in total.makeModel(name: name) }
+                .sorted {
+                    if $0.totalTokens == $1.totalTokens { return $0.name < $1.name }
+                    return $0.totalTokens > $1.totalTokens
+                })
+    }
+}
+
+private struct ModelAccumulator {
+    var inputTokens = 0
+    var cacheCreationInputTokens = 0
+    var cacheReadInputTokens = 0
+    var outputTokens = 0
+    var totalTokens = 0
+
+    mutating func add(
+        inputTokens: Int,
+        cacheCreationInputTokens: Int,
+        cacheReadInputTokens: Int,
+        outputTokens: Int,
+        totalTokens: Int)
+    {
+        self.inputTokens += inputTokens
+        self.cacheCreationInputTokens += cacheCreationInputTokens
+        self.cacheReadInputTokens += cacheReadInputTokens
+        self.outputTokens += outputTokens
+        self.totalTokens += totalTokens
+    }
+
+    func makeModel(name: String) -> ClaudeAdminAPIUsageSnapshot.ModelBreakdown {
+        ClaudeAdminAPIUsageSnapshot.ModelBreakdown(
+            name: name,
+            inputTokens: self.inputTokens,
+            cacheCreationInputTokens: self.cacheCreationInputTokens,
+            cacheReadInputTokens: self.cacheReadInputTokens,
+            outputTokens: self.outputTokens,
+            totalTokens: self.totalTokens)
+    }
+}
+
+private struct CostReportResponse: Decodable {
+    let data: [CostBucket]
+    let hasMore: Bool?
+    let nextPage: String?
+
+    private enum CodingKeys: String, CodingKey {
+        case data
+        case hasMore = "has_more"
+        case nextPage = "next_page"
+    }
+}
+
+private struct CostBucket: Decodable {
+    let startingAt: String
+    let endingAt: String
+    let results: [CostResult]
+
+    private enum CodingKeys: String, CodingKey {
+        case startingAt = "starting_at"
+        case endingAt = "ending_at"
+        case results
+    }
+}
+
+private struct CostResult: Decodable {
+    let currency: String?
+    let amount: String
+    let description: String?
+    let costType: String?
+
+    private enum CodingKeys: String, CodingKey {
+        case currency
+        case amount
+        case description
+        case costType = "cost_type"
+    }
+}
+
+private struct MessagesUsageResponse: Decodable {
+    let data: [MessagesBucket]
+    let hasMore: Bool?
+    let nextPage: String?
+
+    private enum CodingKeys: String, CodingKey {
+        case data
+        case hasMore = "has_more"
+        case nextPage = "next_page"
+    }
+}
+
+private struct MessagesBucket: Decodable {
+    let startingAt: String
+    let endingAt: String
+    let results: [MessagesResult]
+
+    private enum CodingKeys: String, CodingKey {
+        case startingAt = "starting_at"
+        case endingAt = "ending_at"
+        case results
+    }
+}
+
+private struct MessagesResult: Decodable {
+    let uncachedInputTokens: Int?
+    let cacheCreation: CacheCreation?
+    let cacheReadInputTokens: Int?
+    let outputTokens: Int?
+    let model: String?
+
+    private enum CodingKeys: String, CodingKey {
+        case uncachedInputTokens = "uncached_input_tokens"
+        case cacheCreation = "cache_creation"
+        case cacheReadInputTokens = "cache_read_input_tokens"
+        case outputTokens = "output_tokens"
+        case model
+    }
+}
+
+private struct CacheCreation: Decodable {
+    let ephemeral1HInputTokens: Int?
+    let ephemeral5MInputTokens: Int?
+
+    var totalInputTokens: Int {
+        (self.ephemeral1HInputTokens ?? 0) + (self.ephemeral5MInputTokens ?? 0)
+    }
+
+    private enum CodingKeys: String, CodingKey {
+        case ephemeral1HInputTokens = "ephemeral_1h_input_tokens"
+        case ephemeral5MInputTokens = "ephemeral_5m_input_tokens"
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Claude/ClaudeAdminAPIUsageSnapshot.swift b/Sources/CodexBarCore/Providers/Claude/ClaudeAdminAPIUsageSnapshot.swift
new file mode 100644
index 0000000000..f9b82ab0c8
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Claude/ClaudeAdminAPIUsageSnapshot.swift
@@ -0,0 +1,222 @@
+import Foundation
+
+public struct ClaudeAdminAPIUsageSnapshot: Codable, Equatable, Sendable {
+    public struct DailyBucket: Codable, Equatable, Sendable, Identifiable {
+        public let day: String
+        public let startTime: Date
+        public let endTime: Date
+        public let costUSD: Double
+        public let inputTokens: Int
+        public let cacheCreationInputTokens: Int
+        public let cacheReadInputTokens: Int
+        public let outputTokens: Int
+        public let totalTokens: Int
+        public let costItems: [CostBreakdown]
+        public let models: [ModelBreakdown]
+
+        public var id: String {
+            self.day
+        }
+
+        public init(
+            day: String,
+            startTime: Date,
+            endTime: Date,
+            costUSD: Double,
+            inputTokens: Int,
+            cacheCreationInputTokens: Int,
+            cacheReadInputTokens: Int,
+            outputTokens: Int,
+            totalTokens: Int,
+            costItems: [CostBreakdown],
+            models: [ModelBreakdown])
+        {
+            self.day = day
+            self.startTime = startTime
+            self.endTime = endTime
+            self.costUSD = costUSD
+            self.inputTokens = inputTokens
+            self.cacheCreationInputTokens = cacheCreationInputTokens
+            self.cacheReadInputTokens = cacheReadInputTokens
+            self.outputTokens = outputTokens
+            self.totalTokens = totalTokens
+            self.costItems = costItems
+            self.models = models
+        }
+    }
+
+    public struct CostBreakdown: Codable, Equatable, Sendable, Identifiable {
+        public let name: String
+        public let costUSD: Double
+
+        public var id: String {
+            self.name
+        }
+
+        public init(name: String, costUSD: Double) {
+            self.name = name
+            self.costUSD = costUSD
+        }
+    }
+
+    public struct ModelBreakdown: Codable, Equatable, Sendable, Identifiable {
+        public let name: String
+        public let inputTokens: Int
+        public let cacheCreationInputTokens: Int
+        public let cacheReadInputTokens: Int
+        public let outputTokens: Int
+        public let totalTokens: Int
+
+        public var id: String {
+            self.name
+        }
+
+        public init(
+            name: String,
+            inputTokens: Int,
+            cacheCreationInputTokens: Int,
+            cacheReadInputTokens: Int,
+            outputTokens: Int,
+            totalTokens: Int)
+        {
+            self.name = name
+            self.inputTokens = inputTokens
+            self.cacheCreationInputTokens = cacheCreationInputTokens
+            self.cacheReadInputTokens = cacheReadInputTokens
+            self.outputTokens = outputTokens
+            self.totalTokens = totalTokens
+        }
+    }
+
+    public struct Summary: Equatable, Sendable {
+        public let costUSD: Double
+        public let inputTokens: Int
+        public let cacheCreationInputTokens: Int
+        public let cacheReadInputTokens: Int
+        public let outputTokens: Int
+        public let totalTokens: Int
+
+        public init(
+            costUSD: Double,
+            inputTokens: Int,
+            cacheCreationInputTokens: Int,
+            cacheReadInputTokens: Int,
+            outputTokens: Int,
+            totalTokens: Int)
+        {
+            self.costUSD = costUSD
+            self.inputTokens = inputTokens
+            self.cacheCreationInputTokens = cacheCreationInputTokens
+            self.cacheReadInputTokens = cacheReadInputTokens
+            self.outputTokens = outputTokens
+            self.totalTokens = totalTokens
+        }
+    }
+
+    public let daily: [DailyBucket]
+    public let updatedAt: Date
+
+    public init(daily: [DailyBucket], updatedAt: Date) {
+        self.daily = daily.sorted { $0.startTime < $1.startTime }
+        self.updatedAt = updatedAt
+    }
+
+    public var last30Days: Summary {
+        self.summary(days: 30)
+    }
+
+    public var last7Days: Summary {
+        self.summary(days: 7)
+    }
+
+    public var latestDay: Summary {
+        self.summary(days: 1)
+    }
+
+    public func summary(days: Int) -> Summary {
+        let selected = self.daily.suffix(max(1, days))
+        return Summary(
+            costUSD: selected.reduce(0) { $0 + $1.costUSD },
+            inputTokens: selected.reduce(0) { $0 + $1.inputTokens },
+            cacheCreationInputTokens: selected.reduce(0) { $0 + $1.cacheCreationInputTokens },
+            cacheReadInputTokens: selected.reduce(0) { $0 + $1.cacheReadInputTokens },
+            outputTokens: selected.reduce(0) { $0 + $1.outputTokens },
+            totalTokens: selected.reduce(0) { $0 + $1.totalTokens })
+    }
+
+    public var topModels: [ModelBreakdown] {
+        var totals: [String: ModelAccumulator] = [:]
+        for day in self.daily {
+            for model in day.models {
+                totals[model.name, default: ModelAccumulator()].add(model)
+            }
+        }
+        return totals
+            .map { name, total in total.makeModel(name: name) }
+            .sorted {
+                if $0.totalTokens == $1.totalTokens { return $0.name < $1.name }
+                return $0.totalTokens > $1.totalTokens
+            }
+    }
+
+    public var topCostItems: [CostBreakdown] {
+        var totals: [String: Double] = [:]
+        for day in self.daily {
+            for item in day.costItems {
+                totals[item.name, default: 0] += item.costUSD
+            }
+        }
+        return totals
+            .map { CostBreakdown(name: $0.key, costUSD: $0.value) }
+            .sorted {
+                if $0.costUSD == $1.costUSD { return $0.name < $1.name }
+                return $0.costUSD > $1.costUSD
+            }
+    }
+
+    public func toUsageSnapshot() -> UsageSnapshot {
+        let total = self.last30Days
+        return UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            providerCost: ProviderCostSnapshot(
+                used: total.costUSD,
+                limit: 0,
+                currencyCode: "USD",
+                period: "Last 30 days",
+                updatedAt: self.updatedAt),
+            claudeAdminAPIUsage: self,
+            updatedAt: self.updatedAt,
+            identity: ProviderIdentitySnapshot(
+                providerID: .claude,
+                accountEmail: nil,
+                accountOrganization: nil,
+                loginMethod: "Admin API"))
+    }
+
+    private struct ModelAccumulator {
+        var inputTokens = 0
+        var cacheCreationInputTokens = 0
+        var cacheReadInputTokens = 0
+        var outputTokens = 0
+        var totalTokens = 0
+
+        mutating func add(_ model: ModelBreakdown) {
+            self.inputTokens += model.inputTokens
+            self.cacheCreationInputTokens += model.cacheCreationInputTokens
+            self.cacheReadInputTokens += model.cacheReadInputTokens
+            self.outputTokens += model.outputTokens
+            self.totalTokens += model.totalTokens
+        }
+
+        func makeModel(name: String) -> ModelBreakdown {
+            ModelBreakdown(
+                name: name,
+                inputTokens: self.inputTokens,
+                cacheCreationInputTokens: self.cacheCreationInputTokens,
+                cacheReadInputTokens: self.cacheReadInputTokens,
+                outputTokens: self.outputTokens,
+                totalTokens: self.totalTokens)
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Claude/ClaudeCLIRateLimitGate.swift b/Sources/CodexBarCore/Providers/Claude/ClaudeCLIRateLimitGate.swift
new file mode 100644
index 0000000000..5c06ec0eae
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Claude/ClaudeCLIRateLimitGate.swift
@@ -0,0 +1,64 @@
+import Foundation
+
+enum ClaudeCLIRateLimitGate {
+    private static let blockedUntilKey = "claudeCLIUsageRateLimitBlockedUntilV1"
+    private static let defaultCooldown: TimeInterval = 60 * 5
+
+    static let message = "Claude CLI usage endpoint is rate limited right now. Please try again later."
+
+    static func blockedUntil(
+        interaction: ProviderInteraction = ProviderInteractionContext.current,
+        now: Date = Date()) -> Date?
+    {
+        guard interaction != .userInitiated else { return nil }
+        return self.currentBlockedUntil(now: now)
+    }
+
+    static func currentBlockedUntil(now: Date = Date()) -> Date? {
+        guard let raw = UserDefaults.standard.object(forKey: self.blockedUntilKey) as? Double else {
+            return nil
+        }
+
+        let blockedUntil = Date(timeIntervalSince1970: raw)
+        guard blockedUntil > now else {
+            UserDefaults.standard.removeObject(forKey: self.blockedUntilKey)
+            return nil
+        }
+        return blockedUntil
+    }
+
+    static func recordRateLimit(now: Date = Date()) {
+        UserDefaults.standard.set(
+            now.addingTimeInterval(self.defaultCooldown).timeIntervalSince1970,
+            forKey: self.blockedUntilKey)
+    }
+
+    static func recordSuccess() {
+        UserDefaults.standard.removeObject(forKey: self.blockedUntilKey)
+    }
+
+    static func isRateLimitError(_ error: Error) -> Bool {
+        if case let ClaudeStatusProbeError.parseFailed(message) = error {
+            return self.isRateLimitMessage(message, allowRawRateLimitToken: true)
+        }
+        if case let ClaudeUsageError.parseFailed(message) = error {
+            return self.isRateLimitMessage(message, allowRawRateLimitToken: true)
+        }
+        return self.isRateLimitMessage(error.localizedDescription, allowRawRateLimitToken: false)
+    }
+
+    private static func isRateLimitMessage(_ message: String, allowRawRateLimitToken: Bool) -> Bool {
+        let lower = message.lowercased()
+        return lower.contains(Self.message.lowercased()) ||
+            (allowRawRateLimitToken && lower.contains("rate_limit_error")) ||
+            (lower.contains("claude cli") &&
+                lower.contains("usage") &&
+                lower.contains("rate limited"))
+    }
+
+    #if DEBUG
+    static func resetForTesting() {
+        UserDefaults.standard.removeObject(forKey: self.blockedUntilKey)
+    }
+    #endif
+}
diff --git a/Sources/CodexBarCore/Providers/Claude/ClaudeCLISession.swift b/Sources/CodexBarCore/Providers/Claude/ClaudeCLISession.swift
index 9ae1bc052f..8026006cb7 100644
--- a/Sources/CodexBarCore/Providers/Claude/ClaudeCLISession.swift
+++ b/Sources/CodexBarCore/Providers/Claude/ClaudeCLISession.swift
@@ -1,13 +1,34 @@
 #if canImport(Darwin)
 import Darwin
-#else
+#elseif canImport(Glibc)
 import Glibc
+#elseif canImport(Musl)
+import Musl
 #endif
 import Foundation
 
 actor ClaudeCLISession {
     static let shared = ClaudeCLISession()
     private static let log = CodexBarLog.logger(LogCategories.claudeCLI)
+    #if DEBUG
+    @TaskLocal private static var sessionOverrideForTesting: ClaudeCLISession?
+
+    static var current: ClaudeCLISession {
+        self.sessionOverrideForTesting ?? self.shared
+    }
+
+    static func withIsolatedSessionForTesting<T>(operation: () async throws -> T) async rethrows -> T {
+        let session = ClaudeCLISession()
+        defer { Task { await session.reset() } }
+        return try await self.$sessionOverrideForTesting.withValue(session) {
+            try await operation()
+        }
+    }
+    #else
+    static var current: ClaudeCLISession {
+        self.shared
+    }
+    #endif
 
     enum SessionError: LocalizedError {
         case launchFailed(String)
@@ -98,6 +119,7 @@ actor ClaudeCLISession {
         timeout: TimeInterval,
         idleTimeout: TimeInterval? = 3.0,
         stopOnSubstrings: [String] = [],
+        stopWhenNormalized: (@Sendable (String) -> Bool)? = nil,
         settleAfterStop: TimeInterval = 0.25,
         sendEnterEvery: TimeInterval? = nil) async throws -> String
     {
@@ -136,6 +158,7 @@ actor ClaudeCLISession {
 
         var buffer = Data()
         var scanTailText = ""
+        var normalizedScan = ""
         var utf8Carry = Data()
         let deadline = Date().addingTimeInterval(timeout)
         var lastOutputAt = Date()
@@ -152,27 +175,26 @@ actor ClaudeCLISession {
                 lastOutputAt = Date()
                 Self.appendScanText(newData: newData, scanTailText: &scanTailText, utf8Carry: &utf8Carry)
                 if scanTailText.count > 8192 { scanTailText = String(scanTailText.suffix(8192)) }
-            }
+                normalizedScan = Self.normalizedNeedle(TextParsing.stripANSICodes(scanTailText))
 
-            let scanData = scanBuffer.append(newData)
-            if !scanData.isEmpty,
-               scanData.range(of: cursorQuery) != nil
-            {
-                try? self.send("\u{1b}[1;1R")
-            }
-
-            let normalizedScan = Self.normalizedNeedle(TextParsing.stripANSICodes(scanTailText))
+                let scanData = scanBuffer.append(newData)
+                if scanData.range(of: cursorQuery) != nil {
+                    try? self.send("\u{1b}[1;1R")
+                }
 
-            for item in sendNeedles where !triggeredSends.contains(item.needle) {
-                if normalizedScan.contains(item.needle) {
-                    try? self.send(item.keys)
-                    triggeredSends.insert(item.needle)
+                for item in sendNeedles where !triggeredSends.contains(item.needle) {
+                    if normalizedScan.contains(item.needle) {
+                        try? self.send(item.keys)
+                        triggeredSends.insert(item.needle)
+                    }
                 }
-            }
 
-            if stopNeedles.contains(where: normalizedScan.contains) {
-                stoppedEarly = true
-                break
+                if stopNeedles
+                    .contains(where: normalizedScan.contains) || (stopWhenNormalized?(normalizedScan) == true)
+                {
+                    stoppedEarly = true
+                    break
+                }
             }
 
             if self.shouldStopForIdleTimeout(
@@ -278,13 +300,19 @@ actor ClaudeCLISession {
         proc.standardOutput = secondaryHandle
         proc.standardError = secondaryHandle
 
-        let workingDirectory = ClaudeStatusProbe.probeWorkingDirectoryURL()
+        let workingDirectory = ClaudeStatusProbe.preparedProbeWorkingDirectoryURL()
         proc.currentDirectoryURL = workingDirectory
-        var env = TTYCommandRunner.enrichedEnvironment()
-        env = Self.scrubbedClaudeEnvironment(from: env)
+        var env = Self.launchEnvironment()
         env["PWD"] = workingDirectory.path
         proc.environment = env
 
+        guard TTYCommandRunner.beginActiveProcessLaunchForAppShutdown() else {
+            try? primaryHandle.close()
+            try? secondaryHandle.close()
+            throw SessionError.launchFailed("App shutdown in progress")
+        }
+        defer { TTYCommandRunner.endActiveProcessLaunchForAppShutdown() }
+
         do {
             try proc.run()
             Self.log.debug(
@@ -298,9 +326,21 @@ actor ClaudeCLISession {
         }
 
         let pid = proc.processIdentifier
+        guard TTYCommandRunner.registerActiveProcessForAppShutdown(
+            pid: pid,
+            binary: URL(fileURLWithPath: binary).lastPathComponent)
+        else {
+            proc.terminate()
+            kill(pid, SIGKILL)
+            try? primaryHandle.close()
+            try? secondaryHandle.close()
+            throw SessionError.launchFailed("App shutdown in progress")
+        }
+
         var processGroup: pid_t?
         if setpgid(pid, pid) == 0 {
             processGroup = pid
+            TTYCommandRunner.updateActiveProcessGroupForAppShutdown(pid: pid, processGroup: processGroup)
         }
 
         self.process = proc
@@ -312,6 +352,10 @@ actor ClaudeCLISession {
         self.startedAt = Date()
     }
 
+    static func launchEnvironment(baseEnv: [String: String] = ProcessInfo.processInfo.environment) -> [String: String] {
+        self.scrubbedClaudeEnvironment(from: TTYCommandRunner.enrichedEnvironment(baseEnv: baseEnv))
+    }
+
     private static func scrubbedClaudeEnvironment(from base: [String: String]) -> [String: String] {
         var env = base
         let explicitKeys: [String] = [
@@ -337,11 +381,16 @@ actor ClaudeCLISession {
         try? self.primaryHandle?.close()
         try? self.secondaryHandle?.close()
 
+        let descendants = self.process.map { TTYProcessTreeTerminator.descendantPIDs(of: $0.processIdentifier) } ?? []
         if let proc = self.process, proc.isRunning {
             proc.terminate()
         }
-        if let pgid = self.processGroup {
-            kill(-pgid, SIGTERM)
+        if let proc = self.process {
+            TTYProcessTreeTerminator.terminateProcessTree(
+                rootPID: proc.processIdentifier,
+                processGroup: self.processGroup,
+                signal: SIGTERM,
+                knownDescendants: descendants)
         }
         let waitDeadline = Date().addingTimeInterval(1.0)
         if let proc = self.process {
@@ -349,11 +398,17 @@ actor ClaudeCLISession {
                 usleep(100_000)
             }
             if proc.isRunning {
-                if let pgid = self.processGroup {
-                    kill(-pgid, SIGKILL)
+                TTYProcessTreeTerminator.terminateProcessTree(
+                    rootPID: proc.processIdentifier,
+                    processGroup: self.processGroup,
+                    signal: SIGKILL,
+                    knownDescendants: descendants)
+            } else {
+                for pid in descendants where pid > 0 {
+                    kill(pid, SIGKILL)
                 }
-                kill(proc.processIdentifier, SIGKILL)
             }
+            TTYCommandRunner.unregisterActiveProcessForAppShutdown(pid: proc.processIdentifier)
         }
 
         self.process = nil
diff --git a/Sources/CodexBarCore/Providers/Claude/ClaudeCredentialRouting.swift b/Sources/CodexBarCore/Providers/Claude/ClaudeCredentialRouting.swift
new file mode 100644
index 0000000000..2472de27fa
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Claude/ClaudeCredentialRouting.swift
@@ -0,0 +1,102 @@
+import Foundation
+
+public enum ClaudeCredentialRouting: Sendable, Equatable {
+    case none
+    case oauth(accessToken: String)
+    case webCookie(header: String)
+    case adminAPIKey(String)
+
+    public static func resolve(tokenAccountToken: String?, manualCookieHeader: String?) -> Self {
+        if let tokenAccountToken,
+           let route = self.resolvePrimaryCredential(tokenAccountToken)
+        {
+            return route
+        }
+
+        guard let manualCookieHeader = self.normalizedWebCookie(manualCookieHeader) else {
+            return .none
+        }
+        return .webCookie(header: manualCookieHeader)
+    }
+
+    public var oauthAccessToken: String? {
+        guard case let .oauth(accessToken) = self else { return nil }
+        return accessToken
+    }
+
+    public var manualCookieHeader: String? {
+        guard case let .webCookie(header) = self else { return nil }
+        return header
+    }
+
+    public var isOAuth: Bool {
+        if case .oauth = self { return true }
+        return false
+    }
+
+    public var adminAPIKey: String? {
+        guard case let .adminAPIKey(key) = self else { return nil }
+        return key
+    }
+
+    private static func resolvePrimaryCredential(_ raw: String) -> Self? {
+        if let adminKey = self.normalizedAdminAPIKey(raw) {
+            return .adminAPIKey(adminKey)
+        }
+        if let accessToken = self.normalizedOAuthToken(raw) {
+            return .oauth(accessToken: accessToken)
+        }
+        if let cookieHeader = self.normalizedWebCookie(raw) {
+            return .webCookie(header: cookieHeader)
+        }
+        return nil
+    }
+
+    private static func normalizedOAuthToken(_ raw: String?) -> String? {
+        guard let trimmed = self.cleaned(raw) else { return nil }
+        let lower = trimmed.lowercased()
+        if lower.contains("cookie:") || trimmed.contains("=") {
+            return nil
+        }
+        if lower.hasPrefix("bearer ") {
+            let bearerTrimmed = trimmed.dropFirst("bearer ".count)
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+            guard !bearerTrimmed.isEmpty else { return nil }
+            let lowerBearerTrimmed = bearerTrimmed.lowercased()
+            return lowerBearerTrimmed.hasPrefix("sk-ant-oat") ? bearerTrimmed : nil
+        }
+        return lower.hasPrefix("sk-ant-oat") ? trimmed : nil
+    }
+
+    private static func normalizedAdminAPIKey(_ raw: String?) -> String? {
+        guard let trimmed = self.cleaned(raw) else { return nil }
+        let lower = trimmed.lowercased()
+        if lower.contains("cookie:") || trimmed.contains("=") {
+            return nil
+        }
+        if lower.hasPrefix("bearer ") {
+            let bearerTrimmed = trimmed.dropFirst("bearer ".count)
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+            guard !bearerTrimmed.isEmpty else { return nil }
+            return bearerTrimmed.lowercased().hasPrefix("sk-ant-admin") ? bearerTrimmed : nil
+        }
+        return lower.hasPrefix("sk-ant-admin") ? trimmed : nil
+    }
+
+    private static func normalizedWebCookie(_ raw: String?) -> String? {
+        guard let normalized = CookieHeaderNormalizer.normalize(raw) else { return nil }
+        if normalized.contains("=") {
+            return normalized
+        }
+        return "sessionKey=\(normalized)"
+    }
+
+    private static func cleaned(_ raw: String?) -> String? {
+        guard let trimmed = raw?.trimmingCharacters(in: .whitespacesAndNewlines),
+              !trimmed.isEmpty
+        else {
+            return nil
+        }
+        return trimmed
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthCredentialModels.swift b/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthCredentialModels.swift
index a62a138194..a940846079 100644
--- a/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthCredentialModels.swift
+++ b/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthCredentialModels.swift
@@ -10,19 +10,22 @@ public struct ClaudeOAuthCredentials: Sendable {
     public let expiresAt: Date?
     public let scopes: [String]
     public let rateLimitTier: String?
+    public let subscriptionType: String?
 
     public init(
         accessToken: String,
         refreshToken: String?,
         expiresAt: Date?,
         scopes: [String],
-        rateLimitTier: String?)
+        rateLimitTier: String?,
+        subscriptionType: String? = nil)
     {
         self.accessToken = accessToken
         self.refreshToken = refreshToken
         self.expiresAt = expiresAt
         self.scopes = scopes
         self.rateLimitTier = rateLimitTier
+        self.subscriptionType = subscriptionType
     }
 
     public var isExpired: Bool {
@@ -55,7 +58,8 @@ public struct ClaudeOAuthCredentials: Sendable {
             refreshToken: oauth.refreshToken,
             expiresAt: expiresAt,
             scopes: oauth.scopes ?? [],
-            rateLimitTier: oauth.rateLimitTier)
+            rateLimitTier: oauth.rateLimitTier,
+            subscriptionType: oauth.subscriptionType)
     }
 
     private struct Root: Decodable {
@@ -68,6 +72,7 @@ public struct ClaudeOAuthCredentials: Sendable {
         let expiresAt: Double?
         let scopes: [String]?
         let rateLimitTier: String?
+        let subscriptionType: String?
 
         enum CodingKeys: String, CodingKey {
             case accessToken
@@ -75,6 +80,7 @@ public struct ClaudeOAuthCredentials: Sendable {
             case expiresAt
             case scopes
             case rateLimitTier
+            case subscriptionType
         }
     }
 }
diff --git a/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthCredentials+SecurityCLIReader.swift b/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthCredentials+SecurityCLIReader.swift
index 72cb6dd96e..1789258e34 100644
--- a/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthCredentials+SecurityCLIReader.swift
+++ b/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthCredentials+SecurityCLIReader.swift
@@ -5,13 +5,15 @@ import Foundation
 import Darwin
 #elseif canImport(Glibc)
 import Glibc
+#elseif canImport(Musl)
+import Musl
 #endif
 
 extension ClaudeOAuthCredentialsStore {
     private static let securityBinaryPath = "/usr/bin/security"
     private static let securityCLIReadTimeout: TimeInterval = 1.5
 
-    struct SecurityCLIReadRequest: Sendable {
+    struct SecurityCLIReadRequest {
         let account: String?
     }
 
@@ -23,14 +25,14 @@ extension ClaudeOAuthCredentialsStore {
     }
 
     #if os(macOS)
-    private enum SecurityCLIReadError: Error, Sendable {
+    private enum SecurityCLIReadError: Error {
         case binaryUnavailable
         case launchFailed
         case timedOut
         case nonZeroExit(status: Int32, stderrLength: Int)
     }
 
-    private struct SecurityCLIReadCommandResult: Sendable {
+    private struct SecurityCLIReadCommandResult {
         let status: Int32
         let stdout: Data
         let stderrLength: Int
diff --git a/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthCredentials+TestingOverrides.swift b/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthCredentials+TestingOverrides.swift
index dbcd11105a..105df7476b 100644
--- a/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthCredentials+TestingOverrides.swift
+++ b/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthCredentials+TestingOverrides.swift
@@ -102,7 +102,7 @@ extension ClaudeOAuthCredentialsStore {
         }
     }
 
-    enum SecurityCLIReadOverride: Sendable {
+    enum SecurityCLIReadOverride {
         case data(Data?)
         case timedOut
         case nonZeroExit
@@ -115,6 +115,40 @@ extension ClaudeOAuthCredentialsStore {
     @TaskLocal static var taskSecurityCLIReadAccountOverride: String?
     nonisolated(unsafe) static var securityCLIReadOverride: SecurityCLIReadOverride?
 
+    public struct TestingOverridesSnapshot: Sendable {
+        let keychainOverrideStore: ClaudeKeychainOverrideStore?
+        let keychainData: Data?
+        let keychainFingerprint: ClaudeKeychainFingerprint?
+        let memoryCacheStore: MemoryCacheStore?
+        let fingerprintStore: ClaudeKeychainFingerprintStore?
+        let keychainAccessOverride: Bool?
+        let credentialsFileFingerprintStore: CredentialsFileFingerprintStore?
+        let securityCLIReadOverride: SecurityCLIReadOverride?
+        let securityCLIReadAccountOverride: String?
+
+        init(
+            keychainOverrideStore: ClaudeKeychainOverrideStore?,
+            keychainData: Data?,
+            keychainFingerprint: ClaudeKeychainFingerprint?,
+            memoryCacheStore: MemoryCacheStore?,
+            fingerprintStore: ClaudeKeychainFingerprintStore?,
+            keychainAccessOverride: Bool?,
+            credentialsFileFingerprintStore: CredentialsFileFingerprintStore?,
+            securityCLIReadOverride: SecurityCLIReadOverride?,
+            securityCLIReadAccountOverride: String?)
+        {
+            self.keychainOverrideStore = keychainOverrideStore
+            self.keychainData = keychainData
+            self.keychainFingerprint = keychainFingerprint
+            self.memoryCacheStore = memoryCacheStore
+            self.fingerprintStore = fingerprintStore
+            self.keychainAccessOverride = keychainAccessOverride
+            self.credentialsFileFingerprintStore = credentialsFileFingerprintStore
+            self.securityCLIReadOverride = securityCLIReadOverride
+            self.securityCLIReadAccountOverride = securityCLIReadAccountOverride
+        }
+    }
+
     static func withKeychainAccessOverrideForTesting<T>(
         _ disabled: Bool?,
         operation: () throws -> T) rethrows -> T
@@ -187,6 +221,10 @@ extension ClaudeOAuthCredentialsStore {
         }
     }
 
+    static func currentSecurityCLIReadOverrideForTesting() -> SecurityCLIReadOverride? {
+        self.taskSecurityCLIReadOverride ?? self.securityCLIReadOverride
+    }
+
     static func withSecurityCLIReadAccountOverrideForTesting<T>(
         _ account: String?,
         operation: () throws -> T) rethrows -> T
@@ -205,6 +243,98 @@ extension ClaudeOAuthCredentialsStore {
         }
     }
 
+    public static func withCurrentTestingOverridesForTask<T>(
+        operation: () async throws -> T) async rethrows -> T
+    {
+        try await self.withTestingOverridesSnapshotForTask(
+            self.currentTestingOverridesSnapshotForTask,
+            operation: operation)
+    }
+
+    public static func withCurrentTestingOverridesForTask<T>(
+        operation: () throws -> T) rethrows -> T
+    {
+        try self.withTestingOverridesSnapshotForTask(
+            self.currentTestingOverridesSnapshotForTask,
+            operation: operation)
+    }
+
+    public static var currentTestingOverridesSnapshotForTask: TestingOverridesSnapshot {
+        TestingOverridesSnapshot(
+            keychainOverrideStore: self.taskClaudeKeychainOverrideStore,
+            keychainData: self.taskClaudeKeychainDataOverride,
+            keychainFingerprint: self.taskClaudeKeychainFingerprintOverride,
+            memoryCacheStore: self.taskMemoryCacheStoreOverride,
+            fingerprintStore: self.taskClaudeKeychainFingerprintStoreOverride,
+            keychainAccessOverride: self.taskKeychainAccessOverride,
+            credentialsFileFingerprintStore: self.taskCredentialsFileFingerprintStoreOverride,
+            securityCLIReadOverride: self.taskSecurityCLIReadOverride,
+            securityCLIReadAccountOverride: self.taskSecurityCLIReadAccountOverride)
+    }
+
+    public static func withTestingOverridesSnapshotForTask<T>(
+        _ snapshot: TestingOverridesSnapshot,
+        operation: () async throws -> T) async rethrows -> T
+    {
+        try await self.$taskClaudeKeychainOverrideStore.withValue(snapshot.keychainOverrideStore) {
+            try await self.$taskClaudeKeychainDataOverride.withValue(snapshot.keychainData) {
+                try await self.$taskClaudeKeychainFingerprintOverride.withValue(snapshot.keychainFingerprint) {
+                    try await self.$taskMemoryCacheStoreOverride.withValue(snapshot.memoryCacheStore) {
+                        try await self.$taskClaudeKeychainFingerprintStoreOverride
+                            .withValue(snapshot.fingerprintStore) {
+                                try await self.$taskKeychainAccessOverride.withValue(snapshot.keychainAccessOverride) {
+                                    try await self.$taskCredentialsFileFingerprintStoreOverride.withValue(
+                                        snapshot.credentialsFileFingerprintStore)
+                                    {
+                                        try await self.$taskSecurityCLIReadOverride.withValue(
+                                            snapshot.securityCLIReadOverride)
+                                        {
+                                            try await self.$taskSecurityCLIReadAccountOverride.withValue(
+                                                snapshot.securityCLIReadAccountOverride)
+                                            {
+                                                try await operation()
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                    }
+                }
+            }
+        }
+    }
+
+    public static func withTestingOverridesSnapshotForTask<T>(
+        _ snapshot: TestingOverridesSnapshot,
+        operation: () throws -> T) rethrows -> T
+    {
+        try self.$taskClaudeKeychainOverrideStore.withValue(snapshot.keychainOverrideStore) {
+            try self.$taskClaudeKeychainDataOverride.withValue(snapshot.keychainData) {
+                try self.$taskClaudeKeychainFingerprintOverride.withValue(snapshot.keychainFingerprint) {
+                    try self.$taskMemoryCacheStoreOverride.withValue(snapshot.memoryCacheStore) {
+                        try self.$taskClaudeKeychainFingerprintStoreOverride.withValue(snapshot.fingerprintStore) {
+                            try self.$taskKeychainAccessOverride.withValue(snapshot.keychainAccessOverride) {
+                                try self.$taskCredentialsFileFingerprintStoreOverride.withValue(
+                                    snapshot.credentialsFileFingerprintStore)
+                                {
+                                    try self.$taskSecurityCLIReadOverride.withValue(
+                                        snapshot.securityCLIReadOverride)
+                                    {
+                                        try self.$taskSecurityCLIReadAccountOverride.withValue(
+                                            snapshot.securityCLIReadAccountOverride)
+                                        {
+                                            try operation()
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     static func setSecurityCLIReadOverrideForTesting(_ readOverride: SecurityCLIReadOverride?) {
         self.securityCLIReadOverride = readOverride
     }
diff --git a/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthCredentials.swift b/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthCredentials.swift
index e3e52c51f1..5f790ee9cb 100644
--- a/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthCredentials.swift
+++ b/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthCredentials.swift
@@ -10,7 +10,7 @@ import LocalAuthentication
 import Security
 #endif
 
-// swiftlint:disable type_body_length
+// swiftlint:disable type_body_length file_length
 public enum ClaudeOAuthCredentialsStore {
     private static let credentialsPath = ".claude/.credentials.json"
     static let claudeKeychainService = "Claude Code-credentials"
@@ -41,18 +41,18 @@ public enum ClaudeOAuthCredentialsStore {
     private static let claudeKeychainChangeCheckMinimumInterval: TimeInterval = 60
     private static let reauthenticateHint = "Run `claude` to re-authenticate."
 
-    struct ClaudeKeychainFingerprint: Codable, Equatable, Sendable {
+    struct ClaudeKeychainFingerprint: Codable, Equatable {
         let modifiedAt: Int?
         let createdAt: Int?
         let persistentRefHash: String?
     }
 
-    struct CredentialsFileFingerprint: Codable, Equatable, Sendable {
+    struct CredentialsFileFingerprint: Codable, Equatable {
         let modifiedAtMs: Int?
         let size: Int
     }
 
-    struct CacheEntry: Codable, Sendable {
+    struct CacheEntry: Codable {
         let data: Data
         let storedAt: Date
         let owner: ClaudeOAuthCredentialOwner?
@@ -100,273 +100,1003 @@ public enum ClaudeOAuthCredentialsStore {
         self.memoryCacheLock.unlock()
     }
 
-    public static func load(
-        environment: [String: String] = ProcessInfo.processInfo.environment,
-        allowKeychainPrompt: Bool = true,
-        respectKeychainPromptCooldown: Bool = false) throws -> ClaudeOAuthCredentials
-    {
-        try self.loadRecord(
-            environment: environment,
-            allowKeychainPrompt: allowKeychainPrompt,
-            respectKeychainPromptCooldown: respectKeychainPromptCooldown).credentials
-    }
+    private struct CollaboratorContext {
+        let allowBackgroundPromptBootstrap: Bool
+        #if DEBUG
+        let credentialsURLOverride: URL?
+        let testingOverrides: TestingOverridesSnapshot
+        #endif
 
-    public static func loadRecord(
-        environment: [String: String] = ProcessInfo.processInfo.environment,
-        allowKeychainPrompt: Bool = true,
-        respectKeychainPromptCooldown: Bool = false,
-        allowClaudeKeychainRepairWithoutPrompt: Bool = true) throws -> ClaudeOAuthCredentialRecord
-    {
-        // "Silent" keychain probes can still show UI on some macOS configurations. If the caller disallows prompts,
-        // always honor the Claude keychain access cooldown gate to prevent prompt storms in Auto-mode paths.
-        let shouldRespectKeychainPromptCooldownForSilentProbes = respectKeychainPromptCooldown || !allowKeychainPrompt
+        func run<T>(_ operation: () throws -> T) rethrows -> T {
+            try ClaudeOAuthCredentialsStore.$allowBackgroundPromptBootstrap
+                .withValue(self.allowBackgroundPromptBootstrap) {
+                    #if DEBUG
+                    try ClaudeOAuthCredentialsStore.withTestingOverridesSnapshotForTask(self.testingOverrides) {
+                        try ClaudeOAuthCredentialsStore
+                            .withCredentialsURLOverrideForTesting(self.credentialsURLOverride) {
+                                try operation()
+                            }
+                    }
+                    #else
+                    try operation()
+                    #endif
+                }
+        }
 
-        if let credentials = self.loadFromEnvironment(environment) {
-            return ClaudeOAuthCredentialRecord(
-                credentials: credentials,
-                owner: .environment,
-                source: .environment)
+        func run<T>(_ operation: () async throws -> T) async rethrows -> T {
+            try await ClaudeOAuthCredentialsStore.$allowBackgroundPromptBootstrap
+                .withValue(self.allowBackgroundPromptBootstrap) {
+                    #if DEBUG
+                    try await ClaudeOAuthCredentialsStore.withTestingOverridesSnapshotForTask(self.testingOverrides) {
+                        try await ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(
+                            self.credentialsURLOverride)
+                        {
+                            try await operation()
+                        }
+                    }
+                    #else
+                    try await operation()
+                    #endif
+                }
         }
+    }
 
-        _ = self.invalidateCacheIfCredentialsFileChanged()
+    private static func currentCollaboratorContext() -> CollaboratorContext {
+        #if DEBUG
+        CollaboratorContext(
+            allowBackgroundPromptBootstrap: self.allowBackgroundPromptBootstrap,
+            credentialsURLOverride: self.taskCredentialsURLOverride,
+            testingOverrides: self.currentTestingOverridesSnapshotForTask)
+        #else
+        CollaboratorContext(
+            allowBackgroundPromptBootstrap: self.allowBackgroundPromptBootstrap)
+        #endif
+    }
 
-        let memory = self.readMemoryCache()
-        if let cachedRecord = memory.record,
-           let timestamp = memory.timestamp,
-           Date().timeIntervalSince(timestamp) < self.memoryCacheValidityDuration,
-           !cachedRecord.credentials.isExpired
+    private struct Repository {
+        let context: CollaboratorContext
+
+        func load(environment: [String: String], allowKeychainPrompt: Bool, respectKeychainPromptCooldown: Bool) throws
+            -> ClaudeOAuthCredentials
         {
-            if self.shouldAttemptFreshnessSyncFromClaudeKeychain(cached: cachedRecord),
-               let synced = self.syncWithClaudeKeychainIfChanged(
-                   cached: cachedRecord,
-                   respectKeychainPromptCooldown: shouldRespectKeychainPromptCooldownForSilentProbes)
-            {
-                return synced
-            }
-            return ClaudeOAuthCredentialRecord(
-                credentials: cachedRecord.credentials,
-                owner: cachedRecord.owner,
-                source: .memoryCache)
-        }
-
-        var lastError: Error?
-        var expiredRecord: ClaudeOAuthCredentialRecord?
-
-        // 2. Try CodexBar's keychain cache (no prompts)
-        switch KeychainCacheStore.load(key: self.cacheKey, as: CacheEntry.self) {
-        case let .found(entry):
-            if let creds = try? ClaudeOAuthCredentials.parse(data: entry.data) {
-                // Legacy cache entries (pre-owner field) may contain credentials that were originally sourced from
-                // Claude Code (Keychain/file). Treating them as CodexBar-owned would re-enable direct refresh-token
-                // rotation here, which risks desyncing Claude Code (it continues to hold the old refresh token).
-                // Defaulting to `.claudeCLI` keeps refresh ownership with Claude Code.
-                let owner = entry.owner ?? .claudeCLI
-                let record = ClaudeOAuthCredentialRecord(
-                    credentials: creds,
-                    owner: owner,
-                    source: .cacheKeychain)
-                if creds.isExpired {
-                    expiredRecord = record
-                } else {
-                    if self.shouldAttemptFreshnessSyncFromClaudeKeychain(cached: record),
-                       let synced = self.syncWithClaudeKeychainIfChanged(
+            try self.loadRecord(
+                environment: environment,
+                allowKeychainPrompt: allowKeychainPrompt,
+                respectKeychainPromptCooldown: respectKeychainPromptCooldown,
+                allowClaudeKeychainRepairWithoutPrompt: true).credentials
+        }
+
+        func loadRecord(
+            environment: [String: String],
+            allowKeychainPrompt: Bool,
+            respectKeychainPromptCooldown: Bool,
+            allowClaudeKeychainRepairWithoutPrompt: Bool) throws -> ClaudeOAuthCredentialRecord
+        {
+            try self.context.run {
+                let shouldRespectKeychainPromptCooldownForSilentProbes =
+                    respectKeychainPromptCooldown || !allowKeychainPrompt
+
+                if let credentials = ClaudeOAuthCredentialsStore.loadFromEnvironment(environment) {
+                    return ClaudeOAuthCredentialRecord(
+                        credentials: credentials,
+                        owner: .environment,
+                        source: .environment)
+                }
+
+                _ = self.invalidateCacheIfCredentialsFileChanged()
+
+                let recovery = Recovery(context: self.context)
+                let memory = ClaudeOAuthCredentialsStore.readMemoryCache()
+                if let cachedRecord = memory.record,
+                   let timestamp = memory.timestamp,
+                   Date().timeIntervalSince(timestamp) < ClaudeOAuthCredentialsStore.memoryCacheValidityDuration,
+                   !cachedRecord.credentials.isExpired
+                {
+                    let owner = self.resolvedCacheOwner(cachedRecord.owner)
+                    let record = ClaudeOAuthCredentialRecord(
+                        credentials: cachedRecord.credentials,
+                        owner: owner,
+                        source: .memoryCache)
+                    if recovery.shouldAttemptFreshnessSyncFromClaudeKeychain(cached: record),
+                       let synced = recovery.syncWithClaudeKeychainIfChanged(
                            cached: record,
                            respectKeychainPromptCooldown: shouldRespectKeychainPromptCooldownForSilentProbes)
                     {
                         return synced
                     }
-                    self.writeMemoryCache(
-                        record: ClaudeOAuthCredentialRecord(
+                    return record
+                }
+
+                var lastError: Error?
+                var expiredRecord: ClaudeOAuthCredentialRecord?
+                var cacheTemporarilyUnavailable = false
+
+                switch KeychainCacheStore.load(key: ClaudeOAuthCredentialsStore.cacheKey, as: CacheEntry.self) {
+                case let .found(entry):
+                    if let creds = try? ClaudeOAuthCredentials.parse(data: entry.data) {
+                        let owner = self.resolvedCacheOwner(entry.owner ?? .claudeCLI)
+                        let record = ClaudeOAuthCredentialRecord(
                             credentials: creds,
                             owner: owner,
+                            source: .cacheKeychain)
+                        if creds.isExpired {
+                            expiredRecord = record
+                        } else {
+                            if recovery.shouldAttemptFreshnessSyncFromClaudeKeychain(cached: record),
+                               let synced = recovery.syncWithClaudeKeychainIfChanged(
+                                   cached: record,
+                                   respectKeychainPromptCooldown: shouldRespectKeychainPromptCooldownForSilentProbes)
+                            {
+                                return synced
+                            }
+                            ClaudeOAuthCredentialsStore.writeMemoryCache(
+                                record: ClaudeOAuthCredentialRecord(
+                                    credentials: creds,
+                                    owner: owner,
+                                    source: .memoryCache),
+                                timestamp: Date())
+                            return record
+                        }
+                    } else {
+                        KeychainCacheStore.clear(key: ClaudeOAuthCredentialsStore.cacheKey)
+                    }
+                case .invalid:
+                    KeychainCacheStore.clear(key: ClaudeOAuthCredentialsStore.cacheKey)
+                case .temporarilyUnavailable:
+                    cacheTemporarilyUnavailable = true
+                case .missing:
+                    break
+                }
+
+                do {
+                    let fileData = try ClaudeOAuthCredentialsStore.loadFromFile()
+                    let creds = try ClaudeOAuthCredentials.parse(data: fileData)
+                    let record = ClaudeOAuthCredentialRecord(
+                        credentials: creds,
+                        owner: .claudeCLI,
+                        source: .credentialsFile)
+                    if creds.isExpired {
+                        expiredRecord = record
+                    } else {
+                        ClaudeOAuthCredentialsStore.writeMemoryCache(
+                            record: ClaudeOAuthCredentialRecord(
+                                credentials: creds,
+                                owner: .claudeCLI,
+                                source: .memoryCache),
+                            timestamp: Date())
+                        if !cacheTemporarilyUnavailable {
+                            ClaudeOAuthCredentialsStore.saveToCacheKeychain(fileData, owner: .claudeCLI)
+                        }
+                        return record
+                    }
+                } catch let error as ClaudeOAuthCredentialsError {
+                    if case .notFound = error {
+                    } else {
+                        lastError = error
+                    }
+                } catch {
+                    lastError = error
+                }
+
+                if allowClaudeKeychainRepairWithoutPrompt, !allowKeychainPrompt {
+                    if let repaired = recovery.repairFromClaudeKeychainWithoutPromptIfAllowed(
+                        now: Date(),
+                        respectKeychainPromptCooldown: shouldRespectKeychainPromptCooldownForSilentProbes,
+                        allowCacheKeychainWrite: !cacheTemporarilyUnavailable)
+                    {
+                        return repaired
+                    }
+                }
+
+                if let prompted = self.loadFromClaudeKeychainWithPromptIfAllowed(
+                    allowKeychainPrompt: allowKeychainPrompt,
+                    respectKeychainPromptCooldown: respectKeychainPromptCooldown,
+                    allowCacheKeychainWrite: !cacheTemporarilyUnavailable,
+                    lastError: &lastError)
+                {
+                    return prompted
+                }
+
+                if let expiredRecord {
+                    return expiredRecord
+                }
+                if let lastError { throw lastError }
+                throw ClaudeOAuthCredentialsError.notFound
+            }
+        }
+
+        private func loadFromClaudeKeychainWithPromptIfAllowed(
+            allowKeychainPrompt: Bool,
+            respectKeychainPromptCooldown: Bool,
+            allowCacheKeychainWrite: Bool,
+            lastError: inout Error?) -> ClaudeOAuthCredentialRecord?
+        {
+            let shouldApplyPromptCooldown =
+                ClaudeOAuthCredentialsStore.isPromptPolicyApplicable && respectKeychainPromptCooldown
+            let promptAllowed =
+                allowKeychainPrompt
+                    && (!shouldApplyPromptCooldown || ClaudeOAuthKeychainAccessGate.shouldAllowPrompt())
+            guard promptAllowed else { return nil }
+
+            do {
+                ClaudeOAuthCredentialsStore.claudeKeychainPromptLock.lock()
+                defer { ClaudeOAuthCredentialsStore.claudeKeychainPromptLock.unlock() }
+
+                let memory = ClaudeOAuthCredentialsStore.readMemoryCache()
+                if let cachedRecord = memory.record,
+                   let timestamp = memory.timestamp,
+                   Date().timeIntervalSince(timestamp) < ClaudeOAuthCredentialsStore.memoryCacheValidityDuration,
+                   !cachedRecord.credentials.isExpired
+                {
+                    let owner = self.resolvedCacheOwner(cachedRecord.owner)
+                    return ClaudeOAuthCredentialRecord(
+                        credentials: cachedRecord.credentials,
+                        owner: owner,
+                        source: .memoryCache)
+                }
+                if case let .found(entry) = KeychainCacheStore.load(
+                    key: ClaudeOAuthCredentialsStore.cacheKey,
+                    as: CacheEntry.self),
+                    let creds = try? ClaudeOAuthCredentials.parse(data: entry.data),
+                    !creds.isExpired
+                {
+                    let owner = self.resolvedCacheOwner(entry.owner ?? .claudeCLI)
+                    return ClaudeOAuthCredentialRecord(
+                        credentials: creds,
+                        owner: owner,
+                        source: .cacheKeychain)
+                }
+
+                let promptMode = ClaudeOAuthKeychainPromptPreference.current()
+                guard ClaudeOAuthCredentialsStore.shouldAllowClaudeCodeKeychainAccess(mode: promptMode) else {
+                    return nil
+                }
+
+                if ClaudeOAuthCredentialsStore.shouldPreferSecurityCLIKeychainRead(),
+                   let keychainData = ClaudeOAuthCredentialsStore.loadFromClaudeKeychainViaSecurityCLIIfEnabled(
+                       interaction: ProviderInteractionContext.current)
+                {
+                    let creds = try ClaudeOAuthCredentials.parse(data: keychainData)
+                    let record = ClaudeOAuthCredentialRecord(
+                        credentials: creds,
+                        owner: .claudeCLI,
+                        source: .claudeKeychain)
+                    ClaudeOAuthCredentialsStore.writeMemoryCache(
+                        record: ClaudeOAuthCredentialRecord(
+                            credentials: creds,
+                            owner: .claudeCLI,
                             source: .memoryCache),
                         timestamp: Date())
+                    if allowCacheKeychainWrite {
+                        ClaudeOAuthCredentialsStore.saveToCacheKeychain(keychainData, owner: .claudeCLI)
+                    }
                     return record
                 }
-            } else {
-                KeychainCacheStore.clear(key: self.cacheKey)
-            }
-        case .invalid:
-            KeychainCacheStore.clear(key: self.cacheKey)
-        case .missing:
-            break
-        }
 
-        // 3. Try file (no keychain prompt)
-        do {
-            let fileData = try self.loadFromFile()
-            let creds = try ClaudeOAuthCredentials.parse(data: fileData)
-            let record = ClaudeOAuthCredentialRecord(
-                credentials: creds,
-                owner: .claudeCLI,
-                source: .credentialsFile)
-            if creds.isExpired {
-                expiredRecord = record
-            } else {
-                self.writeMemoryCache(
+                let shouldPreferSecurityCLIKeychainRead =
+                    ClaudeOAuthCredentialsStore.shouldPreferSecurityCLIKeychainRead()
+                var fallbackPromptMode = promptMode
+                if shouldPreferSecurityCLIKeychainRead {
+                    fallbackPromptMode = ClaudeOAuthKeychainPromptPreference.securityFrameworkFallbackMode()
+                    let fallbackDecision = ClaudeOAuthCredentialsStore.securityFrameworkFallbackPromptDecision(
+                        promptMode: fallbackPromptMode,
+                        allowKeychainPrompt: allowKeychainPrompt,
+                        respectKeychainPromptCooldown: respectKeychainPromptCooldown)
+                    ClaudeOAuthCredentialsStore.log.debug(
+                        "Claude keychain Security.framework fallback prompt policy evaluated",
+                        metadata: [
+                            "reader": "securityFrameworkFallback",
+                            "fallbackPromptMode": fallbackPromptMode.rawValue,
+                            "fallbackPromptAllowed": "\(fallbackDecision.allowed)",
+                            "fallbackBlockedReason": fallbackDecision.blockedReason ?? "none",
+                        ])
+                    guard fallbackDecision.allowed else { return nil }
+                }
+
+                if ClaudeOAuthCredentialsStore.shouldShowClaudeKeychainPreAlert() {
+                    KeychainPromptHandler.notify(
+                        KeychainPromptContext(
+                            kind: .claudeOAuth,
+                            service: ClaudeOAuthCredentialsStore.claudeKeychainService,
+                            account: nil))
+                }
+                let keychainData: Data = if shouldPreferSecurityCLIKeychainRead {
+                    try ClaudeOAuthCredentialsStore.loadFromClaudeKeychainUsingSecurityFramework(
+                        promptMode: fallbackPromptMode,
+                        allowKeychainPrompt: true)
+                } else {
+                    try ClaudeOAuthCredentialsStore.loadFromClaudeKeychain()
+                }
+                let creds = try ClaudeOAuthCredentials.parse(data: keychainData)
+                let record = ClaudeOAuthCredentialRecord(
+                    credentials: creds,
+                    owner: .claudeCLI,
+                    source: .claudeKeychain)
+                ClaudeOAuthCredentialsStore.writeMemoryCache(
                     record: ClaudeOAuthCredentialRecord(
                         credentials: creds,
                         owner: .claudeCLI,
                         source: .memoryCache),
                     timestamp: Date())
-                self.saveToCacheKeychain(fileData, owner: .claudeCLI)
+                if allowCacheKeychainWrite {
+                    ClaudeOAuthCredentialsStore.saveToCacheKeychain(keychainData, owner: .claudeCLI)
+                }
                 return record
-            }
-        } catch let error as ClaudeOAuthCredentialsError {
-            if case .notFound = error {
-                // Ignore missing file
-            } else {
+            } catch let error as ClaudeOAuthCredentialsError {
+                if case .notFound = error {
+                } else {
+                    lastError = error
+                }
+            } catch {
                 lastError = error
             }
-        } catch {
-            lastError = error
+            return nil
         }
 
-        // 3.5 Try Claude keychain without prompting (repair path; may still show UI on some systems).
-        // Only attempt this when prompts are disallowed; otherwise, go straight to the interactive path.
-        if allowClaudeKeychainRepairWithoutPrompt, !allowKeychainPrompt {
-            if let repaired = self.repairFromClaudeKeychainWithoutPromptIfAllowed(
-                now: Date(),
-                respectKeychainPromptCooldown: shouldRespectKeychainPromptCooldownForSilentProbes)
-            {
-                return repaired
+        private func resolvedCacheOwner(_ owner: ClaudeOAuthCredentialOwner) -> ClaudeOAuthCredentialOwner {
+            guard owner == .codexbar else { return owner }
+            guard self.hasClaudeCLIStorageWithoutPrompt() else { return owner }
+            // Claude Code rotates refresh tokens; when its storage exists, it owns the refresh lifecycle.
+            return .claudeCLI
+        }
+
+        private func hasClaudeCLIStorageWithoutPrompt() -> Bool {
+            if ClaudeOAuthCredentialsStore.currentFileFingerprint() != nil { return true }
+            return ClaudeOAuthCredentialsStore.hasClaudeKeychainItemWithoutPrompt()
+        }
+
+        @discardableResult
+        func invalidateCacheIfCredentialsFileChanged() -> Bool {
+            self.context.run {
+                let current = ClaudeOAuthCredentialsStore.currentFileFingerprint()
+                let stored = ClaudeOAuthCredentialsStore.loadFileFingerprint()
+                guard current != stored else { return false }
+                ClaudeOAuthCredentialsStore.log.info("Claude OAuth credentials file changed; invalidating cache")
+
+                ClaudeOAuthCredentialsStore.writeMemoryCache(record: nil, timestamp: nil)
+
+                var shouldClearKeychainCache = false
+                var shouldSaveFileFingerprint = true
+                if let current {
+                    if let modifiedAtMs = current.modifiedAtMs {
+                        let modifiedAt = Date(timeIntervalSince1970: TimeInterval(Double(modifiedAtMs) / 1000.0))
+                        switch KeychainCacheStore.load(
+                            key: ClaudeOAuthCredentialsStore.cacheKey,
+                            as: CacheEntry.self)
+                        {
+                        case let .found(entry):
+                            if entry.storedAt < modifiedAt {
+                                shouldClearKeychainCache = true
+                            }
+                        case .missing, .invalid:
+                            shouldClearKeychainCache = true
+                        case .temporarilyUnavailable:
+                            shouldClearKeychainCache = false
+                            shouldSaveFileFingerprint = false
+                        }
+                    } else {
+                        shouldClearKeychainCache = true
+                    }
+                } else {
+                    shouldClearKeychainCache = true
+                }
+
+                if shouldClearKeychainCache {
+                    ClaudeOAuthCredentialsStore.clearCacheKeychain()
+                }
+                if shouldSaveFileFingerprint {
+                    ClaudeOAuthCredentialsStore.saveFileFingerprint(current)
+                }
+                return true
             }
         }
 
-        // 4. Fall back to Claude's keychain (may prompt user if allowed)
-        if let prompted = self.loadFromClaudeKeychainWithPromptIfAllowed(
-            allowKeychainPrompt: allowKeychainPrompt,
-            respectKeychainPromptCooldown: respectKeychainPromptCooldown,
-            lastError: &lastError)
-        {
-            return prompted
+        func invalidateCache() {
+            self.context.run {
+                ClaudeOAuthCredentialsStore.writeMemoryCache(record: nil, timestamp: nil)
+                ClaudeOAuthCredentialsStore.clearCacheKeychain()
+            }
         }
 
-        if let expiredRecord {
-            return expiredRecord
+        func hasCachedCredentials(environment: [String: String]) -> Bool {
+            self.context.run {
+                func isRefreshableOrValid(_ record: ClaudeOAuthCredentialRecord) -> Bool {
+                    let creds = record.credentials
+                    if !creds.isExpired { return true }
+                    switch record.owner {
+                    case .claudeCLI:
+                        return true
+                    case .codexbar:
+                        let refreshToken = creds.refreshToken?.trimmingCharacters(
+                            in: .whitespacesAndNewlines) ?? ""
+                        return !refreshToken.isEmpty
+                    case .environment:
+                        return false
+                    }
+                }
+
+                if let creds = ClaudeOAuthCredentialsStore.loadFromEnvironment(environment),
+                   isRefreshableOrValid(
+                       ClaudeOAuthCredentialRecord(
+                           credentials: creds,
+                           owner: .environment,
+                           source: .environment))
+                {
+                    return true
+                }
+
+                let memory = ClaudeOAuthCredentialsStore.readMemoryCache()
+                if let timestamp = memory.timestamp,
+                   let cached = memory.record,
+                   Date().timeIntervalSince(timestamp) < ClaudeOAuthCredentialsStore.memoryCacheValidityDuration,
+                   isRefreshableOrValid(cached)
+                {
+                    return true
+                }
+
+                switch KeychainCacheStore.load(key: ClaudeOAuthCredentialsStore.cacheKey, as: CacheEntry.self) {
+                case let .found(entry):
+                    guard let creds = try? ClaudeOAuthCredentials.parse(data: entry.data) else { return false }
+                    let record = ClaudeOAuthCredentialRecord(
+                        credentials: creds,
+                        owner: entry.owner ?? .claudeCLI,
+                        source: .cacheKeychain)
+                    return isRefreshableOrValid(record)
+                case .temporarilyUnavailable:
+                    return true
+                default:
+                    break
+                }
+
+                if let fileData = try? ClaudeOAuthCredentialsStore.loadFromFile(),
+                   let creds = try? ClaudeOAuthCredentials.parse(data: fileData),
+                   isRefreshableOrValid(
+                       ClaudeOAuthCredentialRecord(
+                           credentials: creds,
+                           owner: .claudeCLI,
+                           source: .credentialsFile))
+                {
+                    return true
+                }
+                return false
+            }
+        }
+
+        func hasClaudeKeychainCredentialsWithoutPrompt() -> Bool {
+            self.context.run {
+                #if os(macOS)
+                let mode = ClaudeOAuthKeychainPromptPreference.current()
+                guard ClaudeOAuthCredentialsStore.shouldAllowClaudeCodeKeychainAccess(mode: mode) else { return false }
+                if ClaudeOAuthCredentialsStore.loadFromClaudeKeychainViaSecurityCLIIfEnabled(
+                    interaction: ProviderInteractionContext.current) != nil
+                {
+                    return true
+                }
+
+                let fallbackPromptMode = ClaudeOAuthKeychainPromptPreference.securityFrameworkFallbackMode()
+                guard ClaudeOAuthCredentialsStore.shouldAllowClaudeCodeKeychainAccess(mode: fallbackPromptMode) else {
+                    return false
+                }
+                if ProviderInteractionContext.current == .background,
+                   !ClaudeOAuthKeychainAccessGate.shouldAllowPrompt()
+                {
+                    return false
+                }
+                #if DEBUG
+                if let store = ClaudeOAuthCredentialsStore.taskClaudeKeychainOverrideStore,
+                   let data = store.data
+                {
+                    return (try? ClaudeOAuthCredentials.parse(data: data)) != nil
+                }
+                if let data = ClaudeOAuthCredentialsStore.taskClaudeKeychainDataOverride
+                    ?? ClaudeOAuthCredentialsStore.claudeKeychainDataOverride
+                {
+                    return (try? ClaudeOAuthCredentials.parse(data: data)) != nil
+                }
+                #endif
+
+                var query: [String: Any] = [
+                    kSecClass as String: kSecClassGenericPassword,
+                    kSecAttrService as String: ClaudeOAuthCredentialsStore.claudeKeychainService,
+                    kSecMatchLimit as String: kSecMatchLimitOne,
+                    kSecReturnAttributes as String: true,
+                ]
+                KeychainNoUIQuery.apply(to: &query)
+
+                let (status, _, durationMs) = ClaudeOAuthKeychainQueryTiming.copyMatching(query)
+                if ClaudeOAuthKeychainQueryTiming
+                    .backoffIfSlowNoUIQuery(
+                        durationMs,
+                        ClaudeOAuthCredentialsStore.claudeKeychainService,
+                        ClaudeOAuthCredentialsStore.log)
+                {
+                    return false
+                }
+                switch status {
+                case errSecSuccess, errSecInteractionNotAllowed:
+                    return true
+                case errSecUserCanceled, errSecAuthFailed, errSecNoAccessForItem:
+                    ClaudeOAuthKeychainAccessGate.recordDenied()
+                    return false
+                default:
+                    return false
+                }
+                #else
+                return false
+                #endif
+            }
         }
-        if let lastError { throw lastError }
-        throw ClaudeOAuthCredentialsError.notFound
     }
 
-    private static func loadFromClaudeKeychainWithPromptIfAllowed(
-        allowKeychainPrompt: Bool,
-        respectKeychainPromptCooldown: Bool,
-        lastError: inout Error?) -> ClaudeOAuthCredentialRecord?
-    {
-        let shouldApplyPromptCooldown = self.isPromptPolicyApplicable && respectKeychainPromptCooldown
-        let promptAllowed =
-            allowKeychainPrompt
-                && (!shouldApplyPromptCooldown || ClaudeOAuthKeychainAccessGate.shouldAllowPrompt())
-        guard promptAllowed else { return nil }
+    private struct Recovery {
+        let context: CollaboratorContext
 
-        do {
-            self.claudeKeychainPromptLock.lock()
-            defer { self.claudeKeychainPromptLock.unlock() }
-
-            // Multiple concurrent callers can all reach this point before the first one populates the cache.
-            // Re-check the cache while holding the prompt lock to avoid triggering multiple OS keychain dialogs.
-            let memory = self.readMemoryCache()
-            if let cachedRecord = memory.record,
-               let timestamp = memory.timestamp,
-               Date().timeIntervalSince(timestamp) < self.memoryCacheValidityDuration,
-               !cachedRecord.credentials.isExpired
-            {
-                return ClaudeOAuthCredentialRecord(
-                    credentials: cachedRecord.credentials,
-                    owner: cachedRecord.owner,
-                    source: .memoryCache)
+        func shouldAttemptFreshnessSyncFromClaudeKeychain(cached: ClaudeOAuthCredentialRecord) -> Bool {
+            guard !cached.credentials.isExpired else { return false }
+            guard cached.owner == .claudeCLI else { return false }
+            guard ClaudeOAuthCredentialsStore.keychainAccessAllowed else { return false }
+
+            let mode = ClaudeOAuthKeychainPromptPreference.storedMode()
+            switch mode {
+            case .never:
+                return false
+            case .onlyOnUserAction:
+                if ProviderInteractionContext.current != .userInitiated {
+                    if ProcessInfo.processInfo.environment["CODEXBAR_DEBUG_CLAUDE_OAUTH_FLOW"] == "1" {
+                        ClaudeOAuthCredentialsStore.log.debug(
+                            "Claude OAuth keychain freshness sync skipped (background)",
+                            metadata: ["promptMode": mode.rawValue, "owner": String(describing: cached.owner)])
+                    }
+                    return false
+                }
+                return true
+            case .always:
+                return true
             }
-            if case let .found(entry) = KeychainCacheStore.load(key: self.cacheKey, as: CacheEntry.self),
-               let creds = try? ClaudeOAuthCredentials.parse(data: entry.data),
-               !creds.isExpired
+        }
+
+        func syncWithClaudeKeychainIfChanged(
+            cached: ClaudeOAuthCredentialRecord,
+            respectKeychainPromptCooldown: Bool,
+            now: Date = Date()) -> ClaudeOAuthCredentialRecord?
+        {
+            #if os(macOS)
+            let mode = ClaudeOAuthKeychainPromptPreference.current()
+            guard ClaudeOAuthCredentialsStore.shouldAllowClaudeCodeKeychainAccess(mode: mode) else { return nil }
+            if ClaudeOAuthCredentialsStore.isPromptPolicyApplicable,
+               respectKeychainPromptCooldown,
+               !ClaudeOAuthKeychainAccessGate.shouldAllowPrompt(now: now)
             {
-                return ClaudeOAuthCredentialRecord(
-                    credentials: creds,
-                    owner: entry.owner ?? .claudeCLI,
-                    source: .cacheKeychain)
+                return nil
             }
 
-            let promptMode = ClaudeOAuthKeychainPromptPreference.current()
-            guard self.shouldAllowClaudeCodeKeychainAccess(mode: promptMode) else { return nil }
+            if ClaudeOAuthCredentialsStore.shouldShowClaudeKeychainPreAlert() {
+                return nil
+            }
 
-            if self.shouldPreferSecurityCLIKeychainRead(),
-               let keychainData = self.loadFromClaudeKeychainViaSecurityCLIIfEnabled(
-                   interaction: ProviderInteractionContext.current)
-            {
-                let creds = try ClaudeOAuthCredentials.parse(data: keychainData)
-                let record = ClaudeOAuthCredentialRecord(
-                    credentials: creds,
+            if !ClaudeOAuthCredentialsStore.shouldCheckClaudeKeychainChange(now: now) {
+                return nil
+            }
+
+            guard let currentFingerprint = ClaudeOAuthCredentialsStore.currentClaudeKeychainFingerprintWithoutPrompt()
+            else {
+                return nil
+            }
+            let storedFingerprint = ClaudeOAuthCredentialsStore.loadClaudeKeychainFingerprint()
+            guard currentFingerprint != storedFingerprint else { return nil }
+
+            do {
+                guard let data = try ClaudeOAuthCredentialsStore.loadFromClaudeKeychainNonInteractive() else {
+                    return nil
+                }
+                guard let keychainCreds = try? ClaudeOAuthCredentials.parse(data: data) else {
+                    ClaudeOAuthCredentialsStore.saveClaudeKeychainFingerprint(currentFingerprint)
+                    return nil
+                }
+                ClaudeOAuthCredentialsStore.saveClaudeKeychainFingerprint(currentFingerprint)
+
+                guard keychainCreds.accessToken != cached.credentials.accessToken else { return nil }
+                if keychainCreds.isExpired, !cached.credentials.isExpired { return nil }
+
+                ClaudeOAuthCredentialsStore.log.info("Claude keychain credentials changed; syncing OAuth cache")
+                let synced = ClaudeOAuthCredentialRecord(
+                    credentials: keychainCreds,
                     owner: .claudeCLI,
                     source: .claudeKeychain)
-                self.writeMemoryCache(
+                ClaudeOAuthCredentialsStore.writeMemoryCache(
                     record: ClaudeOAuthCredentialRecord(
-                        credentials: creds,
+                        credentials: keychainCreds,
                         owner: .claudeCLI,
                         source: .memoryCache),
-                    timestamp: Date())
-                self.saveToCacheKeychain(keychainData, owner: .claudeCLI)
-                return record
+                    timestamp: now)
+                ClaudeOAuthCredentialsStore.saveToCacheKeychain(data, owner: .claudeCLI)
+                return synced
+            } catch let error as ClaudeOAuthCredentialsError {
+                if case let .keychainError(status) = error,
+                   status == Int(errSecUserCanceled)
+                   || status == Int(errSecAuthFailed)
+                   || status == Int(errSecInteractionNotAllowed)
+                   || status == Int(errSecNoAccessForItem)
+                {
+                    ClaudeOAuthKeychainAccessGate.recordDenied(now: now)
+                }
+                return nil
+            } catch {
+                return nil
             }
+            #else
+            _ = cached
+            _ = respectKeychainPromptCooldown
+            _ = now
+            return nil
+            #endif
+        }
 
-            let shouldPreferSecurityCLIKeychainRead = self.shouldPreferSecurityCLIKeychainRead()
-            var fallbackPromptMode = promptMode
-            if shouldPreferSecurityCLIKeychainRead {
-                fallbackPromptMode = ClaudeOAuthKeychainPromptPreference.securityFrameworkFallbackMode()
-                let fallbackDecision = self.securityFrameworkFallbackPromptDecision(
-                    promptMode: fallbackPromptMode,
-                    allowKeychainPrompt: allowKeychainPrompt,
-                    respectKeychainPromptCooldown: respectKeychainPromptCooldown)
-                self.log.debug(
-                    "Claude keychain Security.framework fallback prompt policy evaluated",
-                    metadata: [
-                        "reader": "securityFrameworkFallback",
-                        "fallbackPromptMode": fallbackPromptMode.rawValue,
-                        "fallbackPromptAllowed": "\(fallbackDecision.allowed)",
-                        "fallbackBlockedReason": fallbackDecision.blockedReason ?? "none",
-                    ])
-                guard fallbackDecision.allowed else { return nil }
-            }
+        func repairFromClaudeKeychainWithoutPromptIfAllowed(
+            now: Date,
+            respectKeychainPromptCooldown: Bool,
+            allowCacheKeychainWrite: Bool = true) -> ClaudeOAuthCredentialRecord?
+        {
+            #if os(macOS)
+            let mode = ClaudeOAuthKeychainPromptPreference.current()
+            guard ClaudeOAuthCredentialsStore.shouldAllowClaudeCodeKeychainAccess(mode: mode) else { return nil }
 
-            // Some macOS configurations still show the system keychain prompt even for our "silent" probes.
-            // Only show the in-app pre-alert when we have evidence that Keychain interaction is likely.
-            if self.shouldShowClaudeKeychainPreAlert() {
-                KeychainPromptHandler.notify(
-                    KeychainPromptContext(
-                        kind: .claudeOAuth,
-                        service: self.claudeKeychainService,
-                        account: nil))
+            if ClaudeOAuthCredentialsStore.shouldShowClaudeKeychainPreAlert() {
+                return nil
             }
-            let keychainData: Data = if shouldPreferSecurityCLIKeychainRead {
-                try self.loadFromClaudeKeychainUsingSecurityFramework(
-                    promptMode: fallbackPromptMode,
-                    allowKeychainPrompt: true)
-            } else {
-                try self.loadFromClaudeKeychain()
+
+            if ClaudeOAuthCredentialsStore.isPromptPolicyApplicable,
+               respectKeychainPromptCooldown,
+               ProviderInteractionContext.current != .userInitiated,
+               !ClaudeOAuthKeychainAccessGate.shouldAllowPrompt(now: now)
+            {
+                return nil
             }
-            let creds = try ClaudeOAuthCredentials.parse(data: keychainData)
-            let record = ClaudeOAuthCredentialRecord(
-                credentials: creds,
-                owner: .claudeCLI,
-                source: .claudeKeychain)
-            self.writeMemoryCache(
-                record: ClaudeOAuthCredentialRecord(
+
+            do {
+                if ClaudeOAuthCredentialsStore.shouldPreferSecurityCLIKeychainRead(),
+                   let securityData = ClaudeOAuthCredentialsStore.loadFromClaudeKeychainViaSecurityCLIIfEnabled(
+                       interaction: ProviderInteractionContext.current),
+                   !securityData.isEmpty
+                {
+                    guard let creds = try? ClaudeOAuthCredentials.parse(data: securityData) else { return nil }
+                    if creds.isExpired {
+                        return ClaudeOAuthCredentialRecord(
+                            credentials: creds,
+                            owner: .claudeCLI,
+                            source: .claudeKeychain)
+                    }
+
+                    ClaudeOAuthCredentialsStore.writeMemoryCache(
+                        record: ClaudeOAuthCredentialRecord(
+                            credentials: creds,
+                            owner: .claudeCLI,
+                            source: .memoryCache),
+                        timestamp: now)
+                    if allowCacheKeychainWrite {
+                        ClaudeOAuthCredentialsStore.saveToCacheKeychain(securityData, owner: .claudeCLI)
+                    }
+
+                    ClaudeOAuthCredentialsStore.log.info(
+                        "Claude keychain credentials loaded without prompt; syncing OAuth cache",
+                        metadata: ["interaction": ProviderInteractionContext.current == .userInitiated
+                            ? "user" : "background"])
+                    return ClaudeOAuthCredentialRecord(
+                        credentials: creds,
+                        owner: .claudeCLI,
+                        source: .claudeKeychain)
+                }
+
+                guard let data = try ClaudeOAuthCredentialsStore.loadFromClaudeKeychainNonInteractive(),
+                      !data.isEmpty
+                else {
+                    return nil
+                }
+                let fingerprint = ClaudeOAuthCredentialsStore.currentClaudeKeychainFingerprintWithoutPrompt()
+                guard let creds = try? ClaudeOAuthCredentials.parse(data: data) else {
+                    ClaudeOAuthCredentialsStore.saveClaudeKeychainFingerprint(fingerprint)
+                    return nil
+                }
+
+                if creds.isExpired {
+                    ClaudeOAuthCredentialsStore.saveClaudeKeychainFingerprint(fingerprint)
+                    return ClaudeOAuthCredentialRecord(
+                        credentials: creds,
+                        owner: .claudeCLI,
+                        source: .claudeKeychain)
+                }
+
+                ClaudeOAuthCredentialsStore.saveClaudeKeychainFingerprint(fingerprint)
+                ClaudeOAuthCredentialsStore.writeMemoryCache(
+                    record: ClaudeOAuthCredentialRecord(
+                        credentials: creds,
+                        owner: .claudeCLI,
+                        source: .memoryCache),
+                    timestamp: now)
+                if allowCacheKeychainWrite {
+                    ClaudeOAuthCredentialsStore.saveToCacheKeychain(data, owner: .claudeCLI)
+                }
+
+                ClaudeOAuthCredentialsStore.log.info(
+                    "Claude keychain credentials loaded without prompt; syncing OAuth cache",
+                    metadata: ["interaction": ProviderInteractionContext.current == .userInitiated
+                        ? "user" : "background"])
+                return ClaudeOAuthCredentialRecord(
                     credentials: creds,
                     owner: .claudeCLI,
-                    source: .memoryCache),
-                timestamp: Date())
-            self.saveToCacheKeychain(keychainData, owner: .claudeCLI)
-            return record
-        } catch let error as ClaudeOAuthCredentialsError {
-            if case .notFound = error {
-                // Ignore missing entry
-            } else {
-                lastError = error
+                    source: .claudeKeychain)
+            } catch let error as ClaudeOAuthCredentialsError {
+                if case let .keychainError(status) = error,
+                   status == Int(errSecUserCanceled)
+                   || status == Int(errSecAuthFailed)
+                   || status == Int(errSecInteractionNotAllowed)
+                   || status == Int(errSecNoAccessForItem)
+                {
+                    ClaudeOAuthKeychainAccessGate.recordDenied(now: now)
+                }
+                return nil
+            } catch {
+                return nil
+            }
+            #else
+            _ = now
+            _ = respectKeychainPromptCooldown
+            return nil
+            #endif
+        }
+
+        @discardableResult
+        func syncFromClaudeKeychainWithoutPrompt(now: Date = Date()) -> Bool {
+            self.context.run {
+                #if os(macOS)
+                let mode = ClaudeOAuthKeychainPromptPreference.current()
+                guard ClaudeOAuthCredentialsStore.shouldAllowClaudeCodeKeychainAccess(mode: mode) else { return false }
+
+                if let data = ClaudeOAuthCredentialsStore.loadFromClaudeKeychainViaSecurityCLIIfEnabled(
+                    interaction: ProviderInteractionContext.current),
+                    !data.isEmpty
+                {
+                    if let creds = try? ClaudeOAuthCredentials.parse(data: data), !creds.isExpired {
+                        ClaudeOAuthCredentialsStore.writeMemoryCache(
+                            record: ClaudeOAuthCredentialRecord(
+                                credentials: creds,
+                                owner: .claudeCLI,
+                                source: .memoryCache),
+                            timestamp: now)
+                        ClaudeOAuthCredentialsStore.saveToCacheKeychain(data, owner: .claudeCLI)
+                        return true
+                    }
+                }
+
+                let fallbackPromptMode = ClaudeOAuthKeychainPromptPreference.securityFrameworkFallbackMode()
+                guard ClaudeOAuthCredentialsStore.shouldAllowClaudeCodeKeychainAccess(mode: fallbackPromptMode) else {
+                    return false
+                }
+
+                if ProviderInteractionContext.current == .background,
+                   !ClaudeOAuthKeychainAccessGate.shouldAllowPrompt(now: now)
+                {
+                    return false
+                }
+
+                #if DEBUG
+                let override = ClaudeOAuthCredentialsStore.taskClaudeKeychainOverrideStore?.data
+                    ?? ClaudeOAuthCredentialsStore.taskClaudeKeychainDataOverride
+                    ?? ClaudeOAuthCredentialsStore.claudeKeychainDataOverride
+                if let override,
+                   !override.isEmpty,
+                   let creds = try? ClaudeOAuthCredentials.parse(data: override),
+                   !creds.isExpired
+                {
+                    ClaudeOAuthCredentialsStore.saveClaudeKeychainFingerprint(
+                        ClaudeOAuthCredentialsStore.currentClaudeKeychainFingerprintWithoutPrompt())
+                    ClaudeOAuthCredentialsStore.writeMemoryCache(
+                        record: ClaudeOAuthCredentialRecord(
+                            credentials: creds,
+                            owner: .claudeCLI,
+                            source: .memoryCache),
+                        timestamp: now)
+                    ClaudeOAuthCredentialsStore.saveToCacheKeychain(override, owner: .claudeCLI)
+                    return true
+                }
+                #endif
+
+                if ClaudeOAuthCredentialsStore.shouldShowClaudeKeychainPreAlert() {
+                    return false
+                }
+
+                if let candidate = ClaudeOAuthCredentialsStore.claudeKeychainCandidatesWithoutPrompt(
+                    promptMode: fallbackPromptMode).first,
+                    let data = try? ClaudeOAuthCredentialsStore.loadClaudeKeychainData(
+                        candidate: candidate,
+                        allowKeychainPrompt: false),
+                    !data.isEmpty
+                {
+                    let fingerprint = ClaudeKeychainFingerprint(
+                        modifiedAt: candidate.modifiedAt.map { Int($0.timeIntervalSince1970) },
+                        createdAt: candidate.createdAt.map { Int($0.timeIntervalSince1970) },
+                        persistentRefHash: ClaudeOAuthCredentialsStore.sha256Prefix(candidate.persistentRef))
+
+                    if let creds = try? ClaudeOAuthCredentials.parse(data: data), !creds.isExpired {
+                        ClaudeOAuthCredentialsStore.saveClaudeKeychainFingerprint(fingerprint)
+                        ClaudeOAuthCredentialsStore.writeMemoryCache(
+                            record: ClaudeOAuthCredentialRecord(
+                                credentials: creds,
+                                owner: .claudeCLI,
+                                source: .memoryCache),
+                            timestamp: now)
+                        ClaudeOAuthCredentialsStore.saveToCacheKeychain(data, owner: .claudeCLI)
+                        return true
+                    }
+
+                    ClaudeOAuthCredentialsStore.saveClaudeKeychainFingerprint(fingerprint)
+                }
+
+                let legacyData = try? ClaudeOAuthCredentialsStore.loadClaudeKeychainLegacyData(
+                    allowKeychainPrompt: false,
+                    promptMode: fallbackPromptMode)
+                if let legacyData,
+                   !legacyData.isEmpty,
+                   let creds = try? ClaudeOAuthCredentials.parse(data: legacyData),
+                   !creds.isExpired
+                {
+                    ClaudeOAuthCredentialsStore.saveClaudeKeychainFingerprint(
+                        ClaudeOAuthCredentialsStore.currentClaudeKeychainFingerprintWithoutPrompt())
+                    ClaudeOAuthCredentialsStore.writeMemoryCache(
+                        record: ClaudeOAuthCredentialRecord(
+                            credentials: creds,
+                            owner: .claudeCLI,
+                            source: .memoryCache),
+                        timestamp: now)
+                    ClaudeOAuthCredentialsStore.saveToCacheKeychain(legacyData, owner: .claudeCLI)
+                    return true
+                }
+
+                return false
+                #else
+                _ = now
+                return false
+                #endif
             }
-        } catch {
-            lastError = error
         }
-        return nil
+    }
+
+    private struct Refresher {
+        let context: CollaboratorContext
+
+        func refreshAccessToken(
+            refreshToken: String,
+            existingScopes: [String],
+            existingRateLimitTier: String?,
+            existingSubscriptionType: String? = nil) async throws -> ClaudeOAuthCredentials
+        {
+            try await self.context.run {
+                let newCredentials = try await self.refreshAccessTokenCore(
+                    refreshToken: refreshToken,
+                    existingScopes: existingScopes,
+                    existingRateLimitTier: existingRateLimitTier,
+                    existingSubscriptionType: existingSubscriptionType)
+
+                ClaudeOAuthCredentialsStore.saveRefreshedCredentialsToCache(newCredentials)
+                ClaudeOAuthCredentialsStore.writeMemoryCache(
+                    record: ClaudeOAuthCredentialRecord(
+                        credentials: newCredentials,
+                        owner: .codexbar,
+                        source: .memoryCache),
+                    timestamp: Date())
+                ClaudeOAuthRefreshFailureGate.recordSuccess()
+
+                return newCredentials
+            }
+        }
+
+        private func refreshAccessTokenCore(
+            refreshToken: String,
+            existingScopes: [String],
+            existingRateLimitTier: String?,
+            existingSubscriptionType: String?) async throws -> ClaudeOAuthCredentials
+        {
+            guard ClaudeOAuthRefreshFailureGate.shouldAttempt() else {
+                let status = ClaudeOAuthRefreshFailureGate.currentBlockStatus()
+                let message = switch status {
+                case .terminal:
+                    "Claude OAuth refresh blocked until auth changes. \(ClaudeOAuthCredentialsStore.reauthenticateHint)"
+                case .transient:
+                    "Claude OAuth refresh temporarily backed off due to prior failures; will retry automatically."
+                case nil:
+                    "Claude OAuth refresh temporarily suppressed due to prior failures; will retry automatically."
+                }
+                throw ClaudeOAuthCredentialsError.refreshFailed(message)
+            }
+
+            guard let url = URL(string: ClaudeOAuthCredentialsStore.tokenRefreshEndpoint) else {
+                throw ClaudeOAuthCredentialsError.refreshFailed("Invalid token endpoint URL")
+            }
+
+            var request = URLRequest(url: url)
+            request.httpMethod = "POST"
+            request.timeoutInterval = 30
+            request.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
+            request.setValue("application/json", forHTTPHeaderField: "Accept")
+
+            var components = URLComponents()
+            components.queryItems = [
+                URLQueryItem(name: "grant_type", value: "refresh_token"),
+                URLQueryItem(name: "refresh_token", value: refreshToken),
+                URLQueryItem(name: "client_id", value: ClaudeOAuthCredentialsStore.oauthClientID),
+            ]
+            request.httpBody = (components.percentEncodedQuery ?? "").data(using: .utf8)
+
+            let response = try await ProviderHTTPClient.shared.response(for: request)
+            let data = response.data
+            guard response.statusCode == 200 else {
+                if let disposition = ClaudeOAuthCredentialsStore.refreshFailureDisposition(
+                    statusCode: response.statusCode,
+                    data: data)
+                {
+                    let oauthError = ClaudeOAuthCredentialsStore.extractOAuthErrorCode(from: data)
+                    ClaudeOAuthCredentialsStore.log.info(
+                        "Claude OAuth refresh rejected",
+                        metadata: [
+                            "httpStatus": "\(response.statusCode)",
+                            "oauthError": oauthError ?? "nil",
+                            "disposition": disposition.rawValue,
+                        ])
+
+                    switch disposition {
+                    case .terminalInvalidGrant:
+                        ClaudeOAuthRefreshFailureGate.recordTerminalAuthFailure()
+                        Repository(context: self.context).invalidateCache()
+                        let message = "HTTP \(response.statusCode) invalid_grant. " +
+                            ClaudeOAuthCredentialsStore.reauthenticateHint
+                        throw ClaudeOAuthCredentialsError.refreshFailed(
+                            message)
+                    case .transientBackoff:
+                        ClaudeOAuthRefreshFailureGate.recordTransientFailure()
+                        let suffix = oauthError.map { " (\($0))" } ?? ""
+                        throw ClaudeOAuthCredentialsError.refreshFailed("HTTP \(response.statusCode)\(suffix)")
+                    }
+                }
+                throw ClaudeOAuthCredentialsError.refreshFailed("HTTP \(response.statusCode)")
+            }
+
+            let tokenResponse = try JSONDecoder().decode(TokenRefreshResponse.self, from: data)
+            let expiresAt = Date(timeIntervalSinceNow: TimeInterval(tokenResponse.expiresIn))
+
+            return ClaudeOAuthCredentials(
+                accessToken: tokenResponse.accessToken,
+                refreshToken: tokenResponse.refreshToken ?? refreshToken,
+                expiresAt: expiresAt,
+                scopes: existingScopes,
+                rateLimitTier: existingRateLimitTier,
+                subscriptionType: existingSubscriptionType)
+        }
+    }
+
+    public static func load(
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        allowKeychainPrompt: Bool = true,
+        respectKeychainPromptCooldown: Bool = false) throws -> ClaudeOAuthCredentials
+    {
+        let context = self.currentCollaboratorContext()
+        return try Repository(context: context).load(
+            environment: environment,
+            allowKeychainPrompt: allowKeychainPrompt,
+            respectKeychainPromptCooldown: respectKeychainPromptCooldown)
+    }
+
+    public static func loadRecord(
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        allowKeychainPrompt: Bool = true,
+        respectKeychainPromptCooldown: Bool = false,
+        allowClaudeKeychainRepairWithoutPrompt: Bool = true) throws -> ClaudeOAuthCredentialRecord
+    {
+        let context = self.currentCollaboratorContext()
+        return try Repository(context: context).loadRecord(
+            environment: environment,
+            allowKeychainPrompt: allowKeychainPrompt,
+            respectKeychainPromptCooldown: respectKeychainPromptCooldown,
+            allowClaudeKeychainRepairWithoutPrompt: allowClaudeKeychainRepairWithoutPrompt)
     }
 
     /// Async version of load that handles expired tokens based on credential ownership.
@@ -377,10 +1107,14 @@ public enum ClaudeOAuthCredentialsStore {
         allowKeychainPrompt: Bool = true,
         respectKeychainPromptCooldown: Bool = false) async throws -> ClaudeOAuthCredentials
     {
-        let record = try self.loadRecord(
+        let context = self.currentCollaboratorContext()
+        let repository = Repository(context: context)
+        let refresher = Refresher(context: context)
+        let record = try repository.loadRecord(
             environment: environment,
             allowKeychainPrompt: allowKeychainPrompt,
-            respectKeychainPromptCooldown: respectKeychainPromptCooldown)
+            respectKeychainPromptCooldown: respectKeychainPromptCooldown,
+            allowClaudeKeychainRepairWithoutPrompt: true)
         let credentials = record.credentials
         let now = Date()
         var expiryMetadata = credentials.diagnosticsMetadata(now: now)
@@ -425,430 +1159,183 @@ public enum ClaudeOAuthCredentialsStore {
         self.log.info("Access token expired, attempting auto-refresh")
 
         do {
-            let refreshed = try await self.refreshAccessToken(
+            let refreshed = try await refresher.refreshAccessToken(
                 refreshToken: refreshToken,
                 existingScopes: credentials.scopes,
-                existingRateLimitTier: credentials.rateLimitTier)
-            self.log.info("Token refresh successful, expires in \(refreshed.expiresIn ?? 0) seconds")
-            return refreshed
-        } catch {
-            self.log.error("Token refresh failed: \(error.localizedDescription)")
-            throw error
-        }
-    }
-
-    /// Save refreshed credentials to CodexBar's keychain cache
-    private static func saveRefreshedCredentialsToCache(_ credentials: ClaudeOAuthCredentials) {
-        var oauth: [String: Any] = [
-            "accessToken": credentials.accessToken,
-            "expiresAt": (credentials.expiresAt?.timeIntervalSince1970 ?? 0) * 1000,
-            "scopes": credentials.scopes,
-        ]
-
-        if let refreshToken = credentials.refreshToken {
-            oauth["refreshToken"] = refreshToken
-        }
-        if let rateLimitTier = credentials.rateLimitTier {
-            oauth["rateLimitTier"] = rateLimitTier
-        }
-
-        let oauthData: [String: Any] = ["claudeAiOauth": oauth]
-
-        guard let jsonData = try? JSONSerialization.data(withJSONObject: oauthData) else {
-            self.log.error("Failed to serialize refreshed credentials for cache")
-            return
-        }
-
-        self.saveToCacheKeychain(jsonData, owner: .codexbar)
-        self.log.debug("Saved refreshed credentials to CodexBar keychain cache")
-    }
-
-    /// Response from the OAuth token refresh endpoint
-    private struct TokenRefreshResponse: Decodable {
-        let accessToken: String
-        let refreshToken: String?
-        let expiresIn: Int
-        let tokenType: String?
-
-        enum CodingKeys: String, CodingKey {
-            case accessToken = "access_token"
-            case refreshToken = "refresh_token"
-            case expiresIn = "expires_in"
-            case tokenType = "token_type"
-        }
-    }
-
-    public static func loadFromFile() throws -> Data {
-        let url = self.credentialsFileURL()
-        do {
-            return try Data(contentsOf: url)
-        } catch {
-            if (error as NSError).code == NSFileReadNoSuchFileError {
-                throw ClaudeOAuthCredentialsError.notFound
-            }
-            throw ClaudeOAuthCredentialsError.readFailed(error.localizedDescription)
-        }
-    }
-
-    @discardableResult
-    public static func invalidateCacheIfCredentialsFileChanged() -> Bool {
-        let current = self.currentFileFingerprint()
-        let stored = self.loadFileFingerprint()
-        guard current != stored else { return false }
-        self.saveFileFingerprint(current)
-        self.log.info("Claude OAuth credentials file changed; invalidating cache")
-        // The credentials file can be stale (or even unrelated) compared to what we’ve already cached from the
-        // keychain. Clearing the keychain cache unconditionally can cause us to prefer an expired file over a
-        // still-valid cached token.
-        //
-        // We always drop the in-memory cache. The keychain cache is only cleared when it is older than the
-        // credentials file (or the file disappeared), so we still pick up fresh file updates on next load.
-        self.writeMemoryCache(record: nil, timestamp: nil)
-
-        var shouldClearKeychainCache = false
-        if let current {
-            if let modifiedAtMs = current.modifiedAtMs {
-                let modifiedAt = Date(timeIntervalSince1970: TimeInterval(Double(modifiedAtMs) / 1000.0))
-                if case let .found(entry) = KeychainCacheStore.load(key: self.cacheKey, as: CacheEntry.self) {
-                    if entry.storedAt < modifiedAt {
-                        shouldClearKeychainCache = true
-                    }
-                } else {
-                    // If we can’t load the cache entry, there’s nothing meaningful to preserve here.
-                    shouldClearKeychainCache = true
-                }
-            } else {
-                // If we can’t compare timestamps, be conservative and clear the keychain cache.
-                shouldClearKeychainCache = true
-            }
-        } else {
-            // File was removed; cached values are likely stale (e.g. logout).
-            shouldClearKeychainCache = true
-        }
-
-        if shouldClearKeychainCache {
-            self.clearCacheKeychain()
-        }
-        return true
-    }
-
-    /// Invalidate the credentials cache (call after login/logout)
-    public static func invalidateCache() {
-        self.writeMemoryCache(record: nil, timestamp: nil)
-        self.clearCacheKeychain()
-    }
-
-    /// Check if CodexBar has cached credentials (in memory or keychain cache)
-    public static func hasCachedCredentials(environment: [String: String] = ProcessInfo.processInfo
-        .environment) -> Bool
-    {
-        func isRefreshableOrValid(_ record: ClaudeOAuthCredentialRecord) -> Bool {
-            let creds = record.credentials
-            if !creds.isExpired { return true }
-            switch record.owner {
-            case .claudeCLI:
-                // Claude CLI can refresh its own credentials once invoked, even if no refresh token is visible here.
-                return true
-            case .codexbar:
-                let refreshToken = creds.refreshToken?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
-                return !refreshToken.isEmpty
-            case .environment:
-                return false
-            }
-        }
-
-        if let creds = self.loadFromEnvironment(environment),
-           isRefreshableOrValid(ClaudeOAuthCredentialRecord(
-               credentials: creds,
-               owner: .environment,
-               source: .environment))
-        {
-            return true
-        }
-
-        // Check in-memory cache
-        let memory = self.readMemoryCache()
-        if let timestamp = memory.timestamp,
-           let cached = memory.record,
-           Date().timeIntervalSince(timestamp) < self.memoryCacheValidityDuration,
-           isRefreshableOrValid(cached)
-        {
-            return true
-        }
-        // Check keychain cache (must be parseable; may be expired but still refreshable without prompting)
-        switch KeychainCacheStore.load(key: self.cacheKey, as: CacheEntry.self) {
-        case let .found(entry):
-            guard let creds = try? ClaudeOAuthCredentials.parse(data: entry.data) else { return false }
-            let record = ClaudeOAuthCredentialRecord(
-                credentials: creds,
-                owner: entry.owner ?? .claudeCLI,
-                source: .cacheKeychain)
-            return isRefreshableOrValid(record)
-        default:
-            break
-        }
-
-        // Check credentials file (no prompts)
-        if let fileData = try? self.loadFromFile(),
-           let creds = try? ClaudeOAuthCredentials.parse(data: fileData),
-           isRefreshableOrValid(ClaudeOAuthCredentialRecord(
-               credentials: creds,
-               owner: .claudeCLI,
-               source: .credentialsFile))
-        {
-            return true
-        }
-        return false
-    }
-
-    public static func hasClaudeKeychainCredentialsWithoutPrompt() -> Bool {
-        #if os(macOS)
-        let mode = ClaudeOAuthKeychainPromptPreference.current()
-        guard self.shouldAllowClaudeCodeKeychainAccess(mode: mode) else { return false }
-        if self.loadFromClaudeKeychainViaSecurityCLIIfEnabled(
-            interaction: ProviderInteractionContext.current) != nil
-        {
-            return true
-        }
-
-        let fallbackPromptMode = ClaudeOAuthKeychainPromptPreference.securityFrameworkFallbackMode()
-        guard self.shouldAllowClaudeCodeKeychainAccess(mode: fallbackPromptMode) else { return false }
-        if ProviderInteractionContext.current == .background,
-           !ClaudeOAuthKeychainAccessGate.shouldAllowPrompt() { return false }
-        #if DEBUG
-        if let store = self.taskClaudeKeychainOverrideStore,
-           let data = store.data
-        {
-            return (try? ClaudeOAuthCredentials.parse(data: data)) != nil
-        }
-        if let data = self.taskClaudeKeychainDataOverride ?? self.claudeKeychainDataOverride {
-            return (try? ClaudeOAuthCredentials.parse(data: data)) != nil
-        }
-        #endif
-
-        var query: [String: Any] = [
-            kSecClass as String: kSecClassGenericPassword,
-            kSecAttrService as String: self.claudeKeychainService,
-            kSecMatchLimit as String: kSecMatchLimitOne,
-            kSecReturnAttributes as String: true,
-        ]
-        KeychainNoUIQuery.apply(to: &query)
-
-        let (status, _, durationMs) = ClaudeOAuthKeychainQueryTiming.copyMatching(query)
-        if ClaudeOAuthKeychainQueryTiming
-            .backoffIfSlowNoUIQuery(durationMs, self.claudeKeychainService, self.log) { return false }
-        switch status {
-        case errSecSuccess, errSecInteractionNotAllowed:
-            return true
-        case errSecUserCanceled, errSecAuthFailed, errSecNoAccessForItem:
-            // Treat denial as "not available" and record a cooldown to avoid prompt storms in Auto mode.
-            ClaudeOAuthKeychainAccessGate.recordDenied()
-            return false
-        default:
-            return false
-        }
-        #else
-        return false
-        #endif
-    }
-
-    private static func syncWithClaudeKeychainIfChanged(
-        cached: ClaudeOAuthCredentialRecord,
-        respectKeychainPromptCooldown: Bool,
-        now: Date = Date()) -> ClaudeOAuthCredentialRecord?
-    {
-        #if os(macOS)
-        let mode = ClaudeOAuthKeychainPromptPreference.current()
-        guard self.shouldAllowClaudeCodeKeychainAccess(mode: mode) else { return nil }
-        if self.isPromptPolicyApplicable,
-           respectKeychainPromptCooldown,
-           !ClaudeOAuthKeychainAccessGate.shouldAllowPrompt(now: now)
-        {
-            return nil
+                existingRateLimitTier: credentials.rateLimitTier,
+                existingSubscriptionType: credentials.subscriptionType)
+            self.log.info("Token refresh successful, expires in \(refreshed.expiresIn ?? 0) seconds")
+            return refreshed
+        } catch {
+            self.log.error("Token refresh failed: \(error.localizedDescription)")
+            throw error
         }
+    }
 
-        // Do not attempt a non-interactive data read if preflight indicates interaction is likely.
-        // Why: on some systems, Security.framework can still surface UI even for "no UI" queries.
-        if self.shouldShowClaudeKeychainPreAlert() {
-            return nil
+    /// Save refreshed credentials to CodexBar's keychain cache
+    private static func saveRefreshedCredentialsToCache(_ credentials: ClaudeOAuthCredentials) {
+        var oauth: [String: Any] = [
+            "accessToken": credentials.accessToken,
+            "expiresAt": (credentials.expiresAt?.timeIntervalSince1970 ?? 0) * 1000,
+            "scopes": credentials.scopes,
+        ]
+
+        if let refreshToken = credentials.refreshToken {
+            oauth["refreshToken"] = refreshToken
+        }
+        if let rateLimitTier = credentials.rateLimitTier {
+            oauth["rateLimitTier"] = rateLimitTier
+        }
+        if let subscriptionType = credentials.subscriptionType {
+            oauth["subscriptionType"] = subscriptionType
         }
 
-        if !self.shouldCheckClaudeKeychainChange(now: now) {
-            return nil
+        let oauthData: [String: Any] = ["claudeAiOauth": oauth]
+
+        guard let jsonData = try? JSONSerialization.data(withJSONObject: oauthData) else {
+            self.log.error("Failed to serialize refreshed credentials for cache")
+            return
         }
 
-        guard let currentFingerprint = self.currentClaudeKeychainFingerprintWithoutPrompt() else {
-            return nil
+        self.saveToCacheKeychain(jsonData, owner: .codexbar)
+        self.log.debug("Saved refreshed credentials to CodexBar keychain cache")
+    }
+
+    /// Response from the OAuth token refresh endpoint
+    private struct TokenRefreshResponse: Decodable {
+        let accessToken: String
+        let refreshToken: String?
+        let expiresIn: Int
+        let tokenType: String?
+
+        enum CodingKeys: String, CodingKey {
+            case accessToken = "access_token"
+            case refreshToken = "refresh_token"
+            case expiresIn = "expires_in"
+            case tokenType = "token_type"
         }
-        let storedFingerprint = self.loadClaudeKeychainFingerprint()
-        guard currentFingerprint != storedFingerprint else { return nil }
+    }
 
+    public static func loadFromFile() throws -> Data {
+        let url = self.credentialsFileURL()
         do {
-            guard let data = try self.loadFromClaudeKeychainNonInteractive() else {
-                return nil
-            }
-            guard let keychainCreds = try? ClaudeOAuthCredentials.parse(data: data) else {
-                self.saveClaudeKeychainFingerprint(currentFingerprint)
-                return nil
-            }
-            self.saveClaudeKeychainFingerprint(currentFingerprint)
-
-            // Only sync if token actually changed to avoid churn on unrelated keychain metadata updates.
-            guard keychainCreds.accessToken != cached.credentials.accessToken else { return nil }
-            // Avoid regressing a working cached token if the keychain entry looks invalid/expired.
-            if keychainCreds.isExpired, !cached.credentials.isExpired { return nil }
-
-            self.log.info("Claude keychain credentials changed; syncing OAuth cache")
-            let synced = ClaudeOAuthCredentialRecord(
-                credentials: keychainCreds,
-                owner: .claudeCLI,
-                source: .claudeKeychain)
-            self.writeMemoryCache(
-                record: ClaudeOAuthCredentialRecord(
-                    credentials: keychainCreds,
-                    owner: .claudeCLI,
-                    source: .memoryCache),
-                timestamp: now)
-            self.saveToCacheKeychain(data, owner: .claudeCLI)
-            return synced
-        } catch let error as ClaudeOAuthCredentialsError {
-            if case let .keychainError(status) = error,
-               status == Int(errSecUserCanceled)
-               || status == Int(errSecAuthFailed)
-               || status == Int(errSecInteractionNotAllowed)
-               || status == Int(errSecNoAccessForItem)
-            {
-                // Back off to avoid repeated keychain probes on systems that still show prompts.
-                ClaudeOAuthKeychainAccessGate.recordDenied(now: now)
-            }
-            return nil
+            return try Data(contentsOf: url)
         } catch {
-            return nil
+            if (error as NSError).code == NSFileReadNoSuchFileError {
+                throw ClaudeOAuthCredentialsError.notFound
+            }
+            throw ClaudeOAuthCredentialsError.readFailed(error.localizedDescription)
         }
-        #else
-        _ = cached
-        _ = respectKeychainPromptCooldown
-        _ = now
-        return nil
-        #endif
     }
 
-    private static func shouldAttemptFreshnessSyncFromClaudeKeychain(cached: ClaudeOAuthCredentialRecord) -> Bool {
-        guard !cached.credentials.isExpired else { return false }
-        guard cached.owner == .claudeCLI else { return false }
-        guard self.keychainAccessAllowed else { return false }
+    public static func credentialsFileFingerprintToken() -> String? {
+        guard let fingerprint = self.currentFileFingerprint() else { return nil }
+        let modifiedAt = fingerprint.modifiedAtMs.map(String.init) ?? "nil"
+        return "\(modifiedAt):\(fingerprint.size)"
+    }
 
-        // Freshness sync is opportunistic and may perform Security.framework fingerprint checks.
-        // Keep this gated by the user's stored prompt policy even in experimental reader mode.
-        let mode = ClaudeOAuthKeychainPromptPreference.storedMode()
-        switch mode {
-        case .never:
+    public static func authFingerprintToken() -> String {
+        let file = self.credentialsFileFingerprintToken() ?? "nil"
+        let keychain = self.claudeKeychainFingerprintToken() ?? "nil"
+        return "file=\(file)|keychain=\(keychain)"
+    }
+
+    public static func consumeClaudeKeychainFingerprintChangeWithoutPrompt() -> Bool {
+        let current: ClaudeKeychainFingerprint?
+        switch self.probeClaudeKeychainFingerprintWithoutPrompt() {
+        case .unavailable:
             return false
-        case .onlyOnUserAction:
-            if ProviderInteractionContext.current != .userInitiated {
-                if ProcessInfo.processInfo.environment["CODEXBAR_DEBUG_CLAUDE_OAUTH_FLOW"] == "1" {
-                    self.log.debug(
-                        "Claude OAuth keychain freshness sync skipped (background)",
-                        metadata: ["promptMode": mode.rawValue, "owner": String(describing: cached.owner)])
-                }
-                return false
-            }
-            return true
-        case .always:
-            return true
+        case let .value(fingerprint):
+            current = fingerprint
         }
+        let stored = self.loadClaudeKeychainFingerprint()
+        guard current != stored else { return false }
+        self.saveClaudeKeychainFingerprint(current)
+        return true
     }
 
-    private static func repairFromClaudeKeychainWithoutPromptIfAllowed(
-        now: Date,
-        respectKeychainPromptCooldown: Bool) -> ClaudeOAuthCredentialRecord?
-    {
-        #if os(macOS)
-        let mode = ClaudeOAuthKeychainPromptPreference.current()
-        guard self.shouldAllowClaudeCodeKeychainAccess(mode: mode) else { return nil }
-
-        // If Keychain preflight indicates interaction is likely, skip the silent repair read.
-        // Why: non-interactive probes can still show UI on some systems, and if interaction is required we should
-        // let the interactive prompt path handle it (when allowed).
-        if self.shouldShowClaudeKeychainPreAlert() {
-            return nil
+    public static func claudeKeychainFingerprintChangedWithoutConsuming() -> Bool {
+        let current: ClaudeKeychainFingerprint?
+        switch self.probeClaudeKeychainFingerprintWithoutPrompt() {
+        case .unavailable:
+            return false
+        case let .value(fingerprint):
+            current = fingerprint
         }
+        return current != self.loadClaudeKeychainFingerprint()
+    }
 
-        if self.isPromptPolicyApplicable,
-           respectKeychainPromptCooldown,
-           ProviderInteractionContext.current != .userInitiated,
-           !ClaudeOAuthKeychainAccessGate.shouldAllowPrompt(now: now)
-        {
-            return nil
+    public static func claudeKeychainFingerprintToken() -> String? {
+        let fingerprint: ClaudeKeychainFingerprint? = switch self.probeClaudeKeychainFingerprintWithoutPrompt() {
+        case .unavailable:
+            self.loadClaudeKeychainFingerprint()
+        case let .value(probed):
+            probed
         }
+        guard let fingerprint else { return nil }
+        let modifiedAt = fingerprint.modifiedAt.map(String.init) ?? "nil"
+        let createdAt = fingerprint.createdAt.map(String.init) ?? "nil"
+        let persistentRefHash = fingerprint.persistentRefHash ?? "nil"
+        return "\(modifiedAt):\(createdAt):\(persistentRefHash)"
+    }
 
-        do {
-            if self.shouldPreferSecurityCLIKeychainRead(),
-               let securityData = self.loadFromClaudeKeychainViaSecurityCLIIfEnabled(
-                   interaction: ProviderInteractionContext.current),
-               !securityData.isEmpty
-            {
-                // Keep CLI-success repair prompt-safe in experimental mode by avoiding Security.framework fingerprint
-                // probes, which can still show UI on some systems even for "no UI" queries.
-                guard let creds = try? ClaudeOAuthCredentials.parse(data: securityData) else { return nil }
-                if creds.isExpired {
-                    return ClaudeOAuthCredentialRecord(credentials: creds, owner: .claudeCLI, source: .claudeKeychain)
-                }
+    private enum ClaudeKeychainProbe<Value> {
+        case unavailable
+        case value(Value)
+    }
 
-                self.writeMemoryCache(
-                    record: ClaudeOAuthCredentialRecord(credentials: creds, owner: .claudeCLI, source: .memoryCache),
-                    timestamp: now)
-                self.saveToCacheKeychain(securityData, owner: .claudeCLI)
+    @discardableResult
+    public static func invalidateCacheIfCredentialsFileChanged() -> Bool {
+        Repository(context: self.currentCollaboratorContext()).invalidateCacheIfCredentialsFileChanged()
+    }
 
-                self.log.info(
-                    "Claude keychain credentials loaded without prompt; syncing OAuth cache",
-                    metadata: ["interaction": ProviderInteractionContext
-                        .current == .userInitiated ? "user" : "background"])
-                return ClaudeOAuthCredentialRecord(credentials: creds, owner: .claudeCLI, source: .claudeKeychain)
-            }
+    /// Invalidate the credentials cache (call after login/logout)
+    public static func invalidateCache() {
+        Repository(context: self.currentCollaboratorContext()).invalidateCache()
+    }
 
-            guard let data = try self.loadFromClaudeKeychainNonInteractive(), !data.isEmpty else { return nil }
-            let fingerprint = self.currentClaudeKeychainFingerprintWithoutPrompt()
-            guard let creds = try? ClaudeOAuthCredentials.parse(data: data) else {
-                // Fingerprint so we don't repeatedly hammer a broken keychain item.
-                self.saveClaudeKeychainFingerprint(fingerprint)
-                return nil
-            }
+    /// Check if CodexBar has cached credentials (in memory or keychain cache)
+    public static func hasCachedCredentials(environment: [String: String] = ProcessInfo.processInfo
+        .environment) -> Bool
+    {
+        Repository(context: self.currentCollaboratorContext()).hasCachedCredentials(environment: environment)
+    }
 
-            if creds.isExpired {
-                // We intentionally don't cache expired credentials as a "working" OAuth cache entry. However, for the
-                // OAuth flow to delegate refresh to Claude CLI, we must surface the expired record to the caller.
-                self.saveClaudeKeychainFingerprint(fingerprint)
-                return ClaudeOAuthCredentialRecord(credentials: creds, owner: .claudeCLI, source: .claudeKeychain)
-            }
+    public static func hasClaudeKeychainCredentialsWithoutPrompt() -> Bool {
+        Repository(context: self.currentCollaboratorContext()).hasClaudeKeychainCredentialsWithoutPrompt()
+    }
 
-            self.saveClaudeKeychainFingerprint(fingerprint)
-            self.writeMemoryCache(
-                record: ClaudeOAuthCredentialRecord(credentials: creds, owner: .claudeCLI, source: .memoryCache),
-                timestamp: now)
-            self.saveToCacheKeychain(data, owner: .claudeCLI)
+    private static func hasClaudeKeychainItemWithoutPrompt() -> Bool {
+        #if DEBUG
+        if let store = self.taskClaudeKeychainOverrideStore {
+            if let data = store.data, !data.isEmpty { return true }
+            if store.fingerprint != nil { return true }
+        }
+        if let data = self.taskClaudeKeychainDataOverride ?? self.claudeKeychainDataOverride,
+           !data.isEmpty
+        {
+            return true
+        }
+        if self.taskClaudeKeychainFingerprintOverride ?? self.claudeKeychainFingerprintOverride != nil {
+            return true
+        }
+        #endif
 
-            self.log.info(
-                "Claude keychain credentials loaded without prompt; syncing OAuth cache",
-                metadata: ["interaction": ProviderInteractionContext.current == .userInitiated ? "user" : "background"])
-            return ClaudeOAuthCredentialRecord(credentials: creds, owner: .claudeCLI, source: .claudeKeychain)
-        } catch let error as ClaudeOAuthCredentialsError {
-            if case let .keychainError(status) = error,
-               status == Int(errSecUserCanceled)
-               || status == Int(errSecAuthFailed)
-               || status == Int(errSecInteractionNotAllowed)
-               || status == Int(errSecNoAccessForItem)
-            {
-                ClaudeOAuthKeychainAccessGate.recordDenied(now: now)
-            }
-            return nil
-        } catch {
-            return nil
+        #if os(macOS)
+        switch self.claudeKeychainCandidatesProbeWithoutPrompt(enforcePromptPolicy: false) {
+        case let .value(candidates) where !candidates.isEmpty:
+            return true
+        case .value, .unavailable:
+            break
+        }
+        switch self.claudeKeychainLegacyCandidateProbeWithoutPrompt(enforcePromptPolicy: false) {
+        case let .value(candidate):
+            return candidate != nil
+        case .unavailable:
+            return false
         }
         #else
-        _ = now
-        _ = respectKeychainPromptCooldown
-        return nil
+        return false
         #endif
     }
 
@@ -907,27 +1394,58 @@ public enum ClaudeOAuthCredentialsStore {
     }
 
     private static func currentClaudeKeychainFingerprintWithoutPrompt() -> ClaudeKeychainFingerprint? {
+        switch self.probeClaudeKeychainFingerprintWithoutPrompt() {
+        case .unavailable:
+            nil
+        case let .value(fingerprint):
+            fingerprint
+        }
+    }
+
+    private static func probeClaudeKeychainFingerprintWithoutPrompt()
+    -> ClaudeKeychainProbe<ClaudeKeychainFingerprint?> {
         let mode = ClaudeOAuthKeychainPromptPreference.current()
-        guard self.shouldAllowClaudeCodeKeychainAccess(mode: mode) else { return nil }
         #if DEBUG
-        if let store = taskClaudeKeychainOverrideStore { return store.fingerprint }
+        if let store = taskClaudeKeychainOverrideStore { return .value(store.fingerprint) }
         if let override = taskClaudeKeychainFingerprintOverride ?? self
-            .claudeKeychainFingerprintOverride { return override }
+            .claudeKeychainFingerprintOverride { return .value(override) }
         #endif
+        guard self.shouldAllowClaudeCodeKeychainAccess(mode: mode) else { return .unavailable }
+        if self.isPromptPolicyApplicable,
+           ProviderInteractionContext.current == .background,
+           !ClaudeOAuthKeychainAccessGate.shouldAllowPrompt()
+        {
+            return .unavailable
+        }
         #if os(macOS)
-        let newest: ClaudeKeychainCandidate? = self.claudeKeychainCandidatesWithoutPrompt().first
-            ?? self.claudeKeychainLegacyCandidateWithoutPrompt()
-        guard let newest else { return nil }
+        let candidatesProbe = self.claudeKeychainCandidatesProbeWithoutPrompt(promptMode: mode)
+        let newest: ClaudeKeychainCandidate?
+        switch candidatesProbe {
+        case .unavailable:
+            return .unavailable
+        case let .value(candidates):
+            if let first = candidates.first {
+                newest = first
+            } else {
+                switch self.claudeKeychainLegacyCandidateProbeWithoutPrompt(promptMode: mode) {
+                case .unavailable:
+                    return .unavailable
+                case let .value(candidate):
+                    newest = candidate
+                }
+            }
+        }
+        guard let newest else { return .value(nil) }
 
         let modifiedAt = newest.modifiedAt.map { Int($0.timeIntervalSince1970) }
         let createdAt = newest.createdAt.map { Int($0.timeIntervalSince1970) }
         let persistentRefHash = Self.sha256Prefix(newest.persistentRef)
-        return ClaudeKeychainFingerprint(
+        return .value(ClaudeKeychainFingerprint(
             modifiedAt: modifiedAt,
             createdAt: createdAt,
-            persistentRefHash: persistentRefHash)
+            persistentRefHash: persistentRefHash))
         #else
-        return nil
+        return .unavailable
         #endif
     }
 
@@ -1084,21 +1602,26 @@ public enum ClaudeOAuthCredentialsStore {
     }
 
     #if os(macOS)
-    private struct ClaudeKeychainCandidate: Sendable {
+    private struct ClaudeKeychainCandidate {
         let persistentRef: Data
         let account: String?
         let modifiedAt: Date?
         let createdAt: Date?
     }
 
-    private static func claudeKeychainCandidatesWithoutPrompt(
+    private static func claudeKeychainCandidatesProbeWithoutPrompt(
         promptMode: ClaudeOAuthKeychainPromptMode = ClaudeOAuthKeychainPromptPreference
-            .current()) -> [ClaudeKeychainCandidate]
+            .current(),
+        enforcePromptPolicy: Bool = true) -> ClaudeKeychainProbe<[ClaudeKeychainCandidate]>
     {
-        guard self.shouldAllowClaudeCodeKeychainAccess(mode: promptMode) else { return [] }
-        if self.isPromptPolicyApplicable,
-           ProviderInteractionContext.current == .background,
-           !ClaudeOAuthKeychainAccessGate.shouldAllowPrompt() { return [] }
+        if enforcePromptPolicy {
+            guard self.shouldAllowClaudeCodeKeychainAccess(mode: promptMode) else { return .unavailable }
+            if self.isPromptPolicyApplicable,
+               ProviderInteractionContext.current == .background,
+               !ClaudeOAuthKeychainAccessGate.shouldAllowPrompt() { return .unavailable }
+        } else {
+            guard self.keychainAccessAllowed else { return .unavailable }
+        }
         var query: [String: Any] = [
             kSecClass as String: kSecClassGenericPassword,
             kSecAttrService as String: self.claudeKeychainService,
@@ -1110,12 +1633,13 @@ public enum ClaudeOAuthCredentialsStore {
 
         let (status, result, durationMs) = ClaudeOAuthKeychainQueryTiming.copyMatching(query)
         if ClaudeOAuthKeychainQueryTiming
-            .backoffIfSlowNoUIQuery(durationMs, self.claudeKeychainService, self.log) { return [] }
+            .backoffIfSlowNoUIQuery(durationMs, self.claudeKeychainService, self.log) { return .unavailable }
         if status == errSecUserCanceled || status == errSecAuthFailed || status == errSecNoAccessForItem {
             ClaudeOAuthKeychainAccessGate.recordDenied()
         }
-        guard status == errSecSuccess else { return [] }
-        guard let rows = result as? [[String: Any]], !rows.isEmpty else { return [] }
+        if status == errSecItemNotFound { return .value([]) }
+        guard status == errSecSuccess else { return .unavailable }
+        guard let rows = result as? [[String: Any]], !rows.isEmpty else { return .value([]) }
 
         let candidates: [ClaudeKeychainCandidate] = rows.compactMap { row in
             guard let persistentRef = row[kSecValuePersistentRef as String] as? Data else { return nil }
@@ -1126,21 +1650,39 @@ public enum ClaudeOAuthCredentialsStore {
                 createdAt: row[kSecAttrCreationDate as String] as? Date)
         }
 
-        return candidates.sorted { lhs, rhs in
+        let sorted = candidates.sorted { lhs, rhs in
             let lhsDate = lhs.modifiedAt ?? lhs.createdAt ?? Date.distantPast
             let rhsDate = rhs.modifiedAt ?? rhs.createdAt ?? Date.distantPast
             return lhsDate > rhsDate
         }
+        return .value(sorted)
     }
 
-    private static func claudeKeychainLegacyCandidateWithoutPrompt(
+    private static func claudeKeychainCandidatesWithoutPrompt(
         promptMode: ClaudeOAuthKeychainPromptMode = ClaudeOAuthKeychainPromptPreference
-            .current()) -> ClaudeKeychainCandidate?
+            .current()) -> [ClaudeKeychainCandidate]
     {
-        guard self.shouldAllowClaudeCodeKeychainAccess(mode: promptMode) else { return nil }
-        if self.isPromptPolicyApplicable,
-           ProviderInteractionContext.current == .background,
-           !ClaudeOAuthKeychainAccessGate.shouldAllowPrompt() { return nil }
+        switch self.claudeKeychainCandidatesProbeWithoutPrompt(promptMode: promptMode) {
+        case .unavailable:
+            []
+        case let .value(candidates):
+            candidates
+        }
+    }
+
+    private static func claudeKeychainLegacyCandidateProbeWithoutPrompt(
+        promptMode: ClaudeOAuthKeychainPromptMode = ClaudeOAuthKeychainPromptPreference
+            .current(),
+        enforcePromptPolicy: Bool = true) -> ClaudeKeychainProbe<ClaudeKeychainCandidate?>
+    {
+        if enforcePromptPolicy {
+            guard self.shouldAllowClaudeCodeKeychainAccess(mode: promptMode) else { return .unavailable }
+            if self.isPromptPolicyApplicable,
+               ProviderInteractionContext.current == .background,
+               !ClaudeOAuthKeychainAccessGate.shouldAllowPrompt() { return .unavailable }
+        } else {
+            guard self.keychainAccessAllowed else { return .unavailable }
+        }
         var query: [String: Any] = [
             kSecClass as String: kSecClassGenericPassword,
             kSecAttrService as String: self.claudeKeychainService,
@@ -1152,18 +1694,31 @@ public enum ClaudeOAuthCredentialsStore {
 
         let (status, result, durationMs) = ClaudeOAuthKeychainQueryTiming.copyMatching(query)
         if ClaudeOAuthKeychainQueryTiming
-            .backoffIfSlowNoUIQuery(durationMs, self.claudeKeychainService, self.log) { return nil }
+            .backoffIfSlowNoUIQuery(durationMs, self.claudeKeychainService, self.log) { return .unavailable }
         if status == errSecUserCanceled || status == errSecAuthFailed || status == errSecNoAccessForItem {
             ClaudeOAuthKeychainAccessGate.recordDenied()
         }
-        guard status == errSecSuccess else { return nil }
-        guard let row = result as? [String: Any] else { return nil }
-        guard let persistentRef = row[kSecValuePersistentRef as String] as? Data else { return nil }
-        return ClaudeKeychainCandidate(
+        if status == errSecItemNotFound { return .value(nil) }
+        guard status == errSecSuccess else { return .unavailable }
+        guard let row = result as? [String: Any] else { return .value(nil) }
+        guard let persistentRef = row[kSecValuePersistentRef as String] as? Data else { return .value(nil) }
+        return .value(ClaudeKeychainCandidate(
             persistentRef: persistentRef,
             account: row[kSecAttrAccount as String] as? String,
             modifiedAt: row[kSecAttrModificationDate as String] as? Date,
-            createdAt: row[kSecAttrCreationDate as String] as? Date)
+            createdAt: row[kSecAttrCreationDate as String] as? Date))
+    }
+
+    private static func claudeKeychainLegacyCandidateWithoutPrompt(
+        promptMode: ClaudeOAuthKeychainPromptMode = ClaudeOAuthKeychainPromptPreference
+            .current()) -> ClaudeKeychainCandidate?
+    {
+        switch self.claudeKeychainLegacyCandidateProbeWithoutPrompt(promptMode: promptMode) {
+        case .unavailable:
+            nil
+        case let .value(candidate):
+            candidate
+        }
     }
 
     private static func loadClaudeKeychainData(
@@ -1323,23 +1878,22 @@ public enum ClaudeOAuthCredentialsStore {
     }
 
     #if DEBUG
-    static func withCredentialsURLOverrideForTesting<T>(
-        _ url: URL?,
-        operation: () throws -> T) rethrows -> T
-    {
+    public static func withCredentialsURLOverrideForTesting<T>(_ url: URL?, operation: () throws -> T) rethrows -> T {
         try self.$taskCredentialsURLOverride.withValue(url) {
             try operation()
         }
     }
 
-    static func withCredentialsURLOverrideForTesting<T>(
-        _ url: URL?,
-        operation: () async throws -> T) async rethrows -> T
-    {
+    public static func withCredentialsURLOverrideForTesting<T>(_ url: URL?, operation: () async throws -> T)
+    async rethrows -> T {
         try await self.$taskCredentialsURLOverride.withValue(url) {
             try await operation()
         }
     }
+
+    public static var currentCredentialsURLOverrideForTesting: URL? {
+        self.taskCredentialsURLOverride
+    }
     #endif
 
     private static func saveToCacheKeychain(_ data: Data, owner: ClaudeOAuthCredentialOwner? = nil) {
@@ -1354,10 +1908,22 @@ public enum ClaudeOAuthCredentialsStore {
     private static var keychainAccessAllowed: Bool {
         #if DEBUG
         if let override = self.taskKeychainAccessOverride { return !override }
+        if KeychainAccessGate.currentOverrideForTesting == true { return false }
+        if self.hasTaskKeychainTestingOverride { return true }
         #endif
         return !KeychainAccessGate.isDisabled
     }
 
+    #if DEBUG
+    private static var hasTaskKeychainTestingOverride: Bool {
+        self.taskClaudeKeychainOverrideStore != nil
+            || self.taskClaudeKeychainDataOverride != nil
+            || self.taskClaudeKeychainFingerprintOverride != nil
+            || self.taskSecurityCLIReadOverride != nil
+            || self.taskSecurityCLIReadAccountOverride != nil
+    }
+    #endif
+
     private static var isPromptPolicyApplicable: Bool {
         ClaudeOAuthKeychainPromptPreference.isApplicable()
     }
@@ -1509,102 +2075,7 @@ extension ClaudeOAuthCredentialsStore {
     /// CodexBar's caches. This is used to avoid triggering a second OS keychain dialog during the OAuth retry.
     @discardableResult
     static func syncFromClaudeKeychainWithoutPrompt(now: Date = Date()) -> Bool {
-        #if os(macOS)
-        let mode = ClaudeOAuthKeychainPromptPreference.current()
-        guard self.shouldAllowClaudeCodeKeychainAccess(mode: mode) else { return false }
-
-        if let data = self.loadFromClaudeKeychainViaSecurityCLIIfEnabled(
-            interaction: ProviderInteractionContext.current),
-            !data.isEmpty
-        {
-            if let creds = try? ClaudeOAuthCredentials.parse(data: data), !creds.isExpired {
-                // Keep delegated refresh recovery on the security CLI path only in experimental mode.
-                // Avoid Security.framework fingerprint probes here because "no UI" queries can still prompt.
-                self.writeMemoryCache(
-                    record: ClaudeOAuthCredentialRecord(credentials: creds, owner: .claudeCLI, source: .memoryCache),
-                    timestamp: now)
-                self.saveToCacheKeychain(data, owner: .claudeCLI)
-                return true
-            }
-        }
-
-        let fallbackPromptMode = ClaudeOAuthKeychainPromptPreference.securityFrameworkFallbackMode()
-        guard self.shouldAllowClaudeCodeKeychainAccess(mode: fallbackPromptMode) else { return false }
-
-        // If background keychain access has been denied/blocked, don't attempt silent Security.framework fallback
-        // reads that could trigger repeated prompts on misbehaving configurations.
-        if ProviderInteractionContext.current == .background,
-           !ClaudeOAuthKeychainAccessGate.shouldAllowPrompt(now: now) { return false }
-
-        #if DEBUG
-        // Test hook: allow unit tests to simulate a silent Security.framework fallback read without touching
-        // the real Keychain.
-        let override = self.taskClaudeKeychainOverrideStore?.data ?? self.taskClaudeKeychainDataOverride
-            ?? self.claudeKeychainDataOverride
-        if let override,
-           !override.isEmpty,
-           let creds = try? ClaudeOAuthCredentials.parse(data: override),
-           !creds.isExpired
-        {
-            self.saveClaudeKeychainFingerprint(self.currentClaudeKeychainFingerprintWithoutPrompt())
-            self.writeMemoryCache(
-                record: ClaudeOAuthCredentialRecord(credentials: creds, owner: .claudeCLI, source: .memoryCache),
-                timestamp: now)
-            self.saveToCacheKeychain(override, owner: .claudeCLI)
-            return true
-        }
-        #endif
-
-        // Skip the silent data read if preflight indicates interaction is likely.
-        // Why: on some systems, Security.framework can still surface UI even for "no UI" probes.
-        if self.shouldShowClaudeKeychainPreAlert() {
-            return false
-        }
-
-        // Consult only the newest candidate to avoid syncing from a different keychain entry (e.g. old login).
-        if let candidate = self.claudeKeychainCandidatesWithoutPrompt(promptMode: fallbackPromptMode).first,
-           let data = try? self.loadClaudeKeychainData(candidate: candidate, allowKeychainPrompt: false),
-           !data.isEmpty
-        {
-            let fingerprint = ClaudeKeychainFingerprint(
-                modifiedAt: candidate.modifiedAt.map { Int($0.timeIntervalSince1970) },
-                createdAt: candidate.createdAt.map { Int($0.timeIntervalSince1970) },
-                persistentRefHash: Self.sha256Prefix(candidate.persistentRef))
-
-            if let creds = try? ClaudeOAuthCredentials.parse(data: data), !creds.isExpired {
-                self.saveClaudeKeychainFingerprint(fingerprint)
-                self.writeMemoryCache(
-                    record: ClaudeOAuthCredentialRecord(credentials: creds, owner: .claudeCLI, source: .memoryCache),
-                    timestamp: now)
-                self.saveToCacheKeychain(data, owner: .claudeCLI)
-                return true
-            }
-
-            // Fingerprint so we don't repeatedly hammer a broken/expired keychain item during background retries.
-            self.saveClaudeKeychainFingerprint(fingerprint)
-        }
-
-        let legacyData = try? self.loadClaudeKeychainLegacyData(
-            allowKeychainPrompt: false,
-            promptMode: fallbackPromptMode)
-        if let legacyData,
-           !legacyData.isEmpty,
-           let creds = try? ClaudeOAuthCredentials.parse(data: legacyData),
-           !creds.isExpired
-        {
-            self.saveClaudeKeychainFingerprint(self.currentClaudeKeychainFingerprintWithoutPrompt())
-            self.writeMemoryCache(
-                record: ClaudeOAuthCredentialRecord(credentials: creds, owner: .claudeCLI, source: .memoryCache),
-                timestamp: now)
-            self.saveToCacheKeychain(legacyData, owner: .claudeCLI)
-            return true
-        }
-
-        return false
-        #else
-        _ = now
-        return false
-        #endif
+        Recovery(context: self.currentCollaboratorContext()).syncFromClaudeKeychainWithoutPrompt(now: now)
     }
 
     private static func shouldShowClaudeKeychainPreAlert() -> Bool {
@@ -1627,110 +2098,17 @@ extension ClaudeOAuthCredentialsStore {
     public static func refreshAccessToken(
         refreshToken: String,
         existingScopes: [String],
-        existingRateLimitTier: String?) async throws -> ClaudeOAuthCredentials
+        existingRateLimitTier: String?,
+        existingSubscriptionType: String? = nil) async throws -> ClaudeOAuthCredentials
     {
-        let newCredentials = try await self.refreshAccessTokenCore(
+        try await Refresher(context: self.currentCollaboratorContext()).refreshAccessToken(
             refreshToken: refreshToken,
             existingScopes: existingScopes,
-            existingRateLimitTier: existingRateLimitTier)
-
-        // Save to CodexBar's keychain cache (not Claude's keychain)
-        self.saveRefreshedCredentialsToCache(newCredentials)
-
-        // Update in-memory cache
-        self.writeMemoryCache(
-            record: ClaudeOAuthCredentialRecord(
-                credentials: newCredentials,
-                owner: .codexbar,
-                source: .memoryCache),
-            timestamp: Date())
-        ClaudeOAuthRefreshFailureGate.recordSuccess()
-
-        return newCredentials
-    }
-
-    /// Core refresh logic (network + error disposition + failure gating).
-    /// Does not update any caches or keychain items.
-    private static func refreshAccessTokenCore(
-        refreshToken: String,
-        existingScopes: [String],
-        existingRateLimitTier: String?) async throws -> ClaudeOAuthCredentials
-    {
-        guard ClaudeOAuthRefreshFailureGate.shouldAttempt() else {
-            let status = ClaudeOAuthRefreshFailureGate.currentBlockStatus()
-            let message = switch status {
-            case .terminal:
-                "Claude OAuth refresh blocked until auth changes. \(self.reauthenticateHint)"
-            case .transient:
-                "Claude OAuth refresh temporarily backed off due to prior failures; will retry automatically."
-            case nil:
-                "Claude OAuth refresh temporarily suppressed due to prior failures; will retry automatically."
-            }
-            throw ClaudeOAuthCredentialsError.refreshFailed(message)
-        }
-
-        guard let url = URL(string: self.tokenRefreshEndpoint) else {
-            throw ClaudeOAuthCredentialsError.refreshFailed("Invalid token endpoint URL")
-        }
-
-        var request = URLRequest(url: url)
-        request.httpMethod = "POST"
-        request.timeoutInterval = 30
-        request.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
-        request.setValue("application/json", forHTTPHeaderField: "Accept")
-
-        var components = URLComponents()
-        components.queryItems = [
-            URLQueryItem(name: "grant_type", value: "refresh_token"),
-            URLQueryItem(name: "refresh_token", value: refreshToken),
-            URLQueryItem(name: "client_id", value: self.oauthClientID),
-        ]
-        request.httpBody = (components.percentEncodedQuery ?? "").data(using: .utf8)
-
-        let (data, response) = try await URLSession.shared.data(for: request)
-
-        guard let http = response as? HTTPURLResponse else {
-            throw ClaudeOAuthCredentialsError.refreshFailed("Invalid response")
-        }
-
-        guard http.statusCode == 200 else {
-            if let disposition = self.refreshFailureDisposition(statusCode: http.statusCode, data: data) {
-                let oauthError = self.extractOAuthErrorCode(from: data)
-                self.log.info(
-                    "Claude OAuth refresh rejected",
-                    metadata: [
-                        "httpStatus": "\(http.statusCode)",
-                        "oauthError": oauthError ?? "nil",
-                        "disposition": disposition.rawValue,
-                    ])
-
-                switch disposition {
-                case .terminalInvalidGrant:
-                    ClaudeOAuthRefreshFailureGate.recordTerminalAuthFailure()
-                    self.invalidateCache()
-                    throw ClaudeOAuthCredentialsError.refreshFailed(
-                        "HTTP \(http.statusCode) invalid_grant. \(self.reauthenticateHint)")
-                case .transientBackoff:
-                    ClaudeOAuthRefreshFailureGate.recordTransientFailure()
-                    let suffix = oauthError.map { " (\($0))" } ?? ""
-                    throw ClaudeOAuthCredentialsError.refreshFailed("HTTP \(http.statusCode)\(suffix)")
-                }
-            }
-            throw ClaudeOAuthCredentialsError.refreshFailed("HTTP \(http.statusCode)")
-        }
-
-        let tokenResponse = try JSONDecoder().decode(TokenRefreshResponse.self, from: data)
-        let expiresAt = Date(timeIntervalSinceNow: TimeInterval(tokenResponse.expiresIn))
-
-        return ClaudeOAuthCredentials(
-            accessToken: tokenResponse.accessToken,
-            refreshToken: tokenResponse.refreshToken ?? refreshToken,
-            expiresAt: expiresAt,
-            scopes: existingScopes,
-            rateLimitTier: existingRateLimitTier)
+            existingRateLimitTier: existingRateLimitTier,
+            existingSubscriptionType: existingSubscriptionType)
     }
 
-    private enum RefreshFailureDisposition: String, Sendable {
+    private enum RefreshFailureDisposition: String {
         case terminalInvalidGrant
         case transientBackoff
     }
diff --git a/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthDelegatedRefreshCoordinator.swift b/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthDelegatedRefreshCoordinator.swift
index d94940602a..d775e584fe 100644
--- a/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthDelegatedRefreshCoordinator.swift
+++ b/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthDelegatedRefreshCoordinator.swift
@@ -1,6 +1,21 @@
 import Foundation
 
 public enum ClaudeOAuthDelegatedRefreshCoordinator {
+    private final class AttemptStateStorage: @unchecked Sendable {
+        let lock = NSLock()
+        let persistsCooldown: Bool
+        var hasLoadedState = false
+        var lastAttemptAt: Date?
+        var lastCooldownInterval: TimeInterval?
+        var inFlightAttemptID: UInt64?
+        var inFlightTask: Task<Outcome, Never>?
+        var nextAttemptID: UInt64 = 0
+
+        init(persistsCooldown: Bool) {
+            self.persistsCooldown = persistsCooldown
+        }
+    }
+
     public enum Outcome: Sendable, Equatable {
         case skippedByCooldown
         case cliUnavailable
@@ -14,84 +29,125 @@ public enum ClaudeOAuthDelegatedRefreshCoordinator {
     private static let defaultCooldownInterval: TimeInterval = 60 * 5
     private static let shortCooldownInterval: TimeInterval = 20
 
-    private static let stateLock = NSLock()
-    private nonisolated(unsafe) static var hasLoadedState = false
-    private nonisolated(unsafe) static var lastAttemptAt: Date?
-    private nonisolated(unsafe) static var lastCooldownInterval: TimeInterval?
-    private nonisolated(unsafe) static var inFlightAttemptID: UInt64?
-    private nonisolated(unsafe) static var inFlightTask: Task<Outcome, Never>?
-    private nonisolated(unsafe) static var nextAttemptID: UInt64 = 0
+    private static let sharedState = AttemptStateStorage(persistsCooldown: true)
 
-    public static func attempt(now: Date = Date(), timeout: TimeInterval = 8) async -> Outcome {
+    public static func attempt(
+        now: Date = Date(),
+        timeout: TimeInterval = 8,
+        environment: [String: String] = ProcessInfo.processInfo.environment) async -> Outcome
+    {
         if Task.isCancelled {
             return .attemptedFailed("Cancelled.")
         }
 
-        switch self.inFlightDecision(now: now, timeout: timeout) {
+        switch self.inFlightDecision(now: now, timeout: timeout, environment: environment) {
         case let .join(task):
             return await task.value
-        case let .start(id, task):
+        case let .start(id, task, state):
             let outcome = await task.value
-            self.clearInFlightTaskIfStillCurrent(id: id)
+            self.clearInFlightTaskIfStillCurrent(id: id, state: state)
             return outcome
         }
     }
 
     private enum InFlightDecision {
         case join(Task<Outcome, Never>)
-        case start(UInt64, Task<Outcome, Never>)
+        case start(UInt64, Task<Outcome, Never>, AttemptStateStorage)
     }
 
-    private static func inFlightDecision(now: Date, timeout: TimeInterval) -> InFlightDecision {
-        self.stateLock.lock()
-        defer { self.stateLock.unlock() }
+    private struct AttemptConfiguration {
+        let environment: [String: String]
+        let readStrategy: ClaudeOAuthKeychainReadStrategy
+        let keychainAccessDisabled: Bool
+        #if DEBUG
+        let cliAvailableOverride: Bool?
+        let touchAuthPathOverride: (@Sendable (TimeInterval, [String: String]) async throws -> Void)?
+        let keychainFingerprintOverride: (@Sendable () -> ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint?)?
+        #endif
+    }
+
+    private static func inFlightDecision(
+        now: Date,
+        timeout: TimeInterval,
+        environment: [String: String]) -> InFlightDecision
+    {
+        let state = self.currentStateStorage
+        state.lock.lock()
+        defer { state.lock.unlock() }
 
-        if let existing = self.inFlightTask {
+        if let existing = state.inFlightTask {
             return .join(existing)
         }
 
-        self.nextAttemptID += 1
-        let attemptID = self.nextAttemptID
+        state.nextAttemptID += 1
+        let attemptID = state.nextAttemptID
         // Detached to avoid inheriting the caller's executor context (e.g. MainActor) and cancellation state.
-        let readStrategy = ClaudeOAuthKeychainReadStrategyPreference.current()
-        let keychainAccessDisabled = KeychainAccessGate.isDisabled
+        #if DEBUG
+        let configuration = AttemptConfiguration(
+            environment: environment,
+            readStrategy: ClaudeOAuthKeychainReadStrategyPreference.current(),
+            keychainAccessDisabled: KeychainAccessGate.isDisabled,
+            cliAvailableOverride: self.cliAvailableOverrideForTesting,
+            touchAuthPathOverride: self.touchAuthPathOverrideForTesting,
+            keychainFingerprintOverride: self.keychainFingerprintOverrideForTesting)
+        let securityCLIReadOverride = ClaudeOAuthCredentialsStore.currentSecurityCLIReadOverrideForTesting()
+        #else
+        let configuration = AttemptConfiguration(
+            environment: environment,
+            readStrategy: ClaudeOAuthKeychainReadStrategyPreference.current(),
+            keychainAccessDisabled: KeychainAccessGate.isDisabled)
+        #endif
         let task = Task.detached(priority: .utility) {
+            #if DEBUG
+            return await ClaudeOAuthCredentialsStore.withSecurityCLIReadOverrideForTesting(securityCLIReadOverride) {
+                await self.performAttempt(
+                    now: now,
+                    timeout: timeout,
+                    configuration: configuration,
+                    state: state)
+            }
+            #else
             await self.performAttempt(
                 now: now,
                 timeout: timeout,
-                readStrategy: readStrategy,
-                keychainAccessDisabled: keychainAccessDisabled)
+                configuration: configuration,
+                state: state)
+            #endif
         }
-        self.inFlightAttemptID = attemptID
-        self.inFlightTask = task
-        return .start(attemptID, task)
+        state.inFlightAttemptID = attemptID
+        state.inFlightTask = task
+        return .start(attemptID, task, state)
     }
 
     private static func performAttempt(
         now: Date,
         timeout: TimeInterval,
-        readStrategy: ClaudeOAuthKeychainReadStrategy,
-        keychainAccessDisabled: Bool) async -> Outcome
+        configuration: AttemptConfiguration,
+        state: AttemptStateStorage) async -> Outcome
     {
-        guard self.isClaudeCLIAvailable() else {
+        guard self.isClaudeCLIAvailable(environment: configuration.environment, configuration: configuration) else {
             self.log.info("Claude OAuth delegated refresh skipped: claude CLI unavailable")
             return .cliUnavailable
         }
 
         // Atomically reserve an attempt under the lock so concurrent callers don't race past isInCooldown() and start
         // multiple touches/poll loops.
-        guard self.reserveAttemptIfNotInCooldown(now: now) else {
+        guard self.reserveAttemptIfNotInCooldown(now: now, state: state) else {
             self.log.debug("Claude OAuth delegated refresh skipped by cooldown")
             return .skippedByCooldown
         }
 
         let baseline = self.currentKeychainChangeObservationBaseline(
-            readStrategy: readStrategy,
-            keychainAccessDisabled: keychainAccessDisabled)
+            readStrategy: configuration.readStrategy,
+            keychainAccessDisabled: configuration.keychainAccessDisabled,
+            configuration: configuration)
         var touchError: Error?
 
         do {
-            try await self.touchOAuthAuthPath(timeout: timeout)
+            try await self.touchOAuthAuthPath(
+                timeout: timeout,
+                environment: configuration.environment,
+                configuration: configuration)
         } catch {
             touchError = error
         }
@@ -100,16 +156,17 @@ public enum ClaudeOAuthDelegatedRefreshCoordinator {
         // Otherwise we end up in a long cooldown with still-expired credentials.
         let changed = await self.waitForClaudeKeychainChange(
             from: baseline,
-            readStrategy: readStrategy,
-            keychainAccessDisabled: keychainAccessDisabled,
+            readStrategy: configuration.readStrategy,
+            keychainAccessDisabled: configuration.keychainAccessDisabled,
+            configuration: configuration,
             timeout: min(max(timeout, 1), 2))
         if changed {
-            self.recordAttempt(now: now, cooldown: self.defaultCooldownInterval)
+            self.recordAttempt(now: now, cooldown: self.defaultCooldownInterval, state: state)
             self.log.info("Claude OAuth delegated refresh touch succeeded")
             return .attemptedSucceeded
         }
 
-        self.recordAttempt(now: now, cooldown: self.shortCooldownInterval)
+        self.recordAttempt(now: now, cooldown: self.shortCooldownInterval, state: state)
         if let touchError {
             let errorType = String(describing: type(of: touchError))
             self.log.warning(
@@ -124,65 +181,85 @@ public enum ClaudeOAuthDelegatedRefreshCoordinator {
     }
 
     public static func isInCooldown(now: Date = Date()) -> Bool {
-        self.stateLock.lock()
-        defer { self.stateLock.unlock() }
-        self.loadStateIfNeededLocked()
-        guard let lastAttemptAt = self.lastAttemptAt else { return false }
-        let cooldown = self.lastCooldownInterval ?? self.defaultCooldownInterval
+        let state = self.currentStateStorage
+        state.lock.lock()
+        defer { state.lock.unlock() }
+        self.loadStateIfNeededLocked(state: state)
+        guard let lastAttemptAt = state.lastAttemptAt else { return false }
+        let cooldown = state.lastCooldownInterval ?? self.defaultCooldownInterval
         return now.timeIntervalSince(lastAttemptAt) < cooldown
     }
 
     public static func cooldownRemainingSeconds(now: Date = Date()) -> Int? {
-        self.stateLock.lock()
-        defer { self.stateLock.unlock() }
-        self.loadStateIfNeededLocked()
-        guard let lastAttemptAt = self.lastAttemptAt else { return nil }
-        let cooldown = self.lastCooldownInterval ?? self.defaultCooldownInterval
+        let state = self.currentStateStorage
+        state.lock.lock()
+        defer { state.lock.unlock() }
+        self.loadStateIfNeededLocked(state: state)
+        guard let lastAttemptAt = state.lastAttemptAt else { return nil }
+        let cooldown = state.lastCooldownInterval ?? self.defaultCooldownInterval
         let remaining = cooldown - now.timeIntervalSince(lastAttemptAt)
         guard remaining > 0 else { return nil }
         return Int(remaining.rounded(.up))
     }
 
-    public static func isClaudeCLIAvailable() -> Bool {
+    public static func isClaudeCLIAvailable(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> Bool
+    {
+        self.isClaudeCLIAvailable(
+            environment: environment,
+            configuration: nil)
+    }
+
+    private static func isClaudeCLIAvailable(
+        environment: [String: String],
+        configuration: AttemptConfiguration?) -> Bool
+    {
         #if DEBUG
-        if let override = self.cliAvailableOverride {
+        if let override = configuration?.cliAvailableOverride ?? self.cliAvailableOverrideForTesting {
             return override
         }
         #endif
-        return ClaudeStatusProbe.isClaudeBinaryAvailable()
+        return ClaudeCLIResolver.isAvailable(environment: environment)
     }
 
-    private static func touchOAuthAuthPath(timeout: TimeInterval) async throws {
+    private static func touchOAuthAuthPath(
+        timeout: TimeInterval,
+        environment: [String: String],
+        configuration: AttemptConfiguration?) async throws
+    {
         #if DEBUG
-        if let override = self.touchAuthPathOverride {
-            try await override(timeout)
+        if let override = configuration?.touchAuthPathOverride ?? self.touchAuthPathOverrideForTesting {
+            try await override(timeout, environment)
             return
         }
         #endif
-        try await ClaudeStatusProbe.touchOAuthAuthPath(timeout: timeout)
+        try await ClaudeStatusProbe.touchOAuthAuthPath(timeout: timeout, environment: environment)
     }
 
-    private enum KeychainChangeObservationBaseline: Sendable {
+    private enum KeychainChangeObservationBaseline {
         case securityFramework(fingerprint: ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint?)
         case securityCLI(data: Data?)
     }
 
     private static func currentKeychainChangeObservationBaseline(
         readStrategy: ClaudeOAuthKeychainReadStrategy,
-        keychainAccessDisabled: Bool) -> KeychainChangeObservationBaseline
+        keychainAccessDisabled: Bool,
+        configuration: AttemptConfiguration?) -> KeychainChangeObservationBaseline
     {
         if readStrategy == .securityCLIExperimental {
             return .securityCLI(data: self.currentClaudeKeychainDataViaSecurityCLIForObservation(
                 readStrategy: readStrategy,
-                keychainAccessDisabled: keychainAccessDisabled))
+                keychainAccessDisabled: keychainAccessDisabled,
+                interaction: .background))
         }
-        return .securityFramework(fingerprint: self.currentClaudeKeychainFingerprint())
+        return .securityFramework(fingerprint: self.currentClaudeKeychainFingerprint(configuration: configuration))
     }
 
     private static func waitForClaudeKeychainChange(
         from baseline: KeychainChangeObservationBaseline,
         readStrategy: ClaudeOAuthKeychainReadStrategy,
         keychainAccessDisabled: Bool,
+        configuration: AttemptConfiguration?,
         timeout: TimeInterval) async -> Bool
     {
         // Prefer correctness but bound the delay. Keychain writes can be slightly delayed after the CLI touch.
@@ -198,7 +275,10 @@ public enum ClaudeOAuthDelegatedRefreshCoordinator {
             case let .securityFramework(fingerprintBefore):
                 // Treat "no fingerprint" as "not observed"; we only succeed if we can read a fingerprint and it
                 // differs.
-                guard let current = self.currentClaudeKeychainFingerprintForObservation() else { return false }
+                guard let current = self.currentClaudeKeychainFingerprintForObservation(configuration: configuration)
+                else {
+                    return false
+                }
                 return current != fingerprintBefore
             case let .securityCLI(dataBefore):
                 // In experimental mode, avoid Security.framework observation entirely and detect change from
@@ -208,7 +288,8 @@ public enum ClaudeOAuthDelegatedRefreshCoordinator {
                 guard let dataBefore else { return false }
                 guard let current = self.currentClaudeKeychainDataViaSecurityCLIForObservation(
                     readStrategy: readStrategy,
-                    keychainAccessDisabled: keychainAccessDisabled)
+                    keychainAccessDisabled: keychainAccessDisabled,
+                    interaction: .background)
                 else { return false }
                 return current != dataBefore
             }
@@ -235,9 +316,11 @@ public enum ClaudeOAuthDelegatedRefreshCoordinator {
         return false
     }
 
-    private static func currentClaudeKeychainFingerprint() -> ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint? {
+    private static func currentClaudeKeychainFingerprint(
+        configuration: AttemptConfiguration?) -> ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint?
+    {
         #if DEBUG
-        if let override = self.keychainFingerprintOverride {
+        if let override = configuration?.keychainFingerprintOverride ?? self.keychainFingerprintOverrideForTesting {
             return override()
         }
         #endif
@@ -246,9 +329,15 @@ public enum ClaudeOAuthDelegatedRefreshCoordinator {
 
     private static func currentClaudeKeychainFingerprintForObservation() -> ClaudeOAuthCredentialsStore
         .ClaudeKeychainFingerprint?
+    {
+        self.currentClaudeKeychainFingerprintForObservation(configuration: nil)
+    }
+
+    private static func currentClaudeKeychainFingerprintForObservation(
+        configuration: AttemptConfiguration?) -> ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint?
     {
         #if DEBUG
-        if let override = self.keychainFingerprintOverride {
+        if let override = configuration?.keychainFingerprintOverride ?? self.keychainFingerprintOverrideForTesting {
             return override()
         }
         #endif
@@ -265,101 +354,139 @@ public enum ClaudeOAuthDelegatedRefreshCoordinator {
 
     private static func currentClaudeKeychainDataViaSecurityCLIForObservation(
         readStrategy: ClaudeOAuthKeychainReadStrategy,
-        keychainAccessDisabled: Bool) -> Data?
+        keychainAccessDisabled: Bool,
+        interaction: ProviderInteraction) -> Data?
     {
         guard !keychainAccessDisabled else { return nil }
         return ClaudeOAuthCredentialsStore.loadFromClaudeKeychainViaSecurityCLIIfEnabled(
-            interaction: .background,
+            interaction: interaction,
             readStrategy: readStrategy)
     }
 
-    private static func clearInFlightTaskIfStillCurrent(id: UInt64) {
-        self.stateLock.lock()
-        if self.inFlightAttemptID == id {
-            self.inFlightAttemptID = nil
-            self.inFlightTask = nil
+    private static func clearInFlightTaskIfStillCurrent(id: UInt64, state: AttemptStateStorage) {
+        state.lock.lock()
+        if state.inFlightAttemptID == id {
+            state.inFlightAttemptID = nil
+            state.inFlightTask = nil
         }
-        self.stateLock.unlock()
+        state.lock.unlock()
     }
 
-    private static func recordAttempt(now: Date, cooldown: TimeInterval) {
-        self.stateLock.lock()
-        defer { self.stateLock.unlock() }
-        self.loadStateIfNeededLocked()
-        self.lastAttemptAt = now
-        self.lastCooldownInterval = cooldown
+    private static func recordAttempt(now: Date, cooldown: TimeInterval, state: AttemptStateStorage) {
+        state.lock.lock()
+        defer { state.lock.unlock() }
+        self.loadStateIfNeededLocked(state: state)
+        state.lastAttemptAt = now
+        state.lastCooldownInterval = cooldown
+        guard state.persistsCooldown else { return }
         UserDefaults.standard.set(now.timeIntervalSince1970, forKey: self.cooldownDefaultsKey)
         UserDefaults.standard.set(cooldown, forKey: self.cooldownIntervalDefaultsKey)
     }
 
-    private static func reserveAttemptIfNotInCooldown(now: Date) -> Bool {
-        self.stateLock.lock()
-        defer { self.stateLock.unlock() }
-        self.loadStateIfNeededLocked()
+    private static func reserveAttemptIfNotInCooldown(now: Date, state: AttemptStateStorage) -> Bool {
+        state.lock.lock()
+        defer { state.lock.unlock() }
+        self.loadStateIfNeededLocked(state: state)
 
-        let cooldown = self.lastCooldownInterval ?? self.defaultCooldownInterval
-        if let lastAttemptAt = self.lastAttemptAt, now.timeIntervalSince(lastAttemptAt) < cooldown {
+        let cooldown = state.lastCooldownInterval ?? self.defaultCooldownInterval
+        if let lastAttemptAt = state.lastAttemptAt, now.timeIntervalSince(lastAttemptAt) < cooldown {
             return false
         }
 
         // Reserve with a short cooldown; the final outcome will extend or keep it short.
-        self.lastAttemptAt = now
-        self.lastCooldownInterval = self.shortCooldownInterval
+        state.lastAttemptAt = now
+        state.lastCooldownInterval = self.shortCooldownInterval
+        guard state.persistsCooldown else { return true }
         UserDefaults.standard.set(now.timeIntervalSince1970, forKey: self.cooldownDefaultsKey)
         UserDefaults.standard.set(self.shortCooldownInterval, forKey: self.cooldownIntervalDefaultsKey)
         return true
     }
 
-    private static func loadStateIfNeededLocked() {
-        guard !self.hasLoadedState else { return }
-        self.hasLoadedState = true
+    private static func loadStateIfNeededLocked(state: AttemptStateStorage) {
+        guard !state.hasLoadedState else { return }
+        state.hasLoadedState = true
+        guard state.persistsCooldown else {
+            state.lastAttemptAt = nil
+            state.lastCooldownInterval = nil
+            return
+        }
         guard let raw = UserDefaults.standard.object(forKey: self.cooldownDefaultsKey) as? Double else {
-            self.lastAttemptAt = nil
-            self.lastCooldownInterval = nil
+            state.lastAttemptAt = nil
+            state.lastCooldownInterval = nil
             return
         }
-        self.lastAttemptAt = Date(timeIntervalSince1970: raw)
+        state.lastAttemptAt = Date(timeIntervalSince1970: raw)
         if let interval = UserDefaults.standard.object(forKey: self.cooldownIntervalDefaultsKey) as? Double {
-            self.lastCooldownInterval = interval
+            state.lastCooldownInterval = interval
         } else {
-            self.lastCooldownInterval = nil
+            state.lastCooldownInterval = nil
         }
     }
 
     #if DEBUG
-    private nonisolated(unsafe) static var cliAvailableOverride: Bool?
-    private nonisolated(unsafe) static var touchAuthPathOverride: (@Sendable (TimeInterval) async throws -> Void)?
-    private nonisolated(unsafe) static var keychainFingerprintOverride: (() -> ClaudeOAuthCredentialsStore
+    @TaskLocal private static var stateStorageForTesting: AttemptStateStorage?
+    @TaskLocal static var cliAvailableOverrideForTesting: Bool?
+    @TaskLocal static var touchAuthPathOverrideForTesting: (@Sendable (
+        TimeInterval,
+        [String: String]) async throws -> Void)?
+    @TaskLocal static var keychainFingerprintOverrideForTesting: (@Sendable () -> ClaudeOAuthCredentialsStore
         .ClaudeKeychainFingerprint?)?
 
-    static func setCLIAvailableOverrideForTesting(_ override: Bool?) {
-        self.cliAvailableOverride = override
+    static func withCLIAvailableOverrideForTesting<T>(
+        _ override: Bool?,
+        operation: () async throws -> T) async rethrows -> T
+    {
+        try await self.$cliAvailableOverrideForTesting.withValue(override) {
+            try await operation()
+        }
     }
 
-    static func setTouchAuthPathOverrideForTesting(_ override: (@Sendable (TimeInterval) async throws -> Void)?) {
-        self.touchAuthPathOverride = override
+    static func withTouchAuthPathOverrideForTesting<T>(
+        _ override: (@Sendable (TimeInterval, [String: String]) async throws -> Void)?,
+        operation: () async throws -> T) async rethrows -> T
+    {
+        try await self.$touchAuthPathOverrideForTesting.withValue(override) {
+            try await operation()
+        }
     }
 
-    static func setKeychainFingerprintOverrideForTesting(
-        _ override: (() -> ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint?)?)
+    static func withKeychainFingerprintOverrideForTesting<T>(
+        _ override: (@Sendable () -> ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint?)?,
+        operation: () async throws -> T) async rethrows -> T
     {
-        self.keychainFingerprintOverride = override
+        try await self.$keychainFingerprintOverrideForTesting.withValue(override) {
+            try await operation()
+        }
+    }
+
+    static func withIsolatedStateForTesting<T>(operation: () async throws -> T) async rethrows -> T {
+        let state = AttemptStateStorage(persistsCooldown: false)
+        return try await self.$stateStorageForTesting.withValue(state) {
+            try await operation()
+        }
     }
 
     static func resetForTesting() {
-        self.stateLock.lock()
-        self.hasLoadedState = true
-        self.lastAttemptAt = nil
-        self.lastCooldownInterval = nil
-        self.inFlightAttemptID = nil
-        self.inFlightTask = nil
-        self.nextAttemptID = 0
-        self.stateLock.unlock()
+        let state = self.currentStateStorage
+        state.lock.lock()
+        state.hasLoadedState = true
+        state.lastAttemptAt = nil
+        state.lastCooldownInterval = nil
+        state.inFlightAttemptID = nil
+        state.inFlightTask = nil
+        state.nextAttemptID = 0
+        state.lock.unlock()
+        guard state.persistsCooldown else { return }
         UserDefaults.standard.removeObject(forKey: self.cooldownDefaultsKey)
         UserDefaults.standard.removeObject(forKey: self.cooldownIntervalDefaultsKey)
-        self.cliAvailableOverride = nil
-        self.touchAuthPathOverride = nil
-        self.keychainFingerprintOverride = nil
     }
     #endif
+
+    private static var currentStateStorage: AttemptStateStorage {
+        #if DEBUG
+        self.stateStorageForTesting ?? self.sharedState
+        #else
+        self.sharedState
+        #endif
+    }
 }
diff --git a/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthKeychainAccessGate.swift b/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthKeychainAccessGate.swift
index 451a8b23e5..6d43c45d6e 100644
--- a/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthKeychainAccessGate.swift
+++ b/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthKeychainAccessGate.swift
@@ -14,8 +14,10 @@ public enum ClaudeOAuthKeychainAccessGate {
     private static let cooldownInterval: TimeInterval = 60 * 60 * 6
     @TaskLocal private static var taskOverrideShouldAllowPromptForTesting: Bool?
     #if DEBUG
-    final class DeniedUntilStore: @unchecked Sendable {
-        var deniedUntil: Date?
+    public final class DeniedUntilStore: @unchecked Sendable {
+        public var deniedUntil: Date?
+
+        public init() {}
     }
 
     @TaskLocal private static var taskDeniedUntilStoreOverrideForTesting: DeniedUntilStore?
@@ -106,7 +108,7 @@ public enum ClaudeOAuthKeychainAccessGate {
         }
     }
 
-    static func withDeniedUntilStoreOverrideForTesting<T>(
+    public static func withDeniedUntilStoreOverrideForTesting<T>(
         _ store: DeniedUntilStore?,
         operation: () throws -> T) rethrows -> T
     {
@@ -115,7 +117,7 @@ public enum ClaudeOAuthKeychainAccessGate {
         }
     }
 
-    static func withDeniedUntilStoreOverrideForTesting<T>(
+    public static func withDeniedUntilStoreOverrideForTesting<T>(
         _ store: DeniedUntilStore?,
         operation: () async throws -> T) async rethrows -> T
     {
@@ -124,6 +126,10 @@ public enum ClaudeOAuthKeychainAccessGate {
         }
     }
 
+    public static var currentDeniedUntilStoreOverrideForTesting: DeniedUntilStore? {
+        self.taskDeniedUntilStoreOverrideForTesting
+    }
+
     public static func resetForTesting() {
         self.lock.withLock { state in
             // Keep deterministic during tests: avoid re-loading UserDefaults written by unrelated code paths.
diff --git a/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthKeychainPromptMode.swift b/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthKeychainPromptMode.swift
index 3ae21771bc..0ef6064d95 100644
--- a/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthKeychainPromptMode.swift
+++ b/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthKeychainPromptMode.swift
@@ -58,7 +58,7 @@ public enum ClaudeOAuthKeychainPromptPreference {
     }
 
     #if DEBUG
-    static func withTaskOverrideForTesting<T>(
+    public static func withTaskOverrideForTesting<T>(
         _ mode: ClaudeOAuthKeychainPromptMode?,
         operation: () throws -> T) rethrows -> T
     {
@@ -67,7 +67,7 @@ public enum ClaudeOAuthKeychainPromptPreference {
         }
     }
 
-    static func withTaskOverrideForTesting<T>(
+    public static func withTaskOverrideForTesting<T>(
         _ mode: ClaudeOAuthKeychainPromptMode?,
         operation: () async throws -> T) async rethrows -> T
     {
@@ -75,5 +75,9 @@ public enum ClaudeOAuthKeychainPromptPreference {
             try await operation()
         }
     }
+
+    public static var currentTaskOverrideForTesting: ClaudeOAuthKeychainPromptMode? {
+        self.taskOverride
+    }
     #endif
 }
diff --git a/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthKeychainReadStrategy.swift b/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthKeychainReadStrategy.swift
index 7f766d1e4d..01556f94a0 100644
--- a/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthKeychainReadStrategy.swift
+++ b/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthKeychainReadStrategy.swift
@@ -16,16 +16,28 @@ public enum ClaudeOAuthKeychainReadStrategyPreference {
         #if DEBUG
         if let taskOverride { return taskOverride }
         #endif
-        if let raw = userDefaults.string(forKey: self.userDefaultsKey),
-           let strategy = ClaudeOAuthKeychainReadStrategy(rawValue: raw)
+        if let raw = userDefaults.string(forKey: self.userDefaultsKey) {
+            return ClaudeOAuthKeychainReadStrategy(rawValue: raw) ?? .securityFramework
+        }
+        #if DEBUG
+        if self.isRunningUnderTests,
+           ProcessInfo.processInfo.environment["CODEXBAR_ALLOW_TEST_KEYCHAIN_ACCESS"] != "1"
         {
-            return strategy
+            return .securityFramework
         }
-        return .securityFramework
+        #endif
+        return .securityCLIExperimental
     }
 
     #if DEBUG
-    static func withTaskOverrideForTesting<T>(
+    private static var isRunningUnderTests: Bool {
+        let processName = ProcessInfo.processInfo.processName
+        return processName == "swiftpm-testing-helper"
+            || processName.hasSuffix("PackageTests")
+            || ProcessInfo.processInfo.environment["XCTestConfigurationFilePath"] != nil
+    }
+
+    public static func withTaskOverrideForTesting<T>(
         _ strategy: ClaudeOAuthKeychainReadStrategy?,
         operation: () throws -> T) rethrows -> T
     {
@@ -34,7 +46,7 @@ public enum ClaudeOAuthKeychainReadStrategyPreference {
         }
     }
 
-    static func withTaskOverrideForTesting<T>(
+    public static func withTaskOverrideForTesting<T>(
         _ strategy: ClaudeOAuthKeychainReadStrategy?,
         operation: () async throws -> T) async rethrows -> T
     {
@@ -42,5 +54,9 @@ public enum ClaudeOAuthKeychainReadStrategyPreference {
             try await operation()
         }
     }
+
+    public static var currentTaskOverrideForTesting: ClaudeOAuthKeychainReadStrategy? {
+        self.taskOverride
+    }
     #endif
 }
diff --git a/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthRefreshFailureGate.swift b/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthRefreshFailureGate.swift
index 59aa13241a..e9caa25a53 100644
--- a/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthRefreshFailureGate.swift
+++ b/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthRefreshFailureGate.swift
@@ -9,7 +9,7 @@ public enum ClaudeOAuthRefreshFailureGate {
         case transient(until: Date, failures: Int)
     }
 
-    struct AuthFingerprint: Codable, Equatable, Sendable {
+    struct AuthFingerprint: Codable, Equatable {
         let keychain: ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint?
         let credentialsFile: String?
     }
diff --git a/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthUsageFetcher.swift b/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthUsageFetcher.swift
index 5899eb189e..72b2a4f583 100644
--- a/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthUsageFetcher.swift
+++ b/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthUsageFetcher.swift
@@ -5,6 +5,7 @@ import FoundationNetworking
 
 public enum ClaudeOAuthFetchError: LocalizedError, Sendable {
     case unauthorized
+    case rateLimited(retryAfter: Date?)
     case invalidResponse
     case serverError(Int, String?)
     case networkError(Error)
@@ -13,6 +14,9 @@ public enum ClaudeOAuthFetchError: LocalizedError, Sendable {
         switch self {
         case .unauthorized:
             return "Claude OAuth request unauthorized. Run `claude` to re-authenticate."
+        case .rateLimited:
+            return "Claude OAuth usage endpoint is rate limited by Anthropic right now. Wait a few minutes, "
+                + "then click Refresh. If it keeps happening, run `claude logout && claude login`, then try again."
         case .invalidResponse:
             return "Claude OAuth response was invalid."
         case let .serverError(code, body):
@@ -37,6 +41,10 @@ enum ClaudeOAuthUsageFetcher {
     private static let fallbackClaudeCodeVersion = "2.1.0"
 
     static func fetchUsage(accessToken: String) async throws -> OAuthUsageResponse {
+        if let blockedUntil = ClaudeOAuthUsageRateLimitGate.blockedUntil() {
+            throw ClaudeOAuthFetchError.rateLimited(retryAfter: blockedUntil)
+        }
+
         guard let url = URL(string: baseURL + usagePath) else {
             throw ClaudeOAuthFetchError.invalidResponse
         }
@@ -52,21 +60,26 @@ enum ClaudeOAuthUsageFetcher {
         request.setValue(Self.claudeCodeUserAgent(), forHTTPHeaderField: "User-Agent")
 
         do {
-            let (data, response) = try await URLSession.shared.data(for: request)
-            guard let http = response as? HTTPURLResponse else {
-                throw ClaudeOAuthFetchError.invalidResponse
-            }
-            switch http.statusCode {
+            let response = try await ProviderHTTPClient.shared.response(for: request)
+            let data = response.data
+            switch response.statusCode {
             case 200:
-                return try Self.decodeUsageResponse(data)
+                let usage = try Self.decodeUsageResponse(data)
+                ClaudeOAuthUsageRateLimitGate.recordSuccess()
+                return usage
             case 401:
                 throw ClaudeOAuthFetchError.unauthorized
+            case 429:
+                let retryAfter = Self.retryAfterDate(from: response.response)
+                ClaudeOAuthUsageRateLimitGate.recordRateLimit(retryAfter: retryAfter)
+                throw ClaudeOAuthFetchError.rateLimited(
+                    retryAfter: ClaudeOAuthUsageRateLimitGate.currentBlockedUntil() ?? retryAfter)
             case 403:
                 let body = String(data: data, encoding: .utf8)
-                throw ClaudeOAuthFetchError.serverError(http.statusCode, body)
+                throw ClaudeOAuthFetchError.serverError(response.statusCode, body)
             default:
                 let body = String(data: data, encoding: .utf8)
-                throw ClaudeOAuthFetchError.serverError(http.statusCode, body)
+                throw ClaudeOAuthFetchError.serverError(response.statusCode, body)
             }
         } catch let error as ClaudeOAuthFetchError {
             throw error
@@ -89,6 +102,23 @@ enum ClaudeOAuthUsageFetcher {
         return formatter.date(from: string)
     }
 
+    private static func retryAfterDate(from response: HTTPURLResponse, now: Date = Date()) -> Date? {
+        guard let raw = response.value(forHTTPHeaderField: "Retry-After")?
+            .trimmingCharacters(in: .whitespacesAndNewlines),
+            !raw.isEmpty
+        else { return nil }
+
+        if let seconds = TimeInterval(raw), seconds >= 0 {
+            return now.addingTimeInterval(seconds)
+        }
+
+        let formatter = DateFormatter()
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        formatter.timeZone = TimeZone(secondsFromGMT: 0)
+        formatter.dateFormat = "EEE',' dd MMM yyyy HH':'mm':'ss zzz"
+        return formatter.date(from: raw)
+    }
+
     private static func claudeCodeUserAgent() -> String {
         self.claudeCodeUserAgent(versionString: ProviderVersionDetector.claudeVersion())
     }
@@ -108,27 +138,93 @@ enum ClaudeOAuthUsageFetcher {
     }
 }
 
-struct OAuthUsageResponse: Decodable, Sendable {
+struct OAuthUsageResponse: Decodable {
     let fiveHour: OAuthUsageWindow?
     let sevenDay: OAuthUsageWindow?
     let sevenDayOAuthApps: OAuthUsageWindow?
     let sevenDayOpus: OAuthUsageWindow?
     let sevenDaySonnet: OAuthUsageWindow?
+    let sevenDayRoutines: OAuthUsageWindow?
+    let sevenDayRoutinesSourceKey: String?
     let iguanaNecktie: OAuthUsageWindow?
     let extraUsage: OAuthExtraUsage?
 
-    enum CodingKeys: String, CodingKey {
-        case fiveHour = "five_hour"
-        case sevenDay = "seven_day"
-        case sevenDayOAuthApps = "seven_day_oauth_apps"
-        case sevenDayOpus = "seven_day_opus"
-        case sevenDaySonnet = "seven_day_sonnet"
-        case iguanaNecktie = "iguana_necktie"
-        case extraUsage = "extra_usage"
+    init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: DynamicCodingKey.self)
+        self.fiveHour = Self.decodeWindow(in: container, keys: ["five_hour"])
+        self.sevenDay = Self.decodeWindow(in: container, keys: ["seven_day"])
+        self.sevenDayOAuthApps = Self.decodeWindow(in: container, keys: ["seven_day_oauth_apps"])
+        self.sevenDayOpus = Self.decodeWindow(in: container, keys: ["seven_day_opus"])
+        self.sevenDaySonnet = Self.decodeWindow(in: container, keys: ["seven_day_sonnet"])
+        let routines = Self.decodeWindowWithSource(in: container, keys: [
+            "seven_day_routines",
+            "seven_day_claude_routines",
+            "claude_routines",
+            "routines",
+            "routine",
+            "seven_day_cowork",
+            "cowork",
+        ])
+        self.sevenDayRoutines = routines.window
+        self.sevenDayRoutinesSourceKey = routines.sourceKey
+        self.iguanaNecktie = Self.decodeWindow(in: container, keys: ["iguana_necktie"])
+        self.extraUsage = Self.decodeValue(in: container, keys: ["extra_usage"])
+    }
+
+    private static func decodeWindow(
+        in container: KeyedDecodingContainer<DynamicCodingKey>,
+        keys: [String]) -> OAuthUsageWindow?
+    {
+        self.decodeValue(in: container, keys: keys)
+    }
+
+    private static func decodeWindowWithSource(
+        in container: KeyedDecodingContainer<DynamicCodingKey>,
+        keys: [String]) -> (window: OAuthUsageWindow?, sourceKey: String?)
+    {
+        var firstNullKey: String?
+        for keyName in keys {
+            guard let key = DynamicCodingKey(stringValue: keyName) else { continue }
+            guard container.contains(key) else { continue }
+            if let value = try? container.decodeIfPresent(OAuthUsageWindow.self, forKey: key) {
+                return (value, keyName)
+            }
+            if firstNullKey == nil {
+                firstNullKey = keyName
+            }
+        }
+        return (nil, firstNullKey)
+    }
+
+    private static func decodeValue<T: Decodable>(
+        in container: KeyedDecodingContainer<DynamicCodingKey>,
+        keys: [String]) -> T?
+    {
+        for keyName in keys {
+            guard let key = DynamicCodingKey(stringValue: keyName) else { continue }
+            if let value = try? container.decodeIfPresent(T.self, forKey: key) {
+                return value
+            }
+        }
+        return nil
+    }
+}
+
+private struct DynamicCodingKey: CodingKey {
+    let stringValue: String
+    let intValue: Int?
+
+    init?(stringValue: String) {
+        self.stringValue = stringValue
+        self.intValue = nil
+    }
+
+    init?(intValue: Int) {
+        nil
     }
 }
 
-struct OAuthUsageWindow: Decodable, Sendable {
+struct OAuthUsageWindow: Decodable {
     let utilization: Double?
     let resetsAt: String?
 
@@ -138,7 +234,7 @@ struct OAuthUsageWindow: Decodable, Sendable {
     }
 }
 
-struct OAuthExtraUsage: Decodable, Sendable {
+struct OAuthExtraUsage: Decodable {
     let isEnabled: Bool?
     let monthlyLimit: Double?
     let usedCredits: Double?
@@ -163,5 +259,9 @@ extension ClaudeOAuthUsageFetcher {
     static func _userAgentForTesting(versionString: String?) -> String {
         self.claudeCodeUserAgent(versionString: versionString)
     }
+
+    static func _retryAfterDateForTesting(from response: HTTPURLResponse, now: Date) -> Date? {
+        self.retryAfterDate(from: response, now: now)
+    }
 }
 #endif
diff --git a/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthUsageRateLimitGate.swift b/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthUsageRateLimitGate.swift
new file mode 100644
index 0000000000..01ee9ec8f9
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthUsageRateLimitGate.swift
@@ -0,0 +1,46 @@
+import Foundation
+
+enum ClaudeOAuthUsageRateLimitGate {
+    private static let blockedUntilKey = "claudeOAuthUsageRateLimitBlockedUntilV1"
+    private static let defaultCooldown: TimeInterval = 60 * 5
+
+    static func blockedUntil(
+        interaction: ProviderInteraction = ProviderInteractionContext.current,
+        now: Date = Date()) -> Date?
+    {
+        guard interaction != .userInitiated else { return nil }
+        return self.currentBlockedUntil(now: now)
+    }
+
+    static func currentBlockedUntil(now: Date = Date()) -> Date? {
+        guard let raw = UserDefaults.standard.object(forKey: self.blockedUntilKey) as? Double else {
+            return nil
+        }
+
+        let blockedUntil = Date(timeIntervalSince1970: raw)
+        guard blockedUntil > now else {
+            UserDefaults.standard.removeObject(forKey: self.blockedUntilKey)
+            return nil
+        }
+        return blockedUntil
+    }
+
+    static func recordRateLimit(retryAfter: Date?, now: Date = Date()) {
+        let blockedUntil = if let retryAfter, retryAfter > now {
+            retryAfter
+        } else {
+            now.addingTimeInterval(self.defaultCooldown)
+        }
+        UserDefaults.standard.set(blockedUntil.timeIntervalSince1970, forKey: self.blockedUntilKey)
+    }
+
+    static func recordSuccess() {
+        UserDefaults.standard.removeObject(forKey: self.blockedUntilKey)
+    }
+
+    #if DEBUG
+    static func resetForTesting() {
+        UserDefaults.standard.removeObject(forKey: self.blockedUntilKey)
+    }
+    #endif
+}
diff --git a/Sources/CodexBarCore/Providers/Claude/ClaudePlan.swift b/Sources/CodexBarCore/Providers/Claude/ClaudePlan.swift
new file mode 100644
index 0000000000..73c567106f
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Claude/ClaudePlan.swift
@@ -0,0 +1,154 @@
+import Foundation
+
+public enum ClaudePlan: String, CaseIterable, Sendable {
+    case max
+    case pro
+    case team
+    case enterprise
+    case ultra
+
+    public var brandedLoginMethod: String {
+        switch self {
+        case .max:
+            "Claude Max"
+        case .pro:
+            "Claude Pro"
+        case .team:
+            "Claude Team"
+        case .enterprise:
+            "Claude Enterprise"
+        case .ultra:
+            "Claude Ultra"
+        }
+    }
+
+    public var compactLoginMethod: String {
+        switch self {
+        case .max:
+            "Max"
+        case .pro:
+            "Pro"
+        case .team:
+            "Team"
+        case .enterprise:
+            "Enterprise"
+        case .ultra:
+            "Ultra"
+        }
+    }
+
+    public var countsAsSubscription: Bool {
+        switch self {
+        case .max, .pro, .team, .ultra:
+            true
+        case .enterprise:
+            false
+        }
+    }
+
+    public static func fromOAuthRateLimitTier(_ rateLimitTier: String?) -> Self? {
+        self.fromRateLimitTier(rateLimitTier)
+    }
+
+    public static func fromOAuthCredentials(subscriptionType: String?, rateLimitTier: String?) -> Self? {
+        self.fromCompatibilityLoginMethod(subscriptionType)
+            ?? self.fromOAuthRateLimitTier(rateLimitTier)
+    }
+
+    public static func fromWebAccount(rateLimitTier: String?, billingType: String?) -> Self? {
+        if let plan = self.fromRateLimitTier(rateLimitTier) {
+            return plan
+        }
+
+        let tier = Self.normalized(rateLimitTier)
+        let billing = Self.normalized(billingType)
+        if billing.contains("stripe"), tier.contains("claude") {
+            return .pro
+        }
+        return nil
+    }
+
+    public static func fromCompatibilityLoginMethod(_ loginMethod: String?) -> Self? {
+        let words = Self.normalizedWords(loginMethod)
+        if words.isEmpty {
+            return nil
+        }
+        if words.contains("max") {
+            return .max
+        }
+        if words.contains("pro") {
+            return .pro
+        }
+        if words.contains("team") {
+            return .team
+        }
+        if words.contains("enterprise") {
+            return .enterprise
+        }
+        if words.contains("ultra") {
+            return .ultra
+        }
+        return nil
+    }
+
+    public static func oauthLoginMethod(rateLimitTier: String?) -> String? {
+        self.fromOAuthRateLimitTier(rateLimitTier)?.brandedLoginMethod
+    }
+
+    public static func oauthLoginMethod(subscriptionType: String?, rateLimitTier: String?) -> String? {
+        self.fromOAuthCredentials(
+            subscriptionType: subscriptionType,
+            rateLimitTier: rateLimitTier)?.brandedLoginMethod
+    }
+
+    public static func webLoginMethod(rateLimitTier: String?, billingType: String?) -> String? {
+        self.fromWebAccount(rateLimitTier: rateLimitTier, billingType: billingType)?.brandedLoginMethod
+    }
+
+    public static func cliCompatibilityLoginMethod(_ loginMethod: String?) -> String? {
+        guard let loginMethod = loginMethod?.trimmingCharacters(in: .whitespacesAndNewlines),
+              !loginMethod.isEmpty
+        else {
+            return nil
+        }
+
+        if let plan = self.fromCompatibilityLoginMethod(loginMethod) {
+            return plan.compactLoginMethod
+        }
+
+        return loginMethod
+    }
+
+    public static func isSubscriptionLoginMethod(_ loginMethod: String?) -> Bool {
+        self.fromCompatibilityLoginMethod(loginMethod)?.countsAsSubscription ?? false
+    }
+
+    private static func fromRateLimitTier(_ rateLimitTier: String?) -> Self? {
+        let tier = Self.normalized(rateLimitTier)
+        if tier.contains("max") {
+            return .max
+        }
+        if tier.contains("pro") {
+            return .pro
+        }
+        if tier.contains("team") {
+            return .team
+        }
+        if tier.contains("enterprise") {
+            return .enterprise
+        }
+        return nil
+    }
+
+    private static func normalized(_ text: String?) -> String {
+        text?
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .lowercased() ?? ""
+    }
+
+    private static func normalizedWords(_ text: String?) -> [String] {
+        self.normalized(text)
+            .split(whereSeparator: { !$0.isLetter && !$0.isNumber })
+            .map(String.init)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Claude/ClaudeProbeSessionArtifactCleaner.swift b/Sources/CodexBarCore/Providers/Claude/ClaudeProbeSessionArtifactCleaner.swift
new file mode 100644
index 0000000000..fa7cce370d
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Claude/ClaudeProbeSessionArtifactCleaner.swift
@@ -0,0 +1,105 @@
+import Foundation
+
+enum ClaudeProbeSessionArtifactCleaner {
+    private static let log = CodexBarLog.logger(LogCategories.claudeProbe)
+    private static let maxProjectDirectoryNameLength = 200
+
+    @discardableResult
+    static func cleanupProbeSessionArtifacts(
+        probeDirectory: URL = ClaudeStatusProbe.probeWorkingDirectoryURL(),
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        fileManager fm: FileManager = .default) -> [URL]
+    {
+        let projectDirectoryName = self.claudeProjectDirectoryName(for: probeDirectory)
+        var visitedDirectories = Set<String>()
+        var removedFiles: [URL] = []
+
+        for root in self.claudeConfigRoots(environment: environment, fileManager: fm) {
+            let projectsRoot = root.appendingPathComponent("projects", isDirectory: true)
+            let directories = [projectsRoot.appendingPathComponent(projectDirectoryName, isDirectory: true)]
+
+            for directory in directories where visitedDirectories.insert(directory.path).inserted {
+                guard let entries = try? fm.contentsOfDirectory(
+                    at: directory,
+                    includingPropertiesForKeys: [.isRegularFileKey],
+                    options: [.skipsHiddenFiles])
+                else { continue }
+
+                for entry in entries where entry.pathExtension == "jsonl" {
+                    let values = try? entry.resourceValues(forKeys: [.isRegularFileKey])
+                    guard values?.isRegularFile == true else { continue }
+                    do {
+                        try fm.removeItem(at: entry)
+                        removedFiles.append(entry)
+                    } catch {
+                        Self.log.debug(
+                            "Claude probe session artifact cleanup skipped file",
+                            metadata: ["error": error.localizedDescription])
+                    }
+                }
+
+                if (try? fm.contentsOfDirectory(atPath: directory.path).isEmpty) == true {
+                    try? fm.removeItem(at: directory)
+                }
+            }
+        }
+
+        return removedFiles
+    }
+
+    static func claudeProjectDirectoryName(for directory: URL) -> String {
+        let path = directory.path.precomposedStringWithCanonicalMapping
+        let sanitized = String(path.utf16.map { codeUnit in
+            switch codeUnit {
+            case 48...57, 65...90, 97...122:
+                Character(UnicodeScalar(codeUnit)!)
+            default:
+                "-"
+            }
+        })
+
+        guard sanitized.count > self.maxProjectDirectoryNameLength else { return sanitized }
+        return "\(sanitized.prefix(self.maxProjectDirectoryNameLength))-\(self.javaScriptHashBase36(path))"
+    }
+
+    private static func javaScriptHashBase36(_ string: String) -> String {
+        var hash: Int32 = 0
+        for codeUnit in string.utf16 {
+            hash = hash &* 31 &+ Int32(truncatingIfNeeded: codeUnit)
+        }
+
+        let magnitude = hash < 0 ? -Int64(hash) : Int64(hash)
+        return String(magnitude, radix: 36)
+    }
+
+    private static func claudeConfigRoots(
+        environment: [String: String],
+        fileManager fm: FileManager) -> [URL]
+    {
+        var roots: [URL] = []
+        var seen = Set<String>()
+
+        func append(_ url: URL) {
+            let standardized = url.standardizedFileURL
+            guard seen.insert(standardized.path).inserted else { return }
+            roots.append(standardized)
+        }
+
+        if let raw = environment["CLAUDE_CONFIG_DIR"] {
+            for part in raw.split(separator: ",") {
+                let path = part.trimmingCharacters(in: .whitespacesAndNewlines)
+                guard !path.isEmpty else { continue }
+                append(URL(fileURLWithPath: path))
+            }
+        }
+
+        let home = environment["HOME"].flatMap { $0.isEmpty ? nil : $0 } ?? NSHomeDirectory()
+        append(URL(fileURLWithPath: home).appendingPathComponent(".claude", isDirectory: true))
+        append(URL(fileURLWithPath: home).appendingPathComponent(".config/claude", isDirectory: true))
+
+        if roots.isEmpty {
+            append(fm.homeDirectoryForCurrentUser.appendingPathComponent(".claude", isDirectory: true))
+        }
+        return roots
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Claude/ClaudeProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Claude/ClaudeProviderDescriptor.swift
index 002a600ae9..3bd10cb3c1 100644
--- a/Sources/CodexBarCore/Providers/Claude/ClaudeProviderDescriptor.swift
+++ b/Sources/CodexBarCore/Providers/Claude/ClaudeProviderDescriptor.swift
@@ -1,9 +1,8 @@
-import CodexBarMacroSupport
 import Foundation
 
-@ProviderDescriptorRegistration
-@ProviderDescriptorDefinition
 public enum ClaudeProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
     static func makeDescriptor() -> ProviderDescriptor {
         ProviderDescriptor(
             id: .claude,
@@ -24,6 +23,7 @@ public enum ClaudeProviderDescriptor {
                 browserCookieOrder: ProviderBrowserCookieDefaults.defaultImportOrder,
                 dashboardURL: "https://console.anthropic.com/settings/billing",
                 subscriptionDashboardURL: "https://claude.ai/settings/usage",
+                changelogURL: "https://github.com/anthropics/claude-code/releases",
                 statusPageURL: "https://status.claude.com/"),
             branding: ProviderBranding(
                 iconStyle: .claude,
@@ -33,7 +33,7 @@ public enum ClaudeProviderDescriptor {
                 supportsTokenCost: true,
                 noDataMessage: self.noDataMessage),
             fetchPlan: ProviderFetchPlan(
-                sourceModes: [.auto, .web, .cli, .oauth],
+                sourceModes: [.auto, .api, .web, .cli, .oauth],
                 pipeline: ProviderFetchPipeline(resolveStrategies: self.resolveStrategies)),
             cli: ProviderCLIConfig(
                 name: "claude",
@@ -43,57 +43,65 @@ public enum ClaudeProviderDescriptor {
     }
 
     private static func resolveStrategies(context: ProviderFetchContext) async -> [any ProviderFetchStrategy] {
-        switch context.runtime {
-        case .cli:
-            switch context.sourceMode {
-            case .oauth:
-                return [ClaudeOAuthFetchStrategy()]
-            case .web:
-                return [ClaudeWebFetchStrategy(browserDetection: context.browserDetection)]
-            case .cli:
-                return [ClaudeCLIFetchStrategy(
-                    useWebExtras: false,
-                    manualCookieHeader: nil,
-                    browserDetection: context.browserDetection)]
+        if context.sourceMode == .api || self.hasAutoAdminAPIKey(context: context) {
+            return [ClaudeAdminAPIFetchStrategy()]
+        }
+        if ClaudeAdminAPIFetchStrategy.isSelectedAdminAPIAccount(context: context) {
+            return [ClaudeAdminAPIFetchStrategy()]
+        }
+
+        let planningInput = await Self.makePlanningInput(context: context)
+        let plan = ClaudeSourcePlanner.resolve(input: planningInput)
+        let manualCookieHeader = Self.manualCookieHeader(from: context)
+
+        return plan.orderedSteps.map { step in
+            let strategy: any ProviderFetchStrategy = switch step.dataSource {
             case .api:
-                return []
-            case .auto:
-                return [
-                    ClaudeWebFetchStrategy(browserDetection: context.browserDetection),
-                    ClaudeCLIFetchStrategy(
-                        useWebExtras: false,
-                        manualCookieHeader: nil,
-                        browserDetection: context.browserDetection),
-                ]
-            }
-        case .app:
-            let webExtrasEnabled = context.settings?.claude?.webExtrasEnabled ?? false
-            let manualCookieHeader = CookieHeaderNormalizer.normalize(context.settings?.claude?.manualCookieHeader)
-            switch context.sourceMode {
+                ClaudeAdminAPIFetchStrategy()
             case .oauth:
-                return [ClaudeOAuthFetchStrategy()]
+                ClaudeOAuthFetchStrategy()
             case .web:
-                return [ClaudeWebFetchStrategy(browserDetection: context.browserDetection)]
+                ClaudeWebFetchStrategy(browserDetection: context.browserDetection)
             case .cli:
-                return [ClaudeCLIFetchStrategy(
-                    useWebExtras: webExtrasEnabled,
+                ClaudeCLIFetchStrategy(
+                    useWebExtras: context.runtime == .app
+                        && planningInput.webExtrasEnabled,
                     manualCookieHeader: manualCookieHeader,
-                    browserDetection: context.browserDetection)]
-            case .api:
-                return []
+                    browserDetection: context.browserDetection)
             case .auto:
-                return [
-                    ClaudeOAuthFetchStrategy(),
-                    ClaudeCLIFetchStrategy(
-                        useWebExtras: webExtrasEnabled,
-                        manualCookieHeader: manualCookieHeader,
-                        browserDetection: context.browserDetection),
-                    ClaudeWebFetchStrategy(browserDetection: context.browserDetection),
-                ]
+                fatalError("Planner must not emit .auto as an executable step.")
             }
+            return ClaudePlannedFetchStrategy(base: strategy, plannedStep: step)
         }
     }
 
+    private static func hasAutoAdminAPIKey(context: ProviderFetchContext) -> Bool {
+        context.sourceMode == .auto && ClaudeAdminAPISettingsReader.apiKey(environment: context.env) != nil
+    }
+
+    private static func makePlanningInput(context: ProviderFetchContext) async -> ClaudeSourcePlanningInput {
+        let webExtrasEnabled = context.settings?.claude?.webExtrasEnabled ?? false
+        let needsOAuthAvailability = context.runtime == .app && context.sourceMode == .auto
+
+        return ClaudeSourcePlanningInput(
+            runtime: context.runtime,
+            selectedDataSource: Self.sourceDataSource(from: context.sourceMode),
+            webExtrasEnabled: webExtrasEnabled,
+            hasWebSession: ClaudeWebFetchStrategy.isAvailableForFallback(
+                context: context,
+                browserDetection: context.browserDetection),
+            hasCLI: ClaudeCLIResolver.isAvailable(environment: context.env),
+            hasOAuthCredentials: needsOAuthAvailability && ClaudeOAuthPlanningAvailability.isAvailable(
+                runtime: context.runtime,
+                sourceMode: context.sourceMode,
+                environment: context.env))
+    }
+
+    private static func manualCookieHeader(from context: ProviderFetchContext) -> String? {
+        guard context.settings?.claude?.cookieSource == .manual else { return nil }
+        return CookieHeaderNormalizer.normalize(context.settings?.claude?.manualCookieHeader)
+    }
+
     private static func noDataMessage() -> String {
         "No Claude usage logs found in ~/.config/claude/projects or ~/.claude/projects."
     }
@@ -105,21 +113,29 @@ public enum ClaudeProviderDescriptor {
         hasCLI: Bool,
         hasOAuthCredentials: Bool) -> ClaudeUsageStrategy
     {
-        if selectedDataSource == .auto {
-            if hasOAuthCredentials {
-                return ClaudeUsageStrategy(dataSource: .oauth, useWebExtras: false)
-            }
-            if hasCLI {
-                return ClaudeUsageStrategy(dataSource: .cli, useWebExtras: false)
-            }
-            if hasWebSession {
-                return ClaudeUsageStrategy(dataSource: .web, useWebExtras: false)
-            }
-            return ClaudeUsageStrategy(dataSource: .cli, useWebExtras: false)
-        }
+        let plan = ClaudeSourcePlanner.resolve(input: ClaudeSourcePlanningInput(
+            runtime: .app,
+            selectedDataSource: selectedDataSource,
+            webExtrasEnabled: webExtrasEnabled,
+            hasWebSession: hasWebSession,
+            hasCLI: hasCLI,
+            hasOAuthCredentials: hasOAuthCredentials))
+        return plan.compatibilityStrategy ?? ClaudeUsageStrategy(dataSource: selectedDataSource, useWebExtras: false)
+    }
 
-        let useWebExtras = selectedDataSource == .cli && webExtrasEnabled && hasWebSession
-        return ClaudeUsageStrategy(dataSource: selectedDataSource, useWebExtras: useWebExtras)
+    private static func sourceDataSource(from mode: ProviderSourceMode) -> ClaudeUsageDataSource {
+        switch mode {
+        case .auto:
+            .auto
+        case .api:
+            .api
+        case .web:
+            .web
+        case .cli:
+            .cli
+        case .oauth:
+            .oauth
+        }
     }
 }
 
@@ -128,6 +144,90 @@ public struct ClaudeUsageStrategy: Equatable, Sendable {
     public let useWebExtras: Bool
 }
 
+public enum ClaudeOAuthPlanningAvailability {
+    public static func isAvailable(
+        runtime: ProviderRuntime,
+        sourceMode: ProviderSourceMode,
+        environment: [String: String]) -> Bool
+    {
+        ClaudeOAuthFetchStrategy.isPlausiblyAvailable(
+            runtime: runtime,
+            sourceMode: sourceMode,
+            environment: environment)
+    }
+}
+
+private struct ClaudePlannedFetchStrategy: ProviderFetchStrategy {
+    let base: any ProviderFetchStrategy
+    let plannedStep: ClaudeFetchPlanStep
+
+    var id: String {
+        self.base.id
+    }
+
+    var kind: ProviderFetchKind {
+        self.base.kind
+    }
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        if context.sourceMode == .auto {
+            return self.plannedStep.isPlausiblyAvailable
+        }
+        return await self.base.isAvailable(context)
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        try await self.base.fetch(context)
+    }
+
+    func shouldFallback(on error: Error, context: ProviderFetchContext) -> Bool {
+        self.base.shouldFallback(on: error, context: context)
+    }
+}
+
+struct ClaudeAdminAPIFetchStrategy: ProviderFetchStrategy {
+    let id: String = "claude.admin-api"
+    let kind: ProviderFetchKind = .apiToken
+    let usageFetcher: @Sendable (String) async throws -> ClaudeAdminAPIUsageSnapshot
+
+    init(
+        usageFetcher: @escaping @Sendable (String) async throws -> ClaudeAdminAPIUsageSnapshot = { apiKey in
+            try await ClaudeAdminAPIUsageFetcher.fetchUsage(apiKey: apiKey)
+        })
+    {
+        self.usageFetcher = usageFetcher
+    }
+
+    static func isSelectedAdminAPIAccount(context: ProviderFetchContext) -> Bool {
+        guard context.selectedTokenAccountID != nil else { return false }
+        return self.resolveToken(environment: context.env) != nil
+    }
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        Self.resolveToken(environment: context.env) != nil
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        guard let apiKey = Self.resolveToken(environment: context.env) else {
+            throw ClaudeAdminAPISettingsError.missingToken
+        }
+        let usage = try await self.usageFetcher(apiKey)
+        return self.makeResult(
+            usage: usage.toUsageSnapshot(),
+            sourceLabel: "admin-api")
+    }
+
+    func shouldFallback(on _: Error, context: ProviderFetchContext) -> Bool {
+        context.runtime == .app &&
+            context.sourceMode == .auto &&
+            !Self.isSelectedAdminAPIAccount(context: context)
+    }
+
+    private static func resolveToken(environment: [String: String]) -> String? {
+        ProviderTokenResolver.claudeAdminAPIToken(environment: environment)
+    }
+}
+
 struct ClaudeOAuthFetchStrategy: ProviderFetchStrategy {
     let id: String = "claude.oauth"
     let kind: ProviderFetchKind = .oauth
@@ -137,82 +237,79 @@ struct ClaudeOAuthFetchStrategy: ProviderFetchStrategy {
     @TaskLocal static var claudeCLIAvailableOverride: Bool?
     #endif
 
-    private func loadNonInteractiveCredentialRecord(_ context: ProviderFetchContext) -> ClaudeOAuthCredentialRecord? {
+    private func loadNonInteractiveCredentialRecord(environment: [String: String]) -> ClaudeOAuthCredentialRecord? {
         #if DEBUG
         if let override = Self.nonInteractiveCredentialRecordOverride { return override }
         #endif
 
         return try? ClaudeOAuthCredentialsStore.loadRecord(
-            environment: context.env,
+            environment: environment,
             allowKeychainPrompt: false,
             respectKeychainPromptCooldown: true,
             allowClaudeKeychainRepairWithoutPrompt: false)
     }
 
-    private func isClaudeCLIAvailable() -> Bool {
+    private func isClaudeCLIAvailable(environment: [String: String]) -> Bool {
         #if DEBUG
         if let override = Self.claudeCLIAvailableOverride { return override }
         #endif
-        return ClaudeOAuthDelegatedRefreshCoordinator.isClaudeCLIAvailable()
+        return ClaudeCLIResolver.isAvailable(environment: environment)
     }
 
-    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
-        let nonInteractiveRecord = self.loadNonInteractiveCredentialRecord(context)
+    static func isPlausiblyAvailable(
+        runtime: ProviderRuntime,
+        sourceMode: ProviderSourceMode,
+        environment: [String: String]) -> Bool
+    {
+        let hasEnvironmentOAuthToken = !(environment[ClaudeOAuthCredentialsStore.environmentTokenKey]?
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .isEmpty ?? true)
+        if hasEnvironmentOAuthToken {
+            return true
+        }
+
+        let strategy = ClaudeOAuthFetchStrategy()
+        let nonInteractiveRecord = strategy.loadNonInteractiveCredentialRecord(environment: environment)
         let nonInteractiveCredentials = nonInteractiveRecord?.credentials
         let hasRequiredScopeWithoutPrompt = nonInteractiveCredentials?.scopes.contains("user:profile") == true
         if hasRequiredScopeWithoutPrompt, nonInteractiveCredentials?.isExpired == false {
-            // Gate controls refresh attempts, not use of already-valid access tokens.
             return true
         }
 
-        let hasEnvironmentOAuthToken = !(context.env[ClaudeOAuthCredentialsStore.environmentTokenKey]?
-            .trimmingCharacters(in: .whitespacesAndNewlines)
-            .isEmpty ?? true)
-        let claudeCLIAvailable = self.isClaudeCLIAvailable()
-
-        if hasEnvironmentOAuthToken {
-            return true
-        }
+        let claudeCLIAvailable = strategy.isClaudeCLIAvailable(environment: environment)
 
         if let nonInteractiveRecord, hasRequiredScopeWithoutPrompt, nonInteractiveRecord.credentials.isExpired {
             switch nonInteractiveRecord.owner {
             case .codexbar:
                 let refreshToken = nonInteractiveRecord.credentials.refreshToken?
                     .trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
-                if context.sourceMode == .auto {
+                if sourceMode == .auto {
                     return !refreshToken.isEmpty
                 }
                 return true
             case .claudeCLI:
-                if context.sourceMode == .auto {
+                if sourceMode == .auto {
                     return claudeCLIAvailable
                 }
                 return true
             case .environment:
-                return context.sourceMode != .auto
+                return sourceMode != .auto
             }
         }
 
-        guard context.sourceMode == .auto else { return true }
+        guard sourceMode == .auto else { return true }
 
-        // Prefer OAuth in Auto mode only when it’s plausibly usable:
-        // - we can load credentials without prompting (env / CodexBar cache / credentials file) AND they meet the
-        //   scope requirement, or
-        // - Claude Code has stored OAuth creds in Keychain and we may be able to bootstrap (one prompt max).
-        //
-        // User actions should be able to recover immediately even if a prior background attempt tripped the
-        // keychain cooldown gate. Clear the cooldown before deciding availability so the fetch path can proceed.
+        let fallbackPromptMode = ClaudeOAuthKeychainPromptPreference.securityFrameworkFallbackMode()
         let promptPolicyApplicable = ClaudeOAuthKeychainPromptPreference.isApplicable()
-        if promptPolicyApplicable, ProviderInteractionContext.current == .userInitiated {
+        if ProviderInteractionContext.current == .userInitiated {
             _ = ClaudeOAuthKeychainAccessGate.clearDenied()
         }
 
-        let shouldAllowStartupBootstrap = promptPolicyApplicable &&
-            context.runtime == .app &&
+        let shouldAllowStartupBootstrap = runtime == .app &&
             ProviderRefreshContext.current == .startup &&
             ProviderInteractionContext.current == .background &&
-            ClaudeOAuthKeychainPromptPreference.current() == .onlyOnUserAction &&
-            !ClaudeOAuthCredentialsStore.hasCachedCredentials(environment: context.env)
+            fallbackPromptMode == .onlyOnUserAction &&
+            !ClaudeOAuthCredentialsStore.hasCachedCredentials(environment: environment)
         if shouldAllowStartupBootstrap {
             return ClaudeOAuthKeychainAccessGate.shouldAllowPrompt()
         }
@@ -225,6 +322,13 @@ struct ClaudeOAuthFetchStrategy: ProviderFetchStrategy {
         return ClaudeOAuthCredentialsStore.hasClaudeKeychainCredentialsWithoutPrompt()
     }
 
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        Self.isPlausiblyAvailable(
+            runtime: context.runtime,
+            sourceMode: context.sourceMode,
+            environment: context.env)
+    }
+
     func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
         let fetcher = ClaudeUsageFetcher(
             browserDetection: context.browserDetection,
@@ -253,14 +357,20 @@ struct ClaudeOAuthFetchStrategy: ProviderFetchStrategy {
             accountEmail: usage.accountEmail,
             accountOrganization: usage.accountOrganization,
             loginMethod: usage.loginMethod)
+        let primary = usage.primaryWindowKind == .spendLimit ? nil : usage.primary
         return UsageSnapshot(
-            primary: usage.primary,
+            primary: primary,
             secondary: usage.secondary,
             tertiary: usage.opus,
+            extraRateWindows: usage.extraRateWindows.isEmpty ? nil : usage.extraRateWindows,
             providerCost: usage.providerCost,
             updatedAt: usage.updatedAt,
             identity: identity)
     }
+
+    static func _snapshotForTesting(from usage: ClaudeUsageSnapshot) -> UsageSnapshot {
+        self.snapshot(from: usage)
+    }
 }
 
 struct ClaudeWebFetchStrategy: ProviderFetchStrategy {
@@ -277,7 +387,8 @@ struct ClaudeWebFetchStrategy: ProviderFetchStrategy {
             browserDetection: browserDetection,
             dataSource: .web,
             useWebExtras: false,
-            manualCookieHeader: Self.manualCookieHeader(from: context))
+            manualCookieHeader: Self.manualCookieHeader(from: context),
+            webOrganizationID: context.settings?.claude?.organizationID)
         let usage = try await fetcher.loadLatestUsage(model: "sonnet")
         return self.makeResult(
             usage: ClaudeOAuthFetchStrategy.snapshot(from: usage),
@@ -324,9 +435,11 @@ struct ClaudeCLIFetchStrategy: ProviderFetchStrategy {
         let keepAlive = context.settings?.debugKeepCLISessionsAlive ?? false
         let fetcher = ClaudeUsageFetcher(
             browserDetection: browserDetection,
+            environment: context.env,
             dataSource: .cli,
             useWebExtras: self.useWebExtras,
             manualCookieHeader: self.manualCookieHeader,
+            webOrganizationID: context.settings?.claude?.organizationID,
             keepCLISessionsAlive: keepAlive)
         let usage = try await fetcher.loadLatestUsage(model: "sonnet")
         return self.makeResult(
diff --git a/Sources/CodexBarCore/Providers/Claude/ClaudeSourcePlanner.swift b/Sources/CodexBarCore/Providers/Claude/ClaudeSourcePlanner.swift
new file mode 100644
index 0000000000..24ae2c0c12
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Claude/ClaudeSourcePlanner.swift
@@ -0,0 +1,224 @@
+import Foundation
+
+public struct ClaudeSourcePlanningInput: Equatable, Sendable {
+    public let runtime: ProviderRuntime
+    public let selectedDataSource: ClaudeUsageDataSource
+    public let webExtrasEnabled: Bool
+    public let hasWebSession: Bool
+    public let hasCLI: Bool
+    public let hasOAuthCredentials: Bool
+
+    public init(
+        runtime: ProviderRuntime,
+        selectedDataSource: ClaudeUsageDataSource,
+        webExtrasEnabled: Bool,
+        hasWebSession: Bool,
+        hasCLI: Bool,
+        hasOAuthCredentials: Bool)
+    {
+        self.runtime = runtime
+        self.selectedDataSource = selectedDataSource
+        self.webExtrasEnabled = webExtrasEnabled
+        self.hasWebSession = hasWebSession
+        self.hasCLI = hasCLI
+        self.hasOAuthCredentials = hasOAuthCredentials
+    }
+}
+
+public enum ClaudeSourcePlanReason: String, Equatable, Sendable {
+    case explicitSourceSelection = "explicit-source-selection"
+    case appAutoPreferredOAuth = "app-auto-preferred-oauth"
+    case appAutoFallbackCLI = "app-auto-fallback-cli"
+    case appAutoFallbackWeb = "app-auto-fallback-web"
+    case cliAutoPreferredWeb = "cli-auto-preferred-web"
+    case cliAutoFallbackCLI = "cli-auto-fallback-cli"
+}
+
+public struct ClaudeFetchPlanStep: Equatable, Sendable {
+    public let dataSource: ClaudeUsageDataSource
+    public let inclusionReason: ClaudeSourcePlanReason
+    public let isPlausiblyAvailable: Bool
+
+    public init(
+        dataSource: ClaudeUsageDataSource,
+        inclusionReason: ClaudeSourcePlanReason,
+        isPlausiblyAvailable: Bool)
+    {
+        self.dataSource = dataSource
+        self.inclusionReason = inclusionReason
+        self.isPlausiblyAvailable = isPlausiblyAvailable
+    }
+}
+
+public struct ClaudeFetchPlan: Equatable, Sendable {
+    public let input: ClaudeSourcePlanningInput
+    public let orderedSteps: [ClaudeFetchPlanStep]
+
+    public init(input: ClaudeSourcePlanningInput, orderedSteps: [ClaudeFetchPlanStep]) {
+        self.input = input
+        self.orderedSteps = orderedSteps
+    }
+
+    public var availableSteps: [ClaudeFetchPlanStep] {
+        self.orderedSteps.filter(\.isPlausiblyAvailable)
+    }
+
+    public var isNoSourceAvailable: Bool {
+        self.availableSteps.isEmpty
+    }
+
+    public var preferredStep: ClaudeFetchPlanStep? {
+        switch self.input.selectedDataSource {
+        case .auto:
+            self.availableSteps.first
+        case .api, .oauth, .web, .cli:
+            self.orderedSteps.first
+        }
+    }
+
+    public var executionSteps: [ClaudeFetchPlanStep] {
+        switch self.input.selectedDataSource {
+        case .auto:
+            self.availableSteps
+        case .api, .oauth, .web, .cli:
+            self.orderedSteps
+        }
+    }
+
+    public var compatibilityStrategy: ClaudeUsageStrategy? {
+        guard let preferredStep else { return nil }
+        let useWebExtras = self.input.runtime == .app
+            && preferredStep.dataSource == .cli
+            && self.input.webExtrasEnabled
+        return ClaudeUsageStrategy(
+            dataSource: preferredStep.dataSource,
+            useWebExtras: useWebExtras)
+    }
+
+    public var orderLabel: String {
+        self.orderedSteps.map(\.dataSource.sourceLabel).joined(separator: "→")
+    }
+
+    public func debugLines() -> [String] {
+        var lines = ["planner_order=\(self.orderLabel)"]
+        lines.append("planner_selected=\(self.preferredStep?.dataSource.rawValue ?? "none")")
+        lines.append("planner_no_source=\(self.isNoSourceAvailable)")
+        for step in self.orderedSteps {
+            let availability = step.isPlausiblyAvailable ? "available" : "unavailable"
+            lines.append(
+                "planner_step.\(step.dataSource.rawValue)=\(availability) reason=\(step.inclusionReason.rawValue)")
+        }
+        return lines
+    }
+}
+
+public enum ClaudeCLIResolver {
+    #if DEBUG
+    @TaskLocal static var resolvedBinaryPathOverrideForTesting: String?
+
+    public static var currentResolvedBinaryPathOverrideForTesting: String? {
+        self.resolvedBinaryPathOverrideForTesting
+    }
+
+    public static func withResolvedBinaryPathOverrideForTesting<T>(
+        _ path: String?,
+        operation: () async throws -> T) async rethrows -> T
+    {
+        try await self.$resolvedBinaryPathOverrideForTesting.withValue(path) {
+            try await operation()
+        }
+    }
+    #endif
+
+    public static func resolvedBinaryPath(
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        loginPATH: [String]? = LoginShellPathCache.shared.current)
+        -> String?
+    {
+        #if DEBUG
+        if let override = self.resolvedBinaryPathOverrideForTesting {
+            return FileManager.default.isExecutableFile(atPath: override) ? override : nil
+        }
+        #endif
+
+        var normalizedEnvironment = environment
+        if let override = environment["CLAUDE_CLI_PATH"]?.trimmingCharacters(in: .whitespacesAndNewlines) {
+            if override.isEmpty {
+                normalizedEnvironment.removeValue(forKey: "CLAUDE_CLI_PATH")
+            } else {
+                normalizedEnvironment["CLAUDE_CLI_PATH"] = override
+                if FileManager.default.isExecutableFile(atPath: override) {
+                    return override
+                }
+            }
+        }
+
+        return BinaryLocator.resolveClaudeBinary(
+            env: normalizedEnvironment,
+            loginPATH: loginPATH)
+    }
+
+    public static func isAvailable(environment: [String: String] = ProcessInfo.processInfo.environment) -> Bool {
+        self.resolvedBinaryPath(environment: environment) != nil
+    }
+}
+
+public enum ClaudeSourcePlanner {
+    public static func resolve(input: ClaudeSourcePlanningInput) -> ClaudeFetchPlan {
+        ClaudeFetchPlan(input: input, orderedSteps: self.makeSteps(input: input))
+    }
+
+    private static func makeSteps(input: ClaudeSourcePlanningInput) -> [ClaudeFetchPlanStep] {
+        switch input.selectedDataSource {
+        case .auto:
+            switch input.runtime {
+            case .app:
+                [
+                    self.step(.oauth, reason: .appAutoPreferredOAuth, input: input),
+                    self.step(.cli, reason: .appAutoFallbackCLI, input: input),
+                    self.step(.web, reason: .appAutoFallbackWeb, input: input),
+                ]
+            case .cli:
+                [
+                    self.step(.web, reason: .cliAutoPreferredWeb, input: input),
+                    self.step(.cli, reason: .cliAutoFallbackCLI, input: input),
+                ]
+            }
+        case .api:
+            [self.step(.api, reason: .explicitSourceSelection, input: input)]
+        case .oauth:
+            [self.step(.oauth, reason: .explicitSourceSelection, input: input)]
+        case .web:
+            [self.step(.web, reason: .explicitSourceSelection, input: input)]
+        case .cli:
+            [self.step(.cli, reason: .explicitSourceSelection, input: input)]
+        }
+    }
+
+    private static func step(
+        _ dataSource: ClaudeUsageDataSource,
+        reason: ClaudeSourcePlanReason,
+        input: ClaudeSourcePlanningInput) -> ClaudeFetchPlanStep
+    {
+        ClaudeFetchPlanStep(
+            dataSource: dataSource,
+            inclusionReason: reason,
+            isPlausiblyAvailable: self.isPlausiblyAvailable(dataSource, input: input))
+    }
+
+    private static func isPlausiblyAvailable(
+        _ dataSource: ClaudeUsageDataSource,
+        input: ClaudeSourcePlanningInput) -> Bool
+    {
+        switch dataSource {
+        case .auto, .api:
+            false
+        case .oauth:
+            input.hasOAuthCredentials
+        case .web:
+            input.hasWebSession
+        case .cli:
+            input.hasCLI
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Claude/ClaudeStatusProbe.swift b/Sources/CodexBarCore/Providers/Claude/ClaudeStatusProbe.swift
index f5e768624e..1274b38787 100644
--- a/Sources/CodexBarCore/Providers/Claude/ClaudeStatusProbe.swift
+++ b/Sources/CodexBarCore/Providers/Claude/ClaudeStatusProbe.swift
@@ -48,6 +48,10 @@ public struct ClaudeStatusProbe: Sendable {
     public var timeout: TimeInterval = 20.0
     public var keepCLISessionsAlive: Bool = false
     private static let log = CodexBarLog.logger(LogCategories.claudeProbe)
+    #if DEBUG
+    public typealias FetchOverride = @Sendable (String, TimeInterval, Bool) async throws -> ClaudeStatusSnapshot
+    @TaskLocal static var fetchOverride: FetchOverride?
+    #endif
 
     public init(claudeBinary: String = "claude", timeout: TimeInterval = 20.0, keepCLISessionsAlive: Bool = false) {
         self.claudeBinary = claudeBinary
@@ -55,15 +59,44 @@ public struct ClaudeStatusProbe: Sendable {
         self.keepCLISessionsAlive = keepCLISessionsAlive
     }
 
+    #if DEBUG
+    public static var currentFetchOverrideForTesting: FetchOverride? {
+        self.fetchOverride
+    }
+
+    public static func withFetchOverrideForTesting<T>(
+        _ override: FetchOverride?,
+        operation: () async throws -> T) async rethrows -> T
+    {
+        try await self.$fetchOverride.withValue(override) {
+            try await operation()
+        }
+    }
+
+    public static func withFetchOverrideForTesting<T>(
+        _ override: FetchOverride?,
+        operation: () async -> T) async -> T
+    {
+        await self.$fetchOverride.withValue(override) {
+            await operation()
+        }
+    }
+    #endif
+
     public func fetch() async throws -> ClaudeStatusSnapshot {
         let resolved = Self.resolvedBinaryPath(binaryName: self.claudeBinary)
-        guard Self.isBinaryAvailable(resolved) else {
+        guard let resolved, Self.isBinaryAvailable(resolved) else {
             throw ClaudeStatusProbeError.claudeNotInstalled
         }
 
         // Run commands sequentially through a shared Claude session to avoid warm-up churn.
         let timeout = self.timeout
         let keepAlive = self.keepCLISessionsAlive
+        #if DEBUG
+        if let override = Self.fetchOverride {
+            return try await override(resolved, timeout, keepAlive)
+        }
+        #endif
         do {
             var usage = try await Self.capture(subcommand: "/usage", binary: resolved, timeout: timeout)
             if !Self.usageOutputLooksRelevant(usage) {
@@ -79,17 +112,24 @@ public struct ClaudeStatusProbe: Sendable {
                 "opusPercentLeft": "\(snap.opusPercentLeft ?? -1)",
             ])
             if !keepAlive {
-                await ClaudeCLISession.shared.reset()
+                await Self.resetTransientCLISessionAndCleanupProbeArtifacts()
             }
             return snap
         } catch {
             if !keepAlive {
-                await ClaudeCLISession.shared.reset()
+                await Self.resetTransientCLISessionAndCleanupProbeArtifacts()
             }
             throw error
         }
     }
 
+    private static func resetTransientCLISessionAndCleanupProbeArtifacts() async {
+        await ClaudeCLISession.current.reset()
+        let removed = ClaudeProbeSessionArtifactCleaner.cleanupProbeSessionArtifacts()
+        guard !removed.isEmpty else { return }
+        Self.log.debug("Claude probe session artifacts removed", metadata: ["count": "\(removed.count)"])
+    }
+
     // MARK: - Parsing helpers
 
     private struct LabelSearchContext {
@@ -104,15 +144,11 @@ public struct ClaudeStatusProbe: Sendable {
             self.normalizedData = Data(normalized.utf8)
         }
 
-        func contains(_ needle: Data) -> Bool {
-            self.normalizedData.range(of: needle) != nil
+        func contains(_ needle: String) -> Bool {
+            self.normalizedData.range(of: Data(needle.utf8)) != nil
         }
     }
 
-    private static let weeklyLabelNeedle = Data("current week".utf8)
-    private static let opusLabelNeedle = Data("opus".utf8)
-    private static let sonnetLabelNeedle = Data("sonnet".utf8)
-
     public static func parse(text: String, statusText: String? = nil) throws -> ClaudeStatusSnapshot {
         let clean = TextParsing.stripANSICodes(text)
         let statusClean = statusText.map(TextParsing.stripANSICodes)
@@ -129,11 +165,21 @@ public struct ClaudeStatusProbe: Sendable {
             throw ClaudeStatusProbeError.parseFailed(usageError)
         }
 
+        let latestUsagePanel = self.trimToLatestUsagePanel(clean)
+        if self.isUsageStillLoading(text: latestUsagePanel ?? clean) {
+            Self.dumpIfNeeded(
+                enabled: shouldDump,
+                reason: "usage still loading",
+                usage: clean,
+                status: statusText)
+            throw ClaudeStatusProbeError.parseFailed("Claude CLI /usage is still loading usage data.")
+        }
+
         // Claude CLI renders /usage as a TUI. Our PTY capture includes earlier screen fragments (including a status
         // line
         // with a "0%" context meter) before the usage panel is drawn. To keep parsing stable, trim to the last
         // Settings/Usage panel when present.
-        let usagePanelText = self.trimToLatestUsagePanel(clean) ?? clean
+        let usagePanelText = latestUsagePanel ?? clean
         let labelContext = LabelSearchContext(text: usagePanelText)
 
         var sessionPct = self.extractPercent(labelSubstring: "Current session", context: labelContext)
@@ -151,9 +197,9 @@ public struct ClaudeStatusProbe: Sendable {
         // may omit the weekly panel entirely, and we should treat that as "unavailable" rather than guessing.
         let compactContext = usagePanelText.lowercased().filter { !$0.isWhitespace }
         let hasWeeklyLabel =
-            labelContext.contains(Self.weeklyLabelNeedle)
+            labelContext.contains("currentweek")
             || compactContext.contains("currentweek")
-        let hasOpusLabel = labelContext.contains(Self.opusLabelNeedle) || labelContext.contains(Self.sonnetLabelNeedle)
+        let hasOpusLabel = labelContext.contains("opus") || labelContext.contains("sonnet")
 
         if sessionPct == nil || (hasWeeklyLabel && weeklyPct == nil) || (hasOpusLabel && opusPct == nil) {
             let ordered = self.allPercents(usagePanelText)
@@ -212,18 +258,24 @@ public struct ClaudeStatusProbe: Sendable {
         return self.extractIdentity(usageText: usageClean, statusText: statusClean)
     }
 
-    public static func fetchIdentity(timeout: TimeInterval = 12.0) async throws -> ClaudeAccountIdentity {
-        let resolved = self.resolvedBinaryPath(binaryName: "claude")
-        guard self.isBinaryAvailable(resolved) else {
+    public static func fetchIdentity(
+        timeout: TimeInterval = 12.0,
+        environment: [String: String] = ProcessInfo.processInfo.environment) async throws -> ClaudeAccountIdentity
+    {
+        let resolved = self.resolvedBinaryPath(binaryName: "claude", environment: environment)
+        guard let resolved, self.isBinaryAvailable(resolved) else {
             throw ClaudeStatusProbeError.claudeNotInstalled
         }
         let statusText = try await Self.capture(subcommand: "/status", binary: resolved, timeout: timeout)
         return Self.parseIdentity(usageText: nil, statusText: statusText)
     }
 
-    public static func touchOAuthAuthPath(timeout: TimeInterval = 8) async throws {
-        let resolved = self.resolvedBinaryPath(binaryName: "claude")
-        guard self.isBinaryAvailable(resolved) else {
+    public static func touchOAuthAuthPath(
+        timeout: TimeInterval = 8,
+        environment: [String: String] = ProcessInfo.processInfo.environment) async throws
+    {
+        let resolved = self.resolvedBinaryPath(binaryName: "claude", environment: environment)
+        guard let resolved, self.isBinaryAvailable(resolved) else {
             throw ClaudeStatusProbeError.claudeNotInstalled
         }
         do {
@@ -245,8 +297,10 @@ public struct ClaudeStatusProbe: Sendable {
         }
     }
 
-    public static func isClaudeBinaryAvailable() -> Bool {
-        let resolved = self.resolvedBinaryPath(binaryName: "claude")
+    public static func isClaudeBinaryAvailable(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> Bool
+    {
+        let resolved = self.resolvedBinaryPath(binaryName: "claude", environment: environment)
         return self.isBinaryAvailable(resolved)
     }
 
@@ -270,6 +324,7 @@ public struct ClaudeStatusProbe: Sendable {
             || normalized.contains("currentweek")
             || normalized.contains("loadingusage")
             || normalized.contains("failedtoloadusagedata")
+            || self.usageCaptureHasSubscriptionNotice(normalized)
     }
 
     private static func extractPercent(labelSubstrings: [String], context: LabelSearchContext) -> Int? {
@@ -406,6 +461,9 @@ public struct ClaudeStatusProbe: Sendable {
         {
             return "Claude CLI usage endpoint is rate limited right now. Please try again later."
         }
+        if self.isSubscriptionNoticeOnly(text: text) {
+            return "Claude CLI /usage returned a subscription notice without session quota data."
+        }
         if lower.contains("failed to load usage data") {
             return "Claude CLI could not load usage data. Open the CLI and retry `/usage`."
         }
@@ -415,6 +473,30 @@ public struct ClaudeStatusProbe: Sendable {
         return nil
     }
 
+    private static func isUsageStillLoading(text: String) -> Bool {
+        let normalized = TextParsing.stripANSICodes(text).lowercased().filter { !$0.isWhitespace }
+        guard normalized.contains("loadingusage") else { return false }
+        return !self.usageCaptureHasSessionValue(normalized) && self.allPercents(text).isEmpty
+    }
+
+    /// Returns true when the text contains only a subscription notice with no session/weekly quota data.
+    /// CLI 2.1+ can return "You are currently using your subscription to power your Claude Code usage"
+    /// which lacks the "Current session" / "Current week" labels and percentage values needed for quota display.
+    /// A PTY capture may contain both an intermediate "Loading usage data…" panel and the final subscription
+    /// notice; `loadingusage` is not treated as quota data in this check so mixed captures surface correctly.
+    private static func isSubscriptionNoticeOnly(text: String) -> Bool {
+        let normalized = text.lowercased().filter { !$0.isWhitespace }
+        guard normalized.contains("currentlyusingyoursubscription") else { return false }
+        guard normalized.contains("claudecodeusage") else { return false }
+        // Only real session/week labels and actual percentage values count as quota data.
+        // `loadingusage` is not quota data — a mixed loading+subscription PTY capture should
+        // surface the subscription error, not a still-loading stall.
+        let hasQuotaData = normalized.contains("currentsession") || normalized.contains("currentweek")
+            || normalized.contains("%used") || normalized.contains("%left") || normalized.contains("%remaining")
+            || normalized.contains("%available")
+        return !hasQuotaData
+    }
+
     /// Collect remaining percentages in the order they appear; used as a backup when labels move/rename.
     private static func allPercents(_ text: String) -> [Int] {
         let lines = text.components(separatedBy: .newlines)
@@ -459,7 +541,7 @@ public struct ClaudeStatusProbe: Sendable {
             for candidate in window {
                 let trimmed = candidate.trimmingCharacters(in: .whitespacesAndNewlines)
                 let normalized = self.normalizedForLabelSearch(trimmed)
-                if normalized.hasPrefix("current "), !normalized.contains(label) { break }
+                if normalized.hasPrefix("current"), !normalized.contains(label) { break }
                 if let reset = self.resetFromLine(candidate) { return reset }
             }
         }
@@ -480,9 +562,7 @@ public struct ClaudeStatusProbe: Sendable {
     }
 
     private static func normalizedForLabelSearch(_ text: String) -> String {
-        text.lowercased()
-            .split(whereSeparator: { $0.isWhitespace })
-            .joined(separator: " ")
+        String(text.lowercased().unicodeScalars.filter(CharacterSet.alphanumerics.contains))
     }
 
     /// Capture all "Resets ..." strings to surface in the menu.
@@ -579,6 +659,9 @@ public struct ClaudeStatusProbe: Sendable {
         guard var raw = text?.trimmingCharacters(in: .whitespacesAndNewlines), !raw.isEmpty else { return nil }
         raw = raw.replacingOccurrences(of: #"(?i)^resets?:?\s*"#, with: "", options: .regularExpression)
         raw = raw.replacingOccurrences(of: " at ", with: " ", options: .caseInsensitive)
+        raw = raw.replacingOccurrences(of: #"(?i)\b([A-Za-z]{3})(\d)"#, with: "$1 $2", options: .regularExpression)
+        raw = raw.replacingOccurrences(of: #",(\d)"#, with: ", $1", options: .regularExpression)
+        raw = raw.replacingOccurrences(of: #"(?i)(\d)at(?=\d)"#, with: "$1 ", options: .regularExpression)
         raw = raw.replacingOccurrences(
             of: #"(?<=\d)\.(\d{2})\b"#,
             with: ":$1",
@@ -610,11 +693,14 @@ public struct ClaudeStatusProbe: Sendable {
     private static func extractLoginMethod(text: String) -> String? {
         guard !text.isEmpty else { return nil }
         if let explicit = self.extractFirst(pattern: #"(?i)login\s+method:\s*(.+)"#, text: text) {
-            return self.cleanPlan(explicit)
+            return ClaudePlan.cliCompatibilityLoginMethod(self.cleanPlan(explicit))
         }
         // Capture any "Claude <...>" phrase (e.g., Max/Pro/Ultra/Team) to avoid future plan-name churn.
         // Strip any leading ANSI that may have survived (rare) before matching.
-        let planPattern = #"(?i)(claude\s+[a-z0-9][a-z0-9\s._-]{0,24})"#
+        // Use horizontal whitespace ([ \t]) rather than \s so the match stays on a single rendered line:
+        // \s spans newlines, which let "…use Claude" bridge into the /usage panel's "d → today" hint and
+        // produced a bogus "Dtoday" plan label after ANSI stripping glued the lines together.
+        let planPattern = #"(?i)(claude[ \t]+[a-z0-9][a-z0-9 \t._-]{0,24})"#
         var candidates: [String] = []
         if let regex = try? NSRegularExpression(pattern: planPattern, options: []) {
             let nsrange = NSRange(text.startIndex..<text.endIndex, in: text)
@@ -623,7 +709,7 @@ public struct ClaudeStatusProbe: Sendable {
                       match.numberOfRanges >= 2,
                       let r = Range(match.range(at: 1), in: text) else { return }
                 let raw = String(text[r])
-                let val = Self.cleanPlan(raw)
+                let val = ClaudePlan.cliCompatibilityLoginMethod(Self.cleanPlan(raw)) ?? Self.cleanPlan(raw)
                 candidates.append(val)
             }
         }
@@ -679,6 +765,14 @@ public struct ClaudeStatusProbe: Sendable {
         }
     }
 
+    #if DEBUG
+    public static func _replaceDumpsForTesting(_ dumps: [String]) async {
+        await MainActor.run {
+            self.recentDumps = dumps
+        }
+    }
+    #endif
+
     private static func extractUsageErrorJSON(text: String) -> String? {
         let pattern = #"Failed\s*to\s*load\s*usage\s*data:\s*(\{.*\})"#
         guard let regex = try? NSRegularExpression(pattern: pattern, options: [.dotMatchesLineSeparators]) else {
@@ -726,15 +820,19 @@ public struct ClaudeStatusProbe: Sendable {
 
     // MARK: - Process helpers
 
-    private static func resolvedBinaryPath(binaryName: String) -> String {
-        let env = ProcessInfo.processInfo.environment
-        return BinaryLocator.resolveClaudeBinary(env: env, loginPATH: LoginShellPathCache.shared.current)
-            ?? TTYCommandRunner.which(binaryName)
-            ?? binaryName
+    private static func resolvedBinaryPath(
+        binaryName: String,
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        if binaryName.contains("/") {
+            return binaryName
+        }
+        return ClaudeCLIResolver.resolvedBinaryPath(environment: environment)
     }
 
-    private static func isBinaryAvailable(_ binaryPathOrName: String) -> Bool {
-        FileManager.default.isExecutableFile(atPath: binaryPathOrName)
+    private static func isBinaryAvailable(_ binaryPathOrName: String?) -> Bool {
+        guard let binaryPathOrName else { return false }
+        return FileManager.default.isExecutableFile(atPath: binaryPathOrName)
             || TTYCommandRunner.which(binaryPathOrName) != nil
     }
 
@@ -752,15 +850,48 @@ public struct ClaudeStatusProbe: Sendable {
         }
     }
 
+    static func preparedProbeWorkingDirectoryURL() -> URL {
+        let directory = self.probeWorkingDirectoryURL()
+        do {
+            try self.prepareProbeWorkingDirectory(at: directory)
+        } catch {
+            Self.log.warning(
+                "Claude probe local settings unavailable",
+                metadata: ["error": error.localizedDescription])
+        }
+        return directory
+    }
+
+    static func prepareProbeWorkingDirectory(at directory: URL, fileManager fm: FileManager = .default) throws {
+        try fm.createDirectory(at: directory, withIntermediateDirectories: true)
+        let claudeDirectory = directory.appendingPathComponent(".claude", isDirectory: true)
+        try fm.createDirectory(at: claudeDirectory, withIntermediateDirectories: true)
+
+        let settingsURL = claudeDirectory.appendingPathComponent("settings.local.json")
+        var settings = (try? self.readSettingsObject(from: settingsURL, fileManager: fm)) ?? [:]
+        settings["disableDeepLinkRegistration"] = "disable"
+        let data = try JSONSerialization.data(
+            withJSONObject: settings,
+            options: [.prettyPrinted, .sortedKeys])
+        try data.write(to: settingsURL, options: .atomic)
+    }
+
+    private static func readSettingsObject(from url: URL, fileManager fm: FileManager) throws -> [String: Any] {
+        guard fm.fileExists(atPath: url.path) else {
+            return [:]
+        }
+        let data = try Data(contentsOf: url)
+        guard !data.isEmpty else {
+            return [:]
+        }
+        let object = try JSONSerialization.jsonObject(with: data)
+        return object as? [String: Any] ?? [:]
+    }
+
     /// Run claude CLI inside a PTY so we can respond to interactive permission prompts.
     private static func capture(subcommand: String, binary: String, timeout: TimeInterval) async throws -> String {
         let stopOnSubstrings = subcommand == "/usage"
             ? [
-                "Current week (all models)",
-                "Current week (Opus)",
-                "Current week (Sonnet only)",
-                "Current week (Sonnet)",
-                "Current session",
                 "Failed to load usage data",
                 "failed to load usage data",
                 "Failedto loadusagedata",
@@ -769,25 +900,44 @@ public struct ClaudeStatusProbe: Sendable {
             : []
         let idleTimeout: TimeInterval? = subcommand == "/usage" ? nil : 3.0
         let sendEnterEvery: TimeInterval? = subcommand == "/usage" ? 0.8 : nil
+        let stopWhenNormalized: (@Sendable (String) -> Bool)? = subcommand == "/usage"
+            ? { @Sendable normalizedScan in
+                Self.usageCaptureHasSessionValue(normalizedScan)
+                    || Self.usageCaptureHasSubscriptionNotice(normalizedScan)
+            }
+            : nil
         do {
-            return try await ClaudeCLISession.shared.capture(
+            return try await ClaudeCLISession.current.capture(
                 subcommand: subcommand,
                 binary: binary,
                 timeout: timeout,
                 idleTimeout: idleTimeout,
                 stopOnSubstrings: stopOnSubstrings,
+                stopWhenNormalized: stopWhenNormalized,
                 settleAfterStop: subcommand == "/usage" ? 2.0 : 0.25,
                 sendEnterEvery: sendEnterEvery)
         } catch ClaudeCLISession.SessionError.processExited {
-            await ClaudeCLISession.shared.reset()
+            await ClaudeCLISession.current.reset()
             throw ClaudeStatusProbeError.timedOut
         } catch ClaudeCLISession.SessionError.timedOut {
+            await ClaudeCLISession.current.reset()
             throw ClaudeStatusProbeError.timedOut
         } catch ClaudeCLISession.SessionError.launchFailed(_) {
             throw ClaudeStatusProbeError.claudeNotInstalled
         } catch {
-            await ClaudeCLISession.shared.reset()
+            await ClaudeCLISession.current.reset()
             throw error
         }
     }
+
+    private static func usageCaptureHasSessionValue(_ normalizedText: String) -> Bool {
+        guard let labelRange = normalizedText.range(of: "currentsession") else { return false }
+        let tail = normalizedText[labelRange.upperBound...]
+        return tail.range(of: #"[0-9]{1,3}(?:\.[0-9]+)?%"#, options: .regularExpression) != nil
+    }
+
+    private static func usageCaptureHasSubscriptionNotice(_ normalizedText: String) -> Bool {
+        normalizedText.contains("currentlyusingyoursubscription")
+            && normalizedText.contains("claudecodeusage")
+    }
 }
diff --git a/Sources/CodexBarCore/Providers/Claude/ClaudeUsageDataSource.swift b/Sources/CodexBarCore/Providers/Claude/ClaudeUsageDataSource.swift
index b97dce042c..063de7ffa5 100644
--- a/Sources/CodexBarCore/Providers/Claude/ClaudeUsageDataSource.swift
+++ b/Sources/CodexBarCore/Providers/Claude/ClaudeUsageDataSource.swift
@@ -2,6 +2,7 @@ import Foundation
 
 public enum ClaudeUsageDataSource: String, CaseIterable, Identifiable, Sendable {
     case auto
+    case api
     case oauth
     case web
     case cli
@@ -13,6 +14,7 @@ public enum ClaudeUsageDataSource: String, CaseIterable, Identifiable, Sendable
     public var displayName: String {
         switch self {
         case .auto: "Auto"
+        case .api: "API (Admin key)"
         case .oauth: "OAuth API"
         case .web: "Web API (cookies)"
         case .cli: "CLI (PTY)"
@@ -23,6 +25,8 @@ public enum ClaudeUsageDataSource: String, CaseIterable, Identifiable, Sendable
         switch self {
         case .auto:
             "auto"
+        case .api:
+            "api"
         case .oauth:
             "oauth"
         case .web:
diff --git a/Sources/CodexBarCore/Providers/Claude/ClaudeUsageFetcher.swift b/Sources/CodexBarCore/Providers/Claude/ClaudeUsageFetcher.swift
index 989db8e060..b01b3c1a48 100644
--- a/Sources/CodexBarCore/Providers/Claude/ClaudeUsageFetcher.swift
+++ b/Sources/CodexBarCore/Providers/Claude/ClaudeUsageFetcher.swift
@@ -7,9 +7,16 @@ public protocol ClaudeUsageFetching: Sendable {
 }
 
 public struct ClaudeUsageSnapshot: Sendable {
+    public enum PrimaryWindowKind: Equatable, Sendable {
+        case usage
+        case spendLimit
+    }
+
     public let primary: RateWindow
+    public let primaryWindowKind: PrimaryWindowKind
     public let secondary: RateWindow?
     public let opus: RateWindow?
+    public let extraRateWindows: [NamedRateWindow]
     public let providerCost: ProviderCostSnapshot?
     public let updatedAt: Date
     public let accountEmail: String?
@@ -19,8 +26,10 @@ public struct ClaudeUsageSnapshot: Sendable {
 
     public init(
         primary: RateWindow,
+        primaryWindowKind: PrimaryWindowKind = .usage,
         secondary: RateWindow?,
         opus: RateWindow?,
+        extraRateWindows: [NamedRateWindow] = [],
         providerCost: ProviderCostSnapshot? = nil,
         updatedAt: Date,
         accountEmail: String?,
@@ -29,8 +38,10 @@ public struct ClaudeUsageSnapshot: Sendable {
         rawText: String?)
     {
         self.primary = primary
+        self.primaryWindowKind = primaryWindowKind
         self.secondary = secondary
         self.opus = opus
+        self.extraRateWindows = extraRateWindows
         self.providerCost = providerCost
         self.updatedAt = updatedAt
         self.accountEmail = accountEmail
@@ -58,21 +69,76 @@ public enum ClaudeUsageError: LocalizedError, Sendable {
 }
 
 public struct ClaudeUsageFetcher: ClaudeUsageFetching, Sendable {
-    private let environment: [String: String]
-    private let dataSource: ClaudeUsageDataSource
-    private let oauthKeychainPromptCooldownEnabled: Bool
-    private let allowBackgroundDelegatedRefresh: Bool
-    private let allowStartupBootstrapPrompt: Bool
-    private let useWebExtras: Bool
-    private let manualCookieHeader: String?
-    private let keepCLISessionsAlive: Bool
-    private let browserDetection: BrowserDetection
+    private static let sessionWindowMinutes = 5 * 60
+    private static let weeklyWindowMinutes = 7 * 24 * 60
+    private static let cliAutoProbeTimeout: TimeInterval = 12
+    private static let cliProbeTimeout: TimeInterval = 24
+    private static let cliRetryProbeTimeout: TimeInterval = 60
+    private struct Configuration {
+        let environment: [String: String]
+        let runtime: ProviderRuntime
+        let dataSource: ClaudeUsageDataSource
+        let oauthKeychainPromptCooldownEnabled: Bool
+        let allowBackgroundDelegatedRefresh: Bool
+        let allowStartupBootstrapPrompt: Bool
+        let useWebExtras: Bool
+        let manualCookieHeader: String?
+        let webOrganizationID: String?
+        let keepCLISessionsAlive: Bool
+        let browserDetection: BrowserDetection
+    }
+
+    private let configuration: Configuration
     private static let log = CodexBarLog.logger(LogCategories.claudeUsage)
     private static var isClaudeOAuthFlowDebugEnabled: Bool {
         ProcessInfo.processInfo.environment["CODEXBAR_DEBUG_CLAUDE_OAUTH_FLOW"] == "1"
     }
 
-    private struct ClaudeOAuthKeychainPromptPolicy: Sendable {
+    private var environment: [String: String] {
+        self.configuration.environment
+    }
+
+    private var runtime: ProviderRuntime {
+        self.configuration.runtime
+    }
+
+    private var dataSource: ClaudeUsageDataSource {
+        self.configuration.dataSource
+    }
+
+    private var oauthKeychainPromptCooldownEnabled: Bool {
+        self.configuration.oauthKeychainPromptCooldownEnabled
+    }
+
+    private var allowBackgroundDelegatedRefresh: Bool {
+        self.configuration.allowBackgroundDelegatedRefresh
+    }
+
+    private var allowStartupBootstrapPrompt: Bool {
+        self.configuration.allowStartupBootstrapPrompt
+    }
+
+    private var useWebExtras: Bool {
+        self.configuration.useWebExtras
+    }
+
+    private var manualCookieHeader: String? {
+        self.configuration.manualCookieHeader
+    }
+
+    private var webOrganizationID: String? {
+        self.configuration.webOrganizationID
+    }
+
+    private var keepCLISessionsAlive: Bool {
+        self.configuration.keepCLISessionsAlive
+    }
+
+    private var browserDetection: BrowserDetection {
+        self.configuration.browserDetection
+    }
+
+    private struct ClaudeOAuthKeychainPromptPolicy {
         let mode: ClaudeOAuthKeychainPromptMode
         let isApplicable: Bool
         let interaction: ProviderInteraction
@@ -99,15 +165,15 @@ public struct ClaudeUsageFetcher: ClaudeUsageFetching, Sendable {
         }
     }
 
-    private static func currentClaudeOAuthKeychainPromptPolicy() -> ClaudeOAuthKeychainPromptPolicy {
-        let isApplicable = ClaudeOAuthKeychainPromptPreference.isApplicable()
+    private static func currentClaudeOAuthInteractivePromptPolicy() -> ClaudeOAuthKeychainPromptPolicy {
         let policy = ClaudeOAuthKeychainPromptPolicy(
-            mode: ClaudeOAuthKeychainPromptPreference.current(),
-            isApplicable: isApplicable,
+            mode: ClaudeOAuthKeychainPromptPreference.securityFrameworkFallbackMode(),
+            isApplicable: true,
             interaction: ProviderInteractionContext.current)
 
-        // User actions should be able to immediately retry a repair after a background cooldown was recorded.
-        if policy.isApplicable, policy.interaction == .userInitiated {
+        // User actions should be able to immediately retry a Security.framework fallback repair after a background
+        // cooldown was recorded, even when /usr/bin/security is the primary reader.
+        if policy.interaction == .userInitiated {
             if ClaudeOAuthKeychainAccessGate.clearDenied() {
                 Self.log.info("Claude OAuth keychain cooldown cleared by user action")
             }
@@ -115,6 +181,13 @@ public struct ClaudeUsageFetcher: ClaudeUsageFetching, Sendable {
         return policy
     }
 
+    private static func currentClaudeOAuthDelegatedRefreshPolicy() -> ClaudeOAuthKeychainPromptPolicy {
+        ClaudeOAuthKeychainPromptPolicy(
+            mode: ClaudeOAuthKeychainPromptPreference.current(),
+            isApplicable: ClaudeOAuthKeychainPromptPreference.isApplicable(),
+            interaction: ProviderInteractionContext.current)
+    }
+
     private static func assertDelegatedRefreshAllowedInCurrentInteraction(
         policy: ClaudeOAuthKeychainPromptPolicy,
         allowBackgroundDelegatedRefresh: Bool) throws
@@ -141,7 +214,8 @@ public struct ClaudeUsageFetcher: ClaudeUsageFetching, Sendable {
     @TaskLocal static var fetchOAuthUsageOverride: (@Sendable (String) async throws -> OAuthUsageResponse)?
     @TaskLocal static var delegatedRefreshAttemptOverride: (@Sendable (
         Date,
-        TimeInterval) async -> ClaudeOAuthDelegatedRefreshCoordinator.Outcome)?
+        TimeInterval,
+        [String: String]) async -> ClaudeOAuthDelegatedRefreshCoordinator.Outcome)?
     @TaskLocal static var hasCachedCredentialsOverride: Bool?
     #endif
 
@@ -153,25 +227,420 @@ public struct ClaudeUsageFetcher: ClaudeUsageFetching, Sendable {
     public init(
         browserDetection: BrowserDetection,
         environment: [String: String] = ProcessInfo.processInfo.environment,
+        runtime: ProviderRuntime = .app,
         dataSource: ClaudeUsageDataSource = .oauth,
         oauthKeychainPromptCooldownEnabled: Bool = false,
         allowBackgroundDelegatedRefresh: Bool = false,
         allowStartupBootstrapPrompt: Bool = false,
         useWebExtras: Bool = false,
         manualCookieHeader: String? = nil,
+        webOrganizationID: String? = nil,
         keepCLISessionsAlive: Bool = false)
     {
-        self.browserDetection = browserDetection
-        self.environment = environment
-        self.dataSource = dataSource
-        self.oauthKeychainPromptCooldownEnabled = oauthKeychainPromptCooldownEnabled
-        self.allowBackgroundDelegatedRefresh = allowBackgroundDelegatedRefresh
-        self.allowStartupBootstrapPrompt = allowStartupBootstrapPrompt
-        self.useWebExtras = useWebExtras
-        self.manualCookieHeader = manualCookieHeader
-        self.keepCLISessionsAlive = keepCLISessionsAlive
+        self.configuration = Configuration(
+            environment: environment,
+            runtime: runtime,
+            dataSource: dataSource,
+            oauthKeychainPromptCooldownEnabled: oauthKeychainPromptCooldownEnabled,
+            allowBackgroundDelegatedRefresh: allowBackgroundDelegatedRefresh,
+            allowStartupBootstrapPrompt: allowStartupBootstrapPrompt,
+            useWebExtras: useWebExtras,
+            manualCookieHeader: manualCookieHeader,
+            webOrganizationID: webOrganizationID,
+            keepCLISessionsAlive: keepCLISessionsAlive,
+            browserDetection: browserDetection)
+    }
+
+    private struct OAuthExecutor {
+        let fetcher: ClaudeUsageFetcher
+
+        func load(allowDelegatedRetry: Bool) async throws -> ClaudeUsageSnapshot {
+            do {
+                let promptPolicy = ClaudeUsageFetcher.currentClaudeOAuthInteractivePromptPolicy()
+
+                #if DEBUG
+                let hasCache = if let hasCachedCredentialsOverride = ClaudeUsageFetcher.hasCachedCredentialsOverride {
+                    hasCachedCredentialsOverride
+                } else if ClaudeUsageFetcher.loadOAuthCredentialsOverride != nil {
+                    false
+                } else {
+                    ClaudeOAuthCredentialsStore.hasCachedCredentials(environment: self.fetcher.environment)
+                }
+                #else
+                let hasCache = ClaudeOAuthCredentialsStore.hasCachedCredentials(environment: self.fetcher.environment)
+                #endif
+
+                let startupBootstrapOverride = self.shouldAllowStartupBootstrapPrompt(
+                    policy: promptPolicy,
+                    hasCache: hasCache)
+                let allowKeychainPrompt = (promptPolicy.canPromptNow || startupBootstrapOverride) && !hasCache
+                ClaudeUsageFetcher.logOAuthBootstrapPromptDecision(
+                    allowKeychainPrompt: allowKeychainPrompt,
+                    policy: promptPolicy,
+                    hasCache: hasCache,
+                    startupBootstrapOverride: startupBootstrapOverride)
+
+                let credentials = try await ClaudeOAuthCredentialsStore.$allowBackgroundPromptBootstrap
+                    .withValue(startupBootstrapOverride) {
+                        try await ClaudeUsageFetcher.loadOAuthCredentials(
+                            environment: self.fetcher.environment,
+                            allowKeychainPrompt: allowKeychainPrompt,
+                            respectKeychainPromptCooldown: promptPolicy.shouldRespectKeychainPromptCooldown)
+                    }
+
+                try self.validateRequiredOAuthScope(credentials)
+                let usage = try await ClaudeUsageFetcher.fetchOAuthUsage(accessToken: credentials.accessToken)
+                return try ClaudeUsageFetcher.mapOAuthUsage(usage, credentials: credentials)
+            } catch let error as CancellationError {
+                throw error
+            } catch let error as ClaudeUsageError {
+                throw error
+            } catch let error as ClaudeOAuthCredentialsError {
+                if case .refreshDelegatedToClaudeCLI = error {
+                    return try await self.loadAfterDelegatedRefresh(allowDelegatedRetry: allowDelegatedRetry)
+                }
+                throw ClaudeUsageError.oauthFailed(error.localizedDescription)
+            } catch let error as ClaudeOAuthFetchError {
+                if case .rateLimited = error {
+                    throw ClaudeUsageError.oauthFailed(error.localizedDescription)
+                }
+                ClaudeOAuthCredentialsStore.invalidateCache()
+                if case let .serverError(statusCode, body) = error,
+                   statusCode == 403,
+                   body?.contains("user:profile") ?? false
+                {
+                    throw ClaudeUsageError.oauthFailed(
+                        "Claude OAuth token does not meet scope requirement 'user:profile'. "
+                            + "Run `claude setup-token` to re-generate credentials, or switch Claude Source to "
+                            + "Web/CLI.")
+                }
+                throw ClaudeUsageError.oauthFailed(error.localizedDescription)
+            } catch {
+                throw ClaudeUsageError.oauthFailed(error.localizedDescription)
+            }
+        }
+
+        private func shouldAllowStartupBootstrapPrompt(
+            policy: ClaudeOAuthKeychainPromptPolicy,
+            hasCache: Bool) -> Bool
+        {
+            guard self.fetcher.allowStartupBootstrapPrompt else { return false }
+            guard !hasCache else { return false }
+            guard ClaudeOAuthKeychainPromptPreference.securityFrameworkFallbackMode() == .onlyOnUserAction else {
+                return false
+            }
+            guard policy.interaction == .background else { return false }
+            return ProviderRefreshContext.current == .startup
+        }
+
+        private func loadAfterDelegatedRefresh(allowDelegatedRetry: Bool) async throws -> ClaudeUsageSnapshot {
+            guard allowDelegatedRetry else {
+                throw ClaudeUsageError.oauthFailed(
+                    "Claude OAuth token expired and delegated Claude CLI refresh did not recover. "
+                        + "Run `claude login`, then retry.")
+            }
+
+            try Task.checkCancellation()
+
+            let delegatedPromptPolicy = ClaudeUsageFetcher.currentClaudeOAuthDelegatedRefreshPolicy()
+            try ClaudeUsageFetcher.assertDelegatedRefreshAllowedInCurrentInteraction(
+                policy: delegatedPromptPolicy,
+                allowBackgroundDelegatedRefresh: self.fetcher.allowBackgroundDelegatedRefresh)
+
+            let delegatedOutcome = await ClaudeUsageFetcher.attemptDelegatedRefresh(
+                environment: self.fetcher.environment)
+            ClaudeUsageFetcher.log.info(
+                "Claude OAuth delegated refresh attempted",
+                metadata: [
+                    "outcome": ClaudeUsageFetcher.delegatedRefreshOutcomeLabel(delegatedOutcome),
+                ])
+
+            do {
+                if self.fetcher.oauthKeychainPromptCooldownEnabled {
+                    switch delegatedOutcome {
+                    case .skippedByCooldown, .cliUnavailable:
+                        throw ClaudeUsageError.oauthFailed(
+                            "Claude OAuth token expired; delegated refresh is unavailable (outcome="
+                                + "\(ClaudeUsageFetcher.delegatedRefreshOutcomeLabel(delegatedOutcome))).")
+                    case .attemptedSucceeded, .attemptedFailed:
+                        break
+                    }
+                }
+
+                try Task.checkCancellation()
+
+                _ = ClaudeOAuthCredentialsStore.invalidateCacheIfCredentialsFileChanged()
+
+                let didSyncSilently = delegatedOutcome == .attemptedSucceeded
+                    && ClaudeOAuthCredentialsStore.syncFromClaudeKeychainWithoutPrompt(now: Date())
+
+                let promptPolicy = ClaudeUsageFetcher.currentClaudeOAuthInteractivePromptPolicy()
+                ClaudeUsageFetcher.logDeferredBackgroundDelegatedRecoveryIfNeeded(
+                    delegatedOutcome: delegatedOutcome,
+                    didSyncSilently: didSyncSilently,
+                    policy: promptPolicy)
+                let retryAllowKeychainPrompt = promptPolicy.canPromptNow && !didSyncSilently
+                if retryAllowKeychainPrompt {
+                    ClaudeUsageFetcher.log.info(
+                        "Claude OAuth keychain prompt allowed (post-delegation retry)",
+                        metadata: [
+                            "interaction": promptPolicy.interactionLabel,
+                            "promptMode": promptPolicy.mode.rawValue,
+                            "promptPolicyApplicable": "\(promptPolicy.isApplicable)",
+                            "delegatedOutcome": ClaudeUsageFetcher.delegatedRefreshOutcomeLabel(delegatedOutcome),
+                            "didSyncSilently": "\(didSyncSilently)",
+                        ])
+                }
+                if ClaudeUsageFetcher.isClaudeOAuthFlowDebugEnabled {
+                    ClaudeUsageFetcher.log.debug(
+                        "Claude OAuth credential load (post-delegation retry start)",
+                        metadata: [
+                            "cooldownEnabled": "\(self.fetcher.oauthKeychainPromptCooldownEnabled)",
+                            "didSyncSilently": "\(didSyncSilently)",
+                            "allowKeychainPrompt": "\(retryAllowKeychainPrompt)",
+                            "delegatedOutcome": ClaudeUsageFetcher.delegatedRefreshOutcomeLabel(delegatedOutcome),
+                            "interaction": promptPolicy.interactionLabel,
+                            "promptMode": promptPolicy.mode.rawValue,
+                            "promptPolicyApplicable": "\(promptPolicy.isApplicable)",
+                        ])
+                }
+
+                let refreshedCredentials = try await ClaudeUsageFetcher.loadOAuthCredentials(
+                    environment: self.fetcher.environment,
+                    allowKeychainPrompt: retryAllowKeychainPrompt,
+                    respectKeychainPromptCooldown: promptPolicy.shouldRespectKeychainPromptCooldown)
+                if ClaudeUsageFetcher.isClaudeOAuthFlowDebugEnabled {
+                    ClaudeUsageFetcher.log.debug(
+                        "Claude OAuth credential load (post-delegation retry)",
+                        metadata: [
+                            "cooldownEnabled": "\(self.fetcher.oauthKeychainPromptCooldownEnabled)",
+                            "didSyncSilently": "\(didSyncSilently)",
+                            "allowKeychainPrompt": "\(retryAllowKeychainPrompt)",
+                            "delegatedOutcome": ClaudeUsageFetcher.delegatedRefreshOutcomeLabel(delegatedOutcome),
+                            "interaction": promptPolicy.interactionLabel,
+                            "promptMode": promptPolicy.mode.rawValue,
+                            "promptPolicyApplicable": "\(promptPolicy.isApplicable)",
+                        ])
+                }
+
+                try self.validateRequiredOAuthScope(refreshedCredentials)
+                let usage = try await ClaudeUsageFetcher.fetchOAuthUsage(
+                    accessToken: refreshedCredentials.accessToken)
+                return try ClaudeUsageFetcher.mapOAuthUsage(usage, credentials: refreshedCredentials)
+            } catch {
+                ClaudeUsageFetcher.log.debug(
+                    "Claude OAuth post-delegation retry failed",
+                    metadata: ClaudeUsageFetcher.delegatedRetryFailureMetadata(
+                        error: error,
+                        oauthKeychainPromptCooldownEnabled: self.fetcher.oauthKeychainPromptCooldownEnabled,
+                        delegatedOutcome: delegatedOutcome))
+                throw ClaudeUsageError.oauthFailed(
+                    ClaudeUsageFetcher.delegatedRefreshFailureMessage(
+                        for: delegatedOutcome,
+                        retryError: error))
+            }
+        }
+
+        private func validateRequiredOAuthScope(_ credentials: ClaudeOAuthCredentials) throws {
+            guard credentials.scopes.contains("user:profile") else {
+                let scopes = credentials.scopes.joined(separator: ", ")
+                let detail = scopes.isEmpty
+                    ? "Claude OAuth token missing 'user:profile' scope."
+                    : "Claude OAuth token missing 'user:profile' scope (has: \(scopes))."
+                throw ClaudeUsageError.oauthFailed(
+                    detail + " Run `claude setup-token` to re-generate credentials, or switch Claude Source to "
+                        + "Web/CLI.")
+            }
+        }
+    }
+
+    private struct StepExecutor {
+        let fetcher: ClaudeUsageFetcher
+
+        func loadLatestUsage(model: String) async throws -> ClaudeUsageSnapshot {
+            switch self.fetcher.dataSource {
+            case .auto:
+                return try await self.executeAuto(model: model)
+            case .api:
+                throw ClaudeUsageError.parseFailed("Claude Admin API usage is handled by the provider descriptor.")
+            case .oauth:
+                var snapshot = try await self.fetcher.loadViaOAuth(allowDelegatedRetry: true)
+                snapshot = await self.fetcher.applyWebExtrasIfNeeded(to: snapshot)
+                return snapshot
+            case .web:
+                return try await self.fetcher.loadViaWebAPI()
+            case .cli:
+                return try await self.loadViaCLIWithRetry(model: model)
+            }
+        }
+
+        private func executeAuto(model: String) async throws -> ClaudeUsageSnapshot {
+            let plan = await self.makeAutoFetchPlan()
+            self.logAutoPlan(plan)
+
+            let executionSteps = plan.executionSteps
+            for (index, step) in executionSteps.enumerated() {
+                do {
+                    return try await self.execute(step: step, model: model)
+                } catch {
+                    if index < executionSteps.count - 1 {
+                        ClaudeUsageFetcher.log.debug(
+                            "Claude planner step failed; falling back to next step",
+                            metadata: [
+                                "step": step.dataSource.rawValue,
+                                "reason": step.inclusionReason.rawValue,
+                                "errorType": String(describing: type(of: error)),
+                            ])
+                        continue
+                    }
+                    throw error
+                }
+            }
+            throw ClaudeUsageError.parseFailed("Claude planner produced no executable steps.")
+        }
+
+        private func makeAutoFetchPlan() async -> ClaudeFetchPlan {
+            let hasWebSession =
+                if let header = self.fetcher.manualCookieHeader {
+                    ClaudeWebAPIFetcher.hasSessionKey(cookieHeader: header)
+                } else {
+                    ClaudeWebAPIFetcher.hasSessionKey(browserDetection: self.fetcher.browserDetection)
+                }
+            let hasCLI = ClaudeCLIResolver.isAvailable(environment: self.fetcher.environment)
+            return ClaudeSourcePlanner.resolve(input: ClaudeSourcePlanningInput(
+                runtime: self.fetcher.runtime,
+                selectedDataSource: .auto,
+                webExtrasEnabled: self.fetcher.useWebExtras,
+                hasWebSession: hasWebSession,
+                hasCLI: hasCLI,
+                hasOAuthCredentials: ClaudeOAuthPlanningAvailability.isAvailable(
+                    runtime: self.fetcher.runtime,
+                    sourceMode: .auto,
+                    environment: self.fetcher.environment)))
+        }
+
+        private func logAutoPlan(_ plan: ClaudeFetchPlan) {
+            var metadata: [String: String] = [
+                "plannerOrder": plan.orderLabel,
+                "selected": plan.preferredStep?.dataSource.rawValue ?? "none",
+                "noSourceAvailable": "\(plan.isNoSourceAvailable)",
+                "webExtrasEnabled": "\(self.fetcher.useWebExtras)",
+                "oauthReadStrategy": ClaudeOAuthKeychainReadStrategyPreference.current().rawValue,
+            ]
+            for (index, step) in plan.orderedSteps.enumerated() {
+                metadata["step\(index)"] =
+                    "\(step.dataSource.rawValue):\(step.inclusionReason.rawValue):\(step.isPlausiblyAvailable)"
+            }
+            ClaudeUsageFetcher.log.debug("Claude auto source planner", metadata: metadata)
+        }
+
+        private func execute(step: ClaudeFetchPlanStep, model: String) async throws -> ClaudeUsageSnapshot {
+            switch step.dataSource {
+            case .api:
+                throw ClaudeUsageError.parseFailed("Planner emitted invalid api execution step.")
+            case .oauth:
+                var snapshot = try await self.fetcher.loadViaOAuth(allowDelegatedRetry: true)
+                snapshot = await self.fetcher.applyWebExtrasIfNeeded(to: snapshot)
+                return snapshot
+            case .web:
+                return try await self.fetcher.loadViaWebAPI()
+            case .cli:
+                return try await self.loadViaAutoCLI(model: model)
+            case .auto:
+                throw ClaudeUsageError.parseFailed("Planner emitted invalid auto execution step.")
+            }
+        }
+
+        private func loadViaAutoCLI(model: String) async throws -> ClaudeUsageSnapshot {
+            do {
+                return try await self.loadViaCLI(model: model, timeout: ClaudeUsageFetcher.cliAutoProbeTimeout)
+            } catch {
+                if error is CancellationError { throw error }
+                guard Self.shouldRetryCLIProbe(after: error) else { throw error }
+                return try await self.loadViaCLI(model: model, timeout: ClaudeUsageFetcher.cliRetryProbeTimeout)
+            }
+        }
+
+        private func loadViaCLIWithRetry(model: String) async throws -> ClaudeUsageSnapshot {
+            do {
+                return try await self.loadViaCLI(model: model, timeout: ClaudeUsageFetcher.cliProbeTimeout)
+            } catch {
+                if error is CancellationError { throw error }
+                guard Self.shouldRetryCLIProbe(after: error) else { throw error }
+                return try await self.loadViaCLI(model: model, timeout: ClaudeUsageFetcher.cliRetryProbeTimeout)
+            }
+        }
+
+        private func loadViaCLI(model: String, timeout: TimeInterval) async throws -> ClaudeUsageSnapshot {
+            if ClaudeCLIRateLimitGate.blockedUntil() != nil {
+                throw ClaudeUsageError.parseFailed(ClaudeCLIRateLimitGate.message)
+            }
+
+            var snapshot: ClaudeUsageSnapshot
+            do {
+                snapshot = try await self.fetcher.loadViaPTY(model: model, timeout: timeout)
+            } catch {
+                if error is CancellationError { throw error }
+                if ClaudeUsageFetcher.isCLIRateLimitError(error) {
+                    ClaudeCLIRateLimitGate.recordRateLimit()
+                    throw error
+                }
+                guard Self.shouldTryDirectCLIUsage(after: error) else { throw error }
+                let ptyError = error
+                do {
+                    snapshot = try await self.fetcher.loadViaDirectCLI(
+                        timeout: Self.directCLIUsageTimeout(for: timeout))
+                } catch let directError {
+                    if directError is CancellationError { throw directError }
+                    if ClaudeUsageFetcher.isCLIRateLimitError(directError) {
+                        ClaudeCLIRateLimitGate.recordRateLimit()
+                        throw directError
+                    }
+                    guard Self.directCLIErrorShouldReplacePTYError(directError) else { throw ptyError }
+                    throw directError
+                }
+            }
+            ClaudeCLIRateLimitGate.recordSuccess()
+            snapshot = await self.fetcher.applyWebExtrasIfNeeded(to: snapshot)
+            return snapshot
+        }
+
+        private static func directCLIUsageTimeout(for ptyTimeout: TimeInterval) -> TimeInterval {
+            min(max(ptyTimeout / 3, 6), 8)
+        }
+
+        private static func directCLIErrorShouldReplacePTYError(_ error: Error) -> Bool {
+            if case let ClaudeStatusProbeError.parseFailed(message) = error {
+                return message.lowercased().contains("subscription")
+            }
+            if case let ClaudeUsageError.parseFailed(message) = error {
+                return message.lowercased().contains("subscription")
+            }
+            return false
+        }
+
+        private static func shouldTryDirectCLIUsage(after error: Error) -> Bool {
+            if case ClaudeStatusProbeError.timedOut = error { return true }
+            if case let ClaudeStatusProbeError.parseFailed(message) = error {
+                let lower = message.lowercased()
+                return lower.contains("still loading usage") || lower.contains("could not load usage data")
+            }
+            let message = error.localizedDescription.lowercased()
+            return message.contains("timed out") || message.contains("timeout")
+        }
+
+        private static func shouldRetryCLIProbe(after error: Error) -> Bool {
+            if case ClaudeStatusProbeError.timedOut = error { return true }
+            if case let ClaudeStatusProbeError.parseFailed(message) = error {
+                return message.lowercased().contains("still loading usage")
+            }
+            let message = error.localizedDescription.lowercased()
+            return message.contains("timed out") || message.contains("timeout")
+        }
     }
+}
 
+extension ClaudeUsageFetcher {
     // MARK: - Parsing helpers
 
     public static func parse(json: Data) -> ClaudeUsageSnapshot? {
@@ -199,21 +668,26 @@ public struct ClaudeUsageFetcher: ClaudeUsageFetching, Sendable {
             return nil
         }
 
-        func makeWindow(_ dict: [String: Any]?) -> RateWindow? {
+        func makeWindow(_ dict: [String: Any]?, windowMinutes: Int) -> RateWindow? {
             guard let dict else { return nil }
             let pct = (dict["pct_used"] as? NSNumber)?.doubleValue ?? 0
             let resetText = dict["resets"] as? String
             return RateWindow(
                 usedPercent: pct,
-                windowMinutes: nil,
+                windowMinutes: windowMinutes,
                 resetsAt: Self.parseReset(text: resetText),
                 resetDescription: resetText)
         }
 
-        guard let session = makeWindow(firstWindowDict(["session_5h"])) else {
+        guard let session = makeWindow(
+            firstWindowDict(["session_5h"]),
+            windowMinutes: Self.sessionWindowMinutes)
+        else {
             throw ClaudeUsageError.parseFailed("missing session data")
         }
-        let weekAll = makeWindow(firstWindowDict(["week_all_models", "week_all"]))
+        let weekAll = makeWindow(
+            firstWindowDict(["week_all_models", "week_all"]),
+            windowMinutes: Self.weeklyWindowMinutes)
 
         let rawEmail = (obj["account_email"] as? String)?.trimmingCharacters(
             in: .whitespacesAndNewlines)
@@ -234,7 +708,7 @@ public struct ClaudeUsageFetcher: ClaudeUsageFetching, Sendable {
             let resets = opus["resets"] as? String
             return RateWindow(
                 usedPercent: pct,
-                windowMinutes: nil,
+                windowMinutes: Self.weeklyWindowMinutes,
                 resetsAt: Self.parseReset(text: resets),
                 resetDescription: resets)
         }()
@@ -278,7 +752,7 @@ public struct ClaudeUsageFetcher: ClaudeUsageFetching, Sendable {
 
     public func debugRawProbe(model: String = "sonnet") async -> String {
         do {
-            let snap = try await self.loadViaPTY(model: model, timeout: 10)
+            let snap = try await self.loadViaPTY(model: model, timeout: Self.cliProbeTimeout)
             let opus = snap.opus?.remainingPercent ?? -1
             let email = snap.accountEmail ?? "nil"
             let org = snap.accountOrganization ?? "nil"
@@ -294,19 +768,17 @@ public struct ClaudeUsageFetcher: ClaudeUsageFetching, Sendable {
         }
     }
 
-    // MARK: - OAuth API path
+    public func loadLatestUsage(model: String = "sonnet") async throws -> ClaudeUsageSnapshot {
+        try await StepExecutor(fetcher: self).loadLatestUsage(model: model)
+    }
 
-    private func shouldAllowStartupBootstrapPrompt(
-        policy: ClaudeOAuthKeychainPromptPolicy,
-        hasCache: Bool) -> Bool
-    {
-        guard policy.isApplicable else { return false }
-        guard self.allowStartupBootstrapPrompt else { return false }
-        guard !hasCache else { return false }
-        guard policy.mode == .onlyOnUserAction else { return false }
-        guard policy.interaction == .background else { return false }
-        return ProviderRefreshContext.current == .startup
+    public static func isCLIRateLimitError(_ error: Error) -> Bool {
+        ClaudeCLIRateLimitGate.isRateLimitError(error)
     }
+}
+
+extension ClaudeUsageFetcher {
+    // MARK: - OAuth API path
 
     private static func logOAuthBootstrapPromptDecision(
         allowKeychainPrompt: Bool,
@@ -345,188 +817,7 @@ public struct ClaudeUsageFetcher: ClaudeUsageFetching, Sendable {
     }
 
     private func loadViaOAuth(allowDelegatedRetry: Bool) async throws -> ClaudeUsageSnapshot {
-        do {
-            let promptPolicy = Self.currentClaudeOAuthKeychainPromptPolicy()
-
-            // Allow keychain prompt when no cached credentials exist (bootstrap case)
-            #if DEBUG
-            let hasCache = Self.hasCachedCredentialsOverride
-                ?? ClaudeOAuthCredentialsStore.hasCachedCredentials(environment: self.environment)
-            #else
-            let hasCache = ClaudeOAuthCredentialsStore.hasCachedCredentials(environment: self.environment)
-            #endif
-            let startupBootstrapOverride = self.shouldAllowStartupBootstrapPrompt(
-                policy: promptPolicy,
-                hasCache: hasCache)
-            // Note: `hasCachedCredentials` intentionally returns true for expired Claude-CLI-owned creds, because the
-            // repair path is delegated refresh via Claude CLI (followed by a silent re-sync) rather than immediately
-            // prompting on the initial load.
-            let allowKeychainPrompt = (promptPolicy.canPromptNow || startupBootstrapOverride) && !hasCache
-            Self.logOAuthBootstrapPromptDecision(
-                allowKeychainPrompt: allowKeychainPrompt,
-                policy: promptPolicy,
-                hasCache: hasCache,
-                startupBootstrapOverride: startupBootstrapOverride)
-            // Ownership-aware credential loading:
-            // - Claude CLI-owned credentials delegate refresh to Claude CLI.
-            // - CodexBar-owned credentials use direct token-endpoint refresh.
-            let creds = try await ClaudeOAuthCredentialsStore.$allowBackgroundPromptBootstrap
-                .withValue(startupBootstrapOverride) {
-                    try await Self.loadOAuthCredentials(
-                        environment: self.environment,
-                        allowKeychainPrompt: allowKeychainPrompt,
-                        respectKeychainPromptCooldown: promptPolicy.shouldRespectKeychainPromptCooldown)
-                }
-            // The usage endpoint requires user:profile scope.
-            if !creds.scopes.contains("user:profile") {
-                throw ClaudeUsageError.oauthFailed(
-                    "Claude OAuth token missing 'user:profile' scope (has: \(creds.scopes.joined(separator: ", "))). "
-                        + "Run `claude setup-token` to re-generate credentials, or switch Claude Source to Web/CLI.")
-            }
-            let usage = try await Self.fetchOAuthUsage(accessToken: creds.accessToken)
-            return try Self.mapOAuthUsage(usage, credentials: creds)
-        } catch let error as CancellationError {
-            throw error
-        } catch let error as ClaudeUsageError {
-            throw error
-        } catch let error as ClaudeOAuthCredentialsError {
-            if case .refreshDelegatedToClaudeCLI = error {
-                return try await self.loadViaOAuthAfterDelegatedRefresh(allowDelegatedRetry: allowDelegatedRetry)
-            }
-            throw ClaudeUsageError.oauthFailed(error.localizedDescription)
-        } catch let error as ClaudeOAuthFetchError {
-            ClaudeOAuthCredentialsStore.invalidateCache()
-            if case let .serverError(statusCode, body) = error,
-               statusCode == 403,
-               body?.contains("user:profile") ?? false
-            {
-                throw ClaudeUsageError.oauthFailed(
-                    "Claude OAuth token does not meet scope requirement 'user:profile'. "
-                        + "Run `claude setup-token` to re-generate credentials, or switch Claude Source to Web/CLI.")
-            }
-            throw ClaudeUsageError.oauthFailed(error.localizedDescription)
-        } catch {
-            throw ClaudeUsageError.oauthFailed(error.localizedDescription)
-        }
-    }
-
-    private func loadViaOAuthAfterDelegatedRefresh(allowDelegatedRetry: Bool) async throws -> ClaudeUsageSnapshot {
-        guard allowDelegatedRetry else {
-            throw ClaudeUsageError.oauthFailed(
-                "Claude OAuth token expired and delegated Claude CLI refresh did not recover. "
-                    + "Run `claude login`, then retry.")
-        }
-
-        try Task.checkCancellation()
-
-        let delegatedPromptPolicy = Self.currentClaudeOAuthKeychainPromptPolicy()
-        try Self.assertDelegatedRefreshAllowedInCurrentInteraction(
-            policy: delegatedPromptPolicy,
-            allowBackgroundDelegatedRefresh: self.allowBackgroundDelegatedRefresh)
-
-        let delegatedOutcome = await Self.attemptDelegatedRefresh()
-        Self.log.info(
-            "Claude OAuth delegated refresh attempted",
-            metadata: [
-                "outcome": Self.delegatedRefreshOutcomeLabel(delegatedOutcome),
-            ])
-
-        do {
-            // In Auto mode, avoid forcing interactive Keychain prompts or blocking the fallback chain when
-            // delegation cannot run.
-            if self.oauthKeychainPromptCooldownEnabled {
-                switch delegatedOutcome {
-                case .skippedByCooldown, .cliUnavailable:
-                    throw ClaudeUsageError.oauthFailed(
-                        "Claude OAuth token expired; delegated refresh is unavailable (outcome="
-                            + "\(Self.delegatedRefreshOutcomeLabel(delegatedOutcome))).")
-                case .attemptedSucceeded:
-                    break
-                case .attemptedFailed:
-                    // Delegation ran but didn't observe a keychain change. We'll attempt a non-interactive reload
-                    // below (allowKeychainPrompt=false) and then allow the Auto chain to fall back.
-                    break
-                }
-            }
-
-            try Task.checkCancellation()
-
-            // After delegated refresh, reload credentials and retry OAuth once.
-            // In OAuth mode we allow an interactive Keychain prompt here; in Auto mode we keep it silent to avoid
-            // bypassing the prompt cooldown and to let the fallback chain proceed.
-            _ = ClaudeOAuthCredentialsStore.invalidateCacheIfCredentialsFileChanged()
-
-            let didSyncSilently = delegatedOutcome == .attemptedSucceeded
-                && ClaudeOAuthCredentialsStore.syncFromClaudeKeychainWithoutPrompt(now: Date())
-
-            let promptPolicy = Self.currentClaudeOAuthKeychainPromptPolicy()
-            Self.logDeferredBackgroundDelegatedRecoveryIfNeeded(
-                delegatedOutcome: delegatedOutcome,
-                didSyncSilently: didSyncSilently,
-                policy: promptPolicy)
-            let retryAllowKeychainPrompt = promptPolicy.canPromptNow && !didSyncSilently
-            if retryAllowKeychainPrompt {
-                Self.log.info(
-                    "Claude OAuth keychain prompt allowed (post-delegation retry)",
-                    metadata: [
-                        "interaction": promptPolicy.interactionLabel,
-                        "promptMode": promptPolicy.mode.rawValue,
-                        "promptPolicyApplicable": "\(promptPolicy.isApplicable)",
-                        "delegatedOutcome": Self.delegatedRefreshOutcomeLabel(delegatedOutcome),
-                        "didSyncSilently": "\(didSyncSilently)",
-                    ])
-            }
-            if Self.isClaudeOAuthFlowDebugEnabled {
-                Self.log.debug(
-                    "Claude OAuth credential load (post-delegation retry start)",
-                    metadata: [
-                        "cooldownEnabled": "\(self.oauthKeychainPromptCooldownEnabled)",
-                        "didSyncSilently": "\(didSyncSilently)",
-                        "allowKeychainPrompt": "\(retryAllowKeychainPrompt)",
-                        "delegatedOutcome": Self.delegatedRefreshOutcomeLabel(delegatedOutcome),
-                        "interaction": promptPolicy.interactionLabel,
-                        "promptMode": promptPolicy.mode.rawValue,
-                        "promptPolicyApplicable": "\(promptPolicy.isApplicable)",
-                    ])
-            }
-            let refreshedCreds = try await Self.loadOAuthCredentials(
-                environment: self.environment,
-                allowKeychainPrompt: retryAllowKeychainPrompt,
-                respectKeychainPromptCooldown: promptPolicy.shouldRespectKeychainPromptCooldown)
-            if Self.isClaudeOAuthFlowDebugEnabled {
-                Self.log.debug(
-                    "Claude OAuth credential load (post-delegation retry)",
-                    metadata: [
-                        "cooldownEnabled": "\(self.oauthKeychainPromptCooldownEnabled)",
-                        "didSyncSilently": "\(didSyncSilently)",
-                        "allowKeychainPrompt": "\(retryAllowKeychainPrompt)",
-                        "delegatedOutcome": Self.delegatedRefreshOutcomeLabel(delegatedOutcome),
-                        "interaction": promptPolicy.interactionLabel,
-                        "promptMode": promptPolicy.mode.rawValue,
-                        "promptPolicyApplicable": "\(promptPolicy.isApplicable)",
-                    ])
-            }
-
-            if !refreshedCreds.scopes.contains("user:profile") {
-                let scopes = refreshedCreds.scopes.joined(separator: ", ")
-                throw ClaudeUsageError.oauthFailed(
-                    "Claude OAuth token missing 'user:profile' scope (has: \(scopes)). "
-                        + "Run `claude setup-token` to re-generate credentials, "
-                        + "or switch Claude Source to Web/CLI.")
-            }
-
-            let usage = try await Self.fetchOAuthUsage(accessToken: refreshedCreds.accessToken)
-            return try Self.mapOAuthUsage(usage, credentials: refreshedCreds)
-        } catch {
-            Self.log.debug(
-                "Claude OAuth post-delegation retry failed",
-                metadata: Self.delegatedRetryFailureMetadata(
-                    error: error,
-                    oauthKeychainPromptCooldownEnabled: self.oauthKeychainPromptCooldownEnabled,
-                    delegatedOutcome: delegatedOutcome))
-            throw ClaudeUsageError.oauthFailed(
-                Self.delegatedRefreshFailureMessage(for: delegatedOutcome, retryError: error))
-        }
+        try await OAuthExecutor(fetcher: self).load(allowDelegatedRetry: allowDelegatedRetry)
     }
 
     private static func loadOAuthCredentials(
@@ -556,18 +847,23 @@ public struct ClaudeUsageFetcher: ClaudeUsageFetching, Sendable {
 
     private static func attemptDelegatedRefresh(
         now: Date = Date(),
-        timeout: TimeInterval = 15) async -> ClaudeOAuthDelegatedRefreshCoordinator.Outcome
+        timeout: TimeInterval = 15,
+        environment: [String: String] = ProcessInfo.processInfo.environment)
+        async -> ClaudeOAuthDelegatedRefreshCoordinator.Outcome
     {
         #if DEBUG
         if let override = delegatedRefreshAttemptOverride {
-            return await override(now, timeout)
+            return await override(now, timeout, environment)
         }
         #endif
-        return await ClaudeOAuthDelegatedRefreshCoordinator.attempt(now: now, timeout: timeout)
+        return await ClaudeOAuthDelegatedRefreshCoordinator.attempt(
+            now: now,
+            timeout: timeout,
+            environment: environment)
     }
 
-    private static func delegatedRefreshOutcomeLabel(_ outcome: ClaudeOAuthDelegatedRefreshCoordinator
-        .Outcome) -> String
+    private static func delegatedRefreshOutcomeLabel(
+        _ outcome: ClaudeOAuthDelegatedRefreshCoordinator.Outcome) -> String
     {
         switch outcome {
         case .skippedByCooldown:
@@ -585,7 +881,12 @@ public struct ClaudeUsageFetcher: ClaudeUsageFetching, Sendable {
         for outcome: ClaudeOAuthDelegatedRefreshCoordinator.Outcome,
         retryError: Error) -> String
     {
-        _ = retryError
+        if let oauthError = retryError as? ClaudeOAuthFetchError,
+           case .rateLimited = oauthError
+        {
+            return oauthError.localizedDescription
+        }
+
         switch outcome {
         case .skippedByCooldown:
             return "Claude OAuth token expired and delegated refresh is cooling down. "
@@ -619,6 +920,9 @@ public struct ClaudeUsageFetcher: ClaudeUsageFetching, Sendable {
             switch oauthError {
             case .unauthorized:
                 metadata["oauthError"] = "unauthorized"
+            case let .rateLimited(retryAfter):
+                metadata["oauthError"] = "rateLimited"
+                metadata["retryAfter"] = retryAfter.map { "\($0.timeIntervalSince1970)" } ?? "nil"
             case .invalidResponse:
                 metadata["oauthError"] = "invalidResponse"
             case let .serverError(statusCode, body):
@@ -651,7 +955,35 @@ public struct ClaudeUsageFetcher: ClaudeUsageFetching, Sendable {
                 resetDescription: resetDescription)
         }
 
-        guard let primary = makeWindow(usage.fiveHour, windowMinutes: 5 * 60) else {
+        let loginMethod = ClaudePlan.oauthLoginMethod(
+            subscriptionType: credentials.subscriptionType,
+            rateLimitTier: credentials.rateLimitTier)
+        let primary = makeWindow(usage.fiveHour, windowMinutes: 5 * 60)
+            ?? makeWindow(usage.sevenDay, windowMinutes: 7 * 24 * 60)
+            ?? makeWindow(usage.sevenDayOAuthApps, windowMinutes: 7 * 24 * 60)
+            ?? makeWindow(usage.sevenDaySonnet, windowMinutes: 7 * 24 * 60)
+            ?? makeWindow(usage.sevenDayOpus, windowMinutes: 7 * 24 * 60)
+        let treatAsSpendLimit = primary == nil && usage.extraUsage?.isEnabled == true
+        let providerCost = Self.oauthExtraUsageCost(
+            usage.extraUsage,
+            loginMethod: loginMethod,
+            treatAsSpendLimit: treatAsSpendLimit)
+
+        guard let primary else {
+            if let spendLimit = Self.oauthSpendLimitWindow(from: providerCost, extraUsage: usage.extraUsage) {
+                return ClaudeUsageSnapshot(
+                    primary: spendLimit,
+                    primaryWindowKind: .spendLimit,
+                    secondary: nil,
+                    opus: nil,
+                    extraRateWindows: Self.oauthExtraRateWindows(from: usage),
+                    providerCost: providerCost,
+                    updatedAt: Date(),
+                    accountEmail: nil,
+                    accountOrganization: nil,
+                    loginMethod: loginMethod,
+                    rawText: nil)
+            }
             throw ClaudeUsageError.parseFailed("missing session data")
         }
 
@@ -659,14 +991,13 @@ public struct ClaudeUsageFetcher: ClaudeUsageFetching, Sendable {
         let modelSpecific = makeWindow(
             usage.sevenDaySonnet ?? usage.sevenDayOpus,
             windowMinutes: 7 * 24 * 60)
-
-        let loginMethod = Self.inferPlan(rateLimitTier: credentials.rateLimitTier)
-        let providerCost = Self.oauthExtraUsageCost(usage.extraUsage, loginMethod: loginMethod)
+        let extraRateWindows = Self.oauthExtraRateWindows(from: usage)
 
         return ClaudeUsageSnapshot(
             primary: primary,
             secondary: weekly,
             opus: modelSpecific,
+            extraRateWindows: extraRateWindows,
             providerCost: providerCost,
             updatedAt: Date(),
             accountEmail: nil,
@@ -677,7 +1008,8 @@ public struct ClaudeUsageFetcher: ClaudeUsageFetching, Sendable {
 
     private static func oauthExtraUsageCost(
         _ extra: OAuthExtraUsage?,
-        loginMethod: String?) -> ProviderCostSnapshot?
+        loginMethod: String?,
+        treatAsSpendLimit: Bool = false) -> ProviderCostSnapshot?
     {
         guard let extra, extra.isEnabled == true else { return nil }
         guard let used = extra.usedCredits,
@@ -685,32 +1017,86 @@ public struct ClaudeUsageFetcher: ClaudeUsageFetching, Sendable {
         else { return nil }
         let currency = extra.currency?.trimmingCharacters(in: .whitespacesAndNewlines)
         let code = (currency?.isEmpty ?? true) ? "USD" : currency!
-        let normalized = Self.normalizeClaudeExtraUsageAmounts(used: used, limit: limit)
+        let isSpendLimit = treatAsSpendLimit || ClaudePlan.fromCompatibilityLoginMethod(loginMethod) == .enterprise
+        let normalized = Self.normalizeClaudeExtraUsageAmounts(
+            used: used,
+            limit: limit,
+            treatAsMajorUnits: false)
         return ProviderCostSnapshot(
             used: normalized.used,
             limit: normalized.limit,
             currencyCode: code,
-            period: "Monthly",
+            period: isSpendLimit ? "Spend limit" : "Monthly cap",
             resetsAt: nil,
             updatedAt: Date())
     }
 
-    private static func normalizeClaudeExtraUsageAmounts(used: Double, limit: Double) -> (
-        used: Double, limit: Double)
+    private static func oauthSpendLimitWindow(
+        from providerCost: ProviderCostSnapshot?,
+        extraUsage: OAuthExtraUsage?) -> RateWindow?
     {
+        guard let providerCost,
+              providerCost.limit > 0
+        else { return nil }
+        let usedPercent = extraUsage?.utilization ?? (providerCost.used / providerCost.limit) * 100
+        let used = UsageFormatter.currencyString(providerCost.used, currencyCode: providerCost.currencyCode)
+        let limit = UsageFormatter.currencyString(providerCost.limit, currencyCode: providerCost.currencyCode)
+        return RateWindow(
+            usedPercent: min(100, max(0, usedPercent)),
+            windowMinutes: nil,
+            resetsAt: providerCost.resetsAt,
+            resetDescription: "\(providerCost.period ?? "Spend limit"): \(used) / \(limit)")
+    }
+
+    private static func normalizeClaudeExtraUsageAmounts(
+        used: Double,
+        limit: Double,
+        treatAsMajorUnits: Bool) -> (used: Double, limit: Double)
+    {
+        if treatAsMajorUnits {
+            return (used: used, limit: limit)
+        }
+
         // Claude's OAuth API returns values in cents (minor units), same as the Web API.
         // Always convert to dollars (major units) for display consistency.
         // See: ClaudeWebAPIFetcher.swift which always divides by 100.
-        (used: used / 100.0, limit: limit / 100.0)
+        return (used: used / 100.0, limit: limit / 100.0)
     }
 
-    private static func inferPlan(rateLimitTier: String?) -> String? {
-        let tier = rateLimitTier?.lowercased() ?? ""
-        if tier.contains("max") { return "Claude Max" }
-        if tier.contains("pro") { return "Claude Pro" }
-        if tier.contains("team") { return "Claude Team" }
-        if tier.contains("enterprise") { return "Claude Enterprise" }
-        return nil
+    private static func oauthExtraRateWindows(from usage: OAuthUsageResponse) -> [NamedRateWindow] {
+        let definitions: [(id: String, title: String, window: OAuthUsageWindow?, sourceKey: String?)] = [
+            (
+                id: "claude-routines",
+                title: "Daily Routines",
+                window: usage.sevenDayRoutines,
+                sourceKey: usage.sevenDayRoutinesSourceKey),
+        ]
+        if let routinesKey = usage.sevenDayRoutinesSourceKey {
+            Self.log.debug("Claude OAuth extra usage key matched: routines=\(routinesKey)")
+        }
+        return definitions.compactMap { definition in
+            let utilization: Double
+            let resetDate: Date?
+            if let window = definition.window, let parsedUtilization = window.utilization {
+                utilization = parsedUtilization
+                resetDate = ClaudeOAuthUsageFetcher.parseISO8601Date(window.resetsAt)
+            } else if definition.sourceKey != nil {
+                // Keep product bars visible when the API returns a known key with null payload.
+                utilization = 0
+                resetDate = nil
+            } else {
+                return nil
+            }
+            let resetDescription = resetDate.map(Self.formatResetDate)
+            return NamedRateWindow(
+                id: definition.id,
+                title: definition.title,
+                window: RateWindow(
+                    usedPercent: utilization,
+                    windowMinutes: Self.weeklyWindowMinutes,
+                    resetsAt: resetDate,
+                    resetDescription: resetDescription))
+        }
     }
 
     // MARK: - Web API path (uses browser cookies)
@@ -718,11 +1104,17 @@ public struct ClaudeUsageFetcher: ClaudeUsageFetching, Sendable {
     private func loadViaWebAPI() async throws -> ClaudeUsageSnapshot {
         let webData: ClaudeWebAPIFetcher.WebUsageData =
             if let header = self.manualCookieHeader {
-                try await ClaudeWebAPIFetcher.fetchUsage(cookieHeader: header) { msg in
+                try await ClaudeWebAPIFetcher.fetchUsage(
+                    cookieHeader: header,
+                    targetOrganizationID: self.webOrganizationID)
+                { msg in
                     Self.log.debug(msg)
                 }
             } else {
-                try await ClaudeWebAPIFetcher.fetchUsage(browserDetection: self.browserDetection) { msg in
+                try await ClaudeWebAPIFetcher.fetchUsage(
+                    browserDetection: self.browserDetection,
+                    targetOrganizationID: self.webOrganizationID)
+                { msg in
                     Self.log.debug(msg)
                 }
             }
@@ -753,6 +1145,7 @@ public struct ClaudeUsageFetcher: ClaudeUsageFetching, Sendable {
             primary: primary,
             secondary: secondary,
             opus: opus,
+            extraRateWindows: webData.extraRateWindows,
             providerCost: webData.extraUsageCost,
             updatedAt: Date(),
             accountEmail: webData.accountEmail,
@@ -770,42 +1163,79 @@ public struct ClaudeUsageFetcher: ClaudeUsageFetching, Sendable {
 
     // MARK: - PTY-based probe (no tmux)
 
-    private func loadViaPTY(model: String, timeout: TimeInterval = 10) async throws
-        -> ClaudeUsageSnapshot
-    {
-        guard TTYCommandRunner.which("claude") != nil else {
+    private func loadViaPTY(model: String, timeout: TimeInterval = 10) async throws -> ClaudeUsageSnapshot {
+        guard let claudeBinary = ClaudeCLIResolver.resolvedBinaryPath(environment: self.environment) else {
             throw ClaudeUsageError.claudeNotInstalled
         }
         let probe = ClaudeStatusProbe(
-            claudeBinary: "claude",
+            claudeBinary: claudeBinary,
             timeout: timeout,
             keepCLISessionsAlive: self.keepCLISessionsAlive)
         let snap = try await probe.fetch()
 
+        return try Self.makeSnapshot(from: snap)
+    }
+
+    private func loadViaDirectCLI(timeout: TimeInterval) async throws -> ClaudeUsageSnapshot {
+        guard let claudeBinary = ClaudeCLIResolver.resolvedBinaryPath(environment: self.environment) else {
+            throw ClaudeUsageError.claudeNotInstalled
+        }
+
+        let workingDirectory = ClaudeStatusProbe.preparedProbeWorkingDirectoryURL()
+        var environment = ClaudeCLISession.launchEnvironment(baseEnv: self.environment)
+        environment["PWD"] = workingDirectory.path
+        defer {
+            ClaudeProbeSessionArtifactCleaner.cleanupProbeSessionArtifacts(
+                probeDirectory: workingDirectory,
+                environment: environment)
+        }
+
+        let result = try await SubprocessRunner.run(
+            binary: claudeBinary,
+            arguments: ["/usage"],
+            environment: environment,
+            timeout: timeout,
+            standardInput: FileHandle.nullDevice,
+            currentDirectoryURL: workingDirectory,
+            label: "claude-direct-usage")
+        let snap = try ClaudeStatusProbe.parse(text: result.stdout)
+        return try Self.makeSnapshot(from: snap)
+    }
+
+    private static func makeSnapshot(from snap: ClaudeStatusSnapshot) throws -> ClaudeUsageSnapshot {
         guard let sessionPctLeft = snap.sessionPercentLeft else {
             throw ClaudeUsageError.parseFailed("missing session data")
         }
 
-        func makeWindow(pctLeft: Int?, reset: String?) -> RateWindow? {
+        func makeWindow(pctLeft: Int?, reset: String?, windowMinutes: Int) -> RateWindow? {
             guard let left = pctLeft else { return nil }
             let used = max(0, min(100, 100 - Double(left)))
             let resetClean = reset?.trimmingCharacters(in: .whitespacesAndNewlines)
             return RateWindow(
                 usedPercent: used,
-                windowMinutes: nil,
+                windowMinutes: windowMinutes,
                 resetsAt: ClaudeStatusProbe.parseResetDate(from: resetClean),
                 resetDescription: resetClean)
         }
 
-        let primary = makeWindow(pctLeft: sessionPctLeft, reset: snap.primaryResetDescription)!
+        let primary = makeWindow(
+            pctLeft: sessionPctLeft,
+            reset: snap.primaryResetDescription,
+            windowMinutes: Self.sessionWindowMinutes)!
         let weekly = makeWindow(
-            pctLeft: snap.weeklyPercentLeft, reset: snap.secondaryResetDescription)
-        let opus = makeWindow(pctLeft: snap.opusPercentLeft, reset: snap.opusResetDescription)
+            pctLeft: snap.weeklyPercentLeft,
+            reset: snap.secondaryResetDescription,
+            windowMinutes: Self.weeklyWindowMinutes)
+        let opus = makeWindow(
+            pctLeft: snap.opusPercentLeft,
+            reset: snap.opusResetDescription,
+            windowMinutes: Self.weeklyWindowMinutes)
 
         return ClaudeUsageSnapshot(
             primary: primary,
             secondary: weekly,
             opus: opus,
+            extraRateWindows: [],
             providerCost: nil,
             updatedAt: Date(),
             accountEmail: snap.accountEmail,
@@ -814,30 +1244,37 @@ public struct ClaudeUsageFetcher: ClaudeUsageFetching, Sendable {
             rawText: snap.rawText)
     }
 
-    private func applyWebExtrasIfNeeded(to snapshot: ClaudeUsageSnapshot) async
-        -> ClaudeUsageSnapshot
-    {
+    private func applyWebExtrasIfNeeded(to snapshot: ClaudeUsageSnapshot) async -> ClaudeUsageSnapshot {
         guard self.useWebExtras, self.dataSource != .web else { return snapshot }
         do {
             let webData: ClaudeWebAPIFetcher.WebUsageData =
                 if let header = self.manualCookieHeader {
-                    try await ClaudeWebAPIFetcher.fetchUsage(cookieHeader: header) { msg in
+                    try await ClaudeWebAPIFetcher.fetchUsage(
+                        cookieHeader: header,
+                        targetOrganizationID: self.webOrganizationID)
+                    { msg in
                         Self.log.debug(msg)
                     }
                 } else {
                     try await ClaudeWebAPIFetcher.fetchUsage(
-                        browserDetection: self.browserDetection)
+                        browserDetection: self.browserDetection,
+                        targetOrganizationID: self.webOrganizationID)
                     { msg in
                         Self.log.debug(msg)
                     }
                 }
-            // Only merge cost extras; keep identity fields from the primary data source.
-            if snapshot.providerCost == nil, let extra = webData.extraUsageCost {
+            // Only merge usage/cost extras; keep identity fields from the primary data source.
+            let mergedExtraRateWindows = snapshot.extraRateWindows.isEmpty ? webData.extraRateWindows : snapshot
+                .extraRateWindows
+            let mergedProviderCost = snapshot.providerCost ?? webData.extraUsageCost
+            if mergedProviderCost != snapshot.providerCost || mergedExtraRateWindows != snapshot.extraRateWindows {
                 return ClaudeUsageSnapshot(
                     primary: snapshot.primary,
+                    primaryWindowKind: snapshot.primaryWindowKind,
                     secondary: snapshot.secondary,
                     opus: snapshot.opus,
-                    providerCost: extra,
+                    extraRateWindows: mergedExtraRateWindows,
+                    providerCost: mergedProviderCost,
                     updatedAt: snapshot.updatedAt,
                     accountEmail: snapshot.accountEmail,
                     accountOrganization: snapshot.accountOrganization,
@@ -882,104 +1319,6 @@ public struct ClaudeUsageFetcher: ClaudeUsageFetching, Sendable {
         let data = pipe.fileHandleForReading.readDataToEndOfFile()
         return String(data: data, encoding: .utf8)
     }
-}
-
-extension ClaudeUsageFetcher {
-    public func loadLatestUsage(model: String = "sonnet") async throws -> ClaudeUsageSnapshot {
-        switch self.dataSource {
-        case .auto:
-            let oauthCreds: ClaudeOAuthCredentials?
-            let oauthProbeError: Error?
-            do {
-                oauthCreds = try ClaudeOAuthCredentialsStore.load(
-                    environment: self.environment,
-                    allowKeychainPrompt: false,
-                    respectKeychainPromptCooldown: true)
-                oauthProbeError = nil
-            } catch {
-                oauthCreds = nil
-                oauthProbeError = error
-            }
-
-            let hasOAuthCredentials = oauthCreds?.scopes.contains("user:profile") ?? false
-            let hasWebSession =
-                if let header = self.manualCookieHeader {
-                    ClaudeWebAPIFetcher.hasSessionKey(cookieHeader: header)
-                } else {
-                    ClaudeWebAPIFetcher.hasSessionKey(browserDetection: self.browserDetection)
-                }
-            let hasCLI = TTYCommandRunner.which("claude") != nil
-
-            var autoDecisionMetadata: [String: String] = [
-                "hasOAuthCredentials": "\(hasOAuthCredentials)",
-                "hasWebSession": "\(hasWebSession)",
-                "hasCLI": "\(hasCLI)",
-                "oauthReadStrategy": ClaudeOAuthKeychainReadStrategyPreference.current().rawValue,
-            ]
-            if let oauthCreds {
-                autoDecisionMetadata["oauthProbe"] = "success"
-                for (key, value) in oauthCreds.diagnosticsMetadata(now: Date()) {
-                    autoDecisionMetadata[key] = value
-                }
-            } else if let oauthProbeError {
-                autoDecisionMetadata["oauthProbe"] = "failure"
-                autoDecisionMetadata["oauthProbeError"] = Self.oauthCredentialProbeErrorLabel(oauthProbeError)
-            } else {
-                autoDecisionMetadata["oauthProbe"] = "none"
-            }
-
-            func logAutoDecision(selected: String) {
-                var metadata = autoDecisionMetadata
-                metadata["selected"] = selected
-                Self.log.debug("Claude auto source decision", metadata: metadata)
-            }
-
-            if hasOAuthCredentials {
-                logAutoDecision(selected: "oauth")
-                var snap = try await self.loadViaOAuth(allowDelegatedRetry: true)
-                snap = await self.applyWebExtrasIfNeeded(to: snap)
-                return snap
-            }
-            if hasWebSession {
-                logAutoDecision(selected: "web")
-                return try await self.loadViaWebAPI()
-            }
-            if hasCLI {
-                do {
-                    logAutoDecision(selected: "cli")
-                    var snap = try await self.loadViaPTY(model: model, timeout: 10)
-                    snap = await self.applyWebExtrasIfNeeded(to: snap)
-                    return snap
-                } catch {
-                    Self.log.debug(
-                        "Claude auto source CLI path failed; falling back to OAuth",
-                        metadata: [
-                            "errorType": String(describing: type(of: error)),
-                        ])
-                }
-            }
-            logAutoDecision(selected: "oauthFallback")
-            var snap = try await self.loadViaOAuth(allowDelegatedRetry: true)
-            snap = await self.applyWebExtrasIfNeeded(to: snap)
-            return snap
-        case .oauth:
-            var snap = try await self.loadViaOAuth(allowDelegatedRetry: true)
-            snap = await self.applyWebExtrasIfNeeded(to: snap)
-            return snap
-        case .web:
-            return try await self.loadViaWebAPI()
-        case .cli:
-            do {
-                var snap = try await self.loadViaPTY(model: model, timeout: 10)
-                snap = await self.applyWebExtrasIfNeeded(to: snap)
-                return snap
-            } catch {
-                var snap = try await self.loadViaPTY(model: model, timeout: 24)
-                snap = await self.applyWebExtrasIfNeeded(to: snap)
-                return snap
-            }
-        }
-    }
 
     private static func oauthCredentialProbeErrorLabel(_ error: Error) -> String {
         guard let oauthError = error as? ClaudeOAuthCredentialsError else {
@@ -1013,7 +1352,8 @@ extension ClaudeUsageFetcher {
 extension ClaudeUsageFetcher {
     public static func _mapOAuthUsageForTesting(
         _ data: Data,
-        rateLimitTier: String? = nil) throws -> ClaudeUsageSnapshot
+        rateLimitTier: String? = nil,
+        subscriptionType: String? = nil) throws -> ClaudeUsageSnapshot
     {
         let usage = try ClaudeOAuthUsageFetcher.decodeUsageResponse(data)
         let creds = ClaudeOAuthCredentials(
@@ -1021,7 +1361,8 @@ extension ClaudeUsageFetcher {
             refreshToken: nil,
             expiresAt: Date().addingTimeInterval(3600),
             scopes: [],
-            rateLimitTier: rateLimitTier)
+            rateLimitTier: rateLimitTier,
+            subscriptionType: subscriptionType)
         return try Self.mapOAuthUsage(usage, credentials: creds)
     }
 }
diff --git a/Sources/CodexBarCore/Providers/Claude/ClaudeWeb/ClaudeWebAPIFetcher.swift b/Sources/CodexBarCore/Providers/Claude/ClaudeWeb/ClaudeWebAPIFetcher.swift
index e004b47c12..46573dfb69 100644
--- a/Sources/CodexBarCore/Providers/Claude/ClaudeWeb/ClaudeWebAPIFetcher.swift
+++ b/Sources/CodexBarCore/Providers/Claude/ClaudeWeb/ClaudeWebAPIFetcher.swift
@@ -4,6 +4,97 @@ import SweetCookieKit
 import FoundationNetworking
 #endif
 
+enum ClaudeWebHTTPTransport {
+    #if DEBUG
+    @TaskLocal static var overrideForTesting: (any ProviderHTTPTransport)?
+    #endif
+
+    static var current: any ProviderHTTPTransport {
+        #if DEBUG
+        if let override = self.overrideForTesting {
+            return override
+        }
+        #endif
+        return ProviderHTTPClient.shared
+    }
+}
+
+enum ClaudeWebSessionKeyImport {
+    #if DEBUG
+    @TaskLocal static var overrideForTesting: ClaudeWebAPIFetcher.SessionKeyInfo?
+    #endif
+
+    static var currentOverride: ClaudeWebAPIFetcher.SessionKeyInfo? {
+        #if DEBUG
+        self.overrideForTesting
+        #else
+        nil
+        #endif
+    }
+}
+
+private actor ClaudeWebBrowserFetchGate {
+    private struct Waiter {
+        let id: UUID
+        let continuation: CheckedContinuation<Bool, Never>
+    }
+
+    private var ownerID: UUID?
+    private var waiters: [Waiter] = []
+
+    func acquire(id: UUID) async -> Bool {
+        if Task.isCancelled { return false }
+        guard self.ownerID != nil else {
+            self.ownerID = id
+            return true
+        }
+        return await withCheckedContinuation { continuation in
+            self.waiters.append(Waiter(id: id, continuation: continuation))
+        }
+    }
+
+    func cancel(id: UUID) {
+        if self.ownerID == id { return }
+        guard let index = self.waiters.firstIndex(where: { $0.id == id }) else { return }
+        let waiter = self.waiters.remove(at: index)
+        waiter.continuation.resume(returning: false)
+    }
+
+    func release(id: UUID) {
+        guard self.ownerID == id else { return }
+        guard !self.waiters.isEmpty else {
+            self.ownerID = nil
+            return
+        }
+        let waiter = self.waiters.removeFirst()
+        self.ownerID = waiter.id
+        waiter.continuation.resume(returning: true)
+    }
+}
+
+private enum ClaudeWebBrowserFetchSerialization {
+    private static let gate = ClaudeWebBrowserFetchGate()
+
+    static func run<T>(_ operation: () async throws -> T) async throws -> T {
+        let id = UUID()
+        let acquired = await withTaskCancellationHandler {
+            await self.gate.acquire(id: id)
+        } onCancel: {
+            Task { await self.gate.cancel(id: id) }
+        }
+        guard acquired else { throw CancellationError() }
+        do {
+            try Task.checkCancellation()
+            let value = try await operation()
+            await self.gate.release(id: id)
+            return value
+        } catch {
+            await self.gate.release(id: id)
+            throw error
+        }
+    }
+}
+
 /// Fetches Claude usage data directly from the claude.ai API using browser session cookies.
 ///
 /// This approach mirrors what Claude Usage Tracker does, but automatically extracts the session key
@@ -54,6 +145,7 @@ public enum ClaudeWebAPIFetcher {
         case unauthorized
         case serverError(statusCode: Int)
         case noOrganization
+        case organizationNotFound(String)
 
         public var errorDescription: String? {
             switch self {
@@ -68,11 +160,13 @@ public enum ClaudeWebAPIFetcher {
             case .invalidResponse:
                 "Invalid response from Claude API."
             case .unauthorized:
-                "Unauthorized. Your Claude session may have expired."
+                "Sign in to claude.ai (or refresh Claude cookies) to load usage data."
             case let .serverError(code):
                 "Claude API error: HTTP \(code)"
             case .noOrganization:
                 "No Claude organization found for this account."
+            case let .organizationNotFound(id):
+                "Claude organization '\(id)' was not found for this session."
             }
         }
     }
@@ -84,6 +178,7 @@ public enum ClaudeWebAPIFetcher {
         public let weeklyPercentUsed: Double?
         public let weeklyResetsAt: Date?
         public let opusPercentUsed: Double?
+        public let extraRateWindows: [NamedRateWindow]
         public let extraUsageCost: ProviderCostSnapshot?
         public let accountOrganization: String?
         public let accountEmail: String?
@@ -95,6 +190,7 @@ public enum ClaudeWebAPIFetcher {
             weeklyPercentUsed: Double?,
             weeklyResetsAt: Date?,
             opusPercentUsed: Double?,
+            extraRateWindows: [NamedRateWindow],
             extraUsageCost: ProviderCostSnapshot?,
             accountOrganization: String?,
             accountEmail: String?,
@@ -105,6 +201,7 @@ public enum ClaudeWebAPIFetcher {
             self.weeklyPercentUsed = weeklyPercentUsed
             self.weeklyResetsAt = weeklyResetsAt
             self.opusPercentUsed = opusPercentUsed
+            self.extraRateWindows = extraRateWindows
             self.extraUsageCost = extraUsageCost
             self.accountOrganization = accountOrganization
             self.accountEmail = accountEmail
@@ -131,63 +228,90 @@ public enum ClaudeWebAPIFetcher {
     /// Tries browser cookies using the standard import order.
     public static func fetchUsage(
         browserDetection: BrowserDetection,
+        targetOrganizationID: String? = nil,
         logger: ((String) -> Void)? = nil) async throws -> WebUsageData
     {
-        let log: (String) -> Void = { msg in logger?("[claude-web] \(msg)") }
-
-        if let cached = CookieHeaderCache.load(provider: .claude),
-           !cached.cookieHeader.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
-        {
-            log("Using cached cookie header from \(cached.sourceLabel)")
-            do {
-                return try await self.fetchUsage(cookieHeader: cached.cookieHeader, logger: log)
-            } catch let error as FetchError {
-                switch error {
-                case .unauthorized, .noSessionKeyFound, .invalidSessionKey:
-                    CookieHeaderCache.clear(provider: .claude)
-                default:
-                    throw error
-                }
-            } catch {
-                throw error
-            }
+        try await ClaudeWebBrowserFetchSerialization.run {
+            try await self.fetchUsageSerialized(
+                browserDetection: browserDetection,
+                targetOrganizationID: targetOrganizationID,
+                logger: logger)
         }
-
-        let sessionInfo = try extractSessionKeyInfo(browserDetection: browserDetection, logger: log)
-        log("Found session key (\(sessionInfo.cookieCount) cookies)")
-
-        let usage = try await self.fetchUsage(using: sessionInfo, logger: log)
-        CookieHeaderCache.store(
-            provider: .claude,
-            cookieHeader: "sessionKey=\(sessionInfo.key)",
-            sourceLabel: sessionInfo.sourceLabel)
-        return usage
     }
 
     public static func fetchUsage(
         cookieHeader: String,
+        targetOrganizationID: String? = nil,
         logger: ((String) -> Void)? = nil) async throws -> WebUsageData
     {
         let log: (String) -> Void = { msg in logger?("[claude-web] \(msg)") }
         let sessionInfo = try self.sessionKeyInfo(cookieHeader: cookieHeader)
         log("Using manual session key (\(sessionInfo.cookieCount) cookies)")
-        return try await self.fetchUsage(using: sessionInfo, logger: log)
+        return try await self.fetchUsage(
+            using: sessionInfo,
+            targetOrganizationID: targetOrganizationID,
+            logger: log)
     }
 
     public static func fetchUsage(
         using sessionKeyInfo: SessionKeyInfo,
+        targetOrganizationID: String? = nil,
+        logger: ((String) -> Void)? = nil) async throws -> WebUsageData
+    {
+        try await self.fetchUsage(
+            using: sessionKeyInfo,
+            targetOrganizationID: targetOrganizationID,
+            logger: logger,
+            cacheSourceLabel: nil,
+            expectedCacheObservation: .authoritative(nil))
+    }
+
+    private static func fetchUsageAndRenewCache(
+        cachedEntry: CookieHeaderCache.Entry,
+        targetOrganizationID: String?,
         logger: ((String) -> Void)? = nil) async throws -> WebUsageData
+    {
+        let sessionInfo = try self.sessionKeyInfo(cookieHeader: cachedEntry.cookieHeader)
+        return try await self.fetchUsage(
+            using: sessionInfo,
+            targetOrganizationID: targetOrganizationID,
+            logger: logger,
+            cacheSourceLabel: cachedEntry.sourceLabel,
+            expectedCacheObservation: .authoritative(cachedEntry))
+    }
+
+    private static func fetchUsage(
+        using sessionKeyInfo: SessionKeyInfo,
+        targetOrganizationID: String?,
+        logger: ((String) -> Void)?,
+        cacheSourceLabel: String?,
+        expectedCacheObservation: CookieHeaderCache.ConditionalMutationObservation,
+        persistInitialSessionKey: Bool = false) async throws -> WebUsageData
     {
         let log: (String) -> Void = { msg in logger?(msg) }
         let sessionKey = sessionKeyInfo.key
+        let renewalTracker = ClaudeWebSessionKeyRenewalTracker(initialSessionKey: sessionKey)
 
         // Fetch organization info
-        let organization = try await fetchOrganizationInfo(sessionKey: sessionKey, logger: log)
+        let organization = try await fetchOrganizationInfo(
+            sessionKey: sessionKey,
+            targetOrganizationID: targetOrganizationID,
+            logger: log,
+            renewalTracker: renewalTracker)
         log("Organization resolved")
 
-        var usage = try await fetchUsageData(orgId: organization.id, sessionKey: sessionKey, logger: log)
+        var usage = try await fetchUsageData(
+            orgId: organization.id,
+            sessionKey: renewalTracker.sessionKey,
+            logger: log,
+            renewalTracker: renewalTracker)
         if usage.extraUsageCost == nil,
-           let extra = await fetchExtraUsageCost(orgId: organization.id, sessionKey: sessionKey, logger: log)
+           let extra = await ClaudeWebExtraUsageCost.fetch(
+               baseURL: Self.baseURL,
+               orgId: organization.id,
+               sessionKey: renewalTracker.sessionKey,
+               logger: log,
+               renewalTracker: renewalTracker)
         {
             usage = WebUsageData(
                 sessionPercentUsed: usage.sessionPercentUsed,
@@ -195,18 +319,25 @@ public enum ClaudeWebAPIFetcher {
                 weeklyPercentUsed: usage.weeklyPercentUsed,
                 weeklyResetsAt: usage.weeklyResetsAt,
                 opusPercentUsed: usage.opusPercentUsed,
+                extraRateWindows: usage.extraRateWindows,
                 extraUsageCost: extra,
                 accountOrganization: usage.accountOrganization,
                 accountEmail: usage.accountEmail,
                 loginMethod: usage.loginMethod)
         }
-        if let account = await fetchAccountInfo(sessionKey: sessionKey, orgId: organization.id, logger: log) {
+        if let account = await fetchAccountInfo(
+            sessionKey: renewalTracker.sessionKey,
+            orgId: organization.id,
+            logger: log,
+            renewalTracker: renewalTracker)
+        {
             usage = WebUsageData(
                 sessionPercentUsed: usage.sessionPercentUsed,
                 sessionResetsAt: usage.sessionResetsAt,
                 weeklyPercentUsed: usage.weeklyPercentUsed,
                 weeklyResetsAt: usage.weeklyResetsAt,
                 opusPercentUsed: usage.opusPercentUsed,
+                extraRateWindows: usage.extraRateWindows,
                 extraUsageCost: usage.extraUsageCost,
                 accountOrganization: usage.accountOrganization,
                 accountEmail: account.email,
@@ -219,11 +350,20 @@ public enum ClaudeWebAPIFetcher {
                 weeklyPercentUsed: usage.weeklyPercentUsed,
                 weeklyResetsAt: usage.weeklyResetsAt,
                 opusPercentUsed: usage.opusPercentUsed,
+                extraRateWindows: usage.extraRateWindows,
                 extraUsageCost: usage.extraUsageCost,
                 accountOrganization: name,
                 accountEmail: usage.accountEmail,
                 loginMethod: usage.loginMethod)
         }
+        if let cacheSourceLabel {
+            self.persistSessionKeyIfNeeded(
+                source: (sessionKey, cacheSourceLabel),
+                renewedCookieHeader: renewalTracker.renewedCookieHeader,
+                expectedCacheObservation: expectedCacheObservation,
+                persistInitialSessionKey: persistInitialSessionKey,
+                logger: log)
+        }
         return usage
     }
 
@@ -264,7 +404,7 @@ public enum ClaudeWebAPIFetcher {
             request.timeoutInterval = 20
 
             do {
-                let (data, response) = try await URLSession.shared.data(for: request)
+                let (data, response) = try await ClaudeWebHTTPTransport.current.data(for: request)
                 let http = response as? HTTPURLResponse
                 let contentType = http?.allHeaderFields["Content-Type"] as? String
                 let truncated = data.prefix(Self.maxProbeBytes)
@@ -342,6 +482,7 @@ public enum ClaudeWebAPIFetcher {
         browserDetection: BrowserDetection,
         logger: ((String) -> Void)? = nil) throws -> SessionKeyInfo
     {
+        if let override = ClaudeWebSessionKeyImport.currentOverride { return override }
         let log: (String) -> Void = { msg in logger?(msg) }
 
         let cookieDomains = ["claude.ai"]
@@ -351,7 +492,7 @@ public enum ClaudeWebAPIFetcher {
         for browserSource in installedBrowsers {
             do {
                 let query = BrowserCookieQuery(domains: cookieDomains)
-                let sources = try Self.cookieClient.records(
+                let sources = try Self.cookieClient.codexBarRecords(
                     matching: query,
                     in: browserSource,
                     logger: log)
@@ -390,7 +531,9 @@ public enum ClaudeWebAPIFetcher {
 
     private static func fetchOrganizationInfo(
         sessionKey: String,
-        logger: ((String) -> Void)? = nil) async throws -> OrganizationInfo
+        targetOrganizationID: String? = nil,
+        logger: ((String) -> Void)? = nil,
+        renewalTracker: ClaudeWebSessionKeyRenewalTracker? = nil) async throws -> OrganizationInfo
     {
         let url = URL(string: "\(baseURL)/organizations")!
         var request = URLRequest(url: url)
@@ -399,17 +542,18 @@ public enum ClaudeWebAPIFetcher {
         request.httpMethod = "GET"
         request.timeoutInterval = 15
 
-        let (data, response) = try await URLSession.shared.data(for: request)
+        let (data, response) = try await ClaudeWebHTTPTransport.current.data(for: request)
 
         guard let httpResponse = response as? HTTPURLResponse else {
             throw FetchError.invalidResponse
         }
+        renewalTracker?.observe(response: httpResponse)
 
         logger?("Organizations API status: \(httpResponse.statusCode)")
 
         switch httpResponse.statusCode {
         case 200:
-            return try self.parseOrganizationResponse(data)
+            return try self.parseOrganizationResponse(data, targetOrganizationID: targetOrganizationID)
         case 401, 403:
             throw FetchError.unauthorized
         default:
@@ -420,7 +564,8 @@ public enum ClaudeWebAPIFetcher {
     private static func fetchUsageData(
         orgId: String,
         sessionKey: String,
-        logger: ((String) -> Void)? = nil) async throws -> WebUsageData
+        logger: ((String) -> Void)? = nil,
+        renewalTracker: ClaudeWebSessionKeyRenewalTracker? = nil) async throws -> WebUsageData
     {
         let url = URL(string: "\(baseURL)/organizations/\(orgId)/usage")!
         var request = URLRequest(url: url)
@@ -429,17 +574,18 @@ public enum ClaudeWebAPIFetcher {
         request.httpMethod = "GET"
         request.timeoutInterval = 15
 
-        let (data, response) = try await URLSession.shared.data(for: request)
+        let (data, response) = try await ClaudeWebHTTPTransport.current.data(for: request)
 
         guard let httpResponse = response as? HTTPURLResponse else {
             throw FetchError.invalidResponse
         }
+        renewalTracker?.observe(response: httpResponse)
 
         logger?("Usage API status: \(httpResponse.statusCode)")
 
         switch httpResponse.statusCode {
         case 200:
-            return try self.parseUsageResponse(data)
+            return try self.parseUsageResponse(data, logger: logger)
         case 401, 403:
             throw FetchError.unauthorized
         default:
@@ -447,7 +593,7 @@ public enum ClaudeWebAPIFetcher {
         }
     }
 
-    private static func parseUsageResponse(_ data: Data) throws -> WebUsageData {
+    private static func parseUsageResponse(_ data: Data, logger: ((String) -> Void)? = nil) throws -> WebUsageData {
         guard let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
             throw FetchError.invalidResponse
         }
@@ -463,10 +609,8 @@ public enum ClaudeWebAPIFetcher {
                 sessionResets = self.parseISO8601Date(resetsAt)
             }
         }
-        guard let sessionPercent else {
-            // If we can't parse session utilization, treat this as a failure so callers can fall back to the CLI.
-            throw FetchError.invalidResponse
-        }
+        // Enterprise/credit-based accounts return null for five_hour; treat as 0% rather than an error.
+        let resolvedSessionPercent = sessionPercent ?? 0.0
 
         // Parse seven_day (weekly) usage
         var weeklyPercent: Double?
@@ -480,84 +624,40 @@ public enum ClaudeWebAPIFetcher {
             }
         }
 
-        // Parse seven_day_opus (Opus-specific weekly) usage
+        // Parse seven_day_sonnet (preferred) / seven_day_opus usage
         var opusPercent: Double?
-        if let sevenDayOpus = json["seven_day_opus"] as? [String: Any] {
-            if let utilization = sevenDayOpus["utilization"] as? Int {
-                opusPercent = Double(utilization)
-            }
+        if let sevenDaySonnet = json["seven_day_sonnet"] as? [String: Any] {
+            opusPercent = Self.percentValue(from: sevenDaySonnet["utilization"])
+        } else if let sevenDayOpus = json["seven_day_opus"] as? [String: Any] {
+            opusPercent = Self.percentValue(from: sevenDayOpus["utilization"])
+        }
+        let extraRateParse = ClaudeWebExtraRateWindowParser.parse(from: json)
+        if let sourceKey = extraRateParse.sourceKeys["claude-routines"] {
+            logger?("Usage API extra window key matched: routines=\(sourceKey)")
         }
+        let extraUsageCost = ClaudeWebExtraUsageCost.parse(from: json["extra_usage"])
 
         return WebUsageData(
-            sessionPercentUsed: sessionPercent,
+            sessionPercentUsed: resolvedSessionPercent,
             sessionResetsAt: sessionResets,
             weeklyPercentUsed: weeklyPercent,
             weeklyResetsAt: weeklyResets,
             opusPercentUsed: opusPercent,
-            extraUsageCost: nil,
+            extraRateWindows: extraRateParse.windows,
+            extraUsageCost: extraUsageCost,
             accountOrganization: nil,
             accountEmail: nil,
             loginMethod: nil)
     }
 
-    // MARK: - Extra usage cost (Claude "Extra")
-
-    private struct OverageSpendLimitResponse: Decodable {
-        let monthlyCreditLimit: Double?
-        let currency: String?
-        let usedCredits: Double?
-        let isEnabled: Bool?
-
-        enum CodingKeys: String, CodingKey {
-            case monthlyCreditLimit = "monthly_credit_limit"
-            case currency
-            case usedCredits = "used_credits"
-            case isEnabled = "is_enabled"
+    private static func percentValue(from value: Any?) -> Double? {
+        if let intValue = value as? Int {
+            return Double(intValue)
         }
-    }
-
-    /// Best-effort fetch of Claude Extra spend/limit (does not fail the main usage fetch).
-    private static func fetchExtraUsageCost(
-        orgId: String,
-        sessionKey: String,
-        logger: ((String) -> Void)? = nil) async -> ProviderCostSnapshot?
-    {
-        let url = URL(string: "\(baseURL)/organizations/\(orgId)/overage_spend_limit")!
-        var request = URLRequest(url: url)
-        request.setValue("sessionKey=\(sessionKey)", forHTTPHeaderField: "Cookie")
-        request.setValue("application/json", forHTTPHeaderField: "Accept")
-        request.httpMethod = "GET"
-        request.timeoutInterval = 15
-
-        do {
-            let (data, response) = try await URLSession.shared.data(for: request)
-            guard let httpResponse = response as? HTTPURLResponse else { return nil }
-            logger?("Overage API status: \(httpResponse.statusCode)")
-            guard httpResponse.statusCode == 200 else { return nil }
-            return Self.parseOverageSpendLimit(data)
-        } catch {
-            return nil
+        if let doubleValue = value as? Double {
+            return doubleValue
         }
-    }
-
-    private static func parseOverageSpendLimit(_ data: Data) -> ProviderCostSnapshot? {
-        guard let decoded = try? JSONDecoder().decode(OverageSpendLimitResponse.self, from: data) else { return nil }
-        guard decoded.isEnabled == true else { return nil }
-        guard let used = decoded.usedCredits,
-              let limit = decoded.monthlyCreditLimit,
-              let currency = decoded.currency,
-              !currency.isEmpty else { return nil }
-
-        let usedAmount = used / 100.0
-        let limitAmount = limit / 100.0
-
-        return ProviderCostSnapshot(
-            used: usedAmount,
-            limit: limitAmount,
-            currencyCode: currency,
-            period: "Monthly",
-            resetsAt: nil,
-            updatedAt: Date())
+        return nil
     }
 
     #if DEBUG
@@ -568,12 +668,15 @@ public enum ClaudeWebAPIFetcher {
         try self.parseUsageResponse(data)
     }
 
-    public static func _parseOrganizationsResponseForTesting(_ data: Data) throws -> OrganizationInfo {
-        try self.parseOrganizationResponse(data)
+    public static func _parseOrganizationsResponseForTesting(
+        _ data: Data,
+        targetOrganizationID: String? = nil) throws -> OrganizationInfo
+    {
+        try self.parseOrganizationResponse(data, targetOrganizationID: targetOrganizationID)
     }
 
     public static func _parseOverageSpendLimitForTesting(_ data: Data) -> ProviderCostSnapshot? {
-        self.parseOverageSpendLimit(data)
+        ClaudeWebExtraUsageCost.parseOverageSpendLimit(data)
     }
 
     public static func _parseAccountInfoForTesting(_ data: Data, orgId: String?) -> WebAccountInfo? {
@@ -592,35 +695,31 @@ public enum ClaudeWebAPIFetcher {
         return formatter.date(from: string)
     }
 
-    private struct OrganizationResponse: Decodable {
-        let uuid: String
-        let name: String?
-        let capabilities: [String]?
-
-        var normalizedCapabilities: Set<String> {
-            Set((self.capabilities ?? []).map { $0.lowercased() })
-        }
-
-        var hasChatCapability: Bool {
-            self.normalizedCapabilities.contains("chat")
-        }
-
-        var isApiOnly: Bool {
-            let normalized = self.normalizedCapabilities
-            return !normalized.isEmpty && normalized == ["api"]
-        }
-    }
-
-    private static func parseOrganizationResponse(_ data: Data) throws -> OrganizationInfo {
-        guard let organizations = try? JSONDecoder().decode([OrganizationResponse].self, from: data) else {
+    private static func parseOrganizationResponse(
+        _ data: Data,
+        targetOrganizationID: String? = nil) throws -> OrganizationInfo
+    {
+        guard let organizations = try? JSONDecoder().decode([ClaudeWebOrganizationResponse].self, from: data) else {
             throw FetchError.invalidResponse
         }
+        if let targetOrganizationID = targetOrganizationID?.trimmingCharacters(in: .whitespacesAndNewlines),
+           !targetOrganizationID.isEmpty
+        {
+            guard let selected = organizations.first(where: { $0.uuid == targetOrganizationID }) else {
+                throw FetchError.organizationNotFound(targetOrganizationID)
+            }
+            return self.organizationInfo(from: selected)
+        }
         guard let selected = organizations.first(where: { $0.hasChatCapability })
             ?? organizations.first(where: { !$0.isApiOnly })
             ?? organizations.first
         else {
             throw FetchError.noOrganization
         }
+        return self.organizationInfo(from: selected)
+    }
+
+    private static func organizationInfo(from selected: ClaudeWebOrganizationResponse) -> OrganizationInfo {
         let name = selected.name?.trimmingCharacters(in: .whitespacesAndNewlines)
         let sanitized = (name?.isEmpty ?? true) ? nil : name
         return OrganizationInfo(id: selected.uuid, name: sanitized)
@@ -667,7 +766,8 @@ public enum ClaudeWebAPIFetcher {
     private static func fetchAccountInfo(
         sessionKey: String,
         orgId: String?,
-        logger: ((String) -> Void)? = nil) async -> WebAccountInfo?
+        logger: ((String) -> Void)? = nil,
+        renewalTracker: ClaudeWebSessionKeyRenewalTracker? = nil) async -> WebAccountInfo?
     {
         let url = URL(string: "\(baseURL)/account")!
         var request = URLRequest(url: url)
@@ -677,8 +777,9 @@ public enum ClaudeWebAPIFetcher {
         request.timeoutInterval = 15
 
         do {
-            let (data, response) = try await URLSession.shared.data(for: request)
+            let (data, response) = try await ClaudeWebHTTPTransport.current.data(for: request)
             guard let httpResponse = response as? HTTPURLResponse else { return nil }
+            renewalTracker?.observe(response: httpResponse)
             logger?("Account API status: \(httpResponse.statusCode)")
             guard httpResponse.statusCode == 200 else { return nil }
             return Self.parseAccountInfo(data, orgId: orgId)
@@ -691,7 +792,7 @@ public enum ClaudeWebAPIFetcher {
         guard let response = try? JSONDecoder().decode(AccountResponse.self, from: data) else { return nil }
         let email = response.emailAddress?.trimmingCharacters(in: .whitespacesAndNewlines)
         let membership = Self.selectMembership(response.memberships, orgId: orgId)
-        let plan = Self.inferPlan(
+        let plan = ClaudePlan.webLoginMethod(
             rateLimitTier: membership?.organization.rateLimitTier,
             billingType: membership?.organization.billingType)
         return WebAccountInfo(email: email, loginMethod: plan)
@@ -708,18 +809,7 @@ public enum ClaudeWebAPIFetcher {
         return memberships.first
     }
 
-    private static func inferPlan(rateLimitTier: String?, billingType: String?) -> String? {
-        let tier = rateLimitTier?.lowercased() ?? ""
-        let billing = billingType?.lowercased() ?? ""
-        if tier.contains("max") { return "Claude Max" }
-        if tier.contains("pro") { return "Claude Pro" }
-        if tier.contains("team") { return "Claude Team" }
-        if tier.contains("enterprise") { return "Claude Enterprise" }
-        if billing.contains("stripe"), tier.contains("claude") { return "Claude Pro" }
-        return nil
-    }
-
-    private struct ProbeParseResult: Sendable {
+    private struct ProbeParseResult {
         let keys: [String]
         let emails: [String]
         let planHints: [String]
@@ -841,26 +931,32 @@ public enum ClaudeWebAPIFetcher {
 
     public static func fetchUsage(
         browserDetection: BrowserDetection,
+        targetOrganizationID: String? = nil,
         logger: ((String) -> Void)? = nil) async throws -> WebUsageData
     {
         _ = browserDetection
+        _ = targetOrganizationID
         _ = logger
         throw FetchError.notSupportedOnThisPlatform
     }
 
     public static func fetchUsage(
         cookieHeader: String,
+        targetOrganizationID: String? = nil,
         logger: ((String) -> Void)? = nil) async throws -> WebUsageData
     {
         _ = cookieHeader
+        _ = targetOrganizationID
         _ = logger
         throw FetchError.notSupportedOnThisPlatform
     }
 
     public static func fetchUsage(
         using sessionKeyInfo: SessionKeyInfo,
+        targetOrganizationID: String? = nil,
         logger: ((String) -> Void)? = nil) async throws -> WebUsageData
     {
+        _ = targetOrganizationID
         throw FetchError.notSupportedOnThisPlatform
     }
 
@@ -895,3 +991,268 @@ public enum ClaudeWebAPIFetcher {
 
     #endif
 }
+
+extension ClaudeWebAPIFetcher {
+    private static func persistSessionKeyIfNeeded(
+        source: (initialSessionKey: String, label: String),
+        renewedCookieHeader: String?,
+        expectedCacheObservation: CookieHeaderCache.ConditionalMutationObservation,
+        persistInitialSessionKey: Bool,
+        logger: (String) -> Void)
+    {
+        let importedCookieHeader = persistInitialSessionKey ? "sessionKey=\(source.initialSessionKey)" : nil
+        guard let cookieHeader = renewedCookieHeader ?? importedCookieHeader else { return }
+        let stored = CookieHeaderCache.storeIfObservationCurrent(
+            provider: .claude,
+            expected: expectedCacheObservation,
+            cookieHeader: cookieHeader,
+            sourceLabel: source.label)
+        if renewedCookieHeader != nil {
+            logger(stored ? "Stored renewed Claude session key" : "Skipped renewal because the cache changed")
+        }
+    }
+}
+
+private final class ClaudeWebSessionKeyRenewalTracker: @unchecked Sendable {
+    private let initialSessionKey: String
+    private let lock = NSLock()
+    private var currentSessionKey: String
+
+    init(initialSessionKey: String) {
+        self.initialSessionKey = initialSessionKey
+        self.currentSessionKey = initialSessionKey
+    }
+
+    var sessionKey: String {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        return self.currentSessionKey
+    }
+
+    var renewedCookieHeader: String? {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        guard self.currentSessionKey != self.initialSessionKey else { return nil }
+        return "sessionKey=\(self.currentSessionKey)"
+    }
+
+    func observe(response: HTTPURLResponse) {
+        guard response.statusCode == 200,
+              let sessionKey = Self.sessionKey(fromSetCookieHeaders: response.allHeaderFields)
+        else {
+            return
+        }
+        self.lock.lock()
+        self.currentSessionKey = sessionKey
+        self.lock.unlock()
+    }
+
+    private static func sessionKey(fromSetCookieHeaders fields: [AnyHashable: Any]) -> String? {
+        guard let value = fields.first(where: {
+            String(describing: $0.key).caseInsensitiveCompare("Set-Cookie") == .orderedSame
+        })?.value else {
+            return nil
+        }
+        var latestSessionKey: String?
+        for header in self.setCookieHeaderValues(from: value) {
+            latestSessionKey = self.sessionKey(fromSetCookieHeader: header) ?? latestSessionKey
+        }
+        return latestSessionKey
+    }
+
+    private static func setCookieHeaderValues(from value: Any) -> [String] {
+        if let values = value as? [String] {
+            return values
+        }
+        if let values = value as? [Any] {
+            return values.map { String(describing: $0) }
+        }
+        return [String(describing: value)]
+    }
+
+    private static func sessionKey(fromSetCookieHeader header: String) -> String? {
+        let pattern = #"(?i)(?:^|[,\r\n])\s*sessionKey=([^;,\r\n]+)"#
+        guard let regex = try? NSRegularExpression(pattern: pattern) else { return nil }
+        let range = NSRange(header.startIndex..<header.endIndex, in: header)
+        var latestSessionKey: String?
+        for match in regex.matches(in: header, range: range) {
+            guard match.numberOfRanges >= 2,
+                  let valueRange = Range(match.range(at: 1), in: header)
+            else {
+                continue
+            }
+            let value = String(header[valueRange]).trimmingCharacters(in: .whitespacesAndNewlines)
+            if value.hasPrefix("sk-ant-") {
+                latestSessionKey = value
+            }
+        }
+        return latestSessionKey
+    }
+}
+
+private enum ClaudeWebExtraUsageCost {
+    // MARK: - Extra usage cost (Claude "Extra")
+
+    static func parse(from value: Any?) -> ProviderCostSnapshot? {
+        guard let extraUsage = value as? [String: Any] else { return nil }
+        guard let used = Self.doubleValue(extraUsage["used_credits"]),
+              let limit = Self.doubleValue(extraUsage["monthly_limit"] ?? extraUsage["monthly_credit_limit"]),
+              limit > 0 else { return nil }
+        let currency = (extraUsage["currency"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines)
+        let currencyCode = currency?.isEmpty == false ? currency ?? "USD" : "USD"
+        return Self.makeExtraUsageCost(
+            usedCredits: used,
+            monthlyCreditLimit: limit,
+            currencyCode: currencyCode)
+    }
+
+    struct OverageSpendLimitResponse: Decodable {
+        let monthlyCreditLimit: Double?
+        let currency: String?
+        let usedCredits: Double?
+        let isEnabled: Bool?
+
+        enum CodingKeys: String, CodingKey {
+            case monthlyCreditLimit = "monthly_credit_limit"
+            case currency
+            case usedCredits = "used_credits"
+            case isEnabled = "is_enabled"
+        }
+    }
+
+    /// Best-effort fetch of Claude Extra spend/limit (does not fail the main usage fetch).
+    static func fetch(
+        baseURL: String,
+        orgId: String,
+        sessionKey: String,
+        logger: ((String) -> Void)? = nil,
+        renewalTracker: ClaudeWebSessionKeyRenewalTracker? = nil) async -> ProviderCostSnapshot?
+    {
+        let url = URL(string: "\(baseURL)/organizations/\(orgId)/overage_spend_limit")!
+        var request = URLRequest(url: url)
+        request.setValue("sessionKey=\(sessionKey)", forHTTPHeaderField: "Cookie")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        request.httpMethod = "GET"
+        request.timeoutInterval = 15
+
+        do {
+            let (data, response) = try await ClaudeWebHTTPTransport.current.data(for: request)
+            guard let httpResponse = response as? HTTPURLResponse else { return nil }
+            renewalTracker?.observe(response: httpResponse)
+            logger?("Overage API status: \(httpResponse.statusCode)")
+            guard httpResponse.statusCode == 200 else { return nil }
+            return Self.parseOverageSpendLimit(data)
+        } catch {
+            return nil
+        }
+    }
+
+    static func parseOverageSpendLimit(_ data: Data) -> ProviderCostSnapshot? {
+        guard let decoded = try? JSONDecoder().decode(OverageSpendLimitResponse.self, from: data) else { return nil }
+        guard decoded.isEnabled == true else { return nil }
+        guard let used = decoded.usedCredits,
+              let limit = decoded.monthlyCreditLimit,
+              let currency = decoded.currency,
+              !currency.isEmpty else { return nil }
+
+        return Self.makeExtraUsageCost(
+            usedCredits: used,
+            monthlyCreditLimit: limit,
+            currencyCode: currency)
+    }
+
+    static func makeExtraUsageCost(
+        usedCredits: Double,
+        monthlyCreditLimit: Double,
+        currencyCode: String) -> ProviderCostSnapshot
+    {
+        let usedAmount = usedCredits / 100.0
+        let limitAmount = monthlyCreditLimit / 100.0
+
+        return ProviderCostSnapshot(
+            used: usedAmount,
+            limit: limitAmount,
+            currencyCode: currencyCode,
+            period: "Monthly cap",
+            resetsAt: nil,
+            updatedAt: Date())
+    }
+
+    static func doubleValue(_ value: Any?) -> Double? {
+        switch value {
+        case let int as Int:
+            Double(int)
+        case let double as Double:
+            double
+        case let string as String:
+            Double(string)
+        default:
+            nil
+        }
+    }
+}
+
+#if os(macOS)
+extension ClaudeWebAPIFetcher {
+    fileprivate static func fetchUsageSerialized(
+        browserDetection: BrowserDetection,
+        targetOrganizationID: String?,
+        logger: ((String) -> Void)?) async throws -> WebUsageData
+    {
+        let log: (String) -> Void = { msg in logger?("[claude-web] \(msg)") }
+        var cacheObservation = CookieHeaderCache.observeForConditionalMutation(provider: .claude)
+
+        if let cached = cacheObservation.entry,
+           !cached.cookieHeader.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+        {
+            log("Using cached cookie header from \(cached.sourceLabel)")
+            do {
+                return try await self.fetchUsageAndRenewCache(
+                    cachedEntry: cached,
+                    targetOrganizationID: targetOrganizationID,
+                    logger: log)
+            } catch let error as FetchError {
+                switch error {
+                case .unauthorized, .noSessionKeyFound, .invalidSessionKey:
+                    let cleared = CookieHeaderCache.clearIfCurrent(provider: .claude, expected: cached)
+                    cacheObservation = .authoritative(cleared ? nil : cached)
+                default:
+                    throw error
+                }
+            } catch {
+                throw error
+            }
+        }
+
+        let sessionInfo = try extractSessionKeyInfo(browserDetection: browserDetection, logger: log)
+        log("Found session key (\(sessionInfo.cookieCount) cookies)")
+
+        return try await self.fetchUsage(
+            using: sessionInfo,
+            targetOrganizationID: targetOrganizationID,
+            logger: log,
+            cacheSourceLabel: sessionInfo.sourceLabel,
+            expectedCacheObservation: cacheObservation,
+            persistInitialSessionKey: true)
+    }
+}
+#endif
+
+private struct ClaudeWebOrganizationResponse: Decodable {
+    let uuid: String
+    let name: String?
+    let capabilities: [String]?
+
+    var normalizedCapabilities: Set<String> {
+        Set((self.capabilities ?? []).map { $0.lowercased() })
+    }
+
+    var hasChatCapability: Bool {
+        self.normalizedCapabilities.contains("chat")
+    }
+
+    var isApiOnly: Bool {
+        let normalized = self.normalizedCapabilities
+        return !normalized.isEmpty && normalized == ["api"]
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Claude/ClaudeWeb/ClaudeWebExtraRateWindowParser.swift b/Sources/CodexBarCore/Providers/Claude/ClaudeWeb/ClaudeWebExtraRateWindowParser.swift
new file mode 100644
index 0000000000..e9be31eee4
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Claude/ClaudeWeb/ClaudeWebExtraRateWindowParser.swift
@@ -0,0 +1,106 @@
+import Foundation
+
+enum ClaudeWebExtraRateWindowParser {
+    private static let definitions: [(id: String, title: String, keys: [String])] = [
+        (
+            id: "claude-routines",
+            title: "Daily Routines",
+            keys: [
+                "seven_day_routines",
+                "seven_day_claude_routines",
+                "claude_routines",
+                "routines",
+                "routine",
+                "seven_day_cowork",
+                "cowork",
+            ]),
+    ]
+
+    static func parse(from json: [String: Any]) -> (windows: [NamedRateWindow], sourceKeys: [String: String]) {
+        var windows: [NamedRateWindow] = []
+        var sourceKeys: [String: String] = [:]
+        windows.reserveCapacity(Self.definitions.count)
+
+        for definition in Self.definitions {
+            if let foundWindow = Self.firstUsageWindow(in: json, keys: definition.keys) {
+                let rawWindow = foundWindow.window
+                guard let utilization = Self.percentValue(from: rawWindow["utilization"]) else { continue }
+                let resetsAt = (rawWindow["resets_at"] as? String).flatMap(Self.parseISO8601Date)
+                windows.append(Self.namedWindow(
+                    id: definition.id,
+                    title: definition.title,
+                    usedPercent: utilization,
+                    resetsAt: resetsAt))
+                sourceKeys[definition.id] = foundWindow.sourceKey
+                continue
+            }
+
+            // Some accounts expose the key with null payloads (for example `seven_day_cowork: null`).
+            // Preserve the bar in that case with a 0% window so the product section remains visible.
+            if let key = Self.firstUsageKey(in: json, keys: definition.keys) {
+                windows.append(Self.namedWindow(
+                    id: definition.id,
+                    title: definition.title,
+                    usedPercent: 0,
+                    resetsAt: nil))
+                sourceKeys[definition.id] = key
+            }
+        }
+        return (windows, sourceKeys)
+    }
+
+    private static func namedWindow(
+        id: String,
+        title: String,
+        usedPercent: Double,
+        resetsAt: Date?) -> NamedRateWindow
+    {
+        NamedRateWindow(
+            id: id,
+            title: title,
+            window: RateWindow(
+                usedPercent: usedPercent,
+                windowMinutes: 7 * 24 * 60,
+                resetsAt: resetsAt,
+                resetDescription: nil))
+    }
+
+    private static func firstUsageWindow(
+        in json: [String: Any],
+        keys: [String]) -> (window: [String: Any], sourceKey: String)?
+    {
+        for key in keys {
+            if let window = json[key] as? [String: Any] {
+                return (window, key)
+            }
+        }
+        return nil
+    }
+
+    private static func firstUsageKey(in json: [String: Any], keys: [String]) -> String? {
+        for key in keys where json.keys.contains(key) {
+            return key
+        }
+        return nil
+    }
+
+    private static func percentValue(from value: Any?) -> Double? {
+        if let intValue = value as? Int {
+            return Double(intValue)
+        }
+        if let doubleValue = value as? Double {
+            return doubleValue
+        }
+        return nil
+    }
+
+    private static func parseISO8601Date(_ string: String) -> Date? {
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        if let date = formatter.date(from: string) {
+            return date
+        }
+        formatter.formatOptions = [.withInternetDateTime]
+        return formatter.date(from: string)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Codebuff/CodebuffProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Codebuff/CodebuffProviderDescriptor.swift
new file mode 100644
index 0000000000..6ea5634e90
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Codebuff/CodebuffProviderDescriptor.swift
@@ -0,0 +1,95 @@
+import Foundation
+
+public enum CodebuffProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .codebuff,
+            metadata: ProviderMetadata(
+                id: .codebuff,
+                displayName: "Codebuff",
+                sessionLabel: "Credits",
+                weeklyLabel: "Weekly",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: true,
+                creditsHint: "Credit balance from the Codebuff API",
+                toggleTitle: "Show Codebuff usage",
+                cliName: "codebuff",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                browserCookieOrder: nil,
+                dashboardURL: "https://www.codebuff.com/usage",
+                statusPageURL: nil,
+                statusLinkURL: nil),
+            branding: ProviderBranding(
+                iconStyle: .codebuff,
+                iconResourceName: "ProviderIcon-codebuff",
+                color: ProviderColor(red: 68 / 255, green: 255 / 255, blue: 0 / 255)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "Codebuff cost summary is not yet supported." }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .api],
+                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [CodebuffAPIFetchStrategy()] })),
+            cli: ProviderCLIConfig(
+                name: "codebuff",
+                aliases: ["manicode"],
+                versionDetector: nil))
+    }
+}
+
+struct CodebuffAPIFetchStrategy: ProviderFetchStrategy {
+    let id: String = "codebuff.api"
+    let kind: ProviderFetchKind = .apiToken
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        _ = context
+        // Keep the strategy available so missing-token surfaces as a user-friendly error
+        // instead of a generic "no strategy" outcome.
+        return true
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        guard let resolution = Self.resolveToken(environment: context.env) else {
+            throw CodebuffUsageError.missingCredentials
+        }
+        let usage = try await CodebuffUsageFetcher.fetchUsage(
+            apiKey: resolution.token,
+            environment: context.env,
+            includeSubscription: Self.shouldFetchSubscription(for: resolution))
+        return self.makeResult(
+            usage: usage.toUsageSnapshot(),
+            sourceLabel: "api")
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+
+    static func shouldFetchSubscription(for resolution: ProviderTokenResolution) -> Bool {
+        resolution.source == .authFile
+    }
+
+    private static func resolveToken(environment: [String: String]) -> ProviderTokenResolution? {
+        ProviderTokenResolver.codebuffResolution(environment: environment)
+    }
+}
+
+/// Errors related to Codebuff settings.
+public enum CodebuffSettingsError: LocalizedError, Sendable, Equatable {
+    case missingToken
+    case invalidEndpointOverride(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingToken:
+            "Codebuff API token not configured. Set CODEBUFF_API_KEY or run `codebuff login` to " +
+                "populate ~/.config/manicode/credentials.json."
+        case let .invalidEndpointOverride(key):
+            "Codebuff endpoint override \(key) must use HTTPS or a bare host."
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Codebuff/CodebuffSettingsReader.swift b/Sources/CodexBarCore/Providers/Codebuff/CodebuffSettingsReader.swift
new file mode 100644
index 0000000000..633bf00d94
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Codebuff/CodebuffSettingsReader.swift
@@ -0,0 +1,86 @@
+import Foundation
+
+/// Reads Codebuff settings from the environment or the local credentials file
+/// that the `codebuff` CLI (formerly `manicode`) writes when the user logs in.
+public enum CodebuffSettingsReader {
+    /// Environment variable key for the Codebuff API token.
+    public static let apiTokenKey = "CODEBUFF_API_KEY"
+
+    /// Returns the API token from environment if present and non-empty.
+    public static func apiKey(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        self.cleaned(environment[self.apiTokenKey])
+    }
+
+    /// Returns the API base URL, defaulting to the production endpoint.
+    public static func apiURL(environment: [String: String] = ProcessInfo.processInfo.environment) -> URL {
+        if let override = self.validAPIURL(environment: environment) {
+            return override
+        }
+        return URL(string: "https://www.codebuff.com")!
+    }
+
+    public static func validateEndpointOverrides(
+        environment: [String: String] = ProcessInfo.processInfo.environment) throws
+    {
+        guard let raw = self.cleaned(environment["CODEBUFF_API_URL"]) else { return }
+        guard ProviderEndpointOverrideValidator.normalizedHTTPSURL(from: raw) == nil else { return }
+        throw CodebuffSettingsError.invalidEndpointOverride("CODEBUFF_API_URL")
+    }
+
+    /// Returns the auth token from the local credentials file if present.
+    public static func authToken(
+        authFileURL: URL? = nil,
+        homeDirectory: URL = FileManager.default.homeDirectoryForCurrentUser) -> String?
+    {
+        let fileURL = authFileURL ?? self.defaultAuthFileURL(homeDirectory: homeDirectory)
+        guard let data = try? Data(contentsOf: fileURL) else { return nil }
+        return self.parseAuthToken(data: data)
+    }
+
+    /// Default on-disk credentials path: `~/.config/manicode/credentials.json`.
+    static func defaultAuthFileURL(homeDirectory: URL) -> URL {
+        homeDirectory
+            .appendingPathComponent(".config", isDirectory: true)
+            .appendingPathComponent("manicode", isDirectory: true)
+            .appendingPathComponent("credentials.json", isDirectory: false)
+    }
+
+    static func parseAuthToken(data: Data) -> String? {
+        guard let payload = try? JSONDecoder().decode(CredentialsFile.self, from: data) else {
+            return nil
+        }
+        return self.cleaned(payload.default?.authToken) ?? self.cleaned(payload.authToken)
+    }
+
+    static func cleaned(_ raw: String?) -> String? {
+        guard var value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
+            return nil
+        }
+
+        if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
+            (value.hasPrefix("'") && value.hasSuffix("'"))
+        {
+            value = String(value.dropFirst().dropLast())
+        }
+
+        value = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        return value.isEmpty ? nil : value
+    }
+
+    private static func validAPIURL(environment: [String: String]) -> URL? {
+        guard let raw = self.cleaned(environment["CODEBUFF_API_URL"]) else { return nil }
+        return ProviderEndpointOverrideValidator.normalizedHTTPSURL(from: raw)
+    }
+}
+
+private struct CredentialsFile: Decodable {
+    let `default`: CredentialsProfile?
+    let authToken: String?
+}
+
+private struct CredentialsProfile: Decodable {
+    let authToken: String?
+    let fingerprintId: String?
+    let email: String?
+    let name: String?
+}
diff --git a/Sources/CodexBarCore/Providers/Codebuff/CodebuffUsageError.swift b/Sources/CodexBarCore/Providers/Codebuff/CodebuffUsageError.swift
new file mode 100644
index 0000000000..729d17f89a
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Codebuff/CodebuffUsageError.swift
@@ -0,0 +1,40 @@
+import Foundation
+
+public enum CodebuffUsageError: LocalizedError, Sendable, Equatable {
+    case missingCredentials
+    case unauthorized
+    case endpointNotFound
+    case serviceUnavailable(Int)
+    case apiError(Int)
+    case networkError(String)
+    case parseFailed(String)
+
+    public static let missingToken: CodebuffUsageError = .missingCredentials
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingCredentials:
+            "Codebuff API token not configured. Set CODEBUFF_API_KEY or run `codebuff login` to " +
+                "populate ~/.config/manicode/credentials.json."
+        case .unauthorized:
+            "Unauthorized. Please sign in to Codebuff again."
+        case .endpointNotFound:
+            "Codebuff usage endpoint not found."
+        case let .serviceUnavailable(status):
+            "Codebuff API is temporarily unavailable (status \(status))."
+        case let .apiError(status):
+            "Codebuff API returned an unexpected status (\(status))."
+        case let .networkError(message):
+            "Codebuff API error: \(message)"
+        case let .parseFailed(message):
+            "Could not parse Codebuff usage: \(message)"
+        }
+    }
+
+    public var isAuthRelated: Bool {
+        switch self {
+        case .unauthorized, .missingCredentials: true
+        default: false
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Codebuff/CodebuffUsageFetcher.swift b/Sources/CodexBarCore/Providers/Codebuff/CodebuffUsageFetcher.swift
new file mode 100644
index 0000000000..830fa9beb7
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Codebuff/CodebuffUsageFetcher.swift
@@ -0,0 +1,365 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+/// Fetches live credit balance and subscription details from the Codebuff API.
+/// Uses Bearer token auth against the public www.codebuff.com endpoints used by
+/// the dashboard + the `codebuff` CLI.
+public enum CodebuffUsageFetcher {
+    private static let requestTimeoutSeconds: TimeInterval = 15
+    /// Extra grace period to wait for the optional subscription endpoint after the
+    /// primary usage call returns. Keeps the menu responsive when `/api/user/subscription`
+    /// is slow or hangs while `/api/v1/usage` succeeds quickly.
+    private static let subscriptionGraceSeconds: TimeInterval = 2
+
+    public static func fetchUsage(
+        apiKey: String,
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        includeSubscription: Bool = true,
+        session transport: any ProviderHTTPTransport = ProviderHTTPClient.shared) async throws -> CodebuffUsageSnapshot
+    {
+        try await self.fetchUsage(
+            apiKey: apiKey,
+            environment: environment,
+            includeSubscription: includeSubscription,
+            transport: transport,
+            subscriptionGrace: .seconds(self.subscriptionGraceSeconds))
+    }
+
+    static func _fetchUsageForTesting(
+        apiKey: String,
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        includeSubscription: Bool = true,
+        transport: any ProviderHTTPTransport,
+        subscriptionGrace: Duration) async throws -> CodebuffUsageSnapshot
+    {
+        try await self.fetchUsage(
+            apiKey: apiKey,
+            environment: environment,
+            includeSubscription: includeSubscription,
+            transport: transport,
+            subscriptionGrace: subscriptionGrace)
+    }
+
+    private static func fetchUsage(
+        apiKey: String,
+        environment: [String: String],
+        includeSubscription: Bool,
+        transport: any ProviderHTTPTransport,
+        subscriptionGrace: Duration) async throws -> CodebuffUsageSnapshot
+    {
+        let trimmed = apiKey.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else {
+            throw CodebuffUsageError.missingCredentials
+        }
+        try CodebuffSettingsReader.validateEndpointOverrides(environment: environment)
+
+        let baseURL = CodebuffSettingsReader.apiURL(environment: environment)
+
+        let (usageValues, subscriptionValues) = try await self.fetchPayloads(
+            apiKey: trimmed,
+            baseURL: baseURL,
+            includeSubscription: includeSubscription,
+            transport: transport,
+            subscriptionGrace: subscriptionGrace)
+
+        return CodebuffUsageSnapshot(
+            creditsUsed: usageValues.used,
+            creditsTotal: usageValues.total,
+            creditsRemaining: usageValues.remaining,
+            weeklyUsed: subscriptionValues?.weeklyUsed,
+            weeklyLimit: subscriptionValues?.weeklyLimit,
+            weeklyResetsAt: subscriptionValues?.weeklyResetsAt,
+            billingPeriodEnd: subscriptionValues?.billingPeriodEnd,
+            nextQuotaReset: usageValues.nextQuotaReset,
+            tier: subscriptionValues?.tier,
+            subscriptionStatus: subscriptionValues?.status,
+            autoTopUpEnabled: usageValues.autoTopupEnabled,
+            accountEmail: subscriptionValues?.email,
+            updatedAt: Date())
+    }
+
+    private static func fetchPayloads(
+        apiKey: String,
+        baseURL: URL,
+        includeSubscription: Bool,
+        transport: any ProviderHTTPTransport,
+        subscriptionGrace: Duration) async throws -> (UsagePayload, SubscriptionPayload?)
+    {
+        guard includeSubscription else {
+            return try await (
+                self.fetchUsagePayload(apiKey: apiKey, baseURL: baseURL, transport: transport),
+                nil)
+        }
+
+        let subscriptionTask = Task<SubscriptionPayload?, Error> {
+            try await self.fetchSubscriptionPayload(
+                apiKey: apiKey,
+                baseURL: baseURL,
+                transport: transport)
+        }
+        let usageValues: UsagePayload
+        do {
+            usageValues = try await withTaskCancellationHandler {
+                try await self.fetchUsagePayload(
+                    apiKey: apiKey,
+                    baseURL: baseURL,
+                    transport: transport)
+            } onCancel: {
+                subscriptionTask.cancel()
+            }
+        } catch {
+            subscriptionTask.cancel()
+            throw error
+        }
+
+        do {
+            try Task.checkCancellation()
+        } catch {
+            subscriptionTask.cancel()
+            throw error
+        }
+        let race = BoundedTaskJoin(sourceTask: subscriptionTask)
+        switch await race.value(joinGrace: subscriptionGrace) {
+        case let .value(subscriptionValues):
+            try Task.checkCancellation()
+            return (usageValues, subscriptionValues)
+        case .timedOut:
+            try Task.checkCancellation()
+            return (usageValues, nil)
+        case .failure:
+            subscriptionTask.cancel()
+            try Task.checkCancellation()
+            return (usageValues, nil)
+        }
+    }
+
+    // MARK: - Endpoint helpers
+
+    struct UsagePayload {
+        let used: Double?
+        let total: Double?
+        let remaining: Double?
+        let nextQuotaReset: Date?
+        let autoTopupEnabled: Bool?
+    }
+
+    struct SubscriptionPayload {
+        let status: String?
+        let tier: String?
+        let billingPeriodEnd: Date?
+        let weeklyUsed: Double?
+        let weeklyLimit: Double?
+        let weeklyResetsAt: Date?
+        let email: String?
+    }
+
+    static func usageURL(baseURL: URL) -> URL {
+        baseURL.appendingPathComponent("/api/v1/usage")
+    }
+
+    static func subscriptionURL(baseURL: URL) -> URL {
+        baseURL.appendingPathComponent("/api/user/subscription")
+    }
+
+    static func statusError(for statusCode: Int) -> CodebuffUsageError? {
+        switch statusCode {
+        case 401, 403: .unauthorized
+        case 404: .endpointNotFound
+        case 500...599: .serviceUnavailable(statusCode)
+        default: nil
+        }
+    }
+
+    static func parseUsagePayload(_ data: Data) throws -> UsagePayload {
+        guard let root = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+            throw CodebuffUsageError.parseFailed("Invalid JSON")
+        }
+
+        let used = self.double(from: root["usage"]) ?? self.double(from: root["used"])
+        let total = self.double(from: root["quota"]) ?? self.double(from: root["limit"])
+        let remaining = self.double(from: root["remainingBalance"]) ?? self.double(from: root["remaining"])
+        let reset = self.date(from: root["next_quota_reset"])
+        let autoTopUp = root["autoTopupEnabled"] as? Bool ?? root["auto_topup_enabled"] as? Bool
+
+        return UsagePayload(
+            used: used,
+            total: total,
+            remaining: remaining,
+            nextQuotaReset: reset,
+            autoTopupEnabled: autoTopUp)
+    }
+
+    static func parseSubscriptionPayload(_ data: Data) throws -> SubscriptionPayload {
+        guard let root = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+            throw CodebuffUsageError.parseFailed("Invalid JSON")
+        }
+
+        let subscription = root["subscription"] as? [String: Any]
+        let rateLimit = root["rateLimit"] as? [String: Any]
+
+        let tier = self.string(from: subscription?["displayName"])
+            ?? self.string(from: root["displayName"])
+            ?? self.string(from: subscription?["tier"])
+            ?? self.string(from: root["tier"])
+            ?? self.string(from: subscription?["scheduledTier"])
+        let status = subscription?["status"] as? String
+        let email = root["email"] as? String ?? (root["user"] as? [String: Any])?["email"] as? String
+        let billingPeriodEnd = self.date(from: subscription?["billingPeriodEnd"])
+            ?? self.date(from: subscription?["currentPeriodEnd"])
+        let weeklyUsed = self.double(from: rateLimit?["weeklyUsed"])
+            ?? self.double(from: rateLimit?["used"])
+        let weeklyLimit = self.double(from: rateLimit?["weeklyLimit"])
+            ?? self.double(from: rateLimit?["limit"])
+        let weeklyResetsAt = self.date(from: rateLimit?["weeklyResetsAt"])
+
+        return SubscriptionPayload(
+            status: status,
+            tier: tier,
+            billingPeriodEnd: billingPeriodEnd,
+            weeklyUsed: weeklyUsed,
+            weeklyLimit: weeklyLimit,
+            weeklyResetsAt: weeklyResetsAt,
+            email: email)
+    }
+
+    // MARK: - Test hooks
+
+    static func _parseUsagePayloadForTesting(_ data: Data) throws -> UsagePayload {
+        try self.parseUsagePayload(data)
+    }
+
+    static func _parseSubscriptionPayloadForTesting(_ data: Data) throws -> SubscriptionPayload {
+        try self.parseSubscriptionPayload(data)
+    }
+
+    static func _statusErrorForTesting(_ statusCode: Int) -> CodebuffUsageError? {
+        self.statusError(for: statusCode)
+    }
+
+    // MARK: - Networking
+
+    private static func fetchUsagePayload(
+        apiKey: String,
+        baseURL: URL,
+        transport: any ProviderHTTPTransport) async throws -> UsagePayload
+    {
+        var request = URLRequest(url: self.usageURL(baseURL: baseURL))
+        request.httpMethod = "POST"
+        request.timeoutInterval = self.requestTimeoutSeconds
+        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        request.httpBody = try? JSONSerialization.data(withJSONObject: ["fingerprintId": "codexbar-usage"])
+
+        let response = try await self.send(request: request, transport: transport)
+        if let err = self.statusError(for: response.statusCode) {
+            throw err
+        }
+        guard response.statusCode == 200 else {
+            throw CodebuffUsageError.apiError(response.statusCode)
+        }
+        return try self.parseUsagePayload(response.data)
+    }
+
+    private static func fetchSubscriptionPayload(
+        apiKey: String,
+        baseURL: URL,
+        transport: any ProviderHTTPTransport) async throws -> SubscriptionPayload
+    {
+        var request = URLRequest(url: self.subscriptionURL(baseURL: baseURL))
+        request.httpMethod = "GET"
+        request.timeoutInterval = self.requestTimeoutSeconds
+        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+
+        let response = try await self.send(request: request, transport: transport)
+        if let err = self.statusError(for: response.statusCode) {
+            throw err
+        }
+        guard response.statusCode == 200 else {
+            throw CodebuffUsageError.apiError(response.statusCode)
+        }
+        return try self.parseSubscriptionPayload(response.data)
+    }
+
+    private static func send(
+        request: URLRequest,
+        transport: any ProviderHTTPTransport) async throws -> ProviderHTTPResponse
+    {
+        do {
+            return try await transport.response(for: request)
+        } catch let error as CodebuffUsageError {
+            throw error
+        } catch let error as URLError where error.code == .badServerResponse {
+            throw CodebuffUsageError.networkError("Invalid response")
+        } catch {
+            throw CodebuffUsageError.networkError(error.localizedDescription)
+        }
+    }
+
+    // MARK: - Value parsing
+
+    private static func double(from value: Any?) -> Double? {
+        switch value {
+        case let number as NSNumber:
+            let raw = number.doubleValue
+            return raw.isFinite ? raw : nil
+        case let string as String:
+            let trimmed = string.trimmingCharacters(in: .whitespacesAndNewlines)
+            guard !trimmed.isEmpty, let raw = Double(trimmed), raw.isFinite else { return nil }
+            return raw
+        default:
+            return nil
+        }
+    }
+
+    private static func string(from value: Any?) -> String? {
+        switch value {
+        case let string as String:
+            let trimmed = string.trimmingCharacters(in: .whitespacesAndNewlines)
+            return trimmed.isEmpty ? nil : trimmed
+        case let number as NSNumber:
+            let raw = number.doubleValue
+            guard raw.isFinite else { return nil }
+            return number.stringValue
+        default:
+            return nil
+        }
+    }
+
+    private static func date(from value: Any?) -> Date? {
+        switch value {
+        case let string as String:
+            let trimmed = string.trimmingCharacters(in: .whitespacesAndNewlines)
+            guard !trimmed.isEmpty else { return nil }
+            let fractional = ISO8601DateFormatter()
+            fractional.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+            if let date = fractional.date(from: trimmed) {
+                return date
+            }
+            let plain = ISO8601DateFormatter()
+            plain.formatOptions = [.withInternetDateTime]
+            if let date = plain.date(from: trimmed) {
+                return date
+            }
+            if let interval = Double(trimmed), interval.isFinite {
+                return Self.dateFromNumeric(interval)
+            }
+            return nil
+        case let number as NSNumber:
+            let raw = number.doubleValue
+            return raw.isFinite ? Self.dateFromNumeric(raw) : nil
+        default:
+            return nil
+        }
+    }
+
+    private static func dateFromNumeric(_ value: Double) -> Date? {
+        if value > 10_000_000_000 {
+            return Date(timeIntervalSince1970: value / 1000)
+        }
+        return Date(timeIntervalSince1970: value)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Codebuff/CodebuffUsageSnapshot.swift b/Sources/CodexBarCore/Providers/Codebuff/CodebuffUsageSnapshot.swift
new file mode 100644
index 0000000000..478cc8e1ed
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Codebuff/CodebuffUsageSnapshot.swift
@@ -0,0 +1,147 @@
+import Foundation
+
+/// Parsed view of a Codebuff usage + subscription response pair.
+public struct CodebuffUsageSnapshot: Sendable {
+    public let creditsUsed: Double?
+    public let creditsTotal: Double?
+    public let creditsRemaining: Double?
+    public let weeklyUsed: Double?
+    public let weeklyLimit: Double?
+    public let weeklyResetsAt: Date?
+    public let billingPeriodEnd: Date?
+    public let nextQuotaReset: Date?
+    public let tier: String?
+    public let subscriptionStatus: String?
+    public let autoTopUpEnabled: Bool?
+    public let accountEmail: String?
+    public let updatedAt: Date
+
+    public init(
+        creditsUsed: Double? = nil,
+        creditsTotal: Double? = nil,
+        creditsRemaining: Double? = nil,
+        weeklyUsed: Double? = nil,
+        weeklyLimit: Double? = nil,
+        weeklyResetsAt: Date? = nil,
+        billingPeriodEnd: Date? = nil,
+        nextQuotaReset: Date? = nil,
+        tier: String? = nil,
+        subscriptionStatus: String? = nil,
+        autoTopUpEnabled: Bool? = nil,
+        accountEmail: String? = nil,
+        updatedAt: Date = Date())
+    {
+        self.creditsUsed = creditsUsed
+        self.creditsTotal = creditsTotal
+        self.creditsRemaining = creditsRemaining
+        self.weeklyUsed = weeklyUsed
+        self.weeklyLimit = weeklyLimit
+        self.weeklyResetsAt = weeklyResetsAt
+        self.billingPeriodEnd = billingPeriodEnd
+        self.nextQuotaReset = nextQuotaReset
+        self.tier = tier
+        self.subscriptionStatus = subscriptionStatus
+        self.autoTopUpEnabled = autoTopUpEnabled
+        self.accountEmail = accountEmail
+        self.updatedAt = updatedAt
+    }
+
+    public func toUsageSnapshot() -> UsageSnapshot {
+        let primary = self.makeCreditsWindow()
+        let secondary = self.makeWeeklyWindow()
+
+        let identity = ProviderIdentitySnapshot(
+            providerID: .codebuff,
+            accountEmail: self.accountEmail,
+            accountOrganization: nil,
+            loginMethod: self.makeLoginMethod())
+
+        return UsageSnapshot(
+            primary: primary,
+            secondary: secondary,
+            tertiary: nil,
+            providerCost: nil,
+            updatedAt: self.updatedAt,
+            identity: identity)
+    }
+
+    private func makeCreditsWindow() -> RateWindow? {
+        let total = self.resolvedTotal
+        guard let total, total > 0 else {
+            if self.creditsRemaining != nil || self.creditsUsed != nil {
+                // Degenerate case: no usable quota in the payload. Surface the row as fully
+                // exhausted so missing quota data is visibly surfaced (matches Kilo's behaviour
+                // for zero/unknown totals) rather than rendering a misleading healthy bar.
+                return RateWindow(
+                    usedPercent: 100,
+                    windowMinutes: nil,
+                    resetsAt: self.nextQuotaReset,
+                    resetDescription: nil)
+            }
+            return nil
+        }
+        let used = self.resolvedUsed
+        let percent = min(100, max(0, (used / total) * 100))
+        // Note: do not stuff the credit balance ("X/Y credits") into `resetDescription` —
+        // generic renderers (UsageFormatter.resetLine) prepend "Resets " when `resetsAt`
+        // is absent, which would surface misleading text like "Resets 250/1,000 credits".
+        // The credits detail is shown via the dedicated Codebuff account panel instead.
+        return RateWindow(
+            usedPercent: percent,
+            windowMinutes: nil,
+            resetsAt: self.nextQuotaReset,
+            resetDescription: nil)
+    }
+
+    private func makeWeeklyWindow() -> RateWindow? {
+        guard let limit = self.weeklyLimit, limit > 0 else { return nil }
+        let used = max(0, self.weeklyUsed ?? 0)
+        let percent = min(100, max(0, (used / limit) * 100))
+        // Same reasoning as above: avoid encoding non-reset detail in `resetDescription`.
+        return RateWindow(
+            usedPercent: percent,
+            windowMinutes: 7 * 24 * 60,
+            resetsAt: self.weeklyResetsAt,
+            resetDescription: nil)
+    }
+
+    private var resolvedTotal: Double? {
+        if let creditsTotal { return max(0, creditsTotal) }
+        if let creditsUsed, let creditsRemaining {
+            return max(0, creditsUsed + creditsRemaining)
+        }
+        return nil
+    }
+
+    private var resolvedUsed: Double {
+        if let creditsUsed {
+            return max(0, creditsUsed)
+        }
+        if let total = self.resolvedTotal, let creditsRemaining {
+            return max(0, total - creditsRemaining)
+        }
+        return 0
+    }
+
+    private func makeLoginMethod() -> String? {
+        var parts: [String] = []
+        if let tier = self.tier?.trimmingCharacters(in: .whitespacesAndNewlines), !tier.isEmpty {
+            parts.append(tier.capitalized)
+        }
+        if let remaining = self.creditsRemaining {
+            parts.append("\(Self.compactNumber(remaining)) remaining")
+        }
+        if self.autoTopUpEnabled == true {
+            parts.append("auto top-up")
+        }
+        return parts.isEmpty ? nil : parts.joined(separator: " · ")
+    }
+
+    static func compactNumber(_ value: Double) -> String {
+        let formatter = NumberFormatter()
+        formatter.numberStyle = .decimal
+        formatter.locale = Locale(identifier: "en_US")
+        formatter.maximumFractionDigits = value >= 1000 ? 0 : 1
+        return formatter.string(from: NSNumber(value: value)) ?? String(format: "%.0f", value)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Codex/CodexAccountReconciliation.swift b/Sources/CodexBarCore/Providers/Codex/CodexAccountReconciliation.swift
new file mode 100644
index 0000000000..d157767940
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Codex/CodexAccountReconciliation.swift
@@ -0,0 +1,474 @@
+import Foundation
+
+public struct CodexResolvedActiveSource: Equatable, Sendable {
+    public let persistedSource: CodexActiveSource
+    public let resolvedSource: CodexActiveSource
+
+    public init(persistedSource: CodexActiveSource, resolvedSource: CodexActiveSource) {
+        self.persistedSource = persistedSource
+        self.resolvedSource = resolvedSource
+    }
+
+    public var requiresPersistenceCorrection: Bool {
+        self.persistedSource != self.resolvedSource
+    }
+}
+
+public enum CodexActiveSourceResolver {
+    public static func resolve(from snapshot: CodexAccountReconciliationSnapshot) -> CodexResolvedActiveSource {
+        let persistedSource = snapshot.activeSource
+        let resolvedSource: CodexActiveSource = switch persistedSource {
+        case .liveSystem:
+            .liveSystem
+        case let .managedAccount(id):
+            if let activeStoredAccount = snapshot.activeStoredAccount {
+                self.resolvedSource(for: activeStoredAccount, snapshot: snapshot)
+            } else {
+                snapshot.liveSystemAccount != nil ? .liveSystem : .managedAccount(id: id)
+            }
+        case let .profileHome(path):
+            if let normalizedPath = snapshot.configuredProfileHomePath(path: path) {
+                self.resolvedProfileSource(path: normalizedPath, snapshot: snapshot)
+            } else {
+                .liveSystem
+            }
+        }
+
+        return CodexResolvedActiveSource(
+            persistedSource: persistedSource,
+            resolvedSource: resolvedSource)
+    }
+
+    private static func resolvedProfileSource(
+        path: String,
+        snapshot: CodexAccountReconciliationSnapshot) -> CodexActiveSource
+    {
+        if let livePath = snapshot.liveSystemAccount.flatMap({
+            CodexHomeScope.normalizedHomePath($0.codexHomePath)
+        }), livePath == path {
+            return .liveSystem
+        }
+
+        if let storedAccount = snapshot.storedAccounts.first(where: {
+            CodexHomeScope.normalizedHomePath($0.managedHomePath) == path
+        }) {
+            return self.resolvedSource(for: storedAccount, snapshot: snapshot)
+        }
+
+        return .profileHome(path: path)
+    }
+
+    private static func resolvedSource(
+        for storedAccount: ManagedCodexAccount,
+        snapshot: CodexAccountReconciliationSnapshot) -> CodexActiveSource
+    {
+        self.matchesLiveSystemAccount(
+            storedAccount: storedAccount,
+            snapshot: snapshot,
+            liveSystemAccount: snapshot.liveSystemAccount) ? .liveSystem : .managedAccount(id: storedAccount.id)
+    }
+
+    private static func matchesLiveSystemAccount(
+        storedAccount: ManagedCodexAccount,
+        snapshot: CodexAccountReconciliationSnapshot,
+        liveSystemAccount: ObservedSystemCodexAccount?) -> Bool
+    {
+        guard let liveSystemAccount else { return false }
+        if let storedFingerprint = storedAccount.authFingerprint,
+           let liveFingerprint = liveSystemAccount.authFingerprint,
+           storedFingerprint == liveFingerprint
+        {
+            return true
+        }
+        return CodexIdentityMatcher.matches(
+            snapshot.runtimeIdentity(for: storedAccount),
+            lhsEmail: snapshot.runtimeEmail(for: storedAccount),
+            snapshot.runtimeIdentity(for: liveSystemAccount),
+            rhsEmail: liveSystemAccount.email)
+    }
+}
+
+public struct CodexAccountReconciliationSnapshot: Equatable, Sendable {
+    public let storedAccounts: [ManagedCodexAccount]
+    public let activeStoredAccount: ManagedCodexAccount?
+    public let liveSystemAccount: ObservedSystemCodexAccount?
+    public let profileHomeAccounts: [ObservedSystemCodexAccount]
+    public let profileHomePaths: [String]
+    public let matchingStoredAccountForLiveSystemAccount: ManagedCodexAccount?
+    public let activeSource: CodexActiveSource
+    public let hasUnreadableAddedAccountStore: Bool
+    public let storedAccountRuntimeIdentities: [UUID: CodexIdentity]
+    public let storedAccountRuntimeEmails: [UUID: String]
+
+    public init(
+        storedAccounts: [ManagedCodexAccount],
+        activeStoredAccount: ManagedCodexAccount?,
+        liveSystemAccount: ObservedSystemCodexAccount?,
+        profileHomeAccounts: [ObservedSystemCodexAccount] = [],
+        profileHomePaths: [String]? = nil,
+        matchingStoredAccountForLiveSystemAccount: ManagedCodexAccount?,
+        activeSource: CodexActiveSource,
+        hasUnreadableAddedAccountStore: Bool,
+        storedAccountRuntimeIdentities: [UUID: CodexIdentity] = [:],
+        storedAccountRuntimeEmails: [UUID: String] = [:])
+    {
+        self.storedAccounts = storedAccounts
+        self.activeStoredAccount = activeStoredAccount
+        self.liveSystemAccount = liveSystemAccount
+        self.profileHomeAccounts = Self.uniqueProfileHomeAccounts(profileHomeAccounts)
+        self.profileHomePaths = Self.uniqueNormalizedPaths(
+            profileHomePaths ?? profileHomeAccounts.map(\.codexHomePath))
+        self.matchingStoredAccountForLiveSystemAccount = matchingStoredAccountForLiveSystemAccount
+        self.activeSource = activeSource
+        self.hasUnreadableAddedAccountStore = hasUnreadableAddedAccountStore
+        self.storedAccountRuntimeIdentities = storedAccountRuntimeIdentities
+        self.storedAccountRuntimeEmails = storedAccountRuntimeEmails
+    }
+
+    public static func == (lhs: CodexAccountReconciliationSnapshot, rhs: CodexAccountReconciliationSnapshot) -> Bool {
+        lhs.storedAccounts.map(AccountIdentity.init) == rhs.storedAccounts.map(AccountIdentity.init)
+            && lhs.activeStoredAccount.map(AccountIdentity.init) == rhs.activeStoredAccount.map(AccountIdentity.init)
+            && lhs.liveSystemAccount == rhs.liveSystemAccount
+            && lhs.profileHomeAccounts == rhs.profileHomeAccounts
+            && lhs.profileHomePaths == rhs.profileHomePaths
+            && lhs.matchingStoredAccountForLiveSystemAccount.map(AccountIdentity.init)
+            == rhs.matchingStoredAccountForLiveSystemAccount.map(AccountIdentity.init)
+            && lhs.activeSource == rhs.activeSource
+            && lhs.hasUnreadableAddedAccountStore == rhs.hasUnreadableAddedAccountStore
+            && lhs.storedAccountRuntimeIdentities == rhs.storedAccountRuntimeIdentities
+            && lhs.storedAccountRuntimeEmails == rhs.storedAccountRuntimeEmails
+    }
+
+    public func runtimeIdentity(for storedAccount: ManagedCodexAccount) -> CodexIdentity {
+        self.storedAccountRuntimeIdentities[storedAccount.id]
+            ?? CodexIdentityResolver.resolve(accountId: nil, email: storedAccount.email)
+    }
+
+    public func runtimeEmail(for storedAccount: ManagedCodexAccount) -> String {
+        self.storedAccountRuntimeEmails[storedAccount.id]
+            ?? Self.normalizeEmail(storedAccount.email)
+    }
+
+    public func runtimeIdentity(for liveSystemAccount: ObservedSystemCodexAccount) -> CodexIdentity {
+        CodexIdentityMatcher.normalized(
+            liveSystemAccount.identity,
+            fallbackEmail: liveSystemAccount.email)
+    }
+
+    public func profileHomeAccount(path: String) -> ObservedSystemCodexAccount? {
+        guard let normalizedPath = CodexHomeScope.normalizedHomePath(path) else { return nil }
+        return self.profileHomeAccounts.first {
+            CodexHomeScope.normalizedHomePath($0.codexHomePath) == normalizedPath
+        }
+    }
+
+    public func configuredProfileHomePath(path: String) -> String? {
+        guard let normalizedPath = CodexHomeScope.normalizedHomePath(path),
+              self.profileHomePaths.contains(normalizedPath)
+        else {
+            return nil
+        }
+        return normalizedPath
+    }
+
+    private static func normalizeEmail(_ email: String) -> String {
+        email.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+    }
+
+    private static func uniqueProfileHomeAccounts(
+        _ accounts: [ObservedSystemCodexAccount]) -> [ObservedSystemCodexAccount]
+    {
+        var seenPaths: Set<String> = []
+        var result: [ObservedSystemCodexAccount] = []
+        for account in accounts {
+            let path = CodexHomeScope.normalizedHomePath(account.codexHomePath) ?? account.codexHomePath
+            guard seenPaths.insert(path).inserted else { continue }
+            result.append(account)
+        }
+        return result
+    }
+
+    private static func uniqueNormalizedPaths(_ paths: [String]) -> [String] {
+        var seen: Set<String> = []
+        return paths.compactMap { path in
+            guard let normalizedPath = CodexHomeScope.normalizedHomePath(path),
+                  seen.insert(normalizedPath).inserted
+            else {
+                return nil
+            }
+            return normalizedPath
+        }
+    }
+}
+
+public struct DefaultCodexAccountReconciler: Sendable {
+    public let storeLoader: @Sendable () throws -> ManagedCodexAccountSet
+    public let systemObserver: any CodexSystemAccountObserving
+    public let activeSource: CodexActiveSource
+    public let baseEnvironment: [String: String]
+    public let profileHomePaths: [String]
+    public let managedEnvironmentBuilder: @Sendable ([String: String], ManagedCodexAccount) -> [String: String]
+
+    public init(
+        storeLoader: @escaping @Sendable () throws -> ManagedCodexAccountSet = {
+            try FileManagedCodexAccountStore().loadAccounts()
+        },
+        systemObserver: any CodexSystemAccountObserving = DefaultCodexSystemAccountObserver(),
+        activeSource: CodexActiveSource = .liveSystem,
+        baseEnvironment: [String: String],
+        profileHomePaths: [String] = [],
+        managedEnvironmentBuilder: @escaping @Sendable ([String: String], ManagedCodexAccount)
+            -> [String: String] = { baseEnvironment, account in
+                CodexHomeScope.scopedEnvironment(base: baseEnvironment, codexHome: account.managedHomePath)
+            })
+    {
+        self.storeLoader = storeLoader
+        self.systemObserver = systemObserver
+        self.activeSource = activeSource
+        self.baseEnvironment = baseEnvironment
+        self.profileHomePaths = Self.uniqueNormalizedPaths(profileHomePaths)
+        self.managedEnvironmentBuilder = managedEnvironmentBuilder
+    }
+
+    public func loadSnapshot() -> CodexAccountReconciliationSnapshot {
+        let liveSystemAccount = self.loadLiveSystemAccount()
+        let profileHomeAccounts = self.loadProfileHomeAccounts(liveSystemAccount: liveSystemAccount)
+
+        do {
+            let accounts = try self.storeLoader()
+            let runtimeAccounts = Dictionary(uniqueKeysWithValues: accounts.accounts.map { account in
+                let runtimeAccount = self.loadRuntimeAccount(for: account)
+                return (account.id, runtimeAccount)
+            })
+            let activeStoredAccount: ManagedCodexAccount? = switch self.activeSource {
+            case let .managedAccount(id):
+                accounts.account(id: id)
+            case .liveSystem, .profileHome:
+                nil
+            }
+            let matchingStoredAccountForLiveSystemAccount = liveSystemAccount.flatMap { liveAccount in
+                if let liveFingerprint = liveAccount.authFingerprint,
+                   let exactFingerprintMatch = accounts.accounts.first(where: {
+                       $0.authFingerprint == liveFingerprint
+                   })
+                {
+                    return exactFingerprintMatch
+                }
+                return accounts.accounts.first { account in
+                    guard let runtimeAccount = runtimeAccounts[account.id] else { return false }
+                    return CodexIdentityMatcher.matches(
+                        runtimeAccount.identity,
+                        lhsEmail: runtimeAccount.email,
+                        self.runtimeIdentity(for: liveAccount),
+                        rhsEmail: liveAccount.email)
+                }
+            }
+
+            return CodexAccountReconciliationSnapshot(
+                storedAccounts: accounts.accounts,
+                activeStoredAccount: activeStoredAccount,
+                liveSystemAccount: liveSystemAccount,
+                profileHomeAccounts: self.profileHomeAccounts(
+                    profileHomeAccounts,
+                    excludingManagedAccounts: accounts.accounts),
+                profileHomePaths: self.profileHomePaths,
+                matchingStoredAccountForLiveSystemAccount: matchingStoredAccountForLiveSystemAccount,
+                activeSource: self.activeSource,
+                hasUnreadableAddedAccountStore: false,
+                storedAccountRuntimeIdentities: runtimeAccounts.mapValues(\.identity),
+                storedAccountRuntimeEmails: runtimeAccounts.mapValues(\.email))
+        } catch {
+            return CodexAccountReconciliationSnapshot(
+                storedAccounts: [],
+                activeStoredAccount: nil,
+                liveSystemAccount: liveSystemAccount,
+                profileHomeAccounts: profileHomeAccounts,
+                profileHomePaths: self.profileHomePaths,
+                matchingStoredAccountForLiveSystemAccount: nil,
+                activeSource: self.activeSource,
+                hasUnreadableAddedAccountStore: true)
+        }
+    }
+
+    private func loadProfileHomeAccounts(
+        liveSystemAccount: ObservedSystemCodexAccount?) -> [ObservedSystemCodexAccount]
+    {
+        let livePath = liveSystemAccount.flatMap { CodexHomeScope.normalizedHomePath($0.codexHomePath) }
+        return self.profileHomePaths.compactMap { path in
+            guard path != livePath else { return nil }
+            return self.loadProfileHomeAccount(homePath: path)
+        }
+    }
+
+    private func loadProfileHomeAccount(homePath: String) -> ObservedSystemCodexAccount? {
+        let environment = CodexHomeScope.scopedEnvironment(base: self.baseEnvironment, codexHome: homePath)
+        let account = UsageFetcher(environment: environment).loadAuthBackedCodexAccount()
+
+        guard let rawEmail = account.email?.trimmingCharacters(in: .whitespacesAndNewlines),
+              !rawEmail.isEmpty
+        else {
+            return nil
+        }
+
+        let providerAccountID: String? = switch account.identity {
+        case let .providerAccount(id):
+            ManagedCodexAccount.normalizeProviderAccountID(id)
+        case .emailOnly, .unresolved:
+            nil
+        }
+
+        return ObservedSystemCodexAccount(
+            email: rawEmail.lowercased(),
+            workspaceAccountID: providerAccountID,
+            authFingerprint: CodexAuthFingerprint.fingerprint(homePath: homePath),
+            codexHomePath: homePath,
+            observedAt: Date(),
+            identity: account.identity)
+    }
+
+    private func loadLiveSystemAccount() -> ObservedSystemCodexAccount? {
+        do {
+            guard let account = try self.systemObserver.loadSystemAccount(environment: self.baseEnvironment) else {
+                return nil
+            }
+            let normalizedEmail = Self.normalizeEmail(account.email)
+            guard !normalizedEmail.isEmpty else {
+                return nil
+            }
+            return ObservedSystemCodexAccount(
+                email: normalizedEmail,
+                workspaceLabel: account.workspaceLabel,
+                workspaceAccountID: account.workspaceAccountID,
+                authFingerprint: account.authFingerprint,
+                codexHomePath: account.codexHomePath,
+                observedAt: account.observedAt,
+                identity: self.runtimeIdentity(for: account))
+        } catch {
+            return nil
+        }
+    }
+
+    private static func normalizeEmail(_ email: String) -> String {
+        email.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+    }
+
+    private func loadRuntimeAccount(for account: ManagedCodexAccount) -> RuntimeManagedCodexAccount {
+        let scopedEnvironment = self.managedEnvironmentBuilder(self.baseEnvironment, account)
+        let authBackedAccount = UsageFetcher(environment: scopedEnvironment).loadAuthBackedCodexAccount()
+        let email = Self.normalizeEmail(authBackedAccount.email ?? account.email)
+        let identity = CodexIdentityMatcher.normalized(authBackedAccount.identity, fallbackEmail: email)
+
+        return RuntimeManagedCodexAccount(
+            email: email,
+            identity: identity)
+    }
+
+    private func profileHomeAccounts(
+        _ profileHomeAccounts: [ObservedSystemCodexAccount],
+        excludingManagedAccounts managedAccounts: [ManagedCodexAccount]) -> [ObservedSystemCodexAccount]
+    {
+        let managedPaths = Set(managedAccounts.compactMap { CodexHomeScope.normalizedHomePath($0.managedHomePath) })
+        return profileHomeAccounts.filter { account in
+            guard let path = CodexHomeScope.normalizedHomePath(account.codexHomePath) else { return false }
+            return !managedPaths.contains(path)
+        }
+    }
+
+    private func runtimeIdentity(for liveSystemAccount: ObservedSystemCodexAccount) -> CodexIdentity {
+        CodexIdentityMatcher.normalized(
+            liveSystemAccount.identity,
+            fallbackEmail: liveSystemAccount.email)
+    }
+
+    private static func uniqueNormalizedPaths(_ paths: [String]) -> [String] {
+        var seen: Set<String> = []
+        var result: [String] = []
+        for path in paths.compactMap({ CodexHomeScope.normalizedHomePath($0) }) {
+            guard seen.insert(path).inserted else { continue }
+            result.append(path)
+        }
+        return result
+    }
+}
+
+public enum CodexIdentityMatcher {
+    public static func matches(_ lhs: CodexIdentity, _ rhs: CodexIdentity) -> Bool {
+        switch (lhs, rhs) {
+        case let (.providerAccount(leftID), .providerAccount(rightID)):
+            leftID == rightID
+        case let (.emailOnly(leftEmail), .emailOnly(rightEmail)):
+            leftEmail == rightEmail
+        default:
+            false
+        }
+    }
+
+    public static func matches(
+        _ lhs: CodexIdentity,
+        lhsEmail: String?,
+        _ rhs: CodexIdentity,
+        rhsEmail: String?) -> Bool
+    {
+        guard self.matches(lhs, rhs) else { return false }
+        guard case .providerAccount = lhs, case .providerAccount = rhs else { return true }
+        guard let normalizedLeftEmail = CodexIdentityResolver.normalizeEmail(lhsEmail),
+              let normalizedRightEmail = CodexIdentityResolver.normalizeEmail(rhsEmail)
+        else {
+            return true
+        }
+        return normalizedLeftEmail == normalizedRightEmail
+    }
+
+    public static func normalized(_ identity: CodexIdentity, fallbackEmail: String) -> CodexIdentity {
+        switch identity {
+        case .providerAccount:
+            identity
+        case let .emailOnly(normalizedEmail):
+            CodexIdentityResolver.resolve(accountId: nil, email: normalizedEmail)
+        case .unresolved:
+            CodexIdentityResolver.resolve(accountId: nil, email: fallbackEmail)
+        }
+    }
+
+    public static func selectionKey(for identity: CodexIdentity, fallbackEmail: String) -> String {
+        switch self.normalized(identity, fallbackEmail: fallbackEmail) {
+        case let .providerAccount(id):
+            "provider:\(id)"
+        case let .emailOnly(normalizedEmail):
+            "email:\(normalizedEmail)"
+        case .unresolved:
+            "unresolved:\(fallbackEmail)"
+        }
+    }
+}
+
+private struct RuntimeManagedCodexAccount {
+    let email: String
+    let identity: CodexIdentity
+}
+
+private struct AccountIdentity: Equatable {
+    let id: UUID
+    let email: String
+    let providerAccountID: String?
+    let workspaceLabel: String?
+    let workspaceAccountID: String?
+    let managedHomePath: String
+    let createdAt: TimeInterval
+    let updatedAt: TimeInterval
+    let lastAuthenticatedAt: TimeInterval?
+    let authFingerprint: String?
+
+    init(_ account: ManagedCodexAccount) {
+        self.id = account.id
+        self.email = account.email
+        self.providerAccountID = account.providerAccountID
+        self.workspaceLabel = account.workspaceLabel
+        self.workspaceAccountID = account.workspaceAccountID
+        self.managedHomePath = account.managedHomePath
+        self.createdAt = account.createdAt
+        self.updatedAt = account.updatedAt
+        self.lastAuthenticatedAt = account.lastAuthenticatedAt
+        self.authFingerprint = account.authFingerprint
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Codex/CodexAdditionalRateLimitMapper.swift b/Sources/CodexBarCore/Providers/Codex/CodexAdditionalRateLimitMapper.swift
new file mode 100644
index 0000000000..6a0997de20
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Codex/CodexAdditionalRateLimitMapper.swift
@@ -0,0 +1,153 @@
+import Foundation
+
+/// Maps Codex `additional_rate_limits` entries (model-specific limits such as GPT-5.3-Codex-Spark)
+/// into named extra rate windows.
+///
+/// These limits are reported by the `wham/usage` API alongside, but separately from, the primary and
+/// weekly Codex windows, so we surface them through `UsageSnapshot.extraRateWindows` rather than the core
+/// primary/secondary lanes. When the field is absent the mapper returns an empty list and the snapshot is
+/// unchanged.
+enum CodexAdditionalRateLimitMapper {
+    /// Stable ids/titles for GPT-5.3-Codex-Spark limits so SwiftUI identity stays constant even if the API
+    /// label wording shifts. Keep the original 5-hour id for compatibility with the first Spark implementation.
+    static let sparkWindowID = "codex-spark"
+    static let sparkWeeklyWindowID = "codex-spark-weekly"
+    static let sparkWindowTitle = "Codex Spark 5-hour"
+    static let sparkWeeklyWindowTitle = "Codex Spark Weekly"
+
+    static func extraRateWindows(
+        from additionalRateLimits: [CodexUsageResponse.AdditionalRateLimit]?,
+        now: Date = Date()) -> [NamedRateWindow]
+    {
+        guard let additionalRateLimits, !additionalRateLimits.isEmpty else { return [] }
+        var usedIDs = Set<String>()
+        return additionalRateLimits.flatMap { entry in
+            self.namedWindows(from: entry, usedIDs: &usedIDs, now: now)
+        }
+    }
+
+    private static func namedWindows(
+        from entry: CodexUsageResponse.AdditionalRateLimit,
+        usedIDs: inout Set<String>,
+        now: Date) -> [NamedRateWindow]
+    {
+        if self.isSpark(entry) {
+            return self.sparkWindows(from: entry, usedIDs: &usedIDs, now: now)
+        }
+
+        // Model-specific limits report utilization in the primary window; fall back to the secondary
+        // window only when a primary one is not present.
+        guard let snapshot = entry.rateLimit?.primaryWindow ?? entry.rateLimit?.secondaryWindow else {
+            return []
+        }
+        guard let id = self.windowID(for: entry), usedIDs.insert(id).inserted else { return [] }
+        return [self.namedWindow(
+            id: id,
+            title: self.windowTitle(for: entry),
+            snapshot: snapshot,
+            now: now)]
+    }
+
+    private static func sparkWindows(
+        from entry: CodexUsageResponse.AdditionalRateLimit,
+        usedIDs: inout Set<String>,
+        now: Date) -> [NamedRateWindow]
+    {
+        let candidates: [(CodexUsageResponse.WindowSnapshot?, SparkWindowKind)] = [
+            (entry.rateLimit?.primaryWindow, .fiveHour),
+            (entry.rateLimit?.secondaryWindow, .weekly),
+        ]
+
+        return candidates.compactMap { snapshot, fallbackKind in
+            guard let snapshot else { return nil }
+            let kind = self.sparkWindowKind(for: snapshot, fallback: fallbackKind)
+            guard usedIDs.insert(kind.id).inserted else { return nil }
+            return self.namedWindow(id: kind.id, title: kind.title, snapshot: snapshot, now: now)
+        }
+    }
+
+    private static func namedWindow(
+        id: String,
+        title: String,
+        snapshot: CodexUsageResponse.WindowSnapshot,
+        now: Date) -> NamedRateWindow
+    {
+        let resetDate: Date? = snapshot.resetAt > 0
+            ? Date(timeIntervalSince1970: TimeInterval(snapshot.resetAt))
+            : nil
+        let window = RateWindow(
+            usedPercent: Double(snapshot.usedPercent),
+            windowMinutes: snapshot.limitWindowSeconds > 0 ? snapshot.limitWindowSeconds / 60 : nil,
+            resetsAt: resetDate,
+            resetDescription: resetDate.map { UsageFormatter.resetDescription(from: $0, now: now) })
+        return NamedRateWindow(id: id, title: title, window: window)
+    }
+
+    private enum SparkWindowKind {
+        case fiveHour
+        case weekly
+
+        var id: String {
+            switch self {
+            case .fiveHour: CodexAdditionalRateLimitMapper.sparkWindowID
+            case .weekly: CodexAdditionalRateLimitMapper.sparkWeeklyWindowID
+            }
+        }
+
+        var title: String {
+            switch self {
+            case .fiveHour: CodexAdditionalRateLimitMapper.sparkWindowTitle
+            case .weekly: CodexAdditionalRateLimitMapper.sparkWeeklyWindowTitle
+            }
+        }
+    }
+
+    private static func sparkWindowKind(
+        for snapshot: CodexUsageResponse.WindowSnapshot,
+        fallback: SparkWindowKind) -> SparkWindowKind
+    {
+        let minutes = snapshot.limitWindowSeconds > 0 ? snapshot.limitWindowSeconds / 60 : 0
+        if minutes > 0, minutes <= 6 * 60 { return .fiveHour }
+        if minutes >= 6 * 24 * 60 { return .weekly }
+        return fallback
+    }
+
+    private static func windowID(for entry: CodexUsageResponse.AdditionalRateLimit) -> String? {
+        guard let source = self.firstNonEmpty(entry.meteredFeature, entry.limitName) else { return nil }
+        let slug = self.slug(source)
+        return slug.isEmpty ? nil : "codex-\(slug)"
+    }
+
+    private static func windowTitle(for entry: CodexUsageResponse.AdditionalRateLimit) -> String {
+        self.firstNonEmpty(entry.limitName, entry.meteredFeature) ?? "Codex extra limit"
+    }
+
+    private static func isSpark(_ entry: CodexUsageResponse.AdditionalRateLimit) -> Bool {
+        [entry.limitName, entry.meteredFeature]
+            .compactMap { $0?.lowercased() }
+            .contains { $0.contains("spark") }
+    }
+
+    private static func firstNonEmpty(_ values: String?...) -> String? {
+        for value in values {
+            let trimmed = value?.trimmingCharacters(in: .whitespacesAndNewlines)
+            if let trimmed, !trimmed.isEmpty { return trimmed }
+        }
+        return nil
+    }
+
+    private static func slug(_ value: String) -> String {
+        var result = ""
+        var lastWasDash = false
+        for scalar in value.lowercased().unicodeScalars {
+            if CharacterSet.alphanumerics.contains(scalar) {
+                result.unicodeScalars.append(scalar)
+                lastWasDash = false
+            } else if !lastWasDash {
+                result.append("-")
+                lastWasDash = true
+            }
+        }
+        return result.trimmingCharacters(in: CharacterSet(charactersIn: "-"))
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Codex/CodexCLIDashboardAuthorityContext.swift b/Sources/CodexBarCore/Providers/Codex/CodexCLIDashboardAuthorityContext.swift
new file mode 100644
index 0000000000..ce348063bd
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Codex/CodexCLIDashboardAuthorityContext.swift
@@ -0,0 +1,62 @@
+import Foundation
+
+public enum CodexCLIDashboardAuthorityContext {
+    public static func makeLiveWebInput(
+        dashboard: OpenAIDashboardSnapshot,
+        context: ProviderFetchContext,
+        routingTargetEmail: String?) -> CodexDashboardAuthorityInput
+    {
+        let auth = context.fetcher.loadAuthBackedCodexAccount()
+        return CodexDashboardAuthorityInput(
+            sourceKind: .liveWeb,
+            proof: CodexDashboardOwnershipProofContext(
+                currentIdentity: auth.identity,
+                expectedScopedEmail: auth.email,
+                trustedCurrentUsageEmail: nil,
+                dashboardSignedInEmail: dashboard.signedInEmail,
+                knownOwners: context.settings?.codex?.dashboardAuthorityKnownOwners ?? []),
+            routing: CodexDashboardRoutingHints(
+                targetEmail: CodexIdentityResolver.normalizeEmail(routingTargetEmail),
+                lastKnownDashboardRoutingEmail: nil))
+    }
+
+    public static func makeCachedDashboardInput(
+        dashboard: OpenAIDashboardSnapshot,
+        cachedAccountEmail: String,
+        usage: UsageSnapshot,
+        sourceLabel: String,
+        context: ProviderFetchContext) -> CodexDashboardAuthorityInput
+    {
+        let auth = context.fetcher.loadAuthBackedCodexAccount()
+        let trustedCurrentUsageEmail = Self.shouldTrustUsageEmail(sourceLabel: sourceLabel)
+            ? usage.accountEmail(for: .codex)
+            : nil
+        return CodexDashboardAuthorityInput(
+            sourceKind: .cachedDashboard,
+            proof: CodexDashboardOwnershipProofContext(
+                currentIdentity: auth.identity,
+                expectedScopedEmail: auth.email,
+                trustedCurrentUsageEmail: trustedCurrentUsageEmail,
+                dashboardSignedInEmail: dashboard.signedInEmail,
+                knownOwners: context.settings?.codex?.dashboardAuthorityKnownOwners ?? []),
+            routing: CodexDashboardRoutingHints(
+                targetEmail: auth.email,
+                lastKnownDashboardRoutingEmail: cachedAccountEmail))
+    }
+
+    public static func attachmentEmail(from input: CodexDashboardAuthorityInput) -> String? {
+        CodexIdentityResolver.normalizeEmail(
+            input.proof.expectedScopedEmail ??
+                input.proof.trustedCurrentUsageEmail ??
+                input.proof.dashboardSignedInEmail)
+    }
+
+    public static func shouldTrustUsageEmail(sourceLabel: String) -> Bool {
+        switch sourceLabel.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() {
+        case "codex-cli", "oauth":
+            true
+        default:
+            false
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Codex/CodexCLILaunchGate.swift b/Sources/CodexBarCore/Providers/Codex/CodexCLILaunchGate.swift
new file mode 100644
index 0000000000..78ffa8a7b7
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Codex/CodexCLILaunchGate.swift
@@ -0,0 +1,70 @@
+import Foundation
+
+final class CodexCLILaunchGate: @unchecked Sendable {
+    static let shared = CodexCLILaunchGate()
+    static let cooldown: TimeInterval = 30 * 60
+
+    private struct Entry {
+        let message: String
+        let expiresAt: Date
+    }
+
+    private let lock = NSLock()
+    private var entries: [String: Entry] = [:]
+
+    func backgroundSkipMessage(
+        binary: String,
+        now: Date = Date(),
+        interaction: ProviderInteraction = ProviderInteractionContext.current) -> String?
+    {
+        guard interaction == .background else { return nil }
+
+        self.lock.lock()
+        defer { self.lock.unlock() }
+
+        guard let entry = self.entries[binary] else { return nil }
+        guard entry.expiresAt > now else {
+            self.entries.removeValue(forKey: binary)
+            return nil
+        }
+        return entry.message
+    }
+
+    @discardableResult
+    func recordLaunchFailure(binary: String, message: String, now: Date = Date()) -> String? {
+        guard Self.shouldThrottleLaunchFailure(message) else { return nil }
+        let throttled = Self.throttledMessage(binary: binary, originalMessage: message)
+        let entry = Entry(
+            message: throttled,
+            expiresAt: now.addingTimeInterval(Self.cooldown))
+
+        self.lock.lock()
+        self.entries[binary] = entry
+        self.lock.unlock()
+
+        return throttled
+    }
+
+    func resetForTesting() {
+        self.lock.lock()
+        self.entries.removeAll()
+        self.lock.unlock()
+    }
+
+    static func shouldThrottleLaunchFailure(_ message: String) -> Bool {
+        let lower = message.lowercased()
+        if lower.contains("openpty") ||
+            lower.contains("write to pty") ||
+            lower.contains("app shutdown")
+        {
+            return false
+        }
+        return true
+    }
+
+    private static func throttledMessage(binary: String, originalMessage: String) -> String {
+        "Codex CLI launch failed; background refresh is paused for 30 minutes. " +
+            "Reinstall or unblock `\(binary)` in macOS security settings, then refresh manually. " +
+            "Last error: \(originalMessage)"
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Codex/CodexCLISession.swift b/Sources/CodexBarCore/Providers/Codex/CodexCLISession.swift
index 8c7f3b2457..2c88db3762 100644
--- a/Sources/CodexBarCore/Providers/Codex/CodexCLISession.swift
+++ b/Sources/CodexBarCore/Providers/Codex/CodexCLISession.swift
@@ -1,7 +1,9 @@
 #if canImport(Darwin)
 import Darwin
-#else
+#elseif canImport(Glibc)
 import Glibc
+#elseif canImport(Musl)
+import Musl
 #endif
 import Foundation
 
@@ -31,6 +33,18 @@ actor CodexCLISession {
     private var startedAt: Date?
     private var ptyRows: UInt16 = 0
     private var ptyCols: UInt16 = 0
+    private var sessionEnvironment: [String: String]?
+    private var sessionArguments: [String] = []
+    private var sessionWorkingDirectory: URL?
+
+    struct CaptureOptions {
+        let timeout: TimeInterval
+        let rows: UInt16
+        let cols: UInt16
+        let environment: [String: String]
+        let extraArgs: [String]
+        let workingDirectory: URL?
+    }
 
     private struct RollingBuffer {
         private let maxNeedle: Int
@@ -81,8 +95,11 @@ actor CodexCLISession {
     }
 
     // swiftlint:disable cyclomatic_complexity
-    func captureStatus(binary: String, timeout: TimeInterval, rows: UInt16, cols: UInt16) async throws -> String {
-        try self.ensureStarted(binary: binary, rows: rows, cols: cols)
+    func captureStatus(
+        binary: String,
+        options: CaptureOptions) async throws -> String
+    {
+        try self.ensureStarted(binary: binary, options: options)
         if let startedAt {
             let sinceStart = Date().timeIntervalSince(startedAt)
             if sinceStart < 0.4 {
@@ -110,7 +127,7 @@ actor CodexCLISession {
         var updateScanBuffer = RollingBuffer(maxNeedle: updateMaxNeedle)
 
         var buffer = Data()
-        let deadline = Date().addingTimeInterval(timeout)
+        let deadline = Date().addingTimeInterval(options.timeout)
         var nextCursorCheckAt = Date(timeIntervalSince1970: 0)
 
         var skippedCodexUpdate = false
@@ -243,12 +260,18 @@ actor CodexCLISession {
         self.cleanup()
     }
 
-    private func ensureStarted(binary: String, rows: UInt16, cols: UInt16) throws {
+    private func ensureStarted(
+        binary: String,
+        options: CaptureOptions) throws
+    {
         if let proc = self.process,
            proc.isRunning,
            self.binaryPath == binary,
-           self.ptyRows == rows,
-           self.ptyCols == cols
+           self.ptyRows == options.rows,
+           self.ptyCols == options.cols,
+           self.sessionEnvironment == options.environment,
+           self.sessionArguments == options.extraArgs,
+           self.sessionWorkingDirectory == options.workingDirectory
         {
             return
         }
@@ -256,7 +279,7 @@ actor CodexCLISession {
 
         var primaryFD: Int32 = -1
         var secondaryFD: Int32 = -1
-        var win = winsize(ws_row: rows, ws_col: cols, ws_xpixel: 0, ws_ypixel: 0)
+        var win = winsize(ws_row: options.rows, ws_col: options.cols, ws_xpixel: 0, ws_ypixel: 0)
         guard openpty(&primaryFD, &secondaryFD, nil, nil, &win) == 0 else {
             throw SessionError.launchFailed("openpty failed")
         }
@@ -268,14 +291,24 @@ actor CodexCLISession {
         let proc = Process()
         let resolvedURL = URL(fileURLWithPath: binary)
         proc.executableURL = resolvedURL
-        proc.arguments = ["-s", "read-only", "-a", "untrusted"]
+        proc.arguments = options.extraArgs
         proc.standardInput = secondaryHandle
         proc.standardOutput = secondaryHandle
         proc.standardError = secondaryHandle
+        proc.currentDirectoryURL = options.workingDirectory
 
-        let env = TTYCommandRunner.enrichedEnvironment()
+        let env = TTYCommandRunner.enrichedEnvironment(
+            baseEnv: options.environment,
+            home: options.environment["HOME"] ?? NSHomeDirectory())
         proc.environment = env
 
+        guard TTYCommandRunner.beginActiveProcessLaunchForAppShutdown() else {
+            try? primaryHandle.close()
+            try? secondaryHandle.close()
+            throw SessionError.launchFailed("App shutdown in progress")
+        }
+        defer { TTYCommandRunner.endActiveProcessLaunchForAppShutdown() }
+
         do {
             try proc.run()
         } catch {
@@ -285,9 +318,21 @@ actor CodexCLISession {
         }
 
         let pid = proc.processIdentifier
+        guard TTYCommandRunner.registerActiveProcessForAppShutdown(
+            pid: pid,
+            binary: resolvedURL.lastPathComponent)
+        else {
+            proc.terminate()
+            kill(pid, SIGKILL)
+            try? primaryHandle.close()
+            try? secondaryHandle.close()
+            throw SessionError.launchFailed("App shutdown in progress")
+        }
+
         var processGroup: pid_t?
         if setpgid(pid, pid) == 0 {
             processGroup = pid
+            TTYCommandRunner.updateActiveProcessGroupForAppShutdown(pid: pid, processGroup: processGroup)
         }
 
         self.process = proc
@@ -297,8 +342,11 @@ actor CodexCLISession {
         self.processGroup = processGroup
         self.binaryPath = binary
         self.startedAt = Date()
-        self.ptyRows = rows
-        self.ptyCols = cols
+        self.ptyRows = options.rows
+        self.ptyCols = options.cols
+        self.sessionEnvironment = options.environment
+        self.sessionArguments = options.extraArgs
+        self.sessionWorkingDirectory = options.workingDirectory
     }
 
     private func cleanup() {
@@ -308,11 +356,16 @@ actor CodexCLISession {
         try? self.primaryHandle?.close()
         try? self.secondaryHandle?.close()
 
+        let descendants = self.process.map { TTYProcessTreeTerminator.descendantPIDs(of: $0.processIdentifier) } ?? []
         if let proc = self.process, proc.isRunning {
             proc.terminate()
         }
-        if let pgid = self.processGroup {
-            kill(-pgid, SIGTERM)
+        if let proc = self.process {
+            TTYProcessTreeTerminator.terminateProcessTree(
+                rootPID: proc.processIdentifier,
+                processGroup: self.processGroup,
+                signal: SIGTERM,
+                knownDescendants: descendants)
         }
         let waitDeadline = Date().addingTimeInterval(1.0)
         if let proc = self.process {
@@ -320,11 +373,17 @@ actor CodexCLISession {
                 usleep(100_000)
             }
             if proc.isRunning {
-                if let pgid = self.processGroup {
-                    kill(-pgid, SIGKILL)
+                TTYProcessTreeTerminator.terminateProcessTree(
+                    rootPID: proc.processIdentifier,
+                    processGroup: self.processGroup,
+                    signal: SIGKILL,
+                    knownDescendants: descendants)
+            } else {
+                for pid in descendants where pid > 0 {
+                    kill(pid, SIGKILL)
                 }
-                kill(proc.processIdentifier, SIGKILL)
             }
+            TTYCommandRunner.unregisterActiveProcessForAppShutdown(pid: proc.processIdentifier)
         }
 
         self.process = nil
@@ -336,6 +395,9 @@ actor CodexCLISession {
         self.startedAt = nil
         self.ptyRows = 0
         self.ptyCols = 0
+        self.sessionEnvironment = nil
+        self.sessionArguments = []
+        self.sessionWorkingDirectory = nil
     }
 
     private func readChunk() -> Data {
diff --git a/Sources/CodexBarCore/Providers/Codex/CodexDashboardAuthority.swift b/Sources/CodexBarCore/Providers/Codex/CodexDashboardAuthority.swift
new file mode 100644
index 0000000000..8d40ccc5ae
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Codex/CodexDashboardAuthority.swift
@@ -0,0 +1,332 @@
+import Foundation
+
+public enum CodexDashboardSourceKind: String, Codable, Sendable {
+    case liveWeb
+    case cachedDashboard
+}
+
+public enum CodexDashboardDisposition: String, Codable, Sendable {
+    case attach
+    case displayOnly
+    case failClosed
+}
+
+public enum CodexDashboardAllowedEffect: String, Codable, CaseIterable, Hashable, Sendable {
+    case usageBackfill
+    case creditsAttachment
+    case refreshGuardSeed
+    case historicalBackfill
+    case cachedDashboardReuse
+}
+
+public enum CodexDashboardCleanup: String, Codable, CaseIterable, Hashable, Sendable {
+    case dashboardSnapshot
+    case dashboardDerivedUsage
+    case dashboardDerivedCredits
+    case dashboardRefreshGuardSeed
+    case dashboardCache
+}
+
+public struct CodexDashboardKnownOwnerCandidate: Equatable, Hashable, Sendable {
+    public let identity: CodexIdentity
+    public let normalizedEmail: String?
+    public let sourceIsolationIdentifier: String?
+
+    public init(
+        identity: CodexIdentity,
+        normalizedEmail: String?,
+        sourceIsolationIdentifier: String? = nil)
+    {
+        self.identity = identity
+        self.normalizedEmail = normalizedEmail
+        self.sourceIsolationIdentifier = sourceIsolationIdentifier
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        switch self.identity {
+        case let .providerAccount(id):
+            hasher.combine("providerAccount")
+            hasher.combine(id)
+        case let .emailOnly(normalizedEmail):
+            hasher.combine("emailOnly")
+            hasher.combine(normalizedEmail)
+        case .unresolved:
+            hasher.combine("unresolved")
+        }
+        hasher.combine(self.normalizedEmail)
+        hasher.combine(self.sourceIsolationIdentifier)
+    }
+}
+
+public struct CodexDashboardOwnershipProofContext: Equatable, Sendable {
+    public let currentIdentity: CodexIdentity
+    public let expectedScopedEmail: String?
+    public let trustedCurrentUsageEmail: String?
+    public let dashboardSignedInEmail: String?
+    public let knownOwners: [CodexDashboardKnownOwnerCandidate]
+
+    public init(
+        currentIdentity: CodexIdentity,
+        expectedScopedEmail: String?,
+        trustedCurrentUsageEmail: String?,
+        dashboardSignedInEmail: String?,
+        knownOwners: [CodexDashboardKnownOwnerCandidate])
+    {
+        self.currentIdentity = currentIdentity
+        self.expectedScopedEmail = expectedScopedEmail
+        self.trustedCurrentUsageEmail = trustedCurrentUsageEmail
+        self.dashboardSignedInEmail = dashboardSignedInEmail
+        self.knownOwners = knownOwners
+    }
+}
+
+public struct CodexDashboardRoutingHints: Equatable, Sendable {
+    public let targetEmail: String?
+    public let lastKnownDashboardRoutingEmail: String?
+
+    public init(targetEmail: String?, lastKnownDashboardRoutingEmail: String?) {
+        self.targetEmail = targetEmail
+        self.lastKnownDashboardRoutingEmail = lastKnownDashboardRoutingEmail
+    }
+}
+
+public struct CodexDashboardAuthorityInput: Equatable, Sendable {
+    public let sourceKind: CodexDashboardSourceKind
+    public let proof: CodexDashboardOwnershipProofContext
+    public let routing: CodexDashboardRoutingHints
+
+    public init(
+        sourceKind: CodexDashboardSourceKind,
+        proof: CodexDashboardOwnershipProofContext,
+        routing: CodexDashboardRoutingHints)
+    {
+        self.sourceKind = sourceKind
+        self.proof = proof
+        self.routing = routing
+    }
+}
+
+public enum CodexDashboardDecisionReason: Equatable, Sendable {
+    case exactProviderAccountMatch
+    case trustedEmailMatchNoCompetingOwner
+    case trustedContinuityNoCompetingOwner
+    case wrongEmail(expected: String?, actual: String?)
+    case sameEmailAmbiguity(email: String)
+    case unresolvedWithoutTrustedEvidence
+    case providerAccountMissingScopedEmail
+    case providerAccountLacksExactOwnershipProof
+    case missingDashboardSignedInEmail
+}
+
+public struct CodexDashboardAuthorityDecision: Equatable, Sendable {
+    public let disposition: CodexDashboardDisposition
+    public let reason: CodexDashboardDecisionReason
+    public let allowedEffects: Set<CodexDashboardAllowedEffect>
+    public let cleanup: Set<CodexDashboardCleanup>
+
+    public init(
+        disposition: CodexDashboardDisposition,
+        reason: CodexDashboardDecisionReason,
+        allowedEffects: Set<CodexDashboardAllowedEffect>,
+        cleanup: Set<CodexDashboardCleanup>)
+    {
+        self.disposition = disposition
+        self.reason = reason
+        self.allowedEffects = allowedEffects
+        self.cleanup = cleanup
+    }
+}
+
+public enum CodexDashboardPolicyError: LocalizedError, Equatable, Sendable {
+    case displayOnly(CodexDashboardAuthorityDecision)
+
+    public var errorDescription: String? {
+        switch self {
+        case .displayOnly:
+            "Codex dashboard may be displayed, but it cannot be attached to the active account."
+        }
+    }
+}
+
+public enum CodexDashboardAuthority {
+    /// Evaluates whether a Codex dashboard snapshot may attach to the active account.
+    ///
+    /// App callers may keep `.displayOnly` dashboard data visible, but must not attach usage,
+    /// credits, refresh guards, or historical backfill.
+    ///
+    /// CLI callers should surface `.displayOnly` as `CodexDashboardPolicyError.displayOnly`
+    /// instead of treating it as a generic failure.
+    ///
+    /// Cached dashboard callers may restore data only when the decision includes
+    /// `.cachedDashboardReuse` in `allowedEffects`.
+    public static func evaluate(_ input: CodexDashboardAuthorityInput) -> CodexDashboardAuthorityDecision {
+        let proof = input.proof
+        let currentIdentity = Self.normalizeIdentity(proof.currentIdentity)
+        let expectedScopedEmail = CodexIdentityResolver.normalizeEmail(proof.expectedScopedEmail)
+        let trustedCurrentUsageEmail = CodexIdentityResolver.normalizeEmail(proof.trustedCurrentUsageEmail)
+        let dashboardSignedInEmail = CodexIdentityResolver.normalizeEmail(proof.dashboardSignedInEmail)
+        let knownOwners = Self.normalizeKnownOwners(proof.knownOwners)
+
+        // Routing hints are intentionally excluded from ownership proof. They may help fetch or route
+        // dashboard requests, but they must never influence attach/display/fail-closed policy.
+
+        guard let dashboardSignedInEmail else {
+            return Self.makeDecision(
+                disposition: .failClosed,
+                reason: .missingDashboardSignedInEmail,
+                sourceKind: input.sourceKind)
+        }
+
+        if let expectedScopedEmail, dashboardSignedInEmail != expectedScopedEmail {
+            return Self.makeDecision(
+                disposition: .failClosed,
+                reason: .wrongEmail(expected: expectedScopedEmail, actual: dashboardSignedInEmail),
+                sourceKind: input.sourceKind)
+        }
+
+        switch currentIdentity {
+        case let .providerAccount(id):
+            guard expectedScopedEmail != nil else {
+                return Self.makeDecision(
+                    disposition: .failClosed,
+                    reason: .providerAccountMissingScopedEmail,
+                    sourceKind: input.sourceKind)
+            }
+            if Self.knownOwnerCount(for: dashboardSignedInEmail, in: knownOwners) > 1 {
+                return Self.makeDecision(
+                    disposition: .displayOnly,
+                    reason: .sameEmailAmbiguity(email: dashboardSignedInEmail),
+                    sourceKind: input.sourceKind)
+            }
+            let exactMatch = knownOwners.contains { candidate in
+                candidate.identity == .providerAccount(id: id) && candidate.normalizedEmail == dashboardSignedInEmail
+            }
+            if exactMatch {
+                return Self.makeDecision(
+                    disposition: .attach,
+                    reason: .exactProviderAccountMatch,
+                    sourceKind: input.sourceKind)
+            }
+            return Self.makeDecision(
+                disposition: .failClosed,
+                reason: .providerAccountLacksExactOwnershipProof,
+                sourceKind: input.sourceKind)
+
+        case let .emailOnly(normalizedEmail):
+            guard dashboardSignedInEmail == normalizedEmail else {
+                return Self.makeDecision(
+                    disposition: .failClosed,
+                    reason: .wrongEmail(expected: normalizedEmail, actual: dashboardSignedInEmail),
+                    sourceKind: input.sourceKind)
+            }
+            if Self.knownOwnerCount(for: normalizedEmail, in: knownOwners) > 1 {
+                return Self.makeDecision(
+                    disposition: .displayOnly,
+                    reason: .sameEmailAmbiguity(email: normalizedEmail),
+                    sourceKind: input.sourceKind)
+            }
+            return Self.makeDecision(
+                disposition: .attach,
+                reason: .trustedEmailMatchNoCompetingOwner,
+                sourceKind: input.sourceKind)
+
+        case .unresolved:
+            guard let trustedCurrentUsageEmail else {
+                return Self.makeDecision(
+                    disposition: .failClosed,
+                    reason: .unresolvedWithoutTrustedEvidence,
+                    sourceKind: input.sourceKind)
+            }
+            guard dashboardSignedInEmail == trustedCurrentUsageEmail else {
+                return Self.makeDecision(
+                    disposition: .failClosed,
+                    reason: .wrongEmail(expected: trustedCurrentUsageEmail, actual: dashboardSignedInEmail),
+                    sourceKind: input.sourceKind)
+            }
+            if Self.knownOwnerCount(for: trustedCurrentUsageEmail, in: knownOwners) > 1 {
+                return Self.makeDecision(
+                    disposition: .displayOnly,
+                    reason: .sameEmailAmbiguity(email: trustedCurrentUsageEmail),
+                    sourceKind: input.sourceKind)
+            }
+            return Self.makeDecision(
+                disposition: .attach,
+                reason: .trustedContinuityNoCompetingOwner,
+                sourceKind: input.sourceKind)
+        }
+    }
+
+    private static func normalizeIdentity(_ identity: CodexIdentity) -> CodexIdentity {
+        switch identity {
+        case let .providerAccount(id):
+            if let normalizedID = CodexIdentityResolver.normalizeAccountID(id) {
+                return .providerAccount(id: normalizedID)
+            }
+            return .unresolved
+        case let .emailOnly(normalizedEmail):
+            if let normalizedEmail = CodexIdentityResolver.normalizeEmail(normalizedEmail) {
+                return .emailOnly(normalizedEmail: normalizedEmail)
+            }
+            return .unresolved
+        case .unresolved:
+            return .unresolved
+        }
+    }
+
+    private static func normalizeKnownOwners(
+        _ candidates: [CodexDashboardKnownOwnerCandidate])
+        -> Set<CodexDashboardKnownOwnerCandidate>
+    {
+        Set(candidates.map { candidate in
+            let identity = self.normalizeIdentity(candidate.identity)
+            let sourceIsolationIdentifier: String? = switch identity {
+            case .providerAccount:
+                nil
+            case .emailOnly, .unresolved:
+                candidate.sourceIsolationIdentifier
+            }
+            return CodexDashboardKnownOwnerCandidate(
+                identity: identity,
+                normalizedEmail: CodexIdentityResolver.normalizeEmail(candidate.normalizedEmail),
+                sourceIsolationIdentifier: sourceIsolationIdentifier)
+        })
+    }
+
+    private static func knownOwnerCount(
+        for email: String,
+        in candidates: Set<CodexDashboardKnownOwnerCandidate>) -> Int
+    {
+        candidates.count { $0.normalizedEmail == email }
+    }
+
+    private static func makeDecision(
+        disposition: CodexDashboardDisposition,
+        reason: CodexDashboardDecisionReason,
+        sourceKind: CodexDashboardSourceKind) -> CodexDashboardAuthorityDecision
+    {
+        CodexDashboardAuthorityDecision(
+            disposition: disposition,
+            reason: reason,
+            allowedEffects: self.allowedEffects(disposition: disposition, sourceKind: sourceKind),
+            cleanup: disposition == .attach ? [] : Set(CodexDashboardCleanup.allCases))
+    }
+
+    private static func allowedEffects(
+        disposition: CodexDashboardDisposition,
+        sourceKind: CodexDashboardSourceKind) -> Set<CodexDashboardAllowedEffect>
+    {
+        guard disposition == .attach else { return [] }
+
+        switch sourceKind {
+        case .liveWeb:
+            return [
+                .usageBackfill,
+                .creditsAttachment,
+                .refreshGuardSeed,
+                .historicalBackfill,
+            ]
+        case .cachedDashboard:
+            return [.cachedDashboardReuse]
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Codex/CodexIdentity.swift b/Sources/CodexBarCore/Providers/Codex/CodexIdentity.swift
new file mode 100644
index 0000000000..f83cb195da
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Codex/CodexIdentity.swift
@@ -0,0 +1,47 @@
+import Foundation
+
+public enum CodexIdentity: Codable, Equatable, Sendable {
+    case providerAccount(id: String)
+    // Normal OAuth auth should resolve to a provider account ID. Email-only identity is kept as a
+    // migration/hardening fallback for partial auth payloads, not as the primary steady-state path.
+    case emailOnly(normalizedEmail: String)
+    case unresolved
+}
+
+public enum CodexIdentityResolver {
+    public static func resolve(accountId: String?, email: String?) -> CodexIdentity {
+        if let accountId = normalizeAccountID(accountId) {
+            return .providerAccount(id: accountId)
+        }
+        if let email = Self.normalizeEmail(email) {
+            return .emailOnly(normalizedEmail: email)
+        }
+        return .unresolved
+    }
+
+    public static func normalizeEmail(_ email: String?) -> String? {
+        guard let email = email?.trimmingCharacters(in: .whitespacesAndNewlines), !email.isEmpty else {
+            return nil
+        }
+        return email.lowercased()
+    }
+
+    public static func normalizeAccountID(_ accountId: String?) -> String? {
+        guard let accountId = accountId?.trimmingCharacters(in: .whitespacesAndNewlines), !accountId.isEmpty else {
+            return nil
+        }
+        return accountId
+    }
+}
+
+public struct CodexAuthBackedAccount: Equatable, Sendable {
+    public let identity: CodexIdentity
+    public let email: String?
+    public let plan: String?
+
+    public init(identity: CodexIdentity, email: String?, plan: String?) {
+        self.identity = identity
+        self.email = email
+        self.plan = plan
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Codex/CodexOAuth/CodexOAuthCredentials.swift b/Sources/CodexBarCore/Providers/Codex/CodexOAuth/CodexOAuthCredentials.swift
index f7f5c31917..bb0902d2dd 100644
--- a/Sources/CodexBarCore/Providers/Codex/CodexOAuth/CodexOAuthCredentials.swift
+++ b/Sources/CodexBarCore/Providers/Codex/CodexOAuth/CodexOAuthCredentials.swift
@@ -1,3 +1,10 @@
+#if canImport(Darwin)
+import Darwin
+#elseif canImport(Glibc)
+import Glibc
+#elseif canImport(Musl)
+import Musl
+#endif
 import Foundation
 
 public struct CodexOAuthCredentials: Sendable {
@@ -46,19 +53,19 @@ public enum CodexOAuthCredentialsError: LocalizedError, Sendable {
 }
 
 public enum CodexOAuthCredentialsStore {
-    private static var authFilePath: URL {
-        let home = FileManager.default.homeDirectoryForCurrentUser
-        if let codexHome = ProcessInfo.processInfo.environment["CODEX_HOME"]?.trimmingCharacters(
-            in: .whitespacesAndNewlines),
-            !codexHome.isEmpty
-        {
-            return URL(fileURLWithPath: codexHome).appendingPathComponent("auth.json")
-        }
-        return home.appendingPathComponent(".codex").appendingPathComponent("auth.json")
+    private static func authFilePath(
+        env: [String: String] = ProcessInfo.processInfo.environment,
+        fileManager: FileManager = .default) -> URL
+    {
+        CodexHomeScope
+            .ambientHomeURL(env: env, fileManager: fileManager)
+            .appendingPathComponent("auth.json")
     }
 
-    public static func load() throws -> CodexOAuthCredentials {
-        let url = self.authFilePath
+    public static func load(env: [String: String] = ProcessInfo.processInfo
+        .environment) throws -> CodexOAuthCredentials
+    {
+        let url = self.authFilePath(env: env)
         guard FileManager.default.fileExists(atPath: url.path) else {
             throw CodexOAuthCredentialsError.notFound
         }
@@ -86,15 +93,18 @@ public enum CodexOAuthCredentialsStore {
         guard let tokens = json["tokens"] as? [String: Any] else {
             throw CodexOAuthCredentialsError.missingTokens
         }
-        guard let accessToken = tokens["access_token"] as? String,
-              let refreshToken = tokens["refresh_token"] as? String,
+        guard let accessToken = Self.stringValue(in: tokens, snakeCaseKey: "access_token", camelCaseKey: "accessToken"),
+              let refreshToken = Self.stringValue(
+                  in: tokens,
+                  snakeCaseKey: "refresh_token",
+                  camelCaseKey: "refreshToken"),
               !accessToken.isEmpty
         else {
             throw CodexOAuthCredentialsError.missingTokens
         }
 
-        let idToken = tokens["id_token"] as? String
-        let accountId = tokens["account_id"] as? String
+        let idToken = Self.stringValue(in: tokens, snakeCaseKey: "id_token", camelCaseKey: "idToken")
+        let accountId = Self.stringValue(in: tokens, snakeCaseKey: "account_id", camelCaseKey: "accountId")
         let lastRefresh = Self.parseLastRefresh(from: json["last_refresh"])
 
         return CodexOAuthCredentials(
@@ -105,8 +115,11 @@ public enum CodexOAuthCredentialsStore {
             lastRefresh: lastRefresh)
     }
 
-    public static func save(_ credentials: CodexOAuthCredentials) throws {
-        let url = self.authFilePath
+    public static func save(
+        _ credentials: CodexOAuthCredentials,
+        env: [String: String] = ProcessInfo.processInfo.environment) throws
+    {
+        let url = self.authFilePath(env: env)
 
         var json: [String: Any] = [:]
         if let data = try? Data(contentsOf: url),
@@ -132,7 +145,64 @@ public enum CodexOAuthCredentialsStore {
         let data = try JSONSerialization.data(withJSONObject: json, options: [.prettyPrinted, .sortedKeys])
         let directory = url.deletingLastPathComponent()
         try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
-        try data.write(to: url, options: .atomic)
+        try self.writePrivateFile(data, to: url)
+    }
+
+    private static func writePrivateFile(
+        _ data: Data,
+        to url: URL,
+        beforePublish: ((URL) throws -> Void)? = nil) throws
+    {
+        let fileManager = FileManager.default
+        let stagedURL = url.deletingLastPathComponent().appendingPathComponent(
+            ".\(url.lastPathComponent).codexbar-staged-\(UUID().uuidString)",
+            isDirectory: false)
+        let stagedPath = stagedURL.path
+        let descriptor = stagedPath.withCString {
+            open($0, O_WRONLY | O_CREAT | O_EXCL | O_CLOEXEC, mode_t(0o600))
+        }
+        guard descriptor >= 0 else {
+            throw self.posixError(code: errno, path: stagedPath)
+        }
+
+        let handle = FileHandle(fileDescriptor: descriptor, closeOnDealloc: true)
+        var handleIsOpen = true
+        do {
+            guard fchmod(descriptor, mode_t(0o600)) == 0 else {
+                throw self.posixError(code: errno, path: stagedPath)
+            }
+            try handle.write(contentsOf: data)
+            try handle.synchronize()
+            try handle.close()
+            handleIsOpen = false
+
+            try beforePublish?(stagedURL)
+            try self.renameItem(at: stagedURL, to: url)
+        } catch {
+            if handleIsOpen {
+                try? handle.close()
+            }
+            try? fileManager.removeItem(at: stagedURL)
+            throw error
+        }
+    }
+
+    private static func renameItem(at sourceURL: URL, to destinationURL: URL) throws {
+        let result = sourceURL.path.withCString { sourcePath in
+            destinationURL.path.withCString { destinationPath in
+                rename(sourcePath, destinationPath)
+            }
+        }
+        guard result == 0 else {
+            throw self.posixError(code: errno, path: destinationURL.path)
+        }
+    }
+
+    private static func posixError(code: Int32, path: String) -> NSError {
+        NSError(
+            domain: NSPOSIXErrorDomain,
+            code: Int(code),
+            userInfo: [NSFilePathErrorKey: path])
     }
 
     private static func parseLastRefresh(from raw: Any?) -> Date? {
@@ -143,4 +213,35 @@ public enum CodexOAuthCredentialsStore {
         formatter.formatOptions = [.withInternetDateTime]
         return formatter.date(from: value)
     }
+
+    private static func stringValue(
+        in dictionary: [String: Any],
+        snakeCaseKey: String,
+        camelCaseKey: String)
+        -> String?
+    {
+        if let value = dictionary[snakeCaseKey] as? String, !value.isEmpty {
+            return value
+        }
+        if let value = dictionary[camelCaseKey] as? String, !value.isEmpty {
+            return value
+        }
+        return nil
+    }
+}
+
+#if DEBUG
+extension CodexOAuthCredentialsStore {
+    static func _authFileURLForTesting(env: [String: String]) -> URL {
+        self.authFilePath(env: env)
+    }
+
+    static func _writePrivateFileForTesting(
+        _ data: Data,
+        to url: URL,
+        beforePublish: @escaping (URL) throws -> Void) throws
+    {
+        try self.writePrivateFile(data, to: url, beforePublish: beforePublish)
+    }
 }
+#endif
diff --git a/Sources/CodexBarCore/Providers/Codex/CodexOAuth/CodexOAuthUsageFetcher.swift b/Sources/CodexBarCore/Providers/Codex/CodexOAuth/CodexOAuthUsageFetcher.swift
index 174c08c547..e6e551da21 100644
--- a/Sources/CodexBarCore/Providers/Codex/CodexOAuth/CodexOAuthUsageFetcher.swift
+++ b/Sources/CodexBarCore/Providers/Codex/CodexOAuth/CodexOAuthUsageFetcher.swift
@@ -7,11 +7,45 @@ public struct CodexUsageResponse: Decodable, Sendable {
     public let planType: PlanType?
     public let rateLimit: RateLimitDetails?
     public let credits: CreditDetails?
+    /// Model-specific limits (e.g. GPT-5.3-Codex-Spark) that sit alongside the primary/weekly windows.
+    public let additionalRateLimits: [AdditionalRateLimit]?
+    let additionalRateLimitsDecodeFailed: Bool
 
     enum CodingKeys: String, CodingKey {
         case planType = "plan_type"
         case rateLimit = "rate_limit"
         case credits
+        case additionalRateLimits = "additional_rate_limits"
+    }
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.planType = try? container.decodeIfPresent(PlanType.self, forKey: .planType)
+        self.rateLimit = try? container.decodeIfPresent(RateLimitDetails.self, forKey: .rateLimit)
+        self.credits = try? container.decodeIfPresent(CreditDetails.self, forKey: .credits)
+        // Optional and additive: missing/malformed extra limits must never disturb primary/weekly mapping.
+        // Decode per element so a single malformed entry cannot discard its valid siblings; a non-array
+        // value (or absent field) leaves `additionalRateLimits` nil and primary/weekly mapping untouched.
+        let additionalRateLimitsHadValue = Self.hasNonNilValue(container: container, key: .additionalRateLimits)
+        do {
+            let decoded = try container.decodeIfPresent(
+                [LossyAdditionalRateLimit].self,
+                forKey: .additionalRateLimits)
+            self.additionalRateLimits = decoded?.compactMap(\.value)
+            self.additionalRateLimitsDecodeFailed = decoded?.contains(where: \.decodeFailed) == true
+                || self.additionalRateLimits?.contains(where: \.hasWindowDecodeFailure) == true
+        } catch {
+            self.additionalRateLimits = nil
+            self.additionalRateLimitsDecodeFailed = additionalRateLimitsHadValue
+        }
+    }
+
+    private static func hasNonNilValue(
+        container: KeyedDecodingContainer<CodingKeys>,
+        key: CodingKeys) -> Bool
+    {
+        guard container.contains(key) else { return false }
+        return (try? container.decodeNil(forKey: key)) == false
     }
 
     public enum PlanType: Sendable, Decodable, Equatable {
@@ -75,11 +109,46 @@ public struct CodexUsageResponse: Decodable, Sendable {
     public struct RateLimitDetails: Decodable, Sendable {
         public let primaryWindow: WindowSnapshot?
         public let secondaryWindow: WindowSnapshot?
+        let primaryWindowDecodeFailed: Bool
+        let secondaryWindowDecodeFailed: Bool
 
         enum CodingKeys: String, CodingKey {
             case primaryWindow = "primary_window"
             case secondaryWindow = "secondary_window"
         }
+
+        public init(from decoder: Decoder) throws {
+            let container = try decoder.container(keyedBy: CodingKeys.self)
+            let primaryHadValue = Self.hasNonNilValue(container: container, key: .primaryWindow)
+            do {
+                self.primaryWindow = try container.decodeIfPresent(WindowSnapshot.self, forKey: .primaryWindow)
+                self.primaryWindowDecodeFailed = false
+            } catch {
+                self.primaryWindow = nil
+                self.primaryWindowDecodeFailed = primaryHadValue
+            }
+
+            let secondaryHadValue = Self.hasNonNilValue(container: container, key: .secondaryWindow)
+            do {
+                self.secondaryWindow = try container.decodeIfPresent(WindowSnapshot.self, forKey: .secondaryWindow)
+                self.secondaryWindowDecodeFailed = false
+            } catch {
+                self.secondaryWindow = nil
+                self.secondaryWindowDecodeFailed = secondaryHadValue
+            }
+        }
+
+        private static func hasNonNilValue(
+            container: KeyedDecodingContainer<CodingKeys>,
+            key: CodingKeys) -> Bool
+        {
+            guard container.contains(key) else { return false }
+            return (try? container.decodeNil(forKey: key)) == false
+        }
+
+        var hasWindowDecodeFailure: Bool {
+            self.primaryWindowDecodeFailed || self.secondaryWindowDecodeFailed
+        }
     }
 
     public struct WindowSnapshot: Decodable, Sendable {
@@ -94,6 +163,60 @@ public struct CodexUsageResponse: Decodable, Sendable {
         }
     }
 
+    /// One entry of `additional_rate_limits`: a named, model-specific limit (e.g. GPT-5.3-Codex-Spark)
+    /// whose windows reuse the same shape as the primary/weekly `RateLimitDetails`.
+    public struct AdditionalRateLimit: Decodable, Sendable {
+        public let limitName: String?
+        public let meteredFeature: String?
+        public let rateLimit: RateLimitDetails?
+        let rateLimitDecodeFailed: Bool
+
+        enum CodingKeys: String, CodingKey {
+            case limitName = "limit_name"
+            case meteredFeature = "metered_feature"
+            case rateLimit = "rate_limit"
+        }
+
+        public init(from decoder: Decoder) throws {
+            let container = try decoder.container(keyedBy: CodingKeys.self)
+            self.limitName = try? container.decodeIfPresent(String.self, forKey: .limitName)
+            self.meteredFeature = try? container.decodeIfPresent(String.self, forKey: .meteredFeature)
+            let rateLimitHadValue = Self.hasNonNilValue(container: container, key: .rateLimit)
+            do {
+                self.rateLimit = try container.decodeIfPresent(RateLimitDetails.self, forKey: .rateLimit)
+                self.rateLimitDecodeFailed = false
+            } catch {
+                self.rateLimit = nil
+                self.rateLimitDecodeFailed = rateLimitHadValue
+            }
+        }
+
+        private static func hasNonNilValue(
+            container: KeyedDecodingContainer<CodingKeys>,
+            key: CodingKeys) -> Bool
+        {
+            guard container.contains(key) else { return false }
+            return (try? container.decodeNil(forKey: key)) == false
+        }
+
+        var hasWindowDecodeFailure: Bool {
+            self.rateLimitDecodeFailed || self.rateLimit?.hasWindowDecodeFailure == true
+        }
+    }
+
+    /// Decodes a single `additional_rate_limits` element without ever throwing, so one malformed
+    /// entry cannot discard its valid siblings during array decoding.
+    private struct LossyAdditionalRateLimit: Decodable {
+        let value: AdditionalRateLimit?
+        let decodeFailed: Bool
+
+        init(from decoder: Decoder) throws {
+            let container = try decoder.singleValueContainer()
+            self.value = try? container.decode(AdditionalRateLimit.self)
+            self.decodeFailed = self.value == nil
+        }
+    }
+
     public struct CreditDetails: Decodable, Sendable {
         public let hasCredits: Bool
         public let unlimited: Bool
@@ -149,9 +272,14 @@ public enum CodexOAuthUsageFetcher {
     private static let defaultChatGPTBaseURL = "https://chatgpt.com/backend-api/"
     private static let chatGPTUsagePath = "/wham/usage"
     private static let codexUsagePath = "/api/codex/usage"
+    private static let rateLimitResetCreditsPath = "/wham/rate-limit-reset-credits"
 
-    public static func fetchUsage(accessToken: String, accountId: String?) async throws -> CodexUsageResponse {
-        var request = URLRequest(url: Self.resolveUsageURL())
+    public static func fetchUsage(
+        accessToken: String,
+        accountId: String?,
+        env: [String: String] = ProcessInfo.processInfo.environment) async throws -> CodexUsageResponse
+    {
+        var request = URLRequest(url: Self.resolveUsageURL(env: env))
         request.httpMethod = "GET"
         request.timeoutInterval = 30
         request.setValue("Bearer \(accessToken)", forHTTPHeaderField: "Authorization")
@@ -163,12 +291,10 @@ public enum CodexOAuthUsageFetcher {
         }
 
         do {
-            let (data, response) = try await URLSession.shared.data(for: request)
-            guard let http = response as? HTTPURLResponse else {
-                throw CodexOAuthFetchError.invalidResponse
-            }
+            let response = try await ProviderHTTPClient.shared.response(for: request)
+            let data = response.data
 
-            switch http.statusCode {
+            switch response.statusCode {
             case 200...299:
                 do {
                     return try JSONDecoder().decode(CodexUsageResponse.self, from: data)
@@ -179,7 +305,60 @@ public enum CodexOAuthUsageFetcher {
                 throw CodexOAuthFetchError.unauthorized
             default:
                 let body = String(data: data, encoding: .utf8)
-                throw CodexOAuthFetchError.serverError(http.statusCode, body)
+                throw CodexOAuthFetchError.serverError(response.statusCode, body)
+            }
+        } catch let error as CodexOAuthFetchError {
+            throw error
+        } catch {
+            throw CodexOAuthFetchError.networkError(error)
+        }
+    }
+
+    public static func fetchRateLimitResetCredits(
+        accessToken: String,
+        accountId: String?,
+        env: [String: String] = ProcessInfo.processInfo.environment,
+        timeout: TimeInterval = 4,
+        session transport: any ProviderHTTPTransport = ProviderHTTPClient.shared) async throws
+        -> CodexRateLimitResetCreditsSnapshot
+    {
+        var request = URLRequest(url: Self.resolveRateLimitResetCreditsURL(env: env), timeoutInterval: timeout)
+        request.httpMethod = "GET"
+        request.setValue("Bearer \(accessToken)", forHTTPHeaderField: "Authorization")
+        request.setValue("CodexBar", forHTTPHeaderField: "User-Agent")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        request.setValue("codex-1", forHTTPHeaderField: "OpenAI-Beta")
+        request.setValue("Codex Desktop", forHTTPHeaderField: "originator")
+
+        if let accountId, !accountId.isEmpty {
+            request.setValue(accountId, forHTTPHeaderField: "ChatGPT-Account-ID")
+        }
+
+        do {
+            let response = try await transport.response(for: request)
+            let data = response.data
+
+            switch response.statusCode {
+            case 200...299:
+                do {
+                    let decoder = JSONDecoder()
+                    decoder.dateDecodingStrategy = .custom(Self.decodeISO8601Date)
+                    let payload = try decoder.decode(RateLimitResetCreditsResponse.self, from: data)
+                    guard payload.availableCount >= 0 else {
+                        throw CodexOAuthFetchError.invalidResponse
+                    }
+                    return CodexRateLimitResetCreditsSnapshot(
+                        credits: payload.credits,
+                        availableCount: payload.availableCount,
+                        updatedAt: Date())
+                } catch {
+                    throw CodexOAuthFetchError.invalidResponse
+                }
+            case 401, 403:
+                throw CodexOAuthFetchError.unauthorized
+            default:
+                let body = String(data: data, encoding: .utf8)
+                throw CodexOAuthFetchError.serverError(response.statusCode, body)
             }
         } catch let error as CodexOAuthFetchError {
             throw error
@@ -188,8 +367,8 @@ public enum CodexOAuthUsageFetcher {
         }
     }
 
-    private static func resolveUsageURL() -> URL {
-        self.resolveUsageURL(env: ProcessInfo.processInfo.environment, configContents: nil)
+    private static func resolveUsageURL(env: [String: String]) -> URL {
+        self.resolveUsageURL(env: env, configContents: nil)
     }
 
     private static func resolveUsageURL(env: [String: String], configContents: String?) -> URL {
@@ -200,6 +379,17 @@ public enum CodexOAuthUsageFetcher {
         return URL(string: full) ?? URL(string: Self.defaultChatGPTBaseURL + Self.chatGPTUsagePath)!
     }
 
+    private static func resolveRateLimitResetCreditsURL(env: [String: String]) -> URL {
+        self.resolveRateLimitResetCreditsURL(env: env, configContents: nil)
+    }
+
+    private static func resolveRateLimitResetCreditsURL(env: [String: String], configContents: String?) -> URL {
+        let baseURL = self.resolveChatGPTBaseURL(env: env, configContents: configContents)
+        let normalized = self.normalizeChatGPTBaseURL(baseURL)
+        let full = normalized + Self.rateLimitResetCreditsPath
+        return URL(string: full) ?? URL(string: Self.defaultChatGPTBaseURL + Self.rateLimitResetCreditsPath)!
+    }
+
     private static func resolveChatGPTBaseURL(env: [String: String], configContents: String?) -> String {
         if let configContents, let parsed = self.parseChatGPTBaseURL(from: configContents) {
             return parsed
@@ -254,6 +444,31 @@ public enum CodexOAuthUsageFetcher {
         let url = root.appendingPathComponent("config.toml")
         return try? String(contentsOf: url, encoding: .utf8)
     }
+
+    private struct RateLimitResetCreditsResponse: Decodable {
+        let credits: [CodexRateLimitResetCredit]
+        let availableCount: Int
+
+        private enum CodingKeys: String, CodingKey {
+            case credits
+            case availableCount = "available_count"
+        }
+    }
+
+    private static func decodeISO8601Date(from decoder: Decoder) throws -> Date {
+        let container = try decoder.singleValueContainer()
+        let raw = try container.decode(String.self)
+        let fractional = ISO8601DateFormatter()
+        fractional.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        let seconds = ISO8601DateFormatter()
+        seconds.formatOptions = [.withInternetDateTime]
+        if let date = fractional.date(from: raw) ?? seconds.date(from: raw) {
+            return date
+        }
+        throw DecodingError.dataCorruptedError(
+            in: container,
+            debugDescription: "Invalid ISO-8601 date: \(raw)")
+    }
 }
 
 #if DEBUG
@@ -265,5 +480,22 @@ extension CodexOAuthUsageFetcher {
     static func _decodeUsageResponseForTesting(_ data: Data) throws -> CodexUsageResponse {
         try JSONDecoder().decode(CodexUsageResponse.self, from: data)
     }
+
+    static func _resolveRateLimitResetCreditsURLForTesting(
+        env: [String: String] = [:],
+        configContents: String? = nil) -> URL
+    {
+        self.resolveRateLimitResetCreditsURL(env: env, configContents: configContents)
+    }
+
+    static func _decodeRateLimitResetCreditsForTesting(_ data: Data) throws -> CodexRateLimitResetCreditsSnapshot {
+        let decoder = JSONDecoder()
+        decoder.dateDecodingStrategy = .custom(Self.decodeISO8601Date)
+        let payload = try decoder.decode(RateLimitResetCreditsResponse.self, from: data)
+        return CodexRateLimitResetCreditsSnapshot(
+            credits: payload.credits,
+            availableCount: payload.availableCount,
+            updatedAt: Date())
+    }
 }
 #endif
diff --git a/Sources/CodexBarCore/Providers/Codex/CodexOAuth/CodexTokenRefresher.swift b/Sources/CodexBarCore/Providers/Codex/CodexOAuth/CodexTokenRefresher.swift
index aa49311fad..c39a3c3b17 100644
--- a/Sources/CodexBarCore/Providers/Codex/CodexOAuth/CodexTokenRefresher.swift
+++ b/Sources/CodexBarCore/Providers/Codex/CodexOAuth/CodexTokenRefresher.swift
@@ -49,25 +49,10 @@ public enum CodexTokenRefresher {
         request.httpBody = try JSONSerialization.data(withJSONObject: body)
 
         do {
-            let (data, response) = try await URLSession.shared.data(for: request)
-            guard let http = response as? HTTPURLResponse else {
-                throw RefreshError.invalidResponse("No HTTP response")
-            }
-
-            if http.statusCode == 401 {
-                if let errorCode = Self.extractErrorCode(from: data) {
-                    switch errorCode.lowercased() {
-                    case "refresh_token_expired": throw RefreshError.expired
-                    case "refresh_token_reused": throw RefreshError.reused
-                    case "refresh_token_invalidated": throw RefreshError.revoked
-                    default: throw RefreshError.expired
-                    }
-                }
-                throw RefreshError.expired
-            }
-
-            guard http.statusCode == 200 else {
-                throw RefreshError.invalidResponse("Status \(http.statusCode)")
+            let response = try await ProviderHTTPClient.shared.response(for: request)
+            let data = response.data
+            guard response.statusCode == 200 else {
+                throw Self.refreshFailureError(statusCode: response.statusCode, data: data)
             }
 
             guard let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
@@ -97,4 +82,33 @@ public enum CodexTokenRefresher {
         if let error = json["error"] as? String { return error }
         return json["code"] as? String
     }
+
+    private static func refreshFailureError(statusCode: Int, data: Data) -> RefreshError {
+        if let errorCode = extractErrorCode(from: data) {
+            switch errorCode.lowercased() {
+            case "refresh_token_expired":
+                return .expired
+            case "refresh_token_reused":
+                return .reused
+            case "invalid_grant", "refresh_token_invalidated":
+                return .revoked
+            default:
+                break
+            }
+        }
+
+        if statusCode == 401 {
+            return .expired
+        }
+
+        return .invalidResponse("Status \(statusCode)")
+    }
 }
+
+#if DEBUG
+extension CodexTokenRefresher {
+    static func _refreshFailureErrorForTesting(statusCode: Int, data: Data) -> RefreshError {
+        self.refreshFailureError(statusCode: statusCode, data: data)
+    }
+}
+#endif
diff --git a/Sources/CodexBarCore/Providers/Codex/CodexOpenAIWorkspaceIdentityCache.swift b/Sources/CodexBarCore/Providers/Codex/CodexOpenAIWorkspaceIdentityCache.swift
new file mode 100644
index 0000000000..2809c8c3ca
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Codex/CodexOpenAIWorkspaceIdentityCache.swift
@@ -0,0 +1,115 @@
+import Foundation
+
+public struct CodexOpenAIWorkspaceIdentityCache: @unchecked Sendable {
+    public static let currentVersion = 1
+
+    private struct Payload: Codable {
+        let version: Int
+        var labelsByWorkspaceAccountID: [String: String]
+
+        init(
+            version: Int = CodexOpenAIWorkspaceIdentityCache.currentVersion,
+            labelsByWorkspaceAccountID: [String: String])
+        {
+            self.version = version
+            self.labelsByWorkspaceAccountID = labelsByWorkspaceAccountID
+        }
+    }
+
+    #if DEBUG
+    @TaskLocal static var taskFileURLOverride: URL?
+    #endif
+
+    private let fileURL: URL
+    private let fileManager: FileManager
+
+    public init(fileURL: URL = Self.defaultURL(), fileManager: FileManager = .default) {
+        self.fileURL = fileURL
+        self.fileManager = fileManager
+    }
+
+    public func workspaceLabel(for workspaceAccountID: String?) -> String? {
+        guard let normalizedWorkspaceAccountID = CodexOpenAIWorkspaceResolver
+            .normalizeWorkspaceAccountID(workspaceAccountID)
+        else {
+            return nil
+        }
+
+        return self.loadPayload().labelsByWorkspaceAccountID[normalizedWorkspaceAccountID]
+    }
+
+    public func store(_ identity: CodexOpenAIWorkspaceIdentity) throws {
+        guard let workspaceLabel = CodexOpenAIWorkspaceIdentity.normalizeWorkspaceLabel(identity.workspaceLabel) else {
+            return
+        }
+
+        var payload = self.loadPayload()
+        payload.labelsByWorkspaceAccountID[identity.workspaceAccountID] = workspaceLabel
+
+        let encoder = JSONEncoder()
+        encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
+        let data = try encoder.encode(payload)
+        let directory = self.fileURL.deletingLastPathComponent()
+        if !self.fileManager.fileExists(atPath: directory.path) {
+            try self.fileManager.createDirectory(at: directory, withIntermediateDirectories: true)
+        }
+        try data.write(to: self.fileURL, options: [.atomic])
+        try self.applySecurePermissionsIfNeeded()
+    }
+
+    private func loadPayload() -> Payload {
+        guard self.fileManager.fileExists(atPath: self.fileURL.path),
+              let data = try? Data(contentsOf: self.fileURL),
+              let payload = try? JSONDecoder().decode(Payload.self, from: data),
+              payload.version == Self.currentVersion
+        else {
+            return Payload(labelsByWorkspaceAccountID: [:])
+        }
+
+        return payload
+    }
+
+    private func applySecurePermissionsIfNeeded() throws {
+        #if os(macOS)
+        try self.fileManager.setAttributes([
+            .posixPermissions: NSNumber(value: Int16(0o600)),
+        ], ofItemAtPath: self.fileURL.path)
+        #endif
+    }
+
+    public static func defaultURL() -> URL {
+        #if DEBUG
+        if let override = self.taskFileURLOverride {
+            return override
+        }
+        #endif
+
+        let base = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask).first
+            ?? FileManager.default.homeDirectoryForCurrentUser
+        return base
+            .appendingPathComponent("CodexBar", isDirectory: true)
+            .appendingPathComponent("codex-openai-workspaces.json")
+    }
+}
+
+#if DEBUG
+extension CodexOpenAIWorkspaceIdentityCache {
+    public static func withFileURLOverrideForTesting<T>(
+        _ fileURL: URL,
+        operation: () throws -> T) rethrows -> T
+    {
+        try self.$taskFileURLOverride.withValue(fileURL) {
+            try operation()
+        }
+    }
+
+    public static func withFileURLOverrideForTesting<T>(
+        _ fileURL: URL,
+        operation: () async throws -> T) async rethrows -> T
+    {
+        try await self.$taskFileURLOverride.withValue(fileURL) {
+            try await operation()
+        }
+    }
+}
+#endif
diff --git a/Sources/CodexBarCore/Providers/Codex/CodexOpenAIWorkspaceResolver.swift b/Sources/CodexBarCore/Providers/Codex/CodexOpenAIWorkspaceResolver.swift
new file mode 100644
index 0000000000..4aea367109
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Codex/CodexOpenAIWorkspaceResolver.swift
@@ -0,0 +1,113 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public struct CodexOpenAIWorkspaceIdentity: Equatable, Sendable {
+    public let workspaceAccountID: String
+    public let workspaceLabel: String?
+
+    public init(workspaceAccountID: String, workspaceLabel: String?) {
+        self.workspaceAccountID = Self.normalizeWorkspaceAccountID(workspaceAccountID)
+        self.workspaceLabel = Self.normalizeWorkspaceLabel(workspaceLabel)
+    }
+
+    public static func normalizeWorkspaceAccountID(_ value: String) -> String {
+        value.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+    }
+
+    public static func normalizeWorkspaceLabel(_ value: String?) -> String? {
+        guard let trimmed = value?.trimmingCharacters(in: .whitespacesAndNewlines), !trimmed.isEmpty else {
+            return nil
+        }
+        return trimmed
+    }
+}
+
+public enum CodexOpenAIWorkspaceResolver {
+    private struct AccountsResponse: Decodable {
+        let items: [AccountItem]
+    }
+
+    private struct AccountItem: Decodable {
+        let id: String
+        let name: String?
+    }
+
+    private static let accountsURL = URL(string: "https://chatgpt.com/backend-api/accounts")!
+
+    public static func resolve(
+        credentials: CodexOAuthCredentials,
+        session transport: any ProviderHTTPTransport = ProviderHTTPClient
+            .shared) async throws -> CodexOpenAIWorkspaceIdentity?
+    {
+        guard let workspaceAccountID = normalizeWorkspaceAccountID(credentials.accountId) else {
+            return nil
+        }
+
+        let identities = try await self.listWorkspaces(credentials: credentials, session: transport)
+        if let identity = identities.first(where: { $0.workspaceAccountID == workspaceAccountID }) {
+            return identity
+        }
+
+        return CodexOpenAIWorkspaceIdentity(
+            workspaceAccountID: workspaceAccountID,
+            workspaceLabel: nil)
+    }
+
+    public static func listWorkspaces(
+        credentials: CodexOAuthCredentials,
+        session transport: any ProviderHTTPTransport = ProviderHTTPClient
+            .shared) async throws -> [CodexOpenAIWorkspaceIdentity]
+    {
+        var request = URLRequest(url: self.accountsURL)
+        request.httpMethod = "GET"
+        request.timeoutInterval = 20
+        request.setValue("Bearer \(credentials.accessToken)", forHTTPHeaderField: "Authorization")
+        request.setValue("codex-cli", forHTTPHeaderField: "User-Agent")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        if let workspaceAccountID = normalizeWorkspaceAccountID(credentials.accountId) {
+            request.setValue(workspaceAccountID, forHTTPHeaderField: "ChatGPT-Account-Id")
+        }
+
+        let response = try await transport.response(for: request)
+        guard (200..<300).contains(response.statusCode)
+        else {
+            throw CodexOpenAIWorkspaceResolverError.invalidResponse
+        }
+
+        let decoded = try JSONDecoder().decode(AccountsResponse.self, from: response.data)
+        return decoded.items.compactMap { account in
+            guard let workspaceAccountID = self.normalizeWorkspaceAccountID(account.id) else { return nil }
+            return CodexOpenAIWorkspaceIdentity(
+                workspaceAccountID: workspaceAccountID,
+                workspaceLabel: self.resolveWorkspaceLabel(from: account))
+        }
+    }
+
+    public static func normalizeWorkspaceAccountID(_ value: String?) -> String? {
+        guard let trimmed = value?.trimmingCharacters(in: .whitespacesAndNewlines), !trimmed.isEmpty else {
+            return nil
+        }
+        return trimmed.lowercased()
+    }
+
+    private static func resolveWorkspaceLabel(from account: AccountItem) -> String? {
+        let name = account.name?.trimmingCharacters(in: .whitespacesAndNewlines)
+        if let name, !name.isEmpty {
+            return name
+        }
+        return "Personal"
+    }
+}
+
+public enum CodexOpenAIWorkspaceResolverError: LocalizedError, Sendable {
+    case invalidResponse
+
+    public var errorDescription: String? {
+        switch self {
+        case .invalidResponse:
+            "OpenAI account lookup returned an invalid response."
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Codex/CodexPlanFormatting.swift b/Sources/CodexBarCore/Providers/Codex/CodexPlanFormatting.swift
new file mode 100644
index 0000000000..af546a3807
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Codex/CodexPlanFormatting.swift
@@ -0,0 +1,59 @@
+import Foundation
+
+public enum CodexPlanFormatting {
+    private static let exactDisplayNames: [String: String] = [
+        "pro": "Pro 20x",
+        "prolite": "Pro 5x",
+        "pro_lite": "Pro 5x",
+        "pro-lite": "Pro 5x",
+        "pro lite": "Pro 5x",
+    ]
+
+    private static let uppercaseWords: Set<String> = [
+        "cbp",
+        "k12",
+    ]
+
+    public static func displayName(_ raw: String?) -> String? {
+        guard let raw = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !raw.isEmpty else {
+            return nil
+        }
+
+        let lower = raw.lowercased()
+        if let exact = Self.exactDisplayNames[lower] {
+            return exact
+        }
+
+        let cleaned = UsageFormatter.cleanPlanName(raw)
+        let candidate = cleaned.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !candidate.isEmpty else { return raw }
+
+        if let exact = Self.exactDisplayNames[candidate.lowercased()] {
+            return exact
+        }
+
+        let components = candidate
+            .split(whereSeparator: { $0 == "_" || $0 == "-" || $0.isWhitespace })
+            .map(String.init)
+            .filter { !$0.isEmpty }
+
+        guard !components.isEmpty else { return candidate }
+
+        let formatted = components.map(Self.wordDisplayName).joined(separator: " ")
+        return formatted.isEmpty ? candidate : formatted
+    }
+
+    private static func wordDisplayName(_ raw: String) -> String {
+        let lower = raw.lowercased()
+        if Self.uppercaseWords.contains(lower) {
+            return lower.uppercased()
+        }
+        if raw == raw.uppercased(), raw.contains(where: \.isLetter) {
+            return raw
+        }
+        if let first = raw.first, first.isLowercase {
+            return raw.prefix(1).uppercased() + raw.dropFirst()
+        }
+        return raw
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Codex/CodexProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Codex/CodexProviderDescriptor.swift
index 12b68cd22e..a505258aa0 100644
--- a/Sources/CodexBarCore/Providers/Codex/CodexProviderDescriptor.swift
+++ b/Sources/CodexBarCore/Providers/Codex/CodexProviderDescriptor.swift
@@ -1,9 +1,8 @@
-import CodexBarMacroSupport
 import Foundation
 
-@ProviderDescriptorRegistration
-@ProviderDescriptorDefinition
 public enum CodexProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
     static func makeDescriptor() -> ProviderDescriptor {
         ProviderDescriptor(
             id: .codex,
@@ -21,8 +20,10 @@ public enum CodexProviderDescriptor {
                 defaultEnabled: true,
                 isPrimaryProvider: true,
                 usesAccountFallback: true,
-                browserCookieOrder: ProviderBrowserCookieDefaults.defaultImportOrder,
+                browserCookieOrder: ProviderBrowserCookieDefaults.codexCookieImportOrder
+                    ?? ProviderBrowserCookieDefaults.defaultImportOrder,
                 dashboardURL: "https://chatgpt.com/codex/settings/usage",
+                changelogURL: "https://github.com/openai/codex/releases",
                 statusPageURL: "https://status.openai.com/"),
             branding: ProviderBranding(
                 iconStyle: .codex,
@@ -56,7 +57,7 @@ public enum CodexProviderDescriptor {
             case .api:
                 return []
             case .auto:
-                return [web, cli]
+                return [oauth, cli]
             }
         case .app:
             switch context.sourceMode {
@@ -75,13 +76,11 @@ public enum CodexProviderDescriptor {
     }
 
     private static func noDataMessage() -> String {
-        let fm = FileManager.default
-        let home = fm.homeDirectoryForCurrentUser.path
-        let base = ProcessInfo.processInfo.environment["CODEX_HOME"].flatMap { raw -> String? in
-            let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines)
-            guard !trimmed.isEmpty else { return nil }
-            return trimmed
-        } ?? "\(home)/.codex"
+        self.noDataMessage(env: ProcessInfo.processInfo.environment)
+    }
+
+    private static func noDataMessage(env: [String: String], fileManager: FileManager = .default) -> String {
+        let base = CodexHomeScope.ambientHomeURL(env: env, fileManager: fileManager).path
         let sessions = "\(base)/sessions"
         let archived = "\(base)/archived_sessions"
         return "No Codex sessions found in \(sessions) or \(archived)."
@@ -109,16 +108,27 @@ struct CodexCLIUsageStrategy: ProviderFetchStrategy {
     let id: String = "codex.cli"
     let kind: ProviderFetchKind = .cli
 
-    func isAvailable(_: ProviderFetchContext) async -> Bool {
-        true
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        Self.resolvedBinary(env: context.env) != nil
     }
 
     func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
-        let keepAlive = context.settings?.debugKeepCLISessionsAlive ?? false
-        let usage = try await context.fetcher.loadLatestUsage(keepCLISessionsAlive: keepAlive)
-        let credits = await context.includeCredits
-            ? (try? context.fetcher.loadLatestCredits(keepCLISessionsAlive: keepAlive))
-            : nil
+        let snapshot = try await context.fetcher.loadLatestCLIAccountSnapshot()
+        guard let usage = snapshot.usage else {
+            guard context.includeCredits, let credits = snapshot.credits else {
+                throw UsageError.noRateLimitsFound
+            }
+            // Credits refresh can succeed even when RPC omits rate-limit windows.
+            return self.makeResult(
+                usage: UsageSnapshot(
+                    primary: nil,
+                    secondary: nil,
+                    updatedAt: credits.updatedAt,
+                    identity: nil),
+                credits: credits,
+                sourceLabel: "codex-cli")
+        }
+        let credits = context.includeCredits ? snapshot.credits : nil
         return self.makeResult(
             usage: usage,
             credits: credits,
@@ -128,55 +138,93 @@ struct CodexCLIUsageStrategy: ProviderFetchStrategy {
     func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
         false
     }
+
+    static func resolvedBinary(
+        env: [String: String],
+        loginPATH: [String]? = LoginShellPathCache.shared.current,
+        commandV: (String, String?, TimeInterval, FileManager) -> String? = ShellCommandLocator.commandV,
+        aliasResolver: (String, String?, TimeInterval, FileManager, String) -> String? = ShellCommandLocator
+            .resolveAlias,
+        fileManager: FileManager = .default,
+        home: String = NSHomeDirectory()) -> String?
+    {
+        BinaryLocator.resolveCodexBinary(
+            env: env,
+            loginPATH: loginPATH,
+            commandV: commandV,
+            aliasResolver: aliasResolver,
+            fileManager: fileManager,
+            home: home)
+    }
 }
 
 struct CodexOAuthFetchStrategy: ProviderFetchStrategy {
     let id: String = "codex.oauth"
     let kind: ProviderFetchKind = .oauth
 
-    func isAvailable(_: ProviderFetchContext) async -> Bool {
-        (try? CodexOAuthCredentialsStore.load()) != nil
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        (try? CodexOAuthCredentialsStore.load(env: context.env)) != nil
     }
 
-    func fetch(_: ProviderFetchContext) async throws -> ProviderFetchResult {
-        var credentials = try CodexOAuthCredentialsStore.load()
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        var credentials = try CodexOAuthCredentialsStore.load(env: context.env)
 
         if credentials.needsRefresh, !credentials.refreshToken.isEmpty {
             credentials = try await CodexTokenRefresher.refresh(credentials)
-            try CodexOAuthCredentialsStore.save(credentials)
+            try CodexOAuthCredentialsStore.save(credentials, env: context.env)
         }
 
         let usage = try await CodexOAuthUsageFetcher.fetchUsage(
             accessToken: credentials.accessToken,
-            accountId: credentials.accountId)
-
-        return self.makeResult(
-            usage: Self.mapUsage(usage, credentials: credentials),
-            credits: Self.mapCredits(usage.credits),
-            sourceLabel: "oauth")
+            accountId: credentials.accountId,
+            env: context.env)
+        let shouldFetchResetCredits = context.includeOptionalUsage || context.includeCredits
+        let resetCredits: CodexRateLimitResetCreditsSnapshot? = if shouldFetchResetCredits {
+            try? await CodexOAuthUsageFetcher.fetchRateLimitResetCredits(
+                accessToken: credentials.accessToken,
+                accountId: credentials.accountId,
+                env: context.env)
+        } else {
+            nil
+        }
+        let updatedAt = Date()
+        return try Self.makeResult(
+            usageResponse: usage,
+            resetCredits: resetCredits,
+            credentials: credentials,
+            updatedAt: updatedAt,
+            sourceMode: context.sourceMode)
     }
 
     func shouldFallback(on error: Error, context: ProviderFetchContext) -> Bool {
         guard context.sourceMode == .auto else { return false }
-        return true
-    }
 
-    private static func mapUsage(_ response: CodexUsageResponse, credentials: CodexOAuthCredentials) -> UsageSnapshot {
-        let primary = Self.makeWindow(response.rateLimit?.primaryWindow)
-        let secondary = Self.makeWindow(response.rateLimit?.secondaryWindow)
-
-        let identity = ProviderIdentitySnapshot(
-            providerID: .codex,
-            accountEmail: Self.resolveAccountEmail(from: credentials),
-            accountOrganization: nil,
-            loginMethod: Self.resolvePlan(response: response, credentials: credentials))
-
-        return UsageSnapshot(
-            primary: primary ?? RateWindow(usedPercent: 0, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
-            secondary: secondary,
-            tertiary: nil,
-            updatedAt: Date(),
-            identity: identity)
+        // Auto mode may launch the CLI as the next strategy. Keep that fallback
+        // limited to OAuth states the CLI can actually repair, otherwise
+        // transient API or decode failures can spawn `codex app-server`
+        // repeatedly instead of surfacing the original OAuth failure.
+        if let fetchError = error as? CodexOAuthFetchError {
+            switch fetchError {
+            case .unauthorized:
+                return true
+            case .invalidResponse, .serverError, .networkError:
+                return false
+            }
+        }
+        if let credentialsError = error as? CodexOAuthCredentialsError {
+            switch credentialsError {
+            case .notFound, .missingTokens:
+                return true
+            case .decodeFailed:
+                return false
+            }
+        }
+        switch error as? CodexTokenRefresher.RefreshError {
+        case .expired, .revoked, .reused:
+            return true
+        case .networkError, .invalidResponse, .none:
+            return false
+        }
     }
 
     private static func mapCredits(_ credits: CodexUsageResponse.CreditDetails?) -> CreditsSnapshot? {
@@ -184,47 +232,79 @@ struct CodexOAuthFetchStrategy: ProviderFetchStrategy {
         return CreditsSnapshot(remaining: balance, events: [], updatedAt: Date())
     }
 
-    private static func makeWindow(_ window: CodexUsageResponse.WindowSnapshot?) -> RateWindow? {
-        guard let window else { return nil }
-        let resetDate = Date(timeIntervalSince1970: TimeInterval(window.resetAt))
-        let resetDescription = UsageFormatter.resetDescription(from: resetDate)
-        return RateWindow(
-            usedPercent: Double(window.usedPercent),
-            windowMinutes: window.limitWindowSeconds / 60,
-            resetsAt: resetDate,
-            resetDescription: resetDescription)
-    }
+    private static func makeResult(
+        usageResponse: CodexUsageResponse,
+        resetCredits: CodexRateLimitResetCreditsSnapshot? = nil,
+        credentials: CodexOAuthCredentials,
+        updatedAt: Date,
+        sourceMode: ProviderSourceMode) throws -> ProviderFetchResult
+    {
+        let credits = Self.mapCredits(usageResponse.credits)
+        let reconciled = CodexReconciledState.fromOAuth(
+            response: usageResponse,
+            credentials: credentials,
+            updatedAt: updatedAt)
 
-    private static func resolveAccountEmail(from credentials: CodexOAuthCredentials) -> String? {
-        guard let idToken = credentials.idToken,
-              let payload = UsageFetcher.parseJWT(idToken)
-        else {
-            return nil
+        if let reconciled {
+            let dataConfidence: UsageDataConfidence = usageResponse.rateLimit?.hasWindowDecodeFailure == true
+                || usageResponse.additionalRateLimitsDecodeFailed
+                ? .unknown
+                : .exact
+            return CodexOAuthFetchStrategy().makeResult(
+                usage: reconciled.toUsageSnapshot()
+                    .withCodexResetCredits(resetCredits)
+                    .withDataConfidence(dataConfidence),
+                credits: credits,
+                sourceLabel: "oauth")
         }
 
-        let profileDict = payload["https://api.openai.com/profile"] as? [String: Any]
-        let email = (payload["email"] as? String) ?? (profileDict?["email"] as? String)
-        return email?.trimmingCharacters(in: .whitespacesAndNewlines)
-    }
-
-    private static func resolvePlan(response: CodexUsageResponse, credentials: CodexOAuthCredentials) -> String? {
-        if let plan = response.planType?.rawValue, !plan.isEmpty { return plan }
-        guard let idToken = credentials.idToken,
-              let payload = UsageFetcher.parseJWT(idToken)
-        else {
-            return nil
+        guard credits != nil || (resetCredits?.availableCount ?? 0) > 0 else {
+            throw UsageError.noRateLimitsFound
         }
-        let authDict = payload["https://api.openai.com/auth"] as? [String: Any]
-        let plan = (authDict?["chatgpt_plan_type"] as? String) ?? (payload["chatgpt_plan_type"] as? String)
-        return plan?.trimmingCharacters(in: .whitespacesAndNewlines)
+
+        // Credit balances and manual resets remain useful when OAuth omits
+        // rate-limit windows. Keep the partial result instead of discarding it.
+        return CodexOAuthFetchStrategy().makeResult(
+            usage: UsageSnapshot(
+                primary: nil,
+                secondary: nil,
+                tertiary: nil,
+                codexResetCredits: resetCredits,
+                updatedAt: updatedAt,
+                identity: CodexReconciledState.oauthIdentity(
+                    response: usageResponse,
+                    credentials: credentials)),
+            credits: credits,
+            sourceLabel: "oauth")
     }
 }
 
 #if DEBUG
 extension CodexOAuthFetchStrategy {
-    static func _mapUsageForTesting(_ data: Data, credentials: CodexOAuthCredentials) throws -> UsageSnapshot {
+    static func _mapUsageForTesting(_ data: Data, credentials: CodexOAuthCredentials) throws -> UsageSnapshot? {
         let usage = try JSONDecoder().decode(CodexUsageResponse.self, from: data)
-        return Self.mapUsage(usage, credentials: credentials)
+        return CodexReconciledState.fromOAuth(response: usage, credentials: credentials)?.toUsageSnapshot()
+    }
+
+    static func _mapResultForTesting(
+        _ data: Data,
+        credentials: CodexOAuthCredentials,
+        resetCredits: CodexRateLimitResetCreditsSnapshot? = nil,
+        sourceMode: ProviderSourceMode = .oauth) throws -> ProviderFetchResult
+    {
+        let usageResponse = try JSONDecoder().decode(CodexUsageResponse.self, from: data)
+        return try Self.makeResult(
+            usageResponse: usageResponse,
+            resetCredits: resetCredits,
+            credentials: credentials,
+            updatedAt: Date(),
+            sourceMode: sourceMode)
+    }
+}
+
+extension CodexProviderDescriptor {
+    static func _noDataMessageForTesting(env: [String: String]) -> String {
+        self.noDataMessage(env: env)
     }
 }
 #endif
diff --git a/Sources/CodexBarCore/Providers/Codex/CodexProviderSettingsBuilder.swift b/Sources/CodexBarCore/Providers/Codex/CodexProviderSettingsBuilder.swift
new file mode 100644
index 0000000000..62de1552f5
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Codex/CodexProviderSettingsBuilder.swift
@@ -0,0 +1,93 @@
+import Foundation
+
+public struct CodexProviderSettingsBuilderInput: Sendable {
+    public let usageDataSource: CodexUsageDataSource
+    public let cookieSource: ProviderCookieSource
+    public let manualCookieHeader: String?
+    public let reconciliationSnapshot: CodexAccountReconciliationSnapshot
+    public let resolvedActiveSource: CodexResolvedActiveSource
+
+    public init(
+        usageDataSource: CodexUsageDataSource,
+        cookieSource: ProviderCookieSource,
+        manualCookieHeader: String?,
+        reconciliationSnapshot: CodexAccountReconciliationSnapshot,
+        resolvedActiveSource: CodexResolvedActiveSource)
+    {
+        self.usageDataSource = usageDataSource
+        self.cookieSource = cookieSource
+        self.manualCookieHeader = manualCookieHeader
+        self.reconciliationSnapshot = reconciliationSnapshot
+        self.resolvedActiveSource = resolvedActiveSource
+    }
+}
+
+public enum CodexKnownOwnerCatalog {
+    public static func candidates(
+        from snapshot: CodexAccountReconciliationSnapshot) -> [CodexDashboardKnownOwnerCandidate]
+    {
+        var candidates = snapshot.storedAccounts.map { account in
+            CodexDashboardKnownOwnerCandidate(
+                identity: snapshot.runtimeIdentity(for: account),
+                normalizedEmail: CodexIdentityResolver.normalizeEmail(snapshot.runtimeEmail(for: account)))
+        }
+
+        if let liveSystemAccount = snapshot.liveSystemAccount {
+            candidates.append(CodexDashboardKnownOwnerCandidate(
+                identity: snapshot.runtimeIdentity(for: liveSystemAccount),
+                normalizedEmail: CodexIdentityResolver.normalizeEmail(liveSystemAccount.email)))
+        }
+
+        for profileAccount in snapshot.profileHomeAccounts {
+            candidates.append(CodexDashboardKnownOwnerCandidate(
+                identity: snapshot.runtimeIdentity(for: profileAccount),
+                normalizedEmail: CodexIdentityResolver.normalizeEmail(profileAccount.email),
+                sourceIsolationIdentifier: CookieHeaderCache.Scope.profileHome(profileAccount.codexHomePath)
+                    .isolationIdentifier))
+        }
+
+        return candidates
+    }
+}
+
+public enum CodexProviderSettingsBuilder {
+    public static func make(input: CodexProviderSettingsBuilderInput) -> ProviderSettingsSnapshot
+    .CodexProviderSettings {
+        let snapshot = input.reconciliationSnapshot
+        let persistedSource = input.resolvedActiveSource.persistedSource
+        let managedSourceSelected = switch persistedSource {
+        case .liveSystem:
+            false
+        case .managedAccount:
+            true
+        case .profileHome:
+            false
+        }
+        let openAIWebCacheScope: CookieHeaderCache.Scope? = switch input.resolvedActiveSource.resolvedSource {
+        case .liveSystem:
+            nil
+        case let .managedAccount(id):
+            .managedAccount(id)
+        case let .profileHome(path):
+            .profileHome(path)
+        }
+        let profileAccountTargetUnavailable = switch input.resolvedActiveSource.resolvedSource {
+        case .liveSystem, .managedAccount:
+            false
+        case let .profileHome(path):
+            snapshot.profileHomeAccount(path: path) == nil
+        }
+
+        return ProviderSettingsSnapshot.CodexProviderSettings(
+            usageDataSource: input.usageDataSource,
+            cookieSource: input.cookieSource,
+            manualCookieHeader: input.manualCookieHeader,
+            managedAccountStoreUnreadable: managedSourceSelected && snapshot.hasUnreadableAddedAccountStore,
+            managedAccountTargetUnavailable: managedSourceSelected
+                && snapshot.hasUnreadableAddedAccountStore == false
+                && snapshot.activeStoredAccount == nil,
+            profileAccountTargetUnavailable: profileAccountTargetUnavailable,
+            openAIWebCacheScope: openAIWebCacheScope,
+            dashboardAuthorityKnownOwners: CodexKnownOwnerCatalog.candidates(from: snapshot))
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Codex/CodexRateWindowNormalizer.swift b/Sources/CodexBarCore/Providers/Codex/CodexRateWindowNormalizer.swift
new file mode 100644
index 0000000000..018100eecd
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Codex/CodexRateWindowNormalizer.swift
@@ -0,0 +1,66 @@
+import Foundation
+
+enum CodexRateWindowNormalizer {
+    static func normalize(
+        primary: RateWindow?,
+        secondary: RateWindow?)
+        -> (primary: RateWindow?, secondary: RateWindow?)
+    {
+        switch (primary, secondary) {
+        case let (.some(primaryWindow), .some(secondaryWindow)):
+            switch (self.role(for: primaryWindow), self.role(for: secondaryWindow)) {
+            case (.session, .weekly), (.session, .unknown), (.unknown, .weekly):
+                (primaryWindow, secondaryWindow)
+            case (.weekly, .session), (.weekly, .unknown):
+                (secondaryWindow, primaryWindow)
+            default:
+                (primaryWindow, secondaryWindow)
+            }
+        case let (.some(primaryWindow), .none):
+            switch role(for: primaryWindow) {
+            case .weekly:
+                (nil, primaryWindow)
+            case .session, .unknown:
+                (primaryWindow, nil)
+            }
+        case let (.none, .some(secondaryWindow)):
+            switch self.role(for: secondaryWindow) {
+            case .session, .unknown:
+                (secondaryWindow, nil)
+            case .weekly:
+                (nil, secondaryWindow)
+            }
+        case (.none, .none):
+            (nil, nil)
+        }
+    }
+
+    private enum WindowRole {
+        case session
+        case weekly
+        case unknown
+    }
+
+    private static func role(for window: RateWindow) -> WindowRole {
+        switch window.windowMinutes {
+        case 300:
+            .session
+        case 10080:
+            .weekly
+        default:
+            .unknown
+        }
+    }
+}
+
+#if DEBUG
+extension CodexRateWindowNormalizer {
+    static func _normalizeForTesting(
+        primary: RateWindow?,
+        secondary: RateWindow?)
+        -> (primary: RateWindow?, secondary: RateWindow?)
+    {
+        self.normalize(primary: primary, secondary: secondary)
+    }
+}
+#endif
diff --git a/Sources/CodexBarCore/Providers/Codex/CodexReconciledState.swift b/Sources/CodexBarCore/Providers/Codex/CodexReconciledState.swift
new file mode 100644
index 0000000000..83f8f28d4d
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Codex/CodexReconciledState.swift
@@ -0,0 +1,149 @@
+import Foundation
+
+public struct CodexReconciledState: Sendable {
+    public let session: RateWindow?
+    public let weekly: RateWindow?
+    /// Named model-specific limits (e.g. Codex Spark) surfaced through `UsageSnapshot.extraRateWindows`.
+    public let extraRateWindows: [NamedRateWindow]
+    public let identity: ProviderIdentitySnapshot?
+    public let updatedAt: Date
+
+    public init(
+        session: RateWindow?,
+        weekly: RateWindow?,
+        extraRateWindows: [NamedRateWindow] = [],
+        identity: ProviderIdentitySnapshot?,
+        updatedAt: Date)
+    {
+        self.session = session
+        self.weekly = weekly
+        self.extraRateWindows = extraRateWindows
+        self.identity = identity
+        self.updatedAt = updatedAt
+    }
+
+    public static func fromCLI(
+        primary: RateWindow?,
+        secondary: RateWindow?,
+        identity: ProviderIdentitySnapshot?,
+        updatedAt: Date = Date()) -> CodexReconciledState?
+    {
+        self.make(primary: primary, secondary: secondary, identity: identity, updatedAt: updatedAt)
+    }
+
+    public static func fromOAuth(
+        response: CodexUsageResponse,
+        credentials: CodexOAuthCredentials,
+        updatedAt: Date = Date()) -> CodexReconciledState?
+    {
+        self.make(
+            primary: self.makeWindow(response.rateLimit?.primaryWindow),
+            secondary: self.makeWindow(response.rateLimit?.secondaryWindow),
+            extraRateWindows: CodexAdditionalRateLimitMapper.extraRateWindows(
+                from: response.additionalRateLimits,
+                now: updatedAt),
+            identity: self.oauthIdentity(response: response, credentials: credentials),
+            updatedAt: updatedAt)
+    }
+
+    public static func fromAttachedDashboard(
+        snapshot: OpenAIDashboardSnapshot,
+        provider: UsageProvider = .codex,
+        accountEmail: String? = nil,
+        accountPlan: String? = nil) -> CodexReconciledState?
+    {
+        let resolvedEmail = accountEmail ?? snapshot.signedInEmail
+        let resolvedPlan = accountPlan ?? snapshot.accountPlan
+        let identity = ProviderIdentitySnapshot(
+            providerID: provider,
+            accountEmail: resolvedEmail,
+            accountOrganization: nil,
+            loginMethod: resolvedPlan)
+
+        return self.make(
+            primary: snapshot.primaryLimit,
+            secondary: snapshot.secondaryLimit,
+            extraRateWindows: snapshot.extraRateWindows ?? [],
+            identity: identity,
+            updatedAt: snapshot.updatedAt)
+    }
+
+    public func toUsageSnapshot() -> UsageSnapshot {
+        UsageSnapshot(
+            primary: self.session,
+            secondary: self.weekly,
+            tertiary: nil,
+            extraRateWindows: self.extraRateWindows.isEmpty ? nil : self.extraRateWindows,
+            updatedAt: self.updatedAt,
+            identity: self.identity)
+    }
+
+    public static func oauthIdentity(
+        response: CodexUsageResponse,
+        credentials: CodexOAuthCredentials) -> ProviderIdentitySnapshot
+    {
+        ProviderIdentitySnapshot(
+            providerID: .codex,
+            accountEmail: self.resolveAccountEmail(from: credentials),
+            accountOrganization: nil,
+            loginMethod: self.resolvePlan(response: response, credentials: credentials))
+    }
+
+    private static func make(
+        primary: RateWindow?,
+        secondary: RateWindow?,
+        extraRateWindows: [NamedRateWindow] = [],
+        identity: ProviderIdentitySnapshot?,
+        updatedAt: Date) -> CodexReconciledState?
+    {
+        let normalized = CodexRateWindowNormalizer.normalize(primary: primary, secondary: secondary)
+        // Extra windows are supplemental, so they never resurrect a snapshot on their own: keep the
+        // existing primary/weekly gate to preserve current behavior when only extra limits are present.
+        guard normalized.primary != nil || normalized.secondary != nil else {
+            return nil
+        }
+
+        return CodexReconciledState(
+            session: normalized.primary,
+            weekly: normalized.secondary,
+            extraRateWindows: extraRateWindows,
+            identity: identity,
+            updatedAt: updatedAt)
+    }
+
+    private static func makeWindow(_ window: CodexUsageResponse.WindowSnapshot?) -> RateWindow? {
+        guard let window else { return nil }
+        let resetDate = Date(timeIntervalSince1970: TimeInterval(window.resetAt))
+        let resetDescription = UsageFormatter.resetDescription(from: resetDate)
+        return RateWindow(
+            usedPercent: Double(window.usedPercent),
+            windowMinutes: window.limitWindowSeconds / 60,
+            resetsAt: resetDate,
+            resetDescription: resetDescription)
+    }
+
+    private static func resolveAccountEmail(from credentials: CodexOAuthCredentials) -> String? {
+        guard let idToken = credentials.idToken,
+              let payload = UsageFetcher.parseJWT(idToken)
+        else {
+            return nil
+        }
+
+        let profileDict = payload["https://api.openai.com/profile"] as? [String: Any]
+        let email = (payload["email"] as? String) ?? (profileDict?["email"] as? String)
+        return email?.trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+
+    private static func resolvePlan(response: CodexUsageResponse, credentials: CodexOAuthCredentials) -> String? {
+        if let plan = response.planType?.rawValue, !plan.isEmpty { return plan }
+        guard let idToken = credentials.idToken,
+              let payload = UsageFetcher.parseJWT(idToken)
+        else {
+            return nil
+        }
+
+        let authDict = payload["https://api.openai.com/auth"] as? [String: Any]
+        let plan = (authDict?["chatgpt_plan_type"] as? String) ?? (payload["chatgpt_plan_type"] as? String)
+        return plan?.trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Codex/CodexStatusProbe.swift b/Sources/CodexBarCore/Providers/Codex/CodexStatusProbe.swift
index a04aee558a..6da6290826 100644
--- a/Sources/CodexBarCore/Providers/Codex/CodexStatusProbe.swift
+++ b/Sources/CodexBarCore/Providers/Codex/CodexStatusProbe.swift
@@ -6,6 +6,8 @@ public struct CodexStatusSnapshot: Sendable {
     public let weeklyPercentLeft: Int?
     public let fiveHourResetDescription: String?
     public let weeklyResetDescription: String?
+    public let fiveHourResetsAt: Date?
+    public let weeklyResetsAt: Date?
     public let rawText: String
 
     public init(
@@ -14,6 +16,8 @@ public struct CodexStatusSnapshot: Sendable {
         weeklyPercentLeft: Int?,
         fiveHourResetDescription: String?,
         weeklyResetDescription: String?,
+        fiveHourResetsAt: Date?,
+        weeklyResetsAt: Date?,
         rawText: String)
     {
         self.credits = credits
@@ -21,12 +25,15 @@ public struct CodexStatusSnapshot: Sendable {
         self.weeklyPercentLeft = weeklyPercentLeft
         self.fiveHourResetDescription = fiveHourResetDescription
         self.weeklyResetDescription = weeklyResetDescription
+        self.fiveHourResetsAt = fiveHourResetsAt
+        self.weeklyResetsAt = weeklyResetsAt
         self.rawText = rawText
     }
 }
 
 public enum CodexStatusProbeError: LocalizedError, Sendable {
     case codexNotInstalled
+    case launchBlocked(String)
     case parseFailed(String)
     case timedOut
     case updateRequired(String)
@@ -35,6 +42,8 @@ public enum CodexStatusProbeError: LocalizedError, Sendable {
         switch self {
         case .codexNotInstalled:
             "Codex CLI missing. Install via `npm i -g @openai/codex` (or bun install) and restart."
+        case let .launchBlocked(message):
+            message
         case .parseFailed:
             "Could not parse Codex status; will retry shortly."
         case .timedOut:
@@ -53,26 +62,32 @@ public struct CodexStatusProbe {
     public var codexBinary: String = "codex"
     public var timeout: TimeInterval = Self.defaultTimeoutSeconds
     public var keepCLISessionsAlive: Bool = false
+    public var environment: [String: String] = ProcessInfo.processInfo.environment
 
     public init() {}
 
     public init(
         codexBinary: String = "codex",
         timeout: TimeInterval = 8.0,
-        keepCLISessionsAlive: Bool = false)
+        keepCLISessionsAlive: Bool = false,
+        environment: [String: String] = ProcessInfo.processInfo.environment)
     {
         self.codexBinary = codexBinary
         self.timeout = timeout
         self.keepCLISessionsAlive = keepCLISessionsAlive
+        self.environment = environment
     }
 
     public func fetch() async throws -> CodexStatusSnapshot {
-        let env = ProcessInfo.processInfo.environment
+        let env = self.environment
         let resolved = BinaryLocator.resolveCodexBinary(env: env, loginPATH: LoginShellPathCache.shared.current)
             ?? self.codexBinary
         guard FileManager.default.isExecutableFile(atPath: resolved) || TTYCommandRunner.which(resolved) != nil else {
             throw CodexStatusProbeError.codexNotInstalled
         }
+        if let message = CodexCLILaunchGate.shared.backgroundSkipMessage(binary: resolved) {
+            throw CodexStatusProbeError.launchBlocked(message)
+        }
         do {
             return try await self.runAndParse(binary: resolved, rows: 60, cols: 200, timeout: self.timeout)
         } catch let error as CodexStatusProbeError {
@@ -87,12 +102,14 @@ public struct CodexStatusProbe {
             default:
                 throw error
             }
+        } catch {
+            throw error
         }
     }
 
     // MARK: - Parsing
 
-    public static func parse(text: String) throws -> CodexStatusSnapshot {
+    public static func parse(text: String, now: Date = .init()) throws -> CodexStatusSnapshot {
         let clean = TextParsing.stripANSICodes(text)
         guard !clean.isEmpty else { throw CodexStatusProbeError.timedOut }
         if clean.localizedCaseInsensitiveContains("data not available yet") {
@@ -119,41 +136,121 @@ public struct CodexStatusProbe {
             weeklyPercentLeft: weekPct,
             fiveHourResetDescription: fiveReset,
             weeklyResetDescription: weekReset,
+            fiveHourResetsAt: self.parseResetDate(from: fiveReset, now: now),
+            weeklyResetsAt: self.parseResetDate(from: weekReset, now: now),
             rawText: clean)
     }
 
+    private static func parseResetDate(from text: String?, now: Date) -> Date? {
+        guard var raw = text?.trimmingCharacters(in: .whitespacesAndNewlines), !raw.isEmpty else { return nil }
+        raw = raw.trimmingCharacters(in: CharacterSet(charactersIn: "()"))
+        raw = raw.replacingOccurrences(of: #"\s+"#, with: " ", options: .regularExpression)
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+
+        let calendar = Calendar(identifier: .gregorian)
+        let formatter = DateFormatter()
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        formatter.timeZone = TimeZone.current
+        formatter.defaultDate = now
+
+        if let match = raw.firstMatch(of: /^([0-9]{1,2}:[0-9]{2}) on ([0-9]{1,2} [A-Za-z]{3})$/) {
+            raw = "\(match.output.2) \(match.output.1)"
+            formatter.dateFormat = "d MMM HH:mm"
+            if let date = formatter.date(from: raw) {
+                return self.bumpYearIfNeeded(date, now: now, calendar: calendar)
+            }
+        }
+
+        if let match = raw.firstMatch(of: /^([0-9]{1,2}:[0-9]{2}) on ([A-Za-z]{3} [0-9]{1,2})$/) {
+            raw = "\(match.output.2) \(match.output.1)"
+            formatter.dateFormat = "MMM d HH:mm"
+            if let date = formatter.date(from: raw) {
+                return self.bumpYearIfNeeded(date, now: now, calendar: calendar)
+            }
+        }
+
+        for format in ["HH:mm", "H:mm"] {
+            formatter.dateFormat = format
+            if let time = formatter.date(from: raw) {
+                let components = calendar.dateComponents([.hour, .minute], from: time)
+                guard let anchored = calendar.date(
+                    bySettingHour: components.hour ?? 0,
+                    minute: components.minute ?? 0,
+                    second: 0,
+                    of: now)
+                else {
+                    return nil
+                }
+                if anchored >= now {
+                    return anchored
+                }
+                return calendar.date(byAdding: .day, value: 1, to: anchored)
+            }
+        }
+
+        return nil
+    }
+
+    private static func bumpYearIfNeeded(_ date: Date, now: Date, calendar: Calendar) -> Date? {
+        if date >= now {
+            return date
+        }
+        return calendar.date(byAdding: .year, value: 1, to: date)
+    }
+
     private func runAndParse(
         binary: String,
         rows: UInt16,
         cols: UInt16,
         timeout: TimeInterval) async throws -> CodexStatusSnapshot
     {
+        let stateHome = try CodexStatusProbeIsolation.supportDirectory(environment: self.environment)
+        let extraArgs = CodexStatusProbeIsolation.codexArguments(stateHome: stateHome)
+        let workingDirectory = CodexStatusProbeIsolation.workingDirectory(environment: self.environment)
         let text: String
         if self.keepCLISessionsAlive {
             do {
                 text = try await CodexCLISession.shared.captureStatus(
                     binary: binary,
-                    timeout: timeout,
-                    rows: rows,
-                    cols: cols)
+                    options: .init(
+                        timeout: timeout,
+                        rows: rows,
+                        cols: cols,
+                        environment: self.environment,
+                        extraArgs: extraArgs,
+                        workingDirectory: workingDirectory))
             } catch CodexCLISession.SessionError.processExited {
                 throw CodexStatusProbeError.timedOut
             } catch CodexCLISession.SessionError.timedOut {
                 throw CodexStatusProbeError.timedOut
-            } catch CodexCLISession.SessionError.launchFailed(_) {
+            } catch let CodexCLISession.SessionError.launchFailed(message) {
+                if let throttled = CodexCLILaunchGate.shared.recordLaunchFailure(binary: binary, message: message) {
+                    throw CodexStatusProbeError.launchBlocked(throttled)
+                }
                 throw CodexStatusProbeError.codexNotInstalled
             }
         } else {
             let runner = TTYCommandRunner()
-            let script = "/status\n"
-            let result = try runner.run(
-                binary: binary,
-                send: script,
-                options: .init(
-                    rows: rows,
-                    cols: cols,
-                    timeout: timeout,
-                    extraArgs: ["-s", "read-only", "-a", "untrusted"]))
+            let script = "/status"
+            let result: TTYCommandRunner.Result
+            do {
+                result = try runner.run(
+                    binary: binary,
+                    send: script,
+                    options: .init(
+                        rows: rows,
+                        cols: cols,
+                        timeout: timeout,
+                        workingDirectory: workingDirectory,
+                        extraArgs: extraArgs,
+                        baseEnvironment: self.environment,
+                        forceCodexStatusMode: true))
+            } catch let TTYCommandRunner.Error.launchFailed(message) {
+                if let throttled = CodexCLILaunchGate.shared.recordLaunchFailure(binary: binary, message: message) {
+                    throw CodexStatusProbeError.launchBlocked(throttled)
+                }
+                throw CodexStatusProbeError.codexNotInstalled
+            }
             text = result.text
         }
         return try Self.parse(text: text)
diff --git a/Sources/CodexBarCore/Providers/Codex/CodexStatusProbeIsolation.swift b/Sources/CodexBarCore/Providers/Codex/CodexStatusProbeIsolation.swift
new file mode 100644
index 0000000000..2401122e47
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Codex/CodexStatusProbeIsolation.swift
@@ -0,0 +1,46 @@
+import Foundation
+
+enum CodexStatusProbeIsolation {
+    static func supportDirectory(environment: [String: String]) throws -> URL {
+        let baseURL: URL = if let tmp = environment["TMPDIR"]?.trimmingCharacters(in: .whitespacesAndNewlines),
+                              !tmp.isEmpty
+        {
+            URL(fileURLWithPath: tmp, isDirectory: true)
+        } else {
+            FileManager.default.temporaryDirectory
+        }
+
+        let directory = baseURL
+            .appendingPathComponent("CodexBar", isDirectory: true)
+            .appendingPathComponent("CodexStatusProbe", isDirectory: true)
+        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+        return directory
+    }
+
+    static func workingDirectory(environment: [String: String]) -> URL? {
+        let home = environment["HOME"]?.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard let home, !home.isEmpty else { return nil }
+        return URL(fileURLWithPath: home, isDirectory: true)
+    }
+
+    static func codexArguments(stateHome: URL) -> [String] {
+        [
+            "-s",
+            "read-only",
+            "-a",
+            "untrusted",
+            "-c",
+            "history.persistence=\"none\"",
+            "-c",
+            "experimental_thread_store={type=\"in_memory\",id=\"codexbar-status\"}",
+            "-c",
+            "sqlite_home=\"\(self.tomlEscaped(stateHome.path))\"",
+        ]
+    }
+
+    private static func tomlEscaped(_ value: String) -> String {
+        value
+            .replacingOccurrences(of: "\\", with: "\\\\")
+            .replacingOccurrences(of: "\"", with: "\\\"")
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Codex/CodexSystemAccountObserver.swift b/Sources/CodexBarCore/Providers/Codex/CodexSystemAccountObserver.swift
new file mode 100644
index 0000000000..5b66209737
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Codex/CodexSystemAccountObserver.swift
@@ -0,0 +1,69 @@
+import Foundation
+
+public struct ObservedSystemCodexAccount: Equatable, Sendable {
+    public let email: String
+    public let workspaceLabel: String?
+    public let workspaceAccountID: String?
+    public let authFingerprint: String?
+    public let codexHomePath: String
+    public let observedAt: Date
+    public let identity: CodexIdentity
+
+    public init(
+        email: String,
+        workspaceLabel: String? = nil,
+        workspaceAccountID: String? = nil,
+        authFingerprint: String? = nil,
+        codexHomePath: String,
+        observedAt: Date,
+        identity: CodexIdentity = .unresolved)
+    {
+        self.email = email
+        self.workspaceLabel = workspaceLabel
+        self.workspaceAccountID = workspaceAccountID
+        self.authFingerprint = CodexAuthFingerprint.normalize(authFingerprint)
+        self.codexHomePath = codexHomePath
+        self.observedAt = observedAt
+        self.identity = identity
+    }
+}
+
+public protocol CodexSystemAccountObserving: Sendable {
+    func loadSystemAccount(environment: [String: String]) throws -> ObservedSystemCodexAccount?
+}
+
+public struct DefaultCodexSystemAccountObserver: CodexSystemAccountObserving {
+    private let workspaceCache: CodexOpenAIWorkspaceIdentityCache
+
+    public init(workspaceCache: CodexOpenAIWorkspaceIdentityCache = CodexOpenAIWorkspaceIdentityCache()) {
+        self.workspaceCache = workspaceCache
+    }
+
+    public func loadSystemAccount(environment: [String: String]) throws -> ObservedSystemCodexAccount? {
+        let homeURL = CodexHomeScope.ambientHomeURL(env: environment)
+        let fetcher = UsageFetcher(environment: environment)
+        let account = fetcher.loadAuthBackedCodexAccount()
+
+        guard let rawEmail = account.email?.trimmingCharacters(in: .whitespacesAndNewlines),
+              !rawEmail.isEmpty
+        else {
+            return nil
+        }
+
+        let providerAccountID: String? = switch account.identity {
+        case let .providerAccount(id):
+            ManagedCodexAccount.normalizeProviderAccountID(id)
+        case .emailOnly, .unresolved:
+            nil
+        }
+
+        return ObservedSystemCodexAccount(
+            email: rawEmail.lowercased(),
+            workspaceLabel: self.workspaceCache.workspaceLabel(for: providerAccountID),
+            workspaceAccountID: providerAccountID,
+            authFingerprint: CodexAuthFingerprint.fingerprint(homePath: homeURL.path),
+            codexHomePath: homeURL.path,
+            observedAt: Date(),
+            identity: account.identity)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Codex/CodexVisibleAccountProjection.swift b/Sources/CodexBarCore/Providers/Codex/CodexVisibleAccountProjection.swift
new file mode 100644
index 0000000000..b8ea54a387
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Codex/CodexVisibleAccountProjection.swift
@@ -0,0 +1,280 @@
+import Foundation
+
+public struct CodexVisibleAccount: Equatable, Identifiable, Sendable {
+    public let id: String
+    public let email: String
+    public let workspaceLabel: String?
+    public let workspaceAccountID: String?
+    public let authFingerprint: String?
+    public let storedAccountID: UUID?
+    public let selectionSource: CodexActiveSource
+    public let isActive: Bool
+    public let isLive: Bool
+    public let canReauthenticate: Bool
+    public let canRemove: Bool
+
+    public init(
+        id: String,
+        email: String,
+        workspaceLabel: String? = nil,
+        workspaceAccountID: String? = nil,
+        authFingerprint: String? = nil,
+        storedAccountID: UUID?,
+        selectionSource: CodexActiveSource,
+        isActive: Bool,
+        isLive: Bool,
+        canReauthenticate: Bool,
+        canRemove: Bool)
+    {
+        self.id = id
+        self.email = email
+        self.workspaceLabel = Self.normalizeWorkspaceLabel(workspaceLabel)
+        self.workspaceAccountID = workspaceAccountID
+        self.authFingerprint = CodexAuthFingerprint.normalize(authFingerprint)
+        self.storedAccountID = storedAccountID
+        self.selectionSource = selectionSource
+        self.isActive = isActive
+        self.isLive = isLive
+        self.canReauthenticate = canReauthenticate
+        self.canRemove = canRemove
+    }
+
+    public var displayName: String {
+        guard let workspaceLabel else { return self.email }
+        return "\(self.email) — \(workspaceLabel)"
+    }
+
+    public var menuDisplayName: String {
+        guard let menuWorkspaceLabel else { return self.email }
+        return "\(self.email) — \(menuWorkspaceLabel)"
+    }
+
+    public var menuWorkspaceLabel: String? {
+        guard let workspaceLabel, workspaceLabel.compare("Personal", options: [.caseInsensitive]) != .orderedSame else {
+            return nil
+        }
+        return workspaceLabel
+    }
+
+    public var authenticationHealthLabel: String? {
+        guard !self.isLive, self.storedAccountID != nil, self.authFingerprint == nil else { return nil }
+        return "Missing auth"
+    }
+
+    private static func normalizeWorkspaceLabel(_ workspaceLabel: String?) -> String? {
+        guard let trimmed = workspaceLabel?.trimmingCharacters(in: .whitespacesAndNewlines), !trimmed.isEmpty else {
+            return nil
+        }
+        return trimmed
+    }
+}
+
+public struct CodexVisibleAccountProjection: Equatable, Sendable {
+    public let visibleAccounts: [CodexVisibleAccount]
+    public let activeVisibleAccountID: String?
+    public let liveVisibleAccountID: String?
+    public let hasUnreadableAddedAccountStore: Bool
+
+    public init(
+        visibleAccounts: [CodexVisibleAccount],
+        activeVisibleAccountID: String?,
+        liveVisibleAccountID: String?,
+        hasUnreadableAddedAccountStore: Bool)
+    {
+        self.visibleAccounts = visibleAccounts
+        self.activeVisibleAccountID = activeVisibleAccountID
+        self.liveVisibleAccountID = liveVisibleAccountID
+        self.hasUnreadableAddedAccountStore = hasUnreadableAddedAccountStore
+    }
+
+    public func source(forVisibleAccountID id: String) -> CodexActiveSource? {
+        self.visibleAccounts.first { $0.id == id }?.selectionSource
+    }
+}
+
+extension DefaultCodexAccountReconciler {
+    public func loadVisibleAccounts() -> CodexVisibleAccountProjection {
+        CodexVisibleAccountProjection.make(from: self.loadSnapshot())
+    }
+}
+
+extension CodexVisibleAccountProjection {
+    public static func make(from snapshot: CodexAccountReconciliationSnapshot) -> CodexVisibleAccountProjection {
+        let resolvedActiveSource = CodexActiveSourceResolver.resolve(from: snapshot).resolvedSource
+        var drafts: [VisibleAccountDraft] = []
+
+        for storedAccount in snapshot.storedAccounts {
+            let normalizedEmail = snapshot.runtimeEmail(for: storedAccount)
+            drafts.append(VisibleAccountDraft(
+                email: normalizedEmail,
+                workspaceLabel: Self.normalizeWorkspaceLabel(storedAccount.workspaceLabel),
+                workspaceAccountID: storedAccount.workspaceAccountID,
+                authFingerprint: storedAccount.authFingerprint,
+                storedAccountID: storedAccount.id,
+                selectionSource: .managedAccount(id: storedAccount.id),
+                isLive: false,
+                canReauthenticate: true,
+                canRemove: true,
+                identity: snapshot.runtimeIdentity(for: storedAccount)))
+        }
+
+        if let liveSystemAccount = snapshot.liveSystemAccount {
+            let normalizedEmail = Self.normalizeVisibleEmail(liveSystemAccount.email)
+            let liveIdentity = snapshot.runtimeIdentity(for: liveSystemAccount)
+            if let exactStoredAccountID = snapshot.matchingStoredAccountForLiveSystemAccount?.id,
+               let exactIndex = drafts.firstIndex(where: { $0.storedAccountID == exactStoredAccountID })
+            {
+                let existingDraft = drafts[exactIndex]
+                let liveWorkspaceLabel = Self.normalizeWorkspaceLabel(liveSystemAccount.workspaceLabel)
+                drafts[exactIndex] = VisibleAccountDraft(
+                    email: existingDraft.email,
+                    workspaceLabel: liveWorkspaceLabel ?? existingDraft.workspaceLabel,
+                    workspaceAccountID: liveSystemAccount.workspaceAccountID ?? existingDraft.workspaceAccountID,
+                    authFingerprint: liveSystemAccount.authFingerprint ?? existingDraft.authFingerprint,
+                    storedAccountID: existingDraft.storedAccountID,
+                    selectionSource: .liveSystem,
+                    isLive: true,
+                    canReauthenticate: existingDraft.canReauthenticate,
+                    canRemove: existingDraft.canRemove,
+                    identity: liveIdentity)
+            } else if let existingIndex = drafts.firstIndex(where: { draft in
+                CodexIdentityMatcher.matches(
+                    draft.identity,
+                    lhsEmail: draft.email,
+                    liveIdentity,
+                    rhsEmail: normalizedEmail)
+            }) {
+                let existingDraft = drafts[existingIndex]
+                let liveWorkspaceLabel = Self.normalizeWorkspaceLabel(liveSystemAccount.workspaceLabel)
+                drafts[existingIndex] = VisibleAccountDraft(
+                    email: existingDraft.email,
+                    workspaceLabel: liveWorkspaceLabel ?? existingDraft.workspaceLabel,
+                    workspaceAccountID: liveSystemAccount.workspaceAccountID ?? existingDraft.workspaceAccountID,
+                    authFingerprint: liveSystemAccount.authFingerprint ?? existingDraft.authFingerprint,
+                    storedAccountID: existingDraft.storedAccountID,
+                    selectionSource: .liveSystem,
+                    isLive: true,
+                    canReauthenticate: existingDraft.canReauthenticate,
+                    canRemove: existingDraft.canRemove,
+                    identity: liveIdentity)
+            } else {
+                drafts.append(VisibleAccountDraft(
+                    email: normalizedEmail,
+                    workspaceLabel: Self.normalizeWorkspaceLabel(liveSystemAccount.workspaceLabel),
+                    workspaceAccountID: liveSystemAccount.workspaceAccountID,
+                    authFingerprint: liveSystemAccount.authFingerprint,
+                    storedAccountID: nil,
+                    selectionSource: .liveSystem,
+                    isLive: true,
+                    canReauthenticate: true,
+                    canRemove: false,
+                    identity: liveIdentity))
+            }
+        }
+
+        let livePath = snapshot.liveSystemAccount.flatMap { CodexHomeScope.normalizedHomePath($0.codexHomePath) }
+        let managedPaths = Set(snapshot.storedAccounts.compactMap {
+            CodexHomeScope.normalizedHomePath($0.managedHomePath)
+        })
+        for profileAccount in snapshot.profileHomeAccounts {
+            let profilePath = CodexHomeScope.normalizedHomePath(profileAccount.codexHomePath)
+            guard let profilePath,
+                  profilePath != livePath,
+                  !managedPaths.contains(profilePath)
+            else {
+                continue
+            }
+            drafts.append(VisibleAccountDraft(
+                email: Self.normalizeVisibleEmail(profileAccount.email),
+                workspaceLabel: Self.normalizeWorkspaceLabel(profileAccount.workspaceLabel),
+                workspaceAccountID: profileAccount.workspaceAccountID,
+                authFingerprint: profileAccount.authFingerprint,
+                storedAccountID: nil,
+                selectionSource: .profileHome(path: profilePath),
+                isLive: false,
+                canReauthenticate: false,
+                canRemove: false,
+                identity: snapshot.runtimeIdentity(for: profileAccount)))
+        }
+
+        let groupedByEmail = Dictionary(grouping: drafts.indices, by: { drafts[$0].email })
+        let visibleAccounts = drafts.map { draft in
+            let id = Self.visibleAccountID(for: draft, emailGroupSize: groupedByEmail[draft.email]?.count ?? 0)
+            let isActive = switch resolvedActiveSource {
+            case .liveSystem:
+                draft.selectionSource == .liveSystem
+            case let .managedAccount(id):
+                draft.selectionSource == .managedAccount(id: id)
+            case let .profileHome(path):
+                draft.selectionSource == .profileHome(path: path)
+            }
+
+            return CodexVisibleAccount(
+                id: id,
+                email: draft.email,
+                workspaceLabel: draft.workspaceLabel,
+                workspaceAccountID: draft.workspaceAccountID,
+                authFingerprint: draft.authFingerprint,
+                storedAccountID: draft.storedAccountID,
+                selectionSource: draft.selectionSource,
+                isActive: isActive,
+                isLive: draft.isLive,
+                canReauthenticate: draft.canReauthenticate,
+                canRemove: draft.canRemove)
+        }.sorted { lhs, rhs in
+            if lhs.email != rhs.email {
+                return lhs.email < rhs.email
+            }
+            if lhs.isLive != rhs.isLive {
+                return lhs.isLive && !rhs.isLive
+            }
+            if lhs.displayName != rhs.displayName {
+                return lhs.displayName < rhs.displayName
+            }
+            return lhs.id < rhs.id
+        }
+
+        return CodexVisibleAccountProjection(
+            visibleAccounts: visibleAccounts,
+            activeVisibleAccountID: visibleAccounts.first { $0.isActive }?.id,
+            liveVisibleAccountID: visibleAccounts.first { $0.isLive }?.id,
+            hasUnreadableAddedAccountStore: snapshot.hasUnreadableAddedAccountStore)
+    }
+
+    private static func normalizeVisibleEmail(_ email: String) -> String {
+        email.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+    }
+
+    private static func normalizeWorkspaceLabel(_ workspaceLabel: String?) -> String? {
+        guard let trimmed = workspaceLabel?.trimmingCharacters(in: .whitespacesAndNewlines), !trimmed.isEmpty else {
+            return nil
+        }
+        return trimmed
+    }
+
+    private static func visibleAccountID(for draft: VisibleAccountDraft, emailGroupSize: Int) -> String {
+        guard emailGroupSize > 1 else { return draft.email }
+
+        switch draft.selectionSource {
+        case .liveSystem:
+            return "live:\(CodexIdentityMatcher.selectionKey(for: draft.identity, fallbackEmail: draft.email))"
+        case let .managedAccount(id):
+            return "managed:\(id.uuidString.lowercased())"
+        case let .profileHome(path):
+            return "profile:\(path)"
+        }
+    }
+}
+
+private struct VisibleAccountDraft {
+    let email: String
+    let workspaceLabel: String?
+    let workspaceAccountID: String?
+    let authFingerprint: String?
+    let storedAccountID: UUID?
+    let selectionSource: CodexActiveSource
+    let isLive: Bool
+    let canReauthenticate: Bool
+    let canRemove: Bool
+    let identity: CodexIdentity
+}
diff --git a/Sources/CodexBarCore/Providers/Codex/CodexWebDashboardStrategy.swift b/Sources/CodexBarCore/Providers/Codex/CodexWebDashboardStrategy.swift
index b1c8e91c8b..12eedd43b5 100644
--- a/Sources/CodexBarCore/Providers/Codex/CodexWebDashboardStrategy.swift
+++ b/Sources/CodexBarCore/Providers/Codex/CodexWebDashboardStrategy.swift
@@ -9,26 +9,47 @@ public struct CodexWebDashboardStrategy: ProviderFetchStrategy {
     public init() {}
 
     public func isAvailable(_ context: ProviderFetchContext) async -> Bool {
-        context.sourceMode.usesWeb
+        context.sourceMode.usesWeb &&
+            !Self.managedAccountStoreIsUnreadable(context) &&
+            !Self.managedAccountTargetIsUnavailable(context) &&
+            (!Self.profileAccountTargetIsUnavailable(context) || context.sourceMode == .web)
     }
 
     public func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
-        // Ensure AppKit is initialized before using WebKit in a CLI.
-        await MainActor.run {
-            _ = NSApplication.shared
+        guard !Self.managedAccountStoreIsUnreadable(context) else {
+            // A fail-closed placeholder CODEX_HOME does not identify a target account. If the managed store
+            // itself is unreadable, web import must not fall back to "any signed-in browser account".
+            throw OpenAIDashboardFetcher.FetchError.loginRequired
+        }
+        guard !Self.managedAccountTargetIsUnavailable(context) else {
+            // If the selected managed account no longer exists in a readable store, web import must not
+            // fall back to "any signed-in browser account" for that stale selection.
+            throw OpenAIDashboardFetcher.FetchError.loginRequired
+        }
+        guard !Self.profileAccountTargetIsUnavailable(context) else {
+            // A profile without an auth-backed email cannot safely target browser cookie import.
+            throw OpenAIDashboardFetcher.FetchError.loginRequired
         }
 
-        let accountEmail = context.fetcher.loadAccountInfo().email?
-            .trimmingCharacters(in: .whitespacesAndNewlines)
         let options = OpenAIWebOptions(
-            timeout: context.webTimeout,
+            deadline: OpenAIDashboardFetcher.deadline(startingAt: Date(), timeout: context.webTimeout),
             debugDumpHTML: context.webDebugDumpHTML,
             verbose: context.verbose)
-        let result = try await Self.fetchOpenAIWebCodex(
-            accountEmail: accountEmail,
-            fetcher: context.fetcher,
-            options: options,
-            browserDetection: context.browserDetection)
+
+        // Ensure AppKit is initialized before using WebKit in a CLI.
+        await MainActor.run {
+            _ = NSApplication.shared
+        }
+
+        let result: OpenAIWebCodexResult
+        do {
+            result = try await Self.fetchOpenAIWebCodex(
+                context: context,
+                options: options,
+                browserDetection: context.browserDetection)
+        } catch let error as URLError where error.code == .timedOut {
+            throw OpenAIWebCodexError.timedOut(seconds: context.webTimeout)
+        }
         return self.makeResult(
             usage: result.usage,
             credits: result.credits,
@@ -37,31 +58,74 @@ public struct CodexWebDashboardStrategy: ProviderFetchStrategy {
     }
 
     public func shouldFallback(on error: Error, context: ProviderFetchContext) -> Bool {
-        guard context.sourceMode == .auto else { return false }
         _ = error
-        return true
+        return context.sourceMode == .auto
+    }
+
+    private static func managedAccountStoreIsUnreadable(_ context: ProviderFetchContext) -> Bool {
+        context.settings?.codex?.managedAccountStoreUnreadable == true
+    }
+
+    private static func managedAccountTargetIsUnavailable(_ context: ProviderFetchContext) -> Bool {
+        context.settings?.codex?.managedAccountTargetUnavailable == true
+    }
+
+    private static func profileAccountTargetIsUnavailable(_ context: ProviderFetchContext) -> Bool {
+        context.settings?.codex?.profileAccountTargetUnavailable == true
     }
 }
 
-private struct OpenAIWebCodexResult: Sendable {
+struct OpenAIWebCodexResult {
     let usage: UsageSnapshot
     let credits: CreditsSnapshot?
     let dashboard: OpenAIDashboardSnapshot
 }
 
-private enum OpenAIWebCodexError: LocalizedError {
+enum OpenAIWebCodexError: LocalizedError, Equatable {
     case missingUsage
+    case policyRejected(CodexDashboardAuthorityDecision)
+    case timedOut(seconds: TimeInterval)
 
     var errorDescription: String? {
         switch self {
         case .missingUsage:
-            "OpenAI web dashboard did not include usage limits."
+            return "OpenAI web dashboard did not include usage limits."
+        case let .timedOut(seconds):
+            return "OpenAI web dashboard fetch timed out after \(seconds.formatted()) seconds."
+        case let .policyRejected(decision):
+            switch decision.reason {
+            case let .wrongEmail(expected, actual):
+                var details: [String] = []
+                if let expected {
+                    details.append("expected \(expected)")
+                }
+                if let actual {
+                    details.append("got \(actual)")
+                }
+                if details.isEmpty {
+                    return "OpenAI web dashboard belonged to the wrong account."
+                }
+                return "OpenAI web dashboard belonged to the wrong account (\(details.joined(separator: ", ")))."
+            case .unresolvedWithoutTrustedEvidence:
+                return "Active Codex identity is unresolved and no trusted auth-backed continuity exists."
+            case .providerAccountMissingScopedEmail:
+                return "Active Codex provider account is missing its scoped email, " +
+                    "so dashboard ownership cannot be proven."
+            case .providerAccountLacksExactOwnershipProof:
+                return "OpenAI web dashboard could not be proven to belong to the active provider account."
+            case .missingDashboardSignedInEmail:
+                return "OpenAI web dashboard did not expose a signed-in email."
+            case let .sameEmailAmbiguity(email):
+                return "OpenAI web dashboard email \(email) is ambiguous across multiple known owners."
+            default:
+                return "OpenAI web dashboard was rejected by Codex dashboard authority."
+            }
         }
     }
 }
 
-private struct OpenAIWebOptions: Sendable {
-    let timeout: TimeInterval
+private struct OpenAIWebOptions {
+    let deadline: Date
     let debugDumpHTML: Bool
     let verbose: Bool
 }
@@ -96,8 +160,7 @@ private final class WebLogBuffer {
 extension CodexWebDashboardStrategy {
     @MainActor
     fileprivate static func fetchOpenAIWebCodex(
-        accountEmail: String?,
-        fetcher: UsageFetcher,
+        context: ProviderFetchContext,
         options: OpenAIWebOptions,
         browserDetection: BrowserDetection) async throws -> OpenAIWebCodexResult
     {
@@ -105,47 +168,157 @@ extension CodexWebDashboardStrategy {
         let log: @MainActor (String) -> Void = { line in
             logger.append(line)
         }
-        let dashboard = try await Self.fetchOpenAIWebDashboard(
-            accountEmail: accountEmail,
-            fetcher: fetcher,
-            options: options,
-            browserDetection: browserDetection,
-            logger: log)
-        guard let usage = dashboard.toUsageSnapshot(provider: .codex, accountEmail: accountEmail) else {
-            throw OpenAIWebCodexError.missingUsage
+        do {
+            let result = try await Self.fetchOpenAIWebDashboard(
+                context: context,
+                options: options,
+                browserDetection: browserDetection,
+                preferCachedCookieHeader: true,
+                logger: log)
+            return try Self.makeAuthorizedDashboardResult(
+                dashboard: result.dashboard,
+                context: context,
+                routingTargetEmail: result.routingTargetEmail)
+        } catch {
+            guard Self.shouldRetryWithFreshBrowserImport(after: error) else {
+                throw error
+            }
+            _ = try OpenAIDashboardBrowserCookieImporter.remainingTimeout(until: options.deadline)
+            log("Retrying OpenAI web dashboard with a fresh browser cookie import.")
+            let result = try await Self.fetchOpenAIWebDashboard(
+                context: context,
+                options: options,
+                browserDetection: browserDetection,
+                preferCachedCookieHeader: false,
+                logger: log)
+            return try Self.makeAuthorizedDashboardResult(
+                dashboard: result.dashboard,
+                context: context,
+                routingTargetEmail: result.routingTargetEmail)
         }
-        let credits = dashboard.toCreditsSnapshot()
-        return OpenAIWebCodexResult(usage: usage, credits: credits, dashboard: dashboard)
+    }
+
+    nonisolated static func shouldRetryWithFreshBrowserImport(after error: Error) -> Bool {
+        if error is OpenAIWebCodexError {
+            return error as? OpenAIWebCodexError == .missingUsage
+        }
+        if case OpenAIDashboardFetcher.FetchError.noDashboardData = error {
+            return true
+        }
+        return false
+    }
+
+    @MainActor
+    static func makeAuthorizedDashboardResultForTesting(
+        dashboard: OpenAIDashboardSnapshot,
+        context: ProviderFetchContext,
+        routingTargetEmail: String?)
+        throws -> OpenAIWebCodexResult
+    {
+        try self.makeAuthorizedDashboardResult(
+            dashboard: dashboard,
+            context: context,
+            routingTargetEmail: routingTargetEmail)
     }
 
     @MainActor
-    fileprivate static func fetchOpenAIWebDashboard(
-        accountEmail: String?,
-        fetcher: UsageFetcher,
+    private static func makeAuthorizedDashboardResult(
+        dashboard: OpenAIDashboardSnapshot,
+        context: ProviderFetchContext,
+        routingTargetEmail: String?) throws -> OpenAIWebCodexResult
+    {
+        let input = CodexCLIDashboardAuthorityContext.makeLiveWebInput(
+            dashboard: dashboard,
+            context: context,
+            routingTargetEmail: routingTargetEmail)
+        let decision = CodexDashboardAuthority.evaluate(input)
+
+        switch decision.disposition {
+        case .attach:
+            let attachedAccountEmail = CodexCLIDashboardAuthorityContext.attachmentEmail(from: input)
+            let credits = dashboard.toCreditsSnapshot()
+            let usage = dashboard.toUsageSnapshot(provider: .codex, accountEmail: attachedAccountEmail)
+                ?? Self.makeCreditsOnlyUsageSnapshot(
+                    dashboard: dashboard,
+                    attachedAccountEmail: attachedAccountEmail,
+                    credits: credits)
+            guard let usage else {
+                throw OpenAIWebCodexError.missingUsage
+            }
+            if let attachedAccountEmail {
+                OpenAIDashboardCacheStore.save(OpenAIDashboardCache(
+                    accountEmail: attachedAccountEmail,
+                    snapshot: dashboard))
+            }
+            return OpenAIWebCodexResult(usage: usage, credits: credits, dashboard: dashboard)
+        case .displayOnly:
+            if decision.cleanup.contains(.dashboardCache) {
+                OpenAIDashboardCacheStore.clear()
+            }
+            throw CodexDashboardPolicyError.displayOnly(decision)
+        case .failClosed:
+            if decision.cleanup.contains(.dashboardCache) {
+                OpenAIDashboardCacheStore.clear()
+            }
+            throw OpenAIWebCodexError.policyRejected(decision)
+        }
+    }
+
+    private static func makeCreditsOnlyUsageSnapshot(
+        dashboard: OpenAIDashboardSnapshot,
+        attachedAccountEmail: String?,
+        credits: CreditsSnapshot?) -> UsageSnapshot?
+    {
+        guard credits != nil else { return nil }
+        return UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: dashboard.updatedAt,
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: attachedAccountEmail ?? dashboard.signedInEmail,
+                accountOrganization: nil,
+                loginMethod: dashboard.accountPlan))
+    }
+
+    private struct OpenAIWebDashboardFetchResult {
+        let dashboard: OpenAIDashboardSnapshot
+        let routingTargetEmail: String?
+    }
+
+    @MainActor
+    private static func fetchOpenAIWebDashboard(
+        context: ProviderFetchContext,
         options: OpenAIWebOptions,
         browserDetection: BrowserDetection,
-        logger: @MainActor @escaping (String) -> Void) async throws -> OpenAIDashboardSnapshot
+        preferCachedCookieHeader: Bool,
+        logger: @MainActor @escaping (String) -> Void) async throws -> OpenAIWebDashboardFetchResult
     {
-        let trimmed = accountEmail?.trimmingCharacters(in: .whitespacesAndNewlines)
-        let fallback = fetcher.loadAccountInfo().email?.trimmingCharacters(in: .whitespacesAndNewlines)
-        let codexEmail = trimmed?.isEmpty == false ? trimmed : (fallback?.isEmpty == false ? fallback : nil)
-        let allowAnyAccount = codexEmail == nil
+        let auth = context.fetcher.loadAuthBackedCodexAccount()
+        let routingTargetEmail = auth.email?.trimmingCharacters(in: .whitespacesAndNewlines)
+        let allowAnyAccount = routingTargetEmail == nil
 
         let importResult = try await OpenAIDashboardBrowserCookieImporter(browserDetection: browserDetection)
-            .importBestCookies(intoAccountEmail: codexEmail, allowAnyAccount: allowAnyAccount, logger: logger)
-        let effectiveEmail = codexEmail ?? importResult.signedInEmail?
+            .importBestCookies(
+                intoAccountEmail: routingTargetEmail,
+                allowAnyAccount: allowAnyAccount,
+                preferCachedCookieHeader: preferCachedCookieHeader,
+                cacheScope: context.settings?.codex?.openAIWebCacheScope,
+                deadline: options.deadline,
+                logger: logger)
+        let effectiveEmail = routingTargetEmail ?? importResult.signedInEmail?
             .trimmingCharacters(in: .whitespacesAndNewlines)
 
-        let dash = try await OpenAIDashboardFetcher().loadLatestDashboard(
+        let dashboard = try await OpenAIDashboardFetcher().loadLatestDashboard(
             accountEmail: effectiveEmail,
+            cacheScope: context.settings?.codex?.openAIWebCacheScope,
             logger: logger,
             debugDumpHTML: options.debugDumpHTML,
-            timeout: options.timeout)
-        let cacheEmail = effectiveEmail ?? dash.signedInEmail?.trimmingCharacters(in: .whitespacesAndNewlines)
-        if let cacheEmail, !cacheEmail.isEmpty {
-            OpenAIDashboardCacheStore.save(OpenAIDashboardCache(accountEmail: cacheEmail, snapshot: dash))
-        }
-        return dash
+            timeout: OpenAIDashboardBrowserCookieImporter.remainingTimeout(until: options.deadline))
+        return OpenAIWebDashboardFetchResult(
+            dashboard: dashboard,
+            routingTargetEmail: routingTargetEmail)
     }
 }
 #else
diff --git a/Sources/CodexBarCore/Providers/CommandCode/CommandCodeCookieHeader.swift b/Sources/CodexBarCore/Providers/CommandCode/CommandCodeCookieHeader.swift
new file mode 100644
index 0000000000..f5835c80b2
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/CommandCode/CommandCodeCookieHeader.swift
@@ -0,0 +1,85 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+/// A resolved CommandCode session cookie ready to be sent on `Cookie:` headers.
+///
+/// CommandCode's API (api.commandcode.ai) authenticates with the better-auth session
+/// cookie set by commandcode.ai. better-auth emits either `better-auth.session_token`
+/// or `__Secure-better-auth.session_token` depending on whether `useSecureCookies` is
+/// enabled (the `__Secure-` variant is required by browsers for HTTPS production).
+public struct CommandCodeCookieOverride: Sendable, Equatable {
+    public let name: String
+    public let token: String
+
+    public init(name: String, token: String) {
+        self.name = name
+        self.token = token
+    }
+
+    /// `Cookie: name=value` header value.
+    public var headerValue: String {
+        "\(self.name)=\(self.token)"
+    }
+}
+
+public enum CommandCodeCookieHeader {
+    /// Cookie names used by better-auth in production (HTTPS) and dev (HTTP).
+    /// The `__Secure-` variant is the standard production deployment.
+    public static let supportedSessionCookieNames = [
+        "__Host-better-auth.session_token",
+        "__Secure-better-auth.session_token",
+        "better-auth.session_token",
+    ]
+
+    /// Extract a session cookie from a list of `HTTPCookie` records.
+    public static func sessionCookie(from cookies: [HTTPCookie]) -> CommandCodeCookieOverride? {
+        let pairs = cookies.map { (name: $0.name, value: $0.value) }
+        return self.extractSessionCookie(from: pairs)
+    }
+
+    /// Parse a raw `Cookie:` header (or bare token) and extract the session value.
+    public static func override(from raw: String?) -> CommandCodeCookieOverride? {
+        guard let raw = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !raw.isEmpty else {
+            return nil
+        }
+
+        // Bare token — assume the production cookie name.
+        if !raw.contains("="), !raw.contains(";") {
+            return CommandCodeCookieOverride(
+                name: "__Secure-better-auth.session_token",
+                token: raw)
+        }
+
+        return self.extractSessionCookie(fromHeader: raw)
+    }
+
+    private static func extractSessionCookie(fromHeader header: String) -> CommandCodeCookieOverride? {
+        var pairs: [(name: String, value: String)] = []
+        for chunk in header.split(separator: ";") {
+            let trimmed = chunk.trimmingCharacters(in: .whitespacesAndNewlines)
+            guard let separator = trimmed.firstIndex(of: "=") else { continue }
+            let key = String(trimmed[..<separator]).trimmingCharacters(in: .whitespacesAndNewlines)
+            let value = String(trimmed[trimmed.index(after: separator)...])
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+            guard !key.isEmpty, !value.isEmpty else { continue }
+            pairs.append((name: key, value: value))
+        }
+        return self.extractSessionCookie(from: pairs)
+    }
+
+    private static func extractSessionCookie(from pairs: [(name: String, value: String)])
+    -> CommandCodeCookieOverride? {
+        var byLowerName: [String: (name: String, value: String)] = [:]
+        for pair in pairs {
+            byLowerName[pair.name.lowercased()] = pair
+        }
+        for expected in self.supportedSessionCookieNames {
+            if let match = byLowerName[expected.lowercased()] {
+                return CommandCodeCookieOverride(name: match.name, token: match.value)
+            }
+        }
+        return nil
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/CommandCode/CommandCodeCookieImporter.swift b/Sources/CodexBarCore/Providers/CommandCode/CommandCodeCookieImporter.swift
new file mode 100644
index 0000000000..3db2c5293e
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/CommandCode/CommandCodeCookieImporter.swift
@@ -0,0 +1,230 @@
+import Foundation
+
+#if os(macOS)
+import SweetCookieKit
+
+/// Imports CommandCode session cookies from installed browsers (Chrome by default).
+public enum CommandCodeCookieImporter {
+    private static let importSessionCacheTTL: TimeInterval = 5
+    private static let importSessionCache = ImportSessionCache(ttl: importSessionCacheTTL)
+    private static let log = CodexBarLog.logger(LogCategories.commandcodeCookie)
+    private static let cookieClient = BrowserCookieClient()
+    private static let cookieDomains = ["commandcode.ai", "www.commandcode.ai"]
+    private static let cookieImportOrder: BrowserCookieImportOrder =
+        ProviderDefaults.metadata[.commandcode]?.browserCookieOrder ?? Browser.defaultImportOrder
+
+    public struct SessionInfo: Sendable {
+        public let cookies: [HTTPCookie]
+        public let sourceLabel: String
+
+        public init(cookies: [HTTPCookie], sourceLabel: String) {
+            self.cookies = cookies
+            self.sourceLabel = sourceLabel
+        }
+
+        public var sessionCookie: CommandCodeCookieOverride? {
+            CommandCodeCookieHeader.sessionCookie(from: self.cookies)
+        }
+
+        public var cookieHeader: String {
+            self.cookies.map { "\($0.name)=\($0.value)" }.joined(separator: "; ")
+        }
+    }
+
+    public static func importSessions(
+        browserDetection: BrowserDetection = BrowserDetection(),
+        logger: ((String) -> Void)? = nil) throws -> [SessionInfo]
+    {
+        if let cached = self.cachedImportSessions() {
+            return cached
+        }
+
+        var sessions: [SessionInfo] = []
+        let candidates = self.cookieImportOrder.cookieImportCandidates(using: browserDetection)
+        for browserSource in candidates {
+            do {
+                let perSource = try self.importSessions(from: browserSource, logger: logger)
+                sessions.append(contentsOf: perSource)
+            } catch {
+                BrowserCookieAccessGate.recordIfNeeded(error)
+                self.emit(
+                    "\(browserSource.displayName) cookie import failed: \(error.localizedDescription)",
+                    logger: logger)
+            }
+        }
+
+        guard !sessions.isEmpty else {
+            throw CommandCodeCookieImportError.noCookies
+        }
+        self.storeImportSessions(sessions)
+        return sessions
+    }
+
+    public static func importSessions(
+        from browserSource: Browser,
+        logger: ((String) -> Void)? = nil) throws -> [SessionInfo]
+    {
+        let query = BrowserCookieQuery(domains: self.cookieDomains)
+        let log: (String) -> Void = { msg in self.emit(msg, logger: logger) }
+        let sources = try Self.cookieClient.codexBarRecords(
+            matching: query,
+            in: browserSource,
+            logger: log)
+
+        var sessions: [SessionInfo] = []
+        let grouped = Dictionary(grouping: sources, by: { $0.store.profile.id })
+        let sortedGroups = grouped.values.sorted { lhs, rhs in
+            self.mergedLabel(for: lhs) < self.mergedLabel(for: rhs)
+        }
+
+        for group in sortedGroups where !group.isEmpty {
+            let label = self.mergedLabel(for: group)
+            let mergedRecords = self.mergeRecords(group)
+            guard !mergedRecords.isEmpty else { continue }
+            let httpCookies = BrowserCookieClient.makeHTTPCookies(mergedRecords, origin: query.origin)
+            guard !httpCookies.isEmpty else { continue }
+
+            let session = SessionInfo(cookies: httpCookies, sourceLabel: label)
+            if let sessionCookie = session.sessionCookie {
+                log("Found \(sessionCookie.name) cookie in \(label)")
+            } else {
+                let names = httpCookies.map(\.name).joined(separator: ", ")
+                log("No known session name in \(label); sending all domain cookies (\(names))")
+            }
+            sessions.append(session)
+        }
+        return sessions
+    }
+
+    public static func importSession(
+        browserDetection: BrowserDetection = BrowserDetection(),
+        logger: ((String) -> Void)? = nil) throws -> SessionInfo
+    {
+        let sessions = try self.importSessions(browserDetection: browserDetection, logger: logger)
+        guard let first = sessions.first else { throw CommandCodeCookieImportError.noCookies }
+        return first
+    }
+
+    public static func hasSession(
+        browserDetection: BrowserDetection = BrowserDetection(),
+        logger: ((String) -> Void)? = nil) -> Bool
+    {
+        do {
+            let session = try self.importSession(browserDetection: browserDetection, logger: logger)
+            return !session.cookies.isEmpty
+        } catch {
+            return false
+        }
+    }
+
+    static func invalidateImportSessionCache() {
+        self.importSessionCache.invalidate()
+    }
+
+    private static func emit(_ message: String, logger: ((String) -> Void)?) {
+        logger?("[commandcode-cookie] \(message)")
+        self.log.debug(message)
+    }
+
+    private static func cachedImportSessions(now: Date = Date()) -> [SessionInfo]? {
+        self.importSessionCache.load(now: now)
+    }
+
+    private static func storeImportSessions(_ sessions: [SessionInfo], now: Date = Date()) {
+        self.importSessionCache.store(sessions, now: now)
+    }
+
+    private static func mergedLabel(for sources: [BrowserCookieStoreRecords]) -> String {
+        guard let base = sources.map(\.label).min() else { return "Unknown" }
+        if base.hasSuffix(" (Network)") {
+            return String(base.dropLast(" (Network)".count))
+        }
+        return base
+    }
+
+    private static func mergeRecords(_ sources: [BrowserCookieStoreRecords]) -> [BrowserCookieRecord] {
+        let sortedSources = sources.sorted { lhs, rhs in
+            self.storePriority(lhs.store.kind) < self.storePriority(rhs.store.kind)
+        }
+        var mergedByKey: [String: BrowserCookieRecord] = [:]
+        for source in sortedSources {
+            for record in source.records {
+                let key = self.recordKey(record)
+                if let existing = mergedByKey[key] {
+                    if self.shouldReplace(existing: existing, candidate: record) {
+                        mergedByKey[key] = record
+                    }
+                } else {
+                    mergedByKey[key] = record
+                }
+            }
+        }
+        return Array(mergedByKey.values)
+    }
+
+    private static func storePriority(_ kind: BrowserCookieStoreKind) -> Int {
+        switch kind {
+        case .network: 0
+        case .primary: 1
+        case .safari: 2
+        }
+    }
+
+    private static func recordKey(_ record: BrowserCookieRecord) -> String {
+        "\(record.name)|\(record.domain)|\(record.path)"
+    }
+
+    private static func shouldReplace(existing: BrowserCookieRecord, candidate: BrowserCookieRecord) -> Bool {
+        switch (existing.expires, candidate.expires) {
+        case let (lhs?, rhs?): rhs > lhs
+        case (nil, .some): true
+        case (.some, nil): false
+        case (nil, nil): false
+        }
+    }
+
+    private final class ImportSessionCache: @unchecked Sendable {
+        private let ttl: TimeInterval
+        private let lock = NSLock()
+        private var entry: (sessions: [SessionInfo], expiresAt: Date)?
+
+        init(ttl: TimeInterval) {
+            self.ttl = ttl
+        }
+
+        func load(now: Date) -> [SessionInfo]? {
+            self.lock.lock()
+            defer { self.lock.unlock() }
+            guard let entry = self.entry else { return nil }
+            guard entry.expiresAt > now else {
+                self.entry = nil
+                return nil
+            }
+            return entry.sessions
+        }
+
+        func store(_ sessions: [SessionInfo], now: Date) {
+            self.lock.lock()
+            defer { self.lock.unlock() }
+            self.entry = (sessions: sessions, expiresAt: now.addingTimeInterval(self.ttl))
+        }
+
+        func invalidate() {
+            self.lock.lock()
+            defer { self.lock.unlock() }
+            self.entry = nil
+        }
+    }
+}
+
+public enum CommandCodeCookieImportError: LocalizedError {
+    case noCookies
+
+    public var errorDescription: String? {
+        switch self {
+        case .noCookies:
+            "No Command Code session cookies found in browsers. Sign in to commandcode.ai."
+        }
+    }
+}
+#endif
diff --git a/Sources/CodexBarCore/Providers/CommandCode/CommandCodePlanCatalog.swift b/Sources/CodexBarCore/Providers/CommandCode/CommandCodePlanCatalog.swift
new file mode 100644
index 0000000000..16c7bcea26
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/CommandCode/CommandCodePlanCatalog.swift
@@ -0,0 +1,34 @@
+import Foundation
+
+/// Static catalog of CommandCode subscription plans → monthly credit allowance (in USD).
+///
+/// The `/internal/billing/credits` endpoint exposes the *remaining* `monthlyCredits`,
+/// not the plan total. The plan total is published on the public pricing page
+/// (https://commandcode.ai/pricing) and is keyed by `planId` returned from
+/// `/internal/billing/subscriptions`.
+public enum CommandCodePlanCatalog {
+    public struct Plan: Sendable, Equatable {
+        public let id: String
+        public let displayName: String
+        /// Monthly credit allowance in USD.
+        public let monthlyCreditsUSD: Double
+
+        public init(id: String, displayName: String, monthlyCreditsUSD: Double) {
+            self.id = id
+            self.displayName = displayName
+            self.monthlyCreditsUSD = monthlyCreditsUSD
+        }
+    }
+
+    public static let plans: [Plan] = [
+        Plan(id: "individual-go", displayName: "Go", monthlyCreditsUSD: 10),
+        Plan(id: "individual-pro", displayName: "Pro", monthlyCreditsUSD: 30),
+        Plan(id: "individual-max", displayName: "Max", monthlyCreditsUSD: 150),
+        Plan(id: "individual-ultra", displayName: "Ultra", monthlyCreditsUSD: 300),
+    ]
+
+    public static func plan(forID planID: String) -> Plan? {
+        let normalized = planID.lowercased()
+        return self.plans.first(where: { $0.id == normalized })
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/CommandCode/CommandCodeProviderDescriptor.swift b/Sources/CodexBarCore/Providers/CommandCode/CommandCodeProviderDescriptor.swift
new file mode 100644
index 0000000000..c348d7901c
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/CommandCode/CommandCodeProviderDescriptor.swift
@@ -0,0 +1,98 @@
+import Foundation
+
+public enum CommandCodeProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .commandcode,
+            metadata: ProviderMetadata(
+                id: .commandcode,
+                displayName: "Command Code",
+                sessionLabel: "Monthly credits",
+                weeklyLabel: "Monthly",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: true,
+                creditsHint: "Monthly USD credits from Command Code billing.",
+                toggleTitle: "Show Command Code usage",
+                cliName: "commandcode",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                browserCookieOrder: ProviderBrowserCookieDefaults.defaultImportOrder,
+                dashboardURL: "https://commandcode.ai/studio",
+                subscriptionDashboardURL: "https://commandcode.ai/sixhobbits/settings/billing",
+                statusPageURL: nil,
+                statusLinkURL: nil),
+            branding: ProviderBranding(
+                iconStyle: .commandcode,
+                iconResourceName: "ProviderIcon-commandcode",
+                color: ProviderColor(red: 0 / 255, green: 0 / 255, blue: 0 / 255)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "Command Code cost summary is not yet supported." }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .web],
+                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [CommandCodeWebFetchStrategy()] })),
+            cli: ProviderCLIConfig(
+                name: "commandcode",
+                aliases: ["command-code"],
+                versionDetector: nil))
+    }
+}
+
+struct CommandCodeWebFetchStrategy: ProviderFetchStrategy {
+    let id: String = "commandcode.web"
+    let kind: ProviderFetchKind = .web
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        guard context.settings?.commandcode?.cookieSource != .off else { return false }
+        if Self.manualCookieHeader(from: context) != nil {
+            return true
+        }
+        #if os(macOS)
+        return true
+        #else
+        return false
+        #endif
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        let cookieHeader: String
+        let sourceLabel: String
+        if let manual = Self.manualCookieHeader(from: context) {
+            cookieHeader = manual
+            sourceLabel = "manual"
+        } else {
+            #if os(macOS)
+            let session: CommandCodeCookieImporter.SessionInfo
+            do {
+                session = try CommandCodeCookieImporter.importSession()
+            } catch {
+                throw CommandCodeUsageError.missingCredentials
+            }
+            guard !session.cookies.isEmpty else {
+                throw CommandCodeUsageError.missingCredentials
+            }
+            cookieHeader = session.cookieHeader
+            sourceLabel = session.sourceLabel
+            #else
+            throw CommandCodeUsageError.missingCredentials
+            #endif
+        }
+        let snapshot = try await CommandCodeUsageFetcher.fetchUsage(cookieHeader: cookieHeader)
+        return self.makeResult(
+            usage: snapshot.toUsageSnapshot(),
+            sourceLabel: sourceLabel)
+    }
+
+    private static func manualCookieHeader(from context: ProviderFetchContext) -> String? {
+        guard context.settings?.commandcode?.cookieSource == .manual else { return nil }
+        return CookieHeaderNormalizer.normalize(context.settings?.commandcode?.manualCookieHeader)
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/CommandCode/CommandCodeUsageError.swift b/Sources/CodexBarCore/Providers/CommandCode/CommandCodeUsageError.swift
new file mode 100644
index 0000000000..9e13b8914a
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/CommandCode/CommandCodeUsageError.swift
@@ -0,0 +1,34 @@
+import Foundation
+
+public enum CommandCodeUsageError: LocalizedError, Sendable, Equatable {
+    case missingCredentials
+    case invalidCredentials
+    case networkError(String)
+    case apiError(Int)
+    case parseFailed(String)
+    case unknownPlan(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingCredentials:
+            "Command Code session cookie not found. Sign in to commandcode.ai in Chrome."
+        case .invalidCredentials:
+            "Command Code session is invalid or expired. Sign in to commandcode.ai again."
+        case let .networkError(message):
+            "Command Code network error: \(message)"
+        case let .apiError(status):
+            "Command Code API returned status \(status)."
+        case let .parseFailed(message):
+            "Could not parse Command Code response: \(message)"
+        case let .unknownPlan(planID):
+            "Unknown Command Code plan: \(planID). Add it to CommandCodePlanCatalog."
+        }
+    }
+
+    public var isAuthRelated: Bool {
+        switch self {
+        case .missingCredentials, .invalidCredentials: true
+        default: false
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/CommandCode/CommandCodeUsageFetcher.swift b/Sources/CodexBarCore/Providers/CommandCode/CommandCodeUsageFetcher.swift
new file mode 100644
index 0000000000..74b8d92763
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/CommandCode/CommandCodeUsageFetcher.swift
@@ -0,0 +1,263 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+/// Fetches live billing data from `api.commandcode.ai` using a better-auth session
+/// cookie scraped from the user's browser.
+public enum CommandCodeUsageFetcher {
+    private static let log = CodexBarLog.logger(LogCategories.commandcodeUsage)
+    private static let requestTimeoutSeconds: TimeInterval = 15
+    private static let subscriptionGraceSeconds: TimeInterval = 2
+    private static let apiBase = URL(string: "https://api.commandcode.ai")!
+    private static let creditsPath = "/internal/billing/credits"
+    private static let subscriptionsPath = "/internal/billing/subscriptions"
+    private static let webOrigin = "https://commandcode.ai"
+    private static let userAgent =
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) " +
+        "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36"
+
+    public static func fetchUsage(
+        cookieHeader: String,
+        session transport: any ProviderHTTPTransport = ProviderHTTPClient.shared,
+        now: Date = Date()) async throws -> CommandCodeUsageSnapshot
+    {
+        try await self.fetchUsage(
+            cookieHeader: cookieHeader,
+            transport: transport,
+            now: now,
+            subscriptionGrace: .seconds(self.subscriptionGraceSeconds))
+    }
+
+    static func _fetchUsageForTesting(
+        cookieHeader: String,
+        transport: any ProviderHTTPTransport,
+        now: Date = Date(),
+        subscriptionGrace: Duration) async throws -> CommandCodeUsageSnapshot
+    {
+        try await self.fetchUsage(
+            cookieHeader: cookieHeader,
+            transport: transport,
+            now: now,
+            subscriptionGrace: subscriptionGrace)
+    }
+
+    private static func fetchUsage(
+        cookieHeader: String,
+        transport: any ProviderHTTPTransport,
+        now: Date,
+        subscriptionGrace: Duration) async throws -> CommandCodeUsageSnapshot
+    {
+        let (credits, subscription, subscriptionEnrichmentUnavailable) = try await self.fetchPayloads(
+            cookieHeader: cookieHeader,
+            transport: transport,
+            subscriptionGrace: subscriptionGrace)
+
+        let plan: CommandCodePlanCatalog.Plan? = subscription.flatMap { sub in
+            CommandCodePlanCatalog.plan(forID: sub.planID)
+        }
+
+        // If we got an active subscription with an unrecognised plan ID, surface that
+        // explicitly rather than silently dropping the totals row.
+        if let sub = subscription, sub.status.lowercased() == "active", plan == nil {
+            Self.log.error("Unknown CommandCode planId: \(sub.planID)")
+            throw CommandCodeUsageError.unknownPlan(sub.planID)
+        }
+
+        return CommandCodeUsageSnapshot(
+            monthlyCreditsRemaining: credits.monthlyCredits,
+            purchasedCredits: credits.purchasedCredits,
+            premiumMonthlyCredits: credits.premiumMonthlyCredits,
+            opensourceMonthlyCredits: credits.opensourceMonthlyCredits,
+            plan: plan,
+            billingPeriodEnd: subscription?.currentPeriodEnd,
+            subscriptionStatus: subscription?.status,
+            subscriptionEnrichmentUnavailable: subscriptionEnrichmentUnavailable,
+            updatedAt: now)
+    }
+
+    private static func fetchPayloads(
+        cookieHeader: String,
+        transport: any ProviderHTTPTransport,
+        subscriptionGrace: Duration) async throws -> (CreditsPayload, SubscriptionPayload?, Bool)
+    {
+        let subscriptionTask = Task<SubscriptionPayload?, Error> {
+            try await self.fetchSubscription(cookieHeader: cookieHeader, transport: transport)
+        }
+        let credits: CreditsPayload
+        do {
+            credits = try await withTaskCancellationHandler {
+                try await self.fetchCredits(cookieHeader: cookieHeader, transport: transport)
+            } onCancel: {
+                subscriptionTask.cancel()
+            }
+        } catch {
+            subscriptionTask.cancel()
+            throw error
+        }
+
+        do {
+            try Task.checkCancellation()
+        } catch {
+            subscriptionTask.cancel()
+            throw error
+        }
+        let race = BoundedTaskJoin(sourceTask: subscriptionTask)
+        switch await race.value(joinGrace: subscriptionGrace) {
+        case let .value(subscription):
+            try Task.checkCancellation()
+            return (credits, subscription, false)
+        case .timedOut:
+            try Task.checkCancellation()
+            Self.log.warning("Command Code subscription enrichment timed out")
+            return (credits, nil, true)
+        case let .failure(error):
+            subscriptionTask.cancel()
+            try Task.checkCancellation()
+            Self.log.warning("Command Code subscription enrichment failed: \(error.localizedDescription)")
+            return (credits, nil, true)
+        }
+    }
+
+    // MARK: - Endpoints
+
+    struct CreditsPayload {
+        let monthlyCredits: Double
+        let purchasedCredits: Double
+        let premiumMonthlyCredits: Double
+        let opensourceMonthlyCredits: Double
+    }
+
+    struct SubscriptionPayload {
+        let planID: String
+        let status: String
+        let currentPeriodEnd: Date?
+    }
+
+    private static func fetchCredits(
+        cookieHeader: String,
+        transport: any ProviderHTTPTransport) async throws -> CreditsPayload
+    {
+        let url = self.apiBase.appendingPathComponent(self.creditsPath)
+        let data = try await self.send(url: url, cookieHeader: cookieHeader, transport: transport)
+        return try self.parseCredits(data: data)
+    }
+
+    private static func fetchSubscription(
+        cookieHeader: String,
+        transport: any ProviderHTTPTransport) async throws -> SubscriptionPayload?
+    {
+        let url = self.apiBase.appendingPathComponent(self.subscriptionsPath)
+        let data = try await self.send(url: url, cookieHeader: cookieHeader, transport: transport)
+        return try self.parseSubscription(data: data)
+    }
+
+    private static func send(
+        url: URL,
+        cookieHeader: String,
+        transport: any ProviderHTTPTransport) async throws -> Data
+    {
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.timeoutInterval = self.requestTimeoutSeconds
+        request.setValue(cookieHeader, forHTTPHeaderField: "Cookie")
+        request.setValue("application/json, text/plain, */*", forHTTPHeaderField: "Accept")
+        request.setValue("en-US,en;q=0.9", forHTTPHeaderField: "Accept-Language")
+        request.setValue(self.userAgent, forHTTPHeaderField: "User-Agent")
+        request.setValue(self.webOrigin, forHTTPHeaderField: "Origin")
+        request.setValue("\(self.webOrigin)/", forHTTPHeaderField: "Referer")
+
+        let response: ProviderHTTPResponse
+        do {
+            response = try await transport.response(for: request)
+        } catch {
+            if error is CancellationError || (error as? URLError)?.code == .cancelled || Task.isCancelled {
+                throw CancellationError()
+            }
+            throw CommandCodeUsageError.networkError(error.localizedDescription)
+        }
+        if response.statusCode == 401 || response.statusCode == 403 {
+            throw CommandCodeUsageError.invalidCredentials
+        }
+        guard (200..<300).contains(response.statusCode) else {
+            let body = String(data: response.data, encoding: .utf8) ?? ""
+            Self.log.error("CommandCode \(url.path) → \(response.statusCode): \(body)")
+            throw CommandCodeUsageError.apiError(response.statusCode)
+        }
+        return response.data
+    }
+
+    // MARK: - Parsing
+
+    static func parseCredits(data: Data) throws -> CreditsPayload {
+        guard let root = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+            throw CommandCodeUsageError.parseFailed("Credits: invalid JSON")
+        }
+        guard let credits = root["credits"] as? [String: Any] else {
+            throw CommandCodeUsageError.parseFailed("Credits: missing 'credits' object")
+        }
+        guard let monthly = self.double(from: credits["monthlyCredits"]) else {
+            throw CommandCodeUsageError.parseFailed("Credits: missing monthlyCredits")
+        }
+        return CreditsPayload(
+            monthlyCredits: monthly,
+            purchasedCredits: self.double(from: credits["purchasedCredits"]) ?? 0,
+            premiumMonthlyCredits: self.double(from: credits["premiumMonthlyCredits"]) ?? 0,
+            opensourceMonthlyCredits: self.double(from: credits["opensourceMonthlyCredits"]) ?? 0)
+    }
+
+    static func parseSubscription(data: Data) throws -> SubscriptionPayload? {
+        guard let root = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+            throw CommandCodeUsageError.parseFailed("Subscriptions: invalid JSON")
+        }
+        // Only an explicit successful null response identifies the free tier. Failure envelopes are transient.
+        guard let success = root["success"] as? Bool else {
+            throw CommandCodeUsageError.parseFailed("Subscriptions: missing success flag")
+        }
+        guard success else {
+            throw CommandCodeUsageError.parseFailed("Subscriptions: unsuccessful response")
+        }
+        guard let dataValue = root["data"] else {
+            throw CommandCodeUsageError.parseFailed("Subscriptions: missing data")
+        }
+        if dataValue is NSNull {
+            return nil
+        }
+        guard let data = dataValue as? [String: Any] else {
+            throw CommandCodeUsageError.parseFailed("Subscriptions: invalid data")
+        }
+        guard let planID = data["planId"] as? String, !planID.isEmpty else {
+            throw CommandCodeUsageError.parseFailed("Subscriptions: missing planId")
+        }
+        let status = (data["status"] as? String) ?? "unknown"
+        let periodEnd = self.date(from: data["currentPeriodEnd"])
+        return SubscriptionPayload(planID: planID, status: status, currentPeriodEnd: periodEnd)
+    }
+
+    // MARK: - Value coercion
+
+    private static func double(from value: Any?) -> Double? {
+        switch value {
+        case let n as NSNumber:
+            let d = n.doubleValue
+            return d.isFinite ? d : nil
+        case let s as String:
+            let trimmed = s.trimmingCharacters(in: .whitespacesAndNewlines)
+            return Double(trimmed)
+        default:
+            return nil
+        }
+    }
+
+    private static func date(from value: Any?) -> Date? {
+        guard let s = value as? String else { return nil }
+        let trimmed = s.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else { return nil }
+        let fractional = ISO8601DateFormatter()
+        fractional.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        if let date = fractional.date(from: trimmed) { return date }
+        let plain = ISO8601DateFormatter()
+        plain.formatOptions = [.withInternetDateTime]
+        return plain.date(from: trimmed)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/CommandCode/CommandCodeUsageSnapshot.swift b/Sources/CodexBarCore/Providers/CommandCode/CommandCodeUsageSnapshot.swift
new file mode 100644
index 0000000000..b5747a9763
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/CommandCode/CommandCodeUsageSnapshot.swift
@@ -0,0 +1,124 @@
+import Foundation
+
+/// Parsed view of CommandCode `/internal/billing/credits` + `/internal/billing/subscriptions`.
+public struct CommandCodeUsageSnapshot: Sendable {
+    /// USD remaining in the current monthly grant (`credits.monthlyCredits`).
+    public let monthlyCreditsRemaining: Double
+    /// USD top-up balance carried over (`credits.purchasedCredits`).
+    public let purchasedCredits: Double
+    /// USD remaining in the premium monthly grant (`credits.premiumMonthlyCredits`).
+    public let premiumMonthlyCredits: Double
+    /// USD remaining in the open-source monthly grant (`credits.opensourceMonthlyCredits`).
+    public let opensourceMonthlyCredits: Double
+    /// Subscription plan, or nil when the user is on the free tier.
+    public let plan: CommandCodePlanCatalog.Plan?
+    /// `currentPeriodEnd` from the active subscription.
+    public let billingPeriodEnd: Date?
+    /// Subscription status (e.g. `active`, `canceled`).
+    public let subscriptionStatus: String?
+    /// The optional subscription request timed out or failed for this refresh.
+    public let subscriptionEnrichmentUnavailable: Bool
+    public let updatedAt: Date
+
+    public init(
+        monthlyCreditsRemaining: Double,
+        purchasedCredits: Double,
+        premiumMonthlyCredits: Double,
+        opensourceMonthlyCredits: Double,
+        plan: CommandCodePlanCatalog.Plan?,
+        billingPeriodEnd: Date?,
+        subscriptionStatus: String?,
+        subscriptionEnrichmentUnavailable: Bool = false,
+        updatedAt: Date = Date())
+    {
+        self.monthlyCreditsRemaining = monthlyCreditsRemaining
+        self.purchasedCredits = purchasedCredits
+        self.premiumMonthlyCredits = premiumMonthlyCredits
+        self.opensourceMonthlyCredits = opensourceMonthlyCredits
+        self.plan = plan
+        self.billingPeriodEnd = billingPeriodEnd
+        self.subscriptionStatus = subscriptionStatus
+        self.subscriptionEnrichmentUnavailable = subscriptionEnrichmentUnavailable
+        self.updatedAt = updatedAt
+    }
+
+    /// USD allocation for the active monthly grant (from the catalog).
+    public var monthlyCreditsTotal: Double? {
+        self.plan?.monthlyCreditsUSD
+    }
+
+    /// USD spent in the current monthly grant (total – remaining), clamped to [0, total].
+    public var monthlyCreditsUsed: Double? {
+        guard let total = self.monthlyCreditsTotal else { return nil }
+        return max(0, min(total, total - self.monthlyCreditsRemaining))
+    }
+
+    public func toUsageSnapshot() -> UsageSnapshot {
+        let primary = self.makePrimaryWindow()
+
+        let identity = ProviderIdentitySnapshot(
+            providerID: .commandcode,
+            accountEmail: nil,
+            accountOrganization: nil,
+            loginMethod: self.makeLoginMethod())
+
+        return UsageSnapshot(
+            primary: primary,
+            secondary: nil,
+            tertiary: nil,
+            providerCost: nil,
+            commandCodeSubscriptionEnrichmentUnavailable: self.subscriptionEnrichmentUnavailable,
+            commandCodeHasSubscriptionPlan: self.plan != nil,
+            commandCodeMonthlyGrantDepleted: self.monthlyCreditsRemaining <= 0,
+            updatedAt: self.updatedAt,
+            identity: identity)
+    }
+
+    private func makePrimaryWindow() -> RateWindow? {
+        guard let total = self.monthlyCreditsTotal, total > 0 else {
+            // Free / unknown plan with no allowance — surface 100% so the bar renders empty.
+            if self.monthlyCreditsRemaining > 0 || self.purchasedCredits > 0 {
+                return RateWindow(
+                    usedPercent: 0,
+                    windowMinutes: nil,
+                    resetsAt: self.billingPeriodEnd,
+                    resetDescription: nil)
+            }
+            return nil
+        }
+        let used = self.monthlyCreditsUsed ?? 0
+        let percent = min(100, max(0, (used / total) * 100))
+        return RateWindow(
+            usedPercent: percent,
+            windowMinutes: nil,
+            resetsAt: self.billingPeriodEnd,
+            resetDescription: nil)
+    }
+
+    private func makeLoginMethod() -> String? {
+        var parts: [String] = []
+        if let name = self.plan?.displayName, !name.isEmpty {
+            parts.append(name)
+        }
+        if let total = self.monthlyCreditsTotal {
+            let used = self.monthlyCreditsUsed ?? 0
+            parts.append("\(Self.formatUSD(used)) of \(Self.formatUSD(total))")
+        } else if self.monthlyCreditsRemaining > 0 {
+            parts.append("\(Self.formatUSD(self.monthlyCreditsRemaining)) remaining")
+        }
+        if self.purchasedCredits > 0 {
+            parts.append("+ \(Self.formatUSD(self.purchasedCredits)) credits")
+        }
+        return parts.isEmpty ? nil : parts.joined(separator: " · ")
+    }
+
+    static func formatUSD(_ value: Double) -> String {
+        let formatter = NumberFormatter()
+        formatter.numberStyle = .currency
+        formatter.currencyCode = "USD"
+        formatter.locale = Locale(identifier: "en_US")
+        formatter.maximumFractionDigits = value < 100 ? 2 : 0
+        formatter.minimumFractionDigits = value < 100 ? 2 : 0
+        return formatter.string(from: NSNumber(value: value)) ?? "$\(value)"
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Copilot/CopilotBudgetWebFetcher.swift b/Sources/CodexBarCore/Providers/Copilot/CopilotBudgetWebFetcher.swift
new file mode 100644
index 0000000000..4c599fd6ef
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Copilot/CopilotBudgetWebFetcher.swift
@@ -0,0 +1,801 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+#if os(macOS)
+import SweetCookieKit
+#endif
+
+public struct CopilotBudgetWebFetcher: Sendable {
+    public enum Error: Swift.Error, LocalizedError, Equatable {
+        case noSessionCookie
+        case notLoggedIn
+        case accountMismatch(expected: String, actual: String?)
+        case badStatus(Int)
+        case invalidResponse
+
+        public var errorDescription: String? {
+            switch self {
+            case .noSessionCookie:
+                "No GitHub browser session cookie found."
+            case .notLoggedIn:
+                "GitHub browser session is not logged in."
+            case let .accountMismatch(expected, actual):
+                "GitHub browser session belongs to \(actual ?? "an unknown account"), expected \(expected)."
+            case let .badStatus(status):
+                "GitHub budgets request failed with HTTP \(status)."
+            case .invalidResponse:
+                "GitHub budgets response could not be decoded."
+            }
+        }
+    }
+
+    struct BudgetResponse: Decodable {
+        let budgets: [Budget]
+        let hasNextPage: Bool?
+
+        private enum CodingKeys: String, CodingKey {
+            case budgets
+            case payload
+            case hasNextPage
+            case hasNextPageSnake = "has_next_page"
+        }
+
+        init(budgets: [Budget], hasNextPage: Bool? = nil) {
+            self.budgets = budgets
+            self.hasNextPage = hasNextPage
+        }
+
+        init(from decoder: Decoder) throws {
+            let container = try decoder.container(keyedBy: CodingKeys.self)
+            if let payload = try container.decodeIfPresent(BudgetResponse.self, forKey: .payload) {
+                self = payload
+                return
+            }
+            self.budgets = try container.decodeIfPresent([Budget].self, forKey: .budgets) ?? []
+            self.hasNextPage = try container.decodeIfPresent(Bool.self, forKey: .hasNextPage)
+                ?? container.decodeIfPresent(Bool.self, forKey: .hasNextPageSnake)
+        }
+    }
+
+    struct Budget: Decodable, Equatable {
+        let id: String?
+        let name: String?
+        let budgetType: String?
+        let budgetProductSkus: [String]
+        let budgetScope: String?
+        let budgetEntityName: String?
+        let budgetAmount: Double
+        let currentAmount: Double
+
+        init(
+            id: String? = nil,
+            name: String? = nil,
+            budgetType: String? = nil,
+            budgetProductSkus: [String] = [],
+            budgetScope: String? = nil,
+            budgetEntityName: String? = nil,
+            budgetAmount: Double,
+            currentAmount: Double = 0)
+        {
+            self.id = id
+            self.name = name
+            self.budgetType = budgetType
+            self.budgetProductSkus = budgetProductSkus
+            self.budgetScope = budgetScope
+            self.budgetEntityName = budgetEntityName
+            self.budgetAmount = budgetAmount
+            self.currentAmount = currentAmount
+        }
+
+        init(from decoder: Decoder) throws {
+            let container = try decoder.container(keyedBy: DynamicCodingKey.self)
+            self.id = Self.decodeString(container: container, keys: ["id", "uuid", "budget_id", "budgetId"])
+            self.name = Self.decodeString(container: container, keys: ["name", "display_name", "displayName", "title"])
+            self.budgetType = Self.decodeString(
+                container: container,
+                keys: ["budget_type", "budgetType", "type", "pricing_target_type", "pricingTargetType"])
+            self.budgetProductSkus = Self.decodeStringArray(
+                container: container,
+                keys: [
+                    "budget_product_skus",
+                    "budgetProductSkus",
+                    "budget_product_sku",
+                    "budgetProductSku",
+                    "product_skus",
+                    "productSkus",
+                    "skus",
+                    "sku",
+                    "product",
+                    "product_name",
+                    "productName",
+                    "pricing_target_id",
+                    "pricingTargetId",
+                ])
+            self.budgetScope = Self.decodeString(container: container, keys: ["budget_scope", "budgetScope", "scope"])
+            self.budgetEntityName = Self.decodeString(
+                container: container,
+                keys: [
+                    "budget_entity_name",
+                    "budgetEntityName",
+                    "entity_name",
+                    "entityName",
+                    "target_name",
+                    "targetName",
+                ])
+            self.budgetAmount = Self.decodeDouble(
+                container: container,
+                keys: [
+                    "budget_amount",
+                    "budgetAmount",
+                    "target_amount",
+                    "targetAmount",
+                    "spending_limit",
+                    "spendingLimit",
+                    "limit",
+                    "amount",
+                    "max",
+                ]) ?? 0
+            self.currentAmount = Self.decodeDouble(
+                container: container,
+                keys: [
+                    "current_usage",
+                    "currentUsage",
+                    "current_amount",
+                    "currentAmount",
+                    "usage_amount",
+                    "usageAmount",
+                    "usage",
+                    "spent",
+                    "amount_used",
+                    "amountUsed",
+                ]) ?? 0
+        }
+
+        var normalizedSelectors: Set<String> {
+            let values = self.budgetProductSkus + [
+                self.budgetType,
+                self.budgetEntityName,
+                self.name,
+            ].compactMap(\.self)
+            return Set(values.compactMap(CopilotBudgetWebFetcher.normalizedBillingIdentifier))
+        }
+
+        private static func decodeString(
+            container: KeyedDecodingContainer<DynamicCodingKey>,
+            keys: [String]) -> String?
+        {
+            for key in keys {
+                guard let codingKey = DynamicCodingKey(key) else { continue }
+                if let value = try? container.decodeIfPresent(String.self, forKey: codingKey), !value.isEmpty {
+                    return value
+                }
+                if let value = try? container.decodeIfPresent(Int.self, forKey: codingKey) {
+                    return String(value)
+                }
+            }
+            return nil
+        }
+
+        private static func decodeStringArray(
+            container: KeyedDecodingContainer<DynamicCodingKey>,
+            keys: [String]) -> [String]
+        {
+            for key in keys {
+                guard let codingKey = DynamicCodingKey(key) else { continue }
+                if let values = try? container.decodeIfPresent([String].self, forKey: codingKey), !values.isEmpty {
+                    return values
+                }
+                if let value = try? container.decodeIfPresent(String.self, forKey: codingKey), !value.isEmpty {
+                    return [value]
+                }
+                if let values = try? container.decodeIfPresent([ProductSKU].self, forKey: codingKey),
+                   !values.isEmpty
+                {
+                    return values.flatMap(\.selectors)
+                }
+            }
+            return []
+        }
+
+        private static func decodeDouble(
+            container: KeyedDecodingContainer<DynamicCodingKey>,
+            keys: [String]) -> Double?
+        {
+            for key in keys {
+                guard let codingKey = DynamicCodingKey(key) else { continue }
+                if let value = try? container.decodeIfPresent(Double.self, forKey: codingKey) {
+                    return value
+                }
+                if let value = try? container.decodeIfPresent(Int.self, forKey: codingKey) {
+                    return Double(value)
+                }
+                if let value = try? container.decodeIfPresent(String.self, forKey: codingKey),
+                   let parsed = Self.parseAmount(value)
+                {
+                    return parsed
+                }
+                if let value = try? container.decodeIfPresent(AmountValue.self, forKey: codingKey) {
+                    return value.amount
+                }
+            }
+            return nil
+        }
+
+        fileprivate static func parseAmount(_ value: String) -> Double? {
+            let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
+            let isNegative = trimmed.first == "-"
+            guard !trimmed.dropFirst(isNegative ? 1 : 0).contains("-") else { return nil }
+            let unsigned = trimmed.filter { $0.isNumber || $0 == "." }
+            guard !unsigned.isEmpty else { return nil }
+            return Double(isNegative ? "-\(unsigned)" : unsigned)
+        }
+    }
+
+    struct GitHubWebIdentity: Equatable {
+        let id: String?
+        let login: String?
+
+        init(id: String?, login: String?) {
+            let trimmedID = id?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+            let trimmedLogin = login?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+            self.id = trimmedID.isEmpty ? nil : trimmedID
+            self.login = trimmedLogin.isEmpty ? nil : trimmedLogin
+        }
+
+        var displayName: String? {
+            self.login ?? self.id.map { "github:user:\($0)" }
+        }
+    }
+
+    private struct ProductSKU: Decodable, Equatable {
+        let selectors: [String]
+
+        init(from decoder: Decoder) throws {
+            let container = try decoder.container(keyedBy: DynamicCodingKey.self)
+            self.selectors = [
+                "sku",
+                "name",
+                "display_name",
+                "displayName",
+                "product",
+                "product_name",
+                "productName",
+            ].compactMap { key in
+                guard let codingKey = DynamicCodingKey(key) else { return nil }
+                return try? container.decodeIfPresent(String.self, forKey: codingKey)
+            }
+        }
+    }
+
+    private struct AmountValue: Decodable {
+        let amount: Double?
+
+        init(from decoder: Decoder) throws {
+            let container = try decoder.container(keyedBy: DynamicCodingKey.self)
+            self.amount = [
+                "amount",
+                "value",
+                "total",
+                "cents",
+                "formatted",
+            ].lazy.compactMap { key -> Double? in
+                guard let codingKey = DynamicCodingKey(key) else { return nil }
+                if let value = try? container.decodeIfPresent(Double.self, forKey: codingKey) {
+                    return key == "cents" ? value / 100 : value
+                }
+                if let value = try? container.decodeIfPresent(Int.self, forKey: codingKey) {
+                    return key == "cents" ? Double(value) / 100 : Double(value)
+                }
+                if let value = try? container.decodeIfPresent(String.self, forKey: codingKey) {
+                    return Budget.parseAmount(value)
+                }
+                return nil
+            }.first
+        }
+    }
+
+    private struct DynamicCodingKey: CodingKey {
+        let stringValue: String
+        let intValue: Int?
+
+        init?(_ stringValue: String) {
+            self.stringValue = stringValue
+            self.intValue = nil
+        }
+
+        init?(stringValue: String) {
+            self.init(stringValue)
+        }
+
+        init?(intValue: Int) {
+            self.stringValue = String(intValue)
+            self.intValue = intValue
+        }
+    }
+
+    private static let copilotProductID = "copilot"
+    private static let copilotPremiumRequestSKU = "copilot_premium_request"
+    private static let copilotAgentPremiumRequestSKU = "copilot_agent_premium_request"
+    private static let sparkPremiumRequestSKU = "spark_premium_request"
+    private static let copilotBudgetSelectors: Set<String> = [
+        copilotProductID,
+        copilotPremiumRequestSKU,
+        copilotAgentPremiumRequestSKU,
+        sparkPremiumRequestSKU,
+    ]
+
+    private let cookieHeaderOverride: String?
+    private let expectedGitHubAccountIdentifier: String?
+    private let browserDetection: BrowserDetection
+    private let transport: any ProviderHTTPTransport
+    private let now: @Sendable () -> Date
+
+    public init(
+        cookieHeaderOverride: String? = nil,
+        expectedGitHubAccountIdentifier: String? = nil,
+        browserDetection: BrowserDetection = BrowserDetection(),
+        transport: any ProviderHTTPTransport = ProviderHTTPClient.shared,
+        now: @escaping @Sendable () -> Date = { Date() })
+    {
+        self.cookieHeaderOverride = CookieHeaderNormalizer.normalize(cookieHeaderOverride ?? "")
+        self.expectedGitHubAccountIdentifier = Self.normalizedExpectedAccountIdentifier(
+            expectedGitHubAccountIdentifier)
+        self.browserDetection = browserDetection
+        self.transport = transport
+        self.now = now
+    }
+
+    public func fetchBudgetWindows() async throws -> [NamedRateWindow] {
+        if let cookieHeaderOverride, !cookieHeaderOverride.isEmpty {
+            return try await self.fetchBudgetWindows(cookieHeader: cookieHeaderOverride)
+        }
+
+        if let cached = CookieHeaderCache.load(provider: .copilot),
+           !cached.cookieHeader.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+        {
+            do {
+                return try await self.fetchBudgetWindows(cookieHeader: cached.cookieHeader)
+            } catch {
+                if case Error.notLoggedIn = error {
+                    CookieHeaderCache.clear(provider: .copilot)
+                } else if case Error.accountMismatch = error {
+                    CookieHeaderCache.clear(provider: .copilot)
+                } else {
+                    throw error
+                }
+            }
+        }
+
+        #if os(macOS)
+        for session in CopilotGitHubCookieImporter.importSessions(browserDetection: self.browserDetection) {
+            do {
+                let windows = try await self.fetchBudgetWindows(cookieHeader: session.cookieHeader)
+                CookieHeaderCache.store(
+                    provider: .copilot,
+                    cookieHeader: session.cookieHeader,
+                    sourceLabel: session.sourceLabel)
+                return windows
+            } catch {
+                if case Error.notLoggedIn = error {
+                    continue
+                }
+                if case Error.accountMismatch = error {
+                    continue
+                }
+                throw error
+            }
+        }
+        #endif
+
+        throw Error.noSessionCookie
+    }
+
+    func fetchBudgetWindows(cookieHeader: String) async throws -> [NamedRateWindow] {
+        let nonce = try await self.boundFetchNonce(cookieHeader: cookieHeader)
+        var allBudgets: [Budget] = []
+        var page = 1
+        let maxPages = 20
+        var shouldContinue = true
+        while shouldContinue, page <= maxPages {
+            let response = try await self.fetchBudgetPage(
+                cookieHeader: cookieHeader,
+                nonce: nonce,
+                page: page)
+            allBudgets.append(contentsOf: response.budgets)
+            shouldContinue = response.hasNextPage == true
+            page += 1
+        }
+        if shouldContinue {
+            CodexBarLog.logger(LogCategories.providers).warning(
+                "Copilot budget pagination reached page cap",
+                metadata: ["pageCap": "\(maxPages)"])
+        }
+        return Self.extraRateWindows(from: allBudgets, now: self.now())
+    }
+
+    private func boundFetchNonce(cookieHeader: String) async throws -> String? {
+        guard self.expectedGitHubAccountIdentifier != nil else {
+            return await self.bestEffortFetchNonce(cookieHeader: cookieHeader)
+        }
+        let metadata = try await self.fetchBudgetPageMetadata(cookieHeader: cookieHeader)
+        try self.verifyExpectedGitHubAccount(metadata.identity)
+        return metadata.nonce
+    }
+
+    private func bestEffortFetchNonce(cookieHeader: String) async -> String? {
+        do {
+            return try await self.fetchBudgetPageMetadata(cookieHeader: cookieHeader).nonce
+        } catch {
+            // GitHub accepts some budget requests without a nonce. Keep auth failures and
+            // page-shape changes non-fatal so a valid Cookie header can still be tried.
+            return nil
+        }
+    }
+
+    private struct BudgetPageMetadata {
+        let nonce: String?
+        let identity: GitHubWebIdentity?
+    }
+
+    private func fetchBudgetPageMetadata(cookieHeader: String) async throws -> BudgetPageMetadata {
+        guard let url = URL(string: "https://github.com/settings/billing/budgets") else {
+            throw URLError(.badURL)
+        }
+        var request = URLRequest(url: url)
+        request.timeoutInterval = 15
+        request.setValue(cookieHeader, forHTTPHeaderField: "Cookie")
+        request.setValue("text/html,application/xhtml+xml", forHTTPHeaderField: "Accept")
+        request.setValue("CodexBar", forHTTPHeaderField: "User-Agent")
+
+        let response = try await self.transport.response(for: request)
+        switch response.statusCode {
+        case 200:
+            guard let html = String(data: response.data, encoding: .utf8) else { throw Error.invalidResponse }
+            return BudgetPageMetadata(
+                nonce: Self.extractFetchNonce(from: html),
+                identity: Self.extractGitHubWebIdentity(from: html))
+        case 401, 403:
+            throw Error.notLoggedIn
+        default:
+            throw Error.badStatus(response.statusCode)
+        }
+    }
+
+    private func verifyExpectedGitHubAccount(_ actual: GitHubWebIdentity?) throws {
+        guard let expected = self.expectedGitHubAccountIdentifier else { return }
+        guard let actual else { throw Error.accountMismatch(expected: expected, actual: nil) }
+        guard Self.webIdentity(actual, matches: expected) else {
+            throw Error.accountMismatch(expected: expected, actual: actual.displayName)
+        }
+    }
+
+    private func fetchBudgetPage(cookieHeader: String, nonce: String?, page: Int) async throws -> BudgetResponse {
+        guard var components = URLComponents(string: "https://github.com/settings/billing/budgets") else {
+            throw URLError(.badURL)
+        }
+        components.queryItems = [
+            URLQueryItem(name: "page", value: "\(page)"),
+            URLQueryItem(name: "page_size", value: "10"),
+            URLQueryItem(name: "scope", value: "customer"),
+        ]
+        guard let url = components.url else { throw URLError(.badURL) }
+        var request = URLRequest(url: url)
+        request.timeoutInterval = 15
+        request.setValue(cookieHeader, forHTTPHeaderField: "Cookie")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        request.setValue("https://github.com/settings/billing/budgets", forHTTPHeaderField: "Referer")
+        request.setValue("XMLHttpRequest", forHTTPHeaderField: "X-Requested-With")
+        request.setValue("true", forHTTPHeaderField: "GitHub-Verified-Fetch")
+        request.setValue("CodexBar", forHTTPHeaderField: "User-Agent")
+        if let nonce, !nonce.isEmpty {
+            request.setValue(nonce, forHTTPHeaderField: "X-Fetch-Nonce")
+        }
+
+        let response = try await self.transport.response(for: request)
+        switch response.statusCode {
+        case 200:
+            do {
+                return try JSONDecoder().decode(BudgetResponse.self, from: response.data)
+            } catch {
+                throw Error.invalidResponse
+            }
+        case 401, 403:
+            throw Error.notLoggedIn
+        default:
+            throw Error.badStatus(response.statusCode)
+        }
+    }
+
+    static func extractFetchNonce(from html: String) -> String? {
+        let patterns = [
+            #"x-fetch-nonce"\s+content="([^"]+)""#,
+            #"X-Fetch-Nonce"\s*:\s*"([^"]+)""#,
+            #"fetchNonce"\s*:\s*"([^"]+)""#,
+            #"data-fetch-nonce="([^"]+)""#,
+        ]
+        for pattern in patterns {
+            guard let regex = try? NSRegularExpression(pattern: pattern, options: [.caseInsensitive]) else {
+                continue
+            }
+            let range = NSRange(html.startIndex..<html.endIndex, in: html)
+            guard let match = regex.firstMatch(in: html, range: range),
+                  let nonceRange = Range(match.range(at: 1), in: html)
+            else { continue }
+            return String(html[nonceRange])
+        }
+        return nil
+    }
+
+    static func extractGitHubWebIdentity(from html: String) -> GitHubWebIdentity? {
+        let id = self.extractMetaContent(
+            named: [
+                "octolytics-actor-id",
+                "analytics-user-id",
+                "user-id",
+            ],
+            from: html)
+        let login = self.extractMetaContent(
+            named: [
+                "user-login",
+                "octolytics-actor-login",
+                "analytics-user-login",
+            ],
+            from: html)
+        let identity = GitHubWebIdentity(id: id, login: login)
+        return identity.id == nil && identity.login == nil ? nil : identity
+    }
+
+    private static let metaTagRegex = try? NSRegularExpression(
+        pattern: #"<meta\b[^>]*>"#,
+        options: [.caseInsensitive])
+
+    private static let metaAttributeRegex = try? NSRegularExpression(
+        pattern: #"([A-Za-z_:][-A-Za-z0-9_:.]*)\s*=\s*(['"])(.*?)\2"#,
+        options: [.caseInsensitive])
+
+    private static func extractMetaContent(named names: [String], from html: String) -> String? {
+        guard let metaTagRegex, let metaAttributeRegex else { return nil }
+        let expectedNames = Set(names.map { $0.lowercased() })
+        var contentByName: [String: String] = [:]
+        let htmlRange = NSRange(html.startIndex..<html.endIndex, in: html)
+        for tagMatch in metaTagRegex.matches(in: html, range: htmlRange) {
+            guard let tagRange = Range(tagMatch.range, in: html) else { continue }
+            let tag = String(html[tagRange])
+            let tagNSRange = NSRange(tag.startIndex..<tag.endIndex, in: tag)
+            var attributes: [String: String] = [:]
+            for attributeMatch in metaAttributeRegex.matches(in: tag, range: tagNSRange) {
+                guard let keyRange = Range(attributeMatch.range(at: 1), in: tag),
+                      let valueRange = Range(attributeMatch.range(at: 3), in: tag)
+                else { continue }
+                attributes[String(tag[keyRange]).lowercased()] = String(tag[valueRange])
+            }
+            guard let name = attributes["name"]?.lowercased(),
+                  expectedNames.contains(name),
+                  contentByName[name] == nil,
+                  let content = attributes["content"]?.trimmingCharacters(in: .whitespacesAndNewlines),
+                  !content.isEmpty
+            else { continue }
+            contentByName[name] = content
+        }
+        for name in names {
+            if let content = contentByName[name.lowercased()] {
+                return content
+            }
+        }
+        return nil
+    }
+
+    static func webIdentity(_ identity: GitHubWebIdentity?, matches expectedIdentifier: String?) -> Bool {
+        guard let expected = self.normalizedExpectedAccountIdentifier(expectedIdentifier),
+              let identity
+        else { return false }
+        if let expectedID = self.githubUserID(from: expected) {
+            return identity.id == expectedID
+        }
+        return identity.login?.lowercased() == expected
+    }
+
+    static func normalizedGitHubAccountIdentifier(for identity: CopilotUsageFetcher.GitHubUserIdentity) -> String {
+        "github:user:\(identity.id)"
+    }
+
+    private static func normalizedExpectedAccountIdentifier(_ identifier: String?) -> String? {
+        let trimmed = identifier?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+        return trimmed.isEmpty ? nil : trimmed.lowercased()
+    }
+
+    private static func githubUserID(from identifier: String) -> String? {
+        let prefix = "github:user:"
+        guard identifier.hasPrefix(prefix) else { return nil }
+        let suffix = String(identifier.dropFirst(prefix.count))
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+        return suffix.isEmpty ? nil : suffix
+    }
+
+    static func extraRateWindows(from budgets: [Budget], now: Date) -> [NamedRateWindow] {
+        var usedIDs = Set<String>()
+        let resetDate = self.approximateNextMonthResetDate(now: now)
+        return budgets
+            .compactMap { budget in
+                let selectors = budget.normalizedSelectors
+                guard self.isCopilotBudget(budget, selectors: selectors) else { return nil }
+                let id = self.uniqueWindowID(for: budget, selectors: selectors, usedIDs: &usedIDs)
+                let usedPercent = budget.budgetAmount > 0
+                    ? min(999, max(0, budget.currentAmount / budget.budgetAmount * 100))
+                    : 0
+                let window = RateWindow(
+                    usedPercent: usedPercent,
+                    windowMinutes: nil,
+                    resetsAt: resetDate,
+                    resetDescription: resetDate.map {
+                        UsageFormatter.resetDescription(from: $0, now: now)
+                    })
+                return NamedRateWindow(
+                    id: id,
+                    title: self.windowTitle(for: budget, selectors: selectors),
+                    window: window)
+            }
+    }
+
+    private static func isCopilotBudget(_ budget: Budget, selectors: Set<String>) -> Bool {
+        guard budget.budgetAmount > 0 else { return false }
+        return !selectors.isDisjoint(with: self.copilotBudgetSelectors)
+    }
+
+    static func normalizedBillingIdentifier(_ value: String?) -> String? {
+        guard let value else { return nil }
+        let slug = self.slug(value)
+        guard !slug.isEmpty else { return nil }
+        let underscored = slug.replacingOccurrences(of: "-", with: "_")
+        if underscored == self.copilotProductID {
+            return self.copilotProductID
+        }
+        if underscored == "premium_request" || underscored == "premium_requests" {
+            return self.copilotPremiumRequestSKU
+        }
+        if underscored == "coding_agent_premium_request" || underscored == "coding_agent_premium_requests" {
+            return self.copilotAgentPremiumRequestSKU
+        }
+        if underscored.contains("spark"), underscored.contains("premium"), underscored.contains("request") {
+            return self.sparkPremiumRequestSKU
+        }
+        if underscored.contains("cloud") || underscored.contains("coding"),
+           underscored.contains("agent"),
+           underscored.contains("premium"),
+           underscored.contains("request")
+        {
+            return self.copilotAgentPremiumRequestSKU
+        }
+        if underscored.contains("bundled"), underscored.contains("premium"), underscored.contains("request") {
+            return self.copilotPremiumRequestSKU
+        }
+        if underscored.contains("copilot"),
+           underscored.contains("agent"),
+           underscored.contains("premium"),
+           underscored.contains("request")
+        {
+            return self.copilotAgentPremiumRequestSKU
+        }
+        if underscored.contains("copilot"), underscored.contains("premium"), underscored.contains("request") {
+            return self.copilotPremiumRequestSKU
+        }
+        return underscored
+    }
+
+    private static func windowTitle(for budget: Budget, selectors: Set<String>) -> String {
+        let budgetType = if selectors == [self.copilotProductID] {
+            "Copilot"
+        } else if selectors.contains(self.copilotAgentPremiumRequestSKU) {
+            "Copilot Agent Premium Requests"
+        } else if selectors.contains(self.sparkPremiumRequestSKU) {
+            "Spark Premium Requests"
+        } else if selectors.contains(self.copilotPremiumRequestSKU) {
+            "All Premium Request SKUs"
+        } else if let name = budget.name?.trimmingCharacters(in: .whitespacesAndNewlines),
+                  !name.isEmpty
+        {
+            name
+        } else {
+            "Copilot Premium Requests"
+        }
+        return "Budget - \(budgetType)"
+    }
+
+    private static func uniqueWindowID(
+        for budget: Budget,
+        selectors: Set<String>,
+        usedIDs: inout Set<String>) -> String
+    {
+        let source = budget.id ?? budget.budgetProductSkus.joined(separator: "-")
+        let slug = self.slug(source.isEmpty ? self.windowTitle(for: budget, selectors: selectors) : source)
+        let base = slug.isEmpty ? "copilot-budget" : "copilot-budget-\(slug)"
+        var candidate = base
+        var suffix = 2
+        while !usedIDs.insert(candidate).inserted {
+            candidate = "\(base)-\(suffix)"
+            suffix += 1
+        }
+        return candidate
+    }
+
+    private static func approximateNextMonthResetDate(now: Date) -> Date? {
+        // GitHub's budget response does not expose a reset instant. Use the local
+        // start of next month as a display-only approximation.
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = .current
+        let components = calendar.dateComponents([.year, .month], from: now)
+        guard let monthStart = calendar.date(from: DateComponents(
+            year: components.year,
+            month: components.month,
+            day: 1))
+        else {
+            return nil
+        }
+        return calendar.date(byAdding: .month, value: 1, to: monthStart)
+    }
+
+    private static func slug(_ value: String) -> String {
+        var result = ""
+        var lastWasDash = false
+        for scalar in value.lowercased().unicodeScalars {
+            if CharacterSet.alphanumerics.contains(scalar) {
+                result.unicodeScalars.append(scalar)
+                lastWasDash = false
+            } else if !lastWasDash {
+                result.append("-")
+                lastWasDash = true
+            }
+        }
+        return result.trimmingCharacters(in: CharacterSet(charactersIn: "-"))
+    }
+}
+
+#if os(macOS)
+private enum CopilotGitHubCookieImporter {
+    private static let cookieClient = BrowserCookieClient()
+    private static let cookieImportOrder: BrowserCookieImportOrder =
+        ProviderDefaults.metadata[.copilot]?.browserCookieOrder ?? [.chrome]
+    private static let sessionCookieNames: Set<String> = [
+        "user_session",
+        "__Host-user_session_same_site",
+        "_gh_sess",
+        "logged_in",
+        "dotcom_user",
+    ]
+
+    struct SessionInfo {
+        let cookies: [HTTPCookie]
+        let sourceLabel: String
+
+        var cookieHeader: String {
+            self.cookies.map { "\($0.name)=\($0.value)" }.joined(separator: "; ")
+        }
+    }
+
+    static func importSessions(browserDetection: BrowserDetection) -> [SessionInfo] {
+        let installedBrowsers = self.cookieImportOrder.cookieImportCandidates(using: browserDetection)
+        return installedBrowsers.flatMap { browser -> [SessionInfo] in
+            do {
+                return try self.importSessions(from: browser)
+            } catch {
+                BrowserCookieAccessGate.recordIfNeeded(error)
+                return []
+            }
+        }
+    }
+
+    private static func importSessions(from browser: Browser) throws -> [SessionInfo] {
+        let query = BrowserCookieQuery(domains: ["github.com", "www.github.com"])
+        let sources = try self.cookieClient.codexBarRecords(matching: query, in: browser)
+        return sources.compactMap { source -> SessionInfo? in
+            guard !source.records.isEmpty else { return nil }
+            let cookies = BrowserCookieClient.makeHTTPCookies(source.records, origin: query.origin)
+            guard cookies.contains(where: { self.sessionCookieNames.contains($0.name) }) else {
+                return nil
+            }
+            return SessionInfo(cookies: cookies, sourceLabel: source.label)
+        }
+    }
+}
+#endif
diff --git a/Sources/CodexBarCore/Providers/Copilot/CopilotDeviceFlow.swift b/Sources/CodexBarCore/Providers/Copilot/CopilotDeviceFlow.swift
index 094ad9f2e7..ed003330b7 100644
--- a/Sources/CodexBarCore/Providers/Copilot/CopilotDeviceFlow.swift
+++ b/Sources/CodexBarCore/Providers/Copilot/CopilotDeviceFlow.swift
@@ -4,20 +4,29 @@ import FoundationNetworking
 #endif
 
 public struct CopilotDeviceFlow: Sendable {
+    public static let defaultHost = "github.com"
+
     private let clientID = "Iv1.b507a08c87ecfe98" // VS Code Client ID
     private let scopes = "read:user"
+    private let host: String
 
     public struct DeviceCodeResponse: Decodable, Sendable {
         public let deviceCode: String
         public let userCode: String
         public let verificationUri: String
+        public let verificationUriComplete: String?
         public let expiresIn: Int
         public let interval: Int
 
+        public var verificationURLToOpen: String {
+            self.verificationUriComplete ?? self.verificationUri
+        }
+
         enum CodingKeys: String, CodingKey {
             case deviceCode = "device_code"
             case userCode = "user_code"
             case verificationUri = "verification_uri"
+            case verificationUriComplete = "verification_uri_complete"
             case expiresIn = "expires_in"
             case interval
         }
@@ -35,11 +44,48 @@ public struct CopilotDeviceFlow: Sendable {
         }
     }
 
-    public init() {}
+    public init(enterpriseHost: String? = nil) {
+        self.host = Self.normalizedHost(enterpriseHost)
+    }
+
+    public var deviceCodeURL: URL? {
+        Self.makeRequestURL(host: self.host, path: "/login/device/code")
+    }
+
+    public var accessTokenURL: URL? {
+        Self.makeRequestURL(host: self.host, path: "/login/oauth/access_token")
+    }
+
+    public static func normalizedHost(_ raw: String?) -> String {
+        guard var host = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !host.isEmpty else {
+            return self.defaultHost
+        }
+        let componentsValue = host.contains("://") ? host : "https://\(host)"
+        if let components = URLComponents(string: componentsValue),
+           let parsedHost = components.host,
+           !parsedHost.isEmpty
+        {
+            host = parsedHost
+            if let port = components.port {
+                host += ":\(port)"
+            }
+        } else {
+            if host.hasPrefix("https://") {
+                host.removeFirst("https://".count)
+            } else if host.hasPrefix("http://") {
+                host.removeFirst("http://".count)
+            }
+            host = host.split(separator: "/", maxSplits: 1).first.map(String.init) ?? host
+        }
+        let normalized = host.trimmingCharacters(in: CharacterSet(charactersIn: ".")).lowercased()
+        return normalized.isEmpty ? Self.defaultHost : normalized
+    }
 
     public func requestDeviceCode() async throws -> DeviceCodeResponse {
-        let components = URLComponents(string: "https://github.com/login/device/code")!
-        let request = URLRequest(url: components.url!)
+        guard let deviceCodeURL = self.deviceCodeURL else {
+            throw URLError(.badURL)
+        }
+        let request = URLRequest(url: deviceCodeURL)
 
         var postRequest = request
         postRequest.httpMethod = "POST"
@@ -52,18 +98,20 @@ public struct CopilotDeviceFlow: Sendable {
         ]
         postRequest.httpBody = Self.formURLEncodedBody(body)
 
-        let (data, response) = try await URLSession.shared.data(for: postRequest)
+        let response = try await ProviderHTTPClient.shared.response(for: postRequest)
 
-        guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
+        guard response.statusCode == 200 else {
             throw URLError(.badServerResponse)
         }
 
-        return try JSONDecoder().decode(DeviceCodeResponse.self, from: data)
+        return try JSONDecoder().decode(DeviceCodeResponse.self, from: response.data)
     }
 
     public func pollForToken(deviceCode: String, interval: Int) async throws -> String {
-        let url = URL(string: "https://github.com/login/oauth/access_token")!
-        var request = URLRequest(url: url)
+        guard let accessTokenURL = self.accessTokenURL else {
+            throw URLError(.badURL)
+        }
+        var request = URLRequest(url: accessTokenURL)
         request.httpMethod = "POST"
         request.setValue("application/json", forHTTPHeaderField: "Accept")
         request.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
@@ -79,10 +127,10 @@ public struct CopilotDeviceFlow: Sendable {
             try await Task.sleep(nanoseconds: UInt64(interval) * 1_000_000_000)
             try Task.checkCancellation()
 
-            let (data, _) = try await URLSession.shared.data(for: request)
+            let response = try await ProviderHTTPClient.shared.response(for: request)
 
             // Check for error in JSON
-            if let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+            if let json = try? JSONSerialization.jsonObject(with: response.data) as? [String: Any],
                let error = json["error"] as? String
             {
                 if error == "authorization_pending" {
@@ -98,7 +146,7 @@ public struct CopilotDeviceFlow: Sendable {
                 throw URLError(.userAuthenticationRequired) // Generic failure
             }
 
-            if let tokenResponse = try? JSONDecoder().decode(AccessTokenResponse.self, from: data) {
+            if let tokenResponse = try? JSONDecoder().decode(AccessTokenResponse.self, from: response.data) {
                 return tokenResponse.accessToken
             }
         }
@@ -113,6 +161,10 @@ public struct CopilotDeviceFlow: Sendable {
         return Data(pairs.utf8)
     }
 
+    static func makeRequestURL(host: String, path: String) -> URL? {
+        URL(string: "https://\(host)\(path)")
+    }
+
     private static func formEncode(_ value: String) -> String {
         var allowed = CharacterSet.urlQueryAllowed
         allowed.remove(charactersIn: "+&=")
diff --git a/Sources/CodexBarCore/Providers/Copilot/CopilotProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Copilot/CopilotProviderDescriptor.swift
index 9e2b063ccd..5a3b1f39c4 100644
--- a/Sources/CodexBarCore/Providers/Copilot/CopilotProviderDescriptor.swift
+++ b/Sources/CodexBarCore/Providers/Copilot/CopilotProviderDescriptor.swift
@@ -1,9 +1,8 @@
-import CodexBarMacroSupport
 import Foundation
 
-@ProviderDescriptorRegistration
-@ProviderDescriptorDefinition
 public enum CopilotProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
     static func makeDescriptor() -> ProviderDescriptor {
         ProviderDescriptor(
             id: .copilot,
@@ -21,6 +20,7 @@ public enum CopilotProviderDescriptor {
                 defaultEnabled: false,
                 isPrimaryProvider: false,
                 usesAccountFallback: false,
+                browserCookieOrder: ProviderBrowserCookieDefaults.copilotCookieImportOrder,
                 dashboardURL: "https://github.com/settings/copilot",
                 statusPageURL: "https://www.githubstatus.com/"),
             branding: ProviderBranding(
@@ -44,15 +44,18 @@ struct CopilotAPIFetchStrategy: ProviderFetchStrategy {
     let kind: ProviderFetchKind = .apiToken
 
     func isAvailable(_ context: ProviderFetchContext) async -> Bool {
-        Self.resolveToken(environment: context.env) != nil
+        Self.resolveToken(context: context) != nil
     }
 
     func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
-        guard let token = Self.resolveToken(environment: context.env), !token.isEmpty else {
+        guard let token = Self.resolveToken(context: context), !token.isEmpty else {
             throw URLError(.userAuthenticationRequired)
         }
-        let fetcher = CopilotUsageFetcher(token: token)
-        let snap = try await fetcher.fetch()
+        let fetcher = CopilotUsageFetcher(
+            token: token,
+            enterpriseHost: context.settings?.copilot?.enterpriseHost)
+        let usage = try await fetcher.fetch()
+        let snap = await self.addBudgetWindowsIfNeeded(to: usage, token: token, context: context)
         return self.makeResult(
             usage: snap,
             sourceLabel: "api")
@@ -62,7 +65,71 @@ struct CopilotAPIFetchStrategy: ProviderFetchStrategy {
         false
     }
 
-    private static func resolveToken(environment: [String: String]) -> String? {
-        ProviderTokenResolver.copilotToken(environment: environment)
+    private static func resolveToken(context: ProviderFetchContext) -> String? {
+        ProviderTokenResolver.copilotToken(environment: context.env)
+            ?? ProviderTokenResolver.copilotResolution(environment: [
+                "COPILOT_API_TOKEN": context.settings?.copilot?.apiToken ?? "",
+            ])?.token
+    }
+
+    private func addBudgetWindowsIfNeeded(
+        to usage: UsageSnapshot,
+        token: String,
+        context: ProviderFetchContext) async -> UsageSnapshot
+    {
+        guard let settings = context.settings?.copilot,
+              settings.budgetExtrasEnabled,
+              settings.budgetCookieSource != .off
+        else { return usage }
+
+        let manualCookieHeader = Self.budgetCookieHeaderOverride(from: settings)
+        if settings.budgetCookieSource == .manual, manualCookieHeader == nil {
+            return usage
+        }
+        do {
+            let expectedAccountIdentifier = try await self.expectedBudgetAccountIdentifier(
+                token: token,
+                settings: settings)
+            let extraRateWindows = try await CopilotBudgetWebFetcher(
+                cookieHeaderOverride: manualCookieHeader,
+                expectedGitHubAccountIdentifier: expectedAccountIdentifier,
+                browserDetection: context.browserDetection)
+                .fetchBudgetWindows()
+            guard !extraRateWindows.isEmpty else { return usage }
+            return usage.with(extraRateWindows: extraRateWindows)
+        } catch {
+            CodexBarLog.logger(LogCategories.providers).warning(
+                "Copilot budget extras unavailable",
+                metadata: ["error": "\(error.localizedDescription)"])
+            return usage
+        }
+    }
+
+    static func budgetCookieHeaderOverride(
+        from settings: ProviderSettingsSnapshot.CopilotProviderSettings) -> String?
+    {
+        guard settings.budgetCookieSource == .manual else { return nil }
+        return CookieHeaderNormalizer.normalize(settings.manualBudgetCookieHeader)
+    }
+
+    private func expectedBudgetAccountIdentifier(
+        token: String,
+        settings: ProviderSettingsSnapshot.CopilotProviderSettings) async throws -> String
+    {
+        let identity = try await CopilotUsageFetcher.fetchGitHubIdentity(token: token)
+        let tokenIdentifier = CopilotBudgetWebFetcher.normalizedGitHubAccountIdentifier(for: identity)
+        if let selectedIdentifier = Self.normalizedBudgetAccountIdentifier(settings.selectedAccountExternalIdentifier),
+           selectedIdentifier != tokenIdentifier.lowercased(),
+           selectedIdentifier != identity.login.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+        {
+            CodexBarLog.logger(LogCategories.providers).warning(
+                "Ignoring stale Copilot account identifier")
+        }
+        return tokenIdentifier
+    }
+
+    private static func normalizedBudgetAccountIdentifier(_ identifier: String?) -> String? {
+        let trimmed = identifier?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+        return trimmed.isEmpty ? nil : trimmed.lowercased()
     }
 }
diff --git a/Sources/CodexBarCore/Providers/Copilot/CopilotUsageFetcher.swift b/Sources/CodexBarCore/Providers/Copilot/CopilotUsageFetcher.swift
index ddf41a10a5..f9fe0fb795 100644
--- a/Sources/CodexBarCore/Providers/Copilot/CopilotUsageFetcher.swift
+++ b/Sources/CodexBarCore/Providers/Copilot/CopilotUsageFetcher.swift
@@ -4,14 +4,49 @@ import FoundationNetworking
 #endif
 
 public struct CopilotUsageFetcher: Sendable {
+    public struct GitHubUserIdentity: Decodable, Equatable, Sendable {
+        public let id: Int64
+        public let login: String
+
+        public init(id: Int64, login: String) {
+            self.id = id
+            self.login = login
+        }
+    }
+
     private let token: String
+    private let enterpriseHost: String?
+    private let transport: any ProviderHTTPTransport
 
-    public init(token: String) {
+    public init(
+        token: String,
+        enterpriseHost: String? = nil,
+        transport: any ProviderHTTPTransport = ProviderHTTPClient.shared)
+    {
         self.token = token
+        self.enterpriseHost = enterpriseHost
+        self.transport = transport
+    }
+
+    public static func apiHost(enterpriseHost: String?) -> String {
+        let host = CopilotDeviceFlow.normalizedHost(enterpriseHost)
+        if host == CopilotDeviceFlow.defaultHost {
+            return "api.github.com"
+        }
+        if host.hasPrefix("api.") {
+            return host
+        }
+        return "api.\(host)"
+    }
+
+    public static func usageURL(enterpriseHost: String?) -> URL? {
+        CopilotDeviceFlow.makeRequestURL(
+            host: self.apiHost(enterpriseHost: enterpriseHost),
+            path: "/copilot_internal/user")
     }
 
     public func fetch() async throws -> UsageSnapshot {
-        guard let url = URL(string: "https://api.github.com/copilot_internal/user") else {
+        guard let url = Self.usageURL(enterpriseHost: self.enterpriseHost) else {
             throw URLError(.badURL)
         }
 
@@ -20,23 +55,20 @@ public struct CopilotUsageFetcher: Sendable {
         request.setValue("token \(self.token)", forHTTPHeaderField: "Authorization")
         self.addCommonHeaders(to: &request)
 
-        let (data, response) = try await URLSession.shared.data(for: request)
+        let response = try await self.transport.response(for: request)
 
-        guard let httpResponse = response as? HTTPURLResponse else {
-            throw URLError(.badServerResponse)
-        }
-
-        if httpResponse.statusCode == 401 || httpResponse.statusCode == 403 {
+        if response.statusCode == 401 || response.statusCode == 403 {
             throw URLError(.userAuthenticationRequired)
         }
 
-        guard httpResponse.statusCode == 200 else {
+        guard response.statusCode == 200 else {
             throw URLError(.badServerResponse)
         }
 
-        let usage = try JSONDecoder().decode(CopilotUsageResponse.self, from: data)
-        let premium = self.makeRateWindow(from: usage.quotaSnapshots.premiumInteractions)
-        let chat = self.makeRateWindow(from: usage.quotaSnapshots.chat)
+        let usage = try JSONDecoder().decode(CopilotUsageResponse.self, from: response.data)
+        let resetsAt = Self.parseQuotaResetDate(usage.quotaResetDate)
+        let premium = Self.makeRateWindow(from: usage.quotaSnapshots.premiumInteractions, resetsAt: resetsAt)
+        let chat = Self.makeRateWindow(from: usage.quotaSnapshots.chat, resetsAt: resetsAt)
 
         let primary: RateWindow?
         let secondary: RateWindow?
@@ -48,6 +80,11 @@ public struct CopilotUsageFetcher: Sendable {
             // ("Premium" for primary, "Chat" for secondary) on chat-only plans.
             primary = nil
             secondary = chatWindow
+        } else if usage.tokenBasedBilling {
+            // Copilot Business token-based billing currently exposes zero-entitlement
+            // placeholder quotas on this endpoint, so surface the plan without fake usage.
+            primary = nil
+            secondary = nil
         } else {
             throw URLError(.cannotDecodeRawData)
         }
@@ -66,6 +103,33 @@ public struct CopilotUsageFetcher: Sendable {
             identity: identity)
     }
 
+    public static func fetchGitHubUsername(token: String) async throws -> String {
+        try await self.fetchGitHubIdentity(token: token).login
+    }
+
+    public static func fetchGitHubIdentity(
+        token: String,
+        transport: any ProviderHTTPTransport = ProviderHTTPClient.shared)
+        async throws -> GitHubUserIdentity
+    {
+        guard let url = URL(string: "https://api.github.com/user") else {
+            throw URLError(.badURL)
+        }
+        var request = URLRequest(url: url)
+        request.setValue("token \(token)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+
+        let response = try await transport.response(for: request)
+        switch response.statusCode {
+        case 200:
+            return try JSONDecoder().decode(GitHubUserIdentity.self, from: response.data)
+        case 401, 403:
+            throw URLError(.userAuthenticationRequired)
+        default:
+            throw URLError(.badServerResponse)
+        }
+    }
+
     private func addCommonHeaders(to request: inout URLRequest) {
         request.setValue("application/json", forHTTPHeaderField: "Accept")
         request.setValue("vscode/1.96.2", forHTTPHeaderField: "Editor-Version")
@@ -74,17 +138,49 @@ public struct CopilotUsageFetcher: Sendable {
         request.setValue("2025-04-01", forHTTPHeaderField: "X-Github-Api-Version")
     }
 
-    private func makeRateWindow(from snapshot: CopilotUsageResponse.QuotaSnapshot?) -> RateWindow? {
+    static func makeRateWindow(
+        from snapshot: CopilotUsageResponse.QuotaSnapshot?,
+        resetsAt: Date? = nil) -> RateWindow?
+    {
         guard let snapshot else { return nil }
         guard !snapshot.isPlaceholder else { return nil }
         guard snapshot.hasPercentRemaining else { return nil }
-        // percent_remaining is 0-100 based on the JSON example in the web app source
-        let usedPercent = max(0, 100 - snapshot.percentRemaining)
+        let usedPercent = snapshot.usedPercent
+        let overQuotaDescription = snapshot.overQuotaUsedPercent.map { used in
+            String(format: "%.0f%% used", used)
+        }
+        let effectiveResetsAt = snapshot.unlimited ? nil : resetsAt
 
         return RateWindow(
             usedPercent: usedPercent,
-            windowMinutes: nil, // Not provided
-            resetsAt: nil, // Not provided per-quota in the simplified snapshot
-            resetDescription: nil)
+            windowMinutes: nil,
+            resetsAt: effectiveResetsAt,
+            resetDescription: overQuotaDescription)
+    }
+
+    static func parseQuotaResetDate(_ value: String?) -> Date? {
+        guard let raw = value?.trimmingCharacters(in: .whitespacesAndNewlines), !raw.isEmpty else {
+            return nil
+        }
+
+        let fractionalISO = ISO8601DateFormatter()
+        fractionalISO.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        if let date = fractionalISO.date(from: raw) {
+            return date
+        }
+
+        let internetISO = ISO8601DateFormatter()
+        internetISO.formatOptions = [.withInternetDateTime]
+        if let date = internetISO.date(from: raw) {
+            return date
+        }
+
+        let formatter = DateFormatter()
+        formatter.calendar = Calendar(identifier: .gregorian)
+        formatter.isLenient = false
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        formatter.timeZone = TimeZone(secondsFromGMT: 0)
+        formatter.dateFormat = "yyyy-MM-dd"
+        return formatter.date(from: raw)
     }
 }
diff --git a/Sources/CodexBarCore/Providers/Crof/CrofProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Crof/CrofProviderDescriptor.swift
new file mode 100644
index 0000000000..860733de98
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Crof/CrofProviderDescriptor.swift
@@ -0,0 +1,46 @@
+import Foundation
+
+public enum CrofProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .crof,
+            metadata: ProviderMetadata(
+                id: .crof,
+                displayName: "Crof",
+                sessionLabel: "Requests",
+                weeklyLabel: "Credits",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "Credit balance from the Crof usage API",
+                toggleTitle: "Show Crof usage",
+                cliName: "crof",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                browserCookieOrder: nil,
+                dashboardURL: "https://crof.ai/dashboard",
+                statusPageURL: nil,
+                statusLinkURL: nil),
+            branding: ProviderBranding(
+                iconStyle: .crof,
+                iconResourceName: "ProviderIcon-crof",
+                color: ProviderColor(red: 0.18, green: 0.67, blue: 0.58)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "Crof cost summary is not available via API." }),
+            fetchPlan: .apiToken(
+                strategyID: "crof.api",
+                resolveToken: { ProviderTokenResolver.crofToken(environment: $0) },
+                missingCredentialsError: { CrofUsageError.missingCredentials },
+                loadUsage: { apiKey, _ in
+                    try await CrofUsageFetcher.fetchUsage(apiKey: apiKey).toUsageSnapshot()
+                }),
+            cli: ProviderCLIConfig(
+                name: "crof",
+                aliases: ["crofai"],
+                versionDetector: nil))
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Crof/CrofSettingsReader.swift b/Sources/CodexBarCore/Providers/Crof/CrofSettingsReader.swift
new file mode 100644
index 0000000000..14680a9ceb
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Crof/CrofSettingsReader.swift
@@ -0,0 +1,27 @@
+import Foundation
+
+public enum CrofSettingsReader {
+    public static let apiKeyEnvironmentKeys = ["CROF_API_KEY", "CROFAI_API_KEY"]
+
+    public static func apiKey(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        for key in self.apiKeyEnvironmentKeys {
+            if let value = self.cleaned(environment[key]) {
+                return value
+            }
+        }
+        return nil
+    }
+
+    private static func cleaned(_ raw: String?) -> String? {
+        guard var value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
+            return nil
+        }
+        if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
+            (value.hasPrefix("'") && value.hasSuffix("'"))
+        {
+            value = String(value.dropFirst().dropLast())
+        }
+        value = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        return value.isEmpty ? nil : value
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Crof/CrofUsageFetcher.swift b/Sources/CodexBarCore/Providers/Crof/CrofUsageFetcher.swift
new file mode 100644
index 0000000000..c8c3a4cac2
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Crof/CrofUsageFetcher.swift
@@ -0,0 +1,89 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public struct CrofUsageResponse: Decodable, Sendable {
+    public let credits: Double
+    public let requestsPlan: Double
+    public let usableRequests: Double
+
+    enum CodingKeys: String, CodingKey {
+        case credits
+        case requestsPlan = "requests_plan"
+        case usableRequests = "usable_requests"
+    }
+}
+
+public enum CrofUsageError: LocalizedError, Sendable, Equatable {
+    case missingCredentials
+    case networkError(String)
+    case apiError(Int)
+    case parseFailed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingCredentials:
+            "Missing Crof API key."
+        case let .networkError(message):
+            "Crof network error: \(message)"
+        case let .apiError(statusCode):
+            "Crof API error: HTTP \(statusCode)"
+        case let .parseFailed(message):
+            "Failed to parse Crof response: \(message)"
+        }
+    }
+}
+
+public enum CrofUsageFetcher {
+    public static let usageURL = URL(string: "https://crof.ai/usage_api/")!
+    private static let timeoutSeconds: TimeInterval = 15
+
+    public static func fetchUsage(
+        apiKey: String,
+        session transport: any ProviderHTTPTransport = ProviderHTTPClient.shared) async throws -> CrofUsageSnapshot
+    {
+        let trimmed = apiKey.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else {
+            throw CrofUsageError.missingCredentials
+        }
+
+        var request = URLRequest(url: self.usageURL)
+        request.httpMethod = "GET"
+        request.timeoutInterval = Self.timeoutSeconds
+        request.setValue("Bearer \(trimmed)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+
+        let response: ProviderHTTPResponse
+        do {
+            response = try await transport.response(for: request)
+        } catch {
+            throw CrofUsageError.networkError(error.localizedDescription)
+        }
+
+        guard response.statusCode == 200 else {
+            throw CrofUsageError.apiError(response.statusCode)
+        }
+
+        return try self.parseSnapshot(response.data)
+    }
+
+    static func _parseSnapshotForTesting(_ data: Data) throws -> CrofUsageSnapshot {
+        try self.parseSnapshot(data)
+    }
+
+    private static func parseSnapshot(_ data: Data) throws -> CrofUsageSnapshot {
+        let decoded: CrofUsageResponse
+        do {
+            decoded = try JSONDecoder().decode(CrofUsageResponse.self, from: data)
+        } catch {
+            throw CrofUsageError.parseFailed(error.localizedDescription)
+        }
+
+        return CrofUsageSnapshot(
+            credits: decoded.credits,
+            requestsPlan: decoded.requestsPlan,
+            usableRequests: decoded.usableRequests,
+            updatedAt: Date())
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Crof/CrofUsageSnapshot.swift b/Sources/CodexBarCore/Providers/Crof/CrofUsageSnapshot.swift
new file mode 100644
index 0000000000..ee76bcb9e9
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Crof/CrofUsageSnapshot.swift
@@ -0,0 +1,83 @@
+import Foundation
+
+public struct CrofUsageSnapshot: Sendable {
+    private static let requestWindowMinutes = 24 * 60
+    private static let resetTimeZone = TimeZone(identifier: "America/Chicago") ?? TimeZone(secondsFromGMT: -5)!
+
+    public let credits: Double
+    public let requestsPlan: Double
+    public let usableRequests: Double
+    public let updatedAt: Date
+
+    public init(
+        credits: Double,
+        requestsPlan: Double,
+        usableRequests: Double,
+        updatedAt: Date = Date())
+    {
+        self.credits = credits
+        self.requestsPlan = requestsPlan
+        self.usableRequests = usableRequests
+        self.updatedAt = updatedAt
+    }
+
+    public func toUsageSnapshot() -> UsageSnapshot {
+        let usedPercent: Double
+        if self.requestsPlan > 0 {
+            let usableRequests = max(0, min(self.requestsPlan, self.usableRequests))
+            let remainingPercent = floor(usableRequests / self.requestsPlan * 100).clamped(to: 0...100)
+            usedPercent = 100 - remainingPercent
+        } else {
+            usedPercent = 100
+        }
+
+        let primary = RateWindow(
+            usedPercent: usedPercent,
+            windowMinutes: Self.requestWindowMinutes,
+            resetsAt: Self.nextRequestReset(after: self.updatedAt),
+            resetDescription: Self.formatRequestsLeft(self.usableRequests))
+
+        let creditsDetail = Self.formatCredits(self.credits)
+        let secondary = RateWindow(
+            // Crof returns a balance but no credit cap, so the bar only indicates present vs. exhausted credits.
+            usedPercent: self.credits > 0 ? 0 : 100,
+            windowMinutes: nil,
+            resetsAt: nil,
+            resetDescription: creditsDetail)
+
+        return UsageSnapshot(
+            primary: primary,
+            secondary: secondary,
+            providerCost: nil,
+            updatedAt: self.updatedAt,
+            identity: ProviderIdentitySnapshot(
+                providerID: .crof,
+                accountEmail: nil,
+                accountOrganization: nil,
+                loginMethod: "API key"))
+    }
+
+    private static func formatCredits(_ value: Double) -> String {
+        let clamped = max(0, value)
+        let cents = floor(clamped * 100) / 100
+        return String(format: "$%.2f", cents)
+    }
+
+    private static func formatRequestsLeft(_ value: Double) -> String {
+        let clamped = max(0, value)
+        let formatted = clamped.rounded() == clamped
+            ? String(format: "%.0f", clamped)
+            : String(format: "%.2f", clamped)
+        return "\(formatted) requests left"
+    }
+
+    private static func nextRequestReset(after date: Date) -> Date? {
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = Self.resetTimeZone
+
+        let startOfDay = calendar.startOfDay(for: date)
+        return startOfDay <= date
+            ? calendar.date(byAdding: .day, value: 1, to: startOfDay)
+            : startOfDay
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Cursor/CursorProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Cursor/CursorProviderDescriptor.swift
index e694e2e773..c6f1ff35fa 100644
--- a/Sources/CodexBarCore/Providers/Cursor/CursorProviderDescriptor.swift
+++ b/Sources/CodexBarCore/Providers/Cursor/CursorProviderDescriptor.swift
@@ -1,19 +1,18 @@
-import CodexBarMacroSupport
 import Foundation
 
-@ProviderDescriptorRegistration
-@ProviderDescriptorDefinition
 public enum CursorProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
     static func makeDescriptor() -> ProviderDescriptor {
         ProviderDescriptor(
             id: .cursor,
             metadata: ProviderMetadata(
                 id: .cursor,
                 displayName: "Cursor",
-                sessionLabel: "Plan",
-                weeklyLabel: "On-Demand",
-                opusLabel: nil,
-                supportsOpus: false,
+                sessionLabel: "Total",
+                weeklyLabel: "Auto",
+                opusLabel: "API",
+                supportsOpus: true,
                 supportsCredits: true,
                 creditsHint: "On-demand usage beyond included plan limits.",
                 toggleTitle: "Show Cursor usage",
@@ -21,7 +20,8 @@ public enum CursorProviderDescriptor {
                 defaultEnabled: false,
                 isPrimaryProvider: false,
                 usesAccountFallback: false,
-                browserCookieOrder: ProviderBrowserCookieDefaults.defaultImportOrder,
+                browserCookieOrder: ProviderBrowserCookieDefaults.cursorCookieImportOrder
+                    ?? ProviderBrowserCookieDefaults.defaultImportOrder,
                 dashboardURL: "https://cursor.com/dashboard?tab=usage",
                 statusPageURL: "https://status.cursor.com",
                 statusLinkURL: nil),
diff --git a/Sources/CodexBarCore/Providers/Cursor/CursorStatusProbe.swift b/Sources/CodexBarCore/Providers/Cursor/CursorStatusProbe.swift
index 84cca3c3dd..6bb82fa037 100644
--- a/Sources/CodexBarCore/Providers/Cursor/CursorStatusProbe.swift
+++ b/Sources/CodexBarCore/Providers/Cursor/CursorStatusProbe.swift
@@ -1,5 +1,11 @@
 import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
 import SweetCookieKit
+#if canImport(SQLite3)
+import SQLite3
+#endif
 
 #if os(macOS)
 
@@ -15,6 +21,20 @@ public enum CursorCookieImporter {
         "WorkosCursorSessionToken",
         "__Secure-next-auth.session-token",
         "next-auth.session-token",
+        // WorkOS AuthKit (common default; configurable server-side)
+        "wos-session",
+        "__Secure-wos-session",
+        // Auth.js v5
+        "authjs.session-token",
+        "__Secure-authjs.session-token",
+    ]
+
+    /// Hosts whose cookies may authenticate Cursor web/API requests.
+    private static let cookieDomains = [
+        "cursor.com",
+        "www.cursor.com",
+        "cursor.sh",
+        "authenticator.cursor.sh",
     ]
 
     public struct SessionInfo: Sendable {
@@ -31,35 +51,125 @@ public enum CursorCookieImporter {
         }
     }
 
+    /// Reads Cursor session cookies from one browser if present (no fallback to other browsers).
+    static func importSessionIfPresent(
+        browser: Browser,
+        browserDetection: BrowserDetection,
+        logger: ((String) -> Void)? = nil) -> SessionInfo?
+    {
+        self.importSessionsIfPresent(
+            browser: browser,
+            browserDetection: browserDetection,
+            logger: logger).first
+    }
+
+    /// Reads all Cursor session-cookie candidates from one browser source order.
+    static func importSessionsIfPresent(
+        browser: Browser,
+        browserDetection: BrowserDetection,
+        logger: ((String) -> Void)? = nil) -> [SessionInfo]
+    {
+        self.importCookiesFromBrowser(
+            browser: browser,
+            browserDetection: browserDetection,
+            requireKnownSessionName: true,
+            logger: logger)
+    }
+
+    /// Like ``importSessionIfPresent`` but accepts any non-empty cookie set for Cursor domains so the API can validate
+    /// (used after the strict name pass fails — e.g. new cookie names or host-only cookies).
+    static func importDomainCookiesIfPresent(
+        browser: Browser,
+        browserDetection: BrowserDetection,
+        logger: ((String) -> Void)? = nil) -> SessionInfo?
+    {
+        self.importDomainCookieSessionsIfPresent(
+            browser: browser,
+            browserDetection: browserDetection,
+            logger: logger).first
+    }
+
+    /// Reads fallback cookie candidates whose names are not already covered by the strict session-cookie pass.
+    static func importDomainCookieSessionsIfPresent(
+        browser: Browser,
+        browserDetection: BrowserDetection,
+        logger: ((String) -> Void)? = nil) -> [SessionInfo]
+    {
+        self.importCookiesFromBrowser(
+            browser: browser,
+            browserDetection: browserDetection,
+            requireKnownSessionName: false,
+            logger: logger)
+    }
+
+    private static func importCookiesFromBrowser(
+        browser: Browser,
+        browserDetection: BrowserDetection,
+        requireKnownSessionName: Bool,
+        logger: ((String) -> Void)?) -> [SessionInfo]
+    {
+        let log: (String) -> Void = { msg in logger?("[cursor-cookie] \(msg)") }
+        guard browserDetection.isCookieSourceAvailable(browser) else { return [] }
+        guard BrowserCookieAccessGate.shouldAttempt(browser) else { return [] }
+
+        do {
+            let query = BrowserCookieQuery(domains: Self.cookieDomains)
+            let sources = try Self.cookieClient.codexBarRecords(
+                matching: query,
+                in: browser,
+                logger: log)
+            var sessions: [SessionInfo] = []
+            for source in sources where !source.records.isEmpty {
+                let httpCookies = BrowserCookieClient.makeHTTPCookies(source.records, origin: query.origin)
+                let hasNamedSession = httpCookies.contains(where: { Self.sessionCookieNames.contains($0.name) })
+                if hasNamedSession {
+                    log("Found \(httpCookies.count) Cursor cookies in \(source.label)")
+                    if requireKnownSessionName {
+                        sessions.append(SessionInfo(cookies: httpCookies, sourceLabel: source.label))
+                    }
+                    continue
+                }
+                if !requireKnownSessionName, !httpCookies.isEmpty {
+                    log(
+                        "Found \(httpCookies.count) Cursor domain cookies in \(source.label) "
+                            + "(no known session name); will validate via API")
+                    sessions.append(SessionInfo(
+                        cookies: httpCookies,
+                        sourceLabel: "\(source.label) (domain cookies)"))
+                    continue
+                }
+                log("\(source.label) cookies found, but no Cursor session cookie present")
+            }
+            return sessions
+        } catch {
+            BrowserCookieAccessGate.recordIfNeeded(error)
+            log("\(browser.displayName) cookie import failed: \(error.localizedDescription)")
+        }
+        return []
+    }
+
     /// Attempts to import Cursor cookies using the standard browser import order.
     public static func importSession(
         browserDetection: BrowserDetection,
         logger: ((String) -> Void)? = nil) throws -> SessionInfo
     {
-        let log: (String) -> Void = { msg in logger?("[cursor-cookie] \(msg)") }
-
-        // Filter to cookie-eligible browsers to avoid unnecessary keychain prompts
         let installedBrowsers = cursorCookieImportOrder.cookieImportCandidates(using: browserDetection)
-        let cookieDomains = ["cursor.com", "cursor.sh"]
         for browserSource in installedBrowsers {
-            do {
-                let query = BrowserCookieQuery(domains: cookieDomains)
-                let sources = try Self.cookieClient.records(
-                    matching: query,
-                    in: browserSource,
-                    logger: log)
-                for source in sources where !source.records.isEmpty {
-                    let httpCookies = BrowserCookieClient.makeHTTPCookies(source.records, origin: query.origin)
-                    if httpCookies.contains(where: { Self.sessionCookieNames.contains($0.name) }) {
-                        log("Found \(httpCookies.count) Cursor cookies in \(source.label)")
-                        return SessionInfo(cookies: httpCookies, sourceLabel: source.label)
-                    } else {
-                        log("\(source.label) cookies found, but no Cursor session cookie present")
-                    }
-                }
-            } catch {
-                BrowserCookieAccessGate.recordIfNeeded(error)
-                log("\(browserSource.displayName) cookie import failed: \(error.localizedDescription)")
+            if let session = Self.importSessionsIfPresent(
+                browser: browserSource,
+                browserDetection: browserDetection,
+                logger: logger).first
+            {
+                return session
+            }
+        }
+        for browserSource in installedBrowsers {
+            if let session = Self.importDomainCookieSessionsIfPresent(
+                browser: browserSource,
+                browserDetection: browserDetection,
+                logger: logger).first
+            {
+                return session
             }
         }
 
@@ -94,6 +204,38 @@ public struct CursorUsageSummary: Codable, Sendable {
 public struct CursorIndividualUsage: Codable, Sendable {
     public let plan: CursorPlanUsage?
     public let onDemand: CursorOnDemandUsage?
+    /// Enterprise / team-member personal cap. Reported by Cursor when the account is part of a team or
+    /// enterprise plan with an individual quota. Values follow the same cents-based units as `plan`.
+    public let overall: CursorOverallUsage?
+
+    public init(
+        plan: CursorPlanUsage? = nil,
+        onDemand: CursorOnDemandUsage? = nil,
+        overall: CursorOverallUsage? = nil)
+    {
+        self.plan = plan
+        self.onDemand = onDemand
+        self.overall = overall
+    }
+}
+
+/// Personal cap reported under `individualUsage.overall` for Enterprise/Team members.
+/// Mirrors the shape of `CursorOnDemandUsage`; values are in cents.
+public struct CursorOverallUsage: Codable, Sendable {
+    public let enabled: Bool?
+    /// Usage in cents (e.g., 7384 = $73.84)
+    public let used: Int?
+    /// Limit in cents (e.g., 10000 = $100.00). `nil` indicates the API omitted a numeric cap.
+    public let limit: Int?
+    /// Remaining in cents.
+    public let remaining: Int?
+
+    public init(enabled: Bool? = nil, used: Int? = nil, limit: Int? = nil, remaining: Int? = nil) {
+        self.enabled = enabled
+        self.used = used
+        self.limit = limit
+        self.remaining = remaining
+    }
 }
 
 public struct CursorPlanUsage: Codable, Sendable {
@@ -128,6 +270,31 @@ public struct CursorOnDemandUsage: Codable, Sendable {
 
 public struct CursorTeamUsage: Codable, Sendable {
     public let onDemand: CursorOnDemandUsage?
+    /// Shared team/enterprise pool counted across all members. Same cents-based units as the other usage blocks.
+    public let pooled: CursorPooledUsage?
+
+    public init(onDemand: CursorOnDemandUsage? = nil, pooled: CursorPooledUsage? = nil) {
+        self.onDemand = onDemand
+        self.pooled = pooled
+    }
+}
+
+/// Shared team/enterprise pool reported under `teamUsage.pooled`. Values are in cents.
+public struct CursorPooledUsage: Codable, Sendable {
+    public let enabled: Bool?
+    /// Pool usage in cents.
+    public let used: Int?
+    /// Pool limit in cents. `nil` indicates an unlimited or unreported pool.
+    public let limit: Int?
+    /// Pool remaining in cents.
+    public let remaining: Int?
+
+    public init(enabled: Bool? = nil, used: Int? = nil, limit: Int? = nil, remaining: Int? = nil) {
+        self.enabled = enabled
+        self.used = used
+        self.limit = limit
+        self.remaining = remaining
+    }
 }
 
 // MARK: - Cursor Usage API Models (Legacy Request-Based Plans)
@@ -171,11 +338,155 @@ public struct CursorUserInfo: Codable, Sendable {
     }
 }
 
+// MARK: - Cursor App Auth
+
+struct CursorAppAuthSession: Equatable {
+    let accessToken: String
+
+    var isUsable: Bool {
+        guard !self.accessToken.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty,
+              (try? self.userID()) != nil,
+              let expiresAt = try? self.expiresAt()
+        else {
+            return false
+        }
+        return expiresAt.timeIntervalSinceNow > 60
+    }
+
+    func cookieHeader() throws -> String {
+        try "WorkosCursorSessionToken=\(self.userID())%3A%3A\(self.accessToken)"
+    }
+
+    func userID() throws -> String {
+        let json = try self.payload()
+        guard let subject = json["sub"] as? String,
+              let userID = subject.split(separator: "|", omittingEmptySubsequences: true).last.map(String.init),
+              !userID.isEmpty
+        else {
+            throw CursorStatusProbeError.parseFailed("Cursor.app access token is missing a user ID")
+        }
+
+        let allowed = CharacterSet.alphanumerics.union(CharacterSet(charactersIn: "._-"))
+        guard userID.unicodeScalars.allSatisfy(allowed.contains) else {
+            throw CursorStatusProbeError.parseFailed("Cursor.app access token has an invalid user ID")
+        }
+
+        return userID
+    }
+
+    private func expiresAt() throws -> Date {
+        let json = try self.payload()
+        guard let expiration = json["exp"] as? NSNumber else {
+            throw CursorStatusProbeError.parseFailed("Cursor.app access token is missing an expiration")
+        }
+        return Date(timeIntervalSince1970: expiration.doubleValue)
+    }
+
+    private func payload() throws -> [String: Any] {
+        let parts = self.accessToken.split(separator: ".", omittingEmptySubsequences: false)
+        guard parts.count >= 2 else {
+            throw CursorStatusProbeError.parseFailed("Cursor.app access token is not a JWT")
+        }
+
+        var payload = String(parts[1])
+            .replacingOccurrences(of: "-", with: "+")
+            .replacingOccurrences(of: "_", with: "/")
+        payload += String(repeating: "=", count: (4 - payload.count % 4) % 4)
+
+        guard let data = Data(base64Encoded: payload),
+              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+        else {
+            throw CursorStatusProbeError.parseFailed("Cursor.app access token has an invalid payload")
+        }
+
+        return json
+    }
+}
+
+protocol CursorAppAuthSessionProviding: Sendable {
+    func loadSession() throws -> CursorAppAuthSession?
+}
+
+struct CursorAppAuthStore: CursorAppAuthSessionProviding {
+    private static let defaultDBPath: String = {
+        let home = NSHomeDirectory()
+        return "\(home)/Library/Application Support/Cursor/User/globalStorage/state.vscdb"
+    }()
+
+    private let dbPath: String
+
+    init(dbPath: String? = nil) {
+        self.dbPath = dbPath ?? Self.defaultDBPath
+    }
+
+    func loadSession() throws -> CursorAppAuthSession? {
+        guard FileManager.default.fileExists(atPath: self.dbPath) else { return nil }
+
+        guard let accessToken = try self.value(for: "cursorAuth/accessToken"),
+              !accessToken.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+        else {
+            return nil
+        }
+
+        return CursorAppAuthSession(accessToken: accessToken)
+    }
+
+    private func value(for key: String) throws -> String? {
+        var db: OpaquePointer?
+        guard sqlite3_open_v2(self.dbPath, &db, SQLITE_OPEN_READONLY, nil) == SQLITE_OK else {
+            let message = db.flatMap { String(cString: sqlite3_errmsg($0)) } ?? "unknown error"
+            sqlite3_close(db)
+            throw CursorStatusProbeError.networkError("SQLite error reading Cursor app auth: \(message)")
+        }
+        defer { sqlite3_close(db) }
+        sqlite3_busy_timeout(db, 250)
+
+        let query = "SELECT value FROM ItemTable WHERE key = ? LIMIT 1;"
+        var stmt: OpaquePointer?
+        guard sqlite3_prepare_v2(db, query, -1, &stmt, nil) == SQLITE_OK else {
+            let message = db.flatMap { String(cString: sqlite3_errmsg($0)) } ?? "unknown error"
+            throw CursorStatusProbeError.networkError("SQLite error preparing Cursor app auth read: \(message)")
+        }
+        defer { sqlite3_finalize(stmt) }
+
+        sqlite3_bind_text(stmt, 1, key, -1, SQLITE_TRANSIENT)
+        let stepResult = sqlite3_step(stmt)
+        guard stepResult == SQLITE_ROW else {
+            if stepResult == SQLITE_DONE { return nil }
+            let message = db.flatMap { String(cString: sqlite3_errmsg($0)) } ?? "unknown error"
+            throw CursorStatusProbeError.networkError("SQLite error reading Cursor app auth: \(message)")
+        }
+
+        return Self.decodeSQLiteValue(stmt: stmt, index: 0)
+    }
+
+    private static func decodeSQLiteValue(stmt: OpaquePointer?, index: Int32) -> String? {
+        switch sqlite3_column_type(stmt, index) {
+        case SQLITE_TEXT:
+            guard let c = sqlite3_column_text(stmt, index) else { return nil }
+            return String(cString: c)
+        case SQLITE_BLOB:
+            guard let bytes = sqlite3_column_blob(stmt, index) else { return nil }
+            let data = Data(bytes: bytes, count: Int(sqlite3_column_bytes(stmt, index)))
+            return String(data: data, encoding: .utf8)
+                ?? String(data: data, encoding: .utf16LittleEndian)
+        default:
+            return nil
+        }
+    }
+}
+
+private let SQLITE_TRANSIENT = unsafeBitCast(-1, to: sqlite3_destructor_type.self)
+
 // MARK: - Cursor Status Snapshot
 
 public struct CursorStatusSnapshot: Sendable {
-    /// Percentage of included plan usage (0-100)
+    /// Percentage of included plan usage (0-100) — the "Total" headline number from Cursor's UI
     public let planPercentUsed: Double
+    /// Auto + Composer usage percent (0-100), nil when not available
+    public let autoPercentUsed: Double?
+    /// API (named model) usage percent (0-100), nil when not available
+    public let apiPercentUsed: Double?
     /// Included plan usage in USD
     public let planUsedUSD: Double
     /// Included plan limit in USD
@@ -188,6 +499,8 @@ public struct CursorStatusSnapshot: Sendable {
     public let teamOnDemandUsedUSD: Double?
     /// Team on-demand limit in USD
     public let teamOnDemandLimitUSD: Double?
+    /// Billing cycle start date
+    public let billingCycleStart: Date?
     /// Billing cycle reset date
     public let billingCycleEnd: Date?
     /// Membership type (e.g., "enterprise", "pro", "hobby")
@@ -213,12 +526,15 @@ public struct CursorStatusSnapshot: Sendable {
 
     public init(
         planPercentUsed: Double,
+        autoPercentUsed: Double? = nil,
+        apiPercentUsed: Double? = nil,
         planUsedUSD: Double,
         planLimitUSD: Double,
         onDemandUsedUSD: Double,
         onDemandLimitUSD: Double?,
         teamOnDemandUsedUSD: Double?,
         teamOnDemandLimitUSD: Double?,
+        billingCycleStart: Date? = nil,
         billingCycleEnd: Date?,
         membershipType: String?,
         accountEmail: String?,
@@ -228,12 +544,15 @@ public struct CursorStatusSnapshot: Sendable {
         requestsLimit: Int? = nil)
     {
         self.planPercentUsed = planPercentUsed
+        self.autoPercentUsed = autoPercentUsed
+        self.apiPercentUsed = apiPercentUsed
         self.planUsedUSD = planUsedUSD
         self.planLimitUSD = planLimitUSD
         self.onDemandUsedUSD = onDemandUsedUSD
         self.onDemandLimitUSD = onDemandLimitUSD
         self.teamOnDemandUsedUSD = teamOnDemandUsedUSD
         self.teamOnDemandLimitUSD = teamOnDemandLimitUSD
+        self.billingCycleStart = billingCycleStart
         self.billingCycleEnd = billingCycleEnd
         self.membershipType = membershipType
         self.accountEmail = accountEmail
@@ -245,63 +564,87 @@ public struct CursorStatusSnapshot: Sendable {
 
     /// Convert to UsageSnapshot for the common provider interface
     public func toUsageSnapshot() -> UsageSnapshot {
-        // Primary: For legacy request-based plans, use request usage; otherwise use plan percentage
-        let primaryUsedPercent: Double = if self.isLegacyRequestPlan,
-                                            let used = self.requestsUsed,
-                                            let limit = self.requestsLimit,
-                                            limit > 0
+        let cursorRequests: CursorRequestUsage? = if let used = self.requestsUsed,
+                                                     let limit = self.requestsLimit,
+                                                     limit > 0
         {
-            (Double(used) / Double(limit)) * 100
+            CursorRequestUsage(used: used, limit: limit)
         } else {
-            self.planPercentUsed
+            nil
         }
 
+        // Primary: For usable legacy request quotas, use request usage; otherwise preserve plan percentage.
+        let primaryUsedPercent = cursorRequests?.usedPercent ?? self.planPercentUsed
+
+        let billingCycleWindowMinutes = Self.billingCycleWindowMinutes(
+            start: self.billingCycleStart,
+            end: self.billingCycleEnd)
+
         let primary = RateWindow(
             usedPercent: primaryUsedPercent,
-            windowMinutes: nil,
+            windowMinutes: billingCycleWindowMinutes,
             resetsAt: self.billingCycleEnd,
             resetDescription: self.billingCycleEnd.map { Self.formatResetDate($0) })
 
-        // Always use individual on-demand values (what users see in their Cursor dashboard).
-        // Team values are aggregates across all members, not useful for individual tracking.
-        let resolvedOnDemandUsed = self.onDemandUsedUSD
-        let resolvedOnDemandLimit = self.onDemandLimitUSD
+        // Secondary: Auto + Composer usage (shown as its own bar below Total).
+        // Legacy request-based plans don't have the token-based Auto/API breakdown — those percentages
+        // come from the new usage-based pricing and are meaningless next to a request quota, so hide them.
+        let secondary: RateWindow? = cursorRequests != nil ? nil : self.autoPercentUsed.map { pct in
+            RateWindow(
+                usedPercent: pct,
+                windowMinutes: billingCycleWindowMinutes,
+                resetsAt: self.billingCycleEnd,
+                resetDescription: self.billingCycleEnd.map { Self.formatResetDate($0) })
+        }
 
-        // Secondary: On-demand usage as percentage of individual limit
-        let secondary: RateWindow? = if let limit = resolvedOnDemandLimit,
-                                        limit > 0
-        {
+        // Tertiary: API (named model) usage — hidden for legacy request-based plans (see above).
+        let tertiary: RateWindow? = cursorRequests != nil ? nil : self.apiPercentUsed.map { pct in
             RateWindow(
-                usedPercent: (resolvedOnDemandUsed / limit) * 100,
-                windowMinutes: nil,
+                usedPercent: pct,
+                windowMinutes: billingCycleWindowMinutes,
                 resetsAt: self.billingCycleEnd,
                 resetDescription: self.billingCycleEnd.map { Self.formatResetDate($0) })
+        }
+
+        // Prefer a personal cap. Team accounts with no user cap expose only the shared on-demand budget.
+        let resolvedOnDemandUsed: Double
+        let resolvedOnDemandLimit: Double?
+        if (self.onDemandLimitUSD ?? 0) > 0 {
+            resolvedOnDemandUsed = self.onDemandUsedUSD
+            resolvedOnDemandLimit = self.onDemandLimitUSD
+        } else if (self.teamOnDemandLimitUSD ?? 0) > 0 {
+            resolvedOnDemandUsed = self.teamOnDemandUsedUSD ?? 0
+            resolvedOnDemandLimit = self.teamOnDemandLimitUSD
+        } else {
+            resolvedOnDemandUsed = self.onDemandUsedUSD
+            resolvedOnDemandLimit = self.onDemandLimitUSD
+        }
+
+        // Your own on-demand spend to surface alongside a shared team pool (nil when the budget is personal).
+        let personalOnDemandUsed: Double? = if (self.onDemandLimitUSD ?? 0) > 0 {
+            nil
+        } else if (self.teamOnDemandLimitUSD ?? 0) > 0 {
+            self.onDemandUsedUSD > 0 ? self.onDemandUsedUSD : nil
         } else {
             nil
         }
 
-        // Provider cost snapshot for on-demand usage
-        let providerCost: ProviderCostSnapshot? = if resolvedOnDemandUsed > 0 {
+        // Provider cost snapshot for on-demand usage (include budget before first spend)
+        let providerCost: ProviderCostSnapshot? = if resolvedOnDemandUsed > 0
+            || (resolvedOnDemandLimit ?? 0) > 0
+        {
             ProviderCostSnapshot(
                 used: resolvedOnDemandUsed,
                 limit: resolvedOnDemandLimit ?? 0,
                 currencyCode: "USD",
-                period: "monthly",
+                period: "Monthly",
                 resetsAt: self.billingCycleEnd,
+                personalUsed: personalOnDemandUsed,
                 updatedAt: Date())
         } else {
             nil
         }
 
-        // Legacy plan request usage (when maxRequestUsage is set)
-        let cursorRequests: CursorRequestUsage? = if let used = self.requestsUsed,
-                                                     let limit = self.requestsLimit
-        {
-            CursorRequestUsage(used: used, limit: limit)
-        } else {
-            nil
-        }
-
         let identity = ProviderIdentitySnapshot(
             providerID: .cursor,
             accountEmail: self.accountEmail,
@@ -310,7 +653,7 @@ public struct CursorStatusSnapshot: Sendable {
         return UsageSnapshot(
             primary: primary,
             secondary: secondary,
-            tertiary: nil,
+            tertiary: tertiary,
             providerCost: providerCost,
             cursorRequests: cursorRequests,
             updatedAt: Date(),
@@ -324,6 +667,14 @@ public struct CursorStatusSnapshot: Sendable {
         return "Resets " + formatter.string(from: date)
     }
 
+    private static func billingCycleWindowMinutes(start: Date?, end: Date?) -> Int? {
+        guard let start,
+              let end
+        else { return nil }
+        let minutes = Int((end.timeIntervalSince(start) / 60).rounded())
+        return minutes > 0 ? minutes : nil
+    }
+
     private static func formatMembershipType(_ type: String) -> String {
         switch type.lowercased() {
         case "enterprise":
@@ -348,6 +699,9 @@ public enum CursorStatusProbeError: LocalizedError, Sendable {
     case parseFailed(String)
     case noSessionCookie
 
+    static let safariFullDiskAccessHint =
+        "If you use Safari, grant CodexBar Full Disk Access in System Settings ▸ Privacy & Security."
+
     public var errorDescription: String? {
         switch self {
         case .notLoggedIn:
@@ -357,7 +711,9 @@ public enum CursorStatusProbeError: LocalizedError, Sendable {
         case let .parseFailed(msg):
             "Could not parse Cursor usage: \(msg)"
         case .noSessionCookie:
-            "No Cursor session found. Please log in to cursor.com in \(cursorCookieImportOrder.loginHint)."
+            "No Cursor session found. \(Self.safariFullDiskAccessHint) "
+                + "Please log in to cursor.com in \(cursorCookieImportOrder.loginHint). "
+                + "You can also sign in to Cursor from the CodexBar menu (Add / switch account)."
         }
     }
 }
@@ -490,15 +846,46 @@ public struct CursorStatusProbe: Sendable {
     public let baseURL: URL
     public var timeout: TimeInterval = 15.0
     private let browserDetection: BrowserDetection
+    private let browserCookieImportOrder: BrowserCookieImportOrder
+    private let urlSession: any ProviderHTTPTransport
+    private let appAuthStore: any CursorAppAuthSessionProviding
 
     public init(
         baseURL: URL = URL(string: "https://cursor.com")!,
         timeout: TimeInterval = 15.0,
-        browserDetection: BrowserDetection)
+        browserDetection: BrowserDetection,
+        urlSession: any ProviderHTTPTransport = ProviderHTTPClient.shared)
+    {
+        self.init(
+            baseURL: baseURL,
+            timeout: timeout,
+            browserDetection: browserDetection,
+            browserCookieImportOrder: cursorCookieImportOrder,
+            urlSession: urlSession,
+            appAuthStore: CursorAppAuthStore())
+    }
+
+    init(
+        baseURL: URL = URL(string: "https://cursor.com")!,
+        timeout: TimeInterval = 15.0,
+        browserDetection: BrowserDetection,
+        browserCookieImportOrder: BrowserCookieImportOrder = cursorCookieImportOrder,
+        urlSession: any ProviderHTTPTransport = ProviderHTTPClient.shared,
+        appAuthStore: any CursorAppAuthSessionProviding)
     {
         self.baseURL = baseURL
         self.timeout = timeout
         self.browserDetection = browserDetection
+        self.browserCookieImportOrder = browserCookieImportOrder
+        self.urlSession = urlSession
+        self.appAuthStore = appAuthStore
+    }
+
+    /// Fetch Cursor usage using a first-party web session derived from Cursor.app's access token.
+    func fetchWithAppAuthSession(_ session: CursorAppAuthSession) async throws -> CursorStatusSnapshot {
+        try await self.fetchWithCookieHeader(
+            session.cookieHeader(),
+            requestUsageUserIDFallback: session.userID())
     }
 
     /// Fetch Cursor usage with manual cookie header (for debugging).
@@ -507,17 +894,23 @@ public struct CursorStatusProbe: Sendable {
     }
 
     /// Fetch Cursor usage using browser cookies with fallback to stored session.
-    public func fetch(cookieHeaderOverride: String? = nil, logger: ((String) -> Void)? = nil)
+    public func fetch(
+        cookieHeaderOverride: String? = nil,
+        allowCachedSessions: Bool = true,
+        allowAppAuthFallback: Bool = true,
+        logger: ((String) -> Void)? = nil)
         async throws -> CursorStatusSnapshot
     {
         let log: (String) -> Void = { msg in logger?("[cursor] \(msg)") }
+        var firstRecoverableError: CursorStatusProbeError?
 
         if let override = CookieHeaderNormalizer.normalize(cookieHeaderOverride) {
             log("Using manual cookie header")
             return try await self.fetchWithCookieHeader(override)
         }
 
-        if let cached = CookieHeaderCache.load(provider: .cursor),
+        if allowCachedSessions,
+           let cached = CookieHeaderCache.load(provider: .cursor),
            !cached.cookieHeader.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
         {
             log("Using cached cookie header from \(cached.sourceLabel)")
@@ -534,53 +927,229 @@ public struct CursorStatusProbe: Sendable {
             }
         }
 
-        // Try importing cookies from the configured browser order first.
-        do {
-            let session = try CursorCookieImporter.importSession(browserDetection: self.browserDetection, logger: log)
-            log("Using cookies from \(session.sourceLabel)")
-            let snapshot = try await self.fetchWithCookieHeader(session.cookieHeader)
-            CookieHeaderCache.store(
-                provider: .cursor,
-                cookieHeader: session.cookieHeader,
-                sourceLabel: session.sourceLabel)
+        // Try each browser in order. The first browser that *has* session cookie names is not always valid
+        // (e.g. stale Chrome tokens); keep trying until the API accepts a session or we run out of browsers.
+        let browserCandidates = self.browserCookieImportOrder.cookieImportCandidates(using: self.browserDetection)
+        switch await self.scanBrowsers(
+            browserCandidates,
+            importSessions: { browser in
+                CursorCookieImporter.importSessionsIfPresent(
+                    browser: browser,
+                    browserDetection: self.browserDetection,
+                    logger: log)
+            },
+            attemptFetch: { session in
+                await self.fetchIfSessionAccepted(session, log: log)
+            })
+        {
+        case let .succeeded(snapshot):
             return snapshot
-        } catch {
-            log("Browser cookie import failed: \(error.localizedDescription)")
+        case let .exhausted(error):
+            firstRecoverableError = error ?? firstRecoverableError
+        }
+
+        switch await self.scanBrowsers(
+            browserCandidates,
+            importSessions: { browser in
+                CursorCookieImporter.importDomainCookieSessionsIfPresent(
+                    browser: browser,
+                    browserDetection: self.browserDetection,
+                    logger: log)
+            },
+            attemptFetch: { session in
+                await self.fetchIfSessionAccepted(session, log: log)
+            })
+        {
+        case let .succeeded(snapshot):
+            return snapshot
+        case let .exhausted(error):
+            firstRecoverableError = error ?? firstRecoverableError
         }
 
         // Fall back to stored session cookies (from "Add Account" login flow)
-        let storedCookies = await CursorSessionStore.shared.getCookies()
-        if !storedCookies.isEmpty {
-            log("Using stored session cookies")
-            let cookieHeader = storedCookies.map { "\($0.name)=\($0.value)" }.joined(separator: "; ")
+        if allowCachedSessions {
+            let storedCookies = await CursorSessionStore.shared.getCookies()
+            if !storedCookies.isEmpty {
+                log("Using stored session cookies")
+                let cookieHeader = storedCookies.map { "\($0.name)=\($0.value)" }.joined(separator: "; ")
+                do {
+                    return try await self.fetchWithCookieHeader(cookieHeader)
+                } catch let error as CursorStatusProbeError {
+                    if case .notLoggedIn = error {
+                        // Clear only when auth is invalid; keep for transient failures.
+                        await CursorSessionStore.shared.clearCookies()
+                        log("Stored session invalid, cleared")
+                    } else {
+                        log("Stored session failed: \(error.localizedDescription)")
+                        firstRecoverableError = firstRecoverableError ?? error
+                    }
+                } catch {
+                    log("Stored session failed: \(error.localizedDescription)")
+                    firstRecoverableError = firstRecoverableError ?? .networkError(error.localizedDescription)
+                }
+            }
+        }
+
+        // A transient failure for an explicitly selected session must not switch to Cursor.app's account.
+        if let firstRecoverableError {
+            throw firstRecoverableError
+        }
+
+        // Last fallback: derive Cursor's first-party web session from the app token in its global state DB.
+        // Reusing the web flow preserves modern billing, legacy request quotas, and account-scoped identity.
+        if allowAppAuthFallback,
+           let appSession = try? self.appAuthStore.loadSession(),
+           appSession.isUsable
+        {
+            log("Using Cursor.app local auth fallback")
             do {
-                return try await self.fetchWithCookieHeader(cookieHeader)
-            } catch {
-                if case CursorStatusProbeError.notLoggedIn = error {
-                    // Clear only when auth is invalid; keep for transient failures.
-                    await CursorSessionStore.shared.clearCookies()
-                    log("Stored session invalid, cleared")
+                return try await self.fetchWithAppAuthSession(appSession)
+            } catch let error as CursorStatusProbeError {
+                if case .notLoggedIn = error {
+                    log("Cursor.app local auth was rejected")
                 } else {
-                    log("Stored session failed: \(error.localizedDescription)")
+                    firstRecoverableError = firstRecoverableError ?? error
                 }
+            } catch {
+                firstRecoverableError = firstRecoverableError ?? .networkError(error.localizedDescription)
             }
         }
 
+        if let firstRecoverableError {
+            throw firstRecoverableError
+        }
+
         throw CursorStatusProbeError.noSessionCookie
     }
 
-    private func fetchWithCookieHeader(_ cookieHeader: String) async throws -> CursorStatusSnapshot {
-        async let usageSummaryTask = self.fetchUsageSummary(cookieHeader: cookieHeader)
-        async let userInfoTask = self.fetchUserInfo(cookieHeader: cookieHeader)
+    enum ImportedSessionFetchOutcome {
+        case succeeded(CursorStatusSnapshot)
+        case tryNextBrowser
+        case failed(CursorStatusProbeError)
+    }
+
+    enum ImportedSessionScanResult {
+        case succeeded(CursorStatusSnapshot)
+        case exhausted(CursorStatusProbeError?)
+    }
+
+    func scanBrowsers(
+        _ browsers: [Browser],
+        importSessions: (Browser) -> [CursorCookieImporter.SessionInfo],
+        attemptFetch: (CursorCookieImporter.SessionInfo) async -> ImportedSessionFetchOutcome) async
+        -> ImportedSessionScanResult
+    {
+        var firstFailure: CursorStatusProbeError?
+
+        for browser in browsers {
+            let sessions = importSessions(browser)
+            guard !sessions.isEmpty else { continue }
+            for session in sessions {
+                switch await attemptFetch(session) {
+                case let .succeeded(snapshot):
+                    return .succeeded(snapshot)
+                case .tryNextBrowser:
+                    continue
+                case let .failed(error):
+                    firstFailure = firstFailure ?? error
+                }
+            }
+        }
+
+        return .exhausted(firstFailure)
+    }
+
+    func scanImportedSessions(
+        _ sessions: [CursorCookieImporter.SessionInfo],
+        attemptFetch: (CursorCookieImporter.SessionInfo) async -> ImportedSessionFetchOutcome) async
+        -> ImportedSessionScanResult
+    {
+        var firstFailure: CursorStatusProbeError?
+
+        for session in sessions {
+            switch await attemptFetch(session) {
+            case let .succeeded(snapshot):
+                return .succeeded(snapshot)
+            case .tryNextBrowser:
+                continue
+            case let .failed(error):
+                firstFailure = firstFailure ?? error
+            }
+        }
 
-        let (usageSummary, rawJSON) = try await usageSummaryTask
-        let userInfo = try? await userInfoTask
+        return .exhausted(firstFailure)
+    }
+
+    private func fetchIfSessionAccepted(
+        _ session: CursorCookieImporter.SessionInfo,
+        log: @escaping (String) -> Void) async -> ImportedSessionFetchOutcome
+    {
+        log("Trying Cursor session from \(session.sourceLabel)")
+        do {
+            let snapshot = try await self.fetchWithCookieHeader(session.cookieHeader)
+            CookieHeaderCache.store(
+                provider: .cursor,
+                cookieHeader: session.cookieHeader,
+                sourceLabel: session.sourceLabel)
+            return .succeeded(snapshot)
+        } catch let error as CursorStatusProbeError {
+            if case .notLoggedIn = error {
+                log("Cursor API rejected cookies from \(session.sourceLabel); trying next browser if any")
+                return .tryNextBrowser
+            }
+            log("Cursor fetch failed using \(session.sourceLabel): \(error.localizedDescription)")
+            return .failed(error)
+        } catch {
+            log("Cursor fetch failed using \(session.sourceLabel): \(error.localizedDescription)")
+            return .failed(.networkError(error.localizedDescription))
+        }
+    }
+
+    private func fetchWithCookieHeader(
+        _ cookieHeader: String,
+        requestUsageUserIDFallback: String? = nil) async throws -> CursorStatusSnapshot
+    {
+        enum FetchPart: Sendable {
+            case usageSummary((CursorUsageSummary, String))
+            case userInfo(Result<CursorUserInfo, Error>)
+        }
+
+        var usageSummaryResult: (CursorUsageSummary, String)?
+        var userInfo: CursorUserInfo?
+
+        try await withThrowingTaskGroup(of: FetchPart.self) { group in
+            group.addTask {
+                try await .usageSummary(self.fetchUsageSummary(cookieHeader: cookieHeader))
+            }
+            group.addTask {
+                do {
+                    return try await .userInfo(.success(self.fetchUserInfo(cookieHeader: cookieHeader)))
+                } catch {
+                    return .userInfo(.failure(error))
+                }
+            }
+
+            while let result = try await group.next() {
+                switch result {
+                case let .usageSummary(value):
+                    usageSummaryResult = value
+                case let .userInfo(value):
+                    userInfo = try? value.get()
+                }
+            }
+        }
+
+        guard let usageSummaryResult else {
+            throw CursorStatusProbeError.networkError("Cursor usage summary fetch did not complete")
+        }
+
+        let (usageSummary, rawJSON) = usageSummaryResult
 
         // Fetch legacy request usage only if user has a sub ID.
         // Uses try? to avoid breaking the flow for users where this endpoint fails or returns unexpected data.
         var requestUsage: CursorUsageResponse?
         var requestUsageRawJSON: String?
-        if let userId = userInfo?.sub {
+        if let userId = userInfo?.sub ?? requestUsageUserIDFallback {
             do {
                 let (usage, usageRawJSON) = try await self.fetchRequestUsage(userId: userId, cookieHeader: cookieHeader)
                 requestUsage = usage
@@ -610,7 +1179,7 @@ public struct CursorStatusProbe: Sendable {
         request.setValue("application/json", forHTTPHeaderField: "Accept")
         request.setValue(cookieHeader, forHTTPHeaderField: "Cookie")
 
-        let (data, response) = try await URLSession.shared.data(for: request)
+        let (data, response) = try await self.urlSession.data(for: request)
 
         guard let httpResponse = response as? HTTPURLResponse else {
             throw CursorStatusProbeError.networkError("Invalid response")
@@ -643,7 +1212,7 @@ public struct CursorStatusProbe: Sendable {
         request.setValue("application/json", forHTTPHeaderField: "Accept")
         request.setValue(cookieHeader, forHTTPHeaderField: "Cookie")
 
-        let (data, response) = try await URLSession.shared.data(for: request)
+        let (data, response) = try await self.urlSession.data(for: request)
 
         guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
             throw CursorStatusProbeError.networkError("Failed to fetch user info")
@@ -664,7 +1233,7 @@ public struct CursorStatusProbe: Sendable {
         request.setValue("application/json", forHTTPHeaderField: "Accept")
         request.setValue(cookieHeader, forHTTPHeaderField: "Cookie")
 
-        let (data, response) = try await URLSession.shared.data(for: request)
+        let (data, response) = try await self.urlSession.data(for: request)
 
         guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
             throw CursorStatusProbeError.networkError("Failed to fetch request usage")
@@ -682,27 +1251,89 @@ public struct CursorStatusProbe: Sendable {
         rawJSON: String?,
         requestUsage: CursorUsageResponse? = nil) -> CursorStatusSnapshot
     {
-        // Parse billing cycle end date
-        let billingCycleEnd: Date? = summary.billingCycleEnd.flatMap { dateString in
+        func parseBillingCycleDate(_ dateString: String?) -> Date? {
+            guard let dateString else { return nil }
             let formatter = ISO8601DateFormatter()
             formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
             return formatter.date(from: dateString) ?? ISO8601DateFormatter().date(from: dateString)
         }
+        let billingCycleStart = parseBillingCycleDate(summary.billingCycleStart)
+        let billingCycleEnd = parseBillingCycleDate(summary.billingCycleEnd)
 
         // Convert cents to USD (plan percent derives from raw values to avoid percent unit mismatches).
         // Use plan.limit directly - breakdown.total represents total *used* credits, not the limit.
         let planUsedRaw = Double(summary.individualUsage?.plan?.used ?? 0)
         let planLimitRaw = Double(summary.individualUsage?.plan?.limit ?? 0)
-        let planUsed = planUsedRaw / 100.0
-        let planLimit = planLimitRaw / 100.0
-        let planPercentUsed: Double = if planLimitRaw > 0 {
+        func normPct(_ value: Double?) -> Double? {
+            guard let v = value else { return nil }
+            if v < 0 { return 0 }
+            if v > 100 { return 100 }
+            return v
+        }
+
+        func normalizeTotalPercent(_ v: Double) -> Double {
+            max(0, min(100, v))
+        }
+
+        // Cursor's usage-summary percent fields are already in percentage units, even when they are fractional
+        // values below 1.0 (for example 0.36 means 0.36%, which the dashboard rounds to 0%).
+        let autoPercent = normPct(summary.individualUsage?.plan?.autoPercentUsed)
+        let apiPercent = normPct(summary.individualUsage?.plan?.apiPercentUsed)
+
+        // Enterprise / team-member personal cap (cents). Reported under `individualUsage.overall` for accounts
+        // that don't get a `plan` block. Falls through to existing logic when absent so non-enterprise paths
+        // are untouched.
+        let overallUsedRaw = (summary.individualUsage?.overall?.used).map(Double.init)
+        let overallLimitRaw = (summary.individualUsage?.overall?.limit).map(Double.init)
+
+        // Shared team/enterprise pool (cents). Last-resort fallback when no individual data is available.
+        let pooledUsedRaw = (summary.teamUsage?.pooled?.used).map(Double.init)
+        let pooledLimitRaw = (summary.teamUsage?.pooled?.limit).map(Double.init)
+
+        // Headline "Total" precedence:
+        //   1. `individualUsage.plan.totalPercentUsed` (existing behavior for Pro/Hobby/etc.)
+        //   2. averaged `auto` + `api` lane percents (existing behavior)
+        //   3. either lane alone (existing behavior)
+        //   4. `individualUsage.plan` ratio (existing behavior)
+        //   5. NEW: `individualUsage.overall` ratio (Enterprise/Team personal cap)
+        //   6. NEW: `teamUsage.pooled` ratio (last resort when no individual data is reported)
+        let planPercentUsed: Double = if let totalPercentUsed = summary.individualUsage?.plan?.totalPercentUsed {
+            normalizeTotalPercent(totalPercentUsed)
+        } else if let autoUsed = autoPercent, let apiUsed = apiPercent {
+            max(0, min(100, (autoUsed + apiUsed) / 2))
+        } else if let apiUsed = apiPercent {
+            max(0, min(100, apiUsed))
+        } else if let autoUsed = autoPercent {
+            max(0, min(100, autoUsed))
+        } else if planLimitRaw > 0 {
             (planUsedRaw / planLimitRaw) * 100
-        } else if let totalPercentUsed = summary.individualUsage?.plan?.totalPercentUsed {
-            totalPercentUsed <= 1 ? totalPercentUsed * 100 : totalPercentUsed
+        } else if let used = overallUsedRaw, let limit = overallLimitRaw, limit > 0 {
+            normalizeTotalPercent((used / limit) * 100)
+        } else if let used = pooledUsedRaw, let limit = pooledLimitRaw, limit > 0 {
+            normalizeTotalPercent((used / limit) * 100)
         } else {
             0
         }
 
+        // USD figures: prefer the source the headline ultimately came from. When `plan` is missing but
+        // `overall` or `pooled` carry the cents, surface those so the on-demand display and downstream
+        // consumers see real dollar amounts instead of zeros.
+        let planUsed: Double
+        let planLimit: Double
+        if planLimitRaw > 0 || planUsedRaw > 0 {
+            planUsed = planUsedRaw / 100.0
+            planLimit = planLimitRaw / 100.0
+        } else if let usedCents = overallUsedRaw, let limitCents = overallLimitRaw {
+            planUsed = usedCents / 100.0
+            planLimit = limitCents / 100.0
+        } else if let usedCents = pooledUsedRaw, let limitCents = pooledLimitRaw {
+            planUsed = usedCents / 100.0
+            planLimit = limitCents / 100.0
+        } else {
+            planUsed = 0
+            planLimit = 0
+        }
+
         let onDemandUsed = Double(summary.individualUsage?.onDemand?.used ?? 0) / 100.0
         let onDemandLimit: Double? = summary.individualUsage?.onDemand?.limit.map { Double($0) / 100.0 }
 
@@ -715,12 +1346,15 @@ public struct CursorStatusProbe: Sendable {
 
         return CursorStatusSnapshot(
             planPercentUsed: planPercentUsed,
+            autoPercentUsed: autoPercent,
+            apiPercentUsed: apiPercent,
             planUsedUSD: planUsed,
             planLimitUSD: planLimit,
             onDemandUsedUSD: onDemandUsed,
             onDemandLimitUSD: onDemandLimit,
             teamOnDemandUsedUSD: teamOnDemandUsed,
             teamOnDemandLimitUSD: teamOnDemandLimit,
+            billingCycleStart: billingCycleStart,
             billingCycleEnd: billingCycleEnd,
             membershipType: summary.membershipType,
             accountEmail: userInfo?.email,
@@ -761,11 +1395,13 @@ public struct CursorStatusProbe: Sendable {
     public init(
         baseURL: URL = URL(string: "https://cursor.com")!,
         timeout: TimeInterval = 15.0,
-        browserDetection: BrowserDetection)
+        browserDetection: BrowserDetection,
+        urlSession: any ProviderHTTPTransport = ProviderHTTPClient.shared)
     {
         _ = baseURL
         _ = timeout
         _ = browserDetection
+        _ = urlSession
     }
 
     public func fetch(logger: ((String) -> Void)? = nil) async throws -> CursorStatusSnapshot {
@@ -775,6 +1411,7 @@ public struct CursorStatusProbe: Sendable {
 
     public func fetch(
         cookieHeaderOverride _: String? = nil,
+        allowCachedSessions _: Bool = true,
         logger: ((String) -> Void)? = nil) async throws -> CursorStatusSnapshot
     {
         try await self.fetch(logger: logger)
diff --git a/Sources/CodexBarCore/Providers/DeepSeek/DeepSeekProviderDescriptor.swift b/Sources/CodexBarCore/Providers/DeepSeek/DeepSeekProviderDescriptor.swift
new file mode 100644
index 0000000000..f2847c787d
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/DeepSeek/DeepSeekProviderDescriptor.swift
@@ -0,0 +1,48 @@
+import Foundation
+
+public enum DeepSeekProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .deepseek,
+            metadata: ProviderMetadata(
+                id: .deepseek,
+                displayName: "DeepSeek",
+                sessionLabel: "Balance",
+                weeklyLabel: "Balance",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "",
+                toggleTitle: "Show DeepSeek usage",
+                cliName: "deepseek",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                browserCookieOrder: nil,
+                dashboardURL: "https://platform.deepseek.com/usage",
+                statusPageURL: nil,
+                statusLinkURL: "https://status.deepseek.com"),
+            branding: ProviderBranding(
+                iconStyle: .deepseek,
+                iconResourceName: "ProviderIcon-deepseek",
+                color: ProviderColor(red: 0.32, green: 0.49, blue: 0.94)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "DeepSeek per-day cost history is not available via API." }),
+            fetchPlan: .apiToken(
+                strategyID: "deepseek.api",
+                resolveToken: { ProviderTokenResolver.deepseekToken(environment: $0) },
+                missingCredentialsError: { DeepSeekUsageError.missingCredentials },
+                loadUsage: { apiKey, context in
+                    try await DeepSeekUsageFetcher.fetchUsage(
+                        apiKey: apiKey,
+                        includeOptionalUsage: context.includeOptionalUsage).toUsageSnapshot()
+                }),
+            cli: ProviderCLIConfig(
+                name: "deepseek",
+                aliases: ["deep-seek", "ds"],
+                versionDetector: nil))
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/DeepSeek/DeepSeekSettingsReader.swift b/Sources/CodexBarCore/Providers/DeepSeek/DeepSeekSettingsReader.swift
new file mode 100644
index 0000000000..3c787cabc3
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/DeepSeek/DeepSeekSettingsReader.swift
@@ -0,0 +1,33 @@
+import Foundation
+
+public struct DeepSeekSettingsReader: Sendable {
+    public static let apiKeyEnvironmentKey = "DEEPSEEK_API_KEY"
+    public static let apiKeyEnvironmentKeys = [Self.apiKeyEnvironmentKey, "DEEPSEEK_KEY"]
+
+    public static func apiKey(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        for key in self.apiKeyEnvironmentKeys {
+            guard let raw = environment[key]?.trimmingCharacters(in: .whitespacesAndNewlines),
+                  !raw.isEmpty
+            else {
+                continue
+            }
+            let cleaned = Self.cleaned(raw)
+            if !cleaned.isEmpty {
+                return cleaned
+            }
+        }
+        return nil
+    }
+
+    private static func cleaned(_ raw: String) -> String {
+        var value = raw
+        if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
+            (value.hasPrefix("'") && value.hasSuffix("'"))
+        {
+            value = String(value.dropFirst().dropLast())
+        }
+        return value.trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/DeepSeek/DeepSeekUsageCostParser.swift b/Sources/CodexBarCore/Providers/DeepSeek/DeepSeekUsageCostParser.swift
new file mode 100644
index 0000000000..77e6e4f25b
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/DeepSeek/DeepSeekUsageCostParser.swift
@@ -0,0 +1,709 @@
+import Foundation
+
+// MARK: - Amount Response Models
+
+struct DeepSeekAmountPayload: Decodable {
+    let code: Int?
+    let msg: String?
+    let data: DeepSeekAmountData?
+
+    private enum CodingKeys: String, CodingKey {
+        case code, msg, data
+    }
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.code = try container.decodeIfPresent(Int.self, forKey: .code)
+        self.msg = try container.decodeIfPresent(String.self, forKey: .msg)
+        if container.contains(.data) {
+            if let dataValue = try? container.decodeIfPresent(DeepSeekAmountData.self, forKey: .data) {
+                self.data = dataValue
+            } else {
+                self.data = nil
+            }
+        } else {
+            self.data = nil
+        }
+    }
+}
+
+struct DeepSeekAmountData: Decodable {
+    let bizCode: Int?
+    let bizMsg: String?
+    let bizData: DeepSeekAmountBizData?
+
+    private enum CodingKeys: String, CodingKey {
+        case bizCode = "biz_code"
+        case bizMsg = "biz_msg"
+        case bizData = "biz_data"
+    }
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.bizCode = try container.decodeIfPresent(Int.self, forKey: .bizCode)
+        self.bizMsg = try container.decodeIfPresent(String.self, forKey: .bizMsg)
+        if container.contains(.bizData) {
+            if let dataValue = try? container.decodeIfPresent(DeepSeekAmountBizData.self, forKey: .bizData) {
+                self.bizData = dataValue
+            } else {
+                self.bizData = nil
+            }
+        } else {
+            self.bizData = nil
+        }
+    }
+}
+
+struct DeepSeekAmountBizData: Decodable {
+    let total: [DeepSeekModelUsage]?
+    let days: [DeepSeekDayUsage]?
+
+    private enum CodingKeys: String, CodingKey {
+        case total, days
+    }
+}
+
+// MARK: - Cost Response Models
+
+struct DeepSeekCostPayload: Decodable {
+    let code: Int?
+    let msg: String?
+    let data: DeepSeekCostData?
+
+    private enum CodingKeys: String, CodingKey {
+        case code, msg, data
+    }
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.code = try container.decodeIfPresent(Int.self, forKey: .code)
+        self.msg = try container.decodeIfPresent(String.self, forKey: .msg)
+        if container.contains(.data) {
+            if let dataValue = try? container.decodeIfPresent(DeepSeekCostData.self, forKey: .data) {
+                self.data = dataValue
+            } else {
+                self.data = nil
+            }
+        } else {
+            self.data = nil
+        }
+    }
+}
+
+struct DeepSeekCostData: Decodable {
+    let bizCode: Int?
+    let bizMsg: String?
+    let bizData: [DeepSeekCostBizDataItem]?
+
+    private enum CodingKeys: String, CodingKey {
+        case bizCode = "biz_code"
+        case bizMsg = "biz_msg"
+        case bizData = "biz_data"
+    }
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.bizCode = try container.decodeIfPresent(Int.self, forKey: .bizCode)
+        self.bizMsg = try container.decodeIfPresent(String.self, forKey: .bizMsg)
+        self.bizData = try container.decodeIfPresent([DeepSeekCostBizDataItem].self, forKey: .bizData)
+    }
+}
+
+struct DeepSeekCostBizDataItem: Decodable {
+    let total: [DeepSeekCostModelUsage]?
+    let days: [DeepSeekCostDayUsage]?
+    let currency: String?
+
+    private enum CodingKeys: String, CodingKey {
+        case total, days, currency
+    }
+}
+
+// MARK: - Shared Models
+
+struct DeepSeekModelUsage: Decodable {
+    let model: String?
+    let usage: [DeepSeekUsageItem]?
+
+    private enum CodingKeys: String, CodingKey {
+        case model, usage
+    }
+}
+
+struct DeepSeekDayUsage: Decodable {
+    let date: String?
+    let data: [DeepSeekModelUsage]?
+
+    private enum CodingKeys: String, CodingKey {
+        case date, data
+    }
+}
+
+struct DeepSeekUsageItem: Decodable {
+    let type: String?
+    let amount: String?
+
+    private enum CodingKeys: String, CodingKey {
+        case type, amount
+    }
+}
+
+struct DeepSeekCostModelUsage: Decodable {
+    let model: String?
+    let usage: [DeepSeekCostItem]?
+
+    private enum CodingKeys: String, CodingKey {
+        case model, usage
+    }
+}
+
+struct DeepSeekCostDayUsage: Decodable {
+    let date: String?
+    let data: [DeepSeekCostModelUsage]?
+
+    private enum CodingKeys: String, CodingKey {
+        case date, data
+    }
+}
+
+struct DeepSeekCostItem: Decodable {
+    let type: String?
+    let amount: String?
+
+    private enum CodingKeys: String, CodingKey {
+        case type, amount
+    }
+}
+
+// MARK: - Domain Models
+
+public struct DeepSeekUsageSummary: Sendable, Equatable {
+    public let todayTokens: Int
+    public let currentMonthTokens: Int
+    public let todayCost: Double?
+    public let currentMonthCost: Double?
+    public let requestCount: Int
+    public let currentMonthRequestCount: Int
+    public let topModel: String?
+    public let categoryBreakdown: [DeepSeekCategoryBreakdown]
+    public let daily: [DeepSeekDailyUsage]
+    public let currency: String
+    public let updatedAt: Date
+
+    public init(
+        todayTokens: Int,
+        currentMonthTokens: Int,
+        todayCost: Double?,
+        currentMonthCost: Double?,
+        requestCount: Int,
+        currentMonthRequestCount: Int,
+        topModel: String?,
+        categoryBreakdown: [DeepSeekCategoryBreakdown],
+        daily: [DeepSeekDailyUsage],
+        currency: String,
+        updatedAt: Date)
+    {
+        self.todayTokens = todayTokens
+        self.currentMonthTokens = currentMonthTokens
+        self.todayCost = todayCost
+        self.currentMonthCost = currentMonthCost
+        self.requestCount = requestCount
+        self.currentMonthRequestCount = currentMonthRequestCount
+        self.topModel = topModel
+        self.categoryBreakdown = categoryBreakdown
+        self.daily = daily
+        self.currency = currency
+        self.updatedAt = updatedAt
+    }
+}
+
+public struct DeepSeekCategoryBreakdown: Sendable, Equatable {
+    public let category: DeepSeekUsageCategory
+    public let tokens: Int
+    public let cost: Double?
+
+    public init(category: DeepSeekUsageCategory, tokens: Int, cost: Double?) {
+        self.category = category
+        self.tokens = tokens
+        self.cost = cost
+    }
+}
+
+public enum DeepSeekUsageCategory: String, Sendable, Equatable {
+    case promptCacheHitToken = "PROMPT_CACHE_HIT_TOKEN"
+    case promptCacheMissToken = "PROMPT_CACHE_MISS_TOKEN"
+    case responseToken = "RESPONSE_TOKEN"
+    case request = "REQUEST"
+
+    public init?(rawValue: String) {
+        switch rawValue.uppercased() {
+        case "PROMPT_CACHE_HIT_TOKEN":
+            self = .promptCacheHitToken
+        case "PROMPT_CACHE_MISS_TOKEN":
+            self = .promptCacheMissToken
+        case "RESPONSE_TOKEN":
+            self = .responseToken
+        case "REQUEST":
+            self = .request
+        default:
+            return nil
+        }
+    }
+}
+
+public struct DeepSeekDailyUsage: Sendable, Equatable {
+    public let date: String
+    public let totalTokens: Int
+    public let cost: Double?
+    public let requestCount: Int
+
+    public init(date: String, totalTokens: Int, cost: Double?, requestCount: Int) {
+        self.date = date
+        self.totalTokens = totalTokens
+        self.cost = cost
+        self.requestCount = requestCount
+    }
+}
+
+// MARK: - Parsing
+
+enum DeepSeekUsageCostParser {
+    static func decodeAmountPayload(data: Data) throws -> DeepSeekAmountPayload {
+        try JSONDecoder().decode(DeepSeekAmountPayload.self, from: data)
+    }
+
+    static func decodeCostPayload(data: Data) throws -> DeepSeekCostPayload {
+        try JSONDecoder().decode(DeepSeekCostPayload.self, from: data)
+    }
+
+    static func parse(
+        amountData: Data,
+        costData: Data,
+        now: Date = Date(),
+        calendar: Calendar = .current) throws -> DeepSeekUsageSummary
+    {
+        let amountPayload: DeepSeekAmountPayload
+        let costPayload: DeepSeekCostPayload
+        do {
+            amountPayload = try self.decodeAmountPayload(data: amountData)
+        } catch {
+            throw DeepSeekUsageError.parseFailed("amount: \(error.localizedDescription)")
+        }
+        do {
+            costPayload = try self.decodeCostPayload(data: costData)
+        } catch {
+            throw DeepSeekUsageError.parseFailed("cost: \(error.localizedDescription)")
+        }
+
+        // Validate responses
+        if let code = amountPayload.code, code != 0 {
+            throw DeepSeekUsageError.apiError("amount code \(code)")
+        }
+        if let bizCode = amountPayload.data?.bizCode, bizCode != 0 {
+            throw DeepSeekUsageError.apiError("amount biz_code \(bizCode)")
+        }
+        if let code = costPayload.code, code != 0 {
+            throw DeepSeekUsageError.apiError("cost code \(code)")
+        }
+        if let bizCode = costPayload.data?.bizCode, bizCode != 0 {
+            throw DeepSeekUsageError.apiError("cost biz_code \(bizCode)")
+        }
+
+        guard let amountBizData = amountPayload.data?.bizData else {
+            throw DeepSeekUsageError.parseFailed("Missing amount biz_data")
+        }
+
+        let currency = costPayload.data?.bizData?.first?.currency ?? "CNY"
+
+        // Parse total amounts
+        let totalAmounts = amountBizData.total ?? []
+        let totalCosts = costPayload.data?.bizData?.first?.total ?? []
+
+        // Parse daily data
+        let dailyAmounts = amountBizData.days ?? []
+        let dailyCosts = costPayload.data?.bizData?.first?.days ?? []
+
+        return self.aggregate(input: AggregationInput(
+            totalAmounts: totalAmounts,
+            totalCosts: totalCosts,
+            dailyAmounts: dailyAmounts,
+            dailyCosts: dailyCosts,
+            currency: currency,
+            now: now,
+            calendar: calendar))
+    }
+
+    // MARK: - Aggregation
+
+    private struct AggregationContext {
+        let calendar: Calendar
+        let todayString: String
+        let startOfMonth: Date
+        let now: Date
+        let dailyAmountMap: [String: [String: [DeepSeekUsageItem]]]
+        let dailyCostMap: [String: [String: [DeepSeekCostItem]]]
+        let allDates: Set<String>
+
+        init(
+            dailyAmounts: [DeepSeekDayUsage],
+            dailyCosts: [DeepSeekCostDayUsage],
+            now: Date,
+            calendar: Calendar)
+        {
+            self.calendar = calendar
+            self.now = now
+            self.todayString = Self.dayString(now, calendar: calendar)
+
+            var components = calendar.dateComponents([.year, .month], from: now)
+            components.day = 1
+            self.startOfMonth = calendar.date(from: components) ?? now
+
+            self.dailyAmountMap = Self.buildAmountMap(from: dailyAmounts)
+            self.dailyCostMap = Self.buildCostMap(from: dailyCosts)
+
+            var dates: Set<String> = []
+            for date in self.dailyAmountMap.keys {
+                dates.insert(date)
+            }
+            for date in self.dailyCostMap.keys {
+                dates.insert(date)
+            }
+            self.allDates = dates
+        }
+
+        static func dayString(_ date: Date, calendar: Calendar) -> String {
+            let components = calendar.dateComponents([.year, .month, .day], from: date)
+            guard let year = components.year,
+                  let month = components.month,
+                  let day = components.day
+            else { return "" }
+            return String(format: "%04d-%02d-%02d", year, month, day)
+        }
+
+        static func buildAmountMap(
+            from dailyAmounts: [DeepSeekDayUsage]) -> [String: [String: [DeepSeekUsageItem]]]
+        {
+            var result: [String: [String: [DeepSeekUsageItem]]] = [:]
+            for dayUsage in dailyAmounts {
+                guard let date = dayUsage.date else { continue }
+                var modelMap: [String: [DeepSeekUsageItem]] = [:]
+                for modelUsage in dayUsage.data ?? [] {
+                    guard let model = modelUsage.model else { continue }
+                    let items = modelUsage.usage ?? []
+                    if !items.isEmpty {
+                        modelMap[model] = items
+                    }
+                }
+                if !modelMap.isEmpty {
+                    result[date] = modelMap
+                }
+            }
+            return result
+        }
+
+        static func buildCostMap(
+            from dailyCosts: [DeepSeekCostDayUsage]) -> [String: [String: [DeepSeekCostItem]]]
+        {
+            var result: [String: [String: [DeepSeekCostItem]]] = [:]
+            for dayUsage in dailyCosts {
+                guard let date = dayUsage.date else { continue }
+                var modelMap: [String: [DeepSeekCostItem]] = [:]
+                for modelUsage in dayUsage.data ?? [] {
+                    guard let model = modelUsage.model else { continue }
+                    let items = modelUsage.usage ?? []
+                    if !items.isEmpty {
+                        modelMap[model] = items
+                    }
+                }
+                if !modelMap.isEmpty {
+                    result[date] = modelMap
+                }
+            }
+            return result
+        }
+    }
+
+    private struct AggregationInput {
+        let totalAmounts: [DeepSeekModelUsage]
+        let totalCosts: [DeepSeekCostModelUsage]
+        let dailyAmounts: [DeepSeekDayUsage]
+        let dailyCosts: [DeepSeekCostDayUsage]
+        let currency: String
+        let now: Date
+        let calendar: Calendar
+    }
+
+    private static func aggregate(input: AggregationInput) -> DeepSeekUsageSummary {
+        let ctx = AggregationContext(
+            dailyAmounts: input.dailyAmounts,
+            dailyCosts: input.dailyCosts,
+            now: input.now,
+            calendar: input.calendar)
+
+        // Today aggregation
+        let todayResult = self.aggregateDay(
+            dateString: ctx.todayString,
+            amountMap: ctx.dailyAmountMap,
+            costMap: ctx.dailyCostMap,
+            calendar: ctx.calendar)
+
+        // Month aggregation
+        let dailyCtx = DailyAggregationContext(
+            allDates: ctx.allDates,
+            startOfMonth: ctx.startOfMonth,
+            now: ctx.now,
+            amountMap: ctx.dailyAmountMap,
+            costMap: ctx.dailyCostMap,
+            calendar: ctx.calendar)
+        let monthResult = self.aggregateMonth(ctx: dailyCtx)
+
+        // Model and category breakdown from totals
+        let (topModel, categoryBreakdown) = self.buildBreakdowns(
+            totalAmounts: input.totalAmounts,
+            totalCosts: input.totalCosts)
+
+        // Daily usage array
+        let dailyUsages = self.buildDailyUsages(ctx: dailyCtx)
+
+        return DeepSeekUsageSummary(
+            todayTokens: todayResult.tokens,
+            currentMonthTokens: monthResult.tokens,
+            todayCost: todayResult.cost,
+            currentMonthCost: monthResult.cost,
+            requestCount: todayResult.requests,
+            currentMonthRequestCount: monthResult.requests,
+            topModel: topModel,
+            categoryBreakdown: categoryBreakdown,
+            daily: dailyUsages,
+            currency: input.currency,
+            updatedAt: input.now)
+    }
+
+    private struct DayAggregationResult {
+        let tokens: Int
+        let cost: Double?
+        let requests: Int
+    }
+
+    private struct DailyAggregationContext {
+        let allDates: Set<String>
+        let startOfMonth: Date
+        let now: Date
+        let amountMap: [String: [String: [DeepSeekUsageItem]]]
+        let costMap: [String: [String: [DeepSeekCostItem]]]
+        let calendar: Calendar
+    }
+
+    private static func aggregateDay(
+        dateString: String,
+        amountMap: [String: [String: [DeepSeekUsageItem]]],
+        costMap: [String: [String: [DeepSeekCostItem]]],
+        calendar: Calendar) -> DayAggregationResult
+    {
+        var tokens = 0
+        var cost: Double?
+        var requests = 0
+
+        if let amounts = amountMap[dateString] {
+            for items in amounts.values {
+                for item in items {
+                    guard let category = DeepSeekUsageCategory(rawValue: item.type ?? "") else { continue }
+                    if category == .request {
+                        requests += self.parseTokenAmount(item.amount)
+                    } else {
+                        tokens += self.parseTokenAmount(item.amount)
+                    }
+                }
+            }
+        }
+
+        if let costs = costMap[dateString] {
+            for items in costs.values {
+                for item in items {
+                    guard let category = DeepSeekUsageCategory(rawValue: item.type ?? "") else { continue }
+                    if category != .request {
+                        let amount = Self.parseCostAmount(item.amount)
+                        if let existing = cost {
+                            cost = existing + amount
+                        } else {
+                            cost = amount
+                        }
+                    }
+                }
+            }
+        }
+
+        return DayAggregationResult(tokens: tokens, cost: cost, requests: requests)
+    }
+
+    private static func aggregateMonth(ctx: DailyAggregationContext) -> DayAggregationResult {
+        var tokens = 0
+        var cost: Double?
+        var requests = 0
+
+        for date in ctx.allDates {
+            guard let parsed = self.parseDate(date, calendar: ctx.calendar),
+                  parsed >= ctx.startOfMonth,
+                  parsed <= ctx.now
+            else { continue }
+
+            if let amounts = ctx.amountMap[date] {
+                for items in amounts.values {
+                    for item in items {
+                        guard let category = DeepSeekUsageCategory(rawValue: item.type ?? "") else { continue }
+                        if category == .request {
+                            requests += Self.parseTokenAmount(item.amount)
+                        } else {
+                            tokens += Self.parseTokenAmount(item.amount)
+                        }
+                    }
+                }
+            }
+
+            if let costs = ctx.costMap[date] {
+                for items in costs.values {
+                    for item in items {
+                        guard let category = DeepSeekUsageCategory(rawValue: item.type ?? "") else { continue }
+                        if category != .request {
+                            let amount = Self.parseCostAmount(item.amount)
+                            if let existing = cost {
+                                cost = existing + amount
+                            } else {
+                                cost = amount
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        return DayAggregationResult(tokens: tokens, cost: cost, requests: requests)
+    }
+
+    private static func buildBreakdowns(
+        totalAmounts: [DeepSeekModelUsage],
+        totalCosts: [DeepSeekCostModelUsage]) -> (String?, [DeepSeekCategoryBreakdown])
+    {
+        var modelTokens: [String: Int] = [:]
+        var categoryTokens: [DeepSeekUsageCategory: Int] = [:]
+        var categoryCosts: [DeepSeekUsageCategory: Double] = [:]
+
+        for modelUsage in totalAmounts {
+            guard let model = modelUsage.model else { continue }
+            var total = 0
+            for item in modelUsage.usage ?? [] {
+                guard let category = DeepSeekUsageCategory(rawValue: item.type ?? "") else { continue }
+                if category != .request {
+                    let amount = Self.parseTokenAmount(item.amount)
+                    total += amount
+                    categoryTokens[category, default: 0] += amount
+                }
+            }
+            modelTokens[model] = total
+        }
+
+        for costUsage in totalCosts {
+            guard costUsage.model != nil else { continue }
+            for item in costUsage.usage ?? [] {
+                guard let category = DeepSeekUsageCategory(rawValue: item.type ?? "") else { continue }
+                if category != .request {
+                    let amount = Self.parseCostAmount(item.amount)
+                    categoryCosts[category, default: 0] += amount
+                }
+            }
+        }
+
+        let topModel = modelTokens.max {
+            if $0.value == $1.value { return $0.key > $1.key }
+            return $0.value < $1.value
+        }?.key
+
+        var breakdown: [DeepSeekCategoryBreakdown] = []
+        for category in [DeepSeekUsageCategory.promptCacheHitToken, .promptCacheMissToken, .responseToken] {
+            breakdown.append(DeepSeekCategoryBreakdown(
+                category: category,
+                tokens: categoryTokens[category] ?? 0,
+                cost: categoryCosts[category]))
+        }
+
+        return (topModel, breakdown)
+    }
+
+    private static func buildDailyUsages(ctx: DailyAggregationContext) -> [DeepSeekDailyUsage] {
+        var result: [DeepSeekDailyUsage] = []
+
+        for date in ctx.allDates.sorted() {
+            guard let parsed = self.parseDate(date, calendar: ctx.calendar),
+                  parsed >= ctx.startOfMonth,
+                  parsed <= ctx.now
+            else { continue }
+
+            var dayTokens = 0
+            var dayCost: Double?
+            var dayRequests = 0
+
+            if let amounts = ctx.amountMap[date] {
+                for items in amounts.values {
+                    for item in items {
+                        guard let category = DeepSeekUsageCategory(rawValue: item.type ?? "") else { continue }
+                        if category == .request {
+                            dayRequests += Self.parseTokenAmount(item.amount)
+                        } else {
+                            dayTokens += Self.parseTokenAmount(item.amount)
+                        }
+                    }
+                }
+            }
+
+            if let costs = ctx.costMap[date] {
+                for items in costs.values {
+                    for item in items {
+                        guard let category = DeepSeekUsageCategory(rawValue: item.type ?? "") else { continue }
+                        if category != .request {
+                            let amount = Self.parseCostAmount(item.amount)
+                            if let existing = dayCost {
+                                dayCost = existing + amount
+                            } else {
+                                dayCost = amount
+                            }
+                        }
+                    }
+                }
+            }
+
+            result.append(DeepSeekDailyUsage(
+                date: date,
+                totalTokens: dayTokens,
+                cost: dayCost,
+                requestCount: dayRequests))
+        }
+
+        return result
+    }
+
+    // MARK: - Helpers
+
+    private static func parseTokenAmount(_ value: String?) -> Int {
+        guard let value, let intValue = Int64(value.trimmingCharacters(in: .whitespacesAndNewlines)) else {
+            return 0
+        }
+        return Int(intValue)
+    }
+
+    private static func parseCostAmount(_ value: String?) -> Double {
+        guard let value else { return 0 }
+        let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        return Double(trimmed) ?? 0
+    }
+
+    private static func parseDate(_ text: String, calendar: Calendar) -> Date? {
+        let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else { return nil }
+        let formatter = DateFormatter()
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        formatter.calendar = calendar
+        formatter.timeZone = calendar.timeZone
+        formatter.dateFormat = "yyyy-MM-dd"
+        return formatter.date(from: trimmed)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/DeepSeek/DeepSeekUsageFetcher.swift b/Sources/CodexBarCore/Providers/DeepSeek/DeepSeekUsageFetcher.swift
new file mode 100644
index 0000000000..d2f956ce49
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/DeepSeek/DeepSeekUsageFetcher.swift
@@ -0,0 +1,432 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+// MARK: - API response types
+
+public struct DeepSeekBalanceResponse: Decodable, Sendable {
+    public let isAvailable: Bool
+    public let balanceInfos: [DeepSeekBalanceInfo]
+
+    enum CodingKeys: String, CodingKey {
+        case isAvailable = "is_available"
+        case balanceInfos = "balance_infos"
+    }
+}
+
+public struct DeepSeekBalanceInfo: Decodable, Sendable {
+    public let currency: String
+    public let totalBalance: String
+    public let grantedBalance: String
+    public let toppedUpBalance: String
+
+    enum CodingKeys: String, CodingKey {
+        case currency
+        case totalBalance = "total_balance"
+        case grantedBalance = "granted_balance"
+        case toppedUpBalance = "topped_up_balance"
+    }
+}
+
+// MARK: - Domain snapshot
+
+public struct DeepSeekUsageSnapshot: Sendable {
+    public let isAvailable: Bool
+    public let currency: String
+    public let totalBalance: Double
+    public let grantedBalance: Double
+    public let toppedUpBalance: Double
+    public let usageSummary: DeepSeekUsageSummary?
+    public let updatedAt: Date
+
+    public init(
+        isAvailable: Bool,
+        currency: String,
+        totalBalance: Double,
+        grantedBalance: Double,
+        toppedUpBalance: Double,
+        usageSummary: DeepSeekUsageSummary? = nil,
+        updatedAt: Date)
+    {
+        self.isAvailable = isAvailable
+        self.currency = currency
+        self.totalBalance = totalBalance
+        self.grantedBalance = grantedBalance
+        self.toppedUpBalance = toppedUpBalance
+        self.usageSummary = usageSummary
+        self.updatedAt = updatedAt
+    }
+
+    public func toUsageSnapshot() -> UsageSnapshot {
+        let symbol = self.currency == "CNY" ? "¥" : "$"
+
+        let balanceDetail: String
+        let usedPercent: Double
+        if self.totalBalance <= 0 {
+            balanceDetail = "\(symbol)0.00 — add credits at platform.deepseek.com"
+            usedPercent = 100
+        } else if !self.isAvailable {
+            balanceDetail = "Balance unavailable for API calls"
+            usedPercent = 100
+        } else {
+            let total = String(format: "\(symbol)%.2f", self.totalBalance)
+            let paid = String(format: "\(symbol)%.2f", self.toppedUpBalance)
+            let granted = String(format: "\(symbol)%.2f", self.grantedBalance)
+            balanceDetail = "\(total) (Paid: \(paid) / Granted: \(granted))"
+            usedPercent = 0
+        }
+
+        let identity = ProviderIdentitySnapshot(
+            providerID: .deepseek,
+            accountEmail: nil,
+            accountOrganization: nil,
+            loginMethod: nil)
+        let balanceWindow = RateWindow(
+            usedPercent: usedPercent,
+            windowMinutes: nil,
+            resetsAt: nil,
+            resetDescription: balanceDetail)
+
+        return UsageSnapshot(
+            primary: balanceWindow,
+            secondary: nil,
+            tertiary: nil,
+            providerCost: nil,
+            deepseekUsage: self.usageSummary,
+            updatedAt: self.updatedAt,
+            identity: identity)
+    }
+}
+
+// MARK: - Errors
+
+public enum DeepSeekUsageError: LocalizedError, Sendable {
+    case missingCredentials
+    case networkError(String)
+    case apiError(String)
+    case parseFailed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingCredentials:
+            "Missing DeepSeek API key."
+        case let .networkError(message):
+            "DeepSeek network error: \(message)"
+        case let .apiError(message):
+            "DeepSeek API error: \(message)"
+        case let .parseFailed(message):
+            "Failed to parse DeepSeek response: \(message)"
+        }
+    }
+}
+
+// MARK: - Fetcher
+
+public struct DeepSeekUsageFetcher: Sendable {
+    private static let log = CodexBarLog.logger(LogCategories.deepSeekUsage)
+    private static let balanceURL = URL(string: "https://api.deepseek.com/user/balance")!
+    private static let usageAmountURL = URL(string: "https://platform.deepseek.com/api/v0/usage/amount")!
+    private static let usageCostURL = URL(string: "https://platform.deepseek.com/api/v0/usage/cost")!
+    private static let timeoutSeconds: TimeInterval = 15
+    private static let optionalSummaryJoinGrace: Duration = .seconds(2)
+    private static var apiCalendar: Calendar {
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.locale = Locale(identifier: "en_US_POSIX")
+        calendar.timeZone = TimeZone(secondsFromGMT: 0) ?? .gmt
+        return calendar
+    }
+
+    public static func fetchUsage(
+        apiKey: String,
+        includeOptionalUsage: Bool = true) async throws -> DeepSeekUsageSnapshot
+    {
+        try await self.fetchUsage(
+            apiKey: apiKey,
+            includeOptionalUsage: includeOptionalUsage,
+            optionalSummaryJoinGrace: self.optionalSummaryJoinGrace,
+            fetchBalanceData: { key in
+                try await self.fetchBalanceData(apiKey: key)
+            },
+            fetchSummary: { key in
+                try await self.fetchUsageSummary(apiKey: key)
+            })
+    }
+
+    static func _fetchUsageForTesting(
+        apiKey: String,
+        includeOptionalUsage: Bool,
+        optionalSummaryJoinGrace: Duration = .zero,
+        fetchBalanceData: @escaping @Sendable (String) async throws -> Data,
+        fetchSummary: @escaping @Sendable (String) async throws -> DeepSeekUsageSummary)
+        async throws -> DeepSeekUsageSnapshot
+    {
+        try await self.fetchUsage(
+            apiKey: apiKey,
+            includeOptionalUsage: includeOptionalUsage,
+            optionalSummaryJoinGrace: optionalSummaryJoinGrace,
+            fetchBalanceData: fetchBalanceData,
+            fetchSummary: fetchSummary)
+    }
+
+    private static func fetchUsage(
+        apiKey: String,
+        includeOptionalUsage: Bool,
+        optionalSummaryJoinGrace: Duration,
+        fetchBalanceData: @escaping @Sendable (String) async throws -> Data,
+        fetchSummary: @escaping @Sendable (String) async throws -> DeepSeekUsageSummary)
+        async throws -> DeepSeekUsageSnapshot
+    {
+        guard !apiKey.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+            throw DeepSeekUsageError.missingCredentials
+        }
+
+        let summaryTask: Task<DeepSeekUsageSummary, Error>? = if includeOptionalUsage {
+            Task {
+                try await fetchSummary(apiKey)
+            }
+        } else {
+            nil
+        }
+
+        let balanceData: Data
+        do {
+            balanceData = try await withTaskCancellationHandler {
+                try await fetchBalanceData(apiKey)
+            } onCancel: {
+                summaryTask?.cancel()
+            }
+        } catch {
+            summaryTask?.cancel()
+            throw error
+        }
+        var snapshot: DeepSeekUsageSnapshot
+        do {
+            snapshot = try Self.parseSnapshot(data: balanceData)
+        } catch {
+            summaryTask?.cancel()
+            throw error
+        }
+
+        if let summaryTask {
+            let summary = try await self.completedOptionalUsageSummary(
+                from: summaryTask,
+                joinGrace: optionalSummaryJoinGrace)
+            if let summary {
+                snapshot = DeepSeekUsageSnapshot(
+                    isAvailable: snapshot.isAvailable,
+                    currency: snapshot.currency,
+                    totalBalance: snapshot.totalBalance,
+                    grantedBalance: snapshot.grantedBalance,
+                    toppedUpBalance: snapshot.toppedUpBalance,
+                    usageSummary: summary,
+                    updatedAt: snapshot.updatedAt)
+            }
+        }
+
+        return snapshot
+    }
+
+    private static func fetchBalanceData(apiKey: String) async throws -> Data {
+        var request = URLRequest(url: self.balanceURL)
+        request.httpMethod = "GET"
+        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        request.timeoutInterval = Self.timeoutSeconds
+
+        let response = try await ProviderHTTPClient.shared.response(for: request)
+        let data = response.data
+        guard response.statusCode == 200 else {
+            Self.log.error("DeepSeek balance endpoint returned HTTP \(response.statusCode)")
+            throw DeepSeekUsageError.apiError("HTTP \(response.statusCode)")
+        }
+
+        return data
+    }
+
+    private static func completedOptionalUsageSummary(
+        from task: Task<DeepSeekUsageSummary, Error>,
+        joinGrace: Duration) async throws -> DeepSeekUsageSummary?
+    {
+        let race = BoundedTaskJoin(sourceTask: task)
+        switch await race.value(joinGrace: joinGrace) {
+        case let .value(summary):
+            try Task.checkCancellation()
+            return summary
+        case .timedOut:
+            try Task.checkCancellation()
+            return nil
+        case let .failure(error):
+            task.cancel()
+            if Task.isCancelled {
+                throw error
+            }
+            return nil
+        }
+    }
+
+    static func _parseSnapshotForTesting(_ data: Data) throws -> DeepSeekUsageSnapshot {
+        try self.parseSnapshot(data: data)
+    }
+
+    public static func fetchUsageSummary(
+        apiKey: String,
+        now: Date = Date(),
+        calendar: Calendar? = nil) async throws -> DeepSeekUsageSummary
+    {
+        let calendar = calendar ?? self.apiCalendar
+        let period = try self.usagePeriod(now: now, calendar: calendar)
+
+        let amountData = try await self.fetchAmount(apiKey: apiKey, month: period.month, year: period.year)
+        let costData = try await self.fetchCost(apiKey: apiKey, month: period.month, year: period.year)
+
+        return try DeepSeekUsageCostParser.parse(
+            amountData: amountData,
+            costData: costData,
+            now: now,
+            calendar: calendar)
+    }
+
+    static func _apiUsagePeriodForTesting(now: Date, calendar: Calendar? = nil) throws -> (month: Int, year: Int) {
+        try self.usagePeriod(now: now, calendar: calendar ?? self.apiCalendar)
+    }
+
+    private static func usagePeriod(now: Date, calendar: Calendar) throws -> (month: Int, year: Int) {
+        let monthComponents = calendar.dateComponents([.month, .year], from: now)
+        guard let month = monthComponents.month, let year = monthComponents.year else {
+            throw DeepSeekUsageError.parseFailed("Could not determine current month/year")
+        }
+        return (month: month, year: year)
+    }
+
+    private static func fetchAmount(apiKey: String, month: Int, year: Int) async throws -> Data {
+        guard var components = URLComponents(url: self.usageAmountURL, resolvingAgainstBaseURL: false) else {
+            throw DeepSeekUsageError.networkError("Invalid URL")
+        }
+        components.queryItems = [
+            URLQueryItem(name: "month", value: String(month)),
+            URLQueryItem(name: "year", value: String(year)),
+        ]
+        guard let url = components.url else {
+            throw DeepSeekUsageError.networkError("Could not construct URL")
+        }
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        request.timeoutInterval = Self.timeoutSeconds
+
+        let response = try await ProviderHTTPClient.shared.response(for: request)
+        let data = response.data
+        guard response.statusCode == 200 else {
+            if response.statusCode == 401 || response.statusCode == 403 {
+                throw DeepSeekUsageError.missingCredentials
+            }
+            throw DeepSeekUsageError.apiError("HTTP \(response.statusCode)")
+        }
+
+        return data
+    }
+
+    private static func fetchCost(apiKey: String, month: Int, year: Int) async throws -> Data {
+        guard var components = URLComponents(url: self.usageCostURL, resolvingAgainstBaseURL: false) else {
+            throw DeepSeekUsageError.networkError("Invalid URL")
+        }
+        components.queryItems = [
+            URLQueryItem(name: "month", value: String(month)),
+            URLQueryItem(name: "year", value: String(year)),
+        ]
+        guard let url = components.url else {
+            throw DeepSeekUsageError.networkError("Could not construct URL")
+        }
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        request.timeoutInterval = Self.timeoutSeconds
+
+        let response = try await ProviderHTTPClient.shared.response(for: request)
+        let data = response.data
+        guard response.statusCode == 200 else {
+            if response.statusCode == 401 || response.statusCode == 403 {
+                throw DeepSeekUsageError.missingCredentials
+            }
+            throw DeepSeekUsageError.apiError("HTTP \(response.statusCode)")
+        }
+
+        return data
+    }
+
+    static func _parseUsageSummaryForTesting(
+        amountData: Data,
+        costData: Data,
+        now: Date = Date(),
+        calendar: Calendar = .current) throws -> DeepSeekUsageSummary
+    {
+        try DeepSeekUsageCostParser.parse(
+            amountData: amountData,
+            costData: costData,
+            now: now,
+            calendar: calendar)
+    }
+
+    private static func parseSnapshot(data: Data) throws -> DeepSeekUsageSnapshot {
+        let decoded: DeepSeekBalanceResponse
+        do {
+            decoded = try JSONDecoder().decode(DeepSeekBalanceResponse.self, from: data)
+        } catch {
+            throw DeepSeekUsageError.parseFailed(error.localizedDescription)
+        }
+
+        let balances = try decoded.balanceInfos.map(Self.parseBalanceInfo)
+        guard !balances.isEmpty else {
+            return DeepSeekUsageSnapshot(
+                isAvailable: false,
+                currency: "USD",
+                totalBalance: 0,
+                grantedBalance: 0,
+                toppedUpBalance: 0,
+                updatedAt: Date())
+        }
+
+        // Prefer USD when it is funded, but do not hide a positive CNY balance behind
+        // an empty USD row returned by the API.
+        let selected = balances.first { $0.currency == "USD" && $0.totalBalance > 0 }
+            ?? balances.first { $0.totalBalance > 0 }
+            ?? balances.first { $0.currency == "USD" }
+            ?? balances[0]
+
+        return DeepSeekUsageSnapshot(
+            isAvailable: decoded.isAvailable,
+            currency: selected.currency,
+            totalBalance: selected.totalBalance,
+            grantedBalance: selected.grantedBalance,
+            toppedUpBalance: selected.toppedUpBalance,
+            updatedAt: Date())
+    }
+
+    private struct ParsedBalanceInfo {
+        let currency: String
+        let totalBalance: Double
+        let grantedBalance: Double
+        let toppedUpBalance: Double
+    }
+
+    private static func parseBalanceInfo(_ info: DeepSeekBalanceInfo) throws -> ParsedBalanceInfo {
+        guard
+            let total = Double(info.totalBalance),
+            let granted = Double(info.grantedBalance),
+            let toppedUp = Double(info.toppedUpBalance)
+        else {
+            throw DeepSeekUsageError.parseFailed("Non-numeric balance value in response.")
+        }
+
+        return ParsedBalanceInfo(
+            currency: info.currency,
+            totalBalance: total,
+            grantedBalance: granted,
+            toppedUpBalance: toppedUp)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Deepgram/DeepgramProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Deepgram/DeepgramProviderDescriptor.swift
new file mode 100644
index 0000000000..5e77cb49ce
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Deepgram/DeepgramProviderDescriptor.swift
@@ -0,0 +1,102 @@
+import Foundation
+
+public enum DeepgramProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .deepgram,
+            metadata: ProviderMetadata(
+                id: .deepgram,
+                displayName: "Deepgram",
+                sessionLabel: "Requests",
+                weeklyLabel: "Usage",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "Usage summary from Deepgram API",
+                toggleTitle: "Show Deepgram usage",
+                cliName: "deepgram",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                browserCookieOrder: nil,
+                dashboardURL: "https://console.deepgram.com/project/",
+                statusPageURL: nil,
+                statusLinkURL: "https://status.deepgram.com"),
+            branding: ProviderBranding(
+                iconStyle: .deepgram,
+                iconResourceName: "ProviderIcon-deepgram",
+                color: ProviderColor(
+                    red: 100 / 255,
+                    green: 103 / 255,
+                    blue: 242 / 255)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: {
+                    "Deepgram cost summary is not yet supported."
+                }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .api],
+                pipeline: ProviderFetchPipeline(
+                    resolveStrategies: { _ in
+                        [DeepgramAPIFetchStrategy()]
+                    })),
+            cli: ProviderCLIConfig(
+                name: "deepgram",
+                aliases: ["dg"],
+                versionDetector: nil))
+    }
+}
+
+struct DeepgramAPIFetchStrategy: ProviderFetchStrategy {
+    let id: String = "deepgram.api"
+    let kind: ProviderFetchKind = .apiToken
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        Self.resolveAPIKey(context) != nil
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        guard let apiKey = Self.resolveAPIKey(context) else {
+            throw DeepgramSettingsError.missingToken
+        }
+
+        let usage = try await DeepgramUsageFetcher.fetchUsage(
+            apiKey: apiKey,
+            projectID: Self.resolveProjectID(context),
+            environment: context.env)
+
+        return self.makeResult(
+            usage: usage.toUsageSnapshot(),
+            sourceLabel: "api")
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+
+    private static func resolveAPIKey(_ context: ProviderFetchContext) -> String? {
+        ProviderTokenResolver.deepgramResolution(
+            type: .apiKey,
+            environment: context.env)
+    }
+
+    private static func resolveProjectID(_ context: ProviderFetchContext) -> String? {
+        ProviderTokenResolver.deepgramResolution(
+            type: .projectID,
+            environment: context.env)
+    }
+}
+
+/// Errors related to Deepgram settings
+public enum DeepgramSettingsError: LocalizedError, Sendable {
+    case missingToken
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingToken:
+            "Deepgram API token not configured. Set DEEPGRAM_API_KEY environment variable or configure in Settings."
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Deepgram/DeepgramSettingsReader.swift b/Sources/CodexBarCore/Providers/Deepgram/DeepgramSettingsReader.swift
new file mode 100644
index 0000000000..beb86103f7
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Deepgram/DeepgramSettingsReader.swift
@@ -0,0 +1,33 @@
+import Foundation
+
+public struct DeepgramSettingsReader: Sendable {
+    public static let apiKeyEnvironmentKey = "DEEPGRAM_API_KEY"
+    public static let projectIDEnvironmentKey = "DEEPGRAM_PROJECT_ID"
+
+    public static func apiKey(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.cleaned(environment[self.apiKeyEnvironmentKey])
+    }
+
+    public static func projectID(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.cleaned(environment[self.projectIDEnvironmentKey])
+    }
+
+    private static func cleaned(_ raw: String?) -> String? {
+        guard var value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
+            return nil
+        }
+
+        if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
+            (value.hasPrefix("'") && value.hasSuffix("'"))
+        {
+            value = String(value.dropFirst().dropLast())
+        }
+
+        value = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        return value.isEmpty ? nil : value
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Deepgram/DeepgramUsageFetcher.swift b/Sources/CodexBarCore/Providers/Deepgram/DeepgramUsageFetcher.swift
new file mode 100644
index 0000000000..0cbbc44abe
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Deepgram/DeepgramUsageFetcher.swift
@@ -0,0 +1,561 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public enum DeepgramUsageError: LocalizedError, Sendable {
+    case missingAPIKey
+    case invalidEndpointOverride(String)
+    case invalidCredentials
+    case invalidProjectID
+    case forbidden(String)
+    case networkError(String)
+    case apiError(String)
+    case parseFailed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingAPIKey:
+            "Missing Deepgram API key. Set apiKey in ~/.codexbar/config.json or DEEPGRAM_API_KEY."
+        case let .invalidEndpointOverride(key):
+            "Deepgram endpoint override \(key) must use HTTPS or a bare host."
+        case .invalidCredentials:
+            "Deepgram API key is invalid or expired."
+        case .invalidProjectID:
+            "Deepgram project ID is invalid or no projects were returned for this API key."
+        case let .forbidden(message):
+            "Deepgram rejected access: \(message)"
+        case let .networkError(message):
+            "Deepgram network error: \(message)"
+        case let .apiError(message):
+            "Deepgram API error: \(message)"
+        case let .parseFailed(message):
+            "Deepgram parse error: \(message)"
+        }
+    }
+}
+
+// MARK: - API Responses
+
+public struct DeepgramProjectsResponse: Decodable, Sendable {
+    public let projects: [DeepgramProject]
+}
+
+public struct DeepgramProject: Decodable, Sendable, Equatable {
+    public let projectID: String
+    public let name: String?
+
+    private enum CodingKeys: String, CodingKey {
+        case projectID = "project_id"
+        case name
+    }
+
+    public init(projectID: String, name: String? = nil) {
+        self.projectID = projectID
+        self.name = name
+    }
+}
+
+public struct DeepgramUsageResponse: Decodable, Sendable {
+    public let start: String?
+    public let end: String?
+    public let resolution: DeepgramUsageResolution?
+    public let results: [DeepgramUsageResult]
+}
+
+public struct DeepgramUsageResolution: Decodable, Sendable {
+    public let units: String?
+    public let amount: Int?
+}
+
+public struct DeepgramUsageResult: Codable, Sendable {
+    public let start: String?
+    public let end: String?
+    public let hours: Double?
+    public let totalHours: Double?
+    public let agentHours: Double?
+    public let tokensIn: Int?
+    public let tokensOut: Int?
+    public let ttsCharacters: Int?
+    public let requests: Int?
+
+    private enum CodingKeys: String, CodingKey {
+        case start
+        case end
+        case hours
+        case totalHours = "total_hours"
+        case agentHours = "agent_hours"
+        case tokensIn = "tokens_in"
+        case tokensOut = "tokens_out"
+        case ttsCharacters = "tts_characters"
+        case requests
+    }
+}
+
+// MARK: - Query
+
+public struct DeepgramUsageQuery: Sendable {
+    public var start: String?
+    public var end: String?
+
+    public init(
+        start: String? = nil,
+        end: String? = nil)
+    {
+        self.start = start
+        self.end = end
+    }
+
+    public func queryItems() -> [URLQueryItem] {
+        var items: [URLQueryItem] = []
+
+        func add(_ name: String, _ value: String?) {
+            guard let value = value?.trimmingCharacters(in: .whitespacesAndNewlines),
+                  !value.isEmpty
+            else {
+                return
+            }
+            items.append(URLQueryItem(name: name, value: value))
+        }
+
+        add("start", self.start)
+        add("end", self.end)
+
+        return items
+    }
+}
+
+// MARK: - Snapshot
+
+public struct DeepgramUsageSnapshot: Codable, Sendable {
+    public let projectID: String
+    public let projectName: String?
+    public let projectCount: Int
+    public let start: String?
+    public let end: String?
+    public let hours: Double
+    public let totalHours: Double
+    public let agentHours: Double
+    public let tokensIn: Int
+    public let tokensOut: Int
+    public let ttsCharacters: Int
+    public let requests: Int
+    public let updatedAt: Date
+
+    public init(
+        projectID: String,
+        projectName: String? = nil,
+        projectCount: Int = 1,
+        start: String?,
+        end: String?,
+        hours: Double,
+        totalHours: Double,
+        agentHours: Double = 0,
+        tokensIn: Int = 0,
+        tokensOut: Int = 0,
+        ttsCharacters: Int = 0,
+        requests: Int,
+        updatedAt: Date)
+    {
+        self.projectID = projectID
+        self.projectName = projectName
+        self.projectCount = projectCount
+        self.start = start
+        self.end = end
+        self.hours = hours
+        self.totalHours = totalHours
+        self.agentHours = agentHours
+        self.tokensIn = tokensIn
+        self.tokensOut = tokensOut
+        self.ttsCharacters = ttsCharacters
+        self.requests = requests
+        self.updatedAt = updatedAt
+    }
+}
+
+extension DeepgramUsageSnapshot {
+    public func toUsageSnapshot() -> UsageSnapshot {
+        let identity = ProviderIdentitySnapshot(
+            providerID: .deepgram,
+            accountEmail: nil,
+            accountOrganization: nil,
+            loginMethod: self.identityLabel)
+
+        return UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            tertiary: nil,
+            providerCost: nil,
+            deepgramUsage: self,
+            updatedAt: self.updatedAt,
+            identity: identity)
+    }
+
+    public var displayLines: [String] {
+        var lines: [String] = []
+        lines.append("Requests: \(Self.formatInteger(self.requests))")
+
+        var usageParts: [String] = []
+        if self.hours > 0 {
+            usageParts.append("\(Self.formatDecimal(self.hours)) audio hours")
+        }
+        if self.totalHours > 0 {
+            usageParts.append("\(Self.formatDecimal(self.totalHours)) billable hours")
+        }
+        if !usageParts.isEmpty {
+            lines.append(usageParts.joined(separator: " · "))
+        }
+
+        var modelParts: [String] = []
+        if self.agentHours > 0 {
+            modelParts.append("\(Self.formatDecimal(self.agentHours)) agent hours")
+        }
+        if self.tokensIn > 0 || self.tokensOut > 0 {
+            modelParts.append("\(Self.formatInteger(self.tokensIn + self.tokensOut)) tokens")
+        }
+        if self.ttsCharacters > 0 {
+            modelParts.append("\(Self.formatInteger(self.ttsCharacters)) TTS chars")
+        }
+        if !modelParts.isEmpty {
+            lines.append(modelParts.joined(separator: " · "))
+        }
+
+        if let start, let end {
+            lines.append("Period: \(start) to \(end)")
+        }
+
+        return lines
+    }
+
+    private var identityLabel: String? {
+        if self.projectCount > 1 {
+            return "\(self.projectCount) projects"
+        }
+        if let projectName = self.projectName?.trimmingCharacters(in: .whitespacesAndNewlines),
+           !projectName.isEmpty
+        {
+            return "Project: \(projectName)"
+        }
+        return "Project: \(self.projectID)"
+    }
+
+    fileprivate static func aggregate(
+        _ snapshots: [DeepgramUsageSnapshot],
+        updatedAt: Date) throws -> DeepgramUsageSnapshot
+    {
+        guard let first = snapshots.first else {
+            throw DeepgramUsageError.invalidProjectID
+        }
+        if snapshots.count == 1 { return first }
+        return DeepgramUsageSnapshot(
+            projectID: "all",
+            projectName: nil,
+            projectCount: snapshots.count,
+            start: snapshots.compactMap(\.start).min(),
+            end: snapshots.compactMap(\.end).max(),
+            hours: snapshots.reduce(0) { $0 + $1.hours },
+            totalHours: snapshots.reduce(0) { $0 + $1.totalHours },
+            agentHours: snapshots.reduce(0) { $0 + $1.agentHours },
+            tokensIn: snapshots.reduce(0) { $0 + $1.tokensIn },
+            tokensOut: snapshots.reduce(0) { $0 + $1.tokensOut },
+            ttsCharacters: snapshots.reduce(0) { $0 + $1.ttsCharacters },
+            requests: snapshots.reduce(0) { $0 + $1.requests },
+            updatedAt: updatedAt)
+    }
+
+    private static func formatInteger(_ value: Int) -> String {
+        let formatter = NumberFormatter()
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        formatter.numberStyle = .decimal
+        formatter.usesGroupingSeparator = true
+        formatter.groupingSeparator = ","
+        formatter.maximumFractionDigits = 0
+        return formatter.string(from: NSNumber(value: value)) ?? "\(value)"
+    }
+
+    private static func formatDecimal(_ value: Double) -> String {
+        let formatter = NumberFormatter()
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        formatter.numberStyle = .decimal
+        formatter.usesGroupingSeparator = true
+        formatter.groupingSeparator = ","
+        formatter.minimumFractionDigits = value == floor(value) ? 0 : 1
+        formatter.maximumFractionDigits = 1
+        return formatter.string(from: NSNumber(value: value)) ?? String(format: "%.1f", value)
+    }
+}
+
+// MARK: - Fetcher
+
+public struct DeepgramUsageFetcher: Sendable {
+    public static let apiURLKey = "DEEPGRAM_API_URL"
+
+    private static let log = CodexBarLog.logger(LogCategories.deepgramUsage)
+    private static let defaultBaseURL = URL(string: "https://api.deepgram.com/v1")!
+
+    private struct FetchContext {
+        let apiKey: String
+        let query: DeepgramUsageQuery
+        let timeout: TimeInterval
+        let environment: [String: String]
+        let transport: ProviderHTTPTransport
+        let updatedAt: Date
+    }
+
+    public static func fetchUsage(
+        apiKey: String,
+        projectID: String? = nil,
+        query: DeepgramUsageQuery = DeepgramUsageQuery(),
+        timeout: TimeInterval = 15,
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        transport: ProviderHTTPTransport = ProviderHTTPClient.shared) async throws -> DeepgramUsageSnapshot
+    {
+        let cleanedAPIKey = apiKey.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !cleanedAPIKey.isEmpty else {
+            throw DeepgramUsageError.missingAPIKey
+        }
+        try self.validateEndpointOverrides(environment: environment)
+
+        let updatedAt = Date()
+        let context = FetchContext(
+            apiKey: cleanedAPIKey,
+            query: query,
+            timeout: timeout,
+            environment: environment,
+            transport: transport,
+            updatedAt: updatedAt)
+
+        if let cleanedProjectID = self.cleaned(projectID) {
+            return try await self.fetchUsage(
+                project: DeepgramProject(projectID: cleanedProjectID),
+                context: context)
+        }
+
+        let projects = try await self.listProjects(
+            apiKey: cleanedAPIKey,
+            timeout: timeout,
+            environment: environment,
+            transport: transport)
+        guard !projects.isEmpty else {
+            throw DeepgramUsageError.invalidProjectID
+        }
+
+        var snapshots: [DeepgramUsageSnapshot] = []
+        snapshots.reserveCapacity(projects.count)
+        for project in projects {
+            let snapshot = try await self.fetchUsage(
+                project: project,
+                context: context)
+            snapshots.append(snapshot)
+        }
+        return try DeepgramUsageSnapshot.aggregate(snapshots, updatedAt: updatedAt)
+    }
+
+    static func _parseSnapshotForTesting(
+        _ data: Data,
+        projectID: String = "project-test",
+        projectName: String? = nil,
+        updatedAt: Date = Date()) throws -> DeepgramUsageSnapshot
+    {
+        try self.parseUsage(
+            data: data,
+            project: DeepgramProject(projectID: projectID, name: projectName),
+            updatedAt: updatedAt)
+    }
+
+    private static func listProjects(
+        apiKey: String,
+        timeout: TimeInterval,
+        environment: [String: String],
+        transport: ProviderHTTPTransport) async throws -> [DeepgramProject]
+    {
+        let url = self.apiURL(environment: environment).appendingPathComponent("projects")
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.timeoutInterval = timeout
+        request.setValue("Token \(apiKey)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+
+        let response = try await self.perform(request: request, transport: transport)
+        do {
+            return try JSONDecoder().decode(DeepgramProjectsResponse.self, from: response.data).projects
+        } catch {
+            Self.log.error("Deepgram projects decode failed: \(error.localizedDescription)")
+            throw DeepgramUsageError.parseFailed(error.localizedDescription)
+        }
+    }
+
+    private static func fetchUsage(
+        project: DeepgramProject,
+        context: FetchContext) async throws -> DeepgramUsageSnapshot
+    {
+        let url = try self.usageURL(
+            projectID: project.projectID,
+            query: context.query,
+            environment: context.environment)
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.timeoutInterval = context.timeout
+        request.setValue("Token \(context.apiKey)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+
+        let response = try await self.perform(request: request, transport: context.transport)
+        return try self.parseUsage(data: response.data, project: project, updatedAt: context.updatedAt)
+    }
+
+    private static func perform(
+        request: URLRequest,
+        transport: ProviderHTTPTransport) async throws -> ProviderHTTPResponse
+    {
+        let response: ProviderHTTPResponse
+        do {
+            response = try await transport.response(for: request)
+        } catch {
+            throw DeepgramUsageError.networkError(error.localizedDescription)
+        }
+
+        guard response.statusCode == 200 else {
+            let summary = self.responseSummary(response.data)
+            Self.log.error("Deepgram returned HTTP \(response.statusCode): \(summary)")
+
+            switch response.statusCode {
+            case 401:
+                throw DeepgramUsageError.invalidCredentials
+            case 403:
+                throw DeepgramUsageError.forbidden(
+                    "The API key may not have access to the project or the Management API. HTTP 403: \(summary)")
+            case 400:
+                throw DeepgramUsageError.apiError("Bad request. HTTP 400: \(summary)")
+            default:
+                throw DeepgramUsageError.apiError("HTTP \(response.statusCode): \(summary)")
+            }
+        }
+
+        return response
+    }
+
+    private static func usageURL(
+        projectID: String,
+        query: DeepgramUsageQuery,
+        environment: [String: String]) throws -> URL
+    {
+        let usageURL = self.apiURL(environment: environment)
+            .appendingPathComponent("projects")
+            .appendingPathComponent(projectID)
+            .appendingPathComponent("usage")
+            .appendingPathComponent("breakdown")
+
+        guard var components = URLComponents(url: usageURL, resolvingAgainstBaseURL: false) else {
+            throw DeepgramUsageError.networkError("Invalid usage URL")
+        }
+
+        let queryItems = query.queryItems()
+        if !queryItems.isEmpty {
+            components.queryItems = queryItems
+        }
+
+        guard let finalURL = components.url else {
+            throw DeepgramUsageError.networkError("Invalid usage query")
+        }
+
+        return finalURL
+    }
+
+    private static func apiURL(environment: [String: String]) -> URL {
+        if let raw = self.cleaned(environment[self.apiURLKey]),
+           let url = ProviderEndpointOverrideValidator.normalizedHTTPSURL(from: raw)
+        {
+            return url
+        }
+
+        return self.defaultBaseURL
+    }
+
+    public static func validateEndpointOverrides(environment: [String: String] = ProcessInfo.processInfo
+        .environment) throws
+    {
+        guard let raw = self.cleaned(environment[self.apiURLKey]) else { return }
+        guard ProviderEndpointOverrideValidator.normalizedHTTPSURL(from: raw) == nil else { return }
+        throw DeepgramUsageError.invalidEndpointOverride(self.apiURLKey)
+    }
+
+    private static func parseUsage(
+        data: Data,
+        project: DeepgramProject,
+        updatedAt: Date) throws -> DeepgramUsageSnapshot
+    {
+        do {
+            let response = try JSONDecoder().decode(DeepgramUsageResponse.self, from: data)
+            return DeepgramUsageSnapshot(
+                projectID: project.projectID,
+                projectName: project.name,
+                start: response.start,
+                end: response.end,
+                hours: response.results.reduce(0) { $0 + ($1.hours ?? 0) },
+                totalHours: response.results.reduce(0) { $0 + ($1.totalHours ?? 0) },
+                agentHours: response.results.reduce(0) { $0 + ($1.agentHours ?? 0) },
+                tokensIn: response.results.reduce(0) { $0 + ($1.tokensIn ?? 0) },
+                tokensOut: response.results.reduce(0) { $0 + ($1.tokensOut ?? 0) },
+                ttsCharacters: response.results.reduce(0) { $0 + ($1.ttsCharacters ?? 0) },
+                requests: response.results.reduce(0) { $0 + ($1.requests ?? 0) },
+                updatedAt: updatedAt)
+        } catch let error as DecodingError {
+            Self.log.error("Deepgram decoding error: \(error.localizedDescription)")
+            Self.log.error("Deepgram raw response: \(self.responseSummary(data))")
+            throw DeepgramUsageError.parseFailed(error.localizedDescription)
+        } catch {
+            Self.log.error("Deepgram parse error: \(error.localizedDescription)")
+            Self.log.error("Deepgram raw response: \(self.responseSummary(data))")
+            throw DeepgramUsageError.parseFailed(error.localizedDescription)
+        }
+    }
+
+    private static func cleaned(_ raw: String?) -> String? {
+        guard let value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
+            return nil
+        }
+        return value
+    }
+
+    private static func responseSummary(_ data: Data) -> String {
+        guard !data.isEmpty else { return "empty body" }
+
+        guard let text = String(data: data, encoding: .utf8) else {
+            return "non-text body (\(data.count) bytes)"
+        }
+
+        let cleaned = text
+            .replacingOccurrences(of: #"\s+"#, with: " ", options: .regularExpression)
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+
+        guard !cleaned.isEmpty else {
+            return "empty body"
+        }
+
+        let maxLength = 240
+        guard cleaned.count > maxLength else {
+            return self.redact(cleaned)
+        }
+
+        let index = cleaned.index(cleaned.startIndex, offsetBy: maxLength)
+        return self.redact("\(cleaned[..<index])... [truncated]")
+    }
+
+    private static func redact(_ text: String) -> String {
+        let replacements: [(String, String)] = [
+            (#"(?i)(token\s+)[A-Za-z0-9._\-]+"#, "$1[REDACTED]"),
+            (#"(?i)(dg_[A-Za-z0-9._\-]+)"#, "[REDACTED]"),
+            (
+                #"(?i)(\"(?:api_?key|authorization|token|access_token|refresh_token)\"\s*:\s*\")([^\"]+)(\")"#,
+                "$1[REDACTED]$3"),
+        ]
+
+        return replacements.reduce(text) { partial, replacement in
+            partial.replacingOccurrences(
+                of: replacement.0,
+                with: replacement.1,
+                options: .regularExpression)
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Devin/DevinProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Devin/DevinProviderDescriptor.swift
new file mode 100644
index 0000000000..8cdcd55064
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Devin/DevinProviderDescriptor.swift
@@ -0,0 +1,92 @@
+import Foundation
+
+public enum DevinProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .devin,
+            metadata: ProviderMetadata(
+                id: .devin,
+                displayName: "Devin",
+                sessionLabel: "Daily",
+                weeklyLabel: "Weekly",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "",
+                toggleTitle: "Show Devin usage",
+                cliName: "devin",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                browserCookieOrder: ProviderBrowserCookieDefaults.devinCookieImportOrder,
+                dashboardURL: "https://app.devin.ai",
+                subscriptionDashboardURL: "https://app.devin.ai/settings/usage",
+                statusPageURL: nil),
+            branding: ProviderBranding(
+                iconStyle: .devin,
+                iconResourceName: "ProviderIcon-devin",
+                color: ProviderColor(red: 70 / 255, green: 180 / 255, blue: 130 / 255)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "Devin cost summary is not supported." }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .web],
+                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [DevinWebFetchStrategy()] })),
+            cli: ProviderCLIConfig(
+                name: "devin",
+                versionDetector: nil))
+    }
+}
+
+struct DevinWebFetchStrategy: ProviderFetchStrategy {
+    let id: String = "devin.web"
+    let kind: ProviderFetchKind = .web
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        let settings = context.settings?.devin
+        let source = settings?.cookieSource ?? .auto
+        guard source != .off else { return false }
+        if source == .manual {
+            return DevinUsageFetcher.manualAuth(from: Self.bearerTokenOverride(context: context)) != nil
+        }
+        #if os(macOS)
+        return true
+        #else
+        return false
+        #endif
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        let fetcher = DevinUsageFetcher(browserDetection: context.browserDetection)
+        let settings = context.settings?.devin
+        let logger: ((String) -> Void)? = context.verbose
+            ? { msg in CodexBarLog.logger(LogCategories.devin).verbose(msg) }
+            : nil
+        let snapshot = try await fetcher.fetch(
+            bearerTokenOverride: settings?.cookieSource == .manual ? Self.bearerTokenOverride(context: context) : nil,
+            organizationOverride: Self.organizationOverride(context: context),
+            timeout: context.webTimeout,
+            logger: logger)
+        return self.makeResult(
+            usage: snapshot.toUsageSnapshot(),
+            sourceLabel: "web")
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+
+    private static func bearerTokenOverride(context: ProviderFetchContext) -> String? {
+        context.env["DEVIN_BEARER_TOKEN"]
+            ?? context.env["DEVIN_AUTHORIZATION"]
+            ?? context.settings?.devin?.manualBearerToken
+    }
+
+    private static func organizationOverride(context: ProviderFetchContext) -> String? {
+        context.env["DEVIN_ORGANIZATION"]
+            ?? context.env["DEVIN_ORG"]
+            ?? context.settings?.devin?.organization
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Devin/DevinSessionImporter.swift b/Sources/CodexBarCore/Providers/Devin/DevinSessionImporter.swift
new file mode 100644
index 0000000000..102ed6575c
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Devin/DevinSessionImporter.swift
@@ -0,0 +1,459 @@
+import Foundation
+#if os(macOS)
+import SweetCookieKit
+#endif
+
+#if os(macOS)
+enum DevinSessionImporter {
+    nonisolated(unsafe) static var importSessionOverrideForTesting:
+        ((BrowserDetection, String?, ((String) -> Void)?) -> SessionInfo?)?
+
+    private static let storageOrigin = "https://app.devin.ai"
+    private static let externalOrgPrefix = "last-internal-org-for-external-org-v1-"
+
+    struct SessionInfo: Equatable {
+        let accessToken: String
+        let organization: String?
+        let internalOrganizationID: String?
+        let sourceLabel: String
+    }
+
+    struct LocalStorageCandidate {
+        let label: String
+        let url: URL
+    }
+
+    static func importSession(
+        browserDetection: BrowserDetection,
+        organizationOverride: String? = nil,
+        logger: ((String) -> Void)? = nil) -> SessionInfo?
+    {
+        if let override = self.importSessionOverrideForTesting {
+            return override(browserDetection, organizationOverride, logger)
+        }
+
+        let sessions = self.importSessions(
+            browserDetection: browserDetection,
+            organizationOverride: organizationOverride,
+            logger: logger)
+        return sessions.first
+    }
+
+    static func importSessions(
+        browserDetection: BrowserDetection,
+        organizationOverride: String? = nil,
+        logger: ((String) -> Void)? = nil) -> [SessionInfo]
+    {
+        if let override = self.importSessionOverrideForTesting {
+            return override(browserDetection, organizationOverride, logger).map { [$0] } ?? []
+        }
+
+        let log: (String) -> Void = { msg in logger?("[devin-storage] \(msg)") }
+        let candidates = self.chromeLocalStorageCandidates(browserDetection: browserDetection)
+        if !candidates.isEmpty {
+            log("Chrome local storage candidates: \(candidates.count)")
+        }
+
+        var sessions: [SessionInfo] = []
+        for candidate in candidates {
+            let storage = self.readLocalStorage(from: candidate.url, logger: log)
+            guard let session = self.session(
+                from: storage,
+                organizationOverride: organizationOverride,
+                sourceLabel: candidate.label)
+            else {
+                continue
+            }
+            log(
+                "Found Devin session in \(candidate.label); " +
+                    "organization=\(session.organization != nil), internalOrganizationID=" +
+                    "\(session.internalOrganizationID != nil)")
+            sessions.append(session)
+        }
+        sessions = self.rankSessions(self.deduplicateSessions(sessions))
+
+        if sessions.isEmpty {
+            log("No Devin session found in browser local storage")
+        }
+        return sessions
+    }
+
+    static func session(
+        from storage: [String: String],
+        organizationOverride: String? = nil,
+        sourceLabel: String) -> SessionInfo?
+    {
+        guard let accessToken = self.accessToken(from: storage) else {
+            return nil
+        }
+        let organizationInfo = self.organizationInfo(from: storage, organizationOverride: organizationOverride)
+        return SessionInfo(
+            accessToken: accessToken,
+            organization: organizationInfo.organization,
+            internalOrganizationID: organizationInfo.internalOrganizationID,
+            sourceLabel: sourceLabel)
+    }
+
+    static func accessToken(from storage: [String: String]) -> String? {
+        for (key, value) in storage where self.isAuth1StorageKey(key) {
+            guard let json = self.jsonObject(from: value),
+                  let token = self.findAuth1Token(in: json)
+            else {
+                continue
+            }
+            return token
+        }
+
+        for (key, value) in storage where self.isAuth0StorageKey(key) {
+            guard let json = self.jsonObject(from: value),
+                  let token = self.findAccessToken(in: json)
+            else {
+                continue
+            }
+            return token
+        }
+
+        for value in storage.values {
+            guard let json = self.jsonObject(from: value),
+                  let token = self.findAccessToken(in: json)
+            else {
+                continue
+            }
+            return token
+        }
+
+        return nil
+    }
+
+    static func deduplicateSessions(_ sessions: [SessionInfo]) -> [SessionInfo] {
+        var order: [String] = []
+        var bestByToken: [String: SessionInfo] = [:]
+        for session in sessions {
+            if let existing = bestByToken[session.accessToken] {
+                if self.organizationScore(session) > self.organizationScore(existing) {
+                    bestByToken[session.accessToken] = session
+                }
+            } else {
+                order.append(session.accessToken)
+                bestByToken[session.accessToken] = session
+            }
+        }
+        return order.compactMap { bestByToken[$0] }
+    }
+
+    static func rankSessions(_ sessions: [SessionInfo]) -> [SessionInfo] {
+        sessions.enumerated()
+            .sorted { lhs, rhs in
+                let lhsScore = self.organizationScore(lhs.element)
+                let rhsScore = self.organizationScore(rhs.element)
+                return lhsScore == rhsScore ? lhs.offset < rhs.offset : lhsScore > rhsScore
+            }
+            .map(\.element)
+    }
+
+    private static func organizationScore(_ session: SessionInfo) -> Int {
+        (session.organization == nil ? 0 : 1) + (session.internalOrganizationID == nil ? 0 : 2)
+    }
+
+    static func organizationInfo(
+        from storage: [String: String],
+        organizationOverride: String?) -> (organization: String?, internalOrganizationID: String?)
+    {
+        let override = DevinUsageFetcher.normalizedOrganization(organizationOverride)
+        let overrideSlug = override.flatMap(self.slug(fromNormalizedOrganization:))
+        var firstInternalOrgID: String?
+
+        for (key, value) in storage where self.isExternalOrgStorageKey(key) {
+            let suffix = self.externalOrgSlug(from: key)
+            let orgID = self.cleanedOrgID(value)
+            if firstInternalOrgID == nil {
+                firstInternalOrgID = orgID
+            }
+            if let overrideSlug, suffix == overrideSlug {
+                return (override, orgID)
+            }
+            if override == nil, suffix != "null" {
+                return ("org/\(suffix)", orgID)
+            }
+        }
+
+        if let inferred = self.inferredOrganizationInfo(from: storage, override: override) {
+            return inferred
+        }
+
+        if let override {
+            return (override, firstInternalOrgID ?? self.orgID(fromNormalizedOrganization: override))
+        }
+
+        return (firstInternalOrgID.map { "organizations/\($0)" }, firstInternalOrgID)
+    }
+
+    static func decodedStorageValue(_ value: String) -> String {
+        let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else { return trimmed }
+        if let data = trimmed.data(using: .utf8),
+           let decoded = try? JSONDecoder().decode(String.self, from: data)
+        {
+            return decoded.trimmingCharacters(in: .whitespacesAndNewlines)
+        }
+        return trimmed.trimmingCharacters(in: CharacterSet(charactersIn: "\""))
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+
+    static func chromeLocalStorageCandidates(browserDetection: BrowserDetection) -> [LocalStorageCandidate] {
+        let installedBrowsers = self.localStorageBrowsers(browserDetection: browserDetection)
+        let roots = ChromiumProfileLocator
+            .roots(for: installedBrowsers, homeDirectories: BrowserCookieClient.defaultHomeDirectories())
+            .map { (url: $0.url, labelPrefix: $0.labelPrefix) }
+
+        var candidates: [LocalStorageCandidate] = []
+        for root in roots {
+            candidates.append(contentsOf: self.chromeProfileLocalStorageDirs(
+                root: root.url,
+                labelPrefix: root.labelPrefix))
+        }
+        return candidates
+    }
+
+    static func localStorageBrowsers(browserDetection: BrowserDetection) -> [Browser] {
+        let order = ProviderDefaults.metadata[.devin]?.browserCookieOrder ?? [.chrome]
+        return order.browsersWithProfileData(using: browserDetection)
+    }
+
+    private static func chromeProfileLocalStorageDirs(root: URL, labelPrefix: String) -> [LocalStorageCandidate] {
+        guard let entries = try? FileManager.default.contentsOfDirectory(
+            at: root,
+            includingPropertiesForKeys: [.isDirectoryKey],
+            options: [.skipsHiddenFiles])
+        else { return [] }
+
+        return entries.filter { url in
+            guard let isDir = (try? url.resourceValues(forKeys: [.isDirectoryKey]).isDirectory), isDir else {
+                return false
+            }
+            let name = url.lastPathComponent
+            return name == "Default" || name.hasPrefix("Profile ") || name.hasPrefix("user-")
+        }
+        .sorted { $0.lastPathComponent < $1.lastPathComponent }
+        .compactMap { dir in
+            let levelDBURL = dir.appendingPathComponent("Local Storage").appendingPathComponent("leveldb")
+            guard FileManager.default.fileExists(atPath: levelDBURL.path) else { return nil }
+            return LocalStorageCandidate(label: "\(labelPrefix) \(dir.lastPathComponent)", url: levelDBURL)
+        }
+    }
+
+    private static func readLocalStorage(from levelDBURL: URL, logger: ((String) -> Void)?) -> [String: String] {
+        var storage: [String: String] = [:]
+        let entries = SweetCookieKit.ChromiumLocalStorageReader.readEntries(
+            for: self.storageOrigin,
+            in: levelDBURL,
+            logger: logger)
+        for entry in entries {
+            storage[entry.key] = self.decodedStorageValue(entry.value)
+        }
+
+        let textEntries = SweetCookieKit.ChromiumLocalStorageReader.readTextEntries(
+            in: levelDBURL,
+            logger: logger)
+        for entry in textEntries where storage[entry.key] == nil {
+            if self.isUsefulStorageKey(entry.key) {
+                storage[entry.key] = self.decodedStorageValue(entry.value)
+            }
+        }
+
+        return storage
+    }
+
+    private static func jsonObject(from raw: String) -> Any? {
+        guard let data = raw.data(using: .utf8) else { return nil }
+        return try? JSONSerialization.jsonObject(with: data)
+    }
+
+    private static func findAuth1Token(in object: Any) -> String? {
+        guard let dictionary = object as? [String: Any],
+              let token = dictionary["token"] as? String
+        else {
+            return nil
+        }
+        let value = token.trimmingCharacters(in: .whitespacesAndNewlines)
+        return value.hasPrefix("auth1_") && value.count > 20 ? value : nil
+    }
+
+    private static func findAccessToken(in object: Any) -> String? {
+        if let dictionary = object as? [String: Any] {
+            for key in ["access_token", "accessToken"] {
+                if let value = dictionary[key] as? String,
+                   self.looksLikeToken(value)
+                {
+                    return value
+                }
+            }
+            for value in dictionary.values {
+                if let found = self.findAccessToken(in: value) {
+                    return found
+                }
+            }
+        }
+
+        if let array = object as? [Any] {
+            for value in array {
+                if let found = self.findAccessToken(in: value) {
+                    return found
+                }
+            }
+        }
+
+        return nil
+    }
+
+    private static func looksLikeToken(_ raw: String) -> Bool {
+        let value = raw.trimmingCharacters(in: .whitespacesAndNewlines)
+        return value.count > 20 && (value.hasPrefix("eyJ") || value.contains("."))
+    }
+
+    private static func isAuth1StorageKey(_ key: String) -> Bool {
+        key.hasSuffix("auth1_session")
+    }
+
+    private static func isAuth0StorageKey(_ key: String) -> Bool {
+        key.contains("auth0spajs@@::")
+    }
+
+    private static func isExternalOrgStorageKey(_ key: String) -> Bool {
+        key.contains(self.externalOrgPrefix)
+    }
+
+    private static func isUsefulStorageKey(_ key: String) -> Bool {
+        self.isAuth1StorageKey(key) ||
+            self.isAuth0StorageKey(key) ||
+            self.isExternalOrgStorageKey(key) ||
+            key.contains("post-auth-v") ||
+            key.contains("member-info-v") ||
+            key.contains("feature-flags-cache:org-") ||
+            key.contains("feature-flags-cache:org_")
+    }
+
+    private static func inferredOrganizationInfo(
+        from storage: [String: String],
+        override: String?) -> (organization: String?, internalOrganizationID: String?)?
+    {
+        let overrideSlug = override.flatMap(self.slug(fromNormalizedOrganization:))
+        let overrideOrgID = override.flatMap(self.orgID(fromNormalizedOrganization:))
+        var fallbackSlug: String?
+        var fallbackInternalOrgID: String?
+
+        for (key, value) in storage {
+            let object = self.jsonObject(from: value)
+            let internalOrgID = self.cleanedOrgID(self.firstString(
+                in: object,
+                matching: ["internalOrgId", "internal_org_id", "org_id", "orgId"]))
+                ?? self.internalOrgIDFromStorageKey(key)
+            let slug = self.cleanedSlug(
+                self.slugFromPostAuthKey(key) ??
+                    self.firstString(in: object, matching: ["orgName", "org_name", "externalOrgId", "external_org_id"]))
+
+            if let overrideOrgID, internalOrgID == overrideOrgID {
+                return (override, internalOrgID)
+            }
+            if let overrideSlug, slug == overrideSlug {
+                return (override, internalOrgID)
+            }
+
+            if fallbackSlug == nil, let slug {
+                fallbackSlug = slug
+            }
+            if fallbackInternalOrgID == nil, let internalOrgID {
+                fallbackInternalOrgID = internalOrgID
+            }
+        }
+
+        if let override, fallbackInternalOrgID != nil {
+            return (override, fallbackInternalOrgID)
+        }
+
+        if let fallbackSlug {
+            return ("org/\(fallbackSlug)", fallbackInternalOrgID)
+        }
+        if let fallbackInternalOrgID {
+            return ("organizations/\(fallbackInternalOrgID)", fallbackInternalOrgID)
+        }
+
+        return nil
+    }
+
+    private static func externalOrgSlug(from key: String) -> String {
+        guard let range = key.range(of: self.externalOrgPrefix) else { return key }
+        return String(key[range.upperBound...])
+    }
+
+    private static func cleanedOrgID(_ raw: String) -> String? {
+        let value = self.decodedStorageValue(raw)
+        guard DevinUsageFetcher.isInternalOrganizationID(value) else { return nil }
+        return value
+    }
+
+    private static func cleanedOrgID(_ raw: String?) -> String? {
+        guard let raw else { return nil }
+        return self.cleanedOrgID(raw)
+    }
+
+    private static func cleanedSlug(_ raw: String?) -> String? {
+        guard let raw else { return nil }
+        let value = self.decodedStorageValue(raw)
+            .trimmingCharacters(in: CharacterSet(charactersIn: "/"))
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !value.isEmpty, value != "null", !DevinUsageFetcher.isInternalOrganizationID(value) else {
+            return nil
+        }
+        if value.hasPrefix("org/") {
+            return String(value.dropFirst(4))
+        }
+        return value
+    }
+
+    private static func slugFromPostAuthKey(_ key: String) -> String? {
+        guard let range = key.range(of: "-org_name-") else { return nil }
+        return String(key[range.upperBound...])
+    }
+
+    private static func internalOrgIDFromStorageKey(_ key: String) -> String? {
+        guard let range = key.range(of: #"org[-_][A-Za-z0-9]{8,}"#, options: .regularExpression) else {
+            return nil
+        }
+        return self.cleanedOrgID(String(key[range]))
+    }
+
+    private static func firstString(in object: Any?, matching keys: Set<String>) -> String? {
+        if let dictionary = object as? [String: Any] {
+            for (key, value) in dictionary {
+                if keys.contains(key), let string = value as? String, !string.isEmpty {
+                    return string
+                }
+                if let found = self.firstString(in: value, matching: keys) {
+                    return found
+                }
+            }
+        }
+
+        if let array = object as? [Any] {
+            for value in array {
+                if let found = self.firstString(in: value, matching: keys) {
+                    return found
+                }
+            }
+        }
+
+        return nil
+    }
+
+    private static func slug(fromNormalizedOrganization organization: String) -> String? {
+        guard organization.hasPrefix("org/") else { return nil }
+        return String(organization.dropFirst(4))
+    }
+
+    private static func orgID(fromNormalizedOrganization organization: String) -> String? {
+        guard organization.hasPrefix("organizations/") else { return nil }
+        return String(organization.dropFirst("organizations/".count))
+    }
+}
+#endif
diff --git a/Sources/CodexBarCore/Providers/Devin/DevinUsageFetcher.swift b/Sources/CodexBarCore/Providers/Devin/DevinUsageFetcher.swift
new file mode 100644
index 0000000000..5ae76578ce
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Devin/DevinUsageFetcher.swift
@@ -0,0 +1,271 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public struct DevinUsageFetcher: Sendable {
+    private static let log = CodexBarLog.logger(LogCategories.devin)
+    private static let baseURL = URL(string: "https://app.devin.ai")!
+    private static let defaultUserAgent =
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) " +
+        "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36"
+
+    public struct RequestAuth: Sendable, Equatable {
+        public let bearerToken: String
+        public let organization: String?
+        public let internalOrganizationID: String?
+        public let sourceLabel: String
+
+        public init(
+            bearerToken: String,
+            organization: String?,
+            internalOrganizationID: String?,
+            sourceLabel: String)
+        {
+            self.bearerToken = bearerToken
+            self.organization = organization
+            self.internalOrganizationID = internalOrganizationID
+            self.sourceLabel = sourceLabel
+        }
+    }
+
+    public let browserDetection: BrowserDetection
+
+    public init(browserDetection: BrowserDetection) {
+        self.browserDetection = browserDetection
+    }
+
+    public func fetch(
+        bearerTokenOverride: String? = nil,
+        organizationOverride: String? = nil,
+        timeout: TimeInterval = 15,
+        logger: ((String) -> Void)? = nil,
+        now: Date = Date(),
+        transport: any ProviderHTTPTransport = ProviderHTTPClient.shared) async throws -> DevinUsageSnapshot
+    {
+        let auths = try self.resolveAuths(
+            bearerTokenOverride: bearerTokenOverride,
+            organizationOverride: organizationOverride,
+            logger: logger)
+        var lastError: Error?
+        for auth in auths {
+            do {
+                return try await Self.fetchQuotaUsage(
+                    auth: auth,
+                    organizationOverride: organizationOverride,
+                    timeout: timeout,
+                    logger: logger,
+                    now: now,
+                    transport: transport)
+            } catch {
+                lastError = error
+                logger?("[devin] Session from \(auth.sourceLabel) failed: \(error.localizedDescription)")
+                if auth.sourceLabel == "manual" || !Self.shouldTryNextSession(after: error) {
+                    throw error
+                }
+            }
+        }
+        throw lastError ?? DevinUsageError.noSession
+    }
+
+    public static func fetchQuotaUsage(
+        auth: RequestAuth,
+        organizationOverride: String? = nil,
+        timeout: TimeInterval = 15,
+        logger: ((String) -> Void)? = nil,
+        now: Date = Date(),
+        transport: any ProviderHTTPTransport = ProviderHTTPClient.shared) async throws -> DevinUsageSnapshot
+    {
+        let organization = self.normalizedOrganization(organizationOverride) ??
+            self.normalizedOrganization(auth.organization)
+        guard let organization else {
+            throw DevinUsageError.missingOrganization
+        }
+
+        var lastError: Error?
+        for path in self.candidatePaths(
+            organization: organization,
+            internalOrganizationID: auth.internalOrganizationID)
+        {
+            let data: Data
+            do {
+                data = try await self.fetch(
+                    path: path,
+                    auth: auth,
+                    timeout: timeout,
+                    transport: transport)
+            } catch {
+                lastError = error
+                logger?("[devin] /api/\(path) failed: \(error.localizedDescription)")
+                if case DevinUsageError.invalidCredentials = error {
+                    throw error
+                }
+                continue
+            }
+            logger?("[devin] Fetched quota usage from /api/\(path)")
+            return try DevinUsageParser.parse(data, organization: organization, now: now)
+        }
+
+        throw lastError ?? DevinUsageError.apiError("No Devin quota endpoint succeeded.")
+    }
+
+    public static func manualAuth(from raw: String?, organization: String? = nil) -> RequestAuth? {
+        guard var token = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !token.isEmpty else {
+            return nil
+        }
+        if token.lowercased().hasPrefix("authorization:") {
+            token = token.dropHeaderName().trimmingCharacters(in: .whitespacesAndNewlines)
+        }
+        if token.lowercased().hasPrefix("bearer ") {
+            token = String(token.dropFirst(7)).trimmingCharacters(in: .whitespacesAndNewlines)
+        }
+        guard !token.isEmpty else { return nil }
+        return RequestAuth(
+            bearerToken: token,
+            organization: self.normalizedOrganization(organization),
+            internalOrganizationID: self.internalOrganizationID(from: organization),
+            sourceLabel: "manual")
+    }
+
+    private func resolveAuths(
+        bearerTokenOverride: String?,
+        organizationOverride: String?,
+        logger: ((String) -> Void)?) throws -> [RequestAuth]
+    {
+        if let manual = Self.manualAuth(from: bearerTokenOverride, organization: organizationOverride) {
+            logger?("[devin] Using manual Bearer token")
+            return [manual]
+        }
+
+        #if os(macOS)
+        let normalizedOrganizationOverride = Self.normalizedOrganization(organizationOverride)
+        let sessions = DevinSessionImporter.importSessions(
+            browserDetection: self.browserDetection,
+            organizationOverride: normalizedOrganizationOverride,
+            logger: logger)
+        guard !sessions.isEmpty else {
+            throw DevinUsageError.noSession
+        }
+        logger?("[devin] Found \(sessions.count) browser session(s)")
+        return sessions.map { session in
+            RequestAuth(
+                bearerToken: session.accessToken,
+                organization: normalizedOrganizationOverride ?? Self.normalizedOrganization(session.organization),
+                internalOrganizationID: session.internalOrganizationID,
+                sourceLabel: session.sourceLabel)
+        }
+        #else
+        throw DevinUsageError.noSession
+        #endif
+    }
+
+    static func shouldTryNextSession(after error: Error) -> Bool {
+        switch error {
+        case DevinUsageError.invalidCredentials, DevinUsageError.apiError, DevinUsageError.missingOrganization:
+            true
+        default:
+            false
+        }
+    }
+
+    private static func fetch(
+        path: String,
+        auth: RequestAuth,
+        timeout: TimeInterval,
+        transport: any ProviderHTTPTransport) async throws -> Data
+    {
+        let url = self.baseURL.appending(path: "api/\(path)")
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.timeoutInterval = timeout
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        request.setValue("en-US,en;q=0.9", forHTTPHeaderField: "Accept-Language")
+        request.setValue(self.defaultUserAgent, forHTTPHeaderField: "User-Agent")
+        request.setValue("Bearer \(auth.bearerToken)", forHTTPHeaderField: "Authorization")
+        if let internalOrganizationID = auth.internalOrganizationID {
+            request.setValue(internalOrganizationID, forHTTPHeaderField: "x-cog-org-id")
+        }
+        let response = try await transport.response(for: request)
+        guard response.statusCode == 200 else {
+            let body = String(data: response.data.prefix(200), encoding: .utf8) ?? "<binary>"
+            if response.statusCode == 401 || response.statusCode == 403 {
+                throw DevinUsageError.invalidCredentials
+            }
+            Self.log.error("Devin API returned \(response.statusCode): \(body)")
+            throw DevinUsageError.apiError("HTTP \(response.statusCode)")
+        }
+        return response.data
+    }
+
+    private static func candidatePaths(organization: String, internalOrganizationID: String?) -> [String] {
+        var paths: [String] = []
+        let normalized = self.normalizedOrganization(organization) ?? organization
+        if let internalOrganizationID {
+            paths.append("\(internalOrganizationID)/billing/quota/usage")
+        }
+        paths.append("\(normalized)/billing/quota/usage")
+        if normalized.hasPrefix("org/") {
+            let slug = String(normalized.dropFirst(4))
+            paths.append("\(slug)/billing/quota/usage")
+        }
+        if !normalized.hasPrefix("org/"), !normalized.hasPrefix("organizations/") {
+            paths.append("org/\(normalized)/billing/quota/usage")
+        }
+        if let internalOrganizationID {
+            paths.append("organizations/\(internalOrganizationID)/billing/quota/usage")
+        }
+        return paths.removingDuplicates()
+    }
+
+    public static func normalizedOrganization(_ raw: String?) -> String? {
+        guard var value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
+            return nil
+        }
+        if let url = URL(string: value),
+           let host = url.host?.lowercased(),
+           host == "devin.ai" || host.hasSuffix(".devin.ai")
+        {
+            let components = url.path.split(separator: "/").map(String.init)
+            if components.count >= 2, components[0] == "org" {
+                value = "org/\(components[1])"
+            } else if components.count >= 2, components[0] == "organizations" {
+                value = "organizations/\(components[1])"
+            }
+        }
+        value = value.trimmingCharacters(in: CharacterSet(charactersIn: "/"))
+        if value.hasPrefix("org/") || value.hasPrefix("organizations/") {
+            return value
+        }
+        if self.isInternalOrganizationID(value) {
+            return "organizations/\(value)"
+        }
+        return "org/\(value)"
+    }
+
+    private static func internalOrganizationID(from raw: String?) -> String? {
+        guard let normalized = self.normalizedOrganization(raw),
+              normalized.hasPrefix("organizations/")
+        else {
+            return nil
+        }
+        return String(normalized.dropFirst("organizations/".count))
+    }
+
+    static func isInternalOrganizationID(_ value: String) -> Bool {
+        value.hasPrefix("org-") || value.hasPrefix("org_")
+    }
+}
+
+extension String {
+    fileprivate func dropHeaderName() -> String {
+        guard let index = self.firstIndex(of: ":") else { return self }
+        return String(self[self.index(after: index)...])
+    }
+}
+
+extension [String] {
+    fileprivate func removingDuplicates() -> [String] {
+        var seen = Set<String>()
+        return self.filter { seen.insert($0).inserted }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Devin/DevinUsageSnapshot.swift b/Sources/CodexBarCore/Providers/Devin/DevinUsageSnapshot.swift
new file mode 100644
index 0000000000..53bbcc50c4
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Devin/DevinUsageSnapshot.swift
@@ -0,0 +1,320 @@
+import CoreFoundation
+import Foundation
+
+public enum DevinUsageError: LocalizedError, Sendable {
+    case noSession
+    case missingOrganization
+    case invalidCredentials
+    case apiError(String)
+    case parseFailed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .noSession:
+            "No Devin browser session found. Please log in to app.devin.ai or paste a Bearer token."
+        case .missingOrganization:
+            "No Devin organization was found. Open an app.devin.ai/org/... page " +
+                "or set the organization in Devin settings."
+        case .invalidCredentials:
+            "Devin session token is invalid or expired."
+        case let .apiError(message):
+            "Devin API error: \(message)"
+        case let .parseFailed(message):
+            "Could not parse Devin usage: \(message)"
+        }
+    }
+}
+
+public struct DevinQuotaWindow: Sendable, Equatable {
+    public let usedPercent: Double
+    public let resetsAt: Date?
+
+    public init(usedPercent: Double, resetsAt: Date? = nil) {
+        self.usedPercent = min(100, max(0, usedPercent))
+        self.resetsAt = resetsAt
+    }
+}
+
+public struct DevinUsageSnapshot: Sendable, Equatable {
+    public let daily: DevinQuotaWindow?
+    public let weekly: DevinQuotaWindow?
+    public let planName: String?
+    public let organization: String?
+    public let updatedAt: Date
+
+    public init(
+        daily: DevinQuotaWindow?,
+        weekly: DevinQuotaWindow?,
+        planName: String?,
+        organization: String?,
+        updatedAt: Date)
+    {
+        self.daily = daily
+        self.weekly = weekly
+        self.planName = planName
+        self.organization = organization
+        self.updatedAt = updatedAt
+    }
+
+    public func toUsageSnapshot() -> UsageSnapshot {
+        let primary = self.daily.map {
+            RateWindow(
+                usedPercent: $0.usedPercent,
+                windowMinutes: 24 * 60,
+                resetsAt: $0.resetsAt,
+                resetDescription: "Daily")
+        }
+        let secondary = self.weekly.map {
+            RateWindow(
+                usedPercent: $0.usedPercent,
+                windowMinutes: 7 * 24 * 60,
+                resetsAt: $0.resetsAt,
+                resetDescription: "Weekly")
+        }
+        let identity = ProviderIdentitySnapshot(
+            providerID: .devin,
+            accountEmail: nil,
+            accountOrganization: self.organization,
+            loginMethod: self.planName)
+        return UsageSnapshot(
+            primary: primary,
+            secondary: secondary,
+            updatedAt: self.updatedAt,
+            identity: identity)
+    }
+}
+
+public enum DevinUsageParser {
+    public static func parse(_ data: Data, organization: String?, now: Date = Date()) throws -> DevinUsageSnapshot {
+        let object = try JSONSerialization.jsonObject(with: data)
+        return try self.parse(object, organization: organization, now: now)
+    }
+
+    public static func parse(_ object: Any, organization: String?, now: Date = Date()) throws -> DevinUsageSnapshot {
+        let current = (object as? [String: Any]).map(self.currentQuotaWindows)
+        let daily = current?.daily ?? self.findWindow(in: object, matching: self.isDailyKey)
+        let weekly = current?.weekly ?? self.findWindow(in: object, matching: self.isWeeklyKey)
+        guard daily != nil || weekly != nil else {
+            throw DevinUsageError.parseFailed("Missing Devin quota windows.")
+        }
+
+        return DevinUsageSnapshot(
+            daily: daily,
+            weekly: weekly,
+            planName: self.findPlanName(in: object),
+            organization: self.displayOrganization(from: organization),
+            updatedAt: now)
+    }
+
+    private static func currentQuotaWindows(_ dictionary: [String: Any])
+        -> (daily: DevinQuotaWindow?, weekly: DevinQuotaWindow?)
+    {
+        let daily = self.currentQuotaWindow(
+            percent: dictionary["daily_percentage"],
+            resetsAt: dictionary["daily_reset_at"])
+        let weekly = self.currentQuotaWindow(
+            percent: dictionary["weekly_percentage"],
+            resetsAt: dictionary["weekly_reset_at"])
+        return (daily, weekly)
+    }
+
+    private static func currentQuotaWindow(percent: Any?, resetsAt: Any?) -> DevinQuotaWindow? {
+        guard let usedPercent = self.double(percent) else { return nil }
+        return DevinQuotaWindow(
+            usedPercent: usedPercent <= 1 ? usedPercent * 100 : usedPercent,
+            resetsAt: self.date(from: resetsAt))
+    }
+
+    private static func findWindow(in object: Any, matching keyMatches: (String) -> Bool) -> DevinQuotaWindow? {
+        if let dictionary = object as? [String: Any] {
+            for (key, value) in dictionary where keyMatches(key) {
+                if let window = self.window(from: value) {
+                    return window
+                }
+            }
+            for value in dictionary.values {
+                if let found = self.findWindow(in: value, matching: keyMatches) {
+                    return found
+                }
+            }
+        }
+
+        if let array = object as? [Any] {
+            for value in array {
+                if let found = self.findWindow(in: value, matching: keyMatches) {
+                    return found
+                }
+            }
+        }
+
+        return nil
+    }
+
+    private static func window(from object: Any) -> DevinQuotaWindow? {
+        guard let dictionary = object as? [String: Any] else {
+            guard let percent = self.percent(from: object) else { return nil }
+            return DevinQuotaWindow(usedPercent: percent, resetsAt: nil)
+        }
+
+        if let percent = self.percent(from: dictionary) {
+            return DevinQuotaWindow(
+                usedPercent: percent,
+                resetsAt: self.findResetDate(in: dictionary))
+        }
+
+        if let nested = dictionary.values.lazy.compactMap({ self.window(from: $0) }).first {
+            return nested
+        }
+
+        return nil
+    }
+
+    private static func percent(from object: Any) -> Double? {
+        if let number = self.double(object) {
+            return number <= 1 ? number * 100 : number
+        }
+        guard let dictionary = object as? [String: Any] else { return nil }
+
+        let directKeys = [
+            "used_percent",
+            "usedPercent",
+            "usage_percent",
+            "usagePercent",
+            "percent_used",
+            "percentUsed",
+            "percent",
+        ]
+        for key in directKeys {
+            if let value = self.double(dictionary[key]) {
+                return value <= 1 ? value * 100 : value
+            }
+        }
+
+        let remainingKeys = ["remaining_percent", "remainingPercent", "percent_remaining", "percentRemaining"]
+        for key in remainingKeys {
+            if let value = self.double(dictionary[key]) {
+                let percent = value <= 1 ? value * 100 : value
+                return 100 - percent
+            }
+        }
+
+        let used = self.firstDouble(in: dictionary, keys: ["used", "usage", "used_count", "usedCount", "consumed"])
+        let limit = self.firstDouble(in: dictionary, keys: ["limit", "quota", "total", "max", "available"])
+        if let used, let limit, limit > 0 {
+            return used / limit * 100
+        }
+
+        let remaining = self.firstDouble(in: dictionary, keys: ["remaining", "left", "available"])
+        if let remaining, let limit, limit > 0 {
+            return (limit - remaining) / limit * 100
+        }
+
+        return nil
+    }
+
+    private static func findPlanName(in object: Any) -> String? {
+        if let dictionary = object as? [String: Any] {
+            for key in ["plan_name", "planName", "plan", "tier", "subscription_tier", "subscriptionTier"] {
+                if let value = dictionary[key] as? String,
+                   let cleaned = self.cleanDisplay(value)
+                {
+                    return cleaned
+                }
+            }
+            for value in dictionary.values {
+                if let found = self.findPlanName(in: value) {
+                    return found
+                }
+            }
+        }
+
+        if let array = object as? [Any] {
+            for value in array {
+                if let found = self.findPlanName(in: value) {
+                    return found
+                }
+            }
+        }
+
+        return nil
+    }
+
+    private static func findResetDate(in dictionary: [String: Any]) -> Date? {
+        for (key, value) in dictionary where key.localizedCaseInsensitiveContains("reset") {
+            if let date = self.date(from: value) {
+                return date
+            }
+        }
+        return nil
+    }
+
+    private static func date(from value: Any?) -> Date? {
+        if let raw = value as? String {
+            if let date = ISO8601DateFormatter().date(from: raw) {
+                return date
+            }
+            if let number = Double(raw) {
+                return self.date(from: number)
+            }
+        }
+        if let number = self.double(value) {
+            return self.date(from: number)
+        }
+        return nil
+    }
+
+    private static func date(from number: Double) -> Date? {
+        guard number > 0 else { return nil }
+        let seconds = number > 10_000_000_000 ? number / 1000 : number
+        return Date(timeIntervalSince1970: seconds)
+    }
+
+    private static func firstDouble(in dictionary: [String: Any], keys: [String]) -> Double? {
+        for key in keys {
+            if let value = self.double(dictionary[key]) {
+                return value
+            }
+        }
+        return nil
+    }
+
+    private static func double(_ value: Any?) -> Double? {
+        switch value {
+        case let number as NSNumber:
+            CFGetTypeID(number) == CFBooleanGetTypeID() ? nil : number.doubleValue
+        case let string as String:
+            Double(string.trimmingCharacters(in: .whitespacesAndNewlines))
+        default:
+            nil
+        }
+    }
+
+    private static func isDailyKey(_ raw: String) -> Bool {
+        let key = raw.lowercased()
+        return !key.contains("hide") && (key.contains("daily") || key.contains("day"))
+    }
+
+    private static func isWeeklyKey(_ raw: String) -> Bool {
+        let key = raw.lowercased()
+        return !key.contains("hide") && (key.contains("weekly") || key.contains("week"))
+    }
+
+    private static func displayOrganization(from raw: String?) -> String? {
+        guard let raw = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !raw.isEmpty else { return nil }
+        if raw.hasPrefix("org/") {
+            return String(raw.dropFirst(4))
+        }
+        if raw.hasPrefix("organizations/") {
+            return String(raw.dropFirst("organizations/".count))
+        }
+        return raw
+    }
+
+    private static func cleanDisplay(_ raw: String) -> String? {
+        let cleaned = raw.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !cleaned.isEmpty else { return nil }
+        return cleaned.split(separator: "_").flatMap { $0.split(separator: "-") }.map { part in
+            part.prefix(1).uppercased() + String(part.dropFirst())
+        }.joined(separator: " ")
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Doubao/DoubaoProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Doubao/DoubaoProviderDescriptor.swift
new file mode 100644
index 0000000000..c221f530d3
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Doubao/DoubaoProviderDescriptor.swift
@@ -0,0 +1,45 @@
+import Foundation
+
+public enum DoubaoProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .doubao,
+            metadata: ProviderMetadata(
+                id: .doubao,
+                displayName: "Doubao",
+                sessionLabel: "Requests",
+                weeklyLabel: "Rate limit",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "",
+                toggleTitle: "Show Doubao usage",
+                cliName: "doubao",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                browserCookieOrder: nil,
+                dashboardURL: "https://console.volcengine.com/ark/region:ark+cn-beijing/openManagement?LLM=%7B%7D&advancedActiveKey=subscribe",
+                statusPageURL: nil),
+            branding: ProviderBranding(
+                iconStyle: .doubao,
+                iconResourceName: "ProviderIcon-doubao",
+                color: ProviderColor(red: 51 / 255, green: 112 / 255, blue: 255 / 255)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "Doubao cost summary is not available." }),
+            fetchPlan: .apiToken(
+                strategyID: "doubao.api",
+                resolveToken: { ProviderTokenResolver.doubaoToken(environment: $0) },
+                missingCredentialsError: { DoubaoUsageError.missingCredentials },
+                loadUsage: { apiKey, _ in
+                    try await DoubaoUsageFetcher.fetchUsage(apiKey: apiKey).toUsageSnapshot()
+                }),
+            cli: ProviderCLIConfig(
+                name: "doubao",
+                aliases: ["volcengine", "ark", "bytedance"],
+                versionDetector: nil))
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Doubao/DoubaoSettingsReader.swift b/Sources/CodexBarCore/Providers/Doubao/DoubaoSettingsReader.swift
new file mode 100644
index 0000000000..fc5942e546
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Doubao/DoubaoSettingsReader.swift
@@ -0,0 +1,36 @@
+import Foundation
+
+public struct DoubaoSettingsReader: Sendable {
+    public static let apiKeyEnvironmentKeys = [
+        "ARK_API_KEY",
+        "VOLCENGINE_API_KEY",
+        "DOUBAO_API_KEY",
+    ]
+
+    public static func apiKey(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        for key in self.apiKeyEnvironmentKeys {
+            guard let raw = environment[key]?.trimmingCharacters(in: .whitespacesAndNewlines),
+                  !raw.isEmpty
+            else {
+                continue
+            }
+            let cleaned = Self.cleaned(raw)
+            if !cleaned.isEmpty {
+                return cleaned
+            }
+        }
+        return nil
+    }
+
+    private static func cleaned(_ raw: String) -> String {
+        var value = raw
+        if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
+            (value.hasPrefix("'") && value.hasSuffix("'"))
+        {
+            value = String(value.dropFirst().dropLast())
+        }
+        return value.trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Doubao/DoubaoUsageFetcher.swift b/Sources/CodexBarCore/Providers/Doubao/DoubaoUsageFetcher.swift
new file mode 100644
index 0000000000..d1273b24d6
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Doubao/DoubaoUsageFetcher.swift
@@ -0,0 +1,369 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public struct DoubaoUsageSnapshot: Sendable {
+    public let remainingRequests: Int
+    public let limitRequests: Int
+    public let resetTime: Date?
+    public let updatedAt: Date
+    public let apiKeyValid: Bool
+    public let totalTokens: Int?
+    public let requestLimitsReliable: Bool
+    public init(
+        remainingRequests: Int,
+        limitRequests: Int,
+        resetTime: Date?,
+        updatedAt: Date,
+        apiKeyValid: Bool = false,
+        totalTokens: Int? = nil,
+        requestLimitsReliable: Bool = true)
+    {
+        self.remainingRequests = remainingRequests
+        self.limitRequests = limitRequests
+        self.resetTime = resetTime
+        self.updatedAt = updatedAt
+        self.apiKeyValid = apiKeyValid
+        self.totalTokens = totalTokens
+        self.requestLimitsReliable = requestLimitsReliable
+    }
+
+    public func toUsageSnapshot() -> UsageSnapshot {
+        let primary: RateWindow?
+        if self.limitRequests > 0, self.requestLimitsReliable {
+            let used = max(0, self.limitRequests - self.remainingRequests)
+            primary = RateWindow(
+                usedPercent: min(100, max(0, Double(used) / Double(self.limitRequests) * 100)),
+                windowMinutes: nil,
+                resetsAt: self.resetTime,
+                resetDescription: "\(used)/\(self.limitRequests) requests")
+        } else if self.apiKeyValid {
+            // Ark can return successful requests without a trustworthy request-limit window.
+            // Omitting the window prevents the UI from presenting unknown usage as 100% left.
+            primary = nil
+        } else {
+            primary = RateWindow(
+                usedPercent: 0,
+                windowMinutes: nil,
+                resetsAt: self.resetTime,
+                resetDescription: "No usage data")
+        }
+
+        let identity = ProviderIdentitySnapshot(
+            providerID: .doubao,
+            accountEmail: nil,
+            accountOrganization: nil,
+            loginMethod: nil)
+
+        return UsageSnapshot(
+            primary: primary,
+            secondary: nil,
+            tertiary: nil,
+            providerCost: nil,
+            updatedAt: self.updatedAt,
+            identity: identity)
+    }
+}
+
+public enum DoubaoUsageError: LocalizedError, Sendable {
+    case missingCredentials
+    case networkError(String)
+    case apiError(Int, String)
+    case parseFailed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingCredentials:
+            "Missing Doubao API key (ARK_API_KEY)."
+        case let .networkError(message):
+            "Doubao network error: \(message)"
+        case let .apiError(code, message):
+            "Doubao API error (\(code)): \(message)"
+        case let .parseFailed(message):
+            "Failed to parse Doubao response: \(message)"
+        }
+    }
+}
+
+public struct DoubaoUsageFetcher: Sendable {
+    private static let log = CodexBarLog.logger(LogCategories.doubaoUsage)
+    private static let apiURL = URL(string: "https://ark.cn-beijing.volces.com/api/coding/v3/chat/completions")!
+
+    /// Models to probe, ordered by likelihood. We try multiple models because
+    /// different key types may not have access to every model.
+    private static let probeModels = [
+        "doubao-seed-2.0-code",
+        "doubao-1.5-pro-32k",
+        "doubao-lite-32k",
+    ]
+
+    private struct ProbeResult {
+        let snapshot: DoubaoUsageSnapshot
+        let statusCode: Int
+
+        var hasAmbiguousZeroRemaining: Bool {
+            self.statusCode == 200
+                && self.snapshot.requestLimitsReliable
+                && self.snapshot.limitRequests > 0
+                && self.snapshot.remainingRequests == 0
+        }
+    }
+
+    public static func fetchUsage(
+        apiKey: String,
+        session transport: any ProviderHTTPTransport = ProviderHTTPClient.shared) async throws -> DoubaoUsageSnapshot
+    {
+        guard !apiKey.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+            throw DoubaoUsageError.missingCredentials
+        }
+
+        var lastError: Error?
+        for model in self.probeModels {
+            do {
+                let result = try await self.probe(apiKey: apiKey, model: model, transport: transport)
+                guard result.hasAmbiguousZeroRemaining else {
+                    return result.snapshot
+                }
+
+                return try await self.confirmAmbiguousZeroRemaining(
+                    initial: result,
+                    apiKey: apiKey,
+                    model: model,
+                    transport: transport)
+            } catch let error as DoubaoUsageError {
+                if case let .apiError(code, _) = error, code == 404 || code == 403 {
+                    Self.log.debug("Doubao probe model \(model) unavailable (\(code)), trying next")
+                    lastError = error
+                    continue
+                }
+                throw error
+            }
+        }
+        throw lastError ?? DoubaoUsageError.apiError(0, "All probe models failed")
+    }
+
+    private static func confirmAmbiguousZeroRemaining(
+        initial: ProbeResult,
+        apiKey: String,
+        model: String,
+        transport: any ProviderHTTPTransport) async throws -> DoubaoUsageSnapshot
+    {
+        do {
+            let confirmation = try await self.probe(apiKey: apiKey, model: model, transport: transport)
+            // This path starts only after a complete HTTP 200 request-limit pair
+            // reported zero. An immediate 429 confirms that exhausted state even
+            // when Ark omits the headers from the throttle response.
+            if confirmation.statusCode == 429 {
+                return confirmation.snapshot.requestLimitsReliable
+                    ? confirmation.snapshot
+                    : initial.snapshot
+            }
+            guard confirmation.hasAmbiguousZeroRemaining else {
+                return confirmation.snapshot
+            }
+
+            Self.log.warning(
+                """
+                Doubao Ark returned limit=\(confirmation.snapshot.limitRequests) remaining=0 \
+                with HTTP 200 twice; treating request-limit headers as unreliable.
+                """)
+            return DoubaoUsageSnapshot(
+                remainingRequests: confirmation.snapshot.remainingRequests,
+                limitRequests: confirmation.snapshot.limitRequests,
+                resetTime: confirmation.snapshot.resetTime,
+                updatedAt: confirmation.snapshot.updatedAt,
+                apiKeyValid: confirmation.snapshot.apiKeyValid,
+                totalTokens: confirmation.snapshot.totalTokens,
+                requestLimitsReliable: false)
+        } catch {
+            if error is CancellationError || (error as? URLError)?.code == .cancelled {
+                throw error
+            }
+            self.log.warning(
+                """
+                Doubao zero-remaining confirmation failed; preserving the initial exhausted state: \
+                \(error.localizedDescription)
+                """)
+            return initial.snapshot
+        }
+    }
+
+    private static func probe(
+        apiKey: String,
+        model: String,
+        transport: any ProviderHTTPTransport) async throws -> ProbeResult
+    {
+        var request = URLRequest(url: self.apiURL)
+        request.httpMethod = "POST"
+        request.timeoutInterval = 15
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
+
+        let body: [String: Any] = [
+            "model": model,
+            "max_tokens": 1,
+            "messages": [
+                ["role": "user", "content": "hi"],
+            ] as [[String: Any]],
+        ]
+
+        request.httpBody = try JSONSerialization.data(withJSONObject: body)
+
+        let response = try await transport.response(for: request)
+        let data = response.data
+
+        // Accept both 200 (success) and 429 (rate limited) – both carry rate limit headers.
+        guard response.statusCode == 200 || response.statusCode == 429 else {
+            let summary = Self.apiErrorSummary(statusCode: response.statusCode, data: data)
+            Self.log.error("Doubao API returned \(response.statusCode): \(summary)")
+            throw DoubaoUsageError.apiError(response.statusCode, summary)
+        }
+
+        let headers = response.response.allHeaderFields
+        let remaining = Self.intHeader(headers, "x-ratelimit-remaining-requests")
+        let limit = Self.intHeader(headers, "x-ratelimit-limit-requests")
+        let resetString = Self.stringHeader(headers, "x-ratelimit-reset-requests")
+
+        let resetTime: Date? = resetString.flatMap(Self.parseResetTime)
+
+        var totalTokens: Int?
+        if remaining == nil, limit == nil,
+           let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+           let usage = json["usage"] as? [String: Any]
+        {
+            totalTokens = usage["total_tokens"] as? Int
+        }
+
+        // 429 means the key is valid but rate-limited; treat it as valid so the UI
+        // shows "Active" instead of "No usage data" when headers are absent.
+        let keyValid = response.statusCode == 200 || response.statusCode == 429
+        // A request-limit header on 429 identifies request-bucket exhaustion even
+        // when Ark omits remaining. A bare 429 may describe another throttle.
+        let requestLimitsReliable = response.statusCode == 429
+            ? limit != nil
+            : limit != nil && remaining != nil
+
+        let snapshot = DoubaoUsageSnapshot(
+            remainingRequests: remaining ?? 0,
+            limitRequests: limit ?? 0,
+            resetTime: resetTime,
+            updatedAt: Date(),
+            apiKeyValid: keyValid,
+            totalTokens: totalTokens,
+            requestLimitsReliable: requestLimitsReliable)
+
+        Self.log.debug(
+            """
+            Doubao usage parsed remaining=\(snapshot.remainingRequests) \
+            limit=\(snapshot.limitRequests) valid=\(snapshot.apiKeyValid)
+            """)
+
+        return ProbeResult(snapshot: snapshot, statusCode: response.statusCode)
+    }
+
+    private static func stringHeader(_ headers: [AnyHashable: Any], _ name: String) -> String? {
+        if let value = headers[name] as? String { return value }
+        for (key, val) in headers {
+            if let keyStr = key as? String,
+               keyStr.caseInsensitiveCompare(name) == .orderedSame,
+               let valStr = val as? String
+            {
+                return valStr
+            }
+        }
+        return nil
+    }
+
+    private static func intHeader(_ headers: [AnyHashable: Any], _ name: String) -> Int? {
+        if let value = headers[name] as? String, let int = Int(value) {
+            return int
+        }
+        if let value = headers[name.lowercased()] as? String, let int = Int(value) {
+            return int
+        }
+        for (key, val) in headers {
+            if let keyStr = key as? String,
+               keyStr.lowercased() == name.lowercased(),
+               let valStr = val as? String,
+               let int = Int(valStr)
+            {
+                return int
+            }
+        }
+        return nil
+    }
+
+    private static func parseResetTime(_ value: String) -> Date? {
+        let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        if trimmed.isEmpty { return nil }
+
+        let isoFormatter = ISO8601DateFormatter()
+        isoFormatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        if let date = isoFormatter.date(from: trimmed) { return date }
+        let isoFallback = ISO8601DateFormatter()
+        isoFallback.formatOptions = [.withInternetDateTime]
+        if let date = isoFallback.date(from: trimmed) { return date }
+
+        var seconds: TimeInterval = 0
+        let pattern = /(\d+)([dhms])/
+        for match in trimmed.matches(of: pattern) {
+            guard let num = Double(match.1) else { continue }
+            switch match.2 {
+            case "d": seconds += num * 86400
+            case "h": seconds += num * 3600
+            case "m": seconds += num * 60
+            case "s": seconds += num
+            default: break
+            }
+        }
+        if seconds > 0 {
+            return Date().addingTimeInterval(seconds)
+        }
+
+        if let secs = TimeInterval(trimmed) {
+            return Date().addingTimeInterval(secs)
+        }
+
+        return nil
+    }
+
+    private static func apiErrorSummary(statusCode: Int, data: Data) -> String {
+        guard let root = try? JSONSerialization.jsonObject(with: data),
+              let json = root as? [String: Any]
+        else {
+            if let text = String(data: data, encoding: .utf8)?
+                .trimmingCharacters(in: .whitespacesAndNewlines),
+                !text.isEmpty
+            {
+                return self.compactText(text)
+            }
+            return "Unexpected response body (\(data.count) bytes)."
+        }
+
+        if let error = json["error"] as? [String: Any],
+           let message = error["message"] as? String
+        {
+            let trimmed = message.trimmingCharacters(in: .whitespacesAndNewlines)
+            if !trimmed.isEmpty { return Self.compactText(trimmed) }
+        }
+
+        if let message = json["message"] as? String {
+            let trimmed = message.trimmingCharacters(in: .whitespacesAndNewlines)
+            if !trimmed.isEmpty { return Self.compactText(trimmed) }
+        }
+
+        return "HTTP \(statusCode) (\(data.count) bytes)."
+    }
+
+    private static func compactText(_ text: String, maxLength: Int = 200) -> String {
+        let collapsed = text
+            .components(separatedBy: .newlines)
+            .joined(separator: " ")
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+        if collapsed.count <= maxLength { return collapsed }
+        let limitIndex = collapsed.index(collapsed.startIndex, offsetBy: maxLength)
+        return "\(collapsed[..<limitIndex])..."
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/ElevenLabs/ElevenLabsProviderDescriptor.swift b/Sources/CodexBarCore/Providers/ElevenLabs/ElevenLabsProviderDescriptor.swift
new file mode 100644
index 0000000000..1981614adc
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/ElevenLabs/ElevenLabsProviderDescriptor.swift
@@ -0,0 +1,49 @@
+import Foundation
+
+public enum ElevenLabsProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .elevenlabs,
+            metadata: ProviderMetadata(
+                id: .elevenlabs,
+                displayName: "ElevenLabs",
+                sessionLabel: "Credits",
+                weeklyLabel: "Voices",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "",
+                toggleTitle: "Show ElevenLabs usage",
+                cliName: "elevenlabs",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                browserCookieOrder: nil,
+                dashboardURL: "https://elevenlabs.io/app/developers/usage",
+                subscriptionDashboardURL: "https://elevenlabs.io/app/subscription",
+                statusPageURL: nil,
+                statusLinkURL: "https://status.elevenlabs.io"),
+            branding: ProviderBranding(
+                iconStyle: .elevenlabs,
+                iconResourceName: "ProviderIcon-elevenlabs",
+                color: ProviderColor(red: 0.92, green: 0.92, blue: 0.90)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "ElevenLabs cost history is not available via API yet." }),
+            fetchPlan: .apiToken(
+                strategyID: "elevenlabs.api",
+                resolveToken: { ProviderTokenResolver.elevenLabsToken(environment: $0) },
+                missingCredentialsError: { ElevenLabsUsageError.missingCredentials },
+                loadUsage: { apiKey, context in
+                    try await ElevenLabsUsageFetcher.fetchUsage(
+                        apiKey: apiKey,
+                        environment: context.env).toUsageSnapshot()
+                }),
+            cli: ProviderCLIConfig(
+                name: "elevenlabs",
+                aliases: ["11labs", "eleven"],
+                versionDetector: nil))
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/ElevenLabs/ElevenLabsSettingsReader.swift b/Sources/CodexBarCore/Providers/ElevenLabs/ElevenLabsSettingsReader.swift
new file mode 100644
index 0000000000..2ffececd1c
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/ElevenLabs/ElevenLabsSettingsReader.swift
@@ -0,0 +1,62 @@
+import Foundation
+
+public enum ElevenLabsSettingsReader {
+    public static let apiKeyEnvironmentKey = "ELEVENLABS_API_KEY"
+    public static let apiKeyEnvironmentKeys = [
+        Self.apiKeyEnvironmentKey,
+        "XI_API_KEY",
+    ]
+    public static let apiURLEnvironmentKey = "ELEVENLABS_API_URL"
+
+    public static func apiKey(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        for key in self.apiKeyEnvironmentKeys {
+            guard let token = self.cleaned(environment[key]) else { continue }
+            return token
+        }
+        return nil
+    }
+
+    public static func apiURL(environment: [String: String] = ProcessInfo.processInfo.environment) -> URL {
+        if let override = self.validAPIURL(environment: environment) {
+            return override
+        }
+        return URL(string: "https://api.elevenlabs.io")!
+    }
+
+    public static func validateEndpointOverrides(
+        environment: [String: String] = ProcessInfo.processInfo.environment) throws
+    {
+        guard let raw = self.cleaned(environment[self.apiURLEnvironmentKey]) else { return }
+        guard ProviderEndpointOverrideValidator.normalizedHTTPSURL(from: raw) == nil else { return }
+        throw ElevenLabsSettingsError.invalidEndpointOverride(self.apiURLEnvironmentKey)
+    }
+
+    static func cleaned(_ raw: String?) -> String? {
+        guard var value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
+            return nil
+        }
+        if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
+            (value.hasPrefix("'") && value.hasSuffix("'"))
+        {
+            value = String(value.dropFirst().dropLast())
+        }
+        value = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        return value.isEmpty ? nil : value
+    }
+
+    private static func validAPIURL(environment: [String: String]) -> URL? {
+        guard let raw = self.cleaned(environment[self.apiURLEnvironmentKey]) else { return nil }
+        return ProviderEndpointOverrideValidator.normalizedHTTPSURL(from: raw)
+    }
+}
+
+public enum ElevenLabsSettingsError: LocalizedError, Sendable, Equatable {
+    case invalidEndpointOverride(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case let .invalidEndpointOverride(key):
+            "ElevenLabs endpoint override \(key) must use HTTPS or a bare host."
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/ElevenLabs/ElevenLabsUsageFetcher.swift b/Sources/CodexBarCore/Providers/ElevenLabs/ElevenLabsUsageFetcher.swift
new file mode 100644
index 0000000000..9befb3cc15
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/ElevenLabs/ElevenLabsUsageFetcher.swift
@@ -0,0 +1,252 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public struct ElevenLabsOverage: Codable, Sendable, Equatable {
+    public let amount: String?
+    public let currency: String?
+}
+
+public struct ElevenLabsSubscriptionResponse: Decodable, Sendable {
+    public let tier: String?
+    public let characterCount: Int
+    public let characterLimit: Int
+    public let voiceSlotsUsed: Int?
+    public let professionalVoiceSlotsUsed: Int?
+    public let voiceLimit: Int?
+    public let professionalVoiceLimit: Int?
+    public let currentOverage: ElevenLabsOverage?
+    public let status: String?
+    public let nextCharacterCountResetUnix: Int?
+
+    private enum CodingKeys: String, CodingKey {
+        case tier
+        case characterCount = "character_count"
+        case characterLimit = "character_limit"
+        case voiceSlotsUsed = "voice_slots_used"
+        case professionalVoiceSlotsUsed = "professional_voice_slots_used"
+        case voiceLimit = "voice_limit"
+        case professionalVoiceLimit = "professional_voice_limit"
+        case currentOverage = "current_overage"
+        case status
+        case nextCharacterCountResetUnix = "next_character_count_reset_unix"
+    }
+}
+
+public struct ElevenLabsUsageSnapshot: Codable, Sendable, Equatable {
+    public let tier: String?
+    public let characterCount: Int
+    public let characterLimit: Int
+    public let voiceSlotsUsed: Int?
+    public let professionalVoiceSlotsUsed: Int?
+    public let voiceLimit: Int?
+    public let professionalVoiceLimit: Int?
+    public let currentOverage: ElevenLabsOverage?
+    public let status: String?
+    public let resetsAt: Date?
+    public let updatedAt: Date
+
+    public init(
+        tier: String?,
+        characterCount: Int,
+        characterLimit: Int,
+        voiceSlotsUsed: Int?,
+        professionalVoiceSlotsUsed: Int?,
+        voiceLimit: Int?,
+        professionalVoiceLimit: Int?,
+        currentOverage: ElevenLabsOverage?,
+        status: String?,
+        resetsAt: Date?,
+        updatedAt: Date)
+    {
+        self.tier = tier
+        self.characterCount = characterCount
+        self.characterLimit = characterLimit
+        self.voiceSlotsUsed = voiceSlotsUsed
+        self.professionalVoiceSlotsUsed = professionalVoiceSlotsUsed
+        self.voiceLimit = voiceLimit
+        self.professionalVoiceLimit = professionalVoiceLimit
+        self.currentOverage = currentOverage
+        self.status = status
+        self.resetsAt = resetsAt
+        self.updatedAt = updatedAt
+    }
+
+    public var usedPercent: Double {
+        guard self.characterLimit > 0 else { return 0 }
+        return max(0, Double(self.characterCount) / Double(self.characterLimit) * 100)
+    }
+
+    public var remainingCharacters: Int {
+        max(0, self.characterLimit - self.characterCount)
+    }
+
+    public func toUsageSnapshot() -> UsageSnapshot {
+        let primary = RateWindow(
+            usedPercent: self.usedPercent,
+            windowMinutes: nil,
+            resetsAt: self.resetsAt,
+            resetDescription: self.characterSummary)
+        let extraWindows = self.voiceWindows()
+        let identity = ProviderIdentitySnapshot(
+            providerID: .elevenlabs,
+            accountEmail: nil,
+            accountOrganization: nil,
+            loginMethod: self.displayTier)
+
+        return UsageSnapshot(
+            primary: primary,
+            secondary: nil,
+            tertiary: nil,
+            extraRateWindows: extraWindows.isEmpty ? nil : extraWindows,
+            updatedAt: self.updatedAt,
+            identity: identity)
+    }
+
+    private var displayTier: String? {
+        guard let tier = tier?.trimmingCharacters(in: .whitespacesAndNewlines), !tier.isEmpty else {
+            return status
+        }
+        let statusSuffix = if let status, !status.isEmpty, status.lowercased() != "active" {
+            " · \(status)"
+        } else {
+            ""
+        }
+        return "\(tier.replacingOccurrences(of: "_", with: " ").capitalized)\(statusSuffix)"
+    }
+
+    private var characterSummary: String {
+        "\(Self.formatCount(self.characterCount)) / \(Self.formatCount(self.characterLimit)) credits"
+    }
+
+    private func voiceWindows() -> [NamedRateWindow] {
+        var windows: [NamedRateWindow] = []
+        if let used = voiceSlotsUsed, let limit = voiceLimit, limit > 0 {
+            windows.append(NamedRateWindow(
+                id: "voice-slots",
+                title: "Voice slots",
+                window: RateWindow(
+                    usedPercent: Double(used) / Double(limit) * 100,
+                    windowMinutes: nil,
+                    resetsAt: nil,
+                    resetDescription: "\(used) / \(limit)")))
+        }
+        if let used = professionalVoiceSlotsUsed, let limit = professionalVoiceLimit, limit > 0 {
+            windows.append(NamedRateWindow(
+                id: "professional-voices",
+                title: "Professional voices",
+                window: RateWindow(
+                    usedPercent: Double(used) / Double(limit) * 100,
+                    windowMinutes: nil,
+                    resetsAt: nil,
+                    resetDescription: "\(used) / \(limit)")))
+        }
+        return windows
+    }
+
+    private static func formatCount(_ value: Int) -> String {
+        let formatter = NumberFormatter()
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        formatter.numberStyle = .decimal
+        formatter.usesGroupingSeparator = true
+        formatter.groupingSeparator = ","
+        formatter.maximumFractionDigits = 0
+        return formatter.string(from: NSNumber(value: value)) ?? "\(value)"
+    }
+}
+
+public enum ElevenLabsUsageError: LocalizedError, Sendable {
+    case missingCredentials
+    case networkError(String)
+    case apiError(String)
+    case parseFailed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingCredentials:
+            "Missing ElevenLabs API key. Set apiKey in ~/.codexbar/config.json or ELEVENLABS_API_KEY."
+        case let .networkError(message):
+            "ElevenLabs network error: \(message)"
+        case let .apiError(message):
+            "ElevenLabs API error: \(message)"
+        case let .parseFailed(message):
+            "Failed to parse ElevenLabs response: \(message)"
+        }
+    }
+}
+
+public struct ElevenLabsUsageFetcher: Sendable {
+    private static let log = CodexBarLog.logger(LogCategories.elevenLabsUsage)
+    private static let timeoutSeconds: TimeInterval = 15
+
+    public static func fetchUsage(
+        apiKey: String,
+        environment: [String: String] = ProcessInfo.processInfo.environment) async throws -> ElevenLabsUsageSnapshot
+    {
+        let trimmed = apiKey.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else {
+            throw ElevenLabsUsageError.missingCredentials
+        }
+        try ElevenLabsSettingsReader.validateEndpointOverrides(environment: environment)
+
+        let url = Self.subscriptionURL(baseURL: ElevenLabsSettingsReader.apiURL(environment: environment))
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.setValue(trimmed, forHTTPHeaderField: "xi-api-key")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        request.timeoutInterval = Self.timeoutSeconds
+
+        let response = try await ProviderHTTPClient.shared.response(for: request)
+        switch response.statusCode {
+        case 200:
+            return try Self.parseSnapshot(data: response.data, updatedAt: Date())
+        case 401, 403:
+            throw ElevenLabsUsageError.missingCredentials
+        default:
+            Self.log.error("ElevenLabs API returned \(response.statusCode)")
+            throw ElevenLabsUsageError.apiError("HTTP \(response.statusCode)")
+        }
+    }
+
+    static func _parseSnapshotForTesting(_ data: Data, updatedAt: Date) throws -> ElevenLabsUsageSnapshot {
+        try self.parseSnapshot(data: data, updatedAt: updatedAt)
+    }
+
+    private static func parseSnapshot(data: Data, updatedAt: Date) throws -> ElevenLabsUsageSnapshot {
+        let decoded: ElevenLabsSubscriptionResponse
+        do {
+            decoded = try JSONDecoder().decode(ElevenLabsSubscriptionResponse.self, from: data)
+        } catch {
+            throw ElevenLabsUsageError.parseFailed(error.localizedDescription)
+        }
+
+        let resetsAt = decoded.nextCharacterCountResetUnix.map {
+            Date(timeIntervalSince1970: TimeInterval($0))
+        }
+
+        return ElevenLabsUsageSnapshot(
+            tier: decoded.tier,
+            characterCount: decoded.characterCount,
+            characterLimit: decoded.characterLimit,
+            voiceSlotsUsed: decoded.voiceSlotsUsed,
+            professionalVoiceSlotsUsed: decoded.professionalVoiceSlotsUsed,
+            voiceLimit: decoded.voiceLimit,
+            professionalVoiceLimit: decoded.professionalVoiceLimit,
+            currentOverage: decoded.currentOverage,
+            status: decoded.status,
+            resetsAt: resetsAt,
+            updatedAt: updatedAt)
+    }
+
+    private static func subscriptionURL(baseURL: URL) -> URL {
+        var url = baseURL
+        let pathComponents = url.path.split(separator: "/")
+        if pathComponents.last == "v1" {
+            url.append(path: "user/subscription")
+        } else {
+            url.append(path: "v1/user/subscription")
+        }
+        return url
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Factory/FactoryLocalStorageImporter.swift b/Sources/CodexBarCore/Providers/Factory/FactoryLocalStorageImporter.swift
index b245c6981a..08f0cde2ab 100644
--- a/Sources/CodexBarCore/Providers/Factory/FactoryLocalStorageImporter.swift
+++ b/Sources/CodexBarCore/Providers/Factory/FactoryLocalStorageImporter.swift
@@ -6,7 +6,7 @@ import SweetCookieKit
 
 #if os(macOS)
 enum FactoryLocalStorageImporter {
-    struct TokenInfo: Sendable {
+    struct TokenInfo {
         let refreshToken: String
         let accessToken: String?
         let organizationID: String?
@@ -65,12 +65,12 @@ enum FactoryLocalStorageImporter {
 
     // MARK: - Chrome local storage discovery
 
-    private enum LocalStorageSourceKind: Sendable {
+    private enum LocalStorageSourceKind {
         case chromeLevelDB(URL)
         case safariSQLite(URL)
     }
 
-    private struct LocalStorageCandidate: Sendable {
+    private struct LocalStorageCandidate {
         let label: String
         let kind: LocalStorageSourceKind
     }
@@ -192,7 +192,7 @@ enum FactoryLocalStorageImporter {
 
     // MARK: - Token extraction
 
-    private struct WorkOSTokenMatch: Sendable {
+    private struct WorkOSTokenMatch {
         let refreshToken: String
         let accessToken: String?
         let organizationID: String?
diff --git a/Sources/CodexBarCore/Providers/Factory/FactoryManualCredentials.swift b/Sources/CodexBarCore/Providers/Factory/FactoryManualCredentials.swift
new file mode 100644
index 0000000000..ae4698a534
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Factory/FactoryManualCredentials.swift
@@ -0,0 +1,58 @@
+import Foundation
+
+extension FactoryStatusProbe {
+    struct ManualCredentials {
+        let cookieHeader: String?
+        let bearerToken: String?
+    }
+
+    static func manualCredentials(from raw: String?) -> ManualCredentials? {
+        guard let raw = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !raw.isEmpty else {
+            return nil
+        }
+        let normalizedCookieHeader = CookieHeaderNormalizer.normalize(raw)
+        let cookieHeader = normalizedCookieHeader.flatMap {
+            CookieHeaderNormalizer.pairs(from: $0).isEmpty ? nil : $0
+        }
+        let bearerToken = self.authorizationBearerToken(from: raw)
+            ?? normalizedCookieHeader.flatMap(self.bearerToken(fromHeader:))
+            ?? self.bareBearerToken(from: raw)
+        guard cookieHeader != nil || bearerToken != nil else { return nil }
+        return ManualCredentials(cookieHeader: cookieHeader, bearerToken: bearerToken)
+    }
+
+    static func bearerToken(fromHeader cookieHeader: String) -> String? {
+        for pair in CookieHeaderNormalizer.pairs(from: cookieHeader) where pair.name == "access-token" {
+            let token = pair.value.trimmingCharacters(in: .whitespacesAndNewlines)
+            if !token.isEmpty { return token }
+        }
+        return nil
+    }
+
+    private static func authorizationBearerToken(from raw: String) -> String? {
+        let pattern = #"(?i)(?:authorization\s*:\s*)?bearer\s+([A-Za-z0-9._~+/=-]+)"#
+        guard let regex = try? NSRegularExpression(pattern: pattern, options: []) else { return nil }
+        let range = NSRange(raw.startIndex..<raw.endIndex, in: raw)
+        guard let match = regex.firstMatch(in: raw, options: [], range: range),
+              match.numberOfRanges >= 2,
+              let tokenRange = Range(match.range(at: 1), in: raw)
+        else {
+            return nil
+        }
+        let token = raw[tokenRange].trimmingCharacters(in: .whitespacesAndNewlines)
+        return token.isEmpty ? nil : String(token)
+    }
+
+    private static func bareBearerToken(from raw: String) -> String? {
+        let token = raw.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !token.contains("="),
+              !token.contains(";"),
+              !token.contains(" "),
+              !token.contains("\n"),
+              token.count >= 40 || token.split(separator: ".").count >= 3
+        else {
+            return nil
+        }
+        return token
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Factory/FactoryProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Factory/FactoryProviderDescriptor.swift
index dbbe1509df..444d6a9521 100644
--- a/Sources/CodexBarCore/Providers/Factory/FactoryProviderDescriptor.swift
+++ b/Sources/CodexBarCore/Providers/Factory/FactoryProviderDescriptor.swift
@@ -1,9 +1,8 @@
-import CodexBarMacroSupport
 import Foundation
 
-@ProviderDescriptorRegistration
-@ProviderDescriptorDefinition
 public enum FactoryProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
     static func makeDescriptor() -> ProviderDescriptor {
         ProviderDescriptor(
             id: .factory,
@@ -65,6 +64,6 @@ struct FactoryStatusFetchStrategy: ProviderFetchStrategy {
 
     private static func manualCookieHeader(from context: ProviderFetchContext) -> String? {
         guard context.settings?.factory?.cookieSource == .manual else { return nil }
-        return CookieHeaderNormalizer.normalize(context.settings?.factory?.manualCookieHeader)
+        return context.settings?.factory?.manualCookieHeader?.trimmingCharacters(in: .whitespacesAndNewlines)
     }
 }
diff --git a/Sources/CodexBarCore/Providers/Factory/FactoryStatusProbe.swift b/Sources/CodexBarCore/Providers/Factory/FactoryStatusProbe.swift
index b4994a1d14..6289718776 100644
--- a/Sources/CodexBarCore/Providers/Factory/FactoryStatusProbe.swift
+++ b/Sources/CodexBarCore/Providers/Factory/FactoryStatusProbe.swift
@@ -79,7 +79,7 @@ public enum FactoryCookieImporter {
         let log: (String) -> Void = { msg in logger?("[factory-cookie] \(msg)") }
         let cookieDomains = ["factory.ai", "app.factory.ai", "auth.factory.ai"]
         let query = BrowserCookieQuery(domains: cookieDomains)
-        let sources = try Self.cookieClient.records(
+        let sources = try Self.cookieClient.codexBarRecords(
             matching: query,
             in: browserSource,
             logger: log)
@@ -138,6 +138,12 @@ public enum FactoryCookieImporter {
 public struct FactoryAuthResponse: Codable, Sendable {
     public let featureFlags: FactoryFeatureFlags?
     public let organization: FactoryOrganization?
+    public let userProfile: FactoryUserProfile?
+}
+
+public struct FactoryUserProfile: Codable, Sendable {
+    public let id: String?
+    public let email: String?
 }
 
 public struct FactoryFeatureFlags: Codable, Sendable {
@@ -195,6 +201,117 @@ public struct FactoryTokenUsage: Codable, Sendable {
     public let orgOverageLimit: Int64?
 }
 
+public struct FactoryBillingLimitsResponse: Codable, Sendable {
+    public let usesTokenRateLimitsBilling: Bool
+    public let limits: FactoryTokenRateLimits?
+    public let extraUsageBalanceCents: Int
+    public let overagePreference: String?
+    public let extraUsageAllowed: Bool
+    public let tokenRateLimitsRolloutEligible: Bool
+
+    enum CodingKeys: String, CodingKey {
+        case usesTokenRateLimitsBilling
+        case limits
+        case extraUsageBalanceCents
+        case overagePreference
+        case extraUsageAllowed
+        case tokenRateLimitsRolloutEligible
+    }
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.usesTokenRateLimitsBilling = try container
+            .decodeIfPresent(Bool.self, forKey: .usesTokenRateLimitsBilling) ?? false
+        self.limits = try container.decodeIfPresent(FactoryTokenRateLimits.self, forKey: .limits)
+        self.extraUsageBalanceCents = try container.decodeIfPresent(Int.self, forKey: .extraUsageBalanceCents) ?? 0
+        self.overagePreference = try container.decodeIfPresent(String.self, forKey: .overagePreference)
+        self.extraUsageAllowed = try container.decodeIfPresent(Bool.self, forKey: .extraUsageAllowed) ?? false
+        self.tokenRateLimitsRolloutEligible = try container
+            .decodeIfPresent(Bool.self, forKey: .tokenRateLimitsRolloutEligible) ?? false
+    }
+}
+
+public struct FactoryTokenRateLimits: Codable, Sendable {
+    public let standard: FactoryLimitPool
+    public let core: FactoryLimitPool?
+}
+
+public struct FactoryLimitPool: Codable, Sendable {
+    public let fiveHour: FactoryBillingWindow
+    public let weekly: FactoryBillingWindow
+    public let monthly: FactoryBillingWindow
+
+    public var hasUsageData: Bool {
+        [self.fiveHour, self.weekly, self.monthly].contains {
+            $0.usedPercent > 0 || $0.windowEnd != nil || $0.secondsRemaining != nil
+        }
+    }
+}
+
+public struct FactoryBillingWindow: Codable, Sendable {
+    public let usedPercent: Double
+    public let windowEnd: FlexibleFactoryDate?
+    public let secondsRemaining: Double?
+
+    public func resetAt(now: Date) -> Date? {
+        if let secondsRemaining, secondsRemaining > 0 {
+            return now.addingTimeInterval(secondsRemaining)
+        }
+        guard let windowEnd = self.windowEnd?.date, windowEnd > now else {
+            return nil
+        }
+        return windowEnd
+    }
+
+    public func effectiveUsedPercent(now: Date) -> Double {
+        // Factory can leave stale values after short rolling windows expire. The web UI treats
+        // that state as reset, so mirror it here instead of showing expired usage.
+        if self.resetAt(now: now) == nil, self.windowEnd != nil, self.secondsRemaining == nil {
+            return 0
+        }
+        return min(100, max(0, self.usedPercent))
+    }
+
+    public func rateWindow(windowMinutes: Int?, title: String, now: Date) -> RateWindow {
+        let reset = self.resetAt(now: now)
+        return RateWindow(
+            usedPercent: self.effectiveUsedPercent(now: now),
+            windowMinutes: windowMinutes,
+            resetsAt: reset,
+            resetDescription: reset.map { FactoryStatusSnapshot.formatResetDate($0) })
+    }
+}
+
+public struct FlexibleFactoryDate: Codable, Sendable {
+    public let date: Date
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        if let seconds = try? container.decode(Double.self) {
+            self.date = Date(timeIntervalSince1970: seconds > 1e12 ? seconds / 1000.0 : seconds)
+            return
+        }
+        let string = try container.decode(String.self)
+        if let numeric = Double(string) {
+            self.date = Date(timeIntervalSince1970: numeric > 1e12 ? numeric / 1000.0 : numeric)
+            return
+        }
+
+        let fractional = ISO8601DateFormatter()
+        fractional.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        if let parsed = fractional.date(from: string) ?? ISO8601DateFormatter().date(from: string) {
+            self.date = parsed
+            return
+        }
+        throw DecodingError.dataCorruptedError(in: container, debugDescription: "Invalid Factory date")
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+        try container.encode(self.date)
+    }
+}
+
 /// Helper for encoding arbitrary JSON
 public struct AnyCodable: Codable, Sendable {
     public init(from decoder: Decoder) throws {
@@ -248,6 +365,10 @@ public struct FactoryStatusSnapshot: Sendable {
     public let userId: String?
     /// Raw JSON for debugging
     public let rawJSON: String?
+    /// New Factory token-rate-limits billing payload, when enabled for the account.
+    public let tokenRateLimits: FactoryTokenRateLimits?
+    public let extraUsageBalanceCents: Int?
+    public let overagePreference: String?
 
     public init(
         standardUserTokens: Int64,
@@ -265,7 +386,10 @@ public struct FactoryStatusSnapshot: Sendable {
         organizationName: String?,
         accountEmail: String?,
         userId: String?,
-        rawJSON: String?)
+        rawJSON: String?,
+        tokenRateLimits: FactoryTokenRateLimits? = nil,
+        extraUsageBalanceCents: Int? = nil,
+        overagePreference: String? = nil)
     {
         self.standardUserTokens = standardUserTokens
         self.standardOrgTokens = standardOrgTokens
@@ -283,10 +407,17 @@ public struct FactoryStatusSnapshot: Sendable {
         self.accountEmail = accountEmail
         self.userId = userId
         self.rawJSON = rawJSON
+        self.tokenRateLimits = tokenRateLimits
+        self.extraUsageBalanceCents = extraUsageBalanceCents
+        self.overagePreference = overagePreference
     }
 
     /// Convert to UsageSnapshot for the common provider interface
     public func toUsageSnapshot() -> UsageSnapshot {
+        if let tokenRateLimits {
+            return self.tokenRateLimitsUsageSnapshot(from: tokenRateLimits)
+        }
+
         // Primary: Standard tokens used (as percentage of allowance, capped reasonably)
         let standardPercent = self.calculateUsagePercent(
             used: self.standardUserTokens,
@@ -337,12 +468,75 @@ public struct FactoryStatusSnapshot: Sendable {
             identity: identity)
     }
 
+    private func tokenRateLimitsUsageSnapshot(from limits: FactoryTokenRateLimits) -> UsageSnapshot {
+        let now = Date()
+        let primary = limits.standard.fiveHour.rateWindow(windowMinutes: 5 * 60, title: "5h", now: now)
+        let secondary = limits.standard.weekly.rateWindow(windowMinutes: 7 * 24 * 60, title: "7-day", now: now)
+        let tertiary = limits.standard.monthly.rateWindow(windowMinutes: nil, title: "Monthly", now: now)
+
+        let coreWindows: [NamedRateWindow]? = if let core = limits.core, core.hasUsageData {
+            [
+                NamedRateWindow(
+                    id: "factory-core-5h",
+                    title: "Core 5h",
+                    window: core.fiveHour.rateWindow(windowMinutes: 5 * 60, title: "Core 5h", now: now)),
+                NamedRateWindow(
+                    id: "factory-core-7d",
+                    title: "Core 7-day",
+                    window: core.weekly.rateWindow(windowMinutes: 7 * 24 * 60, title: "Core 7-day", now: now)),
+                NamedRateWindow(
+                    id: "factory-core-monthly",
+                    title: "Core Monthly",
+                    window: core.monthly.rateWindow(windowMinutes: nil, title: "Core Monthly", now: now)),
+            ]
+        } else {
+            nil
+        }
+
+        let loginMethod: String? = {
+            var parts: [String] = []
+            if let tier = self.tier, !tier.isEmpty {
+                parts.append("Factory \(tier.capitalized)")
+            }
+            if let plan = self.planName, !plan.isEmpty, !plan.lowercased().contains("factory") {
+                parts.append(plan)
+            }
+            if let overagePreference, !overagePreference.isEmpty {
+                parts.append("Fallback: \(overagePreference)")
+            }
+            return parts.isEmpty ? nil : parts.joined(separator: " - ")
+        }()
+
+        let identity = ProviderIdentitySnapshot(
+            providerID: .factory,
+            accountEmail: self.accountEmail,
+            accountOrganization: self.organizationName,
+            loginMethod: loginMethod)
+        let providerCost = self.extraUsageBalanceCents.map {
+            ProviderCostSnapshot(
+                used: Double($0) / 100.0,
+                limit: 0,
+                currencyCode: "USD",
+                period: "Extra usage balance",
+                updatedAt: now)
+        }
+        return UsageSnapshot(
+            primary: primary,
+            secondary: secondary,
+            tertiary: tertiary,
+            extraRateWindows: coreWindows,
+            providerCost: providerCost,
+            updatedAt: now,
+            identity: identity)
+    }
+
     private func calculateUsagePercent(used: Int64, allowance: Int64, apiRatio: Double?) -> Double {
         // Prefer API-provided ratio when available and valid.
         // This handles plan-specific limits correctly on the server side,
         // avoiding issues with missing/sentinel values in totalAllowance.
         let unlimitedThreshold: Int64 = 1_000_000_000_000
         if let ratio = apiRatio,
+           !(ratio == 0 && used > 0 && allowance > 0 && allowance <= unlimitedThreshold),
            let percent = Self.percentFromAPIRatio(ratio, allowance: allowance, unlimitedThreshold: unlimitedThreshold)
         {
             return percent
@@ -383,7 +577,7 @@ public struct FactoryStatusSnapshot: Sendable {
         return nil
     }
 
-    private static func formatResetDate(_ date: Date) -> String {
+    static func formatResetDate(_ date: Date) -> String {
         let formatter = DateFormatter()
         formatter.dateFormat = "MMM d 'at' h:mma"
         formatter.locale = Locale(identifier: "en_US_POSIX")
@@ -402,7 +596,8 @@ public enum FactoryStatusProbeError: LocalizedError, Sendable {
     public var errorDescription: String? {
         switch self {
         case .notLoggedIn:
-            "Not logged in to Factory. Please log in via the CodexBar menu."
+            "No usable Droid session found. Log in to app.factory.ai in \(factoryCookieImportOrder.loginHint), " +
+                "then refresh Droid."
         case let .networkError(msg):
             "Factory API error: \(msg)"
         case let .parseFailed(msg):
@@ -421,7 +616,7 @@ public actor FactorySessionStore {
     private var sessionCookies: [HTTPCookie] = []
     private var bearerToken: String?
     private var refreshToken: String?
-    private let fileURL: URL
+    private var fileURL: URL
     private var didLoadFromDisk = false
 
     private init() {
@@ -444,6 +639,13 @@ public actor FactorySessionStore {
         return self.sessionCookies
     }
 
+    public func clearCookies() {
+        self.loadFromDiskIfNeeded()
+        self.didLoadFromDisk = true
+        self.sessionCookies = []
+        self.saveToDisk()
+    }
+
     public func setBearerToken(_ token: String?) {
         self.didLoadFromDisk = true
         self.bearerToken = token
@@ -479,6 +681,22 @@ public actor FactorySessionStore {
         return !self.sessionCookies.isEmpty || self.bearerToken != nil || self.refreshToken != nil
     }
 
+    func resetInMemoryForTesting() {
+        self.sessionCookies = []
+        self.bearerToken = nil
+        self.refreshToken = nil
+        self.didLoadFromDisk = false
+    }
+
+    func useFileURLForTesting(_ fileURL: URL) {
+        self.fileURL = fileURL
+        self.sessionCookies = []
+        self.bearerToken = nil
+        self.refreshToken = nil
+        self.didLoadFromDisk = false
+        try? FileManager.default.removeItem(at: fileURL)
+    }
+
     private func saveToDisk() {
         let cookieData = self.sessionCookies.compactMap { cookie -> [String: Any]? in
             guard let props = cookie.properties else { return nil }
@@ -516,6 +734,7 @@ public actor FactorySessionStore {
         guard !payload.isEmpty,
               let data = try? JSONSerialization.data(withJSONObject: payload, options: [.prettyPrinted])
         else {
+            try? FileManager.default.removeItem(at: self.fileURL)
             return
         }
         try? data.write(to: self.fileURL)
@@ -590,22 +809,25 @@ public struct FactoryStatusProbe: Sendable {
         "client_01HNM792M5G5G1A2THWPXKFMXB",
     ]
 
-    private struct WorkOSAuthResponse: Decodable, Sendable {
+    private struct WorkOSAuthResponse: Decodable {
         let access_token: String
         let refresh_token: String?
         let organization_id: String?
     }
 
     private let browserDetection: BrowserDetection
+    private let transport: any ProviderHTTPTransport
 
     public init(
         baseURL: URL = URL(string: "https://app.factory.ai")!,
         timeout: TimeInterval = 15.0,
-        browserDetection: BrowserDetection)
+        browserDetection: BrowserDetection,
+        transport: any ProviderHTTPTransport = ProviderHTTPClient.shared)
     {
         self.baseURL = baseURL
         self.timeout = timeout
         self.browserDetection = browserDetection
+        self.transport = transport
     }
 
     /// Fetch Factory usage using browser cookies with fallback to stored session.
@@ -616,24 +838,33 @@ public struct FactoryStatusProbe: Sendable {
         let log: (String) -> Void = { msg in logger?("[factory] \(msg)") }
         var lastError: Error?
 
-        if let override = CookieHeaderNormalizer.normalize(cookieHeaderOverride) {
-            log("Using manual cookie header")
-            let bearer = Self.bearerToken(fromHeader: override)
-            let candidates = [
-                self.baseURL,
-                Self.authBaseURL,
-                Self.apiBaseURL,
-            ]
-            for baseURL in candidates {
-                do {
-                    return try await self.fetchWithCookieHeader(
-                        override,
-                        bearerToken: bearer,
-                        baseURL: baseURL)
-                } catch {
-                    lastError = error
+        let manualOverride = cookieHeaderOverride?.trimmingCharacters(in: .whitespacesAndNewlines)
+        if manualOverride?.isEmpty == false {
+            guard let override = Self.manualCredentials(from: manualOverride) else {
+                throw FactoryStatusProbeError.noSessionCookie
+            }
+            if let cookieHeader = override.cookieHeader {
+                log("Using manual cookie header")
+                let candidates = [
+                    self.baseURL,
+                    Self.authBaseURL,
+                    Self.apiBaseURL,
+                ]
+                for baseURL in candidates {
+                    do {
+                        return try await self.fetchWithCookieHeader(
+                            cookieHeader,
+                            bearerToken: override.bearerToken,
+                            baseURL: baseURL)
+                    } catch {
+                        lastError = error
+                    }
                 }
             }
+            if let bearerToken = override.bearerToken {
+                log("Using manual Factory bearer token")
+                return try await self.fetchWithBearerToken(bearerToken, logger: log)
+            }
             if let lastError { throw lastError }
             throw FactoryStatusProbeError.noSessionCookie
         }
@@ -659,19 +890,19 @@ public struct FactoryStatusProbe: Sendable {
         // Filter to only installed browsers to avoid unnecessary keychain prompts
         let installedChromiumAndFirefox = [.chrome, .firefox].cookieImportCandidates(using: self.browserDetection)
 
-        let attempts: [FetchAttemptResult] = await [
-            self.attemptStoredCookies(logger: log),
-            self.attemptStoredBearer(logger: log),
-            self.attemptStoredRefreshToken(logger: log),
-            self.attemptLocalStorageTokens(logger: log),
-            self.attemptBrowserCookies(logger: log, sources: [.safari]),
-            self.attemptWorkOSCookies(logger: log, sources: [.safari]),
-            self.attemptBrowserCookies(logger: log, sources: installedChromiumAndFirefox),
-            self.attemptWorkOSCookies(logger: log, sources: installedChromiumAndFirefox),
+        let attempts: [() async -> FetchAttemptResult] = [
+            { await self.attemptStoredCookies(logger: log) },
+            { await self.attemptStoredBearer(logger: log) },
+            { await self.attemptStoredRefreshToken(logger: log) },
+            { await self.attemptLocalStorageTokens(logger: log) },
+            { await self.attemptBrowserCookies(logger: log, sources: [.safari]) },
+            { await self.attemptWorkOSCookies(logger: log, sources: [.safari]) },
+            { await self.attemptBrowserCookies(logger: log, sources: installedChromiumAndFirefox) },
+            { await self.attemptWorkOSCookies(logger: log, sources: installedChromiumAndFirefox) },
         ]
 
-        for result in attempts {
-            switch result {
+        for attempt in attempts {
+            switch await attempt() {
             case let .success(snapshot):
                 return snapshot
             case let .failure(error):
@@ -685,7 +916,7 @@ public struct FactoryStatusProbe: Sendable {
         throw FactoryStatusProbeError.noSessionCookie
     }
 
-    private enum FetchAttemptResult: Sendable {
+    private enum FetchAttemptResult {
         case success(FactoryStatusSnapshot)
         case failure(Error)
         case skipped
@@ -732,8 +963,8 @@ public struct FactoryStatusProbe: Sendable {
             return try await .success(self.fetchWithCookies(storedCookies, logger: logger))
         } catch {
             if case FactoryStatusProbeError.notLoggedIn = error {
-                await FactorySessionStore.shared.clearSession()
-                logger("Stored session invalid, cleared")
+                await FactorySessionStore.shared.clearCookies()
+                logger("Stored session cookies invalid, cleared")
             } else {
                 logger("Stored session failed: \(error.localizedDescription)")
             }
@@ -818,7 +1049,7 @@ public struct FactoryStatusProbe: Sendable {
         for browserSource in sources {
             do {
                 let query = BrowserCookieQuery(domains: ["workos.com"])
-                let sources = try BrowserCookieClient().records(
+                let sources = try BrowserCookieClient().codexBarRecords(
                     matching: query,
                     in: browserSource,
                     logger: log)
@@ -978,14 +1209,6 @@ public struct FactoryStatusProbe: Sendable {
         cookies.map { "\($0.name)=\($0.value)" }.joined(separator: "; ")
     }
 
-    private static func bearerToken(fromHeader cookieHeader: String) -> String? {
-        for pair in CookieHeaderNormalizer.pairs(from: cookieHeader) where pair.name == "access-token" {
-            let token = pair.value.trimmingCharacters(in: .whitespacesAndNewlines)
-            if !token.isEmpty { return token }
-        }
-        return nil
-    }
-
     private func fetchWithCookieHeader(
         _ cookieHeader: String,
         bearerToken: String?,
@@ -997,8 +1220,21 @@ public struct FactoryStatusProbe: Sendable {
             bearerToken: bearerToken,
             baseURL: baseURL)
 
-        // Extract user ID from JWT in the auth response or use a default endpoint
-        let userId = self.extractUserIdFromAuth(authInfo)
+        let userId = factoryUserIdFromAuth(authInfo)
+            ?? factoryUserIdFromBearerToken(bearerToken)
+
+        if let billingLimits = try await self.fetchBillingLimitsIfAvailable(
+            cookieHeader: cookieHeader,
+            bearerToken: bearerToken),
+            billingLimits.usesTokenRateLimitsBilling,
+            let tokenRateLimits = billingLimits.limits
+        {
+            return self.buildTokenRateLimitsSnapshot(
+                authInfo: authInfo,
+                billingLimits: billingLimits,
+                tokenRateLimits: tokenRateLimits,
+                userId: userId)
+        }
 
         // Fetch usage data
         let usageData = try await self.fetchUsage(
@@ -1010,6 +1246,45 @@ public struct FactoryStatusProbe: Sendable {
         return self.buildSnapshot(authInfo: authInfo, usageData: usageData, userId: userId)
     }
 
+    private func fetchBillingLimitsIfAvailable(
+        cookieHeader: String,
+        bearerToken: String?) async throws -> FactoryBillingLimitsResponse?
+    {
+        let url = Self.apiBaseURL.appendingPathComponent("/api/billing/limits")
+        var request = URLRequest(url: url)
+        request.timeoutInterval = self.timeout
+        request.httpMethod = "GET"
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.setValue("https://app.factory.ai", forHTTPHeaderField: "Origin")
+        request.setValue("https://app.factory.ai/", forHTTPHeaderField: "Referer")
+        request.setValue("web-app", forHTTPHeaderField: "x-factory-client")
+        if !cookieHeader.isEmpty {
+            request.setValue(cookieHeader, forHTTPHeaderField: "Cookie")
+        }
+        if let bearerToken {
+            request.setValue("Bearer \(bearerToken)", forHTTPHeaderField: "Authorization")
+        }
+
+        let data: Data
+        let response: URLResponse
+        do {
+            (data, response) = try await self.transport.data(for: request)
+        } catch {
+            return nil
+        }
+
+        guard let httpResponse = response as? HTTPURLResponse else {
+            return nil
+        }
+
+        guard httpResponse.statusCode == 200 else {
+            return nil
+        }
+
+        return try? JSONDecoder().decode(FactoryBillingLimitsResponse.self, from: data)
+    }
+
     private func fetchAuthInfo(
         cookieHeader: String,
         bearerToken: String?,
@@ -1031,16 +1306,23 @@ public struct FactoryStatusProbe: Sendable {
             request.setValue("Bearer \(bearerToken)", forHTTPHeaderField: "Authorization")
         }
 
-        let (data, response) = try await URLSession.shared.data(for: request)
+        let (data, response) = try await self.transport.data(for: request)
 
         guard let httpResponse = response as? HTTPURLResponse else {
             throw FactoryStatusProbeError.networkError("Invalid response")
         }
 
-        if httpResponse.statusCode == 401 || httpResponse.statusCode == 403 {
+        if httpResponse.statusCode == 401 {
             throw FactoryStatusProbeError.notLoggedIn
         }
 
+        if httpResponse.statusCode == 403 {
+            let body = String(data: data, encoding: .utf8)?
+                .trimmingCharacters(in: .whitespacesAndNewlines) ?? "<binary>"
+            let snippet = body.isEmpty ? "" : ": \(body.prefix(200))"
+            throw FactoryStatusProbeError.networkError("HTTP 403 Forbidden\(snippet)")
+        }
+
         guard httpResponse.statusCode == 200 else {
             let body = String(data: data, encoding: .utf8)?
                 .trimmingCharacters(in: .whitespacesAndNewlines) ?? "<binary>"
@@ -1064,10 +1346,19 @@ public struct FactoryStatusProbe: Sendable {
         userId: String?,
         baseURL: URL) async throws -> FactoryUsageResponse
     {
-        let url = baseURL.appendingPathComponent("/api/organization/subscription/usage")
+        var components = URLComponents(
+            url: baseURL.appendingPathComponent("/api/organization/subscription/usage"),
+            resolvingAgainstBaseURL: false)
+        components?.queryItems = [
+            URLQueryItem(name: "useCache", value: "true"),
+        ]
+        if let userId {
+            components?.queryItems?.append(URLQueryItem(name: "userId", value: userId))
+        }
+        let url = components?.url ?? baseURL.appendingPathComponent("/api/organization/subscription/usage")
         var request = URLRequest(url: url)
         request.timeoutInterval = self.timeout
-        request.httpMethod = "POST"
+        request.httpMethod = "GET"
         request.setValue("application/json", forHTTPHeaderField: "Accept")
         request.setValue("application/json", forHTTPHeaderField: "Content-Type")
         request.setValue("https://app.factory.ai", forHTTPHeaderField: "Origin")
@@ -1080,14 +1371,7 @@ public struct FactoryStatusProbe: Sendable {
             request.setValue("Bearer \(bearerToken)", forHTTPHeaderField: "Authorization")
         }
 
-        // Build request body
-        var body: [String: Any] = ["useCache": true]
-        if let userId {
-            body["userId"] = userId
-        }
-        request.httpBody = try? JSONSerialization.data(withJSONObject: body)
-
-        let (data, response) = try await URLSession.shared.data(for: request)
+        let (data, response) = try await self.transport.data(for: request)
 
         guard let httpResponse = response as? HTTPURLResponse else {
             throw FactoryStatusProbeError.networkError("Invalid response")
@@ -1221,7 +1505,7 @@ public struct FactoryStatusProbe: Sendable {
         }
         request.httpBody = try JSONSerialization.data(withJSONObject: body, options: [])
 
-        let (data, response) = try await URLSession.shared.data(for: request)
+        let (data, response) = try await self.transport.data(for: request)
         guard let httpResponse = response as? HTTPURLResponse else {
             throw FactoryStatusProbeError.networkError("Invalid WorkOS response")
         }
@@ -1291,7 +1575,7 @@ public struct FactoryStatusProbe: Sendable {
         }
         request.httpBody = try JSONSerialization.data(withJSONObject: body, options: [])
 
-        let (data, response) = try await URLSession.shared.data(for: request)
+        let (data, response) = try await self.transport.data(for: request)
         guard let httpResponse = response as? HTTPURLResponse else {
             throw FactoryStatusProbeError.networkError("Invalid WorkOS response")
         }
@@ -1325,12 +1609,6 @@ public struct FactoryStatusProbe: Sendable {
         return description.localizedCaseInsensitiveContains("missing refresh token")
     }
 
-    private func extractUserIdFromAuth(_ auth: FactoryAuthResponse) -> String? {
-        // The user ID might be in the organization or we might need to parse JWT
-        // For now, return nil and let the API handle it
-        nil
-    }
-
     private func buildSnapshot(
         authInfo: FactoryAuthResponse,
         usageData: FactoryUsageResponse,
@@ -1359,6 +1637,55 @@ public struct FactoryStatusProbe: Sendable {
             userId: userId ?? usageData.userId,
             rawJSON: nil)
     }
+
+    private func buildTokenRateLimitsSnapshot(
+        authInfo: FactoryAuthResponse,
+        billingLimits: FactoryBillingLimitsResponse,
+        tokenRateLimits: FactoryTokenRateLimits,
+        userId: String?) -> FactoryStatusSnapshot
+    {
+        FactoryStatusSnapshot(
+            standardUserTokens: 0,
+            standardOrgTokens: 0,
+            standardAllowance: 0,
+            standardUsedRatio: nil,
+            premiumUserTokens: 0,
+            premiumOrgTokens: 0,
+            premiumAllowance: 0,
+            premiumUsedRatio: nil,
+            periodStart: nil,
+            periodEnd: nil,
+            planName: authInfo.organization?.subscription?.orbSubscription?.plan?.name,
+            tier: authInfo.organization?.subscription?.factoryTier,
+            organizationName: authInfo.organization?.name,
+            accountEmail: nil,
+            userId: userId,
+            rawJSON: nil,
+            tokenRateLimits: tokenRateLimits,
+            extraUsageBalanceCents: billingLimits.extraUsageBalanceCents,
+            overagePreference: billingLimits.overagePreference)
+    }
+}
+
+private func factoryUserIdFromAuth(_ auth: FactoryAuthResponse) -> String? {
+    factoryNormalizedString(auth.userProfile?.id)
+}
+
+private func factoryUserIdFromBearerToken(_ token: String?) -> String? {
+    guard let token,
+          let claims = UsageFetcher.parseJWT(token),
+          let subject = claims["sub"] as? String
+    else {
+        return nil
+    }
+    return factoryNormalizedString(subject)
+}
+
+private func factoryNormalizedString(_ value: String?) -> String? {
+    guard let value = value?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
+        return nil
+    }
+    return value
 }
 
 #else
@@ -1391,11 +1718,13 @@ public struct FactoryStatusProbe: Sendable {
     public init(
         baseURL: URL = URL(string: "https://app.factory.ai")!,
         timeout: TimeInterval = 15.0,
-        browserDetection: BrowserDetection)
+        browserDetection: BrowserDetection,
+        transport: any ProviderHTTPTransport = ProviderHTTPClient.shared)
     {
         _ = baseURL
         _ = timeout
         _ = browserDetection
+        _ = transport
     }
 
     public func fetch(
diff --git a/Sources/CodexBarCore/Providers/Gemini/GeminiProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Gemini/GeminiProviderDescriptor.swift
index b503b39785..322ad1f14a 100644
--- a/Sources/CodexBarCore/Providers/Gemini/GeminiProviderDescriptor.swift
+++ b/Sources/CodexBarCore/Providers/Gemini/GeminiProviderDescriptor.swift
@@ -1,9 +1,8 @@
-import CodexBarMacroSupport
 import Foundation
 
-@ProviderDescriptorRegistration
-@ProviderDescriptorDefinition
 public enum GeminiProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
     static func makeDescriptor() -> ProviderDescriptor {
         ProviderDescriptor(
             id: .gemini,
@@ -12,8 +11,8 @@ public enum GeminiProviderDescriptor {
                 displayName: "Gemini",
                 sessionLabel: "Pro",
                 weeklyLabel: "Flash",
-                opusLabel: nil,
-                supportsOpus: false,
+                opusLabel: "Flash Lite",
+                supportsOpus: true,
                 supportsCredits: false,
                 creditsHint: "",
                 toggleTitle: "Show Gemini usage",
@@ -22,6 +21,7 @@ public enum GeminiProviderDescriptor {
                 isPrimaryProvider: false,
                 usesAccountFallback: false,
                 dashboardURL: "https://gemini.google.com",
+                changelogURL: "https://github.com/google-gemini/gemini-cli/releases",
                 statusPageURL: nil,
                 statusLinkURL: "https://www.google.com/appsstatus/dashboard/products/npdyhgECDJ6tB66MxXyo/history",
                 statusWorkspaceProductID: "npdyhgECDJ6tB66MxXyo"),
@@ -42,6 +42,8 @@ public enum GeminiProviderDescriptor {
 }
 
 struct GeminiStatusFetchStrategy: ProviderFetchStrategy {
+    static let sourceLabel = "oauth-api"
+
     let id: String = "gemini.api"
     let kind: ProviderFetchKind = .apiToken
 
@@ -54,7 +56,7 @@ struct GeminiStatusFetchStrategy: ProviderFetchStrategy {
         let snap = try await probe.fetch()
         return self.makeResult(
             usage: snap.toUsageSnapshot(),
-            sourceLabel: "api")
+            sourceLabel: Self.sourceLabel)
     }
 
     func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
diff --git a/Sources/CodexBarCore/Providers/Gemini/GeminiStatusProbe+DataLoader.swift b/Sources/CodexBarCore/Providers/Gemini/GeminiStatusProbe+DataLoader.swift
new file mode 100644
index 0000000000..502f4960c4
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Gemini/GeminiStatusProbe+DataLoader.swift
@@ -0,0 +1,131 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+extension GeminiStatusProbe {
+    public static func defaultDataLoader(for request: URLRequest) async throws -> (Data, URLResponse) {
+        let loader = Self.dataLoaderWithCurlFallback(
+            primary: { request in
+                try await ProviderHTTPClient.shared.data(for: request)
+            },
+            fallback: Self.curlDataLoader)
+        return try await loader(request)
+    }
+
+    public static func dataLoaderWithCurlFallback(
+        primary: @escaping @Sendable (URLRequest) async throws -> (Data, URLResponse),
+        fallback: @escaping @Sendable (URLRequest) async throws -> (Data, URLResponse))
+        -> @Sendable (URLRequest) async throws -> (Data, URLResponse)
+    {
+        { request in
+            do {
+                return try await primary(request)
+            } catch {
+                guard Self.isURLSessionTimeout(error) else {
+                    throw error
+                }
+                CodexBarLog.logger(LogCategories.geminiProbe)
+                    .warning("Gemini URLSession timed out; retrying with curl")
+                return try await fallback(request)
+            }
+        }
+    }
+
+    private static func isURLSessionTimeout(_ error: Error) -> Bool {
+        if let urlError = error as? URLError {
+            return urlError.code == .timedOut
+        }
+
+        let nsError = error as NSError
+        return nsError.domain == NSURLErrorDomain && nsError.code == NSURLErrorTimedOut
+    }
+
+    private static func curlDataLoader(for request: URLRequest) async throws -> (Data, URLResponse) {
+        guard let url = request.url else {
+            throw URLError(.badURL)
+        }
+
+        let fileManager = FileManager.default
+        let tempDir = fileManager.temporaryDirectory
+            .appendingPathComponent("codexbar-gemini-curl-\(UUID().uuidString)", isDirectory: true)
+        try fileManager.createDirectory(
+            at: tempDir,
+            withIntermediateDirectories: true,
+            attributes: [.posixPermissions: 0o700])
+        defer {
+            try? fileManager.removeItem(at: tempDir)
+        }
+
+        let configURL = tempDir.appendingPathComponent("curl.conf")
+        var config = [
+            "silent",
+            "show-error",
+            "location",
+            "url = \(Self.curlConfigQuote(url.absoluteString))",
+            "max-time = \(max(1, Int(ceil(request.timeoutInterval))))",
+        ]
+
+        if let method = request.httpMethod, !method.isEmpty {
+            config.append("request = \(Self.curlConfigQuote(method))")
+        }
+
+        for (name, value) in (request.allHTTPHeaderFields ?? [:]).sorted(by: { $0.key < $1.key }) {
+            let header = "\(name): \(value)"
+            guard !header.contains("\n"), !header.contains("\r") else {
+                throw GeminiStatusProbeError.apiError("Invalid request header")
+            }
+            config.append("header = \(Self.curlConfigQuote(header))")
+        }
+
+        if let body = request.httpBody {
+            let bodyURL = tempDir.appendingPathComponent("body")
+            try body.write(to: bodyURL, options: .atomic)
+            try fileManager.setAttributes([.posixPermissions: 0o600], ofItemAtPath: bodyURL.path)
+            config.append("data-binary = \(Self.curlConfigQuote("@\(bodyURL.path)"))")
+        }
+
+        config.append("write-out = \(Self.curlConfigQuote(Self.curlHTTPStatusMarker + "%{http_code}"))")
+        try config.joined(separator: "\n").write(to: configURL, atomically: true, encoding: .utf8)
+        try fileManager.setAttributes([.posixPermissions: 0o600], ofItemAtPath: configURL.path)
+
+        let result = try await SubprocessRunner.run(
+            binary: "/usr/bin/curl",
+            arguments: ["--config", configURL.path],
+            environment: TTYCommandRunner.enrichedEnvironment(),
+            timeout: max(5, request.timeoutInterval + 2),
+            label: "gemini-api-curl")
+
+        return try Self.parseCurlDataLoaderResult(result.stdout, url: url)
+    }
+
+    private static let curlHTTPStatusMarker = "__CODEXBAR_HTTP_STATUS__:"
+
+    private static func curlConfigQuote(_ value: String) -> String {
+        let escaped = value
+            .replacingOccurrences(of: "\\", with: "\\\\")
+            .replacingOccurrences(of: "\"", with: "\\\"")
+        return "\"\(escaped)\""
+    }
+
+    private static func parseCurlDataLoaderResult(_ output: String, url: URL) throws -> (Data, URLResponse) {
+        guard let markerRange = output.range(of: curlHTTPStatusMarker, options: .backwards) else {
+            throw GeminiStatusProbeError.apiError("curl response missing HTTP status")
+        }
+
+        let body = String(output[..<markerRange.lowerBound])
+        let statusText = output[markerRange.upperBound...]
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+        guard let statusCode = Int(statusText), statusCode > 0,
+              let response = HTTPURLResponse(
+                  url: url,
+                  statusCode: statusCode,
+                  httpVersion: nil,
+                  headerFields: nil)
+        else {
+            throw GeminiStatusProbeError.apiError("curl response had invalid HTTP status")
+        }
+
+        return (Data(body.utf8), response)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Gemini/GeminiStatusProbe.swift b/Sources/CodexBarCore/Providers/Gemini/GeminiStatusProbe.swift
index 509cb03e21..9d19dd7895 100644
--- a/Sources/CodexBarCore/Providers/Gemini/GeminiStatusProbe.swift
+++ b/Sources/CodexBarCore/Providers/Gemini/GeminiStatusProbe.swift
@@ -2,6 +2,13 @@ import Foundation
 #if canImport(FoundationNetworking)
 import FoundationNetworking
 #endif
+#if canImport(Darwin)
+import Darwin
+#elseif canImport(Glibc)
+import Glibc
+#elseif canImport(Musl)
+import Musl
+#endif
 
 public struct GeminiModelQuota: Sendable {
     public let modelId: String
@@ -31,12 +38,15 @@ public struct GeminiStatusSnapshot: Sendable {
     }
 
     /// Converts Gemini quotas to a unified UsageSnapshot.
-    /// Groups quotas by tier: Pro (24h window) as primary, Flash (24h window) as secondary.
+    /// Groups quotas by tier: Pro (24h window) as primary, Flash (24h window) as secondary,
+    /// Flash Lite (24h window) as tertiary.
     public func toUsageSnapshot() -> UsageSnapshot {
         let lower = self.modelQuotas.map { ($0.modelId.lowercased(), $0) }
-        let flashQuotas = lower.filter { $0.0.contains("flash") }.map(\.1)
-        let proQuotas = lower.filter { $0.0.contains("pro") }.map(\.1)
+        let flashLiteQuotas = lower.filter { Self.isFlashLiteModel(id: $0.0) }.map(\.1)
+        let flashQuotas = lower.filter { Self.isFlashModel(id: $0.0) }.map(\.1)
+        let proQuotas = lower.filter { Self.isProModel(id: $0.0) }.map(\.1)
 
+        let flashLiteMin = flashLiteQuotas.min(by: { $0.percentLeft < $1.percentLeft })
         let flashMin = flashQuotas.min(by: { $0.percentLeft < $1.percentLeft })
         let proMin = proQuotas.min(by: { $0.percentLeft < $1.percentLeft })
 
@@ -53,6 +63,13 @@ public struct GeminiStatusSnapshot: Sendable {
                 resetsAt: $0.resetTime,
                 resetDescription: $0.resetDescription)
         }
+        let tertiary: RateWindow? = flashLiteMin.map {
+            RateWindow(
+                usedPercent: 100 - $0.percentLeft,
+                windowMinutes: 1440,
+                resetsAt: $0.resetTime,
+                resetDescription: $0.resetDescription)
+        }
 
         let identity = ProviderIdentitySnapshot(
             providerID: .gemini,
@@ -62,9 +79,22 @@ public struct GeminiStatusSnapshot: Sendable {
         return UsageSnapshot(
             primary: primary,
             secondary: secondary,
+            tertiary: tertiary,
             updatedAt: Date(),
             identity: identity)
     }
+
+    private static func isFlashLiteModel(id: String) -> Bool {
+        id.contains("flash-lite")
+    }
+
+    private static func isFlashModel(id: String) -> Bool {
+        id.contains("flash") && !self.isFlashLiteModel(id: id)
+    }
+
+    private static func isProModel(id: String) -> Bool {
+        id.contains("pro")
+    }
 }
 
 public enum GeminiStatusProbeError: LocalizedError, Sendable, Equatable {
@@ -95,7 +125,7 @@ public enum GeminiStatusProbeError: LocalizedError, Sendable, Equatable {
 
 public enum GeminiAuthType: String, Sendable {
     case oauthPersonal = "oauth-personal"
-    case apiKey = "api-key"
+    case apiKey = "gemini-api-key"
     case vertexAI = "vertex-ai"
     case unknown
 }
@@ -123,9 +153,7 @@ public struct GeminiStatusProbe: Sendable {
     public init(
         timeout: TimeInterval = 10.0,
         homeDirectory: String = NSHomeDirectory(),
-        dataLoader: @escaping @Sendable (URLRequest) async throws -> (Data, URLResponse) = { request in
-            try await URLSession.shared.data(for: request)
-        })
+        dataLoader: @escaping @Sendable (URLRequest) async throws -> (Data, URLResponse) = Self.defaultDataLoader)
     {
         self.timeout = timeout
         self.homeDirectory = homeDirectory
@@ -145,6 +173,9 @@ public struct GeminiStatusProbe: Sendable {
             return .unknown
         }
 
+        if selectedType == "api-key" {
+            return .apiKey
+        }
         return GeminiAuthType(rawValue: selectedType) ?? .unknown
     }
 
@@ -189,31 +220,36 @@ public struct GeminiStatusProbe: Sendable {
             "now": "\(Date())",
         ])
 
-        guard let storedAccessToken = creds.accessToken, !storedAccessToken.isEmpty else {
-            Self.log.error("No access token found")
-            throw GeminiStatusProbeError.notLoggedIn
-        }
-
-        var accessToken = storedAccessToken
-        if let expiry = creds.expiryDate, expiry < Date() {
-            Self.log.info("Token expired; attempting refresh", metadata: [
-                "expiry": "\(expiry)",
-            ])
+        var accessToken = creds.accessToken?.isEmpty == false ? creds.accessToken : nil
+        var idToken = creds.idToken
+        let needsRefresh = accessToken == nil || creds.expiryDate.map { $0 < Date() } == true
+        if needsRefresh {
+            if accessToken == nil {
+                Self.log.info("No access token found; attempting refresh from stored Gemini credentials")
+            } else if let expiry = creds.expiryDate {
+                Self.log.info("Token expired; attempting refresh", metadata: [
+                    "expiry": "\(expiry)",
+                ])
+            }
 
-            guard let refreshToken = creds.refreshToken else {
+            guard let refreshToken = creds.refreshToken, !refreshToken.isEmpty else {
                 Self.log.error("No refresh token available")
                 throw GeminiStatusProbeError.notLoggedIn
             }
-
             accessToken = try await Self.refreshAccessToken(
                 refreshToken: refreshToken,
                 timeout: timeout,
                 homeDirectory: homeDirectory,
                 dataLoader: dataLoader)
+            idToken = (try? Self.loadCredentials(homeDirectory: homeDirectory).idToken) ?? idToken
+        }
+        guard let accessToken else {
+            Self.log.error("No access token found")
+            throw GeminiStatusProbeError.notLoggedIn
         }
 
         // Extract account info from JWT
-        let claims = Self.extractClaimsFromToken(creds.idToken)
+        let claims = Self.extractClaimsFromToken(idToken)
 
         // Load Code Assist status to get project ID and tier (aligned with CLI setupUser logic)
         let caStatus = await Self.loadCodeAssistStatus(
@@ -337,7 +373,7 @@ public struct GeminiStatusProbe: Sendable {
         return nil
     }
 
-    private struct CodeAssistStatus: Sendable {
+    private struct CodeAssistStatus {
         let tier: GeminiUserTierId?
         let projectId: String?
 
@@ -452,20 +488,256 @@ public struct GeminiStatusProbe: Sendable {
         }
 
         // Resolve symlinks to find the actual installation
-        let fm = FileManager.default
-        var realPath = geminiPath
-        if let resolved = try? fm.destinationOfSymbolicLink(atPath: geminiPath) {
-            if resolved.hasPrefix("/") {
-                realPath = resolved
-            } else {
-                realPath = (geminiPath as NSString).deletingLastPathComponent + "/" + resolved
+        let resolvedGeminiPath = URL(fileURLWithPath: geminiPath).resolvingSymlinksInPath().path
+
+        // Try the legacy layouts first — they're cheap file reads and cover the common cases
+        // (Homebrew, npm/bun sibling, Nix) without spawning subprocesses or walking the tree.
+        if let credentials = Self.extractOAuthCredentialsFromLegacyPaths(realGeminiPath: resolvedGeminiPath) {
+            return credentials
+        }
+
+        // For fnm-managed installs, ask fnm where the package lives
+        if Self.isLikelyFnmManagedPath(geminiPath) || Self.isLikelyFnmManagedPath(resolvedGeminiPath),
+           let fnmPath = TTYCommandRunner.which("fnm"),
+           let packageRoot = Self.resolveGeminiPackageRootViaFnm(fnmPath: fnmPath, environment: env),
+           let credentials = Self.extractOAuthCredentials(fromGeminiPackageRoot: packageRoot)
+        {
+            return credentials
+        }
+
+        // Fall back to walking up the directory tree from the binary
+        if let packageRoot = Self.findGeminiPackageRoot(startingAt: resolvedGeminiPath),
+           let credentials = Self.extractOAuthCredentials(fromGeminiPackageRoot: packageRoot)
+        {
+            return credentials
+        }
+
+        return nil
+    }
+
+    private static func isLikelyFnmManagedPath(_ path: String) -> Bool {
+        let normalized = path.replacingOccurrences(of: "\\", with: "/")
+        return normalized.contains("/fnm_multishells/")
+            || (normalized.contains("/node-versions/") && normalized.contains("/fnm/"))
+    }
+
+    private static func resolveGeminiPackageRootViaFnm(
+        fnmPath: String,
+        environment: [String: String]) -> String?
+    {
+        guard let currentVersion = runProcess(
+            executable: fnmPath,
+            arguments: ["current"],
+            environment: environment,
+            timeout: 2.0),
+            !currentVersion.isEmpty
+        else {
+            return nil
+        }
+
+        // Prefer npm root -g because require.resolve searches from the current
+        // working directory and often fails for globally-installed packages.
+        if let npmRoot = runProcess(
+            executable: fnmPath,
+            arguments: [
+                "exec",
+                "--using",
+                currentVersion,
+                "npm",
+                "root",
+                "-g",
+            ],
+            environment: environment,
+            timeout: 4.0),
+            !npmRoot.isEmpty
+        {
+            let packageRoot = "\(npmRoot)/@google/gemini-cli"
+            let packageJSONPath = "\(packageRoot)/package.json"
+            if FileManager.default.fileExists(atPath: packageJSONPath) {
+                return packageRoot
             }
         }
 
-        // Navigate from bin/gemini to the oauth2.js file
-        // Homebrew path: .../libexec/lib/node_modules/@google/gemini-cli/node_modules/@google/gemini-cli-core/dist/src/code_assist/oauth2.js
-        // Bun/npm path: .../node_modules/@google/gemini-cli-core/dist/src/code_assist/oauth2.js (sibling package)
-        let binDir = (realPath as NSString).deletingLastPathComponent
+        // Fallback for non-npm global installations.
+        if let packageJSONPath = runProcess(
+            executable: fnmPath,
+            arguments: [
+                "exec",
+                "--using",
+                currentVersion,
+                "node",
+                "-p",
+                "require.resolve('@google/gemini-cli/package.json')",
+            ],
+            environment: environment,
+            timeout: 4.0),
+            !packageJSONPath.isEmpty
+        {
+            return (packageJSONPath as NSString).deletingLastPathComponent
+        }
+
+        return nil
+    }
+
+    private static func findGeminiPackageRoot(startingAt path: String) -> String? {
+        let fileManager = FileManager.default
+        var currentURL = URL(fileURLWithPath: path).standardizedFileURL
+
+        var isDirectory: ObjCBool = false
+        if !fileManager.fileExists(atPath: currentURL.path, isDirectory: &isDirectory) || !isDirectory.boolValue {
+            currentURL.deleteLastPathComponent()
+        }
+
+        // Bound the walk so an unrelated Gemini install elsewhere on the host
+        // (e.g. a global npm/brew install unrelated to the resolved binary) can't
+        // contaminate discovery started from the actual binary path.
+        let maxAscents = 8
+        for _ in 0...maxAscents {
+            let packageJSONURL = currentURL.appendingPathComponent("package.json")
+            if let data = try? Data(contentsOf: packageJSONURL),
+               let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+               json["name"] as? String == "@google/gemini-cli"
+            {
+                return currentURL.path
+            }
+
+            // Also check for a global Node installation layout:
+            // <current>/lib/node_modules/@google/gemini-cli/package.json
+            let globalPackageJSONURL = currentURL
+                .appendingPathComponent("lib")
+                .appendingPathComponent("node_modules")
+                .appendingPathComponent("@google")
+                .appendingPathComponent("gemini-cli")
+                .appendingPathComponent("package.json")
+            if let data = try? Data(contentsOf: globalPackageJSONURL),
+               let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+               json["name"] as? String == "@google/gemini-cli"
+            {
+                return globalPackageJSONURL.deletingLastPathComponent().path
+            }
+
+            // Homebrew layout:
+            // <cellar-version>/libexec/lib/node_modules/@google/gemini-cli/package.json
+            let homebrewPackageJSONURL = currentURL
+                .appendingPathComponent("libexec")
+                .appendingPathComponent("lib")
+                .appendingPathComponent("node_modules")
+                .appendingPathComponent("@google")
+                .appendingPathComponent("gemini-cli")
+                .appendingPathComponent("package.json")
+            if let data = try? Data(contentsOf: homebrewPackageJSONURL),
+               let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+               json["name"] as? String == "@google/gemini-cli"
+            {
+                return homebrewPackageJSONURL.deletingLastPathComponent().path
+            }
+
+            let parentURL = currentURL.deletingLastPathComponent()
+            if parentURL.path == currentURL.path {
+                return nil
+            }
+            currentURL = parentURL
+        }
+
+        return nil
+    }
+
+    private static func extractOAuthCredentials(fromGeminiPackageRoot packageRoot: String) -> OAuthClientCredentials? {
+        // Check the standard distributed file first, then any sibling core package
+        let oauthFile = "dist/src/code_assist/oauth2.js"
+        let candidatePaths = [
+            "\(packageRoot)/\(oauthFile)",
+            "\(packageRoot)/node_modules/@google/gemini-cli-core/\(oauthFile)",
+        ]
+
+        for path in candidatePaths {
+            if let content = try? String(contentsOfFile: path, encoding: .utf8),
+               let credentials = Self.parseOAuthCredentials(from: content)
+            {
+                return credentials
+            }
+        }
+
+        return Self.extractOAuthCredentialsFromBundle(packageRoot: packageRoot)
+    }
+
+    private static func extractOAuthCredentialsFromBundle(packageRoot: String) -> OAuthClientCredentials? {
+        let bundleRoot = URL(fileURLWithPath: packageRoot).appendingPathComponent("bundle", isDirectory: true)
+        let entryURL = bundleRoot.appendingPathComponent("gemini.js")
+
+        guard FileManager.default.fileExists(atPath: entryURL.path) else {
+            return nil
+        }
+
+        var pendingURLs = [entryURL]
+        var visitedPaths = Set<String>()
+
+        while !pendingURLs.isEmpty {
+            let currentURL = pendingURLs.removeFirst()
+            let standardizedPath = currentURL.standardizedFileURL.path
+            guard visitedPaths.insert(standardizedPath).inserted,
+                  let content = try? String(contentsOf: currentURL, encoding: .utf8)
+            else {
+                continue
+            }
+
+            if let credentials = Self.parseOAuthCredentials(from: content) {
+                return credentials
+            }
+
+            let imports = Self.extractRelativeJavaScriptImports(from: content)
+            for importPath in imports {
+                let nextURL = URL(fileURLWithPath: importPath, relativeTo: currentURL.deletingLastPathComponent())
+                    .standardizedFileURL
+                guard nextURL.path.hasPrefix(bundleRoot.path) else { continue }
+                pendingURLs.append(nextURL)
+            }
+        }
+
+        guard let bundleFiles = try? FileManager.default.contentsOfDirectory(
+            at: bundleRoot,
+            includingPropertiesForKeys: nil,
+            options: [.skipsHiddenFiles])
+        else {
+            return nil
+        }
+
+        for url in bundleFiles where url.pathExtension == "js" && !visitedPaths.contains(url.standardizedFileURL.path) {
+            guard let content = try? String(contentsOf: url, encoding: .utf8) else { continue }
+            if let credentials = Self.parseOAuthCredentials(from: content) {
+                return credentials
+            }
+        }
+
+        return nil
+    }
+
+    private static func extractRelativeJavaScriptImports(from content: String) -> [String] {
+        let patterns = [
+            #"(?:import|export)\s+(?:[^;]*?\s+from\s+)?[\"'](\./[^\"']+\.js)[\"']"#,
+            #"import\(\s*[\"'](\./[^\"']+\.js)[\"']\s*\)"#,
+        ]
+
+        var discoveredPaths: [String] = []
+        var seen = Set<String>()
+        let fullRange = NSRange(content.startIndex..., in: content)
+
+        for pattern in patterns {
+            guard let regex = try? NSRegularExpression(pattern: pattern) else { continue }
+            for match in regex.matches(in: content, range: fullRange) {
+                guard let range = Range(match.range(at: 1), in: content) else { continue }
+                let path = String(content[range])
+                if seen.insert(path).inserted {
+                    discoveredPaths.append(path)
+                }
+            }
+        }
+
+        return discoveredPaths
+    }
+
+    private static func extractOAuthCredentialsFromLegacyPaths(realGeminiPath: String) -> OAuthClientCredentials? {
+        let binDir = (realGeminiPath as NSString).deletingLastPathComponent
         let baseDir = (binDir as NSString).deletingLastPathComponent
 
         let oauthSubpath =
@@ -486,8 +758,10 @@ public struct GeminiStatusProbe: Sendable {
         ]
 
         for path in possiblePaths {
-            if let content = try? String(contentsOfFile: path, encoding: .utf8) {
-                return self.parseOAuthCredentials(from: content)
+            if let content = try? String(contentsOfFile: path, encoding: .utf8),
+               let credentials = Self.parseOAuthCredentials(from: content)
+            {
+                return credentials
             }
         }
 
@@ -495,9 +769,9 @@ public struct GeminiStatusProbe: Sendable {
     }
 
     private static func parseOAuthCredentials(from content: String) -> OAuthClientCredentials? {
-        // Match: const OAUTH_CLIENT_ID = '...';
-        let clientIdPattern = #"OAUTH_CLIENT_ID\s*=\s*['"]([\w\-\.]+)['"]\s*;"#
-        let secretPattern = #"OAUTH_CLIENT_SECRET\s*=\s*['"]([\w\-]+)['"]\s*;"#
+        // Match: const/let/var OAUTH_CLIENT_ID = '...';
+        let clientIdPattern = #"(?:const|let|var)?\s*OAUTH_CLIENT_ID\s*=\s*['"]([\w\-\.]+)['"]\s*;"#
+        let secretPattern = #"(?:const|let|var)?\s*OAUTH_CLIENT_SECRET\s*=\s*['"]([\w\-]+)['"]\s*;"#
 
         guard let clientIdRegex = try? NSRegularExpression(pattern: clientIdPattern),
               let secretRegex = try? NSRegularExpression(pattern: secretPattern)
@@ -812,3 +1086,69 @@ public struct GeminiStatusProbe: Sendable {
         return quotas
     }
 }
+
+extension GeminiStatusProbe {
+    package static func runProcess(
+        executable: String,
+        arguments: [String],
+        environment: [String: String],
+        timeout: TimeInterval) -> String?
+    {
+        let process = Process()
+        process.executableURL = URL(fileURLWithPath: executable)
+        process.arguments = arguments
+
+        var mergedEnvironment = environment
+        mergedEnvironment["PATH"] = PathBuilder.effectivePATH(
+            purposes: [.tty, .nodeTooling],
+            env: environment,
+            loginPATH: LoginShellPathCache.shared.current)
+        process.environment = mergedEnvironment
+
+        let stdout = Pipe()
+        let stderr = Pipe()
+        process.standardOutput = stdout
+        process.standardError = stderr
+        process.standardInput = nil
+
+        let stdoutCapture = ProcessPipeCapture(pipe: stdout)
+        let stderrCapture = ProcessPipeCapture(pipe: stderr)
+
+        let exitSemaphore = DispatchSemaphore(value: 0)
+        process.terminationHandler = { _ in
+            exitSemaphore.signal()
+        }
+
+        do {
+            try process.run()
+        } catch {
+            process.terminationHandler = nil
+            stdoutCapture.stop()
+            stderrCapture.stop()
+            return nil
+        }
+        stdoutCapture.start()
+        stderrCapture.start()
+        let pid = process.processIdentifier
+        let processGroup: pid_t? = setpgid(pid, pid) == 0 ? pid : nil
+
+        let didExit = exitSemaphore.wait(timeout: .now() + timeout) == .success
+        if !didExit {
+            SubprocessRunner.terminateProcess(process, processGroup: processGroup)
+            stdoutCapture.stop()
+            stderrCapture.stop()
+            return nil
+        }
+
+        let data = stdoutCapture.finishSynchronously(timeout: 1)
+        stderrCapture.stop()
+        let output = ProcessPipeCapture.decodeUTF8(data)
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+        guard process.terminationStatus == 0, !output.isEmpty else {
+            return nil
+        }
+
+        return output.components(separatedBy: .newlines).first?
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Grok/GrokAuth.swift b/Sources/CodexBarCore/Providers/Grok/GrokAuth.swift
new file mode 100644
index 0000000000..9544808d1f
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Grok/GrokAuth.swift
@@ -0,0 +1,188 @@
+import Foundation
+
+public struct GrokCredentials: Sendable {
+    public let accessToken: String
+    public let refreshToken: String?
+    public let scope: String
+    public let authMode: String?
+    public let userId: String?
+    public let email: String?
+    public let firstName: String?
+    public let lastName: String?
+    public let teamId: String?
+    public let oidcIssuer: String?
+    public let oidcClientId: String?
+    public let expiresAt: Date?
+    public let createTime: Date?
+
+    public init(
+        accessToken: String,
+        refreshToken: String?,
+        scope: String,
+        authMode: String?,
+        userId: String?,
+        email: String?,
+        firstName: String?,
+        lastName: String?,
+        teamId: String?,
+        oidcIssuer: String?,
+        oidcClientId: String?,
+        expiresAt: Date?,
+        createTime: Date?)
+    {
+        self.accessToken = accessToken
+        self.refreshToken = refreshToken
+        self.scope = scope
+        self.authMode = authMode
+        self.userId = userId
+        self.email = email
+        self.firstName = firstName
+        self.lastName = lastName
+        self.teamId = teamId
+        self.oidcIssuer = oidcIssuer
+        self.oidcClientId = oidcClientId
+        self.expiresAt = expiresAt
+        self.createTime = createTime
+    }
+
+    public var displayName: String? {
+        let parts = [self.firstName, self.lastName].compactMap { $0?.nilIfEmpty }
+        guard !parts.isEmpty else { return nil }
+        return parts.joined(separator: " ")
+    }
+
+    public var isExpired: Bool {
+        guard let expiresAt else { return false }
+        return Date() >= expiresAt
+    }
+
+    public var loginMethod: String? {
+        switch self.authMode?.lowercased() {
+        case "oidc": "SuperGrok"
+        case "session": "session"
+        case nil: nil
+        default: self.authMode
+        }
+    }
+}
+
+public enum GrokCredentialsError: LocalizedError, Sendable {
+    case notFound
+    case decodeFailed(String)
+    case missingTokens
+
+    public var errorDescription: String? {
+        switch self {
+        case .notFound:
+            "Grok auth.json not found. Run `grok login` to authenticate."
+        case let .decodeFailed(message):
+            "Failed to decode Grok credentials: \(message)"
+        case .missingTokens:
+            "Grok auth.json exists but contains no access tokens."
+        }
+    }
+}
+
+public enum GrokCredentialsStore {
+    /// Top-level OIDC scope used by `grok login` for SuperGrok subscribers.
+    public static let oidcScopePrefix = "https://auth.x.ai::"
+    /// Legacy/session scope used by older `grok login` flows.
+    public static let legacySessionScope = "https://accounts.x.ai/sign-in"
+
+    public static func grokHomeURL(
+        env: [String: String] = ProcessInfo.processInfo.environment,
+        fileManager: FileManager = .default) -> URL
+    {
+        if let custom = env["GROK_HOME"]?.nilIfEmpty {
+            return URL(fileURLWithPath: (custom as NSString).expandingTildeInPath)
+        }
+        let home = fileManager.homeDirectoryForCurrentUser
+        return home.appendingPathComponent(".grok", isDirectory: true)
+    }
+
+    public static func authFileURL(
+        env: [String: String] = ProcessInfo.processInfo.environment,
+        fileManager: FileManager = .default) -> URL
+    {
+        self.grokHomeURL(env: env, fileManager: fileManager).appendingPathComponent("auth.json")
+    }
+
+    public static func load(env: [String: String] = ProcessInfo.processInfo.environment) throws -> GrokCredentials {
+        let url = self.authFileURL(env: env)
+        guard FileManager.default.fileExists(atPath: url.path) else {
+            throw GrokCredentialsError.notFound
+        }
+        let data = try Data(contentsOf: url)
+        return try self.parse(data: data)
+    }
+
+    public static func parse(data: Data) throws -> GrokCredentials {
+        let raw: Any
+        do {
+            raw = try JSONSerialization.jsonObject(with: data)
+        } catch {
+            throw GrokCredentialsError.decodeFailed(error.localizedDescription)
+        }
+        guard let root = raw as? [String: Any] else {
+            throw GrokCredentialsError.decodeFailed("Invalid JSON (expected object at root)")
+        }
+
+        // `auth.json` is a map keyed by scope URL. Prefer the OIDC scope (SuperGrok),
+        // fall back to the legacy session scope.
+        let preferredEntry = Self.selectPreferredEntry(in: root)
+        guard let (scope, entry) = preferredEntry else {
+            throw GrokCredentialsError.missingTokens
+        }
+        guard let key = entry["key"] as? String, !key.isEmpty else {
+            throw GrokCredentialsError.missingTokens
+        }
+
+        return GrokCredentials(
+            accessToken: key,
+            refreshToken: (entry["refresh_token"] as? String)?.nilIfEmpty,
+            scope: scope,
+            authMode: (entry["auth_mode"] as? String)?.nilIfEmpty,
+            userId: (entry["user_id"] as? String)?.nilIfEmpty,
+            email: (entry["email"] as? String)?.nilIfEmpty,
+            firstName: (entry["first_name"] as? String)?.nilIfEmpty,
+            lastName: (entry["last_name"] as? String)?.nilIfEmpty,
+            teamId: (entry["team_id"] as? String)?.nilIfEmpty,
+            oidcIssuer: (entry["oidc_issuer"] as? String)?.nilIfEmpty,
+            oidcClientId: (entry["oidc_client_id"] as? String)?.nilIfEmpty,
+            expiresAt: Self.parseDate(entry["expires_at"]),
+            createTime: Self.parseDate(entry["create_time"]))
+    }
+
+    private static func selectPreferredEntry(in root: [String: Any]) -> (scope: String, entry: [String: Any])? {
+        var oidcCandidate: (String, [String: Any])?
+        var legacyCandidate: (String, [String: Any])?
+        for (scope, value) in root {
+            guard let entry = value as? [String: Any] else { continue }
+            // Only accept entries that actually carry a usable bearer token. A
+            // stale/partial OIDC record (key missing or empty) must not shadow a
+            // healthy legacy session entry.
+            guard let key = entry["key"] as? String, !key.isEmpty else { continue }
+            if scope.hasPrefix(self.oidcScopePrefix) {
+                oidcCandidate = (scope, entry)
+            } else if scope == self.legacySessionScope || scope.contains("/sign-in") {
+                legacyCandidate = (scope, entry)
+            }
+        }
+        return oidcCandidate ?? legacyCandidate
+    }
+
+    private static func parseDate(_ raw: Any?) -> Date? {
+        guard let value = raw as? String, !value.isEmpty else { return nil }
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        if let date = formatter.date(from: value) { return date }
+        formatter.formatOptions = [.withInternetDateTime]
+        return formatter.date(from: value)
+    }
+}
+
+extension String {
+    fileprivate var nilIfEmpty: String? {
+        self.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty ? nil : self
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Grok/GrokCookieImporter.swift b/Sources/CodexBarCore/Providers/Grok/GrokCookieImporter.swift
new file mode 100644
index 0000000000..2efd4ee21a
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Grok/GrokCookieImporter.swift
@@ -0,0 +1,213 @@
+import Foundation
+
+#if os(macOS)
+import SweetCookieKit
+
+public enum GrokCookieImporter {
+    private static let importSessionCacheTTL: TimeInterval = 5
+    private static let importSessionCache = ImportSessionCache(ttl: importSessionCacheTTL)
+    private static let log = CodexBarLog.logger(LogCategories.providers)
+    private static let cookieClient = BrowserCookieClient()
+    private static let cookieDomains = ["grok.com"]
+    private static let cookieImportOrder: BrowserCookieImportOrder =
+        ProviderDefaults.metadata[.grok]?.browserCookieOrder ?? Browser.defaultImportOrder
+
+    public struct SessionInfo: Sendable {
+        public let cookies: [HTTPCookie]
+        public let sourceLabel: String
+
+        public init(cookies: [HTTPCookie], sourceLabel: String) {
+            self.cookies = cookies
+            self.sourceLabel = sourceLabel
+        }
+
+        public var cookieHeader: String {
+            self.cookies.map { "\($0.name)=\($0.value)" }.joined(separator: "; ")
+        }
+    }
+
+    public static func importSessions(
+        browserDetection: BrowserDetection = BrowserDetection(),
+        logger: ((String) -> Void)? = nil) throws -> [SessionInfo]
+    {
+        if let cached = self.cachedImportSessions() {
+            return cached
+        }
+
+        var sessions: [SessionInfo] = []
+        let candidates = self.cookieImportOrder.cookieImportCandidates(using: browserDetection)
+        for browserSource in candidates {
+            do {
+                let perSource = try self.importSessions(from: browserSource, logger: logger)
+                sessions.append(contentsOf: perSource)
+            } catch {
+                BrowserCookieAccessGate.recordIfNeeded(error)
+                self.emit(
+                    "\(browserSource.displayName) cookie import failed: \(error.localizedDescription)",
+                    logger: logger)
+            }
+        }
+
+        guard !sessions.isEmpty else { throw GrokWebBillingError.missingCredentials }
+        self.storeImportSessions(sessions)
+        return sessions
+    }
+
+    public static func importSessions(
+        from browserSource: Browser,
+        logger: ((String) -> Void)? = nil) throws -> [SessionInfo]
+    {
+        let query = BrowserCookieQuery(domains: self.cookieDomains)
+        let log: (String) -> Void = { msg in self.emit(msg, logger: logger) }
+        let sources = try Self.cookieClient.codexBarRecords(
+            matching: query,
+            in: browserSource,
+            logger: log)
+
+        var sessions: [SessionInfo] = []
+        let grouped = Dictionary(grouping: sources, by: { $0.store.profile.id })
+        let sortedGroups = grouped.values.sorted { lhs, rhs in
+            self.mergedLabel(for: lhs) < self.mergedLabel(for: rhs)
+        }
+
+        for group in sortedGroups where !group.isEmpty {
+            let label = self.mergedLabel(for: group)
+            let mergedRecords = self.mergeRecords(group)
+            guard mergedRecords.contains(where: { $0.name == "sso" || $0.name == "sso-rw" }) else { continue }
+            let httpCookies = BrowserCookieClient.makeHTTPCookies(mergedRecords, origin: query.origin)
+            guard !httpCookies.isEmpty else { continue }
+            log("Found Grok session cookies in \(label)")
+            sessions.append(SessionInfo(cookies: httpCookies, sourceLabel: label))
+        }
+        return sessions
+    }
+
+    public static func importSession(
+        browserDetection: BrowserDetection = BrowserDetection(),
+        logger: ((String) -> Void)? = nil) throws -> SessionInfo
+    {
+        let sessions = try self.importSessions(browserDetection: browserDetection, logger: logger)
+        guard let first = sessions.first else { throw GrokWebBillingError.missingCredentials }
+        return first
+    }
+
+    public static func hasSession(
+        browserDetection: BrowserDetection = BrowserDetection(),
+        logger: ((String) -> Void)? = nil) -> Bool
+    {
+        do {
+            _ = try self.importSession(browserDetection: browserDetection, logger: logger)
+            return true
+        } catch {
+            return false
+        }
+    }
+
+    static func invalidateImportSessionCache() {
+        self.importSessionCache.invalidate()
+    }
+
+    private static func emit(_ message: String, logger: ((String) -> Void)?) {
+        logger?("[grok-cookie] \(message)")
+        self.log.debug("\(message)")
+    }
+
+    private static func cachedImportSessions(now: Date = Date()) -> [SessionInfo]? {
+        self.importSessionCache.load(now: now)
+    }
+
+    private static func storeImportSessions(_ sessions: [SessionInfo], now: Date = Date()) {
+        self.importSessionCache.store(sessions, now: now)
+    }
+
+    private static func mergedLabel(for sources: [BrowserCookieStoreRecords]) -> String {
+        guard let base = sources.map(\.label).min() else { return "Unknown" }
+        if base.hasSuffix(" (Network)") {
+            return String(base.dropLast(" (Network)".count))
+        }
+        return base
+    }
+
+    private static func mergeRecords(_ sources: [BrowserCookieStoreRecords]) -> [BrowserCookieRecord] {
+        let sortedSources = sources.sorted { lhs, rhs in
+            self.storePriority(lhs.store.kind) < self.storePriority(rhs.store.kind)
+        }
+        var mergedByKey: [String: BrowserCookieRecord] = [:]
+        for source in sortedSources {
+            for record in source.records {
+                let key = self.recordKey(record)
+                if let existing = mergedByKey[key] {
+                    if self.shouldReplace(existing: existing, candidate: record) {
+                        mergedByKey[key] = record
+                    }
+                } else {
+                    mergedByKey[key] = record
+                }
+            }
+        }
+        return Array(mergedByKey.values)
+    }
+
+    private static func storePriority(_ kind: BrowserCookieStoreKind) -> Int {
+        switch kind {
+        case .network: 0
+        case .primary: 1
+        case .safari: 2
+        }
+    }
+
+    private static func recordKey(_ record: BrowserCookieRecord) -> String {
+        "\(record.name)|\(record.domain)|\(record.path)"
+    }
+
+    private static func shouldReplace(existing: BrowserCookieRecord, candidate: BrowserCookieRecord) -> Bool {
+        switch (existing.expires, candidate.expires) {
+        case let (lhs?, rhs?): rhs > lhs
+        case (nil, .some): true
+        case (.some, nil): false
+        case (nil, nil): false
+        }
+    }
+
+    private final class ImportSessionCache: @unchecked Sendable {
+        private let ttl: TimeInterval
+        private let lock = NSLock()
+        private var entry: (sessions: [SessionInfo], expiresAt: Date)?
+
+        init(ttl: TimeInterval) {
+            self.ttl = ttl
+        }
+
+        func load(now: Date) -> [SessionInfo]? {
+            self.lock.lock()
+            defer { self.lock.unlock() }
+            guard let entry = self.entry, entry.expiresAt > now else {
+                self.entry = nil
+                return nil
+            }
+            return entry.sessions
+        }
+
+        func store(_ sessions: [SessionInfo], now: Date) {
+            self.lock.lock()
+            self.entry = (sessions, now.addingTimeInterval(self.ttl))
+            self.lock.unlock()
+        }
+
+        func invalidate() {
+            self.lock.lock()
+            self.entry = nil
+            self.lock.unlock()
+        }
+    }
+}
+#else
+public enum GrokCookieImporter {
+    public static func hasSession(
+        browserDetection _: BrowserDetection = BrowserDetection(),
+        logger _: ((String) -> Void)? = nil) -> Bool
+    {
+        false
+    }
+}
+#endif
diff --git a/Sources/CodexBarCore/Providers/Grok/GrokLocalSessionScanner.swift b/Sources/CodexBarCore/Providers/Grok/GrokLocalSessionScanner.swift
new file mode 100644
index 0000000000..c5b1afded7
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Grok/GrokLocalSessionScanner.swift
@@ -0,0 +1,100 @@
+import Foundation
+
+/// Aggregated stats from local `~/.grok/sessions/**/signals.json` files.
+/// Used as a local fallback view when the JSON-RPC billing call is unavailable.
+public struct GrokLocalSessionSummary: Sendable {
+    public let sessionCount: Int
+    public let totalTokens: Int
+    public let lastSessionAt: Date?
+    public let primaryModel: String?
+    public let models: [String]
+
+    public init(
+        sessionCount: Int,
+        totalTokens: Int,
+        lastSessionAt: Date?,
+        primaryModel: String?,
+        models: [String])
+    {
+        self.sessionCount = sessionCount
+        self.totalTokens = totalTokens
+        self.lastSessionAt = lastSessionAt
+        self.primaryModel = primaryModel
+        self.models = models
+    }
+}
+
+public enum GrokLocalSessionScanner {
+    public static let defaultLookbackDays = 30
+
+    /// Walk `~/.grok/sessions/<encoded_cwd>/<session_id>/signals.json` and aggregate stats.
+    public static func summarize(
+        env: [String: String] = ProcessInfo.processInfo.environment,
+        fileManager: FileManager = .default,
+        lookbackDays: Int = defaultLookbackDays,
+        now: Date = .init()) -> GrokLocalSessionSummary
+    {
+        let root = GrokCredentialsStore.grokHomeURL(env: env, fileManager: fileManager)
+            .appendingPathComponent("sessions", isDirectory: true)
+        guard let rootEnum = fileManager.enumerator(
+            at: root,
+            includingPropertiesForKeys: [.contentModificationDateKey, .isDirectoryKey],
+            options: [.skipsHiddenFiles])
+        else {
+            return GrokLocalSessionSummary(
+                sessionCount: 0,
+                totalTokens: 0,
+                lastSessionAt: nil,
+                primaryModel: nil,
+                models: [])
+        }
+
+        let lookbackCutoff = Calendar.current.date(byAdding: .day, value: -lookbackDays, to: now) ?? now
+        var sessionCount = 0
+        var totalTokens = 0
+        var lastSessionAt: Date?
+        var modelCounts: [String: Int] = [:]
+
+        while let url = rootEnum.nextObject() as? URL {
+            guard url.lastPathComponent == "signals.json" else { continue }
+            let attrs = try? url.resourceValues(forKeys: [.contentModificationDateKey])
+            let mtime = attrs?.contentModificationDate ?? Date.distantPast
+            guard mtime >= lookbackCutoff else { continue }
+
+            guard let data = try? Data(contentsOf: url),
+                  let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+            else { continue }
+
+            sessionCount += 1
+            let beforeCompaction = (json["totalTokensBeforeCompaction"] as? Int) ?? 0
+            let contextUsed = (json["contextTokensUsed"] as? Int) ?? 0
+            totalTokens += beforeCompaction + contextUsed
+
+            if mtime > (lastSessionAt ?? Date.distantPast) {
+                lastSessionAt = mtime
+            }
+
+            if let primary = (json["primaryModelId"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines),
+               !primary.isEmpty
+            {
+                modelCounts[primary, default: 0] += 1
+            }
+            if let models = json["modelsUsed"] as? [String] {
+                for model in models {
+                    let trimmed = model.trimmingCharacters(in: .whitespacesAndNewlines)
+                    if !trimmed.isEmpty {
+                        modelCounts[trimmed, default: 0] += 1
+                    }
+                }
+            }
+        }
+
+        let sortedModels = modelCounts.sorted { $0.value > $1.value }.map(\.key)
+        return GrokLocalSessionSummary(
+            sessionCount: sessionCount,
+            totalTokens: totalTokens,
+            lastSessionAt: lastSessionAt,
+            primaryModel: sortedModels.first,
+            models: sortedModels)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Grok/GrokProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Grok/GrokProviderDescriptor.swift
new file mode 100644
index 0000000000..6aaf76f6a1
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Grok/GrokProviderDescriptor.swift
@@ -0,0 +1,223 @@
+import Foundation
+
+public enum GrokProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .grok,
+            metadata: ProviderMetadata(
+                id: .grok,
+                displayName: "Grok",
+                sessionLabel: "Credits",
+                weeklyLabel: "On-demand",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "",
+                toggleTitle: "Show Grok usage",
+                cliName: "grok",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                browserCookieOrder: ProviderBrowserCookieDefaults.grokCookieImportOrder,
+                dashboardURL: "https://grok.com/?_s=usage",
+                changelogURL: "https://x.ai/news",
+                statusPageURL: nil,
+                statusLinkURL: "https://status.x.ai"),
+            branding: ProviderBranding(
+                iconStyle: .grok,
+                iconResourceName: "ProviderIcon-grok",
+                color: ProviderColor(red: 16 / 255, green: 163 / 255, blue: 127 / 255)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "Grok cost summary is not supported yet." }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .cli, .web],
+                pipeline: ProviderFetchPipeline(resolveStrategies: self.resolveStrategies)),
+            cli: ProviderCLIConfig(
+                name: "grok",
+                versionDetector: { _ in GrokStatusProbe.detectVersion() }))
+    }
+
+    private static func resolveStrategies(context: ProviderFetchContext) async -> [any ProviderFetchStrategy] {
+        switch context.sourceMode {
+        case .auto:
+            [GrokCLIFetchStrategy(), GrokWebFetchStrategy()]
+        case .cli:
+            [GrokCLIFetchStrategy()]
+        case .web:
+            [GrokWebFetchStrategy()]
+        case .api, .oauth:
+            []
+        }
+    }
+
+    /// Returns a contextual label for Grok's primary usage bar ("Weekly" or "Monthly").
+    /// Prefer the billing period duration when available; fall back to reset distance for
+    /// web billing payloads that expose only a reset timestamp.
+    public static func primaryLabel(window: RateWindow?, now: Date = .now) -> String? {
+        if let minutes = window?.windowMinutes {
+            return self.primaryLabel(duration: TimeInterval(minutes) * 60)
+        }
+        return self.primaryLabel(resetsAt: window?.resetsAt, now: now)
+    }
+
+    public static func primaryLabel(resetsAt: Date?, now: Date = .now) -> String? {
+        guard let resetsAt else { return nil }
+        return self.primaryLabel(duration: resetsAt.timeIntervalSince(now))
+    }
+
+    private static func primaryLabel(duration seconds: TimeInterval) -> String? {
+        guard seconds > 3600 else { return nil }
+        let days = Int((seconds / 86400).rounded(.toNearestOrAwayFromZero))
+        if (4...12).contains(days) { return "Weekly" }
+        if (20...45).contains(days) { return "Monthly" }
+        return nil
+    }
+}
+
+struct GrokCLIFetchStrategy: ProviderFetchStrategy {
+    let id: String = "grok.cli"
+    let kind: ProviderFetchKind = .cli
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        BinaryLocator.resolveGrokBinary(env: context.env) != nil
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        let probe = GrokStatusProbe()
+        let snap = try await probe.fetch(env: context.env)
+        return self.makeResult(
+            usage: snap.toUsageSnapshot(),
+            sourceLabel: "grok-cli")
+    }
+
+    func shouldFallback(on _: Error, context: ProviderFetchContext) -> Bool {
+        context.sourceMode == .auto
+    }
+}
+
+struct GrokWebFetchStrategy: ProviderFetchStrategy {
+    let id: String = "grok.web"
+    let kind: ProviderFetchKind = .web
+
+    static func canImportBrowserCookies(runtime: ProviderRuntime, env: [String: String]) -> Bool {
+        runtime == .app || env["CODEXBAR_ALLOW_BROWSER_COOKIE_IMPORT"] == "1"
+    }
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        #if os(macOS)
+        if Self.canImportBrowserCookies(runtime: context.runtime, env: context.env),
+           GrokCookieImporter.hasSession(browserDetection: context.browserDetection)
+        {
+            return true
+        }
+        #endif
+        return FileManager.default.fileExists(atPath: GrokCredentialsStore.authFileURL(env: context.env).path)
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        let (webBilling, sourceLabel, authenticatedByAuthFile) = try await self.fetchWebBilling(context: context)
+        let credentials = Self.credentialsForWebBillingSnapshot(
+            credentials: try? GrokCredentialsStore.load(env: context.env),
+            authenticatedByAuthFile: authenticatedByAuthFile)
+        let snapshot = GrokUsageSnapshot(
+            billing: nil,
+            webBilling: webBilling,
+            credentials: GrokStatusProbe.credentialsForSnapshot(
+                credentials: credentials,
+                billing: nil,
+                webBilling: webBilling),
+            localSummary: GrokLocalSessionScanner.summarize(env: context.env),
+            cliVersion: GrokStatusProbe.detectVersion(env: context.env),
+            updatedAt: Date())
+        return self.makeResult(
+            usage: snapshot.toUsageSnapshot(),
+            sourceLabel: sourceLabel)
+    }
+
+    private func fetchWebBilling(context: ProviderFetchContext) async throws -> (
+        snapshot: GrokWebBillingSnapshot,
+        sourceLabel: String,
+        authenticatedByAuthFile: Bool)
+    {
+        let credentialsResult: Result<GrokCredentials, Error> = Result {
+            try GrokCredentialsStore.load(env: context.env)
+        }
+        let browserCredentials = try? credentialsResult.get()
+
+        #if os(macOS)
+        if Self.canImportBrowserCookies(runtime: context.runtime, env: context.env) {
+            var lastCookieError: Error?
+            do {
+                let sessions = try GrokCookieImporter.importSessions(browserDetection: context.browserDetection)
+                let (snapshot, sourceLabel) = try await Self.fetchFirstValidCookieSession(
+                    sessions,
+                    credentials: browserCredentials)
+                return (snapshot, sourceLabel, false)
+            } catch {
+                lastCookieError = error
+            }
+            if browserCredentials == nil {
+                if FileManager.default.fileExists(
+                    atPath: GrokCredentialsStore.authFileURL(env: context.env).path)
+                {
+                    _ = try credentialsResult.get()
+                }
+                throw lastCookieError ?? GrokWebBillingError.missingCredentials
+            }
+        }
+        #endif
+
+        let authCredentials = try credentialsResult.get()
+        guard !authCredentials.isExpired else {
+            throw GrokWebBillingError.missingCredentials
+        }
+        let snapshot = try await GrokWebBillingFetcher.fetch(credentials: authCredentials)
+        return (snapshot, "grok-web", true)
+    }
+
+    static func credentialsForWebBillingSnapshot(
+        credentials: GrokCredentials?,
+        authenticatedByAuthFile: Bool) -> GrokCredentials?
+    {
+        authenticatedByAuthFile ? credentials : nil
+    }
+
+    #if os(macOS)
+    static func fetchFirstValidCookieSession(
+        _ sessions: [GrokCookieImporter.SessionInfo],
+        credentials: GrokCredentials? = nil,
+        fetch: ((String, GrokCredentials?) async throws -> GrokWebBillingSnapshot)? = nil) async throws
+        -> (GrokWebBillingSnapshot, String)
+    {
+        let fetchSnapshot = fetch ?? { cookieHeader, credentials in
+            try await GrokWebBillingFetcher.fetch(
+                cookieHeader: cookieHeader,
+                credentials: credentials)
+        }
+        var lastError: Error?
+        for session in sessions {
+            for authCredentials in Self.cookieAuthAttempts(credentials: credentials) {
+                do {
+                    let snapshot = try await fetchSnapshot(session.cookieHeader, authCredentials)
+                    return (snapshot, session.sourceLabel)
+                } catch {
+                    lastError = error
+                }
+            }
+        }
+        throw lastError ?? GrokWebBillingError.missingCredentials
+    }
+
+    static func cookieAuthAttempts(credentials: GrokCredentials?) -> [GrokCredentials?] {
+        guard let credentials, !credentials.isExpired else { return [nil] }
+        return [credentials, nil]
+    }
+    #endif
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Grok/GrokRPCClient.swift b/Sources/CodexBarCore/Providers/Grok/GrokRPCClient.swift
new file mode 100644
index 0000000000..a0feea7983
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Grok/GrokRPCClient.swift
@@ -0,0 +1,371 @@
+import Foundation
+
+/// JSON-RPC client for `grok agent stdio` (ACP protocol).
+///
+/// The protocol mirrors Codex's app-server (newline-delimited JSON-RPC 2.0 over stdin/stdout),
+/// but uses `protocolVersion`/`clientCapabilities` for the `initialize` call instead of
+/// `clientInfo`. Billing is fetched via the `x.ai/billing` extension method.
+final class GrokRPCClient: @unchecked Sendable {
+    private static let log = CodexBarLog.logger(LogCategories.grok)
+
+    private let process = Process()
+    private let stdinPipe = Pipe()
+    private let stdoutPipe = Pipe()
+    private let stderrPipe = Pipe()
+    private let initializeTimeoutSeconds: TimeInterval
+    private let requestTimeoutSeconds: TimeInterval
+    private var nextID: Int = 1
+    private let stdoutLineStream: AsyncStream<Data>
+    private let stdoutLineContinuation: AsyncStream<Data>.Continuation
+
+    init(
+        executable: String = "grok",
+        arguments: [String] = ["agent", "stdio"],
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        initializeTimeoutSeconds: TimeInterval = 4.0,
+        requestTimeoutSeconds: TimeInterval = 3.0) throws
+    {
+        self.initializeTimeoutSeconds = initializeTimeoutSeconds
+        self.requestTimeoutSeconds = requestTimeoutSeconds
+        var stdoutContinuation: AsyncStream<Data>.Continuation!
+        self.stdoutLineStream = AsyncStream<Data> { continuation in
+            stdoutContinuation = continuation
+        }
+        self.stdoutLineContinuation = stdoutContinuation
+
+        let resolvedExec = BinaryLocator.resolveGrokBinary(env: environment)
+            ?? TTYCommandRunner.which(executable)
+
+        guard let resolvedExec else {
+            Self.log.warning("Grok RPC binary not found", metadata: ["binary": executable])
+            throw GrokRPCError.binaryNotFound
+        }
+
+        var env = environment
+        env["PATH"] = PathBuilder.effectivePATH(purposes: [.rpc], env: env)
+
+        self.process.environment = env
+        self.process.executableURL = URL(fileURLWithPath: "/usr/bin/env")
+        self.process.arguments = [resolvedExec] + arguments
+        self.process.standardInput = self.stdinPipe
+        self.process.standardOutput = self.stdoutPipe
+        self.process.standardError = self.stderrPipe
+
+        do {
+            try self.process.run()
+            Self.log.debug("Grok RPC started", metadata: ["binary": resolvedExec])
+        } catch {
+            Self.log.warning("Grok RPC failed to start", metadata: ["error": error.localizedDescription])
+            throw GrokRPCError.startFailed(error.localizedDescription)
+        }
+
+        let stdoutHandle = self.stdoutPipe.fileHandleForReading
+        let stdoutLineContinuation = self.stdoutLineContinuation
+        let stdoutBuffer = LineBuffer()
+        stdoutHandle.readabilityHandler = { handle in
+            let data = handle.availableData
+            if data.isEmpty {
+                handle.readabilityHandler = nil
+                stdoutLineContinuation.finish()
+                return
+            }
+            let lines = stdoutBuffer.appendAndDrainLines(data)
+            for lineData in lines {
+                stdoutLineContinuation.yield(lineData)
+            }
+        }
+
+        let stderrHandle = self.stderrPipe.fileHandleForReading
+        stderrHandle.readabilityHandler = { handle in
+            let data = handle.availableData
+            if data.isEmpty {
+                handle.readabilityHandler = nil
+                return
+            }
+            guard let text = String(data: data, encoding: .utf8), !text.isEmpty else { return }
+            for line in text.split(whereSeparator: \.isNewline) {
+                #if !os(Linux)
+                fputs("[grok stderr] \(line)\n", stderr)
+                #endif
+            }
+        }
+    }
+
+    deinit {
+        self.shutdown()
+    }
+
+    func initialize() async throws {
+        let params: [String: Any] = [
+            "protocolVersion": "1",
+            "clientCapabilities": [
+                "fs": ["readTextFile": false, "writeTextFile": false],
+                "terminal": false,
+            ],
+        ]
+        _ = try await self.request(
+            method: "initialize",
+            params: params,
+            timeout: self.initializeTimeoutSeconds)
+    }
+
+    /// Calls `x.ai/billing` and returns the decoded response.
+    func fetchBilling() async throws -> GrokBillingResponse {
+        let message = try await self.request(method: "x.ai/billing", params: [:])
+        return try self.decodeResult(from: message)
+    }
+
+    func shutdown() {
+        if self.process.isRunning {
+            Self.log.debug("Grok RPC stopping")
+            self.process.terminate()
+        }
+    }
+
+    // MARK: - JSON-RPC plumbing (mirrors CodexRPCClient)
+
+    private struct SendableJSONMessage: @unchecked Sendable {
+        let value: [String: Any]
+    }
+
+    private func request(
+        method: String,
+        params: [String: Any]? = nil,
+        timeout: TimeInterval? = nil) async throws -> [String: Any]
+    {
+        let id = self.nextID
+        self.nextID += 1
+        try self.sendRequest(id: id, method: method, params: params)
+
+        let resolvedTimeout = timeout ?? self.requestTimeoutSeconds
+        let wrapped = try await self.withTimeout(seconds: resolvedTimeout, method: method) {
+            while true {
+                let message = try await self.readNextMessage()
+                // Skip notifications (no id) or unrelated responses.
+                if message["id"] == nil { continue }
+                guard let messageID = self.jsonID(message["id"]), messageID == id else { continue }
+                if let error = message["error"] as? [String: Any] {
+                    let messageText = (error["message"] as? String) ?? "unknown JSON-RPC error"
+                    throw GrokRPCError.requestFailed(messageText)
+                }
+                return SendableJSONMessage(value: message)
+            }
+        }
+        return wrapped.value
+    }
+
+    private func withTimeout<T: Sendable>(
+        seconds: TimeInterval,
+        method: String,
+        body: @escaping @Sendable () async throws -> T) async throws -> T
+    {
+        try await withThrowingTaskGroup(of: T.self) { group in
+            group.addTask { try await body() }
+            group.addTask { [weak self] in
+                try await Task.sleep(for: .seconds(seconds))
+                self?.terminateProcessForTimeout(method: method)
+                throw GrokRPCError.timeout(method: method)
+            }
+            do {
+                guard let result = try await group.next() else {
+                    throw GrokRPCError.timeout(method: method)
+                }
+                group.cancelAll()
+                return result
+            } catch {
+                group.cancelAll()
+                throw error
+            }
+        }
+    }
+
+    private func terminateProcessForTimeout(method: String) {
+        if self.process.isRunning {
+            Self.log.warning("Grok RPC timed out on `\(method)`; terminating process")
+            self.process.terminate()
+        }
+    }
+
+    private func sendRequest(id: Int, method: String, params: [String: Any]?) throws {
+        let paramsValue: Any = params ?? [:]
+        let payload: [String: Any] = [
+            "jsonrpc": "2.0",
+            "id": id,
+            "method": method,
+            "params": paramsValue,
+        ]
+        try self.sendPayload(payload)
+    }
+
+    private func sendPayload(_ payload: [String: Any]) throws {
+        let raw = try JSONSerialization.data(withJSONObject: payload)
+        // Foundation's JSONSerialization escapes "/" as "\/" by default. Grok's
+        // ACP server treats the escaped form as a *different* method name (it does
+        // not unescape before lookup), so `x.ai/billing` becomes "Method not found"
+        // when sent as `x.ai\/billing`. Re-encode without slash escapes to match
+        // the on-the-wire shape the grok agent expects.
+        let unescaped = String(data: raw, encoding: .utf8)?
+            .replacingOccurrences(of: "\\/", with: "/")
+        let data = unescaped.flatMap { $0.data(using: .utf8) } ?? raw
+        if let preview = String(data: data.prefix(200), encoding: .utf8) {
+            Self.log.debug("grok rpc -> \(preview)")
+        }
+        self.stdinPipe.fileHandleForWriting.write(data)
+        self.stdinPipe.fileHandleForWriting.write(Data([0x0A]))
+    }
+
+    private func readNextMessage() async throws -> [String: Any] {
+        for await lineData in self.stdoutLineStream {
+            if lineData.isEmpty { continue }
+            if let preview = String(data: lineData.prefix(300), encoding: .utf8) {
+                Self.log.debug("grok rpc <- \(preview)")
+            }
+            if let json = try? JSONSerialization.jsonObject(with: lineData) as? [String: Any] {
+                return json
+            }
+        }
+        throw GrokRPCError.malformed("grok agent stdio closed stdout")
+    }
+
+    private func decodeResult<T: Decodable>(from message: [String: Any]) throws -> T {
+        guard let result = message["result"] else {
+            throw GrokRPCError.malformed("missing result field")
+        }
+        let data = try JSONSerialization.data(withJSONObject: result)
+        let decoder = JSONDecoder()
+        return try decoder.decode(T.self, from: data)
+    }
+
+    private func jsonID(_ value: Any?) -> Int? {
+        switch value {
+        case let int as Int: int
+        case let number as NSNumber: number.intValue
+        default: nil
+        }
+    }
+
+    private final class LineBuffer: @unchecked Sendable {
+        private var buffer = Data()
+        private let lock = NSLock()
+
+        func appendAndDrainLines(_ data: Data) -> [Data] {
+            self.lock.lock()
+            defer { lock.unlock() }
+            self.buffer.append(data)
+            var out: [Data] = []
+            while let newline = self.buffer.firstIndex(of: 0x0A) {
+                let lineData = Data(self.buffer[..<newline])
+                self.buffer.removeSubrange(...newline)
+                if !lineData.isEmpty {
+                    out.append(lineData)
+                }
+            }
+            return out
+        }
+    }
+}
+
+public enum GrokRPCError: LocalizedError, Sendable {
+    case binaryNotFound
+    case startFailed(String)
+    case requestFailed(String)
+    case timeout(method: String)
+    case malformed(String)
+    case notAuthenticated
+
+    public var errorDescription: String? {
+        switch self {
+        case .binaryNotFound:
+            return "Grok CLI not found. Install via `curl -fsSL https://x.ai/cli/install.sh | bash`."
+        case let .startFailed(message):
+            return "Grok CLI failed to start: \(message)"
+        case let .requestFailed(message):
+            // Surface the auth-required hint that billing.rs emits verbatim.
+            if message.localizedCaseInsensitiveContains("authentication required")
+                || message.localizedCaseInsensitiveContains("grok login")
+            {
+                return "Grok billing requires authentication. Run `grok login`."
+            }
+            return "Grok request failed: \(message)"
+        case let .timeout(method):
+            return "Grok RPC timed out on `\(method)`."
+        case let .malformed(message):
+            return "Malformed Grok RPC response: \(message)"
+        case .notAuthenticated:
+            return "Not authenticated to Grok. Run `grok login`."
+        }
+    }
+}
+
+/// Schema for the `x.ai/billing` result.
+///
+/// All monetary amounts (`monthlyLimit`, `onDemandCap`, `includedUsed`, etc.) are
+/// represented as `{ val: <cents> }` in the wire format.
+public struct GrokBillingResponse: Codable, Sendable {
+    public let billingCycle: GrokBillingCycle?
+    public let monthlyLimit: GrokCent?
+    public let onDemandCap: GrokCent?
+    public let onDemandEnabled: Bool?
+    public let disabledByConfig: Bool?
+    public let usage: GrokBillingUsage?
+
+    private enum CodingKeys: String, CodingKey {
+        case billingCycle
+        case monthlyLimit
+        case onDemandCap
+        case onDemandEnabled = "on_demand_enabled"
+        case disabledByConfig
+        case usage
+    }
+}
+
+public struct GrokBillingCycle: Codable, Sendable {
+    public let billingPeriodStart: String?
+    public let billingPeriodEnd: String?
+}
+
+public struct GrokBillingUsage: Codable, Sendable {
+    public let includedUsed: GrokCent?
+    public let onDemandUsed: GrokCent?
+    public let totalUsed: GrokCent?
+}
+
+public struct GrokCent: Codable, Sendable {
+    public let val: Int?
+}
+
+extension GrokBillingResponse {
+    /// Convenience accessor: monthly usage as a 0–100 percent.
+    public var monthlyUsedPercent: Double? {
+        guard let limit = self.monthlyLimit?.val, limit > 0,
+              let used = self.usage?.totalUsed?.val
+        else { return nil }
+        return min(100.0, max(0.0, Double(used) / Double(limit) * 100.0))
+    }
+
+    public var billingPeriodEndDate: Date? {
+        guard let raw = self.billingCycle?.billingPeriodEnd else { return nil }
+        return GrokBillingResponse.parseISO8601(raw)
+    }
+
+    public var billingPeriodStartDate: Date? {
+        guard let raw = self.billingCycle?.billingPeriodStart else { return nil }
+        return GrokBillingResponse.parseISO8601(raw)
+    }
+
+    public var billingPeriodMinutes: Int? {
+        guard let start = self.billingPeriodStartDate,
+              let end = self.billingPeriodEndDate,
+              end > start
+        else { return nil }
+        return Int(end.timeIntervalSince(start) / 60)
+    }
+
+    private static func parseISO8601(_ raw: String) -> Date? {
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        if let date = formatter.date(from: raw) { return date }
+        formatter.formatOptions = [.withInternetDateTime]
+        return formatter.date(from: raw)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Grok/GrokStatusProbe.swift b/Sources/CodexBarCore/Providers/Grok/GrokStatusProbe.swift
new file mode 100644
index 0000000000..5473d24928
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Grok/GrokStatusProbe.swift
@@ -0,0 +1,147 @@
+import Foundation
+
+public struct GrokUsageSnapshot: Sendable {
+    public let billing: GrokBillingResponse?
+    public let webBilling: GrokWebBillingSnapshot?
+    public let credentials: GrokCredentials?
+    public let localSummary: GrokLocalSessionSummary?
+    public let cliVersion: String?
+    public let updatedAt: Date
+
+    public init(
+        billing: GrokBillingResponse?,
+        webBilling: GrokWebBillingSnapshot? = nil,
+        credentials: GrokCredentials?,
+        localSummary: GrokLocalSessionSummary?,
+        cliVersion: String?,
+        updatedAt: Date)
+    {
+        self.billing = billing
+        self.webBilling = webBilling
+        self.credentials = credentials
+        self.localSummary = localSummary
+        self.cliVersion = cliVersion
+        self.updatedAt = updatedAt
+    }
+
+    public func toUsageSnapshot() -> UsageSnapshot {
+        // Primary window: credit usage (against included limit) from the CLI RPC,
+        // falling back to the web billing RPC used by grok.com when the agent surface lacks billing.
+        var primary: RateWindow?
+        if let billing,
+           let percent = billing.monthlyUsedPercent
+        {
+            primary = RateWindow(
+                usedPercent: percent,
+                windowMinutes: billing.billingPeriodMinutes,
+                resetsAt: billing.billingPeriodEndDate,
+                resetDescription: nil)
+        } else if let webBilling,
+                  let percent = webBilling.usedPercent
+        {
+            primary = RateWindow(
+                usedPercent: percent,
+                windowMinutes: nil,
+                resetsAt: webBilling.resetsAt,
+                resetDescription: nil)
+        }
+
+        let identity = ProviderIdentitySnapshot(
+            providerID: .grok,
+            accountEmail: self.credentials?.email,
+            accountOrganization: self.credentials?.teamId,
+            loginMethod: self.credentials?.loginMethod)
+
+        return UsageSnapshot(
+            primary: primary,
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: self.updatedAt,
+            identity: identity)
+    }
+}
+
+public struct GrokStatusProbe: Sendable {
+    public init() {}
+
+    public static func detectVersion(env: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        guard let binary = BinaryLocator.resolveGrokBinary(env: env) else { return nil }
+        guard let output = ProviderVersionDetector.run(
+            path: binary,
+            args: ["--version"],
+            environment: env,
+            mergeStandardError: true)
+        else { return nil }
+        // Output is like "grok 0.1.210 (8b63e9068c)" — strip the leading "grok " so
+        // callers can prefix the CLI name themselves without duplicating it.
+        let withoutPrefix = output.replacingOccurrences(
+            of: #"^grok\s+"#,
+            with: "",
+            options: [.regularExpression])
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+        return withoutPrefix.isEmpty ? nil : withoutPrefix
+    }
+
+    public func fetch(env: [String: String] = ProcessInfo.processInfo.environment) async throws -> GrokUsageSnapshot {
+        // Credentials are optional: we still show identity-less state if the user
+        // hasn't logged in, with a clear hint via the RPC error.
+        let credentials = try? GrokCredentialsStore.load(env: env)
+
+        var billing: GrokBillingResponse?
+        var rpcError: Error?
+        do {
+            let client = try GrokRPCClient(environment: env)
+            defer { client.shutdown() }
+            try await client.initialize()
+            billing = try await client.fetchBilling()
+        } catch {
+            rpcError = error
+        }
+
+        // Local fallback summary always succeeds (empty if no sessions yet).
+        let localSummary = GrokLocalSessionScanner.summarize(env: env)
+        let cliVersion = Self.detectVersion(env: env)
+
+        // `localSummary` is *not* currently projected into a visible RateWindow or
+        // identity field, so a stale `~/.grok/sessions/` directory must not
+        // suppress the auth-required hint. CLI-only fetches need a billing
+        // response; the provider pipeline owns the separate web fallback.
+        if billing == nil {
+            throw rpcError ?? GrokRPCError.notAuthenticated
+        }
+
+        return GrokUsageSnapshot(
+            billing: billing,
+            webBilling: nil,
+            credentials: Self.credentialsForSnapshot(
+                credentials: credentials,
+                billing: billing,
+                webBilling: nil),
+            localSummary: localSummary,
+            cliVersion: cliVersion,
+            updatedAt: Date())
+    }
+
+    static func credentialsForSnapshot(
+        credentials: GrokCredentials?,
+        billing: GrokBillingResponse?,
+        webBilling: GrokWebBillingSnapshot? = nil) -> GrokCredentials?
+    {
+        // If remote usage succeeded, xAI accepted auth and the local
+        // identity is still useful even when the persisted expires_at is stale.
+        if billing != nil || webBilling != nil { return credentials }
+        return credentials.flatMap { $0.isExpired ? nil : $0 }
+    }
+
+    static func shouldSurfaceRemoteAuthError(_ error: Error?) -> Bool {
+        guard let error = error as? GrokWebBillingError else { return false }
+        switch error {
+        case let .requestFailed(status, _):
+            return status == 401 || status == 403
+        case let .rpcFailed(status, _):
+            return status == 16
+        case .missingCredentials, .emptyResponse, .invalidResponse, .parseFailed:
+            return false
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Grok/GrokWebBillingFetcher.swift b/Sources/CodexBarCore/Providers/Grok/GrokWebBillingFetcher.swift
new file mode 100644
index 0000000000..4ab67ac8e2
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Grok/GrokWebBillingFetcher.swift
@@ -0,0 +1,433 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public struct GrokWebBillingSnapshot: Sendable, Equatable {
+    public let usedPercent: Double?
+    public let resetsAt: Date?
+
+    public init(usedPercent: Double?, resetsAt: Date?) {
+        self.usedPercent = usedPercent
+        self.resetsAt = resetsAt
+    }
+}
+
+public enum GrokWebBillingError: LocalizedError, Sendable {
+    case missingCredentials
+    case emptyResponse
+    case invalidResponse
+    case requestFailed(Int, String)
+    case rpcFailed(Int, String)
+    case parseFailed
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingCredentials:
+            "Grok web billing requires a signed-in grok.com browser session or `grok login`."
+        case .emptyResponse:
+            "Grok web billing returned no protobuf payload."
+        case .invalidResponse:
+            "Grok web billing returned an invalid response."
+        case let .requestFailed(status, body):
+            if status == 401 || status == 403 {
+                Self.reauthMessage
+            } else {
+                "Grok web billing request failed with HTTP \(status): \(body)"
+            }
+        case let .rpcFailed(status, message):
+            if Self.isAuthenticationFailure(status: status, message: message) {
+                Self.reauthMessage
+            } else {
+                "Grok web billing RPC failed with status \(status): \(message)"
+            }
+        case .parseFailed:
+            "Could not parse Grok web billing usage."
+        }
+    }
+
+    private static let reauthMessage =
+        "Grok web billing rejected credentials. Sign in to grok.com in Chrome or run `grok login` to refresh xAI auth."
+
+    static func isAuthenticationFailure(status: Int, message: String) -> Bool {
+        if status == 16 { return true }
+        guard status == 7 else { return false }
+        let lower = message.lowercased()
+        return lower.contains("bad-credentials") ||
+            lower.contains("unauthenticated") ||
+            (lower.contains("oauth2") && lower.contains("could not be validated")) ||
+            (lower.contains("access token") &&
+                (lower.contains("invalid") ||
+                    lower.contains("expired") ||
+                    lower.contains("could not be validated")))
+    }
+}
+
+public enum GrokWebBillingFetcher {
+    public static let defaultEndpoint =
+        URL(string: "https://grok.com/grok_api_v2.GrokBuildBilling/GetGrokCreditsConfig")!
+    private static let requestTimeoutSeconds: TimeInterval = 15
+
+    public static func fetch(
+        credentials: GrokCredentials,
+        session transport: any ProviderHTTPTransport = ProviderHTTPClient.shared,
+        endpoint: URL = Self.defaultEndpoint) async throws -> GrokWebBillingSnapshot
+    {
+        try await self.fetch(
+            authorizationHeader: "Bearer \(credentials.accessToken)",
+            cookieHeader: nil,
+            transport: transport,
+            endpoint: endpoint)
+    }
+
+    public static func fetch(
+        cookieHeader: String,
+        session transport: any ProviderHTTPTransport = ProviderHTTPClient.shared,
+        endpoint: URL = Self.defaultEndpoint) async throws -> GrokWebBillingSnapshot
+    {
+        try await self.fetch(
+            cookieHeader: cookieHeader,
+            credentials: nil,
+            session: transport,
+            endpoint: endpoint)
+    }
+
+    public static func fetch(
+        cookieHeader: String,
+        credentials: GrokCredentials?,
+        session transport: any ProviderHTTPTransport = ProviderHTTPClient.shared,
+        endpoint: URL = Self.defaultEndpoint) async throws -> GrokWebBillingSnapshot
+    {
+        let authorizationHeader = credentials.flatMap { credential in
+            credential.isExpired ? nil : "Bearer \(credential.accessToken)"
+        }
+        return try await self.fetch(
+            authorizationHeader: authorizationHeader,
+            cookieHeader: cookieHeader,
+            transport: transport,
+            endpoint: endpoint)
+    }
+
+    private static func fetch(
+        authorizationHeader: String?,
+        cookieHeader: String?,
+        transport: any ProviderHTTPTransport,
+        endpoint: URL) async throws -> GrokWebBillingSnapshot
+    {
+        do {
+            return try await self.fetchOnce(
+                authorizationHeader: authorizationHeader,
+                cookieHeader: cookieHeader,
+                transport: transport,
+                endpoint: endpoint)
+        } catch where self.shouldRetry(error) {
+            return try await self.fetchOnce(
+                authorizationHeader: authorizationHeader,
+                cookieHeader: cookieHeader,
+                transport: transport,
+                endpoint: endpoint)
+        }
+    }
+
+    private static func fetchOnce(
+        authorizationHeader: String?,
+        cookieHeader: String?,
+        transport: any ProviderHTTPTransport,
+        endpoint: URL) async throws -> GrokWebBillingSnapshot
+    {
+        var request = URLRequest(url: endpoint)
+        request.httpMethod = "POST"
+        request.timeoutInterval = Self.requestTimeoutSeconds
+        request.httpBody = Data([0x00, 0x00, 0x00, 0x00, 0x00])
+        if let authorizationHeader {
+            request.setValue(authorizationHeader, forHTTPHeaderField: "Authorization")
+        }
+        if let cookieHeader {
+            request.setValue(cookieHeader, forHTTPHeaderField: "Cookie")
+        }
+        request.setValue("https://grok.com", forHTTPHeaderField: "Origin")
+        request.setValue("https://grok.com/?_s=usage", forHTTPHeaderField: "Referer")
+        request.setValue("*/*", forHTTPHeaderField: "Accept")
+        request.setValue("application/grpc-web+proto", forHTTPHeaderField: "Content-Type")
+        request.setValue("1", forHTTPHeaderField: "x-grpc-web")
+        request.setValue("connect-es/2.1.1", forHTTPHeaderField: "x-user-agent")
+        request.setValue("CodexBar", forHTTPHeaderField: "User-Agent")
+
+        let response: ProviderHTTPResponse
+        do {
+            response = try await transport.response(for: request)
+        } catch let error as URLError where error.code == .badServerResponse {
+            throw GrokWebBillingError.invalidResponse
+        } catch {
+            throw error
+        }
+        guard response.statusCode == 200 else {
+            let body = String(data: response.data.prefix(400), encoding: .utf8) ?? ""
+            throw GrokWebBillingError.requestFailed(response.statusCode, body)
+        }
+        try Self.validateGRPCStatusFields(Self.grpcHeaderFields(from: response.response.allHeaderFields))
+        try Self.validateGRPCWebTrailers(response.data)
+
+        return try Self.parseGRPCWebResponse(response.data)
+    }
+
+    private static func shouldRetry(_ error: Error) -> Bool {
+        if let urlError = error as? URLError {
+            return urlError.code == .timedOut || urlError.code == .networkConnectionLost
+        }
+        if case let GrokWebBillingError.requestFailed(status, body) = error {
+            if [408, 502, 503, 504].contains(status) { return true }
+            return body.localizedCaseInsensitiveContains("timeout")
+                || body.localizedCaseInsensitiveContains("deadline")
+        }
+        guard case let GrokWebBillingError.rpcFailed(status, message) = error else { return false }
+        if status == 4 { return true }
+        guard status == 1 else { return false }
+        return message.localizedCaseInsensitiveContains("timeout")
+            || message.localizedCaseInsensitiveContains("deadline")
+            || message.localizedCaseInsensitiveContains("expired")
+    }
+
+    static func parseGRPCWebResponse(_ data: Data, now: Date = Date()) throws -> GrokWebBillingSnapshot {
+        var payloads = Self.grpcWebDataFrames(from: data)
+        if payloads.isEmpty, Self.looksLikeProtobufPayload(data) {
+            payloads = [data]
+        }
+        guard !payloads.isEmpty else { throw GrokWebBillingError.emptyResponse }
+
+        var scan = ProtobufScan()
+        for payload in payloads {
+            scan.merge(Self.scanProtobuf(payload, depth: 0))
+        }
+
+        let parsedPercent = scan.fixed32Fields
+            .filter { field in
+                field.path.last == 1 && field.value.isFinite && field.value >= 0 && field.value <= 100
+            }
+            .min { lhs, rhs in
+                lhs.path.count == rhs.path.count ? lhs.order < rhs.order : lhs.path.count < rhs.path.count
+            }
+            .map { Double($0.value) }
+
+        let resetFields = scan.varintFields.compactMap { field -> (path: [UInt64], date: Date)? in
+            let raw = field.value
+            guard raw >= 1_700_000_000, raw <= 2_100_000_000 else { return nil }
+            return (field.path, Date(timeIntervalSince1970: TimeInterval(raw)))
+        }
+        let futureResetFields = resetFields.filter { $0.date > now }
+        let reset = futureResetFields
+            .filter { $0.path == [1, 5, 1] }
+            .map(\.date)
+            .min() ?? futureResetFields
+            .map(\.date)
+            .min()
+
+        let hasUsagePeriod = scan.varintFields.contains { field in
+            field.path.starts(with: [1, 6]) ||
+                (field.path == [1, 8, 1] && (field.value == 1 || field.value == 2))
+        }
+        let noUsageYet = parsedPercent == nil &&
+            scan.fixed32Fields.isEmpty &&
+            reset != nil &&
+            hasUsagePeriod
+        guard let percent = parsedPercent ?? (noUsageYet ? 0 : nil) else {
+            throw GrokWebBillingError.parseFailed
+        }
+        return GrokWebBillingSnapshot(usedPercent: percent, resetsAt: reset)
+    }
+
+    static func looksLikeProtobufPayload(_ data: Data) -> Bool {
+        guard let first = data.first else { return false }
+        let fieldNumber = first >> 3
+        let wireType = first & 0x07
+        return fieldNumber > 0 && (wireType == 0 || wireType == 1 || wireType == 2 || wireType == 5)
+    }
+
+    static func grpcWebDataFrames(from data: Data) -> [Data] {
+        let bytes = [UInt8](data)
+        var frames: [Data] = []
+        var index = 0
+        while index < bytes.count {
+            guard index + 5 <= bytes.count else { return [] }
+            let flags = bytes[index]
+            let length = (Int(bytes[index + 1]) << 24)
+                | (Int(bytes[index + 2]) << 16)
+                | (Int(bytes[index + 3]) << 8)
+                | Int(bytes[index + 4])
+            let start = index + 5
+            let end = start + length
+            guard length >= 0, end <= bytes.count else { return [] }
+            if flags & 0x80 == 0 {
+                frames.append(Data(bytes[start..<end]))
+            }
+            index = end
+        }
+        return frames
+    }
+
+    static func validateGRPCWebTrailers(_ data: Data) throws {
+        try self.validateGRPCStatusFields(self.grpcWebTrailerFields(from: data))
+    }
+
+    static func validateGRPCStatusFields(_ fields: [String: String]) throws {
+        guard let rawStatus = fields["grpc-status"],
+              let status = Int(rawStatus),
+              status != 0
+        else {
+            return
+        }
+        throw GrokWebBillingError.rpcFailed(status, fields["grpc-message"] ?? "")
+    }
+
+    static func grpcHeaderFields(from headers: [AnyHashable: Any]) -> [String: String] {
+        var fields: [String: String] = [:]
+        for (key, value) in headers {
+            let normalizedKey = String(describing: key)
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+                .lowercased()
+            guard normalizedKey.hasPrefix("grpc-") else { continue }
+            fields[normalizedKey] = String(describing: value)
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+                .removingPercentEncoding ?? ""
+        }
+        return fields
+    }
+
+    static func grpcWebTrailerFields(from data: Data) -> [String: String] {
+        let bytes = [UInt8](data)
+        var fields: [String: String] = [:]
+        var index = 0
+        while index + 5 <= bytes.count {
+            let flags = bytes[index]
+            let length = (Int(bytes[index + 1]) << 24)
+                | (Int(bytes[index + 2]) << 16)
+                | (Int(bytes[index + 3]) << 8)
+                | Int(bytes[index + 4])
+            let start = index + 5
+            let end = start + length
+            guard length >= 0, end <= bytes.count else { break }
+            if flags & 0x80 != 0, let text = String(data: Data(bytes[start..<end]), encoding: .utf8) {
+                for line in text.components(separatedBy: .newlines) where !line.isEmpty {
+                    guard let separator = line.firstIndex(of: ":") else { continue }
+                    let key = line[..<separator]
+                        .trimmingCharacters(in: .whitespacesAndNewlines)
+                        .lowercased()
+                    let value = line[line.index(after: separator)...]
+                        .trimmingCharacters(in: .whitespacesAndNewlines)
+                        .removingPercentEncoding ?? ""
+                    fields[key] = value
+                }
+            }
+            index = end
+        }
+        return fields
+    }
+
+    private struct ProtobufScan {
+        struct Fixed32Field {
+            var path: [UInt64]
+            var value: Float
+            var order: Int
+        }
+
+        struct VarintField {
+            var path: [UInt64]
+            var value: UInt64
+        }
+
+        var fixed32Fields: [Fixed32Field] = []
+        var varintFields: [VarintField] = []
+
+        mutating func merge(_ other: ProtobufScan) {
+            self.fixed32Fields.append(contentsOf: other.fixed32Fields)
+            self.varintFields.append(contentsOf: other.varintFields)
+        }
+    }
+
+    private static func scanProtobuf(_ data: Data, depth: Int) -> ProtobufScan {
+        self.scanProtobuf(data, depth: depth, path: [], order: 0).scan
+    }
+
+    private static func scanProtobuf(
+        _ data: Data,
+        depth: Int,
+        path: [UInt64],
+        order: Int) -> (scan: ProtobufScan, order: Int)
+    {
+        let bytes = [UInt8](data)
+        var scan = ProtobufScan()
+        var index = 0
+        var nextOrder = order
+
+        while index < bytes.count {
+            let fieldStart = index
+            guard let key = Self.readVarint(bytes, index: &index), key != 0 else {
+                index = fieldStart + 1
+                continue
+            }
+            let fieldNumber = key >> 3
+            let wireType = key & 0x07
+            let fieldPath = path + [fieldNumber]
+
+            switch wireType {
+            case 0:
+                if let value = Self.readVarint(bytes, index: &index) {
+                    scan.varintFields.append(ProtobufScan.VarintField(path: fieldPath, value: value))
+                } else {
+                    index = fieldStart + 1
+                }
+            case 1:
+                guard index + 8 <= bytes.count else { return (scan, nextOrder) }
+                index += 8
+            case 2:
+                guard let length = Self.readVarint(bytes, index: &index),
+                      length <= UInt64(bytes.count - index)
+                else {
+                    index = fieldStart + 1
+                    continue
+                }
+                let start = index
+                let end = index + Int(length)
+                if depth < 4 {
+                    let nested = Self.scanProtobuf(
+                        Data(bytes[start..<end]),
+                        depth: depth + 1,
+                        path: fieldPath,
+                        order: nextOrder)
+                    scan.merge(nested.scan)
+                    nextOrder = nested.order
+                }
+                index = end
+            case 5:
+                guard index + 4 <= bytes.count else { return (scan, nextOrder) }
+                let bitPattern = UInt32(bytes[index])
+                    | (UInt32(bytes[index + 1]) << 8)
+                    | (UInt32(bytes[index + 2]) << 16)
+                    | (UInt32(bytes[index + 3]) << 24)
+                scan.fixed32Fields.append(ProtobufScan.Fixed32Field(
+                    path: fieldPath,
+                    value: Float(bitPattern: bitPattern),
+                    order: nextOrder))
+                nextOrder += 1
+                index += 4
+            default:
+                index = fieldStart + 1
+            }
+        }
+
+        return (scan, nextOrder)
+    }
+
+    private static func readVarint(_ bytes: [UInt8], index: inout Int) -> UInt64? {
+        var value: UInt64 = 0
+        var shift: UInt64 = 0
+        while index < bytes.count, shift < 64 {
+            let byte = bytes[index]
+            index += 1
+            value |= UInt64(byte & 0x7F) << shift
+            if byte & 0x80 == 0 { return value }
+            shift += 7
+        }
+        return nil
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Groq/GroqProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Groq/GroqProviderDescriptor.swift
new file mode 100644
index 0000000000..f4214daa0d
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Groq/GroqProviderDescriptor.swift
@@ -0,0 +1,49 @@
+import Foundation
+
+public enum GroqProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .groq,
+            metadata: ProviderMetadata(
+                id: .groq,
+                displayName: "Groq",
+                sessionLabel: "Requests",
+                weeklyLabel: "Tokens",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "",
+                toggleTitle: "Show Groq usage",
+                cliName: "groqcloud",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                browserCookieOrder: nil,
+                dashboardURL: "https://console.groq.com/dashboard/metrics",
+                statusPageURL: nil,
+                statusLinkURL: "https://status.groq.com"),
+            branding: ProviderBranding(
+                iconStyle: .groq,
+                iconResourceName: "ProviderIcon-groq",
+                color: ProviderColor(red: 245 / 255, green: 104 / 255, blue: 68 / 255)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "Groq cost history is not available via the metrics API." }),
+            fetchPlan: .apiToken(
+                strategyID: "groq.api",
+                sourceLabel: "metrics",
+                resolveToken: { ProviderTokenResolver.groqToken(environment: $0) },
+                missingCredentialsError: { GroqUsageError.missingCredentials },
+                loadUsage: { apiKey, context in
+                    try await GroqUsageFetcher.fetchUsage(
+                        apiKey: apiKey,
+                        environment: context.env).toUsageSnapshot()
+                }),
+            cli: ProviderCLIConfig(
+                name: "groqcloud",
+                aliases: ["groq", "groq-api"],
+                versionDetector: nil))
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Groq/GroqSettingsReader.swift b/Sources/CodexBarCore/Providers/Groq/GroqSettingsReader.swift
new file mode 100644
index 0000000000..65c8a4a3df
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Groq/GroqSettingsReader.swift
@@ -0,0 +1,58 @@
+import Foundation
+
+public enum GroqSettingsReader {
+    public static let apiKeyEnvironmentKey = "GROQ_API_KEY"
+    public static let apiURLEnvironmentKey = "GROQ_API_URL"
+
+    public static func apiKey(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.cleaned(environment[self.apiKeyEnvironmentKey])
+    }
+
+    public static func apiURL(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> URL
+    {
+        if let override = self.validAPIURL(environment: environment) {
+            return override
+        }
+        return URL(string: "https://api.groq.com/v1")!
+    }
+
+    public static func validateEndpointOverrides(
+        environment: [String: String] = ProcessInfo.processInfo.environment) throws
+    {
+        guard let raw = self.cleaned(environment[self.apiURLEnvironmentKey]) else { return }
+        guard ProviderEndpointOverrideValidator.normalizedHTTPSURL(from: raw) == nil else { return }
+        throw GroqSettingsError.invalidEndpointOverride(self.apiURLEnvironmentKey)
+    }
+
+    static func cleaned(_ raw: String?) -> String? {
+        guard var value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
+            return nil
+        }
+        if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
+            (value.hasPrefix("'") && value.hasSuffix("'"))
+        {
+            value = String(value.dropFirst().dropLast())
+        }
+        value = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        return value.isEmpty ? nil : value
+    }
+
+    private static func validAPIURL(environment: [String: String]) -> URL? {
+        guard let raw = self.cleaned(environment[self.apiURLEnvironmentKey]) else { return nil }
+        return ProviderEndpointOverrideValidator.normalizedHTTPSURL(from: raw)
+    }
+}
+
+public enum GroqSettingsError: LocalizedError, Sendable, Equatable {
+    case invalidEndpointOverride(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case let .invalidEndpointOverride(key):
+            "Groq endpoint override \(key) must use HTTPS or a bare host."
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Groq/GroqUsageFetcher.swift b/Sources/CodexBarCore/Providers/Groq/GroqUsageFetcher.swift
new file mode 100644
index 0000000000..bff9a1b0a3
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Groq/GroqUsageFetcher.swift
@@ -0,0 +1,235 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public enum GroqUsageError: LocalizedError, Sendable {
+    case missingCredentials
+    case invalidURL
+    case accessDenied(String)
+    case apiError(String)
+    case parseFailed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingCredentials:
+            "Missing Groq API key. Set apiKey in ~/.codexbar/config.json or GROQ_API_KEY."
+        case .invalidURL:
+            "Groq metrics URL is invalid."
+        case let .accessDenied(message):
+            "Groq metrics access denied: \(message)"
+        case let .apiError(message):
+            "Groq metrics API error: \(message)"
+        case let .parseFailed(message):
+            "Groq metrics parse error: \(message)"
+        }
+    }
+}
+
+public struct GroqUsageSnapshot: Codable, Sendable, Equatable {
+    public let requestRatePerSecond: Double
+    public let inputTokenRatePerSecond: Double
+    public let outputTokenRatePerSecond: Double
+    public let promptCacheHitRatePerSecond: Double
+    public let updatedAt: Date
+
+    public init(
+        requestRatePerSecond: Double,
+        inputTokenRatePerSecond: Double,
+        outputTokenRatePerSecond: Double,
+        promptCacheHitRatePerSecond: Double = 0,
+        updatedAt: Date)
+    {
+        self.requestRatePerSecond = requestRatePerSecond
+        self.inputTokenRatePerSecond = inputTokenRatePerSecond
+        self.outputTokenRatePerSecond = outputTokenRatePerSecond
+        self.promptCacheHitRatePerSecond = promptCacheHitRatePerSecond
+        self.updatedAt = updatedAt
+    }
+
+    public var requestsPerMinute: Double {
+        self.requestRatePerSecond * 60
+    }
+
+    public var tokensPerMinute: Double {
+        (self.inputTokenRatePerSecond + self.outputTokenRatePerSecond) * 60
+    }
+
+    public var cacheHitsPerMinute: Double {
+        self.promptCacheHitRatePerSecond * 60
+    }
+
+    public func toUsageSnapshot() -> UsageSnapshot {
+        UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 0,
+                windowMinutes: 5,
+                resetsAt: nil,
+                resetDescription: "\(Self.formatDecimal(self.requestsPerMinute)) req/min"),
+            secondary: RateWindow(
+                usedPercent: 0,
+                windowMinutes: 5,
+                resetsAt: nil,
+                resetDescription: "\(Self.formatDecimal(self.tokensPerMinute)) tok/min"),
+            tertiary: self.promptCacheHitRatePerSecond > 0 ? RateWindow(
+                usedPercent: 0,
+                windowMinutes: 5,
+                resetsAt: nil,
+                resetDescription: "\(Self.formatDecimal(self.cacheHitsPerMinute)) cache/min") : nil,
+            updatedAt: self.updatedAt,
+            identity: ProviderIdentitySnapshot(
+                providerID: .groq,
+                accountEmail: nil,
+                accountOrganization: nil,
+                loginMethod: "Prometheus metrics"))
+    }
+
+    static func formatDecimal(_ value: Double) -> String {
+        if value >= 100 {
+            return String(format: "%.0f", value)
+        }
+        if value >= 10 {
+            return String(format: "%.1f", value)
+        }
+        return String(format: "%.2f", value)
+    }
+}
+
+private struct GroqPrometheusResponse: Decodable {
+    struct Payload: Decodable {
+        let result: [Series]
+    }
+
+    struct Series: Decodable {
+        let value: [PrometheusValue]?
+    }
+
+    enum PrometheusValue: Decodable {
+        case number(Double)
+        case string(String)
+
+        init(from decoder: Decoder) throws {
+            let container = try decoder.singleValueContainer()
+            if let number = try? container.decode(Double.self) {
+                self = .number(number)
+                return
+            }
+            self = try .string(container.decode(String.self))
+        }
+
+        var doubleValue: Double? {
+            switch self {
+            case let .number(number):
+                number
+            case let .string(text):
+                Double(text)
+            }
+        }
+    }
+
+    let status: String
+    let data: Payload?
+    let error: String?
+}
+
+public struct GroqUsageFetcher: Sendable {
+    public init() {}
+
+    public static func fetchUsage(
+        apiKey: String,
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        transport: any ProviderHTTPTransport = ProviderHTTPClient.shared,
+        updatedAt: Date = Date()) async throws -> GroqUsageSnapshot
+    {
+        guard !apiKey.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+            throw GroqUsageError.missingCredentials
+        }
+        try GroqSettingsReader.validateEndpointOverrides(environment: environment)
+        let baseURL = GroqSettingsReader.apiURL(environment: environment)
+            .appendingPathComponent("metrics")
+            .appendingPathComponent("prometheus")
+
+        async let requests = Self.queryScalar(
+            query: "sum(model_project_id_status_code:requests:rate5m)",
+            apiKey: apiKey,
+            baseURL: baseURL,
+            transport: transport)
+        async let inputTokens = Self.queryScalar(
+            query: "sum(model_project_id:tokens_in:rate5m)",
+            apiKey: apiKey,
+            baseURL: baseURL,
+            transport: transport)
+        async let outputTokens = Self.queryScalar(
+            query: "sum(model_project_id:tokens_out:rate5m)",
+            apiKey: apiKey,
+            baseURL: baseURL,
+            transport: transport)
+        async let cacheHits = Self.queryScalar(
+            query: "sum(model_project_id:prompt_cache_hits:rate5m)",
+            apiKey: apiKey,
+            baseURL: baseURL,
+            transport: transport)
+
+        return try await GroqUsageSnapshot(
+            requestRatePerSecond: requests,
+            inputTokenRatePerSecond: inputTokens,
+            outputTokenRatePerSecond: outputTokens,
+            promptCacheHitRatePerSecond: cacheHits,
+            updatedAt: updatedAt)
+    }
+
+    public static func _parseScalarForTesting(_ data: Data) throws -> Double {
+        try self.parseScalar(data: data)
+    }
+
+    private static func queryScalar(
+        query: String,
+        apiKey: String,
+        baseURL: URL,
+        transport: any ProviderHTTPTransport) async throws -> Double
+    {
+        guard var components = URLComponents(
+            url: baseURL.appendingPathComponent("api/v1/query"),
+            resolvingAgainstBaseURL: false)
+        else { throw GroqUsageError.invalidURL }
+        components.queryItems = [URLQueryItem(name: "query", value: query)]
+        guard let url = components.url else { throw GroqUsageError.invalidURL }
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+
+        let response = try await transport.response(for: request)
+        guard (200..<300).contains(response.statusCode) else {
+            let summary = Self.responseSummary(response.data)
+            if response.statusCode == 401 || response.statusCode == 403 {
+                throw GroqUsageError.accessDenied(summary)
+            }
+            throw GroqUsageError.apiError("HTTP \(response.statusCode): \(summary)")
+        }
+        return try self.parseScalar(data: response.data)
+    }
+
+    private static func parseScalar(data: Data) throws -> Double {
+        do {
+            let decoded = try JSONDecoder().decode(GroqPrometheusResponse.self, from: data)
+            guard decoded.status == "success" else {
+                throw GroqUsageError.apiError(decoded.error ?? "query failed")
+            }
+            return decoded.data?.result.compactMap { series in
+                series.value?.last?.doubleValue
+            }.reduce(0, +) ?? 0
+        } catch let error as GroqUsageError {
+            throw error
+        } catch {
+            throw GroqUsageError.parseFailed(error.localizedDescription)
+        }
+    }
+
+    private static func responseSummary(_ data: Data) -> String {
+        String(bytes: data.prefix(500), encoding: .utf8)?
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            ?? ""
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/JetBrains/JetBrainsProviderDescriptor.swift b/Sources/CodexBarCore/Providers/JetBrains/JetBrainsProviderDescriptor.swift
index 7b079e8832..3b31b1164b 100644
--- a/Sources/CodexBarCore/Providers/JetBrains/JetBrainsProviderDescriptor.swift
+++ b/Sources/CodexBarCore/Providers/JetBrains/JetBrainsProviderDescriptor.swift
@@ -1,9 +1,8 @@
-import CodexBarMacroSupport
 import Foundation
 
-@ProviderDescriptorRegistration
-@ProviderDescriptorDefinition
 public enum JetBrainsProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
     static func makeDescriptor() -> ProviderDescriptor {
         ProviderDescriptor(
             id: .jetbrains,
diff --git a/Sources/CodexBarCore/Providers/JetBrains/JetBrainsStatusProbe.swift b/Sources/CodexBarCore/Providers/JetBrains/JetBrainsStatusProbe.swift
index b9e02dff96..198d830d1a 100644
--- a/Sources/CodexBarCore/Providers/JetBrains/JetBrainsStatusProbe.swift
+++ b/Sources/CodexBarCore/Providers/JetBrains/JetBrainsStatusProbe.swift
@@ -1,5 +1,5 @@
 import Foundation
-#if canImport(FoundationXML)
+#if os(macOS) && canImport(FoundationXML)
 import FoundationXML
 #endif
 
diff --git a/Sources/CodexBarCore/Providers/Kilo/KiloBearerTokenResolver.swift b/Sources/CodexBarCore/Providers/Kilo/KiloBearerTokenResolver.swift
new file mode 100644
index 0000000000..6478c20313
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Kilo/KiloBearerTokenResolver.swift
@@ -0,0 +1,78 @@
+import Foundation
+
+public struct KiloResolvedBearerToken: Sendable, Equatable {
+    public let token: String
+    public let sourceLabel: String
+
+    public init(token: String, sourceLabel: String) {
+        self.token = token
+        self.sourceLabel = sourceLabel
+    }
+}
+
+/// Resolves the Kilo bearer token shared by usage fetches and organization discovery.
+///
+/// Behavior mirrors the per-strategy resolution in `KiloProviderDescriptor`:
+/// - `.api`: explicit `apiKey`, falling back to `KILO_API_KEY` env var.
+/// - `.cli`: token from `~/.local/share/kilo/auth.json` (`kilo.access`).
+/// - `.auto`: API first, falling back to CLI when API credentials are missing.
+public enum KiloBearerTokenResolver {
+    public static func resolve(
+        source: KiloUsageDataSource,
+        apiKey: String?,
+        environment: [String: String] = ProcessInfo.processInfo.environment) throws -> KiloResolvedBearerToken
+    {
+        switch source {
+        case .api:
+            return try self.resolveAPI(apiKey: apiKey, environment: environment)
+        case .cli:
+            return try self.resolveCLI(environment: environment)
+        case .auto:
+            if let resolved = try? self.resolveAPI(apiKey: apiKey, environment: environment) {
+                return resolved
+            }
+            return try self.resolveCLI(environment: environment)
+        }
+    }
+
+    private static func resolveAPI(
+        apiKey: String?,
+        environment: [String: String]) throws -> KiloResolvedBearerToken
+    {
+        let direct = KiloSettingsReader.cleaned(apiKey)
+        let envValue = KiloSettingsReader.cleaned(environment[KiloSettingsReader.apiTokenKey])
+        if let token = direct ?? envValue {
+            return KiloResolvedBearerToken(token: token, sourceLabel: "api")
+        }
+        throw KiloUsageError.missingCredentials
+    }
+
+    private static func resolveCLI(
+        environment: [String: String]) throws -> KiloResolvedBearerToken
+    {
+        let url = self.authFileURL(environment: environment)
+        guard FileManager.default.fileExists(atPath: url.path) else {
+            throw KiloUsageError.cliSessionMissing(url.path)
+        }
+        let data: Data
+        do {
+            data = try Data(contentsOf: url)
+        } catch {
+            throw KiloUsageError.cliSessionUnreadable(url.path)
+        }
+        guard let token = KiloSettingsReader.parseAuthToken(data: data) else {
+            throw KiloUsageError.cliSessionInvalid(url.path)
+        }
+        return KiloResolvedBearerToken(token: token, sourceLabel: "cli")
+    }
+
+    static func authFileURL(environment: [String: String]) -> URL {
+        if let home = KiloSettingsReader.cleaned(environment["HOME"]) {
+            let expandedHome = NSString(string: home).expandingTildeInPath
+            return KiloSettingsReader.defaultAuthFileURL(
+                homeDirectory: URL(fileURLWithPath: expandedHome, isDirectory: true))
+        }
+        return KiloSettingsReader.defaultAuthFileURL(
+            homeDirectory: FileManager.default.homeDirectoryForCurrentUser)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Kilo/KiloOrganization.swift b/Sources/CodexBarCore/Providers/Kilo/KiloOrganization.swift
new file mode 100644
index 0000000000..46b43fad6f
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Kilo/KiloOrganization.swift
@@ -0,0 +1,13 @@
+import Foundation
+
+public struct KiloOrganization: Codable, Sendable, Equatable, Hashable, Identifiable {
+    public let id: String
+    public let name: String
+    public let role: String?
+
+    public init(id: String, name: String, role: String? = nil) {
+        self.id = id
+        self.name = name
+        self.role = role
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Kilo/KiloProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Kilo/KiloProviderDescriptor.swift
index 091bef8464..0fd75324ff 100644
--- a/Sources/CodexBarCore/Providers/Kilo/KiloProviderDescriptor.swift
+++ b/Sources/CodexBarCore/Providers/Kilo/KiloProviderDescriptor.swift
@@ -1,9 +1,8 @@
-import CodexBarMacroSupport
 import Foundation
 
-@ProviderDescriptorRegistration
-@ProviderDescriptorDefinition
 public enum KiloProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
     static func makeDescriptor() -> ProviderDescriptor {
         ProviderDescriptor(
             id: .kilo,
@@ -22,7 +21,7 @@ public enum KiloProviderDescriptor {
                 isPrimaryProvider: false,
                 usesAccountFallback: false,
                 browserCookieOrder: nil,
-                dashboardURL: "https://app.kilo.ai/account/usage",
+                dashboardURL: "https://app.kilo.ai/usage",
                 statusPageURL: nil),
             branding: ProviderBranding(
                 iconStyle: .kilo,
diff --git a/Sources/CodexBarCore/Providers/Kilo/KiloSettingsReader.swift b/Sources/CodexBarCore/Providers/Kilo/KiloSettingsReader.swift
index b32f88b984..e315fc2e60 100644
--- a/Sources/CodexBarCore/Providers/Kilo/KiloSettingsReader.swift
+++ b/Sources/CodexBarCore/Providers/Kilo/KiloSettingsReader.swift
@@ -44,8 +44,7 @@ public enum KiloSettingsReader {
         if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
             (value.hasPrefix("'") && value.hasSuffix("'"))
         {
-            value.removeFirst()
-            value.removeLast()
+            value = String(value.dropFirst().dropLast())
         }
 
         value = value.trimmingCharacters(in: .whitespacesAndNewlines)
diff --git a/Sources/CodexBarCore/Providers/Kilo/KiloUsageFetcher.swift b/Sources/CodexBarCore/Providers/Kilo/KiloUsageFetcher.swift
index a274b113a3..59135ff8f8 100644
--- a/Sources/CodexBarCore/Providers/Kilo/KiloUsageFetcher.swift
+++ b/Sources/CodexBarCore/Providers/Kilo/KiloUsageFetcher.swift
@@ -234,6 +234,7 @@ public enum KiloUsageError: LocalizedError, Sendable, Equatable {
     }
 }
 
+// swiftlint:disable:next type_body_length
 public struct KiloUsageFetcher: Sendable {
     private struct KiloPassFields {
         let used: Double?
@@ -257,6 +258,7 @@ public struct KiloUsageFetcher: Sendable {
 
     public static func fetchUsage(
         apiKey: String,
+        scope: KiloUsageScope = .personal,
         environment: [String: String] = ProcessInfo.processInfo.environment) async throws -> KiloUsageSnapshot
     {
         guard !apiKey.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
@@ -264,39 +266,186 @@ public struct KiloUsageFetcher: Sendable {
         }
 
         let baseURL = KiloSettingsReader.apiURL(environment: environment)
-        let batchURL = try self.makeBatchURL(baseURL: baseURL)
+        let request = try self.makeRequest(baseURL: baseURL, apiKey: apiKey, scope: scope)
+
+        let response: ProviderHTTPResponse
+        do {
+            response = try await ProviderHTTPClient.shared.response(for: request)
+        } catch {
+            throw KiloUsageError.networkError(error.localizedDescription)
+        }
+
+        if let mapped = self.statusError(for: response.statusCode) {
+            throw mapped
+        }
+
+        guard response.statusCode == 200 else {
+            throw KiloUsageError.apiError(response.statusCode)
+        }
+
+        return try self.parseSnapshot(data: response.data)
+    }
+
+    static func _buildBatchURLForTesting(baseURL: URL) throws -> URL {
+        try self.makeBatchURL(baseURL: baseURL)
+    }
 
+    static func _buildRequestForTesting(
+        baseURL: URL,
+        apiKey: String,
+        scope: KiloUsageScope) throws -> URLRequest
+    {
+        try self.makeRequest(baseURL: baseURL, apiKey: apiKey, scope: scope)
+    }
+
+    private static func makeRequest(
+        baseURL: URL,
+        apiKey: String,
+        scope: KiloUsageScope) throws -> URLRequest
+    {
+        let batchURL = try self.makeBatchURL(baseURL: baseURL)
         var request = URLRequest(url: batchURL)
         request.httpMethod = "GET"
         request.timeoutInterval = 15
         request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
         request.setValue("application/json", forHTTPHeaderField: "Accept")
+        if let orgId = scope.organizationID {
+            request.setValue(orgId, forHTTPHeaderField: "X-KILOCODE-ORGANIZATIONID")
+        }
+        return request
+    }
+
+    public static func fetchOrganizations(
+        apiKey: String,
+        environment: [String: String] = ProcessInfo.processInfo.environment) async throws -> [KiloOrganization]
+    {
+        guard !apiKey.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+            throw KiloUsageError.missingCredentials
+        }
+
+        let baseURL = KiloSettingsReader.apiURL(environment: environment)
+        let trpcRequest = try self.makeOrgListTRPCRequest(baseURL: baseURL, apiKey: apiKey)
 
-        let data: Data
-        let response: URLResponse
         do {
-            (data, response) = try await URLSession.shared.data(for: request)
+            let response = try await ProviderHTTPClient.shared.response(for: trpcRequest)
+            if response.statusCode == 404 {
+                return try await self.fetchOrganizationsRESTFallback(apiKey: apiKey)
+            }
+            if let mapped = self.statusError(for: response.statusCode) {
+                throw mapped
+            }
+            return try self.parseOrganizations(data: response.data)
+        } catch let error as KiloUsageError {
+            throw error
         } catch {
             throw KiloUsageError.networkError(error.localizedDescription)
         }
+    }
+
+    static func _parseOrganizationsForTesting(_ data: Data) throws -> [KiloOrganization] {
+        try self.parseOrganizations(data: data)
+    }
 
-        guard let httpResponse = response as? HTTPURLResponse else {
-            throw KiloUsageError.networkError("Invalid response")
+    private static func makeOrgListTRPCRequest(
+        baseURL: URL,
+        apiKey: String) throws -> URLRequest
+    {
+        let endpoint = baseURL.appendingPathComponent("user.getOrganizations")
+        let inputData = try JSONSerialization.data(
+            withJSONObject: ["0": ["json": NSNull()]] as [String: Any])
+        guard let inputString = String(data: inputData, encoding: .utf8),
+              var components = URLComponents(url: endpoint, resolvingAgainstBaseURL: false)
+        else {
+            throw KiloUsageError.parseFailed("Invalid org list endpoint")
+        }
+        components.queryItems = [
+            URLQueryItem(name: "batch", value: "1"),
+            URLQueryItem(name: "input", value: inputString),
+        ]
+        guard let url = components.url else {
+            throw KiloUsageError.parseFailed("Invalid org list endpoint")
         }
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.timeoutInterval = 15
+        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        return request
+    }
+
+    private static func fetchOrganizationsRESTFallback(apiKey: String) async throws -> [KiloOrganization] {
+        guard let url = URL(string: "https://api.kilo.ai/api/profile") else {
+            throw KiloUsageError.parseFailed("Invalid REST fallback URL")
+        }
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.timeoutInterval = 15
+        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
 
-        if let mapped = self.statusError(for: httpResponse.statusCode) {
+        let response = try await ProviderHTTPClient.shared.response(for: request)
+        if let mapped = self.statusError(for: response.statusCode) {
             throw mapped
         }
+        guard response.statusCode == 200 else {
+            throw KiloUsageError.apiError(response.statusCode)
+        }
+        return try self.parseOrganizations(data: response.data)
+    }
+
+    private static func parseOrganizations(data: Data) throws -> [KiloOrganization] {
+        guard let root = try? JSONSerialization.jsonObject(with: data) else {
+            throw KiloUsageError.parseFailed("Invalid JSON")
+        }
 
-        guard httpResponse.statusCode == 200 else {
-            throw KiloUsageError.apiError(httpResponse.statusCode)
+        // tRPC batch shape: [ { result: { data: { json: [orgs] } } } ]
+        if let entries = root as? [[String: Any]],
+           let first = entries.first,
+           let resultObject = first["result"] as? [String: Any]
+        {
+            if let dataObject = resultObject["data"] as? [String: Any],
+               let payload = dataObject["json"] as? [[String: Any]]
+            {
+                return self.decodeOrganizations(payload)
+            }
+            if let payload = resultObject["data"] as? [[String: Any]] {
+                return self.decodeOrganizations(payload)
+            }
         }
 
-        return try self.parseSnapshot(data: data)
+        // REST profile shape: { user: ..., organizations: [orgs] }
+        if let dictionary = root as? [String: Any] {
+            if let orgs = dictionary["organizations"] as? [[String: Any]] {
+                return self.decodeOrganizations(orgs)
+            }
+            // Some single-procedure tRPC shapes flatten to { result: { data: { json: { organizations: [...] }}}}
+            if let resultObject = dictionary["result"] as? [String: Any],
+               let dataObject = resultObject["data"] as? [String: Any]
+            {
+                if let payload = dataObject["json"] as? [[String: Any]] {
+                    return self.decodeOrganizations(payload)
+                }
+                if let payload = dataObject["json"] as? [String: Any],
+                   let orgs = payload["organizations"] as? [[String: Any]]
+                {
+                    return self.decodeOrganizations(orgs)
+                }
+            }
+        }
+
+        return []
     }
 
-    static func _buildBatchURLForTesting(baseURL: URL) throws -> URL {
-        try self.makeBatchURL(baseURL: baseURL)
+    private static func decodeOrganizations(_ raw: [[String: Any]]) -> [KiloOrganization] {
+        raw.compactMap { item -> KiloOrganization? in
+            guard let id = item["id"] as? String, !id.isEmpty else { return nil }
+            let name = (item["name"] as? String).map {
+                $0.trimmingCharacters(in: .whitespacesAndNewlines)
+            } ?? id
+            let role = (item["role"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines)
+            let normalizedRole = (role?.isEmpty ?? true) ? nil : role
+            return KiloOrganization(id: id, name: name.isEmpty ? id : name, role: normalizedRole)
+        }
     }
 
     static func _parseSnapshotForTesting(_ data: Data) throws -> KiloUsageSnapshot {
diff --git a/Sources/CodexBarCore/Providers/Kilo/KiloUsageScope.swift b/Sources/CodexBarCore/Providers/Kilo/KiloUsageScope.swift
new file mode 100644
index 0000000000..30369afef0
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Kilo/KiloUsageScope.swift
@@ -0,0 +1,33 @@
+import Foundation
+
+public enum KiloUsageScope: Sendable, Hashable, Equatable {
+    case personal
+    case organization(id: String, name: String)
+
+    public var scopeIdentifier: String {
+        switch self {
+        case .personal:
+            "personal"
+        case let .organization(id, _):
+            "org:\(id)"
+        }
+    }
+
+    public var organizationID: String? {
+        switch self {
+        case .personal:
+            nil
+        case let .organization(id, _):
+            id
+        }
+    }
+
+    public var displayName: String {
+        switch self {
+        case .personal:
+            "Personal"
+        case let .organization(_, name):
+            name
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Kimi/KimiAPIError.swift b/Sources/CodexBarCore/Providers/Kimi/KimiAPIError.swift
index aee5e13a01..56a73f3ae8 100644
--- a/Sources/CodexBarCore/Providers/Kimi/KimiAPIError.swift
+++ b/Sources/CodexBarCore/Providers/Kimi/KimiAPIError.swift
@@ -3,6 +3,8 @@ import Foundation
 public enum KimiAPIError: LocalizedError, Sendable, Equatable {
     case missingToken
     case invalidToken
+    case missingAPIKey
+    case invalidAPIKey
     case invalidRequest(String)
     case networkError(String)
     case apiError(String)
@@ -14,6 +16,10 @@ public enum KimiAPIError: LocalizedError, Sendable, Equatable {
             "Kimi auth token is missing. Please add your JWT token from the Kimi console."
         case .invalidToken:
             "Kimi auth token is invalid or expired. Please refresh your token."
+        case .missingAPIKey:
+            "Kimi Code API key is missing. Add it in Settings > Providers > Kimi or set KIMI_CODE_API_KEY."
+        case .invalidAPIKey:
+            "Kimi Code API key is invalid or expired. Please refresh your API key."
         case let .invalidRequest(message):
             "Invalid request: \(message)"
         case let .networkError(message):
diff --git a/Sources/CodexBarCore/Providers/Kimi/KimiCookieImporter.swift b/Sources/CodexBarCore/Providers/Kimi/KimiCookieImporter.swift
index 3ede44a7c4..b3f6deef69 100644
--- a/Sources/CodexBarCore/Providers/Kimi/KimiCookieImporter.swift
+++ b/Sources/CodexBarCore/Providers/Kimi/KimiCookieImporter.swift
@@ -54,7 +54,7 @@ public enum KimiCookieImporter {
     {
         let query = BrowserCookieQuery(domains: self.cookieDomains)
         let log: (String) -> Void = { msg in self.emit(msg, logger: logger) }
-        let sources = try Self.cookieClient.records(
+        let sources = try Self.cookieClient.codexBarRecords(
             matching: query,
             in: browserSource,
             logger: log)
diff --git a/Sources/CodexBarCore/Providers/Kimi/KimiModels.swift b/Sources/CodexBarCore/Providers/Kimi/KimiModels.swift
index 62ed83cc13..f1aa6a7a59 100644
--- a/Sources/CodexBarCore/Providers/Kimi/KimiModels.swift
+++ b/Sources/CodexBarCore/Providers/Kimi/KimiModels.swift
@@ -4,6 +4,11 @@ struct KimiUsageResponse: Codable {
     let usages: [KimiUsage]
 }
 
+struct KimiCodeAPIUsageResponse: Codable {
+    let usage: KimiUsageDetail
+    let limits: [KimiRateLimit]?
+}
+
 struct KimiUsage: Codable {
     let scope: String
     let detail: KimiUsageDetail
@@ -12,16 +17,76 @@ struct KimiUsage: Codable {
 
 public struct KimiUsageDetail: Codable, Sendable {
     public let limit: String
-    public let used: String? // Optional because rate limit detail doesn't have this
+    public let used: String?
     public let remaining: String?
-    public let resetTime: String
+    public let resetTime: String?
 
-    public init(limit: String, used: String?, remaining: String?, resetTime: String) {
+    private enum CodingKeys: String, CodingKey {
+        case limit
+        case used
+        case remaining
+        case resetTime
+        case resetAt
+        case resetTimeSnake = "reset_time"
+        case resetAtSnake = "reset_at"
+    }
+
+    public init(limit: String, used: String?, remaining: String?, resetTime: String?) {
         self.limit = limit
         self.used = used
         self.remaining = remaining
         self.resetTime = resetTime
     }
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        guard let limit = Self.stringValue(in: container, forKey: .limit) else {
+            throw DecodingError.keyNotFound(
+                CodingKeys.limit,
+                DecodingError.Context(
+                    codingPath: container.codingPath,
+                    debugDescription: "Kimi usage limit is missing"))
+        }
+
+        self.limit = limit
+        self.used = Self.stringValue(in: container, forKey: .used)
+        self.remaining = Self.stringValue(in: container, forKey: .remaining)
+        self.resetTime =
+            Self.stringValue(in: container, forKey: .resetTime) ??
+            Self.stringValue(in: container, forKey: .resetAt) ??
+            Self.stringValue(in: container, forKey: .resetTimeSnake) ??
+            Self.stringValue(in: container, forKey: .resetAtSnake)
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encode(self.limit, forKey: .limit)
+        try container.encodeIfPresent(self.used, forKey: .used)
+        try container.encodeIfPresent(self.remaining, forKey: .remaining)
+        try container.encodeIfPresent(self.resetTime, forKey: .resetTime)
+    }
+
+    private static func stringValue(
+        in container: KeyedDecodingContainer<CodingKeys>,
+        forKey key: CodingKeys) -> String?
+    {
+        if let value = try? container.decode(String.self, forKey: key) {
+            return value
+        }
+        if let value = try? container.decode(Int64.self, forKey: key) {
+            return String(value)
+        }
+        if let value = try? container.decode(Double.self, forKey: key) {
+            if value.rounded(.towardZero) == value,
+               value >= Double(Int64.min),
+               value <= Double(Int64.max)
+            {
+                return String(Int64(value))
+            }
+            return String(value)
+        }
+        return nil
+    }
 }
 
 struct KimiRateLimit: Codable {
diff --git a/Sources/CodexBarCore/Providers/Kimi/KimiProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Kimi/KimiProviderDescriptor.swift
index 711c20bc85..e4120444fe 100644
--- a/Sources/CodexBarCore/Providers/Kimi/KimiProviderDescriptor.swift
+++ b/Sources/CodexBarCore/Providers/Kimi/KimiProviderDescriptor.swift
@@ -1,9 +1,8 @@
-import CodexBarMacroSupport
 import Foundation
 
-@ProviderDescriptorRegistration
-@ProviderDescriptorDefinition
 public enum KimiProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
     static func makeDescriptor() -> ProviderDescriptor {
         ProviderDescriptor(
             id: .kimi,
@@ -32,13 +31,65 @@ public enum KimiProviderDescriptor {
                 supportsTokenCost: false,
                 noDataMessage: { "Kimi cost summary is not supported." }),
             fetchPlan: ProviderFetchPlan(
-                sourceModes: [.auto, .web],
-                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [KimiWebFetchStrategy()] })),
+                sourceModes: [.auto, .api, .web],
+                pipeline: ProviderFetchPipeline(resolveStrategies: self.resolveStrategies)),
             cli: ProviderCLIConfig(
                 name: "kimi",
                 aliases: ["kimi-ai"],
                 versionDetector: nil))
     }
+
+    private static func resolveStrategies(context: ProviderFetchContext) async -> [any ProviderFetchStrategy] {
+        switch context.sourceMode {
+        case .api:
+            [KimiAPIFetchStrategy()]
+        case .web:
+            [KimiWebFetchStrategy()]
+        case .auto:
+            [KimiAPIFetchStrategy(), KimiWebFetchStrategy()]
+        case .cli, .oauth:
+            []
+        }
+    }
+}
+
+struct KimiAPIFetchStrategy: ProviderFetchStrategy {
+    let id: String = "kimi.api"
+    let kind: ProviderFetchKind = .apiToken
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        context.sourceMode == .api || Self.resolveToken(environment: context.env) != nil
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        guard let apiKey = Self.resolveToken(environment: context.env) else {
+            throw KimiAPIError.missingAPIKey
+        }
+        let baseURL = try KimiSettingsReader.codeAPIBaseURL(environment: context.env)
+        let snapshot = try await KimiUsageFetcher.fetchCodeAPIUsage(
+            apiKey: apiKey,
+            baseURL: baseURL)
+        return self.makeResult(
+            usage: snapshot.toUsageSnapshot(),
+            sourceLabel: "api")
+    }
+
+    func shouldFallback(on error: Error, context: ProviderFetchContext) -> Bool {
+        guard context.sourceMode == .auto else { return false }
+        if error is CancellationError { return false }
+        if let urlError = error as? URLError {
+            return urlError.code != .cancelled
+        }
+        if case KimiAPIError.missingAPIKey = error { return true }
+        if case KimiAPIError.invalidAPIKey = error { return true }
+        if case KimiAPIError.apiError = error { return true }
+        if error is DecodingError { return true }
+        return false
+    }
+
+    private static func resolveToken(environment: [String: String]) -> String? {
+        ProviderTokenResolver.kimiAPIToken(environment: environment)
+    }
 }
 
 struct KimiWebFetchStrategy: ProviderFetchStrategy {
diff --git a/Sources/CodexBarCore/Providers/Kimi/KimiSettingsReader.swift b/Sources/CodexBarCore/Providers/Kimi/KimiSettingsReader.swift
index bcb29d9c09..865098b974 100644
--- a/Sources/CodexBarCore/Providers/Kimi/KimiSettingsReader.swift
+++ b/Sources/CodexBarCore/Providers/Kimi/KimiSettingsReader.swift
@@ -1,11 +1,39 @@
 import Foundation
 
 public enum KimiSettingsReader {
+    public static let apiKeyEnvironmentKeys = ["KIMI_CODE_API_KEY"]
+    public static let codeAPIBaseURLEnvironmentKey = "KIMI_CODE_BASE_URL"
+    public static let defaultCodeAPIBaseURL = URL(string: "https://api.kimi.com")!
+
     public static func authToken(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
         let raw = environment["KIMI_AUTH_TOKEN"] ?? environment["kimi_auth_token"]
         return self.cleaned(raw)
     }
 
+    public static func apiKey(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        for key in self.apiKeyEnvironmentKeys {
+            if let value = self.cleaned(environment[key]) {
+                return value
+            }
+        }
+        return nil
+    }
+
+    public static func codeAPIBaseURL(
+        environment: [String: String] = ProcessInfo.processInfo.environment) throws -> URL
+    {
+        guard let raw = self.cleaned(environment[self.codeAPIBaseURLEnvironmentKey]) else {
+            return self.defaultCodeAPIBaseURL
+        }
+
+        guard URL(string: raw)?.scheme != nil,
+              let url = ProviderEndpointOverrideValidator().validatedURL(raw)
+        else {
+            throw KimiAPIError.invalidRequest("Kimi Code API base URL must use HTTPS without user info")
+        }
+        return url
+    }
+
     private static func cleaned(_ raw: String?) -> String? {
         guard var value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
             return nil
@@ -14,8 +42,7 @@ public enum KimiSettingsReader {
         if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
             (value.hasPrefix("'") && value.hasSuffix("'"))
         {
-            value.removeFirst()
-            value.removeLast()
+            value = String(value.dropFirst().dropLast())
         }
 
         value = value.trimmingCharacters(in: .whitespacesAndNewlines)
diff --git a/Sources/CodexBarCore/Providers/Kimi/KimiUsageFetcher.swift b/Sources/CodexBarCore/Providers/Kimi/KimiUsageFetcher.swift
index c6d6c2a2ec..903b475b28 100644
--- a/Sources/CodexBarCore/Providers/Kimi/KimiUsageFetcher.swift
+++ b/Sources/CodexBarCore/Providers/Kimi/KimiUsageFetcher.swift
@@ -9,6 +9,48 @@ public struct KimiUsageFetcher: Sendable {
     private static let usageURL =
         URL(string: "https://www.kimi.com/apiv2/kimi.gateway.billing.v1.BillingService/GetUsages")!
 
+    public static func fetchCodeAPIUsage(
+        apiKey: String,
+        baseURL: URL = KimiSettingsReader.defaultCodeAPIBaseURL,
+        now: Date = Date()) async throws -> KimiUsageSnapshot
+    {
+        guard !apiKey.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+            throw KimiAPIError.missingAPIKey
+        }
+
+        guard let validatedBaseURL = ProviderEndpointOverrideValidator().validatedURL(baseURL.absoluteString) else {
+            throw KimiAPIError.invalidRequest("Kimi Code API base URL must use HTTPS without user info")
+        }
+
+        let endpoint = self.codeAPIUsageEndpoint(baseURL: validatedBaseURL)
+        var request = URLRequest(url: endpoint)
+        request.httpMethod = "GET"
+        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+
+        let response = try await ProviderHTTPClient.shared.response(for: request)
+        let data = response.data
+        guard response.statusCode == 200 else {
+            let responseBody = String(data: data, encoding: .utf8) ?? "<binary data>"
+            Self.log.error("Kimi Code API returned \(response.statusCode): \(responseBody)")
+            throw self.codeAPIError(statusCode: response.statusCode)
+        }
+
+        return try self.parseCodeAPIUsage(from: data, now: now)
+    }
+
+    static func _parseCodeAPIUsageForTesting(_ data: Data, now: Date = Date()) throws -> KimiUsageSnapshot {
+        try self.parseCodeAPIUsage(from: data, now: now)
+    }
+
+    static func _codeAPIUsageEndpointForTesting(baseURL: URL) -> URL {
+        self.codeAPIUsageEndpoint(baseURL: baseURL)
+    }
+
+    static func _codeAPIErrorForTesting(statusCode: Int) -> KimiAPIError {
+        self.codeAPIError(statusCode: statusCode)
+    }
+
     public static func fetchUsage(authToken: String, now: Date = Date()) async throws -> KimiUsageSnapshot {
         // Decode JWT to get session info
         let sessionInfo = self.decodeSessionInfo(from: authToken)
@@ -46,25 +88,22 @@ public struct KimiUsageFetcher: Sendable {
         let requestBody = ["scope": ["FEATURE_CODING"]]
         request.httpBody = try? JSONSerialization.data(withJSONObject: requestBody)
 
-        let (data, response) = try await URLSession.shared.data(for: request)
-        guard let httpResponse = response as? HTTPURLResponse else {
-            throw KimiAPIError.networkError("Invalid response")
-        }
-
-        guard httpResponse.statusCode == 200 else {
+        let response = try await ProviderHTTPClient.shared.response(for: request)
+        let data = response.data
+        guard response.statusCode == 200 else {
             let responseBody = String(data: data, encoding: .utf8) ?? "<binary data>"
-            Self.log.error("Kimi API returned \(httpResponse.statusCode): \(responseBody)")
+            Self.log.error("Kimi API returned \(response.statusCode): \(responseBody)")
 
-            if httpResponse.statusCode == 401 {
+            if response.statusCode == 401 {
                 throw KimiAPIError.invalidToken
             }
-            if httpResponse.statusCode == 403 {
+            if response.statusCode == 403 {
                 throw KimiAPIError.invalidToken
             }
-            if httpResponse.statusCode == 400 {
+            if response.statusCode == 400 {
                 throw KimiAPIError.invalidRequest("Bad request")
             }
-            throw KimiAPIError.apiError("HTTP \(httpResponse.statusCode)")
+            throw KimiAPIError.apiError("HTTP \(response.statusCode)")
         }
 
         let usageResponse = try JSONDecoder().decode(KimiUsageResponse.self, from: data)
@@ -78,6 +117,44 @@ public struct KimiUsageFetcher: Sendable {
             updatedAt: now)
     }
 
+    private static func parseCodeAPIUsage(from data: Data, now: Date) throws -> KimiUsageSnapshot {
+        let response = try JSONDecoder().decode(KimiCodeAPIUsageResponse.self, from: data)
+        return KimiUsageSnapshot(
+            weekly: response.usage,
+            rateLimit: response.limits?.first?.detail,
+            updatedAt: now)
+    }
+
+    private static func codeAPIUsageEndpoint(baseURL: URL) -> URL {
+        let normalizedPath = baseURL.path.trimmingCharacters(in: CharacterSet(charactersIn: "/"))
+        if normalizedPath == "coding/v1" || normalizedPath.hasSuffix("/coding/v1") {
+            return baseURL.appendingPathComponent("usages")
+        }
+        if normalizedPath == "coding" || normalizedPath.hasSuffix("/coding") {
+            return baseURL
+                .appendingPathComponent("v1")
+                .appendingPathComponent("usages")
+        }
+
+        return baseURL
+            .appendingPathComponent("coding")
+            .appendingPathComponent("v1")
+            .appendingPathComponent("usages")
+    }
+
+    private static func codeAPIError(statusCode: Int) -> KimiAPIError {
+        switch statusCode {
+        case 400:
+            .invalidRequest("Bad request")
+        case 401:
+            .invalidAPIKey
+        case 403:
+            .apiError("HTTP 403 (permission or quota denied)")
+        default:
+            .apiError("HTTP \(statusCode)")
+        }
+    }
+
     private static func decodeSessionInfo(from jwt: String) -> SessionInfo? {
         let parts = jwt.split(separator: ".", maxSplits: 2)
         guard parts.count == 3 else { return nil }
diff --git a/Sources/CodexBarCore/Providers/Kimi/KimiUsageSnapshot.swift b/Sources/CodexBarCore/Providers/Kimi/KimiUsageSnapshot.swift
index c39e1602a7..d19ff420d1 100644
--- a/Sources/CodexBarCore/Providers/Kimi/KimiUsageSnapshot.swift
+++ b/Sources/CodexBarCore/Providers/Kimi/KimiUsageSnapshot.swift
@@ -11,8 +11,8 @@ public struct KimiUsageSnapshot: Sendable {
         self.updatedAt = updatedAt
     }
 
-    private static func parseDate(_ dateString: String) -> Date? {
-        // Handle ISO 8601 format like: 2026-01-09T15:23:13.716839300Z
+    private static func parseDate(_ dateString: String?) -> Date? {
+        guard let dateString else { return nil }
         let formatter = ISO8601DateFormatter()
         formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
         if let date = formatter.date(from: dateString) {
diff --git a/Sources/CodexBarCore/Providers/KimiK2/KimiK2ProviderDescriptor.swift b/Sources/CodexBarCore/Providers/KimiK2/KimiK2ProviderDescriptor.swift
index cc986b6f08..6b7a4383a3 100644
--- a/Sources/CodexBarCore/Providers/KimiK2/KimiK2ProviderDescriptor.swift
+++ b/Sources/CodexBarCore/Providers/KimiK2/KimiK2ProviderDescriptor.swift
@@ -1,28 +1,27 @@
-import CodexBarMacroSupport
 import Foundation
 
-@ProviderDescriptorRegistration
-@ProviderDescriptorDefinition
 public enum KimiK2ProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
     static func makeDescriptor() -> ProviderDescriptor {
         ProviderDescriptor(
             id: .kimik2,
             metadata: ProviderMetadata(
                 id: .kimik2,
-                displayName: "Kimi K2",
+                displayName: "Kimi K2 (unofficial)",
                 sessionLabel: "Credits",
                 weeklyLabel: "Credits",
                 opusLabel: nil,
                 supportsOpus: false,
                 supportsCredits: false,
                 creditsHint: "",
-                toggleTitle: "Show Kimi K2 usage",
+                toggleTitle: "Show unofficial Kimi K2 usage",
                 cliName: "kimik2",
                 defaultEnabled: false,
                 isPrimaryProvider: false,
                 usesAccountFallback: false,
                 browserCookieOrder: nil,
-                dashboardURL: "https://kimi-k2.ai/my-credits",
+                dashboardURL: nil,
                 statusPageURL: nil),
             branding: ProviderBranding(
                 iconStyle: .kimi,
@@ -30,40 +29,17 @@ public enum KimiK2ProviderDescriptor {
                 color: ProviderColor(red: 76 / 255, green: 0 / 255, blue: 255 / 255)),
             tokenCost: ProviderTokenCostConfig(
                 supportsTokenCost: false,
-                noDataMessage: { "Kimi K2 cost summary is not available." }),
-            fetchPlan: ProviderFetchPlan(
-                sourceModes: [.auto, .api],
-                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [KimiK2APIFetchStrategy()] })),
+                noDataMessage: { "Unofficial Kimi K2 cost summary is not available." }),
+            fetchPlan: .apiToken(
+                strategyID: "kimik2.api",
+                resolveToken: { ProviderTokenResolver.kimiK2Token(environment: $0) },
+                missingCredentialsError: { KimiK2UsageError.missingCredentials },
+                loadUsage: { apiKey, _ in
+                    try await KimiK2UsageFetcher.fetchUsage(apiKey: apiKey).toUsageSnapshot()
+                }),
             cli: ProviderCLIConfig(
                 name: "kimik2",
                 aliases: ["kimi-k2", "kimiK2"],
                 versionDetector: nil))
     }
 }
-
-struct KimiK2APIFetchStrategy: ProviderFetchStrategy {
-    let id: String = "kimik2.api"
-    let kind: ProviderFetchKind = .apiToken
-
-    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
-        Self.resolveToken(environment: context.env) != nil
-    }
-
-    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
-        guard let apiKey = Self.resolveToken(environment: context.env) else {
-            throw KimiK2UsageError.missingCredentials
-        }
-        let usage = try await KimiK2UsageFetcher.fetchUsage(apiKey: apiKey)
-        return self.makeResult(
-            usage: usage.toUsageSnapshot(),
-            sourceLabel: "api")
-    }
-
-    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
-        false
-    }
-
-    private static func resolveToken(environment: [String: String]) -> String? {
-        ProviderTokenResolver.kimiK2Token(environment: environment)
-    }
-}
diff --git a/Sources/CodexBarCore/Providers/KimiK2/KimiK2SettingsReader.swift b/Sources/CodexBarCore/Providers/KimiK2/KimiK2SettingsReader.swift
index 3e59199d45..507e597dce 100644
--- a/Sources/CodexBarCore/Providers/KimiK2/KimiK2SettingsReader.swift
+++ b/Sources/CodexBarCore/Providers/KimiK2/KimiK2SettingsReader.swift
@@ -29,8 +29,7 @@ public struct KimiK2SettingsReader: Sendable {
         if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
             (value.hasPrefix("'") && value.hasSuffix("'"))
         {
-            value.removeFirst()
-            value.removeLast()
+            value = String(value.dropFirst().dropLast())
         }
         return value.trimmingCharacters(in: .whitespacesAndNewlines)
     }
diff --git a/Sources/CodexBarCore/Providers/KimiK2/KimiK2UsageFetcher.swift b/Sources/CodexBarCore/Providers/KimiK2/KimiK2UsageFetcher.swift
index 775e109bf9..22f9255e64 100644
--- a/Sources/CodexBarCore/Providers/KimiK2/KimiK2UsageFetcher.swift
+++ b/Sources/CodexBarCore/Providers/KimiK2/KimiK2UsageFetcher.swift
@@ -29,26 +29,13 @@ public struct KimiK2UsageSummary: Sendable {
     }
 
     public func toUsageSnapshot() -> UsageSnapshot {
-        let total = max(0, self.consumed + self.remaining)
-        let usedPercent: Double = if total > 0 {
-            min(100, max(0, (self.consumed / total) * 100))
-        } else {
-            0
-        }
-        let usedText = String(format: "%.0f", self.consumed)
-        let totalText = String(format: "%.0f", total)
-        let rateWindow = RateWindow(
-            usedPercent: usedPercent,
-            windowMinutes: nil,
-            resetsAt: nil,
-            resetDescription: total > 0 ? "Credits: \(usedText)/\(totalText)" : nil)
         let identity = ProviderIdentitySnapshot(
             providerID: .kimik2,
             accountEmail: nil,
             accountOrganization: nil,
-            loginMethod: nil)
+            loginMethod: "Credits: \(UsageFormatter.creditsString(from: self.remaining))")
         return UsageSnapshot(
-            primary: rateWindow,
+            primary: nil,
             secondary: nil,
             tertiary: nil,
             providerCost: nil,
@@ -136,15 +123,11 @@ public struct KimiK2UsageFetcher: Sendable {
         request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
         request.setValue("application/json", forHTTPHeaderField: "Accept")
 
-        let (data, response) = try await URLSession.shared.data(for: request)
-
-        guard let httpResponse = response as? HTTPURLResponse else {
-            throw KimiK2UsageError.networkError("Invalid response")
-        }
-
-        guard httpResponse.statusCode == 200 else {
-            let body = String(data: data, encoding: .utf8) ?? "HTTP \(httpResponse.statusCode)"
-            Self.log.error("Kimi K2 API returned \(httpResponse.statusCode): \(body)")
+        let response = try await ProviderHTTPClient.shared.response(for: request)
+        let data = response.data
+        guard response.statusCode == 200 else {
+            let body = String(data: data, encoding: .utf8) ?? "HTTP \(response.statusCode)"
+            Self.log.error("Kimi K2 API returned \(response.statusCode): \(body)")
             throw KimiK2UsageError.apiError(body)
         }
 
@@ -152,7 +135,7 @@ public struct KimiK2UsageFetcher: Sendable {
             Self.log.debug("Kimi K2 API response: \(jsonString)")
         }
 
-        let summary = try Self.parseSummary(data: data, headers: httpResponse.allHeaderFields)
+        let summary = try Self.parseSummary(data: data, headers: response.response.allHeaderFields)
         return KimiK2UsageSnapshot(summary: summary)
     }
 
diff --git a/Sources/CodexBarCore/Providers/Kiro/KiroProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Kiro/KiroProviderDescriptor.swift
index ad006df0df..804b346c08 100644
--- a/Sources/CodexBarCore/Providers/Kiro/KiroProviderDescriptor.swift
+++ b/Sources/CodexBarCore/Providers/Kiro/KiroProviderDescriptor.swift
@@ -1,9 +1,8 @@
-import CodexBarMacroSupport
 import Foundation
 
-@ProviderDescriptorRegistration
-@ProviderDescriptorDefinition
 public enum KiroProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
     static func makeDescriptor() -> ProviderDescriptor {
         ProviderDescriptor(
             id: .kiro,
diff --git a/Sources/CodexBarCore/Providers/Kiro/KiroStatusProbe.swift b/Sources/CodexBarCore/Providers/Kiro/KiroStatusProbe.swift
index 2e90d136ab..126027224d 100644
--- a/Sources/CodexBarCore/Providers/Kiro/KiroStatusProbe.swift
+++ b/Sources/CodexBarCore/Providers/Kiro/KiroStatusProbe.swift
@@ -1,16 +1,69 @@
 import Foundation
+#if canImport(Darwin)
+import Darwin
+#elseif canImport(Glibc)
+import Glibc
+#elseif canImport(Musl)
+import Musl
+#endif
 
 public struct KiroUsageSnapshot: Sendable {
     public let planName: String
+    public let displayPlanName: String
+    public let accountEmail: String?
+    public let authMethod: String?
     public let creditsUsed: Double
     public let creditsTotal: Double
     public let creditsPercent: Double
     public let bonusCreditsUsed: Double?
     public let bonusCreditsTotal: Double?
     public let bonusExpiryDays: Int?
+    public let overagesStatus: String?
+    public let overageCreditsUsed: Double?
+    public let estimatedOverageCostUSD: Double?
+    public let manageURL: String?
+    public let contextUsage: KiroContextUsageSnapshot?
     public let resetsAt: Date?
     public let updatedAt: Date
 
+    public init(
+        planName: String,
+        displayPlanName: String? = nil,
+        accountEmail: String? = nil,
+        authMethod: String? = nil,
+        creditsUsed: Double,
+        creditsTotal: Double,
+        creditsPercent: Double,
+        bonusCreditsUsed: Double?,
+        bonusCreditsTotal: Double?,
+        bonusExpiryDays: Int?,
+        overagesStatus: String? = nil,
+        overageCreditsUsed: Double? = nil,
+        estimatedOverageCostUSD: Double? = nil,
+        manageURL: String? = nil,
+        contextUsage: KiroContextUsageSnapshot? = nil,
+        resetsAt: Date?,
+        updatedAt: Date)
+    {
+        self.planName = planName
+        self.displayPlanName = displayPlanName ?? KiroStatusProbe.displayPlanName(planName)
+        self.accountEmail = accountEmail
+        self.authMethod = authMethod
+        self.creditsUsed = creditsUsed
+        self.creditsTotal = creditsTotal
+        self.creditsPercent = creditsPercent
+        self.bonusCreditsUsed = bonusCreditsUsed
+        self.bonusCreditsTotal = bonusCreditsTotal
+        self.bonusExpiryDays = bonusExpiryDays
+        self.overagesStatus = overagesStatus
+        self.overageCreditsUsed = overageCreditsUsed
+        self.estimatedOverageCostUSD = estimatedOverageCostUSD
+        self.manageURL = manageURL
+        self.contextUsage = contextUsage
+        self.resetsAt = resetsAt
+        self.updatedAt = updatedAt
+    }
+
     public func toUsageSnapshot() -> UsageSnapshot {
         let primary = RateWindow(
             usedPercent: self.creditsPercent,
@@ -37,19 +90,116 @@ public struct KiroUsageSnapshot: Sendable {
 
         let identity = ProviderIdentitySnapshot(
             providerID: .kiro,
-            accountEmail: nil,
-            accountOrganization: self.planName,
-            loginMethod: self.planName)
+            accountEmail: self.accountEmail,
+            accountOrganization: nil,
+            loginMethod: self.authMethod)
+
+        let kiroUsage = KiroUsageDetails(
+            planName: self.planName,
+            displayPlanName: self.displayPlanName,
+            creditsUsed: self.creditsUsed,
+            creditsTotal: self.creditsTotal,
+            creditsRemaining: self.creditsRemaining,
+            bonusCreditsUsed: self.bonusCreditsUsed,
+            bonusCreditsTotal: self.bonusCreditsTotal,
+            bonusCreditsRemaining: self.bonusCreditsRemaining,
+            bonusExpiryDays: self.bonusExpiryDays,
+            overagesStatus: self.overagesStatus,
+            overageCreditsUsed: self.overageCreditsUsed,
+            estimatedOverageCostUSD: self.estimatedOverageCostUSD,
+            manageURL: self.manageURL,
+            contextUsage: self.contextUsage)
 
         return UsageSnapshot(
             primary: primary,
             secondary: secondary,
             tertiary: nil,
+            kiroUsage: kiroUsage,
             providerCost: nil,
             zaiUsage: nil,
             updatedAt: self.updatedAt,
             identity: identity)
     }
+
+    public var creditsRemaining: Double {
+        max(0, self.creditsTotal - self.creditsUsed)
+    }
+
+    public var bonusCreditsRemaining: Double? {
+        guard let bonusCreditsUsed, let bonusCreditsTotal else { return nil }
+        return max(0, bonusCreditsTotal - bonusCreditsUsed)
+    }
+}
+
+public struct KiroContextUsageSnapshot: Codable, Equatable, Sendable {
+    public let totalPercentUsed: Double
+    public let contextFilesPercent: Double?
+    public let toolsPercent: Double?
+    public let kiroResponsesPercent: Double?
+    public let promptsPercent: Double?
+
+    public init(
+        totalPercentUsed: Double,
+        contextFilesPercent: Double?,
+        toolsPercent: Double?,
+        kiroResponsesPercent: Double?,
+        promptsPercent: Double?)
+    {
+        self.totalPercentUsed = totalPercentUsed
+        self.contextFilesPercent = contextFilesPercent
+        self.toolsPercent = toolsPercent
+        self.kiroResponsesPercent = kiroResponsesPercent
+        self.promptsPercent = promptsPercent
+    }
+}
+
+public struct KiroUsageDetails: Codable, Equatable, Sendable {
+    public let planName: String
+    public let displayPlanName: String
+    public let creditsUsed: Double
+    public let creditsTotal: Double
+    public let creditsRemaining: Double
+    public let bonusCreditsUsed: Double?
+    public let bonusCreditsTotal: Double?
+    public let bonusCreditsRemaining: Double?
+    public let bonusExpiryDays: Int?
+    public let overagesStatus: String?
+    public let overageCreditsUsed: Double?
+    public let estimatedOverageCostUSD: Double?
+    public let manageURL: String?
+    public let contextUsage: KiroContextUsageSnapshot?
+
+    public init(
+        planName: String,
+        displayPlanName: String,
+        creditsUsed: Double,
+        creditsTotal: Double,
+        creditsRemaining: Double,
+        bonusCreditsUsed: Double?,
+        bonusCreditsTotal: Double?,
+        bonusCreditsRemaining: Double?,
+        bonusExpiryDays: Int?,
+        overagesStatus: String?,
+        overageCreditsUsed: Double?,
+        estimatedOverageCostUSD: Double?,
+        manageURL: String?,
+        contextUsage: KiroContextUsageSnapshot?)
+    {
+        self.planName = planName
+        self.displayPlanName = displayPlanName
+        self.creditsUsed = creditsUsed
+        self.creditsTotal = creditsTotal
+        self.creditsRemaining = creditsRemaining
+        self.bonusCreditsUsed = bonusCreditsUsed
+        self.bonusCreditsTotal = bonusCreditsTotal
+        self.bonusCreditsRemaining = bonusCreditsRemaining
+        self.bonusExpiryDays = bonusExpiryDays
+        self.overagesStatus = overagesStatus
+        self.overageCreditsUsed = overageCreditsUsed
+        self.estimatedOverageCostUSD = estimatedOverageCostUSD
+        self.manageURL = manageURL
+        self.contextUsage = contextUsage
+    }
 }
 
 public enum KiroStatusProbeError: LocalizedError, Sendable {
@@ -76,56 +226,134 @@ public enum KiroStatusProbeError: LocalizedError, Sendable {
 }
 
 public struct KiroStatusProbe: Sendable {
-    public init() {}
+    private let cliBinaryResolver: @Sendable () -> String?
+    private let accountProbeTimeout: TimeInterval
+
+    public init() {
+        self.cliBinaryResolver = { TTYCommandRunner.which("kiro-cli") }
+        self.accountProbeTimeout = 3.0
+    }
+
+    init(cliBinaryResolver: @escaping @Sendable () -> String?, accountProbeTimeout: TimeInterval = 3.0) {
+        self.cliBinaryResolver = cliBinaryResolver
+        self.accountProbeTimeout = accountProbeTimeout
+    }
 
     private static let logger = CodexBarLog.logger(LogCategories.kiro)
 
     public static func detectVersion() -> String? {
-        let process = Process()
-        process.executableURL = URL(fileURLWithPath: "/usr/bin/env")
-        process.arguments = ["kiro-cli", "--version"]
-        let pipe = Pipe()
-        process.standardOutput = pipe
-        process.standardError = pipe
-        do {
-            try process.run()
-            process.waitUntilExit()
-            let data = pipe.fileHandleForReading.readDataToEndOfFile()
-            guard let output = String(data: data, encoding: .utf8) else { return nil }
-            // Output is like "kiro-cli 1.23.1"
-            let trimmed = output.trimmingCharacters(in: .whitespacesAndNewlines)
-            if trimmed.hasPrefix("kiro-cli ") {
-                return String(trimmed.dropFirst("kiro-cli ".count))
-            }
-            return trimmed.isEmpty ? nil : trimmed
-        } catch {
-            self.logger.debug("kiro-cli version detection failed: \(error.localizedDescription)")
+        guard let path = TTYCommandRunner.which("kiro-cli"),
+              let output = ProviderVersionDetector.run(
+                  path: path,
+                  args: ["--version"],
+                  mergeStandardError: true)
+        else {
+            self.logger.debug("kiro-cli version detection failed")
             return nil
         }
+        // Output is like "kiro-cli 1.23.1"
+        if output.hasPrefix("kiro-cli ") {
+            return String(output.dropFirst("kiro-cli ".count))
+        }
+        return output
     }
 
     public func fetch() async throws -> KiroUsageSnapshot {
-        try await self.ensureLoggedIn()
-        let output = try await self.runUsageCommand()
-        return try self.parse(output: output)
+        let accountTask = Task { await self.fetchAccountStatus() }
+
+        let output: String
+        do {
+            output = try await self.runUsageCommand()
+        } catch is CancellationError {
+            accountTask.cancel()
+            _ = await accountTask.value
+            throw CancellationError()
+        } catch {
+            if try await self.awaitAccountStatus(accountTask) == .notLoggedIn {
+                throw KiroStatusProbeError.notLoggedIn
+            }
+            throw error
+        }
+
+        var contextUsage: KiroContextUsageSnapshot?
+        do {
+            contextUsage = try await self.fetchContextUsage()
+        } catch is CancellationError {
+            accountTask.cancel()
+            _ = await accountTask.value
+            throw CancellationError()
+        } catch {
+            Self.logger.debug("Kiro context usage probe failed: \(error.localizedDescription)")
+        }
+
+        let accountStatus = try await self.awaitAccountStatus(accountTask)
+        let accountInfo = accountStatus.account
+        do {
+            return try self.parse(
+                output: output,
+                accountEmail: accountInfo?.email,
+                authMethod: accountInfo?.authMethod,
+                contextUsage: contextUsage)
+        } catch KiroStatusProbeError.parseError where accountStatus == .notLoggedIn {
+            throw KiroStatusProbeError.notLoggedIn
+        }
     }
 
-    private struct KiroCLIResult: Sendable {
+    struct KiroCLIResult {
         let stdout: String
         let stderr: String
         let terminationStatus: Int32
         let terminatedForIdle: Bool
     }
 
-    private func ensureLoggedIn() async throws {
-        let result = try await self.runCommand(arguments: ["whoami"], timeout: 5.0)
-        try self.validateWhoAmIOutput(
+    struct KiroAccountInfo: Equatable {
+        let authMethod: String?
+        let email: String?
+    }
+
+    private enum KiroAccountProbeStatus: Equatable {
+        case account(KiroAccountInfo)
+        case notLoggedIn
+        case unavailable
+
+        var account: KiroAccountInfo? {
+            guard case let .account(info) = self else { return nil }
+            return info
+        }
+    }
+
+    private func fetchAccountStatus() async -> KiroAccountProbeStatus {
+        do {
+            return try await .account(self.ensureLoggedIn())
+        } catch KiroStatusProbeError.notLoggedIn {
+            return .notLoggedIn
+        } catch {
+            Self.logger.debug("Kiro account probe failed: \(error.localizedDescription)")
+            return .unavailable
+        }
+    }
+
+    private func awaitAccountStatus(
+        _ task: Task<KiroAccountProbeStatus, Never>) async throws -> KiroAccountProbeStatus
+    {
+        let status = await withTaskCancellationHandler {
+            await task.value
+        } onCancel: {
+            task.cancel()
+        }
+        try Task.checkCancellation()
+        return status
+    }
+
+    private func ensureLoggedIn() async throws -> KiroAccountInfo {
+        let result = try await self.runCommand(arguments: ["whoami"], timeout: self.accountProbeTimeout)
+        return try self.validateWhoAmIOutput(
             stdout: result.stdout,
             stderr: result.stderr,
             terminationStatus: result.terminationStatus)
     }
 
-    func validateWhoAmIOutput(stdout: String, stderr: String, terminationStatus: Int32) throws {
+    func validateWhoAmIOutput(stdout: String, stderr: String, terminationStatus: Int32) throws -> KiroAccountInfo {
         let trimmedStdout = stdout.trimmingCharacters(in: .whitespacesAndNewlines)
         let trimmedStderr = stderr.trimmingCharacters(in: .whitespacesAndNewlines)
         let combined = trimmedStderr.isEmpty ? trimmedStdout : trimmedStderr
@@ -145,6 +373,39 @@ public struct KiroStatusProbe: Sendable {
         if combined.isEmpty {
             throw KiroStatusProbeError.cliFailed("Kiro CLI whoami returned no output.")
         }
+
+        return self.parseWhoAmIOutput(combined)
+    }
+
+    func parseWhoAmIOutput(_ output: String) -> KiroAccountInfo {
+        let stripped = Self.stripANSI(output)
+        var authMethod: String?
+        var email: String?
+        for rawLine in stripped.components(separatedBy: .newlines) {
+            let line = rawLine.trimmingCharacters(in: .whitespacesAndNewlines)
+            guard !line.isEmpty else { continue }
+            if line.localizedCaseInsensitiveContains("logged in with") {
+                authMethod = line.replacingOccurrences(
+                    of: #"(?i)^\s*logged in with\s+"#,
+                    with: "",
+                    options: [.regularExpression])
+                    .trimmingCharacters(in: .whitespacesAndNewlines)
+            } else if line.localizedCaseInsensitiveContains("email:") {
+                email = line.replacingOccurrences(
+                    of: #"(?i)^\s*email:\s*"#,
+                    with: "",
+                    options: [.regularExpression])
+                    .trimmingCharacters(in: .whitespacesAndNewlines)
+            } else if email == nil,
+                      !line.contains(" "),
+                      line.contains("@")
+            {
+                email = line
+            }
+        }
+        return KiroAccountInfo(
+            authMethod: authMethod?.nilIfEmpty,
+            email: email?.nilIfEmpty)
     }
 
     private func runUsageCommand() async throws -> String {
@@ -188,152 +449,139 @@ public struct KiroStatusProbe: Sendable {
         return result.stdout
     }
 
-    private func runCommand(
+    private func fetchContextUsage() async throws -> KiroContextUsageSnapshot? {
+        let result = try await self.runCommand(
+            arguments: ["chat", "--no-interactive", "/context"],
+            timeout: 8.0,
+            idleTimeout: 3.0)
+        let output = result.stdout.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+            ? result.stderr
+            : result.stdout
+        return self.parseContextUsage(output: output)
+    }
+
+    func runCommand(
         arguments: [String],
         timeout: TimeInterval,
         idleTimeout: TimeInterval = 5.0) async throws -> KiroCLIResult
     {
-        guard let binary = TTYCommandRunner.which("kiro-cli") else {
+        guard let binary = self.cliBinaryResolver() else {
             throw KiroStatusProbeError.cliNotFound
         }
 
-        let process = Process()
-        process.executableURL = URL(fileURLWithPath: binary)
-        process.arguments = arguments
-
         let stdoutPipe = Pipe()
         let stderrPipe = Pipe()
-        process.standardOutput = stdoutPipe
-        process.standardError = stderrPipe
-        process.standardInput = FileHandle.nullDevice
 
         var env = ProcessInfo.processInfo.environment
         env["TERM"] = "xterm-256color"
-        process.environment = env
 
-        // Thread-safe state for activity tracking
         final class ActivityState: @unchecked Sendable {
             private let lock = NSLock()
             private var _lastActivityAt = Date()
             private var _hasReceivedOutput = false
-            private var _stdoutData = Data()
-            private var _stderrData = Data()
 
             var lastActivityAt: Date {
-                self.lock.lock()
-                defer { lock.unlock() }
-                return self._lastActivityAt
+                self.lock.withLock { self._lastActivityAt }
             }
 
             var hasReceivedOutput: Bool {
-                self.lock.lock()
-                defer { lock.unlock() }
-                return self._hasReceivedOutput
-            }
-
-            func appendStdout(_ data: Data) {
-                self.lock.lock()
-                defer { lock.unlock() }
-                self._stdoutData.append(data)
-                self._lastActivityAt = Date()
-                self._hasReceivedOutput = true
+                self.lock.withLock { self._hasReceivedOutput }
             }
 
-            func appendStderr(_ data: Data) {
-                self.lock.lock()
-                defer { lock.unlock() }
-                self._stderrData.append(data)
-                self._lastActivityAt = Date()
-                self._hasReceivedOutput = true
-            }
-
-            func getOutput() -> (stdout: Data, stderr: Data) {
-                self.lock.lock()
-                defer { lock.unlock() }
-                return (self._stdoutData, self._stderrData)
+            func markActivity() {
+                self.lock.withLock {
+                    self._lastActivityAt = Date()
+                    self._hasReceivedOutput = true
+                }
             }
         }
 
         let state = ActivityState()
+        let stdoutCapture = ProcessPipeCapture(pipe: stdoutPipe, onData: { state.markActivity() })
+        let stderrCapture = ProcessPipeCapture(pipe: stderrPipe, onData: { state.markActivity() })
+        stdoutCapture.start()
+        stderrCapture.start()
 
-        // Set up readability handlers to track activity
-        stdoutPipe.fileHandleForReading.readabilityHandler = { handle in
-            let data = handle.availableData
-            if !data.isEmpty {
-                state.appendStdout(data)
-            }
-        }
-        stderrPipe.fileHandleForReading.readabilityHandler = { handle in
-            let data = handle.availableData
-            if !data.isEmpty {
-                state.appendStderr(data)
-            }
+        let process: SpawnedProcessGroup
+        do {
+            process = try SpawnedProcessGroup.launch(
+                binary: binary,
+                arguments: arguments,
+                environment: env,
+                stdoutPipe: stdoutPipe,
+                stderrPipe: stderrPipe)
+        } catch {
+            stdoutCapture.stop()
+            stderrCapture.stop()
+            throw error
         }
 
-        return try await withCheckedThrowingContinuation { continuation in
-            DispatchQueue.global().async {
-                do {
-                    try process.run()
-                } catch {
-                    stdoutPipe.fileHandleForReading.readabilityHandler = nil
-                    stderrPipe.fileHandleForReading.readabilityHandler = nil
-                    continuation.resume(throwing: error)
-                    return
-                }
+        let deadline = Date().addingTimeInterval(timeout)
+        var didHitDeadline = false
+        var didTerminateForIdle = false
 
-                let deadline = Date().addingTimeInterval(timeout)
-                var didHitDeadline = false
-                var didTerminateForIdle = false
-
-                while process.isRunning {
-                    if Date() >= deadline {
-                        didHitDeadline = true
-                        break
-                    }
-                    // Idle timeout: if we got output but then it went silent
-                    if state.hasReceivedOutput,
-                       Date().timeIntervalSince(state.lastActivityAt) >= idleTimeout
-                    {
-                        // Process went idle after producing output - likely done or stuck
-                        didTerminateForIdle = true
-                        break
-                    }
-                    Thread.sleep(forTimeInterval: 0.1)
+        do {
+            while process.isRunning {
+                try Task.checkCancellation()
+                if Date() >= deadline {
+                    didHitDeadline = true
+                    break
                 }
-
-                // Clean up handlers
-                stdoutPipe.fileHandleForReading.readabilityHandler = nil
-                stderrPipe.fileHandleForReading.readabilityHandler = nil
-
-                if process.isRunning {
-                    process.terminate()
-                    process.waitUntilExit()
-                    if didHitDeadline || !state.hasReceivedOutput {
-                        continuation.resume(throwing: KiroStatusProbeError.timeout)
-                        return
-                    }
+                if state.hasReceivedOutput,
+                   Date().timeIntervalSince(state.lastActivityAt) >= idleTimeout
+                {
+                    didTerminateForIdle = true
+                    break
                 }
+                try await Task.sleep(for: .milliseconds(100))
+            }
+        } catch {
+            await process.terminate()
+            stdoutCapture.stop()
+            stderrCapture.stop()
+            throw error
+        }
 
-                // Read any remaining data
-                let remainingStdout = stdoutPipe.fileHandleForReading.readDataToEndOfFile()
-                let remainingStderr = stderrPipe.fileHandleForReading.readDataToEndOfFile()
-
-                var output = state.getOutput()
-                output.stdout.append(remainingStdout)
-                output.stderr.append(remainingStderr)
-
-                let stdoutOutput = String(data: output.stdout, encoding: .utf8) ?? ""
-                let stderrOutput = String(data: output.stderr, encoding: .utf8) ?? ""
-                continuation.resume(returning: KiroCLIResult(
-                    stdout: stdoutOutput,
-                    stderr: stderrOutput,
-                    terminationStatus: process.terminationStatus,
-                    terminatedForIdle: didTerminateForIdle))
+        if process.isRunning {
+            await process.terminate()
+            guard !process.isRunning else {
+                stdoutCapture.stop()
+                stderrCapture.stop()
+                throw KiroStatusProbeError.timeout
+            }
+            if didHitDeadline || !state.hasReceivedOutput {
+                stdoutCapture.stop()
+                stderrCapture.stop()
+                throw KiroStatusProbeError.timeout
             }
         }
+        if process.hasResidualProcessGroup {
+            await process.terminateResidualProcesses()
+        }
+
+        async let stdoutData = stdoutCapture.finish(timeout: .seconds(1))
+        async let stderrData = stderrCapture.finish(timeout: .seconds(1))
+        let output = await (stdout: stdoutData, stderr: stderrData)
+        if !stdoutCapture.reachedEOF || !stderrCapture.reachedEOF {
+            await process.terminateResidualProcesses()
+        }
+        await process.finish()
+        guard let terminationStatus = process.terminationStatus else {
+            throw KiroStatusProbeError.timeout
+        }
+        return KiroCLIResult(
+            stdout: ProcessPipeCapture.decodeUTF8(output.stdout),
+            stderr: ProcessPipeCapture.decodeUTF8(output.stderr),
+            terminationStatus: terminationStatus,
+            terminatedForIdle: didTerminateForIdle)
     }
 
-    func parse(output: String) throws -> KiroUsageSnapshot {
+    func parse(
+        output: String,
+        accountEmail: String? = nil,
+        authMethod: String? = nil,
+        contextUsage: KiroContextUsageSnapshot? = nil) throws -> KiroUsageSnapshot
+    {
         let stripped = Self.stripANSI(output)
 
         let trimmed = stripped.trimmingCharacters(in: .whitespacesAndNewlines)
@@ -361,37 +609,15 @@ public struct KiroStatusProbe: Sendable {
         var matchedCredits = false
         var matchedNewFormat = false
 
-        // Parse plan name from "| KIRO FREE" or similar (legacy format)
-        var planName = "Kiro"
-        if let planMatch = stripped.range(of: #"\|\s*(KIRO\s+\w+)"#, options: .regularExpression) {
-            let raw = String(stripped[planMatch]).replacingOccurrences(of: "|", with: "")
-            planName = raw.trimmingCharacters(in: .whitespaces)
-        }
-
-        // Parse plan name from "Plan: Q Developer Pro" (new format, kiro-cli 1.24+)
-        if let newPlanMatch = stripped.range(of: #"Plan:\s*(.+)"#, options: .regularExpression) {
-            let line = String(stripped[newPlanMatch])
-            // Extract just the plan name, stopping at newline
-            let planLine = line.replacingOccurrences(of: "Plan:", with: "").trimmingCharacters(in: .whitespaces)
-            if let firstLine = planLine.split(separator: "\n").first {
-                planName = String(firstLine).trimmingCharacters(in: .whitespaces)
-                matchedNewFormat = true
-            }
-        }
+        let parsedPlan = Self.parsePlanName(from: stripped)
+        let planName = parsedPlan.name
+        matchedNewFormat = parsedPlan.matchedNewFormat
 
         // Check if this is a managed plan with no usage data
         let isManagedPlan = lowered.contains("managed by admin")
             || lowered.contains("managed by organization")
 
-        // Parse reset date from "resets on 01/01"
-        var resetsAt: Date?
-        if let resetMatch = stripped.range(of: #"resets on (\d{2}/\d{2})"#, options: .regularExpression) {
-            let resetStr = String(stripped[resetMatch])
-            if let dateRange = resetStr.range(of: #"\d{2}/\d{2}"#, options: .regularExpression) {
-                let dateStr = String(resetStr[dateRange])
-                resetsAt = Self.parseResetDate(dateStr)
-            }
-        }
+        let resetsAt = Self.parseResetDate(in: stripped)
 
         // Parse credits percentage from "████...█ X%"
         var creditsPercent: Double = 0
@@ -420,24 +646,24 @@ public struct KiroStatusProbe: Sendable {
             creditsPercent = (creditsUsed / creditsTotal) * 100.0
         }
 
-        // Parse bonus credits from "Bonus credits: X.XX/Y credits used, expires in Z days"
-        var bonusUsed: Double?
-        var bonusTotal: Double?
-        var bonusExpiryDays: Int?
-        if let bonusMatch = stripped.range(of: #"Bonus credits:\s*(\d+\.?\d*)/(\d+)"#, options: .regularExpression) {
-            let bonusStr = String(stripped[bonusMatch])
-            let numbers = bonusStr.matches(of: /(\d+\.?\d*)/)
-            if numbers.count >= 2 {
-                bonusUsed = Double(String(numbers[0].output.1))
-                bonusTotal = Double(String(numbers[1].output.1))
-            }
-        }
-        if let expiryMatch = stripped.range(of: #"expires in (\d+) days?"#, options: .regularExpression) {
-            let expiryStr = String(stripped[expiryMatch])
-            if let numMatch = expiryStr.range(of: #"\d+"#, options: .regularExpression) {
-                bonusExpiryDays = Int(String(expiryStr[numMatch]))
-            }
-        }
+        let bonusCredits = Self.parseBonusCredits(in: stripped)
+
+        let overagesStatus = Self.firstCapture(
+            in: stripped,
+            pattern: #"(?i)Overages:\s*([^\n]+)"#)
+            .map(Self.cleanInlineValue)
+            .flatMap(\.nilIfEmpty)
+        let overageCreditsUsed = Self.firstCapture(
+            in: stripped,
+            pattern: #"(?i)Credits used:\s*(\d+\.?\d*)"#)
+            .flatMap(Double.init)
+        let estimatedOverageCostUSD = Self.firstCapture(
+            in: stripped,
+            pattern: #"(?i)Est\.\s*cost:\s*\$?(\d+\.?\d*)\s*USD"#)
+            .flatMap(Double.init)
+        let manageURL = Self.firstCapture(
+            in: stripped,
+            pattern: #"https://app\.kiro\.dev/account/usage"#)
 
         // Managed plans in new format may omit usage metrics. Only fall back to zeros when
         // we did not parse any usage values, so we do not mask real metrics.
@@ -445,12 +671,20 @@ public struct KiroStatusProbe: Sendable {
             // Managed plans don't expose credits; return snapshot with plan name only
             return KiroUsageSnapshot(
                 planName: planName,
+                displayPlanName: Self.displayPlanName(planName),
+                accountEmail: accountEmail?.nilIfEmpty,
+                authMethod: authMethod?.nilIfEmpty,
                 creditsUsed: 0,
                 creditsTotal: 0,
                 creditsPercent: 0,
-                bonusCreditsUsed: nil,
-                bonusCreditsTotal: nil,
-                bonusExpiryDays: nil,
+                bonusCreditsUsed: bonusCredits.used,
+                bonusCreditsTotal: bonusCredits.total,
+                bonusExpiryDays: bonusCredits.expiryDays,
+                overagesStatus: overagesStatus,
+                overageCreditsUsed: overageCreditsUsed,
+                estimatedOverageCostUSD: estimatedOverageCostUSD,
+                manageURL: manageURL,
+                contextUsage: contextUsage,
                 resetsAt: nil,
                 updatedAt: Date())
         }
@@ -464,16 +698,41 @@ public struct KiroStatusProbe: Sendable {
 
         return KiroUsageSnapshot(
             planName: planName,
+            displayPlanName: Self.displayPlanName(planName),
+            accountEmail: accountEmail?.nilIfEmpty,
+            authMethod: authMethod?.nilIfEmpty,
             creditsUsed: creditsUsed,
             creditsTotal: creditsTotal,
             creditsPercent: creditsPercent,
-            bonusCreditsUsed: bonusUsed,
-            bonusCreditsTotal: bonusTotal,
-            bonusExpiryDays: bonusExpiryDays,
+            bonusCreditsUsed: bonusCredits.used,
+            bonusCreditsTotal: bonusCredits.total,
+            bonusExpiryDays: bonusCredits.expiryDays,
+            overagesStatus: overagesStatus,
+            overageCreditsUsed: overageCreditsUsed,
+            estimatedOverageCostUSD: estimatedOverageCostUSD,
+            manageURL: manageURL,
+            contextUsage: contextUsage,
             resetsAt: resetsAt,
             updatedAt: Date())
     }
 
+    func parseContextUsage(output: String) -> KiroContextUsageSnapshot? {
+        let stripped = Self.stripANSI(output)
+        guard let total = Self.firstCapture(
+            in: stripped,
+            pattern: #"(?i)Context window:\s*(\d+\.?\d*)%\s+used"#)
+            .flatMap(Double.init)
+        else {
+            return nil
+        }
+        return KiroContextUsageSnapshot(
+            totalPercentUsed: total,
+            contextFilesPercent: Self.percent(after: "Context files", in: stripped),
+            toolsPercent: Self.percent(after: "Tools", in: stripped),
+            kiroResponsesPercent: Self.percent(after: "Kiro responses", in: stripped),
+            promptsPercent: Self.percent(after: "Your prompts", in: stripped))
+    }
+
     private static func stripANSI(_ text: String) -> String {
         // Remove ANSI escape sequences
         let pattern = #"\x1B\[[0-9;?]*[A-Za-z]|\x1B\].*?\x07"#
@@ -484,7 +743,88 @@ public struct KiroStatusProbe: Sendable {
         return regex.stringByReplacingMatches(in: text, options: [], range: range, withTemplate: "")
     }
 
+    private static func parsePlanName(from text: String) -> (name: String, matchedNewFormat: Bool) {
+        var planName = "Kiro"
+        var matchedNewFormat = false
+
+        // Parse plan name from "| KIRO FREE" or similar (legacy format)
+        // Horizontal whitespace only ([ \t]) so the match cannot bridge a newline into the next line.
+        if let planMatch = text.range(of: #"\|[ \t]*(KIRO[ \t]+\w+)"#, options: .regularExpression) {
+            let raw = String(text[planMatch]).replacingOccurrences(of: "|", with: "")
+            planName = raw.trimmingCharacters(in: .whitespaces)
+        }
+
+        // Parse plan name from "Estimated Usage | resets on 2026-06-01 | KIRO FREE" (kiro-cli 2.x)
+        if let estimatedMatch = text.range(
+            of: #"Estimated Usage[ \t]*\|[^\n|]*\|[ \t]*([A-Z][A-Z0-9 ]+)"#,
+            options: .regularExpression)
+        {
+            let line = String(text[estimatedMatch])
+            if let plan = line.split(separator: "|").last?.trimmingCharacters(in: .whitespacesAndNewlines),
+               !plan.isEmpty
+            {
+                planName = plan
+            }
+        }
+
+        // Parse plan name from "Plan: Q Developer Pro" (new format, kiro-cli 1.24+)
+        if let newPlanMatch = text.range(of: #"Plan:[ \t]*(.+)"#, options: .regularExpression) {
+            let line = String(text[newPlanMatch])
+            let planLine = line.replacingOccurrences(of: "Plan:", with: "").trimmingCharacters(in: .whitespaces)
+            if let firstLine = planLine.split(separator: "\n").first {
+                planName = String(firstLine).trimmingCharacters(in: .whitespaces)
+                matchedNewFormat = true
+            }
+        }
+
+        return (planName, matchedNewFormat)
+    }
+
+    private static func parseResetDate(in text: String) -> Date? {
+        guard let resetMatch = text.range(
+            of: #"resets on (\d{4}-\d{2}-\d{2}|\d{2}/\d{2})"#,
+            options: .regularExpression)
+        else { return nil }
+
+        let resetStr = String(text[resetMatch])
+        guard let dateRange = resetStr.range(
+            of: #"\d{4}-\d{2}-\d{2}|\d{2}/\d{2}"#,
+            options: .regularExpression)
+        else { return nil }
+
+        return Self.parseResetDate(String(resetStr[dateRange]))
+    }
+
+    private static func parseBonusCredits(in text: String) -> (used: Double?, total: Double?, expiryDays: Int?) {
+        var used: Double?
+        var total: Double?
+        var expiryDays: Int?
+        if let bonusMatch = text.range(of: #"Bonus credits:\s*(\d+\.?\d*)/(\d+)"#, options: .regularExpression) {
+            let bonusStr = String(text[bonusMatch])
+            let numbers = bonusStr.matches(of: /(\d+\.?\d*)/)
+            if numbers.count >= 2 {
+                used = Double(String(numbers[0].output.1))
+                total = Double(String(numbers[1].output.1))
+            }
+        }
+        if let expiryMatch = text.range(of: #"expires in (\d+) days?"#, options: .regularExpression) {
+            let expiryStr = String(text[expiryMatch])
+            if let numMatch = expiryStr.range(of: #"\d+"#, options: .regularExpression) {
+                expiryDays = Int(String(expiryStr[numMatch]))
+            }
+        }
+        return (used, total, expiryDays)
+    }
+
     private static func parseResetDate(_ dateStr: String) -> Date? {
+        if dateStr.contains("-") {
+            let formatter = DateFormatter()
+            formatter.locale = Locale(identifier: "en_US_POSIX")
+            formatter.timeZone = Calendar.current.timeZone
+            formatter.dateFormat = "yyyy-MM-dd"
+            return formatter.date(from: dateStr)
+        }
+
         // Format: MM/DD - assume current or next year
         let parts = dateStr.split(separator: "/")
         guard parts.count == 2,
@@ -510,6 +850,45 @@ public struct KiroStatusProbe: Sendable {
         return calendar.date(from: components)
     }
 
+    public static func displayPlanName(_ planName: String) -> String {
+        let cleaned = Self.cleanInlineValue(planName)
+            .replacingOccurrences(of: #"\s+"#, with: " ", options: [.regularExpression])
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+        guard cleaned.localizedCaseInsensitiveContains("KIRO") else {
+            return cleaned.isEmpty ? planName : cleaned
+        }
+        return cleaned
+            .split(separator: " ")
+            .map { word in
+                if word.caseInsensitiveCompare("KIRO") == .orderedSame { return "Kiro" }
+                return word.prefix(1).uppercased() + word.dropFirst().lowercased()
+            }
+            .joined(separator: " ")
+    }
+
+    private static func percent(after label: String, in text: String) -> Double? {
+        let escaped = NSRegularExpression.escapedPattern(for: label)
+        return self.firstCapture(
+            in: text,
+            pattern: #"(?i)"# + escaped + #"\s+(\d+\.?\d*)%"#)
+            .flatMap(Double.init)
+    }
+
+    private static func firstCapture(in text: String, pattern: String) -> String? {
+        guard let regex = try? NSRegularExpression(pattern: pattern, options: []) else { return nil }
+        let nsRange = NSRange(text.startIndex..<text.endIndex, in: text)
+        guard let match = regex.firstMatch(in: text, options: [], range: nsRange) else { return nil }
+        let captureIndex = match.numberOfRanges > 1 ? 1 : 0
+        guard let range = Range(match.range(at: captureIndex), in: text) else { return nil }
+        return String(text[range]).trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+
+    private static func cleanInlineValue(_ text: String) -> String {
+        self.stripANSI(text)
+            .replacingOccurrences(of: #"\x1B|\[[0-9;?]*[A-Za-z]"#, with: "", options: [.regularExpression])
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+
     private static func isUsageOutputComplete(_ output: String) -> Bool {
         let stripped = self.stripANSI(output).lowercased()
         return stripped.contains("covered in plan")
@@ -519,3 +898,9 @@ public struct KiroStatusProbe: Sendable {
             || stripped.contains("managed by admin")
     }
 }
+
+extension String {
+    fileprivate var nilIfEmpty: String? {
+        self.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty ? nil : self
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/LLMProxy/LLMProxyProviderDescriptor.swift b/Sources/CodexBarCore/Providers/LLMProxy/LLMProxyProviderDescriptor.swift
new file mode 100644
index 0000000000..29091b78f3
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/LLMProxy/LLMProxyProviderDescriptor.swift
@@ -0,0 +1,68 @@
+import Foundation
+
+public enum LLMProxyProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .llmproxy,
+            metadata: ProviderMetadata(
+                id: .llmproxy,
+                displayName: "LLM Proxy",
+                sessionLabel: "Quota",
+                weeklyLabel: "Requests",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "",
+                toggleTitle: "Show LLM Proxy usage",
+                cliName: "llmproxy",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                browserCookieOrder: nil,
+                dashboardURL: nil,
+                statusPageURL: nil),
+            branding: ProviderBranding(
+                iconStyle: .llmproxy,
+                iconResourceName: "ProviderIcon-llmproxy",
+                color: ProviderColor(red: 36 / 255, green: 180 / 255, blue: 126 / 255)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "LLM Proxy cost history is reported in the quota-stats summary." }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .api],
+                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [LLMProxyAPIFetchStrategy()] })),
+            cli: ProviderCLIConfig(
+                name: "llmproxy",
+                aliases: ["llm-api-key-proxy", "llm-proxy"],
+                versionDetector: nil))
+    }
+}
+
+struct LLMProxyAPIFetchStrategy: ProviderFetchStrategy {
+    let id: String = "llmproxy.api"
+    let kind: ProviderFetchKind = .apiToken
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        ProviderTokenResolver.llmProxyToken(environment: context.env) != nil &&
+            LLMProxySettingsReader.baseURL(environment: context.env) != nil
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        guard let apiKey = ProviderTokenResolver.llmProxyToken(environment: context.env) else {
+            throw LLMProxyUsageError.missingCredentials
+        }
+        guard let baseURL = LLMProxySettingsReader.baseURL(environment: context.env) else {
+            throw LLMProxyUsageError.missingBaseURL
+        }
+        let usage = try await LLMProxyUsageFetcher.fetchUsage(apiKey: apiKey, baseURL: baseURL)
+        return self.makeResult(
+            usage: usage.toUsageSnapshot(),
+            sourceLabel: "api")
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/LLMProxy/LLMProxySettingsReader.swift b/Sources/CodexBarCore/Providers/LLMProxy/LLMProxySettingsReader.swift
new file mode 100644
index 0000000000..e753752f9f
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/LLMProxy/LLMProxySettingsReader.swift
@@ -0,0 +1,32 @@
+import Foundation
+
+public enum LLMProxySettingsReader {
+    public static let apiKeyEnvironmentKey = "LLM_PROXY_API_KEY"
+    public static let baseURLEnvironmentKey = "LLM_PROXY_BASE_URL"
+
+    public static func apiKey(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.cleaned(environment[self.apiKeyEnvironmentKey])
+    }
+
+    public static func baseURL(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> URL?
+    {
+        guard let raw = self.cleaned(environment[self.baseURLEnvironmentKey]) else { return nil }
+        return URL(string: raw)
+    }
+
+    static func cleaned(_ raw: String?) -> String? {
+        guard var value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
+            return nil
+        }
+        if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
+            (value.hasPrefix("'") && value.hasSuffix("'"))
+        {
+            value = String(value.dropFirst().dropLast())
+        }
+        value = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        return value.isEmpty ? nil : value
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/LLMProxy/LLMProxyUsageFetcher.swift b/Sources/CodexBarCore/Providers/LLMProxy/LLMProxyUsageFetcher.swift
new file mode 100644
index 0000000000..094ec30154
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/LLMProxy/LLMProxyUsageFetcher.swift
@@ -0,0 +1,313 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public enum LLMProxyUsageError: LocalizedError, Sendable {
+    case missingCredentials
+    case missingBaseURL
+    case invalidURL
+    case apiError(String)
+    case parseFailed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingCredentials:
+            "Missing LLM Proxy API key. Set apiKey in ~/.codexbar/config.json or LLM_PROXY_API_KEY."
+        case .missingBaseURL:
+            "Missing LLM Proxy base URL. Set enterpriseHost in ~/.codexbar/config.json or LLM_PROXY_BASE_URL."
+        case .invalidURL:
+            "LLM Proxy URL is invalid."
+        case let .apiError(message):
+            "LLM Proxy API error: \(message)"
+        case let .parseFailed(message):
+            "LLM Proxy parse error: \(message)"
+        }
+    }
+}
+
+public struct LLMProxyUsageSnapshot: Codable, Sendable, Equatable {
+    public let providerCount: Int
+    public let credentialCount: Int
+    public let activeCredentialCount: Int
+    public let exhaustedCredentialCount: Int
+    public let totalRequests: Int
+    public let totalTokens: Int
+    public let approximateCostUSD: Double?
+    public let minimumRemainingPercent: Double?
+    public let nextResetAt: Date?
+    public let topProviders: [ProviderSummary]
+    public let updatedAt: Date
+
+    public struct ProviderSummary: Codable, Sendable, Equatable {
+        public let name: String
+        public let requests: Int
+        public let tokens: Int
+        public let approximateCostUSD: Double?
+    }
+
+    public func toUsageSnapshot() -> UsageSnapshot {
+        let used = self.minimumRemainingPercent.map { max(0, min(100, 100 - $0)) }
+        let windows = self.topProviders.prefix(3).map { provider in
+            NamedRateWindow(
+                id: provider.name,
+                title: provider.name,
+                window: RateWindow(
+                    usedPercent: 0,
+                    windowMinutes: nil,
+                    resetsAt: nil,
+                    resetDescription: Self.providerSummaryText(provider)))
+        }
+        return UsageSnapshot(
+            primary: used.map {
+                RateWindow(
+                    usedPercent: $0,
+                    windowMinutes: nil,
+                    resetsAt: self.nextResetAt,
+                    resetDescription: nil)
+            },
+            secondary: RateWindow(
+                usedPercent: 0,
+                windowMinutes: nil,
+                resetsAt: nil,
+                resetDescription: "\(Self.formatInteger(self.totalRequests)) requests"),
+            tertiary: RateWindow(
+                usedPercent: 0,
+                windowMinutes: nil,
+                resetsAt: nil,
+                resetDescription: "\(Self.formatInteger(self.totalTokens)) tokens"),
+            extraRateWindows: windows.isEmpty ? nil : Array(windows),
+            providerCost: self.approximateCostUSD.map {
+                ProviderCostSnapshot(
+                    used: $0,
+                    limit: 0,
+                    currencyCode: "USD",
+                    period: "Approx. spend",
+                    resetsAt: self.nextResetAt,
+                    updatedAt: self.updatedAt)
+            },
+            updatedAt: self.updatedAt,
+            identity: ProviderIdentitySnapshot(
+                providerID: .llmproxy,
+                accountEmail: nil,
+                accountOrganization: "\(self.activeCredentialCount)/\(self.credentialCount) active keys",
+                loginMethod: "quota-stats"))
+    }
+
+    private static func providerSummaryText(_ provider: ProviderSummary) -> String {
+        var pieces = [
+            "\(Self.formatInteger(provider.requests)) req",
+            "\(Self.formatInteger(provider.tokens)) tok",
+        ]
+        if let cost = provider.approximateCostUSD {
+            pieces.append(UsageFormatter.usdString(cost))
+        }
+        return pieces.joined(separator: " · ")
+    }
+
+    private static func formatInteger(_ value: Int) -> String {
+        let formatter = NumberFormatter()
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        formatter.numberStyle = .decimal
+        formatter.usesGroupingSeparator = true
+        formatter.groupingSeparator = ","
+        formatter.maximumFractionDigits = 0
+        return formatter.string(from: NSNumber(value: value)) ?? "\(value)"
+    }
+}
+
+private struct LLMProxyQuotaStatsResponse: Decodable {
+    struct ProviderStats: Decodable {
+        struct Tokens: Decodable {
+            let inputCached: Int?
+            let inputUncached: Int?
+            let output: Int?
+
+            private enum CodingKeys: String, CodingKey {
+                case inputCached = "input_cached"
+                case inputUncached = "input_uncached"
+                case output
+            }
+        }
+
+        struct QuotaGroup: Decodable {
+            let remainingPercent: Double?
+            let resetTime: String?
+
+            private enum CodingKeys: String, CodingKey {
+                case remainingPercent = "remaining_percent"
+                case resetTime = "reset_time"
+            }
+        }
+
+        let credentialCount: Int?
+        let activeCount: Int?
+        let exhaustedCount: Int?
+        let totalRequests: Int?
+        let tokens: Tokens?
+        let approximateCost: Double?
+        let quotaGroups: [QuotaGroup]?
+
+        private enum CodingKeys: String, CodingKey {
+            case credentialCount = "credential_count"
+            case activeCount = "active_count"
+            case exhaustedCount = "exhausted_count"
+            case totalRequests = "total_requests"
+            case tokens
+            case approximateCost = "approx_cost"
+            case quotaGroups = "quota_groups"
+        }
+
+        init(from decoder: Decoder) throws {
+            let container = try decoder.container(keyedBy: CodingKeys.self)
+            self.credentialCount = try container.decodeIfPresent(Int.self, forKey: .credentialCount)
+            self.activeCount = try container.decodeIfPresent(Int.self, forKey: .activeCount)
+            self.exhaustedCount = try container.decodeIfPresent(Int.self, forKey: .exhaustedCount)
+            self.totalRequests = try container.decodeIfPresent(Int.self, forKey: .totalRequests)
+            self.tokens = try container.decodeIfPresent(Tokens.self, forKey: .tokens)
+            self.approximateCost = try container.decodeIfPresent(Double.self, forKey: .approximateCost)
+            self.quotaGroups = Self.decodeQuotaGroups(from: container)
+        }
+
+        private static func decodeQuotaGroups(from container: KeyedDecodingContainer<CodingKeys>)
+            -> [QuotaGroup]?
+        {
+            if let groups = try? container.decodeIfPresent([QuotaGroup].self, forKey: .quotaGroups) {
+                return groups
+            }
+            let keyedGroups = try? container.decodeIfPresent(
+                [String: QuotaGroup].self,
+                forKey: .quotaGroups)
+            return keyedGroups?.values.sorted { lhs, rhs in
+                (lhs.remainingPercent ?? .infinity) < (rhs.remainingPercent ?? .infinity)
+            }
+        }
+    }
+
+    struct Summary: Decodable {
+        let totalRequests: Int?
+        let approximateCost: Double?
+        let totalTokens: Int?
+
+        private enum CodingKeys: String, CodingKey {
+            case totalRequests = "total_requests"
+            case approximateCost = "approx_cost"
+            case totalTokens = "total_tokens"
+        }
+    }
+
+    let providers: [String: ProviderStats]
+    let summary: Summary?
+}
+
+public struct LLMProxyUsageFetcher: Sendable {
+    public init() {}
+
+    public static func fetchUsage(
+        apiKey: String,
+        baseURL: URL,
+        transport: any ProviderHTTPTransport = ProviderHTTPClient.shared,
+        updatedAt: Date = Date()) async throws -> LLMProxyUsageSnapshot
+    {
+        guard !apiKey.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+            throw LLMProxyUsageError.missingCredentials
+        }
+        let url = self.quotaStatsURL(baseURL: baseURL)
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+
+        let response = try await transport.response(for: request)
+        guard (200..<300).contains(response.statusCode) else {
+            throw LLMProxyUsageError.apiError("HTTP \(response.statusCode): \(Self.responseSummary(response.data))")
+        }
+        return try self.parseSnapshot(data: response.data, updatedAt: updatedAt)
+    }
+
+    public static func _parseSnapshotForTesting(_ data: Data, updatedAt: Date) throws -> LLMProxyUsageSnapshot {
+        try self.parseSnapshot(data: data, updatedAt: updatedAt)
+    }
+
+    public static func _quotaStatsURLForTesting(baseURL: URL) -> URL {
+        self.quotaStatsURL(baseURL: baseURL)
+    }
+
+    private static func quotaStatsURL(baseURL: URL) -> URL {
+        let path = baseURL.path.trimmingCharacters(in: CharacterSet(charactersIn: "/"))
+        let versionedBaseURL = path.split(separator: "/").last == "v1"
+            ? baseURL
+            : baseURL.appendingPathComponent("v1")
+        return versionedBaseURL.appendingPathComponent("quota-stats")
+    }
+
+    private static func parseSnapshot(data: Data, updatedAt: Date) throws -> LLMProxyUsageSnapshot {
+        do {
+            let decoded = try JSONDecoder().decode(LLMProxyQuotaStatsResponse.self, from: data)
+            let providers = decoded.providers
+            let summaries = providers.map { name, stats in
+                LLMProxyUsageSnapshot.ProviderSummary(
+                    name: name,
+                    requests: stats.totalRequests ?? 0,
+                    tokens: Self.tokenTotal(stats.tokens),
+                    approximateCostUSD: stats.approximateCost)
+            }.sorted { lhs, rhs in
+                if lhs.requests != rhs.requests { return lhs.requests > rhs.requests }
+                return lhs.name < rhs.name
+            }
+            let requests = decoded.summary?.totalRequests ?? summaries.reduce(0) { $0 + $1.requests }
+            let tokens = decoded.summary?.totalTokens ?? summaries.reduce(0) { $0 + $1.tokens }
+            let cost = decoded.summary?.approximateCost ?? {
+                let sum = summaries.compactMap(\.approximateCostUSD).reduce(0, +)
+                return sum > 0 ? sum : nil
+            }()
+
+            let quotaGroups = providers.values.flatMap { $0.quotaGroups ?? [] }
+            let minRemaining = quotaGroups.compactMap(\.remainingPercent).min()
+            let reset = quotaGroups.compactMap { Self.parseDate($0.resetTime) }.min()
+
+            return LLMProxyUsageSnapshot(
+                providerCount: providers.count,
+                credentialCount: providers.values.reduce(0) { $0 + ($1.credentialCount ?? 0) },
+                activeCredentialCount: providers.values.reduce(0) { $0 + ($1.activeCount ?? 0) },
+                exhaustedCredentialCount: providers.values.reduce(0) { $0 + ($1.exhaustedCount ?? 0) },
+                totalRequests: requests,
+                totalTokens: tokens,
+                approximateCostUSD: cost,
+                minimumRemainingPercent: minRemaining,
+                nextResetAt: reset,
+                topProviders: summaries,
+                updatedAt: updatedAt)
+        } catch let error as LLMProxyUsageError {
+            throw error
+        } catch {
+            throw LLMProxyUsageError.parseFailed(error.localizedDescription)
+        }
+    }
+
+    private static func tokenTotal(_ tokens: LLMProxyQuotaStatsResponse.ProviderStats.Tokens?) -> Int {
+        (tokens?.inputCached ?? 0) + (tokens?.inputUncached ?? 0) + (tokens?.output ?? 0)
+    }
+
+    private static func parseDate(_ raw: String?) -> Date? {
+        guard let raw else { return nil }
+        if let date = self.iso8601DateFormatter(fractionalSeconds: true).date(from: raw) {
+            return date
+        }
+        return self.iso8601DateFormatter(fractionalSeconds: false).date(from: raw)
+    }
+
+    private static func iso8601DateFormatter(fractionalSeconds: Bool) -> ISO8601DateFormatter {
+        let formatter = ISO8601DateFormatter()
+        if fractionalSeconds {
+            formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        }
+        return formatter
+    }
+
+    private static func responseSummary(_ data: Data) -> String {
+        String(bytes: data.prefix(500), encoding: .utf8)?
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            ?? ""
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/LiteLLM/LiteLLMProviderDescriptor.swift b/Sources/CodexBarCore/Providers/LiteLLM/LiteLLMProviderDescriptor.swift
new file mode 100644
index 0000000000..1360749c16
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/LiteLLM/LiteLLMProviderDescriptor.swift
@@ -0,0 +1,69 @@
+import Foundation
+
+public enum LiteLLMProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .litellm,
+            metadata: ProviderMetadata(
+                id: .litellm,
+                displayName: "LiteLLM",
+                sessionLabel: "Personal budget",
+                weeklyLabel: "Team budget",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "Reads spend and budget from LiteLLM key, user, and team info endpoints.",
+                toggleTitle: "Show LiteLLM usage",
+                cliName: "litellm",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                dashboardURL: nil,
+                statusPageURL: nil),
+            branding: ProviderBranding(
+                iconStyle: .litellm,
+                iconResourceName: "ProviderIcon-litellm",
+                color: ProviderColor(red: 76 / 255, green: 137 / 255, blue: 240 / 255)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "LiteLLM spend is reported by the provider API." }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .api],
+                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [LiteLLMAPIFetchStrategy()] })),
+            cli: ProviderCLIConfig(
+                name: "litellm",
+                aliases: ["litellm-proxy"],
+                versionDetector: nil))
+    }
+}
+
+struct LiteLLMAPIFetchStrategy: ProviderFetchStrategy {
+    let id: String = "litellm.api"
+    let kind: ProviderFetchKind = .apiToken
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        ProviderTokenResolver.liteLLMToken(environment: context.env) != nil &&
+            LiteLLMSettingsReader.baseURL(environment: context.env) != nil
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        guard let apiKey = ProviderTokenResolver.liteLLMToken(environment: context.env) else {
+            throw LiteLLMUsageError.missingCredentials
+        }
+        guard let baseURL = LiteLLMSettingsReader.baseURL(environment: context.env) else {
+            throw LiteLLMUsageError.missingBaseURL
+        }
+        let usage = try await LiteLLMUsageFetcher.fetchUsage(
+            apiKey: apiKey,
+            baseURL: baseURL)
+        return self.makeResult(
+            usage: usage.toUsageSnapshot(),
+            sourceLabel: "api")
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/LiteLLM/LiteLLMSettingsReader.swift b/Sources/CodexBarCore/Providers/LiteLLM/LiteLLMSettingsReader.swift
new file mode 100644
index 0000000000..a060510da8
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/LiteLLM/LiteLLMSettingsReader.swift
@@ -0,0 +1,32 @@
+import Foundation
+
+public enum LiteLLMSettingsReader {
+    public static let apiKeyEnvironmentKey = "LITELLM_API_KEY"
+    public static let baseURLEnvironmentKey = "LITELLM_BASE_URL"
+
+    public static func apiKey(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.cleaned(environment[self.apiKeyEnvironmentKey])
+    }
+
+    public static func baseURL(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> URL?
+    {
+        guard let raw = self.cleaned(environment[self.baseURLEnvironmentKey]) else { return nil }
+        return URL(string: raw)
+    }
+
+    static func cleaned(_ raw: String?) -> String? {
+        guard var value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
+            return nil
+        }
+        if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
+            (value.hasPrefix("'") && value.hasSuffix("'"))
+        {
+            value = String(value.dropFirst().dropLast())
+        }
+        value = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        return value.isEmpty ? nil : value
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/LiteLLM/LiteLLMUsageFetcher.swift b/Sources/CodexBarCore/Providers/LiteLLM/LiteLLMUsageFetcher.swift
new file mode 100644
index 0000000000..eb5e1e6d79
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/LiteLLM/LiteLLMUsageFetcher.swift
@@ -0,0 +1,587 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public enum LiteLLMUsageError: LocalizedError, Sendable {
+    case missingCredentials
+    case missingBaseURL
+    case missingUserID
+    case invalidURL
+    case apiError(String)
+    case parseFailed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingCredentials:
+            "Missing LiteLLM API key. Set apiKey in ~/.codexbar/config.json or LITELLM_API_KEY."
+        case .missingBaseURL:
+            "Missing LiteLLM base URL. Set enterpriseHost in ~/.codexbar/config.json or LITELLM_BASE_URL."
+        case .missingUserID:
+            "LiteLLM key info did not include a user_id or team_id."
+        case .invalidURL:
+            "LiteLLM URL is invalid."
+        case let .apiError(message):
+            "LiteLLM API error: \(message)"
+        case let .parseFailed(message):
+            "LiteLLM parse error: \(message)"
+        }
+    }
+}
+
+public struct LiteLLMKeyInfoSnapshot: Codable, Sendable, Equatable {
+    public let userID: String?
+    public let teamID: String?
+    public let keyName: String?
+    public let spendUSD: Double
+    public let expiresAt: Date?
+
+    public init(userID: String?, teamID: String?, keyName: String?, spendUSD: Double, expiresAt: Date?) {
+        self.userID = userID
+        self.teamID = teamID
+        self.keyName = keyName
+        self.spendUSD = spendUSD
+        self.expiresAt = expiresAt
+    }
+}
+
+public struct LiteLLMUsageSnapshot: Codable, Sendable, Equatable {
+    public let userID: String?
+    public let accountEmail: String?
+    public let personalSpendUSD: Double
+    public let personalBudgetUSD: Double?
+    public let personalResetAt: Date?
+    public let teamUsage: TeamUsage?
+    public let keyName: String?
+    public let keyExpiresAt: Date?
+    public let updatedAt: Date
+
+    public struct TeamUsage: Codable, Sendable, Equatable {
+        public let id: String
+        public let alias: String?
+        public let spendUSD: Double
+        public let budgetUSD: Double?
+        public let resetAt: Date?
+        public let budgetDuration: String?
+    }
+
+    public func toUsageSnapshot() -> UsageSnapshot {
+        let primary = Self.rateWindow(
+            spend: self.personalSpendUSD,
+            budget: self.personalBudgetUSD,
+            resetAt: self.personalResetAt,
+            description: Self.budgetDescription(spend: self.personalSpendUSD, budget: self.personalBudgetUSD))
+
+        let secondary = self.teamUsage.flatMap { team in
+            Self.rateWindow(
+                spend: team.spendUSD,
+                budget: team.budgetUSD,
+                resetAt: team.resetAt,
+                description: Self.teamDescription(team))
+        }
+
+        let providerCost = self.providerCostSnapshot()
+
+        return UsageSnapshot(
+            primary: primary,
+            secondary: secondary,
+            tertiary: nil,
+            providerCost: providerCost,
+            subscriptionExpiresAt: self.keyExpiresAt,
+            updatedAt: self.updatedAt,
+            identity: ProviderIdentitySnapshot(
+                providerID: .litellm,
+                accountEmail: self.accountEmail,
+                accountOrganization: self.teamUsage?.alias,
+                loginMethod: "api"))
+    }
+
+    private static func rateWindow(
+        spend: Double,
+        budget: Double?,
+        resetAt: Date?,
+        description: String?) -> RateWindow?
+    {
+        guard let budget, budget > 0 else { return nil }
+        return RateWindow(
+            usedPercent: min(100, max(0, (spend / budget) * 100)),
+            windowMinutes: nil,
+            resetsAt: resetAt,
+            resetDescription: description)
+    }
+
+    private static func budgetDescription(spend: Double, budget: Double?) -> String? {
+        guard let budget, budget > 0 else { return UsageFormatter.usdString(spend) }
+        return "\(UsageFormatter.usdString(spend)) / \(UsageFormatter.usdString(budget))"
+    }
+
+    private static func teamDescription(_ team: TeamUsage) -> String? {
+        let label = team.alias.map { "Team \($0)" } ?? "Team"
+        guard let budget = team.budgetUSD, budget > 0 else {
+            return "\(label): \(UsageFormatter.usdString(team.spendUSD))"
+        }
+        return "\(label): \(UsageFormatter.usdString(team.spendUSD)) / \(UsageFormatter.usdString(budget))"
+    }
+
+    private func providerCostSnapshot() -> ProviderCostSnapshot? {
+        let spend: Double
+        let budget: Double?
+        let period: String
+        let resetsAt: Date?
+
+        if self.userID == nil, let team = self.teamUsage {
+            spend = team.spendUSD
+            budget = team.budgetUSD
+            period = (team.budgetUSD ?? 0) > 0 ? "Team budget" : "Team spend"
+            resetsAt = team.resetAt
+        } else {
+            spend = self.personalSpendUSD
+            budget = self.personalBudgetUSD
+            period = (self.personalBudgetUSD ?? 0) > 0 ? "Personal budget" : "Personal spend"
+            resetsAt = self.personalResetAt
+        }
+
+        guard spend > 0 || (budget ?? 0) > 0 else { return nil }
+        return ProviderCostSnapshot(
+            used: spend,
+            limit: max(0, budget ?? 0),
+            currencyCode: "USD",
+            period: period,
+            resetsAt: resetsAt,
+            updatedAt: self.updatedAt)
+    }
+}
+
+private struct LiteLLMKeyInfoResponse: Decodable {
+    struct Info: Decodable {
+        let keyName: String?
+        let spend: Double?
+        let expires: String?
+        let userID: String?
+        let teamID: String?
+
+        private enum CodingKeys: String, CodingKey {
+            case keyName = "key_name"
+            case spend
+            case expires
+            case userID = "user_id"
+            case teamID = "team_id"
+        }
+    }
+
+    let info: Info
+}
+
+private struct LiteLLMUserInfoResponse: Decodable {
+    struct UserInfo: Decodable {
+        struct Metadata: Decodable {
+            let preferredUsername: String?
+
+            private enum CodingKeys: String, CodingKey {
+                case preferredUsername = "preferred_username"
+            }
+
+            init(from decoder: Decoder) throws {
+                let container = try decoder.container(keyedBy: CodingKeys.self)
+                self.preferredUsername = try? container.decodeIfPresent(String.self, forKey: .preferredUsername)
+            }
+        }
+
+        let userID: String?
+        let userAlias: String?
+        let maxBudget: Double?
+        let spend: Double?
+        let userEmail: String?
+        let budgetResetAt: String?
+        let metadata: Metadata?
+
+        private enum CodingKeys: String, CodingKey {
+            case userID = "user_id"
+            case userAlias = "user_alias"
+            case maxBudget = "max_budget"
+            case spend
+            case userEmail = "user_email"
+            case budgetResetAt = "budget_reset_at"
+            case metadata
+        }
+    }
+
+    struct Team: Decodable {
+        let teamAlias: String?
+        let teamID: String
+        let maxBudget: Double?
+        let spend: Double?
+        let budgetResetAt: String?
+        let budgetDuration: String?
+
+        private enum CodingKeys: String, CodingKey {
+            case teamAlias = "team_alias"
+            case teamID = "team_id"
+            case maxBudget = "max_budget"
+            case spend
+            case budgetResetAt = "budget_reset_at"
+            case budgetDuration = "budget_duration"
+        }
+    }
+
+    let userID: String?
+    let userInfo: UserInfo
+    let teams: [Team]?
+
+    private enum CodingKeys: String, CodingKey {
+        case userID = "user_id"
+        case userInfo = "user_info"
+        case teams
+    }
+}
+
+private struct LiteLLMTeamInfoResponse: Decodable {
+    struct TeamInfo: Decodable {
+        let teamAlias: String?
+        let teamID: String?
+        let maxBudget: Double?
+        let spend: Double?
+        let budgetResetAt: String?
+        let budgetDuration: String?
+
+        private enum CodingKeys: String, CodingKey {
+            case teamAlias = "team_alias"
+            case teamID = "team_id"
+            case maxBudget = "max_budget"
+            case spend
+            case budgetResetAt = "budget_reset_at"
+            case budgetDuration = "budget_duration"
+        }
+    }
+
+    let teamID: String?
+    let teamInfo: TeamInfo
+
+    private enum CodingKeys: String, CodingKey {
+        case teamID = "team_id"
+        case teamInfo = "team_info"
+    }
+}
+
+public struct LiteLLMUsageFetcher: Sendable {
+    public init() {}
+
+    public static func fetchUsage(
+        apiKey: String,
+        baseURL: URL,
+        transport: any ProviderHTTPTransport = ProviderHTTPClient.shared,
+        updatedAt: Date = Date()) async throws -> LiteLLMUsageSnapshot
+    {
+        let cleanedAPIKey = apiKey.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !cleanedAPIKey.isEmpty else {
+            throw LiteLLMUsageError.missingCredentials
+        }
+
+        let keyInfo = try await self.fetchKeyInfo(
+            apiKey: cleanedAPIKey,
+            baseURL: baseURL,
+            transport: transport)
+        if keyInfo.userID != nil {
+            return try await self.fetchUserInfo(
+                apiKey: cleanedAPIKey,
+                baseURL: baseURL,
+                keyInfo: keyInfo,
+                transport: transport,
+                updatedAt: updatedAt)
+        }
+        if keyInfo.teamID != nil {
+            return try await self.fetchTeamInfo(
+                apiKey: cleanedAPIKey,
+                baseURL: baseURL,
+                keyInfo: keyInfo,
+                transport: transport,
+                updatedAt: updatedAt)
+        }
+        throw LiteLLMUsageError.missingUserID
+    }
+
+    public static func _parseUserInfoForTesting(
+        _ data: Data,
+        keyInfo: LiteLLMKeyInfoSnapshot,
+        updatedAt: Date) throws -> LiteLLMUsageSnapshot
+    {
+        try self.parseUserInfo(data: data, keyInfo: keyInfo, updatedAt: updatedAt)
+    }
+
+    public static func _parseKeyInfoForTesting(_ data: Data) throws -> LiteLLMKeyInfoSnapshot {
+        try self.parseKeyInfo(data: data)
+    }
+
+    public static func _parseTeamInfoForTesting(
+        _ data: Data,
+        keyInfo: LiteLLMKeyInfoSnapshot,
+        updatedAt: Date) throws -> LiteLLMUsageSnapshot
+    {
+        try self.parseTeamInfo(data: data, keyInfo: keyInfo, updatedAt: updatedAt)
+    }
+
+    public static func _keyInfoURLForTesting(baseURL: URL) -> URL {
+        self.keyInfoURL(baseURL: baseURL)
+    }
+
+    public static func _userInfoURLForTesting(baseURL: URL, userID: String) -> URL {
+        self.userInfoURL(baseURL: baseURL, userID: userID)
+    }
+
+    public static func _teamInfoURLForTesting(baseURL: URL, teamID: String) -> URL {
+        self.teamInfoURL(baseURL: baseURL, teamID: teamID)
+    }
+
+    private static func fetchKeyInfo(
+        apiKey: String,
+        baseURL: URL,
+        transport: any ProviderHTTPTransport) async throws -> LiteLLMKeyInfoSnapshot
+    {
+        // Virtual keys may read their own metadata; omit ?key= to avoid requiring or exposing a master key.
+        let request = self.request(
+            url: self.keyInfoURL(baseURL: baseURL),
+            apiKey: apiKey)
+        let response = try await transport.response(for: request)
+        guard (200..<300).contains(response.statusCode) else {
+            throw LiteLLMUsageError.apiError("HTTP \(response.statusCode): \(Self.responseSummary(response.data))")
+        }
+        return try self.parseKeyInfo(data: response.data)
+    }
+
+    private static func fetchUserInfo(
+        apiKey: String,
+        baseURL: URL,
+        keyInfo: LiteLLMKeyInfoSnapshot,
+        transport: any ProviderHTTPTransport,
+        updatedAt: Date) async throws -> LiteLLMUsageSnapshot
+    {
+        guard let userID = keyInfo.userID else {
+            throw LiteLLMUsageError.parseFailed("/user/info requested without a user_id")
+        }
+        let request = self.request(
+            url: self.userInfoURL(baseURL: baseURL, userID: userID),
+            apiKey: apiKey)
+        let response = try await transport.response(for: request)
+        guard (200..<300).contains(response.statusCode) else {
+            throw LiteLLMUsageError.apiError("HTTP \(response.statusCode): \(Self.responseSummary(response.data))")
+        }
+        return try self.parseUserInfo(data: response.data, keyInfo: keyInfo, updatedAt: updatedAt)
+    }
+
+    private static func fetchTeamInfo(
+        apiKey: String,
+        baseURL: URL,
+        keyInfo: LiteLLMKeyInfoSnapshot,
+        transport: any ProviderHTTPTransport,
+        updatedAt: Date) async throws -> LiteLLMUsageSnapshot
+    {
+        guard let teamID = keyInfo.teamID else {
+            throw LiteLLMUsageError.parseFailed("/team/info requested without a team_id")
+        }
+        let request = self.request(
+            url: self.teamInfoURL(baseURL: baseURL, teamID: teamID),
+            apiKey: apiKey)
+        let response = try await transport.response(for: request)
+        guard (200..<300).contains(response.statusCode) else {
+            throw LiteLLMUsageError.apiError("HTTP \(response.statusCode): \(Self.responseSummary(response.data))")
+        }
+        return try self.parseTeamInfo(data: response.data, keyInfo: keyInfo, updatedAt: updatedAt)
+    }
+
+    private static func request(url: URL, apiKey: String) -> URLRequest {
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        return request
+    }
+
+    private static func keyInfoURL(baseURL: URL) -> URL {
+        self.managementBaseURL(baseURL)
+            .appendingPathComponent("key")
+            .appendingPathComponent("info")
+    }
+
+    private static func userInfoURL(baseURL: URL, userID: String) -> URL {
+        self.managementBaseURL(baseURL).appending(
+            queryItems: [URLQueryItem(name: "user_id", value: userID)],
+            pathComponents: ["user", "info"])
+    }
+
+    private static func teamInfoURL(baseURL: URL, teamID: String) -> URL {
+        self.managementBaseURL(baseURL).appending(
+            queryItems: [URLQueryItem(name: "team_id", value: teamID)],
+            pathComponents: ["team", "info"])
+    }
+
+    private static func managementBaseURL(_ baseURL: URL) -> URL {
+        let path = baseURL.path.trimmingCharacters(in: CharacterSet(charactersIn: "/"))
+        guard path.split(separator: "/").last == "v1" else { return baseURL }
+
+        var components = URLComponents(url: baseURL, resolvingAgainstBaseURL: false)
+        let parts = path.split(separator: "/").dropLast()
+        components?.path = parts.isEmpty ? "" : "/" + parts.joined(separator: "/")
+        return components?.url ?? baseURL
+    }
+
+    private static func parseKeyInfo(data: Data) throws -> LiteLLMKeyInfoSnapshot {
+        do {
+            let decoded = try JSONDecoder().decode(LiteLLMKeyInfoResponse.self, from: data)
+            let userID = self.nonEmpty(decoded.info.userID)
+            let teamID = self.nonEmpty(decoded.info.teamID)
+            guard userID != nil || teamID != nil else {
+                throw LiteLLMUsageError.missingUserID
+            }
+            return LiteLLMKeyInfoSnapshot(
+                userID: userID,
+                teamID: teamID,
+                keyName: decoded.info.keyName,
+                spendUSD: decoded.info.spend ?? 0,
+                expiresAt: self.parseDate(decoded.info.expires))
+        } catch let error as LiteLLMUsageError {
+            throw error
+        } catch {
+            throw LiteLLMUsageError.parseFailed(error.localizedDescription)
+        }
+    }
+
+    private static func parseUserInfo(
+        data: Data,
+        keyInfo: LiteLLMKeyInfoSnapshot,
+        updatedAt: Date) throws -> LiteLLMUsageSnapshot
+    {
+        do {
+            let decoded = try JSONDecoder().decode(LiteLLMUserInfoResponse.self, from: data)
+            guard let expectedUserID = keyInfo.userID else {
+                throw LiteLLMUsageError.parseFailed("/user/info requested without a user_id")
+            }
+            if let responseUserID = decoded.userInfo.userID ?? decoded.userID,
+               responseUserID != expectedUserID
+            {
+                throw LiteLLMUsageError.parseFailed("user_id did not match /key/info")
+            }
+
+            let accountEmail = self.firstNonEmpty(
+                decoded.userInfo.userEmail,
+                decoded.userInfo.userAlias,
+                decoded.userInfo.metadata?.preferredUsername)
+            let team = self.preferredTeam(from: decoded.teams, keyTeamID: keyInfo.teamID)
+
+            return LiteLLMUsageSnapshot(
+                userID: expectedUserID,
+                accountEmail: accountEmail,
+                personalSpendUSD: decoded.userInfo.spend ?? 0,
+                personalBudgetUSD: decoded.userInfo.maxBudget,
+                personalResetAt: self.parseDate(decoded.userInfo.budgetResetAt),
+                teamUsage: team.map {
+                    LiteLLMUsageSnapshot.TeamUsage(
+                        id: $0.teamID,
+                        alias: $0.teamAlias,
+                        spendUSD: $0.spend ?? 0,
+                        budgetUSD: $0.maxBudget,
+                        resetAt: self.parseDate($0.budgetResetAt),
+                        budgetDuration: $0.budgetDuration)
+                },
+                keyName: keyInfo.keyName,
+                keyExpiresAt: keyInfo.expiresAt,
+                updatedAt: updatedAt)
+        } catch let error as LiteLLMUsageError {
+            throw error
+        } catch {
+            throw LiteLLMUsageError.parseFailed(error.localizedDescription)
+        }
+    }
+
+    private static func parseTeamInfo(
+        data: Data,
+        keyInfo: LiteLLMKeyInfoSnapshot,
+        updatedAt: Date) throws -> LiteLLMUsageSnapshot
+    {
+        do {
+            let decoded = try JSONDecoder().decode(LiteLLMTeamInfoResponse.self, from: data)
+            guard let expectedTeamID = keyInfo.teamID else {
+                throw LiteLLMUsageError.parseFailed("/team/info requested without a team_id")
+            }
+            if let responseTeamID = self.firstNonEmpty(decoded.teamInfo.teamID, decoded.teamID),
+               responseTeamID != expectedTeamID
+            {
+                throw LiteLLMUsageError.parseFailed("team_id did not match /key/info")
+            }
+
+            let team = decoded.teamInfo
+            return LiteLLMUsageSnapshot(
+                userID: nil,
+                accountEmail: nil,
+                personalSpendUSD: 0,
+                personalBudgetUSD: nil,
+                personalResetAt: nil,
+                teamUsage: LiteLLMUsageSnapshot.TeamUsage(
+                    id: expectedTeamID,
+                    alias: team.teamAlias,
+                    spendUSD: team.spend ?? 0,
+                    budgetUSD: team.maxBudget,
+                    resetAt: self.parseDate(team.budgetResetAt),
+                    budgetDuration: team.budgetDuration),
+                keyName: keyInfo.keyName,
+                keyExpiresAt: keyInfo.expiresAt,
+                updatedAt: updatedAt)
+        } catch let error as LiteLLMUsageError {
+            throw error
+        } catch {
+            throw LiteLLMUsageError.parseFailed(error.localizedDescription)
+        }
+    }
+
+    private static func preferredTeam(
+        from teams: [LiteLLMUserInfoResponse.Team]?,
+        keyTeamID: String?) -> LiteLLMUserInfoResponse.Team?
+    {
+        guard let teams, let keyTeamID else { return nil }
+        return teams.first(where: { $0.teamID == keyTeamID })
+    }
+
+    private static func parseDate(_ raw: String?) -> Date? {
+        guard let raw else { return nil }
+        if let date = self.iso8601DateFormatter(fractionalSeconds: true).date(from: raw) {
+            return date
+        }
+        return self.iso8601DateFormatter(fractionalSeconds: false).date(from: raw)
+    }
+
+    private static func iso8601DateFormatter(fractionalSeconds: Bool) -> ISO8601DateFormatter {
+        let formatter = ISO8601DateFormatter()
+        if fractionalSeconds {
+            formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        }
+        return formatter
+    }
+
+    private static func firstNonEmpty(_ values: String?...) -> String? {
+        values.lazy
+            .compactMap { $0?.trimmingCharacters(in: .whitespacesAndNewlines) }
+            .first { !$0.isEmpty }
+    }
+
+    private static func nonEmpty(_ value: String?) -> String? {
+        self.firstNonEmpty(value)
+    }
+
+    private static func responseSummary(_ data: Data) -> String {
+        String(bytes: data.prefix(500), encoding: .utf8)?
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            ?? ""
+    }
+}
+
+extension URL {
+    fileprivate func appending(queryItems: [URLQueryItem], pathComponents: [String]) -> URL {
+        let url = pathComponents.reduce(self) { partial, component in
+            partial.appendingPathComponent(component)
+        }
+        guard var components = URLComponents(url: url, resolvingAgainstBaseURL: false) else {
+            return url
+        }
+        components.queryItems = queryItems
+        return components.url ?? url
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Manus/ManusCookieHeader.swift b/Sources/CodexBarCore/Providers/Manus/ManusCookieHeader.swift
new file mode 100644
index 0000000000..8e8260915c
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Manus/ManusCookieHeader.swift
@@ -0,0 +1,42 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public enum ManusCookieHeader {
+    public static let sessionCookieName = "session_id"
+
+    public static func resolveToken(context: ProviderFetchContext) -> String? {
+        guard let settings = context.settings?.manus, settings.cookieSource == .manual else { return nil }
+        return self.token(from: settings.manualCookieHeader)
+    }
+
+    public static func token(from raw: String?) -> String? {
+        guard let raw = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !raw.isEmpty else {
+            return nil
+        }
+
+        if !raw.contains("="), !raw.contains(";") {
+            return raw
+        }
+
+        let pairs = CookieHeaderNormalizer.pairs(from: raw)
+        for pair in pairs where pair.name.caseInsensitiveCompare(self.sessionCookieName) == .orderedSame {
+            let token = pair.value.trimmingCharacters(in: .whitespacesAndNewlines)
+            if !token.isEmpty {
+                return token
+            }
+        }
+        return nil
+    }
+
+    public static func sessionToken(from cookies: [HTTPCookie]) -> String? {
+        for cookie in cookies where cookie.name.caseInsensitiveCompare(self.sessionCookieName) == .orderedSame {
+            let token = cookie.value.trimmingCharacters(in: .whitespacesAndNewlines)
+            if !token.isEmpty {
+                return token
+            }
+        }
+        return nil
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Manus/ManusCookieImporter.swift b/Sources/CodexBarCore/Providers/Manus/ManusCookieImporter.swift
new file mode 100644
index 0000000000..e8affb76ea
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Manus/ManusCookieImporter.swift
@@ -0,0 +1,188 @@
+import Foundation
+
+#if os(macOS)
+import SweetCookieKit
+
+public enum ManusCookieImporter {
+    private static let log = CodexBarLog.logger(LogCategories.manusCookie)
+    private static let cookieClient = BrowserCookieClient()
+    private static let cookieDomains = ["manus.im", "www.manus.im"]
+    private static let cookieImportOrder: BrowserCookieImportOrder =
+        ProviderDefaults.metadata[.manus]?.browserCookieOrder ?? Browser.defaultImportOrder
+    nonisolated(unsafe) static var importSessionOverrideForTesting:
+        ((BrowserDetection, ((String) -> Void)?) throws -> SessionInfo)?
+    nonisolated(unsafe) static var importSessionsOverrideForTesting:
+        ((BrowserDetection, ((String) -> Void)?) throws -> [SessionInfo])?
+
+    public struct SessionInfo: Sendable {
+        public let cookies: [HTTPCookie]
+        public let sourceLabel: String
+
+        public init(cookies: [HTTPCookie], sourceLabel: String) {
+            self.cookies = cookies
+            self.sourceLabel = sourceLabel
+        }
+
+        public var sessionToken: String? {
+            ManusCookieHeader.sessionToken(from: self.cookies)
+        }
+    }
+
+    public static func importSessions(
+        browserDetection: BrowserDetection = BrowserDetection(),
+        logger: ((String) -> Void)? = nil) throws -> [SessionInfo]
+    {
+        if let override = self.importSessionsOverrideForTesting {
+            return try override(browserDetection, logger)
+        }
+        if let override = self.importSessionOverrideForTesting {
+            return try [override(browserDetection, logger)]
+        }
+
+        var sessions: [SessionInfo] = []
+        let candidates = self.cookieImportOrder.cookieImportCandidates(using: browserDetection)
+        for browserSource in candidates {
+            do {
+                let perSource = try self.importSessions(from: browserSource, logger: logger)
+                sessions.append(contentsOf: perSource)
+            } catch {
+                BrowserCookieAccessGate.recordIfNeeded(error)
+                self.emit(
+                    "\(browserSource.displayName) cookie import failed: \(error.localizedDescription)",
+                    logger: logger)
+            }
+        }
+
+        guard !sessions.isEmpty else {
+            throw ManusCookieImportError.noCookies
+        }
+        return sessions
+    }
+
+    public static func importSessions(
+        from browserSource: Browser,
+        logger: ((String) -> Void)? = nil) throws -> [SessionInfo]
+    {
+        let query = BrowserCookieQuery(domains: self.cookieDomains)
+        let log: (String) -> Void = { message in self.emit(message, logger: logger) }
+        let sources = try Self.cookieClient.codexBarRecords(
+            matching: query,
+            in: browserSource,
+            logger: log)
+
+        var sessions: [SessionInfo] = []
+        let grouped = Dictionary(grouping: sources, by: { $0.store.profile.id })
+        let sortedGroups = grouped.values.sorted { lhs, rhs in
+            self.mergedLabel(for: lhs) < self.mergedLabel(for: rhs)
+        }
+
+        for group in sortedGroups where !group.isEmpty {
+            let label = self.mergedLabel(for: group)
+            let mergedRecords = self.mergeRecords(group)
+            guard !mergedRecords.isEmpty else { continue }
+            let httpCookies = BrowserCookieClient.makeHTTPCookies(mergedRecords, origin: query.origin)
+            guard !httpCookies.isEmpty else { continue }
+
+            let session = SessionInfo(cookies: httpCookies, sourceLabel: label)
+            guard let token = session.sessionToken else {
+                continue
+            }
+
+            log("Found \(ManusCookieHeader.sessionCookieName) cookie in \(label)")
+            if !token.isEmpty {
+                sessions.append(session)
+            }
+        }
+
+        return sessions
+    }
+
+    public static func importSession(
+        browserDetection: BrowserDetection = BrowserDetection(),
+        logger: ((String) -> Void)? = nil) throws -> SessionInfo
+    {
+        let sessions = try self.importSessions(browserDetection: browserDetection, logger: logger)
+        guard let first = sessions.first else {
+            throw ManusCookieImportError.noCookies
+        }
+        return first
+    }
+
+    public static func hasSession(
+        browserDetection: BrowserDetection = BrowserDetection(),
+        logger: ((String) -> Void)? = nil) -> Bool
+    {
+        do {
+            _ = try self.importSession(browserDetection: browserDetection, logger: logger)
+            return true
+        } catch {
+            return false
+        }
+    }
+
+    private static func emit(_ message: String, logger: ((String) -> Void)?) {
+        logger?("[manus-cookie] \(message)")
+        self.log.debug(message)
+    }
+
+    private static func mergedLabel(for sources: [BrowserCookieStoreRecords]) -> String {
+        guard let base = sources.map(\.label).min() else { return "Unknown" }
+        if base.hasSuffix(" (Network)") {
+            return String(base.dropLast(" (Network)".count))
+        }
+        return base
+    }
+
+    private static func mergeRecords(_ sources: [BrowserCookieStoreRecords]) -> [BrowserCookieRecord] {
+        let sortedSources = sources.sorted { lhs, rhs in
+            self.storePriority(lhs.store.kind) < self.storePriority(rhs.store.kind)
+        }
+        var mergedByKey: [String: BrowserCookieRecord] = [:]
+        for source in sortedSources {
+            for record in source.records {
+                let key = self.recordKey(record)
+                if let existing = mergedByKey[key] {
+                    if self.shouldReplace(existing: existing, candidate: record) {
+                        mergedByKey[key] = record
+                    }
+                } else {
+                    mergedByKey[key] = record
+                }
+            }
+        }
+        return Array(mergedByKey.values)
+    }
+
+    private static func storePriority(_ kind: BrowserCookieStoreKind) -> Int {
+        switch kind {
+        case .network: 0
+        case .primary: 1
+        case .safari: 2
+        }
+    }
+
+    private static func recordKey(_ record: BrowserCookieRecord) -> String {
+        "\(record.name)|\(record.domain)|\(record.path)"
+    }
+
+    private static func shouldReplace(existing: BrowserCookieRecord, candidate: BrowserCookieRecord) -> Bool {
+        switch (existing.expires, candidate.expires) {
+        case let (lhs?, rhs?): rhs > lhs
+        case (nil, .some): true
+        case (.some, nil): false
+        case (nil, nil): false
+        }
+    }
+}
+
+enum ManusCookieImportError: LocalizedError {
+    case noCookies
+
+    var errorDescription: String? {
+        switch self {
+        case .noCookies:
+            "No Manus session cookies found in browsers. Please log into manus.im."
+        }
+    }
+}
+#endif
diff --git a/Sources/CodexBarCore/Providers/Manus/ManusProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Manus/ManusProviderDescriptor.swift
new file mode 100644
index 0000000000..d3ee45796a
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Manus/ManusProviderDescriptor.swift
@@ -0,0 +1,181 @@
+import Foundation
+
+public enum ManusProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .manus,
+            metadata: ProviderMetadata(
+                id: .manus,
+                displayName: "Manus",
+                sessionLabel: "Monthly credits",
+                weeklyLabel: "Daily refresh",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "",
+                toggleTitle: "Show Manus usage",
+                cliName: "manus",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                browserCookieOrder: ProviderBrowserCookieDefaults.defaultImportOrder,
+                dashboardURL: "https://manus.im",
+                statusPageURL: nil),
+            branding: ProviderBranding(
+                iconStyle: .manus,
+                iconResourceName: "ProviderIcon-manus",
+                color: ProviderColor(red: 52 / 255, green: 50 / 255, blue: 45 / 255)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "Manus cost summary is not supported." }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .web],
+                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [ManusWebFetchStrategy()] })),
+            cli: ProviderCLIConfig(
+                name: "manus",
+                aliases: [],
+                versionDetector: nil))
+    }
+}
+
+struct ManusWebFetchStrategy: ProviderFetchStrategy {
+    private enum SessionTokenSource {
+        case manual
+        case cache
+        case browser
+        case environment
+
+        var shouldCacheAfterFetch: Bool {
+            self == .browser
+        }
+    }
+
+    private struct ResolvedSessionToken {
+        let value: String
+        let source: SessionTokenSource
+    }
+
+    let id: String = "manus.web"
+    let kind: ProviderFetchKind = .web
+    private static let log = CodexBarLog.logger(LogCategories.manusWeb)
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        guard context.settings?.manus?.cookieSource != .off else { return false }
+        if context.settings?.manus?.cookieSource == .manual { return true }
+
+        if let cached = CookieHeaderCache.load(provider: .manus),
+           ManusCookieHeader.token(from: cached.cookieHeader) != nil
+        {
+            return true
+        }
+
+        #if os(macOS)
+        if ManusCookieImporter.hasSession(browserDetection: context.browserDetection) {
+            return true
+        }
+        #endif
+
+        return ManusSettingsReader.sessionToken(environment: context.env) != nil
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        let resolvedTokens = try self.resolveSessionTokens(context: context)
+        guard !resolvedTokens.isEmpty else {
+            throw ManusAPIError.missingToken
+        }
+
+        var sawInvalidToken = false
+        for resolved in resolvedTokens {
+            do {
+                let response = try await ManusUsageFetcher.fetchCredits(sessionToken: resolved.value)
+                self.cacheTokenIfNeeded(resolved, sourceLabel: "web")
+                return self.makeResult(
+                    usage: response.toUsageSnapshot(),
+                    sourceLabel: "web")
+            } catch ManusAPIError.invalidToken {
+                sawInvalidToken = true
+                if resolved.source == .cache {
+                    CookieHeaderCache.clear(provider: .manus)
+                }
+                continue
+            }
+        }
+
+        if sawInvalidToken {
+            throw ManusAPIError.invalidToken
+        }
+        throw ManusAPIError.missingToken
+    }
+
+    func shouldFallback(on error: Error, context _: ProviderFetchContext) -> Bool {
+        if case ManusAPIError.missingToken = error { return false }
+        if case ManusAPIError.invalidCookie = error { return false }
+        if case ManusAPIError.invalidToken = error { return false }
+        return true
+    }
+
+    private func resolveSessionTokens(context: ProviderFetchContext) throws -> [ResolvedSessionToken] {
+        guard context.settings?.manus?.cookieSource != .off else { return [] }
+
+        if context.settings?.manus?.cookieSource == .manual {
+            guard let token = ManusCookieHeader.resolveToken(context: context) else {
+                throw ManusAPIError.invalidCookie
+            }
+            return [ResolvedSessionToken(value: token, source: .manual)]
+        }
+
+        var tokens: [ResolvedSessionToken] = []
+
+        if let cached = CookieHeaderCache.load(provider: .manus),
+           let token = ManusCookieHeader.token(from: cached.cookieHeader)
+        {
+            tokens.append(ResolvedSessionToken(value: token, source: .cache))
+        }
+
+        tokens.append(contentsOf: self.resolveBrowserOrEnvironmentTokens(context: context))
+        return self.deduplicated(tokens)
+    }
+
+    private func resolveBrowserOrEnvironmentTokens(context: ProviderFetchContext) -> [ResolvedSessionToken] {
+        guard context.settings?.manus?.cookieSource != .off else { return [] }
+        var tokens: [ResolvedSessionToken] = []
+
+        #if os(macOS)
+        do {
+            let sessions = try ManusCookieImporter.importSessions(browserDetection: context.browserDetection)
+            tokens.append(contentsOf: sessions.compactMap { session in
+                guard let token = session.sessionToken else { return nil }
+                return ResolvedSessionToken(value: token, source: .browser)
+            })
+        } catch {
+            Self.log.debug("No Manus browser session available: \(error.localizedDescription)")
+        }
+        #endif
+
+        if let token = ManusSettingsReader.sessionToken(environment: context.env) {
+            tokens.append(ResolvedSessionToken(value: token, source: .environment))
+        }
+        return self.deduplicated(tokens)
+    }
+
+    private func deduplicated(_ tokens: [ResolvedSessionToken]) -> [ResolvedSessionToken] {
+        var seen: Set<String> = []
+        var deduplicated: [ResolvedSessionToken] = []
+        for token in tokens where !token.value.isEmpty {
+            if seen.insert(token.value).inserted {
+                deduplicated.append(token)
+            }
+        }
+        return deduplicated
+    }
+
+    private func cacheTokenIfNeeded(_ token: ResolvedSessionToken, sourceLabel: String) {
+        guard token.source.shouldCacheAfterFetch else { return }
+        CookieHeaderCache.store(
+            provider: .manus,
+            cookieHeader: "\(ManusCookieHeader.sessionCookieName)=\(token.value)",
+            sourceLabel: sourceLabel)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Manus/ManusSettingsReader.swift b/Sources/CodexBarCore/Providers/Manus/ManusSettingsReader.swift
new file mode 100644
index 0000000000..3d9fbfa84f
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Manus/ManusSettingsReader.swift
@@ -0,0 +1,31 @@
+import Foundation
+
+public enum ManusSettingsReader {
+    public static func sessionToken(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        let rawToken = environment["MANUS_SESSION_TOKEN"]
+            ?? environment["manus_session_token"]
+            ?? environment["MANUS_SESSION_ID"]
+            ?? environment["manus_session_id"]
+        if let token = ManusCookieHeader.token(from: self.cleaned(rawToken)) {
+            return token
+        }
+
+        let rawCookie = environment["MANUS_COOKIE"] ?? environment["manus_cookie"]
+        return ManusCookieHeader.token(from: self.cleaned(rawCookie))
+    }
+
+    private static func cleaned(_ raw: String?) -> String? {
+        guard var value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
+            return nil
+        }
+
+        if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
+            (value.hasPrefix("'") && value.hasSuffix("'"))
+        {
+            value = String(value.dropFirst().dropLast())
+        }
+
+        value = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        return value.isEmpty ? nil : value
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Manus/ManusUsageFetcher.swift b/Sources/CodexBarCore/Providers/Manus/ManusUsageFetcher.swift
new file mode 100644
index 0000000000..b59f37b074
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Manus/ManusUsageFetcher.swift
@@ -0,0 +1,295 @@
+import Foundation
+
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public struct ManusCreditsResponse: Decodable, Sendable {
+    public let totalCredits: Double
+    public let freeCredits: Double
+    public let periodicCredits: Double
+    public let addonCredits: Double
+    public let refreshCredits: Double
+    public let maxRefreshCredits: Double
+    public let proMonthlyCredits: Double
+    public let eventCredits: Double
+    public let nextRefreshTime: Date?
+    public let refreshInterval: String?
+
+    public init(
+        totalCredits: Double,
+        freeCredits: Double,
+        periodicCredits: Double,
+        addonCredits: Double,
+        refreshCredits: Double,
+        maxRefreshCredits: Double,
+        proMonthlyCredits: Double,
+        eventCredits: Double,
+        nextRefreshTime: Date? = nil,
+        refreshInterval: String? = nil)
+    {
+        self.totalCredits = totalCredits
+        self.freeCredits = freeCredits
+        self.periodicCredits = periodicCredits
+        self.addonCredits = addonCredits
+        self.refreshCredits = refreshCredits
+        self.maxRefreshCredits = maxRefreshCredits
+        self.proMonthlyCredits = proMonthlyCredits
+        self.eventCredits = eventCredits
+        self.nextRefreshTime = nextRefreshTime
+        self.refreshInterval = refreshInterval
+    }
+
+    private enum CodingKeys: String, CodingKey {
+        case totalCredits
+        case freeCredits
+        case periodicCredits
+        case addonCredits
+        case refreshCredits
+        case maxRefreshCredits
+        case proMonthlyCredits
+        case eventCredits
+        case nextRefreshTime
+        case refreshInterval
+    }
+
+    public init(from decoder: any Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.totalCredits = container.decodeLossyDoubleIfPresent(forKey: .totalCredits) ?? 0
+        self.freeCredits = container.decodeLossyDoubleIfPresent(forKey: .freeCredits) ?? 0
+        self.periodicCredits = container.decodeLossyDoubleIfPresent(forKey: .periodicCredits) ?? 0
+        self.addonCredits = container.decodeLossyDoubleIfPresent(forKey: .addonCredits) ?? 0
+        self.refreshCredits = container.decodeLossyDoubleIfPresent(forKey: .refreshCredits) ?? 0
+        self.maxRefreshCredits = container.decodeLossyDoubleIfPresent(forKey: .maxRefreshCredits) ?? 0
+        self.proMonthlyCredits = container.decodeLossyDoubleIfPresent(forKey: .proMonthlyCredits) ?? 0
+        self.eventCredits = container.decodeLossyDoubleIfPresent(forKey: .eventCredits) ?? 0
+        self.nextRefreshTime = container.decodeIfPresentFlexibleDate(forKey: .nextRefreshTime)
+        self.refreshInterval = try? container.decodeIfPresent(String.self, forKey: .refreshInterval)
+    }
+}
+
+public enum ManusUsageFetcher {
+    private static let log = CodexBarLog.logger(LogCategories.manusAPI)
+    private static let creditsURL =
+        URL(string: "https://api.manus.im/user.v1.UserService/GetAvailableCredits")!
+    @TaskLocal static var fetchCreditsOverride:
+        (@Sendable (String, Date) async throws -> ManusCreditsResponse)?
+
+    public static func fetchCredits(
+        sessionToken: String,
+        now: Date = Date()) async throws -> ManusCreditsResponse
+    {
+        if let override = self.fetchCreditsOverride {
+            return try await override(sessionToken, now)
+        }
+
+        guard !sessionToken.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+            throw ManusAPIError.missingToken
+        }
+
+        var request = URLRequest(url: self.creditsURL)
+        request.httpMethod = "POST"
+        request.timeoutInterval = 15
+        request.httpBody = Data("{}".utf8)
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.setValue("Bearer \(sessionToken)", forHTTPHeaderField: "Authorization")
+        request.setValue("https://manus.im", forHTTPHeaderField: "Origin")
+        request.setValue("https://manus.im/", forHTTPHeaderField: "Referer")
+        request.setValue("1", forHTTPHeaderField: "Connect-Protocol-Version")
+        let userAgent = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) " +
+            "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36"
+        request.setValue(
+            userAgent,
+            forHTTPHeaderField: "User-Agent")
+
+        let response = try await ProviderHTTPClient.shared.response(for: request)
+        let data = response.data
+        guard response.statusCode == 200 else {
+            let body = String(data: data, encoding: .utf8) ?? "<binary>"
+            let truncated = body.count > 200 ? String(body.prefix(200)) + "…" : body
+            Self.log.error("Manus API returned \(response.statusCode): \(truncated)")
+            if response.statusCode == 401 || response.statusCode == 403 {
+                throw ManusAPIError.invalidToken
+            }
+            throw ManusAPIError.apiError("HTTP \(response.statusCode)")
+        }
+
+        do {
+            return try self.parseResponse(data)
+        } catch let error as ManusAPIError {
+            throw error
+        } catch {
+            let preview = String(data: data.prefix(500), encoding: .utf8) ?? "<binary>"
+            Self.log.error("Manus parse failed: \(error) — response: \(preview)")
+            throw ManusAPIError.parseFailed(error.localizedDescription)
+        }
+    }
+
+    public static func parseResponse(_ data: Data) throws -> ManusCreditsResponse {
+        let decoder = JSONDecoder()
+
+        // Try envelope first — the direct decoder defaults missing fields to 0,
+        // so it would "succeed" on wrapped payloads and silently return zero credits.
+        if let envelope = try? decoder.decode(ManusCreditsEnvelope.self, from: data),
+           let response = envelope.data ?? envelope.result ?? envelope.response ?? envelope.availableCredits
+        {
+            return response
+        }
+
+        let response = try decoder.decode(ManusCreditsResponse.self, from: data)
+        // The custom decoder defaults every numeric field to 0, so an unrelated JSON
+        // object (e.g. an error payload) would otherwise surface as a bogus zero-credit
+        // snapshot. Require at least one known credits key in the raw payload.
+        guard Self.payloadContainsCreditsField(data: data) else {
+            throw ManusAPIError.parseFailed("response missing expected credits fields")
+        }
+        return response
+    }
+
+    private static let expectedCreditsKeys: Set<String> = [
+        "totalCredits", "freeCredits", "periodicCredits", "addonCredits",
+        "refreshCredits", "maxRefreshCredits", "proMonthlyCredits", "eventCredits",
+    ]
+
+    private static func payloadContainsCreditsField(data: Data) -> Bool {
+        guard let object = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+            return false
+        }
+        return !Self.expectedCreditsKeys.isDisjoint(with: object.keys)
+    }
+}
+
+extension ManusCreditsResponse {
+    public func toUsageSnapshot(now: Date = Date()) -> UsageSnapshot {
+        let primary: RateWindow? = if self.proMonthlyCredits > 0 {
+            RateWindow(
+                usedPercent: min(
+                    100,
+                    max(0, (self.proMonthlyCredits - self.periodicCredits) / self.proMonthlyCredits * 100)),
+                windowMinutes: nil,
+                resetsAt: nil,
+                resetDescription: Self.monthlyDetail(totalCredits: self.totalCredits, freeCredits: self.freeCredits))
+        } else {
+            nil
+        }
+
+        let secondary: RateWindow? = if self.maxRefreshCredits > 0 {
+            RateWindow(
+                usedPercent: min(
+                    100,
+                    max(0, (self.maxRefreshCredits - self.refreshCredits) / self.maxRefreshCredits * 100)),
+                windowMinutes: nil,
+                resetsAt: self.nextRefreshTime,
+                resetDescription: Self.refreshDetail(
+                    refreshCredits: self.refreshCredits,
+                    maxRefreshCredits: self.maxRefreshCredits,
+                    refreshInterval: self.refreshInterval))
+        } else {
+            nil
+        }
+
+        let balance = Self.creditCountString(self.totalCredits)
+        let identity = ProviderIdentitySnapshot(
+            providerID: .manus,
+            accountEmail: nil,
+            accountOrganization: nil,
+            loginMethod: "Balance: \(balance) credits")
+
+        return UsageSnapshot(
+            primary: primary,
+            secondary: secondary,
+            tertiary: nil,
+            providerCost: nil,
+            updatedAt: now,
+            identity: identity)
+    }
+
+    private static func creditCountString(_ value: Double) -> String {
+        let formatter = NumberFormatter()
+        formatter.numberStyle = .decimal
+        formatter.usesGroupingSeparator = true
+        formatter.maximumFractionDigits = 0
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        return formatter.string(from: NSNumber(value: value.rounded())) ?? String(Int(value.rounded()))
+    }
+
+    private static func monthlyDetail(totalCredits: Double, freeCredits: Double) -> String? {
+        let total = self.creditCountString(totalCredits)
+        let free = self.creditCountString(freeCredits)
+        return "Total \(total) • Free \(free)"
+    }
+
+    private static func refreshDetail(
+        refreshCredits: Double,
+        maxRefreshCredits: Double,
+        refreshInterval: String?) -> String?
+    {
+        let refresh = self.creditCountString(refreshCredits)
+        let maxRefresh = self.creditCountString(maxRefreshCredits)
+        if let refreshInterval, !refreshInterval.isEmpty {
+            return "\(refreshInterval.capitalized): \(refresh) / \(maxRefresh)"
+        }
+        return "\(refresh) / \(maxRefresh)"
+    }
+}
+
+public enum ManusAPIError: LocalizedError, Equatable, Sendable {
+    case missingToken
+    case invalidCookie
+    case invalidToken
+    case networkError(String)
+    case apiError(String)
+    case parseFailed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingToken:
+            "No Manus session token provided."
+        case .invalidCookie:
+            "Manus session cookie is invalid."
+        case .invalidToken:
+            "Invalid Manus session token."
+        case let .networkError(message):
+            "Manus network error: \(message)"
+        case let .apiError(message):
+            "Manus API error: \(message)"
+        case let .parseFailed(message):
+            "Failed to parse Manus response: \(message)"
+        }
+    }
+}
+
+private struct ManusCreditsEnvelope: Decodable {
+    let data: ManusCreditsResponse?
+    let result: ManusCreditsResponse?
+    let response: ManusCreditsResponse?
+    let availableCredits: ManusCreditsResponse?
+}
+
+extension KeyedDecodingContainer where K: CodingKey {
+    fileprivate func decodeLossyDoubleIfPresent(forKey key: K) -> Double? {
+        if let value = try? self.decodeIfPresent(Double.self, forKey: key) {
+            return value
+        }
+        if let intValue = try? self.decodeIfPresent(Int.self, forKey: key) {
+            return Double(intValue)
+        }
+        if let stringValue = try? self.decodeIfPresent(String.self, forKey: key) {
+            return Double(stringValue.trimmingCharacters(in: .whitespacesAndNewlines))
+        }
+        return nil
+    }
+
+    fileprivate func decodeIfPresentFlexibleDate(forKey key: K) -> Date? {
+        if let value = try? self.decodeIfPresent(Date.self, forKey: key) {
+            return value
+        }
+        guard let stringValue = try? self.decodeIfPresent(String.self, forKey: key),
+              !stringValue.isEmpty
+        else {
+            return nil
+        }
+        return ISO8601DateFormatter().date(from: stringValue)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/MiMo/MiMoCookieImporter.swift b/Sources/CodexBarCore/Providers/MiMo/MiMoCookieImporter.swift
new file mode 100644
index 0000000000..2b7c0fc2d4
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/MiMo/MiMoCookieImporter.swift
@@ -0,0 +1,265 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+enum MiMoCookieHeader {
+    static let requiredCookieNames: Set<String> = [
+        "api-platform_serviceToken",
+        "userId",
+    ]
+    static let knownCookieNames: Set<String> = requiredCookieNames.union([
+        "api-platform_ph",
+        "api-platform_slh",
+    ])
+
+    static func normalizedHeader(from raw: String?) -> String? {
+        guard let normalized = CookieHeaderNormalizer.normalize(raw) else { return nil }
+        let pairs = CookieHeaderNormalizer.pairs(from: normalized)
+        guard !pairs.isEmpty else { return nil }
+
+        var byName: [String: String] = [:]
+        for pair in pairs {
+            let name = pair.name.trimmingCharacters(in: .whitespacesAndNewlines)
+            let value = pair.value.trimmingCharacters(in: .whitespacesAndNewlines)
+            guard self.knownCookieNames.contains(name), !value.isEmpty else { continue }
+            byName[name] = value
+        }
+
+        guard self.requiredCookieNames.isSubset(of: Set(byName.keys)) else { return nil }
+        return byName.keys.sorted().compactMap { name in
+            guard let value = byName[name] else { return nil }
+            return "\(name)=\(value)"
+        }.joined(separator: "; ")
+    }
+
+    static func header(from cookies: [HTTPCookie]) -> String? {
+        let requestURL = URL(string: "https://platform.xiaomimimo.com/api/v1/balance")!
+        var byName: [String: HTTPCookie] = [:]
+        for cookie in cookies {
+            guard self.knownCookieNames.contains(cookie.name) else { continue }
+            guard !cookie.value.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else { continue }
+            if let expiry = cookie.expiresDate, expiry < Date() { continue }
+            guard Self.matchesRequestURL(cookie: cookie, url: requestURL) else { continue }
+
+            if let existing = byName[cookie.name] {
+                if Self.cookieSortKey(for: cookie) >= Self.cookieSortKey(for: existing) {
+                    byName[cookie.name] = cookie
+                }
+            } else {
+                byName[cookie.name] = cookie
+            }
+        }
+
+        guard self.requiredCookieNames.isSubset(of: Set(byName.keys)) else { return nil }
+        return byName.keys.sorted().compactMap { name in
+            guard let cookie = byName[name] else { return nil }
+            return "\(cookie.name)=\(cookie.value)"
+        }.joined(separator: "; ")
+    }
+
+    private static func matchesRequestURL(cookie: HTTPCookie, url: URL) -> Bool {
+        guard let host = url.host else { return false }
+        let normalizedDomain = cookie.domain.lowercased().trimmingCharacters(in: CharacterSet(charactersIn: "."))
+        guard !normalizedDomain.isEmpty else { return false }
+        guard host == normalizedDomain || host.hasSuffix(".\(normalizedDomain)") else { return false }
+
+        let cookiePath = cookie.path.isEmpty ? "/" : cookie.path
+        let requestPath = url.path.isEmpty ? "/" : url.path
+        if requestPath == cookiePath {
+            return true
+        }
+        guard requestPath.hasPrefix(cookiePath) else { return false }
+        guard cookiePath != "/" else { return true }
+        if cookiePath.hasSuffix("/") {
+            return true
+        }
+        guard
+            let boundaryIndex = requestPath.index(
+                cookiePath.startIndex,
+                offsetBy: cookiePath.count,
+                limitedBy: requestPath.endIndex),
+            boundaryIndex < requestPath.endIndex
+        else {
+            return true
+        }
+        return requestPath[boundaryIndex] == "/"
+    }
+
+    private static func cookieSortKey(for cookie: HTTPCookie) -> (Int, Int, Date) {
+        let pathLength = cookie.path.count
+        let normalizedDomain = cookie.domain.lowercased().trimmingCharacters(in: CharacterSet(charactersIn: "."))
+        let domainLength = normalizedDomain.count
+        let expiry = cookie.expiresDate ?? .distantPast
+        return (pathLength, domainLength, expiry)
+    }
+}
+
+#if os(macOS)
+import SweetCookieKit
+
+private let miMoCookieImportOrder: BrowserCookieImportOrder =
+    ProviderDefaults.metadata[.mimo]?.browserCookieOrder ?? Browser.defaultImportOrder
+
+public enum MiMoCookieImporter {
+    private static let cookieClient = BrowserCookieClient()
+    private static let cookieDomains = [
+        "platform.xiaomimimo.com",
+        "xiaomimimo.com",
+    ]
+
+    public struct SessionInfo: Sendable {
+        public let cookieHeader: String
+        public let sourceLabel: String
+
+        public init(cookieHeader: String, sourceLabel: String) {
+            self.cookieHeader = cookieHeader
+            self.sourceLabel = sourceLabel
+        }
+    }
+
+    nonisolated(unsafe) static var importSessionsOverrideForTesting:
+        ((BrowserDetection, ((String) -> Void)?) throws -> [SessionInfo])?
+
+    public static func importSessions(
+        browserDetection: BrowserDetection,
+        logger: ((String) -> Void)? = nil) throws -> [SessionInfo]
+    {
+        if let override = self.importSessionsOverrideForTesting {
+            return try override(browserDetection, logger)
+        }
+
+        return try self.importSessions(
+            browserDetection: browserDetection,
+            logger: logger,
+            loadRecords: { browserSource, query, log in
+                try Self.cookieClient.codexBarRecords(
+                    matching: query,
+                    in: browserSource,
+                    logger: log)
+            })
+    }
+
+    static func importSessions(
+        browserDetection: BrowserDetection,
+        logger: ((String) -> Void)? = nil,
+        loadRecords: (Browser, BrowserCookieQuery, ((String) -> Void)?) throws
+            -> [BrowserCookieStoreRecords]) throws -> [SessionInfo]
+    {
+        let log: (String) -> Void = { msg in logger?("[mimo-cookie] \(msg)") }
+        var sessions: [SessionInfo] = []
+        var accessDeniedHints: [String] = []
+        let installed = miMoCookieImportOrder.cookieImportCandidates(using: browserDetection)
+        let labels = installed.map(\.displayName).joined(separator: ", ")
+        log("Cookie import candidates: \(labels)")
+
+        for browserSource in installed {
+            do {
+                let query = BrowserCookieQuery(domains: self.cookieDomains)
+                let sources = try loadRecords(browserSource, query, log)
+                sessions.append(contentsOf: self.sessionInfos(from: sources, origin: query.origin))
+            } catch let error as BrowserCookieError {
+                BrowserCookieAccessGate.recordIfNeeded(error)
+                if let hint = error.accessDeniedHint {
+                    accessDeniedHints.append(hint)
+                }
+                log("\(browserSource.displayName) cookie import failed: \(error.localizedDescription)")
+            } catch {
+                BrowserCookieAccessGate.recordIfNeeded(error)
+                log("\(browserSource.displayName) cookie import failed: \(error.localizedDescription)")
+            }
+        }
+
+        if sessions.isEmpty, !accessDeniedHints.isEmpty {
+            let details = Array(Set(accessDeniedHints)).sorted().joined(separator: " ")
+            throw MiMoSettingsError.missingCookie(details: details)
+        }
+        return sessions
+    }
+
+    public static func hasSession(
+        browserDetection: BrowserDetection,
+        logger: ((String) -> Void)? = nil) -> Bool
+    {
+        (try? self.importSessions(browserDetection: browserDetection, logger: logger).isEmpty == false) ?? false
+    }
+
+    static func sessionInfos(
+        from sources: [BrowserCookieStoreRecords],
+        origin: BrowserCookieOriginStrategy = .domainBased) -> [SessionInfo]
+    {
+        let grouped = Dictionary(grouping: sources, by: { $0.store.profile.id })
+        let sortedGroups = grouped.values.sorted { lhs, rhs in
+            self.mergedLabel(for: lhs) < self.mergedLabel(for: rhs)
+        }
+
+        var sessions: [SessionInfo] = []
+        for group in sortedGroups where !group.isEmpty {
+            let label = self.mergedLabel(for: group)
+            let mergedRecords = self.mergeRecords(group)
+            guard !mergedRecords.isEmpty else { continue }
+            let cookies = BrowserCookieClient.makeHTTPCookies(mergedRecords, origin: origin)
+            guard let cookieHeader = MiMoCookieHeader.header(from: cookies) else {
+                continue
+            }
+            sessions.append(SessionInfo(cookieHeader: cookieHeader, sourceLabel: label))
+        }
+        return sessions
+    }
+
+    private static func mergedLabel(for sources: [BrowserCookieStoreRecords]) -> String {
+        guard let base = sources.map(\.label).min() else {
+            return "Unknown"
+        }
+        if base.hasSuffix(" (Network)") {
+            return String(base.dropLast(" (Network)".count))
+        }
+        return base
+    }
+
+    private static func mergeRecords(_ sources: [BrowserCookieStoreRecords]) -> [BrowserCookieRecord] {
+        let sortedSources = sources.sorted { lhs, rhs in
+            self.storePriority(lhs.store.kind) < self.storePriority(rhs.store.kind)
+        }
+        var mergedByKey: [String: BrowserCookieRecord] = [:]
+        for source in sortedSources {
+            for record in source.records {
+                let key = self.recordKey(record)
+                if let existing = mergedByKey[key] {
+                    if self.shouldReplace(existing: existing, candidate: record) {
+                        mergedByKey[key] = record
+                    }
+                } else {
+                    mergedByKey[key] = record
+                }
+            }
+        }
+        return Array(mergedByKey.values)
+    }
+
+    private static func storePriority(_ kind: BrowserCookieStoreKind) -> Int {
+        switch kind {
+        case .network: 0
+        case .primary: 1
+        case .safari: 2
+        }
+    }
+
+    private static func recordKey(_ record: BrowserCookieRecord) -> String {
+        "\(record.name)|\(record.domain)|\(record.path)"
+    }
+
+    private static func shouldReplace(existing: BrowserCookieRecord, candidate: BrowserCookieRecord) -> Bool {
+        switch (existing.expires, candidate.expires) {
+        case let (lhs?, rhs?):
+            rhs > lhs
+        case (nil, .some):
+            true
+        case (.some, nil):
+            false
+        case (nil, nil):
+            false
+        }
+    }
+}
+#endif
diff --git a/Sources/CodexBarCore/Providers/MiMo/MiMoLocalUsageFallback.swift b/Sources/CodexBarCore/Providers/MiMo/MiMoLocalUsageFallback.swift
new file mode 100644
index 0000000000..41a955064d
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/MiMo/MiMoLocalUsageFallback.swift
@@ -0,0 +1,109 @@
+import Foundation
+
+/// Local tracker fallback for MiMo when Xiaomi platform.xiaomimimo.com cookie is unavailable.
+///
+/// Reads the JSON cache produced by `Scripts/mimo-usage.py` which scans
+/// `~/.claude-envs/mimo/.claude/projects/**/*.jsonl` and aggregates token usage
+/// per time window. This is local accounting only — not real platform quota —
+/// but gives users a useful view when SSO cookie access is blocked (keychain,
+/// Chrome session-cookie expiry, etc.).
+///
+/// **Implicit opt-in**: this fallback only triggers when the cache file exists;
+/// users who do not run `Scripts/mimo-usage.py` see no behavior change.
+///
+/// See `docs/mimo.md` "Local fallback (opt-in)" for setup instructions.
+public enum MiMoLocalUsageFallback {
+    public static func defaultCachePath() -> String {
+        "\(NSHomeDirectory())/.codexbar/mimo-local-usage.json"
+    }
+
+    public static func cachePath(environment: [String: String]) -> String {
+        guard let override = environment["MIMO_LOCAL_USAGE_PATH"]?
+            .trimmingCharacters(in: .whitespacesAndNewlines),
+            !override.isEmpty
+        else {
+            return self.defaultCachePath()
+        }
+        return NSString(string: override).expandingTildeInPath
+    }
+
+    public static func cacheExists(environment: [String: String]) -> Bool {
+        FileManager.default.fileExists(atPath: self.cachePath(environment: environment))
+    }
+
+    public static func snapshot(now: Date = Date()) -> MiMoUsageSnapshot? {
+        self.snapshot(cachePath: self.defaultCachePath(), now: now)
+    }
+
+    public static func snapshot(cachePath: String, now: Date = Date()) -> MiMoUsageSnapshot? {
+        let url = URL(fileURLWithPath: cachePath)
+        guard let data = try? Data(contentsOf: url) else { return nil }
+        guard let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else { return nil }
+        guard let windows = json["windows"] as? [String: Any],
+              let week = windows["week"] as? [String: Any],
+              let today = windows["today"] as? [String: Any],
+              let allTime = windows["all_time"] as? [String: Any]
+        else {
+            return nil
+        }
+        let sessionsScanned = Self.intValue(json["sessions_scanned"])
+        let weekTotal = Self.total(for: week)
+        let todayTotal = Self.total(for: today)
+        let allTotal = Self.total(for: allTime)
+
+        var parts = ["Local"]
+        if todayTotal > 0 { parts.append("\(Self.fmtTokens(todayTotal)) today") }
+        if weekTotal > 0 { parts.append("\(Self.fmtTokens(weekTotal)) week") }
+        if allTotal > 0 { parts.append("\(Self.fmtTokens(allTotal)) total") }
+        parts.append("\(sessionsScanned) sessions")
+        let planCode = parts.joined(separator: " · ")
+
+        return MiMoUsageSnapshot(
+            balance: 0,
+            currency: "",
+            planCode: planCode,
+            planPeriodEnd: nil,
+            planExpired: false,
+            tokenUsed: 0,
+            tokenLimit: 0,
+            tokenPercent: 0,
+            updatedAt: Self.updatedAt(json: json, url: url, fallback: now))
+    }
+
+    private static func fmtTokens(_ n: Int) -> String {
+        if n >= 1_000_000 { return String(format: "%.1fM", Double(n) / 1_000_000) }
+        if n >= 1000 { return String(format: "%.1fk", Double(n) / 1000) }
+        return "\(n)"
+    }
+
+    private static func total(for window: [String: Any]) -> Int {
+        ["input", "output", "cache_read", "cache_create"].reduce(into: 0) { total, key in
+            let (sum, overflow) = total.addingReportingOverflow(Self.intValue(window[key]))
+            total = overflow ? Int.max : sum
+        }
+    }
+
+    private static func intValue(_ raw: Any?) -> Int {
+        if let i = raw as? Int { return max(0, i) }
+        if let d = raw as? Double,
+           d.isFinite,
+           d >= 0,
+           d <= Double(Int.max)
+        {
+            return Int(d)
+        }
+        if let s = raw as? String, let i = Int(s) { return max(0, i) }
+        return 0
+    }
+
+    private static func updatedAt(json: [String: Any], url: URL, fallback: Date) -> Date {
+        if let raw = json["updated_at"] as? String {
+            let fractional = ISO8601DateFormatter()
+            fractional.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+            if let parsed = fractional.date(from: raw) ?? ISO8601DateFormatter().date(from: raw) {
+                return parsed
+            }
+        }
+        return (try? url.resourceValues(forKeys: [.contentModificationDateKey]).contentModificationDate) ?? fallback
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/MiMo/MiMoProviderDescriptor.swift b/Sources/CodexBarCore/Providers/MiMo/MiMoProviderDescriptor.swift
new file mode 100644
index 0000000000..9ceab352a7
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/MiMo/MiMoProviderDescriptor.swift
@@ -0,0 +1,212 @@
+import Foundation
+
+public enum MiMoProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .mimo,
+            metadata: ProviderMetadata(
+                id: .mimo,
+                displayName: "Xiaomi MiMo",
+                sessionLabel: "Credits",
+                weeklyLabel: "Window",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: true,
+                creditsHint: "Token plan credits usage.",
+                toggleTitle: "Show Xiaomi MiMo token plan & balance",
+                cliName: "mimo",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                browserCookieOrder: ProviderBrowserCookieDefaults.mimoCookieImportOrder,
+                dashboardURL: "https://platform.xiaomimimo.com/#/console/balance",
+                statusPageURL: nil),
+            branding: ProviderBranding(
+                iconStyle: .mimo,
+                iconResourceName: "ProviderIcon-mimo",
+                color: ProviderColor(red: 1.0, green: 105 / 255, blue: 0)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "Xiaomi MiMo cost summary is not supported." }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .web],
+                pipeline: ProviderFetchPipeline(resolveStrategies: { context in
+                    if context.sourceMode == .web {
+                        return [MiMoWebFetchStrategy()]
+                    }
+                    return [MiMoWebFetchStrategy(), MiMoLocalFetchStrategy()]
+                })),
+            cli: ProviderCLIConfig(
+                name: "mimo",
+                aliases: ["xiaomi-mimo"],
+                versionDetector: nil))
+    }
+}
+
+struct MiMoWebFetchStrategy: ProviderFetchStrategy {
+    let id: String = "mimo.web"
+    let kind: ProviderFetchKind = .web
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        guard context.settings?.mimo?.cookieSource != .off else { return false }
+        if context.settings?.mimo?.cookieSource == .manual {
+            return Self.resolveManualCookieHeader(context: context) != nil
+        }
+        // Fetch resolves the session so missing-cookie and browser-permission errors stay actionable.
+        return true
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        try await self.fetchFromWeb(context)
+    }
+
+    static func shouldFallbackToLocal(error: Error) -> Bool {
+        if let settingsError = error as? MiMoSettingsError {
+            switch settingsError {
+            case .missingCookie, .invalidCookie:
+                return true
+            case .invalidEndpointOverride:
+                return false
+            }
+        }
+        guard let mimoError = error as? MiMoUsageError else { return false }
+        switch mimoError {
+        case .invalidCredentials, .loginRequired: return true
+        case .parseFailed, .networkError: return false
+        }
+    }
+
+    private func fetchFromWeb(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        guard context.settings?.mimo?.cookieSource != .off else {
+            throw MiMoSettingsError.missingCookie()
+        }
+        if context.settings?.mimo?.cookieSource == .manual {
+            guard let manualCookie = Self.resolveManualCookieHeader(context: context) else {
+                throw MiMoSettingsError.invalidCookie
+            }
+            let snapshot = try await MiMoUsageFetcher.fetchUsage(
+                cookieHeader: manualCookie,
+                environment: context.env)
+            return self.makeResult(usage: snapshot.toUsageSnapshot(), sourceLabel: "web")
+        }
+        if let manualCookie = Self.resolveManualCookieHeader(context: context) {
+            let snapshot = try await MiMoUsageFetcher.fetchUsage(
+                cookieHeader: manualCookie,
+                environment: context.env)
+            return self.makeResult(usage: snapshot.toUsageSnapshot(), sourceLabel: "web")
+        }
+
+        #if os(macOS)
+        var lastError: Error?
+
+        if let cached = CookieHeaderCache.load(provider: .mimo),
+           let cachedHeader = MiMoCookieHeader.normalizedHeader(from: cached.cookieHeader)
+        {
+            do {
+                let snapshot = try await MiMoUsageFetcher.fetchUsage(
+                    cookieHeader: cachedHeader,
+                    environment: context.env)
+                return self.makeResult(usage: snapshot.toUsageSnapshot(), sourceLabel: "web")
+            } catch {
+                guard Self.shouldRetryNextSession(for: error) else {
+                    throw error
+                }
+                CookieHeaderCache.clear(provider: .mimo)
+                lastError = error
+            }
+        }
+
+        let sessions = try MiMoCookieImporter.importSessions(browserDetection: context.browserDetection)
+        guard !sessions.isEmpty else {
+            if let lastError { throw lastError }
+            throw MiMoSettingsError.missingCookie()
+        }
+
+        for session in sessions {
+            do {
+                let snapshot = try await MiMoUsageFetcher.fetchUsage(
+                    cookieHeader: session.cookieHeader,
+                    environment: context.env)
+                CookieHeaderCache.store(
+                    provider: .mimo,
+                    cookieHeader: session.cookieHeader,
+                    sourceLabel: session.sourceLabel)
+                return self.makeResult(usage: snapshot.toUsageSnapshot(), sourceLabel: "web")
+            } catch {
+                guard Self.shouldRetryNextSession(for: error) else {
+                    throw error
+                }
+                lastError = error
+                continue
+            }
+        }
+
+        if let lastError { throw lastError }
+        throw MiMoSettingsError.missingCookie()
+        #else
+        throw MiMoSettingsError.missingCookie()
+        #endif
+    }
+
+    func shouldFallback(on error: Error, context _: ProviderFetchContext) -> Bool {
+        Self.shouldFallbackToLocal(error: error)
+    }
+
+    private static func resolveManualCookieHeader(context: ProviderFetchContext) -> String? {
+        guard context.settings?.mimo?.cookieSource == .manual else { return nil }
+        return MiMoCookieHeader.normalizedHeader(from: context.settings?.mimo?.manualCookieHeader)
+    }
+
+    private static func shouldRetryNextSession(for error: Error) -> Bool {
+        if error is DecodingError {
+            return true
+        }
+        guard let mimoError = error as? MiMoUsageError else {
+            return false
+        }
+        switch mimoError {
+        case .invalidCredentials, .loginRequired, .parseFailed:
+            return true
+        case .networkError:
+            return false
+        }
+    }
+}
+
+enum MiMoLocalUsageError: LocalizedError {
+    case invalidCache(String)
+
+    var errorDescription: String? {
+        switch self {
+        case let .invalidCache(path):
+            "Xiaomi MiMo local usage cache is unreadable or malformed: \(path)"
+        }
+    }
+}
+
+struct MiMoLocalFetchStrategy: ProviderFetchStrategy {
+    let id: String = "mimo.local"
+    let kind: ProviderFetchKind = .localProbe
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        MiMoLocalUsageFallback.cacheExists(environment: context.env)
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        let path = Self.cachePath(context: context)
+        guard let snapshot = MiMoLocalUsageFallback.snapshot(cachePath: path) else {
+            throw MiMoLocalUsageError.invalidCache(path)
+        }
+        return self.makeResult(usage: snapshot.toUsageSnapshot(includeBalance: false), sourceLabel: "local")
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+
+    private static func cachePath(context: ProviderFetchContext) -> String {
+        MiMoLocalUsageFallback.cachePath(environment: context.env)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/MiMo/MiMoUsageFetcher.swift b/Sources/CodexBarCore/Providers/MiMo/MiMoUsageFetcher.swift
new file mode 100644
index 0000000000..e9b4e01612
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/MiMo/MiMoUsageFetcher.swift
@@ -0,0 +1,354 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public enum MiMoSettingsError: LocalizedError, Sendable, Equatable {
+    case missingCookie(details: String? = nil)
+    case invalidCookie
+    case invalidEndpointOverride(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case let .missingCookie(details):
+            [
+                "No Xiaomi MiMo browser session found. Log in at platform.xiaomimimo.com first.",
+                details,
+            ]
+                .compactMap(\.self)
+                .joined(separator: " ")
+        case .invalidCookie:
+            "Xiaomi MiMo requires the api-platform_serviceToken and userId cookies."
+        case let .invalidEndpointOverride(key):
+            "Xiaomi MiMo endpoint override \(key) must use HTTPS or a bare host."
+        }
+    }
+}
+
+public enum MiMoUsageError: LocalizedError, Sendable {
+    case invalidCredentials
+    case loginRequired
+    case parseFailed(String)
+    case networkError(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .invalidCredentials:
+            "Xiaomi MiMo browser session expired. Log in again."
+        case .loginRequired:
+            "Xiaomi MiMo login required."
+        case let .parseFailed(message):
+            "Could not parse Xiaomi MiMo balance: \(message)"
+        case let .networkError(message):
+            "Xiaomi MiMo request failed: \(message)"
+        }
+    }
+}
+
+public enum MiMoSettingsReader {
+    public static let apiURLKey = "MIMO_API_URL"
+
+    public static func apiURL(environment: [String: String] = ProcessInfo.processInfo.environment) -> URL {
+        if let override = self.cleaned(environment[self.apiURLKey]),
+           let url = ProviderEndpointOverrideValidator.normalizedHTTPSURL(from: override)
+        {
+            return url
+        }
+        return URL(string: "https://platform.xiaomimimo.com/api/v1")!
+    }
+
+    public static func validateEndpointOverrides(
+        environment: [String: String] = ProcessInfo.processInfo.environment) throws
+    {
+        guard let override = self.cleaned(environment[self.apiURLKey]) else { return }
+        guard ProviderEndpointOverrideValidator.normalizedHTTPSURL(from: override) == nil else { return }
+        throw MiMoSettingsError.invalidEndpointOverride(self.apiURLKey)
+    }
+
+    private static func cleaned(_ raw: String?) -> String? {
+        guard let value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else { return nil }
+        return value
+    }
+}
+
+public enum MiMoUsageFetcher {
+    private static let requestTimeout: TimeInterval = 15
+
+    public static func fetchUsage(
+        cookieHeader: String,
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        now: Date = Date(),
+        session transport: any ProviderHTTPTransport = ProviderHTTPClient.shared) async throws -> MiMoUsageSnapshot
+    {
+        guard let normalizedCookie = MiMoCookieHeader.normalizedHeader(from: cookieHeader) else {
+            throw MiMoSettingsError.invalidCookie
+        }
+        try MiMoSettingsReader.validateEndpointOverrides(environment: environment)
+
+        let balanceURL = MiMoSettingsReader.apiURL(environment: environment).appendingPathComponent("balance")
+        let tokenDetailURL = MiMoSettingsReader.apiURL(environment: environment)
+            .appendingPathComponent("tokenPlan/detail")
+        let tokenUsageURL = MiMoSettingsReader.apiURL(environment: environment)
+            .appendingPathComponent("tokenPlan/usage")
+
+        let payloads = try await self.fetchPayloads(
+            balanceURL: balanceURL,
+            tokenDetailURL: tokenDetailURL,
+            tokenUsageURL: tokenUsageURL,
+            cookie: normalizedCookie,
+            transport: transport)
+
+        return try self.parseCombinedSnapshot(
+            balanceData: payloads.balance,
+            tokenDetailData: payloads.tokenDetail,
+            tokenUsageData: payloads.tokenUsage,
+            now: now)
+    }
+
+    private enum FetchPart {
+        case balance(Data)
+        case tokenDetail(Data?)
+        case tokenUsage(Data?)
+    }
+
+    private static func fetchPayloads(
+        balanceURL: URL,
+        tokenDetailURL: URL,
+        tokenUsageURL: URL,
+        cookie: String,
+        transport: any ProviderHTTPTransport) async throws -> (balance: Data, tokenDetail: Data?, tokenUsage: Data?)
+    {
+        try await withThrowingTaskGroup(of: FetchPart.self) { group in
+            group.addTask {
+                try await .balance(self.fetchAuthenticated(
+                    url: balanceURL,
+                    cookie: cookie,
+                    transport: transport))
+            }
+            group.addTask {
+                await .tokenDetail(try? self.fetchAuthenticated(
+                    url: tokenDetailURL,
+                    cookie: cookie,
+                    transport: transport))
+            }
+            group.addTask {
+                await .tokenUsage(try? self.fetchAuthenticated(
+                    url: tokenUsageURL,
+                    cookie: cookie,
+                    transport: transport))
+            }
+
+            var balance: Data?
+            var tokenDetail: Data?
+            var tokenUsage: Data?
+
+            while let part = try await group.next() {
+                switch part {
+                case let .balance(data):
+                    balance = data
+                case let .tokenDetail(data):
+                    tokenDetail = data
+                case let .tokenUsage(data):
+                    tokenUsage = data
+                }
+            }
+
+            guard let balance else {
+                throw MiMoUsageError.networkError("Balance request did not complete")
+            }
+            return (balance, tokenDetail, tokenUsage)
+        }
+    }
+
+    private static func fetchAuthenticated(
+        url: URL,
+        cookie: String,
+        transport: any ProviderHTTPTransport = ProviderHTTPClient.shared) async throws -> Data
+    {
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.timeoutInterval = Self.requestTimeout
+        request.setValue("application/json, text/plain, */*", forHTTPHeaderField: "Accept")
+        request.setValue(cookie, forHTTPHeaderField: "Cookie")
+        request.setValue("en-US,en;q=0.9", forHTTPHeaderField: "Accept-Language")
+        request.setValue("UTC+01:00", forHTTPHeaderField: "x-timeZone")
+        request.setValue("https://platform.xiaomimimo.com", forHTTPHeaderField: "Origin")
+        request.setValue("https://platform.xiaomimimo.com/#/console/balance", forHTTPHeaderField: "Referer")
+        request.setValue(
+            "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) " +
+                "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36",
+            forHTTPHeaderField: "User-Agent")
+
+        let response = try await transport.response(for: request)
+
+        switch response.statusCode {
+        case 200:
+            break
+        // Expired browser sessions can redirect API requests to the login flow.
+        case 300..<400:
+            throw MiMoUsageError.loginRequired
+        case 401:
+            throw MiMoUsageError.loginRequired
+        case 403:
+            throw MiMoUsageError.invalidCredentials
+        default:
+            throw MiMoUsageError.networkError("HTTP \(response.statusCode)")
+        }
+
+        return response.data
+    }
+
+    static func parseCombinedSnapshot(
+        balanceData: Data,
+        tokenDetailData: Data?,
+        tokenUsageData: Data?,
+        now: Date = Date()) throws -> MiMoUsageSnapshot
+    {
+        let balanceSnapshot = try self.parseUsageSnapshot(from: balanceData, now: now)
+        let planDetail: (planCode: String?, periodEnd: Date?, expired: Bool) = {
+            guard let data = tokenDetailData, let result = try? self.parseTokenPlanDetail(from: data) else {
+                return (planCode: nil, periodEnd: nil, expired: false)
+            }
+            return result
+        }()
+        let planUsage: (used: Int, limit: Int, percent: Double) = {
+            guard let data = tokenUsageData, let result = try? self.parseTokenPlanUsage(from: data) else {
+                return (used: 0, limit: 0, percent: 0)
+            }
+            return result
+        }()
+
+        return MiMoUsageSnapshot(
+            balance: balanceSnapshot.balance,
+            currency: balanceSnapshot.currency,
+            cashBalance: balanceSnapshot.cashBalance,
+            giftBalance: balanceSnapshot.giftBalance,
+            planCode: planDetail.planCode,
+            planPeriodEnd: planDetail.periodEnd,
+            planExpired: planDetail.expired,
+            tokenUsed: planUsage.used,
+            tokenLimit: planUsage.limit,
+            tokenPercent: planUsage.percent,
+            updatedAt: now)
+    }
+
+    static func parseUsageSnapshot(from data: Data, now: Date = Date()) throws -> MiMoUsageSnapshot {
+        let decoder = JSONDecoder()
+        let response = try decoder.decode(BalanceResponse.self, from: data)
+
+        guard response.code == 0 else {
+            let message = response.message?.trimmingCharacters(in: .whitespacesAndNewlines)
+            if response.code == 401 {
+                throw MiMoUsageError.loginRequired
+            }
+            if response.code == 403 {
+                throw MiMoUsageError.invalidCredentials
+            }
+            throw MiMoUsageError.parseFailed(message?.isEmpty == false ? message! : "code \(response.code)")
+        }
+
+        guard let data = response.data else {
+            throw MiMoUsageError.parseFailed("Missing balance payload")
+        }
+        guard let balance = Double(data.balance) else {
+            throw MiMoUsageError.parseFailed("Invalid balance value")
+        }
+        let cashBalance = data.cashBalance.flatMap(Double.init)
+        let giftBalance = data.giftBalance.flatMap(Double.init)
+
+        let currency = data.currency.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !currency.isEmpty else {
+            throw MiMoUsageError.parseFailed("Missing currency")
+        }
+
+        return MiMoUsageSnapshot(
+            balance: balance,
+            currency: currency,
+            cashBalance: cashBalance,
+            giftBalance: giftBalance,
+            updatedAt: now)
+    }
+
+    static func parseTokenPlanDetail(from data: Data) throws -> (planCode: String?, periodEnd: Date?, expired: Bool) {
+        let decoder = JSONDecoder()
+        let response = try decoder.decode(TokenPlanDetailResponse.self, from: data)
+
+        guard response.code == 0, let payload = response.data else {
+            return (planCode: nil, periodEnd: nil, expired: false)
+        }
+
+        let formatter = DateFormatter()
+        formatter.dateFormat = "yyyy-MM-dd HH:mm:ss"
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        formatter.timeZone = TimeZone(secondsFromGMT: 0)
+
+        let periodEnd: Date? = if let dateStr = payload.currentPeriodEnd {
+            formatter.date(from: dateStr)
+        } else {
+            nil
+        }
+
+        return (planCode: payload.planCode, periodEnd: periodEnd, expired: payload.expired)
+    }
+
+    static func parseTokenPlanUsage(from data: Data) throws -> (used: Int, limit: Int, percent: Double) {
+        let decoder = JSONDecoder()
+        let response = try decoder.decode(TokenPlanUsageResponse.self, from: data)
+
+        guard response.code == 0,
+              let monthUsage = response.data?.monthUsage,
+              let item = monthUsage.items.first
+        else {
+            return (used: 0, limit: 0, percent: 0)
+        }
+
+        return (used: item.used, limit: item.limit, percent: item.percent)
+    }
+
+    private struct BalanceResponse: Decodable {
+        let code: Int
+        let message: String?
+        let data: BalancePayload?
+    }
+
+    private struct BalancePayload: Decodable {
+        let balance: String
+        let currency: String
+        let cashBalance: String?
+        let giftBalance: String?
+    }
+
+    private struct TokenPlanDetailResponse: Decodable {
+        let code: Int
+        let message: String?
+        let data: TokenPlanDetailPayload?
+    }
+
+    private struct TokenPlanDetailPayload: Decodable {
+        let planCode: String?
+        let currentPeriodEnd: String?
+        let expired: Bool
+    }
+
+    private struct TokenPlanUsageResponse: Decodable {
+        let code: Int
+        let message: String?
+        let data: TokenPlanUsagePayload?
+    }
+
+    private struct TokenPlanUsagePayload: Decodable {
+        let monthUsage: MonthUsage?
+    }
+
+    private struct MonthUsage: Decodable {
+        let percent: Double
+        let items: [UsageItem]
+    }
+
+    private struct UsageItem: Decodable {
+        let name: String
+        let used: Int
+        let limit: Int
+        let percent: Double
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/MiMo/MiMoUsageSnapshot.swift b/Sources/CodexBarCore/Providers/MiMo/MiMoUsageSnapshot.swift
new file mode 100644
index 0000000000..095f6ae450
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/MiMo/MiMoUsageSnapshot.swift
@@ -0,0 +1,96 @@
+import Foundation
+
+public struct MiMoUsageSnapshot: Codable, Sendable {
+    public let balance: Double
+    public let currency: String
+    public let cashBalance: Double?
+    public let giftBalance: Double?
+    public let planCode: String?
+    public let planPeriodEnd: Date?
+    public let planExpired: Bool
+    public let tokenUsed: Int
+    public let tokenLimit: Int
+    public let tokenPercent: Double
+    public let updatedAt: Date
+
+    public init(
+        balance: Double,
+        currency: String,
+        cashBalance: Double? = nil,
+        giftBalance: Double? = nil,
+        planCode: String? = nil,
+        planPeriodEnd: Date? = nil,
+        planExpired: Bool = false,
+        tokenUsed: Int = 0,
+        tokenLimit: Int = 0,
+        tokenPercent: Double = 0,
+        updatedAt: Date)
+    {
+        self.balance = balance
+        self.currency = currency
+        self.cashBalance = cashBalance
+        self.giftBalance = giftBalance
+        self.planCode = planCode
+        self.planPeriodEnd = planPeriodEnd
+        self.planExpired = planExpired
+        self.tokenUsed = tokenUsed
+        self.tokenLimit = tokenLimit
+        self.tokenPercent = tokenPercent
+        self.updatedAt = updatedAt
+    }
+}
+
+extension MiMoUsageSnapshot {
+    public var balanceDetail: String {
+        let trimmedCurrency = self.currency.trimmingCharacters(in: .whitespacesAndNewlines)
+        let balanceText = UsageFormatter.currencyString(self.balance, currencyCode: trimmedCurrency)
+        guard let cashBalance = self.cashBalance, let giftBalance = self.giftBalance else {
+            return balanceText
+        }
+        let paid = UsageFormatter.currencyString(cashBalance, currencyCode: trimmedCurrency)
+        let granted = UsageFormatter.currencyString(giftBalance, currencyCode: trimmedCurrency)
+        return "\(balanceText) (Paid: \(paid) / Granted: \(granted))"
+    }
+
+    public func toUsageSnapshot(includeBalance: Bool = true) -> UsageSnapshot {
+        let tokenWindow: RateWindow? = {
+            guard self.tokenLimit > 0 else { return nil }
+            let usedPercent = max(0, min(100, self.tokenPercent * 100))
+            let usedText = Self.fullCountString(self.tokenUsed)
+            let limitText = Self.fullCountString(self.tokenLimit)
+            let resetDesc = "\(usedText) / \(limitText) Credits"
+            return RateWindow(
+                usedPercent: usedPercent,
+                windowMinutes: nil,
+                resetsAt: self.planPeriodEnd,
+                resetDescription: resetDesc)
+        }()
+
+        let planLabel: String? = {
+            guard let planCode = self.planCode else { return nil }
+            return planCode.capitalized
+        }()
+
+        let identity = ProviderIdentitySnapshot(
+            providerID: .mimo,
+            accountEmail: nil,
+            accountOrganization: nil,
+            loginMethod: planLabel)
+
+        return UsageSnapshot(
+            primary: tokenWindow,
+            secondary: nil,
+            tertiary: nil,
+            mimoUsage: includeBalance ? self : nil,
+            updatedAt: self.updatedAt,
+            identity: identity)
+    }
+
+    private static func fullCountString(_ value: Int) -> String {
+        let formatter = NumberFormatter()
+        formatter.numberStyle = .decimal
+        formatter.usesGroupingSeparator = true
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        return formatter.string(from: NSNumber(value: value)) ?? "\(value)"
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/MiniMax/MiniMaxAPIRegion.swift b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxAPIRegion.swift
index 8428f81f76..56e77e2c75 100644
--- a/Sources/CodexBarCore/Providers/MiniMax/MiniMaxAPIRegion.swift
+++ b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxAPIRegion.swift
@@ -7,6 +7,8 @@ public enum MiniMaxAPIRegion: String, CaseIterable, Sendable {
     private static let codingPlanPath = "user-center/payment/coding-plan"
     private static let codingPlanQuery = "cycle_type=3"
     private static let remainsPath = "v1/api/openplatform/coding_plan/remains"
+    private static let tokenPlanRemainsPath = "v1/token_plan/remains"
+    private static let billingHistoryPath = "account/amount"
 
     public var displayName: String {
         switch self {
@@ -55,4 +57,26 @@ public enum MiniMaxAPIRegion: String, CaseIterable, Sendable {
     public var apiRemainsURL: URL {
         URL(string: self.apiBaseURLString)!.appendingPathComponent(Self.remainsPath)
     }
+
+    public var tokenPlanRemainsURL: URL {
+        URL(string: self.apiBaseURLString)!.appendingPathComponent(Self.tokenPlanRemainsPath)
+    }
+
+    public var dashboardURL: URL {
+        var components = URLComponents(string: self.baseURLString)!
+        components.path = "/" + Self.codingPlanPath
+        components.query = Self.codingPlanQuery
+        return components.url!
+    }
+
+    public func billingHistoryURL(page: Int, limit: Int) -> URL {
+        var components = URLComponents(string: self.baseURLString)!
+        components.path = "/" + Self.billingHistoryPath
+        components.queryItems = [
+            URLQueryItem(name: "page", value: "\(page)"),
+            URLQueryItem(name: "limit", value: "\(limit)"),
+            URLQueryItem(name: "aggregate", value: "false"),
+        ]
+        return components.url!
+    }
 }
diff --git a/Sources/CodexBarCore/Providers/MiniMax/MiniMaxAPISettingsReader.swift b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxAPISettingsReader.swift
index ed9e41138f..ab1a2359b0 100644
--- a/Sources/CodexBarCore/Providers/MiniMax/MiniMaxAPISettingsReader.swift
+++ b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxAPISettingsReader.swift
@@ -2,6 +2,11 @@ import Foundation
 
 public struct MiniMaxAPISettingsReader: Sendable {
     public static let apiTokenKey = "MINIMAX_API_KEY"
+    public static let codingPlanAPITokenKey = "MINIMAX_CODING_API_KEY"
+    public static let apiTokenEnvironmentKeys = [
+        Self.codingPlanAPITokenKey,
+        Self.apiTokenKey,
+    ]
 
     public enum APIKeyKind: Sendable {
         case codingPlan
@@ -12,7 +17,9 @@ public struct MiniMaxAPISettingsReader: Sendable {
     public static func apiToken(
         environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
     {
-        if let token = self.cleaned(environment[apiTokenKey]) { return token }
+        for key in self.apiTokenEnvironmentKeys {
+            if let token = self.cleaned(environment[key]) { return token }
+        }
         return nil
     }
 
@@ -37,8 +44,7 @@ public struct MiniMaxAPISettingsReader: Sendable {
         if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
             (value.hasPrefix("'") && value.hasSuffix("'"))
         {
-            value.removeFirst()
-            value.removeLast()
+            value = String(value.dropFirst().dropLast())
         }
 
         value = value.trimmingCharacters(in: .whitespacesAndNewlines)
@@ -52,7 +58,8 @@ public enum MiniMaxAPISettingsError: LocalizedError, Sendable {
     public var errorDescription: String? {
         switch self {
         case .missingToken:
-            "MiniMax API token not found. Set apiKey in ~/.codexbar/config.json or MINIMAX_API_KEY."
+            "MiniMax API token not found. Set apiKey in ~/.codexbar/config.json, " +
+                "MINIMAX_CODING_API_KEY, or MINIMAX_API_KEY."
         }
     }
 }
diff --git a/Sources/CodexBarCore/Providers/MiniMax/MiniMaxAuthMode.swift b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxAuthMode.swift
index 89f4c9c81d..ea0fd87a68 100644
--- a/Sources/CodexBarCore/Providers/MiniMax/MiniMaxAuthMode.swift
+++ b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxAuthMode.swift
@@ -29,6 +29,14 @@ public enum MiniMaxAuthMode: Sendable {
         self != .apiToken
     }
 
+    public var description: String {
+        switch self {
+        case .apiToken: "apiToken"
+        case .cookie: "cookie"
+        case .none: "none"
+        }
+    }
+
     private static func cleaned(_ raw: String?) -> String? {
         guard let value = raw?.trimmingCharacters(in: .whitespacesAndNewlines),
               !value.isEmpty
diff --git a/Sources/CodexBarCore/Providers/MiniMax/MiniMaxBillingHistory.swift b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxBillingHistory.swift
new file mode 100644
index 0000000000..159e72af8c
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxBillingHistory.swift
@@ -0,0 +1,360 @@
+import Foundation
+
+public struct MiniMaxBillingSummary: Sendable {
+    public let todayTokens: Int
+    public let last30DaysTokens: Int
+    public let todayCash: Double?
+    public let last30DaysCash: Double?
+    public let daily: [MiniMaxBillingDay]
+    public let topMethods: [MiniMaxBillingBreakdown]
+    public let topModels: [MiniMaxBillingBreakdown]
+    public let updatedAt: Date
+
+    public init(
+        todayTokens: Int,
+        last30DaysTokens: Int,
+        todayCash: Double?,
+        last30DaysCash: Double?,
+        daily: [MiniMaxBillingDay],
+        topMethods: [MiniMaxBillingBreakdown],
+        topModels: [MiniMaxBillingBreakdown],
+        updatedAt: Date)
+    {
+        self.todayTokens = todayTokens
+        self.last30DaysTokens = last30DaysTokens
+        self.todayCash = todayCash
+        self.last30DaysCash = last30DaysCash
+        self.daily = daily
+        self.topMethods = topMethods
+        self.topModels = topModels
+        self.updatedAt = updatedAt
+    }
+}
+
+public struct MiniMaxBillingDay: Sendable, Equatable {
+    public let day: String
+    public let tokens: Int
+    public let cash: Double?
+
+    public init(day: String, tokens: Int, cash: Double?) {
+        self.day = day
+        self.tokens = tokens
+        self.cash = cash
+    }
+}
+
+public struct MiniMaxBillingBreakdown: Sendable, Equatable {
+    public let name: String
+    public let tokens: Int
+    public let cash: Double?
+
+    public init(name: String, tokens: Int, cash: Double?) {
+        self.name = name
+        self.tokens = tokens
+        self.cash = cash
+    }
+}
+
+struct MiniMaxBillingHistoryPayload: Decodable {
+    let baseResp: MiniMaxBaseResponse?
+    let chargeRecords: [MiniMaxBillingRecord]
+    let totalCount: Int?
+
+    private enum CodingKeys: String, CodingKey {
+        case baseResp = "base_resp"
+        case chargeRecords = "charge_records"
+        case totalCount = "total_cnt"
+    }
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.baseResp = try container.decodeIfPresent(MiniMaxBaseResponse.self, forKey: .baseResp)
+        self.chargeRecords = try container.decodeIfPresent([MiniMaxBillingRecord].self, forKey: .chargeRecords) ?? []
+        self.totalCount = MiniMaxDecoding.decodeInt(container, forKey: .totalCount)
+    }
+}
+
+struct MiniMaxBillingRecord: Decodable {
+    let consumeToken: Int?
+    let consumeInputToken: Int?
+    let consumeOutputToken: Int?
+    let consumeCash: Double?
+    let consumeCashAfterVoucher: Double?
+    let createdAt: Int?
+    let ymd: String?
+    let consumeTime: String?
+    let method: String?
+    let model: String?
+    let result: String?
+    let status: String?
+
+    private enum CodingKeys: String, CodingKey {
+        case consumeToken = "consume_token"
+        case consumeInputToken = "consume_input_token"
+        case consumeOutputToken = "consume_output_token"
+        case consumeCash = "consume_cash"
+        case consumeCashAfterVoucher = "consume_cash_after_voucher"
+        case createdAt = "created_at"
+        case ymd
+        case consumeTime = "consume_time"
+        case method
+        case model
+        case result
+        case status
+    }
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.consumeToken = MiniMaxDecoding.decodeInt(container, forKey: .consumeToken)
+        self.consumeInputToken = MiniMaxDecoding.decodeInt(container, forKey: .consumeInputToken)
+        self.consumeOutputToken = MiniMaxDecoding.decodeInt(container, forKey: .consumeOutputToken)
+        self.consumeCash = MiniMaxDecoding.decodeDouble(container, forKey: .consumeCash)
+        self.consumeCashAfterVoucher = MiniMaxDecoding.decodeDouble(container, forKey: .consumeCashAfterVoucher)
+        self.createdAt = MiniMaxDecoding.decodeInt(container, forKey: .createdAt)
+        self.ymd = try container.decodeIfPresent(String.self, forKey: .ymd)
+        self.consumeTime = try container.decodeIfPresent(String.self, forKey: .consumeTime)
+        self.method = try container.decodeIfPresent(String.self, forKey: .method)
+        self.model = try container.decodeIfPresent(String.self, forKey: .model)
+        self.result = Self.decodeOptionalScalarString(container, forKey: .result)
+        self.status = Self.decodeOptionalScalarString(container, forKey: .status)
+    }
+
+    var recordResult: String? {
+        if let result = self.result?.trimmingCharacters(in: .whitespacesAndNewlines), !result.isEmpty {
+            return result
+        }
+        if let status = self.status?.trimmingCharacters(in: .whitespacesAndNewlines), !status.isEmpty {
+            return status
+        }
+        return nil
+    }
+
+    var tokenCount: Int {
+        if let consumeToken, consumeToken > 0 { return consumeToken }
+        return max(0, (self.consumeInputToken ?? 0) + (self.consumeOutputToken ?? 0))
+    }
+
+    var cashValue: Double? {
+        self.consumeCashAfterVoucher ?? self.consumeCash
+    }
+
+    private static func decodeOptionalScalarString<K: CodingKey>(
+        _ container: KeyedDecodingContainer<K>,
+        forKey key: K) -> String?
+    {
+        if let value = try? container.decodeIfPresent(String.self, forKey: key) {
+            return value
+        }
+        if let value = try? container.decodeIfPresent(Int.self, forKey: key) {
+            return String(value)
+        }
+        if let value = try? container.decodeIfPresent(Double.self, forKey: key) {
+            return String(value)
+        }
+        if let value = try? container.decodeIfPresent(Bool.self, forKey: key) {
+            return String(value)
+        }
+        return nil
+    }
+}
+
+enum MiniMaxBillingHistoryParser {
+    static func decodePayload(data: Data) throws -> MiniMaxBillingHistoryPayload {
+        try JSONDecoder().decode(MiniMaxBillingHistoryPayload.self, from: data)
+    }
+
+    static func parse(
+        data: Data,
+        now: Date = Date(),
+        calendar: Calendar = .current) throws -> MiniMaxBillingSummary
+    {
+        let payload = try self.decodePayload(data: data)
+        if let status = payload.baseResp?.statusCode, status != 0 {
+            let message = payload.baseResp?.statusMessage ?? "status_code \(status)"
+            throw MiniMaxUsageError.apiError(message)
+        }
+        guard !payload.chargeRecords.isEmpty || (payload.totalCount ?? 0) == 0 else {
+            throw MiniMaxUsageError.parseFailed("Missing MiniMax billing records.")
+        }
+        return self.aggregate(records: payload.chargeRecords, now: now, calendar: calendar)
+    }
+
+    static func aggregate(
+        records: [MiniMaxBillingRecord],
+        now: Date = Date(),
+        calendar inputCalendar: Calendar = .current) -> MiniMaxBillingSummary
+    {
+        var calendar = inputCalendar
+        calendar.timeZone = inputCalendar.timeZone
+
+        let startOfToday = calendar.startOfDay(for: now)
+        let startOf30Days = calendar.date(byAdding: .day, value: -29, to: startOfToday) ?? startOfToday
+        var daily: [String: (date: Date, tokens: Int, cash: Double, hasCash: Bool)] = [:]
+        var methodTotals: [String: (tokens: Int, cash: Double, hasCash: Bool)] = [:]
+        var modelTotals: [String: (tokens: Int, cash: Double, hasCash: Bool)] = [:]
+
+        for record in records {
+            if let recordResult = record.recordResult,
+               recordResult.caseInsensitiveCompare("SUCCESS") != .orderedSame
+            {
+                continue
+            }
+
+            guard let date = self.recordDate(record, calendar: calendar),
+                  date >= startOf30Days,
+                  date <= now
+            else {
+                continue
+            }
+
+            let day = self.dayString(date, calendar: calendar)
+            let tokens = record.tokenCount
+            let cash = record.cashValue
+            var bucket = daily[day] ?? (calendar.startOfDay(for: date), 0, 0, false)
+            bucket.tokens += tokens
+            if let cash {
+                bucket.cash += cash
+                bucket.hasCash = true
+            }
+            daily[day] = bucket
+
+            self.add(record, tokens: tokens, cash: cash, keyPath: \.method, totals: &methodTotals)
+            self.add(record, tokens: tokens, cash: cash, keyPath: \.model, totals: &modelTotals)
+        }
+
+        let sortedDays = daily
+            .sorted { $0.value.date < $1.value.date }
+            .map { key, value in
+                MiniMaxBillingDay(
+                    day: key,
+                    tokens: value.tokens,
+                    cash: value.hasCash ? value.cash : nil)
+            }
+        let todayKey = self.dayString(now, calendar: calendar)
+        let today = daily[todayKey]
+        let last30Tokens = sortedDays.reduce(0) { $0 + $1.tokens }
+        let last30CashValues = sortedDays.compactMap(\.cash)
+        let last30Cash = last30CashValues.isEmpty ? nil : last30CashValues.reduce(0, +)
+
+        return MiniMaxBillingSummary(
+            todayTokens: today?.tokens ?? 0,
+            last30DaysTokens: last30Tokens,
+            todayCash: (today?.hasCash == true) ? today?.cash : nil,
+            last30DaysCash: last30Cash,
+            daily: sortedDays,
+            topMethods: self.breakdowns(from: methodTotals),
+            topModels: self.breakdowns(from: modelTotals),
+            updatedAt: now)
+    }
+
+    private static func add(
+        _ record: MiniMaxBillingRecord,
+        tokens: Int,
+        cash: Double?,
+        keyPath: KeyPath<MiniMaxBillingRecord, String?>,
+        totals: inout [String: (tokens: Int, cash: Double, hasCash: Bool)])
+    {
+        let rawName = record[keyPath: keyPath]?.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard let rawName, !rawName.isEmpty else { return }
+        var total = totals[rawName] ?? (0, 0, false)
+        total.tokens += tokens
+        if let cash {
+            total.cash += cash
+            total.hasCash = true
+        }
+        totals[rawName] = total
+    }
+
+    private static func breakdowns(from totals: [String: (tokens: Int, cash: Double, hasCash: Bool)])
+        -> [MiniMaxBillingBreakdown]
+    {
+        totals
+            .map { name, value in
+                MiniMaxBillingBreakdown(
+                    name: name,
+                    tokens: value.tokens,
+                    cash: value.hasCash ? value.cash : nil)
+            }
+            .sorted {
+                if $0.tokens == $1.tokens {
+                    return $0.name.localizedCaseInsensitiveCompare($1.name) == .orderedAscending
+                }
+                return $0.tokens > $1.tokens
+            }
+            .prefix(3)
+            .map(\.self)
+    }
+
+    static func containsRecordBefore30DayWindow(
+        _ records: [MiniMaxBillingRecord],
+        now: Date = Date(),
+        calendar inputCalendar: Calendar = .current) -> Bool
+    {
+        var calendar = inputCalendar
+        calendar.timeZone = inputCalendar.timeZone
+        let startOfToday = calendar.startOfDay(for: now)
+        let startOf30Days = calendar.date(byAdding: .day, value: -29, to: startOfToday) ?? startOfToday
+        return records.contains { record in
+            guard let date = self.recordDate(record, calendar: calendar) else { return false }
+            return date < startOf30Days
+        }
+    }
+
+    private static func recordDate(_ record: MiniMaxBillingRecord, calendar: Calendar) -> Date? {
+        if let createdAt = record.createdAt {
+            let interval = createdAt > 1_000_000_000_000
+                ? TimeInterval(createdAt) / 1000
+                : TimeInterval(createdAt)
+            return Date(timeIntervalSince1970: interval)
+        }
+        if let ymd = record.ymd {
+            return self.parseDateOnly(ymd, calendar: calendar)
+        }
+        if let consumeTime = record.consumeTime {
+            return self.parseDate(consumeTime, formats: [
+                "yyyy-MM-dd HH:mm:ss",
+                "yyyy/MM/dd HH:mm:ss",
+                "yyyy-MM-dd'T'HH:mm:ssXXXXX",
+            ])
+        }
+        return nil
+    }
+
+    private static func parseDateOnly(_ text: String, calendar: Calendar) -> Date? {
+        let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else { return nil }
+        let formatter = DateFormatter()
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        formatter.calendar = calendar
+        formatter.timeZone = calendar.timeZone
+        for format in ["yyyy-MM-dd", "yyyyMMdd", "yyyy/MM/dd"] {
+            formatter.dateFormat = format
+            if let date = formatter.date(from: trimmed) {
+                return calendar.startOfDay(for: date)
+            }
+        }
+        return nil
+    }
+
+    private static func parseDate(_ text: String, formats: [String]) -> Date? {
+        let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else { return nil }
+        let formatter = DateFormatter()
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        formatter.timeZone = TimeZone(secondsFromGMT: 0)
+        for format in formats {
+            formatter.dateFormat = format
+            if let date = formatter.date(from: trimmed) { return date }
+        }
+        return nil
+    }
+
+    private static func dayString(_ date: Date, calendar: Calendar) -> String {
+        let components = calendar.dateComponents([.year, .month, .day], from: date)
+        guard let year = components.year,
+              let month = components.month,
+              let day = components.day
+        else { return "" }
+        return String(format: "%04d-%02d-%02d", year, month, day)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/MiniMax/MiniMaxCookieHeader.swift b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxCookieHeader.swift
index 3f16aef95e..ab68319a04 100644
--- a/Sources/CodexBarCore/Providers/MiniMax/MiniMaxCookieHeader.swift
+++ b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxCookieHeader.swift
@@ -24,7 +24,11 @@ public enum MiniMaxCookieHeader {
         #"(?i)(?:--cookie|-b)\s*([^\s]+)"#,
     ]
     private static let authorizationPattern = #"(?i)\bauthorization:\s*bearer\s+([A-Za-z0-9._\-+=/]+)"#
-    private static let groupIDPattern = #"(?i)\bgroup[_]?id=([0-9]{4,})"#
+    private static let groupIDPatterns = [
+        #"(?i)\bx-group-id:\s*([0-9]{4,})"#,
+        #"(?i)\bminimax_group_id_v2=([0-9]{4,})"#,
+        #"(?i)\bgroup[_]?id=([0-9]{4,})"#,
+    ]
 
     public static func override(from raw: String?) -> MiniMaxCookieOverride? {
         guard let raw = raw?.trimmingCharacters(in: .whitespacesAndNewlines),
@@ -34,7 +38,7 @@ public enum MiniMaxCookieHeader {
         }
         guard let cookie = self.normalized(from: raw) else { return nil }
         let authorizationToken = self.extractFirst(pattern: self.authorizationPattern, text: raw)
-        let groupID = self.extractFirst(pattern: self.groupIDPattern, text: raw)
+        let groupID = self.extractFirst(patterns: self.groupIDPatterns, text: raw)
         return MiniMaxCookieOverride(
             cookieHeader: cookie,
             authorizationToken: authorizationToken,
@@ -102,4 +106,13 @@ public enum MiniMaxCookieHeader {
         let value = text[captureRange].trimmingCharacters(in: .whitespacesAndNewlines)
         return value.isEmpty ? nil : String(value)
     }
+
+    private static func extractFirst(patterns: [String], text: String) -> String? {
+        for pattern in patterns {
+            if let value = self.extractFirst(pattern: pattern, text: text) {
+                return value
+            }
+        }
+        return nil
+    }
 }
diff --git a/Sources/CodexBarCore/Providers/MiniMax/MiniMaxCookieImporter.swift b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxCookieImporter.swift
index 756b350dfd..5841de1783 100644
--- a/Sources/CodexBarCore/Providers/MiniMax/MiniMaxCookieImporter.swift
+++ b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxCookieImporter.swift
@@ -64,7 +64,7 @@ public enum MiniMaxCookieImporter {
     {
         let query = BrowserCookieQuery(domains: self.cookieDomains)
         let log: (String) -> Void = { msg in self.emit(msg, logger: logger) }
-        let sources = try Self.cookieClient.records(
+        let sources = try Self.cookieClient.codexBarRecords(
             matching: query,
             in: browserSource,
             logger: log)
diff --git a/Sources/CodexBarCore/Providers/MiniMax/MiniMaxDecoding.swift b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxDecoding.swift
new file mode 100644
index 0000000000..6ad41bb9e3
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxDecoding.swift
@@ -0,0 +1,46 @@
+import Foundation
+
+enum MiniMaxDecoding {
+    static func decodeInt<K: CodingKey>(_ container: KeyedDecodingContainer<K>, forKey key: K) -> Int? {
+        if let value = try? container.decodeIfPresent(Int.self, forKey: key) {
+            return value
+        }
+        if let value = try? container.decodeIfPresent(Int64.self, forKey: key) {
+            return Int(value)
+        }
+        if let value = try? container.decodeIfPresent(Double.self, forKey: key) {
+            return Int(value)
+        }
+        if let value = try? container.decodeIfPresent(String.self, forKey: key) {
+            let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
+            return Int(trimmed)
+        }
+        return nil
+    }
+
+    static func decodeDouble<K: CodingKey>(_ container: KeyedDecodingContainer<K>, forKey key: K) -> Double? {
+        if let value = try? container.decodeIfPresent(Double.self, forKey: key) {
+            return value
+        }
+        if let value = try? container.decodeIfPresent(Int.self, forKey: key) {
+            return Double(value)
+        }
+        if let value = try? container.decodeIfPresent(Int64.self, forKey: key) {
+            return Double(value)
+        }
+        if let value = try? container.decodeIfPresent(String.self, forKey: key) {
+            let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
+            return Double(trimmed)
+        }
+        return nil
+    }
+
+    static func decodeDouble<K: CodingKey>(_ container: KeyedDecodingContainer<K>, forKeys keys: [K]) -> Double? {
+        for key in keys {
+            if let value = self.decodeDouble(container, forKey: key) {
+                return value
+            }
+        }
+        return nil
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/MiniMax/MiniMaxLocalStorageImporter.swift b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxLocalStorageImporter.swift
index fcd1ebcce6..51f92891d3 100644
--- a/Sources/CodexBarCore/Providers/MiniMax/MiniMaxLocalStorageImporter.swift
+++ b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxLocalStorageImporter.swift
@@ -5,7 +5,7 @@ import SweetCookieKit
 
 #if os(macOS)
 enum MiniMaxLocalStorageImporter {
-    struct TokenInfo: Sendable {
+    struct TokenInfo {
         let accessToken: String
         let groupID: String?
         let sourceLabel: String
@@ -106,21 +106,21 @@ enum MiniMaxLocalStorageImporter {
 
     // MARK: - Chrome local storage discovery
 
-    private enum LocalStorageSourceKind: Sendable {
+    private enum LocalStorageSourceKind {
         case chromeLevelDB(URL)
     }
 
-    private struct LocalStorageCandidate: Sendable {
+    private struct LocalStorageCandidate {
         let label: String
         let kind: LocalStorageSourceKind
     }
 
-    private struct SessionStorageCandidate: Sendable {
+    private struct SessionStorageCandidate {
         let label: String
         let url: URL
     }
 
-    private struct IndexedDBCandidate: Sendable {
+    private struct IndexedDBCandidate {
         let label: String
         let url: URL
     }
@@ -335,7 +335,7 @@ enum MiniMaxLocalStorageImporter {
 
     // MARK: - Token extraction
 
-    private struct LocalStorageSnapshot: Sendable {
+    private struct LocalStorageSnapshot {
         let tokens: [String]
         let groupID: String?
     }
diff --git a/Sources/CodexBarCore/Providers/MiniMax/MiniMaxModelRemains.swift b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxModelRemains.swift
new file mode 100644
index 0000000000..40d39b522a
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxModelRemains.swift
@@ -0,0 +1,68 @@
+struct MiniMaxModelRemains: Decodable {
+    let modelName: String?
+    let currentIntervalTotalCount: Int?
+    let currentIntervalUsageCount: Int?
+    let startTime: Int?
+    let endTime: Int?
+    let remainsTime: Int?
+    let intervalBoostPermille: Int?
+    let currentIntervalRemainingPercent: Double?
+    let currentIntervalStatus: Int?
+    let currentWeeklyTotalCount: Int?
+    let currentWeeklyUsageCount: Int?
+    let weeklyStartTime: Int?
+    let weeklyEndTime: Int?
+    let weeklyRemainsTime: Int?
+    let weeklyBoostPermille: Int?
+    let currentWeeklyRemainingPercent: Double?
+    let currentWeeklyStatus: Int?
+
+    private enum CodingKeys: String, CodingKey {
+        case modelName = "model_name"
+        case currentIntervalTotalCount = "current_interval_total_count"
+        case currentIntervalUsageCount = "current_interval_usage_count"
+        case startTime = "start_time"
+        case endTime = "end_time"
+        case remainsTime = "remains_time"
+        case intervalBoostPermille = "interval_boost_permill"
+        case intervalBoostPermilleAlt = "interval_boost_permille"
+        case currentIntervalRemainingPercent = "current_interval_remaining_percent"
+        case currentIntervalStatus = "current_interval_status"
+        case currentWeeklyTotalCount = "current_weekly_total_count"
+        case currentWeeklyUsageCount = "current_weekly_usage_count"
+        case weeklyStartTime = "weekly_start_time"
+        case weeklyEndTime = "weekly_end_time"
+        case weeklyRemainsTime = "weekly_remains_time"
+        case weeklyBoostPermille = "weekly_boost_permill"
+        case weeklyBoostPermilleAlt = "weekly_boost_permille"
+        case currentWeeklyRemainingPercent = "current_weekly_remaining_percent"
+        case currentWeeklyStatus = "current_weekly_status"
+    }
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.modelName = try container.decodeIfPresent(String.self, forKey: .modelName)
+        self.currentIntervalTotalCount = MiniMaxDecoding.decodeInt(container, forKey: .currentIntervalTotalCount)
+        self.currentIntervalUsageCount = MiniMaxDecoding.decodeInt(container, forKey: .currentIntervalUsageCount)
+        self.startTime = MiniMaxDecoding.decodeInt(container, forKey: .startTime)
+        self.endTime = MiniMaxDecoding.decodeInt(container, forKey: .endTime)
+        self.remainsTime = MiniMaxDecoding.decodeInt(container, forKey: .remainsTime)
+        self.intervalBoostPermille = MiniMaxDecoding.decodeInt(container, forKey: .intervalBoostPermille)
+            ?? MiniMaxDecoding.decodeInt(container, forKey: .intervalBoostPermilleAlt)
+        self.currentIntervalRemainingPercent = MiniMaxDecoding.decodeDouble(
+            container,
+            forKey: .currentIntervalRemainingPercent)
+        self.currentIntervalStatus = MiniMaxDecoding.decodeInt(container, forKey: .currentIntervalStatus)
+        self.currentWeeklyTotalCount = MiniMaxDecoding.decodeInt(container, forKey: .currentWeeklyTotalCount)
+        self.currentWeeklyUsageCount = MiniMaxDecoding.decodeInt(container, forKey: .currentWeeklyUsageCount)
+        self.weeklyStartTime = MiniMaxDecoding.decodeInt(container, forKey: .weeklyStartTime)
+        self.weeklyEndTime = MiniMaxDecoding.decodeInt(container, forKey: .weeklyEndTime)
+        self.weeklyRemainsTime = MiniMaxDecoding.decodeInt(container, forKey: .weeklyRemainsTime)
+        self.weeklyBoostPermille = MiniMaxDecoding.decodeInt(container, forKey: .weeklyBoostPermille)
+            ?? MiniMaxDecoding.decodeInt(container, forKey: .weeklyBoostPermilleAlt)
+        self.currentWeeklyRemainingPercent = MiniMaxDecoding.decodeDouble(
+            container,
+            forKey: .currentWeeklyRemainingPercent)
+        self.currentWeeklyStatus = MiniMaxDecoding.decodeInt(container, forKey: .currentWeeklyStatus)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/MiniMax/MiniMaxProviderDescriptor.swift b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxProviderDescriptor.swift
index 5bf0a9c525..fab28f9f9e 100644
--- a/Sources/CodexBarCore/Providers/MiniMax/MiniMaxProviderDescriptor.swift
+++ b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxProviderDescriptor.swift
@@ -1,9 +1,8 @@
-import CodexBarMacroSupport
 import Foundation
 
-@ProviderDescriptorRegistration
-@ProviderDescriptorDefinition
 public enum MiniMaxProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
     static func makeDescriptor() -> ProviderDescriptor {
         ProviderDescriptor(
             id: .minimax,
@@ -121,6 +120,9 @@ struct MiniMaxCodingPlanFetchStrategy: ProviderFetchStrategy {
         {
             return true
         }
+        guard Self.allowsBrowserCookieImport(context: context) else {
+            return false
+        }
         return MiniMaxCookieImporter.hasSession(browserDetection: context.browserDetection)
         #else
         return false
@@ -130,7 +132,8 @@ struct MiniMaxCodingPlanFetchStrategy: ProviderFetchStrategy {
     func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
         let fetchContext = FetchContext(
             region: context.settings?.minimax?.apiRegion ?? .global,
-            environment: context.env)
+            environment: context.env,
+            includeBillingHistory: context.includeOptionalUsage)
         if let override = Self.resolveCookieOverride(context: context) {
             Self.log.debug("Using MiniMax cookie header from settings/env")
             let snapshot = try await MiniMaxUsageFetcher.fetchUsage(
@@ -138,7 +141,8 @@ struct MiniMaxCodingPlanFetchStrategy: ProviderFetchStrategy {
                 authorizationToken: override.authorizationToken,
                 groupID: override.groupID,
                 region: fetchContext.region,
-                environment: fetchContext.environment)
+                environment: fetchContext.environment,
+                includeBillingHistory: context.includeOptionalUsage)
             return self.makeResult(
                 usage: snapshot.toUsageSnapshot(),
                 sourceLabel: "web")
@@ -172,6 +176,11 @@ struct MiniMaxCodingPlanFetchStrategy: ProviderFetchStrategy {
             }
         }
 
+        guard Self.allowsBrowserCookieImport(context: context) else {
+            if let lastError { throw lastError }
+            throw MiniMaxSettingsError.missingCookie
+        }
+
         let sessions = (try? MiniMaxCookieImporter.importSessions(
             browserDetection: context.browserDetection)) ?? []
         guard !sessions.isEmpty else {
@@ -217,17 +226,22 @@ struct MiniMaxCodingPlanFetchStrategy: ProviderFetchStrategy {
         false
     }
 
-    private struct TokenContext: Sendable {
+    static func allowsBrowserCookieImport(context: ProviderFetchContext) -> Bool {
+        context.runtime == .app && ProviderInteractionContext.current == .userInitiated
+    }
+
+    private struct TokenContext {
         let tokensByLabel: [String: [String]]
         let groupIDByLabel: [String: String]
     }
 
-    private struct FetchContext: Sendable {
+    private struct FetchContext {
         let region: MiniMaxAPIRegion
         let environment: [String: String]
+        let includeBillingHistory: Bool
     }
 
-    private enum FetchAttemptResult: Sendable {
+    private enum FetchAttemptResult {
         case success(MiniMaxUsageSnapshot)
         case failure(Error)
     }
@@ -314,7 +328,8 @@ struct MiniMaxCodingPlanFetchStrategy: ProviderFetchStrategy {
                     authorizationToken: token,
                     groupID: groupID,
                     region: fetchContext.region,
-                    environment: fetchContext.environment)
+                    environment: fetchContext.environment,
+                    includeBillingHistory: fetchContext.includeBillingHistory)
                 Self.log.debug("MiniMax \(prefix)cookies valid from \(sourceLabel)")
                 return .success(snapshot)
             } catch {
diff --git a/Sources/CodexBarCore/Providers/MiniMax/MiniMaxServiceUsage.swift b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxServiceUsage.swift
new file mode 100644
index 0000000000..71101e8ca3
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxServiceUsage.swift
@@ -0,0 +1,225 @@
+//
+//  MiniMaxServiceUsage.swift
+//  CodexBarCore
+//
+//  Created by Sisyphus on 2026-03-25.
+//
+
+import Foundation
+
+/// Represents the usage information for a specific MiniMax service.
+///
+/// This struct encapsulates all the relevant details about how much of a particular
+/// MiniMax service has been used within its quota window, including reset timing
+/// and localized display strings.
+public struct MiniMaxServiceUsage: Sendable {
+    /// The service identifier (e.g., "text-generation", "text-to-speech", "image")
+    public let serviceType: String
+
+    /// The type of time window for the quota (e.g., "5 hours" or "Today")
+    /// This should be a localized string.
+    public let windowType: String
+
+    /// The specific time range for the current quota window.
+    /// For hourly quotas: "10:00-15:00(UTC+8)"
+    /// For daily quotas: full date range string
+    public let timeRange: String
+
+    /// The amount of quota that has been used.
+    public let usage: Int
+
+    /// The total quota limit for this service in the current window
+    public let limit: Int
+
+    /// The percentage of quota used (0-100)
+    public let percent: Double
+
+    /// Whether this quota window is explicitly unlimited.
+    public let isUnlimited: Bool
+
+    /// The timestamp when the quota will reset, if available
+    public let resetsAt: Date?
+
+    /// A localized description of when the quota resets (e.g., "Resets in 2 hours 30 minutes")
+    public let resetDescription: String
+
+    /// The remaining quota available (limit - usage)
+    public var remaining: Int {
+        max(0, self.limit - self.usage)
+    }
+
+    /// The display name for this service
+    public var displayName: String {
+        let normalized = self.serviceType.lowercased()
+        return switch normalized {
+        case "general":
+            "General"
+        case "video":
+            "Video"
+        case "text-generation":
+            "Text Generation"
+        case "text-to-speech":
+            "Text to Speech"
+        case "image":
+            "Image"
+        case "text generation":
+            "Text Generation"
+        case "text to speech":
+            "Text to Speech"
+        case "image generation":
+            "Image Generation"
+        case "text to video":
+            "Text to Video"
+        case "image to video":
+            "Image to Video"
+        case "music generation":
+            "Music Generation"
+        case "music generation · v2.6":
+            "Music Generation · v2.6"
+        case "music cover":
+            "Music Cover"
+        case "lyrics generation":
+            "Lyrics Generation"
+        case "image understanding":
+            "Image Understanding"
+        default:
+            self.serviceType
+        }
+    }
+
+    public var isPrimaryTextQuotaLane: Bool {
+        let normalized = self.serviceType.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+        return normalized == "general" || self.displayName == "Text Generation"
+    }
+
+    /// Creates a new MiniMaxServiceUsage instance.
+    ///
+    /// - Parameters:
+    ///   - serviceType: The service identifier
+    ///   - windowType: The type of time window (localized)
+    ///   - timeRange: The specific time range string
+    ///   - usage: The amount of quota used
+    ///   - limit: The total quota limit
+    ///   - percent: The percentage used (0-100)
+    ///   - resetsAt: Optional reset timestamp
+    ///   - resetDescription: Localized reset description
+    public init(
+        serviceType: String,
+        windowType: String,
+        timeRange: String,
+        usage: Int,
+        limit: Int,
+        percent: Double,
+        isUnlimited: Bool = false,
+        resetsAt: Date?,
+        resetDescription: String)
+    {
+        self.serviceType = serviceType
+        self.windowType = windowType
+        self.timeRange = timeRange
+        self.usage = usage
+        self.limit = limit
+        self.percent = percent
+        self.isUnlimited = isUnlimited
+        self.resetsAt = resetsAt
+        self.resetDescription = resetDescription
+    }
+}
+
+extension MiniMaxServiceUsage {
+    public static func parseWindowType(_ windowType: String) -> (windowType: String, windowMinutes: Int?) {
+        switch windowType.lowercased() {
+        case "5 hours", "5 小时":
+            return ("5 hours", 300)
+        case "today", "今日":
+            return ("Today", 1440)
+        default:
+            // Try to extract hours from string like "X hours"
+            if let hours = Int(windowType.components(separatedBy: .whitespaces).first ?? "") {
+                return (windowType, hours * 60)
+            }
+            return (windowType, nil)
+        }
+    }
+
+    public static func parseTimeRange(_ timeRange: String, now: Date) -> Date? {
+        let calendar = Calendar.current
+
+        // Handle "10:00-15:00(UTC+8)" format
+        if timeRange.contains("-"), timeRange.contains("("), timeRange.contains(")") {
+            // Extract the time part before the timezone
+            let components = timeRange.split(separator: "(")
+            guard components.count >= 1 else { return nil }
+            let timePart = String(components[0]).trimmingCharacters(in: .whitespaces)
+
+            // Split by "-" to get start and end times
+            let timeComponents = timePart.split(separator: "-")
+            guard timeComponents.count == 2 else { return nil }
+
+            let endTimeStr = String(timeComponents[1]).trimmingCharacters(in: .whitespaces)
+
+            // Parse end time (HH:mm format)
+            let timeFormatter = DateFormatter()
+            timeFormatter.dateFormat = "HH:mm"
+            timeFormatter.timeZone = TimeZone.current
+
+            guard let endTime = timeFormatter.date(from: endTimeStr) else { return nil }
+
+            // Get today's date components
+            let nowComponents = calendar.dateComponents([.year, .month, .day], from: now)
+            let endTimeComponents = calendar.dateComponents([.hour, .minute], from: endTime)
+
+            // Combine today's date with end time
+            var combinedComponents = DateComponents()
+            combinedComponents.year = nowComponents.year
+            combinedComponents.month = nowComponents.month
+            combinedComponents.day = nowComponents.day
+            combinedComponents.hour = endTimeComponents.hour
+            combinedComponents.minute = endTimeComponents.minute
+
+            guard let resultDate = calendar.date(from: combinedComponents) else { return nil }
+
+            // If the result date is in the past (before now), add one day
+            if resultDate < now {
+                return calendar.date(byAdding: .day, value: 1, to: resultDate)
+            }
+
+            return resultDate
+        }
+
+        // Handle "2026/03/25 00:00 - 2026/03/26 00:00" format
+        if timeRange.contains(" - ") {
+            let dateComponents = timeRange.split(separator: " - ")
+            guard dateComponents.count == 2 else { return nil }
+
+            let endDateStr = String(dateComponents[1]).trimmingCharacters(in: .whitespaces)
+
+            let dateFormatter = DateFormatter()
+            dateFormatter.dateFormat = "yyyy/MM/dd HH:mm"
+            dateFormatter.timeZone = TimeZone.current
+
+            return dateFormatter.date(from: endDateStr)
+        }
+
+        return nil
+    }
+
+    public static func generateResetDescription(resetsAt: Date, now: Date = Date()) -> String {
+        let calendar = Calendar.current
+        let components = calendar.dateComponents([.hour, .minute], from: now, to: resetsAt)
+
+        guard let hours = components.hour, let minutes = components.minute else {
+            return "Resets soon"
+        }
+
+        if hours > 0, minutes > 0 {
+            return "Resets in \(hours) hours \(minutes) minutes"
+        } else if hours > 0 {
+            return "Resets in \(hours) hour\(hours > 1 ? "s" : "")"
+        } else if minutes > 0 {
+            return "Resets in \(minutes) minute\(minutes > 1 ? "s" : "")"
+        } else {
+            return "Resets now"
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/MiniMax/MiniMaxSettingsReader.swift b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxSettingsReader.swift
index 57dfbd3bdd..fe0e864f64 100644
--- a/Sources/CodexBarCore/Providers/MiniMax/MiniMaxSettingsReader.swift
+++ b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxSettingsReader.swift
@@ -1,6 +1,9 @@
 import Foundation
 
 public struct MiniMaxSettingsReader: Sendable {
+    private static let endpointValidator = ProviderEndpointOverrideValidator(
+        allowedDomainSuffixes: ["minimax.io", "minimaxi.com"])
+
     public static let cookieHeaderKeys = [
         "MINIMAX_COOKIE",
         "MINIMAX_COOKIE_HEADER",
@@ -8,6 +11,14 @@ public struct MiniMaxSettingsReader: Sendable {
     public static let hostKey = "MINIMAX_HOST"
     public static let codingPlanURLKey = "MINIMAX_CODING_PLAN_URL"
     public static let remainsURLKey = "MINIMAX_REMAINS_URL"
+    public static let billingHistoryURLKey = "MINIMAX_BILLING_HISTORY_URL"
+    public static let requireProviderEndpointOverridesKey = "MINIMAX_REQUIRE_PROVIDER_ENDPOINT_OVERRIDES"
+    private static let endpointOverrideKeys = [
+        Self.hostKey,
+        Self.codingPlanURLKey,
+        Self.remainsURLKey,
+        Self.billingHistoryURLKey,
+    ]
 
     public static func cookieHeader(
         environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
@@ -26,19 +37,54 @@ public struct MiniMaxSettingsReader: Sendable {
     }
 
     public static func hostOverride(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
-        self.cleaned(environment[self.hostKey])
+        self.endpointValidator.validatedHost(
+            self.cleaned(environment[self.hostKey]),
+            policy: self.endpointOverrideHostPolicy(environment: environment))
+    }
+
+    public static func rejectedEndpointOverrideKey(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        let policy = self.endpointOverrideHostPolicy(environment: environment)
+        return self.endpointOverrideKeys.first { key in
+            guard let value = self.cleaned(environment[key]) else { return false }
+            if key == Self.hostKey {
+                return self.endpointValidator.validatedHost(value, policy: policy) == nil
+            }
+            return self.endpointValidator.validatedURL(value, policy: policy) == nil
+        }
     }
 
     public static func codingPlanURL(
         environment: [String: String] = ProcessInfo.processInfo.environment) -> URL?
     {
-        self.url(from: environment[self.codingPlanURLKey])
+        self.endpointValidator.validatedURL(
+            self.cleaned(environment[self.codingPlanURLKey]),
+            policy: self.endpointOverrideHostPolicy(environment: environment))
     }
 
     public static func remainsURL(
         environment: [String: String] = ProcessInfo.processInfo.environment) -> URL?
     {
-        self.url(from: environment[self.remainsURLKey])
+        self.endpointValidator.validatedURL(
+            self.cleaned(environment[self.remainsURLKey]),
+            policy: self.endpointOverrideHostPolicy(environment: environment))
+    }
+
+    public static func billingHistoryURL(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> URL?
+    {
+        self.endpointValidator.validatedURL(
+            self.cleaned(environment[self.billingHistoryURLKey]),
+            policy: self.endpointOverrideHostPolicy(environment: environment))
+    }
+
+    static func endpointOverrideHostPolicy(environment: [String: String]) -> ProviderEndpointOverrideValidator
+    .HostPolicy {
+        guard let value = self.cleaned(environment[self.requireProviderEndpointOverridesKey])?.lowercased(),
+              ["1", "true", "yes", "on"].contains(value)
+        else { return .allowAnyHTTPSHost }
+        return .providerOwnedOnly
     }
 
     static func cleaned(_ raw: String?) -> String? {
@@ -49,21 +95,12 @@ public struct MiniMaxSettingsReader: Sendable {
         if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
             (value.hasPrefix("'") && value.hasSuffix("'"))
         {
-            value.removeFirst()
-            value.removeLast()
+            value = String(value.dropFirst().dropLast())
         }
 
         value = value.trimmingCharacters(in: .whitespacesAndNewlines)
         return value.isEmpty ? nil : value
     }
-
-    private static func url(from raw: String?) -> URL? {
-        guard let cleaned = self.cleaned(raw) else { return nil }
-        if let url = URL(string: cleaned), url.scheme != nil {
-            return url
-        }
-        return URL(string: "https://\(cleaned)")
-    }
 }
 
 public enum MiniMaxSettingsError: LocalizedError, Sendable {
@@ -72,7 +109,8 @@ public enum MiniMaxSettingsError: LocalizedError, Sendable {
     public var errorDescription: String? {
         switch self {
         case .missingCookie:
-            "MiniMax session not found. Sign in to platform.minimax.io or platform.minimaxi.com in your browser and try again."
+            "MiniMax session not found. Sign in to platform.minimax.io or platform.minimaxi.com " +
+                "in your browser and try again."
         }
     }
 }
diff --git a/Sources/CodexBarCore/Providers/MiniMax/MiniMaxSubscriptionMetadata.swift b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxSubscriptionMetadata.swift
new file mode 100644
index 0000000000..de2b787979
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxSubscriptionMetadata.swift
@@ -0,0 +1,274 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+struct MiniMaxSubscriptionMetadata: Equatable {
+    let planName: String?
+    let subscriptionExpiresAt: Date?
+    let subscriptionRenewsAt: Date?
+}
+
+enum MiniMaxSubscriptionMetadataFetcher {
+    private static let comboPath = "v1/api/openplatform/charge/combo/cycle_audio_resource_package"
+
+    static func fetch(
+        cookieHeader: String,
+        groupID: String?,
+        region: MiniMaxAPIRegion,
+        environment: [String: String],
+        transport: any ProviderHTTPTransport) async throws -> MiniMaxSubscriptionMetadata
+    {
+        let url = try self.resolveComboURL(region: region, environment: environment)
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.setValue(cookieHeader, forHTTPHeaderField: "Cookie")
+        if let groupID = groupID?.trimmingCharacters(in: .whitespacesAndNewlines), !groupID.isEmpty {
+            request.setValue(groupID, forHTTPHeaderField: "x-group-id")
+        }
+        request.setValue("application/json, text/plain, */*", forHTTPHeaderField: "accept")
+        request.setValue("zh-CN,zh;q=0.9", forHTTPHeaderField: "accept-language")
+        request.setValue(self.platformOrigin(region: region).absoluteString, forHTTPHeaderField: "origin")
+        request.setValue(self.platformOrigin(region: region).absoluteString + "/", forHTTPHeaderField: "referer")
+
+        let response = try await transport.response(for: request)
+        guard response.statusCode == 200 else {
+            if response.statusCode == 401 || response.statusCode == 403 { throw MiniMaxUsageError.invalidCredentials }
+            throw MiniMaxUsageError.apiError("HTTP \(response.statusCode)")
+        }
+        return try self.parse(data: response.data)
+    }
+
+    static func parse(data: Data) throws -> MiniMaxSubscriptionMetadata {
+        let object = try JSONSerialization.jsonObject(with: data, options: [])
+        try self.validateBaseResponse(in: object)
+        let planName = self.findPlanName(in: object)
+        let subscriptionExpiresAt = self.findDate(
+            in: object,
+            keys: ["current_subscribe_end_time_ts", "current_subscribe_end_time"])
+        let subscriptionRenewsAt = self.findDate(
+            in: object,
+            keys: ["renewal_trigger_time_ts", "renewal_date"])
+        guard planName != nil || subscriptionExpiresAt != nil || subscriptionRenewsAt != nil else {
+            throw MiniMaxUsageError.parseFailed("MiniMax combo metadata did not include subscription metadata.")
+        }
+        return MiniMaxSubscriptionMetadata(
+            planName: planName,
+            subscriptionExpiresAt: subscriptionExpiresAt,
+            subscriptionRenewsAt: subscriptionRenewsAt)
+    }
+
+    static func resolveComboURL(region: MiniMaxAPIRegion, environment: [String: String]) throws -> URL {
+        if let rejectedKey = MiniMaxSettingsReader.rejectedEndpointOverrideKey(environment: environment) {
+            throw ProviderEndpointOverrideError.minimax(rejectedKey)
+        }
+        let baseURL = MiniMaxSettingsReader.hostOverride(environment: environment)
+            .map { "https://\($0)" } ?? self.defaultWebHost(region: region)
+        guard var components = URLComponents(string: baseURL),
+              components.host?.isEmpty == false
+        else {
+            throw MiniMaxUsageError.apiError("MiniMax combo metadata host is invalid.")
+        }
+        guard components.scheme?.lowercased() == "https" else {
+            throw MiniMaxUsageError.apiError("MiniMax combo metadata host must use HTTPS.")
+        }
+        components.path = "/" + Self.comboPath
+        components.queryItems = [
+            URLQueryItem(name: "biz_line", value: "2"),
+            URLQueryItem(name: "cycle_type", value: "3"),
+            URLQueryItem(name: "resource_package_type", value: "7"),
+        ]
+        guard let url = components.url else {
+            throw MiniMaxUsageError.apiError("MiniMax combo metadata host is invalid.")
+        }
+        return url
+    }
+
+    private static func validateBaseResponse(in object: Any) throws {
+        guard let root = object as? [String: Any],
+              let baseResp = root["base_resp"] as? [String: Any]
+        else { return }
+        let status = self.intValue(baseResp["status_code"]) ?? 0
+        guard status != 0 else { return }
+        let message = (baseResp["status_msg"] as? String) ?? "MiniMax combo metadata error \(status)"
+        if status == 1004 || message.lowercased().contains("cookie") {
+            throw MiniMaxUsageError.invalidCredentials
+        }
+        throw MiniMaxUsageError.apiError(message)
+    }
+
+    private static func findPlanName(in object: Any) -> String? {
+        let currentSubscriptionStrings = self.collectCurrentSubscriptionStrings(in: object)
+        if let tokenPlan = self.bestPlanName(in: currentSubscriptionStrings) {
+            return tokenPlan
+        }
+
+        let strings = self.collectStrings(in: object)
+        if let tokenPlan = self.bestPlanName(in: strings) {
+            return tokenPlan
+        }
+
+        return nil
+    }
+
+    private static func bestPlanName(in strings: [String]) -> String? {
+        let tokenPlans = strings.compactMap { value -> (rank: Int, value: String)? in
+            guard let rank = self.tokenPlanRank(value) else { return nil }
+            return (rank, value.trimmingCharacters(in: .whitespacesAndNewlines))
+        }
+        if let tokenPlan = tokenPlans.min(by: { lhs, rhs in
+            lhs.rank == rhs.rank ? lhs.value.count < rhs.value.count : lhs.rank < rhs.rank
+        }) {
+            return tokenPlan.value
+        }
+        return strings.first { value in
+            let cleaned = value.trimmingCharacters(in: .whitespacesAndNewlines)
+            return ["plus", "max", "ultra"].contains(cleaned.lowercased())
+        }
+    }
+
+    private static func collectCurrentSubscriptionStrings(in object: Any) -> [String] {
+        guard let dictionary = object as? [String: Any] else {
+            if let array = object as? [Any] {
+                return array.flatMap(self.collectCurrentSubscriptionStrings(in:))
+            }
+            return []
+        }
+
+        return dictionary.flatMap { key, value in
+            let lowercasedKey = key.lowercased()
+            let stringsForCurrentField: [String] = if lowercasedKey == "current_subscribe" ||
+                lowercasedKey == "current_subscription" ||
+                lowercasedKey.contains("current_subscribe") ||
+                lowercasedKey.contains("current_subscription") ||
+                lowercasedKey.contains("current_plan")
+            {
+                self.collectStrings(in: value)
+            } else {
+                []
+            }
+            return stringsForCurrentField + self.collectCurrentSubscriptionStrings(in: value)
+        }
+    }
+
+    private static func tokenPlanRank(_ value: String) -> Int? {
+        let lower = value.lowercased()
+        if lower.contains("tokenplanplus") { return 0 }
+        if lower.contains("tokenplanmax") { return 1 }
+        if lower.contains("tokenplanultra") { return 2 }
+        if lower.contains("token plan"), lower.contains("plus") || lower.contains("max") || lower.contains("ultra") {
+            return 3
+        }
+        return nil
+    }
+
+    private static func collectStrings(in object: Any) -> [String] {
+        if let string = object as? String { return [string] }
+        if let array = object as? [Any] { return array.flatMap(self.collectStrings(in:)) }
+        if let dictionary = object as? [String: Any] {
+            return dictionary.sorted { $0.key < $1.key }.flatMap { self.collectStrings(in: $0.value) }
+        }
+        return []
+    }
+
+    private static func intValue(_ value: Any?) -> Int? {
+        if let int = value as? Int { return int }
+        if let string = value as? String { return Int(string) }
+        return nil
+    }
+
+    private static func findDate(in object: Any, keys: [String]) -> Date? {
+        keys.lazy.compactMap { key in
+            self.findValue(forKey: key, in: object).flatMap(self.dateValue(from:))
+        }.first
+    }
+
+    private static func findValue(forKey key: String, in object: Any) -> Any? {
+        if let dictionary = object as? [String: Any] {
+            if let value = dictionary[key] { return value }
+            for nested in dictionary.values {
+                if let value = self.findValue(forKey: key, in: nested) {
+                    return value
+                }
+            }
+        }
+        if let array = object as? [Any] {
+            for nested in array {
+                if let value = self.findValue(forKey: key, in: nested) {
+                    return value
+                }
+            }
+        }
+        return nil
+    }
+
+    private static func dateValue(from value: Any) -> Date? {
+        if let int = value as? Int {
+            return self.dateValue(fromNumber: Double(int))
+        }
+        if let double = value as? Double {
+            return self.dateValue(fromNumber: double)
+        }
+        guard let string = value as? String else { return nil }
+        let trimmed = string.trimmingCharacters(in: .whitespacesAndNewlines)
+        if let numeric = Double(trimmed) {
+            return self.dateValue(fromNumber: numeric)
+        }
+        return self.dateFromMonthDayYear(trimmed)
+    }
+
+    private static func dateValue(fromNumber value: Double) -> Date? {
+        guard value.isFinite, value > 0 else { return nil }
+        let seconds = value > 10_000_000_000 ? value / 1000 : value
+        return Date(timeIntervalSince1970: seconds)
+    }
+
+    private static func dateFromMonthDayYear(_ value: String) -> Date? {
+        let formatter = DateFormatter()
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        formatter.timeZone = TimeZone(identifier: "Asia/Shanghai")
+        formatter.dateFormat = "MM/dd/yyyy"
+        return formatter.date(from: value)
+    }
+
+    private static func defaultWebHost(region: MiniMaxAPIRegion) -> String {
+        switch region {
+        case .global: "https://www.minimax.io"
+        case .chinaMainland: "https://www.minimaxi.com"
+        }
+    }
+
+    private static func platformOrigin(region: MiniMaxAPIRegion) -> URL {
+        switch region {
+        case .global: URL(string: "https://platform.minimax.io")!
+        case .chinaMainland: URL(string: "https://platform.minimaxi.com")!
+        }
+    }
+}
+
+extension MiniMaxUsageFetcher {
+    static func attachingSubscriptionMetadataIfAvailable(
+        to snapshot: MiniMaxUsageSnapshot,
+        context: WebFetchContext,
+        groupID: String?) async throws -> MiniMaxUsageSnapshot
+    {
+        let resolvedGroupID = groupID ?? MiniMaxCookieHeader.override(from: context.cookie)?.groupID
+        guard resolvedGroupID?.isEmpty == false else { return snapshot }
+        do {
+            let metadata = try await MiniMaxSubscriptionMetadataFetcher.fetch(
+                cookieHeader: context.cookie,
+                groupID: resolvedGroupID,
+                region: context.region,
+                environment: context.environment,
+                transport: context.transport)
+            return snapshot.withSubscriptionMetadata(metadata)
+        } catch is CancellationError {
+            throw CancellationError()
+        } catch let error as URLError where error.code == .cancelled {
+            throw CancellationError()
+        } catch {
+            Self.log.debug("MiniMax subscription metadata unavailable: \(error.localizedDescription)")
+            return snapshot
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/MiniMax/MiniMaxUsageError.swift b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxUsageError.swift
new file mode 100644
index 0000000000..4cd856816e
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxUsageError.swift
@@ -0,0 +1,21 @@
+import Foundation
+
+public enum MiniMaxUsageError: LocalizedError, Sendable, Equatable {
+    case invalidCredentials
+    case networkError(String)
+    case apiError(String)
+    case parseFailed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .invalidCredentials:
+            "MiniMax credentials are invalid or expired."
+        case let .networkError(message):
+            "MiniMax network error: \(message)"
+        case let .apiError(message):
+            "MiniMax API error: \(message)"
+        case let .parseFailed(message):
+            "Failed to parse MiniMax coding plan: \(message)"
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/MiniMax/MiniMaxUsageFetcher+ModelMapping.swift b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxUsageFetcher+ModelMapping.swift
new file mode 100644
index 0000000000..cfca8fcfcf
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxUsageFetcher+ModelMapping.swift
@@ -0,0 +1,62 @@
+import Foundation
+
+extension MiniMaxUsageParser {
+    static func mapModelNameToServiceType(modelName: String) -> String {
+        let lower = modelName.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+        if lower == "general" || lower == "video" {
+            return lower
+        }
+
+        // Legacy text model names are separate from Token Plan's `general` bucket.
+        if self.isTextGenerationModelName(modelName) {
+            return "Text Generation"
+        }
+
+        // Text to Speech (语音合成): speech-hd, Speech 2.8, etc.
+        if lower.contains("speech") {
+            return "Text to Speech"
+        }
+
+        // Image to Video Fast (图生视频 Fast): Hailuo-2.3-Fast
+        if lower.contains("hailuo"), lower.contains("fast") {
+            return "Image to Video"
+        }
+
+        // Text to Video (文生视频): Hailuo-2.3 (non-Fast)
+        if lower.contains("hailuo") {
+            return "Text to Video"
+        }
+
+        // Image Generation (图像生成): image-01, image-02, etc.
+        if lower.hasPrefix("image-") {
+            return "Image Generation"
+        }
+
+        // Music Generation (音乐生成): music-2.5, etc.
+        if lower.contains("music") {
+            return "Music Generation"
+        }
+
+        return modelName
+    }
+
+    static func isTextGenerationModelName(_ modelName: String) -> Bool {
+        let lower = modelName.lowercased()
+        return lower == "general" || lower.contains("minimax-m") || lower.hasPrefix("m2.")
+    }
+
+    static func shouldRenderWeeklyWindow(for modelName: String) -> Bool {
+        self.isTextGenerationModelName(modelName)
+    }
+
+    static func formatMiniMaxDateTimeRange(startTime: Date?, endTime: Date?) -> String? {
+        guard let startTime, let endTime else { return nil }
+        let formatter = DateFormatter()
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        formatter.timeZone = TimeZone(identifier: "Asia/Shanghai")
+        formatter.dateFormat = "MM/dd HH:mm"
+        let start = formatter.string(from: startTime)
+        let end = formatter.string(from: endTime)
+        return "\(start) - \(end)(UTC+8)"
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/MiniMax/MiniMaxUsageFetcher.swift b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxUsageFetcher.swift
index debe082886..49d208ede8 100644
--- a/Sources/CodexBarCore/Providers/MiniMax/MiniMaxUsageFetcher.swift
+++ b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxUsageFetcher.swift
@@ -4,44 +4,103 @@ import FoundationNetworking
 #endif
 
 public struct MiniMaxUsageFetcher: Sendable {
-    private static let log = CodexBarLog.logger(LogCategories.minimaxUsage)
+    static let log = CodexBarLog.logger(LogCategories.minimaxUsage)
     private static let codingPlanPath = "user-center/payment/coding-plan"
     private static let codingPlanQuery = "cycle_type=3"
     private static let codingPlanRemainsPath = "v1/api/openplatform/coding_plan/remains"
-    private struct RemainsContext: Sendable {
+    private static let tokenPlanRemainsPath = "v1/token_plan/remains"
+    private static let billingHistoryPath = "account/amount"
+    private static let billingHistoryLimit = 100
+    private struct RemainsContext {
         let authorizationToken: String?
         let groupID: String?
     }
 
+    struct WebFetchContext {
+        let cookie: String
+        let authorizationToken: String?
+        let region: MiniMaxAPIRegion
+        let environment: [String: String]
+        let transport: any ProviderHTTPTransport
+    }
+
     public static func fetchUsage(
         cookieHeader: String,
         authorizationToken: String? = nil,
         groupID: String? = nil,
         region: MiniMaxAPIRegion = .global,
         environment: [String: String] = ProcessInfo.processInfo.environment,
+        includeBillingHistory: Bool = true,
+        session transport: any ProviderHTTPTransport = ProviderHTTPClient.shared,
         now: Date = Date()) async throws -> MiniMaxUsageSnapshot
     {
         guard let cookie = MiniMaxCookieHeader.normalized(from: cookieHeader) else {
             throw MiniMaxUsageError.invalidCredentials
         }
+        if let rejectedKey = MiniMaxSettingsReader.rejectedEndpointOverrideKey(environment: environment) {
+            throw ProviderEndpointOverrideError.minimax(rejectedKey)
+        }
 
+        let context = WebFetchContext(
+            cookie: cookie,
+            authorizationToken: authorizationToken,
+            region: region,
+            environment: environment,
+            transport: transport)
         do {
-            return try await self.fetchCodingPlanHTML(
-                cookie: cookie,
-                authorizationToken: authorizationToken,
-                region: region,
-                environment: environment,
+            let htmlSnapshot = try await self.fetchCodingPlanHTML(context: context, now: now)
+            if htmlSnapshot.services?.isEmpty != false {
+                do {
+                    Self.log.debug("MiniMax coding plan HTML lacks service quota data, trying remains API")
+                    let remainsSnapshot = try await self.fetchCodingPlanRemains(
+                        context: context,
+                        remainsContext: RemainsContext(
+                            authorizationToken: authorizationToken,
+                            groupID: groupID),
+                        now: now)
+                        .withPlanNameIfMissing(htmlSnapshot.planName)
+                    let snapshot = try await self.attachingSubscriptionMetadataIfAvailable(
+                        to: remainsSnapshot,
+                        context: context,
+                        groupID: groupID)
+                    return try await self.attachingBillingIfAvailable(
+                        to: snapshot,
+                        context: context,
+                        includeBillingHistory: includeBillingHistory,
+                        now: now)
+                } catch {
+                    if self.shouldRethrowAfterHTMLFallback(error) {
+                        throw error
+                    }
+                    Self.log.debug(
+                        "MiniMax remains API enrichment failed after HTML fallback: \(error.localizedDescription)")
+                }
+            }
+            let snapshot = try await self.attachingSubscriptionMetadataIfAvailable(
+                to: htmlSnapshot,
+                context: context,
+                groupID: groupID)
+            return try await self.attachingBillingIfAvailable(
+                to: snapshot,
+                context: context,
+                includeBillingHistory: includeBillingHistory,
                 now: now)
         } catch let error as MiniMaxUsageError {
             if case .parseFailed = error {
                 Self.log.debug("MiniMax coding plan HTML parse failed, trying remains API")
-                return try await self.fetchCodingPlanRemains(
-                    cookie: cookie,
-                    remainsContext: RemainsContext(
-                        authorizationToken: authorizationToken,
-                        groupID: groupID),
-                    region: region,
-                    environment: environment,
+                let snapshot = try await self.attachingSubscriptionMetadataIfAvailable(
+                    to: self.fetchCodingPlanRemains(
+                        context: context,
+                        remainsContext: RemainsContext(
+                            authorizationToken: authorizationToken,
+                            groupID: groupID),
+                        now: now),
+                    context: context,
+                    groupID: groupID)
+                return try await self.attachingBillingIfAvailable(
+                    to: snapshot,
+                    context: context,
+                    includeBillingHistory: includeBillingHistory,
                     now: now)
             }
             throw error
@@ -51,7 +110,8 @@ public struct MiniMaxUsageFetcher: Sendable {
     public static func fetchUsage(
         apiToken: String,
         region: MiniMaxAPIRegion = .global,
-        now: Date = Date()) async throws -> MiniMaxUsageSnapshot
+        now: Date = Date(),
+        session transport: any ProviderHTTPTransport = ProviderHTTPClient.shared) async throws -> MiniMaxUsageSnapshot
     {
         let cleaned = apiToken.trimmingCharacters(in: .whitespacesAndNewlines)
         guard !cleaned.isEmpty else {
@@ -62,16 +122,24 @@ public struct MiniMaxUsageFetcher: Sendable {
         // user has no persisted region and we default to `.global`, retry the China endpoint when the global host
         // rejects the token so upgrades don't regress existing setups.
         if region != .global {
-            return try await self.fetchUsageOnce(apiToken: cleaned, region: region, now: now)
+            return try await self.fetchUsageOnce(apiToken: cleaned, region: region, now: now, transport: transport)
         }
 
         do {
-            return try await self.fetchUsageOnce(apiToken: cleaned, region: .global, now: now)
+            return try await self.fetchUsageOnce(
+                apiToken: cleaned,
+                region: .global,
+                now: now,
+                transport: transport)
         } catch let error as MiniMaxUsageError {
             guard case .invalidCredentials = error else { throw error }
             Self.log.debug("MiniMax API token rejected for global host, retrying China mainland host")
             do {
-                return try await self.fetchUsageOnce(apiToken: cleaned, region: .chinaMainland, now: now)
+                return try await self.fetchUsageOnce(
+                    apiToken: cleaned,
+                    region: .chinaMainland,
+                    now: now,
+                    transport: transport)
             } catch {
                 // Preserve the original invalid-credentials error so the fetch pipeline can fall back to web.
                 Self.log.debug("MiniMax China mainland retry failed, preserving global invalidCredentials")
@@ -83,44 +151,107 @@ public struct MiniMaxUsageFetcher: Sendable {
     private static func fetchUsageOnce(
         apiToken: String,
         region: MiniMaxAPIRegion,
-        now: Date) async throws -> MiniMaxUsageSnapshot
+        now: Date,
+        transport: any ProviderHTTPTransport) async throws -> MiniMaxUsageSnapshot
+    {
+        var lastError: Error?
+        var tokenPlanCredentialFailure = false
+        for remainsURL in [region.tokenPlanRemainsURL, region.apiRemainsURL] {
+            do {
+                return try await self.fetchAPIUsageOnce(
+                    apiToken: apiToken,
+                    remainsURL: remainsURL,
+                    now: now,
+                    transport: transport)
+            } catch let error as MiniMaxUsageError {
+                lastError = error
+                guard remainsURL == region.tokenPlanRemainsURL,
+                      self.shouldTryLegacyAPIEndpoint(after: error)
+                else {
+                    if tokenPlanCredentialFailure {
+                        throw MiniMaxUsageError.invalidCredentials
+                    }
+                    throw error
+                }
+                if case .invalidCredentials = error {
+                    tokenPlanCredentialFailure = true
+                }
+                Self.log.debug("MiniMax token-plan API failed, trying legacy coding-plan endpoint")
+            }
+        }
+        if let lastError { throw lastError }
+        throw MiniMaxUsageError.parseFailed("Missing MiniMax API remains URL.")
+    }
+
+    private static func fetchAPIUsageOnce(
+        apiToken: String,
+        remainsURL: URL,
+        now: Date,
+        transport: any ProviderHTTPTransport) async throws -> MiniMaxUsageSnapshot
     {
-        var request = URLRequest(url: region.apiRemainsURL)
+        var request = URLRequest(url: remainsURL)
         request.httpMethod = "GET"
         request.setValue("Bearer \(apiToken)", forHTTPHeaderField: "Authorization")
         request.setValue("application/json", forHTTPHeaderField: "accept")
         request.setValue("application/json", forHTTPHeaderField: "Content-Type")
         request.setValue("CodexBar", forHTTPHeaderField: "MM-API-Source")
 
-        let (data, response) = try await URLSession.shared.data(for: request)
-        guard let httpResponse = response as? HTTPURLResponse else {
-            throw MiniMaxUsageError.networkError("Invalid response")
+        let response: ProviderHTTPResponse
+        do {
+            response = try await transport.response(for: request)
+        } catch {
+            throw self.normalizedTransportError(error)
         }
 
-        guard httpResponse.statusCode == 200 else {
-            let body = String(data: data, encoding: .utf8) ?? ""
-            Self.log.error("MiniMax returned \(httpResponse.statusCode): \(body)")
-            if httpResponse.statusCode == 401 || httpResponse.statusCode == 403 {
+        guard response.statusCode == 200 else {
+            let body = String(data: response.data, encoding: .utf8) ?? ""
+            Self.log.error("MiniMax returned \(response.statusCode): \(body)")
+            if response.statusCode == 401 || response.statusCode == 403 {
                 throw MiniMaxUsageError.invalidCredentials
             }
-            throw MiniMaxUsageError.apiError("HTTP \(httpResponse.statusCode)")
+            throw MiniMaxUsageError.apiError("HTTP \(response.statusCode)")
         }
 
-        return try MiniMaxUsageParser.parseCodingPlanRemains(data: data, now: now)
+        let snapshot: MiniMaxUsageSnapshot
+        do {
+            snapshot = try MiniMaxUsageParser.parseCodingPlanRemains(data: response.data, now: now)
+        } catch let error as MiniMaxUsageError {
+            throw self.normalizedAPITokenError(error)
+        } catch {
+            throw MiniMaxUsageError.parseFailed(error.localizedDescription)
+        }
+        if let services = snapshot.services, !services.isEmpty {
+            Self.log.debug("MiniMax multi-service response detected: \(services.count) services")
+        }
+        return snapshot
+    }
+
+    private static func normalizedAPITokenError(_ error: MiniMaxUsageError) -> MiniMaxUsageError {
+        guard case let .apiError(message) = error else { return error }
+        let normalizedMessage = message.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+        return normalizedMessage == "invalid api key" ? .invalidCredentials : error
+    }
+
+    private static func shouldTryLegacyAPIEndpoint(after error: MiniMaxUsageError) -> Bool {
+        switch error {
+        case .invalidCredentials:
+            true
+        case let .apiError(message):
+            message.contains("HTTP 404") || message.contains("HTTP 405")
+        case .networkError, .parseFailed:
+            true
+        }
     }
 
     private static func fetchCodingPlanHTML(
-        cookie: String,
-        authorizationToken: String?,
-        region: MiniMaxAPIRegion,
-        environment: [String: String],
+        context: WebFetchContext,
         now: Date) async throws -> MiniMaxUsageSnapshot
     {
-        let url = self.resolveCodingPlanURL(region: region, environment: environment)
+        let url = self.resolveCodingPlanURL(region: context.region, environment: context.environment)
         var request = URLRequest(url: url)
         request.httpMethod = "GET"
-        request.setValue(cookie, forHTTPHeaderField: "Cookie")
-        if let authorizationToken {
+        request.setValue(context.cookie, forHTTPHeaderField: "Cookie")
+        if let authorizationToken = context.authorizationToken {
             request.setValue("Bearer \(authorizationToken)", forHTTPHeaderField: "Authorization")
         }
         let acceptHeader = "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
@@ -133,30 +264,43 @@ public struct MiniMaxUsageFetcher: Sendable {
         let origin = self.originURL(from: url)
         request.setValue(origin.absoluteString, forHTTPHeaderField: "origin")
         request.setValue(
-            self.resolveCodingPlanRefererURL(region: region, environment: environment).absoluteString,
+            self.resolveCodingPlanRefererURL(region: context.region, environment: context.environment).absoluteString,
             forHTTPHeaderField: "referer")
 
-        let (data, response) = try await URLSession.shared.data(for: request)
-        guard let httpResponse = response as? HTTPURLResponse else {
-            throw MiniMaxUsageError.networkError("Invalid response")
+        let response: ProviderHTTPResponse
+        do {
+            response = try await context.transport.response(for: request)
+        } catch {
+            throw self.normalizedTransportError(error)
         }
 
-        guard httpResponse.statusCode == 200 else {
-            let body = String(data: data, encoding: .utf8) ?? ""
-            Self.log.error("MiniMax returned \(httpResponse.statusCode): \(body)")
-            if httpResponse.statusCode == 401 || httpResponse.statusCode == 403 {
+        guard response.statusCode == 200 else {
+            let body = String(data: response.data, encoding: .utf8) ?? ""
+            Self.log.error("MiniMax returned \(response.statusCode): \(body)")
+            if response.statusCode == 401 || response.statusCode == 403 {
                 throw MiniMaxUsageError.invalidCredentials
             }
-            throw MiniMaxUsageError.apiError("HTTP \(httpResponse.statusCode)")
+            throw MiniMaxUsageError.apiError("HTTP \(response.statusCode)")
         }
 
-        if let contentType = httpResponse.value(forHTTPHeaderField: "Content-Type"),
+        if let contentType = response.response.value(forHTTPHeaderField: "Content-Type"),
            contentType.lowercased().contains("application/json")
         {
-            return try MiniMaxUsageParser.parseCodingPlanRemains(data: data, now: now)
+            let snapshot: MiniMaxUsageSnapshot
+            do {
+                snapshot = try MiniMaxUsageParser.parseCodingPlanRemains(data: response.data, now: now)
+            } catch let error as MiniMaxUsageError {
+                throw error
+            } catch {
+                throw MiniMaxUsageError.parseFailed(error.localizedDescription)
+            }
+            if let services = snapshot.services, !services.isEmpty {
+                Self.log.debug("MiniMax multi-service response detected: \(services.count) services")
+            }
+            return snapshot
         }
 
-        let html = String(data: data, encoding: .utf8) ?? ""
+        let html = String(data: response.data, encoding: .utf8) ?? ""
         if html.contains("__NEXT_DATA__") {
             Self.log.debug("MiniMax coding plan HTML contains __NEXT_DATA__")
         }
@@ -167,17 +311,38 @@ public struct MiniMaxUsageFetcher: Sendable {
     }
 
     private static func fetchCodingPlanRemains(
-        cookie: String,
+        context: WebFetchContext,
+        remainsContext: RemainsContext,
+        now: Date) async throws -> MiniMaxUsageSnapshot
+    {
+        var lastError: Error?
+        for baseRemainsURL in self.resolveRemainsURLs(region: context.region, environment: context.environment) {
+            do {
+                return try await self.fetchCodingPlanRemainsOnce(
+                    baseRemainsURL: baseRemainsURL,
+                    context: context,
+                    remainsContext: remainsContext,
+                    now: now)
+            } catch let error as MiniMaxUsageError {
+                lastError = error
+                guard self.shouldTryNextRemainsURL(after: error) else { throw error }
+                Self.log.debug("MiniMax remains API failed for \(baseRemainsURL.host ?? "unknown host"), trying next")
+            }
+        }
+        if let lastError { throw lastError }
+        throw MiniMaxUsageError.parseFailed("Missing MiniMax remains URL.")
+    }
+
+    private static func fetchCodingPlanRemainsOnce(
+        baseRemainsURL: URL,
+        context: WebFetchContext,
         remainsContext: RemainsContext,
-        region: MiniMaxAPIRegion,
-        environment: [String: String],
         now: Date) async throws -> MiniMaxUsageSnapshot
     {
-        let baseRemainsURL = self.resolveRemainsURL(region: region, environment: environment)
         let remainsURL = self.appendGroupID(remainsContext.groupID, to: baseRemainsURL)
         var request = URLRequest(url: remainsURL)
         request.httpMethod = "GET"
-        request.setValue(cookie, forHTTPHeaderField: "Cookie")
+        request.setValue(context.cookie, forHTTPHeaderField: "Cookie")
         if let authorizationToken = remainsContext.authorizationToken {
             request.setValue("Bearer \(authorizationToken)", forHTTPHeaderField: "Authorization")
         }
@@ -192,38 +357,179 @@ public struct MiniMaxUsageFetcher: Sendable {
         let origin = self.originURL(from: baseRemainsURL)
         request.setValue(origin.absoluteString, forHTTPHeaderField: "origin")
         request.setValue(
-            self.resolveCodingPlanRefererURL(region: region, environment: environment).absoluteString,
+            self.resolveCodingPlanRefererURL(region: context.region, environment: context.environment).absoluteString,
             forHTTPHeaderField: "referer")
 
-        let (data, response) = try await URLSession.shared.data(for: request)
-        guard let httpResponse = response as? HTTPURLResponse else {
-            throw MiniMaxUsageError.networkError("Invalid response")
+        let response: ProviderHTTPResponse
+        do {
+            response = try await context.transport.response(for: request)
+        } catch {
+            throw self.normalizedTransportError(error)
         }
 
-        guard httpResponse.statusCode == 200 else {
-            let body = String(data: data, encoding: .utf8) ?? ""
-            Self.log.error("MiniMax returned \(httpResponse.statusCode): \(body)")
-            if httpResponse.statusCode == 401 || httpResponse.statusCode == 403 {
+        guard response.statusCode == 200 else {
+            let body = String(data: response.data, encoding: .utf8) ?? ""
+            Self.log.error("MiniMax returned \(response.statusCode): \(body)")
+            if response.statusCode == 401 || response.statusCode == 403 {
                 throw MiniMaxUsageError.invalidCredentials
             }
-            throw MiniMaxUsageError.apiError("HTTP \(httpResponse.statusCode)")
+            throw MiniMaxUsageError.apiError("HTTP \(response.statusCode)")
         }
 
-        if let contentType = httpResponse.value(forHTTPHeaderField: "Content-Type"),
+        if let contentType = response.response.value(forHTTPHeaderField: "Content-Type"),
            contentType.lowercased().contains("application/json")
         {
-            let payload = try MiniMaxUsageParser.decodePayload(data: data)
-            self.logCodingPlanStatus(payload: payload)
-            return try MiniMaxUsageParser.parseCodingPlanRemains(payload: payload, now: now)
+            let snapshot: MiniMaxUsageSnapshot
+            do {
+                snapshot = try MiniMaxUsageParser.parseCodingPlanRemains(data: response.data, now: now)
+            } catch let error as MiniMaxUsageError {
+                throw error
+            } catch {
+                throw MiniMaxUsageError.parseFailed(error.localizedDescription)
+            }
+            if let services = snapshot.services, !services.isEmpty {
+                Self.log.debug("MiniMax multi-service response detected: \(services.count) services")
+            }
+            return snapshot
         }
 
-        let html = String(data: data, encoding: .utf8) ?? ""
+        let html = String(data: response.data, encoding: .utf8) ?? ""
         if self.looksSignedOut(html: html) {
             throw MiniMaxUsageError.invalidCredentials
         }
         return try MiniMaxUsageParser.parse(html: html, now: now)
     }
 
+    private static func shouldTryNextRemainsURL(after error: MiniMaxUsageError) -> Bool {
+        switch error {
+        case .invalidCredentials:
+            false
+        case let .apiError(message):
+            message.contains("HTTP 404") || message.contains("HTTP 405")
+        case .networkError, .parseFailed:
+            true
+        }
+    }
+
+    private static func normalizedTransportError(_ error: Error) -> Error {
+        if error is MiniMaxUsageError || error is CancellationError {
+            return error
+        }
+        if let urlError = error as? URLError {
+            if urlError.code == .cancelled {
+                return error
+            }
+            if urlError.code == .badServerResponse {
+                return MiniMaxUsageError.networkError("Invalid response")
+            }
+            return MiniMaxUsageError.networkError(urlError.localizedDescription)
+        }
+        return error
+    }
+
+    private static func shouldRethrowAfterHTMLFallback(_ error: Error) -> Bool {
+        if error is CancellationError { return true }
+        if let urlError = error as? URLError, urlError.code == .cancelled { return true }
+        if let minimaxError = error as? MiniMaxUsageError {
+            if case .invalidCredentials = minimaxError { return true }
+        }
+        if error is ProviderEndpointOverrideError { return true }
+        return false
+    }
+
+    private static func attachingBillingIfAvailable(
+        to snapshot: MiniMaxUsageSnapshot,
+        context: WebFetchContext,
+        includeBillingHistory: Bool,
+        now: Date) async throws -> MiniMaxUsageSnapshot
+    {
+        guard includeBillingHistory else { return snapshot }
+        do {
+            let billing = try await self.fetchBillingSummary(context: context, now: now)
+            return snapshot.withBillingSummary(billing)
+        } catch is CancellationError {
+            throw CancellationError()
+        } catch let error as URLError where error.code == .cancelled {
+            throw error
+        } catch let error as MiniMaxUsageError {
+            if case .invalidCredentials = error, context.authorizationToken != nil {
+                throw error
+            }
+            Self.log.debug("MiniMax billing history unavailable: \(error.localizedDescription)")
+            return snapshot
+        } catch {
+            Self.log.debug("MiniMax billing history unavailable: \(error.localizedDescription)")
+            return snapshot
+        }
+    }
+
+    private static func fetchBillingSummary(context: WebFetchContext, now: Date) async throws -> MiniMaxBillingSummary {
+        var records: [MiniMaxBillingRecord] = []
+        var totalCount: Int?
+
+        var page = 1
+        while true {
+            let url = self.resolveBillingHistoryURL(
+                region: context.region,
+                environment: context.environment,
+                page: page,
+                limit: Self.billingHistoryLimit)
+            let response = try await self.billingHistoryResponse(url: url, context: context)
+            guard response.statusCode == 200 else {
+                let body = String(data: response.data, encoding: .utf8) ?? ""
+                Self.log.debug("MiniMax billing history returned \(response.statusCode): \(body)")
+                if response.statusCode == 401 || response.statusCode == 403 {
+                    throw MiniMaxUsageError.invalidCredentials
+                }
+                throw MiniMaxUsageError.apiError("HTTP \(response.statusCode)")
+            }
+
+            let payload = try MiniMaxBillingHistoryParser.decodePayload(data: response.data)
+            if let status = payload.baseResp?.statusCode, status != 0 {
+                let message = payload.baseResp?.statusMessage ?? "status_code \(status)"
+                throw MiniMaxUsageError.apiError(message)
+            }
+            totalCount = payload.totalCount ?? totalCount
+            guard !payload.chargeRecords.isEmpty else { break }
+            records.append(contentsOf: payload.chargeRecords)
+            if MiniMaxBillingHistoryParser.containsRecordBefore30DayWindow(payload.chargeRecords, now: now) { break }
+            if let totalCount, records.count >= totalCount { break }
+            page += 1
+        }
+
+        return MiniMaxBillingHistoryParser.aggregate(records: records, now: now)
+    }
+
+    private static func billingHistoryResponse(
+        url: URL,
+        context: WebFetchContext) async throws -> ProviderHTTPResponse
+    {
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.setValue(context.cookie, forHTTPHeaderField: "Cookie")
+        if let authorizationToken = context.authorizationToken {
+            request.setValue("Bearer \(authorizationToken)", forHTTPHeaderField: "Authorization")
+        }
+        request.setValue("application/json, text/plain, */*", forHTTPHeaderField: "accept")
+        request.setValue("XMLHttpRequest", forHTTPHeaderField: "x-requested-with")
+        let userAgent =
+            "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) " +
+            "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36"
+        request.setValue(userAgent, forHTTPHeaderField: "user-agent")
+        request.setValue("en-US,en;q=0.9", forHTTPHeaderField: "accept-language")
+        let origin = self.originURL(from: url)
+        request.setValue(origin.absoluteString, forHTTPHeaderField: "origin")
+        request.setValue(origin.appendingPathComponent("account").absoluteString, forHTTPHeaderField: "referer")
+
+        do {
+            return try await context.transport.response(for: request)
+        } catch let error as URLError where error.code == .badServerResponse {
+            throw MiniMaxUsageError.networkError("Invalid response")
+        } catch {
+            throw error
+        }
+    }
+
     private static func appendGroupID(_ groupID: String?, to url: URL) -> URL {
         guard let groupID, !groupID.isEmpty else { return url }
         guard var components = URLComponents(url: url, resolvingAgainstBaseURL: false) else { return url }
@@ -290,6 +596,79 @@ public struct MiniMaxUsageFetcher: Sendable {
         return region.remainsURL
     }
 
+    static func resolveRemainsURLs(
+        region: MiniMaxAPIRegion,
+        environment: [String: String]) -> [URL]
+    {
+        if let override = MiniMaxSettingsReader.remainsURL(environment: environment) {
+            return [override]
+        }
+        if let host = MiniMaxSettingsReader.hostOverride(environment: environment),
+           let hostURL = self.url(from: host, path: Self.codingPlanRemainsPath)
+        {
+            return [hostURL]
+        }
+
+        let primary = region.remainsURL
+        let webCandidates = self.webRemainsFallbackURLs(region: region)
+        return self.deduplicated([primary] + webCandidates)
+    }
+
+    static func resolveTokenPlanRemainsURL(region: MiniMaxAPIRegion) -> URL {
+        region.tokenPlanRemainsURL
+    }
+
+    private static func webRemainsFallbackURLs(region: MiniMaxAPIRegion) -> [URL] {
+        let hosts = switch region {
+        case .global:
+            ["https://www.minimax.io"]
+        case .chinaMainland:
+            ["https://www.minimaxi.com"]
+        }
+        return hosts.compactMap { self.url(from: $0, path: Self.codingPlanRemainsPath) }
+    }
+
+    private static func deduplicated(_ urls: [URL]) -> [URL] {
+        var seen: Set<String> = []
+        var result: [URL] = []
+        for url in urls {
+            let key = url.absoluteString
+            guard !seen.contains(key) else { continue }
+            seen.insert(key)
+            result.append(url)
+        }
+        return result
+    }
+
+    static func resolveBillingHistoryURL(
+        region: MiniMaxAPIRegion,
+        environment: [String: String],
+        page: Int,
+        limit: Int = Self.billingHistoryLimit) -> URL
+    {
+        if let override = MiniMaxSettingsReader.billingHistoryURL(environment: environment) {
+            return self.billingHistoryURL(from: override, page: page, limit: limit)
+        }
+        if let host = MiniMaxSettingsReader.hostOverride(environment: environment),
+           let hostURL = self.url(from: host, path: Self.billingHistoryPath)
+        {
+            return self.billingHistoryURL(from: hostURL, page: page, limit: limit)
+        }
+        return region.billingHistoryURL(page: page, limit: limit)
+    }
+
+    private static func billingHistoryURL(from url: URL, page: Int, limit: Int) -> URL {
+        guard var components = URLComponents(url: url, resolvingAgainstBaseURL: false) else { return url }
+        var items = components.queryItems?.filter {
+            $0.name != "page" && $0.name != "limit" && $0.name != "aggregate"
+        } ?? []
+        items.append(URLQueryItem(name: "page", value: "\(page)"))
+        items.append(URLQueryItem(name: "limit", value: "\(limit)"))
+        items.append(URLQueryItem(name: "aggregate", value: "false"))
+        components.queryItems = items
+        return components.url ?? url
+    }
+
     static func url(from raw: String, path: String? = nil, query: String? = nil) -> URL? {
         guard let cleaned = MiniMaxSettingsReader.cleaned(raw) else { return nil }
 
@@ -300,11 +679,7 @@ public struct MiniMaxUsageFetcher: Sendable {
             return components.url
         }
 
-        if let url = URL(string: cleaned), url.scheme != nil {
-            if let composed = compose(url) { return composed }
-            return url
-        }
-        guard let base = URL(string: "https://\(cleaned)") else { return nil }
+        guard let base = ProviderEndpointOverrideValidator.normalizedHTTPSURL(from: cleaned) else { return nil }
         return compose(base)
     }
 
@@ -320,12 +695,35 @@ public struct MiniMaxUsageFetcher: Sendable {
     }
 
     private static func looksSignedOut(html: String) -> Bool {
-        let lower = html.lowercased()
+        let lower = self.visibleText(from: html).lowercased()
         return lower.contains("sign in") || lower.contains("log in") || lower.contains("登录") || lower.contains("登入")
     }
+
+    static func _looksSignedOutForTesting(html: String) -> Bool {
+        self.looksSignedOut(html: html)
+    }
+
+    private static func visibleText(from html: String) -> String {
+        let patterns = [
+            #"(?is)<script\b[^>]*>.*?</script>"#,
+            #"(?is)<style\b[^>]*>.*?</style>"#,
+            #"(?is)<!--.*?-->"#,
+            #"<[^>]+>"#,
+            #"\s+"#,
+        ]
+
+        return patterns.enumerated().reduce(html) { result, item in
+            let replacement = item.offset == patterns.count - 1 ? " " : ""
+            return result.replacingOccurrences(
+                of: item.element,
+                with: replacement,
+                options: .regularExpression)
+        }
+        .trimmingCharacters(in: .whitespacesAndNewlines)
+    }
 }
 
-struct MiniMaxCodingPlanPayload: Decodable, Sendable {
+struct MiniMaxCodingPlanPayload: Decodable {
     let baseResp: MiniMaxBaseResponse?
     let data: MiniMaxCodingPlanData
 
@@ -346,13 +744,14 @@ struct MiniMaxCodingPlanPayload: Decodable, Sendable {
     }
 }
 
-struct MiniMaxCodingPlanData: Decodable, Sendable {
+struct MiniMaxCodingPlanData: Decodable {
     let baseResp: MiniMaxBaseResponse?
     let currentSubscribeTitle: String?
     let planName: String?
     let comboTitle: String?
     let currentPlanTitle: String?
     let currentComboCard: MiniMaxComboCard?
+    let pointsBalance: Double?
     let modelRemains: [MiniMaxModelRemains]
 
     private enum CodingKeys: String, CodingKey {
@@ -362,6 +761,11 @@ struct MiniMaxCodingPlanData: Decodable, Sendable {
         case comboTitle = "combo_title"
         case currentPlanTitle = "current_plan_title"
         case currentComboCard = "current_combo_card"
+        case pointsBalance = "points_balance"
+        case pointBalance = "point_balance"
+        case creditsBalance = "credits_balance"
+        case creditBalance = "credit_balance"
+        case balance
         case modelRemains = "model_remains"
     }
 
@@ -373,40 +777,22 @@ struct MiniMaxCodingPlanData: Decodable, Sendable {
         self.comboTitle = try container.decodeIfPresent(String.self, forKey: .comboTitle)
         self.currentPlanTitle = try container.decodeIfPresent(String.self, forKey: .currentPlanTitle)
         self.currentComboCard = try container.decodeIfPresent(MiniMaxComboCard.self, forKey: .currentComboCard)
+        self.pointsBalance = MiniMaxDecoding.decodeDouble(container, forKeys: [
+            .pointsBalance,
+            .pointBalance,
+            .creditsBalance,
+            .creditBalance,
+            .balance,
+        ])
         self.modelRemains = try (container.decodeIfPresent([MiniMaxModelRemains].self, forKey: .modelRemains)) ?? []
     }
 }
 
-struct MiniMaxComboCard: Decodable, Sendable {
+struct MiniMaxComboCard: Decodable {
     let title: String?
 }
 
-struct MiniMaxModelRemains: Decodable, Sendable {
-    let currentIntervalTotalCount: Int?
-    let currentIntervalUsageCount: Int?
-    let startTime: Int?
-    let endTime: Int?
-    let remainsTime: Int?
-
-    private enum CodingKeys: String, CodingKey {
-        case currentIntervalTotalCount = "current_interval_total_count"
-        case currentIntervalUsageCount = "current_interval_usage_count"
-        case startTime = "start_time"
-        case endTime = "end_time"
-        case remainsTime = "remains_time"
-    }
-
-    init(from decoder: Decoder) throws {
-        let container = try decoder.container(keyedBy: CodingKeys.self)
-        self.currentIntervalTotalCount = MiniMaxDecoding.decodeInt(container, forKey: .currentIntervalTotalCount)
-        self.currentIntervalUsageCount = MiniMaxDecoding.decodeInt(container, forKey: .currentIntervalUsageCount)
-        self.startTime = MiniMaxDecoding.decodeInt(container, forKey: .startTime)
-        self.endTime = MiniMaxDecoding.decodeInt(container, forKey: .endTime)
-        self.remainsTime = MiniMaxDecoding.decodeInt(container, forKey: .remainsTime)
-    }
-}
-
-struct MiniMaxBaseResponse: Decodable, Sendable {
+struct MiniMaxBaseResponse: Decodable {
     let statusCode: Int?
     let statusMessage: String?
 
@@ -422,22 +808,50 @@ struct MiniMaxBaseResponse: Decodable, Sendable {
     }
 }
 
-enum MiniMaxDecoding {
-    static func decodeInt<K: CodingKey>(_ container: KeyedDecodingContainer<K>, forKey key: K) -> Int? {
-        if let value = try? container.decodeIfPresent(Int.self, forKey: key) {
-            return value
-        }
-        if let value = try? container.decodeIfPresent(Int64.self, forKey: key) {
-            return Int(value)
-        }
-        if let value = try? container.decodeIfPresent(Double.self, forKey: key) {
-            return Int(value)
-        }
-        if let value = try? container.decodeIfPresent(String.self, forKey: key) {
-            let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
-            return Int(trimmed)
+// MARK: - Multi-Service API Response Structures
+
+struct MiniMaxMultiServicePayload: Decodable {
+    let data: MiniMaxMultiServiceData
+}
+
+struct MiniMaxMultiServiceData: Decodable {
+    let services: [MiniMaxServiceItem]
+}
+
+struct MiniMaxServiceItem: Decodable {
+    let serviceType: String?
+    let windowType: String?
+    let timeRange: String?
+    let usage: Int?
+    let limit: Int?
+    let percent: Double?
+
+    private enum CodingKeys: String, CodingKey {
+        case serviceType = "service_type"
+        case windowType = "window_type"
+        case timeRange = "time_range"
+        case usage
+        case limit
+        case percent
+    }
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.serviceType = try container.decodeIfPresent(String.self, forKey: .serviceType)
+        self.windowType = try container.decodeIfPresent(String.self, forKey: .windowType)
+        self.timeRange = try container.decodeIfPresent(String.self, forKey: .timeRange)
+        self.usage = MiniMaxDecoding.decodeInt(container, forKey: .usage)
+        self.limit = MiniMaxDecoding.decodeInt(container, forKey: .limit)
+        // Handle both Double and String for percent (flexible parsing)
+        if let percentDouble = try? container.decodeIfPresent(Double.self, forKey: .percent) {
+            self.percent = percentDouble
+        } else if let percentString = try? container.decodeIfPresent(String.self, forKey: .percent),
+                  let percentValue = Double(percentString)
+        {
+            self.percent = percentValue
+        } else {
+            self.percent = nil
         }
-        return nil
     }
 }
 
@@ -447,6 +861,11 @@ enum MiniMaxUsageParser {
         return try decoder.decode(MiniMaxCodingPlanPayload.self, from: data)
     }
 
+    static func decodeMultiServicePayload(data: Data) throws -> MiniMaxMultiServicePayload {
+        let decoder = JSONDecoder()
+        return try decoder.decode(MiniMaxMultiServicePayload.self, from: data)
+    }
+
     static func decodePayload(json: [String: Any]) throws -> MiniMaxCodingPlanPayload {
         let normalized = self.normalizeCodingPlanPayload(json)
         let data = try JSONSerialization.data(withJSONObject: normalized, options: [])
@@ -454,6 +873,15 @@ enum MiniMaxUsageParser {
     }
 
     static func parseCodingPlanRemains(data: Data, now: Date = Date()) throws -> MiniMaxUsageSnapshot {
+        do {
+            if let multiServiceSnapshot = try self.parseMultiService(data: data, now: now) {
+                return multiServiceSnapshot
+            }
+        } catch {
+            // Log multi-service parsing failure but continue to single-service parsing
+            MiniMaxUsageFetcher.log.debug("MiniMax multi-service parsing failed: \(error.localizedDescription)")
+        }
+
         let payload = try self.decodePayload(data: data)
         return try self.parseCodingPlanRemains(payload: payload, now: now)
     }
@@ -498,29 +926,76 @@ enum MiniMaxUsageParser {
             throw MiniMaxUsageError.apiError(message)
         }
 
-        guard let first = payload.data.modelRemains.first else {
+        guard !payload.data.modelRemains.isEmpty else {
             throw MiniMaxUsageError.parseFailed("Missing coding plan data.")
         }
 
-        let total = first.currentIntervalTotalCount
-        let remaining = first.currentIntervalUsageCount
-        let usedPercent = self.usedPercent(total: total, remaining: remaining)
+        // Convert model_remains to services array for multi-service UI display
+        var services: [MiniMaxServiceUsage] = []
+        for item in payload.data.modelRemains {
+            guard let modelName = item.modelName else { continue }
+            let serviceTypeIdentifier = self.mapModelNameToServiceType(modelName: modelName)
+
+            if let intervalService = self.makeServiceUsage(
+                ServiceUsageInput(
+                    serviceType: serviceTypeIdentifier,
+                    windowTypeOverride: nil,
+                    total: item.currentIntervalTotalCount,
+                    remaining: item.currentIntervalUsageCount,
+                    remainingPercent: item.currentIntervalRemainingPercent,
+                    status: item.currentIntervalStatus,
+                    start: item.startTime,
+                    end: item.endTime,
+                    remainsTime: item.remainsTime,
+                    boostPermille: item.intervalBoostPermille),
+                now: now)
+            {
+                services.append(intervalService)
+            }
+
+            // current_weekly_usage_count is also REMAINING quota; render only when weekly quota is real.
+            if self.shouldRenderWeeklyWindow(for: modelName),
+               let weeklyService = self.makeServiceUsage(
+                   ServiceUsageInput(
+                       serviceType: serviceTypeIdentifier,
+                       windowTypeOverride: "Weekly",
+                       total: item.currentWeeklyTotalCount,
+                       remaining: item.currentWeeklyUsageCount,
+                       remainingPercent: item.currentWeeklyRemainingPercent,
+                       status: item.currentWeeklyStatus,
+                       start: item.weeklyStartTime,
+                       end: item.weeklyEndTime,
+                       remainsTime: item.weeklyRemainsTime,
+                       boostPermille: item.weeklyBoostPermille),
+                   now: now)
+            {
+                services.append(weeklyService)
+            }
+        }
+
+        // Use first service for backward compatibility fields
+        let first = payload.data.modelRemains.first
+        let hasPercentQuota = first?.currentIntervalRemainingPercent != nil
+        let total = hasPercentQuota && first?.currentIntervalTotalCount == 0 ? nil : first?.currentIntervalTotalCount
+        let remaining = hasPercentQuota && first?.currentIntervalUsageCount == 0
+            ? nil
+            : first?.currentIntervalUsageCount
+        let usedPercent = self.usedPercent(
+            total: total,
+            remaining: remaining,
+            remainingPercent: first?.currentIntervalRemainingPercent)
 
         let windowMinutes = self.windowMinutes(
-            start: self.dateFromEpoch(first.startTime),
-            end: self.dateFromEpoch(first.endTime))
+            start: self.dateFromEpoch(first?.startTime),
+            end: self.dateFromEpoch(first?.endTime))
 
         let resetsAt = self.resetsAt(
-            end: self.dateFromEpoch(first.endTime),
-            remains: first.remainsTime,
+            end: self.dateFromEpoch(first?.endTime),
+            remains: first?.remainsTime,
             now: now)
 
         let planName = self.parsePlanName(data: payload.data)
 
-        if planName == nil, total == nil, usedPercent == nil {
-            throw MiniMaxUsageError.parseFailed("Missing coding plan data.")
-        }
-
         let currentPrompts: Int? = if let total, let remaining {
             max(0, total - remaining)
         } else {
@@ -535,16 +1010,25 @@ enum MiniMaxUsageParser {
             windowMinutes: windowMinutes,
             usedPercent: usedPercent,
             resetsAt: resetsAt,
-            updatedAt: now)
+            updatedAt: now,
+            services: services.isEmpty ? nil : services,
+            pointsBalance: payload.data.pointsBalance)
     }
 
-    private static func usedPercent(total: Int?, remaining: Int?) -> Double? {
+    private static func usedPercent(total: Int?, remaining: Int?, remainingPercent: Double? = nil) -> Double? {
+        if let remainingPercent {
+            return self.usedPercent(remainingPercent: remainingPercent)
+        }
         guard let total, total > 0, let remaining else { return nil }
         let used = max(0, total - remaining)
         let percent = Double(used) / Double(total) * 100
         return min(100, max(0, percent))
     }
 
+    private static func usedPercent(remainingPercent: Double) -> Double {
+        min(100, max(0, 100 - remainingPercent))
+    }
+
     private static func dateFromEpoch(_ value: Int?) -> Date? {
         guard let raw = value else { return nil }
         if raw > 1_000_000_000_000 {
@@ -572,40 +1056,53 @@ enum MiniMaxUsageParser {
     }
 
     private static func parsePlanName(data: MiniMaxCodingPlanData) -> String? {
-        let candidates = [
+        [
             data.currentSubscribeTitle,
             data.planName,
             data.comboTitle,
             data.currentPlanTitle,
             data.currentComboCard?.title,
-        ].compactMap(\.self)
+        ]
+            .compactMap { $0?.trimmingCharacters(in: .whitespacesAndNewlines) }
+            .first { !$0.isEmpty } ?? self.inferredTokenPlanName(data: data)
+    }
 
-        for candidate in candidates {
-            let trimmed = candidate.trimmingCharacters(in: .whitespacesAndNewlines)
-            if !trimmed.isEmpty { return trimmed }
-        }
-        return nil
+    private static func inferredTokenPlanName(data: MiniMaxCodingPlanData) -> String? {
+        let hasTextGeneration = data.modelRemains.contains { $0.modelName.map(self.isTextGenerationModelName) ?? false }
+        let hasUnavailableVideo = data.modelRemains.contains { item in
+            item.modelName?.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() == "video" &&
+                self.isUnavailableQuotaPlaceholder(ServiceUsageInput(
+                    serviceType: "Text to Video",
+                    windowTypeOverride: nil,
+                    total: item.currentIntervalTotalCount,
+                    remaining: item.currentIntervalUsageCount,
+                    remainingPercent: item.currentIntervalRemainingPercent,
+                    status: item.currentIntervalStatus,
+                    start: nil,
+                    end: nil,
+                    remainsTime: nil,
+                    boostPermille: nil))
+        }
+        return hasTextGeneration && hasUnavailableVideo ? "Plus" : nil
     }
 
     private static func parsePlanName(html: String, text: String) -> String? {
-        let candidates = [
+        [
             self.extractFirst(pattern: #"(?i)"planName"\s*:\s*"([^"]+)""#, text: html),
             self.extractFirst(pattern: #"(?i)"plan"\s*:\s*"([^"]+)""#, text: html),
             self.extractFirst(pattern: #"(?i)"packageName"\s*:\s*"([^"]+)""#, text: html),
             self.extractFirst(pattern: #"(?i)Coding\s*Plan\s*([A-Za-z0-9][A-Za-z0-9\s._-]{0,32})"#, text: text),
-        ].compactMap(\.self)
-
-        for candidate in candidates {
-            let cleaned = UsageFormatter.cleanPlanName(candidate)
-            let trimmed = cleaned
-                .replacingOccurrences(
-                    of: #"(?i)\s+available\s+usage.*$"#,
-                    with: "",
-                    options: .regularExpression)
-                .trimmingCharacters(in: .whitespacesAndNewlines)
-            if !trimmed.isEmpty { return trimmed }
-        }
-        return nil
+        ]
+            .compactMap(\.self)
+            .map {
+                UsageFormatter.cleanPlanName($0)
+                    .replacingOccurrences(
+                        of: #"(?i)\s+available\s+usage.*$"#,
+                        with: "",
+                        options: .regularExpression)
+                    .trimmingCharacters(in: .whitespacesAndNewlines)
+            }
+            .first { !$0.isEmpty }
     }
 
     private static func parseNextData(html: String, now: Date) -> MiniMaxUsageSnapshot? {
@@ -666,6 +1163,12 @@ enum MiniMaxUsageParser {
         if normalized["base_resp"] == nil, let value = normalized["baseResp"] {
             normalized["base_resp"] = value
         }
+        if normalized["points_balance"] == nil, let value = normalized["pointsBalance"] {
+            normalized["points_balance"] = value
+        }
+        if normalized["credits_balance"] == nil, let value = normalized["creditsBalance"] {
+            normalized["credits_balance"] = value
+        }
 
         if let data = normalized["data"] as? [String: Any] {
             normalized["data"] = self.normalizeCodingPlanPayload(data)
@@ -786,7 +1289,7 @@ enum MiniMaxUsageParser {
         if let tzHint = timeZoneHint?.trimmingCharacters(in: .whitespacesAndNewlines),
            !tzHint.isEmpty
         {
-            formatter.timeZone = TimeZone(identifier: tzHint)
+            formatter.timeZone = self.timeZone(from: tzHint)
         }
         formatter.locale = Locale(identifier: "en_US_POSIX")
 
@@ -816,6 +1319,33 @@ enum MiniMaxUsageParser {
         return 0
     }
 
+    private static func timeZone(from hint: String) -> TimeZone? {
+        let trimmed = hint.trimmingCharacters(in: .whitespacesAndNewlines)
+        if let timeZone = TimeZone(identifier: trimmed) {
+            return timeZone
+        }
+
+        let pattern = #"(?i)^(?:UTC|GMT)\s*([+-])\s*(\d{1,2})(?::?(\d{2}))?$"#
+        guard let regex = try? NSRegularExpression(pattern: pattern),
+              let match = regex.firstMatch(in: trimmed, range: NSRange(trimmed.startIndex..., in: trimmed)),
+              let signRange = Range(match.range(at: 1), in: trimmed),
+              let hourRange = Range(match.range(at: 2), in: trimmed)
+        else {
+            return nil
+        }
+
+        let sign = trimmed[signRange] == "-" ? -1 : 1
+        let hours = Int(trimmed[hourRange]) ?? 0
+        let minutes = if match.range(at: 3).location != NSNotFound,
+                         let minuteRange = Range(match.range(at: 3), in: trimmed)
+        {
+            Int(trimmed[minuteRange]) ?? 0
+        } else {
+            0
+        }
+        return TimeZone(secondsFromGMT: sign * ((hours * 3600) + (minutes * 60)))
+    }
+
     private static func seconds(from value: Double, unit: String) -> TimeInterval {
         let lower = unit.lowercased()
         if lower.hasPrefix("d") { return value * 24 * 60 * 60 }
@@ -855,24 +1385,283 @@ enum MiniMaxUsageParser {
             return String(text[captureRange]).trimmingCharacters(in: .whitespacesAndNewlines)
         }
     }
-}
 
-public enum MiniMaxUsageError: LocalizedError, Sendable, Equatable {
-    case invalidCredentials
-    case networkError(String)
-    case apiError(String)
-    case parseFailed(String)
+    // MARK: - Multi-Service Parsing
 
-    public var errorDescription: String? {
-        switch self {
-        case .invalidCredentials:
-            "MiniMax credentials are invalid or expired."
-        case let .networkError(message):
-            "MiniMax network error: \(message)"
-        case let .apiError(message):
-            "MiniMax API error: \(message)"
-        case let .parseFailed(message):
-            "Failed to parse MiniMax coding plan: \(message)"
+    private static func parseMultiService(data: Data, now: Date) throws -> MiniMaxUsageSnapshot? {
+        let payload = try self.decodeMultiServicePayload(data: data)
+
+        guard !payload.data.services.isEmpty else {
+            return nil
         }
+
+        var services: [MiniMaxServiceUsage] = []
+        for item in payload.data.services {
+            guard let serviceType = item.serviceType,
+                  let windowType = item.windowType,
+                  let timeRange = item.timeRange,
+                  let usage = item.usage,
+                  let limit = item.limit,
+                  limit > 0
+            else {
+                continue
+            }
+
+            var percent = item.percent ?? 0.0
+            if item.percent == nil, limit > 0 {
+                percent = Double(usage) / Double(limit) * 100.0
+            }
+
+            let resetsAt = self.parseResetsAtFromTimeRange(timeRange: timeRange, windowType: windowType, now: now)
+            let resetDescription = self.resetDescription(
+                for: windowType,
+                timeRange: timeRange,
+                now: now,
+                resetsAt: resetsAt)
+
+            let serviceTypeIdentifier: String = if serviceType.lowercased().contains("text"),
+                                                   serviceType.lowercased().contains("generation")
+            {
+                "text-generation"
+            } else if serviceType.lowercased().contains("text"), serviceType.lowercased().contains("speech") {
+                "text-to-speech"
+            } else if serviceType.lowercased().contains("image") {
+                "image"
+            } else {
+                serviceType.lowercased()
+                    .replacingOccurrences(of: " ", with: "-")
+                    .replacingOccurrences(of: "_", with: "-")
+            }
+
+            let serviceUsage = MiniMaxServiceUsage(
+                serviceType: serviceTypeIdentifier,
+                windowType: windowType,
+                timeRange: timeRange,
+                usage: usage,
+                limit: limit,
+                percent: min(100.0, max(0.0, percent)),
+                resetsAt: resetsAt,
+                resetDescription: resetDescription)
+            services.append(serviceUsage)
+        }
+
+        if services.isEmpty {
+            return nil
+        }
+
+        let planName = self.extractPlanNameFromServices(services: payload.data.services)
+
+        return MiniMaxUsageSnapshot(
+            planName: planName,
+            availablePrompts: nil,
+            currentPrompts: nil,
+            remainingPrompts: nil,
+            windowMinutes: nil,
+            usedPercent: nil,
+            resetsAt: nil,
+            updatedAt: now,
+            services: services)
+    }
+
+    private static func parseResetsAtFromTimeRange(timeRange: String, windowType: String, now: Date) -> Date? {
+        let lowerWindow = windowType.lowercased().trimmingCharacters(in: .whitespacesAndNewlines)
+
+        if lowerWindow == "today" {
+            let components = timeRange.split(separator: "-", maxSplits: 1)
+            guard components.count == 2 else { return nil }
+
+            let endTimeStr = String(components[1].trimmingCharacters(in: .whitespacesAndNewlines))
+            let formatter = DateFormatter()
+            formatter.dateFormat = "yyyy/MM/dd HH:mm"
+            formatter.locale = Locale(identifier: "en_US_POSIX")
+            formatter.timeZone = TimeZone(identifier: "Asia/Shanghai")
+
+            return formatter.date(from: endTimeStr)
+        }
+
+        if lowerWindow.contains("hour") || lowerWindow.contains("h") {
+            let timeComponents = timeRange.split(separator: "-")
+            guard timeComponents.count >= 2 else { return nil }
+
+            let endTimePart = String(timeComponents[1])
+            let endTimeClean = endTimePart.replacingOccurrences(of: "\\(.*\\)", with: "", options: .regularExpression)
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+
+            return self.dateForTime(endTimeClean, timeZoneHint: "UTC+8", now: now)
+        }
+
+        return nil
+    }
+
+    private static func resetDescription(
+        for windowType: String,
+        timeRange: String,
+        now: Date,
+        resetsAt: Date?) -> String
+    {
+        if let resetsAt, resetsAt > now {
+            let interval = resetsAt.timeIntervalSince(now)
+            if interval < 60 {
+                return "Resets in \(Int(interval)) seconds"
+            } else if interval < 3600 {
+                let minutes = Int(interval / 60)
+                return "Resets in \(minutes) minute\(minutes == 1 ? "" : "s")"
+            } else if interval < 86400 {
+                let hours = Int(interval / 3600)
+                return "Resets in \(hours) hour\(hours == 1 ? "" : "s")"
+            } else {
+                let days = Int(interval / 86400)
+                return "Resets in \(days) day\(days == 1 ? "" : "s")"
+            }
+        }
+
+        return "\(windowType): \(timeRange)"
+    }
+
+    private static func extractPlanNameFromServices(services: [MiniMaxServiceItem]) -> String? {
+        for service in services {
+            if let serviceType = service.serviceType,
+               serviceType.lowercased().contains("pro") || serviceType.lowercased().contains("max")
+            {
+                return serviceType
+            }
+        }
+
+        return nil
+    }
+
+    private static func parseWindowInfo(
+        startTime: Date?,
+        endTime: Date?,
+        now: Date) -> (windowType: String, timeRange: String)
+    {
+        guard let startTime, let endTime else {
+            return (windowType: "Unknown", timeRange: "N/A")
+        }
+
+        let durationSeconds = endTime.timeIntervalSince(startTime)
+        let durationHours = durationSeconds / 3600
+
+        // Determine window type based on duration
+        let windowType = if durationHours >= 23, durationHours <= 25 {
+            "Today"
+        } else if durationHours >= 4, durationHours <= 6 {
+            "5 hours"
+        } else if durationHours >= 1, durationHours < 23 {
+            "\(Int(durationHours)) hours"
+        } else {
+            "Custom"
+        }
+
+        // Format time range
+        let formatter = DateFormatter()
+        formatter.dateFormat = "HH:mm"
+        formatter.timeZone = TimeZone(identifier: "Asia/Shanghai") ?? .current
+        let startStr = formatter.string(from: startTime)
+        let endStr = formatter.string(from: endTime)
+
+        let timeRange = "\(startStr)-\(endStr)(UTC+8)"
+
+        return (windowType: windowType, timeRange: timeRange)
+    }
+
+    private struct ServiceUsageInput {
+        let serviceType: String
+        let windowTypeOverride: String?
+        let total: Int?
+        let remaining: Int?
+        let remainingPercent: Double?
+        let status: Int?
+        let start: Int?
+        let end: Int?
+        let remainsTime: Int?
+        let boostPermille: Int?
+    }
+
+    private static func makeServiceUsage(_ input: ServiceUsageInput, now: Date) -> MiniMaxServiceUsage? {
+        guard self.shouldRenderQuotaWindow(input) else { return nil }
+
+        let startTime = self.dateFromEpoch(input.start)
+        let endTime = self.dateFromEpoch(input.end)
+        var (windowType, timeRange) = self.parseWindowInfo(startTime: startTime, endTime: endTime, now: now)
+        if let windowTypeOverride = input.windowTypeOverride { windowType = windowTypeOverride }
+        if windowType.lowercased() == "weekly",
+           let weeklyRange = self.formatMiniMaxDateTimeRange(startTime: startTime, endTime: endTime)
+        {
+            timeRange = weeklyRange
+        }
+
+        let isUnlimited = self.isUnlimitedQuotaWindow(input, windowType: windowType)
+        let resetsAt = isUnlimited ? nil : self.resetsAt(end: endTime, remains: input.remainsTime, now: now)
+        let resetDescription = if isUnlimited {
+            "Unlimited"
+        } else {
+            self.resetDescription(
+                for: windowType,
+                timeRange: timeRange,
+                now: now,
+                resetsAt: resetsAt)
+        }
+        let limit: Int
+        let usage: Int
+        let percent: Double
+        if isUnlimited {
+            percent = 0
+            limit = 0
+            usage = 0
+        } else if let remainingPercent = input.remainingPercent {
+            let quotaLimit = self.percentQuotaLimit(boostPermille: input.boostPermille)
+            percent = self.usedPercent(remainingPercent: remainingPercent)
+            limit = quotaLimit
+            usage = Int((percent * Double(quotaLimit) / 100.0).rounded())
+        } else {
+            guard let total = input.total, total > 0, let remaining = input.remaining else { return nil }
+            let used = max(0, total - remaining)
+            percent = Double(used) / Double(total) * 100.0
+            limit = total
+            usage = used
+        }
+
+        return MiniMaxServiceUsage(
+            serviceType: input.serviceType,
+            windowType: windowType,
+            timeRange: timeRange,
+            usage: usage,
+            limit: limit,
+            percent: min(100.0, max(0.0, percent)),
+            isUnlimited: isUnlimited,
+            resetsAt: resetsAt,
+            resetDescription: resetDescription)
+    }
+
+    private static func percentQuotaLimit(boostPermille: Int?) -> Int {
+        guard let boostPermille, boostPermille > 0 else { return 100 }
+        return max(1, Int((Double(boostPermille) / 10.0).rounded()))
+    }
+
+    private static func shouldRenderQuotaWindow(_ input: ServiceUsageInput) -> Bool {
+        // MiniMax Token Plan returns status 3 for quota lanes that exist in the schema but are not included in
+        // the current subscription, for example Plus accounts receiving a video lane with 100% remaining and 0 count.
+        !self.isUnavailableQuotaPlaceholder(input)
+    }
+
+    private static func isUnavailableQuotaPlaceholder(_ input: ServiceUsageInput) -> Bool {
+        if let windowType = input.windowTypeOverride, self.isUnlimitedQuotaWindow(input, windowType: windowType) {
+            return false
+        }
+        return input.status == 3 &&
+            (input.total ?? 0) == 0 &&
+            (input.remaining ?? 0) == 0 &&
+            (input.remainingPercent.map { $0 >= 100 } ?? false)
+    }
+
+    private static func isUnlimitedQuotaWindow(_ input: ServiceUsageInput, windowType: String) -> Bool {
+        let normalizedService = input.serviceType.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+        let normalizedWindow = windowType.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+        let unlimitedServices = ["text generation", "general"]
+        return input.status == 3 &&
+            unlimitedServices.contains(normalizedService) &&
+            normalizedWindow == "weekly" &&
+            (input.remainingPercent.map { $0 >= 100 } ?? false)
     }
 }
diff --git a/Sources/CodexBarCore/Providers/MiniMax/MiniMaxUsageSnapshot+Metadata.swift b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxUsageSnapshot+Metadata.swift
new file mode 100644
index 0000000000..d5048761b8
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxUsageSnapshot+Metadata.swift
@@ -0,0 +1,47 @@
+import Foundation
+
+extension MiniMaxUsageSnapshot {
+    func withPlanNameIfMissing(_ planName: String?) -> MiniMaxUsageSnapshot {
+        let existing = self.planName?.trimmingCharacters(in: .whitespacesAndNewlines)
+        if let existing, !existing.isEmpty { return self }
+        let cleaned = planName?.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard let cleaned, !cleaned.isEmpty else { return self }
+        return MiniMaxUsageSnapshot(
+            planName: cleaned,
+            availablePrompts: self.availablePrompts,
+            currentPrompts: self.currentPrompts,
+            remainingPrompts: self.remainingPrompts,
+            windowMinutes: self.windowMinutes,
+            usedPercent: self.usedPercent,
+            resetsAt: self.resetsAt,
+            updatedAt: self.updatedAt,
+            services: self.services,
+            billingSummary: self.billingSummary,
+            pointsBalance: self.pointsBalance,
+            subscriptionExpiresAt: self.subscriptionExpiresAt,
+            subscriptionRenewsAt: self.subscriptionRenewsAt)
+    }
+
+    func withSubscriptionMetadata(_ metadata: MiniMaxSubscriptionMetadata) -> MiniMaxUsageSnapshot {
+        MiniMaxUsageSnapshot(
+            planName: metadata.planName?.trimmingCharacters(in: .whitespacesAndNewlines).nonEmpty ?? self.planName,
+            availablePrompts: self.availablePrompts,
+            currentPrompts: self.currentPrompts,
+            remainingPrompts: self.remainingPrompts,
+            windowMinutes: self.windowMinutes,
+            usedPercent: self.usedPercent,
+            resetsAt: self.resetsAt,
+            updatedAt: self.updatedAt,
+            services: self.services,
+            billingSummary: self.billingSummary,
+            pointsBalance: self.pointsBalance,
+            subscriptionExpiresAt: metadata.subscriptionExpiresAt ?? self.subscriptionExpiresAt,
+            subscriptionRenewsAt: metadata.subscriptionRenewsAt ?? self.subscriptionRenewsAt)
+    }
+}
+
+extension String {
+    fileprivate var nonEmpty: String? {
+        self.isEmpty ? nil : self
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/MiniMax/MiniMaxUsageSnapshot.swift b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxUsageSnapshot.swift
index 09ed671e26..fe73270d0d 100644
--- a/Sources/CodexBarCore/Providers/MiniMax/MiniMaxUsageSnapshot.swift
+++ b/Sources/CodexBarCore/Providers/MiniMax/MiniMaxUsageSnapshot.swift
@@ -9,6 +9,60 @@ public struct MiniMaxUsageSnapshot: Sendable {
     public let usedPercent: Double?
     public let resetsAt: Date?
     public let updatedAt: Date
+    public let services: [MiniMaxServiceUsage]?
+    public let billingSummary: MiniMaxBillingSummary?
+    public let pointsBalance: Double?
+    public let subscriptionExpiresAt: Date?
+    public let subscriptionRenewsAt: Date?
+
+    public var primaryService: MiniMaxServiceUsage? {
+        self.orderedQuotaServices.first
+    }
+
+    public var secondaryService: MiniMaxServiceUsage? {
+        let services = self.orderedQuotaServices
+        guard services.count >= 2 else { return nil }
+        return services[1]
+    }
+
+    public var tertiaryService: MiniMaxServiceUsage? {
+        let services = self.orderedQuotaServices
+        guard services.count >= 3 else { return nil }
+        return services[2]
+    }
+
+    public var orderedQuotaServices: [MiniMaxServiceUsage] {
+        guard let services, !services.isEmpty else { return [] }
+        return services.enumerated().sorted { lhs, rhs in
+            let lhsRank = self.quotaServiceRank(lhs.element, originalIndex: lhs.offset)
+            let rhsRank = self.quotaServiceRank(rhs.element, originalIndex: rhs.offset)
+            if lhsRank.primary != rhsRank.primary {
+                return lhsRank.primary < rhsRank.primary
+            }
+            if lhsRank.window != rhsRank.window {
+                return lhsRank.window < rhsRank.window
+            }
+            return lhsRank.originalIndex < rhsRank.originalIndex
+        }.map(\.element)
+    }
+
+    private func quotaServiceRank(
+        _ service: MiniMaxServiceUsage,
+        originalIndex: Int) -> (primary: Int, window: Int, originalIndex: Int)
+    {
+        (
+            primary: service.isPrimaryTextQuotaLane ? 0 : 1,
+            window: self.quotaWindowRank(service),
+            originalIndex: originalIndex)
+    }
+
+    private func quotaWindowRank(_ service: MiniMaxServiceUsage) -> Int {
+        let window = service.windowType.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+        if window == "weekly" {
+            return 1
+        }
+        return 0
+    }
 
     public init(
         planName: String?,
@@ -18,7 +72,12 @@ public struct MiniMaxUsageSnapshot: Sendable {
         windowMinutes: Int?,
         usedPercent: Double?,
         resetsAt: Date?,
-        updatedAt: Date)
+        updatedAt: Date,
+        services: [MiniMaxServiceUsage]? = nil,
+        billingSummary: MiniMaxBillingSummary? = nil,
+        pointsBalance: Double? = nil,
+        subscriptionExpiresAt: Date? = nil,
+        subscriptionRenewsAt: Date? = nil)
     {
         self.planName = planName
         self.availablePrompts = availablePrompts
@@ -28,11 +87,60 @@ public struct MiniMaxUsageSnapshot: Sendable {
         self.usedPercent = usedPercent
         self.resetsAt = resetsAt
         self.updatedAt = updatedAt
+        self.services = services
+        self.billingSummary = billingSummary
+        self.pointsBalance = pointsBalance
+        self.subscriptionExpiresAt = subscriptionExpiresAt
+        self.subscriptionRenewsAt = subscriptionRenewsAt
+    }
+
+    public func withBillingSummary(_ billingSummary: MiniMaxBillingSummary?) -> MiniMaxUsageSnapshot {
+        MiniMaxUsageSnapshot(
+            planName: self.planName,
+            availablePrompts: self.availablePrompts,
+            currentPrompts: self.currentPrompts,
+            remainingPrompts: self.remainingPrompts,
+            windowMinutes: self.windowMinutes,
+            usedPercent: self.usedPercent,
+            resetsAt: self.resetsAt,
+            updatedAt: self.updatedAt,
+            services: self.services,
+            billingSummary: billingSummary,
+            pointsBalance: self.pointsBalance,
+            subscriptionExpiresAt: self.subscriptionExpiresAt,
+            subscriptionRenewsAt: self.subscriptionRenewsAt)
     }
 }
 
 extension MiniMaxUsageSnapshot {
     public func toUsageSnapshot() -> UsageSnapshot {
+        // If we have services array, use that for multi-service support
+        if let services = self.services, !services.isEmpty {
+            let primaryWindow = self.rateWindow(for: self.primaryService)
+            let secondaryWindow = self.rateWindow(for: self.secondaryService)
+            let tertiaryWindow = self.rateWindow(for: self.tertiaryService)
+
+            let planName = self.planName?.trimmingCharacters(in: .whitespacesAndNewlines)
+            let loginMethod = (planName?.isEmpty ?? true) ? nil : planName
+            let identity = ProviderIdentitySnapshot(
+                providerID: .minimax,
+                accountEmail: nil,
+                accountOrganization: nil,
+                loginMethod: loginMethod)
+
+            return UsageSnapshot(
+                primary: primaryWindow,
+                secondary: secondaryWindow,
+                tertiary: tertiaryWindow,
+                providerCost: self.pointsBalanceSnapshot(),
+                minimaxUsage: self,
+                subscriptionExpiresAt: self.subscriptionExpiresAt,
+                subscriptionRenewsAt: self.subscriptionRenewsAt,
+                updatedAt: self.updatedAt,
+                identity: identity)
+        }
+
+        // Fallback to single-service mode for backward compatibility
         let used = max(0, min(100, self.usedPercent ?? 0))
         let resetDescription = self.limitDescription()
         let primary = RateWindow(
@@ -53,12 +161,24 @@ extension MiniMaxUsageSnapshot {
             primary: primary,
             secondary: nil,
             tertiary: nil,
-            providerCost: nil,
+            providerCost: self.pointsBalanceSnapshot(),
             minimaxUsage: self,
+            subscriptionExpiresAt: self.subscriptionExpiresAt,
+            subscriptionRenewsAt: self.subscriptionRenewsAt,
             updatedAt: self.updatedAt,
             identity: identity)
     }
 
+    private func rateWindow(for service: MiniMaxServiceUsage?) -> RateWindow? {
+        guard let service else { return nil }
+        let windowMinutes = self.windowMinutes(for: service)
+        return RateWindow(
+            usedPercent: max(0, min(100, service.percent)),
+            windowMinutes: windowMinutes,
+            resetsAt: service.resetsAt,
+            resetDescription: service.resetDescription)
+    }
+
     private func limitDescription() -> String? {
         guard let availablePrompts, availablePrompts > 0 else {
             return self.windowDescription()
@@ -82,4 +202,44 @@ extension MiniMaxUsageSnapshot {
         }
         return "\(windowMinutes) \(windowMinutes == 1 ? "minute" : "minutes")"
     }
+
+    private func windowMinutes(for service: MiniMaxServiceUsage) -> Int? {
+        let windowType = service.windowType.lowercased().trimmingCharacters(in: .whitespacesAndNewlines)
+
+        // Handle "Today" case - 24 hours = 1440 minutes
+        if windowType == "today" {
+            return 24 * 60
+        }
+        if windowType == "weekly" {
+            return 7 * 24 * 60
+        }
+
+        // Handle time duration formats like "5 hours", "30 minutes", etc.
+        let components = windowType.split(separator: " ")
+        guard components.count >= 2 else { return nil }
+
+        guard let value = Int(components[0]) else { return nil }
+        let unit = components[1].lowercased()
+
+        switch unit {
+        case "hour", "hours", "h", "hr", "hrs":
+            return value * 60
+        case "minute", "minutes", "min", "mins", "m":
+            return value
+        case "day", "days", "d":
+            return value * 24 * 60
+        default:
+            return nil
+        }
+    }
+
+    private func pointsBalanceSnapshot() -> ProviderCostSnapshot? {
+        guard let pointsBalance, pointsBalance >= 0 else { return nil }
+        return ProviderCostSnapshot(
+            used: pointsBalance,
+            limit: 0,
+            currencyCode: "Points",
+            period: "MiniMax points balance",
+            updatedAt: self.updatedAt)
+    }
 }
diff --git a/Sources/CodexBarCore/Providers/Mistral/MistralCookieImporter.swift b/Sources/CodexBarCore/Providers/Mistral/MistralCookieImporter.swift
new file mode 100644
index 0000000000..8d1c6d38df
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Mistral/MistralCookieImporter.swift
@@ -0,0 +1,101 @@
+import Foundation
+
+#if os(macOS)
+import SweetCookieKit
+
+private let mistralCookieImportOrder: BrowserCookieImportOrder =
+    ProviderDefaults.metadata[.mistral]?.browserCookieOrder ?? Browser.defaultImportOrder
+
+public enum MistralCookieImporter {
+    private static let cookieClient = BrowserCookieClient()
+    private static let cookieDomains = ["mistral.ai", "admin.mistral.ai", "auth.mistral.ai"]
+
+    public struct SessionInfo: Sendable {
+        public let cookies: [HTTPCookie]
+        public let sourceLabel: String
+
+        public init(cookies: [HTTPCookie], sourceLabel: String) {
+            self.cookies = cookies
+            self.sourceLabel = sourceLabel
+        }
+
+        public var cookieHeader: String {
+            self.cookies.map { "\($0.name)=\($0.value)" }.joined(separator: "; ")
+        }
+
+        /// Extracts the CSRF token from the `csrftoken` cookie for the `X-CSRFTOKEN` header.
+        public var csrfToken: String? {
+            self.cookies.first { $0.name == "csrftoken" }?.value
+        }
+    }
+
+    /// Returns `true` if any cookie name starts with `ory_session_` (the Ory Kratos session cookie).
+    private static func hasSessionCookie(_ cookies: [HTTPCookie]) -> Bool {
+        cookies.contains { $0.name.hasPrefix("ory_session_") }
+    }
+
+    public static func importSession(
+        browserDetection: BrowserDetection,
+        preferredBrowsers: [Browser] = [.chrome],
+        logger: ((String) -> Void)? = nil) throws -> SessionInfo
+    {
+        let log: (String) -> Void = { msg in logger?("[mistral-cookie] \(msg)") }
+        let installedBrowsers = preferredBrowsers.isEmpty
+            ? mistralCookieImportOrder.cookieImportCandidates(using: browserDetection)
+            : preferredBrowsers.cookieImportCandidates(using: browserDetection)
+
+        for browserSource in installedBrowsers {
+            do {
+                let query = BrowserCookieQuery(domains: self.cookieDomains)
+                let sources = try Self.cookieClient.codexBarRecords(
+                    matching: query,
+                    in: browserSource,
+                    logger: log)
+                for source in sources where !source.records.isEmpty {
+                    let httpCookies = BrowserCookieClient.makeHTTPCookies(source.records, origin: query.origin)
+                    if !httpCookies.isEmpty {
+                        guard Self.hasSessionCookie(httpCookies) else {
+                            log("Skipping \(source.label) cookies: missing ory_session_* cookie")
+                            continue
+                        }
+                        log("Found \(httpCookies.count) Mistral cookies in \(source.label)")
+                        return SessionInfo(cookies: httpCookies, sourceLabel: source.label)
+                    }
+                }
+            } catch {
+                BrowserCookieAccessGate.recordIfNeeded(error)
+                log("\(browserSource.displayName) cookie import failed: \(error.localizedDescription)")
+            }
+        }
+
+        throw MistralCookieImportError.noCookies
+    }
+
+    public static func hasSession(
+        browserDetection: BrowserDetection,
+        preferredBrowsers: [Browser] = [.chrome],
+        logger: ((String) -> Void)? = nil) -> Bool
+    {
+        do {
+            _ = try self.importSession(
+                browserDetection: browserDetection,
+                preferredBrowsers: preferredBrowsers,
+                logger: logger)
+            return true
+        } catch {
+            return false
+        }
+    }
+}
+
+enum MistralCookieImportError: LocalizedError {
+    case noCookies
+
+    var errorDescription: String? {
+        switch self {
+        case .noCookies:
+            "No Mistral session cookies found in browsers."
+        }
+    }
+}
+#endif
diff --git a/Sources/CodexBarCore/Providers/Mistral/MistralErrors.swift b/Sources/CodexBarCore/Providers/Mistral/MistralErrors.swift
new file mode 100644
index 0000000000..1c8ab4ae42
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Mistral/MistralErrors.swift
@@ -0,0 +1,35 @@
+import Foundation
+
+public enum MistralUsageError: LocalizedError, Sendable {
+    case missingCookie
+    case invalidCredentials
+    case apiError(String)
+    case parseFailed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingCookie:
+            "No Mistral session cookies found in browsers."
+        case .invalidCredentials:
+            "Mistral session expired or invalid (HTTP 401/403)."
+        case let .apiError(detail):
+            "Mistral API error: \(detail)"
+        case let .parseFailed(detail):
+            "Failed to parse Mistral billing response: \(detail)"
+        }
+    }
+}
+
+enum MistralSettingsError: LocalizedError {
+    case missingCookie
+    case invalidCookie
+
+    var errorDescription: String? {
+        switch self {
+        case .missingCookie:
+            "No Mistral session cookies found in browsers."
+        case .invalidCookie:
+            "Mistral cookie header is invalid or missing ory_session cookie."
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Mistral/MistralModels.swift b/Sources/CodexBarCore/Providers/Mistral/MistralModels.swift
new file mode 100644
index 0000000000..1470a76881
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Mistral/MistralModels.swift
@@ -0,0 +1,250 @@
+import Foundation
+
+// MARK: - API Response Models
+
+/// Top-level response from `GET https://admin.mistral.ai/api/billing/v2/usage`.
+struct MistralBillingResponse: Codable {
+    let completion: MistralModelUsageCategory?
+    let ocr: MistralModelUsageCategory?
+    let connectors: MistralModelUsageCategory?
+    let librariesApi: MistralLibrariesUsageCategory?
+    let fineTuning: MistralFineTuningCategory?
+    let audio: MistralModelUsageCategory?
+    let vibeUsage: Double?
+    let date: String?
+    let previousMonth: String?
+    let nextMonth: String?
+    let startDate: String?
+    let endDate: String?
+    let currency: String?
+    let currencySymbol: String?
+    let prices: [MistralPrice]?
+
+    enum CodingKeys: String, CodingKey {
+        case completion, ocr, connectors, audio, date, currency, prices
+        case librariesApi = "libraries_api"
+        case fineTuning = "fine_tuning"
+        case vibeUsage = "vibe_usage"
+        case previousMonth = "previous_month"
+        case nextMonth = "next_month"
+        case startDate = "start_date"
+        case endDate = "end_date"
+        case currencySymbol = "currency_symbol"
+    }
+}
+
+struct MistralModelUsageCategory: Codable {
+    let models: [String: MistralModelUsageData]?
+}
+
+struct MistralLibrariesUsageCategory: Codable {
+    let pages: MistralModelUsageCategory?
+    let tokens: MistralModelUsageCategory?
+}
+
+struct MistralFineTuningCategory: Codable {
+    let training: [String: MistralModelUsageData]?
+    let storage: [String: MistralModelUsageData]?
+}
+
+struct MistralModelUsageData: Codable {
+    let input: [MistralUsageEntry]?
+    let output: [MistralUsageEntry]?
+    let cached: [MistralUsageEntry]?
+}
+
+struct MistralUsageEntry: Codable {
+    let usageType: String?
+    let eventType: String?
+    let billingMetric: String?
+    let billingDisplayName: String?
+    let billingGroup: String?
+    let timestamp: String?
+    let value: Int?
+    let valuePaid: Int?
+
+    enum CodingKeys: String, CodingKey {
+        case timestamp, value
+        case usageType = "usage_type"
+        case eventType = "event_type"
+        case billingMetric = "billing_metric"
+        case billingDisplayName = "billing_display_name"
+        case billingGroup = "billing_group"
+        case valuePaid = "value_paid"
+    }
+}
+
+struct MistralPrice: Codable {
+    let eventType: String?
+    let billingMetric: String?
+    let billingGroup: String?
+    let price: String?
+
+    enum CodingKeys: String, CodingKey {
+        case price
+        case eventType = "event_type"
+        case billingMetric = "billing_metric"
+        case billingGroup = "billing_group"
+    }
+}
+
+// MARK: - Intermediate Snapshot
+
+public struct MistralDailyUsageBucket: Codable, Equatable, Sendable, Identifiable {
+    public struct ModelBreakdown: Codable, Equatable, Sendable, Identifiable {
+        public let name: String
+        public let cost: Double
+        public let inputTokens: Int
+        public let cachedTokens: Int
+        public let outputTokens: Int
+
+        public var id: String {
+            self.name
+        }
+
+        public var totalTokens: Int {
+            self.inputTokens + self.cachedTokens + self.outputTokens
+        }
+
+        public init(name: String, cost: Double, inputTokens: Int, cachedTokens: Int, outputTokens: Int) {
+            self.name = name
+            self.cost = cost
+            self.inputTokens = inputTokens
+            self.cachedTokens = cachedTokens
+            self.outputTokens = outputTokens
+        }
+    }
+
+    public let day: String
+    public let cost: Double
+    public let inputTokens: Int
+    public let cachedTokens: Int
+    public let outputTokens: Int
+    public let models: [ModelBreakdown]
+
+    public var id: String {
+        self.day
+    }
+
+    public var totalTokens: Int {
+        self.inputTokens + self.cachedTokens + self.outputTokens
+    }
+
+    public init(
+        day: String,
+        cost: Double,
+        inputTokens: Int,
+        cachedTokens: Int,
+        outputTokens: Int,
+        models: [ModelBreakdown])
+    {
+        self.day = day
+        self.cost = cost
+        self.inputTokens = inputTokens
+        self.cachedTokens = cachedTokens
+        self.outputTokens = outputTokens
+        self.models = models
+    }
+}
+
+public struct MistralUsageSnapshot: Codable, Sendable {
+    public let totalCost: Double
+    public let currency: String
+    public let currencySymbol: String
+    public let totalInputTokens: Int
+    public let totalOutputTokens: Int
+    public let totalCachedTokens: Int
+    public let modelCount: Int
+    public let daily: [MistralDailyUsageBucket]
+    public let startDate: Date?
+    public let endDate: Date?
+    public let updatedAt: Date
+
+    public init(
+        totalCost: Double,
+        currency: String,
+        currencySymbol: String,
+        totalInputTokens: Int,
+        totalOutputTokens: Int,
+        totalCachedTokens: Int,
+        modelCount: Int,
+        daily: [MistralDailyUsageBucket] = [],
+        startDate: Date?,
+        endDate: Date?,
+        updatedAt: Date)
+    {
+        self.totalCost = totalCost
+        self.currency = currency
+        self.currencySymbol = currencySymbol
+        self.totalInputTokens = totalInputTokens
+        self.totalOutputTokens = totalOutputTokens
+        self.totalCachedTokens = totalCachedTokens
+        self.modelCount = modelCount
+        self.daily = daily.sorted { $0.day < $1.day }
+        self.startDate = startDate
+        self.endDate = endDate
+        self.updatedAt = updatedAt
+    }
+
+    public func toUsageSnapshot() -> UsageSnapshot {
+        // Negative totalCost means a refund/credit adjustment; clamp to zero rather than
+        // showing a confusing negative amount in the menu bar.
+        let spendText = if self.totalCost > 0 {
+            "\(self.currencySymbol)\(String(format: "%.4f", self.totalCost)) this month"
+        } else {
+            "\(self.currencySymbol)0.0000 this month"
+        }
+        let identity = ProviderIdentitySnapshot(
+            providerID: .mistral,
+            accountEmail: nil,
+            accountOrganization: nil,
+            loginMethod: "API spend: \(spendText)")
+        return UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            providerCost: nil,
+            mistralUsage: self,
+            updatedAt: self.updatedAt,
+            identity: identity)
+    }
+
+    public func toCostUsageTokenSnapshot(historyDays: Int = 30) -> CostUsageTokenSnapshot {
+        let clampedHistoryDays = max(1, min(365, historyDays))
+        let selected = self.daily
+        let entries = selected.map { bucket in
+            let modelBreakdowns = bucket.models.map {
+                CostUsageDailyReport.ModelBreakdown(
+                    modelName: $0.name,
+                    costUSD: max($0.cost, 0),
+                    totalTokens: $0.totalTokens)
+            }
+            let modelsUsed = bucket.models.map(\.name)
+            return CostUsageDailyReport.Entry(
+                date: bucket.day,
+                inputTokens: bucket.inputTokens,
+                outputTokens: bucket.outputTokens,
+                cacheReadTokens: bucket.cachedTokens,
+                cacheCreationTokens: nil,
+                totalTokens: bucket.totalTokens,
+                costUSD: max(bucket.cost, 0),
+                modelsUsed: modelsUsed.isEmpty ? nil : modelsUsed,
+                modelBreakdowns: modelBreakdowns.isEmpty ? nil : modelBreakdowns)
+        }
+        let latest = selected.last
+        let totalCost = max(self.totalCost, 0)
+        let totalTokens = selected.isEmpty
+            ? self.totalInputTokens + self.totalCachedTokens + self.totalOutputTokens
+            : selected.reduce(0) { $0 + $1.totalTokens }
+        let tokens = totalTokens > 0 ? totalTokens : nil
+        return CostUsageTokenSnapshot(
+            sessionTokens: latest?.totalTokens,
+            sessionCostUSD: latest.map { max($0.cost, 0) },
+            last30DaysTokens: tokens,
+            last30DaysCostUSD: totalCost,
+            currencyCode: self.currency,
+            historyDays: selected.isEmpty ? clampedHistoryDays : max(1, min(365, selected.count)),
+            historyLabel: "This month",
+            daily: entries,
+            updatedAt: self.updatedAt)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Mistral/MistralProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Mistral/MistralProviderDescriptor.swift
new file mode 100644
index 0000000000..9c28175991
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Mistral/MistralProviderDescriptor.swift
@@ -0,0 +1,175 @@
+import Foundation
+
+public enum MistralProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .mistral,
+            metadata: ProviderMetadata(
+                id: .mistral,
+                displayName: "Mistral",
+                sessionLabel: "Monthly",
+                weeklyLabel: "",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "",
+                toggleTitle: "Show Mistral usage",
+                cliName: "mistral",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                browserCookieOrder: ProviderBrowserCookieDefaults.defaultImportOrder,
+                dashboardURL: "https://admin.mistral.ai/organization/usage",
+                statusPageURL: nil,
+                statusLinkURL: "https://status.mistral.ai"),
+            branding: ProviderBranding(
+                iconStyle: .mistral,
+                iconResourceName: "ProviderIcon-mistral",
+                color: ProviderColor(red: 255 / 255, green: 80 / 255, blue: 15 / 255)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: true,
+                noDataMessage: { "Mistral cost history needs a billing web session." }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .web],
+                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [MistralWebFetchStrategy()] })),
+            cli: ProviderCLIConfig(
+                name: "mistral",
+                aliases: ["mistral-ai"],
+                versionDetector: nil))
+    }
+}
+
+struct MistralWebFetchStrategy: ProviderFetchStrategy {
+    let id: String = "mistral.web"
+    let kind: ProviderFetchKind = .web
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        guard context.settings?.mistral?.cookieSource != .off else { return false }
+        return true
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        let cookieSource = context.settings?.mistral?.cookieSource ?? .auto
+        do {
+            let (cookieHeader, csrfToken) = try Self.resolveCookieHeader(context: context, allowCached: true)
+            let usage = try await Self.fetchUsageWithVibe(
+                cookieHeader: cookieHeader,
+                csrfToken: csrfToken,
+                timeout: context.webTimeout)
+            return self.makeResult(
+                usage: usage,
+                sourceLabel: "web")
+        } catch MistralUsageError.invalidCredentials where cookieSource != .manual {
+            #if os(macOS)
+            CookieHeaderCache.clear(provider: .mistral)
+            let (cookieHeader, csrfToken) = try Self.resolveCookieHeader(context: context, allowCached: false)
+            let usage = try await Self.fetchUsageWithVibe(
+                cookieHeader: cookieHeader,
+                csrfToken: csrfToken,
+                timeout: context.webTimeout)
+            return self.makeResult(
+                usage: usage,
+                sourceLabel: "web")
+            #else
+            throw MistralUsageError.invalidCredentials
+            #endif
+        }
+    }
+
+    private static func fetchUsageWithVibe(
+        cookieHeader: String,
+        csrfToken: String?,
+        timeout: TimeInterval) async throws -> UsageSnapshot
+    {
+        let deadline = Date().addingTimeInterval(timeout)
+        let snapshot = try await MistralUsageFetcher.fetchUsage(
+            cookieHeader: cookieHeader,
+            csrfToken: csrfToken,
+            timeout: timeout)
+        let remaining = deadline.timeIntervalSinceNow
+        let vibeResult: MistralUsageFetcher.MistralVibeUsageResult? = if let csrfToken, remaining > 0 {
+            try await Self.fetchOptionalVibeUsage(
+                csrfToken: csrfToken,
+                timeout: min(remaining, 4))
+        } else {
+            nil
+        }
+        return Self.attachVibeWindow(to: snapshot.toUsageSnapshot(), vibeResult: vibeResult)
+    }
+
+    static func fetchOptionalVibeUsage(
+        csrfToken: String,
+        timeout: TimeInterval,
+        transport: ProviderHTTPTransport = ProviderHTTPClient.shared) async throws
+        -> MistralUsageFetcher.MistralVibeUsageResult?
+    {
+        do {
+            return try await MistralUsageFetcher.fetchVibeUsage(
+                csrfToken: csrfToken,
+                timeout: timeout,
+                transport: transport)
+        } catch {
+            if error is CancellationError || (error as? URLError)?.code == .cancelled || Task.isCancelled {
+                throw CancellationError()
+            }
+            return nil
+        }
+    }
+
+    static func attachVibeWindow(
+        to usageSnapshot: UsageSnapshot,
+        vibeResult: MistralUsageFetcher.MistralVibeUsageResult?) -> UsageSnapshot
+    {
+        guard let vibeResult else { return usageSnapshot }
+        let window = RateWindow(
+            usedPercent: vibeResult.usagePercentage,
+            windowMinutes: nil,
+            resetsAt: vibeResult.resetAt,
+            resetDescription: nil)
+        let named = NamedRateWindow(id: "mistral-monthly-plan", title: "Monthly Plan", window: window)
+        let existing = usageSnapshot.extraRateWindows?.filter { $0.id != named.id } ?? []
+        return usageSnapshot.with(extraRateWindows: existing + [named])
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+
+    private static func resolveCookieHeader(
+        context: ProviderFetchContext,
+        allowCached: Bool) throws -> (cookieHeader: String, csrfToken: String?)
+    {
+        if let settings = context.settings?.mistral, settings.cookieSource == .manual {
+            if let header = CookieHeaderNormalizer.normalize(settings.manualCookieHeader) {
+                let pairs = CookieHeaderNormalizer.pairs(from: header)
+                let hasSessionCookie = pairs.contains { $0.name.hasPrefix("ory_session_") }
+                if hasSessionCookie {
+                    let csrfToken = pairs.first { $0.name == "csrftoken" }?.value
+                    return (header, csrfToken)
+                }
+            }
+            throw MistralSettingsError.invalidCookie
+        }
+
+        #if os(macOS)
+        if allowCached,
+           let cached = CookieHeaderCache.load(provider: .mistral),
+           !cached.cookieHeader.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+        {
+            let pairs = CookieHeaderNormalizer.pairs(from: cached.cookieHeader)
+            let csrfToken = pairs.first { $0.name == "csrftoken" }?.value
+            return (cached.cookieHeader, csrfToken)
+        }
+        let session = try MistralCookieImporter.importSession(browserDetection: context.browserDetection)
+        CookieHeaderCache.store(
+            provider: .mistral,
+            cookieHeader: session.cookieHeader,
+            sourceLabel: session.sourceLabel)
+        return (session.cookieHeader, session.csrfToken)
+        #else
+        throw MistralSettingsError.missingCookie
+        #endif
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Mistral/MistralUsageFetcher.swift b/Sources/CodexBarCore/Providers/Mistral/MistralUsageFetcher.swift
new file mode 100644
index 0000000000..0db8b4e09c
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Mistral/MistralUsageFetcher.swift
@@ -0,0 +1,485 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public enum MistralUsageFetcher {
+    private static let baseURL = URL(string: "https://admin.mistral.ai")!
+
+    public struct MistralVibeUsageResult: Equatable, Sendable {
+        public let usagePercentage: Double
+        public let resetAt: Date?
+    }
+
+    public static func fetchUsage(
+        cookieHeader: String,
+        csrfToken: String?,
+        timeout: TimeInterval = 15) async throws -> MistralUsageSnapshot
+    {
+        let now = Date()
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = TimeZone(identifier: "UTC")!
+        let month = calendar.component(.month, from: now)
+        let year = calendar.component(.year, from: now)
+
+        let usagePath = self.baseURL.appendingPathComponent("/api/billing/v2/usage")
+        var components = URLComponents(url: usagePath, resolvingAgainstBaseURL: false)!
+        components.queryItems = [
+            URLQueryItem(name: "month", value: "\(month)"),
+            URLQueryItem(name: "year", value: "\(year)"),
+        ]
+        guard let url = components.url else {
+            throw MistralUsageError.apiError("Failed to construct URL")
+        }
+
+        var request = URLRequest(url: url, timeoutInterval: timeout)
+        request.setValue("*/*", forHTTPHeaderField: "Accept")
+        request.setValue(cookieHeader, forHTTPHeaderField: "Cookie")
+        request.setValue("https://admin.mistral.ai/organization/usage", forHTTPHeaderField: "Referer")
+        request.setValue("https://admin.mistral.ai", forHTTPHeaderField: "Origin")
+        if let csrfToken {
+            request.setValue(csrfToken, forHTTPHeaderField: "X-CSRFTOKEN")
+        }
+
+        let response = try await ProviderHTTPClient.shared.response(for: request)
+        let data = response.data
+
+        switch response.statusCode {
+        case 200:
+            break
+        case 401, 403:
+            throw MistralUsageError.invalidCredentials
+        default:
+            let body = String(data: data.prefix(200), encoding: .utf8) ?? ""
+            throw MistralUsageError.apiError("HTTP \(response.statusCode): \(body)")
+        }
+
+        return try Self.parseResponse(data: data, updatedAt: now)
+    }
+
+    public static func fetchVibeUsage(
+        csrfToken: String,
+        timeout: TimeInterval = 4,
+        transport: ProviderHTTPTransport = ProviderHTTPClient.shared) async throws -> MistralVibeUsageResult
+    {
+        let urlString = "https://console.mistral.ai/api-ui/trpc/billing.vibeUsage?batch=1&input=%7B%220%22%3A%7B%22json%22%3Anull%2C%22meta%22%3A%7B%22values%22%3A%5B%22undefined%22%5D%2C%22v%22%3A1%7D%7D%7D"
+        guard let url = URL(string: urlString) else {
+            throw MistralUsageError.apiError("Failed to construct URL")
+        }
+
+        var request = URLRequest(url: url, timeoutInterval: timeout)
+        // The observed console request sends only csrftoken; keep admin Ory cookies origin-bound.
+        request.httpShouldHandleCookies = false
+        let validatedCSRFToken = try Self.validatedVibeCSRFToken(csrfToken)
+        request.setValue("*/*", forHTTPHeaderField: "Accept")
+        request.setValue("csrftoken=\(validatedCSRFToken)", forHTTPHeaderField: "Cookie")
+        request.setValue(validatedCSRFToken, forHTTPHeaderField: "X-CSRFToken")
+
+        let response = try await transport.response(for: request)
+        let data = response.data
+
+        switch response.statusCode {
+        case 200:
+            break
+        case 401, 403:
+            throw MistralUsageError.invalidCredentials
+        default:
+            let body = String(data: data.prefix(200), encoding: .utf8) ?? ""
+            throw MistralUsageError.apiError("HTTP \(response.statusCode): \(body)")
+        }
+
+        return try Self.parseVibeUsage(data: data)
+    }
+
+    static func parseVibeUsage(data: Data) throws -> MistralVibeUsageResult {
+        let responses: [VibeUsageResponse]
+        do {
+            responses = try JSONDecoder().decode([VibeUsageResponse].self, from: data)
+        } catch {
+            throw MistralUsageError.parseFailed(error.localizedDescription)
+        }
+        guard let json = responses.first?.result.data.json else {
+            throw MistralUsageError.parseFailed("Empty response array")
+        }
+        guard json.usagePercentage.isFinite, (0...100).contains(json.usagePercentage) else {
+            throw MistralUsageError.parseFailed("Invalid usage percentage")
+        }
+        return MistralVibeUsageResult(
+            usagePercentage: json.usagePercentage,
+            resetAt: json.resetAt.flatMap(Self.parseISO8601Date))
+    }
+
+    static func vibeCookieHeader(csrfToken: String) throws -> String {
+        try "csrftoken=\(self.validatedVibeCSRFToken(csrfToken))"
+    }
+
+    private static func validatedVibeCSRFToken(_ csrfToken: String) throws -> String {
+        let token = csrfToken.trimmingCharacters(in: .whitespacesAndNewlines)
+        let forbidden = CharacterSet(charactersIn: ";,\r\n")
+        guard !token.isEmpty, token.rangeOfCharacter(from: forbidden) == nil else {
+            throw MistralUsageError.invalidCredentials
+        }
+        return token
+    }
+
+    private static func parseISO8601Date(_ value: String) -> Date? {
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        if let date = formatter.date(from: value) { return date }
+        formatter.formatOptions = [.withInternetDateTime]
+        return formatter.date(from: value)
+    }
+
+    static func parseResponse(data: Data, updatedAt: Date) throws -> MistralUsageSnapshot {
+        let decoder = JSONDecoder()
+        let billing: MistralBillingResponse
+        do {
+            billing = try decoder.decode(MistralBillingResponse.self, from: data)
+        } catch {
+            throw MistralUsageError.parseFailed(error.localizedDescription)
+        }
+
+        let prices = Self.buildPriceIndex(billing.prices ?? [])
+        var totalCost: Double = 0
+        var totalInput = 0
+        var totalOutput = 0
+        var totalCached = 0
+        var modelCount = 0
+        var daily: [String: DailyAccumulator] = [:]
+
+        // Aggregate completion tokens
+        if let models = billing.completion?.models {
+            for (modelName, modelData) in models {
+                modelCount += 1
+                let (input, output, cached, cost) = Self.aggregateModel(modelData, prices: prices)
+                totalInput += input
+                totalOutput += output
+                totalCached += cached
+                totalCost += cost
+                Self.addDailyEntries(
+                    modelName: modelName,
+                    data: modelData,
+                    prices: prices,
+                    daily: &daily,
+                    countsTokens: true)
+            }
+        }
+
+        // Aggregate OCR, connectors, audio if present
+        for category in [billing.ocr, billing.connectors, billing.audio] {
+            if let models = category?.models {
+                for (modelName, modelData) in models {
+                    let (_, _, _, cost) = Self.aggregateModel(modelData, prices: prices)
+                    totalCost += cost
+                    Self.addDailyEntries(
+                        modelName: modelName,
+                        data: modelData,
+                        prices: prices,
+                        daily: &daily,
+                        countsTokens: false)
+                }
+            }
+        }
+
+        // Aggregate libraries_api (pages + tokens)
+        if let models = billing.librariesApi?.pages?.models {
+            for (modelName, modelData) in models {
+                let (_, _, _, cost) = Self.aggregateModel(modelData, prices: prices)
+                totalCost += cost
+                Self.addDailyEntries(
+                    modelName: modelName,
+                    data: modelData,
+                    prices: prices,
+                    daily: &daily,
+                    countsTokens: false)
+            }
+        }
+        if let models = billing.librariesApi?.tokens?.models {
+            for (modelName, modelData) in models {
+                let (_, _, _, cost) = Self.aggregateModel(modelData, prices: prices)
+                totalCost += cost
+                Self.addDailyEntries(
+                    modelName: modelName,
+                    data: modelData,
+                    prices: prices,
+                    daily: &daily,
+                    countsTokens: true)
+            }
+        }
+
+        // Aggregate fine_tuning (training + storage)
+        for models in [billing.fineTuning?.training, billing.fineTuning?.storage] {
+            if let models {
+                for (modelName, modelData) in models {
+                    let (_, _, _, cost) = Self.aggregateModel(modelData, prices: prices)
+                    totalCost += cost
+                    Self.addDailyEntries(
+                        modelName: modelName,
+                        data: modelData,
+                        prices: prices,
+                        daily: &daily,
+                        countsTokens: false)
+                }
+            }
+        }
+
+        let currency = billing.currency ?? "EUR"
+        let currencySymbol = billing.currencySymbol ?? "€"
+
+        let startDate = billing.startDate.flatMap { Self.parseDate($0) }
+        let endDate = billing.endDate.flatMap { Self.parseDate($0) }
+
+        return MistralUsageSnapshot(
+            totalCost: totalCost,
+            currency: currency,
+            currencySymbol: currencySymbol,
+            totalInputTokens: totalInput,
+            totalOutputTokens: totalOutput,
+            totalCachedTokens: totalCached,
+            modelCount: modelCount,
+            daily: daily.values.map { $0.makeBucket() },
+            startDate: startDate,
+            endDate: endDate,
+            updatedAt: updatedAt)
+    }
+
+    // MARK: - Private Helpers
+
+    private static func buildPriceIndex(_ prices: [MistralPrice]) -> [String: Double] {
+        var index: [String: Double] = [:]
+        for price in prices {
+            guard let metric = price.billingMetric,
+                  let group = price.billingGroup,
+                  let priceStr = price.price,
+                  let value = Double(priceStr)
+            else { continue }
+            let key = "\(metric)::\(group)"
+            index[key] = value
+        }
+        return index
+    }
+
+    private static func aggregateModel(
+        _ data: MistralModelUsageData,
+        prices: [String: Double]) -> (input: Int, output: Int, cached: Int, cost: Double)
+    {
+        var totalInput = 0
+        var totalOutput = 0
+        var totalCached = 0
+        var totalCost: Double = 0
+
+        for entry in data.input ?? [] {
+            let tokens = entry.valuePaid ?? entry.value ?? 0
+            totalInput += tokens
+            if let metric = entry.billingMetric, let group = entry.billingGroup {
+                let pricePerToken = prices["\(metric)::\(group)"] ?? 0
+                totalCost += Double(tokens) * pricePerToken
+            }
+        }
+
+        for entry in data.output ?? [] {
+            let tokens = entry.valuePaid ?? entry.value ?? 0
+            totalOutput += tokens
+            if let metric = entry.billingMetric, let group = entry.billingGroup {
+                let pricePerToken = prices["\(metric)::\(group)"] ?? 0
+                totalCost += Double(tokens) * pricePerToken
+            }
+        }
+
+        for entry in data.cached ?? [] {
+            let tokens = entry.valuePaid ?? entry.value ?? 0
+            totalCached += tokens
+            if let metric = entry.billingMetric, let group = entry.billingGroup {
+                let pricePerToken = prices["\(metric)::\(group)"] ?? 0
+                totalCost += Double(tokens) * pricePerToken
+            }
+        }
+
+        return (totalInput, totalOutput, totalCached, totalCost)
+    }
+
+    private static func addDailyEntries(
+        modelName: String,
+        data: MistralModelUsageData,
+        prices: [String: Double],
+        daily: inout [String: DailyAccumulator],
+        countsTokens: Bool)
+    {
+        self.addDaily(
+            entries: data.input ?? [],
+            context: DailyEntryContext(
+                kind: .input,
+                modelName: modelName,
+                prices: prices,
+                countsTokens: countsTokens),
+            daily: &daily)
+        self.addDaily(
+            entries: data.output ?? [],
+            context: DailyEntryContext(
+                kind: .output,
+                modelName: modelName,
+                prices: prices,
+                countsTokens: countsTokens),
+            daily: &daily)
+        self.addDaily(
+            entries: data.cached ?? [],
+            context: DailyEntryContext(
+                kind: .cached,
+                modelName: modelName,
+                prices: prices,
+                countsTokens: countsTokens),
+            daily: &daily)
+    }
+
+    fileprivate enum TokenKind {
+        case input
+        case cached
+        case output
+    }
+
+    private static func addDaily(
+        entries: [MistralUsageEntry],
+        context: DailyEntryContext,
+        daily: inout [String: DailyAccumulator])
+    {
+        for entry in entries {
+            guard let day = dayKey(from: entry.timestamp) else { continue }
+            let units = entry.valuePaid ?? entry.value ?? 0
+            let cost = Self.cost(for: entry, units: units, prices: context.prices)
+            var accumulator = daily[day] ?? DailyAccumulator(day: day)
+            accumulator.add(
+                modelName: Self.displayModelName(context.modelName, entry: entry),
+                kind: context.kind,
+                units: units,
+                cost: cost,
+                countsTokens: context.countsTokens)
+            daily[day] = accumulator
+        }
+    }
+
+    private static func cost(for entry: MistralUsageEntry, units: Int, prices: [String: Double]) -> Double {
+        guard let metric = entry.billingMetric, let group = entry.billingGroup else { return 0 }
+        return Double(units) * (prices["\(metric)::\(group)"] ?? 0)
+    }
+
+    private static func displayModelName(_ raw: String, entry: MistralUsageEntry) -> String {
+        if let display = entry.billingDisplayName?.trimmingCharacters(in: .whitespacesAndNewlines),
+           !display.isEmpty
+        {
+            return display
+        }
+        return raw.split(separator: "::").first.map(String.init) ?? raw
+    }
+
+    private static func dayKey(from timestamp: String?) -> String? {
+        guard let trimmed = timestamp?.trimmingCharacters(in: .whitespacesAndNewlines), !trimmed.isEmpty else {
+            return nil
+        }
+        if trimmed.count >= 10 {
+            return String(trimmed.prefix(10))
+        }
+        return nil
+    }
+
+    private static func parseDate(_ string: String) -> Date? {
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        if let date = formatter.date(from: string) { return date }
+        formatter.formatOptions = [.withInternetDateTime]
+        return formatter.date(from: string)
+    }
+}
+
+private struct DailyEntryContext {
+    let kind: MistralUsageFetcher.TokenKind
+    let modelName: String
+    let prices: [String: Double]
+    let countsTokens: Bool
+}
+
+private struct DailyAccumulator {
+    let day: String
+    var cost: Double = 0
+    var inputTokens = 0
+    var cachedTokens = 0
+    var outputTokens = 0
+    var models: [String: ModelAccumulator] = [:]
+
+    mutating func add(
+        modelName: String,
+        kind: MistralUsageFetcher.TokenKind,
+        units: Int,
+        cost: Double,
+        countsTokens: Bool)
+    {
+        self.cost += cost
+        var model = self.models[modelName] ?? ModelAccumulator(name: modelName)
+        model.cost += cost
+        guard countsTokens else {
+            self.models[modelName] = model
+            return
+        }
+        switch kind {
+        case .input:
+            self.inputTokens += units
+            model.inputTokens += units
+        case .cached:
+            self.cachedTokens += units
+            model.cachedTokens += units
+        case .output:
+            self.outputTokens += units
+            model.outputTokens += units
+        }
+        self.models[modelName] = model
+    }
+
+    func makeBucket() -> MistralDailyUsageBucket {
+        MistralDailyUsageBucket(
+            day: self.day,
+            cost: self.cost,
+            inputTokens: self.inputTokens,
+            cachedTokens: self.cachedTokens,
+            outputTokens: self.outputTokens,
+            models: self.models.values
+                .map { $0.makeBreakdown() }
+                .sorted {
+                    if $0.totalTokens == $1.totalTokens { return $0.name < $1.name }
+                    return $0.totalTokens > $1.totalTokens
+                })
+    }
+}
+
+private struct ModelAccumulator {
+    let name: String
+    var cost: Double = 0
+    var inputTokens = 0
+    var cachedTokens = 0
+    var outputTokens = 0
+
+    func makeBreakdown() -> MistralDailyUsageBucket.ModelBreakdown {
+        MistralDailyUsageBucket.ModelBreakdown(
+            name: self.name,
+            cost: self.cost,
+            inputTokens: self.inputTokens,
+            cachedTokens: self.cachedTokens,
+            outputTokens: self.outputTokens)
+    }
+}
+
+private struct VibeUsageResponse: Decodable {
+    let result: VibeResult
+    struct VibeResult: Decodable {
+        let data: VibeData
+        struct VibeData: Decodable {
+            let json: VibeJson
+            struct VibeJson: Decodable {
+                let usagePercentage: Double
+                let resetAt: String?
+                enum CodingKeys: String, CodingKey {
+                    case usagePercentage = "usage_percentage"
+                    case resetAt = "reset_at"
+                }
+            }
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Moonshot/MoonshotProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Moonshot/MoonshotProviderDescriptor.swift
new file mode 100644
index 0000000000..a5552e2a8d
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Moonshot/MoonshotProviderDescriptor.swift
@@ -0,0 +1,49 @@
+import Foundation
+
+public enum MoonshotProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .moonshot,
+            metadata: ProviderMetadata(
+                id: .moonshot,
+                displayName: "Moonshot / Kimi API",
+                sessionLabel: "Balance",
+                weeklyLabel: "Balance",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "",
+                toggleTitle: "Show Moonshot / Kimi API balance",
+                cliName: "moonshot",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                browserCookieOrder: nil,
+                dashboardURL: "https://platform.moonshot.ai/console/account",
+                statusPageURL: nil),
+            branding: ProviderBranding(
+                iconStyle: .kimi,
+                iconResourceName: "ProviderIcon-kimi",
+                color: ProviderColor(red: 32 / 255, green: 93 / 255, blue: 235 / 255)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "Moonshot / Kimi API cost summary is not available." }),
+            fetchPlan: .apiToken(
+                strategyID: "moonshot.api",
+                resolveToken: { ProviderTokenResolver.moonshotToken(environment: $0) },
+                missingCredentialsError: { MoonshotUsageError.missingCredentials },
+                loadUsage: { apiKey, context in
+                    let region =
+                        context.settings?.moonshot?.region ?? MoonshotSettingsReader.region(environment: context.env)
+                    return try await MoonshotUsageFetcher.fetchUsage(
+                        apiKey: apiKey,
+                        region: region).toUsageSnapshot()
+                }),
+            cli: ProviderCLIConfig(
+                name: "moonshot",
+                aliases: [],
+                versionDetector: nil))
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Moonshot/MoonshotRegion.swift b/Sources/CodexBarCore/Providers/Moonshot/MoonshotRegion.swift
new file mode 100644
index 0000000000..420e3ff1e7
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Moonshot/MoonshotRegion.swift
@@ -0,0 +1,30 @@
+import Foundation
+
+public enum MoonshotRegion: String, CaseIterable, Sendable {
+    case international
+    case china
+
+    private static let balancePath = "v1/users/me/balance"
+
+    public var displayName: String {
+        switch self {
+        case .international:
+            "International (api.moonshot.ai)"
+        case .china:
+            "China (api.moonshot.cn)"
+        }
+    }
+
+    public var apiBaseURLString: String {
+        switch self {
+        case .international:
+            "https://api.moonshot.ai"
+        case .china:
+            "https://api.moonshot.cn"
+        }
+    }
+
+    public var balanceURL: URL {
+        URL(string: self.apiBaseURLString)!.appendingPathComponent(Self.balancePath)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Moonshot/MoonshotSettingsReader.swift b/Sources/CodexBarCore/Providers/Moonshot/MoonshotSettingsReader.swift
new file mode 100644
index 0000000000..b01db6eca5
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Moonshot/MoonshotSettingsReader.swift
@@ -0,0 +1,47 @@
+import Foundation
+
+public struct MoonshotSettingsReader: Sendable {
+    public static let apiKeyEnvironmentKeys = [
+        "MOONSHOT_API_KEY",
+        "MOONSHOT_KEY",
+    ]
+    public static let regionEnvironmentKey = "MOONSHOT_REGION"
+
+    public static func apiKey(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        for key in self.apiKeyEnvironmentKeys {
+            guard let raw = environment[key]?.trimmingCharacters(in: .whitespacesAndNewlines),
+                  !raw.isEmpty
+            else {
+                continue
+            }
+            let cleaned = Self.cleaned(raw)
+            if !cleaned.isEmpty {
+                return cleaned
+            }
+        }
+
+        return nil
+    }
+
+    public static func region(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> MoonshotRegion
+    {
+        guard let raw = environment[self.regionEnvironmentKey] else {
+            return .international
+        }
+        let cleaned = Self.cleaned(raw).lowercased()
+        return MoonshotRegion(rawValue: cleaned) ?? .international
+    }
+
+    private static func cleaned(_ raw: String) -> String {
+        var value = raw
+        if (value.hasPrefix("\"") && value.hasSuffix("\""))
+            || (value.hasPrefix("'") && value.hasSuffix("'"))
+        {
+            value = String(value.dropFirst().dropLast())
+        }
+        return value.trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Moonshot/MoonshotUsageFetcher.swift b/Sources/CodexBarCore/Providers/Moonshot/MoonshotUsageFetcher.swift
new file mode 100644
index 0000000000..04a137d0d5
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Moonshot/MoonshotUsageFetcher.swift
@@ -0,0 +1,161 @@
+import Foundation
+
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public struct MoonshotUsageSnapshot: Sendable {
+    public let summary: MoonshotUsageSummary
+
+    public init(summary: MoonshotUsageSummary) {
+        self.summary = summary
+    }
+
+    public func toUsageSnapshot() -> UsageSnapshot {
+        self.summary.toUsageSnapshot()
+    }
+}
+
+public struct MoonshotUsageSummary: Sendable {
+    public let availableBalance: Double
+    public let voucherBalance: Double
+    public let cashBalance: Double
+    public let updatedAt: Date
+
+    public init(
+        availableBalance: Double, voucherBalance: Double, cashBalance: Double, updatedAt: Date)
+    {
+        self.availableBalance = availableBalance
+        self.voucherBalance = voucherBalance
+        self.cashBalance = cashBalance
+        self.updatedAt = updatedAt
+    }
+
+    public func toUsageSnapshot() -> UsageSnapshot {
+        let balance = UsageFormatter.usdString(self.availableBalance)
+        let loginMethod: String
+        if self.cashBalance < 0 {
+            let deficit = UsageFormatter.usdString(abs(self.cashBalance))
+            loginMethod = "Balance: \(balance) · \(deficit) in deficit"
+        } else {
+            loginMethod = "Balance: \(balance)"
+        }
+        let identity = ProviderIdentitySnapshot(
+            providerID: .moonshot,
+            accountEmail: nil,
+            accountOrganization: nil,
+            loginMethod: loginMethod)
+        return UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            tertiary: nil,
+            providerCost: nil,
+            updatedAt: self.updatedAt,
+            identity: identity)
+    }
+}
+
+private struct MoonshotBalanceResponse: Decodable {
+    let code: Int
+    let data: MoonshotBalanceData
+    let scode: String
+    let status: Bool
+}
+
+private struct MoonshotBalanceData: Decodable {
+    let availableBalance: Double
+    let voucherBalance: Double
+    let cashBalance: Double
+
+    private enum CodingKeys: String, CodingKey {
+        case availableBalance = "available_balance"
+        case voucherBalance = "voucher_balance"
+        case cashBalance = "cash_balance"
+    }
+}
+
+public enum MoonshotUsageError: LocalizedError, Sendable {
+    case missingCredentials
+    case networkError(String)
+    case apiError(String)
+    case parseFailed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingCredentials:
+            "Missing Moonshot API key."
+        case let .networkError(message):
+            "Moonshot network error: \(message)"
+        case let .apiError(message):
+            "Moonshot API error: \(message)"
+        case let .parseFailed(message):
+            "Failed to parse Moonshot response: \(message)"
+        }
+    }
+}
+
+public struct MoonshotUsageFetcher: Sendable {
+    private static let log = CodexBarLog.logger(LogCategories.moonshotUsage)
+    private static let timeoutSeconds: TimeInterval = 15
+
+    public static func fetchUsage(
+        apiKey: String,
+        region: MoonshotRegion = .international,
+        session transport: any ProviderHTTPTransport = ProviderHTTPClient.shared) async throws -> MoonshotUsageSnapshot
+    {
+        let cleaned = apiKey.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !cleaned.isEmpty else {
+            throw MoonshotUsageError.missingCredentials
+        }
+
+        var request = URLRequest(url: self.resolveBalanceURL(region: region))
+        request.httpMethod = "GET"
+        request.setValue("Bearer \(cleaned)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        request.timeoutInterval = Self.timeoutSeconds
+
+        let response: ProviderHTTPResponse
+        do {
+            response = try await transport.response(for: request)
+        } catch let error as URLError where error.code == .badServerResponse {
+            throw MoonshotUsageError.networkError("Invalid response")
+        } catch {
+            throw error
+        }
+
+        guard response.statusCode == 200 else {
+            Self.log.error("Moonshot API returned HTTP \(response.statusCode)")
+            throw MoonshotUsageError.apiError("HTTP \(response.statusCode)")
+        }
+
+        let summary = try self.parseSummary(data: response.data)
+        return MoonshotUsageSnapshot(summary: summary)
+    }
+
+    public static func resolveBalanceURL(region: MoonshotRegion) -> URL {
+        region.balanceURL
+    }
+
+    static func _parseSummaryForTesting(_ data: Data) throws -> MoonshotUsageSummary {
+        try self.parseSummary(data: data)
+    }
+
+    private static func parseSummary(data: Data) throws -> MoonshotUsageSummary {
+        let response: MoonshotBalanceResponse
+        do {
+            response = try JSONDecoder().decode(MoonshotBalanceResponse.self, from: data)
+        } catch {
+            throw MoonshotUsageError.parseFailed(error.localizedDescription)
+        }
+
+        guard response.code == 0, response.status else {
+            throw MoonshotUsageError.apiError("code \(response.code), scode \(response.scode)")
+        }
+
+        return MoonshotUsageSummary(
+            availableBalance: response.data.availableBalance,
+            voucherBalance: response.data.voucherBalance,
+            cashBalance: response.data.cashBalance,
+            updatedAt: Date())
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Ollama/OllamaProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Ollama/OllamaProviderDescriptor.swift
index 4702609fae..16097ac553 100644
--- a/Sources/CodexBarCore/Providers/Ollama/OllamaProviderDescriptor.swift
+++ b/Sources/CodexBarCore/Providers/Ollama/OllamaProviderDescriptor.swift
@@ -1,9 +1,8 @@
-import CodexBarMacroSupport
 import Foundation
 
-@ProviderDescriptorRegistration
-@ProviderDescriptorDefinition
 public enum OllamaProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
     static func makeDescriptor() -> ProviderDescriptor {
         ProviderDescriptor(
             id: .ollama,
@@ -32,12 +31,32 @@ public enum OllamaProviderDescriptor {
                 supportsTokenCost: false,
                 noDataMessage: { "Ollama cost summary is not supported." }),
             fetchPlan: ProviderFetchPlan(
-                sourceModes: [.auto, .web],
-                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [OllamaStatusFetchStrategy()] })),
+                sourceModes: [.auto, .web, .api],
+                pipeline: ProviderFetchPipeline(resolveStrategies: self.resolveStrategies)),
             cli: ProviderCLIConfig(
                 name: "ollama",
                 versionDetector: nil))
     }
+
+    private static func resolveStrategies(context: ProviderFetchContext) async -> [any ProviderFetchStrategy] {
+        switch context.sourceMode {
+        case .web:
+            return [OllamaStatusFetchStrategy()]
+        case .api:
+            return [OllamaAPIFetchStrategy()]
+        case .cli, .oauth:
+            return []
+        case .auto:
+            break
+        }
+        if context.settings?.ollama?.cookieSource == .off {
+            return [OllamaAPIFetchStrategy()]
+        }
+        if ProviderTokenResolver.ollamaToken(environment: context.env) != nil {
+            return [OllamaStatusFetchStrategy(), OllamaAPIFetchStrategy()]
+        }
+        return [OllamaStatusFetchStrategy()]
+    }
 }
 
 struct OllamaStatusFetchStrategy: ProviderFetchStrategy {
@@ -65,8 +84,9 @@ struct OllamaStatusFetchStrategy: ProviderFetchStrategy {
             sourceLabel: "web")
     }
 
-    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
-        false
+    func shouldFallback(on _: Error, context: ProviderFetchContext) -> Bool {
+        context.sourceMode == .auto
+            && ProviderTokenResolver.ollamaToken(environment: context.env) != nil
     }
 
     private static func manualCookieHeader(from context: ProviderFetchContext) -> String? {
@@ -74,3 +94,30 @@ struct OllamaStatusFetchStrategy: ProviderFetchStrategy {
         return CookieHeaderNormalizer.normalize(context.settings?.ollama?.manualCookieHeader)
     }
 }
+
+struct OllamaAPIFetchStrategy: ProviderFetchStrategy {
+    let id: String = "ollama.api"
+    let kind: ProviderFetchKind = .apiToken
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        Self.resolveToken(environment: context.env) != nil
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        guard let apiKey = Self.resolveToken(environment: context.env) else {
+            throw OllamaUsageError.missingAPIKey
+        }
+        let snapshot = try await OllamaAPIUsageFetcher.fetchUsage(apiKey: apiKey)
+        return self.makeResult(
+            usage: snapshot.toUsageSnapshot(),
+            sourceLabel: "api")
+    }
+
+    func shouldFallback(on _: Error, context: ProviderFetchContext) -> Bool {
+        context.sourceMode == .auto
+    }
+
+    private static func resolveToken(environment: [String: String]) -> String? {
+        ProviderTokenResolver.ollamaToken(environment: environment)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Ollama/OllamaUsageFetcher.swift b/Sources/CodexBarCore/Providers/Ollama/OllamaUsageFetcher.swift
index 9e5c4b0689..d3aaea9763 100644
--- a/Sources/CodexBarCore/Providers/Ollama/OllamaUsageFetcher.swift
+++ b/Sources/CodexBarCore/Providers/Ollama/OllamaUsageFetcher.swift
@@ -9,6 +9,7 @@ import SweetCookieKit
 
 private let ollamaSessionCookieNames: Set<String> = [
     "session",
+    "__Secure-session",
     "ollama_session",
     "__Host-ollama_session",
     "__Secure-next-auth.session-token",
@@ -29,18 +30,24 @@ private func hasRecognizedOllamaSessionCookie(in header: String) -> Bool {
 }
 
 public enum OllamaUsageError: LocalizedError, Sendable {
+    case missingAPIKey
     case notLoggedIn
     case invalidCredentials
+    case apiUnauthorized
     case parseFailed(String)
     case networkError(String)
     case noSessionCookie
 
     public var errorDescription: String? {
         switch self {
+        case .missingAPIKey:
+            "Missing Ollama API key. Set apiKey in ~/.codexbar/config.json or OLLAMA_API_KEY."
         case .notLoggedIn:
             "Not logged in to Ollama. Please log in via ollama.com/settings."
         case .invalidCredentials:
             "Ollama session cookie expired. Please log in again."
+        case .apiUnauthorized:
+            "Ollama API key is invalid or expired."
         case let .parseFailed(message):
             "Could not parse Ollama usage: \(message)"
         case let .networkError(message):
@@ -59,6 +66,7 @@ public enum OllamaCookieImporter {
     private static let cookieClient = BrowserCookieClient()
     private static let cookieDomains = ["ollama.com", "www.ollama.com"]
     static let defaultPreferredBrowsers: [Browser] = [.chrome]
+    static let defaultAllowFallbackBrowsers = true
 
     public struct SessionInfo: Sendable {
         public let cookies: [HTTPCookie]
@@ -199,7 +207,7 @@ public enum OllamaCookieImporter {
         for browserSource in browserSources {
             do {
                 let query = BrowserCookieQuery(domains: self.cookieDomains)
-                let sources = try Self.cookieClient.records(
+                let sources = try Self.cookieClient.codexBarRecords(
                     matching: query,
                     in: browserSource,
                     logger: logger)
@@ -228,12 +236,12 @@ public struct OllamaUsageFetcher: Sendable {
     private static let settingsURL = URL(string: "https://ollama.com/settings")!
     @MainActor private static var recentDumps: [String] = []
 
-    private struct CookieCandidate: Sendable {
+    private struct CookieCandidate {
         let cookieHeader: String
         let sourceLabel: String
     }
 
-    enum RetryableParseFailure: Error, Sendable {
+    enum RetryableParseFailure: Error {
         case missingUsageData
     }
 
@@ -368,7 +376,11 @@ public struct OllamaUsageFetcher: Sendable {
             return [CookieCandidate(cookieHeader: manualHeader, sourceLabel: "manual cookie header")]
         }
         #if os(macOS)
-        let sessions = try OllamaCookieImporter.importSessions(browserDetection: self.browserDetection, logger: logger)
+        let sessions = try OllamaCookieImporter.importSessions(
+            browserDetection: self.browserDetection,
+            preferredBrowsers: OllamaCookieImporter.defaultPreferredBrowsers,
+            allowFallbackBrowsers: OllamaCookieImporter.defaultAllowFallbackBrowsers,
+            logger: logger)
         return sessions.map { session in
             CookieCandidate(cookieHeader: session.cookieHeader, sourceLabel: session.sourceLabel)
         }
@@ -450,7 +462,11 @@ public struct OllamaUsageFetcher: Sendable {
             return manualHeader
         }
         #if os(macOS)
-        let session = try OllamaCookieImporter.importSession(browserDetection: self.browserDetection, logger: logger)
+        let session = try OllamaCookieImporter.importSession(
+            browserDetection: self.browserDetection,
+            preferredBrowsers: OllamaCookieImporter.defaultPreferredBrowsers,
+            allowFallbackBrowsers: OllamaCookieImporter.defaultAllowFallbackBrowsers,
+            logger: logger)
         logger?("[ollama] Using cookies from \(session.sourceLabel)")
         return session.cookieHeader
         #else
@@ -508,13 +524,10 @@ public struct OllamaUsageFetcher: Sendable {
         request.setValue(Self.settingsURL.absoluteString, forHTTPHeaderField: "referer")
 
         let session = self.makeURLSession(diagnostics)
-        let (data, response) = try await session.data(for: request)
-        guard let httpResponse = response as? HTTPURLResponse else {
-            throw OllamaUsageError.networkError("Invalid response")
-        }
+        let httpResponse = try await session.response(for: request)
         let responseInfo = ResponseInfo(
             statusCode: httpResponse.statusCode,
-            url: httpResponse.url?.absoluteString ?? "unknown")
+            url: httpResponse.response.url?.absoluteString ?? "unknown")
 
         guard httpResponse.statusCode == 200 else {
             if httpResponse.statusCode == 401 || httpResponse.statusCode == 403 {
@@ -523,7 +536,7 @@ public struct OllamaUsageFetcher: Sendable {
             throw OllamaUsageError.networkError("HTTP \(httpResponse.statusCode)")
         }
 
-        let html = String(data: data, encoding: .utf8) ?? ""
+        let html = String(data: httpResponse.data, encoding: .utf8) ?? ""
         return (html, responseInfo)
     }
 
@@ -568,7 +581,7 @@ public struct OllamaUsageFetcher: Sendable {
         }
     }
 
-    private struct ResponseInfo: Sendable {
+    private struct ResponseInfo {
         let statusCode: Int
         let url: String
     }
@@ -607,8 +620,123 @@ public struct OllamaUsageFetcher: Sendable {
     }
 
     static func shouldAttachCookie(to url: URL?) -> Bool {
+        guard url?.scheme?.lowercased() == "https" else { return false }
         guard let host = url?.host?.lowercased() else { return false }
         if host == "ollama.com" || host == "www.ollama.com" { return true }
         return host.hasSuffix(".ollama.com")
     }
 }
+
+public struct OllamaAPISettingsReader: Sendable {
+    public static let apiKeyEnvironmentKeys = [
+        "OLLAMA_API_KEY",
+        "OLLAMA_KEY",
+    ]
+
+    public static func apiKey(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        for key in self.apiKeyEnvironmentKeys {
+            guard let value = self.cleaned(environment[key]), !value.isEmpty else { continue }
+            return value
+        }
+        return nil
+    }
+
+    private static func cleaned(_ raw: String?) -> String? {
+        guard var value = raw?.trimmingCharacters(in: .whitespacesAndNewlines),
+              !value.isEmpty
+        else {
+            return nil
+        }
+        if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
+            (value.hasPrefix("'") && value.hasSuffix("'"))
+        {
+            value = String(value.dropFirst().dropLast())
+        }
+        return value.trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+}
+
+public struct OllamaAPIUsageSnapshot: Sendable {
+    public let modelCount: Int
+    public let updatedAt: Date
+
+    public init(modelCount: Int, updatedAt: Date) {
+        self.modelCount = modelCount
+        self.updatedAt = updatedAt
+    }
+
+    public func toUsageSnapshot() -> UsageSnapshot {
+        UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            tertiary: nil,
+            providerCost: nil,
+            updatedAt: self.updatedAt,
+            identity: ProviderIdentitySnapshot(
+                providerID: .ollama,
+                accountEmail: nil,
+                accountOrganization: nil,
+                loginMethod: "API key"))
+    }
+}
+
+public enum OllamaAPIUsageFetcher {
+    public static let tagsURL = URL(string: "https://ollama.com/api/tags")!
+    private static let timeoutSeconds: TimeInterval = 20
+
+    public static func fetchUsage(
+        apiKey: String,
+        tagsURL: URL = Self.tagsURL,
+        transport: any ProviderHTTPTransport = ProviderHTTPClient.shared,
+        now: Date = Date()) async throws -> OllamaAPIUsageSnapshot
+    {
+        let trimmed = apiKey.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else {
+            throw OllamaUsageError.missingAPIKey
+        }
+
+        var request = URLRequest(url: tagsURL)
+        request.httpMethod = "GET"
+        request.timeoutInterval = Self.timeoutSeconds
+        request.setValue("Bearer \(trimmed)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        request.setValue("CodexBar/1.0", forHTTPHeaderField: "User-Agent")
+
+        let response: ProviderHTTPResponse
+        do {
+            response = try await transport.response(for: request)
+        } catch {
+            throw OllamaUsageError.networkError(error.localizedDescription)
+        }
+
+        switch response.statusCode {
+        case 200:
+            return try Self.parseTags(data: response.data, now: now)
+        case 401, 403:
+            throw OllamaUsageError.apiUnauthorized
+        default:
+            throw OllamaUsageError.networkError("HTTP \(response.statusCode)")
+        }
+    }
+
+    static func _parseTagsForTesting(_ data: Data, now: Date = Date()) throws -> OllamaAPIUsageSnapshot {
+        try self.parseTags(data: data, now: now)
+    }
+
+    private static func parseTags(data: Data, now: Date) throws -> OllamaAPIUsageSnapshot {
+        do {
+            let response = try JSONDecoder().decode(TagsResponse.self, from: data)
+            return OllamaAPIUsageSnapshot(modelCount: response.models.count, updatedAt: now)
+        } catch {
+            throw OllamaUsageError.parseFailed(error.localizedDescription)
+        }
+    }
+
+    private struct TagsResponse: Decodable {
+        let models: [Model]
+    }
+
+    private struct Model: Decodable {}
+}
diff --git a/Sources/CodexBarCore/Providers/Ollama/OllamaUsageParser.swift b/Sources/CodexBarCore/Providers/Ollama/OllamaUsageParser.swift
index f93f358649..53d3cf51ff 100644
--- a/Sources/CodexBarCore/Providers/Ollama/OllamaUsageParser.swift
+++ b/Sources/CodexBarCore/Providers/Ollama/OllamaUsageParser.swift
@@ -2,13 +2,14 @@ import Foundation
 
 enum OllamaUsageParser {
     private static let primaryUsageLabels = ["Session usage", "Hourly usage"]
+    private static let usageLabels = primaryUsageLabels + ["Weekly usage"]
 
-    enum ParseFailure: Sendable, Equatable {
+    enum ParseFailure: Equatable {
         case notLoggedIn
         case missingUsageData
     }
 
-    enum ClassifiedParseResult: Sendable {
+    enum ClassifiedParseResult {
         case success(OllamaUsageSnapshot)
         case failure(ParseFailure)
     }
@@ -44,12 +45,14 @@ enum OllamaUsageParser {
             weeklyUsedPercent: weekly?.usedPercent,
             sessionResetsAt: session?.resetsAt,
             weeklyResetsAt: weekly?.resetsAt,
+            sessionWindowMinutes: session?.windowMinutes,
             updatedAt: now))
     }
 
-    private struct UsageBlock: Sendable {
+    private struct UsageBlock {
         let usedPercent: Double
         let resetsAt: Date?
+        let windowMinutes: Int?
     }
 
     private static func parsePlanName(_ html: String) -> String? {
@@ -72,11 +75,15 @@ enum OllamaUsageParser {
     private static func parseUsageBlock(label: String, html: String) -> UsageBlock? {
         guard let labelRange = html.range(of: label) else { return nil }
         let tail = String(html[labelRange.upperBound...])
-        let window = String(tail.prefix(800))
+        let window = self.usageBlockWindow(after: label, in: tail)
 
         guard let usedPercent = self.parsePercent(in: window) else { return nil }
         let resetsAt = self.parseISODate(in: window)
-        return UsageBlock(usedPercent: usedPercent, resetsAt: resetsAt)
+        let windowMinutes = label == "Session usage" ? 5 * 60 : nil
+        return UsageBlock(
+            usedPercent: usedPercent,
+            resetsAt: resetsAt,
+            windowMinutes: windowMinutes)
     }
 
     private static func parseUsageBlock(labels: [String], html: String) -> UsageBlock? {
@@ -88,6 +95,16 @@ enum OllamaUsageParser {
         return nil
     }
 
+    private static func usageBlockWindow(after label: String, in tail: String) -> String {
+        let maxLength = 4000
+        let boundary = self.usageLabels
+            .filter { $0 != label }
+            .compactMap { tail.range(of: $0)?.lowerBound }
+            .min()
+        let bounded = boundary.map { String(tail[..<$0]) } ?? String(tail.prefix(maxLength))
+        return String(bounded.prefix(maxLength))
+    }
+
     private static func parsePercent(in text: String) -> Double? {
         let usedPattern = #"([0-9]+(?:\.[0-9]+)?)\s*%\s*used"#
         if let raw = self.firstCapture(in: text, pattern: usedPattern, options: [.caseInsensitive]) {
diff --git a/Sources/CodexBarCore/Providers/Ollama/OllamaUsageSnapshot.swift b/Sources/CodexBarCore/Providers/Ollama/OllamaUsageSnapshot.swift
index 002f78d817..d3c7e32739 100644
--- a/Sources/CodexBarCore/Providers/Ollama/OllamaUsageSnapshot.swift
+++ b/Sources/CodexBarCore/Providers/Ollama/OllamaUsageSnapshot.swift
@@ -7,6 +7,7 @@ public struct OllamaUsageSnapshot: Sendable {
     public let weeklyUsedPercent: Double?
     public let sessionResetsAt: Date?
     public let weeklyResetsAt: Date?
+    public let sessionWindowMinutes: Int?
     public let updatedAt: Date
 
     public init(
@@ -16,6 +17,7 @@ public struct OllamaUsageSnapshot: Sendable {
         weeklyUsedPercent: Double?,
         sessionResetsAt: Date?,
         weeklyResetsAt: Date?,
+        sessionWindowMinutes: Int? = nil,
         updatedAt: Date)
     {
         self.planName = planName
@@ -24,16 +26,17 @@ public struct OllamaUsageSnapshot: Sendable {
         self.weeklyUsedPercent = weeklyUsedPercent
         self.sessionResetsAt = sessionResetsAt
         self.weeklyResetsAt = weeklyResetsAt
+        self.sessionWindowMinutes = sessionWindowMinutes
         self.updatedAt = updatedAt
     }
 }
 
 extension OllamaUsageSnapshot {
     public func toUsageSnapshot() -> UsageSnapshot {
-        let sessionWindow = self.makeWindow(
+        let sessionWindow = self.makeSessionWindow(
             usedPercent: self.sessionUsedPercent,
             resetsAt: self.sessionResetsAt)
-        let weeklyWindow = self.makeWindow(
+        let weeklyWindow = self.makeWeeklyWindow(
             usedPercent: self.weeklyUsedPercent,
             resetsAt: self.weeklyResetsAt)
 
@@ -54,12 +57,22 @@ extension OllamaUsageSnapshot {
             identity: identity)
     }
 
-    private func makeWindow(usedPercent: Double?, resetsAt: Date?) -> RateWindow? {
+    private func makeSessionWindow(usedPercent: Double?, resetsAt: Date?) -> RateWindow? {
         guard let usedPercent else { return nil }
         let clamped = min(100, max(0, usedPercent))
         return RateWindow(
             usedPercent: clamped,
-            windowMinutes: nil,
+            windowMinutes: self.sessionWindowMinutes,
+            resetsAt: resetsAt,
+            resetDescription: nil)
+    }
+
+    private func makeWeeklyWindow(usedPercent: Double?, resetsAt: Date?) -> RateWindow? {
+        guard let usedPercent else { return nil }
+        let clamped = min(100, max(0, usedPercent))
+        return RateWindow(
+            usedPercent: clamped,
+            windowMinutes: 7 * 24 * 60,
             resetsAt: resetsAt,
             resetDescription: nil)
     }
diff --git a/Sources/CodexBarCore/Providers/OpenAI/OpenAIAPICreditBalanceFetcher.swift b/Sources/CodexBarCore/Providers/OpenAI/OpenAIAPICreditBalanceFetcher.swift
new file mode 100644
index 0000000000..f35db443a1
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/OpenAI/OpenAIAPICreditBalanceFetcher.swift
@@ -0,0 +1,185 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public struct OpenAIAPICreditGrant: Decodable, Sendable {
+    public let grantAmount: Double?
+    public let usedAmount: Double?
+    public let expiresAt: Date?
+
+    private enum CodingKeys: String, CodingKey {
+        case grantAmount = "grant_amount"
+        case usedAmount = "used_amount"
+        case expiresAt = "expires_at"
+    }
+}
+
+public struct OpenAIAPICreditGrantsList: Decodable, Sendable {
+    public let data: [OpenAIAPICreditGrant]
+}
+
+public struct OpenAIAPICreditGrantsResponse: Decodable, Sendable {
+    public let totalGranted: Double
+    public let totalUsed: Double
+    public let totalAvailable: Double
+    public let grants: OpenAIAPICreditGrantsList?
+
+    private enum CodingKeys: String, CodingKey {
+        case totalGranted = "total_granted"
+        case totalUsed = "total_used"
+        case totalAvailable = "total_available"
+        case grants
+    }
+}
+
+public enum OpenAIAPICreditBalanceError: LocalizedError, Sendable, Equatable {
+    case missingCredentials
+    case networkError(String)
+    case apiError(Int)
+    case forbidden
+    case parseFailed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingCredentials:
+            "Missing OpenAI API key."
+        case let .networkError(message):
+            "OpenAI API credit balance network error: \(message)"
+        case let .apiError(statusCode):
+            "OpenAI API credit balance error: HTTP \(statusCode)"
+        case .forbidden:
+            "OpenAI API credit balance endpoint returned HTTP 403. Use a legacy/user API key with billing access; " +
+                "project keys may not expose credit grants."
+        case let .parseFailed(message):
+            "Failed to parse OpenAI API credit balance: \(message)"
+        }
+    }
+}
+
+public struct OpenAIAPICreditBalanceSnapshot: Sendable {
+    public let totalGranted: Double
+    public let totalUsed: Double
+    public let totalAvailable: Double
+    public let nextGrantExpiry: Date?
+    public let updatedAt: Date
+
+    public init(
+        totalGranted: Double,
+        totalUsed: Double,
+        totalAvailable: Double,
+        nextGrantExpiry: Date?,
+        updatedAt: Date = Date())
+    {
+        self.totalGranted = totalGranted
+        self.totalUsed = totalUsed
+        self.totalAvailable = totalAvailable
+        self.nextGrantExpiry = nextGrantExpiry
+        self.updatedAt = updatedAt
+    }
+
+    public func toUsageSnapshot() -> UsageSnapshot {
+        let usedPercent: Double = if self.totalGranted > 0 {
+            min(100, max(0, (self.totalUsed / self.totalGranted) * 100))
+        } else {
+            self.totalAvailable > 0 ? 0 : 100
+        }
+
+        let primary = RateWindow(
+            usedPercent: usedPercent,
+            windowMinutes: nil,
+            resetsAt: self.nextGrantExpiry,
+            resetDescription: "\(Self.formatUSD(self.totalAvailable)) available")
+
+        return UsageSnapshot(
+            primary: primary,
+            secondary: nil,
+            providerCost: ProviderCostSnapshot(
+                used: max(0, self.totalUsed),
+                limit: max(0, self.totalGranted),
+                currencyCode: "USD",
+                period: "API credits",
+                resetsAt: self.nextGrantExpiry,
+                updatedAt: self.updatedAt),
+            updatedAt: self.updatedAt,
+            identity: ProviderIdentitySnapshot(
+                providerID: .openai,
+                accountEmail: nil,
+                accountOrganization: nil,
+                loginMethod: "API balance: \(Self.formatUSD(self.totalAvailable))"))
+    }
+
+    private static func formatUSD(_ value: Double) -> String {
+        UsageFormatter.currencyString(max(0, value), currencyCode: "USD")
+    }
+}
+
+public enum OpenAIAPICreditBalanceFetcher {
+    public static let creditGrantsURL = URL(string: "https://api.openai.com/v1/dashboard/billing/credit_grants")!
+    private static let timeoutSeconds: TimeInterval = 15
+
+    public static func fetchBalance(
+        apiKey: String,
+        url: URL = Self.creditGrantsURL,
+        session transport: any ProviderHTTPTransport = ProviderHTTPClient.shared,
+        now: Date = Date()) async throws -> OpenAIAPICreditBalanceSnapshot
+    {
+        let trimmed = apiKey.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else {
+            throw OpenAIAPICreditBalanceError.missingCredentials
+        }
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.timeoutInterval = Self.timeoutSeconds
+        request.setValue("Bearer \(trimmed)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+
+        let response: ProviderHTTPResponse
+        do {
+            response = try await transport.response(for: request)
+        } catch {
+            throw OpenAIAPICreditBalanceError.networkError(error.localizedDescription)
+        }
+
+        guard response.statusCode != 403 else {
+            throw OpenAIAPICreditBalanceError.forbidden
+        }
+        guard response.statusCode == 200 else {
+            throw OpenAIAPICreditBalanceError.apiError(response.statusCode)
+        }
+
+        return try self.parseSnapshot(response.data, now: now)
+    }
+
+    public static func _parseSnapshotForTesting(
+        _ data: Data,
+        now: Date = Date()) throws -> OpenAIAPICreditBalanceSnapshot
+    {
+        try self.parseSnapshot(data, now: now)
+    }
+
+    private static func parseSnapshot(_ data: Data, now: Date) throws -> OpenAIAPICreditBalanceSnapshot {
+        let decoder = JSONDecoder()
+        decoder.dateDecodingStrategy = .secondsSince1970
+
+        let decoded: OpenAIAPICreditGrantsResponse
+        do {
+            decoded = try decoder.decode(OpenAIAPICreditGrantsResponse.self, from: data)
+        } catch {
+            throw OpenAIAPICreditBalanceError.parseFailed(error.localizedDescription)
+        }
+
+        let nextExpiry = decoded.grants?.data
+            .compactMap(\.expiresAt)
+            .filter { $0 > now }
+            .min()
+
+        return OpenAIAPICreditBalanceSnapshot(
+            totalGranted: decoded.totalGranted,
+            totalUsed: decoded.totalUsed,
+            totalAvailable: decoded.totalAvailable,
+            nextGrantExpiry: nextExpiry,
+            updatedAt: now)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/OpenAI/OpenAIAPIProviderDescriptor.swift b/Sources/CodexBarCore/Providers/OpenAI/OpenAIAPIProviderDescriptor.swift
new file mode 100644
index 0000000000..d2a5e6f151
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/OpenAI/OpenAIAPIProviderDescriptor.swift
@@ -0,0 +1,133 @@
+import Foundation
+
+public enum OpenAIAPIProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .openai,
+            metadata: ProviderMetadata(
+                id: .openai,
+                displayName: "OpenAI",
+                sessionLabel: "Spend",
+                weeklyLabel: "Requests",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "",
+                toggleTitle: "Show OpenAI usage",
+                cliName: "openai",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                dashboardURL: "https://platform.openai.com/usage",
+                statusPageURL: "https://status.openai.com"),
+            branding: ProviderBranding(
+                iconStyle: .openai,
+                iconResourceName: "ProviderIcon-codex",
+                color: ProviderColor(red: 0.06, green: 0.51, blue: 0.43)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: true,
+                noDataMessage: { "OpenAI usage needs an Admin API key for organization usage." }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .api],
+                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [OpenAIAPIBalanceFetchStrategy()] })),
+            cli: ProviderCLIConfig(
+                name: "openai",
+                aliases: ["openai-api"],
+                versionDetector: nil))
+    }
+}
+
+struct OpenAIAPIBalanceFetchStrategy: ProviderFetchStrategy {
+    let id: String = "openai.api.balance"
+    let kind: ProviderFetchKind = .apiToken
+    let usageFetcher: @Sendable (OpenAIAPIUsageCredential, Int) async throws -> OpenAIAPIUsageSnapshot
+    let balanceFetcher: @Sendable (String) async throws -> OpenAIAPICreditBalanceSnapshot
+
+    init(
+        usageFetcher: @escaping @Sendable (OpenAIAPIUsageCredential, Int) async throws -> OpenAIAPIUsageSnapshot =
+            OpenAIAPIBalanceFetchStrategy.fetchUsage(credential:days:),
+        balanceFetcher: @escaping @Sendable (String) async throws -> OpenAIAPICreditBalanceSnapshot = { apiKey in
+            try await OpenAIAPICreditBalanceFetcher.fetchBalance(apiKey: apiKey)
+        })
+    {
+        self.usageFetcher = usageFetcher
+        self.balanceFetcher = balanceFetcher
+    }
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        OpenAIAPIUsageCredential(environment: context.env) != nil
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        guard let credential = OpenAIAPIUsageCredential(environment: context.env) else {
+            throw OpenAIAPISettingsError.missingToken
+        }
+
+        do {
+            let usage = try await self.usageFetcher(credential, context.costUsageHistoryDays)
+            return self.makeResult(
+                usage: usage.toUsageSnapshot(),
+                sourceLabel: credential.sourceLabel)
+        } catch {
+            let usageError = error
+            if !credential.allowsLegacyBalanceFallback {
+                throw usageError
+            }
+            // Preserve the older balance-only path for unscoped keys and Admin API outages.
+            do {
+                let balance = try await self.balanceFetcher(credential.apiKey)
+                return self.makeResult(
+                    usage: balance.toUsageSnapshot(),
+                    sourceLabel: "billing-api")
+            } catch {
+                if (usageError as? OpenAIAPIUsageError)?.isCredentialRejected != true {
+                    throw usageError
+                }
+                throw error
+            }
+        }
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+
+    private static func fetchUsage(
+        credential: OpenAIAPIUsageCredential,
+        days: Int) async throws -> OpenAIAPIUsageSnapshot
+    {
+        try await OpenAIAPIUsageFetcher.fetchUsage(
+            apiKey: credential.apiKey,
+            projectID: credential.projectID,
+            historyDays: days)
+    }
+}
+
+struct OpenAIAPIUsageCredential: Equatable {
+    let apiKey: String
+    let projectID: String?
+    let usesAdminKey: Bool
+
+    init?(environment: [String: String]) {
+        if let adminKey = OpenAIAPISettingsReader.adminAPIKey(environment: environment) {
+            self.apiKey = adminKey
+            self.usesAdminKey = true
+        } else if let apiKey = OpenAIAPISettingsReader.apiKey(environment: environment) {
+            self.apiKey = apiKey
+            self.usesAdminKey = false
+        } else {
+            return nil
+        }
+        self.projectID = OpenAIAPISettingsReader.projectID(environment: environment)
+    }
+
+    var sourceLabel: String {
+        self.projectID == nil ? "admin-api" : "admin-api:project"
+    }
+
+    var allowsLegacyBalanceFallback: Bool {
+        self.projectID == nil || !self.usesAdminKey
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/OpenAI/OpenAIAPISettingsReader.swift b/Sources/CodexBarCore/Providers/OpenAI/OpenAIAPISettingsReader.swift
new file mode 100644
index 0000000000..a641872d11
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/OpenAI/OpenAIAPISettingsReader.swift
@@ -0,0 +1,52 @@
+import Foundation
+
+public enum OpenAIAPISettingsReader {
+    public static let adminAPIKeyEnvironmentKey = "OPENAI_ADMIN_KEY"
+    public static let apiKeyEnvironmentKey = "OPENAI_API_KEY"
+    public static let projectIDEnvironmentKey = "OPENAI_PROJECT_ID"
+    public static let apiKeyEnvironmentKeys = [
+        Self.adminAPIKeyEnvironmentKey,
+        Self.apiKeyEnvironmentKey,
+    ]
+
+    public static func apiKey(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        for key in self.apiKeyEnvironmentKeys {
+            if let token = self.cleaned(environment[key]) { return token }
+        }
+        return nil
+    }
+
+    public static func adminAPIKey(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        self.cleaned(environment[self.adminAPIKeyEnvironmentKey])
+    }
+
+    public static func projectID(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        self.cleaned(environment[self.projectIDEnvironmentKey])
+    }
+
+    static func cleaned(_ raw: String?) -> String? {
+        guard var value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
+            return nil
+        }
+
+        if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
+            (value.hasPrefix("'") && value.hasSuffix("'"))
+        {
+            value = String(value.dropFirst().dropLast())
+        }
+
+        value = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        return value.isEmpty ? nil : value
+    }
+}
+
+public enum OpenAIAPISettingsError: LocalizedError, Sendable {
+    case missingToken
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingToken:
+            "OpenAI API key not configured. Set OPENAI_API_KEY or configure an API key in Settings."
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/OpenAI/OpenAIAPIUsageFetcher.swift b/Sources/CodexBarCore/Providers/OpenAI/OpenAIAPIUsageFetcher.swift
new file mode 100644
index 0000000000..8faa3f6c7a
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/OpenAI/OpenAIAPIUsageFetcher.swift
@@ -0,0 +1,462 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public enum OpenAIAPIUsageError: LocalizedError, Sendable, Equatable {
+    case missingCredentials
+    case networkError(String)
+    case apiError(endpoint: String, statusCode: Int)
+    case parseFailed(endpoint: String, message: String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingCredentials:
+            "Missing OpenAI Admin API key."
+        case let .networkError(message):
+            "OpenAI API usage network error: \(message)"
+        case let .apiError(endpoint, statusCode):
+            "OpenAI API usage \(endpoint) error: HTTP \(statusCode)"
+        case let .parseFailed(endpoint, message):
+            "Failed to parse OpenAI API usage \(endpoint): \(message)"
+        }
+    }
+
+    var isCredentialRejected: Bool {
+        switch self {
+        case let .apiError(_, statusCode):
+            statusCode == 401 || statusCode == 403
+        default:
+            false
+        }
+    }
+}
+
+public enum OpenAIAPIUsageFetcher {
+    public static let organizationCostsURL = URL(string: "https://api.openai.com/v1/organization/costs")!
+    public static let organizationCompletionsUsageURL =
+        URL(string: "https://api.openai.com/v1/organization/usage/completions")!
+
+    private static let maxDailyBucketLimit = 31
+    private static let maxPaginationPages = 100
+    private static let timeoutSeconds: TimeInterval = 20
+
+    private struct EndpointRequestContext {
+        let apiKey: String
+        let projectID: String?
+        let transport: any ProviderHTTPTransport
+        let retryPolicy: ProviderHTTPRetryPolicy
+    }
+
+    private struct UsageEndpoint<Bucket> {
+        let name: String
+        let baseURL: URL
+        let queryItems: [URLQueryItem]
+        let decodePage: (Data) throws -> UsagePage<Bucket>
+    }
+
+    private struct UsagePage<Bucket> {
+        let data: [Bucket]
+        let hasMore: Bool
+        let nextPage: String?
+    }
+
+    private typealias SnapshotMetadata = (now: Date, calendar: Calendar, historyDays: Int, projectID: String?)
+
+    public static func fetchUsage(
+        apiKey: String,
+        projectID: String? = nil,
+        costsURL: URL = Self.organizationCostsURL,
+        completionsURL: URL = Self.organizationCompletionsUsageURL,
+        session transport: any ProviderHTTPTransport = ProviderHTTPClient.shared,
+        now: Date = Date(),
+        historyDays: Int = 30,
+        retryPolicy: ProviderHTTPRetryPolicy = .transientIdempotent) async throws -> OpenAIAPIUsageSnapshot
+    {
+        let trimmed = apiKey.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else {
+            throw OpenAIAPIUsageError.missingCredentials
+        }
+        let normalizedProjectID = OpenAIAPISettingsReader.cleaned(projectID)
+
+        let calendar = Self.utcCalendar
+        let clampedHistoryDays = max(1, min(365, historyDays))
+        let ranges = Self.dailyRanges(now: now, calendar: calendar, historyDays: clampedHistoryDays)
+        let requestContext = EndpointRequestContext(
+            apiKey: trimmed,
+            projectID: normalizedProjectID,
+            transport: transport,
+            retryPolicy: retryPolicy)
+        let costs = try await Self.fetchBuckets(
+            endpoint: Self.costsEndpoint(baseURL: costsURL),
+            context: requestContext,
+            ranges: ranges)
+        let completions = try await Self.fetchBuckets(
+            endpoint: Self.completionsEndpoint(baseURL: completionsURL),
+            context: requestContext,
+            ranges: ranges)
+
+        return Self.makeSnapshot(
+            costs: costs,
+            completions: completions,
+            metadata: SnapshotMetadata(
+                now: now,
+                calendar: calendar,
+                historyDays: clampedHistoryDays,
+                projectID: normalizedProjectID))
+    }
+
+    static func _parseSnapshotForTesting(
+        costs: Data,
+        completions: Data,
+        now: Date,
+        calendar: Calendar = Self.utcCalendar,
+        historyDays: Int = 30,
+        projectID: String? = nil) throws -> OpenAIAPIUsageSnapshot
+    {
+        try self.makeSnapshot(
+            costs: self.decodeCosts(costs).data,
+            completions: self.decodeCompletions(completions).data,
+            metadata: SnapshotMetadata(
+                now: now,
+                calendar: calendar,
+                historyDays: historyDays,
+                projectID: OpenAIAPISettingsReader.cleaned(projectID)))
+    }
+
+    private static func costsEndpoint(baseURL: URL) -> UsageEndpoint<OpenAICostBucket> {
+        UsageEndpoint(
+            name: "costs",
+            baseURL: baseURL,
+            queryItems: [URLQueryItem(name: "group_by", value: "line_item")],
+            decodePage: {
+                let response = try self.decodeCosts($0)
+                return UsagePage(
+                    data: response.data,
+                    hasMore: response.hasMore,
+                    nextPage: response.nextPage)
+            })
+    }
+
+    private static func completionsEndpoint(
+        baseURL: URL) -> UsageEndpoint<OpenAICompletionsUsageBucket>
+    {
+        UsageEndpoint(
+            name: "completions",
+            baseURL: baseURL,
+            queryItems: [URLQueryItem(name: "group_by", value: "model")],
+            decodePage: {
+                let response = try self.decodeCompletions($0)
+                return UsagePage(
+                    data: response.data,
+                    hasMore: response.hasMore,
+                    nextPage: response.nextPage)
+            })
+    }
+
+    private static func fetchBuckets<Bucket>(
+        endpoint: UsageEndpoint<Bucket>,
+        context: EndpointRequestContext,
+        ranges: [DateRange]) async throws -> [Bucket]
+    {
+        var buckets: [Bucket] = []
+        for range in ranges {
+            var nextPage: String?
+            var seenPages: Set<String> = []
+            var pageCount = 0
+
+            repeat {
+                pageCount += 1
+                guard pageCount <= Self.maxPaginationPages else {
+                    throw OpenAIAPIUsageError.parseFailed(
+                        endpoint: endpoint.name,
+                        message: "Pagination exceeded \(Self.maxPaginationPages) pages.")
+                }
+
+                let url = Self.url(
+                    baseURL: endpoint.baseURL,
+                    range: range,
+                    queryItems: endpoint.queryItems + Self.projectQueryItems(projectID: context.projectID),
+                    page: nextPage)
+                let data = try await Self.fetchData(
+                    url: url,
+                    apiKey: context.apiKey,
+                    endpoint: endpoint.name,
+                    transport: context.transport,
+                    retryPolicy: context.retryPolicy)
+                let page = try endpoint.decodePage(data)
+                buckets.append(contentsOf: page.data)
+
+                guard page.hasMore else {
+                    nextPage = nil
+                    continue
+                }
+                guard let cursor = Self.cleanedPageCursor(page.nextPage) else {
+                    throw OpenAIAPIUsageError.parseFailed(
+                        endpoint: endpoint.name,
+                        message: "Pagination cursor missing.")
+                }
+                guard seenPages.insert(cursor).inserted else {
+                    throw OpenAIAPIUsageError.parseFailed(
+                        endpoint: endpoint.name,
+                        message: "Pagination cursor repeated.")
+                }
+                nextPage = cursor
+            } while nextPage != nil
+        }
+        return buckets
+    }
+
+    private static func projectQueryItems(projectID: String?) -> [URLQueryItem] {
+        guard let projectID else { return [] }
+        return [URLQueryItem(name: "project_ids", value: projectID)]
+    }
+
+    private static func fetchData(
+        url: URL,
+        apiKey: String,
+        endpoint: String,
+        transport: any ProviderHTTPTransport,
+        retryPolicy: ProviderHTTPRetryPolicy) async throws -> Data
+    {
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.timeoutInterval = Self.timeoutSeconds
+        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+
+        let response: ProviderHTTPResponse
+        do {
+            response = try await transport.response(for: request, retryPolicy: retryPolicy)
+        } catch {
+            throw OpenAIAPIUsageError.networkError(error.localizedDescription)
+        }
+
+        guard response.statusCode == 200 else {
+            throw OpenAIAPIUsageError.apiError(endpoint: endpoint, statusCode: response.statusCode)
+        }
+        return response.data
+    }
+
+    private static func decodeCosts(_ data: Data) throws -> CostsResponse {
+        do {
+            return try JSONDecoder().decode(CostsResponse.self, from: data)
+        } catch {
+            throw OpenAIAPIUsageError.parseFailed(endpoint: "costs", message: error.localizedDescription)
+        }
+    }
+
+    private static func decodeCompletions(_ data: Data) throws -> CompletionsUsageResponse {
+        do {
+            return try JSONDecoder().decode(CompletionsUsageResponse.self, from: data)
+        } catch {
+            throw OpenAIAPIUsageError.parseFailed(endpoint: "completions", message: error.localizedDescription)
+        }
+    }
+
+    private static func makeSnapshot(
+        costs: [OpenAICostBucket],
+        completions: [OpenAICompletionsUsageBucket],
+        metadata: SnapshotMetadata) -> OpenAIAPIUsageSnapshot
+    {
+        var accumulators: [Int: DailyAccumulator] = [:]
+
+        for bucket in costs {
+            var accumulator = accumulators[bucket.startTime] ?? DailyAccumulator(
+                startTime: bucket.startTime,
+                endTime: bucket.endTime)
+            for result in bucket.results {
+                let value = result.amount?.value ?? 0
+                accumulator.costUSD += value
+                let lineItem = Self.displayName(result.lineItem, fallback: "API")
+                accumulator.lineItems[lineItem, default: 0] += value
+            }
+            accumulators[bucket.startTime] = accumulator
+        }
+
+        for bucket in completions {
+            var accumulator = accumulators[bucket.startTime] ?? DailyAccumulator(
+                startTime: bucket.startTime,
+                endTime: bucket.endTime)
+            for result in bucket.results {
+                let input = result.inputTokens ?? 0
+                let cached = result.inputCachedTokens ?? 0
+                let output = result.outputTokens ?? 0
+                let audioInput = result.inputAudioTokens ?? 0
+                let audioOutput = result.outputAudioTokens ?? 0
+                let requests = result.numModelRequests ?? 0
+                let totalTokens = input + output + audioInput + audioOutput
+                accumulator.requests += requests
+                accumulator.inputTokens += input + audioInput
+                accumulator.cachedInputTokens += cached
+                accumulator.outputTokens += output + audioOutput
+                accumulator.totalTokens += totalTokens
+                let modelName = Self.displayName(result.model, fallback: "Responses and Chat Completions")
+                accumulator.models[modelName, default: ModelAccumulator()].add(
+                    requests: requests,
+                    inputTokens: input + audioInput,
+                    cachedInputTokens: cached,
+                    outputTokens: output + audioOutput,
+                    totalTokens: totalTokens)
+            }
+            accumulators[bucket.startTime] = accumulator
+        }
+
+        let daily = accumulators.values
+            .filter { $0.startDate <= metadata.now }
+            .sorted { $0.startTime < $1.startTime }
+            .map { $0.makeBucket(calendar: metadata.calendar) }
+        return OpenAIAPIUsageSnapshot(
+            daily: daily,
+            updatedAt: metadata.now,
+            historyDays: metadata.historyDays,
+            projectID: metadata.projectID)
+    }
+
+    private static func displayName(_ raw: String?, fallback: String) -> String {
+        guard let trimmed = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !trimmed.isEmpty else {
+            return fallback
+        }
+        return trimmed
+    }
+
+    private static func cleanedPageCursor(_ raw: String?) -> String? {
+        guard let trimmed = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !trimmed.isEmpty else {
+            return nil
+        }
+        return trimmed
+    }
+
+    private static func url(
+        baseURL: URL,
+        range: DateRange,
+        queryItems extraItems: [URLQueryItem],
+        page: String? = nil) -> URL
+    {
+        var components = URLComponents(url: baseURL, resolvingAgainstBaseURL: false)!
+        var queryItems = [
+            URLQueryItem(name: "start_time", value: String(range.startTime)),
+            URLQueryItem(name: "end_time", value: String(range.endTime)),
+            URLQueryItem(name: "bucket_width", value: "1d"),
+            URLQueryItem(name: "limit", value: String(range.limit)),
+        ] + extraItems
+        if let page {
+            queryItems.append(URLQueryItem(name: "page", value: page))
+        }
+        components.queryItems = queryItems
+        return components.url!
+    }
+
+    private static func dailyRanges(now: Date, calendar: Calendar, historyDays: Int) -> [DateRange] {
+        let today = calendar.startOfDay(for: now)
+        let clampedHistoryDays = max(1, min(365, historyDays))
+        var cursor = calendar.date(byAdding: .day, value: -(clampedHistoryDays - 1), to: today) ?? today
+        var remainingDays = clampedHistoryDays
+        var ranges: [DateRange] = []
+        ranges.reserveCapacity(Int(ceil(Double(clampedHistoryDays) / Double(Self.maxDailyBucketLimit))))
+
+        while remainingDays > 0 {
+            let chunkDays = min(Self.maxDailyBucketLimit, remainingDays)
+            let end = calendar.date(byAdding: .day, value: chunkDays, to: cursor) ?? cursor
+            ranges.append(DateRange(
+                startTime: Int(cursor.timeIntervalSince1970),
+                endTime: Int(end.timeIntervalSince1970),
+                limit: chunkDays))
+            cursor = end
+            remainingDays -= chunkDays
+        }
+        return ranges
+    }
+
+    private static var utcCalendar: Calendar {
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.locale = Locale(identifier: "en_US_POSIX")
+        calendar.timeZone = TimeZone(secondsFromGMT: 0)!
+        return calendar
+    }
+}
+
+private struct DateRange {
+    let startTime: Int
+    let endTime: Int
+    let limit: Int
+}
+
+private struct DailyAccumulator {
+    let startTime: Int
+    let endTime: Int
+    var costUSD: Double = 0
+    var requests: Int = 0
+    var inputTokens: Int = 0
+    var cachedInputTokens: Int = 0
+    var outputTokens: Int = 0
+    var totalTokens: Int = 0
+    var lineItems: [String: Double] = [:]
+    var models: [String: ModelAccumulator] = [:]
+
+    var startDate: Date {
+        Date(timeIntervalSince1970: TimeInterval(self.startTime))
+    }
+
+    func makeBucket(calendar: Calendar) -> OpenAIAPIUsageSnapshot.DailyBucket {
+        OpenAIAPIUsageSnapshot.DailyBucket(
+            day: Self.dayKey(from: self.startDate, calendar: calendar),
+            startTime: self.startDate,
+            endTime: Date(timeIntervalSince1970: TimeInterval(self.endTime)),
+            costUSD: self.costUSD,
+            requests: self.requests,
+            inputTokens: self.inputTokens,
+            cachedInputTokens: self.cachedInputTokens,
+            outputTokens: self.outputTokens,
+            totalTokens: self.totalTokens,
+            lineItems: self.lineItems
+                .map { OpenAIAPIUsageSnapshot.LineItemBreakdown(name: $0.key, costUSD: $0.value) }
+                .sorted {
+                    if $0.costUSD == $1.costUSD { return $0.name < $1.name }
+                    return $0.costUSD > $1.costUSD
+                },
+            models: self.models
+                .map { $0.value.makeModel(name: $0.key) }
+                .sorted {
+                    if $0.totalTokens == $1.totalTokens { return $0.name < $1.name }
+                    return $0.totalTokens > $1.totalTokens
+                })
+    }
+
+    private static func dayKey(from date: Date, calendar: Calendar) -> String {
+        let comps = calendar.dateComponents([.year, .month, .day], from: date)
+        return String(format: "%04d-%02d-%02d", comps.year ?? 0, comps.month ?? 0, comps.day ?? 0)
+    }
+}
+
+private struct ModelAccumulator {
+    var requests = 0
+    var inputTokens = 0
+    var cachedInputTokens = 0
+    var outputTokens = 0
+    var totalTokens = 0
+
+    mutating func add(
+        requests: Int,
+        inputTokens: Int,
+        cachedInputTokens: Int,
+        outputTokens: Int,
+        totalTokens: Int)
+    {
+        self.requests += requests
+        self.inputTokens += inputTokens
+        self.cachedInputTokens += cachedInputTokens
+        self.outputTokens += outputTokens
+        self.totalTokens += totalTokens
+    }
+
+    func makeModel(name: String) -> OpenAIAPIUsageSnapshot.ModelBreakdown {
+        OpenAIAPIUsageSnapshot.ModelBreakdown(
+            name: name,
+            requests: self.requests,
+            inputTokens: self.inputTokens,
+            cachedInputTokens: self.cachedInputTokens,
+            outputTokens: self.outputTokens,
+            totalTokens: self.totalTokens)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/OpenAI/OpenAIAPIUsageResponses.swift b/Sources/CodexBarCore/Providers/OpenAI/OpenAIAPIUsageResponses.swift
new file mode 100644
index 0000000000..a540a0610f
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/OpenAI/OpenAIAPIUsageResponses.swift
@@ -0,0 +1,136 @@
+import Foundation
+
+struct CostsResponse: Decodable {
+    let data: [OpenAICostBucket]
+    let hasMore: Bool
+    let nextPage: String?
+
+    private enum CodingKeys: String, CodingKey {
+        case data
+        case hasMore = "has_more"
+        case nextPage = "next_page"
+    }
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.data = try container.decode([OpenAICostBucket].self, forKey: .data)
+        self.hasMore = try container.decode(Bool.self, forKey: .hasMore)
+        self.nextPage = try container.decodeIfPresent(String.self, forKey: .nextPage)
+    }
+}
+
+struct OpenAICostBucket: Decodable {
+    let startTime: Int
+    let endTime: Int
+    let results: [OpenAICostResult]
+
+    private enum CodingKeys: String, CodingKey {
+        case startTime = "start_time"
+        case endTime = "end_time"
+        case results
+    }
+}
+
+struct OpenAICostResult: Decodable {
+    struct Amount: Decodable {
+        let value: Double?
+        let currency: String?
+
+        private enum CodingKeys: String, CodingKey {
+            case value
+            case currency
+        }
+
+        init(from decoder: Decoder) throws {
+            let container = try decoder.container(keyedBy: CodingKeys.self)
+            self.value = try container.decodeFlexibleDoubleIfPresent(forKey: .value)
+            self.currency = try container.decodeIfPresent(String.self, forKey: .currency)
+        }
+    }
+
+    let amount: Amount?
+    let lineItem: String?
+
+    private enum CodingKeys: String, CodingKey {
+        case amount
+        case lineItem = "line_item"
+    }
+}
+
+struct CompletionsUsageResponse: Decodable {
+    let data: [OpenAICompletionsUsageBucket]
+    let hasMore: Bool
+    let nextPage: String?
+
+    private enum CodingKeys: String, CodingKey {
+        case data
+        case hasMore = "has_more"
+        case nextPage = "next_page"
+    }
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.data = try container.decode([OpenAICompletionsUsageBucket].self, forKey: .data)
+        self.hasMore = try container.decode(Bool.self, forKey: .hasMore)
+        self.nextPage = try container.decodeIfPresent(String.self, forKey: .nextPage)
+    }
+}
+
+struct OpenAICompletionsUsageBucket: Decodable {
+    let startTime: Int
+    let endTime: Int
+    let results: [OpenAICompletionsUsageResult]
+
+    private enum CodingKeys: String, CodingKey {
+        case startTime = "start_time"
+        case endTime = "end_time"
+        case results
+    }
+}
+
+struct OpenAICompletionsUsageResult: Decodable {
+    let inputTokens: Int?
+    let inputCachedTokens: Int?
+    let inputAudioTokens: Int?
+    let outputTokens: Int?
+    let outputAudioTokens: Int?
+    let numModelRequests: Int?
+    let model: String?
+
+    private enum CodingKeys: String, CodingKey {
+        case inputTokens = "input_tokens"
+        case inputCachedTokens = "input_cached_tokens"
+        case inputAudioTokens = "input_audio_tokens"
+        case outputTokens = "output_tokens"
+        case outputAudioTokens = "output_audio_tokens"
+        case numModelRequests = "num_model_requests"
+        case model
+    }
+}
+
+extension KeyedDecodingContainer {
+    fileprivate func decodeFlexibleDoubleIfPresent(forKey key: Key) throws -> Double? {
+        guard self.contains(key), try !self.decodeNil(forKey: key) else {
+            return nil
+        }
+
+        if let value = try? self.decode(Double.self, forKey: key) {
+            return value
+        }
+
+        if let rawValue = try? self.decode(String.self, forKey: key) {
+            let trimmed = rawValue.trimmingCharacters(in: .whitespacesAndNewlines)
+            guard !trimmed.isEmpty else {
+                return nil
+            }
+            if let value = Double(trimmed) {
+                return value
+            }
+        }
+
+        throw DecodingError.dataCorruptedError(
+            forKey: key,
+            in: self,
+            debugDescription: "Expected a number or numeric string for \(key.stringValue)")
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/OpenAI/OpenAIAPIUsageSnapshot.swift b/Sources/CodexBarCore/Providers/OpenAI/OpenAIAPIUsageSnapshot.swift
new file mode 100644
index 0000000000..9f741ea994
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/OpenAI/OpenAIAPIUsageSnapshot.swift
@@ -0,0 +1,280 @@
+import Foundation
+
+public struct OpenAIAPIUsageSnapshot: Codable, Equatable, Sendable {
+    public struct DailyBucket: Codable, Equatable, Sendable, Identifiable {
+        public let day: String
+        public let startTime: Date
+        public let endTime: Date
+        public let costUSD: Double
+        public let requests: Int
+        public let inputTokens: Int
+        public let cachedInputTokens: Int
+        public let outputTokens: Int
+        public let totalTokens: Int
+        public let lineItems: [LineItemBreakdown]
+        public let models: [ModelBreakdown]
+
+        public var id: String {
+            self.day
+        }
+
+        public init(
+            day: String,
+            startTime: Date,
+            endTime: Date,
+            costUSD: Double,
+            requests: Int,
+            inputTokens: Int,
+            cachedInputTokens: Int,
+            outputTokens: Int,
+            totalTokens: Int,
+            lineItems: [LineItemBreakdown],
+            models: [ModelBreakdown])
+        {
+            self.day = day
+            self.startTime = startTime
+            self.endTime = endTime
+            self.costUSD = costUSD
+            self.requests = requests
+            self.inputTokens = inputTokens
+            self.cachedInputTokens = cachedInputTokens
+            self.outputTokens = outputTokens
+            self.totalTokens = totalTokens
+            self.lineItems = lineItems
+            self.models = models
+        }
+    }
+
+    public struct LineItemBreakdown: Codable, Equatable, Sendable, Identifiable {
+        public let name: String
+        public let costUSD: Double
+
+        public var id: String {
+            self.name
+        }
+
+        public init(name: String, costUSD: Double) {
+            self.name = name
+            self.costUSD = costUSD
+        }
+    }
+
+    public struct ModelBreakdown: Codable, Equatable, Sendable, Identifiable {
+        public let name: String
+        public let requests: Int
+        public let inputTokens: Int
+        public let cachedInputTokens: Int
+        public let outputTokens: Int
+        public let totalTokens: Int
+
+        public var id: String {
+            self.name
+        }
+
+        public init(
+            name: String,
+            requests: Int,
+            inputTokens: Int,
+            cachedInputTokens: Int,
+            outputTokens: Int,
+            totalTokens: Int)
+        {
+            self.name = name
+            self.requests = requests
+            self.inputTokens = inputTokens
+            self.cachedInputTokens = cachedInputTokens
+            self.outputTokens = outputTokens
+            self.totalTokens = totalTokens
+        }
+    }
+
+    public struct Summary: Equatable, Sendable {
+        public let costUSD: Double
+        public let requests: Int
+        public let inputTokens: Int
+        public let cachedInputTokens: Int
+        public let outputTokens: Int
+        public let totalTokens: Int
+
+        public init(
+            costUSD: Double,
+            requests: Int,
+            inputTokens: Int,
+            cachedInputTokens: Int,
+            outputTokens: Int,
+            totalTokens: Int)
+        {
+            self.costUSD = costUSD
+            self.requests = requests
+            self.inputTokens = inputTokens
+            self.cachedInputTokens = cachedInputTokens
+            self.outputTokens = outputTokens
+            self.totalTokens = totalTokens
+        }
+    }
+
+    public let daily: [DailyBucket]
+    public let updatedAt: Date
+    public let historyDays: Int
+    public let projectID: String?
+
+    public init(daily: [DailyBucket], updatedAt: Date, historyDays: Int = 30, projectID: String? = nil) {
+        self.daily = daily.sorted { $0.startTime < $1.startTime }
+        self.updatedAt = updatedAt
+        self.historyDays = max(1, min(365, historyDays))
+        self.projectID = OpenAIAPISettingsReader.cleaned(projectID)
+    }
+
+    public var last30Days: Summary {
+        self.summary(days: self.historyDays)
+    }
+
+    public var historyWindowLabel: String {
+        self.historyDays == 1 ? "Today" : "\(self.historyDays)d"
+    }
+
+    public var historyWindowPeriodLabel: String {
+        self.historyDays == 1 ? "Today" : "Last \(self.historyDays) days"
+    }
+
+    public var last7Days: Summary {
+        self.summary(days: 7)
+    }
+
+    public var latestDay: Summary {
+        self.summary(days: 1)
+    }
+
+    public func summary(days: Int) -> Summary {
+        let selected = self.daily.suffix(max(1, days))
+        return Summary(
+            costUSD: selected.reduce(0) { $0 + $1.costUSD },
+            requests: selected.reduce(0) { $0 + $1.requests },
+            inputTokens: selected.reduce(0) { $0 + $1.inputTokens },
+            cachedInputTokens: selected.reduce(0) { $0 + $1.cachedInputTokens },
+            outputTokens: selected.reduce(0) { $0 + $1.outputTokens },
+            totalTokens: selected.reduce(0) { $0 + $1.totalTokens })
+    }
+
+    public var topModels: [ModelBreakdown] {
+        var totals: [String: ModelAccumulator] = [:]
+        for day in self.daily {
+            for model in day.models {
+                totals[model.name, default: ModelAccumulator()].add(model)
+            }
+        }
+        return totals
+            .map { name, total in total.makeModel(name: name) }
+            .sorted {
+                if $0.totalTokens == $1.totalTokens { return $0.name < $1.name }
+                return $0.totalTokens > $1.totalTokens
+            }
+    }
+
+    public var topLineItems: [LineItemBreakdown] {
+        var totals: [String: Double] = [:]
+        for day in self.daily {
+            for item in day.lineItems {
+                totals[item.name, default: 0] += item.costUSD
+            }
+        }
+        return totals
+            .map { LineItemBreakdown(name: $0.key, costUSD: $0.value) }
+            .sorted {
+                if $0.costUSD == $1.costUSD { return $0.name < $1.name }
+                return $0.costUSD > $1.costUSD
+            }
+    }
+
+    public func toUsageSnapshot() -> UsageSnapshot {
+        let total = self.last30Days
+        return UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            providerCost: ProviderCostSnapshot(
+                used: total.costUSD,
+                limit: 0,
+                currencyCode: "USD",
+                period: self.historyWindowPeriodLabel,
+                updatedAt: self.updatedAt),
+            openAIAPIUsage: self,
+            updatedAt: self.updatedAt,
+            identity: ProviderIdentitySnapshot(
+                providerID: .openai,
+                accountEmail: nil,
+                accountOrganization: self.identityAccountOrganization,
+                loginMethod: self.identityLoginMethod))
+    }
+
+    private var identityLoginMethod: String {
+        guard let projectID else { return "Admin API" }
+        return "Admin API: \(projectID)"
+    }
+
+    private var identityAccountOrganization: String? {
+        guard let projectID else { return nil }
+        return "Project: \(projectID)"
+    }
+
+    public func toCostUsageTokenSnapshot() -> CostUsageTokenSnapshot {
+        let daily = self.daily.map { bucket in
+            let modelBreakdowns = bucket.models.map {
+                CostUsageDailyReport.ModelBreakdown(
+                    modelName: $0.name,
+                    costUSD: nil,
+                    totalTokens: $0.totalTokens,
+                    requestCount: $0.requests)
+            }
+            let modelsUsed = bucket.models.map(\.name)
+            return CostUsageDailyReport.Entry(
+                date: bucket.day,
+                inputTokens: bucket.inputTokens,
+                outputTokens: bucket.outputTokens,
+                cacheReadTokens: bucket.cachedInputTokens,
+                cacheCreationTokens: nil,
+                totalTokens: bucket.totalTokens,
+                requestCount: bucket.requests,
+                costUSD: bucket.costUSD,
+                modelsUsed: modelsUsed.isEmpty ? nil : modelsUsed,
+                modelBreakdowns: modelBreakdowns.isEmpty ? nil : modelBreakdowns)
+        }
+        let latest = self.latestDay
+        let total = self.last30Days
+        return CostUsageTokenSnapshot(
+            sessionTokens: latest.totalTokens,
+            sessionCostUSD: latest.costUSD,
+            sessionRequests: latest.requests,
+            last30DaysTokens: total.totalTokens,
+            last30DaysCostUSD: total.costUSD,
+            last30DaysRequests: total.requests,
+            historyDays: self.historyDays,
+            daily: daily,
+            updatedAt: self.updatedAt)
+    }
+
+    private struct ModelAccumulator {
+        var requests = 0
+        var inputTokens = 0
+        var cachedInputTokens = 0
+        var outputTokens = 0
+        var totalTokens = 0
+
+        mutating func add(_ model: ModelBreakdown) {
+            self.requests += model.requests
+            self.inputTokens += model.inputTokens
+            self.cachedInputTokens += model.cachedInputTokens
+            self.outputTokens += model.outputTokens
+            self.totalTokens += model.totalTokens
+        }
+
+        func makeModel(name: String) -> ModelBreakdown {
+            ModelBreakdown(
+                name: name,
+                requests: self.requests,
+                inputTokens: self.inputTokens,
+                cachedInputTokens: self.cachedInputTokens,
+                outputTokens: self.outputTokens,
+                totalTokens: self.totalTokens)
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/OpenCode/OpenCodeCookieImporter.swift b/Sources/CodexBarCore/Providers/OpenCode/OpenCodeCookieImporter.swift
index d91261fdbd..0532d8cae8 100644
--- a/Sources/CodexBarCore/Providers/OpenCode/OpenCodeCookieImporter.swift
+++ b/Sources/CodexBarCore/Providers/OpenCode/OpenCodeCookieImporter.swift
@@ -37,7 +37,7 @@ public enum OpenCodeCookieImporter {
         for browserSource in installedBrowsers {
             do {
                 let query = BrowserCookieQuery(domains: self.cookieDomains)
-                let sources = try Self.cookieClient.records(
+                let sources = try Self.cookieClient.codexBarRecords(
                     matching: query,
                     in: browserSource,
                     logger: log)
diff --git a/Sources/CodexBarCore/Providers/OpenCode/OpenCodeProviderDescriptor.swift b/Sources/CodexBarCore/Providers/OpenCode/OpenCodeProviderDescriptor.swift
index 18803a46cd..2f62ba57cb 100644
--- a/Sources/CodexBarCore/Providers/OpenCode/OpenCodeProviderDescriptor.swift
+++ b/Sources/CodexBarCore/Providers/OpenCode/OpenCodeProviderDescriptor.swift
@@ -1,9 +1,8 @@
-import CodexBarMacroSupport
 import Foundation
 
-@ProviderDescriptorRegistration
-@ProviderDescriptorDefinition
 public enum OpenCodeProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
     static func makeDescriptor() -> ProviderDescriptor {
         ProviderDescriptor(
             id: .opencode,
@@ -84,35 +83,14 @@ struct OpenCodeUsageFetchStrategy: ProviderFetchStrategy {
     }
 
     private static func resolveCookieHeader(context: ProviderFetchContext, allowCached: Bool) throws -> String {
-        if let settings = context.settings?.opencode, settings.cookieSource == .manual {
-            if let header = CookieHeaderNormalizer.normalize(settings.manualCookieHeader) {
-                let pairs = CookieHeaderNormalizer.pairs(from: header)
-                let hasAuthCookie = pairs.contains { pair in
-                    pair.name == "auth" || pair.name == "__Host-auth"
-                }
-                if hasAuthCookie {
-                    return header
-                }
-            }
-            throw OpenCodeSettingsError.invalidCookie
-        }
-
-        #if os(macOS)
-        if allowCached,
-           let cached = CookieHeaderCache.load(provider: .opencode),
-           !cached.cookieHeader.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
-        {
-            return cached.cookieHeader
-        }
-        let session = try OpenCodeCookieImporter.importSession(browserDetection: context.browserDetection)
-        CookieHeaderCache.store(
-            provider: .opencode,
-            cookieHeader: session.cookieHeader,
-            sourceLabel: session.sourceLabel)
-        return session.cookieHeader
-        #else
-        throw OpenCodeSettingsError.missingCookie
-        #endif
+        try OpenCodeWebCookieSupport.resolveCookieHeader(
+            context: OpenCodeWebCookieSupport.Context(
+                settings: context.settings?.opencode,
+                provider: .opencode,
+                browserDetection: context.browserDetection,
+                allowCached: allowCached),
+            invalidCookie: OpenCodeSettingsError.invalidCookie,
+            missingCookie: OpenCodeSettingsError.missingCookie)
     }
 }
 
diff --git a/Sources/CodexBarCore/Providers/OpenCode/OpenCodeUsageFetcher.swift b/Sources/CodexBarCore/Providers/OpenCode/OpenCodeUsageFetcher.swift
index ed27f1d4f7..71aa427195 100644
--- a/Sources/CodexBarCore/Providers/OpenCode/OpenCodeUsageFetcher.swift
+++ b/Sources/CodexBarCore/Providers/OpenCode/OpenCodeUsageFetcher.swift
@@ -62,6 +62,10 @@ public struct OpenCodeUsageFetcher: Sendable {
         "renewAt",
         "renew_at",
     ]
+    private static let renewAtKeys = [
+        "renewAt",
+        "renew_at",
+    ]
     private static func makeISO8601Formatter() -> ISO8601DateFormatter {
         let formatter = ISO8601DateFormatter()
         formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
@@ -83,25 +87,32 @@ public struct OpenCodeUsageFetcher: Sendable {
         cookieHeader: String,
         timeout: TimeInterval,
         now: Date = Date(),
-        workspaceIDOverride: String? = nil) async throws -> OpenCodeUsageSnapshot
+        workspaceIDOverride: String? = nil,
+        session transport: any ProviderHTTPTransport = ProviderHTTPClient.shared) async throws -> OpenCodeUsageSnapshot
     {
+        guard let requestCookieHeader = OpenCodeWebCookieSupport.requestCookieHeader(from: cookieHeader) else {
+            throw OpenCodeUsageError.invalidCredentials
+        }
         let workspaceID: String = if let override = self.normalizeWorkspaceID(workspaceIDOverride) {
             override
         } else {
             try await self.fetchWorkspaceID(
-                cookieHeader: cookieHeader,
-                timeout: timeout)
+                cookieHeader: requestCookieHeader,
+                timeout: timeout,
+                transport: transport)
         }
         let subscriptionText = try await self.fetchSubscriptionInfo(
             workspaceID: workspaceID,
-            cookieHeader: cookieHeader,
-            timeout: timeout)
+            cookieHeader: requestCookieHeader,
+            timeout: timeout,
+            transport: transport)
         return try self.parseSubscription(text: subscriptionText, now: now)
     }
 
     private static func fetchWorkspaceID(
         cookieHeader: String,
-        timeout: TimeInterval) async throws -> String
+        timeout: TimeInterval,
+        transport: any ProviderHTTPTransport) async throws -> String
     {
         let text = try await self.fetchServerText(
             request: ServerRequest(
@@ -110,7 +121,8 @@ public struct OpenCodeUsageFetcher: Sendable {
                 method: "GET",
                 referer: self.baseURL),
             cookieHeader: cookieHeader,
-            timeout: timeout)
+            timeout: timeout,
+            transport: transport)
         if self.looksSignedOut(text: text) {
             throw OpenCodeUsageError.invalidCredentials
         }
@@ -127,7 +139,8 @@ public struct OpenCodeUsageFetcher: Sendable {
                     method: "POST",
                     referer: self.baseURL),
                 cookieHeader: cookieHeader,
-                timeout: timeout)
+                timeout: timeout,
+                transport: transport)
             if self.looksSignedOut(text: fallback) {
                 throw OpenCodeUsageError.invalidCredentials
             }
@@ -147,7 +160,8 @@ public struct OpenCodeUsageFetcher: Sendable {
     private static func fetchSubscriptionInfo(
         workspaceID: String,
         cookieHeader: String,
-        timeout: TimeInterval) async throws -> String
+        timeout: TimeInterval,
+        transport: any ProviderHTTPTransport) async throws -> String
     {
         let referer = URL(string: "https://opencode.ai/workspace/\(workspaceID)/billing") ?? self.baseURL
         let text = try await self.fetchServerText(
@@ -157,7 +171,8 @@ public struct OpenCodeUsageFetcher: Sendable {
                 method: "GET",
                 referer: referer),
             cookieHeader: cookieHeader,
-            timeout: timeout)
+            timeout: timeout,
+            transport: transport)
         if self.looksSignedOut(text: text) {
             throw OpenCodeUsageError.invalidCredentials
         }
@@ -178,7 +193,8 @@ public struct OpenCodeUsageFetcher: Sendable {
                     method: "POST",
                     referer: referer),
                 cookieHeader: cookieHeader,
-                timeout: timeout)
+                timeout: timeout,
+                transport: transport)
             if self.looksSignedOut(text: fallback) {
                 throw OpenCodeUsageError.invalidCredentials
             }
@@ -207,7 +223,7 @@ public struct OpenCodeUsageFetcher: Sendable {
     private static func missingSubscriptionDataError(workspaceID: String) -> OpenCodeUsageError {
         OpenCodeUsageError.apiError(
             "No subscription usage data was returned for workspace \(workspaceID). " +
-                "This usually means this workspace does not have OpenCode Black usage data.")
+                "This usually means this workspace does not have OpenCode subscription quota data available.")
     }
 
     private static func normalizeWorkspaceID(_ raw: String?) -> String? {
@@ -236,7 +252,8 @@ public struct OpenCodeUsageFetcher: Sendable {
     private static func fetchServerText(
         request serverRequest: ServerRequest,
         cookieHeader: String,
-        timeout: TimeInterval) async throws -> String
+        timeout: TimeInterval,
+        transport: any ProviderHTTPTransport) async throws -> String
     {
         let url = self.serverRequestURL(
             serverID: serverRequest.serverID,
@@ -260,28 +277,33 @@ public struct OpenCodeUsageFetcher: Sendable {
             urlRequest.setValue("application/json", forHTTPHeaderField: "Content-Type")
         }
 
-        let (data, response) = try await URLSession.shared.data(for: urlRequest)
-        guard let httpResponse = response as? HTTPURLResponse else {
+        let response: ProviderHTTPResponse
+        do {
+            response = try await transport.response(for: urlRequest)
+        } catch let error as URLError where error.code == .badServerResponse {
             throw OpenCodeUsageError.networkError("Invalid response")
+        } catch {
+            throw error
         }
 
-        guard httpResponse.statusCode == 200 else {
-            let bodyText = String(data: data, encoding: .utf8) ?? ""
-            let contentType = httpResponse.value(forHTTPHeaderField: "Content-Type") ?? "unknown"
-            Self.log.error("OpenCode returned \(httpResponse.statusCode) (type=\(contentType) length=\(data.count))")
+        guard response.statusCode == 200 else {
+            let bodyText = String(data: response.data, encoding: .utf8) ?? ""
+            let contentType = response.response.value(forHTTPHeaderField: "Content-Type") ?? "unknown"
+            Self.log
+                .error("OpenCode returned \(response.statusCode) (type=\(contentType) length=\(response.data.count))")
             if self.looksSignedOut(text: bodyText) {
                 throw OpenCodeUsageError.invalidCredentials
             }
-            if httpResponse.statusCode == 401 || httpResponse.statusCode == 403 {
+            if response.statusCode == 401 || response.statusCode == 403 {
                 throw OpenCodeUsageError.invalidCredentials
             }
             if let message = self.extractServerErrorMessage(from: bodyText) {
-                throw OpenCodeUsageError.apiError("HTTP \(httpResponse.statusCode): \(message)")
+                throw OpenCodeUsageError.apiError("HTTP \(response.statusCode): \(message)")
             }
-            throw OpenCodeUsageError.apiError("HTTP \(httpResponse.statusCode)")
+            throw OpenCodeUsageError.apiError("HTTP \(response.statusCode)")
         }
 
-        guard let text = String(data: data, encoding: .utf8) else {
+        guard let text = String(data: response.data, encoding: .utf8) else {
             throw OpenCodeUsageError.parseFailed("Response was not UTF-8.")
         }
         return text
@@ -428,7 +450,12 @@ public struct OpenCodeUsageFetcher: Sendable {
 
     private static func looksSignedOut(text: String) -> Bool {
         let lower = text.lowercased()
-        if lower.contains("login") || lower.contains("sign in") || lower.contains("auth/authorize") {
+        if lower.contains("login") ||
+            lower.contains("sign in") ||
+            lower.contains("auth/authorize") ||
+            lower.contains("not associated with an account") ||
+            lower.contains("actor of type \"public\"")
+        {
             return true
         }
         return false
@@ -479,24 +506,33 @@ public struct OpenCodeUsageFetcher: Sendable {
 
     private static func parseUsageJSON(object: Any, now: Date) -> OpenCodeUsageSnapshot? {
         guard let dict = object as? [String: Any] else { return nil }
-        if let snapshot = self.parseUsageDictionary(dict, now: now) {
+        let renewsAt = self.dateValue(from: self.value(from: dict, keys: self.renewAtKeys))
+        if let snapshot = self.parseUsageDictionary(dict, now: now, inheritedRenewsAt: renewsAt) {
             return snapshot
         }
 
         for key in ["data", "result", "usage", "billing", "payload"] {
             if let nested = dict[key] as? [String: Any],
-               let snapshot = self.parseUsageDictionary(nested, now: now)
+               let snapshot = self.parseUsageDictionary(nested, now: now, inheritedRenewsAt: renewsAt)
             {
                 return snapshot
             }
         }
 
-        return self.parseUsageNested(dict, now: now, depth: 0)
+        if let snapshot = self.parseUsageNested(dict, now: now, depth: 0, inheritedRenewsAt: renewsAt) {
+            return snapshot
+        }
+        return self.parseUsageFromCandidates(object: object, now: now, inheritedRenewsAt: renewsAt)
     }
 
-    private static func parseUsageDictionary(_ dict: [String: Any], now: Date) -> OpenCodeUsageSnapshot? {
+    private static func parseUsageDictionary(
+        _ dict: [String: Any],
+        now: Date,
+        inheritedRenewsAt: Date?) -> OpenCodeUsageSnapshot?
+    {
+        let renewsAt = self.dateValue(from: self.value(from: dict, keys: self.renewAtKeys)) ?? inheritedRenewsAt
         if let usage = dict["usage"] as? [String: Any],
-           let snapshot = self.parseUsageDictionary(usage, now: now)
+           let snapshot = self.parseUsageDictionary(usage, now: now, inheritedRenewsAt: renewsAt)
         {
             return snapshot
         }
@@ -508,14 +544,20 @@ public struct OpenCodeUsageFetcher: Sendable {
         let weekly = weeklyKeys.compactMap { dict[$0] as? [String: Any] }.first
 
         if let rolling, let weekly {
-            return self.buildSnapshot(rolling: rolling, weekly: weekly, now: now)
+            return self.buildSnapshot(rolling: rolling, weekly: weekly, now: now, renewsAt: renewsAt)
         }
 
         return nil
     }
 
-    private static func parseUsageNested(_ dict: [String: Any], now: Date, depth: Int) -> OpenCodeUsageSnapshot? {
+    private static func parseUsageNested(
+        _ dict: [String: Any],
+        now: Date,
+        depth: Int,
+        inheritedRenewsAt: Date?) -> OpenCodeUsageSnapshot?
+    {
         if depth > 3 { return nil }
+        let renewsAt = self.dateValue(from: self.value(from: dict, keys: self.renewAtKeys)) ?? inheritedRenewsAt
         var rolling: [String: Any]?
         var weekly: [String: Any]?
 
@@ -529,15 +571,18 @@ public struct OpenCodeUsageFetcher: Sendable {
             }
         }
 
-        if let rolling, let weekly,
-           let snapshot = self.buildSnapshot(rolling: rolling, weekly: weekly, now: now)
-        {
-            return snapshot
+        if let rolling, let weekly {
+            let snapshot = self.buildSnapshot(rolling: rolling, weekly: weekly, now: now, renewsAt: renewsAt)
+            if let snapshot { return snapshot }
         }
 
         for value in dict.values {
             if let sub = value as? [String: Any],
-               let snapshot = self.parseUsageNested(sub, now: now, depth: depth + 1)
+               let snapshot = self.parseUsageNested(
+                   sub,
+                   now: now,
+                   depth: depth + 1,
+                   inheritedRenewsAt: renewsAt)
             {
                 return snapshot
             }
@@ -546,7 +591,11 @@ public struct OpenCodeUsageFetcher: Sendable {
         return nil
     }
 
-    private static func parseUsageFromCandidates(object: Any, now: Date) -> OpenCodeUsageSnapshot? {
+    private static func parseUsageFromCandidates(
+        object: Any,
+        now: Date,
+        inheritedRenewsAt: Date? = nil) -> OpenCodeUsageSnapshot?
+    {
         let candidates = self.collectWindowCandidates(object: object, now: now)
         guard !candidates.isEmpty else { return nil }
 
@@ -573,15 +622,18 @@ public struct OpenCodeUsageFetcher: Sendable {
 
         guard let rolling, let weekly else { return nil }
 
+        let renewsAt = self.dateValue(from: self.value(from: object as? [String: Any] ?? [:], keys: self.renewAtKeys))
+            ?? inheritedRenewsAt
         return OpenCodeUsageSnapshot(
             rollingUsagePercent: rolling.percent,
             weeklyUsagePercent: weekly.percent,
             rollingResetInSec: rolling.resetInSec,
             weeklyResetInSec: weekly.resetInSec,
+            renewsAt: renewsAt,
             updatedAt: now)
     }
 
-    private struct WindowCandidate: Sendable {
+    private struct WindowCandidate {
         let id: UUID
         let percent: Double
         let resetInSec: Int
@@ -656,7 +708,8 @@ public struct OpenCodeUsageFetcher: Sendable {
     private static func buildSnapshot(
         rolling: [String: Any],
         weekly: [String: Any],
-        now: Date) -> OpenCodeUsageSnapshot?
+        now: Date,
+        renewsAt: Date? = nil) -> OpenCodeUsageSnapshot?
     {
         guard let rollingWindow = self.parseWindow(rolling, now: now),
               let weeklyWindow = self.parseWindow(weekly, now: now)
@@ -669,6 +722,7 @@ public struct OpenCodeUsageFetcher: Sendable {
             weeklyUsagePercent: weeklyWindow.percent,
             rollingResetInSec: rollingWindow.resetInSec,
             weeklyResetInSec: weeklyWindow.resetInSec,
+            renewsAt: renewsAt,
             updatedAt: now)
     }
 
diff --git a/Sources/CodexBarCore/Providers/OpenCode/OpenCodeUsageSnapshot.swift b/Sources/CodexBarCore/Providers/OpenCode/OpenCodeUsageSnapshot.swift
index aa1d87f282..672812525e 100644
--- a/Sources/CodexBarCore/Providers/OpenCode/OpenCodeUsageSnapshot.swift
+++ b/Sources/CodexBarCore/Providers/OpenCode/OpenCodeUsageSnapshot.swift
@@ -5,6 +5,7 @@ public struct OpenCodeUsageSnapshot: Sendable {
     public let weeklyUsagePercent: Double
     public let rollingResetInSec: Int
     public let weeklyResetInSec: Int
+    public let renewsAt: Date?
     public let updatedAt: Date
 
     public init(
@@ -12,12 +13,14 @@ public struct OpenCodeUsageSnapshot: Sendable {
         weeklyUsagePercent: Double,
         rollingResetInSec: Int,
         weeklyResetInSec: Int,
+        renewsAt: Date? = nil,
         updatedAt: Date)
     {
         self.rollingUsagePercent = rollingUsagePercent
         self.weeklyUsagePercent = weeklyUsagePercent
         self.rollingResetInSec = rollingResetInSec
         self.weeklyResetInSec = weeklyResetInSec
+        self.renewsAt = renewsAt
         self.updatedAt = updatedAt
     }
 
@@ -36,9 +39,20 @@ public struct OpenCodeUsageSnapshot: Sendable {
             resetsAt: weeklyReset,
             resetDescription: nil)
 
+        var extraWindows: [NamedRateWindow]?
+        if let renewsAt = self.renewsAt {
+            let renewalWindow = RateWindow(
+                usedPercent: 0,
+                windowMinutes: nil,
+                resetsAt: renewsAt,
+                resetDescription: nil)
+            extraWindows = [NamedRateWindow(id: "renewal", title: "Renews", window: renewalWindow)]
+        }
+
         return UsageSnapshot(
             primary: primary,
             secondary: secondary,
+            extraRateWindows: extraWindows,
             updatedAt: self.updatedAt,
             identity: nil)
     }
diff --git a/Sources/CodexBarCore/Providers/OpenCode/OpenCodeWebCookieSupport.swift b/Sources/CodexBarCore/Providers/OpenCode/OpenCodeWebCookieSupport.swift
new file mode 100644
index 0000000000..5d239b08d0
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/OpenCode/OpenCodeWebCookieSupport.swift
@@ -0,0 +1,62 @@
+import Foundation
+
+enum OpenCodeWebCookieSupport {
+    private static let requestCookieNames: Set<String> = ["auth", "__Host-auth"]
+
+    struct Context {
+        let settings: ProviderSettingsSnapshot.OpenCodeProviderSettings?
+        let provider: UsageProvider
+        let browserDetection: BrowserDetection
+        let allowCached: Bool
+    }
+
+    static func requestCookieHeader(from rawHeader: String?) -> String? {
+        CookieHeaderNormalizer.filteredHeader(from: rawHeader, allowedNames: self.requestCookieNames)
+    }
+
+    static func resolveCookieHeader(
+        context: Context,
+        invalidCookie: @autoclosure () -> Error,
+        missingCookie: @autoclosure () -> Error) throws -> String
+    {
+        if let settings = context.settings, settings.cookieSource == .manual {
+            if let header = self.requestCookieHeader(from: settings.manualCookieHeader) {
+                return header
+            }
+            throw invalidCookie()
+        }
+
+        #if os(macOS)
+        if context.allowCached,
+           let cached = CookieHeaderCache.load(provider: context.provider),
+           let header = self.requestCookieHeader(from: cached.cookieHeader)
+        {
+            return header
+        }
+        let session = try OpenCodeCookieImporter.importSession(
+            browserDetection: context.browserDetection,
+            preferredBrowsers: self.automaticImportOrder(provider: context.provider))
+        guard let header = self.requestCookieHeader(from: session.cookieHeader) else {
+            throw missingCookie()
+        }
+        CookieHeaderCache.store(
+            provider: context.provider,
+            cookieHeader: header,
+            sourceLabel: session.sourceLabel)
+        return header
+        #else
+        throw missingCookie()
+        #endif
+    }
+
+    #if os(macOS)
+    static func automaticImportOrder(provider: UsageProvider) -> BrowserCookieImportOrder {
+        if provider == .opencodego,
+           let order = ProviderDefaults.metadata[provider]?.browserCookieOrder
+        {
+            return order
+        }
+        return [.chrome]
+    }
+    #endif
+}
diff --git a/Sources/CodexBarCore/Providers/OpenCodeGo/OpenCodeGoLocalUsageReader.swift b/Sources/CodexBarCore/Providers/OpenCodeGo/OpenCodeGoLocalUsageReader.swift
new file mode 100644
index 0000000000..e4cdf237e3
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/OpenCodeGo/OpenCodeGoLocalUsageReader.swift
@@ -0,0 +1,324 @@
+import Foundation
+
+#if canImport(SQLite3)
+import SQLite3
+#elseif canImport(CSQLite3)
+import CSQLite3
+#endif
+
+#if canImport(SQLite3) || canImport(CSQLite3)
+public enum OpenCodeGoLocalUsageError: LocalizedError, Sendable, Equatable {
+    case notDetected
+    case historyUnavailable(String)
+    case sqliteFailed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .notDetected:
+            "OpenCode Go not detected. Log in with OpenCode Go or use it locally first."
+        case let .historyUnavailable(message):
+            "OpenCode Go local usage history is unavailable: \(message)"
+        case let .sqliteFailed(message):
+            "SQLite error reading OpenCode Go usage: \(message)"
+        }
+    }
+}
+
+public struct OpenCodeGoLocalUsageReader: Sendable {
+    private static let fiveHours: TimeInterval = 5 * 60 * 60
+    private static let week: TimeInterval = 7 * 24 * 60 * 60
+    private static let limits = (session: 12.0, weekly: 30.0, monthly: 60.0)
+
+    private let authURL: URL
+    private let databaseURL: URL
+
+    public init(homeDirectory: URL = FileManager.default.homeDirectoryForCurrentUser) {
+        let openCodeDirectory = homeDirectory
+            .appendingPathComponent(".local", isDirectory: true)
+            .appendingPathComponent("share", isDirectory: true)
+            .appendingPathComponent("opencode", isDirectory: true)
+        self.authURL = openCodeDirectory.appendingPathComponent("auth.json", isDirectory: false)
+        self.databaseURL = openCodeDirectory.appendingPathComponent("opencode.db", isDirectory: false)
+    }
+
+    public init(authURL: URL, databaseURL: URL) {
+        self.authURL = authURL
+        self.databaseURL = databaseURL
+    }
+
+    public func fetch(now: Date = Date()) throws -> OpenCodeGoUsageSnapshot {
+        let hasAuth = Self.hasAuthKey(at: self.authURL)
+        guard FileManager.default.fileExists(atPath: self.databaseURL.path) else {
+            if hasAuth {
+                throw OpenCodeGoLocalUsageError.historyUnavailable("database not found")
+            }
+            throw OpenCodeGoLocalUsageError.notDetected
+        }
+
+        let rows = try self.readRows()
+        guard hasAuth || !rows.isEmpty else {
+            throw OpenCodeGoLocalUsageError.notDetected
+        }
+        guard !rows.isEmpty else {
+            throw OpenCodeGoLocalUsageError.historyUnavailable("no local usage rows")
+        }
+        return Self.snapshot(rows: rows, now: now)
+    }
+
+    private func readRows() throws -> [UsageRow] {
+        var db: OpaquePointer?
+        guard sqlite3_open_v2(self.databaseURL.path, &db, SQLITE_OPEN_READONLY, nil) == SQLITE_OK else {
+            let message = db.flatMap { String(cString: sqlite3_errmsg($0)) } ?? "unknown error"
+            sqlite3_close(db)
+            throw OpenCodeGoLocalUsageError.sqliteFailed(message)
+        }
+        defer { sqlite3_close(db) }
+        sqlite3_busy_timeout(db, 250)
+
+        let sql = self.hasTable(named: "part", db: db) ? Self.messageAndPartUsageSQL : Self.messageUsageSQL
+
+        var stmt: OpaquePointer?
+        guard sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK else {
+            let message = db.flatMap { String(cString: sqlite3_errmsg($0)) } ?? "unknown error"
+            throw OpenCodeGoLocalUsageError.sqliteFailed(message)
+        }
+        defer { sqlite3_finalize(stmt) }
+
+        var rows: [UsageRow] = []
+        while true {
+            let step = sqlite3_step(stmt)
+            if step == SQLITE_DONE { break }
+            guard step == SQLITE_ROW else {
+                let message = db.flatMap { String(cString: sqlite3_errmsg($0)) } ?? "unknown error"
+                throw OpenCodeGoLocalUsageError.sqliteFailed(message)
+            }
+
+            let createdMs = sqlite3_column_int64(stmt, 0)
+            let cost = sqlite3_column_double(stmt, 1)
+            guard createdMs > 0, cost >= 0, cost.isFinite else { continue }
+            rows.append(UsageRow(createdMs: createdMs, cost: cost))
+        }
+        return rows
+    }
+
+    private func hasTable(named name: String, db: OpaquePointer?) -> Bool {
+        var stmt: OpaquePointer?
+        guard sqlite3_prepare_v2(
+            db,
+            "SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ? LIMIT 1",
+            -1,
+            &stmt,
+            nil) == SQLITE_OK
+        else {
+            return false
+        }
+        defer { sqlite3_finalize(stmt) }
+
+        let transient = unsafeBitCast(-1, to: sqlite3_destructor_type.self)
+        sqlite3_bind_text(stmt, 1, name, -1, transient)
+        return sqlite3_step(stmt) == SQLITE_ROW
+    }
+
+    private static let messageUsageSQL = """
+        SELECT
+          CAST(COALESCE(json_extract(data, '$.time.created'), time_created) AS INTEGER) AS createdMs,
+          CAST(json_extract(data, '$.cost') AS REAL) AS cost
+        FROM message
+        WHERE json_valid(data)
+          AND json_extract(data, '$.providerID') = 'opencode-go'
+          AND json_extract(data, '$.role') = 'assistant'
+          AND json_type(data, '$.cost') IN ('integer', 'real')
+    """
+
+    private static let messageAndPartUsageSQL = """
+        WITH message_costs AS (
+          SELECT
+            id AS messageID,
+            CAST(COALESCE(json_extract(data, '$.time.created'), time_created) AS INTEGER) AS createdMs,
+            CAST(json_extract(data, '$.cost') AS REAL) AS cost
+          FROM message
+          WHERE json_valid(data)
+            AND json_extract(data, '$.providerID') = 'opencode-go'
+            AND json_extract(data, '$.role') = 'assistant'
+            AND json_type(data, '$.cost') IN ('integer', 'real')
+        )
+        SELECT createdMs, cost
+        FROM message_costs
+        UNION ALL
+        SELECT
+          CAST(COALESCE(json_extract(p.data, '$.time.created'), p.time_created, m.time_created) AS INTEGER)
+            AS createdMs,
+          CAST(json_extract(p.data, '$.cost') AS REAL) AS cost
+        FROM part p
+        JOIN message m ON m.id = p.message_id
+        WHERE json_valid(p.data)
+          AND json_valid(m.data)
+          AND json_extract(p.data, '$.type') = 'step-finish'
+          AND json_type(p.data, '$.cost') IN ('integer', 'real')
+          AND json_extract(m.data, '$.providerID') = 'opencode-go'
+          AND json_extract(m.data, '$.role') = 'assistant'
+          AND NOT EXISTS (
+            SELECT 1
+            FROM message_costs
+            WHERE message_costs.messageID = p.message_id
+          )
+    """
+
+    private struct UsageRow {
+        let createdMs: Int64
+        let cost: Double
+    }
+
+    private static func hasAuthKey(at url: URL) -> Bool {
+        guard let data = try? Data(contentsOf: url),
+              let object = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+              let entry = object["opencode-go"] as? [String: Any],
+              let key = entry["key"] as? String
+        else {
+            return false
+        }
+        return !key.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+    }
+
+    private static func snapshot(rows: [UsageRow], now: Date) -> OpenCodeGoUsageSnapshot {
+        let nowMs = Int64(now.timeIntervalSince1970 * 1000)
+        let sessionStart = nowMs - Int64(Self.fiveHours * 1000)
+        let weekStart = self.startOfUTCWeek(now: now).timeIntervalSince1970 * 1000
+        let weekStartMs = Int64(weekStart)
+        let weekEndMs = weekStartMs + Int64(Self.week * 1000)
+        let earliestMs = rows.map(\.createdMs).min()
+        let monthBounds = self.monthBounds(now: now, anchorMs: earliestMs)
+
+        let sessionCost = self.sum(rows: rows, startMs: sessionStart, endMs: nowMs)
+        let weeklyCost = self.sum(rows: rows, startMs: weekStartMs, endMs: weekEndMs)
+        let monthlyCost = self.sum(rows: rows, startMs: monthBounds.startMs, endMs: monthBounds.endMs)
+
+        return OpenCodeGoUsageSnapshot(
+            hasMonthlyUsage: true,
+            rollingUsagePercent: self.percent(used: sessionCost, limit: self.limits.session),
+            weeklyUsagePercent: self.percent(used: weeklyCost, limit: self.limits.weekly),
+            monthlyUsagePercent: self.percent(used: monthlyCost, limit: self.limits.monthly),
+            rollingResetInSec: self.rollingReset(rows: rows, nowMs: nowMs),
+            weeklyResetInSec: max(0, Int((weekEndMs - nowMs) / 1000)),
+            monthlyResetInSec: max(0, Int((monthBounds.endMs - nowMs) / 1000)),
+            updatedAt: now)
+    }
+
+    private static func sum(rows: [UsageRow], startMs: Int64, endMs: Int64) -> Double {
+        rows.reduce(0) { total, row in
+            guard row.createdMs >= startMs, row.createdMs < endMs else { return total }
+            return total + row.cost
+        }
+    }
+
+    private static func percent(used: Double, limit: Double) -> Double {
+        guard used.isFinite, limit > 0 else { return 0 }
+        let value = max(0, min(100, used / limit * 100))
+        return (value * 10).rounded() / 10
+    }
+
+    private static func rollingReset(rows: [UsageRow], nowMs: Int64) -> Int {
+        let sessionStart = nowMs - Int64(Self.fiveHours * 1000)
+        let oldest = rows
+            .filter { $0.createdMs >= sessionStart && $0.createdMs < nowMs }
+            .map(\.createdMs)
+            .min() ?? nowMs
+        return max(0, Int((oldest + Int64(Self.fiveHours * 1000) - nowMs) / 1000))
+    }
+
+    private static func startOfUTCWeek(now: Date) -> Date {
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = TimeZone(secondsFromGMT: 0) ?? TimeZone.current
+        calendar.firstWeekday = 2
+        calendar.minimumDaysInFirstWeek = 4
+        let components = calendar.dateComponents([.yearForWeekOfYear, .weekOfYear], from: now)
+        return calendar.date(from: components) ?? now
+    }
+
+    private static func monthBounds(now: Date, anchorMs: Int64?) -> (startMs: Int64, endMs: Int64) {
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = TimeZone(secondsFromGMT: 0) ?? TimeZone.current
+
+        guard let anchorMs else {
+            let start = calendar.date(from: calendar.dateComponents([.year, .month], from: now)) ?? now
+            let end = calendar.date(byAdding: .month, value: 1, to: start) ?? start
+            return (Int64(start.timeIntervalSince1970 * 1000), Int64(end.timeIntervalSince1970 * 1000))
+        }
+
+        let anchor = Date(timeIntervalSince1970: TimeInterval(anchorMs) / 1000)
+        let anchorComponents = calendar.dateComponents([.day, .hour, .minute, .second, .nanosecond], from: anchor)
+        let nowComponents = calendar.dateComponents([.year, .month], from: now)
+
+        var startMonthComponents = nowComponents
+        var start = self.anchoredMonth(calendar: calendar, month: startMonthComponents, anchor: anchorComponents)
+        if start > now {
+            guard let previous = calendar.date(byAdding: .month, value: -1, to: start) else {
+                let end = self.anchoredMonth(
+                    calendar: calendar,
+                    month: self.monthComponents(after: startMonthComponents, calendar: calendar),
+                    anchor: anchorComponents)
+                return (Int64(start.timeIntervalSince1970 * 1000), Int64(end.timeIntervalSince1970 * 1000))
+            }
+            startMonthComponents = calendar.dateComponents([.year, .month], from: previous)
+            start = self.anchoredMonth(calendar: calendar, month: startMonthComponents, anchor: anchorComponents)
+        }
+        let end = self.anchoredMonth(
+            calendar: calendar,
+            month: self.monthComponents(after: startMonthComponents, calendar: calendar),
+            anchor: anchorComponents)
+        return (Int64(start.timeIntervalSince1970 * 1000), Int64(end.timeIntervalSince1970 * 1000))
+    }
+
+    private static func monthComponents(after month: DateComponents, calendar: Calendar) -> DateComponents {
+        let monthStart = calendar.date(from: month) ?? Date()
+        let nextMonth = calendar.date(byAdding: .month, value: 1, to: monthStart) ?? monthStart
+        return calendar.dateComponents([.year, .month], from: nextMonth)
+    }
+
+    private static func anchoredMonth(
+        calendar: Calendar,
+        month: DateComponents,
+        anchor: DateComponents) -> Date
+    {
+        var components = DateComponents()
+        components.calendar = calendar
+        components.timeZone = calendar.timeZone
+        components.year = month.year
+        components.month = month.month
+        components.day = anchor.day
+        components.hour = anchor.hour
+        components.minute = anchor.minute
+        components.second = anchor.second
+        components.nanosecond = anchor.nanosecond
+
+        if let date = calendar.date(from: components),
+           calendar.component(.month, from: date) == month.month
+        {
+            return date
+        }
+
+        components.day = calendar.range(of: .day, in: .month, for: calendar.date(from: month) ?? Date())?.count
+        return calendar.date(from: components) ?? Date()
+    }
+}
+
+#else
+
+public enum OpenCodeGoLocalUsageError: LocalizedError, Sendable, Equatable {
+    case notSupported
+
+    public var errorDescription: String? {
+        "OpenCode Go local usage is only supported on macOS."
+    }
+}
+
+public struct OpenCodeGoLocalUsageReader: Sendable {
+    public init(homeDirectory _: URL = FileManager.default.homeDirectoryForCurrentUser) {}
+    public init(authURL _: URL, databaseURL _: URL) {}
+
+    public func fetch(now _: Date = Date()) throws -> OpenCodeGoUsageSnapshot {
+        throw OpenCodeGoLocalUsageError.notSupported
+    }
+}
+
+#endif
diff --git a/Sources/CodexBarCore/Providers/OpenCodeGo/OpenCodeGoProviderDescriptor.swift b/Sources/CodexBarCore/Providers/OpenCodeGo/OpenCodeGoProviderDescriptor.swift
new file mode 100644
index 0000000000..b3306b67be
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/OpenCodeGo/OpenCodeGoProviderDescriptor.swift
@@ -0,0 +1,192 @@
+import Foundation
+
+public enum OpenCodeGoProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .opencodego,
+            metadata: ProviderMetadata(
+                id: .opencodego,
+                displayName: "OpenCode Go",
+                sessionLabel: "5-hour",
+                weeklyLabel: "Weekly",
+                opusLabel: "Monthly",
+                supportsOpus: true,
+                supportsCredits: false,
+                creditsHint: "",
+                toggleTitle: "Show OpenCode Go usage",
+                cliName: "opencodego",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                browserCookieOrder: ProviderBrowserCookieDefaults.defaultImportOrder,
+                dashboardURL: "https://opencode.ai",
+                statusPageURL: nil),
+            branding: ProviderBranding(
+                iconStyle: .opencodego,
+                iconResourceName: "ProviderIcon-opencodego",
+                color: ProviderColor(red: 59 / 255, green: 130 / 255, blue: 246 / 255)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "OpenCode Go cost summary is not supported." }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .web],
+                pipeline: ProviderFetchPipeline(resolveStrategies: self.resolveStrategies)),
+            cli: ProviderCLIConfig(
+                name: "opencodego",
+                versionDetector: nil))
+    }
+
+    private static func resolveStrategies(context: ProviderFetchContext) async -> [any ProviderFetchStrategy] {
+        if context.sourceMode == .web {
+            return [OpenCodeGoUsageFetchStrategy()]
+        }
+        return [
+            OpenCodeGoUsageFetchStrategy(),
+            OpenCodeGoLocalUsageFetchStrategy(),
+        ]
+    }
+}
+
+struct OpenCodeGoLocalUsageFetchStrategy: ProviderFetchStrategy {
+    let id: String = "opencodego.local"
+    let kind: ProviderFetchKind = .localProbe
+
+    func isAvailable(_: ProviderFetchContext) async -> Bool {
+        true
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        let snapshot = try await self.snapshot(context: context)
+        return self.makeResult(
+            usage: snapshot.toUsageSnapshot(),
+            sourceLabel: "local")
+    }
+
+    func shouldFallback(on error: Error, context _: ProviderFetchContext) -> Bool {
+        error is OpenCodeGoLocalUsageError
+    }
+
+    private func snapshot(context: ProviderFetchContext) async throws -> OpenCodeGoUsageSnapshot {
+        let snapshot = try OpenCodeGoLocalUsageReader().fetch()
+        guard context.includeOptionalUsage,
+              context.settings?.opencodego?.cookieSource != .off
+        else {
+            return snapshot
+        }
+
+        guard let cookieHeader = Self.cachedOrManualCookieHeader(context: context) else {
+            return snapshot
+        }
+
+        let workspaceOverride = context.settings?.opencodego?.workspaceID
+            ?? context.env["CODEXBAR_OPENCODEGO_WORKSPACE_ID"]
+        let zenBalanceTask = Task<Double?, Error> {
+            do {
+                return try await OpenCodeGoUsageFetcher.fetchOptionalZenBalance(
+                    cookieHeader: cookieHeader,
+                    timeout: context.webTimeout,
+                    workspaceIDOverride: workspaceOverride)
+            } catch is CancellationError {
+                throw CancellationError()
+            } catch {
+                return nil
+            }
+        }
+        let zenBalance = try await OpenCodeGoUsageFetcher.completedOptionalZenBalance(from: zenBalanceTask)
+        return snapshot.withZenBalanceUSD(zenBalance)
+    }
+
+    private static func cachedOrManualCookieHeader(context: ProviderFetchContext) -> String? {
+        if let settings = context.settings?.opencodego, settings.cookieSource == .manual {
+            return OpenCodeWebCookieSupport.requestCookieHeader(from: settings.manualCookieHeader)
+        }
+
+        #if os(macOS)
+        guard let cached = CookieHeaderCache.load(provider: .opencodego) else { return nil }
+        return OpenCodeWebCookieSupport.requestCookieHeader(from: cached.cookieHeader)
+        #else
+        return nil
+        #endif
+    }
+}
+
+struct OpenCodeGoUsageFetchStrategy: ProviderFetchStrategy {
+    let id: String = "opencodego.web"
+    let kind: ProviderFetchKind = .web
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        guard context.settings?.opencodego?.cookieSource != .off else { return false }
+        return true
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        let workspaceOverride = context.settings?.opencodego?.workspaceID
+            ?? context.env["CODEXBAR_OPENCODEGO_WORKSPACE_ID"]
+        let cookieSource = context.settings?.opencodego?.cookieSource ?? .auto
+        do {
+            let cookieHeader = try Self.resolveCookieHeader(context: context, allowCached: true)
+            let snapshot = try await OpenCodeGoUsageFetcher.fetchUsage(
+                cookieHeader: cookieHeader,
+                timeout: context.webTimeout,
+                workspaceIDOverride: workspaceOverride,
+                includeZenBalance: context.includeOptionalUsage)
+            return self.makeResult(
+                usage: snapshot.toUsageSnapshot(),
+                sourceLabel: "web")
+        } catch OpenCodeGoUsageError.invalidCredentials where cookieSource != .manual {
+            #if os(macOS)
+            CookieHeaderCache.clear(provider: .opencodego)
+            let cookieHeader = try Self.resolveCookieHeader(context: context, allowCached: false)
+            let snapshot = try await OpenCodeGoUsageFetcher.fetchUsage(
+                cookieHeader: cookieHeader,
+                timeout: context.webTimeout,
+                workspaceIDOverride: workspaceOverride,
+                includeZenBalance: context.includeOptionalUsage)
+            return self.makeResult(
+                usage: snapshot.toUsageSnapshot(),
+                sourceLabel: "web")
+            #else
+            throw OpenCodeGoUsageError.invalidCredentials
+            #endif
+        }
+    }
+
+    func shouldFallback(on error: Error, context: ProviderFetchContext) -> Bool {
+        guard context.sourceMode == .auto else { return false }
+        return switch error {
+        case OpenCodeGoSettingsError.missingCookie,
+             OpenCodeGoSettingsError.invalidCookie,
+             OpenCodeGoUsageError.invalidCredentials:
+            true
+        default:
+            false
+        }
+    }
+
+    static func resolveCookieHeader(context: ProviderFetchContext, allowCached: Bool) throws -> String {
+        try OpenCodeWebCookieSupport.resolveCookieHeader(
+            context: OpenCodeWebCookieSupport.Context(
+                settings: context.settings?.opencodego,
+                provider: .opencodego,
+                browserDetection: context.browserDetection,
+                allowCached: allowCached),
+            invalidCookie: OpenCodeGoSettingsError.invalidCookie,
+            missingCookie: OpenCodeGoSettingsError.missingCookie)
+    }
+}
+
+enum OpenCodeGoSettingsError: LocalizedError {
+    case missingCookie
+    case invalidCookie
+
+    var errorDescription: String? {
+        switch self {
+        case .missingCookie:
+            "No OpenCode Go session cookies found in browsers."
+        case .invalidCookie:
+            "OpenCode Go cookie header is invalid."
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/OpenCodeGo/OpenCodeGoUsageFetcher.swift b/Sources/CodexBarCore/Providers/OpenCodeGo/OpenCodeGoUsageFetcher.swift
new file mode 100644
index 0000000000..cdcb7d30dd
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/OpenCodeGo/OpenCodeGoUsageFetcher.swift
@@ -0,0 +1,1004 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public enum OpenCodeGoUsageError: LocalizedError {
+    case invalidCredentials
+    case networkError(String)
+    case apiError(String)
+    case parseFailed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .invalidCredentials:
+            "OpenCode Go session cookie is invalid or expired."
+        case let .networkError(message):
+            "OpenCode Go network error: \(message)"
+        case let .apiError(message):
+            "OpenCode Go API error: \(message)"
+        case let .parseFailed(message):
+            "OpenCode Go parse error: \(message)"
+        }
+    }
+}
+
+public struct OpenCodeGoUsageFetcher: Sendable {
+    private static let log = CodexBarLog.logger(LogCategories.opencodeGoUsage)
+    private static let baseURL = URL(string: "https://opencode.ai")!
+    private static let serverURL = URL(string: "https://opencode.ai/_server")!
+    private static let workspacesServerID = "def39973159c7f0483d8793a822b8dbb10d067e12c65455fcb4608459ba0234f"
+    private static let billingServerID = "c83b78a614689c38ebee981f9b39a8b377716db85c1fd7dbab604adc02d3313d"
+
+    private static let userAgent =
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) " +
+        "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36"
+
+    private final class RedirectGuardDelegate: NSObject, URLSessionTaskDelegate {
+        func urlSession(
+            _ session: URLSession,
+            task: URLSessionTask,
+            willPerformHTTPRedirection response: HTTPURLResponse,
+            newRequest request: URLRequest,
+            completionHandler: @escaping (URLRequest?) -> Void)
+        {
+            guard OpenCodeGoUsageFetcher.allowsRedirect(
+                from: task.originalRequest?.url,
+                to: request.url)
+            else {
+                completionHandler(nil)
+                return
+            }
+            completionHandler(request)
+        }
+    }
+
+    private struct ServerRequest {
+        let serverID: String
+        let args: String?
+        let method: String
+        let referer: URL
+    }
+
+    // swiftformat:disable:next redundantSendable
+    struct ZenBalanceRequest: Sendable {
+        let workspaceID: String
+        let cookieHeader: String
+        let timeout: TimeInterval
+        let session: URLSession
+    }
+
+    private static let percentKeys = [
+        "usagePercent",
+        "usedPercent",
+        "percentUsed",
+        "percent",
+        "usage_percent",
+        "used_percent",
+        "utilization",
+        "utilizationPercent",
+        "utilization_percent",
+        "usage",
+    ]
+    private static let resetInKeys = [
+        "resetInSec",
+        "resetInSeconds",
+        "resetSeconds",
+        "reset_sec",
+        "reset_in_sec",
+        "resetsInSec",
+        "resetsInSeconds",
+        "resetIn",
+        "resetSec",
+    ]
+    private static let resetAtKeys = [
+        "resetAt",
+        "resetsAt",
+        "reset_at",
+        "resets_at",
+        "nextReset",
+        "next_reset",
+        "renewAt",
+        "renew_at",
+    ]
+    private static let renewAtKeys = [
+        "renewAt",
+        "renew_at",
+    ]
+    private static let redirectGuardDelegate = RedirectGuardDelegate()
+    private static let redirectGuardSession: URLSession = {
+        let configuration = URLSessionConfiguration.ephemeral
+        configuration.httpCookieStorage = nil
+        return URLSession(
+            configuration: configuration,
+            delegate: OpenCodeGoUsageFetcher.redirectGuardDelegate,
+            delegateQueue: nil)
+    }()
+
+    public static func fetchUsage(
+        cookieHeader: String,
+        timeout: TimeInterval,
+        now: Date = Date(),
+        workspaceIDOverride: String? = nil,
+        includeZenBalance: Bool = true,
+        session: URLSession? = nil) async throws -> OpenCodeGoUsageSnapshot
+    {
+        let session = session ?? self.redirectGuardSession
+        guard let requestCookieHeader = OpenCodeWebCookieSupport.requestCookieHeader(from: cookieHeader) else {
+            throw OpenCodeGoUsageError.invalidCredentials
+        }
+        let workspaceID: String = if let override = self.normalizeWorkspaceID(workspaceIDOverride) {
+            override
+        } else {
+            try await self.fetchWorkspaceID(
+                cookieHeader: requestCookieHeader,
+                timeout: timeout,
+                session: session)
+        }
+        let zenBalanceRequest = ZenBalanceRequest(
+            workspaceID: workspaceID,
+            cookieHeader: requestCookieHeader,
+            timeout: timeout,
+            session: session)
+        let subscriptionTask = Task {
+            try await self.fetchUsagePage(
+                workspaceID: workspaceID,
+                cookieHeader: requestCookieHeader,
+                timeout: timeout,
+                session: session)
+        }
+        let zenBalanceTask = includeZenBalance ? Task {
+            try await Task.sleep(for: self.optionalZenBalanceStartDelay)
+            return try await self.fetchZenBalance(
+                workspaceID: workspaceID,
+                cookieHeader: requestCookieHeader,
+                timeout: timeout,
+                session: session)
+        } : nil
+        defer {
+            subscriptionTask.cancel()
+            zenBalanceTask?.cancel()
+        }
+        let subscriptionText: String
+        do {
+            subscriptionText = try await withTaskCancellationHandler {
+                try await subscriptionTask.value
+            } onCancel: {
+                subscriptionTask.cancel()
+                zenBalanceTask?.cancel()
+            }
+        } catch is CancellationError {
+            throw CancellationError()
+        } catch let error as URLError where error.code == .cancelled {
+            throw CancellationError()
+        } catch let error as OpenCodeGoUsageError {
+            return try await self.requiredZenBalanceFallback(
+                from: zenBalanceTask,
+                for: error,
+                request: zenBalanceRequest,
+                now: now)
+        } catch {
+            throw error
+        }
+        let snapshot: OpenCodeGoUsageSnapshot
+        do {
+            snapshot = try self.parseSubscription(text: subscriptionText, now: now)
+        } catch let error as OpenCodeGoUsageError {
+            return try await self.requiredZenBalanceFallback(
+                from: zenBalanceTask,
+                for: error,
+                request: zenBalanceRequest,
+                now: now)
+        }
+        guard let zenBalanceTask else {
+            return snapshot
+        }
+        let zenBalance = try await self.completedOptionalZenBalance(from: zenBalanceTask)
+        return snapshot.withZenBalanceUSD(zenBalance)
+    }
+
+    static func requiredZenBalanceFallback(
+        from task: Task<Double?, Error>?,
+        for error: OpenCodeGoUsageError,
+        request: ZenBalanceRequest,
+        now: Date) async throws -> OpenCodeGoUsageSnapshot
+    {
+        guard case let .parseFailed(message) = error,
+              message.contains("Missing usage fields")
+        else {
+            throw error
+        }
+        let task = task ?? Task {
+            try await self.fetchZenBalance(
+                workspaceID: request.workspaceID,
+                cookieHeader: request.cookieHeader,
+                timeout: request.timeout,
+                session: request.session)
+        }
+        defer {
+            task.cancel()
+        }
+        let zenBalance = try await self.completedRequiredZenBalance(from: task)
+        guard let zenBalance else {
+            throw error
+        }
+        return OpenCodeGoUsageSnapshot.zenBalanceOnly(balanceUSD: zenBalance, updatedAt: now)
+    }
+
+    static func fetchOptionalZenBalance(
+        cookieHeader: String,
+        timeout: TimeInterval,
+        workspaceIDOverride: String? = nil,
+        session: URLSession? = nil) async throws -> Double?
+    {
+        let session = session ?? self.redirectGuardSession
+        guard let requestCookieHeader = OpenCodeWebCookieSupport.requestCookieHeader(from: cookieHeader) else {
+            throw OpenCodeGoUsageError.invalidCredentials
+        }
+        let workspaceID: String = if let override = self.normalizeWorkspaceID(workspaceIDOverride) {
+            override
+        } else {
+            try await self.fetchWorkspaceID(
+                cookieHeader: requestCookieHeader,
+                timeout: timeout,
+                session: session)
+        }
+        return try await self.fetchOptionalZenBalance(
+            workspaceID: workspaceID,
+            cookieHeader: requestCookieHeader,
+            timeout: min(timeout, self.optionalZenBalanceTimeout),
+            session: session)
+    }
+
+    static func allowsRedirect(from sourceURL: URL?, to destinationURL: URL?) -> Bool {
+        guard let sourceHost = sourceURL?.host?.lowercased(),
+              let destinationHost = destinationURL?.host?.lowercased(),
+              sourceHost == destinationHost,
+              destinationURL?.scheme?.lowercased() == "https"
+        else { return false }
+        return true
+    }
+
+    public static func dashboardURL(workspaceID raw: String?) -> URL {
+        guard let workspaceID = self.normalizeWorkspaceID(raw),
+              let url = URL(string: "\(self.baseURL.absoluteString)/workspace/\(workspaceID)/go")
+        else {
+            return self.baseURL
+        }
+        return url
+    }
+}
+
+extension OpenCodeGoUsageFetcher {
+    static func fetchZenBillingText(
+        workspaceID: String,
+        cookieHeader: String,
+        timeout: TimeInterval,
+        session: URLSession) async throws -> String
+    {
+        let argsData = try JSONSerialization.data(withJSONObject: [workspaceID])
+        guard let args = String(data: argsData, encoding: .utf8) else {
+            throw OpenCodeGoUsageError.parseFailed("Could not encode billing request.")
+        }
+        return try await self.fetchServerText(
+            request: ServerRequest(
+                serverID: self.billingServerID,
+                args: args,
+                method: "GET",
+                referer: self.zenDashboardURL(workspaceID: workspaceID)),
+            cookieHeader: cookieHeader,
+            timeout: timeout,
+            session: session)
+    }
+
+    private static func fetchWorkspaceID(
+        cookieHeader: String,
+        timeout: TimeInterval,
+        session: URLSession) async throws -> String
+    {
+        let text = try await self.fetchServerText(
+            request: ServerRequest(
+                serverID: self.workspacesServerID,
+                args: nil,
+                method: "GET",
+                referer: self.baseURL),
+            cookieHeader: cookieHeader,
+            timeout: timeout,
+            session: session)
+        if self.looksSignedOut(text: text) {
+            throw OpenCodeGoUsageError.invalidCredentials
+        }
+        var ids = self.parseWorkspaceIDs(text: text)
+        if ids.isEmpty {
+            ids = self.parseWorkspaceIDsFromJSON(text: text)
+        }
+        if ids.isEmpty {
+            Self.log.error("OpenCode Go workspace ids missing after GET; retrying with POST.")
+            let fallback = try await self.fetchServerText(
+                request: ServerRequest(
+                    serverID: self.workspacesServerID,
+                    args: "[]",
+                    method: "POST",
+                    referer: self.baseURL),
+                cookieHeader: cookieHeader,
+                timeout: timeout,
+                session: session)
+            if self.looksSignedOut(text: fallback) {
+                throw OpenCodeGoUsageError.invalidCredentials
+            }
+            ids = self.parseWorkspaceIDs(text: fallback)
+            if ids.isEmpty {
+                ids = self.parseWorkspaceIDsFromJSON(text: fallback)
+            }
+            if ids.isEmpty {
+                throw OpenCodeGoUsageError.parseFailed("Missing workspace id.")
+            }
+            return ids[0]
+        }
+        return ids[0]
+    }
+
+    static func normalizeWorkspaceID(_ raw: String?) -> String? {
+        guard let raw else { return nil }
+        let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines)
+        if trimmed.hasPrefix("wrk_"), trimmed.count > 4 {
+            return trimmed
+        }
+        if let url = URL(string: trimmed) {
+            let parts = url.pathComponents
+            if let index = parts.firstIndex(of: "workspace"),
+               parts.count > index + 1
+            {
+                let candidate = parts[index + 1]
+                if candidate.hasPrefix("wrk_"), candidate.count > 4 {
+                    return candidate
+                }
+            }
+        }
+        if let match = trimmed.range(of: #"wrk_[A-Za-z0-9]+"#, options: .regularExpression) {
+            return String(trimmed[match])
+        }
+        return nil
+    }
+
+    static func parseWorkspaceIDs(text: String) -> [String] {
+        let pattern = #"id\s*:\s*\"(wrk_[^\"]+)\""#
+        guard let regex = try? NSRegularExpression(pattern: pattern, options: []) else { return [] }
+        let nsrange = NSRange(text.startIndex..<text.endIndex, in: text)
+        return regex.matches(in: text, options: [], range: nsrange).compactMap { match in
+            guard let range = Range(match.range(at: 1), in: text) else { return nil }
+            return String(text[range])
+        }
+    }
+
+    private static func parseWorkspaceIDsFromJSON(text: String) -> [String] {
+        guard let data = text.data(using: .utf8),
+              let object = try? JSONSerialization.jsonObject(with: data, options: [])
+        else {
+            return []
+        }
+        var results: [String] = []
+        self.collectWorkspaceIDs(object: object, out: &results)
+        return results
+    }
+
+    private static func collectWorkspaceIDs(object: Any, out: inout [String]) {
+        if let dict = object as? [String: Any] {
+            for (_, value) in dict {
+                self.collectWorkspaceIDs(object: value, out: &out)
+            }
+            return
+        }
+        if let array = object as? [Any] {
+            for value in array {
+                self.collectWorkspaceIDs(object: value, out: &out)
+            }
+            return
+        }
+        if let string = object as? String,
+           string.hasPrefix("wrk_"),
+           !out.contains(string)
+        {
+            out.append(string)
+        }
+    }
+
+    private static func fetchUsagePage(
+        workspaceID: String,
+        cookieHeader: String,
+        timeout: TimeInterval,
+        session: URLSession) async throws -> String
+    {
+        let url = URL(string: "https://opencode.ai/workspace/\(workspaceID)/go") ?? self.baseURL
+        let text = try await self.fetchPageText(
+            url: url,
+            cookieHeader: cookieHeader,
+            timeout: timeout,
+            session: session)
+        if self.looksSignedOut(text: text) {
+            throw OpenCodeGoUsageError.invalidCredentials
+        }
+        guard self.parseSubscriptionJSON(text: text, now: Date()) != nil ||
+            self.extractDouble(
+                pattern: #"rollingUsage[^}]*?usagePercent\s*:\s*([0-9]+(?:\.[0-9]+)?)"#,
+                text: text) != nil
+        else {
+            Self.log.error("OpenCode Go usage page payload missing usage fields.")
+            throw OpenCodeGoUsageError.parseFailed("Missing usage fields.")
+        }
+        return text
+    }
+
+    static func parseSubscription(text: String, now: Date) throws -> OpenCodeGoUsageSnapshot {
+        if let snapshot = self.parseSubscriptionJSON(text: text, now: now) {
+            return snapshot
+        }
+
+        guard let rollingPercent = self.extractDouble(
+            pattern: #"rollingUsage[^}]*?usagePercent\s*:\s*([0-9]+(?:\.[0-9]+)?)"#,
+            text: text),
+            let rollingReset = self.extractInt(
+                pattern: #"rollingUsage[^}]*?resetInSec\s*:\s*([0-9]+)"#,
+                text: text),
+            let weeklyPercent = self.extractDouble(
+                pattern: #"weeklyUsage[^}]*?usagePercent\s*:\s*([0-9]+(?:\.[0-9]+)?)"#,
+                text: text),
+            let weeklyReset = self.extractInt(
+                pattern: #"weeklyUsage[^}]*?resetInSec\s*:\s*([0-9]+)"#,
+                text: text)
+        else {
+            throw OpenCodeGoUsageError.parseFailed("Missing usage fields.")
+        }
+
+        let monthlyPercent = self.extractDouble(
+            pattern: #"monthlyUsage[^}]*?usagePercent\s*:\s*([0-9]+(?:\.[0-9]+)?)"#,
+            text: text)
+        let monthlyReset = self.extractInt(
+            pattern: #"monthlyUsage[^}]*?resetInSec\s*:\s*([0-9]+)"#,
+            text: text)
+
+        return OpenCodeGoUsageSnapshot(
+            hasMonthlyUsage: monthlyPercent != nil || monthlyReset != nil,
+            rollingUsagePercent: rollingPercent,
+            weeklyUsagePercent: weeklyPercent,
+            monthlyUsagePercent: monthlyPercent ?? 0,
+            rollingResetInSec: rollingReset,
+            weeklyResetInSec: weeklyReset,
+            monthlyResetInSec: monthlyReset ?? 0,
+            updatedAt: now)
+    }
+
+    private static func parseSubscriptionJSON(text: String, now: Date) -> OpenCodeGoUsageSnapshot? {
+        guard let data = text.data(using: .utf8),
+              let object = try? JSONSerialization.jsonObject(with: data, options: []),
+              let dict = object as? [String: Any]
+        else {
+            return nil
+        }
+
+        let renewsAt = self.dateValue(from: self.value(from: dict, keys: self.renewAtKeys))
+        if let snapshot = self.parseUsageDictionary(dict, now: now, inheritedRenewsAt: renewsAt) {
+            return snapshot
+        }
+        for key in ["data", "result", "usage", "billing", "payload"] {
+            if let nested = dict[key] as? [String: Any],
+               let snapshot = self.parseUsageDictionary(nested, now: now, inheritedRenewsAt: renewsAt)
+            {
+                return snapshot
+            }
+        }
+        if let snapshot = self.parseUsageNested(dict, now: now, depth: 0, inheritedRenewsAt: renewsAt) {
+            return snapshot
+        }
+        return self.parseUsageFromCandidates(object: object, now: now, inheritedRenewsAt: renewsAt)
+    }
+
+    private static func parseUsageDictionary(
+        _ dict: [String: Any],
+        now: Date,
+        inheritedRenewsAt: Date?) -> OpenCodeGoUsageSnapshot?
+    {
+        let renewsAt = self.dateValue(from: self.value(from: dict, keys: self.renewAtKeys)) ?? inheritedRenewsAt
+        if let usage = dict["usage"] as? [String: Any],
+           let snapshot = self.parseUsageDictionary(usage, now: now, inheritedRenewsAt: renewsAt)
+        {
+            return snapshot
+        }
+
+        let rollingKeys = ["rollingUsage", "rolling", "rolling_usage", "rollingWindow", "rolling_window"]
+        let weeklyKeys = ["weeklyUsage", "weekly", "weekly_usage", "weeklyWindow", "weekly_window"]
+        let monthlyKeys = ["monthlyUsage", "monthly", "monthly_usage", "monthlyWindow", "monthly_window"]
+
+        let rolling = self.firstDict(from: dict, keys: rollingKeys)
+        let weekly = self.firstDict(from: dict, keys: weeklyKeys)
+        let monthly = self.firstDict(from: dict, keys: monthlyKeys)
+
+        guard let rolling, let weekly else { return nil }
+
+        return self.buildSnapshot(rolling: rolling, weekly: weekly, monthly: monthly, now: now, renewsAt: renewsAt)
+    }
+
+    private static func parseUsageNested(
+        _ dict: [String: Any],
+        now: Date,
+        depth: Int,
+        inheritedRenewsAt: Date?) -> OpenCodeGoUsageSnapshot?
+    {
+        if depth > 3 { return nil }
+        let renewsAt = self.dateValue(from: self.value(from: dict, keys: self.renewAtKeys)) ?? inheritedRenewsAt
+        var rolling: [String: Any]?
+        var weekly: [String: Any]?
+        var monthly: [String: Any]?
+
+        for (key, value) in dict {
+            guard let sub = value as? [String: Any] else { continue }
+            let lower = key.lowercased()
+            if lower.contains("rolling") || lower.contains("hour") || lower.contains("5h") || lower.contains("5-hour") {
+                rolling = sub
+            } else if lower.contains("weekly") || lower.contains("week") {
+                weekly = sub
+            } else if lower.contains("monthly") || lower.contains("month") {
+                monthly = sub
+            }
+        }
+
+        if let rolling, let weekly {
+            let snapshot = self.buildSnapshot(
+                rolling: rolling,
+                weekly: weekly,
+                monthly: monthly,
+                now: now,
+                renewsAt: renewsAt)
+            if let snapshot { return snapshot }
+        }
+
+        for value in dict.values {
+            if let sub = value as? [String: Any],
+               let snapshot = self.parseUsageNested(
+                   sub,
+                   now: now,
+                   depth: depth + 1,
+                   inheritedRenewsAt: renewsAt)
+            {
+                return snapshot
+            }
+        }
+
+        return nil
+    }
+
+    private static func parseUsageFromCandidates(
+        object: Any,
+        now: Date,
+        inheritedRenewsAt: Date? = nil) -> OpenCodeGoUsageSnapshot?
+    {
+        let candidates = self.collectWindowCandidates(object: object, now: now)
+        guard !candidates.isEmpty else { return nil }
+
+        let rollingCandidates = candidates.filter { candidate in
+            candidate.pathLower.contains("rolling") ||
+                candidate.pathLower.contains("hour") ||
+                candidate.pathLower.contains("5h") ||
+                candidate.pathLower.contains("5-hour")
+        }
+        let weeklyCandidates = candidates.filter { candidate in
+            candidate.pathLower.contains("weekly") ||
+                candidate.pathLower.contains("week")
+        }
+        let monthlyCandidates = candidates.filter { candidate in
+            candidate.pathLower.contains("monthly") ||
+                candidate.pathLower.contains("month")
+        }
+
+        let rolling = self.pickCandidate(
+            preferred: rollingCandidates,
+            fallback: candidates,
+            pickShorter: true)
+        let weekly = self.pickCandidate(
+            from: weeklyCandidates.filter { candidate in
+                candidate.id != rolling?.id
+            },
+            pickShorter: false)
+        let monthly = self.pickCandidate(
+            from: monthlyCandidates.filter { candidate in
+                candidate.id != rolling?.id && candidate.id != weekly?.id
+            },
+            pickShorter: false)
+
+        guard let rolling, let weekly else { return nil }
+
+        let renewsAt = self.dateValue(from: self.value(from: object as? [String: Any] ?? [:], keys: self.renewAtKeys))
+            ?? inheritedRenewsAt
+        return OpenCodeGoUsageSnapshot(
+            hasMonthlyUsage: monthly != nil,
+            rollingUsagePercent: rolling.percent,
+            weeklyUsagePercent: weekly.percent,
+            monthlyUsagePercent: monthly?.percent ?? 0,
+            rollingResetInSec: rolling.resetInSec,
+            weeklyResetInSec: weekly.resetInSec,
+            monthlyResetInSec: monthly?.resetInSec ?? 0,
+            renewsAt: renewsAt,
+            updatedAt: now)
+    }
+
+    private struct WindowCandidate {
+        let id: UUID
+        let percent: Double
+        let resetInSec: Int
+        let pathLower: String
+    }
+
+    private static func collectWindowCandidates(object: Any, now: Date) -> [WindowCandidate] {
+        var candidates: [WindowCandidate] = []
+        self.collectWindowCandidates(object: object, now: now, path: [], out: &candidates)
+        return candidates
+    }
+
+    private static func collectWindowCandidates(
+        object: Any,
+        now: Date,
+        path: [String],
+        out: inout [WindowCandidate])
+    {
+        if let dict = object as? [String: Any] {
+            if let window = self.parseWindow(dict, now: now) {
+                let pathLower = path.joined(separator: ".").lowercased()
+                out.append(WindowCandidate(
+                    id: UUID(),
+                    percent: window.percent,
+                    resetInSec: window.resetInSec,
+                    pathLower: pathLower))
+            }
+            for (key, value) in dict {
+                self.collectWindowCandidates(object: value, now: now, path: path + [key], out: &out)
+            }
+            return
+        }
+
+        if let array = object as? [Any] {
+            for (index, value) in array.enumerated() {
+                self.collectWindowCandidates(
+                    object: value,
+                    now: now,
+                    path: path + ["[\(index)]"],
+                    out: &out)
+            }
+        }
+    }
+
+    private static func pickCandidate(
+        preferred: [WindowCandidate],
+        fallback: [WindowCandidate],
+        pickShorter: Bool,
+        excluding excluded: UUID? = nil) -> WindowCandidate?
+    {
+        let filteredPreferred = preferred.filter { $0.id != excluded }
+        if let picked = self.pickCandidate(from: filteredPreferred, pickShorter: pickShorter) {
+            return picked
+        }
+        let filteredFallback = fallback.filter { $0.id != excluded }
+        return self.pickCandidate(from: filteredFallback, pickShorter: pickShorter)
+    }
+
+    private static func pickCandidate(from candidates: [WindowCandidate], pickShorter: Bool) -> WindowCandidate? {
+        guard !candidates.isEmpty else { return nil }
+        let comparator: (WindowCandidate, WindowCandidate) -> Bool = { lhs, rhs in
+            if pickShorter {
+                if lhs.resetInSec == rhs.resetInSec { return lhs.percent > rhs.percent }
+                return lhs.resetInSec < rhs.resetInSec
+            }
+            if lhs.resetInSec == rhs.resetInSec { return lhs.percent > rhs.percent }
+            return lhs.resetInSec > rhs.resetInSec
+        }
+        return candidates.min(by: comparator)
+    }
+
+    private static func firstDict(from dict: [String: Any], keys: [String]) -> [String: Any]? {
+        for key in keys {
+            if let value = dict[key] as? [String: Any] {
+                return value
+            }
+        }
+        return nil
+    }
+
+    private static func buildSnapshot(
+        rolling: [String: Any],
+        weekly: [String: Any],
+        monthly: [String: Any]?,
+        now: Date,
+        renewsAt: Date? = nil) -> OpenCodeGoUsageSnapshot?
+    {
+        guard let rollingWindow = self.parseWindow(rolling, now: now),
+              let weeklyWindow = self.parseWindow(weekly, now: now)
+        else {
+            return nil
+        }
+
+        let monthlyWindow = monthly.flatMap { self.parseWindow($0, now: now) }
+
+        return OpenCodeGoUsageSnapshot(
+            hasMonthlyUsage: monthlyWindow != nil,
+            rollingUsagePercent: rollingWindow.percent,
+            weeklyUsagePercent: weeklyWindow.percent,
+            monthlyUsagePercent: monthlyWindow?.percent ?? 0,
+            rollingResetInSec: rollingWindow.resetInSec,
+            weeklyResetInSec: weeklyWindow.resetInSec,
+            monthlyResetInSec: monthlyWindow?.resetInSec ?? 0,
+            renewsAt: renewsAt,
+            updatedAt: now)
+    }
+
+    private static func parseWindow(_ dict: [String: Any], now: Date) -> (percent: Double, resetInSec: Int)? {
+        var percent: Double?
+
+        for key in self.percentKeys {
+            if let value = self.doubleValue(from: dict[key]) {
+                percent = value
+                break
+            }
+        }
+
+        if percent == nil {
+            let usedKeys = ["used", "usage", "consumed", "count", "usedTokens"]
+            let limitKeys = ["limit", "total", "quota", "max", "cap", "tokenLimit"]
+            var used: Double?
+            for key in usedKeys {
+                if let value = self.doubleValue(from: dict[key]) {
+                    used = value
+                    break
+                }
+            }
+            var limit: Double?
+            for key in limitKeys {
+                if let value = self.doubleValue(from: dict[key]) {
+                    limit = value
+                    break
+                }
+            }
+            if let used, let limit, limit > 0 {
+                percent = (used / limit) * 100
+            }
+        }
+
+        guard var resolvedPercent = percent else { return nil }
+        if resolvedPercent <= 1.0, resolvedPercent >= 0 {
+            resolvedPercent *= 100
+        }
+        resolvedPercent = max(0, min(100, resolvedPercent))
+
+        var resetInSec: Int?
+        for key in self.resetInKeys {
+            if let value = self.intValue(from: dict[key]) {
+                resetInSec = value
+                break
+            }
+        }
+
+        if resetInSec == nil {
+            for key in self.resetAtKeys {
+                if let resetAt = self.dateValue(from: dict[key]) {
+                    resetInSec = max(0, Int(resetAt.timeIntervalSince(now)))
+                    break
+                }
+            }
+        }
+
+        let resolvedReset = max(0, resetInSec ?? 0)
+        return (resolvedPercent, resolvedReset)
+    }
+
+    private static func fetchServerText(
+        request serverRequest: ServerRequest,
+        cookieHeader: String,
+        timeout: TimeInterval,
+        session: URLSession) async throws -> String
+    {
+        let url = self.serverRequestURL(
+            serverID: serverRequest.serverID,
+            args: serverRequest.args,
+            method: serverRequest.method)
+        var urlRequest = URLRequest(url: url)
+        urlRequest.httpMethod = serverRequest.method
+        urlRequest.timeoutInterval = timeout
+        urlRequest.setValue(cookieHeader, forHTTPHeaderField: "Cookie")
+        urlRequest.setValue(serverRequest.serverID, forHTTPHeaderField: "X-Server-Id")
+        urlRequest.setValue("server-fn:\(UUID().uuidString)", forHTTPHeaderField: "X-Server-Instance")
+        urlRequest.setValue(self.userAgent, forHTTPHeaderField: "User-Agent")
+        urlRequest.setValue(self.baseURL.absoluteString, forHTTPHeaderField: "Origin")
+        urlRequest.setValue(serverRequest.referer.absoluteString, forHTTPHeaderField: "Referer")
+        urlRequest.setValue("text/javascript, application/json;q=0.9, */*;q=0.8", forHTTPHeaderField: "Accept")
+        if serverRequest.method.uppercased() != "GET",
+           let args = serverRequest.args
+        {
+            urlRequest.httpBody = args.data(using: .utf8)
+            urlRequest.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        }
+
+        let httpResponse = try await session.response(for: urlRequest)
+
+        guard httpResponse.statusCode == 200 else {
+            let bodyText = String(data: httpResponse.data, encoding: .utf8) ?? ""
+            let contentType = httpResponse.response.value(forHTTPHeaderField: "Content-Type") ?? "unknown"
+            let dataLength = httpResponse.data.count
+            Self.log.error(
+                "OpenCode Go returned \(httpResponse.statusCode) (type=\(contentType) length=\(dataLength))")
+            if self.looksSignedOut(text: bodyText) {
+                throw OpenCodeGoUsageError.invalidCredentials
+            }
+            if httpResponse.statusCode == 401 || httpResponse.statusCode == 403 {
+                throw OpenCodeGoUsageError.invalidCredentials
+            }
+            if let message = self.extractServerErrorMessage(from: bodyText) {
+                throw OpenCodeGoUsageError.apiError("HTTP \(httpResponse.statusCode): \(message)")
+            }
+            throw OpenCodeGoUsageError.apiError("HTTP \(httpResponse.statusCode)")
+        }
+
+        guard let text = String(data: httpResponse.data, encoding: .utf8) else {
+            throw OpenCodeGoUsageError.parseFailed("Response was not UTF-8.")
+        }
+        return text
+    }
+
+    static func fetchPageText(
+        url: URL,
+        cookieHeader: String,
+        timeout: TimeInterval,
+        session: URLSession) async throws -> String
+    {
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.timeoutInterval = timeout
+        request.setValue(cookieHeader, forHTTPHeaderField: "Cookie")
+        request.setValue(self.userAgent, forHTTPHeaderField: "User-Agent")
+        request.setValue(
+            "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+            forHTTPHeaderField: "Accept")
+
+        let httpResponse = try await session.response(for: request)
+        guard httpResponse.statusCode == 200 else {
+            let bodyText = String(data: httpResponse.data, encoding: .utf8) ?? ""
+            if self.looksSignedOut(text: bodyText) {
+                throw OpenCodeGoUsageError.invalidCredentials
+            }
+            if httpResponse.statusCode == 401 || httpResponse.statusCode == 403 {
+                throw OpenCodeGoUsageError.invalidCredentials
+            }
+            if let message = self.extractServerErrorMessage(from: bodyText) {
+                throw OpenCodeGoUsageError.apiError("HTTP \(httpResponse.statusCode): \(message)")
+            }
+            throw OpenCodeGoUsageError.apiError("HTTP \(httpResponse.statusCode)")
+        }
+        guard let text = String(data: httpResponse.data, encoding: .utf8) else {
+            throw OpenCodeGoUsageError.parseFailed("Response was not UTF-8.")
+        }
+        return text
+    }
+
+    private static func serverRequestURL(serverID: String, args: String?, method: String) -> URL {
+        guard method.uppercased() == "GET" else {
+            return self.serverURL
+        }
+
+        var components = URLComponents(url: self.serverURL, resolvingAgainstBaseURL: false)
+        var queryItems = [URLQueryItem(name: "id", value: serverID)]
+        if let args, !args.isEmpty {
+            queryItems.append(URLQueryItem(name: "args", value: args))
+        }
+        components?.queryItems = queryItems
+        return components?.url ?? self.serverURL
+    }
+
+    static func looksSignedOut(text: String) -> Bool {
+        let lower = text.lowercased()
+        return lower.contains("login") ||
+            lower.contains("sign in") ||
+            lower.contains("auth/authorize") ||
+            lower.contains("not associated with an account") ||
+            lower.contains("actor of type \"public\"")
+    }
+
+    private static func extractServerErrorMessage(from text: String) -> String? {
+        guard let data = text.data(using: .utf8),
+              let object = try? JSONSerialization.jsonObject(with: data, options: [])
+        else {
+            if let match = text.range(of: #"(?i)<title>([^<]+)</title>"#, options: .regularExpression) {
+                return String(text[match].dropFirst(7).dropLast(8)).trimmingCharacters(in: .whitespacesAndNewlines)
+            }
+            return nil
+        }
+
+        guard let dict = object as? [String: Any] else { return nil }
+        if let message = dict["message"] as? String, !message.isEmpty {
+            return message
+        }
+        if let error = dict["error"] as? String, !error.isEmpty {
+            return error
+        }
+        if let detail = dict["detail"] as? String, !detail.isEmpty {
+            return detail
+        }
+        return nil
+    }
+
+    private static func extractDouble(pattern: String, text: String) -> Double? {
+        guard let regex = try? NSRegularExpression(pattern: pattern, options: []) else { return nil }
+        let nsrange = NSRange(text.startIndex..<text.endIndex, in: text)
+        guard let match = regex.firstMatch(in: text, options: [], range: nsrange),
+              let range = Range(match.range(at: 1), in: text)
+        else {
+            return nil
+        }
+        return Double(text[range])
+    }
+
+    private static func extractInt(pattern: String, text: String) -> Int? {
+        guard let regex = try? NSRegularExpression(pattern: pattern, options: []) else { return nil }
+        let nsrange = NSRange(text.startIndex..<text.endIndex, in: text)
+        guard let match = regex.firstMatch(in: text, options: [], range: nsrange),
+              let range = Range(match.range(at: 1), in: text)
+        else {
+            return nil
+        }
+        return Int(text[range])
+    }
+
+    private static func doubleValue(from value: Any?) -> Double? {
+        switch value {
+        case let number as Double:
+            number
+        case let number as NSNumber:
+            number.doubleValue
+        case let string as String:
+            Double(string.trimmingCharacters(in: .whitespacesAndNewlines))
+        default:
+            nil
+        }
+    }
+
+    private static func intValue(from value: Any?) -> Int? {
+        switch value {
+        case let number as Int:
+            number
+        case let number as NSNumber:
+            number.intValue
+        case let string as String:
+            Int(string.trimmingCharacters(in: .whitespacesAndNewlines))
+        default:
+            nil
+        }
+    }
+
+    private static func value(from dict: [String: Any], keys: [String]) -> Any? {
+        for key in keys {
+            if let value = dict[key] {
+                return value
+            }
+        }
+        return nil
+    }
+
+    private static func dateValue(from value: Any?) -> Date? {
+        guard let value else { return nil }
+        if let number = self.doubleValue(from: value) {
+            if number > 1_000_000_000_000 {
+                return Date(timeIntervalSince1970: number / 1000)
+            }
+            if number > 1_000_000_000 {
+                return Date(timeIntervalSince1970: number)
+            }
+        }
+        if let string = value as? String {
+            if let number = Double(string.trimmingCharacters(in: .whitespacesAndNewlines)) {
+                return self.dateValue(from: number)
+            }
+            let formatter = ISO8601DateFormatter()
+            formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+            if let parsed = formatter.date(from: string) {
+                return parsed
+            }
+        }
+        return nil
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/OpenCodeGo/OpenCodeGoUsageSnapshot.swift b/Sources/CodexBarCore/Providers/OpenCodeGo/OpenCodeGoUsageSnapshot.swift
new file mode 100644
index 0000000000..d1c1a2ce2d
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/OpenCodeGo/OpenCodeGoUsageSnapshot.swift
@@ -0,0 +1,136 @@
+import Foundation
+
+public struct OpenCodeGoUsageSnapshot: Sendable {
+    public let isBalanceOnly: Bool
+    public let hasMonthlyUsage: Bool
+    public let rollingUsagePercent: Double
+    public let weeklyUsagePercent: Double
+    public let monthlyUsagePercent: Double
+    public let rollingResetInSec: Int
+    public let weeklyResetInSec: Int
+    public let monthlyResetInSec: Int
+    public let zenBalanceUSD: Double?
+    public let renewsAt: Date?
+    public let updatedAt: Date
+
+    public init(
+        isBalanceOnly: Bool = false,
+        hasMonthlyUsage: Bool,
+        rollingUsagePercent: Double,
+        weeklyUsagePercent: Double,
+        monthlyUsagePercent: Double,
+        rollingResetInSec: Int,
+        weeklyResetInSec: Int,
+        monthlyResetInSec: Int,
+        zenBalanceUSD: Double? = nil,
+        renewsAt: Date? = nil,
+        updatedAt: Date)
+    {
+        self.isBalanceOnly = isBalanceOnly
+        self.hasMonthlyUsage = hasMonthlyUsage
+        self.rollingUsagePercent = rollingUsagePercent
+        self.weeklyUsagePercent = weeklyUsagePercent
+        self.monthlyUsagePercent = monthlyUsagePercent
+        self.rollingResetInSec = rollingResetInSec
+        self.weeklyResetInSec = weeklyResetInSec
+        self.monthlyResetInSec = monthlyResetInSec
+        self.zenBalanceUSD = zenBalanceUSD
+        self.renewsAt = renewsAt
+        self.updatedAt = updatedAt
+    }
+
+    public static func zenBalanceOnly(balanceUSD: Double, updatedAt: Date) -> OpenCodeGoUsageSnapshot {
+        OpenCodeGoUsageSnapshot(
+            isBalanceOnly: true,
+            hasMonthlyUsage: false,
+            rollingUsagePercent: 0,
+            weeklyUsagePercent: 0,
+            monthlyUsagePercent: 0,
+            rollingResetInSec: 0,
+            weeklyResetInSec: 0,
+            monthlyResetInSec: 0,
+            zenBalanceUSD: balanceUSD,
+            updatedAt: updatedAt)
+    }
+
+    public func toUsageSnapshot() -> UsageSnapshot {
+        if self.isBalanceOnly {
+            return UsageSnapshot(
+                primary: nil,
+                secondary: nil,
+                providerCost: self.providerCostSnapshot,
+                updatedAt: self.updatedAt,
+                identity: nil)
+        }
+
+        let rollingReset = self.updatedAt.addingTimeInterval(TimeInterval(self.rollingResetInSec))
+        let weeklyReset = self.updatedAt.addingTimeInterval(TimeInterval(self.weeklyResetInSec))
+
+        let primary = RateWindow(
+            usedPercent: self.rollingUsagePercent,
+            windowMinutes: 5 * 60,
+            resetsAt: rollingReset,
+            resetDescription: nil)
+        let secondary = RateWindow(
+            usedPercent: self.weeklyUsagePercent,
+            windowMinutes: 7 * 24 * 60,
+            resetsAt: weeklyReset,
+            resetDescription: nil)
+        let tertiary: RateWindow?
+        if self.hasMonthlyUsage {
+            let monthlyReset = self.updatedAt.addingTimeInterval(TimeInterval(self.monthlyResetInSec))
+            tertiary = RateWindow(
+                usedPercent: self.monthlyUsagePercent,
+                windowMinutes: 30 * 24 * 60,
+                resetsAt: monthlyReset,
+                resetDescription: nil)
+        } else {
+            tertiary = nil
+        }
+
+        var extraWindows: [NamedRateWindow]?
+        if let renewsAt = self.renewsAt {
+            let renewalWindow = RateWindow(
+                usedPercent: 0,
+                windowMinutes: nil,
+                resetsAt: renewsAt,
+                resetDescription: nil)
+            extraWindows = [NamedRateWindow(id: "renewal", title: "Renews", window: renewalWindow)]
+        }
+
+        return UsageSnapshot(
+            primary: primary,
+            secondary: secondary,
+            tertiary: tertiary,
+            extraRateWindows: extraWindows,
+            providerCost: self.providerCostSnapshot,
+            updatedAt: self.updatedAt,
+            identity: nil)
+    }
+
+    private var providerCostSnapshot: ProviderCostSnapshot? {
+        self.zenBalanceUSD.map {
+            ProviderCostSnapshot(
+                used: $0,
+                limit: 0,
+                currencyCode: "USD",
+                period: "Zen balance",
+                updatedAt: self.updatedAt)
+        }
+    }
+
+    public func withZenBalanceUSD(_ balance: Double?) -> OpenCodeGoUsageSnapshot {
+        OpenCodeGoUsageSnapshot(
+            isBalanceOnly: self.isBalanceOnly,
+            hasMonthlyUsage: self.hasMonthlyUsage,
+            rollingUsagePercent: self.rollingUsagePercent,
+            weeklyUsagePercent: self.weeklyUsagePercent,
+            monthlyUsagePercent: self.monthlyUsagePercent,
+            rollingResetInSec: self.rollingResetInSec,
+            weeklyResetInSec: self.weeklyResetInSec,
+            monthlyResetInSec: self.monthlyResetInSec,
+            zenBalanceUSD: balance,
+            renewsAt: self.renewsAt,
+            updatedAt: self.updatedAt)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/OpenCodeGo/OpenCodeGoZenBalanceFetcher.swift b/Sources/CodexBarCore/Providers/OpenCodeGo/OpenCodeGoZenBalanceFetcher.swift
new file mode 100644
index 0000000000..cbc0b3f4e0
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/OpenCodeGo/OpenCodeGoZenBalanceFetcher.swift
@@ -0,0 +1,166 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+private final class OpenCodeGoZenBalanceTaskRace: @unchecked Sendable {
+    private let lock = NSLock()
+    private let sourceTask: Task<Double?, Error>
+    private var result: Result<Double?, Error>?
+    private var continuation: CheckedContinuation<Double?, Error>?
+    private var observerTask: Task<Void, Never>?
+    private var timeoutTask: Task<Void, Never>?
+
+    init(sourceTask: Task<Double?, Error>) {
+        self.sourceTask = sourceTask
+    }
+
+    func value(timeout: Duration? = nil) async throws -> Double? {
+        try await withTaskCancellationHandler {
+            try await withCheckedThrowingContinuation { continuation in
+                self.lock.lock()
+                if let result = self.result {
+                    self.lock.unlock()
+                    continuation.resume(with: result)
+                    return
+                }
+
+                self.continuation = continuation
+                let sourceTask = self.sourceTask
+                self.observerTask = Task { [weak self] in
+                    do {
+                        let value = try await sourceTask.value
+                        self?.resolve(.success(value), cancelSource: false)
+                    } catch {
+                        self?.resolve(.failure(error), cancelSource: false)
+                    }
+                }
+                if let timeout {
+                    self.timeoutTask = Task { [weak self] in
+                        do {
+                            try await Task.sleep(for: timeout)
+                            self?.resolve(.success(nil), cancelSource: true)
+                        } catch {
+                            // The source completed or the caller canceled the race.
+                        }
+                    }
+                }
+                self.lock.unlock()
+            }
+        } onCancel: {
+            self.resolve(.failure(CancellationError()), cancelSource: true)
+        }
+    }
+
+    private func resolve(_ result: Result<Double?, Error>, cancelSource: Bool) {
+        self.lock.lock()
+        guard self.result == nil else {
+            self.lock.unlock()
+            return
+        }
+
+        self.result = result
+        let continuation = self.continuation
+        self.continuation = nil
+        let observerTask = self.observerTask
+        let timeoutTask = self.timeoutTask
+        self.observerTask = nil
+        self.timeoutTask = nil
+        self.lock.unlock()
+
+        if cancelSource {
+            self.sourceTask.cancel()
+        }
+        observerTask?.cancel()
+        timeoutTask?.cancel()
+        continuation?.resume(with: result)
+    }
+}
+
+extension OpenCodeGoUsageFetcher {
+    static let optionalZenBalanceTimeout: TimeInterval = 5
+    static let optionalZenBalanceStartDelay: Duration = .milliseconds(25)
+    static let optionalZenBalanceJoinGrace: Duration = .milliseconds(250)
+
+    public static func zenDashboardURL(workspaceID raw: String?) -> URL {
+        guard let workspaceID = self.normalizeWorkspaceID(raw),
+              let url = URL(string: "https://opencode.ai/workspace/\(workspaceID)")
+        else {
+            return URL(string: "https://opencode.ai")!
+        }
+        return url
+    }
+
+    static func fetchOptionalZenBalance(
+        workspaceID: String,
+        cookieHeader: String,
+        timeout: TimeInterval,
+        session: URLSession) async throws -> Double?
+    {
+        do {
+            let balance = try await self.fetchZenBalance(
+                workspaceID: workspaceID,
+                cookieHeader: cookieHeader,
+                timeout: timeout,
+                session: session)
+            try Task.checkCancellation()
+            return balance
+        } catch is CancellationError {
+            throw CancellationError()
+        } catch {
+            if Task.isCancelled {
+                throw CancellationError()
+            }
+            return nil
+        }
+    }
+
+    static func completedOptionalZenBalance(from task: Task<Double?, Error>) async throws -> Double? {
+        let race = OpenCodeGoZenBalanceTaskRace(sourceTask: task)
+        do {
+            return try await race.value(timeout: self.optionalZenBalanceJoinGrace)
+        } catch is CancellationError {
+            throw CancellationError()
+        } catch {
+            return nil
+        }
+    }
+
+    static func completedRequiredZenBalance(from task: Task<Double?, Error>) async throws -> Double? {
+        let race = OpenCodeGoZenBalanceTaskRace(sourceTask: task)
+        return try await race.value()
+    }
+
+    static func parseZenBalance(text: String) -> Double? {
+        OpenCodeGoZenBalanceParser.parse(text: text)
+    }
+
+    static func fetchZenBalance(
+        workspaceID: String,
+        cookieHeader: String,
+        timeout: TimeInterval,
+        session: URLSession) async throws -> Double?
+    {
+        let text = try await self.fetchPageText(
+            url: self.zenDashboardURL(workspaceID: workspaceID),
+            cookieHeader: cookieHeader,
+            timeout: timeout,
+            session: session)
+        if self.looksSignedOut(text: text) {
+            throw OpenCodeGoUsageError.invalidCredentials
+        }
+        if let balance = self.parseZenBalance(text: text) {
+            return balance
+        }
+
+        let billingText = try await self.fetchZenBillingText(
+            workspaceID: workspaceID,
+            cookieHeader: cookieHeader,
+            timeout: timeout,
+            session: session)
+        if self.looksSignedOut(text: billingText) {
+            throw OpenCodeGoUsageError.invalidCredentials
+        }
+        return OpenCodeGoZenBalanceParser.parseBillingServerResponse(text: billingText)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/OpenCodeGo/OpenCodeGoZenBalanceParser.swift b/Sources/CodexBarCore/Providers/OpenCodeGo/OpenCodeGoZenBalanceParser.swift
new file mode 100644
index 0000000000..45fc7cb8c4
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/OpenCodeGo/OpenCodeGoZenBalanceParser.swift
@@ -0,0 +1,155 @@
+import Foundation
+
+enum OpenCodeGoZenBalanceParser {
+    private static let billingScale = 100_000_000.0
+
+    static func parse(text: String) -> Double? {
+        if let value = self.parseJSON(text: text) {
+            return value
+        }
+        let localizedPattern = [
+            #"(?i)(?:current\s+balance|zen\s+balance|現在の残高)"#,
+            #"[^$]{0,80}\$\s*([0-9][0-9,]*(?:\.[0-9]+)?)"#,
+        ].joined()
+        if let value = self.extractDollarValue(pattern: localizedPattern, text: text) {
+            return value
+        }
+        let nearbyPattern = #"(?i)(?:balance|残高)[\s\S]{0,120}?\$\s*([0-9][0-9,]*(?:\.[0-9]+)?)"#
+        return self.extractDollarValue(pattern: nearbyPattern, text: text)
+    }
+
+    static func parseBillingServerResponse(text: String) -> Double? {
+        if let data = text.data(using: .utf8),
+           let object = try? JSONSerialization.jsonObject(with: data, options: []),
+           let rawBalance = self.findRawBillingBalance(in: object)
+        {
+            return rawBalance / self.billingScale
+        }
+
+        let customerPattern =
+            #"(?:\"customerID\"|customerID)\s*:\s*(?:\$R\[\d+\]\s*=\s*)?\"[^\"]+\""#
+        guard self.containsMatch(pattern: customerPattern, text: text) else {
+            return nil
+        }
+        let pattern = #"(?:\"balance\"|balance)\s*:\s*(?:\$R\[\d+\]\s*=\s*)?(-?[0-9]+(?:\.[0-9]+)?)"#
+        guard let rawBalance = self.extractNumber(pattern: pattern, text: text) else {
+            return nil
+        }
+        return rawBalance / self.billingScale
+    }
+
+    private static func parseJSON(text: String) -> Double? {
+        guard let data = text.data(using: .utf8),
+              let object = try? JSONSerialization.jsonObject(with: data, options: [])
+        else {
+            return nil
+        }
+        return self.findBalanceValue(in: object, path: [])
+    }
+
+    private static func findBalanceValue(in object: Any, path: [String]) -> Double? {
+        if let dict = object as? [String: Any] {
+            for (key, value) in dict {
+                let nextPath = path + [key]
+                if self.isExplicitBalanceAmountKey(key),
+                   let number = self.doubleValue(from: value)
+                {
+                    return number
+                }
+                if let found = self.findBalanceValue(in: value, path: nextPath) {
+                    return found
+                }
+            }
+            return nil
+        }
+        if let array = object as? [Any] {
+            for (index, value) in array.enumerated() {
+                if let found = self.findBalanceValue(in: value, path: path + ["[\(index)]"]) {
+                    return found
+                }
+            }
+        }
+        return nil
+    }
+
+    private static func findRawBillingBalance(in object: Any) -> Double? {
+        if let dict = object as? [String: Any] {
+            if dict["balance"] != nil {
+                guard let customerID = dict["customerID"] as? String,
+                      !customerID.isEmpty
+                else {
+                    return nil
+                }
+                guard let rawBalance = self.doubleValue(from: dict["balance"]) else {
+                    return nil
+                }
+                return rawBalance
+            }
+            for value in dict.values {
+                if let found = self.findRawBillingBalance(in: value) {
+                    return found
+                }
+            }
+        } else if let array = object as? [Any] {
+            for value in array {
+                if let found = self.findRawBillingBalance(in: value) {
+                    return found
+                }
+            }
+        }
+        return nil
+    }
+
+    private static func containsMatch(pattern: String, text: String) -> Bool {
+        guard let regex = try? NSRegularExpression(pattern: pattern, options: []) else { return false }
+        let nsrange = NSRange(text.startIndex..<text.endIndex, in: text)
+        return regex.firstMatch(in: text, options: [], range: nsrange) != nil
+    }
+
+    private static func isExplicitBalanceAmountKey(_ key: String) -> Bool {
+        let normalized = key
+            .lowercased()
+            .filter { $0.isLetter || $0.isNumber }
+        return [
+            "zenbalance",
+            "zencurrentbalance",
+            "currentbalance",
+            "currentbalanceusd",
+            "balanceusd",
+            "usdbalance",
+        ].contains(normalized)
+    }
+
+    private static func extractDollarValue(pattern: String, text: String) -> Double? {
+        self.extractNumber(pattern: pattern, text: text)
+    }
+
+    private static func extractNumber(pattern: String, text: String) -> Double? {
+        guard let regex = try? NSRegularExpression(pattern: pattern, options: []) else { return nil }
+        let nsrange = NSRange(text.startIndex..<text.endIndex, in: text)
+        guard let match = regex.firstMatch(in: text, options: [], range: nsrange),
+              let range = Range(match.range(at: 1), in: text)
+        else {
+            return nil
+        }
+        return Double(text[range].replacingOccurrences(of: ",", with: ""))
+    }
+
+    private static func doubleValue(from value: Any?) -> Double? {
+        switch value {
+        case is Bool:
+            nil
+        case let number as Double:
+            number
+        case let number as NSNumber:
+            number.doubleValue
+        case let string as String:
+            Double(
+                string
+                    .trimmingCharacters(in: .whitespacesAndNewlines)
+                    .replacingOccurrences(of: ",", with: ""))
+        default:
+            nil
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/OpenRouter/OpenRouterProviderDescriptor.swift b/Sources/CodexBarCore/Providers/OpenRouter/OpenRouterProviderDescriptor.swift
index 7119541985..7cc05ef485 100644
--- a/Sources/CodexBarCore/Providers/OpenRouter/OpenRouterProviderDescriptor.swift
+++ b/Sources/CodexBarCore/Providers/OpenRouter/OpenRouterProviderDescriptor.swift
@@ -1,9 +1,8 @@
-import CodexBarMacroSupport
 import Foundation
 
-@ProviderDescriptorRegistration
-@ProviderDescriptorDefinition
 public enum OpenRouterProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
     static func makeDescriptor() -> ProviderDescriptor {
         ProviderDescriptor(
             id: .openrouter,
@@ -31,9 +30,15 @@ public enum OpenRouterProviderDescriptor {
             tokenCost: ProviderTokenCostConfig(
                 supportsTokenCost: false,
                 noDataMessage: { "OpenRouter cost summary is not yet supported." }),
-            fetchPlan: ProviderFetchPlan(
-                sourceModes: [.auto, .api],
-                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [OpenRouterAPIFetchStrategy()] })),
+            fetchPlan: .apiToken(
+                strategyID: "openrouter.api",
+                resolveToken: { ProviderTokenResolver.openRouterToken(environment: $0) },
+                missingCredentialsError: { OpenRouterSettingsError.missingToken },
+                loadUsage: { apiKey, context in
+                    try await OpenRouterUsageFetcher.fetchUsage(
+                        apiKey: apiKey,
+                        environment: context.env).toUsageSnapshot()
+                }),
             cli: ProviderCLIConfig(
                 name: "openrouter",
                 aliases: ["or"],
@@ -41,43 +46,17 @@ public enum OpenRouterProviderDescriptor {
     }
 }
 
-struct OpenRouterAPIFetchStrategy: ProviderFetchStrategy {
-    let id: String = "openrouter.api"
-    let kind: ProviderFetchKind = .apiToken
-
-    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
-        Self.resolveToken(environment: context.env) != nil
-    }
-
-    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
-        guard let apiKey = Self.resolveToken(environment: context.env) else {
-            throw OpenRouterSettingsError.missingToken
-        }
-        let usage = try await OpenRouterUsageFetcher.fetchUsage(
-            apiKey: apiKey,
-            environment: context.env)
-        return self.makeResult(
-            usage: usage.toUsageSnapshot(),
-            sourceLabel: "api")
-    }
-
-    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
-        false
-    }
-
-    private static func resolveToken(environment: [String: String]) -> String? {
-        ProviderTokenResolver.openRouterToken(environment: environment)
-    }
-}
-
 /// Errors related to OpenRouter settings
-public enum OpenRouterSettingsError: LocalizedError, Sendable {
+public enum OpenRouterSettingsError: LocalizedError, Sendable, Equatable {
     case missingToken
+    case invalidEndpointOverride(String)
 
     public var errorDescription: String? {
         switch self {
         case .missingToken:
             "OpenRouter API token not configured. Set OPENROUTER_API_KEY environment variable or configure in Settings."
+        case let .invalidEndpointOverride(key):
+            "OpenRouter endpoint override \(key) must use HTTPS or a bare host."
         }
     }
 }
diff --git a/Sources/CodexBarCore/Providers/OpenRouter/OpenRouterSettingsReader.swift b/Sources/CodexBarCore/Providers/OpenRouter/OpenRouterSettingsReader.swift
index e5e3f4d78e..3219e56c0d 100644
--- a/Sources/CodexBarCore/Providers/OpenRouter/OpenRouterSettingsReader.swift
+++ b/Sources/CodexBarCore/Providers/OpenRouter/OpenRouterSettingsReader.swift
@@ -12,14 +12,20 @@ public enum OpenRouterSettingsReader {
 
     /// Returns the API URL, defaulting to production endpoint
     public static func apiURL(environment: [String: String] = ProcessInfo.processInfo.environment) -> URL {
-        if let override = environment["OPENROUTER_API_URL"],
-           let url = URL(string: cleaned(override) ?? "")
-        {
-            return url
+        if let override = self.validAPIURL(environment: environment) {
+            return override
         }
         return URL(string: "https://openrouter.ai/api/v1")!
     }
 
+    public static func validateEndpointOverrides(
+        environment: [String: String] = ProcessInfo.processInfo.environment) throws
+    {
+        guard let raw = self.cleaned(environment["OPENROUTER_API_URL"]) else { return }
+        guard ProviderEndpointOverrideValidator.normalizedHTTPSURL(from: raw) == nil else { return }
+        throw OpenRouterSettingsError.invalidEndpointOverride("OPENROUTER_API_URL")
+    }
+
     static func cleaned(_ raw: String?) -> String? {
         guard var value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
             return nil
@@ -28,11 +34,15 @@ public enum OpenRouterSettingsReader {
         if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
             (value.hasPrefix("'") && value.hasSuffix("'"))
         {
-            value.removeFirst()
-            value.removeLast()
+            value = String(value.dropFirst().dropLast())
         }
 
         value = value.trimmingCharacters(in: .whitespacesAndNewlines)
         return value.isEmpty ? nil : value
     }
+
+    private static func validAPIURL(environment: [String: String]) -> URL? {
+        guard let raw = self.cleaned(environment["OPENROUTER_API_URL"]) else { return nil }
+        return ProviderEndpointOverrideValidator.normalizedHTTPSURL(from: raw)
+    }
 }
diff --git a/Sources/CodexBarCore/Providers/OpenRouter/OpenRouterUsageStats.swift b/Sources/CodexBarCore/Providers/OpenRouter/OpenRouterUsageStats.swift
index fbcc3e44c5..bfbbacc554 100644
--- a/Sources/CodexBarCore/Providers/OpenRouter/OpenRouterUsageStats.swift
+++ b/Sources/CodexBarCore/Providers/OpenRouter/OpenRouterUsageStats.swift
@@ -45,11 +45,20 @@ public struct OpenRouterKeyData: Decodable, Sendable {
     public let limit: Double?
     /// Current usage
     public let usage: Double?
+    /// API key usage for the current UTC day.
+    public let usageDaily: Double?
+    /// API key usage for the current UTC week.
+    public let usageWeekly: Double?
+    /// API key usage for the current UTC month.
+    public let usageMonthly: Double?
 
     private enum CodingKeys: String, CodingKey {
         case rateLimit = "rate_limit"
         case limit
         case usage
+        case usageDaily = "usage_daily"
+        case usageWeekly = "usage_weekly"
+        case usageMonthly = "usage_monthly"
     }
 }
 
@@ -59,6 +68,11 @@ public struct OpenRouterRateLimit: Codable, Sendable {
     public let requests: Int
     /// Interval for the rate limit (e.g., "10s", "1m")
     public let interval: String
+
+    public init(requests: Int, interval: String) {
+        self.requests = requests
+        self.interval = interval
+    }
 }
 
 public enum OpenRouterKeyQuotaStatus: String, Codable, Sendable {
@@ -76,6 +90,9 @@ public struct OpenRouterUsageSnapshot: Codable, Sendable {
     public let keyDataFetched: Bool
     public let keyLimit: Double?
     public let keyUsage: Double?
+    public let keyUsageDaily: Double?
+    public let keyUsageWeekly: Double?
+    public let keyUsageMonthly: Double?
     public let rateLimit: OpenRouterRateLimit?
     public let updatedAt: Date
 
@@ -87,6 +104,9 @@ public struct OpenRouterUsageSnapshot: Codable, Sendable {
         keyDataFetched: Bool = false,
         keyLimit: Double? = nil,
         keyUsage: Double? = nil,
+        keyUsageDaily: Double? = nil,
+        keyUsageWeekly: Double? = nil,
+        keyUsageMonthly: Double? = nil,
         rateLimit: OpenRouterRateLimit?,
         updatedAt: Date)
     {
@@ -94,9 +114,13 @@ public struct OpenRouterUsageSnapshot: Codable, Sendable {
         self.totalUsage = totalUsage
         self.balance = balance
         self.usedPercent = usedPercent
-        self.keyDataFetched = keyDataFetched || keyLimit != nil || keyUsage != nil
+        self.keyDataFetched = keyDataFetched || keyLimit != nil || keyUsage != nil ||
+            keyUsageDaily != nil || keyUsageWeekly != nil || keyUsageMonthly != nil
         self.keyLimit = keyLimit
         self.keyUsage = keyUsage
+        self.keyUsageDaily = keyUsageDaily
+        self.keyUsageWeekly = keyUsageWeekly
+        self.keyUsageMonthly = keyUsageMonthly
         self.rateLimit = rateLimit
         self.updatedAt = updatedAt
     }
@@ -201,6 +225,7 @@ public struct OpenRouterUsageFetcher: Sendable {
         guard !apiKey.isEmpty else {
             throw OpenRouterUsageError.invalidCredentials
         }
+        try OpenRouterSettingsReader.validateEndpointOverrides(environment: environment)
 
         let baseURL = OpenRouterSettingsReader.apiURL(environment: environment)
         let creditsURL = baseURL.appendingPathComponent("credits")
@@ -216,21 +241,17 @@ public struct OpenRouterUsageFetcher: Sendable {
         let title = Self.sanitizedHeaderValue(environment[self.clientTitleEnvKey]) ?? Self.defaultClientTitle
         request.setValue(title, forHTTPHeaderField: "X-Title")
 
-        let (data, response) = try await URLSession.shared.data(for: request)
-
-        guard let httpResponse = response as? HTTPURLResponse else {
-            throw OpenRouterUsageError.networkError("Invalid response")
-        }
-
-        guard httpResponse.statusCode == 200 else {
+        let response = try await ProviderHTTPClient.shared.response(for: request)
+        let data = response.data
+        guard response.statusCode == 200 else {
             let errorSummary = LogRedactor.redact(Self.sanitizedResponseBodySummary(data))
             if Self.debugFullErrorBodiesEnabled(environment: environment),
                let debugBody = Self.redactedDebugResponseBody(data)
             {
                 Self.log.debug("OpenRouter non-200 body (redacted): \(LogRedactor.redact(debugBody))")
             }
-            Self.log.error("OpenRouter API returned \(httpResponse.statusCode): \(errorSummary)")
-            throw OpenRouterUsageError.apiError("HTTP \(httpResponse.statusCode)")
+            Self.log.error("OpenRouter API returned \(response.statusCode): \(errorSummary)")
+            throw OpenRouterUsageError.apiError("HTTP \(response.statusCode)")
         }
 
         do {
@@ -239,7 +260,7 @@ public struct OpenRouterUsageFetcher: Sendable {
 
             // Optionally fetch key quota/rate-limit info from /key endpoint, but keep this bounded so
             // credits updates are not blocked by a slow or unavailable secondary endpoint.
-            let keyFetch = await fetchKeyData(
+            let keyFetch = try await fetchKeyData(
                 apiKey: apiKey,
                 baseURL: baseURL,
                 timeoutSeconds: Self.rateLimitTimeoutSeconds)
@@ -252,8 +273,13 @@ public struct OpenRouterUsageFetcher: Sendable {
                 keyDataFetched: keyFetch.fetched,
                 keyLimit: keyFetch.data?.limit,
                 keyUsage: keyFetch.data?.usage,
+                keyUsageDaily: keyFetch.data?.usageDaily,
+                keyUsageWeekly: keyFetch.data?.usageWeekly,
+                keyUsageMonthly: keyFetch.data?.usageMonthly,
                 rateLimit: keyFetch.data?.rateLimit,
                 updatedAt: Date())
+        } catch is CancellationError {
+            throw CancellationError()
         } catch let error as DecodingError {
             Self.log.error("OpenRouter JSON decoding error: \(error.localizedDescription)")
             throw OpenRouterUsageError.parseFailed(error.localizedDescription)
@@ -266,7 +292,7 @@ public struct OpenRouterUsageFetcher: Sendable {
     }
 
     /// Fetches key quota/rate-limit info from /key endpoint
-    private struct OpenRouterKeyFetchResult: Sendable {
+    private struct OpenRouterKeyFetchResult {
         let data: OpenRouterKeyData?
         let fetched: Bool
     }
@@ -274,37 +300,47 @@ public struct OpenRouterUsageFetcher: Sendable {
     private static func fetchKeyData(
         apiKey: String,
         baseURL: URL,
-        timeoutSeconds: TimeInterval) async -> OpenRouterKeyFetchResult
+        timeoutSeconds: TimeInterval) async throws -> OpenRouterKeyFetchResult
     {
         let timeout = max(0.1, timeoutSeconds)
-        let timeoutNanoseconds = UInt64(timeout * 1_000_000_000)
-
-        return await withTaskGroup(of: OpenRouterKeyFetchResult.self) { group in
-            group.addTask {
-                await Self.fetchKeyDataRequest(
-                    apiKey: apiKey,
-                    baseURL: baseURL,
-                    timeoutSeconds: timeout)
-            }
-            group.addTask {
-                do {
-                    try await Task.sleep(nanoseconds: timeoutNanoseconds)
-                } catch {
-                    // Cancelled because the /key request finished first.
-                    return OpenRouterKeyFetchResult(data: nil, fetched: false)
-                }
-                guard !Task.isCancelled else {
-                    return OpenRouterKeyFetchResult(data: nil, fetched: false)
-                }
-                Self.log.debug("OpenRouter /key enrichment timed out after \(timeout)s")
-                return OpenRouterKeyFetchResult(data: nil, fetched: false)
-            }
+        return try await self.boundedKeyFetch(timeout: .seconds(timeout)) {
+            await Self.fetchKeyDataRequest(
+                apiKey: apiKey,
+                baseURL: baseURL,
+                timeoutSeconds: timeout)
+        }
+    }
 
-            let result = await group.next()
-            group.cancelAll()
-            if let result {
-                return result
-            }
+    static func _boundedKeyFetchForTesting(
+        timeout: Duration,
+        operation: @escaping @Sendable () async -> Void) async throws -> Bool
+    {
+        let result = try await self.boundedKeyFetch(timeout: timeout) {
+            await operation()
+            return OpenRouterKeyFetchResult(data: nil, fetched: true)
+        }
+        return result.fetched
+    }
+
+    private static func boundedKeyFetch(
+        timeout: Duration,
+        operation: @escaping @Sendable () async -> OpenRouterKeyFetchResult) async throws -> OpenRouterKeyFetchResult
+    {
+        let sourceTask = Task<OpenRouterKeyFetchResult, Error> {
+            await operation()
+        }
+        let race = BoundedTaskJoin(sourceTask: sourceTask)
+        switch await race.value(joinGrace: timeout) {
+        case let .value(result):
+            try Task.checkCancellation()
+            return result
+        case .timedOut:
+            try Task.checkCancellation()
+            Self.log.debug("OpenRouter /key enrichment timed out")
+            return OpenRouterKeyFetchResult(data: nil, fetched: false)
+        case .failure:
+            sourceTask.cancel()
+            try Task.checkCancellation()
             return OpenRouterKeyFetchResult(data: nil, fetched: false)
         }
     }
@@ -323,16 +359,13 @@ public struct OpenRouterUsageFetcher: Sendable {
         request.timeoutInterval = timeoutSeconds
 
         do {
-            let (data, response) = try await URLSession.shared.data(for: request)
-
-            guard let httpResponse = response as? HTTPURLResponse,
-                  httpResponse.statusCode == 200
-            else {
+            let response = try await ProviderHTTPClient.shared.response(for: request)
+            guard response.statusCode == 200 else {
                 return OpenRouterKeyFetchResult(data: nil, fetched: false)
             }
 
             let decoder = JSONDecoder()
-            let keyResponse = try decoder.decode(OpenRouterKeyResponse.self, from: data)
+            let keyResponse = try decoder.decode(OpenRouterKeyResponse.self, from: response.data)
             return OpenRouterKeyFetchResult(data: keyResponse.data, fetched: true)
         } catch {
             Self.log.debug("Failed to fetch OpenRouter /key enrichment: \(error.localizedDescription)")
diff --git a/Sources/CodexBarCore/Providers/Perplexity/PerplexityAPIError.swift b/Sources/CodexBarCore/Providers/Perplexity/PerplexityAPIError.swift
new file mode 100644
index 0000000000..35baf93509
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Perplexity/PerplexityAPIError.swift
@@ -0,0 +1,27 @@
+import Foundation
+
+public enum PerplexityAPIError: LocalizedError, Sendable, Equatable {
+    case missingToken
+    case invalidCookie
+    case invalidToken
+    case networkError(String)
+    case apiError(String)
+    case parseFailed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingToken:
+            "Perplexity session token is missing. Please log into Perplexity in your browser."
+        case .invalidCookie:
+            "Perplexity manual cookie header is empty or invalid."
+        case .invalidToken:
+            "Perplexity session token is invalid or expired. Please log in again."
+        case let .networkError(message):
+            "Perplexity network error: \(message)"
+        case let .apiError(message):
+            "Perplexity API error: \(message)"
+        case let .parseFailed(message):
+            "Failed to parse Perplexity usage data: \(message)"
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Perplexity/PerplexityCookieHeader.swift b/Sources/CodexBarCore/Providers/Perplexity/PerplexityCookieHeader.swift
new file mode 100644
index 0000000000..1c66a95f2c
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Perplexity/PerplexityCookieHeader.swift
@@ -0,0 +1,129 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public struct PerplexityCookieOverride: Sendable {
+    public let name: String
+    public let token: String
+    public let requestCookieNames: [String]
+
+    public init(name: String, token: String, requestCookieNames: [String]? = nil) {
+        self.name = name
+        self.token = token
+        self.requestCookieNames = requestCookieNames ?? [name]
+    }
+}
+
+public enum PerplexityCookieHeader {
+    public static let defaultSessionCookieName = "__Secure-next-auth.session-token"
+    public static let supportedSessionCookieNames = [
+        "__Secure-authjs.session-token",
+        "authjs.session-token",
+        "__Secure-next-auth.session-token",
+        "next-auth.session-token",
+    ]
+
+    public static func resolveCookieOverride(context: ProviderFetchContext) -> PerplexityCookieOverride? {
+        if let settings = context.settings?.perplexity, settings.cookieSource == .manual {
+            if let manual = settings.manualCookieHeader, !manual.isEmpty {
+                return self.override(from: manual)
+            }
+        }
+        return nil
+    }
+
+    public static func override(from raw: String?) -> PerplexityCookieOverride? {
+        guard let raw = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !raw.isEmpty else {
+            return nil
+        }
+
+        // Accept bare token value
+        if !raw.contains("="), !raw.contains(";") {
+            return PerplexityCookieOverride(
+                name: self.defaultSessionCookieName,
+                token: raw,
+                requestCookieNames: self.supportedSessionCookieNames)
+        }
+
+        // Extract a supported session cookie from a full cookie string.
+        if let cookie = self.extractSessionCookie(from: raw) {
+            return cookie
+        }
+
+        return nil
+    }
+
+    static func sessionCookie(from cookies: [HTTPCookie]) -> PerplexityCookieOverride? {
+        self.extractSessionCookie(from: cookies.map { (name: $0.name, value: $0.value) })
+    }
+
+    private static func extractSessionCookie(from raw: String) -> PerplexityCookieOverride? {
+        let pairs = raw.split(separator: ";")
+        var cookies: [(name: String, value: String)] = []
+        for pair in pairs {
+            let trimmed = pair.trimmingCharacters(in: .whitespacesAndNewlines)
+            guard !trimmed.isEmpty else { continue }
+            guard let separator = trimmed.firstIndex(of: "=") else { continue }
+            let key = String(trimmed[..<separator]).trimmingCharacters(in: .whitespacesAndNewlines)
+            let value = String(trimmed[trimmed.index(after: separator)...]).trimmingCharacters(
+                in: .whitespacesAndNewlines)
+            guard !key.isEmpty, !value.isEmpty else { continue }
+            cookies.append((name: key, value: value))
+        }
+        return self.extractSessionCookie(from: cookies)
+    }
+
+    private static func extractSessionCookie(from cookies: [(name: String, value: String)])
+    -> PerplexityCookieOverride? {
+        var cookieMap: [String: (name: String, value: String)] = [:]
+        var chunkedCookies: [String: [Int: (name: String, value: String)]] = [:]
+
+        for cookie in cookies {
+            let loweredName = cookie.name.lowercased()
+            cookieMap[loweredName] = cookie
+
+            for expected in self.supportedSessionCookieNames {
+                let loweredExpected = expected.lowercased()
+                let prefix = "\(loweredExpected)."
+                guard loweredName.hasPrefix(prefix) else { continue }
+                let suffix = String(loweredName.dropFirst(prefix.count))
+                guard let index = Int(suffix) else { continue }
+                chunkedCookies[loweredExpected, default: [:]][index] = cookie
+            }
+        }
+
+        for expected in self.supportedSessionCookieNames {
+            let loweredExpected = expected.lowercased()
+            if let match = cookieMap[loweredExpected] {
+                return PerplexityCookieOverride(name: match.name, token: match.value)
+            }
+            if let chunked = self.reassembleChunkedSessionCookie(from: chunkedCookies[loweredExpected]) {
+                return chunked
+            }
+        }
+        return nil
+    }
+
+    private static func reassembleChunkedSessionCookie(
+        from chunks: [Int: (name: String, value: String)]?) -> PerplexityCookieOverride?
+    {
+        guard let chunks,
+              let firstChunk = chunks[0],
+              let maxIndex = chunks.keys.max()
+        else {
+            return nil
+        }
+
+        var tokenParts: [String] = []
+        tokenParts.reserveCapacity(maxIndex + 1)
+        for index in 0...maxIndex {
+            guard let chunk = chunks[index] else { return nil }
+            tokenParts.append(chunk.value)
+        }
+
+        guard let suffixStart = firstChunk.name.lastIndex(of: ".") else { return nil }
+        let baseName = String(firstChunk.name[..<suffixStart])
+        return PerplexityCookieOverride(name: baseName, token: tokenParts.joined())
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Perplexity/PerplexityCookieImporter.swift b/Sources/CodexBarCore/Providers/Perplexity/PerplexityCookieImporter.swift
new file mode 100644
index 0000000000..1c0a7c911e
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Perplexity/PerplexityCookieImporter.swift
@@ -0,0 +1,245 @@
+import Foundation
+
+#if os(macOS)
+import SweetCookieKit
+
+public enum PerplexityCookieImporter {
+    private static let importSessionCacheTTL: TimeInterval = 5
+    private static let importSessionCache = ImportSessionCache(ttl: importSessionCacheTTL)
+    private static let log = CodexBarLog.logger(LogCategories.perplexityCookie)
+    private static let cookieClient = BrowserCookieClient()
+    private static let cookieDomains = ["www.perplexity.ai", "perplexity.ai"]
+    private static let cookieImportOrder: BrowserCookieImportOrder =
+        ProviderDefaults.metadata[.perplexity]?.browserCookieOrder ?? Browser.defaultImportOrder
+    nonisolated(unsafe) static var importSessionOverrideForTesting:
+        ((BrowserDetection, ((String) -> Void)?) throws -> SessionInfo)?
+    nonisolated(unsafe) static var importSessionsOverrideForTesting:
+        ((BrowserDetection, ((String) -> Void)?) throws -> [SessionInfo])?
+
+    public struct SessionInfo: Sendable {
+        public let cookies: [HTTPCookie]
+        public let sourceLabel: String
+
+        public init(cookies: [HTTPCookie], sourceLabel: String) {
+            self.cookies = cookies
+            self.sourceLabel = sourceLabel
+        }
+
+        public var sessionCookie: PerplexityCookieOverride? {
+            PerplexityCookieHeader.sessionCookie(from: self.cookies)
+        }
+
+        public var sessionToken: String? {
+            self.sessionCookie?.token
+        }
+    }
+
+    public static func importSessions(
+        browserDetection: BrowserDetection = BrowserDetection(),
+        logger: ((String) -> Void)? = nil) throws -> [SessionInfo]
+    {
+        if let cached = self.cachedImportSessions() {
+            return cached
+        }
+        if let override = self.importSessionsOverrideForTesting {
+            let sessions = try override(browserDetection, logger)
+            self.storeImportSessions(sessions)
+            return sessions
+        }
+        if let override = self.importSessionOverrideForTesting {
+            let session = try override(browserDetection, logger)
+            let sessions = [session]
+            self.storeImportSessions(sessions)
+            return sessions
+        }
+
+        var sessions: [SessionInfo] = []
+        let candidates = self.cookieImportOrder.cookieImportCandidates(using: browserDetection)
+        for browserSource in candidates {
+            do {
+                let perSource = try self.importSessions(from: browserSource, logger: logger)
+                sessions.append(contentsOf: perSource)
+            } catch {
+                BrowserCookieAccessGate.recordIfNeeded(error)
+                self.emit(
+                    "\(browserSource.displayName) cookie import failed: \(error.localizedDescription)",
+                    logger: logger)
+            }
+        }
+
+        guard !sessions.isEmpty else {
+            throw PerplexityCookieImportError.noCookies
+        }
+        self.storeImportSessions(sessions)
+        return sessions
+    }
+
+    public static func importSessions(
+        from browserSource: Browser,
+        logger: ((String) -> Void)? = nil) throws -> [SessionInfo]
+    {
+        let query = BrowserCookieQuery(domains: self.cookieDomains)
+        let log: (String) -> Void = { msg in self.emit(msg, logger: logger) }
+        let sources = try Self.cookieClient.codexBarRecords(
+            matching: query,
+            in: browserSource,
+            logger: log)
+
+        var sessions: [SessionInfo] = []
+        let grouped = Dictionary(grouping: sources, by: { $0.store.profile.id })
+        let sortedGroups = grouped.values.sorted { lhs, rhs in
+            self.mergedLabel(for: lhs) < self.mergedLabel(for: rhs)
+        }
+
+        for group in sortedGroups where !group.isEmpty {
+            let label = self.mergedLabel(for: group)
+            let mergedRecords = self.mergeRecords(group)
+            guard !mergedRecords.isEmpty else { continue }
+            let httpCookies = BrowserCookieClient.makeHTTPCookies(mergedRecords, origin: query.origin)
+            guard !httpCookies.isEmpty else { continue }
+
+            let session = SessionInfo(cookies: httpCookies, sourceLabel: label)
+            guard let sessionCookie = session.sessionCookie else {
+                continue
+            }
+
+            log("Found \(sessionCookie.name) cookie in \(label)")
+            sessions.append(session)
+        }
+        return sessions
+    }
+
+    public static func importSession(
+        browserDetection: BrowserDetection = BrowserDetection(),
+        logger: ((String) -> Void)? = nil) throws -> SessionInfo
+    {
+        let sessions = try self.importSessions(browserDetection: browserDetection, logger: logger)
+        guard let first = sessions.first else {
+            throw PerplexityCookieImportError.noCookies
+        }
+        return first
+    }
+
+    public static func hasSession(
+        browserDetection: BrowserDetection = BrowserDetection(),
+        logger: ((String) -> Void)? = nil) -> Bool
+    {
+        do {
+            _ = try self.importSession(browserDetection: browserDetection, logger: logger)
+            return true
+        } catch {
+            return false
+        }
+    }
+
+    static func invalidateImportSessionCache() {
+        self.importSessionCache.invalidate()
+    }
+
+    private static func emit(_ message: String, logger: ((String) -> Void)?) {
+        logger?("[perplexity-cookie] \(message)")
+        self.log.debug(message)
+    }
+
+    private static func cachedImportSessions(now: Date = Date()) -> [SessionInfo]? {
+        self.importSessionCache.load(now: now)
+    }
+
+    private static func storeImportSessions(_ sessions: [SessionInfo], now: Date = Date()) {
+        self.importSessionCache.store(sessions, now: now)
+    }
+
+    private static func mergedLabel(for sources: [BrowserCookieStoreRecords]) -> String {
+        guard let base = sources.map(\.label).min() else { return "Unknown" }
+        if base.hasSuffix(" (Network)") {
+            return String(base.dropLast(" (Network)".count))
+        }
+        return base
+    }
+
+    private static func mergeRecords(_ sources: [BrowserCookieStoreRecords]) -> [BrowserCookieRecord] {
+        let sortedSources = sources.sorted { lhs, rhs in
+            self.storePriority(lhs.store.kind) < self.storePriority(rhs.store.kind)
+        }
+        var mergedByKey: [String: BrowserCookieRecord] = [:]
+        for source in sortedSources {
+            for record in source.records {
+                let key = self.recordKey(record)
+                if let existing = mergedByKey[key] {
+                    if self.shouldReplace(existing: existing, candidate: record) {
+                        mergedByKey[key] = record
+                    }
+                } else {
+                    mergedByKey[key] = record
+                }
+            }
+        }
+        return Array(mergedByKey.values)
+    }
+
+    private static func storePriority(_ kind: BrowserCookieStoreKind) -> Int {
+        switch kind {
+        case .network: 0
+        case .primary: 1
+        case .safari: 2
+        }
+    }
+
+    private static func recordKey(_ record: BrowserCookieRecord) -> String {
+        "\(record.name)|\(record.domain)|\(record.path)"
+    }
+
+    private static func shouldReplace(existing: BrowserCookieRecord, candidate: BrowserCookieRecord) -> Bool {
+        switch (existing.expires, candidate.expires) {
+        case let (lhs?, rhs?): rhs > lhs
+        case (nil, .some): true
+        case (.some, nil): false
+        case (nil, nil): false
+        }
+    }
+
+    private final class ImportSessionCache: @unchecked Sendable {
+        private let ttl: TimeInterval
+        private let lock = NSLock()
+        private var entry: (sessions: [SessionInfo], expiresAt: Date)?
+
+        init(ttl: TimeInterval) {
+            self.ttl = ttl
+        }
+
+        func load(now: Date) -> [SessionInfo]? {
+            self.lock.lock()
+            defer { self.lock.unlock() }
+            guard let entry = self.entry else { return nil }
+            guard entry.expiresAt > now else {
+                self.entry = nil
+                return nil
+            }
+            return entry.sessions
+        }
+
+        func store(_ sessions: [SessionInfo], now: Date) {
+            self.lock.lock()
+            defer { self.lock.unlock() }
+            self.entry = (sessions: sessions, expiresAt: now.addingTimeInterval(self.ttl))
+        }
+
+        func invalidate() {
+            self.lock.lock()
+            defer { self.lock.unlock() }
+            self.entry = nil
+        }
+    }
+}
+
+enum PerplexityCookieImportError: LocalizedError {
+    case noCookies
+
+    var errorDescription: String? {
+        switch self {
+        case .noCookies:
+            "No Perplexity session cookies found in browsers. Please log into perplexity.ai."
+        }
+    }
+}
+#endif
diff --git a/Sources/CodexBarCore/Providers/Perplexity/PerplexityModels.swift b/Sources/CodexBarCore/Providers/Perplexity/PerplexityModels.swift
new file mode 100644
index 0000000000..ae4ae592bf
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Perplexity/PerplexityModels.swift
@@ -0,0 +1,29 @@
+import Foundation
+
+public struct PerplexityCreditsResponse: Codable {
+    public let balanceCents: Double
+    public let renewalDateTs: TimeInterval
+    public let currentPeriodPurchasedCents: Double
+    public let creditGrants: [PerplexityCreditGrant]
+    public let totalUsageCents: Double
+
+    enum CodingKeys: String, CodingKey {
+        case balanceCents = "balance_cents"
+        case renewalDateTs = "renewal_date_ts"
+        case currentPeriodPurchasedCents = "current_period_purchased_cents"
+        case creditGrants = "credit_grants"
+        case totalUsageCents = "total_usage_cents"
+    }
+}
+
+public struct PerplexityCreditGrant: Codable {
+    public let type: String
+    public let amountCents: Double
+    public let expiresAtTs: TimeInterval?
+
+    enum CodingKeys: String, CodingKey {
+        case type
+        case amountCents = "amount_cents"
+        case expiresAtTs = "expires_at_ts"
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Perplexity/PerplexityProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Perplexity/PerplexityProviderDescriptor.swift
new file mode 100644
index 0000000000..2700549054
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Perplexity/PerplexityProviderDescriptor.swift
@@ -0,0 +1,237 @@
+import Foundation
+
+public enum PerplexityProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .perplexity,
+            metadata: ProviderMetadata(
+                id: .perplexity,
+                displayName: "Perplexity",
+                sessionLabel: "Credits",
+                weeklyLabel: "Bonus credits",
+                opusLabel: "Purchased",
+                supportsOpus: true,
+                supportsCredits: false,
+                creditsHint: "",
+                toggleTitle: "Show Perplexity usage",
+                cliName: "perplexity",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                browserCookieOrder: nil,
+                dashboardURL: "https://www.perplexity.ai/account/usage",
+                statusPageURL: nil,
+                statusLinkURL: "https://status.perplexity.com/"),
+            branding: ProviderBranding(
+                iconStyle: .perplexity,
+                iconResourceName: "ProviderIcon-perplexity",
+                color: ProviderColor(red: 32 / 255, green: 178 / 255, blue: 170 / 255)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "Perplexity cost tracking is not supported." }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .web],
+                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [PerplexityWebFetchStrategy()] })),
+            cli: ProviderCLIConfig(
+                name: "perplexity",
+                aliases: [],
+                versionDetector: nil))
+    }
+}
+
+struct PerplexityWebFetchStrategy: ProviderFetchStrategy {
+    private enum SessionCookieSource {
+        case manual
+        case cache
+        case browser
+        case environment
+
+        var shouldCacheAfterFetch: Bool {
+            self == .browser
+        }
+    }
+
+    private struct ResolvedSessionCookie {
+        let value: PerplexityCookieOverride
+        let source: SessionCookieSource
+    }
+
+    private struct SessionFetchResult {
+        let snapshot: PerplexityUsageSnapshot
+        let cookie: PerplexityCookieOverride
+    }
+
+    let id: String = "perplexity.web"
+    let kind: ProviderFetchKind = .web
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        guard context.settings?.perplexity?.cookieSource != .off else { return false }
+        if context.settings?.perplexity?.cookieSource == .manual { return true }
+
+        // Priority order mirrors resolveSessionCookie: manual override → cache → browser import → env var
+        if PerplexityCookieHeader.resolveCookieOverride(context: context) != nil {
+            return true
+        }
+
+        if CookieHeaderCache.load(provider: .perplexity) != nil {
+            return true
+        }
+
+        #if os(macOS)
+        if context.settings?.perplexity?.cookieSource != .off {
+            if PerplexityCookieImporter.hasSession() { return true }
+        }
+        #endif
+
+        if PerplexitySettingsReader.sessionToken(environment: context.env) != nil {
+            return true
+        }
+
+        return false
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        let resolvedCookies = try self.resolveSessionCookies(context: context)
+        guard !resolvedCookies.isEmpty else {
+            throw PerplexityAPIError.missingToken
+        }
+        var sawInvalidToken = false
+
+        for resolvedCookie in resolvedCookies {
+            do {
+                let result = try await self.fetchSnapshot(using: resolvedCookie)
+                self.cacheSessionCookieIfNeeded(resolvedCookie, usedCookie: result.cookie, sourceLabel: "web")
+                return self.makeResult(
+                    usage: result.snapshot.toUsageSnapshot(),
+                    sourceLabel: "web")
+            } catch PerplexityAPIError.invalidToken {
+                sawInvalidToken = true
+                if resolvedCookie.source == .cache {
+                    CookieHeaderCache.clear(provider: .perplexity)
+                }
+                continue
+            }
+        }
+
+        if sawInvalidToken {
+            throw PerplexityAPIError.invalidToken
+        }
+        throw PerplexityAPIError.missingToken
+    }
+
+    func shouldFallback(on error: Error, context: ProviderFetchContext) -> Bool {
+        if case PerplexityAPIError.missingToken = error { return false }
+        if case PerplexityAPIError.invalidCookie = error { return false }
+        if case PerplexityAPIError.invalidToken = error { return false }
+        return true
+    }
+
+    private func resolveSessionCookies(context: ProviderFetchContext) throws -> [ResolvedSessionCookie] {
+        guard context.settings?.perplexity?.cookieSource != .off else { return [] }
+
+        if context.settings?.perplexity?.cookieSource == .manual {
+            guard let override = PerplexityCookieHeader.resolveCookieOverride(context: context) else {
+                throw PerplexityAPIError.invalidCookie
+            }
+            return [ResolvedSessionCookie(value: override, source: .manual)]
+        }
+
+        var cookies: [ResolvedSessionCookie] = []
+
+        // Try cached cookie before expensive browser import
+        if let cached = CookieHeaderCache.load(provider: .perplexity) {
+            if let override = PerplexityCookieHeader.override(from: cached.cookieHeader) {
+                cookies.append(ResolvedSessionCookie(value: override, source: .cache))
+            }
+        }
+
+        cookies.append(contentsOf: self.resolveSessionCookiesFromBrowserOrEnv(context: context))
+        return self.deduplicatedSessionCookies(cookies)
+    }
+
+    private func resolveSessionCookiesFromBrowserOrEnv(
+        context: ProviderFetchContext,
+        preferEnvironment: Bool = false) -> [ResolvedSessionCookie]
+    {
+        guard context.settings?.perplexity?.cookieSource != .off else { return [] }
+        var cookies: [ResolvedSessionCookie] = []
+
+        if preferEnvironment,
+           let cookie = PerplexitySettingsReader.sessionCookieOverride(environment: context.env)
+        {
+            cookies.append(ResolvedSessionCookie(value: cookie, source: .environment))
+        }
+
+        // Try browser cookie import when auto mode is enabled
+        #if os(macOS)
+        do {
+            let sessions = try PerplexityCookieImporter.importSessions()
+            cookies.append(contentsOf: sessions.compactMap { session in
+                guard let cookie = session.sessionCookie else { return nil }
+                return ResolvedSessionCookie(value: cookie, source: .browser)
+            })
+        } catch {
+            // No browser cookies found
+        }
+        #endif
+
+        // Fall back to environment
+        if !preferEnvironment,
+           let cookie = PerplexitySettingsReader.sessionCookieOverride(environment: context.env)
+        {
+            cookies.append(ResolvedSessionCookie(value: cookie, source: .environment))
+        }
+        return self.deduplicatedSessionCookies(cookies)
+    }
+
+    private func deduplicatedSessionCookies(_ cookies: [ResolvedSessionCookie]) -> [ResolvedSessionCookie] {
+        var deduplicated: [ResolvedSessionCookie] = []
+        for cookie in cookies {
+            if deduplicated.contains(where: { self.isEquivalentCookie($0.value, cookie.value) }) {
+                continue
+            }
+            deduplicated.append(cookie)
+        }
+        return deduplicated
+    }
+
+    private func cacheSessionCookieIfNeeded(
+        _ cookie: ResolvedSessionCookie,
+        usedCookie: PerplexityCookieOverride,
+        sourceLabel: String)
+    {
+        guard cookie.source.shouldCacheAfterFetch else { return }
+        CookieHeaderCache.store(
+            provider: .perplexity,
+            cookieHeader: "\(usedCookie.name)=\(usedCookie.token)",
+            sourceLabel: sourceLabel)
+    }
+
+    private func fetchSnapshot(using cookie: ResolvedSessionCookie) async throws -> SessionFetchResult {
+        var lastInvalidToken = false
+        for cookieName in cookie.value.requestCookieNames {
+            do {
+                let snapshot = try await PerplexityUsageFetcher.fetchCredits(
+                    sessionToken: cookie.value.token,
+                    cookieName: cookieName)
+                return SessionFetchResult(
+                    snapshot: snapshot,
+                    cookie: PerplexityCookieOverride(name: cookieName, token: cookie.value.token))
+            } catch PerplexityAPIError.invalidToken {
+                lastInvalidToken = true
+                continue
+            }
+        }
+
+        if lastInvalidToken {
+            throw PerplexityAPIError.invalidToken
+        }
+        throw PerplexityAPIError.missingToken
+    }
+
+    private func isEquivalentCookie(_ lhs: PerplexityCookieOverride, _ rhs: PerplexityCookieOverride) -> Bool {
+        lhs.token == rhs.token && lhs.requestCookieNames == rhs.requestCookieNames
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Perplexity/PerplexitySettingsReader.swift b/Sources/CodexBarCore/Providers/Perplexity/PerplexitySettingsReader.swift
new file mode 100644
index 0000000000..ef1952b5a8
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Perplexity/PerplexitySettingsReader.swift
@@ -0,0 +1,38 @@
+import Foundation
+
+public enum PerplexitySettingsReader {
+    public static func sessionCookieOverride(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> PerplexityCookieOverride?
+    {
+        let raw = environment["PERPLEXITY_SESSION_TOKEN"]
+            ?? environment["perplexity_session_token"]
+        if let token = self.cleaned(raw) { return PerplexityCookieHeader.override(from: token) }
+
+        // PERPLEXITY_COOKIE may be a full Cookie header string; preserve the matching session cookie name.
+        if let cookieRaw = environment["PERPLEXITY_COOKIE"] {
+            return PerplexityCookieHeader.override(from: self.cleaned(cookieRaw))
+        }
+        return nil
+    }
+
+    public static func sessionToken(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.sessionCookieOverride(environment: environment)?.token
+    }
+
+    private static func cleaned(_ raw: String?) -> String? {
+        guard var value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
+            return nil
+        }
+
+        if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
+            (value.hasPrefix("'") && value.hasSuffix("'"))
+        {
+            value = String(value.dropFirst().dropLast())
+        }
+
+        value = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        return value.isEmpty ? nil : value
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Perplexity/PerplexityUsageFetcher.swift b/Sources/CodexBarCore/Providers/Perplexity/PerplexityUsageFetcher.swift
new file mode 100644
index 0000000000..84e735e262
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Perplexity/PerplexityUsageFetcher.swift
@@ -0,0 +1,71 @@
+import Foundation
+
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public struct PerplexityUsageFetcher: Sendable {
+    private static let log = CodexBarLog.logger(LogCategories.perplexityAPI)
+    private static let creditsURL =
+        URL(string: "https://www.perplexity.ai/rest/billing/credits?version=2.18&source=default")!
+    @TaskLocal static var fetchCreditsOverride:
+        (@Sendable (String, String, Date) async throws -> PerplexityUsageSnapshot)?
+
+    /// Testing hook: parse a raw JSON response without making network calls.
+    public static func _parseResponseForTesting(_ data: Data, now: Date = Date()) throws -> PerplexityUsageSnapshot {
+        do {
+            let decoded = try JSONDecoder().decode(PerplexityCreditsResponse.self, from: data)
+            return PerplexityUsageSnapshot(response: decoded, now: now)
+        } catch {
+            throw PerplexityAPIError.parseFailed(error.localizedDescription)
+        }
+    }
+
+    public static func fetchCredits(
+        sessionToken: String,
+        cookieName: String = PerplexityCookieHeader.defaultSessionCookieName,
+        now: Date = Date()) async throws -> PerplexityUsageSnapshot
+    {
+        if let override = self.fetchCreditsOverride {
+            return try await override(sessionToken, cookieName, now)
+        }
+
+        var request = URLRequest(url: self.creditsURL)
+        request.httpMethod = "GET"
+        request.timeoutInterval = 15
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        request.setValue(
+            "\(cookieName)=\(sessionToken)",
+            forHTTPHeaderField: "Cookie")
+        request.setValue("https://www.perplexity.ai", forHTTPHeaderField: "Origin")
+        request.setValue("https://www.perplexity.ai/account/usage", forHTTPHeaderField: "Referer")
+        let userAgent = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) " +
+            "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36"
+        request.setValue(userAgent, forHTTPHeaderField: "User-Agent")
+
+        let response = try await ProviderHTTPClient.shared.response(for: request)
+        let data = response.data
+        guard response.statusCode == 200 else {
+            let statusCode = response.statusCode
+            let body = String(data: data, encoding: .utf8) ?? "<binary>"
+            let truncated = body.count > 200 ? String(body.prefix(200)) + "…" : body
+            Self.log.error("Perplexity API returned \(statusCode): \(truncated)")
+            if statusCode == 401 || statusCode == 403 {
+                throw PerplexityAPIError.invalidToken
+            }
+            throw PerplexityAPIError.apiError("HTTP \(statusCode)")
+        }
+
+        do {
+            let decoded = try JSONDecoder().decode(PerplexityCreditsResponse.self, from: data)
+            let snapshot = PerplexityUsageSnapshot(response: decoded, now: now)
+            Self.log.debug(
+                "Perplexity credits parsed balance=\(snapshot.balanceCents) totalUsage=\(snapshot.totalUsageCents)")
+            return snapshot
+        } catch {
+            let preview = String(data: data.prefix(500), encoding: .utf8) ?? "<binary>"
+            Self.log.error("Perplexity parse failed: \(error) — response: \(preview)")
+            throw PerplexityAPIError.parseFailed(error.localizedDescription)
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Perplexity/PerplexityUsageSnapshot.swift b/Sources/CodexBarCore/Providers/Perplexity/PerplexityUsageSnapshot.swift
new file mode 100644
index 0000000000..48e4cf9cc4
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Perplexity/PerplexityUsageSnapshot.swift
@@ -0,0 +1,134 @@
+import Foundation
+
+public struct PerplexityUsageSnapshot: Sendable {
+    public let recurringTotal: Double
+    public let recurringUsed: Double
+    public let promoTotal: Double
+    public let promoUsed: Double
+    public let purchasedTotal: Double
+    public let purchasedUsed: Double
+    public let balanceCents: Double
+    public let totalUsageCents: Double
+    public let renewalDate: Date
+    public let promoExpiration: Date?
+    public let updatedAt: Date
+
+    public init(response: PerplexityCreditsResponse, now: Date) {
+        let recurring = response.creditGrants.filter { $0.type == "recurring" }
+        let promotional = response.creditGrants.filter {
+            $0.type == "promotional" && ($0.expiresAtTs ?? .infinity) > now.timeIntervalSince1970
+        }
+        let purchased = response.creditGrants.filter { $0.type == "purchased" }
+
+        // All timestamps from the Perplexity API are Unix seconds (verified Feb 2026).
+        let recurringSum = max(0, recurring.reduce(0.0) { $0 + $1.amountCents })
+        let promoSum = max(0, promotional.reduce(0.0) { $0 + $1.amountCents })
+        // Purchased credits may appear in the top-level field, in the credit_grants
+        // array (type == "purchased"), or both. Take whichever is larger to avoid
+        // double-counting while still catching either source.
+        let purchasedFromGrants = max(0, purchased.reduce(0.0) { $0 + $1.amountCents })
+        let purchasedFromField = max(0, response.currentPeriodPurchasedCents)
+        let purchasedSum = max(purchasedFromGrants, purchasedFromField)
+
+        // Waterfall attribution: recurring → purchased → promotional
+        var remaining = response.totalUsageCents
+        let usedFromRecurring = min(remaining, recurringSum); remaining -= usedFromRecurring
+        let usedFromPurchased = min(remaining, purchasedSum); remaining -= usedFromPurchased
+        let usedFromPromo = min(remaining, promoSum)
+
+        self.recurringTotal = recurringSum
+        self.recurringUsed = usedFromRecurring
+        self.promoTotal = promoSum
+        self.promoUsed = usedFromPromo
+        self.purchasedTotal = purchasedSum
+        self.purchasedUsed = usedFromPurchased
+        self.balanceCents = response.balanceCents
+        self.totalUsageCents = response.totalUsageCents
+        self.renewalDate = Date(timeIntervalSince1970: response.renewalDateTs)
+        self.promoExpiration = promotional
+            .compactMap { $0.expiresAtTs.map { Date(timeIntervalSince1970: $0) } }
+            .min()
+        self.updatedAt = now
+    }
+
+    /// Infer plan name from recurring credit allotment.
+    /// Free = 0, Pro = small pool (~500–1000), Max = 10,000+.
+    public var planName: String? {
+        if self.recurringTotal <= 0 { return nil }
+        if self.recurringTotal < 5000 { return "Pro" }
+        return "Max"
+    }
+
+    private static let promoExpiryFormatter: DateFormatter = {
+        let fmt = DateFormatter()
+        fmt.dateFormat = "MMM d"
+        return fmt
+    }()
+}
+
+extension PerplexityUsageSnapshot {
+    public func toUsageSnapshot() -> UsageSnapshot {
+        // Primary: recurring (monthly) credits
+        let hasFallbackCredits = self.promoTotal > 0 || self.purchasedTotal > 0
+        let primaryWindow: RateWindow? = {
+            if self.recurringTotal > 0 {
+                let primaryPercent = min(100, max(0, self.recurringUsed / self.recurringTotal * 100))
+                return RateWindow(
+                    usedPercent: primaryPercent,
+                    windowMinutes: nil,
+                    resetsAt: self.renewalDate,
+                    resetDescription: "\(Int(self.recurringUsed.rounded()))/\(Int(self.recurringTotal)) credits")
+            }
+            if hasFallbackCredits {
+                // When recurring is absent but bonus/purchased credits remain, omit the fake 0/0 primary lane
+                // so automatic menu-bar rendering can fall through to the usable pool.
+                return nil
+            }
+            return RateWindow(
+                usedPercent: 100,
+                windowMinutes: nil,
+                resetsAt: self.renewalDate,
+                resetDescription: "0/0 credits")
+        }()
+
+        // Secondary: promotional bonus credits — always shown.
+        // usedPercent=100 when promoTotal==0 so the bar renders empty rather than full.
+        let promoPercent = self.promoTotal > 0
+            ? min(100, max(0, self.promoUsed / self.promoTotal * 100))
+            : 100.0
+        var promoDesc = "\(Int(promoUsed.rounded()))/\(Int(self.promoTotal)) bonus"
+        if let expiry = promoExpiration {
+            promoDesc += " \u{00b7} exp. \(Self.promoExpiryFormatter.string(from: expiry))"
+        }
+        let secondary = RateWindow(
+            usedPercent: promoPercent,
+            windowMinutes: nil,
+            resetsAt: nil,
+            resetDescription: promoDesc)
+
+        // Tertiary: on-demand purchased credits — always shown.
+        // usedPercent=100 when purchasedTotal==0 so the bar renders empty rather than full.
+        let purchasedPercent = self.purchasedTotal > 0
+            ? min(100, max(0, self.purchasedUsed / self.purchasedTotal * 100))
+            : 100.0
+        let tertiary = RateWindow(
+            usedPercent: purchasedPercent,
+            windowMinutes: nil,
+            resetsAt: nil,
+            resetDescription: "\(Int(purchasedUsed.rounded()))/\(Int(self.purchasedTotal)) credits")
+
+        let identity = ProviderIdentitySnapshot(
+            providerID: .perplexity,
+            accountEmail: nil,
+            accountOrganization: nil,
+            loginMethod: planName)
+
+        return UsageSnapshot(
+            primary: primaryWindow,
+            secondary: secondary,
+            tertiary: tertiary,
+            providerCost: nil,
+            updatedAt: self.updatedAt,
+            identity: identity)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Poe/PoeProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Poe/PoeProviderDescriptor.swift
new file mode 100644
index 0000000000..176e2ee18c
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Poe/PoeProviderDescriptor.swift
@@ -0,0 +1,69 @@
+import Foundation
+
+public enum PoeProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .poe,
+            metadata: ProviderMetadata(
+                id: .poe,
+                displayName: "Poe",
+                sessionLabel: "Points",
+                weeklyLabel: "Points",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "",
+                toggleTitle: "Show Poe usage",
+                cliName: "poe",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                browserCookieOrder: nil,
+                dashboardURL: "https://poe.com/api/keys",
+                statusPageURL: nil,
+                statusLinkURL: nil),
+            branding: ProviderBranding(
+                iconStyle: .poe,
+                iconResourceName: "ProviderIcon-poe",
+                color: ProviderColor(red: 0.15, green: 0.68, blue: 0.38)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "Poe usage history is unavailable." }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .api],
+                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [PoeAPIFetchStrategy()] })),
+            cli: ProviderCLIConfig(
+                name: "poe",
+                aliases: [],
+                versionDetector: nil))
+    }
+}
+
+struct PoeAPIFetchStrategy: ProviderFetchStrategy {
+    let id: String = "poe.api"
+    let kind: ProviderFetchKind = .apiToken
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        Self.resolveToken(environment: context.env) != nil
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        guard let apiKey = Self.resolveToken(environment: context.env) else {
+            throw PoeUsageError.missingCredentials
+        }
+        let usage = try await PoeUsageFetcher.fetchUsage(apiKey: apiKey)
+        return self.makeResult(
+            usage: usage.toUsageSnapshot(),
+            sourceLabel: "api")
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+
+    private static func resolveToken(environment: [String: String]) -> String? {
+        ProviderTokenResolver.poeToken(environment: environment)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Poe/PoeSettingsReader.swift b/Sources/CodexBarCore/Providers/Poe/PoeSettingsReader.swift
new file mode 100644
index 0000000000..7cb6f0ca28
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Poe/PoeSettingsReader.swift
@@ -0,0 +1,26 @@
+import Foundation
+
+public enum PoeSettingsReader {
+    public static let apiKeyEnvironmentKey = "POE_API_KEY"
+
+    public static func apiKey(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.cleaned(environment[self.apiKeyEnvironmentKey])
+    }
+
+    private static func cleaned(_ raw: String?) -> String? {
+        guard var value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
+            return nil
+        }
+
+        if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
+            (value.hasPrefix("'") && value.hasSuffix("'"))
+        {
+            value = String(value.dropFirst().dropLast())
+        }
+
+        value = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        return value.isEmpty ? nil : value
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Poe/PoeUsageFetcher.swift b/Sources/CodexBarCore/Providers/Poe/PoeUsageFetcher.swift
new file mode 100644
index 0000000000..92fb866f5a
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Poe/PoeUsageFetcher.swift
@@ -0,0 +1,287 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public enum PoeUsageError: LocalizedError, Sendable {
+    case missingCredentials
+    case networkError(String)
+    case apiError(String)
+    case unauthorized
+    case parseFailed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingCredentials:
+            "Missing Poe API token."
+        case let .networkError(message):
+            "Poe network error: \(message)"
+        case let .apiError(message):
+            "Poe API error: \(message)"
+        case .unauthorized:
+            "Invalid or expired Poe API token."
+        case let .parseFailed(message):
+            "Failed to parse Poe response: \(message)"
+        }
+    }
+}
+
+public struct PoeUsageFetcher: Sendable {
+    private static let log = CodexBarLog.logger(LogCategories.poeUsage)
+    private static let usageURL = URL(string: "https://api.poe.com/usage/current_balance")!
+    private static let historyURL = URL(string: "https://api.poe.com/usage/points_history")!
+    private static let timeoutSeconds: TimeInterval = 15
+
+    public static func fetchUsage(apiKey: String) async throws -> PoeUsageSnapshot {
+        try await self._fetchUsage(apiKey: apiKey, transport: ProviderHTTPClient.shared)
+    }
+
+    static func _fetchUsage(
+        apiKey: String,
+        transport: any ProviderHTTPTransport) async throws -> PoeUsageSnapshot
+    {
+        let trimmed = apiKey.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else {
+            throw PoeUsageError.missingCredentials
+        }
+
+        var request = URLRequest(url: self.usageURL)
+        request.httpMethod = "GET"
+        request.setValue("Bearer \(trimmed)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        request.timeoutInterval = Self.timeoutSeconds
+
+        let response = try await self.perform(request: request, transport: transport)
+        let balance = try self.parseSnapshot(data: response.data).currentPointBalance
+        // `points_history` is a best-effort supplement; never let an optional
+        // history failure cost the user the current balance display.
+        let history: PoeUsageHistorySnapshot?
+        do {
+            history = try await self.fetchHistory(apiKey: trimmed, transport: transport)
+        } catch {
+            Self.log.error("Poe points_history fetch failed; returning balance only: \(error)")
+            history = nil
+        }
+        return PoeUsageSnapshot(
+            currentPointBalance: balance,
+            history: history,
+            updatedAt: Date())
+    }
+
+    static func _parseSnapshotForTesting(_ data: Data) throws -> PoeUsageSnapshot {
+        try self.parseSnapshot(data: data)
+    }
+
+    static func _parseHistoryPageForTesting(_ data: Data) throws
+        -> (entries: [PoeUsageHistorySnapshot.Entry], nextCursor: String?)
+    {
+        try self.parseHistoryPage(data: data)
+    }
+
+    static func _buildDailyBucketsForTesting(entries: [PoeUsageHistorySnapshot.Entry])
+    -> [PoeUsageHistorySnapshot.DailyBucket] {
+        self.buildDailyBuckets(entries: entries)
+    }
+
+    private static func parseSnapshot(data: Data) throws -> PoeUsageSnapshot {
+        guard let root = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+            throw PoeUsageError.parseFailed("Invalid JSON")
+        }
+
+        let balance = self.double(from: root["current_point_balance"])
+
+        return PoeUsageSnapshot(
+            currentPointBalance: balance,
+            updatedAt: Date())
+    }
+
+    private static func fetchHistory(
+        apiKey: String,
+        transport: any ProviderHTTPTransport) async throws -> PoeUsageHistorySnapshot?
+    {
+        var cursor: String?
+        var entries: [PoeUsageHistorySnapshot.Entry] = []
+        let cutoff = Date().addingTimeInterval(-30 * 24 * 3600)
+        var page = 0
+
+        while page < 5 {
+            page += 1
+            var components = URLComponents(url: self.historyURL, resolvingAgainstBaseURL: false)
+            var query: [URLQueryItem] = [URLQueryItem(name: "limit", value: "100")]
+            if let cursor, !cursor.isEmpty {
+                query.append(URLQueryItem(name: "starting_after", value: cursor))
+            }
+            components?.queryItems = query
+            guard let url = components?.url else {
+                throw PoeUsageError.parseFailed("Invalid points_history URL")
+            }
+
+            var request = URLRequest(url: url)
+            request.httpMethod = "GET"
+            request.timeoutInterval = Self.timeoutSeconds
+            request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
+            request.setValue("application/json", forHTTPHeaderField: "Accept")
+
+            let response = try await self.perform(request: request, transport: transport)
+            let parsed = try self.parseHistoryPage(data: response.data)
+            entries.append(contentsOf: parsed.entries)
+            cursor = parsed.nextCursor
+
+            if parsed.entries.last?.createdAt ?? .distantPast < cutoff { break }
+            if cursor == nil { break }
+        }
+
+        guard !entries.isEmpty else { return nil }
+        let filtered = entries.filter { $0.createdAt >= cutoff }
+        guard !filtered.isEmpty else { return nil }
+        let daily = self.buildDailyBuckets(entries: filtered)
+        return PoeUsageHistorySnapshot(entries: filtered, daily: daily, updatedAt: Date())
+    }
+
+    private static func buildDailyBuckets(entries: [PoeUsageHistorySnapshot.Entry])
+    -> [PoeUsageHistorySnapshot.DailyBucket] {
+        var acc: [String: (points: Double, requests: Int, costUSD: Double)] = [:]
+        let formatter = DateFormatter()
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        formatter.timeZone = TimeZone(secondsFromGMT: 0)
+        formatter.dateFormat = "yyyy-MM-dd"
+        for entry in entries {
+            let key = formatter.string(from: entry.createdAt)
+            var row = acc[key] ?? (points: 0, requests: 0, costUSD: 0)
+            row.points += max(0, entry.points)
+            row.requests += 1
+            row.costUSD += max(0, entry.costUSD ?? 0)
+            acc[key] = row
+        }
+        return acc.keys.sorted().map { day in
+            let row = acc[day] ?? (0, 0, 0)
+            return PoeUsageHistorySnapshot.DailyBucket(
+                day: day,
+                points: row.points,
+                requests: row.requests,
+                costUSD: row.costUSD > 0 ? row.costUSD : nil)
+        }
+    }
+
+    private static func parseHistoryPage(data: Data) throws
+        -> (entries: [PoeUsageHistorySnapshot.Entry], nextCursor: String?)
+    {
+        guard let root = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+            throw PoeUsageError.parseFailed("Invalid history JSON")
+        }
+
+        let rawEntries: [[String: Any]] = if let rows = root["data"] as? [[String: Any]] {
+            rows
+        } else if let rows = root["items"] as? [[String: Any]] {
+            rows
+        } else if let rows = root["results"] as? [[String: Any]] {
+            rows
+        } else {
+            []
+        }
+
+        let entries = rawEntries.compactMap { row -> PoeUsageHistorySnapshot.Entry? in
+            guard let createdAt = self
+                .date(fromHistoryValue: row["creation_time"] ?? row["timestamp"] ?? row["created_at"])
+            else {
+                return nil
+            }
+            let model = (row["bot_name"] as? String)?
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+                ?? "unknown"
+            let usageType = (row["usage_type"] as? String)?
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+                ?? "unknown"
+            let points = self.double(from: row["cost_points"])
+                ?? self.double(from: row["points"])
+                ?? self.double(from: row["point_cost"])
+                ?? 0
+            let costUSD = self.double(from: row["cost_usd"] ?? row["usd"])
+            let id = (row["query_id"] as? String)
+                ?? (row["message_id"] as? String)
+                ?? (row["id"] as? String)
+                ?? "\(createdAt.timeIntervalSince1970)-\(model)"
+            return PoeUsageHistorySnapshot.Entry(
+                id: id,
+                createdAt: createdAt,
+                model: model.isEmpty ? "unknown" : model,
+                usageType: usageType.isEmpty ? "unknown" : usageType,
+                points: max(0, points),
+                costUSD: costUSD)
+        }
+
+        let nextCursor = (root["next_cursor"] as? String)?
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+        if let nextCursor, !nextCursor.isEmpty {
+            return (entries: entries, nextCursor: nextCursor)
+        }
+        if let hasMore = root["has_more"] as? Bool, hasMore {
+            let fallbackCursor = (rawEntries.last?["query_id"] as? String)?
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+            if let fallbackCursor, !fallbackCursor.isEmpty {
+                return (entries: entries, nextCursor: fallbackCursor)
+            }
+        }
+        return (entries: entries, nextCursor: nil)
+    }
+
+    private static func date(fromHistoryValue value: Any?) -> Date? {
+        switch value {
+        case let number as NSNumber:
+            return self.date(fromNumericTimestamp: number.doubleValue)
+        case let string as String:
+            let trimmed = string.trimmingCharacters(in: .whitespacesAndNewlines)
+            if let numeric = Double(trimmed) {
+                return self.date(fromNumericTimestamp: numeric)
+            }
+            let formatter = ISO8601DateFormatter()
+            return formatter.date(from: trimmed)
+        default:
+            return nil
+        }
+    }
+
+    private static func date(fromNumericTimestamp raw: Double) -> Date? {
+        guard raw.isFinite, raw > 0 else { return nil }
+        if raw > 1_000_000_000_000 {
+            return Date(timeIntervalSince1970: raw / 1_000_000)
+        }
+        return Date(timeIntervalSince1970: raw)
+    }
+
+    private static func perform(
+        request: URLRequest,
+        transport: any ProviderHTTPTransport) async throws -> ProviderHTTPResponse
+    {
+        let (data, urlResponse) = try await transport.data(for: request)
+        guard let httpResponse = urlResponse as? HTTPURLResponse else {
+            throw PoeUsageError.networkError("Non-HTTP response")
+        }
+        let response = ProviderHTTPResponse(data: data, response: httpResponse)
+        guard response.statusCode == 200 else {
+            let body = String(data: data, encoding: .utf8) ?? ""
+            Self.log.error("Poe API returned \(response.statusCode): \(body)")
+            if response.statusCode == 401 || response.statusCode == 403 {
+                throw PoeUsageError.unauthorized
+            }
+            throw PoeUsageError.apiError("HTTP \(response.statusCode)")
+        }
+        return response
+    }
+
+    // MARK: - Value parsing
+
+    private static func double(from value: Any?) -> Double? {
+        switch value {
+        case let number as NSNumber:
+            let raw = number.doubleValue
+            return raw.isFinite ? raw : nil
+        case let string as String:
+            let trimmed = string.trimmingCharacters(in: .whitespacesAndNewlines)
+            guard !trimmed.isEmpty, let raw = Double(trimmed), raw.isFinite else { return nil }
+            return raw
+        default:
+            return nil
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Poe/PoeUsageHistorySnapshot.swift b/Sources/CodexBarCore/Providers/Poe/PoeUsageHistorySnapshot.swift
new file mode 100644
index 0000000000..63cceb5e58
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Poe/PoeUsageHistorySnapshot.swift
@@ -0,0 +1,153 @@
+import Foundation
+
+public struct PoeUsageHistorySnapshot: Codable, Equatable, Sendable {
+    public struct BreakdownItem: Equatable, Sendable {
+        public let name: String
+        public let points: Double
+        public let requests: Int
+        public let costUSD: Double?
+    }
+
+    public struct Entry: Codable, Equatable, Sendable, Identifiable {
+        public let id: String
+        public let createdAt: Date
+        public let model: String
+        public let usageType: String
+        public let points: Double
+        public let costUSD: Double?
+
+        public init(
+            id: String,
+            createdAt: Date,
+            model: String,
+            usageType: String,
+            points: Double,
+            costUSD: Double?)
+        {
+            self.id = id
+            self.createdAt = createdAt
+            self.model = model
+            self.usageType = usageType
+            self.points = points
+            self.costUSD = costUSD
+        }
+    }
+
+    public struct DailyBucket: Codable, Equatable, Sendable, Identifiable {
+        public let day: String
+        public let points: Double
+        public let requests: Int
+        public let costUSD: Double?
+
+        public init(day: String, points: Double, requests: Int, costUSD: Double?) {
+            self.day = day
+            self.points = points
+            self.requests = requests
+            self.costUSD = costUSD
+        }
+
+        public var id: String {
+            self.day
+        }
+    }
+
+    public struct Summary: Equatable, Sendable {
+        public let points: Double
+        public let requests: Int
+        public let costUSD: Double?
+    }
+
+    public let entries: [Entry]
+    public let daily: [DailyBucket]
+    public let updatedAt: Date
+
+    public init(entries: [Entry], daily: [DailyBucket], updatedAt: Date) {
+        self.entries = entries.sorted { $0.createdAt < $1.createdAt }
+        self.daily = daily.sorted { $0.day < $1.day }
+        self.updatedAt = updatedAt
+    }
+
+    public var latestDay: Summary {
+        self.summary(days: 1)
+    }
+
+    public var last7Days: Summary {
+        self.summary(days: 7)
+    }
+
+    public var last30Days: Summary {
+        self.summary(days: 30)
+    }
+
+    public func summary(days: Int) -> Summary {
+        let selected = self.daily.suffix(max(1, days))
+        let points = selected.reduce(0) { $0 + $1.points }
+        let requests = selected.reduce(0) { $0 + $1.requests }
+        let costValues = selected.compactMap(\.costUSD)
+        let cost: Double? = costValues.isEmpty ? nil : costValues.reduce(0, +)
+        return Summary(points: points, requests: requests, costUSD: cost)
+    }
+
+    public var topModel: String? {
+        self.topModels.first?.name
+    }
+
+    public var topModels: [BreakdownItem] {
+        self.breakdown(
+            groupedBy: \.model,
+            fallback: "unknown")
+    }
+
+    public var topUsageTypes: [BreakdownItem] {
+        self.breakdown(
+            groupedBy: \.usageType,
+            fallback: "unknown")
+    }
+
+    public func recentEntries(limit: Int = 3) -> [Entry] {
+        let clamped = max(1, limit)
+        return Array(self.entries.sorted { $0.createdAt > $1.createdAt }.prefix(clamped))
+    }
+
+    private func breakdown(
+        groupedBy keyPath: KeyPath<Entry, String>,
+        fallback: String) -> [BreakdownItem]
+    {
+        struct Acc {
+            var points: Double = 0
+            var requests: Int = 0
+            var costUSD: Double = 0
+            var hasCost = false
+        }
+
+        var grouped: [String: Acc] = [:]
+        for entry in self.entries {
+            let raw = entry[keyPath: keyPath].trimmingCharacters(in: .whitespacesAndNewlines)
+            let key = raw.isEmpty ? fallback : raw
+            var row = grouped[key] ?? Acc()
+            row.points += max(0, entry.points)
+            row.requests += 1
+            if let cost = entry.costUSD {
+                row.costUSD += max(0, cost)
+                row.hasCost = true
+            }
+            grouped[key] = row
+        }
+
+        return grouped.map { key, value in
+            BreakdownItem(
+                name: key,
+                points: value.points,
+                requests: value.requests,
+                costUSD: value.hasCost ? value.costUSD : nil)
+        }
+        .sorted {
+            if $0.points == $1.points { return $0.name < $1.name }
+            return $0.points > $1.points
+        }
+    }
+
+    public var topUsageType: String? {
+        self.topUsageTypes.first?.name
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Poe/PoeUsageSnapshot.swift b/Sources/CodexBarCore/Providers/Poe/PoeUsageSnapshot.swift
new file mode 100644
index 0000000000..b1dab545c3
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Poe/PoeUsageSnapshot.swift
@@ -0,0 +1,47 @@
+import Foundation
+
+public struct PoeUsageSnapshot: Sendable {
+    public let currentPointBalance: Double?
+    public let history: PoeUsageHistorySnapshot?
+    public let updatedAt: Date
+
+    public init(
+        currentPointBalance: Double? = nil,
+        history: PoeUsageHistorySnapshot? = nil,
+        updatedAt: Date = Date())
+    {
+        self.currentPointBalance = currentPointBalance
+        self.history = history
+        self.updatedAt = updatedAt
+    }
+
+    public func toUsageSnapshot() -> UsageSnapshot {
+        let identity = ProviderIdentitySnapshot(
+            providerID: .poe,
+            accountEmail: nil,
+            accountOrganization: nil,
+            loginMethod: self.balanceLabel)
+
+        return UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            tertiary: nil,
+            providerCost: nil,
+            poeUsage: self.history,
+            updatedAt: self.updatedAt,
+            identity: identity)
+    }
+
+    private var balanceLabel: String? {
+        guard let balance = self.currentPointBalance, balance.isFinite else { return nil }
+        return "Balance: \(Self.compactNumber(balance)) points"
+    }
+
+    static func compactNumber(_ value: Double) -> String {
+        let formatter = NumberFormatter()
+        formatter.numberStyle = .decimal
+        formatter.locale = Locale(identifier: "en_US")
+        formatter.maximumFractionDigits = value >= 1000 ? 0 : 1
+        return formatter.string(from: NSNumber(value: value)) ?? String(format: "%.0f", value)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/ProviderCandidateRetryRunner.swift b/Sources/CodexBarCore/Providers/ProviderCandidateRetryRunner.swift
index 5b20482362..f3009d24c8 100644
--- a/Sources/CodexBarCore/Providers/ProviderCandidateRetryRunner.swift
+++ b/Sources/CodexBarCore/Providers/ProviderCandidateRetryRunner.swift
@@ -1,6 +1,6 @@
 import Foundation
 
-enum ProviderCandidateRetryRunnerError: Error, Sendable {
+enum ProviderCandidateRetryRunnerError: Error {
     case noCandidates
 }
 
diff --git a/Sources/CodexBarCore/Providers/ProviderCookieSettingsResolver.swift b/Sources/CodexBarCore/Providers/ProviderCookieSettingsResolver.swift
new file mode 100644
index 0000000000..2da2671839
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/ProviderCookieSettingsResolver.swift
@@ -0,0 +1,25 @@
+import Foundation
+
+public enum ProviderCookieSettingsResolver {
+    public static func resolve(
+        provider: UsageProvider,
+        configuredSource: ProviderCookieSource,
+        configuredHeader: String?,
+        selectedAccount: ProviderTokenAccount?) -> ProviderSettingsSnapshot.CookieProviderSettings
+    {
+        guard let support = TokenAccountSupportCatalog.support(for: provider),
+              case .cookieHeader = support.injection,
+              let selectedAccount
+        else {
+            return ProviderSettingsSnapshot.CookieProviderSettings(
+                cookieSource: configuredSource,
+                manualCookieHeader: configuredHeader)
+        }
+
+        return ProviderSettingsSnapshot.CookieProviderSettings(
+            cookieSource: support.requiresManualCookieSource ? .manual : configuredSource,
+            manualCookieHeader: TokenAccountSupportCatalog.normalizedCookieHeader(
+                selectedAccount.token,
+                support: support))
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/ProviderDescriptor.swift b/Sources/CodexBarCore/Providers/ProviderDescriptor.swift
index d7a3669d4a..99ee47ccd1 100644
--- a/Sources/CodexBarCore/Providers/ProviderDescriptor.swift
+++ b/Sources/CodexBarCore/Providers/ProviderDescriptor.swift
@@ -54,15 +54,22 @@ public enum ProviderDescriptorRegistry {
     private static let store = Store()
     private static let descriptorsByID: [UsageProvider: ProviderDescriptor] = [
         .codex: CodexProviderDescriptor.descriptor,
+        .openai: OpenAIAPIProviderDescriptor.descriptor,
+        .azureopenai: AzureOpenAIProviderDescriptor.descriptor,
         .claude: ClaudeProviderDescriptor.descriptor,
         .cursor: CursorProviderDescriptor.descriptor,
         .opencode: OpenCodeProviderDescriptor.descriptor,
+        .opencodego: OpenCodeGoProviderDescriptor.descriptor,
+        .alibaba: AlibabaCodingPlanProviderDescriptor.descriptor,
+        .alibabatokenplan: AlibabaTokenPlanProviderDescriptor.descriptor,
         .factory: FactoryProviderDescriptor.descriptor,
         .gemini: GeminiProviderDescriptor.descriptor,
         .antigravity: AntigravityProviderDescriptor.descriptor,
         .copilot: CopilotProviderDescriptor.descriptor,
+        .devin: DevinProviderDescriptor.descriptor,
         .zai: ZaiProviderDescriptor.descriptor,
         .minimax: MiniMaxProviderDescriptor.descriptor,
+        .manus: ManusProviderDescriptor.descriptor,
         .kimi: KimiProviderDescriptor.descriptor,
         .kilo: KiloProviderDescriptor.descriptor,
         .kiro: KiroProviderDescriptor.descriptor,
@@ -70,11 +77,35 @@ public enum ProviderDescriptorRegistry {
         .augment: AugmentProviderDescriptor.descriptor,
         .jetbrains: JetBrainsProviderDescriptor.descriptor,
         .kimik2: KimiK2ProviderDescriptor.descriptor,
+        .moonshot: MoonshotProviderDescriptor.descriptor,
         .amp: AmpProviderDescriptor.descriptor,
+        .t3chat: T3ChatProviderDescriptor.descriptor,
         .ollama: OllamaProviderDescriptor.descriptor,
         .synthetic: SyntheticProviderDescriptor.descriptor,
         .openrouter: OpenRouterProviderDescriptor.descriptor,
+        .elevenlabs: ElevenLabsProviderDescriptor.descriptor,
         .warp: WarpProviderDescriptor.descriptor,
+        .windsurf: WindsurfProviderDescriptor.descriptor,
+        .zed: ZedProviderDescriptor.descriptor,
+        .perplexity: PerplexityProviderDescriptor.descriptor,
+        .mimo: MiMoProviderDescriptor.descriptor,
+        .doubao: DoubaoProviderDescriptor.descriptor,
+        .abacus: AbacusProviderDescriptor.descriptor,
+        .mistral: MistralProviderDescriptor.descriptor,
+        .deepseek: DeepSeekProviderDescriptor.descriptor,
+        .codebuff: CodebuffProviderDescriptor.descriptor,
+        .crof: CrofProviderDescriptor.descriptor,
+        .venice: VeniceProviderDescriptor.descriptor,
+        .commandcode: CommandCodeProviderDescriptor.descriptor,
+        .stepfun: StepFunProviderDescriptor.descriptor,
+        .bedrock: BedrockProviderDescriptor.descriptor,
+        .grok: GrokProviderDescriptor.descriptor,
+        .groq: GroqProviderDescriptor.descriptor,
+        .llmproxy: LLMProxyProviderDescriptor.descriptor,
+        .litellm: LiteLLMProviderDescriptor.descriptor,
+        .deepgram: DeepgramProviderDescriptor.descriptor,
+        .poe: PoeProviderDescriptor.descriptor,
+        .chutes: ChutesProviderDescriptor.descriptor,
     ]
     private static let bootstrap: Void = {
         for provider in UsageProvider.allCases {
diff --git a/Sources/CodexBarCore/Providers/ProviderDiagnosticExport.swift b/Sources/CodexBarCore/Providers/ProviderDiagnosticExport.swift
new file mode 100644
index 0000000000..c12c59f857
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/ProviderDiagnosticExport.swift
@@ -0,0 +1,583 @@
+import Foundation
+
+public struct ProviderDiagnosticBatchExport: Codable, Sendable {
+    public let schemaVersion: String
+    public let timestamp: Date
+    public let diagnostics: [ProviderDiagnosticExport]
+
+    public init(
+        schemaVersion: String = "1.0",
+        timestamp: Date,
+        diagnostics: [ProviderDiagnosticExport])
+    {
+        self.schemaVersion = schemaVersion
+        self.timestamp = timestamp
+        self.diagnostics = diagnostics
+    }
+}
+
+public struct ProviderDiagnosticExport: Codable, Sendable {
+    public let schemaVersion: String
+    public let timestamp: Date
+    public let platform: String
+    public let appVersion: String?
+    public let provider: String
+    public let displayName: String
+    public let source: String
+    public let sourceMode: String
+    public let auth: ProviderDiagnosticAuthSummary
+    public let usage: ProviderDiagnosticUsageSummary?
+    public let fetchAttempts: [ProviderDiagnosticFetchAttempt]
+    public let error: ProviderDiagnosticError?
+    public let settings: ProviderDiagnosticSettingsSummary
+    public let details: ProviderDiagnosticDetails?
+
+    private enum CodingKeys: String, CodingKey {
+        case schemaVersion
+        case timestamp
+        case platform
+        case appVersion
+        case provider
+        case displayName
+        case source
+        case sourceMode
+        case auth
+        case usage
+        case fetchAttempts
+        case error
+        case settings
+        case details
+    }
+
+    public init(
+        schemaVersion: String = "1.0",
+        timestamp: Date,
+        platform: String = ProviderDiagnosticPlatform.current,
+        appVersion: String? = nil,
+        provider: String,
+        displayName: String,
+        source: String,
+        sourceMode: String,
+        auth: ProviderDiagnosticAuthSummary,
+        usage: ProviderDiagnosticUsageSummary?,
+        fetchAttempts: [ProviderDiagnosticFetchAttempt],
+        error: ProviderDiagnosticError?,
+        settings: ProviderDiagnosticSettingsSummary,
+        details: ProviderDiagnosticDetails?)
+    {
+        self.schemaVersion = schemaVersion
+        self.timestamp = timestamp
+        self.platform = platform
+        self.appVersion = appVersion
+        self.provider = provider
+        self.displayName = displayName
+        self.source = source
+        self.sourceMode = sourceMode
+        self.auth = auth
+        self.usage = usage
+        self.fetchAttempts = fetchAttempts
+        self.error = error
+        self.settings = settings
+        self.details = details
+    }
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        try self.init(
+            schemaVersion: container.decode(String.self, forKey: .schemaVersion),
+            timestamp: container.decode(Date.self, forKey: .timestamp),
+            platform: container.decodeIfPresent(String.self, forKey: .platform)
+                ?? ProviderDiagnosticPlatform.current,
+            appVersion: container.decodeIfPresent(String.self, forKey: .appVersion),
+            provider: container.decode(String.self, forKey: .provider),
+            displayName: container.decode(String.self, forKey: .displayName),
+            source: container.decode(String.self, forKey: .source),
+            sourceMode: container.decode(String.self, forKey: .sourceMode),
+            auth: container.decode(ProviderDiagnosticAuthSummary.self, forKey: .auth),
+            usage: container.decodeIfPresent(ProviderDiagnosticUsageSummary.self, forKey: .usage),
+            fetchAttempts: container.decode([ProviderDiagnosticFetchAttempt].self, forKey: .fetchAttempts),
+            error: container.decodeIfPresent(ProviderDiagnosticError.self, forKey: .error),
+            settings: container.decode(ProviderDiagnosticSettingsSummary.self, forKey: .settings),
+            details: container.decodeIfPresent(ProviderDiagnosticDetails.self, forKey: .details))
+    }
+}
+
+public enum ProviderDiagnosticPlatform {
+    public static var current: String {
+        #if os(macOS)
+        "macOS"
+        #elseif os(Linux)
+        "Linux"
+        #else
+        "unknown"
+        #endif
+    }
+}
+
+public struct ProviderDiagnosticAuthSummary: Codable, Sendable {
+    public let configured: Bool
+    public let modes: [String]
+
+    public init(configured: Bool, modes: [String]) {
+        self.configured = configured
+        self.modes = modes
+    }
+
+    public func resolved(with outcome: ProviderFetchOutcome) -> ProviderDiagnosticAuthSummary {
+        var resolvedModes = self.modes
+        if outcome.isSuccess {
+            for attempt in outcome.attempts where attempt.wasAvailable {
+                let mode = ProviderDiagnosticFetchAttempt.kindLabel(attempt.kind)
+                if !resolvedModes.contains(mode) {
+                    resolvedModes.append(mode)
+                }
+            }
+        }
+        let configured = self.configured || outcome.isSuccess
+        return ProviderDiagnosticAuthSummary(configured: configured, modes: resolvedModes)
+    }
+}
+
+public struct ProviderDiagnosticUsageSummary: Codable, Sendable {
+    public let updatedAt: Date
+    public let dataConfidence: String
+    public let windows: [ProviderDiagnosticRateWindow]
+    public let extraWindowCount: Int
+    public let providerCostPresent: Bool
+    public let providerSpecificData: [String]
+
+    private enum CodingKeys: String, CodingKey {
+        case updatedAt
+        case dataConfidence
+        case windows
+        case extraWindowCount
+        case providerCostPresent
+        case providerSpecificData
+    }
+
+    public init(from snapshot: UsageSnapshot) {
+        var windows: [ProviderDiagnosticRateWindow] = []
+        if let primary = snapshot.primary {
+            windows.append(ProviderDiagnosticRateWindow(label: "primary", window: primary))
+        }
+        if let secondary = snapshot.secondary {
+            windows.append(ProviderDiagnosticRateWindow(label: "secondary", window: secondary))
+        }
+        if let tertiary = snapshot.tertiary {
+            windows.append(ProviderDiagnosticRateWindow(label: "tertiary", window: tertiary))
+        }
+        for extra in snapshot.extraRateWindows ?? [] {
+            windows.append(ProviderDiagnosticRateWindow(
+                label: extra.title,
+                window: extra.window,
+                usageKnown: extra.usageKnown))
+        }
+
+        var providerSpecificData: [String] = []
+        if snapshot.kiroUsage != nil { providerSpecificData.append("kiroUsage") }
+        if snapshot.ampUsage != nil { providerSpecificData.append("ampUsage") }
+        if snapshot.zaiUsage != nil { providerSpecificData.append("zaiUsage") }
+        if snapshot.minimaxUsage != nil { providerSpecificData.append("minimaxUsage") }
+        if snapshot.deepseekUsage != nil { providerSpecificData.append("deepseekUsage") }
+        if snapshot.openRouterUsage != nil { providerSpecificData.append("openRouterUsage") }
+        if snapshot.openAIAPIUsage != nil { providerSpecificData.append("openAIAPIUsage") }
+        if snapshot.claudeAdminAPIUsage != nil { providerSpecificData.append("claudeAdminAPIUsage") }
+        if snapshot.mistralUsage != nil { providerSpecificData.append("mistralUsage") }
+        if snapshot.deepgramUsage != nil { providerSpecificData.append("deepgramUsage") }
+        if snapshot.cursorRequests != nil { providerSpecificData.append("cursorRequests") }
+
+        self.updatedAt = snapshot.updatedAt
+        self.dataConfidence = snapshot.dataConfidence.rawValue
+        self.windows = windows
+        self.extraWindowCount = snapshot.extraRateWindows?.count ?? 0
+        self.providerCostPresent = snapshot.providerCost != nil
+        self.providerSpecificData = providerSpecificData.sorted()
+    }
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.updatedAt = try container.decode(Date.self, forKey: .updatedAt)
+        self.dataConfidence = try container.decodeIfPresent(String.self, forKey: .dataConfidence)
+            ?? UsageDataConfidence.unknown.rawValue
+        self.windows = try container.decode([ProviderDiagnosticRateWindow].self, forKey: .windows)
+        self.extraWindowCount = try container.decode(Int.self, forKey: .extraWindowCount)
+        self.providerCostPresent = try container.decode(Bool.self, forKey: .providerCostPresent)
+        self.providerSpecificData = try container.decode([String].self, forKey: .providerSpecificData)
+    }
+}
+
+public struct ProviderDiagnosticRateWindow: Codable, Sendable {
+    public let label: String
+    public let usedPercent: Double
+    public let windowMinutes: Int?
+    public let resetsAt: Date?
+    public let hasResetDescription: Bool
+    public let nextRegenPercent: Double?
+    public let usageKnown: Bool
+
+    private enum CodingKeys: String, CodingKey {
+        case label
+        case usedPercent
+        case windowMinutes
+        case resetsAt
+        case hasResetDescription
+        case nextRegenPercent
+        case usageKnown
+    }
+
+    public init(label: String, window: RateWindow, usageKnown: Bool = true) {
+        self.label = label
+        self.usedPercent = window.usedPercent
+        self.windowMinutes = window.windowMinutes
+        self.resetsAt = window.resetsAt
+        self.hasResetDescription = window.resetDescription?.isEmpty == false
+        self.nextRegenPercent = window.nextRegenPercent
+        self.usageKnown = usageKnown
+    }
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.label = try container.decode(String.self, forKey: .label)
+        self.usedPercent = try container.decode(Double.self, forKey: .usedPercent)
+        self.windowMinutes = try container.decodeIfPresent(Int.self, forKey: .windowMinutes)
+        self.resetsAt = try container.decodeIfPresent(Date.self, forKey: .resetsAt)
+        self.hasResetDescription = try container.decode(Bool.self, forKey: .hasResetDescription)
+        self.nextRegenPercent = try container.decodeIfPresent(Double.self, forKey: .nextRegenPercent)
+        self.usageKnown = try container.decodeIfPresent(Bool.self, forKey: .usageKnown) ?? true
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encode(self.label, forKey: .label)
+        try container.encode(self.usedPercent, forKey: .usedPercent)
+        try container.encodeIfPresent(self.windowMinutes, forKey: .windowMinutes)
+        try container.encodeIfPresent(self.resetsAt, forKey: .resetsAt)
+        try container.encode(self.hasResetDescription, forKey: .hasResetDescription)
+        try container.encodeIfPresent(self.nextRegenPercent, forKey: .nextRegenPercent)
+        if !self.usageKnown {
+            try container.encode(false, forKey: .usageKnown)
+        }
+    }
+}
+
+public struct ProviderDiagnosticFetchAttempt: Codable, Sendable {
+    public let kind: String
+    public let wasAvailable: Bool
+    public let errorCategory: String?
+
+    public init(
+        kind: String,
+        wasAvailable: Bool,
+        errorCategory: String?)
+    {
+        self.kind = kind
+        self.wasAvailable = wasAvailable
+        self.errorCategory = errorCategory
+    }
+
+    public init(from attempt: ProviderFetchAttempt) {
+        self.kind = Self.kindLabel(attempt.kind)
+        self.wasAvailable = attempt.wasAvailable
+        self.errorCategory = attempt.errorDescription.map(Self.errorCategoryLabel)
+    }
+
+    public static func kindLabel(_ kind: ProviderFetchKind) -> String {
+        switch kind {
+        case .cli: "cli"
+        case .web: "web"
+        case .oauth: "oauth"
+        case .apiToken: "api"
+        case .localProbe: "local"
+        case .webDashboard: "web"
+        }
+    }
+
+    public static func errorCategoryLabel(_ description: String?) -> String {
+        guard let desc = description?.lowercased() else { return "unknown" }
+        if desc.contains("endpoint override") {
+            return "configuration"
+        }
+        if desc.contains("network") || desc.contains("timeout") || desc.contains("connection") {
+            return "network"
+        }
+        if desc.contains("auth") || desc.contains("credential") || desc.contains("token") || desc.contains("cookie") ||
+            desc.contains("api key") || desc.contains("key not configured") || desc.contains("missing key")
+        {
+            return "auth"
+        }
+        if desc.contains("source") || desc.contains("not supported") || desc.contains("unavailable") {
+            return "configuration"
+        }
+        if desc.contains("api") || desc.contains("http") || desc.contains("404") || desc.contains("403") {
+            return "api"
+        }
+        if desc.contains("parse") || desc.contains("format") || desc.contains("decode") {
+            return "parse"
+        }
+        return "unknown"
+    }
+}
+
+public struct ProviderDiagnosticError: Codable, Sendable {
+    public let category: String
+    public let safeDescription: String
+
+    public init(category: String, safeDescription: String) {
+        self.category = category
+        self.safeDescription = safeDescription
+    }
+
+    public init(from error: Error, authConfigured: Bool) {
+        self.category = Self.errorCategory(error, authConfigured: authConfigured)
+        self.safeDescription = Self.safeDescription(category: self.category)
+    }
+
+    private static func errorCategory(_ error: Error, authConfigured: Bool) -> String {
+        if case ProviderFetchError.noAvailableStrategy = error {
+            return authConfigured ? "configuration" : "auth"
+        }
+        if error is ProviderEndpointOverrideError {
+            return "configuration"
+        }
+        if let minimaxError = error as? MiniMaxUsageError {
+            switch minimaxError {
+            case .networkError: return "network"
+            case .invalidCredentials: return "auth"
+            case .apiError: return "api"
+            case .parseFailed: return "parse"
+            }
+        }
+        if let alibabaError = error as? AlibabaCodingPlanUsageError {
+            switch alibabaError {
+            case .networkError: return "network"
+            case .loginRequired, .invalidCredentials: return "auth"
+            case .apiError, .apiKeyUnavailableInRegion: return "api"
+            case .parseFailed: return "parse"
+            }
+        }
+        if error is MiniMaxSettingsError || error is MiniMaxAPISettingsError { return "auth" }
+        return ProviderDiagnosticFetchAttempt.errorCategoryLabel(error.localizedDescription)
+    }
+
+    private static func safeDescription(category: String) -> String {
+        switch category {
+        case "network":
+            "Network error - check your connection"
+        case "auth":
+            "Authentication or setup issue - check provider credentials"
+        case "api":
+            "API error - service returned an unexpected response"
+        case "parse":
+            "Parse error - unexpected response format"
+        case "configuration":
+            "Configuration issue - check provider source and settings"
+        default:
+            "An unexpected error occurred"
+        }
+    }
+}
+
+public struct ProviderDiagnosticSettingsSummary: Codable, Sendable {
+    public let sourceMode: String
+    public let apiRegion: String?
+
+    public init(sourceMode: ProviderSourceMode, apiRegion: String? = nil) {
+        self.sourceMode = sourceMode.rawValue
+        self.apiRegion = apiRegion
+    }
+}
+
+public enum ProviderDiagnosticDetails: Codable, Sendable {
+    case minimax(MiniMaxDiagnosticDetails)
+
+    private enum CodingKeys: String, CodingKey {
+        case type
+        case minimax
+    }
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        let type = try container.decode(String.self, forKey: .type)
+        switch type {
+        case "minimax":
+            self = try .minimax(container.decode(MiniMaxDiagnosticDetails.self, forKey: .minimax))
+        default:
+            throw DecodingError.dataCorruptedError(
+                forKey: .type,
+                in: container,
+                debugDescription: "Unknown provider diagnostic detail type")
+        }
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        switch self {
+        case let .minimax(details):
+            try container.encode("minimax", forKey: .type)
+            try container.encode(details, forKey: .minimax)
+        }
+    }
+}
+
+public struct MiniMaxDiagnosticDetails: Codable, Sendable {
+    public let planName: String?
+    public let availablePrompts: Int?
+    public let currentPrompts: Int?
+    public let remainingPrompts: Int?
+    public let windowMinutes: Int?
+    public let usedPercent: Double?
+    public let resetsAt: Date?
+    public let services: [MiniMaxDiagnosticServiceUsage]?
+    public let billingSummaryPresent: Bool
+
+    public init(from snapshot: MiniMaxUsageSnapshot) {
+        self.planName = snapshot.planName
+        self.availablePrompts = snapshot.availablePrompts
+        self.currentPrompts = snapshot.currentPrompts
+        self.remainingPrompts = snapshot.remainingPrompts
+        self.windowMinutes = snapshot.windowMinutes
+        self.usedPercent = snapshot.usedPercent
+        self.resetsAt = snapshot.resetsAt
+        self.services = snapshot.services?.map { MiniMaxDiagnosticServiceUsage(from: $0) }
+        self.billingSummaryPresent = snapshot.billingSummary != nil
+    }
+}
+
+public struct MiniMaxDiagnosticServiceUsage: Codable, Sendable {
+    public let displayName: String
+    public let percent: Double
+    public let usage: Int
+    public let limit: Int
+    public let remaining: Int?
+    public let isUnlimited: Bool
+    public let windowType: String
+    public let resetsAt: Date?
+    public let hasResetDescription: Bool
+
+    private enum CodingKeys: String, CodingKey {
+        case displayName
+        case percent
+        case usage
+        case limit
+        case remaining
+        case isUnlimited
+        case windowType
+        case resetsAt
+        case hasResetDescription
+    }
+
+    public init(from service: MiniMaxServiceUsage) {
+        self.displayName = service.displayName
+        self.percent = service.percent
+        self.usage = service.usage
+        self.limit = service.limit
+        self.remaining = service.isUnlimited ? nil : max(0, service.limit - service.usage)
+        self.isUnlimited = service.isUnlimited
+        self.windowType = service.windowType
+        self.resetsAt = service.resetsAt
+        self.hasResetDescription = !service.resetDescription.isEmpty
+    }
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.displayName = try container.decode(String.self, forKey: .displayName)
+        self.percent = try container.decode(Double.self, forKey: .percent)
+        self.usage = try container.decodeIfPresent(Int.self, forKey: .usage) ?? 0
+        self.limit = try container.decodeIfPresent(Int.self, forKey: .limit) ?? 0
+        self.remaining = try container.decodeIfPresent(Int.self, forKey: .remaining)
+        self.isUnlimited = try container.decodeIfPresent(Bool.self, forKey: .isUnlimited) ?? false
+        self.windowType = try container.decode(String.self, forKey: .windowType)
+        self.resetsAt = try container.decodeIfPresent(Date.self, forKey: .resetsAt)
+        self.hasResetDescription = try container.decode(Bool.self, forKey: .hasResetDescription)
+    }
+}
+
+public enum ProviderDiagnosticExportBuilder {
+    public struct Input: Sendable {
+        public let provider: UsageProvider
+        public let descriptor: ProviderDescriptor
+        public let outcome: ProviderFetchOutcome
+        public let sourceMode: ProviderSourceMode
+        public let settings: ProviderSettingsSnapshot?
+        public let auth: ProviderDiagnosticAuthSummary
+        public let appVersion: String?
+
+        public init(
+            provider: UsageProvider,
+            descriptor: ProviderDescriptor,
+            outcome: ProviderFetchOutcome,
+            sourceMode: ProviderSourceMode,
+            settings: ProviderSettingsSnapshot?,
+            auth: ProviderDiagnosticAuthSummary,
+            appVersion: String? = nil)
+        {
+            self.provider = provider
+            self.descriptor = descriptor
+            self.outcome = outcome
+            self.sourceMode = sourceMode
+            self.settings = settings
+            self.auth = auth
+            self.appVersion = appVersion
+        }
+    }
+
+    public static func build(_ input: Input) -> ProviderDiagnosticExport {
+        let resolvedAuth = input.auth.resolved(with: input.outcome)
+        let usage = input.outcome.usageSnapshot.map { ProviderDiagnosticUsageSummary(from: $0) }
+        let error = input.outcome.failureError
+            .map { ProviderDiagnosticError(from: $0, authConfigured: resolvedAuth.configured) }
+        let settingsSummary = ProviderDiagnosticSettingsSummary(
+            sourceMode: input.sourceMode,
+            apiRegion: Self.safeAPIRegion(provider: input.provider, settings: input.settings))
+
+        return ProviderDiagnosticExport(
+            timestamp: Date(),
+            appVersion: input.appVersion,
+            provider: input.provider.rawValue,
+            displayName: input.descriptor.metadata.displayName,
+            source: input.outcome.sourceLabel,
+            sourceMode: input.sourceMode.rawValue,
+            auth: resolvedAuth,
+            usage: usage,
+            fetchAttempts: input.outcome.attempts.map { ProviderDiagnosticFetchAttempt(from: $0) },
+            error: error,
+            settings: settingsSummary,
+            details: Self.details(provider: input.provider, outcome: input.outcome))
+    }
+
+    private static func safeAPIRegion(provider: UsageProvider, settings: ProviderSettingsSnapshot?) -> String? {
+        guard provider == .minimax else { return nil }
+        return settings?.minimax?.apiRegion.rawValue ?? "global"
+    }
+
+    private static func details(provider: UsageProvider, outcome: ProviderFetchOutcome) -> ProviderDiagnosticDetails? {
+        guard provider == .minimax,
+              let usage = outcome.usageSnapshot?.minimaxUsage
+        else {
+            return nil
+        }
+        return .minimax(MiniMaxDiagnosticDetails(from: usage))
+    }
+}
+
+extension ProviderFetchOutcome {
+    fileprivate var isSuccess: Bool {
+        guard case .success = self.result else { return false }
+        return true
+    }
+
+    fileprivate var sourceLabel: String {
+        guard case let .success(result) = result else { return "failed" }
+        return result.sourceLabel
+    }
+
+    fileprivate var usageSnapshot: UsageSnapshot? {
+        guard case let .success(result) = result else { return nil }
+        return result.usage
+    }
+
+    fileprivate var failureError: Error? {
+        guard case let .failure(error) = result else { return nil }
+        return error
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/ProviderEnvironmentResolver.swift b/Sources/CodexBarCore/Providers/ProviderEnvironmentResolver.swift
new file mode 100644
index 0000000000..4bc0e53a9b
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/ProviderEnvironmentResolver.swift
@@ -0,0 +1,28 @@
+import Foundation
+
+public enum ProviderEnvironmentResolver {
+    public static func resolve(
+        base: [String: String],
+        provider: UsageProvider,
+        config: ProviderConfig?,
+        selectedAccount: ProviderTokenAccount?) -> [String: String]
+    {
+        var environment = ProviderConfigEnvironment.applyProviderConfigOverrides(
+            base: base,
+            provider: provider,
+            config: config)
+        guard let selectedAccount else { return environment }
+
+        TokenAccountSupportCatalog.scrubEnvironmentForSelectedAccount(
+            &environment,
+            provider: provider,
+            token: selectedAccount.token)
+        if let override = TokenAccountSupportCatalog.envOverride(
+            for: provider,
+            token: selectedAccount.token)
+        {
+            environment.merge(override) { _, selectedAccountValue in selectedAccountValue }
+        }
+        return environment
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/ProviderFetchPlan.swift b/Sources/CodexBarCore/Providers/ProviderFetchPlan.swift
index cadbdc813c..95fabe2d9d 100644
--- a/Sources/CodexBarCore/Providers/ProviderFetchPlan.swift
+++ b/Sources/CodexBarCore/Providers/ProviderFetchPlan.swift
@@ -18,9 +18,13 @@ public enum ProviderSourceMode: String, CaseIterable, Sendable, Codable {
 }
 
 public struct ProviderFetchContext: Sendable {
+    public typealias TokenAccountTokenUpdater = @Sendable (UsageProvider, UUID, String) async -> Void
+    public typealias ProviderManualTokenUpdater = @Sendable (UsageProvider, String) async -> Void
+
     public let runtime: ProviderRuntime
     public let sourceMode: ProviderSourceMode
     public let includeCredits: Bool
+    public let includeOptionalUsage: Bool
     public let webTimeout: TimeInterval
     public let webDebugDumpHTML: Bool
     public let verbose: Bool
@@ -29,11 +33,25 @@ public struct ProviderFetchContext: Sendable {
     public let fetcher: UsageFetcher
     public let claudeFetcher: any ClaudeUsageFetching
     public let browserDetection: BrowserDetection
+    public let selectedTokenAccountID: UUID?
+    public let tokenAccountTokenUpdater: TokenAccountTokenUpdater?
+    public let providerManualTokenUpdater: ProviderManualTokenUpdater?
+    public let costUsageHistoryDays: Int
+    /// Whether warm CLI helper sessions (such as the managed Antigravity `agy`
+    /// process) may outlive a single fetch. True for long-lived hosts (the app,
+    /// `codexbar serve`); false for one-shot CLI invocations that should reset
+    /// the session after each fetch.
+    public let persistsCLISessions: Bool
+    /// Minimum idle lifetime for persistent CLI helper sessions. Long-lived
+    /// hosts set this beyond their refresh cadence so a slow cold start can
+    /// recover on the next refresh.
+    public let persistentCLISessionIdleWindow: TimeInterval?
 
     public init(
         runtime: ProviderRuntime,
         sourceMode: ProviderSourceMode,
         includeCredits: Bool,
+        includeOptionalUsage: Bool = true,
         webTimeout: TimeInterval,
         webDebugDumpHTML: Bool,
         verbose: Bool,
@@ -41,11 +59,18 @@ public struct ProviderFetchContext: Sendable {
         settings: ProviderSettingsSnapshot?,
         fetcher: UsageFetcher,
         claudeFetcher: any ClaudeUsageFetching,
-        browserDetection: BrowserDetection)
+        browserDetection: BrowserDetection,
+        selectedTokenAccountID: UUID? = nil,
+        tokenAccountTokenUpdater: TokenAccountTokenUpdater? = nil,
+        providerManualTokenUpdater: ProviderManualTokenUpdater? = nil,
+        costUsageHistoryDays: Int = 30,
+        persistsCLISessions: Bool = false,
+        persistentCLISessionIdleWindow: TimeInterval? = nil)
     {
         self.runtime = runtime
         self.sourceMode = sourceMode
         self.includeCredits = includeCredits
+        self.includeOptionalUsage = includeOptionalUsage
         self.webTimeout = webTimeout
         self.webDebugDumpHTML = webDebugDumpHTML
         self.verbose = verbose
@@ -54,6 +79,18 @@ public struct ProviderFetchContext: Sendable {
         self.fetcher = fetcher
         self.claudeFetcher = claudeFetcher
         self.browserDetection = browserDetection
+        self.selectedTokenAccountID = selectedTokenAccountID
+        self.tokenAccountTokenUpdater = tokenAccountTokenUpdater
+        self.providerManualTokenUpdater = providerManualTokenUpdater
+        self.costUsageHistoryDays = max(1, min(365, costUsageHistoryDays))
+        self.persistsCLISessions = persistsCLISessions
+        self.persistentCLISessionIdleWindow = persistentCLISessionIdleWindow
+    }
+}
+
+public enum ProviderCLISessionLifecycle {
+    public static func shutdownPersistentSessions() async {
+        await AntigravityCLISession.shared.reset()
     }
 }
 
@@ -162,6 +199,7 @@ public struct ProviderFetchPipeline: Sendable {
         let strategies = await self.resolveStrategies(context)
         var attempts: [ProviderFetchAttempt] = []
         attempts.reserveCapacity(strategies.count)
+        var lastAvailableError: Error?
 
         for strategy in strategies {
             let available = await strategy.isAvailable(context)
@@ -184,6 +222,7 @@ public struct ProviderFetchPipeline: Sendable {
                     errorDescription: nil))
                 return ProviderFetchOutcome(result: .success(result), attempts: attempts)
             } catch {
+                lastAvailableError = error
                 attempts.append(ProviderFetchAttempt(
                     strategyID: strategy.id,
                     kind: strategy.kind,
@@ -196,7 +235,7 @@ public struct ProviderFetchPipeline: Sendable {
             }
         }
 
-        let error = ProviderFetchError.noAvailableStrategy(provider)
+        let error = lastAvailableError ?? ProviderFetchError.noAvailableStrategy(provider)
         return ProviderFetchOutcome(result: .failure(error), attempts: attempts)
     }
 }
diff --git a/Sources/CodexBarCore/Providers/ProviderSettingsSnapshot.swift b/Sources/CodexBarCore/Providers/ProviderSettingsSnapshot.swift
index e9bf84f9e7..88cd14f15d 100644
--- a/Sources/CodexBarCore/Providers/ProviderSettingsSnapshot.swift
+++ b/Sources/CodexBarCore/Providers/ProviderSettingsSnapshot.swift
@@ -1,5 +1,12 @@
 import Foundation
 
+public protocol ProviderCookieSettings: Sendable {
+    var cookieSource: ProviderCookieSource { get }
+    var manualCookieHeader: String? { get }
+
+    init(cookieSource: ProviderCookieSource, manualCookieHeader: String?)
+}
+
 public struct ProviderSettingsSnapshot: Sendable {
     public static func make(
         debugMenuEnabled: Bool = false,
@@ -8,16 +15,30 @@ public struct ProviderSettingsSnapshot: Sendable {
         claude: ClaudeProviderSettings? = nil,
         cursor: CursorProviderSettings? = nil,
         opencode: OpenCodeProviderSettings? = nil,
+        opencodego: OpenCodeProviderSettings? = nil,
+        alibaba: AlibabaCodingPlanProviderSettings? = nil,
+        alibabaTokenPlan: AlibabaTokenPlanProviderSettings? = nil,
         factory: FactoryProviderSettings? = nil,
         minimax: MiniMaxProviderSettings? = nil,
+        manus: ManusProviderSettings? = nil,
         zai: ZaiProviderSettings? = nil,
         copilot: CopilotProviderSettings? = nil,
         kilo: KiloProviderSettings? = nil,
         kimi: KimiProviderSettings? = nil,
         augment: AugmentProviderSettings? = nil,
+        moonshot: MoonshotProviderSettings? = nil,
         amp: AmpProviderSettings? = nil,
+        t3chat: T3ChatProviderSettings? = nil,
+        devin: DevinProviderSettings? = nil,
+        commandcode: CommandCodeProviderSettings? = nil,
         ollama: OllamaProviderSettings? = nil,
-        jetbrains: JetBrainsProviderSettings? = nil) -> ProviderSettingsSnapshot
+        jetbrains: JetBrainsProviderSettings? = nil,
+        windsurf: WindsurfProviderSettings? = nil,
+        perplexity: PerplexityProviderSettings? = nil,
+        mimo: MiMoProviderSettings? = nil,
+        abacus: AbacusProviderSettings? = nil,
+        mistral: MistralProviderSettings? = nil,
+        stepfun: StepFunProviderSettings? = nil) -> ProviderSettingsSnapshot
     {
         ProviderSettingsSnapshot(
             debugMenuEnabled: debugMenuEnabled,
@@ -26,31 +47,60 @@ public struct ProviderSettingsSnapshot: Sendable {
             claude: claude,
             cursor: cursor,
             opencode: opencode,
+            opencodego: opencodego,
+            alibaba: alibaba,
+            alibabaTokenPlan: alibabaTokenPlan,
             factory: factory,
             minimax: minimax,
+            manus: manus,
             zai: zai,
             copilot: copilot,
             kilo: kilo,
             kimi: kimi,
             augment: augment,
+            moonshot: moonshot,
             amp: amp,
+            t3chat: t3chat,
+            devin: devin,
+            commandcode: commandcode,
             ollama: ollama,
-            jetbrains: jetbrains)
+            jetbrains: jetbrains,
+            windsurf: windsurf,
+            perplexity: perplexity,
+            mimo: mimo,
+            abacus: abacus,
+            mistral: mistral,
+            stepfun: stepfun)
     }
 
     public struct CodexProviderSettings: Sendable {
         public let usageDataSource: CodexUsageDataSource
         public let cookieSource: ProviderCookieSource
         public let manualCookieHeader: String?
+        public let managedAccountStoreUnreadable: Bool
+        public let managedAccountTargetUnavailable: Bool
+        public let profileAccountTargetUnavailable: Bool
+        public let openAIWebCacheScope: CookieHeaderCache.Scope?
+        public let dashboardAuthorityKnownOwners: [CodexDashboardKnownOwnerCandidate]
 
         public init(
             usageDataSource: CodexUsageDataSource,
             cookieSource: ProviderCookieSource,
-            manualCookieHeader: String?)
+            manualCookieHeader: String?,
+            managedAccountStoreUnreadable: Bool = false,
+            managedAccountTargetUnavailable: Bool = false,
+            profileAccountTargetUnavailable: Bool = false,
+            openAIWebCacheScope: CookieHeaderCache.Scope? = nil,
+            dashboardAuthorityKnownOwners: [CodexDashboardKnownOwnerCandidate] = [])
         {
             self.usageDataSource = usageDataSource
             self.cookieSource = cookieSource
             self.manualCookieHeader = manualCookieHeader
+            self.managedAccountStoreUnreadable = managedAccountStoreUnreadable
+            self.managedAccountTargetUnavailable = managedAccountTargetUnavailable
+            self.profileAccountTargetUnavailable = profileAccountTargetUnavailable
+            self.openAIWebCacheScope = openAIWebCacheScope
+            self.dashboardAuthorityKnownOwners = dashboardAuthorityKnownOwners
         }
     }
 
@@ -59,21 +109,34 @@ public struct ProviderSettingsSnapshot: Sendable {
         public let webExtrasEnabled: Bool
         public let cookieSource: ProviderCookieSource
         public let manualCookieHeader: String?
+        public let organizationID: String?
 
         public init(
             usageDataSource: ClaudeUsageDataSource,
             webExtrasEnabled: Bool,
             cookieSource: ProviderCookieSource,
-            manualCookieHeader: String?)
+            manualCookieHeader: String?,
+            organizationID: String? = nil)
         {
             self.usageDataSource = usageDataSource
             self.webExtrasEnabled = webExtrasEnabled
             self.cookieSource = cookieSource
             self.manualCookieHeader = manualCookieHeader
+            self.organizationID = organizationID
         }
     }
 
-    public struct CursorProviderSettings: Sendable {
+    public struct CookieProviderSettings: ProviderCookieSettings {
+        public let cookieSource: ProviderCookieSource
+        public let manualCookieHeader: String?
+
+        public init(cookieSource: ProviderCookieSource = .auto, manualCookieHeader: String? = nil) {
+            self.cookieSource = cookieSource
+            self.manualCookieHeader = manualCookieHeader
+        }
+    }
+
+    public struct CursorProviderSettings: ProviderCookieSettings {
         public let cookieSource: ProviderCookieSource
         public let manualCookieHeader: String?
 
@@ -95,7 +158,33 @@ public struct ProviderSettingsSnapshot: Sendable {
         }
     }
 
-    public struct FactoryProviderSettings: Sendable {
+    public struct AlibabaCodingPlanProviderSettings: Sendable {
+        public let cookieSource: ProviderCookieSource
+        public let manualCookieHeader: String?
+        public let apiRegion: AlibabaCodingPlanAPIRegion
+
+        public init(
+            cookieSource: ProviderCookieSource = .auto,
+            manualCookieHeader: String? = nil,
+            apiRegion: AlibabaCodingPlanAPIRegion = .international)
+        {
+            self.cookieSource = cookieSource
+            self.manualCookieHeader = manualCookieHeader
+            self.apiRegion = apiRegion
+        }
+    }
+
+    public struct AlibabaTokenPlanProviderSettings: ProviderCookieSettings {
+        public let cookieSource: ProviderCookieSource
+        public let manualCookieHeader: String?
+
+        public init(cookieSource: ProviderCookieSource = .auto, manualCookieHeader: String? = nil) {
+            self.cookieSource = cookieSource
+            self.manualCookieHeader = manualCookieHeader
+        }
+    }
+
+    public struct FactoryProviderSettings: ProviderCookieSettings {
         public let cookieSource: ProviderCookieSource
         public let manualCookieHeader: String?
 
@@ -121,6 +210,16 @@ public struct ProviderSettingsSnapshot: Sendable {
         }
     }
 
+    public struct ManusProviderSettings: ProviderCookieSettings {
+        public let cookieSource: ProviderCookieSource
+        public let manualCookieHeader: String?
+
+        public init(cookieSource: ProviderCookieSource, manualCookieHeader: String?) {
+            self.cookieSource = cookieSource
+            self.manualCookieHeader = manualCookieHeader
+        }
+    }
+
     public struct ZaiProviderSettings: Sendable {
         public let apiRegion: ZaiAPIRegion
 
@@ -130,7 +229,28 @@ public struct ProviderSettingsSnapshot: Sendable {
     }
 
     public struct CopilotProviderSettings: Sendable {
-        public init() {}
+        public let apiToken: String?
+        public let enterpriseHost: String?
+        public let selectedAccountExternalIdentifier: String?
+        public let budgetExtrasEnabled: Bool
+        public let budgetCookieSource: ProviderCookieSource
+        public let manualBudgetCookieHeader: String?
+
+        public init(
+            apiToken: String? = nil,
+            enterpriseHost: String? = nil,
+            selectedAccountExternalIdentifier: String? = nil,
+            budgetExtrasEnabled: Bool = false,
+            budgetCookieSource: ProviderCookieSource = .auto,
+            manualBudgetCookieHeader: String? = nil)
+        {
+            self.apiToken = apiToken
+            self.enterpriseHost = enterpriseHost
+            self.selectedAccountExternalIdentifier = selectedAccountExternalIdentifier
+            self.budgetExtrasEnabled = budgetExtrasEnabled
+            self.budgetCookieSource = budgetCookieSource
+            self.manualBudgetCookieHeader = manualBudgetCookieHeader
+        }
     }
 
     public struct KiloProviderSettings: Sendable {
@@ -143,7 +263,7 @@ public struct ProviderSettingsSnapshot: Sendable {
         }
     }
 
-    public struct KimiProviderSettings: Sendable {
+    public struct KimiProviderSettings: ProviderCookieSettings {
         public let cookieSource: ProviderCookieSource
         public let manualCookieHeader: String?
 
@@ -153,7 +273,7 @@ public struct ProviderSettingsSnapshot: Sendable {
         }
     }
 
-    public struct AugmentProviderSettings: Sendable {
+    public struct AugmentProviderSettings: ProviderCookieSettings {
         public let cookieSource: ProviderCookieSource
         public let manualCookieHeader: String?
 
@@ -163,6 +283,14 @@ public struct ProviderSettingsSnapshot: Sendable {
         }
     }
 
+    public struct MoonshotProviderSettings: Sendable {
+        public let region: MoonshotRegion?
+
+        public init(region: MoonshotRegion? = nil) {
+            self.region = region
+        }
+    }
+
     public struct JetBrainsProviderSettings: Sendable {
         public let ideBasePath: String?
 
@@ -171,7 +299,75 @@ public struct ProviderSettingsSnapshot: Sendable {
         }
     }
 
-    public struct AmpProviderSettings: Sendable {
+    public struct AmpProviderSettings: ProviderCookieSettings {
+        public let cookieSource: ProviderCookieSource
+        public let manualCookieHeader: String?
+
+        public init(cookieSource: ProviderCookieSource, manualCookieHeader: String?) {
+            self.cookieSource = cookieSource
+            self.manualCookieHeader = manualCookieHeader
+        }
+    }
+
+    public struct T3ChatProviderSettings: ProviderCookieSettings {
+        public let cookieSource: ProviderCookieSource
+        public let manualCookieHeader: String?
+
+        public init(cookieSource: ProviderCookieSource, manualCookieHeader: String?) {
+            self.cookieSource = cookieSource
+            self.manualCookieHeader = manualCookieHeader
+        }
+    }
+
+    public struct DevinProviderSettings: Sendable {
+        public let cookieSource: ProviderCookieSource
+        public let manualBearerToken: String?
+        public let organization: String?
+
+        public init(cookieSource: ProviderCookieSource, manualBearerToken: String?, organization: String?) {
+            self.cookieSource = cookieSource
+            self.manualBearerToken = manualBearerToken
+            self.organization = organization
+        }
+    }
+
+    public struct CommandCodeProviderSettings: ProviderCookieSettings {
+        public let cookieSource: ProviderCookieSource
+        public let manualCookieHeader: String?
+
+        public init(cookieSource: ProviderCookieSource, manualCookieHeader: String?) {
+            self.cookieSource = cookieSource
+            self.manualCookieHeader = manualCookieHeader
+        }
+    }
+
+    public struct OllamaProviderSettings: ProviderCookieSettings {
+        public let cookieSource: ProviderCookieSource
+        public let manualCookieHeader: String?
+
+        public init(cookieSource: ProviderCookieSource, manualCookieHeader: String?) {
+            self.cookieSource = cookieSource
+            self.manualCookieHeader = manualCookieHeader
+        }
+    }
+
+    public struct WindsurfProviderSettings: Sendable {
+        public let usageDataSource: WindsurfUsageDataSource
+        public let cookieSource: ProviderCookieSource
+        public let manualCookieHeader: String?
+
+        public init(
+            usageDataSource: WindsurfUsageDataSource,
+            cookieSource: ProviderCookieSource,
+            manualCookieHeader: String?)
+        {
+            self.usageDataSource = usageDataSource
+            self.cookieSource = cookieSource
+            self.manualCookieHeader = manualCookieHeader
+        }
+    }
+
+    public struct PerplexityProviderSettings: ProviderCookieSettings {
         public let cookieSource: ProviderCookieSource
         public let manualCookieHeader: String?
 
@@ -181,7 +377,7 @@ public struct ProviderSettingsSnapshot: Sendable {
         }
     }
 
-    public struct OllamaProviderSettings: Sendable {
+    public struct MiMoProviderSettings: ProviderCookieSettings {
         public let cookieSource: ProviderCookieSource
         public let manualCookieHeader: String?
 
@@ -191,22 +387,75 @@ public struct ProviderSettingsSnapshot: Sendable {
         }
     }
 
+    public struct AbacusProviderSettings: ProviderCookieSettings {
+        public let cookieSource: ProviderCookieSource
+        public let manualCookieHeader: String?
+
+        public init(cookieSource: ProviderCookieSource, manualCookieHeader: String?) {
+            self.cookieSource = cookieSource
+            self.manualCookieHeader = manualCookieHeader
+        }
+    }
+
+    public struct MistralProviderSettings: ProviderCookieSettings {
+        public let cookieSource: ProviderCookieSource
+        public let manualCookieHeader: String?
+
+        public init(cookieSource: ProviderCookieSource, manualCookieHeader: String?) {
+            self.cookieSource = cookieSource
+            self.manualCookieHeader = manualCookieHeader
+        }
+    }
+
+    public struct StepFunProviderSettings: Sendable {
+        public let cookieSource: ProviderCookieSource
+        public let manualToken: String
+        public let username: String
+        public let password: String
+
+        public init(
+            cookieSource: ProviderCookieSource = .auto,
+            manualToken: String = "",
+            username: String = "",
+            password: String = "")
+        {
+            self.cookieSource = cookieSource
+            self.manualToken = manualToken
+            self.username = username
+            self.password = password
+        }
+    }
+
     public let debugMenuEnabled: Bool
     public let debugKeepCLISessionsAlive: Bool
     public let codex: CodexProviderSettings?
     public let claude: ClaudeProviderSettings?
     public let cursor: CursorProviderSettings?
     public let opencode: OpenCodeProviderSettings?
+    public let opencodego: OpenCodeProviderSettings?
+    public let alibaba: AlibabaCodingPlanProviderSettings?
+    public let alibabaTokenPlan: AlibabaTokenPlanProviderSettings?
     public let factory: FactoryProviderSettings?
     public let minimax: MiniMaxProviderSettings?
+    public let manus: ManusProviderSettings?
     public let zai: ZaiProviderSettings?
     public let copilot: CopilotProviderSettings?
     public let kilo: KiloProviderSettings?
     public let kimi: KimiProviderSettings?
     public let augment: AugmentProviderSettings?
+    public let moonshot: MoonshotProviderSettings?
     public let amp: AmpProviderSettings?
+    public let t3chat: T3ChatProviderSettings?
+    public let devin: DevinProviderSettings?
+    public let commandcode: CommandCodeProviderSettings?
     public let ollama: OllamaProviderSettings?
     public let jetbrains: JetBrainsProviderSettings?
+    public let windsurf: WindsurfProviderSettings?
+    public let perplexity: PerplexityProviderSettings?
+    public let mimo: MiMoProviderSettings?
+    public let abacus: AbacusProviderSettings?
+    public let mistral: MistralProviderSettings?
+    public let stepfun: StepFunProviderSettings?
 
     public var jetbrainsIDEBasePath: String? {
         self.jetbrains?.ideBasePath
@@ -219,16 +468,30 @@ public struct ProviderSettingsSnapshot: Sendable {
         claude: ClaudeProviderSettings?,
         cursor: CursorProviderSettings?,
         opencode: OpenCodeProviderSettings?,
+        opencodego: OpenCodeProviderSettings?,
+        alibaba: AlibabaCodingPlanProviderSettings?,
+        alibabaTokenPlan: AlibabaTokenPlanProviderSettings? = nil,
         factory: FactoryProviderSettings?,
         minimax: MiniMaxProviderSettings?,
+        manus: ManusProviderSettings?,
         zai: ZaiProviderSettings?,
         copilot: CopilotProviderSettings?,
         kilo: KiloProviderSettings?,
         kimi: KimiProviderSettings?,
         augment: AugmentProviderSettings?,
+        moonshot: MoonshotProviderSettings? = nil,
         amp: AmpProviderSettings?,
+        t3chat: T3ChatProviderSettings? = nil,
+        devin: DevinProviderSettings? = nil,
+        commandcode: CommandCodeProviderSettings? = nil,
         ollama: OllamaProviderSettings?,
-        jetbrains: JetBrainsProviderSettings? = nil)
+        jetbrains: JetBrainsProviderSettings? = nil,
+        windsurf: WindsurfProviderSettings? = nil,
+        perplexity: PerplexityProviderSettings? = nil,
+        mimo: MiMoProviderSettings? = nil,
+        abacus: AbacusProviderSettings? = nil,
+        mistral: MistralProviderSettings? = nil,
+        stepfun: StepFunProviderSettings? = nil)
     {
         self.debugMenuEnabled = debugMenuEnabled
         self.debugKeepCLISessionsAlive = debugKeepCLISessionsAlive
@@ -236,16 +499,30 @@ public struct ProviderSettingsSnapshot: Sendable {
         self.claude = claude
         self.cursor = cursor
         self.opencode = opencode
+        self.opencodego = opencodego
+        self.alibaba = alibaba
+        self.alibabaTokenPlan = alibabaTokenPlan
         self.factory = factory
         self.minimax = minimax
+        self.manus = manus
         self.zai = zai
         self.copilot = copilot
         self.kilo = kilo
         self.kimi = kimi
         self.augment = augment
+        self.moonshot = moonshot
         self.amp = amp
+        self.t3chat = t3chat
+        self.devin = devin
+        self.commandcode = commandcode
         self.ollama = ollama
         self.jetbrains = jetbrains
+        self.windsurf = windsurf
+        self.perplexity = perplexity
+        self.mimo = mimo
+        self.abacus = abacus
+        self.mistral = mistral
+        self.stepfun = stepfun
     }
 }
 
@@ -254,16 +531,30 @@ public enum ProviderSettingsSnapshotContribution: Sendable {
     case claude(ProviderSettingsSnapshot.ClaudeProviderSettings)
     case cursor(ProviderSettingsSnapshot.CursorProviderSettings)
     case opencode(ProviderSettingsSnapshot.OpenCodeProviderSettings)
+    case opencodego(ProviderSettingsSnapshot.OpenCodeProviderSettings)
+    case alibaba(ProviderSettingsSnapshot.AlibabaCodingPlanProviderSettings)
+    case alibabaTokenPlan(ProviderSettingsSnapshot.AlibabaTokenPlanProviderSettings)
     case factory(ProviderSettingsSnapshot.FactoryProviderSettings)
     case minimax(ProviderSettingsSnapshot.MiniMaxProviderSettings)
+    case manus(ProviderSettingsSnapshot.ManusProviderSettings)
     case zai(ProviderSettingsSnapshot.ZaiProviderSettings)
     case copilot(ProviderSettingsSnapshot.CopilotProviderSettings)
     case kilo(ProviderSettingsSnapshot.KiloProviderSettings)
     case kimi(ProviderSettingsSnapshot.KimiProviderSettings)
     case augment(ProviderSettingsSnapshot.AugmentProviderSettings)
+    case moonshot(ProviderSettingsSnapshot.MoonshotProviderSettings)
     case amp(ProviderSettingsSnapshot.AmpProviderSettings)
+    case t3chat(ProviderSettingsSnapshot.T3ChatProviderSettings)
+    case devin(ProviderSettingsSnapshot.DevinProviderSettings)
+    case commandcode(ProviderSettingsSnapshot.CommandCodeProviderSettings)
     case ollama(ProviderSettingsSnapshot.OllamaProviderSettings)
     case jetbrains(ProviderSettingsSnapshot.JetBrainsProviderSettings)
+    case windsurf(ProviderSettingsSnapshot.WindsurfProviderSettings)
+    case perplexity(ProviderSettingsSnapshot.PerplexityProviderSettings)
+    case mimo(ProviderSettingsSnapshot.MiMoProviderSettings)
+    case abacus(ProviderSettingsSnapshot.AbacusProviderSettings)
+    case mistral(ProviderSettingsSnapshot.MistralProviderSettings)
+    case stepfun(ProviderSettingsSnapshot.StepFunProviderSettings)
 }
 
 public struct ProviderSettingsSnapshotBuilder: Sendable {
@@ -273,38 +564,67 @@ public struct ProviderSettingsSnapshotBuilder: Sendable {
     public var claude: ProviderSettingsSnapshot.ClaudeProviderSettings?
     public var cursor: ProviderSettingsSnapshot.CursorProviderSettings?
     public var opencode: ProviderSettingsSnapshot.OpenCodeProviderSettings?
+    public var opencodego: ProviderSettingsSnapshot.OpenCodeProviderSettings?
+    public var alibaba: ProviderSettingsSnapshot.AlibabaCodingPlanProviderSettings?
+    public var alibabaTokenPlan: ProviderSettingsSnapshot.AlibabaTokenPlanProviderSettings?
     public var factory: ProviderSettingsSnapshot.FactoryProviderSettings?
     public var minimax: ProviderSettingsSnapshot.MiniMaxProviderSettings?
+    public var manus: ProviderSettingsSnapshot.ManusProviderSettings?
     public var zai: ProviderSettingsSnapshot.ZaiProviderSettings?
     public var copilot: ProviderSettingsSnapshot.CopilotProviderSettings?
     public var kilo: ProviderSettingsSnapshot.KiloProviderSettings?
     public var kimi: ProviderSettingsSnapshot.KimiProviderSettings?
     public var augment: ProviderSettingsSnapshot.AugmentProviderSettings?
+    public var moonshot: ProviderSettingsSnapshot.MoonshotProviderSettings?
     public var amp: ProviderSettingsSnapshot.AmpProviderSettings?
+    public var t3chat: ProviderSettingsSnapshot.T3ChatProviderSettings?
+    public var devin: ProviderSettingsSnapshot.DevinProviderSettings?
+    public var commandcode: ProviderSettingsSnapshot.CommandCodeProviderSettings?
     public var ollama: ProviderSettingsSnapshot.OllamaProviderSettings?
     public var jetbrains: ProviderSettingsSnapshot.JetBrainsProviderSettings?
+    public var windsurf: ProviderSettingsSnapshot.WindsurfProviderSettings?
+    public var perplexity: ProviderSettingsSnapshot.PerplexityProviderSettings?
+    public var mimo: ProviderSettingsSnapshot.MiMoProviderSettings?
+    public var abacus: ProviderSettingsSnapshot.AbacusProviderSettings?
+    public var mistral: ProviderSettingsSnapshot.MistralProviderSettings?
+    public var stepfun: ProviderSettingsSnapshot.StepFunProviderSettings?
 
     public init(debugMenuEnabled: Bool = false, debugKeepCLISessionsAlive: Bool = false) {
         self.debugMenuEnabled = debugMenuEnabled
         self.debugKeepCLISessionsAlive = debugKeepCLISessionsAlive
     }
 
+    // swiftlint:disable:next cyclomatic_complexity
     public mutating func apply(_ contribution: ProviderSettingsSnapshotContribution) {
         switch contribution {
         case let .codex(value): self.codex = value
         case let .claude(value): self.claude = value
         case let .cursor(value): self.cursor = value
         case let .opencode(value): self.opencode = value
+        case let .opencodego(value): self.opencodego = value
+        case let .alibaba(value): self.alibaba = value
+        case let .alibabaTokenPlan(value): self.alibabaTokenPlan = value
         case let .factory(value): self.factory = value
         case let .minimax(value): self.minimax = value
+        case let .manus(value): self.manus = value
         case let .zai(value): self.zai = value
         case let .copilot(value): self.copilot = value
         case let .kilo(value): self.kilo = value
         case let .kimi(value): self.kimi = value
         case let .augment(value): self.augment = value
+        case let .moonshot(value): self.moonshot = value
         case let .amp(value): self.amp = value
+        case let .t3chat(value): self.t3chat = value
+        case let .devin(value): self.devin = value
+        case let .commandcode(value): self.commandcode = value
         case let .ollama(value): self.ollama = value
         case let .jetbrains(value): self.jetbrains = value
+        case let .windsurf(value): self.windsurf = value
+        case let .perplexity(value): self.perplexity = value
+        case let .mimo(value): self.mimo = value
+        case let .abacus(value): self.abacus = value
+        case let .mistral(value): self.mistral = value
+        case let .stepfun(value): self.stepfun = value
         }
     }
 
@@ -316,15 +636,29 @@ public struct ProviderSettingsSnapshotBuilder: Sendable {
             claude: self.claude,
             cursor: self.cursor,
             opencode: self.opencode,
+            opencodego: self.opencodego,
+            alibaba: self.alibaba,
+            alibabaTokenPlan: self.alibabaTokenPlan,
             factory: self.factory,
             minimax: self.minimax,
+            manus: self.manus,
             zai: self.zai,
             copilot: self.copilot,
             kilo: self.kilo,
             kimi: self.kimi,
             augment: self.augment,
+            moonshot: self.moonshot,
             amp: self.amp,
+            t3chat: self.t3chat,
+            devin: self.devin,
+            commandcode: self.commandcode,
             ollama: self.ollama,
-            jetbrains: self.jetbrains)
+            jetbrains: self.jetbrains,
+            windsurf: self.windsurf,
+            perplexity: self.perplexity,
+            mimo: self.mimo,
+            abacus: self.abacus,
+            mistral: self.mistral,
+            stepfun: self.stepfun)
     }
 }
diff --git a/Sources/CodexBarCore/Providers/ProviderTokenResolver.swift b/Sources/CodexBarCore/Providers/ProviderTokenResolver.swift
index ada9fac8d2..3bf7117fa7 100644
--- a/Sources/CodexBarCore/Providers/ProviderTokenResolver.swift
+++ b/Sources/CodexBarCore/Providers/ProviderTokenResolver.swift
@@ -16,6 +16,10 @@ public struct ProviderTokenResolution: Sendable {
 }
 
 public enum ProviderTokenResolver {
+    public static func ampToken(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        self.ampResolution(environment: environment)?.token
+    }
+
     public static func zaiToken(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
         self.zaiResolution(environment: environment)?.token
     }
@@ -26,6 +30,24 @@ public enum ProviderTokenResolver {
         self.syntheticResolution(environment: environment)?.token
     }
 
+    public static func openAIAPIToken(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.openAIAPIResolution(environment: environment)?.token
+    }
+
+    public static func azureOpenAIToken(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.azureOpenAIResolution(environment: environment)?.token
+    }
+
+    public static func claudeAdminAPIToken(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.claudeAdminAPIResolution(environment: environment)?.token
+    }
+
     public static func copilotToken(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
         self.copilotResolution(environment: environment)?.token
     }
@@ -34,6 +56,10 @@ public enum ProviderTokenResolver {
         self.minimaxTokenResolution(environment: environment)?.token
     }
 
+    public static func alibabaToken(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        self.alibabaTokenResolution(environment: environment)?.token
+    }
+
     public static func minimaxCookie(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
         self.minimaxCookieResolution(environment: environment)?.token
     }
@@ -42,10 +68,22 @@ public enum ProviderTokenResolver {
         self.kimiAuthResolution(environment: environment)?.token
     }
 
+    public static func kimiAPIToken(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        self.kimiAPIResolution(environment: environment)?.token
+    }
+
     public static func kimiK2Token(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
         self.kimiK2Resolution(environment: environment)?.token
     }
 
+    public static func moonshotToken(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        self.moonshotResolution(environment: environment)?.token
+    }
+
+    public static func ollamaToken(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        self.ollamaResolution(environment: environment)?.token
+    }
+
     public static func kiloToken(
         environment: [String: String] = ProcessInfo.processInfo.environment,
         authFileURL: URL? = nil) -> String?
@@ -61,6 +99,125 @@ public enum ProviderTokenResolver {
         self.openRouterResolution(environment: environment)?.token
     }
 
+    public static func elevenLabsToken(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.elevenLabsResolution(environment: environment)?.token
+    }
+
+    public static func groqToken(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        self.groqResolution(environment: environment)?.token
+    }
+
+    public static func llmProxyToken(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        self.llmProxyResolution(environment: environment)?.token
+    }
+
+    public static func liteLLMToken(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        self.liteLLMResolution(environment: environment)?.token
+    }
+
+    public static func perplexitySessionToken(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.perplexityResolution(environment: environment)?.token
+    }
+
+    public static func deepseekToken(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.deepseekResolution(environment: environment)?.token
+    }
+
+    public static func poeToken(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.poeResolution(environment: environment)?.token
+    }
+
+    public static func crofToken(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.crofResolution(environment: environment)?.token
+    }
+
+    public static func veniceToken(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.veniceResolution(environment: environment)?.token
+    }
+
+    public static func stepfunToken(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.stepfunResolution(environment: environment)?.token
+    }
+
+    public static func doubaoToken(environment: [String: String] = ProcessInfo.processInfo.environment) -> String? {
+        self.doubaoResolution(environment: environment)?.token
+    }
+
+    public static func bedrockAccessKeyID(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.bedrockResolution(environment: environment)?.token
+    }
+
+    public static func bedrockResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        self.resolveEnv(BedrockSettingsReader.accessKeyID(environment: environment))
+    }
+
+    public static func ampResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        self.resolveEnv(AmpSettingsReader.apiToken(environment: environment))
+    }
+
+    public static func deepseekResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        self.resolveEnv(DeepSeekSettingsReader.apiKey(environment: environment))
+    }
+
+    public static func poeResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        self.resolveEnv(PoeSettingsReader.apiKey(environment: environment))
+    }
+
+    public static func crofResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        self.resolveEnv(CrofSettingsReader.apiKey(environment: environment))
+    }
+
+    public static func veniceResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        self.resolveEnv(VeniceSettingsReader.apiKey(environment: environment))
+    }
+
+    public static func codebuffToken(
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        authFileURL: URL? = nil) -> String?
+    {
+        self.codebuffResolution(environment: environment, authFileURL: authFileURL)?.token
+    }
+
+    public static func stepfunResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        self.resolveEnv(StepFunSettingsReader.token(environment: environment))
+    }
+
+    public static func doubaoResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        self.resolveEnv(DoubaoSettingsReader.apiKey(environment: environment))
+    }
+
     public static func zaiResolution(
         environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
     {
@@ -73,6 +230,24 @@ public enum ProviderTokenResolver {
         self.resolveEnv(SyntheticSettingsReader.apiKey(environment: environment))
     }
 
+    public static func openAIAPIResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        self.resolveEnv(OpenAIAPISettingsReader.apiKey(environment: environment))
+    }
+
+    public static func azureOpenAIResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        self.resolveEnv(AzureOpenAISettingsReader.apiKey(environment: environment))
+    }
+
+    public static func claudeAdminAPIResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        self.resolveEnv(ClaudeAdminAPISettingsReader.apiKey(environment: environment))
+    }
+
     public static func copilotResolution(
         environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
     {
@@ -85,6 +260,12 @@ public enum ProviderTokenResolver {
         self.resolveEnv(MiniMaxAPISettingsReader.apiToken(environment: environment))
     }
 
+    public static func alibabaTokenResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        self.resolveEnv(AlibabaCodingPlanSettingsReader.apiToken(environment: environment))
+    }
+
     public static func minimaxCookieResolution(
         environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
     {
@@ -110,12 +291,30 @@ public enum ProviderTokenResolver {
         return nil
     }
 
+    public static func kimiAPIResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        self.resolveEnv(KimiSettingsReader.apiKey(environment: environment))
+    }
+
     public static func kimiK2Resolution(
         environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
     {
         self.resolveEnv(KimiK2SettingsReader.apiKey(environment: environment))
     }
 
+    public static func moonshotResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        self.resolveEnv(MoonshotSettingsReader.apiKey(environment: environment))
+    }
+
+    public static func ollamaResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        self.resolveEnv(OllamaAPISettingsReader.apiKey(environment: environment))
+    }
+
     public static func kiloResolution(
         environment: [String: String] = ProcessInfo.processInfo.environment,
         authFileURL: URL? = nil) -> ProviderTokenResolution?
@@ -141,6 +340,80 @@ public enum ProviderTokenResolver {
         self.resolveEnv(OpenRouterSettingsReader.apiToken(environment: environment))
     }
 
+    public static func elevenLabsResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        self.resolveEnv(ElevenLabsSettingsReader.apiKey(environment: environment))
+    }
+
+    public static func groqResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        self.resolveEnv(GroqSettingsReader.apiKey(environment: environment))
+    }
+
+    public static func llmProxyResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        self.resolveEnv(LLMProxySettingsReader.apiKey(environment: environment))
+    }
+
+    public static func liteLLMResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        self.resolveEnv(LiteLLMSettingsReader.apiKey(environment: environment))
+    }
+
+    public enum DeepgramCredentialKind: Sendable {
+        case apiKey
+        case projectID
+    }
+
+    public static func deepgramResolution(
+        type: DeepgramCredentialKind,
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        switch type {
+        case .apiKey:
+            self.resolveEnv(DeepgramSettingsReader.apiKey(environment: environment))?.token
+
+        case .projectID:
+            self.resolveEnv(DeepgramSettingsReader.projectID(environment: environment))?.token
+        }
+    }
+
+    public static func codebuffResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        authFileURL: URL? = nil) -> ProviderTokenResolution?
+    {
+        if let resolution = self.resolveEnv(CodebuffSettingsReader.apiKey(environment: environment)) {
+            return resolution
+        }
+        if let token = CodebuffSettingsReader.authToken(authFileURL: authFileURL) {
+            return ProviderTokenResolution(token: token, source: .authFile)
+        }
+        return nil
+    }
+
+    public static func perplexityResolution(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> ProviderTokenResolution?
+    {
+        if let resolution = self.resolveEnv(PerplexitySettingsReader.sessionToken(environment: environment)) {
+            return resolution
+        }
+        #if os(macOS)
+        do {
+            let session = try PerplexityCookieImporter.importSession()
+            if let token = session.sessionToken {
+                return ProviderTokenResolution(token: token, source: .environment)
+            }
+        } catch {
+            // No browser cookies found, continue to fallback
+        }
+        #endif
+        return nil
+    }
+
     private static func cleaned(_ raw: String?) -> String? {
         guard var value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
             return nil
@@ -149,8 +422,7 @@ public enum ProviderTokenResolver {
         if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
             (value.hasPrefix("'") && value.hasSuffix("'"))
         {
-            value.removeFirst()
-            value.removeLast()
+            value = String(value.dropFirst().dropLast())
         }
 
         value = value.trimmingCharacters(in: .whitespacesAndNewlines)
diff --git a/Sources/CodexBarCore/Providers/ProviderVersionDetector.swift b/Sources/CodexBarCore/Providers/ProviderVersionDetector.swift
index 15dd131daa..071b0606c6 100644
--- a/Sources/CodexBarCore/Providers/ProviderVersionDetector.swift
+++ b/Sources/CodexBarCore/Providers/ProviderVersionDetector.swift
@@ -1,3 +1,10 @@
+#if canImport(Darwin)
+import Darwin
+#elseif canImport(Glibc)
+import Glibc
+#elseif canImport(Musl)
+import Musl
+#endif
 import Foundation
 
 public enum ProviderVersionDetector {
@@ -10,7 +17,8 @@ public enum ProviderVersionDetector {
                 options: TTYCommandRunner.Options(
                     timeout: 5.0,
                     extraArgs: ["--allowed-tools", "", "--version"],
-                    initialDelay: 0.0)).text
+                    initialDelay: 0.0,
+                    useClaudeProbeWorkingDirectory: true)).text
             let trimmed = TextParsing.stripANSICodes(out).trimmingCharacters(in: .whitespacesAndNewlines)
             return trimmed.isEmpty ? nil : trimmed
         } catch {
@@ -45,41 +53,61 @@ public enum ProviderVersionDetector {
         return nil
     }
 
-    private static func run(path: String, args: [String]) -> String? {
+    static func run(
+        path: String,
+        args: [String],
+        timeout: TimeInterval = 2.0,
+        environment: [String: String]? = nil,
+        mergeStandardError: Bool = false) -> String?
+    {
         let proc = Process()
         proc.executableURL = URL(fileURLWithPath: path)
         proc.arguments = args
+        proc.environment = environment
         let out = Pipe()
         proc.standardOutput = out
-        proc.standardError = Pipe()
+        proc.standardError = mergeStandardError ? out : FileHandle.nullDevice
+        proc.standardInput = nil
+        let outputCapture = ProcessPipeCapture(pipe: out)
+        outputCapture.start()
+
+        let exitSemaphore = DispatchSemaphore(value: 0)
+        proc.terminationHandler = { _ in
+            exitSemaphore.signal()
+        }
 
         do {
             try proc.run()
         } catch {
+            outputCapture.stop()
             return nil
         }
 
-        let deadline = Date().addingTimeInterval(2.0)
-        while proc.isRunning, Date() < deadline {
-            usleep(50000)
-        }
-        if proc.isRunning {
-            proc.terminate()
-            let killDeadline = Date().addingTimeInterval(0.5)
-            while proc.isRunning, Date() < killDeadline {
-                usleep(20000)
-            }
-            if proc.isRunning {
-                kill(proc.processIdentifier, SIGKILL)
-            }
+        let didExit = exitSemaphore.wait(timeout: .now() + timeout) == .success
+        if !didExit, !Self.forceExit(proc, exitSemaphore: exitSemaphore) {
+            outputCapture.stop()
+            return nil
         }
 
-        let data = out.fileHandleForReading.readDataToEndOfFile()
+        let data = outputCapture.finishSynchronously(timeout: 0.25)
         guard proc.terminationStatus == 0,
-              let text = String(data: data, encoding: .utf8)?
+              let text = ProcessPipeCapture.decodeUTF8(data)
                   .split(whereSeparator: \.isNewline).first
         else { return nil }
         let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
         return trimmed.isEmpty ? nil : trimmed
     }
+
+    private static func forceExit(_ proc: Process, exitSemaphore: DispatchSemaphore) -> Bool {
+        guard proc.isRunning else { return true }
+
+        proc.terminate()
+        if exitSemaphore.wait(timeout: .now() + 0.5) == .success {
+            return true
+        }
+
+        guard proc.isRunning else { return true }
+        kill(proc.processIdentifier, SIGKILL)
+        return exitSemaphore.wait(timeout: .now() + 1.0) == .success
+    }
 }
diff --git a/Sources/CodexBarCore/Providers/Providers.swift b/Sources/CodexBarCore/Providers/Providers.swift
index f48eefe437..005a6d2e4d 100644
--- a/Sources/CodexBarCore/Providers/Providers.swift
+++ b/Sources/CodexBarCore/Providers/Providers.swift
@@ -4,15 +4,22 @@ import SweetCookieKit
 // swiftformat:disable sortDeclarations
 public enum UsageProvider: String, CaseIterable, Sendable, Codable {
     case codex
+    case openai
+    case azureopenai
     case claude
     case cursor
     case opencode
+    case opencodego
+    case alibaba
+    case alibabatokenplan
     case factory
     case gemini
     case antigravity
     case copilot
+    case devin
     case zai
     case minimax
+    case manus
     case kimi
     case kilo
     case kiro
@@ -20,26 +27,55 @@ public enum UsageProvider: String, CaseIterable, Sendable, Codable {
     case augment
     case jetbrains
     case kimik2
+    case moonshot
     case amp
+    case t3chat
     case ollama
     case synthetic
     case warp
     case openrouter
+    case elevenlabs
+    case windsurf
+    case zed
+    case perplexity
+    case mimo
+    case doubao
+    case abacus
+    case mistral
+    case deepseek
+    case codebuff
+    case crof
+    case venice
+    case commandcode
+    case stepfun
+    case bedrock
+    case grok
+    case groq
+    case llmproxy
+    case litellm
+    case deepgram
+    case poe
+    case chutes
 }
 
 // swiftformat:enable sortDeclarations
 
-public enum IconStyle: Sendable, CaseIterable {
+public enum IconStyle: String, Sendable, CaseIterable {
     case codex
+    case openai
     case claude
     case zai
     case minimax
+    case manus
     case gemini
     case antigravity
     case cursor
     case opencode
+    case opencodego
+    case alibaba
     case factory
     case copilot
+    case devin
     case kimi
     case kimik2
     case kilo
@@ -47,11 +83,35 @@ public enum IconStyle: Sendable, CaseIterable {
     case vertexai
     case augment
     case jetbrains
+    case moonshot
     case amp
+    case t3chat
     case ollama
     case synthetic
     case warp
     case openrouter
+    case elevenlabs
+    case windsurf
+    case zed
+    case perplexity
+    case mimo
+    case doubao
+    case abacus
+    case mistral
+    case deepseek
+    case codebuff
+    case crof
+    case venice
+    case commandcode
+    case stepfun
+    case bedrock
+    case grok
+    case groq
+    case llmproxy
+    case litellm
+    case deepgram
+    case poe
+    case chutes
     case combined
 }
 
@@ -72,6 +132,8 @@ public struct ProviderMetadata: Sendable {
     public let browserCookieOrder: BrowserCookieImportOrder?
     public let dashboardURL: String?
     public let subscriptionDashboardURL: String?
+    /// Provider-specific release notes or changelog URL for CLI/provider updates.
+    public let changelogURL: String?
     /// Statuspage.io base URL for incident polling (append /api/v2/status.json).
     public let statusPageURL: String?
     /// Browser-only status link (no API polling); used when statusPageURL is nil.
@@ -96,6 +158,7 @@ public struct ProviderMetadata: Sendable {
         browserCookieOrder: BrowserCookieImportOrder? = nil,
         dashboardURL: String?,
         subscriptionDashboardURL: String? = nil,
+        changelogURL: String? = nil,
         statusPageURL: String?,
         statusLinkURL: String? = nil,
         statusWorkspaceProductID: String? = nil)
@@ -116,6 +179,7 @@ public struct ProviderMetadata: Sendable {
         self.browserCookieOrder = browserCookieOrder
         self.dashboardURL = dashboardURL
         self.subscriptionDashboardURL = subscriptionDashboardURL
+        self.changelogURL = changelogURL
         self.statusPageURL = statusPageURL
         self.statusLinkURL = statusLinkURL
         self.statusWorkspaceProductID = statusWorkspaceProductID
@@ -136,4 +200,64 @@ public enum ProviderBrowserCookieDefaults {
         nil
         #endif
     }
+
+    /// Safari first for Cursor: active sessions often live only there, and Chromium profiles may carry stale tokens.
+    public static var cursorCookieImportOrder: BrowserCookieImportOrder? {
+        #if os(macOS)
+        [.safari] + Browser.defaultImportOrder.filter { $0 != .safari }
+        #else
+        nil
+        #endif
+    }
+
+    /// Preserve the legacy Codex prompt behavior: prefer Safari/Chrome/Firefox before
+    /// probing additional Chromium variants that may trigger Safe Storage prompts.
+    public static var codexCookieImportOrder: BrowserCookieImportOrder? {
+        #if os(macOS)
+        let preferredPrefix: [Browser] = [.safari, .chrome, .firefox]
+        return preferredPrefix + Browser.defaultImportOrder.filter { !preferredPrefix.contains($0) }
+        #else
+        nil
+        #endif
+    }
+
+    /// Grok is normally signed in through Chrome; keep this narrow so CLI/live probes do not touch
+    /// unrelated browser keychains.
+    public static var grokCookieImportOrder: BrowserCookieImportOrder? {
+        #if os(macOS)
+        [.chrome]
+        #else
+        nil
+        #endif
+    }
+
+    /// MiMo Auto: Safari first (no Keychain prompt), keep the existing Chrome-family
+    /// entries from main, and add Firefox/Edge per #1304. Other Chromium forks stay on
+    /// Manual import to avoid scanning the full SweetCookieKit default order.
+    public static var mimoCookieImportOrder: BrowserCookieImportOrder? {
+        #if os(macOS)
+        [.safari, .chrome, .chromeBeta, .chromeCanary, .firefox, .edge]
+        #else
+        nil
+        #endif
+    }
+
+    /// Devin sessions are normally in Chrome. Keep automatic import narrow so live probes do not
+    /// touch unrelated browser keychains; users can select another browser explicitly.
+    public static var devinCookieImportOrder: BrowserCookieImportOrder? {
+        #if os(macOS)
+        [.chrome]
+        #else
+        nil
+        #endif
+    }
+
+    /// Copilot budget imports should stay Chrome-only by default to avoid prompting unrelated browsers.
+    public static var copilotCookieImportOrder: BrowserCookieImportOrder? {
+        #if os(macOS)
+        [.chrome]
+        #else
+        nil
+        #endif
+    }
 }
diff --git a/Sources/CodexBarCore/Providers/StepFun/StepFunProviderDescriptor.swift b/Sources/CodexBarCore/Providers/StepFun/StepFunProviderDescriptor.swift
new file mode 100644
index 0000000000..1cdac836fa
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/StepFun/StepFunProviderDescriptor.swift
@@ -0,0 +1,315 @@
+import Foundation
+
+public enum StepFunProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .stepfun,
+            metadata: ProviderMetadata(
+                id: .stepfun,
+                displayName: "StepFun",
+                sessionLabel: "5h Window",
+                weeklyLabel: "Weekly Window",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "",
+                toggleTitle: "Show StepFun usage",
+                cliName: "stepfun",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                browserCookieOrder: nil,
+                dashboardURL: "https://platform.stepfun.com/plan-usage",
+                statusPageURL: nil,
+                statusLinkURL: nil),
+            branding: ProviderBranding(
+                iconStyle: .stepfun,
+                iconResourceName: "ProviderIcon-stepfun",
+                color: ProviderColor(red: 0.13, green: 0.59, blue: 0.95)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "StepFun per-day cost history is not available via API." }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .web],
+                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [StepFunWebFetchStrategy()] })),
+            cli: ProviderCLIConfig(
+                name: "stepfun",
+                aliases: ["step-fun", "sf"],
+                versionDetector: nil))
+    }
+}
+
+struct StepFunWebFetchStrategy: ProviderFetchStrategy {
+    let id: String = "stepfun.web"
+    let kind: ProviderFetchKind = .web
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        context.settings?.stepfun?.cookieSource != .off
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        do {
+            let resolved = try await Self.resolveToken(context: context, allowCached: true)
+            let usage = try await StepFunUsageFetcher.fetchUsage(token: resolved.token)
+            return self.makeResult(
+                usage: usage.toUsageSnapshot(),
+                sourceLabel: "web")
+        } catch let error where Self.isAuthenticationFailure(error) {
+            return try await self.recoverFromAuthenticationFailure(context: context, originalError: error)
+        }
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+
+    // MARK: - Token Resolution
+
+    private struct ResolvedToken {
+        let token: String
+        let source: TokenSource
+    }
+
+    private enum TokenSource {
+        case manual
+        case cached
+        case settingsLogin
+        case environmentToken
+        case environmentLogin
+    }
+
+    private static func resolveToken(
+        context: ProviderFetchContext,
+        allowCached: Bool) async throws -> ResolvedToken
+    {
+        let settings = context.settings?.stepfun
+
+        // 1. Manual mode: use the token directly from settings
+        if settings?.cookieSource == .manual {
+            let manualToken = settings?.manualToken ?? ""
+            guard !manualToken.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+                throw StepFunUsageError.missingToken
+            }
+            return ResolvedToken(
+                token: StepFunTokenNormalizer.normalize(manualToken),
+                source: .manual)
+        }
+
+        // 2. Cached token from previous login
+        if allowCached, let cached = CookieHeaderCache.load(provider: .stepfun) {
+            return ResolvedToken(
+                token: StepFunTokenNormalizer.normalize(cached.cookieHeader),
+                source: .cached)
+        }
+
+        // 3. Username + password from Settings UI → perform full login flow
+        //    (register device → sign in by password → get Oasis-Token)
+        if let settings, !settings.username.isEmpty, !settings.password.isEmpty {
+            let token = try await StepFunUsageFetcher.login(
+                username: settings.username,
+                password: settings.password)
+            CookieHeaderCache.store(provider: .stepfun, cookieHeader: token, sourceLabel: "login")
+            return ResolvedToken(token: token, source: .settingsLogin)
+        }
+
+        // 4. Direct token from env var
+        if let token = StepFunSettingsReader.token(environment: context.env) {
+            return ResolvedToken(token: token, source: .environmentToken)
+        }
+
+        // 5. Username + password from env vars → perform full login flow
+        if let username = StepFunSettingsReader.username(environment: context.env),
+           let password = StepFunSettingsReader.password(environment: context.env)
+        {
+            let token = try await StepFunUsageFetcher.login(username: username, password: password)
+            CookieHeaderCache.store(provider: .stepfun, cookieHeader: token, sourceLabel: "login")
+            return ResolvedToken(token: token, source: .environmentLogin)
+        }
+
+        throw StepFunUsageError.missingCredentials
+    }
+
+    private func recoverFromAuthenticationFailure(
+        context: ProviderFetchContext,
+        originalError: Error) async throws -> ProviderFetchResult
+    {
+        let resolved = try await Self.resolveToken(context: context, allowCached: true)
+        let refreshed: String
+        do {
+            refreshed = try await StepFunUsageFetcher.refreshToken(token: resolved.token)
+        } catch {
+            if let fallback = try await Self.resolvedTokenWithoutStaleCache(context: context, source: resolved.source) {
+                do {
+                    let usage = try await StepFunUsageFetcher.fetchUsage(token: fallback.token)
+                    await Self.persistRecoveredToken(fallback.token, source: fallback.source, context: context)
+                    return self.makeResult(
+                        usage: usage.toUsageSnapshot(),
+                        sourceLabel: "web")
+                } catch {
+                    if !Self.isAuthenticationFailure(error) {
+                        throw error
+                    }
+                }
+            }
+            if let loginToken = try await Self.loginTokenIfAvailable(context: context, source: resolved.source) {
+                let usage = try await StepFunUsageFetcher.fetchUsage(token: loginToken)
+                return self.makeResult(
+                    usage: usage.toUsageSnapshot(),
+                    sourceLabel: "web")
+            }
+            throw Self.actionableAuthenticationError(for: resolved.source, originalError: originalError)
+        }
+
+        await Self.persistRecoveredToken(refreshed, source: resolved.source, context: context)
+
+        do {
+            let usage = try await StepFunUsageFetcher.fetchUsage(token: refreshed)
+            return self.makeResult(
+                usage: usage.toUsageSnapshot(),
+                sourceLabel: "web")
+        } catch let retryError where Self.isAuthenticationFailure(retryError) {
+            if let loginToken = try await Self.loginTokenIfAvailable(context: context, source: resolved.source) {
+                let usage = try await StepFunUsageFetcher.fetchUsage(token: loginToken)
+                return self.makeResult(
+                    usage: usage.toUsageSnapshot(),
+                    sourceLabel: "web")
+            }
+            throw Self.actionableAuthenticationError(for: resolved.source, originalError: originalError)
+        }
+    }
+
+    private static func resolvedTokenWithoutStaleCache(
+        context: ProviderFetchContext,
+        source: TokenSource) async throws -> ResolvedToken?
+    {
+        guard case .cached = source else { return nil }
+        CookieHeaderCache.clear(provider: .stepfun)
+        do {
+            return try await self.resolveToken(context: context, allowCached: false)
+        } catch StepFunUsageError.missingCredentials {
+            return nil
+        } catch StepFunUsageError.missingToken {
+            return nil
+        }
+    }
+
+    private static func loginTokenIfAvailable(
+        context: ProviderFetchContext,
+        source: TokenSource) async throws -> String?
+    {
+        if case .manual = source {
+            return nil
+        }
+
+        let settings = context.settings?.stepfun
+        if settings?.cookieSource != .manual,
+           let settings,
+           !settings.username.isEmpty,
+           !settings.password.isEmpty
+        {
+            CookieHeaderCache.clear(provider: .stepfun)
+            let token = try await StepFunUsageFetcher.login(
+                username: settings.username,
+                password: settings.password)
+            CookieHeaderCache.store(provider: .stepfun, cookieHeader: token, sourceLabel: "login")
+            return token
+        }
+
+        if let username = StepFunSettingsReader.username(environment: context.env),
+           let password = StepFunSettingsReader.password(environment: context.env)
+        {
+            CookieHeaderCache.clear(provider: .stepfun)
+            let token = try await StepFunUsageFetcher.login(username: username, password: password)
+            CookieHeaderCache.store(provider: .stepfun, cookieHeader: token, sourceLabel: "login")
+            return token
+        }
+
+        return nil
+    }
+
+    private static func persistRecoveredToken(
+        _ token: String,
+        source: TokenSource,
+        context: ProviderFetchContext) async
+    {
+        switch source {
+        case .cached, .settingsLogin, .environmentLogin:
+            CookieHeaderCache.store(provider: .stepfun, cookieHeader: token, sourceLabel: "refresh")
+        case .manual:
+            guard let accountID = context.selectedTokenAccountID,
+                  let updater = context.tokenAccountTokenUpdater
+            else {
+                await context.providerManualTokenUpdater?(.stepfun, token)
+                return
+            }
+            await updater(.stepfun, accountID, token)
+        case .environmentToken:
+            guard let accountID = context.selectedTokenAccountID,
+                  let updater = context.tokenAccountTokenUpdater
+            else { return }
+            await updater(.stepfun, accountID, token)
+        }
+    }
+
+    private static func isAuthenticationFailure(_ error: Error) -> Bool {
+        guard case let StepFunUsageError.apiError(message) = error else {
+            return false
+        }
+        let lower = message.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+        return lower.contains("401") ||
+            lower.contains("403") ||
+            lower.contains("unauthorized") ||
+            lower.contains("unauthenticated") ||
+            lower.contains("invalid credentials") ||
+            lower.contains("invalid token") ||
+            lower.contains("token expired") ||
+            lower.contains("expired token")
+    }
+
+    private static func actionableAuthenticationError(
+        for source: TokenSource,
+        originalError: Error) -> StepFunUsageError
+    {
+        let suffix = switch source {
+        case .manual:
+            "Refresh the Oasis-Token, or switch StepFun to auto auth with username/password."
+        case .environmentToken:
+            "Refresh STEPFUN_TOKEN, or configure STEPFUN_USERNAME and STEPFUN_PASSWORD."
+        case .cached, .settingsLogin, .environmentLogin:
+            "Refresh the StepFun credentials and try again."
+        }
+        return .apiError("\(Self.authenticationFailureMessage(originalError)). \(suffix)")
+    }
+
+    private static func authenticationFailureMessage(_ error: Error) -> String {
+        if case let StepFunUsageError.apiError(message) = error {
+            return message
+        }
+        return error.localizedDescription
+    }
+}
+
+// MARK: - Token Normalizer
+
+public enum StepFunTokenNormalizer {
+    /// Normalize a StepFun token value — extracts the Oasis-Token from a cookie header
+    /// or returns the raw token value if it's not a cookie header.
+    public static func normalize(_ raw: String) -> String {
+        let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else { return "" }
+
+        // If it looks like a cookie header, extract Oasis-Token
+        if trimmed.contains("Oasis-Token=") {
+            let parts = trimmed.components(separatedBy: "Oasis-Token=")
+            if parts.count > 1 {
+                let afterToken = parts[1]
+                return afterToken.components(separatedBy: ";").first?
+                    .trimmingCharacters(in: .whitespaces) ?? afterToken
+            }
+        }
+
+        return trimmed
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/StepFun/StepFunSettingsReader.swift b/Sources/CodexBarCore/Providers/StepFun/StepFunSettingsReader.swift
new file mode 100644
index 0000000000..b8a497a6f7
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/StepFun/StepFunSettingsReader.swift
@@ -0,0 +1,38 @@
+import Foundation
+
+public struct StepFunSettingsReader: Sendable {
+    public static let usernameEnvironmentKey = "STEPFUN_USERNAME"
+    public static let passwordEnvironmentKey = "STEPFUN_PASSWORD"
+    public static let tokenEnvironmentKey = "STEPFUN_TOKEN"
+
+    public static func username(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.cleaned(environment[self.usernameEnvironmentKey])
+    }
+
+    public static func password(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.cleaned(environment[self.passwordEnvironmentKey])
+    }
+
+    public static func token(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        self.cleaned(environment[self.tokenEnvironmentKey])
+    }
+
+    private static func cleaned(_ raw: String?) -> String? {
+        guard var value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
+            return nil
+        }
+        if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
+            (value.hasPrefix("'") && value.hasSuffix("'"))
+        {
+            value = String(value.dropFirst().dropLast())
+        }
+        value = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        return value.isEmpty ? nil : value
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/StepFun/StepFunUsageFetcher.swift b/Sources/CodexBarCore/Providers/StepFun/StepFunUsageFetcher.swift
new file mode 100644
index 0000000000..9c8bca186b
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/StepFun/StepFunUsageFetcher.swift
@@ -0,0 +1,554 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+// MARK: - API response types
+
+/// A flexible number type that can decode from both JSON integers and floats.
+/// The StepFun API returns `five_hour_usage_left_rate: 1` (int) or `0.99781543` (float).
+public struct StepFunFlexibleNumber: Decodable, Sendable {
+    public let value: Double
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        if let intVal = try? container.decode(Int.self) {
+            self.value = Double(intVal)
+        } else if let doubleVal = try? container.decode(Double.self) {
+            self.value = doubleVal
+        } else {
+            self.value = 0
+        }
+    }
+
+    public init(_ value: Double) {
+        self.value = value
+    }
+}
+
+/// A flexible timestamp type that can decode from both JSON strings and integers.
+/// The StepFun API returns timestamps as strings like `"1777528800"`.
+public struct StepFunFlexibleTimestamp: Decodable, Sendable {
+    public let value: Int64
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        if let strVal = try? container.decode(String.self), let parsed = Int64(strVal) {
+            self.value = parsed
+        } else if let intVal = try? container.decode(Int64.self) {
+            self.value = intVal
+        } else {
+            self.value = 0
+        }
+    }
+
+    public init(_ value: Int64) {
+        self.value = value
+    }
+}
+
+public struct StepFunRateLimitResponse: Decodable, Sendable {
+    public let status: Int?
+    public let code: Int?
+    public let message: String?
+    public let desc: String?
+    public let fiveHourUsageLeftRate: StepFunFlexibleNumber?
+    public let weeklyUsageLeftRate: StepFunFlexibleNumber?
+    public let fiveHourUsageResetTime: StepFunFlexibleTimestamp?
+    public let weeklyUsageResetTime: StepFunFlexibleTimestamp?
+
+    enum CodingKeys: String, CodingKey {
+        case status
+        case code
+        case message
+        case desc
+        case fiveHourUsageLeftRate = "five_hour_usage_left_rate"
+        case weeklyUsageLeftRate = "weekly_usage_left_rate"
+        case fiveHourUsageResetTime = "five_hour_usage_reset_time"
+        case weeklyUsageResetTime = "weekly_usage_reset_time"
+    }
+
+    public var isSuccess: Bool {
+        self.status == 1
+    }
+}
+
+// MARK: - Plan status response types
+
+struct StepFunPlanStatusResponse: Decodable {
+    let status: Int?
+    let subscription: StepFunSubscription?
+
+    var planName: String? {
+        self.subscription?.name?.trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+}
+
+struct StepFunSubscription: Decodable {
+    let name: String?
+    let planType: Int?
+    let planStatus: Int?
+
+    enum CodingKeys: String, CodingKey {
+        case name
+        case planType = "plan_type"
+        case planStatus = "status"
+    }
+}
+
+// MARK: - Auth response types
+
+struct StepFunRegisterDeviceResponse: Decodable {
+    let accessToken: StepFunTokenPair?
+    let refreshToken: StepFunTokenPair?
+}
+
+struct StepFunLoginResponse: Decodable {
+    let accessToken: StepFunTokenPair?
+    let refreshToken: StepFunTokenPair?
+}
+
+struct StepFunRefreshTokenResponse: Decodable {
+    let accessToken: StepFunTokenPair?
+    let refreshToken: StepFunTokenPair?
+}
+
+struct StepFunTokenPair: Decodable {
+    let raw: String
+}
+
+// MARK: - Domain snapshot
+
+public struct StepFunUsageSnapshot: Sendable {
+    public let fiveHourUsageLeftRate: Double
+    public let weeklyUsageLeftRate: Double
+    public let fiveHourUsageResetTime: Date
+    public let weeklyUsageResetTime: Date
+    public let planName: String?
+    public let updatedAt: Date
+
+    public init(
+        fiveHourUsageLeftRate: Double,
+        weeklyUsageLeftRate: Double,
+        fiveHourUsageResetTime: Date,
+        weeklyUsageResetTime: Date,
+        planName: String? = nil,
+        updatedAt: Date)
+    {
+        self.fiveHourUsageLeftRate = fiveHourUsageLeftRate
+        self.weeklyUsageLeftRate = weeklyUsageLeftRate
+        self.fiveHourUsageResetTime = fiveHourUsageResetTime
+        self.weeklyUsageResetTime = weeklyUsageResetTime
+        self.planName = planName
+        self.updatedAt = updatedAt
+    }
+
+    public func toUsageSnapshot() -> UsageSnapshot {
+        // Five-hour window: primary
+        let fiveHourUsedPercent = max(0, min(100, (1.0 - self.fiveHourUsageLeftRate) * 100))
+        let fiveHourResetDescription = UsageFormatter.resetDescription(from: self.fiveHourUsageResetTime)
+        let fiveHourWindow = RateWindow(
+            usedPercent: fiveHourUsedPercent,
+            windowMinutes: 300,
+            resetsAt: self.fiveHourUsageResetTime,
+            resetDescription: fiveHourResetDescription)
+
+        // Weekly window: secondary
+        let weeklyUsedPercent = max(0, min(100, (1.0 - self.weeklyUsageLeftRate) * 100))
+        let weeklyResetDescription = UsageFormatter.resetDescription(from: self.weeklyUsageResetTime)
+        let weeklyWindow = RateWindow(
+            usedPercent: weeklyUsedPercent,
+            windowMinutes: 10080,
+            resetsAt: self.weeklyUsageResetTime,
+            resetDescription: weeklyResetDescription)
+
+        let trimmedPlan = self.planName?.trimmingCharacters(in: .whitespacesAndNewlines)
+        let loginMethod = (trimmedPlan?.isEmpty ?? true) ? "password" : trimmedPlan
+
+        let identity = ProviderIdentitySnapshot(
+            providerID: .stepfun,
+            accountEmail: nil,
+            accountOrganization: nil,
+            loginMethod: loginMethod)
+
+        return UsageSnapshot(
+            primary: fiveHourWindow,
+            secondary: weeklyWindow,
+            tertiary: nil,
+            updatedAt: self.updatedAt,
+            identity: identity)
+    }
+}
+
+// MARK: - Errors
+
+public enum StepFunUsageError: LocalizedError, Sendable {
+    case missingCredentials
+    case missingToken
+    case networkError(String)
+    case apiError(String)
+    case parseFailed(String)
+    case loginFailed(String)
+    case tokenRefreshFailed(String)
+    case deviceRegistrationFailed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingCredentials:
+            "Missing StepFun username or password. Set STEPFUN_USERNAME and STEPFUN_PASSWORD environment variables."
+        case .missingToken:
+            "Missing StepFun authentication token."
+        case let .networkError(message):
+            "StepFun network error: \(message)"
+        case let .apiError(message):
+            "StepFun API error: \(message)"
+        case let .parseFailed(message):
+            "Failed to parse StepFun response: \(message)"
+        case let .loginFailed(message):
+            "StepFun login failed: \(message)"
+        case let .tokenRefreshFailed(message):
+            "StepFun token refresh failed: \(message)"
+        case let .deviceRegistrationFailed(message):
+            "StepFun device registration failed: \(message)"
+        }
+    }
+}
+
+// MARK: - Fetcher
+
+public struct StepFunUsageFetcher: Sendable {
+    private static let log = CodexBarLog.logger(LogCategories.stepfunUsage)
+    private static let platformURL = URL(string: "https://platform.stepfun.com")!
+    private static let apiURL =
+        URL(string: "https://platform.stepfun.com/api/step.openapi.devcenter.Dashboard/QueryStepPlanRateLimit")!
+    private static let planStatusURL =
+        URL(string: "https://platform.stepfun.com/api/step.openapi.devcenter.Dashboard/GetStepPlanStatus")!
+    private static let registerDeviceURL =
+        URL(string: "https://platform.stepfun.com/passport/proto.api.passport.v1.PassportService/RegisterDevice")!
+    private static let loginURL =
+        URL(string: "https://platform.stepfun.com/passport/proto.api.passport.v1.PassportService/SignInByPassword")!
+    private static let refreshTokenURL =
+        URL(string: "https://platform.stepfun.com/passport/proto.api.passport.v1.PassportService/RefreshToken")!
+    private static let timeoutSeconds: TimeInterval = 15
+
+    private static let webID = "c8a1002d2c457e758785a9979832217c7c0b884c"
+    private static let appID = "10300"
+
+    private static let baseHeaders: [String: String] = [
+        "content-type": "application/json",
+        "oasis-appid": appID,
+        "oasis-platform": "web",
+        "oasis-webid": webID,
+        "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) " +
+            "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
+    ]
+
+    // MARK: - Public API
+
+    /// Perform the full login flow (username + password → Oasis-Token) and return the token.
+    /// Does NOT fetch usage — the caller should cache the token and then call `fetchUsage(token:)`.
+    public static func login(username: String, password: String) async throws -> String {
+        try await self.fullLogin(username: username, password: password)
+    }
+
+    /// Refresh an existing Oasis-Token and return a fresh access + refresh token pair.
+    public static func refreshToken(token: String) async throws -> String {
+        try await self.refreshOasisToken(token: token)
+    }
+
+    /// Fetch usage data using an existing Oasis-Token (from env var or cached).
+    public static func fetchUsage(token: String) async throws -> StepFunUsageSnapshot {
+        guard !token.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+            throw StepFunUsageError.missingToken
+        }
+        return try await self.queryUsage(token: token)
+    }
+
+    /// Full login flow: username + password → token, then fetch usage.
+    public static func fetchUsage(username: String, password: String) async throws -> StepFunUsageSnapshot {
+        let token = try await self.fullLogin(username: username, password: password)
+        return try await self.queryUsage(token: token)
+    }
+
+    // MARK: - Login
+
+    private static func fullLogin(username: String, password: String) async throws -> String {
+        // Step 1: Get INGRESSCOOKIE by visiting the platform homepage
+        let (ingressCookie, _) = try await self.getIngressCookie()
+
+        // Step 2: RegisterDevice → get anonymous token
+        let anonToken = try await self.registerDevice(ingressCookie: ingressCookie)
+
+        // Step 3: SignInByPassword → get authenticated token
+        return try await self.signInByPassword(
+            username: username,
+            password: password,
+            ingressCookie: ingressCookie,
+            anonToken: anonToken)
+    }
+
+    private static func getIngressCookie() async throws -> (String, HTTPURLResponse) {
+        var request = URLRequest(url: self.platformURL)
+        request.httpMethod = "GET"
+        for (key, value) in self.baseHeaders {
+            request.setValue(value, forHTTPHeaderField: key)
+        }
+        request.timeoutInterval = self.timeoutSeconds
+
+        let response = try await ProviderHTTPClient.shared.response(for: request)
+        let httpResponse = response.response
+
+        // Extract INGRESSCOOKIE from Set-Cookie headers
+        let setCookieHeaders = httpResponse.allHeaderFields.filter { ($0.key as? String)?.lowercased() == "set-cookie" }
+        var ingressCookie = ""
+        for (_, value) in setCookieHeaders {
+            let cookieString = "\(value)"
+            if cookieString.contains("INGRESSCOOKIE=") {
+                let parts = cookieString.components(separatedBy: "INGRESSCOOKIE=")
+                if parts.count > 1 {
+                    let valuePart = parts[1].components(separatedBy: ";").first ?? ""
+                    ingressCookie = valuePart.trimmingCharacters(in: .whitespaces)
+                }
+            }
+        }
+
+        // Also check cookies from the URLSession cookie store
+        if ingressCookie.isEmpty {
+            let cookies = HTTPCookieStorage.shared.cookies(for: self.platformURL) ?? []
+            for cookie in cookies where cookie.name == "INGRESSCOOKIE" {
+                ingressCookie = cookie.value
+                break
+            }
+        }
+
+        guard !ingressCookie.isEmpty else {
+            throw StepFunUsageError.loginFailed("Could not obtain INGRESSCOOKIE")
+        }
+
+        return (ingressCookie, httpResponse)
+    }
+
+    private static func registerDevice(ingressCookie: String) async throws -> String {
+        var request = URLRequest(url: self.registerDeviceURL)
+        request.httpMethod = "POST"
+        request.httpBody = Data("{}".utf8)
+        for (key, value) in self.baseHeaders {
+            request.setValue(value, forHTTPHeaderField: key)
+        }
+        request.setValue("INGRESSCOOKIE=\(ingressCookie)", forHTTPHeaderField: "Cookie")
+        request.timeoutInterval = self.timeoutSeconds
+
+        let response = try await ProviderHTTPClient.shared.response(for: request)
+        let data = response.data
+        guard response.statusCode == 200 else {
+            let body = String(data: data, encoding: .utf8) ?? ""
+            Self.log.error("StepFun RegisterDevice returned \(response.statusCode): \(body)")
+            throw StepFunUsageError.deviceRegistrationFailed("HTTP \(response.statusCode)")
+        }
+
+        let decoded: StepFunRegisterDeviceResponse
+        do {
+            decoded = try JSONDecoder().decode(StepFunRegisterDeviceResponse.self, from: data)
+        } catch {
+            throw StepFunUsageError.parseFailed("RegisterDevice response: \(error.localizedDescription)")
+        }
+
+        guard let accessToken = decoded.accessToken?.raw, !accessToken.isEmpty else {
+            throw StepFunUsageError.deviceRegistrationFailed("No access token in RegisterDevice response")
+        }
+
+        return self.combinedToken(accessToken: accessToken, refreshToken: decoded.refreshToken?.raw)
+    }
+
+    private static func signInByPassword(
+        username: String,
+        password: String,
+        ingressCookie: String,
+        anonToken: String) async throws -> String
+    {
+        var request = URLRequest(url: self.loginURL)
+        request.httpMethod = "POST"
+        let body: [String: String] = ["username": username, "password": password]
+        request.httpBody = try? JSONSerialization.data(withJSONObject: body)
+        for (key, value) in self.baseHeaders {
+            request.setValue(value, forHTTPHeaderField: key)
+        }
+        request.setValue(
+            "Oasis-Token=\(anonToken); Oasis-Webid=\(self.webID); INGRESSCOOKIE=\(ingressCookie)",
+            forHTTPHeaderField: "Cookie")
+        request.timeoutInterval = self.timeoutSeconds
+
+        let response = try await ProviderHTTPClient.shared.response(for: request)
+        let data = response.data
+        guard response.statusCode == 200 else {
+            let body = String(data: data, encoding: .utf8) ?? ""
+            Self.log.error("StepFun SignInByPassword returned \(response.statusCode): \(body)")
+            throw StepFunUsageError.loginFailed("HTTP \(response.statusCode)")
+        }
+
+        let decoded: StepFunLoginResponse
+        do {
+            decoded = try JSONDecoder().decode(StepFunLoginResponse.self, from: data)
+        } catch {
+            throw StepFunUsageError.parseFailed("SignInByPassword response: \(error.localizedDescription)")
+        }
+
+        guard let accessToken = decoded.accessToken?.raw, !accessToken.isEmpty else {
+            throw StepFunUsageError.loginFailed("No access token in login response")
+        }
+
+        return self.combinedToken(accessToken: accessToken, refreshToken: decoded.refreshToken?.raw)
+    }
+
+    private static func refreshOasisToken(token: String) async throws -> String {
+        let normalized = StepFunTokenNormalizer.normalize(token)
+        guard !normalized.isEmpty else {
+            throw StepFunUsageError.missingToken
+        }
+
+        var request = URLRequest(url: self.refreshTokenURL)
+        request.httpMethod = "POST"
+        request.httpBody = Data("{}".utf8)
+        for (key, value) in self.baseHeaders {
+            request.setValue(value, forHTTPHeaderField: key)
+        }
+        request.setValue(normalized, forHTTPHeaderField: "Oasis-Token")
+        request.setValue(
+            "Oasis-Token=\(normalized); Oasis-Webid=\(self.webID)",
+            forHTTPHeaderField: "Cookie")
+        request.timeoutInterval = self.timeoutSeconds
+
+        let response = try await ProviderHTTPClient.shared.response(for: request)
+        let data = response.data
+        guard response.statusCode == 200 else {
+            let body = String(data: data, encoding: .utf8) ?? ""
+            Self.log.error("StepFun RefreshToken returned \(response.statusCode): \(body)")
+            throw StepFunUsageError.tokenRefreshFailed("HTTP \(response.statusCode)")
+        }
+
+        let decoded: StepFunRefreshTokenResponse
+        do {
+            decoded = try JSONDecoder().decode(StepFunRefreshTokenResponse.self, from: data)
+        } catch {
+            throw StepFunUsageError.parseFailed("RefreshToken response: \(error.localizedDescription)")
+        }
+
+        guard let accessToken = decoded.accessToken?.raw, !accessToken.isEmpty else {
+            throw StepFunUsageError.tokenRefreshFailed("No access token in refresh response")
+        }
+
+        return self.combinedToken(accessToken: accessToken, refreshToken: decoded.refreshToken?.raw)
+    }
+
+    private static func combinedToken(accessToken: String, refreshToken: String?) -> String {
+        guard let refreshToken, !refreshToken.isEmpty else {
+            return accessToken
+        }
+        return "\(accessToken)...\(refreshToken)"
+    }
+
+    // MARK: - Query usage
+
+    private static func queryUsage(token: String) async throws -> StepFunUsageSnapshot {
+        var request = URLRequest(url: self.apiURL)
+        request.httpMethod = "POST"
+        request.httpBody = Data("{}".utf8)
+        for (key, value) in self.baseHeaders {
+            request.setValue(value, forHTTPHeaderField: key)
+        }
+        request.setValue("Oasis-Token=\(token); Oasis-Webid=\(self.webID)", forHTTPHeaderField: "Cookie")
+        request.timeoutInterval = self.timeoutSeconds
+
+        let response = try await ProviderHTTPClient.shared.response(for: request)
+        let data = response.data
+        guard response.statusCode == 200 else {
+            let body = String(data: data, encoding: .utf8) ?? ""
+            Self.log.error("StepFun API returned \(response.statusCode): \(body)")
+            throw StepFunUsageError.apiError("HTTP \(response.statusCode)")
+        }
+
+        if let jsonString = String(data: data, encoding: .utf8) {
+            Self.log.debug("StepFun API response: \(jsonString)")
+        }
+
+        var snapshot = try self.parseSnapshot(data: data)
+
+        // Fetch plan name in parallel is not needed — just do it sequentially.
+        // If plan status fails, we still return usage data without plan name.
+        if let planName = try? await self.queryPlanStatus(token: token) {
+            snapshot = StepFunUsageSnapshot(
+                fiveHourUsageLeftRate: snapshot.fiveHourUsageLeftRate,
+                weeklyUsageLeftRate: snapshot.weeklyUsageLeftRate,
+                fiveHourUsageResetTime: snapshot.fiveHourUsageResetTime,
+                weeklyUsageResetTime: snapshot.weeklyUsageResetTime,
+                planName: planName,
+                updatedAt: snapshot.updatedAt)
+        }
+
+        return snapshot
+    }
+
+    // MARK: - Plan Status
+
+    private static func queryPlanStatus(token: String) async throws -> String? {
+        var request = URLRequest(url: self.planStatusURL)
+        request.httpMethod = "POST"
+        request.httpBody = Data("{}".utf8)
+        for (key, value) in self.baseHeaders {
+            request.setValue(value, forHTTPHeaderField: key)
+        }
+        request.setValue("Oasis-Token=\(token); Oasis-Webid=\(self.webID)", forHTTPHeaderField: "Cookie")
+        request.timeoutInterval = self.timeoutSeconds
+
+        let response = try await ProviderHTTPClient.shared.response(for: request)
+        guard response.statusCode == 200 else {
+            Self.log.debug("StepFun plan status request failed, skipping plan name")
+            return nil
+        }
+
+        let decoded: StepFunPlanStatusResponse
+        do {
+            decoded = try JSONDecoder().decode(StepFunPlanStatusResponse.self, from: response.data)
+        } catch {
+            Self.log.debug("StepFun plan status parse failed: \(error.localizedDescription)")
+            return nil
+        }
+
+        return decoded.planName
+    }
+
+    public static func _parseSnapshotForTesting(_ data: Data) throws -> StepFunUsageSnapshot {
+        try self.parseSnapshot(data: data)
+    }
+
+    private static func parseSnapshot(data: Data) throws -> StepFunUsageSnapshot {
+        let decoded: StepFunRateLimitResponse
+        do {
+            decoded = try JSONDecoder().decode(StepFunRateLimitResponse.self, from: data)
+        } catch {
+            throw StepFunUsageError.parseFailed(error.localizedDescription)
+        }
+
+        guard decoded.isSuccess else {
+            let msg = [decoded.message, decoded.desc]
+                .compactMap { $0?.trimmingCharacters(in: .whitespacesAndNewlines) }
+                .first { !$0.isEmpty } ?? decoded.code.map(String.init) ?? "unknown"
+            throw StepFunUsageError.apiError(msg)
+        }
+
+        guard let fiveHourRate = decoded.fiveHourUsageLeftRate,
+              let weeklyRate = decoded.weeklyUsageLeftRate,
+              let fiveHourReset = decoded.fiveHourUsageResetTime,
+              let weeklyReset = decoded.weeklyUsageResetTime
+        else {
+            throw StepFunUsageError.parseFailed("Missing usage rate or reset time fields")
+        }
+
+        return StepFunUsageSnapshot(
+            fiveHourUsageLeftRate: fiveHourRate.value,
+            weeklyUsageLeftRate: weeklyRate.value,
+            fiveHourUsageResetTime: Date(timeIntervalSince1970: TimeInterval(fiveHourReset.value)),
+            weeklyUsageResetTime: Date(timeIntervalSince1970: TimeInterval(weeklyReset.value)),
+            updatedAt: Date())
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Synthetic/SyntheticProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Synthetic/SyntheticProviderDescriptor.swift
index 550ab9190a..84ad7806a2 100644
--- a/Sources/CodexBarCore/Providers/Synthetic/SyntheticProviderDescriptor.swift
+++ b/Sources/CodexBarCore/Providers/Synthetic/SyntheticProviderDescriptor.swift
@@ -1,21 +1,20 @@
-import CodexBarMacroSupport
 import Foundation
 
-@ProviderDescriptorRegistration
-@ProviderDescriptorDefinition
 public enum SyntheticProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
     static func makeDescriptor() -> ProviderDescriptor {
         ProviderDescriptor(
             id: .synthetic,
             metadata: ProviderMetadata(
                 id: .synthetic,
                 displayName: "Synthetic",
-                sessionLabel: "Quota",
-                weeklyLabel: "Usage",
-                opusLabel: nil,
-                supportsOpus: false,
+                sessionLabel: "Five-hour quota",
+                weeklyLabel: "Weekly tokens",
+                opusLabel: "Search hourly",
+                supportsOpus: true,
                 supportsCredits: false,
-                creditsHint: "",
+                creditsHint: "Weekly token quota regenerates continuously.",
                 toggleTitle: "Show Synthetic usage",
                 cliName: "synthetic",
                 defaultEnabled: false,
@@ -30,39 +29,16 @@ public enum SyntheticProviderDescriptor {
             tokenCost: ProviderTokenCostConfig(
                 supportsTokenCost: false,
                 noDataMessage: { "Synthetic cost summary is not supported." }),
-            fetchPlan: ProviderFetchPlan(
-                sourceModes: [.auto, .api],
-                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [SyntheticAPIFetchStrategy()] })),
+            fetchPlan: .apiToken(
+                strategyID: "synthetic.api",
+                resolveToken: { ProviderTokenResolver.syntheticToken(environment: $0) },
+                missingCredentialsError: { SyntheticSettingsError.missingToken },
+                loadUsage: { apiKey, _ in
+                    try await SyntheticUsageFetcher.fetchUsage(apiKey: apiKey).toUsageSnapshot()
+                }),
             cli: ProviderCLIConfig(
                 name: "synthetic",
                 aliases: ["synthetic.new"],
                 versionDetector: nil))
     }
 }
-
-struct SyntheticAPIFetchStrategy: ProviderFetchStrategy {
-    let id: String = "synthetic.api"
-    let kind: ProviderFetchKind = .apiToken
-
-    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
-        Self.resolveToken(environment: context.env) != nil
-    }
-
-    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
-        guard let apiKey = Self.resolveToken(environment: context.env) else {
-            throw SyntheticSettingsError.missingToken
-        }
-        let usage = try await SyntheticUsageFetcher.fetchUsage(apiKey: apiKey)
-        return self.makeResult(
-            usage: usage.toUsageSnapshot(),
-            sourceLabel: "api")
-    }
-
-    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
-        false
-    }
-
-    private static func resolveToken(environment: [String: String]) -> String? {
-        ProviderTokenResolver.syntheticToken(environment: environment)
-    }
-}
diff --git a/Sources/CodexBarCore/Providers/Synthetic/SyntheticSettingsReader.swift b/Sources/CodexBarCore/Providers/Synthetic/SyntheticSettingsReader.swift
index a6134f8833..14e07f4303 100644
--- a/Sources/CodexBarCore/Providers/Synthetic/SyntheticSettingsReader.swift
+++ b/Sources/CodexBarCore/Providers/Synthetic/SyntheticSettingsReader.swift
@@ -18,8 +18,7 @@ public struct SyntheticSettingsReader: Sendable {
         if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
             (value.hasPrefix("'") && value.hasSuffix("'"))
         {
-            value.removeFirst()
-            value.removeLast()
+            value = String(value.dropFirst().dropLast())
         }
 
         value = value.trimmingCharacters(in: .whitespacesAndNewlines)
diff --git a/Sources/CodexBarCore/Providers/Synthetic/SyntheticUsageStats.swift b/Sources/CodexBarCore/Providers/Synthetic/SyntheticUsageStats.swift
index 198c42c252..a1ff84f954 100644
--- a/Sources/CodexBarCore/Providers/Synthetic/SyntheticUsageStats.swift
+++ b/Sources/CodexBarCore/Providers/Synthetic/SyntheticUsageStats.swift
@@ -9,29 +9,45 @@ public struct SyntheticQuotaEntry: Sendable {
     public let windowMinutes: Int?
     public let resetsAt: Date?
     public let resetDescription: String?
+    public let nextRegenPercent: Double?
+    public let cost: ProviderCostSnapshot?
 
     public init(
         label: String?,
         usedPercent: Double,
         windowMinutes: Int?,
         resetsAt: Date?,
-        resetDescription: String?)
+        resetDescription: String?,
+        nextRegenPercent: Double? = nil,
+        cost: ProviderCostSnapshot? = nil)
     {
         self.label = label
         self.usedPercent = usedPercent
         self.windowMinutes = windowMinutes
         self.resetsAt = resetsAt
         self.resetDescription = resetDescription
+        self.nextRegenPercent = nextRegenPercent
+        self.cost = cost
     }
 }
 
 public struct SyntheticUsageSnapshot: Sendable {
     public let quotas: [SyntheticQuotaEntry]
+    /// Slot-identified lanes for the known Synthetic response shape: [rolling-5h, weekly, search-hourly].
+    /// When set, `toUsageSnapshot` maps slot 0 → primary, slot 1 → secondary, slot 2 → tertiary,
+    /// so a missing lane stays nil instead of promoting the next lane into the wrong UI label.
+    public let slottedQuotas: [SyntheticQuotaEntry?]?
     public let planName: String?
     public let updatedAt: Date
 
-    public init(quotas: [SyntheticQuotaEntry], planName: String?, updatedAt: Date) {
+    public init(
+        quotas: [SyntheticQuotaEntry],
+        slottedQuotas: [SyntheticQuotaEntry?]? = nil,
+        planName: String?,
+        updatedAt: Date)
+    {
         self.quotas = quotas
+        self.slottedQuotas = slottedQuotas
         self.planName = planName
         self.updatedAt = updatedAt
     }
@@ -39,11 +55,13 @@ public struct SyntheticUsageSnapshot: Sendable {
 
 extension SyntheticUsageSnapshot {
     public func toUsageSnapshot() -> UsageSnapshot {
-        let primaryEntry = self.quotas.first
-        let secondaryEntry = self.quotas.dropFirst().first
+        let slots = self.slottedQuotas
+            ?? [self.quotas.first, self.quotas.dropFirst().first, self.quotas.dropFirst(2).first]
+        let entries: [SyntheticQuotaEntry?] = (0..<3).map { slots.indices.contains($0) ? slots[$0] : nil }
 
-        let primary = primaryEntry.map(Self.rateWindow(for:))
-        let secondary = secondaryEntry.map(Self.rateWindow(for:))
+        let primary = entries[0].map(Self.rateWindow(for:))
+        let secondary = entries[1].map(Self.rateWindow(for:))
+        let tertiary = entries[2].map(Self.rateWindow(for:))
 
         let planName = self.planName?.trimmingCharacters(in: .whitespacesAndNewlines)
         let loginMethod = (planName?.isEmpty ?? true) ? nil : planName
@@ -56,8 +74,8 @@ extension SyntheticUsageSnapshot {
         return UsageSnapshot(
             primary: primary,
             secondary: secondary,
-            tertiary: nil,
-            providerCost: nil,
+            tertiary: tertiary,
+            providerCost: self.quotas.first(where: { $0.cost != nil })?.cost,
             updatedAt: self.updatedAt,
             identity: identity)
     }
@@ -67,7 +85,8 @@ extension SyntheticUsageSnapshot {
             usedPercent: quota.usedPercent,
             windowMinutes: quota.windowMinutes,
             resetsAt: quota.resetsAt,
-            resetDescription: quota.resetDescription)
+            resetDescription: quota.resetDescription,
+            nextRegenPercent: quota.nextRegenPercent)
     }
 }
 
@@ -85,19 +104,15 @@ public struct SyntheticUsageFetcher: Sendable {
         request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
         request.setValue("application/json", forHTTPHeaderField: "Accept")
 
-        let (data, response) = try await URLSession.shared.data(for: request)
-
-        guard let httpResponse = response as? HTTPURLResponse else {
-            throw SyntheticUsageError.networkError("Invalid response")
-        }
-
-        guard httpResponse.statusCode == 200 else {
+        let response = try await ProviderHTTPClient.shared.response(for: request)
+        let data = response.data
+        guard response.statusCode == 200 else {
             let errorMessage = String(data: data, encoding: .utf8) ?? "Unknown error"
-            Self.log.error("Synthetic API returned \(httpResponse.statusCode): \(errorMessage)")
-            if httpResponse.statusCode == 401 || httpResponse.statusCode == 403 {
+            Self.log.error("Synthetic API returned \(response.statusCode): \(errorMessage)")
+            if response.statusCode == 401 || response.statusCode == 403 {
                 throw SyntheticUsageError.invalidCredentials
             }
-            throw SyntheticUsageError.apiError("HTTP \(httpResponse.statusCode): \(errorMessage)")
+            throw SyntheticUsageError.apiError("HTTP \(response.statusCode): \(errorMessage)")
         }
 
         do {
@@ -147,20 +162,46 @@ enum SyntheticUsageParser {
         }()
 
         let planName = self.planName(from: root)
-        let quotaObjects = self.quotaObjects(from: root)
-        let quotas = quotaObjects.compactMap { self.parseQuota($0) }
 
+        if let slots = self.prioritizedQuotaSlots(from: root) {
+            let slotted: [SyntheticQuotaEntry?] = slots.map { $0.flatMap(self.parseQuota) }
+            let flat = slotted.compactMap(\.self)
+            guard !flat.isEmpty else {
+                throw SyntheticUsageError.parseFailed("Missing quota data.")
+            }
+            return SyntheticUsageSnapshot(
+                quotas: flat,
+                slottedQuotas: slotted,
+                planName: planName,
+                updatedAt: now)
+        }
+
+        let quotas = self.fallbackQuotaObjects(from: root).compactMap(self.parseQuota)
         guard !quotas.isEmpty else {
             throw SyntheticUsageError.parseFailed("Missing quota data.")
         }
-
         return SyntheticUsageSnapshot(
             quotas: quotas,
             planName: planName,
             updatedAt: now)
     }
 
-    private static func quotaObjects(from root: [String: Any]) -> [[String: Any]] {
+    /// Returns slot-positional quota payloads `[rolling-5h, weekly, search-hourly]` when the known Synthetic
+    /// response shape is detected. Missing lanes stay nil in their slot so downstream code doesn't shift
+    /// labels. Returns nil if none of the known keys appear, so the fallback path runs.
+    private static func prioritizedQuotaSlots(from root: [String: Any]) -> [[String: Any]?]? {
+        let dataDict = root["data"] as? [String: Any]
+        let rolling = self.namedQuota(root["rollingFiveHourLimit"], label: "Rolling five-hour limit")
+            ?? self.namedQuota(dataDict?["rollingFiveHourLimit"], label: "Rolling five-hour limit")
+        let weekly = self.namedQuota(root["weeklyTokenLimit"], label: "Weekly token limit")
+            ?? self.namedQuota(dataDict?["weeklyTokenLimit"], label: "Weekly token limit")
+        let searchHourly = self.namedQuota((root["search"] as? [String: Any])?["hourly"], label: "Search hourly")
+            ?? self.namedQuota((dataDict?["search"] as? [String: Any])?["hourly"], label: "Search hourly")
+        let slots: [[String: Any]?] = [rolling, weekly, searchHourly]
+        return slots.contains(where: { $0 != nil }) ? slots : nil
+    }
+
+    private static func fallbackQuotaObjects(from root: [String: Any]) -> [[String: Any]] {
         let dataDict = root["data"] as? [String: Any]
         let candidates: [Any?] = [
             root["quotas"],
@@ -179,14 +220,8 @@ enum SyntheticUsageParser {
         ]
 
         for candidate in candidates {
-            if let array = candidate as? [[String: Any]] { return array }
-            if let array = candidate as? [Any] {
-                let dicts = array.compactMap { $0 as? [String: Any] }
-                if !dicts.isEmpty { return dicts }
-            }
-            if let dict = candidate as? [String: Any], self.isQuotaPayload(dict) {
-                return [dict]
-            }
+            let quotas = self.extractQuotaObjects(from: candidate)
+            if !quotas.isEmpty { return quotas }
         }
         return []
     }
@@ -239,14 +274,22 @@ enum SyntheticUsageParser {
 
         let windowMinutes = windowMinutes(from: payload)
         let resetsAt = self.firstDate(in: payload, keys: self.resetKeys)
+        // Leave resetDescription nil when resetsAt is set so the UI rebuilds the countdown each render
+        // against the current clock instead of freezing a stale "in Xm" string at parse time.
         let resetDescription = resetsAt == nil ? self.windowDescription(minutes: windowMinutes) : nil
 
+        let cost = self.providerCost(from: payload, usedPercent: clamped, resetsAt: resetsAt)
+        let nextRegenPercent = self.normalizedPercent(
+            self.firstDouble(in: payload, keys: Self.tickPercentKeys))
+
         return SyntheticQuotaEntry(
             label: label,
             usedPercent: clamped,
             windowMinutes: windowMinutes,
             resetsAt: resetsAt,
-            resetDescription: resetDescription)
+            resetDescription: resetDescription,
+            nextRegenPercent: nextRegenPercent,
+            cost: cost)
     }
 
     private static func isQuotaPayload(_ payload: [String: Any]) -> Bool {
@@ -271,9 +314,78 @@ enum SyntheticUsageParser {
         if let seconds = self.firstDouble(in: payload, keys: windowSecondsKeys) {
             return Int((seconds / 60).rounded())
         }
+        if let text = self.firstString(in: payload, keys: windowStringKeys) {
+            return self.windowMinutes(fromText: text)
+        }
         return nil
     }
 
+    private static func namedQuota(_ candidate: Any?, label: String) -> [String: Any]? {
+        guard var payload = candidate as? [String: Any], self.isQuotaPayload(payload) else { return nil }
+        if payload["label"] == nil, payload["name"] == nil {
+            payload["label"] = label
+        }
+        return payload
+    }
+
+    private static func extractQuotaObjects(from candidate: Any?) -> [[String: Any]] {
+        switch candidate {
+        case let array as [[String: Any]]:
+            var nestedQuotas: [[String: Any]] = []
+            for entry in array {
+                if self.isQuotaPayload(entry) {
+                    nestedQuotas.append(entry)
+                } else {
+                    nestedQuotas.append(contentsOf: self.extractQuotaObjects(from: entry))
+                }
+            }
+            return nestedQuotas
+        case let array as [Any]:
+            return array.flatMap { self.extractQuotaObjects(from: $0) }
+        case let dict as [String: Any]:
+            if self.isQuotaPayload(dict) {
+                return [dict]
+            }
+            var nestedQuotas: [[String: Any]] = []
+            for key in dict.keys.sorted() {
+                nestedQuotas.append(contentsOf: self.extractQuotaObjects(from: dict[key]))
+            }
+            return nestedQuotas
+        default:
+            return []
+        }
+    }
+
+    /// Parses durations like `"5hr"`, `"30min"`, `"2 days"`. Suffixes are sorted longest-first so
+    /// multi-letter units always win over their single-letter aliases — no ordering surprises if a
+    /// future unit shares a trailing letter with another.
+    static func windowMinutes(fromText text: String) -> Int? {
+        let normalized = text
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .lowercased()
+            .replacingOccurrences(of: " ", with: "")
+        guard !normalized.isEmpty else { return nil }
+
+        for (suffix, multiplier) in Self.windowSuffixMultipliers {
+            guard normalized.hasSuffix(suffix) else { continue }
+            let valueText = String(normalized.dropLast(suffix.count))
+            guard let value = Double(valueText), value > 0 else { return nil }
+            return Int((value * multiplier).rounded())
+        }
+        return nil
+    }
+
+    private static let windowSuffixMultipliers: [(suffix: String, multiplier: Double)] = {
+        let raw: [(String, Double)] = [
+            ("minutes", 1), ("minute", 1), ("mins", 1), ("min", 1), ("m", 1),
+            ("hours", 60), ("hour", 60), ("hrs", 60), ("hr", 60), ("h", 60),
+            ("days", 24 * 60), ("day", 24 * 60), ("d", 24 * 60),
+        ]
+        return raw
+            .sorted { $0.0.count > $1.0.count }
+            .map { (suffix: $0.0, multiplier: $0.1) }
+    }()
+
     private static func windowDescription(minutes: Int?) -> String? {
         guard let minutes, minutes > 0 else { return nil }
         let dayMinutes = 24 * 60
@@ -288,6 +400,57 @@ enum SyntheticUsageParser {
         return "\(minutes) minute\(minutes == 1 ? "" : "s") window"
     }
 
+    private static func providerCost(
+        from payload: [String: Any],
+        usedPercent: Double,
+        resetsAt: Date?) -> ProviderCostSnapshot?
+    {
+        guard let limit = self.firstCurrency(in: payload, keys: self.costLimitKeys) else { return nil }
+
+        let remaining = self.firstCurrency(in: payload, keys: self.costRemainingKeys)
+        let usedFromPayload = self.firstCurrency(in: payload, keys: self.costUsedKeys)
+        let nextRegenAmount = self.firstCurrency(in: payload, keys: self.regenAmountKeys)
+        let used = if let usedFromPayload {
+            usedFromPayload
+        } else if let remaining {
+            max(0, limit - remaining)
+        } else {
+            (usedPercent.clamped(to: 0...100) / 100) * limit
+        }
+
+        return ProviderCostSnapshot(
+            used: used,
+            limit: limit,
+            currencyCode: "USD",
+            period: "Weekly",
+            resetsAt: resetsAt,
+            nextRegenAmount: nextRegenAmount,
+            updatedAt: Date())
+    }
+
+    private static func firstCurrency(in payload: [String: Any], keys: [String]) -> Double? {
+        for key in keys {
+            guard let value = payload[key] else { continue }
+            if let text = value as? String,
+               let parsed = self.parseCurrency(text)
+            {
+                return parsed
+            }
+            if let number = self.doubleValue(value) {
+                return number
+            }
+        }
+        return nil
+    }
+
+    private static func parseCurrency(_ text: String) -> Double? {
+        let cleaned = text
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .replacingOccurrences(of: "$", with: "")
+            .replacingOccurrences(of: ",", with: "")
+        return Double(cleaned)
+    }
+
     private static func normalizedPercent(_ value: Double?) -> Double? {
         guard let value else { return nil }
         if value <= 1 { return value * 100 }
@@ -423,6 +586,13 @@ enum SyntheticUsageParser {
 
     private static let limitKeys = [
         "limit",
+        "messageLimit",
+        "message_limit",
+        "messages",
+        "maxRequests",
+        "max_requests",
+        "requestLimit",
+        "request_limit",
         "quota",
         "max",
         "total",
@@ -433,6 +603,10 @@ enum SyntheticUsageParser {
     private static let usedKeys = [
         "used",
         "usage",
+        "usedMessages",
+        "used_messages",
+        "messagesUsed",
+        "messages_used",
         "requests",
         "requestCount",
         "request_count",
@@ -456,6 +630,10 @@ enum SyntheticUsageParser {
         "renew_at",
         "renewsAt",
         "renews_at",
+        "nextTickAt",
+        "next_tick_at",
+        "nextRegenAt",
+        "next_regen_at",
         "periodEnd",
         "period_end",
         "expiresAt",
@@ -464,6 +642,33 @@ enum SyntheticUsageParser {
         "end_at",
     ]
 
+    private static let regenAmountKeys = [
+        "nextRegenCredits",
+        "next_regen_credits",
+    ]
+
+    private static let tickPercentKeys = [
+        "tickPercent",
+        "tick_percent",
+        "nextTickPercent",
+        "next_tick_percent",
+    ]
+
+    private static let costLimitKeys = [
+        "maxCredits",
+        "max_credits",
+    ]
+
+    private static let costRemainingKeys = [
+        "remainingCredits",
+        "remaining_credits",
+    ]
+
+    private static let costUsedKeys = [
+        "usedCredits",
+        "used_credits",
+    ]
+
     private static let windowMinutesKeys = [
         "windowMinutes",
         "window_minutes",
@@ -491,6 +696,15 @@ enum SyntheticUsageParser {
         "periodSeconds",
         "period_seconds",
     ]
+
+    private static let windowStringKeys = [
+        "window",
+        "windowLabel",
+        "window_label",
+        "period",
+        "periodLabel",
+        "period_label",
+    ]
 }
 
 public enum SyntheticUsageError: LocalizedError, Sendable {
diff --git a/Sources/CodexBarCore/Providers/T3Chat/T3ChatProviderDescriptor.swift b/Sources/CodexBarCore/Providers/T3Chat/T3ChatProviderDescriptor.swift
new file mode 100644
index 0000000000..d06649fc4b
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/T3Chat/T3ChatProviderDescriptor.swift
@@ -0,0 +1,84 @@
+import Foundation
+
+public enum T3ChatProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .t3chat,
+            metadata: ProviderMetadata(
+                id: .t3chat,
+                displayName: "T3 Chat",
+                sessionLabel: "Base",
+                weeklyLabel: "Overage",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "",
+                toggleTitle: "Show T3 Chat usage",
+                cliName: "t3chat",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                browserCookieOrder: ProviderBrowserCookieDefaults.defaultImportOrder,
+                dashboardURL: "https://t3.chat/settings/customization",
+                subscriptionDashboardURL: "https://t3.chat/settings/subscription",
+                statusPageURL: nil),
+            branding: ProviderBranding(
+                iconStyle: .t3chat,
+                iconResourceName: "ProviderIcon-t3chat",
+                color: ProviderColor(red: 245 / 255, green: 102 / 255, blue: 71 / 255)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "T3 Chat cost summary is not supported." }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .web],
+                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [T3ChatWebFetchStrategy()] })),
+            cli: ProviderCLIConfig(
+                name: "t3chat",
+                aliases: ["t3-chat", "t3"],
+                versionDetector: nil))
+    }
+}
+
+struct T3ChatWebFetchStrategy: ProviderFetchStrategy {
+    let id: String = "t3chat.web"
+    let kind: ProviderFetchKind = .web
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        let cookieSource = context.settings?.t3chat?.cookieSource ?? .auto
+        guard cookieSource != .off else { return false }
+        if cookieSource == .manual {
+            return T3ChatUsageFetcher.requestContext(from: context.settings?.t3chat?.manualCookieHeader) != nil
+        }
+        #if os(macOS)
+        return true
+        #else
+        return false
+        #endif
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        let fetcher = T3ChatUsageFetcher(browserDetection: context.browserDetection)
+        let manual = Self.manualCookieHeader(from: context)
+        let logger: ((String) -> Void)? = context.verbose
+            ? { msg in CodexBarLog.logger(LogCategories.t3chat).verbose(msg) }
+            : nil
+        let snapshot = try await fetcher.fetch(
+            cookieHeaderOverride: manual,
+            timeout: context.webTimeout,
+            logger: logger)
+        return self.makeResult(
+            usage: snapshot.toUsageSnapshot(),
+            sourceLabel: "web")
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+
+    private static func manualCookieHeader(from context: ProviderFetchContext) -> String? {
+        guard context.settings?.t3chat?.cookieSource == .manual else { return nil }
+        return context.settings?.t3chat?.manualCookieHeader
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/T3Chat/T3ChatUsageFetcher.swift b/Sources/CodexBarCore/Providers/T3Chat/T3ChatUsageFetcher.swift
new file mode 100644
index 0000000000..bddc960e47
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/T3Chat/T3ChatUsageFetcher.swift
@@ -0,0 +1,366 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+#if os(macOS)
+import SweetCookieKit
+#endif
+
+#if os(macOS)
+private let t3ChatCookieImportOrder: BrowserCookieImportOrder =
+    ProviderDefaults.metadata[.t3chat]?.browserCookieOrder ?? Browser.defaultImportOrder
+
+public enum T3ChatCookieImporter {
+    private static let cookieClient = BrowserCookieClient()
+    private static let cookieDomains = ["t3.chat", "www.t3.chat"]
+
+    public struct SessionInfo: Sendable {
+        public let cookieHeader: String
+        public let sourceLabel: String
+
+        public init(cookieHeader: String, sourceLabel: String) {
+            self.cookieHeader = cookieHeader
+            self.sourceLabel = sourceLabel
+        }
+    }
+
+    public static func importSession(
+        browserDetection: BrowserDetection,
+        logger: ((String) -> Void)? = nil) throws -> SessionInfo
+    {
+        let log: (String) -> Void = { msg in logger?("[t3chat-cookie] \(msg)") }
+        let installed = t3ChatCookieImportOrder.cookieImportCandidates(using: browserDetection)
+
+        for browserSource in installed {
+            do {
+                let query = BrowserCookieQuery(domains: self.cookieDomains)
+                let sources = try self.cookieClient.codexBarRecords(
+                    matching: query,
+                    in: browserSource,
+                    logger: log)
+                for source in sources where !source.records.isEmpty {
+                    let cookies = BrowserCookieClient.makeHTTPCookies(source.records, origin: query.origin)
+                    guard !cookies.isEmpty else { continue }
+                    let names = cookies.map(\.name).joined(separator: ", ")
+                    log("\(source.label) cookies: \(names)")
+                    let header = cookies.map { "\($0.name)=\($0.value)" }.joined(separator: "; ")
+                    return SessionInfo(cookieHeader: header, sourceLabel: source.label)
+                }
+            } catch {
+                BrowserCookieAccessGate.recordIfNeeded(error)
+                log("\(browserSource.displayName) cookie import failed: \(error.localizedDescription)")
+            }
+        }
+
+        throw T3ChatUsageError.noSessionCookie
+    }
+}
+#endif
+
+public struct T3ChatUsageFetcher: Sendable {
+    private static let log = CodexBarLog.logger(LogCategories.t3chat)
+    private static let baseURL = URL(string: "https://t3.chat")!
+    private static let refererURL = URL(string: "https://t3.chat/settings/customization")!
+    /// Browser fingerprint defaults are only fallbacks; full cURL captures override these forwarded headers.
+    private static let userAgent =
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) " +
+        "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36"
+    /// Captured from T3 Chat's getCustomerData tRPC request shape in May 2026.
+    private static let input = #"{"0":{"json":{"sessionId":null},"meta":{"values":{"sessionId":["undefined"]}}}}"#
+    private static let forwardedManualHeaders = [
+        "accept": "Accept",
+        "accept-language": "Accept-Language",
+        "cache-control": "Cache-Control",
+        "pragma": "Pragma",
+        "priority": "Priority",
+        "referer": "Referer",
+        "sec-fetch-dest": "Sec-Fetch-Dest",
+        "sec-fetch-mode": "Sec-Fetch-Mode",
+        "sec-fetch-site": "Sec-Fetch-Site",
+        "trpc-accept": "trpc-accept",
+        "user-agent": "User-Agent",
+        "x-client-context": "x-client-context",
+        "x-deployment-id": "X-Deployment-Id",
+        "x-trpc-batch": "x-trpc-batch",
+        "x-trpc-source": "x-trpc-source",
+    ]
+
+    public struct RequestContext: Sendable {
+        public let cookieHeader: String
+        public let headers: [String: String]
+
+        public init(cookieHeader: String, headers: [String: String] = [:]) {
+            self.cookieHeader = cookieHeader
+            self.headers = headers
+        }
+    }
+
+    public let browserDetection: BrowserDetection
+
+    public init(browserDetection: BrowserDetection) {
+        self.browserDetection = browserDetection
+    }
+
+    public func fetch(
+        cookieHeaderOverride: String? = nil,
+        timeout: TimeInterval = 15,
+        logger: ((String) -> Void)? = nil,
+        now: Date = Date(),
+        transport: any ProviderHTTPTransport = ProviderHTTPClient.shared) async throws -> T3ChatUsageSnapshot
+    {
+        let log: (String) -> Void = { msg in logger?("[t3chat] \(msg)") }
+        let context = try await self.resolveRequestContext(override: cookieHeaderOverride, logger: log)
+        if let logger {
+            let names = CookieHeaderNormalizer.pairs(from: context.cookieHeader).map(\.name)
+            if !names.isEmpty {
+                logger("[t3chat] Cookie names: \(names.joined(separator: ", "))")
+            }
+            if !context.headers.isEmpty {
+                let headerNames = context.headers.keys.sorted().joined(separator: ", ")
+                logger("[t3chat] Forwarding captured headers: \(headerNames)")
+            }
+        }
+        return try await Self.fetchCustomerData(
+            context: context,
+            timeout: timeout,
+            now: now,
+            transport: transport)
+    }
+
+    public func debugRawProbe(cookieHeaderOverride: String? = nil) async -> String {
+        let stamp = ISO8601DateFormatter().string(from: Date())
+        var lines: [String] = []
+        lines.append("=== T3 Chat Debug Probe @ \(stamp) ===")
+        lines.append("")
+
+        do {
+            let snapshot = try await self.fetch(
+                cookieHeaderOverride: cookieHeaderOverride,
+                logger: { msg in lines.append(msg) })
+            lines.append("")
+            lines.append("Fetch Success")
+            lines.append("subTier=\(snapshot.customerData.subTier ?? "nil")")
+            lines.append("usageBand=\(snapshot.customerData.usageBand ?? "nil")")
+            lines
+                .append(
+                    "usageFourHourPercentage=\(snapshot.customerData.usageFourHourPercentage?.description ?? "nil")")
+            lines.append("usageMonthPercentage=\(snapshot.customerData.usageMonthPercentage?.description ?? "nil")")
+            lines.append("usagePeriodPercentage=\(snapshot.customerData.usagePeriodPercentage?.description ?? "nil")")
+            lines
+                .append(
+                    "usageFourHourNextResetAt=\(snapshot.customerData.usageFourHourNextResetAt?.description ?? "nil")")
+            lines.append("billingNextResetAt=\(snapshot.customerData.billingNextResetAt?.description ?? "nil")")
+        } catch {
+            lines.append("")
+            lines.append("Probe Failed: \(error.localizedDescription)")
+        }
+
+        return lines.joined(separator: "\n")
+    }
+
+    public static func fetchCustomerData(
+        cookieHeader: String,
+        timeout: TimeInterval = 15,
+        now: Date = Date(),
+        transport: any ProviderHTTPTransport = ProviderHTTPClient.shared) async throws -> T3ChatUsageSnapshot
+    {
+        guard let normalizedCookieHeader = CookieHeaderNormalizer.normalize(cookieHeader) else {
+            throw T3ChatUsageError.noSessionCookie
+        }
+        return try await self.fetchCustomerData(
+            context: RequestContext(cookieHeader: normalizedCookieHeader),
+            timeout: timeout,
+            now: now,
+            transport: transport)
+    }
+
+    public static func fetchCustomerData(
+        context: RequestContext,
+        timeout: TimeInterval = 15,
+        now: Date = Date(),
+        transport: any ProviderHTTPTransport = ProviderHTTPClient.shared) async throws -> T3ChatUsageSnapshot
+    {
+        guard let normalizedCookieHeader = CookieHeaderNormalizer.normalize(context.cookieHeader) else {
+            throw T3ChatUsageError.noSessionCookie
+        }
+
+        let url = try self.customerDataURL()
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.timeoutInterval = timeout
+        self.applyDefaultHeaders(to: &request)
+        for (name, value) in context.headers {
+            request.setValue(value, forHTTPHeaderField: name)
+        }
+        request.setValue(self.baseURL.absoluteString, forHTTPHeaderField: "Origin")
+        request.setValue(normalizedCookieHeader, forHTTPHeaderField: "Cookie")
+
+        let response = try await transport.response(for: request)
+        let data = response.data
+        guard response.statusCode == 200 else {
+            let body = String(data: data.prefix(200), encoding: .utf8) ?? "<binary>"
+            Self.log.error("T3 Chat API returned \(response.statusCode): \(body)")
+            if response.statusCode == 401 || response.statusCode == 403 {
+                throw T3ChatUsageError.invalidCredentials
+            }
+            if response.statusCode == 429,
+               response.response.value(forHTTPHeaderField: "x-vercel-mitigated") == "challenge"
+            {
+                throw T3ChatUsageError.vercelChallenge
+            }
+            throw T3ChatUsageError.apiError("HTTP \(response.statusCode)")
+        }
+
+        do {
+            return try T3ChatUsageParser.parseJSONLines(data, now: now)
+        } catch {
+            let preview = String(data: data.prefix(500), encoding: .utf8) ?? "<binary>"
+            Self.log.error("T3 Chat parse failed: \(error.localizedDescription) response=\(preview)")
+            throw error
+        }
+    }
+
+    private func resolveRequestContext(
+        override: String?,
+        logger: ((String) -> Void)?) async throws -> RequestContext
+    {
+        if let override = Self.requestContext(from: override) {
+            let source = override.headers.isEmpty ? "manual cookie header" : "manual cURL capture"
+            logger?("[t3chat] Using \(source)")
+            return override
+        }
+
+        #if os(macOS)
+        let session = try T3ChatCookieImporter.importSession(
+            browserDetection: self.browserDetection,
+            logger: logger)
+        logger?("[t3chat] Using cookies from \(session.sourceLabel)")
+        return RequestContext(cookieHeader: session.cookieHeader)
+        #else
+        throw T3ChatUsageError.noSessionCookie
+        #endif
+    }
+
+    static func requestContext(from raw: String?) -> RequestContext? {
+        guard let raw = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !raw.isEmpty else { return nil }
+        let headerFields = Self.headerFields(from: raw)
+        guard let cookieHeader = Self.cookieHeader(from: headerFields) ?? CookieHeaderNormalizer.normalize(raw) else {
+            return nil
+        }
+        let headers = Self.forwardedHeaders(from: headerFields)
+        return RequestContext(cookieHeader: cookieHeader, headers: headers)
+    }
+
+    private static func applyDefaultHeaders(to request: inout URLRequest) {
+        request.setValue("*/*", forHTTPHeaderField: "Accept")
+        request.setValue("application/jsonl", forHTTPHeaderField: "trpc-accept")
+        request.setValue("web-client", forHTTPHeaderField: "x-trpc-source")
+        request.setValue("true", forHTTPHeaderField: "x-trpc-batch")
+        request.setValue("en-US,en;q=0.9", forHTTPHeaderField: "Accept-Language")
+        request.setValue(self.userAgent, forHTTPHeaderField: "User-Agent")
+        request.setValue(self.refererURL.absoluteString, forHTTPHeaderField: "Referer")
+        request.setValue("empty", forHTTPHeaderField: "Sec-Fetch-Dest")
+        request.setValue("cors", forHTTPHeaderField: "Sec-Fetch-Mode")
+        request.setValue("same-origin", forHTTPHeaderField: "Sec-Fetch-Site")
+        request.setValue("u=4", forHTTPHeaderField: "Priority")
+        request.setValue("no-cache", forHTTPHeaderField: "Pragma")
+        request.setValue("no-cache", forHTTPHeaderField: "Cache-Control")
+    }
+
+    private static func forwardedHeaders(from fields: [String]) -> [String: String] {
+        var headers: [String: String] = [:]
+        for field in fields {
+            guard let colon = field.firstIndex(of: ":") else { continue }
+            let rawName = field[..<colon].trimmingCharacters(in: .whitespacesAndNewlines)
+            let value = field[field.index(after: colon)...].trimmingCharacters(in: .whitespacesAndNewlines)
+            guard !rawName.isEmpty, !value.isEmpty else { continue }
+            guard let canonical = self.forwardedManualHeaders[rawName.lowercased()] else { continue }
+            headers[canonical] = value
+        }
+        return headers
+    }
+
+    private static func cookieHeader(from fields: [String]) -> String? {
+        for field in fields {
+            guard let colon = field.firstIndex(of: ":") else { continue }
+            let rawName = field[..<colon].trimmingCharacters(in: .whitespacesAndNewlines)
+            guard rawName.caseInsensitiveCompare("Cookie") == .orderedSame else { continue }
+            let value = field[field.index(after: colon)...].trimmingCharacters(in: .whitespacesAndNewlines)
+            if let normalized = CookieHeaderNormalizer.normalize(String(value)) {
+                return normalized
+            }
+        }
+        return nil
+    }
+
+    private static func headerFields(from raw: String) -> [String] {
+        var fields: [String] = []
+        let pattern =
+            #"(?s)(?:^|\s)(?:-H|--header)(?:\s+|=|(?=['"$]))"# +
+            #"(?:\$'((?:\\.|[^'])*)'|'([^']*)'|"((?:\\.|[^"])*)"|(\S+))"#
+        guard let regex = try? NSRegularExpression(pattern: pattern, options: []) else { return fields }
+        let range = NSRange(raw.startIndex..<raw.endIndex, in: raw)
+        for match in regex.matches(in: raw, options: [], range: range) {
+            if let ansi = self.capture(1, in: match, raw: raw) {
+                fields.append(self.unescapeShellSegment(ansi, ansi: true))
+            } else if let single = self.capture(2, in: match, raw: raw) {
+                fields.append(single)
+            } else if let double = self.capture(3, in: match, raw: raw) {
+                fields.append(self.unescapeShellSegment(double, ansi: false))
+            } else if let bare = self.capture(4, in: match, raw: raw) {
+                fields.append(self.unescapeShellSegment(bare, ansi: false))
+            }
+        }
+        return fields
+    }
+
+    private static func capture(_ index: Int, in match: NSTextCheckingResult, raw: String) -> String? {
+        guard match.numberOfRanges > index,
+              let range = Range(match.range(at: index), in: raw)
+        else {
+            return nil
+        }
+        return String(raw[range])
+    }
+
+    private static func unescapeShellSegment(_ raw: String, ansi: Bool) -> String {
+        var output = ""
+        var index = raw.startIndex
+        while index < raw.endIndex {
+            guard raw[index] == "\\" else {
+                output.append(raw[index])
+                index = raw.index(after: index)
+                continue
+            }
+            let next = raw.index(after: index)
+            guard next < raw.endIndex else { return output }
+            switch raw[next] {
+            case "n" where ansi:
+                output.append("\n")
+            case "r" where ansi:
+                output.append("\r")
+            case "t" where ansi:
+                output.append("\t")
+            case "\n":
+                break
+            default:
+                output.append(raw[next])
+            }
+            index = raw.index(after: next)
+        }
+        return output
+    }
+
+    private static func customerDataURL() throws -> URL {
+        var components = URLComponents(string: "https://t3.chat/api/trpc/getCustomerData")!
+        components.queryItems = [
+            URLQueryItem(name: "batch", value: "1"),
+            URLQueryItem(name: "input", value: self.input),
+        ]
+        guard let url = components.url else {
+            throw T3ChatUsageError.apiError("Failed to build customer data URL.")
+        }
+        return url
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/T3Chat/T3ChatUsageSnapshot.swift b/Sources/CodexBarCore/Providers/T3Chat/T3ChatUsageSnapshot.swift
new file mode 100644
index 0000000000..e75c05e7ed
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/T3Chat/T3ChatUsageSnapshot.swift
@@ -0,0 +1,180 @@
+import Foundation
+
+public enum T3ChatUsageError: LocalizedError, Sendable {
+    case noSessionCookie
+    case invalidCredentials
+    case vercelChallenge
+    case apiError(String)
+    case parseFailed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .noSessionCookie:
+            "No T3 Chat cookies found. Please log in to t3.chat in your browser."
+        case .invalidCredentials:
+            "T3 Chat session cookie is invalid or expired."
+        case .vercelChallenge:
+            "T3 Chat returned a Vercel security challenge. Paste the full browser cURL request, " +
+                "not just the Cookie header."
+        case let .apiError(message):
+            "T3 Chat API error: \(message)"
+        case let .parseFailed(message):
+            "Could not parse T3 Chat usage: \(message)"
+        }
+    }
+}
+
+public struct T3ChatSubscription: Decodable, Sendable {
+    public let productId: String?
+    public let productName: String?
+    public let status: String?
+    public let currentPeriodStart: TimeInterval?
+    public let currentPeriodEnd: TimeInterval?
+    public let canceledAt: TimeInterval?
+    public let trialEndsAt: TimeInterval?
+}
+
+public struct T3ChatCustomerData: Decodable, Sendable {
+    public let subTier: String?
+    public let subscription: T3ChatSubscription?
+    public let lifetimeBalance: Double?
+    public let usageBand: String?
+    public let billingNextResetAt: TimeInterval?
+    public let usageFourHourPercentage: Double?
+    public let usageMonthPercentage: Double?
+    public let usageFourHourNextResetAt: TimeInterval?
+    public let usagePeriodPercentage: Double?
+    public let usageWindowNextResetAt: TimeInterval?
+
+    public var planName: String? {
+        let raw = self.subscription?.productName ?? self.subTier
+        guard let raw = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !raw.isEmpty else {
+            return nil
+        }
+        return raw.split(separator: "-").map { part in
+            part.prefix(1).uppercased() + String(part.dropFirst())
+        }.joined(separator: " ")
+    }
+}
+
+public struct T3ChatUsageSnapshot: Sendable {
+    public let customerData: T3ChatCustomerData
+    public let updatedAt: Date
+
+    public init(customerData: T3ChatCustomerData, updatedAt: Date) {
+        self.customerData = customerData
+        self.updatedAt = updatedAt
+    }
+
+    public func toUsageSnapshot() -> UsageSnapshot {
+        let baseReset = Self.date(fromMilliseconds: self.customerData.usageFourHourNextResetAt)
+            ?? Self.date(fromMilliseconds: self.customerData.usageWindowNextResetAt)
+        // billingNextResetAt tracks the usage window reset, not the overage billing period.
+        // If subscription metadata is absent, leave the overage reset unknown instead of showing the base reset.
+        let overageReset = Self.date(fromMilliseconds: self.customerData.subscription?.currentPeriodEnd)
+
+        let primary = RateWindow(
+            usedPercent: Self.percent(self.customerData.usageFourHourPercentage),
+            windowMinutes: 4 * 60,
+            resetsAt: baseReset,
+            resetDescription: Self.description(label: "Base", usageBand: self.customerData.usageBand))
+
+        let secondaryPercent = self.customerData.usageMonthPercentage
+            ?? self.customerData.usagePeriodPercentage
+        let secondary = RateWindow(
+            usedPercent: Self.percent(secondaryPercent),
+            windowMinutes: nil,
+            resetsAt: overageReset,
+            resetDescription: "Overage")
+
+        let identity = ProviderIdentitySnapshot(
+            providerID: .t3chat,
+            accountEmail: nil,
+            accountOrganization: nil,
+            loginMethod: self.customerData.planName)
+
+        return UsageSnapshot(
+            primary: primary,
+            secondary: secondary,
+            updatedAt: self.updatedAt,
+            identity: identity)
+    }
+
+    private static func percent(_ raw: Double?) -> Double {
+        min(100, max(0, raw ?? 0))
+    }
+
+    private static func date(fromMilliseconds raw: TimeInterval?) -> Date? {
+        guard let raw, raw > 0 else { return nil }
+        // T3 Chat currently returns JavaScript epoch milliseconds, while some subscription fields may be seconds.
+        let seconds = raw > 10_000_000_000 ? raw / 1000 : raw
+        return Date(timeIntervalSince1970: seconds)
+    }
+
+    private static func description(label: String, usageBand: String?) -> String {
+        guard let usageBand = usageBand?.trimmingCharacters(in: .whitespacesAndNewlines),
+              !usageBand.isEmpty
+        else {
+            return label
+        }
+        return "\(label) - \(usageBand)"
+    }
+}
+
+public enum T3ChatUsageParser {
+    public static func parseJSONLines(_ data: Data, now: Date = Date()) throws -> T3ChatUsageSnapshot {
+        guard let text = String(data: data, encoding: .utf8) else {
+            throw T3ChatUsageError.parseFailed("Response is not UTF-8.")
+        }
+        return try self.parseJSONLines(text, now: now)
+    }
+
+    public static func parseJSONLines(_ text: String, now: Date = Date()) throws -> T3ChatUsageSnapshot {
+        let lines = text.split(whereSeparator: \.isNewline)
+        for line in lines {
+            guard let data = String(line).data(using: .utf8) else { continue }
+            guard let object = try? JSONSerialization.jsonObject(with: data) else { continue }
+            guard let customerObject = self.findCustomerData(in: object) else { continue }
+            let customerData = try self.decodeCustomerData(customerObject)
+            return T3ChatUsageSnapshot(customerData: customerData, updatedAt: now)
+        }
+
+        throw T3ChatUsageError.parseFailed("Missing customer data object.")
+    }
+
+    private static func findCustomerData(in object: Any) -> [String: Any]? {
+        if let dictionary = object as? [String: Any] {
+            if dictionary["usageFourHourPercentage"] != nil ||
+                dictionary["usageMonthPercentage"] != nil ||
+                dictionary["subscription"] != nil && dictionary["usageBand"] != nil
+            {
+                return dictionary
+            }
+
+            for value in dictionary.values {
+                if let found = self.findCustomerData(in: value) {
+                    return found
+                }
+            }
+        }
+
+        if let array = object as? [Any] {
+            for value in array {
+                if let found = self.findCustomerData(in: value) {
+                    return found
+                }
+            }
+        }
+
+        return nil
+    }
+
+    private static func decodeCustomerData(_ object: [String: Any]) throws -> T3ChatCustomerData {
+        do {
+            let data = try JSONSerialization.data(withJSONObject: object, options: [])
+            return try JSONDecoder().decode(T3ChatCustomerData.self, from: data)
+        } catch {
+            throw T3ChatUsageError.parseFailed(error.localizedDescription)
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Venice/VeniceProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Venice/VeniceProviderDescriptor.swift
new file mode 100644
index 0000000000..d080293003
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Venice/VeniceProviderDescriptor.swift
@@ -0,0 +1,46 @@
+import Foundation
+
+public enum VeniceProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .venice,
+            metadata: ProviderMetadata(
+                id: .venice,
+                displayName: "Venice",
+                sessionLabel: "Balance",
+                weeklyLabel: "Balance",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "",
+                toggleTitle: "Show Venice usage",
+                cliName: "venice",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                browserCookieOrder: nil,
+                dashboardURL: "https://venice.ai/settings/api",
+                statusPageURL: nil,
+                statusLinkURL: nil),
+            branding: ProviderBranding(
+                iconStyle: .venice,
+                iconResourceName: "ProviderIcon-venice",
+                color: ProviderColor(red: 0.2, green: 0.6, blue: 1.0)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "Venice per-day cost history is not available via API." }),
+            fetchPlan: .apiToken(
+                strategyID: "venice.api",
+                resolveToken: { ProviderTokenResolver.veniceToken(environment: $0) },
+                missingCredentialsError: { VeniceUsageError.missingCredentials },
+                loadUsage: { apiKey, _ in
+                    try await VeniceUsageFetcher.fetchUsage(apiKey: apiKey).toUsageSnapshot()
+                }),
+            cli: ProviderCLIConfig(
+                name: "venice",
+                aliases: ["ven"],
+                versionDetector: nil))
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Venice/VeniceSettingsReader.swift b/Sources/CodexBarCore/Providers/Venice/VeniceSettingsReader.swift
new file mode 100644
index 0000000000..fcfffa0c38
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Venice/VeniceSettingsReader.swift
@@ -0,0 +1,33 @@
+import Foundation
+
+public struct VeniceSettingsReader: Sendable {
+    public static let apiKeyEnvironmentKey = "VENICE_API_KEY"
+    public static let apiKeyEnvironmentKeys = [Self.apiKeyEnvironmentKey, "VENICE_KEY"]
+
+    public static func apiKey(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> String?
+    {
+        for key in self.apiKeyEnvironmentKeys {
+            guard let raw = environment[key]?.trimmingCharacters(in: .whitespacesAndNewlines),
+                  !raw.isEmpty
+            else {
+                continue
+            }
+            let cleaned = Self.cleaned(raw)
+            if !cleaned.isEmpty {
+                return cleaned
+            }
+        }
+        return nil
+    }
+
+    private static func cleaned(_ raw: String) -> String {
+        var value = raw
+        if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
+            (value.hasPrefix("'") && value.hasSuffix("'"))
+        {
+            value = String(value.dropFirst().dropLast())
+        }
+        return value.trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Venice/VeniceUsageFetcher.swift b/Sources/CodexBarCore/Providers/Venice/VeniceUsageFetcher.swift
new file mode 100644
index 0000000000..0326a40ddf
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Venice/VeniceUsageFetcher.swift
@@ -0,0 +1,236 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+// MARK: - API response types
+
+public struct VeniceBalanceResponse: Decodable, Sendable {
+    public let canConsume: Bool
+    public let consumptionCurrency: String?
+    public let balances: VeniceBalances
+    public let diemEpochAllocation: Double?
+
+    enum CodingKeys: String, CodingKey {
+        case canConsume
+        case consumptionCurrency
+        case balances
+        case diemEpochAllocation
+    }
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.canConsume = try container.decode(Bool.self, forKey: .canConsume)
+        self.consumptionCurrency = try container.decodeIfPresent(String.self, forKey: .consumptionCurrency)
+        self.balances = try container.decode(VeniceBalances.self, forKey: .balances)
+        self.diemEpochAllocation = try container.decodeFlexibleDoubleIfPresent(forKey: .diemEpochAllocation)
+    }
+}
+
+public struct VeniceBalances: Decodable, Sendable {
+    public let diem: Double?
+    public let usd: Double?
+
+    enum CodingKeys: String, CodingKey {
+        case diem
+        case usd
+    }
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.diem = try container.decodeFlexibleDoubleIfPresent(forKey: .diem)
+        self.usd = try container.decodeFlexibleDoubleIfPresent(forKey: .usd)
+    }
+}
+
+// MARK: - Domain snapshot
+
+public struct VeniceUsageSnapshot: Sendable {
+    public let canConsume: Bool
+    public let consumptionCurrency: String?
+    public let diemBalance: Double?
+    public let usdBalance: Double?
+    public let diemEpochAllocation: Double?
+    public let updatedAt: Date
+
+    public init(
+        canConsume: Bool,
+        consumptionCurrency: String?,
+        diemBalance: Double?,
+        usdBalance: Double?,
+        diemEpochAllocation: Double?,
+        updatedAt: Date)
+    {
+        self.canConsume = canConsume
+        self.consumptionCurrency = consumptionCurrency
+        self.diemBalance = diemBalance
+        self.usdBalance = usdBalance
+        self.diemEpochAllocation = diemEpochAllocation
+        self.updatedAt = updatedAt
+    }
+
+    public func toUsageSnapshot() -> UsageSnapshot {
+        let balanceDetail: String
+        let usedPercent: Double
+        let activeCurrency = self.consumptionCurrency?.uppercased()
+
+        if !self.canConsume {
+            balanceDetail = "Balance unavailable for API calls"
+            usedPercent = 100
+        } else if activeCurrency == "USD", let usd = self.usdBalance, usd > 0 {
+            let usdStr = String(format: "%.2f", usd)
+            balanceDetail = "$\(usdStr) USD remaining"
+            usedPercent = 0
+        } else if activeCurrency != "USD", let diem = self.diemBalance, let allocation = self.diemEpochAllocation,
+                  allocation > 0
+        {
+            // DIEM balance with epoch allocation
+            let remaining = diem
+            let usedAmount = allocation - remaining
+            let used = clamp(usedAmount / allocation * 100, min: 0, max: 100)
+            usedPercent = used
+            let allocationStr = String(format: "%.2f", allocation)
+            let remainingStr = String(format: "%.2f", remaining)
+            balanceDetail = "DIEM \(remainingStr) / \(allocationStr) epoch allocation"
+        } else if activeCurrency == "DIEM", let diem = self.diemBalance, diem > 0 {
+            let diemStr = String(format: "%.2f", diem)
+            balanceDetail = "DIEM \(diemStr) remaining"
+            usedPercent = 0
+        } else if let diem = self.diemBalance, diem > 0 {
+            // DIEM balance without allocation
+            let diemStr = String(format: "%.2f", diem)
+            balanceDetail = "DIEM \(diemStr) remaining"
+            usedPercent = 0
+        } else if let usd = self.usdBalance, usd > 0 {
+            // USD balance
+            let usdStr = String(format: "%.2f", usd)
+            balanceDetail = "$\(usdStr) USD remaining"
+            usedPercent = 0
+        } else {
+            balanceDetail = "No Venice API balance available"
+            usedPercent = 100
+        }
+
+        let identity = ProviderIdentitySnapshot(
+            providerID: .venice,
+            accountEmail: nil,
+            accountOrganization: nil,
+            loginMethod: nil)
+        let balanceWindow = RateWindow(
+            usedPercent: usedPercent,
+            windowMinutes: nil,
+            resetsAt: nil,
+            resetDescription: balanceDetail)
+
+        return UsageSnapshot(
+            primary: balanceWindow,
+            secondary: nil,
+            tertiary: nil,
+            providerCost: nil,
+            updatedAt: self.updatedAt,
+            identity: identity)
+    }
+}
+
+// MARK: - Errors
+
+public enum VeniceUsageError: LocalizedError, Sendable {
+    case missingCredentials
+    case networkError(String)
+    case apiError(String)
+    case parseFailed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingCredentials:
+            "Missing Venice API key."
+        case let .networkError(message):
+            "Venice network error: \(message)"
+        case let .apiError(message):
+            "Venice API error: \(message)"
+        case let .parseFailed(message):
+            "Failed to parse Venice response: \(message)"
+        }
+    }
+}
+
+// MARK: - Fetcher
+
+public struct VeniceUsageFetcher: Sendable {
+    private static let log = CodexBarLog.logger(LogCategories.veniceUsage)
+    private static let balanceURL = URL(string: "https://api.venice.ai/api/v1/billing/balance")!
+    private static let timeoutSeconds: TimeInterval = 15
+
+    public static func fetchUsage(apiKey: String) async throws -> VeniceUsageSnapshot {
+        guard !apiKey.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+            throw VeniceUsageError.missingCredentials
+        }
+
+        var request = URLRequest(url: self.balanceURL)
+        request.httpMethod = "GET"
+        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        request.timeoutInterval = Self.timeoutSeconds
+
+        let response = try await ProviderHTTPClient.shared.response(for: request)
+        guard response.statusCode == 200 else {
+            Self.log.error("Venice API returned \(response.statusCode)")
+            throw VeniceUsageError.apiError("HTTP \(response.statusCode)")
+        }
+
+        return try Self.parseSnapshot(data: response.data)
+    }
+
+    static func _parseSnapshotForTesting(_ data: Data) throws -> VeniceUsageSnapshot {
+        try self.parseSnapshot(data: data)
+    }
+
+    private static func parseSnapshot(data: Data) throws -> VeniceUsageSnapshot {
+        let decoded: VeniceBalanceResponse
+        do {
+            decoded = try JSONDecoder().decode(VeniceBalanceResponse.self, from: data)
+        } catch {
+            throw VeniceUsageError.parseFailed(error.localizedDescription)
+        }
+
+        return VeniceUsageSnapshot(
+            canConsume: decoded.canConsume,
+            consumptionCurrency: decoded.consumptionCurrency,
+            diemBalance: decoded.balances.diem,
+            usdBalance: decoded.balances.usd,
+            diemEpochAllocation: decoded.diemEpochAllocation,
+            updatedAt: Date())
+    }
+}
+
+// MARK: - Helper
+
+private func clamp(_ value: Double, min: Double, max: Double) -> Double {
+    Swift.min(Swift.max(value, min), max)
+}
+
+extension KeyedDecodingContainer {
+    fileprivate func decodeFlexibleDoubleIfPresent(forKey key: K) throws -> Double? {
+        if try self.decodeNil(forKey: key) {
+            return nil
+        }
+        if let value = try? self.decode(Double.self, forKey: key) {
+            return value
+        }
+        if let stringValue = try? self.decode(String.self, forKey: key) {
+            let trimmed = stringValue.trimmingCharacters(in: .whitespacesAndNewlines)
+            guard !trimmed.isEmpty else { return nil }
+            if let parsed = Double(trimmed) {
+                return parsed
+            }
+            throw DecodingError.dataCorruptedError(
+                forKey: key,
+                in: self,
+                debugDescription: "Expected a numeric string for \(key.stringValue), got '\(stringValue)'")
+        }
+        throw DecodingError.dataCorruptedError(
+            forKey: key,
+            in: self,
+            debugDescription: "Expected a number or numeric string for \(key.stringValue)")
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/VertexAI/VertexAIOAuth/VertexAIOAuthCredentials.swift b/Sources/CodexBarCore/Providers/VertexAI/VertexAIOAuth/VertexAIOAuthCredentials.swift
index f1400800a9..4356d24fbb 100644
--- a/Sources/CodexBarCore/Providers/VertexAI/VertexAIOAuth/VertexAIOAuthCredentials.swift
+++ b/Sources/CodexBarCore/Providers/VertexAI/VertexAIOAuth/VertexAIOAuthCredentials.swift
@@ -55,10 +55,28 @@ public enum VertexAIOAuthCredentialsError: LocalizedError, Sendable {
 }
 
 public enum VertexAIOAuthCredentialsStore {
-    private static var credentialsFilePath: URL {
+    #if DEBUG
+    @TaskLocal static var gcloudAccessTokenOverrideForTesting: (@Sendable ([String: String]) async throws -> String)?
+    #endif
+
+    private struct ServiceAccountMetadata {
+        let email: String
+        let projectId: String?
+    }
+
+    private static func credentialsFilePath(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> URL
+    {
+        if let path = environment["GOOGLE_APPLICATION_CREDENTIALS"]?.trimmingCharacters(
+            in: .whitespacesAndNewlines),
+            !path.isEmpty
+        {
+            return URL(fileURLWithPath: path)
+        }
+
         let home = FileManager.default.homeDirectoryForCurrentUser
         // gcloud application default credentials location
-        if let configDir = ProcessInfo.processInfo.environment["CLOUDSDK_CONFIG"]?.trimmingCharacters(
+        if let configDir = environment["CLOUDSDK_CONFIG"]?.trimmingCharacters(
             in: .whitespacesAndNewlines),
             !configDir.isEmpty
         {
@@ -71,9 +89,11 @@ public enum VertexAIOAuthCredentialsStore {
             .appendingPathComponent("application_default_credentials.json")
     }
 
-    private static var projectFilePath: URL {
+    private static func projectFilePath(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> URL
+    {
         let home = FileManager.default.homeDirectoryForCurrentUser
-        if let configDir = ProcessInfo.processInfo.environment["CLOUDSDK_CONFIG"]?.trimmingCharacters(
+        if let configDir = environment["CLOUDSDK_CONFIG"]?.trimmingCharacters(
             in: .whitespacesAndNewlines),
             !configDir.isEmpty
         {
@@ -88,28 +108,88 @@ public enum VertexAIOAuthCredentialsStore {
             .appendingPathComponent("config_default")
     }
 
-    public static func load() throws -> VertexAIOAuthCredentials {
-        let url = self.credentialsFilePath
+    public static func hasCredentials(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> Bool
+    {
+        let url = self.credentialsFilePath(environment: environment)
+        guard FileManager.default.fileExists(atPath: url.path),
+              let data = try? Data(contentsOf: url),
+              let json = try? self.parseJSONObject(data: data)
+        else {
+            return false
+        }
+
+        if self.parseServiceAccountMetadata(json: json) != nil {
+            return true
+        }
+
+        return (try? self.parseUserCredentials(json: json, environment: environment)) != nil
+    }
+
+    public static func load(
+        environment: [String: String] = ProcessInfo.processInfo.environment) throws -> VertexAIOAuthCredentials
+    {
+        let url = self.credentialsFilePath(environment: environment)
+        guard FileManager.default.fileExists(atPath: url.path) else {
+            throw VertexAIOAuthCredentialsError.notFound
+        }
+
+        let data = try Data(contentsOf: url)
+        return try self.parse(data: data, environment: environment)
+    }
+
+    public static func loadForFetch(
+        environment: [String: String] = ProcessInfo.processInfo.environment) async throws -> VertexAIOAuthCredentials
+    {
+        let url = self.credentialsFilePath(environment: environment)
         guard FileManager.default.fileExists(atPath: url.path) else {
             throw VertexAIOAuthCredentialsError.notFound
         }
 
         let data = try Data(contentsOf: url)
-        return try self.parse(data: data)
+        let json = try self.parseJSONObject(data: data)
+        if let serviceAccount = self.parseServiceAccountMetadata(json: json) {
+            let token = try await self.printAccessToken(environment: environment)
+            return VertexAIOAuthCredentials(
+                accessToken: token,
+                refreshToken: "",
+                clientId: "",
+                clientSecret: "",
+                projectId: serviceAccount.projectId ?? self.loadProjectId(environment: environment),
+                email: serviceAccount.email,
+                expiryDate: Date().addingTimeInterval(50 * 60))
+        }
+
+        return try self.parseUserCredentials(json: json, environment: environment)
     }
 
     public static func parse(data: Data) throws -> VertexAIOAuthCredentials {
+        try self.parse(data: data, environment: ProcessInfo.processInfo.environment)
+    }
+
+    public static func parse(
+        data: Data,
+        environment: [String: String]) throws -> VertexAIOAuthCredentials
+    {
+        let json = try self.parseJSONObject(data: data)
+        return try self.parseUserCredentials(json: json, environment: environment)
+    }
+
+    private static func parseJSONObject(data: Data) throws -> [String: Any] {
         guard let json = try JSONSerialization.jsonObject(with: data) as? [String: Any] else {
             throw VertexAIOAuthCredentialsError.decodeFailed("Invalid JSON")
         }
+        return json
+    }
 
+    private static func parseUserCredentials(
+        json: [String: Any],
+        environment: [String: String]) throws -> VertexAIOAuthCredentials
+    {
         // Check for service account credentials
-        if json["client_email"] is String,
-           json["private_key"] is String
-        {
-            // Service account - use JWT for access token (simplified)
+        if self.parseServiceAccountMetadata(json: json) != nil {
             throw VertexAIOAuthCredentialsError.decodeFailed(
-                "Service account credentials not yet supported. Use `gcloud auth application-default login`.")
+                "Service account credentials require `gcloud auth application-default print-access-token`.")
         }
 
         // User credentials from gcloud auth application-default login
@@ -127,7 +207,7 @@ public enum VertexAIOAuthCredentialsStore {
         let accessToken = json["access_token"] as? String ?? ""
 
         // Try to get project ID from gcloud config
-        let projectId = Self.loadProjectId()
+        let projectId = Self.loadProjectId(environment: environment)
 
         // Try to extract email from ID token if present
         let email = Self.extractEmailFromIdToken(json["id_token"] as? String)
@@ -154,12 +234,56 @@ public enum VertexAIOAuthCredentialsStore {
         // The refresh happens on each app launch if needed
     }
 
-    private static func loadProjectId() -> String? {
-        let configPath = self.projectFilePath
-        guard let content = try? String(contentsOf: configPath, encoding: .utf8) else {
+    private static func parseServiceAccountMetadata(json: [String: Any]) -> ServiceAccountMetadata? {
+        guard let email = (json["client_email"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines),
+              !email.isEmpty,
+              let privateKey = (json["private_key"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines),
+              !privateKey.isEmpty
+        else {
             return nil
         }
 
+        let projectId = (json["project_id"] as? String)?
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+        return ServiceAccountMetadata(
+            email: email,
+            projectId: projectId?.isEmpty == false ? projectId : nil)
+    }
+
+    private static func printAccessToken(environment: [String: String]) async throws -> String {
+        #if DEBUG
+        if let override = self.gcloudAccessTokenOverrideForTesting {
+            let token = try await override(environment)
+            return try self.cleanAccessToken(token)
+        }
+        #endif
+
+        let env = TTYCommandRunner.enrichedEnvironment(baseEnv: environment)
+        let result = try await SubprocessRunner.run(
+            binary: "/usr/bin/env",
+            arguments: ["gcloud", "auth", "application-default", "print-access-token"],
+            environment: env,
+            timeout: 20,
+            label: "vertexai-gcloud-adc-token")
+        return try self.cleanAccessToken(result.stdout)
+    }
+
+    private static func cleanAccessToken(_ token: String) throws -> String {
+        let trimmed = token.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else {
+            throw VertexAIOAuthCredentialsError.missingTokens
+        }
+        return trimmed
+    }
+
+    private static func loadProjectId(environment: [String: String]) -> String? {
+        let configPath = self.projectFilePath(environment: environment)
+        guard let content = try? String(contentsOf: configPath, encoding: .utf8) else {
+            return environment["GOOGLE_CLOUD_PROJECT"]
+                ?? environment["GCLOUD_PROJECT"]
+                ?? environment["CLOUDSDK_CORE_PROJECT"]
+        }
+
         // Parse INI-style config for project
         for line in content.components(separatedBy: .newlines) {
             let trimmed = line.trimmingCharacters(in: .whitespaces)
@@ -172,9 +296,9 @@ public enum VertexAIOAuthCredentialsStore {
         }
 
         // Try environment variable
-        return ProcessInfo.processInfo.environment["GOOGLE_CLOUD_PROJECT"]
-            ?? ProcessInfo.processInfo.environment["GCLOUD_PROJECT"]
-            ?? ProcessInfo.processInfo.environment["CLOUDSDK_CORE_PROJECT"]
+        return environment["GOOGLE_CLOUD_PROJECT"]
+            ?? environment["GCLOUD_PROJECT"]
+            ?? environment["CLOUDSDK_CORE_PROJECT"]
     }
 
     private static func extractEmailFromIdToken(_ token: String?) -> String? {
diff --git a/Sources/CodexBarCore/Providers/VertexAI/VertexAIOAuth/VertexAITokenRefresher.swift b/Sources/CodexBarCore/Providers/VertexAI/VertexAIOAuth/VertexAITokenRefresher.swift
index b5e8e3f682..206fc3060a 100644
--- a/Sources/CodexBarCore/Providers/VertexAI/VertexAIOAuth/VertexAITokenRefresher.swift
+++ b/Sources/CodexBarCore/Providers/VertexAI/VertexAIOAuth/VertexAITokenRefresher.swift
@@ -49,12 +49,10 @@ public enum VertexAITokenRefresher {
         request.httpBody = bodyString.data(using: .utf8)
 
         do {
-            let (data, response) = try await URLSession.shared.data(for: request)
-            guard let http = response as? HTTPURLResponse else {
-                throw RefreshError.invalidResponse("No HTTP response")
-            }
+            let response = try await ProviderHTTPClient.shared.response(for: request)
+            let data = response.data
 
-            if http.statusCode == 400 || http.statusCode == 401 {
+            if response.statusCode == 400 || response.statusCode == 401 {
                 if let errorCode = Self.extractErrorCode(from: data) {
                     switch errorCode.lowercased() {
                     case "invalid_grant":
@@ -68,8 +66,8 @@ public enum VertexAITokenRefresher {
                 throw RefreshError.expired
             }
 
-            guard http.statusCode == 200 else {
-                throw RefreshError.invalidResponse("Status \(http.statusCode)")
+            guard response.statusCode == 200 else {
+                throw RefreshError.invalidResponse("Status \(response.statusCode)")
             }
 
             guard let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
diff --git a/Sources/CodexBarCore/Providers/VertexAI/VertexAIOAuth/VertexAIUsageFetcher.swift b/Sources/CodexBarCore/Providers/VertexAI/VertexAIOAuth/VertexAIUsageFetcher.swift
index 2c9da20338..e3ad58b3ab 100644
--- a/Sources/CodexBarCore/Providers/VertexAI/VertexAIOAuth/VertexAIUsageFetcher.swift
+++ b/Sources/CodexBarCore/Providers/VertexAI/VertexAIOAuth/VertexAIUsageFetcher.swift
@@ -215,20 +215,15 @@ public enum VertexAIUsageFetcher {
             request.setValue("Bearer \(accessToken)", forHTTPHeaderField: "Authorization")
             request.timeoutInterval = 30
 
-            let data: Data
-            let response: URLResponse
+            let response: ProviderHTTPResponse
 
             do {
-                (data, response) = try await URLSession.shared.data(for: request)
+                response = try await ProviderHTTPClient.shared.response(for: request)
             } catch {
                 throw VertexAIFetchError.networkError(error)
             }
 
-            guard let http = response as? HTTPURLResponse else {
-                throw VertexAIFetchError.invalidResponse("No HTTP response")
-            }
-
-            switch http.statusCode {
+            switch response.statusCode {
             case 401:
                 throw VertexAIFetchError.unauthorized
             case 403:
@@ -236,11 +231,11 @@ public enum VertexAIUsageFetcher {
             case 200:
                 break
             default:
-                let body = String(data: data, encoding: .utf8) ?? ""
-                throw VertexAIFetchError.invalidResponse("HTTP \(http.statusCode): \(body)")
+                let body = String(data: response.data, encoding: .utf8) ?? ""
+                throw VertexAIFetchError.invalidResponse("HTTP \(response.statusCode): \(body)")
             }
 
-            let decoded = try JSONDecoder().decode(MonitoringTimeSeriesResponse.self, from: data)
+            let decoded = try JSONDecoder().decode(MonitoringTimeSeriesResponse.self, from: response.data)
             if let series = decoded.timeSeries {
                 allSeries.append(contentsOf: series)
             }
diff --git a/Sources/CodexBarCore/Providers/VertexAI/VertexAIProviderDescriptor.swift b/Sources/CodexBarCore/Providers/VertexAI/VertexAIProviderDescriptor.swift
index f81e0d1f2b..f076951afd 100644
--- a/Sources/CodexBarCore/Providers/VertexAI/VertexAIProviderDescriptor.swift
+++ b/Sources/CodexBarCore/Providers/VertexAI/VertexAIProviderDescriptor.swift
@@ -1,9 +1,8 @@
-import CodexBarMacroSupport
 import Foundation
 
-@ProviderDescriptorRegistration
-@ProviderDescriptorDefinition
 public enum VertexAIProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
     static func makeDescriptor() -> ProviderDescriptor {
         ProviderDescriptor(
             id: .vertexai,
@@ -45,12 +44,12 @@ struct VertexAIOAuthFetchStrategy: ProviderFetchStrategy {
     let id: String = "vertexai.oauth"
     let kind: ProviderFetchKind = .oauth
 
-    func isAvailable(_: ProviderFetchContext) async -> Bool {
-        (try? VertexAIOAuthCredentialsStore.load()) != nil
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        VertexAIOAuthCredentialsStore.hasCredentials(environment: context.env)
     }
 
-    func fetch(_: ProviderFetchContext) async throws -> ProviderFetchResult {
-        var credentials = try VertexAIOAuthCredentialsStore.load()
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        var credentials = try await VertexAIOAuthCredentialsStore.loadForFetch(environment: context.env)
 
         // Refresh token if expired
         if credentials.needsRefresh {
diff --git a/Sources/CodexBarCore/Providers/Warp/WarpProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Warp/WarpProviderDescriptor.swift
index 29506321ca..d089134224 100644
--- a/Sources/CodexBarCore/Providers/Warp/WarpProviderDescriptor.swift
+++ b/Sources/CodexBarCore/Providers/Warp/WarpProviderDescriptor.swift
@@ -1,9 +1,8 @@
-import CodexBarMacroSupport
 import Foundation
 
-@ProviderDescriptorRegistration
-@ProviderDescriptorDefinition
 public enum WarpProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
     static func makeDescriptor() -> ProviderDescriptor {
         ProviderDescriptor(
             id: .warp,
@@ -31,39 +30,16 @@ public enum WarpProviderDescriptor {
             tokenCost: ProviderTokenCostConfig(
                 supportsTokenCost: false,
                 noDataMessage: { "Warp cost summary is not available." }),
-            fetchPlan: ProviderFetchPlan(
-                sourceModes: [.auto, .api],
-                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [WarpAPIFetchStrategy()] })),
+            fetchPlan: .apiToken(
+                strategyID: "warp.api",
+                resolveToken: { ProviderTokenResolver.warpToken(environment: $0) },
+                missingCredentialsError: { WarpUsageError.missingCredentials },
+                loadUsage: { apiKey, _ in
+                    try await WarpUsageFetcher.fetchUsage(apiKey: apiKey).toUsageSnapshot()
+                }),
             cli: ProviderCLIConfig(
                 name: "warp",
                 aliases: ["warp-ai", "warp-terminal"],
                 versionDetector: nil))
     }
 }
-
-struct WarpAPIFetchStrategy: ProviderFetchStrategy {
-    let id: String = "warp.api"
-    let kind: ProviderFetchKind = .apiToken
-
-    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
-        Self.resolveToken(environment: context.env) != nil
-    }
-
-    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
-        guard let apiKey = Self.resolveToken(environment: context.env) else {
-            throw WarpUsageError.missingCredentials
-        }
-        let usage = try await WarpUsageFetcher.fetchUsage(apiKey: apiKey)
-        return self.makeResult(
-            usage: usage.toUsageSnapshot(),
-            sourceLabel: "api")
-    }
-
-    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
-        false
-    }
-
-    private static func resolveToken(environment: [String: String]) -> String? {
-        ProviderTokenResolver.warpToken(environment: environment)
-    }
-}
diff --git a/Sources/CodexBarCore/Providers/Warp/WarpSettingsReader.swift b/Sources/CodexBarCore/Providers/Warp/WarpSettingsReader.swift
index cd3c639c1b..afe5df0c37 100644
--- a/Sources/CodexBarCore/Providers/Warp/WarpSettingsReader.swift
+++ b/Sources/CodexBarCore/Providers/Warp/WarpSettingsReader.swift
@@ -28,8 +28,7 @@ public struct WarpSettingsReader: Sendable {
         if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
             (value.hasPrefix("'") && value.hasSuffix("'"))
         {
-            value.removeFirst()
-            value.removeLast()
+            value = String(value.dropFirst().dropLast())
         }
         return value.trimmingCharacters(in: .whitespacesAndNewlines)
     }
diff --git a/Sources/CodexBarCore/Providers/Warp/WarpUsageFetcher.swift b/Sources/CodexBarCore/Providers/Warp/WarpUsageFetcher.swift
index 79ec2e8f0b..0114d81c4a 100644
--- a/Sources/CodexBarCore/Providers/Warp/WarpUsageFetcher.swift
+++ b/Sources/CodexBarCore/Providers/Warp/WarpUsageFetcher.swift
@@ -206,16 +206,12 @@ public struct WarpUsageFetcher: Sendable {
 
         request.httpBody = try JSONSerialization.data(withJSONObject: body)
 
-        let (data, response) = try await URLSession.shared.data(for: request)
-
-        guard let httpResponse = response as? HTTPURLResponse else {
-            throw WarpUsageError.networkError("Invalid response")
-        }
-
-        guard httpResponse.statusCode == 200 else {
-            let summary = Self.apiErrorSummary(statusCode: httpResponse.statusCode, data: data)
-            Self.log.error("Warp API returned \(httpResponse.statusCode): \(summary)")
-            throw WarpUsageError.apiError(httpResponse.statusCode, summary)
+        let response = try await ProviderHTTPClient.shared.response(for: request)
+        let data = response.data
+        guard response.statusCode == 200 else {
+            let summary = Self.apiErrorSummary(statusCode: response.statusCode, data: data)
+            Self.log.error("Warp API returned \(response.statusCode): \(summary)")
+            throw WarpUsageError.apiError(response.statusCode, summary)
         }
 
         do {
@@ -293,13 +289,13 @@ public struct WarpUsageFetcher: Sendable {
             bonusNextExpirationRemaining: bonus.nextExpirationRemaining)
     }
 
-    private struct BonusGrant: Sendable {
+    private struct BonusGrant {
         let granted: Int
         let remaining: Int
         let expiration: Date?
     }
 
-    private struct BonusSummary: Sendable {
+    private struct BonusSummary {
         let remaining: Int
         let total: Int
         let nextExpiration: Date?
diff --git a/Sources/CodexBarCore/Providers/Windsurf/WindsurfDevinSessionImporter.swift b/Sources/CodexBarCore/Providers/Windsurf/WindsurfDevinSessionImporter.swift
new file mode 100644
index 0000000000..2d6955aabb
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Windsurf/WindsurfDevinSessionImporter.swift
@@ -0,0 +1,308 @@
+import Foundation
+#if os(macOS)
+import SweetCookieKit
+#endif
+
+#if os(macOS)
+enum WindsurfDevinSessionImporter {
+    nonisolated(unsafe) static var importSessionsOverrideForTesting:
+        ((BrowserDetection, ((String) -> Void)?) -> [SessionInfo])?
+    nonisolated(unsafe) static var importPreferredSessionsOverrideForTesting:
+        ((BrowserDetection, ((String) -> Void)?) -> [SessionInfo])?
+    nonisolated(unsafe) static var importFallbackSessionsOverrideForTesting:
+        ((BrowserDetection, ((String) -> Void)?) -> [SessionInfo])?
+    static let defaultPreferredBrowsers: [Browser] = [.chrome]
+    static let fallbackBrowsers: [Browser] = [
+        .chromeBeta,
+        .chromeCanary,
+        .edge,
+        .edgeBeta,
+        .edgeCanary,
+        .brave,
+        .braveBeta,
+        .braveNightly,
+        .vivaldi,
+        .arc,
+        .arcBeta,
+        .arcCanary,
+        .dia,
+        .chatgptAtlas,
+        .chromium,
+        .helium,
+    ]
+
+    struct SessionInfo: Equatable {
+        let session: WindsurfDevinSessionAuth
+        let sourceLabel: String
+    }
+
+    static func importSessions(
+        browserDetection: BrowserDetection,
+        logger: ((String) -> Void)? = nil) -> [SessionInfo]
+    {
+        if let override = self.importSessionsOverrideForTesting {
+            return override(browserDetection, logger)
+        }
+
+        let log: (String) -> Void = { msg in logger?("[windsurf-storage] \(msg)") }
+        let preferredSessions = self.importSessions(
+            browserDetection: browserDetection,
+            browsers: self.defaultPreferredBrowsers,
+            logger: log)
+        if !preferredSessions.isEmpty {
+            return preferredSessions
+        }
+
+        log("No Windsurf devin session found in Chrome; trying fallback Chromium browsers")
+        let sessions = self.importSessions(
+            browserDetection: browserDetection,
+            browsers: self.fallbackBrowsersExcluding(self.defaultPreferredBrowsers),
+            logger: log)
+
+        if sessions.isEmpty {
+            log("No Windsurf devin session found in browser local storage")
+        }
+
+        return sessions
+    }
+
+    static func importPreferredSessions(
+        browserDetection: BrowserDetection,
+        logger: ((String) -> Void)? = nil) -> [SessionInfo]
+    {
+        if let override = self.importPreferredSessionsOverrideForTesting {
+            return override(browserDetection, logger)
+        }
+        let log: (String) -> Void = { msg in logger?("[windsurf-storage] \(msg)") }
+        return self.importSessions(
+            browserDetection: browserDetection,
+            browsers: self.defaultPreferredBrowsers,
+            logger: log)
+    }
+
+    static func importFallbackSessions(
+        browserDetection: BrowserDetection,
+        logger: ((String) -> Void)? = nil) -> [SessionInfo]
+    {
+        if let override = self.importFallbackSessionsOverrideForTesting {
+            return override(browserDetection, logger)
+        }
+        let log: (String) -> Void = { msg in logger?("[windsurf-storage] \(msg)") }
+        return self.importSessions(
+            browserDetection: browserDetection,
+            browsers: self.fallbackBrowsersExcluding(self.defaultPreferredBrowsers),
+            logger: log)
+    }
+
+    static func fallbackBrowsersExcluding(_ preferredBrowsers: [Browser]) -> [Browser] {
+        let preferred = Set(preferredBrowsers)
+        return self.fallbackBrowsers.filter { !preferred.contains($0) }
+    }
+
+    static func deduplicateSessions(_ sessions: [SessionInfo]) -> [SessionInfo] {
+        var deduplicated: [SessionInfo] = []
+        var seenSessionTokens = Set<String>()
+
+        for session in sessions {
+            guard seenSessionTokens.insert(session.session.sessionToken).inserted else { continue }
+            deduplicated.append(session)
+        }
+
+        return deduplicated
+    }
+
+    static func session(from storage: [String: String], sourceLabel: String) -> SessionInfo? {
+        guard let sessionToken = storage["devin_session_token"],
+              let auth1Token = storage["devin_auth1_token"],
+              let accountID = storage["devin_account_id"],
+              let primaryOrgID = storage["devin_primary_org_id"]
+        else {
+            return nil
+        }
+
+        return SessionInfo(
+            session: WindsurfDevinSessionAuth(
+                sessionToken: sessionToken,
+                auth1Token: auth1Token,
+                accountID: accountID,
+                primaryOrgID: primaryOrgID),
+            sourceLabel: sourceLabel)
+    }
+
+    static func decodedStorageValue(_ value: String) -> String {
+        let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else { return trimmed }
+
+        if let data = trimmed.data(using: .utf8),
+           let decoded = try? JSONDecoder().decode(String.self, from: data)
+        {
+            return decoded.trimmingCharacters(in: .whitespacesAndNewlines)
+        }
+
+        return trimmed.trimmingCharacters(in: CharacterSet(charactersIn: "\""))
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+
+    struct LocalStorageCandidate {
+        let label: String
+        let url: URL
+    }
+
+    struct LocalStorageSnapshot: Equatable {
+        let storage: [String: String]
+        let sourceSuffix: String?
+    }
+
+    typealias LocalStorageOriginEntries = (
+        origin: URL,
+        entries: [SweetCookieKit.ChromiumLocalStorageEntry])
+
+    static let localStorageOrigins = [
+        URL(string: "https://app.devin.ai")!,
+        URL(string: "https://windsurf.com")!,
+    ]
+
+    private static func importSessions(
+        browserDetection: BrowserDetection,
+        browsers: [Browser],
+        logger: @escaping (String) -> Void) -> [SessionInfo]
+    {
+        var sessions: [SessionInfo] = []
+        let candidates = self.chromeLocalStorageCandidates(
+            browserDetection: browserDetection,
+            browsers: browsers)
+        if !candidates.isEmpty {
+            logger("Chrome local storage candidates: \(candidates.count)")
+        }
+
+        for candidate in candidates {
+            let snapshots = self.readLocalStorageSnapshots(from: candidate.url, logger: logger)
+            for snapshot in snapshots {
+                let sourceLabel = self.sourceLabel(candidate.label, suffix: snapshot.sourceSuffix)
+                guard let session = self.session(from: snapshot.storage, sourceLabel: sourceLabel) else { continue }
+                logger("Found Windsurf devin session in \(sourceLabel)")
+                sessions.append(session)
+            }
+        }
+
+        return self.deduplicateSessions(sessions)
+    }
+
+    static func chromeLocalStorageCandidates(
+        browserDetection: BrowserDetection,
+        browsers: [Browser]) -> [LocalStorageCandidate]
+    {
+        let installedBrowsers = browsers.browsersWithProfileData(using: browserDetection)
+        let roots = ChromiumProfileLocator
+            .roots(for: installedBrowsers, homeDirectories: BrowserCookieClient.defaultHomeDirectories())
+            .map { (url: $0.url, labelPrefix: $0.labelPrefix) }
+
+        var candidates: [LocalStorageCandidate] = []
+        for root in roots {
+            candidates.append(contentsOf: self.chromeProfileLocalStorageDirs(
+                root: root.url,
+                labelPrefix: root.labelPrefix))
+        }
+        return candidates
+    }
+
+    private static func chromeProfileLocalStorageDirs(root: URL, labelPrefix: String) -> [LocalStorageCandidate] {
+        guard let entries = try? FileManager.default.contentsOfDirectory(
+            at: root,
+            includingPropertiesForKeys: [.isDirectoryKey],
+            options: [.skipsHiddenFiles])
+        else { return [] }
+
+        let profileDirs = entries.filter { url in
+            guard let isDir = (try? url.resourceValues(forKeys: [.isDirectoryKey]).isDirectory), isDir else {
+                return false
+            }
+            let name = url.lastPathComponent
+            return name == "Default" || name.hasPrefix("Profile ") || name.hasPrefix("user-")
+        }
+        .sorted { $0.lastPathComponent < $1.lastPathComponent }
+
+        return profileDirs.compactMap { dir in
+            let levelDBURL = dir.appendingPathComponent("Local Storage").appendingPathComponent("leveldb")
+            guard FileManager.default.fileExists(atPath: levelDBURL.path) else { return nil }
+            let label = "\(labelPrefix) \(dir.lastPathComponent)"
+            return LocalStorageCandidate(label: label, url: levelDBURL)
+        }
+    }
+
+    private static func readLocalStorageSnapshots(
+        from levelDBURL: URL,
+        logger: ((String) -> Void)? = nil) -> [LocalStorageSnapshot]
+    {
+        let originEntries = Self.localStorageOrigins.map { origin in
+            let entries = SweetCookieKit.ChromiumLocalStorageReader.readEntries(
+                for: origin.absoluteString,
+                in: levelDBURL,
+                logger: logger)
+            return (origin: origin, entries: entries)
+        }
+
+        let textEntries = SweetCookieKit.ChromiumLocalStorageReader.readTextEntries(
+            in: levelDBURL,
+            logger: logger)
+        return self.localStorageSnapshots(from: originEntries, textEntries: textEntries)
+    }
+
+    static func localStorageSnapshots(
+        from originEntries: [LocalStorageOriginEntries],
+        textEntries: [SweetCookieKit.ChromiumLevelDBTextEntry]) -> [LocalStorageSnapshot]
+    {
+        var snapshots = self.localStorageSnapshots(from: originEntries)
+        let textStorage = self.storage(from: textEntries)
+        if textStorage.count == Self.targetKeys.count {
+            snapshots.append(LocalStorageSnapshot(storage: textStorage, sourceSuffix: nil))
+        }
+
+        return snapshots
+    }
+
+    static func localStorageSnapshots(from originEntries: [LocalStorageOriginEntries]) -> [LocalStorageSnapshot] {
+        originEntries.compactMap { originEntry in
+            let storage = self.storage(from: originEntry.entries)
+            guard storage.count == Self.targetKeys.count else { return nil }
+            return LocalStorageSnapshot(
+                storage: storage,
+                sourceSuffix: originEntry.origin.host ?? originEntry.origin.absoluteString)
+        }
+    }
+
+    private static func storage(
+        from entries: [SweetCookieKit.ChromiumLocalStorageEntry]) -> [String: String]
+    {
+        var storage: [String: String] = [:]
+        for entry in entries where storage[entry.key] == nil && Self.targetKeys.contains(entry.key) {
+            storage[entry.key] = self.decodedStorageValue(entry.value)
+        }
+        return storage
+    }
+
+    private static func storage(
+        from entries: [SweetCookieKit.ChromiumLevelDBTextEntry]) -> [String: String]
+    {
+        var storage: [String: String] = [:]
+        for entry in entries {
+            guard storage[entry.key] == nil, Self.targetKeys.contains(entry.key) else { continue }
+            storage[entry.key] = self.decodedStorageValue(entry.value)
+        }
+
+        return storage
+    }
+
+    private static func sourceLabel(_ label: String, suffix: String?) -> String {
+        guard let suffix else { return label }
+        return "\(label) (\(suffix))"
+    }
+
+    private static let targetKeys: Set<String> = [
+        "devin_session_token",
+        "devin_auth1_token",
+        "devin_account_id",
+        "devin_primary_org_id",
+    ]
+}
+#endif
diff --git a/Sources/CodexBarCore/Providers/Windsurf/WindsurfProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Windsurf/WindsurfProviderDescriptor.swift
new file mode 100644
index 0000000000..facf988ca1
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Windsurf/WindsurfProviderDescriptor.swift
@@ -0,0 +1,100 @@
+import Foundation
+
+public enum WindsurfProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .windsurf,
+            metadata: ProviderMetadata(
+                id: .windsurf,
+                displayName: "Windsurf",
+                sessionLabel: "Daily",
+                weeklyLabel: "Weekly",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "",
+                toggleTitle: "Show Windsurf usage",
+                cliName: "windsurf",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                dashboardURL: "https://windsurf.com/subscription/usage",
+                statusPageURL: nil),
+            branding: ProviderBranding(
+                iconStyle: .windsurf,
+                iconResourceName: "ProviderIcon-windsurf",
+                color: ProviderColor(red: 52 / 255, green: 232 / 255, blue: 187 / 255)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "Windsurf cost summary is not supported." }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .web, .cli],
+                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in
+                    [WindsurfWebFetchStrategy(), WindsurfLocalFetchStrategy()]
+                })),
+            cli: ProviderCLIConfig(
+                name: "windsurf",
+                versionDetector: nil))
+    }
+}
+
+struct WindsurfWebFetchStrategy: ProviderFetchStrategy {
+    let id: String = "windsurf.web"
+    let kind: ProviderFetchKind = .web
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        guard context.sourceMode.usesWeb else { return false }
+        guard context.settings?.windsurf?.cookieSource != .off else { return false }
+        return true
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        #if os(macOS)
+        let cookieSource = context.settings?.windsurf?.cookieSource ?? .auto
+        let manualToken = Self.manualToken(from: context)
+        let usage = try await WindsurfWebFetcher.fetchUsage(
+            browserDetection: context.browserDetection,
+            cookieSource: cookieSource,
+            manualSessionInput: manualToken,
+            timeout: context.webTimeout,
+            logger: context.verbose ? { print($0) } : nil)
+        return self.makeResult(usage: usage, sourceLabel: "windsurf-web")
+        #else
+        throw WindsurfStatusProbeError.notSupported
+        #endif
+    }
+
+    func shouldFallback(on _: Error, context: ProviderFetchContext) -> Bool {
+        context.sourceMode == .auto
+    }
+
+    private static func manualToken(from context: ProviderFetchContext) -> String? {
+        guard context.settings?.windsurf?.cookieSource == .manual else { return nil }
+        let header = context.settings?.windsurf?.manualCookieHeader ?? ""
+        return header.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty ? nil : header
+    }
+}
+
+struct WindsurfLocalFetchStrategy: ProviderFetchStrategy {
+    let id: String = "windsurf.local"
+    let kind: ProviderFetchKind = .localProbe
+
+    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
+        context.sourceMode != .web
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        let probe = WindsurfStatusProbe()
+        let planInfo = try probe.fetch()
+        let usage = planInfo.toUsageSnapshot()
+        return self.makeResult(
+            usage: usage,
+            sourceLabel: "local")
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Windsurf/WindsurfStatusProbe.swift b/Sources/CodexBarCore/Providers/Windsurf/WindsurfStatusProbe.swift
new file mode 100644
index 0000000000..73f863ec8e
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Windsurf/WindsurfStatusProbe.swift
@@ -0,0 +1,281 @@
+import Foundation
+
+// MARK: - Cached Plan Info (Codable)
+
+public struct WindsurfCachedPlanInfo: Codable, Sendable {
+    public let planName: String?
+    public let startTimestamp: Int64?
+    public let endTimestamp: Int64?
+    public let usage: Usage?
+    public let quotaUsage: QuotaUsage?
+
+    public struct Usage: Codable, Sendable {
+        public let messages: Int?
+        public let usedMessages: Int?
+        public let remainingMessages: Int?
+        public let flowActions: Int?
+        public let usedFlowActions: Int?
+        public let remainingFlowActions: Int?
+        public let flexCredits: Int?
+        public let usedFlexCredits: Int?
+        public let remainingFlexCredits: Int?
+    }
+
+    public struct QuotaUsage: Codable, Sendable {
+        public let dailyRemainingPercent: Double?
+        public let weeklyRemainingPercent: Double?
+        public let dailyResetAtUnix: Int64?
+        public let weeklyResetAtUnix: Int64?
+    }
+}
+
+// MARK: - Errors & Probe
+
+#if os(macOS)
+
+import SQLite3
+
+public enum WindsurfStatusProbeError: LocalizedError, Sendable, Equatable {
+    case dbNotFound(String)
+    case sqliteFailed(String)
+    case noData
+    case parseFailed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case let .dbNotFound(path):
+            "Windsurf database not found at \(path). Ensure Windsurf is installed and has been launched at least once."
+        case let .sqliteFailed(message):
+            "SQLite error reading Windsurf data: \(message)"
+        case .noData:
+            "No plan data found in Windsurf database. Sign in to Windsurf first."
+        case let .parseFailed(message):
+            "Could not parse Windsurf plan data: \(message)"
+        }
+    }
+}
+
+// MARK: - Probe
+
+public struct WindsurfStatusProbe: Sendable {
+    private static let defaultDBPath: String = {
+        let home = NSHomeDirectory()
+        return "\(home)/Library/Application Support/Windsurf/User/globalStorage/state.vscdb"
+    }()
+
+    private static let query = "SELECT value FROM ItemTable WHERE key = 'windsurf.settings.cachedPlanInfo' LIMIT 1;"
+
+    private let dbPath: String
+
+    public init(dbPath: String? = nil) {
+        self.dbPath = dbPath ?? Self.defaultDBPath
+    }
+
+    public func fetch() throws -> WindsurfCachedPlanInfo {
+        guard FileManager.default.fileExists(atPath: self.dbPath) else {
+            throw WindsurfStatusProbeError.dbNotFound(self.dbPath)
+        }
+
+        var db: OpaquePointer?
+        guard sqlite3_open_v2(self.dbPath, &db, SQLITE_OPEN_READONLY, nil) == SQLITE_OK else {
+            let message = db.flatMap { String(cString: sqlite3_errmsg($0)) } ?? "unknown error"
+            sqlite3_close(db)
+            throw WindsurfStatusProbeError.sqliteFailed(message)
+        }
+        defer { sqlite3_close(db) }
+
+        sqlite3_busy_timeout(db, 250)
+
+        var stmt: OpaquePointer?
+        guard sqlite3_prepare_v2(db, Self.query, -1, &stmt, nil) == SQLITE_OK else {
+            let message = db.flatMap { String(cString: sqlite3_errmsg($0)) } ?? "unknown error"
+            throw WindsurfStatusProbeError.sqliteFailed(message)
+        }
+        defer { sqlite3_finalize(stmt) }
+
+        let stepResult = sqlite3_step(stmt)
+        guard stepResult == SQLITE_ROW else {
+            if stepResult == SQLITE_DONE {
+                throw WindsurfStatusProbeError.noData
+            }
+            let message = db.flatMap { String(cString: sqlite3_errmsg($0)) } ?? "unknown error"
+            throw WindsurfStatusProbeError.sqliteFailed(message)
+        }
+
+        guard let jsonString = Self.decodeSQLiteValue(stmt: stmt, index: 0) else {
+            throw WindsurfStatusProbeError.noData
+        }
+        guard let jsonData = jsonString.data(using: .utf8) else {
+            throw WindsurfStatusProbeError.parseFailed("Invalid UTF-8 encoding")
+        }
+
+        do {
+            return try JSONDecoder().decode(WindsurfCachedPlanInfo.self, from: jsonData)
+        } catch {
+            throw WindsurfStatusProbeError.parseFailed(error.localizedDescription)
+        }
+    }
+
+    private static func decodeSQLiteValue(stmt: OpaquePointer?, index: Int32) -> String? {
+        switch sqlite3_column_type(stmt, index) {
+        case SQLITE_TEXT:
+            guard let c = sqlite3_column_text(stmt, index) else { return nil }
+            return String(cString: c)
+        case SQLITE_BLOB:
+            guard let bytes = sqlite3_column_blob(stmt, index) else { return nil }
+            let data = Data(bytes: bytes, count: Int(sqlite3_column_bytes(stmt, index)))
+            // VSCode/Windsurf state.vscdb schema declares value as BLOB;
+            // only accept decodes that still parse as JSON to avoid UTF-16 mojibake.
+            return self.decodeJSONBlob(data)
+        default:
+            return nil
+        }
+    }
+
+    private static func decodeJSONBlob(_ data: Data) -> String? {
+        for encoding in [String.Encoding.utf8, .utf16LittleEndian] {
+            guard let decoded = String(data: data, encoding: encoding) else { continue }
+            let trimmed = decoded.trimmingCharacters(in: .controlCharacters)
+            guard let jsonData = trimmed.data(using: .utf8),
+                  (try? JSONSerialization.jsonObject(with: jsonData)) != nil
+            else {
+                continue
+            }
+            return trimmed
+        }
+        return nil
+    }
+}
+
+#else
+
+// MARK: - Windsurf (Unsupported)
+
+public enum WindsurfStatusProbeError: LocalizedError, Sendable, Equatable {
+    case notSupported
+
+    public var errorDescription: String? {
+        "Windsurf is only supported on macOS."
+    }
+}
+
+public struct WindsurfStatusProbe: Sendable {
+    public init(dbPath _: String? = nil) {}
+
+    public func fetch() throws -> WindsurfCachedPlanInfo {
+        throw WindsurfStatusProbeError.notSupported
+    }
+}
+
+#endif
+
+// MARK: - Conversion to UsageSnapshot
+
+extension WindsurfCachedPlanInfo {
+    public func toUsageSnapshot() -> UsageSnapshot {
+        var primary: RateWindow?
+        var secondary: RateWindow?
+
+        if let quota = self.quotaUsage {
+            // Primary: daily usage (usedPercent = 100 - dailyRemainingPercent)
+            if let daily = quota.dailyRemainingPercent {
+                let resetDate = quota.dailyResetAtUnix.map {
+                    Date(timeIntervalSince1970: TimeInterval($0))
+                }
+                primary = RateWindow(
+                    usedPercent: max(0, min(100, 100 - daily)),
+                    windowMinutes: nil,
+                    resetsAt: resetDate,
+                    resetDescription: Self.formatResetDescription(resetDate))
+            }
+
+            // Secondary: weekly usage
+            if let weekly = quota.weeklyRemainingPercent {
+                let resetDate = quota.weeklyResetAtUnix.map {
+                    Date(timeIntervalSince1970: TimeInterval($0))
+                }
+                secondary = RateWindow(
+                    usedPercent: max(0, min(100, 100 - weekly)),
+                    windowMinutes: nil,
+                    resetsAt: resetDate,
+                    resetDescription: Self.formatResetDescription(resetDate))
+            }
+        }
+
+        if primary == nil, let usage = self.usage {
+            primary = Self.makeUsageWindow(
+                used: usage.usedMessages,
+                remaining: usage.remainingMessages,
+                total: usage.messages,
+                unit: "messages")
+        }
+
+        if secondary == nil, let usage = self.usage {
+            secondary = Self.makeUsageWindow(
+                used: usage.usedFlowActions,
+                remaining: usage.remainingFlowActions,
+                total: usage.flowActions,
+                unit: "flow actions")
+        }
+
+        // Identity
+        var orgDescription: String?
+        if let endTimestamp = self.endTimestamp {
+            let endDate = Date(timeIntervalSince1970: TimeInterval(endTimestamp) / 1000)
+            let formatter = DateFormatter()
+            formatter.dateStyle = .medium
+            formatter.timeStyle = .none
+            orgDescription = "Expires \(formatter.string(from: endDate))"
+        }
+
+        let identity = ProviderIdentitySnapshot(
+            providerID: .windsurf,
+            accountEmail: nil,
+            accountOrganization: orgDescription,
+            loginMethod: self.planName)
+
+        return UsageSnapshot(
+            primary: primary,
+            secondary: secondary,
+            updatedAt: Date(),
+            identity: identity)
+    }
+
+    private static func makeUsageWindow(
+        used rawUsed: Int?,
+        remaining rawRemaining: Int?,
+        total rawTotal: Int?,
+        unit: String) -> RateWindow?
+    {
+        guard let total = rawTotal, total > 0 else { return nil }
+        let inferredUsed = rawUsed ?? rawRemaining.map { max(0, total - $0) }
+        guard let used = inferredUsed else { return nil }
+        let clampedUsed = max(0, min(total, used))
+        let usedPercent = max(0, min(100, Double(clampedUsed) / Double(total) * 100))
+        return RateWindow(
+            usedPercent: usedPercent,
+            windowMinutes: nil,
+            resetsAt: nil,
+            resetDescription: "\(clampedUsed) / \(total) \(unit)")
+    }
+
+    private static func formatResetDescription(_ date: Date?) -> String? {
+        guard let date else { return nil }
+        let now = Date()
+        let interval = date.timeIntervalSince(now)
+        guard interval > 0 else { return "Expired" }
+
+        let hours = Int(interval / 3600)
+        let minutes = Int((interval.truncatingRemainder(dividingBy: 3600)) / 60)
+
+        if hours > 24 {
+            let days = hours / 24
+            let remainingHours = hours % 24
+            return "Resets in \(days)d \(remainingHours)h"
+        } else if hours > 0 {
+            return "Resets in \(hours)h \(minutes)m"
+        } else {
+            return "Resets in \(minutes)m"
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Windsurf/WindsurfUsageDataSource.swift b/Sources/CodexBarCore/Providers/Windsurf/WindsurfUsageDataSource.swift
new file mode 100644
index 0000000000..1330be5988
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Windsurf/WindsurfUsageDataSource.swift
@@ -0,0 +1,27 @@
+import Foundation
+
+public enum WindsurfUsageDataSource: String, CaseIterable, Identifiable, Sendable {
+    case auto
+    case web
+    case cli
+
+    public var id: String {
+        self.rawValue
+    }
+
+    public var displayName: String {
+        switch self {
+        case .auto: "Auto"
+        case .web: "Web API (IndexedDB)"
+        case .cli: "Local (SQLite cache)"
+        }
+    }
+
+    public var sourceLabel: String {
+        switch self {
+        case .auto: "auto"
+        case .web: "web"
+        case .cli: "cli"
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Windsurf/WindsurfWebFetcher.swift b/Sources/CodexBarCore/Providers/Windsurf/WindsurfWebFetcher.swift
new file mode 100644
index 0000000000..27bc8579f0
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Windsurf/WindsurfWebFetcher.swift
@@ -0,0 +1,679 @@
+import Foundation
+
+// MARK: - API Response Model
+
+public struct WindsurfGetPlanStatusResponse: Sendable, Equatable {
+    public let planStatus: PlanStatus?
+
+    public struct PlanStatus: Sendable, Equatable {
+        public let planInfo: PlanInfo?
+        public let planStart: Date?
+        public let planEnd: Date?
+        public let dailyQuotaRemainingPercent: Int?
+        public let weeklyQuotaRemainingPercent: Int?
+        public let dailyQuotaResetAtUnix: Int64?
+        public let weeklyQuotaResetAtUnix: Int64?
+        public let topUpStatus: TopUpStatus?
+        public let gracePeriodStatus: Int?
+
+        public struct PlanInfo: Sendable, Equatable {
+            public let planName: String?
+            public let teamsTier: Int?
+        }
+
+        public struct TopUpStatus: Sendable, Equatable {
+            public let topUpTransactionStatus: Int?
+        }
+    }
+}
+
+// MARK: - Conversion to UsageSnapshot
+
+extension WindsurfGetPlanStatusResponse {
+    public func toUsageSnapshot() -> UsageSnapshot {
+        var primary: RateWindow?
+        var secondary: RateWindow?
+
+        if let status = self.planStatus {
+            if let daily = status.dailyQuotaRemainingPercent {
+                let resetDate = status.dailyQuotaResetAtUnix.map {
+                    Date(timeIntervalSince1970: TimeInterval($0))
+                }
+                primary = RateWindow(
+                    usedPercent: max(0, min(100, 100 - Double(daily))),
+                    windowMinutes: nil,
+                    resetsAt: resetDate,
+                    resetDescription: Self.formatResetDescription(resetDate))
+            }
+
+            if let weekly = status.weeklyQuotaRemainingPercent {
+                let resetDate = status.weeklyQuotaResetAtUnix.map {
+                    Date(timeIntervalSince1970: TimeInterval($0))
+                }
+                secondary = RateWindow(
+                    usedPercent: max(0, min(100, 100 - Double(weekly))),
+                    windowMinutes: nil,
+                    resetsAt: resetDate,
+                    resetDescription: Self.formatResetDescription(resetDate))
+            }
+        }
+
+        var orgDescription: String?
+        if let endDate = self.planStatus?.planEnd {
+            let formatter = DateFormatter()
+            formatter.dateStyle = .medium
+            formatter.timeStyle = .none
+            orgDescription = "Expires \(formatter.string(from: endDate))"
+        }
+
+        let identity = ProviderIdentitySnapshot(
+            providerID: .windsurf,
+            accountEmail: nil,
+            accountOrganization: orgDescription,
+            loginMethod: self.planStatus?.planInfo?.planName)
+
+        return UsageSnapshot(
+            primary: primary,
+            secondary: secondary,
+            updatedAt: Date(),
+            identity: identity)
+    }
+
+    private static func formatResetDescription(_ date: Date?) -> String? {
+        guard let date else { return nil }
+        let now = Date()
+        let interval = date.timeIntervalSince(now)
+        guard interval > 0 else { return "Expired" }
+
+        let hours = Int(interval / 3600)
+        let minutes = Int((interval.truncatingRemainder(dividingBy: 3600)) / 60)
+
+        if hours > 24 {
+            let days = hours / 24
+            let remainingHours = hours % 24
+            return "Resets in \(days)d \(remainingHours)h"
+        } else if hours > 0 {
+            return "Resets in \(hours)h \(minutes)m"
+        } else {
+            return "Resets in \(minutes)m"
+        }
+    }
+}
+
+// MARK: - Session Material
+
+#if os(macOS)
+
+struct WindsurfDevinSessionAuth: Codable, Equatable {
+    let sessionToken: String
+    let auth1Token: String
+    let accountID: String
+    let primaryOrgID: String
+}
+
+public enum WindsurfWebFetcherError: LocalizedError, Sendable {
+    case noSessionData
+    case invalidManualSession(String)
+    case apiCallFailed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .noSessionData:
+            "No Windsurf web session found in Chromium localStorage. " +
+                "Sign in to app.devin.ai or windsurf.com in Chrome first."
+        case let .invalidManualSession(message):
+            "Invalid Windsurf session payload: \(message)"
+        case let .apiCallFailed(message):
+            "Windsurf API call failed: \(message)"
+        }
+    }
+}
+
+public enum WindsurfWebFetcher {
+    private static let windsurfOrigin = "https://windsurf.com"
+    private static let windsurfProfileReferer = "https://windsurf.com/profile"
+    private static let getPlanStatusURL = "https://windsurf.com/_backend/exa.seat_management_pb.SeatManagementService/GetPlanStatus"
+
+    public static func fetchUsage(
+        browserDetection: BrowserDetection,
+        cookieSource: ProviderCookieSource = .auto,
+        manualSessionInput: String? = nil,
+        timeout: TimeInterval = 15,
+        logger: ((String) -> Void)? = nil,
+        session transport: any ProviderHTTPTransport = ProviderHTTPClient.shared) async throws -> UsageSnapshot
+    {
+        let log: (String) -> Void = { msg in logger?("[windsurf-web] \(msg)") }
+
+        if cookieSource == .manual {
+            guard let manualSessionInput,
+                  !manualSessionInput.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+            else {
+                throw WindsurfWebFetcherError.invalidManualSession("empty input")
+            }
+            log("Using manual Windsurf session bundle")
+            let auth = try self.parseManualSessionInput(manualSessionInput)
+            let response = try await self.fetchPlanStatus(auth: auth, timeout: timeout, transport: transport)
+            return response.toUsageSnapshot()
+        }
+
+        guard cookieSource != .off else {
+            throw WindsurfWebFetcherError.noSessionData
+        }
+
+        let preferredSessionInfos = WindsurfDevinSessionImporter.importPreferredSessions(
+            browserDetection: browserDetection,
+            logger: logger)
+        let sessionInfos = preferredSessionInfos.isEmpty
+            ? WindsurfDevinSessionImporter.importFallbackSessions(
+                browserDetection: browserDetection,
+                logger: logger)
+            : preferredSessionInfos
+        guard !sessionInfos.isEmpty else {
+            throw WindsurfWebFetcherError.noSessionData
+        }
+
+        do {
+            return try await self.fetchUsage(
+                sessionInfos: sessionInfos,
+                timeout: timeout,
+                logger: log,
+                transport: transport)
+        } catch {
+            guard !preferredSessionInfos.isEmpty, self.isRecoverableImportedSessionError(error) else {
+                throw error
+            }
+        }
+
+        log("Chrome Windsurf sessions failed; trying fallback Chromium browser sessions")
+        let fallbackSessionInfos = WindsurfDevinSessionImporter.importFallbackSessions(
+            browserDetection: browserDetection,
+            logger: logger)
+        guard !fallbackSessionInfos.isEmpty else {
+            throw WindsurfWebFetcherError.noSessionData
+        }
+        return try await self.fetchUsage(
+            sessionInfos: fallbackSessionInfos,
+            timeout: timeout,
+            logger: log,
+            transport: transport)
+    }
+
+    static func parseManualSessionInput(_ raw: String) throws -> WindsurfDevinSessionAuth {
+        let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else {
+            throw WindsurfWebFetcherError.invalidManualSession("empty input")
+        }
+
+        if let auth = self.parseJSONSessionInput(trimmed) {
+            return auth
+        }
+
+        if let auth = self.parseKeyValueSessionInput(trimmed) {
+            return auth
+        }
+
+        throw WindsurfWebFetcherError.invalidManualSession(
+            "expected JSON with devin_session_token, devin_auth1_token, devin_account_id, and devin_primary_org_id")
+    }
+
+    private static func parseJSONSessionInput(_ raw: String) -> WindsurfDevinSessionAuth? {
+        guard let data = raw.data(using: .utf8),
+              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+        else {
+            return nil
+        }
+        return self.sessionAuth(from: json)
+    }
+
+    private static func parseKeyValueSessionInput(_ raw: String) -> WindsurfDevinSessionAuth? {
+        let separators = CharacterSet(charactersIn: "\n,;")
+        let segments = raw
+            .trimmingCharacters(in: CharacterSet(charactersIn: "{}"))
+            .components(separatedBy: separators)
+            .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
+            .filter { !$0.isEmpty }
+
+        var values: [String: String] = [:]
+        for segment in segments {
+            let delimiter: Character? = segment.contains("=") ? "=" : (segment.contains(":") ? ":" : nil)
+            guard let delimiter, let index = segment.firstIndex(of: delimiter) else { continue }
+            let key = String(segment[..<index]).trimmingCharacters(in: .whitespacesAndNewlines)
+            let value = String(segment[segment.index(after: index)...]).trimmingCharacters(in: .whitespacesAndNewlines)
+            values[key] = value.trimmingCharacters(in: CharacterSet(charactersIn: "\"'"))
+        }
+
+        guard !values.isEmpty else { return nil }
+        return self.sessionAuth(from: values)
+    }
+
+    private static func isRecoverableImportedSessionError(_ error: Error) -> Bool {
+        guard case let WindsurfWebFetcherError.apiCallFailed(message) = error else {
+            return false
+        }
+
+        return ["HTTP 400", "HTTP 401", "HTTP 403"].contains { message.hasPrefix($0) }
+    }
+
+    private static func fetchUsage(
+        sessionInfos: [WindsurfDevinSessionImporter.SessionInfo],
+        timeout: TimeInterval,
+        logger log: (String) -> Void,
+        transport: any ProviderHTTPTransport) async throws -> UsageSnapshot
+    {
+        var lastError: Error?
+        for sessionInfo in sessionInfos {
+            do {
+                log("Using devin session from \(sessionInfo.sourceLabel)")
+                let response = try await self.fetchPlanStatus(
+                    auth: sessionInfo.session,
+                    timeout: timeout,
+                    transport: transport)
+                return response.toUsageSnapshot()
+            } catch {
+                guard self.isRecoverableImportedSessionError(error) else {
+                    throw error
+                }
+                lastError = error
+                log("Windsurf devin session from \(sessionInfo.sourceLabel) failed; trying next imported session")
+            }
+        }
+
+        throw lastError ?? WindsurfWebFetcherError.noSessionData
+    }
+
+    private static func sessionAuth(from values: [String: Any]) -> WindsurfDevinSessionAuth? {
+        func stringValue(for keys: [String]) -> String? {
+            for key in keys {
+                if let value = values[key] as? String {
+                    let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
+                    if !trimmed.isEmpty {
+                        return trimmed
+                    }
+                }
+            }
+            return nil
+        }
+
+        guard let sessionToken = stringValue(for: ["devin_session_token", "devinSessionToken", "sessionToken"]),
+              let auth1Token = stringValue(for: ["devin_auth1_token", "devinAuth1Token", "auth1Token"]),
+              let accountID = stringValue(for: ["devin_account_id", "devinAccountId", "accountID", "accountId"]),
+              let primaryOrgID = stringValue(for: [
+                  "devin_primary_org_id",
+                  "devinPrimaryOrgId",
+                  "primaryOrgID",
+                  "primaryOrgId",
+              ])
+        else {
+            return nil
+        }
+
+        return WindsurfDevinSessionAuth(
+            sessionToken: sessionToken,
+            auth1Token: auth1Token,
+            accountID: accountID,
+            primaryOrgID: primaryOrgID)
+    }
+
+    private static func fetchPlanStatus(
+        auth: WindsurfDevinSessionAuth,
+        timeout: TimeInterval,
+        transport: any ProviderHTTPTransport) async throws -> WindsurfGetPlanStatusResponse
+    {
+        guard let url = URL(string: self.getPlanStatusURL) else {
+            throw WindsurfWebFetcherError.apiCallFailed("Invalid GetPlanStatus URL")
+        }
+
+        var request = URLRequest(url: url)
+        request.timeoutInterval = timeout
+        request.httpMethod = "POST"
+        request.setValue("application/proto", forHTTPHeaderField: "Content-Type")
+        request.setValue("1", forHTTPHeaderField: "Connect-Protocol-Version")
+        self.applyWindsurfHeaders(to: &request, auth: auth)
+        request.httpBody = WindsurfPlanStatusProtoCodec.encodeRequest(
+            authToken: auth.sessionToken,
+            includeTopUpStatus: true)
+
+        let response: ProviderHTTPResponse
+        do {
+            response = try await transport.response(for: request)
+        } catch let error as URLError where error.code == .badServerResponse {
+            throw WindsurfWebFetcherError.apiCallFailed("Invalid response")
+        } catch {
+            throw error
+        }
+
+        guard response.statusCode == 200 else {
+            let body = String(data: response.data, encoding: .utf8)?
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+            let snippet = if let body, !body.isEmpty {
+                ": \(body.prefix(200))"
+            } else {
+                ": <binary \(response.data.count) bytes>"
+            }
+            throw WindsurfWebFetcherError.apiCallFailed("HTTP \(response.statusCode)\(snippet)")
+        }
+
+        do {
+            return try WindsurfPlanStatusProtoCodec.decodeResponse(response.data)
+        } catch {
+            throw WindsurfWebFetcherError.apiCallFailed("Parse error: \(error.localizedDescription)")
+        }
+    }
+
+    private static func applyWindsurfHeaders(to request: inout URLRequest, auth: WindsurfDevinSessionAuth) {
+        request.setValue(self.windsurfOrigin, forHTTPHeaderField: "Origin")
+        request.setValue(self.windsurfProfileReferer, forHTTPHeaderField: "Referer")
+        request.setValue(auth.sessionToken, forHTTPHeaderField: "x-auth-token")
+        request.setValue(auth.sessionToken, forHTTPHeaderField: "x-devin-session-token")
+        request.setValue(auth.auth1Token, forHTTPHeaderField: "x-devin-auth1-token")
+        request.setValue(auth.accountID, forHTTPHeaderField: "x-devin-account-id")
+        request.setValue(auth.primaryOrgID, forHTTPHeaderField: "x-devin-primary-org-id")
+    }
+}
+
+enum WindsurfPlanStatusProtoCodec {
+    /// Field numbers come from Windsurf's bundled protobuf metadata in
+    /// `/Applications/Windsurf.app/.../extension.js` and were re-verified against live browser traffic on 2026-04-17.
+    struct Request: Equatable {
+        let authToken: String
+        let includeTopUpStatus: Bool
+    }
+
+    static func encodeRequest(authToken: String, includeTopUpStatus: Bool) -> Data {
+        var data = Data()
+        self.appendFieldKey(1, wireType: .lengthDelimited, to: &data)
+        self.appendString(authToken, to: &data)
+        self.appendFieldKey(2, wireType: .varint, to: &data)
+        self.appendVarint(includeTopUpStatus ? 1 : 0, to: &data)
+        return data
+    }
+
+    static func decodeRequest(_ data: Data) throws -> Request {
+        var reader = ProtoReader(data: data)
+        var authToken: String?
+        var includeTopUpStatus = false
+
+        while let field = try reader.nextField() {
+            switch (field.number, field.wireType) {
+            case (1, .lengthDelimited):
+                authToken = try reader.readString()
+            case (2, .varint):
+                includeTopUpStatus = try reader.readVarint() != 0
+            default:
+                try reader.skipFieldBody(wireType: field.wireType)
+            }
+        }
+
+        guard let authToken else {
+            throw WindsurfProtoError.missingField("auth_token")
+        }
+
+        return Request(authToken: authToken, includeTopUpStatus: includeTopUpStatus)
+    }
+
+    static func decodeResponse(_ data: Data) throws -> WindsurfGetPlanStatusResponse {
+        var reader = ProtoReader(data: data)
+        var planStatus: WindsurfGetPlanStatusResponse.PlanStatus?
+
+        while let field = try reader.nextField() {
+            switch (field.number, field.wireType) {
+            case (1, .lengthDelimited):
+                planStatus = try self.decodePlanStatus(from: reader.readLengthDelimitedData())
+            default:
+                try reader.skipFieldBody(wireType: field.wireType)
+            }
+        }
+
+        return WindsurfGetPlanStatusResponse(planStatus: planStatus)
+    }
+
+    private static func decodePlanStatus(from data: Data) throws -> WindsurfGetPlanStatusResponse.PlanStatus {
+        var reader = ProtoReader(data: data)
+        var planInfo: WindsurfGetPlanStatusResponse.PlanStatus.PlanInfo?
+        var planStart: Date?
+        var planEnd: Date?
+        var dailyQuotaRemainingPercent: Int?
+        var weeklyQuotaRemainingPercent: Int?
+        var dailyQuotaResetAtUnix: Int64?
+        var weeklyQuotaResetAtUnix: Int64?
+        var topUpStatus: WindsurfGetPlanStatusResponse.PlanStatus.TopUpStatus?
+        var gracePeriodStatus: Int?
+
+        while let field = try reader.nextField() {
+            switch (field.number, field.wireType) {
+            case (1, .lengthDelimited):
+                planInfo = try self.decodePlanInfo(from: reader.readLengthDelimitedData())
+            case (2, .lengthDelimited):
+                planStart = try self.decodeTimestamp(from: reader.readLengthDelimitedData())
+            case (3, .lengthDelimited):
+                planEnd = try self.decodeTimestamp(from: reader.readLengthDelimitedData())
+            case (10, .lengthDelimited):
+                topUpStatus = try self.decodeTopUpStatus(from: reader.readLengthDelimitedData())
+            case (12, .varint):
+                gracePeriodStatus = try Int(reader.readVarint())
+            case (14, .varint):
+                dailyQuotaRemainingPercent = try Int(reader.readVarint())
+            case (15, .varint):
+                weeklyQuotaRemainingPercent = try Int(reader.readVarint())
+            case (17, .varint):
+                dailyQuotaResetAtUnix = try Int64(reader.readVarint())
+            case (18, .varint):
+                weeklyQuotaResetAtUnix = try Int64(reader.readVarint())
+            default:
+                try reader.skipFieldBody(wireType: field.wireType)
+            }
+        }
+
+        return WindsurfGetPlanStatusResponse.PlanStatus(
+            planInfo: planInfo,
+            planStart: planStart,
+            planEnd: planEnd,
+            dailyQuotaRemainingPercent: dailyQuotaRemainingPercent,
+            weeklyQuotaRemainingPercent: weeklyQuotaRemainingPercent,
+            dailyQuotaResetAtUnix: dailyQuotaResetAtUnix,
+            weeklyQuotaResetAtUnix: weeklyQuotaResetAtUnix,
+            topUpStatus: topUpStatus,
+            gracePeriodStatus: gracePeriodStatus)
+    }
+
+    private static func decodePlanInfo(
+        from data: Data) throws -> WindsurfGetPlanStatusResponse.PlanStatus.PlanInfo
+    {
+        var reader = ProtoReader(data: data)
+        var planName: String?
+        var teamsTier: Int?
+
+        while let field = try reader.nextField() {
+            switch (field.number, field.wireType) {
+            case (1, .varint):
+                teamsTier = try Int(reader.readVarint())
+            case (2, .lengthDelimited):
+                planName = try reader.readString()
+            default:
+                try reader.skipFieldBody(wireType: field.wireType)
+            }
+        }
+
+        return WindsurfGetPlanStatusResponse.PlanStatus.PlanInfo(planName: planName, teamsTier: teamsTier)
+    }
+
+    private static func decodeTopUpStatus(
+        from data: Data) throws -> WindsurfGetPlanStatusResponse.PlanStatus.TopUpStatus
+    {
+        var reader = ProtoReader(data: data)
+        var topUpTransactionStatus: Int?
+
+        while let field = try reader.nextField() {
+            switch (field.number, field.wireType) {
+            case (1, .varint):
+                topUpTransactionStatus = try Int(reader.readVarint())
+            default:
+                try reader.skipFieldBody(wireType: field.wireType)
+            }
+        }
+
+        return WindsurfGetPlanStatusResponse.PlanStatus.TopUpStatus(
+            topUpTransactionStatus: topUpTransactionStatus)
+    }
+
+    private static func decodeTimestamp(from data: Data) throws -> Date {
+        var reader = ProtoReader(data: data)
+        var seconds: Int64 = 0
+        var nanos: Int32 = 0
+
+        while let field = try reader.nextField() {
+            switch (field.number, field.wireType) {
+            case (1, .varint):
+                seconds = try Int64(reader.readVarint())
+            case (2, .varint):
+                nanos = try Int32(reader.readVarint())
+            default:
+                try reader.skipFieldBody(wireType: field.wireType)
+            }
+        }
+
+        let timeInterval = TimeInterval(seconds) + (TimeInterval(nanos) / 1_000_000_000)
+        return Date(timeIntervalSince1970: timeInterval)
+    }
+
+    private static func appendString(_ string: String, to data: inout Data) {
+        let encoded = Data(string.utf8)
+        self.appendVarint(UInt64(encoded.count), to: &data)
+        data.append(encoded)
+    }
+
+    private static func appendFieldKey(_ fieldNumber: Int, wireType: ProtoWireType, to data: inout Data) {
+        self.appendVarint(UInt64((fieldNumber << 3) | Int(wireType.rawValue)), to: &data)
+    }
+
+    private static func appendVarint(_ value: UInt64, to data: inout Data) {
+        var remaining = value
+        while remaining >= 0x80 {
+            data.append(UInt8((remaining & 0x7F) | 0x80))
+            remaining >>= 7
+        }
+        data.append(UInt8(remaining))
+    }
+}
+
+enum WindsurfProtoError: LocalizedError {
+    case truncated
+    case invalidWireType(UInt64)
+    case invalidUTF8
+    case missingField(String)
+    case unsupportedWireType(ProtoWireType)
+    case malformedFieldKey
+
+    var errorDescription: String? {
+        switch self {
+        case .truncated:
+            "truncated protobuf payload"
+        case let .invalidWireType(rawValue):
+            "invalid wire type \(rawValue)"
+        case .invalidUTF8:
+            "invalid UTF-8 string"
+        case let .missingField(name):
+            "missing protobuf field \(name)"
+        case let .unsupportedWireType(type):
+            "unsupported protobuf wire type \(type.rawValue)"
+        case .malformedFieldKey:
+            "malformed protobuf field key"
+        }
+    }
+}
+
+enum ProtoWireType: UInt64 {
+    case varint = 0
+    case fixed64 = 1
+    case lengthDelimited = 2
+    case startGroup = 3
+    case endGroup = 4
+    case fixed32 = 5
+}
+
+private struct ProtoField {
+    let number: Int
+    let wireType: ProtoWireType
+}
+
+private struct ProtoReader {
+    private let bytes: [UInt8]
+    private var index: Int = 0
+
+    init(data: Data) {
+        self.bytes = Array(data)
+    }
+
+    mutating func nextField() throws -> ProtoField? {
+        guard self.index < self.bytes.count else { return nil }
+        let key = try self.readVarint()
+        let number = Int(key >> 3)
+        guard number > 0 else {
+            throw WindsurfProtoError.malformedFieldKey
+        }
+        guard let wireType = ProtoWireType(rawValue: key & 0x07) else {
+            throw WindsurfProtoError.invalidWireType(key & 0x07)
+        }
+        return ProtoField(number: number, wireType: wireType)
+    }
+
+    mutating func readVarint() throws -> UInt64 {
+        var result: UInt64 = 0
+        var shift: UInt64 = 0
+
+        while self.index < self.bytes.count {
+            let byte = self.bytes[self.index]
+            self.index += 1
+
+            result |= UInt64(byte & 0x7F) << shift
+            if byte & 0x80 == 0 {
+                return result
+            }
+
+            shift += 7
+            if shift >= 64 {
+                throw WindsurfProtoError.truncated
+            }
+        }
+
+        throw WindsurfProtoError.truncated
+    }
+
+    mutating func readLengthDelimitedData() throws -> Data {
+        let length = try Int(self.readVarint())
+        guard length >= 0, self.index + length <= self.bytes.count else {
+            throw WindsurfProtoError.truncated
+        }
+
+        let chunk = Data(self.bytes[self.index..<(self.index + length)])
+        self.index += length
+        return chunk
+    }
+
+    mutating func readString() throws -> String {
+        let data = try self.readLengthDelimitedData()
+        guard let string = String(data: data, encoding: .utf8) else {
+            throw WindsurfProtoError.invalidUTF8
+        }
+        return string
+    }
+
+    mutating func skipFieldBody(wireType: ProtoWireType) throws {
+        switch wireType {
+        case .varint:
+            _ = try self.readVarint()
+        case .fixed64:
+            guard self.index + 8 <= self.bytes.count else { throw WindsurfProtoError.truncated }
+            self.index += 8
+        case .lengthDelimited:
+            _ = try self.readLengthDelimitedData()
+        case .fixed32:
+            guard self.index + 4 <= self.bytes.count else { throw WindsurfProtoError.truncated }
+            self.index += 4
+        case .startGroup, .endGroup:
+            throw WindsurfProtoError.unsupportedWireType(wireType)
+        }
+    }
+}
+
+#endif
diff --git a/Sources/CodexBarCore/Providers/Zai/ZaiAPIRegion.swift b/Sources/CodexBarCore/Providers/Zai/ZaiAPIRegion.swift
index 18d5a15e9b..df14c23922 100644
--- a/Sources/CodexBarCore/Providers/Zai/ZaiAPIRegion.swift
+++ b/Sources/CodexBarCore/Providers/Zai/ZaiAPIRegion.swift
@@ -5,6 +5,7 @@ public enum ZaiAPIRegion: String, CaseIterable, Sendable {
     case bigmodelCN = "bigmodel-cn"
 
     private static let quotaPath = "api/monitor/usage/quota/limit"
+    private static let modelUsagePath = "api/monitor/usage/model-usage"
 
     public var displayName: String {
         switch self {
@@ -27,4 +28,17 @@ public enum ZaiAPIRegion: String, CaseIterable, Sendable {
     public var quotaLimitURL: URL {
         URL(string: self.baseURLString)!.appendingPathComponent(Self.quotaPath)
     }
+
+    public var modelUsageURL: URL {
+        URL(string: self.baseURLString)!.appendingPathComponent(Self.modelUsagePath)
+    }
+
+    public var dashboardURL: URL {
+        switch self {
+        case .global:
+            URL(string: "https://z.ai/manage-apikey/coding-plan/personal/my-plan")!
+        case .bigmodelCN:
+            URL(string: "https://bigmodel.cn/coding-plan/personal/usage")!
+        }
+    }
 }
diff --git a/Sources/CodexBarCore/Providers/Zai/ZaiProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Zai/ZaiProviderDescriptor.swift
index 430066a109..43554d4ea6 100644
--- a/Sources/CodexBarCore/Providers/Zai/ZaiProviderDescriptor.swift
+++ b/Sources/CodexBarCore/Providers/Zai/ZaiProviderDescriptor.swift
@@ -1,9 +1,8 @@
-import CodexBarMacroSupport
 import Foundation
 
-@ProviderDescriptorRegistration
-@ProviderDescriptorDefinition
 public enum ZaiProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
     static func makeDescriptor() -> ProviderDescriptor {
         ProviderDescriptor(
             id: .zai,
@@ -12,8 +11,8 @@ public enum ZaiProviderDescriptor {
                 displayName: "z.ai",
                 sessionLabel: "Tokens",
                 weeklyLabel: "MCP",
-                opusLabel: nil,
-                supportsOpus: false,
+                opusLabel: "5-hour",
+                supportsOpus: true,
                 supportsCredits: false,
                 creditsHint: "",
                 toggleTitle: "Show z.ai usage",
@@ -21,7 +20,7 @@ public enum ZaiProviderDescriptor {
                 defaultEnabled: false,
                 isPrimaryProvider: false,
                 usesAccountFallback: false,
-                dashboardURL: "https://z.ai/manage-apikey/subscription",
+                dashboardURL: ZaiAPIRegion.global.dashboardURL.absoluteString,
                 statusPageURL: nil),
             branding: ProviderBranding(
                 iconStyle: .zai,
@@ -30,43 +29,20 @@ public enum ZaiProviderDescriptor {
             tokenCost: ProviderTokenCostConfig(
                 supportsTokenCost: false,
                 noDataMessage: { "z.ai cost summary is not supported." }),
-            fetchPlan: ProviderFetchPlan(
-                sourceModes: [.auto, .api],
-                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [ZaiAPIFetchStrategy()] })),
+            fetchPlan: .apiToken(
+                strategyID: "zai.api",
+                resolveToken: { ProviderTokenResolver.zaiToken(environment: $0) },
+                missingCredentialsError: { ZaiSettingsError.missingToken },
+                loadUsage: { apiKey, context in
+                    let region = context.settings?.zai?.apiRegion ?? .global
+                    return try await ZaiUsageFetcher.fetchUsageWithModelUsage(
+                        apiKey: apiKey,
+                        region: region,
+                        environment: context.env).toUsageSnapshot()
+                }),
             cli: ProviderCLIConfig(
                 name: "zai",
                 aliases: ["z.ai"],
                 versionDetector: nil))
     }
 }
-
-struct ZaiAPIFetchStrategy: ProviderFetchStrategy {
-    let id: String = "zai.api"
-    let kind: ProviderFetchKind = .apiToken
-
-    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
-        Self.resolveToken(environment: context.env) != nil
-    }
-
-    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
-        guard let apiKey = Self.resolveToken(environment: context.env) else {
-            throw ZaiSettingsError.missingToken
-        }
-        let region = context.settings?.zai?.apiRegion ?? .global
-        let usage = try await ZaiUsageFetcher.fetchUsage(
-            apiKey: apiKey,
-            region: region,
-            environment: context.env)
-        return self.makeResult(
-            usage: usage.toUsageSnapshot(),
-            sourceLabel: "api")
-    }
-
-    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
-        false
-    }
-
-    private static func resolveToken(environment: [String: String]) -> String? {
-        ProviderTokenResolver.zaiToken(environment: environment)
-    }
-}
diff --git a/Sources/CodexBarCore/Providers/Zai/ZaiSettingsReader.swift b/Sources/CodexBarCore/Providers/Zai/ZaiSettingsReader.swift
index 4df2223e36..ad385f59e5 100644
--- a/Sources/CodexBarCore/Providers/Zai/ZaiSettingsReader.swift
+++ b/Sources/CodexBarCore/Providers/Zai/ZaiSettingsReader.swift
@@ -24,10 +24,36 @@ public struct ZaiSettingsReader: Sendable {
         environment: [String: String] = ProcessInfo.processInfo.environment) -> URL?
     {
         guard let raw = self.cleaned(environment[quotaURLKey]) else { return nil }
-        if let url = URL(string: raw), url.scheme != nil {
-            return url
+        return ProviderEndpointOverrideValidator.normalizedHTTPSURL(from: raw)
+    }
+
+    public static func validateEndpointOverrides(
+        environment: [String: String] = ProcessInfo.processInfo.environment) throws
+    {
+        try self.validateQuotaEndpointOverride(environment: environment)
+        try self.validateAPIHostEndpointOverride(environment: environment)
+    }
+
+    public static func validateQuotaEndpointOverride(
+        environment: [String: String] = ProcessInfo.processInfo.environment) throws
+    {
+        if let raw = self.cleaned(environment[self.quotaURLKey]) {
+            guard ProviderEndpointOverrideValidator.normalizedHTTPSURL(from: raw) != nil else {
+                throw ZaiSettingsError.invalidEndpointOverride(self.quotaURLKey)
+            }
+            return
+        }
+
+        try self.validateAPIHostEndpointOverride(environment: environment)
+    }
+
+    public static func validateAPIHostEndpointOverride(
+        environment: [String: String] = ProcessInfo.processInfo.environment) throws
+    {
+        guard let raw = self.cleaned(environment[self.apiHostKey]) else { return }
+        guard ProviderEndpointOverrideValidator.normalizedHTTPSURL(from: raw) != nil else {
+            throw ZaiSettingsError.invalidEndpointOverride(self.apiHostKey)
         }
-        return URL(string: "https://\(raw)")
     }
 
     static func cleaned(_ raw: String?) -> String? {
@@ -38,8 +64,7 @@ public struct ZaiSettingsReader: Sendable {
         if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
             (value.hasPrefix("'") && value.hasSuffix("'"))
         {
-            value.removeFirst()
-            value.removeLast()
+            value = String(value.dropFirst().dropLast())
         }
 
         value = value.trimmingCharacters(in: .whitespacesAndNewlines)
@@ -47,13 +72,16 @@ public struct ZaiSettingsReader: Sendable {
     }
 }
 
-public enum ZaiSettingsError: LocalizedError, Sendable {
+public enum ZaiSettingsError: LocalizedError, Sendable, Equatable {
     case missingToken
+    case invalidEndpointOverride(String)
 
     public var errorDescription: String? {
         switch self {
         case .missingToken:
             "z.ai API token not found. Set apiKey in ~/.codexbar/config.json or Z_AI_API_KEY."
+        case let .invalidEndpointOverride(key):
+            "z.ai endpoint override \(key) must use HTTPS or a bare host."
         }
     }
 }
diff --git a/Sources/CodexBarCore/Providers/Zai/ZaiUsageStats.swift b/Sources/CodexBarCore/Providers/Zai/ZaiUsageStats.swift
index 1592a61819..c21d105d4d 100644
--- a/Sources/CodexBarCore/Providers/Zai/ZaiUsageStats.swift
+++ b/Sources/CodexBarCore/Providers/Zai/ZaiUsageStats.swift
@@ -15,6 +15,7 @@ public enum ZaiLimitUnit: Int, Sendable {
     case days = 1
     case hours = 3
     case minutes = 5
+    case weeks = 6
 }
 
 /// A single limit entry from the z.ai API
@@ -69,6 +70,8 @@ extension ZaiLimitEntry {
             return self.number * 60
         case .days:
             return self.number * 24 * 60
+        case .weeks:
+            return self.number * 7 * 24 * 60
         case .unknown:
             return nil
         }
@@ -80,6 +83,7 @@ extension ZaiLimitEntry {
         case .minutes: "minute"
         case .hours: "hour"
         case .days: "day"
+        case .weeks: "week"
         case .unknown: nil
         }
         guard let unitLabel else { return nil }
@@ -92,6 +96,10 @@ extension ZaiLimitEntry {
         return "\(description) window"
     }
 
+    var isMCPMonthlyMarker: Bool {
+        self.type == .timeLimit && self.unit == .minutes && self.number == 1
+    }
+
     private var computedUsedPercent: Double? {
         guard let limit = self.usage, limit > 0 else { return nil }
 
@@ -129,14 +137,26 @@ public struct ZaiUsageDetail: Sendable, Codable {
 /// Complete z.ai usage response
 public struct ZaiUsageSnapshot: Sendable {
     public let tokenLimit: ZaiLimitEntry?
+    /// Shorter-window TOKENS_LIMIT (e.g. 5-hour), present only when the API returns two TOKENS_LIMIT entries.
+    public let sessionTokenLimit: ZaiLimitEntry?
     public let timeLimit: ZaiLimitEntry?
     public let planName: String?
+    public let modelUsage: ZaiModelUsageData?
     public let updatedAt: Date
 
-    public init(tokenLimit: ZaiLimitEntry?, timeLimit: ZaiLimitEntry?, planName: String?, updatedAt: Date) {
+    public init(
+        tokenLimit: ZaiLimitEntry?,
+        sessionTokenLimit: ZaiLimitEntry? = nil,
+        timeLimit: ZaiLimitEntry?,
+        planName: String?,
+        modelUsage: ZaiModelUsageData? = nil,
+        updatedAt: Date)
+    {
         self.tokenLimit = tokenLimit
+        self.sessionTokenLimit = sessionTokenLimit
         self.timeLimit = timeLimit
         self.planName = planName
+        self.modelUsage = modelUsage
         self.updatedAt = updatedAt
     }
 
@@ -150,13 +170,13 @@ extension ZaiUsageSnapshot {
     public func toUsageSnapshot() -> UsageSnapshot {
         let primaryLimit = self.tokenLimit ?? self.timeLimit
         let secondaryLimit = (self.tokenLimit != nil && self.timeLimit != nil) ? self.timeLimit : nil
-
         let primary = primaryLimit.map { Self.rateWindow(for: $0) } ?? RateWindow(
             usedPercent: 0,
             windowMinutes: nil,
             resetsAt: nil,
             resetDescription: nil)
         let secondary = secondaryLimit.map { Self.rateWindow(for: $0) }
+        let tertiary = self.sessionTokenLimit.map { Self.rateWindow(for: $0) }
 
         let planName = self.planName?.trimmingCharacters(in: .whitespacesAndNewlines)
         let loginMethod = (planName?.isEmpty ?? true) ? nil : planName
@@ -168,7 +188,7 @@ extension ZaiUsageSnapshot {
         return UsageSnapshot(
             primary: primary,
             secondary: secondary,
-            tertiary: nil,
+            tertiary: tertiary,
             providerCost: nil,
             zaiUsage: self,
             updatedAt: self.updatedAt,
@@ -184,6 +204,9 @@ extension ZaiUsageSnapshot {
     }
 
     private static func resetDescription(for limit: ZaiLimitEntry) -> String? {
+        if limit.isMCPMonthlyMarker {
+            return "Monthly"
+        }
         if let label = limit.windowLabel {
             return label
         }
@@ -286,6 +309,21 @@ public struct ZaiUsageFetcher: Sendable {
         return region.quotaLimitURL
     }
 
+    /// Resolves the canonical dashboard for the effective quota endpoint without opening custom override hosts.
+    public static func resolveDashboardURL(
+        region: ZaiAPIRegion,
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> URL
+    {
+        let quotaHost = self.resolveQuotaURL(region: region, environment: environment).host?.lowercased()
+        if quotaHost == ZaiAPIRegion.global.quotaLimitURL.host?.lowercased() {
+            return ZaiAPIRegion.global.dashboardURL
+        }
+        if quotaHost == ZaiAPIRegion.bigmodelCN.quotaLimitURL.host?.lowercased() {
+            return ZaiAPIRegion.bigmodelCN.dashboardURL
+        }
+        return region.dashboardURL
+    }
+
     /// Fetches usage stats from z.ai using the provided API key
     public static func fetchUsage(
         apiKey: String,
@@ -295,6 +333,7 @@ public struct ZaiUsageFetcher: Sendable {
         guard !apiKey.isEmpty else {
             throw ZaiUsageError.invalidCredentials
         }
+        try ZaiSettingsReader.validateQuotaEndpointOverride(environment: environment)
 
         let quotaURL = self.resolveQuotaURL(region: region, environment: environment)
 
@@ -303,16 +342,12 @@ public struct ZaiUsageFetcher: Sendable {
         request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "authorization")
         request.setValue("application/json", forHTTPHeaderField: "accept")
 
-        let (data, response) = try await URLSession.shared.data(for: request)
-
-        guard let httpResponse = response as? HTTPURLResponse else {
-            throw ZaiUsageError.networkError("Invalid response")
-        }
-
-        guard httpResponse.statusCode == 200 else {
+        let response = try await ProviderHTTPClient.shared.response(for: request)
+        let data = response.data
+        guard response.statusCode == 200 else {
             let errorMessage = String(data: data, encoding: .utf8) ?? "Unknown error"
-            Self.log.error("z.ai API returned \(httpResponse.statusCode): \(errorMessage)")
-            throw ZaiUsageError.apiError("HTTP \(httpResponse.statusCode): \(errorMessage)")
+            Self.log.error("z.ai API returned \(response.statusCode): \(errorMessage)")
+            throw ZaiUsageError.apiError("HTTP \(response.statusCode): \(errorMessage)")
         }
 
         // Some upstream issues (wrong endpoint/region/proxy) can yield HTTP 200 with an empty body.
@@ -364,37 +399,54 @@ public struct ZaiUsageFetcher: Sendable {
             throw ZaiUsageError.parseFailed("Missing data")
         }
 
-        var tokenLimit: ZaiLimitEntry?
+        var tokenLimits: [ZaiLimitEntry] = []
         var timeLimit: ZaiLimitEntry?
 
         for limit in responseData.limits {
             if let entry = limit.toLimitEntry() {
                 switch entry.type {
                 case .tokensLimit:
-                    tokenLimit = entry
+                    tokenLimits.append(entry)
                 case .timeLimit:
                     timeLimit = entry
                 }
             }
         }
 
+        // Multiple TOKENS_LIMIT entries: shortest window → sessionTokenLimit (tertiary),
+        // longest → tokenLimit (primary).
+        let tokenLimit: ZaiLimitEntry?
+        let sessionTokenLimit: ZaiLimitEntry?
+        if tokenLimits.count >= 2 {
+            let sorted = tokenLimits.sorted {
+                ($0.windowMinutes ?? Int.max) < ($1.windowMinutes ?? Int.max)
+            }
+            sessionTokenLimit = sorted.first
+            tokenLimit = sorted.last
+        } else {
+            tokenLimit = tokenLimits.first
+            sessionTokenLimit = nil
+        }
+
         return ZaiUsageSnapshot(
             tokenLimit: tokenLimit,
+            sessionTokenLimit: sessionTokenLimit,
             timeLimit: timeLimit,
             planName: responseData.planName,
+            modelUsage: nil,
             updatedAt: Date())
     }
 
     private static func quotaURL(baseURLString: String) -> URL? {
         guard let cleaned = ZaiSettingsReader.cleaned(baseURLString) else { return nil }
 
-        if let url = URL(string: cleaned), url.scheme != nil {
+        if let url = ProviderEndpointOverrideValidator.normalizedHTTPSURL(from: cleaned) {
             if url.path.isEmpty || url.path == "/" {
                 return url.appendingPathComponent(Self.quotaAPIPath)
             }
             return url
         }
-        guard let base = URL(string: "https://\(cleaned)") else { return nil }
+        guard let base = ProviderEndpointOverrideValidator.normalizedHTTPSURL(from: cleaned) else { return nil }
         if base.path.isEmpty || base.path == "/" {
             return base.appendingPathComponent(Self.quotaAPIPath)
         }
@@ -402,6 +454,281 @@ public struct ZaiUsageFetcher: Sendable {
     }
 }
 
+// MARK: - Model Usage Data
+
+/// Per-model hourly token usage from the z.ai model-usage API
+public struct ZaiModelUsageData: Sendable {
+    public let xTime: [String]
+    public let modelDataList: [ZaiModelDataItem]
+
+    public init(xTime: [String], modelDataList: [ZaiModelDataItem]) {
+        self.xTime = xTime
+        self.modelDataList = modelDataList
+    }
+
+    public var modelNames: [String] {
+        self.modelDataList.compactMap(\.modelName)
+    }
+}
+
+public struct ZaiModelDataItem: Sendable {
+    public let modelName: String?
+    public let tokensUsage: [Int?]
+
+    public init(modelName: String?, tokensUsage: [Int?]) {
+        self.modelName = modelName
+        self.tokensUsage = tokensUsage
+    }
+}
+
+// MARK: - Hourly Chart Data
+
+public enum ZaiHourlyRange: Equatable, Sendable {
+    case today(referenceDate: Date)
+    case last24h
+
+    public var isToday: Bool {
+        if case .today = self { return true }
+        return false
+    }
+}
+
+public struct ZaiHourlyBar: Sendable {
+    public let label: String
+    public let segments: [(model: String, tokens: Int)]
+
+    public init(label: String, segments: [(model: String, tokens: Int)]) {
+        self.label = label
+        self.segments = segments
+    }
+
+    public var totalTokens: Int {
+        self.segments.reduce(0) { $0 + $1.tokens }
+    }
+}
+
+public enum ZaiHourlyBars: Sendable {
+    public static func from(modelData: ZaiModelUsageData, range: ZaiHourlyRange, now: Date = Date()) -> [ZaiHourlyBar] {
+        let calendar = Calendar.current
+        let referenceDate: Date = switch range {
+        case let .today(ref): ref
+        case .last24h: now
+        }
+
+        let todayStart = calendar.startOfDay(for: referenceDate)
+        let cutoff: Date = switch range {
+        case .today: todayStart
+        case .last24h: calendar.date(byAdding: .hour, value: -24, to: now) ?? now
+        }
+
+        var bars: [ZaiHourlyBar] = []
+        for (index, timeString) in modelData.xTime.enumerated() {
+            guard let hourDate = parseHourDate(timeString) else { continue }
+
+            if hourDate < cutoff { continue }
+
+            var segments: [(model: String, tokens: Int)] = []
+            for item in modelData.modelDataList {
+                guard index < item.tokensUsage.count,
+                      let tokenCount = item.tokensUsage[index], tokenCount > 0
+                else { continue }
+                segments.append((model: item.modelName ?? "Unknown", tokens: tokenCount))
+            }
+
+            let total = segments.reduce(0) { $0 + $1.tokens }
+            guard total > 0 else { continue }
+
+            let label = self.formatHourLabel(hourDate: hourDate)
+            bars.append(ZaiHourlyBar(label: label, segments: segments))
+        }
+
+        return bars
+    }
+
+    public static func parseHourDate(_ string: String) -> Date? {
+        let formatter = DateFormatter()
+        formatter.dateFormat = "yyyy-MM-dd HH:mm"
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        return formatter.date(from: string)
+    }
+
+    private static func formatHourLabel(hourDate: Date) -> String {
+        let formatter = DateFormatter()
+        formatter.dateFormat = "HH"
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        return formatter.string(from: hourDate)
+    }
+}
+
+// MARK: - Model Usage Fetcher Extension
+
+extension ZaiUsageFetcher {
+    /// Fetches hourly model usage data for the last 24 hours
+    public static func fetchModelUsage(
+        apiKey: String,
+        region: ZaiAPIRegion = .global,
+        environment: [String: String] = ProcessInfo.processInfo.environment) async throws -> ZaiModelUsageData
+    {
+        guard !apiKey.isEmpty else {
+            throw ZaiUsageError.invalidCredentials
+        }
+        try ZaiSettingsReader.validateAPIHostEndpointOverride(environment: environment)
+
+        let baseURL: URL = if let host = ZaiSettingsReader.apiHost(environment: environment),
+                              let resolved = Self.modelUsageURL(baseURLString: host)
+        {
+            resolved
+        } else {
+            region.modelUsageURL
+        }
+
+        let now = Date()
+        let calendar = Calendar.current
+        guard let startDate = calendar.date(byAdding: .day, value: -1, to: calendar.startOfDay(for: now)) else {
+            throw ZaiUsageError.parseFailed("Invalid date calculation")
+        }
+
+        let startComponents = calendar.dateComponents([.year, .month, .day, .hour], from: startDate)
+        let endComponents = calendar.dateComponents([.year, .month, .day, .hour], from: now)
+        let startTime = String(
+            format: "%04d-%02d-%02d %02d:00:00",
+            startComponents.year!,
+            startComponents.month!,
+            startComponents.day!,
+            startComponents.hour!)
+        let endTime = String(
+            format: "%04d-%02d-%02d %02d:59:59",
+            endComponents.year!,
+            endComponents.month!,
+            endComponents.day!,
+            endComponents.hour!)
+
+        guard var components = URLComponents(url: baseURL, resolvingAgainstBaseURL: false) else {
+            throw ZaiUsageError.networkError("Invalid URL")
+        }
+        components.queryItems = [
+            URLQueryItem(name: "startTime", value: startTime),
+            URLQueryItem(name: "endTime", value: endTime),
+        ]
+
+        guard let requestURL = components.url else {
+            throw ZaiUsageError.networkError("Invalid URL")
+        }
+
+        var request = URLRequest(url: requestURL)
+        request.httpMethod = "GET"
+        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+
+        let response = try await ProviderHTTPClient.shared.response(for: request)
+        let data = response.data
+        guard response.statusCode == 200 else {
+            let errorMessage = String(data: data, encoding: .utf8) ?? "Unknown error"
+            Self.log.error("z.ai model-usage API returned \(response.statusCode): \(errorMessage)")
+            throw ZaiUsageError.apiError("HTTP \(response.statusCode): \(errorMessage)")
+        }
+
+        guard !data.isEmpty else { return ZaiModelUsageData(xTime: [], modelDataList: []) }
+
+        return try Self.parseModelUsage(from: data)
+    }
+
+    static func parseModelUsage(from data: Data) throws -> ZaiModelUsageData {
+        let decoder = JSONDecoder()
+        let apiResponse = try decoder.decode(ZaiModelUsageAPIResponse.self, from: data)
+
+        guard apiResponse.isSuccess else {
+            throw ZaiUsageError.apiError(apiResponse.msg)
+        }
+
+        guard let responseData = apiResponse.data else {
+            return ZaiModelUsageData(xTime: [], modelDataList: [])
+        }
+
+        let items = responseData.modelDataList?.map { raw in
+            ZaiModelDataItem(
+                modelName: raw.modelName,
+                tokensUsage: raw.tokensUsage ?? [])
+        } ?? []
+
+        return ZaiModelUsageData(
+            xTime: responseData.xTime ?? [],
+            modelDataList: items)
+    }
+
+    /// Fetches required quota data and attaches optional model usage when available.
+    public static func fetchUsageWithModelUsage(
+        apiKey: String,
+        region: ZaiAPIRegion = .global,
+        environment: [String: String] = ProcessInfo.processInfo.environment) async throws -> ZaiUsageSnapshot
+    {
+        try ZaiSettingsReader.validateEndpointOverrides(environment: environment)
+        let snapshot = try await Self.fetchUsage(apiKey: apiKey, region: region, environment: environment)
+        let modelUsage: ZaiModelUsageData?
+        do {
+            modelUsage = try await Self.fetchModelUsage(apiKey: apiKey, region: region, environment: environment)
+        } catch {
+            Self.log.info("z.ai model usage fetch failed (non-fatal): \(error.localizedDescription)")
+            modelUsage = nil
+        }
+
+        guard modelUsage != nil else { return snapshot }
+
+        return ZaiUsageSnapshot(
+            tokenLimit: snapshot.tokenLimit,
+            sessionTokenLimit: snapshot.sessionTokenLimit,
+            timeLimit: snapshot.timeLimit,
+            planName: snapshot.planName,
+            modelUsage: modelUsage,
+            updatedAt: snapshot.updatedAt)
+    }
+
+    private static func modelUsageURL(baseURLString: String) -> URL? {
+        guard let cleaned = ZaiSettingsReader.cleaned(baseURLString) else { return nil }
+        let path = "api/monitor/usage/model-usage"
+
+        if let url = URL(string: cleaned), url.scheme != nil {
+            if url.path.isEmpty || url.path == "/" {
+                return url.appendingPathComponent(path)
+            }
+            return url
+        }
+        guard let base = URL(string: "https://\(cleaned)") else { return nil }
+        if base.path.isEmpty || base.path == "/" {
+            return base.appendingPathComponent(path)
+        }
+        return base
+    }
+}
+
+// MARK: - Model Usage API Response (private)
+
+private struct ZaiModelUsageAPIResponse: Decodable {
+    let code: Int
+    let msg: String
+    let data: ZaiModelUsageRawData?
+    let success: Bool
+
+    var isSuccess: Bool {
+        self.success && self.code == 200
+    }
+}
+
+private struct ZaiModelUsageRawData: Decodable {
+    let xTime: [String]?
+    let modelDataList: [ZaiModelDataItemRaw]?
+
+    enum CodingKeys: String, CodingKey {
+        case xTime = "x_time"
+        case modelDataList
+    }
+}
+
+private struct ZaiModelDataItemRaw: Decodable {
+    let modelName: String?
+    let tokensUsage: [Int?]?
+}
+
 /// Errors that can occur during z.ai usage fetching
 public enum ZaiUsageError: LocalizedError, Sendable {
     case invalidCredentials
diff --git a/Sources/CodexBarCore/Providers/Zed/ZedProviderDescriptor.swift b/Sources/CodexBarCore/Providers/Zed/ZedProviderDescriptor.swift
new file mode 100644
index 0000000000..e6f56cb66e
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Zed/ZedProviderDescriptor.swift
@@ -0,0 +1,60 @@
+import Foundation
+
+public enum ZedProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
+    static func makeDescriptor() -> ProviderDescriptor {
+        ProviderDescriptor(
+            id: .zed,
+            metadata: ProviderMetadata(
+                id: .zed,
+                displayName: "Zed",
+                sessionLabel: "Edit predictions",
+                weeklyLabel: "Billing cycle",
+                opusLabel: nil,
+                supportsOpus: false,
+                supportsCredits: false,
+                creditsHint: "",
+                toggleTitle: "Show Zed usage",
+                cliName: "zed",
+                defaultEnabled: false,
+                isPrimaryProvider: false,
+                usesAccountFallback: false,
+                dashboardURL: nil,
+                statusPageURL: nil),
+            branding: ProviderBranding(
+                iconStyle: .zed,
+                iconResourceName: "ProviderIcon-zed",
+                color: ProviderColor(red: 8 / 255, green: 78 / 255, blue: 255 / 255)),
+            tokenCost: ProviderTokenCostConfig(
+                supportsTokenCost: false,
+                noDataMessage: { "Zed cost summary is not supported." }),
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .api],
+                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in
+                    [ZedLocalFetchStrategy()]
+                })),
+            cli: ProviderCLIConfig(
+                name: "zed",
+                versionDetector: nil))
+    }
+}
+
+struct ZedLocalFetchStrategy: ProviderFetchStrategy {
+    let id: String = "zed.local"
+    let kind: ProviderFetchKind = .localProbe
+
+    func isAvailable(_: ProviderFetchContext) async -> Bool {
+        true
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        _ = context
+        let snapshot = try await ZedStatusProbe().fetch()
+        return self.makeResult(usage: snapshot.toUsageSnapshot(), sourceLabel: "local")
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+}
diff --git a/Sources/CodexBarCore/Providers/Zed/ZedStatusProbe.swift b/Sources/CodexBarCore/Providers/Zed/ZedStatusProbe.swift
new file mode 100644
index 0000000000..4527c992da
--- /dev/null
+++ b/Sources/CodexBarCore/Providers/Zed/ZedStatusProbe.swift
@@ -0,0 +1,554 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+// MARK: - Models
+
+public struct ZedAuthenticatedUserResponse: Decodable, Equatable, Sendable {
+    public let user: ZedAuthenticatedUser
+    public let plan: ZedPlanInfo
+
+    public init(user: ZedAuthenticatedUser, plan: ZedPlanInfo) {
+        self.user = user
+        self.plan = plan
+    }
+}
+
+public struct ZedAuthenticatedUser: Decodable, Equatable, Sendable {
+    public let id: Int
+    public let githubLogin: String
+    public let name: String?
+
+    enum CodingKeys: String, CodingKey {
+        case id
+        case githubLogin = "github_login"
+        case name
+    }
+}
+
+public struct ZedPlanInfo: Decodable, Equatable, Sendable {
+    public let planV3: String
+    public let subscriptionPeriod: ZedSubscriptionPeriod?
+    public let usage: ZedCurrentUsage
+    public let hasOverdueInvoices: Bool
+
+    enum CodingKeys: String, CodingKey {
+        case planV3 = "plan_v3"
+        case subscriptionPeriod = "subscription_period"
+        case usage
+        case hasOverdueInvoices = "has_overdue_invoices"
+    }
+}
+
+public struct ZedSubscriptionPeriod: Decodable, Equatable, Sendable {
+    public let startedAt: Date
+    public let endedAt: Date
+
+    enum CodingKeys: String, CodingKey {
+        case startedAt = "started_at"
+        case endedAt = "ended_at"
+    }
+}
+
+public struct ZedCurrentUsage: Decodable, Equatable, Sendable {
+    public let editPredictions: ZedUsageData
+
+    enum CodingKeys: String, CodingKey {
+        case editPredictions = "edit_predictions"
+    }
+}
+
+public struct ZedUsageData: Decodable, Equatable, Sendable {
+    public let used: Int
+    public let limit: ZedUsageLimit
+}
+
+public enum ZedUsageLimit: Equatable, Sendable {
+    case limited(Int)
+    case unlimited
+}
+
+extension ZedUsageLimit: Decodable {
+    public init(from decoder: Decoder) throws {
+        if let single = try? decoder.singleValueContainer() {
+            if let string = try? single.decode(String.self), string == "unlimited" {
+                self = .unlimited
+                return
+            }
+            if let value = try? single.decode(Int.self) {
+                self = .limited(value)
+                return
+            }
+        }
+
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        if let value = try container.decodeIfPresent(Int.self, forKey: .limited) {
+            self = .limited(value)
+            return
+        }
+
+        throw DecodingError.dataCorrupted(
+            DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Unrecognized Zed usage limit"))
+    }
+
+    private enum CodingKeys: String, CodingKey {
+        case limited
+    }
+}
+
+public struct ZedCredentials: Equatable, Sendable {
+    public let userID: String
+    public let accessToken: String
+
+    public init(userID: String, accessToken: String) {
+        self.userID = userID
+        self.accessToken = accessToken
+    }
+
+    public var authorizationHeader: String {
+        "\(self.userID) \(self.accessToken)"
+    }
+}
+
+public struct ZedUsageSnapshot: Sendable, Equatable {
+    public let response: ZedAuthenticatedUserResponse
+    public let updatedAt: Date
+
+    public init(response: ZedAuthenticatedUserResponse, updatedAt: Date = Date()) {
+        self.response = response
+        self.updatedAt = updatedAt
+    }
+}
+
+// MARK: - Errors
+
+public enum ZedStatusProbeError: LocalizedError, Sendable, Equatable {
+    case notSupported
+    case notSignedIn
+    case keychainUnavailable
+    case invalidServerURL(String)
+    case untrustedServerConfiguration
+    case networkError(String)
+    case httpError(Int)
+    case unauthorized
+    case parseFailed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .notSupported:
+            "Zed is only supported on macOS."
+        case .notSignedIn:
+            "Not signed in to Zed. Sign in from the Zed editor app with GitHub."
+        case .keychainUnavailable:
+            "Could not read Zed credentials from the Keychain. Grant CodexBar Keychain access or sign in to Zed again."
+        case let .invalidServerURL(value):
+            "Zed server URL is invalid: \(value)"
+        case .untrustedServerConfiguration:
+            "Zed custom servers must use HTTPS and store credentials under the same server URL."
+        case let .networkError(message):
+            "Zed cloud API request failed: \(message)"
+        case let .httpError(status):
+            "Zed cloud API returned HTTP \(status)."
+        case .unauthorized:
+            "Zed credentials are invalid or expired. Sign in to Zed again."
+        case let .parseFailed(message):
+            "Could not parse Zed account response: \(message)"
+        }
+    }
+}
+
+// MARK: - Settings
+
+public struct ZedClientSettings: Sendable, Equatable {
+    public let credentialsURL: String?
+    public let serverURL: String?
+
+    public init(credentialsURL: String?, serverURL: String?) {
+        self.credentialsURL = credentialsURL
+        self.serverURL = serverURL
+    }
+
+    public var keychainServiceURL: String {
+        let trimmedCredentials = self.credentialsURL?.trimmingCharacters(in: .whitespacesAndNewlines)
+        if let trimmedCredentials, !trimmedCredentials.isEmpty {
+            return trimmedCredentials
+        }
+        let trimmedServer = self.serverURL?.trimmingCharacters(in: .whitespacesAndNewlines)
+        if let trimmedServer, !trimmedServer.isEmpty {
+            return trimmedServer
+        }
+        return ZedStatusProbe.defaultKeychainServiceURL
+    }
+
+    public var cloudAPIURL: URL? {
+        let trimmedServer = self.serverURL?.trimmingCharacters(in: .whitespacesAndNewlines)
+        let server = if let trimmedServer, !trimmedServer.isEmpty {
+            trimmedServer
+        } else {
+            ZedStatusProbe.defaultKeychainServiceURL
+        }
+        let isTrustedZedServer = server == "https://zed.dev" || server == "https://staging.zed.dev"
+        let trimmedCredentials = self.credentialsURL?.trimmingCharacters(in: .whitespacesAndNewlines)
+        if !isTrustedZedServer,
+           let trimmedCredentials,
+           !trimmedCredentials.isEmpty,
+           trimmedCredentials != server
+        {
+            return nil
+        }
+        let cloudBase = switch server {
+        case "https://zed.dev", "https://staging.zed.dev":
+            "https://cloud.zed.dev"
+        default:
+            server
+        }
+        guard let baseURL = URL(string: cloudBase),
+              let scheme = baseURL.scheme?.lowercased(),
+              scheme == "https",
+              baseURL.host != nil
+        else {
+            return nil
+        }
+        return baseURL.appendingPathComponent("client/users/me")
+    }
+
+    public static func load(from url: URL = ZedStatusProbe.defaultSettingsURL) -> ZedClientSettings? {
+        guard let data = try? Data(contentsOf: url) else { return nil }
+        struct Payload: Decodable {
+            let credentialsURL: String?
+            let serverURL: String?
+
+            enum CodingKeys: String, CodingKey {
+                case credentialsURL = "credentials_url"
+                case serverURL = "server_url"
+            }
+        }
+        guard let payload = try? JSONDecoder().decode(Payload.self, from: data) else { return nil }
+        return ZedClientSettings(
+            credentialsURL: payload.credentialsURL,
+            serverURL: payload.serverURL)
+    }
+}
+
+// MARK: - Credentials
+
+public protocol ZedCredentialsReading: Sendable {
+    func loadCredentials(serviceURL: String) throws -> ZedCredentials?
+}
+
+#if os(macOS)
+import Security
+
+public struct ZedKeychainCredentialsReader: ZedCredentialsReading, Sendable {
+    public init() {}
+
+    public func loadCredentials(serviceURL: String) throws -> ZedCredentials? {
+        if let credentials = try self.loadInternetPasswordCredentials(server: serviceURL) {
+            return credentials
+        }
+        return try self.loadGenericPasswordCredentials(service: serviceURL)
+    }
+
+    private func loadInternetPasswordCredentials(server: String) throws -> ZedCredentials? {
+        var query: [String: Any] = [
+            kSecClass as String: kSecClassInternetPassword,
+            kSecAttrServer as String: server,
+            kSecMatchLimit as String: kSecMatchLimitOne,
+            kSecReturnAttributes as String: true,
+            kSecReturnData as String: true,
+        ]
+        KeychainNoUIQuery.apply(to: &query)
+        return try self.credentials(from: query)
+    }
+
+    private func loadGenericPasswordCredentials(service: String) throws -> ZedCredentials? {
+        var query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: service,
+            kSecMatchLimit as String: kSecMatchLimitOne,
+            kSecReturnAttributes as String: true,
+            kSecReturnData as String: true,
+        ]
+        KeychainNoUIQuery.apply(to: &query)
+        return try self.credentials(from: query)
+    }
+
+    private func credentials(from query: [String: Any]) throws -> ZedCredentials? {
+        var result: AnyObject?
+        let status = SecItemCopyMatching(query as CFDictionary, &result)
+        switch status {
+        case errSecSuccess:
+            break
+        case errSecItemNotFound:
+            return nil
+        case errSecInteractionNotAllowed, errSecAuthFailed, errSecNoAccessForItem:
+            throw ZedStatusProbeError.keychainUnavailable
+        default:
+            throw ZedStatusProbeError.keychainUnavailable
+        }
+
+        guard let item = result as? [String: Any],
+              let account = item[kSecAttrAccount as String] as? String,
+              !account.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+        else {
+            return nil
+        }
+
+        let tokenData: Data? = if let data = item[kSecValueData as String] as? Data {
+            data
+        } else {
+            nil
+        }
+        guard let tokenData,
+              let accessToken = String(data: tokenData, encoding: .utf8),
+              !accessToken.isEmpty
+        else {
+            return nil
+        }
+
+        return ZedCredentials(userID: account, accessToken: accessToken)
+    }
+}
+#else
+public struct ZedKeychainCredentialsReader: ZedCredentialsReading, Sendable {
+    public init() {}
+
+    public func loadCredentials(serviceURL _: String) throws -> ZedCredentials? {
+        throw ZedStatusProbeError.notSupported
+    }
+}
+#endif
+
+// MARK: - Probe
+
+public struct ZedStatusProbe: Sendable {
+    public static let defaultKeychainServiceURL = "https://zed.dev"
+    public static let cloudAPIURL = URL(string: "https://cloud.zed.dev/client/users/me")!
+
+    public static var defaultSettingsURL: URL {
+        let home = FileManager.default.homeDirectoryForCurrentUser
+        return home
+            .appendingPathComponent(".config/zed/settings.json")
+    }
+
+    private static let logger = CodexBarLog.logger(LogCategories.zed)
+
+    private let credentialsReader: any ZedCredentialsReading
+    private let transport: any ProviderHTTPTransport
+    private let settingsLoader: @Sendable () -> ZedClientSettings?
+
+    public init(
+        credentialsReader: any ZedCredentialsReading = ZedKeychainCredentialsReader(),
+        transport: any ProviderHTTPTransport = ProviderHTTPClient.shared,
+        settingsLoader: @escaping @Sendable () -> ZedClientSettings? = { ZedClientSettings.load() })
+    {
+        self.credentialsReader = credentialsReader
+        self.transport = transport
+        self.settingsLoader = settingsLoader
+    }
+
+    public func fetch() async throws -> ZedUsageSnapshot {
+        let settings = self.settingsLoader()
+        let serviceURL = settings?.keychainServiceURL ?? Self.defaultKeychainServiceURL
+        let cloudAPIURL: URL
+        if let settings {
+            guard let configuredURL = settings.cloudAPIURL else {
+                let serverURL = settings.serverURL ?? ""
+                guard URL(string: serverURL)?.scheme?.lowercased() == "https" else {
+                    throw ZedStatusProbeError.invalidServerURL(serverURL)
+                }
+                throw ZedStatusProbeError.untrustedServerConfiguration
+            }
+            cloudAPIURL = configuredURL
+        } else {
+            cloudAPIURL = Self.cloudAPIURL
+        }
+        guard let credentials = try self.credentialsReader.loadCredentials(serviceURL: serviceURL) else {
+            throw ZedStatusProbeError.notSignedIn
+        }
+
+        let response = try await self.fetchAuthenticatedUser(credentials: credentials, apiURL: cloudAPIURL)
+        return ZedUsageSnapshot(response: response)
+    }
+
+    private func fetchAuthenticatedUser(
+        credentials: ZedCredentials,
+        apiURL: URL) async throws -> ZedAuthenticatedUserResponse
+    {
+        var request = URLRequest(url: apiURL)
+        request.httpMethod = "GET"
+        request.setValue(credentials.authorizationHeader, forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+
+        let httpResponse: ProviderHTTPResponse
+        do {
+            httpResponse = try await self.transport.response(for: request)
+        } catch is CancellationError {
+            throw CancellationError()
+        } catch let error as URLError where error.code == .cancelled {
+            throw CancellationError()
+        } catch {
+            Self.logger.debug("Zed cloud API transport failed: \(error.localizedDescription)")
+            throw ZedStatusProbeError.networkError(error.localizedDescription)
+        }
+
+        switch httpResponse.statusCode {
+        case 200:
+            return try Self.parseResponse(httpResponse.data)
+        case 401, 403:
+            throw ZedStatusProbeError.unauthorized
+        default:
+            throw ZedStatusProbeError.httpError(httpResponse.statusCode)
+        }
+    }
+
+    public static func parseResponse(_ data: Data) throws -> ZedAuthenticatedUserResponse {
+        let decoder = JSONDecoder()
+        decoder.dateDecodingStrategy = .custom { decoder in
+            let container = try decoder.singleValueContainer()
+            let value = try container.decode(String.self)
+            if let date = Self.parseISO8601Date(value) {
+                return date
+            }
+            throw DecodingError.dataCorruptedError(
+                in: container,
+                debugDescription: "Invalid ISO8601 date: \(value)")
+        }
+        do {
+            return try decoder.decode(ZedAuthenticatedUserResponse.self, from: data)
+        } catch {
+            throw ZedStatusProbeError.parseFailed(error.localizedDescription)
+        }
+    }
+
+    private static func parseISO8601Date(_ value: String) -> Date? {
+        let withFractional = ISO8601DateFormatter()
+        withFractional.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        if let date = withFractional.date(from: value) {
+            return date
+        }
+        let plain = ISO8601DateFormatter()
+        plain.formatOptions = [.withInternetDateTime]
+        return plain.date(from: value)
+    }
+}
+
+// MARK: - UsageSnapshot mapping
+
+extension ZedUsageSnapshot {
+    public func toUsageSnapshot() -> UsageSnapshot {
+        let plan = self.response.plan
+        let user = self.response.user
+
+        let primary = Self.makeEditPredictionsWindow(
+            used: plan.usage.editPredictions.used,
+            limit: plan.usage.editPredictions.limit)
+
+        let secondary = plan.subscriptionPeriod.map { period in
+            RateWindow(
+                usedPercent: Self.billingCycleUsedPercent(startedAt: period.startedAt, endedAt: period.endedAt),
+                windowMinutes: nil,
+                resetsAt: period.endedAt,
+                resetDescription: Self.formatResetDescription(period.endedAt))
+        }
+
+        var extraRateWindows: [NamedRateWindow] = []
+        if plan.hasOverdueInvoices {
+            extraRateWindows.append(NamedRateWindow(
+                id: "zed.overdue-invoices",
+                title: "Billing",
+                window: RateWindow(
+                    usedPercent: 100,
+                    windowMinutes: nil,
+                    resetsAt: nil,
+                    resetDescription: "Overdue invoices"),
+                usageKnown: false))
+        }
+
+        let identity = ProviderIdentitySnapshot(
+            providerID: .zed,
+            accountEmail: user.githubLogin.nilIfEmpty,
+            accountOrganization: user.name?.nilIfEmpty,
+            loginMethod: Self.displayPlanName(plan.planV3))
+
+        return UsageSnapshot(
+            primary: primary,
+            secondary: secondary,
+            extraRateWindows: extraRateWindows.isEmpty ? nil : extraRateWindows,
+            subscriptionRenewsAt: plan.subscriptionPeriod?.endedAt,
+            updatedAt: self.updatedAt,
+            identity: identity)
+    }
+
+    private static func makeEditPredictionsWindow(used: Int, limit: ZedUsageLimit) -> RateWindow? {
+        switch limit {
+        case .unlimited:
+            return RateWindow(
+                usedPercent: 0,
+                windowMinutes: nil,
+                resetsAt: nil,
+                resetDescription: "Unlimited")
+        case let .limited(total):
+            guard total > 0 else { return nil }
+            let clampedUsed = max(0, min(total, used))
+            let usedPercent = Double(clampedUsed) / Double(total) * 100.0
+            return RateWindow(
+                usedPercent: usedPercent,
+                windowMinutes: nil,
+                resetsAt: nil,
+                resetDescription: "\(clampedUsed) / \(total) predictions")
+        }
+    }
+
+    public static func displayPlanName(_ rawPlan: String) -> String {
+        switch rawPlan.lowercased() {
+        case "zed_free": "Zed Free"
+        case "zed_pro": "Zed Pro"
+        case "zed_pro_trial": "Zed Pro Trial"
+        case "zed_student": "Zed Student"
+        case "zed_business": "Zed Business"
+        default:
+            rawPlan
+                .replacingOccurrences(of: "_", with: " ")
+                .split(separator: " ")
+                .map { word in
+                    word.prefix(1).uppercased() + word.dropFirst().lowercased()
+                }
+                .joined(separator: " ")
+        }
+    }
+
+    private static func billingCycleUsedPercent(startedAt: Date, endedAt: Date) -> Double {
+        let now = Date()
+        let total = endedAt.timeIntervalSince(startedAt)
+        guard total > 0 else { return 0 }
+        let elapsed = now.timeIntervalSince(startedAt)
+        return max(0, min(100, elapsed / total * 100))
+    }
+
+    private static func formatResetDescription(_ date: Date) -> String? {
+        let now = Date()
+        let interval = date.timeIntervalSince(now)
+        guard interval > 0 else { return "Cycle ended" }
+
+        let hours = Int(interval / 3600)
+        let minutes = Int((interval.truncatingRemainder(dividingBy: 3600)) / 60)
+
+        if hours > 24 {
+            let days = hours / 24
+            let remainingHours = hours % 24
+            return "Cycle ends in \(days)d \(remainingHours)h"
+        } else if hours > 0 {
+            return "Cycle ends in \(hours)h \(minutes)m"
+        } else {
+            return "Cycle ends in \(minutes)m"
+        }
+    }
+}
+
+extension String {
+    fileprivate var nilIfEmpty: String? {
+        self.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty ? nil : self
+    }
+}
diff --git a/Sources/CodexBarCore/TokenAccountSupport.swift b/Sources/CodexBarCore/TokenAccountSupport.swift
index 378ad39392..37ec660a97 100644
--- a/Sources/CodexBarCore/TokenAccountSupport.swift
+++ b/Sources/CodexBarCore/TokenAccountSupport.swift
@@ -12,6 +12,7 @@ public struct TokenAccountSupport: Sendable {
     public let injection: TokenAccountInjection
     public let requiresManualCookieSource: Bool
     public let cookieName: String?
+    public let environmentKeysToScrub: [String]
 
     public init(
         title: String,
@@ -19,7 +20,8 @@ public struct TokenAccountSupport: Sendable {
         placeholder: String,
         injection: TokenAccountInjection,
         requiresManualCookieSource: Bool,
-        cookieName: String?)
+        cookieName: String?,
+        environmentKeysToScrub: [String] = [])
     {
         self.title = title
         self.subtitle = subtitle
@@ -27,6 +29,7 @@ public struct TokenAccountSupport: Sendable {
         self.injection = injection
         self.requiresManualCookieSource = requiresManualCookieSource
         self.cookieName = cookieName
+        self.environmentKeysToScrub = environmentKeysToScrub
     }
 }
 
@@ -42,15 +45,42 @@ public enum TokenAccountSupportCatalog {
             return [key: token]
         case .cookieHeader:
             if provider == .claude,
-               let normalized = self.normalizedClaudeOAuthToken(token),
-               self.isClaudeOAuthToken(normalized)
+               case let route = ClaudeCredentialRouting.resolve(tokenAccountToken: token, manualCookieHeader: nil)
             {
-                return [ClaudeOAuthCredentialsStore.environmentTokenKey: normalized]
+                switch route {
+                case let .oauth(accessToken):
+                    return [ClaudeOAuthCredentialsStore.environmentTokenKey: accessToken]
+                case let .adminAPIKey(apiKey):
+                    return [ClaudeAdminAPISettingsReader.adminAPIKeyEnvironmentKey: apiKey]
+                case .none, .webCookie:
+                    break
+                }
             }
             return nil
         }
     }
 
+    public static func scrubEnvironmentForSelectedAccount(
+        _ environment: inout [String: String],
+        provider: UsageProvider,
+        token _: String)
+    {
+        guard let support = self.support(for: provider) else { return }
+        switch support.injection {
+        case let .environment(key):
+            environment.removeValue(forKey: key)
+            for key in support.environmentKeysToScrub {
+                environment.removeValue(forKey: key)
+            }
+        case .cookieHeader:
+            guard provider == .claude else { return }
+            environment.removeValue(forKey: ClaudeOAuthCredentialsStore.environmentTokenKey)
+            for key in ClaudeAdminAPISettingsReader.apiKeyEnvironmentKeys {
+                environment.removeValue(forKey: key)
+            }
+        }
+    }
+
     public static func normalizedCookieHeader(for provider: UsageProvider, token: String) -> String {
         guard let support = self.support(for: provider) else {
             return token.trimmingCharacters(in: .whitespacesAndNewlines)
@@ -59,23 +89,7 @@ public enum TokenAccountSupportCatalog {
     }
 
     public static func isClaudeOAuthToken(_ token: String) -> Bool {
-        guard let trimmed = self.normalizedClaudeOAuthToken(token) else { return false }
-        let lower = trimmed.lowercased()
-        if lower.contains("cookie:") || trimmed.contains("=") {
-            return false
-        }
-        return lower.hasPrefix("sk-ant-oat")
-    }
-
-    private static func normalizedClaudeOAuthToken(_ token: String) -> String? {
-        let trimmed = token.trimmingCharacters(in: .whitespacesAndNewlines)
-        guard !trimmed.isEmpty else { return nil }
-        let lower = trimmed.lowercased()
-        if lower.hasPrefix("bearer ") {
-            return trimmed.dropFirst("bearer ".count)
-                .trimmingCharacters(in: .whitespacesAndNewlines)
-        }
-        return trimmed
+        ClaudeCredentialRouting.resolve(tokenAccountToken: token, manualCookieHeader: nil).isOAuth
     }
 
     public static func normalizedCookieHeader(_ token: String, support: TokenAccountSupport) -> String {
diff --git a/Sources/CodexBarCore/TokenAccountSupportCatalog+Data.swift b/Sources/CodexBarCore/TokenAccountSupportCatalog+Data.swift
index 2a1d0f1d46..4db3a50bca 100644
--- a/Sources/CodexBarCore/TokenAccountSupportCatalog+Data.swift
+++ b/Sources/CodexBarCore/TokenAccountSupportCatalog+Data.swift
@@ -2,13 +2,35 @@ import Foundation
 
 extension TokenAccountSupportCatalog {
     static let supportByProvider: [UsageProvider: TokenAccountSupport] = [
+        .openai: TokenAccountSupport(
+            title: "API keys",
+            subtitle: "Store multiple OpenAI API keys.",
+            placeholder: "sk-admin-...",
+            injection: .environment(key: OpenAIAPISettingsReader.adminAPIKeyEnvironmentKey),
+            requiresManualCookieSource: false,
+            cookieName: nil,
+            environmentKeysToScrub: [OpenAIAPISettingsReader.projectIDEnvironmentKey]),
         .claude: TokenAccountSupport(
-            title: "Session tokens",
-            subtitle: "Store Claude sessionKey cookies or OAuth access tokens.",
-            placeholder: "Paste sessionKey or OAuth token…",
+            title: "Claude credentials",
+            subtitle: "Store Claude sessionKey cookies, OAuth tokens, or Anthropic Admin API keys.",
+            placeholder: "Paste sessionKey, OAuth token, or sk-ant-admin…",
             injection: .cookieHeader,
             requiresManualCookieSource: true,
             cookieName: "sessionKey"),
+        .deepseek: TokenAccountSupport(
+            title: "API tokens",
+            subtitle: "Store multiple DeepSeek API keys.",
+            placeholder: "Paste API key…",
+            injection: .environment(key: DeepSeekSettingsReader.apiKeyEnvironmentKey),
+            requiresManualCookieSource: false,
+            cookieName: nil),
+        .antigravity: TokenAccountSupport(
+            title: "Google accounts",
+            subtitle: "Store multiple Antigravity Google OAuth accounts for quick switching.",
+            placeholder: "Antigravity OAuth credentials JSON",
+            injection: .environment(key: AntigravityOAuthCredentialsStore.environmentCredentialsKey),
+            requiresManualCookieSource: false,
+            cookieName: nil),
         .zai: TokenAccountSupport(
             title: "API tokens",
             subtitle: "Stored in the CodexBar config file.",
@@ -30,13 +52,20 @@ extension TokenAccountSupportCatalog {
             injection: .cookieHeader,
             requiresManualCookieSource: true,
             cookieName: nil),
-        .factory: TokenAccountSupport(
+        .opencodego: TokenAccountSupport(
             title: "Session tokens",
-            subtitle: "Store multiple Factory Cookie headers.",
+            subtitle: "Store multiple OpenCode Go Cookie headers.",
             placeholder: "Cookie: …",
             injection: .cookieHeader,
             requiresManualCookieSource: true,
             cookieName: nil),
+        .factory: TokenAccountSupport(
+            title: "Session tokens",
+            subtitle: "Store multiple Factory Cookie or Authorization headers.",
+            placeholder: "Cookie: … or Authorization: Bearer …",
+            injection: .cookieHeader,
+            requiresManualCookieSource: true,
+            cookieName: nil),
         .minimax: TokenAccountSupport(
             title: "Session tokens",
             subtitle: "Store multiple MiniMax Cookie headers.",
@@ -44,6 +73,13 @@ extension TokenAccountSupportCatalog {
             injection: .cookieHeader,
             requiresManualCookieSource: true,
             cookieName: nil),
+        .manus: TokenAccountSupport(
+            title: "Session tokens",
+            subtitle: "Store multiple Manus session_id cookies.",
+            placeholder: "session_id=…",
+            injection: .cookieHeader,
+            requiresManualCookieSource: true,
+            cookieName: "session_id"),
         .augment: TokenAccountSupport(
             title: "Session tokens",
             subtitle: "Store multiple Augment Cookie headers.",
@@ -58,5 +94,68 @@ extension TokenAccountSupportCatalog {
             injection: .cookieHeader,
             requiresManualCookieSource: true,
             cookieName: nil),
+        .abacus: TokenAccountSupport(
+            title: "Session tokens",
+            subtitle: "Store multiple Abacus AI Cookie headers.",
+            placeholder: "Cookie: …",
+            injection: .cookieHeader,
+            requiresManualCookieSource: true,
+            cookieName: nil),
+        .mistral: TokenAccountSupport(
+            title: "Session tokens",
+            subtitle: "Store multiple Mistral Cookie headers.",
+            placeholder: "Cookie: …",
+            injection: .cookieHeader,
+            requiresManualCookieSource: true,
+            cookieName: nil),
+        .copilot: TokenAccountSupport(
+            title: "GitHub accounts",
+            subtitle: "Sign in with multiple GitHub accounts via OAuth.",
+            placeholder: "Paste GitHub token…",
+            injection: .environment(key: "COPILOT_API_TOKEN"),
+            requiresManualCookieSource: false,
+            cookieName: nil),
+        .venice: TokenAccountSupport(
+            title: "API tokens",
+            subtitle: "Store multiple Venice API keys.",
+            placeholder: "Paste API key…",
+            injection: .environment(key: VeniceSettingsReader.apiKeyEnvironmentKey),
+            requiresManualCookieSource: false,
+            cookieName: nil),
+        .elevenlabs: TokenAccountSupport(
+            title: "API keys",
+            subtitle: "Store multiple ElevenLabs API keys.",
+            placeholder: "Paste API key…",
+            injection: .environment(key: ElevenLabsSettingsReader.apiKeyEnvironmentKey),
+            requiresManualCookieSource: false,
+            cookieName: nil),
+        .groq: TokenAccountSupport(
+            title: "API keys",
+            subtitle: "Store multiple Groq API keys.",
+            placeholder: "Paste Groq API key…",
+            injection: .environment(key: GroqSettingsReader.apiKeyEnvironmentKey),
+            requiresManualCookieSource: false,
+            cookieName: nil),
+        .llmproxy: TokenAccountSupport(
+            title: "API keys",
+            subtitle: "Store multiple LLM Proxy API keys.",
+            placeholder: "Paste proxy API key…",
+            injection: .environment(key: LLMProxySettingsReader.apiKeyEnvironmentKey),
+            requiresManualCookieSource: false,
+            cookieName: nil),
+        .litellm: TokenAccountSupport(
+            title: "API keys",
+            subtitle: "Store multiple LiteLLM API keys.",
+            placeholder: "Paste LiteLLM API key…",
+            injection: .environment(key: LiteLLMSettingsReader.apiKeyEnvironmentKey),
+            requiresManualCookieSource: false,
+            cookieName: nil),
+        .stepfun: TokenAccountSupport(
+            title: "Session tokens",
+            subtitle: "Store multiple StepFun Oasis-Token values.",
+            placeholder: "Oasis-Token=…",
+            injection: .cookieHeader,
+            requiresManualCookieSource: true,
+            cookieName: nil),
     ]
 }
diff --git a/Sources/CodexBarCore/TokenAccounts.swift b/Sources/CodexBarCore/TokenAccounts.swift
index 519386aec1..73110d28de 100644
--- a/Sources/CodexBarCore/TokenAccounts.swift
+++ b/Sources/CodexBarCore/TokenAccounts.swift
@@ -6,18 +6,53 @@ public struct ProviderTokenAccount: Codable, Identifiable, Sendable {
     public let token: String
     public let addedAt: TimeInterval
     public let lastUsed: TimeInterval?
+    /// Stable provider-specific identity (e.g. GitHub `login`) used for
+    /// re-auth deduplication. Optional so legacy accounts keep working.
+    public let externalIdentifier: String?
+    /// Optional provider-specific organization/workspace target. Claude web
+    /// sessionKey accounts use this to disambiguate linked Anthropic emails.
+    public let organizationID: String?
 
-    public init(id: UUID, label: String, token: String, addedAt: TimeInterval, lastUsed: TimeInterval?) {
+    enum CodingKeys: String, CodingKey {
+        case id
+        case label
+        case token
+        case addedAt
+        case lastUsed
+        case externalIdentifier
+        case organizationID = "organizationId"
+    }
+
+    public init(
+        id: UUID,
+        label: String,
+        token: String,
+        addedAt: TimeInterval,
+        lastUsed: TimeInterval?,
+        externalIdentifier: String? = nil,
+        organizationID: String? = nil)
+    {
         self.id = id
         self.label = label
         self.token = token
         self.addedAt = addedAt
         self.lastUsed = lastUsed
+        self.externalIdentifier = externalIdentifier
+        self.organizationID = organizationID
     }
 
     public var displayName: String {
         self.label
     }
+
+    public var sanitizedOrganizationID: String? {
+        Self.clean(self.organizationID)
+    }
+
+    private static func clean(_ raw: String?) -> String? {
+        let trimmed = raw?.trimmingCharacters(in: .whitespacesAndNewlines)
+        return (trimmed?.isEmpty ?? true) ? nil : trimmed
+    }
 }
 
 public struct ProviderTokenAccountData: Codable, Sendable {
diff --git a/Sources/CodexBarCore/UsageFetcher.swift b/Sources/CodexBarCore/UsageFetcher.swift
index f2370e9cac..ed82715c57 100644
--- a/Sources/CodexBarCore/UsageFetcher.swift
+++ b/Sources/CodexBarCore/UsageFetcher.swift
@@ -6,17 +6,87 @@ public struct RateWindow: Codable, Equatable, Sendable {
     public let resetsAt: Date?
     /// Optional textual reset description (used by Claude CLI UI scrape).
     public let resetDescription: String?
+    /// Optional percent restored on the next regeneration tick for providers with rolling recovery.
+    public let nextRegenPercent: Double?
 
-    public init(usedPercent: Double, windowMinutes: Int?, resetsAt: Date?, resetDescription: String?) {
+    public init(
+        usedPercent: Double,
+        windowMinutes: Int?,
+        resetsAt: Date?,
+        resetDescription: String?,
+        nextRegenPercent: Double? = nil)
+    {
         self.usedPercent = usedPercent
         self.windowMinutes = windowMinutes
         self.resetsAt = resetsAt
         self.resetDescription = resetDescription
+        self.nextRegenPercent = nextRegenPercent
     }
 
     public var remainingPercent: Double {
         max(0, 100 - self.usedPercent)
     }
+
+    public func backfillingResetTime(from cached: RateWindow?, now: Date = .init()) -> RateWindow {
+        if self.resetsAt != nil { return self }
+        guard let cachedReset = cached?.resetsAt, cachedReset > now else { return self }
+        let windowMinutes = if let windowMinutes = self.windowMinutes, windowMinutes > 0 {
+            windowMinutes
+        } else {
+            cached?.windowMinutes
+        }
+        return RateWindow(
+            usedPercent: self.usedPercent,
+            windowMinutes: windowMinutes,
+            resetsAt: cachedReset,
+            resetDescription: self.resetDescription ?? cached?.resetDescription,
+            nextRegenPercent: self.nextRegenPercent)
+    }
+}
+
+public struct NamedRateWindow: Codable, Equatable, Sendable {
+    public let id: String
+    public let title: String
+    public let window: RateWindow
+    /// Whether `window.usedPercent` reflects known quota usage.
+    ///
+    /// Some providers expose reset metadata for a named quota window before
+    /// they expose remaining usage. Keep those windows visible for reset/debug
+    /// context, but mark them so clients do not render `usedPercent` as a real
+    /// exhausted quota. Missing values decode as `true` for older cached payloads.
+    public let usageKnown: Bool
+
+    public init(id: String, title: String, window: RateWindow, usageKnown: Bool = true) {
+        self.id = id
+        self.title = title
+        self.window = window
+        self.usageKnown = usageKnown
+    }
+
+    private enum CodingKeys: String, CodingKey {
+        case id
+        case title
+        case window
+        case usageKnown
+    }
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.id = try container.decode(String.self, forKey: .id)
+        self.title = try container.decode(String.self, forKey: .title)
+        self.window = try container.decode(RateWindow.self, forKey: .window)
+        self.usageKnown = try container.decodeIfPresent(Bool.self, forKey: .usageKnown) ?? true
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encode(self.id, forKey: .id)
+        try container.encode(self.title, forKey: .title)
+        try container.encode(self.window, forKey: .window)
+        if !self.usageKnown {
+            try container.encode(false, forKey: .usageKnown)
+        }
+    }
 }
 
 public struct ProviderIdentitySnapshot: Codable, Sendable {
@@ -47,26 +117,66 @@ public struct ProviderIdentitySnapshot: Codable, Sendable {
     }
 }
 
+public enum UsageDataConfidence: String, Codable, Equatable, Sendable {
+    case exact
+    case estimated
+    case percentOnly
+    case unknown
+}
+
 public struct UsageSnapshot: Codable, Sendable {
     public let primary: RateWindow?
     public let secondary: RateWindow?
     public let tertiary: RateWindow?
+    public let extraRateWindows: [NamedRateWindow]?
     public let providerCost: ProviderCostSnapshot?
+    public let kiroUsage: KiroUsageDetails?
+    public let ampUsage: AmpUsageDetails?
     public let zaiUsage: ZaiUsageSnapshot?
     public let minimaxUsage: MiniMaxUsageSnapshot?
+    public let deepseekUsage: DeepSeekUsageSummary?
+    public let mimoUsage: MiMoUsageSnapshot?
     public let openRouterUsage: OpenRouterUsageSnapshot?
+    public let openAIAPIUsage: OpenAIAPIUsageSnapshot?
+    public let codexResetCredits: CodexRateLimitResetCreditsSnapshot?
+    public let claudeAdminAPIUsage: ClaudeAdminAPIUsageSnapshot?
+    public let mistralUsage: MistralUsageSnapshot?
+    public let deepgramUsage: DeepgramUsageSnapshot?
+    public let poeUsage: PoeUsageHistorySnapshot?
     public let cursorRequests: CursorRequestUsage?
+    /// Live-only marker for optional Command Code subscription lookup failure.
+    public let commandCodeSubscriptionEnrichmentUnavailable: Bool
+    /// Live-only marker that Command Code returned a recognized subscription plan.
+    public let commandCodeHasSubscriptionPlan: Bool
+    /// Live-only marker that Command Code's monthly grant has no remaining credits.
+    public let commandCodeMonthlyGrantDepleted: Bool
+    public let subscriptionExpiresAt: Date?
+    public let subscriptionRenewsAt: Date?
     public let updatedAt: Date
     public let identity: ProviderIdentitySnapshot?
+    public let dataConfidence: UsageDataConfidence
 
     private enum CodingKeys: String, CodingKey {
         case primary
         case secondary
         case tertiary
+        case extraRateWindows
         case providerCost
+        case kiroUsage
+        case ampUsage
+        case mimoUsage
         case openRouterUsage
+        case openAIAPIUsage
+        case codexResetCredits
+        case claudeAdminAPIUsage
+        case mistralUsage
+        case deepgramUsage
+        case poeUsage
+        case subscriptionExpiresAt
+        case subscriptionRenewsAt
         case updatedAt
         case identity
+        case dataConfidence
         case accountEmail
         case accountOrganization
         case loginMethod
@@ -76,24 +186,72 @@ public struct UsageSnapshot: Codable, Sendable {
         primary: RateWindow?,
         secondary: RateWindow?,
         tertiary: RateWindow? = nil,
+        extraRateWindows: [NamedRateWindow]? = nil,
+        kiroUsage: KiroUsageDetails? = nil,
+        ampUsage: AmpUsageDetails? = nil,
         providerCost: ProviderCostSnapshot? = nil,
         zaiUsage: ZaiUsageSnapshot? = nil,
         minimaxUsage: MiniMaxUsageSnapshot? = nil,
+        deepseekUsage: DeepSeekUsageSummary? = nil,
+        mimoUsage: MiMoUsageSnapshot? = nil,
         openRouterUsage: OpenRouterUsageSnapshot? = nil,
+        openAIAPIUsage: OpenAIAPIUsageSnapshot? = nil,
+        codexResetCredits: CodexRateLimitResetCreditsSnapshot? = nil,
+        claudeAdminAPIUsage: ClaudeAdminAPIUsageSnapshot? = nil,
+        mistralUsage: MistralUsageSnapshot? = nil,
+        deepgramUsage: DeepgramUsageSnapshot? = nil,
+        poeUsage: PoeUsageHistorySnapshot? = nil,
         cursorRequests: CursorRequestUsage? = nil,
+        commandCodeSubscriptionEnrichmentUnavailable: Bool = false,
+        commandCodeHasSubscriptionPlan: Bool = false,
+        commandCodeMonthlyGrantDepleted: Bool = false,
+        subscriptionExpiresAt: Date? = nil,
+        subscriptionRenewsAt: Date? = nil,
         updatedAt: Date,
-        identity: ProviderIdentitySnapshot? = nil)
+        identity: ProviderIdentitySnapshot? = nil,
+        dataConfidence: UsageDataConfidence = .unknown)
     {
         self.primary = primary
         self.secondary = secondary
         self.tertiary = tertiary
+        self.extraRateWindows = extraRateWindows
+        self.kiroUsage = kiroUsage
+        self.ampUsage = ampUsage
         self.providerCost = providerCost
         self.zaiUsage = zaiUsage
         self.minimaxUsage = minimaxUsage
+        self.deepseekUsage = deepseekUsage
+        self.mimoUsage = mimoUsage
         self.openRouterUsage = openRouterUsage
+        self.openAIAPIUsage = openAIAPIUsage
+        self.codexResetCredits = codexResetCredits
+        self.claudeAdminAPIUsage = claudeAdminAPIUsage
+        self.mistralUsage = mistralUsage
+        self.deepgramUsage = deepgramUsage
+        self.poeUsage = poeUsage
         self.cursorRequests = cursorRequests
+        self.commandCodeSubscriptionEnrichmentUnavailable = commandCodeSubscriptionEnrichmentUnavailable
+        self.commandCodeHasSubscriptionPlan = commandCodeHasSubscriptionPlan
+        self.commandCodeMonthlyGrantDepleted = commandCodeMonthlyGrantDepleted
+        self.subscriptionExpiresAt = subscriptionExpiresAt
+        self.subscriptionRenewsAt = subscriptionRenewsAt
         self.updatedAt = updatedAt
         self.identity = identity
+        self.dataConfidence = dataConfidence
+    }
+
+    public func with(extraRateWindows: [NamedRateWindow]?) -> UsageSnapshot {
+        self.replacing(extraRateWindows: .value(extraRateWindows))
+    }
+
+    public func withCodexResetCredits(_ resetCredits: CodexRateLimitResetCreditsSnapshot?) -> UsageSnapshot {
+        self.replacing(codexResetCredits: .value(resetCredits))
+    }
+
+    public func with(primary: RateWindow?, secondary: RateWindow?) -> UsageSnapshot {
+        self.replacing(
+            primary: .value(primary),
+            secondary: .value(secondary))
     }
 
     public init(from decoder: Decoder) throws {
@@ -101,12 +259,37 @@ public struct UsageSnapshot: Codable, Sendable {
         self.primary = try container.decodeIfPresent(RateWindow.self, forKey: .primary)
         self.secondary = try container.decodeIfPresent(RateWindow.self, forKey: .secondary)
         self.tertiary = try container.decodeIfPresent(RateWindow.self, forKey: .tertiary)
+        self.extraRateWindows = try container.decodeIfPresent([NamedRateWindow].self, forKey: .extraRateWindows)
         self.providerCost = try container.decodeIfPresent(ProviderCostSnapshot.self, forKey: .providerCost)
+        self.kiroUsage = try container.decodeIfPresent(KiroUsageDetails.self, forKey: .kiroUsage)
+        self.ampUsage = try container.decodeIfPresent(AmpUsageDetails.self, forKey: .ampUsage)
         self.zaiUsage = nil // Not persisted, fetched fresh each time
         self.minimaxUsage = nil // Not persisted, fetched fresh each time
+        self.deepseekUsage = nil // Not persisted, fetched fresh each time
+        self.mimoUsage = try container.decodeIfPresent(MiMoUsageSnapshot.self, forKey: .mimoUsage)
         self.openRouterUsage = try container.decodeIfPresent(OpenRouterUsageSnapshot.self, forKey: .openRouterUsage)
+        self.openAIAPIUsage = try container.decodeIfPresent(OpenAIAPIUsageSnapshot.self, forKey: .openAIAPIUsage)
+        self.codexResetCredits = try container.decodeIfPresent(
+            CodexRateLimitResetCreditsSnapshot.self,
+            forKey: .codexResetCredits)
+        self.claudeAdminAPIUsage = try container.decodeIfPresent(
+            ClaudeAdminAPIUsageSnapshot.self,
+            forKey: .claudeAdminAPIUsage)
+        self.mistralUsage = try container.decodeIfPresent(MistralUsageSnapshot.self, forKey: .mistralUsage)
+        self.deepgramUsage = try container.decodeIfPresent(DeepgramUsageSnapshot.self, forKey: .deepgramUsage)
+        self.poeUsage = try container.decodeIfPresent(PoeUsageHistorySnapshot.self, forKey: .poeUsage)
         self.cursorRequests = nil // Not persisted, fetched fresh each time
+        self.commandCodeSubscriptionEnrichmentUnavailable = false // Live-only fetch state
+        self.commandCodeHasSubscriptionPlan = false // Live-only fetch state
+        self.commandCodeMonthlyGrantDepleted = false // Live-only fetch state
+        self.subscriptionExpiresAt = try container.decodeIfPresent(Date.self, forKey: .subscriptionExpiresAt)
+        self.subscriptionRenewsAt = try container.decodeIfPresent(Date.self, forKey: .subscriptionRenewsAt)
         self.updatedAt = try container.decode(Date.self, forKey: .updatedAt)
+        if let dataConfidence = try container.decodeIfPresent(String.self, forKey: .dataConfidence) {
+            self.dataConfidence = UsageDataConfidence(rawValue: dataConfidence) ?? .unknown
+        } else {
+            self.dataConfidence = .unknown
+        }
         if let identity = try container.decodeIfPresent(ProviderIdentitySnapshot.self, forKey: .identity) {
             self.identity = identity
         } else {
@@ -131,10 +314,25 @@ public struct UsageSnapshot: Codable, Sendable {
         try container.encode(self.primary, forKey: .primary)
         try container.encode(self.secondary, forKey: .secondary)
         try container.encode(self.tertiary, forKey: .tertiary)
+        try container.encodeIfPresent(self.extraRateWindows, forKey: .extraRateWindows)
         try container.encodeIfPresent(self.providerCost, forKey: .providerCost)
+        try container.encodeIfPresent(self.kiroUsage, forKey: .kiroUsage)
+        try container.encodeIfPresent(self.ampUsage, forKey: .ampUsage)
+        try container.encodeIfPresent(self.mimoUsage, forKey: .mimoUsage)
         try container.encodeIfPresent(self.openRouterUsage, forKey: .openRouterUsage)
+        try container.encodeIfPresent(self.openAIAPIUsage, forKey: .openAIAPIUsage)
+        try container.encodeIfPresent(self.codexResetCredits, forKey: .codexResetCredits)
+        try container.encodeIfPresent(self.claudeAdminAPIUsage, forKey: .claudeAdminAPIUsage)
+        try container.encodeIfPresent(self.mistralUsage, forKey: .mistralUsage)
+        try container.encodeIfPresent(self.deepgramUsage, forKey: .deepgramUsage)
+        try container.encodeIfPresent(self.poeUsage, forKey: .poeUsage)
+        try container.encodeIfPresent(self.subscriptionExpiresAt, forKey: .subscriptionExpiresAt)
+        try container.encodeIfPresent(self.subscriptionRenewsAt, forKey: .subscriptionRenewsAt)
         try container.encode(self.updatedAt, forKey: .updatedAt)
         try container.encodeIfPresent(self.identity, forKey: .identity)
+        if self.dataConfidence != .unknown {
+            try container.encode(self.dataConfidence, forKey: .dataConfidence)
+        }
         try container.encodeIfPresent(self.identity?.accountEmail, forKey: .accountEmail)
         try container.encodeIfPresent(self.identity?.accountOrganization, forKey: .accountOrganization)
         try container.encodeIfPresent(self.identity?.loginMethod, forKey: .loginMethod)
@@ -145,20 +343,51 @@ public struct UsageSnapshot: Codable, Sendable {
         return identity
     }
 
+    public func automaticPerplexityWindow() -> RateWindow? {
+        let fallbackWindows = self.orderedPerplexityFallbackWindows()
+        guard let primary = self.primary else {
+            return fallbackWindows.first
+        }
+        if primary.remainingPercent > 0 || fallbackWindows.isEmpty {
+            return primary
+        }
+        return fallbackWindows.first
+    }
+
+    public func orderedPerplexityDisplayWindows() -> [RateWindow] {
+        let fallbackWindows = self.orderedPerplexityFallbackWindows()
+        guard let primary = self.primary else {
+            return fallbackWindows
+        }
+        if primary.remainingPercent > 0 || fallbackWindows.isEmpty {
+            return [primary] + fallbackWindows
+        }
+        return fallbackWindows + [primary]
+    }
+
     public func switcherWeeklyWindow(for provider: UsageProvider, showUsed: Bool) -> RateWindow? {
         switch provider {
         case .factory:
             // Factory prefers secondary window
             return self.secondary ?? self.primary
+        case .perplexity:
+            return self.automaticPerplexityWindow()
         case .cursor:
-            // Cursor: fall back to On-Demand when Plan is exhausted (only in "show remaining" mode).
-            // In "show used" mode, keep showing primary so 100% used Plan is visible.
+            // Cursor: fall back to on-demand budget when the included plan is exhausted (only in
+            // "show remaining" mode). The secondary/tertiary lanes are Total/Auto/API breakdowns,
+            // not extra capacity, so they should not replace the remaining paid quota indicator.
             if !showUsed,
                let primary = self.primary,
                primary.remainingPercent <= 0,
-               let secondary = self.secondary
+               let providerCost = self.providerCost,
+               providerCost.limit > 0
             {
-                return secondary
+                let usedPercent = max(0, min(100, (providerCost.used / providerCost.limit) * 100))
+                return RateWindow(
+                    usedPercent: usedPercent,
+                    windowMinutes: nil,
+                    resetsAt: providerCost.resetsAt,
+                    resetDescription: nil)
             }
             return self.primary ?? self.secondary
         default:
@@ -178,19 +407,21 @@ public struct UsageSnapshot: Codable, Sendable {
         self.identity(for: provider)?.loginMethod
     }
 
-    /// Keep this initializer-style copy in sync with UsageSnapshot fields so relabeling/scoping never drops data.
+    public var hasRateLimitWindows: Bool {
+        self.primary != nil || self.secondary != nil || self.tertiary != nil ||
+            !(self.extraRateWindows?.isEmpty ?? true)
+    }
+
+    public func rateLimitsUnavailable(for provider: UsageProvider) -> Bool {
+        UsageLimitsAvailability.resolve(provider: provider, snapshot: self).isUnavailable
+    }
+
     public func withIdentity(_ identity: ProviderIdentitySnapshot?) -> UsageSnapshot {
-        UsageSnapshot(
-            primary: self.primary,
-            secondary: self.secondary,
-            tertiary: self.tertiary,
-            providerCost: self.providerCost,
-            zaiUsage: self.zaiUsage,
-            minimaxUsage: self.minimaxUsage,
-            openRouterUsage: self.openRouterUsage,
-            cursorRequests: self.cursorRequests,
-            updatedAt: self.updatedAt,
-            identity: identity)
+        self.replacing(identity: .value(identity))
+    }
+
+    public func withDataConfidence(_ dataConfidence: UsageDataConfidence) -> UsageSnapshot {
+        self.replacing(dataConfidence: .value(dataConfidence))
     }
 
     public func scoped(to provider: UsageProvider) -> UsageSnapshot {
@@ -199,18 +430,117 @@ public struct UsageSnapshot: Codable, Sendable {
         if scopedIdentity.providerID == identity.providerID { return self }
         return self.withIdentity(scopedIdentity)
     }
+
+    public func backfillingResetTimes(from cached: UsageSnapshot?, now: Date = .init()) -> UsageSnapshot {
+        guard let cached else { return self }
+        guard Self.identitiesMatch(self.identity, cached.identity) else { return self }
+        let primary = self.primary?.backfillingResetTime(from: cached.primary, now: now)
+        let secondary = self.secondary?.backfillingResetTime(from: cached.secondary, now: now)
+        let tertiary = self.tertiary?.backfillingResetTime(from: cached.tertiary, now: now)
+        if primary == self.primary, secondary == self.secondary, tertiary == self.tertiary {
+            return self
+        }
+        return self.replacing(
+            primary: .value(primary),
+            secondary: .value(secondary),
+            tertiary: .value(tertiary))
+    }
+
+    private func orderedPerplexityFallbackWindows() -> [RateWindow] {
+        let fallbackWindows = [self.tertiary, self.secondary].compactMap(\.self)
+        let usableFallback = fallbackWindows.filter { $0.remainingPercent > 0 }
+        let exhaustedFallback = fallbackWindows.filter { $0.remainingPercent <= 0 }
+        return usableFallback + exhaustedFallback
+    }
+
+    private static func identitiesMatch(_ lhs: ProviderIdentitySnapshot?, _ rhs: ProviderIdentitySnapshot?) -> Bool {
+        if lhs == nil, rhs == nil { return true }
+        guard let lhs, let rhs else { return false }
+        let lhsEmail = lhs.accountEmail?.trimmingCharacters(in: .whitespacesAndNewlines)
+        let rhsEmail = rhs.accountEmail?.trimmingCharacters(in: .whitespacesAndNewlines)
+        if let lhsEmail, let rhsEmail, !lhsEmail.isEmpty, !rhsEmail.isEmpty {
+            return lhsEmail == rhsEmail
+        }
+        return true
+    }
+
+    private enum Replacement<Value> {
+        case unchanged
+        case value(Value)
+
+        func resolving(_ current: Value) -> Value {
+            switch self {
+            case .unchanged: current
+            case let .value(value): value
+            }
+        }
+    }
+
+    private func replacing(
+        primary: Replacement<RateWindow?> = .unchanged,
+        secondary: Replacement<RateWindow?> = .unchanged,
+        tertiary: Replacement<RateWindow?> = .unchanged,
+        extraRateWindows: Replacement<[NamedRateWindow]?> = .unchanged,
+        codexResetCredits: Replacement<CodexRateLimitResetCreditsSnapshot?> = .unchanged,
+        identity: Replacement<ProviderIdentitySnapshot?> = .unchanged,
+        dataConfidence: Replacement<UsageDataConfidence> = .unchanged) -> UsageSnapshot
+    {
+        UsageSnapshot(
+            primary: primary.resolving(self.primary),
+            secondary: secondary.resolving(self.secondary),
+            tertiary: tertiary.resolving(self.tertiary),
+            extraRateWindows: extraRateWindows.resolving(self.extraRateWindows),
+            kiroUsage: self.kiroUsage,
+            ampUsage: self.ampUsage,
+            providerCost: self.providerCost,
+            zaiUsage: self.zaiUsage,
+            minimaxUsage: self.minimaxUsage,
+            deepseekUsage: self.deepseekUsage,
+            mimoUsage: self.mimoUsage,
+            openRouterUsage: self.openRouterUsage,
+            openAIAPIUsage: self.openAIAPIUsage,
+            codexResetCredits: codexResetCredits.resolving(self.codexResetCredits),
+            claudeAdminAPIUsage: self.claudeAdminAPIUsage,
+            mistralUsage: self.mistralUsage,
+            deepgramUsage: self.deepgramUsage,
+            poeUsage: self.poeUsage,
+            cursorRequests: self.cursorRequests,
+            commandCodeSubscriptionEnrichmentUnavailable: self.commandCodeSubscriptionEnrichmentUnavailable,
+            commandCodeHasSubscriptionPlan: self.commandCodeHasSubscriptionPlan,
+            commandCodeMonthlyGrantDepleted: self.commandCodeMonthlyGrantDepleted,
+            subscriptionExpiresAt: self.subscriptionExpiresAt,
+            subscriptionRenewsAt: self.subscriptionRenewsAt,
+            updatedAt: self.updatedAt,
+            identity: identity.resolving(self.identity),
+            dataConfidence: dataConfidence.resolving(self.dataConfidence))
+    }
 }
 
 public struct AccountInfo: Equatable, Sendable {
     public let email: String?
     public let plan: String?
 
+    public var hasIdentity: Bool {
+        self.email?.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty == false ||
+            self.plan?.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty == false
+    }
+
     public init(email: String?, plan: String?) {
         self.email = email
         self.plan = plan
     }
 }
 
+public struct CodexCLIAccountSnapshot: Sendable {
+    public let usage: UsageSnapshot?
+    public let credits: CreditsSnapshot?
+
+    public init(usage: UsageSnapshot?, credits: CreditsSnapshot?) {
+        self.usage = usage
+        self.credits = credits
+    }
+}
+
 public enum UsageError: LocalizedError, Sendable {
     case noSessions
     case noRateLimitsFound
@@ -226,6 +556,49 @@ public enum UsageError: LocalizedError, Sendable {
             "Could not parse Codex session log."
         }
     }
+
+    public static func isNoRateLimitsFoundDescription(_ text: String?) -> Bool {
+        text?.trimmingCharacters(in: .whitespacesAndNewlines) == UsageError.noRateLimitsFound.errorDescription
+    }
+}
+
+public enum UsageLimitsAvailability: Equatable, Sendable {
+    case available
+    case unavailable
+
+    public var isUnavailable: Bool {
+        self == .unavailable
+    }
+
+    public static func resolve(
+        provider: UsageProvider,
+        snapshot: UsageSnapshot?,
+        account: AccountInfo? = nil,
+        lastErrorDescription: String? = nil) -> Self
+    {
+        if provider == .doubao || provider == .antigravity {
+            guard let snapshot,
+                  snapshot.identity(for: provider) != nil
+            else {
+                return .available
+            }
+            return snapshot.hasRateLimitWindows ? .available : .unavailable
+        }
+
+        guard provider == .codex else { return .available }
+
+        if let snapshot {
+            guard snapshot.identity(for: provider) != nil else { return .available }
+            return snapshot.hasRateLimitWindows ? .available : .unavailable
+        }
+
+        guard UsageError.isNoRateLimitsFoundDescription(lastErrorDescription),
+              account?.hasIdentity == true
+        else {
+            return .available
+        }
+        return .unavailable
+    }
 }
 
 // MARK: - Codex RPC client (local process)
@@ -272,6 +645,7 @@ private struct RPCRateLimitSnapshot: Decodable, Encodable {
     let primary: RPCRateLimitWindow?
     let secondary: RPCRateLimitWindow?
     let credits: RPCCreditsSnapshot?
+    let planType: String?
 }
 
 private struct RPCRateLimitWindow: Decodable, Encodable {
@@ -286,10 +660,25 @@ private struct RPCCreditsSnapshot: Decodable, Encodable {
     let balance: String?
 }
 
-private enum RPCWireError: Error, LocalizedError {
+private struct RPCRateLimitsErrorBody: Decodable {
+    let email: String?
+    let planType: String?
+    let rateLimit: CodexUsageResponse.RateLimitDetails?
+    let credits: CodexUsageResponse.CreditDetails?
+
+    enum CodingKeys: String, CodingKey {
+        case email
+        case planType = "plan_type"
+        case rateLimit = "rate_limit"
+        case credits
+    }
+}
+
+enum RPCWireError: Error, LocalizedError {
     case startFailed(String)
     case requestFailed(String)
     case malformed(String)
+    case timeout(method: String)
 
     var errorDescription: String? {
         switch self {
@@ -299,10 +688,19 @@ private enum RPCWireError: Error, LocalizedError {
             "Codex connection failed: \(message)"
         case let .malformed(message):
             "Codex returned invalid data: \(message)"
+        case let .timeout(method):
+            "Codex RPC timed out waiting for `\(method)` reply."
         }
     }
 }
 
+typealias CodexExecutableResolver = @Sendable (_ environment: [String: String], _ executable: String) -> String?
+
+let defaultCodexExecutableResolver: CodexExecutableResolver = { environment, executable in
+    BinaryLocator.resolveCodexBinary(env: environment)
+        ?? TTYCommandRunner.which(executable)
+}
+
 /// RPC helper used on background tasks; safe because we confine it to the owning task.
 private final class CodexRPCClient: @unchecked Sendable {
     private static let log = CodexBarLog.logger(LogCategories.codexRPC)
@@ -313,6 +711,8 @@ private final class CodexRPCClient: @unchecked Sendable {
     private let stdoutLineStream: AsyncStream<Data>
     private let stdoutLineContinuation: AsyncStream<Data>.Continuation
     private var nextID = 1
+    private let initializeTimeoutSeconds: TimeInterval
+    private let requestTimeoutSeconds: TimeInterval
 
     private final class LineBuffer: @unchecked Sendable {
         private let lock = NSLock()
@@ -343,23 +743,27 @@ private final class CodexRPCClient: @unchecked Sendable {
 
     init(
         executable: String = "codex",
-        arguments: [String] = ["-s", "read-only", "-a", "untrusted", "app-server"]) throws
+        arguments: [String] = ["-s", "read-only", "-a", "untrusted", "app-server"],
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        initializeTimeoutSeconds: TimeInterval = 8.0,
+        requestTimeoutSeconds: TimeInterval = 3.0,
+        resolveExecutable: CodexExecutableResolver = defaultCodexExecutableResolver) throws
     {
+        self.initializeTimeoutSeconds = initializeTimeoutSeconds
+        self.requestTimeoutSeconds = requestTimeoutSeconds
         var stdoutContinuation: AsyncStream<Data>.Continuation!
         self.stdoutLineStream = AsyncStream<Data> { continuation in
             stdoutContinuation = continuation
         }
         self.stdoutLineContinuation = stdoutContinuation
 
-        let resolvedExec = BinaryLocator.resolveCodexBinary()
-            ?? TTYCommandRunner.which(executable)
+        let resolvedExec = resolveExecutable(environment, executable)
 
         guard let resolvedExec else {
             Self.log.warning("Codex RPC binary not found", metadata: ["binary": executable])
-            throw RPCWireError.startFailed(
-                "Codex CLI not found. Install with `npm i -g @openai/codex` (or bun) then relaunch CodexBar.")
+            throw CodexStatusProbeError.codexNotInstalled
         }
-        var env = ProcessInfo.processInfo.environment
+        var env = environment
         env["PATH"] = PathBuilder.effectivePATH(
             purposes: [.rpc, .nodeTooling],
             env: env)
@@ -371,12 +775,19 @@ private final class CodexRPCClient: @unchecked Sendable {
         self.process.standardOutput = self.stdoutPipe
         self.process.standardError = self.stderrPipe
 
+        if let message = CodexCLILaunchGate.shared.backgroundSkipMessage(binary: resolvedExec) {
+            Self.log.warning("Codex RPC launch skipped after recent launch failure", metadata: ["binary": resolvedExec])
+            throw RPCWireError.startFailed(message)
+        }
+
         do {
             try self.process.run()
             Self.log.debug("Codex RPC started", metadata: ["binary": resolvedExec])
         } catch {
-            Self.log.warning("Codex RPC failed to start", metadata: ["error": error.localizedDescription])
-            throw RPCWireError.startFailed(error.localizedDescription)
+            let message = error.localizedDescription
+            let throttled = CodexCLILaunchGate.shared.recordLaunchFailure(binary: resolvedExec, message: message)
+            Self.log.warning("Codex RPC failed to start", metadata: ["error": message])
+            throw RPCWireError.startFailed(throttled ?? message)
         }
 
         let stdoutHandle = self.stdoutPipe.fileHandleForReading
@@ -416,7 +827,8 @@ private final class CodexRPCClient: @unchecked Sendable {
     func initialize(clientName: String, clientVersion: String) async throws {
         _ = try await self.request(
             method: "initialize",
-            params: ["clientInfo": ["name": clientName, "version": clientVersion]])
+            params: ["clientInfo": ["name": clientName, "version": clientVersion]],
+            timeout: self.initializeTimeoutSeconds)
         try self.sendNotification(method: "initialized")
     }
 
@@ -439,26 +851,72 @@ private final class CodexRPCClient: @unchecked Sendable {
 
     // MARK: - JSON-RPC helpers
 
-    private func request(method: String, params: [String: Any]? = nil) async throws -> [String: Any] {
+    private struct SendableJSONMessage: @unchecked Sendable {
+        let value: [String: Any]
+    }
+
+    private func request(
+        method: String,
+        params: [String: Any]? = nil,
+        timeout: TimeInterval? = nil) async throws -> [String: Any]
+    {
         let id = self.nextID
         self.nextID += 1
         try self.sendRequest(id: id, method: method, params: params)
 
-        while true {
-            let message = try await self.readNextMessage()
+        let resolvedTimeout = timeout ?? self.requestTimeoutSeconds
+        let wrapped = try await self.withTimeout(seconds: resolvedTimeout, method: method) {
+            while true {
+                let message = try await self.readNextMessage()
 
-            if message["id"] == nil, let methodName = message["method"] as? String {
-                Self.debugWriteStderr("[codex notify] \(methodName)\n")
-                continue
-            }
+                if message["id"] == nil, let methodName = message["method"] as? String {
+                    Self.debugWriteStderr("[codex notify] \(methodName)\n")
+                    continue
+                }
 
-            guard let messageID = self.jsonID(message["id"]), messageID == id else { continue }
+                guard let messageID = self.jsonID(message["id"]), messageID == id else { continue }
+
+                if let error = message["error"] as? [String: Any], let messageText = error["message"] as? String {
+                    throw RPCWireError.requestFailed(messageText)
+                }
 
-            if let error = message["error"] as? [String: Any], let messageText = error["message"] as? String {
-                throw RPCWireError.requestFailed(messageText)
+                return SendableJSONMessage(value: message)
+            }
+        }
+        return wrapped.value
+    }
+
+    private func withTimeout<T: Sendable>(
+        seconds: TimeInterval,
+        method: String,
+        body: @escaping @Sendable () async throws -> T) async throws -> T
+    {
+        try await withThrowingTaskGroup(of: T.self) { group in
+            group.addTask {
+                try await body()
+            }
+            group.addTask { [weak self] in
+                try await Task.sleep(for: .seconds(seconds))
+                self?.terminateProcessForTimeout(method: method)
+                throw RPCWireError.timeout(method: method)
+            }
+            do {
+                guard let result = try await group.next() else {
+                    throw RPCWireError.timeout(method: method)
+                }
+                group.cancelAll()
+                return result
+            } catch {
+                group.cancelAll()
+                throw error
             }
+        }
+    }
 
-            return message
+    private func terminateProcessForTimeout(method: String) {
+        if self.process.isRunning {
+            Self.log.warning("Codex RPC timed out on `\(method)`; terminating process")
+            self.process.terminate()
         }
     }
 
@@ -514,118 +972,110 @@ private final class CodexRPCClient: @unchecked Sendable {
 
 public struct UsageFetcher: Sendable {
     private let environment: [String: String]
+    private let initializeTimeoutSeconds: TimeInterval
+    private let requestTimeoutSeconds: TimeInterval
+    private let codexExecutableResolver: CodexExecutableResolver
+    private let codexArguments: [String]
 
     public init(environment: [String: String] = ProcessInfo.processInfo.environment) {
         self.environment = environment
+        self.initializeTimeoutSeconds = 8.0
+        self.requestTimeoutSeconds = 3.0
+        self.codexExecutableResolver = defaultCodexExecutableResolver
+        self.codexArguments = ["-s", "read-only", "-a", "untrusted", "app-server"]
         LoginShellPathCache.shared.captureOnce()
     }
 
-    public func loadLatestUsage(keepCLISessionsAlive: Bool = false) async throws -> UsageSnapshot {
-        try await self.withFallback(
-            primary: self.loadRPCUsage,
-            secondary: { try await self.loadTTYUsage(keepCLISessionsAlive: keepCLISessionsAlive) })
+    init(
+        environment: [String: String],
+        initializeTimeoutSeconds: TimeInterval,
+        requestTimeoutSeconds: TimeInterval,
+        codexArguments: [String] = ["-s", "read-only", "-a", "untrusted", "app-server"],
+        codexExecutableResolver: @escaping CodexExecutableResolver = defaultCodexExecutableResolver)
+    {
+        self.environment = environment
+        self.initializeTimeoutSeconds = initializeTimeoutSeconds
+        self.requestTimeoutSeconds = requestTimeoutSeconds
+        self.codexExecutableResolver = codexExecutableResolver
+        self.codexArguments = codexArguments
+        LoginShellPathCache.shared.captureOnce()
     }
 
-    private func loadRPCUsage() async throws -> UsageSnapshot {
-        let rpc = try CodexRPCClient()
-        defer { rpc.shutdown() }
-
-        try await rpc.initialize(clientName: "codexbar", clientVersion: "0.5.4")
-        // The app-server answers on a single stdout stream, so keep requests
-        // serialized to avoid starving one reader when multiple awaiters race
-        // for the same pipe.
-        let limits = try await rpc.fetchRateLimits().rateLimits
-        let account = try? await rpc.fetchAccount()
-
-        guard let primary = Self.makeWindow(from: limits.primary),
-              let secondary = Self.makeWindow(from: limits.secondary)
-        else {
+    public func loadLatestUsage(keepCLISessionsAlive: Bool = false) async throws -> UsageSnapshot {
+        _ = keepCLISessionsAlive
+        guard let usage = try await self.loadLatestCLIAccountSnapshot().usage else {
             throw UsageError.noRateLimitsFound
         }
-
-        let identity = ProviderIdentitySnapshot(
-            providerID: .codex,
-            accountEmail: account?.account.flatMap { details in
-                if case let .chatgpt(email, _) = details { email } else { nil }
-            },
-            accountOrganization: nil,
-            loginMethod: account?.account.flatMap { details in
-                if case let .chatgpt(_, plan) = details { plan } else { nil }
-            })
-        return UsageSnapshot(
-            primary: primary,
-            secondary: secondary,
-            tertiary: nil,
-            updatedAt: Date(),
-            identity: identity)
+        return usage
     }
 
-    private func loadTTYUsage(keepCLISessionsAlive: Bool) async throws -> UsageSnapshot {
-        let status = try await CodexStatusProbe(keepCLISessionsAlive: keepCLISessionsAlive).fetch()
-        guard let fiveLeft = status.fiveHourPercentLeft, let weekLeft = status.weeklyPercentLeft else {
-            throw UsageError.noRateLimitsFound
+    public func loadLatestCLIAccountSnapshot() async throws -> CodexCLIAccountSnapshot {
+        let rpc = try CodexRPCClient(
+            arguments: self.codexArguments,
+            environment: self.environment,
+            initializeTimeoutSeconds: self.initializeTimeoutSeconds,
+            requestTimeoutSeconds: self.requestTimeoutSeconds,
+            resolveExecutable: self.codexExecutableResolver)
+        defer { rpc.shutdown() }
+        do {
+            try await rpc.initialize(clientName: "codexbar", clientVersion: "0.5.4")
+            // The app-server answers on a single stdout stream, so keep requests
+            // serialized to avoid starving one reader when multiple awaiters race
+            // for the same pipe.
+            let limits = try await rpc.fetchRateLimits().rateLimits
+            let account = try? await rpc.fetchAccount()
+            let rateLimitsPlan = Self.normalizedCodexAccountField(limits.planType)
+            let identity = ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: account?.account.flatMap { details in
+                    if case let .chatgpt(email, _) = details { email } else { nil }
+                },
+                accountOrganization: nil,
+                loginMethod: account?.account.flatMap { details in
+                    if case let .chatgpt(_, plan) = details { plan } else { nil }
+                } ?? rateLimitsPlan)
+            let credits = Self.makeCredits(from: limits.credits)
+            let shouldReturnUnavailableUsage = credits == nil || rateLimitsPlan != nil
+            let usage = CodexReconciledState.fromCLI(
+                primary: Self.makeWindow(from: limits.primary),
+                secondary: Self.makeWindow(from: limits.secondary),
+                identity: identity)?
+                .toUsageSnapshot()
+                ?? (shouldReturnUnavailableUsage ? Self.emptyCodexUsageSnapshotIfIdentified(identity: identity) : nil)
+            guard usage != nil || credits != nil else {
+                throw UsageError.noRateLimitsFound
+            }
+            return CodexCLIAccountSnapshot(
+                usage: usage,
+                credits: credits)
+        } catch {
+            let usage = Self.recoverUsageFromRPCError(error)
+            let credits = Self.recoverCreditsFromRPCError(error)
+            if usage != nil || credits != nil {
+                return CodexCLIAccountSnapshot(
+                    usage: usage,
+                    credits: credits)
+            }
+            throw error
         }
-
-        let primary = RateWindow(
-            usedPercent: max(0, 100 - Double(fiveLeft)),
-            windowMinutes: 300,
-            resetsAt: nil,
-            resetDescription: status.fiveHourResetDescription)
-        let secondary = RateWindow(
-            usedPercent: max(0, 100 - Double(weekLeft)),
-            windowMinutes: 10080,
-            resetsAt: nil,
-            resetDescription: status.weeklyResetDescription)
-
-        return UsageSnapshot(
-            primary: primary,
-            secondary: secondary,
-            tertiary: nil,
-            updatedAt: Date(),
-            identity: nil)
     }
 
     public func loadLatestCredits(keepCLISessionsAlive: Bool = false) async throws -> CreditsSnapshot {
-        try await self.withFallback(
-            primary: self.loadRPCCredits,
-            secondary: { try await self.loadTTYCredits(keepCLISessionsAlive: keepCLISessionsAlive) })
-    }
-
-    private func loadRPCCredits() async throws -> CreditsSnapshot {
-        let rpc = try CodexRPCClient()
-        defer { rpc.shutdown() }
-        try await rpc.initialize(clientName: "codexbar", clientVersion: "0.5.4")
-        let limits = try await rpc.fetchRateLimits().rateLimits
-        guard let credits = limits.credits else { throw UsageError.noRateLimitsFound }
-        let remaining = Self.parseCredits(credits.balance)
-        return CreditsSnapshot(remaining: remaining, events: [], updatedAt: Date())
-    }
-
-    private func loadTTYCredits(keepCLISessionsAlive: Bool) async throws -> CreditsSnapshot {
-        let status = try await CodexStatusProbe(keepCLISessionsAlive: keepCLISessionsAlive).fetch()
-        guard let credits = status.credits else { throw UsageError.noRateLimitsFound }
-        return CreditsSnapshot(remaining: credits, events: [], updatedAt: Date())
-    }
-
-    private func withFallback<T>(
-        primary: @escaping () async throws -> T,
-        secondary: @escaping () async throws -> T) async throws -> T
-    {
-        do {
-            return try await primary()
-        } catch let primaryError {
-            do {
-                return try await secondary()
-            } catch {
-                // Preserve the original failure so callers see the primary path error.
-                throw primaryError
-            }
+        _ = keepCLISessionsAlive
+        guard let credits = try await self.loadLatestCLIAccountSnapshot().credits else {
+            throw UsageError.noRateLimitsFound
         }
+        return credits
     }
 
     public func debugRawRateLimits() async -> String {
         do {
-            let rpc = try CodexRPCClient()
+            let rpc = try CodexRPCClient(
+                arguments: self.codexArguments,
+                environment: self.environment,
+                initializeTimeoutSeconds: self.initializeTimeoutSeconds,
+                requestTimeoutSeconds: self.requestTimeoutSeconds,
+                resolveExecutable: self.codexExecutableResolver)
             defer { rpc.shutdown() }
             try await rpc.initialize(clientName: "codexbar", clientVersion: "0.5.4")
             let limits = try await rpc.fetchRateLimits()
@@ -637,30 +1087,30 @@ public struct UsageFetcher: Sendable {
     }
 
     public func loadAccountInfo() -> AccountInfo {
-        // Keep using auth.json for quick startup (non-blocking, no RPC spin-up required).
-        let authURL = URL(fileURLWithPath: self.environment["CODEX_HOME"] ?? "\(NSHomeDirectory())/.codex")
-            .appendingPathComponent("auth.json")
-        guard let data = try? Data(contentsOf: authURL),
-              let auth = try? JSONDecoder().decode(AuthFile.self, from: data),
-              let idToken = auth.tokens?.idToken
-        else {
-            return AccountInfo(email: nil, plan: nil)
-        }
+        let account = self.loadAuthBackedCodexAccount()
+        return AccountInfo(email: account.email, plan: account.plan)
+    }
 
-        guard let payload = UsageFetcher.parseJWT(idToken) else {
-            return AccountInfo(email: nil, plan: nil)
+    public func loadAuthBackedCodexAccount() -> CodexAuthBackedAccount {
+        guard let credentials = try? CodexOAuthCredentialsStore.load(env: self.environment) else {
+            return CodexAuthBackedAccount(identity: .unresolved, email: nil, plan: nil)
         }
 
-        let authDict = payload["https://api.openai.com/auth"] as? [String: Any]
-        let profileDict = payload["https://api.openai.com/profile"] as? [String: Any]
-
-        let plan = (authDict?["chatgpt_plan_type"] as? String)
-            ?? (payload["chatgpt_plan_type"] as? String)
-
-        let email = (payload["email"] as? String)
-            ?? (profileDict?["email"] as? String)
-
-        return AccountInfo(email: email, plan: plan)
+        let payload = credentials.idToken.flatMap(Self.parseJWT)
+        let authDict = payload?["https://api.openai.com/auth"] as? [String: Any]
+        let profileDict = payload?["https://api.openai.com/profile"] as? [String: Any]
+
+        let email = Self.normalizedCodexAccountField(
+            (payload?["email"] as? String) ?? (profileDict?["email"] as? String))
+        let plan = Self.normalizedCodexAccountField(
+            (authDict?["chatgpt_plan_type"] as? String) ?? (payload?["chatgpt_plan_type"] as? String))
+        let accountId = Self.normalizedCodexAccountField(
+            credentials.accountId
+                ?? (authDict?["chatgpt_account_id"] as? String)
+                ?? (payload?["chatgpt_account_id"] as? String))
+        let identity = CodexIdentityResolver.resolve(accountId: accountId, email: email)
+
+        return CodexAuthBackedAccount(identity: identity, email: email, plan: plan)
     }
 
     // MARK: - Helpers
@@ -676,11 +1126,133 @@ public struct UsageFetcher: Sendable {
             resetDescription: resetDescription)
     }
 
+    private static func makeWindow(from response: CodexUsageResponse.WindowSnapshot?) -> RateWindow? {
+        guard let response else { return nil }
+        let resetsAtDate = Date(timeIntervalSince1970: TimeInterval(response.resetAt))
+        return RateWindow(
+            usedPercent: Double(response.usedPercent),
+            windowMinutes: response.limitWindowSeconds / 60,
+            resetsAt: resetsAtDate,
+            resetDescription: UsageFormatter.resetDescription(from: resetsAtDate))
+    }
+
+    private static func makeTTYWindow(
+        percentLeft: Int?,
+        windowMinutes: Int,
+        resetsAt: Date?,
+        resetDescription: String?) -> RateWindow?
+    {
+        guard let percentLeft else { return nil }
+        return RateWindow(
+            usedPercent: max(0, 100 - Double(percentLeft)),
+            windowMinutes: windowMinutes,
+            resetsAt: resetsAt,
+            resetDescription: resetDescription)
+    }
+
     private static func parseCredits(_ balance: String?) -> Double {
         guard let balance, let val = Double(balance) else { return 0 }
         return val
     }
 
+    private static func makeCredits(from rpc: RPCCreditsSnapshot?) -> CreditsSnapshot? {
+        guard let rpc else { return nil }
+        return CreditsSnapshot(remaining: self.parseCredits(rpc.balance), events: [], updatedAt: Date())
+    }
+
+    private static func emptyCodexUsageSnapshotIfIdentified(identity: ProviderIdentitySnapshot) -> UsageSnapshot? {
+        guard identity.accountEmail != nil || identity.loginMethod != nil else { return nil }
+        return UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: Date(),
+            identity: identity)
+    }
+
+    private static func recoverUsageFromRPCError(_ error: Error) -> UsageSnapshot? {
+        guard let body = self.decodeRateLimitsErrorBody(from: error) else { return nil }
+        let identity = ProviderIdentitySnapshot(
+            providerID: .codex,
+            accountEmail: self.normalizedCodexAccountField(body.email),
+            accountOrganization: nil,
+            loginMethod: self.normalizedCodexAccountField(body.planType))
+        guard let state = CodexReconciledState.fromCLI(
+            primary: self.makeWindow(from: body.rateLimit?.primaryWindow),
+            secondary: self.makeWindow(from: body.rateLimit?.secondaryWindow),
+            identity: identity)
+        else {
+            return nil
+        }
+        if body.rateLimit?.hasWindowDecodeFailure == true,
+           state.session == nil
+        {
+            return nil
+        }
+        return state.toUsageSnapshot()
+    }
+
+    private static func recoverCreditsFromRPCError(_ error: Error) -> CreditsSnapshot? {
+        guard let credits = self.decodeRateLimitsErrorBody(from: error)?.credits else { return nil }
+        guard let remaining = credits.balance else { return nil }
+        return CreditsSnapshot(remaining: remaining, events: [], updatedAt: Date())
+    }
+
+    private static func decodeRateLimitsErrorBody(from error: Error) -> RPCRateLimitsErrorBody? {
+        guard case let RPCWireError.requestFailed(message) = error else { return nil }
+        guard let json = self.extractJSONObject(after: "body=", in: message) else { return nil }
+        guard let data = json.data(using: .utf8) else { return nil }
+        return try? JSONDecoder().decode(RPCRateLimitsErrorBody.self, from: data)
+    }
+
+    private static func extractJSONObject(after marker: String, in text: String) -> String? {
+        guard let markerRange = text.range(of: marker) else { return nil }
+        let suffix = text[markerRange.upperBound...]
+        guard let start = suffix.firstIndex(of: "{") else { return nil }
+
+        var depth = 0
+        var inString = false
+        var isEscaped = false
+
+        for index in suffix[start...].indices {
+            let character = suffix[index]
+
+            if inString {
+                if isEscaped {
+                    isEscaped = false
+                } else if character == "\\" {
+                    isEscaped = true
+                } else if character == "\"" {
+                    inString = false
+                }
+                continue
+            }
+
+            switch character {
+            case "\"":
+                inString = true
+            case "{":
+                depth += 1
+            case "}":
+                depth -= 1
+                if depth == 0 {
+                    return String(suffix[start...index])
+                }
+            default:
+                break
+            }
+        }
+
+        return nil
+    }
+
+    private static func normalizedCodexAccountField(_ value: String?) -> String? {
+        guard let value = value?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
+            return nil
+        }
+        return value
+    }
+
     public static func parseJWT(_ token: String) -> [String: Any]? {
         let parts = token.split(separator: ".")
         guard parts.count >= 2 else { return nil }
@@ -698,8 +1270,68 @@ public struct UsageFetcher: Sendable {
     }
 }
 
-/// Minimal auth.json struct preserved from previous implementation
-private struct AuthFile: Decodable {
-    struct Tokens: Decodable { let idToken: String? }
-    let tokens: Tokens?
+#if DEBUG
+extension UsageFetcher {
+    static func _mapCodexRPCLimitsForTesting(
+        primary: (usedPercent: Double, windowMinutes: Int, resetsAt: Int?)?,
+        secondary: (usedPercent: Double, windowMinutes: Int, resetsAt: Int?)?,
+        planType: String? = nil) throws -> UsageSnapshot
+    {
+        let identity = ProviderIdentitySnapshot(
+            providerID: .codex,
+            accountEmail: nil,
+            accountOrganization: nil,
+            loginMethod: self.normalizedCodexAccountField(planType))
+        guard let state = CodexReconciledState.fromCLI(
+            primary: primary.map(self.makeTestingWindow),
+            secondary: secondary.map(self.makeTestingWindow),
+            identity: identity)
+        else {
+            if let usage = self.emptyCodexUsageSnapshotIfIdentified(identity: identity) {
+                return usage
+            }
+            throw UsageError.noRateLimitsFound
+        }
+        return state.toUsageSnapshot()
+    }
+
+    static func _mapCodexStatusForTesting(_ status: CodexStatusSnapshot) throws -> UsageSnapshot {
+        guard let state = CodexReconciledState.fromCLI(
+            primary: self.makeTTYWindow(
+                percentLeft: status.fiveHourPercentLeft,
+                windowMinutes: 300,
+                resetsAt: status.fiveHourResetsAt,
+                resetDescription: status.fiveHourResetDescription),
+            secondary: self.makeTTYWindow(
+                percentLeft: status.weeklyPercentLeft,
+                windowMinutes: 10080,
+                resetsAt: status.weeklyResetsAt,
+                resetDescription: status.weeklyResetDescription),
+            identity: nil)
+        else {
+            throw UsageError.noRateLimitsFound
+        }
+        return state.toUsageSnapshot()
+    }
+
+    public static func _recoverCodexRPCUsageFromErrorForTesting(_ message: String) -> UsageSnapshot? {
+        self.recoverUsageFromRPCError(RPCWireError.requestFailed(message))
+    }
+
+    public static func _recoverCodexRPCCreditsFromErrorForTesting(_ message: String) -> CreditsSnapshot? {
+        self.recoverCreditsFromRPCError(RPCWireError.requestFailed(message))
+    }
+
+    private static func makeTestingWindow(
+        _ value: (usedPercent: Double, windowMinutes: Int, resetsAt: Int?))
+        -> RateWindow
+    {
+        let resetsAt = value.resetsAt.map { Date(timeIntervalSince1970: TimeInterval($0)) }
+        return RateWindow(
+            usedPercent: value.usedPercent,
+            windowMinutes: value.windowMinutes,
+            resetsAt: resetsAt,
+            resetDescription: resetsAt.map { UsageFormatter.resetDescription(from: $0) })
+    }
 }
+#endif
diff --git a/Sources/CodexBarCore/UsageFormatter.swift b/Sources/CodexBarCore/UsageFormatter.swift
index 226d435698..e6bcc6a62f 100644
--- a/Sources/CodexBarCore/UsageFormatter.swift
+++ b/Sources/CodexBarCore/UsageFormatter.swift
@@ -6,10 +6,84 @@ public enum ResetTimeDisplayStyle: String, Codable, Sendable {
 }
 
 public enum UsageFormatter {
+    private final class BundleToken {}
+
+    private static let localizationLock = NSLock()
+    private nonisolated(unsafe) static var localizationProvider: (@Sendable (String) -> String)?
+    private nonisolated(unsafe) static var localeProvider: (@Sendable () -> Locale)?
+
+    public static func setLocalizationProvider(_ provider: @escaping @Sendable (String) -> String) {
+        self.localizationLock.lock()
+        self.localizationProvider = provider
+        self.localizationLock.unlock()
+    }
+
+    public static func clearLocalizationProvider() {
+        self.localizationLock.lock()
+        self.localizationProvider = nil
+        self.localizationLock.unlock()
+    }
+
+    public static func setLocaleProvider(_ provider: @escaping @Sendable () -> Locale) {
+        self.localizationLock.lock()
+        self.localeProvider = provider
+        self.localizationLock.unlock()
+    }
+
+    public static func clearLocaleProvider() {
+        self.localizationLock.lock()
+        self.localeProvider = nil
+        self.localizationLock.unlock()
+    }
+
+    private static func currentLocale() -> Locale {
+        self.localizationLock.lock()
+        let provider = self.localeProvider
+        self.localizationLock.unlock()
+        return provider?() ?? Locale(identifier: "en_US_POSIX")
+    }
+
+    private static func localized(_ key: String) -> String {
+        self.localizationLock.lock()
+        let provider = self.localizationProvider
+        self.localizationLock.unlock()
+        if let provider {
+            return provider(key)
+        }
+        let coreBundle = Bundle(for: BundleToken.self)
+        let coreValue = NSLocalizedString(key, tableName: "Localizable", bundle: coreBundle, value: key, comment: "")
+        if coreValue != key { return coreValue }
+
+        let mainValue = NSLocalizedString(key, tableName: "Localizable", bundle: .main, value: key, comment: "")
+        if mainValue != key { return mainValue }
+
+        switch key {
+        case "usage_percent_suffix_left": return "left"
+        case "usage_percent_suffix_used": return "used"
+        case "reset_tomorrow_format": return "tomorrow, %@"
+        case "byte_unit_byte": return "byte"
+        case "byte_unit_bytes": return "bytes"
+        case "byte_unit_kilobyte": return "kilobyte"
+        case "byte_unit_kilobytes": return "kilobytes"
+        case "byte_unit_megabyte": return "megabyte"
+        case "byte_unit_megabytes": return "megabytes"
+        case "byte_unit_gigabyte": return "gigabyte"
+        case "byte_unit_gigabytes": return "gigabytes"
+        default: return key
+        }
+    }
+
+    private static func localized(_ key: String, _ args: CVarArg...) -> String {
+        let format = self.localized(key)
+        return String(format: format, locale: self.currentLocale(), arguments: args)
+    }
+
     public static func usageLine(remaining: Double, used: Double, showUsed: Bool) -> String {
         let percent = showUsed ? used : remaining
         let clamped = min(100, max(0, percent))
-        let suffix = showUsed ? "used" : "left"
+        let suffix = showUsed
+            ? self.localized("usage_percent_suffix_used")
+            : self.localized("usage_percent_suffix_left")
         return String(format: "%.0f%% %@", clamped, suffix)
     }
 
@@ -37,14 +111,15 @@ public enum UsageFormatter {
         // Human-friendly phrasing: today / tomorrow / date+time.
         let calendar = Calendar.current
         if calendar.isDate(date, inSameDayAs: now) {
-            return date.formatted(date: .omitted, time: .shortened)
+            return date.formatted(.dateTime.hour().minute().locale(self.currentLocale()))
         }
         if let tomorrow = calendar.date(byAdding: .day, value: 1, to: now),
            calendar.isDate(date, inSameDayAs: tomorrow)
         {
-            return "tomorrow, \(date.formatted(date: .omitted, time: .shortened))"
+            let timeStr = date.formatted(.dateTime.hour().minute().locale(self.currentLocale()))
+            return self.localized("reset_tomorrow_format", timeStr)
         }
-        return date.formatted(date: .abbreviated, time: .shortened)
+        return date.formatted(.dateTime.month(.abbreviated).day().hour().minute().locale(self.currentLocale()))
     }
 
     public static func resetLine(
@@ -53,17 +128,30 @@ public enum UsageFormatter {
         now: Date = .init()) -> String?
     {
         if let date = window.resetsAt {
-            let text = style == .countdown
-                ? self.resetCountdownDescription(from: date, now: now)
-                : self.resetDescription(from: date, now: now)
-            return "Resets \(text)"
+            if style == .countdown {
+                let countdown = self.resetCountdownDescription(from: date, now: now)
+                if countdown == "now" {
+                    return self.localized("Resets now")
+                }
+                if countdown.hasPrefix("in ") {
+                    return self.localized("Resets in %@", String(countdown.dropFirst(3)))
+                }
+                return self.localized("Resets %@", countdown)
+            }
+            let text = self.resetDescription(from: date, now: now)
+            return self.localized("Resets %@", text)
         }
 
         if let desc = window.resetDescription {
             let trimmed = desc.trimmingCharacters(in: .whitespacesAndNewlines)
             guard !trimmed.isEmpty else { return nil }
-            if trimmed.lowercased().hasPrefix("resets") { return trimmed }
-            return "Resets \(trimmed)"
+            if trimmed.lowercased().hasPrefix("resets in ") {
+                return self.localized("Resets in %@", String(trimmed.dropFirst("Resets in ".count)))
+            }
+            if trimmed.lowercased().hasPrefix("resets ") {
+                return self.localized("Resets %@", String(trimmed.dropFirst("Resets ".count)))
+            }
+            return self.localized("Resets %@", trimmed)
         }
         return nil
     }
@@ -71,24 +159,27 @@ public enum UsageFormatter {
     public static func updatedString(from date: Date, now: Date = .init()) -> String {
         let delta = now.timeIntervalSince(date)
         if abs(delta) < 60 {
-            return "Updated just now"
+            return self.localized("Updated just now")
         }
         if let hours = Calendar.current.dateComponents([.hour], from: date, to: now).hour, hours < 24 {
             #if os(macOS)
             let rel = RelativeDateTimeFormatter()
+            rel.locale = self.currentLocale()
             rel.unitsStyle = .abbreviated
-            return "Updated \(rel.localizedString(for: date, relativeTo: now))"
+            return self.localized("Updated %@", rel.localizedString(for: date, relativeTo: now))
             #else
             let seconds = max(0, Int(now.timeIntervalSince(date)))
             if seconds < 3600 {
                 let minutes = max(1, seconds / 60)
-                return "Updated \(minutes)m ago"
+                return self.localized("Updated %@m ago", String(minutes))
             }
             let wholeHours = max(1, seconds / 3600)
-            return "Updated \(wholeHours)h ago"
+            return self.localized("Updated %@h ago", String(wholeHours))
             #endif
         } else {
-            return "Updated \(date.formatted(date: .omitted, time: .shortened))"
+            return self.localized(
+                "Updated %@",
+                date.formatted(.dateTime.hour().minute().locale(self.currentLocale())))
         }
     }
 
@@ -99,7 +190,15 @@ public enum UsageFormatter {
         // Use explicit locale for consistent formatting on all systems
         number.locale = Locale(identifier: "en_US_POSIX")
         let formatted = number.string(from: NSNumber(value: value)) ?? String(format: "%.2f", value)
-        return "\(formatted) left"
+        return self.localized("%@ left", formatted)
+    }
+
+    public static func kiroCreditNumber(_ value: Double) -> String {
+        let rounded = value.rounded()
+        if abs(value - rounded) < 0.005 {
+            return String(format: "%.0f", rounded)
+        }
+        return String(format: "%.2f", value)
     }
 
     /// Formats a USD value with proper negative handling and thousand separators.
@@ -108,6 +207,18 @@ public enum UsageFormatter {
         value.formatted(.currency(code: "USD").locale(Locale(identifier: "en_US")))
     }
 
+    public static let costEstimateHint = "Estimated from local logs · may differ from your bill"
+
+    public static func costEstimateHint(provider: UsageProvider) -> String {
+        switch provider {
+        case .claude:
+            "Estimated from local Claude logs at API rates; token totals include cache read/write tokens " +
+                "and may differ from Claude Code /status."
+        default:
+            self.costEstimateHint
+        }
+    }
+
     /// Formats a currency value with the specified currency code.
     /// Uses FormatStyle with explicit en_US locale to ensure consistent formatting
     /// regardless of the user's system locale (e.g., pt-BR users see $54.72 not US$ 54,72).
@@ -138,11 +249,50 @@ public enum UsageFormatter {
             return "\(sign)\(formatted)\(unit.suffix)"
         }
 
-        let formatter = NumberFormatter()
-        formatter.numberStyle = .decimal
-        formatter.usesGroupingSeparator = true
-        formatter.locale = Locale(identifier: "en_US_POSIX")
-        return formatter.string(from: NSNumber(value: value)) ?? "\(value)"
+        return "\(value)"
+    }
+
+    public static func byteCountString(_ bytes: Int64) -> String {
+        let sign = bytes < 0 ? "-" : ""
+        let absBytes = Double(bytes.magnitude)
+        let units: [(threshold: Double, divisor: Double, suffix: String)] = [
+            (1024 * 1024 * 1024, 1024 * 1024 * 1024, "GB"),
+            (1024 * 1024, 1024 * 1024, "MB"),
+            (1024, 1024, "KB"),
+        ]
+
+        for unit in units where absBytes >= unit.threshold {
+            let scaled = absBytes / unit.divisor
+            let format = scaled >= 10 || scaled.rounded(.towardZero) == scaled ? "%.0f" : "%.1f"
+            let formatted = String(format: format, scaled)
+            return "\(sign)\(formatted) \(unit.suffix)"
+        }
+
+        return "\(bytes) B"
+    }
+
+    /// Same magnitudes as `byteCountString`, but spelled out ("megabytes" instead of "MB").
+    public static func byteCountStringLong(_ bytes: Int64) -> String {
+        let sign = bytes < 0 ? "-" : ""
+        let absBytes = Double(bytes.magnitude)
+        let units: [(threshold: Double, divisor: Double, singularKey: String, pluralKey: String)] = [
+            (1024 * 1024 * 1024, 1024 * 1024 * 1024, "byte_unit_gigabyte", "byte_unit_gigabytes"),
+            (1024 * 1024, 1024 * 1024, "byte_unit_megabyte", "byte_unit_megabytes"),
+            (1024, 1024, "byte_unit_kilobyte", "byte_unit_kilobytes"),
+        ]
+
+        for unit in units where absBytes >= unit.threshold {
+            let scaled = absBytes / unit.divisor
+            let format = scaled >= 10 || scaled.rounded(.towardZero) == scaled ? "%.0f" : "%.1f"
+            let formatted = String(format: format, locale: self.currentLocale(), scaled)
+            let displayScale = format == "%.0f" ? 1.0 : 10.0
+            let displayedValue = (scaled * displayScale).rounded() / displayScale
+            let word = self.localized(displayedValue == 1 ? unit.singularKey : unit.pluralKey)
+            return "\(sign)\(formatted) \(word)"
+        }
+
+        let word = self.localized(bytes.magnitude == 1 ? "byte_unit_byte" : "byte_unit_bytes")
+        return "\(bytes) \(word)"
     }
 
     public static func creditEventSummary(_ event: CreditEvent) -> String {
@@ -206,6 +356,26 @@ public enum UsageFormatter {
         return cleaned.isEmpty ? raw : cleaned
     }
 
+    public static func modelCostDetail(
+        _ model: String,
+        costUSD: Double?,
+        totalTokens: Int? = nil,
+        currencyCode: String = "USD") -> String?
+    {
+        let costDetail: String? = if let label = CostUsagePricing.codexDisplayLabel(model: model) {
+            label
+        } else if let costUSD {
+            self.currencyString(costUSD, currencyCode: currencyCode)
+        } else {
+            nil
+        }
+
+        let tokenDetail = totalTokens.map(self.tokenCountString)
+        let parts = [costDetail, tokenDetail].compactMap(\.self)
+        guard !parts.isEmpty else { return nil }
+        return parts.joined(separator: " · ")
+    }
+
     /// Cleans a provider plan string: strip ANSI/bracket noise, drop boilerplate words, collapse whitespace, and
     /// ensure a leading capital if the result starts lowercase.
     public static func cleanPlanName(_ text: String) -> String {
diff --git a/Sources/CodexBarCore/UsagePace.swift b/Sources/CodexBarCore/UsagePace.swift
index 2c93f0a474..c55b54c890 100644
--- a/Sources/CodexBarCore/UsagePace.swift
+++ b/Sources/CodexBarCore/UsagePace.swift
@@ -40,7 +40,9 @@ public struct UsagePace: Sendable {
     public static func weekly(
         window: RateWindow,
         now: Date = .init(),
-        defaultWindowMinutes: Int = 10080) -> UsagePace?
+        defaultWindowMinutes: Int = 10080,
+        workDays: Int? = nil,
+        calendar: Calendar = .current) -> UsagePace?
     {
         guard let resetsAt = window.resetsAt else { return nil }
         let minutes = window.windowMinutes ?? defaultWindowMinutes
@@ -51,7 +53,20 @@ public struct UsagePace: Sendable {
         guard timeUntilReset > 0 else { return nil }
         guard timeUntilReset <= duration else { return nil }
         let elapsed = (duration - timeUntilReset).clamped(to: 0...duration)
-        let expected = ((elapsed / duration) * 100).clamped(to: 0...100)
+        let workdayProgress: WorkdayProgress? = if let workDays, workDays >= 2, workDays < 7,
+                                                   minutes == 10080
+        {
+            Self.workdayProgress(
+                now: now,
+                duration: duration,
+                resetsAt: resetsAt,
+                workDays: workDays,
+                calendar: calendar)
+        } else {
+            nil
+        }
+        let expected = workdayProgress?.expectedUsedPercent
+            ?? ((elapsed / duration) * 100).clamped(to: 0...100)
         let actual = window.usedPercent.clamped(to: 0...100)
         if elapsed == 0, actual > 0 {
             return nil
@@ -62,18 +77,29 @@ public struct UsagePace: Sendable {
         var etaSeconds: TimeInterval?
         var willLastToReset = false
 
-        if elapsed > 0, actual > 0 {
-            let rate = actual / elapsed
+        let paceElapsed = workdayProgress?.elapsedSeconds ?? elapsed
+        if actual >= 100 {
+            etaSeconds = 0
+        } else if paceElapsed > 0, actual > 0 {
+            let rate = actual / paceElapsed
             if rate > 0 {
-                let remaining = max(0, 100 - actual)
+                let remaining = 100 - actual
                 let candidate = remaining / rate
-                if candidate >= timeUntilReset {
+                let effectiveTimeUntilReset = workdayProgress?.remainingSeconds ?? timeUntilReset
+                if candidate >= effectiveTimeUntilReset {
                     willLastToReset = true
+                } else if let workDays = workdayProgress?.workDays {
+                    etaSeconds = Self.wallClockInterval(
+                        from: now,
+                        to: resetsAt,
+                        consumingWorkSeconds: candidate,
+                        workDays: workDays,
+                        calendar: calendar)
                 } else {
                     etaSeconds = candidate
                 }
             }
-        } else if elapsed > 0, actual == 0 {
+        } else if paceElapsed > 0, actual == 0 {
             willLastToReset = true
         }
 
@@ -107,6 +133,101 @@ public struct UsagePace: Sendable {
             runOutProbability: runOutProbability)
     }
 
+    private struct WorkdayProgress {
+        let workDays: Int
+        let totalSeconds: TimeInterval
+        let elapsedSeconds: TimeInterval
+        let remainingSeconds: TimeInterval
+
+        var expectedUsedPercent: Double {
+            ((self.elapsedSeconds / self.totalSeconds) * 100).clamped(to: 0...100)
+        }
+    }
+
+    /// Splits the weekly window at local day boundaries so reset offsets do not shift weekday classification.
+    private static func workdayProgress(
+        now: Date,
+        duration: TimeInterval,
+        resetsAt: Date,
+        workDays: Int,
+        calendar: Calendar) -> WorkdayProgress?
+    {
+        let windowStart = resetsAt.addingTimeInterval(-duration)
+
+        var totalWorkSeconds: TimeInterval = 0
+        var elapsedWorkSeconds: TimeInterval = 0
+        var remainingWorkSeconds: TimeInterval = 0
+
+        var cursor = windowStart
+        while cursor < resetsAt {
+            guard let startOfNextDay = Self.nextDayBoundary(after: cursor, calendar: calendar),
+                  startOfNextDay > cursor
+            else {
+                return nil
+            }
+            let sliceEnd = min(startOfNextDay, resetsAt)
+
+            if Self.isWorkday(cursor, calendar: calendar, workDays: workDays) {
+                let sliceDuration = sliceEnd.timeIntervalSince(cursor)
+                totalWorkSeconds += sliceDuration
+                if now > cursor {
+                    elapsedWorkSeconds += min(now, sliceEnd).timeIntervalSince(cursor)
+                }
+                if now < sliceEnd {
+                    remainingWorkSeconds += sliceEnd.timeIntervalSince(max(now, cursor))
+                }
+            }
+            cursor = sliceEnd
+        }
+
+        guard totalWorkSeconds > 0 else { return nil }
+        return WorkdayProgress(
+            workDays: workDays,
+            totalSeconds: totalWorkSeconds,
+            elapsedSeconds: elapsedWorkSeconds,
+            remainingSeconds: remainingWorkSeconds)
+    }
+
+    private static func wallClockInterval(
+        from now: Date,
+        to resetsAt: Date,
+        consumingWorkSeconds requiredWorkSeconds: TimeInterval,
+        workDays: Int,
+        calendar: Calendar) -> TimeInterval?
+    {
+        guard requiredWorkSeconds > 0 else { return 0 }
+
+        var remaining = requiredWorkSeconds
+        var cursor = now
+        while cursor < resetsAt {
+            guard let startOfNextDay = Self.nextDayBoundary(after: cursor, calendar: calendar),
+                  startOfNextDay > cursor
+            else {
+                return nil
+            }
+            let sliceEnd = min(startOfNextDay, resetsAt)
+            if Self.isWorkday(cursor, calendar: calendar, workDays: workDays) {
+                let available = sliceEnd.timeIntervalSince(cursor)
+                if remaining <= available {
+                    return cursor.addingTimeInterval(remaining).timeIntervalSince(now)
+                }
+                remaining -= available
+            }
+            cursor = sliceEnd
+        }
+        return nil
+    }
+
+    private static func nextDayBoundary(after date: Date, calendar: Calendar) -> Date? {
+        calendar.date(byAdding: .day, value: 1, to: calendar.startOfDay(for: date))
+    }
+
+    private static func isWorkday(_ date: Date, calendar: Calendar, workDays: Int) -> Bool {
+        let weekday = calendar.component(.weekday, from: date)
+        let isoWeekday = weekday == 1 ? 7 : weekday - 1
+        return isoWeekday <= workDays
+    }
+
     private static func stage(for delta: Double) -> Stage {
         let absDelta = abs(delta)
         if absDelta <= 2 { return .onTrack }
diff --git a/Sources/CodexBarCore/Vendored/CostUsage/CostUsageCache.swift b/Sources/CodexBarCore/Vendored/CostUsage/CostUsageCache.swift
index e56131a416..40c2d8c6f4 100644
--- a/Sources/CodexBarCore/Vendored/CostUsage/CostUsageCache.swift
+++ b/Sources/CodexBarCore/Vendored/CostUsage/CostUsageCache.swift
@@ -1,6 +1,21 @@
 import Foundation
 
 enum CostUsageCacheIO {
+    private static let compatibleCodexProducerKeys: Set<String> = [
+        "codex:cu:p3c27f997569eb3c5",
+    ]
+
+    private static func artifactVersion(for provider: UsageProvider) -> Int {
+        switch provider {
+        case .codex:
+            8
+        case .claude, .vertexai:
+            4
+        default:
+            1
+        }
+    }
+
     private static func defaultCacheRoot() -> URL {
         let root = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first!
         return root.appendingPathComponent("CodexBar", isDirectory: true)
@@ -8,44 +23,95 @@ enum CostUsageCacheIO {
 
     static func cacheFileURL(provider: UsageProvider, cacheRoot: URL? = nil) -> URL {
         let root = cacheRoot ?? self.defaultCacheRoot()
+        let artifactVersion = self.artifactVersion(for: provider)
         return root
             .appendingPathComponent("cost-usage", isDirectory: true)
-            .appendingPathComponent("\(provider.rawValue)-v1.json", isDirectory: false)
+            .appendingPathComponent("\(provider.rawValue)-v\(artifactVersion).json", isDirectory: false)
     }
 
-    static func load(provider: UsageProvider, cacheRoot: URL? = nil) -> CostUsageCache {
+    static func load(
+        provider: UsageProvider,
+        cacheRoot: URL? = nil,
+        producerKey: String? = nil) -> CostUsageCache
+    {
         let url = self.cacheFileURL(provider: provider, cacheRoot: cacheRoot)
-        if let decoded = self.loadCache(at: url) { return decoded }
+        let expectedProducerKey = producerKey ?? self.currentProducerKey(provider: provider)
+        let compatibleProducerKeys = producerKey == nil && provider == .codex
+            ? self.compatibleCodexProducerKeys
+            : []
+        if let decoded = self.loadCache(
+            at: url,
+            expectedProducerKey: expectedProducerKey,
+            compatibleProducerKeys: compatibleProducerKeys)
+        {
+            return decoded
+        }
         return CostUsageCache()
     }
 
-    private static func loadCache(at url: URL) -> CostUsageCache? {
+    private static func loadCache(
+        at url: URL,
+        expectedProducerKey: String?,
+        compatibleProducerKeys: Set<String>) -> CostUsageCache?
+    {
         guard let data = try? Data(contentsOf: url) else { return nil }
         guard let decoded = try? JSONDecoder().decode(CostUsageCache.self, from: data)
         else { return nil }
         guard decoded.version == 1 else { return nil }
+        if let expectedProducerKey {
+            guard decoded.producerKey == expectedProducerKey
+                || decoded.producerKey.map(compatibleProducerKeys.contains) == true
+            else { return nil }
+        }
         return decoded
     }
 
-    static func save(provider: UsageProvider, cache: CostUsageCache, cacheRoot: URL? = nil) {
+    static func save(
+        provider: UsageProvider,
+        cache: CostUsageCache,
+        cacheRoot: URL? = nil,
+        producerKey: String? = nil)
+    {
         let url = self.cacheFileURL(provider: provider, cacheRoot: cacheRoot)
         let dir = url.deletingLastPathComponent()
         try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
 
+        var cache = cache
+        cache.producerKey = producerKey ?? self.currentProducerKey(provider: provider)
+
         let tmp = dir.appendingPathComponent(".tmp-\(UUID().uuidString).json", isDirectory: false)
         let data = (try? JSONEncoder().encode(cache)) ?? Data()
         do {
             try data.write(to: tmp, options: [.atomic])
-            _ = try FileManager.default.replaceItemAt(url, withItemAt: tmp)
+            if FileManager.default.fileExists(atPath: url.path) {
+                _ = try FileManager.default.replaceItemAt(url, withItemAt: tmp)
+            } else {
+                try FileManager.default.moveItem(at: tmp, to: url)
+            }
         } catch {
             try? FileManager.default.removeItem(at: tmp)
         }
     }
+
+    static func currentProducerKey(
+        provider: UsageProvider,
+        parserHash: String = CodexParserHash.value) -> String?
+    {
+        guard provider == .codex else { return nil }
+        return "\(provider.rawValue):cu:p\(parserHash)"
+    }
 }
 
-struct CostUsageCache: Codable, Sendable {
+struct CostUsageCache: Codable {
     var version: Int = 1
+    var producerKey: String?
     var lastScanUnixMs: Int64 = 0
+    var scanSinceKey: String?
+    var scanUntilKey: String?
+    var codexPricingKey: String?
+    var codexPriorityMetadataKey: String?
+    var codexPriorityTurnKeys: [String: String]?
+    var codexPriorityTurnIDsByDay: [String: [String]]?
 
     /// filePath -> file usage
     var files: [String: CostUsageFileUsage] = [:]
@@ -57,17 +123,31 @@ struct CostUsageCache: Codable, Sendable {
     var roots: [String: Int64]?
 }
 
-struct CostUsageFileUsage: Codable, Sendable {
+struct CostUsageFileUsage: Codable {
     var mtimeUnixMs: Int64
     var size: Int64
     var days: [String: [String: [Int]]]
     var parsedBytes: Int64?
     var lastModel: String?
     var lastTotals: CostUsageCodexTotals?
+    var lastCountedTotals: CostUsageCodexTotals?
+    var lastRawTotalsBaseline: CostUsageCodexTotals?
+    var hasDivergentTotals: Bool?
+    var lastCodexTurnID: String?
     var sessionId: String?
+    var forkedFromId: String?
+    var codexCostNanos: [String: [String: Int64]]?
+    var codexPrioritySurchargeNanos: [String: [String: Int64]]?
+    var codexStandardCostNanos: [String: [String: Int64]]?
+    var codexPriorityCostNanos: [String: [String: Int64]]?
+    var codexStandardTokens: [String: [String: Int]]?
+    var codexPriorityTokens: [String: [String: Int]]?
+    var codexTurnIDs: [String]?
+    var codexRows: [CostUsageScanner.CodexUsageRow]?
+    var claudeRows: [CostUsageScanner.ClaudeUsageRow]?
 }
 
-struct CostUsageCodexTotals: Codable, Sendable {
+struct CostUsageCodexTotals: Codable {
     var input: Int
     var cached: Int
     var output: Int
diff --git a/Sources/CodexBarCore/Vendored/CostUsage/CostUsageJsonl.swift b/Sources/CodexBarCore/Vendored/CostUsage/CostUsageJsonl.swift
index 5105f97593..35f58b446a 100644
--- a/Sources/CodexBarCore/Vendored/CostUsage/CostUsageJsonl.swift
+++ b/Sources/CodexBarCore/Vendored/CostUsage/CostUsageJsonl.swift
@@ -1,7 +1,7 @@
 import Foundation
 
 enum CostUsageJsonl {
-    struct Line: Sendable {
+    struct Line {
         let bytes: Data
         let wasTruncated: Bool
     }
@@ -14,6 +14,25 @@ enum CostUsageJsonl {
         prefixBytes: Int,
         onLine: (Line) -> Void) throws
         -> Int64
+    {
+        try self.scan(
+            fileURL: fileURL,
+            offset: offset,
+            maxLineBytes: maxLineBytes,
+            prefixBytes: prefixBytes,
+            checkCancellation: nil,
+            onLine: onLine)
+    }
+
+    @discardableResult
+    static func scan(
+        fileURL: URL,
+        offset: Int64 = 0,
+        maxLineBytes: Int,
+        prefixBytes: Int,
+        checkCancellation: (() throws -> Void)? = nil,
+        onLine: (Line) -> Void) throws
+        -> Int64
     {
         let handle = try FileHandle(forReadingFrom: fileURL)
         defer { try? handle.close() }
@@ -29,16 +48,18 @@ enum CostUsageJsonl {
         var truncated = false
         var bytesRead: Int64 = 0
 
-        func appendSegment(_ segment: Data.SubSequence) {
-            guard !segment.isEmpty else { return }
-            lineBytes += segment.count
-            guard !truncated else { return }
+        func appendSegment(_ bytes: UnsafePointer<UInt8>, count: Int) {
+            guard count > 0 else { return }
+            lineBytes += count
+            if current.count < prefixBytes {
+                let appendCount = min(prefixBytes - current.count, count)
+                if appendCount > 0 {
+                    current.append(bytes, count: appendCount)
+                }
+            }
             if lineBytes > maxLineBytes || lineBytes > prefixBytes {
                 truncated = true
-                current.removeAll(keepingCapacity: true)
-                return
             }
-            current.append(contentsOf: segment)
         }
 
         func flushLine() {
@@ -51,22 +72,36 @@ enum CostUsageJsonl {
         }
 
         while true {
-            let chunk = try handle.read(upToCount: 256 * 1024) ?? Data()
-            if chunk.isEmpty {
-                flushLine()
-                break
-            }
+            try checkCancellation?()
+            let reachedEOF = try autoreleasepool {
+                let chunk = try handle.read(upToCount: 256 * 1024) ?? Data()
+                if chunk.isEmpty {
+                    flushLine()
+                    return true
+                }
 
-            bytesRead += Int64(chunk.count)
-            var segmentStart = chunk.startIndex
-            while let nl = chunk[segmentStart...].firstIndex(of: 0x0A) {
-                appendSegment(chunk[segmentStart..<nl])
-                flushLine()
-                segmentStart = chunk.index(after: nl)
-            }
-            if segmentStart < chunk.endIndex {
-                appendSegment(chunk[segmentStart..<chunk.endIndex])
+                try checkCancellation?()
+                bytesRead += Int64(chunk.count)
+                chunk.withUnsafeBytes { rawBuffer in
+                    guard let base = rawBuffer.bindMemory(to: UInt8.self).baseAddress else { return }
+                    var segmentStart = 0
+                    var index = 0
+                    while index < rawBuffer.count {
+                        if base[index] == 0x0A {
+                            appendSegment(base.advanced(by: segmentStart), count: index - segmentStart)
+                            flushLine()
+                            segmentStart = index + 1
+                        }
+                        index += 1
+                    }
+                    if segmentStart < rawBuffer.count {
+                        appendSegment(base.advanced(by: segmentStart), count: rawBuffer.count - segmentStart)
+                    }
+                }
+                return false
             }
+            if reachedEOF { break }
+            try checkCancellation?()
         }
 
         return startOffset + bytesRead
diff --git a/Sources/CodexBarCore/Vendored/CostUsage/CostUsagePricing.swift b/Sources/CodexBarCore/Vendored/CostUsage/CostUsagePricing.swift
index ffc7b1b91a..26017ae4c1 100644
--- a/Sources/CodexBarCore/Vendored/CostUsage/CostUsagePricing.swift
+++ b/Sources/CodexBarCore/Vendored/CostUsage/CostUsagePricing.swift
@@ -1,13 +1,50 @@
 import Foundation
 
 enum CostUsagePricing {
-    struct CodexPricing: Sendable {
+    private static let codexPriorityInputTokenLimit = 272_000
+
+    struct CodexPricing {
         let inputCostPerToken: Double
         let outputCostPerToken: Double
-        let cacheReadInputCostPerToken: Double
+        let cacheReadInputCostPerToken: Double?
+        let displayLabel: String?
+
+        let thresholdTokens: Int?
+        let inputCostPerTokenAboveThreshold: Double?
+        let outputCostPerTokenAboveThreshold: Double?
+        let cacheReadInputCostPerTokenAboveThreshold: Double?
+        let priorityInputCostPerToken: Double?
+        let priorityOutputCostPerToken: Double?
+        let priorityCacheReadInputCostPerToken: Double?
+
+        init(
+            inputCostPerToken: Double,
+            outputCostPerToken: Double,
+            cacheReadInputCostPerToken: Double?,
+            displayLabel: String?,
+            thresholdTokens: Int? = nil,
+            inputCostPerTokenAboveThreshold: Double? = nil,
+            outputCostPerTokenAboveThreshold: Double? = nil,
+            cacheReadInputCostPerTokenAboveThreshold: Double? = nil,
+            priorityInputCostPerToken: Double? = nil,
+            priorityOutputCostPerToken: Double? = nil,
+            priorityCacheReadInputCostPerToken: Double? = nil)
+        {
+            self.inputCostPerToken = inputCostPerToken
+            self.outputCostPerToken = outputCostPerToken
+            self.cacheReadInputCostPerToken = cacheReadInputCostPerToken
+            self.displayLabel = displayLabel
+            self.thresholdTokens = thresholdTokens
+            self.inputCostPerTokenAboveThreshold = inputCostPerTokenAboveThreshold
+            self.outputCostPerTokenAboveThreshold = outputCostPerTokenAboveThreshold
+            self.cacheReadInputCostPerTokenAboveThreshold = cacheReadInputCostPerTokenAboveThreshold
+            self.priorityInputCostPerToken = priorityInputCostPerToken
+            self.priorityOutputCostPerToken = priorityOutputCostPerToken
+            self.priorityCacheReadInputCostPerToken = priorityCacheReadInputCostPerToken
+        }
     }
 
-    struct ClaudePricing: Sendable {
+    struct ClaudePricing {
         let inputCostPerToken: Double
         let outputCostPerToken: Double
         let cacheCreationInputCostPerToken: Double
@@ -20,38 +57,172 @@ enum CostUsagePricing {
         let cacheReadInputCostPerTokenAboveThreshold: Double?
     }
 
+    private struct ClaudeCostTokens {
+        let input: Int
+        let cacheRead: Int
+        let cacheCreation: Int
+        let cacheCreation1h: Int
+        let output: Int
+    }
+
     private static let codex: [String: CodexPricing] = [
         "gpt-5": CodexPricing(
             inputCostPerToken: 1.25e-6,
             outputCostPerToken: 1e-5,
-            cacheReadInputCostPerToken: 1.25e-7),
+            cacheReadInputCostPerToken: 1.25e-7,
+            displayLabel: nil),
         "gpt-5-codex": CodexPricing(
             inputCostPerToken: 1.25e-6,
             outputCostPerToken: 1e-5,
-            cacheReadInputCostPerToken: 1.25e-7),
+            cacheReadInputCostPerToken: 1.25e-7,
+            displayLabel: nil),
+        "gpt-5-mini": CodexPricing(
+            inputCostPerToken: 2.5e-7,
+            outputCostPerToken: 2e-6,
+            cacheReadInputCostPerToken: 2.5e-8,
+            displayLabel: nil),
+        "gpt-5-nano": CodexPricing(
+            inputCostPerToken: 5e-8,
+            outputCostPerToken: 4e-7,
+            cacheReadInputCostPerToken: 5e-9,
+            displayLabel: nil),
+        "gpt-5-pro": CodexPricing(
+            inputCostPerToken: 1.5e-5,
+            outputCostPerToken: 1.2e-4,
+            cacheReadInputCostPerToken: nil,
+            displayLabel: nil),
         "gpt-5.1": CodexPricing(
             inputCostPerToken: 1.25e-6,
             outputCostPerToken: 1e-5,
-            cacheReadInputCostPerToken: 1.25e-7),
+            cacheReadInputCostPerToken: 1.25e-7,
+            displayLabel: nil),
+        "gpt-5.1-codex": CodexPricing(
+            inputCostPerToken: 1.25e-6,
+            outputCostPerToken: 1e-5,
+            cacheReadInputCostPerToken: 1.25e-7,
+            displayLabel: nil),
+        "gpt-5.1-codex-max": CodexPricing(
+            inputCostPerToken: 1.25e-6,
+            outputCostPerToken: 1e-5,
+            cacheReadInputCostPerToken: 1.25e-7,
+            displayLabel: nil),
+        "gpt-5.1-codex-mini": CodexPricing(
+            inputCostPerToken: 2.5e-7,
+            outputCostPerToken: 2e-6,
+            cacheReadInputCostPerToken: 2.5e-8,
+            displayLabel: nil),
         "gpt-5.2": CodexPricing(
             inputCostPerToken: 1.75e-6,
             outputCostPerToken: 1.4e-5,
-            cacheReadInputCostPerToken: 1.75e-7),
+            cacheReadInputCostPerToken: 1.75e-7,
+            displayLabel: nil),
         "gpt-5.2-codex": CodexPricing(
             inputCostPerToken: 1.75e-6,
             outputCostPerToken: 1.4e-5,
-            cacheReadInputCostPerToken: 1.75e-7),
-        "gpt-5.3": CodexPricing(
-            inputCostPerToken: 1.75e-6,
-            outputCostPerToken: 1.4e-5,
-            cacheReadInputCostPerToken: 1.75e-7),
+            cacheReadInputCostPerToken: 1.75e-7,
+            displayLabel: nil),
+        "gpt-5.2-pro": CodexPricing(
+            inputCostPerToken: 2.1e-5,
+            outputCostPerToken: 1.68e-4,
+            cacheReadInputCostPerToken: nil,
+            displayLabel: nil),
         "gpt-5.3-codex": CodexPricing(
             inputCostPerToken: 1.75e-6,
             outputCostPerToken: 1.4e-5,
-            cacheReadInputCostPerToken: 1.75e-7),
+            cacheReadInputCostPerToken: 1.75e-7,
+            displayLabel: nil),
+        "gpt-5.3-codex-spark": CodexPricing(
+            inputCostPerToken: 0,
+            outputCostPerToken: 0,
+            cacheReadInputCostPerToken: 0,
+            displayLabel: "Research Preview"),
+        "gpt-5.4": CodexPricing(
+            inputCostPerToken: 2.5e-6,
+            outputCostPerToken: 1.5e-5,
+            cacheReadInputCostPerToken: 2.5e-7,
+            displayLabel: nil,
+            thresholdTokens: 272_000,
+            inputCostPerTokenAboveThreshold: 5e-6,
+            outputCostPerTokenAboveThreshold: 2.25e-5,
+            cacheReadInputCostPerTokenAboveThreshold: 5e-7,
+            priorityInputCostPerToken: 5e-6,
+            priorityOutputCostPerToken: 3e-5,
+            priorityCacheReadInputCostPerToken: 5e-7),
+        "gpt-5.4-mini": CodexPricing(
+            inputCostPerToken: 7.5e-7,
+            outputCostPerToken: 4.5e-6,
+            cacheReadInputCostPerToken: 7.5e-8,
+            displayLabel: nil,
+            priorityInputCostPerToken: 1.5e-6,
+            priorityOutputCostPerToken: 9e-6,
+            priorityCacheReadInputCostPerToken: 1.5e-7),
+        "gpt-5.4-nano": CodexPricing(
+            inputCostPerToken: 2e-7,
+            outputCostPerToken: 1.25e-6,
+            cacheReadInputCostPerToken: 2e-8,
+            displayLabel: nil),
+        "gpt-5.4-pro": CodexPricing(
+            inputCostPerToken: 3e-5,
+            outputCostPerToken: 1.8e-4,
+            cacheReadInputCostPerToken: nil,
+            displayLabel: nil),
+        "gpt-5.5": CodexPricing(
+            inputCostPerToken: 5e-6,
+            outputCostPerToken: 3e-5,
+            cacheReadInputCostPerToken: 5e-7,
+            displayLabel: nil,
+            thresholdTokens: 272_000,
+            inputCostPerTokenAboveThreshold: 1e-5,
+            outputCostPerTokenAboveThreshold: 4.5e-5,
+            cacheReadInputCostPerTokenAboveThreshold: 1e-6,
+            priorityInputCostPerToken: 1.25e-5,
+            priorityOutputCostPerToken: 7.5e-5,
+            priorityCacheReadInputCostPerToken: 1.25e-6),
+        "gpt-5.5-pro": CodexPricing(
+            inputCostPerToken: 3e-5,
+            outputCostPerToken: 1.8e-4,
+            cacheReadInputCostPerToken: nil,
+            displayLabel: nil),
     ]
 
+    static func codexBuiltInPricingFingerprint() -> String {
+        var parts = ["priorityInputTokenLimit=\(self.codexPriorityInputTokenLimit)"]
+        for model in self.codex.keys.sorted() {
+            guard let pricing = self.codex[model] else { continue }
+            parts.append([
+                "model=\(model)",
+                self.optionalPricingFingerprint(pricing.inputCostPerToken),
+                self.optionalPricingFingerprint(pricing.outputCostPerToken),
+                self.optionalPricingFingerprint(pricing.cacheReadInputCostPerToken),
+                pricing.displayLabel ?? "nil",
+                pricing.thresholdTokens.map(String.init) ?? "nil",
+                self.optionalPricingFingerprint(pricing.inputCostPerTokenAboveThreshold),
+                self.optionalPricingFingerprint(pricing.outputCostPerTokenAboveThreshold),
+                self.optionalPricingFingerprint(pricing.cacheReadInputCostPerTokenAboveThreshold),
+                self.optionalPricingFingerprint(pricing.priorityInputCostPerToken),
+                self.optionalPricingFingerprint(pricing.priorityOutputCostPerToken),
+                self.optionalPricingFingerprint(pricing.priorityCacheReadInputCostPerToken),
+            ].joined(separator: "|"))
+        }
+        return parts.joined(separator: "\n")
+    }
+
+    private static func optionalPricingFingerprint(_ value: Double?) -> String {
+        guard let value else { return "nil" }
+        return String(format: "%.17g", value)
+    }
+
     private static let claude: [String: ClaudePricing] = [
+        "claude-fable-5": ClaudePricing(
+            inputCostPerToken: 1e-5,
+            outputCostPerToken: 5e-5,
+            cacheCreationInputCostPerToken: 1.25e-5,
+            cacheReadInputCostPerToken: 1e-6,
+            thresholdTokens: nil,
+            inputCostPerTokenAboveThreshold: nil,
+            outputCostPerTokenAboveThreshold: nil,
+            cacheCreationInputCostPerTokenAboveThreshold: nil,
+            cacheReadInputCostPerTokenAboveThreshold: nil),
         "claude-haiku-4-5-20251001": ClaudePricing(
             inputCostPerToken: 1e-6,
             outputCostPerToken: 5e-6,
@@ -112,6 +283,26 @@ enum CostUsagePricing {
             outputCostPerTokenAboveThreshold: nil,
             cacheCreationInputCostPerTokenAboveThreshold: nil,
             cacheReadInputCostPerTokenAboveThreshold: nil),
+        "claude-opus-4-7": ClaudePricing(
+            inputCostPerToken: 5e-6,
+            outputCostPerToken: 2.5e-5,
+            cacheCreationInputCostPerToken: 6.25e-6,
+            cacheReadInputCostPerToken: 5e-7,
+            thresholdTokens: nil,
+            inputCostPerTokenAboveThreshold: nil,
+            outputCostPerTokenAboveThreshold: nil,
+            cacheCreationInputCostPerTokenAboveThreshold: nil,
+            cacheReadInputCostPerTokenAboveThreshold: nil),
+        "claude-opus-4-8": ClaudePricing(
+            inputCostPerToken: 5e-6,
+            outputCostPerToken: 2.5e-5,
+            cacheCreationInputCostPerToken: 6.25e-6,
+            cacheReadInputCostPerToken: 5e-7,
+            thresholdTokens: nil,
+            inputCostPerTokenAboveThreshold: nil,
+            outputCostPerTokenAboveThreshold: nil,
+            cacheCreationInputCostPerTokenAboveThreshold: nil,
+            cacheReadInputCostPerTokenAboveThreshold: nil),
         "claude-sonnet-4-5": ClaudePricing(
             inputCostPerToken: 3e-6,
             outputCostPerToken: 1.5e-5,
@@ -122,6 +313,16 @@ enum CostUsagePricing {
             outputCostPerTokenAboveThreshold: 2.25e-5,
             cacheCreationInputCostPerTokenAboveThreshold: 7.5e-6,
             cacheReadInputCostPerTokenAboveThreshold: 6e-7),
+        "claude-sonnet-4-6": ClaudePricing(
+            inputCostPerToken: 3e-6,
+            outputCostPerToken: 1.5e-5,
+            cacheCreationInputCostPerToken: 3.75e-6,
+            cacheReadInputCostPerToken: 3e-7,
+            thresholdTokens: nil,
+            inputCostPerTokenAboveThreshold: nil,
+            outputCostPerTokenAboveThreshold: nil,
+            cacheCreationInputCostPerTokenAboveThreshold: nil,
+            cacheReadInputCostPerTokenAboveThreshold: nil),
         "claude-sonnet-4-5-20250929": ClaudePricing(
             inputCostPerToken: 3e-6,
             outputCostPerToken: 1.5e-5,
@@ -164,18 +365,57 @@ enum CostUsagePricing {
             cacheReadInputCostPerTokenAboveThreshold: 6e-7),
     ]
 
+    private static let claudeFullContextStandardPricingCutoff = Date(timeIntervalSince1970: 1_773_360_000)
+    private static let claudeHistoricalLongContext: [String: ClaudePricing] = [
+        "claude-opus-4-6": ClaudePricing(
+            inputCostPerToken: 5e-6,
+            outputCostPerToken: 2.5e-5,
+            cacheCreationInputCostPerToken: 6.25e-6,
+            cacheReadInputCostPerToken: 5e-7,
+            thresholdTokens: 200_000,
+            inputCostPerTokenAboveThreshold: 1e-5,
+            outputCostPerTokenAboveThreshold: 3.75e-5,
+            cacheCreationInputCostPerTokenAboveThreshold: 1.25e-5,
+            cacheReadInputCostPerTokenAboveThreshold: 1e-6),
+        "claude-sonnet-4-6": ClaudePricing(
+            inputCostPerToken: 3e-6,
+            outputCostPerToken: 1.5e-5,
+            cacheCreationInputCostPerToken: 3.75e-6,
+            cacheReadInputCostPerToken: 3e-7,
+            thresholdTokens: 200_000,
+            inputCostPerTokenAboveThreshold: 6e-6,
+            outputCostPerTokenAboveThreshold: 2.25e-5,
+            cacheCreationInputCostPerTokenAboveThreshold: 7.5e-6,
+            cacheReadInputCostPerTokenAboveThreshold: 6e-7),
+    ]
+
+    private static let codexModelsDevProviderID = "openai"
+    private static let claudeModelsDevProviderID = "anthropic"
+
     static func normalizeCodexModel(_ raw: String) -> String {
         var trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines)
         if trimmed.hasPrefix("openai/") {
             trimmed = String(trimmed.dropFirst("openai/".count))
         }
-        if let codexRange = trimmed.range(of: "-codex") {
-            let base = String(trimmed[..<codexRange.lowerBound])
-            if self.codex[base] != nil { return base }
+
+        if self.codex[trimmed] != nil {
+            return trimmed
+        }
+
+        if let datedSuffix = trimmed.range(of: #"-\d{4}-\d{2}-\d{2}$"#, options: .regularExpression) {
+            let base = String(trimmed[..<datedSuffix.lowerBound])
+            if self.codex[base] != nil {
+                return base
+            }
         }
         return trimmed
     }
 
+    static func codexDisplayLabel(model: String) -> String? {
+        let key = self.normalizeCodexModel(model)
+        return self.codex[key]?.displayLabel
+    }
+
     static func normalizeClaudeModel(_ raw: String) -> String {
         var trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines)
         if trimmed.hasPrefix("anthropic.") {
@@ -205,14 +445,110 @@ enum CostUsagePricing {
         return trimmed
     }
 
-    static func codexCostUSD(model: String, inputTokens: Int, cachedInputTokens: Int, outputTokens: Int) -> Double? {
+    static func codexCostUSD(
+        model: String,
+        inputTokens: Int,
+        cachedInputTokens: Int,
+        outputTokens: Int,
+        modelsDevCatalog: ModelsDevCatalog? = nil,
+        modelsDevCacheRoot: URL? = nil) -> Double?
+    {
         let key = self.normalizeCodexModel(model)
+        if let lookup = self.modelsDevLookup(
+            providerID: self.codexModelsDevProviderID,
+            model: model,
+            catalog: modelsDevCatalog,
+            cacheRoot: modelsDevCacheRoot)
+        {
+            return self.codexCostUSD(
+                pricing: lookup.pricing,
+                thresholdTokens: self.codex[key]?.thresholdTokens,
+                inputTokens: inputTokens,
+                cachedInputTokens: cachedInputTokens,
+                outputTokens: outputTokens)
+        }
+
         guard let pricing = self.codex[key] else { return nil }
+        return self.codexCostUSD(
+            pricing: pricing,
+            inputTokens: inputTokens,
+            cachedInputTokens: cachedInputTokens,
+            outputTokens: outputTokens)
+    }
+
+    static func codexPriorityCostUSD(
+        model: String,
+        inputTokens: Int,
+        cachedInputTokens: Int = 0,
+        outputTokens: Int) -> Double?
+    {
+        let key = self.normalizeCodexModel(model)
+        guard let pricing = self.codex[key],
+              let priorityInputCostPerToken = pricing.priorityInputCostPerToken,
+              let priorityOutputCostPerToken = pricing.priorityOutputCostPerToken
+        else { return nil }
+        if max(0, inputTokens) > self.codexPriorityInputTokenLimit {
+            return nil
+        }
+
+        let priorityPricing = CodexPricing(
+            inputCostPerToken: priorityInputCostPerToken,
+            outputCostPerToken: priorityOutputCostPerToken,
+            cacheReadInputCostPerToken: pricing.priorityCacheReadInputCostPerToken,
+            displayLabel: nil)
+        return self.codexCostUSD(
+            pricing: priorityPricing,
+            inputTokens: inputTokens,
+            cachedInputTokens: cachedInputTokens,
+            outputTokens: outputTokens)
+    }
+
+    private static func codexCostUSD(
+        pricing: CodexPricing,
+        inputTokens: Int,
+        cachedInputTokens: Int,
+        outputTokens: Int) -> Double
+    {
         let cached = min(max(0, cachedInputTokens), max(0, inputTokens))
         let nonCached = max(0, inputTokens - cached)
-        return Double(nonCached) * pricing.inputCostPerToken
-            + Double(cached) * pricing.cacheReadInputCostPerToken
-            + Double(max(0, outputTokens)) * pricing.outputCostPerToken
+        let cachedRate = pricing.cacheReadInputCostPerToken ?? pricing.inputCostPerToken
+
+        let usesLongContextRates = pricing.thresholdTokens.map { max(0, inputTokens) > $0 } ?? false
+        let inputRate = usesLongContextRates
+            ? pricing.inputCostPerTokenAboveThreshold ?? pricing.inputCostPerToken
+            : pricing.inputCostPerToken
+        let cachedInputRate = usesLongContextRates
+            ? pricing.cacheReadInputCostPerTokenAboveThreshold ?? cachedRate
+            : cachedRate
+        let outputRate = usesLongContextRates
+            ? pricing.outputCostPerTokenAboveThreshold ?? pricing.outputCostPerToken
+            : pricing.outputCostPerToken
+
+        return (Double(nonCached) * inputRate)
+            + (Double(cached) * cachedInputRate)
+            + (Double(max(0, outputTokens)) * outputRate)
+    }
+
+    private static func codexCostUSD(
+        pricing: ModelsDevPricingInfo,
+        thresholdTokens: Int? = nil,
+        inputTokens: Int,
+        cachedInputTokens: Int,
+        outputTokens: Int) -> Double
+    {
+        self.codexCostUSD(
+            pricing: CodexPricing(
+                inputCostPerToken: pricing.inputCostPerToken,
+                outputCostPerToken: pricing.outputCostPerToken,
+                cacheReadInputCostPerToken: pricing.cacheReadInputCostPerToken,
+                displayLabel: nil,
+                thresholdTokens: thresholdTokens ?? pricing.thresholdTokens,
+                inputCostPerTokenAboveThreshold: pricing.inputCostPerTokenAboveThreshold,
+                outputCostPerTokenAboveThreshold: pricing.outputCostPerTokenAboveThreshold,
+                cacheReadInputCostPerTokenAboveThreshold: pricing.cacheReadInputCostPerTokenAboveThreshold),
+            inputTokens: inputTokens,
+            cachedInputTokens: cachedInputTokens,
+            outputTokens: outputTokens)
     }
 
     static func claudeCostUSD(
@@ -220,37 +556,113 @@ enum CostUsagePricing {
         inputTokens: Int,
         cacheReadInputTokens: Int,
         cacheCreationInputTokens: Int,
-        outputTokens: Int) -> Double?
+        cacheCreationInputTokens1h: Int = 0,
+        outputTokens: Int,
+        pricingDate: Date? = nil,
+        modelsDevCatalog: ModelsDevCatalog? = nil,
+        modelsDevCacheRoot: URL? = nil) -> Double?
     {
+        let tokens = ClaudeCostTokens(
+            input: inputTokens,
+            cacheRead: cacheReadInputTokens,
+            cacheCreation: cacheCreationInputTokens,
+            cacheCreation1h: cacheCreationInputTokens1h,
+            output: outputTokens)
         let key = self.normalizeClaudeModel(model)
+        if let pricingDate,
+           let historicalPricing = self.claudeHistoricalLongContext[key],
+           let currentPricing = self.claude[key]
+        {
+            return self.claudeCostUSD(
+                pricing: pricingDate < self.claudeFullContextStandardPricingCutoff
+                    ? historicalPricing
+                    : currentPricing,
+                tokens: tokens)
+        }
+        if let lookup = self.modelsDevLookup(
+            providerID: self.claudeModelsDevProviderID,
+            model: model,
+            catalog: modelsDevCatalog,
+            cacheRoot: modelsDevCacheRoot)
+        {
+            return self.claudeCostUSD(
+                pricing: lookup.pricing,
+                tokens: tokens)
+        }
+
         guard let pricing = self.claude[key] else { return nil }
+        return self.claudeCostUSD(
+            pricing: pricing,
+            tokens: tokens)
+    }
+
+    private static func claudeCostUSD(
+        pricing: ClaudePricing,
+        tokens: ClaudeCostTokens) -> Double
+    {
+        let input = max(0, tokens.input)
+        let cacheRead = max(0, tokens.cacheRead)
+        let cacheCreationTotal = max(0, tokens.cacheCreation)
+        let cacheCreation1h = min(max(0, tokens.cacheCreation1h), cacheCreationTotal)
+        let cacheCreation5m = cacheCreationTotal - cacheCreation1h
+        let usesLongContextRates = pricing.thresholdTokens.map {
+            input + cacheRead + cacheCreationTotal > $0
+        } ?? false
+        let inputRate = usesLongContextRates
+            ? pricing.inputCostPerTokenAboveThreshold ?? pricing.inputCostPerToken
+            : pricing.inputCostPerToken
+        let cacheReadRate = usesLongContextRates
+            ? pricing.cacheReadInputCostPerTokenAboveThreshold ?? pricing.cacheReadInputCostPerToken
+            : pricing.cacheReadInputCostPerToken
+        let cacheCreation5mRate = usesLongContextRates
+            ? pricing.cacheCreationInputCostPerTokenAboveThreshold ?? pricing.cacheCreationInputCostPerToken
+            : pricing.cacheCreationInputCostPerToken
+        let outputRate = usesLongContextRates
+            ? pricing.outputCostPerTokenAboveThreshold ?? pricing.outputCostPerToken
+            : pricing.outputCostPerToken
+
+        return Double(input) * inputRate
+            + Double(cacheRead) * cacheReadRate
+            + Double(cacheCreation5m) * cacheCreation5mRate
+            + Double(cacheCreation1h) * inputRate * 2
+            + Double(max(0, tokens.output)) * outputRate
+    }
+
+    private static func claudeCostUSD(
+        pricing: ModelsDevPricingInfo,
+        tokens: ClaudeCostTokens) -> Double
+    {
+        self.claudeCostUSD(
+            pricing: ClaudePricing(
+                inputCostPerToken: pricing.inputCostPerToken,
+                outputCostPerToken: pricing.outputCostPerToken,
+                cacheCreationInputCostPerToken: pricing.cacheCreationInputCostPerToken ?? pricing.inputCostPerToken,
+                cacheReadInputCostPerToken: pricing.cacheReadInputCostPerToken ?? pricing.inputCostPerToken,
+                thresholdTokens: pricing.thresholdTokens,
+                inputCostPerTokenAboveThreshold: pricing.inputCostPerTokenAboveThreshold,
+                outputCostPerTokenAboveThreshold: pricing.outputCostPerTokenAboveThreshold,
+                cacheCreationInputCostPerTokenAboveThreshold: pricing.cacheCreationInputCostPerTokenAboveThreshold,
+                cacheReadInputCostPerTokenAboveThreshold: pricing.cacheReadInputCostPerTokenAboveThreshold),
+            tokens: tokens)
+    }
 
-        func tiered(_ tokens: Int, base: Double, above: Double?, threshold: Int?) -> Double {
-            guard let threshold, let above else { return Double(tokens) * base }
-            let below = min(tokens, threshold)
-            let over = max(tokens - threshold, 0)
-            return Double(below) * base + Double(over) * above
+    static func modelsDevCatalog(now: Date = Date(), cacheRoot: URL? = nil) -> ModelsDevCatalog? {
+        ModelsDevCache.load(now: now, cacheRoot: cacheRoot).artifact?.catalog
+    }
+
+    private static func modelsDevLookup(
+        providerID: String,
+        model: String,
+        catalog: ModelsDevCatalog?,
+        cacheRoot: URL?) -> ModelsDevPricingLookup?
+    {
+        if let catalog {
+            return catalog.pricing(providerID: providerID, modelID: model)
         }
 
-        return tiered(
-            max(0, inputTokens),
-            base: pricing.inputCostPerToken,
-            above: pricing.inputCostPerTokenAboveThreshold,
-            threshold: pricing.thresholdTokens)
-            + tiered(
-                max(0, cacheReadInputTokens),
-                base: pricing.cacheReadInputCostPerToken,
-                above: pricing.cacheReadInputCostPerTokenAboveThreshold,
-                threshold: pricing.thresholdTokens)
-            + tiered(
-                max(0, cacheCreationInputTokens),
-                base: pricing.cacheCreationInputCostPerToken,
-                above: pricing.cacheCreationInputCostPerTokenAboveThreshold,
-                threshold: pricing.thresholdTokens)
-            + tiered(
-                max(0, outputTokens),
-                base: pricing.outputCostPerToken,
-                above: pricing.outputCostPerTokenAboveThreshold,
-                threshold: pricing.thresholdTokens)
+        return ModelsDevPricingPipeline.lookup(
+            providerID: providerID,
+            modelID: model,
+            cacheRoot: cacheRoot)
     }
 }
diff --git a/Sources/CodexBarCore/Vendored/CostUsage/CostUsageScanner+CacheHelpers.swift b/Sources/CodexBarCore/Vendored/CostUsage/CostUsageScanner+CacheHelpers.swift
new file mode 100644
index 0000000000..0e7ea82ce7
--- /dev/null
+++ b/Sources/CodexBarCore/Vendored/CostUsage/CostUsageScanner+CacheHelpers.swift
@@ -0,0 +1,1212 @@
+import Foundation
+#if canImport(Musl)
+import Musl
+#elseif canImport(Glibc)
+import Glibc
+#else
+import Darwin
+#endif
+
+extension CostUsageScanner {
+    static func codexRowsByDayModel(
+        cache: CostUsageCache,
+        range: CostUsageDayRange) -> [String: [String: [CodexUsageRow]]]
+    {
+        var rowsByDayModel: [String: [String: [CodexUsageRow]]] = [:]
+        for usage in cache.files.values {
+            for row in usage.codexRows ?? [] {
+                guard CostUsageDayRange.isInRange(dayKey: row.day, since: range.sinceKey, until: range.untilKey)
+                else { continue }
+                rowsByDayModel[row.day, default: [:]][row.model, default: []].append(row)
+            }
+        }
+        return rowsByDayModel
+    }
+
+    static func codexRowsByDayModel(
+        rows: [CodexUsageRow],
+        range: CostUsageDayRange) -> [String: [String: [CodexUsageRow]]]
+    {
+        var rowsByDayModel: [String: [String: [CodexUsageRow]]] = [:]
+        for row in rows {
+            guard CostUsageDayRange.isInRange(dayKey: row.day, since: range.sinceKey, until: range.untilKey)
+            else { continue }
+            rowsByDayModel[row.day, default: [:]][row.model, default: []].append(row)
+        }
+        return rowsByDayModel
+    }
+
+    static func codexCostNanosByDayModel(
+        cache: CostUsageCache,
+        range: CostUsageDayRange) -> [String: [String: Int64]]
+    {
+        self.codexNanosByDayModel(cache: cache, range: range) { $0.codexCostNanos }
+    }
+
+    static func codexPrioritySurchargeNanosByDayModel(
+        cache: CostUsageCache,
+        range: CostUsageDayRange) -> [String: [String: Int64]]
+    {
+        self.codexNanosByDayModel(cache: cache, range: range) { $0.codexPrioritySurchargeNanos }
+    }
+
+    static func codexStandardCostNanosByDayModel(
+        cache: CostUsageCache,
+        range: CostUsageDayRange) -> [String: [String: Int64]]
+    {
+        self.codexNanosByDayModel(cache: cache, range: range) { $0.codexStandardCostNanos }
+    }
+
+    static func codexPriorityCostNanosByDayModel(
+        cache: CostUsageCache,
+        range: CostUsageDayRange) -> [String: [String: Int64]]
+    {
+        self.codexNanosByDayModel(cache: cache, range: range) { $0.codexPriorityCostNanos }
+    }
+
+    static func codexStandardTokensByDayModel(
+        cache: CostUsageCache,
+        range: CostUsageDayRange) -> [String: [String: Int]]
+    {
+        self.codexIntByDayModel(cache: cache, range: range) { $0.codexStandardTokens }
+    }
+
+    static func codexPriorityTokensByDayModel(
+        cache: CostUsageCache,
+        range: CostUsageDayRange) -> [String: [String: Int]]
+    {
+        self.codexIntByDayModel(cache: cache, range: range) { $0.codexPriorityTokens }
+    }
+
+    static func codexNanosByDayModel(
+        cache: CostUsageCache,
+        range: CostUsageDayRange,
+        keyPath: (CostUsageFileUsage) -> [String: [String: Int64]]?) -> [String: [String: Int64]]
+    {
+        var out: [String: [String: Int64]] = [:]
+        for usage in cache.files.values {
+            for (day, models) in keyPath(usage) ?? [:] {
+                guard CostUsageDayRange.isInRange(dayKey: day, since: range.sinceKey, until: range.untilKey)
+                else { continue }
+                for (model, value) in models {
+                    out[day, default: [:]][model, default: 0] += value
+                }
+            }
+        }
+        return out
+    }
+
+    static func codexIntByDayModel(
+        cache: CostUsageCache,
+        range: CostUsageDayRange,
+        keyPath: (CostUsageFileUsage) -> [String: [String: Int]]?) -> [String: [String: Int]]
+    {
+        var out: [String: [String: Int]] = [:]
+        for usage in cache.files.values {
+            for (day, models) in keyPath(usage) ?? [:] {
+                guard CostUsageDayRange.isInRange(dayKey: day, since: range.sinceKey, until: range.untilKey)
+                else { continue }
+                for (model, value) in models {
+                    out[day, default: [:]][model, default: 0] += value
+                }
+            }
+        }
+        return out
+    }
+
+    static func codexRowsCostUSD(
+        rows: [CodexUsageRow],
+        modelsDevCatalog: ModelsDevCatalog?,
+        modelsDevCacheRoot: URL?) -> Double?
+    {
+        var total: Double = 0
+        var seen = false
+        for row in rows {
+            guard let cost = CostUsagePricing.codexCostUSD(
+                model: row.model,
+                inputTokens: row.input,
+                cachedInputTokens: row.cached,
+                outputTokens: row.output,
+                modelsDevCatalog: modelsDevCatalog,
+                modelsDevCacheRoot: modelsDevCacheRoot)
+            else { continue }
+            total += cost
+            seen = true
+        }
+        return seen ? total : nil
+    }
+
+    static func codexPrioritySurchargeUSD(
+        rows: [CodexUsageRow],
+        priorityTurns: [String: CodexPriorityTurnMetadata],
+        modelsDevCatalog: ModelsDevCatalog?,
+        modelsDevCacheRoot: URL?) -> Double?
+    {
+        var total: Double = 0
+        var seen = false
+        for row in rows {
+            guard let turnID = row.turnID, let priorityMetadata = priorityTurns[turnID] else { continue }
+            let pricedModel = Self.codexPriorityPricingModel(for: row, priorityMetadata: priorityMetadata)
+            guard let baseCost = CostUsagePricing.codexCostUSD(
+                model: pricedModel,
+                inputTokens: row.input,
+                cachedInputTokens: row.cached,
+                outputTokens: row.output,
+                modelsDevCatalog: modelsDevCatalog,
+                modelsDevCacheRoot: modelsDevCacheRoot),
+                let priorityCost = CostUsagePricing.codexPriorityCostUSD(
+                    model: pricedModel,
+                    inputTokens: row.input,
+                    cachedInputTokens: row.cached,
+                    outputTokens: row.output)
+            else { continue }
+            total += max(priorityCost - baseCost, 0)
+            seen = true
+        }
+        return seen ? total : nil
+    }
+
+    private static func codexPriorityPricingModel(
+        for row: CodexUsageRow,
+        priorityMetadata: CodexPriorityTurnMetadata) -> String
+    {
+        guard let model = priorityMetadata.model,
+              CostUsagePricing.codexPriorityCostUSD(
+                  model: model,
+                  inputTokens: row.input,
+                  cachedInputTokens: row.cached,
+                  outputTokens: row.output) != nil
+        else { return row.model }
+        return model
+    }
+
+    struct CodexRowCostBreakdown {
+        var standardCostUSD: Double = 0
+        var priorityCostUSD: Double = 0
+        var standardTokens: Int = 0
+        var priorityTokens: Int = 0
+        var sawStandardCost = false
+        var sawPriorityCost = false
+
+        var optionalStandardCostUSD: Double? {
+            self.sawStandardCost ? self.standardCostUSD : nil
+        }
+
+        var optionalPriorityCostUSD: Double? {
+            self.sawPriorityCost ? self.priorityCostUSD : nil
+        }
+
+        var optionalStandardTokens: Int? {
+            self.standardTokens > 0 ? self.standardTokens : nil
+        }
+
+        var optionalPriorityTokens: Int? {
+            self.priorityTokens > 0 ? self.priorityTokens : nil
+        }
+
+        var totalCostUSD: Double? {
+            guard self.sawStandardCost || self.sawPriorityCost else { return nil }
+            return self.standardCostUSD + self.priorityCostUSD
+        }
+
+        var hasModeSplit: Bool {
+            self.sawPriorityCost || self.priorityTokens > 0
+        }
+    }
+
+    static func codexRowCostBreakdown(
+        rows: [CodexUsageRow],
+        priorityTurns: [String: CodexPriorityTurnMetadata],
+        modelsDevCatalog: ModelsDevCatalog?,
+        modelsDevCacheRoot: URL?) -> CodexRowCostBreakdown
+    {
+        var breakdown = CodexRowCostBreakdown()
+        for row in rows {
+            let tokenCount = row.input + row.output
+            let priorityMetadata = row.turnID.flatMap { priorityTurns[$0] }
+            let isPriority = priorityMetadata != nil
+            if isPriority {
+                breakdown.priorityTokens += tokenCount
+            } else {
+                breakdown.standardTokens += tokenCount
+            }
+            let pricedModel = priorityMetadata.map { Self.codexPriorityPricingModel(for: row, priorityMetadata: $0) }
+                ?? row.model
+
+            let baseCost = CostUsagePricing.codexCostUSD(
+                model: pricedModel,
+                inputTokens: row.input,
+                cachedInputTokens: row.cached,
+                outputTokens: row.output,
+                modelsDevCatalog: modelsDevCatalog,
+                modelsDevCacheRoot: modelsDevCacheRoot)
+            if isPriority, let priorityCost = CostUsagePricing.codexPriorityCostUSD(
+                model: pricedModel,
+                inputTokens: row.input,
+                cachedInputTokens: row.cached,
+                outputTokens: row.output)
+            {
+                breakdown.priorityCostUSD += max(priorityCost, baseCost ?? priorityCost)
+                breakdown.sawPriorityCost = true
+            } else if isPriority, let baseCost {
+                breakdown.priorityCostUSD += baseCost
+                breakdown.sawPriorityCost = true
+            } else if let baseCost {
+                breakdown.standardCostUSD += baseCost
+                breakdown.sawStandardCost = true
+            }
+        }
+        return breakdown
+    }
+
+    // MARK: - File cache construction
+
+    static func makeFileUsage(
+        mtimeUnixMs: Int64,
+        size: Int64,
+        days: [String: [String: [Int]]],
+        parsedBytes: Int64?,
+        lastModel: String? = nil,
+        lastTotals: CostUsageCodexTotals? = nil,
+        lastCountedTotals: CostUsageCodexTotals? = nil,
+        lastRawTotalsBaseline: CostUsageCodexTotals? = nil,
+        hasDivergentTotals: Bool? = nil,
+        lastCodexTurnID: String? = nil,
+        sessionId: String? = nil,
+        forkedFromId: String? = nil,
+        codexCostNanos: [String: [String: Int64]]? = nil,
+        codexPrioritySurchargeNanos: [String: [String: Int64]]? = nil,
+        codexStandardCostNanos: [String: [String: Int64]]? = nil,
+        codexPriorityCostNanos: [String: [String: Int64]]? = nil,
+        codexStandardTokens: [String: [String: Int]]? = nil,
+        codexPriorityTokens: [String: [String: Int]]? = nil,
+        codexTurnIDs: [String]? = nil,
+        codexRows: [CodexUsageRow]? = nil,
+        claudeRows: [ClaudeUsageRow]? = nil) -> CostUsageFileUsage
+    {
+        CostUsageFileUsage(
+            mtimeUnixMs: mtimeUnixMs,
+            size: size,
+            days: days,
+            parsedBytes: parsedBytes,
+            lastModel: lastModel,
+            lastTotals: lastTotals,
+            lastCountedTotals: lastCountedTotals,
+            lastRawTotalsBaseline: lastRawTotalsBaseline,
+            hasDivergentTotals: hasDivergentTotals,
+            lastCodexTurnID: lastCodexTurnID,
+            sessionId: sessionId,
+            forkedFromId: forkedFromId,
+            codexCostNanos: codexCostNanos,
+            codexPrioritySurchargeNanos: codexPrioritySurchargeNanos,
+            codexStandardCostNanos: codexStandardCostNanos,
+            codexPriorityCostNanos: codexPriorityCostNanos,
+            codexStandardTokens: codexStandardTokens,
+            codexPriorityTokens: codexPriorityTokens,
+            codexTurnIDs: codexTurnIDs,
+            codexRows: codexRows,
+            claudeRows: claudeRows)
+    }
+
+    static func needsCodexCostCache(_ usage: CostUsageFileUsage) -> Bool {
+        !(usage.codexRows?.isEmpty ?? true)
+            && (usage.codexCostNanos == nil || self.needsCodexModeSplitCache(usage))
+    }
+
+    static func needsCodexCostCache(_ usage: CostUsageFileUsage, range: CostUsageDayRange) -> Bool {
+        guard let rows = usage.codexRows, !rows.isEmpty else { return false }
+        return rows.contains {
+            CostUsageDayRange.isInRange(dayKey: $0.day, since: range.sinceKey, until: range.untilKey)
+        } && (usage.codexCostNanos == nil || Self.needsCodexModeSplitCache(usage))
+    }
+
+    static func needsCodexModeSplitCache(_ usage: CostUsageFileUsage) -> Bool {
+        usage.codexStandardCostNanos == nil
+            || usage.codexPriorityCostNanos == nil
+            || usage.codexStandardTokens == nil
+            || usage.codexPriorityTokens == nil
+    }
+
+    static func codexFileUsageWithCostCache(
+        _ usage: CostUsageFileUsage,
+        context: CodexFileScanContext) -> CostUsageFileUsage
+    {
+        guard let rows = usage.codexRows, !rows.isEmpty else { return usage }
+        var migratedRows: [CodexUsageRow] = []
+        var retainedRows: [CodexUsageRow] = []
+        for row in rows {
+            if CostUsageDayRange.isInRange(
+                dayKey: row.day,
+                since: context.range.scanSinceKey,
+                until: context.range.scanUntilKey)
+            {
+                migratedRows.append(row)
+            } else {
+                retainedRows.append(row)
+            }
+        }
+        guard !migratedRows.isEmpty else { return usage }
+
+        let splitMaps = Self.codexModeSplitMaps(
+            rows: migratedRows,
+            range: context.range,
+            priorityTurns: context.resources.priorityTurns,
+            modelsDevCatalog: context.resources.modelsDevCatalog,
+            modelsDevCacheRoot: context.resources.modelsDevCacheRoot)
+        var updated = usage
+        updated.codexCostNanos = Self.mergeMissingCostMaps(
+            usage.codexCostNanos,
+            Self.codexCostNanos(
+                rows: migratedRows,
+                range: context.range,
+                modelsDevCatalog: context.resources.modelsDevCatalog,
+                modelsDevCacheRoot: context.resources.modelsDevCacheRoot))
+        updated.codexPrioritySurchargeNanos = Self.mergeMissingCostMaps(
+            usage.codexPrioritySurchargeNanos,
+            Self.codexPrioritySurchargeNanos(
+                rows: migratedRows,
+                range: context.range,
+                priorityTurns: context.resources.priorityTurns,
+                modelsDevCatalog: context.resources.modelsDevCatalog,
+                modelsDevCacheRoot: context.resources.modelsDevCacheRoot))
+        updated.codexStandardCostNanos = Self.mergeMissingCostMaps(
+            usage.codexStandardCostNanos,
+            splitMaps.standardCostNanos)
+        updated.codexPriorityCostNanos = Self.mergeMissingCostMaps(
+            usage.codexPriorityCostNanos,
+            splitMaps.priorityCostNanos)
+        updated.codexStandardTokens = Self.mergeMissingIntMaps(
+            usage.codexStandardTokens,
+            splitMaps.standardTokens)
+        updated.codexPriorityTokens = Self.mergeMissingIntMaps(
+            usage.codexPriorityTokens,
+            splitMaps.priorityTokens)
+        updated.codexTurnIDs = Self.mergeCodexTurnIDs(usage.codexTurnIDs, rows: migratedRows)
+        updated.codexRows = retainedRows.isEmpty ? nil : retainedRows
+        return updated
+    }
+
+    static func codexMergedCostMap(
+        _ existing: [String: [String: Int64]]?,
+        deltaRows: [CodexUsageRow],
+        context: CodexFileScanContext) -> [String: [String: Int64]]?
+    {
+        self.mergeCostMaps(
+            existing,
+            self.codexCostNanos(
+                rows: deltaRows,
+                range: context.range,
+                modelsDevCatalog: context.resources.modelsDevCatalog,
+                modelsDevCacheRoot: context.resources.modelsDevCacheRoot))
+    }
+
+    static func codexMergedPrioritySurchargeMap(
+        _ existing: [String: [String: Int64]]?,
+        deltaRows: [CodexUsageRow],
+        context: CodexFileScanContext) -> [String: [String: Int64]]?
+    {
+        self.mergeCostMaps(
+            existing,
+            self.codexPrioritySurchargeNanos(
+                rows: deltaRows,
+                range: context.range,
+                priorityTurns: context.resources.priorityTurns,
+                modelsDevCatalog: context.resources.modelsDevCatalog,
+                modelsDevCacheRoot: context.resources.modelsDevCacheRoot))
+    }
+
+    static func codexCostNanos(
+        rows: [CodexUsageRow],
+        range: CostUsageDayRange,
+        modelsDevCatalog: ModelsDevCatalog?,
+        modelsDevCacheRoot: URL?) -> [String: [String: Int64]]?
+    {
+        let rowsByDayModel = Self.codexRowsByDayModel(rows: rows, range: range)
+        var out: [String: [String: Int64]] = [:]
+        for (day, models) in rowsByDayModel {
+            for (model, rows) in models {
+                guard let cost = Self.codexRowsCostUSD(
+                    rows: rows,
+                    modelsDevCatalog: modelsDevCatalog,
+                    modelsDevCacheRoot: modelsDevCacheRoot)
+                else { continue }
+                out[day, default: [:]][model] = Int64((cost * Self.costScale).rounded())
+            }
+        }
+        return out.isEmpty ? nil : out
+    }
+
+    static func codexPrioritySurchargeNanos(
+        rows: [CodexUsageRow],
+        range: CostUsageDayRange,
+        priorityTurns: [String: CodexPriorityTurnMetadata],
+        modelsDevCatalog: ModelsDevCatalog?,
+        modelsDevCacheRoot: URL?) -> [String: [String: Int64]]?
+    {
+        guard !priorityTurns.isEmpty else { return nil }
+        let rowsByDayModel = Self.codexRowsByDayModel(rows: rows, range: range)
+        var out: [String: [String: Int64]] = [:]
+        for (day, models) in rowsByDayModel {
+            for (model, rows) in models {
+                guard let surcharge = Self.codexPrioritySurchargeUSD(
+                    rows: rows,
+                    priorityTurns: priorityTurns,
+                    modelsDevCatalog: modelsDevCatalog,
+                    modelsDevCacheRoot: modelsDevCacheRoot)
+                else { continue }
+                out[day, default: [:]][model] = Int64((surcharge * Self.costScale).rounded())
+            }
+        }
+        return out.isEmpty ? nil : out
+    }
+
+    static func codexModeSplitMaps(
+        rows: [CodexUsageRow],
+        range: CostUsageDayRange,
+        priorityTurns: [String: CodexPriorityTurnMetadata],
+        modelsDevCatalog: ModelsDevCatalog?,
+        modelsDevCacheRoot: URL?) -> (
+        standardCostNanos: [String: [String: Int64]]?,
+        priorityCostNanos: [String: [String: Int64]]?,
+        standardTokens: [String: [String: Int]]?,
+        priorityTokens: [String: [String: Int]]?)
+    {
+        var standardCostNanos: [String: [String: Int64]] = [:]
+        var priorityCostNanos: [String: [String: Int64]] = [:]
+        var standardTokens: [String: [String: Int]] = [:]
+        var priorityTokens: [String: [String: Int]] = [:]
+
+        for row in rows {
+            guard CostUsageDayRange.isInRange(dayKey: row.day, since: range.sinceKey, until: range.untilKey)
+            else { continue }
+
+            let tokenCount = row.input + row.output
+            let priorityMetadata = row.turnID.flatMap { priorityTurns[$0] }
+            let pricedModel = priorityMetadata.map { Self.codexPriorityPricingModel(for: row, priorityMetadata: $0) }
+                ?? row.model
+            let isPriority = priorityMetadata != nil
+
+            if isPriority {
+                priorityTokens[row.day, default: [:]][row.model, default: 0] += tokenCount
+            } else {
+                standardTokens[row.day, default: [:]][row.model, default: 0] += tokenCount
+            }
+
+            let baseCost = CostUsagePricing.codexCostUSD(
+                model: pricedModel,
+                inputTokens: row.input,
+                cachedInputTokens: row.cached,
+                outputTokens: row.output,
+                modelsDevCatalog: modelsDevCatalog,
+                modelsDevCacheRoot: modelsDevCacheRoot)
+
+            if isPriority, let priorityCost = CostUsagePricing.codexPriorityCostUSD(
+                model: pricedModel,
+                inputTokens: row.input,
+                cachedInputTokens: row.cached,
+                outputTokens: row.output)
+            {
+                priorityCostNanos[row.day, default: [:]][row.model, default: 0] += Int64(
+                    (max(priorityCost, baseCost ?? priorityCost) * Self.costScale).rounded())
+            } else if isPriority, let baseCost {
+                priorityCostNanos[row.day, default: [:]][row.model, default: 0] += Int64(
+                    (baseCost * Self.costScale).rounded())
+            } else if let baseCost {
+                standardCostNanos[row.day, default: [:]][row.model, default: 0] += Int64(
+                    (baseCost * Self.costScale).rounded())
+            }
+        }
+
+        return (
+            standardCostNanos.isEmpty ? nil : standardCostNanos,
+            priorityCostNanos.isEmpty ? nil : priorityCostNanos,
+            standardTokens.isEmpty ? nil : standardTokens,
+            priorityTokens.isEmpty ? nil : priorityTokens)
+    }
+
+    static func codexTurnIDs(rows: [CodexUsageRow]) -> [String]? {
+        let ids = Set(rows.compactMap(\.turnID))
+        return ids.sorted()
+    }
+
+    static func mergeCodexTurnIDs(_ existing: [String]?, rows: [CodexUsageRow]) -> [String]? {
+        var ids = Set(existing ?? [])
+        ids.formUnion(rows.compactMap(\.turnID))
+        return ids.sorted()
+    }
+
+    static func mergeCostMaps(
+        _ existing: [String: [String: Int64]]?,
+        _ delta: [String: [String: Int64]]?) -> [String: [String: Int64]]?
+    {
+        var out = existing ?? [:]
+        for (day, models) in delta ?? [:] {
+            for (model, value) in models {
+                out[day, default: [:]][model, default: 0] += value
+            }
+        }
+        return out.isEmpty ? nil : out
+    }
+
+    static func mergeMissingCostMaps(
+        _ existing: [String: [String: Int64]]?,
+        _ delta: [String: [String: Int64]]?) -> [String: [String: Int64]]?
+    {
+        var out = existing ?? [:]
+        for (day, models) in delta ?? [:] {
+            for (model, value) in models where out[day]?[model] == nil {
+                out[day, default: [:]][model] = value
+            }
+        }
+        return out.isEmpty ? nil : out
+    }
+
+    static func mergeIntMaps(
+        _ existing: [String: [String: Int]]?,
+        _ delta: [String: [String: Int]]?) -> [String: [String: Int]]?
+    {
+        var out = existing ?? [:]
+        for (day, models) in delta ?? [:] {
+            for (model, value) in models {
+                out[day, default: [:]][model, default: 0] += value
+            }
+        }
+        return out.isEmpty ? nil : out
+    }
+
+    static func mergeMissingIntMaps(
+        _ existing: [String: [String: Int]]?,
+        _ delta: [String: [String: Int]]?) -> [String: [String: Int]]?
+    {
+        var out = existing ?? [:]
+        for (day, models) in delta ?? [:] {
+            for (model, value) in models where out[day]?[model] == nil {
+                out[day, default: [:]][model] = value
+            }
+        }
+        return out.isEmpty ? nil : out
+    }
+
+    static func costMapOutsideScanWindow(
+        _ map: [String: [String: Int64]]?,
+        range: CostUsageDayRange) -> [String: [String: Int64]]?
+    {
+        let filtered = (map ?? [:]).filter {
+            !CostUsageDayRange.isInRange(dayKey: $0.key, since: range.scanSinceKey, until: range.scanUntilKey)
+        }
+        return filtered.isEmpty ? nil : filtered
+    }
+
+    static func intMapOutsideScanWindow(
+        _ map: [String: [String: Int]]?,
+        range: CostUsageDayRange) -> [String: [String: Int]]?
+    {
+        let filtered = (map ?? [:]).filter {
+            !CostUsageDayRange.isInRange(dayKey: $0.key, since: range.scanSinceKey, until: range.scanUntilKey)
+        }
+        return filtered.isEmpty ? nil : filtered
+    }
+
+    // MARK: - File scan orchestration
+
+    struct CodexFileMetadata {
+        let path: String
+        let mtimeUnixMs: Int64
+        let size: Int64
+        let fileId: String?
+    }
+
+    struct CodexFileScanInput {
+        let fileURL: URL
+        let metadata: CodexFileMetadata
+        let cached: CostUsageFileUsage?
+    }
+
+    static func codexFileMetadata(fileURL: URL) -> CodexFileMetadata {
+        let path = fileURL.path
+        var info = stat()
+        guard path.withCString({ fstatat(AT_FDCWD, $0, &info, 0) }) == 0 else {
+            return CodexFileMetadata(path: path, mtimeUnixMs: 0, size: 0, fileId: nil)
+        }
+        #if os(Linux)
+        let modifiedSeconds = Int64(info.st_mtim.tv_sec)
+        let modifiedNanoseconds = Int64(info.st_mtim.tv_nsec)
+        #else
+        let modifiedSeconds = Int64(info.st_mtimespec.tv_sec)
+        let modifiedNanoseconds = Int64(info.st_mtimespec.tv_nsec)
+        #endif
+        return CodexFileMetadata(
+            path: path,
+            mtimeUnixMs: modifiedSeconds * 1000 + modifiedNanoseconds / 1_000_000,
+            size: Int64(info.st_size),
+            fileId: "\(info.st_dev):\(info.st_ino)")
+    }
+
+    static func dropCachedCodexFile(
+        path: String,
+        cached: CostUsageFileUsage?,
+        cache: inout CostUsageCache)
+    {
+        if let cached {
+            self.applyFileDays(cache: &cache, fileDays: cached.days, sign: -1)
+        }
+        cache.files.removeValue(forKey: path)
+    }
+
+    static func rememberScannedCodexFile(
+        fileURL: URL,
+        metadata: CodexFileMetadata,
+        sessionId: String?,
+        context: CodexFileScanContext,
+        state: inout CodexScanState)
+    {
+        if let sessionId {
+            state.seenSessionIds.insert(sessionId)
+            context.resources.fileIndex.remember(fileURL: fileURL, sessionId: sessionId)
+        }
+        if let fileId = metadata.fileId {
+            state.seenFileIds.insert(fileId)
+        }
+    }
+
+    static func keepCachedCodexFileIfFresh(
+        input: CodexFileScanInput,
+        context: CodexFileScanContext,
+        cache: inout CostUsageCache,
+        state: inout CodexScanState) -> Bool
+    {
+        guard let cached = input.cached else { return false }
+        let needsSessionId = cached.sessionId == nil
+        guard cached.mtimeUnixMs == input.metadata.mtimeUnixMs,
+              cached.size == input.metadata.size,
+              !needsSessionId,
+              !context.forceFullScan
+        else { return false }
+
+        guard !Self.cachedCodexFileNeedsPriorityRescan(cached, context: context) else { return false }
+
+        if Self.needsCodexCostCache(cached, range: context.range) {
+            cache.files[input.metadata.path] = Self.codexFileUsageWithCostCache(cached, context: context)
+        }
+        Self.rememberScannedCodexFile(
+            fileURL: input.fileURL,
+            metadata: input.metadata,
+            sessionId: cached.sessionId,
+            context: context,
+            state: &state)
+        return true
+    }
+
+    static func cachedCodexFileNeedsPriorityRescan(
+        _ cached: CostUsageFileUsage,
+        context: CodexFileScanContext) -> Bool
+    {
+        if cached.codexTurnIDs == nil {
+            return context.requiresTurnIDCache
+        }
+        guard !context.changedPriorityTurnIDs.isEmpty else { return false }
+        return !(Set(cached.codexTurnIDs ?? []).isDisjoint(with: context.changedPriorityTurnIDs))
+    }
+
+    static func appendCodexFileIncrementIfPossible(
+        input: CodexFileScanInput,
+        context: CodexFileScanContext,
+        cache: inout CostUsageCache,
+        state: inout CodexScanState) throws -> Bool
+    {
+        try context.checkCancellation?()
+        guard let cached = input.cached, cached.sessionId != nil, !context.forceFullScan else { return false }
+        guard !Self.cachedCodexFileNeedsPriorityRescan(cached, context: context) else { return false }
+        let startOffset = cached.parsedBytes ?? cached.size
+        let initialCountedTotals = cached.lastCountedTotals ?? cached.lastTotals
+        let initialRawTotalsBaseline = cached.lastRawTotalsBaseline ?? cached.lastTotals
+        let canIncremental = input.metadata.size > cached.size && startOffset > 0
+            && startOffset <= input.metadata.size
+            && initialCountedTotals != nil
+            && cached.forkedFromId == nil
+        guard canIncremental else { return false }
+
+        let delta = try Self.parseCodexFileCancellable(
+            fileURL: input.fileURL,
+            range: context.range,
+            startOffset: startOffset,
+            initialModel: cached.lastModel,
+            initialTotals: initialCountedTotals,
+            initialRawTotalsBaseline: initialRawTotalsBaseline,
+            initialHasDivergentTotals: cached.hasDivergentTotals ?? (cached.lastTotals == nil),
+            initialCodexTurnID: cached.lastCodexTurnID,
+            checkCancellation: context.checkCancellation)
+        if delta.forkedFromId != nil {
+            return false
+        }
+        let sessionId = delta.sessionId ?? cached.sessionId
+        if let sessionId, state.seenSessionIds.contains(sessionId) {
+            Self.dropCachedCodexFile(path: input.metadata.path, cached: cached, cache: &cache)
+            return true
+        }
+
+        let migratedCached = Self.codexFileUsageWithCostCache(cached, context: context)
+        if !delta.days.isEmpty {
+            Self.applyFileDays(cache: &cache, fileDays: delta.days, sign: 1)
+        }
+
+        var mergedDays = migratedCached.days
+        Self.mergeFileDays(existing: &mergedDays, delta: delta.days)
+        let splitMaps = Self.codexModeSplitMaps(
+            rows: delta.rows,
+            range: context.range,
+            priorityTurns: context.resources.priorityTurns,
+            modelsDevCatalog: context.resources.modelsDevCatalog,
+            modelsDevCacheRoot: context.resources.modelsDevCacheRoot)
+        cache.files[input.metadata.path] = Self.makeFileUsage(
+            mtimeUnixMs: input.metadata.mtimeUnixMs,
+            size: input.metadata.size,
+            days: mergedDays,
+            parsedBytes: delta.parsedBytes,
+            lastModel: delta.lastModel,
+            lastTotals: delta.lastTotals,
+            lastCountedTotals: delta.lastCountedTotals,
+            lastRawTotalsBaseline: delta.lastRawTotalsBaseline,
+            hasDivergentTotals: delta.hasDivergentTotals,
+            lastCodexTurnID: delta.lastCodexTurnID,
+            sessionId: sessionId,
+            forkedFromId: delta.forkedFromId ?? migratedCached.forkedFromId,
+            codexCostNanos: Self.codexMergedCostMap(
+                migratedCached.codexCostNanos,
+                deltaRows: delta.rows,
+                context: context),
+            codexPrioritySurchargeNanos: Self.codexMergedPrioritySurchargeMap(
+                migratedCached.codexPrioritySurchargeNanos,
+                deltaRows: delta.rows,
+                context: context),
+            codexStandardCostNanos: Self.mergeCostMaps(
+                migratedCached.codexStandardCostNanos,
+                splitMaps.standardCostNanos),
+            codexPriorityCostNanos: Self.mergeCostMaps(
+                migratedCached.codexPriorityCostNanos,
+                splitMaps.priorityCostNanos),
+            codexStandardTokens: Self.mergeIntMaps(
+                migratedCached.codexStandardTokens,
+                splitMaps.standardTokens),
+            codexPriorityTokens: Self.mergeIntMaps(
+                migratedCached.codexPriorityTokens,
+                splitMaps.priorityTokens),
+            codexTurnIDs: Self.mergeCodexTurnIDs(migratedCached.codexTurnIDs, rows: delta.rows),
+            codexRows: migratedCached.codexRows)
+        Self.rememberScannedCodexFile(
+            fileURL: input.fileURL,
+            metadata: input.metadata,
+            sessionId: sessionId,
+            context: context,
+            state: &state)
+        return true
+    }
+
+    static func rescanCodexFile(
+        input: CodexFileScanInput,
+        context: CodexFileScanContext,
+        cache: inout CostUsageCache,
+        state: inout CodexScanState) throws
+    {
+        try context.checkCancellation?()
+        if let cached = input.cached {
+            self.applyFileDays(cache: &cache, fileDays: cached.days, sign: -1)
+        }
+        let migratedCached = input.cached.map { Self.codexFileUsageWithCostCache($0, context: context) }
+        var usageDays = context.dropDeferredCodexRows
+            ? [:]
+            : Self.fileDaysOutsideScanWindow(migratedCached?.days ?? [:], range: context.range)
+
+        let parsed = try Self.parseCodexFileCancellable(
+            fileURL: input.fileURL,
+            range: context.range,
+            inheritedTotalsResolver: context.resources.inheritedResolver.inheritedTotals(for:atOrBefore:),
+            checkCancellation: context.checkCancellation)
+        let sessionId = parsed.sessionId ?? input.cached?.sessionId
+        if let sessionId, state.seenSessionIds.contains(sessionId) {
+            cache.files.removeValue(forKey: input.metadata.path)
+            return
+        }
+        Self.mergeFileDays(existing: &usageDays, delta: parsed.days)
+        let splitMaps = Self.codexModeSplitMaps(
+            rows: parsed.rows,
+            range: context.range,
+            priorityTurns: context.resources.priorityTurns,
+            modelsDevCatalog: context.resources.modelsDevCatalog,
+            modelsDevCacheRoot: context.resources.modelsDevCacheRoot)
+
+        cache.files[input.metadata.path] = Self.makeFileUsage(
+            mtimeUnixMs: input.metadata.mtimeUnixMs,
+            size: input.metadata.size,
+            days: usageDays,
+            parsedBytes: parsed.parsedBytes,
+            lastModel: parsed.lastModel,
+            lastTotals: parsed.lastTotals,
+            lastCountedTotals: parsed.lastCountedTotals,
+            lastRawTotalsBaseline: parsed.lastRawTotalsBaseline,
+            hasDivergentTotals: parsed.hasDivergentTotals,
+            lastCodexTurnID: parsed.lastCodexTurnID,
+            sessionId: sessionId,
+            forkedFromId: parsed.forkedFromId,
+            codexCostNanos: Self.mergeCostMaps(
+                context.dropDeferredCodexRows
+                    ? nil
+                    : Self.costMapOutsideScanWindow(migratedCached?.codexCostNanos, range: context.range),
+                Self.codexCostNanos(
+                    rows: parsed.rows,
+                    range: context.range,
+                    modelsDevCatalog: context.resources.modelsDevCatalog,
+                    modelsDevCacheRoot: context.resources.modelsDevCacheRoot)),
+            codexPrioritySurchargeNanos: Self.mergeCostMaps(
+                context.dropDeferredCodexRows
+                    ? nil
+                    : Self.costMapOutsideScanWindow(migratedCached?.codexPrioritySurchargeNanos, range: context.range),
+                Self.codexPrioritySurchargeNanos(
+                    rows: parsed.rows,
+                    range: context.range,
+                    priorityTurns: context.resources.priorityTurns,
+                    modelsDevCatalog: context.resources.modelsDevCatalog,
+                    modelsDevCacheRoot: context.resources.modelsDevCacheRoot)),
+            codexStandardCostNanos: Self.mergeCostMaps(
+                context.dropDeferredCodexRows
+                    ? nil
+                    : Self.costMapOutsideScanWindow(migratedCached?.codexStandardCostNanos, range: context.range),
+                splitMaps.standardCostNanos),
+            codexPriorityCostNanos: Self.mergeCostMaps(
+                context.dropDeferredCodexRows
+                    ? nil
+                    : Self.costMapOutsideScanWindow(migratedCached?.codexPriorityCostNanos, range: context.range),
+                splitMaps.priorityCostNanos),
+            codexStandardTokens: Self.mergeIntMaps(
+                context.dropDeferredCodexRows
+                    ? nil
+                    : Self.intMapOutsideScanWindow(migratedCached?.codexStandardTokens, range: context.range),
+                splitMaps.standardTokens),
+            codexPriorityTokens: Self.mergeIntMaps(
+                context.dropDeferredCodexRows
+                    ? nil
+                    : Self.intMapOutsideScanWindow(migratedCached?.codexPriorityTokens, range: context.range),
+                splitMaps.priorityTokens),
+            codexTurnIDs: context.dropDeferredCodexRows
+                ? Self.codexTurnIDs(rows: parsed.rows)
+                : Self.mergeCodexTurnIDs(migratedCached?.codexTurnIDs, rows: parsed.rows),
+            codexRows: context.dropDeferredCodexRows ? nil : migratedCached?.codexRows)
+        Self.applyFileDays(cache: &cache, fileDays: cache.files[input.metadata.path]?.days ?? [:], sign: 1)
+        Self.rememberScannedCodexFile(
+            fileURL: input.fileURL,
+            metadata: input.metadata,
+            sessionId: sessionId,
+            context: context,
+            state: &state)
+    }
+
+    static func mergeFileDays(
+        existing: inout [String: [String: [Int]]],
+        delta: [String: [String: [Int]]])
+    {
+        for (day, models) in delta {
+            var dayModels = existing[day] ?? [:]
+            for (model, packed) in models {
+                let existingPacked = dayModels[model] ?? []
+                let merged = self.addPacked(a: existingPacked, b: packed, sign: 1)
+                if merged.allSatisfy({ $0 == 0 }) {
+                    dayModels.removeValue(forKey: model)
+                } else {
+                    dayModels[model] = merged
+                }
+            }
+
+            if dayModels.isEmpty {
+                existing.removeValue(forKey: day)
+            } else {
+                existing[day] = dayModels
+            }
+        }
+    }
+
+    static func fileDaysOutsideScanWindow(
+        _ days: [String: [String: [Int]]],
+        range: CostUsageDayRange) -> [String: [String: [Int]]]
+    {
+        days.filter {
+            !CostUsageDayRange.isInRange(dayKey: $0.key, since: range.scanSinceKey, until: range.scanUntilKey)
+        }
+    }
+
+    static func applyFileDays(cache: inout CostUsageCache, fileDays: [String: [String: [Int]]], sign: Int) {
+        for (day, models) in fileDays {
+            var dayModels = cache.days[day] ?? [:]
+            for (model, packed) in models {
+                let existing = dayModels[model] ?? []
+                let merged = self.addPacked(a: existing, b: packed, sign: sign)
+                if merged.allSatisfy({ $0 == 0 }) {
+                    dayModels.removeValue(forKey: model)
+                } else {
+                    dayModels[model] = merged
+                }
+            }
+
+            if dayModels.isEmpty {
+                cache.days.removeValue(forKey: day)
+            } else {
+                cache.days[day] = dayModels
+            }
+        }
+    }
+
+    static func pruneDays(cache: inout CostUsageCache, sinceKey: String, untilKey: String) {
+        for key in cache.days.keys where !CostUsageDayRange.isInRange(dayKey: key, since: sinceKey, until: untilKey) {
+            cache.days.removeValue(forKey: key)
+        }
+    }
+
+    static func pruneForceRescanFilesOutsideWindow(
+        cache: inout CostUsageCache,
+        range: CostUsageDayRange,
+        isForceRescan: Bool)
+    {
+        guard isForceRescan else { return }
+        for key in cache.files.keys {
+            guard let old = cache.files[key] else { continue }
+            guard !old.touchesCodexScanWindow(sinceKey: range.scanSinceKey, untilKey: range.scanUntilKey)
+            else { continue }
+            Self.applyFileDays(cache: &cache, fileDays: old.days, sign: -1)
+            cache.files.removeValue(forKey: key)
+        }
+    }
+
+    static func requestedWindowExpandsCache(range: CostUsageDayRange, cache: CostUsageCache) -> Bool {
+        guard let cachedSince = cache.scanSinceKey,
+              let cachedUntil = cache.scanUntilKey
+        else {
+            return cache.lastScanUnixMs != 0 || !cache.files.isEmpty || !cache.days.isEmpty
+        }
+        return range.scanSinceKey < cachedSince || range.scanUntilKey > cachedUntil
+    }
+
+    static func addPacked(a: [Int], b: [Int], sign: Int) -> [Int] {
+        let len = max(a.count, b.count)
+        var out: [Int] = Array(repeating: 0, count: len)
+        for idx in 0..<len {
+            let next = (a[safe: idx] ?? 0) + sign * (b[safe: idx] ?? 0)
+            out[idx] = max(0, next)
+        }
+        return out
+    }
+
+    static func buildCodexReportFromCache(
+        cache: CostUsageCache,
+        range: CostUsageDayRange,
+        modelsDevCatalog: ModelsDevCatalog? = nil,
+        modelsDevCacheRoot: URL? = nil,
+        priorityTurns: [String: CodexPriorityTurnMetadata] = [:]) -> CostUsageDailyReport
+    {
+        var entries: [CostUsageDailyReport.Entry] = []
+        var totalInput = 0
+        var totalOutput = 0
+        var totalTokens = 0
+        var totalCost: Double = 0
+        var costSeen = false
+
+        let dayKeys = cache.days.keys.sorted().filter {
+            CostUsageDayRange.isInRange(dayKey: $0, since: range.sinceKey, until: range.untilKey)
+        }
+        let costNanosByDayModel = self.codexCostNanosByDayModel(cache: cache, range: range)
+        let prioritySurchargeNanosByDayModel = self.codexPrioritySurchargeNanosByDayModel(cache: cache, range: range)
+        let standardCostNanosByDayModel = self.codexStandardCostNanosByDayModel(cache: cache, range: range)
+        let priorityCostNanosByDayModel = self.codexPriorityCostNanosByDayModel(cache: cache, range: range)
+        let standardTokensByDayModel = self.codexStandardTokensByDayModel(cache: cache, range: range)
+        let priorityTokensByDayModel = self.codexPriorityTokensByDayModel(cache: cache, range: range)
+
+        let hasCodexRows = cache.files.values.contains {
+            !($0.codexRows?.isEmpty ?? true)
+        }
+        let rowsByDayModel = hasCodexRows ? self.codexRowsByDayModel(cache: cache, range: range) : [:]
+
+        for day in dayKeys {
+            guard let models = cache.days[day] else { continue }
+            let modelNames = models.keys.sorted()
+
+            var dayInput = 0
+            var dayOutput = 0
+            var breakdown: [CostUsageDailyReport.ModelBreakdown] = []
+            var dayCost: Double = 0
+            var dayCostSeen = false
+
+            for model in modelNames {
+                let packed = models[model] ?? [0, 0, 0]
+                let input = packed[safe: 0] ?? 0
+                let cached = packed[safe: 1] ?? 0
+                let output = packed[safe: 2] ?? 0
+                let totalTokens = input + output
+
+                dayInput += input
+                dayOutput += output
+
+                let rows = rowsByDayModel[day]?[model]
+                let rowCostBreakdown = rows.map {
+                    self.codexRowCostBreakdown(
+                        rows: $0,
+                        priorityTurns: priorityTurns,
+                        modelsDevCatalog: modelsDevCatalog,
+                        modelsDevCacheRoot: modelsDevCacheRoot)
+                }
+                let cachedBaseCost = costNanosByDayModel[day]?[model].map { Double($0) / Self.costScale }
+                let rowTotalCost = cachedBaseCost == nil ? rowCostBreakdown?.totalCostUSD : nil
+                let standardCost = standardCostNanosByDayModel[day]?[model].map { Double($0) / Self.costScale }
+                    ?? (rowCostBreakdown?.hasModeSplit == true ? rowCostBreakdown?.optionalStandardCostUSD : nil)
+                let priorityCost = priorityCostNanosByDayModel[day]?[model].map { Double($0) / Self.costScale }
+                    ?? (rowCostBreakdown?.hasModeSplit == true ? rowCostBreakdown?.optionalPriorityCostUSD : nil)
+                let splitTotalCost: Double? = if standardCost != nil || priorityCost != nil {
+                    (standardCost ?? 0) + (priorityCost ?? 0)
+                } else {
+                    nil
+                }
+                var cost = splitTotalCost
+                    ?? cachedBaseCost
+                    ?? rowTotalCost
+                    ?? CostUsagePricing.codexCostUSD(
+                        model: model,
+                        inputTokens: input,
+                        cachedInputTokens: cached,
+                        outputTokens: output,
+                        modelsDevCatalog: modelsDevCatalog,
+                        modelsDevCacheRoot: modelsDevCacheRoot)
+                if splitTotalCost == nil,
+                   let surchargeNanos = prioritySurchargeNanosByDayModel[day]?[model],
+                   cachedBaseCost != nil
+                {
+                    cost = (cost ?? 0) + (Double(surchargeNanos) / Self.costScale)
+                } else if splitTotalCost == nil,
+                          rowTotalCost == nil,
+                          !priorityTurns.isEmpty,
+                          let rows,
+                          let surcharge = self.codexPrioritySurchargeUSD(
+                              rows: rows,
+                              priorityTurns: priorityTurns,
+                              modelsDevCatalog: modelsDevCatalog,
+                              modelsDevCacheRoot: modelsDevCacheRoot)
+                {
+                    cost = (cost ?? 0) + surcharge
+                }
+                let standardModeTokens = standardTokensByDayModel[day]?[model]
+                    ?? (rowCostBreakdown?.hasModeSplit == true ? rowCostBreakdown?.optionalStandardTokens : nil)
+                let priorityModeTokens = priorityTokensByDayModel[day]?[model]
+                    ?? (rowCostBreakdown?.hasModeSplit == true ? rowCostBreakdown?.optionalPriorityTokens : nil)
+                let hasModeSplit = priorityCost != nil || priorityModeTokens != nil
+                breakdown.append(
+                    CostUsageDailyReport.ModelBreakdown(
+                        modelName: model,
+                        costUSD: cost,
+                        totalTokens: totalTokens,
+                        standardCostUSD: hasModeSplit ? standardCost : nil,
+                        priorityCostUSD: hasModeSplit ? priorityCost : nil,
+                        standardTokens: hasModeSplit ? standardModeTokens : nil,
+                        priorityTokens: hasModeSplit ? priorityModeTokens : nil))
+                if let cost {
+                    dayCost += cost
+                    dayCostSeen = true
+                }
+            }
+
+            let dayTotal = dayInput + dayOutput
+            let entryCost = dayCostSeen ? dayCost : nil
+            entries.append(CostUsageDailyReport.Entry(
+                date: day,
+                inputTokens: dayInput,
+                outputTokens: dayOutput,
+                totalTokens: dayTotal,
+                costUSD: entryCost,
+                modelsUsed: modelNames,
+                modelBreakdowns: Self.sortedModelBreakdowns(breakdown)))
+
+            totalInput += dayInput
+            totalOutput += dayOutput
+            totalTokens += dayTotal
+            if let entryCost {
+                totalCost += entryCost
+                costSeen = true
+            }
+        }
+
+        let summary: CostUsageDailyReport.Summary? = entries.isEmpty
+            ? nil
+            : CostUsageDailyReport.Summary(
+                totalInputTokens: totalInput,
+                totalOutputTokens: totalOutput,
+                totalTokens: totalTokens,
+                totalCostUSD: costSeen ? totalCost : nil)
+
+        return CostUsageDailyReport(data: entries, summary: summary)
+    }
+
+    static func sortedModelBreakdowns(_ breakdowns: [CostUsageDailyReport.ModelBreakdown])
+        -> [CostUsageDailyReport.ModelBreakdown]
+    {
+        breakdowns.sorted { lhs, rhs in
+            let lhsCost = lhs.costUSD ?? -1
+            let rhsCost = rhs.costUSD ?? -1
+            if lhsCost != rhsCost {
+                return lhsCost > rhsCost
+            }
+
+            let lhsTokens = lhs.totalTokens ?? -1
+            let rhsTokens = rhs.totalTokens ?? -1
+            if lhsTokens != rhsTokens {
+                return lhsTokens > rhsTokens
+            }
+
+            return lhs.modelName > rhs.modelName
+        }
+    }
+
+    static func parseDayKey(_ key: String) -> Date? {
+        let parts = key.split(separator: "-")
+        guard parts.count == 3 else { return nil }
+        guard
+            let year = Int(parts[0]),
+            let month = Int(parts[1]),
+            let day = Int(parts[2])
+        else { return nil }
+
+        var comps = DateComponents()
+        comps.calendar = Calendar.current
+        comps.timeZone = TimeZone.current
+        comps.year = year
+        comps.month = month
+        comps.day = day
+        comps.hour = 12
+        return comps.date
+    }
+}
+
+extension Data {
+    func containsAscii(_ needle: String) -> Bool {
+        guard let n = needle.data(using: .utf8) else { return false }
+        return self.range(of: n) != nil
+    }
+}
+
+extension [Int] {
+    subscript(safe index: Int) -> Int? {
+        if index < 0 { return nil }
+        if index >= self.count { return nil }
+        return self[index]
+    }
+}
+
+extension [UInt8] {
+    subscript(safe index: Int) -> UInt8? {
+        if index < 0 { return nil }
+        if index >= self.count { return nil }
+        return self[index]
+    }
+}
+
+extension CostUsageFileUsage {
+    func touchesCodexScanWindow(sinceKey: String, untilKey: String) -> Bool {
+        self.days.keys.contains {
+            CostUsageScanner.CostUsageDayRange.isInRange(dayKey: $0, since: sinceKey, until: untilKey)
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Vendored/CostUsage/CostUsageScanner+Claude.swift b/Sources/CodexBarCore/Vendored/CostUsage/CostUsageScanner+Claude.swift
index 5e32060b00..83730d3b16 100644
--- a/Sources/CodexBarCore/Vendored/CostUsage/CostUsageScanner+Claude.swift
+++ b/Sources/CodexBarCore/Vendored/CostUsage/CostUsageScanner+Claude.swift
@@ -3,6 +3,27 @@ import Foundation
 extension CostUsageScanner {
     // MARK: - Claude
 
+    private struct ClaudeTokens {
+        let input: Int
+        let cacheRead: Int
+        let cacheCreate: Int
+        let cacheCreate1h: Int
+        let output: Int
+        let costNanos: Int
+        let costPriced: Bool
+    }
+
+    private struct ClaudeDayModelKey: Hashable {
+        let day: String
+        let model: String
+    }
+
+    private struct ClaudeRepricedCost {
+        var total: Double = 0
+        var sampleCount: Int = 0
+        var unresolved = false
+    }
+
     private static func defaultClaudeProjectsRoots(options: Options) -> [URL] {
         if let override = options.claudeProjectsRoots { return override }
 
@@ -35,105 +56,308 @@ extension CostUsageScanner {
         fileURL: URL,
         range: CostUsageDayRange,
         providerFilter: ClaudeLogProviderFilter,
-        startOffset: Int64 = 0) -> ClaudeParseResult
+        startOffset: Int64 = 0,
+        modelsDevCatalog: ModelsDevCatalog? = nil,
+        modelsDevCacheRoot: URL? = nil) -> ClaudeParseResult
     {
-        var days: [String: [String: [Int]]] = [:]
-        // Track seen message+request IDs to deduplicate streaming chunks within a JSONL file.
-        // Claude emits multiple lines per message with cumulative usage, so we only count once.
-        var seenKeys: Set<String> = []
-
-        struct ClaudeTokens: Sendable {
-            let input: Int
-            let cacheRead: Int
-            let cacheCreate: Int
-            let output: Int
-            let costNanos: Int
-        }
+        (
+            try? self.parseClaudeFileCancellable(
+                fileURL: fileURL,
+                range: range,
+                providerFilter: providerFilter,
+                startOffset: startOffset,
+                modelsDevCatalog: modelsDevCatalog,
+                modelsDevCacheRoot: modelsDevCacheRoot,
+                checkCancellation: nil)) ?? ClaudeParseResult(days: [:], rows: [], parsedBytes: startOffset)
+    }
 
-        func add(dayKey: String, model: String, tokens: ClaudeTokens) {
+    static func parseClaudeFileCancellable(
+        fileURL: URL,
+        range: CostUsageDayRange,
+        providerFilter: ClaudeLogProviderFilter,
+        startOffset: Int64 = 0,
+        modelsDevCatalog: ModelsDevCatalog? = nil,
+        modelsDevCacheRoot: URL? = nil,
+        checkCancellation: CancellationCheck? = nil) throws -> ClaudeParseResult
+    {
+        func add(dayKey: String, model: String, tokens: ClaudeTokens, days: inout [String: [String: [Int]]]) {
             guard CostUsageDayRange.isInRange(dayKey: dayKey, since: range.scanSinceKey, until: range.scanUntilKey)
             else { return }
             let normModel = CostUsagePricing.normalizeClaudeModel(model)
             var dayModels = days[dayKey] ?? [:]
-            var packed = dayModels[normModel] ?? [0, 0, 0, 0, 0]
+            var packed = dayModels[normModel] ?? [0, 0, 0, 0, 0, 0, 0, 0]
             packed[0] = (packed[safe: 0] ?? 0) + tokens.input
             packed[1] = (packed[safe: 1] ?? 0) + tokens.cacheRead
             packed[2] = (packed[safe: 2] ?? 0) + tokens.cacheCreate
             packed[3] = (packed[safe: 3] ?? 0) + tokens.output
             packed[4] = (packed[safe: 4] ?? 0) + tokens.costNanos
+            packed[5] = (packed[safe: 5] ?? 0) + 1
+            packed[6] = (packed[safe: 6] ?? 0) + (tokens.costPriced ? 1 : 0)
+            packed[7] = (packed[safe: 7] ?? 0) + tokens.cacheCreate1h
             dayModels[normModel] = packed
             days[dayKey] = dayModels
         }
 
+        func toInt(_ v: Any?) -> Int {
+            if let n = v as? NSNumber { return n.intValue }
+            return 0
+        }
+
+        func toBool(_ value: Any?) -> Bool {
+            if let bool = value as? Bool { return bool }
+            if let number = value as? NSNumber { return number.boolValue }
+            return false
+        }
+
+        let pathRole = Self.claudePathRole(fileURL: fileURL)
+        var keyedRows: [String: ClaudeUsageRow] = [:]
+        var unkeyedRows: [ClaudeUsageRow] = []
+
         let maxLineBytes = 512 * 1024
         // Keep the full line so usage at the tail isn't dropped on large tool outputs.
         let prefixBytes = maxLineBytes
         let costScale = 1_000_000_000.0
 
-        let parsedBytes = (try? CostUsageJsonl.scan(
-            fileURL: fileURL,
-            offset: startOffset,
-            maxLineBytes: maxLineBytes,
-            prefixBytes: prefixBytes,
-            onLine: { line in
-                guard !line.bytes.isEmpty else { return }
-                guard !line.wasTruncated else { return }
-                guard line.bytes.containsAscii(#""type":"assistant""#) else { return }
-                guard line.bytes.containsAscii(#""usage""#) else { return }
-
-                guard
-                    let obj = (try? JSONSerialization.jsonObject(with: line.bytes)) as? [String: Any],
-                    let type = obj["type"] as? String,
-                    type == "assistant"
-                else { return }
-                guard Self.matchesClaudeProviderFilter(obj: obj, filter: providerFilter) else { return }
-
-                guard let tsText = obj["timestamp"] as? String else { return }
-                guard let dayKey = Self.dayKeyFromTimestamp(tsText) ?? Self.dayKeyFromParsedISO(tsText) else { return }
-
-                guard let message = obj["message"] as? [String: Any] else { return }
-                guard let model = message["model"] as? String else { return }
-                guard let usage = message["usage"] as? [String: Any] else { return }
-
-                // Deduplicate by message.id + requestId (streaming chunks have same usage).
-                let messageId = message["id"] as? String
-                let requestId = obj["requestId"] as? String
-                if let messageId, let requestId {
-                    let key = "\(messageId):\(requestId)"
-                    if seenKeys.contains(key) { return }
-                    seenKeys.insert(key)
+        let parsedBytes: Int64
+        do {
+            parsedBytes = try CostUsageJsonl.scan(
+                fileURL: fileURL,
+                offset: startOffset,
+                maxLineBytes: maxLineBytes,
+                prefixBytes: prefixBytes,
+                checkCancellation: checkCancellation,
+                onLine: { line in
+                    guard !line.bytes.isEmpty else { return }
+                    guard !line.wasTruncated else { return }
+                    guard line.bytes.containsAscii(#""type":"assistant""#) else { return }
+                    guard line.bytes.containsAscii(#""usage""#) else { return }
+
+                    autoreleasepool {
+                        guard
+                            let obj = (try? JSONSerialization.jsonObject(with: line.bytes)) as? [String: Any],
+                            let type = obj["type"] as? String,
+                            type == "assistant"
+                        else { return }
+                        guard Self.matchesClaudeProviderFilter(obj: obj, filter: providerFilter) else { return }
+
+                        guard let tsText = obj["timestamp"] as? String, let timestamp = Self.dateFromTimestamp(tsText)
+                        else { return }
+                        guard let dayKey = Self.dayKeyFromTimestamp(tsText) ?? Self.dayKeyFromParsedISO(tsText)
+                        else { return }
+
+                        guard let message = obj["message"] as? [String: Any] else { return }
+                        guard let model = message["model"] as? String else { return }
+                        guard let usage = message["usage"] as? [String: Any] else { return }
+
+                        let input = max(0, toInt(usage["input_tokens"]))
+                        let cacheCreate = max(0, toInt(usage["cache_creation_input_tokens"]))
+                        let cacheCreate1h = Self.claudeOneHourCacheCreationTokens(
+                            usage: usage,
+                            total: cacheCreate)
+                        let cacheRead = max(0, toInt(usage["cache_read_input_tokens"]))
+                        let output = max(0, toInt(usage["output_tokens"]))
+                        if input == 0, cacheCreate == 0, cacheRead == 0, output == 0 { return }
+
+                        let cost = CostUsagePricing.claudeCostUSD(
+                            model: model,
+                            inputTokens: input,
+                            cacheReadInputTokens: cacheRead,
+                            cacheCreationInputTokens: cacheCreate,
+                            cacheCreationInputTokens1h: cacheCreate1h,
+                            outputTokens: output,
+                            pricingDate: timestamp,
+                            modelsDevCatalog: modelsDevCatalog,
+                            modelsDevCacheRoot: modelsDevCacheRoot)
+                        let costNanos = cost.map { Int(($0 * costScale).rounded()) } ?? 0
+                        let tokens = ClaudeTokens(
+                            input: input,
+                            cacheRead: cacheRead,
+                            cacheCreate: cacheCreate,
+                            cacheCreate1h: cacheCreate1h,
+                            output: output,
+                            costNanos: costNanos,
+                            costPriced: cost != nil)
+
+                        guard CostUsageDayRange.isInRange(
+                            dayKey: dayKey,
+                            since: range.scanSinceKey,
+                            until: range.scanUntilKey)
+                        else { return }
+
+                        let messageId = message["id"] as? String
+                        let requestId = obj["requestId"] as? String
+                        let sessionId = obj["sessionId"] as? String
+                            ?? obj["session_id"] as? String
+                            ?? (obj["metadata"] as? [String: Any])?["sessionId"] as? String
+                            ?? (message["metadata"] as? [String: Any])?["sessionId"] as? String
+                        let normalizedModel = CostUsagePricing.normalizeClaudeModel(model)
+                        let row = ClaudeUsageRow(
+                            dayKey: dayKey,
+                            model: normalizedModel,
+                            sessionId: sessionId,
+                            messageId: messageId,
+                            requestId: requestId,
+                            timestampUnixMs: Int64((timestamp.timeIntervalSince1970 * 1000).rounded()),
+                            isSidechain: toBool(obj["isSidechain"]),
+                            pathRole: pathRole,
+                            input: tokens.input,
+                            cacheRead: tokens.cacheRead,
+                            cacheCreate: tokens.cacheCreate,
+                            cacheCreate1h: tokens.cacheCreate1h,
+                            output: tokens.output,
+                            costNanos: tokens.costNanos,
+                            costPriced: tokens.costPriced)
+
+                        // Streaming chunks share message.id + requestId inside a file.
+                        // Keep overwriting so the final cumulative chunk wins.
+                        if let messageId, let requestId {
+                            let key = "\(messageId):\(requestId)"
+                            keyedRows[key] = row
+                        } else {
+                            // Older logs omit IDs; treat each line as distinct to avoid dropping usage.
+                            unkeyedRows.append(row)
+                        }
+                    }
+                })
+        } catch is CancellationError {
+            throw CancellationError()
+        } catch {
+            parsedBytes = startOffset
+        }
+
+        let rows = keyedRows.keys.sorted().compactMap { keyedRows[$0] } + unkeyedRows
+        var days: [String: [String: [Int]]] = [:]
+        for row in rows {
+            let tokens = ClaudeTokens(
+                input: row.input,
+                cacheRead: row.cacheRead,
+                cacheCreate: row.cacheCreate,
+                cacheCreate1h: row.cacheCreate1h ?? 0,
+                output: row.output,
+                costNanos: row.costNanos,
+                costPriced: row.costPriced ?? (row.costNanos > 0))
+            add(dayKey: row.dayKey, model: row.model, tokens: tokens, days: &days)
+        }
+
+        return ClaudeParseResult(days: days, rows: rows, parsedBytes: parsedBytes)
+    }
+
+    private static func claudeOneHourCacheCreationTokens(usage: [String: Any], total: Int) -> Int {
+        guard let cacheCreation = usage["cache_creation"] as? [String: Any] else { return 0 }
+        let tokens = (cacheCreation["ephemeral_1h_input_tokens"] as? NSNumber)?.intValue ?? 0
+        return min(total, max(0, tokens))
+    }
+
+    private static func claudePathRole(fileURL: URL) -> ClaudePathRole {
+        fileURL.path.contains("/subagents/") ? .subagent : .parent
+    }
+
+    private static func claudeCanonicalRowKey(_ row: ClaudeUsageRow) -> String? {
+        guard let messageId = row.messageId, let requestId = row.requestId else {
+            return nil
+        }
+        return "\(messageId):\(requestId)"
+    }
+
+    private static func mergeClaudeRows(existing: [ClaudeUsageRow], delta: [ClaudeUsageRow]) -> [ClaudeUsageRow] {
+        var keyedRows: [String: ClaudeUsageRow] = [:]
+        var unkeyedRows: [ClaudeUsageRow] = []
+
+        for row in existing {
+            if let key = Self.claudeInFileKey(row) {
+                keyedRows[key] = row
+            } else {
+                unkeyedRows.append(row)
+            }
+        }
+        for row in delta {
+            if let key = Self.claudeInFileKey(row) {
+                keyedRows[key] = row
+            } else {
+                unkeyedRows.append(row)
+            }
+        }
+
+        return keyedRows.keys.sorted().compactMap { keyedRows[$0] } + unkeyedRows
+    }
+
+    private static func claudeInFileKey(_ row: ClaudeUsageRow) -> String? {
+        guard let messageId = row.messageId, let requestId = row.requestId else { return nil }
+        return "\(messageId):\(requestId)"
+    }
+
+    private static func claudeRowWins(
+        lhs: (path: String, row: ClaudeUsageRow),
+        rhs: (path: String, row: ClaudeUsageRow)) -> Bool
+    {
+        if lhs.row.isSidechain != rhs.row.isSidechain {
+            return rhs.row.isSidechain
+        }
+        if lhs.row.pathRole != rhs.row.pathRole {
+            return rhs.row.pathRole == .subagent
+        }
+        return lhs.path < rhs.path
+    }
+
+    private static func reconciledClaudeRows(cache: CostUsageCache) -> [ClaudeUsageRow] {
+        var rows: [ClaudeUsageRow] = []
+        var winners: [String: (path: String, row: ClaudeUsageRow)] = [:]
+
+        for path in cache.files.keys.sorted() {
+            guard let fileRows = cache.files[path]?.claudeRows else { continue }
+            for row in fileRows {
+                guard let canonicalKey = Self.claudeCanonicalRowKey(row) else {
+                    rows.append(row)
+                    continue
+                }
+                let candidate = (path: path, row: row)
+                if let existing = winners[canonicalKey] {
+                    if Self.claudeRowWins(lhs: candidate, rhs: existing) {
+                        winners[canonicalKey] = candidate
+                    }
                 } else {
-                    // Older logs omit IDs; treat each line as distinct to avoid dropping usage.
+                    winners[canonicalKey] = candidate
                 }
+            }
+        }
 
-                func toInt(_ v: Any?) -> Int {
-                    if let n = v as? NSNumber { return n.intValue }
-                    return 0
-                }
+        rows.append(contentsOf: winners.keys.sorted().compactMap { winners[$0]?.row })
+        return rows
+    }
+
+    private static func rebuildClaudeDays(cache: inout CostUsageCache) {
+        var days: [String: [String: [Int]]] = [:]
 
-                let input = max(0, toInt(usage["input_tokens"]))
-                let cacheCreate = max(0, toInt(usage["cache_creation_input_tokens"]))
-                let cacheRead = max(0, toInt(usage["cache_read_input_tokens"]))
-                let output = max(0, toInt(usage["output_tokens"]))
-                if input == 0, cacheCreate == 0, cacheRead == 0, output == 0 { return }
-
-                let cost = CostUsagePricing.claudeCostUSD(
-                    model: model,
-                    inputTokens: input,
-                    cacheReadInputTokens: cacheRead,
-                    cacheCreationInputTokens: cacheCreate,
-                    outputTokens: output)
-                let costNanos = cost.map { Int(($0 * costScale).rounded()) } ?? 0
-                let tokens = ClaudeTokens(
-                    input: input,
-                    cacheRead: cacheRead,
-                    cacheCreate: cacheCreate,
-                    output: output,
-                    costNanos: costNanos)
-                add(dayKey: dayKey, model: model, tokens: tokens)
-            })) ?? startOffset
-
-        return ClaudeParseResult(days: days, parsedBytes: parsedBytes)
+        for row in Self.reconciledClaudeRows(cache: cache) {
+            var dayModels = days[row.dayKey] ?? [:]
+            var packed = dayModels[row.model] ?? [0, 0, 0, 0, 0, 0, 0, 0]
+            packed[0] = (packed[safe: 0] ?? 0) + row.input
+            packed[1] = (packed[safe: 1] ?? 0) + row.cacheRead
+            packed[2] = (packed[safe: 2] ?? 0) + row.cacheCreate
+            packed[3] = (packed[safe: 3] ?? 0) + row.output
+            packed[4] = (packed[safe: 4] ?? 0) + row.costNanos
+            packed[5] = (packed[safe: 5] ?? 0) + 1
+            packed[6] = (packed[safe: 6] ?? 0) + ((row.costPriced ?? (row.costNanos > 0)) ? 1 : 0)
+            packed[7] = (packed[safe: 7] ?? 0) + (row.cacheCreate1h ?? 0)
+            dayModels[row.model] = packed
+            days[row.dayKey] = dayModels
+        }
+
+        cache.days = days
+    }
+
+    private static func makeClaudeFileUsage(
+        mtimeMs: Int64,
+        size: Int64,
+        rows: [ClaudeUsageRow],
+        parsedBytes: Int64?) -> CostUsageFileUsage
+    {
+        makeFileUsage(
+            mtimeUnixMs: mtimeMs,
+            size: size,
+            days: [:],
+            parsedBytes: parsedBytes,
+            claudeRows: rows)
     }
 
     private static let vertexProviderKeys: Set<String> = [
@@ -260,17 +484,31 @@ extension CostUsageScanner {
 
     private final class ClaudeScanState {
         var cache: CostUsageCache
-        var rootCache: [String: Int64]
         var touched: Set<String>
         let range: CostUsageDayRange
         let providerFilter: ClaudeLogProviderFilter
-
-        init(cache: CostUsageCache, range: CostUsageDayRange, providerFilter: ClaudeLogProviderFilter) {
+        let forceFullScan: Bool
+        let modelsDevCatalog: ModelsDevCatalog?
+        let modelsDevCacheRoot: URL?
+        let checkCancellation: CancellationCheck?
+
+        init(
+            cache: CostUsageCache,
+            range: CostUsageDayRange,
+            providerFilter: ClaudeLogProviderFilter,
+            forceFullScan: Bool,
+            modelsDevCatalog: ModelsDevCatalog?,
+            modelsDevCacheRoot: URL?,
+            checkCancellation: CancellationCheck?)
+        {
             self.cache = cache
-            self.rootCache = cache.roots ?? [:]
             self.touched = []
             self.range = range
             self.providerFilter = providerFilter
+            self.forceFullScan = forceFullScan
+            self.modelsDevCatalog = modelsDevCatalog
+            self.modelsDevCacheRoot = modelsDevCacheRoot
+            self.checkCancellation = checkCancellation
         }
     }
 
@@ -278,119 +516,87 @@ extension CostUsageScanner {
         url: URL,
         size: Int64,
         mtimeMs: Int64,
-        state: ClaudeScanState)
+        state: ClaudeScanState) throws
     {
+        try state.checkCancellation?()
         let path = url.path
         state.touched.insert(path)
 
         if let cached = state.cache.files[path],
            cached.mtimeUnixMs == mtimeMs,
-           cached.size == size
+           cached.size == size,
+           !state.forceFullScan
         {
             return
         }
 
-        if let cached = state.cache.files[path] {
+        if let cached = state.cache.files[path], !state.forceFullScan {
             let startOffset = cached.parsedBytes ?? cached.size
             let canIncremental = size > cached.size && startOffset > 0 && startOffset <= size
+                && cached.claudeRows != nil
             if canIncremental {
-                let delta = Self.parseClaudeFile(
+                let delta = try Self.parseClaudeFileCancellable(
                     fileURL: url,
                     range: state.range,
                     providerFilter: state.providerFilter,
-                    startOffset: startOffset)
-                if !delta.days.isEmpty {
-                    Self.applyFileDays(cache: &state.cache, fileDays: delta.days, sign: 1)
-                }
-
-                var mergedDays = cached.days
-                Self.mergeFileDays(existing: &mergedDays, delta: delta.days)
-                state.cache.files[path] = Self.makeFileUsage(
-                    mtimeUnixMs: mtimeMs,
+                    startOffset: startOffset,
+                    modelsDevCatalog: state.modelsDevCatalog,
+                    modelsDevCacheRoot: state.modelsDevCacheRoot,
+                    checkCancellation: state.checkCancellation)
+                let mergedRows = Self.mergeClaudeRows(existing: cached.claudeRows ?? [], delta: delta.rows)
+                state.cache.files[path] = Self.makeClaudeFileUsage(
+                    mtimeMs: mtimeMs,
                     size: size,
-                    days: mergedDays,
+                    rows: mergedRows,
                     parsedBytes: delta.parsedBytes)
                 return
             }
-
-            Self.applyFileDays(cache: &state.cache, fileDays: cached.days, sign: -1)
         }
 
-        let parsed = Self.parseClaudeFile(
+        let parsed = try Self.parseClaudeFileCancellable(
             fileURL: url,
             range: state.range,
-            providerFilter: state.providerFilter)
-        let usage = Self.makeFileUsage(
-            mtimeUnixMs: mtimeMs,
+            providerFilter: state.providerFilter,
+            modelsDevCatalog: state.modelsDevCatalog,
+            modelsDevCacheRoot: state.modelsDevCacheRoot,
+            checkCancellation: state.checkCancellation)
+        let usage = Self.makeClaudeFileUsage(
+            mtimeMs: mtimeMs,
             size: size,
-            days: parsed.days,
+            rows: parsed.rows,
             parsedBytes: parsed.parsedBytes)
         state.cache.files[path] = usage
-        Self.applyFileDays(cache: &state.cache, fileDays: usage.days, sign: 1)
     }
 
     private static func scanClaudeRoot(
         root: URL,
-        state: ClaudeScanState)
+        state: ClaudeScanState) throws
     {
+        try state.checkCancellation?()
         let rootPath = root.path
         let rootCandidates = Self.claudeRootCandidates(for: rootPath)
         let prefixes = Set(rootCandidates).map { path in
             path.hasSuffix("/") ? path : "\(path)/"
         }
         let rootExists = rootCandidates.contains { FileManager.default.fileExists(atPath: $0) }
-        let canonicalRootPath = rootCandidates.first(where: {
-            FileManager.default.fileExists(atPath: $0)
-        }) ?? rootPath
 
         guard rootExists else {
             let stale = state.cache.files.keys.filter { path in
                 prefixes.contains(where: { path.hasPrefix($0) })
             }
             for path in stale {
-                if let old = state.cache.files[path] {
-                    Self.applyFileDays(cache: &state.cache, fileDays: old.days, sign: -1)
-                }
                 state.cache.files.removeValue(forKey: path)
             }
-            for candidate in rootCandidates {
-                state.rootCache.removeValue(forKey: candidate)
-            }
-            return
-        }
-
-        let rootAttrs = (try? FileManager.default.attributesOfItem(atPath: canonicalRootPath)) ?? [:]
-        let rootMtime = (rootAttrs[.modificationDate] as? Date)?.timeIntervalSince1970 ?? 0
-        let rootMtimeMs = Int64(rootMtime * 1000)
-        let cachedRootMtime = rootCandidates.compactMap { state.rootCache[$0] }.first
-        let canSkipEnumeration = cachedRootMtime == rootMtimeMs && rootMtimeMs > 0
-
-        if canSkipEnumeration {
-            let cachedPaths = state.cache.files.keys.filter { path in
-                prefixes.contains(where: { path.hasPrefix($0) })
-            }
-            for path in cachedPaths {
-                guard FileManager.default.fileExists(atPath: path) else {
-                    if let old = state.cache.files[path] {
-                        Self.applyFileDays(cache: &state.cache, fileDays: old.days, sign: -1)
-                    }
-                    state.cache.files.removeValue(forKey: path)
-                    continue
-                }
-                let attrs = (try? FileManager.default.attributesOfItem(atPath: path)) ?? [:]
-                let size = (attrs[.size] as? NSNumber)?.int64Value ?? 0
-                if size <= 0 { continue }
-                let mtime = (attrs[.modificationDate] as? Date)?.timeIntervalSince1970 ?? 0
-                let mtimeMs = Int64(mtime * 1000)
-                Self.processClaudeFile(
-                    url: URL(fileURLWithPath: path),
-                    size: size,
-                    mtimeMs: mtimeMs,
-                    state: state)
-            }
             return
         }
 
+        // Always enumerate the directory tree. The per-file mtime/size cache in
+        // processClaudeFile already skips unchanged files, so the only cost here is
+        // the directory walk itself. The previous root-mtime optimization skipped
+        // enumeration entirely when the root directory mtime was unchanged, but on
+        // POSIX systems a directory mtime only updates for direct child changes —
+        // not for files created or modified inside subdirectories. This caused new
+        // session logs to go undetected until the cache was manually cleared.
         let keys: [URLResourceKey] = [
             .isRegularFileKey,
             .contentModificationDateKey,
@@ -404,6 +610,7 @@ extension CostUsageScanner {
         else { return }
 
         for case let url as URL in enumerator {
+            try state.checkCancellation?()
             guard url.pathExtension.lowercased() == "jsonl" else { continue }
             guard let values = try? url.resourceValues(forKeys: Set(keys)) else { continue }
             guard values.isRegularFile == true else { continue }
@@ -412,32 +619,33 @@ extension CostUsageScanner {
 
             let mtime = values.contentModificationDate?.timeIntervalSince1970 ?? 0
             let mtimeMs = Int64(mtime * 1000)
-            Self.processClaudeFile(
+            try Self.processClaudeFile(
                 url: url,
                 size: size,
                 mtimeMs: mtimeMs,
                 state: state)
         }
 
-        if rootMtimeMs > 0 {
-            state.rootCache[canonicalRootPath] = rootMtimeMs
-            for candidate in rootCandidates where candidate != canonicalRootPath {
-                state.rootCache.removeValue(forKey: candidate)
-            }
-        }
+        // Root mtime caching removed — see comment above.
     }
 
     static func loadClaudeDaily(
         provider: UsageProvider,
         range: CostUsageDayRange,
         now: Date,
-        options: Options) -> CostUsageDailyReport
+        options: Options,
+        checkCancellation: CancellationCheck?) throws -> CostUsageDailyReport
     {
         var cache = CostUsageCacheIO.load(provider: provider, cacheRoot: options.cacheRoot)
         let nowMs = Int64(now.timeIntervalSince1970 * 1000)
 
         let refreshMs = Int64(max(0, options.refreshMinIntervalSeconds) * 1000)
-        let shouldRefresh = refreshMs == 0 || cache.lastScanUnixMs == 0 || nowMs - cache.lastScanUnixMs > refreshMs
+        let windowExpanded = Self.requestedWindowExpandsCache(range: range, cache: cache)
+        let shouldRefresh = options.forceRescan
+            || windowExpanded
+            || refreshMs == 0
+            || cache.lastScanUnixMs == 0
+            || nowMs - cache.lastScanUnixMs > refreshMs
 
         let roots = self.defaultClaudeProjectsRoots(options: options)
         let providerFilter = options.claudeLogProviderFilter
@@ -445,39 +653,57 @@ extension CostUsageScanner {
         var touched: Set<String> = []
 
         if shouldRefresh {
+            try checkCancellation?()
             if options.forceRescan {
                 cache = CostUsageCache()
             }
-            let scanState = ClaudeScanState(cache: cache, range: range, providerFilter: providerFilter)
+            let modelsDevCatalog = CostUsagePricing.modelsDevCatalog(now: now, cacheRoot: options.cacheRoot)
+            let scanState = ClaudeScanState(
+                cache: cache,
+                range: range,
+                providerFilter: providerFilter,
+                forceFullScan: options.forceRescan || windowExpanded,
+                modelsDevCatalog: modelsDevCatalog,
+                modelsDevCacheRoot: options.cacheRoot,
+                checkCancellation: checkCancellation)
 
             for root in roots {
-                Self.scanClaudeRoot(
+                try Self.scanClaudeRoot(
                     root: root,
                     state: scanState)
             }
+            try checkCancellation?()
 
             cache = scanState.cache
             touched = scanState.touched
-            cache.roots = scanState.rootCache.isEmpty ? nil : scanState.rootCache
+            cache.roots = nil
 
             for key in cache.files.keys where !touched.contains(key) {
-                if let old = cache.files[key] {
-                    Self.applyFileDays(cache: &cache, fileDays: old.days, sign: -1)
-                }
                 cache.files.removeValue(forKey: key)
             }
 
+            Self.rebuildClaudeDays(cache: &cache)
             Self.pruneDays(cache: &cache, sinceKey: range.scanSinceKey, untilKey: range.scanUntilKey)
+            cache.scanSinceKey = range.scanSinceKey
+            cache.scanUntilKey = range.scanUntilKey
             cache.lastScanUnixMs = nowMs
+            try checkCancellation?()
             CostUsageCacheIO.save(provider: provider, cache: cache, cacheRoot: options.cacheRoot)
         }
 
-        return Self.buildClaudeReportFromCache(cache: cache, range: range)
+        let modelsDevCatalog = CostUsagePricing.modelsDevCatalog(now: now, cacheRoot: options.cacheRoot)
+        return Self.buildClaudeReportFromCache(
+            cache: cache,
+            range: range,
+            modelsDevCatalog: modelsDevCatalog,
+            modelsDevCacheRoot: options.cacheRoot)
     }
 
     private static func buildClaudeReportFromCache(
         cache: CostUsageCache,
-        range: CostUsageDayRange) -> CostUsageDailyReport
+        range: CostUsageDayRange,
+        modelsDevCatalog: ModelsDevCatalog? = nil,
+        modelsDevCacheRoot: URL? = nil) -> CostUsageDailyReport
     {
         var entries: [CostUsageDailyReport.Entry] = []
         var totalInput = 0
@@ -488,6 +714,41 @@ extension CostUsageScanner {
         var totalCost: Double = 0
         var costSeen = false
         let costScale = 1_000_000_000.0
+        var repricedCosts: [ClaudeDayModelKey: ClaudeRepricedCost] = [:]
+
+        for row in Self.reconciledClaudeRows(cache: cache) {
+            let key = ClaudeDayModelKey(day: row.dayKey, model: row.model)
+            var aggregate = repricedCosts[key] ?? ClaudeRepricedCost()
+            aggregate.sampleCount += 1
+            let isPriced = row.costPriced ?? (row.costNanos > 0)
+            let currentPricingCost = CostUsagePricing.claudeCostUSD(
+                model: row.model,
+                inputTokens: row.input,
+                cacheReadInputTokens: row.cacheRead,
+                cacheCreationInputTokens: row.cacheCreate,
+                cacheCreationInputTokens1h: row.cacheCreate1h ?? 0,
+                outputTokens: row.output,
+                pricingDate: row.timestampUnixMs.map {
+                    Date(timeIntervalSince1970: Double($0) / 1000)
+                },
+                modelsDevCatalog: modelsDevCatalog,
+                modelsDevCacheRoot: modelsDevCacheRoot)
+            let cost: Double? = if isPriced, row.costNanos == 0 {
+                0
+            } else if let currentPricingCost {
+                currentPricingCost
+            } else if isPriced {
+                Double(row.costNanos) / costScale
+            } else {
+                nil
+            }
+            if let cost {
+                aggregate.total += cost
+            } else {
+                aggregate.unresolved = true
+            }
+            repricedCosts[key] = aggregate
+        }
 
         let dayKeys = cache.days.keys.sorted().filter {
             CostUsageDayRange.isInRange(dayKey: $0, since: range.sinceKey, until: range.untilKey)
@@ -512,7 +773,8 @@ extension CostUsageScanner {
                 let cacheRead = packed[safe: 1] ?? 0
                 let cacheCreate = packed[safe: 2] ?? 0
                 let output = packed[safe: 3] ?? 0
-                let cachedCost = packed[safe: 4] ?? 0
+                let sampleCount = packed[safe: 5] ?? 0
+                let totalTokens = input + cacheRead + cacheCreate + output
 
                 // Cache tokens are tracked separately; totalTokens includes input + cache.
                 dayInput += input
@@ -520,23 +782,28 @@ extension CostUsageScanner {
                 dayCacheCreate += cacheCreate
                 dayOutput += output
 
-                let cost = cachedCost > 0
-                    ? Double(cachedCost) / costScale
-                    : CostUsagePricing.claudeCostUSD(
-                        model: model,
-                        inputTokens: input,
-                        cacheReadInputTokens: cacheRead,
-                        cacheCreationInputTokens: cacheCreate,
-                        outputTokens: output)
-                breakdown.append(CostUsageDailyReport.ModelBreakdown(modelName: model, costUSD: cost))
+                let repricedCost = repricedCosts[ClaudeDayModelKey(day: day, model: model)]
+                let currentPricingCost: Double? = if let repricedCost,
+                                                     repricedCost.sampleCount == sampleCount,
+                                                     !repricedCost.unresolved
+                {
+                    repricedCost.total
+                } else {
+                    nil
+                }
+                let cost = currentPricingCost
+                breakdown.append(
+                    CostUsageDailyReport.ModelBreakdown(
+                        modelName: model,
+                        costUSD: cost,
+                        totalTokens: totalTokens))
                 if let cost {
                     dayCost += cost
                     dayCostSeen = true
                 }
             }
 
-            breakdown.sort { lhs, rhs in (rhs.costUSD ?? -1) < (lhs.costUSD ?? -1) }
-            let top = Array(breakdown.prefix(3))
+            let sortedBreakdown = Self.sortedModelBreakdowns(breakdown)
 
             let dayTotal = dayInput + dayCacheRead + dayCacheCreate + dayOutput
             let entryCost = dayCostSeen ? dayCost : nil
@@ -549,7 +816,7 @@ extension CostUsageScanner {
                 totalTokens: dayTotal,
                 costUSD: entryCost,
                 modelsUsed: modelNames,
-                modelBreakdowns: top))
+                modelBreakdowns: sortedBreakdown))
 
             totalInput += dayInput
             totalOutput += dayOutput
diff --git a/Sources/CodexBarCore/Vendored/CostUsage/CostUsageScanner+CodexFastJSON.swift b/Sources/CodexBarCore/Vendored/CostUsage/CostUsageScanner+CodexFastJSON.swift
new file mode 100644
index 0000000000..958e45092c
--- /dev/null
+++ b/Sources/CodexBarCore/Vendored/CostUsage/CostUsageScanner+CodexFastJSON.swift
@@ -0,0 +1,255 @@
+import Foundation
+
+extension CostUsageScanner {
+    static func extractJSONByteStringField(
+        _ field: [UInt8],
+        from bytes: UnsafeBufferPointer<UInt8>,
+        in range: Range<Int>,
+        atDepth targetDepth: Int) -> String?
+    {
+        self.extractJSONByteField(field, from: bytes, in: range, atDepth: targetDepth) { valueIndex in
+            guard let parsed = parseJSONByteStringRange(in: bytes, index: &valueIndex, limit: range.upperBound),
+                  parsed.range.lowerBound < parsed.range.upperBound
+            else { return nil }
+            if parsed.hasEscapes {
+                return self.decodeEscapedJSONByteString(from: bytes, in: parsed.range)
+            }
+            return String(bytes: bytes[parsed.range], encoding: .utf8)
+        }
+    }
+
+    static func extractJSONByteObjectField(
+        _ field: [UInt8],
+        from bytes: UnsafeBufferPointer<UInt8>,
+        in range: Range<Int>,
+        atDepth targetDepth: Int) -> Range<Int>?
+    {
+        self.extractJSONByteField(field, from: bytes, in: range, atDepth: targetDepth) { valueIndex in
+            self.parseJSONByteObjectRange(in: bytes, index: &valueIndex, limit: range.upperBound)
+        }
+    }
+
+    static func extractJSONByteIntField(
+        _ field: [UInt8],
+        from bytes: UnsafeBufferPointer<UInt8>,
+        in range: Range<Int>,
+        atDepth targetDepth: Int) -> Int?
+    {
+        self.extractJSONByteField(field, from: bytes, in: range, atDepth: targetDepth) { valueIndex in
+            self.parseJSONByteInt(in: bytes, index: &valueIndex, limit: range.upperBound)
+        }
+    }
+
+    private static func extractJSONByteField<T>(
+        _ field: [UInt8],
+        from bytes: UnsafeBufferPointer<UInt8>,
+        in range: Range<Int>,
+        atDepth targetDepth: Int,
+        parseValue: (inout Int) -> T?) -> T?
+    {
+        var index = range.lowerBound
+        var depth = 0
+
+        while index < range.upperBound {
+            switch bytes[index] {
+            case 0x7B: // {
+                depth += 1
+                index += 1
+            case 0x7D: // }
+                depth -= 1
+                index += 1
+            case 0x22: // "
+                var valueIndex = index
+                guard let key = parseJSONByteStringRange(in: bytes, index: &valueIndex, limit: range.upperBound)
+                else { return nil }
+                index = valueIndex
+                guard depth == targetDepth,
+                      !key.hasEscapes,
+                      self.byteRange(bytes, key.range, equals: field)
+                else { continue }
+
+                self.skipJSONByteWhitespace(in: bytes, index: &valueIndex, limit: range.upperBound)
+                guard valueIndex < range.upperBound, bytes[valueIndex] == 0x3A else { continue } // :
+
+                valueIndex += 1
+                self.skipJSONByteWhitespace(in: bytes, index: &valueIndex, limit: range.upperBound)
+                if let value = parseValue(&valueIndex) {
+                    return value
+                }
+            default:
+                index += 1
+            }
+        }
+
+        return nil
+    }
+
+    private static func parseJSONByteStringRange(
+        in bytes: UnsafeBufferPointer<UInt8>,
+        index: inout Int,
+        limit: Int) -> (range: Range<Int>, hasEscapes: Bool)?
+    {
+        guard index < limit, bytes[index] == 0x22 else { return nil } // "
+        index += 1
+        let start = index
+        var hasEscapes = false
+
+        while index < limit {
+            switch bytes[index] {
+            case 0x5C: // \
+                hasEscapes = true
+                index += 2
+            case 0x22: // "
+                let end = index
+                index += 1
+                return (start..<end, hasEscapes)
+            default:
+                index += 1
+            }
+        }
+
+        return nil
+    }
+
+    private static func parseJSONByteObjectRange(
+        in bytes: UnsafeBufferPointer<UInt8>,
+        index: inout Int,
+        limit: Int) -> Range<Int>?
+    {
+        guard index < limit, bytes[index] == 0x7B else { return nil } // {
+        let start = index
+        var depth = 0
+
+        while index < limit {
+            switch bytes[index] {
+            case 0x22: // "
+                guard self.parseJSONByteStringRange(in: bytes, index: &index, limit: limit) != nil else {
+                    return nil
+                }
+            case 0x7B: // {
+                depth += 1
+                index += 1
+            case 0x7D: // }
+                depth -= 1
+                index += 1
+                if depth == 0 {
+                    return start..<index
+                }
+            default:
+                index += 1
+            }
+        }
+
+        return nil
+    }
+
+    private static func parseJSONByteInt(
+        in bytes: UnsafeBufferPointer<UInt8>,
+        index: inout Int,
+        limit: Int) -> Int?
+    {
+        var sign = 1
+        if index < limit, bytes[index] == 0x2D { // -
+            sign = -1
+            index += 1
+        }
+
+        var value = 0
+        var sawDigit = false
+        while index < limit {
+            let byte = bytes[index]
+            guard byte >= 0x30, byte <= 0x39 else { break }
+            sawDigit = true
+            let digit = Int(byte - 0x30)
+            let multiplied = value.multipliedReportingOverflow(by: 10)
+            if multiplied.overflow { return nil }
+            let added = multiplied.partialValue.addingReportingOverflow(digit)
+            if added.overflow { return nil }
+            value = added.partialValue
+            index += 1
+        }
+        return sawDigit ? (sign == -1 ? -value : value) : nil
+    }
+
+    private static func skipJSONByteWhitespace(
+        in bytes: UnsafeBufferPointer<UInt8>,
+        index: inout Int,
+        limit: Int)
+    {
+        while index < limit {
+            switch bytes[index] {
+            case 0x20, 0x09, 0x0A, 0x0D:
+                index += 1
+            default:
+                return
+            }
+        }
+    }
+
+    private static func decodeEscapedJSONByteString(
+        from bytes: UnsafeBufferPointer<UInt8>,
+        in range: Range<Int>) -> String?
+    {
+        var out: [UInt8] = []
+        out.reserveCapacity(range.count)
+        var index = range.lowerBound
+        while index < range.upperBound {
+            let byte = bytes[index]
+            guard byte == 0x5C else { // \
+                out.append(byte)
+                index += 1
+                continue
+            }
+
+            index += 1
+            guard index < range.upperBound else { return nil }
+            switch bytes[index] {
+            case 0x22, 0x5C, 0x2F: // ", \, /
+                out.append(bytes[index])
+            case 0x62: // b
+                out.append(0x08)
+            case 0x66: // f
+                out.append(0x0C)
+            case 0x6E: // n
+                out.append(0x0A)
+            case 0x72: // r
+                out.append(0x0D)
+            case 0x74: // t
+                out.append(0x09)
+            case 0x75: // u
+                return self.decodeJSONStringViaFoundation(from: bytes, in: range)
+            default:
+                return nil
+            }
+            index += 1
+        }
+
+        return String(bytes: out, encoding: .utf8)
+    }
+
+    private static func decodeJSONStringViaFoundation(
+        from bytes: UnsafeBufferPointer<UInt8>,
+        in range: Range<Int>) -> String?
+    {
+        var data = Data([0x22])
+        data.append(UnsafeBufferPointer(rebasing: bytes[range]))
+        data.append(0x22)
+        return (try? JSONSerialization.jsonObject(with: data)) as? String
+    }
+
+    private static func byteRange(
+        _ bytes: UnsafeBufferPointer<UInt8>,
+        _ range: Range<Int>,
+        equals field: [UInt8]) -> Bool
+    {
+        guard range.count == field.count else { return false }
+        var index = range.lowerBound
+        var fieldIndex = 0
+        while index < range.upperBound {
+            guard bytes[index] == field[fieldIndex] else { return false }
+            index += 1
+            fieldIndex += 1
+        }
+        return true
+    }
+}
diff --git a/Sources/CodexBarCore/Vendored/CostUsage/CostUsageScanner+CodexPriority.swift b/Sources/CodexBarCore/Vendored/CostUsage/CostUsageScanner+CodexPriority.swift
new file mode 100644
index 0000000000..088af5b728
--- /dev/null
+++ b/Sources/CodexBarCore/Vendored/CostUsage/CostUsageScanner+CodexPriority.swift
@@ -0,0 +1,653 @@
+import Foundation
+#if canImport(SQLite3)
+import SQLite3
+#endif
+
+extension CostUsageScanner {
+    struct CodexPriorityTurnMetadata: Codable, Equatable {
+        var threadID: String?
+        var turnID: String
+        var model: String?
+        var timestamp: String?
+    }
+
+    private static let requestMarker = "websocket request:"
+
+    static func defaultCodexPriorityDatabaseURL() -> URL {
+        FileManager.default.homeDirectoryForCurrentUser
+            .appendingPathComponent(".codex", isDirectory: true)
+            .appendingPathComponent("logs_2.sqlite", isDirectory: false)
+    }
+
+    #if canImport(SQLite3)
+    /// Accumulated priority-turn state for one trace database. The `logs` table uses an
+    /// `INTEGER PRIMARY KEY AUTOINCREMENT` id, so rowids are monotonic and never
+    /// reused. Codex prunes old rows in place, so source row IDs are retained and cheaply
+    /// revalidated before each incremental scan.
+    struct CodexPriorityTurnsMemoState {
+        var observationID: UInt64
+        var coverageSinceEpoch: Int64
+        var lastRowID: Int64
+        var fileIdentity: UInt64?
+        var turns: [String: CodexPriorityTurnMetadata]
+        var requestSourcesByTurnID: [String: [Int64: CodexPriorityTurnMetadata]]
+        var priorityCompletedModelsByTurnID: [String: [Int64: String]]
+        var completedModelsByTurnID: [String: [Int64: String]]
+        var completedTurnIDInsertionOrder: [String]
+        var completedTurnIDInsertionOrderStartIndex: Int
+    }
+
+    /// Completion models for known priority turns are retained with those turns. Completions
+    /// seen before their request are pending and may belong to non-priority turns, so that
+    /// separate map is bounded to keep memory constant while preserving ordering.
+    static let codexPriorityCompletedModelRetentionLimit = 4096
+
+    private final class CodexPriorityLockedState<State>: @unchecked Sendable {
+        private let lock = NSLock()
+        private var state: State
+
+        init(_ state: State) {
+            self.state = state
+        }
+
+        func withLock<Result>(_ body: (inout State) throws -> Result) rethrows -> Result {
+            self.lock.lock()
+            defer { self.lock.unlock() }
+            return try body(&self.state)
+        }
+    }
+
+    private static let codexPriorityTurnsMemo =
+        CodexPriorityLockedState<[String: CodexPriorityTurnsMemoState]>([:])
+    private static let codexPriorityTurnsObservationCounter = CodexPriorityLockedState<UInt64>(0)
+
+    private static func nextCodexPriorityTurnsObservationID() -> UInt64 {
+        self.codexPriorityTurnsObservationCounter.withLock {
+            $0 &+= 1
+            return $0
+        }
+    }
+
+    /// Scans run outside the lock, so overlapping refreshes can write back out of order.
+    /// A monotonically increasing observation ID makes the later-started scan authoritative;
+    /// same-observation test snapshots still use coverage/cursor dominance.
+    static func storeCodexPriorityTurnsMemoIfNewer(
+        _ updated: CodexPriorityTurnsMemoState,
+        forPath path: String)
+    {
+        self.codexPriorityTurnsMemo.withLock { memo in
+            if let existing = memo[path],
+               existing.observationID > updated.observationID
+            {
+                return
+            }
+            if let existing = memo[path],
+               existing.observationID == updated.observationID,
+               existing.fileIdentity == updated.fileIdentity,
+               existing.coverageSinceEpoch <= updated.coverageSinceEpoch,
+               existing.lastRowID >= updated.lastRowID
+            {
+                return
+            }
+            memo[path] = updated
+        }
+    }
+
+    static func _test_resetCodexPriorityTurnsMemo() {
+        self.codexPriorityTurnsMemo.withLock { $0.removeAll() }
+        self.codexPriorityTurnsObservationCounter.withLock { $0 = 0 }
+    }
+
+    static func _test_codexPriorityTurnsMemoState(forPath path: String) -> CodexPriorityTurnsMemoState? {
+        self.codexPriorityTurnsMemo.withLock { $0[path] }
+    }
+
+    static func _test_accumulateCodexPriorityTurns(
+        _ db: OpaquePointer?,
+        into state: inout CodexPriorityTurnsMemoState) -> Bool
+    {
+        self.accumulateCodexPriorityTurns(db, into: &state)
+    }
+
+    static func _test_codexPriorityAccumulationQuery(
+        _ db: OpaquePointer?,
+        lastRowID: Int64,
+        coverageSinceEpoch: Int64) -> String
+    {
+        self.codexPriorityAccumulationPlan(
+            db,
+            lastRowID: lastRowID,
+            coverageSinceEpoch: coverageSinceEpoch).query
+    }
+    #endif
+
+    /// Resolves priority turn metadata from the codex CLI trace database. The full-table
+    /// `LIKE` scan over `feedback_log_body` grows with the database (hundreds of megabytes on
+    /// active machines) and used to run on every refresh past the scan interval. For windows
+    /// that extend through today — every live refresh — the result is now accumulated per
+    /// database in process memory and only rows appended since the last call are examined; the
+    /// database shrinking or being replaced, or the requested window expanding earlier than
+    /// the accumulated coverage, triggers a full rescan. Windows that end before today keep
+    /// the original bounded one-shot query so historical lookups never pay an open-ended scan.
+    static func codexPriorityTurns(
+        databaseURL: URL? = nil,
+        sinceDayKey: String? = nil,
+        untilDayKey: String? = nil) -> [String: CodexPriorityTurnMetadata]
+    {
+        let url = databaseURL ?? self.defaultCodexPriorityDatabaseURL()
+        guard FileManager.default.fileExists(atPath: url.path) else { return [:] }
+
+        #if canImport(SQLite3)
+        if let untilDayKey, untilDayKey < CostUsageDayRange.dayKey(from: Date()) {
+            return self.boundedCodexPriorityTurns(
+                databaseURL: url,
+                sinceDayKey: sinceDayKey,
+                untilDayKey: untilDayKey)
+        }
+
+        guard let opened = self.openCodexPriorityDatabase(at: url) else { return [:] }
+        let db = opened.db
+        let fileIdentity = opened.fileIdentity
+        defer { sqlite3_close(db) }
+        sqlite3_busy_timeout(db, 250)
+
+        let observationID = self.nextCodexPriorityTurnsObservationID()
+        guard let maxRowID = self.maxCodexLogsRowID(db) else { return [:] }
+
+        let requestedSinceEpoch: Int64 = if sinceDayKey != nil || untilDayKey != nil {
+            self.epochSeconds(forDayKey: sinceDayKey ?? "0000-01-01") ?? 0
+        } else {
+            0
+        }
+
+        var state = self.codexPriorityTurnsMemo.withLock { $0[url.path] }
+        if let memo = state,
+           maxRowID < memo.lastRowID
+           || requestedSinceEpoch < memo.coverageSinceEpoch
+           || memo.fileIdentity != fileIdentity
+        {
+            state = nil
+        }
+        var resolved = state ?? CodexPriorityTurnsMemoState(
+            observationID: observationID,
+            coverageSinceEpoch: requestedSinceEpoch,
+            lastRowID: 0,
+            fileIdentity: fileIdentity,
+            turns: [:],
+            requestSourcesByTurnID: [:],
+            priorityCompletedModelsByTurnID: [:],
+            completedModelsByTurnID: [:],
+            completedTurnIDInsertionOrder: [],
+            completedTurnIDInsertionOrderStartIndex: 0)
+        resolved.observationID = observationID
+
+        var prunedDeletedSources = false
+        if state != nil {
+            var pruned = resolved
+            guard let didPrune = self.pruneDeletedCodexPrioritySources(db, from: &pruned) else {
+                return self.filteredResolvedCodexPriorityTurns(
+                    resolved,
+                    sinceDayKey: sinceDayKey,
+                    untilDayKey: untilDayKey)
+            }
+            resolved = pruned
+            prunedDeletedSources = didPrune
+        }
+
+        if maxRowID > resolved.lastRowID {
+            var updated = resolved
+            guard self.accumulateCodexPriorityTurns(db, into: &updated) else {
+                return self.filteredResolvedCodexPriorityTurns(
+                    resolved,
+                    sinceDayKey: sinceDayKey,
+                    untilDayKey: untilDayKey)
+            }
+            updated.lastRowID = maxRowID
+            self.storeCodexPriorityTurnsMemoIfNewer(updated, forPath: url.path)
+            resolved = updated
+        } else if state == nil || prunedDeletedSources {
+            self.storeCodexPriorityTurnsMemoIfNewer(resolved, forPath: url.path)
+        }
+
+        return self.filteredResolvedCodexPriorityTurns(
+            resolved,
+            sinceDayKey: sinceDayKey,
+            untilDayKey: untilDayKey)
+        #else
+        return [:]
+        #endif
+    }
+
+    #if canImport(SQLite3)
+    private static func filteredResolvedCodexPriorityTurns(
+        _ state: CodexPriorityTurnsMemoState,
+        sinceDayKey: String?,
+        untilDayKey: String?) -> [String: CodexPriorityTurnMetadata]
+    {
+        var turns = state.turns
+        for (turnID, completedModels) in state.priorityCompletedModelsByTurnID {
+            turns[turnID]?.model = self.latestCodexCompletedModel(completedModels)
+        }
+        guard sinceDayKey != nil || untilDayKey != nil else { return turns }
+        return turns.filter { _, turn in
+            self.timestamp(turn.timestamp, isInRangeSince: sinceDayKey, until: untilDayKey)
+        }
+    }
+
+    private static func latestCodexCompletedModel(_ modelsByRowID: [Int64: String]) -> String? {
+        modelsByRowID.max { $0.key < $1.key }?.value
+    }
+
+    /// The pre-memo one-shot query, kept for windows that end before today: both `ts` bounds
+    /// stay in SQL, so a narrow historical window never scans the database tail.
+    private static func boundedCodexPriorityTurns(
+        databaseURL: URL,
+        sinceDayKey: String?,
+        untilDayKey: String?) -> [String: CodexPriorityTurnMetadata]
+    {
+        var db: OpaquePointer?
+        guard sqlite3_open_v2(databaseURL.path, &db, SQLITE_OPEN_READONLY, nil) == SQLITE_OK else {
+            sqlite3_close(db)
+            return [:]
+        }
+        defer { sqlite3_close(db) }
+        sqlite3_busy_timeout(db, 250)
+
+        let query = """
+        select ts, feedback_log_body
+        from logs
+        where ts >= ? and ts < ?
+          and (feedback_log_body like '%websocket request:%'
+               or feedback_log_body like '%response.completed%')
+        """
+        var stmt: OpaquePointer?
+        guard sqlite3_prepare_v2(db, query, -1, &stmt, nil) == SQLITE_OK else { return [:] }
+        defer { sqlite3_finalize(stmt) }
+        let start = self.epochSeconds(forDayKey: sinceDayKey ?? "0000-01-01") ?? 0
+        let end = self.epochSeconds(forDayKey: self.nextDayKey(after: untilDayKey ?? "9999-12-30"))
+            ?? Int64.max
+        sqlite3_bind_int64(stmt, 1, start)
+        sqlite3_bind_int64(stmt, 2, end)
+
+        var turns: [String: CodexPriorityTurnMetadata] = [:]
+        var completedModelsByTurnID: [String: String] = [:]
+        while sqlite3_step(stmt) == SQLITE_ROW {
+            let timestamp = self.timestamp(stmt: stmt, index: 0)
+            guard self.timestamp(timestamp, isInRangeSince: sinceDayKey, until: untilDayKey),
+                  let body = self.text(stmt: stmt, index: 1)
+            else { continue }
+            if let completed = self.parseCodexCompletedTraceRow(body: body) {
+                completedModelsByTurnID[completed.turnID] = completed.model
+                if var existing = turns[completed.turnID] {
+                    existing.model = completed.model
+                    turns[completed.turnID] = existing
+                }
+                continue
+            }
+            guard var parsed = self.parseCodexPriorityTraceRow(timestamp: timestamp, body: body)
+            else { continue }
+            if let completedModel = completedModelsByTurnID[parsed.turnID] {
+                parsed.model = completedModel
+            }
+            turns[parsed.turnID] = parsed
+        }
+        return turns
+    }
+
+    private static func maxCodexLogsRowID(_ db: OpaquePointer?) -> Int64? {
+        var stmt: OpaquePointer?
+        guard sqlite3_prepare_v2(db, "select max(rowid) from logs", -1, &stmt, nil) == SQLITE_OK
+        else { return nil }
+        defer { sqlite3_finalize(stmt) }
+        guard sqlite3_step(stmt) == SQLITE_ROW else { return nil }
+        return sqlite3_column_int64(stmt, 0)
+    }
+
+    static func openCodexPriorityDatabase(
+        at url: URL,
+        afterOpen: (() -> Void)? = nil) -> (db: OpaquePointer?, fileIdentity: UInt64)?
+    {
+        guard let fileIdentity = self.codexPriorityDatabaseFileIdentity(at: url) else { return nil }
+        var db: OpaquePointer?
+        guard sqlite3_open_v2(url.path, &db, SQLITE_OPEN_READONLY, nil) == SQLITE_OK else {
+            sqlite3_close(db)
+            return nil
+        }
+        afterOpen?()
+        guard self.codexPriorityDatabaseFileIdentity(at: url) == fileIdentity else {
+            sqlite3_close(db)
+            return nil
+        }
+        return (db, fileIdentity)
+    }
+
+    private static func codexPriorityDatabaseFileIdentity(at url: URL) -> UInt64? {
+        (try? FileManager.default.attributesOfItem(atPath: url.path))?[.systemFileNumber]
+            .flatMap { $0 as? UInt64 }
+    }
+
+    private static func pruneDeletedCodexPrioritySources(
+        _ db: OpaquePointer?,
+        from state: inout CodexPriorityTurnsMemoState) -> Bool?
+    {
+        let sourceRowIDs = state.requestSourcesByTurnID.values.flatMap(\.keys)
+            + state.priorityCompletedModelsByTurnID.values.flatMap(\.keys)
+            + state.completedModelsByTurnID.values.flatMap(\.keys)
+        guard let retainedRowIDs = self.retainedCodexPrioritySourceRowIDs(db, rowIDs: sourceRowIDs) else {
+            return nil
+        }
+
+        var didPrune = false
+        for (turnID, sources) in state.requestSourcesByTurnID {
+            let retainedSources = sources.filter { retainedRowIDs.contains($0.key) }
+            guard retainedSources.count != sources.count else { continue }
+            didPrune = true
+            if retainedSources.isEmpty {
+                state.requestSourcesByTurnID.removeValue(forKey: turnID)
+                state.turns.removeValue(forKey: turnID)
+                if let completedModels = state.priorityCompletedModelsByTurnID.removeValue(forKey: turnID) {
+                    self.storePendingCodexCompletedModels(completedModels, turnID: turnID, in: &state)
+                }
+            } else {
+                state.requestSourcesByTurnID[turnID] = retainedSources
+                state.turns[turnID] = retainedSources.max { $0.key < $1.key }?.value
+            }
+        }
+
+        didPrune = self.pruneDeletedCodexCompletedModels(
+            retainedRowIDs: retainedRowIDs,
+            from: &state.priorityCompletedModelsByTurnID) || didPrune
+        didPrune = self.pruneDeletedCodexCompletedModels(
+            retainedRowIDs: retainedRowIDs,
+            from: &state.completedModelsByTurnID) || didPrune
+        self.compactCodexPendingCompletionOrderPrefix(in: &state)
+        state.completedTurnIDInsertionOrder.removeAll { state.completedModelsByTurnID[$0] == nil }
+        return didPrune
+    }
+
+    private static func pruneDeletedCodexCompletedModels(
+        retainedRowIDs: Set<Int64>,
+        from modelsByTurnID: inout [String: [Int64: String]]) -> Bool
+    {
+        var didPrune = false
+        for (turnID, modelsByRowID) in modelsByTurnID {
+            let retainedModels = modelsByRowID.filter { retainedRowIDs.contains($0.key) }
+            guard retainedModels.count != modelsByRowID.count else { continue }
+            didPrune = true
+            if retainedModels.isEmpty {
+                modelsByTurnID.removeValue(forKey: turnID)
+            } else {
+                modelsByTurnID[turnID] = retainedModels
+            }
+        }
+        return didPrune
+    }
+
+    private static func retainedCodexPrioritySourceRowIDs(
+        _ db: OpaquePointer?,
+        rowIDs: [Int64]) -> Set<Int64>?
+    {
+        guard !rowIDs.isEmpty else { return [] }
+
+        var retained: Set<Int64> = []
+        let chunkSize = 500
+        for start in stride(from: 0, to: rowIDs.count, by: chunkSize) {
+            let end = min(start + chunkSize, rowIDs.count)
+            let chunk = rowIDs[start..<end]
+            let placeholders = Array(repeating: "?", count: chunk.count).joined(separator: ",")
+            let query = "select rowid from logs where rowid in (\(placeholders))"
+            var stmt: OpaquePointer?
+            guard sqlite3_prepare_v2(db, query, -1, &stmt, nil) == SQLITE_OK else { return nil }
+            defer { sqlite3_finalize(stmt) }
+            for (offset, rowID) in chunk.enumerated() {
+                sqlite3_bind_int64(stmt, Int32(offset + 1), rowID)
+            }
+            while true {
+                let stepResult = sqlite3_step(stmt)
+                if stepResult == SQLITE_DONE { break }
+                guard stepResult == SQLITE_ROW else { return nil }
+                retained.insert(sqlite3_column_int64(stmt, 0))
+            }
+        }
+        return retained
+    }
+
+    private static func storePendingCodexCompletedModels(
+        _ completedModels: [Int64: String],
+        turnID: String,
+        in state: inout CodexPriorityTurnsMemoState)
+    {
+        if state.completedModelsByTurnID[turnID] == nil {
+            state.completedTurnIDInsertionOrder.append(turnID)
+            let retainedCount = state.completedTurnIDInsertionOrder.count
+                - state.completedTurnIDInsertionOrderStartIndex
+            if retainedCount > self.codexPriorityCompletedModelRetentionLimit {
+                let evicted = state.completedTurnIDInsertionOrder[
+                    state.completedTurnIDInsertionOrderStartIndex,
+                ]
+                state.completedTurnIDInsertionOrderStartIndex += 1
+                state.completedModelsByTurnID.removeValue(forKey: evicted)
+                if state.completedTurnIDInsertionOrderStartIndex
+                    >= self.codexPriorityCompletedModelRetentionLimit
+                {
+                    self.compactCodexPendingCompletionOrderPrefix(in: &state)
+                }
+            }
+        }
+        state.completedModelsByTurnID[turnID, default: [:]].merge(completedModels) { _, new in new }
+    }
+
+    private static func compactCodexPendingCompletionOrderPrefix(
+        in state: inout CodexPriorityTurnsMemoState)
+    {
+        guard state.completedTurnIDInsertionOrderStartIndex > 0 else { return }
+        state.completedTurnIDInsertionOrder.removeFirst(state.completedTurnIDInsertionOrderStartIndex)
+        state.completedTurnIDInsertionOrderStartIndex = 0
+    }
+
+    private static func accumulateCodexPriorityTurns(
+        _ db: OpaquePointer?,
+        into state: inout CodexPriorityTurnsMemoState) -> Bool
+    {
+        let plan = self.codexPriorityAccumulationPlan(
+            db,
+            lastRowID: state.lastRowID,
+            coverageSinceEpoch: state.coverageSinceEpoch)
+        var stmt: OpaquePointer?
+        guard sqlite3_prepare_v2(db, plan.query, -1, &stmt, nil) == SQLITE_OK else { return false }
+        defer { sqlite3_finalize(stmt) }
+        if plan.usesTimestampIndex {
+            sqlite3_bind_int64(stmt, 1, state.coverageSinceEpoch)
+        } else {
+            sqlite3_bind_int64(stmt, 1, state.lastRowID)
+            sqlite3_bind_int64(stmt, 2, state.coverageSinceEpoch)
+        }
+
+        while true {
+            let stepResult = sqlite3_step(stmt)
+            guard stepResult == SQLITE_ROW else { return stepResult == SQLITE_DONE }
+            let rowID = sqlite3_column_int64(stmt, 0)
+            let timestamp = self.timestamp(stmt: stmt, index: 1)
+            guard let body = self.text(stmt: stmt, index: 2) else { continue }
+            if let completed = self.parseCodexCompletedTraceRow(body: body) {
+                if state.turns[completed.turnID] != nil {
+                    state.priorityCompletedModelsByTurnID[completed.turnID, default: [:]][rowID] = completed.model
+                } else {
+                    self.storePendingCodexCompletedModels(
+                        [rowID: completed.model],
+                        turnID: completed.turnID,
+                        in: &state)
+                }
+                continue
+            }
+            guard let parsed = self.parseCodexPriorityTraceRow(timestamp: timestamp, body: body)
+            else { continue }
+            state.turns[parsed.turnID] = parsed
+            state.requestSourcesByTurnID[parsed.turnID, default: [:]][rowID] = parsed
+            if let completedModels = state.completedModelsByTurnID.removeValue(forKey: parsed.turnID) {
+                self.compactCodexPendingCompletionOrderPrefix(in: &state)
+                state.completedTurnIDInsertionOrder.removeAll { $0 == parsed.turnID }
+                state.priorityCompletedModelsByTurnID[parsed.turnID] = completedModels
+            }
+        }
+    }
+
+    private static func codexPriorityAccumulationPlan(
+        _ db: OpaquePointer?,
+        lastRowID: Int64,
+        coverageSinceEpoch: Int64) -> (query: String, usesTimestampIndex: Bool)
+    {
+        if lastRowID == 0,
+           coverageSinceEpoch > 0,
+           self.hasCodexLogsTimestampIndex(db)
+        {
+            return (
+                """
+                select rowid, ts, feedback_log_body
+                from logs indexed by idx_logs_ts
+                where ts >= ?
+                  and (feedback_log_body like '%websocket request:%'
+                       or feedback_log_body like '%response.completed%')
+                order by rowid
+                """,
+                true)
+        }
+        return (
+            """
+            select rowid, ts, feedback_log_body
+            from logs
+            where rowid > ? and ts >= ?
+              and (feedback_log_body like '%websocket request:%'
+                   or feedback_log_body like '%response.completed%')
+            order by rowid
+            """,
+            false)
+    }
+
+    private static func hasCodexLogsTimestampIndex(_ db: OpaquePointer?) -> Bool {
+        var stmt: OpaquePointer?
+        let query = """
+        select 1
+        from sqlite_master
+        where type = 'index' and tbl_name = 'logs' and name = 'idx_logs_ts'
+        limit 1
+        """
+        guard sqlite3_prepare_v2(db, query, -1, &stmt, nil) == SQLITE_OK else { return false }
+        defer { sqlite3_finalize(stmt) }
+        return sqlite3_step(stmt) == SQLITE_ROW
+    }
+    #endif
+
+    static func parseCodexPriorityTraceRow(timestamp: String?, body: String) -> CodexPriorityTurnMetadata? {
+        guard let markerRange = body.range(of: self.requestMarker) else { return nil }
+        let prefix = String(body[..<markerRange.lowerBound])
+        let jsonText = body[markerRange.upperBound...].trimmingCharacters(in: .whitespacesAndNewlines)
+        guard let data = jsonText.data(using: .utf8),
+              let request = (try? JSONSerialization.jsonObject(with: data)) as? [String: Any],
+              request["type"] as? String == "response.create",
+              request["service_tier"] as? String == "priority"
+        else { return nil }
+
+        let turnID = self.value(named: "turn.id", in: prefix)
+            ?? self.value(named: "turn_id", in: prefix)
+            ?? request["turn_id"] as? String
+        guard let turnID, !turnID.isEmpty else { return nil }
+
+        return CodexPriorityTurnMetadata(
+            threadID: self.value(named: "thread_id", in: prefix),
+            turnID: turnID,
+            model: request["model"] as? String,
+            timestamp: timestamp)
+    }
+
+    static func parseCodexCompletedTraceRow(body: String) -> (turnID: String, model: String)? {
+        let marker = "websocket event:"
+        guard let markerRange = body.range(of: marker) else { return nil }
+        let prefix = String(body[..<markerRange.lowerBound])
+        let jsonText = body[markerRange.upperBound...].trimmingCharacters(in: .whitespacesAndNewlines)
+        guard let data = jsonText.data(using: .utf8),
+              let event = (try? JSONSerialization.jsonObject(with: data)) as? [String: Any],
+              event["type"] as? String == "response.completed",
+              let response = event["response"] as? [String: Any],
+              let model = response["model"] as? String,
+              !model.isEmpty
+        else { return nil }
+
+        let turnID = self.value(named: "turn.id", in: prefix)
+            ?? self.value(named: "turn_id", in: prefix)
+        guard let turnID, !turnID.isEmpty else { return nil }
+
+        return (turnID: turnID, model: model)
+    }
+
+    private static func value(named name: String, in text: String) -> String? {
+        guard let range = text.range(of: "\(name)=") else { return nil }
+        let tail = text[range.upperBound...]
+        let value = tail.prefix { char in
+            !char.isWhitespace && char != "," && char != "]" && char != ")"
+        }
+        return value.isEmpty ? nil : String(value)
+    }
+
+    #if canImport(SQLite3)
+    private static func text(stmt: OpaquePointer?, index: Int32) -> String? {
+        guard sqlite3_column_type(stmt, index) != SQLITE_NULL,
+              let cString = sqlite3_column_text(stmt, index)
+        else { return nil }
+        return String(cString: cString)
+    }
+
+    private static func timestamp(stmt: OpaquePointer?, index: Int32) -> String? {
+        guard sqlite3_column_type(stmt, index) != SQLITE_NULL else { return nil }
+        if sqlite3_column_type(stmt, index) == SQLITE_INTEGER {
+            return String(sqlite3_column_int64(stmt, index))
+        }
+        return self.text(stmt: stmt, index: index)
+    }
+    #endif
+
+    private static func timestamp(_ timestamp: String?, isInRangeSince since: String?, until: String?) -> Bool {
+        guard since != nil || until != nil else { return true }
+        guard let dayKey = self.dayKey(fromTimestamp: timestamp) else { return false }
+        if let since, dayKey < since { return false }
+        if let until, dayKey > until { return false }
+        return true
+    }
+
+    private static func dayKey(fromTimestamp timestamp: String?) -> String? {
+        guard let timestamp else { return nil }
+        if let seconds = Int64(timestamp) {
+            return CostUsageScanner.CostUsageDayRange.dayKey(
+                from: Date(timeIntervalSince1970: TimeInterval(seconds)))
+        }
+        let dayKey = timestamp.prefix(10)
+        return dayKey.count == 10 ? String(dayKey) : nil
+    }
+
+    private static func nextDayKey(after dayKey: String) -> String {
+        guard let date = self.localDate(forDayKey: dayKey),
+              let next = Calendar.current.date(byAdding: .day, value: 1, to: date)
+        else { return dayKey }
+        return CostUsageScanner.CostUsageDayRange.dayKey(from: next)
+    }
+
+    private static func epochSeconds(forDayKey dayKey: String) -> Int64? {
+        guard let date = self.localDate(forDayKey: dayKey) else { return nil }
+        return Int64(date.timeIntervalSince1970)
+    }
+
+    private static func localDate(forDayKey dayKey: String) -> Date? {
+        let parts = dayKey.split(separator: "-")
+        guard parts.count == 3,
+              let year = Int(parts[0]),
+              let month = Int(parts[1]),
+              let day = Int(parts[2])
+        else { return nil }
+        var components = DateComponents()
+        components.calendar = Calendar.current
+        components.year = year
+        components.month = month
+        components.day = day
+        return components.date
+    }
+}
diff --git a/Sources/CodexBarCore/Vendored/CostUsage/CostUsageScanner+CodexTruncatedPrefix.swift b/Sources/CodexBarCore/Vendored/CostUsage/CostUsageScanner+CodexTruncatedPrefix.swift
new file mode 100644
index 0000000000..dadb09039e
--- /dev/null
+++ b/Sources/CodexBarCore/Vendored/CostUsage/CostUsageScanner+CodexTruncatedPrefix.swift
@@ -0,0 +1,148 @@
+import Foundation
+
+extension CostUsageScanner {
+    static func extractCodexTurnContextModel(from bytes: Data) -> String? {
+        guard let text = truncatedUTF8String(from: bytes) else { return nil }
+        let object = text[...]
+        guard Self.extractJSONStringField("type", from: object, atDepth: 1) == "turn_context",
+              let payloadText = Self.extractJSONObjectField("payload", from: object, atDepth: 1)
+        else { return nil }
+
+        let payloadModel = Self.extractJSONStringField("model", from: payloadText, atDepth: 1)
+            ?? Self.extractJSONStringField("model_name", from: payloadText, atDepth: 1)
+        if let payloadModel { return payloadModel }
+
+        guard let infoText = Self.extractJSONObjectField("info", from: payloadText, atDepth: 1) else { return nil }
+        return Self.extractJSONStringField("model", from: infoText, atDepth: 1)
+            ?? Self.extractJSONStringField("model_name", from: infoText, atDepth: 1)
+    }
+
+    static func truncatedUTF8String(from bytes: Data) -> String? {
+        for dropCount in 0...min(4, bytes.count) {
+            let end = bytes.count - dropCount
+            if let text = String(bytes: bytes.prefix(end), encoding: .utf8) {
+                return text
+            }
+        }
+        return nil
+    }
+
+    static func extractJSONStringField(
+        _ field: String,
+        from text: Substring,
+        atDepth targetDepth: Int) -> String?
+    {
+        self.extractJSONField(field, from: text, atDepth: targetDepth) { text, index in
+            guard index < text.endIndex, text[index] == "\"" else { return nil }
+            let value = Self.parseJSONString(in: text, index: &index)
+            return value?.isEmpty == true ? nil : value
+        }
+    }
+
+    static func extractJSONObjectField(
+        _ field: String,
+        from text: Substring,
+        atDepth targetDepth: Int) -> Substring?
+    {
+        self.extractJSONField(field, from: text, atDepth: targetDepth) { text, index in
+            guard index < text.endIndex, text[index] == "{" else { return nil }
+            return text[index...]
+        }
+    }
+
+    static func extractJSONIntField(
+        _ field: String,
+        from text: Substring,
+        atDepth targetDepth: Int) -> Int?
+    {
+        self.extractJSONField(field, from: text, atDepth: targetDepth) { text, index in
+            Self.parseJSONInt(in: text, index: &index)
+        }
+    }
+
+    static func extractJSONField<T>(
+        _ field: String,
+        from text: Substring,
+        atDepth targetDepth: Int,
+        parseValue: (Substring, inout String.Index) -> T?) -> T?
+    {
+        var index = text.startIndex
+        var depth = 0
+
+        while index < text.endIndex {
+            let character = text[index]
+            if character == "{" {
+                depth += 1
+                text.formIndex(after: &index)
+            } else if character == "}" {
+                depth -= 1
+                text.formIndex(after: &index)
+            } else if character == "\"" {
+                var valueIndex = index
+                guard let key = Self.parseJSONString(in: text, index: &valueIndex) else { return nil }
+                defer { index = valueIndex }
+                guard depth == targetDepth, key == field else { continue }
+
+                Self.skipJSONWhitespace(in: text, index: &valueIndex)
+                guard valueIndex < text.endIndex, text[valueIndex] == ":" else { continue }
+
+                text.formIndex(after: &valueIndex)
+                Self.skipJSONWhitespace(in: text, index: &valueIndex)
+                if let value = parseValue(text, &valueIndex) {
+                    return value
+                }
+            } else {
+                text.formIndex(after: &index)
+            }
+        }
+
+        return nil
+    }
+
+    static func parseJSONString(in text: Substring, index: inout String.Index) -> String? {
+        guard index < text.endIndex, text[index] == "\"" else { return nil }
+        text.formIndex(after: &index)
+        var value = ""
+        var isEscaped = false
+        while index < text.endIndex {
+            let character = text[index]
+            if isEscaped {
+                value.append(character)
+                isEscaped = false
+            } else if character == "\\" {
+                isEscaped = true
+            } else if character == "\"" {
+                text.formIndex(after: &index)
+                return value
+            } else {
+                value.append(character)
+            }
+            text.formIndex(after: &index)
+        }
+
+        return nil
+    }
+
+    static func parseJSONInt(in text: Substring, index: inout String.Index) -> Int? {
+        var sign = 1
+        if index < text.endIndex, text[index] == "-" {
+            sign = -1
+            text.formIndex(after: &index)
+        }
+
+        var value = 0
+        var sawDigit = false
+        while index < text.endIndex, let digit = text[index].wholeNumberValue {
+            sawDigit = true
+            value = (value * 10) + digit
+            text.formIndex(after: &index)
+        }
+        return sawDigit ? value * sign : nil
+    }
+
+    static func skipJSONWhitespace(in text: Substring, index: inout String.Index) {
+        while index < text.endIndex, text[index].isWhitespace {
+            text.formIndex(after: &index)
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/Vendored/CostUsage/CostUsageScanner+Timestamp.swift b/Sources/CodexBarCore/Vendored/CostUsage/CostUsageScanner+Timestamp.swift
index e7cda6310e..b8bf32153c 100644
--- a/Sources/CodexBarCore/Vendored/CostUsage/CostUsageScanner+Timestamp.swift
+++ b/Sources/CodexBarCore/Vendored/CostUsage/CostUsageScanner+Timestamp.swift
@@ -26,6 +26,10 @@ private enum CostUsageTimestampParser {
 }
 
 extension CostUsageScanner {
+    static func dateFromTimestamp(_ text: String) -> Date? {
+        CostUsageTimestampParser.parseISO(text)
+    }
+
     static func dayKeyFromTimestamp(_ text: String) -> String? {
         let bytes = Array(text.utf8)
         guard bytes.count >= 20 else { return nil }
diff --git a/Sources/CodexBarCore/Vendored/CostUsage/CostUsageScanner.swift b/Sources/CodexBarCore/Vendored/CostUsage/CostUsageScanner.swift
index a5ef942b51..aff14a6d9a 100644
--- a/Sources/CodexBarCore/Vendored/CostUsage/CostUsageScanner.swift
+++ b/Sources/CodexBarCore/Vendored/CostUsage/CostUsageScanner.swift
@@ -1,16 +1,29 @@
+#if canImport(CryptoKit)
+import CryptoKit
+#else
+import Crypto
+#endif
 import Foundation
 
+// swiftlint:disable type_body_length file_length
 enum CostUsageScanner {
-    enum ClaudeLogProviderFilter: Sendable {
+    typealias CancellationCheck = () throws -> Void
+
+    static let log = CodexBarLog.logger(LogCategories.tokenCost)
+    static let codexActiveSessionLookbackDays = 30
+    static let costScale = 1_000_000_000.0
+
+    enum ClaudeLogProviderFilter {
         case all
         case vertexAIOnly
         case excludeVertexAI
     }
 
-    struct Options: Sendable {
+    struct Options {
         var codexSessionsRoot: URL?
         var claudeProjectsRoots: [URL]?
         var cacheRoot: URL?
+        var codexTraceDatabaseURL: URL?
         var refreshMinIntervalSeconds: TimeInterval = 60
         var claudeLogProviderFilter: ClaudeLogProviderFilter = .all
         /// Force a full rescan, ignoring per-file cache and incremental offsets.
@@ -20,65 +33,433 @@ enum CostUsageScanner {
             codexSessionsRoot: URL? = nil,
             claudeProjectsRoots: [URL]? = nil,
             cacheRoot: URL? = nil,
+            codexTraceDatabaseURL: URL? = nil,
             claudeLogProviderFilter: ClaudeLogProviderFilter = .all,
             forceRescan: Bool = false)
         {
             self.codexSessionsRoot = codexSessionsRoot
             self.claudeProjectsRoots = claudeProjectsRoots
             self.cacheRoot = cacheRoot
+            self.codexTraceDatabaseURL = codexTraceDatabaseURL
             self.claudeLogProviderFilter = claudeLogProviderFilter
             self.forceRescan = forceRescan
         }
     }
 
-    struct CodexParseResult: Sendable {
+    struct CodexParseResult {
         let days: [String: [String: [Int]]]
-        let parsedBytes: Int64
+        var parsedBytes: Int64
         let lastModel: String?
         let lastTotals: CostUsageCodexTotals?
+        let lastCountedTotals: CostUsageCodexTotals?
+        let lastRawTotalsBaseline: CostUsageCodexTotals?
+        let hasDivergentTotals: Bool
+        let lastCodexTurnID: String?
         let sessionId: String?
+        let forkedFromId: String?
+        let rows: [CodexUsageRow]
+    }
+
+    struct CodexUsageRow: Codable, Equatable {
+        let day: String
+        let model: String
+        let turnID: String?
+        let input: Int
+        let cached: Int
+        let output: Int
     }
 
-    private struct CodexScanState {
+    struct CodexScanState {
         var seenSessionIds: Set<String> = []
         var seenFileIds: Set<String> = []
     }
 
-    struct ClaudeParseResult: Sendable {
+    private struct CodexTimestampedTotals {
+        let timestamp: String
+        let date: Date?
+        let totals: CostUsageCodexTotals
+    }
+
+    enum CodexForkBaseline {
+        case resolved(CostUsageCodexTotals?)
+        case unresolved
+    }
+
+    private static func codexTotalsEqual(_ lhs: CostUsageCodexTotals?, _ rhs: CostUsageCodexTotals?) -> Bool {
+        lhs?.input == rhs?.input && lhs?.cached == rhs?.cached && lhs?.output == rhs?.output
+    }
+
+    private static func codexTotalsAtLeast(_ lhs: CostUsageCodexTotals, _ rhs: CostUsageCodexTotals) -> Bool {
+        lhs.input >= rhs.input && lhs.cached >= rhs.cached && lhs.output >= rhs.output
+    }
+
+    private static func codexTotalsAtMost(_ lhs: CostUsageCodexTotals, _ rhs: CostUsageCodexTotals) -> Bool {
+        lhs.input <= rhs.input && lhs.cached <= rhs.cached && lhs.output <= rhs.output
+    }
+
+    private static func codexShouldPreferTotalDelta(
+        rawBaseline: CostUsageCodexTotals?,
+        currentTotal: CostUsageCodexTotals,
+        totalDelta: CostUsageCodexTotals,
+        lastDelta: CostUsageCodexTotals,
+        sawDivergentTotals: Bool) -> Bool
+    {
+        guard !sawDivergentTotals, let rawBaseline else { return false }
+        return Self.codexTotalsAtLeast(currentTotal, rawBaseline)
+            && Self.codexTotalsAtMost(totalDelta, lastDelta)
+    }
+
+    private static func codexAddTotals(
+        _ lhs: CostUsageCodexTotals,
+        _ rhs: CostUsageCodexTotals) -> CostUsageCodexTotals
+    {
+        CostUsageCodexTotals(
+            input: lhs.input + rhs.input,
+            cached: lhs.cached + rhs.cached,
+            output: lhs.output + rhs.output)
+    }
+
+    private static func codexMinTotals(
+        _ lhs: CostUsageCodexTotals,
+        _ rhs: CostUsageCodexTotals) -> CostUsageCodexTotals
+    {
+        CostUsageCodexTotals(
+            input: min(lhs.input, rhs.input),
+            cached: min(lhs.cached, rhs.cached),
+            output: min(lhs.output, rhs.output))
+    }
+
+    private static func codexTotalDelta(
+        from baseline: CostUsageCodexTotals?,
+        to current: CostUsageCodexTotals) -> CostUsageCodexTotals
+    {
+        let baseline = baseline ?? .init(input: 0, cached: 0, output: 0)
+        return CostUsageCodexTotals(
+            input: max(0, current.input - baseline.input),
+            cached: max(0, current.cached - baseline.cached),
+            output: max(0, current.output - baseline.output))
+    }
+
+    private static func codexDivergentTotalDelta(
+        rawBaseline: CostUsageCodexTotals?,
+        countedBaseline: CostUsageCodexTotals?,
+        current: CostUsageCodexTotals) -> CostUsageCodexTotals
+    {
+        let rawBaseline = rawBaseline ?? .init(input: 0, cached: 0, output: 0)
+        let countedBaseline = countedBaseline ?? .init(input: 0, cached: 0, output: 0)
+
+        func delta(raw: Int, counted: Int, current: Int) -> Int {
+            if current >= raw {
+                return max(0, current - raw)
+            }
+            return max(0, current - counted)
+        }
+
+        return CostUsageCodexTotals(
+            input: delta(raw: rawBaseline.input, counted: countedBaseline.input, current: current.input),
+            cached: delta(raw: rawBaseline.cached, counted: countedBaseline.cached, current: current.cached),
+            output: delta(raw: rawBaseline.output, counted: countedBaseline.output, current: current.output))
+    }
+
+    struct CodexScanResources {
+        let fileIndex: CodexSessionFileIndex
+        let inheritedResolver: CodexInheritedTotalsResolver
+        let modelsDevCatalog: ModelsDevCatalog?
+        let modelsDevCacheRoot: URL?
+        let priorityTurns: [String: CodexPriorityTurnMetadata]
+    }
+
+    struct CodexFileScanContext {
+        let range: CostUsageDayRange
+        let forceFullScan: Bool
+        let dropDeferredCodexRows: Bool
+        let requiresTurnIDCache: Bool
+        let changedPriorityTurnIDs: Set<String>
+        let resources: CodexScanResources
+        let checkCancellation: CancellationCheck?
+    }
+
+    struct CodexRefreshPlan {
+        let refreshMs: Int64
+        let roots: [URL]
+        let rootsFingerprint: [String: Int64]
+        let rootsChanged: Bool
+        let windowExpanded: Bool
+        let needsCostCacheMigration: Bool
+        let modelsDevCatalog: ModelsDevCatalog?
+        let codexPricingKey: String
+        let codexPriorityMetadataKey: String
+        let hasPriorityMetadata: Bool
+        let priorityTurns: [String: CodexPriorityTurnMetadata]
+        let priorityTurnKeys: [String: String]
+        let priorityTurnIDsByDay: [String: [String]]
+        let pricingChanged: Bool
+        let priorityMetadataChanged: Bool
+        let priorityTurnsChanged: Bool
+        let needsTurnIDCacheMigration: Bool
+        let changedPriorityTurnIDs: Set<String>
+        let shouldRefresh: Bool
+    }
+
+    final class CodexSessionFileIndex {
+        private let files: [URL]
+        private let filePaths: Set<String>
+        private let roots: [URL]
+        private let checkCancellation: CancellationCheck?
+        private var nextUnindexedFile = 0
+        private var didIndexRoots = false
+        private var fileURLBySessionId: [String: URL] = [:]
+        private var missingSessionIds: Set<String> = []
+
+        init(
+            files: [URL],
+            roots: [URL],
+            cachedSessionFiles: [String: URL] = [:],
+            checkCancellation: CancellationCheck? = nil)
+        {
+            self.files = files
+            self.filePaths = Set(files.map(\.path))
+            self.roots = roots
+            self.fileURLBySessionId = cachedSessionFiles
+            self.checkCancellation = checkCancellation
+        }
+
+        func remember(fileURL: URL, sessionId: String?) {
+            guard let sessionId, !sessionId.isEmpty else { return }
+            self.fileURLBySessionId[sessionId] = fileURL
+        }
+
+        func fileURL(for sessionId: String) throws -> URL? {
+            if let cached = self.fileURLBySessionId[sessionId] {
+                return cached
+            }
+            if self.missingSessionIds.contains(sessionId) {
+                return nil
+            }
+
+            while self.nextUnindexedFile < self.files.count {
+                try self.checkCancellation?()
+                let fileURL = self.files[self.nextUnindexedFile]
+                self.nextUnindexedFile += 1
+                guard let indexedSessionId = try CostUsageScanner.parseCodexSessionIdentifier(
+                    fileURL: fileURL,
+                    checkCancellation: self.checkCancellation)
+                else {
+                    continue
+                }
+                self.fileURLBySessionId[indexedSessionId] = fileURL
+                if indexedSessionId == sessionId {
+                    return fileURL
+                }
+            }
+
+            if !self.didIndexRoots {
+                try self.indexRoots()
+                if let indexed = self.fileURLBySessionId[sessionId] {
+                    return indexed
+                }
+            }
+
+            self.missingSessionIds.insert(sessionId)
+            return nil
+        }
+
+        private func indexRoots() throws {
+            self.didIndexRoots = true
+            guard !self.roots.isEmpty else { return }
+            for root in self.roots {
+                try self.checkCancellation?()
+                guard let enumerator = FileManager.default.enumerator(
+                    at: root,
+                    includingPropertiesForKeys: [.isRegularFileKey],
+                    options: [.skipsHiddenFiles, .skipsPackageDescendants])
+                else { continue }
+
+                while let fileURL = enumerator.nextObject() as? URL {
+                    try self.checkCancellation?()
+                    guard fileURL.pathExtension.lowercased() == "jsonl" else { continue }
+                    guard !self.filePaths.contains(fileURL.path) else { continue }
+                    guard let indexedSessionId = try CostUsageScanner.parseCodexSessionIdentifier(
+                        fileURL: fileURL,
+                        checkCancellation: self.checkCancellation)
+                    else {
+                        continue
+                    }
+                    self.fileURLBySessionId[indexedSessionId] = fileURL
+                }
+            }
+        }
+    }
+
+    final class CodexInheritedTotalsResolver {
+        private let fileIndex: CodexSessionFileIndex
+        private let checkCancellation: CancellationCheck?
+        private var snapshotsBySessionId: [String: [CodexTimestampedTotals]] = [:]
+
+        init(fileIndex: CodexSessionFileIndex, checkCancellation: CancellationCheck?) {
+            self.fileIndex = fileIndex
+            self.checkCancellation = checkCancellation
+        }
+
+        func inheritedTotals(for sessionId: String, atOrBefore cutoffTimestamp: String) throws -> CodexForkBaseline {
+            guard !cutoffTimestamp.isEmpty else {
+                CostUsageScanner.log.warning(
+                    "Codex cost usage fork timestamp missing; treating parent baseline as unresolved",
+                    metadata: ["sessionId": sessionId])
+                return .unresolved
+            }
+            let cutoffDate = CostUsageScanner.dateFromTimestamp(cutoffTimestamp)
+            if cutoffDate == nil {
+                CostUsageScanner.log.warning(
+                    "Codex cost usage could not parse fork timestamp; falling back to lexical comparison",
+                    metadata: ["sessionId": sessionId, "timestamp": cutoffTimestamp])
+            }
+            guard let snapshots = try self.snapshots(for: sessionId) else { return .unresolved }
+            var inherited: CostUsageCodexTotals?
+            for snapshot in snapshots {
+                let isAtOrBefore: Bool = if let snapshotDate = snapshot.date, let cutoffDate {
+                    snapshotDate <= cutoffDate
+                } else {
+                    snapshot.timestamp <= cutoffTimestamp
+                }
+                if isAtOrBefore {
+                    inherited = snapshot.totals
+                }
+            }
+            return .resolved(inherited)
+        }
+
+        private func snapshots(for sessionId: String) throws -> [CodexTimestampedTotals]? {
+            if let cached = self.snapshotsBySessionId[sessionId] {
+                return cached
+            }
+            try self.checkCancellation?()
+            guard let fileURL = try self.fileIndex.fileURL(for: sessionId) else {
+                CostUsageScanner.log.warning(
+                    "Codex cost usage parent session file not found",
+                    metadata: ["sessionId": sessionId])
+                return nil
+            }
+            let parsed = try CostUsageScanner.parseCodexTokenSnapshots(
+                fileURL: fileURL,
+                checkCancellation: self.checkCancellation)
+            guard let parsedSessionId = parsed.sessionId else {
+                CostUsageScanner.log.warning(
+                    "Codex cost usage parent session missing session metadata",
+                    metadata: ["sessionId": sessionId, "path": fileURL.path])
+                return nil
+            }
+            if parsedSessionId != sessionId {
+                CostUsageScanner.log.warning(
+                    "Codex cost usage parent session resolved to mismatched session id",
+                    metadata: [
+                        "requestedSessionId": sessionId,
+                        "resolvedSessionId": parsedSessionId,
+                        "path": fileURL.path,
+                    ])
+                return nil
+            }
+            self.snapshotsBySessionId[sessionId] = parsed.snapshots
+            return parsed.snapshots
+        }
+    }
+
+    struct ClaudeParseResult {
         let days: [String: [String: [Int]]]
+        let rows: [ClaudeUsageRow]
         let parsedBytes: Int64
     }
 
+    enum ClaudePathRole: String, Codable {
+        case parent
+        case subagent
+    }
+
+    struct ClaudeUsageRow: Codable {
+        let dayKey: String
+        let model: String
+        let sessionId: String?
+        let messageId: String?
+        let requestId: String?
+        let timestampUnixMs: Int64?
+        let isSidechain: Bool
+        let pathRole: ClaudePathRole
+        let input: Int
+        let cacheRead: Int
+        let cacheCreate: Int
+        let cacheCreate1h: Int?
+        let output: Int
+        let costNanos: Int
+        let costPriced: Bool?
+    }
+
     static func loadDailyReport(
         provider: UsageProvider,
         since: Date,
         until: Date,
         now: Date = Date(),
         options: Options = Options()) -> CostUsageDailyReport
+    {
+        (
+            try? self.loadDailyReportCancellable(
+                provider: provider,
+                since: since,
+                until: until,
+                now: now,
+                options: options,
+                checkCancellation: nil)) ?? CostUsageDailyReport(data: [], summary: nil)
+    }
+
+    static func loadDailyReportCancellable(
+        provider: UsageProvider,
+        since: Date,
+        until: Date,
+        now: Date = Date(),
+        options: Options = Options(),
+        checkCancellation: CancellationCheck?) throws -> CostUsageDailyReport
     {
         let range = CostUsageDayRange(since: since, until: until)
         let emptyReport = CostUsageDailyReport(data: [], summary: nil)
+        try checkCancellation?()
 
         switch provider {
         case .codex:
-            return self.loadCodexDaily(range: range, now: now, options: options)
+            return try self.loadCodexDaily(
+                range: range,
+                now: now,
+                options: options,
+                checkCancellation: checkCancellation)
         case .claude:
-            return self.loadClaudeDaily(provider: .claude, range: range, now: now, options: options)
+            return try self.loadClaudeDaily(
+                provider: .claude,
+                range: range,
+                now: now,
+                options: options,
+                checkCancellation: checkCancellation)
         case .vertexai:
             var filtered = options
             if filtered.claudeLogProviderFilter == .all {
                 filtered.claudeLogProviderFilter = .vertexAIOnly
             }
-            return self.loadClaudeDaily(provider: .vertexai, range: range, now: now, options: filtered)
-        case .zai, .gemini, .antigravity, .cursor, .opencode, .factory, .copilot, .minimax, .kilo, .kiro, .kimi,
-             .kimik2, .augment, .jetbrains, .amp, .ollama, .synthetic, .openrouter, .warp:
+            return try self.loadClaudeDaily(
+                provider: .vertexai,
+                range: range,
+                now: now,
+                options: filtered,
+                checkCancellation: checkCancellation)
+        case .openai, .azureopenai, .zai, .gemini, .antigravity, .cursor, .opencode, .opencodego, .alibaba,
+             .alibabatokenplan, .factory,
+             .copilot, .devin, .minimax, .manus, .kilo, .kiro, .kimi, .kimik2, .moonshot, .augment, .jetbrains, .amp,
+             .ollama, .t3chat, .synthetic, .openrouter, .elevenlabs, .warp, .perplexity, .mimo, .doubao, .abacus,
+             .mistral, .deepseek, .codebuff, .crof, .windsurf, .zed, .venice, .commandcode, .stepfun, .bedrock, .grok,
+             .groq, .llmproxy, .litellm, .deepgram, .poe, .chutes:
             return emptyReport
         }
     }
 
     // MARK: - Day keys
 
-    struct CostUsageDayRange: Sendable {
+    struct CostUsageDayRange {
         let sinceKey: String
         let untilKey: String
         let scanSinceKey: String
@@ -135,21 +516,327 @@ enum CostUsageScanner {
             .appendingPathComponent("archived_sessions", isDirectory: true)
     }
 
-    private static func listCodexSessionFiles(root: URL, scanSinceKey: String, scanUntilKey: String) -> [URL] {
+    private static func listCodexSessionFiles(
+        root: URL,
+        scanSinceKey: String,
+        scanUntilKey: String,
+        includeRecursive: Bool) -> [URL]
+    {
         let partitioned = self.listCodexSessionFilesByDatePartition(
             root: root,
             scanSinceKey: scanSinceKey,
             scanUntilKey: scanUntilKey)
         let flat = self.listCodexSessionFilesFlat(root: root, scanSinceKey: scanSinceKey, scanUntilKey: scanUntilKey)
+        let recursive = includeRecursive ? self.listCodexLegacySessionFilesRecursive(root: root) : []
         var seen: Set<String> = []
         var out: [URL] = []
-        for item in partitioned + flat where !seen.contains(item.path) {
+        for item in partitioned + flat + recursive where !seen.contains(item.path) {
             seen.insert(item.path)
             out.append(item)
         }
         return out
     }
 
+    private static func cachedCodexSessionFiles(
+        cache: CostUsageCache,
+        range: CostUsageDayRange,
+        roots: [URL],
+        excludingPaths: Set<String>) -> [URL]
+    {
+        cache.files.compactMap { path, usage in
+            guard !excludingPaths.contains(path) else { return nil }
+            let hasRelevantDay = usage.days.keys.contains {
+                CostUsageDayRange.isInRange(dayKey: $0, since: range.scanSinceKey, until: range.scanUntilKey)
+            }
+            guard hasRelevantDay else { return nil }
+            guard FileManager.default.fileExists(atPath: path) else { return nil }
+            let fileURL = URL(fileURLWithPath: path)
+            guard Self.isWithinCodexRoots(fileURL: fileURL, roots: roots) else { return nil }
+            return fileURL
+        }
+    }
+
+    private static func cachedCodexSessionIndex(
+        cache: CostUsageCache,
+        roots: [URL],
+        knownExistingPaths: Set<String>) -> [String: URL]
+    {
+        var out: [String: URL] = [:]
+        for (path, usage) in cache.files {
+            guard let sessionId = usage.sessionId, !sessionId.isEmpty else { continue }
+            if knownExistingPaths.contains(path) {
+                out[sessionId] = URL(fileURLWithPath: path)
+                continue
+            }
+            guard FileManager.default.fileExists(atPath: path) else { continue }
+            let fileURL = URL(fileURLWithPath: path)
+            guard Self.isWithinCodexRoots(fileURL: fileURL, roots: roots) else { continue }
+            out[sessionId] = fileURL
+        }
+        return out
+    }
+
+    private static func codexRootsFingerprint(_ roots: [URL]) -> [String: Int64] {
+        var out: [String: Int64] = [:]
+        for root in roots {
+            out[root.standardizedFileURL.path] = 0
+        }
+        return out
+    }
+
+    static func codexRootsFingerprint(options: Options) -> [String: Int64] {
+        self.codexRootsFingerprint(self.codexSessionsRoots(options: options))
+    }
+
+    private static func codexPricingKey(modelsDevArtifact: ModelsDevCacheArtifact?) -> String {
+        guard let modelsDevArtifact else {
+            let fingerprint = CostUsagePricing.codexBuiltInPricingFingerprint()
+            return "builtin-\(Self.sha256Hex(Data(fingerprint.utf8)))"
+        }
+        let fingerprint = self.modelsDevPricingFingerprint(modelsDevArtifact.catalog)
+        return "models-dev-v\(modelsDevArtifact.version)-\(Self.sha256Hex(Data(fingerprint.utf8)))"
+    }
+
+    private static func modelsDevPricingFingerprint(_ catalog: ModelsDevCatalog) -> String {
+        var parts: [String] = []
+        for providerID in catalog.providers.keys.sorted() {
+            guard let provider = catalog.providers[providerID] else { continue }
+            parts.append("provider=\(providerID)|\(provider.id ?? "")")
+            for modelKey in provider.models.keys.sorted() {
+                guard let model = provider.models[modelKey] else { continue }
+                let cost = model.cost
+                let contextOver200K = cost?.contextOver200K
+                parts.append([
+                    "model=\(modelKey)",
+                    model.id,
+                    Self.optionalDoubleFingerprint(cost?.input),
+                    Self.optionalDoubleFingerprint(cost?.output),
+                    Self.optionalDoubleFingerprint(cost?.cacheRead),
+                    Self.optionalDoubleFingerprint(cost?.cacheWrite),
+                    Self.optionalDoubleFingerprint(contextOver200K?.input),
+                    Self.optionalDoubleFingerprint(contextOver200K?.output),
+                    Self.optionalDoubleFingerprint(contextOver200K?.cacheRead),
+                    Self.optionalDoubleFingerprint(contextOver200K?.cacheWrite),
+                    model.limit?.context.map(String.init) ?? "nil",
+                ].joined(separator: "|"))
+            }
+        }
+        return parts.joined(separator: "\n")
+    }
+
+    private static func optionalDoubleFingerprint(_ value: Double?) -> String {
+        guard let value else { return "nil" }
+        return String(format: "%.17g", value)
+    }
+
+    private static func codexPriorityMetadataKey(databaseURL: URL?) -> String {
+        let url = databaseURL ?? self.defaultCodexPriorityDatabaseURL()
+        let path = url.standardizedFileURL.path
+        return FileManager.default.fileExists(atPath: path) ? "sqlite:\(path)" : "missing:\(path)"
+    }
+
+    private static func codexPriorityMetadataChanged(old: String?, new: String) -> Bool {
+        guard let old, old != new else { return false }
+        return new.hasPrefix("sqlite:")
+    }
+
+    private static func codexPriorityTurnKeys(
+        _ priorityTurns: [String: CodexPriorityTurnMetadata]) -> [String: String]
+    {
+        var partsByDay: [String: [String]] = [:]
+        for (turnID, turn) in priorityTurns {
+            guard let dayKey = self.codexPriorityDayKey(turn) else { continue }
+            partsByDay[dayKey, default: []].append([
+                turnID,
+                turn.model ?? "",
+                turn.timestamp ?? "",
+                turn.threadID ?? "",
+            ].joined(separator: "|"))
+        }
+        var out: [String: String] = [:]
+        for (dayKey, parts) in partsByDay {
+            out[dayKey] = self.sha256Hex(Data(parts.sorted().joined(separator: "\n").utf8))
+        }
+        return out
+    }
+
+    private static func codexPriorityTurnIDsByDay(
+        _ priorityTurns: [String: CodexPriorityTurnMetadata]) -> [String: [String]]
+    {
+        var out: [String: Set<String>] = [:]
+        for (turnID, turn) in priorityTurns {
+            guard let dayKey = self.codexPriorityDayKey(turn) else { continue }
+            out[dayKey, default: []].insert(turnID)
+        }
+        return out.mapValues { $0.sorted() }
+    }
+
+    private static func codexPriorityDayKey(_ turn: CodexPriorityTurnMetadata) -> String? {
+        guard let timestamp = turn.timestamp else { return nil }
+        let dayKeyFromEpoch = Int64(timestamp).map {
+            CostUsageDayRange.dayKey(from: Date(timeIntervalSince1970: TimeInterval($0)))
+        }
+        return dayKeyFromEpoch ?? self.dayKeyFromTimestamp(timestamp) ?? self.dayKeyFromParsedISO(timestamp)
+    }
+
+    private static func codexPriorityTurnKeysChanged(
+        old: [String: String]?,
+        new: [String: String],
+        range: CostUsageDayRange) -> Bool
+    {
+        for dayKey in self.dayKeys(sinceKey: range.scanSinceKey, untilKey: range.scanUntilKey)
+            where old?[dayKey] != new[dayKey]
+        {
+            return true
+        }
+        return false
+    }
+
+    private static func changedPriorityTurnIDs(
+        old: [String: [String]]?,
+        new: [String: [String]],
+        oldKeys: [String: String]?,
+        newKeys: [String: String],
+        range: CostUsageDayRange) -> Set<String>
+    {
+        var out = Set<String>()
+        for dayKey in self.dayKeys(sinceKey: range.scanSinceKey, untilKey: range.scanUntilKey) {
+            let oldIDs = Set(old?[dayKey] ?? [])
+            let newIDs = Set(new[dayKey] ?? [])
+            if oldIDs != newIDs || oldKeys?[dayKey] != newKeys[dayKey] {
+                out.formUnion(oldIDs)
+                out.formUnion(newIDs)
+            }
+        }
+        return out
+    }
+
+    private static func mergePriorityTurnKeys(
+        existing: [String: String]?,
+        new: [String: String],
+        range: CostUsageDayRange,
+        retainedSinceKey: String,
+        retainedUntilKey: String) -> [String: String]?
+    {
+        var out = existing ?? [:]
+        for dayKey in self.dayKeys(sinceKey: range.scanSinceKey, untilKey: range.scanUntilKey) {
+            out[dayKey] = new[dayKey]
+        }
+        out = out.filter { key, _ in
+            CostUsageDayRange.isInRange(dayKey: key, since: retainedSinceKey, until: retainedUntilKey)
+        }
+        return out.isEmpty ? nil : out
+    }
+
+    private static func mergePriorityTurnIDsByDay(
+        existing: [String: [String]]?,
+        new: [String: [String]],
+        range: CostUsageDayRange,
+        retainedSinceKey: String,
+        retainedUntilKey: String) -> [String: [String]]?
+    {
+        var out = existing ?? [:]
+        for dayKey in self.dayKeys(sinceKey: range.scanSinceKey, untilKey: range.scanUntilKey) {
+            out[dayKey] = new[dayKey] ?? []
+        }
+        out = out.filter { key, _ in
+            CostUsageDayRange.isInRange(dayKey: key, since: retainedSinceKey, until: retainedUntilKey)
+        }
+        return out.isEmpty ? nil : out
+    }
+
+    private static func sha256Hex(_ data: Data) -> String {
+        SHA256.hash(data: data).map { String(format: "%02x", $0) }.joined()
+    }
+
+    private static func listCodexRecentlyModifiedFiles(
+        root: URL,
+        scanSinceKey: String,
+        scanUntilKey: String,
+        modifiedSince: Date) -> [URL]
+    {
+        let lookbackSinceKey = self.dayKey(scanSinceKey, addingDays: -self.codexActiveSessionLookbackDays)
+            ?? scanSinceKey
+        let partitioned = self.listCodexSessionFilesByDatePartition(
+            root: root,
+            scanSinceKey: lookbackSinceKey,
+            scanUntilKey: scanUntilKey)
+        let partitionedModified = self.filterRecentlyModified(files: partitioned, modifiedSince: modifiedSince)
+
+        let legacyRecursive = self.listCodexRecentlyModifiedFilesRecursive(root: root, modifiedSince: modifiedSince)
+        var seen = Set(partitionedModified.map(\.path))
+        var out = partitionedModified
+        for fileURL in legacyRecursive where !seen.contains(fileURL.path) {
+            seen.insert(fileURL.path)
+            out.append(fileURL)
+        }
+        return out
+    }
+
+    private static func filterRecentlyModified(files: [URL], modifiedSince: Date) -> [URL] {
+        files.filter { fileURL in
+            let values = try? fileURL.resourceValues(forKeys: [.isRegularFileKey, .contentModificationDateKey])
+            guard values?.isRegularFile == true else { return false }
+            guard let modifiedAt = values?.contentModificationDate else { return false }
+            return modifiedAt >= modifiedSince
+        }
+    }
+
+    private static func isDatePartitionComponent(_ value: String, length: Int) -> Bool {
+        value.count == length && value.allSatisfy(\.isNumber)
+    }
+
+    private static func dayKey(_ dayKey: String, addingDays days: Int) -> String? {
+        guard let date = self.parseDayKey(dayKey) else { return nil }
+        guard let shifted = Calendar.current.date(byAdding: .day, value: days, to: date) else { return nil }
+        return CostUsageDayRange.dayKey(from: shifted)
+    }
+
+    private static func dayKeys(sinceKey: String, untilKey: String) -> [String] {
+        guard let since = self.parseDayKey(sinceKey),
+              self.parseDayKey(untilKey) != nil
+        else { return sinceKey <= untilKey ? [sinceKey] : [] }
+
+        var out: [String] = []
+        var cursor = since
+        let calendar = Calendar.current
+        while CostUsageDayRange.dayKey(from: cursor) <= untilKey {
+            out.append(CostUsageDayRange.dayKey(from: cursor))
+            guard let next = calendar.date(byAdding: .day, value: 1, to: cursor) else { break }
+            if next <= cursor { break }
+            cursor = next
+        }
+        return out
+    }
+
+    private static func listCodexRecentlyModifiedFilesRecursive(root: URL, modifiedSince: Date) -> [URL] {
+        guard let enumerator = FileManager.default.enumerator(
+            at: root,
+            includingPropertiesForKeys: [.isRegularFileKey, .contentModificationDateKey],
+            options: [.skipsHiddenFiles, .skipsPackageDescendants])
+        else { return [] }
+
+        var out: [URL] = []
+        while let fileURL = enumerator.nextObject() as? URL {
+            guard fileURL.pathExtension.lowercased() == "jsonl" else { continue }
+            let values = try? fileURL.resourceValues(forKeys: [.isRegularFileKey, .contentModificationDateKey])
+            guard values?.isRegularFile == true else { continue }
+            guard let modifiedAt = values?.contentModificationDate, modifiedAt >= modifiedSince else { continue }
+            out.append(fileURL)
+        }
+        return out
+    }
+
+    private static func isWithinCodexRoots(fileURL: URL, roots: [URL]) -> Bool {
+        let filePath = fileURL.standardizedFileURL.path
+        return roots.contains { root in
+            let rootPath = root.standardizedFileURL.path
+            if filePath == rootPath { return true }
+            let prefix = rootPath.hasSuffix("/") ? rootPath : rootPath + "/"
+            return filePath.hasPrefix(prefix)
+        }
+    }
+
     private static func listCodexSessionFilesByDatePartition(
         root: URL,
         scanSinceKey: String,
@@ -206,6 +893,36 @@ enum CostUsageScanner {
         return out
     }
 
+    private static func listCodexLegacySessionFilesRecursive(root: URL) -> [URL] {
+        guard FileManager.default.fileExists(atPath: root.path) else { return [] }
+        let rootPath = root.standardizedFileURL.path
+        guard let enumerator = FileManager.default.enumerator(
+            at: root,
+            includingPropertiesForKeys: [.isDirectoryKey, .isRegularFileKey],
+            options: [.skipsHiddenFiles, .skipsPackageDescendants])
+        else { return [] }
+
+        var out: [URL] = []
+        while let item = enumerator.nextObject() as? URL {
+            if Self.isCodexDatePartitionAncestor(item, rootPath: rootPath) {
+                enumerator.skipDescendants()
+                continue
+            }
+            guard item.pathExtension.lowercased() == "jsonl" else { continue }
+            out.append(item)
+        }
+        return out
+    }
+
+    private static func isCodexDatePartitionAncestor(_ url: URL, rootPath: String) -> Bool {
+        let path = url.standardizedFileURL.path
+        guard path.hasPrefix(rootPath + "/") else { return false }
+        let relative = String(path.dropFirst(rootPath.count + 1))
+        let parts = relative.split(separator: "/")
+        guard parts.count == 1 else { return false }
+        return Self.isDatePartitionComponent(String(parts[0]), length: 4)
+    }
+
     private static let codexFilenameDateRegex = try? NSRegularExpression(pattern: "(\\d{4}-\\d{2}-\\d{2})")
 
     private static func dayKeyFromFilename(_ filename: String) -> String? {
@@ -216,520 +933,1483 @@ enum CostUsageScanner {
         return String(filename[matchRange])
     }
 
-    private static func fileIdentityString(fileURL: URL) -> String? {
-        guard let values = try? fileURL.resourceValues(forKeys: [.fileResourceIdentifierKey]) else { return nil }
-        guard let identifier = values.fileResourceIdentifier else { return nil }
-        if let data = identifier as? Data {
-            return data.base64EncodedString()
-        }
-        return String(describing: identifier)
+    private struct CodexSessionMetadata {
+        let sessionId: String?
+        let forkedFromId: String?
+        let forkTimestamp: String?
     }
 
-    static func parseCodexFile(
-        fileURL: URL,
-        range: CostUsageDayRange,
-        startOffset: Int64 = 0,
-        initialModel: String? = nil,
-        initialTotals: CostUsageCodexTotals? = nil) -> CodexParseResult
-    {
-        var currentModel = initialModel
-        var previousTotals = initialTotals
-        var sessionId: String?
+    private struct CodexTokenCountRecord {
+        let timestamp: String
+        let model: String?
+        let turnID: String?
+        let last: CostUsageCodexTotals?
+        let total: CostUsageCodexTotals?
+    }
 
-        var days: [String: [String: [Int]]] = [:]
+    private enum CodexFastLine {
+        case sessionMeta(CodexSessionMetadata)
+        case turnContext(model: String?)
+        case taskStarted(turnID: String?)
+        case tokenCount(CodexTokenCountRecord)
+    }
 
-        func add(dayKey: String, model: String, input: Int, cached: Int, output: Int) {
-            guard CostUsageDayRange.isInRange(dayKey: dayKey, since: range.scanSinceKey, until: range.scanUntilKey)
-            else { return }
-            let normModel = CostUsagePricing.normalizeCodexModel(model)
+    private static let codexJSONFieldCachedInputTokens = Array("cached_input_tokens".utf8)
+    private static let codexJSONFieldCacheReadInputTokens = Array("cache_read_input_tokens".utf8)
+    private static let codexJSONFieldForkedFromId = Array("forked_from_id".utf8)
+    private static let codexJSONFieldForkedFromIdCamel = Array("forkedFromId".utf8)
+    private static let codexJSONFieldId = Array("id".utf8)
+    private static let codexJSONFieldInfo = Array("info".utf8)
+    private static let codexJSONFieldInputTokens = Array("input_tokens".utf8)
+    private static let codexJSONFieldLastTokenUsage = Array("last_token_usage".utf8)
+    private static let codexJSONFieldModel = Array("model".utf8)
+    private static let codexJSONFieldModelName = Array("model_name".utf8)
+    private static let codexJSONFieldOutputTokens = Array("output_tokens".utf8)
+    private static let codexJSONFieldParentSessionId = Array("parent_session_id".utf8)
+    private static let codexJSONFieldParentSessionIdCamel = Array("parentSessionId".utf8)
+    private static let codexJSONFieldPayload = Array("payload".utf8)
+    private static let codexJSONFieldSessionId = Array("session_id".utf8)
+    private static let codexJSONFieldSessionIdCamel = Array("sessionId".utf8)
+    private static let codexJSONFieldTimestamp = Array("timestamp".utf8)
+    private static let codexJSONFieldTotalTokenUsage = Array("total_token_usage".utf8)
+    private static let codexJSONFieldTurnId = Array("turn_id".utf8)
+    private static let codexJSONFieldTurnIdCamel = Array("turnId".utf8)
+    private static let codexJSONFieldType = Array("type".utf8)
+
+    private static func codexForkParentId(from payload: [String: Any]?) -> String? {
+        guard let payload else { return nil }
+        for key in ["forked_from_id", "forkedFromId", "parent_session_id", "parentSessionId"] {
+            guard let value = payload[key] as? String else { continue }
+            let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
+            if !trimmed.isEmpty {
+                return trimmed
+            }
+        }
+        return nil
+    }
 
-            var dayModels = days[dayKey] ?? [:]
-            var packed = dayModels[normModel] ?? [0, 0, 0]
-            packed[0] = (packed[safe: 0] ?? 0) + input
-            packed[1] = (packed[safe: 1] ?? 0) + cached
-            packed[2] = (packed[safe: 2] ?? 0) + output
-            dayModels[normModel] = packed
-            days[dayKey] = dayModels
+    private static func codexForkParentId(
+        from bytes: UnsafeBufferPointer<UInt8>,
+        in payloadRange: Range<Int>) -> String?
+    {
+        for key in [
+            self.codexJSONFieldForkedFromId,
+            self.codexJSONFieldForkedFromIdCamel,
+            self.codexJSONFieldParentSessionId,
+            self.codexJSONFieldParentSessionIdCamel,
+        ] {
+            guard let value = extractJSONByteStringField(key, from: bytes, in: payloadRange, atDepth: 1)?
+                .trimmingCharacters(in: .whitespacesAndNewlines),
+                !value.isEmpty
+            else { continue }
+            return value
         }
+        return nil
+    }
 
-        let maxLineBytes = 256 * 1024
-        let prefixBytes = 32 * 1024
-
-        let parsedBytes = (try? CostUsageJsonl.scan(
-            fileURL: fileURL,
-            offset: startOffset,
-            maxLineBytes: maxLineBytes,
-            prefixBytes: prefixBytes,
-            onLine: { line in
-                guard !line.bytes.isEmpty else { return }
-                guard !line.wasTruncated else { return }
-
-                guard
-                    line.bytes.containsAscii(#""type":"event_msg""#)
-                    || line.bytes.containsAscii(#""type":"turn_context""#)
-                    || line.bytes.containsAscii(#""type":"session_meta""#)
-                else { return }
-
-                if line.bytes.containsAscii(#""type":"event_msg""#), !line.bytes.containsAscii(#""token_count""#) {
-                    return
+    private static func codexTurnID(from bytes: UnsafeBufferPointer<UInt8>, in payloadRange: Range<Int>) -> String? {
+        for key in [self.codexJSONFieldTurnId, self.codexJSONFieldTurnIdCamel, self.codexJSONFieldId] {
+            if let value = extractJSONByteStringField(key, from: bytes, in: payloadRange, atDepth: 1), !value.isEmpty {
+                return value
+            }
+        }
+        if let infoRange = extractJSONByteObjectField(codexJSONFieldInfo, from: bytes, in: payloadRange, atDepth: 1) {
+            for key in [self.codexJSONFieldTurnId, self.codexJSONFieldTurnIdCamel, self.codexJSONFieldId] {
+                if let value = extractJSONByteStringField(key, from: bytes, in: infoRange, atDepth: 1), !value.isEmpty {
+                    return value
                 }
-
-                guard
-                    let obj = (try? JSONSerialization.jsonObject(with: line.bytes)) as? [String: Any],
-                    let type = obj["type"] as? String
-                else { return }
-
-                if type == "session_meta" {
-                    if sessionId == nil {
-                        let payload = obj["payload"] as? [String: Any]
-                        sessionId = payload?["session_id"] as? String
-                            ?? payload?["sessionId"] as? String
-                            ?? payload?["id"] as? String
-                            ?? obj["session_id"] as? String
-                            ?? obj["sessionId"] as? String
-                            ?? obj["id"] as? String
-                    }
-                    return
+            }
+        }
+        return nil
+    }
+
+    private static func codexSessionId(
+        from bytes: UnsafeBufferPointer<UInt8>,
+        in rootRange: Range<Int>,
+        payloadRange: Range<Int>?) -> String?
+    {
+        if let payloadRange {
+            for key in [self.codexJSONFieldSessionId, self.codexJSONFieldSessionIdCamel, self.codexJSONFieldId] {
+                if let value = extractJSONByteStringField(key, from: bytes, in: payloadRange, atDepth: 1),
+                   !value.isEmpty
+                {
+                    return value
                 }
+            }
+        }
+        for key in [Self.codexJSONFieldSessionId, Self.codexJSONFieldSessionIdCamel, Self.codexJSONFieldId] {
+            if let value = Self.extractJSONByteStringField(key, from: bytes, in: rootRange, atDepth: 1),
+               !value.isEmpty
+            {
+                return value
+            }
+        }
+        return nil
+    }
 
-                guard let tsText = obj["timestamp"] as? String else { return }
-                guard let dayKey = Self.dayKeyFromTimestamp(tsText) ?? Self.dayKeyFromParsedISO(tsText) else { return }
+    private static func codexTotals(
+        from bytes: UnsafeBufferPointer<UInt8>,
+        in objectRange: Range<Int>?) -> CostUsageCodexTotals?
+    {
+        guard let objectRange else { return nil }
+        let input = max(
+            0,
+            Self.extractJSONByteIntField(Self.codexJSONFieldInputTokens, from: bytes, in: objectRange, atDepth: 1) ?? 0)
+        let cached = max(
+            0,
+            Self.extractJSONByteIntField(Self.codexJSONFieldCachedInputTokens, from: bytes, in: objectRange, atDepth: 1)
+                ?? Self.extractJSONByteIntField(
+                    Self.codexJSONFieldCacheReadInputTokens,
+                    from: bytes,
+                    in: objectRange,
+                    atDepth: 1)
+                ?? 0)
+        let output = max(
+            0,
+            Self
+                .extractJSONByteIntField(Self.codexJSONFieldOutputTokens, from: bytes, in: objectRange, atDepth: 1) ??
+                0)
+        return CostUsageCodexTotals(input: input, cached: cached, output: output)
+    }
 
-                if type == "turn_context" {
-                    if let payload = obj["payload"] as? [String: Any] {
-                        if let model = payload["model"] as? String {
-                            currentModel = model
-                        } else if let info = payload["info"] as? [String: Any], let model = info["model"] as? String {
-                            currentModel = model
-                        }
+    private static func parseCodexFastLine(_ bytes: Data) -> CodexFastLine? {
+        bytes.withUnsafeBytes { rawBytes in
+            let rawBuffer = rawBytes.bindMemory(to: UInt8.self)
+            guard !rawBuffer.isEmpty else { return nil }
+            let objectRange = 0..<rawBuffer.count
+            guard let type = Self.extractJSONByteStringField(
+                Self.codexJSONFieldType,
+                from: rawBuffer,
+                in: objectRange,
+                atDepth: 1)
+            else { return nil }
+
+            switch type {
+            case "session_meta":
+                let payloadRange = Self.extractJSONByteObjectField(
+                    Self.codexJSONFieldPayload,
+                    from: rawBuffer,
+                    in: objectRange,
+                    atDepth: 1)
+                return .sessionMeta(CodexSessionMetadata(
+                    sessionId: Self.codexSessionId(from: rawBuffer, in: objectRange, payloadRange: payloadRange),
+                    forkedFromId: payloadRange.flatMap { Self.codexForkParentId(from: rawBuffer, in: $0) },
+                    forkTimestamp: payloadRange.flatMap {
+                        Self.extractJSONByteStringField(
+                            Self.codexJSONFieldTimestamp,
+                            from: rawBuffer,
+                            in: $0,
+                            atDepth: 1)
+                    } ?? Self.extractJSONByteStringField(
+                        Self.codexJSONFieldTimestamp,
+                        from: rawBuffer,
+                        in: objectRange,
+                        atDepth: 1)))
+
+            case "turn_context":
+                guard let payloadRange = Self.extractJSONByteObjectField(
+                    Self.codexJSONFieldPayload,
+                    from: rawBuffer,
+                    in: objectRange,
+                    atDepth: 1)
+                else { return .turnContext(model: nil) }
+                let model = Self.extractJSONByteStringField(
+                    Self.codexJSONFieldModel,
+                    from: rawBuffer,
+                    in: payloadRange,
+                    atDepth: 1)
+                    ?? Self.extractJSONByteStringField(
+                        Self.codexJSONFieldModelName,
+                        from: rawBuffer,
+                        in: payloadRange,
+                        atDepth: 1)
+                    ?? Self.extractJSONByteObjectField(
+                        Self.codexJSONFieldInfo,
+                        from: rawBuffer,
+                        in: payloadRange,
+                        atDepth: 1).flatMap {
+                        Self.extractJSONByteStringField(
+                            Self.codexJSONFieldModel,
+                            from: rawBuffer,
+                            in: $0,
+                            atDepth: 1)
+                            ?? Self.extractJSONByteStringField(
+                                Self.codexJSONFieldModelName,
+                                from: rawBuffer,
+                                in: $0,
+                                atDepth: 1)
                     }
-                    return
+                return .turnContext(model: model)
+
+            case "event_msg":
+                guard let payloadRange = Self.extractJSONByteObjectField(
+                    Self.codexJSONFieldPayload,
+                    from: rawBuffer,
+                    in: objectRange,
+                    atDepth: 1),
+                    let payloadType = Self.extractJSONByteStringField(
+                        Self.codexJSONFieldType,
+                        from: rawBuffer,
+                        in: payloadRange,
+                        atDepth: 1)
+                else { return nil }
+
+                if payloadType == "task_started" {
+                    return .taskStarted(turnID: Self.codexTurnID(from: rawBuffer, in: payloadRange))
                 }
 
-                guard type == "event_msg" else { return }
-                guard let payload = obj["payload"] as? [String: Any] else { return }
-                guard (payload["type"] as? String) == "token_count" else { return }
+                guard payloadType == "token_count",
+                      let timestamp = Self.extractJSONByteStringField(
+                          Self.codexJSONFieldTimestamp,
+                          from: rawBuffer,
+                          in: objectRange,
+                          atDepth: 1),
+                      let infoRange = Self.extractJSONByteObjectField(
+                          Self.codexJSONFieldInfo,
+                          from: rawBuffer,
+                          in: payloadRange,
+                          atDepth: 1)
+                else { return nil }
+
+                let model = Self.extractJSONByteStringField(
+                    Self.codexJSONFieldModel,
+                    from: rawBuffer,
+                    in: infoRange,
+                    atDepth: 1)
+                    ?? Self.extractJSONByteStringField(
+                        Self.codexJSONFieldModelName,
+                        from: rawBuffer,
+                        in: infoRange,
+                        atDepth: 1)
+                    ?? Self.extractJSONByteStringField(
+                        Self.codexJSONFieldModel,
+                        from: rawBuffer,
+                        in: payloadRange,
+                        atDepth: 1)
+                    ?? Self.extractJSONByteStringField(
+                        Self.codexJSONFieldModel,
+                        from: rawBuffer,
+                        in: objectRange,
+                        atDepth: 1)
+                let total = Self.codexTotals(
+                    from: rawBuffer,
+                    in: Self.extractJSONByteObjectField(
+                        Self.codexJSONFieldTotalTokenUsage,
+                        from: rawBuffer,
+                        in: infoRange,
+                        atDepth: 1))
+                let last = Self.codexTotals(
+                    from: rawBuffer,
+                    in: Self.extractJSONByteObjectField(
+                        Self.codexJSONFieldLastTokenUsage,
+                        from: rawBuffer,
+                        in: infoRange,
+                        atDepth: 1))
+                return .tokenCount(CodexTokenCountRecord(
+                    timestamp: timestamp,
+                    model: model,
+                    turnID: Self.codexTurnID(from: rawBuffer, in: payloadRange),
+                    last: last,
+                    total: total))
 
-                let info = payload["info"] as? [String: Any]
-                let modelFromInfo = info?["model"] as? String
-                    ?? info?["model_name"] as? String
-                    ?? payload["model"] as? String
-                    ?? obj["model"] as? String
-                let model = modelFromInfo ?? currentModel ?? "gpt-5"
+            default:
+                return nil
+            }
+        }
+    }
+
+    private static func parseCodexSessionIdentifier(
+        fileURL: URL,
+        checkCancellation: CancellationCheck? = nil) throws -> String?
+    {
+        try self.parseCodexSessionMetadata(fileURL: fileURL, checkCancellation: checkCancellation)?.sessionId
+    }
+
+    private static func parseCodexSessionMetadata(
+        fileURL: URL,
+        checkCancellation: CancellationCheck? = nil) throws -> CodexSessionMetadata?
+    {
+        let handle: FileHandle
+        do {
+            handle = try FileHandle(forReadingFrom: fileURL)
+        } catch {
+            self.log.warning(
+                "Codex cost usage failed to open session file for session id parsing",
+                metadata: ["path": fileURL.path, "error": error.localizedDescription])
+            return nil
+        }
+        defer { try? handle.close() }
+
+        var buffer = Data()
+        let newline = Data([0x0A])
+
+        func parseSessionMetadata(from lineData: Data) -> CodexSessionMetadata? {
+            guard !lineData.isEmpty else { return nil }
+            if case let .sessionMeta(metadata) = Self.parseCodexFastLine(lineData) {
+                return metadata
+            }
+            return autoreleasepool {
+                guard let obj = (try? JSONSerialization.jsonObject(with: lineData)) as? [String: Any]
+                else { return nil }
+                guard obj["type"] as? String == "session_meta" else { return nil }
+                let payload = obj["payload"] as? [String: Any]
+                return CodexSessionMetadata(
+                    sessionId: payload?["session_id"] as? String
+                        ?? payload?["sessionId"] as? String
+                        ?? payload?["id"] as? String
+                        ?? obj["session_id"] as? String
+                        ?? obj["sessionId"] as? String
+                        ?? obj["id"] as? String,
+                    forkedFromId: Self.codexForkParentId(from: payload),
+                    forkTimestamp: payload?["timestamp"] as? String
+                        ?? obj["timestamp"] as? String)
+            }
+        }
 
-                func toInt(_ v: Any?) -> Int {
-                    if let n = v as? NSNumber { return n.intValue }
-                    return 0
+        do {
+            while let chunk = try handle.read(upToCount: 64 * 1024), !chunk.isEmpty {
+                try checkCancellation?()
+                buffer.append(chunk)
+                while let newlineRange = buffer.range(of: newline) {
+                    let lineData = buffer.subdata(in: 0..<newlineRange.lowerBound)
+                    buffer.removeSubrange(0..<newlineRange.upperBound)
+                    if let metadata = parseSessionMetadata(from: lineData) {
+                        return metadata
+                    }
                 }
+            }
+        } catch is CancellationError {
+            throw CancellationError()
+        } catch {
+            self.log.warning(
+                "Codex cost usage failed while reading session file for session id parsing",
+                metadata: ["path": fileURL.path, "error": error.localizedDescription])
+            return nil
+        }
 
-                let total = (info?["total_token_usage"] as? [String: Any])
-                let last = (info?["last_token_usage"] as? [String: Any])
+        if let metadata = parseSessionMetadata(from: buffer) {
+            return metadata
+        }
+        return nil
+    }
 
-                var deltaInput = 0
-                var deltaCached = 0
-                var deltaOutput = 0
+    private static func parseCodexTokenSnapshots(
+        fileURL: URL,
+        checkCancellation: CancellationCheck? = nil) throws -> (
+        sessionId: String?,
+        snapshots: [CodexTimestampedTotals])
+    {
+        var sessionId: String?
+        var previousTotals: CostUsageCodexTotals?
+        var rawTotalsBaseline: CostUsageCodexTotals?
+        var sawDivergentTotals = false
+        var snapshots: [CodexTimestampedTotals] = []
+        var warnedAboutUnparsedTimestamp = false
+
+        func parsedSnapshotDate(timestamp: String) -> Date? {
+            let date = Self.dateFromTimestamp(timestamp)
+            if date == nil, !warnedAboutUnparsedTimestamp {
+                warnedAboutUnparsedTimestamp = true
+                self.log.warning(
+                    "Codex cost usage could not parse parent token snapshot timestamp; "
+                        + "falling back to lexical comparison",
+                    metadata: ["path": fileURL.path, "timestamp": timestamp])
+            }
+            return date
+        }
+
+        func appendSnapshot(timestamp: String, last: CostUsageCodexTotals?, total: CostUsageCodexTotals?) {
+            if let last {
+                let rawDelta = last
+                let base = previousTotals ?? .init(input: 0, cached: 0, output: 0)
+                var countedDelta = rawDelta
 
                 if let total {
-                    let input = toInt(total["input_tokens"])
-                    let cached = toInt(total["cached_input_tokens"] ?? total["cache_read_input_tokens"])
-                    let output = toInt(total["output_tokens"])
-
-                    let prev = previousTotals
-                    deltaInput = max(0, input - (prev?.input ?? 0))
-                    deltaCached = max(0, cached - (prev?.cached ?? 0))
-                    deltaOutput = max(0, output - (prev?.output ?? 0))
-                    previousTotals = CostUsageCodexTotals(input: input, cached: cached, output: output)
-                } else if let last {
-                    deltaInput = max(0, toInt(last["input_tokens"]))
-                    deltaCached = max(0, toInt(last["cached_input_tokens"] ?? last["cache_read_input_tokens"]))
-                    deltaOutput = max(0, toInt(last["output_tokens"]))
+                    let rawTotals = total
+                    let totalDelta = Self.codexTotalDelta(from: rawTotalsBaseline, to: rawTotals)
+                    if Self.codexShouldPreferTotalDelta(
+                        rawBaseline: rawTotalsBaseline,
+                        currentTotal: rawTotals,
+                        totalDelta: totalDelta,
+                        lastDelta: rawDelta,
+                        sawDivergentTotals: sawDivergentTotals)
+                    {
+                        countedDelta = totalDelta
+                    }
+                    let next = Self.codexAddTotals(base, countedDelta)
+                    previousTotals = next
+                    rawTotalsBaseline = rawTotals
+                    if !Self.codexTotalsEqual(rawTotals, next) {
+                        sawDivergentTotals = true
+                    }
                 } else {
-                    return
+                    let next = Self.codexAddTotals(base, countedDelta)
+                    previousTotals = next
+                    rawTotalsBaseline = next
+                }
+
+                snapshots.append(CodexTimestampedTotals(
+                    timestamp: timestamp,
+                    date: parsedSnapshotDate(timestamp: timestamp),
+                    totals: previousTotals ?? base))
+            } else if let total {
+                let next = total
+                let delta = sawDivergentTotals
+                    ? Self.codexDivergentTotalDelta(
+                        rawBaseline: rawTotalsBaseline,
+                        countedBaseline: previousTotals,
+                        current: next)
+                    : Self.codexTotalDelta(from: rawTotalsBaseline, to: next)
+                let base = previousTotals ?? .init(input: 0, cached: 0, output: 0)
+                let countedTotals = Self.codexAddTotals(base, delta)
+                previousTotals = countedTotals
+                rawTotalsBaseline = next
+                if !Self.codexTotalsEqual(next, countedTotals) {
+                    sawDivergentTotals = true
                 }
+                snapshots.append(CodexTimestampedTotals(
+                    timestamp: timestamp,
+                    date: parsedSnapshotDate(timestamp: timestamp),
+                    totals: countedTotals))
+            }
+        }
 
-                if deltaInput == 0, deltaCached == 0, deltaOutput == 0 { return }
-                let cachedClamp = min(deltaCached, deltaInput)
-                add(dayKey: dayKey, model: model, input: deltaInput, cached: cachedClamp, output: deltaOutput)
-            })) ?? startOffset
+        do {
+            _ = try CostUsageJsonl.scan(
+                fileURL: fileURL,
+                maxLineBytes: 512 * 1024,
+                prefixBytes: 512 * 1024,
+                checkCancellation: checkCancellation,
+                onLine: { line in
+                    guard !line.bytes.isEmpty, !line.wasTruncated else { return }
+                    if let fastLine = Self.parseCodexFastLine(line.bytes) {
+                        switch fastLine {
+                        case let .sessionMeta(metadata):
+                            if sessionId == nil {
+                                sessionId = metadata.sessionId
+                            }
+                        case let .tokenCount(record):
+                            appendSnapshot(timestamp: record.timestamp, last: record.last, total: record.total)
+                        case .turnContext, .taskStarted:
+                            break
+                        }
+                        return
+                    }
 
-        return CodexParseResult(
-            days: days,
-            parsedBytes: parsedBytes,
-            lastModel: currentModel,
-            lastTotals: previousTotals,
-            sessionId: sessionId)
+                    autoreleasepool {
+                        guard let obj = (try? JSONSerialization.jsonObject(with: line.bytes)) as? [String: Any]
+                        else { return }
+
+                        if obj["type"] as? String == "session_meta" {
+                            let payload = obj["payload"] as? [String: Any]
+                            if sessionId == nil {
+                                sessionId = payload?["session_id"] as? String
+                                    ?? payload?["sessionId"] as? String
+                                    ?? payload?["id"] as? String
+                                    ?? obj["session_id"] as? String
+                                    ?? obj["sessionId"] as? String
+                                    ?? obj["id"] as? String
+                            }
+                            return
+                        }
+
+                        guard obj["type"] as? String == "event_msg" else { return }
+                        guard let payload = obj["payload"] as? [String: Any] else { return }
+                        guard payload["type"] as? String == "token_count" else { return }
+                        guard let info = payload["info"] as? [String: Any] else { return }
+                        guard let timestamp = obj["timestamp"] as? String else { return }
+
+                        func toInt(_ value: Any?) -> Int {
+                            if let number = value as? NSNumber { return number.intValue }
+                            return 0
+                        }
+
+                        let total = (info["total_token_usage"] as? [String: Any]).map {
+                            CostUsageCodexTotals(
+                                input: toInt($0["input_tokens"]),
+                                cached: toInt($0["cached_input_tokens"] ?? $0["cache_read_input_tokens"]),
+                                output: toInt($0["output_tokens"]))
+                        }
+                        let last = (info["last_token_usage"] as? [String: Any]).map {
+                            CostUsageCodexTotals(
+                                input: max(0, toInt($0["input_tokens"])),
+                                cached: max(0, toInt($0["cached_input_tokens"] ?? $0["cache_read_input_tokens"])),
+                                output: max(0, toInt($0["output_tokens"])))
+                        }
+                        appendSnapshot(timestamp: timestamp, last: last, total: total)
+                    }
+                })
+        } catch is CancellationError {
+            throw CancellationError()
+        } catch {
+            self.log.warning(
+                "Codex cost usage failed while scanning parent token snapshots",
+                metadata: ["path": fileURL.path, "error": error.localizedDescription])
+        }
+
+        return (sessionId, snapshots)
     }
 
-    private static func scanCodexFile(
+    static func parseCodexFile(
         fileURL: URL,
         range: CostUsageDayRange,
-        cache: inout CostUsageCache,
-        state: inout CodexScanState)
+        startOffset: Int64 = 0,
+        initialModel: String? = nil,
+        initialTotals: CostUsageCodexTotals? = nil,
+        initialRawTotalsBaseline: CostUsageCodexTotals? = nil,
+        initialHasDivergentTotals: Bool = false,
+        initialCodexTurnID: String? = nil,
+        inheritedTotalsResolver: ((String, String) -> CodexForkBaseline)? = nil) -> CodexParseResult
     {
-        let path = fileURL.path
-        let attrs = (try? FileManager.default.attributesOfItem(atPath: path)) ?? [:]
-        let mtime = (attrs[.modificationDate] as? Date)?.timeIntervalSince1970 ?? 0
-        let size = (attrs[.size] as? NSNumber)?.int64Value ?? 0
-        let mtimeMs = Int64(mtime * 1000)
-        let fileId = Self.fileIdentityString(fileURL: fileURL)
-
-        func dropCachedFile(_ cached: CostUsageFileUsage?) {
-            if let cached {
-                Self.applyFileDays(cache: &cache, fileDays: cached.days, sign: -1)
+        let throwingResolver: ((String, String) throws -> CodexForkBaseline)? = inheritedTotalsResolver
+            .map { resolver in
+                { sessionId, timestamp in resolver(sessionId, timestamp) }
             }
-            cache.files.removeValue(forKey: path)
-        }
+        return (
+            try? Self.parseCodexFileCancellable(
+                fileURL: fileURL,
+                range: range,
+                startOffset: startOffset,
+                initialModel: initialModel,
+                initialTotals: initialTotals,
+                initialRawTotalsBaseline: initialRawTotalsBaseline,
+                initialHasDivergentTotals: initialHasDivergentTotals,
+                initialCodexTurnID: initialCodexTurnID,
+                inheritedTotalsResolver: throwingResolver,
+                checkCancellation: nil)) ?? CodexParseResult(
+            days: [:],
+            parsedBytes: startOffset,
+            lastModel: initialModel,
+            lastTotals: initialTotals,
+            lastCountedTotals: initialTotals,
+            lastRawTotalsBaseline: initialRawTotalsBaseline,
+            hasDivergentTotals: initialHasDivergentTotals,
+            lastCodexTurnID: initialCodexTurnID,
+            sessionId: nil,
+            forkedFromId: nil,
+            rows: [])
+    }
 
-        if let fileId, state.seenFileIds.contains(fileId) {
-            dropCachedFile(cache.files[path])
-            return
+    // swiftlint:disable:next cyclomatic_complexity function_body_length
+    static func parseCodexFileCancellable(
+        fileURL: URL,
+        range: CostUsageDayRange,
+        startOffset: Int64 = 0,
+        initialModel: String? = nil,
+        initialTotals: CostUsageCodexTotals? = nil,
+        initialRawTotalsBaseline: CostUsageCodexTotals? = nil,
+        initialHasDivergentTotals: Bool = false,
+        initialCodexTurnID: String? = nil,
+        inheritedTotalsResolver: ((String, String) throws -> CodexForkBaseline)? = nil,
+        checkCancellation: CancellationCheck? = nil) throws -> CodexParseResult
+    {
+        var currentModel = initialModel
+        var previousTotals = initialTotals
+        var sessionId: String?
+        var forkedFromId: String?
+        var inheritedTotals: CostUsageCodexTotals?
+        var remainingInheritedTotals: CostUsageCodexTotals?
+        var forkBaselineResolved = false
+        var hasUnresolvedForkBaseline = false
+        var unresolvedForkTotalWatermark: CostUsageCodexTotals?
+        var currentTurnID = initialCodexTurnID
+        var rawTotalsBaseline = initialRawTotalsBaseline ?? initialTotals
+        var sawDivergentTotals = initialHasDivergentTotals
+        var deferredError: Error?
+
+        var days: [String: [String: [Int]]] = [:]
+        var rows: [CodexUsageRow] = []
+
+        func add(dayKey: String, model: String, input: Int, cached: Int, output: Int) {
+            guard CostUsageDayRange.isInRange(dayKey: dayKey, since: range.scanSinceKey, until: range.scanUntilKey)
+            else { return }
+            let normModel = CostUsagePricing.normalizeCodexModel(model)
+
+            var dayModels = days[dayKey] ?? [:]
+            var packed = dayModels[normModel] ?? [0, 0, 0]
+            packed[0] = (packed[safe: 0] ?? 0) + input
+            packed[1] = (packed[safe: 1] ?? 0) + cached
+            packed[2] = (packed[safe: 2] ?? 0) + output
+            dayModels[normModel] = packed
+            days[dayKey] = dayModels
         }
 
-        let cached = cache.files[path]
-        if let cachedSessionId = cached?.sessionId, state.seenSessionIds.contains(cachedSessionId) {
-            dropCachedFile(cached)
-            return
+        func resolveForkBaseline(parentSessionId: String, forkedAt: String) throws {
+            guard !forkBaselineResolved else { return }
+            guard let inheritedTotalsResolver else { return }
+            forkBaselineResolved = true
+            switch try inheritedTotalsResolver(parentSessionId, forkedAt) {
+            case let .resolved(totals):
+                inheritedTotals = totals
+                remainingInheritedTotals = totals
+                hasUnresolvedForkBaseline = false
+            case .unresolved:
+                hasUnresolvedForkBaseline = true
+            }
         }
 
-        let needsSessionId = cached != nil && cached?.sessionId == nil
-        if let cached,
-           cached.mtimeUnixMs == mtimeMs,
-           cached.size == size,
-           !needsSessionId
-        {
-            if let cachedSessionId = cached.sessionId {
-                state.seenSessionIds.insert(cachedSessionId)
+        func handleSessionMetadata(_ metadata: CodexSessionMetadata) throws {
+            if sessionId == nil {
+                sessionId = metadata.sessionId
             }
-            if let fileId {
-                state.seenFileIds.insert(fileId)
+            if forkedFromId == nil {
+                forkedFromId = metadata.forkedFromId
+            }
+            if let forkedFromId {
+                try resolveForkBaseline(parentSessionId: forkedFromId, forkedAt: metadata.forkTimestamp ?? "")
             }
-            return
         }
 
-        if let cached, cached.sessionId != nil {
-            let startOffset = cached.parsedBytes ?? cached.size
-            let canIncremental = size > cached.size && startOffset > 0 && startOffset <= size
-                && cached.lastTotals != nil
-            if canIncremental {
-                let delta = Self.parseCodexFile(
-                    fileURL: fileURL,
-                    range: range,
-                    startOffset: startOffset,
-                    initialModel: cached.lastModel,
-                    initialTotals: cached.lastTotals)
-                let sessionId = delta.sessionId ?? cached.sessionId
-                if let sessionId, state.seenSessionIds.contains(sessionId) {
-                    dropCachedFile(cached)
-                    return
+        // swiftlint:disable:next function_body_length
+        func handleTokenCount(_ record: CodexTokenCountRecord) throws {
+            guard let dayKey = Self.dayKeyFromTimestamp(record.timestamp) ?? Self.dayKeyFromParsedISO(record.timestamp)
+            else { return }
+
+            let model = currentModel ?? record.model ?? "gpt-5"
+            let total = record.total
+            let last = record.last
+
+            var deltaInput = 0
+            var deltaCached = 0
+            var deltaOutput = 0
+
+            func adjustedLastDelta(_ rawDelta: CostUsageCodexTotals) -> CostUsageCodexTotals {
+                guard var remaining = remainingInheritedTotals else { return rawDelta }
+
+                let adjusted = CostUsageCodexTotals(
+                    input: max(0, rawDelta.input - remaining.input),
+                    cached: max(0, rawDelta.cached - remaining.cached),
+                    output: max(0, rawDelta.output - remaining.output))
+
+                remaining.input = max(0, remaining.input - rawDelta.input)
+                remaining.cached = max(0, remaining.cached - rawDelta.cached)
+                remaining.output = max(0, remaining.output - rawDelta.output)
+                remainingInheritedTotals = if remaining.input == 0, remaining.cached == 0,
+                                              remaining.output == 0
+                {
+                    nil
+                } else {
+                    remaining
                 }
 
-                if !delta.days.isEmpty {
-                    Self.applyFileDays(cache: &cache, fileDays: delta.days, sign: 1)
+                return adjusted
+            }
+
+            let handledUnresolvedForkTotal = hasUnresolvedForkBaseline && total != nil
+            if hasUnresolvedForkBaseline, let total {
+                let currentRawTotals = total
+                defer {
+                    unresolvedForkTotalWatermark = currentRawTotals
                 }
+                guard let last,
+                      let watermark = unresolvedForkTotalWatermark
+                else {
+                    return
+                }
+
+                let rawLastDelta = last
+                let rawTotalDelta = Self.codexTotalDelta(from: watermark, to: currentRawTotals)
+                let adjustedDelta = Self.codexMinTotals(rawLastDelta, rawTotalDelta)
+                deltaInput = adjustedDelta.input
+                deltaCached = adjustedDelta.cached
+                deltaOutput = adjustedDelta.output
+                let prev = previousTotals ?? .init(input: 0, cached: 0, output: 0)
+                previousTotals = Self.codexAddTotals(prev, adjustedDelta)
+                rawTotalsBaseline = previousTotals
+            }
 
-                var mergedDays = cached.days
-                Self.mergeFileDays(existing: &mergedDays, delta: delta.days)
-                cache.files[path] = Self.makeFileUsage(
-                    mtimeUnixMs: mtimeMs,
-                    size: size,
-                    days: mergedDays,
-                    parsedBytes: delta.parsedBytes,
-                    lastModel: delta.lastModel,
-                    lastTotals: delta.lastTotals,
-                    sessionId: sessionId)
-                if let sessionId {
-                    state.seenSessionIds.insert(sessionId)
+            if !handledUnresolvedForkTotal,
+               let total,
+               forkedFromId != nil,
+               !hasUnresolvedForkBaseline
+            {
+                let rawTotals = total
+                let currentTotals: CostUsageCodexTotals = if let inheritedTotals {
+                    CostUsageCodexTotals(
+                        input: max(0, rawTotals.input - inheritedTotals.input),
+                        cached: max(0, rawTotals.cached - inheritedTotals.cached),
+                        output: max(0, rawTotals.output - inheritedTotals.output))
+                } else {
+                    rawTotals
+                }
+                let delta = sawDivergentTotals
+                    ? Self.codexDivergentTotalDelta(
+                        rawBaseline: rawTotalsBaseline,
+                        countedBaseline: previousTotals,
+                        current: currentTotals)
+                    : Self.codexTotalDelta(from: rawTotalsBaseline, to: currentTotals)
+                deltaInput = delta.input
+                deltaCached = delta.cached
+                deltaOutput = delta.output
+                let prev = previousTotals ?? .init(input: 0, cached: 0, output: 0)
+                previousTotals = Self.codexAddTotals(prev, delta)
+                rawTotalsBaseline = currentTotals
+                if !Self.codexTotalsEqual(rawTotalsBaseline, previousTotals) {
+                    sawDivergentTotals = true
                 }
-                if let fileId {
-                    state.seenFileIds.insert(fileId)
+                remainingInheritedTotals = nil
+            } else if !handledUnresolvedForkTotal, let last {
+                let rawDelta = last
+                let hadRemainingInheritedTotals = remainingInheritedTotals != nil
+                var adjustedDelta = adjustedLastDelta(rawDelta)
+                deltaInput = adjustedDelta.input
+                deltaCached = adjustedDelta.cached
+                deltaOutput = adjustedDelta.output
+                let prev = previousTotals ?? .init(input: 0, cached: 0, output: 0)
+
+                if let total, !hasUnresolvedForkBaseline {
+                    let rawTotals = total
+                    let currentTotals: CostUsageCodexTotals = if let inheritedTotals {
+                        CostUsageCodexTotals(
+                            input: max(0, rawTotals.input - inheritedTotals.input),
+                            cached: max(0, rawTotals.cached - inheritedTotals.cached),
+                            output: max(0, rawTotals.output - inheritedTotals.output))
+                    } else {
+                        rawTotals
+                    }
+                    let totalDelta = Self.codexTotalDelta(from: rawTotalsBaseline, to: currentTotals)
+                    if !hadRemainingInheritedTotals,
+                       Self.codexShouldPreferTotalDelta(
+                           rawBaseline: rawTotalsBaseline,
+                           currentTotal: currentTotals,
+                           totalDelta: totalDelta,
+                           lastDelta: rawDelta,
+                           sawDivergentTotals: sawDivergentTotals)
+                    {
+                        adjustedDelta = totalDelta
+                        deltaInput = adjustedDelta.input
+                        deltaCached = adjustedDelta.cached
+                        deltaOutput = adjustedDelta.output
+                        remainingInheritedTotals = nil
+                    }
+                    let countedTotals = Self.codexAddTotals(prev, adjustedDelta)
+                    previousTotals = countedTotals
+                    rawTotalsBaseline = currentTotals
+                    if !Self.codexTotalsEqual(currentTotals, countedTotals) {
+                        sawDivergentTotals = true
+                    }
+                } else {
+                    let countedTotals = Self.codexAddTotals(prev, adjustedDelta)
+                    previousTotals = countedTotals
+                    rawTotalsBaseline = countedTotals
+                }
+            } else if !handledUnresolvedForkTotal, let total {
+                let rawTotals = total
+
+                let currentTotals: CostUsageCodexTotals = if let inheritedTotals {
+                    CostUsageCodexTotals(
+                        input: max(0, rawTotals.input - inheritedTotals.input),
+                        cached: max(0, rawTotals.cached - inheritedTotals.cached),
+                        output: max(0, rawTotals.output - inheritedTotals.output))
+                } else {
+                    rawTotals
                 }
+
+                let delta = sawDivergentTotals
+                    ? Self.codexDivergentTotalDelta(
+                        rawBaseline: rawTotalsBaseline,
+                        countedBaseline: previousTotals,
+                        current: currentTotals)
+                    : Self.codexTotalDelta(from: rawTotalsBaseline, to: currentTotals)
+                deltaInput = delta.input
+                deltaCached = delta.cached
+                deltaOutput = delta.output
+                let prev = previousTotals ?? .init(input: 0, cached: 0, output: 0)
+                previousTotals = Self.codexAddTotals(prev, delta)
+                rawTotalsBaseline = currentTotals
+                if !Self.codexTotalsEqual(rawTotalsBaseline, previousTotals) {
+                    sawDivergentTotals = true
+                }
+                remainingInheritedTotals = nil
+            } else if !handledUnresolvedForkTotal {
                 return
             }
-        }
-
-        if let cached {
-            Self.applyFileDays(cache: &cache, fileDays: cached.days, sign: -1)
-        }
 
-        let parsed = Self.parseCodexFile(fileURL: fileURL, range: range)
-        let sessionId = parsed.sessionId ?? cached?.sessionId
-        if let sessionId, state.seenSessionIds.contains(sessionId) {
-            cache.files.removeValue(forKey: path)
-            return
+            if deltaInput == 0, deltaCached == 0, deltaOutput == 0 { return }
+            let cachedClamp = min(deltaCached, deltaInput)
+            let normModel = CostUsagePricing.normalizeCodexModel(model)
+            add(
+                dayKey: dayKey,
+                model: normModel,
+                input: deltaInput,
+                cached: cachedClamp,
+                output: deltaOutput)
+            if CostUsageDayRange.isInRange(
+                dayKey: dayKey,
+                since: range.scanSinceKey,
+                until: range.scanUntilKey)
+            {
+                rows.append(CodexUsageRow(
+                    day: dayKey,
+                    model: normModel,
+                    turnID: record.turnID ?? currentTurnID,
+                    input: deltaInput,
+                    cached: cachedClamp,
+                    output: deltaOutput))
+            }
         }
 
-        let usage = Self.makeFileUsage(
-            mtimeUnixMs: mtimeMs,
-            size: size,
-            days: parsed.days,
-            parsedBytes: parsed.parsedBytes,
-            lastModel: parsed.lastModel,
-            lastTotals: parsed.lastTotals,
-            sessionId: sessionId)
-        cache.files[path] = usage
-        Self.applyFileDays(cache: &cache, fileDays: usage.days, sign: 1)
-        if let sessionId {
-            state.seenSessionIds.insert(sessionId)
-        }
-        if let fileId {
-            state.seenFileIds.insert(fileId)
+        func handleFastLine(_ fastLine: CodexFastLine) throws {
+            switch fastLine {
+            case let .sessionMeta(metadata):
+                try handleSessionMetadata(metadata)
+            case let .turnContext(model):
+                if let model {
+                    currentModel = model
+                }
+            case let .taskStarted(turnID):
+                currentTurnID = turnID
+            case let .tokenCount(record):
+                try handleTokenCount(record)
+            }
         }
-    }
 
-    private static func loadCodexDaily(range: CostUsageDayRange, now: Date, options: Options) -> CostUsageDailyReport {
-        var cache = CostUsageCacheIO.load(provider: .codex, cacheRoot: options.cacheRoot)
-        let nowMs = Int64(now.timeIntervalSince1970 * 1000)
-
-        let refreshMs = Int64(max(0, options.refreshMinIntervalSeconds) * 1000)
-        let shouldRefresh = refreshMs == 0 || cache.lastScanUnixMs == 0 || nowMs - cache.lastScanUnixMs > refreshMs
+        let maxLineBytes = 256 * 1024
+        let prefixBytes = maxLineBytes
 
-        let roots = self.codexSessionsRoots(options: options)
-        var seenPaths: Set<String> = []
-        var files: [URL] = []
-        for root in roots {
-            let rootFiles = Self.listCodexSessionFiles(
-                root: root,
-                scanSinceKey: range.scanSinceKey,
-                scanUntilKey: range.scanUntilKey)
-            for fileURL in rootFiles.sorted(by: { $0.path < $1.path }) where !seenPaths.contains(fileURL.path) {
-                seenPaths.insert(fileURL.path)
-                files.append(fileURL)
+        if startOffset == 0,
+           let metadata = try Self.parseCodexSessionMetadata(
+               fileURL: fileURL,
+               checkCancellation: checkCancellation)
+        {
+            sessionId = metadata.sessionId
+            forkedFromId = metadata.forkedFromId
+            if let forkedFromId = metadata.forkedFromId,
+               inheritedTotals == nil
+            {
+                let forkedAt = metadata.forkTimestamp ?? ""
+                try resolveForkBaseline(parentSessionId: forkedFromId, forkedAt: forkedAt)
             }
         }
-        let filePathsInScan = Set(files.map(\.path))
-
-        if shouldRefresh {
-            if options.forceRescan {
-                cache = CostUsageCache()
-            }
-            var scanState = CodexScanState()
-            for fileURL in files {
-                Self.scanCodexFile(
-                    fileURL: fileURL,
-                    range: range,
-                    cache: &cache,
-                    state: &scanState)
-            }
 
-            for key in cache.files.keys where !filePathsInScan.contains(key) {
-                if let old = cache.files[key] {
-                    Self.applyFileDays(cache: &cache, fileDays: old.days, sign: -1)
-                }
-                cache.files.removeValue(forKey: key)
-            }
+        var parsedBytes: Int64
+        do {
+            parsedBytes = try CostUsageJsonl.scan(
+                fileURL: fileURL,
+                offset: startOffset,
+                maxLineBytes: maxLineBytes,
+                prefixBytes: prefixBytes,
+                checkCancellation: checkCancellation,
+                onLine: { line in
+                    if deferredError != nil { return }
+                    guard !line.bytes.isEmpty else { return }
+                    if line.wasTruncated {
+                        // `turn_context` can carry very large prompts, but its model usually appears near the start.
+                        if let model = Self.extractCodexTurnContextModel(from: line.bytes) {
+                            currentModel = model
+                        }
+                        return
+                    }
 
-            Self.pruneDays(cache: &cache, sinceKey: range.scanSinceKey, untilKey: range.scanUntilKey)
-            cache.lastScanUnixMs = nowMs
-            CostUsageCacheIO.save(provider: .codex, cache: cache, cacheRoot: options.cacheRoot)
-        }
+                    guard
+                        line.bytes.containsAscii(#""type":"event_msg""#)
+                        || line.bytes.containsAscii(#""type":"turn_context""#)
+                        || line.bytes.containsAscii(#""type":"session_meta""#)
+                    else { return }
+
+                    if line.bytes.containsAscii(#""type":"event_msg""#),
+                       !line.bytes.containsAscii(#""token_count""#),
+                       !line.bytes.containsAscii(#""task_started""#)
+                    {
+                        return
+                    }
 
-        return Self.buildCodexReportFromCache(cache: cache, range: range)
-    }
+                    if let fastLine = Self.parseCodexFastLine(line.bytes) {
+                        do {
+                            try handleFastLine(fastLine)
+                        } catch {
+                            deferredError = error
+                        }
+                        return
+                    }
 
-    private static func buildCodexReportFromCache(
-        cache: CostUsageCache,
-        range: CostUsageDayRange) -> CostUsageDailyReport
-    {
-        var entries: [CostUsageDailyReport.Entry] = []
-        var totalInput = 0
-        var totalOutput = 0
-        var totalTokens = 0
-        var totalCost: Double = 0
-        var costSeen = false
+                    autoreleasepool {
+                        guard
+                            let obj = (try? JSONSerialization.jsonObject(with: line.bytes)) as? [String: Any],
+                            let type = obj["type"] as? String
+                        else { return }
+
+                        if type == "session_meta" {
+                            let payload = obj["payload"] as? [String: Any]
+                            if sessionId == nil {
+                                sessionId = payload?["session_id"] as? String
+                                    ?? payload?["sessionId"] as? String
+                                    ?? payload?["id"] as? String
+                                    ?? obj["session_id"] as? String
+                                    ?? obj["sessionId"] as? String
+                                    ?? obj["id"] as? String
+                            }
+                            if forkedFromId == nil {
+                                forkedFromId = Self.codexForkParentId(from: payload)
+                            }
+                            if let forkedFromId {
+                                let forkedAt = payload?["timestamp"] as? String
+                                    ?? obj["timestamp"] as? String
+                                    ?? ""
+                                do {
+                                    try resolveForkBaseline(parentSessionId: forkedFromId, forkedAt: forkedAt)
+                                } catch {
+                                    deferredError = error
+                                    return
+                                }
+                            }
+                            return
+                        }
 
-        let dayKeys = cache.days.keys.sorted().filter {
-            CostUsageDayRange.isInRange(dayKey: $0, since: range.sinceKey, until: range.untilKey)
-        }
+                        guard let tsText = obj["timestamp"] as? String else { return }
+                        guard let dayKey = Self.dayKeyFromTimestamp(tsText) ?? Self.dayKeyFromParsedISO(tsText)
+                        else { return }
+
+                        if type == "turn_context" {
+                            if let payload = obj["payload"] as? [String: Any] {
+                                if let model = payload["model"] as? String {
+                                    currentModel = model
+                                } else if let info = payload["info"] as? [String: Any],
+                                          let model = info["model"] as? String
+                                {
+                                    currentModel = model
+                                }
+                            }
+                            return
+                        }
 
-        for day in dayKeys {
-            guard let models = cache.days[day] else { continue }
-            let modelNames = models.keys.sorted()
+                        guard type == "event_msg" else { return }
+                        guard let payload = obj["payload"] as? [String: Any] else { return }
+                        if (payload["type"] as? String) == "task_started" {
+                            currentTurnID = Self.codexTurnID(from: payload)
+                            return
+                        }
+                        guard (payload["type"] as? String) == "token_count" else { return }
+
+                        let info = payload["info"] as? [String: Any]
+                        let modelFromInfo = info?["model"] as? String
+                            ?? info?["model_name"] as? String
+                            ?? payload["model"] as? String
+                            ?? obj["model"] as? String
+                        let model = currentModel ?? modelFromInfo ?? "gpt-5"
+
+                        func toInt(_ v: Any?) -> Int {
+                            if let n = v as? NSNumber { return n.intValue }
+                            return 0
+                        }
 
-            var dayInput = 0
-            var dayOutput = 0
+                        func tokenTotals(_ usage: [String: Any]) -> CostUsageCodexTotals {
+                            CostUsageCodexTotals(
+                                input: max(0, toInt(usage["input_tokens"])),
+                                cached: max(0, toInt(usage["cached_input_tokens"] ?? usage["cache_read_input_tokens"])),
+                                output: max(0, toInt(usage["output_tokens"])))
+                        }
 
-            var breakdown: [CostUsageDailyReport.ModelBreakdown] = []
-            var dayCost: Double = 0
-            var dayCostSeen = false
+                        let total = (info?["total_token_usage"] as? [String: Any])
+                        let last = (info?["last_token_usage"] as? [String: Any])
+
+                        var deltaInput = 0
+                        var deltaCached = 0
+                        var deltaOutput = 0
+
+                        func adjustedLastDelta(_ rawDelta: CostUsageCodexTotals) -> CostUsageCodexTotals {
+                            guard var remaining = remainingInheritedTotals else { return rawDelta }
+
+                            let adjusted = CostUsageCodexTotals(
+                                input: max(0, rawDelta.input - remaining.input),
+                                cached: max(0, rawDelta.cached - remaining.cached),
+                                output: max(0, rawDelta.output - remaining.output))
+
+                            remaining.input = max(0, remaining.input - rawDelta.input)
+                            remaining.cached = max(0, remaining.cached - rawDelta.cached)
+                            remaining.output = max(0, remaining.output - rawDelta.output)
+                            remainingInheritedTotals = if remaining.input == 0, remaining.cached == 0,
+                                                          remaining.output == 0
+                            {
+                                nil
+                            } else {
+                                remaining
+                            }
+
+                            return adjusted
+                        }
 
-            for model in modelNames {
-                let packed = models[model] ?? [0, 0, 0]
-                let input = packed[safe: 0] ?? 0
-                let cached = packed[safe: 1] ?? 0
-                let output = packed[safe: 2] ?? 0
+                        let handledUnresolvedForkTotal = hasUnresolvedForkBaseline && total != nil
+                        if hasUnresolvedForkBaseline, let total {
+                            let currentRawTotals = tokenTotals(total)
+                            defer {
+                                unresolvedForkTotalWatermark = currentRawTotals
+                            }
+                            guard let last,
+                                  let watermark = unresolvedForkTotalWatermark
+                            else {
+                                return
+                            }
+
+                            let rawLastDelta = tokenTotals(last)
+                            let rawTotalDelta = Self.codexTotalDelta(from: watermark, to: currentRawTotals)
+                            let adjustedDelta = Self.codexMinTotals(rawLastDelta, rawTotalDelta)
+                            deltaInput = adjustedDelta.input
+                            deltaCached = adjustedDelta.cached
+                            deltaOutput = adjustedDelta.output
+                            let prev = previousTotals ?? .init(input: 0, cached: 0, output: 0)
+                            previousTotals = Self.codexAddTotals(prev, adjustedDelta)
+                            rawTotalsBaseline = previousTotals
+                        }
 
-                dayInput += input
-                dayOutput += output
+                        if !handledUnresolvedForkTotal,
+                           let total,
+                           forkedFromId != nil,
+                           !hasUnresolvedForkBaseline
+                        {
+                            let rawTotals = tokenTotals(total)
+                            let currentTotals: CostUsageCodexTotals = if let inheritedTotals {
+                                CostUsageCodexTotals(
+                                    input: max(0, rawTotals.input - inheritedTotals.input),
+                                    cached: max(0, rawTotals.cached - inheritedTotals.cached),
+                                    output: max(0, rawTotals.output - inheritedTotals.output))
+                            } else {
+                                rawTotals
+                            }
+                            let delta = sawDivergentTotals
+                                ? Self.codexDivergentTotalDelta(
+                                    rawBaseline: rawTotalsBaseline,
+                                    countedBaseline: previousTotals,
+                                    current: currentTotals)
+                                : Self.codexTotalDelta(from: rawTotalsBaseline, to: currentTotals)
+                            deltaInput = delta.input
+                            deltaCached = delta.cached
+                            deltaOutput = delta.output
+                            let prev = previousTotals ?? .init(input: 0, cached: 0, output: 0)
+                            previousTotals = Self.codexAddTotals(prev, delta)
+                            rawTotalsBaseline = currentTotals
+                            if !Self.codexTotalsEqual(rawTotalsBaseline, previousTotals) {
+                                sawDivergentTotals = true
+                            }
+                            remainingInheritedTotals = nil
+                        } else if !handledUnresolvedForkTotal, let last {
+                            let rawDelta = CostUsageCodexTotals(
+                                input: max(0, toInt(last["input_tokens"])),
+                                cached: max(0, toInt(last["cached_input_tokens"] ?? last["cache_read_input_tokens"])),
+                                output: max(0, toInt(last["output_tokens"])))
+                            let hadRemainingInheritedTotals = remainingInheritedTotals != nil
+                            var adjustedDelta = adjustedLastDelta(rawDelta)
+                            deltaInput = adjustedDelta.input
+                            deltaCached = adjustedDelta.cached
+                            deltaOutput = adjustedDelta.output
+                            let prev = previousTotals ?? .init(input: 0, cached: 0, output: 0)
+
+                            if let total, !hasUnresolvedForkBaseline {
+                                let rawTotals = tokenTotals(total)
+                                let currentTotals: CostUsageCodexTotals = if let inheritedTotals {
+                                    CostUsageCodexTotals(
+                                        input: max(0, rawTotals.input - inheritedTotals.input),
+                                        cached: max(0, rawTotals.cached - inheritedTotals.cached),
+                                        output: max(0, rawTotals.output - inheritedTotals.output))
+                                } else {
+                                    rawTotals
+                                }
+                                let totalDelta = Self.codexTotalDelta(from: rawTotalsBaseline, to: currentTotals)
+                                if !hadRemainingInheritedTotals,
+                                   Self.codexShouldPreferTotalDelta(
+                                       rawBaseline: rawTotalsBaseline,
+                                       currentTotal: currentTotals,
+                                       totalDelta: totalDelta,
+                                       lastDelta: rawDelta,
+                                       sawDivergentTotals: sawDivergentTotals)
+                                {
+                                    adjustedDelta = totalDelta
+                                    deltaInput = adjustedDelta.input
+                                    deltaCached = adjustedDelta.cached
+                                    deltaOutput = adjustedDelta.output
+                                    remainingInheritedTotals = nil
+                                }
+                                let countedTotals = Self.codexAddTotals(prev, adjustedDelta)
+                                previousTotals = countedTotals
+                                rawTotalsBaseline = currentTotals
+                                if !Self.codexTotalsEqual(currentTotals, countedTotals) {
+                                    sawDivergentTotals = true
+                                }
+                            } else {
+                                let countedTotals = Self.codexAddTotals(prev, adjustedDelta)
+                                previousTotals = countedTotals
+                                rawTotalsBaseline = countedTotals
+                            }
+                        } else if !handledUnresolvedForkTotal, let total {
+                            let rawTotals = tokenTotals(total)
+
+                            let currentTotals: CostUsageCodexTotals = if let inheritedTotals {
+                                CostUsageCodexTotals(
+                                    input: max(0, rawTotals.input - inheritedTotals.input),
+                                    cached: max(0, rawTotals.cached - inheritedTotals.cached),
+                                    output: max(0, rawTotals.output - inheritedTotals.output))
+                            } else {
+                                rawTotals
+                            }
+
+                            let delta = sawDivergentTotals
+                                ? Self.codexDivergentTotalDelta(
+                                    rawBaseline: rawTotalsBaseline,
+                                    countedBaseline: previousTotals,
+                                    current: currentTotals)
+                                : Self.codexTotalDelta(from: rawTotalsBaseline, to: currentTotals)
+                            deltaInput = delta.input
+                            deltaCached = delta.cached
+                            deltaOutput = delta.output
+                            let prev = previousTotals ?? .init(input: 0, cached: 0, output: 0)
+                            previousTotals = Self.codexAddTotals(prev, delta)
+                            rawTotalsBaseline = currentTotals
+                            if !Self.codexTotalsEqual(rawTotalsBaseline, previousTotals) {
+                                sawDivergentTotals = true
+                            }
+                            remainingInheritedTotals = nil
+                        } else if !handledUnresolvedForkTotal {
+                            return
+                        }
 
-                let cost = CostUsagePricing.codexCostUSD(
-                    model: model,
-                    inputTokens: input,
-                    cachedInputTokens: cached,
-                    outputTokens: output)
-                breakdown.append(CostUsageDailyReport.ModelBreakdown(modelName: model, costUSD: cost))
-                if let cost {
-                    dayCost += cost
-                    dayCostSeen = true
-                }
+                        if deltaInput == 0, deltaCached == 0, deltaOutput == 0 { return }
+                        let cachedClamp = min(deltaCached, deltaInput)
+                        let normModel = CostUsagePricing.normalizeCodexModel(model)
+                        add(
+                            dayKey: dayKey,
+                            model: normModel,
+                            input: deltaInput,
+                            cached: cachedClamp,
+                            output: deltaOutput)
+                        if CostUsageDayRange.isInRange(
+                            dayKey: dayKey,
+                            since: range.scanSinceKey,
+                            until: range.scanUntilKey)
+                        {
+                            rows.append(CodexUsageRow(
+                                day: dayKey,
+                                model: normModel,
+                                turnID: Self.codexTurnID(from: payload) ?? currentTurnID,
+                                input: deltaInput,
+                                cached: cachedClamp,
+                                output: deltaOutput))
+                        }
+                    }
+                })
+            if let deferredError {
+                throw deferredError
             }
+        } catch is CancellationError {
+            throw CancellationError()
+        } catch {
+            self.log.warning(
+                "Codex cost usage failed while scanning session file",
+                metadata: ["path": fileURL.path, "error": error.localizedDescription])
+            parsedBytes = startOffset
+        }
 
-            breakdown.sort { lhs, rhs in (rhs.costUSD ?? -1) < (lhs.costUSD ?? -1) }
-            let top = Array(breakdown.prefix(3))
+        return CodexParseResult(
+            days: days,
+            parsedBytes: parsedBytes,
+            lastModel: currentModel,
+            lastTotals: sawDivergentTotals && !Self.codexTotalsEqual(rawTotalsBaseline, previousTotals)
+                ? nil
+                : previousTotals,
+            lastCountedTotals: previousTotals,
+            lastRawTotalsBaseline: rawTotalsBaseline,
+            hasDivergentTotals: sawDivergentTotals && !Self.codexTotalsEqual(rawTotalsBaseline, previousTotals),
+            lastCodexTurnID: currentTurnID,
+            sessionId: sessionId,
+            forkedFromId: forkedFromId,
+            rows: rows)
+    }
 
-            let dayTotal = dayInput + dayOutput
-            let entryCost = dayCostSeen ? dayCost : nil
-            entries.append(CostUsageDailyReport.Entry(
-                date: day,
-                inputTokens: dayInput,
-                outputTokens: dayOutput,
-                totalTokens: dayTotal,
-                costUSD: entryCost,
-                modelsUsed: modelNames,
-                modelBreakdowns: top))
+    private static func codexTurnID(from payload: [String: Any]) -> String? {
+        if let turnID = payload["turn_id"] as? String ?? payload["turnId"] as? String ?? payload["id"] as? String {
+            return turnID
+        }
+        if let info = payload["info"] as? [String: Any] {
+            return info["turn_id"] as? String ?? info["turnId"] as? String ?? info["id"] as? String
+        }
+        return nil
+    }
 
-            totalInput += dayInput
-            totalOutput += dayOutput
-            totalTokens += dayTotal
-            if let entryCost {
-                totalCost += entryCost
-                costSeen = true
-            }
+    private static func scanCodexFile(
+        fileURL: URL,
+        context: CodexFileScanContext,
+        cache: inout CostUsageCache,
+        state: inout CodexScanState) throws
+    {
+        try context.checkCancellation?()
+        let metadata = Self.codexFileMetadata(fileURL: fileURL)
+        if let fileId = metadata.fileId, state.seenFileIds.contains(fileId) {
+            Self.dropCachedCodexFile(path: metadata.path, cached: cache.files[metadata.path], cache: &cache)
+            return
         }
 
-        let summary: CostUsageDailyReport.Summary? = entries.isEmpty
-            ? nil
-            : CostUsageDailyReport.Summary(
-                totalInputTokens: totalInput,
-                totalOutputTokens: totalOutput,
-                totalTokens: totalTokens,
-                totalCostUSD: costSeen ? totalCost : nil)
+        let cached = cache.files[metadata.path]
+        if let cachedSessionId = cached?.sessionId, state.seenSessionIds.contains(cachedSessionId) {
+            Self.dropCachedCodexFile(path: metadata.path, cached: cached, cache: &cache)
+            return
+        }
 
-        return CostUsageDailyReport(data: entries, summary: summary)
+        let input = CodexFileScanInput(fileURL: fileURL, metadata: metadata, cached: cached)
+        if Self.keepCachedCodexFileIfFresh(input: input, context: context, cache: &cache, state: &state) {
+            return
+        }
+        if try Self.appendCodexFileIncrementIfPossible(input: input, context: context, cache: &cache, state: &state) {
+            return
+        }
+        try Self.rescanCodexFile(input: input, context: context, cache: &cache, state: &state)
     }
 
-    // MARK: - Shared cache mutations
-
-    static func makeFileUsage(
-        mtimeUnixMs: Int64,
-        size: Int64,
-        days: [String: [String: [Int]]],
-        parsedBytes: Int64?,
-        lastModel: String? = nil,
-        lastTotals: CostUsageCodexTotals? = nil,
-        sessionId: String? = nil) -> CostUsageFileUsage
+    private static func makeCodexRefreshPlan(
+        cache: CostUsageCache,
+        range: CostUsageDayRange,
+        now: Date,
+        nowMs: Int64,
+        options: Options) -> CodexRefreshPlan
     {
-        CostUsageFileUsage(
-            mtimeUnixMs: mtimeUnixMs,
-            size: size,
-            days: days,
-            parsedBytes: parsedBytes,
-            lastModel: lastModel,
-            lastTotals: lastTotals,
-            sessionId: sessionId)
+        let refreshMs = Int64(max(0, options.refreshMinIntervalSeconds) * 1000)
+        let roots = self.codexSessionsRoots(options: options)
+        let rootsFingerprint = Self.codexRootsFingerprint(roots)
+        let rootsChanged = cache.roots != rootsFingerprint
+        let windowExpanded = Self.requestedWindowExpandsCache(range: range, cache: cache)
+        let needsCostCacheMigration = cache.files.values.contains { Self.needsCodexCostCache($0, range: range) }
+        let modelsDevLoad = ModelsDevCache.load(now: now, cacheRoot: options.cacheRoot)
+        let modelsDevCatalog = modelsDevLoad.artifact?.catalog
+        let codexPricingKey = Self.codexPricingKey(modelsDevArtifact: modelsDevLoad.artifact)
+        let codexPriorityMetadataKey = Self.codexPriorityMetadataKey(databaseURL: options.codexTraceDatabaseURL)
+        let hasPriorityMetadata = codexPriorityMetadataKey.hasPrefix("sqlite:")
+        let pricingChanged = cache.codexPricingKey != nil && cache.codexPricingKey != codexPricingKey
+        let priorityMetadataChanged = Self.codexPriorityMetadataChanged(
+            old: cache.codexPriorityMetadataKey,
+            new: codexPriorityMetadataKey)
+        let needsTurnIDCacheMigration = hasPriorityMetadata && cache.files.values.contains {
+            $0.codexTurnIDs == nil && $0.touchesCodexScanWindow(
+                sinceKey: range.scanSinceKey,
+                untilKey: range.scanUntilKey)
+        }
+        let shouldInspectPriorityTurns = options.forceRescan
+            || windowExpanded
+            || rootsChanged
+            || needsCostCacheMigration
+            || needsTurnIDCacheMigration
+            || pricingChanged
+            || priorityMetadataChanged
+            || refreshMs == 0
+            || cache.lastScanUnixMs == 0
+            || nowMs - cache.lastScanUnixMs > refreshMs
+        let priorityTurns = shouldInspectPriorityTurns ? Self.codexPriorityTurns(
+            databaseURL: options.codexTraceDatabaseURL,
+            sinceDayKey: range.scanSinceKey,
+            untilDayKey: range.scanUntilKey) : [:]
+        let priorityTurnKeys = Self.codexPriorityTurnKeys(priorityTurns)
+        let priorityTurnIDsByDay = Self.codexPriorityTurnIDsByDay(priorityTurns)
+        let priorityTurnsChanged = shouldInspectPriorityTurns
+            && hasPriorityMetadata
+            && Self.codexPriorityTurnKeysChanged(
+                old: cache.codexPriorityTurnKeys,
+                new: priorityTurnKeys,
+                range: range)
+        let changedPriorityTurnIDs = shouldInspectPriorityTurns && hasPriorityMetadata
+            ? Self.changedPriorityTurnIDs(
+                old: cache.codexPriorityTurnIDsByDay,
+                new: priorityTurnIDsByDay,
+                oldKeys: cache.codexPriorityTurnKeys,
+                newKeys: priorityTurnKeys,
+                range: range)
+            : []
+        let shouldRefresh = options.forceRescan
+            || windowExpanded
+            || rootsChanged
+            || needsCostCacheMigration
+            || needsTurnIDCacheMigration
+            || pricingChanged
+            || priorityMetadataChanged
+            || priorityTurnsChanged
+            || refreshMs == 0
+            || cache.lastScanUnixMs == 0
+            || nowMs - cache.lastScanUnixMs > refreshMs
+
+        return CodexRefreshPlan(
+            refreshMs: refreshMs,
+            roots: roots,
+            rootsFingerprint: rootsFingerprint,
+            rootsChanged: rootsChanged,
+            windowExpanded: windowExpanded,
+            needsCostCacheMigration: needsCostCacheMigration,
+            modelsDevCatalog: modelsDevCatalog,
+            codexPricingKey: codexPricingKey,
+            codexPriorityMetadataKey: codexPriorityMetadataKey,
+            hasPriorityMetadata: hasPriorityMetadata,
+            priorityTurns: priorityTurns,
+            priorityTurnKeys: priorityTurnKeys,
+            priorityTurnIDsByDay: priorityTurnIDsByDay,
+            pricingChanged: pricingChanged,
+            priorityMetadataChanged: priorityMetadataChanged,
+            priorityTurnsChanged: priorityTurnsChanged,
+            needsTurnIDCacheMigration: needsTurnIDCacheMigration,
+            changedPriorityTurnIDs: changedPriorityTurnIDs,
+            shouldRefresh: shouldRefresh)
     }
 
-    static func mergeFileDays(
-        existing: inout [String: [String: [Int]]],
-        delta: [String: [String: [Int]]])
+    private static func loadCodexDaily(
+        range: CostUsageDayRange,
+        now: Date,
+        options: Options,
+        checkCancellation: CancellationCheck?) throws -> CostUsageDailyReport
     {
-        for (day, models) in delta {
-            var dayModels = existing[day] ?? [:]
-            for (model, packed) in models {
-                let existingPacked = dayModels[model] ?? []
-                let merged = Self.addPacked(a: existingPacked, b: packed, sign: 1)
-                if merged.allSatisfy({ $0 == 0 }) {
-                    dayModels.removeValue(forKey: model)
-                } else {
-                    dayModels[model] = merged
-                }
-            }
+        var cache = CostUsageCacheIO.load(provider: .codex, cacheRoot: options.cacheRoot)
+        let nowMs = Int64(now.timeIntervalSince1970 * 1000)
+        let plan = Self.makeCodexRefreshPlan(cache: cache, range: range, now: now, nowMs: nowMs, options: options)
 
-            if dayModels.isEmpty {
-                existing.removeValue(forKey: day)
-            } else {
-                existing[day] = dayModels
+        if plan.shouldRefresh {
+            try checkCancellation?()
+            if options.forceRescan {
+                cache = CostUsageCache()
             }
-        }
-    }
 
-    static func applyFileDays(cache: inout CostUsageCache, fileDays: [String: [String: [Int]]], sign: Int) {
-        for (day, models) in fileDays {
-            var dayModels = cache.days[day] ?? [:]
-            for (model, packed) in models {
-                let existing = dayModels[model] ?? []
-                let merged = Self.addPacked(a: existing, b: packed, sign: sign)
-                if merged.allSatisfy({ $0 == 0 }) {
-                    dayModels.removeValue(forKey: model)
-                } else {
-                    dayModels[model] = merged
+            let cachedSinceKey = cache.scanSinceKey
+            let cachedUntilKey = cache.scanUntilKey
+            let shouldRunColdCacheLookback = cache.files.isEmpty || plan.rootsChanged
+            let coldCacheLookbackStart = Self.parseDayKey(range.scanSinceKey)
+                .map { Calendar.current.startOfDay(for: $0) }
+            var seenPaths: Set<String> = []
+            var files: [URL] = []
+            for root in plan.roots {
+                let rootFiles = Self.listCodexSessionFiles(
+                    root: root,
+                    scanSinceKey: range.scanSinceKey,
+                    scanUntilKey: range.scanUntilKey,
+                    includeRecursive: options.forceRescan)
+                for fileURL in rootFiles.sorted(by: { $0.path < $1.path }) where !seenPaths.contains(fileURL.path) {
+                    seenPaths.insert(fileURL.path)
+                    files.append(fileURL)
                 }
-            }
 
-            if dayModels.isEmpty {
-                cache.days.removeValue(forKey: day)
-            } else {
-                cache.days[day] = dayModels
+                if shouldRunColdCacheLookback, let coldCacheLookbackStart {
+                    let recentlyModifiedFiles = Self.listCodexRecentlyModifiedFiles(
+                        root: root,
+                        scanSinceKey: range.scanSinceKey,
+                        scanUntilKey: range.scanUntilKey,
+                        modifiedSince: coldCacheLookbackStart)
+                    for fileURL in recentlyModifiedFiles.sorted(by: { $0.path < $1.path })
+                        where !seenPaths.contains(fileURL.path)
+                    {
+                        seenPaths.insert(fileURL.path)
+                        files.append(fileURL)
+                    }
+                }
             }
-        }
-    }
 
-    static func pruneDays(cache: inout CostUsageCache, sinceKey: String, untilKey: String) {
-        for key in cache.days.keys where !CostUsageDayRange.isInRange(dayKey: key, since: sinceKey, until: untilKey) {
-            cache.days.removeValue(forKey: key)
-        }
-    }
+            for fileURL in Self.cachedCodexSessionFiles(
+                cache: cache,
+                range: range,
+                roots: plan.roots,
+                excludingPaths: seenPaths)
+                .sorted(by: { $0.path < $1.path })
+            {
+                seenPaths.insert(fileURL.path)
+                files.append(fileURL)
+            }
 
-    static func addPacked(a: [Int], b: [Int], sign: Int) -> [Int] {
-        let len = max(a.count, b.count)
-        var out: [Int] = Array(repeating: 0, count: len)
-        for idx in 0..<len {
-            let next = (a[safe: idx] ?? 0) + sign * (b[safe: idx] ?? 0)
-            out[idx] = max(0, next)
-        }
-        return out
-    }
+            let filePathsInScan = Set(files.map(\.path))
+            var scanState = CodexScanState()
+            let fileIndex = CodexSessionFileIndex(
+                files: files,
+                roots: plan.roots,
+                cachedSessionFiles: Self.cachedCodexSessionIndex(
+                    cache: cache,
+                    roots: plan.roots,
+                    knownExistingPaths: filePathsInScan),
+                checkCancellation: checkCancellation)
+            let inheritedResolver = CodexInheritedTotalsResolver(
+                fileIndex: fileIndex,
+                checkCancellation: checkCancellation)
+            let resources = CodexScanResources(
+                fileIndex: fileIndex,
+                inheritedResolver: inheritedResolver,
+                modelsDevCatalog: plan.modelsDevCatalog,
+                modelsDevCacheRoot: options.cacheRoot,
+                priorityTurns: plan.priorityTurns)
+            for fileURL in files {
+                try Self.scanCodexFile(
+                    fileURL: fileURL,
+                    context: CodexFileScanContext(
+                        range: range,
+                        forceFullScan: options
+                            .forceRescan || plan.windowExpanded || plan.pricingChanged || plan.priorityMetadataChanged,
+                        dropDeferredCodexRows: options.forceRescan || plan.pricingChanged || plan
+                            .priorityMetadataChanged
+                            || plan.needsTurnIDCacheMigration,
+                        requiresTurnIDCache: plan.needsTurnIDCacheMigration,
+                        changedPriorityTurnIDs: plan.changedPriorityTurnIDs,
+                        resources: resources,
+                        checkCancellation: checkCancellation),
+                    cache: &cache,
+                    state: &scanState)
+            }
+            try checkCancellation?()
 
-    // MARK: - Date parsing
+            Self.pruneForceRescanFilesOutsideWindow(
+                cache: &cache,
+                range: range,
+                isForceRescan: options.forceRescan)
 
-    private static func parseDayKey(_ key: String) -> Date? {
-        let parts = key.split(separator: "-")
-        guard parts.count == 3 else { return nil }
-        guard
-            let y = Int(parts[0]),
-            let m = Int(parts[1]),
-            let d = Int(parts[2])
-        else { return nil }
+            let shouldDropAllUnscannedFiles = options.forceRescan || plan.rootsChanged || cache.files.isEmpty
+            for key in cache.files.keys where !filePathsInScan.contains(key) {
+                guard let old = cache.files[key] else { continue }
+                let shouldDrop = shouldDropAllUnscannedFiles ||
+                    old.touchesCodexScanWindow(sinceKey: range.scanSinceKey, untilKey: range.scanUntilKey)
+                guard shouldDrop else { continue }
+                Self.applyFileDays(cache: &cache, fileDays: old.days, sign: -1)
+                cache.files.removeValue(forKey: key)
+            }
 
-        var comps = DateComponents()
-        comps.calendar = Calendar.current
-        comps.timeZone = TimeZone.current
-        comps.year = y
-        comps.month = m
-        comps.day = d
-        comps.hour = 12
-        return comps.date
-    }
-}
+            if !shouldDropAllUnscannedFiles {
+                for key in cache.files.keys {
+                    guard let old = cache.files[key] else { continue }
+                    guard old.touchesCodexScanWindow(sinceKey: range.scanSinceKey, untilKey: range.scanUntilKey)
+                    else { continue }
+                    guard FileManager.default.fileExists(atPath: key) else {
+                        Self.applyFileDays(cache: &cache, fileDays: old.days, sign: -1)
+                        cache.files.removeValue(forKey: key)
+                        continue
+                    }
+                }
+            }
 
-extension Data {
-    func containsAscii(_ needle: String) -> Bool {
-        guard let n = needle.data(using: .utf8) else { return false }
-        return self.range(of: n) != nil
-    }
-}
+            let shouldRetainWiderWindow = !options.forceRescan && !plan.pricingChanged && !plan
+                .priorityMetadataChanged && !plan.needsTurnIDCacheMigration
+            let retainedSinceKey = shouldRetainWiderWindow
+                ? [cachedSinceKey, range.scanSinceKey].compactMap(\.self).min() ?? range.scanSinceKey
+                : range.scanSinceKey
+            let retainedUntilKey = shouldRetainWiderWindow
+                ? [cachedUntilKey, range.scanUntilKey].compactMap(\.self).max() ?? range.scanUntilKey
+                : range.scanUntilKey
+            Self.pruneDays(cache: &cache, sinceKey: retainedSinceKey, untilKey: retainedUntilKey)
+            cache.roots = plan.rootsFingerprint
+            cache.scanSinceKey = retainedSinceKey
+            cache.scanUntilKey = retainedUntilKey
+            cache.codexPricingKey = plan.codexPricingKey
+            cache.codexPriorityMetadataKey = plan.codexPriorityMetadataKey
+            if plan.hasPriorityMetadata {
+                cache.codexPriorityTurnKeys = Self.mergePriorityTurnKeys(
+                    existing: shouldRetainWiderWindow ? cache.codexPriorityTurnKeys : nil,
+                    new: plan.priorityTurnKeys,
+                    range: range,
+                    retainedSinceKey: retainedSinceKey,
+                    retainedUntilKey: retainedUntilKey)
+                cache.codexPriorityTurnIDsByDay = Self.mergePriorityTurnIDsByDay(
+                    existing: shouldRetainWiderWindow ? cache.codexPriorityTurnIDsByDay : nil,
+                    new: plan.priorityTurnIDsByDay,
+                    range: range,
+                    retainedSinceKey: retainedSinceKey,
+                    retainedUntilKey: retainedUntilKey)
+            }
+            cache.lastScanUnixMs = nowMs
+            try checkCancellation?()
+            CostUsageCacheIO.save(provider: .codex, cache: cache, cacheRoot: options.cacheRoot)
+        }
 
-extension [Int] {
-    subscript(safe index: Int) -> Int? {
-        if index < 0 { return nil }
-        if index >= self.count { return nil }
-        return self[index]
+        return Self.buildCodexReportFromCache(
+            cache: cache,
+            range: range,
+            modelsDevCatalog: plan.modelsDevCatalog,
+            modelsDevCacheRoot: options.cacheRoot,
+            priorityTurns: plan.priorityTurns)
     }
 }
 
-extension [UInt8] {
-    subscript(safe index: Int) -> UInt8? {
-        if index < 0 { return nil }
-        if index >= self.count { return nil }
-        return self[index]
-    }
-}
+// swiftlint:enable type_body_length
diff --git a/Sources/CodexBarCore/Vendored/CostUsage/ModelsDevPricing.swift b/Sources/CodexBarCore/Vendored/CostUsage/ModelsDevPricing.swift
new file mode 100644
index 0000000000..282c6e55c3
--- /dev/null
+++ b/Sources/CodexBarCore/Vendored/CostUsage/ModelsDevPricing.swift
@@ -0,0 +1,611 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+struct ModelsDevPricingInfo: Codable, Equatable {
+    var providerID: String
+    var providerName: String?
+    var modelID: String
+    var modelName: String?
+    var inputCostPerToken: Double
+    var outputCostPerToken: Double
+    var cacheReadInputCostPerToken: Double?
+    var cacheCreationInputCostPerToken: Double?
+    var contextWindow: Int?
+    var thresholdTokens: Int?
+    var inputCostPerTokenAboveThreshold: Double?
+    var outputCostPerTokenAboveThreshold: Double?
+    var cacheReadInputCostPerTokenAboveThreshold: Double?
+    var cacheCreationInputCostPerTokenAboveThreshold: Double?
+}
+
+struct ModelsDevPricingLookup: Equatable {
+    var pricing: ModelsDevPricingInfo
+    var normalizedModelID: String
+}
+
+struct ModelsDevCatalog: Codable, Equatable {
+    var providers: [String: ModelsDevProvider]
+
+    init(providers: [String: ModelsDevProvider]) {
+        self.providers = providers
+    }
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: ModelsDevAnyCodingKey.self)
+        if let providersKey = ModelsDevAnyCodingKey(stringValue: "providers"),
+           let decoded = try? container.decode([String: ModelsDevProvider].self, forKey: providersKey)
+        {
+            self.providers = decoded.reduce(into: [:]) { result, item in
+                var provider = item.value
+                provider.mapKey = provider.mapKey ?? item.key
+                let providerID = ModelsDevProvider.normalizeProviderID(provider.id ?? item.key)
+                result[providerID] = provider
+            }
+            return
+        }
+
+        var providers: [String: ModelsDevProvider] = [:]
+
+        for key in container.allKeys {
+            guard var provider = try? container.decode(ModelsDevProvider.self, forKey: key) else { continue }
+            provider.mapKey = key.stringValue
+            let providerID = ModelsDevProvider.normalizeProviderID(provider.id ?? key.stringValue)
+            providers[providerID] = provider
+        }
+
+        self.providers = providers
+    }
+
+    func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: ModelsDevAnyCodingKey.self)
+        try container.encode(self.providers, forKey: ModelsDevAnyCodingKey(stringValue: "providers")!)
+    }
+
+    func pricing(providerID rawProviderID: String, modelID rawModelID: String) -> ModelsDevPricingLookup? {
+        let providerID = ModelsDevProvider.normalizeProviderID(rawProviderID)
+        return self.providers[providerID]?.pricing(modelID: rawModelID)
+    }
+
+    func isPlausibleRefresh() -> Bool {
+        // These are the direct pricing sources CodexBar relies on. Requiring both
+        // rejects empty/partial responses without comparing against a fallback-
+        // enriched cache that intentionally grows as models.dev churns.
+        ["anthropic", "openai"].allSatisfy { providerID in
+            self.providers[providerID]?.models.values.contains(where: \.isPriceable) == true
+        }
+    }
+
+    func mergingFallbackPricing(from cachedCatalog: ModelsDevCatalog) -> ModelsDevCatalog {
+        var merged = self
+        for (providerID, cachedProvider) in cachedCatalog.providers {
+            let normalizedProviderID = ModelsDevProvider.normalizeProviderID(providerID)
+            guard var provider = merged.providers[normalizedProviderID] else {
+                merged.providers[normalizedProviderID] = cachedProvider
+                continue
+            }
+
+            for (modelKey, cachedModel) in cachedProvider.models
+                where cachedModel.isPriceable && !provider.containsPricedModel(
+                    withStableIdentity: cachedModel.stableIdentity)
+            {
+                let fallbackKey = provider.models[modelKey] == nil
+                    ? modelKey
+                    : "codexbar-fallback:\(modelKey):\(cachedModel.normalizedID)"
+                provider.models[fallbackKey] = cachedModel
+            }
+            merged.providers[normalizedProviderID] = provider
+        }
+        return merged
+    }
+}
+
+private struct ModelsDevAnyCodingKey: CodingKey {
+    var intValue: Int?
+    var stringValue: String
+
+    init?(intValue: Int) {
+        self.intValue = intValue
+        self.stringValue = String(intValue)
+    }
+
+    init?(stringValue: String) {
+        self.intValue = nil
+        self.stringValue = stringValue
+    }
+}
+
+struct ModelsDevProvider: Codable, Equatable {
+    var id: String?
+    var name: String?
+    var models: [String: ModelsDevModel]
+    var mapKey: String?
+
+    private enum CodingKeys: String, CodingKey {
+        case id
+        case name
+        case models
+    }
+
+    init(id: String?, name: String?, models: [String: ModelsDevModel], mapKey: String? = nil) {
+        self.id = id
+        self.name = name
+        self.models = models
+        self.mapKey = mapKey
+    }
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.id = try container.decodeIfPresent(String.self, forKey: .id)
+        self.name = try container.decodeIfPresent(String.self, forKey: .name)
+
+        let modelContainer = try container.nestedContainer(keyedBy: ModelsDevAnyCodingKey.self, forKey: .models)
+        var models: [String: ModelsDevModel] = [:]
+        for key in modelContainer.allKeys {
+            guard let model = try? modelContainer.decode(ModelsDevModel.self, forKey: key) else { continue }
+            models[key.stringValue] = model
+        }
+        self.models = models
+    }
+
+    func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encodeIfPresent(self.id, forKey: .id)
+        try container.encodeIfPresent(self.name, forKey: .name)
+        try container.encode(self.models, forKey: .models)
+    }
+
+    static func normalizeProviderID(_ raw: String) -> String {
+        raw.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+    }
+
+    func pricing(modelID rawModelID: String) -> ModelsDevPricingLookup? {
+        let candidates = ModelsDevModelIDNormalizer.candidates(rawModelID)
+        for candidate in candidates {
+            if let model = self.models[candidate],
+               let pricing = model.pricing(providerID: self.id ?? self.mapKey ?? "", providerName: self.name)
+            {
+                return ModelsDevPricingLookup(pricing: pricing, normalizedModelID: candidate)
+            }
+
+            for match in self.models.values where match.normalizedID == candidate {
+                if let pricing = match.pricing(providerID: self.id ?? self.mapKey ?? "", providerName: self.name) {
+                    return ModelsDevPricingLookup(pricing: pricing, normalizedModelID: match.normalizedID)
+                }
+            }
+        }
+
+        return nil
+    }
+
+    func containsPricedModel(withStableIdentity modelID: String) -> Bool {
+        self.models.values.contains { model in
+            model.isPriceable && model.stableIdentity == modelID
+        }
+    }
+}
+
+struct ModelsDevModel: Codable, Equatable {
+    var id: String
+    var name: String?
+    var cost: ModelsDevCost?
+    var limit: ModelsDevLimit?
+
+    var normalizedID: String {
+        ModelsDevModelIDNormalizer.normalize(self.id)
+    }
+
+    var stableIdentity: String {
+        ModelsDevModelIDNormalizer.stableIdentity(self.id)
+    }
+
+    var isPriceable: Bool {
+        self.cost?.input != nil && self.cost?.output != nil
+    }
+
+    func pricing(providerID: String, providerName: String?) -> ModelsDevPricingInfo? {
+        guard let input = self.cost?.input, let output = self.cost?.output else { return nil }
+
+        // models.dev publishes USD per 1M tokens. CodexBar cost math uses USD per token.
+        let unit = 1_000_000.0
+        let contextOver200K = self.cost?.contextOver200K
+        return ModelsDevPricingInfo(
+            providerID: ModelsDevProvider.normalizeProviderID(providerID),
+            providerName: providerName,
+            modelID: self.id,
+            modelName: self.name,
+            inputCostPerToken: input / unit,
+            outputCostPerToken: output / unit,
+            cacheReadInputCostPerToken: self.cost?.cacheRead.map { $0 / unit },
+            cacheCreationInputCostPerToken: self.cost?.cacheWrite.map { $0 / unit },
+            contextWindow: self.limit?.context,
+            thresholdTokens: contextOver200K == nil ? nil : 200_000,
+            inputCostPerTokenAboveThreshold: contextOver200K?.input.map { $0 / unit },
+            outputCostPerTokenAboveThreshold: contextOver200K?.output.map { $0 / unit },
+            cacheReadInputCostPerTokenAboveThreshold: contextOver200K?.cacheRead.map { $0 / unit },
+            cacheCreationInputCostPerTokenAboveThreshold: contextOver200K?.cacheWrite.map { $0 / unit })
+    }
+}
+
+struct ModelsDevCost: Codable, Equatable {
+    var input: Double?
+    var output: Double?
+    var cacheRead: Double?
+    var cacheWrite: Double?
+    var contextOver200K: ModelsDevContextOver200KCost?
+
+    private enum CodingKeys: String, CodingKey {
+        case input
+        case output
+        case cacheRead = "cache_read"
+        case cacheWrite = "cache_write"
+        case contextOver200K = "context_over_200k"
+    }
+}
+
+struct ModelsDevContextOver200KCost: Codable, Equatable {
+    var input: Double?
+    var output: Double?
+    var cacheRead: Double?
+    var cacheWrite: Double?
+
+    private enum CodingKeys: String, CodingKey {
+        case input
+        case output
+        case cacheRead = "cache_read"
+        case cacheWrite = "cache_write"
+    }
+}
+
+struct ModelsDevLimit: Codable, Equatable {
+    var context: Int?
+}
+
+enum ModelsDevModelIDNormalizer {
+    static func normalize(_ raw: String) -> String {
+        raw.trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+
+    static func stableIdentity(_ raw: String) -> String {
+        let normalized = self.normalize(raw)
+        if let atSign = normalized.firstIndex(of: "@") {
+            let base = String(normalized[..<atSign])
+            let suffix = String(normalized[normalized.index(after: atSign)...])
+            if suffix.range(of: #"^\d{8}$"#, options: .regularExpression) != nil {
+                return "\(self.canonicalAliasIdentity(base))-\(suffix)"
+            }
+        }
+
+        return self.canonicalAliasIdentity(normalized)
+    }
+
+    private static func canonicalAliasIdentity(_ raw: String) -> String {
+        self.candidates(raw, preserveDatedSnapshots: true).reversed().lazy
+            .map { candidate in
+                guard candidate.hasSuffix("@default") else { return candidate }
+                return String(candidate.dropLast("@default".count))
+            }
+            .first { !$0.isEmpty } ?? self.normalize(raw)
+    }
+
+    static func candidates(_ raw: String, preserveDatedSnapshots: Bool = false) -> [String] {
+        var candidates: [String] = []
+
+        func append(_ value: String) {
+            let normalized = self.normalize(value)
+            guard !normalized.isEmpty, !candidates.contains(normalized) else { return }
+            candidates.append(normalized)
+        }
+
+        let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines)
+        append(trimmed)
+
+        if trimmed.hasPrefix("openai/") {
+            append(String(trimmed.dropFirst("openai/".count)))
+        }
+
+        if trimmed.hasPrefix("anthropic.") {
+            append(String(trimmed.dropFirst("anthropic.".count)))
+        }
+
+        if let lastDot = trimmed.lastIndex(of: "."),
+           trimmed.contains("claude-")
+        {
+            let tail = String(trimmed[trimmed.index(after: lastDot)...])
+            if tail.hasPrefix("claude-") {
+                append(tail)
+            }
+        }
+
+        var index = 0
+        while index < candidates.count {
+            let candidate = candidates[index]
+            if let atSign = candidate.firstIndex(of: "@") {
+                let base = String(candidate[..<atSign])
+                let suffix = String(candidate[candidate.index(after: atSign)...])
+                if suffix.range(of: #"^\d{8}$"#, options: .regularExpression) != nil {
+                    append("\(base)-\(suffix)")
+                }
+                append(base)
+            } else if candidate.hasPrefix("claude-") {
+                append("\(candidate)@default")
+            }
+
+            if !preserveDatedSnapshots {
+                if let dated = candidate.range(of: #"-\d{4}-\d{2}-\d{2}$"#, options: .regularExpression) {
+                    append(String(candidate[..<dated.lowerBound]))
+                }
+                if let compactDate = candidate.range(of: #"-\d{8}$"#, options: .regularExpression) {
+                    append(String(candidate[..<compactDate.lowerBound]))
+                }
+            }
+            if let version = candidate.range(of: #"-v\d+:\d+$"#, options: .regularExpression) {
+                var base = candidate
+                base.removeSubrange(version)
+                append(base)
+            }
+
+            index += 1
+        }
+
+        return candidates
+    }
+}
+
+struct ModelsDevCacheArtifact: Codable, Equatable {
+    var version: Int
+    var fetchedAt: Date
+    var catalog: ModelsDevCatalog
+}
+
+struct ModelsDevCacheLoadResult: Equatable {
+    var artifact: ModelsDevCacheArtifact?
+    var isStale: Bool
+    var error: ModelsDevCache.Error?
+}
+
+/// In-memory memo for the decoded models.dev catalog, keyed by file path + on-disk identity.
+///
+/// `ModelsDevCache.load` is called once per usage row whenever a cost lookup is performed without a
+/// pre-resolved catalog (see `CostUsagePricing.modelsDevLookup`). Without this memo, scanning a large
+/// `~/.codex` history re-reads and re-decodes the ~800 KB catalog JSON for every row, which pegs the CPU
+/// and freezes the menu during a refresh.
+///
+/// The full load *outcome* is memoized, not just successful decodes: a corrupt or wrong-version cache is
+/// read and decode-attempted exactly as expensively as a valid one, so caching only successes would leave
+/// the per-row storm in place whenever the cache is unreadable. Reusing the outcome while the file is
+/// unchanged keeps every fallback path cheap.
+private final class ModelsDevCacheMemo: @unchecked Sendable {
+    enum Outcome {
+        case decoded(ModelsDevCacheArtifact)
+        case failure(ModelsDevCache.Error)
+    }
+
+    private struct Entry {
+        let modificationDate: Date?
+        let size: Int?
+        let outcome: Outcome
+    }
+
+    private let lock = NSLock()
+    private var entries: [String: Entry] = [:]
+
+    func outcome(path: String, modificationDate: Date?, size: Int?) -> Outcome? {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        guard let entry = self.entries[path],
+              entry.modificationDate == modificationDate,
+              entry.size == size
+        else {
+            return nil
+        }
+        return entry.outcome
+    }
+
+    func store(path: String, modificationDate: Date?, size: Int?, outcome: Outcome) {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        self.entries[path] = Entry(modificationDate: modificationDate, size: size, outcome: outcome)
+    }
+
+    func invalidate(path: String) {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        self.entries.removeValue(forKey: path)
+    }
+}
+
+enum ModelsDevCache {
+    enum Error: Swift.Error, Equatable {
+        case unreadable
+        case invalidVersion
+        case invalidJSON
+    }
+
+    static let artifactVersion = 1
+    static let ttlSeconds: TimeInterval = 24 * 60 * 60
+
+    private static let memo = ModelsDevCacheMemo()
+
+    private static func fileMetadata(at url: URL) -> (modificationDate: Date?, size: Int?) {
+        guard let attributes = try? FileManager.default.attributesOfItem(atPath: url.path) else {
+            return (nil, nil)
+        }
+        let modificationDate = attributes[.modificationDate] as? Date
+        let size = (attributes[.size] as? NSNumber)?.intValue
+        return (modificationDate, size)
+    }
+
+    private static func defaultCacheRoot() -> URL {
+        let root = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first!
+        return root.appendingPathComponent("CodexBar", isDirectory: true)
+    }
+
+    static func cacheFileURL(cacheRoot: URL? = nil) -> URL {
+        let root = cacheRoot ?? self.defaultCacheRoot()
+        return root
+            .appendingPathComponent("model-pricing", isDirectory: true)
+            .appendingPathComponent("models-dev-v\(Self.artifactVersion).json", isDirectory: false)
+    }
+
+    static func load(now: Date = Date(), cacheRoot: URL? = nil) -> ModelsDevCacheLoadResult {
+        let url = self.cacheFileURL(cacheRoot: cacheRoot)
+        let metadata = Self.fileMetadata(at: url)
+
+        // Staleness depends on `now`, so the result is always rebuilt; only the read+decode outcome is memoized.
+        if let outcome = Self.memo.outcome(
+            path: url.path,
+            modificationDate: metadata.modificationDate,
+            size: metadata.size)
+        {
+            return Self.result(for: outcome, now: now)
+        }
+
+        let outcome = Self.readOutcome(at: url)
+        Self.memo.store(
+            path: url.path,
+            modificationDate: metadata.modificationDate,
+            size: metadata.size,
+            outcome: outcome)
+        return Self.result(for: outcome, now: now)
+    }
+
+    private static func readOutcome(at url: URL) -> ModelsDevCacheMemo.Outcome {
+        guard let data = try? Data(contentsOf: url) else {
+            return .failure(.unreadable)
+        }
+
+        let decoder = JSONDecoder()
+        decoder.dateDecodingStrategy = .iso8601
+        guard let decoded = try? decoder.decode(ModelsDevCacheArtifact.self, from: data) else {
+            return .failure(.invalidJSON)
+        }
+        guard decoded.version == Self.artifactVersion else {
+            return .failure(.invalidVersion)
+        }
+        return .decoded(decoded)
+    }
+
+    private static func result(for outcome: ModelsDevCacheMemo.Outcome, now: Date) -> ModelsDevCacheLoadResult {
+        switch outcome {
+        case let .decoded(artifact):
+            ModelsDevCacheLoadResult(
+                artifact: artifact,
+                isStale: now.timeIntervalSince(artifact.fetchedAt) > Self.ttlSeconds,
+                error: nil)
+        case let .failure(error):
+            ModelsDevCacheLoadResult(artifact: nil, isStale: true, error: error)
+        }
+    }
+
+    static func save(catalog: ModelsDevCatalog, fetchedAt: Date = Date(), cacheRoot: URL? = nil) {
+        let artifact = ModelsDevCacheArtifact(
+            version: Self.artifactVersion,
+            fetchedAt: fetchedAt,
+            catalog: catalog)
+        self.save(artifact: artifact, cacheRoot: cacheRoot)
+    }
+
+    static func save(artifact: ModelsDevCacheArtifact, cacheRoot: URL? = nil) {
+        let url = self.cacheFileURL(cacheRoot: cacheRoot)
+        let dir = url.deletingLastPathComponent()
+        try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+
+        let encoder = JSONEncoder()
+        encoder.dateEncodingStrategy = .iso8601
+        guard let data = try? encoder.encode(artifact) else { return }
+
+        let tmp = dir.appendingPathComponent(".tmp-\(UUID().uuidString).json", isDirectory: false)
+        do {
+            try data.write(to: tmp, options: [.atomic])
+            if FileManager.default.fileExists(atPath: url.path) {
+                _ = try FileManager.default.replaceItemAt(url, withItemAt: tmp)
+            } else {
+                try FileManager.default.moveItem(at: tmp, to: url)
+            }
+            // The on-disk catalog changed; drop the memo so the next load decodes the fresh file.
+            Self.memo.invalidate(path: url.path)
+        } catch {
+            try? FileManager.default.removeItem(at: tmp)
+        }
+    }
+}
+
+protocol ModelsDevHTTPTransport: Sendable {
+    func data(for request: URLRequest) async throws -> (Data, URLResponse)
+}
+
+struct URLSessionModelsDevTransport: ModelsDevHTTPTransport {
+    func data(for request: URLRequest) async throws -> (Data, URLResponse) {
+        try await URLSession.shared.data(for: request)
+    }
+}
+
+struct ModelsDevClient {
+    enum Error: Swift.Error, Equatable {
+        case invalidResponse
+        case httpStatus(Int)
+        case invalidJSON
+    }
+
+    var url: URL
+    var transport: any ModelsDevHTTPTransport
+
+    init(
+        url: URL = URL(string: "https://models.dev/api.json")!,
+        transport: any ModelsDevHTTPTransport = URLSessionModelsDevTransport())
+    {
+        self.url = url
+        self.transport = transport
+    }
+
+    func fetchCatalog() async throws -> ModelsDevCatalog {
+        var request = URLRequest(url: self.url)
+        request.httpMethod = "GET"
+        request.timeoutInterval = 20
+
+        let (data, response) = try await self.transport.data(for: request)
+        guard let http = response as? HTTPURLResponse else { throw Error.invalidResponse }
+        guard (200..<300).contains(http.statusCode) else { throw Error.httpStatus(http.statusCode) }
+
+        do {
+            return try JSONDecoder().decode(ModelsDevCatalog.self, from: data)
+        } catch {
+            throw Error.invalidJSON
+        }
+    }
+}
+
+enum ModelsDevPricingPipeline {
+    static func lookup(
+        providerID: String,
+        modelID: String,
+        now: Date = Date(),
+        cacheRoot: URL? = nil) -> ModelsDevPricingLookup?
+    {
+        ModelsDevCache.load(now: now, cacheRoot: cacheRoot)
+            .artifact?
+            .catalog
+            .pricing(providerID: providerID, modelID: modelID)
+    }
+
+    static func refreshIfNeeded(
+        now: Date = Date(),
+        cacheRoot: URL? = nil,
+        client: ModelsDevClient = ModelsDevClient()) async
+    {
+        let load = ModelsDevCache.load(now: now, cacheRoot: cacheRoot)
+        guard load.isStale else { return }
+
+        do {
+            let catalog = try await client.fetchCatalog()
+            let oldCatalog = load.artifact?.catalog
+            guard catalog.isPlausibleRefresh() else { return }
+            let refreshedCatalog = oldCatalog.map { catalog.mergingFallbackPricing(from: $0) } ?? catalog
+            ModelsDevCache.save(catalog: refreshedCatalog, fetchedAt: now, cacheRoot: cacheRoot)
+        } catch {
+            // Best-effort refresh only. Future scanner integration should keep using the last valid cache.
+        }
+    }
+}
diff --git a/Sources/CodexBarCore/WidgetSnapshot.swift b/Sources/CodexBarCore/WidgetSnapshot.swift
index 25a2f85b9c..17affa8b1c 100644
--- a/Sources/CodexBarCore/WidgetSnapshot.swift
+++ b/Sources/CodexBarCore/WidgetSnapshot.swift
@@ -1,12 +1,25 @@
 import Foundation
 
 public struct WidgetSnapshot: Codable, Sendable {
+    public struct WidgetUsageRowSnapshot: Codable, Equatable, Sendable {
+        public let id: String
+        public let title: String
+        public let percentLeft: Double?
+
+        public init(id: String, title: String, percentLeft: Double?) {
+            self.id = id
+            self.title = title
+            self.percentLeft = percentLeft
+        }
+    }
+
     public struct ProviderEntry: Codable, Sendable {
         public let provider: UsageProvider
         public let updatedAt: Date
         public let primary: RateWindow?
         public let secondary: RateWindow?
         public let tertiary: RateWindow?
+        public let usageRows: [WidgetUsageRowSnapshot]?
         public let creditsRemaining: Double?
         public let codeReviewRemainingPercent: Double?
         public let tokenUsage: TokenUsageSummary?
@@ -18,6 +31,7 @@ public struct WidgetSnapshot: Codable, Sendable {
             primary: RateWindow?,
             secondary: RateWindow?,
             tertiary: RateWindow?,
+            usageRows: [WidgetUsageRowSnapshot]? = nil,
             creditsRemaining: Double?,
             codeReviewRemainingPercent: Double?,
             tokenUsage: TokenUsageSummary?,
@@ -28,6 +42,7 @@ public struct WidgetSnapshot: Codable, Sendable {
             self.primary = primary
             self.secondary = secondary
             self.tertiary = tertiary
+            self.usageRows = usageRows
             self.creditsRemaining = creditsRemaining
             self.codeReviewRemainingPercent = codeReviewRemainingPercent
             self.tokenUsage = tokenUsage
@@ -40,17 +55,54 @@ public struct WidgetSnapshot: Codable, Sendable {
         public let sessionTokens: Int?
         public let last30DaysCostUSD: Double?
         public let last30DaysTokens: Int?
+        public let currencyCode: String
+        public let sessionLabel: String
+        public let last30DaysLabel: String
 
         public init(
             sessionCostUSD: Double?,
             sessionTokens: Int?,
             last30DaysCostUSD: Double?,
-            last30DaysTokens: Int?)
+            last30DaysTokens: Int?,
+            currencyCode: String = "USD",
+            sessionLabel: String = "Today",
+            last30DaysLabel: String = "30d")
         {
             self.sessionCostUSD = sessionCostUSD
             self.sessionTokens = sessionTokens
             self.last30DaysCostUSD = last30DaysCostUSD
             self.last30DaysTokens = last30DaysTokens
+            self.currencyCode = currencyCode.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+                ? "USD"
+                : currencyCode.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()
+            self.sessionLabel = sessionLabel.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+                ? "Today"
+                : sessionLabel
+            self.last30DaysLabel = last30DaysLabel.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+                ? "30d"
+                : last30DaysLabel
+        }
+
+        private enum CodingKeys: String, CodingKey {
+            case sessionCostUSD
+            case sessionTokens
+            case last30DaysCostUSD
+            case last30DaysTokens
+            case currencyCode
+            case sessionLabel
+            case last30DaysLabel
+        }
+
+        public init(from decoder: Decoder) throws {
+            let container = try decoder.container(keyedBy: CodingKeys.self)
+            try self.init(
+                sessionCostUSD: container.decodeIfPresent(Double.self, forKey: .sessionCostUSD),
+                sessionTokens: container.decodeIfPresent(Int.self, forKey: .sessionTokens),
+                last30DaysCostUSD: container.decodeIfPresent(Double.self, forKey: .last30DaysCostUSD),
+                last30DaysTokens: container.decodeIfPresent(Int.self, forKey: .last30DaysTokens),
+                currencyCode: container.decodeIfPresent(String.self, forKey: .currencyCode) ?? "USD",
+                sessionLabel: container.decodeIfPresent(String.self, forKey: .sessionLabel) ?? "Today",
+                last30DaysLabel: container.decodeIfPresent(String.self, forKey: .last30DaysLabel) ?? "30d")
         }
     }
 
@@ -99,17 +151,16 @@ public struct WidgetSnapshot: Codable, Sendable {
 }
 
 public enum WidgetSnapshotStore {
-    public static let appGroupID = "group.com.steipete.codexbar"
-    private static let filename = "widget-snapshot.json"
+    private static let filename = AppGroupSupport.widgetSnapshotFilename
 
     public static func load(bundleID: String? = Bundle.main.bundleIdentifier) -> WidgetSnapshot? {
-        guard let url = self.snapshotURL(bundleID: bundleID) else { return nil }
+        let url = self.snapshotURL(bundleID: bundleID)
         guard let data = try? Data(contentsOf: url) else { return nil }
         return try? self.decoder.decode(WidgetSnapshot.self, from: data)
     }
 
     public static func save(_ snapshot: WidgetSnapshot, bundleID: String? = Bundle.main.bundleIdentifier) {
-        guard let url = self.snapshotURL(bundleID: bundleID) else { return }
+        let url = self.snapshotURL(bundleID: bundleID)
         do {
             let data = try self.encoder.encode(snapshot)
             try data.write(to: url, options: [.atomic])
@@ -118,32 +169,12 @@ public enum WidgetSnapshotStore {
         }
     }
 
-    private static func snapshotURL(bundleID: String?) -> URL? {
-        let fm = FileManager.default
-        let groupID = self.groupID(for: bundleID)
-        #if os(macOS)
-        if let groupID, let container = fm.containerURL(forSecurityApplicationGroupIdentifier: groupID) {
-            return container.appendingPathComponent(self.filename, isDirectory: false)
-        }
-        #endif
-
-        let base = fm.urls(for: .applicationSupportDirectory, in: .userDomainMask).first
-            ?? fm.temporaryDirectory
-        let dir = base.appendingPathComponent("CodexBar", isDirectory: true)
-        try? fm.createDirectory(at: dir, withIntermediateDirectories: true)
-        return dir.appendingPathComponent(self.filename, isDirectory: false)
+    private static func snapshotURL(bundleID: String?) -> URL {
+        AppGroupSupport.snapshotURL(bundleID: bundleID)
     }
 
     public static func appGroupID(for bundleID: String?) -> String? {
-        self.groupID(for: bundleID)
-    }
-
-    private static func groupID(for bundleID: String?) -> String? {
-        guard let bundleID, !bundleID.isEmpty else { return self.appGroupID }
-        if bundleID.contains(".debug") {
-            return "group.com.steipete.codexbar.debug"
-        }
-        return self.appGroupID
+        AppGroupSupport.currentGroupID(for: bundleID)
     }
 
     private static var encoder: JSONEncoder {
@@ -163,7 +194,7 @@ public enum WidgetSelectionStore {
     private static let selectedProviderKey = "widgetSelectedProvider"
 
     public static func loadSelectedProvider(bundleID: String? = Bundle.main.bundleIdentifier) -> UsageProvider? {
-        guard let defaults = self.sharedDefaults(bundleID: bundleID) else { return nil }
+        let defaults = self.sharedDefaults(bundleID: bundleID)
         guard let raw = defaults.string(forKey: self.selectedProviderKey) else { return nil }
         return UsageProvider(rawValue: raw)
     }
@@ -172,12 +203,11 @@ public enum WidgetSelectionStore {
         _ provider: UsageProvider,
         bundleID: String? = Bundle.main.bundleIdentifier)
     {
-        guard let defaults = self.sharedDefaults(bundleID: bundleID) else { return }
+        let defaults = self.sharedDefaults(bundleID: bundleID)
         defaults.set(provider.rawValue, forKey: self.selectedProviderKey)
     }
 
-    private static func sharedDefaults(bundleID: String?) -> UserDefaults? {
-        guard let groupID = WidgetSnapshotStore.appGroupID(for: bundleID) else { return nil }
-        return UserDefaults(suiteName: groupID)
+    private static func sharedDefaults(bundleID: String?) -> UserDefaults {
+        AppGroupSupport.sharedDefaults(bundleID: bundleID) ?? .standard
     }
 }
diff --git a/Sources/CodexBarMacroSupport/ProviderRegistrationMacros.swift b/Sources/CodexBarMacroSupport/ProviderRegistrationMacros.swift
deleted file mode 100644
index 4adf0218b4..0000000000
--- a/Sources/CodexBarMacroSupport/ProviderRegistrationMacros.swift
+++ /dev/null
@@ -1,14 +0,0 @@
-@attached(peer, names: prefixed(_CodexBarDescriptorRegistration_))
-public macro ProviderDescriptorRegistration() = #externalMacro(
-    module: "CodexBarMacros",
-    type: "ProviderDescriptorRegistrationMacro")
-
-@attached(member, names: named(descriptor))
-public macro ProviderDescriptorDefinition() = #externalMacro(
-    module: "CodexBarMacros",
-    type: "ProviderDescriptorDefinitionMacro")
-
-@attached(peer, names: prefixed(_CodexBarImplementationRegistration_))
-public macro ProviderImplementationRegistration() = #externalMacro(
-    module: "CodexBarMacros",
-    type: "ProviderImplementationRegistrationMacro")
diff --git a/Sources/CodexBarMacros/ProviderRegistrationMacros.swift b/Sources/CodexBarMacros/ProviderRegistrationMacros.swift
deleted file mode 100644
index 1072e73fec..0000000000
--- a/Sources/CodexBarMacros/ProviderRegistrationMacros.swift
+++ /dev/null
@@ -1,216 +0,0 @@
-import SwiftCompilerPlugin
-import SwiftDiagnostics
-import SwiftSyntax
-import SwiftSyntaxBuilder
-import SwiftSyntaxMacros
-
-private enum ProviderMacroError {
-    struct Message: DiagnosticMessage {
-        let message: String
-        let diagnosticID: MessageID
-        let severity: DiagnosticSeverity
-    }
-
-    static func unsupportedTarget(_ context: some MacroExpansionContext, node: SyntaxProtocol, macro: String) {
-        context.diagnose(Diagnostic(
-            node: node,
-            message: Message(
-                message: "@\(macro) must be attached to a struct, class, or enum.",
-                diagnosticID: MessageID(domain: "CodexBarMacros", id: "unsupported_target"),
-                severity: .error)))
-    }
-
-    static func missingDescriptor(_ context: some MacroExpansionContext, node: SyntaxProtocol, typeName: String) {
-        context.diagnose(Diagnostic(
-            node: node,
-            message: Message(
-                message: "\(typeName) must declare static let descriptor or static func makeDescriptor() " +
-                    "to use @ProviderDescriptorRegistration.",
-                diagnosticID: MessageID(domain: "CodexBarMacros", id: "missing_descriptor"),
-                severity: .error)))
-    }
-
-    static func missingMakeDescriptor(_ context: some MacroExpansionContext, node: SyntaxProtocol, typeName: String) {
-        context.diagnose(Diagnostic(
-            node: node,
-            message: Message(
-                message: "\(typeName) must declare static func makeDescriptor() to use @ProviderDescriptorDefinition.",
-                diagnosticID: MessageID(domain: "CodexBarMacros", id: "missing_make_descriptor"),
-                severity: .error)))
-    }
-
-    static func duplicateDescriptor(_ context: some MacroExpansionContext, node: SyntaxProtocol, typeName: String) {
-        context.diagnose(Diagnostic(
-            node: node,
-            message: Message(
-                message: "\(typeName) already declares descriptor; remove @ProviderDescriptorDefinition.",
-                diagnosticID: MessageID(domain: "CodexBarMacros", id: "duplicate_descriptor"),
-                severity: .error)))
-    }
-
-    static func missingInit(_ context: some MacroExpansionContext, node: SyntaxProtocol, typeName: String) {
-        context.diagnose(Diagnostic(
-            node: node,
-            message: Message(
-                message: "\(typeName) must provide an init() to use @ProviderImplementationRegistration.",
-                diagnosticID: MessageID(domain: "CodexBarMacros", id: "missing_init"),
-                severity: .error)))
-    }
-}
-
-private enum ProviderMacroIntrospection {
-    static func typeDecl(from declaration: some DeclSyntaxProtocol) -> (decl: DeclGroupSyntax, name: String)? {
-        if let decl = declaration.as(StructDeclSyntax.self) { return (decl, decl.name.text) }
-        if let decl = declaration.as(ClassDeclSyntax.self) { return (decl, decl.name.text) }
-        if let decl = declaration.as(EnumDeclSyntax.self) { return (decl, decl.name.text) }
-        return nil
-    }
-
-    static func hasStaticDescriptor(in decl: DeclGroupSyntax) -> Bool {
-        for member in decl.memberBlock.members {
-            guard let varDecl = member.decl.as(VariableDeclSyntax.self) else { continue }
-            guard self.isStatic(varDecl.modifiers) else { continue }
-            for binding in varDecl.bindings {
-                guard let pattern = binding.pattern.as(IdentifierPatternSyntax.self) else { continue }
-                if pattern.identifier.text == "descriptor" { return true }
-            }
-        }
-        return false
-    }
-
-    static func hasMakeDescriptor(in decl: DeclGroupSyntax) -> Bool {
-        for member in decl.memberBlock.members {
-            guard let funcDecl = member.decl.as(FunctionDeclSyntax.self) else { continue }
-            guard self.isStatic(funcDecl.modifiers) else { continue }
-            if funcDecl.name.text == "makeDescriptor" { return true }
-        }
-        return false
-    }
-
-    static func hasAccessibleInit(in decl: DeclGroupSyntax) -> Bool {
-        if self.hasZeroArgInit(in: decl) { return true }
-        if decl.is(EnumDeclSyntax.self) { return false }
-        return self.canSynthesizeDefaultInit(in: decl)
-    }
-
-    private static func hasZeroArgInit(in decl: DeclGroupSyntax) -> Bool {
-        for member in decl.memberBlock.members {
-            guard let initDecl = member.decl.as(InitializerDeclSyntax.self) else { continue }
-            let params = initDecl.signature.parameterClause.parameters
-            if params.isEmpty { return true }
-            let allDefaulted = params.allSatisfy { $0.defaultValue != nil }
-            if allDefaulted { return true }
-        }
-        return false
-    }
-
-    private static func canSynthesizeDefaultInit(in decl: DeclGroupSyntax) -> Bool {
-        for member in decl.memberBlock.members {
-            guard let varDecl = member.decl.as(VariableDeclSyntax.self) else { continue }
-            guard !self.isStatic(varDecl.modifiers) else { continue }
-            for binding in varDecl.bindings {
-                if binding.accessorBlock != nil { continue }
-                if binding.initializer == nil { return false }
-            }
-        }
-        return true
-    }
-
-    private static func isStatic(_ modifiers: DeclModifierListSyntax?) -> Bool {
-        guard let modifiers else { return false }
-        return modifiers.contains { $0.name.tokenKind == .keyword(.static) }
-    }
-}
-
-public struct ProviderDescriptorRegistrationMacro: PeerMacro {
-    public static func expansion(
-        of _: AttributeSyntax,
-        providingPeersOf declaration: some DeclSyntaxProtocol,
-        in context: some MacroExpansionContext) throws -> [DeclSyntax]
-    {
-        guard let (decl, typeName) = ProviderMacroIntrospection.typeDecl(from: declaration) else {
-            ProviderMacroError.unsupportedTarget(
-                context,
-                node: Syntax(declaration),
-                macro: "ProviderDescriptorRegistration")
-            return []
-        }
-
-        let hasDescriptor = ProviderMacroIntrospection.hasStaticDescriptor(in: decl)
-        let hasMakeDescriptor = ProviderMacroIntrospection.hasMakeDescriptor(in: decl)
-        guard hasDescriptor || hasMakeDescriptor else {
-            ProviderMacroError.missingDescriptor(context, node: Syntax(declaration), typeName: typeName)
-            return []
-        }
-
-        let registerName = "_CodexBarDescriptorRegistration_\(typeName)"
-        return [
-            DeclSyntax(
-                "private let \(raw: registerName) = ProviderDescriptorRegistry.register(\(raw: typeName).descriptor)"),
-        ]
-    }
-}
-
-public struct ProviderDescriptorDefinitionMacro: MemberMacro {
-    public static func expansion(
-        of _: AttributeSyntax,
-        providingMembersOf declaration: some DeclGroupSyntax,
-        in context: some MacroExpansionContext) throws -> [DeclSyntax]
-    {
-        guard let (decl, typeName) = ProviderMacroIntrospection.typeDecl(from: declaration) else {
-            ProviderMacroError.unsupportedTarget(
-                context,
-                node: Syntax(declaration),
-                macro: "ProviderDescriptorDefinition")
-            return []
-        }
-
-        if ProviderMacroIntrospection.hasStaticDescriptor(in: decl) {
-            ProviderMacroError.duplicateDescriptor(context, node: Syntax(declaration), typeName: typeName)
-            return []
-        }
-
-        guard ProviderMacroIntrospection.hasMakeDescriptor(in: decl) else {
-            ProviderMacroError.missingMakeDescriptor(context, node: Syntax(declaration), typeName: typeName)
-            return []
-        }
-
-        return [DeclSyntax("public static let descriptor: ProviderDescriptor = Self.makeDescriptor()")]
-    }
-}
-
-public struct ProviderImplementationRegistrationMacro: PeerMacro {
-    public static func expansion(
-        of _: AttributeSyntax,
-        providingPeersOf declaration: some DeclSyntaxProtocol,
-        in context: some MacroExpansionContext) throws -> [DeclSyntax]
-    {
-        guard let (decl, typeName) = ProviderMacroIntrospection.typeDecl(from: declaration) else {
-            ProviderMacroError.unsupportedTarget(
-                context,
-                node: Syntax(declaration),
-                macro: "ProviderImplementationRegistration")
-            return []
-        }
-
-        guard ProviderMacroIntrospection.hasAccessibleInit(in: decl) else {
-            ProviderMacroError.missingInit(context, node: Syntax(declaration), typeName: typeName)
-            return []
-        }
-
-        let registerName = "_CodexBarImplementationRegistration_\(typeName)"
-        return [
-            DeclSyntax(
-                "private let \(raw: registerName) = ProviderImplementationRegistry.register(\(raw: typeName)())"),
-        ]
-    }
-}
-
-@main
-struct CodexBarMacroPlugin: CompilerPlugin {
-    let providingMacros: [Macro.Type] = [
-        ProviderDescriptorRegistrationMacro.self,
-        ProviderDescriptorDefinitionMacro.self,
-        ProviderImplementationRegistrationMacro.self,
-    ]
-}
diff --git a/Sources/CodexBarWidget/BurnDownWidgetProvider.swift b/Sources/CodexBarWidget/BurnDownWidgetProvider.swift
new file mode 100644
index 0000000000..34f70535e9
--- /dev/null
+++ b/Sources/CodexBarWidget/BurnDownWidgetProvider.swift
@@ -0,0 +1,228 @@
+import AppIntents
+import CodexBarCore
+import WidgetKit
+
+enum BurnProviderChoice: String, AppEnum {
+    case codex
+    case claude
+
+    static let typeDisplayRepresentation = TypeDisplayRepresentation(name: "Provider")
+
+    static let caseDisplayRepresentations: [BurnProviderChoice: DisplayRepresentation] = [
+        .codex: DisplayRepresentation(title: "Codex"),
+        .claude: DisplayRepresentation(title: "Claude"),
+    ]
+
+    var provider: UsageProvider {
+        switch self {
+        case .codex: .codex
+        case .claude: .claude
+        }
+    }
+}
+
+enum BurnWindowChoice: String, AppEnum {
+    case session
+    case weekly
+
+    static let typeDisplayRepresentation = TypeDisplayRepresentation(name: "Usage window")
+
+    static let caseDisplayRepresentations: [BurnWindowChoice: DisplayRepresentation] = [
+        .session: DisplayRepresentation(title: "Session (5-hour)"),
+        .weekly: DisplayRepresentation(title: "Weekly (7-day)"),
+    ]
+}
+
+struct BurnDownSelectionIntent: AppIntent, WidgetConfigurationIntent {
+    static let title: LocalizedStringResource = "Burn Down"
+    static let description = IntentDescription("Select the provider and usage window to display.")
+
+    @Parameter(title: "Provider", default: .codex)
+    var provider: BurnProviderChoice
+
+    @Parameter(title: "Usage window", default: .session)
+    var window: BurnWindowChoice
+
+    init() {
+        self.provider = .codex
+        self.window = .session
+    }
+}
+
+struct BurnProviderSelectionIntent: AppIntent, WidgetConfigurationIntent {
+    static let title: LocalizedStringResource = "Burn Down Provider"
+    static let description = IntentDescription("Select the provider to display.")
+
+    @Parameter(title: "Provider", default: .codex)
+    var provider: BurnProviderChoice
+
+    init() {
+        self.provider = .codex
+    }
+}
+
+struct BurnDownEntry: TimelineEntry {
+    let date: Date
+    let provider: UsageProvider
+    let window: BurnWindowChoice
+    let snapshot: WidgetSnapshot
+}
+
+struct CombinedBurnDownEntry: TimelineEntry {
+    let date: Date
+    let provider: UsageProvider
+    let snapshot: WidgetSnapshot
+}
+
+struct BurnDownState {
+    private static let sessionWindowMinutes = 5 * 60
+    private static let weeklyWindowMinutes = 7 * 24 * 60
+
+    let entry: WidgetSnapshot.ProviderEntry
+    let selection: BurnWindowChoice
+    let now: Date
+
+    init?(
+        snapshot: WidgetSnapshot,
+        provider: UsageProvider,
+        selection: BurnWindowChoice,
+        now: Date = Date())
+    {
+        guard let entry = snapshot.entries.first(where: { $0.provider == provider }) else { return nil }
+        self.entry = entry
+        self.selection = selection
+        self.now = now
+    }
+
+    var secondaryGloballyCapsPrimary: Bool {
+        switch self.entry.provider {
+        case .codex, .claude: true
+        default: false
+        }
+    }
+
+    var secondaryExhausted: Bool {
+        guard self.secondaryGloballyCapsPrimary, let secondary = self.secondaryWindow else { return false }
+        guard secondary.remainingPercent <= 0 else { return false }
+        return secondary.resetsAt.map { $0 > self.now } ?? true
+    }
+
+    var primaryWindow: RateWindow? {
+        guard let primary = self.window(minutes: Self.sessionWindowMinutes) else { return nil }
+        guard self.secondaryExhausted, primary.remainingPercent > 0 else { return primary }
+        return RateWindow(
+            usedPercent: 100,
+            windowMinutes: primary.windowMinutes,
+            resetsAt: primary.resetsAt,
+            resetDescription: primary.resetDescription,
+            nextRegenPercent: primary.nextRegenPercent)
+    }
+
+    var secondaryWindow: RateWindow? {
+        self.window(minutes: Self.weeklyWindowMinutes)
+    }
+
+    var selectedWindow: RateWindow? {
+        switch self.selection {
+        case .session: self.primaryWindow
+        case .weekly: self.secondaryWindow
+        }
+    }
+
+    var blankPrimaryChart: Bool {
+        self.selection == .session
+            && self.secondaryExhausted
+            && self.window(minutes: Self.sessionWindowMinutes) != nil
+    }
+
+    var selectedResetOverride: Date? {
+        self.blankPrimaryChart ? self.secondaryWindow?.resetsAt : nil
+    }
+
+    private func window(minutes: Int) -> RateWindow? {
+        [self.entry.primary, self.entry.secondary]
+            .compactMap(\.self)
+            .first { $0.windowMinutes == minutes }
+    }
+}
+
+enum BurnDownRefreshSchedule {
+    private static let maximumInterval: TimeInterval = 30 * 60
+
+    static func nextRefresh(
+        snapshot: WidgetSnapshot,
+        provider: UsageProvider,
+        now: Date = Date()) -> Date
+    {
+        let fallback = now.addingTimeInterval(self.maximumInterval)
+        guard let entry = snapshot.entries.first(where: { $0.provider == provider }) else { return fallback }
+        let nextReset = [entry.primary?.resetsAt, entry.secondary?.resetsAt]
+            .compactMap(\.self)
+            .filter { $0 > now }
+            .min()?
+            .addingTimeInterval(1)
+        return min(fallback, nextReset ?? fallback)
+    }
+}
+
+struct BurnDownTimelineProvider: AppIntentTimelineProvider {
+    func placeholder(in context: Context) -> BurnDownEntry {
+        BurnDownEntry(
+            date: Date(),
+            provider: .codex,
+            window: .session,
+            snapshot: WidgetPreviewData.snapshot())
+    }
+
+    func snapshot(for configuration: BurnDownSelectionIntent, in context: Context) async -> BurnDownEntry {
+        BurnDownEntry(
+            date: Date(),
+            provider: configuration.provider.provider,
+            window: configuration.window,
+            snapshot: WidgetSnapshotStore.load() ?? WidgetPreviewData.snapshot())
+    }
+
+    func timeline(
+        for configuration: BurnDownSelectionIntent,
+        in context: Context) async -> Timeline<BurnDownEntry>
+    {
+        let entry = BurnDownEntry(
+            date: Date(),
+            provider: configuration.provider.provider,
+            window: configuration.window,
+            snapshot: WidgetSnapshotStore.load() ?? WidgetPreviewData.emptySnapshot())
+        let refresh = BurnDownRefreshSchedule.nextRefresh(snapshot: entry.snapshot, provider: entry.provider)
+        return Timeline(entries: [entry], policy: .after(refresh))
+    }
+}
+
+struct CombinedBurnDownTimelineProvider: AppIntentTimelineProvider {
+    func placeholder(in context: Context) -> CombinedBurnDownEntry {
+        CombinedBurnDownEntry(
+            date: Date(),
+            provider: .codex,
+            snapshot: WidgetPreviewData.snapshot())
+    }
+
+    func snapshot(
+        for configuration: BurnProviderSelectionIntent,
+        in context: Context) async -> CombinedBurnDownEntry
+    {
+        CombinedBurnDownEntry(
+            date: Date(),
+            provider: configuration.provider.provider,
+            snapshot: WidgetSnapshotStore.load() ?? WidgetPreviewData.snapshot())
+    }
+
+    func timeline(
+        for configuration: BurnProviderSelectionIntent,
+        in context: Context) async -> Timeline<CombinedBurnDownEntry>
+    {
+        let entry = CombinedBurnDownEntry(
+            date: Date(),
+            provider: configuration.provider.provider,
+            snapshot: WidgetSnapshotStore.load() ?? WidgetPreviewData.emptySnapshot())
+        let refresh = BurnDownRefreshSchedule.nextRefresh(snapshot: entry.snapshot, provider: entry.provider)
+        return Timeline(entries: [entry], policy: .after(refresh))
+    }
+}
diff --git a/Sources/CodexBarWidget/BurnDownWidgetViews.swift b/Sources/CodexBarWidget/BurnDownWidgetViews.swift
new file mode 100644
index 0000000000..4ba3037065
--- /dev/null
+++ b/Sources/CodexBarWidget/BurnDownWidgetViews.swift
@@ -0,0 +1,682 @@
+import AppKit
+import CodexBarCore
+import SwiftUI
+import WidgetKit
+
+// MARK: - Entry View
+
+struct BurnDownWidgetView: View {
+    let entry: BurnDownEntry
+
+    var body: some View {
+        let state = BurnDownState(
+            snapshot: self.entry.snapshot,
+            provider: self.entry.provider,
+            selection: self.entry.window)
+
+        Group {
+            if let state, let window = state.selectedWindow {
+                BurnDownLayout(
+                    window: window,
+                    provider: self.entry.provider,
+                    blankChart: state.blankPrimaryChart,
+                    resetsAtOverride: state.selectedResetOverride)
+            } else {
+                self.emptyState
+            }
+        }
+        .containerBackground(for: .widget) {
+            BurnWidgetBackground()
+        }
+    }
+
+    private var emptyState: some View {
+        VStack(spacing: 6) {
+            Text("Open CodexBar")
+                .font(.body)
+                .fontWeight(.semibold)
+            Text("Usage data will appear once the app refreshes.")
+                .font(.caption)
+                .multilineTextAlignment(.center)
+                .opacity(0.55)
+        }
+        .padding(12)
+    }
+}
+
+// MARK: - Main Layout
+
+private struct BurnDownLayout: View {
+    @Environment(\.widgetRenderingMode) private var renderingMode
+    @Environment(\.colorScheme) private var colorScheme
+
+    let window: RateWindow
+    let provider: UsageProvider
+    /// True when the session window is blocked because the weekly budget is exhausted:
+    /// suppress the chart and retarget "Resets in" to the weekly reset.
+    var blankChart = false
+    /// When set, "Resets in" counts down to this date (the weekly reset) instead of the
+    /// session window's own reset.
+    var resetsAtOverride: Date?
+
+    var body: some View {
+        let dark = self.colorScheme == .dark
+        let isMonochrome = self.renderingMode != .fullColor
+        let geom = BurnGeom(window: self.window)
+        let theme = BurnTheme(provider: self.provider, geom: geom, dark: dark, isMonochrome: isMonochrome)
+        let windowMins = self.window.windowMinutes ?? 300
+        let isDailyWindow = windowMins >= 1440
+        let now = Date()
+        let estimatedResetMinutes = self.blankChart || geom.tNow >= 1
+            ? nil
+            : (1 - geom.tNow) * Double(windowMins)
+        let explicitReset = self.blankChart
+            ? self.resetsAtOverride
+            : self.resetsAtOverride ?? self.window.resetsAt
+        let effectiveResetAt = burnEffectiveResetDate(
+            explicitResetAt: explicitReset,
+            estimatedResetMinutes: estimatedResetMinutes,
+            now: now)
+        let resetsIn = effectiveResetAt.map { max(0, $0.timeIntervalSince(now) / 60) } ?? 0
+        let outInMins = geom.slope < -0.01 ? (geom.vNow / -geom.slope) * Double(windowMins) : Double.infinity
+        // Very early in the window a single sample can't forecast a credible run-out: a
+        // tiny burst right after reset extrapolates to "runs dry in minutes" even at ~99%
+        // remaining. Match the design's fresh-window behaviour ("Runs out: after reset")
+        // and only surface the estimate once enough of the window has elapsed to trust the
+        // average burn rate.
+        let windowEstablished = geom.tNow >= 0.08
+        let runsDryBefore = geom.runsOut && outInMins < resetsIn && windowEstablished
+
+        let sign = geom.margin >= 0 ? "+" : "−"
+        let badgeNum = "\(sign)\(abs(Int(geom.margin.rounded())))%"
+        // Per the design's edge states, "fresh" and "spent" show only the glyph + word
+        // (◆ full / ■ spent) with no pace number — the margin is meaningless once the
+        // budget is full or gone.
+        let showBadgeNumber = !geom.depleted && !geom.fresh
+        let statusWord: String = geom.depleted ? "spent" : geom.fresh ? "full"
+            : geom.status == .ahead ? "conserving" : geom.status == .behind ? "over pace" : "on pace"
+        let arrow: String = geom.depleted ? "■" : geom.fresh ? "◆"
+            : geom.status == .ahead ? "▲" : geom.status == .behind ? "▼" : "●"
+
+        let axisDates = burnAxisDateRange(
+            effectiveResetAt: effectiveResetAt,
+            windowMinutes: windowMins,
+            now: now)
+        let startLabel = burnAxisLabel(axisDates.start, isDailyWindow: isDailyWindow)
+        let resetLabel = burnAxisLabel(axisDates.reset, isDailyWindow: isDailyWindow)
+
+        VStack(spacing: 0) {
+            // Header: brand + pace badge
+            HStack(alignment: .top) {
+                VStack(alignment: .leading, spacing: 2) {
+                    HStack(spacing: 6) {
+                        Circle()
+                            .fill(theme.brandDot)
+                            .frame(width: 7, height: 7)
+                            .shadow(color: theme.brandDot.opacity(0.7), radius: 3.5)
+                        Text(burnProviderName(self.provider))
+                            .font(.system(size: 14.5, weight: .semibold))
+                            .foregroundStyle(theme.text)
+                            .lineLimit(1)
+                    }
+                    Text(burnWindowLabel(self.window.windowMinutes))
+                        .font(.system(size: 11))
+                        .foregroundStyle(theme.sub)
+                        .kerning(0.2)
+                }
+
+                Spacer()
+
+                VStack(alignment: .trailing, spacing: 1) {
+                    if showBadgeNumber {
+                        Text(badgeNum)
+                            .font(.system(size: 14, weight: .semibold))
+                            .foregroundStyle(theme.statusColor)
+                            .monospacedDigit()
+                    }
+                    HStack(spacing: 3) {
+                        Text(arrow)
+                            .font(.system(size: 8))
+                            .foregroundStyle(theme.statusColor)
+                        Text(statusWord)
+                            .font(.system(size: 10.5))
+                            .foregroundStyle(theme.sub)
+                    }
+                }
+            }
+
+            // Body: stats + hero / chart
+            HStack(alignment: .bottom, spacing: 13) {
+                // Left: stats + hero %
+                VStack(alignment: .leading, spacing: 0) {
+                    VStack(spacing: 5) {
+                        BurnResetStatRow(resetAt: effectiveResetAt, theme: theme)
+                        BurnStatRow(
+                            label: geom.depleted ? "Ran out" : runsDryBefore ? "Runs out in" : "Runs out",
+                            value: geom
+                                .depleted ? "budget spent" : runsDryBefore ? "~\(burnFmtDuration(outInMins))" :
+                                "after reset",
+                            theme: theme,
+                            danger: geom.depleted || runsDryBefore)
+                    }
+                    .padding(.top, 8)
+
+                    Spacer()
+
+                    HStack(alignment: .lastTextBaseline, spacing: 5) {
+                        Text("\(Int(geom.vNow.rounded()))")
+                            .font(.system(size: 41, weight: .semibold))
+                            .foregroundStyle(geom.depleted ? theme.danger : theme.text)
+                            .monospacedDigit()
+                            .lineLimit(1)
+                            .minimumScaleFactor(0.75)
+                        Text("%")
+                            .font(.system(size: 19, weight: .medium))
+                            .foregroundStyle(theme.sub)
+                        Text("left")
+                            .font(.system(size: 11))
+                            .foregroundStyle(theme.sub)
+                    }
+                }
+                .frame(width: 143, alignment: .leading)
+
+                // Right: chart + axis. Blanked when the session window is blocked by the
+                // weekly cap — there's no session burn to chart until the weekly resets.
+                VStack(spacing: 2) {
+                    if self.blankChart {
+                        Color.clear.frame(height: 84)
+                        Color.clear.frame(height: 13)
+                    } else {
+                        BurnChartCanvas(
+                            geom: geom,
+                            theme: theme)
+                            .frame(height: 84)
+
+                        BurnAxisRow(
+                            startLabel: startLabel,
+                            resetLabel: resetLabel,
+                            tNow: geom.tNow,
+                            theme: theme)
+                            .frame(height: 13)
+                    }
+                }
+                .frame(maxWidth: .infinity)
+            }
+        }
+        .padding(.horizontal, 15)
+        .padding(.top, 13)
+        .padding(.bottom, 12)
+    }
+}
+
+// MARK: - Stat Row
+
+private struct BurnStatRow: View {
+    let label: String
+    let value: String
+    let theme: BurnTheme
+    let danger: Bool
+
+    var body: some View {
+        HStack(alignment: .firstTextBaseline) {
+            Text(self.label)
+                .font(.system(size: 11.5))
+                .foregroundStyle(self.theme.sub)
+            Spacer()
+            Text(self.value)
+                .font(.system(size: 12.5, weight: .semibold))
+                .foregroundStyle(self.danger ? self.theme.danger : self.theme.text)
+                .monospacedDigit()
+                .lineLimit(1)
+        }
+    }
+}
+
+private struct BurnResetStatRow: View {
+    let resetAt: Date?
+    let theme: BurnTheme
+
+    var body: some View {
+        HStack(alignment: .firstTextBaseline) {
+            Text("Resets in")
+                .font(.system(size: 11.5))
+                .foregroundStyle(self.theme.sub)
+            Spacer()
+            if let resetAt {
+                Text(resetAt, style: .relative)
+                    .font(.system(size: 12.5, weight: .semibold))
+                    .foregroundStyle(self.theme.text)
+                    .monospacedDigit()
+                    .lineLimit(1)
+            } else {
+                Text("—")
+                    .font(.system(size: 12.5, weight: .semibold))
+                    .foregroundStyle(self.theme.text)
+            }
+        }
+    }
+}
+
+// MARK: - Axis Row
+
+private struct BurnAxisRow: View {
+    let startLabel: String
+    let resetLabel: String
+    let tNow: Double
+    let theme: BurnTheme
+
+    var body: some View {
+        GeometryReader { geo in
+            // Hide "now" when it would collide with the start/reset labels. The edge labels
+            // are anchored to the ends, so estimate their widths (≈9.5pt monospaced digits)
+            // and only show "now" when it clears both with a small gap — otherwise the
+            // now-dot on the chart already conveys position. Matches the design's rule that
+            // "now" hides near an end label.
+            let w = geo.size.width
+            let approxChar: CGFloat = 5.8
+            let nowX = self.tNow * w
+            let nowHalf: CGFloat = 13
+            let gap: CGFloat = 6
+            let clearsStart = nowX - nowHalf > CGFloat(self.startLabel.count) * approxChar + gap
+            let clearsReset = nowX + nowHalf < w - CGFloat(self.resetLabel.count) * approxChar - gap
+            let showNow = self.tNow > 0.05 && self.tNow < 0.95 && clearsStart && clearsReset
+
+            ZStack(alignment: .leading) {
+                Text(self.startLabel)
+                    .font(.system(size: 9.5))
+                    .foregroundStyle(self.theme.sub)
+                    .monospacedDigit()
+                    .frame(maxWidth: .infinity, alignment: .leading)
+
+                if showNow {
+                    Text("now")
+                        .font(.system(size: 9.5, weight: .semibold))
+                        .foregroundStyle(self.theme.text)
+                        .position(x: nowX, y: geo.size.height / 2)
+                }
+
+                Text(self.resetLabel)
+                    .font(.system(size: 9.5))
+                    .foregroundStyle(self.theme.sub)
+                    .monospacedDigit()
+                    .frame(maxWidth: .infinity, alignment: .trailing)
+            }
+        }
+    }
+}
+
+// MARK: - Chart Canvas
+
+private struct BurnChartCanvas: View {
+    let geom: BurnGeom
+    let theme: BurnTheme
+
+    var body: some View {
+        Canvas { context, size in
+            let w = size.width
+            let h = size.height
+            let padT: CGFloat = 8
+            let padB: CGFloat = 2
+            let padL: CGFloat = 1
+            let padR: CGFloat = 1
+
+            func X(_ t: Double) -> CGFloat {
+                padL + CGFloat(t) * (w - padL - padR)
+            }
+            func Y(_ v: Double) -> CGFloat {
+                padT + CGFloat(1 - v / 100) * (h - padT - padB)
+            }
+
+            let tNow = self.geom.tNow
+            let vNow = self.geom.vNow
+
+            // --- Now vertical hairline ---
+            do {
+                var p = Path()
+                p.move(to: CGPoint(x: X(tNow), y: Y(100)))
+                p.addLine(to: CGPoint(x: X(tNow), y: Y(0)))
+                context.stroke(p, with: .color(self.theme.chartGrid), lineWidth: 1)
+            }
+
+            // --- Baseline ---
+            do {
+                var p = Path()
+                p.move(to: CGPoint(x: X(0), y: Y(0)))
+                p.addLine(to: CGPoint(x: X(1), y: Y(0)))
+                context.stroke(p, with: .color(self.theme.chartGrid), lineWidth: 1)
+            }
+
+            // --- Area fill (gradient from actual line down to baseline) ---
+            do {
+                var p = Path()
+                p.move(to: CGPoint(x: X(0), y: Y(100)))
+                p.addLine(to: CGPoint(x: X(tNow), y: Y(vNow)))
+                p.addLine(to: CGPoint(x: X(tNow), y: Y(0)))
+                p.addLine(to: CGPoint(x: X(0), y: Y(0)))
+                p.closeSubpath()
+
+                let gradient = Gradient(stops: [
+                    .init(color: self.theme.chartFillTop.opacity(self.theme.chartFillTopOpacity), location: 0),
+                    .init(color: self.theme.chartFillTop.opacity(0), location: 0.92),
+                ])
+                context.fill(
+                    p,
+                    with: .linearGradient(
+                        gradient,
+                        startPoint: CGPoint(x: 0, y: padT),
+                        endPoint: CGPoint(x: 0, y: h)))
+            }
+
+            // --- Ideal line (dashed, knocked back) ---
+            do {
+                var p = Path()
+                p.move(to: CGPoint(x: X(0), y: Y(100)))
+                p.addLine(to: CGPoint(x: X(1), y: Y(0)))
+                context.stroke(
+                    p,
+                    with: .color(self.theme.chartIdeal),
+                    style: StrokeStyle(lineWidth: 1.4, lineCap: .round, dash: [2.5, 3]))
+            }
+
+            // --- Projection (fine dotted) ---
+            if self.geom.slope < -0.01 {
+                var p = Path()
+                p.move(to: CGPoint(x: X(tNow), y: Y(vNow)))
+                p.addLine(to: CGPoint(x: X(self.geom.projT), y: Y(self.geom.projV)))
+                context.stroke(
+                    p,
+                    with: .color(self.theme.chartProj.opacity(0.95)),
+                    style: StrokeStyle(lineWidth: 1.6, lineCap: .round, dash: [0.5, 3.5]))
+            }
+
+            // --- Actual line (solid, hero) ---
+            do {
+                var p = Path()
+                p.move(to: CGPoint(x: X(0), y: Y(100)))
+                p.addLine(to: CGPoint(x: X(tNow), y: Y(vNow)))
+                context.stroke(
+                    p,
+                    with: .color(self.theme.chartLine),
+                    style: StrokeStyle(lineWidth: 2.4, lineCap: .round, lineJoin: .round))
+            }
+
+            // --- Now dot (filled, with ring punched in bg color) ---
+            let dotCenter = CGPoint(x: X(tNow), y: Y(vNow))
+            let ringPath = Path(ellipseIn: CGRect(
+                x: dotCenter.x - 5.4, y: dotCenter.y - 5.4, width: 10.8, height: 10.8))
+            context.fill(ringPath, with: .color(self.theme.chartNowRing))
+            let dotPath = Path(ellipseIn: CGRect(
+                x: dotCenter.x - 3.4, y: dotCenter.y - 3.4, width: 6.8, height: 6.8))
+            context.fill(dotPath, with: .color(self.theme.chartNowDot))
+        }
+    }
+}
+
+// MARK: - Background
+
+struct BurnWidgetBackground: View {
+    @Environment(\.widgetRenderingMode) private var renderingMode
+    @Environment(\.colorScheme) private var colorScheme
+
+    var body: some View {
+        if self.renderingMode == .fullColor {
+            let dark = self.colorScheme == .dark
+            LinearGradient(
+                colors: dark
+                    ? [BurnPalette.darkBgTop, BurnPalette.darkBgBottom]
+                    : [BurnPalette.lightBgTop, BurnPalette.lightBgBottom],
+                startPoint: .init(x: 0.15, y: 0),
+                endPoint: .init(x: 0.85, y: 1))
+                .overlay(alignment: .top) {
+                    LinearGradient(
+                        colors: [
+                            Color.white.opacity(dark ? 0.04 : 0.60),
+                            Color.white.opacity(0),
+                        ],
+                        startPoint: .top,
+                        endPoint: .center)
+                }
+        } else {
+            Color.clear
+        }
+    }
+}
+
+// MARK: - Theme
+
+struct BurnTheme {
+    let text: Color
+    let sub: Color
+    let hair: Color
+    let accent: Color
+    let statusColor: Color
+    let danger: Color
+    let brandDot: Color
+    let chartLine: Color
+    let chartFillTop: Color
+    let chartFillTopOpacity: Double
+    let chartIdeal: Color
+    let chartProj: Color
+    let chartGrid: Color
+    let chartNowDot: Color
+    let chartNowRing: Color
+
+    init(provider: UsageProvider, geom: BurnGeom, dark: Bool, isMonochrome: Bool) {
+        if isMonochrome {
+            let fg = dark ? Color.white : Color.black
+            self.text = fg.opacity(dark ? 0.95 : 0.90)
+            self.sub = fg.opacity(dark ? 0.50 : 0.46)
+            self.hair = fg.opacity(dark ? 0.13 : 0.11)
+            self.accent = fg.opacity(dark ? 0.95 : 0.85)
+            self.statusColor = fg.opacity(dark ? 0.90 : 0.80)
+            self.danger = fg.opacity(dark ? 0.95 : 0.85)
+            self.brandDot = fg.opacity(dark ? 0.85 : 0.72)
+            self.chartLine = fg.opacity(dark ? 0.95 : 0.85)
+            self.chartFillTop = fg.opacity(dark ? 0.95 : 0.85)
+            self.chartFillTopOpacity = dark ? 0.20 : 0.16
+            self.chartIdeal = fg.opacity(dark ? 0.36 : 0.30)
+            self.chartProj = fg.opacity(dark ? 0.60 : 0.48)
+            self.chartGrid = fg.opacity(dark ? 0.12 : 0.10)
+            self.chartNowDot = fg.opacity(dark ? 1.0 : 0.92)
+            self.chartNowRing = dark
+                ? Color(red: 0.10, green: 0.10, blue: 0.12).opacity(0.92)
+                : Color(red: 0.96, green: 0.96, blue: 0.97).opacity(0.95)
+        } else {
+            let accentColor = Self.accentColor(geom.status, dark: dark)
+            self.accent = accentColor
+            self.statusColor = accentColor
+            self.text = dark ? Color.white.opacity(0.98) : Color(white: 0.20)
+            self.sub = dark ? Color(white: 0.60) : Color(white: 0.45)
+            self.hair = dark ? Color.white.opacity(0.10) : Color.black.opacity(0.09)
+            self.danger = BurnPalette.behindDark
+            self.brandDot = Self.brandDotColor(provider)
+            self.chartLine = accentColor
+            self.chartFillTop = accentColor
+            self.chartFillTopOpacity = dark ? 0.30 : 0.22
+            self.chartIdeal = dark ? Color.white.opacity(0.45) : Color.black.opacity(0.50)
+            // Projection goes red when behind (the one allowed color cue in full-color mode)
+            self.chartProj = geom.status == .behind ? BurnPalette.behindDark : accentColor
+            self.chartGrid = dark ? Color.white.opacity(0.10) : Color.black.opacity(0.09)
+            self.chartNowDot = accentColor
+            self.chartNowRing = dark ? BurnPalette.darkBgBottom : BurnPalette.lightBgBottom
+        }
+    }
+
+    private static func accentColor(_ status: BurnGeom.Status, dark: Bool) -> Color {
+        switch status {
+        case .ahead: dark ? BurnPalette.aheadDark : BurnPalette.aheadLight
+        case .onpace: dark ? BurnPalette.onpaceDark : BurnPalette.onpaceLight
+        case .behind: dark ? BurnPalette.behindDark : BurnPalette.behindLight
+        }
+    }
+
+    private static func brandDotColor(_ provider: UsageProvider) -> Color {
+        switch provider {
+        case .claude: BurnPalette.claudeDot
+        case .codex: BurnPalette.codexDot
+        case .gemini: BurnPalette.geminiDot
+        default: BurnPalette.genericDot
+        }
+    }
+}
+
+// MARK: - Palette
+
+enum BurnPalette {
+    // Status accents — approximated from OKLCH (L=0.80 dark, L=0.62 light)
+    // oklch(0.80 0.15 152) / oklch(0.62 0.15 152) — green
+    static let aheadDark = Color(red: 0.306, green: 0.800, blue: 0.506)
+    static let aheadLight = Color(red: 0.192, green: 0.620, blue: 0.376)
+    // oklch(0.80 0.11 236) / oklch(0.62 0.11 236) — blue
+    static let onpaceDark = Color(red: 0.408, green: 0.668, blue: 0.910)
+    static let onpaceLight = Color(red: 0.264, green: 0.474, blue: 0.712)
+    // oklch(0.72 0.19 26) / oklch(0.60 0.19 26) — red-orange
+    static let behindDark = Color(red: 0.922, green: 0.420, blue: 0.227)
+    static let behindLight = Color(red: 0.762, green: 0.294, blue: 0.137)
+
+    // Brand identity dots — always the LLM's hue
+    static let claudeDot = Color(red: 0.880, green: 0.580, blue: 0.180) // clay/amber, hue 48
+    static let codexDot = Color(red: 0.120, green: 0.780, blue: 0.598) // teal, hue 168
+    static let geminiDot = Color(red: 0.420, green: 0.440, blue: 0.900) // indigo, hue 268
+    static let genericDot = Color(white: 0.60)
+
+    // Backgrounds
+    static let darkBgTop = Color(red: 0.108, green: 0.108, blue: 0.132)
+    static let darkBgBottom = Color(red: 0.132, green: 0.132, blue: 0.156)
+    static let lightBgTop = Color(white: 0.990)
+    static let lightBgBottom = Color(red: 0.940, green: 0.940, blue: 0.960)
+}
+
+// MARK: - Geometry
+
+struct BurnGeom {
+    enum Status { case ahead, onpace, behind }
+
+    let vNow: Double // % remaining (0..100)
+    let tNow: Double // position in window (0..1)
+    let idealNow: Double // what you should have left = 100 * (1 - tNow)
+    let margin: Double // vNow - idealNow; + = conserving, − = over pace
+    let slope: Double // %/unit-t (negative = burning)
+    let projT: Double // t where projection ends
+    let projV: Double // v where projection ends
+    let runsOut: Bool // projection hits 0 inside the window
+
+    var status: Status {
+        self.margin > 4 ? .ahead : self.margin < -4 ? .behind : .onpace
+    }
+
+    var depleted: Bool {
+        self.vNow <= 0.5
+    }
+
+    var fresh: Bool {
+        self.vNow >= 99.5
+    }
+
+    init(window: RateWindow) {
+        let remaining = max(0, min(100, window.remainingPercent))
+        self.vNow = remaining
+
+        let t: Double
+        if let resetsAt = window.resetsAt, let windowMins = window.windowMinutes, windowMins > 0 {
+            let minutesUntilReset = max(0, resetsAt.timeIntervalSinceNow / 60)
+            let minutesElapsed = Double(windowMins) - minutesUntilReset
+            t = max(0.001, min(0.999, minutesElapsed / Double(windowMins)))
+        } else {
+            t = max(0.001, min(0.999, window.usedPercent / 100.0))
+        }
+        self.tNow = t
+        self.idealNow = 100.0 * (1.0 - t)
+        self.margin = remaining - self.idealNow
+
+        let slope = t > 0.001 ? (remaining - 100.0) / t : -remaining
+        self.slope = slope
+
+        if slope < -0.01 {
+            let tOut = t + remaining / -slope
+            if tOut <= 1.0 {
+                self.projT = tOut
+                self.projV = 0
+                self.runsOut = true
+            } else {
+                self.projT = 1.0
+                self.projV = max(0, remaining + slope * (1.0 - t))
+                self.runsOut = false
+            }
+        } else {
+            self.projT = 1.0
+            self.projV = remaining
+            self.runsOut = false
+        }
+    }
+}
+
+// MARK: - Helpers
+
+func burnWindowLabel(_ windowMinutes: Int?) -> String {
+    guard let mins = windowMinutes else { return "Usage limit" }
+    if mins < 60 { return "\(mins)-minute limit" }
+    let hours = mins / 60
+    if hours < 24 { return "\(hours)-hour limit" }
+    return "\(hours / 24)-day limit"
+}
+
+func burnEffectiveResetDate(
+    explicitResetAt: Date?,
+    estimatedResetMinutes: Double?,
+    now: Date) -> Date?
+{
+    if let explicitResetAt {
+        return explicitResetAt > now ? explicitResetAt : nil
+    }
+    guard let estimatedResetMinutes, estimatedResetMinutes > 0 else { return nil }
+    return now.addingTimeInterval(estimatedResetMinutes * 60)
+}
+
+func burnAxisDateRange(
+    effectiveResetAt: Date?,
+    windowMinutes: Int,
+    now: Date) -> (start: Date, reset: Date)
+{
+    let reset = effectiveResetAt ?? now
+    return (reset.addingTimeInterval(-Double(windowMinutes) * 60), reset)
+}
+
+func burnCompactWindowLabel(_ windowMinutes: Int?, fallback: String) -> String {
+    guard let minutes = windowMinutes else { return fallback }
+    if minutes < 60 { return "\(minutes)M" }
+    let hours = minutes / 60
+    if hours < 24 { return "\(hours)H" }
+    return "\(hours / 24)D"
+}
+
+func burnFmtDuration(_ minutes: Double) -> String {
+    guard minutes.isFinite, minutes > 0 else { return "—" }
+    if minutes >= 1440 {
+        let d = Int(minutes / 1440)
+        let h = Int(minutes / 60) % 24
+        return "\(d)d \(h)h"
+    }
+    let h = Int(minutes / 60)
+    let m = Int(minutes) % 60
+    if h <= 0 { return "\(max(1, m))m" }
+    return "\(h)h \(String(format: "%02d", m))m"
+}
+
+func burnAxisLabel(_ date: Date, isDailyWindow: Bool) -> String {
+    let f = DateFormatter()
+    if isDailyWindow {
+        // A rolling multi-day window's start and reset fall on the same weekday, so "EEE"
+        // would print the same label at both ends ("Sat … Sat"). Use a numeric date so the
+        // two ends are distinguishable.
+        f.setLocalizedDateFormatFromTemplate("Md")
+    } else {
+        f.dateStyle = .none
+        f.timeStyle = .short
+    }
+    return f.string(from: date)
+}
+
+func burnProviderName(_ provider: UsageProvider) -> String {
+    ProviderDefaults.metadata[provider]?.displayName ?? provider.rawValue.capitalized
+}
diff --git a/Sources/CodexBarWidget/CodexBarWidgetBundle.swift b/Sources/CodexBarWidget/CodexBarWidgetBundle.swift
index 4b65052170..a2d2cd23ca 100644
--- a/Sources/CodexBarWidget/CodexBarWidgetBundle.swift
+++ b/Sources/CodexBarWidget/CodexBarWidgetBundle.swift
@@ -8,6 +8,8 @@ struct CodexBarWidgetBundle: WidgetBundle {
         CodexBarUsageWidget()
         CodexBarHistoryWidget()
         CodexBarCompactWidget()
+        CodexBarBurnDownWidget()
+        CodexBarCombinedBurnDownWidget()
     }
 }
 
@@ -77,3 +79,37 @@ struct CodexBarCompactWidget: Widget {
         .supportedFamilies([.systemSmall])
     }
 }
+
+struct CodexBarBurnDownWidget: Widget {
+    private let kind = "CodexBarBurnDownWidget"
+
+    var body: some WidgetConfiguration {
+        AppIntentConfiguration(
+            kind: self.kind,
+            intent: BurnDownSelectionIntent.self,
+            provider: BurnDownTimelineProvider())
+        { entry in
+            BurnDownWidgetView(entry: entry)
+        }
+        .configurationDisplayName("CodexBar Burn Down")
+        .description("Remaining budget compared with an ideal steady burn rate.")
+        .supportedFamilies([.systemMedium])
+    }
+}
+
+struct CodexBarCombinedBurnDownWidget: Widget {
+    private let kind = "CodexBarCombinedBurnDownWidget"
+
+    var body: some WidgetConfiguration {
+        AppIntentConfiguration(
+            kind: self.kind,
+            intent: BurnProviderSelectionIntent.self,
+            provider: CombinedBurnDownTimelineProvider())
+        { entry in
+            CombinedBurnDownWidgetView(entry: entry)
+        }
+        .configurationDisplayName("CodexBar Burn Down (Combined)")
+        .description("Session and weekly burn-down charts in one tile.")
+        .supportedFamilies([.systemMedium])
+    }
+}
diff --git a/Sources/CodexBarWidget/CodexBarWidgetProvider.swift b/Sources/CodexBarWidget/CodexBarWidgetProvider.swift
index eb0d005741..923690bb13 100644
--- a/Sources/CodexBarWidget/CodexBarWidgetProvider.swift
+++ b/Sources/CodexBarWidget/CodexBarWidgetProvider.swift
@@ -7,12 +7,15 @@ enum ProviderChoice: String, AppEnum {
     case codex
     case claude
     case gemini
+    case alibaba
+    case alibabatokenplan
     case antigravity
     case zai
     case copilot
     case minimax
     case kilo
     case opencode
+    case opencodego
 
     static let typeDisplayRepresentation = TypeDisplayRepresentation(name: "Provider")
 
@@ -20,12 +23,15 @@ enum ProviderChoice: String, AppEnum {
         .codex: DisplayRepresentation(title: "Codex"),
         .claude: DisplayRepresentation(title: "Claude"),
         .gemini: DisplayRepresentation(title: "Gemini"),
+        .alibaba: DisplayRepresentation(title: "Alibaba"),
+        .alibabatokenplan: DisplayRepresentation(title: "Alibaba Token Plan"),
         .antigravity: DisplayRepresentation(title: "Antigravity"),
         .zai: DisplayRepresentation(title: "z.ai"),
         .copilot: DisplayRepresentation(title: "Copilot"),
         .minimax: DisplayRepresentation(title: "MiniMax"),
         .kilo: DisplayRepresentation(title: "Kilo"),
         .opencode: DisplayRepresentation(title: "OpenCode"),
+        .opencodego: DisplayRepresentation(title: "OpenCode Go"),
     ]
 
     var provider: UsageProvider {
@@ -33,12 +39,15 @@ enum ProviderChoice: String, AppEnum {
         case .codex: .codex
         case .claude: .claude
         case .gemini: .gemini
+        case .alibaba: .alibaba
+        case .alibabatokenplan: .alibabatokenplan
         case .antigravity: .antigravity
         case .zai: .zai
         case .copilot: .copilot
         case .minimax: .minimax
         case .kilo: .kilo
         case .opencode: .opencode
+        case .opencodego: .opencodego
         }
     }
 
@@ -46,15 +55,22 @@ enum ProviderChoice: String, AppEnum {
     init?(provider: UsageProvider) {
         switch provider {
         case .codex: self = .codex
+        case .openai: return nil // OpenAI not yet supported in widgets
+        case .azureopenai: return nil // Azure OpenAI not yet supported in widgets
         case .claude: self = .claude
         case .gemini: self = .gemini
+        case .alibaba: self = .alibaba
+        case .alibabatokenplan: self = .alibabatokenplan
         case .antigravity: self = .antigravity
         case .cursor: return nil // Cursor not yet supported in widgets
         case .opencode: self = .opencode
+        case .opencodego: self = .opencodego
         case .zai: self = .zai
         case .factory: return nil // Factory not yet supported in widgets
         case .copilot: self = .copilot
+        case .devin: return nil // Devin not yet supported in widgets
         case .minimax: self = .minimax
+        case .manus: return nil // Manus not yet supported in widgets
         case .vertexai: return nil // Vertex AI not yet supported in widgets
         case .kilo: self = .kilo
         case .kiro: return nil // Kiro not yet supported in widgets
@@ -62,11 +78,35 @@ enum ProviderChoice: String, AppEnum {
         case .jetbrains: return nil // JetBrains not yet supported in widgets
         case .kimi: return nil // Kimi not yet supported in widgets
         case .kimik2: return nil // Kimi K2 not yet supported in widgets
+        case .moonshot: return nil // Moonshot not yet supported in widgets
         case .amp: return nil // Amp not yet supported in widgets
+        case .t3chat: return nil // T3 Chat not yet supported in widgets
         case .ollama: return nil // Ollama not yet supported in widgets
         case .synthetic: return nil // Synthetic not yet supported in widgets
         case .openrouter: return nil // OpenRouter not yet supported in widgets
+        case .elevenlabs: return nil // ElevenLabs not yet supported in widgets
         case .warp: return nil // Warp not yet supported in widgets
+        case .windsurf: return nil // Windsurf not yet supported in widgets
+        case .perplexity: return nil // Perplexity not yet supported in widgets
+        case .mimo: return nil // Xiaomi MiMo not yet supported in widgets
+        case .doubao: return nil // Doubao not yet supported in widgets
+        case .abacus: return nil // Abacus AI not yet supported in widgets
+        case .mistral: return nil // Mistral not yet supported in widgets
+        case .deepseek: return nil // DeepSeek not yet supported in widgets
+        case .codebuff: return nil // Codebuff not yet supported in widgets
+        case .crof: return nil // Crof not yet supported in widgets
+        case .venice: return nil // Venice not yet supported in widgets
+        case .commandcode: return nil // CommandCode not yet supported in widgets
+        case .stepfun: return nil // StepFun not yet supported in widgets
+        case .bedrock: return nil // Bedrock not yet supported in widgets
+        case .grok: return nil // Grok not yet supported in widgets
+        case .groq: return nil // Groq not yet supported in widgets
+        case .llmproxy: return nil // LLM Proxy not yet supported in widgets
+        case .litellm: return nil // LiteLLM not yet supported in widgets
+        case .deepgram: return nil // Deepgram not yet supported in widgets
+        case .poe: return nil // Poe not yet supported in widgets
+        case .chutes: return nil // Chutes not yet supported in widgets
+        case .zed: return nil // Zed not yet supported in widgets
         }
     }
 }
@@ -89,7 +129,7 @@ struct ProviderSelectionIntent: AppIntent, WidgetConfigurationIntent {
     static let title: LocalizedStringResource = "Provider"
     static let description = IntentDescription("Select the provider to display in the widget.")
 
-    @Parameter(title: "Provider")
+    @Parameter(title: "Provider", default: .codex)
     var provider: ProviderChoice
 
     init() {
@@ -121,10 +161,10 @@ struct CompactMetricSelectionIntent: AppIntent, WidgetConfigurationIntent {
     static let title: LocalizedStringResource = "Provider + Metric"
     static let description = IntentDescription("Select the provider and metric to display.")
 
-    @Parameter(title: "Provider")
+    @Parameter(title: "Provider", default: .codex)
     var provider: ProviderChoice
 
-    @Parameter(title: "Metric")
+    @Parameter(title: "Metric", default: .credits)
     var metric: CompactMetric
 
     init() {
@@ -174,7 +214,7 @@ struct CodexBarTimelineProvider: AppIntentTimelineProvider {
         in context: Context) async -> Timeline<CodexBarWidgetEntry>
     {
         let provider = configuration.provider.provider
-        let snapshot = WidgetSnapshotStore.load() ?? WidgetPreviewData.snapshot()
+        let snapshot = WidgetSnapshotStore.load() ?? WidgetPreviewData.emptySnapshot()
         let entry = CodexBarWidgetEntry(date: Date(), provider: provider, snapshot: snapshot)
         let refresh = Date().addingTimeInterval(30 * 60)
         return Timeline(entries: [entry], policy: .after(refresh))
@@ -203,7 +243,7 @@ struct CodexBarSwitcherTimelineProvider: TimelineProvider {
     }
 
     private func makeEntry() -> CodexBarSwitcherEntry {
-        let snapshot = WidgetSnapshotStore.load() ?? WidgetPreviewData.snapshot()
+        let snapshot = WidgetSnapshotStore.load() ?? WidgetPreviewData.emptySnapshot()
         let providers = self.availableProviders(from: snapshot)
         let stored = WidgetSelectionStore.loadSelectedProvider()
         let selected = providers.first { $0 == stored } ?? providers.first ?? .codex
@@ -218,6 +258,10 @@ struct CodexBarSwitcherTimelineProvider: TimelineProvider {
     }
 
     private func availableProviders(from snapshot: WidgetSnapshot) -> [UsageProvider] {
+        Self.supportedProviders(from: snapshot)
+    }
+
+    static func supportedProviders(from snapshot: WidgetSnapshot) -> [UsageProvider] {
         let enabled = snapshot.enabledProviders
         let providers = enabled.isEmpty ? snapshot.entries.map(\.provider) : enabled
         let supported = providers.filter { ProviderChoice(provider: $0) != nil }
@@ -236,10 +280,11 @@ struct CodexBarCompactTimelineProvider: AppIntentTimelineProvider {
 
     func snapshot(for configuration: CompactMetricSelectionIntent, in context: Context) async -> CodexBarCompactEntry {
         let provider = configuration.provider.provider
+        let metric = configuration.metric
         return CodexBarCompactEntry(
             date: Date(),
             provider: provider,
-            metric: configuration.metric,
+            metric: metric,
             snapshot: WidgetSnapshotStore.load() ?? WidgetPreviewData.snapshot())
     }
 
@@ -248,11 +293,12 @@ struct CodexBarCompactTimelineProvider: AppIntentTimelineProvider {
         in context: Context) async -> Timeline<CodexBarCompactEntry>
     {
         let provider = configuration.provider.provider
-        let snapshot = WidgetSnapshotStore.load() ?? WidgetPreviewData.snapshot()
+        let metric = configuration.metric
+        let snapshot = WidgetSnapshotStore.load() ?? WidgetPreviewData.emptySnapshot()
         let entry = CodexBarCompactEntry(
             date: Date(),
             provider: provider,
-            metric: configuration.metric,
+            metric: metric,
             snapshot: snapshot)
         let refresh = Date().addingTimeInterval(30 * 60)
         return Timeline(entries: [entry], policy: .after(refresh))
@@ -260,9 +306,17 @@ struct CodexBarCompactTimelineProvider: AppIntentTimelineProvider {
 }
 
 enum WidgetPreviewData {
+    static func emptySnapshot() -> WidgetSnapshot {
+        WidgetSnapshot(entries: [], enabledProviders: [], generatedAt: Date())
+    }
+
     static func snapshot() -> WidgetSnapshot {
-        let primary = RateWindow(usedPercent: 35, windowMinutes: nil, resetsAt: nil, resetDescription: "Resets in 4h")
-        let secondary = RateWindow(usedPercent: 60, windowMinutes: nil, resetsAt: nil, resetDescription: "Resets in 3d")
+        let primary = RateWindow(usedPercent: 35, windowMinutes: 300, resetsAt: nil, resetDescription: "Resets in 4h")
+        let secondary = RateWindow(
+            usedPercent: 60,
+            windowMinutes: 10080,
+            resetsAt: nil,
+            resetDescription: "Resets in 3d")
         let entry = WidgetSnapshot.ProviderEntry(
             provider: .codex,
             updatedAt: Date(),
diff --git a/Sources/CodexBarWidget/CodexBarWidgetViews.swift b/Sources/CodexBarWidget/CodexBarWidgetViews.swift
index fbb8c5d9c0..10fe0183fe 100644
--- a/Sources/CodexBarWidget/CodexBarWidgetViews.swift
+++ b/Sources/CodexBarWidget/CodexBarWidgetViews.swift
@@ -184,13 +184,19 @@ private struct CompactMetricView: View {
             let value = self.entry.creditsRemaining.map(WidgetFormat.credits) ?? "—"
             return (value, "Credits left", nil)
         case .todayCost:
-            let value = self.entry.tokenUsage?.sessionCostUSD.map(WidgetFormat.usd) ?? "—"
+            let value = self.entry.tokenUsage.map { token in
+                token.sessionCostUSD.map { WidgetFormat.currency($0, code: token.currencyCode) } ?? "—"
+            } ?? "—"
             let detail = self.entry.tokenUsage?.sessionTokens.map(WidgetFormat.tokenCount)
-            return (value, "Today cost", detail)
+            let label = self.entry.tokenUsage.map { "\($0.sessionLabel) cost" } ?? "Today cost"
+            return (value, label, detail)
         case .last30DaysCost:
-            let value = self.entry.tokenUsage?.last30DaysCostUSD.map(WidgetFormat.usd) ?? "—"
+            let value = self.entry.tokenUsage.map { token in
+                token.last30DaysCostUSD.map { WidgetFormat.currency($0, code: token.currencyCode) } ?? "—"
+            } ?? "—"
             let detail = self.entry.tokenUsage?.last30DaysTokens.map(WidgetFormat.tokenCount)
-            return (value, "30d cost", detail)
+            let label = self.entry.tokenUsage.map { "\($0.last30DaysLabel) cost" } ?? "30d cost"
+            return (value, label, detail)
         }
     }
 }
@@ -258,15 +264,22 @@ private struct ProviderSwitchChip: View {
     private var shortLabel: String {
         switch self.provider {
         case .codex: "Codex"
+        case .openai: "OpenAI"
+        case .azureopenai: "Azure OpenAI"
         case .claude: "Claude"
         case .gemini: "Gemini"
         case .antigravity: "Anti"
         case .cursor: "Cursor"
         case .opencode: "OpenCode"
+        case .opencodego: "OpenCode Go"
+        case .alibaba: "Alibaba"
+        case .alibabatokenplan: "Token Plan"
         case .zai: "z.ai"
         case .factory: "Droid"
         case .copilot: "Copilot"
+        case .devin: "Devin"
         case .minimax: "MiniMax"
+        case .manus: "Manus"
         case .vertexai: "Vertex"
         case .kilo: "Kilo"
         case .kiro: "Kiro"
@@ -274,11 +287,35 @@ private struct ProviderSwitchChip: View {
         case .jetbrains: "JetBrains"
         case .kimi: "Kimi"
         case .kimik2: "Kimi K2"
+        case .moonshot: "Moonshot"
         case .amp: "Amp"
+        case .t3chat: "T3 Chat"
         case .ollama: "Ollama"
         case .synthetic: "Synthetic"
         case .openrouter: "OpenRouter"
+        case .elevenlabs: "ElevenLabs"
         case .warp: "Warp"
+        case .windsurf: "Windsurf"
+        case .perplexity: "Pplx"
+        case .mimo: "MiMo"
+        case .doubao: "Doubao"
+        case .abacus: "Abacus"
+        case .mistral: "Mistral"
+        case .deepseek: "DeepSeek"
+        case .codebuff: "Codebuff"
+        case .crof: "Crof"
+        case .venice: "Venice"
+        case .commandcode: "Command Code"
+        case .stepfun: "StepFun"
+        case .bedrock: "Bedrock"
+        case .grok: "Grok"
+        case .groq: "Groq"
+        case .llmproxy: "LLM Proxy"
+        case .litellm: "LiteLLM"
+        case .deepgram: "Deepgram"
+        case .poe: "Poe"
+        case .chutes: "Chutes"
+        case .zed: "Zed"
         }
     }
 }
@@ -288,14 +325,15 @@ private struct SwitcherSmallUsageView: View {
 
     var body: some View {
         VStack(alignment: .leading, spacing: 8) {
-            UsageBarRow(
-                title: ProviderDefaults.metadata[self.entry.provider]?.sessionLabel ?? "Session",
-                percentLeft: self.entry.primary?.remainingPercent,
-                color: WidgetColors.color(for: self.entry.provider))
-            UsageBarRow(
-                title: ProviderDefaults.metadata[self.entry.provider]?.weeklyLabel ?? "Weekly",
-                percentLeft: self.entry.secondary?.remainingPercent,
-                color: WidgetColors.color(for: self.entry.provider))
+            ForEach(WidgetUsageRow.rows(
+                for: self.entry,
+                limit: WidgetUsageRow.smallWidgetRowLimit(for: self.entry)))
+            { row in
+                UsageBarRow(
+                    title: row.title,
+                    percentLeft: row.percentLeft,
+                    color: WidgetColors.color(for: self.entry.provider))
+            }
             if let codeReview = entry.codeReviewRemainingPercent {
                 UsageBarRow(
                     title: "Code review",
@@ -311,21 +349,25 @@ private struct SwitcherMediumUsageView: View {
 
     var body: some View {
         VStack(alignment: .leading, spacing: 10) {
-            UsageBarRow(
-                title: ProviderDefaults.metadata[self.entry.provider]?.sessionLabel ?? "Session",
-                percentLeft: self.entry.primary?.remainingPercent,
-                color: WidgetColors.color(for: self.entry.provider))
-            UsageBarRow(
-                title: ProviderDefaults.metadata[self.entry.provider]?.weeklyLabel ?? "Weekly",
-                percentLeft: self.entry.secondary?.remainingPercent,
-                color: WidgetColors.color(for: self.entry.provider))
+            ForEach(WidgetUsageRow.rows(
+                for: self.entry,
+                limit: WidgetUsageRow.mediumWidgetRowLimit(for: self.entry)))
+            { row in
+                UsageBarRow(
+                    title: row.title,
+                    percentLeft: row.percentLeft,
+                    color: WidgetColors.color(for: self.entry.provider))
+            }
             if let credits = entry.creditsRemaining {
                 ValueLine(title: "Credits", value: WidgetFormat.credits(credits))
             }
             if let token = entry.tokenUsage {
                 ValueLine(
-                    title: "Today",
-                    value: WidgetFormat.costAndTokens(cost: token.sessionCostUSD, tokens: token.sessionTokens))
+                    title: token.sessionLabel,
+                    value: WidgetFormat.costAndTokens(
+                        cost: token.sessionCostUSD,
+                        tokens: token.sessionTokens,
+                        currencyCode: token.currencyCode))
             }
         }
     }
@@ -336,14 +378,12 @@ private struct SwitcherLargeUsageView: View {
 
     var body: some View {
         VStack(alignment: .leading, spacing: 12) {
-            UsageBarRow(
-                title: ProviderDefaults.metadata[self.entry.provider]?.sessionLabel ?? "Session",
-                percentLeft: self.entry.primary?.remainingPercent,
-                color: WidgetColors.color(for: self.entry.provider))
-            UsageBarRow(
-                title: ProviderDefaults.metadata[self.entry.provider]?.weeklyLabel ?? "Weekly",
-                percentLeft: self.entry.secondary?.remainingPercent,
-                color: WidgetColors.color(for: self.entry.provider))
+            ForEach(WidgetUsageRow.rows(for: self.entry)) { row in
+                UsageBarRow(
+                    title: row.title,
+                    percentLeft: row.percentLeft,
+                    color: WidgetColors.color(for: self.entry.provider))
+            }
             if let codeReview = entry.codeReviewRemainingPercent {
                 UsageBarRow(
                     title: "Code review",
@@ -356,13 +396,17 @@ private struct SwitcherLargeUsageView: View {
             if let token = entry.tokenUsage {
                 VStack(alignment: .leading, spacing: 4) {
                     ValueLine(
-                        title: "Today",
-                        value: WidgetFormat.costAndTokens(cost: token.sessionCostUSD, tokens: token.sessionTokens))
+                        title: token.sessionLabel,
+                        value: WidgetFormat.costAndTokens(
+                            cost: token.sessionCostUSD,
+                            tokens: token.sessionTokens,
+                            currencyCode: token.currencyCode))
                     ValueLine(
-                        title: "30d",
+                        title: token.last30DaysLabel,
                         value: WidgetFormat.costAndTokens(
                             cost: token.last30DaysCostUSD,
-                            tokens: token.last30DaysTokens))
+                            tokens: token.last30DaysTokens,
+                            currencyCode: token.currencyCode))
                 }
             }
             UsageHistoryChart(points: self.entry.dailyUsage, color: WidgetColors.color(for: self.entry.provider))
@@ -377,14 +421,15 @@ private struct SmallUsageView: View {
     var body: some View {
         VStack(alignment: .leading, spacing: 8) {
             HeaderView(provider: self.entry.provider, updatedAt: self.entry.updatedAt)
-            UsageBarRow(
-                title: ProviderDefaults.metadata[self.entry.provider]?.sessionLabel ?? "Session",
-                percentLeft: self.entry.primary?.remainingPercent,
-                color: WidgetColors.color(for: self.entry.provider))
-            UsageBarRow(
-                title: ProviderDefaults.metadata[self.entry.provider]?.weeklyLabel ?? "Weekly",
-                percentLeft: self.entry.secondary?.remainingPercent,
-                color: WidgetColors.color(for: self.entry.provider))
+            ForEach(WidgetUsageRow.rows(
+                for: self.entry,
+                limit: WidgetUsageRow.smallWidgetRowLimit(for: self.entry)))
+            { row in
+                UsageBarRow(
+                    title: row.title,
+                    percentLeft: row.percentLeft,
+                    color: WidgetColors.color(for: self.entry.provider))
+            }
             if let codeReview = entry.codeReviewRemainingPercent {
                 UsageBarRow(
                     title: "Code review",
@@ -402,21 +447,25 @@ private struct MediumUsageView: View {
     var body: some View {
         VStack(alignment: .leading, spacing: 10) {
             HeaderView(provider: self.entry.provider, updatedAt: self.entry.updatedAt)
-            UsageBarRow(
-                title: ProviderDefaults.metadata[self.entry.provider]?.sessionLabel ?? "Session",
-                percentLeft: self.entry.primary?.remainingPercent,
-                color: WidgetColors.color(for: self.entry.provider))
-            UsageBarRow(
-                title: ProviderDefaults.metadata[self.entry.provider]?.weeklyLabel ?? "Weekly",
-                percentLeft: self.entry.secondary?.remainingPercent,
-                color: WidgetColors.color(for: self.entry.provider))
+            ForEach(WidgetUsageRow.rows(
+                for: self.entry,
+                limit: WidgetUsageRow.mediumWidgetRowLimit(for: self.entry)))
+            { row in
+                UsageBarRow(
+                    title: row.title,
+                    percentLeft: row.percentLeft,
+                    color: WidgetColors.color(for: self.entry.provider))
+            }
             if let credits = entry.creditsRemaining {
                 ValueLine(title: "Credits", value: WidgetFormat.credits(credits))
             }
             if let token = entry.tokenUsage {
                 ValueLine(
-                    title: "Today",
-                    value: WidgetFormat.costAndTokens(cost: token.sessionCostUSD, tokens: token.sessionTokens))
+                    title: token.sessionLabel,
+                    value: WidgetFormat.costAndTokens(
+                        cost: token.sessionCostUSD,
+                        tokens: token.sessionTokens,
+                        currencyCode: token.currencyCode))
             }
         }
         .padding(12)
@@ -429,14 +478,12 @@ private struct LargeUsageView: View {
     var body: some View {
         VStack(alignment: .leading, spacing: 12) {
             HeaderView(provider: self.entry.provider, updatedAt: self.entry.updatedAt)
-            UsageBarRow(
-                title: ProviderDefaults.metadata[self.entry.provider]?.sessionLabel ?? "Session",
-                percentLeft: self.entry.primary?.remainingPercent,
-                color: WidgetColors.color(for: self.entry.provider))
-            UsageBarRow(
-                title: ProviderDefaults.metadata[self.entry.provider]?.weeklyLabel ?? "Weekly",
-                percentLeft: self.entry.secondary?.remainingPercent,
-                color: WidgetColors.color(for: self.entry.provider))
+            ForEach(WidgetUsageRow.rows(for: self.entry)) { row in
+                UsageBarRow(
+                    title: row.title,
+                    percentLeft: row.percentLeft,
+                    color: WidgetColors.color(for: self.entry.provider))
+            }
             if let codeReview = entry.codeReviewRemainingPercent {
                 UsageBarRow(
                     title: "Code review",
@@ -449,13 +496,17 @@ private struct LargeUsageView: View {
             if let token = entry.tokenUsage {
                 VStack(alignment: .leading, spacing: 4) {
                     ValueLine(
-                        title: "Today",
-                        value: WidgetFormat.costAndTokens(cost: token.sessionCostUSD, tokens: token.sessionTokens))
+                        title: token.sessionLabel,
+                        value: WidgetFormat.costAndTokens(
+                            cost: token.sessionCostUSD,
+                            tokens: token.sessionTokens,
+                            currencyCode: token.currencyCode))
                     ValueLine(
-                        title: "30d",
+                        title: token.last30DaysLabel,
                         value: WidgetFormat.costAndTokens(
                             cost: token.last30DaysCostUSD,
-                            tokens: token.last30DaysTokens))
+                            tokens: token.last30DaysTokens,
+                            currencyCode: token.currencyCode))
                 }
             }
             UsageHistoryChart(points: self.entry.dailyUsage, color: WidgetColors.color(for: self.entry.provider))
@@ -465,6 +516,130 @@ private struct LargeUsageView: View {
     }
 }
 
+struct WidgetUsageRow: Identifiable, Equatable {
+    let id: String
+    let title: String
+    let percentLeft: Double?
+
+    private enum AntigravityQuotaFamily {
+        case gemini
+        case claudeGPT
+    }
+
+    static func smallWidgetRowLimit(for entry: WidgetSnapshot.ProviderEntry) -> Int? {
+        self.antigravityQuotaSummaryRowLimit(for: entry, limit: 2)
+    }
+
+    static func mediumWidgetRowLimit(for entry: WidgetSnapshot.ProviderEntry) -> Int? {
+        self.antigravityQuotaSummaryRowLimit(for: entry, limit: 3)
+    }
+
+    private static func antigravityQuotaSummaryRowLimit(
+        for entry: WidgetSnapshot.ProviderEntry,
+        limit: Int) -> Int?
+    {
+        guard entry.provider == .antigravity,
+              entry.usageRows?.contains(where: {
+                  $0.id.hasPrefix("antigravity-quota-summary-")
+              }) == true
+        else {
+            return nil
+        }
+        return limit
+    }
+
+    static func rows(for entry: WidgetSnapshot.ProviderEntry, limit: Int? = nil) -> [WidgetUsageRow] {
+        let rows: [WidgetUsageRow]
+        if let usageRows = entry.usageRows {
+            rows = usageRows.map { row in
+                WidgetUsageRow(id: row.id, title: row.title, percentLeft: row.percentLeft)
+            }
+        } else {
+            let metadata = ProviderDefaults.metadata[entry.provider]
+            var defaultRows = [
+                WidgetUsageRow(
+                    id: "primary",
+                    title: metadata?.sessionLabel ?? "Session",
+                    percentLeft: entry.primary?.remainingPercent),
+                WidgetUsageRow(
+                    id: "secondary",
+                    title: metadata?.weeklyLabel ?? "Weekly",
+                    percentLeft: entry.secondary?.remainingPercent),
+            ]
+            if metadata?.supportsOpus == true {
+                defaultRows.append(WidgetUsageRow(
+                    id: "tertiary",
+                    title: metadata?.opusLabel ?? "Opus",
+                    percentLeft: entry.tertiary?.remainingPercent))
+            }
+            rows = defaultRows.filter { $0.percentLeft != nil }
+        }
+        guard let limit else { return rows }
+        if entry.provider == .antigravity,
+           limit >= 2,
+           rows.contains(where: { $0.id.hasPrefix("antigravity-quota-summary-") })
+        {
+            var selected = [AntigravityQuotaFamily.gemini, .claudeGPT].compactMap { family in
+                rows
+                    .filter { self.antigravityQuotaFamily(for: $0) == family }
+                    .min(by: self.isMoreConstrained)
+            }
+            let selectedIDs = Set(selected.map(\.id))
+            let fallbackRows = rows.enumerated()
+                .filter { !selectedIDs.contains($0.element.id) }
+                .sorted { lhs, rhs in
+                    switch (lhs.element.percentLeft, rhs.element.percentLeft) {
+                    case let (.some(left), .some(right)):
+                        left == right ? lhs.offset < rhs.offset : left < right
+                    case (.some, .none):
+                        true
+                    case (.none, .some):
+                        false
+                    case (.none, .none):
+                        lhs.offset < rhs.offset
+                    }
+                }
+                .map(\.element)
+            selected.append(contentsOf: fallbackRows.prefix(max(0, limit - selected.count)))
+            return selected
+        }
+        return Array(rows.prefix(max(0, limit)))
+    }
+
+    private static func antigravityQuotaFamily(for row: WidgetUsageRow) -> AntigravityQuotaFamily? {
+        guard row.id.hasPrefix("antigravity-quota-summary-") else { return nil }
+        let id = row.id.lowercased()
+        if id.contains("gemini") {
+            return .gemini
+        }
+        if id.contains("3p") || id.contains("third-party") {
+            return .claudeGPT
+        }
+
+        let title = row.title.lowercased()
+        if title.contains("gemini") {
+            return .gemini
+        }
+        if title.contains("claude") || title.contains("gpt") {
+            return .claudeGPT
+        }
+        return nil
+    }
+
+    private static func isMoreConstrained(_ lhs: WidgetUsageRow, than rhs: WidgetUsageRow) -> Bool {
+        switch (lhs.percentLeft, rhs.percentLeft) {
+        case let (.some(left), .some(right)):
+            left < right
+        case (.some, .none):
+            true
+        case (.none, .some):
+            false
+        case (.none, .none):
+            false
+        }
+    }
+}
+
 private struct HistoryView: View {
     let entry: WidgetSnapshot.ProviderEntry
     let isLarge: Bool
@@ -476,11 +651,17 @@ private struct HistoryView: View {
                 .frame(height: self.isLarge ? 90 : 60)
             if let token = entry.tokenUsage {
                 ValueLine(
-                    title: "Today",
-                    value: WidgetFormat.costAndTokens(cost: token.sessionCostUSD, tokens: token.sessionTokens))
+                    title: token.sessionLabel,
+                    value: WidgetFormat.costAndTokens(
+                        cost: token.sessionCostUSD,
+                        tokens: token.sessionTokens,
+                        currencyCode: token.currencyCode))
                 ValueLine(
-                    title: "30d",
-                    value: WidgetFormat.costAndTokens(cost: token.last30DaysCostUSD, tokens: token.last30DaysTokens))
+                    title: token.last30DaysLabel,
+                    value: WidgetFormat.costAndTokens(
+                        cost: token.last30DaysCostUSD,
+                        tokens: token.last30DaysTokens,
+                        currencyCode: token.currencyCode))
             }
         }
         .padding(12)
@@ -576,6 +757,10 @@ enum WidgetColors {
         switch provider {
         case .codex:
             Color(red: 73 / 255, green: 163 / 255, blue: 176 / 255)
+        case .openai:
+            Color(red: 15 / 255, green: 130 / 255, blue: 110 / 255)
+        case .azureopenai:
+            Color(red: 0, green: 120 / 255, blue: 212 / 255)
         case .claude:
             Color(red: 204 / 255, green: 124 / 255, blue: 94 / 255)
         case .gemini:
@@ -586,14 +771,22 @@ enum WidgetColors {
             Color(red: 0 / 255, green: 191 / 255, blue: 165 / 255) // #00BFA5 - Cursor teal
         case .opencode:
             Color(red: 59 / 255, green: 130 / 255, blue: 246 / 255)
+        case .opencodego:
+            Color(red: 59 / 255, green: 130 / 255, blue: 246 / 255)
+        case .alibaba, .alibabatokenplan:
+            Color(red: 1.0, green: 106 / 255, blue: 0)
         case .zai:
             Color(red: 232 / 255, green: 90 / 255, blue: 106 / 255)
         case .factory:
             Color(red: 255 / 255, green: 107 / 255, blue: 53 / 255) // Factory orange
         case .copilot:
             Color(red: 168 / 255, green: 85 / 255, blue: 247 / 255) // Purple
+        case .devin:
+            Color(red: 70 / 255, green: 180 / 255, blue: 130 / 255)
         case .minimax:
             Color(red: 254 / 255, green: 96 / 255, blue: 60 / 255)
+        case .manus:
+            Color(red: 24 / 255, green: 24 / 255, blue: 24 / 255)
         case .vertexai:
             Color(red: 66 / 255, green: 133 / 255, blue: 244 / 255) // Google Blue
         case .kilo:
@@ -608,16 +801,64 @@ enum WidgetColors {
             Color(red: 254 / 255, green: 96 / 255, blue: 60 / 255) // Kimi orange
         case .kimik2:
             Color(red: 76 / 255, green: 0 / 255, blue: 255 / 255) // Kimi K2 purple
+        case .moonshot:
+            Color(red: 32 / 255, green: 93 / 255, blue: 235 / 255)
         case .amp:
             Color(red: 220 / 255, green: 38 / 255, blue: 38 / 255) // Amp red
+        case .t3chat:
+            Color(red: 245 / 255, green: 102 / 255, blue: 71 / 255)
         case .ollama:
             Color(red: 32 / 255, green: 32 / 255, blue: 32 / 255) // Ollama charcoal
         case .synthetic:
             Color(red: 20 / 255, green: 20 / 255, blue: 20 / 255) // Synthetic charcoal
         case .openrouter:
             Color(red: 111 / 255, green: 66 / 255, blue: 193 / 255) // OpenRouter purple
+        case .elevenlabs:
+            Color(red: 235 / 255, green: 235 / 255, blue: 230 / 255)
         case .warp:
             Color(red: 147 / 255, green: 139 / 255, blue: 180 / 255)
+        case .windsurf:
+            Color(red: 52 / 255, green: 232 / 255, blue: 187 / 255) // Windsurf #34e8bb
+        case .perplexity:
+            Color(red: 32 / 255, green: 178 / 255, blue: 170 / 255) // Perplexity teal
+        case .mimo:
+            Color(red: 1.0, green: 105 / 255, blue: 0)
+        case .doubao:
+            Color(red: 45 / 255, green: 136 / 255, blue: 255 / 255) // Doubao blue
+        case .abacus:
+            Color(red: 56 / 255, green: 189 / 255, blue: 248 / 255)
+        case .mistral:
+            Color(red: 255 / 255, green: 80 / 255, blue: 15 / 255) // Mistral orange
+        case .deepseek:
+            Color(red: 82 / 255, green: 125 / 255, blue: 240 / 255)
+        case .codebuff:
+            Color(red: 68 / 255, green: 255 / 255, blue: 0 / 255) // Codebuff lime
+        case .crof:
+            Color(red: 46 / 255, green: 171 / 255, blue: 148 / 255)
+        case .venice:
+            Color(red: 51 / 255, green: 153 / 255, blue: 1.0)
+        case .commandcode:
+            Color(red: 0, green: 0, blue: 0)
+        case .stepfun:
+            Color(red: 255 / 255, green: 140 / 255, blue: 0 / 255) // StepFun orange
+        case .bedrock:
+            Color(red: 255 / 255, green: 153 / 255, blue: 0 / 255) // AWS orange
+        case .grok:
+            Color(red: 16 / 255, green: 163 / 255, blue: 127 / 255) // Grok teal
+        case .groq:
+            Color(red: 245 / 255, green: 104 / 255, blue: 68 / 255)
+        case .llmproxy:
+            Color(red: 36 / 255, green: 180 / 255, blue: 126 / 255)
+        case .litellm:
+            Color(red: 76 / 255, green: 137 / 255, blue: 240 / 255)
+        case .deepgram:
+            Color(red: 10 / 255, green: 18 / 255, blue: 27 / 255)
+        case .poe:
+            Color(red: 0.15, green: 0.68, blue: 0.38)
+        case .chutes:
+            Color(red: 24 / 255, green: 160 / 255, blue: 88 / 255)
+        case .zed:
+            Color(red: 64 / 255, green: 156 / 255, blue: 255 / 255)
         }
     }
 }
@@ -636,21 +877,21 @@ enum WidgetFormat {
         return formatter.string(from: NSNumber(value: value)) ?? String(format: "%.2f", value)
     }
 
-    static func costAndTokens(cost: Double?, tokens: Int?) -> String {
-        let costText = cost.map(self.usd) ?? "—"
+    static func costAndTokens(cost: Double?, tokens: Int?, currencyCode: String = "USD") -> String {
+        let costText = cost.map { self.currency($0, code: currencyCode) } ?? "—"
         if let tokens {
             return "\(costText) · \(self.tokenCount(tokens))"
         }
         return costText
     }
 
-    static func usd(_ value: Double) -> String {
+    static func currency(_ value: Double, code: String) -> String {
         let formatter = NumberFormatter()
         formatter.numberStyle = .currency
-        formatter.currencyCode = "USD"
+        formatter.currencyCode = code
         formatter.maximumFractionDigits = 2
         formatter.minimumFractionDigits = 2
-        return formatter.string(from: NSNumber(value: value)) ?? String(format: "$%.2f", value)
+        return formatter.string(from: NSNumber(value: value)) ?? "\(code) \(String(format: "%.2f", value))"
     }
 
     static func tokenCount(_ value: Int) -> String {
@@ -663,6 +904,7 @@ enum WidgetFormat {
 
     static func relativeDate(_ date: Date) -> String {
         let formatter = RelativeDateTimeFormatter()
+        formatter.locale = Locale(identifier: "en_US")
         formatter.unitsStyle = .short
         return formatter.localizedString(for: date, relativeTo: Date())
     }
diff --git a/Sources/CodexBarWidget/CombinedBurnDownWidgetViews.swift b/Sources/CodexBarWidget/CombinedBurnDownWidgetViews.swift
new file mode 100644
index 0000000000..258812b5ad
--- /dev/null
+++ b/Sources/CodexBarWidget/CombinedBurnDownWidgetViews.swift
@@ -0,0 +1,480 @@
+import AppKit
+import CodexBarCore
+import SwiftUI
+import WidgetKit
+
+// MARK: - Entry View
+
+struct CombinedBurnDownWidgetView: View {
+    let entry: CombinedBurnDownEntry
+
+    var body: some View {
+        let state = BurnDownState(
+            snapshot: self.entry.snapshot,
+            provider: self.entry.provider,
+            selection: .session)
+
+        Group {
+            if let state {
+                CombinedBurnDownLayout(state: state, provider: self.entry.provider)
+            } else {
+                self.emptyState
+            }
+        }
+        .containerBackground(for: .widget) {
+            BurnWidgetBackground()
+        }
+    }
+
+    private var emptyState: some View {
+        VStack(spacing: 6) {
+            Text("Open CodexBar")
+                .font(.body)
+                .fontWeight(.semibold)
+            Text("Usage data will appear once the app refreshes.")
+                .font(.caption)
+                .multilineTextAlignment(.center)
+                .opacity(0.55)
+        }
+        .padding(12)
+    }
+}
+
+// MARK: - Layout
+
+private struct CombinedBurnDownLayout: View {
+    @Environment(\.widgetRenderingMode) private var renderingMode
+    @Environment(\.colorScheme) private var colorScheme
+
+    let state: BurnDownState
+    let provider: UsageProvider
+
+    var body: some View {
+        let dark = self.colorScheme == .dark
+        let isMonochrome = self.renderingMode != .fullColor
+
+        let sessionWindow = self.state.primaryWindow
+        let weeklyWindow = self.state.secondaryWindow
+
+        let sessionGeom = sessionWindow.map { BurnGeom(window: $0) }
+        let weeklyGeom = weeklyWindow.map { BurnGeom(window: $0) }
+
+        // Use a neutral baseline theme for the header/hairline colors
+        let baseGeom = sessionGeom ?? weeklyGeom ?? BurnGeom(
+            window: RateWindow(
+                usedPercent: 50,
+                windowMinutes: 300,
+                resetsAt: Date().addingTimeInterval(2.5 * 3600),
+                resetDescription: nil))
+        let baseTheme = BurnTheme(
+            provider: self.provider,
+            geom: baseGeom,
+            dark: dark,
+            isMonochrome: isMonochrome)
+
+        VStack(spacing: 0) {
+            // Header
+            HStack(alignment: .center) {
+                HStack(spacing: 6) {
+                    Circle()
+                        .fill(baseTheme.brandDot)
+                        .frame(width: 7, height: 7)
+                        .shadow(color: baseTheme.brandDot.opacity(0.7), radius: 3.5)
+                    Text(burnProviderName(self.provider))
+                        .font(.system(size: 14, weight: .semibold))
+                        .foregroundStyle(baseTheme.text)
+                        .lineLimit(1)
+                }
+                Spacer()
+                Text("Session & weekly limits")
+                    .font(.system(size: 10))
+                    .foregroundStyle(baseTheme.sub)
+                    .kerning(0.3)
+            }
+
+            // Two rows
+            VStack(spacing: 0) {
+                // 5H row — shows % remaining by default
+                if let win = sessionWindow, let geom = sessionGeom {
+                    CombinedBurnRow(
+                        window: win,
+                        geom: geom,
+                        theme: BurnTheme(
+                            provider: self.provider,
+                            geom: geom,
+                            dark: dark,
+                            isMonochrome: isMonochrome),
+                        tag: burnCompactWindowLabel(win.windowMinutes, fallback: "S"),
+                        periods: 5,
+                        metric: .remaining,
+                        dark: dark,
+                        blankChart: self.state.blankPrimaryChart,
+                        resetsAtOverride: self.state.selectedResetOverride)
+                } else {
+                    CombinedEmptyRow(tag: "S", theme: baseTheme)
+                }
+
+                Rectangle()
+                    .fill(baseTheme.hair)
+                    .frame(height: 1)
+
+                // 7D row — shows % off pace by default
+                if let win = weeklyWindow, let geom = weeklyGeom {
+                    CombinedBurnRow(
+                        window: win,
+                        geom: geom,
+                        theme: BurnTheme(
+                            provider: self.provider,
+                            geom: geom,
+                            dark: dark,
+                            isMonochrome: isMonochrome),
+                        tag: burnCompactWindowLabel(win.windowMinutes, fallback: "W"),
+                        periods: 7,
+                        metric: .pace,
+                        dark: dark)
+                } else {
+                    CombinedEmptyRow(tag: "W", theme: baseTheme)
+                }
+            }
+            .frame(maxHeight: .infinity)
+            .padding(.top, 6)
+        }
+        .padding(.horizontal, 15)
+        .padding(.top, 12)
+        .padding(.bottom, 11)
+    }
+}
+
+// MARK: - Metric
+
+private enum CombinedMetric {
+    case remaining // % left (default for 5H)
+    case pace // % off ideal pace (default for 7D)
+    case used // % consumed
+}
+
+// MARK: - Row
+
+private struct CombinedBurnRow: View {
+    let window: RateWindow
+    let geom: BurnGeom
+    let theme: BurnTheme
+    let tag: String
+    let periods: Int
+    let metric: CombinedMetric
+    let dark: Bool
+    var blankChart = false
+    var resetsAtOverride: Date?
+
+    var body: some View {
+        let windowMins = self.window.windowMinutes ?? 300
+        let isDailyWindow = windowMins >= 1440
+
+        let heroNum = self.metric == .pace ? abs(Int(self.geom.margin.rounded()))
+            : self.metric == .used ? Int((100 - self.geom.vNow).rounded())
+            : Int(self.geom.vNow.rounded())
+        let suffix = self.metric == .remaining ? "left" : self.metric == .used ? "used" : ""
+        let prefixArrow = self.metric == .pace
+
+        let paceWord: String = self.geom.depleted ? "spent" : self.geom.fresh ? "full"
+            : self.geom.status == .ahead ? "under pace"
+            : self.geom.status == .behind ? "over pace" : "on pace"
+        let arrow: String = self.geom.depleted ? "■" : self.geom.fresh ? "◆"
+            : self.geom.status == .ahead ? "▲" : self.geom.status == .behind ? "▼" : "●"
+
+        let explicitReset = self.blankChart
+            ? self.resetsAtOverride
+            : self.resetsAtOverride ?? self.window.resetsAt
+        let now = Date()
+        let estimatedResetMinutes = self.blankChart || self.geom.tNow >= 1
+            ? nil
+            : (1 - self.geom.tNow) * Double(windowMins)
+        let effectiveResetDate = burnEffectiveResetDate(
+            explicitResetAt: explicitReset,
+            estimatedResetMinutes: estimatedResetMinutes,
+            now: now)
+        let heroColor = self.geom.depleted ? self.theme.danger : self.theme.statusColor
+
+        HStack(alignment: .center, spacing: 12) {
+            // Label column
+            VStack(alignment: .leading, spacing: 0) {
+                // Line 1: tag + (arrow for non-pace metrics) + pace word
+                // For remaining/used: "5H ▼ over pace". For pace: "7D on pace" (arrow is on hero line).
+                HStack(alignment: .firstTextBaseline, spacing: 5) {
+                    Text(self.tag)
+                        .font(.system(size: 9.5, weight: .heavy))
+                        .foregroundStyle(self.theme.sub)
+                        .kerning(1)
+                    HStack(alignment: .firstTextBaseline, spacing: 2) {
+                        if !prefixArrow {
+                            Text(arrow)
+                                .font(.system(size: 8))
+                                .foregroundStyle(self.theme.statusColor)
+                        }
+                        Text(paceWord)
+                            .font(.system(size: 10, weight: .semibold))
+                            .foregroundStyle(self.theme.statusColor)
+                    }
+                    .lineLimit(1)
+                }
+
+                // Line 2: hero number. Pace metric prefixes an arrow glyph.
+                HStack(alignment: .lastTextBaseline, spacing: 2) {
+                    if prefixArrow {
+                        Text(arrow)
+                            .font(.system(size: 13, weight: .bold))
+                            .foregroundStyle(heroColor)
+                    }
+                    Text("\(heroNum)")
+                        .font(.system(size: 27, weight: .semibold))
+                        .foregroundStyle(heroColor)
+                        .monospacedDigit()
+                        .lineLimit(1)
+                        .minimumScaleFactor(0.8)
+                    Text("%")
+                        .font(.system(size: 13, weight: .medium))
+                        .foregroundStyle(self.theme.sub)
+                    if !suffix.isEmpty {
+                        Text(suffix)
+                            .font(.system(size: 10))
+                            .foregroundStyle(self.theme.sub)
+                    }
+                }
+                .padding(.top, 1)
+
+                // Line 3: reset line — refresh glyph + countdown + compact time
+                HStack(spacing: 4) {
+                    Image(systemName: "arrow.clockwise")
+                        .font(.system(size: 9))
+                        .foregroundStyle(self.theme.sub.opacity(0.85))
+                    if let effectiveResetDate {
+                        Text(effectiveResetDate, style: .relative)
+                            .font(.system(size: 9.5, weight: .medium))
+                            .foregroundStyle(self.theme.text)
+                            .monospacedDigit()
+                        Text("· \(combinedCompactResetTime(effectiveResetDate, isDailyWindow: isDailyWindow))")
+                            .font(.system(size: 9.5, weight: .medium))
+                            .foregroundStyle(self.theme.text)
+                    } else {
+                        Text("—")
+                            .font(.system(size: 9.5, weight: .medium))
+                            .foregroundStyle(self.theme.text)
+                    }
+                }
+                .padding(.top, 2)
+                .lineLimit(1)
+            }
+            .frame(width: 112, alignment: .leading)
+
+            // Chart column — blanked when the session window is blocked by an exhausted
+            // weekly cap; there is no session burn to chart until the weekly resets.
+            if self.blankChart {
+                Color.clear
+                    .frame(maxWidth: .infinity)
+                    .frame(height: 50)
+            } else {
+                CombinedBurnChartCanvas(geom: self.geom, theme: self.theme, periods: self.periods, dark: self.dark)
+                    .frame(maxWidth: .infinity)
+                    .frame(height: 50)
+            }
+        }
+        .frame(maxHeight: .infinity)
+    }
+}
+
+// MARK: - Empty Row
+
+private struct CombinedEmptyRow: View {
+    let tag: String
+    let theme: BurnTheme
+
+    var body: some View {
+        HStack {
+            Text(self.tag)
+                .font(.system(size: 9.5, weight: .heavy))
+                .foregroundStyle(self.theme.sub)
+                .kerning(1)
+            Text("No data")
+                .font(.system(size: 10))
+                .foregroundStyle(self.theme.sub)
+            Spacer()
+        }
+        .frame(maxHeight: .infinity)
+    }
+}
+
+// MARK: - Mini Chart Canvas
+
+private struct CombinedBurnChartCanvas: View {
+    let geom: BurnGeom
+    let theme: BurnTheme
+    let periods: Int
+    let dark: Bool
+
+    var body: some View {
+        Canvas { context, size in
+            let w = size.width
+            let h = size.height
+            let padT: CGFloat = 5
+            let padB: CGFloat = 2
+            let padL: CGFloat = 1
+            let padR: CGFloat = 1
+
+            func X(_ t: Double) -> CGFloat {
+                padL + CGFloat(t) * (w - padL - padR)
+            }
+            func Y(_ v: Double) -> CGFloat {
+                padT + CGFloat(1 - v / 100) * (h - padT - padB)
+            }
+
+            let tNow = self.geom.tNow
+            let vNow = self.geom.vNow
+            let barColor = self.dark ? Color.white : Color.black
+
+            // --- Usage bars (background texture) ---
+            // Drawn first so the actual line renders on top.
+            // Heights are relative-to-ideal: idealPerPeriod maps to ~46% of plot height.
+            let plotH = h - padT - padB
+            let refH = 0.46 * plotH // reference height = ideal-pace bar height
+            let idealPerPeriod = 100.0 / Double(self.periods)
+            let burnRate = tNow > 0.001 ? (100.0 - vNow) / tNow : 0.0 // %/unit-t
+            let slotW = (w - padL - padR) / CGFloat(self.periods)
+
+            for i in 0..<self.periods {
+                let slotStart = Double(i) / Double(self.periods)
+                let slotEnd = Double(i + 1) / Double(self.periods)
+                let slotX = padL + CGFloat(slotStart) * (w - padL - padR)
+
+                if slotEnd <= tNow {
+                    // Completed period — full-width bar
+                    let consumed = burnRate * (slotEnd - slotStart)
+                    let ratio = consumed / idealPerPeriod
+                    let totalBarH = CGFloat(ratio) * refH
+                    let baseH = min(totalBarH, refH)
+
+                    if baseH > 0 {
+                        let rect = CGRect(
+                            x: slotX,
+                            y: h - padB - baseH,
+                            width: slotW - 1,
+                            height: baseH)
+                        context.fill(Path(rect), with: .color(barColor.opacity(0.17)))
+                    }
+                    // Overage segment — above ideal reference line
+                    if totalBarH > refH {
+                        let overH = totalBarH - refH
+                        let rect = CGRect(
+                            x: slotX,
+                            y: h - padB - totalBarH,
+                            width: slotW - 1,
+                            height: overH)
+                        context.fill(Path(rect), with: .color(barColor.opacity(0.34)))
+                    }
+                } else if slotStart < tNow {
+                    // Current (partial) period — narrower bar ending at tNow
+                    let partialFrac = (tNow - slotStart) / (slotEnd - slotStart)
+                    let consumed = burnRate * (tNow - slotStart)
+                    let ratio = consumed / idealPerPeriod
+                    let totalBarH = CGFloat(ratio) * refH
+                    let baseH = min(totalBarH, refH)
+                    let barW = CGFloat(partialFrac) * (slotW - 1)
+
+                    if baseH > 0 {
+                        let rect = CGRect(
+                            x: slotX,
+                            y: h - padB - baseH,
+                            width: barW,
+                            height: baseH)
+                        context.fill(Path(rect), with: .color(barColor.opacity(0.13)))
+                    }
+                    if totalBarH > refH {
+                        let overH = totalBarH - refH
+                        let rect = CGRect(
+                            x: slotX,
+                            y: h - padB - totalBarH,
+                            width: barW,
+                            height: overH)
+                        context.fill(Path(rect), with: .color(barColor.opacity(0.26)))
+                    }
+                } else {
+                    // Future period — faint full-height placeholder
+                    let rect = CGRect(
+                        x: slotX,
+                        y: h - padB - refH,
+                        width: slotW - 1,
+                        height: refH)
+                    context.fill(Path(rect), with: .color(barColor.opacity(0.045)))
+                }
+            }
+
+            // --- Now vertical hairline ---
+            do {
+                var p = Path()
+                p.move(to: CGPoint(x: X(tNow), y: Y(100)))
+                p.addLine(to: CGPoint(x: X(tNow), y: Y(0)))
+                context.stroke(p, with: .color(self.theme.chartGrid), lineWidth: 1)
+            }
+
+            // --- Baseline ---
+            do {
+                var p = Path()
+                p.move(to: CGPoint(x: X(0), y: Y(0)))
+                p.addLine(to: CGPoint(x: X(1), y: Y(0)))
+                context.stroke(p, with: .color(self.theme.chartGrid), lineWidth: 1)
+            }
+
+            // --- Ideal line (dashed, recedes) ---
+            do {
+                var p = Path()
+                p.move(to: CGPoint(x: X(0), y: Y(100)))
+                p.addLine(to: CGPoint(x: X(1), y: Y(0)))
+                context.stroke(
+                    p,
+                    with: .color(self.theme.chartIdeal),
+                    style: StrokeStyle(lineWidth: 1.4, lineCap: .round, dash: [2.5, 3]))
+            }
+
+            // --- Projection (fine dotted) ---
+            if self.geom.slope < -0.01 {
+                var p = Path()
+                p.move(to: CGPoint(x: X(tNow), y: Y(vNow)))
+                p.addLine(to: CGPoint(x: X(self.geom.projT), y: Y(self.geom.projV)))
+                context.stroke(
+                    p,
+                    with: .color(self.theme.chartProj.opacity(0.95)),
+                    style: StrokeStyle(lineWidth: 1.6, lineCap: .round, dash: [0.5, 3.5]))
+            }
+
+            // --- Actual line (solid, dominant) ---
+            do {
+                var p = Path()
+                p.move(to: CGPoint(x: X(0), y: Y(100)))
+                p.addLine(to: CGPoint(x: X(tNow), y: Y(vNow)))
+                context.stroke(
+                    p,
+                    with: .color(self.theme.chartLine),
+                    style: StrokeStyle(lineWidth: 2.4, lineCap: .round, lineJoin: .round))
+            }
+
+            // --- Now dot (filled, ringed) ---
+            let dotCenter = CGPoint(x: X(tNow), y: Y(vNow))
+            let ringPath = Path(ellipseIn: CGRect(
+                x: dotCenter.x - 5.4, y: dotCenter.y - 5.4, width: 10.8, height: 10.8))
+            context.fill(ringPath, with: .color(self.theme.chartNowRing))
+            let dotPath = Path(ellipseIn: CGRect(
+                x: dotCenter.x - 3.4, y: dotCenter.y - 3.4, width: 6.8, height: 6.8))
+            context.fill(dotPath, with: .color(self.theme.chartNowDot))
+        }
+    }
+}
+
+// MARK: - Compact reset time helper
+
+/// Formats a reset date compactly: "4:30p", "5p", "Sun 9a".
+/// Weekday prefix is added for the 7-day window or when the reset is ≥20h away.
+private func combinedCompactResetTime(_ date: Date, isDailyWindow: Bool) -> String {
+    let includeDay = isDailyWindow || date.timeIntervalSinceNow >= 20 * 3600
+    let formatter = DateFormatter()
+    formatter.setLocalizedDateFormatFromTemplate(includeDay ? "EEEjm" : "jm")
+    return formatter.string(from: date)
+}
diff --git a/Tests/CodexBarTests/APITokenFetchStrategyTests.swift b/Tests/CodexBarTests/APITokenFetchStrategyTests.swift
new file mode 100644
index 0000000000..f1eea0b207
--- /dev/null
+++ b/Tests/CodexBarTests/APITokenFetchStrategyTests.swift
@@ -0,0 +1,81 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+private enum APITokenStrategyTestError: Error {
+    case missingCredentials
+}
+
+private struct APITokenStrategyStubClaudeFetcher: ClaudeUsageFetching {
+    func loadLatestUsage(model _: String) async throws -> ClaudeUsageSnapshot {
+        throw APITokenStrategyTestError.missingCredentials
+    }
+
+    func debugRawProbe(model _: String) async -> String {
+        "stub"
+    }
+
+    func detectVersion() -> String? {
+        nil
+    }
+}
+
+struct APITokenFetchStrategyTests {
+    @Test
+    func `missing token is unavailable and preserves provider error`() async {
+        let strategy = Self.makeStrategy()
+        let context = Self.makeContext(environment: [:])
+
+        #expect(await strategy.isAvailable(context) == false)
+        await #expect(throws: APITokenStrategyTestError.missingCredentials) {
+            try await strategy.fetch(context)
+        }
+    }
+
+    @Test
+    func `resolved token loads usage and stamps result metadata`() async throws {
+        let strategy = Self.makeStrategy()
+        let context = Self.makeContext(environment: ["TEST_API_KEY": "test-token"])
+
+        #expect(await strategy.isAvailable(context))
+        let result = try await strategy.fetch(context)
+
+        #expect(result.strategyID == "test.api")
+        #expect(result.strategyKind == .apiToken)
+        #expect(result.sourceLabel == "test-source")
+        #expect(result.usage.updatedAt == Date(timeIntervalSince1970: 42))
+        #expect(strategy.shouldFallback(on: APITokenStrategyTestError.missingCredentials, context: context) == false)
+    }
+
+    private static func makeStrategy() -> APITokenFetchStrategy {
+        APITokenFetchStrategy(
+            id: "test.api",
+            sourceLabel: "test-source",
+            resolveToken: { $0["TEST_API_KEY"] },
+            missingCredentialsError: { APITokenStrategyTestError.missingCredentials },
+            loadUsage: { token, context in
+                UsageSnapshot(
+                    primary: nil,
+                    secondary: nil,
+                    updatedAt: token == context.env["TEST_API_KEY"]
+                        ? Date(timeIntervalSince1970: 42)
+                        : Date.distantFuture)
+            })
+    }
+
+    private static func makeContext(environment: [String: String]) -> ProviderFetchContext {
+        let browserDetection = BrowserDetection(cacheTTL: 0)
+        return ProviderFetchContext(
+            runtime: .app,
+            sourceMode: .api,
+            includeCredits: false,
+            webTimeout: 1,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: environment,
+            settings: nil,
+            fetcher: UsageFetcher(environment: environment),
+            claudeFetcher: APITokenStrategyStubClaudeFetcher(),
+            browserDetection: browserDetection)
+    }
+}
diff --git a/Tests/CodexBarTests/AbacusProviderTests.swift b/Tests/CodexBarTests/AbacusProviderTests.swift
new file mode 100644
index 0000000000..8aca07d2b9
--- /dev/null
+++ b/Tests/CodexBarTests/AbacusProviderTests.swift
@@ -0,0 +1,289 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+// MARK: - Descriptor Tests
+
+struct AbacusDescriptorTests {
+    @Test
+    func `descriptor has correct identity`() {
+        let descriptor = AbacusProviderDescriptor.descriptor
+        #expect(descriptor.id == .abacus)
+        #expect(descriptor.metadata.displayName == "Abacus AI")
+        #expect(descriptor.metadata.cliName == "abacusai")
+    }
+
+    @Test
+    func `descriptor does not expose a separate credits panel`() {
+        let meta = AbacusProviderDescriptor.descriptor.metadata
+        #expect(meta.supportsCredits == false)
+        #expect(meta.supportsOpus == false)
+    }
+
+    @Test
+    func `descriptor is not primary provider`() {
+        let meta = AbacusProviderDescriptor.descriptor.metadata
+        #expect(meta.isPrimaryProvider == false)
+        #expect(meta.defaultEnabled == false)
+    }
+
+    @Test
+    func `descriptor supports auto and web source modes`() {
+        let descriptor = AbacusProviderDescriptor.descriptor
+        #expect(descriptor.fetchPlan.sourceModes.contains(.auto))
+        #expect(descriptor.fetchPlan.sourceModes.contains(.web))
+    }
+
+    @Test
+    func `descriptor has no version detector`() {
+        let descriptor = AbacusProviderDescriptor.descriptor
+        #expect(descriptor.cli.versionDetector == nil)
+    }
+
+    @Test
+    func `descriptor does not support token cost`() {
+        let descriptor = AbacusProviderDescriptor.descriptor
+        #expect(descriptor.tokenCost.supportsTokenCost == false)
+    }
+
+    @Test
+    func `cli aliases include abacus-ai`() {
+        let descriptor = AbacusProviderDescriptor.descriptor
+        #expect(descriptor.cli.aliases.contains("abacus-ai"))
+    }
+
+    @Test
+    func `dashboard url points to compute points page`() {
+        let meta = AbacusProviderDescriptor.descriptor.metadata
+        #expect(meta.dashboardURL?.contains("compute-points") == true)
+    }
+}
+
+// MARK: - Usage Snapshot Conversion Tests
+
+struct AbacusUsageSnapshotTests {
+    @Test
+    func `converts full snapshot to usage snapshot`() throws {
+        let resetDate = Date(timeIntervalSince1970: 1_700_000_000)
+        let snapshot = AbacusUsageSnapshot(
+            creditsUsed: 250,
+            creditsTotal: 1000,
+            resetsAt: resetDate,
+            planName: "Pro")
+
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.primary != nil)
+        #expect(abs((usage.primary?.usedPercent ?? 0) - 25.0) < 0.01)
+        #expect(usage.primary?.resetDescription == "250 / 1,000 credits")
+        #expect(usage.primary?.resetsAt == resetDate)
+        // Window derived from actual billing cycle (1 calendar month before resetDate)
+        let cycleStart = try #require(Calendar.current.date(byAdding: .month, value: -1, to: resetDate))
+        let expectedMinutes = Int(resetDate.timeIntervalSince(cycleStart) / 60)
+        #expect(usage.primary?.windowMinutes == expectedMinutes)
+        #expect(usage.secondary == nil)
+        #expect(usage.tertiary == nil)
+        #expect(usage.identity?.providerID == .abacus)
+        #expect(usage.identity?.loginMethod == "Pro")
+    }
+
+    @Test
+    func `handles zero usage`() {
+        let snapshot = AbacusUsageSnapshot(
+            creditsUsed: 0,
+            creditsTotal: 500,
+            resetsAt: nil,
+            planName: "Basic")
+
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary?.usedPercent == 0.0)
+        #expect(usage.primary?.resetDescription == "0 / 500 credits")
+    }
+
+    @Test
+    func `handles full usage`() {
+        let snapshot = AbacusUsageSnapshot(
+            creditsUsed: 1000,
+            creditsTotal: 1000,
+            resetsAt: nil,
+            planName: nil)
+
+        let usage = snapshot.toUsageSnapshot()
+        #expect(abs((usage.primary?.usedPercent ?? 0) - 100.0) < 0.01)
+        #expect(usage.primary?.resetDescription == "1,000 / 1,000 credits")
+    }
+
+    @Test
+    func `handles nil credits gracefully`() {
+        let snapshot = AbacusUsageSnapshot(
+            creditsUsed: nil,
+            creditsTotal: nil,
+            resetsAt: nil,
+            planName: nil)
+
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary?.usedPercent == 0.0)
+        #expect(usage.primary?.resetDescription == nil)
+    }
+
+    @Test
+    func `handles nil total with non-nil used`() {
+        let snapshot = AbacusUsageSnapshot(
+            creditsUsed: 100,
+            creditsTotal: nil,
+            resetsAt: nil,
+            planName: nil)
+
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary?.usedPercent == 0.0)
+    }
+
+    @Test
+    func `handles zero total credits`() {
+        let snapshot = AbacusUsageSnapshot(
+            creditsUsed: 0,
+            creditsTotal: 0,
+            resetsAt: nil,
+            planName: nil)
+
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary?.usedPercent == 0.0)
+    }
+
+    @Test
+    func `formats large credit values with comma grouping`() {
+        let snapshot = AbacusUsageSnapshot(
+            creditsUsed: 12345,
+            creditsTotal: 50000,
+            resetsAt: nil,
+            planName: nil)
+
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary?.resetDescription == "12,345 / 50,000 credits")
+    }
+
+    @Test
+    func `formats fractional credit values`() {
+        let snapshot = AbacusUsageSnapshot(
+            creditsUsed: 42.5,
+            creditsTotal: 100,
+            resetsAt: nil,
+            planName: nil)
+
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary?.resetDescription == "42.5 / 100 credits")
+    }
+
+    @Test
+    func `window minutes represents monthly cycle`() {
+        let snapshot = AbacusUsageSnapshot(
+            creditsUsed: 0,
+            creditsTotal: 100,
+            resetsAt: nil,
+            planName: nil)
+
+        let usage = snapshot.toUsageSnapshot()
+        // 30 days * 24 hours * 60 minutes = 43200
+        #expect(usage.primary?.windowMinutes == 43200)
+    }
+
+    @Test
+    func `identity has no email or organization`() {
+        let snapshot = AbacusUsageSnapshot(
+            creditsUsed: 0,
+            creditsTotal: 100,
+            resetsAt: nil,
+            planName: "Pro")
+
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.identity?.accountEmail == nil)
+        #expect(usage.identity?.accountOrganization == nil)
+    }
+}
+
+// MARK: - Error Description Tests
+
+struct AbacusErrorTests {
+    @Test
+    func `noSessionCookie error mentions login`() {
+        let error = AbacusUsageError.noSessionCookie
+        #expect(error.errorDescription?.contains("log in") == true)
+    }
+
+    @Test
+    func `sessionExpired error mentions expired`() {
+        let error = AbacusUsageError.sessionExpired
+        #expect(error.errorDescription?.contains("expired") == true)
+    }
+
+    @Test
+    func `networkError includes message`() {
+        let error = AbacusUsageError.networkError("HTTP 500")
+        #expect(error.errorDescription?.contains("HTTP 500") == true)
+    }
+
+    @Test
+    func `parseFailed includes message`() {
+        let error = AbacusUsageError.parseFailed("Invalid JSON")
+        #expect(error.errorDescription?.contains("Invalid JSON") == true)
+    }
+
+    @Test
+    func `unauthorized error mentions login`() {
+        let error = AbacusUsageError.unauthorized
+        #expect(error.errorDescription?.contains("log in") == true)
+    }
+}
+
+// MARK: - Error Classification Tests
+
+struct AbacusErrorClassificationTests {
+    @Test
+    func `unauthorized is recoverable and auth related`() {
+        let error = AbacusUsageError.unauthorized
+        #expect(error.isRecoverable == true)
+        #expect(error.isAuthRelated == true)
+    }
+
+    @Test
+    func `sessionExpired is recoverable and auth related`() {
+        let error = AbacusUsageError.sessionExpired
+        #expect(error.isRecoverable == true)
+        #expect(error.isAuthRelated == true)
+    }
+
+    @Test
+    func `parseFailed is not recoverable`() {
+        let error = AbacusUsageError.parseFailed("bad json")
+        #expect(error.isRecoverable == false)
+        #expect(error.isAuthRelated == false)
+        #expect(error.shouldTryNextImportedSession == true)
+        #expect(error.shouldClearCachedCookie == true)
+    }
+
+    @Test
+    func `networkError is not recoverable`() {
+        let error = AbacusUsageError.networkError("timeout")
+        #expect(error.isRecoverable == false)
+        #expect(error.isAuthRelated == false)
+        #expect(error.shouldTryNextImportedSession == true)
+        #expect(error.shouldClearCachedCookie == false)
+    }
+
+    @Test
+    func `noSessionCookie is not recoverable`() {
+        let error = AbacusUsageError.noSessionCookie
+        #expect(error.isRecoverable == false)
+        #expect(error.isAuthRelated == false)
+        #expect(error.shouldTryNextImportedSession == false)
+        #expect(error.shouldClearCachedCookie == false)
+    }
+
+    @Test
+    func `auth failures continue imported session scanning`() {
+        #expect(AbacusUsageError.unauthorized.shouldTryNextImportedSession == true)
+        #expect(AbacusUsageError.sessionExpired.shouldTryNextImportedSession == true)
+        #expect(AbacusUsageError.unauthorized.shouldClearCachedCookie == true)
+        #expect(AbacusUsageError.sessionExpired.shouldClearCachedCookie == true)
+    }
+}
diff --git a/Tests/CodexBarTests/AlibabaCodingPlanCookieImporterTests.swift b/Tests/CodexBarTests/AlibabaCodingPlanCookieImporterTests.swift
new file mode 100644
index 0000000000..eaa30a0e83
--- /dev/null
+++ b/Tests/CodexBarTests/AlibabaCodingPlanCookieImporterTests.swift
@@ -0,0 +1,142 @@
+import Foundation
+import os.lock
+import Testing
+@testable import CodexBarCore
+
+#if os(macOS)
+import SweetCookieKit
+
+@Suite(.serialized)
+struct AlibabaCodingPlanCookieImporterTests {
+    @Test(.disabled(
+        if: ProcessInfo.processInfo.environment[BrowserCookieAccessGate.allowTestCookieAccessEnvironmentKey] == "1",
+        "Default-home cookie access is explicitly enabled for this test run."))
+    func `default home import is suppressed before profile and keychain access`() throws {
+        let profileProbeCount = OSAllocatedUnfairLock(initialState: 0)
+        let keychainProbeCount = OSAllocatedUnfairLock(initialState: 0)
+        let defaultHome = try #require(BrowserCookieClient.defaultHomeDirectories().first)
+        let detection = BrowserDetection(
+            homeDirectory: defaultHome.path,
+            cacheTTL: 0,
+            fileExists: { _ in
+                profileProbeCount.withLock { $0 += 1 }
+                return true
+            },
+            directoryContents: { _ in
+                profileProbeCount.withLock { $0 += 1 }
+                return ["Default"]
+            })
+
+        _ = KeychainAccessGate.withTaskOverrideForTesting(false) {
+            KeychainAccessPreflight.withCheckGenericPasswordOverrideForTesting { _, _ in
+                keychainProbeCount.withLock { $0 += 1 }
+                return .allowed
+            } operation: {
+                #expect(throws: AlibabaCodingPlanSettingsError.self) {
+                    _ = try AlibabaCodingPlanCookieImporter.importSession(browserDetection: detection)
+                }
+            }
+        }
+
+        #expect(profileProbeCount.withLock { $0 } == 0)
+        #expect(keychainProbeCount.withLock { $0 } == 0)
+    }
+
+    @Test(.disabled(
+        if: ProcessInfo.processInfo.environment[BrowserCookieAccessGate.allowTestCookieAccessEnvironmentKey] == "1",
+        "Default-home cookie access is explicitly enabled for this test run."))
+    func `chromium fallback rejects default client before keychain access`() {
+        let keychainProbeCount = OSAllocatedUnfairLock(initialState: 0)
+        _ = KeychainAccessGate.withTaskOverrideForTesting(false) {
+            KeychainAccessPreflight.withCheckGenericPasswordOverrideForTesting { _, _ in
+                keychainProbeCount.withLock { $0 += 1 }
+                return .allowed
+            } operation: {
+                #expect(throws: BrowserCookieStoreAccessSuppressedError.self) {
+                    _ = try AlibabaChromiumCookieFallbackImporter.importSession(
+                        browser: .chrome,
+                        domains: ["example.com"])
+                }
+            }
+        }
+        #expect(keychainProbeCount.withLock { $0 } == 0)
+    }
+
+    @Test
+    func `domain matching requires exact or label bounded suffix`() {
+        #expect(AlibabaCodingPlanCookieImporter.matchesCookieDomain("console.aliyun.com"))
+        #expect(AlibabaCodingPlanCookieImporter.matchesCookieDomain(".modelstudio.console.alibabacloud.com"))
+        #expect(AlibabaCodingPlanCookieImporter.matchesCookieDomain("foo.aliyun.com"))
+        #expect(AlibabaCodingPlanCookieImporter.matchesCookieDomain("evilaliyun.com") == false)
+        #expect(AlibabaCodingPlanCookieImporter.matchesCookieDomain("notalibabacloud.com") == false)
+    }
+
+    @Test
+    func `cookie import candidates honor provided browser order`() throws {
+        BrowserCookieAccessGate.resetForTesting()
+
+        let temp = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        try FileManager.default.createDirectory(at: temp, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: temp) }
+
+        let firefoxProfile = temp
+            .appendingPathComponent("Library")
+            .appendingPathComponent("Application Support")
+            .appendingPathComponent("Firefox")
+            .appendingPathComponent("Profiles")
+            .appendingPathComponent("abc.default-release")
+        try FileManager.default.createDirectory(at: firefoxProfile, withIntermediateDirectories: true)
+        FileManager.default.createFile(
+            atPath: firefoxProfile.appendingPathComponent("cookies.sqlite").path,
+            contents: Data())
+
+        let detection = BrowserDetection(homeDirectory: temp.path, cacheTTL: 0)
+        let importOrder: BrowserCookieImportOrder = [.firefox, .safari, .chrome]
+
+        let candidates = AlibabaCodingPlanCookieImporter.cookieImportCandidates(
+            browserDetection: detection,
+            importOrder: importOrder)
+
+        let expected: [Browser] = [.firefox, .safari]
+        #expect(candidates == expected)
+    }
+
+    @Test
+    func `default cookie import candidates skip keychain browsers during tests`() throws {
+        BrowserCookieAccessGate.resetForTesting()
+
+        let temp = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        try FileManager.default.createDirectory(at: temp, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: temp) }
+
+        let chromeProfile = temp
+            .appendingPathComponent("Library")
+            .appendingPathComponent("Application Support")
+            .appendingPathComponent("Google")
+            .appendingPathComponent("Chrome")
+            .appendingPathComponent("Default")
+        try FileManager.default.createDirectory(at: chromeProfile, withIntermediateDirectories: true)
+        let cookiesDir = chromeProfile.appendingPathComponent("Network")
+        try FileManager.default.createDirectory(at: cookiesDir, withIntermediateDirectories: true)
+        FileManager.default.createFile(
+            atPath: cookiesDir.appendingPathComponent("Cookies").path,
+            contents: Data())
+
+        let detection = BrowserDetection(homeDirectory: temp.path, cacheTTL: 0)
+        let candidates = AlibabaCodingPlanCookieImporter.cookieImportCandidates(browserDetection: detection)
+
+        #expect(candidates.first == .safari)
+        #expect(candidates.contains(.chrome) == false)
+    }
+}
+
+#else
+
+struct AlibabaCodingPlanCookieImporterTests {
+    @Test
+    func `non mac OS placeholder`() {
+        #expect(true)
+    }
+}
+
+#endif
diff --git a/Tests/CodexBarTests/AlibabaCodingPlanProviderTests.swift b/Tests/CodexBarTests/AlibabaCodingPlanProviderTests.swift
new file mode 100644
index 0000000000..5e7534e31f
--- /dev/null
+++ b/Tests/CodexBarTests/AlibabaCodingPlanProviderTests.swift
@@ -0,0 +1,1143 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct AlibabaCodingPlanSettingsReaderTests {
+    @Test
+    func `api token reads from environment`() {
+        let token = AlibabaCodingPlanSettingsReader.apiToken(environment: ["ALIBABA_CODING_PLAN_API_KEY": "abc123"])
+        #expect(token == "abc123")
+    }
+
+    @Test
+    func `api token reads qwen alias from environment`() {
+        let token = AlibabaCodingPlanSettingsReader.apiToken(environment: ["ALIBABA_QWEN_API_KEY": "qwen123"])
+        #expect(token == "qwen123")
+    }
+
+    @Test
+    func `api token reads dashscope alias from environment`() {
+        let token = AlibabaCodingPlanSettingsReader.apiToken(environment: ["DASHSCOPE_API_KEY": "dashscope123"])
+        #expect(token == "dashscope123")
+    }
+
+    @Test
+    func `api token prefers coding plan key over aliases`() {
+        let token = AlibabaCodingPlanSettingsReader.apiToken(environment: [
+            "ALIBABA_CODING_PLAN_API_KEY": "coding-plan",
+            "ALIBABA_QWEN_API_KEY": "qwen",
+            "DASHSCOPE_API_KEY": "dashscope",
+        ])
+        #expect(token == "coding-plan")
+    }
+
+    @Test
+    func `api token strips quotes`() {
+        let token = AlibabaCodingPlanSettingsReader
+            .apiToken(environment: ["ALIBABA_CODING_PLAN_API_KEY": "\"token-xyz\""])
+        #expect(token == "token-xyz")
+    }
+
+    @Test
+    func `quota URL infers scheme`() {
+        let url = AlibabaCodingPlanSettingsReader
+            .quotaURL(environment: [AlibabaCodingPlanSettingsReader
+                    .quotaURLKey: "modelstudio.console.alibabacloud.com/data/api.json"])
+        #expect(url?.absoluteString == "https://modelstudio.console.alibabacloud.com/data/api.json")
+    }
+
+    @Test
+    func `endpoint overrides allow custom https hosts by default`() {
+        let env = [
+            AlibabaCodingPlanSettingsReader.hostKey: "https://attacker.example",
+            AlibabaCodingPlanSettingsReader.quotaURLKey: "https://attacker.example/data/api.json",
+        ]
+
+        #expect(AlibabaCodingPlanSettingsReader.hostOverride(environment: env) == "attacker.example")
+        #expect(AlibabaCodingPlanSettingsReader.quotaURL(environment: env)?.host == "attacker.example")
+        #expect(AlibabaCodingPlanSettingsReader.rejectedEndpointOverrideKey(environment: env) == nil)
+    }
+
+    @Test
+    func `host endpoint overrides preserve explicit port`() {
+        let env = [AlibabaCodingPlanSettingsReader.hostKey: "proxy.example.test:8443"]
+
+        #expect(AlibabaCodingPlanSettingsReader.hostOverride(environment: env) == "proxy.example.test:8443")
+        #expect(
+            AlibabaCodingPlanUsageFetcher.resolveQuotaURL(region: .international, environment: env).absoluteString ==
+                "https://proxy.example.test:8443/data/api.json?action=zeldaEasy.broadscope-bailian.codingPlan.queryCodingPlanInstanceInfoV2&product=broadscope-bailian&api=queryCodingPlanInstanceInfoV2&currentRegionId=ap-southeast-1")
+        #expect(
+            AlibabaCodingPlanUsageFetcher.resolveConsoleDashboardURL(region: .international, environment: env)
+                .absoluteString
+                .hasPrefix("https://proxy.example.test:8443/") == true)
+    }
+
+    @Test
+    func `endpoint overrides reject encoded host delimiters before suffix matching`() {
+        let encodedSlash = "https://attacker.example%2f.modelstudio.console.alibabacloud.com"
+        let doubleEncodedSlash = "https://attacker.example%252f.modelstudio.console.alibabacloud.com"
+        let env = [
+            AlibabaCodingPlanSettingsReader.hostKey: encodedSlash,
+            AlibabaCodingPlanSettingsReader.quotaURLKey: "\(encodedSlash)/data/api.json",
+        ]
+
+        #expect(AlibabaCodingPlanSettingsReader.hostOverride(environment: env) == nil)
+        #expect(AlibabaCodingPlanSettingsReader.quotaURL(environment: env) == nil)
+        #expect(AlibabaCodingPlanSettingsReader.hostOverride(environment: [
+            AlibabaCodingPlanSettingsReader.hostKey: doubleEncodedSlash,
+        ]) == nil)
+    }
+
+    @Test
+    func `endpoint overrides reject whitespace and control characters in hosts`() {
+        for host in ["https://bad host", "https://bad%20host", "https://bad%09host"] {
+            #expect(AlibabaCodingPlanSettingsReader.hostOverride(environment: [
+                AlibabaCodingPlanSettingsReader.hostKey: host,
+            ]) == nil)
+            #expect(AlibabaCodingPlanSettingsReader.quotaURL(environment: [
+                AlibabaCodingPlanSettingsReader.quotaURLKey: "\(host)/data/api.json",
+            ]) == nil)
+        }
+    }
+
+    @Test
+    func `endpoint overrides require https and no userinfo`() {
+        #expect(AlibabaCodingPlanSettingsReader.hostOverride(environment: [
+            AlibabaCodingPlanSettingsReader.hostKey: "http://modelstudio.console.alibabacloud.com",
+        ]) == nil)
+        #expect(AlibabaCodingPlanSettingsReader.quotaURL(environment: [
+            AlibabaCodingPlanSettingsReader.quotaURLKey:
+                "https://user:pass@modelstudio.console.alibabacloud.com/data/api.json",
+        ]) == nil)
+    }
+
+    @Test
+    func `strict provider endpoint mode rejects custom hosts`() {
+        let env = [
+            AlibabaCodingPlanSettingsReader.requireProviderEndpointOverridesKey: "true",
+            AlibabaCodingPlanSettingsReader.hostKey: "proxy.example.test",
+            AlibabaCodingPlanSettingsReader.quotaURLKey: "https://proxy.example.test/data/api.json",
+        ]
+
+        #expect(AlibabaCodingPlanSettingsReader.hostOverride(environment: env) == nil)
+        #expect(AlibabaCodingPlanSettingsReader.quotaURL(environment: env) == nil)
+        #expect(AlibabaCodingPlanSettingsReader
+            .rejectedEndpointOverrideKey(environment: env) == AlibabaCodingPlanSettingsReader.hostKey)
+    }
+
+    @Test
+    func `strict provider endpoint mode rejects customer controlled Alibaba Cloud hosts`() {
+        let env = [
+            AlibabaCodingPlanSettingsReader.requireProviderEndpointOverridesKey: "true",
+            AlibabaCodingPlanSettingsReader.hostKey: "tenant.cn-beijing.fc.aliyuncs.com",
+        ]
+
+        #expect(AlibabaCodingPlanSettingsReader.hostOverride(environment: env) == nil)
+        #expect(AlibabaCodingPlanSettingsReader
+            .rejectedEndpointOverrideKey(environment: env) == AlibabaCodingPlanSettingsReader.hostKey)
+    }
+
+    @Test
+    func `strict provider endpoint mode accepts known Coding Plan hosts`() {
+        let env = [
+            AlibabaCodingPlanSettingsReader.requireProviderEndpointOverridesKey: "true",
+            AlibabaCodingPlanSettingsReader.hostKey: "bailian-beijing-cs.aliyuncs.com",
+        ]
+
+        #expect(
+            AlibabaCodingPlanSettingsReader.hostOverride(environment: env) ==
+                "bailian-beijing-cs.aliyuncs.com")
+        #expect(AlibabaCodingPlanSettingsReader.rejectedEndpointOverrideKey(environment: env) == nil)
+    }
+
+    @Test
+    func `custom https compatibility mode still rejects http and userinfo`() {
+        #expect(AlibabaCodingPlanSettingsReader.hostOverride(environment: [
+            AlibabaCodingPlanSettingsReader.hostKey: "http://proxy.example.test",
+        ]) == nil)
+        #expect(AlibabaCodingPlanSettingsReader.rejectedEndpointOverrideKey(environment: [
+            AlibabaCodingPlanSettingsReader.quotaURLKey: "https://user:pass@proxy.example.test/data/api.json",
+        ]) == AlibabaCodingPlanSettingsReader.quotaURLKey)
+    }
+
+    @Test
+    func `missing cookie error includes access hint when present`() {
+        let error = AlibabaCodingPlanSettingsError
+            .missingCookie(details: "Safari cookie file exists but is not readable.")
+        #expect(error.errorDescription?.contains("Safari cookie file exists but is not readable.") == true)
+    }
+}
+
+struct AlibabaCodingPlanUsageSnapshotTests {
+    @Test
+    func `maps usage snapshot windows`() {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let reset5h = Date(timeIntervalSince1970: 1_700_000_300)
+        let resetWeek = Date(timeIntervalSince1970: 1_700_010_000)
+        let resetMonth = Date(timeIntervalSince1970: 1_700_100_000)
+        let snapshot = AlibabaCodingPlanUsageSnapshot(
+            planName: "Pro",
+            fiveHourUsedQuota: 20,
+            fiveHourTotalQuota: 100,
+            fiveHourNextRefreshTime: reset5h,
+            weeklyUsedQuota: 120,
+            weeklyTotalQuota: 400,
+            weeklyNextRefreshTime: resetWeek,
+            monthlyUsedQuota: 500,
+            monthlyTotalQuota: 2000,
+            monthlyNextRefreshTime: resetMonth,
+            updatedAt: now)
+
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.primary?.usedPercent == 20)
+        #expect(usage.primary?.windowMinutes == 300)
+        #expect(usage.secondary?.usedPercent == 30)
+        #expect(usage.secondary?.windowMinutes == 10080)
+        #expect(usage.tertiary?.usedPercent == 25)
+        #expect(usage.tertiary?.windowMinutes == 43200)
+        #expect(usage.loginMethod(for: .alibaba) == "Pro")
+    }
+
+    @Test
+    func `shifts primary reset forward when backend reset is not future`() {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let stalePrimaryReset = Date(timeIntervalSince1970: 1_699_999_900)
+        let snapshot = AlibabaCodingPlanUsageSnapshot(
+            planName: "Lite",
+            fiveHourUsedQuota: 70,
+            fiveHourTotalQuota: 1200,
+            fiveHourNextRefreshTime: stalePrimaryReset,
+            weeklyUsedQuota: 80,
+            weeklyTotalQuota: 9000,
+            weeklyNextRefreshTime: Date(timeIntervalSince1970: 1_700_010_000),
+            monthlyUsedQuota: 80,
+            monthlyTotalQuota: 18000,
+            monthlyNextRefreshTime: Date(timeIntervalSince1970: 1_700_100_000),
+            updatedAt: now)
+
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary?.resetsAt == stalePrimaryReset.addingTimeInterval(TimeInterval(5 * 60 * 60)))
+    }
+}
+
+struct AlibabaCodingPlanUsageParsingTests {
+    @Test
+    func `parses quota payload`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let json = """
+        {
+          "data": {
+            "codingPlanInstanceInfos": [
+              { "planName": "Alibaba Coding Plan Pro" }
+            ],
+            "codingPlanQuotaInfo": {
+              "per5HourUsedQuota": 52,
+              "per5HourTotalQuota": 1000,
+              "per5HourQuotaNextRefreshTime": 1700000300000,
+              "perWeekUsedQuota": 800,
+              "perWeekTotalQuota": 5000,
+              "perWeekQuotaNextRefreshTime": 1700100000000,
+              "perBillMonthUsedQuota": 1200,
+              "perBillMonthTotalQuota": 20000,
+              "perBillMonthQuotaNextRefreshTime": 1701000000000
+            }
+          },
+          "status_code": 0
+        }
+        """
+
+        let snapshot = try AlibabaCodingPlanUsageFetcher.parseUsageSnapshot(from: Data(json.utf8), now: now)
+
+        #expect(snapshot.planName == "Alibaba Coding Plan Pro")
+        #expect(snapshot.fiveHourUsedQuota == 52)
+        #expect(snapshot.fiveHourTotalQuota == 1000)
+        #expect(snapshot.weeklyTotalQuota == 5000)
+        #expect(snapshot.monthlyTotalQuota == 20000)
+        #expect(snapshot.fiveHourNextRefreshTime == Date(timeIntervalSince1970: 1_700_000_300))
+    }
+
+    @Test
+    func `multi instance quota payload uses selected active instance plan name`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let json = """
+        {
+          "data": {
+            "codingPlanInstanceInfos": [
+              {
+                "planName": "Expired Starter",
+                "status": "EXPIRED",
+                "endTime": "2025-04-01 17:00",
+                "codingPlanQuotaInfo": {
+                  "per5HourUsedQuota": 7,
+                  "per5HourTotalQuota": 100,
+                  "per5HourQuotaNextRefreshTime": 1700000100000
+                }
+              },
+              {
+                "planName": "Active Pro",
+                "status": "VALID",
+                "codingPlanQuotaInfo": {
+                  "per5HourUsedQuota": 52,
+                  "per5HourTotalQuota": 1000,
+                  "per5HourQuotaNextRefreshTime": 1700000300000
+                }
+              }
+            ]
+          },
+          "status_code": 0
+        }
+        """
+
+        let snapshot = try AlibabaCodingPlanUsageFetcher.parseUsageSnapshot(from: Data(json.utf8), now: now)
+
+        #expect(snapshot.planName == "Active Pro")
+        #expect(snapshot.fiveHourUsedQuota == 52)
+        #expect(snapshot.fiveHourTotalQuota == 1000)
+        #expect(snapshot.fiveHourNextRefreshTime == Date(timeIntervalSince1970: 1_700_000_300))
+    }
+
+    @Test
+    func `missing quota data without positive active signal fails`() {
+        let json = """
+        {
+          "data": {
+            "codingPlanInstanceInfos": [
+              { "planName": "Alibaba Coding Plan Pro" }
+            ]
+          },
+          "status_code": 0
+        }
+        """
+
+        #expect(throws: AlibabaCodingPlanUsageError.self) {
+            try AlibabaCodingPlanUsageFetcher.parseUsageSnapshot(from: Data(json.utf8))
+        }
+    }
+
+    @Test
+    func `plan usage without positive active proof fails`() {
+        let json = """
+        {
+          "data": {
+            "codingPlanInstanceInfos": [
+              {
+                "planName": "Alibaba Coding Plan Pro",
+                "planUsage": "18%"
+              }
+            ]
+          },
+          "status_code": 0
+        }
+        """
+
+        #expect(throws: AlibabaCodingPlanUsageError.self) {
+            try AlibabaCodingPlanUsageFetcher.parseUsageSnapshot(from: Data(json.utf8))
+        }
+    }
+
+    @Test
+    func `parses wrapped JSON string payload`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let inner = """
+        {
+          "data": {
+            "codingPlanInstanceInfos": [
+              {
+                "planName": "Coding Plan Lite",
+                "status": "VALID",
+                "codingPlanQuotaInfo": {
+                  "per5HourUsedQuota": 0,
+                  "per5HourTotalQuota": 1000,
+                  "per5HourQuotaNextRefreshTime": 1700000300000
+                }
+              }
+            ]
+          },
+          "statusCode": 200
+        }
+        """
+            .replacingOccurrences(of: "\n", with: "")
+            .replacingOccurrences(of: "  ", with: "")
+            .replacingOccurrences(of: "\"", with: "\\\"")
+
+        let wrapped = """
+        {
+          "successResponse": {
+            "body": "\(inner)"
+          }
+        }
+        """
+
+        let snapshot = try AlibabaCodingPlanUsageFetcher.parseUsageSnapshot(from: Data(wrapped.utf8), now: now)
+
+        #expect(snapshot.planName == "Coding Plan Lite")
+        #expect(snapshot.fiveHourTotalQuota == 1000)
+        #expect(snapshot.fiveHourUsedQuota == 0)
+    }
+
+    @Test
+    func `plan usage fallback stays visible but non quantitative`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let json = """
+        {
+          "data": {
+            "codingPlanInstanceInfos": [
+              {
+                "planName": "Coding Plan Lite",
+                "status": "VALID",
+                "planUsage": "0%",
+                "endTime": "2026-04-01 17:00"
+              }
+            ]
+          },
+          "status_code": 0
+        }
+        """
+
+        let snapshot = try AlibabaCodingPlanUsageFetcher.parseUsageSnapshot(from: Data(json.utf8), now: now)
+
+        #expect(snapshot.planName == "Coding Plan Lite")
+        #expect(snapshot.fiveHourUsedQuota == nil)
+        #expect(snapshot.fiveHourTotalQuota == nil)
+        #expect(snapshot.fiveHourNextRefreshTime == nil)
+
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary == nil)
+        #expect(usage.loginMethod(for: .alibaba) == "Coding Plan Lite")
+    }
+
+    @Test
+    func `falls back to active plan when quota and usage missing`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let json = """
+        {
+          "data": {
+            "codingPlanInstanceInfos": [
+              {
+                "planName": "Coding Plan Lite",
+                "status": "VALID",
+                "endTime": "2026-04-01 17:00"
+              }
+            ]
+          },
+          "status_code": 0
+        }
+        """
+
+        let snapshot = try AlibabaCodingPlanUsageFetcher.parseUsageSnapshot(from: Data(json.utf8), now: now)
+
+        #expect(snapshot.planName == "Coding Plan Lite")
+        #expect(snapshot.fiveHourUsedQuota == nil)
+        #expect(snapshot.fiveHourTotalQuota == nil)
+
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary == nil)
+        #expect(usage.loginMethod(for: .alibaba) == "Coding Plan Lite")
+    }
+
+    @Test
+    func `future end time counts as positive active signal`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let json = """
+        {
+          "data": {
+            "codingPlanInstanceInfos": [
+              {
+                "planName": "Coding Plan Lite",
+                "endTime": "2030-04-01 17:00"
+              }
+            ]
+          },
+          "status_code": 0
+        }
+        """
+
+        let snapshot = try AlibabaCodingPlanUsageFetcher.parseUsageSnapshot(from: Data(json.utf8), now: now)
+
+        #expect(snapshot.planName == "Coding Plan Lite")
+        #expect(snapshot.fiveHourUsedQuota == nil)
+        #expect(snapshot.weeklyTotalQuota == nil)
+
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary == nil)
+        #expect(usage.loginMethod(for: .alibaba) == "Coding Plan Lite")
+    }
+
+    @Test
+    func `multi instance fallback uses selected active instance plan name`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let json = """
+        {
+          "data": {
+            "codingPlanInstanceInfos": [
+              {
+                "planName": "Expired Starter",
+                "status": "EXPIRED",
+                "endTime": "2025-04-01 17:00"
+              },
+              {
+                "planName": "Active Pro",
+                "status": "VALID",
+                "planUsage": "42%"
+              }
+            ]
+          },
+          "status_code": 0
+        }
+        """
+
+        let snapshot = try AlibabaCodingPlanUsageFetcher.parseUsageSnapshot(from: Data(json.utf8), now: now)
+
+        #expect(snapshot.planName == "Active Pro")
+        #expect(snapshot.fiveHourUsedQuota == nil)
+        #expect(snapshot.fiveHourTotalQuota == nil)
+
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary == nil)
+        #expect(usage.loginMethod(for: .alibaba) == "Active Pro")
+    }
+
+    @Test
+    func `active instance without quota does not borrow quota from another instance`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let json = """
+        {
+          "data": {
+            "codingPlanInstanceInfos": [
+              {
+                "planName": "Expired Starter",
+                "status": "EXPIRED",
+                "endTime": "2025-04-01 17:00",
+                "codingPlanQuotaInfo": {
+                  "per5HourUsedQuota": 7,
+                  "per5HourTotalQuota": 100,
+                  "per5HourQuotaNextRefreshTime": 1700000100000
+                }
+              },
+              {
+                "planName": "Active Pro",
+                "status": "VALID"
+              }
+            ]
+          },
+          "status_code": 0
+        }
+        """
+
+        let snapshot = try AlibabaCodingPlanUsageFetcher.parseUsageSnapshot(from: Data(json.utf8), now: now)
+
+        #expect(snapshot.planName == "Active Pro")
+        #expect(snapshot.fiveHourUsedQuota == nil)
+        #expect(snapshot.fiveHourTotalQuota == nil)
+        #expect(snapshot.fiveHourNextRefreshTime == nil)
+    }
+
+    @Test
+    func `payload level active proof does not label first instance when no instance is active`() {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let json = """
+        {
+          "data": {
+            "status": "VALID",
+            "codingPlanInstanceInfos": [
+              {
+                "planName": "Expired Starter",
+                "status": "EXPIRED",
+                "endTime": "2025-04-01 17:00"
+              },
+              {
+                "planName": "No Proof Pro"
+              }
+            ]
+          },
+          "status_code": 0
+        }
+        """
+
+        #expect(throws: AlibabaCodingPlanUsageError.self) {
+            try AlibabaCodingPlanUsageFetcher.parseUsageSnapshot(from: Data(json.utf8), now: now)
+        }
+    }
+
+    @Test
+    func `does not fallback for inactive plan without quota`() {
+        let json = """
+        {
+          "data": {
+            "codingPlanInstanceInfos": [
+              {
+                "planName": "Coding Plan Lite",
+                "status": "EXPIRED"
+              }
+            ]
+          },
+          "status_code": 0
+        }
+        """
+
+        #expect(throws: AlibabaCodingPlanUsageError.self) {
+            try AlibabaCodingPlanUsageFetcher.parseUsageSnapshot(from: Data(json.utf8))
+        }
+    }
+
+    @Test
+    func `console need login payload maps to login required`() {
+        let json = """
+        {
+          "code": "ConsoleNeedLogin",
+          "message": "You need to log in.",
+          "requestId": "abc",
+          "successResponse": false
+        }
+        """
+
+        #expect(throws: AlibabaCodingPlanUsageError.loginRequired) {
+            try AlibabaCodingPlanUsageFetcher.parseUsageSnapshot(from: Data(json.utf8))
+        }
+    }
+
+    @Test
+    func `console need login payload maps to unavailable API key mode`() {
+        let json = """
+        {
+          "code": "ConsoleNeedLogin",
+          "message": "You need to log in.",
+          "requestId": "abc",
+          "successResponse": false
+        }
+        """
+
+        #expect(throws: AlibabaCodingPlanUsageError.apiKeyUnavailableInRegion) {
+            try AlibabaCodingPlanUsageFetcher.parseUsageSnapshot(
+                from: Data(json.utf8),
+                authMode: .apiKey)
+        }
+    }
+}
+
+@Suite(.serialized)
+struct AlibabaCodingPlanFallbackTests {
+    private struct StubClaudeFetcher: ClaudeUsageFetching {
+        func loadLatestUsage(model _: String) async throws -> ClaudeUsageSnapshot {
+            throw ClaudeUsageError.parseFailed("stub")
+        }
+
+        func debugRawProbe(model _: String) async -> String {
+            "stub"
+        }
+
+        func detectVersion() -> String? {
+            nil
+        }
+    }
+
+    private func makeContext(
+        sourceMode: ProviderSourceMode,
+        settings: ProviderSettingsSnapshot? = nil,
+        env: [String: String] = [:]) -> ProviderFetchContext
+    {
+        let browserDetection = BrowserDetection(cacheTTL: 0)
+        return ProviderFetchContext(
+            runtime: .cli,
+            sourceMode: sourceMode,
+            includeCredits: false,
+            webTimeout: 1,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: env,
+            settings: settings,
+            fetcher: UsageFetcher(environment: env),
+            claudeFetcher: StubClaudeFetcher(),
+            browserDetection: browserDetection)
+    }
+
+    @Test
+    func `falls back on TLS failure in auto mode`() {
+        let strategy = AlibabaCodingPlanWebFetchStrategy()
+        let context = self.makeContext(sourceMode: .auto)
+        #expect(strategy.shouldFallback(on: URLError(.secureConnectionFailed), context: context))
+    }
+
+    @Test
+    func `does not fallback on TLS failure when source forced to web`() {
+        let strategy = AlibabaCodingPlanWebFetchStrategy()
+        let context = self.makeContext(sourceMode: .web)
+        #expect(strategy.shouldFallback(on: URLError(.secureConnectionFailed), context: context) == false)
+    }
+
+    @Test
+    func `auto mode does not borrow manual cookie authority when browser import fails`() {
+        let strategy = AlibabaCodingPlanWebFetchStrategy()
+        let settings = ProviderSettingsSnapshot.make(
+            alibaba: ProviderSettingsSnapshot.AlibabaCodingPlanProviderSettings(
+                cookieSource: .auto,
+                manualCookieHeader: "session=manual-cookie",
+                apiRegion: .international))
+        let context = self.makeContext(sourceMode: .auto, settings: settings)
+
+        CookieHeaderCache.clear(provider: .alibaba)
+        AlibabaCodingPlanCookieImporter.importSessionOverrideForTesting = { _, _ in
+            throw AlibabaCodingPlanSettingsError.missingCookie()
+        }
+        defer {
+            AlibabaCodingPlanCookieImporter.importSessionOverrideForTesting = nil
+        }
+
+        do {
+            _ = try AlibabaCodingPlanWebFetchStrategy.resolveCookieHeader(context: context, allowCached: false)
+            Issue.record("Expected auto mode to fail instead of borrowing the manual cookie header")
+        } catch let error as AlibabaCodingPlanSettingsError {
+            guard case .missingCookie = error else {
+                Issue.record("Expected missingCookie, got \(error)")
+                return
+            }
+            #expect(strategy.shouldFallback(on: error, context: context))
+        } catch {
+            Issue.record("Expected AlibabaCodingPlanSettingsError, got \(error)")
+        }
+    }
+
+    @Test
+    func `auto mode skips web when no alibaba session is available`() async {
+        let strategy = AlibabaCodingPlanWebFetchStrategy()
+        let settings = ProviderSettingsSnapshot.make(
+            alibaba: ProviderSettingsSnapshot.AlibabaCodingPlanProviderSettings(
+                cookieSource: .auto,
+                manualCookieHeader: nil,
+                apiRegion: .international))
+        let context = self.makeContext(
+            sourceMode: .auto,
+            settings: settings,
+            env: [AlibabaCodingPlanSettingsReader.apiTokenKey: "token-abc"])
+
+        CookieHeaderCache.clear(provider: .alibaba)
+        AlibabaCodingPlanCookieImporter.importSessionOverrideForTesting = { _, _ in
+            throw AlibabaCodingPlanSettingsError.missingCookie()
+        }
+        defer {
+            AlibabaCodingPlanCookieImporter.importSessionOverrideForTesting = nil
+        }
+
+        #expect(await strategy.isAvailable(context) == false)
+    }
+}
+
+struct AlibabaCodingPlanRegionTests {
+    @Test
+    func `defaults to international endpoint`() {
+        let url = AlibabaCodingPlanUsageFetcher.resolveQuotaURL(region: .international, environment: [:])
+        #expect(url.host == "modelstudio.console.alibabacloud.com")
+        #expect(url.path == "/data/api.json")
+    }
+
+    @Test
+    func `uses china mainland host`() {
+        let url = AlibabaCodingPlanUsageFetcher.resolveQuotaURL(region: .chinaMainland, environment: [:])
+        #expect(url.host == "bailian.console.aliyun.com")
+    }
+
+    @Test
+    func `host override wins for quota URL`() {
+        let env = [AlibabaCodingPlanSettingsReader.hostKey: "custom.aliyun.com"]
+        let url = AlibabaCodingPlanUsageFetcher.resolveQuotaURL(region: .international, environment: env)
+        #expect(url.host == "custom.aliyun.com")
+        #expect(url.path == "/data/api.json")
+    }
+
+    @Test
+    func `host override uses selected region for quota URL`() {
+        let env = [AlibabaCodingPlanSettingsReader.hostKey: "custom.aliyun.com"]
+        let url = AlibabaCodingPlanUsageFetcher.resolveQuotaURL(region: .chinaMainland, environment: env)
+        #expect(url.host == "custom.aliyun.com")
+
+        let components = URLComponents(url: url, resolvingAgainstBaseURL: false)
+        let currentRegion = components?.queryItems?.first(where: { $0.name == "currentRegionId" })?.value
+        #expect(currentRegion == AlibabaCodingPlanAPIRegion.chinaMainland.currentRegionID)
+    }
+
+    @Test
+    func `bare host override builds console dashboard URL`() {
+        let env = [AlibabaCodingPlanSettingsReader.hostKey: "custom.aliyun.com"]
+        let url = AlibabaCodingPlanUsageFetcher.resolveConsoleDashboardURL(region: .international, environment: env)
+        #expect(url.scheme == "https")
+        #expect(url.host == "custom.aliyun.com")
+        #expect(url.path == AlibabaCodingPlanAPIRegion.international.dashboardURL.path)
+
+        let components = URLComponents(url: url, resolvingAgainstBaseURL: false)
+        let tab = components?.queryItems?.first(where: { $0.name == "tab" })?.value
+        #expect(tab == "coding-plan")
+    }
+
+    @Test
+    func `quota url override beats host`() {
+        let env = [
+            AlibabaCodingPlanSettingsReader.quotaURLKey:
+                "https://modelstudio.console.alibabacloud.com/custom/quota",
+        ]
+        let url = AlibabaCodingPlanUsageFetcher.resolveQuotaURL(region: .international, environment: env)
+        #expect(url.absoluteString == "https://modelstudio.console.alibabacloud.com/custom/quota")
+    }
+
+    @Test
+    func `custom quota url override is preserved by default`() {
+        let env = [AlibabaCodingPlanSettingsReader.quotaURLKey: "https://attacker.example/custom/quota"]
+        let url = AlibabaCodingPlanUsageFetcher.resolveQuotaURL(region: .international, environment: env)
+        #expect(url.host == "attacker.example")
+    }
+
+    @Test
+    func `strict provider endpoint mode falls back to provider endpoint`() {
+        let env = [
+            AlibabaCodingPlanSettingsReader.requireProviderEndpointOverridesKey: "true",
+            AlibabaCodingPlanSettingsReader.quotaURLKey: "https://attacker.example/custom/quota",
+        ]
+        let url = AlibabaCodingPlanUsageFetcher.resolveQuotaURL(region: .international, environment: env)
+        #expect(url.host == AlibabaCodingPlanAPIRegion.international.quotaURL.host)
+    }
+
+    @Test
+    func `explicit endpoint override rejects invalid api scheme before network`() async {
+        await #expect(throws: ProviderEndpointOverrideError.alibabaCodingPlan(
+            AlibabaCodingPlanSettingsReader.quotaURLKey))
+        {
+            _ = try await AlibabaCodingPlanUsageFetcher.fetchUsage(
+                apiKey: "cpk-test",
+                environment: [AlibabaCodingPlanSettingsReader
+                    .quotaURLKey: "http://modelstudio.console.alibabacloud.com/custom/quota"])
+        }
+    }
+
+    @Test
+    func `explicit endpoint override rejects invalid cookie scheme before network`() async {
+        await #expect(throws: ProviderEndpointOverrideError.alibabaCodingPlan(
+            AlibabaCodingPlanSettingsReader.quotaURLKey))
+        {
+            _ = try await AlibabaCodingPlanUsageFetcher.fetchUsage(
+                cookieHeader: "login_aliyunid_ticket=ticket; login_aliyunid_pk=user",
+                environment: [AlibabaCodingPlanSettingsReader
+                    .quotaURLKey: "http://modelstudio.console.alibabacloud.com/custom/quota"])
+        }
+    }
+}
+
+@Suite(.serialized)
+struct AlibabaCodingPlanUsageFetcherRequestTests {
+    @Test
+    func `api401 maps to invalid credentials`() async throws {
+        let transport = ProviderHTTPTransportHandler { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            let (response, data) = Self.makeResponse(
+                url: url,
+                body: #"{"message":"unauthorized"}"#,
+                statusCode: 401)
+            return (data, response)
+        }
+
+        await #expect(throws: AlibabaCodingPlanUsageError.invalidCredentials) {
+            _ = try await AlibabaCodingPlanUsageFetcher.fetchUsage(
+                apiKey: "cpk-test",
+                region: .chinaMainland,
+                environment: [
+                    AlibabaCodingPlanSettingsReader.quotaURLKey: "https://bailian.console.aliyun.com/data/api.json",
+                ],
+                transport: transport)
+        }
+    }
+
+    @Test
+    func `cookie SEC token fallback survives user info request failure`() async throws {
+        let registered = URLProtocol.registerClass(AlibabaConsoleSECTokenStubURLProtocol.self)
+        defer {
+            if registered {
+                URLProtocol.unregisterClass(AlibabaConsoleSECTokenStubURLProtocol.self)
+            }
+            AlibabaConsoleSECTokenStubURLProtocol.handler = nil
+        }
+
+        AlibabaConsoleSECTokenStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+
+            if url.host == "modelstudio.console.alibabacloud.com", request.httpMethod == "GET" {
+                return Self.makeResponse(url: url, body: "<html></html>", statusCode: 200)
+            }
+
+            if url.host == "modelstudio.console.alibabacloud.com", url.path == "/tool/user/info.json" {
+                throw URLError(.timedOut)
+            }
+
+            if url.host == "bailian-singapore-cs.alibabacloud.com", request.httpMethod == "POST" {
+                let body = Self.requestBodyString(from: request)
+                #expect(body.contains("sec_token=cookie-sec-token"))
+                let json = """
+                {
+                  "data": {
+                    "codingPlanInstanceInfos": [
+                      { "planName": "Alibaba Coding Plan Pro", "status": "VALID" }
+                    ],
+                    "codingPlanQuotaInfo": {
+                      "per5HourUsedQuota": 52,
+                      "per5HourTotalQuota": 1000,
+                      "per5HourQuotaNextRefreshTime": 1700000300000
+                    }
+                  },
+                  "status_code": 0
+                }
+                """
+                return Self.makeResponse(url: url, body: json, statusCode: 200)
+            }
+
+            throw URLError(.unsupportedURL)
+        }
+
+        let snapshot = try await AlibabaCodingPlanUsageFetcher.fetchUsage(
+            cookieHeader: "sec_token=cookie-sec-token; login_aliyunid_ticket=ticket; login_aliyunid_pk=user",
+            region: .international,
+            environment: [:],
+            now: Date(timeIntervalSince1970: 1_700_000_000))
+
+        #expect(snapshot.planName == "Alibaba Coding Plan Pro")
+        #expect(snapshot.fiveHourUsedQuota == 52)
+        #expect(snapshot.fiveHourTotalQuota == 1000)
+    }
+
+    @Test
+    func `host override applies to user info SEC token fallback`() async throws {
+        let registered = URLProtocol.registerClass(AlibabaConsoleSECTokenStubURLProtocol.self)
+        defer {
+            if registered {
+                URLProtocol.unregisterClass(AlibabaConsoleSECTokenStubURLProtocol.self)
+            }
+            AlibabaConsoleSECTokenStubURLProtocol.handler = nil
+        }
+
+        AlibabaConsoleSECTokenStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            #expect(url.host == "modelstudio.console.alibabacloud.com")
+
+            if request.httpMethod == "GET", url.path == AlibabaCodingPlanAPIRegion.international.dashboardURL.path {
+                return Self.makeResponse(url: url, body: "<html></html>", statusCode: 200)
+            }
+
+            if request.httpMethod == "GET", url.path == "/tool/user/info.json" {
+                return Self.makeResponse(
+                    url: url,
+                    body: #"{"data":{"secToken":"override-sec-token"}}"#,
+                    statusCode: 200)
+            }
+
+            if request.httpMethod == "POST", url.path == "/data/api.json" {
+                let body = Self.requestBodyString(from: request)
+                #expect(body.contains("sec_token=override-sec-token"))
+                let json = """
+                {
+                  "data": {
+                    "codingPlanInstanceInfos": [
+                      { "planName": "Alibaba Coding Plan Pro", "status": "VALID" }
+                    ],
+                    "codingPlanQuotaInfo": {
+                      "per5HourUsedQuota": 21,
+                      "per5HourTotalQuota": 1000,
+                      "per5HourQuotaNextRefreshTime": 1700000300000
+                    }
+                  },
+                  "status_code": 0
+                }
+                """
+                return Self.makeResponse(url: url, body: json, statusCode: 200)
+            }
+
+            throw URLError(.unsupportedURL)
+        }
+
+        let snapshot = try await AlibabaCodingPlanUsageFetcher.fetchUsage(
+            cookieHeader: "sec_token=cookie-sec-token; login_aliyunid_ticket=ticket; login_aliyunid_pk=user",
+            region: .international,
+            environment: [AlibabaCodingPlanSettingsReader.hostKey: "https://modelstudio.console.alibabacloud.com"],
+            now: Date(timeIntervalSince1970: 1_700_000_000))
+
+        #expect(snapshot.planName == "Alibaba Coding Plan Pro")
+        #expect(snapshot.fiveHourUsedQuota == 21)
+        #expect(snapshot.fiveHourTotalQuota == 1000)
+    }
+
+    @Test
+    func `console request body uses region specific metadata`() async throws {
+        let registered = URLProtocol.registerClass(AlibabaConsoleSECTokenStubURLProtocol.self)
+        defer {
+            if registered {
+                URLProtocol.unregisterClass(AlibabaConsoleSECTokenStubURLProtocol.self)
+            }
+            AlibabaConsoleSECTokenStubURLProtocol.handler = nil
+        }
+
+        AlibabaConsoleSECTokenStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+
+            if request.httpMethod == "GET", url.path == AlibabaCodingPlanAPIRegion.chinaMainland.dashboardURL.path {
+                return Self.makeResponse(url: url, body: "<html></html>", statusCode: 200)
+            }
+
+            if request.httpMethod == "GET", url.path == "/tool/user/info.json" {
+                return Self.makeResponse(url: url, body: #"{"data":{"secToken":"cn-sec-token"}}"#, statusCode: 200)
+            }
+
+            if request.httpMethod == "POST", url.path == "/data/api.json" {
+                let body = Self.requestBodyString(from: request)
+                let params = try #require(Self.requestParamsDictionary(from: body))
+                let data = try #require(params["Data"] as? [String: Any])
+                let cornerstone = try #require(data["cornerstoneParam"] as? [String: Any])
+                #expect(cornerstone["domain"] as? String == AlibabaCodingPlanAPIRegion.chinaMainland.consoleDomain)
+                #expect(cornerstone["consoleSite"] as? String == AlibabaCodingPlanAPIRegion.chinaMainland.consoleSite)
+                #expect(
+                    cornerstone["feURL"] as? String
+                        == AlibabaCodingPlanAPIRegion.chinaMainland.dashboardURL.absoluteString)
+
+                let json = """
+                {
+                  "data": {
+                    "codingPlanInstanceInfos": [
+                      { "planName": "Alibaba Coding Plan Pro", "status": "VALID" }
+                    ],
+                    "codingPlanQuotaInfo": {
+                      "per5HourUsedQuota": 21,
+                      "per5HourTotalQuota": 1000,
+                      "per5HourQuotaNextRefreshTime": 1700000300000
+                    }
+                  },
+                  "status_code": 0
+                }
+                """
+                return Self.makeResponse(url: url, body: json, statusCode: 200)
+            }
+
+            throw URLError(.unsupportedURL)
+        }
+
+        let snapshot = try await AlibabaCodingPlanUsageFetcher.fetchUsage(
+            cookieHeader: "sec_token=cookie-sec-token; login_aliyunid_ticket=ticket; login_aliyunid_pk=user",
+            region: .chinaMainland,
+            environment: [:],
+            now: Date(timeIntervalSince1970: 1_700_000_000))
+
+        #expect(snapshot.planName == "Alibaba Coding Plan Pro")
+        #expect(snapshot.fiveHourUsedQuota == 21)
+        #expect(snapshot.fiveHourTotalQuota == 1000)
+    }
+
+    private static func makeResponse(url: URL, body: String, statusCode: Int) -> (HTTPURLResponse, Data) {
+        let response = HTTPURLResponse(
+            url: url,
+            statusCode: statusCode,
+            httpVersion: "HTTP/1.1",
+            headerFields: ["Content-Type": "application/json"])!
+        return (response, Data(body.utf8))
+    }
+
+    private static func requestBodyString(from request: URLRequest) -> String {
+        if let data = request.httpBody {
+            return String(data: data, encoding: .utf8) ?? ""
+        }
+
+        guard let stream = request.httpBodyStream else {
+            return ""
+        }
+
+        stream.open()
+        defer { stream.close() }
+
+        var data = Data()
+        let bufferSize = 4096
+        let buffer = UnsafeMutablePointer<UInt8>.allocate(capacity: bufferSize)
+        defer { buffer.deallocate() }
+
+        while stream.hasBytesAvailable {
+            let count = stream.read(buffer, maxLength: bufferSize)
+            if count <= 0 {
+                break
+            }
+            data.append(buffer, count: count)
+        }
+
+        return String(data: data, encoding: .utf8) ?? ""
+    }
+
+    private static func requestParamsDictionary(from body: String) -> [String: Any]? {
+        guard let components = URLComponents(string: "https://example.invalid/?\(body)"),
+              let params = components.queryItems?.first(where: { $0.name == "params" })?.value,
+              let data = params.data(using: .utf8)
+        else {
+            return nil
+        }
+
+        let object = try? JSONSerialization.jsonObject(with: data, options: [])
+        return object as? [String: Any]
+    }
+}
+
+final class AlibabaUsageFetcherStubURLProtocol: URLProtocol {
+    nonisolated(unsafe) static var handler: ((URLRequest) throws -> (HTTPURLResponse, Data))?
+
+    override static func canInit(with request: URLRequest) -> Bool {
+        request.url?.host == "bailian.console.aliyun.com"
+    }
+
+    override static func canonicalRequest(for request: URLRequest) -> URLRequest {
+        request
+    }
+
+    override func startLoading() {
+        guard let handler = Self.handler else {
+            self.client?.urlProtocol(self, didFailWithError: URLError(.badServerResponse))
+            return
+        }
+
+        do {
+            let (response, data) = try handler(self.request)
+            self.client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
+            self.client?.urlProtocol(self, didLoad: data)
+            self.client?.urlProtocolDidFinishLoading(self)
+        } catch {
+            self.client?.urlProtocol(self, didFailWithError: error)
+        }
+    }
+
+    override func stopLoading() {}
+}
+
+final class AlibabaConsoleSECTokenStubURLProtocol: URLProtocol {
+    nonisolated(unsafe) static var handler: ((URLRequest) throws -> (HTTPURLResponse, Data))?
+
+    override static func canInit(with request: URLRequest) -> Bool {
+        guard let host = request.url?.host else { return false }
+        return [
+            "modelstudio.console.alibabacloud.com",
+            "bailian-singapore-cs.alibabacloud.com",
+            "bailian.console.aliyun.com",
+            "bailian-cs.console.aliyun.com",
+            "bailian-beijing-cs.aliyuncs.com",
+        ].contains(host)
+    }
+
+    override static func canonicalRequest(for request: URLRequest) -> URLRequest {
+        request
+    }
+
+    override func startLoading() {
+        guard let handler = Self.handler else {
+            self.client?.urlProtocol(self, didFailWithError: URLError(.badServerResponse))
+            return
+        }
+
+        do {
+            let (response, data) = try handler(self.request)
+            self.client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
+            self.client?.urlProtocol(self, didLoad: data)
+            self.client?.urlProtocolDidFinishLoading(self)
+        } catch {
+            self.client?.urlProtocol(self, didFailWithError: error)
+        }
+    }
+
+    override func stopLoading() {}
+}
diff --git a/Tests/CodexBarTests/AlibabaTokenPlanProviderTests.swift b/Tests/CodexBarTests/AlibabaTokenPlanProviderTests.swift
new file mode 100644
index 0000000000..fb17b4d0fa
--- /dev/null
+++ b/Tests/CodexBarTests/AlibabaTokenPlanProviderTests.swift
@@ -0,0 +1,774 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct AlibabaTokenPlanSettingsReaderTests {
+    @Test
+    func `cookie reads from environment`() {
+        let cookie = AlibabaTokenPlanSettingsReader.cookieHeader(environment: [
+            AlibabaTokenPlanSettingsReader.cookieHeaderKey: "\"login_aliyunid_ticket=ticket\"",
+        ])
+        #expect(cookie == "login_aliyunid_ticket=ticket")
+    }
+
+    @Test
+    func `quota URL infers HTTPS scheme`() {
+        let url = AlibabaTokenPlanSettingsReader.quotaURL(environment: [
+            AlibabaTokenPlanSettingsReader.quotaURLKey: "quota.token-plan.test/data/api.json",
+        ])
+
+        #expect(url?.scheme == "https")
+        #expect(url?.host == "quota.token-plan.test")
+    }
+
+    @Test
+    func `quota URL rejects non HTTPS schemes`() {
+        let httpURL = AlibabaTokenPlanSettingsReader.quotaURL(environment: [
+            AlibabaTokenPlanSettingsReader.quotaURLKey: "http://quota.token-plan.test/data/api.json",
+        ])
+        let ftpURL = AlibabaTokenPlanSettingsReader.quotaURL(environment: [
+            AlibabaTokenPlanSettingsReader.quotaURLKey: "ftp://quota.token-plan.test/data/api.json",
+        ])
+
+        #expect(httpURL == nil)
+        #expect(ftpURL == nil)
+    }
+
+    @Test
+    func `host override rejects non HTTPS schemes`() {
+        let httpHost = AlibabaTokenPlanSettingsReader.hostOverride(environment: [
+            AlibabaTokenPlanSettingsReader.hostKey: "http://dashboard.token-plan.test",
+        ])
+        let httpsHost = AlibabaTokenPlanSettingsReader.hostOverride(environment: [
+            AlibabaTokenPlanSettingsReader.hostKey: "https://dashboard.token-plan.test",
+        ])
+        let bareHost = AlibabaTokenPlanSettingsReader.hostOverride(environment: [
+            AlibabaTokenPlanSettingsReader.hostKey: "dashboard.token-plan.test",
+        ])
+
+        #expect(httpHost == nil)
+        #expect(httpsHost == "https://dashboard.token-plan.test")
+        #expect(bareHost == "dashboard.token-plan.test")
+    }
+
+    @Test
+    func `default quota URL targets subscription summary API`() {
+        let url = AlibabaTokenPlanUsageFetcher.defaultQuotaURL
+        #expect(url.host == "bailian.console.aliyun.com")
+        #expect(url.absoluteString.contains("GetSubscriptionSummary"))
+        #expect(url.absoluteString.contains("BssOpenAPI-V3"))
+    }
+}
+
+struct AlibabaTokenPlanCookieHeaderTests {
+    @Test
+    func `builds URL scoped headers for API and dashboard`() throws {
+        let cookies = [
+            self.cookie(name: "login_aliyunid_ticket", value: "ticket", domain: ".aliyun.com"),
+            self.cookie(name: "login_current_pk", value: "account", domain: ".aliyun.com"),
+            self.cookie(name: "sec_token", value: "shared", domain: ".console.aliyun.com"),
+            self.cookie(name: "sec_token", value: "dashboard", domain: "bailian.console.aliyun.com"),
+            self.cookie(name: "modelstudio_only", value: "modelstudio", domain: "modelstudio.console.alibabacloud.com"),
+        ]
+
+        let headers = try #require(AlibabaTokenPlanCookieHeader.headers(from: cookies))
+
+        #expect(headers.apiCookieHeader.contains("login_aliyunid_ticket=ticket"))
+        #expect(headers.apiCookieHeader.contains("login_current_pk=account"))
+        #expect(headers.apiCookieHeader.contains("sec_token=dashboard"))
+        #expect(!headers.apiCookieHeader.contains("modelstudio_only=modelstudio"))
+        #expect(headers.dashboardCookieHeader.contains("sec_token=dashboard"))
+        #expect(!headers.dashboardCookieHeader.contains("modelstudio_only=modelstudio"))
+    }
+
+    @Test
+    func `cached token plan headers preserve URL scoping`() throws {
+        let headers = AlibabaTokenPlanCookieHeaders(
+            apiCookieHeader: "login_aliyunid_ticket=ticket; api_only=api",
+            dashboardCookieHeader: "login_aliyunid_ticket=ticket; dashboard_only=dashboard")
+
+        let cached = try #require(AlibabaTokenPlanCookieHeaders(cachedHeader: headers.cacheCookieHeader))
+
+        #expect(cached.apiCookieHeader.contains("api_only=api"))
+        #expect(!cached.apiCookieHeader.contains("dashboard_only=dashboard"))
+        #expect(cached.dashboardCookieHeader.contains("dashboard_only=dashboard"))
+        #expect(!cached.dashboardCookieHeader.contains("api_only=api"))
+    }
+
+    @Test
+    func `builds headers from environment scoped URLs`() throws {
+        let cookies = [
+            self.cookie(name: "login_aliyunid_ticket", value: "ticket", domain: ".token-plan.test"),
+            self.cookie(name: "api_only", value: "api", domain: "quota.token-plan.test"),
+            self.cookie(name: "dashboard_only", value: "dashboard", domain: "dashboard.token-plan.test"),
+            self.cookie(name: "prod_api_only", value: "prod-api", domain: "bailian.console.aliyun.com"),
+            self.cookie(name: "prod_dashboard_only", value: "prod-dashboard", domain: "bailian.console.aliyun.com"),
+        ]
+
+        let headers = try #require(AlibabaTokenPlanCookieHeader.headers(
+            from: cookies,
+            environment: [
+                AlibabaTokenPlanSettingsReader.quotaURLKey: "https://quota.token-plan.test/data/api.json",
+                AlibabaTokenPlanSettingsReader.hostKey: "https://dashboard.token-plan.test",
+            ]))
+
+        #expect(headers.apiCookieHeader.contains("login_aliyunid_ticket=ticket"))
+        #expect(headers.apiCookieHeader.contains("api_only=api"))
+        #expect(!headers.apiCookieHeader.contains("prod_api_only=prod-api"))
+        #expect(headers.dashboardCookieHeader.contains("dashboard_only=dashboard"))
+        #expect(!headers.dashboardCookieHeader.contains("prod_dashboard_only=prod-dashboard"))
+    }
+
+    private func cookie(
+        name: String,
+        value: String,
+        domain: String,
+        path: String = "/",
+        expires: Date = Date(timeIntervalSinceNow: 3600)) -> HTTPCookie
+    {
+        HTTPCookie(properties: [
+            .domain: domain,
+            .path: path,
+            .name: name,
+            .value: value,
+            .expires: expires,
+            .secure: true,
+        ])!
+    }
+}
+
+struct AlibabaTokenPlanUsageSnapshotTests {
+    @Test
+    func `maps used and total quota to primary window`() {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let reset = Date(timeIntervalSince1970: 1_700_100_000)
+        let snapshot = AlibabaTokenPlanUsageSnapshot(
+            planName: "TOKEN PLAN",
+            usedQuota: 250,
+            totalQuota: 1000,
+            remainingQuota: nil,
+            resetsAt: reset,
+            updatedAt: now)
+
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.primary?.usedPercent == 25)
+        #expect(usage.primary?.resetsAt == reset)
+        #expect(usage.primary?.resetDescription == "250 / 1,000 credits used")
+        #expect(usage.loginMethod(for: .alibabatokenplan) == "TOKEN PLAN")
+    }
+
+    @Test
+    func `does not create primary window from balance only`() {
+        let snapshot = AlibabaTokenPlanUsageSnapshot(
+            planName: "TOKEN PLAN",
+            usedQuota: nil,
+            totalQuota: nil,
+            remainingQuota: 700,
+            resetsAt: nil,
+            updatedAt: Date(timeIntervalSince1970: 1_700_000_000))
+
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.primary == nil)
+        #expect(usage.loginMethod(for: .alibabatokenplan) == "TOKEN PLAN")
+    }
+}
+
+@Suite(.serialized)
+struct AlibabaTokenPlanUsageParsingTests {
+    @Test
+    func `parses subscription summary payload`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let json = """
+        {
+          "Success": true,
+          "Data": {
+            "TotalCount": 1,
+            "TotalValue": 1000,
+            "TotalSurplusValue": 875,
+            "NearestExpireDate": 1701000000000
+          },
+          "Code": "200"
+        }
+        """
+
+        let snapshot = try AlibabaTokenPlanUsageFetcher.parseUsageSnapshot(from: Data(json.utf8), now: now)
+
+        #expect(snapshot.planName == "TOKEN PLAN")
+        #expect(snapshot.usedQuota == 125)
+        #expect(snapshot.totalQuota == 1000)
+        #expect(snapshot.remainingQuota == 875)
+        #expect(snapshot.resetsAt == Date(timeIntervalSince1970: 1_701_000_000))
+        #expect(snapshot.toUsageSnapshot().primary?.usedPercent == 12.5)
+    }
+
+    @Test
+    func `parses nested subscription summary body`() throws {
+        let body = """
+        {
+          "success": true,
+          "data": {
+            "totalCount": 1,
+            "totalSurplusValue": 750,
+            "totalValue": 1000
+          }
+        }
+        """
+        let payload = ["successResponse": ["body": body]]
+        let data = try JSONSerialization.data(withJSONObject: payload)
+
+        let snapshot = try AlibabaTokenPlanUsageFetcher.parseUsageSnapshot(from: data)
+
+        #expect(snapshot.planName == "TOKEN PLAN")
+        #expect(snapshot.usedQuota == 250)
+        #expect(snapshot.remainingQuota == 750)
+        #expect(snapshot.totalQuota == 1000)
+        #expect(snapshot.toUsageSnapshot().primary?.usedPercent == 25)
+    }
+
+    @Test
+    func `empty subscription summary stays visible without quota window`() throws {
+        let json = """
+        {
+          "Success": true,
+          "Data": {
+            "TotalCount": 0
+          }
+        }
+        """
+
+        let snapshot = try AlibabaTokenPlanUsageFetcher.parseUsageSnapshot(from: Data(json.utf8))
+
+        #expect(snapshot.planName == nil)
+        #expect(snapshot.totalQuota == nil)
+        #expect(snapshot.toUsageSnapshot().primary == nil)
+    }
+
+    @Test
+    func `login payload maps to login required`() {
+        let json = """
+        {
+          "code": "ConsoleNeedLogin",
+          "message": "You need to log in.",
+          "successResponse": false
+        }
+        """
+
+        #expect(throws: AlibabaTokenPlanUsageError.loginRequired) {
+            try AlibabaTokenPlanUsageFetcher.parseUsageSnapshot(from: Data(json.utf8))
+        }
+    }
+
+    @Test
+    func `post only token payload maps to login required`() {
+        let json = """
+        {
+          "code": "PostonlyOrTokenError",
+          "message": "Your request has expired. Please refresh the page.",
+          "successResponse": false
+        }
+        """
+
+        #expect(throws: AlibabaTokenPlanUsageError.loginRequired) {
+            try AlibabaTokenPlanUsageFetcher.parseUsageSnapshot(from: Data(json.utf8))
+        }
+    }
+
+    @Test
+    func `nested unsuccessful subscription summary maps to API error`() throws {
+        let body = """
+        {
+          "success": false,
+          "message": "Subscription lookup failed"
+        }
+        """
+        let payload = ["successResponse": ["body": body]]
+        let data = try JSONSerialization.data(withJSONObject: payload)
+
+        #expect(throws: AlibabaTokenPlanUsageError.apiError("Subscription lookup failed")) {
+            try AlibabaTokenPlanUsageFetcher.parseUsageSnapshot(from: data)
+        }
+    }
+
+    @Test
+    func `forbidden payload maps to invalid credentials`() {
+        let json = """
+        {
+          "statusCode": 403,
+          "message": "Forbidden"
+        }
+        """
+
+        #expect(throws: AlibabaTokenPlanUsageError.invalidCredentials) {
+            try AlibabaTokenPlanUsageFetcher.parseUsageSnapshot(from: Data(json.utf8))
+        }
+    }
+
+    @Test
+    func `failed forbidden payload maps to invalid credentials`() {
+        let json = """
+        {
+          "successResponse": false,
+          "statusCode": 403,
+          "message": "Forbidden"
+        }
+        """
+
+        #expect(throws: AlibabaTokenPlanUsageError.invalidCredentials) {
+            try AlibabaTokenPlanUsageFetcher.parseUsageSnapshot(from: Data(json.utf8))
+        }
+    }
+
+    @Test
+    func `html login payload maps to login required`() {
+        let html = """
+        <html>
+          <body>Please login to Alibaba Cloud</body>
+        </html>
+        """
+
+        #expect(throws: AlibabaTokenPlanUsageError.loginRequired) {
+            try AlibabaTokenPlanUsageFetcher.parseUsageSnapshot(from: Data(html.utf8))
+        }
+    }
+
+    @Test
+    func `non json payload maps to parse failed`() {
+        #expect(throws: AlibabaTokenPlanUsageError.parseFailed("Invalid JSON response")) {
+            try AlibabaTokenPlanUsageFetcher.parseUsageSnapshot(from: Data("not-json".utf8))
+        }
+    }
+
+    @Test
+    func `SEC token preflight falls back to user info`() async throws {
+        defer {
+            AlibabaTokenPlanStubURLProtocol.handler = nil
+        }
+
+        AlibabaTokenPlanStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+
+            if url.host == "alibaba-token-plan.test",
+               url.path == "/cn-beijing",
+               request.httpMethod == "GET"
+            {
+                #expect(url.port == 9443)
+                return Self.makeResponse(url: url, body: "<html></html>", statusCode: 200)
+            }
+
+            if url.host == "alibaba-token-plan.test",
+               url.path == "/tool/user/info.json",
+               request.httpMethod == "GET"
+            {
+                #expect(url.port == 9443)
+                #expect(request.value(forHTTPHeaderField: "Cookie") == "login_aliyunid_ticket=ticket; raw_only=keep")
+                #expect(request.value(forHTTPHeaderField: "Accept") == "application/json, text/plain, */*")
+                let json = """
+                {
+                  "code": "200",
+                  "data": {
+                    "secToken": "user-info-token"
+                  },
+                  "successResponse": true
+                }
+                """
+                return Self.makeResponse(url: url, body: json, statusCode: 200)
+            }
+
+            if url.host == "alibaba-token-plan.test", request.httpMethod == "POST" {
+                #expect(request.value(forHTTPHeaderField: "Cookie") == "login_aliyunid_ticket=ticket; raw_only=keep")
+                #expect(request.value(forHTTPHeaderField: "Origin") == "https://bailian.console.aliyun.com")
+                #expect(request.value(forHTTPHeaderField: "Referer") == AlibabaTokenPlanUsageFetcher.dashboardURL
+                    .absoluteString)
+                let body = Self.requestBodyString(from: request)
+                #expect(body.contains("sec_token=user-info-token"))
+                #expect(body.contains("GetSubscriptionSummary"))
+                #expect(body.contains("BssOpenAPI-V3"))
+                #expect(body.contains("ProductCode"))
+                #expect(body.contains("sfm_tokenplanteams_dp_cn"))
+                let json = """
+                {
+                  "Success": true,
+                  "Data": {
+                    "TotalCount": 1,
+                    "TotalValue": 1000,
+                    "TotalSurplusValue": 900
+                  }
+                }
+                """
+                return Self.makeResponse(url: url, body: json, statusCode: 200)
+            }
+
+            throw URLError(.unsupportedURL)
+        }
+
+        let configuration = URLSessionConfiguration.ephemeral
+        configuration.protocolClasses = [AlibabaTokenPlanStubURLProtocol.self]
+        let session = URLSession(configuration: configuration)
+        let snapshot = try await AlibabaTokenPlanUsageFetcher.fetchUsage(
+            apiCookieHeader: "login_aliyunid_ticket=ticket; raw_only=keep",
+            dashboardCookieHeader: "login_aliyunid_ticket=ticket; raw_only=keep",
+            environment: [AlibabaTokenPlanSettingsReader.hostKey: "https://alibaba-token-plan.test:9443"],
+            session: session)
+
+        #expect(snapshot.planName == "TOKEN PLAN")
+    }
+
+    @Test
+    func `SEC token preflight uses injected session`() async throws {
+        AlibabaTokenPlanStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+
+            if url.host == "session-token.test", request.httpMethod == "GET" {
+                return Self.makeResponse(
+                    url: url,
+                    body: "<html><script>sec_token = \"session-html-token\";</script></html>",
+                    statusCode: 200)
+            }
+
+            if url.host == "session-token.test", request.httpMethod == "POST" {
+                let body = Self.requestBodyString(from: request)
+                #expect(body.contains("sec_token=session-html-token"))
+                let json = """
+                {
+                  "Success": true,
+                  "Data": {
+                    "TotalCount": 1,
+                    "TotalValue": 1000,
+                    "TotalSurplusValue": 900
+                  }
+                }
+                """
+                return Self.makeResponse(url: url, body: json, statusCode: 200)
+            }
+
+            throw URLError(.unsupportedURL)
+        }
+        defer {
+            AlibabaTokenPlanStubURLProtocol.handler = nil
+        }
+
+        let configuration = URLSessionConfiguration.ephemeral
+        configuration.protocolClasses = [AlibabaTokenPlanStubURLProtocol.self]
+        let session = URLSession(configuration: configuration)
+        let snapshot = try await AlibabaTokenPlanUsageFetcher.fetchUsage(
+            apiCookieHeader: "login_aliyunid_ticket=ticket",
+            dashboardCookieHeader: "login_aliyunid_ticket=ticket",
+            environment: [AlibabaTokenPlanSettingsReader.hostKey: "https://session-token.test"],
+            session: session)
+
+        #expect(snapshot.planName == "TOKEN PLAN")
+    }
+
+    @Test
+    func `redirect preserves cookie only for same host HTTPS requests`() throws {
+        let sourceURL = try #require(URL(string: "https://bailian.console.aliyun.com/data/api.json"))
+        let sameHostURL = try #require(URL(string: "https://bailian.console.aliyun.com/redirected"))
+        let crossHostURL = try #require(URL(string: "https://signin.aliyun.com/login"))
+        let insecureURL = try #require(URL(string: "http://bailian.console.aliyun.com/redirected"))
+        let response = try #require(HTTPURLResponse(
+            url: sourceURL,
+            statusCode: 302,
+            httpVersion: "HTTP/1.1",
+            headerFields: nil))
+
+        var sameHostRequest = URLRequest(url: sameHostURL)
+        sameHostRequest.setValue("old=value", forHTTPHeaderField: "Cookie")
+        let sameHostRedirect = try #require(AlibabaTokenPlanUsageFetcher.redirectedRequest(
+            response: response,
+            request: sameHostRequest,
+            cookieHeader: "login_aliyunid_ticket=ticket"))
+        #expect(sameHostRedirect.value(forHTTPHeaderField: "Cookie") == "login_aliyunid_ticket=ticket")
+
+        var crossHostRequest = URLRequest(url: crossHostURL)
+        crossHostRequest.setValue("old=value", forHTTPHeaderField: "Cookie")
+        let crossHostRedirect = try #require(AlibabaTokenPlanUsageFetcher.redirectedRequest(
+            response: response,
+            request: crossHostRequest,
+            cookieHeader: "login_aliyunid_ticket=ticket"))
+        #expect(crossHostRedirect.value(forHTTPHeaderField: "Cookie") == nil)
+
+        let insecureRedirect = AlibabaTokenPlanUsageFetcher.redirectedRequest(
+            response: response,
+            request: URLRequest(url: insecureURL),
+            cookieHeader: "login_aliyunid_ticket=ticket")
+        #expect(insecureRedirect == nil)
+    }
+
+    @Test
+    func `dashboard redirect preserves dashboard cookie header`() throws {
+        let sourceURL = try #require(URL(string: "https://bailian.console.aliyun.com/cn-beijing"))
+        let targetURL = try #require(URL(string: "https://bailian.console.aliyun.com/redirected"))
+        let response = try #require(HTTPURLResponse(
+            url: sourceURL,
+            statusCode: 302,
+            httpVersion: "HTTP/1.1",
+            headerFields: nil))
+        var request = URLRequest(url: targetURL)
+        request.setValue("api_only=wrong", forHTTPHeaderField: "Cookie")
+
+        let redirected = try #require(AlibabaTokenPlanUsageFetcher.redirectedRequest(
+            response: response,
+            request: request,
+            cookieHeader: "dashboard_only=keep"))
+
+        #expect(redirected.value(forHTTPHeaderField: "Cookie") == "dashboard_only=keep")
+    }
+
+    private static func makeResponse(url: URL, body: String, statusCode: Int) -> (HTTPURLResponse, Data) {
+        let response = HTTPURLResponse(
+            url: url,
+            statusCode: statusCode,
+            httpVersion: "HTTP/1.1",
+            headerFields: ["Content-Type": "application/json"])!
+        return (response, Data(body.utf8))
+    }
+
+    private static func requestBodyString(from request: URLRequest) -> String {
+        if let data = request.httpBody {
+            return String(data: data, encoding: .utf8) ?? ""
+        }
+        if let stream = request.httpBodyStream {
+            stream.open()
+            defer {
+                stream.close()
+            }
+            var data = Data()
+            var buffer = [UInt8](repeating: 0, count: 1024)
+            while stream.hasBytesAvailable {
+                let count = stream.read(&buffer, maxLength: buffer.count)
+                if count <= 0 {
+                    break
+                }
+                data.append(buffer, count: count)
+            }
+            return String(data: data, encoding: .utf8) ?? ""
+        }
+        return ""
+    }
+}
+
+@Suite(.serialized)
+struct AlibabaTokenPlanWebStrategyTests {
+    private struct StubClaudeFetcher: ClaudeUsageFetching {
+        func loadLatestUsage(model _: String) async throws -> ClaudeUsageSnapshot {
+            throw ClaudeUsageError.parseFailed("stub")
+        }
+
+        func debugRawProbe(model _: String) async -> String {
+            "stub"
+        }
+
+        func detectVersion() -> String? {
+            nil
+        }
+    }
+
+    @Test
+    func `auto web strategy surfaces cookie import errors`() async throws {
+        let strategy = AlibabaTokenPlanWebFetchStrategy()
+        let settings = ProviderSettingsSnapshot.make(
+            alibabaTokenPlan: ProviderSettingsSnapshot.AlibabaTokenPlanProviderSettings(
+                cookieSource: .auto,
+                manualCookieHeader: nil))
+        let context = ProviderFetchContext(
+            runtime: .cli,
+            sourceMode: .web,
+            includeCredits: false,
+            webTimeout: 1,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: [:],
+            settings: settings,
+            fetcher: UsageFetcher(environment: [:]),
+            claudeFetcher: StubClaudeFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0))
+
+        CookieHeaderCache.clear(provider: .alibabatokenplan)
+        AlibabaCodingPlanCookieImporter.importSessionOverrideForTesting = { _, _ in
+            throw AlibabaCodingPlanSettingsError.missingCookie(
+                details: "macOS Keychain denied access to Chrome Safe Storage.")
+        }
+        defer {
+            AlibabaCodingPlanCookieImporter.importSessionOverrideForTesting = nil
+        }
+
+        #expect(await strategy.isAvailable(context))
+
+        do {
+            _ = try AlibabaTokenPlanWebFetchStrategy.resolveCookieHeader(context: context, allowCached: false)
+            Issue.record("Expected cookie import failure to be surfaced")
+        } catch let error as AlibabaTokenPlanSettingsError {
+            guard case let .missingCookie(details) = error else {
+                Issue.record("Expected missingCookie, got \(error)")
+                return
+            }
+            #expect(details == "macOS Keychain denied access to Chrome Safe Storage.")
+            #expect(error.localizedDescription.contains("Alibaba Token Plan"))
+            #expect(!error.localizedDescription.contains("Alibaba Coding Plan"))
+        }
+    }
+
+    @Test
+    func `auto web strategy imports subscription scoped token plan cookies`() throws {
+        let strategy = AlibabaTokenPlanWebFetchStrategy()
+        let settings = ProviderSettingsSnapshot.make(
+            alibabaTokenPlan: ProviderSettingsSnapshot.AlibabaTokenPlanProviderSettings(
+                cookieSource: .auto,
+                manualCookieHeader: nil))
+        let context = ProviderFetchContext(
+            runtime: .cli,
+            sourceMode: .web,
+            includeCredits: false,
+            webTimeout: 1,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: [:],
+            settings: settings,
+            fetcher: UsageFetcher(environment: [:]),
+            claudeFetcher: StubClaudeFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0))
+
+        CookieHeaderCache.clear(provider: .alibabatokenplan)
+        AlibabaCodingPlanCookieImporter.importSessionOverrideForTesting = { _, _ in
+            AlibabaCodingPlanCookieImporter.SessionInfo(
+                cookies: [
+                    self.cookie(name: "login_aliyunid_ticket", value: "ticket", domain: ".aliyun.com"),
+                    self.cookie(name: "login_current_pk", value: "account", domain: ".aliyun.com"),
+                    self.cookie(name: "dashboard_only", value: "dashboard", domain: "bailian.console.aliyun.com"),
+                    self.cookie(
+                        name: "modelstudio_only",
+                        value: "modelstudio",
+                        domain: "modelstudio.console.alibabacloud.com"),
+                    self.cookie(name: "alibabacloud_only", value: "cloud", domain: ".alibabacloud.com"),
+                ],
+                sourceLabel: "Chrome Default")
+        }
+        defer {
+            AlibabaCodingPlanCookieImporter.importSessionOverrideForTesting = nil
+            CookieHeaderCache.clear(provider: .alibabatokenplan)
+        }
+
+        let headers = try AlibabaTokenPlanWebFetchStrategy.resolveCookieHeaders(context: context, allowCached: false)
+
+        #expect(headers.apiCookieHeader == headers.dashboardCookieHeader)
+        #expect(headers.apiCookieHeader.contains("dashboard_only=dashboard"))
+        #expect(!headers.apiCookieHeader.contains("modelstudio_only=modelstudio"))
+        #expect(!headers.apiCookieHeader.contains("alibabacloud_only=cloud"))
+        #expect(headers.dashboardCookieHeader.contains("dashboard_only=dashboard"))
+        #expect(!headers.dashboardCookieHeader.contains("modelstudio_only=modelstudio"))
+        #expect(!headers.dashboardCookieHeader.contains("alibabacloud_only=cloud"))
+
+        AlibabaCodingPlanCookieImporter.importSessionOverrideForTesting = { _, _ in
+            throw AlibabaCodingPlanSettingsError.missingCookie(details: "unexpected import")
+        }
+        let cachedHeaders = try AlibabaTokenPlanWebFetchStrategy.resolveCookieHeaders(
+            context: context,
+            allowCached: true)
+        #expect(cachedHeaders.apiCookieHeader == headers.apiCookieHeader)
+        #expect(cachedHeaders.dashboardCookieHeader == headers.dashboardCookieHeader)
+        #expect(strategy.id == "alibaba-token-plan.web")
+    }
+
+    @Test
+    func `auto web strategy scopes imported cookies to environment overrides`() throws {
+        let settings = ProviderSettingsSnapshot.make(
+            alibabaTokenPlan: ProviderSettingsSnapshot.AlibabaTokenPlanProviderSettings(
+                cookieSource: .auto,
+                manualCookieHeader: nil))
+        let environment = [
+            AlibabaTokenPlanSettingsReader.quotaURLKey: "https://quota.token-plan.test/data/api.json",
+            AlibabaTokenPlanSettingsReader.hostKey: "https://dashboard.token-plan.test",
+        ]
+        let context = ProviderFetchContext(
+            runtime: .cli,
+            sourceMode: .web,
+            includeCredits: false,
+            webTimeout: 1,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: environment,
+            settings: settings,
+            fetcher: UsageFetcher(environment: environment),
+            claudeFetcher: StubClaudeFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0))
+
+        CookieHeaderCache.clear(provider: .alibabatokenplan)
+        AlibabaCodingPlanCookieImporter.importSessionOverrideForTesting = { _, _ in
+            AlibabaCodingPlanCookieImporter.SessionInfo(
+                cookies: [
+                    self.cookie(name: "login_aliyunid_ticket", value: "ticket", domain: ".token-plan.test"),
+                    self.cookie(name: "api_only", value: "api", domain: "quota.token-plan.test"),
+                    self.cookie(name: "dashboard_only", value: "dashboard", domain: "dashboard.token-plan.test"),
+                    self.cookie(name: "prod_api_only", value: "prod-api", domain: "bailian.console.aliyun.com"),
+                    self.cookie(
+                        name: "prod_dashboard_only",
+                        value: "prod-dashboard",
+                        domain: "bailian.console.aliyun.com"),
+                ],
+                sourceLabel: "Chrome Default")
+        }
+        defer {
+            AlibabaCodingPlanCookieImporter.importSessionOverrideForTesting = nil
+            CookieHeaderCache.clear(provider: .alibabatokenplan)
+        }
+
+        let headers = try AlibabaTokenPlanWebFetchStrategy.resolveCookieHeaders(context: context, allowCached: false)
+
+        #expect(headers.apiCookieHeader.contains("api_only=api"))
+        #expect(!headers.apiCookieHeader.contains("prod_api_only=prod-api"))
+        #expect(headers.dashboardCookieHeader.contains("dashboard_only=dashboard"))
+        #expect(!headers.dashboardCookieHeader.contains("prod_dashboard_only=prod-dashboard"))
+    }
+
+    private func cookie(
+        name: String,
+        value: String,
+        domain: String,
+        path: String = "/",
+        expires: Date = Date(timeIntervalSinceNow: 3600)) -> HTTPCookie
+    {
+        HTTPCookie(properties: [
+            .domain: domain,
+            .path: path,
+            .name: name,
+            .value: value,
+            .expires: expires,
+            .secure: true,
+        ])!
+    }
+}
+
+final class AlibabaTokenPlanStubURLProtocol: URLProtocol {
+    nonisolated(unsafe) static var handler: ((URLRequest) throws -> (HTTPURLResponse, Data))?
+
+    override static func canInit(with request: URLRequest) -> Bool {
+        guard let host = request.url?.host else { return false }
+        return host == "bailian.console.aliyun.com" ||
+            host == "alibaba-token-plan.test" ||
+            host == "session-token.test"
+    }
+
+    override static func canonicalRequest(for request: URLRequest) -> URLRequest {
+        request
+    }
+
+    override func startLoading() {
+        guard let handler = Self.handler else {
+            self.client?.urlProtocol(self, didFailWithError: URLError(.badServerResponse))
+            return
+        }
+
+        do {
+            let (response, data) = try handler(self.request)
+            self.client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
+            self.client?.urlProtocol(self, didLoad: data)
+            self.client?.urlProtocolDidFinishLoading(self)
+        } catch {
+            self.client?.urlProtocol(self, didFailWithError: error)
+        }
+    }
+
+    override func stopLoading() {}
+}
diff --git a/Tests/CodexBarTests/AmpUsageFetcherTests.swift b/Tests/CodexBarTests/AmpUsageFetcherTests.swift
index 8a4e8506cb..150042c73c 100644
--- a/Tests/CodexBarTests/AmpUsageFetcherTests.swift
+++ b/Tests/CodexBarTests/AmpUsageFetcherTests.swift
@@ -2,27 +2,133 @@ import Foundation
 import Testing
 @testable import CodexBarCore
 
-@Suite
 struct AmpUsageFetcherTests {
+    private func makeContext(
+        sourceMode: ProviderSourceMode,
+        env: [String: String] = [:]) -> ProviderFetchContext
+    {
+        let browserDetection = BrowserDetection(cacheTTL: 0)
+        return ProviderFetchContext(
+            runtime: .app,
+            sourceMode: sourceMode,
+            includeCredits: true,
+            webTimeout: 1,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: env,
+            settings: nil,
+            fetcher: UsageFetcher(),
+            claudeFetcher: ClaudeUsageFetcher(browserDetection: browserDetection),
+            browserDetection: browserDetection)
+    }
+
+    @Test
+    func `uses amp internal usage endpoint`() {
+        #expect(
+            AmpUsageFetcher.usageURL.absoluteString ==
+                "https://ampcode.com/api/internal?userDisplayBalanceInfo")
+    }
+
+    @Test
+    func `web fallback requires browser import or a manual session cookie`() {
+        let disabled = ProviderSettingsSnapshot.AmpProviderSettings(cookieSource: .off, manualCookieHeader: nil)
+        let invalidManual = ProviderSettingsSnapshot.AmpProviderSettings(
+            cookieSource: .manual,
+            manualCookieHeader: "other=value")
+        let validManual = ProviderSettingsSnapshot.AmpProviderSettings(
+            cookieSource: .manual,
+            manualCookieHeader: "session=test")
+
+        #expect(AmpStatusFetchStrategy.canUseWebFallback(
+            settings: nil,
+            canImportBrowserCookies: false) == false)
+        #expect(AmpStatusFetchStrategy.canUseWebFallback(
+            settings: nil,
+            canImportBrowserCookies: true))
+        #expect(AmpStatusFetchStrategy.canUseWebFallback(
+            settings: disabled,
+            canImportBrowserCookies: true) == false)
+        #expect(AmpStatusFetchStrategy.canUseWebFallback(
+            settings: invalidManual,
+            canImportBrowserCookies: false) == false)
+        #expect(AmpStatusFetchStrategy.canUseWebFallback(
+            settings: validManual,
+            canImportBrowserCookies: false))
+    }
+
+    @Test
+    func `cli cancellation does not fall back to web`() {
+        let strategy = AmpCLIFetchStrategy()
+        let context = self.makeContext(sourceMode: .auto)
+
+        #expect(!strategy.shouldFallback(on: CancellationError(), context: context))
+        #expect(!strategy.shouldFallback(on: URLError(.cancelled), context: context))
+        #expect(strategy.shouldFallback(on: AmpUsageError.parseFailed("missing"), context: context))
+        #expect(!strategy.shouldFallback(
+            on: AmpUsageError.parseFailed("missing"),
+            context: self.makeContext(sourceMode: .cli)))
+    }
+
+    @Test
+    func `api request uses bearer token without cookies`() throws {
+        let request = try AmpUsageFetcher.makeUsageAPIRequest(apiToken: "sgamp_test")
+
+        #expect(request.value(forHTTPHeaderField: "Authorization") == "Bearer sgamp_test")
+        #expect(request.value(forHTTPHeaderField: "Cookie") == nil)
+    }
+
+    @Test
+    func `api strategy falls back only from auto mode and preserves cancellation`() {
+        let strategy = AmpAPIFetchStrategy()
+        let auto = self.makeContext(sourceMode: .auto)
+
+        #expect(strategy.shouldFallback(on: AmpUsageError.missingAPIToken, context: auto))
+        #expect(strategy.shouldFallback(on: AmpUsageError.invalidAPIToken, context: auto))
+        #expect(strategy.shouldFallback(on: URLError(.timedOut), context: auto))
+        #expect(!strategy.shouldFallback(on: CancellationError(), context: auto))
+        #expect(!strategy.shouldFallback(on: URLError(.cancelled), context: auto))
+        #expect(!strategy.shouldFallback(
+            on: AmpUsageError.invalidAPIToken,
+            context: self.makeContext(sourceMode: .api)))
+    }
+
     @Test
-    func attachesCookieForAmpHosts() {
+    func `amp config token resolves through environment`() {
+        let env = [AmpSettingsReader.apiTokenKey: " 'sgamp_test' "]
+
+        #expect(ProviderTokenResolver.ampToken(environment: env) == "sgamp_test")
+    }
+
+    @Test
+    func `attaches cookie for amp hosts`() {
         #expect(AmpUsageFetcher.shouldAttachCookie(to: URL(string: "https://ampcode.com/settings")))
         #expect(AmpUsageFetcher.shouldAttachCookie(to: URL(string: "https://www.ampcode.com")))
         #expect(AmpUsageFetcher.shouldAttachCookie(to: URL(string: "https://app.ampcode.com/path")))
     }
 
     @Test
-    func rejectsNonAmpHosts() {
+    func `rejects non amp hosts`() {
         #expect(!AmpUsageFetcher.shouldAttachCookie(to: URL(string: "https://example.com")))
         #expect(!AmpUsageFetcher.shouldAttachCookie(to: URL(string: "https://ampcode.com.evil.com")))
         #expect(!AmpUsageFetcher.shouldAttachCookie(to: nil))
     }
 
     @Test
-    func detectsLoginRedirects() throws {
+    func `rejects non https amp urls`() {
+        #expect(!AmpUsageFetcher.shouldAttachCookie(to: URL(string: "http://ampcode.com/settings")))
+        #expect(!AmpUsageFetcher.shouldAttachCookie(to: URL(string: "http://www.ampcode.com")))
+        #expect(!AmpUsageFetcher.shouldAttachCookie(to: URL(string: "http://app.ampcode.com/path")))
+    }
+
+    @Test
+    func `detects login redirects`() throws {
         let signIn = try #require(URL(string: "https://ampcode.com/auth/sign-in?returnTo=%2Fsettings"))
         #expect(AmpUsageFetcher.isLoginRedirect(signIn))
 
+        let downgradedSignIn = try #require(URL(string: "http://ampcode.com/auth/sign-in?returnTo=%2Fsettings"))
+        #expect(AmpUsageFetcher.isLoginRedirect(downgradedSignIn))
+        #expect(!AmpUsageFetcher.shouldAttachCookie(to: downgradedSignIn))
+
         let sso = try #require(URL(string: "https://ampcode.com/auth/sso?returnTo=%2Fsettings"))
         #expect(AmpUsageFetcher.isLoginRedirect(sso))
 
@@ -31,10 +137,14 @@ struct AmpUsageFetcherTests {
 
         let signin = try #require(URL(string: "https://www.ampcode.com/signin"))
         #expect(AmpUsageFetcher.isLoginRedirect(signin))
+
+        let hostedAuth = try #require(URL(
+            string: "https://auth.ampcode.com/?client_id=test&redirect_uri=https%3A%2F%2Fampcode.com%2Fauth%2Fcallback"))
+        #expect(AmpUsageFetcher.isLoginRedirect(hostedAuth))
     }
 
     @Test
-    func ignoresNonLoginURLs() throws {
+    func `ignores non login UR ls`() throws {
         let settings = try #require(URL(string: "https://ampcode.com/settings"))
         #expect(!AmpUsageFetcher.isLoginRedirect(settings))
 
diff --git a/Tests/CodexBarTests/AmpUsageParserTests.swift b/Tests/CodexBarTests/AmpUsageParserTests.swift
index 89ab59bdc3..66a1cfc0b3 100644
--- a/Tests/CodexBarTests/AmpUsageParserTests.swift
+++ b/Tests/CodexBarTests/AmpUsageParserTests.swift
@@ -2,10 +2,156 @@ import Foundation
 import Testing
 @testable import CodexBarCore
 
-@Suite
 struct AmpUsageParserTests {
     @Test
-    func parsesFreeTierUsageFromSettingsHTML() throws {
+    func `amp cli probe runs usage and parses balances`() async throws {
+        let script = """
+        [ "$1" = "usage" ] || exit 2
+        cat <<'EOF'
+        Signed in as cli@example.com (team)
+        Amp Free: $6/$10 remaining (replenishes +$0.5/hour)
+        Individual credits: $12.50 remaining
+        Workspace Test Team: $7.25 remaining
+        EOF
+        """
+
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let snapshot = try await AmpCLIProbe(arguments: ["-c", script, "amp", "usage"]).fetch(
+            environment: ["AMP_CLI_PATH": "/bin/sh"],
+            now: now)
+
+        #expect(snapshot.freeUsed == 4)
+        #expect(snapshot.individualCredits == 12.5)
+        #expect(snapshot.workspaceBalances == [AmpWorkspaceBalance(name: "Test Team", remaining: 7.25)])
+        #expect(snapshot.accountEmail == "cli@example.com")
+        #expect(snapshot.updatedAt == now)
+    }
+
+    @Test
+    func `parses current amp usage display text`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let output = """
+        \u{1B}[2mSigned in as ampcode@3kh0.net (echo)\u{1B}[0m
+        Amp Free: $4.71/$10 remaining (replenishes +$0.42/hour) - https://ampcode.com/settings#amp-free
+        Individual credits: $25.64 remaining (set up automatic top-up to avoid running out) - https://ampcode.com/settings
+        Workspace meow: $10.22 remaining (set up automatic top-up to avoid running out) - https://ampcode.com/workspaces/meow
+        """
+
+        let snapshot = try AmpUsageParser.parse(displayText: output, now: now)
+
+        #expect(snapshot.freeQuota == 10)
+        #expect(try abs(#require(snapshot.freeUsed) - 5.29) < 0.001)
+        #expect(snapshot.hourlyReplenishment == 0.42)
+        #expect(snapshot.windowHours == 24)
+        #expect(snapshot.individualCredits == 25.64)
+        #expect(snapshot.workspaceBalances == [AmpWorkspaceBalance(name: "meow", remaining: 10.22)])
+        #expect(snapshot.accountEmail == "ampcode@3kh0.net")
+        #expect(snapshot.accountOrganization == "echo")
+        #expect(snapshot.toUsageSnapshot(now: now).ampUsage == AmpUsageDetails(
+            individualCredits: 25.64,
+            workspaceBalances: [AmpWorkspaceBalance(name: "meow", remaining: 10.22)]))
+
+        let encoded = try JSONEncoder().encode(snapshot.toUsageSnapshot(now: now))
+        let decoded = try JSONDecoder().decode(UsageSnapshot.self, from: encoded)
+        #expect(decoded.ampUsage == AmpUsageDetails(
+            individualCredits: 25.64,
+            workspaceBalances: [AmpWorkspaceBalance(name: "meow", remaining: 10.22)]))
+    }
+
+    @Test
+    func `parses individual credits without free tier usage`() throws {
+        let output = """
+        Signed in as paid@example.com
+        Individual credits: $25.64 remaining
+        """
+
+        let snapshot = try AmpUsageParser.parse(displayText: output)
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(snapshot.freeQuota == nil)
+        #expect(snapshot.freeUsed == nil)
+        #expect(snapshot.individualCredits == 25.64)
+        #expect(usage.primary == nil)
+        #expect(usage.ampUsage == AmpUsageDetails(individualCredits: 25.64, workspaceBalances: []))
+        #expect(usage.identity?.loginMethod == "Amp")
+    }
+
+    @Test
+    func `parses workspace credits without free tier usage`() throws {
+        let output = """
+        Signed in as workspace@example.com (team)
+        Workspace Alpha Team: $1,234.56 remaining
+        Workspace Beta: $7 remaining
+        """
+
+        let snapshot = try AmpUsageParser.parse(displayText: output)
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(snapshot.freeQuota == nil)
+        #expect(snapshot.workspaceBalances == [
+            AmpWorkspaceBalance(name: "Alpha Team", remaining: 1234.56),
+            AmpWorkspaceBalance(name: "Beta", remaining: 7),
+        ])
+        #expect(usage.primary == nil)
+        #expect(usage.ampUsage == AmpUsageDetails(
+            individualCredits: nil,
+            workspaceBalances: snapshot.workspaceBalances))
+    }
+
+    @Test
+    func `signed in identity can contain login`() throws {
+        let output = """
+        Signed in as login@example.com (login-team)
+        Amp Free: $6/$10 remaining (replenishes +$0.5/hour)
+        """
+
+        let snapshot = try AmpUsageParser.parse(displayText: output)
+
+        #expect(snapshot.accountEmail == "login@example.com")
+        #expect(snapshot.accountOrganization == "login-team")
+    }
+
+    @Test
+    func `parses current usage api response`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_005_000)
+        let displayText = """
+        Signed in as user@example.com (team)
+        Amp Free: $8/$10 remaining (replenishes +$0.5/hour)
+        Individual credits: $12.50 remaining
+        Workspace Alpha Team: $1,234.56 remaining
+        Workspace Beta: $7 remaining
+        """
+        let data = try JSONSerialization.data(withJSONObject: [
+            "ok": true,
+            "result": ["displayText": displayText],
+        ])
+
+        let snapshot = try AmpUsageFetcher.parseUsageAPIResponse(data, now: now)
+
+        #expect(snapshot.freeUsed == 2)
+        #expect(snapshot.individualCredits == 12.5)
+        #expect(snapshot.workspaceBalances == [
+            AmpWorkspaceBalance(name: "Alpha Team", remaining: 1234.56),
+            AmpWorkspaceBalance(name: "Beta", remaining: 7),
+        ])
+        #expect(snapshot.accountEmail == "user@example.com")
+        #expect(snapshot.accountOrganization == "team")
+    }
+
+    @Test
+    func `usage api auth error is invalid API token`() {
+        let data = Data(#"{"ok":false,"error":{"code":"auth-required","message":"Sign in"}}"#.utf8)
+
+        #expect {
+            try AmpUsageFetcher.parseUsageAPIResponse(data)
+        } throws: { error in
+            guard case AmpUsageError.invalidAPIToken = error else { return false }
+            return true
+        }
+    }
+
+    @Test
+    func `parses free tier usage from settings HTML`() throws {
         let now = Date(timeIntervalSince1970: 1_700_000_000)
         let html = """
         <script>
@@ -33,7 +179,7 @@ struct AmpUsageParserTests {
     }
 
     @Test
-    func parsesFreeTierUsageFromPrefetchedKey() throws {
+    func `parses free tier usage from prefetched key`() throws {
         let now = Date(timeIntervalSince1970: 1_700_010_000)
         let html = """
         <script>
@@ -49,7 +195,7 @@ struct AmpUsageParserTests {
     }
 
     @Test
-    func missingUsageThrowsParseFailed() {
+    func `missing usage throws parse failed`() {
         let html = "<html><body>No usage here.</body></html>"
 
         #expect {
@@ -61,7 +207,7 @@ struct AmpUsageParserTests {
     }
 
     @Test
-    func signedOutThrowsNotLoggedIn() {
+    func `signed out throws not logged in`() {
         let html = "<html><body>Please sign in to Amp.</body></html>"
 
         #expect {
@@ -73,7 +219,7 @@ struct AmpUsageParserTests {
     }
 
     @Test
-    func usageSnapshotClampsPercentAndWindow() {
+    func `usage snapshot clamps percent and window`() {
         let now = Date(timeIntervalSince1970: 1_700_020_000)
         let snapshot = AmpUsageSnapshot(
             freeQuota: 100,
@@ -88,7 +234,7 @@ struct AmpUsageParserTests {
     }
 
     @Test
-    func usageSnapshotOmitsResetWhenHourlyReplenishmentIsZero() {
+    func `usage snapshot omits reset when hourly replenishment is zero`() {
         let now = Date(timeIntervalSince1970: 1_700_030_000)
         let snapshot = AmpUsageSnapshot(
             freeQuota: 100,
diff --git a/Tests/CodexBarTests/AntigravityCLIHTTPSFetchStrategyTests.swift b/Tests/CodexBarTests/AntigravityCLIHTTPSFetchStrategyTests.swift
new file mode 100644
index 0000000000..2427f29e15
--- /dev/null
+++ b/Tests/CodexBarTests/AntigravityCLIHTTPSFetchStrategyTests.swift
@@ -0,0 +1,903 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+private func antigravityBlockingSleep(_ interval: TimeInterval) {
+    Thread.sleep(forTimeInterval: interval)
+}
+
+private final class AntigravityCLICounter: @unchecked Sendable {
+    private let lock = NSLock()
+    private var count = 0
+
+    @discardableResult
+    func increment() -> Int {
+        self.lock.lock()
+        self.count += 1
+        let value = self.count
+        self.lock.unlock()
+        return value
+    }
+
+    var value: Int {
+        self.lock.lock()
+        let value = self.count
+        self.lock.unlock()
+        return value
+    }
+}
+
+private final class AntigravityCLIPortRecorder: @unchecked Sendable {
+    private let lock = NSLock()
+    private var ports: [[Int]] = []
+
+    func append(_ value: [Int]) {
+        self.lock.lock()
+        self.ports.append(value)
+        self.lock.unlock()
+    }
+
+    func snapshot() -> [[Int]] {
+        self.lock.lock()
+        let value = self.ports
+        self.lock.unlock()
+        return value
+    }
+}
+
+private final class AntigravityCLITimeoutRecorder: @unchecked Sendable {
+    private let lock = NSLock()
+    private var timeouts: [TimeInterval] = []
+
+    func append(_ value: TimeInterval) {
+        self.lock.lock()
+        self.timeouts.append(value)
+        self.lock.unlock()
+    }
+
+    func snapshot() -> [TimeInterval] {
+        self.lock.lock()
+        let value = self.timeouts
+        self.lock.unlock()
+        return value
+    }
+}
+
+private final class AntigravityCLITestClock: @unchecked Sendable {
+    private let lock = NSLock()
+    private var date: Date
+
+    init(date: Date) {
+        self.date = date
+    }
+
+    func now() -> Date {
+        self.lock.lock()
+        let value = self.date
+        self.date = self.date.addingTimeInterval(1)
+        self.lock.unlock()
+        return value
+    }
+}
+
+private final class AntigravityCLIOutputSequence: @unchecked Sendable {
+    private let lock = NSLock()
+    private var values: [Data]
+
+    init(_ values: [Data]) {
+        self.values = values
+    }
+
+    func next() -> Data {
+        self.lock.lock()
+        let value = self.values.isEmpty ? Data() : self.values.removeFirst()
+        self.lock.unlock()
+        return value
+    }
+}
+
+struct AntigravityCLIHTTPSFetchStrategyTests {
+    @Test
+    func `local strategy falls back to cli HTTPS in cli source mode`() {
+        let strategy = AntigravityStatusFetchStrategy()
+        let context = self.makeFetchContext(sourceMode: .cli)
+
+        #expect(strategy.shouldFallback(on: AntigravityStatusProbeError.notRunning, context: context))
+    }
+
+    @Test
+    func `local strategy falls back to cli HTTPS in auto source mode`() {
+        let strategy = AntigravityStatusFetchStrategy()
+        let context = self.makeFetchContext(sourceMode: .auto)
+
+        #expect(strategy.shouldFallback(on: AntigravityStatusProbeError.notRunning, context: context))
+    }
+
+    @Test
+    func `local strategy does not fallback for unrelated source modes`() {
+        let strategy = AntigravityStatusFetchStrategy()
+
+        #expect(!strategy.shouldFallback(
+            on: AntigravityStatusProbeError.notRunning,
+            context: self.makeFetchContext(sourceMode: .oauth)))
+        #expect(!strategy.shouldFallback(
+            on: AntigravityStatusProbeError.notRunning,
+            context: self.makeFetchContext(sourceMode: .web)))
+        #expect(!strategy.shouldFallback(
+            on: AntigravityStatusProbeError.notRunning,
+            context: self.makeFetchContext(sourceMode: .api)))
+    }
+
+    @Test
+    func `strategy pipeline includes cli HTTPS fallback in cli and auto modes`() async {
+        let descriptor = ProviderDescriptorRegistry.descriptor(for: .antigravity)
+
+        let cliStrategies = await descriptor.fetchPlan.pipeline.resolveStrategies(
+            self.makeFetchContext(sourceMode: .cli))
+        #expect(cliStrategies.map(\.id) == [
+            "antigravity.app-local",
+            "antigravity.cli-https",
+            "antigravity.ide-local",
+        ])
+
+        let autoStrategies = await descriptor.fetchPlan.pipeline.resolveStrategies(
+            self.makeFetchContext(sourceMode: .auto))
+        #expect(autoStrategies.map(\.id) == [
+            "antigravity.app-local",
+            "antigravity.cli-https",
+            "antigravity.ide-local",
+        ])
+    }
+
+    @Test
+    func `strategy pipeline keeps source mode authoritative with selected token account`() async {
+        let descriptor = ProviderDescriptorRegistry.descriptor(for: .antigravity)
+
+        let accountID = UUID()
+        let autoStrategies = await descriptor.fetchPlan.pipeline.resolveStrategies(
+            self.makeFetchContext(sourceMode: .auto, selectedTokenAccountID: accountID))
+        let cliStrategies = await descriptor.fetchPlan.pipeline.resolveStrategies(
+            self.makeFetchContext(sourceMode: .cli, selectedTokenAccountID: accountID))
+        let oauthStrategies = await descriptor.fetchPlan.pipeline.resolveStrategies(
+            self.makeFetchContext(sourceMode: .oauth, selectedTokenAccountID: accountID))
+
+        #expect(autoStrategies.map(\.id) == [
+            "antigravity.app-local",
+            "antigravity.cli-https",
+            "antigravity.ide-local",
+            "antigravity.oauth",
+        ])
+        #expect(cliStrategies.map(\.id) == [
+            "antigravity.app-local",
+            "antigravity.cli-https",
+            "antigravity.ide-local",
+        ])
+        #expect(oauthStrategies.map(\.id) == ["antigravity.oauth"])
+    }
+
+    @Test
+    func `auto strategy pipeline includes oauth when credentials are injected`() async {
+        let descriptor = ProviderDescriptorRegistry.descriptor(for: .antigravity)
+
+        let autoStrategies = await descriptor.fetchPlan.pipeline.resolveStrategies(
+            self.makeFetchContext(
+                sourceMode: .auto,
+                env: self.accountEnv(email: "selected@example.com")))
+
+        #expect(autoStrategies.map(\.id) == [
+            "antigravity.app-local",
+            "antigravity.cli-https",
+            "antigravity.ide-local",
+            "antigravity.oauth",
+        ])
+    }
+
+    @Test
+    func `auto strategy pipeline preserves oauth fallback for shared credentials file`() async throws {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent("antigravity-shared-auto-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+        let store = AntigravityOAuthCredentialsStore(
+            fileURL: AntigravityOAuthCredentialsStore.defaultURL(home: root))
+        try store.save(AntigravityOAuthCredentials(
+            accessToken: "access",
+            refreshToken: "refresh",
+            expiryDate: Date().addingTimeInterval(3600),
+            email: "legacy@example.com"))
+
+        let descriptor = ProviderDescriptorRegistry.descriptor(for: .antigravity)
+        let autoStrategies = await descriptor.fetchPlan.pipeline.resolveStrategies(
+            self.makeFetchContext(sourceMode: .auto, env: ["HOME": root.path]))
+
+        #expect(autoStrategies.map(\.id) == [
+            "antigravity.app-local",
+            "antigravity.cli-https",
+            "antigravity.ide-local",
+            "antigravity.oauth",
+        ])
+    }
+
+    // MARK: - Selected-account guard
+
+    @Test
+    func `account guard ignores fetches without a selected account`() throws {
+        let usage = self.makeUsage(accountEmail: "ambient@example.com")
+        let context = self.makeFetchContext(
+            sourceMode: .auto,
+            env: self.accountEnv(email: "selected@example.com"))
+
+        try AntigravitySelectedAccountGuard.validate(usage, context: context)
+    }
+
+    @Test
+    func `account guard accepts matching ambient snapshot in auto mode`() throws {
+        let usage = self.makeUsage(accountEmail: "Selected@Example.com")
+        let context = self.makeFetchContext(
+            sourceMode: .auto,
+            selectedTokenAccountID: UUID(),
+            env: self.accountEnv(email: "selected@example.com"))
+
+        try AntigravitySelectedAccountGuard.validate(usage, context: context)
+    }
+
+    @Test
+    func `account guard rejects mismatched ambient snapshot in auto mode`() {
+        let usage = self.makeUsage(accountEmail: "ambient@example.com")
+        let context = self.makeFetchContext(
+            sourceMode: .auto,
+            selectedTokenAccountID: UUID(),
+            env: self.accountEnv(email: "selected@example.com"))
+
+        #expect(throws: AntigravityStatusProbeError.accountMismatch(
+            expected: "selected@example.com",
+            found: "ambient@example.com"))
+        {
+            try AntigravitySelectedAccountGuard.validate(usage, context: context)
+        }
+    }
+
+    @Test
+    func `account guard rejects snapshot without an identity email`() {
+        let usage = self.makeUsage(accountEmail: nil)
+        let context = self.makeFetchContext(
+            sourceMode: .auto,
+            selectedTokenAccountID: UUID(),
+            env: self.accountEnv(email: "selected@example.com"))
+
+        #expect(throws: AntigravityStatusProbeError.accountMismatch(
+            expected: "selected@example.com",
+            found: nil))
+        {
+            try AntigravitySelectedAccountGuard.validate(usage, context: context)
+        }
+    }
+
+    @Test
+    func `account guard rejects when selected account email cannot be resolved`() {
+        let usage = self.makeUsage(accountEmail: "ambient@example.com")
+        let context = self.makeFetchContext(
+            sourceMode: .auto,
+            selectedTokenAccountID: UUID())
+
+        #expect(throws: AntigravityStatusProbeError.accountMismatch(
+            expected: nil,
+            found: "ambient@example.com"))
+        {
+            try AntigravitySelectedAccountGuard.validate(usage, context: context)
+        }
+    }
+
+    @Test
+    func `account guard leaves explicit cli source mode authoritative`() throws {
+        let usage = self.makeUsage(accountEmail: "ambient@example.com")
+        let context = self.makeFetchContext(
+            sourceMode: .cli,
+            selectedTokenAccountID: UUID(),
+            env: self.accountEnv(email: "selected@example.com"))
+
+        try AntigravitySelectedAccountGuard.validate(usage, context: context)
+    }
+
+    @Test
+    func `selected account email resolves from id_token when email field missing`() {
+        let idToken = Self.makeIDToken(email: "jwt@example.com")
+        let context = self.makeFetchContext(
+            sourceMode: .auto,
+            selectedTokenAccountID: UUID(),
+            env: self.accountEnv(email: nil, idToken: idToken))
+
+        #expect(AntigravitySelectedAccountGuard.selectedAccountEmail(context: context) == "jwt@example.com")
+    }
+
+    @Test
+    func `selected account email prefers id_token over stored email field`() {
+        let idToken = Self.makeIDToken(email: "jwt@example.com")
+        let context = self.makeFetchContext(
+            sourceMode: .auto,
+            selectedTokenAccountID: UUID(),
+            env: self.accountEnv(email: "stored@example.com", idToken: idToken))
+
+        #expect(AntigravitySelectedAccountGuard.selectedAccountEmail(context: context) == "jwt@example.com")
+    }
+
+    @Test
+    func `cli HTTPS resets session only for one-shot CLI runtime`() {
+        // One-shot CLI invocation: reset after fetch.
+        #expect(AntigravityCLIHTTPSFetchStrategy.shouldResetSessionAfterFetch(self.makeFetchContext(runtime: .cli)))
+        // App runtime keeps the warm session.
+        #expect(!AntigravityCLIHTTPSFetchStrategy.shouldResetSessionAfterFetch(self.makeFetchContext(runtime: .app)))
+        // Long-lived CLI host (codexbar serve) keeps the warm session even at .cli runtime.
+        #expect(!AntigravityCLIHTTPSFetchStrategy.shouldResetSessionAfterFetch(
+            self.makeFetchContext(runtime: .cli, persistsCLISessions: true)))
+    }
+
+    @Test
+    func `cli HTTPS reports public source as cli`() {
+        #expect(AntigravityCLIHTTPSFetchStrategy.sourceLabel == "cli")
+    }
+
+    @Test
+    func `cli local strategy availability requires binary`() async throws {
+        let binaryURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-antigravity-\(UUID().uuidString)")
+        try Data("#!/bin/sh\n".utf8).write(to: binaryURL)
+        try FileManager.default.setAttributes(
+            [.posixPermissions: 0o755],
+            ofItemAtPath: binaryURL.path)
+        defer { try? FileManager.default.removeItem(at: binaryURL) }
+
+        let strategy = AntigravityCLIHTTPSFetchStrategy()
+        let context = self.makeFetchContext(env: ["ANTIGRAVITY_CLI_PATH": binaryURL.path])
+        let isAvailable = await strategy.isAvailable(context)
+
+        #expect(isAvailable)
+    }
+
+    @Test
+    func `cli local endpoints remain HTTPS only on macOS`() {
+        #expect(
+            AntigravityStatusProbe.cliEndpoints(ports: [55624]) == [
+                AntigravityStatusProbe.AntigravityConnectionEndpoint(
+                    scheme: "https",
+                    port: 55624,
+                    csrfToken: "",
+                    source: .cliHTTPS),
+            ])
+    }
+
+    @Test
+    func `cli HTTPS falls back to command model configs when quota summary and user status fail`() async throws {
+        let endpoints = [
+            AntigravityStatusProbe.AntigravityConnectionEndpoint(
+                scheme: "https",
+                port: 50080,
+                csrfToken: "",
+                source: .cliHTTPS),
+        ]
+        let attempts = AntigravityCLICounter()
+
+        let snapshot = try await AntigravityStatusProbe.fetchSnapshot(
+            context: AntigravityStatusProbe.RequestContext(
+                endpoints: endpoints,
+                timeout: 1,
+                deadline: Date().addingTimeInterval(2)),
+            send: { payload, _, _ in
+                let attempt = attempts.increment()
+                if attempt == 1 {
+                    #expect(payload.path == "/exa.language_server_pb.LanguageServerService/RetrieveUserQuotaSummary")
+                    throw AntigravityStatusProbeError.apiError("quota summary unavailable")
+                }
+                if attempt == 2 {
+                    #expect(payload.path == "/exa.language_server_pb.LanguageServerService/GetUserStatus")
+                    throw AntigravityStatusProbeError.apiError("user status unavailable")
+                }
+                #expect(payload.path == "/exa.language_server_pb.LanguageServerService/GetCommandModelConfigs")
+                return Data("""
+                {
+                  "clientModelConfigs": [
+                    {
+                      "label": "Claude Sonnet",
+                      "modelOrAlias": { "model": "claude-sonnet" },
+                      "quotaInfo": { "remainingFraction": 0.5 }
+                    }
+                  ]
+                }
+                """.utf8)
+            })
+
+        #expect(snapshot.modelQuotas.first?.label == "Claude Sonnet")
+        #expect(attempts.value == 3)
+    }
+
+    @Test
+    func `cli HTTPS waits for user status after ports appear`() async throws {
+        let fetchAttempts = AntigravityCLICounter()
+        let drainAttempts = AntigravityCLICounter()
+        let fetchedPorts = AntigravityCLIPortRecorder()
+        let snapshot = try await AntigravityCLIHTTPSFetchStrategy.waitForSnapshot(
+            pid: 123,
+            deadline: Date().addingTimeInterval(5),
+            dependencies: AntigravityCLIHTTPSFetchStrategy.SnapshotWaitDependencies(
+                pollIntervalNanoseconds: 0,
+                listeningPorts: { _, _ in [50080, 50081] },
+                drainOutput: {
+                    drainAttempts.increment()
+                    return Data()
+                },
+                fetchSnapshot: { ports in
+                    fetchedPorts.append(ports)
+                    if fetchAttempts.increment() == 1 {
+                        throw AntigravityStatusProbeError.apiError("HTTP 500: GetCascadeModelConfigData() is nil")
+                    }
+                    return AntigravityStatusSnapshot(
+                        modelQuotas: [
+                            AntigravityModelQuota(
+                                label: "Claude Opus 4.6 (Thinking)",
+                                modelId: "claude-opus-4.6-thinking",
+                                remainingFraction: 1,
+                                resetTime: nil,
+                                resetDescription: nil),
+                        ],
+                        accountEmail: "user@example.com",
+                        accountPlan: "Pro",
+                        source: .local)
+                }))
+
+        #expect(snapshot.accountEmail == "user@example.com")
+        #expect(fetchAttempts.value == 2)
+        #expect(fetchedPorts.snapshot() == [[50080, 50081], [50080, 50081]])
+        #expect(drainAttempts.value == 4)
+    }
+
+    @Test
+    func `cli HTTPS retries empty quota snapshots until usage is parseable`() async throws {
+        let fetchAttempts = AntigravityCLICounter()
+
+        let snapshot = try await AntigravityCLIHTTPSFetchStrategy.waitForSnapshot(
+            pid: 123,
+            deadline: Date().addingTimeInterval(5),
+            dependencies: AntigravityCLIHTTPSFetchStrategy.SnapshotWaitDependencies(
+                pollIntervalNanoseconds: 0,
+                listeningPorts: { _, _ in [50080] },
+                drainOutput: { Data() },
+                fetchSnapshot: { _ in
+                    if fetchAttempts.increment() == 1 {
+                        return AntigravityStatusSnapshot(
+                            modelQuotas: [],
+                            accountEmail: nil,
+                            accountPlan: nil,
+                            source: .local)
+                    }
+                    return AntigravityStatusSnapshot(
+                        modelQuotas: [
+                            AntigravityModelQuota(
+                                label: "Claude Sonnet",
+                                modelId: "claude-sonnet",
+                                remainingFraction: 0.5,
+                                resetTime: nil,
+                                resetDescription: nil),
+                        ],
+                        accountEmail: "user@example.com",
+                        accountPlan: "Pro",
+                        source: .local)
+                }))
+
+        #expect(fetchAttempts.value == 2)
+        #expect(snapshot.modelQuotas.first?.modelId == "claude-sonnet")
+    }
+
+    @Test
+    func `cli HTTPS drains output before ports appear`() async throws {
+        let portPolls = AntigravityCLICounter()
+        let drainAttempts = AntigravityCLICounter()
+        let snapshot = try await AntigravityCLIHTTPSFetchStrategy.waitForSnapshot(
+            pid: 123,
+            deadline: Date().addingTimeInterval(5),
+            dependencies: AntigravityCLIHTTPSFetchStrategy.SnapshotWaitDependencies(
+                pollIntervalNanoseconds: 0,
+                listeningPorts: { _, _ in
+                    portPolls.increment() == 1 ? [] : [50080]
+                },
+                drainOutput: {
+                    drainAttempts.increment()
+                    return Data()
+                },
+                fetchSnapshot: { _ in
+                    AntigravityStatusSnapshot(
+                        modelQuotas: [
+                            AntigravityModelQuota(
+                                label: "Claude Sonnet",
+                                modelId: "claude-sonnet",
+                                remainingFraction: 1,
+                                resetTime: nil,
+                                resetDescription: nil),
+                        ],
+                        accountEmail: "user@example.com",
+                        accountPlan: "Pro",
+                        source: .local)
+                }))
+
+        #expect(snapshot.accountEmail == "user@example.com")
+        #expect(portPolls.value == 2)
+        #expect(drainAttempts.value == 3)
+    }
+
+    @Test
+    func `cli HTTPS stops before probing when signed out prompt spans output chunks`() async {
+        let output = AntigravityCLIOutputSequence([
+            Data("Welcome. You are currently ".utf8),
+            Data("Welcome. You are currently not signed in.\nSelect login method:".utf8),
+        ])
+        let portPolls = AntigravityCLICounter()
+
+        do {
+            _ = try await AntigravityCLIHTTPSFetchStrategy.waitForSnapshot(
+                pid: 123,
+                deadline: Date().addingTimeInterval(2),
+                dependencies: AntigravityCLIHTTPSFetchStrategy.SnapshotWaitDependencies(
+                    pollIntervalNanoseconds: 0,
+                    listeningPorts: { _, _ in
+                        portPolls.increment()
+                        return []
+                    },
+                    drainOutput: {
+                        output.next()
+                    },
+                    fetchSnapshot: { _ in
+                        Issue.record("Signed-out helper should not fetch a snapshot")
+                        return AntigravityStatusSnapshot(
+                            modelQuotas: [],
+                            accountEmail: nil,
+                            accountPlan: nil,
+                            source: .local)
+                    }))
+            Issue.record("Expected authentication failure")
+        } catch AntigravityStatusProbeError.authenticationRequired {
+            #expect(portPolls.value == 1)
+        } catch {
+            Issue.record("Expected authenticationRequired, got \(error)")
+        }
+    }
+
+    @Test
+    func `cli HTTPS allows transient automatic sign in banner`() async throws {
+        let output = AntigravityCLIOutputSequence([
+            Data("Welcome. You are currently not signed in.\nSigning in...".utf8),
+            Data("user@example.com\nGemini 3.1 Pro (High)".utf8),
+        ])
+
+        let snapshot = try await AntigravityCLIHTTPSFetchStrategy.waitForSnapshot(
+            pid: 123,
+            deadline: Date().addingTimeInterval(2),
+            dependencies: AntigravityCLIHTTPSFetchStrategy.SnapshotWaitDependencies(
+                pollIntervalNanoseconds: 0,
+                listeningPorts: { _, _ in [50080] },
+                drainOutput: {
+                    output.next()
+                },
+                fetchSnapshot: { _ in
+                    AntigravityStatusSnapshot(
+                        modelQuotas: [
+                            AntigravityModelQuota(
+                                label: "Claude Sonnet",
+                                modelId: "claude-sonnet",
+                                remainingFraction: 1,
+                                resetTime: nil,
+                                resetDescription: nil),
+                        ],
+                        accountEmail: "user@example.com",
+                        accountPlan: "Pro",
+                        source: .local)
+                }))
+
+        #expect(snapshot.accountEmail == "user@example.com")
+    }
+
+    @Test
+    func `cli HTTPS rechecks signed out prompt after snapshot readiness`() async {
+        let output = AntigravityCLIOutputSequence([
+            Data(),
+            Data("You are currently not signed in.\nSelect login method:".utf8),
+        ])
+
+        do {
+            _ = try await AntigravityCLIHTTPSFetchStrategy.waitForSnapshot(
+                pid: 123,
+                deadline: Date().addingTimeInterval(2),
+                dependencies: AntigravityCLIHTTPSFetchStrategy.SnapshotWaitDependencies(
+                    pollIntervalNanoseconds: 0,
+                    listeningPorts: { _, _ in [50080] },
+                    drainOutput: {
+                        output.next()
+                    },
+                    fetchSnapshot: { _ in
+                        AntigravityStatusSnapshot(
+                            modelQuotas: [
+                                AntigravityModelQuota(
+                                    label: "Claude Sonnet",
+                                    modelId: "claude-sonnet",
+                                    remainingFraction: 1,
+                                    resetTime: nil,
+                                    resetDescription: nil),
+                            ],
+                            accountEmail: "user@example.com",
+                            accountPlan: "Pro",
+                            source: .local)
+                    }))
+            Issue.record("Expected authentication failure")
+        } catch AntigravityStatusProbeError.authenticationRequired {
+            // Expected: the late prompt wins over the apparently ready API.
+        } catch {
+            Issue.record("Expected authenticationRequired, got \(error)")
+        }
+    }
+
+    @Test
+    func `cli HTTPS treats empty lsof exit as ports not ready`() async throws {
+        let portPolls = AntigravityCLICounter()
+        let snapshot = try await AntigravityCLIHTTPSFetchStrategy.waitForSnapshot(
+            pid: 123,
+            deadline: Date().addingTimeInterval(5),
+            dependencies: AntigravityCLIHTTPSFetchStrategy.SnapshotWaitDependencies(
+                pollIntervalNanoseconds: 0,
+                listeningPorts: { _, _ in
+                    if portPolls.increment() == 1 {
+                        throw SubprocessRunnerError.nonZeroExit(code: 1, stderr: "")
+                    }
+                    return [50080]
+                },
+                drainOutput: { Data() },
+                fetchSnapshot: { _ in
+                    AntigravityStatusSnapshot(
+                        modelQuotas: [
+                            AntigravityModelQuota(
+                                label: "Claude Sonnet",
+                                modelId: "claude-sonnet",
+                                remainingFraction: 0.5,
+                                resetTime: nil,
+                                resetDescription: nil),
+                        ],
+                        accountEmail: "user@example.com",
+                        accountPlan: "Pro",
+                        source: .local)
+                }))
+
+        #expect(snapshot.accountEmail == "user@example.com")
+        #expect(portPolls.value == 2)
+    }
+
+    @Test
+    func `parsed requests recompute timeout from shared deadline between endpoints`() async throws {
+        let timeoutRecorder = AntigravityCLITimeoutRecorder()
+        let attempts = AntigravityCLICounter()
+        let endpoints = [
+            AntigravityStatusProbe.AntigravityConnectionEndpoint(
+                scheme: "https",
+                port: 50080,
+                csrfToken: "",
+                source: .cliHTTPS),
+            AntigravityStatusProbe.AntigravityConnectionEndpoint(
+                scheme: "https",
+                port: 50081,
+                csrfToken: "",
+                source: .cliHTTPS),
+        ]
+
+        let result = try await AntigravityStatusProbe.makeParsedRequest(
+            payload: AntigravityStatusProbe.RequestPayload(path: "/status", body: [:]),
+            context: AntigravityStatusProbe.RequestContext(
+                endpoints: endpoints,
+                timeout: 10,
+                deadline: Date().addingTimeInterval(10)),
+            send: { _, _, timeout in
+                timeoutRecorder.append(timeout)
+                if attempts.increment() == 1 {
+                    antigravityBlockingSleep(0.1)
+                    throw AntigravityStatusProbeError.apiError("first endpoint failed")
+                }
+                return Data("ok".utf8)
+            },
+            parse: { data in
+                guard let value = String(bytes: data, encoding: .utf8) else {
+                    throw AntigravityStatusProbeError.apiError("invalid test data")
+                }
+                return value
+            })
+
+        let timeouts = timeoutRecorder.snapshot()
+        #expect(result == "ok")
+        #expect(timeouts.count == 2)
+        #expect(timeouts.allSatisfy { $0 < 10 })
+        #expect((timeouts.last ?? 10) < (timeouts.first ?? 0))
+    }
+
+    @Test
+    func `parsed request reports timeout when shared deadline is already expired`() async {
+        do {
+            _ = try await AntigravityStatusProbe.makeParsedRequest(
+                payload: AntigravityStatusProbe.RequestPayload(path: "/status", body: [:]),
+                context: AntigravityStatusProbe.RequestContext(
+                    endpoints: [
+                        AntigravityStatusProbe.AntigravityConnectionEndpoint(
+                            scheme: "https",
+                            port: 50080,
+                            csrfToken: "",
+                            source: .cliHTTPS),
+                    ],
+                    timeout: 10,
+                    deadline: Date().addingTimeInterval(-1)),
+                send: { _, _, _ in
+                    Issue.record("Expired deadline should not send a request")
+                    return Data()
+                },
+                parse: { _ in "ok" })
+            Issue.record("Expected timeout")
+        } catch AntigravityStatusProbeError.timedOut {
+        } catch {
+            Issue.record("Expected timedOut, got \(error)")
+        }
+    }
+
+    @Test
+    func `cli HTTPS reports last readiness error when ports never become usable`() async {
+        let fetchAttempts = AntigravityCLICounter()
+        let start = Date(timeIntervalSinceReferenceDate: 0)
+        let clock = AntigravityCLITestClock(date: start)
+
+        do {
+            _ = try await AntigravityCLIHTTPSFetchStrategy.waitForSnapshot(
+                pid: 123,
+                deadline: start.addingTimeInterval(5),
+                dependencies: AntigravityCLIHTTPSFetchStrategy.SnapshotWaitDependencies(
+                    pollIntervalNanoseconds: 0,
+                    listeningPorts: { _, _ in [50080] },
+                    drainOutput: { Data() },
+                    fetchSnapshot: { _ in
+                        let attempt = fetchAttempts.increment()
+                        throw AntigravityStatusProbeError.apiError("HTTP 500: warming attempt \(attempt)")
+                    },
+                    now: { clock.now() }))
+            Issue.record("Expected readiness polling to throw")
+        } catch let AntigravityStatusProbeError.apiError(message) {
+            #expect(fetchAttempts.value == 2)
+            #expect(message == "HTTP 500: warming attempt 2")
+        } catch {
+            Issue.record("Expected apiError, got \(error)")
+        }
+    }
+
+    @Test
+    func `cli HTTPS preserves non transient port detection errors`() async {
+        do {
+            _ = try await AntigravityCLIHTTPSFetchStrategy.waitForSnapshot(
+                pid: 123,
+                deadline: Date().addingTimeInterval(2),
+                dependencies: AntigravityCLIHTTPSFetchStrategy.SnapshotWaitDependencies(
+                    pollIntervalNanoseconds: 0,
+                    listeningPorts: { _, _ in
+                        throw AntigravityStatusProbeError.portDetectionFailed("lsof not available")
+                    },
+                    drainOutput: { Data() },
+                    fetchSnapshot: { _ in
+                        Issue.record("Port detection failure should not fetch a snapshot")
+                        return AntigravityStatusSnapshot(
+                            modelQuotas: [],
+                            accountEmail: nil,
+                            accountPlan: nil,
+                            source: .local)
+                    }))
+            Issue.record("Expected port detection failure")
+        } catch let AntigravityStatusProbeError.portDetectionFailed(message) {
+            #expect(message == "lsof not available")
+        } catch {
+            Issue.record("Expected portDetectionFailed, got \(error)")
+        }
+    }
+
+    @Test
+    func `cli HTTPS endpoint does not require CSRF token`() {
+        let endpoint = AntigravityStatusProbe.AntigravityConnectionEndpoint(
+            scheme: "https",
+            port: 55624,
+            csrfToken: "ignored-by-cli",
+            source: .cliHTTPS)
+        #expect(!endpoint.requiresCSRFToken)
+    }
+
+    @Test
+    func `languageServer endpoint requires CSRF token`() {
+        let endpoint = AntigravityStatusProbe.AntigravityConnectionEndpoint(
+            scheme: "https",
+            port: 64440,
+            csrfToken: "",
+            source: .languageServer)
+        #expect(endpoint.requiresCSRFToken)
+    }
+
+    @Test
+    func `extensionServer endpoint requires CSRF token`() {
+        let endpoint = AntigravityStatusProbe.AntigravityConnectionEndpoint(
+            scheme: "http",
+            port: 64432,
+            csrfToken: "",
+            source: .extensionServer)
+        #expect(endpoint.requiresCSRFToken)
+    }
+
+    private func makeFetchContext(
+        runtime: ProviderRuntime = .app,
+        sourceMode: ProviderSourceMode = .auto,
+        selectedTokenAccountID: UUID? = nil,
+        persistsCLISessions: Bool = false,
+        env: [String: String] = [:]) -> ProviderFetchContext
+    {
+        var effectiveEnv = env
+        effectiveEnv["HOME"] = effectiveEnv["HOME"] ??
+            FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-antigravity-empty-home-\(UUID().uuidString)", isDirectory: true)
+            .path
+        return ProviderFetchContext(
+            runtime: runtime,
+            sourceMode: sourceMode,
+            includeCredits: false,
+            webTimeout: 1,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: effectiveEnv,
+            settings: nil,
+            fetcher: UsageFetcher(environment: effectiveEnv),
+            claudeFetcher: StubClaudeFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            selectedTokenAccountID: selectedTokenAccountID,
+            persistsCLISessions: persistsCLISessions)
+    }
+
+    private func makeUsage(accountEmail: String?) -> UsageSnapshot {
+        UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .antigravity,
+                accountEmail: accountEmail,
+                accountOrganization: nil,
+                loginMethod: nil))
+    }
+
+    private func accountEnv(email: String?, idToken: String? = nil) -> [String: String] {
+        let credentials = AntigravityOAuthCredentials(
+            accessToken: "access",
+            refreshToken: "refresh",
+            expiryDate: Date().addingTimeInterval(3600),
+            idToken: idToken,
+            email: email)
+        guard let value = try? AntigravityOAuthCredentialsStore.tokenAccountValue(for: credentials) else {
+            return [:]
+        }
+        return [AntigravityOAuthCredentialsStore.environmentCredentialsKey: value]
+    }
+
+    private static func makeIDToken(email: String) -> String {
+        let payload = Data("{\"email\":\"\(email)\"}".utf8)
+        let encodedPayload = payload.base64EncodedString()
+            .replacingOccurrences(of: "+", with: "-")
+            .replacingOccurrences(of: "/", with: "_")
+            .replacingOccurrences(of: "=", with: "")
+        return "header.\(encodedPayload).signature"
+    }
+
+    private struct StubClaudeFetcher: ClaudeUsageFetching {
+        func loadLatestUsage(model _: String) async throws -> ClaudeUsageSnapshot {
+            throw ClaudeUsageError.parseFailed("stub")
+        }
+
+        func debugRawProbe(model _: String) async -> String {
+            "stub"
+        }
+
+        func detectVersion() -> String? {
+            nil
+        }
+    }
+}
diff --git a/Tests/CodexBarTests/AntigravityCLISessionTests.swift b/Tests/CodexBarTests/AntigravityCLISessionTests.swift
new file mode 100644
index 0000000000..b41c19b73b
--- /dev/null
+++ b/Tests/CodexBarTests/AntigravityCLISessionTests.swift
@@ -0,0 +1,1536 @@
+#if canImport(Darwin)
+import Darwin
+#else
+import Glibc
+#endif
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+private final class FakeAntigravityProcessHandle: AntigravityCLIProcessHandle, @unchecked Sendable {
+    private let lock = NSLock()
+    let pid: pid_t
+    var descendants: [pid_t]
+    private var running: Bool
+    private let terminateRootStopsProcess: Bool
+    private var assignedProcessGroup: pid_t?
+    private var events: [String] = []
+    private var drainOutputChunks: [Data] = []
+
+    init(pid: pid_t, running: Bool = true, descendants: [pid_t] = [], terminateRootStopsProcess: Bool = true) {
+        self.pid = pid
+        self.running = running
+        self.descendants = descendants
+        self.terminateRootStopsProcess = terminateRootStopsProcess
+    }
+
+    var isRunning: Bool {
+        self.lock.lock()
+        let value = self.running
+        self.events.append("isRunning:\(value)")
+        self.lock.unlock()
+        return value
+    }
+
+    var processGroup: pid_t? {
+        self.lock.lock()
+        let value = self.assignedProcessGroup
+        self.lock.unlock()
+        return value
+    }
+
+    func assignProcessGroup() -> pid_t? {
+        self.lock.lock()
+        self.assignedProcessGroup = self.pid
+        self.events.append("assignProcessGroup")
+        self.lock.unlock()
+        return self.pid
+    }
+
+    func sendExit() throws {
+        self.append("sendExit")
+    }
+
+    func closePTY() {
+        self.append("closePTY")
+    }
+
+    func terminateRoot() {
+        self.lock.lock()
+        if self.terminateRootStopsProcess {
+            self.running = false
+        }
+        self.events.append("terminateRoot")
+        self.lock.unlock()
+    }
+
+    func killRoot() {
+        self.lock.lock()
+        self.running = false
+        self.events.append("killRoot")
+        self.lock.unlock()
+    }
+
+    func descendantPIDs() -> [pid_t] {
+        self.lock.lock()
+        let value = self.descendants
+        self.events.append("descendantPIDs")
+        self.lock.unlock()
+        return value
+    }
+
+    func terminateTree(signal: Int32, knownDescendants _: [pid_t]) {
+        self.lock.lock()
+        if signal == SIGKILL {
+            self.running = false
+        }
+        self.events.append("terminateTree:\(signal)")
+        self.lock.unlock()
+    }
+
+    func killDescendants(_ descendants: [pid_t]) {
+        self.append("killDescendants:\(descendants.map(String.init).joined(separator: ","))")
+    }
+
+    func drainOutput() -> Data {
+        self.lock.lock()
+        self.events.append("drainOutput")
+        let output = self.drainOutputChunks.isEmpty ? Data() : self.drainOutputChunks.removeFirst()
+        self.lock.unlock()
+        return output
+    }
+
+    func enqueueDrainOutput(_ output: Data) {
+        self.lock.lock()
+        self.drainOutputChunks.append(output)
+        self.lock.unlock()
+    }
+
+    func snapshotEvents() -> [String] {
+        self.lock.lock()
+        let value = self.events
+        self.lock.unlock()
+        return value
+    }
+
+    private func append(_ event: String) {
+        self.lock.lock()
+        self.events.append(event)
+        self.lock.unlock()
+    }
+}
+
+private final class FakeAntigravityProcessLauncher: AntigravityCLIProcessLaunching, @unchecked Sendable {
+    private let lock = NSLock()
+    private var nextPID: pid_t
+    private var launchError: Error?
+    private var launchedBinaries: [String] = []
+    private var terminateRootStopsProcess = true
+    private var handles: [FakeAntigravityProcessHandle] = []
+
+    init(nextPID: pid_t = 1) {
+        self.nextPID = nextPID
+    }
+
+    func launch(binary: String) throws -> any AntigravityCLIProcessHandle {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        if let launchError {
+            throw launchError
+        }
+        let handle = FakeAntigravityProcessHandle(
+            pid: self.nextPID,
+            descendants: [self.nextPID + 100],
+            terminateRootStopsProcess: self.terminateRootStopsProcess)
+        self.nextPID += 1
+        self.launchedBinaries.append(binary)
+        self.handles.append(handle)
+        return handle
+    }
+
+    func setLaunchError(_ error: Error?) {
+        self.lock.lock()
+        self.launchError = error
+        self.lock.unlock()
+    }
+
+    func setTerminateRootStopsProcess(_ value: Bool) {
+        self.lock.lock()
+        self.terminateRootStopsProcess = value
+        self.lock.unlock()
+    }
+
+    func launchedBinarySnapshot() -> [String] {
+        self.lock.lock()
+        let value = self.launchedBinaries
+        self.lock.unlock()
+        return value
+    }
+
+    func handleSnapshot() -> [FakeAntigravityProcessHandle] {
+        self.lock.lock()
+        let value = self.handles
+        self.lock.unlock()
+        return value
+    }
+}
+
+private final class FakeAntigravityIdentityProvider: AntigravityCLIProcessIdentityProviding, @unchecked Sendable {
+    private let lock = NSLock()
+    private var identities: [pid_t: AntigravityCLIProcessIdentity] = [:]
+
+    func setIdentity(pid: pid_t, executablePath: String, startEpoch: TimeInterval) {
+        self.lock.lock()
+        self.identities[pid] = AntigravityCLIProcessIdentity(executablePath: executablePath, startEpoch: startEpoch)
+        self.lock.unlock()
+    }
+
+    func removeIdentity(pid: pid_t) {
+        self.lock.lock()
+        self.identities[pid] = nil
+        self.lock.unlock()
+    }
+
+    func identity(for pid: pid_t) -> AntigravityCLIProcessIdentity? {
+        self.lock.lock()
+        let value = self.identities[pid]
+        self.lock.unlock()
+        return value
+    }
+}
+
+private final class MemoryAntigravitySessionRecordStore: AntigravityCLISessionRecordStoring, @unchecked Sendable {
+    private let lock = NSLock()
+    private var records: [AntigravityCLISessionRecord]
+    private let failSaves: Bool
+    private var saves = 0
+    private var removes = 0
+
+    init(record: AntigravityCLISessionRecord? = nil, failSaves: Bool = false) {
+        self.records = record.map { [$0] } ?? []
+        self.failSaves = failSaves
+    }
+
+    func load() throws -> [AntigravityCLISessionRecord] {
+        self.lock.lock()
+        let value = self.records
+        self.lock.unlock()
+        return value
+    }
+
+    func save(_ record: AntigravityCLISessionRecord) throws {
+        self.lock.lock()
+        guard !self.failSaves else {
+            self.lock.unlock()
+            throw CocoaError(.fileWriteNoPermission)
+        }
+        self.records.removeAll { existing in
+            if let existingOwnerPID = existing.ownerPID,
+               let recordOwnerPID = record.ownerPID,
+               let existingOwnerPath = existing.ownerExecutablePath,
+               let recordOwnerPath = record.ownerExecutablePath,
+               let existingOwnerStart = existing.ownerStartEpoch,
+               let recordOwnerStart = record.ownerStartEpoch
+            {
+                return existingOwnerPID == recordOwnerPID &&
+                    existingOwnerPath == recordOwnerPath &&
+                    abs(existingOwnerStart - recordOwnerStart) < 0.001
+            }
+            return existing.pid == record.pid &&
+                existing.executablePath == record.executablePath &&
+                abs(existing.startEpoch - record.startEpoch) < 0.001
+        }
+        self.records.append(record)
+        self.saves += 1
+        self.lock.unlock()
+    }
+
+    func remove(_ record: AntigravityCLISessionRecord) throws {
+        self.lock.lock()
+        self.records.removeAll {
+            $0.pid == record.pid &&
+                $0.executablePath == record.executablePath &&
+                abs($0.startEpoch - record.startEpoch) < 0.001
+        }
+        self.removes += 1
+        self.lock.unlock()
+    }
+
+    func snapshot() -> AntigravityCLISessionRecord? {
+        self.lock.lock()
+        let value = self.records.first
+        self.lock.unlock()
+        return value
+    }
+
+    func snapshots() -> [AntigravityCLISessionRecord] {
+        self.lock.lock()
+        let value = self.records
+        self.lock.unlock()
+        return value
+    }
+
+    var saveCount: Int {
+        self.lock.lock()
+        let value = self.saves
+        self.lock.unlock()
+        return value
+    }
+
+    var removeCount: Int {
+        self.lock.lock()
+        let value = self.removes
+        self.lock.unlock()
+        return value
+    }
+}
+
+private final class MemoryAntigravitySessionLaunchLock: AntigravityCLISessionLaunchLocking, @unchecked Sendable {
+    private let lock = NSLock()
+
+    func withLock<T>(_ operation: () throws -> T) throws -> T {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        return try operation()
+    }
+}
+
+private struct FailingAntigravitySessionLaunchLock: AntigravityCLISessionLaunchLocking {
+    func withLock<T>(_: () throws -> T) throws -> T {
+        throw CocoaError(.fileWriteNoPermission)
+    }
+}
+
+private final class AntigravitySessionTerminationRecorder: @unchecked Sendable {
+    private let lock = NSLock()
+    private var events: [(pid: pid_t, group: pid_t?, signal: Int32, descendants: [pid_t])] = []
+
+    func append(pid: pid_t, group: pid_t?, signal: Int32, descendants: [pid_t]) {
+        self.lock.lock()
+        self.events.append((pid: pid, group: group, signal: signal, descendants: descendants))
+        self.lock.unlock()
+    }
+
+    func snapshot() -> [(pid: pid_t, group: pid_t?, signal: Int32, descendants: [pid_t])] {
+        self.lock.lock()
+        let value = self.events
+        self.lock.unlock()
+        return value
+    }
+}
+
+private final class AntigravityRegistryRecorder: @unchecked Sendable {
+    private let lock = NSLock()
+    private var shouldRegister = true
+    private var registered: [pid_t] = []
+    private var unregistered: [pid_t] = []
+    private var groups: [pid_t: pid_t?] = [:]
+
+    func setShouldRegister(_ value: Bool) {
+        self.lock.lock()
+        self.shouldRegister = value
+        self.lock.unlock()
+    }
+
+    func register(pid: pid_t, _: String) -> Bool {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        guard self.shouldRegister else { return false }
+        self.registered.append(pid)
+        return true
+    }
+
+    func update(pid: pid_t, group: pid_t?) {
+        self.lock.lock()
+        self.groups[pid] = group
+        self.lock.unlock()
+    }
+
+    func unregister(pid: pid_t) {
+        self.lock.lock()
+        self.unregistered.append(pid)
+        self.lock.unlock()
+    }
+
+    func registeredSnapshot() -> [pid_t] {
+        self.lock.lock()
+        let value = self.registered
+        self.lock.unlock()
+        return value
+    }
+
+    func unregisteredSnapshot() -> [pid_t] {
+        self.lock.lock()
+        let value = self.unregistered
+        self.lock.unlock()
+        return value
+    }
+}
+
+private final class AntigravityLaunchReservationRecorder: @unchecked Sendable {
+    private let lock = NSLock()
+    private var beginCount = 0
+    private var endCount = 0
+
+    func begin() -> Bool {
+        self.lock.lock()
+        self.beginCount += 1
+        self.lock.unlock()
+        return true
+    }
+
+    func end() {
+        self.lock.lock()
+        self.endCount += 1
+        self.lock.unlock()
+    }
+
+    func counts() -> (begin: Int, end: Int) {
+        self.lock.lock()
+        let counts = (begin: self.beginCount, end: self.endCount)
+        self.lock.unlock()
+        return counts
+    }
+}
+
+private final class AntigravityManualSleeper: @unchecked Sendable {
+    private let lock = NSLock()
+    private var continuations: [CheckedContinuation<Void, Error>] = []
+
+    func sleep(_: UInt64) async throws {
+        try await withCheckedThrowingContinuation { continuation in
+            self.lock.lock()
+            self.continuations.append(continuation)
+            self.lock.unlock()
+        }
+    }
+
+    func resumeAll() {
+        self.lock.lock()
+        let continuations = self.continuations
+        self.continuations.removeAll()
+        self.lock.unlock()
+
+        for continuation in continuations {
+            continuation.resume()
+        }
+    }
+
+    func waitForSleeps(_ expectedCount: Int) async {
+        for _ in 0..<200 {
+            if self.pendingSleepCount >= expectedCount { return }
+            try? await Task.sleep(nanoseconds: 1_000_000)
+        }
+        Issue.record("Timed out waiting for \(expectedCount) sleep continuation(s)")
+    }
+
+    private var pendingSleepCount: Int {
+        self.lock.lock()
+        let count = self.continuations.count
+        self.lock.unlock()
+        return count
+    }
+}
+
+struct AntigravityCLISessionTests {
+    @Test
+    func `reuses alive process for same binary`() async throws {
+        let fixture = self.makeFixture()
+        fixture.identity.setIdentity(pid: 10, executablePath: "/bin/agy", startEpoch: 100)
+
+        let firstPID = try await fixture.session.beginProbe(binary: "/bin/agy")
+        await fixture.session.finishProbe(success: true, resetAfterFetch: false)
+        let secondPID = try await fixture.session.beginProbe(binary: "/bin/agy")
+        await fixture.session.finishProbe(success: true, resetAfterFetch: false)
+
+        #expect(firstPID == 10)
+        #expect(secondPID == 10)
+        #expect(fixture.launcher.launchedBinarySnapshot() == ["/bin/agy"])
+        #expect(fixture.launchReservations.counts().begin == 1)
+        #expect(fixture.launchReservations.counts().end == 1)
+    }
+
+    @Test
+    func `relaunches when binary changes`() async throws {
+        let fixture = self.makeFixture()
+        fixture.identity.setIdentity(pid: 10, executablePath: "/bin/agy", startEpoch: 100)
+        fixture.identity.setIdentity(pid: 11, executablePath: "/new/agy", startEpoch: 101)
+
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+        await fixture.session.finishProbe(success: true, resetAfterFetch: false)
+        let secondPID = try await fixture.session.beginProbe(binary: "/new/agy")
+        await fixture.session.finishProbe(success: true, resetAfterFetch: false)
+
+        #expect(secondPID == 11)
+        #expect(fixture.launcher.launchedBinarySnapshot() == ["/bin/agy", "/new/agy"])
+        #expect(fixture.registry.unregisteredSnapshot() == [10])
+    }
+
+    @Test
+    func `replacement launch waits for in progress teardown`() async throws {
+        let fixture = self.makeFixture(
+            manualSleep: true,
+            terminationGracePeriod: 1,
+            terminateRootStopsProcess: false)
+        fixture.identity.setIdentity(pid: 10, executablePath: "/old/agy", startEpoch: 100)
+        fixture.identity.setIdentity(pid: 11, executablePath: "/new/agy", startEpoch: 101)
+
+        _ = try await fixture.session.beginProbe(binary: "/old/agy")
+        await fixture.session.finishProbe(success: true, resetAfterFetch: false)
+
+        let firstReplacement = Task {
+            try await fixture.session.beginProbe(binary: "/new/agy")
+        }
+        await fixture.sleeper?.waitForSleeps(1)
+
+        let secondReplacement = Task {
+            try await fixture.session.beginProbe(binary: "/new/agy")
+        }
+        await Task.yield()
+        #expect(fixture.launcher.launchedBinarySnapshot() == ["/old/agy"])
+
+        fixture.launcher.handleSnapshot().first?.killRoot()
+        fixture.sleeper?.resumeAll()
+        let firstPID = try await firstReplacement.value
+        let secondPID = try await secondReplacement.value
+        await fixture.session.finishProbe(success: true, resetAfterFetch: false)
+        await fixture.session.finishProbe(success: true, resetAfterFetch: false)
+
+        #expect(firstPID == 11)
+        #expect(secondPID == 11)
+        #expect(fixture.launcher.launchedBinarySnapshot() == ["/old/agy", "/new/agy"])
+    }
+
+    @Test
+    func `replacement waits for active probe before relaunching`() async throws {
+        let fixture = self.makeFixture()
+        fixture.identity.setIdentity(pid: 10, executablePath: "/old/agy", startEpoch: 100)
+        fixture.identity.setIdentity(pid: 11, executablePath: "/new/agy", startEpoch: 101)
+
+        let firstPID = try await fixture.session.beginProbe(binary: "/old/agy")
+        let replacement = Task {
+            try await fixture.session.beginProbe(binary: "/new/agy")
+        }
+        await Task.yield()
+        await Task.yield()
+
+        #expect(firstPID == 10)
+        #expect(fixture.launcher.launchedBinarySnapshot() == ["/old/agy"])
+        #expect(fixture.registry.unregisteredSnapshot().isEmpty)
+
+        await fixture.session.finishProbe(success: true, resetAfterFetch: false)
+        let secondPID = try await replacement.value
+        await fixture.session.finishProbe(success: true, resetAfterFetch: false)
+
+        #expect(secondPID == 11)
+        #expect(fixture.launcher.launchedBinarySnapshot() == ["/old/agy", "/new/agy"])
+        #expect(fixture.registry.unregisteredSnapshot() == [10])
+    }
+
+    @Test
+    func `queued replacement hard stops a signed out process`() async throws {
+        let fixture = self.makeFixture()
+        fixture.identity.setIdentity(pid: 10, executablePath: "/old/agy", startEpoch: 100)
+        fixture.identity.setIdentity(pid: 11, executablePath: "/new/agy", startEpoch: 101)
+
+        _ = try await fixture.session.beginProbe(binary: "/old/agy")
+        let replacement = Task {
+            try await fixture.session.beginProbe(binary: "/new/agy")
+        }
+        for _ in 0..<100 where await fixture.session.activeProbeCountForTesting < 2 {
+            await Task.yield()
+        }
+        #expect(await fixture.session.activeProbeCountForTesting == 2)
+
+        await fixture.session.finishProbe(success: false, resetAfterFetch: true, forceTerminate: true)
+        let replacementPID = try await replacement.value
+        let oldEvents = try #require(fixture.launcher.handleSnapshot().first).snapshotEvents()
+        #expect(await fixture.session.lastStopReasonForTesting == "authentication required")
+        await fixture.session.finishProbe(success: true, resetAfterFetch: true)
+
+        #expect(replacementPID == 11)
+        #expect(!oldEvents.contains("sendExit"))
+        #expect(oldEvents.contains("terminateRoot"))
+    }
+
+    @Test
+    func `replacement ignores queued starters while waiting for active probe`() async throws {
+        let fixture = self.makeFixture()
+        fixture.identity.setIdentity(pid: 10, executablePath: "/old/agy", startEpoch: 100)
+        fixture.identity.setIdentity(pid: 11, executablePath: "/new/agy", startEpoch: 101)
+
+        _ = try await fixture.session.beginProbe(binary: "/old/agy")
+        let firstReplacement = Task {
+            try await fixture.session.beginProbe(binary: "/new/agy")
+        }
+        let secondReplacement = Task {
+            try await fixture.session.beginProbe(binary: "/new/agy")
+        }
+        await Task.yield()
+        await Task.yield()
+
+        #expect(fixture.launcher.launchedBinarySnapshot() == ["/old/agy"])
+
+        await fixture.session.finishProbe(success: true, resetAfterFetch: false)
+        let didLaunchReplacement = await self.waitForLaunches(fixture.launcher, count: 2)
+        #expect(didLaunchReplacement)
+        if !didLaunchReplacement {
+            await fixture.session.finishProbe(success: true, resetAfterFetch: false)
+        }
+
+        let firstPID = try await firstReplacement.value
+        let secondPID = try await secondReplacement.value
+        await fixture.session.finishProbe(success: true, resetAfterFetch: false)
+        await fixture.session.finishProbe(success: true, resetAfterFetch: false)
+
+        #expect(firstPID == 11)
+        #expect(secondPID == 11)
+        #expect(fixture.launcher.launchedBinarySnapshot() == ["/old/agy", "/new/agy"])
+    }
+
+    @Test
+    func `relaunches when existing process is dead`() async throws {
+        let fixture = self.makeFixture()
+        fixture.identity.setIdentity(pid: 10, executablePath: "/bin/agy", startEpoch: 100)
+        fixture.identity.setIdentity(pid: 11, executablePath: "/bin/agy", startEpoch: 101)
+
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+        await fixture.session.finishProbe(success: true, resetAfterFetch: false)
+        fixture.launcher.handleSnapshot().first?.terminateRoot()
+        let secondPID = try await fixture.session.beginProbe(binary: "/bin/agy")
+        await fixture.session.finishProbe(success: true, resetAfterFetch: false)
+
+        #expect(secondPID == 11)
+        #expect(fixture.launcher.launchedBinarySnapshot() == ["/bin/agy", "/bin/agy"])
+    }
+
+    @Test
+    func `pty launcher creates dedicated process group before returning`() throws {
+        let launcher = AntigravityPTYProcessLauncher()
+        let handle = try launcher.launch(binary: "/bin/cat")
+        defer {
+            handle.killRoot()
+            handle.terminateTree(signal: SIGKILL, knownDescendants: [])
+            handle.closePTY()
+        }
+
+        #expect(handle.processGroup == handle.pid)
+        #expect(getpgid(handle.pid) == handle.pid)
+    }
+
+    @Test
+    func `pty launcher resets termination signals for child process`() {
+        var signals = AntigravityPTYProcessLauncher.defaultSignalsForSpawn()
+
+        #expect(sigismember(&signals, SIGINT) == 1)
+        #expect(sigismember(&signals, SIGTERM) == 1)
+        #expect(sigismember(&signals, SIGHUP) == 1)
+    }
+
+    @Test
+    func `pty launcher retries transient text busy spawn errors`() {
+        var attempts = 0
+
+        let result = AntigravityPTYProcessLauncher.spawnWithTextBusyRetry(retryDelay: 0) {
+            attempts += 1
+            return attempts < 3 ? ETXTBSY : 0
+        }
+
+        #expect(result == 0)
+        #expect(attempts == 3)
+    }
+
+    @Test
+    func `pty launcher does not retry other spawn errors`() {
+        var attempts = 0
+
+        let result = AntigravityPTYProcessLauncher.spawnWithTextBusyRetry(retryDelay: 0) {
+            attempts += 1
+            return EACCES
+        }
+
+        #expect(result == EACCES)
+        #expect(attempts == 1)
+    }
+
+    @Test
+    func `pty launcher uses home and closes unrelated descriptors`() throws {
+        let tempDirectory = FileManager.default.temporaryDirectory
+            .appendingPathComponent("antigravity-spawn-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: tempDirectory, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: tempDirectory) }
+
+        let inheritedSourceFD = open("/dev/null", O_RDONLY)
+        guard inheritedSourceFD >= 0 else {
+            Issue.record("Failed to open descriptor fixture")
+            return
+        }
+        defer { close(inheritedSourceFD) }
+        let inheritedFD = fcntl(inheritedSourceFD, F_DUPFD, 200)
+        guard inheritedFD >= 200 else {
+            Issue.record("Failed to duplicate descriptor fixture")
+            return
+        }
+        defer { close(inheritedFD) }
+
+        let outputURL = tempDirectory.appendingPathComponent("result.txt")
+        let script = """
+        pwd > \(outputURL.path)
+        if [ -e /dev/fd/\(inheritedFD) ] || [ -e /proc/self/fd/\(inheritedFD) ]; then
+          echo inherited >> \(outputURL.path)
+        else
+          echo closed >> \(outputURL.path)
+        fi
+        """
+
+        let handle = try AntigravityPTYProcessLauncher().launch(
+            binary: "/bin/sh",
+            arguments: ["-c", script])
+        defer {
+            handle.killRoot()
+            handle.terminateTree(signal: SIGKILL, knownDescendants: [])
+            handle.closePTY()
+        }
+
+        for _ in 0..<200 where !FileManager.default.fileExists(atPath: outputURL.path) {
+            Thread.sleep(forTimeInterval: 0.01)
+        }
+        let lines = try String(contentsOf: outputURL, encoding: .utf8)
+            .split(separator: "\n")
+            .map(String.init)
+        #expect(lines == [NSHomeDirectory(), "closed"])
+    }
+
+    @Test
+    func `spawned PTY drain is bounded per call`() throws {
+        let temp = FileManager.default.temporaryDirectory
+            .appendingPathComponent("antigravity-drain-\(UUID().uuidString)")
+        defer { try? FileManager.default.removeItem(at: temp) }
+        try Data(repeating: 1, count: 8192 * 65).write(to: temp)
+        let primaryFD = open(temp.path, O_RDONLY)
+        guard primaryFD >= 0 else {
+            Issue.record("Failed to open temporary drain input")
+            return
+        }
+        let secondaryFD = open("/dev/null", O_RDONLY)
+        guard secondaryFD >= 0 else {
+            close(primaryFD)
+            Issue.record("Failed to open /dev/null")
+            return
+        }
+        let handle = AntigravitySpawnedPTYProcessHandle(
+            pid: getpid(),
+            processGroup: getpgrp(),
+            primaryFD: primaryFD,
+            primaryHandle: FileHandle(fileDescriptor: primaryFD, closeOnDealloc: true),
+            secondaryHandle: FileHandle(fileDescriptor: secondaryFD, closeOnDealloc: true))
+        defer { handle.closePTY() }
+
+        let output = handle.drainOutput()
+
+        #expect(lseek(primaryFD, 0, SEEK_CUR) == off_t(8192 * 64))
+        #expect(output.count == 8192 * 64)
+    }
+
+    @Test
+    func `session keeps one rolling PTY buffer across concurrent probes`() async throws {
+        let fixture = self.makeFixture()
+        fixture.identity.setIdentity(pid: 10, executablePath: "/bin/agy", startEpoch: 100)
+
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+        let handle = try #require(fixture.launcher.handleSnapshot().first)
+        handle.enqueueDrainOutput(Data([0xE2, 0x96]))
+        let first = await fixture.session.drainOutput()
+        handle.enqueueDrainOutput(Data([0x84]) + Data("Select login method:".utf8))
+        let second = await fixture.session.drainOutput()
+        let third = await fixture.session.drainOutput()
+
+        #expect(first == Data([0xE2, 0x96]))
+        #expect(AntigravityCLIHTTPSFetchStrategy.containsAuthenticationPrompt(second))
+        #expect(third == second)
+
+        await fixture.session.finishProbe(success: false, resetAfterFetch: true, forceTerminate: true)
+        await fixture.session.finishProbe(success: false, resetAfterFetch: false)
+    }
+
+    @Test
+    func `authentication prompt matcher tolerates prompt casing and spacing`() {
+        #expect(AntigravityCLIHTTPSFetchStrategy.containsAuthenticationPrompt(
+            Data("select  LOGIN\nmethod :".utf8)))
+        #expect(AntigravityCLIHTTPSFetchStrategy.containsAuthenticationPrompt(
+            Data("Select login method:".utf8)))
+        #expect(!AntigravityCLIHTTPSFetchStrategy.containsAuthenticationPrompt(
+            Data("You are currently not signed in".utf8)))
+    }
+
+    @Test
+    func `session returns complete new output before retaining only its tail`() async throws {
+        let fixture = self.makeFixture()
+        fixture.identity.setIdentity(pid: 10, executablePath: "/bin/agy", startEpoch: 100)
+
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+        let handle = try #require(fixture.launcher.handleSnapshot().first)
+        let prompt = Data("Select login method:".utf8)
+        let oversizedRedraw = prompt + Data(repeating: 0x20, count: 8192)
+        handle.enqueueDrainOutput(oversizedRedraw)
+
+        let searchableOutput = await fixture.session.drainOutput()
+        let retainedTail = await fixture.session.drainOutput()
+
+        #expect(searchableOutput == oversizedRedraw)
+        #expect(AntigravityCLIHTTPSFetchStrategy.containsAuthenticationPrompt(searchableOutput))
+        #expect(AntigravityCLIHTTPSFetchStrategy.containsAuthenticationPrompt(retainedTail))
+
+        await fixture.session.finishProbe(success: false, resetAfterFetch: true, forceTerminate: true)
+    }
+
+    @Test
+    func `registration failure tears down launched process`() async {
+        let fixture = self.makeFixture()
+        fixture.registry.setShouldRegister(false)
+
+        await #expect(throws: AntigravityCLISession.SessionError.self) {
+            _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+        }
+
+        let handle = fixture.launcher.handleSnapshot().first
+        #expect(handle?.isRunning == false)
+        #expect(handle?.snapshotEvents().contains("sendExit") == false)
+        #expect(handle?.snapshotEvents().contains("closePTY") == true)
+        #expect(handle?.snapshotEvents().contains("terminateRoot") == true)
+        #expect(fixture.registry.registeredSnapshot().isEmpty)
+    }
+
+    @Test
+    func `launch remains usable when coordination lock is unavailable`() async throws {
+        let fixture = self.makeFixture(launchLock: FailingAntigravitySessionLaunchLock())
+        fixture.identity.setIdentity(pid: 10, executablePath: "/bin/agy", startEpoch: 100)
+
+        let pid = try await fixture.session.beginProbe(binary: "/bin/agy")
+        await fixture.session.finishProbe(success: true, resetAfterFetch: true)
+
+        #expect(pid == 10)
+        #expect(fixture.store.snapshot() == nil)
+    }
+
+    @Test
+    func `launch remains usable when ownership record cannot be saved`() async throws {
+        let store = MemoryAntigravitySessionRecordStore(failSaves: true)
+        let fixture = self.makeFixture(store: store)
+        fixture.identity.setIdentity(pid: 10, executablePath: "/bin/agy", startEpoch: 100)
+
+        let pid = try await fixture.session.beginProbe(binary: "/bin/agy")
+        await fixture.session.finishProbe(success: true, resetAfterFetch: true)
+
+        #expect(pid == 10)
+        #expect(store.snapshot() == nil)
+    }
+
+    @Test
+    func `idle window tears down warm process`() async throws {
+        let fixture = self.makeFixture(idleWindow: 0.05, manualSleep: true)
+        fixture.identity.setIdentity(pid: 10, executablePath: "/bin/agy", startEpoch: 100)
+
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+        await fixture.session.finishProbe(success: true, resetAfterFetch: false)
+        await fixture.sleeper?.waitForSleeps(1)
+        fixture.sleeper?.resumeAll()
+        await self.waitUntilStopped(fixture.session)
+
+        #expect(await fixture.session.isRunning == false)
+        #expect(fixture.registry.unregisteredSnapshot() == [10])
+        #expect(fixture.store.snapshot() == nil)
+    }
+
+    @Test
+    func `host idle window extends the default session lifetime`() async throws {
+        let fixture = self.makeFixture(idleWindow: 180)
+        fixture.identity.setIdentity(pid: 10, executablePath: "/bin/agy", startEpoch: 100)
+
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy", idleWindow: 360)
+        await fixture.session.finishProbe(success: true, resetAfterFetch: false)
+
+        #expect(await fixture.session.idleWindowForTesting == 360)
+    }
+
+    @Test
+    func `active probe prevents idle teardown until finish`() async throws {
+        let fixture = self.makeFixture(idleWindow: 0.05, manualSleep: true)
+        fixture.identity.setIdentity(pid: 10, executablePath: "/bin/agy", startEpoch: 100)
+
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+        await fixture.session.finishProbe(success: true, resetAfterFetch: false)
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+        await fixture.sleeper?.waitForSleeps(1)
+        fixture.sleeper?.resumeAll()
+        await Task.yield()
+
+        #expect(await fixture.session.isRunning)
+        await fixture.session.finishProbe(success: true, resetAfterFetch: false)
+        await fixture.sleeper?.waitForSleeps(1)
+        fixture.sleeper?.resumeAll()
+        await self.waitUntilStopped(fixture.session)
+        #expect(await fixture.session.isRunning == false)
+    }
+
+    @Test
+    func `manual reset waits for active probe to finish`() async throws {
+        let fixture = self.makeFixture()
+        fixture.identity.setIdentity(pid: 10, executablePath: "/bin/agy", startEpoch: 100)
+
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+        await fixture.session.reset()
+        #expect(await fixture.session.isRunning)
+        await fixture.session.finishProbe(success: true, resetAfterFetch: false)
+
+        #expect(await fixture.session.isRunning == false)
+        #expect(fixture.registry.unregisteredSnapshot() == [10])
+    }
+
+    @Test
+    func `reset reaps persisted stale session when no in memory process exists`() async {
+        let store = MemoryAntigravitySessionRecordStore(record: AntigravityCLISessionRecord(
+            pid: 777,
+            requestedBinaryPath: "/bin/agy",
+            executablePath: "/bin/agy",
+            startEpoch: 42,
+            processGroup: 777))
+        let fixture = self.makeFixture(store: store)
+        fixture.identity.setIdentity(pid: 777, executablePath: "/bin/agy", startEpoch: 42)
+
+        await fixture.session.reset()
+
+        let terminations = fixture.terminations.snapshot()
+        #expect(terminations.map(\.signal) == [SIGTERM, SIGKILL])
+        #expect(terminations.allSatisfy { $0.pid == 777 && $0.group == 777 })
+        #expect(fixture.store.snapshot() == nil)
+    }
+
+    @Test
+    func `reset preserves persisted session owned by another live process`() async {
+        let store = MemoryAntigravitySessionRecordStore(record: AntigravityCLISessionRecord(
+            pid: 777,
+            requestedBinaryPath: "/bin/agy",
+            executablePath: "/bin/agy",
+            startEpoch: 42,
+            processGroup: 777,
+            ownerPID: 900,
+            ownerExecutablePath: "/Applications/CodexBar.app/Contents/MacOS/CodexBar",
+            ownerStartEpoch: 10))
+        let fixture = self.makeFixture(store: store, currentProcessID: 901)
+        fixture.identity.setIdentity(pid: 777, executablePath: "/bin/agy", startEpoch: 42)
+        fixture.identity.setIdentity(
+            pid: 900,
+            executablePath: "/Applications/CodexBar.app/Contents/MacOS/CodexBar",
+            startEpoch: 10)
+
+        await fixture.session.reset()
+
+        #expect(fixture.terminations.snapshot().isEmpty)
+        #expect(fixture.store.snapshot() != nil)
+    }
+
+    @Test
+    func `launch tracks an independent session while another process is live`() async throws {
+        let protectedRecord = AntigravityCLISessionRecord(
+            pid: 777,
+            requestedBinaryPath: "/bin/agy",
+            executablePath: "/bin/agy",
+            startEpoch: 42,
+            processGroup: 777,
+            ownerPID: 900,
+            ownerExecutablePath: "/Applications/CodexBar.app/Contents/MacOS/CodexBar",
+            ownerStartEpoch: 10)
+        let store = MemoryAntigravitySessionRecordStore(record: protectedRecord)
+        let fixture = self.makeFixture(store: store, currentProcessID: 901)
+        fixture.identity.setIdentity(pid: 777, executablePath: "/bin/agy", startEpoch: 42)
+        fixture.identity.setIdentity(
+            pid: 900,
+            executablePath: "/Applications/CodexBar.app/Contents/MacOS/CodexBar",
+            startEpoch: 10)
+        fixture.identity.setIdentity(pid: 10, executablePath: "/bin/agy", startEpoch: 100)
+        fixture.identity.setIdentity(pid: 901, executablePath: "/app/codexbar", startEpoch: 20)
+
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+
+        #expect(fixture.launcher.launchedBinarySnapshot() == ["/bin/agy"])
+        #expect(fixture.terminations.snapshot().isEmpty)
+        #expect(fixture.store.saveCount == 1)
+        #expect(Set(fixture.store.snapshots().map(\.pid)) == [10, 777])
+
+        await fixture.session.finishProbe(success: true, resetAfterFetch: true)
+        #expect(fixture.store.snapshot() == protectedRecord)
+    }
+
+    @Test
+    func `different binary tracks an independent session while another process is live`() async throws {
+        let protectedRecord = AntigravityCLISessionRecord(
+            pid: 777,
+            requestedBinaryPath: "/bin/agy",
+            executablePath: "/bin/agy",
+            startEpoch: 42,
+            processGroup: 777,
+            ownerPID: 900,
+            ownerExecutablePath: "/Applications/CodexBar.app/Contents/MacOS/CodexBar",
+            ownerStartEpoch: 10)
+        let store = MemoryAntigravitySessionRecordStore(record: protectedRecord)
+        let fixture = self.makeFixture(store: store, currentProcessID: 901)
+        fixture.identity.setIdentity(pid: 777, executablePath: "/bin/agy", startEpoch: 42)
+        fixture.identity.setIdentity(
+            pid: 900,
+            executablePath: "/Applications/CodexBar.app/Contents/MacOS/CodexBar",
+            startEpoch: 10)
+        fixture.identity.setIdentity(pid: 10, executablePath: "/new/agy", startEpoch: 100)
+        fixture.identity.setIdentity(pid: 901, executablePath: "/app/codexbar", startEpoch: 20)
+
+        _ = try await fixture.session.beginProbe(binary: "/new/agy")
+
+        #expect(fixture.launcher.launchedBinarySnapshot() == ["/new/agy"])
+        #expect(fixture.store.saveCount == 1)
+        #expect(Set(fixture.store.snapshots().map(\.pid)) == [10, 777])
+
+        await fixture.session.finishProbe(success: true, resetAfterFetch: true)
+        #expect(fixture.store.snapshot() == protectedRecord)
+    }
+
+    @Test
+    func `concurrent hosts atomically track independent sessions`() async {
+        let store = MemoryAntigravitySessionRecordStore()
+        let launchLock = MemoryAntigravitySessionLaunchLock()
+        let identity = FakeAntigravityIdentityProvider()
+        let firstLauncher = FakeAntigravityProcessLauncher(nextPID: 10)
+        let secondLauncher = FakeAntigravityProcessLauncher(nextPID: 20)
+        identity.setIdentity(pid: 10, executablePath: "/bin/agy", startEpoch: 100)
+        identity.setIdentity(pid: 20, executablePath: "/bin/agy", startEpoch: 200)
+        identity.setIdentity(pid: 900, executablePath: "/app/CodexBar", startEpoch: 1)
+        identity.setIdentity(pid: 901, executablePath: "/app/codexbar", startEpoch: 2)
+        let first = self.makeFixture(
+            launcher: firstLauncher,
+            identity: identity,
+            store: store,
+            launchLock: launchLock,
+            currentProcessID: 900)
+        let second = self.makeFixture(
+            launcher: secondLauncher,
+            identity: identity,
+            store: store,
+            launchLock: launchLock,
+            currentProcessID: 901)
+
+        async let firstStarted = Self.beginPersistentSession(first.session)
+        async let secondStarted = Self.beginPersistentSession(second.session)
+        let results = await [firstStarted, secondStarted]
+
+        #expect(!results.contains(false))
+        #expect(firstLauncher.launchedBinarySnapshot().count + secondLauncher.launchedBinarySnapshot().count == 2)
+        #expect(Set(store.snapshots().map(\.pid)) == [10, 20])
+
+        await first.session.reset()
+        await second.session.reset()
+        #expect(store.snapshots().isEmpty)
+    }
+}
+
+extension AntigravityCLISessionTests {
+    @Test
+    func `warm reuse reaps a crashed peer session`() async throws {
+        let store = MemoryAntigravitySessionRecordStore()
+        let launchLock = MemoryAntigravitySessionLaunchLock()
+        let identity = FakeAntigravityIdentityProvider()
+        let firstLauncher = FakeAntigravityProcessLauncher(nextPID: 10)
+        let secondLauncher = FakeAntigravityProcessLauncher(nextPID: 20)
+        identity.setIdentity(pid: 10, executablePath: "/bin/agy", startEpoch: 100)
+        identity.setIdentity(pid: 20, executablePath: "/bin/agy", startEpoch: 200)
+        identity.setIdentity(pid: 900, executablePath: "/app/CodexBar", startEpoch: 1)
+        identity.setIdentity(pid: 901, executablePath: "/app/codexbar", startEpoch: 2)
+        let first = self.makeFixture(
+            launcher: firstLauncher,
+            identity: identity,
+            store: store,
+            launchLock: launchLock,
+            currentProcessID: 900)
+        let second = self.makeFixture(
+            launcher: secondLauncher,
+            identity: identity,
+            store: store,
+            launchLock: launchLock,
+            currentProcessID: 901)
+        #expect(await Self.beginPersistentSession(first.session))
+        #expect(await Self.beginPersistentSession(second.session))
+
+        identity.removeIdentity(pid: 901)
+        _ = try await first.session.beginProbe(binary: "/bin/agy")
+        await first.session.finishProbe(success: true, resetAfterFetch: false)
+
+        #expect(first.terminations.snapshot().map(\.pid) == [20, 20])
+        #expect(store.snapshots().map(\.pid) == [10])
+
+        await first.session.reset()
+        await second.session.reset()
+    }
+
+    @Test
+    func `file store migrates legacy record and preserves independent owners`() throws {
+        let directory = FileManager.default.temporaryDirectory
+            .appendingPathComponent("CodexBarAntigravitySessionTests-\(UUID().uuidString)", isDirectory: true)
+        let fileURL = directory.appendingPathComponent("agy-session.json")
+        defer { try? FileManager.default.removeItem(at: directory) }
+        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+
+        let legacy = AntigravityCLISessionRecord(
+            pid: 10,
+            requestedBinaryPath: "/bin/agy",
+            executablePath: "/bin/agy",
+            startEpoch: 100,
+            processGroup: 10,
+            ownerPID: 900,
+            ownerExecutablePath: "/app/CodexBar",
+            ownerStartEpoch: 1)
+        try JSONEncoder().encode(legacy).write(to: fileURL)
+        let store = AntigravityFileCLISessionRecordStore(fileURL: fileURL)
+        #expect(try store.load() == [legacy])
+
+        let second = AntigravityCLISessionRecord(
+            pid: 20,
+            requestedBinaryPath: "/bin/agy",
+            executablePath: "/bin/agy",
+            startEpoch: 200,
+            processGroup: 20,
+            ownerPID: 901,
+            ownerExecutablePath: "/app/codexbar",
+            ownerStartEpoch: 2)
+        try store.save(second)
+        #expect(try Set(store.load().map(\.pid)) == [10, 20])
+
+        try store.remove(legacy)
+        #expect(try store.load() == [second])
+
+        try Data("{".utf8).write(to: fileURL)
+        try store.save(legacy)
+        #expect(try store.load() == [legacy])
+    }
+
+    @Test
+    func `session reaps stale owner before launch`() async throws {
+        let protectedRecord = AntigravityCLISessionRecord(
+            pid: 777,
+            requestedBinaryPath: "/bin/agy",
+            executablePath: "/bin/agy",
+            startEpoch: 42,
+            processGroup: 777,
+            ownerPID: 900,
+            ownerExecutablePath: "/Applications/CodexBar.app/Contents/MacOS/CodexBar",
+            ownerStartEpoch: 10)
+        let store = MemoryAntigravitySessionRecordStore(record: protectedRecord)
+        let fixture = self.makeFixture(store: store, currentProcessID: 901)
+        fixture.identity.setIdentity(pid: 777, executablePath: "/bin/agy", startEpoch: 42)
+        fixture.identity.setIdentity(
+            pid: 900,
+            executablePath: "/Applications/CodexBar.app/Contents/MacOS/CodexBar",
+            startEpoch: 10)
+        fixture.identity.setIdentity(
+            pid: 901,
+            executablePath: "/Applications/CodexBar.app/Contents/MacOS/CodexBar",
+            startEpoch: 20)
+        fixture.identity.setIdentity(pid: 10, executablePath: "/bin/agy", startEpoch: 100)
+
+        fixture.identity.removeIdentity(pid: 900)
+        let secondPID = try await fixture.session.beginProbe(binary: "/bin/agy")
+        let record = fixture.store.snapshot()
+        await fixture.session.finishProbe(success: true, resetAfterFetch: true)
+        #expect(secondPID == 10)
+        #expect(fixture.launcher.launchedBinarySnapshot() == ["/bin/agy"])
+        #expect(fixture.terminations.snapshot().map(\.pid) == [777, 777])
+        #expect(fixture.store.saveCount == 1)
+        #expect(record?.pid == 10)
+        #expect(record?.ownerPID == 901)
+    }
+
+    @Test
+    func `reset rechecks protected persisted session after owner exits`() async {
+        let store = MemoryAntigravitySessionRecordStore(record: AntigravityCLISessionRecord(
+            pid: 777,
+            requestedBinaryPath: "/bin/agy",
+            executablePath: "/bin/agy",
+            startEpoch: 42,
+            processGroup: 777,
+            ownerPID: 900,
+            ownerExecutablePath: "/Applications/CodexBar.app/Contents/MacOS/CodexBar",
+            ownerStartEpoch: 10))
+        let fixture = self.makeFixture(store: store, currentProcessID: 901)
+        fixture.identity.setIdentity(pid: 777, executablePath: "/bin/agy", startEpoch: 42)
+        fixture.identity.setIdentity(
+            pid: 900,
+            executablePath: "/Applications/CodexBar.app/Contents/MacOS/CodexBar",
+            startEpoch: 10)
+
+        await fixture.session.reset()
+        fixture.identity.removeIdentity(pid: 900)
+        await fixture.session.reset()
+
+        let terminations = fixture.terminations.snapshot()
+        #expect(terminations.map(\.signal) == [SIGTERM, SIGKILL])
+        #expect(terminations.allSatisfy { $0.pid == 777 && $0.group == 777 })
+        #expect(fixture.store.snapshot() == nil)
+    }
+
+    @Test
+    func `teardown preserves record written by another live session`() async throws {
+        let fixture = self.makeFixture()
+        fixture.identity.setIdentity(pid: 10, executablePath: "/bin/agy", startEpoch: 100)
+
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+        let otherRecord = AntigravityCLISessionRecord(
+            pid: 777,
+            requestedBinaryPath: "/other/agy",
+            executablePath: "/other/agy",
+            startEpoch: 42,
+            processGroup: 777)
+        try fixture.store.save(otherRecord)
+        await fixture.session.finishProbe(success: true, resetAfterFetch: true)
+
+        #expect(fixture.store.snapshot() == otherRecord)
+    }
+
+    @Test
+    func `force killed process is polled again so the child can be reaped`() async throws {
+        let fixture = self.makeFixture(terminateRootStopsProcess: false)
+        fixture.identity.setIdentity(pid: 10, executablePath: "/bin/agy", startEpoch: 100)
+        fixture.identity.setIdentity(pid: 900, executablePath: "/app/CodexBar", startEpoch: 1)
+
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+        await fixture.session.finishProbe(success: true, resetAfterFetch: true)
+
+        let events = fixture.launcher.handleSnapshot().first?.snapshotEvents() ?? []
+        guard let killIndex = events.firstIndex(of: "terminateTree:\(SIGKILL)") else {
+            Issue.record("Expected SIGKILL during teardown")
+            return
+        }
+        #expect(events.dropFirst(killIndex + 1).contains("isRunning:false"))
+    }
+
+    @Test
+    func `one shot CLI reset tears down after fetch`() async throws {
+        let fixture = self.makeFixture()
+        fixture.identity.setIdentity(pid: 10, executablePath: "/bin/agy", startEpoch: 100)
+
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+        await fixture.session.finishProbe(success: true, resetAfterFetch: true)
+
+        #expect(await fixture.session.isRunning == false)
+        #expect(fixture.registry.unregisteredSnapshot() == [10])
+    }
+
+    @Test
+    func `one shot CLI reset is deferred until all active probes finish`() async throws {
+        let fixture = self.makeFixture()
+        fixture.identity.setIdentity(pid: 10, executablePath: "/bin/agy", startEpoch: 100)
+
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+
+        await fixture.session.finishProbe(success: true, resetAfterFetch: true)
+        #expect(await fixture.session.isRunning)
+
+        await fixture.session.finishProbe(success: true, resetAfterFetch: false)
+
+        #expect(await fixture.session.isRunning == false)
+        #expect(fixture.registry.unregisteredSnapshot() == [10])
+    }
+
+    @Test
+    func `authentication reset never writes interactive exit input`() async throws {
+        let fixture = self.makeFixture()
+        fixture.identity.setIdentity(pid: 10, executablePath: "/bin/agy", startEpoch: 100)
+
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+        await fixture.session.finishProbe(success: false, resetAfterFetch: true, forceTerminate: true)
+
+        let events = try #require(fixture.launcher.handleSnapshot().first).snapshotEvents()
+        #expect(!events.contains("sendExit"))
+        #expect(events.contains("closePTY"))
+        #expect(events.contains("terminateRoot"))
+        #expect(await fixture.session.isRunning == false)
+    }
+
+    @Test
+    func `failed reset never writes interactive exit input`() async throws {
+        let fixture = self.makeFixture()
+        fixture.identity.setIdentity(pid: 10, executablePath: "/bin/agy", startEpoch: 100)
+
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+        await fixture.session.finishProbe(success: false, resetAfterFetch: true)
+
+        let events = try #require(fixture.launcher.handleSnapshot().first).snapshotEvents()
+        #expect(!events.contains("sendExit"))
+        #expect(events.contains("terminateRoot"))
+        #expect(await fixture.session.isRunning == false)
+    }
+
+    @Test
+    func `concurrent success preserves a failed probes deferred hard reset`() async throws {
+        let fixture = self.makeFixture()
+        fixture.identity.setIdentity(pid: 10, executablePath: "/bin/agy", startEpoch: 100)
+
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+        await fixture.session.finishProbe(success: false, resetAfterFetch: true)
+        #expect(await fixture.session.isRunning)
+
+        await fixture.session.finishProbe(success: true, resetAfterFetch: false)
+
+        let events = try #require(fixture.launcher.handleSnapshot().first).snapshotEvents()
+        #expect(!events.contains("sendExit"))
+        #expect(events.contains("terminateRoot"))
+        #expect(await fixture.session.isRunning == false)
+    }
+
+    @Test
+    func `idle timeout hard stops a previously failed process`() async throws {
+        let fixture = self.makeFixture(idleWindow: 0.05, manualSleep: true)
+        fixture.identity.setIdentity(pid: 10, executablePath: "/bin/agy", startEpoch: 100)
+
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+        await fixture.session.finishProbe(success: false, resetAfterFetch: false)
+        await fixture.sleeper?.waitForSleeps(1)
+        fixture.sleeper?.resumeAll()
+        await self.waitUntilStopped(fixture.session)
+
+        let events = try #require(fixture.launcher.handleSnapshot().first).snapshotEvents()
+        #expect(!events.contains("sendExit"))
+        #expect(events.contains("terminateRoot"))
+    }
+
+    @Test
+    func `repeated probe failures relaunch session`() async throws {
+        let fixture = self.makeFixture(failureRelaunchThreshold: 2)
+        fixture.identity.setIdentity(pid: 10, executablePath: "/bin/agy", startEpoch: 100)
+        fixture.identity.setIdentity(pid: 11, executablePath: "/bin/agy", startEpoch: 101)
+
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+        await fixture.session.finishProbe(success: false, resetAfterFetch: false)
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+        await fixture.session.finishProbe(success: false, resetAfterFetch: false)
+        let relaunchedPID = try await fixture.session.beginProbe(binary: "/bin/agy")
+        await fixture.session.finishProbe(success: true, resetAfterFetch: false)
+
+        #expect(relaunchedPID == 11)
+        #expect(fixture.launcher.launchedBinarySnapshot() == ["/bin/agy", "/bin/agy"])
+        #expect(await fixture.session.failureCountForTesting == 0)
+    }
+
+    @Test
+    func `session reset reasons distinguish authentication from unhealthy probes`() {
+        #expect(AntigravityCLISession.resetCause(
+            authenticationRequired: true,
+            resetAfterFetch: true,
+            shouldForceStopUnhealthy: true).message == "authentication required")
+        #expect(AntigravityCLISession.resetCause(
+            authenticationRequired: false,
+            resetAfterFetch: true,
+            shouldForceStopUnhealthy: true).message == "unhealthy CLI HTTPS session")
+        #expect(AntigravityCLISession.resetCause(
+            authenticationRequired: false,
+            resetAfterFetch: true,
+            shouldForceStopUnhealthy: false).message == "one-shot CLI fetch")
+        #expect(AntigravityCLISession.resetCause(
+            authenticationRequired: false,
+            resetAfterFetch: false,
+            shouldForceStopUnhealthy: false).message == "deferred reset")
+    }
+
+    @Test
+    func `deferred unhealthy reset preserves its cause after a concurrent success`() async throws {
+        let fixture = self.makeFixture(failureRelaunchThreshold: 1)
+        fixture.identity.setIdentity(pid: 10, executablePath: "/bin/agy", startEpoch: 100)
+
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+        await fixture.session.finishProbe(success: false, resetAfterFetch: false)
+        await fixture.session.finishProbe(success: true, resetAfterFetch: false)
+
+        #expect(await fixture.session.lastStopReasonForTesting == "unhealthy CLI HTTPS session")
+    }
+
+    @Test
+    func `deferred authentication reset preserves its cause after a concurrent success`() async throws {
+        let fixture = self.makeFixture()
+        fixture.identity.setIdentity(pid: 10, executablePath: "/bin/agy", startEpoch: 100)
+
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+        await fixture.session.finishProbe(success: false, resetAfterFetch: true, forceTerminate: true)
+        await fixture.session.finishProbe(success: true, resetAfterFetch: false)
+
+        #expect(await fixture.session.lastStopReasonForTesting == "authentication required")
+    }
+
+    @Test
+    func `success resets failure counter`() async throws {
+        let fixture = self.makeFixture(failureRelaunchThreshold: 2)
+        fixture.identity.setIdentity(pid: 10, executablePath: "/bin/agy", startEpoch: 100)
+
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+        await fixture.session.finishProbe(success: false, resetAfterFetch: false)
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+        await fixture.session.finishProbe(success: true, resetAfterFetch: false)
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+        await fixture.session.finishProbe(success: false, resetAfterFetch: false)
+
+        #expect(fixture.launcher.launchedBinarySnapshot() == ["/bin/agy"])
+        #expect(await fixture.session.failureCountForTesting == 1)
+    }
+
+    @Test
+    func `matching persisted stale process is reaped when resolved binary changed`() async throws {
+        let store = MemoryAntigravitySessionRecordStore(record: AntigravityCLISessionRecord(
+            pid: 777,
+            requestedBinaryPath: "/old/agy",
+            executablePath: "/old/agy",
+            startEpoch: 42,
+            processGroup: 777))
+        let fixture = self.makeFixture(store: store)
+        fixture.identity.setIdentity(pid: 777, executablePath: "/old/agy", startEpoch: 42)
+        fixture.identity.setIdentity(pid: 10, executablePath: "/new/agy", startEpoch: 100)
+
+        _ = try await fixture.session.beginProbe(binary: "/new/agy")
+        await fixture.session.finishProbe(success: true, resetAfterFetch: false)
+
+        let terminations = fixture.terminations.snapshot()
+        #expect(terminations.map(\.signal) == [SIGTERM, SIGKILL])
+        #expect(terminations.allSatisfy { $0.pid == 777 && $0.group == 777 })
+    }
+
+    @Test
+    func `matching persisted stale process is reaped before launch`() async throws {
+        let store = MemoryAntigravitySessionRecordStore(record: AntigravityCLISessionRecord(
+            pid: 777,
+            requestedBinaryPath: "/bin/agy",
+            executablePath: "/bin/agy",
+            startEpoch: 42,
+            processGroup: 777))
+        let fixture = self.makeFixture(store: store)
+        fixture.identity.setIdentity(pid: 777, executablePath: "/bin/agy", startEpoch: 42)
+        fixture.identity.setIdentity(pid: 10, executablePath: "/bin/agy", startEpoch: 100)
+
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+        await fixture.session.finishProbe(success: true, resetAfterFetch: false)
+
+        let terminations = fixture.terminations.snapshot()
+        #expect(terminations.map(\.signal) == [SIGTERM, SIGKILL])
+        #expect(terminations.allSatisfy { $0.pid == 777 && $0.group == 777 })
+    }
+
+    @Test
+    func `non matching persisted process is not reaped`() async throws {
+        let store = MemoryAntigravitySessionRecordStore(record: AntigravityCLISessionRecord(
+            pid: 777,
+            requestedBinaryPath: "/bin/agy",
+            executablePath: "/bin/agy",
+            startEpoch: 42,
+            processGroup: 777))
+        let fixture = self.makeFixture(store: store)
+        fixture.identity.setIdentity(pid: 777, executablePath: "/usr/bin/other", startEpoch: 42)
+        fixture.identity.setIdentity(pid: 10, executablePath: "/bin/agy", startEpoch: 100)
+
+        _ = try await fixture.session.beginProbe(binary: "/bin/agy")
+        await fixture.session.finishProbe(success: true, resetAfterFetch: false)
+
+        #expect(fixture.terminations.snapshot().isEmpty)
+    }
+
+    private func waitForLaunches(_ launcher: FakeAntigravityProcessLauncher, count: Int) async -> Bool {
+        for _ in 0..<200 {
+            if launcher.launchedBinarySnapshot().count >= count { return true }
+            try? await Task.sleep(nanoseconds: 1_000_000)
+        }
+        return false
+    }
+
+    private func waitUntilStopped(_ session: AntigravityCLISession) async {
+        for _ in 0..<200 {
+            let running = await session.isRunning
+            if !running { return }
+            await Task.yield()
+        }
+        Issue.record("Timed out waiting for Antigravity CLI session to stop")
+    }
+
+    private static func beginPersistentSession(_ session: AntigravityCLISession) async -> Bool {
+        do {
+            _ = try await session.beginProbe(binary: "/bin/agy")
+            await session.finishProbe(success: true, resetAfterFetch: false)
+            return true
+        } catch {
+            return false
+        }
+    }
+
+    private struct Fixture {
+        let session: AntigravityCLISession
+        let launcher: FakeAntigravityProcessLauncher
+        let identity: FakeAntigravityIdentityProvider
+        let store: MemoryAntigravitySessionRecordStore
+        let terminations: AntigravitySessionTerminationRecorder
+        let registry: AntigravityRegistryRecorder
+        let launchReservations: AntigravityLaunchReservationRecorder
+        let sleeper: AntigravityManualSleeper?
+    }
+
+    private func makeFixture(
+        launcher suppliedLauncher: FakeAntigravityProcessLauncher? = nil,
+        identity suppliedIdentity: FakeAntigravityIdentityProvider? = nil,
+        store: MemoryAntigravitySessionRecordStore = MemoryAntigravitySessionRecordStore(),
+        launchLock: any AntigravityCLISessionLaunchLocking = MemoryAntigravitySessionLaunchLock(),
+        idleWindow: TimeInterval = 3600,
+        failureRelaunchThreshold: Int = 2,
+        manualSleep: Bool = false,
+        terminationGracePeriod: TimeInterval = 0,
+        terminateRootStopsProcess: Bool = true,
+        currentProcessID: pid_t = 900) -> Fixture
+    {
+        let launcher = suppliedLauncher ?? FakeAntigravityProcessLauncher(nextPID: 10)
+        launcher.setTerminateRootStopsProcess(terminateRootStopsProcess)
+        let identity = suppliedIdentity ?? FakeAntigravityIdentityProvider()
+        let terminations = AntigravitySessionTerminationRecorder()
+        let registry = AntigravityRegistryRecorder()
+        let launchReservations = AntigravityLaunchReservationRecorder()
+        let sleeper = manualSleep ? AntigravityManualSleeper() : nil
+        let session = AntigravityCLISession(dependencies: AntigravityCLISession.Dependencies(
+            launcher: launcher,
+            identityProvider: identity,
+            recordStore: store,
+            launchLock: launchLock,
+            beginAppShutdownTrackedLaunch: { launchReservations.begin() },
+            endAppShutdownTrackedLaunch: { launchReservations.end() },
+            registerForAppShutdown: { pid, binary in registry.register(pid: pid, binary) },
+            updateAppShutdownProcessGroup: { pid, group in registry.update(pid: pid, group: group) },
+            unregisterForAppShutdown: { pid in registry.unregister(pid: pid) },
+            descendantPIDs: { pid in [pid + 1, pid + 2] },
+            terminateProcessTree: { pid, group, signal, descendants in
+                terminations.append(pid: pid, group: group, signal: signal, descendants: descendants)
+            },
+            currentProcessID: { currentProcessID },
+            now: Date.init,
+            sleep: { nanoseconds in
+                if let sleeper {
+                    try await sleeper.sleep(nanoseconds)
+                } else {
+                    try await Task.sleep(nanoseconds: nanoseconds)
+                }
+            },
+            idleWindow: idleWindow,
+            failureRelaunchThreshold: failureRelaunchThreshold,
+            terminationGracePeriod: terminationGracePeriod))
+        return Fixture(
+            session: session,
+            launcher: launcher,
+            identity: identity,
+            store: store,
+            terminations: terminations,
+            registry: registry,
+            launchReservations: launchReservations,
+            sleeper: sleeper)
+    }
+}
diff --git a/Tests/CodexBarTests/AntigravityCompactFallbackTests.swift b/Tests/CodexBarTests/AntigravityCompactFallbackTests.swift
new file mode 100644
index 0000000000..05ba7c7d7d
--- /dev/null
+++ b/Tests/CodexBarTests/AntigravityCompactFallbackTests.swift
@@ -0,0 +1,94 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct AntigravityCompactFallbackTests {
+    @Test
+    func `model quota reset proximity does not imply window duration`() throws {
+        let resetTime = Date().addingTimeInterval(2 * 60 * 60)
+        let snapshot = AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "Gemini 3.1 Pro (Low)",
+                    modelId: "MODEL_PLACEHOLDER_M36",
+                    remainingFraction: 0.5,
+                    resetTime: resetTime,
+                    resetDescription: nil),
+            ],
+            accountEmail: nil,
+            accountPlan: nil)
+
+        let usage = try snapshot.toUsageSnapshot()
+
+        #expect(usage.primary?.windowMinutes == nil)
+        #expect(usage.primary?.resetsAt == resetTime)
+    }
+
+    @Test
+    func `local unclassified model remains available as compact fallback`() throws {
+        let snapshot = AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "Experimental Model",
+                    modelId: "MODEL_PLACEHOLDER_NEW",
+                    remainingFraction: 0.36,
+                    resetTime: nil,
+                    resetDescription: nil),
+            ],
+            accountEmail: nil,
+            accountPlan: nil,
+            source: .local)
+
+        let usage = try snapshot.toUsageSnapshot()
+
+        #expect(usage.primary == nil)
+        #expect(usage.secondary == nil)
+        #expect(usage.tertiary == nil)
+        #expect(usage.extraRateWindows?.map(\.id) == ["antigravity-compact-fallback-MODEL_PLACEHOLDER_NEW"])
+        #expect(usage.extraRateWindows?.map(\.title) == ["Experimental Model"])
+        #expect(usage.extraRateWindows?.map(\.window.usedPercent) == [64])
+    }
+
+    @Test
+    func `remote unclassified model remains detail only`() throws {
+        let snapshot = AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "Experimental Model",
+                    modelId: "MODEL_PLACEHOLDER_NEW",
+                    remainingFraction: 0.36,
+                    resetTime: nil,
+                    resetDescription: nil),
+            ],
+            accountEmail: nil,
+            accountPlan: nil,
+            source: .remote)
+
+        let usage = try snapshot.toUsageSnapshot()
+
+        #expect(usage.primary == nil)
+        #expect(usage.secondary == nil)
+        #expect(usage.extraRateWindows?.map(\.id) == ["MODEL_PLACEHOLDER_NEW"])
+    }
+
+    @Test
+    func `fully unused local model remains available as compact fallback`() throws {
+        let snapshot = AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "Experimental Model",
+                    modelId: "MODEL_PLACEHOLDER_NEW",
+                    remainingFraction: 1,
+                    resetTime: nil,
+                    resetDescription: nil),
+            ],
+            accountEmail: nil,
+            accountPlan: nil,
+            source: .local)
+
+        let usage = try snapshot.toUsageSnapshot()
+
+        #expect(usage.extraRateWindows?.map(\.id) == ["antigravity-compact-fallback-MODEL_PLACEHOLDER_NEW"])
+        #expect(usage.extraRateWindows?.map(\.window.usedPercent) == [0])
+    }
+}
diff --git a/Tests/CodexBarTests/AntigravityDeadlineTests.swift b/Tests/CodexBarTests/AntigravityDeadlineTests.swift
new file mode 100644
index 0000000000..7c9234f3d9
--- /dev/null
+++ b/Tests/CodexBarTests/AntigravityDeadlineTests.swift
@@ -0,0 +1,199 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+private final class AntigravityTimeoutRecorder: @unchecked Sendable {
+    private let lock = NSLock()
+    private var timeouts: [TimeInterval] = []
+
+    func append(_ timeout: TimeInterval) {
+        self.lock.withLock {
+            self.timeouts.append(timeout)
+        }
+    }
+
+    func snapshot() -> [TimeInterval] {
+        self.lock.withLock {
+            self.timeouts
+        }
+    }
+}
+
+private final class AntigravityConcurrencyRecorder: @unchecked Sendable {
+    private let lock = NSLock()
+    private var activeCount = 0
+    private var maximumActiveCount = 0
+
+    func begin() {
+        self.lock.withLock {
+            self.activeCount += 1
+            self.maximumActiveCount = max(self.maximumActiveCount, self.activeCount)
+        }
+    }
+
+    func end() {
+        self.lock.withLock {
+            self.activeCount -= 1
+        }
+    }
+
+    func maximum() -> Int {
+        self.lock.withLock {
+            self.maximumActiveCount
+        }
+    }
+}
+
+struct AntigravityDeadlineTests {
+    @Test
+    func `process candidates probe concurrently while preserving result order`() async throws {
+        let processInfos = [
+            AntigravityStatusProbe.ProcessInfoResult(
+                pid: 1,
+                extensionPort: nil,
+                extensionServerCSRFToken: nil,
+                csrfToken: "first",
+                commandLine: "first"),
+            AntigravityStatusProbe.ProcessInfoResult(
+                pid: 2,
+                extensionPort: nil,
+                extensionServerCSRFToken: nil,
+                csrfToken: "second",
+                commandLine: "second"),
+        ]
+        let concurrency = AntigravityConcurrencyRecorder()
+
+        let result = try await AntigravityStatusProbe.fetchProcessSnapshots(
+            processInfos: processInfos)
+        { processInfo in
+            concurrency.begin()
+            defer { concurrency.end() }
+            if processInfo.pid == 1 {
+                try await Task.sleep(for: .milliseconds(120))
+            } else {
+                try await Task.sleep(for: .milliseconds(20))
+            }
+            return AntigravityStatusSnapshot(
+                modelQuotas: [],
+                accountEmail: "\(processInfo.pid)@example.com",
+                accountPlan: nil)
+        }
+
+        #expect(concurrency.maximum() == 2)
+        #expect(result.snapshots.map(\.accountEmail) == ["1@example.com", "2@example.com"])
+        #expect(result.lastError == nil)
+    }
+
+    @Test
+    func `process candidate transport error preserves url error identity`() async throws {
+        let processInfo = AntigravityStatusProbe.ProcessInfoResult(
+            pid: 1,
+            extensionPort: nil,
+            extensionServerCSRFToken: nil,
+            csrfToken: "token",
+            commandLine: "command")
+
+        let result = try await AntigravityStatusProbe.fetchProcessSnapshots(processInfos: [processInfo]) { _ in
+            throw URLError(.cannotConnectToHost)
+        }
+
+        #expect((result.lastError as? URLError)?.code == .cannotConnectToHost)
+    }
+
+    @Test
+    func `process candidate cancellation rejects partial success`() async {
+        let processInfos = [
+            AntigravityStatusProbe.ProcessInfoResult(
+                pid: 1,
+                extensionPort: nil,
+                extensionServerCSRFToken: nil,
+                csrfToken: "first",
+                commandLine: "first"),
+            AntigravityStatusProbe.ProcessInfoResult(
+                pid: 2,
+                extensionPort: nil,
+                extensionServerCSRFToken: nil,
+                csrfToken: "second",
+                commandLine: "second"),
+        ]
+
+        await #expect(throws: CancellationError.self) {
+            try await AntigravityStatusProbe.fetchProcessSnapshots(processInfos: processInfos) { processInfo in
+                if processInfo.pid == 2 {
+                    throw CancellationError()
+                }
+                return AntigravityStatusSnapshot(
+                    modelQuotas: [],
+                    accountEmail: "partial@example.com",
+                    accountPlan: nil)
+            }
+        }
+    }
+
+    @Test
+    func `cancelled process request rejects partial success`() async {
+        let processInfos = [
+            AntigravityStatusProbe.ProcessInfoResult(
+                pid: 1,
+                extensionPort: nil,
+                extensionServerCSRFToken: nil,
+                csrfToken: "first",
+                commandLine: "first"),
+            AntigravityStatusProbe.ProcessInfoResult(
+                pid: 2,
+                extensionPort: nil,
+                extensionServerCSRFToken: nil,
+                csrfToken: "second",
+                commandLine: "second"),
+        ]
+
+        await #expect(throws: CancellationError.self) {
+            try await AntigravityStatusProbe.fetchProcessSnapshots(processInfos: processInfos) { processInfo in
+                if processInfo.pid == 2 {
+                    throw URLError(.cancelled)
+                }
+                return AntigravityStatusSnapshot(
+                    modelQuotas: [],
+                    accountEmail: "partial@example.com",
+                    accountPlan: nil)
+            }
+        }
+    }
+
+    @Test
+    func `shared deadline reserves time for later endpoint probes`() async throws {
+        let endpoints = [
+            AntigravityStatusProbe.AntigravityConnectionEndpoint(
+                scheme: "https",
+                port: 64001,
+                csrfToken: "token",
+                source: .languageServer),
+            AntigravityStatusProbe.AntigravityConnectionEndpoint(
+                scheme: "https",
+                port: 64002,
+                csrfToken: "token",
+                source: .languageServer),
+        ]
+        let recorder = AntigravityTimeoutRecorder()
+        let deadline = Date().addingTimeInterval(2)
+
+        let resolved = try await AntigravityStatusProbe.resolveWorkingEndpoint(
+            candidateEndpoints: endpoints,
+            timeout: 1,
+            deadline: deadline,
+            testConnectivity: { endpoint, timeout in
+                recorder.append(timeout)
+                if endpoint.port == 64001 {
+                    try? await Task.sleep(for: .seconds(timeout))
+                    return false
+                }
+                return true
+            })
+
+        let timeouts = recorder.snapshot()
+        #expect(resolved.port == 64002)
+        #expect(timeouts.count == 2)
+        #expect(timeouts[0] < 1.1)
+        #expect(timeouts[1] > 0)
+    }
+}
diff --git a/Tests/CodexBarTests/AntigravityLocalSnapshotSelectionTests.swift b/Tests/CodexBarTests/AntigravityLocalSnapshotSelectionTests.swift
new file mode 100644
index 0000000000..414d26bf82
--- /dev/null
+++ b/Tests/CodexBarTests/AntigravityLocalSnapshotSelectionTests.swift
@@ -0,0 +1,46 @@
+import Testing
+@testable import CodexBarCore
+
+struct AntigravityLocalSnapshotSelectionTests {
+    @Test
+    func `selected account wins before quota richness`() throws {
+        let selectedAccount = AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "Gemini 3 Pro Low",
+                    modelId: "gemini-3-pro-low",
+                    remainingFraction: 0.9,
+                    resetTime: nil,
+                    resetDescription: nil),
+            ],
+            accountEmail: "selected@example.com",
+            accountPlan: "Pro",
+            source: .local)
+        let richerOtherAccount = AntigravityStatusSnapshot(
+            quotaSummary: AntigravityQuotaSummary(
+                description: nil,
+                groups: [
+                    AntigravityQuotaSummaryGroup(
+                        displayName: "Gemini Models",
+                        description: nil,
+                        buckets: [
+                            AntigravityQuotaSummaryBucket(
+                                bucketId: "gemini-5h",
+                                displayName: "Five Hour Limit",
+                                remainingFraction: 0.9,
+                                resetDescription: nil,
+                                disabled: false),
+                        ]),
+                ]),
+            accountEmail: "other@example.com",
+            accountPlan: "Ultra",
+            source: .local)
+
+        let selected = try #require(
+            AntigravityStatusProbe.preferredLocalSnapshot(
+                [richerOtherAccount, selectedAccount],
+                matchingAccountEmail: " SELECTED@example.com "))
+
+        #expect(selected.accountEmail == "selected@example.com")
+    }
+}
diff --git a/Tests/CodexBarTests/AntigravityLoginAlertTests.swift b/Tests/CodexBarTests/AntigravityLoginAlertTests.swift
new file mode 100644
index 0000000000..a11ee63a7f
--- /dev/null
+++ b/Tests/CodexBarTests/AntigravityLoginAlertTests.swift
@@ -0,0 +1,52 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct AntigravityLoginAlertTests {
+    @Test
+    func `authorization URL asks Google to select an account`() throws {
+        let redirectURL = try #require(URL(string: "http://127.0.0.1:54321/callback"))
+        let url = try AntigravityLoginRunner.makeAuthorizationURL(
+            redirectURL: redirectURL,
+            state: "state",
+            oauthClient: AntigravityOAuthClient(
+                clientID: "client.apps.googleusercontent.com",
+                clientSecret: "secret"))
+        let components = try #require(URLComponents(url: url, resolvingAgainstBaseURL: false))
+        let prompt = components.queryItems?.first(where: { $0.name == "prompt" })?.value
+
+        #expect(prompt?.split(separator: " ").contains("select_account") == true)
+        #expect(prompt?.split(separator: " ").contains("consent") == true)
+    }
+
+    @Test
+    func `returns alert for timeout`() {
+        let result = AntigravityLoginRunner.Result(outcome: .timedOut)
+        let info = StatusItemController.antigravityLoginAlertInfo(for: result)
+        #expect(info?.title == "Antigravity login timed out")
+    }
+
+    @Test
+    func `returns alert for launch failure`() {
+        let result = AntigravityLoginRunner.Result(outcome: .launchFailed("https://example.com/login"))
+        let info = StatusItemController.antigravityLoginAlertInfo(for: result)
+        #expect(info?.title == "Could not open browser for Antigravity")
+        #expect(info?.message.contains("https://example.com/login") == true)
+    }
+
+    @Test
+    func `returns alert for auth failure`() {
+        let result = AntigravityLoginRunner.Result(outcome: .failed("permission denied"))
+        let info = StatusItemController.antigravityLoginAlertInfo(for: result)
+        #expect(info?.title == "Antigravity login failed")
+        #expect(info?.message == "permission denied")
+    }
+
+    @Test
+    func `returns nil on success`() {
+        let result = AntigravityLoginRunner.Result(outcome: .success("user@example.com"))
+        let info = StatusItemController.antigravityLoginAlertInfo(for: result)
+        #expect(info == nil)
+    }
+}
diff --git a/Tests/CodexBarTests/AntigravityModelLabelTests.swift b/Tests/CodexBarTests/AntigravityModelLabelTests.swift
new file mode 100644
index 0000000000..78c1932010
--- /dev/null
+++ b/Tests/CodexBarTests/AntigravityModelLabelTests.swift
@@ -0,0 +1,25 @@
+import Testing
+@testable import CodexBarCore
+
+struct AntigravityModelLabelTests {
+    @Test
+    func `humanizes raw model ids when label matches model id`() {
+        #expect(AntigravityStatusSnapshot.humanizedModelID("gemini-3-pro-preview") == "Gemini 3 Pro Preview")
+        #expect(AntigravityStatusSnapshot.humanizedModelID("gemini-2.5-flash") == "Gemini 2.5 Flash")
+        #expect(AntigravityStatusSnapshot.humanizedModelID("example-3-1-pro-low") == "Example 3.1 Pro Low")
+        #expect(AntigravityStatusSnapshot.humanizedModelID("gpt-api-oss") == "GPT API OSS")
+        #expect(AntigravityStatusSnapshot.humanizedModelID("").isEmpty)
+    }
+
+    @Test
+    func `preserves custom model labels`() {
+        let quota = AntigravityModelQuota(
+            label: "Custom enterprise label",
+            modelId: "gemini-3-pro-preview",
+            remainingFraction: 1,
+            resetTime: nil,
+            resetDescription: nil)
+
+        #expect(AntigravityStatusSnapshot.quotaDisplayLabel(quota) == "Custom enterprise label")
+    }
+}
diff --git a/Tests/CodexBarTests/AntigravityOAuthCredentialsStoreTests.swift b/Tests/CodexBarTests/AntigravityOAuthCredentialsStoreTests.swift
new file mode 100644
index 0000000000..f4961ee123
--- /dev/null
+++ b/Tests/CodexBarTests/AntigravityOAuthCredentialsStoreTests.swift
@@ -0,0 +1,159 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct AntigravityOAuthCredentialsStoreTests {
+    @Test
+    func `oauth client discovery reads renamed legacy bundle`() throws {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let legacyClient = AntigravityOAuthClient(
+            clientID: self.googleClientID("legacy"),
+            clientSecret: self.googleClientSecret(repeating: "a"))
+        try self.writeAntigravityApp(
+            named: "Antigravity 2.app",
+            under: root,
+            bundleIdentifier: "com.google.antigravity-ide",
+            artifactRelativePath: "Contents/Resources/app/out/main.js",
+            artifactData: Data("""
+            out-build/vs/platform/cloudCode/common/oauthClient.js
+            clientId="\(legacyClient.clientID)";
+            clientSecret="\(legacyClient.clientSecret)";
+            """.utf8))
+
+        #expect(
+            AntigravityOAuthConfig.discoverClientFromInstalledApp(
+                applicationRoots: [root]) == legacyClient)
+    }
+
+    @Test
+    func `oauth client discovery reads standalone antigravity 2 bundle`() throws {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let standaloneClient = AntigravityOAuthClient(
+            clientID: self.googleClientID("standalone"),
+            clientSecret: self.googleClientSecret(repeating: "b"))
+        let alternateClient = AntigravityOAuthClient(
+            clientID: self.googleClientID("alternate"),
+            clientSecret: self.googleClientSecret(repeating: "c"))
+        var artifactData = Data([0xFF])
+        artifactData.append(Data(
+            """
+            \u{0}\(alternateClient.clientSecret)\u{0}\(standaloneClient.clientSecret)\
+            \u{0}oauth_data\(standaloneClient.clientID)\u{0}\(alternateClient.clientID)\u{0}
+            """.utf8))
+        try self.writeAntigravityApp(
+            named: "Antigravity.app",
+            under: root,
+            artifactRelativePath: "Contents/Resources/bin/language_server",
+            artifactData: artifactData)
+
+        #expect(
+            AntigravityOAuthConfig.discoverClientFromInstalledApp(
+                applicationRoots: [root]) == standaloneClient)
+    }
+
+    @Test
+    func `oauth client discovery reads antigravity extension language server`() throws {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let extensionClient = AntigravityOAuthClient(
+            clientID: self.googleClientID("extension"),
+            clientSecret: self.googleClientSecret(repeating: "d"))
+        let staleClient = AntigravityOAuthClient(
+            clientID: self.googleClientID("stale"),
+            clientSecret: self.googleClientSecret(repeating: "e"))
+        try self.writeAntigravityApp(
+            named: "Antigravity IDE.app",
+            under: root,
+            bundleIdentifier: "com.google.antigravity-ide",
+            artifactRelativePath: "Contents/Resources/app/out/main.js",
+            artifactData: Data("""
+            out-build/vs/platform/cloudCode/common/oauthClient.js
+            clientId="\(staleClient.clientID)";
+            clientSecret="\(staleClient.clientSecret)";
+            """.utf8))
+        var artifactData = Data([0xFF])
+        artifactData.append(Data(
+            """
+            \u{0}\(extensionClient.clientSecret)\u{0}oauth_data\u{0}\(extensionClient.clientID)\u{0}
+            """.utf8))
+        try self.writeAntigravityApp(
+            named: "Antigravity IDE.app",
+            under: root,
+            bundleIdentifier: "com.google.antigravity-ide",
+            artifactRelativePath: "Contents/Resources/app/extensions/antigravity/bin/language_server_macos_arm",
+            artifactData: artifactData)
+
+        #expect(
+            AntigravityOAuthConfig.discoverClientFromInstalledApp(
+                applicationRoots: [root]) == extensionClient)
+    }
+
+    @Test
+    func `oauth client discovery pairs lone binary secret with trailing client id`() throws {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let standaloneClient = AntigravityOAuthClient(
+            clientID: self.googleClientID("standalone"),
+            clientSecret: self.googleClientSecret(repeating: "b"))
+        let alternateClientID = self.googleClientID("alternate")
+        var artifactData = Data([0xFF])
+        artifactData.append(Data(
+            """
+            \u{0}\(standaloneClient.clientSecret)\u{0}oauth_data\
+            \u{0}\(alternateClientID)\u{0}\(standaloneClient.clientID)\u{0}
+            """.utf8))
+        try self.writeAntigravityApp(
+            named: "Antigravity.app",
+            under: root,
+            artifactRelativePath: "Contents/Resources/bin/language_server",
+            artifactData: artifactData)
+
+        #expect(
+            AntigravityOAuthConfig.discoverClientFromInstalledApp(
+                applicationRoots: [root]) == standaloneClient)
+    }
+
+    private func writeAntigravityApp(
+        named name: String,
+        under root: URL,
+        bundleIdentifier: String = "com.google.antigravity",
+        artifactRelativePath: String,
+        artifactData: Data) throws
+    {
+        let appURL = root.appendingPathComponent(name, isDirectory: true)
+        let contentsURL = appURL.appendingPathComponent("Contents", isDirectory: true)
+        try FileManager.default.createDirectory(
+            at: contentsURL,
+            withIntermediateDirectories: true)
+        let infoURL = contentsURL.appendingPathComponent("Info.plist")
+        let infoData = try PropertyListSerialization.data(
+            fromPropertyList: ["CFBundleIdentifier": bundleIdentifier],
+            format: .xml,
+            options: 0)
+        try infoData.write(to: infoURL)
+
+        let artifactURL = appURL.appendingPathComponent(artifactRelativePath)
+        try FileManager.default.createDirectory(
+            at: artifactURL.deletingLastPathComponent(),
+            withIntermediateDirectories: true)
+        try artifactData.write(to: artifactURL)
+    }
+
+    private func googleClientID(_ name: String) -> String {
+        "123456789012-" + name + ".apps" + ".googleusercontent.com"
+    }
+
+    private func googleClientSecret(repeating character: Character) -> String {
+        "GOC" + "SPX-" + String(repeating: character, count: 28)
+    }
+}
diff --git a/Tests/CodexBarTests/AntigravityQuotaSummaryTests.swift b/Tests/CodexBarTests/AntigravityQuotaSummaryTests.swift
new file mode 100644
index 0000000000..48824ad58b
--- /dev/null
+++ b/Tests/CodexBarTests/AntigravityQuotaSummaryTests.swift
@@ -0,0 +1,381 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+private final class AntigravityQuotaSummaryPathRecorder: @unchecked Sendable {
+    private let lock = NSLock()
+    private var paths: [String] = []
+
+    func append(_ path: String) {
+        self.lock.lock()
+        self.paths.append(path)
+        self.lock.unlock()
+    }
+
+    func snapshot() -> [String] {
+        self.lock.lock()
+        let snapshot = self.paths
+        self.lock.unlock()
+        return snapshot
+    }
+}
+
+struct AntigravityQuotaSummaryTests {
+    @Test
+    func `parses quota summary response into two model groups with session before weekly windows`() throws {
+        let snapshot = try AntigravityStatusProbe.parseQuotaSummaryResponse(
+            Data(antigravityQuotaSummaryJSON().utf8))
+
+        #expect(snapshot.modelQuotas.isEmpty)
+        let usage = try snapshot.toUsageSnapshot()
+        let windows = try #require(usage.extraRateWindows)
+
+        #expect(windows.map(\.id) == [
+            "antigravity-quota-summary-gemini-5h",
+            "antigravity-quota-summary-gemini-weekly",
+            "antigravity-quota-summary-3p-5h",
+            "antigravity-quota-summary-3p-weekly",
+        ])
+        #expect(windows.map(\.title) == [
+            "Gemini Models Five Hour Limit",
+            "Gemini Models Weekly Limit",
+            "Claude and GPT models Five Hour Limit",
+            "Claude and GPT models Weekly Limit",
+        ])
+        #expect(windows.map(\.window.windowMinutes) == [300, 10080, 300, 10080])
+        #expect(windows.map { $0.window.remainingPercent.rounded() } == [91, 82, 73, 64])
+        #expect(windows.map(\.usageKnown) == [true, true, true, true])
+
+        let expectedDates = [
+            ISO8601DateFormatter().date(from: "2026-06-15T11:39:34Z"),
+            ISO8601DateFormatter().date(from: "2026-06-19T08:45:39Z"),
+            ISO8601DateFormatter().date(from: "2026-06-15T12:52:10Z"),
+            ISO8601DateFormatter().date(from: "2026-06-20T00:39:54Z"),
+        ]
+        #expect(windows.map(\.window.resetsAt) == expectedDates)
+
+        #expect(usage.primary?.remainingPercent.rounded() == 82)
+        #expect(usage.secondary?.remainingPercent.rounded() == 64)
+        #expect(usage.tertiary == nil)
+    }
+
+    @Test
+    func `parses quota summary oneof remaining value shape`() throws {
+        let json = """
+        {
+          "groups": [
+            {
+              "displayName": "Gemini Models",
+              "buckets": [
+                {
+                  "bucketId": "gemini-weekly",
+                  "displayName": "Weekly Limit",
+                  "remaining": { "case": "remainingFraction", "value": 0.5 }
+                }
+              ]
+            }
+          ]
+        }
+        """
+
+        let snapshot = try AntigravityStatusProbe.parseQuotaSummaryResponse(Data(json.utf8))
+        let usage = try snapshot.toUsageSnapshot()
+
+        #expect(usage.extraRateWindows?.first?.window.remainingPercent == 50)
+    }
+
+    @Test
+    func `fetch snapshot prefers quota summary endpoint and merges identity`() async throws {
+        let endpoint = AntigravityStatusProbe.AntigravityConnectionEndpoint(
+            scheme: "https",
+            port: 64440,
+            csrfToken: "token",
+            source: .languageServer)
+        let paths = AntigravityQuotaSummaryPathRecorder()
+
+        let snapshot = try await AntigravityStatusProbe.fetchSnapshot(
+            context: AntigravityStatusProbe.RequestContext(endpoints: [endpoint], timeout: 1),
+            send: { payload, _, _ in
+                paths.append(payload.path)
+                if payload.path.contains("GetUserStatus") {
+                    return Data(antigravityUserStatusJSON().utf8)
+                }
+                return Data(antigravityQuotaSummaryJSON().utf8)
+            })
+        let usage = try snapshot.toUsageSnapshot()
+
+        #expect(paths.snapshot() == [
+            "/exa.language_server_pb.LanguageServerService/RetrieveUserQuotaSummary",
+            "/exa.language_server_pb.LanguageServerService/GetUserStatus",
+        ])
+        #expect(usage.extraRateWindows?.count == 4)
+        #expect(usage.identity?.accountEmail == "test@example.com")
+        #expect(usage.identity?.loginMethod == "Pro")
+    }
+
+    @Test
+    func `fetch snapshot keeps quota summary when identity endpoint fails`() async throws {
+        let endpoint = AntigravityStatusProbe.AntigravityConnectionEndpoint(
+            scheme: "https",
+            port: 64440,
+            csrfToken: "token",
+            source: .languageServer)
+        let paths = AntigravityQuotaSummaryPathRecorder()
+
+        let snapshot = try await AntigravityStatusProbe.fetchSnapshot(
+            context: AntigravityStatusProbe.RequestContext(endpoints: [endpoint], timeout: 1),
+            send: { payload, _, _ in
+                paths.append(payload.path)
+                if payload.path.contains("GetUserStatus") {
+                    return Data(#"{"code":16}"#.utf8)
+                }
+                return Data(antigravityQuotaSummaryJSON().utf8)
+            })
+        let usage = try snapshot.toUsageSnapshot()
+
+        #expect(paths.snapshot() == [
+            "/exa.language_server_pb.LanguageServerService/RetrieveUserQuotaSummary",
+            "/exa.language_server_pb.LanguageServerService/GetUserStatus",
+        ])
+        #expect(usage.extraRateWindows?.count == 4)
+        #expect(usage.identity?.accountEmail == nil)
+    }
+
+    @Test
+    func `fetch snapshot falls back to user status when quota summary is unavailable`() async throws {
+        let endpoint = AntigravityStatusProbe.AntigravityConnectionEndpoint(
+            scheme: "https",
+            port: 64440,
+            csrfToken: "token",
+            source: .languageServer)
+        let paths = AntigravityQuotaSummaryPathRecorder()
+
+        let snapshot = try await AntigravityStatusProbe.fetchSnapshot(
+            context: AntigravityStatusProbe.RequestContext(endpoints: [endpoint], timeout: 1),
+            send: { payload, _, _ in
+                paths.append(payload.path)
+                if payload.path.contains("RetrieveUserQuotaSummary") {
+                    return Data(#"{"code":16}"#.utf8)
+                }
+                return Data(antigravityUserStatusJSON().utf8)
+            })
+        let usage = try snapshot.toUsageSnapshot()
+
+        #expect(paths.snapshot() == [
+            "/exa.language_server_pb.LanguageServerService/RetrieveUserQuotaSummary",
+            "/exa.language_server_pb.LanguageServerService/GetUserStatus",
+        ])
+        #expect(usage.primary?.remainingPercent.rounded() == 90)
+    }
+
+    @Test
+    func `fetch snapshot falls back when quota summary has no known usage buckets`() async throws {
+        let endpoint = AntigravityStatusProbe.AntigravityConnectionEndpoint(
+            scheme: "https",
+            port: 64440,
+            csrfToken: "token",
+            source: .languageServer)
+        let paths = AntigravityQuotaSummaryPathRecorder()
+
+        let snapshot = try await AntigravityStatusProbe.fetchSnapshot(
+            context: AntigravityStatusProbe.RequestContext(endpoints: [endpoint], timeout: 1),
+            send: { payload, _, _ in
+                paths.append(payload.path)
+                if payload.path.contains("RetrieveUserQuotaSummary") {
+                    return Data(antigravityQuotaSummaryWithoutKnownUsageJSON().utf8)
+                }
+                return Data(antigravityUserStatusJSON().utf8)
+            })
+        let usage = try snapshot.toUsageSnapshot()
+
+        #expect(paths.snapshot() == [
+            "/exa.language_server_pb.LanguageServerService/RetrieveUserQuotaSummary",
+            "/exa.language_server_pb.LanguageServerService/GetUserStatus",
+        ])
+        #expect(usage.primary?.remainingPercent.rounded() == 90)
+    }
+
+    @Test
+    func `quota summary timeout reserves deadline for legacy fallback`() async throws {
+        let endpoint = AntigravityStatusProbe.AntigravityConnectionEndpoint(
+            scheme: "https",
+            port: 64440,
+            csrfToken: "token",
+            source: .languageServer)
+        let paths = AntigravityQuotaSummaryPathRecorder()
+
+        let snapshot = try await AntigravityStatusProbe.fetchSnapshot(
+            context: AntigravityStatusProbe.RequestContext(
+                endpoints: [endpoint],
+                timeout: 1,
+                deadline: Date().addingTimeInterval(2)),
+            send: { payload, _, timeout in
+                paths.append(payload.path)
+                if payload.path.contains("RetrieveUserQuotaSummary") {
+                    try await Task.sleep(for: .seconds(timeout))
+                    throw AntigravityStatusProbeError.timedOut
+                }
+                return Data(antigravityUserStatusJSON().utf8)
+            })
+        let usage = try snapshot.toUsageSnapshot()
+
+        #expect(paths.snapshot() == [
+            "/exa.language_server_pb.LanguageServerService/RetrieveUserQuotaSummary",
+            "/exa.language_server_pb.LanguageServerService/GetUserStatus",
+        ])
+        #expect(usage.primary?.remainingPercent.rounded() == 90)
+    }
+
+    @Test
+    func `user status timeout reserves deadline for command model fallback`() async throws {
+        let endpoint = AntigravityStatusProbe.AntigravityConnectionEndpoint(
+            scheme: "https",
+            port: 64440,
+            csrfToken: "token",
+            source: .languageServer)
+        let paths = AntigravityQuotaSummaryPathRecorder()
+
+        let snapshot = try await AntigravityStatusProbe.fetchSnapshot(
+            context: AntigravityStatusProbe.RequestContext(
+                endpoints: [endpoint],
+                timeout: 1,
+                deadline: Date().addingTimeInterval(2)),
+            send: { payload, _, timeout in
+                paths.append(payload.path)
+                if payload.path.contains("RetrieveUserQuotaSummary") {
+                    throw AntigravityStatusProbeError.apiError("unsupported")
+                }
+                if payload.path.contains("GetUserStatus") {
+                    try await Task.sleep(for: .seconds(timeout))
+                    throw AntigravityStatusProbeError.timedOut
+                }
+                return Data(antigravityCommandModelConfigJSON().utf8)
+            })
+        let usage = try snapshot.toUsageSnapshot()
+
+        #expect(paths.snapshot() == [
+            "/exa.language_server_pb.LanguageServerService/RetrieveUserQuotaSummary",
+            "/exa.language_server_pb.LanguageServerService/GetUserStatus",
+            "/exa.language_server_pb.LanguageServerService/GetCommandModelConfigs",
+        ])
+        #expect(usage.primary?.remainingPercent.rounded() == 90)
+    }
+}
+
+private func antigravityQuotaSummaryJSON() -> String {
+    """
+    {
+      "response": {
+        "description": "Within each group, models share a weekly limit and a 5-hour limit.",
+        "groups": [
+          {
+            "displayName": "Gemini Models",
+            "description": "Models within this group: Gemini Flash, Gemini Pro",
+            "buckets": [
+              {
+                "bucketId": "gemini-weekly",
+                "displayName": "Weekly Limit",
+                "remaining": { "remainingFraction": 0.82 },
+                "description": "You have used some of your weekly limit, it will fully refresh in 5 days, 11 hours.",
+                "resetTime": "2026-06-19T08:45:39Z"
+              },
+              {
+                "bucketId": "gemini-5h",
+                "displayName": "Five Hour Limit",
+                "remaining": { "remainingFraction": 0.91 },
+                "description": "You have used some of your 5-hour limit, it will fully refresh in 4 hours.",
+                "resetTime": "2026-06-15T11:39:34Z"
+              }
+            ]
+          },
+          {
+            "displayName": "Claude and GPT models",
+            "description": "Models within this group: Claude Opus, Claude Sonnet, GPT-OSS",
+            "buckets": [
+              {
+                "bucketId": "3p-weekly",
+                "displayName": "Weekly Limit",
+                "remaining": { "remainingFraction": 0.64 },
+                "description": "You have used some of your weekly limit, it will fully refresh in 6 days, 22 hours.",
+                "resetTime": "2026-06-20T00:39:54Z"
+              },
+              {
+                "bucketId": "3p-5h",
+                "displayName": "Five Hour Limit",
+                "remaining": { "remainingFraction": 0.73 },
+                "description": "You have used some of your 5-hour limit, it will fully refresh in 3 hours, 38 minutes.",
+                "resetTime": "2026-06-15T12:52:10Z"
+              }
+            ]
+          }
+        ]
+      }
+    }
+    """
+}
+
+private func antigravityQuotaSummaryWithoutKnownUsageJSON() -> String {
+    """
+    {
+      "response": {
+        "groups": [
+          {
+            "displayName": "Gemini Models",
+            "buckets": [
+              {
+                "bucketId": "gemini-weekly",
+                "displayName": "Weekly Limit",
+                "description": "Refreshes later."
+              },
+              {
+                "bucketId": "gemini-5h",
+                "displayName": "Five Hour Limit",
+                "disabled": true,
+                "remaining": { "remainingFraction": 0.5 }
+              }
+            ]
+          }
+        ]
+      }
+    }
+    """
+}
+
+private func antigravityUserStatusJSON() -> String {
+    """
+    {
+      "code": 0,
+      "userStatus": {
+        "email": "test@example.com",
+        "planStatus": {
+          "planInfo": {
+            "planName": "Pro"
+          }
+        },
+        "cascadeModelConfigData": {
+          "clientModelConfigs": [
+            {
+              "label": "Gemini 3 Pro Low",
+              "modelOrAlias": { "model": "gemini-3-pro-low" },
+              "quotaInfo": { "remainingFraction": 0.9, "resetTime": "2025-12-24T10:00:00Z" }
+            }
+          ]
+        }
+      }
+    }
+    """
+}
+
+private func antigravityCommandModelConfigJSON() -> String {
+    """
+    {
+      "clientModelConfigs": [
+        {
+          "label": "Gemini 3 Pro Low",
+          "modelOrAlias": { "model": "gemini-3-pro-low" },
+          "quotaInfo": { "remainingFraction": 0.9, "resetTime": "2025-12-24T10:00:00Z" }
+        }
+      ]
+    }
+    """
+}
diff --git a/Tests/CodexBarTests/AntigravityRemoteUsageFetcherTests.swift b/Tests/CodexBarTests/AntigravityRemoteUsageFetcherTests.swift
new file mode 100644
index 0000000000..d6976c20bf
--- /dev/null
+++ b/Tests/CodexBarTests/AntigravityRemoteUsageFetcherTests.swift
@@ -0,0 +1,1247 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+private actor AntigravityCredentialUpdateCapture {
+    private var captured: [AntigravityOAuthCredentials] = []
+
+    func append(_ credentials: AntigravityOAuthCredentials) {
+        self.captured.append(credentials)
+    }
+
+    func values() -> [AntigravityOAuthCredentials] {
+        self.captured
+    }
+}
+
+@Suite(.serialized)
+// swiftlint:disable:next type_body_length
+struct AntigravityRemoteUsageFetcherTests {
+    @Test
+    func `antigravity supports token accounts for quick account switching`() {
+        let support = TokenAccountSupportCatalog.support(for: .antigravity)
+
+        #expect(support?.title == "Google accounts")
+        #expect(support?.requiresManualCookieSource == false)
+        #expect(TokenAccountSupportCatalog.envOverride(
+            for: .antigravity,
+            token: "serialized-credentials")?[AntigravityOAuthCredentialsStore.environmentCredentialsKey] ==
+            "serialized-credentials")
+    }
+
+    @Test
+    func `oauth credentials round trip through token account value`() throws {
+        let credentials = AntigravityOAuthCredentials(
+            accessToken: "access-token",
+            refreshToken: "refresh-token",
+            expiryDate: Date(timeIntervalSince1970: 1_700_000_000),
+            idToken: GeminiAPITestHelpers.makeIDToken(email: "user@example.com"),
+            email: "user@example.com",
+            projectID: "project-123",
+            clientID: "client-id",
+            clientSecret: "client-secret")
+
+        let token = try AntigravityOAuthCredentialsStore.tokenAccountValue(for: credentials)
+        let decoded = try #require(AntigravityOAuthCredentialsStore.credentials(fromTokenAccountValue: token))
+
+        #expect(decoded == credentials)
+    }
+
+    @Test
+    func `remote fetch uses selected token account credentials before shared credentials`() async throws {
+        let env = try GeminiTestEnvironment()
+        defer { env.cleanup() }
+        try env.writeAntigravityCredentials(
+            accessToken: "shared-token",
+            refreshToken: nil,
+            expiry: Date().addingTimeInterval(3600),
+            idToken: GeminiAPITestHelpers.makeIDToken(email: "shared@example.com"),
+            email: "shared@example.com")
+        let selectedCredentials = AntigravityOAuthCredentials(
+            accessToken: "selected-token",
+            refreshToken: nil,
+            expiryDate: Date().addingTimeInterval(3600),
+            idToken: GeminiAPITestHelpers.makeIDToken(email: "selected@example.com"),
+            email: "selected@example.com",
+            projectID: nil,
+            clientID: nil,
+            clientSecret: nil)
+        let token = try AntigravityOAuthCredentialsStore.tokenAccountValue(for: selectedCredentials)
+
+        let dataLoader = GeminiAPITestHelpers.dataLoader { request in
+            guard let url = request.url, let host = url.host else {
+                throw URLError(.badURL)
+            }
+            #expect(request.value(forHTTPHeaderField: "Authorization") == "Bearer selected-token")
+
+            switch host {
+            case "cloudcode-pa.googleapis.com":
+                if url.path == "/v1internal:loadCodeAssist" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: GeminiAPITestHelpers.jsonData([
+                            "currentTier": ["id": "free-tier", "name": "free"],
+                            "cloudaicompanionProject": "managed-project-123",
+                        ]))
+                }
+                if url.path == "/v1internal:fetchAvailableModels" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: Self.availableModelsResponse())
+                }
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            default:
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            }
+        }
+
+        let fetcher = AntigravityRemoteUsageFetcher(
+            timeout: 1,
+            homeDirectory: env.homeURL.path,
+            environment: [AntigravityOAuthCredentialsStore.environmentCredentialsKey: token],
+            dataLoader: dataLoader)
+        let snapshot = try await fetcher.fetch()
+
+        #expect(snapshot.accountEmail == "selected@example.com")
+    }
+
+    @Test
+    func `remote fetch refreshes selected token account without mutating shared credentials`() async throws {
+        let env = try GeminiTestEnvironment()
+        defer { env.cleanup() }
+        try env.writeAntigravityCredentials(
+            accessToken: "shared-token",
+            refreshToken: "shared-refresh",
+            expiry: Date().addingTimeInterval(3600),
+            idToken: GeminiAPITestHelpers.makeIDToken(email: "shared@example.com"),
+            email: "shared@example.com",
+            clientID: "shared-client-id",
+            clientSecret: "shared-client-secret")
+        let selectedCredentials = AntigravityOAuthCredentials(
+            accessToken: "selected-old-token",
+            refreshToken: "selected-refresh",
+            expiryDate: Date().addingTimeInterval(-3600),
+            idToken: GeminiAPITestHelpers.makeIDToken(email: "selected-old@example.com"),
+            email: "selected-old@example.com",
+            projectID: nil,
+            clientID: "selected-client-id",
+            clientSecret: "selected-client-secret")
+        let token = try AntigravityOAuthCredentialsStore.tokenAccountValue(for: selectedCredentials)
+        let updateCapture = AntigravityCredentialUpdateCapture()
+
+        let dataLoader = GeminiAPITestHelpers.dataLoader { request in
+            guard let url = request.url, let host = url.host else {
+                throw URLError(.badURL)
+            }
+
+            switch host {
+            case "oauth2.googleapis.com":
+                let body = String(data: request.httpBody ?? Data(), encoding: .utf8) ?? ""
+                #expect(body.contains("client_id=selected-client-id"))
+                #expect(body.contains("refresh_token=selected-refresh"))
+                return GeminiAPITestHelpers.response(
+                    url: url.absoluteString,
+                    status: 200,
+                    body: GeminiAPITestHelpers.jsonData([
+                        "access_token": "selected-new-token",
+                        "expires_in": 3600,
+                        "id_token": GeminiAPITestHelpers.makeIDToken(email: "selected-new@example.com"),
+                    ]))
+            case "cloudcode-pa.googleapis.com":
+                #expect(request.value(forHTTPHeaderField: "Authorization") == "Bearer selected-new-token")
+                if url.path == "/v1internal:loadCodeAssist" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: GeminiAPITestHelpers.jsonData([
+                            "currentTier": ["id": "free-tier", "name": "free"],
+                            "cloudaicompanionProject": "selected-project-123",
+                        ]))
+                }
+                if url.path == "/v1internal:fetchAvailableModels" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: Self.availableModelsResponse())
+                }
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            default:
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            }
+        }
+
+        let fetcher = AntigravityRemoteUsageFetcher(
+            timeout: 1,
+            homeDirectory: env.homeURL.path,
+            environment: [AntigravityOAuthCredentialsStore.environmentCredentialsKey: token],
+            dataLoader: dataLoader,
+            credentialsUpdateHandler: { credentials in
+                await updateCapture.append(credentials)
+            })
+        let snapshot = try await fetcher.fetch()
+        let shared = try env.readAntigravityCredentials()
+        let updatedCredentials = await updateCapture.values()
+
+        #expect(snapshot.accountEmail == "selected-new@example.com")
+        #expect(shared["access_token"] as? String == "shared-token")
+        #expect(shared["email"] as? String == "shared@example.com")
+        #expect(updatedCredentials.last?.accessToken == "selected-new-token")
+        #expect(updatedCredentials.last?.projectID == "selected-project-123")
+    }
+
+    @Test
+    func `remote fetch ignores selected token account project id persistence failure`() async throws {
+        let env = try GeminiTestEnvironment()
+        defer { env.cleanup() }
+        let selectedCredentials = AntigravityOAuthCredentials(
+            accessToken: "selected-token",
+            refreshToken: nil,
+            expiryDate: Date().addingTimeInterval(3600),
+            idToken: GeminiAPITestHelpers.makeIDToken(email: "selected@example.com"),
+            email: "selected@example.com",
+            projectID: nil,
+            clientID: nil,
+            clientSecret: nil)
+        let token = try AntigravityOAuthCredentialsStore.tokenAccountValue(for: selectedCredentials)
+
+        let dataLoader = GeminiAPITestHelpers.dataLoader { request in
+            guard let url = request.url, let host = url.host else {
+                throw URLError(.badURL)
+            }
+
+            switch host {
+            case "cloudcode-pa.googleapis.com":
+                if url.path == "/v1internal:loadCodeAssist" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: GeminiAPITestHelpers.jsonData([
+                            "currentTier": ["id": "free-tier", "name": "free"],
+                            "cloudaicompanionProject": "selected-project-123",
+                        ]))
+                }
+                if url.path == "/v1internal:fetchAvailableModels" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: Self.availableModelsResponse())
+                }
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            default:
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            }
+        }
+
+        let fetcher = AntigravityRemoteUsageFetcher(
+            timeout: 1,
+            homeDirectory: env.homeURL.path,
+            environment: [AntigravityOAuthCredentialsStore.environmentCredentialsKey: token],
+            dataLoader: dataLoader,
+            credentialsUpdateHandler: { _ in
+                throw CocoaError(.fileWriteUnknown)
+            })
+        let snapshot = try await fetcher.fetch()
+
+        #expect(snapshot.accountEmail == "selected@example.com")
+    }
+
+    @Test
+    func `remote fetch rejects invalid selected token account`() async throws {
+        let env = try GeminiTestEnvironment()
+        defer { env.cleanup() }
+        try env.writeAntigravityCredentials(
+            accessToken: "shared-token",
+            refreshToken: nil,
+            expiry: Date().addingTimeInterval(3600),
+            idToken: GeminiAPITestHelpers.makeIDToken(email: "shared@example.com"),
+            email: "shared@example.com")
+
+        let fetcher = AntigravityRemoteUsageFetcher(
+            timeout: 1,
+            homeDirectory: env.homeURL.path,
+            environment: [AntigravityOAuthCredentialsStore.environmentCredentialsKey: "not-json"],
+            dataLoader: GeminiAPITestHelpers.dataLoader { _ in
+                throw URLError(.badServerResponse)
+            })
+
+        do {
+            _ = try await fetcher.fetch()
+            #expect(Bool(false), "Expected selected account decode failure")
+        } catch let error as AntigravityRemoteFetchError {
+            guard case let .parseFailed(message) = error else {
+                #expect(Bool(false), "Unexpected Antigravity error: \(error)")
+                return
+            }
+            #expect(message.contains("selected account"))
+        } catch {
+            #expect(Bool(false), "Unexpected error: \(error)")
+        }
+    }
+
+    @Test
+    func `remote fetch maps cloud code models into antigravity usage`() async throws {
+        let env = try GeminiTestEnvironment()
+        defer { env.cleanup() }
+        try env.writeAntigravityCredentials(
+            accessToken: "token",
+            refreshToken: nil,
+            expiry: Date().addingTimeInterval(3600),
+            idToken: GeminiAPITestHelpers.makeIDToken(email: "user@company.com", hostedDomain: "company.com"),
+            email: "user@company.com")
+
+        let dataLoader = GeminiAPITestHelpers.dataLoader { request in
+            guard let url = request.url, let host = url.host else {
+                throw URLError(.badURL)
+            }
+
+            switch host {
+            case "cloudcode-pa.googleapis.com":
+                if url.path == "/v1internal:loadCodeAssist" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: GeminiAPITestHelpers.jsonData([
+                            "currentTier": ["id": "standard-tier", "name": "standard"],
+                            "cloudaicompanionProject": "managed-project-123",
+                        ]))
+                }
+                if url.path == "/v1internal:fetchAvailableModels" {
+                    let body = try #require(request.httpBody)
+                    let json = try #require(JSONSerialization.jsonObject(with: body) as? [String: Any])
+                    #expect(json["project"] as? String == "managed-project-123")
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: Self.availableModelsResponse())
+                }
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            default:
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            }
+        }
+
+        let fetcher = AntigravityRemoteUsageFetcher(
+            timeout: 1,
+            homeDirectory: env.homeURL.path,
+            dataLoader: dataLoader)
+        let snapshot = try await fetcher.fetch()
+
+        #expect(snapshot.accountEmail == "user@company.com")
+        #expect(snapshot.accountPlan == "Paid")
+
+        let usage = try snapshot.toUsageSnapshot()
+        #expect(usage.primary?.remainingPercent.rounded() == 20)
+        #expect(usage.secondary?.remainingPercent.rounded() == 50)
+        #expect(usage.tertiary == nil)
+    }
+
+    @Test
+    func `remote fetch verifies full model quotas with quota endpoint`() async throws {
+        let env = try GeminiTestEnvironment()
+        defer { env.cleanup() }
+        try env.writeAntigravityCredentials(
+            accessToken: "token",
+            refreshToken: nil,
+            expiry: Date().addingTimeInterval(3600),
+            idToken: GeminiAPITestHelpers.makeIDToken(email: "user@example.com"),
+            email: "user@example.com")
+
+        final class Counter: @unchecked Sendable {
+            private let lock = NSLock()
+            private var value = 0
+
+            func increment() {
+                self.lock.lock()
+                self.value += 1
+                self.lock.unlock()
+            }
+
+            func get() -> Int {
+                self.lock.lock()
+                defer { self.lock.unlock() }
+                return self.value
+            }
+        }
+
+        let quotaCalls = Counter()
+        let dataLoader = GeminiAPITestHelpers.dataLoader { request in
+            guard let url = request.url, let host = url.host else {
+                throw URLError(.badURL)
+            }
+
+            switch host {
+            case "cloudcode-pa.googleapis.com":
+                if url.path == "/v1internal:loadCodeAssist" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: GeminiAPITestHelpers.loadCodeAssistResponse(
+                            tierId: "standard-tier",
+                            projectId: "managed-project-123"))
+                }
+                if url.path == "/v1internal:fetchAvailableModels" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: GeminiAPITestHelpers.jsonData([
+                            "models": [
+                                "claude-sonnet-4": [
+                                    "displayName": "Claude Sonnet 4",
+                                    "quotaInfo": ["remainingFraction": 1],
+                                ],
+                                "gemini-2.5-pro": [
+                                    "displayName": "Gemini 2.5 Pro",
+                                    "quotaInfo": ["remainingFraction": 1],
+                                ],
+                                "gemini-2.5-flash": [
+                                    "displayName": "Gemini 2.5 Flash",
+                                    "quotaInfo": ["remainingFraction": 1],
+                                ],
+                            ],
+                        ]))
+                }
+                if url.path == "/v1internal:retrieveUserQuota" {
+                    quotaCalls.increment()
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: GeminiAPITestHelpers.jsonData([
+                            "buckets": [
+                                [
+                                    "modelId": "claude-sonnet-4",
+                                    "resetTime": "2025-01-01T00:00:00Z",
+                                ],
+                                [
+                                    "modelId": "gemini-2.5-pro",
+                                    "remainingFraction": 0.6,
+                                    "resetTime": "2025-01-01T00:00:00Z",
+                                ],
+                                [
+                                    "modelId": "gemini-2.5-flash",
+                                    "remainingFraction": 0.9,
+                                    "resetTime": "2025-01-01T00:00:00Z",
+                                ],
+                            ],
+                        ]))
+                }
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            default:
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            }
+        }
+
+        let snapshot = try await AntigravityRemoteUsageFetcher(
+            timeout: 1,
+            homeDirectory: env.homeURL.path,
+            dataLoader: dataLoader)
+            .fetch()
+        let usage = try snapshot.toUsageSnapshot()
+
+        #expect(quotaCalls.get() == 1)
+        #expect(usage.primary?.remainingPercent == 60.0)
+        #expect(usage.secondary?.remainingPercent == 100.0)
+        #expect(usage.tertiary == nil)
+    }
+
+    @Test
+    func `remote fetch ignores full model availability when verification has no quota data`() async throws {
+        let env = try GeminiTestEnvironment()
+        defer { env.cleanup() }
+        try env.writeAntigravityCredentials(
+            accessToken: "token",
+            refreshToken: nil,
+            expiry: Date().addingTimeInterval(3600),
+            idToken: GeminiAPITestHelpers.makeIDToken(email: "user@example.com"),
+            email: "user@example.com")
+
+        let dataLoader = GeminiAPITestHelpers.dataLoader { request in
+            guard let url = request.url, let host = url.host else {
+                throw URLError(.badURL)
+            }
+
+            switch host {
+            case "cloudcode-pa.googleapis.com":
+                if url.path == "/v1internal:loadCodeAssist" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: GeminiAPITestHelpers.loadCodeAssistResponse(
+                            tierId: "standard-tier",
+                            projectId: "managed-project-123"))
+                }
+                if url.path == "/v1internal:fetchAvailableModels" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: GeminiAPITestHelpers.jsonData([
+                            "models": [
+                                "claude-sonnet-4": [
+                                    "displayName": "Claude Sonnet 4",
+                                    "quotaInfo": ["remainingFraction": 1],
+                                ],
+                                "gemini-2.5-pro": [
+                                    "displayName": "Gemini 2.5 Pro",
+                                    "quotaInfo": ["remainingFraction": 1],
+                                ],
+                            ],
+                        ]))
+                }
+                if url.path == "/v1internal:retrieveUserQuota" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: GeminiAPITestHelpers.jsonData(["buckets": []]))
+                }
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            default:
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            }
+        }
+
+        let snapshot = try await AntigravityRemoteUsageFetcher(
+            timeout: 1,
+            homeDirectory: env.homeURL.path,
+            dataLoader: dataLoader)
+            .fetch()
+
+        #expect(snapshot.modelQuotas.isEmpty)
+        #expect(snapshot.accountEmail == "user@example.com")
+    }
+
+    @Test
+    func `remote fetch propagates quota verification server errors`() async throws {
+        let env = try GeminiTestEnvironment()
+        defer { env.cleanup() }
+        try env.writeAntigravityCredentials(
+            accessToken: "token",
+            refreshToken: nil,
+            expiry: Date().addingTimeInterval(3600),
+            idToken: GeminiAPITestHelpers.makeIDToken(email: "user@example.com"),
+            email: "user@example.com")
+
+        let dataLoader = GeminiAPITestHelpers.dataLoader { request in
+            guard let url = request.url, let host = url.host else {
+                throw URLError(.badURL)
+            }
+
+            switch host {
+            case "cloudcode-pa.googleapis.com":
+                if url.path == "/v1internal:loadCodeAssist" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: GeminiAPITestHelpers.loadCodeAssistResponse(
+                            tierId: "standard-tier",
+                            projectId: "managed-project-123"))
+                }
+                if url.path == "/v1internal:fetchAvailableModels" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: GeminiAPITestHelpers.jsonData([
+                            "models": [
+                                "claude-sonnet-4": [
+                                    "displayName": "Claude Sonnet 4",
+                                    "quotaInfo": ["remainingFraction": 1],
+                                ],
+                                "gemini-2.5-pro": [
+                                    "displayName": "Gemini 2.5 Pro",
+                                    "quotaInfo": ["remainingFraction": 1],
+                                ],
+                            ],
+                        ]))
+                }
+                if url.path == "/v1internal:retrieveUserQuota" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 503,
+                        body: Data("temporary outage".utf8))
+                }
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            default:
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            }
+        }
+
+        do {
+            _ = try await AntigravityRemoteUsageFetcher(
+                timeout: 1,
+                homeDirectory: env.homeURL.path,
+                dataLoader: dataLoader)
+                .fetch()
+            Issue.record("Expected quota verification server error")
+        } catch let error as AntigravityRemoteFetchError {
+            guard case let .apiError(message) = error else {
+                Issue.record("Unexpected Antigravity error: \(error)")
+                return
+            }
+            #expect(message.contains("HTTP 503"))
+        } catch {
+            Issue.record("Unexpected error: \(error)")
+        }
+    }
+
+    @Test
+    func `remote fetch keeps full quotas when verified quota endpoint has fractions`() async throws {
+        let env = try GeminiTestEnvironment()
+        defer { env.cleanup() }
+        try env.writeAntigravityCredentials(
+            accessToken: "token",
+            refreshToken: nil,
+            expiry: Date().addingTimeInterval(3600),
+            idToken: GeminiAPITestHelpers.makeIDToken(email: "user@example.com"),
+            email: "user@example.com")
+
+        let dataLoader = GeminiAPITestHelpers.dataLoader { request in
+            guard let url = request.url, let host = url.host else {
+                throw URLError(.badURL)
+            }
+
+            switch host {
+            case "cloudcode-pa.googleapis.com":
+                if url.path == "/v1internal:loadCodeAssist" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: GeminiAPITestHelpers.loadCodeAssistResponse(
+                            tierId: "standard-tier",
+                            projectId: "managed-project-123"))
+                }
+                if url.path == "/v1internal:fetchAvailableModels" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: GeminiAPITestHelpers.jsonData([
+                            "models": [
+                                "claude-sonnet-4": [
+                                    "displayName": "Claude Sonnet 4",
+                                    "quotaInfo": ["remainingFraction": 1],
+                                ],
+                                "gemini-2.5-pro": [
+                                    "displayName": "Gemini 2.5 Pro",
+                                    "quotaInfo": ["remainingFraction": 1],
+                                ],
+                            ],
+                        ]))
+                }
+                if url.path == "/v1internal:retrieveUserQuota" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: GeminiAPITestHelpers.jsonData([
+                            "buckets": [
+                                [
+                                    "modelId": "claude-sonnet-4",
+                                    "remainingFraction": 1,
+                                    "resetTime": "2025-01-01T00:00:00Z",
+                                ],
+                                [
+                                    "modelId": "gemini-2.5-pro",
+                                    "remainingFraction": 1,
+                                    "resetTime": "2025-01-01T00:00:00Z",
+                                ],
+                            ],
+                        ]))
+                }
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            default:
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            }
+        }
+
+        let snapshot = try await AntigravityRemoteUsageFetcher(
+            timeout: 1,
+            homeDirectory: env.homeURL.path,
+            dataLoader: dataLoader)
+            .fetch()
+        let usage = try snapshot.toUsageSnapshot()
+
+        #expect(usage.primary?.remainingPercent == 100.0)
+        #expect(usage.secondary?.remainingPercent == 100.0)
+        #expect(usage.tertiary == nil)
+    }
+
+    @Test
+    func `remote fetch drops full quota rows absent from partial verification`() async throws {
+        let env = try GeminiTestEnvironment()
+        defer { env.cleanup() }
+        try env.writeAntigravityCredentials(
+            accessToken: "token",
+            refreshToken: nil,
+            expiry: Date().addingTimeInterval(3600),
+            idToken: GeminiAPITestHelpers.makeIDToken(email: "user@example.com"),
+            email: "user@example.com")
+
+        let dataLoader = GeminiAPITestHelpers.dataLoader { request in
+            guard let url = request.url else {
+                throw URLError(.badURL)
+            }
+            if url.path == "/v1internal:loadCodeAssist" {
+                return GeminiAPITestHelpers.response(
+                    url: url.absoluteString,
+                    status: 200,
+                    body: GeminiAPITestHelpers.loadCodeAssistResponse(
+                        tierId: "standard-tier",
+                        projectId: "managed-project-123"))
+            }
+            if url.path == "/v1internal:fetchAvailableModels" {
+                return GeminiAPITestHelpers.response(
+                    url: url.absoluteString,
+                    status: 200,
+                    body: GeminiAPITestHelpers.jsonData([
+                        "models": [
+                            "claude-sonnet-4": [
+                                "displayName": "Claude Sonnet 4",
+                                "quotaInfo": ["remainingFraction": 1],
+                            ],
+                            "gemini-2.5-pro": [
+                                "displayName": "Gemini 2.5 Pro",
+                                "quotaInfo": ["remainingFraction": 1],
+                            ],
+                        ],
+                    ]))
+            }
+            if url.path == "/v1internal:retrieveUserQuota" {
+                return GeminiAPITestHelpers.response(
+                    url: url.absoluteString,
+                    status: 200,
+                    body: GeminiAPITestHelpers.jsonData([
+                        "buckets": [
+                            [
+                                "modelId": "gemini-2.5-pro",
+                                "remainingFraction": 0.5,
+                            ],
+                        ],
+                    ]))
+            }
+            return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+        }
+
+        let snapshot = try await AntigravityRemoteUsageFetcher(
+            timeout: 1,
+            homeDirectory: env.homeURL.path,
+            dataLoader: dataLoader)
+            .fetch()
+
+        #expect(snapshot.modelQuotas.map(\.modelId) == ["gemini-2.5-pro"])
+        #expect(snapshot.modelQuotas.map(\.remainingFraction) == [0.5])
+    }
+
+    @Test
+    func `remote fetch refreshes expired shared google token`() async throws {
+        let env = try GeminiTestEnvironment()
+        defer { env.cleanup() }
+        try env.writeAntigravityCredentials(
+            accessToken: "old-token",
+            refreshToken: "refresh-token",
+            expiry: Date().addingTimeInterval(-3600),
+            idToken: GeminiAPITestHelpers.makeIDToken(email: "stale@example.com"),
+            email: "stale@example.com",
+            clientID: "test-client-id",
+            clientSecret: "test-client-secret")
+
+        let dataLoader = GeminiAPITestHelpers.dataLoader { request in
+            guard let url = request.url, let host = url.host else {
+                throw URLError(.badURL)
+            }
+
+            switch host {
+            case "oauth2.googleapis.com":
+                return GeminiAPITestHelpers.response(
+                    url: url.absoluteString,
+                    status: 200,
+                    body: GeminiAPITestHelpers.jsonData([
+                        "access_token": "new-token",
+                        "expires_in": 3600,
+                        "id_token": GeminiAPITestHelpers.makeIDToken(email: "refreshed@example.com"),
+                    ]))
+            case "cloudcode-pa.googleapis.com":
+                let auth = request.value(forHTTPHeaderField: "Authorization")
+                #expect(auth == "Bearer new-token")
+                if url.path == "/v1internal:loadCodeAssist" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: GeminiAPITestHelpers.jsonData([
+                            "currentTier": ["id": "standard-tier", "name": "standard"],
+                            "cloudaicompanionProject": "managed-project-123",
+                        ]))
+                }
+                if url.path == "/v1internal:fetchAvailableModels" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: Self.availableModelsResponse())
+                }
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            default:
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            }
+        }
+
+        let fetcher = AntigravityRemoteUsageFetcher(
+            timeout: 2,
+            homeDirectory: env.homeURL.path,
+            dataLoader: dataLoader)
+        let snapshot = try await fetcher.fetch()
+
+        let updated = try env.readAntigravityCredentials()
+        #expect(updated["access_token"] as? String == "new-token")
+        #expect(snapshot.accountEmail == "refreshed@example.com")
+    }
+
+    @Test
+    func `remote fetch refreshes nearly expired shared google token`() async throws {
+        let env = try GeminiTestEnvironment()
+        defer { env.cleanup() }
+        try env.writeAntigravityCredentials(
+            accessToken: "old-token",
+            refreshToken: "refresh-token",
+            expiry: Date().addingTimeInterval(5),
+            idToken: GeminiAPITestHelpers.makeIDToken(email: "stale@example.com"),
+            email: "stale@example.com",
+            clientID: "test-client-id",
+            clientSecret: "test-client-secret")
+
+        let dataLoader = GeminiAPITestHelpers.dataLoader { request in
+            guard let url = request.url, let host = url.host else {
+                throw URLError(.badURL)
+            }
+
+            switch host {
+            case "oauth2.googleapis.com":
+                return GeminiAPITestHelpers.response(
+                    url: url.absoluteString,
+                    status: 200,
+                    body: GeminiAPITestHelpers.jsonData([
+                        "access_token": "new-token",
+                        "expires_in": 3600,
+                        "id_token": GeminiAPITestHelpers.makeIDToken(email: "refreshed@example.com"),
+                    ]))
+            case "cloudcode-pa.googleapis.com":
+                #expect(request.value(forHTTPHeaderField: "Authorization") == "Bearer new-token")
+                if url.path == "/v1internal:loadCodeAssist" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: GeminiAPITestHelpers.jsonData([
+                            "currentTier": ["id": "standard-tier", "name": "standard"],
+                            "cloudaicompanionProject": "managed-project-123",
+                        ]))
+                }
+                if url.path == "/v1internal:fetchAvailableModels" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: Self.availableModelsResponse())
+                }
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            default:
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            }
+        }
+
+        let fetcher = AntigravityRemoteUsageFetcher(
+            timeout: 2,
+            homeDirectory: env.homeURL.path,
+            dataLoader: dataLoader)
+        let snapshot = try await fetcher.fetch()
+
+        let updated = try env.readAntigravityCredentials()
+        #expect(updated["access_token"] as? String == "new-token")
+        #expect(snapshot.accountEmail == "refreshed@example.com")
+    }
+
+    @Test
+    func `remote refresh requires configured oauth client`() async throws {
+        let env = try GeminiTestEnvironment()
+        defer { env.cleanup() }
+        try env.writeAntigravityCredentials(
+            accessToken: "old-token",
+            refreshToken: "refresh-token",
+            expiry: Date().addingTimeInterval(-3600),
+            idToken: GeminiAPITestHelpers.makeIDToken(email: "user@example.com"),
+            email: "user@example.com")
+
+        let fetcher = AntigravityRemoteUsageFetcher(
+            timeout: 1,
+            homeDirectory: env.homeURL.path,
+            dataLoader: GeminiAPITestHelpers.dataLoader { _ in
+                throw URLError(.badServerResponse)
+            },
+            oauthClientResolver: { nil })
+
+        do {
+            _ = try await fetcher.fetch()
+            #expect(Bool(false), "Expected missing OAuth client configuration error")
+        } catch let error as AntigravityRemoteFetchError {
+            guard case let .apiError(message) = error else {
+                #expect(Bool(false), "Unexpected Antigravity error: \(error)")
+                return
+            }
+            #expect(message.contains("ANTIGRAVITY_OAUTH_CLIENT_ID"))
+        } catch {
+            #expect(Bool(false), "Unexpected error: \(error)")
+        }
+    }
+
+    @Test
+    func `remote fetch onboards project before fetching models`() async throws {
+        let env = try GeminiTestEnvironment()
+        defer { env.cleanup() }
+        try env.writeAntigravityCredentials(
+            accessToken: "token",
+            refreshToken: nil,
+            expiry: Date().addingTimeInterval(3600),
+            idToken: GeminiAPITestHelpers.makeIDToken(email: "user@example.com"),
+            email: "user@example.com")
+
+        final class Recorder: @unchecked Sendable {
+            private let lock = NSLock()
+            private var projects: [String] = []
+
+            func append(_ value: String) {
+                self.lock.lock()
+                self.projects.append(value)
+                self.lock.unlock()
+            }
+
+            func last() -> String? {
+                self.lock.lock()
+                defer { self.lock.unlock() }
+                return self.projects.last
+            }
+        }
+
+        let recorder = Recorder()
+        let dataLoader = GeminiAPITestHelpers.dataLoader { request in
+            guard let url = request.url, let host = url.host else {
+                throw URLError(.badURL)
+            }
+
+            switch host {
+            case "cloudcode-pa.googleapis.com":
+                if url.path == "/v1internal:loadCodeAssist" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: GeminiAPITestHelpers.jsonData([
+                            "currentTier": ["id": "standard-tier", "name": "standard"],
+                            "allowedTiers": [["id": "standard-tier", "isDefault": true]],
+                        ]))
+                }
+                if url.path == "/v1internal:onboardUser" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: GeminiAPITestHelpers.jsonData([
+                            "response": [
+                                "cloudaicompanionProject": [
+                                    "id": "onboarded-project-456",
+                                ],
+                            ],
+                        ]))
+                }
+                if url.path == "/v1internal:fetchAvailableModels" {
+                    let body = try #require(request.httpBody)
+                    let json = try #require(JSONSerialization.jsonObject(with: body) as? [String: Any])
+                    if let project = json["project"] as? String {
+                        recorder.append(project)
+                    }
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: Self.availableModelsResponse())
+                }
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            default:
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            }
+        }
+
+        let fetcher = AntigravityRemoteUsageFetcher(
+            timeout: 1,
+            homeDirectory: env.homeURL.path,
+            dataLoader: dataLoader)
+        _ = try await fetcher.fetch()
+
+        #expect(recorder.last() == "onboarded-project-456")
+    }
+
+    @Test
+    func `remote fetch falls back to retrieve user quota when model endpoint is forbidden`() async throws {
+        let env = try GeminiTestEnvironment()
+        defer { env.cleanup() }
+        try env.writeAntigravityCredentials(
+            accessToken: "token",
+            refreshToken: nil,
+            expiry: Date().addingTimeInterval(3600),
+            idToken: GeminiAPITestHelpers.makeIDToken(email: "user@example.com"),
+            email: "user@example.com")
+
+        final class Counter: @unchecked Sendable {
+            private let lock = NSLock()
+            private var value = 0
+
+            func increment() {
+                self.lock.lock()
+                self.value += 1
+                self.lock.unlock()
+            }
+
+            func get() -> Int {
+                self.lock.lock()
+                defer { self.lock.unlock() }
+                return self.value
+            }
+        }
+
+        let quotaCalls = Counter()
+        let dataLoader = GeminiAPITestHelpers.dataLoader { request in
+            guard let url = request.url, let host = url.host else {
+                throw URLError(.badURL)
+            }
+
+            switch host {
+            case "cloudcode-pa.googleapis.com":
+                if url.path == "/v1internal:loadCodeAssist" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: GeminiAPITestHelpers.jsonData([
+                            "currentTier": ["id": "standard-tier", "name": "standard"],
+                            "cloudaicompanionProject": "managed-project-123",
+                        ]))
+                }
+                if url.path == "/v1internal:fetchAvailableModels" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 403,
+                        body: GeminiAPITestHelpers.jsonData([
+                            "error": [
+                                "code": 403,
+                                "message": "The caller does not have permission",
+                                "status": "PERMISSION_DENIED",
+                            ],
+                        ]))
+                }
+                if url.path == "/v1internal:retrieveUserQuota" {
+                    quotaCalls.increment()
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: GeminiAPITestHelpers.sampleQuotaResponse())
+                }
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            default:
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            }
+        }
+
+        let fetcher = AntigravityRemoteUsageFetcher(
+            timeout: 1,
+            homeDirectory: env.homeURL.path,
+            dataLoader: dataLoader)
+        let snapshot = try await fetcher.fetch()
+        let usage = try snapshot.toUsageSnapshot()
+
+        #expect(quotaCalls.get() == 1)
+        #expect(usage.primary?.remainingPercent == 60.0)
+        #expect(usage.secondary == nil)
+        #expect(usage.tertiary == nil)
+    }
+
+    @Test
+    func `antigravity descriptor advertises oauth mode`() {
+        let descriptor = ProviderDescriptorRegistry.descriptor(for: .antigravity)
+        #expect(descriptor.fetchPlan.sourceModes == [.auto, .cli, .oauth])
+    }
+
+    @Test
+    func `remote fetch returns identity when both remote quota endpoints are forbidden`() async throws {
+        let env = try GeminiTestEnvironment()
+        defer { env.cleanup() }
+        try env.writeAntigravityCredentials(
+            accessToken: "token",
+            refreshToken: nil,
+            expiry: Date().addingTimeInterval(3600),
+            idToken: GeminiAPITestHelpers.makeIDToken(email: "user@example.com"),
+            email: "user@example.com")
+
+        let dataLoader = GeminiAPITestHelpers.dataLoader { request in
+            guard let url = request.url, let host = url.host else {
+                throw URLError(.badURL)
+            }
+
+            switch host {
+            case "cloudcode-pa.googleapis.com":
+                if url.path == "/v1internal:loadCodeAssist" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: GeminiAPITestHelpers.jsonData([
+                            "currentTier": ["id": "standard-tier", "name": "standard"],
+                            "cloudaicompanionProject": "managed-project-123",
+                        ]))
+                }
+                if url.path == "/v1internal:fetchAvailableModels" || url.path == "/v1internal:retrieveUserQuota" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 403,
+                        body: GeminiAPITestHelpers.jsonData([
+                            "error": [
+                                "code": 403,
+                                "message": "The caller does not have permission",
+                                "status": "PERMISSION_DENIED",
+                            ],
+                        ]))
+                }
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            default:
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            }
+        }
+
+        let snapshot = try await AntigravityRemoteUsageFetcher(
+            timeout: 1,
+            homeDirectory: env.homeURL.path,
+            dataLoader: dataLoader)
+            .fetch()
+        let usage = try AntigravityOAuthFetchStrategy.usageSnapshot(from: snapshot)
+
+        #expect(snapshot.modelQuotas.isEmpty)
+        #expect(snapshot.accountEmail == "user@example.com")
+        #expect(snapshot.accountPlan == "Paid")
+        #expect(usage.rateLimitsUnavailable(for: .antigravity))
+    }
+
+    @Test
+    func `remote fetch ignores gemini credentials when antigravity auth is missing`() async throws {
+        let env = try GeminiTestEnvironment()
+        defer { env.cleanup() }
+        try env.writeCredentials(
+            accessToken: "gemini-token",
+            refreshToken: nil,
+            expiry: Date().addingTimeInterval(3600),
+            idToken: GeminiAPITestHelpers.makeIDToken(email: "gemini@example.com"))
+
+        let fetcher = AntigravityRemoteUsageFetcher(
+            timeout: 1,
+            homeDirectory: env.homeURL.path,
+            dataLoader: GeminiAPITestHelpers.dataLoader { _ in
+                throw URLError(.badServerResponse)
+            })
+
+        await #expect(throws: AntigravityRemoteFetchError.notLoggedIn) {
+            try await fetcher.fetch()
+        }
+    }
+
+    @Test
+    func `remote fetch prefers stored project id from antigravity credentials`() async throws {
+        let env = try GeminiTestEnvironment()
+        defer { env.cleanup() }
+        try env.writeAntigravityCredentials(
+            accessToken: "token",
+            refreshToken: nil,
+            expiry: Date().addingTimeInterval(3600),
+            idToken: GeminiAPITestHelpers.makeIDToken(email: "user@example.com"),
+            email: "user@example.com",
+            projectID: "stored-project-789")
+
+        final class Recorder: @unchecked Sendable {
+            private let lock = NSLock()
+            private var projects: [String] = []
+
+            func append(_ value: String) {
+                self.lock.lock()
+                self.projects.append(value)
+                self.lock.unlock()
+            }
+
+            func last() -> String? {
+                self.lock.lock()
+                defer { self.lock.unlock() }
+                return self.projects.last
+            }
+        }
+
+        let recorder = Recorder()
+        let dataLoader = GeminiAPITestHelpers.dataLoader { request in
+            guard let url = request.url, let host = url.host else {
+                throw URLError(.badURL)
+            }
+
+            switch host {
+            case "cloudcode-pa.googleapis.com":
+                if url.path == "/v1internal:loadCodeAssist" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: GeminiAPITestHelpers.jsonData([
+                            "currentTier": ["id": "standard-tier", "name": "standard"],
+                        ]))
+                }
+                if url.path == "/v1internal:fetchAvailableModels" {
+                    let body = try #require(request.httpBody)
+                    let json = try #require(JSONSerialization.jsonObject(with: body) as? [String: Any])
+                    if let project = json["project"] as? String {
+                        recorder.append(project)
+                    }
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: Self.availableModelsResponse())
+                }
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            default:
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            }
+        }
+
+        _ = try await AntigravityRemoteUsageFetcher(
+            timeout: 1,
+            homeDirectory: env.homeURL.path,
+            dataLoader: dataLoader)
+            .fetch()
+
+        #expect(recorder.last() == "stored-project-789")
+    }
+
+    private static func availableModelsResponse() -> Data {
+        GeminiAPITestHelpers.jsonData([
+            "models": [
+                "claude-sonnet-4": [
+                    "displayName": "Claude Sonnet 4",
+                    "quotaInfo": [
+                        "remainingFraction": 0.5,
+                        "resetTime": "2025-01-01T00:00:00Z",
+                    ],
+                ],
+                "gemini-3-pro-low": [
+                    "displayName": "Gemini 3 Pro Low",
+                    "quotaInfo": [
+                        "remainingFraction": 0.8,
+                        "resetTime": "2025-01-01T00:00:00Z",
+                    ],
+                ],
+                "gemini-3-flash": [
+                    "displayName": "Gemini 3 Flash",
+                    "quotaInfo": [
+                        "remainingFraction": 0.2,
+                        "resetTime": "2025-01-01T00:00:00Z",
+                    ],
+                ],
+                "gemini-3-flash-lite": [
+                    "displayName": "Gemini 3 Flash Lite",
+                    "quotaInfo": [
+                        "remainingFraction": 0.7,
+                        "resetTime": "2025-01-01T00:00:00Z",
+                    ],
+                ],
+            ],
+        ])
+    }
+}
diff --git a/Tests/CodexBarTests/AntigravityStatusProbeTests.swift b/Tests/CodexBarTests/AntigravityStatusProbeTests.swift
index d69a3041f9..5182cef097 100644
--- a/Tests/CodexBarTests/AntigravityStatusProbeTests.swift
+++ b/Tests/CodexBarTests/AntigravityStatusProbeTests.swift
@@ -1,11 +1,721 @@
-import CodexBarCore
 import Foundation
 import Testing
+@testable import CodexBarCore
+
+private final class AntigravityAttemptRecorder: @unchecked Sendable {
+    private let lock = NSLock()
+    private var endpoints: [AntigravityStatusProbe.AntigravityConnectionEndpoint] = []
+
+    func append(_ endpoint: AntigravityStatusProbe.AntigravityConnectionEndpoint) {
+        self.lock.lock()
+        self.endpoints.append(endpoint)
+        self.lock.unlock()
+    }
+
+    func snapshot() -> [AntigravityStatusProbe.AntigravityConnectionEndpoint] {
+        self.lock.lock()
+        let snapshot = self.endpoints
+        self.lock.unlock()
+        return snapshot
+    }
+}
 
-@Suite
 struct AntigravityStatusProbeTests {
     @Test
-    func parsesUserStatusResponse() throws {
+    func `process detection accepts antigravity 2 unsuffixed language server`() {
+        let command = """
+        /Applications/Antigravity.app/Contents/Resources/bin/language_server --standalone \
+        --override_ide_name antigravity --override_ide_version 2.0.0 \
+        --csrf_token token --app_data_dir antigravity
+        """
+
+        #expect(AntigravityStatusProbe.isAntigravityLanguageServerCommandLine(command))
+    }
+
+    @Test
+    func `process detection accepts antigravity language server paths with spaces`() {
+        let command = """
+        /Applications/Google Antigravity.app/Contents/Resources/bin/language_server --standalone \
+        --override_ide_name antigravity --csrf_token token --app_data_dir antigravity
+        """
+
+        #expect(AntigravityStatusProbe.isAntigravityLanguageServerCommandLine(command))
+    }
+
+    @Test
+    func `process detection accepts hyphenated language server from app bundle`() throws {
+        let command = """
+        /Applications/Google Antigravity.app/Contents/Resources/bin/language-server --standalone \
+        --csrf_token token --extension_server_port 64123
+        """
+
+        #expect(AntigravityStatusProbe.isAntigravityLanguageServerCommandLine(command))
+
+        let result = try AntigravityStatusProbe.processInfo(fromProcessListOutput: "  321 \(command)")
+        #expect(result.pid == 321)
+        #expect(result.csrfToken == "token")
+        #expect(result.extensionPort == 64123)
+    }
+
+    @Test
+    func `process detection keeps ignoring non language server antigravity helpers`() {
+        let helper = """
+        /Applications/Antigravity.app/Contents/Frameworks/Antigravity Helper.app/Contents/MacOS/Antigravity Helper \
+        --type=renderer --user-data-dir=/Users/test/Library/Application Support/Antigravity
+        """
+
+        #expect(!AntigravityStatusProbe.isAntigravityLanguageServerCommandLine(helper))
+    }
+
+    @Test
+    func `process detection still accepts legacy antigravity language server`() {
+        let command = """
+        /Applications/Antigravity.app/Contents/Resources/bin/language_server_macos \
+        --csrf_token token --app_data_dir antigravity
+        """
+
+        #expect(AntigravityStatusProbe.isAntigravityLanguageServerCommandLine(command))
+    }
+
+    @Test
+    func `process detection accepts platform suffixed antigravity language server`() throws {
+        let output = """
+          101 /Applications/Antigravity.app/Contents/Resources/bin/language_server_macos_arm \
+          --csrf_token ide-token --app_data_dir antigravity --extension_server_port 54977
+        """
+
+        let result = try AntigravityStatusProbe.processInfo(fromProcessListOutput: output, scope: .appOnly)
+
+        #expect(result.pid == 101)
+        #expect(result.csrfToken == "ide-token")
+        #expect(result.extensionPort == 54977)
+    }
+
+    @Test
+    func `process detection accepts antigravity cli without csrf token`() {
+        // The CLI launches its language server without a `--csrf_token` flag.
+        let node = """
+        node /Users/test/.gemini/antigravity-cli/build/mcp-server.cjs \
+        --app_data_dir /Users/test/.gemini/antigravity
+        """
+        #expect(AntigravityStatusProbe.isAntigravityLanguageServerCommandLine(node))
+
+        let agy = "/Users/test/.local/bin/agy -p hello"
+        #expect(AntigravityStatusProbe.isAntigravityLanguageServerCommandLine(agy))
+
+        let agyUnderscore = "/usr/local/bin/agy --app_data_dir /Users/test/.gemini/antigravity_cli"
+        #expect(AntigravityStatusProbe.isAntigravityLanguageServerCommandLine(agyUnderscore))
+    }
+
+    @Test
+    func `process detection ignores unrelated binaries containing agy substring`() {
+        // "agy" must be path-anchored so unrelated commands do not match.
+        #expect(!AntigravityStatusProbe.isAntigravityLanguageServerCommandLine("/usr/bin/legacy --run"))
+        #expect(!AntigravityStatusProbe.isAntigravityLanguageServerCommandLine("/opt/imagymagic/bin/tool"))
+    }
+
+    @Test
+    func `process detection ignores cli names outside explicit cli path segments`() {
+        #expect(
+            !AntigravityStatusProbe.isAntigravityLanguageServerCommandLine(
+                "/usr/bin/node /tmp/not-antigravity-cli/build/server.js"))
+        #expect(
+            !AntigravityStatusProbe.isAntigravityLanguageServerCommandLine(
+                "/usr/bin/helper --workspace antigravity-cli"))
+    }
+
+    @Test
+    func `process kind distinguishes app ide language server and cli`() {
+        let app = """
+        /Applications/Antigravity.app/Contents/Resources/bin/language_server \
+        --csrf_token token --app_data_dir antigravity
+        """
+        let ide = """
+        /Applications/Antigravity IDE.app/Contents/Resources/app/extensions/antigravity/bin/language_server_macos_arm \
+        --csrf_token token --app_data_dir antigravity-ide
+        """
+        #expect(AntigravityStatusProbe.antigravityProcessKind(app) == .app)
+        #expect(AntigravityStatusProbe.antigravityProcessKind(ide) == .ide)
+        #expect(AntigravityStatusProbe.antigravityProcessKind("/Users/test/.local/bin/agy -p hi") == .cli)
+        #expect(
+            AntigravityStatusProbe.antigravityProcessKind(
+                "node /x/.gemini/antigravity-cli/build/mcp-server.cjs --app_data_dir /x/.gemini/antigravity") == .cli)
+        #expect(AntigravityStatusProbe.antigravityProcessKind("/usr/bin/legacy --run") == nil)
+    }
+
+    @Test
+    func `csrf token stays required for ide but optional for cli`() {
+        // Desktop app/IDE with a token returns it.
+        let appWithToken = """
+        /Applications/Antigravity.app/Contents/Resources/bin/language_server \
+        --csrf_token ide-token --app_data_dir antigravity
+        """
+        #expect(AntigravityStatusProbe.resolvedCSRFToken(forKind: .app, command: appWithToken) == "ide-token")
+
+        // Tokenless desktop app is skipped (nil) so detection keeps scanning for a valid
+        // server and preserves the missing-token diagnostic - no empty-token probe.
+        let appNoToken = """
+        /Applications/Antigravity.app/Contents/Resources/bin/language_server \
+        --app_data_dir antigravity
+        """
+        #expect(AntigravityStatusProbe.resolvedCSRFToken(forKind: .app, command: appNoToken) == nil)
+
+        // CLI without a token resolves to an empty token (its server needs none).
+        #expect(
+            AntigravityStatusProbe.resolvedCSRFToken(
+                forKind: .cli, command: "/Users/test/.local/bin/agy -p hi")?.isEmpty == true)
+
+        // A CLI that does carry a token still uses it.
+        #expect(
+            AntigravityStatusProbe.resolvedCSRFToken(
+                forKind: .cli, command: "/Users/test/.local/bin/agy --csrf_token cli-token") == "cli-token")
+    }
+
+    @Test
+    func `process scan skips tokenless ide before later valid ide`() throws {
+        let tokenlessIDE =
+            "  100 /Applications/Antigravity.app/Contents/Resources/bin/language_server --app_data_dir antigravity"
+        let validIDE = "  101 /Applications/Antigravity.app/Contents/Resources/bin/language_server " +
+            "--csrf_token ide-token --app_data_dir antigravity " +
+            "--extension_server_port 64432 --extension_server_csrf_token extension-token"
+        let output = [tokenlessIDE, validIDE].joined(separator: "\n")
+
+        let result = try AntigravityStatusProbe.processInfo(fromProcessListOutput: output)
+
+        #expect(result.pid == 101)
+        #expect(result.csrfToken == "ide-token")
+        #expect(result.extensionPort == 64432)
+        #expect(result.extensionServerCSRFToken == "extension-token")
+    }
+
+    @Test
+    func `process scan returns all valid app candidates`() throws {
+        let firstApp = "  101 /Applications/Antigravity.app/Contents/Resources/bin/language_server " +
+            "--csrf_token first-token --app_data_dir antigravity"
+        let secondApp = "  102 /Applications/Antigravity.app/Contents/Resources/bin/language_server " +
+            "--csrf_token second-token --app_data_dir antigravity " +
+            "--extension_server_port 64432 --extension_server_csrf_token extension-token"
+        let output = [firstApp, secondApp].joined(separator: "\n")
+
+        let results = try AntigravityStatusProbe.processInfos(fromProcessListOutput: output, scope: .appOnly)
+
+        #expect(results.map(\.pid) == [101, 102])
+        #expect(results.map(\.csrfToken) == ["first-token", "second-token"])
+        #expect(results.last?.extensionPort == 64432)
+        #expect(results.last?.extensionServerCSRFToken == "extension-token")
+    }
+
+    @Test
+    func `local snapshot score prefers quota summary over legacy model quotas`() {
+        let legacy = AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "Gemini 3 Pro Low",
+                    modelId: "gemini-3-pro-low",
+                    remainingFraction: 0.9,
+                    resetTime: Date(timeIntervalSince1970: 1_700_000_000),
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Claude Sonnet",
+                    modelId: "claude-sonnet",
+                    remainingFraction: 0.5,
+                    resetTime: Date(timeIntervalSince1970: 1_700_000_000),
+                    resetDescription: nil),
+            ],
+            accountEmail: "user@example.com",
+            accountPlan: "Pro",
+            source: .local)
+        let summary = AntigravityStatusSnapshot(
+            quotaSummary: AntigravityQuotaSummary(
+                description: nil,
+                groups: [
+                    AntigravityQuotaSummaryGroup(
+                        displayName: "Gemini Models",
+                        description: nil,
+                        buckets: [
+                            AntigravityQuotaSummaryBucket(
+                                bucketId: "gemini-5h",
+                                displayName: "Five Hour Limit",
+                                remainingFraction: 0.9,
+                                resetDescription: nil,
+                                disabled: false),
+                            AntigravityQuotaSummaryBucket(
+                                bucketId: "gemini-weekly",
+                                displayName: "Weekly Limit",
+                                remainingFraction: 0.8,
+                                resetDescription: nil,
+                                disabled: false),
+                        ]),
+                    AntigravityQuotaSummaryGroup(
+                        displayName: "Claude and GPT models",
+                        description: nil,
+                        buckets: [
+                            AntigravityQuotaSummaryBucket(
+                                bucketId: "3p-5h",
+                                displayName: "Five Hour Limit",
+                                remainingFraction: 0.7,
+                                resetDescription: nil,
+                                disabled: false),
+                            AntigravityQuotaSummaryBucket(
+                                bucketId: "3p-weekly",
+                                displayName: "Weekly Limit",
+                                remainingFraction: 0.6,
+                                resetDescription: nil,
+                                disabled: false),
+                        ]),
+                ]),
+            accountEmail: "user@example.com",
+            accountPlan: "Pro",
+            source: .local)
+
+        #expect(AntigravityStatusProbe.localSnapshotScore(summary) > AntigravityStatusProbe.localSnapshotScore(legacy))
+    }
+
+    @Test
+    func `process scan reports missing csrf when only tokenless ide matches`() {
+        let output = """
+          100 /Applications/Antigravity.app/Contents/Resources/bin/language_server --app_data_dir antigravity
+        """
+
+        #expect(throws: AntigravityStatusProbeError.missingCSRFToken) {
+            try AntigravityStatusProbe.processInfo(fromProcessListOutput: output)
+        }
+    }
+
+    @Test
+    func `process scan allows empty csrf only for explicit cli match`() throws {
+        let output = """
+          200 /Users/test/.local/bin/agy -p hello
+        """
+
+        let result = try AntigravityStatusProbe.processInfo(fromProcessListOutput: output)
+
+        #expect(result.pid == 200)
+        #expect(result.csrfToken.isEmpty)
+        #expect(result.commandLine == "/Users/test/.local/bin/agy -p hello")
+    }
+
+    @Test
+    func `ideOnly scope skips app and cli processes and reports not running`() {
+        let output = "  200 /Users/test/.local/bin/agy -p hello"
+
+        #expect(throws: AntigravityStatusProbeError.notRunning) {
+            try AntigravityStatusProbe.processInfo(fromProcessListOutput: output, scope: .ideOnly)
+        }
+
+        let app = "  101 /Applications/Antigravity.app/Contents/Resources/bin/language_server " +
+            "--csrf_token app-token --app_data_dir antigravity"
+        #expect(throws: AntigravityStatusProbeError.notRunning) {
+            try AntigravityStatusProbe.processInfo(fromProcessListOutput: app, scope: .ideOnly)
+        }
+    }
+
+    @Test
+    func `ideOnly scope still matches ide server listed after cli and app processes`() throws {
+        let cli = "  200 /Users/test/.local/bin/agy -p hello"
+        let app = "  101 /Applications/Antigravity.app/Contents/Resources/bin/language_server " +
+            "--csrf_token app-token --app_data_dir antigravity"
+        let ide = "  102 /Applications/Antigravity IDE.app/Contents/Resources/app/extensions/antigravity/bin/" +
+            "language_server_macos_arm " +
+            "--csrf_token ide-token --app_data_dir antigravity"
+        let output = cli + "\n" + app + "\n" + ide
+
+        let result = try AntigravityStatusProbe.processInfo(fromProcessListOutput: output, scope: .ideOnly)
+
+        #expect(result.pid == 102)
+        #expect(result.csrfToken == "ide-token")
+    }
+
+    @Test
+    func `appOnly scope skips ide and cli processes`() throws {
+        let cli = "  200 /Users/test/.local/bin/agy -p hello"
+        let ide = "  102 /Applications/Antigravity IDE.app/Contents/Resources/app/extensions/antigravity/bin/" +
+            "language_server_macos_arm --csrf_token ide-token --app_data_dir antigravity-ide"
+        let app = "  101 /Applications/Antigravity.app/Contents/Resources/bin/language_server " +
+            "--csrf_token app-token --app_data_dir antigravity"
+        let output = cli + "\n" + ide + "\n" + app
+
+        let result = try AntigravityStatusProbe.processInfo(fromProcessListOutput: output, scope: .appOnly)
+
+        #expect(result.pid == 101)
+        #expect(result.csrfToken == "app-token")
+    }
+}
+
+extension AntigravityStatusProbeTests {
+    @Test
+    func `localhost trust policy only accepts local server trust challenges`() {
+        #expect(
+            LocalhostTrustPolicy.shouldAcceptServerTrust(
+                host: "127.0.0.1",
+                authenticationMethod: NSURLAuthenticationMethodServerTrust,
+                hasServerTrust: true))
+        #expect(
+            LocalhostTrustPolicy.shouldAcceptServerTrust(
+                host: "LOCALHOST",
+                authenticationMethod: NSURLAuthenticationMethodServerTrust,
+                hasServerTrust: true))
+
+        #expect(
+            !LocalhostTrustPolicy.shouldAcceptServerTrust(
+                host: "cursor.com",
+                authenticationMethod: NSURLAuthenticationMethodServerTrust,
+                hasServerTrust: true))
+        #expect(
+            !LocalhostTrustPolicy.shouldAcceptServerTrust(
+                host: "127.0.0.1",
+                authenticationMethod: NSURLAuthenticationMethodHTTPBasic,
+                hasServerTrust: true))
+        #expect(
+            !LocalhostTrustPolicy.shouldAcceptServerTrust(
+                host: "127.0.0.1",
+                authenticationMethod: NSURLAuthenticationMethodServerTrust,
+                hasServerTrust: false))
+    }
+
+    @Test
+    func `localhost trust policy rejects non loopback hostnames that contain localhost`() {
+        #expect(
+            !LocalhostTrustPolicy.shouldAcceptServerTrust(
+                host: "localhost.example.com",
+                authenticationMethod: NSURLAuthenticationMethodServerTrust,
+                hasServerTrust: true))
+    }
+
+    @Test
+    func `connection candidates preserve scheme order and endpoint tokens`() {
+        let candidates = AntigravityStatusProbe.connectionCandidates(
+            listeningPorts: [64440],
+            languageServerCSRFToken: "language-token",
+            extensionServerPort: 64432,
+            extensionServerCSRFToken: "extension-token")
+
+        #expect(
+            candidates == [
+                AntigravityStatusProbe.AntigravityConnectionEndpoint(
+                    scheme: "https",
+                    port: 64440,
+                    csrfToken: "language-token",
+                    source: .languageServer),
+                AntigravityStatusProbe.AntigravityConnectionEndpoint(
+                    scheme: "http",
+                    port: 64432,
+                    csrfToken: "extension-token",
+                    source: .extensionServer),
+                AntigravityStatusProbe.AntigravityConnectionEndpoint(
+                    scheme: "http",
+                    port: 64432,
+                    csrfToken: "language-token",
+                    source: .extensionServer),
+            ])
+    }
+
+    @Test
+    func `connection candidates restrict plain http probing to the declared extension port`() {
+        let candidates = AntigravityStatusProbe.connectionCandidates(
+            listeningPorts: [64440, 64441],
+            languageServerCSRFToken: "language-token",
+            extensionServerPort: 64432,
+            extensionServerCSRFToken: nil)
+
+        #expect(
+            candidates == [
+                AntigravityStatusProbe.AntigravityConnectionEndpoint(
+                    scheme: "https",
+                    port: 64440,
+                    csrfToken: "language-token",
+                    source: .languageServer),
+                AntigravityStatusProbe.AntigravityConnectionEndpoint(
+                    scheme: "https",
+                    port: 64441,
+                    csrfToken: "language-token",
+                    source: .languageServer),
+                AntigravityStatusProbe.AntigravityConnectionEndpoint(
+                    scheme: "http",
+                    port: 64432,
+                    csrfToken: "language-token",
+                    source: .extensionServer),
+            ])
+    }
+
+    @Test
+    func `connection candidates preserve extension fallback when extension token is unavailable`() {
+        let candidates = AntigravityStatusProbe.connectionCandidates(
+            listeningPorts: [64440],
+            languageServerCSRFToken: "language-token",
+            extensionServerPort: 64432,
+            extensionServerCSRFToken: nil)
+
+        #expect(
+            candidates == [
+                AntigravityStatusProbe.AntigravityConnectionEndpoint(
+                    scheme: "https",
+                    port: 64440,
+                    csrfToken: "language-token",
+                    source: .languageServer),
+                AntigravityStatusProbe.AntigravityConnectionEndpoint(
+                    scheme: "http",
+                    port: 64432,
+                    csrfToken: "language-token",
+                    source: .extensionServer),
+            ])
+    }
+
+    @Test
+    func `connection candidates do not duplicate the same http target when ports overlap`() {
+        let candidates = AntigravityStatusProbe.connectionCandidates(
+            listeningPorts: [64432],
+            languageServerCSRFToken: "language-token",
+            extensionServerPort: 64432,
+            extensionServerCSRFToken: nil)
+
+        #expect(
+            candidates == [
+                AntigravityStatusProbe.AntigravityConnectionEndpoint(
+                    scheme: "https",
+                    port: 64432,
+                    csrfToken: "language-token",
+                    source: .languageServer),
+                AntigravityStatusProbe.AntigravityConnectionEndpoint(
+                    scheme: "http",
+                    port: 64432,
+                    csrfToken: "language-token",
+                    source: .extensionServer),
+            ])
+    }
+
+    @Test
+    func `request endpoints retry extension server after language server success`() {
+        let resolvedEndpoint = AntigravityStatusProbe.AntigravityConnectionEndpoint(
+            scheme: "https",
+            port: 64440,
+            csrfToken: "language-token",
+            source: .languageServer)
+
+        let endpoints = AntigravityStatusProbe.requestEndpoints(
+            resolvedEndpoint: resolvedEndpoint,
+            listeningPorts: [64440],
+            languageServerCSRFToken: "language-token",
+            extensionServerPort: 64432,
+            extensionServerCSRFToken: "extension-token")
+
+        #expect(
+            endpoints == [
+                resolvedEndpoint,
+                AntigravityStatusProbe.AntigravityConnectionEndpoint(
+                    scheme: "http",
+                    port: 64432,
+                    csrfToken: "extension-token",
+                    source: .extensionServer),
+                AntigravityStatusProbe.AntigravityConnectionEndpoint(
+                    scheme: "http",
+                    port: 64432,
+                    csrfToken: "language-token",
+                    source: .extensionServer),
+            ])
+    }
+
+    @Test
+    func `request endpoints preserve extension fallback when extension token is unavailable`() {
+        let resolvedEndpoint = AntigravityStatusProbe.AntigravityConnectionEndpoint(
+            scheme: "https",
+            port: 64440,
+            csrfToken: "language-token",
+            source: .languageServer)
+
+        let endpoints = AntigravityStatusProbe.requestEndpoints(
+            resolvedEndpoint: resolvedEndpoint,
+            listeningPorts: [64440],
+            languageServerCSRFToken: "language-token",
+            extensionServerPort: 64432,
+            extensionServerCSRFToken: nil)
+
+        #expect(
+            endpoints == [
+                resolvedEndpoint,
+                AntigravityStatusProbe.AntigravityConnectionEndpoint(
+                    scheme: "http",
+                    port: 64432,
+                    csrfToken: "language-token",
+                    source: .extensionServer),
+            ])
+    }
+
+    @Test
+    func `request endpoints retry alternate token after extension server wins discovery`() {
+        let resolvedEndpoint = AntigravityStatusProbe.AntigravityConnectionEndpoint(
+            scheme: "http",
+            port: 64432,
+            csrfToken: "extension-token",
+            source: .extensionServer)
+
+        let endpoints = AntigravityStatusProbe.requestEndpoints(
+            resolvedEndpoint: resolvedEndpoint,
+            listeningPorts: [64440],
+            languageServerCSRFToken: "language-token",
+            extensionServerPort: 64432,
+            extensionServerCSRFToken: "extension-token")
+
+        #expect(
+            endpoints == [
+                resolvedEndpoint,
+                AntigravityStatusProbe.AntigravityConnectionEndpoint(
+                    scheme: "http",
+                    port: 64432,
+                    csrfToken: "language-token",
+                    source: .extensionServer),
+                AntigravityStatusProbe.AntigravityConnectionEndpoint(
+                    scheme: "https",
+                    port: 64440,
+                    csrfToken: "language-token",
+                    source: .languageServer),
+            ])
+    }
+
+    @Test
+    func `request endpoints keep https language server fallback after extension probe wins`() {
+        let resolvedEndpoint = AntigravityStatusProbe.AntigravityConnectionEndpoint(
+            scheme: "http",
+            port: 64432,
+            csrfToken: "language-token",
+            source: .extensionServer)
+
+        let endpoints = AntigravityStatusProbe.requestEndpoints(
+            resolvedEndpoint: resolvedEndpoint,
+            listeningPorts: [64432, 64440],
+            languageServerCSRFToken: "language-token",
+            extensionServerPort: 64432,
+            extensionServerCSRFToken: nil)
+
+        #expect(
+            endpoints == [
+                resolvedEndpoint,
+                AntigravityStatusProbe.AntigravityConnectionEndpoint(
+                    scheme: "https",
+                    port: 64432,
+                    csrfToken: "language-token",
+                    source: .languageServer),
+                AntigravityStatusProbe.AntigravityConnectionEndpoint(
+                    scheme: "https",
+                    port: 64440,
+                    csrfToken: "language-token",
+                    source: .languageServer),
+            ])
+    }
+
+    @Test
+    func `parsed request retries later endpoints after api level error payload`() async throws {
+        let endpoints = [
+            AntigravityStatusProbe.AntigravityConnectionEndpoint(
+                scheme: "https",
+                port: 64440,
+                csrfToken: "bad-token",
+                source: .languageServer),
+            AntigravityStatusProbe.AntigravityConnectionEndpoint(
+                scheme: "http",
+                port: 64432,
+                csrfToken: "good-token",
+                source: .extensionServer),
+        ]
+        let attempted = AntigravityAttemptRecorder()
+
+        let snapshot = try await AntigravityStatusProbe.makeParsedRequest(
+            payload: AntigravityStatusProbe.RequestPayload(
+                path: "/exa.language_server_pb.LanguageServerService/GetUserStatus",
+                body: ["metadata": [:]]),
+            context: AntigravityStatusProbe.RequestContext(
+                endpoints: endpoints,
+                timeout: 1),
+            send: { _, endpoint, _ in
+                attempted.append(endpoint)
+                if endpoint.csrfToken == "bad-token" {
+                    return Data(#"{"code":16}"#.utf8)
+                }
+                return Data(
+                    #"""
+                    {
+                      "code": 0,
+                      "userStatus": {
+                        "email": "test@example.com",
+                        "cascadeModelConfigData": {
+                          "clientModelConfigs": []
+                        }
+                      }
+                    }
+                    """#.utf8)
+            },
+            parse: AntigravityStatusProbe.parseUserStatusResponse)
+
+        #expect(snapshot.accountEmail == "test@example.com")
+        #expect(attempted.snapshot() == endpoints)
+    }
+
+    @Test
+    func `endpoint resolver prefers successful https language server candidate`() async throws {
+        let candidates = AntigravityStatusProbe.connectionCandidates(
+            listeningPorts: [64440],
+            languageServerCSRFToken: "language-token",
+            extensionServerPort: 64432,
+            extensionServerCSRFToken: "extension-token")
+        let attempted = AntigravityAttemptRecorder()
+
+        let endpoint = try await AntigravityStatusProbe.resolveWorkingEndpoint(
+            candidateEndpoints: candidates,
+            timeout: 1)
+        { endpoint, _ in
+            attempted.append(endpoint)
+            return endpoint.scheme == "https" && endpoint.port == 64440
+        }
+
+        #expect(endpoint == candidates[0])
+        #expect(attempted.snapshot() == [candidates[0]])
+    }
+
+    @Test
+    func `endpoint resolver falls back to extension server after https language server candidates`() async throws {
+        let candidates = AntigravityStatusProbe.connectionCandidates(
+            listeningPorts: [64440, 64441],
+            languageServerCSRFToken: "language-token",
+            extensionServerPort: 64432,
+            extensionServerCSRFToken: "extension-token")
+        let attempted = AntigravityAttemptRecorder()
+
+        let endpoint = try await AntigravityStatusProbe.resolveWorkingEndpoint(
+            candidateEndpoints: candidates,
+            timeout: 1)
+        { endpoint, _ in
+            attempted.append(endpoint)
+            return endpoint.scheme == "http" && endpoint.port == 64432 && endpoint.source == .extensionServer
+        }
+
+        #expect(endpoint == candidates[2])
+        #expect(attempted.snapshot() == Array(candidates.prefix(3)))
+    }
+
+    @Test
+    func `endpoint resolver falls back to alternate extension token after primary token fails`() async throws {
+        let candidates = AntigravityStatusProbe.connectionCandidates(
+            listeningPorts: [64440],
+            languageServerCSRFToken: "language-token",
+            extensionServerPort: 64432,
+            extensionServerCSRFToken: "extension-token")
+        let attempted = AntigravityAttemptRecorder()
+
+        let endpoint = try await AntigravityStatusProbe.resolveWorkingEndpoint(
+            candidateEndpoints: candidates,
+            timeout: 1)
+        { endpoint, _ in
+            attempted.append(endpoint)
+            return endpoint.source == .extensionServer && endpoint.csrfToken == "language-token"
+        }
+
+        #expect(endpoint == candidates[2])
+        #expect(attempted.snapshot() == candidates)
+        #expect(endpoint.csrfToken == "language-token")
+    }
+
+    @Test
+    func `parses user status response`() throws {
         let json = """
         {
           "code": 0,
@@ -49,8 +759,925 @@ struct AntigravityStatusProbeTests {
         guard let primary = usage.primary else {
             return
         }
-        #expect(primary.remainingPercent.rounded() == 50)
-        #expect(usage.secondary?.remainingPercent.rounded() == 80)
-        #expect(usage.tertiary?.remainingPercent.rounded() == 20)
+        #expect(primary.remainingPercent.rounded() == 20)
+        #expect(usage.secondary?.remainingPercent.rounded() == 50)
+        #expect(usage.tertiary == nil)
+    }
+
+    @Test
+    func `prefers user tier name over generic plan info`() throws {
+        let json = """
+        {
+          "code": 0,
+          "userStatus": {
+            "email": "ultra@example.com",
+            "userTier": {
+              "id": "google_ai_ultra",
+              "name": "Google AI Ultra",
+              "description": "Ultra tier"
+            },
+            "planStatus": {
+              "planInfo": {
+                "planName": "Pro"
+              }
+            },
+            "cascadeModelConfigData": {
+              "clientModelConfigs": []
+            }
+          }
+        }
+        """
+
+        let data = Data(json.utf8)
+        let snapshot = try AntigravityStatusProbe.parseUserStatusResponse(data)
+
+        #expect(snapshot.accountEmail == "ultra@example.com")
+        #expect(snapshot.accountPlan == "Google AI Ultra")
+        #expect(snapshot.modelQuotas.isEmpty)
+    }
+
+    @Test
+    func `falls back to plan info when user tier name is blank`() throws {
+        let json = """
+        {
+          "code": 0,
+          "userStatus": {
+            "email": "fallback@example.com",
+            "userTier": {
+              "id": "google_ai_ultra",
+              "name": "   ",
+              "description": "Ultra tier"
+            },
+            "planStatus": {
+              "planInfo": {
+                "planName": "Pro"
+              }
+            },
+            "cascadeModelConfigData": {
+              "clientModelConfigs": []
+            }
+          }
+        }
+        """
+
+        let data = Data(json.utf8)
+        let snapshot = try AntigravityStatusProbe.parseUserStatusResponse(data)
+
+        #expect(snapshot.accountEmail == "fallback@example.com")
+        #expect(snapshot.accountPlan == "Pro")
+        #expect(snapshot.modelQuotas.isEmpty)
+    }
+
+    @Test
+    func `claude gpt pool can use thinking variants`() throws {
+        let snapshot = AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "Claude Thinking",
+                    modelId: "claude-thinking",
+                    remainingFraction: 0.7,
+                    resetTime: nil,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Claude Sonnet 4",
+                    modelId: "claude-sonnet-4",
+                    remainingFraction: 0.3,
+                    resetTime: nil,
+                    resetDescription: nil),
+            ],
+            accountEmail: nil,
+            accountPlan: nil)
+
+        let usage = try snapshot.toUsageSnapshot()
+        #expect(usage.primary == nil)
+        #expect(usage.secondary?.remainingPercent.rounded() == 30)
+    }
+
+    @Test
+    func `claude gpt pool uses thinking model when it is the only claude option`() throws {
+        let snapshot = AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "Claude Thinking",
+                    modelId: "claude-thinking",
+                    remainingFraction: 0.7,
+                    resetTime: nil,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Gemini 3 Pro Low",
+                    modelId: "gemini-3-pro-low",
+                    remainingFraction: 0.4,
+                    resetTime: nil,
+                    resetDescription: nil),
+            ],
+            accountEmail: nil,
+            accountPlan: nil)
+
+        let usage = try snapshot.toUsageSnapshot()
+        #expect(usage.primary?.remainingPercent.rounded() == 40)
+        #expect(usage.secondary?.remainingPercent.rounded() == 70)
+    }
+
+    @Test
+    func `gemini pool unavailable when only excluded variants exist`() throws {
+        let snapshot = AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "Gemini Pro Lite",
+                    modelId: "gemini-3-pro-lite",
+                    remainingFraction: 0.6,
+                    resetTime: nil,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Claude Sonnet 4",
+                    modelId: "claude-sonnet-4",
+                    remainingFraction: 0.3,
+                    resetTime: nil,
+                    resetDescription: nil),
+            ],
+            accountEmail: nil,
+            accountPlan: nil)
+
+        let usage = try snapshot.toUsageSnapshot()
+        #expect(usage.primary == nil)
+        #expect(usage.secondary?.remainingPercent.rounded() == 30)
+    }
+
+    @Test
+    func `gemini pool chooses most constrained pro variant`() throws {
+        let snapshot = AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "Gemini 3 Pro",
+                    modelId: "gemini-3-pro",
+                    remainingFraction: 0.9,
+                    resetTime: nil,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Gemini 3 Pro Low",
+                    modelId: "gemini-3-pro-low",
+                    remainingFraction: 0.4,
+                    resetTime: nil,
+                    resetDescription: nil),
+            ],
+            accountEmail: nil,
+            accountPlan: nil)
+
+        let usage = try snapshot.toUsageSnapshot()
+        #expect(usage.primary?.remainingPercent.rounded() == 40)
+        #expect(usage.secondary == nil)
+    }
+
+    @Test
+    func `gemini pool chooses standard pro when it is more constrained than low variant`() throws {
+        let snapshot = AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "Gemini 3 Pro",
+                    modelId: "gemini-3-pro",
+                    remainingFraction: 0.1,
+                    resetTime: nil,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Gemini 3 Pro Low",
+                    modelId: "gemini-3-pro-low",
+                    remainingFraction: 0.9,
+                    resetTime: nil,
+                    resetDescription: nil),
+            ],
+            accountEmail: nil,
+            accountPlan: nil)
+
+        let usage = try snapshot.toUsageSnapshot()
+        #expect(usage.primary?.remainingPercent.rounded() == 10)
+        #expect(usage.secondary == nil)
+    }
+
+    @Test
+    func `gemini pool ignores reset only placeholder when remaining data exists`() throws {
+        let snapshot = AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "Gemini 3 Pro (Low)",
+                    modelId: "MODEL_PLACEHOLDER_M36",
+                    remainingFraction: nil,
+                    resetTime: Date(timeIntervalSince1970: 1_735_000_000),
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Gemini 3 Pro (High)",
+                    modelId: "MODEL_PLACEHOLDER_M37",
+                    remainingFraction: 1,
+                    resetTime: Date(timeIntervalSince1970: 1_735_100_000),
+                    resetDescription: nil),
+            ],
+            accountEmail: nil,
+            accountPlan: nil)
+
+        let usage = try snapshot.toUsageSnapshot()
+        #expect(usage.primary?.remainingPercent.rounded() == 100)
+        #expect(usage.secondary == nil)
+    }
+
+    @Test
+    func `gemini pool does not fallback to lite flash variant`() throws {
+        let snapshot = AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "Gemini 2 Flash Lite",
+                    modelId: "gemini-2-flash-lite",
+                    remainingFraction: 0.2,
+                    resetTime: nil,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Claude Sonnet 4",
+                    modelId: "claude-sonnet-4",
+                    remainingFraction: 0.3,
+                    resetTime: nil,
+                    resetDescription: nil),
+            ],
+            accountEmail: nil,
+            accountPlan: nil)
+
+        let usage = try snapshot.toUsageSnapshot()
+        #expect(usage.tertiary == nil)
+        #expect(usage.primary == nil)
+        #expect(usage.secondary?.remainingPercent.rounded() == 30)
+    }
+
+    @Test
+    func `falls back to labels when model ids are placeholders`() throws {
+        let snapshot = AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "Claude Sonnet 4.6",
+                    modelId: "MODEL_PLACEHOLDER_M35",
+                    remainingFraction: 0.3,
+                    resetTime: nil,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Gemini 3.1 Pro (Low)",
+                    modelId: "MODEL_PLACEHOLDER_M36",
+                    remainingFraction: 0.4,
+                    resetTime: nil,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Gemini 3 Flash",
+                    modelId: "MODEL_PLACEHOLDER_M47",
+                    remainingFraction: 1,
+                    resetTime: nil,
+                    resetDescription: nil),
+            ],
+            accountEmail: nil,
+            accountPlan: nil)
+
+        let usage = try snapshot.toUsageSnapshot()
+        #expect(usage.primary?.remainingPercent.rounded() == 40)
+        #expect(usage.secondary?.remainingPercent.rounded() == 30)
+        #expect(usage.tertiary == nil)
+    }
+
+    @Test
+    func `matches remote antigravity model names with parentheses`() throws {
+        let resetTime = Date(timeIntervalSince1970: 1_775_000_000)
+        let snapshot = AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "Claude Opus 4.6 (Thinking)",
+                    modelId: "MODEL_PLACEHOLDER_M50",
+                    remainingFraction: 1,
+                    resetTime: resetTime,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Claude Sonnet 4.6 (Thinking)",
+                    modelId: "MODEL_PLACEHOLDER_M51",
+                    remainingFraction: 1,
+                    resetTime: resetTime,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Gemini 3 Pro (High)",
+                    modelId: "MODEL_PLACEHOLDER_M52",
+                    remainingFraction: 1,
+                    resetTime: resetTime,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Gemini 3 Pro (Low)",
+                    modelId: "MODEL_PLACEHOLDER_M53",
+                    remainingFraction: 1,
+                    resetTime: resetTime,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Gemini 3 Flash",
+                    modelId: "MODEL_PLACEHOLDER_M54",
+                    remainingFraction: 1,
+                    resetTime: resetTime,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "GPT-OSS 120B (Medium)",
+                    modelId: "MODEL_PLACEHOLDER_M55",
+                    remainingFraction: 1,
+                    resetTime: resetTime,
+                    resetDescription: nil),
+            ],
+            accountEmail: "user@example.com",
+            accountPlan: "Pro")
+
+        let usage = try snapshot.toUsageSnapshot()
+        #expect(usage.primary?.remainingPercent.rounded() == 100)
+        #expect(usage.secondary?.remainingPercent.rounded() == 100)
+        #expect(usage.tertiary == nil)
+        #expect(usage.identity?.accountEmail == "user@example.com")
+    }
+}
+
+extension AntigravityStatusProbeTests {
+    @Test
+    func `known model quota rows collapse into two usage pools`() throws {
+        let resetTime = Date(timeIntervalSince1970: 1_775_000_000)
+        let snapshot = AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "GPT-OSS 120B (Medium)",
+                    modelId: "MODEL_PLACEHOLDER_M55",
+                    remainingFraction: 0.25,
+                    resetTime: resetTime,
+                    resetDescription: "tomorrow"),
+                AntigravityModelQuota(
+                    label: "Gemini 3 Pro (Low)",
+                    modelId: "MODEL_PLACEHOLDER_M53",
+                    remainingFraction: 0.5,
+                    resetTime: resetTime,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Claude Opus 4.6 (Thinking)",
+                    modelId: "MODEL_PLACEHOLDER_M50",
+                    remainingFraction: 0.75,
+                    resetTime: resetTime,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Gemini 3 Pro (High)",
+                    modelId: "MODEL_PLACEHOLDER_M52",
+                    remainingFraction: 1,
+                    resetTime: resetTime,
+                    resetDescription: nil),
+            ],
+            accountEmail: nil,
+            accountPlan: nil,
+            source: .local)
+
+        let usage = try snapshot.toUsageSnapshot()
+        #expect(usage.primary?.remainingPercent.rounded() == 50)
+        #expect(usage.secondary?.remainingPercent.rounded() == 25)
+        #expect(usage.extraRateWindows == nil)
+    }
+
+    @Test
+    func `model without remaining fraction stays out of family summary and preserves reset metadata`() throws {
+        let resetTime = Date(timeIntervalSince1970: 1_735_000_000)
+        let snapshot = AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "Gemini 3.1 Pro (Low)",
+                    modelId: "MODEL_PLACEHOLDER_M36",
+                    remainingFraction: nil,
+                    resetTime: resetTime,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Gemini 3 Flash",
+                    modelId: "MODEL_PLACEHOLDER_M47",
+                    remainingFraction: 1,
+                    resetTime: nil,
+                    resetDescription: nil),
+            ],
+            accountEmail: nil,
+            accountPlan: nil)
+
+        let usage = try snapshot.toUsageSnapshot()
+        #expect(usage.primary?.remainingPercent.rounded() == 100)
+        #expect(usage.secondary == nil)
+        #expect(usage.tertiary == nil)
+        #expect(usage.extraRateWindows == nil)
+    }
+
+    @Test
+    func `group without remaining fraction preserves reset metadata as unavailable grouped window`() throws {
+        let resetTime = Date(timeIntervalSince1970: 1_735_000_000)
+        let snapshot = AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "Gemini 3.1 Pro (Low)",
+                    modelId: "MODEL_PLACEHOLDER_M36",
+                    remainingFraction: nil,
+                    resetTime: resetTime,
+                    resetDescription: nil),
+            ],
+            accountEmail: nil,
+            accountPlan: nil)
+
+        let usage = try snapshot.toUsageSnapshot()
+        #expect(usage.primary == nil)
+        let modelWindow = try #require(usage.extraRateWindows?.first)
+        #expect(modelWindow.id == "antigravity-gemini")
+        #expect(modelWindow.title == "Gemini Models")
+        #expect(modelWindow.window.resetsAt == resetTime)
+        #expect(modelWindow.usageKnown == false)
+    }
+
+    @Test
+    func `named rate windows default legacy payloads to known usage`() throws {
+        let json = """
+        {
+          "id": "legacy-window",
+          "title": "Legacy Window",
+          "window": {
+            "usedPercent": 42,
+            "windowMinutes": null,
+            "resetsAt": null,
+            "resetDescription": null,
+            "nextRegenPercent": null
+          }
+        }
+        """
+
+        let decoded = try JSONDecoder().decode(NamedRateWindow.self, from: Data(json.utf8))
+
+        #expect(decoded.usageKnown)
+    }
+
+    @Test
+    func `filtered variants stay out of summary but remain distinct extras`() throws {
+        let snapshot = AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "Gemini 3 Pro Lite",
+                    modelId: "gemini-3-pro-lite",
+                    remainingFraction: 0.6,
+                    resetTime: nil,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Gemini 3 Flash Lite",
+                    modelId: "gemini-3-flash-lite",
+                    remainingFraction: 0.2,
+                    resetTime: nil,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Tab Autocomplete",
+                    modelId: "tab_autocomplete_model",
+                    remainingFraction: 0.9,
+                    resetTime: nil,
+                    resetDescription: nil),
+            ],
+            accountEmail: "test@example.com",
+            accountPlan: "Pro",
+            source: .local)
+
+        let usage = try snapshot.toUsageSnapshot()
+        #expect(usage.primary == nil)
+        #expect(usage.secondary == nil)
+        #expect(usage.tertiary == nil)
+        #expect(usage.extraRateWindows?.map(\.id) == [
+            "gemini-3-pro-lite",
+            "gemini-3-flash-lite",
+            "tab_autocomplete_model",
+        ])
+        #expect(usage.accountEmail(for: .antigravity) == "test@example.com")
+        #expect(usage.loginMethod(for: .antigravity) == "Pro")
+    }
+
+    // MARK: - Source-aware filter + sort tests
+
+    @Test
+    func `local source collapses opaque model ids into two usage pools`() throws {
+        // Fixture A: 8 opaque-ID models, source .local -> two grouped quota pools
+        let resetTime = Date(timeIntervalSince1970: 1_775_000_000)
+        let snapshot = AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "Claude Sonnet 4.6 (Thinking)",
+                    modelId: "MODEL_PLACEHOLDER_M60",
+                    remainingFraction: 0.8,
+                    resetTime: resetTime,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Claude Opus 4.6 (Thinking)",
+                    modelId: "MODEL_PLACEHOLDER_M61",
+                    remainingFraction: 0.7,
+                    resetTime: resetTime,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Gemini 3.1 Pro (High)",
+                    modelId: "MODEL_PLACEHOLDER_M62",
+                    remainingFraction: 0.9,
+                    resetTime: resetTime,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Gemini 3.1 Pro (Low)",
+                    modelId: "MODEL_PLACEHOLDER_M63",
+                    remainingFraction: 0.4,
+                    resetTime: resetTime,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Gemini 3.5 Flash (High)",
+                    modelId: "MODEL_PLACEHOLDER_M64",
+                    remainingFraction: 0.6,
+                    resetTime: resetTime,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Gemini 3.5 Flash (Low)",
+                    modelId: "MODEL_PLACEHOLDER_M65",
+                    remainingFraction: 0.3,
+                    resetTime: resetTime,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Gemini 3.5 Flash (Medium)",
+                    modelId: "MODEL_PLACEHOLDER_M66",
+                    remainingFraction: 0.5,
+                    resetTime: resetTime,
+                    resetDescription: nil),
+                // GPT-OSS pinned at remainingFraction == 1.0 - shown by local show-all
+                AntigravityModelQuota(
+                    label: "GPT-OSS 120B (Medium)",
+                    modelId: "MODEL_PLACEHOLDER_M55",
+                    remainingFraction: 1.0,
+                    resetTime: resetTime,
+                    resetDescription: nil),
+            ],
+            accountEmail: nil,
+            accountPlan: nil,
+            source: .local)
+
+        let usage = try snapshot.toUsageSnapshot()
+        #expect(usage.primary?.remainingPercent.rounded() == 30)
+        #expect(usage.secondary?.remainingPercent.rounded() == 70)
+        #expect(usage.extraRateWindows == nil)
+    }
+
+    @Test
+    func `remote source collapses recognized family models and hides unconsumed junk`() throws {
+        // Fixture B: verified 13 remote models; recognized text models collapse into Gemini,
+        // and unconsumed junk stays hidden.
+        let snapshot = AntigravityStatusSnapshot(
+            modelQuotas: [
+                // junk: image
+                AntigravityModelQuota(
+                    label: "Gemini 2.5 Flash Image",
+                    modelId: "gemini-2-5-flash-image",
+                    remainingFraction: 1.0,
+                    resetTime: nil,
+                    resetDescription: nil),
+                // junk: tab autocomplete
+                AntigravityModelQuota(
+                    label: "Tab Flash Lite Vertex",
+                    modelId: "tab_flash_lite_vertex",
+                    remainingFraction: 1.0,
+                    resetTime: nil,
+                    resetDescription: nil),
+                // survivor
+                AntigravityModelQuota(
+                    label: "Gemini 2.5 Pro",
+                    modelId: "gemini-2-5-pro",
+                    remainingFraction: 1.0,
+                    resetTime: nil,
+                    resetDescription: nil),
+                // survivor
+                AntigravityModelQuota(
+                    label: "Gemini 3 Pro (High)",
+                    modelId: "gemini-3-pro-high",
+                    remainingFraction: 1.0,
+                    resetTime: nil,
+                    resetDescription: nil),
+                // junk: lite
+                AntigravityModelQuota(
+                    label: "Gemini 2.5 Flash Lite",
+                    modelId: "gemini-2-5-flash-lite",
+                    remainingFraction: 1.0,
+                    resetTime: nil,
+                    resetDescription: nil),
+                // junk: image
+                AntigravityModelQuota(
+                    label: "Gemini 3 Pro Image",
+                    modelId: "gemini-3-pro-image",
+                    remainingFraction: 1.0,
+                    resetTime: nil,
+                    resetDescription: nil),
+                // survivor
+                AntigravityModelQuota(
+                    label: "Gemini 3 Flash",
+                    modelId: "gemini-3-flash",
+                    remainingFraction: 1.0,
+                    resetTime: nil,
+                    resetDescription: nil),
+                // junk: lite
+                AntigravityModelQuota(
+                    label: "Gemini 3.1 Flash Lite",
+                    modelId: "gemini-3-1-flash-lite",
+                    remainingFraction: 1.0,
+                    resetTime: nil,
+                    resetDescription: nil),
+                // survivor
+                AntigravityModelQuota(
+                    label: "Gemini 3.1 Pro (Low)",
+                    modelId: "gemini-3-1-pro-low",
+                    remainingFraction: 1.0,
+                    resetTime: nil,
+                    resetDescription: nil),
+                // survivor
+                AntigravityModelQuota(
+                    label: "Gemini 3.1 Pro (High)",
+                    modelId: "gemini-3-1-pro-high",
+                    remainingFraction: 1.0,
+                    resetTime: nil,
+                    resetDescription: nil),
+                // junk: tab autocomplete
+                AntigravityModelQuota(
+                    label: "Tab Jump Flash Lite Vertex",
+                    modelId: "tab_jump_flash_lite_vertex",
+                    remainingFraction: 1.0,
+                    resetTime: nil,
+                    resetDescription: nil),
+                // survivor
+                AntigravityModelQuota(
+                    label: "Gemini 3 Pro (Low)",
+                    modelId: "gemini-3-pro-low",
+                    remainingFraction: 1.0,
+                    resetTime: nil,
+                    resetDescription: nil),
+                // survivor
+                AntigravityModelQuota(
+                    label: "Gemini 2.5 Flash",
+                    modelId: "gemini-2-5-flash",
+                    remainingFraction: 1.0,
+                    resetTime: nil,
+                    resetDescription: nil),
+            ],
+            accountEmail: nil,
+            accountPlan: nil,
+            source: .remote)
+
+        let usage = try snapshot.toUsageSnapshot()
+        #expect(usage.primary?.remainingPercent.rounded() == 100)
+        #expect(usage.secondary == nil)
+        #expect(usage.extraRateWindows == nil)
+    }
+
+    @Test
+    func `remote source shows consumed junk models despite filter`() throws {
+        // Fixture C: junk models with remainingFraction < 0.999 must be shown
+        let snapshot = AntigravityStatusSnapshot(
+            modelQuotas: [
+                // consumed tab - should be shown
+                AntigravityModelQuota(
+                    label: "Tab Flash Lite Vertex",
+                    modelId: "tab_flash_lite_vertex",
+                    remainingFraction: 0.4,
+                    resetTime: nil,
+                    resetDescription: nil),
+                // consumed image - should be shown
+                AntigravityModelQuota(
+                    label: "Gemini 3 Pro Image",
+                    modelId: "gemini-3-pro-image",
+                    remainingFraction: 0.4,
+                    resetTime: nil,
+                    resetDescription: nil),
+                // unconsumed sibling tab (0.9995 >= 0.999) - should be hidden
+                AntigravityModelQuota(
+                    label: "Tab Jump Flash Lite Vertex",
+                    modelId: "tab_jump_flash_lite_vertex",
+                    remainingFraction: 0.9995,
+                    resetTime: nil,
+                    resetDescription: nil),
+                // a clean survivor for non-empty guard
+                AntigravityModelQuota(
+                    label: "Gemini 3 Flash",
+                    modelId: "gemini-3-flash",
+                    remainingFraction: 1.0,
+                    resetTime: nil,
+                    resetDescription: nil),
+            ],
+            accountEmail: nil,
+            accountPlan: nil,
+            source: .remote)
+
+        let usage = try snapshot.toUsageSnapshot()
+        let extraWindows = try #require(usage.extraRateWindows)
+        let ids = extraWindows.map(\.id)
+
+        // Consumed junk models shown despite being junk type
+        #expect(ids.contains("tab_flash_lite_vertex"))
+        #expect(ids.contains("gemini-3-pro-image"))
+
+        // Unconsumed sibling stays hidden
+        #expect(!ids.contains("tab_jump_flash_lite_vertex"))
+    }
+
+    @Test
+    func `remote source image models do not drive family summary bars`() throws {
+        let snapshot = AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "Gemini 3 Pro Image",
+                    modelId: "gemini-3-pro-image",
+                    remainingFraction: 0.2,
+                    resetTime: nil,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Gemini 3 Pro (High)",
+                    modelId: "gemini-3-pro-high",
+                    remainingFraction: 0.9,
+                    resetTime: nil,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Gemini 3 Flash Image",
+                    modelId: "gemini-3-flash-image",
+                    remainingFraction: 0.1,
+                    resetTime: nil,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Gemini 3 Flash",
+                    modelId: "gemini-3-flash",
+                    remainingFraction: 0.8,
+                    resetTime: nil,
+                    resetDescription: nil),
+            ],
+            accountEmail: nil,
+            accountPlan: nil,
+            source: .remote)
+
+        let usage = try snapshot.toUsageSnapshot()
+
+        #expect(usage.primary?.usedPercent == 20)
+        #expect(usage.secondary == nil)
+        #expect(usage.extraRateWindows?.map(\.id).contains("gemini-3-pro-image") == true)
+        #expect(usage.extraRateWindows?.map(\.id).contains("gemini-3-flash-image") == true)
+    }
+
+    @Test
+    func `remote source yields nil extra windows when all models are unconsumed junk`() throws {
+        // Fixture D: all-junk-unconsumed -> extraRateWindows nil
+        let snapshot = AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "Tab Flash Lite Vertex",
+                    modelId: "tab_flash_lite_vertex",
+                    remainingFraction: 1.0,
+                    resetTime: nil,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Gemini 2.5 Flash Lite",
+                    modelId: "gemini-2-5-flash-lite",
+                    remainingFraction: 1.0,
+                    resetTime: nil,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Gemini 3 Pro Image",
+                    modelId: "gemini-3-pro-image",
+                    remainingFraction: 1.0,
+                    resetTime: nil,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Unknown Model X",
+                    modelId: "unknown-model-x",
+                    remainingFraction: 1.0,
+                    resetTime: nil,
+                    resetDescription: nil),
+            ],
+            accountEmail: nil,
+            accountPlan: nil,
+            source: .remote)
+
+        let usage = try snapshot.toUsageSnapshot()
+        #expect(usage.primary == nil)
+        #expect(usage.secondary == nil)
+        #expect(usage.tertiary == nil)
+        #expect(usage.extraRateWindows == nil)
+    }
+
+    @Test
+    func `ordering edge cases collapse to most constrained usage pool`() throws {
+        // Fixture F: local source; known Gemini Pro rows collapse into the Gemini pool
+        // using the most constrained remaining fraction.
+        let snapshot = AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "Gemini 3 Pro (Low)",
+                    modelId: "MODEL_PLACEHOLDER_M70",
+                    remainingFraction: 0.5,
+                    resetTime: nil,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Gemini 3 Pro (High)",
+                    modelId: "MODEL_PLACEHOLDER_M71",
+                    remainingFraction: 0.8,
+                    resetTime: nil,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Gemini Pro Experimental",
+                    modelId: "MODEL_PLACEHOLDER_M72",
+                    remainingFraction: 0.3,
+                    resetTime: nil,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Claude Sonnet 4",
+                    modelId: "MODEL_PLACEHOLDER_M73",
+                    remainingFraction: 0.9,
+                    resetTime: nil,
+                    resetDescription: nil),
+            ],
+            accountEmail: nil,
+            accountPlan: nil,
+            source: .local)
+
+        let usage = try snapshot.toUsageSnapshot()
+        #expect(usage.primary?.remainingPercent.rounded() == 30)
+        #expect(usage.secondary?.remainingPercent.rounded() == 90)
+        #expect(usage.extraRateWindows == nil)
+    }
+
+    @Test
+    func `nil version unknown family models sort deterministically by label`() throws {
+        // Strict-weak-ordering guard: two .unknown models with unparseable versions
+        // should sort by label without trapping
+        let snapshot = AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "Zebra Unknown Model",
+                    modelId: "MODEL_PLACEHOLDER_MA",
+                    remainingFraction: 0.5,
+                    resetTime: nil,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Alpha Unknown Model",
+                    modelId: "MODEL_PLACEHOLDER_MB",
+                    remainingFraction: 0.5,
+                    resetTime: nil,
+                    resetDescription: nil),
+            ],
+            accountEmail: nil,
+            accountPlan: nil,
+            source: .local)
+
+        let usage = try snapshot.toUsageSnapshot()
+        let extraWindows = try #require(usage.extraRateWindows)
+        let titles = extraWindows.map(\.title)
+
+        // Deterministic: label tiebreaker -> Alpha before Zebra
+        #expect(titles == ["Alpha Unknown Model", "Zebra Unknown Model"])
+    }
+
+    @Test
+    func `hyphenated raw model ids without display name still map to gemini group`() throws {
+        // When the remote catalog omits displayName/label, the raw hyphenated model id
+        // becomes the label and still participates in the Gemini group.
+        let snapshot = AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "gemini-3-pro-preview",
+                    modelId: "gemini-3-pro-preview",
+                    remainingFraction: 1,
+                    resetTime: nil,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "gemini-2.5-pro",
+                    modelId: "gemini-2.5-pro",
+                    remainingFraction: 1,
+                    resetTime: nil,
+                    resetDescription: nil),
+            ],
+            accountEmail: nil,
+            accountPlan: nil,
+            source: .remote)
+
+        let usage = try snapshot.toUsageSnapshot()
+        #expect(usage.primary?.remainingPercent.rounded() == 100)
+        #expect(usage.extraRateWindows == nil)
+    }
+
+    @Test
+    func `http probe errors still count as reachable`() {
+        #expect(
+            AntigravityStatusProbe.isReachableProbeError(
+                AntigravityStatusProbeError.apiError("HTTP 403: Forbidden")))
+        #expect(
+            AntigravityStatusProbe.isReachableProbeError(
+                AntigravityStatusProbeError.apiError("HTTP 404: Not Found")))
+        #expect(
+            !AntigravityStatusProbe.isReachableProbeError(
+                AntigravityStatusProbeError.apiError("Invalid response")))
+        #expect(!AntigravityStatusProbe.isReachableProbeError(AntigravityStatusProbeError.notRunning))
+    }
+
+    @Test
+    func `fallback probe port prefers non extension candidate`() {
+        #expect(
+            AntigravityStatusProbe.fallbackProbePort(
+                ports: [51170, 61775],
+                extensionPort: 61775) == 51170)
+        #expect(
+            AntigravityStatusProbe.fallbackProbePort(
+                ports: [61775],
+                extensionPort: 61775) == 61775)
+        #expect(
+            AntigravityStatusProbe.fallbackProbePort(
+                ports: [51170, 61775],
+                extensionPort: nil) == 51170)
     }
 }
diff --git a/Tests/CodexBarTests/AppDelegateTests.swift b/Tests/CodexBarTests/AppDelegateTests.swift
index 70677caad9..ffc7656a5c 100644
--- a/Tests/CodexBarTests/AppDelegateTests.swift
+++ b/Tests/CodexBarTests/AppDelegateTests.swift
@@ -4,19 +4,14 @@ import Testing
 @testable import CodexBar
 
 @MainActor
-@Suite
 struct AppDelegateTests {
     @Test
-    func buildsStatusControllerAfterLaunch() {
+    func `builds status controller after launch`() {
         let appDelegate = AppDelegate()
         var factoryCalls = 0
-
-        // Install a test factory that records invocations without touching NSStatusBar.
-        StatusItemController.factory = { _, _, _, _, _ in
-            factoryCalls += 1
-            return DummyStatusController()
-        }
-        defer { StatusItemController.factory = StatusItemController.defaultFactory }
+        var ttyShutdowns = 0
+        let dummyStatusController = DummyStatusController()
+        let managedCodexAccountCoordinator = ManagedCodexAccountCoordinator()
 
         let settings = SettingsStore(
             configStore: testConfigStore(suiteName: "AppDelegateTests"),
@@ -25,9 +20,31 @@ struct AppDelegateTests {
         let fetcher = UsageFetcher()
         let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
         let account = fetcher.loadAccountInfo()
+        let promotionCoordinator = CodexAccountPromotionCoordinator(
+            settingsStore: settings,
+            usageStore: store,
+            managedAccountCoordinator: managedCodexAccountCoordinator)
+        appDelegate.terminateActiveProcessesForAppShutdown = {
+            ttyShutdowns += 1
+        }
+
+        // Install a test factory that records invocations without touching NSStatusBar.
+        StatusItemController.factory = { _, _, _, _, _, receivedManagedCoordinator, receivedPromotionCoordinator in
+            factoryCalls += 1
+            #expect(receivedManagedCoordinator === managedCodexAccountCoordinator)
+            #expect(receivedPromotionCoordinator === promotionCoordinator)
+            return dummyStatusController
+        }
+        defer { StatusItemController.factory = StatusItemController.defaultFactory }
 
         // configure should not eagerly construct the status controller
-        appDelegate.configure(store: store, settings: settings, account: account, selection: PreferencesSelection())
+        appDelegate.configure(.init(
+            store: store,
+            settings: settings,
+            account: account,
+            selection: PreferencesSelection(),
+            managedCodexAccountCoordinator: managedCodexAccountCoordinator,
+            codexAccountPromotionCoordinator: promotionCoordinator))
         #expect(factoryCalls == 0)
 
         // construction happens once after launch
@@ -37,10 +54,21 @@ struct AppDelegateTests {
         // idempotent on subsequent calls
         appDelegate.applicationDidFinishLaunching(Notification(name: NSApplication.didFinishLaunchingNotification))
         #expect(factoryCalls == 1)
+
+        // production termination should ask the status controller to detach AppKit status/menu state
+        appDelegate.applicationWillTerminate(Notification(name: NSApplication.willTerminateNotification))
+        #expect(dummyStatusController.shutdowns == 1)
+        #expect(ttyShutdowns == 1)
     }
 }
 
 @MainActor
 private final class DummyStatusController: StatusItemControlling {
+    private(set) var shutdowns = 0
+
     func openMenuFromShortcut() {}
+    func runLoginFlowFromSettings(provider _: UsageProvider) async {}
+    func prepareForAppShutdown() {
+        self.shutdowns += 1
+    }
 }
diff --git a/Tests/CodexBarTests/AppGroupSupportTests.swift b/Tests/CodexBarTests/AppGroupSupportTests.swift
new file mode 100644
index 0000000000..ba55d2acdc
--- /dev/null
+++ b/Tests/CodexBarTests/AppGroupSupportTests.swift
@@ -0,0 +1,121 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct AppGroupSupportTests {
+    @Test
+    func `app group identifiers use resolved team-prefixed release and debug variants`() {
+        #expect(
+            AppGroupSupport.currentGroupID(teamID: "Y5PE65HELJ", bundleID: "com.steipete.codexbar")
+                == "Y5PE65HELJ.com.steipete.codexbar")
+        #expect(
+            AppGroupSupport.currentGroupID(teamID: "ABCDE12345", bundleID: "com.steipete.codexbar.debug")
+                == "ABCDE12345.com.steipete.codexbar.debug")
+        #expect(
+            AppGroupSupport.legacyGroupID(for: "com.steipete.codexbar")
+                == "group.com.steipete.codexbar")
+        #expect(
+            AppGroupSupport.legacyGroupID(for: "com.steipete.codexbar.debug")
+                == "group.com.steipete.codexbar.debug")
+    }
+
+    @Test
+    func `resolved team id falls back to plist and then default`() {
+        #expect(
+            AppGroupSupport.resolvedTeamID(
+                infoDictionaryOverride: [AppGroupSupport.teamIDInfoKey: "ABCDE12345"],
+                bundleURLOverride: nil) == "ABCDE12345")
+        #expect(
+            AppGroupSupport.resolvedTeamID(
+                infoDictionaryOverride: nil,
+                bundleURLOverride: nil) == AppGroupSupport.defaultTeamID)
+    }
+
+    @Test
+    func `legacy migration copies snapshot once`() throws {
+        let fileManager = FileManager.default
+        let root = fileManager.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        try fileManager.createDirectory(at: root, withIntermediateDirectories: true)
+        defer { try? fileManager.removeItem(at: root) }
+
+        let standardSuite = "AppGroupSupportTests-standard-\(UUID().uuidString)"
+        let currentSuite = "AppGroupSupportTests-current-\(UUID().uuidString)"
+        let legacySuite = "AppGroupSupportTests-legacy-\(UUID().uuidString)"
+
+        let standardDefaults = try #require(UserDefaults(suiteName: standardSuite))
+        let currentDefaults = try #require(UserDefaults(suiteName: currentSuite))
+        let legacyDefaults = try #require(UserDefaults(suiteName: legacySuite))
+        standardDefaults.removePersistentDomain(forName: standardSuite)
+        currentDefaults.removePersistentDomain(forName: currentSuite)
+        legacyDefaults.removePersistentDomain(forName: legacySuite)
+
+        legacyDefaults.set(true, forKey: "debugDisableKeychainAccess")
+        legacyDefaults.set(UsageProvider.cursor.rawValue, forKey: "widgetSelectedProvider")
+
+        let legacySnapshotURL = root.appendingPathComponent(
+            "legacy/widget-snapshot.json",
+            isDirectory: false)
+        try fileManager.createDirectory(
+            at: legacySnapshotURL.deletingLastPathComponent(),
+            withIntermediateDirectories: true)
+        try Data("legacy-snapshot".utf8).write(to: legacySnapshotURL)
+
+        let currentSnapshotURL = root.appendingPathComponent("current/widget-snapshot.json", isDirectory: false)
+        let result = AppGroupSupport.migrateLegacyDataIfNeeded(
+            bundleID: "com.steipete.codexbar",
+            standardDefaults: standardDefaults,
+            currentDefaultsOverride: currentDefaults,
+            legacyDefaultsOverride: legacyDefaults,
+            currentSnapshotURLOverride: currentSnapshotURL,
+            legacySnapshotURLOverride: legacySnapshotURL)
+
+        #expect(result.status == .migrated)
+        #expect(result.copiedSnapshot)
+        #expect(result.copiedDefaults == 2)
+        #expect(currentDefaults.bool(forKey: "debugDisableKeychainAccess"))
+        #expect(currentDefaults.string(forKey: "widgetSelectedProvider") == UsageProvider.cursor.rawValue)
+        #expect(fileManager.fileExists(atPath: currentSnapshotURL.path))
+        #expect(
+            standardDefaults.integer(forKey: AppGroupSupport.migrationVersionKey)
+                == AppGroupSupport.migrationVersion)
+
+        let secondResult = AppGroupSupport.migrateLegacyDataIfNeeded(
+            bundleID: "com.steipete.codexbar",
+            standardDefaults: standardDefaults,
+            currentDefaultsOverride: currentDefaults,
+            legacyDefaultsOverride: legacyDefaults,
+            currentSnapshotURLOverride: currentSnapshotURL,
+            legacySnapshotURLOverride: legacySnapshotURL)
+        #expect(secondResult.status == .alreadyCompleted)
+    }
+
+    @Test
+    func `legacy migration preserves existing target shared defaults`() throws {
+        let standardSuite = "AppGroupSupportTests-standard-existing-\(UUID().uuidString)"
+        let currentSuite = "AppGroupSupportTests-current-existing-\(UUID().uuidString)"
+        let legacySuite = "AppGroupSupportTests-legacy-existing-\(UUID().uuidString)"
+
+        let standardDefaults = try #require(UserDefaults(suiteName: standardSuite))
+        let currentDefaults = try #require(UserDefaults(suiteName: currentSuite))
+        let legacyDefaults = try #require(UserDefaults(suiteName: legacySuite))
+        standardDefaults.removePersistentDomain(forName: standardSuite)
+        currentDefaults.removePersistentDomain(forName: currentSuite)
+        legacyDefaults.removePersistentDomain(forName: legacySuite)
+
+        currentDefaults.set(false, forKey: "debugDisableKeychainAccess")
+        currentDefaults.set(UsageProvider.codex.rawValue, forKey: "widgetSelectedProvider")
+        legacyDefaults.set(true, forKey: "debugDisableKeychainAccess")
+        legacyDefaults.set(UsageProvider.cursor.rawValue, forKey: "widgetSelectedProvider")
+
+        let result = AppGroupSupport.migrateLegacyDataIfNeeded(
+            bundleID: "com.steipete.codexbar",
+            standardDefaults: standardDefaults,
+            currentDefaultsOverride: currentDefaults,
+            legacyDefaultsOverride: legacyDefaults)
+
+        #expect(result.status == .noChangesNeeded)
+        #expect(result.copiedDefaults == 0)
+        #expect(!currentDefaults.bool(forKey: "debugDisableKeychainAccess"))
+        #expect(currentDefaults.string(forKey: "widgetSelectedProvider") == UsageProvider.codex.rawValue)
+    }
+}
diff --git a/Tests/CodexBarTests/AuggieCLIProbeParseTests.swift b/Tests/CodexBarTests/AuggieCLIProbeParseTests.swift
new file mode 100644
index 0000000000..338d8d2f04
--- /dev/null
+++ b/Tests/CodexBarTests/AuggieCLIProbeParseTests.swift
@@ -0,0 +1,50 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+#if os(macOS)
+
+struct AuggieCLIProbeParseTests {
+    private let probe = AuggieCLIProbe()
+
+    @Test
+    func `parses current auggie account status output`() throws {
+        let output = """
+        ╭ Account ───────────────────────────────────────────────╮
+        │                                                        │
+        │ 319,054 credits remaining                     Max Plan │
+        │                                450,000 credits / month │
+        │                                                        │
+        ╰────────────────────────────────────────────────────────╯
+
+         9 days remaining in this billing cycle (ends 6/9/2026)
+         For more detail, visit https://app.augmentcode.com/account
+        """
+
+        let snapshot = try probe.parse(output)
+
+        #expect(snapshot.creditsRemaining == 319_054)
+        #expect(snapshot.creditsLimit == 450_000)
+        #expect(snapshot.creditsUsed == 130_946)
+        #expect(snapshot.accountPlan == "\(450_000.formatted()) credits/month")
+        #expect(snapshot.billingCycleEnd != nil)
+    }
+
+    @Test
+    func `parses legacy auggie account status output`() throws {
+        let output = """
+        Max Plan 450,000 credits / month
+        11,657 remaining · 953,170 / 964,827 credits used
+        2 days remaining in this billing cycle (ends 1/8/2026)
+        """
+
+        let snapshot = try probe.parse(output)
+
+        #expect(snapshot.creditsRemaining == 11657)
+        #expect(snapshot.creditsUsed == 953_170)
+        #expect(snapshot.creditsLimit == 964_827)
+        #expect(snapshot.accountPlan == "\(450_000.formatted()) credits/month")
+    }
+}
+
+#endif
diff --git a/Tests/CodexBarTests/AugmentCLIFetchStrategyFallbackTests.swift b/Tests/CodexBarTests/AugmentCLIFetchStrategyFallbackTests.swift
new file mode 100644
index 0000000000..905a8e92ea
--- /dev/null
+++ b/Tests/CodexBarTests/AugmentCLIFetchStrategyFallbackTests.swift
@@ -0,0 +1,97 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+#if os(macOS)
+
+/// Regression tests for #474: verify that CLI timeout errors trigger fallback
+/// to the web strategy instead of stalling the refresh cycle.
+struct AugmentCLIFetchStrategyFallbackTests {
+    private struct StubClaudeFetcher: ClaudeUsageFetching {
+        func loadLatestUsage(model _: String) async throws -> ClaudeUsageSnapshot {
+            throw ClaudeUsageError.parseFailed("stub")
+        }
+
+        func debugRawProbe(model _: String) async -> String {
+            "stub"
+        }
+
+        func detectVersion() -> String? {
+            nil
+        }
+    }
+
+    private func makeContext(sourceMode: ProviderSourceMode = .auto) -> ProviderFetchContext {
+        let env: [String: String] = [:]
+        return ProviderFetchContext(
+            runtime: .app,
+            sourceMode: sourceMode,
+            includeCredits: false,
+            webTimeout: 1,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: env,
+            settings: nil,
+            fetcher: UsageFetcher(environment: env),
+            claudeFetcher: StubClaudeFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0))
+    }
+
+    // SubprocessRunnerError is not an AuggieCLIError, so it hits the default
+    // fallback=true path — the desired behavior for infrastructure errors.
+
+    @Test
+    func `timeout error falls back to web`() {
+        let strategy = AugmentCLIFetchStrategy()
+        let context = self.makeContext()
+        let error = SubprocessRunnerError.timedOut("auggie-account-status")
+        #expect(strategy.shouldFallback(on: error, context: context) == true)
+    }
+
+    @Test
+    func `binary not found falls back to web`() {
+        let strategy = AugmentCLIFetchStrategy()
+        let context = self.makeContext()
+        let error = SubprocessRunnerError.binaryNotFound("/usr/local/bin/auggie")
+        #expect(strategy.shouldFallback(on: error, context: context) == true)
+    }
+
+    @Test
+    func `launch failed falls back to web`() {
+        let strategy = AugmentCLIFetchStrategy()
+        let context = self.makeContext()
+        let error = SubprocessRunnerError.launchFailed("permission denied")
+        #expect(strategy.shouldFallback(on: error, context: context) == true)
+    }
+
+    @Test
+    func `not authenticated falls back to web`() {
+        let strategy = AugmentCLIFetchStrategy()
+        let context = self.makeContext()
+        #expect(strategy.shouldFallback(on: AuggieCLIError.notAuthenticated, context: context) == true)
+    }
+
+    @Test
+    func `no output falls back to web`() {
+        let strategy = AugmentCLIFetchStrategy()
+        let context = self.makeContext()
+        #expect(strategy.shouldFallback(on: AuggieCLIError.noOutput, context: context) == true)
+    }
+
+    @Test
+    func `parse error falls back to web`() {
+        let strategy = AugmentCLIFetchStrategy()
+        let context = self.makeContext()
+        #expect(strategy.shouldFallback(on: AuggieCLIError.parseError("bad data"), context: context) == true)
+    }
+
+    @Test
+    func `non zero exit falls back to web`() {
+        let strategy = AugmentCLIFetchStrategy()
+        let context = self.makeContext()
+        let error = SubprocessRunnerError.nonZeroExit(code: 1, stderr: "crash")
+        #expect(strategy.shouldFallback(on: error, context: context) == true)
+    }
+}
+
+#endif
diff --git a/Tests/CodexBarTests/AugmentProviderRuntimeTests.swift b/Tests/CodexBarTests/AugmentProviderRuntimeTests.swift
new file mode 100644
index 0000000000..889da06509
--- /dev/null
+++ b/Tests/CodexBarTests/AugmentProviderRuntimeTests.swift
@@ -0,0 +1,42 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@MainActor
+@Suite(.serialized)
+struct AugmentProviderRuntimeTests {
+    @Test
+    func `repeated stop only reports a running keepalive once`() throws {
+        let suite = "AugmentProviderRuntimeTests-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore(),
+            augmentCookieStore: InMemoryCookieHeaderStore())
+        let metadata = try #require(ProviderRegistry.shared.metadata[.augment])
+        settings.setProviderEnabled(provider: .augment, metadata: metadata, enabled: true)
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        let runtime = AugmentProviderRuntime()
+        let context = ProviderRuntimeContext(provider: .augment, settings: settings, store: store)
+        defer { runtime.stop(context: context) }
+
+        runtime.start(context: context)
+        #expect(runtime._test_isKeepaliveRunning)
+        runtime.stop(context: context)
+        settings.setProviderEnabled(provider: .augment, metadata: metadata, enabled: false)
+        runtime.stop(context: context)
+        runtime.settingsDidChange(context: context)
+
+        #expect(!runtime._test_isKeepaliveRunning)
+        #expect(runtime._test_keepaliveStopCount == 1)
+    }
+}
diff --git a/Tests/CodexBarTests/AugmentStatusProbeTests.swift b/Tests/CodexBarTests/AugmentStatusProbeTests.swift
index 912f367337..c72014ef5c 100644
--- a/Tests/CodexBarTests/AugmentStatusProbeTests.swift
+++ b/Tests/CodexBarTests/AugmentStatusProbeTests.swift
@@ -2,12 +2,33 @@ import XCTest
 @testable import CodexBarCore
 
 final class AugmentStatusProbeTests: XCTestCase {
-    func test_debugRawProbe_returnsFormattedOutput() async {
+    private func failingProbe() throws -> AugmentStatusProbe {
+        try AugmentStatusProbe(baseURL: XCTUnwrap(URL(string: "http://127.0.0.1:1")), timeout: 0.1)
+    }
+
+    @MainActor
+    func test_sessionKeepaliveStartLogsActualIntervals() {
+        var messages: [String] = []
+        let keepalive = AugmentSessionKeepalive { message in
+            messages.append(message)
+        }
+
+        keepalive.start()
+        defer { keepalive.stop() }
+
+        XCTAssertTrue(messages.contains { $0.contains("Check interval: 60s (1 minute)") })
+        XCTAssertTrue(messages.contains { $0.contains("Refresh buffer: 300s (5 minutes before expiry)") })
+        XCTAssertTrue(messages.contains { $0.contains("Min refresh interval: 60s (1 minute)") })
+        XCTAssertFalse(messages.contains { $0.contains("every 5 minutes") })
+        XCTAssertFalse(messages.contains { $0.contains("2 minutes") })
+    }
+
+    func test_debugRawProbe_returnsFormattedOutput() async throws {
         // Given: A probe instance
-        let probe = AugmentStatusProbe()
+        let probe = try self.failingProbe()
 
         // When: We call debugRawProbe
-        let output = await probe.debugRawProbe()
+        let output = await probe.debugRawProbe(cookieHeaderOverride: "session=test")
 
         // Then: The output should contain expected debug information
         XCTAssertTrue(output.contains("=== Augment Debug Probe @"), "Should contain debug header")
@@ -29,10 +50,10 @@ final class AugmentStatusProbeTests: XCTestCase {
 
     func test_debugRawProbe_capturesFailureInDumps() async throws {
         // Given: A probe with an invalid base URL that will fail
-        let invalidProbe = try AugmentStatusProbe(baseURL: XCTUnwrap(URL(string: "https://invalid.example.com")))
+        let invalidProbe = try self.failingProbe()
 
         // When: We call debugRawProbe which should fail
-        let output = await invalidProbe.debugRawProbe()
+        let output = await invalidProbe.debugRawProbe(cookieHeaderOverride: "session=test")
 
         // Then: The output should indicate failure
         XCTAssertTrue(output.contains("Probe Failed"), "Should contain failure message")
@@ -45,11 +66,11 @@ final class AugmentStatusProbeTests: XCTestCase {
 
     func test_latestDumps_maintainsRingBuffer() async throws {
         // Given: Multiple failed probes to fill the ring buffer
-        let invalidProbe = try AugmentStatusProbe(baseURL: XCTUnwrap(URL(string: "https://invalid.example.com")))
+        let invalidProbe = try self.failingProbe()
 
         // When: We generate more than 5 dumps (the ring buffer size)
         for _ in 1...7 {
-            _ = await invalidProbe.debugRawProbe()
+            _ = await invalidProbe.debugRawProbe(cookieHeaderOverride: "session=test")
             // Small delay to ensure different timestamps
             try await Task.sleep(nanoseconds: 100_000_000) // 0.1 seconds
         }
@@ -60,24 +81,24 @@ final class AugmentStatusProbeTests: XCTestCase {
         XCTAssertLessThanOrEqual(separatorCount, 5, "Should maintain at most 5 dumps in ring buffer")
     }
 
-    func test_debugRawProbe_includesTimestamp() async {
+    func test_debugRawProbe_includesTimestamp() async throws {
         // Given: A probe instance
-        let probe = AugmentStatusProbe()
+        let probe = try self.failingProbe()
 
         // When: We call debugRawProbe
-        let output = await probe.debugRawProbe()
+        let output = await probe.debugRawProbe(cookieHeaderOverride: "session=test")
 
         // Then: The output should include an ISO8601 timestamp
         XCTAssertTrue(output.contains("@"), "Should contain timestamp marker")
         XCTAssertTrue(output.contains("==="), "Should contain debug header markers")
     }
 
-    func test_debugRawProbe_includesCreditsBalance() async {
+    func test_debugRawProbe_includesCreditsBalance() async throws {
         // Given: A probe instance
-        let probe = AugmentStatusProbe()
+        let probe = try self.failingProbe()
 
         // When: We call debugRawProbe
-        let output = await probe.debugRawProbe()
+        let output = await probe.debugRawProbe(cookieHeaderOverride: "session=test")
 
         // Then: The output should mention credits balance (either in success or failure)
         XCTAssertTrue(
@@ -85,6 +106,44 @@ final class AugmentStatusProbeTests: XCTestCase {
             "Should contain credits information or failure message")
     }
 
+    func test_creditsLimit_prefersUsageUnitsAvailable() throws {
+        let response = try JSONDecoder().decode(AugmentCreditsResponse.self, from: Data("""
+        {
+          "usageUnitsRemaining": 15,
+          "usageUnitsConsumedThisBillingCycle": 10,
+          "usageUnitsAvailable": 100,
+          "usageBalanceStatus": "active"
+        }
+        """.utf8))
+
+        XCTAssertEqual(response.creditsLimit, 100)
+    }
+
+    func test_creditsLimit_fallsBackToRemainingPlusConsumedWhenAvailableMissing() throws {
+        let response = try JSONDecoder().decode(AugmentCreditsResponse.self, from: Data("""
+        {
+          "usageUnitsRemaining": 15,
+          "usageUnitsConsumedThisBillingCycle": 10,
+          "usageBalanceStatus": "active"
+        }
+        """.utf8))
+
+        XCTAssertEqual(response.creditsLimit, 25)
+    }
+
+    func test_creditsLimit_ignoresZeroAvailableValue() throws {
+        let response = try JSONDecoder().decode(AugmentCreditsResponse.self, from: Data("""
+        {
+          "usageUnitsRemaining": 15,
+          "usageUnitsConsumedThisBillingCycle": 10,
+          "usageUnitsAvailable": 0,
+          "usageBalanceStatus": "active"
+        }
+        """.utf8))
+
+        XCTAssertEqual(response.creditsLimit, 25)
+    }
+
     // MARK: - Cookie Domain Filtering Tests
 
     func test_cookieDomainMatching_exactMatch() throws {
diff --git a/Tests/CodexBarTests/AzureOpenAIUsageFetcherTests.swift b/Tests/CodexBarTests/AzureOpenAIUsageFetcherTests.swift
new file mode 100644
index 0000000000..8e93b0d1f0
--- /dev/null
+++ b/Tests/CodexBarTests/AzureOpenAIUsageFetcherTests.swift
@@ -0,0 +1,282 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct AzureOpenAIUsageFetcherTests {
+    private func makeContext(environment: [String: String]) -> ProviderFetchContext {
+        let browserDetection = BrowserDetection(cacheTTL: 0)
+        return ProviderFetchContext(
+            runtime: .app,
+            sourceMode: .auto,
+            includeCredits: false,
+            webTimeout: 1,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: environment,
+            settings: nil,
+            fetcher: UsageFetcher(environment: environment),
+            claudeFetcher: ClaudeUsageFetcher(browserDetection: browserDetection),
+            browserDetection: browserDetection)
+    }
+
+    @Test
+    func `settings reader trims env vars and normalizes endpoint`() {
+        let environment = [
+            AzureOpenAISettingsReader.apiKeyEnvironmentKey: " 'azure-key' ",
+            AzureOpenAISettingsReader.endpointEnvironmentKey: "my-resource.openai.azure.com",
+            AzureOpenAISettingsReader.deploymentNameEnvironmentKey: " \"chat-deployment\" ",
+        ]
+
+        #expect(AzureOpenAISettingsReader.apiKey(environment: environment) == "azure-key")
+        #expect(
+            AzureOpenAISettingsReader.endpoint(environment: environment)?.absoluteString ==
+                "https://my-resource.openai.azure.com")
+        #expect(AzureOpenAISettingsReader.deploymentName(environment: environment) == "chat-deployment")
+        #expect(AzureOpenAISettingsReader.apiVersion(environment: [:]) == AzureOpenAISettingsReader.defaultAPIVersion)
+    }
+
+    @Test
+    func `missing deployment config returns precise provider error`() async {
+        let descriptor = ProviderDescriptorRegistry.descriptor(for: .azureopenai)
+        let outcome = await descriptor.fetchPlan.fetchOutcome(
+            context: self.makeContext(environment: [
+                AzureOpenAISettingsReader.apiKeyEnvironmentKey: "azure-key",
+                AzureOpenAISettingsReader.endpointEnvironmentKey: "https://example-resource.openai.azure.com",
+            ]),
+            provider: .azureopenai)
+
+        guard case let .failure(error) = outcome.result else {
+            Issue.record("Expected missing deployment to fail")
+            return
+        }
+
+        #expect(error as? AzureOpenAIUsageError == .missingDeploymentName)
+        #expect(error.localizedDescription.contains("deployment not configured"))
+        #expect(outcome.attempts.map(\.wasAvailable) == [true])
+    }
+
+    @Test
+    func `invalid endpoint returns precise provider error before fetch`() async {
+        let descriptor = ProviderDescriptorRegistry.descriptor(for: .azureopenai)
+        let outcome = await descriptor.fetchPlan.fetchOutcome(
+            context: self.makeContext(environment: [
+                AzureOpenAISettingsReader.apiKeyEnvironmentKey: "AZURE_CANARY_KEY",
+                AzureOpenAISettingsReader.endpointEnvironmentKey: "http://127.0.0.1:31337",
+                AzureOpenAISettingsReader.deploymentNameEnvironmentKey: "canary-deployment",
+            ]),
+            provider: .azureopenai)
+
+        guard case let .failure(error) = outcome.result else {
+            Issue.record("Expected invalid endpoint override to fail")
+            return
+        }
+
+        #expect(error as? AzureOpenAISettingsError == .invalidEndpointOverride(
+            AzureOpenAISettingsReader.endpointEnvironmentKey))
+        #expect(error.localizedDescription.contains("HTTPS endpoint"))
+        #expect(outcome.attempts.map(\.wasAvailable) == [true])
+    }
+
+    @Test
+    func `fetcher validates deployment with chat completions request`() async throws {
+        let endpoint = try #require(URL(string: "https://example-resource.openai.azure.com"))
+        let updatedAt = Date(timeIntervalSince1970: 1_800_000_000)
+        let transport = ProviderHTTPTransportStub { request in
+            #expect(request.httpMethod == "POST")
+            #expect(request.url?.path == "/openai/deployments/chat-prod/chat/completions")
+            #expect(request.url?.query == "api-version=2024-10-21")
+            #expect(request.value(forHTTPHeaderField: "api-key") == "azure-key")
+            #expect(request.value(forHTTPHeaderField: "Accept") == "application/json")
+            #expect(request.value(forHTTPHeaderField: "Content-Type") == "application/json")
+
+            let body = try #require(request.httpBody)
+            let json = try #require(JSONSerialization.jsonObject(with: body) as? [String: Any])
+            #expect(json["max_tokens"] as? Int == 1)
+            #expect(json["temperature"] == nil)
+            let messages = try #require(json["messages"] as? [[String: String]])
+            #expect(messages.first?["content"] == "ping")
+
+            let response = try HTTPURLResponse(
+                url: #require(request.url),
+                statusCode: 200,
+                httpVersion: "HTTP/1.1",
+                headerFields: ["Content-Type": "application/json"])!
+            return (Data(#"{"id":"cmpl-1","model":"gpt-4o-mini"}"#.utf8), response)
+        }
+
+        let snapshot = try await AzureOpenAIUsageFetcher.fetchUsage(
+            apiKey: "azure-key",
+            endpoint: endpoint,
+            deploymentName: "chat-prod",
+            transport: transport,
+            updatedAt: updatedAt)
+
+        #expect(snapshot.endpointHost == "example-resource.openai.azure.com")
+        #expect(snapshot.deploymentName == "chat-prod")
+        #expect(snapshot.model == "gpt-4o-mini")
+        #expect(snapshot.apiVersion == AzureOpenAISettingsReader.defaultAPIVersion)
+        #expect(snapshot.updatedAt == updatedAt)
+
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.identity?.providerID == .azureopenai)
+        #expect(usage.identity?.accountOrganization == "example-resource.openai.azure.com")
+        #expect(usage.identity?.loginMethod == "Deployment: chat-prod")
+        #expect(usage.primary?.resetDescription == "Deployment: chat-prod · Model: gpt-4o-mini")
+    }
+
+    @Test
+    func `chat completions URL preserves endpoint path and deployment escaping`() throws {
+        let endpoint = try #require(URL(string: "https://proxy.example.com/base"))
+        let url = try AzureOpenAIUsageFetcher._chatCompletionsURLForTesting(
+            endpoint: endpoint,
+            deploymentName: "chat prod",
+            apiVersion: "2024-10-21")
+
+        #expect(
+            url.absoluteString ==
+                "https://proxy.example.com/base/openai/deployments/chat%20prod/chat/completions?api-version=2024-10-21")
+    }
+
+    @Test
+    func `chat completions URL does not duplicate openai endpoint suffix`() throws {
+        let endpoint = try #require(URL(string: "https://proxy.example.com/base/openai"))
+        let url = try AzureOpenAIUsageFetcher._chatCompletionsURLForTesting(
+            endpoint: endpoint,
+            deploymentName: "chat-prod",
+            apiVersion: "2024-10-21")
+
+        #expect(
+            url.absoluteString ==
+                "https://proxy.example.com/base/openai/deployments/chat-prod/chat/completions?api-version=2024-10-21")
+    }
+
+    @Test
+    func `v1 API validates with OpenAI compatible path and model field`() async throws {
+        let endpoint = try #require(URL(string: "https://example-resource.openai.azure.com"))
+        let transport = ProviderHTTPTransportStub { request in
+            #expect(request.httpMethod == "POST")
+            #expect(
+                request.url?.absoluteString ==
+                    "https://example-resource.openai.azure.com/openai/v1/chat/completions")
+            #expect(request.value(forHTTPHeaderField: "api-key") == "azure-key")
+
+            let body = try #require(request.httpBody)
+            let json = try #require(JSONSerialization.jsonObject(with: body) as? [String: Any])
+            #expect(json["model"] as? String == "chat-prod")
+            #expect(json["max_completion_tokens"] as? Int == 1)
+            #expect(json["max_tokens"] == nil)
+            #expect(json["temperature"] == nil)
+
+            let response = try HTTPURLResponse(
+                url: #require(request.url),
+                statusCode: 200,
+                httpVersion: "HTTP/1.1",
+                headerFields: ["Content-Type": "application/json"])!
+            return (Data(#"{"id":"cmpl-1","model":"gpt-4o-mini"}"#.utf8), response)
+        }
+
+        let snapshot = try await AzureOpenAIUsageFetcher.fetchUsage(
+            apiKey: "azure-key",
+            endpoint: endpoint,
+            deploymentName: "chat-prod",
+            apiVersion: "v1",
+            transport: transport)
+
+        #expect(snapshot.apiVersion == "v1")
+        #expect(snapshot.deploymentName == "chat-prod")
+        #expect(snapshot.model == "gpt-4o-mini")
+    }
+
+    @Test
+    func `v1 API accepts documented openai v1 base URL`() throws {
+        let endpoint = try #require(URL(string: "https://example-resource.openai.azure.com/openai/v1"))
+        let url = try AzureOpenAIUsageFetcher._chatCompletionsURLForTesting(
+            endpoint: endpoint,
+            deploymentName: "chat-prod",
+            apiVersion: "v1")
+
+        #expect(
+            url.absoluteString ==
+                "https://example-resource.openai.azure.com/openai/v1/chat/completions")
+    }
+}
+
+@MainActor
+struct AzureOpenAIProviderAvailabilityTests {
+    @Test
+    func `configured invalid endpoint remains visible for actionable error`() throws {
+        let suite = "AzureOpenAIProviderAvailabilityTests-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        defer { defaults.removePersistentDomain(forName: suite) }
+
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.azureOpenAIAPIKey = "AZURE_CANARY_KEY"
+        settings.azureOpenAIEndpoint = "http://127.0.0.1:31337"
+        settings.azureOpenAIDeploymentName = "canary-deployment"
+
+        let environment = ProviderRegistry.makeEnvironment(
+            base: [:],
+            provider: .azureopenai,
+            settings: settings,
+            tokenOverride: nil)
+        let context = ProviderAvailabilityContext(
+            provider: .azureopenai,
+            settings: settings,
+            environment: environment)
+
+        #expect(AzureOpenAISettingsReader.endpoint(environment: environment) == nil)
+        #expect(AzureOpenAIProviderImplementation().isAvailable(context: context))
+    }
+}
+
+@MainActor
+struct AzureOpenAIMenuDescriptorTests {
+    @Test
+    func `azure openai deployment detail appears in menu`() throws {
+        let suite = "AzureOpenAIMenuDescriptorTests-menu"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.statusChecksEnabled = false
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings)
+        let snapshot = AzureOpenAIUsageSnapshot(
+            endpointHost: "example-resource.openai.azure.com",
+            deploymentName: "chat-prod",
+            model: "gpt-4o-mini",
+            apiVersion: "2024-10-21",
+            updatedAt: Date(timeIntervalSince1970: 1_800_000_000))
+        store._setSnapshotForTesting(snapshot.toUsageSnapshot(), provider: .azureopenai)
+
+        let descriptor = MenuDescriptor.build(
+            provider: .azureopenai,
+            store: store,
+            settings: settings,
+            account: AccountInfo(email: nil, plan: nil),
+            updateReady: false,
+            includeContextualActions: false)
+        let lines = descriptor.sections
+            .flatMap(\.entries)
+            .compactMap { entry -> String? in
+                guard case let .text(text, _) = entry else { return nil }
+                return text
+            }
+
+        #expect(lines.contains("Azure OpenAI"))
+        #expect(lines.contains("Deployment: chat-prod · Model: gpt-4o-mini"))
+    }
+}
diff --git a/Tests/CodexBarTests/BatteryDrainDiagnosticTests.swift b/Tests/CodexBarTests/BatteryDrainDiagnosticTests.swift
index 914c8aaed5..a841725696 100644
--- a/Tests/CodexBarTests/BatteryDrainDiagnosticTests.swift
+++ b/Tests/CodexBarTests/BatteryDrainDiagnosticTests.swift
@@ -14,15 +14,13 @@ struct BatteryDrainDiagnosticTests {
     }
 
     private func makeStatusBarForTesting() -> NSStatusBar {
-        let env = ProcessInfo.processInfo.environment
-        if env["GITHUB_ACTIONS"] == "true" || env["CI"] == "true" {
-            return .system
-        }
-        return NSStatusBar()
+        // Use the real system status bar in tests. Creating standalone NSStatusBar instances
+        // has caused AppKit teardown crashes under swiftpm-testing-helper.
+        .system
     }
 
-    @Test("Fallback provider should not animate when all providers are disabled")
-    func fallbackProviderDoesNotAnimate() {
+    @Test
+    func `Fallback provider should not animate when all providers are disabled`() {
         self.ensureAppKitInitialized()
 
         let settings = SettingsStore(
@@ -54,6 +52,7 @@ struct BatteryDrainDiagnosticTests {
             updater: DisabledUpdaterController(),
             preferencesSelection: PreferencesSelection(),
             statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
 
         #expect(
             controller.needsMenuBarIconAnimation() == false,
@@ -63,8 +62,8 @@ struct BatteryDrainDiagnosticTests {
             "Animation driver should not start for fallback provider")
     }
 
-    @Test("Enabled provider with data should not animate")
-    func enabledProviderWithDataDoesNotAnimate() {
+    @Test
+    func `Enabled provider with data should not animate`() {
         self.ensureAppKitInitialized()
 
         let settings = SettingsStore(
@@ -101,6 +100,7 @@ struct BatteryDrainDiagnosticTests {
             updater: DisabledUpdaterController(),
             preferencesSelection: PreferencesSelection(),
             statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
 
         #expect(
             controller.needsMenuBarIconAnimation() == false,
@@ -110,8 +110,8 @@ struct BatteryDrainDiagnosticTests {
             "Animation driver should be nil when data is present")
     }
 
-    @Test("Enabled provider without data should animate")
-    func enabledProviderWithoutDataAnimates() {
+    @Test
+    func `Enabled provider without data should animate`() {
         self.ensureAppKitInitialized()
 
         let settings = SettingsStore(
@@ -141,9 +141,50 @@ struct BatteryDrainDiagnosticTests {
             updater: DisabledUpdaterController(),
             preferencesSelection: PreferencesSelection(),
             statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
 
         #expect(
             controller.needsMenuBarIconAnimation() == true,
             "Should animate when enabled provider has no data")
     }
+
+    @Test
+    func `Enabled provider with error should not animate`() {
+        self.ensureAppKitInitialized()
+
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "BatteryDrain-ErrorStops"),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+
+        let registry = ProviderRegistry.shared
+        if let meta = registry.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: meta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(
+            fetcher: fetcher,
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings)
+        store._setErrorForTesting("simulated Codex RPC timeout", provider: .codex)
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+
+        #expect(store.isStale(provider: .codex) == true)
+        #expect(
+            controller.needsMenuBarIconAnimation() == false,
+            "Should not animate when provider has recorded an error")
+        #expect(controller.animationDriver == nil)
+    }
 }
diff --git a/Tests/CodexBarTests/BedrockCredentialResolverTests.swift b/Tests/CodexBarTests/BedrockCredentialResolverTests.swift
new file mode 100644
index 0000000000..62db841e99
--- /dev/null
+++ b/Tests/CodexBarTests/BedrockCredentialResolverTests.swift
@@ -0,0 +1,139 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+private final class CapturedEnvironment: @unchecked Sendable {
+    private let lock = NSLock()
+    private var stored: [String: String] = [:]
+    func record(_ environment: [String: String]) {
+        self.lock.withLock { self.stored = environment }
+    }
+
+    var value: [String: String] {
+        self.lock.withLock { self.stored }
+    }
+}
+
+@Suite(.serialized)
+struct BedrockCredentialResolverTests {
+    private static let credentialsJSON = #"""
+    {"Version":1,"AccessKeyId":"AKIAPROFILE","SecretAccessKey":"profile-secret","SessionToken":"profile-token"}
+    """#
+
+    /// Fake AWS CLI runner: returns exported credentials and a profile region.
+    private func profileProvider(region: String = "ap-southeast-2") -> BedrockProfileCredentialProvider {
+        BedrockProfileCredentialProvider(awsBinaryPath: "/usr/bin/aws") { arguments, _ in
+            if arguments.contains("export-credentials") {
+                return SubprocessResult(stdout: Self.credentialsJSON, stderr: "")
+            }
+            if arguments.contains("get") {
+                return SubprocessResult(stdout: region + "\n", stderr: "")
+            }
+            return SubprocessResult(stdout: "", stderr: "")
+        }
+    }
+
+    @Test
+    func `keys mode resolves static credentials and region`() async throws {
+        let env = [
+            BedrockSettingsReader.accessKeyIDKey: "AKIAKEYS",
+            BedrockSettingsReader.secretAccessKeyKey: "keys-secret",
+            BedrockSettingsReader.regionKeys[0]: "us-west-2",
+        ]
+        let resolved = try await BedrockCredentialResolver.resolve(environment: env)
+        #expect(resolved.credentials.accessKeyID == "AKIAKEYS")
+        #expect(resolved.credentials.secretAccessKey == "keys-secret")
+        #expect(resolved.region == "us-west-2")
+    }
+
+    @Test
+    func `keys mode without credentials throws missingCredentials`() async {
+        await #expect(throws: BedrockUsageError.missingCredentials) {
+            try await BedrockCredentialResolver.resolve(environment: [:])
+        }
+    }
+
+    @Test
+    func `profile mode resolves credentials via the AWS CLI`() async throws {
+        let env = [
+            BedrockSettingsReader.authModeKey: "profile",
+            BedrockSettingsReader.profileKey: "work",
+        ]
+        let resolved = try await BedrockCredentialResolver.resolve(
+            environment: env,
+            resolveAWSBinary: { _ in "/usr/bin/aws" },
+            makeProvider: { _ in self.profileProvider() })
+        #expect(resolved.credentials.accessKeyID == "AKIAPROFILE")
+        #expect(resolved.credentials.sessionToken == "profile-token")
+        // No explicit region in env, so it is derived from the profile.
+        #expect(resolved.region == "ap-southeast-2")
+    }
+
+    @Test
+    func `profile mode prefers explicit region over the profile region`() async throws {
+        let env = [
+            BedrockSettingsReader.authModeKey: "profile",
+            BedrockSettingsReader.profileKey: "work",
+            BedrockSettingsReader.regionKeys[0]: "eu-central-1",
+        ]
+        let resolved = try await BedrockCredentialResolver.resolve(
+            environment: env,
+            resolveAWSBinary: { _ in "/usr/bin/aws" },
+            makeProvider: { _ in self.profileProvider() })
+        #expect(resolved.region == "eu-central-1")
+    }
+
+    @Test
+    func `profile mode without a profile name throws missingCredentials`() async {
+        let env = [BedrockSettingsReader.authModeKey: "profile"]
+        await #expect(throws: BedrockUsageError.missingCredentials) {
+            try await BedrockCredentialResolver.resolve(
+                environment: env,
+                resolveAWSBinary: { _ in "/usr/bin/aws" },
+                makeProvider: { _ in self.profileProvider() })
+        }
+    }
+
+    @Test
+    func `profile mode preserves source credentials but removes AWS_PROFILE for AWS CLI`() async throws {
+        let captured = CapturedEnvironment()
+        let env = [
+            BedrockSettingsReader.authModeKey: "profile",
+            BedrockSettingsReader.profileKey: "work",
+            BedrockSettingsReader.accessKeyIDKey: "AKIAINHERITED",
+            BedrockSettingsReader.secretAccessKeyKey: "inherited-secret",
+            BedrockSettingsReader.sessionTokenKey: "inherited-token",
+        ]
+        _ = try await BedrockCredentialResolver.resolve(
+            environment: env,
+            resolveAWSBinary: { _ in "/usr/bin/aws" },
+            makeProvider: { _ in
+                BedrockProfileCredentialProvider(awsBinaryPath: "/usr/bin/aws") { arguments, environment in
+                    captured.record(environment)
+                    if arguments.contains("export-credentials") {
+                        return SubprocessResult(stdout: Self.credentialsJSON, stderr: "")
+                    }
+                    return SubprocessResult(stdout: "us-east-1\n", stderr: "")
+                }
+            })
+        let seen = captured.value
+        #expect(seen[BedrockSettingsReader.accessKeyIDKey] == "AKIAINHERITED")
+        #expect(seen[BedrockSettingsReader.secretAccessKeyKey] == "inherited-secret")
+        #expect(seen[BedrockSettingsReader.sessionTokenKey] == "inherited-token")
+        #expect(seen[BedrockSettingsReader.profileKey] == nil)
+    }
+
+    @Test
+    func `profile mode without the AWS CLI throws awsCLINotFound`() async {
+        let env = [
+            BedrockSettingsReader.authModeKey: "profile",
+            BedrockSettingsReader.profileKey: "work",
+        ]
+        await #expect(throws: BedrockUsageError.awsCLINotFound) {
+            try await BedrockCredentialResolver.resolve(
+                environment: env,
+                resolveAWSBinary: { _ in nil },
+                makeProvider: { _ in self.profileProvider() })
+        }
+    }
+}
diff --git a/Tests/CodexBarTests/BedrockMenuCardTests.swift b/Tests/CodexBarTests/BedrockMenuCardTests.swift
new file mode 100644
index 0000000000..897c4419a5
--- /dev/null
+++ b/Tests/CodexBarTests/BedrockMenuCardTests.swift
@@ -0,0 +1,121 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct BedrockMenuCardTests {
+    @Test
+    func `bedrock cost section labels latest billing day`() throws {
+        let now = Date()
+        let metadata = try #require(ProviderDefaults.metadata[.bedrock])
+        let tokenSnapshot = CostUsageTokenSnapshot(
+            sessionTokens: nil,
+            sessionCostUSD: 12.34,
+            last30DaysTokens: nil,
+            last30DaysCostUSD: 56.78,
+            historyDays: 7,
+            daily: [
+                CostUsageDailyReport.Entry(
+                    date: "2026-05-12",
+                    inputTokens: nil,
+                    outputTokens: nil,
+                    totalTokens: nil,
+                    costUSD: 12.34,
+                    modelsUsed: ["Amazon Bedrock"],
+                    modelBreakdowns: nil),
+            ],
+            updatedAt: now)
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .bedrock,
+            metadata: metadata,
+            snapshot: nil,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: tokenSnapshot,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: true,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.tokenUsage?.sessionLine == "Latest billing day (May 12): $12.34")
+        #expect(model.tokenUsage?.sessionLine.contains("Today") == false)
+        #expect(model.tokenUsage?.monthLine == "Last 7 days: $56.78")
+        #expect(model.tokenUsage?.hintLine == "AWS Cost Explorer billing can lag.")
+    }
+
+    @Test
+    func `bedrock cost section picks latest valid billing day`() throws {
+        let now = Date()
+        let metadata = try #require(ProviderDefaults.metadata[.bedrock])
+        let tokenSnapshot = CostUsageTokenSnapshot(
+            sessionTokens: nil,
+            sessionCostUSD: 23.45,
+            last30DaysTokens: nil,
+            last30DaysCostUSD: 56.78,
+            historyDays: 7,
+            daily: [
+                CostUsageDailyReport.Entry(
+                    date: "not-a-day",
+                    inputTokens: nil,
+                    outputTokens: nil,
+                    totalTokens: 10,
+                    costUSD: 99,
+                    modelsUsed: ["Amazon Bedrock"],
+                    modelBreakdowns: nil),
+                CostUsageDailyReport.Entry(
+                    date: "2026-06-31",
+                    inputTokens: nil,
+                    outputTokens: nil,
+                    totalTokens: 40,
+                    costUSD: 99,
+                    modelsUsed: ["Amazon Bedrock"],
+                    modelBreakdowns: nil),
+                CostUsageDailyReport.Entry(
+                    date: "2026-05-12",
+                    inputTokens: nil,
+                    outputTokens: nil,
+                    totalTokens: 20,
+                    costUSD: 12.34,
+                    modelsUsed: ["Amazon Bedrock"],
+                    modelBreakdowns: nil),
+                CostUsageDailyReport.Entry(
+                    date: "2026-05-13",
+                    inputTokens: nil,
+                    outputTokens: nil,
+                    totalTokens: 30,
+                    costUSD: 23.45,
+                    modelsUsed: ["Amazon Bedrock"],
+                    modelBreakdowns: nil),
+            ],
+            updatedAt: now)
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .bedrock,
+            metadata: metadata,
+            snapshot: nil,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: tokenSnapshot,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: true,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.tokenUsage?.sessionLine == "Latest billing day (May 13): $23.45")
+    }
+}
diff --git a/Tests/CodexBarTests/BedrockProfileCredentialProviderTests.swift b/Tests/CodexBarTests/BedrockProfileCredentialProviderTests.swift
new file mode 100644
index 0000000000..f8861bcd2d
--- /dev/null
+++ b/Tests/CodexBarTests/BedrockProfileCredentialProviderTests.swift
@@ -0,0 +1,93 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct BedrockProfileCredentialProviderTests {
+    private func provider(
+        stdout: String = "",
+        stderr: String = "",
+        throwsNonZero: Bool = false) -> BedrockProfileCredentialProvider
+    {
+        BedrockProfileCredentialProvider(awsBinaryPath: "/usr/bin/aws") { _, _ in
+            if throwsNonZero {
+                throw SubprocessRunnerError.nonZeroExit(code: 1, stderr: stderr)
+            }
+            return SubprocessResult(stdout: stdout, stderr: stderr)
+        }
+    }
+
+    @Test
+    func `parses export-credentials json with session token`() async throws {
+        let json = """
+        {"Version":1,"AccessKeyId":"AKIA","SecretAccessKey":"secret",\
+        "SessionToken":"token","Expiration":"2026-05-27T12:00:00Z"}
+        """
+        let creds = try await provider(stdout: json).exportCredentials(profile: "work")
+        #expect(creds.accessKeyID == "AKIA")
+        #expect(creds.secretAccessKey == "secret")
+        #expect(creds.sessionToken == "token")
+    }
+
+    @Test
+    func `parses export-credentials json without session token`() async throws {
+        let json = #"{"Version":1,"AccessKeyId":"AKIA","SecretAccessKey":"secret"}"#
+        let creds = try await provider(stdout: json).exportCredentials(profile: "work")
+        #expect(creds.accessKeyID == "AKIA")
+        #expect(creds.sessionToken == nil)
+    }
+
+    @Test
+    func `maps expired SSO stderr to profileSessionExpired`() async {
+        let stderr = "The SSO session associated with this profile has expired. " +
+            "To refresh this SSO session run aws sso login with the corresponding profile."
+        let sut = self.provider(stderr: stderr, throwsNonZero: true)
+        await #expect(throws: BedrockUsageError.profileSessionExpired("work")) {
+            try await sut.exportCredentials(profile: "work")
+        }
+    }
+
+    @Test
+    func `maps other non-zero exit to apiError`() async {
+        let sut = self.provider(stderr: "The config profile (work) could not be found", throwsNonZero: true)
+        do {
+            _ = try await sut.exportCredentials(profile: "work")
+            Issue.record("expected an error")
+        } catch let error as BedrockUsageError {
+            if case .apiError = error { } else { Issue.record("expected apiError, got \(error)") }
+        } catch {
+            Issue.record("unexpected error type: \(error)")
+        }
+    }
+
+    @Test
+    func `malformed json throws parseFailed`() async {
+        let sut = self.provider(stdout: "not json")
+        do {
+            _ = try await sut.exportCredentials(profile: "work")
+            Issue.record("expected an error")
+        } catch let error as BedrockUsageError {
+            if case .parseFailed = error { } else { Issue.record("expected parseFailed, got \(error)") }
+        } catch {
+            Issue.record("unexpected error type: \(error)")
+        }
+    }
+
+    @Test
+    func `resolveRegion returns trimmed value`() async throws {
+        let region = try await provider(stdout: "eu-west-1\n").resolveRegion(profile: "work")
+        #expect(region == "eu-west-1")
+    }
+
+    @Test
+    func `resolveRegion returns nil when unset (non-zero exit)`() async throws {
+        let region = try await provider(throwsNonZero: true).resolveRegion(profile: "work")
+        #expect(region == nil)
+    }
+
+    @Test
+    func `resolveRegion returns nil for empty output`() async throws {
+        let region = try await provider(stdout: "\n").resolveRegion(profile: "work")
+        #expect(region == nil)
+    }
+}
diff --git a/Tests/CodexBarTests/BedrockSettingsFlowTests.swift b/Tests/CodexBarTests/BedrockSettingsFlowTests.swift
new file mode 100644
index 0000000000..526eeb80f9
--- /dev/null
+++ b/Tests/CodexBarTests/BedrockSettingsFlowTests.swift
@@ -0,0 +1,103 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@Suite(.serialized)
+@MainActor
+struct BedrockSettingsFlowTests {
+    @Test
+    func `settings store maps Bedrock credentials into provider environment`() throws {
+        let suite = "BedrockSettingsFlowTests-settings-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        settings.bedrockAccessKeyID = "AKIATEST"
+        settings.bedrockSecretAccessKey = "secret"
+        settings.bedrockRegion = "us-west-2"
+
+        let config = try #require(settings.providerConfig(for: .bedrock))
+        #expect(config.sanitizedAPIKey == "AKIATEST")
+        #expect(config.sanitizedSecretKey == "secret")
+        #expect(config.sanitizedCookieHeader == nil)
+        #expect(config.sanitizedRegion == "us-west-2")
+
+        let env = ProviderRegistry.makeEnvironment(
+            base: [:],
+            provider: .bedrock,
+            settings: settings,
+            tokenOverride: nil)
+
+        #expect(env[BedrockSettingsReader.accessKeyIDKey] == "AKIATEST")
+        #expect(env[BedrockSettingsReader.secretAccessKeyKey] == "secret")
+        #expect(env[BedrockSettingsReader.regionKeys[0]] == "us-west-2")
+        #expect(BedrockSettingsReader.hasCredentials(environment: env))
+        #expect(BedrockProviderImplementation().isAvailable(context: ProviderAvailabilityContext(
+            provider: .bedrock,
+            settings: settings,
+            environment: env)))
+    }
+
+    @Test
+    func `bedrock availability requires secret access key`() throws {
+        let suite = "BedrockSettingsFlowTests-missing-secret-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        settings.bedrockAccessKeyID = "AKIATEST"
+
+        let env = ProviderRegistry.makeEnvironment(
+            base: [:],
+            provider: .bedrock,
+            settings: settings,
+            tokenOverride: nil)
+
+        #expect(env[BedrockSettingsReader.accessKeyIDKey] == "AKIATEST")
+        #expect(env[BedrockSettingsReader.secretAccessKeyKey] == nil)
+        #expect(!BedrockProviderImplementation().isAvailable(context: ProviderAvailabilityContext(
+            provider: .bedrock,
+            settings: settings,
+            environment: env)))
+    }
+
+    @Test
+    func `profile mode maps profile into provider environment and is available`() throws {
+        let suite = "BedrockSettingsFlowTests-profile-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        settings.bedrockAuthMode = BedrockAuthMode.profile.rawValue
+        settings.bedrockProfile = "work"
+
+        let config = try #require(settings.providerConfig(for: .bedrock))
+        #expect(config.sanitizedAWSAuthMode == "profile")
+        #expect(config.sanitizedAWSProfile == "work")
+
+        let env = ProviderRegistry.makeEnvironment(
+            base: [:],
+            provider: .bedrock,
+            settings: settings,
+            tokenOverride: nil)
+
+        #expect(env[BedrockSettingsReader.authModeKey] == "profile")
+        #expect(env[BedrockSettingsReader.profileKey] == "work")
+        #expect(env[BedrockSettingsReader.accessKeyIDKey] == nil)
+        #expect(BedrockSettingsReader.hasCredentials(environment: env))
+    }
+}
diff --git a/Tests/CodexBarTests/BedrockSettingsReaderTests.swift b/Tests/CodexBarTests/BedrockSettingsReaderTests.swift
new file mode 100644
index 0000000000..e8a119a1cc
--- /dev/null
+++ b/Tests/CodexBarTests/BedrockSettingsReaderTests.swift
@@ -0,0 +1,50 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct BedrockSettingsReaderTests {
+    @Test
+    func `default auth mode is keys`() {
+        #expect(BedrockSettingsReader.authMode(environment: [:]) == .keys)
+    }
+
+    @Test
+    func `explicit profile auth mode wins`() {
+        let env = ["CODEXBAR_BEDROCK_AUTH_MODE": "profile"]
+        #expect(BedrockSettingsReader.authMode(environment: env) == .profile)
+    }
+
+    @Test
+    func `AWS_PROFILE without keys implies profile mode`() {
+        let env = ["AWS_PROFILE": "work"]
+        #expect(BedrockSettingsReader.authMode(environment: env) == .profile)
+        #expect(BedrockSettingsReader.profile(environment: env) == "work")
+    }
+
+    @Test
+    func `AWS_PROFILE alongside static keys keeps keys mode`() {
+        let env = [
+            "AWS_PROFILE": "work",
+            "AWS_ACCESS_KEY_ID": "AKIA",
+            "AWS_SECRET_ACCESS_KEY": "secret",
+        ]
+        #expect(BedrockSettingsReader.authMode(environment: env) == .keys)
+    }
+
+    @Test
+    func `hasCredentials in profile mode requires a profile name`() {
+        let withProfile = ["CODEXBAR_BEDROCK_AUTH_MODE": "profile", "AWS_PROFILE": "work"]
+        let withoutProfile = ["CODEXBAR_BEDROCK_AUTH_MODE": "profile"]
+        #expect(BedrockSettingsReader.hasCredentials(environment: withProfile))
+        #expect(!BedrockSettingsReader.hasCredentials(environment: withoutProfile))
+    }
+
+    @Test
+    func `hasCredentials in keys mode requires both keys`() {
+        let both = ["AWS_ACCESS_KEY_ID": "AKIA", "AWS_SECRET_ACCESS_KEY": "secret"]
+        let onlyAccess = ["AWS_ACCESS_KEY_ID": "AKIA"]
+        #expect(BedrockSettingsReader.hasCredentials(environment: both))
+        #expect(!BedrockSettingsReader.hasCredentials(environment: onlyAccess))
+    }
+}
diff --git a/Tests/CodexBarTests/BedrockUsageStatsTests.swift b/Tests/CodexBarTests/BedrockUsageStatsTests.swift
new file mode 100644
index 0000000000..dc2dee4724
--- /dev/null
+++ b/Tests/CodexBarTests/BedrockUsageStatsTests.swift
@@ -0,0 +1,712 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct BedrockUsageStatsTests {
+    @Test
+    func `to usage snapshot with budget shows primary window`() {
+        let snapshot = BedrockUsageSnapshot(
+            monthlySpend: 50,
+            monthlyBudget: 200,
+            inputTokens: 1_500_000,
+            outputTokens: 500_000,
+            requestCount: 42,
+            region: "us-east-1",
+            updatedAt: Date(timeIntervalSince1970: 1_739_841_600))
+
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.primary?.usedPercent == 25)
+        #expect(usage.primary?.resetDescription == "Monthly budget")
+        #expect(usage.primary?.resetsAt != nil)
+        #expect(usage.providerCost?.used == 50)
+        #expect(usage.providerCost?.limit == 200)
+        #expect(usage.providerCost?.currencyCode == "USD")
+        #expect(usage.providerCost?.period == "Monthly")
+        #expect(usage.identity?.providerID == .bedrock)
+        #expect(usage.identity?.loginMethod?.contains("Spend: $50.00") == true)
+        #expect(usage.identity?.loginMethod?.contains("Claude 14d: 2.0M tokens") == true)
+        #expect(usage.identity?.loginMethod?.contains("Requests: 42") == true)
+    }
+
+    @Test
+    func `to usage snapshot without budget omits primary window`() {
+        let snapshot = BedrockUsageSnapshot(
+            monthlySpend: 75.5,
+            monthlyBudget: nil,
+            region: "us-west-2",
+            updatedAt: Date(timeIntervalSince1970: 1_739_841_600))
+
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.primary == nil)
+        #expect(usage.providerCost?.used == 75.5)
+        #expect(usage.providerCost?.limit == 0)
+    }
+
+    @Test
+    func `settings reader parses credentials from environment`() {
+        let env = [
+            "AWS_ACCESS_KEY_ID": "AKIAIOSFODNN7EXAMPLE",
+            "AWS_SECRET_ACCESS_KEY": "secret",
+            "AWS_REGION": "eu-west-1",
+            "CODEXBAR_BEDROCK_BUDGET": "500",
+        ]
+
+        #expect(BedrockSettingsReader.accessKeyID(environment: env) == "AKIAIOSFODNN7EXAMPLE")
+        #expect(BedrockSettingsReader.secretAccessKey(environment: env) == "secret")
+        #expect(BedrockSettingsReader.region(environment: env) == "eu-west-1")
+        #expect(BedrockSettingsReader.budget(environment: env) == 500)
+        #expect(BedrockSettingsReader.hasCredentials(environment: env))
+    }
+
+    @Test
+    func `settings reader requires both credential fields`() {
+        #expect(!BedrockSettingsReader.hasCredentials(environment: [:]))
+        #expect(!BedrockSettingsReader.hasCredentials(environment: [
+            "AWS_ACCESS_KEY_ID": "AKIATEST",
+        ]))
+        #expect(!BedrockSettingsReader.hasCredentials(environment: [
+            "AWS_SECRET_ACCESS_KEY": "secret",
+        ]))
+    }
+
+    @Test
+    func `cost explorer response parsing extracts total`() async throws {
+        let registered = URLProtocol.registerClass(BedrockStubURLProtocol.self)
+        defer {
+            if registered {
+                URLProtocol.unregisterClass(BedrockStubURLProtocol.self)
+            }
+            BedrockStubURLProtocol.handler = nil
+        }
+
+        BedrockStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            let body = """
+            {
+                "ResultsByTime": [
+                    {
+                        "TimePeriod": {"Start": "2026-04-01", "End": "2026-04-06"},
+                        "Groups": [
+                            {
+                                "Keys": ["Claude Opus (Bedrock Edition)"],
+                                "Metrics": {"UnblendedCost": {"Amount": "30.00", "Unit": "USD"}}
+                            },
+                            {
+                                "Keys": ["Claude Sonnet (Bedrock Edition)"],
+                                "Metrics": {"UnblendedCost": {"Amount": "12.50", "Unit": "USD"}}
+                            },
+                            {
+                                "Keys": ["Amazon EC2"],
+                                "Metrics": {"UnblendedCost": {"Amount": "5.00", "Unit": "USD"}}
+                            }
+                        ]
+                    }
+                ]
+            }
+            """
+            return Self.makeResponse(url: url, body: body, statusCode: 200)
+        }
+
+        let credentials = BedrockAWSSigner.Credentials(
+            accessKeyID: "AKIATEST",
+            secretAccessKey: "testSecret",
+            sessionToken: nil)
+
+        let usage = try await BedrockUsageFetcher.fetchUsage(
+            credentials: credentials,
+            region: "us-east-1",
+            budget: 100,
+            environment: ["CODEXBAR_BEDROCK_API_URL": "https://bedrock.test"])
+
+        #expect(usage.monthlySpend == 42.50)
+        #expect(usage.monthlyBudget == 100)
+        #expect(usage.region == "us-east-1")
+    }
+
+    @Test
+    func `cost explorer data unavailable response returns zero usage`() async throws {
+        let registered = URLProtocol.registerClass(BedrockStubURLProtocol.self)
+        defer {
+            if registered {
+                URLProtocol.unregisterClass(BedrockStubURLProtocol.self)
+            }
+            BedrockStubURLProtocol.handler = nil
+        }
+
+        BedrockStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            return Self.makeResponse(
+                url: url,
+                body: #"{"__type":"com.amazonaws.ce#DataUnavailableException","message":"Data is not ready"}"#,
+                statusCode: 400)
+        }
+
+        let credentials = BedrockAWSSigner.Credentials(
+            accessKeyID: "AKIATEST",
+            secretAccessKey: "testSecret",
+            sessionToken: nil)
+
+        let usage = try await BedrockUsageFetcher.fetchUsage(
+            credentials: credentials,
+            region: "us-east-1",
+            budget: 100,
+            environment: [BedrockSettingsReader.apiURLKey: "https://bedrock.test"])
+
+        #expect(usage.monthlySpend == 0)
+        #expect(usage.monthlyBudget == 100)
+    }
+
+    @Test
+    func `cost explorer unrelated bad request remains an API error`() async throws {
+        let registered = URLProtocol.registerClass(BedrockStubURLProtocol.self)
+        defer {
+            if registered {
+                URLProtocol.unregisterClass(BedrockStubURLProtocol.self)
+            }
+            BedrockStubURLProtocol.handler = nil
+        }
+
+        BedrockStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            return Self.makeResponse(
+                url: url,
+                body: #"{"__type":"ValidationException","message":"Invalid request"}"#,
+                statusCode: 400)
+        }
+
+        let credentials = BedrockAWSSigner.Credentials(
+            accessKeyID: "AKIATEST",
+            secretAccessKey: "testSecret",
+            sessionToken: nil)
+
+        await #expect(throws: BedrockUsageError.apiError("HTTP 400")) {
+            try await BedrockUsageFetcher.fetchUsage(
+                credentials: credentials,
+                region: "us-east-1",
+                budget: nil,
+                environment: [BedrockSettingsReader.apiURLKey: "https://bedrock.test"])
+        }
+    }
+
+    @Test
+    func `cost explorer rejects remote HTTP override before transport`() async throws {
+        let registered = URLProtocol.registerClass(BedrockStubURLProtocol.self)
+        defer {
+            if registered {
+                URLProtocol.unregisterClass(BedrockStubURLProtocol.self)
+            }
+            BedrockStubURLProtocol.handler = nil
+        }
+        let capture = BedrockRequestCapture()
+        BedrockStubURLProtocol.handler = { request in
+            capture.append(request)
+            throw URLError(.badURL)
+        }
+
+        await #expect(throws: BedrockUsageError.parseFailed("invalid endpoint override")) {
+            try await BedrockUsageFetcher.fetchUsage(
+                credentials: Self.testCredentials,
+                region: "us-east-1",
+                budget: nil,
+                environment: [BedrockSettingsReader.apiURLKey: "http://bedrock.test"])
+        }
+        #expect(capture.requests.isEmpty)
+    }
+
+    @Test
+    func `cost explorer pagination aggregates monthly total`() async throws {
+        let registered = URLProtocol.registerClass(BedrockStubURLProtocol.self)
+        defer {
+            if registered {
+                URLProtocol.unregisterClass(BedrockStubURLProtocol.self)
+            }
+            BedrockStubURLProtocol.handler = nil
+        }
+
+        let responses = BedrockStubResponseQueue([
+            """
+            {
+                "NextPageToken": "page-2",
+                "ResultsByTime": [
+                    {
+                        "TimePeriod": {"Start": "2026-04-01", "End": "2026-04-06"},
+                        "Groups": [
+                            {
+                                "Keys": ["Amazon EC2"],
+                                "Metrics": {"UnblendedCost": {"Amount": "5.00", "Unit": "USD"}}
+                            }
+                        ]
+                    }
+                ]
+            }
+            """,
+            """
+            {
+                "ResultsByTime": [
+                    {
+                        "TimePeriod": {"Start": "2026-04-01", "End": "2026-04-06"},
+                        "Groups": [
+                            {
+                                "Keys": ["Amazon Bedrock"],
+                                "Metrics": {"UnblendedCost": {"Amount": "12.00", "Unit": "USD"}}
+                            },
+                            {
+                                "Keys": ["Claude Sonnet (Bedrock Edition)"],
+                                "Metrics": {"UnblendedCost": {"Amount": "8.00", "Unit": "USD"}}
+                            }
+                        ]
+                    }
+                ]
+            }
+            """,
+        ])
+        BedrockStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            return responses.next(url: url)
+        }
+
+        let credentials = BedrockAWSSigner.Credentials(
+            accessKeyID: "AKIATEST",
+            secretAccessKey: "testSecret",
+            sessionToken: nil)
+
+        let usage = try await BedrockUsageFetcher.fetchUsage(
+            credentials: credentials,
+            region: "us-east-1",
+            budget: nil,
+            environment: [BedrockSettingsReader.apiURLKey: "https://bedrock.test"])
+
+        #expect(usage.monthlySpend == 20)
+        #expect(responses.remainingCount == 0)
+    }
+
+    @Test
+    func `cost usage fetcher uses provided bedrock environment`() async throws {
+        let registered = URLProtocol.registerClass(BedrockStubURLProtocol.self)
+        defer {
+            if registered {
+                URLProtocol.unregisterClass(BedrockStubURLProtocol.self)
+            }
+            BedrockStubURLProtocol.handler = nil
+        }
+
+        let responses = BedrockStubResponseQueue([
+            """
+            {
+                "NextPageToken": "daily-page-2",
+                "ResultsByTime": [
+                    {
+                        "TimePeriod": {"Start": "2025-12-10", "End": "2025-12-11"},
+                        "Groups": [
+                            {
+                                "Keys": ["Amazon EC2"],
+                                "Metrics": {"UnblendedCost": {"Amount": "5.00", "Unit": "USD"}}
+                            }
+                        ]
+                    }
+                ]
+            }
+            """,
+            """
+            {
+                "ResultsByTime": [
+                    {
+                        "TimePeriod": {"Start": "2025-12-10", "End": "2025-12-11"},
+                        "Groups": [
+                            {
+                                "Keys": ["Amazon Bedrock"],
+                                "Metrics": {"UnblendedCost": {"Amount": "7.25", "Unit": "USD"}}
+                            }
+                        ]
+                    }
+                ]
+            }
+            """,
+        ])
+        BedrockStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            return responses.next(url: url)
+        }
+
+        let snapshot = try await CostUsageFetcher().loadTokenSnapshot(
+            provider: .bedrock,
+            environment: [
+                BedrockSettingsReader.accessKeyIDKey: "AKIATEST",
+                BedrockSettingsReader.secretAccessKeyKey: "testSecret",
+                BedrockSettingsReader.apiURLKey: "https://bedrock.test",
+            ],
+            now: Date(timeIntervalSince1970: 1_765_324_800))
+
+        #expect(snapshot.last30DaysCostUSD == 7.25)
+        #expect(snapshot.sessionCostUSD == 7.25)
+        #expect(snapshot.daily.map(\.date) == ["2025-12-10"])
+        #expect(responses.remainingCount == 0)
+    }
+
+    @Test
+    func `current month range uses UTC calendar`() throws {
+        let originalTimeZone = NSTimeZone.default
+        NSTimeZone.default = TimeZone(secondsFromGMT: 14 * 60 * 60)!
+        defer {
+            NSTimeZone.default = originalTimeZone
+        }
+
+        let now = try #require(ISO8601DateFormatter().date(from: "2026-05-10T12:00:00Z"))
+        let range = BedrockUsageFetcher.currentMonthRange(now: now)
+
+        #expect(range.start == "2026-05-01")
+        #expect(range.end == "2026-05-11")
+    }
+
+    @Test
+    func `cloudwatch fetch aggregates Claude activity with bounded signed query`() async throws {
+        let now = try #require(ISO8601DateFormatter().date(from: "2026-06-19T12:00:00Z"))
+        let capture = BedrockRequestCapture()
+        let transport = ProviderHTTPTransportHandler { request in
+            capture.append(request)
+            let requestURL = try #require(request.url)
+            let response = try #require(HTTPURLResponse(
+                url: requestURL,
+                statusCode: 200,
+                httpVersion: "HTTP/1.1",
+                headerFields: ["Content-Type": "application/json"]))
+            let body = """
+            {
+                "MetricDataResults": [
+                    {"Id":"inputTokens","StatusCode":"Complete","Values":[1000,2500]},
+                    {"Id":"outputTokens","StatusCode":"Complete","Values":[400,600]},
+                    {"Id":"requests","StatusCode":"Complete","Values":[7,8]}
+                ]
+            }
+            """
+            return (Data(body.utf8), response)
+        }
+
+        let activity = try await BedrockCloudWatchUsageFetcher.fetch(
+            credentials: Self.testCredentials,
+            region: "us-west-2",
+            now: now,
+            endpointOverride: "https://cloudwatch.test",
+            transport: transport)
+
+        #expect(activity == BedrockClaudeActivity(inputTokens: 3500, outputTokens: 1000, requestCount: 15))
+        let request = try #require(capture.requests.first)
+        #expect(capture.requests.count == 1)
+        #expect(request.value(forHTTPHeaderField: "X-Amz-Target") ==
+            "GraniteServiceVersion20100801.GetMetricData")
+        #expect(request.value(forHTTPHeaderField: "Content-Type") == "application/x-amz-json-1.0")
+        #expect(request.value(forHTTPHeaderField: "Authorization")?.contains(
+            "/us-west-2/monitoring/aws4_request") == true)
+
+        let requestBody = try #require(request.httpBody)
+        let payload = try #require(try JSONSerialization.jsonObject(with: requestBody) as? [String: Any])
+        #expect(payload["StartTime"] as? Double == now.timeIntervalSince1970 - 14 * 24 * 60 * 60)
+        #expect(payload["EndTime"] as? Double == now.timeIntervalSince1970)
+        let queries = try #require(payload["MetricDataQueries"] as? [[String: Any]])
+        #expect(queries.count == 3)
+        #expect(queries.allSatisfy { query in
+            guard let expression = query["Expression"] as? String else { return false }
+            return expression.hasPrefix("SUM(SEARCH(") && expression.contains("claude") &&
+                expression.contains("86400")
+        })
+    }
+
+    @Test
+    func `cloudwatch pagination aggregates pages`() async throws {
+        let transport = ProviderHTTPTransportHandler { request in
+            let requestBody = try #require(request.httpBody)
+            let payload = try #require(JSONSerialization.jsonObject(with: requestBody) as? [String: Any])
+            let isSecondPage = payload["NextToken"] as? String == "page-2"
+            let body = if isSecondPage {
+                """
+                {"MetricDataResults":[{"Id":"inputTokens","StatusCode":"Complete","Values":[3]}]}
+                """
+            } else {
+                """
+                {
+                    "NextToken":"page-2",
+                    "MetricDataResults":[{"Id":"inputTokens","StatusCode":"Complete","Values":[2]}]
+                }
+                """
+            }
+            let requestURL = try #require(request.url)
+            let response = try #require(HTTPURLResponse(
+                url: requestURL,
+                statusCode: 200,
+                httpVersion: "HTTP/1.1",
+                headerFields: nil))
+            return (Data(body.utf8), response)
+        }
+
+        let activity = try await BedrockCloudWatchUsageFetcher.fetch(
+            credentials: Self.testCredentials,
+            region: "us-east-1",
+            now: Date(timeIntervalSince1970: 1_750_000_000),
+            endpointOverride: "https://cloudwatch.test",
+            transport: transport)
+
+        #expect(activity.inputTokens == 5)
+        #expect(activity.outputTokens == 0)
+        #expect(activity.requestCount == 0)
+    }
+
+    @Test
+    func `cloudwatch rejects incomplete search results`() async throws {
+        let transport = ProviderHTTPTransportHandler { request in
+            let requestURL = try #require(request.url)
+            let response = try #require(HTTPURLResponse(
+                url: requestURL,
+                statusCode: 200,
+                httpVersion: "HTTP/1.1",
+                headerFields: nil))
+            let body = #"{"Messages":[{"Code":"MaxQueryLimit","Value":"Maximum number exceeded"}]}"#
+            return (Data(body.utf8), response)
+        }
+
+        await #expect(throws: BedrockUsageError.cloudWatchParseFailed(
+            "CloudWatch reported incomplete results"))
+        {
+            try await BedrockCloudWatchUsageFetcher.fetch(
+                credentials: Self.testCredentials,
+                region: "us-east-1",
+                now: Date(timeIntervalSince1970: 1_750_000_000),
+                endpointOverride: "https://cloudwatch.test",
+                transport: transport)
+        }
+    }
+
+    @Test
+    func `cloudwatch permission failure preserves cost explorer usage`() async throws {
+        let registered = URLProtocol.registerClass(BedrockStubURLProtocol.self)
+        defer {
+            if registered {
+                URLProtocol.unregisterClass(BedrockStubURLProtocol.self)
+            }
+            BedrockStubURLProtocol.handler = nil
+        }
+        BedrockStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            let body = """
+            {
+                "ResultsByTime": [{
+                    "Groups": [{
+                        "Keys": ["Amazon Bedrock"],
+                        "Metrics": {"UnblendedCost": {"Amount": "12.50"}}
+                    }]
+                }]
+            }
+            """
+            return Self.makeResponse(url: url, body: body)
+        }
+        let cloudWatchTransport = ProviderHTTPTransportHandler { request in
+            let requestURL = try #require(request.url)
+            let response = try #require(HTTPURLResponse(
+                url: requestURL,
+                statusCode: 403,
+                httpVersion: "HTTP/1.1",
+                headerFields: nil))
+            return (Data(), response)
+        }
+        let now = Date(timeIntervalSince1970: 1_750_000_000)
+
+        let usage = try await BedrockUsageFetcher.fetchUsage(
+            credentials: Self.testCredentials,
+            region: "us-east-1",
+            budget: nil,
+            environment: [
+                BedrockSettingsReader.apiURLKey: "https://bedrock.test",
+                BedrockSettingsReader.cloudWatchAPIURLKey: "https://cloudwatch.test",
+            ],
+            now: now,
+            cloudWatchTransport: cloudWatchTransport)
+
+        #expect(usage.monthlySpend == 12.5)
+        #expect(usage.inputTokens == nil)
+        #expect(usage.outputTokens == nil)
+        #expect(usage.requestCount == nil)
+        #expect(usage.updatedAt == now)
+    }
+
+    @Test
+    func `cloudwatch invalid override fails closed without transport`() async throws {
+        let capture = BedrockRequestCapture()
+        let transport = ProviderHTTPTransportHandler { request in
+            capture.append(request)
+            throw URLError(.badURL)
+        }
+
+        for override in ["   ", "not-an-absolute-url", "http://cloudwatch.test"] {
+            await #expect(throws: BedrockUsageError.cloudWatchParseFailed("invalid endpoint override")) {
+                try await BedrockCloudWatchUsageFetcher.fetch(
+                    credentials: Self.testCredentials,
+                    region: "us-east-1",
+                    now: Date(timeIntervalSince1970: 1_750_000_000),
+                    endpointOverride: override,
+                    transport: transport)
+            }
+        }
+        #expect(capture.requests.isEmpty)
+    }
+
+    @Test
+    func `cloudwatch allows HTTP only for loopback overrides`() async throws {
+        let capture = BedrockRequestCapture()
+        let transport = ProviderHTTPTransportHandler { request in
+            capture.append(request)
+            let requestURL = try #require(request.url)
+            let response = try #require(HTTPURLResponse(
+                url: requestURL,
+                statusCode: 200,
+                httpVersion: "HTTP/1.1",
+                headerFields: nil))
+            return (Data(#"{"MetricDataResults":[]}"#.utf8), response)
+        }
+        let overrides = [
+            "http://localhost:8080",
+            "http://127.42.0.1:8080",
+            "http://[::1]:8080",
+        ]
+
+        for endpointOverride in overrides {
+            _ = try await BedrockCloudWatchUsageFetcher.fetch(
+                credentials: Self.testCredentials,
+                region: "us-east-1",
+                now: Date(timeIntervalSince1970: 1_750_000_000),
+                endpointOverride: endpointOverride,
+                transport: transport)
+        }
+
+        #expect(capture.requests.compactMap(\.url?.absoluteString) == overrides)
+    }
+
+    @Test
+    func `cloudwatch resolves AWS partition endpoints`() async throws {
+        let capture = BedrockRequestCapture()
+        let transport = ProviderHTTPTransportHandler { request in
+            capture.append(request)
+            let requestURL = try #require(request.url)
+            let response = try #require(HTTPURLResponse(
+                url: requestURL,
+                statusCode: 200,
+                httpVersion: "HTTP/1.1",
+                headerFields: nil))
+            return (Data(#"{"MetricDataResults":[]}"#.utf8), response)
+        }
+        let cases = [
+            ("us-east-1", "monitoring.us-east-1.amazonaws.com"),
+            ("us-gov-west-1", "monitoring.us-gov-west-1.amazonaws.com"),
+            ("cn-north-1", "monitoring.cn-north-1.amazonaws.com.cn"),
+            ("eusc-de-east-1", "monitoring.eusc-de-east-1.amazonaws.eu"),
+            ("us-iso-east-1", "monitoring.us-iso-east-1.c2s.ic.gov"),
+            ("us-isob-east-1", "monitoring.us-isob-east-1.sc2s.sgov.gov"),
+            ("eu-isoe-west-1", "monitoring.eu-isoe-west-1.cloud.adc-e.uk"),
+            ("us-isof-south-1", "monitoring.us-isof-south-1.csp.hci.ic.gov"),
+        ]
+
+        for (region, _) in cases {
+            _ = try await BedrockCloudWatchUsageFetcher.fetch(
+                credentials: Self.testCredentials,
+                region: region,
+                now: Date(timeIntervalSince1970: 1_750_000_000),
+                endpointOverride: nil,
+                transport: transport)
+        }
+
+        #expect(capture.requests.compactMap(\.url?.host) == cases.map(\.1))
+    }
+
+    private static let testCredentials = BedrockAWSSigner.Credentials(
+        accessKeyID: "AKIATEST",
+        secretAccessKey: "testSecret",
+        sessionToken: nil)
+
+    private final class BedrockStubResponseQueue {
+        private let lock = NSLock()
+        private var bodies: [String]
+
+        init(_ bodies: [String]) {
+            self.bodies = bodies
+        }
+
+        var remainingCount: Int {
+            self.lock.lock()
+            defer { self.lock.unlock() }
+            return self.bodies.count
+        }
+
+        func next(url: URL) -> (HTTPURLResponse, Data) {
+            self.lock.lock()
+            let body = self.bodies.isEmpty ? #"{"ResultsByTime":[]}"# : self.bodies.removeFirst()
+            self.lock.unlock()
+
+            let response = HTTPURLResponse(
+                url: url,
+                statusCode: 200,
+                httpVersion: "HTTP/1.1",
+                headerFields: ["Content-Type": "application/json"])!
+            return (response, Data(body.utf8))
+        }
+    }
+
+    private static func makeResponse(
+        url: URL,
+        body: String,
+        statusCode: Int = 200) -> (HTTPURLResponse, Data)
+    {
+        let response = HTTPURLResponse(
+            url: url,
+            statusCode: statusCode,
+            httpVersion: "HTTP/1.1",
+            headerFields: ["Content-Type": "application/json"])!
+        return (response, Data(body.utf8))
+    }
+}
+
+private final class BedrockRequestCapture: @unchecked Sendable {
+    private let lock = NSLock()
+    private var storage: [URLRequest] = []
+
+    var requests: [URLRequest] {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        return self.storage
+    }
+
+    func append(_ request: URLRequest) {
+        self.lock.lock()
+        self.storage.append(request)
+        self.lock.unlock()
+    }
+}
+
+final class BedrockStubURLProtocol: URLProtocol {
+    nonisolated(unsafe) static var handler: ((URLRequest) throws -> (HTTPURLResponse, Data))?
+
+    override static func canInit(with request: URLRequest) -> Bool {
+        request.url?.host == "bedrock.test"
+    }
+
+    override static func canonicalRequest(for request: URLRequest) -> URLRequest {
+        request
+    }
+
+    override func startLoading() {
+        guard let handler = Self.handler else {
+            self.client?.urlProtocol(self, didFailWithError: URLError(.badServerResponse))
+            return
+        }
+        do {
+            let (response, data) = try handler(self.request)
+            self.client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
+            self.client?.urlProtocol(self, didLoad: data)
+            self.client?.urlProtocolDidFinishLoading(self)
+        } catch {
+            self.client?.urlProtocol(self, didFailWithError: error)
+        }
+    }
+
+    override func stopLoading() {}
+}
diff --git a/Tests/CodexBarTests/BrowserCookieOrderLabelTests.swift b/Tests/CodexBarTests/BrowserCookieOrderLabelTests.swift
index 64e6e0934d..c8cf68d48a 100644
--- a/Tests/CodexBarTests/BrowserCookieOrderLabelTests.swift
+++ b/Tests/CodexBarTests/BrowserCookieOrderLabelTests.swift
@@ -1,22 +1,73 @@
-import CodexBarCore
 import SweetCookieKit
 import Testing
+@testable import CodexBarCore
 
-@Suite
 struct BrowserCookieOrderStatusStringTests {
     #if os(macOS)
     @Test
-    func cursorNoSessionIncludesBrowserLoginHint() {
+    func `codex cookie import order keeps firefox ahead of extra chromium browsers`() {
+        let order = ProviderDefaults.metadata[.codex]?.browserCookieOrder ?? Browser.defaultImportOrder
+        #expect(Array(order.prefix(3)) == [.safari, .chrome, .firefox])
+    }
+
+    @Test
+    func `automatic cookie import includes newly supported chromium browsers`() {
+        #expect(Browser.defaultImportOrder.contains(.comet))
+        #expect(Browser.defaultImportOrder.contains(.yandex))
+    }
+
+    @Test
+    func `cursor no session includes browser login hint`() {
         let order = ProviderDefaults.metadata[.cursor]?.browserCookieOrder ?? Browser.defaultImportOrder
         let message = CursorStatusProbeError.noSessionCookie.errorDescription ?? ""
         #expect(message.contains(order.loginHint))
     }
 
     @Test
-    func factoryNoSessionIncludesBrowserLoginHint() {
+    func `cursor no session shows full disk access hint before browser list`() throws {
+        let order = ProviderDefaults.metadata[.cursor]?.browserCookieOrder ?? Browser.defaultImportOrder
+        let message = try #require(CursorStatusProbeError.noSessionCookie.errorDescription)
+        let fullDiskAccessRange = try #require(message.range(of: CursorStatusProbeError.safariFullDiskAccessHint))
+        let browserListRange = try #require(message.range(of: order.loginHint))
+
+        #expect(fullDiskAccessRange.lowerBound < browserListRange.lowerBound)
+    }
+
+    @Test
+    func `factory no session includes browser login hint`() {
         let order = ProviderDefaults.metadata[.factory]?.browserCookieOrder ?? Browser.defaultImportOrder
         let message = FactoryStatusProbeError.noSessionCookie.errorDescription ?? ""
         #expect(message.contains(order.loginHint))
     }
+
+    @Test
+    func `opencode go automatic cookies use full provider browser order`() {
+        let order = OpenCodeWebCookieSupport.automaticImportOrder(provider: .opencodego)
+        #expect(order == ProviderDefaults.metadata[.opencodego]?.browserCookieOrder)
+        #expect(order.contains(.edge))
+        #expect(order.contains(.firefox))
+    }
+
+    @Test
+    func `opencode automatic cookies keep chrome only default`() {
+        #expect(OpenCodeWebCookieSupport.automaticImportOrder(provider: .opencode) == [.chrome])
+    }
+
+    @Test
+    func `mimo cookie import order supports safari firefox and edge`() {
+        let order = ProviderDefaults.metadata[.mimo]?.browserCookieOrder ?? Browser.defaultImportOrder
+        #expect(order == ProviderBrowserCookieDefaults.mimoCookieImportOrder)
+        #expect(order == [.safari, .chrome, .chromeBeta, .chromeCanary, .firefox, .edge])
+        #expect(order.first == .safari)
+        #expect(order.contains(.firefox))
+        #expect(order.contains(.edge))
+        #expect(!order.contains(.arc))
+    }
+
+    @Test
+    func `copilot cookie imports default to chrome only`() {
+        #expect(ProviderDefaults.metadata[.copilot]?.browserCookieOrder == [.chrome])
+        #expect(ProviderBrowserCookieDefaults.copilotCookieImportOrder == [.chrome])
+    }
     #endif
 }
diff --git a/Tests/CodexBarTests/BrowserDetectionTests.swift b/Tests/CodexBarTests/BrowserDetectionTests.swift
index fe4f32a830..19945ba9dd 100644
--- a/Tests/CodexBarTests/BrowserDetectionTests.swift
+++ b/Tests/CodexBarTests/BrowserDetectionTests.swift
@@ -1,27 +1,113 @@
-import CodexBarCore
 import Foundation
+import os.lock
 import Testing
+@testable import CodexBarCore
 
 #if os(macOS)
 import SweetCookieKit
 
-@Suite
+@Suite(.serialized)
 struct BrowserDetectionTests {
+    @Test(.disabled(
+        if: ProcessInfo.processInfo.environment[BrowserCookieAccessGate.allowTestCookieAccessEnvironmentKey] == "1",
+        "Default-home cookie access is explicitly enabled for this test run."))
+    func `default home detection is suppressed before profile probes`() throws {
+        let probeCount = OSAllocatedUnfairLock(initialState: 0)
+        let defaultHome = try #require(BrowserCookieClient.defaultHomeDirectories().first)
+        let detection = BrowserDetection(
+            homeDirectory: defaultHome.path,
+            cacheTTL: 0,
+            fileExists: { _ in
+                probeCount.withLock { $0 += 1 }
+                return false
+            },
+            directoryContents: { _ in
+                probeCount.withLock { $0 += 1 }
+                return nil
+            })
+
+        _ = detection.isCookieSourceAvailable(.chrome)
+        #expect(probeCount.withLock { $0 } == 0)
+    }
+
+    @Test(.disabled(
+        if: ProcessInfo.processInfo.environment[BrowserCookieAccessGate.allowTestCookieAccessEnvironmentKey] == "1",
+        "Default-home cookie access is explicitly enabled for this test run."))
+    func `default client reports structured suppression before store discovery`() {
+        let client = BrowserCookieClient()
+
+        #expect(throws: BrowserCookieStoreAccessSuppressedError.self) {
+            _ = try client.codexBarStores(for: .chrome)
+        }
+        #expect(throws: BrowserCookieStoreAccessSuppressedError.self) {
+            _ = try client.codexBarRecords(
+                matching: BrowserCookieQuery(domains: ["example.com"]),
+                in: .safari)
+        }
+    }
+
     @Test
-    func safariAlwaysInstalled() {
+    func `cookie store decision allows production and explicit test opt in`() {
+        let defaultHomes = BrowserCookieClient.defaultHomeDirectories()
+        let testProcess = "swiftpm-testing-helper"
+
+        #expect(BrowserCookieAccessGate.cookieStoreAccessDecision(
+            homeDirectories: defaultHomes,
+            processName: testProcess,
+            environment: [:]) == .suppressed)
+        #expect(BrowserCookieAccessGate.cookieStoreAccessDecision(
+            homeDirectories: defaultHomes,
+            processName: testProcess,
+            environment: [BrowserCookieAccessGate.allowTestCookieAccessEnvironmentKey: "1"]) == .allowed)
+        #expect(BrowserCookieAccessGate.cookieStoreAccessDecision(
+            homeDirectories: defaultHomes,
+            processName: "CodexBar",
+            environment: [:]) == .allowed)
+    }
+
+    @Test(.disabled(
+        if: ProcessInfo.processInfo.environment[BrowserCookieAccessGate.allowTestCookieAccessEnvironmentKey] == "1",
+        "Default-home cookie access is explicitly enabled for this test run."))
+    func `safari is installed but default cookie access is disabled during tests`() {
         #expect(BrowserDetection(cacheTTL: 0).isAppInstalled(.safari) == true)
-        #expect(BrowserDetection(cacheTTL: 0).isCookieSourceAvailable(.safari) == true)
+        #expect(BrowserDetection(cacheTTL: 0).isCookieSourceAvailable(.safari) == false)
     }
 
-    @Test
-    func filterInstalledIncludesSafari() {
+    @Test(.disabled(
+        if: ProcessInfo.processInfo.environment[BrowserCookieAccessGate.allowTestCookieAccessEnvironmentKey] == "1",
+        "Default-home cookie access is explicitly enabled for this test run."))
+    func `default cookie candidates exclude safari during tests`() {
         let detection = BrowserDetection(cacheTTL: 0)
         let browsers: [Browser] = [.safari, .chrome, .firefox]
-        #expect(browsers.cookieImportCandidates(using: detection).contains(.safari))
+        #expect(browsers.cookieImportCandidates(using: detection).contains(.safari) == false)
+    }
+
+    @Test
+    func `explicit isolated home keeps safari cookie source available`() {
+        let detection = BrowserDetection(homeDirectory: "/tmp/codexbar-browser-detection", cacheTTL: 0)
+        #expect(detection.isCookieSourceAvailable(.safari))
+    }
+
+    @Test
+    func `cookie client permits isolated chromium stores during tests`() throws {
+        let temp = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        let profile = temp
+            .appendingPathComponent("Library/Application Support/Google/Chrome/Default/Network")
+        try FileManager.default.createDirectory(at: profile, withIntermediateDirectories: true)
+        FileManager.default.createFile(atPath: profile.appendingPathComponent("Cookies").path, contents: Data())
+        defer { try? FileManager.default.removeItem(at: temp) }
+
+        let client = BrowserCookieClient(configuration: .init(homeDirectories: [temp]))
+        let stores = try KeychainAccessGate.withTaskOverrideForTesting(false) {
+            try KeychainAccessPreflight.withCheckGenericPasswordOverrideForTesting { _, _ in .allowed } operation: {
+                try client.codexBarStores(for: .chrome)
+            }
+        }
+        #expect(stores.count == 1)
     }
 
     @Test
-    func filterPreservesOrder() {
+    func `filter preserves order`() {
         BrowserCookieAccessGate.resetForTesting()
 
         let temp = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
@@ -46,7 +132,7 @@ struct BrowserDetectionTests {
     }
 
     @Test
-    func chromeRequiresProfileData() throws {
+    func `chrome requires profile data`() throws {
         let temp = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
         try FileManager.default.createDirectory(at: temp, withIntermediateDirectories: true)
         defer { try? FileManager.default.removeItem(at: temp) }
@@ -69,7 +155,112 @@ struct BrowserDetectionTests {
     }
 
     @Test
-    func diaRequiresProfileData() throws {
+    func `process filters chromium candidates despite false global keychain override`() throws {
+        guard ProcessInfo.processInfo.environment["CODEXBAR_ALLOW_TEST_KEYCHAIN_ACCESS"] != "1" else { return }
+        KeychainAccessGate.resetOverrideForTesting()
+        defer { KeychainAccessGate.resetOverrideForTesting() }
+
+        KeychainAccessGate.isDisabled = false
+
+        let temp = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        try FileManager.default.createDirectory(at: temp, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: temp) }
+
+        let profile = temp
+            .appendingPathComponent("Library")
+            .appendingPathComponent("Application Support")
+            .appendingPathComponent("Google")
+            .appendingPathComponent("Chrome")
+            .appendingPathComponent("Default")
+        try FileManager.default.createDirectory(at: profile, withIntermediateDirectories: true)
+        let cookiesDir = profile.appendingPathComponent("Network")
+        try FileManager.default.createDirectory(at: cookiesDir, withIntermediateDirectories: true)
+        FileManager.default.createFile(atPath: cookiesDir.appendingPathComponent("Cookies").path, contents: Data())
+
+        let detection = BrowserDetection(homeDirectory: temp.path, cacheTTL: 0)
+        let browsers: [Browser] = [.chrome, .safari]
+        #expect(browsers.cookieImportCandidates(using: detection) == [.safari])
+    }
+
+    @Test
+    func `keychain interaction suppresses chromium cookie source during cooldown`() {
+        BrowserCookieAccessGate.resetForTesting()
+        defer { BrowserCookieAccessGate.resetForTesting() }
+
+        let start = Date(timeIntervalSince1970: 1000)
+        var preflightCount = 0
+
+        KeychainAccessGate.withTaskOverrideForTesting(false) {
+            ProviderInteractionContext.$current.withValue(.userInitiated) {
+                KeychainAccessPreflight.withCheckGenericPasswordOverrideForTesting { _, _ in
+                    preflightCount += 1
+                    return .interactionRequired
+                } operation: {
+                    #expect(BrowserCookieAccessGate.shouldAttempt(.chrome, now: start) == false)
+                }
+
+                KeychainAccessPreflight.withCheckGenericPasswordOverrideForTesting { _, _ in
+                    preflightCount += 1
+                    return .allowed
+                } operation: {
+                    #expect(BrowserCookieAccessGate.shouldAttempt(.chrome, now: start.addingTimeInterval(60)) == false)
+                    #expect(
+                        BrowserCookieAccessGate.shouldAttempt(
+                            .chrome,
+                            now: start.addingTimeInterval((60 * 60 * 6) + 1)) == true)
+                }
+            }
+        }
+
+        #expect(preflightCount == 2)
+    }
+
+    @Test
+    func `background cookie import allows authorized chromium keychain sources`() {
+        BrowserCookieAccessGate.resetForTesting()
+        defer { BrowserCookieAccessGate.resetForTesting() }
+
+        var preflightCount = 0
+
+        KeychainAccessGate.withTaskOverrideForTesting(false) {
+            KeychainAccessPreflight.withCheckGenericPasswordOverrideForTesting { _, _ in
+                preflightCount += 1
+                return .allowed
+            } operation: {
+                ProviderInteractionContext.$current.withValue(.background) {
+                    #expect(BrowserCookieAccessGate.shouldAttempt(.chrome) == true)
+                    #expect(BrowserCookieAccessGate.shouldAttempt(.safari) == true)
+                }
+            }
+        }
+
+        #expect(preflightCount == 1)
+    }
+
+    @Test
+    func `background cookie import suppresses chromium keychain sources requiring interaction`() {
+        BrowserCookieAccessGate.resetForTesting()
+        defer { BrowserCookieAccessGate.resetForTesting() }
+
+        var preflightCount = 0
+
+        KeychainAccessGate.withTaskOverrideForTesting(false) {
+            KeychainAccessPreflight.withCheckGenericPasswordOverrideForTesting { _, _ in
+                preflightCount += 1
+                return .interactionRequired
+            } operation: {
+                ProviderInteractionContext.$current.withValue(.background) {
+                    #expect(BrowserCookieAccessGate.shouldAttempt(.chrome) == false)
+                    #expect(BrowserCookieAccessGate.shouldAttempt(.safari) == true)
+                }
+            }
+        }
+
+        #expect(preflightCount == 1)
+    }
+
+    @Test
+    func `dia requires profile data`() throws {
         let temp = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
         try FileManager.default.createDirectory(at: temp, withIntermediateDirectories: true)
         defer { try? FileManager.default.removeItem(at: temp) }
@@ -92,7 +283,7 @@ struct BrowserDetectionTests {
     }
 
     @Test
-    func firefoxRequiresDefaultProfileDir() throws {
+    func `firefox requires default profile dir`() throws {
         let temp = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
         try FileManager.default.createDirectory(at: temp, withIntermediateDirectories: true)
         defer { try? FileManager.default.removeItem(at: temp) }
@@ -114,7 +305,7 @@ struct BrowserDetectionTests {
     }
 
     @Test
-    func zenAcceptsUppercaseDefaultProfileDir() throws {
+    func `zen accepts uppercase default profile dir`() throws {
         let temp = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
         try FileManager.default.createDirectory(at: temp, withIntermediateDirectories: true)
         defer { try? FileManager.default.removeItem(at: temp) }
@@ -138,15 +329,14 @@ struct BrowserDetectionTests {
 
 #else
 
-@Suite
 struct BrowserDetectionTests {
     @Test
-    func nonMacOSReturnsNoBrowsers() {
+    func `non mac OS returns no browsers`() {
         #expect(BrowserDetection(cacheTTL: 0).isCookieSourceAvailable(Browser()) == false)
     }
 
     @Test
-    func nonMacOSFilterReturnsEmpty() {
+    func `non mac OS filter returns empty`() {
         let detection = BrowserDetection(cacheTTL: 0)
         let browsers = [Browser(), Browser()]
         #expect(browsers.cookieImportCandidates(using: detection).isEmpty == true)
diff --git a/Tests/CodexBarTests/CLIArgumentParsingTests.swift b/Tests/CodexBarTests/CLIArgumentParsingTests.swift
index 969a2c01be..5c9d0c7331 100644
--- a/Tests/CodexBarTests/CLIArgumentParsingTests.swift
+++ b/Tests/CodexBarTests/CLIArgumentParsingTests.swift
@@ -3,10 +3,9 @@ import Commander
 import Testing
 @testable import CodexBarCLI
 
-@Suite
 struct CLIArgumentParsingTests {
     @Test
-    func jsonShortcutDoesNotEnableJsonLogs() throws {
+    func `json shortcut does not enable json logs`() throws {
         let signature = CodexBarCLI._usageSignatureForTesting()
         let parser = CommandParser(signature: signature)
         let parsed = try parser.parse(arguments: ["--json"])
@@ -17,7 +16,7 @@ struct CLIArgumentParsingTests {
     }
 
     @Test
-    func jsonOutputFlagEnablesJsonLogs() throws {
+    func `json output flag enables json logs`() throws {
         let signature = CodexBarCLI._usageSignatureForTesting()
         let parser = CommandParser(signature: signature)
         let parsed = try parser.parse(arguments: ["--json-output"])
@@ -28,7 +27,7 @@ struct CLIArgumentParsingTests {
     }
 
     @Test
-    func logLevelAndVerboseAreParsed() throws {
+    func `log level and verbose are parsed`() throws {
         let signature = CodexBarCLI._usageSignatureForTesting()
         let parser = CommandParser(signature: signature)
         let parsed = try parser.parse(arguments: ["--log-level", "info", "--verbose"])
@@ -38,14 +37,14 @@ struct CLIArgumentParsingTests {
     }
 
     @Test
-    func resolvedLogLevelDefaultsToError() {
+    func `resolved log level defaults to error`() {
         #expect(CodexBarCLI.resolvedLogLevel(verbose: false, rawLevel: nil) == .error)
         #expect(CodexBarCLI.resolvedLogLevel(verbose: true, rawLevel: nil) == .debug)
         #expect(CodexBarCLI.resolvedLogLevel(verbose: false, rawLevel: "info") == .info)
     }
 
     @Test
-    func formatOptionOverridesJsonShortcut() throws {
+    func `format option overrides json shortcut`() throws {
         let signature = CodexBarCLI._usageSignatureForTesting()
         let parser = CommandParser(signature: signature)
         let parsed = try parser.parse(arguments: ["--json", "--format", "text"])
@@ -56,7 +55,7 @@ struct CLIArgumentParsingTests {
     }
 
     @Test
-    func jsonOnlyEnablesJsonFormat() throws {
+    func `json only enables json format`() throws {
         let signature = CodexBarCLI._usageSignatureForTesting()
         let parser = CommandParser(signature: signature)
         let parsed = try parser.parse(arguments: ["--json-only"])
@@ -65,4 +64,39 @@ struct CLIArgumentParsingTests {
         #expect(!parsed.flags.contains("jsonOutput"))
         #expect(CodexBarCLI._decodeFormatForTesting(from: parsed) == .json)
     }
+
+    @Test
+    func `diagnose accepts json output flag but discards provider logs`() throws {
+        let signature = CodexBarCLI._diagnoseSignatureForTesting()
+        let parser = CommandParser(signature: signature)
+        let parsed = try parser.parse(arguments: [
+            "--provider", "minimax",
+            "--format", "json",
+            "--json-output",
+        ])
+
+        #expect(parsed.flags.contains("jsonOutput"))
+        let config = CodexBarCLI.loggingConfiguration(path: ["diagnose"], values: parsed)
+        switch config.destination {
+        case .discard:
+            break
+        case .stderr, .oslog:
+            Issue.record("diagnose should not emit provider logs beside the safe JSON export")
+        }
+    }
+
+    @Test
+    func `diagnose accepts explicit redact and output path`() throws {
+        let signature = CodexBarCLI._diagnoseSignatureForTesting()
+        let parser = CommandParser(signature: signature)
+        let parsed = try parser.parse(arguments: [
+            "--provider", "minimax",
+            "--format", "json",
+            "--redact",
+            "--output", "diagnostic.json",
+        ])
+
+        #expect(parsed.flags.contains("redact"))
+        #expect(parsed.options["output"] == ["diagnostic.json"])
+    }
 }
diff --git a/Tests/CodexBarTests/CLICacheTests.swift b/Tests/CodexBarTests/CLICacheTests.swift
new file mode 100644
index 0000000000..21ca7d869a
--- /dev/null
+++ b/Tests/CodexBarTests/CLICacheTests.swift
@@ -0,0 +1,32 @@
+import Commander
+import Testing
+@testable import CodexBarCLI
+
+struct CLICacheTests {
+    @Test
+    func `cache clear parses cookies provider flags`() throws {
+        let parser = CommandParser(signature: CodexBarCLI._cacheSignatureForTesting())
+        let parsed = try parser.parse(arguments: ["--cookies", "--provider", "claude", "--json"])
+
+        #expect(parsed.flags.contains("cookies"))
+        #expect(parsed.flags.contains("jsonShortcut"))
+        #expect(parsed.options["provider"] == ["claude"])
+        #expect(CodexBarCLI._decodeFormatForTesting(from: parsed) == .json)
+    }
+
+    @Test
+    func `provider scope is rejected for cost clearing`() {
+        #expect(CodexBarCLI.cacheClearProviderScopeError(rawProvider: nil, clearCost: true) == nil)
+        #expect(CodexBarCLI.cacheClearProviderScopeError(rawProvider: "claude", clearCost: false) == nil)
+        #expect(CodexBarCLI.cacheClearProviderScopeError(rawProvider: "claude", clearCost: true)?
+            .contains("--provider only scopes cookie caches") == true)
+    }
+
+    @Test
+    func `cache help documents provider as cookie scoped`() {
+        let help = CodexBarCLI.cacheHelp(version: "0.0.0")
+
+        #expect(help.contains("--provider with --cookies"))
+        #expect(help.contains("codexbar cache clear --cookies --provider claude"))
+    }
+}
diff --git a/Tests/CodexBarTests/CLIConfigCommandTests.swift b/Tests/CodexBarTests/CLIConfigCommandTests.swift
new file mode 100644
index 0000000000..e65fee2ca2
--- /dev/null
+++ b/Tests/CodexBarTests/CLIConfigCommandTests.swift
@@ -0,0 +1,123 @@
+import CodexBarCore
+import Commander
+import Testing
+@testable import CodexBarCLI
+
+struct CLIConfigCommandTests {
+    @Test
+    func `config set api key parses provider stdin and no enable flags`() throws {
+        let parser = CommandParser(signature: CodexBarCLI._configSetAPIKeySignatureForTesting())
+        let parsed = try parser.parse(arguments: [
+            "--provider", "elevenlabs",
+            "--stdin",
+            "--no-enable",
+            "--json",
+        ])
+
+        #expect(parsed.options["provider"] == ["elevenlabs"])
+        #expect(parsed.flags.contains("stdin"))
+        #expect(parsed.flags.contains("noEnable"))
+        #expect(CodexBarCLI._decodeFormatForTesting(from: parsed) == .json)
+    }
+
+    @Test
+    func `config set api key stores key and enables provider`() {
+        let config = CodexBarConfig.makeDefault()
+        let updated = CodexBarCLI.configSettingAPIKey(
+            config,
+            provider: .elevenlabs,
+            apiKey: "xi-test-token",
+            enableProvider: true)
+        let provider = updated.providerConfig(for: .elevenlabs)
+
+        #expect(provider?.sanitizedAPIKey == "xi-test-token")
+        #expect(provider?.enabled == true)
+    }
+
+    @Test
+    func `config provider toggle parses provider and json flags`() throws {
+        let parser = CommandParser(signature: CodexBarCLI._configProviderToggleSignatureForTesting())
+        let parsed = try parser.parse(arguments: [
+            "--provider", "grok",
+            "--json",
+            "--pretty",
+        ])
+
+        #expect(parsed.options["provider"] == ["grok"])
+        #expect(CodexBarCLI._decodeFormatForTesting(from: parsed) == .json)
+        #expect(parsed.flags.contains("pretty"))
+    }
+
+    @Test
+    func `config provider toggle enables and disables provider`() {
+        let config = CodexBarConfig.makeDefault()
+        let enabled = CodexBarCLI.configSettingProviderEnabled(config, provider: .grok, enabled: true)
+        let disabled = CodexBarCLI.configSettingProviderEnabled(enabled, provider: .grok, enabled: false)
+
+        #expect(enabled.providerConfig(for: .grok)?.enabled == true)
+        #expect(disabled.providerConfig(for: .grok)?.enabled == false)
+    }
+
+    @Test
+    func `config provider status includes effective default`() throws {
+        let config = CodexBarConfig(providers: [
+            ProviderConfig(id: .grok, enabled: true),
+            ProviderConfig(id: .cursor, enabled: false),
+        ])
+        let statuses = CodexBarCLI.configProviderStatuses(config)
+        let grok = try #require(statuses.first { $0.provider == "grok" })
+        let cursor = try #require(statuses.first { $0.provider == "cursor" })
+
+        #expect(grok.enabled)
+        #expect(!cursor.enabled)
+        #expect(statuses.count == UsageProvider.allCases.count)
+    }
+
+    @Test
+    func `config set api key only accepts consumed config keys`() {
+        #expect(ProviderConfigEnvironment.supportsAPIKeyOverride(for: .elevenlabs))
+        #expect(ProviderConfigEnvironment.supportsAPIKeyOverride(for: .groq))
+        #expect(ProviderConfigEnvironment.supportsAPIKeyOverride(for: .llmproxy))
+        #expect(ProviderConfigEnvironment.supportsAPIKeyOverride(for: .openai))
+        #expect(ProviderConfigEnvironment.supportsAPIKeyOverride(for: .amp))
+        #expect(ProviderConfigEnvironment.supportsAPIKeyOverride(for: .kimi))
+        #expect(!ProviderConfigEnvironment.supportsAPIKeyOverride(for: .bedrock))
+        #expect(!ProviderConfigEnvironment.supportsAPIKeyOverride(for: .deepseek))
+        #expect(!ProviderConfigEnvironment.supportsAPIKeyOverride(for: .cursor))
+    }
+
+    @Test
+    func `config set api key preserves disabled provider when requested`() {
+        var config = CodexBarConfig.makeDefault()
+        config.setProviderConfig(ProviderConfig(id: .elevenlabs, enabled: false))
+
+        let updated = CodexBarCLI.configSettingAPIKey(
+            config,
+            provider: .elevenlabs,
+            apiKey: "xi-test-token",
+            enableProvider: false)
+        let provider = updated.providerConfig(for: .elevenlabs)
+
+        #expect(provider?.sanitizedAPIKey == "xi-test-token")
+        #expect(provider?.enabled == false)
+    }
+
+    @Test
+    func `config set api key rejects ambiguous input`() {
+        #expect(throws: CLIArgumentError.self) {
+            try CodexBarCLI.resolveConfigAPIKeyInput(apiKey: "xi-test-token", readFromStdin: true)
+        }
+    }
+
+    @Test
+    func `config help documents set api key`() {
+        let help = CodexBarCLI.configHelp(version: "0.0.0")
+
+        #expect(help.contains("config set-api-key --provider <name>"))
+        #expect(help.contains("config providers"))
+        #expect(help.contains("config enable --provider <name>"))
+        #expect(help.contains("config disable --provider <name>"))
+        #expect(help.contains("--stdin"))
+        #expect(help.contains("enables that provider by default"))
+    }
+}
diff --git a/Tests/CodexBarTests/CLICostTests.swift b/Tests/CodexBarTests/CLICostTests.swift
index d376d383ea..1b223bce56 100644
--- a/Tests/CodexBarTests/CLICostTests.swift
+++ b/Tests/CodexBarTests/CLICostTests.swift
@@ -4,10 +4,9 @@ import Foundation
 import Testing
 @testable import CodexBarCLI
 
-@Suite
 struct CLICostTests {
     @Test
-    func costJsonShortcutDoesNotEnableJsonLogs() throws {
+    func `cost json shortcut does not enable json logs`() throws {
         let signature = CodexBarCLI._costSignatureForTesting()
         let parser = CommandParser(signature: signature)
         let parsed = try parser.parse(arguments: ["--json"])
@@ -18,12 +17,13 @@ struct CLICostTests {
     }
 
     @Test
-    func rendersCostTextSnapshot() {
+    func `renders cost text snapshot`() {
         let snap = CostUsageTokenSnapshot(
             sessionTokens: 1200,
             sessionCostUSD: 1.25,
             last30DaysTokens: 9000,
             last30DaysCostUSD: 9.99,
+            historyDays: 90,
             daily: [],
             updatedAt: Date(timeIntervalSince1970: 0))
 
@@ -31,19 +31,22 @@ struct CLICostTests {
             .replacingOccurrences(of: "\u{00A0}", with: " ")
             .replacingOccurrences(of: "$ ", with: "$")
 
-        #expect(output.contains("Claude Cost (local)"))
+        #expect(output.contains("Claude Cost (API-rate estimate)"))
         #expect(output.contains("Today: $1.25 · 1.2K tokens"))
-        #expect(output.contains("Last 30 days: $9.99 · 9K tokens"))
+        #expect(output.contains("Last 90 days: $9.99 · 9K tokens"))
+        #expect(output.contains("cache read/write tokens"))
+        #expect(output.contains("Claude Code /status"))
     }
 
     @Test
-    func encodesCostPayloadJSON() throws {
+    func `encodes cost payload JSON`() throws {
         let payload = CostPayload(
             provider: "claude",
             source: "local",
             updatedAt: Date(timeIntervalSince1970: 1_700_000_000),
             sessionTokens: 100,
             sessionCostUSD: 0.5,
+            historyDays: 90,
             last30DaysTokens: 200,
             last30DaysCostUSD: 1.5,
             daily: [
@@ -57,7 +60,10 @@ struct CLICostTests {
                     costUSD: 0.01,
                     modelsUsed: ["claude-sonnet-4-20250514"],
                     modelBreakdowns: [
-                        CostModelBreakdownPayload(modelName: "claude-sonnet-4-20250514", costUSD: 0.01),
+                        CostModelBreakdownPayload(
+                            modelName: "claude-sonnet-4-20250514",
+                            costUSD: 0.01,
+                            totalTokens: 15),
                     ]),
             ],
             totals: CostTotalsPayload(
@@ -79,11 +85,71 @@ struct CLICostTests {
 
         #expect(json.contains("\"provider\":\"claude\""))
         #expect(json.contains("\"source\":\"local\""))
+        #expect(json.contains("\"historyDays\":90"))
         #expect(json.contains("\"daily\""))
         #expect(json.contains("\"totals\""))
         #expect(json.contains("\"cacheReadTokens\":2"))
         #expect(json.contains("\"cacheCreationTokens\":3"))
         #expect(json.contains("\"totalCost\""))
+        #expect(json.contains("\"totalTokens\":15"))
         #expect(json.contains("1700000000"))
     }
+
+    @Test
+    func `encodes exact codex model I ds and zero cost breakdowns`() throws {
+        let payload = CostPayload(
+            provider: "codex",
+            source: "local",
+            updatedAt: Date(timeIntervalSince1970: 1_700_000_000),
+            sessionTokens: 155,
+            sessionCostUSD: 0,
+            historyDays: 30,
+            last30DaysTokens: 155,
+            last30DaysCostUSD: 0,
+            daily: [
+                CostDailyEntryPayload(
+                    date: "2025-12-21",
+                    inputTokens: 120,
+                    outputTokens: 15,
+                    cacheReadTokens: 20,
+                    cacheCreationTokens: nil,
+                    totalTokens: 155,
+                    costUSD: 0,
+                    modelsUsed: ["gpt-5.3-codex-spark", "gpt-5.2-codex"],
+                    modelBreakdowns: [
+                        CostModelBreakdownPayload(modelName: "gpt-5.3-codex-spark", costUSD: 0, totalTokens: 15),
+                        CostModelBreakdownPayload(modelName: "gpt-5.2-codex", costUSD: 1.23, totalTokens: 140),
+                    ]),
+            ],
+            totals: CostTotalsPayload(
+                totalInputTokens: 120,
+                totalOutputTokens: 15,
+                cacheReadTokens: 20,
+                cacheCreationTokens: nil,
+                totalTokens: 155,
+                totalCostUSD: 0),
+            error: nil)
+
+        let encoder = JSONEncoder()
+        encoder.dateEncodingStrategy = .secondsSince1970
+        let data = try encoder.encode(payload)
+        guard let json = String(data: data, encoding: .utf8) else {
+            Issue.record("Failed to decode cost payload JSON")
+            return
+        }
+
+        #expect(json.contains("\"gpt-5.3-codex-spark\""))
+        #expect(json.contains("\"gpt-5.2-codex\""))
+        #expect(!json.contains("\"gpt-5.2\""))
+        #expect(json.contains("\"cost\":0"))
+        #expect(json.contains("\"totalTokens\":140"))
+    }
+
+    @Test
+    func `cost estimate hint is stable string`() {
+        let hint = UsageFormatter.costEstimateHint
+        #expect(!hint.isEmpty)
+        #expect(hint.contains("Estimated"))
+        #expect(UsageFormatter.costEstimateHint(provider: .claude).contains("cache read/write tokens"))
+    }
 }
diff --git a/Tests/CodexBarTests/CLIDiagnoseCommandTests.swift b/Tests/CodexBarTests/CLIDiagnoseCommandTests.swift
new file mode 100644
index 0000000000..68175d630a
--- /dev/null
+++ b/Tests/CodexBarTests/CLIDiagnoseCommandTests.swift
@@ -0,0 +1,154 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBarCLI
+
+struct CLIDiagnoseCommandTests {
+    @Test
+    func `diagnose help describes generic JSON export`() {
+        let help = CodexBarCLI.diagnoseHelp(version: "0.0.0")
+
+        #expect(help.contains("codexbar diagnose --provider <name|all> --format json"))
+        #expect(help.contains("codexbar diagnose --provider all --format json"))
+        #expect(help.contains("--redact"))
+        #expect(help.contains("--output <path>"))
+        #expect(help.contains("safe JSON export"))
+        #expect(help.contains("raw API tokens"))
+    }
+
+    @Test
+    func `diagnose output writer creates parent directories`() throws {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent("CodexBarDiagnoseTests-\(UUID().uuidString)")
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let output = root.appendingPathComponent("nested/diagnostic.json")
+        try CodexBarCLI.writeDiagnosticExport(#"{"provider":"minimax"}"#, to: output.path)
+
+        let contents = try String(contentsOf: output, encoding: .utf8)
+        #expect(contents == #"{"provider":"minimax"}"#)
+    }
+
+    private func makeSettingsWithMiniMaxCookie(_ manualCookieHeader: String) -> ProviderSettingsSnapshot {
+        ProviderSettingsSnapshot(
+            debugMenuEnabled: false,
+            debugKeepCLISessionsAlive: false,
+            codex: nil,
+            claude: nil,
+            cursor: nil,
+            opencode: nil,
+            opencodego: nil,
+            alibaba: nil,
+            factory: nil,
+            minimax: ProviderSettingsSnapshot.MiniMaxProviderSettings(
+                cookieSource: .manual,
+                manualCookieHeader: manualCookieHeader,
+                apiRegion: .global),
+            manus: nil,
+            zai: nil,
+            copilot: nil,
+            kilo: nil,
+            kimi: nil,
+            augment: nil,
+            amp: nil,
+            ollama: nil)
+    }
+
+    @Test
+    func `diagnose auth mode uses settings-backed MiniMax manual cookie when env token is absent`() {
+        let settings = self.makeSettingsWithMiniMaxCookie("Cookie: session_id=demo-cookie")
+
+        let authMode = CodexBarCLI._resolveMiniMaxAuthModeForTesting(
+            environment: [:],
+            settings: settings)
+
+        #expect(authMode == .cookie)
+    }
+
+    @Test
+    func `diagnose auth mode keeps apiToken precedence over settings cookie`() {
+        let settings = self.makeSettingsWithMiniMaxCookie("Cookie: session_id=demo-cookie")
+
+        let authMode = CodexBarCLI._resolveMiniMaxAuthModeForTesting(
+            environment: [MiniMaxAPISettingsReader.apiTokenKey: "sk-api-demo-token"],
+            settings: settings)
+
+        #expect(authMode == .apiToken)
+    }
+
+    @Test
+    func `generic diagnose auth summary detects provider config`() {
+        let summary = CodexBarCLI._diagnosticAuthSummaryForTesting(
+            provider: .openai,
+            account: nil,
+            config: ProviderConfig(id: .openai, apiKey: "sk-test"),
+            environment: [:],
+            settings: nil)
+
+        #expect(summary.configured)
+        #expect(summary.modes == ["api"])
+    }
+
+    @Test
+    func `generic diagnose auth summary detects provider environment credentials`() {
+        let summary = CodexBarCLI._diagnosticAuthSummaryForTesting(
+            provider: .openai,
+            account: nil,
+            config: nil,
+            environment: [OpenAIAPISettingsReader.apiKeyEnvironmentKey: "sk-test"],
+            settings: nil)
+
+        #expect(summary.configured)
+        #expect(summary.modes == ["api"])
+    }
+
+    @Test
+    func `generic diagnose auth summary detects Chutes environment credentials`() {
+        let summary = CodexBarCLI._diagnosticAuthSummaryForTesting(
+            provider: .chutes,
+            account: nil,
+            config: nil,
+            environment: [ChutesSettingsReader.apiKeyEnvironmentKey: "chutes-test"],
+            settings: nil)
+
+        #expect(summary.configured)
+        #expect(summary.modes == ["api"])
+    }
+
+    @Test
+    func `generic diagnose auth summary requires complete Bedrock credentials`() {
+        let partial = CodexBarCLI._diagnosticAuthSummaryForTesting(
+            provider: .bedrock,
+            account: nil,
+            config: ProviderConfig(id: .bedrock, apiKey: "access-only"),
+            environment: [BedrockSettingsReader.accessKeyIDKey: "access-only"],
+            settings: nil)
+        #expect(!partial.configured)
+        #expect(partial.modes.isEmpty)
+
+        let complete = CodexBarCLI._diagnosticAuthSummaryForTesting(
+            provider: .bedrock,
+            account: nil,
+            config: nil,
+            environment: [
+                BedrockSettingsReader.accessKeyIDKey: "access",
+                BedrockSettingsReader.secretAccessKeyKey: "secret",
+            ],
+            settings: nil)
+        #expect(complete.configured)
+        #expect(complete.modes == ["api"])
+    }
+
+    @Test
+    func `generic diagnose auth summary does not assume ambient credentials`() {
+        let summary = CodexBarCLI._diagnosticAuthSummaryForTesting(
+            provider: .codex,
+            account: nil,
+            config: nil,
+            environment: [:],
+            settings: nil)
+
+        #expect(!summary.configured)
+        #expect(summary.modes.isEmpty)
+    }
+}
diff --git a/Tests/CodexBarTests/CLIEntryTests.swift b/Tests/CodexBarTests/CLIEntryTests.swift
index 22c78c1ce1..ce845423db 100644
--- a/Tests/CodexBarTests/CLIEntryTests.swift
+++ b/Tests/CodexBarTests/CLIEntryTests.swift
@@ -1,52 +1,136 @@
 import CodexBarCore
 import Commander
 import Foundation
-import Testing
+import XCTest
 @testable import CodexBarCLI
 
-@Suite
-struct CLIEntryTests {
-    @Test
-    func effectiveArgvDefaultsToUsage() {
-        #expect(CodexBarCLI.effectiveArgv([]) == ["usage"])
-        #expect(CodexBarCLI.effectiveArgv(["--json"]) == ["usage", "--json"])
-        #expect(CodexBarCLI.effectiveArgv(["usage", "--json"]) == ["usage", "--json"])
+final class CLIEntryTests: XCTestCase {
+    func test_effectiveArgvDefaultsToUsage() {
+        XCTAssertEqual(CodexBarCLI.effectiveArgv([]), ["usage"])
+        XCTAssertEqual(CodexBarCLI.effectiveArgv(["--json"]), ["usage", "--json"])
+        XCTAssertEqual(CodexBarCLI.effectiveArgv(["usage", "--json"]), ["usage", "--json"])
     }
 
-    @Test
-    func decodesFormatFromOptionsAndFlags() {
+    func test_decodesFormatFromOptionsAndFlags() {
         let jsonOption = ParsedValues(positional: [], options: ["format": ["json"]], flags: [])
-        #expect(CodexBarCLI._decodeFormatForTesting(from: jsonOption) == .json)
+        XCTAssertEqual(CodexBarCLI._decodeFormatForTesting(from: jsonOption), .json)
 
         let jsonFlag = ParsedValues(positional: [], options: [:], flags: ["json"])
-        #expect(CodexBarCLI._decodeFormatForTesting(from: jsonFlag) == .json)
+        XCTAssertEqual(CodexBarCLI._decodeFormatForTesting(from: jsonFlag), .json)
 
         let textDefault = ParsedValues(positional: [], options: [:], flags: [])
-        #expect(CodexBarCLI._decodeFormatForTesting(from: textDefault) == .text)
+        XCTAssertEqual(CodexBarCLI._decodeFormatForTesting(from: textDefault), .text)
     }
 
-    @Test
-    func providerSelectionPrefersOverride() {
+    func test_providerSelectionPrefersOverride() {
         let selection = CodexBarCLI.providerSelection(rawOverride: "codex", enabled: [.claude, .gemini])
-        #expect(selection.asList == [.codex])
+        XCTAssertEqual(selection.asList, [.codex])
     }
 
-    @Test
-    func normalizeVersionExtractsNumeric() {
-        #expect(CodexBarCLI.normalizeVersion(raw: "codex 1.2.3 (build 4)") == "1.2.3")
-        #expect(CodexBarCLI.normalizeVersion(raw: "  v2.0  ") == "2.0")
+    func test_normalizeVersionExtractsNumeric() {
+        XCTAssertEqual(CodexBarCLI.normalizeVersion(raw: "codex 1.2.3 (build 4)"), "1.2.3")
+        XCTAssertEqual(CodexBarCLI.normalizeVersion(raw: "  v2.0  "), "2.0")
     }
 
-    @Test
-    func makeHeaderIncludesVersionWhenAvailable() {
+    func test_makeHeaderIncludesVersionWhenAvailable() {
         let header = CodexBarCLI.makeHeader(provider: .codex, version: "1.2.3", source: "cli")
-        #expect(header.contains("Codex"))
-        #expect(header.contains("1.2.3"))
-        #expect(header.contains("cli"))
+        XCTAssertTrue(header.contains("Codex"))
+        XCTAssertTrue(header.contains("1.2.3"))
+        XCTAssertTrue(header.contains("cli"))
     }
 
-    @Test
-    func renderOpenAIWebDashboardTextIncludesSummary() {
+    func test_cliVersionFallsBackToContainingAppBundle() throws {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-cli-version-\(UUID().uuidString)", isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let appURL = root.appendingPathComponent("CodexBar.app", isDirectory: true)
+        let contentsURL = appURL.appendingPathComponent("Contents", isDirectory: true)
+        let helpersURL = contentsURL.appendingPathComponent("Helpers", isDirectory: true)
+        try FileManager.default.createDirectory(at: helpersURL, withIntermediateDirectories: true)
+
+        let infoURL = contentsURL.appendingPathComponent("Info.plist")
+        let plist: [String: Any] = ["CFBundleShortVersionString": "9.8.7"]
+        let data = try PropertyListSerialization.data(fromPropertyList: plist, format: .xml, options: 0)
+        try data.write(to: infoURL)
+
+        let helperURL = helpersURL.appendingPathComponent("CodexBarCLI")
+        try Data().write(to: helperURL)
+
+        XCTAssertEqual(CodexBarCLI.containingAppVersion(for: helperURL), "9.8.7")
+    }
+
+    func test_cliVersionFollowsSymlinkedHelper() throws {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-cli-version-symlink-\(UUID().uuidString)", isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let appURL = root.appendingPathComponent("CodexBar.app", isDirectory: true)
+        let contentsURL = appURL.appendingPathComponent("Contents", isDirectory: true)
+        let helpersURL = contentsURL.appendingPathComponent("Helpers", isDirectory: true)
+        let binURL = root.appendingPathComponent("bin", isDirectory: true)
+        try FileManager.default.createDirectory(at: helpersURL, withIntermediateDirectories: true)
+        try FileManager.default.createDirectory(at: binURL, withIntermediateDirectories: true)
+
+        let infoURL = contentsURL.appendingPathComponent("Info.plist")
+        let plist: [String: Any] = ["CFBundleShortVersionString": "2.4.6"]
+        let data = try PropertyListSerialization.data(fromPropertyList: plist, format: .xml, options: 0)
+        try data.write(to: infoURL)
+
+        let helperURL = helpersURL.appendingPathComponent("CodexBarCLI")
+        try Data().write(to: helperURL)
+
+        let symlinkURL = binURL.appendingPathComponent("codexbar")
+        try FileManager.default.createSymbolicLink(at: symlinkURL, withDestinationURL: helperURL)
+
+        XCTAssertEqual(CodexBarCLI.currentVersion(bundleVersion: nil, executablePath: symlinkURL.path), "2.4.6")
+    }
+
+    func test_cliVersionFallsBackToAdjacentVersionFile() throws {
+        try self.expectAdjacentVersionFile(raw: "v3.2.1\n", expected: "3.2.1")
+        try self.expectAdjacentVersionFile(raw: "3.2.2\n", expected: "3.2.2")
+        try self.expectAdjacentVersionFile(raw: "version-3.2.3\n", expected: "version-3.2.3")
+    }
+
+    func test_cliVersionPrefersAdjacentVersionOverStandaloneBundleName() throws {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-cli-version-bundle-\(UUID().uuidString)", isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let binURL = root.appendingPathComponent("bin", isDirectory: true)
+        try FileManager.default.createDirectory(at: binURL, withIntermediateDirectories: true)
+
+        let helperURL = binURL.appendingPathComponent("CodexBarCLI")
+        try Data().write(to: helperURL)
+        try "4.5.6\n".write(
+            to: binURL.appendingPathComponent("VERSION"),
+            atomically: false,
+            encoding: .utf8)
+
+        XCTAssertEqual(
+            CodexBarCLI.currentVersion(bundleVersion: "CodexBar", executablePath: helperURL.path),
+            "4.5.6")
+    }
+
+    private func expectAdjacentVersionFile(raw: String, expected: String) throws {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-cli-version-file-\(UUID().uuidString)", isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let binURL = root.appendingPathComponent("bin", isDirectory: true)
+        try FileManager.default.createDirectory(at: binURL, withIntermediateDirectories: true)
+
+        let helperURL = binURL.appendingPathComponent("CodexBarCLI")
+        try Data().write(to: helperURL)
+        try raw.write(
+            to: binURL.appendingPathComponent("VERSION"),
+            atomically: false,
+            encoding: .utf8)
+
+        XCTAssertEqual(CodexBarCLI.currentVersion(bundleVersion: nil, executablePath: helperURL.path), expected)
+    }
+
+    func test_renderOpenAIWebDashboardTextIncludesSummary() {
         let event = CreditEvent(
             date: Date(timeIntervalSince1970: 1_700_000_000),
             service: "codex",
@@ -54,6 +138,11 @@ struct CLIEntryTests {
         let snapshot = OpenAIDashboardSnapshot(
             signedInEmail: "user@example.com",
             codeReviewRemainingPercent: 45,
+            codeReviewLimit: RateWindow(
+                usedPercent: 55,
+                windowMinutes: nil,
+                resetsAt: Date().addingTimeInterval(3600),
+                resetDescription: nil),
             creditEvents: [event],
             dailyBreakdown: [],
             usageBreakdown: [],
@@ -62,87 +151,110 @@ struct CLIEntryTests {
 
         let text = CodexBarCLI.renderOpenAIWebDashboardText(snapshot)
 
-        #expect(text.contains("Web session: user@example.com"))
-        #expect(text.contains("Code review: 45% remaining"))
-        #expect(text.contains("Web history: 1 events"))
+        XCTAssertTrue(text.contains("Web session: user@example.com"))
+        XCTAssertTrue(text.contains("Code review: 45% remaining (Resets in "))
+        XCTAssertTrue(text.contains("Web history: 1 events"))
     }
 
-    @Test
-    func mapsErrorsToExitCodes() {
-        #expect(CodexBarCLI.mapError(CodexStatusProbeError.codexNotInstalled) == ExitCode(2))
-        #expect(CodexBarCLI.mapError(CodexStatusProbeError.timedOut) == ExitCode(4))
-        #expect(CodexBarCLI.mapError(UsageError.noRateLimitsFound) == ExitCode(3))
+    func test_mapsErrorsToExitCodes() {
+        XCTAssertEqual(CodexBarCLI.mapError(CodexStatusProbeError.codexNotInstalled), ExitCode(2))
+        XCTAssertEqual(CodexBarCLI.mapError(CodexStatusProbeError.timedOut), ExitCode(4))
+        XCTAssertEqual(CodexBarCLI.mapError(UsageError.noRateLimitsFound), ExitCode(3))
     }
 
-    @Test
-    func providerSelectionFallsBackToBothForPrimaryPair() {
+    func test_antigravityPlanDebugKeepsOneShotHelperAliveUntilDebugFetch() {
+        XCTAssertTrue(CodexBarCLI.holdsAntigravityCLISessionForPlanDebug(
+            provider: .antigravity,
+            planDebugEnabled: true,
+            jsonOnly: false,
+            persistsCLISessions: false))
+        XCTAssertFalse(CodexBarCLI.holdsAntigravityCLISessionForPlanDebug(
+            provider: .codex,
+            planDebugEnabled: true,
+            jsonOnly: false,
+            persistsCLISessions: false))
+        XCTAssertFalse(CodexBarCLI.holdsAntigravityCLISessionForPlanDebug(
+            provider: .antigravity,
+            planDebugEnabled: true,
+            jsonOnly: true,
+            persistsCLISessions: false))
+        XCTAssertFalse(CodexBarCLI.holdsAntigravityCLISessionForPlanDebug(
+            provider: .antigravity,
+            planDebugEnabled: true,
+            jsonOnly: false,
+            persistsCLISessions: true))
+    }
+
+    func test_missingCodexBinaryErrorPayloadUsesInstallGuidance() {
+        let payload = CodexBarCLI.makeErrorPayload(CodexStatusProbeError.codexNotInstalled, kind: .provider)
+
+        XCTAssertEqual(payload.code, ExitCode.binaryNotFound.rawValue)
+        XCTAssertTrue(payload.message.contains("Codex CLI missing"))
+        XCTAssertFalse(payload.message.contains("Codex not running"))
+    }
+
+    func test_providerSelectionFallsBackToBothForPrimaryPair() {
         let selection = CodexBarCLI.providerSelection(rawOverride: nil, enabled: [.codex, .claude])
         switch selection {
         case .both:
             break
         default:
-            #expect(Bool(false))
+            XCTFail("Expected both selection")
         }
     }
 
-    @Test
-    func providerSelectionFallsBackToCustomWhenNonPrimary() {
+    func test_providerSelectionFallsBackToCustomWhenNonPrimary() {
         let selection = CodexBarCLI.providerSelection(rawOverride: nil, enabled: [.codex, .gemini])
         switch selection {
         case let .custom(providers):
-            #expect(providers == [.codex, .gemini])
+            XCTAssertEqual(providers, [.codex, .gemini])
         default:
-            #expect(Bool(false))
+            XCTFail("Expected custom selection")
         }
     }
 
-    @Test
-    func providerSelectionDefaultsToCodexWhenEmpty() {
+    func test_providerSelectionHonorsEmptyEnabledSet() {
         let selection = CodexBarCLI.providerSelection(rawOverride: nil, enabled: [])
         switch selection {
-        case let .single(provider):
-            #expect(provider == .codex)
+        case let .custom(providers):
+            XCTAssertEqual(providers, [])
         default:
-            #expect(Bool(false))
+            XCTFail("Expected empty custom selection")
         }
     }
 
-    @Test
-    func decodesSourceAndTimeoutOptions() throws {
+    func test_decodesSourceAndTimeoutOptions() throws {
         let signature = CodexBarCLI._usageSignatureForTesting()
         let parser = CommandParser(signature: signature)
         let parsed = try parser.parse(arguments: ["--web-timeout", "45", "--source", "oauth"])
-        #expect(CodexBarCLI._decodeWebTimeoutForTesting(from: parsed) == 45)
-        #expect(CodexBarCLI._decodeSourceModeForTesting(from: parsed) == .oauth)
+        XCTAssertEqual(CodexBarCLI._decodeWebTimeoutForTesting(from: parsed), 45)
+        XCTAssertEqual(CodexBarCLI._decodeSourceModeForTesting(from: parsed), .oauth)
 
         let parsedWeb = try parser.parse(arguments: ["--web"])
-        #expect(CodexBarCLI._decodeSourceModeForTesting(from: parsedWeb) == .web)
+        XCTAssertEqual(CodexBarCLI._decodeSourceModeForTesting(from: parsedWeb), .web)
     }
 
-    @Test
-    func shouldUseColorRespectsFormatAndFlags() {
-        #expect(!CodexBarCLI.shouldUseColor(noColor: true, format: .text))
-        #expect(!CodexBarCLI.shouldUseColor(noColor: false, format: .json))
+    func test_shouldUseColorRespectsFormatAndFlags() {
+        XCTAssertFalse(CodexBarCLI.shouldUseColor(noColor: true, format: .text))
+        XCTAssertFalse(CodexBarCLI.shouldUseColor(noColor: false, format: .json))
     }
 
-    @Test
-    func kiloUsageTextNotesShowFallbackOnlyForAutoResolvedToCLI() {
-        #expect(CodexBarCLI.usageTextNotes(
+    func test_kiloUsageTextNotesShowFallbackOnlyForAutoResolvedToCLI() {
+        XCTAssertEqual(CodexBarCLI.usageTextNotes(
             provider: .kilo,
             sourceMode: .auto,
-            resolvedSourceLabel: "cli") == ["Using CLI fallback"])
-        #expect(CodexBarCLI.usageTextNotes(
+            resolvedSourceLabel: "cli"), ["Using CLI fallback"])
+        XCTAssertTrue(CodexBarCLI.usageTextNotes(
             provider: .kilo,
             sourceMode: .api,
             resolvedSourceLabel: "cli").isEmpty)
-        #expect(CodexBarCLI.usageTextNotes(
+        XCTAssertTrue(CodexBarCLI.usageTextNotes(
             provider: .codex,
             sourceMode: .auto,
             resolvedSourceLabel: "cli").isEmpty)
     }
 
-    @Test
-    func kiloAutoFallbackSummaryIncludesOrderedAttemptDetails() {
+    func test_kiloAutoFallbackSummaryIncludesOrderedAttemptDetails() {
         let attempts = [
             ProviderFetchAttempt(
                 strategyID: "kilo.api",
@@ -165,13 +277,10 @@ struct CLIEntryTests {
             " -> cli: Kilo CLI session not found.",
         ].joined()
 
-        #expect(
-            summary ==
-                expected)
+        XCTAssertEqual(summary, expected)
     }
 
-    @Test
-    func kiloAutoFallbackSummaryIsNilOutsideKiloAutoFailures() {
+    func test_kiloAutoFallbackSummaryIsNilOutsideKiloAutoFailures() {
         let attempts = [
             ProviderFetchAttempt(
                 strategyID: "kilo.api",
@@ -180,21 +289,134 @@ struct CLIEntryTests {
                 errorDescription: "example"),
         ]
 
-        #expect(CodexBarCLI.kiloAutoFallbackSummary(
+        XCTAssertNil(CodexBarCLI.kiloAutoFallbackSummary(
             provider: .kilo,
             sourceMode: .api,
-            attempts: attempts) == nil)
-        #expect(CodexBarCLI.kiloAutoFallbackSummary(
+            attempts: attempts))
+        XCTAssertNil(CodexBarCLI.kiloAutoFallbackSummary(
             provider: .codex,
             sourceMode: .auto,
-            attempts: attempts) == nil)
+            attempts: attempts))
     }
 
-    @Test
-    func sourceModeRequiresWebSupportIsProviderAware() {
-        #expect(CodexBarCLI.sourceModeRequiresWebSupport(.web, provider: .kilo))
-        #expect(CodexBarCLI.sourceModeRequiresWebSupport(.auto, provider: .codex))
-        #expect(!CodexBarCLI.sourceModeRequiresWebSupport(.auto, provider: .kilo))
-        #expect(!CodexBarCLI.sourceModeRequiresWebSupport(.api, provider: .kilo))
+    func test_sourceModeRequiresWebSupportIsProviderAware() throws {
+        let directory = FileManager.default.temporaryDirectory
+            .appendingPathComponent("mimo-cli-source-mode-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: directory) }
+        let validMiMoCache = directory.appendingPathComponent("valid.json")
+        let invalidMiMoCache = directory.appendingPathComponent("invalid.json")
+        let payload: [String: Any] = [
+            "sessions_scanned": 1,
+            "windows": [
+                "today": [:],
+                "week": [:],
+                "all_time": [:],
+            ],
+        ]
+        try JSONSerialization.data(withJSONObject: payload).write(to: validMiMoCache)
+        try Data("{}".utf8).write(to: invalidMiMoCache)
+
+        XCTAssertTrue(CodexBarCLI.sourceModeRequiresWebSupport(.web, provider: .kilo))
+        XCTAssertFalse(CodexBarCLI.sourceModeRequiresWebSupport(.auto, provider: .codex))
+        XCTAssertFalse(CodexBarCLI.sourceModeRequiresWebSupport(.auto, provider: .kilo))
+        XCTAssertFalse(CodexBarCLI.sourceModeRequiresWebSupport(.auto, provider: .grok))
+        XCTAssertFalse(CodexBarCLI.sourceModeRequiresWebSupport(.web, provider: .grok))
+        XCTAssertFalse(CodexBarCLI.sourceModeRequiresWebSupport(.auto, provider: .amp))
+        XCTAssertFalse(CodexBarCLI.sourceModeRequiresWebSupport(.api, provider: .kilo))
+        XCTAssertFalse(CodexBarCLI.sourceModeRequiresWebSupport(
+            .auto,
+            provider: .opencodego,
+            settings: ProviderSettingsSnapshot.make(
+                opencodego: .init(
+                    cookieSource: .manual,
+                    manualCookieHeader: "auth=manual",
+                    workspaceID: nil))))
+        XCTAssertFalse(CodexBarCLI.sourceModeRequiresWebSupport(
+            .web,
+            provider: .opencodego,
+            settings: ProviderSettingsSnapshot.make(
+                opencodego: .init(
+                    cookieSource: .manual,
+                    manualCookieHeader: "auth=manual",
+                    workspaceID: nil))))
+        XCTAssertFalse(CodexBarCLI.sourceModeRequiresWebSupport(
+            .auto,
+            provider: .opencodego,
+            settings: ProviderSettingsSnapshot.make(
+                opencodego: .init(
+                    cookieSource: .auto,
+                    manualCookieHeader: nil,
+                    workspaceID: nil))))
+        XCTAssertTrue(CodexBarCLI.sourceModeRequiresWebSupport(
+            .web,
+            provider: .opencodego,
+            settings: ProviderSettingsSnapshot.make(
+                opencodego: .init(
+                    cookieSource: .auto,
+                    manualCookieHeader: nil,
+                    workspaceID: nil))))
+        XCTAssertFalse(CodexBarCLI.sourceModeRequiresWebSupport(
+            .auto,
+            provider: .commandcode,
+            settings: ProviderSettingsSnapshot.make(
+                commandcode: .init(
+                    cookieSource: .manual,
+                    manualCookieHeader: "session=manual"))))
+        XCTAssertFalse(CodexBarCLI.sourceModeRequiresWebSupport(
+            .web,
+            provider: .commandcode,
+            settings: ProviderSettingsSnapshot.make(
+                commandcode: .init(
+                    cookieSource: .manual,
+                    manualCookieHeader: "session=manual"))))
+        XCTAssertTrue(CodexBarCLI.sourceModeRequiresWebSupport(
+            .auto,
+            provider: .commandcode,
+            settings: ProviderSettingsSnapshot.make(
+                commandcode: .init(
+                    cookieSource: .auto,
+                    manualCookieHeader: nil))))
+        XCTAssertTrue(CodexBarCLI.sourceModeRequiresWebSupport(
+            .auto,
+            provider: .opencode,
+            settings: ProviderSettingsSnapshot.make(
+                opencode: .init(
+                    cookieSource: .manual,
+                    manualCookieHeader: "auth=manual",
+                    workspaceID: nil))))
+        XCTAssertFalse(CodexBarCLI.sourceModeRequiresWebSupport(
+            .auto,
+            provider: .ollama,
+            environment: ["OLLAMA_API_KEY": "ollama-test"]))
+        XCTAssertFalse(CodexBarCLI.sourceModeRequiresWebSupport(
+            .auto,
+            provider: .codex,
+            environment: ["OLLAMA_API_KEY": "ollama-test"]))
+        XCTAssertFalse(CodexBarCLI.sourceModeRequiresWebSupport(
+            .auto,
+            provider: .ollama,
+            settings: ProviderSettingsSnapshot.make(
+                ollama: .init(cookieSource: .off, manualCookieHeader: nil))))
+        XCTAssertFalse(CodexBarCLI.sourceModeRequiresWebSupport(
+            .auto,
+            provider: .kimi,
+            environment: ["KIMI_CODE_API_KEY": "kimi-test"]))
+        XCTAssertFalse(CodexBarCLI.sourceModeRequiresWebSupport(
+            .auto,
+            provider: .mimo,
+            environment: ["MIMO_LOCAL_USAGE_PATH": validMiMoCache.path]))
+        XCTAssertTrue(CodexBarCLI.sourceModeRequiresWebSupport(
+            .web,
+            provider: .mimo,
+            environment: ["MIMO_LOCAL_USAGE_PATH": validMiMoCache.path]))
+        XCTAssertFalse(CodexBarCLI.sourceModeRequiresWebSupport(
+            .auto,
+            provider: .mimo,
+            environment: ["MIMO_LOCAL_USAGE_PATH": invalidMiMoCache.path]))
+        XCTAssertTrue(CodexBarCLI.sourceModeRequiresWebSupport(
+            .auto,
+            provider: .mimo,
+            environment: ["MIMO_LOCAL_USAGE_PATH": directory.appendingPathComponent("missing.json").path]))
     }
 }
diff --git a/Tests/CodexBarTests/CLIOpenAIDashboardCacheTests.swift b/Tests/CodexBarTests/CLIOpenAIDashboardCacheTests.swift
new file mode 100644
index 0000000000..96e84f52d3
--- /dev/null
+++ b/Tests/CodexBarTests/CLIOpenAIDashboardCacheTests.swift
@@ -0,0 +1,433 @@
+import Foundation
+import Testing
+@testable import CodexBarCLI
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct CLIOpenAIDashboardCacheTests {
+    @Test
+    func `cached dashboard restores when authority allows cached reuse`() throws {
+        OpenAIDashboardCacheStore.clear()
+        defer { OpenAIDashboardCacheStore.clear() }
+
+        let authHome = try self.makeAuthHome(
+            email: "owner@example.com",
+            accountId: "acct-owner")
+        defer { try? FileManager.default.removeItem(at: authHome) }
+
+        let context = self.makeContext(
+            authHome: authHome,
+            knownOwners: [
+                CodexDashboardKnownOwnerCandidate(
+                    identity: .providerAccount(id: "acct-owner"),
+                    normalizedEmail: "owner@example.com"),
+            ])
+        let dashboard = self.makeDashboard(email: "owner@example.com")
+        OpenAIDashboardCacheStore.save(OpenAIDashboardCache(
+            accountEmail: "stale-route@example.com",
+            snapshot: dashboard))
+
+        let restored = CodexBarCLI.loadOpenAIDashboardIfAvailable(
+            usage: self.makeUsage(email: nil),
+            sourceLabel: "openai-web",
+            context: context)
+
+        #expect(restored == dashboard)
+    }
+
+    @Test
+    func `cached dashboard returns nil on display only and clears cache`() throws {
+        OpenAIDashboardCacheStore.clear()
+        defer { OpenAIDashboardCacheStore.clear() }
+
+        let authHome = try self.makeAuthHome(email: "shared@example.com")
+        defer { try? FileManager.default.removeItem(at: authHome) }
+
+        let context = self.makeContext(
+            authHome: authHome,
+            knownOwners: [
+                CodexDashboardKnownOwnerCandidate(
+                    identity: .providerAccount(id: "acct-alpha"),
+                    normalizedEmail: "shared@example.com"),
+                CodexDashboardKnownOwnerCandidate(
+                    identity: .providerAccount(id: "acct-beta"),
+                    normalizedEmail: "shared@example.com"),
+            ])
+        OpenAIDashboardCacheStore.save(OpenAIDashboardCache(
+            accountEmail: "shared@example.com",
+            snapshot: self.makeDashboard(email: "shared@example.com")))
+
+        let restored = CodexBarCLI.loadOpenAIDashboardIfAvailable(
+            usage: self.makeUsage(email: "shared@example.com"),
+            sourceLabel: "codex-cli",
+            context: context)
+
+        #expect(restored == nil)
+        #expect(OpenAIDashboardCacheStore.load() == nil)
+    }
+
+    @Test
+    func `cached dashboard returns nil on fail closed and clears cache`() throws {
+        OpenAIDashboardCacheStore.clear()
+        defer { OpenAIDashboardCacheStore.clear() }
+
+        let authHome = try self.makeAuthHome(
+            email: "owner@example.com",
+            accountId: "acct-owner")
+        defer { try? FileManager.default.removeItem(at: authHome) }
+
+        let context = self.makeContext(
+            authHome: authHome,
+            knownOwners: [
+                CodexDashboardKnownOwnerCandidate(
+                    identity: .providerAccount(id: "acct-other"),
+                    normalizedEmail: "owner@example.com"),
+            ])
+        OpenAIDashboardCacheStore.save(OpenAIDashboardCache(
+            accountEmail: "owner@example.com",
+            snapshot: self.makeDashboard(email: "owner@example.com")))
+
+        let restored = CodexBarCLI.loadOpenAIDashboardIfAvailable(
+            usage: self.makeUsage(email: "owner@example.com"),
+            sourceLabel: "codex-cli",
+            context: context)
+
+        #expect(restored == nil)
+        #expect(OpenAIDashboardCacheStore.load() == nil)
+    }
+
+    @Test
+    func `cached dashboard wrong email returns nil and clears cache`() throws {
+        OpenAIDashboardCacheStore.clear()
+        defer { OpenAIDashboardCacheStore.clear() }
+
+        let authHome = try self.makeAuthHome(
+            email: "owner@example.com",
+            accountId: "acct-owner")
+        defer { try? FileManager.default.removeItem(at: authHome) }
+
+        let context = self.makeContext(
+            authHome: authHome,
+            knownOwners: [
+                CodexDashboardKnownOwnerCandidate(
+                    identity: .providerAccount(id: "acct-owner"),
+                    normalizedEmail: "owner@example.com"),
+            ])
+        OpenAIDashboardCacheStore.save(OpenAIDashboardCache(
+            accountEmail: "other@example.com",
+            snapshot: self.makeDashboard(email: "other@example.com")))
+
+        let restored = CodexBarCLI.loadOpenAIDashboardIfAvailable(
+            usage: self.makeUsage(email: "owner@example.com"),
+            sourceLabel: "codex-cli",
+            context: context)
+
+        #expect(restored == nil)
+        #expect(OpenAIDashboardCacheStore.load() == nil)
+    }
+
+    @Test
+    func `cached dashboard provider account without scoped auth email fails closed`() throws {
+        OpenAIDashboardCacheStore.clear()
+        defer { OpenAIDashboardCacheStore.clear() }
+
+        let authHome = try self.makeAuthHome(email: nil, accountId: "acct-owner")
+        defer { try? FileManager.default.removeItem(at: authHome) }
+
+        let context = self.makeContext(
+            authHome: authHome,
+            knownOwners: [
+                CodexDashboardKnownOwnerCandidate(
+                    identity: .providerAccount(id: "acct-alpha"),
+                    normalizedEmail: "shared@example.com"),
+                CodexDashboardKnownOwnerCandidate(
+                    identity: .providerAccount(id: "acct-beta"),
+                    normalizedEmail: "shared@example.com"),
+            ])
+        OpenAIDashboardCacheStore.save(OpenAIDashboardCache(
+            accountEmail: "shared@example.com",
+            snapshot: self.makeDashboard(email: "shared@example.com")))
+
+        let restored = CodexBarCLI.loadOpenAIDashboardIfAvailable(
+            usage: self.makeUsage(email: "shared@example.com"),
+            sourceLabel: "codex-cli",
+            context: context)
+
+        #expect(restored == nil)
+        #expect(OpenAIDashboardCacheStore.load() == nil)
+    }
+
+    @Test
+    func `cached dashboard unresolved trusted continuity with competing owner returns nil`() {
+        OpenAIDashboardCacheStore.clear()
+        defer { OpenAIDashboardCacheStore.clear() }
+
+        let emptyHome = self.makeEmptyHome()
+        defer { try? FileManager.default.removeItem(at: emptyHome) }
+        let context = self.makeContext(
+            authHome: emptyHome,
+            knownOwners: [
+                CodexDashboardKnownOwnerCandidate(
+                    identity: .providerAccount(id: "acct-alpha"),
+                    normalizedEmail: "shared@example.com"),
+                CodexDashboardKnownOwnerCandidate(
+                    identity: .providerAccount(id: "acct-beta"),
+                    normalizedEmail: "shared@example.com"),
+            ])
+        OpenAIDashboardCacheStore.save(OpenAIDashboardCache(
+            accountEmail: "shared@example.com",
+            snapshot: self.makeDashboard(email: "shared@example.com")))
+
+        let restored = CodexBarCLI.loadOpenAIDashboardIfAvailable(
+            usage: self.makeUsage(email: "shared@example.com"),
+            sourceLabel: "codex-cli",
+            context: context)
+
+        #expect(restored == nil)
+        #expect(OpenAIDashboardCacheStore.load() == nil)
+    }
+
+    @Test
+    func `cached dashboard trusts codex cli usage continuity`() {
+        OpenAIDashboardCacheStore.clear()
+        defer { OpenAIDashboardCacheStore.clear() }
+
+        let emptyHome = self.makeEmptyHome()
+        defer { try? FileManager.default.removeItem(at: emptyHome) }
+        let context = self.makeContext(
+            authHome: emptyHome,
+            knownOwners: [
+                CodexDashboardKnownOwnerCandidate(
+                    identity: .providerAccount(id: "acct-owner"),
+                    normalizedEmail: "owner@example.com"),
+            ])
+        let dashboard = self.makeDashboard(email: "owner@example.com")
+        OpenAIDashboardCacheStore.save(OpenAIDashboardCache(
+            accountEmail: "stale-route@example.com",
+            snapshot: dashboard))
+
+        let restored = CodexBarCLI.loadOpenAIDashboardIfAvailable(
+            usage: self.makeUsage(email: "owner@example.com"),
+            sourceLabel: "codex-cli",
+            context: context)
+
+        #expect(restored == dashboard)
+    }
+
+    @Test
+    func `cached dashboard trusts oauth usage continuity`() {
+        OpenAIDashboardCacheStore.clear()
+        defer { OpenAIDashboardCacheStore.clear() }
+
+        let emptyHome = self.makeEmptyHome()
+        defer { try? FileManager.default.removeItem(at: emptyHome) }
+        let context = self.makeContext(
+            authHome: emptyHome,
+            knownOwners: [
+                CodexDashboardKnownOwnerCandidate(
+                    identity: .providerAccount(id: "acct-owner"),
+                    normalizedEmail: "owner@example.com"),
+            ])
+        let dashboard = self.makeDashboard(email: "owner@example.com")
+        OpenAIDashboardCacheStore.save(OpenAIDashboardCache(
+            accountEmail: "stale-route@example.com",
+            snapshot: dashboard))
+
+        let restored = CodexBarCLI.loadOpenAIDashboardIfAvailable(
+            usage: self.makeUsage(email: "owner@example.com"),
+            sourceLabel: "oauth",
+            context: context)
+
+        #expect(restored == dashboard)
+    }
+
+    @Test
+    func `cached dashboard does not trust open A I web usage continuity`() {
+        OpenAIDashboardCacheStore.clear()
+        defer { OpenAIDashboardCacheStore.clear() }
+
+        let emptyHome = self.makeEmptyHome()
+        defer { try? FileManager.default.removeItem(at: emptyHome) }
+        let context = self.makeContext(
+            authHome: emptyHome,
+            knownOwners: [
+                CodexDashboardKnownOwnerCandidate(
+                    identity: .providerAccount(id: "acct-owner"),
+                    normalizedEmail: "owner@example.com"),
+            ])
+        OpenAIDashboardCacheStore.save(OpenAIDashboardCache(
+            accountEmail: "owner@example.com",
+            snapshot: self.makeDashboard(email: "owner@example.com")))
+
+        let restored = CodexBarCLI.loadOpenAIDashboardIfAvailable(
+            usage: self.makeUsage(email: "owner@example.com"),
+            sourceLabel: "openai-web",
+            context: context)
+
+        #expect(restored == nil)
+        #expect(OpenAIDashboardCacheStore.load() == nil)
+    }
+
+    @Test
+    func `cached dashboard ignores cached account email equality when authority rejects`() throws {
+        OpenAIDashboardCacheStore.clear()
+        defer { OpenAIDashboardCacheStore.clear() }
+
+        let authHome = try self.makeAuthHome(
+            email: "owner@example.com",
+            accountId: "acct-owner")
+        defer { try? FileManager.default.removeItem(at: authHome) }
+
+        let context = self.makeContext(
+            authHome: authHome,
+            knownOwners: [
+                CodexDashboardKnownOwnerCandidate(
+                    identity: .providerAccount(id: "acct-other"),
+                    normalizedEmail: "owner@example.com"),
+            ])
+        OpenAIDashboardCacheStore.save(OpenAIDashboardCache(
+            accountEmail: "owner@example.com",
+            snapshot: self.makeDashboard(email: "owner@example.com")))
+
+        let restored = CodexBarCLI.loadOpenAIDashboardIfAvailable(
+            usage: self.makeUsage(email: "owner@example.com"),
+            sourceLabel: "codex-cli",
+            context: context)
+
+        #expect(restored == nil)
+        #expect(OpenAIDashboardCacheStore.load() == nil)
+    }
+
+    private func makeContext(
+        authHome: URL?,
+        knownOwners: [CodexDashboardKnownOwnerCandidate]) -> ProviderFetchContext
+    {
+        let env = authHome.map { ["CODEX_HOME": $0.path] } ?? [:]
+        let browserDetection = BrowserDetection(cacheTTL: 0)
+        return ProviderFetchContext(
+            runtime: .cli,
+            sourceMode: .auto,
+            includeCredits: true,
+            webTimeout: 60,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: env,
+            settings: ProviderSettingsSnapshot.make(
+                codex: .init(
+                    usageDataSource: .auto,
+                    cookieSource: .auto,
+                    manualCookieHeader: nil,
+                    dashboardAuthorityKnownOwners: knownOwners)),
+            fetcher: UsageFetcher(environment: env),
+            claudeFetcher: ClaudeUsageFetcher(browserDetection: browserDetection),
+            browserDetection: browserDetection)
+    }
+
+    private func makeUsage(email: String?) -> UsageSnapshot {
+        UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 10,
+                windowMinutes: 300,
+                resetsAt: Date(timeIntervalSince1970: 7200),
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date(timeIntervalSince1970: 2000),
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: email,
+                accountOrganization: nil,
+                loginMethod: nil))
+    }
+
+    private func makeDashboard(email: String) -> OpenAIDashboardSnapshot {
+        let creditEvents = [
+            CreditEvent(
+                date: Date(timeIntervalSince1970: 1000),
+                service: "codex",
+                creditsUsed: 3),
+        ]
+        return OpenAIDashboardSnapshot(
+            signedInEmail: email,
+            codeReviewRemainingPercent: 75,
+            codeReviewLimit: RateWindow(
+                usedPercent: 25,
+                windowMinutes: 60,
+                resetsAt: Date(timeIntervalSince1970: 3600),
+                resetDescription: nil),
+            creditEvents: creditEvents,
+            dailyBreakdown: OpenAIDashboardSnapshot.makeDailyBreakdown(from: creditEvents, maxDays: 30),
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            primaryLimit: RateWindow(
+                usedPercent: 10,
+                windowMinutes: 300,
+                resetsAt: Date(timeIntervalSince1970: 7200),
+                resetDescription: nil),
+            secondaryLimit: nil,
+            creditsRemaining: 42,
+            accountPlan: "pro",
+            updatedAt: Date(timeIntervalSince1970: 2000))
+    }
+
+    private func makeAuthHome(email: String?, accountId: String? = nil) throws -> URL {
+        let homeURL = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        try self.writeCodexAuthFile(homeURL: homeURL, email: email, accountId: accountId)
+        return homeURL
+    }
+
+    private func makeEmptyHome() -> URL {
+        let homeURL = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        try? FileManager.default.createDirectory(at: homeURL, withIntermediateDirectories: true)
+        return homeURL
+    }
+
+    private func writeCodexAuthFile(
+        homeURL: URL,
+        email: String?,
+        accountId: String?) throws
+    {
+        try FileManager.default.createDirectory(at: homeURL, withIntermediateDirectories: true)
+        var tokens: [String: Any] = [
+            "accessToken": "access-token",
+            "refreshToken": "refresh-token",
+            "idToken": Self.fakeJWT(email: email, accountId: accountId),
+        ]
+        if let accountId {
+            tokens["accountId"] = accountId
+        }
+        let auth = ["tokens": tokens]
+        let data = try JSONSerialization.data(withJSONObject: auth)
+        try data.write(to: homeURL.appendingPathComponent("auth.json"))
+    }
+
+    private static func fakeJWT(email: String?, accountId: String?) -> String {
+        let header = (try? JSONSerialization.data(withJSONObject: ["alg": "none"])) ?? Data()
+        var authClaims: [String: Any] = [
+            "chatgpt_plan_type": "pro",
+        ]
+        if let accountId {
+            authClaims["chatgpt_account_id"] = accountId
+        }
+        var claims: [String: Any] = [
+            "chatgpt_plan_type": "pro",
+            "https://api.openai.com/auth": authClaims,
+        ]
+        if let email {
+            claims["email"] = email
+        }
+        let payload = (try? JSONSerialization.data(withJSONObject: claims)) ?? Data()
+
+        func base64URL(_ data: Data) -> String {
+            data.base64EncodedString()
+                .replacingOccurrences(of: "=", with: "")
+                .replacingOccurrences(of: "+", with: "-")
+                .replacingOccurrences(of: "/", with: "_")
+        }
+
+        return "\(base64URL(header)).\(base64URL(payload))."
+    }
+}
diff --git a/Tests/CodexBarTests/CLIOutputTests.swift b/Tests/CodexBarTests/CLIOutputTests.swift
index e8b828b1ec..143651a14e 100644
--- a/Tests/CodexBarTests/CLIOutputTests.swift
+++ b/Tests/CodexBarTests/CLIOutputTests.swift
@@ -1,18 +1,18 @@
 import Foundation
 import Testing
 @testable import CodexBarCLI
+@testable import CodexBarCore
 
-@Suite
 struct CLIOutputTests {
     @Test
-    func outputPreferencesJsonOnlyForcesJSON() {
+    func `output preferences json only forces JSON`() {
         let output = CLIOutputPreferences.from(argv: ["--json-only"])
         #expect(output.jsonOnly == true)
         #expect(output.format == .json)
     }
 
     @Test
-    func cliErrorPayloadIsJSONArray() throws {
+    func `cli error payload is JSON array`() throws {
         let payload = CodexBarCLI.makeCLIErrorPayload(
             message: "Nope",
             code: .failure,
@@ -27,4 +27,126 @@ struct CLIOutputTests {
         let error = first?["error"] as? [String: Any]
         #expect(error?["message"] as? String == "Nope")
     }
+
+    @Test
+    func `exit omits generic error when command already emitted payload`() {
+        #expect(!CodexBarCLI.shouldPrintExitError(code: .success, message: nil))
+        #expect(!CodexBarCLI.shouldPrintExitError(code: .failure, message: nil))
+        #expect(CodexBarCLI.shouldPrintExitError(code: .failure, message: "Nope"))
+    }
+
+    @Test
+    func `text renderer includes deepgram usage metrics`() {
+        let deepgram = DeepgramUsageSnapshot(
+            projectID: "project-123",
+            start: "2026-05-10",
+            end: "2026-05-17",
+            hours: 12.5,
+            totalHours: 14,
+            agentHours: 1.25,
+            tokensIn: 100,
+            tokensOut: 50,
+            ttsCharacters: 1200,
+            requests: 42,
+            updatedAt: Date(timeIntervalSince1970: 0))
+        let text = CLIRenderer.renderText(
+            provider: .deepgram,
+            snapshot: deepgram.toUsageSnapshot(),
+            credits: nil,
+            context: RenderContext(
+                header: "Deepgram (api)",
+                status: nil,
+                useColor: false,
+                resetStyle: .countdown))
+
+        #expect(text.contains("Requests: 42"))
+        #expect(text.contains("Usage: 12.5 audio hours · 14 billable hours"))
+        #expect(text.contains("Usage: 1.2 agent hours · 150 tokens · 1,200 TTS chars"))
+        #expect(text.contains("Period: 2026-05-10 to 2026-05-17"))
+    }
+
+    @Test
+    func `text renderer includes amp credits without free tier usage`() {
+        let snapshot = AmpUsageSnapshot(
+            freeQuota: nil,
+            freeUsed: nil,
+            hourlyReplenishment: nil,
+            windowHours: nil,
+            individualCredits: 25.64,
+            workspaceBalances: [
+                AmpWorkspaceBalance(name: "Alpha Team", remaining: 1234.56),
+            ],
+            accountEmail: "paid@example.com",
+            updatedAt: Date(timeIntervalSince1970: 0))
+            .toUsageSnapshot()
+
+        let text = CLIRenderer.renderText(
+            provider: .amp,
+            snapshot: snapshot,
+            credits: nil,
+            context: RenderContext(
+                header: "Amp (cli)",
+                status: nil,
+                useColor: false,
+                resetStyle: .countdown))
+
+        #expect(text.contains("Individual credits: $25.64"))
+        #expect(text.contains("Workspace Alpha Team: $1,234.56"))
+        #expect(text.contains("Account: paid@example.com"))
+        #expect(!text.contains("Amp Free:"))
+    }
+
+    @Test
+    func `text renderer shows mimo balance without quota or reset text`() {
+        let snapshot = MiMoUsageSnapshot(
+            balance: 25.51,
+            currency: "USD",
+            cashBalance: 20,
+            giftBalance: 5.51,
+            updatedAt: Date(timeIntervalSince1970: 0))
+            .toUsageSnapshot()
+
+        let text = CLIRenderer.renderText(
+            provider: .mimo,
+            snapshot: snapshot,
+            credits: nil,
+            context: RenderContext(
+                header: "Xiaomi MiMo (web)",
+                status: nil,
+                useColor: false,
+                resetStyle: .countdown))
+
+        #expect(text.contains("Balance: $25.51 (Paid: $20.00 / Granted: $5.51)"))
+        #expect(!text.contains("100%"))
+        #expect(!text.contains("Resets"))
+        #expect(!text.contains("Plan: Balance"))
+    }
+
+    @Test
+    func `text renderer shows mimo token credits and balance`() {
+        let snapshot = MiMoUsageSnapshot(
+            balance: 25.51,
+            currency: "USD",
+            planCode: "standard",
+            tokenUsed: 10,
+            tokenLimit: 100,
+            tokenPercent: 0.1,
+            updatedAt: Date(timeIntervalSince1970: 0))
+            .toUsageSnapshot()
+
+        let text = CLIRenderer.renderText(
+            provider: .mimo,
+            snapshot: snapshot,
+            credits: nil,
+            context: RenderContext(
+                header: "Xiaomi MiMo (web)",
+                status: nil,
+                useColor: false,
+                resetStyle: .countdown))
+
+        #expect(text.contains("Credits: 90% left"))
+        #expect(text.contains("Balance: $25.51"))
+        #expect(text.contains("Plan: Standard"))
+        #expect(!text.contains("Window: 100%"))
+    }
 }
diff --git a/Tests/CodexBarTests/CLIProviderSelectionTests.swift b/Tests/CodexBarTests/CLIProviderSelectionTests.swift
index fe74c2860b..8fa24d0a72 100644
--- a/Tests/CodexBarTests/CLIProviderSelectionTests.swift
+++ b/Tests/CodexBarTests/CLIProviderSelectionTests.swift
@@ -3,10 +3,9 @@ import Foundation
 import Testing
 @testable import CodexBarCLI
 
-@Suite
 struct CLIProviderSelectionTests {
     @Test
-    func helpIncludesGeminiAndAll() {
+    func `help includes gemini and all`() {
         let usage = CodexBarCLI.usageHelp(version: "0.0.0")
         let root = CodexBarCLI.rootHelp(version: "0.0.0")
         let expectedProviders = [
@@ -45,7 +44,7 @@ struct CLIProviderSelectionTests {
     }
 
     @Test
-    func helpMentionsSourceFlag() {
+    func `help mentions source flag`() {
         let usage = CodexBarCLI.usageHelp(version: "0.0.0")
         let root = CodexBarCLI.rootHelp(version: "0.0.0")
 
@@ -65,41 +64,49 @@ struct CLIProviderSelectionTests {
     }
 
     @Test
-    func providerSelectionRespectsOverride() {
+    func `provider selection respects override`() {
         let selection = CodexBarCLI.providerSelection(rawOverride: "gemini", enabled: [.codex, .claude])
         #expect(selection.asList == [.gemini])
     }
 
     @Test
-    func providerSelectionUsesAllWhenEnabled() {
+    func `provider selection uses enabled providers when three or more are enabled`() {
         let selection = CodexBarCLI.providerSelection(
             rawOverride: nil,
             enabled: [.codex, .claude, .zai, .cursor, .gemini, .antigravity, .factory, .copilot])
-        #expect(selection.asList == ProviderSelection.all.asList)
+        #expect(selection.asList == [.codex, .claude, .zai, .cursor, .gemini, .antigravity, .factory, .copilot])
     }
 
     @Test
-    func providerSelectionUsesBothForCodexAndClaude() {
+    func `provider selection does not expand three enabled providers to all providers`() {
+        let enabled: [UsageProvider] = [.codex, .claude, .copilot]
+        let selection = CodexBarCLI.providerSelection(rawOverride: nil, enabled: enabled)
+        #expect(selection.asList == enabled)
+        #expect(!selection.asList.contains(.gemini))
+    }
+
+    @Test
+    func `provider selection uses both for codex and claude`() {
         let selection = CodexBarCLI.providerSelection(rawOverride: nil, enabled: [.codex, .claude])
         #expect(selection.asList == [.codex, .claude])
     }
 
     @Test
-    func providerSelectionUsesCustomForCodexAndGemini() {
+    func `provider selection uses custom for codex and gemini`() {
         let enabled: [UsageProvider] = [.codex, .gemini]
         let selection = CodexBarCLI.providerSelection(rawOverride: nil, enabled: enabled)
         #expect(selection.asList == enabled)
     }
 
     @Test
-    func providerSelectionAcceptsKiroAlias() {
+    func `provider selection accepts kiro alias`() {
         let selection = CodexBarCLI.providerSelection(rawOverride: "kiro-cli", enabled: [.codex])
         #expect(selection.asList == [.kiro])
     }
 
     @Test
-    func providerSelectionDefaultsToCodexWhenEmpty() {
+    func `provider selection honors empty enabled set`() {
         let selection = CodexBarCLI.providerSelection(rawOverride: nil, enabled: [])
-        #expect(selection.asList == [.codex])
+        #expect(selection.asList == [])
     }
 }
diff --git a/Tests/CodexBarTests/CLIServeRouterTests.swift b/Tests/CodexBarTests/CLIServeRouterTests.swift
new file mode 100644
index 0000000000..0e75871cdd
--- /dev/null
+++ b/Tests/CodexBarTests/CLIServeRouterTests.swift
@@ -0,0 +1,1347 @@
+import Commander
+import Foundation
+import Testing
+#if canImport(Darwin)
+import Darwin
+#else
+import Glibc
+#endif
+@testable import CodexBarCLI
+@testable import CodexBarCore
+
+// Cache state-machine coverage is intentionally kept together for sequence readability.
+// swiftlint:disable:next type_body_length
+struct CLIServeRouterTests {
+    @Test
+    func `termination monitor handles interactive and hangup signals`() {
+        #expect(CLITerminationSignalMonitor.signalNumbers == [SIGINT, SIGTERM, SIGHUP])
+    }
+
+    @Test
+    func `local http parser accepts only loopback host headers`() throws {
+        let allowedHosts = [
+            "localhost",
+            "localhost.",
+            "localhost:8080",
+            "127.0.0.1",
+            "127.0.0.1:8080",
+            "[::1]",
+            "[::1]:8080",
+        ]
+
+        for host in allowedHosts {
+            let request = try Self.parsedRequest(host: host)
+            #expect(request.host == host)
+            #expect(request.path == "/usage")
+        }
+    }
+
+    @Test
+    func `local http parser rejects hostile missing and duplicate hosts`() {
+        Self.expectParseFailure(raw: "GET /usage HTTP/1.1\r\n\r\n", .missingHost)
+        Self.expectParseFailure(raw: "GET /usage HTTP/1.1\r\nHost: evil.test\r\n\r\n", .disallowedHost)
+        Self.expectParseFailure(raw: "GET /usage HTTP/1.1\r\nHost: localhost, evil.test\r\n\r\n", .disallowedHost)
+        Self.expectParseFailure(raw: "GET /usage HTTP/1.1\r\nHost: localhost:abc\r\n\r\n", .disallowedHost)
+        Self.expectParseFailure(
+            raw: "GET /usage HTTP/1.1\r\nHost: localhost\r\nHost: 127.0.0.1\r\n\r\n",
+            .duplicateHost)
+    }
+
+    @Test
+    func `routes health usage and cost endpoints`() throws {
+        #expect(try CLIServeRouter.route(method: "GET", path: "/health", queryItems: [:]) == .health)
+        #expect(try CLIServeRouter.route(method: "GET", path: "/usage", queryItems: [:]) == .usage(provider: nil))
+        #expect(
+            try CLIServeRouter.route(
+                method: "GET",
+                path: "/usage",
+                queryItems: ["provider": "claude"]) == .usage(provider: "claude"))
+        #expect(
+            try CLIServeRouter.route(
+                method: "GET",
+                path: "/cost",
+                queryItems: ["provider": "codex"]) == .cost(provider: "codex"))
+    }
+
+    @Test
+    func `rejects non get methods`() {
+        do {
+            _ = try CLIServeRouter.route(method: "POST", path: "/usage", queryItems: [:])
+            Issue.record("Expected methodNotAllowed")
+        } catch let error as CLIServeRouteError {
+            #expect(error == .methodNotAllowed)
+        } catch {
+            Issue.record("Unexpected error: \(error)")
+        }
+    }
+
+    @Test
+    func `rejects unknown paths`() {
+        do {
+            _ = try CLIServeRouter.route(method: "GET", path: "/missing", queryItems: [:])
+            Issue.record("Expected notFound")
+        } catch let error as CLIServeRouteError {
+            #expect(error == .notFound)
+        } catch {
+            Issue.record("Unexpected error: \(error)")
+        }
+    }
+
+    @Test
+    func `health response reports ok status and build version`() throws {
+        let response = CodexBarCLI.serveHealthResponse(version: "1.2.3")
+        #expect(response.status == .ok)
+        let object = try JSONSerialization.jsonObject(with: response.body) as? [String: Any]
+        #expect(object?["status"] as? String == "ok")
+        #expect(object?["version"] as? String == "1.2.3")
+    }
+
+    @Test
+    func `health response omits version detail when unavailable`() throws {
+        let response = CodexBarCLI.serveHealthResponse(version: nil)
+        #expect(response.status == .ok)
+        let object = try JSONSerialization.jsonObject(with: response.body) as? [String: Any]
+        #expect(object?["status"] as? String == "ok")
+        #expect(object?.keys.contains("version") == false)
+    }
+
+    @Test
+    func `serve numeric options reject malformed values`() {
+        #expect(CodexBarCLI.decodeServePort(from: ParsedValues(
+            positional: [],
+            options: ["port": ["abc"]],
+            flags: [])) == nil)
+        #expect(CodexBarCLI.decodeServePort(from: ParsedValues(
+            positional: [],
+            options: ["port": ["0"]],
+            flags: [])) == nil)
+        #expect(CodexBarCLI.decodeServePort(from: ParsedValues(
+            positional: [],
+            options: ["port": ["65536"]],
+            flags: [])) == nil)
+        #expect(CodexBarCLI.decodeServePort(from: ParsedValues(
+            positional: [],
+            options: [:],
+            flags: [])) == 8080)
+
+        #expect(CodexBarCLI.decodeServeRefreshInterval(from: ParsedValues(
+            positional: [],
+            options: ["refreshInterval": ["later"]],
+            flags: [])) == nil)
+        #expect(CodexBarCLI.decodeServeRefreshInterval(from: ParsedValues(
+            positional: [],
+            options: ["refreshInterval": ["-1"]],
+            flags: [])) == nil)
+        #expect(CodexBarCLI.decodeServeRefreshInterval(from: ParsedValues(
+            positional: [],
+            options: ["refreshInterval": ["inf"]],
+            flags: [])) == nil)
+        #expect(CodexBarCLI.decodeServeRefreshInterval(from: ParsedValues(
+            positional: [],
+            options: ["refreshInterval": ["86401"]],
+            flags: [])) == 86401)
+        #expect(CodexBarCLI.decodeServeRefreshInterval(from: ParsedValues(
+            positional: [],
+            options: ["refreshInterval": ["86400"]],
+            flags: [])) == 86400)
+        #expect(CodexBarCLI.decodeServeRefreshInterval(from: ParsedValues(
+            positional: [],
+            options: [:],
+            flags: [])) == 60)
+
+        #expect(CodexBarCLI.decodeServeRequestTimeout(from: ParsedValues(
+            positional: [],
+            options: ["requestTimeout": ["soon"]],
+            flags: [])) == nil)
+        #expect(CodexBarCLI.decodeServeRequestTimeout(from: ParsedValues(
+            positional: [],
+            options: ["requestTimeout": ["-0.5"]],
+            flags: [])) == nil)
+        #expect(CodexBarCLI.decodeServeRequestTimeout(from: ParsedValues(
+            positional: [],
+            options: ["requestTimeout": ["0"]],
+            flags: [])) == 0)
+        #expect(CodexBarCLI.decodeServeRequestTimeout(from: ParsedValues(
+            positional: [],
+            options: ["requestTimeout": ["12.5"]],
+            flags: [])) == 12.5)
+        #expect(CodexBarCLI.decodeServeRequestTimeout(from: ParsedValues(
+            positional: [],
+            options: [:],
+            flags: [])) == 30)
+    }
+
+    @Test
+    func `serve help documents request timeout option`() {
+        let serve = CodexBarCLI.serveHelp(version: "0.0.0")
+        let root = CodexBarCLI.rootHelp(version: "0.0.0")
+
+        #expect(serve.contains("--request-timeout <seconds>"))
+        #expect(serve.contains("codexbar serve --port 8080 --refresh-interval 60 --request-timeout 30"))
+        #expect(root.contains("--request-timeout <seconds>"))
+    }
+
+    @Test
+    func `serve config snapshot reflects provider changes`() throws {
+        let store = testConfigStore(suiteName: "CLIServeRouterTests-serve-config-freshness-\(UUID().uuidString)")
+        defer { try? store.deleteIfPresent() }
+        var firstConfig = CodexBarConfig.makeDefault()
+        firstConfig.setProviderConfig(ProviderConfig(id: .opencodego, enabled: false))
+        try store.save(firstConfig)
+
+        let firstSnapshot = try CodexBarCLI.loadServeConfigSnapshot(configStore: store)
+
+        var secondConfig = firstConfig
+        secondConfig.setProviderConfig(ProviderConfig(id: .opencodego, enabled: true))
+        try store.save(secondConfig)
+        let secondSnapshot = try CodexBarCLI.loadServeConfigSnapshot(configStore: store)
+
+        #expect(!firstSnapshot.config.enabledProviders().contains(.opencodego))
+        #expect(secondSnapshot.config.enabledProviders().contains(.opencodego))
+        #expect(firstSnapshot.cacheToken != secondSnapshot.cacheToken)
+        #expect(
+            CodexBarCLI.serveCacheKey(kind: "usage", provider: nil, configToken: firstSnapshot.cacheToken) !=
+                CodexBarCLI.serveCacheKey(kind: "usage", provider: nil, configToken: secondSnapshot.cacheToken))
+    }
+
+    @Test
+    func `serve cache skips provider error payloads`() {
+        let success = CLILocalHTTPResponse(
+            status: .ok,
+            body: Data(#"[{"provider":"codex","source":"local"}]"#.utf8))
+        let providerError = CLILocalHTTPResponse(
+            status: .ok,
+            body: Data(#"[{"provider":"codex","source":"local","error":{"message":"temporary"}}]"#.utf8))
+        let routeError = CLILocalHTTPResponse(
+            status: .badRequest,
+            body: Data(#"{"error":"bad request"}"#.utf8))
+
+        #expect(CodexBarCLI.shouldCacheServeResponse(success))
+        #expect(!CodexBarCLI.shouldCacheServeResponse(providerError))
+        #expect(!CodexBarCLI.shouldCacheServeResponse(routeError))
+    }
+
+    @Test
+    func `serve cache uses stable Codex account identities`() {
+        let storedID = UUID()
+        let firstProjection = Self.codexVisibleAccount(
+            id: "email-shaped-id",
+            workspaceAccountID: "workspace-1",
+            authFingerprint: "auth-1",
+            storedAccountID: storedID)
+        let reshapedProjection = Self.codexVisibleAccount(
+            id: "managed:\(storedID.uuidString)",
+            workspaceAccountID: "workspace-1",
+            authFingerprint: "auth-1",
+            storedAccountID: storedID)
+        let replacement = Self.codexVisibleAccount(
+            id: "email-shaped-id",
+            workspaceAccountID: "workspace-2",
+            authFingerprint: "auth-2",
+            storedAccountID: UUID())
+        let workspacePeer = Self.codexVisibleAccount(
+            id: "workspace-peer",
+            email: "other@example.com",
+            workspaceAccountID: "workspace-1",
+            authFingerprint: "auth-3",
+            storedAccountID: UUID())
+        let ambiguous = Self.codexVisibleAccount(
+            id: "email-only",
+            workspaceAccountID: nil,
+            authFingerprint: nil,
+            storedAccountID: nil)
+        let storedBeforeRefresh = Self.codexVisibleAccount(
+            id: "stored-before",
+            workspaceAccountID: nil,
+            authFingerprint: "old-auth",
+            storedAccountID: storedID)
+        let storedAfterRefresh = Self.codexVisibleAccount(
+            id: "stored-after",
+            workspaceAccountID: nil,
+            authFingerprint: "new-auth",
+            storedAccountID: storedID)
+
+        let firstKey = CodexBarCLI.usageCacheAccountKey(
+            provider: .codex,
+            account: nil,
+            codexVisibleAccount: firstProjection)
+        let reshapedKey = CodexBarCLI.usageCacheAccountKey(
+            provider: .codex,
+            account: nil,
+            codexVisibleAccount: reshapedProjection)
+        let replacementKey = CodexBarCLI.usageCacheAccountKey(
+            provider: .codex,
+            account: nil,
+            codexVisibleAccount: replacement)
+        let workspacePeerKey = CodexBarCLI.usageCacheAccountKey(
+            provider: .codex,
+            account: nil,
+            codexVisibleAccount: workspacePeer)
+        let storedBeforeKey = CodexBarCLI.usageCacheAccountKey(
+            provider: .codex,
+            account: nil,
+            codexVisibleAccount: storedBeforeRefresh)
+        let storedAfterKey = CodexBarCLI.usageCacheAccountKey(
+            provider: .codex,
+            account: nil,
+            codexVisibleAccount: storedAfterRefresh)
+
+        #expect(firstKey == reshapedKey)
+        #expect(firstKey != replacementKey)
+        #expect(firstKey != workspacePeerKey)
+        #expect(storedBeforeKey == storedAfterKey)
+        #expect(CodexBarCLI.usageCacheAccountKey(
+            provider: .codex,
+            account: nil,
+            codexVisibleAccount: ambiguous) == nil)
+        #expect(CodexBarCLI.usageCacheAccountKey(
+            provider: .antigravity,
+            account: nil,
+            codexVisibleAccount: nil) == nil)
+    }
+
+    @Test
+    func `serve cache coalesces concurrent cache misses`() async {
+        let cache = CLIServeResponseCache()
+        let counter = ServeTestCounter()
+
+        let responses = await withTaskGroup(of: CLILocalHTTPResponse.self) { group -> [CLILocalHTTPResponse] in
+            for _ in 0..<5 {
+                group.addTask {
+                    await CodexBarCLI.cachedServeResponse(
+                        key: "usage:",
+                        cache: cache,
+                        refreshInterval: 60,
+                        requestTimeout: 1)
+                    {
+                        let call = await counter.increment()
+                        try? await Task.sleep(nanoseconds: 50_000_000)
+                        return Self.response("[{\"provider\":\"codex\",\"call\":\(call)}]")
+                    }
+                }
+            }
+
+            var responses: [CLILocalHTTPResponse] = []
+            for await response in group {
+                responses.append(response)
+            }
+            return responses
+        }
+
+        #expect(await counter.current() == 1)
+        #expect(Set(responses.map(Self.bodyString)).count == 1)
+        #expect(responses.allSatisfy { $0.status == .ok })
+        #expect(responses.allSatisfy { Self.bodyString($0).contains("\"call\":1") })
+    }
+
+    @Test
+    func `serve cache prunes expired config token entries`() async throws {
+        let cache = CLIServeResponseCache()
+
+        _ = await CodexBarCLI.cachedServeResponse(
+            key: "usage::old-config",
+            cache: cache,
+            refreshInterval: 0.001)
+        {
+            Self.response(#"[{"provider":"codex","config":"old"}]"#)
+        }
+        #expect(await cache.cachedEntryCount() == 1)
+
+        try await Task.sleep(nanoseconds: 20_000_000)
+        _ = await CodexBarCLI.cachedServeResponse(
+            key: "usage::new-config",
+            cache: cache,
+            refreshInterval: 60)
+        {
+            Self.response(#"[{"provider":"codex","config":"new"}]"#)
+        }
+
+        #expect(await cache.cachedEntryCount() == 1)
+    }
+
+    @Test
+    func `serve cache does not cache timeouts and recovers on next success`() async {
+        let cache = CLIServeResponseCache()
+        let counter = ServeTestCounter()
+
+        let timeout = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 60,
+            requestTimeout: 0.01)
+        {
+            _ = await counter.increment()
+            try? await Task.sleep(nanoseconds: 200_000_000)
+            return Self.response("[{\"provider\":\"codex\",\"call\":1}]")
+        }
+
+        #expect(timeout.status == .gatewayTimeout)
+        #expect(Self.bodyString(timeout).contains("request timed out"))
+
+        let success = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 60,
+            requestTimeout: 1)
+        {
+            let call = await counter.increment()
+            return Self.response("[{\"provider\":\"codex\",\"call\":\(call)}]")
+        }
+
+        #expect(success.status == .ok)
+        #expect(Self.bodyString(success).contains("\"call\":2"))
+
+        let cached = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 60,
+            requestTimeout: 1)
+        {
+            let call = await counter.increment()
+            return Self.response("[{\"provider\":\"codex\",\"call\":\(call)}]")
+        }
+
+        #expect(cached.status == .ok)
+        #expect(Self.bodyString(cached) == Self.bodyString(success))
+        #expect(await counter.current() == 2)
+    }
+
+    @Test
+    func `serve cache resumes coalesced waiters on timeout`() async {
+        let cache = CLIServeResponseCache()
+        let counter = ServeTestCounter()
+
+        let responses = await withTaskGroup(of: CLILocalHTTPResponse.self) { group -> [CLILocalHTTPResponse] in
+            for _ in 0..<4 {
+                group.addTask {
+                    await CodexBarCLI.cachedServeResponse(
+                        key: "usage:",
+                        cache: cache,
+                        refreshInterval: 60,
+                        requestTimeout: 0.01)
+                    {
+                        _ = await counter.increment()
+                        try? await Task.sleep(nanoseconds: 200_000_000)
+                        return Self.response("[{\"provider\":\"codex\"}]")
+                    }
+                }
+            }
+
+            var responses: [CLILocalHTTPResponse] = []
+            for await response in group {
+                responses.append(response)
+            }
+            return responses
+        }
+
+        #expect(await counter.current() == 1)
+        #expect(responses.count == 4)
+        #expect(responses.allSatisfy { $0.status == .gatewayTimeout })
+        #expect(responses.allSatisfy { Self.bodyString($0).contains("request timed out") })
+    }
+
+    @Test
+    func `serve cache serves last good payload when refresh fails`() async {
+        let cache = CLIServeResponseCache()
+        let counter = ServeTestCounter()
+
+        let first = await CodexBarCLI.cachedServeResponse(
+            key: "usage:antigravity",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            let call = await counter.increment()
+            return Self.response("[{\"provider\":\"antigravity\",\"call\":\(call)}]")
+        }
+        #expect(first.status == .ok)
+
+        // Let the fresh cache entry expire so the next request re-fetches.
+        try? await Task.sleep(nanoseconds: 100_000_000)
+
+        let failed = await CodexBarCLI.cachedServeResponse(
+            key: "usage:antigravity",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            _ = await counter.increment()
+            return Self.response(
+                "[{\"provider\":\"antigravity\",\"error\":{\"message\":\"transient\"}}]")
+        }
+
+        // Transient failure is masked by the last good payload.
+        #expect(failed.status == .ok)
+        let failedRows = try? Self.jsonRows(failed)
+        #expect(failedRows?.first?["call"] as? Int == 1)
+        #expect(await counter.current() == 2)
+
+        try? await Task.sleep(nanoseconds: 100_000_000)
+
+        let recovered = await CodexBarCLI.cachedServeResponse(
+            key: "usage:antigravity",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            let call = await counter.increment()
+            return Self.response("[{\"provider\":\"antigravity\",\"call\":\(call)}]")
+        }
+
+        #expect(recovered.status == .ok)
+        #expect(Self.bodyString(recovered).contains("\"call\":3"))
+    }
+
+    @Test
+    func `serve cache replaces only failed provider account rows`() async throws {
+        let cache = CLIServeResponseCache()
+
+        _ = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            Self.response("""
+            [
+              {"provider":"codex","account":"personal","call":1},
+              {"provider":"antigravity","account":"work","call":1},
+              {"provider":"antigravity","account":"personal","call":1}
+            ]
+            """)
+        }
+
+        try? await Task.sleep(nanoseconds: 100_000_000)
+
+        let refreshed = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            Self.response("""
+            [
+              {"provider":"codex","account":"personal","call":2},
+              {"provider":"antigravity","account":"work","error":{"message":"transient"}},
+              {"provider":"antigravity","account":"personal","call":2}
+            ]
+            """)
+        }
+        let rows = try Self.jsonRows(refreshed)
+
+        #expect(Self.row(rows, provider: "codex", account: "personal")?["call"] as? Int == 2)
+        #expect(Self.row(rows, provider: "antigravity", account: "work")?["call"] as? Int == 1)
+        #expect(Self.row(rows, provider: "antigravity", account: "personal")?["call"] as? Int == 2)
+        #expect(rows.allSatisfy { $0["error"] == nil })
+    }
+
+    @Test
+    func `serve cache retains newer per-row success across all-error refresh`() async throws {
+        let cache = CLIServeResponseCache()
+
+        _ = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            Self.response("""
+            [
+              {"provider":"codex","call":1},
+              {"provider":"antigravity","call":1}
+            ]
+            """)
+        }
+        try? await Task.sleep(nanoseconds: 100_000_000)
+
+        _ = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            Self.response("""
+            [
+              {"provider":"codex","call":2},
+              {"provider":"antigravity","error":{"message":"transient"}}
+            ]
+            """)
+        }
+        try? await Task.sleep(nanoseconds: 100_000_000)
+
+        let failed = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            Self.response("""
+            [
+              {"provider":"codex","error":{"message":"transient"}},
+              {"provider":"antigravity","error":{"message":"transient"}}
+            ]
+            """)
+        }
+        let rows = try Self.jsonRows(failed)
+
+        #expect(Self.row(rows, provider: "codex")?["call"] as? Int == 2)
+        #expect(Self.row(rows, provider: "antigravity")?["call"] as? Int == 1)
+    }
+
+    @Test
+    func `serve cache fails closed on timeout after merged rows`() async {
+        let cache = CLIServeResponseCache()
+
+        _ = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            Self.response("""
+            [
+              {"provider":"codex","call":1},
+              {"provider":"antigravity","call":1}
+            ]
+            """)
+        }
+        try? await Task.sleep(nanoseconds: 100_000_000)
+
+        _ = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            Self.response("""
+            [
+              {"provider":"codex","call":2},
+              {"provider":"antigravity","error":{"message":"transient"}}
+            ]
+            """)
+        }
+        try? await Task.sleep(nanoseconds: 100_000_000)
+
+        let timedOut = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 0.01)
+        {
+            try? await Task.sleep(nanoseconds: 200_000_000)
+            return Self.response("[]")
+        }
+        #expect(timedOut.status == .gatewayTimeout)
+        #expect(!Self.bodyString(timedOut).contains("\"call\":1"))
+        #expect(!Self.bodyString(timedOut).contains("\"call\":2"))
+    }
+
+    @Test
+    func `serve cache fails closed on timeout after a partial refresh`() async {
+        let cache = CLIServeResponseCache()
+
+        _ = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            Self.response(#"[{"provider":"codex","call":1}]"#)
+        }
+        try? await Task.sleep(nanoseconds: 100_000_000)
+
+        _ = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            Self.response("""
+            [
+              {"provider":"codex","call":2},
+              {"provider":"antigravity","error":{"message":"transient"}}
+            ]
+            """)
+        }
+        try? await Task.sleep(nanoseconds: 100_000_000)
+
+        let timedOut = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 0.01)
+        {
+            try? await Task.sleep(nanoseconds: 200_000_000)
+            return Self.response("[]")
+        }
+        #expect(timedOut.status == .gatewayTimeout)
+        #expect(!Self.bodyString(timedOut).contains("\"call\":2"))
+        #expect(!Self.bodyString(timedOut).contains("antigravity"))
+    }
+
+    @Test
+    func `serve cache does not reconstruct usage rows after timeout`() async {
+        let cache = CLIServeResponseCache()
+        let policy = CLIServeResponseCache.CachePolicy(ttl: 0, staleTTL: 10)
+        let startedAt = Date(timeIntervalSince1970: 1000)
+
+        _ = await cache.responseOrStartFetch(for: "usage:", now: startedAt)
+        _ = await cache.completeFetch(
+            Self.response(
+                """
+                [
+                  {"provider":"codex","call":1},
+                  {"provider":"antigravity","call":1}
+                ]
+                """),
+            for: "usage:",
+            policy: policy,
+            now: startedAt,
+            shouldCache: true)
+
+        let partialAt = startedAt.addingTimeInterval(9)
+        _ = await cache.responseOrStartFetch(for: "usage:", now: partialAt)
+        _ = await cache.completeFetch(
+            Self.response("""
+            [
+              {"provider":"codex","call":2},
+              {"provider":"antigravity","error":{"message":"transient"}}
+            ]
+            """),
+            for: "usage:",
+            policy: policy,
+            now: partialAt,
+            shouldCache: false)
+
+        let timeoutAt = startedAt.addingTimeInterval(11)
+        _ = await cache.responseOrStartFetch(for: "usage:", now: timeoutAt)
+        let timedOut = await cache.completeFetch(
+            Self.response(#"{"error":"request timed out"}"#, status: .gatewayTimeout),
+            for: "usage:",
+            policy: policy,
+            now: timeoutAt,
+            shouldCache: false)
+        #expect(timedOut.status == .gatewayTimeout)
+        #expect(Self.bodyString(timedOut).contains("request timed out"))
+        #expect(!Self.bodyString(timedOut).contains("\"call\":2"))
+    }
+
+    @Test
+    func `serve cache preserves newer row when another failed row has no fallback`() async throws {
+        let cache = CLIServeResponseCache()
+
+        _ = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            Self.response(#"[{"provider":"codex","call":1}]"#)
+        }
+        try? await Task.sleep(nanoseconds: 100_000_000)
+
+        _ = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            Self.response("""
+            [
+              {"provider":"codex","call":2},
+              {"provider":"antigravity","error":{"message":"transient"}}
+            ]
+            """)
+        }
+        try? await Task.sleep(nanoseconds: 100_000_000)
+
+        let failed = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            Self.response("""
+            [
+              {"provider":"codex","error":{"message":"transient"}},
+              {"provider":"antigravity","error":{"message":"transient"}}
+            ]
+            """)
+        }
+        let rows = try Self.jsonRows(failed)
+
+        #expect(Self.row(rows, provider: "codex")?["call"] as? Int == 2)
+        #expect(Self.row(rows, provider: "antigravity")?["error"] != nil)
+    }
+
+    @Test
+    func `serve cache keeps fresh rows when a failed row has no stale match`() async throws {
+        let cache = CLIServeResponseCache()
+
+        _ = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            Self.response(#"[{"provider":"codex","account":"personal","call":1}]"#)
+        }
+
+        try? await Task.sleep(nanoseconds: 100_000_000)
+
+        let refreshed = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            Self.response("""
+            [
+              {"provider":"codex","account":"personal","call":2},
+              {"provider":"antigravity","account":"work","error":{"message":"transient"}}
+            ]
+            """)
+        }
+        let rows = try Self.jsonRows(refreshed)
+
+        #expect(Self.row(rows, provider: "codex", account: "personal")?["call"] as? Int == 2)
+        #expect(Self.row(rows, provider: "antigravity", account: "work")?["error"] != nil)
+    }
+
+    @Test
+    func `serve cache does not merge duplicate provider account labels`() async throws {
+        let cache = CLIServeResponseCache()
+
+        _ = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            Self.response("""
+            [
+              {"provider":"codex","account":"shared","slot":"first","call":1},
+              {"provider":"codex","account":"shared","slot":"second","call":1}
+            ]
+            """)
+        }
+
+        try? await Task.sleep(nanoseconds: 100_000_000)
+
+        let refreshed = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            Self.response("""
+            [
+              {
+                "provider":"codex",
+                "account":"shared",
+                "slot":"first",
+                "error":{"message":"transient"}
+              },
+              {"provider":"codex","account":"shared","slot":"second","call":2}
+            ]
+            """)
+        }
+        let rows = try Self.jsonRows(refreshed)
+        let first = rows.first { $0["slot"] as? String == "first" }
+        let second = rows.first { $0["slot"] as? String == "second" }
+
+        #expect(first?["error"] != nil)
+        #expect(second?["call"] as? Int == 2)
+    }
+
+    @Test
+    func `serve cache follows stable account identity across label changes`() async throws {
+        let cache = CLIServeResponseCache()
+
+        _ = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            Self.response(
+                #"[{"provider":"codex","account":"old label","call":1}]"#,
+                usageCacheKeys: ["account-1"])
+        }
+        try? await Task.sleep(nanoseconds: 100_000_000)
+
+        let failed = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            Self.response(
+                #"[{"provider":"codex","account":"new label","error":{"message":"transient"}}]"#,
+                usageCacheKeys: ["account-1"])
+        }
+        let row = try #require(Self.jsonRows(failed).first)
+
+        #expect(row["account"] as? String == "old label")
+        #expect(row["call"] as? Int == 1)
+    }
+
+    @Test
+    func `serve cache does not reuse a label for a different account identity`() async throws {
+        let cache = CLIServeResponseCache()
+
+        _ = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            Self.response(
+                #"[{"provider":"codex","account":"shared","call":1}]"#,
+                usageCacheKeys: ["account-1"])
+        }
+        try? await Task.sleep(nanoseconds: 100_000_000)
+
+        let refreshed = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            Self.response(
+                """
+                [
+                  {"provider":"codex","account":"shared","error":{"message":"transient"}},
+                  {"provider":"antigravity","account":"work","call":2}
+                ]
+                """,
+                usageCacheKeys: ["account-2", "account-3"])
+        }
+        let rows = try Self.jsonRows(refreshed)
+
+        #expect(Self.row(rows, provider: "codex", account: "shared")?["error"] != nil)
+        #expect(Self.row(rows, provider: "antigravity", account: "work")?["call"] as? Int == 2)
+    }
+
+    @Test
+    func `serve cache does not use whole fallback after an account switch`() async throws {
+        let cache = CLIServeResponseCache()
+
+        _ = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            Self.response(
+                #"[{"provider":"codex","account":"shared","call":1}]"#,
+                usageCacheKeys: ["account-1"])
+        }
+        try? await Task.sleep(nanoseconds: 100_000_000)
+
+        let failed = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            Self.response(
+                #"[{"provider":"codex","account":"shared","error":{"message":"transient"}}]"#,
+                usageCacheKeys: ["account-2"])
+        }
+        let row = try #require(Self.jsonRows(failed).first)
+
+        #expect(row["call"] == nil)
+        #expect(row["error"] != nil)
+
+        let timedOut = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 0.01)
+        {
+            try? await Task.sleep(nanoseconds: 200_000_000)
+            return Self.response(
+                #"[{"provider":"codex","account":"shared","call":3}]"#,
+                usageCacheKeys: ["account-2"])
+        }
+
+        #expect(timedOut.status == .gatewayTimeout)
+        #expect(!Self.bodyString(timedOut).contains("\"call\":1"))
+    }
+
+    @Test
+    func `serve cache prunes accounts absent from a successful snapshot`() async throws {
+        let cache = CLIServeResponseCache()
+
+        _ = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            Self.response(#"[{"provider":"codex","account":"shared","call":1}]"#)
+        }
+        try? await Task.sleep(nanoseconds: 100_000_000)
+
+        _ = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            Self.response(#"[{"provider":"antigravity","account":"work","call":2}]"#)
+        }
+        try? await Task.sleep(nanoseconds: 100_000_000)
+
+        let refreshed = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            Self.response("""
+            [
+              {"provider":"codex","account":"shared","error":{"message":"transient"}},
+              {"provider":"antigravity","account":"work","call":3}
+            ]
+            """)
+        }
+        let rows = try Self.jsonRows(refreshed)
+
+        #expect(Self.row(rows, provider: "codex", account: "shared")?["error"] != nil)
+        #expect(Self.row(rows, provider: "antigravity", account: "work")?["call"] as? Int == 3)
+    }
+
+    @Test
+    func `serve cache fails closed when all-error rows have ambiguous identities`() async throws {
+        let cache = CLIServeResponseCache()
+
+        _ = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            Self.response(
+                """
+                [
+                  {"provider":"codex","account":"shared","slot":"first","call":1},
+                  {"provider":"codex","account":"shared","slot":"second","call":1},
+                  {"provider":"antigravity","account":"work","call":1}
+                ]
+                """,
+                usageCacheKeys: [nil, nil, nil])
+        }
+        try? await Task.sleep(nanoseconds: 100_000_000)
+
+        let failed = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            Self.response(
+                """
+                [
+                  {
+                    "provider":"codex",
+                    "account":"shared",
+                    "slot":"first",
+                    "error":{"message":"transient"}
+                  },
+                  {
+                    "provider":"codex",
+                    "account":"shared",
+                    "slot":"second",
+                    "error":{"message":"transient"}
+                  },
+                  {"provider":"antigravity","account":"work","error":{"message":"transient"}}
+                ]
+                """,
+                usageCacheKeys: [nil, nil, nil])
+        }
+        let rows = try Self.jsonRows(failed)
+
+        #expect(rows.count == 3)
+        #expect(rows.allSatisfy { $0["call"] == nil })
+        #expect(rows.allSatisfy { $0["error"] != nil })
+    }
+
+    @Test
+    func `serve cache does not whole-fallback ambiguous usage after timeout`() async {
+        let cache = CLIServeResponseCache()
+
+        _ = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            Self.response(
+                #"[{"provider":"antigravity","account":"first@example.com","call":1}]"#,
+                usageCacheKeys: [nil])
+        }
+        try? await Task.sleep(nanoseconds: 100_000_000)
+
+        let timedOut = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 0.01)
+        {
+            try? await Task.sleep(nanoseconds: 200_000_000)
+            return Self.response(
+                #"[{"provider":"antigravity","account":"second@example.com","call":2}]"#,
+                usageCacheKeys: [nil])
+        }
+
+        #expect(timedOut.status == .gatewayTimeout)
+        #expect(!Self.bodyString(timedOut).contains("first@example.com"))
+        #expect(!Self.bodyString(timedOut).contains("\"call\":1"))
+    }
+
+    @Test
+    func `serve cache mixed identities do not enable timeout fallback`() async {
+        let cache = CLIServeResponseCache()
+
+        _ = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 1)
+        {
+            Self.response(
+                """
+                [
+                  {"provider":"codex","account":"stable@example.com","call":1},
+                  {"provider":"antigravity","account":"ambient@example.com","call":1}
+                ]
+                """,
+                usageCacheKeys: ["account-1", nil])
+        }
+        try? await Task.sleep(nanoseconds: 100_000_000)
+
+        let timedOut = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0.05,
+            requestTimeout: 0.01)
+        {
+            try? await Task.sleep(nanoseconds: 200_000_000)
+            return Self.response("[]", usageCacheKeys: [])
+        }
+        #expect(timedOut.status == .gatewayTimeout)
+        #expect(!Self.bodyString(timedOut).contains("stable@example.com"))
+        #expect(!Self.bodyString(timedOut).contains("ambient@example.com"))
+    }
+
+    @Test
+    func `serve stale ttl is bounded and disabled without caching`() {
+        #expect(CodexBarCLI.serveStaleTTL(refreshInterval: 0) == 0)
+        #expect(CodexBarCLI.serveStaleTTL(refreshInterval: 1) == 300)
+        #expect(CodexBarCLI.serveStaleTTL(refreshInterval: 60) == 600)
+        #expect(CodexBarCLI.serveStaleTTL(refreshInterval: 1800) == 3600)
+        #expect(CodexBarCLI.serveStaleTTL(refreshInterval: 86401) == 3600)
+        #expect(CodexBarCLI.serveStaleTTL(refreshInterval: .infinity) == 3600)
+    }
+
+    @Test
+    func `serve cache prunes stale variants from old configurations`() async {
+        let cache = CLIServeResponseCache()
+        let startedAt = Date(timeIntervalSince1970: 1000)
+        let policy = CLIServeResponseCache.CachePolicy(
+            ttl: 0,
+            staleTTL: CLIServeResponseCache.maximumStaleTTL)
+
+        _ = await cache.responseOrStartFetch(for: "config:old", now: startedAt)
+        _ = await cache.completeFetch(
+            Self.response(#"{"status":"ok"}"#),
+            for: "config:old",
+            policy: policy,
+            now: startedAt,
+            shouldCache: true)
+
+        _ = await cache.responseOrStartFetch(for: "usage:old", now: startedAt)
+        _ = await cache.completeFetch(
+            Self.response(
+                #"[{"provider":"codex","call":1}]"#,
+                usageCacheKeys: ["account-1"]),
+            for: "usage:old",
+            policy: policy,
+            now: startedAt,
+            shouldCache: true)
+        #expect(await cache.cachedStaleVariantCount() == 2)
+
+        let expiredAt = startedAt.addingTimeInterval(CLIServeResponseCache.maximumStaleTTL + 1)
+        _ = await cache.responseOrStartFetch(for: "config:new", now: expiredAt)
+        #expect(await cache.cachedStaleVariantCount() == 0)
+        _ = await cache.completeFetch(
+            Self.response(#"{"status":"ok"}"#),
+            for: "config:new",
+            policy: policy,
+            now: expiredAt,
+            shouldCache: false)
+    }
+
+    @Test
+    func `serve helper idle window outlives the refresh cadence`() {
+        #expect(CodexBarCLI.serveCLISessionIdleWindow(refreshInterval: 0) == 180)
+        #expect(CodexBarCLI.serveCLISessionIdleWindow(refreshInterval: 60) == 180)
+        #expect(CodexBarCLI.serveCLISessionIdleWindow(refreshInterval: 300) == 360)
+    }
+
+    @Test
+    func `local HTTP server stops its accept loop`() async throws {
+        let listening = ServeListeningSignal()
+        let server = CLILocalHTTPServer(host: "127.0.0.1", port: 0) { _ in
+            Self.response(#"{"status":"ok"}"#)
+        }
+        let task = Task {
+            try await server.run {
+                listening.signal()
+            }
+        }
+
+        await listening.wait()
+        server.stop()
+        try await task.value
+    }
+
+    @Test
+    func `serve request timeout zero disables the deadline`() async {
+        let cache = CLIServeResponseCache()
+
+        let response = await CodexBarCLI.cachedServeResponse(
+            key: "usage:",
+            cache: cache,
+            refreshInterval: 0,
+            requestTimeout: 0)
+        {
+            try? await Task.sleep(nanoseconds: 80_000_000)
+            return Self.response("[{\"provider\":\"codex\",\"slow\":true}]")
+        }
+
+        #expect(response.status == .ok)
+        #expect(Self.bodyString(response).contains("\"slow\":true"))
+    }
+
+    private static func parsedRequest(host: String) throws -> CLILocalHTTPRequest {
+        let raw = "GET /usage?provider=claude HTTP/1.1\r\nHost: \(host)\r\n\r\n"
+        return try CLILocalHTTPRequest.parse(Data(raw.utf8)).get()
+    }
+
+    private static func expectParseFailure(raw: String, _ expected: CLILocalHTTPRequestParseError) {
+        switch CLILocalHTTPRequest.parse(Data(raw.utf8)) {
+        case .success:
+            Issue.record("Expected \(expected)")
+        case let .failure(error):
+            #expect(error == expected)
+        }
+    }
+
+    private static func response(
+        _ body: String,
+        status: CLIHTTPStatus = .ok,
+        usageCacheKeys: [String?]? = nil) -> CLILocalHTTPResponse
+    {
+        let data = Data(body.utf8)
+        return CLILocalHTTPResponse(
+            status: status,
+            body: data,
+            usageCacheKeys: usageCacheKeys ?? Self.syntheticUsageCacheKeys(data))
+    }
+
+    private static func bodyString(_ response: CLILocalHTTPResponse) -> String {
+        String(data: response.body, encoding: .utf8) ?? ""
+    }
+
+    private static func jsonRows(_ response: CLILocalHTTPResponse) throws -> [[String: Any]] {
+        try #require(JSONSerialization.jsonObject(with: response.body) as? [[String: Any]])
+    }
+
+    private static func row(
+        _ rows: [[String: Any]],
+        provider: String,
+        account: String) -> [String: Any]?
+    {
+        rows.first {
+            $0["provider"] as? String == provider
+                && $0["account"] as? String == account
+        }
+    }
+
+    private static func row(_ rows: [[String: Any]], provider: String) -> [String: Any]? {
+        rows.first { $0["provider"] as? String == provider }
+    }
+
+    private static func syntheticUsageCacheKeys(_ data: Data) -> [String?]? {
+        guard let rows = try? JSONSerialization.jsonObject(with: data) as? [[String: Any]] else { return nil }
+        return rows.map { row in
+            guard let provider = row["provider"] as? String else { return nil }
+            let account = row["account"] as? String ?? "default"
+            return "test:\(provider):\(account)"
+        }
+    }
+
+    private static func codexVisibleAccount(
+        id: String,
+        email: String = "user@example.com",
+        workspaceAccountID: String?,
+        authFingerprint: String?,
+        storedAccountID: UUID?) -> CodexVisibleAccount
+    {
+        CodexVisibleAccount(
+            id: id,
+            email: email,
+            workspaceAccountID: workspaceAccountID,
+            authFingerprint: authFingerprint,
+            storedAccountID: storedAccountID,
+            selectionSource: .liveSystem,
+            isActive: true,
+            isLive: true,
+            canReauthenticate: true,
+            canRemove: false)
+    }
+}
+
+private actor ServeTestCounter {
+    private var value = 0
+
+    func increment() -> Int {
+        self.value += 1
+        return self.value
+    }
+
+    func current() -> Int {
+        self.value
+    }
+}
+
+private final class ServeListeningSignal: @unchecked Sendable {
+    private let lock = NSLock()
+    private var continuation: CheckedContinuation<Void, Never>?
+    private var isSignaled = false
+
+    func signal() {
+        let continuation = self.lock.withLock {
+            self.isSignaled = true
+            defer { self.continuation = nil }
+            return self.continuation
+        }
+        continuation?.resume()
+    }
+
+    func wait() async {
+        await withCheckedContinuation { continuation in
+            let shouldResume = self.lock.withLock {
+                guard !self.isSignaled else { return true }
+                self.continuation = continuation
+                return false
+            }
+            if shouldResume {
+                continuation.resume()
+            }
+        }
+    }
+}
diff --git a/Tests/CodexBarTests/CLISnapshotTests.swift b/Tests/CodexBarTests/CLISnapshotTests.swift
index dd755b29f3..9967f7e15e 100644
--- a/Tests/CodexBarTests/CLISnapshotTests.swift
+++ b/Tests/CodexBarTests/CLISnapshotTests.swift
@@ -3,10 +3,58 @@ import Foundation
 import Testing
 @testable import CodexBarCLI
 
-@Suite
 struct CLISnapshotTests {
     @Test
-    func rendersTextSnapshotForCodex() {
+    func `renders Factory token rate billing with time window labels`() {
+        let snap = UsageSnapshot(
+            primary: .init(usedPercent: 12, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: .init(usedPercent: 25, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            tertiary: .init(usedPercent: 50, windowMinutes: 43200, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date(timeIntervalSince1970: 0))
+
+        let output = CLIRenderer.renderText(
+            provider: .factory,
+            snapshot: snap,
+            credits: nil,
+            context: RenderContext(
+                header: "Droid (factory)",
+                status: nil,
+                useColor: false,
+                resetStyle: .absolute))
+
+        #expect(output.contains("5-hour: 88% left"))
+        #expect(output.contains("Weekly: 75% left"))
+        #expect(output.contains("Monthly: 50% left"))
+        #expect(!output.contains("Standard:"))
+        #expect(!output.contains("Premium:"))
+    }
+
+    @Test
+    func `renders Factory legacy billing with pool labels`() {
+        let snap = UsageSnapshot(
+            primary: .init(usedPercent: 12, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: .init(usedPercent: 25, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            tertiary: nil,
+            updatedAt: Date(timeIntervalSince1970: 0))
+
+        let output = CLIRenderer.renderText(
+            provider: .factory,
+            snapshot: snap,
+            credits: nil,
+            context: RenderContext(
+                header: "Droid (factory)",
+                status: nil,
+                useColor: false,
+                resetStyle: .absolute))
+
+        #expect(output.contains("Standard: 88% left"))
+        #expect(output.contains("Premium: 75% left"))
+        #expect(!output.contains("5-hour:"))
+        #expect(!output.contains("Monthly:"))
+    }
+
+    @Test
+    func `renders text snapshot for codex`() {
         let identity = ProviderIdentitySnapshot(
             providerID: .codex,
             accountEmail: "user@example.com",
@@ -40,11 +88,110 @@ struct CLISnapshotTests {
         #expect(output.contains("Weekly: 75% left"))
         #expect(output.contains("Credits: 42"))
         #expect(output.contains("Account: user@example.com"))
-        #expect(output.contains("Plan: Pro"))
+        #expect(output.contains("Plan: Pro 20x"))
+    }
+
+    @Test
+    func `renders Codex limit reset credits`() {
+        let expiresAt = Date().addingTimeInterval(7200)
+        let resetCredits = CodexRateLimitResetCreditsSnapshot(
+            credits: [
+                CodexRateLimitResetCredit(
+                    id: "credit-1",
+                    resetType: "codex_rate_limits",
+                    status: .available,
+                    grantedAt: Date(timeIntervalSince1970: 0),
+                    expiresAt: expiresAt,
+                    redeemStartedAt: nil,
+                    redeemedAt: nil,
+                    title: nil,
+                    description: nil),
+            ],
+            availableCount: 1,
+            updatedAt: Date(timeIntervalSince1970: 0))
+        let snapshot = UsageSnapshot(
+            primary: .init(usedPercent: 10, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            tertiary: nil,
+            codexResetCredits: resetCredits,
+            updatedAt: Date(timeIntervalSince1970: 0))
+
+        let output = CLIRenderer.renderText(
+            provider: .codex,
+            snapshot: snapshot,
+            credits: nil,
+            context: RenderContext(
+                header: "Codex (oauth)",
+                status: nil,
+                useColor: false,
+                resetStyle: .countdown))
+
+        #expect(output.contains("Limit Reset Credits: 1 available"))
+        #expect(output.contains("Next reset credit expires"))
     }
 
     @Test
-    func rendersTextSnapshotForClaudeWithoutWeekly() {
+    func `renders Codex prolite plan with multiplier display name`() {
+        let identity = ProviderIdentitySnapshot(
+            providerID: .codex,
+            accountEmail: "user@example.com",
+            accountOrganization: nil,
+            loginMethod: "prolite")
+        let snap = UsageSnapshot(
+            primary: .init(usedPercent: 12, windowMinutes: 300, resetsAt: nil, resetDescription: "today at 3:00 PM"),
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: Date(timeIntervalSince1970: 0),
+            identity: identity)
+
+        let output = CLIRenderer.renderText(
+            provider: .codex,
+            snapshot: snap,
+            credits: nil,
+            context: RenderContext(
+                header: "Codex 1.2.3 (codex-cli)",
+                status: nil,
+                useColor: false,
+                resetStyle: .absolute))
+
+        #expect(output.contains("Plan: Pro 5x"))
+        #expect(!output.contains("Plan: Pro Lite"))
+        #expect(!output.contains("Plan: Prolite"))
+    }
+
+    @Test
+    func `renders Codex plan only limits as unavailable`() {
+        let identity = ProviderIdentitySnapshot(
+            providerID: .codex,
+            accountEmail: "user@example.com",
+            accountOrganization: nil,
+            loginMethod: "pro")
+        let snap = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: Date(timeIntervalSince1970: 0),
+            identity: identity)
+
+        let output = CLIRenderer.renderText(
+            provider: .codex,
+            snapshot: snap,
+            credits: nil,
+            context: RenderContext(
+                header: "Codex 1.2.3 (codex-cli)",
+                status: nil,
+                useColor: false,
+                resetStyle: .absolute))
+
+        #expect(output.contains("Limits: not available"))
+        #expect(output.contains("Account: user@example.com"))
+        #expect(output.contains("Plan: Pro 20x"))
+        #expect(!output.contains("Session:"))
+        #expect(!output.contains("Weekly:"))
+    }
+
+    @Test
+    func `renders text snapshot for claude without weekly`() {
         let snap = UsageSnapshot(
             primary: .init(usedPercent: 2, windowMinutes: nil, resetsAt: nil, resetDescription: "3pm (Europe/Vienna)"),
             secondary: nil,
@@ -66,7 +213,7 @@ struct CLISnapshotTests {
     }
 
     @Test
-    func rendersWarpUnlimitedAsDetailNotReset() {
+    func `renders warp unlimited as detail not reset`() {
         let meta = ProviderDescriptorRegistry.descriptor(for: .warp).metadata
         let snap = UsageSnapshot(
             primary: .init(usedPercent: 0, windowMinutes: nil, resetsAt: nil, resetDescription: "Unlimited"),
@@ -95,7 +242,7 @@ struct CLISnapshotTests {
     }
 
     @Test
-    func rendersWarpCreditsAsDetailAndResetAsDate() {
+    func `renders warp credits as detail and reset as date`() {
         let meta = ProviderDescriptorRegistry.descriptor(for: .warp).metadata
         let now = Date(timeIntervalSince1970: 0)
         let snap = UsageSnapshot(
@@ -130,7 +277,32 @@ struct CLISnapshotTests {
     }
 
     @Test
-    func rendersKiloPlanActivityAndFallbackNote() {
+    func `renders crof dollar balance as detail not reset`() {
+        let meta = ProviderDescriptorRegistry.descriptor(for: .crof).metadata
+        let snap = CrofUsageSnapshot(
+            credits: 9.9999,
+            requestsPlan: 1000,
+            usableRequests: 998,
+            updatedAt: Date(timeIntervalSince1970: 0)).toUsageSnapshot()
+
+        let output = CLIRenderer.renderText(
+            provider: .crof,
+            snapshot: snap,
+            credits: nil,
+            context: RenderContext(
+                header: "Crof",
+                status: nil,
+                useColor: false,
+                resetStyle: .countdown))
+
+        #expect(output.contains("\(meta.sessionLabel): 99% left"))
+        #expect(output.contains("\(meta.weeklyLabel): 100% left"))
+        #expect(output.contains("$9.99"))
+        #expect(!output.contains("Resets $9.99"))
+    }
+
+    @Test
+    func `renders kilo plan activity and fallback note`() {
         let now = Date(timeIntervalSince1970: 0)
         let identity = ProviderIdentitySnapshot(
             providerID: .kilo,
@@ -164,7 +336,7 @@ struct CLISnapshotTests {
     }
 
     @Test
-    func rendersKiloZeroTotalEdgeStateAsDetail() {
+    func `renders kilo zero total edge state as detail`() {
         let now = Date(timeIntervalSince1970: 0)
         let snap = KiloUsageSnapshot(
             creditsUsed: 0,
@@ -191,7 +363,7 @@ struct CLISnapshotTests {
     }
 
     @Test
-    func rendersKiloAutoTopUpOnlyAsActivityWithoutPlan() {
+    func `renders kilo auto top up only as activity without plan`() {
         let now = Date(timeIntervalSince1970: 0)
         let identity = ProviderIdentitySnapshot(
             providerID: .kilo,
@@ -220,7 +392,7 @@ struct CLISnapshotTests {
     }
 
     @Test
-    func rendersPaceLineWhenWeeklyHasReset() {
+    func `renders pace line when weekly has reset`() {
         let now = Date()
         let snap = UsageSnapshot(
             primary: nil,
@@ -246,7 +418,175 @@ struct CLISnapshotTests {
     }
 
     @Test
-    func rendersJSONPayload() throws {
+    func `renders Ollama weekly pace line when weekly window has reset`() {
+        let now = Date()
+        let snap = UsageSnapshot(
+            primary: .init(
+                usedPercent: 0,
+                windowMinutes: nil,
+                resetsAt: now.addingTimeInterval(4 * 3600),
+                resetDescription: nil),
+            secondary: .init(
+                usedPercent: 23,
+                windowMinutes: 10080,
+                resetsAt: now.addingTimeInterval(5 * 24 * 3600),
+                resetDescription: nil),
+            tertiary: nil,
+            updatedAt: now)
+
+        let output = CLIRenderer.renderText(
+            provider: .ollama,
+            snapshot: snap,
+            credits: nil,
+            context: RenderContext(
+                header: "Ollama (web)",
+                status: nil,
+                useColor: false,
+                resetStyle: .countdown))
+
+        #expect(output.contains("Weekly: 77% left"))
+        #expect(output.contains("Pace: 6% in reserve | Expected 29% used | Lasts until reset"))
+    }
+
+    @Test
+    func `hides Ollama weekly pace when weekly duration is missing`() {
+        let now = Date()
+        let snap = UsageSnapshot(
+            primary: nil,
+            secondary: .init(
+                usedPercent: 23,
+                windowMinutes: nil,
+                resetsAt: now.addingTimeInterval(5 * 24 * 3600),
+                resetDescription: nil),
+            tertiary: nil,
+            updatedAt: now)
+
+        let output = CLIRenderer.renderText(
+            provider: .ollama,
+            snapshot: snap,
+            credits: nil,
+            context: RenderContext(
+                header: "Ollama (web)",
+                status: nil,
+                useColor: false,
+                resetStyle: .countdown))
+
+        #expect(output.contains("Weekly: 77% left"))
+        #expect(!output.contains("Pace:"))
+    }
+
+    @Test
+    func `renders session pace line when session window has reset`() {
+        let now = Date()
+        let snap = UsageSnapshot(
+            primary: .init(
+                usedPercent: 20,
+                windowMinutes: 300,
+                resetsAt: now.addingTimeInterval(2 * 60 * 60),
+                resetDescription: nil),
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: now)
+
+        let output = CLIRenderer.renderText(
+            provider: .codex,
+            snapshot: snap,
+            credits: nil,
+            context: RenderContext(
+                header: "Codex 0.0.0 (codex-cli)",
+                status: nil,
+                useColor: false,
+                resetStyle: .countdown))
+
+        #expect(output.contains("Session: 80% left"))
+        // 2h remaining of a 5h window => 3h elapsed => 60% expected.
+        #expect(output.contains("Pace: 40% in reserve | Expected 60% used"))
+    }
+
+    @Test
+    func `renders Claude session pace using five hour default window`() {
+        let now = Date()
+        let snap = UsageSnapshot(
+            primary: .init(
+                usedPercent: 20,
+                windowMinutes: nil,
+                resetsAt: now.addingTimeInterval(2 * 60 * 60),
+                resetDescription: nil),
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: now)
+
+        let output = CLIRenderer.renderText(
+            provider: .claude,
+            snapshot: snap,
+            credits: nil,
+            context: RenderContext(
+                header: "Claude Code 2.0.69 (claude)",
+                status: nil,
+                useColor: false,
+                resetStyle: .countdown))
+
+        // windowMinutes is nil, so the 5-hour (300 minute) session default must drive the pace.
+        #expect(output.contains("Pace: 40% in reserve | Expected 60% used"))
+    }
+
+    @Test
+    func `renders session pace deficit with run out estimate`() {
+        let now = Date()
+        let snap = UsageSnapshot(
+            primary: .init(
+                usedPercent: 50,
+                windowMinutes: 300,
+                resetsAt: now.addingTimeInterval(4 * 60 * 60),
+                resetDescription: nil),
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: now)
+
+        let output = CLIRenderer.renderText(
+            provider: .codex,
+            snapshot: snap,
+            credits: nil,
+            context: RenderContext(
+                header: "Codex 0.0.0 (codex-cli)",
+                status: nil,
+                useColor: false,
+                resetStyle: .countdown))
+
+        // 1h elapsed of a 5h window => 20% expected vs 50% used => burning ahead of pace.
+        // Session mirrors the GUI's "Projected empty" wording (weekly uses "Runs out").
+        #expect(output.contains("Pace: 30% in deficit | Expected 20% used | Projected empty in"))
+        #expect(!output.contains("Runs out"))
+    }
+
+    @Test
+    func `hides session pace for unsupported provider`() {
+        let now = Date()
+        let snap = UsageSnapshot(
+            primary: .init(
+                usedPercent: 20,
+                windowMinutes: 300,
+                resetsAt: now.addingTimeInterval(2 * 60 * 60),
+                resetDescription: nil),
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: now)
+
+        let output = CLIRenderer.renderText(
+            provider: .zai,
+            snapshot: snap,
+            credits: nil,
+            context: RenderContext(
+                header: "z.ai 0.0.0 (zai)",
+                status: nil,
+                useColor: false,
+                resetStyle: .countdown))
+
+        #expect(!output.contains("Pace:"))
+    }
+
+    @Test
+    func `renders JSON payload`() throws {
         let snap = UsageSnapshot(
             primary: .init(usedPercent: 50, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
             secondary: .init(usedPercent: 10, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
@@ -286,7 +626,126 @@ struct CLISnapshotTests {
     }
 
     @Test
-    func encodesJSONWithSecondaryNullWhenMissing() throws {
+    func `json payload includes session and weekly pace with distinct wording`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let snap = UsageSnapshot(
+            // 1h elapsed of a 5h window => 20% expected vs 50% used => deficit, runs out in 1h.
+            primary: .init(
+                usedPercent: 50,
+                windowMinutes: 300,
+                resetsAt: now.addingTimeInterval(4 * 60 * 60),
+                resetDescription: nil),
+            // 5d elapsed of a 7d window => ~71% expected vs 90% used => deficit, runs out before reset.
+            secondary: .init(
+                usedPercent: 90,
+                windowMinutes: 10080,
+                resetsAt: now.addingTimeInterval(2 * 24 * 60 * 60),
+                resetDescription: nil),
+            tertiary: nil,
+            updatedAt: now)
+
+        let payload = ProviderPayload(
+            provider: .codex,
+            account: nil,
+            version: "1.2.3",
+            source: "codex-cli",
+            status: nil,
+            usage: snap,
+            credits: nil,
+            antigravityPlanInfo: nil,
+            openaiDashboard: nil,
+            error: nil,
+            pace: CLIRenderer.providerPacePayload(provider: .codex, snapshot: snap, now: now))
+
+        let data = try JSONEncoder().encode(payload)
+        let root = try #require(try JSONSerialization.jsonObject(with: data) as? [String: Any])
+        let pace = try #require(root["pace"] as? [String: Any])
+
+        let primary = try #require(pace["primary"] as? [String: Any])
+        #expect(primary["stage"] as? String == "farAhead")
+        #expect(primary["expectedUsedPercent"] as? Double == 20)
+        #expect(primary["actualUsedPercent"] as? Double == 50)
+        #expect(primary["deltaPercent"] as? Double == 30)
+        #expect(primary["willLastToReset"] as? Bool == false)
+        #expect(primary["etaSeconds"] as? Double == 3600)
+        #expect((primary["summary"] as? String)?
+            .contains("30% in deficit | Expected 20% used | Projected empty in") == true)
+        // CLI never sets a run-out probability, so the key is omitted (consistent with other nil fields).
+        #expect(primary["runOutProbability"] == nil)
+
+        let secondary = try #require(pace["secondary"] as? [String: Any])
+        #expect(secondary["stage"] as? String == "farAhead")
+        #expect((secondary["summary"] as? String)?.contains("Runs out in") == true)
+        #expect((secondary["summary"] as? String)?.contains("Projected empty") == false)
+    }
+
+    @Test
+    func `json omits pace when not applicable`() throws {
+        let now = Date()
+        let snap = UsageSnapshot(
+            primary: .init(
+                usedPercent: 20,
+                windowMinutes: 300,
+                resetsAt: now.addingTimeInterval(2 * 60 * 60),
+                resetDescription: nil),
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: now)
+
+        // z.ai is not a session/weekly pace provider, so no pace should be emitted.
+        let payload = ProviderPayload(
+            provider: .zai,
+            account: nil,
+            version: nil,
+            source: "zai",
+            status: nil,
+            usage: snap,
+            credits: nil,
+            antigravityPlanInfo: nil,
+            openaiDashboard: nil,
+            error: nil,
+            pace: CLIRenderer.providerPacePayload(provider: .zai, snapshot: snap, now: now))
+
+        let data = try JSONEncoder().encode(payload)
+        let json = try #require(String(data: data, encoding: .utf8))
+        #expect(!json.contains("\"pace\""))
+    }
+
+    @Test
+    func `json includes only session pace when weekly window missing`() throws {
+        let now = Date()
+        let snap = UsageSnapshot(
+            primary: .init(
+                usedPercent: 50,
+                windowMinutes: 300,
+                resetsAt: now.addingTimeInterval(4 * 60 * 60),
+                resetDescription: nil),
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: now)
+
+        let payload = ProviderPayload(
+            provider: .codex,
+            account: nil,
+            version: nil,
+            source: "codex-cli",
+            status: nil,
+            usage: snap,
+            credits: nil,
+            antigravityPlanInfo: nil,
+            openaiDashboard: nil,
+            error: nil,
+            pace: CLIRenderer.providerPacePayload(provider: .codex, snapshot: snap, now: now))
+
+        let data = try JSONEncoder().encode(payload)
+        let root = try #require(try JSONSerialization.jsonObject(with: data) as? [String: Any])
+        let pace = try #require(root["pace"] as? [String: Any])
+        #expect(pace["primary"] as? [String: Any] != nil)
+        #expect(pace["secondary"] == nil)
+    }
+
+    @Test
+    func `encodes JSON with secondary null when missing`() throws {
         let snap = UsageSnapshot(
             primary: .init(usedPercent: 0, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
             secondary: nil,
@@ -305,21 +764,21 @@ struct CLISnapshotTests {
     }
 
     @Test
-    func parsesOutputFormat() {
+    func `parses output format`() {
         #expect(OutputFormat(argument: "json") == .json)
         #expect(OutputFormat(argument: "TEXT") == .text)
         #expect(OutputFormat(argument: "invalid") == nil)
     }
 
     @Test
-    func defaultsToUsageWhenNoCommandProvided() {
+    func `defaults to usage when no command provided`() {
         #expect(CodexBarCLI.effectiveArgv([]) == ["usage"])
         #expect(CodexBarCLI.effectiveArgv(["--format", "json"]).first == "usage")
         #expect(CodexBarCLI.effectiveArgv(["usage", "--format", "json"]).first == "usage")
     }
 
     @Test
-    func statusLineIsLastAndColoredWhenTTY() {
+    func `status line is last and colored when TTY`() {
         let identity = ProviderIdentitySnapshot(
             providerID: .claude,
             accountEmail: nil,
@@ -352,7 +811,7 @@ struct CLISnapshotTests {
     }
 
     @Test
-    func outputHasAnsiWhenTTYEvenWithoutStatus() {
+    func `output has ansi when TTY even without status`() {
         let snap = UsageSnapshot(
             primary: .init(usedPercent: 1, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
             secondary: nil,
@@ -373,7 +832,7 @@ struct CLISnapshotTests {
     }
 
     @Test
-    func ttyOutputColorsHeaderAndUsage() {
+    func `tty output colors header and usage`() {
         let snap = UsageSnapshot(
             primary: .init(usedPercent: 95, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
             secondary: .init(usedPercent: 80, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
@@ -396,7 +855,7 @@ struct CLISnapshotTests {
     }
 
     @Test
-    func statusLineIsPlainWhenNoTTY() {
+    func `status line is plain when no TTY`() {
         let identity = ProviderIdentitySnapshot(
             providerID: .codex,
             accountEmail: nil,
@@ -426,4 +885,27 @@ struct CLISnapshotTests {
         #expect(!output.contains("\u{001B}["))
         #expect(output.contains("Status: Operational – Operational"))
     }
+
+    @Test
+    func `renders 5-hour tertiary row for zai`() {
+        let snap = UsageSnapshot(
+            primary: .init(usedPercent: 9, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            secondary: .init(usedPercent: 50, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            tertiary: .init(usedPercent: 25, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date(timeIntervalSince1970: 0))
+
+        let output = CLIRenderer.renderText(
+            provider: .zai,
+            snapshot: snap,
+            credits: nil,
+            context: RenderContext(
+                header: "z.ai 0.0.0 (zai)",
+                status: nil,
+                useColor: false,
+                resetStyle: .absolute))
+
+        #expect(output.contains("5-hour:"))
+        #expect(output.contains("Tokens:"))
+        #expect(output.contains("MCP:"))
+    }
 }
diff --git a/Tests/CodexBarTests/CLIWebFallbackTests.swift b/Tests/CodexBarTests/CLIWebFallbackTests.swift
index 8ebc1cbb17..4788f85810 100644
--- a/Tests/CodexBarTests/CLIWebFallbackTests.swift
+++ b/Tests/CodexBarTests/CLIWebFallbackTests.swift
@@ -2,7 +2,6 @@ import Testing
 @testable import CodexBarCLI
 @testable import CodexBarCore
 
-@Suite
 struct CLIWebFallbackTests {
     private func makeContext(
         runtime: ProviderRuntime = .cli,
@@ -34,7 +33,7 @@ struct CLIWebFallbackTests {
     }
 
     @Test
-    func codexFallsBackWhenCookiesMissing() {
+    func `codex falls back when cookies missing`() {
         let context = self.makeContext()
         let strategy = CodexWebDashboardStrategy()
         #expect(strategy.shouldFallback(
@@ -55,7 +54,7 @@ struct CLIWebFallbackTests {
     }
 
     @Test
-    func codexFallsBackForDashboardDataErrorsInAuto() {
+    func `codex falls back for dashboard data errors in auto`() {
         let context = self.makeContext()
         let strategy = CodexWebDashboardStrategy()
         #expect(strategy.shouldFallback(
@@ -64,7 +63,100 @@ struct CLIWebFallbackTests {
     }
 
     @Test
-    func claudeFallsBackWhenNoSessionKey() {
+    func `codex retries fresh browser import for missing usage and no data`() {
+        #expect(CodexWebDashboardStrategy.shouldRetryWithFreshBrowserImport(
+            after: OpenAIWebCodexError.missingUsage))
+        #expect(CodexWebDashboardStrategy.shouldRetryWithFreshBrowserImport(
+            after: OpenAIDashboardFetcher.FetchError.noDashboardData(body: "missing")))
+        #expect(!CodexWebDashboardStrategy.shouldRetryWithFreshBrowserImport(
+            after: OpenAIDashboardFetcher.FetchError.loginRequired))
+        #expect(!CodexWebDashboardStrategy.shouldRetryWithFreshBrowserImport(
+            after: OpenAIWebCodexError.timedOut(seconds: 30)))
+    }
+
+    @Test
+    func `codex shared deadline timeout has useful error`() {
+        let error = OpenAIWebCodexError.timedOut(seconds: 30)
+        #expect(error.localizedDescription == "OpenAI web dashboard fetch timed out after 30 seconds.")
+    }
+
+    @Test
+    func `codex display only falls back in auto`() {
+        let strategy = CodexWebDashboardStrategy()
+        let decision = self.makeCodexDisplayOnlyDecision()
+
+        #expect(strategy.shouldFallback(
+            on: CodexDashboardPolicyError.displayOnly(decision),
+            context: self.makeContext(sourceMode: .auto)))
+    }
+
+    @Test
+    func `codex display only does not fall back in explicit web`() {
+        let strategy = CodexWebDashboardStrategy()
+        let decision = self.makeCodexDisplayOnlyDecision()
+
+        #expect(!strategy.shouldFallback(
+            on: CodexDashboardPolicyError.displayOnly(decision),
+            context: self.makeContext(sourceMode: .web)))
+    }
+
+    @Test
+    func `codex web strategy is unavailable when managed account store is unreadable`() async {
+        let context = self.makeContext(settings: ProviderSettingsSnapshot.make(
+            codex: .init(
+                usageDataSource: .auto,
+                cookieSource: .auto,
+                manualCookieHeader: nil,
+                managedAccountStoreUnreadable: true)))
+        let strategy = CodexWebDashboardStrategy()
+        let available = await strategy.isAvailable(context)
+
+        #expect(!available)
+    }
+
+    @Test
+    func `codex web strategy is unavailable when selected managed target is unavailable`() async {
+        let context = self.makeContext(settings: ProviderSettingsSnapshot.make(
+            codex: .init(
+                usageDataSource: .auto,
+                cookieSource: .auto,
+                manualCookieHeader: nil,
+                managedAccountTargetUnavailable: true)))
+        let strategy = CodexWebDashboardStrategy()
+        let available = await strategy.isAvailable(context)
+
+        #expect(!available)
+    }
+
+    @Test
+    func `codex web strategy fails closed when profile target is unavailable`() async {
+        let settings = ProviderSettingsSnapshot.make(
+            codex: .init(
+                usageDataSource: .auto,
+                cookieSource: .auto,
+                manualCookieHeader: nil,
+                profileAccountTargetUnavailable: true))
+        let strategy = CodexWebDashboardStrategy()
+
+        let autoContext = self.makeContext(sourceMode: .auto, settings: settings)
+        let autoAvailable = await strategy.isAvailable(autoContext)
+        #expect(!autoAvailable)
+
+        let explicitWebContext = self.makeContext(sourceMode: .web, settings: settings)
+        let explicitWebAvailable = await strategy.isAvailable(explicitWebContext)
+        #expect(explicitWebAvailable)
+        do {
+            _ = try await strategy.fetch(explicitWebContext)
+            Issue.record("Expected unavailable profile target to require login")
+        } catch OpenAIDashboardFetcher.FetchError.loginRequired {
+            // Expected before browser import can accept an arbitrary account.
+        } catch {
+            Issue.record("Unexpected error: \(error)")
+        }
+    }
+
+    @Test
+    func `claude falls back when no session key`() {
         let context = self.makeContext()
         let strategy = ClaudeWebFetchStrategy(browserDetection: BrowserDetection(cacheTTL: 0))
         #expect(strategy.shouldFallback(on: ClaudeWebAPIFetcher.FetchError.noSessionKeyFound, context: context))
@@ -72,7 +164,7 @@ struct CLIWebFallbackTests {
     }
 
     @Test
-    func claudeCLIFallbackIsEnabledOnlyForAppAuto() {
+    func `claude CLI fallback is enabled only for app auto`() {
         let strategy = ClaudeCLIFetchStrategy(
             useWebExtras: false,
             manualCookieHeader: nil,
@@ -94,10 +186,32 @@ struct CLIWebFallbackTests {
     }
 
     @Test
-    func claudeWebFallbackIsDisabledForAppAuto() {
+    func `claude web fallback is disabled for app auto`() {
         let strategy = ClaudeWebFetchStrategy(browserDetection: BrowserDetection(cacheTTL: 0))
         let error = ClaudeWebAPIFetcher.FetchError.unauthorized
         #expect(strategy.shouldFallback(on: error, context: self.makeContext(runtime: .cli, sourceMode: .auto)))
         #expect(!strategy.shouldFallback(on: error, context: self.makeContext(runtime: .app, sourceMode: .auto)))
     }
+
+    private func makeCodexDisplayOnlyDecision() -> CodexDashboardAuthorityDecision {
+        CodexDashboardAuthority.evaluate(
+            CodexDashboardAuthorityInput(
+                sourceKind: .liveWeb,
+                proof: CodexDashboardOwnershipProofContext(
+                    currentIdentity: .emailOnly(normalizedEmail: "shared@example.com"),
+                    expectedScopedEmail: nil,
+                    trustedCurrentUsageEmail: nil,
+                    dashboardSignedInEmail: "shared@example.com",
+                    knownOwners: [
+                        CodexDashboardKnownOwnerCandidate(
+                            identity: .providerAccount(id: "acct-alpha"),
+                            normalizedEmail: "shared@example.com"),
+                        CodexDashboardKnownOwnerCandidate(
+                            identity: .providerAccount(id: "acct-beta"),
+                            normalizedEmail: "shared@example.com"),
+                    ]),
+                routing: CodexDashboardRoutingHints(
+                    targetEmail: "shared@example.com",
+                    lastKnownDashboardRoutingEmail: nil)))
+    }
 }
diff --git a/Tests/CodexBarTests/ChartBarHoverSelectionTests.swift b/Tests/CodexBarTests/ChartBarHoverSelectionTests.swift
new file mode 100644
index 0000000000..517a496084
--- /dev/null
+++ b/Tests/CodexBarTests/ChartBarHoverSelectionTests.swift
@@ -0,0 +1,49 @@
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct ChartBarHoverSelectionTests {
+    @Test
+    func `single selectable bar accepts the full plot`() {
+        #expect(ChartBarHoverSelection.accepts(
+            distanceFromBarCenter: 120,
+            barHalfWidth: 5,
+            selectableCount: 1))
+    }
+
+    @Test
+    func `multiple selectable bars accept only the bar body`() {
+        #expect(ChartBarHoverSelection.accepts(
+            distanceFromBarCenter: 5,
+            barHalfWidth: 5,
+            selectableCount: 2))
+        #expect(!ChartBarHoverSelection.accepts(
+            distanceFromBarCenter: 5.1,
+            barHalfWidth: 5,
+            selectableCount: 2))
+    }
+
+    @Test
+    func `calendar day spacing follows daylight saving transitions`() throws {
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = try #require(TimeZone(identifier: "America/Los_Angeles"))
+        let springDate = try #require(calendar.date(from: DateComponents(
+            year: 2026,
+            month: 3,
+            day: 7,
+            hour: 12)))
+        let fallDate = try #require(calendar.date(from: DateComponents(
+            year: 2026,
+            month: 10,
+            day: 31,
+            hour: 12)))
+
+        let springNextDay = ChartBarHoverSelection.nextCalendarDay(after: springDate, calendar: calendar)
+        let fallNextDay = ChartBarHoverSelection.nextCalendarDay(after: fallDate, calendar: calendar)
+
+        #expect(calendar.component(.day, from: springNextDay) == 8)
+        #expect(springNextDay.timeIntervalSince(springDate) == 23 * 60 * 60)
+        #expect(calendar.component(.day, from: fallNextDay) == 1)
+        #expect(fallNextDay.timeIntervalSince(fallDate) == 25 * 60 * 60)
+    }
+}
diff --git a/Tests/CodexBarTests/ChutesProviderTests.swift b/Tests/CodexBarTests/ChutesProviderTests.swift
new file mode 100644
index 0000000000..07f00d1cb9
--- /dev/null
+++ b/Tests/CodexBarTests/ChutesProviderTests.swift
@@ -0,0 +1,355 @@
+import Foundation
+import Testing
+@testable import CodexBar
+@testable import CodexBarCore
+
+struct ChutesProviderTests {
+    @Test
+    func `settings reader trims quoted API key`() {
+        let token = ChutesSettingsReader.apiKey(environment: [
+            ChutesSettingsReader.apiKeyEnvironmentKey: " 'chutes-test' ",
+        ])
+
+        #expect(token == "chutes-test")
+    }
+
+    @Test
+    func `config API key projects into Chutes environment`() {
+        let config = ProviderConfig(id: .chutes, apiKey: "chutes-config-token")
+        let env = ProviderConfigEnvironment.applyAPIKeyOverride(
+            base: [:],
+            provider: .chutes,
+            config: config)
+
+        #expect(env[ChutesSettingsReader.apiKeyEnvironmentKey] == "chutes-config-token")
+        #expect(ChutesSettingsReader.apiKey(environment: env) == "chutes-config-token")
+        #expect(ProviderConfigEnvironment.supportsAPIKeyOverride(for: .chutes))
+    }
+
+    @Test
+    func `fetch usage maps active subscription monthly and rolling windows`() async throws {
+        let now = Date(timeIntervalSince1970: 1_800_000_000)
+        let rollingReset = try Self.date("2026-06-13T18:00:00Z")
+        let monthlyReset = try Self.date("2026-07-01T00:00:00Z")
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            #expect(url.path == "/users/me/subscription_usage")
+            #expect(request.httpMethod == "GET")
+            #expect(request.value(forHTTPHeaderField: "Authorization") == "Bearer chutes-key")
+            #expect(request.value(forHTTPHeaderField: "Accept") == "application/json")
+            #expect(request.timeoutInterval == 15)
+
+            let body = #"""
+            {
+              "subscription": {
+                "active": true,
+                "plan_name": "Pro",
+                "current_period_end": "2026-07-01T00:00:00Z"
+              },
+              "monthly": {
+                "used": 250,
+                "limit": 1000,
+                "resets_at": "2026-07-01T00:00:00Z",
+                "unit": "credits"
+              },
+              "rolling_window": {
+                "requests": 40,
+                "limit": 100,
+                "window_minutes": 240,
+                "reset_at": "2026-06-13T18:00:00Z",
+                "unit": "requests"
+              }
+            }
+            """#
+            return Self.makeResponse(url: url, body: body)
+        }
+
+        let snapshot = try await ChutesUsageFetcher.fetchUsage(
+            apiKey: " chutes-key ",
+            environment: [ChutesSettingsReader.apiURLEnvironmentKey: "https://chutes.test"],
+            transport: transport,
+            now: now)
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.primary?.usedPercent == 40)
+        #expect(usage.primary?.windowMinutes == 240)
+        #expect(usage.primary?.resetsAt == rollingReset)
+        #expect(usage.primary?.resetDescription == "40/100 requests")
+        #expect(usage.secondary?.usedPercent == 25)
+        #expect(usage.secondary?.resetsAt == monthlyReset)
+        #expect(usage.secondary?.resetDescription == "250/1000 credits")
+        #expect(usage.subscriptionRenewsAt == monthlyReset)
+        #expect(usage.loginMethod(for: .chutes) == "Pro")
+
+        let requests = await transport.requests()
+        #expect(requests.count == 1)
+    }
+
+    @Test
+    func `no active subscription falls back to quotas endpoint`() async throws {
+        let now = Date(timeIntervalSince1970: 1_800_000_000)
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            switch url.path {
+            case "/users/me/subscription_usage":
+                return Self.makeResponse(url: url, body: #"""
+                {
+                  "subscription": {
+                    "active": false,
+                    "status": "free"
+                  }
+                }
+                """#)
+            case "/users/me/quotas":
+                return Self.makeResponse(url: url, body: #"""
+                [
+                  {
+                    "chute_id": "0",
+                    "is_default": true,
+                    "quota": 100
+                  }
+                ]
+                """#)
+            case "/users/me/quota_usage/0":
+                return Self.makeResponse(url: url, body: #"""
+                {
+                  "quota": 100,
+                  "used": 10
+                }
+                """#)
+            default:
+                throw URLError(.badURL)
+            }
+        }
+
+        let snapshot = try await ChutesUsageFetcher.fetchUsage(
+            apiKey: "chutes-key",
+            environment: [ChutesSettingsReader.apiURLEnvironmentKey: "https://chutes.test"],
+            transport: transport,
+            now: now)
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.primary?.usedPercent == 10)
+        #expect(usage.primary?.resetDescription == "10/100 credits")
+        #expect(usage.secondary == nil)
+        #expect(usage.loginMethod(for: .chutes) == "No active subscription")
+
+        let requests = await transport.requests()
+        let paths = requests.compactMap { $0.url?.path }
+        #expect(paths == [
+            "/users/me/subscription_usage",
+            "/users/me/quotas",
+            "/users/me/quota_usage/0",
+        ])
+    }
+
+    @Test
+    func `wrapped quota list fetches per quota usage`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            switch url.path {
+            case "/users/me/subscription_usage":
+                return Self.makeResponse(url: url, body: #"{"subscription":{"active":false}}"#)
+            case "/users/me/quotas":
+                return Self.makeResponse(url: url, body: #"""
+                {
+                  "data": [
+                    {
+                      "chute_id": "wrapped",
+                      "quota": 200
+                    }
+                  ]
+                }
+                """#)
+            case "/users/me/quota_usage/wrapped":
+                return Self.makeResponse(url: url, body: #"{"quota":200,"used":50}"#)
+            default:
+                throw URLError(.badURL)
+            }
+        }
+
+        let snapshot = try await ChutesUsageFetcher.fetchUsage(
+            apiKey: "chutes-key",
+            environment: [ChutesSettingsReader.apiURLEnvironmentKey: "https://chutes.test"],
+            transport: transport)
+
+        #expect(snapshot.toUsageSnapshot().primary?.usedPercent == 25)
+        let requests = await transport.requests()
+        #expect(requests.compactMap { $0.url?.path } == [
+            "/users/me/subscription_usage",
+            "/users/me/quotas",
+            "/users/me/quota_usage/wrapped",
+        ])
+    }
+
+    @Test
+    func `partial subscription usage fills missing rolling window from quotas`() async throws {
+        let now = Date(timeIntervalSince1970: 1_800_000_000)
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            switch url.path {
+            case "/users/me/subscription_usage":
+                return Self.makeResponse(url: url, body: #"""
+                {
+                  "subscription": {
+                    "active": true,
+                    "plan_name": "Pro",
+                    "current_period_end": "2026-07-01T00:00:00Z"
+                  },
+                  "monthly": {
+                    "used": 250,
+                    "limit": 1000,
+                    "unit": "credits"
+                  }
+                }
+                """#)
+            case "/users/me/quotas":
+                return Self.makeResponse(url: url, body: #"""
+                {
+                  "rolling_window": {
+                    "requests": 40,
+                    "limit": 100,
+                    "window_minutes": 240,
+                    "unit": "requests"
+                  }
+                }
+                """#)
+            default:
+                throw URLError(.badURL)
+            }
+        }
+
+        let snapshot = try await ChutesUsageFetcher.fetchUsage(
+            apiKey: "chutes-key",
+            environment: [ChutesSettingsReader.apiURLEnvironmentKey: "https://chutes.test"],
+            transport: transport,
+            now: now)
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.primary?.usedPercent == 40)
+        #expect(usage.primary?.windowMinutes == 240)
+        #expect(usage.primary?.resetDescription == "40/100 requests")
+        #expect(usage.secondary?.usedPercent == 25)
+        #expect(usage.secondary?.resetDescription == "250/1000 credits")
+        #expect(usage.loginMethod(for: .chutes) == "Pro")
+
+        let requests = await transport.requests()
+        let paths = requests.compactMap { $0.url?.path }
+        #expect(paths == ["/users/me/subscription_usage", "/users/me/quotas"])
+    }
+
+    @Test
+    func `missing usage fields returns no data snapshot without decode failure`() throws {
+        let data = Data(#"{"subscription":{"active":true},"unexpected":{"nested":true}}"#.utf8)
+        let snapshot = try ChutesUsageParser.parse(data: data, now: Date(timeIntervalSince1970: 123))
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(!snapshot.hasUsageData)
+        #expect(usage.primary == nil)
+        #expect(usage.secondary == nil)
+        #expect(usage.loginMethod(for: .chutes) == nil)
+    }
+
+    @Test
+    func `identical usage values keep distinct quota windows`() throws {
+        let data = Data(#"""
+        {
+          "quotas": [
+            {
+              "used": 0,
+              "limit": 100,
+              "window_minutes": 240
+            },
+            {
+              "used": 0,
+              "limit": 100,
+              "window_minutes": 43200
+            }
+          ]
+        }
+        """#.utf8)
+
+        let snapshot = try ChutesUsageParser.parse(data: data, now: Date(timeIntervalSince1970: 123))
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.primary?.usedPercent == 0)
+        #expect(usage.primary?.windowMinutes == 240)
+        #expect(usage.secondary?.usedPercent == 0)
+        #expect(usage.secondary?.windowMinutes == 43200)
+    }
+
+    @Test
+    func `exact percent value of one stays one percent`() throws {
+        let usedData = Data(#"""
+        {
+          "rolling_window": {
+            "usage_percent": 1
+          }
+        }
+        """#.utf8)
+        let remainingData = Data(#"""
+        {
+          "rolling_window": {
+            "percent_remaining": 1
+          }
+        }
+        """#.utf8)
+
+        let usedSnapshot = try ChutesUsageParser.parse(
+            data: usedData,
+            now: Date(timeIntervalSince1970: 123))
+        let remainingSnapshot = try ChutesUsageParser.parse(
+            data: remainingData,
+            now: Date(timeIntervalSince1970: 123))
+
+        #expect(usedSnapshot.toUsageSnapshot().primary?.usedPercent == 1)
+        #expect(remainingSnapshot.toUsageSnapshot().primary?.usedPercent == 99)
+    }
+
+    @Test
+    func `auth failure surfaces invalid credentials`() async {
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            return Self.makeResponse(url: url, body: #"{"detail":"unauthorized"}"#, statusCode: 401)
+        }
+
+        await #expect {
+            _ = try await ChutesUsageFetcher.fetchUsage(
+                apiKey: "bad-key",
+                environment: [ChutesSettingsReader.apiURLEnvironmentKey: "https://chutes.test"],
+                transport: transport)
+        } throws: { error in
+            guard case ChutesUsageError.invalidCredentials = error else { return false }
+            return true
+        }
+    }
+
+    @Test
+    func `descriptor and app implementation registry include Chutes`() throws {
+        let descriptor = ProviderDescriptorRegistry.descriptor(for: .chutes)
+        #expect(descriptor.metadata.displayName == "Chutes")
+        #expect(ProviderDescriptorRegistry.all.contains { $0.id == .chutes })
+
+        let implementation = try #require(ProviderImplementationRegistry.implementation(for: .chutes))
+        #expect(implementation is ChutesProviderImplementation)
+    }
+
+    private static func makeResponse(
+        url: URL,
+        body: String,
+        statusCode: Int = 200) -> (Data, URLResponse)
+    {
+        let response = HTTPURLResponse(
+            url: url,
+            statusCode: statusCode,
+            httpVersion: "HTTP/1.1",
+            headerFields: ["Content-Type": "application/json"])!
+        return (Data(body.utf8), response)
+    }
+
+    private static func date(_ text: String) throws -> Date {
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime]
+        return try #require(formatter.date(from: text))
+    }
+}
diff --git a/Tests/CodexBarTests/ClaudeAdminAPIUsageTests.swift b/Tests/CodexBarTests/ClaudeAdminAPIUsageTests.swift
new file mode 100644
index 0000000000..6a63827e99
--- /dev/null
+++ b/Tests/CodexBarTests/ClaudeAdminAPIUsageTests.swift
@@ -0,0 +1,196 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct ClaudeAdminAPIUsageTests {
+    private func makeContext(
+        apiKey: String = "sk-ant-admin-test",
+        sourceMode: ProviderSourceMode = .api) -> ProviderFetchContext
+    {
+        let browserDetection = BrowserDetection(cacheTTL: 0)
+        let env = [ClaudeAdminAPISettingsReader.adminAPIKeyEnvironmentKey: apiKey]
+        return ProviderFetchContext(
+            runtime: .app,
+            sourceMode: sourceMode,
+            includeCredits: false,
+            webTimeout: 1,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: env,
+            settings: nil,
+            fetcher: UsageFetcher(environment: env),
+            claudeFetcher: ClaudeUsageFetcher(browserDetection: browserDetection),
+            browserDetection: browserDetection)
+    }
+
+    @Test
+    func `prefers primary Anthropic admin key environment variable`() {
+        let token = ClaudeAdminAPISettingsReader.apiKey(environment: [
+            ClaudeAdminAPISettingsReader.alternateAdminAPIKeyEnvironmentKey: "sk-ant-admin-alt",
+            ClaudeAdminAPISettingsReader.adminAPIKeyEnvironmentKey: "sk-ant-admin-primary",
+        ])
+
+        #expect(token == "sk-ant-admin-primary")
+    }
+
+    @Test
+    func `routes Claude token account admin keys into admin api environment`() {
+        let env = TokenAccountSupportCatalog.envOverride(for: .claude, token: "Bearer sk-ant-admin-token")
+
+        #expect(env?[ClaudeAdminAPISettingsReader.adminAPIKeyEnvironmentKey] == "sk-ant-admin-token")
+    }
+
+    @Test
+    func `auto source uses configured admin api key`() async {
+        let descriptor = ProviderDescriptorRegistry.descriptor(for: .claude)
+        let context = self.makeContext(sourceMode: .auto)
+        let strategies = await descriptor.fetchPlan.pipeline.resolveStrategies(context)
+
+        #expect(strategies.map(\.id) == ["claude.admin-api"])
+    }
+
+    @Test
+    func `parses Anthropic admin cost and messages usage into daily summaries`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_179_200)
+        let costs = """
+        {
+          "data": [
+            {
+              "starting_at": "2023-11-14T00:00:00Z",
+              "ending_at": "2023-11-15T00:00:00Z",
+              "results": [
+                {
+                  "currency": "USD",
+                  "amount": "12345.00",
+                  "description": "Claude Sonnet 4 Usage - Input Tokens",
+                  "cost_type": "tokens"
+                },
+                {
+                  "currency": "USD",
+                  "amount": "2500.00",
+                  "description": "Web Search Usage",
+                  "cost_type": "web_search"
+                }
+              ]
+            },
+            {
+              "starting_at": "2023-11-15T00:00:00Z",
+              "ending_at": "2023-11-16T00:00:00Z",
+              "results": [
+                {
+                  "currency": "USD",
+                  "amount": "5000",
+                  "description": "Claude Haiku Usage - Output Tokens",
+                  "cost_type": "tokens"
+                }
+              ]
+            }
+          ],
+          "has_more": false,
+          "next_page": null
+        }
+        """
+        let messages = """
+        {
+          "data": [
+            {
+              "starting_at": "2023-11-14T00:00:00Z",
+              "ending_at": "2023-11-15T00:00:00Z",
+              "results": [
+                {
+                  "uncached_input_tokens": 1500,
+                  "cache_creation": {
+                    "ephemeral_1h_input_tokens": 1000,
+                    "ephemeral_5m_input_tokens": 500
+                  },
+                  "cache_read_input_tokens": 200,
+                  "output_tokens": 500,
+                  "model": "claude-sonnet-4-20250514"
+                },
+                {
+                  "uncached_input_tokens": 100,
+                  "output_tokens": 50,
+                  "model": "claude-opus-4-20250514"
+                }
+              ]
+            },
+            {
+              "starting_at": "2023-11-15T00:00:00Z",
+              "ending_at": "2023-11-16T00:00:00Z",
+              "results": [
+                {
+                  "uncached_input_tokens": 200,
+                  "cache_read_input_tokens": 300,
+                  "output_tokens": 100,
+                  "model": "claude-sonnet-4-20250514"
+                }
+              ]
+            }
+          ],
+          "has_more": false,
+          "next_page": null
+        }
+        """
+
+        let snapshot = try ClaudeAdminAPIUsageFetcher._parseSnapshotForTesting(
+            costs: Data(costs.utf8),
+            messages: Data(messages.utf8),
+            now: now)
+
+        #expect(snapshot.daily.count == 2)
+        #expect(snapshot.daily[0].costUSD == 148.45)
+        #expect(snapshot.daily[0].inputTokens == 1600)
+        #expect(snapshot.daily[0].cacheCreationInputTokens == 1500)
+        #expect(snapshot.daily[0].cacheReadInputTokens == 200)
+        #expect(snapshot.daily[0].outputTokens == 550)
+        #expect(snapshot.daily[0].totalTokens == 3850)
+        #expect(snapshot.last30Days.costUSD == 198.45)
+        #expect(snapshot.last30Days.totalTokens == 4450)
+        #expect(snapshot.topModels.first?.name == "claude-sonnet-4-20250514")
+        #expect(snapshot.topModels.first?.totalTokens == 4300)
+    }
+
+    @Test
+    func `maps Anthropic admin usage to Claude usage snapshot`() {
+        let now = Date(timeIntervalSince1970: 1_700_179_200)
+        let apiUsage = ClaudeAdminAPIUsageSnapshot(
+            daily: [
+                ClaudeAdminAPIUsageSnapshot.DailyBucket(
+                    day: "2023-11-14",
+                    startTime: now,
+                    endTime: now.addingTimeInterval(86400),
+                    costUSD: 8.5,
+                    inputTokens: 1000,
+                    cacheCreationInputTokens: 400,
+                    cacheReadInputTokens: 300,
+                    outputTokens: 250,
+                    totalTokens: 1950,
+                    costItems: [],
+                    models: []),
+            ],
+            updatedAt: now)
+
+        let usage = apiUsage.toUsageSnapshot()
+
+        #expect(usage.primary == nil)
+        #expect(usage.providerCost?.used == 8.5)
+        #expect(usage.providerCost?.limit == 0)
+        #expect(usage.providerCost?.period == "Last 30 days")
+        #expect(usage.claudeAdminAPIUsage?.last30Days.totalTokens == 1950)
+        #expect(usage.identity?.providerID == .claude)
+        #expect(usage.identity?.loginMethod == "Admin API")
+    }
+
+    @Test
+    func `fetch strategy reports admin api source label`() async throws {
+        let strategy = ClaudeAdminAPIFetchStrategy(usageFetcher: { apiKey in
+            #expect(apiKey == "sk-ant-admin-test")
+            return ClaudeAdminAPIUsageSnapshot(daily: [], updatedAt: Date(timeIntervalSince1970: 1_700_000_000))
+        })
+
+        let result = try await strategy.fetch(self.makeContext())
+
+        #expect(result.sourceLabel == "admin-api")
+        #expect(result.usage.identity?.loginMethod == "Admin API")
+    }
+}
diff --git a/Tests/CodexBarTests/ClaudeBaselineCharacterizationTests.swift b/Tests/CodexBarTests/ClaudeBaselineCharacterizationTests.swift
new file mode 100644
index 0000000000..ff3a80c1af
--- /dev/null
+++ b/Tests/CodexBarTests/ClaudeBaselineCharacterizationTests.swift
@@ -0,0 +1,297 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct ClaudeBaselineCharacterizationTests {
+    private func makeStubClaudeCLI() throws -> String {
+        let sample = """
+        Current session
+        12% used  (Resets 11am)
+        Current week (all models)
+        40% used  (Resets Nov 21)
+        Current week (Sonnet only)
+        5% used (Resets Nov 21)
+        Account: user@example.com
+        Org: Example Org
+        """
+        let script = """
+        #!/bin/sh
+        cat <<'EOF'
+        \(sample)
+        EOF
+        """
+        let url = FileManager.default.temporaryDirectory
+            .appendingPathComponent("claude-stub-\(UUID().uuidString)")
+        try Data(script.utf8).write(to: url)
+        try FileManager.default.setAttributes([.posixPermissions: 0o755], ofItemAtPath: url.path)
+        return url.path
+    }
+
+    private func makeContext(
+        runtime: ProviderRuntime,
+        sourceMode: ProviderSourceMode,
+        env: [String: String] = [:],
+        settings: ProviderSettingsSnapshot? = nil) -> ProviderFetchContext
+    {
+        let browserDetection = BrowserDetection(cacheTTL: 0)
+        return ProviderFetchContext(
+            runtime: runtime,
+            sourceMode: sourceMode,
+            includeCredits: false,
+            webTimeout: 1,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: env,
+            settings: settings,
+            fetcher: UsageFetcher(environment: env),
+            claudeFetcher: ClaudeUsageFetcher(browserDetection: browserDetection),
+            browserDetection: browserDetection)
+    }
+
+    private func strategyIDs(
+        runtime: ProviderRuntime,
+        sourceMode: ProviderSourceMode,
+        env: [String: String] = [:],
+        settings: ProviderSettingsSnapshot? = nil) async -> [String]
+    {
+        let descriptor = ProviderDescriptorRegistry.descriptor(for: .claude)
+        let context = self.makeContext(runtime: runtime, sourceMode: sourceMode, env: env, settings: settings)
+        let strategies = await descriptor.fetchPlan.pipeline.resolveStrategies(context)
+        return strategies.map(\.id)
+    }
+
+    private func fetchOutcome(
+        runtime: ProviderRuntime,
+        sourceMode: ProviderSourceMode,
+        env: [String: String] = [:],
+        settings: ProviderSettingsSnapshot? = nil) async -> ProviderFetchOutcome
+    {
+        let descriptor = ProviderDescriptorRegistry.descriptor(for: .claude)
+        let context = self.makeContext(runtime: runtime, sourceMode: sourceMode, env: env, settings: settings)
+        return await descriptor.fetchPlan.fetchOutcome(context: context, provider: .claude)
+    }
+
+    private func withNoOAuthCredentials<T>(operation: () async throws -> T) async rethrows -> T {
+        let missingCredentialsURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent("missing-claude-creds-\(UUID().uuidString).json")
+        return try await KeychainCacheStore.withServiceOverrideForTesting("rat-110-\(UUID().uuidString)") {
+            KeychainCacheStore.setTestStoreForTesting(true)
+            defer { KeychainCacheStore.setTestStoreForTesting(false) }
+            return try await ClaudeOAuthCredentialsStore.withIsolatedMemoryCacheForTesting {
+                try await ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+                    try await ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(missingCredentialsURL) {
+                        try await ClaudeOAuthCredentialsStore.withKeychainAccessOverrideForTesting(true) {
+                            try await ClaudeOAuthCredentialsStore.withClaudeKeychainOverridesForTesting(
+                                data: nil,
+                                fingerprint: nil)
+                            {
+                                try await operation()
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    func `app auto pipeline order is OAuth then CLI then web`() async {
+        let settings = ProviderSettingsSnapshot.make(claude: .init(
+            usageDataSource: .auto,
+            webExtrasEnabled: true,
+            cookieSource: .manual,
+            manualCookieHeader: "sessionKey=sk-ant-session-token"))
+        let env = [
+            ClaudeOAuthCredentialsStore.environmentTokenKey: "oauth-token",
+            ClaudeOAuthCredentialsStore.environmentScopesKey: "user:profile",
+            "CLAUDE_CLI_PATH": "/usr/bin/true",
+        ]
+        let strategyIDs = await self.strategyIDs(runtime: .app, sourceMode: .auto, env: env, settings: settings)
+        #expect(strategyIDs == ["claude.oauth", "claude.cli", "claude.web"])
+    }
+
+    @Test
+    func `CLI auto pipeline order is web then CLI`() async {
+        let settings = ProviderSettingsSnapshot.make(claude: .init(
+            usageDataSource: .auto,
+            webExtrasEnabled: false,
+            cookieSource: .manual,
+            manualCookieHeader: "sessionKey=sk-ant-session-token"))
+        let env = [
+            "CLAUDE_CLI_PATH": "/usr/bin/true",
+        ]
+        let strategyIDs = await self.strategyIDs(runtime: .cli, sourceMode: .auto, env: env, settings: settings)
+        #expect(strategyIDs == ["claude.web", "claude.cli"])
+    }
+
+    @Test
+    func `explicit CLI pipeline attempts strategy even when planner marks CLI unavailable`() async {
+        let settings = ProviderSettingsSnapshot.make(claude: .init(
+            usageDataSource: .cli,
+            webExtrasEnabled: false,
+            cookieSource: .off,
+            manualCookieHeader: nil))
+        let env = [
+            "CLAUDE_CLI_PATH": "/definitely/missing/claude",
+        ]
+        let descriptor = ProviderDescriptorRegistry.descriptor(for: .claude)
+        let context = self.makeContext(runtime: .app, sourceMode: .cli, env: env, settings: settings)
+        let strategies = await descriptor.fetchPlan.pipeline.resolveStrategies(context)
+
+        #expect(strategies.map(\.id) == ["claude.cli"])
+        #expect(await strategies[0].isAvailable(context))
+    }
+
+    @Test
+    func `auto pipeline records unavailable planned steps when planner has no executable source`() async {
+        let settings = ProviderSettingsSnapshot.make(claude: .init(
+            usageDataSource: .auto,
+            webExtrasEnabled: true,
+            cookieSource: .off,
+            manualCookieHeader: nil))
+        let env = ["CLAUDE_CLI_PATH": "/definitely/missing/claude"]
+
+        await self.withNoOAuthCredentials {
+            await ClaudeCLIResolver.withResolvedBinaryPathOverrideForTesting("/definitely/missing/claude") {
+                let strategyIDs = await self.strategyIDs(runtime: .app, sourceMode: .auto, env: env, settings: settings)
+                #expect(strategyIDs == ["claude.oauth", "claude.cli", "claude.web"])
+
+                let outcome = await self.fetchOutcome(runtime: .app, sourceMode: .auto, env: env, settings: settings)
+                #expect(outcome.attempts.map(\.strategyID) == ["claude.oauth", "claude.cli", "claude.web"])
+                #expect(outcome.attempts.map(\.wasAvailable) == [false, false, false])
+
+                switch outcome.result {
+                case let .failure(error as ProviderFetchError):
+                    switch error {
+                    case let .noAvailableStrategy(provider):
+                        #expect(provider == .claude)
+                    }
+                case let .failure(error):
+                    Issue.record("Unexpected failure: \(error)")
+                case let .success(result):
+                    Issue.record("Unexpected success: \(result.sourceLabel)")
+                }
+            }
+        }
+    }
+
+    @Test
+    func `app auto pipeline retains OAuth bootstrap strategy at startup`() async {
+        let settings = ProviderSettingsSnapshot.make(claude: .init(
+            usageDataSource: .auto,
+            webExtrasEnabled: false,
+            cookieSource: .off,
+            manualCookieHeader: nil))
+
+        await ClaudeOAuthCredentialsStore.withIsolatedMemoryCacheForTesting {
+            ClaudeOAuthCredentialsStore.invalidateCache()
+            ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting()
+            ClaudeOAuthKeychainAccessGate.resetForTesting()
+            defer {
+                ClaudeOAuthCredentialsStore.invalidateCache()
+                ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting()
+                ClaudeOAuthKeychainAccessGate.resetForTesting()
+            }
+
+            await self.withNoOAuthCredentials {
+                let strategyIDs = await ClaudeOAuthKeychainPromptPreference.withTaskOverrideForTesting(
+                    .onlyOnUserAction)
+                {
+                    await ProviderRefreshContext.$current.withValue(.startup) {
+                        await ProviderInteractionContext.$current.withValue(.background) {
+                            await self.strategyIDs(runtime: .app, sourceMode: .auto, settings: settings)
+                        }
+                    }
+                }
+                #expect(strategyIDs.first == "claude.oauth")
+                #expect(strategyIDs.contains("claude.oauth"))
+            }
+        }
+    }
+
+    @Test
+    func `auto pipeline CLI uses planned environment for execution`() async throws {
+        let settings = ProviderSettingsSnapshot.make(claude: .init(
+            usageDataSource: .auto,
+            webExtrasEnabled: false,
+            cookieSource: .off,
+            manualCookieHeader: nil))
+        let stubCLIPath = try self.makeStubClaudeCLI()
+        let env = ["CLAUDE_CLI_PATH": stubCLIPath]
+
+        await self.withNoOAuthCredentials {
+            let fetchOverride: @Sendable (String, TimeInterval, Bool) async throws
+                -> ClaudeStatusSnapshot = { binary, _, _ in
+                    #expect(binary == stubCLIPath)
+                    return ClaudeStatusSnapshot(
+                        sessionPercentLeft: 88,
+                        weeklyPercentLeft: 60,
+                        opusPercentLeft: 95,
+                        accountEmail: "user@example.com",
+                        accountOrganization: "Example Org",
+                        loginMethod: nil,
+                        primaryResetDescription: "Resets 11am",
+                        secondaryResetDescription: "Resets Nov 21",
+                        opusResetDescription: "Resets Nov 21",
+                        rawText: "stub")
+                }
+            let outcome = await ClaudeStatusProbe.$fetchOverride.withValue(fetchOverride) {
+                await self.fetchOutcome(runtime: .app, sourceMode: .auto, env: env, settings: settings)
+            }
+
+            #expect(outcome.attempts.map(\.strategyID) == ["claude.oauth", "claude.cli"])
+            #expect(outcome.attempts.map(\.wasAvailable) == [false, true])
+
+            switch outcome.result {
+            case let .success(result):
+                #expect(result.strategyID == "claude.cli")
+                #expect(result.sourceLabel == "claude")
+                #expect(result.usage.primary?.usedPercent == 12)
+                #expect(result.usage.secondary?.usedPercent == 40)
+                #expect(result.usage.tertiary?.usedPercent == 5)
+                #expect(result.usage.identity?.accountEmail == "user@example.com")
+            case let .failure(error):
+                Issue.record("Unexpected failure: \(error)")
+            }
+        }
+    }
+
+    @Test(arguments: [
+        (ProviderSourceMode.oauth, "claude.oauth"),
+        (ProviderSourceMode.cli, "claude.cli"),
+        (ProviderSourceMode.web, "claude.web"),
+    ])
+    func `explicit modes resolve single Claude strategy`(
+        sourceMode: ProviderSourceMode,
+        expectedStrategyID: String) async
+    {
+        let strategyIDs = await self.strategyIDs(runtime: .app, sourceMode: sourceMode)
+        #expect(strategyIDs == [expectedStrategyID])
+    }
+
+    @Test(arguments: [
+        (ProviderSourceMode.oauth, "claude.oauth"),
+        (ProviderSourceMode.cli, "claude.cli"),
+        (ProviderSourceMode.web, "claude.web"),
+    ])
+    func `CLI explicit modes resolve single Claude strategy`(
+        sourceMode: ProviderSourceMode,
+        expectedStrategyID: String) async
+    {
+        let strategyIDs = await self.strategyIDs(runtime: .cli, sourceMode: sourceMode)
+        #expect(strategyIDs == [expectedStrategyID])
+    }
+
+    @Test
+    func `Claude OAuth token heuristics accept raw and bearer inputs`() {
+        #expect(TokenAccountSupportCatalog.isClaudeOAuthToken("sk-ant-oat-test-token"))
+        #expect(TokenAccountSupportCatalog.isClaudeOAuthToken("Bearer sk-ant-oat-test-token"))
+    }
+
+    @Test
+    func `Claude OAuth token heuristics reject cookie shaped inputs`() {
+        #expect(!TokenAccountSupportCatalog.isClaudeOAuthToken("sessionKey=sk-ant-session"))
+        #expect(!TokenAccountSupportCatalog.isClaudeOAuthToken("Cookie: sessionKey=sk-ant-session; foo=bar"))
+    }
+}
diff --git a/Tests/CodexBarTests/ClaudeCLITimeoutRetryTests.swift b/Tests/CodexBarTests/ClaudeCLITimeoutRetryTests.swift
new file mode 100644
index 0000000000..f201b597bc
--- /dev/null
+++ b/Tests/CodexBarTests/ClaudeCLITimeoutRetryTests.swift
@@ -0,0 +1,367 @@
+import Foundation
+import Testing
+@testable import CodexBar
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct ClaudeCLITimeoutRetryTests {
+    private actor AttemptRecorder {
+        private var count = 0
+        private var timeouts: [TimeInterval] = []
+
+        func record(timeout: TimeInterval) -> Int {
+            self.count += 1
+            self.timeouts.append(timeout)
+            return self.count
+        }
+
+        func snapshot() -> (count: Int, timeouts: [TimeInterval]) {
+            (self.count, self.timeouts)
+        }
+    }
+
+    private final class WebRequestRecorder: @unchecked Sendable {
+        private let lock = NSLock()
+        private var paths: [String] = []
+
+        func record(_ path: String) {
+            self.lock.withLock {
+                self.paths.append(path)
+            }
+        }
+
+        func snapshot() -> [String] {
+            self.lock.withLock {
+                self.paths
+            }
+        }
+    }
+
+    @Test
+    func `cli usage retries with longer timeout after transient probe failure`() async throws {
+        let attempts = AttemptRecorder()
+        let fetcher = ClaudeUsageFetcher(
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            environment: [:],
+            dataSource: .cli)
+
+        let fetchOverride: ClaudeStatusProbe.FetchOverride = { _, timeout, _ in
+            let attempt = await attempts.record(timeout: timeout)
+            if attempt == 1 {
+                throw ClaudeStatusProbeError.timedOut
+            }
+            return ClaudeStatusSnapshot(
+                sessionPercentLeft: 91,
+                weeklyPercentLeft: 88,
+                opusPercentLeft: nil,
+                accountEmail: "cli@example.com",
+                accountOrganization: "CLI Org",
+                loginMethod: "cli",
+                primaryResetDescription: nil,
+                secondaryResetDescription: nil,
+                opusResetDescription: nil,
+                rawText: "probe raw")
+        }
+
+        let snapshot = try await ClaudeCLIResolver.withResolvedBinaryPathOverrideForTesting("/usr/bin/true") {
+            try await ClaudeStatusProbe.withFetchOverrideForTesting(fetchOverride) {
+                try await fetcher.loadLatestUsage(model: "sonnet")
+            }
+        }
+
+        let recorded = await attempts.snapshot()
+        #expect(recorded.count == 2)
+        #expect(recorded.timeouts == [24, 60])
+        #expect(snapshot.primary.usedPercent == 9)
+        #expect(snapshot.secondary?.usedPercent == 12)
+        #expect(snapshot.accountEmail == "cli@example.com")
+    }
+
+    @Test
+    func `auto cli usage does not retry unrecoverable parse failure`() async throws {
+        let attempts = AttemptRecorder()
+        let fetcher = ClaudeUsageFetcher(
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            environment: [:],
+            dataSource: .auto,
+            manualCookieHeader: "foo=bar")
+
+        let fetchOverride: ClaudeStatusProbe.FetchOverride = { _, timeout, _ in
+            _ = await attempts.record(timeout: timeout)
+            throw ClaudeStatusProbeError.parseFailed("Missing Current session.")
+        }
+
+        await #expect(throws: ClaudeStatusProbeError.self) {
+            try await self.withNoOAuthCredentials {
+                try await ClaudeCLIResolver.withResolvedBinaryPathOverrideForTesting("/usr/bin/true") {
+                    try await ClaudeStatusProbe.withFetchOverrideForTesting(fetchOverride) {
+                        try await fetcher.loadLatestUsage(model: "sonnet")
+                    }
+                }
+            }
+        }
+
+        let recorded = await attempts.snapshot()
+        #expect(recorded.count == 1)
+        #expect(recorded.timeouts == [12])
+    }
+
+    @Test
+    func `auto cli usage retries loading panel before stale web fallback`() async throws {
+        let attempts = AttemptRecorder()
+        let webRequests = WebRequestRecorder()
+        let fetcher = ClaudeUsageFetcher(
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            environment: [:],
+            dataSource: .auto,
+            manualCookieHeader: "sessionKey=sk-ant-session-token")
+
+        let fetchOverride: ClaudeStatusProbe.FetchOverride = { _, timeout, _ in
+            let attempt = await attempts.record(timeout: timeout)
+            if attempt == 1 {
+                throw ClaudeStatusProbeError.parseFailed("Claude CLI /usage is still loading usage data.")
+            }
+            return ClaudeStatusSnapshot(
+                sessionPercentLeft: 95,
+                weeklyPercentLeft: 93,
+                opusPercentLeft: nil,
+                accountEmail: "loading-cli@example.com",
+                accountOrganization: "Loading CLI Org",
+                loginMethod: "cli",
+                primaryResetDescription: nil,
+                secondaryResetDescription: nil,
+                opusResetDescription: nil,
+                rawText: "probe raw")
+        }
+
+        let snapshot = try await self.withNoOAuthCredentials {
+            try await self.withClaudeWebStub(handler: { request in
+                webRequests.record(request.url?.path ?? "<missing>")
+                throw URLError(.userAuthenticationRequired)
+            }, operation: {
+                try await ClaudeCLIResolver.withResolvedBinaryPathOverrideForTesting("/usr/bin/true") {
+                    try await ClaudeStatusProbe.withFetchOverrideForTesting(fetchOverride) {
+                        try await fetcher.loadLatestUsage(model: "sonnet")
+                    }
+                }
+            })
+        }
+
+        let recorded = await attempts.snapshot()
+        #expect(recorded.count == 2)
+        #expect(recorded.timeouts == [12, 60])
+        #expect(webRequests.snapshot().isEmpty)
+        #expect(snapshot.primary.usedPercent == 5)
+        #expect(snapshot.secondary?.usedPercent == 7)
+        #expect(snapshot.accountEmail == "loading-cli@example.com")
+    }
+
+    @Test
+    func `auto cli usage retries timeout when cli is final source`() async throws {
+        let attempts = AttemptRecorder()
+        let fetcher = ClaudeUsageFetcher(
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            environment: [:],
+            dataSource: .auto,
+            manualCookieHeader: "foo=bar")
+
+        let fetchOverride: ClaudeStatusProbe.FetchOverride = { _, timeout, _ in
+            let attempt = await attempts.record(timeout: timeout)
+            if attempt == 1 {
+                throw ClaudeStatusProbeError.timedOut
+            }
+            return ClaudeStatusSnapshot(
+                sessionPercentLeft: 72,
+                weeklyPercentLeft: 64,
+                opusPercentLeft: nil,
+                accountEmail: "auto-cli@example.com",
+                accountOrganization: "Auto CLI Org",
+                loginMethod: "cli",
+                primaryResetDescription: nil,
+                secondaryResetDescription: nil,
+                opusResetDescription: nil,
+                rawText: "probe raw")
+        }
+
+        let snapshot = try await self.withNoOAuthCredentials {
+            try await ClaudeCLIResolver.withResolvedBinaryPathOverrideForTesting("/usr/bin/true") {
+                try await ClaudeStatusProbe.withFetchOverrideForTesting(fetchOverride) {
+                    try await fetcher.loadLatestUsage(model: "sonnet")
+                }
+            }
+        }
+
+        let recorded = await attempts.snapshot()
+        #expect(recorded.count == 2)
+        #expect(recorded.timeouts == [12, 60])
+        #expect(snapshot.primary.usedPercent == 28)
+        #expect(snapshot.secondary?.usedPercent == 36)
+        #expect(snapshot.accountEmail == "auto-cli@example.com")
+    }
+
+    @Test
+    func `cli usage does not retry cancelled probe`() async throws {
+        let attempts = AttemptRecorder()
+        let fetcher = ClaudeUsageFetcher(
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            environment: [:],
+            dataSource: .cli)
+
+        let fetchOverride: ClaudeStatusProbe.FetchOverride = { _, timeout, _ in
+            _ = await attempts.record(timeout: timeout)
+            throw CancellationError()
+        }
+
+        await #expect(throws: CancellationError.self) {
+            try await ClaudeCLIResolver.withResolvedBinaryPathOverrideForTesting("/usr/bin/true") {
+                try await ClaudeStatusProbe.withFetchOverrideForTesting(fetchOverride) {
+                    try await fetcher.loadLatestUsage(model: "sonnet")
+                }
+            }
+        }
+
+        let recorded = await attempts.snapshot()
+        #expect(recorded.count == 1)
+        #expect(recorded.timeouts == [24])
+    }
+
+    @Test
+    func `cli usage records background cooldown after rate limit`() async {
+        ClaudeCLIRateLimitGate.resetForTesting()
+        defer { ClaudeCLIRateLimitGate.resetForTesting() }
+
+        let attempts = AttemptRecorder()
+        let fetcher = ClaudeUsageFetcher(
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            environment: [:],
+            dataSource: .cli)
+
+        let fetchOverride: ClaudeStatusProbe.FetchOverride = { _, timeout, _ in
+            _ = await attempts.record(timeout: timeout)
+            throw ClaudeStatusProbeError.parseFailed(ClaudeCLIRateLimitGate.message)
+        }
+
+        await ProviderInteractionContext.$current.withValue(.background) {
+            await #expect(throws: ClaudeStatusProbeError.self) {
+                try await ClaudeCLIResolver.withResolvedBinaryPathOverrideForTesting("/usr/bin/true") {
+                    try await ClaudeStatusProbe.withFetchOverrideForTesting(fetchOverride) {
+                        try await fetcher.loadLatestUsage(model: "sonnet")
+                    }
+                }
+            }
+        }
+
+        let recordedAfterRateLimit = await attempts.snapshot()
+        #expect(recordedAfterRateLimit.count == 1)
+        #expect(recordedAfterRateLimit.timeouts == [24])
+        #expect(ClaudeCLIRateLimitGate.currentBlockedUntil() != nil)
+
+        await ProviderInteractionContext.$current.withValue(.background) {
+            await #expect(throws: ClaudeUsageError.self) {
+                try await ClaudeCLIResolver.withResolvedBinaryPathOverrideForTesting("/usr/bin/true") {
+                    try await ClaudeStatusProbe.withFetchOverrideForTesting(fetchOverride) {
+                        try await fetcher.loadLatestUsage(model: "sonnet")
+                    }
+                }
+            }
+        }
+
+        let recordedAfterBlockedRetry = await attempts.snapshot()
+        #expect(recordedAfterBlockedRetry.count == 1)
+        #expect(recordedAfterBlockedRetry.timeouts == [24])
+    }
+
+    @Test
+    func `user initiated cli usage bypasses rate limit cooldown`() async throws {
+        ClaudeCLIRateLimitGate.resetForTesting()
+        defer { ClaudeCLIRateLimitGate.resetForTesting() }
+        ClaudeCLIRateLimitGate.recordRateLimit()
+
+        let attempts = AttemptRecorder()
+        let fetcher = ClaudeUsageFetcher(
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            environment: [:],
+            dataSource: .cli)
+
+        let fetchOverride: ClaudeStatusProbe.FetchOverride = { _, timeout, _ in
+            _ = await attempts.record(timeout: timeout)
+            return ClaudeStatusSnapshot(
+                sessionPercentLeft: 89,
+                weeklyPercentLeft: 83,
+                opusPercentLeft: nil,
+                accountEmail: "manual-cli@example.com",
+                accountOrganization: "Manual CLI Org",
+                loginMethod: "cli",
+                primaryResetDescription: nil,
+                secondaryResetDescription: nil,
+                opusResetDescription: nil,
+                rawText: "probe raw")
+        }
+
+        await ProviderInteractionContext.$current.withValue(.background) {
+            await #expect(throws: ClaudeUsageError.self) {
+                try await ClaudeCLIResolver.withResolvedBinaryPathOverrideForTesting("/usr/bin/true") {
+                    try await ClaudeStatusProbe.withFetchOverrideForTesting(fetchOverride) {
+                        try await fetcher.loadLatestUsage(model: "sonnet")
+                    }
+                }
+            }
+        }
+
+        #expect(await (attempts.snapshot()).timeouts.isEmpty)
+
+        let snapshot = try await ProviderInteractionContext.$current.withValue(.userInitiated) {
+            try await ClaudeCLIResolver.withResolvedBinaryPathOverrideForTesting("/usr/bin/true") {
+                try await ClaudeStatusProbe.withFetchOverrideForTesting(fetchOverride) {
+                    try await fetcher.loadLatestUsage(model: "sonnet")
+                }
+            }
+        }
+
+        let recorded = await attempts.snapshot()
+        #expect(recorded.count == 1)
+        #expect(recorded.timeouts == [24])
+        #expect(snapshot.primary.usedPercent == 11)
+        #expect(snapshot.secondary?.usedPercent == 17)
+        #expect(snapshot.accountEmail == "manual-cli@example.com")
+        #expect(ClaudeCLIRateLimitGate.currentBlockedUntil() == nil)
+    }
+
+    private func withNoOAuthCredentials<T>(operation: () async throws -> T) async rethrows -> T {
+        let missingCredentialsURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent("missing-claude-creds-\(UUID().uuidString).json")
+        return try await KeychainCacheStore.withServiceOverrideForTesting("rat-107-\(UUID().uuidString)") {
+            KeychainCacheStore.setTestStoreForTesting(true)
+            defer { KeychainCacheStore.setTestStoreForTesting(false) }
+            return try await ClaudeOAuthCredentialsStore.withIsolatedMemoryCacheForTesting {
+                try await ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+                    try await ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(missingCredentialsURL) {
+                        try await ClaudeOAuthCredentialsStore.withKeychainAccessOverrideForTesting(true) {
+                            try await ClaudeOAuthCredentialsStore.withClaudeKeychainOverridesForTesting(
+                                data: nil,
+                                fingerprint: nil)
+                            {
+                                try await operation()
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private func withClaudeWebStub<T>(
+        handler: @escaping (URLRequest) throws -> (HTTPURLResponse, Data),
+        operation: () async throws -> T) async rethrows -> T
+    {
+        let registered = URLProtocol.registerClass(ClaudeAutoFetcherStubURLProtocol.self)
+        ClaudeAutoFetcherStubURLProtocol.handler = handler
+        defer {
+            if registered {
+                URLProtocol.unregisterClass(ClaudeAutoFetcherStubURLProtocol.self)
+            }
+            ClaudeAutoFetcherStubURLProtocol.handler = nil
+        }
+        return try await operation()
+    }
+}
diff --git a/Tests/CodexBarTests/ClaudeCredentialRoutingTests.swift b/Tests/CodexBarTests/ClaudeCredentialRoutingTests.swift
new file mode 100644
index 0000000000..e711d03884
--- /dev/null
+++ b/Tests/CodexBarTests/ClaudeCredentialRoutingTests.swift
@@ -0,0 +1,58 @@
+import CodexBarCore
+import Testing
+
+struct ClaudeCredentialRoutingTests {
+    @Test
+    func `resolves raw OAuth token`() {
+        let routing = ClaudeCredentialRouting.resolve(
+            tokenAccountToken: "sk-ant-oat-test-token",
+            manualCookieHeader: nil)
+
+        #expect(routing == .oauth(accessToken: "sk-ant-oat-test-token"))
+    }
+
+    @Test
+    func `resolves bearer OAuth token`() {
+        let routing = ClaudeCredentialRouting.resolve(
+            tokenAccountToken: "Bearer sk-ant-oat-test-token",
+            manualCookieHeader: nil)
+
+        #expect(routing == .oauth(accessToken: "sk-ant-oat-test-token"))
+    }
+
+    @Test
+    func `resolves session token to cookie header`() {
+        let routing = ClaudeCredentialRouting.resolve(
+            tokenAccountToken: "sk-ant-session-token",
+            manualCookieHeader: nil)
+
+        #expect(routing == .webCookie(header: "sessionKey=sk-ant-session-token"))
+    }
+
+    @Test
+    func `resolves config cookie header through shared normalizer`() {
+        let routing = ClaudeCredentialRouting.resolve(
+            tokenAccountToken: nil,
+            manualCookieHeader: "Cookie: sessionKey=sk-ant-session-token; foo=bar")
+
+        #expect(routing == .webCookie(header: "sessionKey=sk-ant-session-token; foo=bar"))
+    }
+
+    @Test
+    func `token account input wins over config cookie fallback`() {
+        let routing = ClaudeCredentialRouting.resolve(
+            tokenAccountToken: "Bearer sk-ant-oat-test-token",
+            manualCookieHeader: "Cookie: sessionKey=sk-ant-session-token")
+
+        #expect(routing == .oauth(accessToken: "sk-ant-oat-test-token"))
+    }
+
+    @Test
+    func `empty inputs resolve to none`() {
+        let routing = ClaudeCredentialRouting.resolve(
+            tokenAccountToken: "   ",
+            manualCookieHeader: "\n")
+
+        #expect(routing == .none)
+    }
+}
diff --git a/Tests/CodexBarTests/ClaudeDebugDiagnosticsTests.swift b/Tests/CodexBarTests/ClaudeDebugDiagnosticsTests.swift
new file mode 100644
index 0000000000..e67706257c
--- /dev/null
+++ b/Tests/CodexBarTests/ClaudeDebugDiagnosticsTests.swift
@@ -0,0 +1,461 @@
+import Foundation
+import Testing
+@testable import CodexBar
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct ClaudeDebugDiagnosticsTests {
+    private func makeCredentialsData(
+        accessToken: String,
+        expiresAt: Date,
+        refreshToken: String? = nil) -> Data
+    {
+        let refreshTokenLine = if let refreshToken {
+            """
+                "refreshToken": "\(refreshToken)",
+            """
+        } else {
+            ""
+        }
+        let json = """
+        {
+          "claudeAiOauth": {
+            "accessToken": "\(accessToken)",
+        \(refreshTokenLine)
+            "expiresAt": \(Int(expiresAt.timeIntervalSince1970 * 1000)),
+            "scopes": ["user:profile"]
+          }
+        }
+        """
+        return Data(json.utf8)
+    }
+
+    @Test
+    func `debug log uses planner derived order and reasons`() async throws {
+        let suite = "ClaudeDebugDiagnosticsTests-\(UUID().uuidString)"
+        let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
+        let tempDir = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+        let credentialsURL = tempDir.appendingPathComponent("credentials.json")
+        let credsJSON = """
+        {
+          "claudeAiOauth": {
+            "accessToken": "oauth-token",
+            "expiresAt": \(Int(Date(timeIntervalSinceNow: 3600).timeIntervalSince1970 * 1000)),
+            "scopes": ["user:profile"]
+          }
+        }
+        """
+        try Data(credsJSON.utf8).write(to: credentialsURL)
+
+        let store = try await MainActor.run { () -> UsageStore in
+            let defaults = try #require(UserDefaults(suiteName: suite))
+            defaults.removePersistentDomain(forName: suite)
+            let configStore = testConfigStore(suiteName: suite)
+            let settings = SettingsStore(
+                userDefaults: defaults,
+                configStore: configStore,
+                zaiTokenStore: NoopZaiTokenStore())
+            settings.claudeUsageDataSource = .auto
+            settings.claudeCookieSource = .manual
+            settings.claudeCookieHeader = "sessionKey=sk-ant-session-token"
+
+            return UsageStore(
+                fetcher: UsageFetcher(),
+                browserDetection: BrowserDetection(cacheTTL: 0),
+                settings: settings)
+        }
+
+        let text = await KeychainCacheStore.withServiceOverrideForTesting(service) {
+            KeychainCacheStore.setTestStoreForTesting(true)
+            defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+            return await ClaudeOAuthCredentialsStore.withIsolatedMemoryCacheForTesting {
+                await ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+                    await ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(credentialsURL) {
+                        await store.debugLog(for: .claude)
+                    }
+                }
+            }
+        }
+
+        #expect(text.contains("planner_order=oauth→cli→web"))
+        #expect(text.contains("planner_selected=oauth"))
+        #expect(text.contains("planner_no_source=false"))
+        #expect(text.contains("planner_step.oauth=available reason=app-auto-preferred-oauth"))
+        #expect(text.contains("planner_step.cli="))
+        #expect(text.contains("reason=app-auto-fallback-cli"))
+        #expect(text.contains("planner_step.web=available reason=app-auto-fallback-web"))
+        #expect(!text.contains("auto_heuristic="))
+    }
+
+    @Test
+    func `debug log reports no planner selected source when auto has no available sources`() async throws {
+        let suite = "ClaudeDebugDiagnosticsTests-\(UUID().uuidString)"
+        let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
+        let tempDir = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+        let missingCredentialsURL = tempDir.appendingPathComponent("missing-credentials.json")
+
+        let store = try await MainActor.run { () -> UsageStore in
+            let defaults = try #require(UserDefaults(suiteName: suite))
+            defaults.removePersistentDomain(forName: suite)
+            let configStore = testConfigStore(suiteName: suite)
+            let settings = SettingsStore(
+                userDefaults: defaults,
+                configStore: configStore,
+                zaiTokenStore: NoopZaiTokenStore())
+            settings.claudeUsageDataSource = .auto
+            settings.claudeCookieSource = .off
+            settings.claudeWebExtrasEnabled = true
+
+            return UsageStore(
+                fetcher: UsageFetcher(),
+                browserDetection: BrowserDetection(cacheTTL: 0),
+                settings: settings)
+        }
+
+        let text = await ClaudeCLIResolver.withResolvedBinaryPathOverrideForTesting("/definitely/missing/claude") {
+            await KeychainCacheStore.withServiceOverrideForTesting(service) {
+                KeychainCacheStore.setTestStoreForTesting(true)
+                defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+                return await ClaudeOAuthCredentialsStore.withIsolatedMemoryCacheForTesting {
+                    await ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+                        await ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(missingCredentialsURL) {
+                            await ClaudeOAuthCredentialsStore.withKeychainAccessOverrideForTesting(true) {
+                                await ClaudeOAuthCredentialsStore.withClaudeKeychainOverridesForTesting(
+                                    data: nil,
+                                    fingerprint: nil)
+                                {
+                                    await store.debugLog(for: .claude)
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        #expect(text.contains("planner_selected=none"))
+        #expect(text.contains("planner_no_source=true"))
+        #expect(text.contains("No planner-selected Claude source."))
+        #expect(!text.contains("web_extras=enabled"))
+    }
+
+    @Test
+    func `debug Claude dump returns recorded parse dumps`() async {
+        await ClaudeStatusProbe._replaceDumpsForTesting([
+            "dump one",
+            "dump two",
+        ])
+
+        let store = await MainActor.run {
+            UsageStore(
+                fetcher: UsageFetcher(),
+                browserDetection: BrowserDetection(cacheTTL: 0),
+                settings: SettingsStore(
+                    userDefaults: UserDefaults(),
+                    configStore: testConfigStore(suiteName: "ClaudeDebugDiagnosticsTests-\(UUID().uuidString)"),
+                    zaiTokenStore: NoopZaiTokenStore()))
+        }
+        let text = await store.debugClaudeDump()
+
+        #expect(text.contains("dump one"))
+        #expect(text.contains("dump two"))
+        #expect(!text.contains("planner_order="))
+        await ClaudeStatusProbe._replaceDumpsForTesting([])
+    }
+
+    @Test
+    func `debug log uses runtime OAuth availability for token account routing`() async throws {
+        let suite = "ClaudeDebugDiagnosticsTests-\(UUID().uuidString)"
+        let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
+        let tempDir = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+        let missingCredentialsURL = tempDir.appendingPathComponent("missing-credentials.json")
+
+        let store = try await MainActor.run { () -> UsageStore in
+            let defaults = try #require(UserDefaults(suiteName: suite))
+            defaults.removePersistentDomain(forName: suite)
+            let configStore = testConfigStore(suiteName: suite)
+            let settings = SettingsStore(
+                userDefaults: defaults,
+                configStore: configStore,
+                zaiTokenStore: NoopZaiTokenStore())
+            settings.claudeUsageDataSource = .auto
+            settings.claudeCookieSource = .off
+            settings.addTokenAccount(
+                provider: .claude,
+                label: "OAuth Account",
+                token: "sk-ant-oat-test-token")
+
+            return UsageStore(
+                fetcher: UsageFetcher(),
+                browserDetection: BrowserDetection(cacheTTL: 0),
+                settings: settings)
+        }
+
+        let text = await ClaudeCLIResolver.withResolvedBinaryPathOverrideForTesting("/definitely/missing/claude") {
+            await KeychainCacheStore.withServiceOverrideForTesting(service) {
+                KeychainCacheStore.setTestStoreForTesting(true)
+                defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+                return await ClaudeOAuthCredentialsStore.withIsolatedMemoryCacheForTesting {
+                    await ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+                        await ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(missingCredentialsURL) {
+                            await ClaudeOAuthCredentialsStore.withKeychainAccessOverrideForTesting(true) {
+                                await ClaudeOAuthCredentialsStore.withClaudeKeychainOverridesForTesting(
+                                    data: nil,
+                                    fingerprint: nil)
+                                {
+                                    await store.debugLog(for: .claude)
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        #expect(text.contains("planner_selected=oauth"))
+        #expect(text.contains("hasOAuthCredentials=true"))
+        #expect(text.contains("oauthCredentialOwner=environment"))
+        #expect(text.contains("oauthCredentialSource=environment"))
+        #expect(!text.contains("planner_selected=none"))
+    }
+
+    @Test
+    func `debug log preserves CLI probe overrides across detached work`() async throws {
+        let suite = "ClaudeDebugDiagnosticsTests-\(UUID().uuidString)"
+        let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
+        let tempDir = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+        let missingCredentialsURL = tempDir.appendingPathComponent("missing-credentials.json")
+        let store = try await MainActor.run { () -> UsageStore in
+            let defaults = try #require(UserDefaults(suiteName: suite))
+            defaults.removePersistentDomain(forName: suite)
+            let configStore = testConfigStore(suiteName: suite)
+            let settings = SettingsStore(
+                userDefaults: defaults,
+                configStore: configStore,
+                zaiTokenStore: NoopZaiTokenStore())
+            settings.claudeUsageDataSource = .cli
+            settings.claudeCookieSource = .off
+
+            return UsageStore(
+                fetcher: UsageFetcher(),
+                browserDetection: BrowserDetection(cacheTTL: 0),
+                settings: settings)
+        }
+
+        let fetchOverride: ClaudeStatusProbe.FetchOverride = { resolved, _, _ in
+            #expect(resolved == "/usr/bin/true")
+            return ClaudeStatusSnapshot(
+                sessionPercentLeft: 76,
+                weeklyPercentLeft: 55,
+                opusPercentLeft: nil,
+                accountEmail: "cli@example.com",
+                accountOrganization: "CLI Org",
+                loginMethod: "cli",
+                primaryResetDescription: "Mar 7 at 1pm",
+                secondaryResetDescription: nil,
+                opusResetDescription: nil,
+                rawText: "probe raw")
+        }
+
+        let text = await ClaudeCLIResolver.withResolvedBinaryPathOverrideForTesting("/usr/bin/true") {
+            await KeychainCacheStore.withServiceOverrideForTesting(service) {
+                KeychainCacheStore.setTestStoreForTesting(true)
+                defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+                return await ClaudeOAuthCredentialsStore.withIsolatedMemoryCacheForTesting {
+                    await ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+                        await ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(missingCredentialsURL) {
+                            await ClaudeOAuthCredentialsStore.withKeychainAccessOverrideForTesting(true) {
+                                await ClaudeOAuthCredentialsStore.withClaudeKeychainOverridesForTesting(
+                                    data: nil,
+                                    fingerprint: nil)
+                                {
+                                    await ClaudeStatusProbe.withFetchOverrideForTesting(fetchOverride) {
+                                        await store.debugLog(for: .claude)
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        #expect(text.contains("planner_selected=cli"))
+        #expect(text.contains("session_left=76.0 weekly_left=55.0"))
+        #expect(text.contains("email cli@example.com"))
+    }
+
+    @Test
+    func `debug log uses user initiated interaction for OAuth prompt gate`() async throws {
+        let suite = "ClaudeDebugDiagnosticsTests-\(UUID().uuidString)"
+        let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
+        let tempDir = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+        let missingCredentialsURL = tempDir.appendingPathComponent("missing-credentials.json")
+        let securityData = self.makeCredentialsData(
+            accessToken: "user-initiated-oauth",
+            expiresAt: Date(timeIntervalSinceNow: 3600))
+        let deniedStore = ClaudeOAuthKeychainAccessGate.DeniedUntilStore()
+        deniedStore.deniedUntil = Date(timeIntervalSinceNow: 300)
+
+        let store = try await MainActor.run { () -> UsageStore in
+            let defaults = try #require(UserDefaults(suiteName: suite))
+            defaults.removePersistentDomain(forName: suite)
+            let configStore = testConfigStore(suiteName: suite)
+            let settings = SettingsStore(
+                userDefaults: defaults,
+                configStore: configStore,
+                zaiTokenStore: NoopZaiTokenStore())
+            settings.claudeUsageDataSource = .auto
+            settings.claudeCookieSource = .off
+
+            return UsageStore(
+                fetcher: UsageFetcher(),
+                browserDetection: BrowserDetection(cacheTTL: 0),
+                settings: settings)
+        }
+
+        let text = await ClaudeCLIResolver.withResolvedBinaryPathOverrideForTesting("/definitely/missing/claude") {
+            await KeychainCacheStore.withServiceOverrideForTesting(service) {
+                KeychainCacheStore.setTestStoreForTesting(true)
+                defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+                return await ClaudeOAuthCredentialsStore.withIsolatedMemoryCacheForTesting {
+                    await ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+                        await ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(missingCredentialsURL) {
+                            await ClaudeOAuthKeychainAccessGate.withDeniedUntilStoreOverrideForTesting(deniedStore) {
+                                await ClaudeOAuthKeychainPromptPreference
+                                    .withTaskOverrideForTesting(.onlyOnUserAction) {
+                                        await ClaudeOAuthKeychainReadStrategyPreference.withTaskOverrideForTesting(
+                                            .securityCLIExperimental)
+                                        {
+                                            await ClaudeOAuthCredentialsStore.withSecurityCLIReadOverrideForTesting(
+                                                .data(securityData))
+                                            {
+                                                await ProviderInteractionContext.$current.withValue(.userInitiated) {
+                                                    await store.debugLog(for: .claude)
+                                                }
+                                            }
+                                        }
+                                    }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        #expect(text.contains("planner_selected=oauth"))
+        #expect(text.contains("hasOAuthCredentials=true"))
+    }
+
+    @Test
+    func `debug log invalidates cached planner output when Claude settings change`() async throws {
+        let suite = "ClaudeDebugDiagnosticsTests-\(UUID().uuidString)"
+        let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
+        let tempDir = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+        let missingCredentialsURL = tempDir.appendingPathComponent("missing-credentials.json")
+        let storeAndSettings = try await MainActor.run { () -> (UsageStore, SettingsStore) in
+            let defaults = try #require(UserDefaults(suiteName: suite))
+            defaults.removePersistentDomain(forName: suite)
+            let configStore = testConfigStore(suiteName: suite)
+            let settings = SettingsStore(
+                userDefaults: defaults,
+                configStore: configStore,
+                zaiTokenStore: NoopZaiTokenStore())
+            settings.claudeUsageDataSource = .cli
+            settings.claudeCookieSource = .off
+
+            let store = UsageStore(
+                fetcher: UsageFetcher(),
+                browserDetection: BrowserDetection(cacheTTL: 0),
+                settings: settings)
+            return (store, settings)
+        }
+        let store = storeAndSettings.0
+        let settings = storeAndSettings.1
+        let fetchOverride: ClaudeStatusProbe.FetchOverride = { _, _, _ in
+            ClaudeStatusSnapshot(
+                sessionPercentLeft: 80,
+                weeklyPercentLeft: 60,
+                opusPercentLeft: nil,
+                accountEmail: "cache@example.com",
+                accountOrganization: nil,
+                loginMethod: "cli",
+                primaryResetDescription: "Mar 7 at 1pm",
+                secondaryResetDescription: nil,
+                opusResetDescription: nil,
+                rawText: "probe raw")
+        }
+
+        let first = await ClaudeCLIResolver.withResolvedBinaryPathOverrideForTesting("/usr/bin/true") {
+            await KeychainCacheStore.withServiceOverrideForTesting(service) {
+                KeychainCacheStore.setTestStoreForTesting(true)
+                defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+                return await ClaudeOAuthCredentialsStore.withIsolatedMemoryCacheForTesting {
+                    await ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+                        await ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(missingCredentialsURL) {
+                            await ClaudeOAuthCredentialsStore.withKeychainAccessOverrideForTesting(false) {
+                                await ClaudeOAuthCredentialsStore.withClaudeKeychainOverridesForTesting(
+                                    data: nil,
+                                    fingerprint: nil)
+                                {
+                                    await ClaudeStatusProbe.withFetchOverrideForTesting(fetchOverride) {
+                                        await store.debugLog(for: .claude)
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        await MainActor.run {
+            settings.claudeUsageDataSource = .auto
+        }
+        await Task.yield()
+        await Task.yield()
+
+        let second = await ClaudeCLIResolver.withResolvedBinaryPathOverrideForTesting("/definitely/missing/claude") {
+            await KeychainCacheStore.withServiceOverrideForTesting(service) {
+                KeychainCacheStore.setTestStoreForTesting(true)
+                defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+                return await ClaudeOAuthCredentialsStore.withIsolatedMemoryCacheForTesting {
+                    await ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+                        await ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(missingCredentialsURL) {
+                            await ClaudeOAuthCredentialsStore.withKeychainAccessOverrideForTesting(true) {
+                                await ClaudeOAuthCredentialsStore.withClaudeKeychainOverridesForTesting(
+                                    data: nil,
+                                    fingerprint: nil)
+                                {
+                                    await store.debugLog(for: .claude)
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        #expect(first.contains("planner_selected=cli"))
+        #expect(second.contains("planner_selected=none"))
+    }
+}
diff --git a/Tests/CodexBarTests/ClaudeDirectUsageFallbackTests.swift b/Tests/CodexBarTests/ClaudeDirectUsageFallbackTests.swift
new file mode 100644
index 0000000000..8b2375ac6a
--- /dev/null
+++ b/Tests/CodexBarTests/ClaudeDirectUsageFallbackTests.swift
@@ -0,0 +1,152 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct ClaudeDirectUsageFallbackTests {
+    private final class InvocationLog: @unchecked Sendable {
+        private let url: URL
+        private let lock = NSLock()
+
+        init(url: URL) {
+            self.url = url
+        }
+
+        func contents() -> String {
+            self.lock.withLock {
+                (try? String(contentsOf: self.url, encoding: .utf8)) ?? ""
+            }
+        }
+    }
+
+    @Test
+    func `cli source falls back to direct usage when pty usage fails to load`() async throws {
+        let cliLogURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent("claude-direct-fallback-log-\(UUID().uuidString).txt")
+        let log = InvocationLog(url: cliLogURL)
+        let fakeCLI = try Self.makeDirectFallbackClaudeCLI(logURL: cliLogURL)
+        let fetcher = ClaudeUsageFetcher(
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            environment: [
+                "CLAUDE_CLI_PATH": fakeCLI.path,
+                ClaudeOAuthCredentialsStore.environmentTokenKey: "oauth-token",
+                ClaudeOAuthCredentialsStore.environmentScopesKey: "user:profile",
+                "ANTHROPIC_ADMIN_KEY": "admin-token",
+            ],
+            dataSource: .cli)
+
+        try await ClaudeCLISession.withIsolatedSessionForTesting {
+            try await ClaudeCLIResolver.withResolvedBinaryPathOverrideForTesting(fakeCLI.path) {
+                do {
+                    _ = try await fetcher.loadLatestUsage(model: "sonnet")
+                    #expect(Bool(false), "Subscription-only usage should fail parsing")
+                } catch let ClaudeUsageError.parseFailed(message) {
+                    #expect(message.lowercased().contains("subscription"))
+                } catch let ClaudeStatusProbeError.parseFailed(message) {
+                    #expect(message.lowercased().contains("subscription"))
+                }
+            }
+        }
+
+        let invocations = log.contents()
+        #expect(invocations.contains("pty-usage"))
+        #expect(invocations.contains("direct-usage"))
+        #expect(!invocations.contains("pty-secret-env"))
+        #expect(!invocations.contains("direct-secret-env"))
+    }
+
+    @Test
+    func `direct usage timeout keeps original pty failure`() async throws {
+        let cliLogURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent("claude-direct-timeout-log-\(UUID().uuidString).txt")
+        let log = InvocationLog(url: cliLogURL)
+        let fakeCLI = try Self.makeDirectTimeoutClaudeCLI(logURL: cliLogURL)
+        let fetcher = ClaudeUsageFetcher(
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            environment: ["CLAUDE_CLI_PATH": fakeCLI.path],
+            dataSource: .cli)
+
+        await ClaudeCLISession.withIsolatedSessionForTesting {
+            await ClaudeCLIResolver.withResolvedBinaryPathOverrideForTesting(fakeCLI.path) {
+                do {
+                    _ = try await fetcher.loadLatestUsage(model: "sonnet")
+                    #expect(Bool(false), "PTY failure should still surface")
+                } catch let ClaudeStatusProbeError.parseFailed(message) {
+                    #expect(message.lowercased().contains("could not load usage data"))
+                } catch {
+                    #expect(Bool(false), "Unexpected error: \(error)")
+                }
+            }
+        }
+
+        let invocations = log.contents()
+        #expect(invocations.contains("pty-usage"))
+        #expect(invocations.contains("direct-usage"))
+    }
+
+    private static func makeDirectFallbackClaudeCLI(logURL: URL) throws -> URL {
+        try self.makeClaudeCLI(name: "claude-direct-fallback", logURL: logURL, scriptBody: """
+        if [ "$1" = "/usage" ]; then
+          printf 'direct-usage\\n' >> "$LOG_FILE"
+          if [ -n "$CODEXBAR_CLAUDE_OAUTH_TOKEN" ] ||
+             [ -n "$CODEXBAR_CLAUDE_OAUTH_SCOPES" ] ||
+             [ -n "$ANTHROPIC_ADMIN_KEY" ]; then
+            printf 'direct-secret-env\\n' >> "$LOG_FILE"
+          fi
+          printf '%s\\n' 'You are currently using your subscription to power your Claude Code usage'
+          exit 0
+        fi
+        while IFS= read -r line; do
+          case "$line" in
+            *"/usage"*)
+              printf 'pty-usage\\n' >> "$LOG_FILE"
+              if [ -n "$CODEXBAR_CLAUDE_OAUTH_TOKEN" ] ||
+                 [ -n "$CODEXBAR_CLAUDE_OAUTH_SCOPES" ] ||
+                 [ -n "$ANTHROPIC_ADMIN_KEY" ]; then
+                printf 'pty-secret-env\\n' >> "$LOG_FILE"
+              fi
+              printf '%s\\n' 'Failed to load usage data'
+              ;;
+            *"/status"*)
+              printf 'pty-status\\n' >> "$LOG_FILE"
+              printf '%s\\n' 'Account: subscription@example.com'
+              ;;
+          esac
+        done
+        """)
+    }
+
+    private static func makeDirectTimeoutClaudeCLI(logURL: URL) throws -> URL {
+        try self.makeClaudeCLI(name: "claude-direct-timeout", logURL: logURL, scriptBody: """
+        if [ "$1" = "/usage" ]; then
+          printf 'direct-usage\\n' >> "$LOG_FILE"
+          sleep 30
+          exit 0
+        fi
+        while IFS= read -r line; do
+          case "$line" in
+            *"/usage"*)
+              printf 'pty-usage\\n' >> "$LOG_FILE"
+              printf '%s\\n' 'Failed to load usage data'
+              ;;
+          esac
+        done
+        """)
+    }
+
+    private static func makeClaudeCLI(name: String, logURL: URL, scriptBody: String) throws -> URL {
+        let directory = FileManager.default.temporaryDirectory
+            .appendingPathComponent("\(name)-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+        let scriptURL = directory.appendingPathComponent("claude")
+        let script = """
+        #!/bin/sh
+        LOG_FILE='\(logURL.path)'
+        \(scriptBody)
+        """
+        try script.write(to: scriptURL, atomically: true, encoding: .utf8)
+        try FileManager.default.setAttributes(
+            [.posixPermissions: NSNumber(value: Int16(0o755))],
+            ofItemAtPath: scriptURL.path)
+        return scriptURL
+    }
+}
diff --git a/Tests/CodexBarTests/ClaudeOAuthCredentialsStoreCLIStorageOwnershipTests.swift b/Tests/CodexBarTests/ClaudeOAuthCredentialsStoreCLIStorageOwnershipTests.swift
new file mode 100644
index 0000000000..fe6664bb1a
--- /dev/null
+++ b/Tests/CodexBarTests/ClaudeOAuthCredentialsStoreCLIStorageOwnershipTests.swift
@@ -0,0 +1,441 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct ClaudeOAuthCredentialsStoreCLIStorageOwnershipTests {
+    private func makeCredentialsData(accessToken: String, expiresAt: Date, refreshToken: String? = nil) -> Data {
+        let millis = Int(expiresAt.timeIntervalSince1970 * 1000)
+        let refreshField: String = {
+            guard let refreshToken else { return "" }
+            return ",\n            \"refreshToken\": \"\(refreshToken)\""
+        }()
+        let json = """
+        {
+          "claudeAiOauth": {
+            "accessToken": "\(accessToken)",
+            "expiresAt": \(millis),
+            "scopes": ["user:profile"]\(refreshField)
+          }
+        }
+        """
+        return Data(json.utf8)
+    }
+
+    private func withClaudeOAuthTokenRefreshStub<T>(
+        handler: @escaping (URLRequest) throws -> (HTTPURLResponse, Data),
+        operation: () async throws -> T) async rethrows -> T
+    {
+        let registered = URLProtocol.registerClass(ClaudeOAuthTokenRefreshStubURLProtocol.self)
+        ClaudeOAuthTokenRefreshStubURLProtocol.reset()
+        ClaudeOAuthTokenRefreshStubURLProtocol.handler = handler
+        defer {
+            if registered {
+                URLProtocol.unregisterClass(ClaudeOAuthTokenRefreshStubURLProtocol.self)
+            }
+            ClaudeOAuthTokenRefreshStubURLProtocol.reset()
+        }
+        return try await operation()
+    }
+
+    private func requestBodyString(_ request: URLRequest) -> String {
+        if let body = request.httpBody {
+            return String(data: body, encoding: .utf8) ?? ""
+        }
+
+        guard let stream = request.httpBodyStream else { return "" }
+        stream.open()
+        defer { stream.close() }
+
+        var data = Data()
+        let bufferSize = 1024
+        let buffer = UnsafeMutablePointer<UInt8>.allocate(capacity: bufferSize)
+        defer { buffer.deallocate() }
+
+        while stream.hasBytesAvailable {
+            let count = stream.read(buffer, maxLength: bufferSize)
+            guard count > 0 else { break }
+            data.append(buffer, count: count)
+        }
+
+        return String(data: data, encoding: .utf8) ?? ""
+    }
+
+    @Test
+    func `successful codexbar refresh is re-owned when Claude CLI storage appears`() async throws {
+        let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
+        try await KeychainCacheStore.withServiceOverrideForTesting(service) {
+            KeychainCacheStore.setTestStoreForTesting(true)
+            defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+            ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting()
+            defer { ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting() }
+
+            let tempDir = FileManager.default.temporaryDirectory
+                .appendingPathComponent(UUID().uuidString, isDirectory: true)
+            try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+            defer { try? FileManager.default.removeItem(at: tempDir) }
+            let fileURL = tempDir.appendingPathComponent("credentials.json")
+            try await ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+                try await ClaudeOAuthCredentialsStore.withIsolatedMemoryCacheForTesting {
+                    try await ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
+                        try await ClaudeOAuthCredentialsStore.withKeychainAccessOverrideForTesting(true) {
+                            ClaudeOAuthCredentialsStore.invalidateCache()
+                            let cacheKey = KeychainCacheStore.Key.oauth(provider: .claude)
+                            defer { KeychainCacheStore.clear(key: cacheKey) }
+
+                            let expiredData = self.makeCredentialsData(
+                                accessToken: "expired-codexbar-only",
+                                expiresAt: Date(timeIntervalSinceNow: -3600),
+                                refreshToken: "cached-refresh-token")
+                            KeychainCacheStore.store(
+                                key: cacheKey,
+                                entry: ClaudeOAuthCredentialsStore.CacheEntry(
+                                    data: expiredData,
+                                    storedAt: Date(timeIntervalSinceNow: 60),
+                                    owner: .codexbar))
+
+                            var tokenRefreshRequestCount = 0
+                            let refreshed = try await self.withClaudeOAuthTokenRefreshStub(handler: { request in
+                                tokenRefreshRequestCount += 1
+                                #expect(request.url?.host == "platform.claude.com")
+                                #expect(request.url?.path == "/v1/oauth/token")
+                                #expect(request.httpMethod == "POST")
+                                #expect(request.value(forHTTPHeaderField: "Accept") == "application/json")
+                                #expect(
+                                    request.value(forHTTPHeaderField: "Content-Type") ==
+                                        "application/x-www-form-urlencoded")
+
+                                let body = self.requestBodyString(request)
+                                #expect(body.contains("grant_type=refresh_token"))
+                                #expect(body.contains("refresh_token=cached-refresh-token"))
+                                #expect(body.contains("client_id=\(ClaudeOAuthCredentialsStore.defaultOAuthClientID)"))
+
+                                let response = try HTTPURLResponse(
+                                    url: #require(request.url),
+                                    statusCode: 200,
+                                    httpVersion: "HTTP/1.1",
+                                    headerFields: ["Content-Type": "application/json"])!
+                                let json = """
+                                {
+                                  "access_token": "fresh-codexbar-token",
+                                  "refresh_token": "fresh-refresh-token",
+                                  "expires_in": 3600,
+                                  "token_type": "Bearer"
+                                }
+                                """
+                                return (response, Data(json.utf8))
+                            }, operation: {
+                                try await ClaudeOAuthRefreshFailureGate.$shouldAttemptOverride.withValue(true) {
+                                    try await ClaudeOAuthCredentialsStore.loadWithAutoRefresh(
+                                        environment: [:],
+                                        allowKeychainPrompt: false,
+                                        respectKeychainPromptCooldown: true)
+                                }
+                            })
+
+                            #expect(refreshed.accessToken == "fresh-codexbar-token")
+                            #expect(refreshed.refreshToken == "fresh-refresh-token")
+                            #expect(tokenRefreshRequestCount == 1)
+
+                            switch KeychainCacheStore.load(
+                                key: cacheKey,
+                                as: ClaudeOAuthCredentialsStore.CacheEntry.self)
+                            {
+                            case let .found(entry):
+                                #expect(entry.owner == .codexbar)
+                                let parsed = try ClaudeOAuthCredentials.parse(data: entry.data)
+                                #expect(parsed.accessToken == "fresh-codexbar-token")
+                                #expect(parsed.refreshToken == "fresh-refresh-token")
+                            default:
+                                Issue.record("Expected refreshed CodexBar-owned cache entry")
+                            }
+
+                            let keychainData = self.makeCredentialsData(
+                                accessToken: "claude-keychain",
+                                expiresAt: Date(timeIntervalSinceNow: 3600),
+                                refreshToken: "keychain-refresh-token")
+
+                            let recordAfterCLIStorageAppears = try ClaudeOAuthCredentialsStore
+                                .withClaudeKeychainOverridesForTesting(data: keychainData, fingerprint: nil) {
+                                    try ClaudeOAuthCredentialsStore.loadRecord(
+                                        environment: [:],
+                                        allowKeychainPrompt: false,
+                                        respectKeychainPromptCooldown: true,
+                                        allowClaudeKeychainRepairWithoutPrompt: false)
+                                }
+
+                            #expect(recordAfterCLIStorageAppears.credentials.accessToken == "fresh-codexbar-token")
+                            #expect(recordAfterCLIStorageAppears.owner == .claudeCLI)
+                            #expect(recordAfterCLIStorageAppears.source == .memoryCache)
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    func `load record treats codexbar cache as claude CLI owned when credentials file exists`() throws {
+        let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
+        try KeychainCacheStore.withServiceOverrideForTesting(service) {
+            KeychainCacheStore.setTestStoreForTesting(true)
+            defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+            ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting()
+            defer { ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting() }
+
+            let tempDir = FileManager.default.temporaryDirectory
+                .appendingPathComponent(UUID().uuidString, isDirectory: true)
+            try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+            let fileURL = tempDir.appendingPathComponent("credentials.json")
+            try ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+                try ClaudeOAuthCredentialsStore.withIsolatedMemoryCacheForTesting {
+                    try ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
+                        try ClaudeOAuthCredentialsStore.withKeychainAccessOverrideForTesting(true) {
+                            ClaudeOAuthCredentialsStore.invalidateCache()
+                            let cacheKey = KeychainCacheStore.Key.oauth(provider: .claude)
+                            defer { KeychainCacheStore.clear(key: cacheKey) }
+
+                            let fileData = self.makeCredentialsData(
+                                accessToken: "claude-cli-file",
+                                expiresAt: Date(timeIntervalSinceNow: 3600),
+                                refreshToken: "cli-refresh-token")
+                            try fileData.write(to: fileURL)
+
+                            let cachedData = self.makeCredentialsData(
+                                accessToken: "codexbar-cache",
+                                expiresAt: Date(timeIntervalSinceNow: 3600),
+                                refreshToken: "cached-refresh-token")
+                            KeychainCacheStore.store(
+                                key: cacheKey,
+                                entry: ClaudeOAuthCredentialsStore.CacheEntry(
+                                    data: cachedData,
+                                    storedAt: Date(timeIntervalSinceNow: 60),
+                                    owner: .codexbar))
+
+                            let record = try ClaudeOAuthCredentialsStore.loadRecord(
+                                environment: [:],
+                                allowKeychainPrompt: false,
+                                respectKeychainPromptCooldown: true,
+                                allowClaudeKeychainRepairWithoutPrompt: false)
+
+                            #expect(record.credentials.accessToken == "codexbar-cache")
+                            #expect(record.owner == .claudeCLI)
+                            #expect(record.source == .cacheKeychain)
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    func `load with auto refresh delegates expired codexbar cache when credentials file exists`() async throws {
+        let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
+        try await KeychainCacheStore.withServiceOverrideForTesting(service) {
+            KeychainCacheStore.setTestStoreForTesting(true)
+            defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+            ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting()
+            defer { ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting() }
+
+            let tempDir = FileManager.default.temporaryDirectory
+                .appendingPathComponent(UUID().uuidString, isDirectory: true)
+            try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+            let fileURL = tempDir.appendingPathComponent("credentials.json")
+            try await ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+                try await ClaudeOAuthCredentialsStore.withIsolatedMemoryCacheForTesting {
+                    try await ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
+                        try await ClaudeOAuthCredentialsStore.withKeychainAccessOverrideForTesting(true) {
+                            ClaudeOAuthCredentialsStore.invalidateCache()
+                            let cacheKey = KeychainCacheStore.Key.oauth(provider: .claude)
+                            defer { KeychainCacheStore.clear(key: cacheKey) }
+
+                            try Data("not valid credentials".utf8).write(to: fileURL)
+
+                            let expiredData = self.makeCredentialsData(
+                                accessToken: "expired-codexbar-with-file",
+                                expiresAt: Date(timeIntervalSinceNow: -3600),
+                                refreshToken: "cached-refresh-token")
+                            KeychainCacheStore.store(
+                                key: cacheKey,
+                                entry: ClaudeOAuthCredentialsStore.CacheEntry(
+                                    data: expiredData,
+                                    storedAt: Date(timeIntervalSinceNow: 60),
+                                    owner: .codexbar))
+
+                            await ClaudeOAuthRefreshFailureGate.$shouldAttemptOverride.withValue(false) {
+                                do {
+                                    _ = try await ClaudeOAuthCredentialsStore.loadWithAutoRefresh(
+                                        environment: [:],
+                                        allowKeychainPrompt: false,
+                                        respectKeychainPromptCooldown: true)
+                                    Issue.record("Expected delegated refresh error when Claude CLI file is present")
+                                } catch let error as ClaudeOAuthCredentialsError {
+                                    guard case .refreshDelegatedToClaudeCLI = error else {
+                                        Issue.record("Expected .refreshDelegatedToClaudeCLI, got \(error)")
+                                        return
+                                    }
+                                } catch {
+                                    Issue.record("Expected ClaudeOAuthCredentialsError, got \(error)")
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    func `load with auto refresh keeps codexbar cache ownership without Claude CLI storage`() async throws {
+        let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
+        try await KeychainCacheStore.withServiceOverrideForTesting(service) {
+            KeychainCacheStore.setTestStoreForTesting(true)
+            defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+            ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting()
+            defer { ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting() }
+
+            let tempDir = FileManager.default.temporaryDirectory
+                .appendingPathComponent(UUID().uuidString, isDirectory: true)
+            try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+            defer { try? FileManager.default.removeItem(at: tempDir) }
+            let fileURL = tempDir.appendingPathComponent("missing-credentials.json")
+            await ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+                await ClaudeOAuthCredentialsStore.withIsolatedMemoryCacheForTesting {
+                    await ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
+                        await ClaudeOAuthCredentialsStore.withKeychainAccessOverrideForTesting(true) {
+                            ClaudeOAuthCredentialsStore.invalidateCache()
+                            let cacheKey = KeychainCacheStore.Key.oauth(provider: .claude)
+                            defer { KeychainCacheStore.clear(key: cacheKey) }
+
+                            let expiredData = self.makeCredentialsData(
+                                accessToken: "expired-codexbar-only",
+                                expiresAt: Date(timeIntervalSinceNow: -3600),
+                                refreshToken: "cached-refresh-token")
+                            KeychainCacheStore.store(
+                                key: cacheKey,
+                                entry: ClaudeOAuthCredentialsStore.CacheEntry(
+                                    data: expiredData,
+                                    storedAt: Date(timeIntervalSinceNow: 60),
+                                    owner: .codexbar))
+
+                            await ClaudeOAuthRefreshFailureGate.$shouldAttemptOverride.withValue(false) {
+                                do {
+                                    _ = try await ClaudeOAuthCredentialsStore.loadWithAutoRefresh(
+                                        environment: [:],
+                                        allowKeychainPrompt: false,
+                                        respectKeychainPromptCooldown: true)
+                                    Issue.record("Expected direct CodexBar refresh failure")
+                                } catch let error as ClaudeOAuthCredentialsError {
+                                    guard case let .refreshFailed(message) = error else {
+                                        Issue.record("Expected .refreshFailed, got \(error)")
+                                        return
+                                    }
+                                    #expect(message.contains("suppressed") || message.contains("backed off"))
+                                } catch {
+                                    Issue.record("Expected ClaudeOAuthCredentialsError, got \(error)")
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    func `load record treats codexbar cache as claude CLI owned when Claude keychain item exists`() throws {
+        let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
+        try KeychainCacheStore.withServiceOverrideForTesting(service) {
+            KeychainCacheStore.setTestStoreForTesting(true)
+            defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+            ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting()
+            defer { ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting() }
+
+            let tempDir = FileManager.default.temporaryDirectory
+                .appendingPathComponent(UUID().uuidString, isDirectory: true)
+            try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+            let fileURL = tempDir.appendingPathComponent("credentials.json")
+            try ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+                try ClaudeOAuthCredentialsStore.withIsolatedMemoryCacheForTesting {
+                    try ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
+                        ClaudeOAuthCredentialsStore.invalidateCache()
+                        let cacheKey = KeychainCacheStore.Key.oauth(provider: .claude)
+                        defer { KeychainCacheStore.clear(key: cacheKey) }
+
+                        let cachedData = self.makeCredentialsData(
+                            accessToken: "codexbar-cache",
+                            expiresAt: Date(timeIntervalSinceNow: 3600),
+                            refreshToken: "cached-refresh-token")
+                        KeychainCacheStore.store(
+                            key: cacheKey,
+                            entry: ClaudeOAuthCredentialsStore.CacheEntry(
+                                data: cachedData,
+                                storedAt: Date(),
+                                owner: .codexbar))
+
+                        let keychainData = self.makeCredentialsData(
+                            accessToken: "claude-keychain",
+                            expiresAt: Date(timeIntervalSinceNow: 3600),
+                            refreshToken: "keychain-refresh-token")
+
+                        let record = try ClaudeOAuthKeychainPromptPreference.withTaskOverrideForTesting(.never) {
+                            try ClaudeOAuthCredentialsStore.withClaudeKeychainOverridesForTesting(
+                                data: keychainData,
+                                fingerprint: nil)
+                            {
+                                try ClaudeOAuthCredentialsStore.loadRecord(
+                                    environment: [:],
+                                    allowKeychainPrompt: false,
+                                    respectKeychainPromptCooldown: true,
+                                    allowClaudeKeychainRepairWithoutPrompt: false)
+                            }
+                        }
+
+                        #expect(record.credentials.accessToken == "codexbar-cache")
+                        #expect(record.owner == .claudeCLI)
+                        #expect(record.source == .cacheKeychain)
+                    }
+                }
+            }
+        }
+    }
+}
+
+private final class ClaudeOAuthTokenRefreshStubURLProtocol: URLProtocol {
+    nonisolated(unsafe) static var handler: ((URLRequest) throws -> (HTTPURLResponse, Data))?
+
+    static func reset() {
+        self.handler = nil
+    }
+
+    override static func canInit(with request: URLRequest) -> Bool {
+        request.url?.host == "platform.claude.com" && request.url?.path == "/v1/oauth/token"
+    }
+
+    override static func canonicalRequest(for request: URLRequest) -> URLRequest {
+        request
+    }
+
+    override func startLoading() {
+        guard let handler = Self.handler else {
+            self.client?.urlProtocol(self, didFailWithError: URLError(.badServerResponse))
+            return
+        }
+
+        do {
+            let (response, data) = try handler(self.request)
+            self.client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
+            self.client?.urlProtocol(self, didLoad: data)
+            self.client?.urlProtocolDidFinishLoading(self)
+        } catch {
+            self.client?.urlProtocol(self, didFailWithError: error)
+        }
+    }
+
+    override func stopLoading() {}
+}
diff --git a/Tests/CodexBarTests/ClaudeOAuthCredentialsStorePromptPolicyTests.swift b/Tests/CodexBarTests/ClaudeOAuthCredentialsStorePromptPolicyTests.swift
index 41ea049f7c..341bc033ac 100644
--- a/Tests/CodexBarTests/ClaudeOAuthCredentialsStorePromptPolicyTests.swift
+++ b/Tests/CodexBarTests/ClaudeOAuthCredentialsStorePromptPolicyTests.swift
@@ -23,7 +23,7 @@ struct ClaudeOAuthCredentialsStorePromptPolicyTests {
     }
 
     @Test
-    func doesNotReadClaudeKeychainInBackgroundWhenPromptModeOnlyOnUserAction() throws {
+    func `does not read claude keychain in background when prompt mode only on user action`() throws {
         let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
         try KeychainCacheStore.withServiceOverrideForTesting(service) {
             try KeychainAccessGate.withTaskOverrideForTesting(false) {
@@ -78,7 +78,7 @@ struct ClaudeOAuthCredentialsStorePromptPolicyTests {
     }
 
     @Test
-    func canReadClaudeKeychainOnUserActionWhenPromptModeOnlyOnUserAction() throws {
+    func `can read claude keychain on user action when prompt mode only on user action`() throws {
         let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
         try KeychainCacheStore.withServiceOverrideForTesting(service) {
             try KeychainAccessGate.withTaskOverrideForTesting(false) {
@@ -127,7 +127,7 @@ struct ClaudeOAuthCredentialsStorePromptPolicyTests {
     }
 
     @Test
-    func doesNotShowPreAlertWhenClaudeKeychainReadableWithoutInteraction() throws {
+    func `does not show pre alert when claude keychain readable without interaction`() throws {
         let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
         try KeychainCacheStore.withServiceOverrideForTesting(service) {
             try KeychainAccessGate.withTaskOverrideForTesting(false) {
@@ -188,7 +188,7 @@ struct ClaudeOAuthCredentialsStorePromptPolicyTests {
     }
 
     @Test
-    func showsPreAlertWhenClaudeKeychainLikelyRequiresInteraction() throws {
+    func `shows pre alert when claude keychain likely requires interaction`() throws {
         let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
         try KeychainCacheStore.withServiceOverrideForTesting(service) {
             try KeychainAccessGate.withTaskOverrideForTesting(false) {
@@ -251,7 +251,7 @@ struct ClaudeOAuthCredentialsStorePromptPolicyTests {
     }
 
     @Test
-    func showsPreAlertWhenClaudeKeychainPreflightFails() throws {
+    func `shows pre alert when claude keychain preflight fails`() throws {
         let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
         try KeychainCacheStore.withServiceOverrideForTesting(service) {
             try KeychainAccessGate.withTaskOverrideForTesting(false) {
@@ -314,7 +314,7 @@ struct ClaudeOAuthCredentialsStorePromptPolicyTests {
     }
 
     @Test
-    func experimentalReader_skipsPreAlertWhenSecurityCLIReadSucceeds() throws {
+    func `experimental reader skips pre alert when security CLI read succeeds`() throws {
         let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
         try KeychainCacheStore.withServiceOverrideForTesting(service) {
             try KeychainAccessGate.withTaskOverrideForTesting(false) {
@@ -376,7 +376,7 @@ struct ClaudeOAuthCredentialsStorePromptPolicyTests {
     }
 
     @Test
-    func experimentalReader_showsPreAlertWhenSecurityCLIFailsAndFallbackNeedsInteraction() throws {
+    func `experimental reader shows pre alert when security CLI fails and fallback needs interaction`() throws {
         let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
         try KeychainCacheStore.withServiceOverrideForTesting(service) {
             try KeychainAccessGate.withTaskOverrideForTesting(false) {
@@ -442,7 +442,7 @@ struct ClaudeOAuthCredentialsStorePromptPolicyTests {
     }
 
     @Test
-    func experimentalReader_doesNotFallbackInBackgroundWhenStoredModeOnlyOnUserAction() throws {
+    func `experimental reader does not fallback in background when stored mode only on user action`() throws {
         let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
         try KeychainCacheStore.withServiceOverrideForTesting(service) {
             try KeychainAccessGate.withTaskOverrideForTesting(false) {
@@ -520,7 +520,7 @@ struct ClaudeOAuthCredentialsStorePromptPolicyTests {
     }
 
     @Test
-    func experimentalReader_doesNotFallbackWhenStoredModeNever() throws {
+    func `experimental reader does not fallback when stored mode never`() throws {
         let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
         try KeychainCacheStore.withServiceOverrideForTesting(service) {
             try KeychainAccessGate.withTaskOverrideForTesting(false) {
@@ -595,7 +595,9 @@ struct ClaudeOAuthCredentialsStorePromptPolicyTests {
     }
 
     @Test
-    func experimentalReader_nonInteractiveFallbackBlockedInBackgroundWhenStoredModeOnlyOnUserAction() throws {
+    func `experimental reader non interactive fallback blocked in background when stored mode only on user action`()
+        throws
+    {
         let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
         try KeychainCacheStore.withServiceOverrideForTesting(service) {
             try KeychainAccessGate.withTaskOverrideForTesting(false) {
@@ -663,7 +665,7 @@ struct ClaudeOAuthCredentialsStorePromptPolicyTests {
     }
 
     @Test
-    func experimentalReader_allowsFallbackInBackgroundWhenStoredModeAlways() throws {
+    func `experimental reader allows fallback in background when stored mode always`() throws {
         let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
         try KeychainCacheStore.withServiceOverrideForTesting(service) {
             try KeychainAccessGate.withTaskOverrideForTesting(false) {
diff --git a/Tests/CodexBarTests/ClaudeOAuthCredentialsStoreSecurityCLIFallbackPolicyTests.swift b/Tests/CodexBarTests/ClaudeOAuthCredentialsStoreSecurityCLIFallbackPolicyTests.swift
index 4db21b4b4e..f2ba54d65f 100644
--- a/Tests/CodexBarTests/ClaudeOAuthCredentialsStoreSecurityCLIFallbackPolicyTests.swift
+++ b/Tests/CodexBarTests/ClaudeOAuthCredentialsStoreSecurityCLIFallbackPolicyTests.swift
@@ -19,7 +19,7 @@ struct ClaudeOAuthCredentialsStoreSecurityCLIFallbackPolicyTests {
     }
 
     @Test
-    func experimentalReader_hasClaudeKeychainCredentialsWithoutPrompt_backgroundFallbackBlockedByStoredPolicy() {
+    func `experimental reader blocks background fallback per stored policy`() {
         let fallbackData = self.makeCredentialsData(
             accessToken: "fallback-should-be-blocked",
             expiresAt: Date(timeIntervalSinceNow: 3600))
@@ -51,7 +51,7 @@ struct ClaudeOAuthCredentialsStoreSecurityCLIFallbackPolicyTests {
     }
 
     @Test
-    func experimentalReader_syncFromClaudeKeychainWithoutPrompt_backgroundFallbackBlockedByStoredPolicy() {
+    func `experimental reader sync from claude keychain without prompt background fallback blocked by stored policy`() {
         let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
         KeychainCacheStore.withServiceOverrideForTesting(service) {
             KeychainAccessGate.withTaskOverrideForTesting(false) {
diff --git a/Tests/CodexBarTests/ClaudeOAuthCredentialsStoreSecurityCLITests.swift b/Tests/CodexBarTests/ClaudeOAuthCredentialsStoreSecurityCLITests.swift
index bfae65a0fd..c9a167f64d 100644
--- a/Tests/CodexBarTests/ClaudeOAuthCredentialsStoreSecurityCLITests.swift
+++ b/Tests/CodexBarTests/ClaudeOAuthCredentialsStoreSecurityCLITests.swift
@@ -23,7 +23,7 @@ struct ClaudeOAuthCredentialsStoreSecurityCLITests {
     }
 
     @Test
-    func experimentalReader_prefersSecurityCLIForNonInteractiveLoad() throws {
+    func `experimental reader prefers security CLI for non interactive load`() throws {
         let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
         try KeychainCacheStore.withServiceOverrideForTesting(service) {
             try KeychainAccessGate.withTaskOverrideForTesting(false) {
@@ -77,7 +77,7 @@ struct ClaudeOAuthCredentialsStoreSecurityCLITests {
     }
 
     @Test
-    func experimentalReader_nonInteractiveBackgroundLoad_stillExecutesSecurityCLIRead() throws {
+    func `experimental reader non interactive background load still executes security CLI read`() throws {
         let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
         try KeychainCacheStore.withServiceOverrideForTesting(service) {
             try KeychainAccessGate.withTaskOverrideForTesting(false) {
@@ -136,7 +136,7 @@ struct ClaudeOAuthCredentialsStoreSecurityCLITests {
     }
 
     @Test
-    func experimentalReader_fallsBackWhenSecurityCLIThrows() throws {
+    func `experimental reader falls back when security CLI throws`() throws {
         let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
         try KeychainCacheStore.withServiceOverrideForTesting(service) {
             try KeychainAccessGate.withTaskOverrideForTesting(false) {
@@ -193,7 +193,7 @@ struct ClaudeOAuthCredentialsStoreSecurityCLITests {
     }
 
     @Test
-    func experimentalReader_fallsBackWhenSecurityCLIOutputMalformed() throws {
+    func `experimental reader falls back when security CLI output malformed`() throws {
         let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
         try KeychainCacheStore.withServiceOverrideForTesting(service) {
             try KeychainAccessGate.withTaskOverrideForTesting(false) {
@@ -249,7 +249,7 @@ struct ClaudeOAuthCredentialsStoreSecurityCLITests {
     }
 
     @Test
-    func experimentalReader_loadFromClaudeKeychainUsesSecurityCLI() throws {
+    func `experimental reader load from claude keychain uses security CLI`() throws {
         let securityData = self.makeCredentialsData(
             accessToken: "security-direct",
             expiresAt: Date(timeIntervalSinceNow: 3600),
@@ -292,7 +292,7 @@ struct ClaudeOAuthCredentialsStoreSecurityCLITests {
     }
 
     @Test
-    func experimentalReader_hasClaudeKeychainCredentialsWithoutPrompt_usesSecurityCLI() {
+    func `experimental reader has claude keychain credentials without prompt uses security CLI`() {
         let securityData = self.makeCredentialsData(
             accessToken: "security-available",
             expiresAt: Date(timeIntervalSinceNow: 3600))
@@ -317,7 +317,7 @@ struct ClaudeOAuthCredentialsStoreSecurityCLITests {
     }
 
     @Test
-    func experimentalReader_hasClaudeKeychainCredentialsWithoutPrompt_fallsBackWhenSecurityCLIFails() {
+    func `experimental reader has claude keychain credentials without prompt falls back when security CLI fails`() {
         let fallbackData = self.makeCredentialsData(
             accessToken: "fallback-available",
             expiresAt: Date(timeIntervalSinceNow: 3600))
@@ -347,7 +347,7 @@ struct ClaudeOAuthCredentialsStoreSecurityCLITests {
     }
 
     @Test
-    func experimentalReader_ignoresPromptPolicyAndCooldownForBackgroundSilentCheck() {
+    func `experimental reader ignores prompt policy and cooldown for background silent check`() {
         let securityData = self.makeCredentialsData(
             accessToken: "security-background",
             expiresAt: Date(timeIntervalSinceNow: 3600))
@@ -376,7 +376,7 @@ struct ClaudeOAuthCredentialsStoreSecurityCLITests {
     }
 
     @Test
-    func experimentalReader_loadFromClaudeKeychainFallbackBlockedWhenStoredModeNever() throws {
+    func `experimental reader load from claude keychain fallback blocked when stored mode never`() throws {
         var threwNotFound = false
         do {
             _ = try KeychainAccessGate.withTaskOverrideForTesting(false) {
@@ -406,7 +406,7 @@ struct ClaudeOAuthCredentialsStoreSecurityCLITests {
     }
 
     @Test
-    func experimentalReader_securityCLIRead_pinsPreferredAccountWhenAvailable() throws {
+    func `experimental reader security CLI read pins preferred account when available`() throws {
         let securityData = self.makeCredentialsData(
             accessToken: "security-account-pinned",
             expiresAt: Date(timeIntervalSinceNow: 3600))
@@ -441,7 +441,7 @@ struct ClaudeOAuthCredentialsStoreSecurityCLITests {
     }
 
     @Test
-    func experimentalReader_securityCLIRead_doesNotPinAccountInBackground() throws {
+    func `experimental reader security CLI read does not pin account in background`() throws {
         let securityData = self.makeCredentialsData(
             accessToken: "security-account-not-pinned",
             expiresAt: Date(timeIntervalSinceNow: 3600))
@@ -476,7 +476,7 @@ struct ClaudeOAuthCredentialsStoreSecurityCLITests {
     }
 
     @Test
-    func experimentalReader_freshnessSync_skipsSecurityCLIWhenPreflightRequiresInteraction() throws {
+    func `experimental reader freshness sync skips security CLI when preflight requires interaction`() throws {
         let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
         try KeychainCacheStore.withServiceOverrideForTesting(service) {
             try KeychainAccessGate.withTaskOverrideForTesting(false) {
@@ -484,63 +484,67 @@ struct ClaudeOAuthCredentialsStoreSecurityCLITests {
                 defer { KeychainCacheStore.setTestStoreForTesting(false) }
 
                 try ClaudeOAuthCredentialsStore.withIsolatedMemoryCacheForTesting {
-                    ClaudeOAuthCredentialsStore.invalidateCache()
-                    ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting()
-                    defer {
+                    try ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
                         ClaudeOAuthCredentialsStore.invalidateCache()
                         ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting()
-                    }
-
-                    let tempDir = FileManager.default.temporaryDirectory
-                        .appendingPathComponent(UUID().uuidString, isDirectory: true)
-                    try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
-                    let fileURL = tempDir.appendingPathComponent("credentials.json")
-                    try ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
-                        let securityData = self.makeCredentialsData(
-                            accessToken: "security-sync",
-                            expiresAt: Date(timeIntervalSinceNow: 3600))
-                        final class ReadCounter: @unchecked Sendable {
-                            var count = 0
+                        defer {
+                            ClaudeOAuthCredentialsStore.invalidateCache()
+                            ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting()
                         }
-                        let securityReadCalls = ReadCounter()
 
-                        func loadWithPreflight(
-                            _ outcome: KeychainAccessPreflight.Outcome) throws -> ClaudeOAuthCredentials
-                        {
-                            let preflightOverride: (String, String?) -> KeychainAccessPreflight.Outcome = { _, _ in
-                                outcome
+                        let tempDir = FileManager.default.temporaryDirectory
+                            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+                        try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+                        let fileURL = tempDir.appendingPathComponent("credentials.json")
+                        try ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
+                            let securityData = self.makeCredentialsData(
+                                accessToken: "security-sync",
+                                expiresAt: Date(timeIntervalSinceNow: 3600))
+                            final class ReadCounter: @unchecked Sendable {
+                                var count = 0
                             }
-                            return try KeychainAccessPreflight.withCheckGenericPasswordOverrideForTesting(
-                                preflightOverride,
-                                operation: {
-                                    try ClaudeOAuthKeychainReadStrategyPreference.withTaskOverrideForTesting(
-                                        .securityCLIExperimental)
-                                    {
-                                        try ClaudeOAuthKeychainPromptPreference.withTaskOverrideForTesting(.always) {
-                                            try ProviderInteractionContext.$current.withValue(.background) {
-                                                try ClaudeOAuthCredentialsStore.withSecurityCLIReadOverrideForTesting(
-                                                    .dynamic { _ in
-                                                        securityReadCalls.count += 1
-                                                        return securityData
-                                                    }) {
-                                                        try ClaudeOAuthCredentialsStore.load(
-                                                            environment: [:],
-                                                            allowKeychainPrompt: false,
-                                                            respectKeychainPromptCooldown: true)
+                            let securityReadCalls = ReadCounter()
+
+                            func loadWithPreflight(
+                                _ outcome: KeychainAccessPreflight.Outcome) throws -> ClaudeOAuthCredentials
+                            {
+                                let preflightOverride: (String, String?) -> KeychainAccessPreflight.Outcome = { _, _ in
+                                    outcome
+                                }
+                                return try KeychainAccessPreflight.withCheckGenericPasswordOverrideForTesting(
+                                    preflightOverride,
+                                    operation: {
+                                        try ClaudeOAuthKeychainReadStrategyPreference.withTaskOverrideForTesting(
+                                            .securityCLIExperimental)
+                                        {
+                                            try ClaudeOAuthKeychainPromptPreference
+                                                .withTaskOverrideForTesting(.always) {
+                                                    try ProviderInteractionContext.$current.withValue(.background) {
+                                                        try ClaudeOAuthCredentialsStore
+                                                            .withSecurityCLIReadOverrideForTesting(
+                                                                .dynamic { _ in
+                                                                    securityReadCalls.count += 1
+                                                                    return securityData
+                                                                }) {
+                                                                    try ClaudeOAuthCredentialsStore.load(
+                                                                        environment: [:],
+                                                                        allowKeychainPrompt: false,
+                                                                        respectKeychainPromptCooldown: true)
+                                                            }
                                                     }
-                                            }
+                                                }
                                         }
-                                    }
-                                })
-                        }
+                                    })
+                            }
 
-                        let first = try loadWithPreflight(.allowed)
-                        #expect(first.accessToken == "security-sync")
-                        #expect(securityReadCalls.count == 1)
+                            let first = try loadWithPreflight(.allowed)
+                            #expect(first.accessToken == "security-sync")
+                            #expect(securityReadCalls.count == 1)
 
-                        let second = try loadWithPreflight(.interactionRequired)
-                        #expect(second.accessToken == "security-sync")
-                        #expect(securityReadCalls.count == 1)
+                            let second = try loadWithPreflight(.interactionRequired)
+                            #expect(second.accessToken == "security-sync")
+                            #expect(securityReadCalls.count == 1)
+                        }
                     }
                 }
             }
@@ -548,7 +552,7 @@ struct ClaudeOAuthCredentialsStoreSecurityCLITests {
     }
 
     @Test
-    func experimentalReader_freshnessSync_background_respectsStoredOnlyOnUserAction() throws {
+    func `experimental reader freshness sync background respects stored only on user action`() throws {
         let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
         try KeychainCacheStore.withServiceOverrideForTesting(service) {
             try KeychainAccessGate.withTaskOverrideForTesting(false) {
@@ -556,63 +560,66 @@ struct ClaudeOAuthCredentialsStoreSecurityCLITests {
                 defer { KeychainCacheStore.setTestStoreForTesting(false) }
 
                 try ClaudeOAuthCredentialsStore.withIsolatedMemoryCacheForTesting {
-                    ClaudeOAuthCredentialsStore.invalidateCache()
-                    ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting()
-                    defer {
+                    try ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
                         ClaudeOAuthCredentialsStore.invalidateCache()
                         ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting()
-                    }
-
-                    let tempDir = FileManager.default.temporaryDirectory
-                        .appendingPathComponent(UUID().uuidString, isDirectory: true)
-                    try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
-                    let fileURL = tempDir.appendingPathComponent("credentials.json")
-                    try ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
-                        let securityData = self.makeCredentialsData(
-                            accessToken: "security-sync-only-on-user-action",
-                            expiresAt: Date(timeIntervalSinceNow: 3600))
-                        final class ReadCounter: @unchecked Sendable {
-                            var count = 0
-                        }
-                        let securityReadCalls = ReadCounter()
-                        let preflightOverride: (String, String?) -> KeychainAccessPreflight.Outcome = { _, _ in
-                            .allowed
+                        defer {
+                            ClaudeOAuthCredentialsStore.invalidateCache()
+                            ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting()
                         }
 
-                        func load(_ interaction: ProviderInteraction) throws -> ClaudeOAuthCredentials {
-                            try KeychainAccessPreflight.withCheckGenericPasswordOverrideForTesting(
-                                preflightOverride,
-                                operation: {
-                                    try ClaudeOAuthKeychainReadStrategyPreference.withTaskOverrideForTesting(
-                                        .securityCLIExperimental)
-                                    {
-                                        try ClaudeOAuthKeychainPromptPreference.withTaskOverrideForTesting(
-                                            .onlyOnUserAction)
+                        let tempDir = FileManager.default.temporaryDirectory
+                            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+                        try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+                        let fileURL = tempDir.appendingPathComponent("credentials.json")
+                        try ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
+                            let securityData = self.makeCredentialsData(
+                                accessToken: "security-sync-only-on-user-action",
+                                expiresAt: Date(timeIntervalSinceNow: 3600))
+                            final class ReadCounter: @unchecked Sendable {
+                                var count = 0
+                            }
+                            let securityReadCalls = ReadCounter()
+                            let preflightOverride: (String, String?) -> KeychainAccessPreflight.Outcome = { _, _ in
+                                .allowed
+                            }
+
+                            func load(_ interaction: ProviderInteraction) throws -> ClaudeOAuthCredentials {
+                                try KeychainAccessPreflight.withCheckGenericPasswordOverrideForTesting(
+                                    preflightOverride,
+                                    operation: {
+                                        try ClaudeOAuthKeychainReadStrategyPreference.withTaskOverrideForTesting(
+                                            .securityCLIExperimental)
                                         {
-                                            try ProviderInteractionContext.$current.withValue(interaction) {
-                                                try ClaudeOAuthCredentialsStore.withSecurityCLIReadOverrideForTesting(
-                                                    .dynamic { _ in
-                                                        securityReadCalls.count += 1
-                                                        return securityData
-                                                    }) {
-                                                        try ClaudeOAuthCredentialsStore.load(
-                                                            environment: [:],
-                                                            allowKeychainPrompt: false,
-                                                            respectKeychainPromptCooldown: true)
-                                                    }
+                                            try ClaudeOAuthKeychainPromptPreference.withTaskOverrideForTesting(
+                                                .onlyOnUserAction)
+                                            {
+                                                try ProviderInteractionContext.$current.withValue(interaction) {
+                                                    try ClaudeOAuthCredentialsStore
+                                                        .withSecurityCLIReadOverrideForTesting(
+                                                            .dynamic { _ in
+                                                                securityReadCalls.count += 1
+                                                                return securityData
+                                                            }) {
+                                                                try ClaudeOAuthCredentialsStore.load(
+                                                                    environment: [:],
+                                                                    allowKeychainPrompt: false,
+                                                                    respectKeychainPromptCooldown: true)
+                                                        }
+                                                }
                                             }
                                         }
-                                    }
-                                })
-                        }
+                                    })
+                            }
 
-                        let first = try load(.userInitiated)
-                        #expect(first.accessToken == "security-sync-only-on-user-action")
-                        #expect(securityReadCalls.count == 1)
+                            let first = try load(.userInitiated)
+                            #expect(first.accessToken == "security-sync-only-on-user-action")
+                            #expect(securityReadCalls.count == 1)
 
-                        let second = try load(.background)
-                        #expect(second.accessToken == "security-sync-only-on-user-action")
-                        #expect(securityReadCalls.count == 1)
+                            let second = try load(.background)
+                            #expect(second.accessToken == "security-sync-only-on-user-action")
+                            #expect(securityReadCalls.count == 1)
+                        }
                     }
                 }
             }
@@ -620,7 +627,7 @@ struct ClaudeOAuthCredentialsStoreSecurityCLITests {
     }
 
     @Test
-    func experimentalReader_syncFromClaudeKeychainWithoutPrompt_skipsFingerprintProbeAfterSecurityCLIRead() {
+    func `experimental reader sync skips fingerprint probe after security CLI read`() {
         let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
         KeychainCacheStore.withServiceOverrideForTesting(service) {
             KeychainAccessGate.withTaskOverrideForTesting(false) {
@@ -672,7 +679,7 @@ struct ClaudeOAuthCredentialsStoreSecurityCLITests {
     }
 
     @Test
-    func experimentalReader_noPromptRepair_skipsFingerprintProbeAfterSecurityCLISuccess() throws {
+    func `experimental reader no prompt repair skips fingerprint probe after security CLI success`() throws {
         let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
         try KeychainCacheStore.withServiceOverrideForTesting(service) {
             try KeychainAccessGate.withTaskOverrideForTesting(false) {
@@ -686,57 +693,63 @@ struct ClaudeOAuthCredentialsStoreSecurityCLITests {
                     ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting()
                 }
 
-                let tempDir = FileManager.default.temporaryDirectory
-                    .appendingPathComponent(UUID().uuidString, isDirectory: true)
-                try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
-                let fileURL = tempDir.appendingPathComponent("credentials.json")
-                try ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
-                    let securityData = self.makeCredentialsData(
-                        accessToken: "security-repair-no-fingerprint-probe",
-                        expiresAt: Date(timeIntervalSinceNow: 3600))
-                    let fingerprintStore = ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprintStore()
-                    let sentinelFingerprint = ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
-                        modifiedAt: 456,
-                        createdAt: 455,
-                        persistentRefHash: "sentinel")
-
-                    let record = try ClaudeOAuthKeychainReadStrategyPreference.withTaskOverrideForTesting(
-                        .securityCLIExperimental,
-                        operation: {
-                            try ClaudeOAuthKeychainPromptPreference.withTaskOverrideForTesting(.always) {
-                                try ProviderInteractionContext.$current.withValue(.background) {
-                                    try ClaudeOAuthCredentialsStore
-                                        .withClaudeKeychainFingerprintStoreOverrideForTesting(
-                                            fingerprintStore)
-                                        {
-                                            try ClaudeOAuthCredentialsStore.withClaudeKeychainOverridesForTesting(
-                                                data: nil,
-                                                fingerprint: sentinelFingerprint)
-                                            {
-                                                try ClaudeOAuthCredentialsStore.withSecurityCLIReadOverrideForTesting(
-                                                    .data(securityData))
+                try ClaudeOAuthCredentialsStore.withIsolatedMemoryCacheForTesting {
+                    try ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+                        let tempDir = FileManager.default.temporaryDirectory
+                            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+                        try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+                        let fileURL = tempDir.appendingPathComponent("credentials.json")
+                        try ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
+                            let securityData = self.makeCredentialsData(
+                                accessToken: "security-repair-no-fingerprint-probe",
+                                expiresAt: Date(timeIntervalSinceNow: 3600))
+                            let fingerprintStore = ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprintStore()
+                            let sentinelFingerprint = ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
+                                modifiedAt: 456,
+                                createdAt: 455,
+                                persistentRefHash: "sentinel")
+
+                            let record = try ClaudeOAuthKeychainReadStrategyPreference.withTaskOverrideForTesting(
+                                .securityCLIExperimental,
+                                operation: {
+                                    try ClaudeOAuthKeychainPromptPreference.withTaskOverrideForTesting(.always) {
+                                        try ProviderInteractionContext.$current.withValue(.background) {
+                                            try ClaudeOAuthCredentialsStore
+                                                .withClaudeKeychainFingerprintStoreOverrideForTesting(
+                                                    fingerprintStore)
                                                 {
-                                                    try ClaudeOAuthCredentialsStore.loadRecord(
-                                                        environment: [:],
-                                                        allowKeychainPrompt: false,
-                                                        respectKeychainPromptCooldown: true)
+                                                    try ClaudeOAuthCredentialsStore
+                                                        .withClaudeKeychainOverridesForTesting(
+                                                            data: nil,
+                                                            fingerprint: sentinelFingerprint)
+                                                        {
+                                                            try ClaudeOAuthCredentialsStore
+                                                                .withSecurityCLIReadOverrideForTesting(
+                                                                    .data(securityData))
+                                                                {
+                                                                    try ClaudeOAuthCredentialsStore.loadRecord(
+                                                                        environment: [:],
+                                                                        allowKeychainPrompt: false,
+                                                                        respectKeychainPromptCooldown: true)
+                                                                }
+                                                        }
                                                 }
-                                            }
                                         }
-                                }
-                            }
-                        })
+                                    }
+                                })
 
-                    #expect(record.credentials.accessToken == "security-repair-no-fingerprint-probe")
-                    #expect(record.source == .claudeKeychain)
-                    #expect(fingerprintStore.fingerprint == nil)
+                            #expect(record.credentials.accessToken == "security-repair-no-fingerprint-probe")
+                            #expect(record.source == .claudeKeychain)
+                            #expect(fingerprintStore.fingerprint == nil)
+                        }
+                    }
                 }
             }
         }
     }
 
     @Test
-    func experimentalReader_loadWithPrompt_skipsFingerprintProbeAfterSecurityCLISuccess() throws {
+    func `experimental reader load with prompt skips fingerprint probe after security CLI success`() throws {
         let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
         try KeychainCacheStore.withServiceOverrideForTesting(service) {
             try KeychainAccessGate.withTaskOverrideForTesting(false) {
@@ -750,57 +763,62 @@ struct ClaudeOAuthCredentialsStoreSecurityCLITests {
                     ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting()
                 }
 
-                let tempDir = FileManager.default.temporaryDirectory
-                    .appendingPathComponent(UUID().uuidString, isDirectory: true)
-                try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
-                let fileURL = tempDir.appendingPathComponent("credentials.json")
-                try ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
-                    let securityData = self.makeCredentialsData(
-                        accessToken: "security-load-with-prompt",
-                        expiresAt: Date(timeIntervalSinceNow: 3600))
-                    let fingerprintStore = ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprintStore()
-                    let sentinelFingerprint = ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
-                        modifiedAt: 321,
-                        createdAt: 320,
-                        persistentRefHash: "sentinel")
-
-                    let creds = try ClaudeOAuthKeychainReadStrategyPreference.withTaskOverrideForTesting(
-                        .securityCLIExperimental,
-                        operation: {
-                            try ClaudeOAuthKeychainPromptPreference.withTaskOverrideForTesting(.always) {
-                                try ProviderInteractionContext.$current.withValue(.userInitiated) {
-                                    try ClaudeOAuthCredentialsStore
-                                        .withClaudeKeychainFingerprintStoreOverrideForTesting(
-                                            fingerprintStore)
-                                        {
-                                            try ClaudeOAuthCredentialsStore.withClaudeKeychainOverridesForTesting(
-                                                data: nil,
-                                                fingerprint: sentinelFingerprint)
-                                            {
-                                                try ClaudeOAuthCredentialsStore
-                                                    .withSecurityCLIReadOverrideForTesting(
-                                                        .data(securityData))
-                                                    {
-                                                        try ClaudeOAuthCredentialsStore.load(
-                                                            environment: [:],
-                                                            allowKeychainPrompt: true,
-                                                            respectKeychainPromptCooldown: false)
-                                                    }
-                                            }
+                try ClaudeOAuthCredentialsStore.withIsolatedMemoryCacheForTesting {
+                    try ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+                        let tempDir = FileManager.default.temporaryDirectory
+                            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+                        try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+                        let fileURL = tempDir.appendingPathComponent("credentials.json")
+                        try ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
+                            let securityData = self.makeCredentialsData(
+                                accessToken: "security-load-with-prompt",
+                                expiresAt: Date(timeIntervalSinceNow: 3600))
+                            let fingerprintStore = ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprintStore()
+                            let sentinelFingerprint = ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
+                                modifiedAt: 321,
+                                createdAt: 320,
+                                persistentRefHash: "sentinel")
+
+                            let creds = try ClaudeOAuthKeychainReadStrategyPreference.withTaskOverrideForTesting(
+                                .securityCLIExperimental,
+                                operation: {
+                                    try ClaudeOAuthKeychainPromptPreference.withTaskOverrideForTesting(.always) {
+                                        try ProviderInteractionContext.$current.withValue(.userInitiated) {
+                                            try ClaudeOAuthCredentialsStore
+                                                .withClaudeKeychainFingerprintStoreOverrideForTesting(
+                                                    fingerprintStore)
+                                                {
+                                                    try ClaudeOAuthCredentialsStore
+                                                        .withClaudeKeychainOverridesForTesting(
+                                                            data: nil,
+                                                            fingerprint: sentinelFingerprint)
+                                                        {
+                                                            try ClaudeOAuthCredentialsStore
+                                                                .withSecurityCLIReadOverrideForTesting(
+                                                                    .data(securityData))
+                                                                {
+                                                                    try ClaudeOAuthCredentialsStore.load(
+                                                                        environment: [:],
+                                                                        allowKeychainPrompt: true,
+                                                                        respectKeychainPromptCooldown: false)
+                                                                }
+                                                        }
+                                                }
                                         }
-                                }
-                            }
-                        })
+                                    }
+                                })
 
-                    #expect(creds.accessToken == "security-load-with-prompt")
-                    #expect(fingerprintStore.fingerprint == nil)
+                            #expect(creds.accessToken == "security-load-with-prompt")
+                            #expect(fingerprintStore.fingerprint == nil)
+                        }
+                    }
                 }
             }
         }
     }
 
     @Test
-    func experimentalReader_loadWithPrompt_doesNotReadWhenGlobalKeychainDisabled() throws {
+    func `experimental reader load with prompt does not read when global keychain disabled`() throws {
         let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
         try KeychainCacheStore.withServiceOverrideForTesting(service) {
             try KeychainAccessGate.withTaskOverrideForTesting(true) {
diff --git a/Tests/CodexBarTests/ClaudeOAuthCredentialsStoreTemporaryKeychainCacheTests.swift b/Tests/CodexBarTests/ClaudeOAuthCredentialsStoreTemporaryKeychainCacheTests.swift
new file mode 100644
index 0000000000..b9e0630f55
--- /dev/null
+++ b/Tests/CodexBarTests/ClaudeOAuthCredentialsStoreTemporaryKeychainCacheTests.swift
@@ -0,0 +1,237 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct ClaudeOAuthCredentialsStoreTemporaryKeychainCacheTests {
+    private struct WrongCacheEntry: Codable {
+        let value: String
+    }
+
+    private func makeCredentialsData(accessToken: String, expiresAt: Date, refreshToken: String? = nil) -> Data {
+        let millis = Int(expiresAt.timeIntervalSince1970 * 1000)
+        let refreshField: String = {
+            guard let refreshToken else { return "" }
+            return ",\n            \"refreshToken\": \"\(refreshToken)\""
+        }()
+        let json = """
+        {
+          "claudeAiOauth": {
+            "accessToken": "\(accessToken)",
+            "expiresAt": \(millis),
+            "scopes": ["user:profile"]\(refreshField)
+          }
+        }
+        """
+        return Data(json.utf8)
+    }
+
+    #if os(macOS)
+    @Test
+    func `credentials file invalidation preserves keychain cache when temporarily unavailable`() throws {
+        let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
+        try KeychainCacheStore.withServiceOverrideForTesting(service) {
+            KeychainCacheStore.setTestStoreForTesting(true)
+            defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+            try ClaudeOAuthCredentialsStore.withIsolatedMemoryCacheForTesting {
+                try ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+                    ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting()
+                    defer { ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting() }
+
+                    let tempDir = FileManager.default.temporaryDirectory
+                        .appendingPathComponent(UUID().uuidString, isDirectory: true)
+                    try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+                    let fileURL = tempDir.appendingPathComponent("credentials.json")
+                    try ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
+                        let firstFile = self.makeCredentialsData(
+                            accessToken: "first-file",
+                            expiresAt: Date(timeIntervalSinceNow: 3600))
+                        try firstFile.write(to: fileURL)
+                        #expect(ClaudeOAuthCredentialsStore.invalidateCacheIfCredentialsFileChanged())
+
+                        let cacheKey = KeychainCacheStore.Key.oauth(provider: .claude)
+                        let cachedData = self.makeCredentialsData(
+                            accessToken: "cached-token",
+                            expiresAt: Date(timeIntervalSinceNow: 3600))
+                        KeychainCacheStore.store(
+                            key: cacheKey,
+                            entry: ClaudeOAuthCredentialsStore.CacheEntry(
+                                data: cachedData,
+                                storedAt: Date(),
+                                owner: .claudeCLI))
+                        defer { KeychainCacheStore.clear(key: cacheKey) }
+
+                        let updatedFile = self.makeCredentialsData(
+                            accessToken: "updated-file-token-longer",
+                            expiresAt: Date(timeIntervalSinceNow: 3600))
+                        try updatedFile.write(to: fileURL)
+
+                        KeychainCacheStore.withLoadFailureStatusOverrideForTesting(errSecInteractionNotAllowed) {
+                            #expect(ClaudeOAuthCredentialsStore.invalidateCacheIfCredentialsFileChanged())
+                        }
+
+                        switch KeychainCacheStore.load(
+                            key: cacheKey,
+                            as: ClaudeOAuthCredentialsStore.CacheEntry.self)
+                        {
+                        case let .found(entry):
+                            let parsed = try ClaudeOAuthCredentials.parse(data: entry.data)
+                            #expect(parsed.accessToken == "cached-token")
+                        case .missing, .temporarilyUnavailable, .invalid:
+                            #expect(Bool(false), "Expected temporary unavailability not to clear Claude cache")
+                        }
+
+                        #expect(ClaudeOAuthCredentialsStore.invalidateCacheIfCredentialsFileChanged())
+
+                        switch KeychainCacheStore.load(
+                            key: cacheKey,
+                            as: ClaudeOAuthCredentialsStore.CacheEntry.self)
+                        {
+                        case .missing:
+                            #expect(true)
+                        case .found, .temporarilyUnavailable, .invalid:
+                            #expect(Bool(false), "Expected pending invalidation to clear stale Claude cache")
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    func `temporary keychain cache unavailability does not overwrite cache from credentials file fallback`() throws {
+        let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
+        try KeychainCacheStore.withServiceOverrideForTesting(service) {
+            try KeychainAccessGate.withTaskOverrideForTesting(true) {
+                KeychainCacheStore.setTestStoreForTesting(true)
+                defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+                try ClaudeOAuthCredentialsStore.withIsolatedMemoryCacheForTesting {
+                    try ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+                        ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting()
+                        defer { ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting() }
+
+                        let tempDir = FileManager.default.temporaryDirectory
+                            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+                        try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+                        let fileURL = tempDir.appendingPathComponent("credentials.json")
+                        try ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
+                            let fileData = self.makeCredentialsData(
+                                accessToken: "file-fallback-token",
+                                expiresAt: Date(timeIntervalSinceNow: 3600))
+                            try fileData.write(to: fileURL)
+
+                            let cacheKey = KeychainCacheStore.Key.oauth(provider: .claude)
+                            let cachedData = self.makeCredentialsData(
+                                accessToken: "cached-token",
+                                expiresAt: Date(timeIntervalSinceNow: 3600))
+                            KeychainCacheStore.store(
+                                key: cacheKey,
+                                entry: ClaudeOAuthCredentialsStore.CacheEntry(
+                                    data: cachedData,
+                                    storedAt: Date(),
+                                    owner: .claudeCLI))
+                            defer { KeychainCacheStore.clear(key: cacheKey) }
+
+                            let loaded = try KeychainCacheStore.withLoadFailureStatusOverrideForTesting(
+                                errSecInteractionNotAllowed)
+                            {
+                                try ClaudeOAuthCredentialsStore.load(environment: [:], allowKeychainPrompt: false)
+                            }
+                            #expect(loaded.accessToken == "file-fallback-token")
+
+                            switch KeychainCacheStore.load(
+                                key: cacheKey,
+                                as: ClaudeOAuthCredentialsStore.CacheEntry.self)
+                            {
+                            case let .found(entry):
+                                let parsed = try ClaudeOAuthCredentials.parse(data: entry.data)
+                                #expect(parsed.accessToken == "cached-token")
+                            case .missing, .temporarilyUnavailable, .invalid:
+                                #expect(Bool(false), "Expected file fallback not to overwrite unavailable cache")
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    func `has cached credentials treats temporary keychain cache unavailability as present`() {
+        let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
+        KeychainCacheStore.withServiceOverrideForTesting(service) {
+            KeychainCacheStore.setTestStoreForTesting(true)
+            defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+            ClaudeOAuthCredentialsStore.withIsolatedMemoryCacheForTesting {
+                ClaudeOAuthCredentialsStore.invalidateCache()
+                let cacheKey = KeychainCacheStore.Key.oauth(provider: .claude)
+                let cachedData = self.makeCredentialsData(
+                    accessToken: "cached-token",
+                    expiresAt: Date(timeIntervalSinceNow: 3600))
+                KeychainCacheStore.store(
+                    key: cacheKey,
+                    entry: ClaudeOAuthCredentialsStore.CacheEntry(data: cachedData, storedAt: Date()))
+                defer { KeychainCacheStore.clear(key: cacheKey) }
+
+                let hasCached = KeychainCacheStore.withLoadFailureStatusOverrideForTesting(
+                    errSecInteractionNotAllowed)
+                {
+                    ClaudeOAuthCredentialsStore.hasCachedCredentials(environment: [:])
+                }
+
+                #expect(hasCached == true)
+            }
+        }
+    }
+    #endif
+
+    @Test
+    func `invalid keychain cache is cleared by load`() throws {
+        let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
+        try KeychainCacheStore.withServiceOverrideForTesting(service) {
+            try KeychainAccessGate.withTaskOverrideForTesting(true) {
+                KeychainCacheStore.setTestStoreForTesting(true)
+                defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+                ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting()
+                defer { ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting() }
+
+                try ClaudeOAuthCredentialsStore.withIsolatedMemoryCacheForTesting {
+                    try ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+                        let tempDir = FileManager.default.temporaryDirectory
+                            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+                        try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+                        let fileURL = tempDir.appendingPathComponent("credentials.json")
+                        try ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
+                            let cacheKey = KeychainCacheStore.Key.oauth(provider: .claude)
+                            KeychainCacheStore.store(key: cacheKey, entry: WrongCacheEntry(value: "wrong-shape"))
+
+                            do {
+                                _ = try ClaudeOAuthCredentialsStore.load(environment: [:], allowKeychainPrompt: false)
+                                Issue.record("Expected ClaudeOAuthCredentialsError.notFound")
+                            } catch let error as ClaudeOAuthCredentialsError {
+                                guard case .notFound = error else {
+                                    Issue.record("Expected .notFound, got \(error)")
+                                    return
+                                }
+                            }
+
+                            switch KeychainCacheStore.load(
+                                key: cacheKey,
+                                as: ClaudeOAuthCredentialsStore.CacheEntry.self)
+                            {
+                            case .missing:
+                                #expect(true)
+                            case .found, .temporarilyUnavailable, .invalid:
+                                #expect(Bool(false), "Expected invalid Claude cache to be cleared")
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/Tests/CodexBarTests/ClaudeOAuthCredentialsStoreTests.swift b/Tests/CodexBarTests/ClaudeOAuthCredentialsStoreTests.swift
index 5fd258eb08..ff4fddba84 100644
--- a/Tests/CodexBarTests/ClaudeOAuthCredentialsStoreTests.swift
+++ b/Tests/CodexBarTests/ClaudeOAuthCredentialsStoreTests.swift
@@ -23,7 +23,7 @@ struct ClaudeOAuthCredentialsStoreTests {
     }
 
     @Test
-    func loadsFromKeychainCacheBeforeExpiredFile() throws {
+    func `loads from keychain cache before expired file`() throws {
         let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
         try ProviderInteractionContext.$current.withValue(.background) {
             try KeychainCacheStore.withServiceOverrideForTesting(service) {
@@ -91,7 +91,7 @@ struct ClaudeOAuthCredentialsStoreTests {
     }
 
     @Test
-    func loadRecord_nonInteractiveRepairCanBeDisabled() throws {
+    func `load record non interactive repair can be disabled`() throws {
         let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
         try KeychainCacheStore.withServiceOverrideForTesting(service) {
             KeychainCacheStore.setTestStoreForTesting(true)
@@ -151,7 +151,7 @@ struct ClaudeOAuthCredentialsStoreTests {
     }
 
     @Test
-    func invalidatesCacheWhenCredentialsFileChanges() throws {
+    func `invalidates cache when credentials file changes`() throws {
         KeychainCacheStore.setTestStoreForTesting(true)
         defer { KeychainCacheStore.setTestStoreForTesting(false) }
 
@@ -160,38 +160,42 @@ struct ClaudeOAuthCredentialsStoreTests {
 
         // Avoid interacting with the real Keychain in unit tests.
         try ClaudeOAuthCredentialsStore.withKeychainAccessOverrideForTesting(true) {
-            let tempDir = FileManager.default.temporaryDirectory
-                .appendingPathComponent(UUID().uuidString, isDirectory: true)
-            try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
-            let fileURL = tempDir.appendingPathComponent("credentials.json")
-            try ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
-                let first = self.makeCredentialsData(
-                    accessToken: "first",
-                    expiresAt: Date(timeIntervalSinceNow: 3600))
-                try first.write(to: fileURL)
+            try ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+                try ClaudeOAuthCredentialsStore.withIsolatedMemoryCacheForTesting {
+                    let tempDir = FileManager.default.temporaryDirectory
+                        .appendingPathComponent(UUID().uuidString, isDirectory: true)
+                    try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+                    let fileURL = tempDir.appendingPathComponent("credentials.json")
+                    try ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
+                        let first = self.makeCredentialsData(
+                            accessToken: "first",
+                            expiresAt: Date(timeIntervalSinceNow: 3600))
+                        try first.write(to: fileURL)
 
-                let cacheKey = KeychainCacheStore.Key.oauth(provider: .claude)
-                let cacheEntry = ClaudeOAuthCredentialsStore.CacheEntry(data: first, storedAt: Date())
-                KeychainCacheStore.store(key: cacheKey, entry: cacheEntry)
+                        let cacheKey = KeychainCacheStore.Key.oauth(provider: .claude)
+                        let cacheEntry = ClaudeOAuthCredentialsStore.CacheEntry(data: first, storedAt: Date())
+                        KeychainCacheStore.store(key: cacheKey, entry: cacheEntry)
 
-                _ = try ClaudeOAuthCredentialsStore.load(environment: [:])
+                        _ = try ClaudeOAuthCredentialsStore.load(environment: [:])
 
-                let updated = self.makeCredentialsData(
-                    accessToken: "second",
-                    expiresAt: Date(timeIntervalSinceNow: 3600))
-                try updated.write(to: fileURL)
+                        let updated = self.makeCredentialsData(
+                            accessToken: "second",
+                            expiresAt: Date(timeIntervalSinceNow: 3600))
+                        try updated.write(to: fileURL)
 
-                #expect(ClaudeOAuthCredentialsStore.invalidateCacheIfCredentialsFileChanged())
-                KeychainCacheStore.clear(key: cacheKey)
+                        #expect(ClaudeOAuthCredentialsStore.invalidateCacheIfCredentialsFileChanged())
+                        KeychainCacheStore.clear(key: cacheKey)
 
-                let creds = try ClaudeOAuthCredentialsStore.load(environment: [:])
-                #expect(creds.accessToken == "second")
+                        let creds = try ClaudeOAuthCredentialsStore.load(environment: [:])
+                        #expect(creds.accessToken == "second")
+                    }
+                }
             }
         }
     }
 
     @Test
-    func returnsExpiredFileWhenNoOtherSources() throws {
+    func `returns expired file when no other sources`() throws {
         let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
         try KeychainCacheStore.withServiceOverrideForTesting(service) {
             try KeychainAccessGate.withTaskOverrideForTesting(true) {
@@ -226,54 +230,57 @@ struct ClaudeOAuthCredentialsStoreTests {
     }
 
     @Test
-    func loadWithAutoRefresh_expiredClaudeCLIOwner_throwsDelegatedRefresh() async throws {
-        KeychainCacheStore.setTestStoreForTesting(true)
-        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+    func `load with auto refresh expired claude CLI owner throws delegated refresh`() async throws {
+        let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
+        try await KeychainCacheStore.withServiceOverrideForTesting(service) {
+            KeychainCacheStore.setTestStoreForTesting(true)
+            defer { KeychainCacheStore.setTestStoreForTesting(false) }
 
-        ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting()
-        defer { ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting() }
+            ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting()
+            defer { ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting() }
 
-        let tempDir = FileManager.default.temporaryDirectory
-            .appendingPathComponent(UUID().uuidString, isDirectory: true)
-        try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
-        let fileURL = tempDir.appendingPathComponent("credentials.json")
-        await ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
-            await ClaudeOAuthCredentialsStore.withKeychainAccessOverrideForTesting(true) {
-                ClaudeOAuthCredentialsStore.invalidateCache()
-                let cacheKey = KeychainCacheStore.Key.oauth(provider: .claude)
-                defer { KeychainCacheStore.clear(key: cacheKey) }
+            let tempDir = FileManager.default.temporaryDirectory
+                .appendingPathComponent(UUID().uuidString, isDirectory: true)
+            try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+            let fileURL = tempDir.appendingPathComponent("credentials.json")
+            await ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
+                await ClaudeOAuthCredentialsStore.withKeychainAccessOverrideForTesting(true) {
+                    ClaudeOAuthCredentialsStore.invalidateCache()
+                    let cacheKey = KeychainCacheStore.Key.oauth(provider: .claude)
+                    defer { KeychainCacheStore.clear(key: cacheKey) }
 
-                let expiredData = self.makeCredentialsData(
-                    accessToken: "expired-claude-cli-owner",
-                    expiresAt: Date(timeIntervalSinceNow: -3600),
-                    refreshToken: "refresh-token")
-                KeychainCacheStore.store(
-                    key: cacheKey,
-                    entry: ClaudeOAuthCredentialsStore.CacheEntry(
-                        data: expiredData,
-                        storedAt: Date(),
-                        owner: .claudeCLI))
+                    let expiredData = self.makeCredentialsData(
+                        accessToken: "expired-claude-cli-owner",
+                        expiresAt: Date(timeIntervalSinceNow: -3600),
+                        refreshToken: "refresh-token")
+                    KeychainCacheStore.store(
+                        key: cacheKey,
+                        entry: ClaudeOAuthCredentialsStore.CacheEntry(
+                            data: expiredData,
+                            storedAt: Date(),
+                            owner: .claudeCLI))
 
-                do {
-                    _ = try await ClaudeOAuthCredentialsStore.loadWithAutoRefresh(
-                        environment: [:],
-                        allowKeychainPrompt: false,
-                        respectKeychainPromptCooldown: true)
-                    Issue.record("Expected delegated refresh error for Claude CLI-owned credentials")
-                } catch let error as ClaudeOAuthCredentialsError {
-                    guard case .refreshDelegatedToClaudeCLI = error else {
-                        Issue.record("Expected .refreshDelegatedToClaudeCLI, got \(error)")
-                        return
+                    do {
+                        _ = try await ClaudeOAuthCredentialsStore.loadWithAutoRefresh(
+                            environment: [:],
+                            allowKeychainPrompt: false,
+                            respectKeychainPromptCooldown: true)
+                        Issue.record("Expected delegated refresh error for Claude CLI-owned credentials")
+                    } catch let error as ClaudeOAuthCredentialsError {
+                        guard case .refreshDelegatedToClaudeCLI = error else {
+                            Issue.record("Expected .refreshDelegatedToClaudeCLI, got \(error)")
+                            return
+                        }
+                    } catch {
+                        Issue.record("Expected ClaudeOAuthCredentialsError, got \(error)")
                     }
-                } catch {
-                    Issue.record("Expected ClaudeOAuthCredentialsError, got \(error)")
                 }
             }
         }
     }
 
     @Test
-    func loadWithAutoRefresh_expiredCodexbarOwner_usesDirectRefreshPath() async throws {
+    func `load with auto refresh expired codexbar owner uses direct refresh path`() async throws {
         let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
         try await KeychainCacheStore.withServiceOverrideForTesting(service) {
             KeychainCacheStore.setTestStoreForTesting(true)
@@ -325,7 +332,7 @@ struct ClaudeOAuthCredentialsStoreTests {
     }
 
     @Test
-    func loadRecord_legacyCacheEntryWithoutOwner_defaultsToClaudeCLIOwner() throws {
+    func `load record legacy cache entry without owner defaults to claude CLI owner`() throws {
         KeychainCacheStore.setTestStoreForTesting(true)
         defer { KeychainCacheStore.setTestStoreForTesting(false) }
 
@@ -336,34 +343,36 @@ struct ClaudeOAuthCredentialsStoreTests {
             .appendingPathComponent(UUID().uuidString, isDirectory: true)
         try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
         let fileURL = tempDir.appendingPathComponent("credentials.json")
-        try ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
-            try ClaudeOAuthCredentialsStore.withKeychainAccessOverrideForTesting(true) {
-                ClaudeOAuthCredentialsStore.invalidateCache()
-                let cacheKey = KeychainCacheStore.Key.oauth(provider: .claude)
-                defer { KeychainCacheStore.clear(key: cacheKey) }
+        try ClaudeOAuthCredentialsStore.withIsolatedMemoryCacheForTesting {
+            try ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
+                try ClaudeOAuthCredentialsStore.withKeychainAccessOverrideForTesting(true) {
+                    ClaudeOAuthCredentialsStore.invalidateCache()
+                    let cacheKey = KeychainCacheStore.Key.oauth(provider: .claude)
+                    defer { KeychainCacheStore.clear(key: cacheKey) }
 
-                let validData = self.makeCredentialsData(
-                    accessToken: "legacy-owner",
-                    expiresAt: Date(timeIntervalSinceNow: 3600),
-                    refreshToken: "refresh-token")
-                KeychainCacheStore.store(
-                    key: cacheKey,
-                    entry: ClaudeOAuthCredentialsStore.CacheEntry(
-                        data: validData,
-                        storedAt: Date()))
-
-                let record = try ClaudeOAuthCredentialsStore.loadRecord(
-                    environment: [:],
-                    allowKeychainPrompt: false,
-                    respectKeychainPromptCooldown: true)
-                #expect(record.owner == .claudeCLI)
-                #expect(record.source == .cacheKeychain)
+                    let validData = self.makeCredentialsData(
+                        accessToken: "legacy-owner",
+                        expiresAt: Date(timeIntervalSinceNow: 3600),
+                        refreshToken: "refresh-token")
+                    KeychainCacheStore.store(
+                        key: cacheKey,
+                        entry: ClaudeOAuthCredentialsStore.CacheEntry(
+                            data: validData,
+                            storedAt: Date()))
+
+                    let record = try ClaudeOAuthCredentialsStore.loadRecord(
+                        environment: [:],
+                        allowKeychainPrompt: false,
+                        respectKeychainPromptCooldown: true)
+                    #expect(record.owner == .claudeCLI)
+                    #expect(record.source == .cacheKeychain)
+                }
             }
         }
     }
 
     @Test
-    func hasCachedCredentials_returnsFalseForExpiredUnrefreshableCodexbarCacheEntry() throws {
+    func `has cached credentials returns false for expired unrefreshable codexbar cache entry`() throws {
         KeychainCacheStore.setTestStoreForTesting(true)
         defer { KeychainCacheStore.setTestStoreForTesting(false) }
 
@@ -393,7 +402,7 @@ struct ClaudeOAuthCredentialsStoreTests {
     }
 
     @Test
-    func hasCachedCredentials_returnsTrueForExpiredRefreshableCacheEntry() throws {
+    func `has cached credentials returns true for expired refreshable cache entry`() throws {
         KeychainCacheStore.setTestStoreForTesting(true)
         defer { KeychainCacheStore.setTestStoreForTesting(false) }
 
@@ -420,7 +429,7 @@ struct ClaudeOAuthCredentialsStoreTests {
     }
 
     @Test
-    func hasCachedCredentials_returnsTrueForExpiredClaudeCLIBackedCredentialsFile() throws {
+    func `has cached credentials returns true for expired claude CLI backed credentials file`() throws {
         KeychainCacheStore.setTestStoreForTesting(true)
         defer { KeychainCacheStore.setTestStoreForTesting(false) }
 
@@ -445,7 +454,7 @@ struct ClaudeOAuthCredentialsStoreTests {
     }
 
     @Test
-    func syncsCacheWhenClaudeKeychainFingerprintChangesAndTokenDiffers() throws {
+    func `syncs cache when claude keychain fingerprint changes and token differs`() throws {
         let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
         try KeychainCacheStore.withServiceOverrideForTesting(service) {
             try KeychainAccessGate.withTaskOverrideForTesting(false) {
@@ -546,7 +555,7 @@ struct ClaudeOAuthCredentialsStoreTests {
     }
 
     @Test
-    func doesNotSyncInBackgroundWhenCacheValidAndPromptModeOnlyOnUserAction() throws {
+    func `does not sync in background when cache valid and prompt mode only on user action`() throws {
         let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
         try KeychainCacheStore.withServiceOverrideForTesting(service) {
             try KeychainAccessGate.withTaskOverrideForTesting(false) {
@@ -633,142 +642,74 @@ struct ClaudeOAuthCredentialsStoreTests {
     }
 
     @Test
-    func doesNotSyncWhenClaudeKeychainFingerprintUnchanged() throws {
+    func `does not sync when claude keychain fingerprint unchanged`() throws {
         KeychainCacheStore.setTestStoreForTesting(true)
         defer { KeychainCacheStore.setTestStoreForTesting(false) }
 
-        ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting()
-        defer { ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting() }
+        try ClaudeOAuthCredentialsStore.withIsolatedMemoryCacheForTesting {
+            try ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+                ClaudeOAuthCredentialsStore.invalidateCache()
+                ClaudeOAuthCredentialsStore._resetClaudeKeychainChangeTrackingForTesting()
+                defer {
+                    ClaudeOAuthCredentialsStore.invalidateCache()
+                    ClaudeOAuthCredentialsStore._resetClaudeKeychainChangeTrackingForTesting()
+                }
 
-        ClaudeOAuthCredentialsStore.invalidateCache()
-        ClaudeOAuthCredentialsStore._resetClaudeKeychainChangeTrackingForTesting()
-        defer {
-            ClaudeOAuthCredentialsStore.invalidateCache()
-            ClaudeOAuthCredentialsStore._resetClaudeKeychainChangeTrackingForTesting()
-            ClaudeOAuthCredentialsStore.setClaudeKeychainDataOverrideForTesting(nil)
-            ClaudeOAuthCredentialsStore.setClaudeKeychainFingerprintOverrideForTesting(nil)
-        }
+                let cacheKey = KeychainCacheStore.Key.oauth(provider: .claude)
+                let cachedData = self.makeCredentialsData(
+                    accessToken: "cached-token",
+                    expiresAt: Date(timeIntervalSinceNow: 3600))
+                KeychainCacheStore.store(
+                    key: cacheKey,
+                    entry: ClaudeOAuthCredentialsStore.CacheEntry(data: cachedData, storedAt: Date()))
 
-        let cacheKey = KeychainCacheStore.Key.oauth(provider: .claude)
-        let cachedData = self.makeCredentialsData(
-            accessToken: "cached-token",
-            expiresAt: Date(timeIntervalSinceNow: 3600))
-        KeychainCacheStore.store(
-            key: cacheKey,
-            entry: ClaudeOAuthCredentialsStore.CacheEntry(data: cachedData, storedAt: Date()))
+                let fingerprint = ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
+                    modifiedAt: 1,
+                    createdAt: 1,
+                    persistentRefHash: "ref1")
+                let first = try ClaudeOAuthCredentialsStore.withClaudeKeychainOverridesForTesting(
+                    data: cachedData,
+                    fingerprint: fingerprint,
+                    operation: {
+                        try ClaudeOAuthCredentialsStore.load(environment: [:], allowKeychainPrompt: false)
+                    })
+                #expect(first.accessToken == "cached-token")
 
-        let fingerprint = ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
-            modifiedAt: 1,
-            createdAt: 1,
-            persistentRefHash: "ref1")
-        ClaudeOAuthCredentialsStore.setClaudeKeychainFingerprintOverrideForTesting(fingerprint)
-        ClaudeOAuthCredentialsStore.setClaudeKeychainDataOverrideForTesting(cachedData)
-
-        let first = try ClaudeOAuthCredentialsStore.load(environment: [:], allowKeychainPrompt: false)
-        #expect(first.accessToken == "cached-token")
-
-        ClaudeOAuthCredentialsStore._resetClaudeKeychainChangeThrottleForTesting()
-        let keychainData = self.makeCredentialsData(
-            accessToken: "keychain-token",
-            expiresAt: Date(timeIntervalSinceNow: 3600))
-        ClaudeOAuthCredentialsStore.setClaudeKeychainDataOverrideForTesting(keychainData)
-
-        let second = try ClaudeOAuthCredentialsStore.load(environment: [:], allowKeychainPrompt: false)
-        #expect(second.accessToken == "cached-token")
-
-        switch KeychainCacheStore.load(key: cacheKey, as: ClaudeOAuthCredentialsStore.CacheEntry.self) {
-        case let .found(entry):
-            let parsed = try ClaudeOAuthCredentials.parse(data: entry.data)
-            #expect(parsed.accessToken == "cached-token")
-        default:
-            #expect(Bool(false))
+                ClaudeOAuthCredentialsStore._resetClaudeKeychainChangeThrottleForTesting()
+                let keychainData = self.makeCredentialsData(
+                    accessToken: "keychain-token",
+                    expiresAt: Date(timeIntervalSinceNow: 3600))
+                let second = try ClaudeOAuthCredentialsStore.withClaudeKeychainOverridesForTesting(
+                    data: keychainData,
+                    fingerprint: fingerprint,
+                    operation: {
+                        try ClaudeOAuthCredentialsStore.load(environment: [:], allowKeychainPrompt: false)
+                    })
+                #expect(second.accessToken == "cached-token")
+
+                switch KeychainCacheStore.load(key: cacheKey, as: ClaudeOAuthCredentialsStore.CacheEntry.self) {
+                case let .found(entry):
+                    let parsed = try ClaudeOAuthCredentials.parse(data: entry.data)
+                    #expect(parsed.accessToken == "cached-token")
+                default:
+                    #expect(Bool(false))
+                }
+            }
         }
     }
 
     @Test
-    func doesNotSyncWhenKeychainCredentialsExpiredButCacheValid() throws {
+    func `does not sync when keychain credentials expired but cache valid`() throws {
         KeychainCacheStore.setTestStoreForTesting(true)
         defer { KeychainCacheStore.setTestStoreForTesting(false) }
 
-        ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting()
-        defer { ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting() }
-
-        ClaudeOAuthCredentialsStore.invalidateCache()
-        ClaudeOAuthCredentialsStore._resetClaudeKeychainChangeTrackingForTesting()
-        defer {
-            ClaudeOAuthCredentialsStore.invalidateCache()
-            ClaudeOAuthCredentialsStore._resetClaudeKeychainChangeTrackingForTesting()
-            ClaudeOAuthCredentialsStore.setClaudeKeychainDataOverrideForTesting(nil)
-            ClaudeOAuthCredentialsStore.setClaudeKeychainFingerprintOverrideForTesting(nil)
-        }
-
-        let cacheKey = KeychainCacheStore.Key.oauth(provider: .claude)
-        let cachedData = self.makeCredentialsData(
-            accessToken: "cached-token",
-            expiresAt: Date(timeIntervalSinceNow: 3600))
-        KeychainCacheStore.store(
-            key: cacheKey,
-            entry: ClaudeOAuthCredentialsStore.CacheEntry(data: cachedData, storedAt: Date()))
-
-        ClaudeOAuthCredentialsStore.setClaudeKeychainFingerprintOverrideForTesting(
-            ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
-                modifiedAt: 1,
-                createdAt: 1,
-                persistentRefHash: "ref1"))
-        ClaudeOAuthCredentialsStore.setClaudeKeychainDataOverrideForTesting(cachedData)
-
-        let first = try ClaudeOAuthCredentialsStore.load(environment: [:], allowKeychainPrompt: false)
-        #expect(first.accessToken == "cached-token")
-
-        ClaudeOAuthCredentialsStore._resetClaudeKeychainChangeThrottleForTesting()
-
-        ClaudeOAuthCredentialsStore.setClaudeKeychainFingerprintOverrideForTesting(
-            ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
-                modifiedAt: 2,
-                createdAt: 2,
-                persistentRefHash: "ref2"))
-        let expiredKeychainData = self.makeCredentialsData(
-            accessToken: "expired-keychain-token",
-            expiresAt: Date(timeIntervalSinceNow: -3600))
-        ClaudeOAuthCredentialsStore.setClaudeKeychainDataOverrideForTesting(expiredKeychainData)
-
-        let second = try ClaudeOAuthCredentialsStore.load(environment: [:], allowKeychainPrompt: false)
-        #expect(second.accessToken == "cached-token")
-
-        switch KeychainCacheStore.load(key: cacheKey, as: ClaudeOAuthCredentialsStore.CacheEntry.self) {
-        case let .found(entry):
-            let parsed = try ClaudeOAuthCredentials.parse(data: entry.data)
-            #expect(parsed.accessToken == "cached-token")
-        default:
-            #expect(Bool(false))
-        }
-    }
-
-    @Test
-    func respectsPromptCooldownGateWhenDisabledPrompting() throws {
-        let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
-        try KeychainCacheStore.withServiceOverrideForTesting(service) {
-            KeychainCacheStore.setTestStoreForTesting(true)
-            defer { KeychainCacheStore.setTestStoreForTesting(false) }
-
-            ClaudeOAuthKeychainAccessGate.resetForTesting()
-            defer { ClaudeOAuthKeychainAccessGate.resetForTesting() }
-
-            ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting()
-            defer { ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting() }
-
-            let tempDir = FileManager.default.temporaryDirectory
-                .appendingPathComponent(UUID().uuidString, isDirectory: true)
-            try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
-            let fileURL = tempDir.appendingPathComponent("credentials.json")
-            try ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
+        try ClaudeOAuthCredentialsStore.withIsolatedMemoryCacheForTesting {
+            try ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
                 ClaudeOAuthCredentialsStore.invalidateCache()
                 ClaudeOAuthCredentialsStore._resetClaudeKeychainChangeTrackingForTesting()
                 defer {
                     ClaudeOAuthCredentialsStore.invalidateCache()
                     ClaudeOAuthCredentialsStore._resetClaudeKeychainChangeTrackingForTesting()
-                    ClaudeOAuthCredentialsStore.setClaudeKeychainDataOverrideForTesting(nil)
-                    ClaudeOAuthCredentialsStore.setClaudeKeychainFingerprintOverrideForTesting(nil)
                 }
 
                 let cacheKey = KeychainCacheStore.Key.oauth(provider: .claude)
@@ -779,33 +720,31 @@ struct ClaudeOAuthCredentialsStoreTests {
                     key: cacheKey,
                     entry: ClaudeOAuthCredentialsStore.CacheEntry(data: cachedData, storedAt: Date()))
 
-                ClaudeOAuthCredentialsStore.setClaudeKeychainFingerprintOverrideForTesting(
-                    ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
+                let first = try ClaudeOAuthCredentialsStore.withClaudeKeychainOverridesForTesting(
+                    data: cachedData,
+                    fingerprint: ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
                         modifiedAt: 1,
                         createdAt: 1,
-                        persistentRefHash: "ref1"))
-                ClaudeOAuthCredentialsStore.setClaudeKeychainDataOverrideForTesting(cachedData)
-
-                let first = try ClaudeOAuthCredentialsStore.load(environment: [:], allowKeychainPrompt: false)
+                        persistentRefHash: "ref1"),
+                    operation: {
+                        try ClaudeOAuthCredentialsStore.load(environment: [:], allowKeychainPrompt: false)
+                    })
                 #expect(first.accessToken == "cached-token")
 
                 ClaudeOAuthCredentialsStore._resetClaudeKeychainChangeThrottleForTesting()
-                ClaudeOAuthKeychainAccessGate.recordDenied(now: Date())
 
-                ClaudeOAuthCredentialsStore.setClaudeKeychainFingerprintOverrideForTesting(
-                    ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
+                let expiredKeychainData = self.makeCredentialsData(
+                    accessToken: "expired-keychain-token",
+                    expiresAt: Date(timeIntervalSinceNow: -3600))
+                let second = try ClaudeOAuthCredentialsStore.withClaudeKeychainOverridesForTesting(
+                    data: expiredKeychainData,
+                    fingerprint: ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
                         modifiedAt: 2,
                         createdAt: 2,
-                        persistentRefHash: "ref2"))
-                let keychainData = self.makeCredentialsData(
-                    accessToken: "keychain-token",
-                    expiresAt: Date(timeIntervalSinceNow: 3600))
-                ClaudeOAuthCredentialsStore.setClaudeKeychainDataOverrideForTesting(keychainData)
-
-                let second = try ClaudeOAuthCredentialsStore.load(
-                    environment: [:],
-                    allowKeychainPrompt: false,
-                    respectKeychainPromptCooldown: true)
+                        persistentRefHash: "ref2"),
+                    operation: {
+                        try ClaudeOAuthCredentialsStore.load(environment: [:], allowKeychainPrompt: false)
+                    })
                 #expect(second.accessToken == "cached-token")
 
                 switch KeychainCacheStore.load(key: cacheKey, as: ClaudeOAuthCredentialsStore.CacheEntry.self) {
@@ -820,7 +759,83 @@ struct ClaudeOAuthCredentialsStoreTests {
     }
 
     @Test
-    func syncFromClaudeKeychainWithoutPrompt_respectsBackoffInBackground() {
+    func `respects prompt cooldown gate when disabled prompting`() throws {
+        let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
+        try KeychainCacheStore.withServiceOverrideForTesting(service) {
+            KeychainCacheStore.setTestStoreForTesting(true)
+            defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+            ClaudeOAuthKeychainAccessGate.resetForTesting()
+            defer { ClaudeOAuthKeychainAccessGate.resetForTesting() }
+
+            let tempDir = FileManager.default.temporaryDirectory
+                .appendingPathComponent(UUID().uuidString, isDirectory: true)
+            try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+            let fileURL = tempDir.appendingPathComponent("credentials.json")
+            try ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
+                try ClaudeOAuthCredentialsStore.withIsolatedMemoryCacheForTesting {
+                    try ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+                        ClaudeOAuthCredentialsStore.invalidateCache()
+                        ClaudeOAuthCredentialsStore._resetClaudeKeychainChangeTrackingForTesting()
+                        defer {
+                            ClaudeOAuthCredentialsStore.invalidateCache()
+                            ClaudeOAuthCredentialsStore._resetClaudeKeychainChangeTrackingForTesting()
+                        }
+
+                        let cacheKey = KeychainCacheStore.Key.oauth(provider: .claude)
+                        let cachedData = self.makeCredentialsData(
+                            accessToken: "cached-token",
+                            expiresAt: Date(timeIntervalSinceNow: 3600))
+                        KeychainCacheStore.store(
+                            key: cacheKey,
+                            entry: ClaudeOAuthCredentialsStore.CacheEntry(data: cachedData, storedAt: Date()))
+
+                        let first = try ClaudeOAuthCredentialsStore.withClaudeKeychainOverridesForTesting(
+                            data: cachedData,
+                            fingerprint: ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
+                                modifiedAt: 1,
+                                createdAt: 1,
+                                persistentRefHash: "ref1"),
+                            operation: {
+                                try ClaudeOAuthCredentialsStore.load(environment: [:], allowKeychainPrompt: false)
+                            })
+                        #expect(first.accessToken == "cached-token")
+
+                        ClaudeOAuthCredentialsStore._resetClaudeKeychainChangeThrottleForTesting()
+                        ClaudeOAuthKeychainAccessGate.recordDenied(now: Date())
+
+                        let keychainData = self.makeCredentialsData(
+                            accessToken: "keychain-token",
+                            expiresAt: Date(timeIntervalSinceNow: 3600))
+                        let second = try ClaudeOAuthCredentialsStore.withClaudeKeychainOverridesForTesting(
+                            data: keychainData,
+                            fingerprint: ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
+                                modifiedAt: 2,
+                                createdAt: 2,
+                                persistentRefHash: "ref2"),
+                            operation: {
+                                try ClaudeOAuthCredentialsStore.load(
+                                    environment: [:],
+                                    allowKeychainPrompt: false,
+                                    respectKeychainPromptCooldown: true)
+                            })
+                        #expect(second.accessToken == "cached-token")
+
+                        switch KeychainCacheStore.load(key: cacheKey, as: ClaudeOAuthCredentialsStore.CacheEntry.self) {
+                        case let .found(entry):
+                            let parsed = try ClaudeOAuthCredentials.parse(data: entry.data)
+                            #expect(parsed.accessToken == "cached-token")
+                        default:
+                            #expect(Bool(false))
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    func `sync from claude keychain without prompt respects backoff in background`() {
         ProviderInteractionContext.$current.withValue(.background) {
             KeychainAccessGate.withTaskOverrideForTesting(true) {
                 ClaudeOAuthCredentialsStore.withKeychainAccessOverrideForTesting(true) {
@@ -846,4 +861,29 @@ struct ClaudeOAuthCredentialsStoreTests {
             }
         }
     }
+
+    @Test
+    func `testing override snapshot forwards mutable Claude keychain override store across detached task`() async {
+        let fingerprint = ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
+            modifiedAt: 11,
+            createdAt: 7,
+            persistentRefHash: "snapshot-store")
+        let store = ClaudeOAuthCredentialsStore.ClaudeKeychainOverrideStore(
+            data: nil,
+            fingerprint: fingerprint)
+
+        let forwarded = await ClaudeOAuthCredentialsStore.withMutableClaudeKeychainOverrideStoreForTesting(store) {
+            let snapshot = ClaudeOAuthCredentialsStore.currentTestingOverridesSnapshotForTask
+
+            return await Task.detached {
+                ClaudeOAuthKeychainPromptPreference.withTaskOverrideForTesting(.always) {
+                    ClaudeOAuthCredentialsStore.withTestingOverridesSnapshotForTask(snapshot) {
+                        ClaudeOAuthCredentialsStore.currentClaudeKeychainFingerprintWithoutPromptForAuthGate()
+                    }
+                }
+            }.value
+        }
+
+        #expect(forwarded == fingerprint)
+    }
 }
diff --git a/Tests/CodexBarTests/ClaudeOAuthDelegatedRefreshCoordinatorTests.swift b/Tests/CodexBarTests/ClaudeOAuthDelegatedRefreshCoordinatorTests.swift
index 3ab8f87c9c..d2d139a9a9 100644
--- a/Tests/CodexBarTests/ClaudeOAuthDelegatedRefreshCoordinatorTests.swift
+++ b/Tests/CodexBarTests/ClaudeOAuthDelegatedRefreshCoordinatorTests.swift
@@ -29,8 +29,49 @@ struct ClaudeOAuthDelegatedRefreshCoordinatorTests {
         return Data(json.utf8)
     }
 
+    private func withCoordinatorOverrides<T>(
+        isolateState: Bool = true,
+        cliAvailable: Bool? = nil,
+        touchAuthPath: (@Sendable (TimeInterval, [String: String]) async throws -> Void)? = nil,
+        keychainFingerprint: (@Sendable () -> ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint?)? = nil,
+        operation: () async throws -> T) async rethrows -> T
+    {
+        if isolateState {
+            return try await ClaudeOAuthDelegatedRefreshCoordinator.withIsolatedStateForTesting {
+                ClaudeOAuthDelegatedRefreshCoordinator.resetForTesting()
+                defer { ClaudeOAuthDelegatedRefreshCoordinator.resetForTesting() }
+                return try await ClaudeOAuthDelegatedRefreshCoordinator.withKeychainFingerprintOverrideForTesting(
+                    keychainFingerprint)
+                {
+                    try await ClaudeOAuthDelegatedRefreshCoordinator.withCLIAvailableOverrideForTesting(
+                        cliAvailable)
+                    {
+                        try await ClaudeOAuthDelegatedRefreshCoordinator.withTouchAuthPathOverrideForTesting(
+                            touchAuthPath)
+                        {
+                            try await operation()
+                        }
+                    }
+                }
+            }
+        }
+        ClaudeOAuthDelegatedRefreshCoordinator.resetForTesting()
+        defer { ClaudeOAuthDelegatedRefreshCoordinator.resetForTesting() }
+        return try await ClaudeOAuthDelegatedRefreshCoordinator.withKeychainFingerprintOverrideForTesting(
+            keychainFingerprint)
+        {
+            try await ClaudeOAuthDelegatedRefreshCoordinator.withCLIAvailableOverrideForTesting(cliAvailable) {
+                try await ClaudeOAuthDelegatedRefreshCoordinator.withTouchAuthPathOverrideForTesting(
+                    touchAuthPath)
+                {
+                    try await operation()
+                }
+            }
+        }
+    }
+
     @Test
-    func cooldownPreventsRepeatedAttempts() async {
+    func `cooldown prevents repeated attempts`() async {
         ClaudeOAuthDelegatedRefreshCoordinator.resetForTesting()
         defer { ClaudeOAuthDelegatedRefreshCoordinator.resetForTesting() }
 
@@ -44,41 +85,47 @@ struct ClaudeOAuthDelegatedRefreshCoordinatorTests {
             modifiedAt: 1,
             createdAt: 1,
             persistentRefHash: "ref1"))
-        ClaudeOAuthDelegatedRefreshCoordinator.setKeychainFingerprintOverrideForTesting { box.fingerprint }
-
-        ClaudeOAuthDelegatedRefreshCoordinator.setCLIAvailableOverrideForTesting(true)
-        ClaudeOAuthDelegatedRefreshCoordinator.setTouchAuthPathOverrideForTesting { _ in
-            box.fingerprint = ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
-                modifiedAt: 2,
-                createdAt: 2,
-                persistentRefHash: "ref2")
-        }
-
         let start = Date(timeIntervalSince1970: 10000)
-        let first = await ClaudeOAuthDelegatedRefreshCoordinator.attempt(now: start, timeout: 0.1)
-        let second = await ClaudeOAuthDelegatedRefreshCoordinator
-            .attempt(now: start.addingTimeInterval(30), timeout: 0.1)
+        let (first, second) = await ClaudeOAuthKeychainReadStrategyPreference.withTaskOverrideForTesting(
+            .securityFramework)
+        {
+            await self.withCoordinatorOverrides(
+                cliAvailable: true,
+                touchAuthPath: { _, _ in
+                    box.fingerprint = ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
+                        modifiedAt: 2,
+                        createdAt: 2,
+                        persistentRefHash: "ref2")
+                },
+                keychainFingerprint: { box.fingerprint },
+                operation: {
+                    let first = await ClaudeOAuthDelegatedRefreshCoordinator.attempt(now: start, timeout: 0.1)
+                    let second = await ClaudeOAuthDelegatedRefreshCoordinator
+                        .attempt(now: start.addingTimeInterval(30), timeout: 0.1)
+                    return (first, second)
+                })
+        }
 
         #expect(first == .attemptedSucceeded)
         #expect(second == .skippedByCooldown)
     }
 
     @Test
-    func cliUnavailableReturnsCliUnavailable() async {
+    func `cli unavailable returns cli unavailable`() async {
         ClaudeOAuthDelegatedRefreshCoordinator.resetForTesting()
         defer { ClaudeOAuthDelegatedRefreshCoordinator.resetForTesting() }
 
-        ClaudeOAuthDelegatedRefreshCoordinator.setCLIAvailableOverrideForTesting(false)
-
-        let outcome = await ClaudeOAuthDelegatedRefreshCoordinator.attempt(
-            now: Date(timeIntervalSince1970: 20000),
-            timeout: 0.1)
+        let outcome = await self.withCoordinatorOverrides(cliAvailable: false, operation: {
+            await ClaudeOAuthDelegatedRefreshCoordinator.attempt(
+                now: Date(timeIntervalSince1970: 20000),
+                timeout: 0.1)
+        })
 
         #expect(outcome == .cliUnavailable)
     }
 
     @Test
-    func successfulAuthTouchReportsAttemptedSucceeded() async {
+    func `successful auth touch reports attempted succeeded`() async {
         ClaudeOAuthDelegatedRefreshCoordinator.resetForTesting()
         defer { ClaudeOAuthDelegatedRefreshCoordinator.resetForTesting() }
 
@@ -92,53 +139,102 @@ struct ClaudeOAuthDelegatedRefreshCoordinatorTests {
             modifiedAt: 10,
             createdAt: 10,
             persistentRefHash: "refA"))
-        ClaudeOAuthDelegatedRefreshCoordinator.setKeychainFingerprintOverrideForTesting { box.fingerprint }
-
-        ClaudeOAuthDelegatedRefreshCoordinator.setCLIAvailableOverrideForTesting(true)
-        ClaudeOAuthDelegatedRefreshCoordinator.setTouchAuthPathOverrideForTesting { _ in
-            box.fingerprint = ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
-                modifiedAt: 11,
-                createdAt: 11,
-                persistentRefHash: "refB")
+        let outcome = await ClaudeOAuthKeychainReadStrategyPreference.withTaskOverrideForTesting(
+            .securityFramework)
+        {
+            await self.withCoordinatorOverrides(
+                cliAvailable: true,
+                touchAuthPath: { _, _ in
+                    box.fingerprint = ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
+                        modifiedAt: 11,
+                        createdAt: 11,
+                        persistentRefHash: "refB")
+                },
+                keychainFingerprint: { box.fingerprint },
+                operation: {
+                    await ClaudeOAuthDelegatedRefreshCoordinator.attempt(
+                        now: Date(timeIntervalSince1970: 30000),
+                        timeout: 0.1)
+                })
         }
 
-        let outcome = await ClaudeOAuthDelegatedRefreshCoordinator.attempt(
-            now: Date(timeIntervalSince1970: 30000),
-            timeout: 0.1)
-
         #expect(outcome == .attemptedSucceeded)
     }
 
     @Test
-    func failedAuthTouchReportsAttemptedFailed() async {
+    func `failed auth touch reports attempted failed`() async throws {
         ClaudeOAuthDelegatedRefreshCoordinator.resetForTesting()
         defer { ClaudeOAuthDelegatedRefreshCoordinator.resetForTesting() }
 
-        ClaudeOAuthDelegatedRefreshCoordinator.setKeychainFingerprintOverrideForTesting {
-            ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
-                modifiedAt: 20,
-                createdAt: 20,
-                persistentRefHash: "refX")
-        }
+        let outcome = try await self.withCoordinatorOverrides(
+            cliAvailable: true,
+            touchAuthPath: { _, _ in
+                throw StubError.failed
+            },
+            keychainFingerprint: {
+                ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
+                    modifiedAt: 20,
+                    createdAt: 20,
+                    persistentRefHash: "refX")
+            },
+            operation: {
+                await KeychainAccessGate.withTaskOverrideForTesting(false) {
+                    await ClaudeOAuthKeychainReadStrategyPreference.withTaskOverrideForTesting(.securityFramework) {
+                        await ClaudeOAuthDelegatedRefreshCoordinator.attempt(
+                            now: Date(timeIntervalSince1970: 40000),
+                            timeout: 0.1)
+                    }
+                }
+            })
 
-        ClaudeOAuthDelegatedRefreshCoordinator.setCLIAvailableOverrideForTesting(true)
-        ClaudeOAuthDelegatedRefreshCoordinator.setTouchAuthPathOverrideForTesting { _ in
-            throw StubError.failed
+        guard case let .attemptedFailed(message) = outcome else {
+            Issue.record("Expected .attemptedFailed outcome")
+            return
         }
+        #expect(message.contains("failed"))
+    }
 
-        let outcome = await ClaudeOAuthDelegatedRefreshCoordinator.attempt(
-            now: Date(timeIntervalSince1970: 40000),
-            timeout: 0.1)
+    @Test
+    func `environment CLI override avoids CLI unavailable`() async throws {
+        ClaudeOAuthDelegatedRefreshCoordinator.resetForTesting()
+        defer { ClaudeOAuthDelegatedRefreshCoordinator.resetForTesting() }
+
+        let stubCLI = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        let script = "#!/bin/sh\nexit 0\n"
+        try script.write(to: stubCLI, atomically: true, encoding: .utf8)
+        try FileManager.default.setAttributes([.posixPermissions: 0o755], ofItemAtPath: stubCLI.path)
+
+        let outcome = try await self.withCoordinatorOverrides(
+            touchAuthPath: { _, environment in
+                #expect(environment["CLAUDE_CLI_PATH"] == stubCLI.path)
+                throw StubError.failed
+            },
+            keychainFingerprint: {
+                ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
+                    modifiedAt: 20,
+                    createdAt: 20,
+                    persistentRefHash: "ref-env")
+            },
+            operation: {
+                await KeychainAccessGate.withTaskOverrideForTesting(false) {
+                    await ClaudeOAuthKeychainReadStrategyPreference.withTaskOverrideForTesting(.securityFramework) {
+                        await ClaudeOAuthDelegatedRefreshCoordinator.attempt(
+                            now: Date(timeIntervalSince1970: 45000),
+                            timeout: 0.1,
+                            environment: ["CLAUDE_CLI_PATH": stubCLI.path])
+                    }
+                }
+            })
 
         guard case let .attemptedFailed(message) = outcome else {
-            Issue.record("Expected .attemptedFailed outcome")
+            Issue.record("Expected env-provided CLI override to reach touch attempt")
             return
         }
         #expect(message.contains("failed"))
     }
 
     @Test
-    func concurrentAttemptsJoinInFlight() async {
+    func `concurrent attempts join in flight`() async {
         ClaudeOAuthDelegatedRefreshCoordinator.resetForTesting()
         defer { ClaudeOAuthDelegatedRefreshCoordinator.resetForTesting() }
 
@@ -200,213 +296,238 @@ struct ClaudeOAuthDelegatedRefreshCoordinatorTests {
             modifiedAt: 1,
             createdAt: 1,
             persistentRefHash: "ref1"))
-        ClaudeOAuthDelegatedRefreshCoordinator.setKeychainFingerprintOverrideForTesting { box.fingerprint }
-
-        ClaudeOAuthDelegatedRefreshCoordinator.setCLIAvailableOverrideForTesting(true)
-        ClaudeOAuthDelegatedRefreshCoordinator.setTouchAuthPathOverrideForTesting { _ in
-            counter.increment()
-            await gate.markStarted()
-            await gate.waitRelease()
-            box.fingerprint = ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
-                modifiedAt: 2,
-                createdAt: 2,
-                persistentRefHash: "ref2")
-        }
-
         let now = Date(timeIntervalSince1970: 50000)
-        async let first = ClaudeOAuthDelegatedRefreshCoordinator.attempt(now: now, timeout: 2)
-        await gate.waitStarted()
-        async let second = ClaudeOAuthDelegatedRefreshCoordinator.attempt(now: now.addingTimeInterval(30), timeout: 2)
-
-        await gate.release()
-        let outcomes = await [first, second]
+        let outcomes = await KeychainAccessGate.withTaskOverrideForTesting(false) {
+            await ClaudeOAuthKeychainReadStrategyPreference.withTaskOverrideForTesting(.securityFramework) {
+                await self.withCoordinatorOverrides(
+                    isolateState: false,
+                    cliAvailable: true,
+                    touchAuthPath: { _, _ in
+                        counter.increment()
+                        await gate.markStarted()
+                        await gate.waitRelease()
+                        box.fingerprint = ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
+                            modifiedAt: 2,
+                            createdAt: 2,
+                            persistentRefHash: "ref2")
+                        try? await Task.sleep(nanoseconds: 50_000_000)
+                    },
+                    keychainFingerprint: { box.fingerprint },
+                    operation: {
+                        let first = Task {
+                            await ClaudeOAuthDelegatedRefreshCoordinator.attempt(now: now, timeout: 2)
+                        }
+                        await gate.waitStarted()
+                        let second = Task {
+                            await ClaudeOAuthDelegatedRefreshCoordinator.attempt(
+                                now: now.addingTimeInterval(30),
+                                timeout: 2)
+                        }
+
+                        await gate.release()
+                        return await [first.value, second.value]
+                    })
+            }
+        }
 
         #expect(outcomes.allSatisfy { $0 == .attemptedSucceeded })
         #expect(counter.count == 1)
     }
 
     @Test
-    func experimentalStrategy_doesNotUseSecurityFrameworkFingerprintObservation() async {
+    func `experimental strategy does not use security framework fingerprint observation`() async {
         ClaudeOAuthDelegatedRefreshCoordinator.resetForTesting()
         defer { ClaudeOAuthDelegatedRefreshCoordinator.resetForTesting() }
-        await ClaudeOAuthKeychainReadStrategyPreference.withTaskOverrideForTesting(
-            .securityCLIExperimental)
-        {
-            final class CounterBox: @unchecked Sendable {
-                private let lock = NSLock()
-                private(set) var count: Int = 0
-                func increment() {
-                    self.lock.lock()
-                    self.count += 1
-                    self.lock.unlock()
+        await KeychainAccessGate.withTaskOverrideForTesting(false) {
+            await ClaudeOAuthKeychainReadStrategyPreference.withTaskOverrideForTesting(
+                .securityCLIExperimental)
+            {
+                final class CounterBox: @unchecked Sendable {
+                    private let lock = NSLock()
+                    private(set) var count: Int = 0
+                    func increment() {
+                        self.lock.lock()
+                        self.count += 1
+                        self.lock.unlock()
+                    }
                 }
+                let fingerprintCounter = CounterBox()
+                let securityData = self.makeCredentialsData(
+                    accessToken: "security-token-a",
+                    expiresAt: Date(timeIntervalSinceNow: 3600))
+                let outcome = await self.withCoordinatorOverrides(
+                    cliAvailable: true,
+                    touchAuthPath: { _, _ in },
+                    keychainFingerprint: {
+                        fingerprintCounter.increment()
+                        return ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
+                            modifiedAt: 1,
+                            createdAt: 1,
+                            persistentRefHash: "framework-fingerprint")
+                    },
+                    operation: {
+                        await ClaudeOAuthCredentialsStore.withSecurityCLIReadOverrideForTesting(.data(securityData)) {
+                            await ClaudeOAuthDelegatedRefreshCoordinator.attempt(
+                                now: Date(timeIntervalSince1970: 60000),
+                                timeout: 0.1)
+                        }
+                    })
+
+                guard case .attemptedFailed = outcome else {
+                    Issue.record("Expected .attemptedFailed outcome")
+                    return
+                }
+                #expect(fingerprintCounter.count < 1)
             }
-            let fingerprintCounter = CounterBox()
-            ClaudeOAuthDelegatedRefreshCoordinator.setKeychainFingerprintOverrideForTesting {
-                fingerprintCounter.increment()
-                return ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
-                    modifiedAt: 1,
-                    createdAt: 1,
-                    persistentRefHash: "framework-fingerprint")
-            }
-            ClaudeOAuthDelegatedRefreshCoordinator.setCLIAvailableOverrideForTesting(true)
-            ClaudeOAuthDelegatedRefreshCoordinator.setTouchAuthPathOverrideForTesting { _ in }
-
-            let securityData = self.makeCredentialsData(
-                accessToken: "security-token-a",
-                expiresAt: Date(timeIntervalSinceNow: 3600))
-            ClaudeOAuthCredentialsStore.setSecurityCLIReadOverrideForTesting(.data(securityData))
-            defer { ClaudeOAuthCredentialsStore.setSecurityCLIReadOverrideForTesting(nil) }
-            let outcome = await ClaudeOAuthDelegatedRefreshCoordinator.attempt(
-                now: Date(timeIntervalSince1970: 60000),
-                timeout: 0.1)
-
-            guard case .attemptedFailed = outcome else {
-                Issue.record("Expected .attemptedFailed outcome")
-                return
-            }
-            #expect(fingerprintCounter.count < 1)
         }
     }
 
     @Test
-    func experimentalStrategy_observesSecurityCLIChangeAfterTouch() async {
+    func `experimental strategy observes security CLI change after touch`() async {
         ClaudeOAuthDelegatedRefreshCoordinator.resetForTesting()
         defer { ClaudeOAuthDelegatedRefreshCoordinator.resetForTesting() }
-        await ClaudeOAuthKeychainReadStrategyPreference.withTaskOverrideForTesting(
-            .securityCLIExperimental)
-        {
-            final class DataBox: @unchecked Sendable {
-                private let lock = NSLock()
-                private var _data: Data?
-                init(data: Data?) {
-                    self._data = data
-                }
-
-                func load() -> Data? {
-                    self.lock.lock()
-                    defer { self.lock.unlock() }
-                    return self._data
+        await KeychainAccessGate.withTaskOverrideForTesting(false) {
+            await ClaudeOAuthKeychainReadStrategyPreference.withTaskOverrideForTesting(
+                .securityCLIExperimental)
+            {
+                final class DataBox: @unchecked Sendable {
+                    private let lock = NSLock()
+                    private var _data: Data?
+                    init(data: Data?) {
+                        self._data = data
+                    }
+
+                    func load() -> Data? {
+                        self.lock.lock()
+                        defer { self.lock.unlock() }
+                        return self._data
+                    }
+
+                    func store(_ data: Data?) {
+                        self.lock.lock()
+                        self._data = data
+                        self.lock.unlock()
+                    }
                 }
-
-                func store(_ data: Data?) {
-                    self.lock.lock()
-                    self._data = data
-                    self.lock.unlock()
-                }
-            }
-            final class CounterBox: @unchecked Sendable {
-                private let lock = NSLock()
-                private(set) var count: Int = 0
-                func increment() {
-                    self.lock.lock()
-                    self.count += 1
-                    self.lock.unlock()
+                final class CounterBox: @unchecked Sendable {
+                    private let lock = NSLock()
+                    private(set) var count: Int = 0
+                    func increment() {
+                        self.lock.lock()
+                        self.count += 1
+                        self.lock.unlock()
+                    }
                 }
+                let fingerprintCounter = CounterBox()
+                let beforeData = self.makeCredentialsData(
+                    accessToken: "security-token-before",
+                    expiresAt: Date(timeIntervalSinceNow: -60))
+                let afterData = self.makeCredentialsData(
+                    accessToken: "security-token-after",
+                    expiresAt: Date(timeIntervalSinceNow: 3600))
+                let dataBox = DataBox(data: beforeData)
+                let outcome = await self.withCoordinatorOverrides(
+                    cliAvailable: true,
+                    touchAuthPath: { _, _ in
+                        dataBox.store(afterData)
+                    },
+                    keychainFingerprint: {
+                        fingerprintCounter.increment()
+                        return ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
+                            modifiedAt: 11,
+                            createdAt: 11,
+                            persistentRefHash: "framework-fingerprint")
+                    },
+                    operation: {
+                        await ClaudeOAuthCredentialsStore.withSecurityCLIReadOverrideForTesting(
+                            .dynamic { _ in dataBox.load() })
+                        {
+                            await ClaudeOAuthDelegatedRefreshCoordinator.attempt(
+                                now: Date(timeIntervalSince1970: 61000),
+                                timeout: 0.1)
+                        }
+                    })
+
+                #expect(outcome == .attemptedSucceeded)
+                #expect(fingerprintCounter.count < 1)
             }
-            let fingerprintCounter = CounterBox()
-            ClaudeOAuthDelegatedRefreshCoordinator.setKeychainFingerprintOverrideForTesting {
-                fingerprintCounter.increment()
-                return ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
-                    modifiedAt: 11,
-                    createdAt: 11,
-                    persistentRefHash: "framework-fingerprint")
-            }
-
-            let beforeData = self.makeCredentialsData(
-                accessToken: "security-token-before",
-                expiresAt: Date(timeIntervalSinceNow: -60))
-            let afterData = self.makeCredentialsData(
-                accessToken: "security-token-after",
-                expiresAt: Date(timeIntervalSinceNow: 3600))
-            let dataBox = DataBox(data: beforeData)
-
-            ClaudeOAuthDelegatedRefreshCoordinator.setCLIAvailableOverrideForTesting(true)
-            ClaudeOAuthDelegatedRefreshCoordinator.setTouchAuthPathOverrideForTesting { _ in
-                dataBox.store(afterData)
-            }
-            ClaudeOAuthCredentialsStore.setSecurityCLIReadOverrideForTesting(.dynamic { _ in dataBox.load() })
-            defer { ClaudeOAuthCredentialsStore.setSecurityCLIReadOverrideForTesting(nil) }
-
-            let outcome = await ClaudeOAuthDelegatedRefreshCoordinator.attempt(
-                now: Date(timeIntervalSince1970: 61000),
-                timeout: 0.1)
-
-            #expect(outcome == .attemptedSucceeded)
-            #expect(fingerprintCounter.count < 1)
         }
     }
 
     @Test
-    func experimentalStrategy_missingBaselineDoesNotAutoSucceedWhenLaterReadSucceeds() async {
+    func `experimental strategy missing baseline does not auto succeed when later read succeeds`() async {
         ClaudeOAuthDelegatedRefreshCoordinator.resetForTesting()
         defer { ClaudeOAuthDelegatedRefreshCoordinator.resetForTesting() }
-        await ClaudeOAuthKeychainReadStrategyPreference.withTaskOverrideForTesting(
-            .securityCLIExperimental)
-        {
-            final class DataBox: @unchecked Sendable {
-                private let lock = NSLock()
-                private var _data: Data?
-                init(data: Data?) {
-                    self._data = data
+        await KeychainAccessGate.withTaskOverrideForTesting(false) {
+            await ClaudeOAuthKeychainReadStrategyPreference.withTaskOverrideForTesting(
+                .securityCLIExperimental)
+            {
+                final class DataBox: @unchecked Sendable {
+                    private let lock = NSLock()
+                    private var _data: Data?
+                    init(data: Data?) {
+                        self._data = data
+                    }
+
+                    func load() -> Data? {
+                        self.lock.lock()
+                        defer { self.lock.unlock() }
+                        return self._data
+                    }
+
+                    func store(_ data: Data?) {
+                        self.lock.lock()
+                        self._data = data
+                        self.lock.unlock()
+                    }
                 }
-
-                func load() -> Data? {
-                    self.lock.lock()
-                    defer { self.lock.unlock() }
-                    return self._data
+                final class CounterBox: @unchecked Sendable {
+                    private let lock = NSLock()
+                    private(set) var count: Int = 0
+                    func increment() {
+                        self.lock.lock()
+                        self.count += 1
+                        self.lock.unlock()
+                    }
                 }
-
-                func store(_ data: Data?) {
-                    self.lock.lock()
-                    self._data = data
-                    self.lock.unlock()
+                let fingerprintCounter = CounterBox()
+                let afterData = self.makeCredentialsData(
+                    accessToken: "security-token-after-baseline-miss",
+                    expiresAt: Date(timeIntervalSinceNow: 3600))
+                let dataBox = DataBox(data: nil)
+                let outcome = await self.withCoordinatorOverrides(
+                    cliAvailable: true,
+                    touchAuthPath: { _, _ in
+                        dataBox.store(afterData)
+                    },
+                    keychainFingerprint: {
+                        fingerprintCounter.increment()
+                        return ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
+                            modifiedAt: 21,
+                            createdAt: 21,
+                            persistentRefHash: "framework-fingerprint")
+                    },
+                    operation: {
+                        await ClaudeOAuthCredentialsStore.withSecurityCLIReadOverrideForTesting(
+                            .dynamic { _ in dataBox.load() })
+                        {
+                            await ClaudeOAuthDelegatedRefreshCoordinator.attempt(
+                                now: Date(timeIntervalSince1970: 61500),
+                                timeout: 0.1)
+                        }
+                    })
+
+                guard case .attemptedFailed = outcome else {
+                    Issue.record("Expected .attemptedFailed outcome when baseline is unavailable")
+                    return
                 }
+                #expect(fingerprintCounter.count < 1)
             }
-            final class CounterBox: @unchecked Sendable {
-                private let lock = NSLock()
-                private(set) var count: Int = 0
-                func increment() {
-                    self.lock.lock()
-                    self.count += 1
-                    self.lock.unlock()
-                }
-            }
-            let fingerprintCounter = CounterBox()
-            ClaudeOAuthDelegatedRefreshCoordinator.setKeychainFingerprintOverrideForTesting {
-                fingerprintCounter.increment()
-                return ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
-                    modifiedAt: 21,
-                    createdAt: 21,
-                    persistentRefHash: "framework-fingerprint")
-            }
-
-            let afterData = self.makeCredentialsData(
-                accessToken: "security-token-after-baseline-miss",
-                expiresAt: Date(timeIntervalSinceNow: 3600))
-            let dataBox = DataBox(data: nil)
-
-            ClaudeOAuthDelegatedRefreshCoordinator.setCLIAvailableOverrideForTesting(true)
-            ClaudeOAuthDelegatedRefreshCoordinator.setTouchAuthPathOverrideForTesting { _ in
-                dataBox.store(afterData)
-            }
-            ClaudeOAuthCredentialsStore.setSecurityCLIReadOverrideForTesting(.dynamic { _ in dataBox.load() })
-            defer { ClaudeOAuthCredentialsStore.setSecurityCLIReadOverrideForTesting(nil) }
-
-            let outcome = await ClaudeOAuthDelegatedRefreshCoordinator.attempt(
-                now: Date(timeIntervalSince1970: 61500),
-                timeout: 0.1)
-
-            guard case .attemptedFailed = outcome else {
-                Issue.record("Expected .attemptedFailed outcome when baseline is unavailable")
-                return
-            }
-            #expect(fingerprintCounter.count < 1)
         }
     }
 
     @Test
-    func experimentalStrategy_observationSkipsSecurityCLIWhenGlobalKeychainDisabled() async {
+    func `experimental strategy observation skips security CLI when global keychain disabled`() async {
         ClaudeOAuthDelegatedRefreshCoordinator.resetForTesting()
         defer { ClaudeOAuthDelegatedRefreshCoordinator.resetForTesting() }
         await ClaudeOAuthKeychainReadStrategyPreference.withTaskOverrideForTesting(
@@ -426,18 +547,21 @@ struct ClaudeOAuthDelegatedRefreshCoordinatorTests {
             let securityData = self.makeCredentialsData(
                 accessToken: "security-should-not-be-read",
                 expiresAt: Date(timeIntervalSinceNow: 3600))
-            ClaudeOAuthDelegatedRefreshCoordinator.setCLIAvailableOverrideForTesting(true)
-            ClaudeOAuthDelegatedRefreshCoordinator.setTouchAuthPathOverrideForTesting { _ in }
-            ClaudeOAuthCredentialsStore.setSecurityCLIReadOverrideForTesting(.dynamic { _ in
-                securityReadCounter.increment()
-                return securityData
-            })
-            defer { ClaudeOAuthCredentialsStore.setSecurityCLIReadOverrideForTesting(nil) }
-            let outcome = await KeychainAccessGate.withTaskOverrideForTesting(true) {
-                await ClaudeOAuthDelegatedRefreshCoordinator.attempt(
-                    now: Date(timeIntervalSince1970: 62000),
-                    timeout: 0.1)
-            }
+            let outcome = await self.withCoordinatorOverrides(
+                cliAvailable: true,
+                touchAuthPath: { _, _ in },
+                operation: {
+                    await ClaudeOAuthCredentialsStore.withSecurityCLIReadOverrideForTesting(.dynamic { _ in
+                        securityReadCounter.increment()
+                        return securityData
+                    }) {
+                        await KeychainAccessGate.withTaskOverrideForTesting(true) {
+                            await ClaudeOAuthDelegatedRefreshCoordinator.attempt(
+                                now: Date(timeIntervalSince1970: 62000),
+                                timeout: 0.1)
+                        }
+                    }
+                })
 
             guard case .attemptedFailed = outcome else {
                 Issue.record("Expected .attemptedFailed outcome")
diff --git a/Tests/CodexBarTests/ClaudeOAuthDelegatedRefreshRecoveryTests.swift b/Tests/CodexBarTests/ClaudeOAuthDelegatedRefreshRecoveryTests.swift
index fa25a78e6f..e6827b531c 100644
--- a/Tests/CodexBarTests/ClaudeOAuthDelegatedRefreshRecoveryTests.swift
+++ b/Tests/CodexBarTests/ClaudeOAuthDelegatedRefreshRecoveryTests.swift
@@ -58,7 +58,7 @@ struct ClaudeOAuthDelegatedRefreshRecoveryTests {
     }
 
     @Test
-    func silentKeychainRepair_recoversWithoutDelegation() async throws {
+    func `silent keychain repair recovers without delegation`() async throws {
         let delegatedCounter = AsyncCounter()
         let usageResponse = try Self.makeOAuthUsageResponse()
         let tokenCapture = TokenCapture()
@@ -121,10 +121,12 @@ struct ClaudeOAuthDelegatedRefreshRecoveryTests {
                                 }
                                 let delegatedOverride: (@Sendable (
                                     Date,
-                                    TimeInterval) async -> ClaudeOAuthDelegatedRefreshCoordinator.Outcome)? = { _, _ in
-                                    _ = await delegatedCounter.increment()
-                                    return .attemptedSucceeded
-                                }
+                                    TimeInterval,
+                                    [String: String]) async -> ClaudeOAuthDelegatedRefreshCoordinator.Outcome)? =
+                                    { _, _, _ in
+                                        _ = await delegatedCounter.increment()
+                                        return .attemptedSucceeded
+                                    }
 
                                 let snapshot = try await ClaudeOAuthKeychainPromptPreference
                                     .withTaskOverrideForTesting(.onlyOnUserAction) {
@@ -162,7 +164,7 @@ struct ClaudeOAuthDelegatedRefreshRecoveryTests {
     }
 
     @Test
-    func delegatedRefresh_attemptedSucceeded_recoversAfterKeychainSync() async throws {
+    func `delegated refresh attempted succeeded recovers after keychain sync`() async throws {
         let delegatedCounter = AsyncCounter()
         let usageResponse = try Self.makeOAuthUsageResponse()
         let tokenCapture = TokenCapture()
@@ -229,13 +231,16 @@ struct ClaudeOAuthDelegatedRefreshRecoveryTests {
 
                                 let delegatedOverride: (@Sendable (
                                     Date,
-                                    TimeInterval) async -> ClaudeOAuthDelegatedRefreshCoordinator.Outcome)? = { _, _ in
-                                    // Simulate Claude CLI writing fresh credentials after the delegated refresh touch.
-                                    keychainOverrideStore.data = freshData
-                                    keychainOverrideStore.fingerprint = stubFingerprint
-                                    _ = await delegatedCounter.increment()
-                                    return .attemptedSucceeded
-                                }
+                                    TimeInterval,
+                                    [String: String]) async -> ClaudeOAuthDelegatedRefreshCoordinator.Outcome)? =
+                                    { _, _, _ in
+                                        // Simulate Claude CLI writing fresh credentials after the delegated refresh
+                                        // touch.
+                                        keychainOverrideStore.data = freshData
+                                        keychainOverrideStore.fingerprint = stubFingerprint
+                                        _ = await delegatedCounter.increment()
+                                        return .attemptedSucceeded
+                                    }
 
                                 let snapshot = try await ClaudeOAuthKeychainPromptPreference
                                     .withTaskOverrideForTesting(.always) {
@@ -274,7 +279,9 @@ struct ClaudeOAuthDelegatedRefreshRecoveryTests {
     }
 
     @Test
-    func delegatedRefresh_attemptedSucceeded_backgroundOnlyOnUserAction_doesNotRecoverFromKeychain() async throws {
+    func `delegated refresh attempted succeeded background only on user action does not recover from keychain`()
+        async throws
+    {
         let delegatedCounter = AsyncCounter()
         let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
 
@@ -331,12 +338,14 @@ struct ClaudeOAuthDelegatedRefreshRecoveryTests {
 
                             let delegatedOverride: (@Sendable (
                                 Date,
-                                TimeInterval) async -> ClaudeOAuthDelegatedRefreshCoordinator.Outcome)? = { _, _ in
-                                keychainOverrideStore.data = freshData
-                                keychainOverrideStore.fingerprint = stubFingerprint
-                                _ = await delegatedCounter.increment()
-                                return .attemptedSucceeded
-                            }
+                                TimeInterval,
+                                [String: String]) async -> ClaudeOAuthDelegatedRefreshCoordinator.Outcome)? =
+                                { _, _, _ in
+                                    keychainOverrideStore.data = freshData
+                                    keychainOverrideStore.fingerprint = stubFingerprint
+                                    _ = await delegatedCounter.increment()
+                                    return .attemptedSucceeded
+                                }
 
                             do {
                                 _ = try await ClaudeOAuthKeychainPromptPreference.withTaskOverrideForTesting(
diff --git a/Tests/CodexBarTests/ClaudeOAuthFetchStrategyAvailabilityTests.swift b/Tests/CodexBarTests/ClaudeOAuthFetchStrategyAvailabilityTests.swift
index 6bebf67a46..82f4fb58cb 100644
--- a/Tests/CodexBarTests/ClaudeOAuthFetchStrategyAvailabilityTests.swift
+++ b/Tests/CodexBarTests/ClaudeOAuthFetchStrategyAvailabilityTests.swift
@@ -19,9 +19,11 @@ struct ClaudeOAuthFetchStrategyAvailabilityTests {
         }
     }
 
-    private func makeContext(sourceMode: ProviderSourceMode) -> ProviderFetchContext {
-        let env: [String: String] = [:]
-        return ProviderFetchContext(
+    private func makeContext(
+        sourceMode: ProviderSourceMode,
+        env: [String: String] = [:]) -> ProviderFetchContext
+    {
+        ProviderFetchContext(
             runtime: .app,
             sourceMode: sourceMode,
             includeCredits: false,
@@ -48,7 +50,7 @@ struct ClaudeOAuthFetchStrategyAvailabilityTests {
     }
 
     @Test
-    func autoModeExpiredCreds_cliAvailable_returnsAvailable() async {
+    func `auto mode expired creds cli available returns available`() async {
         let context = self.makeContext(sourceMode: .auto)
         let strategy = ClaudeOAuthFetchStrategy()
         let available = await ClaudeOAuthFetchStrategy.$nonInteractiveCredentialRecordOverride
@@ -61,7 +63,7 @@ struct ClaudeOAuthFetchStrategyAvailabilityTests {
     }
 
     @Test
-    func autoModeExpiredCreds_cliUnavailable_returnsUnavailable() async {
+    func `auto mode expired creds cli unavailable returns unavailable`() async {
         let context = self.makeContext(sourceMode: .auto)
         let strategy = ClaudeOAuthFetchStrategy()
         let available = await ClaudeOAuthFetchStrategy.$nonInteractiveCredentialRecordOverride
@@ -74,7 +76,7 @@ struct ClaudeOAuthFetchStrategyAvailabilityTests {
     }
 
     @Test
-    func oauthModeExpiredCreds_cliAvailable_returnsAvailable() async {
+    func `oauth mode expired creds cli available returns available`() async {
         let context = self.makeContext(sourceMode: .oauth)
         let strategy = ClaudeOAuthFetchStrategy()
         let available = await ClaudeOAuthFetchStrategy.$nonInteractiveCredentialRecordOverride
@@ -87,7 +89,7 @@ struct ClaudeOAuthFetchStrategyAvailabilityTests {
     }
 
     @Test
-    func autoModeExpiredCodexbarCreds_cliUnavailable_stillAvailable() async {
+    func `auto mode expired codexbar creds cli unavailable still available`() async {
         let context = self.makeContext(sourceMode: .auto)
         let strategy = ClaudeOAuthFetchStrategy()
         let available = await ClaudeOAuthFetchStrategy.$nonInteractiveCredentialRecordOverride
@@ -100,7 +102,7 @@ struct ClaudeOAuthFetchStrategyAvailabilityTests {
     }
 
     @Test
-    func oauthModeDoesNotFallbackAfterOAuthFailure() {
+    func `oauth mode does not fallback after O auth failure`() {
         let context = self.makeContext(sourceMode: .oauth)
         let strategy = ClaudeOAuthFetchStrategy()
         #expect(strategy.shouldFallback(
@@ -109,7 +111,7 @@ struct ClaudeOAuthFetchStrategyAvailabilityTests {
     }
 
     @Test
-    func autoModeFallsBackAfterOAuthFailure() {
+    func `auto mode falls back after O auth failure`() {
         let context = self.makeContext(sourceMode: .auto)
         let strategy = ClaudeOAuthFetchStrategy()
         #expect(strategy.shouldFallback(
@@ -118,7 +120,7 @@ struct ClaudeOAuthFetchStrategyAvailabilityTests {
     }
 
     @Test
-    func autoMode_userInitiated_clearsKeychainCooldownGate() async {
+    func `auto mode user initiated clears keychain cooldown gate`() async {
         let context = self.makeContext(sourceMode: .auto)
         let strategy = ClaudeOAuthFetchStrategy()
         let recordWithoutRequiredScope = ClaudeOAuthCredentialRecord(
@@ -151,7 +153,7 @@ struct ClaudeOAuthFetchStrategyAvailabilityTests {
     }
 
     @Test
-    func autoMode_onlyOnUserAction_background_startup_withoutCache_isAvailableForBootstrap() async throws {
+    func `auto mode only on user action background startup without cache is available for bootstrap`() async throws {
         let context = self.makeContext(sourceMode: .auto)
         let strategy = ClaudeOAuthFetchStrategy()
         let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
@@ -175,12 +177,79 @@ struct ClaudeOAuthFetchStrategyAvailabilityTests {
                 try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
                 let fileURL = tempDir.appendingPathComponent("credentials.json")
 
-                let available = await ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
-                    await ClaudeOAuthKeychainReadStrategyPreference.withTaskOverrideForTesting(.securityFramework) {
+                let available = await KeychainAccessGate.withTaskOverrideForTesting(false) {
+                    await ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
+                        await ClaudeOAuthKeychainReadStrategyPreference.withTaskOverrideForTesting(.securityFramework) {
+                            await ClaudeOAuthKeychainPromptPreference.withTaskOverrideForTesting(.onlyOnUserAction) {
+                                await ProviderRefreshContext.$current.withValue(.startup) {
+                                    await ProviderInteractionContext.$current.withValue(.background) {
+                                        await strategy.isAvailable(context)
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                #expect(available == true)
+            }
+        }
+    }
+
+    @Test
+    func `auto mode expired Claude CLI creds env provided CLI override returns available`() async throws {
+        let tempDir = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+        let cliURL = tempDir.appendingPathComponent("claude")
+        try Data("#!/bin/sh\nexit 0\n".utf8).write(to: cliURL)
+        try FileManager.default.setAttributes([.posixPermissions: 0o755], ofItemAtPath: cliURL.path)
+
+        let context = self.makeContext(
+            sourceMode: .auto,
+            env: ["CLAUDE_CLI_PATH": cliURL.path])
+        let strategy = ClaudeOAuthFetchStrategy()
+        let available = await ClaudeOAuthFetchStrategy.$nonInteractiveCredentialRecordOverride
+            .withValue(self.expiredRecord()) {
+                await strategy.isAvailable(context)
+            }
+
+        #expect(available == true)
+    }
+
+    @Test
+    func `auto mode default reader keeps background startup bootstrap available`() async throws {
+        let context = self.makeContext(sourceMode: .auto)
+        let strategy = ClaudeOAuthFetchStrategy()
+        let service = "com.steipete.codexbar.cache.tests.\(UUID().uuidString)"
+
+        try await KeychainCacheStore.withServiceOverrideForTesting(service) {
+            KeychainCacheStore.setTestStoreForTesting(true)
+            defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+            try await ClaudeOAuthCredentialsStore.withIsolatedMemoryCacheForTesting {
+                ClaudeOAuthCredentialsStore.invalidateCache()
+                ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting()
+                ClaudeOAuthKeychainAccessGate.resetForTesting()
+                defer {
+                    ClaudeOAuthCredentialsStore.invalidateCache()
+                    ClaudeOAuthCredentialsStore._resetCredentialsFileTrackingForTesting()
+                    ClaudeOAuthKeychainAccessGate.resetForTesting()
+                }
+
+                let tempDir = FileManager.default.temporaryDirectory
+                    .appendingPathComponent(UUID().uuidString, isDirectory: true)
+                try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+                let fileURL = tempDir.appendingPathComponent("credentials.json")
+
+                let available = await KeychainAccessGate.withTaskOverrideForTesting(false) {
+                    await ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
                         await ClaudeOAuthKeychainPromptPreference.withTaskOverrideForTesting(.onlyOnUserAction) {
-                            await ProviderRefreshContext.$current.withValue(.startup) {
-                                await ProviderInteractionContext.$current.withValue(.background) {
-                                    await strategy.isAvailable(context)
+                            await ClaudeOAuthCredentialsStore.withSecurityCLIReadOverrideForTesting(.nonZeroExit) {
+                                await ProviderRefreshContext.$current.withValue(.startup) {
+                                    await ProviderInteractionContext.$current.withValue(.background) {
+                                        await strategy.isAvailable(context)
+                                    }
                                 }
                             }
                         }
@@ -193,7 +262,7 @@ struct ClaudeOAuthFetchStrategyAvailabilityTests {
     }
 
     @Test
-    func autoMode_experimental_reader_ignoresPromptPolicyCooldownGate() async {
+    func `auto mode experimental reader ignores prompt policy cooldown gate`() async {
         let context = self.makeContext(sourceMode: .auto)
         let strategy = ClaudeOAuthFetchStrategy()
         let securityData = Data("""
@@ -242,7 +311,9 @@ struct ClaudeOAuthFetchStrategyAvailabilityTests {
     }
 
     @Test
-    func autoMode_experimental_reader_securityFailure_blocksAvailabilityWhenStoredPolicyBlocksFallback() async {
+    func `auto mode experimental reader security failure blocks availability when stored policy blocks fallback`()
+        async
+    {
         let context = self.makeContext(sourceMode: .auto)
         let strategy = ClaudeOAuthFetchStrategy()
         let fallbackData = Data("""
diff --git a/Tests/CodexBarTests/ClaudeOAuthKeychainAccessGateTests.swift b/Tests/CodexBarTests/ClaudeOAuthKeychainAccessGateTests.swift
index 3854b7b124..9eab259215 100644
--- a/Tests/CodexBarTests/ClaudeOAuthKeychainAccessGateTests.swift
+++ b/Tests/CodexBarTests/ClaudeOAuthKeychainAccessGateTests.swift
@@ -5,7 +5,7 @@ import Testing
 @Suite(.serialized)
 struct ClaudeOAuthKeychainAccessGateTests {
     @Test
-    func blocksUntilCooldownExpires() {
+    func `blocks until cooldown expires`() {
         KeychainAccessGate.withTaskOverrideForTesting(false) {
             let store = ClaudeOAuthKeychainAccessGate.DeniedUntilStore()
             ClaudeOAuthKeychainAccessGate.withDeniedUntilStoreOverrideForTesting(store) {
@@ -23,7 +23,7 @@ struct ClaudeOAuthKeychainAccessGateTests {
     }
 
     @Test
-    func persistsDeniedUntil() {
+    func `persists denied until`() {
         KeychainAccessGate.withTaskOverrideForTesting(false) {
             ClaudeOAuthKeychainAccessGate.resetForTesting()
             defer { ClaudeOAuthKeychainAccessGate.resetForTesting() }
@@ -39,7 +39,7 @@ struct ClaudeOAuthKeychainAccessGateTests {
     }
 
     @Test
-    func respectsDebugDisableKeychainAccess() {
+    func `respects debug disable keychain access`() {
         KeychainAccessGate.withTaskOverrideForTesting(true) {
             ClaudeOAuthKeychainAccessGate.resetForTesting()
             defer { ClaudeOAuthKeychainAccessGate.resetForTesting() }
@@ -48,7 +48,30 @@ struct ClaudeOAuthKeychainAccessGateTests {
     }
 
     @Test
-    func clearDeniedAllowsImmediateRetry() {
+    func `process keeps keychain access disabled despite false global override`() {
+        guard ProcessInfo.processInfo.environment["CODEXBAR_ALLOW_TEST_KEYCHAIN_ACCESS"] != "1" else { return }
+        KeychainAccessGate.resetOverrideForTesting()
+        defer { KeychainAccessGate.resetOverrideForTesting() }
+
+        KeychainAccessGate.isDisabled = false
+
+        #expect(KeychainAccessGate.isDisabled)
+    }
+
+    @Test
+    func `process force disable survives settings override`() {
+        KeychainAccessGate.resetOverrideForTesting()
+        defer { KeychainAccessGate.resetOverrideForTesting() }
+
+        KeychainAccessGate.forceDisabledForProcess(reason: "unbundled-executable")
+        KeychainAccessGate.isDisabled = false
+
+        #expect(KeychainAccessGate.isDisabled)
+        #expect(KeychainAccessGate.processDisableReason == "unbundled-executable")
+    }
+
+    @Test
+    func `clear denied allows immediate retry`() {
         KeychainAccessGate.withTaskOverrideForTesting(false) {
             ClaudeOAuthKeychainAccessGate.resetForTesting()
             defer { ClaudeOAuthKeychainAccessGate.resetForTesting() }
diff --git a/Tests/CodexBarTests/ClaudeOAuthRefreshDispositionTests.swift b/Tests/CodexBarTests/ClaudeOAuthRefreshDispositionTests.swift
index 45b032c088..7950952513 100644
--- a/Tests/CodexBarTests/ClaudeOAuthRefreshDispositionTests.swift
+++ b/Tests/CodexBarTests/ClaudeOAuthRefreshDispositionTests.swift
@@ -2,24 +2,23 @@ import Foundation
 import Testing
 @testable import CodexBarCore
 
-@Suite
 struct ClaudeOAuthRefreshDispositionTests {
     @Test
-    func invalidGrant_isTerminal() {
+    func `invalid grant is terminal`() {
         let data = Data(#"{"error":"invalid_grant"}"#.utf8)
         #expect(ClaudeOAuthCredentialsStore
             .refreshFailureDispositionForTesting(statusCode: 400, data: data) == "terminalInvalidGrant")
     }
 
     @Test
-    func otherError_isTransient() {
+    func `other error is transient`() {
         let data = Data(#"{"error":"invalid_request"}"#.utf8)
         #expect(ClaudeOAuthCredentialsStore
             .refreshFailureDispositionForTesting(statusCode: 400, data: data) == "transientBackoff")
     }
 
     @Test
-    func undecodableBody_isTransient() {
+    func `undecodable body is transient`() {
         let data = Data("not-json".utf8)
         #expect(ClaudeOAuthCredentialsStore
             .refreshFailureDispositionForTesting(statusCode: 401, data: data) == "transientBackoff")
@@ -27,7 +26,7 @@ struct ClaudeOAuthRefreshDispositionTests {
     }
 
     @Test
-    func nonAuthStatus_isNotHandled() {
+    func `non auth status is not handled`() {
         let data = Data(#"{"error":"invalid_grant"}"#.utf8)
         #expect(ClaudeOAuthCredentialsStore.refreshFailureDispositionForTesting(statusCode: 500, data: data) == nil)
     }
diff --git a/Tests/CodexBarTests/ClaudeOAuthRefreshFailureGateTests.swift b/Tests/CodexBarTests/ClaudeOAuthRefreshFailureGateTests.swift
index 5ae45a4b57..107eae03fe 100644
--- a/Tests/CodexBarTests/ClaudeOAuthRefreshFailureGateTests.swift
+++ b/Tests/CodexBarTests/ClaudeOAuthRefreshFailureGateTests.swift
@@ -13,7 +13,7 @@ struct ClaudeOAuthRefreshFailureGateTests {
     private let transientFailureCountKey = "claudeOAuthRefreshTransientFailureCountV1"
 
     @Test
-    func blocksIndefinitely_whenFingerprintUnchanged() {
+    func `blocks indefinitely when fingerprint unchanged`() {
         ClaudeOAuthRefreshFailureGate.resetForTesting()
         defer { ClaudeOAuthRefreshFailureGate.resetForTesting() }
 
@@ -43,7 +43,7 @@ struct ClaudeOAuthRefreshFailureGateTests {
     }
 
     @Test
-    func migratesLegacyBlockedUntilInPast_doesNotBlockAndClearsKey() {
+    func `migrates legacy blocked until in past does not block and clears key`() {
         ClaudeOAuthRefreshFailureGate.resetForTesting()
         defer { ClaudeOAuthRefreshFailureGate.resetForTesting() }
 
@@ -57,7 +57,7 @@ struct ClaudeOAuthRefreshFailureGateTests {
     }
 
     @Test
-    func migratesLegacyBackoffToTransientBackoff_doesNotSetTerminalBlock() throws {
+    func `migrates legacy backoff to transient backoff does not set terminal block`() throws {
         ClaudeOAuthRefreshFailureGate.resetForTesting()
         defer { ClaudeOAuthRefreshFailureGate.resetForTesting() }
 
@@ -87,7 +87,7 @@ struct ClaudeOAuthRefreshFailureGateTests {
     }
 
     @Test
-    func unblocksWhenFingerprintBecomesAvailable_afterBeingUnknownAtFailure() {
+    func `unblocks when fingerprint becomes available after being unknown at failure`() {
         ClaudeOAuthRefreshFailureGate.resetForTesting()
         defer { ClaudeOAuthRefreshFailureGate.resetForTesting() }
 
@@ -112,7 +112,7 @@ struct ClaudeOAuthRefreshFailureGateTests {
     }
 
     @Test
-    func unblocksImmediately_whenFingerprintChanges() {
+    func `unblocks immediately when fingerprint changes`() {
         ClaudeOAuthRefreshFailureGate.resetForTesting()
         defer { ClaudeOAuthRefreshFailureGate.resetForTesting() }
 
@@ -139,7 +139,7 @@ struct ClaudeOAuthRefreshFailureGateTests {
     }
 
     @Test
-    func throttlesFingerprintRecheck_whileTerminalBlocked() {
+    func `throttles fingerprint recheck while terminal blocked`() {
         ClaudeOAuthRefreshFailureGate.resetForTesting()
         defer { ClaudeOAuthRefreshFailureGate.resetForTesting() }
 
@@ -174,7 +174,7 @@ struct ClaudeOAuthRefreshFailureGateTests {
     }
 
     @Test
-    func terminalBlockIsMonotonic_whenTransientFailureIsRecorded() {
+    func `terminal block is monotonic when transient failure is recorded`() {
         ClaudeOAuthRefreshFailureGate.resetForTesting()
         defer { ClaudeOAuthRefreshFailureGate.resetForTesting() }
 
@@ -197,7 +197,7 @@ struct ClaudeOAuthRefreshFailureGateTests {
     }
 
     @Test
-    func recordSuccess_clearsTerminalBlock() {
+    func `record success clears terminal block`() {
         ClaudeOAuthRefreshFailureGate.resetForTesting()
         defer { ClaudeOAuthRefreshFailureGate.resetForTesting() }
 
@@ -219,7 +219,7 @@ struct ClaudeOAuthRefreshFailureGateTests {
     }
 
     @Test
-    func transientBackoff_blocksUntilExpiry_thenUnblocks() {
+    func `transient backoff blocks until expiry then unblocks`() {
         ClaudeOAuthRefreshFailureGate.resetForTesting()
         defer { ClaudeOAuthRefreshFailureGate.resetForTesting() }
 
@@ -241,7 +241,7 @@ struct ClaudeOAuthRefreshFailureGateTests {
     }
 
     @Test
-    func transientBackoff_isExponentialAndCapped() {
+    func `transient backoff is exponential and capped`() {
         ClaudeOAuthRefreshFailureGate.resetForTesting()
         defer { ClaudeOAuthRefreshFailureGate.resetForTesting() }
 
@@ -274,7 +274,7 @@ struct ClaudeOAuthRefreshFailureGateTests {
     }
 
     @Test
-    func transientBackoff_unblocksEarly_whenFingerprintChanges() {
+    func `transient backoff unblocks early when fingerprint changes`() {
         ClaudeOAuthRefreshFailureGate.resetForTesting()
         defer { ClaudeOAuthRefreshFailureGate.resetForTesting() }
 
diff --git a/Tests/CodexBarTests/ClaudeOAuthTests.swift b/Tests/CodexBarTests/ClaudeOAuthTests.swift
index ecdf4109c8..a08fec11b8 100644
--- a/Tests/CodexBarTests/ClaudeOAuthTests.swift
+++ b/Tests/CodexBarTests/ClaudeOAuthTests.swift
@@ -2,10 +2,9 @@ import Foundation
 import Testing
 @testable import CodexBarCore
 
-@Suite
 struct ClaudeOAuthTests {
     @Test
-    func parsesOAuthCredentials() throws {
+    func `parses O auth credentials`() throws {
         let json = """
         {
           "claudeAiOauth": {
@@ -13,7 +12,8 @@ struct ClaudeOAuthTests {
             "refreshToken": "test-refresh",
             "expiresAt": 4102444800000,
             "scopes": ["usage:read"],
-            "rateLimitTier": "default_claude_max_20x"
+            "rateLimitTier": "default_claude_max_20x",
+            "subscriptionType": "pro"
           }
         }
         """
@@ -22,11 +22,12 @@ struct ClaudeOAuthTests {
         #expect(creds.refreshToken == "test-refresh")
         #expect(creds.scopes == ["usage:read"])
         #expect(creds.rateLimitTier == "default_claude_max_20x")
+        #expect(creds.subscriptionType == "pro")
         #expect(creds.isExpired == false)
     }
 
     @Test
-    func missingAccessTokenThrows() {
+    func `missing access token throws`() {
         let json = """
         {
           "claudeAiOauth": {
@@ -42,7 +43,7 @@ struct ClaudeOAuthTests {
     }
 
     @Test
-    func missingOAuthBlockThrows() {
+    func `missing O auth block throws`() {
         let json = """
         { "other": { "accessToken": "nope" } }
         """
@@ -52,7 +53,7 @@ struct ClaudeOAuthTests {
     }
 
     @Test
-    func treatsMissingExpiryAsExpired() {
+    func `treats missing expiry as expired`() {
         let creds = ClaudeOAuthCredentials(
             accessToken: "token",
             refreshToken: nil,
@@ -63,7 +64,7 @@ struct ClaudeOAuthTests {
     }
 
     @Test
-    func mapsOAuthUsageToSnapshot() throws {
+    func `maps O auth usage to snapshot`() throws {
         let json = """
         {
           "five_hour": { "utilization": 12.5, "resets_at": "2025-12-25T12:00:00.000Z" },
@@ -83,7 +84,82 @@ struct ClaudeOAuthTests {
     }
 
     @Test
-    func mapsOAuthExtraUsage() throws {
+    func `maps O auth subscription type when rate limit tier is generic`() throws {
+        let json = """
+        {
+          "five_hour": { "utilization": 12.5, "resets_at": "2025-12-25T12:00:00.000Z" }
+        }
+        """
+        let snap = try ClaudeUsageFetcher._mapOAuthUsageForTesting(
+            Data(json.utf8),
+            rateLimitTier: "default_claude_ai",
+            subscriptionType: "pro")
+        #expect(snap.loginMethod == "Claude Pro")
+    }
+
+    @Test
+    func `ignores merged O auth design usage window`() throws {
+        let json = """
+        {
+          "five_hour": { "utilization": 12.5, "resets_at": "2025-12-25T12:00:00.000Z" },
+          "seven_day_design": { "utilization": 44, "resets_at": "2025-12-31T00:00:00.000Z" },
+          "seven_day_routines": { "utilization": 18, "resets_at": "2026-01-01T00:00:00.000Z" }
+        }
+        """
+        let snap = try ClaudeUsageFetcher._mapOAuthUsageForTesting(Data(json.utf8))
+        #expect(snap.extraRateWindows.count == 1)
+        #expect(snap.extraRateWindows.contains { $0.id == "claude-design" } == false)
+        #expect(snap.extraRateWindows.first(where: { $0.id == "claude-routines" })?.title == "Daily Routines")
+        #expect(snap.extraRateWindows.first(where: { $0.id == "claude-routines" })?.window.usedPercent == 18)
+    }
+
+    @Test
+    func `ignores merged O auth omelette usage window`() throws {
+        let json = """
+        {
+          "five_hour": { "utilization": 12.5, "resets_at": "2025-12-25T12:00:00.000Z" },
+          "seven_day_omelette": { "utilization": 29, "resets_at": "2025-12-31T00:00:00.000Z" },
+          "seven_day_cowork": { "utilization": 9, "resets_at": "2026-01-01T00:00:00.000Z" }
+        }
+        """
+        let snap = try ClaudeUsageFetcher._mapOAuthUsageForTesting(Data(json.utf8))
+        #expect(snap.extraRateWindows.count == 1)
+        #expect(snap.extraRateWindows.contains { $0.id == "claude-design" } == false)
+        #expect(snap.extraRateWindows.first(where: { $0.id == "claude-routines" })?.window.usedPercent == 9)
+    }
+
+    @Test
+    func `maps O auth null cowork as zero routines window`() throws {
+        let json = """
+        {
+          "five_hour": { "utilization": 12.5, "resets_at": "2025-12-25T12:00:00.000Z" },
+          "seven_day_omelette": { "utilization": 29, "resets_at": "2025-12-31T00:00:00.000Z" },
+          "seven_day_cowork": null
+        }
+        """
+        let snap = try ClaudeUsageFetcher._mapOAuthUsageForTesting(Data(json.utf8))
+        #expect(snap.extraRateWindows.first(where: { $0.id == "claude-routines" })?.window.usedPercent == 0)
+        #expect(snap.extraRateWindows.contains { $0.id == "claude-design" } == false)
+    }
+
+    @Test
+    func `prefers populated routines alias over null alias in mixed payload`() throws {
+        let json = """
+        {
+          "five_hour": { "utilization": 12.5, "resets_at": "2025-12-25T12:00:00.000Z" },
+          "seven_day_design": null,
+          "seven_day_omelette": { "utilization": 37, "resets_at": "2025-12-31T00:00:00.000Z" },
+          "seven_day_routines": null,
+          "seven_day_cowork": { "utilization": 14, "resets_at": "2026-01-01T00:00:00.000Z" }
+        }
+        """
+        let snap = try ClaudeUsageFetcher._mapOAuthUsageForTesting(Data(json.utf8))
+        #expect(snap.extraRateWindows.contains { $0.id == "claude-design" } == false)
+        #expect(snap.extraRateWindows.first(where: { $0.id == "claude-routines" })?.window.usedPercent == 14)
+    }
+
+    @Test
+    func `maps O auth extra usage`() throws {
         // OAuth API returns values in cents (minor units), same as Web API.
         // The normalization always converts to dollars (major units).
         let json = """
@@ -100,10 +176,11 @@ struct ClaudeOAuthTests {
         #expect(snap.providerCost?.currencyCode == "USD")
         #expect(snap.providerCost?.limit == 20.5)
         #expect(snap.providerCost?.used == 3.25)
+        #expect(snap.providerCost?.period == "Monthly cap")
     }
 
     @Test
-    func mapsOAuthExtraUsageMinorUnitsAsMajorUnits() throws {
+    func `maps O auth extra usage minor units as major units`() throws {
         let json = """
         {
           "five_hour": { "utilization": 1, "resets_at": "2025-12-25T12:00:00.000Z" },
@@ -119,10 +196,93 @@ struct ClaudeOAuthTests {
         #expect(snap.providerCost?.currencyCode == "USD")
         #expect(snap.providerCost?.limit == 20)
         #expect(snap.providerCost?.used == 5.2)
+        #expect(snap.providerCost?.period == "Monthly cap")
+    }
+
+    @Test
+    func `does not display spend limit 100x too high for enterprise O auth`() throws {
+        let json = """
+        {
+          "extra_usage": {
+            "is_enabled": true,
+            "monthly_limit": 2000,
+            "used_credits": 763,
+            "utilization": 38.15,
+            "currency": "EUR"
+          }
+        }
+        """
+        let snap = try ClaudeUsageFetcher._mapOAuthUsageForTesting(
+            Data(json.utf8),
+            subscriptionType: "enterprise")
+        #expect(snap.loginMethod == "Claude Enterprise")
+        #expect(snap.primary.usedPercent == 38.15)
+        #expect(snap.primaryWindowKind == .spendLimit)
+        #expect(snap.primary.windowMinutes == nil)
+        #expect(snap.primary.resetDescription == "Spend limit: €7.63 / €20.00")
+        #expect(snap.secondary == nil)
+        #expect(snap.providerCost?.period == "Spend limit")
+        #expect(snap.providerCost?.currencyCode == "EUR")
+        #expect(snap.providerCost?.limit == 20)
+        #expect(snap.providerCost?.used == 7.63)
+
+        let usage = ClaudeOAuthFetchStrategy._snapshotForTesting(from: snap)
+        #expect(usage.primary == nil)
+        #expect(usage.providerCost?.period == "Spend limit")
+        #expect(usage.providerCost?.limit == 20)
+        #expect(usage.providerCost?.used == 7.63)
     }
 
     @Test
-    func normalizesHighLimitOAuthExtraUsage() throws {
+    func `maps O auth spend limit without plan metadata from minor units`() throws {
+        let json = """
+        {
+          "extra_usage": {
+            "is_enabled": true,
+            "monthly_limit": 2000,
+            "used_credits": 763,
+            "utilization": 38.15,
+            "currency": "EUR"
+          }
+        }
+        """
+        let snap = try ClaudeUsageFetcher._mapOAuthUsageForTesting(Data(json.utf8))
+        #expect(snap.loginMethod == nil)
+        #expect(snap.primaryWindowKind == .spendLimit)
+        #expect(snap.primary.usedPercent == 38.15)
+        #expect(snap.primary.resetDescription == "Spend limit: €7.63 / €20.00")
+        #expect(snap.providerCost?.period == "Spend limit")
+        #expect(snap.providerCost?.currencyCode == "EUR")
+        #expect(snap.providerCost?.limit == 20)
+        #expect(snap.providerCost?.used == 7.63)
+    }
+
+    @Test
+    func `maps large enterprise O auth spend limit from minor units`() throws {
+        let json = """
+        {
+          "extra_usage": {
+            "is_enabled": true,
+            "monthly_limit": 1000000,
+            "used_credits": 123456,
+            "utilization": 12.3456,
+            "currency": "USD"
+          }
+        }
+        """
+        let snap = try ClaudeUsageFetcher._mapOAuthUsageForTesting(
+            Data(json.utf8),
+            subscriptionType: "enterprise")
+        #expect(snap.primaryWindowKind == .spendLimit)
+        #expect(snap.primary.usedPercent == 12.3456)
+        #expect(snap.primary.resetDescription == "Spend limit: $1,234.56 / $10,000.00")
+        #expect(snap.providerCost?.period == "Spend limit")
+        #expect(snap.providerCost?.limit == 10000)
+        #expect(snap.providerCost?.used == 1234.56)
+    }
+
+    @Test
+    func `normalizes high limit O auth extra usage`() throws {
         let json = """
         {
           "five_hour": { "utilization": 1, "resets_at": "2025-12-25T12:00:00.000Z" },
@@ -143,7 +303,7 @@ struct ClaudeOAuthTests {
     }
 
     @Test
-    func normalizesOAuthExtraUsageCentsToMajorUnits() throws {
+    func `normalizes O auth extra usage cents to major units`() throws {
         let json = """
         {
           "five_hour": { "utilization": 1, "resets_at": "2025-12-25T12:00:00.000Z" },
@@ -162,7 +322,7 @@ struct ClaudeOAuthTests {
     }
 
     @Test
-    func prefersOpusWhenSonnetMissing() throws {
+    func `prefers opus when sonnet missing`() throws {
         let json = """
         {
           "five_hour": { "utilization": 10, "resets_at": "2025-12-25T12:00:00.000Z" },
@@ -174,7 +334,7 @@ struct ClaudeOAuthTests {
     }
 
     @Test
-    func includesBodyInOAuth403Error() {
+    func `includes body in O auth403 error`() {
         let err = ClaudeOAuthFetchError.serverError(
             403,
             "HTTP 403: OAuth token does not meet scope requirement user:profile")
@@ -183,7 +343,108 @@ struct ClaudeOAuthTests {
     }
 
     @Test
-    func oauthUsageUserAgentUsesClaudeCodeVersion() {
+    func `O auth429 error gives actionable guidance without raw body`() {
+        let err = ClaudeOAuthFetchError.rateLimited(retryAfter: nil)
+        #expect(err.localizedDescription.contains("rate limited"))
+        #expect(err.localizedDescription.contains("claude logout && claude login"))
+        #expect(!err.localizedDescription.contains("rate_limit_error"))
+    }
+
+    @Test
+    func `O auth429 usage fetch surfaces guidance without raw JSON`() async throws {
+        let fetcher = ClaudeUsageFetcher(
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            environment: [:],
+            dataSource: .oauth,
+            oauthKeychainPromptCooldownEnabled: true)
+
+        let loadCredsOverride: (@Sendable (
+            [String: String],
+            Bool,
+            Bool) async throws -> ClaudeOAuthCredentials)? = { _, _, _ in
+            ClaudeOAuthCredentials(
+                accessToken: "rate-limited-token",
+                refreshToken: "refresh-token",
+                expiresAt: Date(timeIntervalSinceNow: 3600),
+                scopes: ["user:profile"],
+                rateLimitTier: nil)
+        }
+        let fetchOverride: (@Sendable (String) async throws -> OAuthUsageResponse)? = { _ in
+            throw ClaudeOAuthFetchError.rateLimited(retryAfter: nil)
+        }
+
+        do {
+            _ = try await ClaudeUsageFetcher.$fetchOAuthUsageOverride.withValue(fetchOverride) {
+                try await ClaudeUsageFetcher.$loadOAuthCredentialsOverride.withValue(
+                    loadCredsOverride,
+                    operation: {
+                        try await fetcher.loadLatestUsage(model: "sonnet")
+                    })
+            }
+            Issue.record("Expected OAuth rate limit to fail with guidance")
+        } catch let error as ClaudeUsageError {
+            guard case let .oauthFailed(message) = error else {
+                Issue.record("Expected ClaudeUsageError.oauthFailed, got \(error)")
+                return
+            }
+            #expect(message.contains("rate limited"))
+            #expect(message.contains("claude logout && claude login"))
+            #expect(!message.contains("rate_limit_error"))
+        } catch {
+            Issue.record("Expected ClaudeUsageError, got \(error)")
+        }
+    }
+
+    @Test
+    func `O auth usage rate limit gate blocks background retries until cooldown`() {
+        ClaudeOAuthUsageRateLimitGate.resetForTesting()
+        defer { ClaudeOAuthUsageRateLimitGate.resetForTesting() }
+
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let retryAfter = now.addingTimeInterval(120)
+
+        #expect(ClaudeOAuthUsageRateLimitGate.currentBlockedUntil(now: now) == nil)
+        ClaudeOAuthUsageRateLimitGate.recordRateLimit(retryAfter: retryAfter, now: now)
+
+        #expect(ClaudeOAuthUsageRateLimitGate.currentBlockedUntil(now: now) == retryAfter)
+        #expect(ClaudeOAuthUsageRateLimitGate.blockedUntil(interaction: .background, now: now) == retryAfter)
+        #expect(ClaudeOAuthUsageRateLimitGate.blockedUntil(interaction: .userInitiated, now: now) == nil)
+        #expect(ClaudeOAuthUsageRateLimitGate.currentBlockedUntil(now: now.addingTimeInterval(119)) != nil)
+        #expect(ClaudeOAuthUsageRateLimitGate.currentBlockedUntil(now: now.addingTimeInterval(121)) == nil)
+    }
+
+    @Test
+    func `O auth retry after parses seconds`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let url = try #require(URL(string: "https://api.anthropic.com/api/oauth/usage"))
+        let response = try #require(HTTPURLResponse(
+            url: url,
+            statusCode: 429,
+            httpVersion: "HTTP/1.1",
+            headerFields: ["Retry-After": "42"]))
+
+        #expect(
+            ClaudeOAuthUsageFetcher._retryAfterDateForTesting(from: response, now: now)
+                == now.addingTimeInterval(42))
+    }
+
+    @Test
+    func `O auth retry after parses HTTP date`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let url = try #require(URL(string: "https://api.anthropic.com/api/oauth/usage"))
+        let response = try #require(HTTPURLResponse(
+            url: url,
+            statusCode: 429,
+            httpVersion: "HTTP/1.1",
+            headerFields: ["Retry-After": "Wed, 21 Oct 2015 07:28:00 GMT"]))
+
+        #expect(
+            ClaudeOAuthUsageFetcher._retryAfterDateForTesting(from: response, now: now)
+                == Date(timeIntervalSince1970: 1_445_412_480))
+    }
+
+    @Test
+    func `oauth usage user agent uses claude code version`() {
         #expect(
             ClaudeOAuthUsageFetcher._userAgentForTesting(versionString: "2.1.70 (Claude Code)")
                 == "claude-code/2.1.70")
@@ -191,7 +452,7 @@ struct ClaudeOAuthTests {
     }
 
     @Test
-    func skipsExtraUsageWhenDisabled() throws {
+    func `skips extra usage when disabled`() throws {
         let json = """
         {
           "five_hour": { "utilization": 1, "resets_at": "2025-12-25T12:00:00.000Z" },
@@ -209,7 +470,7 @@ struct ClaudeOAuthTests {
     // MARK: - Scope-based strategy resolution
 
     @Test
-    func prefersOAuthWhenAvailable() {
+    func `prefers O auth when available`() {
         let strategy = ClaudeProviderDescriptor.resolveUsageStrategy(
             selectedDataSource: .auto,
             webExtrasEnabled: false,
@@ -220,7 +481,7 @@ struct ClaudeOAuthTests {
     }
 
     @Test
-    func fallsBackToCLIWhenOAuthMissingAndCLIAvailable() {
+    func `falls back to CLI when O auth missing and CLI available`() {
         let strategy = ClaudeProviderDescriptor.resolveUsageStrategy(
             selectedDataSource: .auto,
             webExtrasEnabled: false,
@@ -231,7 +492,7 @@ struct ClaudeOAuthTests {
     }
 
     @Test
-    func fallsBackToWebWhenOAuthMissingAndCLIMissing() {
+    func `falls back to web when O auth missing and CLI missing`() {
         let strategy = ClaudeProviderDescriptor.resolveUsageStrategy(
             selectedDataSource: .auto,
             webExtrasEnabled: false,
@@ -242,7 +503,7 @@ struct ClaudeOAuthTests {
     }
 
     @Test
-    func fallsBackToCLIWhenOAuthMissingAndWebMissing() {
+    func `falls back to CLI when O auth missing and web missing`() {
         let strategy = ClaudeProviderDescriptor.resolveUsageStrategy(
             selectedDataSource: .auto,
             webExtrasEnabled: false,
diff --git a/Tests/CodexBarTests/ClaudePlanResolverTests.swift b/Tests/CodexBarTests/ClaudePlanResolverTests.swift
new file mode 100644
index 0000000000..caeb2d17d1
--- /dev/null
+++ b/Tests/CodexBarTests/ClaudePlanResolverTests.swift
@@ -0,0 +1,66 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct ClaudePlanResolverTests {
+    @Test
+    func `oauth rate limit tier maps to branded plan`() {
+        #expect(ClaudePlan.oauthLoginMethod(rateLimitTier: "default_claude_max_20x") == "Claude Max")
+        #expect(ClaudePlan.oauthLoginMethod(rateLimitTier: "claude_pro") == "Claude Pro")
+        #expect(ClaudePlan.oauthLoginMethod(rateLimitTier: "claude_team") == "Claude Team")
+        #expect(ClaudePlan.oauthLoginMethod(rateLimitTier: "claude_enterprise") == "Claude Enterprise")
+    }
+
+    @Test
+    func `oauth subscription type overrides generic rate limit tier`() {
+        #expect(
+            ClaudePlan.oauthLoginMethod(subscriptionType: "pro", rateLimitTier: "default_claude_ai")
+                == "Claude Pro")
+        #expect(
+            ClaudePlan.oauthLoginMethod(subscriptionType: "team", rateLimitTier: "default_claude_max_5x")
+                == "Claude Team")
+        #expect(ClaudePlan.oauthLoginMethod(subscriptionType: nil, rateLimitTier: "default_claude_ai") == nil)
+    }
+
+    @Test
+    func `web fallback preserves stripe Claude compatibility`() {
+        #expect(
+            ClaudePlan.webLoginMethod(
+                rateLimitTier: "default_claude",
+                billingType: "stripe_subscription")
+                == "Claude Pro")
+    }
+
+    @Test
+    func `compatibility parser understands current labels`() {
+        #expect(ClaudePlan.fromCompatibilityLoginMethod("Claude Max") == .max)
+        #expect(ClaudePlan.fromCompatibilityLoginMethod("Max") == .max)
+        #expect(ClaudePlan.fromCompatibilityLoginMethod("Claude Pro") == .pro)
+        #expect(ClaudePlan.fromCompatibilityLoginMethod("Ultra") == .ultra)
+        #expect(ClaudePlan.fromCompatibilityLoginMethod("Claude Team") == .team)
+        #expect(ClaudePlan.fromCompatibilityLoginMethod("Claude Enterprise") == .enterprise)
+    }
+
+    @Test
+    func `CLI projection keeps compact compatibility and unknown fallback`() {
+        #expect(ClaudePlan.cliCompatibilityLoginMethod("Claude Max Account") == "Max")
+        #expect(ClaudePlan.cliCompatibilityLoginMethod("Team") == "Team")
+        #expect(ClaudePlan.cliCompatibilityLoginMethod("Claude Enterprise Account") == "Enterprise")
+        #expect(ClaudePlan.cliCompatibilityLoginMethod("Claude Ultra Account") == "Ultra")
+        #expect(ClaudePlan.cliCompatibilityLoginMethod("Experimental") == "Experimental")
+        #expect(ClaudePlan.cliCompatibilityLoginMethod("Profile") == "Profile")
+        #expect(ClaudePlan.cliCompatibilityLoginMethod("Browser profile") == "Browser profile")
+    }
+
+    @Test
+    func `subscription compatibility preserves ultra and excludes enterprise`() {
+        #expect(ClaudePlan.isSubscriptionLoginMethod("Claude Max"))
+        #expect(ClaudePlan.isSubscriptionLoginMethod("Pro"))
+        #expect(ClaudePlan.isSubscriptionLoginMethod("Ultra"))
+        #expect(ClaudePlan.isSubscriptionLoginMethod("Team"))
+        #expect(!ClaudePlan.isSubscriptionLoginMethod("Claude Enterprise"))
+        #expect(!ClaudePlan.isSubscriptionLoginMethod("Profile"))
+        #expect(!ClaudePlan.isSubscriptionLoginMethod("Browser profile"))
+        #expect(!ClaudePlan.isSubscriptionLoginMethod("API"))
+    }
+}
diff --git a/Tests/CodexBarTests/ClaudeProbeWorkingDirectoryTests.swift b/Tests/CodexBarTests/ClaudeProbeWorkingDirectoryTests.swift
new file mode 100644
index 0000000000..722ce155b6
--- /dev/null
+++ b/Tests/CodexBarTests/ClaudeProbeWorkingDirectoryTests.swift
@@ -0,0 +1,156 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct ClaudeProbeWorkingDirectoryTests {
+    @Test
+    func `probe working directory disables deep link registration`() throws {
+        let directory = try Self.makeTemporaryDirectory()
+
+        try ClaudeStatusProbe.prepareProbeWorkingDirectory(at: directory)
+
+        let settings = try Self.readSettings(from: directory)
+        #expect(settings["disableDeepLinkRegistration"] as? String == "disable")
+    }
+
+    @Test
+    func `probe working directory preserves existing local settings`() throws {
+        let directory = try Self.makeTemporaryDirectory()
+        let settingsURL = directory
+            .appendingPathComponent(".claude", isDirectory: true)
+            .appendingPathComponent("settings.local.json")
+        try FileManager.default.createDirectory(
+            at: settingsURL.deletingLastPathComponent(),
+            withIntermediateDirectories: true)
+        let existing: [String: Any] = [
+            "permissions": [
+                "allow": ["Bash(*)"],
+            ],
+        ]
+        let data = try JSONSerialization.data(withJSONObject: existing)
+        try data.write(to: settingsURL)
+
+        try ClaudeStatusProbe.prepareProbeWorkingDirectory(at: directory)
+
+        let settings = try Self.readSettings(from: directory)
+        #expect(settings["disableDeepLinkRegistration"] as? String == "disable")
+        let permissions = try #require(settings["permissions"] as? [String: Any])
+        #expect(permissions["allow"] as? [String] == ["Bash(*)"])
+    }
+
+    @Test
+    func `probe working directory overwrites invalid local settings`() throws {
+        let directory = try Self.makeTemporaryDirectory()
+        let settingsURL = directory
+            .appendingPathComponent(".claude", isDirectory: true)
+            .appendingPathComponent("settings.local.json")
+        try FileManager.default.createDirectory(
+            at: settingsURL.deletingLastPathComponent(),
+            withIntermediateDirectories: true)
+        try Data("{".utf8).write(to: settingsURL)
+
+        try ClaudeStatusProbe.prepareProbeWorkingDirectory(at: directory)
+
+        let settings = try Self.readSettings(from: directory)
+        #expect(settings["disableDeepLinkRegistration"] as? String == "disable")
+    }
+
+    @Test
+    func `probe project directory name matches Claude Code encoding`() {
+        let cases = [
+            (
+                "/Users/test/Library/Application Support/CodexBar/ClaudeProbe",
+                "-Users-test-Library-Application-Support-CodexBar-ClaudeProbe"),
+            (
+                "/Users/test.name/t\u{00E9}st_under/Library/Application Support/CodexBar/ClaudeProbe",
+                "-Users-test-name-t-st-under-Library-Application-Support-CodexBar-ClaudeProbe"),
+            (
+                "/Users/test/emoji_😀/ClaudeProbe",
+                "-Users-test-emoji----ClaudeProbe"),
+            (
+                "/tmp/\(String(repeating: "segment_", count: 40))/ClaudeProbe",
+                "-tmp-segment-segment-segment-segment-segment-segment-segment-segment-segment-segment-segment-" +
+                    "segment-segment-segment-segment-segment-segment-segment-segment-segment-segment-segment-" +
+                    "segment-segment-seg-x9mpdi"),
+        ]
+
+        for (path, expected) in cases {
+            let directory = URL(fileURLWithPath: path)
+            #expect(ClaudeProbeSessionArtifactCleaner.claudeProjectDirectoryName(for: directory) == expected)
+        }
+    }
+
+    @Test
+    func `cleanup removes only probe session jsonl artifacts`() throws {
+        let probeDirectory = try Self.makeTemporaryDirectory()
+        let claudeRoot = try Self.makeTemporaryDirectory()
+        let projectsRoot = claudeRoot.appendingPathComponent("projects", isDirectory: true)
+        let probeProject = projectsRoot
+            .appendingPathComponent(
+                ClaudeProbeSessionArtifactCleaner.claudeProjectDirectoryName(for: probeDirectory),
+                isDirectory: true)
+        let unrelatedProject = projectsRoot.appendingPathComponent("unrelated-project", isDirectory: true)
+        try FileManager.default.createDirectory(at: probeProject, withIntermediateDirectories: true)
+        try FileManager.default.createDirectory(at: unrelatedProject, withIntermediateDirectories: true)
+        defer {
+            try? FileManager.default.removeItem(at: probeDirectory)
+            try? FileManager.default.removeItem(at: claudeRoot)
+        }
+
+        let probeSession = probeProject.appendingPathComponent("probe-session.jsonl")
+        let probeNote = probeProject.appendingPathComponent("keep.txt")
+        let unrelatedSession = unrelatedProject.appendingPathComponent("user-session.jsonl")
+        try Data("{}\n".utf8).write(to: probeSession)
+        try Data("keep".utf8).write(to: probeNote)
+        try Data("{}\n".utf8).write(to: unrelatedSession)
+
+        let removed = ClaudeProbeSessionArtifactCleaner.cleanupProbeSessionArtifacts(
+            probeDirectory: probeDirectory,
+            environment: ["CLAUDE_CONFIG_DIR": claudeRoot.path, "HOME": claudeRoot.path])
+
+        #expect(removed.map(\.lastPathComponent) == ["probe-session.jsonl"])
+        #expect(!FileManager.default.fileExists(atPath: probeSession.path))
+        #expect(FileManager.default.fileExists(atPath: probeNote.path))
+        #expect(FileManager.default.fileExists(atPath: unrelatedSession.path))
+    }
+
+    @Test
+    func `cleanup removes hashed long probe project artifacts`() throws {
+        let probeDirectory = URL(fileURLWithPath: "/tmp/\(String(repeating: "segment_", count: 40))/ClaudeProbe")
+        let claudeRoot = try Self.makeTemporaryDirectory()
+        let projectsRoot = claudeRoot.appendingPathComponent("projects", isDirectory: true)
+        let probeProject = projectsRoot
+            .appendingPathComponent(
+                ClaudeProbeSessionArtifactCleaner.claudeProjectDirectoryName(for: probeDirectory),
+                isDirectory: true)
+        try FileManager.default.createDirectory(at: probeProject, withIntermediateDirectories: true)
+        defer {
+            try? FileManager.default.removeItem(at: claudeRoot)
+        }
+
+        let probeSession = probeProject.appendingPathComponent("probe-session.jsonl")
+        try Data("{}\n".utf8).write(to: probeSession)
+
+        let removed = ClaudeProbeSessionArtifactCleaner.cleanupProbeSessionArtifacts(
+            probeDirectory: probeDirectory,
+            environment: ["CLAUDE_CONFIG_DIR": claudeRoot.path, "HOME": claudeRoot.path])
+
+        #expect(removed.map(\.lastPathComponent) == ["probe-session.jsonl"])
+        #expect(!FileManager.default.fileExists(atPath: probeSession.path))
+    }
+
+    private static func makeTemporaryDirectory() throws -> URL {
+        let directory = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-claude-probe-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+        return directory
+    }
+
+    private static func readSettings(from directory: URL) throws -> [String: Any] {
+        let settingsURL = directory
+            .appendingPathComponent(".claude", isDirectory: true)
+            .appendingPathComponent("settings.local.json")
+        let data = try Data(contentsOf: settingsURL)
+        return try #require(JSONSerialization.jsonObject(with: data) as? [String: Any])
+    }
+}
diff --git a/Tests/CodexBarTests/ClaudeResilienceTests.swift b/Tests/CodexBarTests/ClaudeResilienceTests.swift
index d0d7372b74..aa2c851d29 100644
--- a/Tests/CodexBarTests/ClaudeResilienceTests.swift
+++ b/Tests/CodexBarTests/ClaudeResilienceTests.swift
@@ -1,10 +1,11 @@
+import Foundation
 import Testing
 @testable import CodexBar
+@testable import CodexBarCore
 
-@Suite
 struct ClaudeResilienceTests {
     @Test
-    func suppressesSingleFlakeWhenPriorDataExists() {
+    func `suppresses single flake when prior data exists`() {
         var gate = ConsecutiveFailureGate()
         let firstFailure = gate.shouldSurfaceError(onFailureWithPriorData: true)
         let secondFailure = gate.shouldSurfaceError(onFailureWithPriorData: true)
@@ -13,18 +14,1135 @@ struct ClaudeResilienceTests {
     }
 
     @Test
-    func surfacesFailureWithoutPriorData() {
+    func `surfaces failure without prior data`() {
         var gate = ConsecutiveFailureGate()
         let shouldSurface = gate.shouldSurfaceError(onFailureWithPriorData: false)
         #expect(shouldSurface)
     }
 
     @Test
-    func resetsAfterSuccess() {
+    func `resets after success`() {
         var gate = ConsecutiveFailureGate()
         _ = gate.shouldSurfaceError(onFailureWithPriorData: true)
         gate.recordSuccess()
         let shouldSurface = gate.shouldSurfaceError(onFailureWithPriorData: true)
         #expect(shouldSurface == false)
     }
+
+    @Test
+    func `timeout keeps prior Claude snapshot without surfacing repeated failure`() async throws {
+        try await ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+            let tempDir = FileManager.default.temporaryDirectory
+                .appendingPathComponent(UUID().uuidString, isDirectory: true)
+            try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+            let fileURL = tempDir.appendingPathComponent("missing-credentials.json")
+
+            try await ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
+                let (store, prior) = try await MainActor.run {
+                    let settings = Self.makeSettingsStore(suite: "ClaudeResilienceTests-timeout-cache")
+                    settings.refreshFrequency = .manual
+                    settings.statusChecksEnabled = false
+                    settings.claudeUsageDataSource = .cli
+
+                    let metadata = ProviderRegistry.shared.metadata
+                    for provider in UsageProvider.allCases {
+                        try settings.setProviderEnabled(
+                            provider: provider,
+                            metadata: #require(metadata[provider]),
+                            enabled: provider == .claude)
+                    }
+
+                    let store = UsageStore(
+                        fetcher: UsageFetcher(environment: [:]),
+                        browserDetection: BrowserDetection(cacheTTL: 0),
+                        settings: settings,
+                        startupBehavior: .testing,
+                        environmentBase: [:])
+                    let prior = UsageSnapshot(
+                        primary: RateWindow(usedPercent: 12, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+                        secondary: RateWindow(
+                            usedPercent: 34,
+                            windowMinutes: 10080,
+                            resetsAt: nil,
+                            resetDescription: nil),
+                        updatedAt: Date(timeIntervalSince1970: 1_800_000_000),
+                        identity: ProviderIdentitySnapshot(
+                            providerID: .claude,
+                            accountEmail: "claude@example.com",
+                            accountOrganization: nil,
+                            loginMethod: "Pro"))
+                    store._setSnapshotForTesting(prior, provider: .claude)
+
+                    let baseSpec = try #require(store.providerSpecs[.claude])
+                    let descriptor = ProviderDescriptor(
+                        id: .claude,
+                        metadata: baseSpec.descriptor.metadata,
+                        branding: baseSpec.descriptor.branding,
+                        tokenCost: baseSpec.descriptor.tokenCost,
+                        fetchPlan: ProviderFetchPlan(
+                            sourceModes: [.cli],
+                            pipeline: ProviderFetchPipeline { _ in [TimeoutFetchStrategy()] }),
+                        cli: baseSpec.descriptor.cli)
+                    store.providerSpecs[.claude] = ProviderSpec(
+                        style: baseSpec.style,
+                        isEnabled: baseSpec.isEnabled,
+                        descriptor: descriptor,
+                        makeFetchContext: baseSpec.makeFetchContext)
+                    return (store, prior)
+                }
+
+                await store.refreshProvider(.claude)
+                let firstResult = await MainActor.run {
+                    (
+                        updatedAt: store.snapshot(for: .claude)?.updatedAt,
+                        hasError: store.error(for: .claude) != nil)
+                }
+
+                #expect(firstResult.updatedAt == prior.updatedAt)
+                #expect(!firstResult.hasError)
+
+                await store.refreshProvider(.claude)
+                let secondResult = await MainActor.run {
+                    (
+                        updatedAt: store.snapshot(for: .claude)?.updatedAt,
+                        hasError: store.error(for: .claude) != nil)
+                }
+
+                #expect(secondResult.updatedAt == prior.updatedAt)
+                #expect(!secondResult.hasError)
+            }
+        }
+    }
+
+    @Test
+    func `repeated non probe transient failure still surfaces`() async throws {
+        try await ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+            let tempDir = FileManager.default.temporaryDirectory
+                .appendingPathComponent(UUID().uuidString, isDirectory: true)
+            try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+            let fileURL = tempDir.appendingPathComponent("missing-credentials.json")
+
+            try await ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
+                let (store, prior) = try await MainActor.run {
+                    let settings = Self.makeSettingsStore(suite: "ClaudeResilienceTests-network-cache")
+                    settings.refreshFrequency = .manual
+                    settings.statusChecksEnabled = false
+                    settings.claudeUsageDataSource = .cli
+
+                    let metadata = ProviderRegistry.shared.metadata
+                    for provider in UsageProvider.allCases {
+                        try settings.setProviderEnabled(
+                            provider: provider,
+                            metadata: #require(metadata[provider]),
+                            enabled: provider == .claude)
+                    }
+
+                    let store = UsageStore(
+                        fetcher: UsageFetcher(environment: [:]),
+                        browserDetection: BrowserDetection(cacheTTL: 0),
+                        settings: settings,
+                        startupBehavior: .testing,
+                        environmentBase: [:])
+                    let prior = UsageSnapshot(
+                        primary: RateWindow(usedPercent: 12, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+                        secondary: nil,
+                        updatedAt: Date(timeIntervalSince1970: 1_800_000_000),
+                        identity: ProviderIdentitySnapshot(
+                            providerID: .claude,
+                            accountEmail: "claude@example.com",
+                            accountOrganization: nil,
+                            loginMethod: "Pro"))
+                    store._setSnapshotForTesting(prior, provider: .claude)
+
+                    let baseSpec = try #require(store.providerSpecs[.claude])
+                    let descriptor = ProviderDescriptor(
+                        id: .claude,
+                        metadata: baseSpec.descriptor.metadata,
+                        branding: baseSpec.descriptor.branding,
+                        tokenCost: baseSpec.descriptor.tokenCost,
+                        fetchPlan: ProviderFetchPlan(
+                            sourceModes: [.cli],
+                            pipeline: ProviderFetchPipeline { _ in [NetworkLostFetchStrategy()] }),
+                        cli: baseSpec.descriptor.cli)
+                    store.providerSpecs[.claude] = ProviderSpec(
+                        style: baseSpec.style,
+                        isEnabled: baseSpec.isEnabled,
+                        descriptor: descriptor,
+                        makeFetchContext: baseSpec.makeFetchContext)
+                    return (store, prior)
+                }
+
+                await store.refreshProvider(.claude)
+                let firstResult = await MainActor.run {
+                    (
+                        updatedAt: store.snapshot(for: .claude)?.updatedAt,
+                        hasError: store.error(for: .claude) != nil)
+                }
+
+                #expect(firstResult.updatedAt == prior.updatedAt)
+                #expect(!firstResult.hasError)
+
+                await store.refreshProvider(.claude)
+                let secondResult = await MainActor.run {
+                    (
+                        updatedAt: store.snapshot(for: .claude)?.updatedAt,
+                        hasError: store.error(for: .claude) != nil)
+                }
+
+                #expect(secondResult.updatedAt == prior.updatedAt)
+                #expect(secondResult.hasError)
+            }
+        }
+    }
+
+    @Test
+    func `credentials change clears prior Claude snapshot for non transient failure`() async throws {
+        try await KeychainCacheStore.withServiceOverrideForTesting("com.steipete.codexbar.cache.tests.\(UUID())") {
+            KeychainCacheStore.setTestStoreForTesting(true)
+            defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+            try await ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+                let tempDir = FileManager.default.temporaryDirectory
+                    .appendingPathComponent(UUID().uuidString, isDirectory: true)
+                try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+                let fileURL = tempDir.appendingPathComponent("credentials.json")
+                try Data("{}".utf8).write(to: fileURL)
+
+                try await ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
+                    #expect(ClaudeOAuthCredentialsStore.invalidateCacheIfCredentialsFileChanged())
+
+                    let store = try await MainActor.run {
+                        let settings = Self.makeSettingsStore(suite: "ClaudeResilienceTests-auth-change")
+                        settings.refreshFrequency = .manual
+                        settings.statusChecksEnabled = false
+                        settings.claudeUsageDataSource = .cli
+
+                        let metadata = ProviderRegistry.shared.metadata
+                        for provider in UsageProvider.allCases {
+                            try settings.setProviderEnabled(
+                                provider: provider,
+                                metadata: #require(metadata[provider]),
+                                enabled: provider == .claude)
+                        }
+
+                        let store = UsageStore(
+                            fetcher: UsageFetcher(environment: [:]),
+                            browserDetection: BrowserDetection(cacheTTL: 0),
+                            settings: settings,
+                            startupBehavior: .testing,
+                            environmentBase: [:])
+                        let prior = UsageSnapshot(
+                            primary: RateWindow(
+                                usedPercent: 12,
+                                windowMinutes: 300,
+                                resetsAt: nil,
+                                resetDescription: nil),
+                            secondary: nil,
+                            updatedAt: Date(timeIntervalSince1970: 1_800_000_000),
+                            identity: ProviderIdentitySnapshot(
+                                providerID: .claude,
+                                accountEmail: "old@example.com",
+                                accountOrganization: nil,
+                                loginMethod: "Pro"))
+                        store._setSnapshotForTesting(prior, provider: .claude)
+
+                        let baseSpec = try #require(store.providerSpecs[.claude])
+                        let descriptor = ProviderDescriptor(
+                            id: .claude,
+                            metadata: baseSpec.descriptor.metadata,
+                            branding: baseSpec.descriptor.branding,
+                            tokenCost: baseSpec.descriptor.tokenCost,
+                            fetchPlan: ProviderFetchPlan(
+                                sourceModes: [.cli],
+                                pipeline: ProviderFetchPipeline { _ in
+                                    [AuthFailureFetchStrategy(credentialsFileURL: fileURL)]
+                                }),
+                            cli: baseSpec.descriptor.cli)
+                        store.providerSpecs[.claude] = ProviderSpec(
+                            style: baseSpec.style,
+                            isEnabled: baseSpec.isEnabled,
+                            descriptor: descriptor,
+                            makeFetchContext: baseSpec.makeFetchContext)
+                        return store
+                    }
+
+                    await store.refreshProvider(.claude)
+                    let result = await MainActor.run {
+                        (
+                            hasSnapshot: store.snapshot(for: .claude) != nil,
+                            hasError: store.error(for: .claude) != nil)
+                    }
+
+                    #expect(!result.hasSnapshot)
+                    #expect(result.hasError)
+                }
+            }
+        }
+    }
+
+    @Test
+    func `credentials change clears prior Claude snapshot for transient failure`() async throws {
+        try await KeychainCacheStore.withServiceOverrideForTesting("com.steipete.codexbar.cache.tests.\(UUID())") {
+            KeychainCacheStore.setTestStoreForTesting(true)
+            defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+            try await ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+                let tempDir = FileManager.default.temporaryDirectory
+                    .appendingPathComponent(UUID().uuidString, isDirectory: true)
+                try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+                let fileURL = tempDir.appendingPathComponent("credentials.json")
+                try Data("{}".utf8).write(to: fileURL)
+
+                try await ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
+                    #expect(ClaudeOAuthCredentialsStore.invalidateCacheIfCredentialsFileChanged())
+
+                    let store = try await MainActor.run {
+                        let settings = Self.makeSettingsStore(suite: "ClaudeResilienceTests-transient-auth-change")
+                        settings.refreshFrequency = .manual
+                        settings.statusChecksEnabled = false
+                        settings.claudeUsageDataSource = .cli
+
+                        let metadata = ProviderRegistry.shared.metadata
+                        for provider in UsageProvider.allCases {
+                            try settings.setProviderEnabled(
+                                provider: provider,
+                                metadata: #require(metadata[provider]),
+                                enabled: provider == .claude)
+                        }
+
+                        let store = UsageStore(
+                            fetcher: UsageFetcher(environment: [:]),
+                            browserDetection: BrowserDetection(cacheTTL: 0),
+                            settings: settings,
+                            startupBehavior: .testing,
+                            environmentBase: [:])
+                        let prior = UsageSnapshot(
+                            primary: RateWindow(
+                                usedPercent: 12,
+                                windowMinutes: 300,
+                                resetsAt: nil,
+                                resetDescription: nil),
+                            secondary: nil,
+                            updatedAt: Date(timeIntervalSince1970: 1_800_000_000),
+                            identity: ProviderIdentitySnapshot(
+                                providerID: .claude,
+                                accountEmail: "old@example.com",
+                                accountOrganization: nil,
+                                loginMethod: "Pro"))
+                        store._setSnapshotForTesting(prior, provider: .claude)
+
+                        let baseSpec = try #require(store.providerSpecs[.claude])
+                        let descriptor = ProviderDescriptor(
+                            id: .claude,
+                            metadata: baseSpec.descriptor.metadata,
+                            branding: baseSpec.descriptor.branding,
+                            tokenCost: baseSpec.descriptor.tokenCost,
+                            fetchPlan: ProviderFetchPlan(
+                                sourceModes: [.cli],
+                                pipeline: ProviderFetchPipeline { _ in
+                                    [TransientFailureAfterCredentialSwapFetchStrategy(credentialsFileURL: fileURL)]
+                                }),
+                            cli: baseSpec.descriptor.cli)
+                        store.providerSpecs[.claude] = ProviderSpec(
+                            style: baseSpec.style,
+                            isEnabled: baseSpec.isEnabled,
+                            descriptor: descriptor,
+                            makeFetchContext: baseSpec.makeFetchContext)
+                        return store
+                    }
+
+                    await store.refreshProvider(.claude)
+                    let result = await MainActor.run {
+                        (
+                            hasSnapshot: store.snapshot(for: .claude) != nil,
+                            hasError: store.error(for: .claude) != nil)
+                    }
+
+                    #expect(!result.hasSnapshot)
+                    #expect(result.hasError)
+                }
+            }
+        }
+    }
+
+    @Test
+    func `keychain change clears prior Claude snapshot for transient failure`() async throws {
+        try await KeychainCacheStore.withServiceOverrideForTesting("com.steipete.codexbar.cache.tests.\(UUID())") {
+            KeychainCacheStore.setTestStoreForTesting(true)
+            defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+            let storedFingerprint = ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
+                modifiedAt: 1,
+                createdAt: 1,
+                persistentRefHash: "old")
+            let currentFingerprint = ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
+                modifiedAt: 2,
+                createdAt: 1,
+                persistentRefHash: "new")
+            let fingerprintStore = ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprintStore(
+                fingerprint: storedFingerprint)
+
+            try await ClaudeOAuthCredentialsStore.withClaudeKeychainFingerprintStoreOverrideForTesting(
+                fingerprintStore)
+            {
+                try await ClaudeOAuthKeychainPromptPreference.withTaskOverrideForTesting(.always) {
+                    try await ClaudeOAuthCredentialsStore.withKeychainAccessOverrideForTesting(false) {
+                        try await KeychainAccessGate.withTaskOverrideForTesting(false) {
+                            try await ClaudeOAuthKeychainAccessGate.withShouldAllowPromptOverrideForTesting(true) {
+                                try await ClaudeOAuthCredentialsStore.withClaudeKeychainOverridesForTesting(
+                                    data: nil,
+                                    fingerprint: currentFingerprint)
+                                {
+                                    try await ClaudeOAuthCredentialsStore
+                                        .withIsolatedCredentialsFileTrackingForTesting {
+                                            let tempDir = FileManager.default.temporaryDirectory
+                                                .appendingPathComponent(UUID().uuidString, isDirectory: true)
+                                            try FileManager.default.createDirectory(
+                                                at: tempDir,
+                                                withIntermediateDirectories: true)
+                                            let fileURL = tempDir.appendingPathComponent("missing-credentials.json")
+
+                                            try await ClaudeOAuthCredentialsStore
+                                                .withCredentialsURLOverrideForTesting(fileURL) {
+                                                    let store = try await MainActor.run {
+                                                        let settings = Self.makeSettingsStore(
+                                                            suite: "ClaudeResilienceTests-keychain-auth-change")
+                                                        settings.refreshFrequency = .manual
+                                                        settings.statusChecksEnabled = false
+                                                        settings.claudeUsageDataSource = .cli
+
+                                                        let metadata = ProviderRegistry.shared.metadata
+                                                        for provider in UsageProvider.allCases {
+                                                            try settings.setProviderEnabled(
+                                                                provider: provider,
+                                                                metadata: #require(metadata[provider]),
+                                                                enabled: provider == .claude)
+                                                        }
+
+                                                        let store = UsageStore(
+                                                            fetcher: UsageFetcher(environment: [:]),
+                                                            browserDetection: BrowserDetection(cacheTTL: 0),
+                                                            settings: settings,
+                                                            startupBehavior: .testing,
+                                                            environmentBase: [:])
+                                                        let prior = UsageSnapshot(
+                                                            primary: RateWindow(
+                                                                usedPercent: 12,
+                                                                windowMinutes: 300,
+                                                                resetsAt: nil,
+                                                                resetDescription: nil),
+                                                            secondary: nil,
+                                                            updatedAt: Date(timeIntervalSince1970: 1_800_000_000),
+                                                            identity: ProviderIdentitySnapshot(
+                                                                providerID: .claude,
+                                                                accountEmail: "old@example.com",
+                                                                accountOrganization: nil,
+                                                                loginMethod: "Pro"))
+                                                        store._setSnapshotForTesting(prior, provider: .claude)
+
+                                                        let baseSpec = try #require(store.providerSpecs[.claude])
+                                                        let descriptor = ProviderDescriptor(
+                                                            id: .claude,
+                                                            metadata: baseSpec.descriptor.metadata,
+                                                            branding: baseSpec.descriptor.branding,
+                                                            tokenCost: baseSpec.descriptor.tokenCost,
+                                                            fetchPlan: ProviderFetchPlan(
+                                                                sourceModes: [.cli],
+                                                                pipeline: ProviderFetchPipeline { _ in
+                                                                    [TimeoutFetchStrategy()]
+                                                                }),
+                                                            cli: baseSpec.descriptor.cli)
+                                                        store.providerSpecs[.claude] = ProviderSpec(
+                                                            style: baseSpec.style,
+                                                            isEnabled: baseSpec.isEnabled,
+                                                            descriptor: descriptor,
+                                                            makeFetchContext: baseSpec.makeFetchContext)
+                                                        return store
+                                                    }
+
+                                                    await store.refreshProvider(.claude)
+                                                    let result = await MainActor.run {
+                                                        (
+                                                            hasSnapshot: store.snapshot(for: .claude) != nil,
+                                                            hasError: store.error(for: .claude) != nil)
+                                                    }
+
+                                                    #expect(!result.hasSnapshot)
+                                                    #expect(result.hasError)
+                                                }
+                                        }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    func `keychain removal clears prior Claude snapshot for transient failure`() async throws {
+        try await KeychainCacheStore.withServiceOverrideForTesting("com.steipete.codexbar.cache.tests.\(UUID())") {
+            KeychainCacheStore.setTestStoreForTesting(true)
+            defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+            let storedFingerprint = ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
+                modifiedAt: 1,
+                createdAt: 1,
+                persistentRefHash: "old")
+            let fingerprintStore = ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprintStore(
+                fingerprint: storedFingerprint)
+            let keychainStore = ClaudeOAuthCredentialsStore.ClaudeKeychainOverrideStore(data: nil, fingerprint: nil)
+
+            try await ClaudeOAuthCredentialsStore.withClaudeKeychainFingerprintStoreOverrideForTesting(
+                fingerprintStore)
+            {
+                try await ClaudeOAuthKeychainPromptPreference.withTaskOverrideForTesting(.always) {
+                    try await ClaudeOAuthCredentialsStore.withKeychainAccessOverrideForTesting(false) {
+                        try await KeychainAccessGate.withTaskOverrideForTesting(false) {
+                            try await ClaudeOAuthKeychainAccessGate.withShouldAllowPromptOverrideForTesting(true) {
+                                try await ClaudeOAuthCredentialsStore.withMutableClaudeKeychainOverrideStoreForTesting(
+                                    keychainStore)
+                                {
+                                    try await ClaudeOAuthCredentialsStore
+                                        .withIsolatedCredentialsFileTrackingForTesting {
+                                            let tempDir = FileManager.default.temporaryDirectory
+                                                .appendingPathComponent(UUID().uuidString, isDirectory: true)
+                                            try FileManager.default.createDirectory(
+                                                at: tempDir,
+                                                withIntermediateDirectories: true)
+                                            let fileURL = tempDir.appendingPathComponent("missing-credentials.json")
+
+                                            try await ClaudeOAuthCredentialsStore
+                                                .withCredentialsURLOverrideForTesting(fileURL) {
+                                                    let store = try await MainActor.run {
+                                                        let settings = Self.makeSettingsStore(
+                                                            suite: "ClaudeResilienceTests-keychain-auth-removal")
+                                                        settings.refreshFrequency = .manual
+                                                        settings.statusChecksEnabled = false
+                                                        settings.claudeUsageDataSource = .cli
+
+                                                        let metadata = ProviderRegistry.shared.metadata
+                                                        for provider in UsageProvider.allCases {
+                                                            try settings.setProviderEnabled(
+                                                                provider: provider,
+                                                                metadata: #require(metadata[provider]),
+                                                                enabled: provider == .claude)
+                                                        }
+
+                                                        let store = UsageStore(
+                                                            fetcher: UsageFetcher(environment: [:]),
+                                                            browserDetection: BrowserDetection(cacheTTL: 0),
+                                                            settings: settings,
+                                                            startupBehavior: .testing,
+                                                            environmentBase: [:])
+                                                        let prior = UsageSnapshot(
+                                                            primary: RateWindow(
+                                                                usedPercent: 12,
+                                                                windowMinutes: 300,
+                                                                resetsAt: nil,
+                                                                resetDescription: nil),
+                                                            secondary: nil,
+                                                            updatedAt: Date(timeIntervalSince1970: 1_800_000_000),
+                                                            identity: ProviderIdentitySnapshot(
+                                                                providerID: .claude,
+                                                                accountEmail: "old@example.com",
+                                                                accountOrganization: nil,
+                                                                loginMethod: "Pro"))
+                                                        store._setSnapshotForTesting(prior, provider: .claude)
+
+                                                        let baseSpec = try #require(store.providerSpecs[.claude])
+                                                        let descriptor = ProviderDescriptor(
+                                                            id: .claude,
+                                                            metadata: baseSpec.descriptor.metadata,
+                                                            branding: baseSpec.descriptor.branding,
+                                                            tokenCost: baseSpec.descriptor.tokenCost,
+                                                            fetchPlan: ProviderFetchPlan(
+                                                                sourceModes: [.cli],
+                                                                pipeline: ProviderFetchPipeline { _ in
+                                                                    [TimeoutFetchStrategy()]
+                                                                }),
+                                                            cli: baseSpec.descriptor.cli)
+                                                        store.providerSpecs[.claude] = ProviderSpec(
+                                                            style: baseSpec.style,
+                                                            isEnabled: baseSpec.isEnabled,
+                                                            descriptor: descriptor,
+                                                            makeFetchContext: baseSpec.makeFetchContext)
+                                                        return store
+                                                    }
+
+                                                    await store.refreshProvider(.claude)
+                                                    let result = await MainActor.run {
+                                                        (
+                                                            hasSnapshot: store.snapshot(for: .claude) != nil,
+                                                            hasError: store.error(for: .claude) != nil,
+                                                            storedFingerprint: fingerprintStore.fingerprint)
+                                                    }
+
+                                                    #expect(!result.hasSnapshot)
+                                                    #expect(result.hasError)
+                                                    #expect(result.storedFingerprint == nil)
+                                                }
+                                        }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+extension ClaudeResilienceTests {
+    @Test
+    func `keychain probe denial preserves prior Claude snapshot for transient failure`() async throws {
+        try await KeychainCacheStore.withServiceOverrideForTesting("com.steipete.codexbar.cache.tests.\(UUID())") {
+            KeychainCacheStore.setTestStoreForTesting(true)
+            defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+            let storedFingerprint = ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
+                modifiedAt: 1,
+                createdAt: 1,
+                persistentRefHash: "old")
+            let fingerprintStore = ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprintStore(
+                fingerprint: storedFingerprint)
+            let deniedStore = ClaudeOAuthKeychainAccessGate.DeniedUntilStore()
+            deniedStore.deniedUntil = Date(timeIntervalSinceNow: 3600)
+
+            try await ClaudeOAuthCredentialsStore.withClaudeKeychainFingerprintStoreOverrideForTesting(
+                fingerprintStore)
+            {
+                try await ClaudeOAuthKeychainAccessGate.withDeniedUntilStoreOverrideForTesting(deniedStore) {
+                    try await ClaudeOAuthKeychainPromptPreference.withTaskOverrideForTesting(.always) {
+                        try await ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+                            let tempDir = FileManager.default.temporaryDirectory
+                                .appendingPathComponent(UUID().uuidString, isDirectory: true)
+                            try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+                            let fileURL = tempDir.appendingPathComponent("missing-credentials.json")
+
+                            try await ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
+                                let (store, prior) = try await MainActor.run {
+                                    let settings = Self.makeSettingsStore(
+                                        suite: "ClaudeResilienceTests-keychain-denial")
+                                    settings.refreshFrequency = .manual
+                                    settings.statusChecksEnabled = false
+                                    settings.claudeUsageDataSource = .cli
+
+                                    let metadata = ProviderRegistry.shared.metadata
+                                    for provider in UsageProvider.allCases {
+                                        try settings.setProviderEnabled(
+                                            provider: provider,
+                                            metadata: #require(metadata[provider]),
+                                            enabled: provider == .claude)
+                                    }
+
+                                    let store = UsageStore(
+                                        fetcher: UsageFetcher(environment: [:]),
+                                        browserDetection: BrowserDetection(cacheTTL: 0),
+                                        settings: settings,
+                                        startupBehavior: .testing,
+                                        environmentBase: [:])
+                                    let prior = UsageSnapshot(
+                                        primary: RateWindow(
+                                            usedPercent: 12,
+                                            windowMinutes: 300,
+                                            resetsAt: nil,
+                                            resetDescription: nil),
+                                        secondary: nil,
+                                        updatedAt: Date(timeIntervalSince1970: 1_800_000_000),
+                                        identity: ProviderIdentitySnapshot(
+                                            providerID: .claude,
+                                            accountEmail: "old@example.com",
+                                            accountOrganization: nil,
+                                            loginMethod: "Pro"))
+                                    store._setSnapshotForTesting(prior, provider: .claude)
+
+                                    let baseSpec = try #require(store.providerSpecs[.claude])
+                                    let descriptor = ProviderDescriptor(
+                                        id: .claude,
+                                        metadata: baseSpec.descriptor.metadata,
+                                        branding: baseSpec.descriptor.branding,
+                                        tokenCost: baseSpec.descriptor.tokenCost,
+                                        fetchPlan: ProviderFetchPlan(
+                                            sourceModes: [.cli],
+                                            pipeline: ProviderFetchPipeline { _ in [TimeoutFetchStrategy()] }),
+                                        cli: baseSpec.descriptor.cli)
+                                    store.providerSpecs[.claude] = ProviderSpec(
+                                        style: baseSpec.style,
+                                        isEnabled: baseSpec.isEnabled,
+                                        descriptor: descriptor,
+                                        makeFetchContext: baseSpec.makeFetchContext)
+                                    return (store, prior)
+                                }
+
+                                await store.refreshProvider(.claude)
+                                let result = await MainActor.run {
+                                    (
+                                        updatedAt: store.snapshot(for: .claude)?.updatedAt,
+                                        hasError: store.error(for: .claude) != nil,
+                                        storedFingerprint: fingerprintStore.fingerprint)
+                                }
+
+                                #expect(result.updatedAt == prior.updatedAt)
+                                #expect(!result.hasError)
+                                #expect(result.storedFingerprint == storedFingerprint)
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    func `keychain change clears once then preserves later reset backfill`() async throws {
+        try await KeychainCacheStore.withServiceOverrideForTesting("com.steipete.codexbar.cache.tests.\(UUID())") {
+            KeychainCacheStore.setTestStoreForTesting(true)
+            defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+            let resetDate = Date(timeIntervalSince1970: 1_900_000_000)
+            let storedFingerprint = ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
+                modifiedAt: 1,
+                createdAt: 1,
+                persistentRefHash: "old")
+            let currentFingerprint = ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprint(
+                modifiedAt: 2,
+                createdAt: 1,
+                persistentRefHash: "new")
+            let fingerprintStore = ClaudeOAuthCredentialsStore.ClaudeKeychainFingerprintStore(
+                fingerprint: storedFingerprint)
+
+            try await ClaudeOAuthCredentialsStore.withClaudeKeychainFingerprintStoreOverrideForTesting(
+                fingerprintStore)
+            {
+                try await ClaudeOAuthKeychainPromptPreference.withTaskOverrideForTesting(.always) {
+                    try await ClaudeOAuthCredentialsStore.withKeychainAccessOverrideForTesting(false) {
+                        try await KeychainAccessGate.withTaskOverrideForTesting(false) {
+                            try await ClaudeOAuthKeychainAccessGate.withShouldAllowPromptOverrideForTesting(true) {
+                                try await ClaudeOAuthCredentialsStore.withClaudeKeychainOverridesForTesting(
+                                    data: nil,
+                                    fingerprint: currentFingerprint)
+                                {
+                                    try await ClaudeOAuthCredentialsStore
+                                        .withIsolatedCredentialsFileTrackingForTesting {
+                                            let tempDir = FileManager.default.temporaryDirectory
+                                                .appendingPathComponent(UUID().uuidString, isDirectory: true)
+                                            try FileManager.default.createDirectory(
+                                                at: tempDir,
+                                                withIntermediateDirectories: true)
+                                            let fileURL = tempDir.appendingPathComponent("missing-credentials.json")
+
+                                            try await ClaudeOAuthCredentialsStore
+                                                .withCredentialsURLOverrideForTesting(fileURL) {
+                                                    let store = try await MainActor.run {
+                                                        let settings = Self.makeSettingsStore(
+                                                            suite: "ClaudeResilienceTests-keychain-auth-consumed")
+                                                        settings.refreshFrequency = .manual
+                                                        settings.statusChecksEnabled = false
+                                                        settings.claudeUsageDataSource = .cli
+
+                                                        let metadata = ProviderRegistry.shared.metadata
+                                                        for provider in UsageProvider.allCases {
+                                                            try settings.setProviderEnabled(
+                                                                provider: provider,
+                                                                metadata: #require(metadata[provider]),
+                                                                enabled: provider == .claude)
+                                                        }
+
+                                                        let store = UsageStore(
+                                                            fetcher: UsageFetcher(environment: [:]),
+                                                            browserDetection: BrowserDetection(cacheTTL: 0),
+                                                            settings: settings,
+                                                            startupBehavior: .testing,
+                                                            environmentBase: [:])
+                                                        let prior = UsageSnapshot(
+                                                            primary: RateWindow(
+                                                                usedPercent: 12,
+                                                                windowMinutes: 300,
+                                                                resetsAt: resetDate,
+                                                                resetDescription: "old reset"),
+                                                            secondary: nil,
+                                                            updatedAt: Date(timeIntervalSince1970: 1_800_000_000),
+                                                            identity: nil)
+                                                        store._setSnapshotForTesting(prior, provider: .claude)
+                                                        store.lastKnownResetSnapshots[.claude] = prior
+
+                                                        let baseSpec = try #require(store.providerSpecs[.claude])
+                                                        let descriptor = ProviderDescriptor(
+                                                            id: .claude,
+                                                            metadata: baseSpec.descriptor.metadata,
+                                                            branding: baseSpec.descriptor.branding,
+                                                            tokenCost: baseSpec.descriptor.tokenCost,
+                                                            fetchPlan: ProviderFetchPlan(
+                                                                sourceModes: [.cli],
+                                                                pipeline: ProviderFetchPipeline { _ in
+                                                                    [SuccessfulFetchStrategy()]
+                                                                }),
+                                                            cli: baseSpec.descriptor.cli)
+                                                        store.providerSpecs[.claude] = ProviderSpec(
+                                                            style: baseSpec.style,
+                                                            isEnabled: baseSpec.isEnabled,
+                                                            descriptor: descriptor,
+                                                            makeFetchContext: baseSpec.makeFetchContext)
+                                                        return store
+                                                    }
+
+                                                    await store.refreshProvider(.claude)
+                                                    let firstReset = await MainActor.run {
+                                                        store.snapshot(for: .claude)?.primary?.resetsAt
+                                                    }
+                                                    #expect(firstReset == nil)
+                                                    #expect(fingerprintStore.fingerprint == currentFingerprint)
+
+                                                    await MainActor.run {
+                                                        let seed = UsageSnapshot(
+                                                            primary: RateWindow(
+                                                                usedPercent: 10,
+                                                                windowMinutes: 300,
+                                                                resetsAt: resetDate,
+                                                                resetDescription: "fresh reset"),
+                                                            secondary: nil,
+                                                            updatedAt: Date(timeIntervalSince1970: 1_800_000_050),
+                                                            identity: nil)
+                                                        store.lastKnownResetSnapshots[.claude] = seed
+                                                    }
+
+                                                    await store.refreshProvider(.claude)
+                                                    let secondReset = await MainActor.run {
+                                                        store.snapshot(for: .claude)?.primary?.resetsAt
+                                                    }
+
+                                                    #expect(secondReset == resetDate)
+                                                }
+                                        }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    func `credentials change before fetch clears stale reset backfill`() async throws {
+        try await KeychainCacheStore.withServiceOverrideForTesting("com.steipete.codexbar.cache.tests.\(UUID())") {
+            KeychainCacheStore.setTestStoreForTesting(true)
+            defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+            try await ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+                let tempDir = FileManager.default.temporaryDirectory
+                    .appendingPathComponent(UUID().uuidString, isDirectory: true)
+                try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+                let fileURL = tempDir.appendingPathComponent("credentials.json")
+                try Data("{\"old\":true}".utf8).write(to: fileURL)
+
+                try await ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
+                    #expect(ClaudeOAuthCredentialsStore.invalidateCacheIfCredentialsFileChanged())
+                    try Data("{\"new\":true,\"version\":2}".utf8).write(to: fileURL)
+
+                    let store = try await MainActor.run {
+                        let settings = Self.makeSettingsStore(suite: "ClaudeResilienceTests-prefetch-auth-change")
+                        settings.refreshFrequency = .manual
+                        settings.statusChecksEnabled = false
+                        settings.claudeUsageDataSource = .cli
+
+                        let metadata = ProviderRegistry.shared.metadata
+                        for provider in UsageProvider.allCases {
+                            try settings.setProviderEnabled(
+                                provider: provider,
+                                metadata: #require(metadata[provider]),
+                                enabled: provider == .claude)
+                        }
+
+                        let store = UsageStore(
+                            fetcher: UsageFetcher(environment: [:]),
+                            browserDetection: BrowserDetection(cacheTTL: 0),
+                            settings: settings,
+                            startupBehavior: .testing,
+                            environmentBase: [:])
+                        let prior = UsageSnapshot(
+                            primary: RateWindow(
+                                usedPercent: 12,
+                                windowMinutes: 300,
+                                resetsAt: Date(timeIntervalSince1970: 1_900_000_000),
+                                resetDescription: "old reset"),
+                            secondary: nil,
+                            updatedAt: Date(timeIntervalSince1970: 1_800_000_000),
+                            identity: nil)
+                        store._setSnapshotForTesting(prior, provider: .claude)
+                        store.lastKnownResetSnapshots[.claude] = prior
+
+                        let baseSpec = try #require(store.providerSpecs[.claude])
+                        let descriptor = ProviderDescriptor(
+                            id: .claude,
+                            metadata: baseSpec.descriptor.metadata,
+                            branding: baseSpec.descriptor.branding,
+                            tokenCost: baseSpec.descriptor.tokenCost,
+                            fetchPlan: ProviderFetchPlan(
+                                sourceModes: [.cli],
+                                pipeline: ProviderFetchPipeline { _ in [SuccessfulFetchStrategy()] }),
+                            cli: baseSpec.descriptor.cli)
+                        store.providerSpecs[.claude] = ProviderSpec(
+                            style: baseSpec.style,
+                            isEnabled: baseSpec.isEnabled,
+                            descriptor: descriptor,
+                            makeFetchContext: baseSpec.makeFetchContext)
+                        return store
+                    }
+
+                    await store.refreshProvider(.claude)
+                    let reset = await MainActor.run {
+                        store.snapshot(for: .claude)?.primary?.resetsAt
+                    }
+
+                    #expect(reset == nil)
+                }
+            }
+        }
+    }
+
+    @Test
+    func `credentials change during successful Claude fetch applies fresh snapshot without stale reset`() async throws {
+        try await KeychainCacheStore.withServiceOverrideForTesting("com.steipete.codexbar.cache.tests.\(UUID())") {
+            KeychainCacheStore.setTestStoreForTesting(true)
+            defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+            try await ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+                let tempDir = FileManager.default.temporaryDirectory
+                    .appendingPathComponent(UUID().uuidString, isDirectory: true)
+                try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+                let fileURL = tempDir.appendingPathComponent("credentials.json")
+                try Data("{\"old\":true}".utf8).write(to: fileURL)
+
+                try await ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
+                    #expect(ClaudeOAuthCredentialsStore.invalidateCacheIfCredentialsFileChanged())
+
+                    let store = try await MainActor.run {
+                        let settings = Self.makeSettingsStore(suite: "ClaudeResilienceTests-midfetch-auth-change")
+                        settings.refreshFrequency = .manual
+                        settings.statusChecksEnabled = false
+                        settings.claudeUsageDataSource = .cli
+
+                        let metadata = ProviderRegistry.shared.metadata
+                        for provider in UsageProvider.allCases {
+                            try settings.setProviderEnabled(
+                                provider: provider,
+                                metadata: #require(metadata[provider]),
+                                enabled: provider == .claude)
+                        }
+
+                        let store = UsageStore(
+                            fetcher: UsageFetcher(environment: [:]),
+                            browserDetection: BrowserDetection(cacheTTL: 0),
+                            settings: settings,
+                            startupBehavior: .testing,
+                            environmentBase: [:])
+                        let prior = UsageSnapshot(
+                            primary: RateWindow(
+                                usedPercent: 12,
+                                windowMinutes: 300,
+                                resetsAt: Date(timeIntervalSince1970: 1_900_000_000),
+                                resetDescription: "old reset"),
+                            secondary: nil,
+                            updatedAt: Date(timeIntervalSince1970: 1_800_000_000),
+                            identity: ProviderIdentitySnapshot(
+                                providerID: .claude,
+                                accountEmail: "old@example.com",
+                                accountOrganization: nil,
+                                loginMethod: "Pro"))
+                        store._setSnapshotForTesting(prior, provider: .claude)
+                        store.lastKnownResetSnapshots[.claude] = prior
+
+                        let baseSpec = try #require(store.providerSpecs[.claude])
+                        let descriptor = ProviderDescriptor(
+                            id: .claude,
+                            metadata: baseSpec.descriptor.metadata,
+                            branding: baseSpec.descriptor.branding,
+                            tokenCost: baseSpec.descriptor.tokenCost,
+                            fetchPlan: ProviderFetchPlan(
+                                sourceModes: [.cli],
+                                pipeline: ProviderFetchPipeline { _ in
+                                    [SuccessfulCredentialSwapFetchStrategy(credentialsFileURL: fileURL)]
+                                }),
+                            cli: baseSpec.descriptor.cli)
+                        store.providerSpecs[.claude] = ProviderSpec(
+                            style: baseSpec.style,
+                            isEnabled: baseSpec.isEnabled,
+                            descriptor: descriptor,
+                            makeFetchContext: baseSpec.makeFetchContext)
+                        return store
+                    }
+
+                    await store.refreshProvider(.claude)
+                    let result = await MainActor.run {
+                        (
+                            hasSnapshot: store.snapshot(for: .claude) != nil,
+                            hasError: store.error(for: .claude) != nil,
+                            reset: store.lastKnownResetSnapshots[.claude]?.primary?.resetsAt)
+                    }
+
+                    #expect(result.hasSnapshot)
+                    #expect(!result.hasError)
+                    #expect(result.reset == nil)
+                }
+            }
+        }
+    }
+
+    @MainActor
+    private static func makeSettingsStore(suite: String) -> SettingsStore {
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore(),
+            codexCookieStore: InMemoryCookieHeaderStore(),
+            claudeCookieStore: InMemoryCookieHeaderStore(),
+            cursorCookieStore: InMemoryCookieHeaderStore(),
+            opencodeCookieStore: InMemoryCookieHeaderStore(),
+            factoryCookieStore: InMemoryCookieHeaderStore(),
+            minimaxCookieStore: InMemoryMiniMaxCookieStore(),
+            minimaxAPITokenStore: InMemoryMiniMaxAPITokenStore(),
+            kimiTokenStore: InMemoryKimiTokenStore(),
+            kimiK2TokenStore: InMemoryKimiK2TokenStore(),
+            augmentCookieStore: InMemoryCookieHeaderStore(),
+            ampCookieStore: InMemoryCookieHeaderStore(),
+            copilotTokenStore: InMemoryCopilotTokenStore(),
+            tokenAccountStore: InMemoryTokenAccountStore())
+        settings.providerDetectionCompleted = true
+        return settings
+    }
+}
+
+private struct TimeoutFetchStrategy: ProviderFetchStrategy {
+    let id = "test.timeout"
+    let kind: ProviderFetchKind = .cli
+
+    func isAvailable(_: ProviderFetchContext) async -> Bool {
+        true
+    }
+
+    func fetch(_: ProviderFetchContext) async throws -> ProviderFetchResult {
+        throw ClaudeStatusProbeError.timedOut
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+}
+
+private struct NetworkLostFetchStrategy: ProviderFetchStrategy {
+    let id = "test.network-lost"
+    let kind: ProviderFetchKind = .cli
+
+    func isAvailable(_: ProviderFetchContext) async -> Bool {
+        true
+    }
+
+    func fetch(_: ProviderFetchContext) async throws -> ProviderFetchResult {
+        throw URLError(.networkConnectionLost)
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+}
+
+private struct AuthFailureFetchStrategy: ProviderFetchStrategy {
+    let id = "test.auth-failure"
+    let kind: ProviderFetchKind = .cli
+    let credentialsFileURL: URL
+
+    func isAvailable(_: ProviderFetchContext) async -> Bool {
+        true
+    }
+
+    func fetch(_: ProviderFetchContext) async throws -> ProviderFetchResult {
+        try Data("{\"updated\":true}".utf8).write(to: self.credentialsFileURL)
+        _ = ClaudeOAuthCredentialsStore.invalidateCacheIfCredentialsFileChanged()
+        throw ClaudeUsageError.oauthFailed("Claude auth failed.")
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+}
+
+private struct TransientFailureAfterCredentialSwapFetchStrategy: ProviderFetchStrategy {
+    let id = "test.transient-credential-swap"
+    let kind: ProviderFetchKind = .cli
+    let credentialsFileURL: URL
+
+    func isAvailable(_: ProviderFetchContext) async -> Bool {
+        true
+    }
+
+    func fetch(_: ProviderFetchContext) async throws -> ProviderFetchResult {
+        try Data("{\"updated\":true}".utf8).write(to: self.credentialsFileURL)
+        throw ClaudeStatusProbeError.timedOut
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+}
+
+private struct SuccessfulCredentialSwapFetchStrategy: ProviderFetchStrategy {
+    let id = "test.successful-credential-swap"
+    let kind: ProviderFetchKind = .cli
+    let credentialsFileURL: URL
+
+    func isAvailable(_: ProviderFetchContext) async -> Bool {
+        true
+    }
+
+    func fetch(_: ProviderFetchContext) async throws -> ProviderFetchResult {
+        try Data("{\"updated\":true}".utf8).write(to: self.credentialsFileURL)
+        return self.makeResult(
+            usage: UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 20,
+                    windowMinutes: 300,
+                    resetsAt: nil,
+                    resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date(timeIntervalSince1970: 1_800_000_100),
+                identity: nil),
+            sourceLabel: "CLI")
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+}
+
+private struct SuccessfulFetchStrategy: ProviderFetchStrategy {
+    let id = "test.successful"
+    let kind: ProviderFetchKind = .cli
+
+    func isAvailable(_: ProviderFetchContext) async -> Bool {
+        true
+    }
+
+    func fetch(_: ProviderFetchContext) async throws -> ProviderFetchResult {
+        self.makeResult(
+            usage: UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 20,
+                    windowMinutes: 300,
+                    resetsAt: nil,
+                    resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date(timeIntervalSince1970: 1_800_000_100),
+                identity: nil),
+            sourceLabel: "CLI")
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
 }
diff --git a/Tests/CodexBarTests/ClaudeSourcePlannerTests.swift b/Tests/CodexBarTests/ClaudeSourcePlannerTests.swift
new file mode 100644
index 0000000000..c06851e1fb
--- /dev/null
+++ b/Tests/CodexBarTests/ClaudeSourcePlannerTests.swift
@@ -0,0 +1,118 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct ClaudeSourcePlannerTests {
+    @Test
+    func `app auto plan preserves ordered steps and reasons`() {
+        let plan = ClaudeSourcePlanner.resolve(input: ClaudeSourcePlanningInput(
+            runtime: .app,
+            selectedDataSource: .auto,
+            webExtrasEnabled: false,
+            hasWebSession: true,
+            hasCLI: true,
+            hasOAuthCredentials: true))
+
+        #expect(plan.orderedSteps.map(\.dataSource) == [.oauth, .cli, .web])
+        #expect(plan.orderedSteps.map(\.inclusionReason) == [
+            .appAutoPreferredOAuth,
+            .appAutoFallbackCLI,
+            .appAutoFallbackWeb,
+        ])
+        #expect(plan.availableSteps.map(\.dataSource) == [.oauth, .cli, .web])
+        #expect(plan.preferredStep?.dataSource == .oauth)
+    }
+
+    @Test
+    func `CLI auto plan preserves ordered steps and reasons`() {
+        let plan = ClaudeSourcePlanner.resolve(input: ClaudeSourcePlanningInput(
+            runtime: .cli,
+            selectedDataSource: .auto,
+            webExtrasEnabled: false,
+            hasWebSession: true,
+            hasCLI: true,
+            hasOAuthCredentials: false))
+
+        #expect(plan.orderedSteps.map(\.dataSource) == [.web, .cli])
+        #expect(plan.orderedSteps.map(\.inclusionReason) == [
+            .cliAutoPreferredWeb,
+            .cliAutoFallbackCLI,
+        ])
+        #expect(plan.preferredStep?.dataSource == .web)
+    }
+
+    @Test
+    func `explicit mode plan is single step`() {
+        let plan = ClaudeSourcePlanner.resolve(input: ClaudeSourcePlanningInput(
+            runtime: .app,
+            selectedDataSource: .cli,
+            webExtrasEnabled: true,
+            hasWebSession: false,
+            hasCLI: true,
+            hasOAuthCredentials: false))
+
+        #expect(plan.orderedSteps.count == 1)
+        #expect(plan.orderedSteps.first?.dataSource == .cli)
+        #expect(plan.orderedSteps.first?.inclusionReason == .explicitSourceSelection)
+        #expect(plan.compatibilityStrategy == ClaudeUsageStrategy(dataSource: .cli, useWebExtras: true))
+    }
+
+    @Test
+    func `app auto CLI fallback reports web extras like runtime`() {
+        let plan = ClaudeSourcePlanner.resolve(input: ClaudeSourcePlanningInput(
+            runtime: .app,
+            selectedDataSource: .auto,
+            webExtrasEnabled: true,
+            hasWebSession: false,
+            hasCLI: true,
+            hasOAuthCredentials: false))
+
+        #expect(plan.preferredStep?.dataSource == .cli)
+        #expect(plan.compatibilityStrategy == ClaudeUsageStrategy(dataSource: .cli, useWebExtras: true))
+    }
+
+    @Test
+    func `no source planner output is deterministic`() {
+        let input = ClaudeSourcePlanningInput(
+            runtime: .app,
+            selectedDataSource: .auto,
+            webExtrasEnabled: false,
+            hasWebSession: false,
+            hasCLI: false,
+            hasOAuthCredentials: false)
+        let plan = ClaudeSourcePlanner.resolve(input: input)
+
+        #expect(plan.orderedSteps.map(\.dataSource) == [.oauth, .cli, .web])
+        #expect(plan.availableSteps.isEmpty)
+        #expect(plan.isNoSourceAvailable)
+        #expect(plan.preferredStep == nil)
+        #expect(plan.executionSteps.isEmpty)
+        #expect(plan.debugLines() == [
+            "planner_order=oauth→cli→web",
+            "planner_selected=none",
+            "planner_no_source=true",
+            "planner_step.oauth=unavailable reason=app-auto-preferred-oauth",
+            "planner_step.cli=unavailable reason=app-auto-fallback-cli",
+            "planner_step.web=unavailable reason=app-auto-fallback-web",
+        ])
+    }
+
+    @Test
+    func `CLI resolver falls back to PATH when Claude CLI path override is invalid`() throws {
+        let tempDir = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+        let binaryURL = tempDir.appendingPathComponent("claude")
+        try Data("#!/bin/sh\nexit 0\n".utf8).write(to: binaryURL)
+        try FileManager.default.setAttributes([.posixPermissions: 0o755], ofItemAtPath: binaryURL.path)
+
+        let resolved = ClaudeCLIResolver.resolvedBinaryPath(
+            environment: [
+                "CLAUDE_CLI_PATH": "/definitely/missing/claude",
+                "PATH": tempDir.path,
+            ],
+            loginPATH: nil)
+
+        #expect(resolved == binaryURL.path)
+    }
+}
diff --git a/Tests/CodexBarTests/ClaudeUsageDelegatedRefreshEnvironmentTests.swift b/Tests/CodexBarTests/ClaudeUsageDelegatedRefreshEnvironmentTests.swift
new file mode 100644
index 0000000000..06cb71eba2
--- /dev/null
+++ b/Tests/CodexBarTests/ClaudeUsageDelegatedRefreshEnvironmentTests.swift
@@ -0,0 +1,53 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct ClaudeUsageDelegatedRefreshEnvironmentTests {
+    @Test
+    func `oauth delegated retry passes fetcher environment to delegated refresh`() async throws {
+        let fetcher = ClaudeUsageFetcher(
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            environment: ["CLAUDE_CLI_PATH": "/tmp/rat110-env-claude"],
+            dataSource: .oauth,
+            oauthKeychainPromptCooldownEnabled: true)
+
+        let delegatedOverride: (@Sendable (Date, TimeInterval, [String: String]) async
+            -> ClaudeOAuthDelegatedRefreshCoordinator.Outcome)? = { _, _, environment in
+            #expect(environment["CLAUDE_CLI_PATH"] == "/tmp/rat110-env-claude")
+            return .cliUnavailable
+        }
+        let loadCredsOverride: (@Sendable (
+            [String: String],
+            Bool,
+            Bool) async throws -> ClaudeOAuthCredentials)? = { _, _, _ in
+            throw ClaudeOAuthCredentialsError.refreshDelegatedToClaudeCLI
+        }
+
+        do {
+            _ = try await ClaudeOAuthKeychainPromptPreference.withTaskOverrideForTesting(.onlyOnUserAction) {
+                try await ProviderInteractionContext.$current.withValue(.userInitiated) {
+                    try await ClaudeUsageFetcher.$delegatedRefreshAttemptOverride.withValue(
+                        delegatedOverride,
+                        operation: {
+                            try await ClaudeUsageFetcher.$loadOAuthCredentialsOverride.withValue(
+                                loadCredsOverride,
+                                operation: {
+                                    try await ClaudeUsageFetcher.$hasCachedCredentialsOverride.withValue(
+                                        false,
+                                        operation: {
+                                            try await fetcher.loadLatestUsage(model: "sonnet")
+                                        })
+                                })
+                        })
+                }
+            }
+            Issue.record("Expected delegated retry to fail when the override reports CLI unavailable")
+        } catch let error as ClaudeUsageError {
+            guard case let .oauthFailed(message) = error else {
+                Issue.record("Expected ClaudeUsageError.oauthFailed, got \(error)")
+                return
+            }
+            #expect(message.contains("Claude CLI is not available"))
+        }
+    }
+}
diff --git a/Tests/CodexBarTests/ClaudeUsageTests.swift b/Tests/CodexBarTests/ClaudeUsageTests.swift
index 7f007b8118..b52ed973d7 100644
--- a/Tests/CodexBarTests/ClaudeUsageTests.swift
+++ b/Tests/CodexBarTests/ClaudeUsageTests.swift
@@ -3,7 +3,6 @@ import Testing
 @testable import CodexBar
 @testable import CodexBarCore
 
-@Suite
 struct ClaudeUsageTests {
     private actor AsyncCounter {
         private var value = 0
@@ -29,7 +28,7 @@ struct ClaudeUsageTests {
     }
 
     @Test
-    func parsesUsageJSONWithSonnetLimit() {
+    func `parses usage JSON with sonnet limit`() {
         let json = """
         {
           "ok": true,
@@ -42,12 +41,14 @@ struct ClaudeUsageTests {
         let snap = ClaudeUsageFetcher.parse(json: data)
         #expect(snap != nil)
         #expect(snap?.primary.usedPercent == 1)
+        #expect(snap?.primary.windowMinutes == 300)
         #expect(snap?.secondary?.usedPercent == 8)
+        #expect(snap?.secondary?.windowMinutes == 10080)
         #expect(snap?.primary.resetDescription == "11am (Europe/Vienna)")
     }
 
     @Test
-    func oauthDelegatedRetry_retriesOnce_thenSucceeds() async throws {
+    func `oauth delegated retry retries once then succeeds`() async throws {
         let loadCounter = AsyncCounter()
         let delegatedCounter = AsyncCounter()
         let usageResponse = try Self.makeOAuthUsageResponse()
@@ -60,7 +61,8 @@ struct ClaudeUsageTests {
         let fetchOverride: (@Sendable (String) async throws -> OAuthUsageResponse)? = { _ in usageResponse }
         let delegatedOverride: (@Sendable (
             Date,
-            TimeInterval) async -> ClaudeOAuthDelegatedRefreshCoordinator.Outcome)? = { _, _ in
+            TimeInterval,
+            [String: String]) async -> ClaudeOAuthDelegatedRefreshCoordinator.Outcome)? = { _, _, _ in
             _ = await delegatedCounter.increment()
             return .attemptedSucceeded
         }
@@ -102,7 +104,7 @@ struct ClaudeUsageTests {
     }
 
     @Test
-    func oauthDelegatedRetry_secondAttemptStillExpired_failsCleanly() async throws {
+    func `oauth delegated retry second attempt still expired fails cleanly`() async throws {
         let loadCounter = AsyncCounter()
         let delegatedCounter = AsyncCounter()
         let fetcher = ClaudeUsageFetcher(
@@ -114,7 +116,8 @@ struct ClaudeUsageTests {
         do {
             let delegatedOverride: (@Sendable (
                 Date,
-                TimeInterval) async -> ClaudeOAuthDelegatedRefreshCoordinator.Outcome)? = { _, _ in
+                TimeInterval,
+                [String: String]) async -> ClaudeOAuthDelegatedRefreshCoordinator.Outcome)? = { _, _, _ in
                 _ = await delegatedCounter.increment()
                 return .attemptedSucceeded
             }
@@ -155,7 +158,7 @@ struct ClaudeUsageTests {
     }
 
     @Test
-    func oauthDelegatedRetry_autoMode_cliUnavailable_failsFast() async throws {
+    func `oauth delegated retry auto mode cli unavailable fails fast`() async throws {
         let loadCounter = AsyncCounter()
         let delegatedCounter = AsyncCounter()
 
@@ -165,8 +168,8 @@ struct ClaudeUsageTests {
             dataSource: .oauth,
             oauthKeychainPromptCooldownEnabled: true)
 
-        let delegatedOverride: (@Sendable (Date, TimeInterval) async -> ClaudeOAuthDelegatedRefreshCoordinator
-            .Outcome)? = { _, _ in
+        let delegatedOverride: (@Sendable (Date, TimeInterval, [String: String]) async
+            -> ClaudeOAuthDelegatedRefreshCoordinator.Outcome)? = { _, _, _ in
             _ = await delegatedCounter.increment()
             return .cliUnavailable
         }
@@ -209,7 +212,7 @@ struct ClaudeUsageTests {
     }
 
     @Test
-    func oauthDelegatedRetry_autoMode_attemptedFailed_thenNonInteractiveReloadSucceeds() async throws {
+    func `oauth delegated retry auto mode attempted failed then non interactive reload succeeds`() async throws {
         let loadCounter = AsyncCounter()
         let delegatedCounter = AsyncCounter()
         let usageResponse = try Self.makeOAuthUsageResponse()
@@ -226,8 +229,8 @@ struct ClaudeUsageTests {
             oauthKeychainPromptCooldownEnabled: true)
 
         let fetchOverride: (@Sendable (String) async throws -> OAuthUsageResponse)? = { _ in usageResponse }
-        let delegatedOverride: (@Sendable (Date, TimeInterval) async -> ClaudeOAuthDelegatedRefreshCoordinator
-            .Outcome)? = { _, _ in
+        let delegatedOverride: (@Sendable (Date, TimeInterval, [String: String]) async
+            -> ClaudeOAuthDelegatedRefreshCoordinator.Outcome)? = { _, _, _ in
             _ = await delegatedCounter.increment()
             return .attemptedFailed("no-change")
         }
@@ -274,7 +277,7 @@ struct ClaudeUsageTests {
     }
 
     @Test
-    func oauthDelegatedRetry_onlyOnUserAction_background_suppressesDelegation() async throws {
+    func `oauth delegated retry only on user action background suppresses delegation`() async throws {
         let loadCounter = AsyncCounter()
         let delegatedCounter = AsyncCounter()
 
@@ -286,7 +289,8 @@ struct ClaudeUsageTests {
 
         let delegatedOverride: (@Sendable (
             Date,
-            TimeInterval) async -> ClaudeOAuthDelegatedRefreshCoordinator.Outcome)? = { _, _ in
+            TimeInterval,
+            [String: String]) async -> ClaudeOAuthDelegatedRefreshCoordinator.Outcome)? = { _, _, _ in
             _ = await delegatedCounter.increment()
             return .attemptedSucceeded
         }
@@ -299,15 +303,23 @@ struct ClaudeUsageTests {
         }
 
         do {
-            _ = try await ClaudeOAuthKeychainPromptPreference.withTaskOverrideForTesting(.onlyOnUserAction) {
-                try await ProviderInteractionContext.$current.withValue(.background) {
-                    try await ClaudeUsageFetcher.$delegatedRefreshAttemptOverride.withValue(delegatedOverride) {
-                        try await ClaudeUsageFetcher.$loadOAuthCredentialsOverride.withValue(loadCredsOverride) {
-                            try await fetcher.loadLatestUsage(model: "sonnet")
+            _ = try await ClaudeOAuthKeychainReadStrategyPreference.withTaskOverrideForTesting(
+                .securityFramework,
+                operation: {
+                    try await ClaudeOAuthKeychainPromptPreference.withTaskOverrideForTesting(.onlyOnUserAction) {
+                        try await ProviderInteractionContext.$current.withValue(.background) {
+                            try await ClaudeUsageFetcher.$delegatedRefreshAttemptOverride.withValue(
+                                delegatedOverride)
+                            {
+                                try await ClaudeUsageFetcher.$loadOAuthCredentialsOverride.withValue(
+                                    loadCredsOverride)
+                                {
+                                    try await fetcher.loadLatestUsage(model: "sonnet")
+                                }
+                            }
                         }
                     }
-                }
-            }
+                })
             Issue.record("Expected delegated refresh to be suppressed in background")
         } catch let error as ClaudeUsageError {
             guard case let .oauthFailed(message) = error else {
@@ -324,7 +336,7 @@ struct ClaudeUsageTests {
     }
 
     @Test
-    func oauthDelegatedRetry_never_background_suppressesDelegationEvenForCLI() async throws {
+    func `oauth delegated retry never background suppresses delegation even for CLI`() async throws {
         let loadCounter = AsyncCounter()
         let delegatedCounter = AsyncCounter()
 
@@ -337,7 +349,8 @@ struct ClaudeUsageTests {
 
         let delegatedOverride: (@Sendable (
             Date,
-            TimeInterval) async -> ClaudeOAuthDelegatedRefreshCoordinator.Outcome)? = { _, _ in
+            TimeInterval,
+            [String: String]) async -> ClaudeOAuthDelegatedRefreshCoordinator.Outcome)? = { _, _, _ in
             _ = await delegatedCounter.increment()
             return .attemptedSucceeded
         }
@@ -350,15 +363,23 @@ struct ClaudeUsageTests {
         }
 
         do {
-            _ = try await ClaudeOAuthKeychainPromptPreference.withTaskOverrideForTesting(.never) {
-                try await ProviderInteractionContext.$current.withValue(.background) {
-                    try await ClaudeUsageFetcher.$delegatedRefreshAttemptOverride.withValue(delegatedOverride) {
-                        try await ClaudeUsageFetcher.$loadOAuthCredentialsOverride.withValue(loadCredsOverride) {
-                            try await fetcher.loadLatestUsage(model: "sonnet")
+            _ = try await ClaudeOAuthKeychainReadStrategyPreference.withTaskOverrideForTesting(
+                .securityFramework,
+                operation: {
+                    try await ClaudeOAuthKeychainPromptPreference.withTaskOverrideForTesting(.never) {
+                        try await ProviderInteractionContext.$current.withValue(.background) {
+                            try await ClaudeUsageFetcher.$delegatedRefreshAttemptOverride.withValue(
+                                delegatedOverride)
+                            {
+                                try await ClaudeUsageFetcher.$loadOAuthCredentialsOverride.withValue(
+                                    loadCredsOverride)
+                                {
+                                    try await fetcher.loadLatestUsage(model: "sonnet")
+                                }
+                            }
                         }
                     }
-                }
-            }
+                })
             Issue.record("Expected delegated refresh to be suppressed for prompt policy 'never'")
         } catch let error as ClaudeUsageError {
             guard case let .oauthFailed(message) = error else {
@@ -375,9 +396,10 @@ struct ClaudeUsageTests {
     }
 
     @Test
-    func oauthBootstrap_onlyOnUserAction_background_startup_allowsInteractiveReadWhenNoCache() async throws {
+    func `oauth bootstrap only on user action background startup allows interactive read when no cache`() async throws {
         final class FlagBox: @unchecked Sendable {
             var allowKeychainPromptFlags: [Bool] = []
+            var allowBackgroundPromptBootstrapFlags: [Bool] = []
         }
 
         let flags = FlagBox()
@@ -395,6 +417,7 @@ struct ClaudeUsageTests {
             Bool,
             Bool) async throws -> ClaudeOAuthCredentials)? = { _, allowKeychainPrompt, _ in
             flags.allowKeychainPromptFlags.append(allowKeychainPrompt)
+            flags.allowBackgroundPromptBootstrapFlags.append(ClaudeOAuthCredentialsStore.allowBackgroundPromptBootstrap)
             return ClaudeOAuthCredentials(
                 accessToken: "fresh-token",
                 refreshToken: "refresh-token",
@@ -418,11 +441,12 @@ struct ClaudeUsageTests {
         }
 
         #expect(flags.allowKeychainPromptFlags == [true])
+        #expect(flags.allowBackgroundPromptBootstrapFlags == [true])
         #expect(snapshot.primary.usedPercent == 7)
     }
 
     @Test
-    func oauthDelegatedRetry_onlyOnUserAction_background_allowsDelegationForCLI() async throws {
+    func `oauth delegated retry only on user action background allows delegation for CLI`() async throws {
         let loadCounter = AsyncCounter()
         let delegatedCounter = AsyncCounter()
         let usageResponse = try Self.makeOAuthUsageResponse()
@@ -442,7 +466,8 @@ struct ClaudeUsageTests {
         let fetchOverride: (@Sendable (String) async throws -> OAuthUsageResponse)? = { _ in usageResponse }
         let delegatedOverride: (@Sendable (
             Date,
-            TimeInterval) async -> ClaudeOAuthDelegatedRefreshCoordinator.Outcome)? = { _, _ in
+            TimeInterval,
+            [String: String]) async -> ClaudeOAuthDelegatedRefreshCoordinator.Outcome)? = { _, _, _ in
             _ = await delegatedCounter.increment()
             return .attemptedSucceeded
         }
@@ -482,7 +507,7 @@ struct ClaudeUsageTests {
     }
 
     @Test
-    func parsesUsageJSONWhenWeeklyMissing() {
+    func `parses usage JSON when weekly missing`() {
         let json = """
         {
           "ok": true,
@@ -497,7 +522,7 @@ struct ClaudeUsageTests {
     }
 
     @Test
-    func parsesLegacyOpusAndAccount() {
+    func `parses legacy opus and account`() {
         let json = """
         {
           "ok": true,
@@ -511,13 +536,14 @@ struct ClaudeUsageTests {
         let data = Data(json.utf8)
         let snap = ClaudeUsageFetcher.parse(json: data)
         #expect(snap?.opus?.usedPercent == 0)
+        #expect(snap?.opus?.windowMinutes == 10080)
         #expect(snap?.opus?.resetDescription?.isEmpty == true)
         #expect(snap?.accountEmail == "steipete@gmail.com")
         #expect(snap?.accountOrganization == nil)
     }
 
     @Test
-    func parsesUsageJSONWhenOnlySonnetLimitIsPresent() {
+    func `parses usage JSON when only sonnet limit is present`() {
         let json = """
         {
           "ok": true,
@@ -534,7 +560,7 @@ struct ClaudeUsageTests {
     }
 
     @Test
-    func trimsAccountFields() throws {
+    func `trims account fields`() throws {
         let cases: [[String: String?]] = [
             ["email": " steipete@gmail.com ", "org": "  Org  "],
             ["email": "", "org": " Claude Max Account "],
@@ -563,7 +589,7 @@ struct ClaudeUsageTests {
     }
 
     @Test
-    func liveClaudeFetchPTY() async throws {
+    func `live claude fetch PTY`() async throws {
         guard ProcessInfo.processInfo.environment["LIVE_CLAUDE_FETCH"] == "1" else {
             return
         }
@@ -620,7 +646,7 @@ struct ClaudeUsageTests {
     // MARK: - Web API tests
 
     @Test
-    func liveClaudeFetchWebAPI() async throws {
+    func `live claude fetch web API`() async throws {
         // Set LIVE_CLAUDE_WEB_FETCH=1 to run this test with real browser cookies
         guard ProcessInfo.processInfo.environment["LIVE_CLAUDE_WEB_FETCH"] == "1" else {
             return
@@ -641,7 +667,7 @@ struct ClaudeUsageTests {
     }
 
     @Test
-    func claudeWebAPIHasSessionKeyCheck() {
+    func `claude web API has session key check`() {
         // Quick check that hasSessionKey returns a boolean (doesn't crash)
         let hasKey = ClaudeWebAPIFetcher.hasSessionKey(browserDetection: BrowserDetection(cacheTTL: 0))
         // We can't assert the value since it depends on the test environment
@@ -649,7 +675,7 @@ struct ClaudeUsageTests {
     }
 
     @Test
-    func parsesClaudeWebAPIUsageResponse() throws {
+    func `parses claude web API usage response`() throws {
         let json = """
         {
           "five_hour": { "utilization": 9, "resets_at": "2025-12-23T16:00:00.000Z" },
@@ -667,7 +693,7 @@ struct ClaudeUsageTests {
     }
 
     @Test
-    func parsesClaudeWebAPIUsageResponseWhenWeeklyMissing() throws {
+    func `parses claude web API usage response when weekly missing`() throws {
         let json = """
         {
           "five_hour": { "utilization": 9, "resets_at": "2025-12-23T16:00:00.000Z" }
@@ -680,7 +706,7 @@ struct ClaudeUsageTests {
     }
 
     @Test
-    func parsesClaudeWebAPIOverageSpendLimit() {
+    func `parses claude web API overage spend limit`() {
         let json = """
         {
           "monthly_credit_limit": 2000,
@@ -695,11 +721,11 @@ struct ClaudeUsageTests {
         #expect(cost?.currencyCode == "EUR")
         #expect(cost?.limit == 20)
         #expect(cost?.used == 0)
-        #expect(cost?.period == "Monthly")
+        #expect(cost?.period == "Monthly cap")
     }
 
     @Test
-    func parsesClaudeWebAPIOverageSpendLimitCents() {
+    func `parses claude web API overage spend limit cents`() {
         let json = """
         {
           "monthly_credit_limit": 12345,
@@ -716,7 +742,7 @@ struct ClaudeUsageTests {
     }
 
     @Test
-    func parsesClaudeWebAPIOrganizationsResponse() throws {
+    func `parses claude web API organizations response`() throws {
         let json = """
         [
           { "uuid": "org-123", "name": "Example Org", "capabilities": [] }
@@ -729,7 +755,7 @@ struct ClaudeUsageTests {
     }
 
     @Test
-    func parsesClaudeWebAPIOrganizationsPrefersChatCapabilityOverApiOnly() throws {
+    func `parses claude web API organizations prefers chat capability over api only`() throws {
         let json = """
         [
           { "uuid": "org-api", "name": "API Org", "capabilities": ["api"] },
@@ -743,7 +769,7 @@ struct ClaudeUsageTests {
     }
 
     @Test
-    func parsesClaudeWebAPIOrganizationsPrefersHybridChatOrg() throws {
+    func `parses claude web API organizations prefers hybrid chat org`() throws {
         let json = """
         [
           { "uuid": "org-api", "name": "API Org", "capabilities": ["api"] },
@@ -757,7 +783,7 @@ struct ClaudeUsageTests {
     }
 
     @Test
-    func parsesClaudeWebAPIAccountInfo() {
+    func `parses claude web API account info`() {
         let json = """
         {
           "email_address": "steipete@gmail.com",
@@ -780,7 +806,7 @@ struct ClaudeUsageTests {
     }
 
     @Test
-    func parsesClaudeWebAPIAccountInfoSelectsMatchingOrg() {
+    func `parses claude web API account info selects matching org`() {
         let json = """
         {
           "email_address": "steipete@gmail.com",
@@ -810,7 +836,7 @@ struct ClaudeUsageTests {
     }
 
     @Test
-    func parsesClaudeWebAPIAccountInfoFallsBackToFirstMembership() {
+    func `parses claude web API account info falls back to first membership`() {
         let json = """
         {
           "email_address": "steipete@gmail.com",
@@ -840,7 +866,7 @@ struct ClaudeUsageTests {
     }
 
     @Test
-    func claudeUsageFetcherInitWithDataSources() {
+    func `claude usage fetcher init with data sources`() {
         // Verify we can create fetchers with both configurations
         let browserDetection = BrowserDetection(cacheTTL: 0)
         let defaultFetcher = ClaudeUsageFetcher(browserDetection: browserDetection)
@@ -856,9 +882,530 @@ struct ClaudeUsageTests {
     }
 }
 
+struct ClaudeOAuthUsageMappingTests {
+    @Test
+    func `oauth usage falls back to weekly window when five hour is absent`() throws {
+        let json = """
+        {
+          "seven_day": { "utilization": 42, "resets_at": "2025-12-29T23:00:00.000Z" },
+          "seven_day_sonnet": { "utilization": 17, "resets_at": "2025-12-29T23:00:00.000Z" }
+        }
+        """
+        let snapshot = try ClaudeUsageFetcher._mapOAuthUsageForTesting(Data(json.utf8))
+
+        #expect(snapshot.primary.usedPercent == 42)
+        #expect(snapshot.primary.windowMinutes == 7 * 24 * 60)
+        #expect(snapshot.secondary?.usedPercent == 42)
+        #expect(snapshot.opus?.usedPercent == 17)
+    }
+
+    @Test
+    func `oauth usage falls back when five hour has no utilization`() throws {
+        let json = """
+        {
+          "five_hour": { "resets_at": "2025-12-23T16:00:00.000Z" },
+          "seven_day": { "utilization": 9, "resets_at": "2025-12-29T23:00:00.000Z" }
+        }
+        """
+        let snapshot = try ClaudeUsageFetcher._mapOAuthUsageForTesting(Data(json.utf8))
+
+        #expect(snapshot.primary.usedPercent == 9)
+        #expect(snapshot.primary.windowMinutes == 7 * 24 * 60)
+    }
+
+    @Test
+    func `oauth usage throws when no usable windows are present`() {
+        let json = "{}"
+
+        #expect(throws: ClaudeUsageError.self) {
+            try ClaudeUsageFetcher._mapOAuthUsageForTesting(Data(json.utf8))
+        }
+    }
+}
+
+@Suite(.serialized)
+struct ClaudeAutoFetcherCharacterizationTests {
+    private final class RequestLog: @unchecked Sendable {
+        private var paths: [String] = []
+        private let lock = NSLock()
+
+        func append(_ path: String) {
+            self.lock.lock()
+            defer { self.lock.unlock() }
+            self.paths.append(path)
+        }
+
+        func current() -> [String] {
+            self.lock.lock()
+            defer { self.lock.unlock() }
+            return self.paths
+        }
+    }
+
+    private final class InvocationLog: @unchecked Sendable {
+        let url: URL
+
+        init(url: URL) {
+            self.url = url
+        }
+
+        func contents() -> String {
+            (try? String(contentsOf: self.url, encoding: .utf8)) ?? ""
+        }
+    }
+
+    private static func makeOAuthUsageResponse() throws -> OAuthUsageResponse {
+        let json = """
+        {
+          "five_hour": { "utilization": 7, "resets_at": "2025-12-23T16:00:00.000Z" },
+          "seven_day": { "utilization": 21, "resets_at": "2025-12-29T23:00:00.000Z" }
+        }
+        """
+        return try ClaudeOAuthUsageFetcher._decodeUsageResponseForTesting(Data(json.utf8))
+    }
+
+    private static func makeFakeClaudeCLI(logURL: URL) throws -> URL {
+        let directory = FileManager.default.temporaryDirectory
+            .appendingPathComponent("claude-auto-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+        let scriptURL = directory.appendingPathComponent("claude")
+        let script = """
+        #!/bin/sh
+        LOG_FILE='\(logURL.path)'
+        while IFS= read -r line; do
+          case "$line" in
+            *"/usage"*)
+              printf 'usage\\n' >> "$LOG_FILE"
+              cat <<'EOF'
+        Current session
+        93% left
+        Dec 23 at 4:00PM
+        Current week (all models)
+        79% left
+        Dec 29 at 11:00PM
+        EOF
+              ;;
+            *"/status"*)
+              printf 'status\\n' >> "$LOG_FILE"
+              cat <<'EOF'
+        Account: cli@example.com
+        Org: CLI Org
+        EOF
+              ;;
+          esac
+        done
+        """
+        try script.write(to: scriptURL, atomically: true, encoding: .utf8)
+        try FileManager.default.setAttributes(
+            [.posixPermissions: NSNumber(value: Int16(0o755))],
+            ofItemAtPath: scriptURL.path)
+        return scriptURL
+    }
+
+    private func withNoOAuthCredentials<T>(operation: () async throws -> T) async rethrows -> T {
+        let missingCredentialsURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent("missing-claude-creds-\(UUID().uuidString).json")
+        return try await KeychainCacheStore.withServiceOverrideForTesting("rat-107-\(UUID().uuidString)") {
+            KeychainCacheStore.setTestStoreForTesting(true)
+            defer { KeychainCacheStore.setTestStoreForTesting(false) }
+            return try await ClaudeOAuthCredentialsStore.withIsolatedMemoryCacheForTesting {
+                try await ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+                    try await ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(missingCredentialsURL) {
+                        try await ClaudeOAuthCredentialsStore.withKeychainAccessOverrideForTesting(true) {
+                            try await ClaudeOAuthCredentialsStore.withClaudeKeychainOverridesForTesting(
+                                data: nil,
+                                fingerprint: nil)
+                            {
+                                try await operation()
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private func withClaudeWebStub<T>(
+        handler: @escaping (URLRequest) throws -> (HTTPURLResponse, Data),
+        operation: () async throws -> T) async rethrows -> T
+    {
+        let registered = URLProtocol.registerClass(ClaudeAutoFetcherStubURLProtocol.self)
+        ClaudeAutoFetcherStubURLProtocol.handler = handler
+        defer {
+            if registered {
+                URLProtocol.unregisterClass(ClaudeAutoFetcherStubURLProtocol.self)
+            }
+            ClaudeAutoFetcherStubURLProtocol.handler = nil
+        }
+        return try await operation()
+    }
+
+    fileprivate static func makeJSONResponse(
+        url: URL,
+        body: String,
+        statusCode: Int = 200) -> (HTTPURLResponse, Data)
+    {
+        let response = HTTPURLResponse(
+            url: url,
+            statusCode: statusCode,
+            httpVersion: "HTTP/1.1",
+            headerFields: ["Content-Type": "application/json"])!
+        return (response, Data(body.utf8))
+    }
+
+    @Test
+    func `auto prefers OAuth even when web and CLI appear available`() async throws {
+        let usageResponse = try Self.makeOAuthUsageResponse()
+        let cliLogURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent("claude-auto-cli-log-\(UUID().uuidString).txt")
+        let log = InvocationLog(url: cliLogURL)
+        let fakeCLI = try Self.makeFakeClaudeCLI(logURL: cliLogURL)
+        let webRequests = RequestLog()
+        let fetcher = ClaudeUsageFetcher(
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            environment: [
+                ClaudeOAuthCredentialsStore.environmentTokenKey: "oauth-token",
+                ClaudeOAuthCredentialsStore.environmentScopesKey: "user:profile",
+            ],
+            runtime: .app,
+            dataSource: .auto,
+            manualCookieHeader: "sessionKey=sk-ant-session-token")
+
+        try await ClaudeCLISession.withIsolatedSessionForTesting {
+            try await ClaudeCLIResolver.withResolvedBinaryPathOverrideForTesting(fakeCLI.path) {
+                try await self.withClaudeWebStub(handler: { request in
+                    webRequests.append(request.url?.path ?? "<missing>")
+                    let url = try #require(request.url)
+                    return Self.makeJSONResponse(url: url, body: "{}")
+                }, operation: {
+                    let fetchOverride: @Sendable (String) async throws -> OAuthUsageResponse = { _ in usageResponse }
+                    let snapshot = try await ClaudeUsageFetcher.$fetchOAuthUsageOverride.withValue(
+                        fetchOverride,
+                        operation: {
+                            try await fetcher.loadLatestUsage(model: "sonnet")
+                        })
+
+                    #expect(snapshot.primary.usedPercent == 7)
+                    #expect(snapshot.secondary?.usedPercent == 21)
+                    #expect(log.contents().isEmpty)
+                    let requests = webRequests.current()
+                    #expect(requests.isEmpty)
+                })
+            }
+        }
+    }
+
+    @Test
+    func `app runtime auto prefers CLI before web when OAuth unavailable`() async throws {
+        let cliLogURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent("claude-auto-web-log-\(UUID().uuidString).txt")
+        let log = InvocationLog(url: cliLogURL)
+        let fakeCLI = try Self.makeFakeClaudeCLI(logURL: cliLogURL)
+        let fetcher = ClaudeUsageFetcher(
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            environment: ["CLAUDE_CLI_PATH": fakeCLI.path],
+            runtime: .app,
+            dataSource: .auto,
+            manualCookieHeader: "sessionKey=sk-ant-session-token")
+
+        try await ClaudeCLISession.withIsolatedSessionForTesting {
+            try await ClaudeCLIResolver.withResolvedBinaryPathOverrideForTesting(fakeCLI.path) {
+                try await self.withNoOAuthCredentials {
+                    try await self.withClaudeWebStub(handler: { request in
+                        let url = try #require(request.url)
+                        switch url.path {
+                        case "/api/organizations":
+                            return Self.makeJSONResponse(
+                                url: url,
+                                body: #"[{"uuid":"org-123","name":"Test Org","capabilities":["chat"]}]"#)
+                        case "/api/organizations/org-123/usage":
+                            let body = """
+                            {
+                              "five_hour": { "utilization": 11, "resets_at": "2025-12-23T16:00:00.000Z" },
+                              "seven_day": { "utilization": 22, "resets_at": "2025-12-29T23:00:00.000Z" },
+                              "seven_day_opus": { "utilization": 33 }
+                            }
+                            """
+                            return Self.makeJSONResponse(
+                                url: url,
+                                body: body)
+                        case "/api/account":
+                            let body = """
+                            {
+                              "email_address": "web@example.com",
+                              "memberships": [
+                                {
+                                  "organization": {
+                                    "uuid": "org-123",
+                                    "name": "Test Org",
+                                    "rate_limit_tier": "claude_max",
+                                    "billing_type": "stripe"
+                                  }
+                                }
+                              ]
+                            }
+                            """
+                            return Self.makeJSONResponse(
+                                url: url,
+                                body: body)
+                        case "/api/organizations/org-123/overage_spend_limit":
+                            let body = """
+                            {"monthly_credit_limit":5000,"currency":"USD","used_credits":1200,"is_enabled":true}
+                            """
+                            return Self.makeJSONResponse(
+                                url: url,
+                                body: body)
+                        default:
+                            return Self.makeJSONResponse(url: url, body: "{}", statusCode: 404)
+                        }
+                    }, operation: {
+                        let snapshot = try await fetcher.loadLatestUsage(model: "sonnet")
+
+                        #expect(snapshot.rawText != nil)
+                        #expect(log.contents().contains("usage"))
+                    })
+                }
+            }
+        }
+    }
+
+    @Test
+    func `CLI runtime auto prefers web before CLI when OAuth unavailable`() async throws {
+        let cliLogURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent("claude-auto-cli-runtime-web-log-\(UUID().uuidString).txt")
+        let log = InvocationLog(url: cliLogURL)
+        let fakeCLI = try Self.makeFakeClaudeCLI(logURL: cliLogURL)
+        let fetcher = ClaudeUsageFetcher(
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            environment: ["CLAUDE_CLI_PATH": fakeCLI.path],
+            runtime: .cli,
+            dataSource: .auto,
+            manualCookieHeader: "sessionKey=sk-ant-session-token")
+
+        try await ClaudeCLISession.withIsolatedSessionForTesting {
+            try await ClaudeCLIResolver.withResolvedBinaryPathOverrideForTesting(fakeCLI.path) {
+                try await self.withNoOAuthCredentials {
+                    try await self.withClaudeWebStub(handler: { request in
+                        let url = try #require(request.url)
+                        switch url.path {
+                        case "/api/organizations":
+                            return Self.makeJSONResponse(
+                                url: url,
+                                body: #"[{"uuid":"org-123","name":"Test Org","capabilities":["chat"]}]"#)
+                        case "/api/organizations/org-123/usage":
+                            let body = """
+                            {
+                              "five_hour": { "utilization": 11, "resets_at": "2025-12-23T16:00:00.000Z" },
+                              "seven_day": { "utilization": 22, "resets_at": "2025-12-29T23:00:00.000Z" },
+                              "seven_day_opus": { "utilization": 33 }
+                            }
+                            """
+                            return Self.makeJSONResponse(url: url, body: body)
+                        case "/api/account":
+                            let body = """
+                            {
+                              "email_address": "web@example.com",
+                              "memberships": [
+                                {
+                                  "organization": {
+                                    "uuid": "org-123",
+                                    "name": "Test Org",
+                                    "rate_limit_tier": "claude_max",
+                                    "billing_type": "stripe"
+                                  }
+                                }
+                              ]
+                            }
+                            """
+                            return Self.makeJSONResponse(url: url, body: body)
+                        case "/api/organizations/org-123/overage_spend_limit":
+                            let body = """
+                            {"monthly_credit_limit":5000,"currency":"USD","used_credits":1200,"is_enabled":true}
+                            """
+                            return Self.makeJSONResponse(url: url, body: body)
+                        default:
+                            return Self.makeJSONResponse(url: url, body: "{}", statusCode: 404)
+                        }
+                    }, operation: {
+                        let snapshot = try await fetcher.loadLatestUsage(model: "sonnet")
+
+                        #expect(snapshot.primary.usedPercent == 11)
+                        #expect(snapshot.secondary?.usedPercent == 22)
+                        #expect(snapshot.opus?.usedPercent == 33)
+                        #expect(snapshot.accountEmail == "web@example.com")
+                        #expect(snapshot.loginMethod == "Claude Max")
+                        #expect(log.contents().isEmpty)
+                    })
+                }
+            }
+        }
+    }
+
+    @Test
+    func `app runtime auto fails deterministically when planner has no executable steps`() async {
+        let fetcher = ClaudeUsageFetcher(
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            environment: ["CLAUDE_CLI_PATH": "/definitely/missing/claude"],
+            runtime: .app,
+            dataSource: .auto,
+            manualCookieHeader: "foo=bar")
+
+        await self.withNoOAuthCredentials {
+            await ClaudeCLIResolver.withResolvedBinaryPathOverrideForTesting("/definitely/missing/claude") {
+                do {
+                    _ = try await fetcher.loadLatestUsage(model: "sonnet")
+                    Issue.record("Expected app auto no-source fetch to fail.")
+                } catch let error as ClaudeUsageError {
+                    #expect(error.localizedDescription.contains("Claude planner produced no executable steps."))
+                } catch {
+                    Issue.record("Unexpected error: \(error)")
+                }
+            }
+        }
+    }
+
+    @Test
+    func `CLI runtime auto fails deterministically when planner has no executable steps`() async {
+        let fetcher = ClaudeUsageFetcher(
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            environment: ["CLAUDE_CLI_PATH": "/definitely/missing/claude"],
+            runtime: .cli,
+            dataSource: .auto,
+            manualCookieHeader: "foo=bar")
+
+        await self.withNoOAuthCredentials {
+            await ClaudeCLIResolver.withResolvedBinaryPathOverrideForTesting("/definitely/missing/claude") {
+                do {
+                    _ = try await fetcher.loadLatestUsage(model: "sonnet")
+                    Issue.record("Expected CLI auto no-source fetch to fail.")
+                } catch let error as ClaudeUsageError {
+                    #expect(error.localizedDescription.contains("Claude planner produced no executable steps."))
+                } catch {
+                    Issue.record("Unexpected error: \(error)")
+                }
+            }
+        }
+    }
+}
+
+final class ClaudeAutoFetcherStubURLProtocol: URLProtocol {
+    nonisolated(unsafe) static var handler: ((URLRequest) throws -> (HTTPURLResponse, Data))?
+
+    override static func canInit(with request: URLRequest) -> Bool {
+        request.url?.host == "claude.ai"
+    }
+
+    override static func canonicalRequest(for request: URLRequest) -> URLRequest {
+        request
+    }
+
+    override func startLoading() {
+        guard let handler = Self.handler else {
+            self.client?.urlProtocol(self, didFailWithError: URLError(.badServerResponse))
+            return
+        }
+        do {
+            let (response, data) = try handler(self.request)
+            self.client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
+            self.client?.urlProtocol(self, didLoad: data)
+            self.client?.urlProtocolDidFinishLoading(self)
+        } catch {
+            self.client?.urlProtocol(self, didFailWithError: error)
+        }
+    }
+
+    override func stopLoading() {}
+}
+
+extension ClaudeAutoFetcherCharacterizationTests {
+    @Test
+    func `web fetcher uses configured target organization`() async throws {
+        let fetcher = ClaudeUsageFetcher(
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            dataSource: .web,
+            manualCookieHeader: "sessionKey=sk-ant-session-token",
+            webOrganizationID: "org-team")
+
+        try await self.withClaudeWebStub(handler: { request in
+            let url = try #require(request.url)
+            switch url.path {
+            case "/api/organizations":
+                let body = """
+                [
+                  { "uuid": "org-personal", "name": "Personal", "capabilities": ["chat"] },
+                  { "uuid": "org-team", "name": "Team Org", "capabilities": ["chat"] }
+                ]
+                """
+                return Self.makeJSONResponse(url: url, body: body)
+            case "/api/organizations/org-team/usage":
+                let body = """
+                {
+                  "five_hour": { "utilization": 14, "resets_at": "2025-12-23T16:00:00.000Z" },
+                  "seven_day": { "utilization": 28, "resets_at": "2025-12-29T23:00:00.000Z" }
+                }
+                """
+                return Self.makeJSONResponse(url: url, body: body)
+            case "/api/account":
+                let body = """
+                {
+                  "email_address": "linked@example.com",
+                  "memberships": [
+                    {
+                      "organization": {
+                        "uuid": "org-personal",
+                        "name": "Personal",
+                        "rate_limit_tier": "claude_max",
+                        "billing_type": "stripe"
+                      }
+                    },
+                    {
+                      "organization": {
+                        "uuid": "org-team",
+                        "name": "Team Org",
+                        "rate_limit_tier": "enterprise",
+                        "billing_type": "invoice"
+                      }
+                    }
+                  ]
+                }
+                """
+                return Self.makeJSONResponse(url: url, body: body)
+            case "/api/organizations/org-team/overage_spend_limit":
+                return Self.makeJSONResponse(url: url, body: "{}", statusCode: 404)
+            default:
+                return Self.makeJSONResponse(url: url, body: "{}", statusCode: 404)
+            }
+        }, operation: {
+            let snapshot = try await fetcher.loadLatestUsage(model: "sonnet")
+
+            #expect(snapshot.primary.usedPercent == 14)
+            #expect(snapshot.secondary?.usedPercent == 28)
+            #expect(snapshot.accountOrganization == "Team Org")
+            #expect(snapshot.accountEmail == "linked@example.com")
+            #expect(snapshot.loginMethod == "Claude Enterprise")
+        })
+    }
+}
+
 extension ClaudeUsageTests {
     @Test
-    func oauthDelegatedRetry_experimental_background_ignoresOnlyOnUserActionSuppression() async throws {
+    func `parses claude web API organizations honors target organization`() throws {
+        let json = """
+        [
+          { "uuid": "org-personal", "name": "Personal", "capabilities": ["chat"] },
+          { "uuid": "org-team", "name": "Team", "capabilities": ["chat"] }
+        ]
+        """
+        let data = Data(json.utf8)
+        let org = try ClaudeWebAPIFetcher._parseOrganizationsResponseForTesting(
+            data,
+            targetOrganizationID: "org-team")
+        #expect(org.id == "org-team")
+        #expect(org.name == "Team")
+    }
+
+    @Test
+    func `oauth delegated retry experimental background ignores only on user action suppression`() async throws {
         let loadCounter = AsyncCounter()
         let delegatedCounter = AsyncCounter()
         let usageResponse = try Self.makeOAuthUsageResponse()
@@ -873,7 +1420,8 @@ extension ClaudeUsageTests {
         let fetchOverride: (@Sendable (String) async throws -> OAuthUsageResponse)? = { _ in usageResponse }
         let delegatedOverride: (@Sendable (
             Date,
-            TimeInterval) async -> ClaudeOAuthDelegatedRefreshCoordinator.Outcome)? = { _, _ in
+            TimeInterval,
+            [String: String]) async -> ClaudeOAuthDelegatedRefreshCoordinator.Outcome)? = { _, _, _ in
             _ = await delegatedCounter.increment()
             return .attemptedSucceeded
         }
@@ -921,7 +1469,7 @@ extension ClaudeUsageTests {
     }
 
     @Test
-    func oauthLoad_experimental_background_fallbackBlocked_propagatesOAuthFailure() async throws {
+    func `oauth load experimental background fallback blocked propagates O auth failure`() async throws {
         final class FlagBox: @unchecked Sendable {
             var respectPromptCooldownFlags: [Bool] = []
         }
diff --git a/Tests/CodexBarTests/ClaudeWebCookieRenewalTests.swift b/Tests/CodexBarTests/ClaudeWebCookieRenewalTests.swift
new file mode 100644
index 0000000000..80ca1ba924
--- /dev/null
+++ b/Tests/CodexBarTests/ClaudeWebCookieRenewalTests.swift
@@ -0,0 +1,491 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct ClaudeWebCookieRenewalTests {
+    @Test
+    func `cached web session key renews from set cookie after successful fetch`() async throws {
+        try await self.withIsolatedCookieCache {
+            CookieHeaderCache.store(
+                provider: .claude,
+                cookieHeader: "sessionKey=sk-ant-old-token",
+                sourceLabel: "Chrome")
+            defer { CookieHeaderCache.clear(provider: .claude) }
+            let usageCookies = RequestHeaderLog()
+
+            try await self.withClaudeWebStub { request in
+                if request.url?.path == "/api/organizations/org-123/usage" {
+                    usageCookies.append(request.value(forHTTPHeaderField: "Cookie"))
+                }
+                return try Self.response(for: request, setCookie: Self.renewedSessionCookie)
+            } operation: {
+                let usage = try await ClaudeWebAPIFetcher.fetchUsage(browserDetection: BrowserDetection(cacheTTL: 0))
+
+                #expect(usage.sessionPercentUsed == 11)
+                #expect(usage.weeklyPercentUsed == 22)
+                #expect(usageCookies.values == ["sessionKey=sk-ant-renewed-token"])
+                let cached = try #require(CookieHeaderCache.load(provider: .claude))
+                #expect(cached.cookieHeader == "sessionKey=sk-ant-renewed-token")
+                #expect(cached.sourceLabel == "Chrome")
+            }
+        }
+    }
+
+    @Test
+    func `cached fetch without renewal does not block concurrent renewal`() async throws {
+        try await self.withIsolatedCookieCache {
+            CookieHeaderCache.store(
+                provider: .claude,
+                cookieHeader: "sessionKey=sk-ant-old-token",
+                sourceLabel: "Chrome",
+                now: Date(timeIntervalSince1970: 1))
+            defer { CookieHeaderCache.clear(provider: .claude) }
+            let initial = try #require(CookieHeaderCache.load(provider: .claude))
+
+            try await self.withClaudeWebStub { request in
+                try Self.response(for: request, setCookie: nil)
+            } operation: {
+                _ = try await ClaudeWebAPIFetcher.fetchUsage(browserDetection: BrowserDetection(cacheTTL: 0))
+            }
+
+            let renewed = CookieHeaderCache.storeIfCurrent(
+                provider: .claude,
+                expected: initial,
+                cookieHeader: "sessionKey=sk-ant-concurrent-renewal",
+                sourceLabel: "Chrome")
+            #expect(renewed)
+            #expect(CookieHeaderCache.load(provider: .claude)?.cookieHeader ==
+                "sessionKey=sk-ant-concurrent-renewal")
+        }
+    }
+
+    @Test
+    func `browser fallback replaces stale cache when conditional clear fails`() async throws {
+        try await self.withIsolatedCookieCache {
+            CookieHeaderCache.store(
+                provider: .claude,
+                cookieHeader: "sessionKey=sk-ant-stale-token",
+                sourceLabel: "Chrome")
+            defer { CookieHeaderCache.clear(provider: .claude) }
+            let imported = ClaudeWebAPIFetcher.SessionKeyInfo(
+                key: "sk-ant-imported-token",
+                sourceLabel: "Safari",
+                cookieCount: 1)
+
+            try await KeychainCacheStore.withClearFailureStatusOverrideForTesting(errSecInteractionNotAllowed) {
+                try await ClaudeWebSessionKeyImport.$overrideForTesting.withValue(imported) {
+                    try await self.withClaudeWebStub { request in
+                        let isStale = request.value(forHTTPHeaderField: "Cookie") ==
+                            "sessionKey=sk-ant-stale-token"
+                        if request.url?.path == "/api/organizations", isStale {
+                            let url = try #require(request.url)
+                            return Self.jsonResponse(
+                                url: url,
+                                body: "{}",
+                                statusCode: 401,
+                                setCookie: nil)
+                        }
+                        return try Self.response(for: request, setCookie: nil)
+                    } operation: {
+                        _ = try await ClaudeWebAPIFetcher.fetchUsage(
+                            browserDetection: BrowserDetection(cacheTTL: 0))
+                    }
+                }
+            }
+
+            let cached = try #require(CookieHeaderCache.load(provider: .claude))
+            #expect(cached.cookieHeader == "sessionKey=sk-ant-imported-token")
+            #expect(cached.sourceLabel == "Safari")
+        }
+    }
+
+    @Test
+    func `concurrent cached fetches serialize session key rotations`() async throws {
+        try await self.withIsolatedCookieCache {
+            CookieHeaderCache.store(
+                provider: .claude,
+                cookieHeader: "sessionKey=sk-ant-initial-token",
+                sourceLabel: "Chrome")
+            defer { CookieHeaderCache.clear(provider: .claude) }
+            let probe = ConcurrentClaudeFetchProbe()
+            let transport = ProviderHTTPTransportHandler { request in
+                let setCookie: String? = if request.url?.path == "/api/organizations" {
+                    await probe.organizationSessionCookie(
+                        requestCookie: request.value(forHTTPHeaderField: "Cookie"))
+                } else {
+                    nil
+                }
+                let (response, data) = try Self.response(for: request, setCookie: setCookie)
+                return (data, response)
+            }
+
+            try await ClaudeWebHTTPTransport.$overrideForTesting.withValue(transport) {
+                let first = Task {
+                    try await ClaudeWebAPIFetcher.fetchUsage(browserDetection: BrowserDetection(cacheTTL: 0))
+                }
+                await probe.waitForOrganizationCount(1)
+                let second = Task {
+                    try await ClaudeWebAPIFetcher.fetchUsage(browserDetection: BrowserDetection(cacheTTL: 0))
+                }
+                for _ in 0..<20 {
+                    await Task.yield()
+                }
+                #expect(await probe.organizationRequestCount == 1)
+
+                await probe.releaseFirstRequest()
+                _ = try await first.value
+                _ = try await second.value
+            }
+
+            #expect(await probe.organizationRequestCookies == [
+                "sessionKey=sk-ant-initial-token",
+                "sessionKey=sk-ant-first-rotation",
+            ])
+            #expect(CookieHeaderCache.load(provider: .claude)?.cookieHeader ==
+                "sessionKey=sk-ant-second-rotation")
+        }
+    }
+
+    @Test
+    func `cancelled waiting fetch relinquishes the serialization gate`() async throws {
+        try await self.withIsolatedCookieCache {
+            CookieHeaderCache.store(
+                provider: .claude,
+                cookieHeader: "sessionKey=sk-ant-initial-token",
+                sourceLabel: "Chrome")
+            defer { CookieHeaderCache.clear(provider: .claude) }
+            let probe = ConcurrentClaudeFetchProbe()
+            let transport = ProviderHTTPTransportHandler { request in
+                let setCookie: String? = if request.url?.path == "/api/organizations" {
+                    await probe.organizationSessionCookie(
+                        requestCookie: request.value(forHTTPHeaderField: "Cookie"))
+                } else {
+                    nil
+                }
+                let (response, data) = try Self.response(for: request, setCookie: setCookie)
+                return (data, response)
+            }
+
+            try await ClaudeWebHTTPTransport.$overrideForTesting.withValue(transport) {
+                let first = Task {
+                    try await ClaudeWebAPIFetcher.fetchUsage(browserDetection: BrowserDetection(cacheTTL: 0))
+                }
+                await probe.waitForOrganizationCount(1)
+                let cancelled = Task {
+                    try await ClaudeWebAPIFetcher.fetchUsage(browserDetection: BrowserDetection(cacheTTL: 0))
+                }
+                for _ in 0..<20 {
+                    await Task.yield()
+                }
+                cancelled.cancel()
+                await #expect(throws: CancellationError.self) {
+                    try await cancelled.value
+                }
+                #expect(await probe.organizationRequestCount == 1)
+
+                await probe.releaseFirstRequest()
+                _ = try await first.value
+                _ = try await ClaudeWebAPIFetcher.fetchUsage(browserDetection: BrowserDetection(cacheTTL: 0))
+            }
+
+            #expect(await probe.organizationRequestCookies == [
+                "sessionKey=sk-ant-initial-token",
+                "sessionKey=sk-ant-first-rotation",
+            ])
+            #expect(CookieHeaderCache.load(provider: .claude)?.cookieHeader ==
+                "sessionKey=sk-ant-second-rotation")
+        }
+    }
+
+    @Test
+    func `manual web session fetch does not rewrite cached cookie`() async throws {
+        try await self.withIsolatedCookieCache {
+            CookieHeaderCache.store(
+                provider: .claude,
+                cookieHeader: "sessionKey=sk-ant-cache-token",
+                sourceLabel: "Chrome")
+            defer { CookieHeaderCache.clear(provider: .claude) }
+            let usageCookies = RequestHeaderLog()
+
+            try await self.withClaudeWebStub { request in
+                if request.url?.path == "/api/organizations/org-123/usage" {
+                    usageCookies.append(request.value(forHTTPHeaderField: "Cookie"))
+                }
+                return try Self.response(for: request, setCookie: Self.renewedSessionCookie)
+            } operation: {
+                let usage = try await ClaudeWebAPIFetcher.fetchUsage(cookieHeader: "sessionKey=sk-ant-manual-token")
+
+                #expect(usage.sessionPercentUsed == 11)
+                #expect(usageCookies.values == ["sessionKey=sk-ant-renewed-token"])
+                let cached = try #require(CookieHeaderCache.load(provider: .claude))
+                #expect(cached.cookieHeader == "sessionKey=sk-ant-cache-token")
+                #expect(cached.sourceLabel == "Chrome")
+            }
+        }
+    }
+
+    @Test
+    func `usage response renewal propagates to later requests and cache`() async throws {
+        try await self.withIsolatedCookieCache {
+            CookieHeaderCache.store(
+                provider: .claude,
+                cookieHeader: "sessionKey=sk-ant-old-token",
+                sourceLabel: "Chrome")
+            defer { CookieHeaderCache.clear(provider: .claude) }
+            let usageCookies = RequestHeaderLog()
+            let overageCookies = RequestHeaderLog()
+            let accountCookies = RequestHeaderLog()
+
+            try await self.withClaudeWebStub { request in
+                let path = request.url?.path
+                switch path {
+                case "/api/organizations/org-123/usage":
+                    usageCookies.append(request.value(forHTTPHeaderField: "Cookie"))
+                case "/api/organizations/org-123/overage_spend_limit":
+                    overageCookies.append(request.value(forHTTPHeaderField: "Cookie"))
+                case "/api/account":
+                    accountCookies.append(request.value(forHTTPHeaderField: "Cookie"))
+                default:
+                    break
+                }
+                return try Self.response(
+                    for: request,
+                    setCookie: path == "/api/organizations/org-123/usage" ? Self.renewedSessionCookie : nil)
+            } operation: {
+                _ = try await ClaudeWebAPIFetcher.fetchUsage(browserDetection: BrowserDetection(cacheTTL: 0))
+
+                #expect(usageCookies.values == ["sessionKey=sk-ant-old-token"])
+                #expect(overageCookies.values == ["sessionKey=sk-ant-renewed-token"])
+                #expect(accountCookies.values == ["sessionKey=sk-ant-renewed-token"])
+                let cached = try #require(CookieHeaderCache.load(provider: .claude))
+                #expect(cached.cookieHeader == "sessionKey=sk-ant-renewed-token")
+            }
+        }
+    }
+
+    @Test
+    func `renewal can return to initial session key`() async throws {
+        try await self.withIsolatedCookieCache {
+            CookieHeaderCache.store(
+                provider: .claude,
+                cookieHeader: "sessionKey=sk-ant-initial-token",
+                sourceLabel: "Chrome")
+            defer { CookieHeaderCache.clear(provider: .claude) }
+            let usageCookies = RequestHeaderLog()
+            let overageCookies = RequestHeaderLog()
+            let accountCookies = RequestHeaderLog()
+
+            try await self.withClaudeWebStub { request in
+                let path = request.url?.path
+                switch path {
+                case "/api/organizations/org-123/usage":
+                    usageCookies.append(request.value(forHTTPHeaderField: "Cookie"))
+                case "/api/organizations/org-123/overage_spend_limit":
+                    overageCookies.append(request.value(forHTTPHeaderField: "Cookie"))
+                case "/api/account":
+                    accountCookies.append(request.value(forHTTPHeaderField: "Cookie"))
+                default:
+                    break
+                }
+                let setCookie: String? = switch path {
+                case "/api/organizations":
+                    "sessionKey=sk-ant-intermediate-token; Path=/; HttpOnly"
+                case "/api/organizations/org-123/usage":
+                    "sessionKey=sk-ant-initial-token; Path=/; HttpOnly"
+                default:
+                    nil
+                }
+                return try Self.response(for: request, setCookie: setCookie)
+            } operation: {
+                _ = try await ClaudeWebAPIFetcher.fetchUsage(browserDetection: BrowserDetection(cacheTTL: 0))
+
+                #expect(usageCookies.values == ["sessionKey=sk-ant-intermediate-token"])
+                #expect(overageCookies.values == ["sessionKey=sk-ant-initial-token"])
+                #expect(accountCookies.values == ["sessionKey=sk-ant-initial-token"])
+                let cached = try #require(CookieHeaderCache.load(provider: .claude))
+                #expect(cached.cookieHeader == "sessionKey=sk-ant-initial-token")
+                #expect(cached.sourceLabel == "Chrome")
+            }
+        }
+    }
+
+    @Test
+    func `last session key assignment in one response wins`() async throws {
+        try await self.withIsolatedCookieCache {
+            CookieHeaderCache.store(
+                provider: .claude,
+                cookieHeader: "sessionKey=sk-ant-old-token",
+                sourceLabel: "Chrome")
+            defer { CookieHeaderCache.clear(provider: .claude) }
+            let usageCookies = RequestHeaderLog()
+            let overageCookies = RequestHeaderLog()
+            let accountCookies = RequestHeaderLog()
+
+            try await self.withClaudeWebStub { request in
+                let path = request.url?.path
+                switch path {
+                case "/api/organizations/org-123/usage":
+                    usageCookies.append(request.value(forHTTPHeaderField: "Cookie"))
+                case "/api/organizations/org-123/overage_spend_limit":
+                    overageCookies.append(request.value(forHTTPHeaderField: "Cookie"))
+                case "/api/account":
+                    accountCookies.append(request.value(forHTTPHeaderField: "Cookie"))
+                default:
+                    break
+                }
+                let setCookie = path == "/api/organizations"
+                    ? "sessionKey=sk-ant-first-token; Expires=Wed, 21 Oct 2030 07:28:00 GMT; Path=/, "
+                    + "sessionKey=sk-ant-final-token; Path=/; HttpOnly"
+                    : nil
+                return try Self.response(for: request, setCookie: setCookie)
+            } operation: {
+                _ = try await ClaudeWebAPIFetcher.fetchUsage(browserDetection: BrowserDetection(cacheTTL: 0))
+
+                #expect(usageCookies.values == ["sessionKey=sk-ant-final-token"])
+                #expect(overageCookies.values == ["sessionKey=sk-ant-final-token"])
+                #expect(accountCookies.values == ["sessionKey=sk-ant-final-token"])
+                let cached = try #require(CookieHeaderCache.load(provider: .claude))
+                #expect(cached.cookieHeader == "sessionKey=sk-ant-final-token")
+                #expect(cached.sourceLabel == "Chrome")
+            }
+        }
+    }
+
+    private static let renewedSessionCookie =
+        "sessionKey=sk-ant-renewed-token; Path=/; HttpOnly; Secure; SameSite=Lax"
+
+    private func withIsolatedCookieCache<T>(_ operation: () async throws -> T) async rethrows -> T {
+        let legacyBase = FileManager.default.temporaryDirectory
+            .appendingPathComponent("claude-web-renewal-\(UUID().uuidString)", isDirectory: true)
+        return try await KeychainCacheStore.withServiceOverrideForTesting("claude-web-renewal-\(UUID().uuidString)") {
+            try await CookieHeaderCache.withLegacyBaseURLOverrideForTesting(legacyBase) {
+                KeychainCacheStore.setTestStoreForTesting(true)
+                defer { KeychainCacheStore.setTestStoreForTesting(false) }
+                CookieHeaderCache.resetDisplayCacheForTesting()
+                defer { CookieHeaderCache.resetDisplayCacheForTesting() }
+                return try await operation()
+            }
+        }
+    }
+
+    private func withClaudeWebStub<T>(
+        handler: @escaping @Sendable (URLRequest) throws -> (HTTPURLResponse, Data),
+        operation: () async throws -> T) async rethrows -> T
+    {
+        let transport = ProviderHTTPTransportHandler { request in
+            let (response, data) = try handler(request)
+            return (data, response)
+        }
+        return try await ClaudeWebHTTPTransport.$overrideForTesting.withValue(transport) {
+            try await operation()
+        }
+    }
+
+    private static func response(
+        for request: URLRequest,
+        setCookie: String?) throws -> (HTTPURLResponse, Data)
+    {
+        let url = try #require(request.url)
+        switch url.path {
+        case "/api/organizations":
+            return self.jsonResponse(
+                url: url,
+                body: #"[{"uuid":"org-123","name":"Test Org","capabilities":["chat"]}]"#,
+                setCookie: setCookie)
+        case "/api/organizations/org-123/usage":
+            return self.jsonResponse(
+                url: url,
+                body: """
+                {
+                  "five_hour": { "utilization": 11 },
+                  "seven_day": { "utilization": 22 }
+                }
+                """,
+                setCookie: setCookie)
+        case "/api/account", "/api/organizations/org-123/overage_spend_limit":
+            return self.jsonResponse(url: url, body: "{}", statusCode: 404, setCookie: setCookie)
+        default:
+            return self.jsonResponse(url: url, body: "{}", statusCode: 404, setCookie: setCookie)
+        }
+    }
+
+    private static func jsonResponse(
+        url: URL,
+        body: String,
+        statusCode: Int = 200,
+        setCookie: String?) -> (HTTPURLResponse, Data)
+    {
+        var headerFields = ["Content-Type": "application/json"]
+        if let setCookie {
+            headerFields["Set-Cookie"] = setCookie
+        }
+        let response = HTTPURLResponse(
+            url: url,
+            statusCode: statusCode,
+            httpVersion: "HTTP/1.1",
+            headerFields: headerFields)!
+        return (response, Data(body.utf8))
+    }
+}
+
+private final class RequestHeaderLog: @unchecked Sendable {
+    private let lock = NSLock()
+    private var storage: [String?] = []
+
+    var values: [String?] {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        return self.storage
+    }
+
+    func append(_ value: String?) {
+        self.lock.lock()
+        self.storage.append(value)
+        self.lock.unlock()
+    }
+}
+
+private actor ConcurrentClaudeFetchProbe {
+    private var requestCookies: [String?] = []
+    private var organizationCountWaiters: [(Int, CheckedContinuation<Void, Never>)] = []
+    private var firstRequestReleased = false
+    private var firstRequestReleaseWaiters: [CheckedContinuation<Void, Never>] = []
+
+    var organizationRequestCount: Int {
+        self.requestCookies.count
+    }
+
+    var organizationRequestCookies: [String?] {
+        self.requestCookies
+    }
+
+    func organizationSessionCookie(requestCookie: String?) async -> String {
+        self.requestCookies.append(requestCookie)
+        let ordinal = self.requestCookies.count
+        let readyWaiters = self.organizationCountWaiters.filter { $0.0 <= ordinal }
+        self.organizationCountWaiters.removeAll { $0.0 <= ordinal }
+        readyWaiters.forEach { $0.1.resume() }
+        if ordinal == 1, !self.firstRequestReleased {
+            await withCheckedContinuation { continuation in
+                self.firstRequestReleaseWaiters.append(continuation)
+            }
+        }
+        let value = ordinal == 1 ? "sk-ant-first-rotation" : "sk-ant-second-rotation"
+        return "sessionKey=\(value); Path=/; HttpOnly"
+    }
+
+    func waitForOrganizationCount(_ count: Int) async {
+        if self.requestCookies.count >= count { return }
+        await withCheckedContinuation { continuation in
+            self.organizationCountWaiters.append((count, continuation))
+        }
+    }
+
+    func releaseFirstRequest() {
+        self.firstRequestReleased = true
+        let waiters = self.firstRequestReleaseWaiters
+        self.firstRequestReleaseWaiters.removeAll()
+        waiters.forEach { $0.resume() }
+    }
+}
diff --git a/Tests/CodexBarTests/ClaudeWebEnterpriseUsageTests.swift b/Tests/CodexBarTests/ClaudeWebEnterpriseUsageTests.swift
new file mode 100644
index 0000000000..dcd5e1dddc
--- /dev/null
+++ b/Tests/CodexBarTests/ClaudeWebEnterpriseUsageTests.swift
@@ -0,0 +1,43 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct ClaudeWebEnterpriseUsageTests {
+    @Test
+    func `parses usage response when session window is null`() throws {
+        let json = """
+        {
+          "five_hour": null,
+          "seven_day": { "utilization": 42, "resets_at": "2025-12-29T23:00:00.000Z" }
+        }
+        """
+        let data = Data(json.utf8)
+        let parsed = try ClaudeWebAPIFetcher._parseUsageResponseForTesting(data)
+        #expect(parsed.sessionPercentUsed == 0)
+        #expect(parsed.weeklyPercentUsed == 42)
+    }
+
+    @Test
+    func `parses enterprise credit spend from usage response`() throws {
+        let json = """
+        {
+          "five_hour": null,
+          "seven_day": null,
+          "extra_usage": {
+            "monthly_limit": 100000,
+            "used_credits": 4132
+          }
+        }
+        """
+        let data = Data(json.utf8)
+        let parsed = try ClaudeWebAPIFetcher._parseUsageResponseForTesting(data)
+
+        #expect(parsed.sessionPercentUsed == 0)
+        #expect(parsed.sessionResetsAt == nil)
+        #expect(parsed.weeklyPercentUsed == nil)
+        #expect(parsed.extraUsageCost?.used == 41.32)
+        #expect(parsed.extraUsageCost?.limit == 1000)
+        #expect(parsed.extraUsageCost?.currencyCode == "USD")
+        #expect(parsed.extraUsageCost?.period == "Monthly cap")
+    }
+}
diff --git a/Tests/CodexBarTests/ClaudeWebRecoveryMenuTests.swift b/Tests/CodexBarTests/ClaudeWebRecoveryMenuTests.swift
new file mode 100644
index 0000000000..82779a3a40
--- /dev/null
+++ b/Tests/CodexBarTests/ClaudeWebRecoveryMenuTests.swift
@@ -0,0 +1,164 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@MainActor
+@Suite(.serialized)
+struct ClaudeWebRecoveryMenuTests {
+    @Test
+    func `unauthorized error explains how to restore web usage`() {
+        #expect(
+            ClaudeWebAPIFetcher.FetchError.unauthorized.localizedDescription ==
+                "Sign in to claude.ai (or refresh Claude cookies) to load usage data.")
+    }
+
+    private func makeSettings() -> SettingsStore {
+        let suite = "ClaudeWebRecoveryMenuTests-\(UUID().uuidString)"
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        return SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+    }
+
+    private func actions(
+        error: String,
+        source: ClaudeUsageDataSource,
+        cookieSource: ProviderCookieSource = .auto,
+        selectedSessionKey: Bool = false,
+        attempts: [ProviderFetchAttempt] = []) -> [(String, MenuDescriptor.MenuAction)]
+    {
+        let settings = self.makeSettings()
+        settings.claudeUsageDataSource = source
+        if selectedSessionKey {
+            settings.addTokenAccount(provider: .claude, label: "Session", token: "sk-ant-session-token")
+        }
+        settings.claudeCookieSource = cookieSource
+        let fetcher = UsageFetcher()
+        let store = UsageStore(
+            fetcher: fetcher,
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings)
+        store.errors[.claude] = error
+        store.lastFetchAttempts[.claude] = attempts
+
+        return MenuDescriptor.build(
+            provider: .claude,
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updateReady: false)
+            .sections
+            .flatMap(\.entries)
+            .compactMap { entry in
+                guard case let .action(label, action) = entry else { return nil }
+                return (label, action)
+            }
+    }
+
+    @Test
+    func `web session errors show claude relogin action`() {
+        let errors = [
+            ClaudeWebAPIFetcher.FetchError.unauthorized.localizedDescription,
+            ClaudeWebAPIFetcher.FetchError.noSessionKeyFound.localizedDescription,
+            ClaudeWebAPIFetcher.FetchError.invalidSessionKey.localizedDescription,
+        ]
+
+        for error in errors {
+            let actions = self.actions(error: error, source: .web)
+            #expect(actions.contains {
+                $0.0 == "Re-login at claude.ai" &&
+                    $0.1 == .loginToProvider(url: "https://claude.ai/")
+            })
+        }
+    }
+
+    @Test
+    func `auto source shows relogin action for terminal web session error`() {
+        let actions = self.actions(
+            error: ClaudeWebAPIFetcher.FetchError.unauthorized.localizedDescription,
+            source: .auto)
+
+        #expect(actions.contains {
+            $0.0 == "Re-login at claude.ai" &&
+                $0.1 == .loginToProvider(url: "https://claude.ai/")
+        })
+    }
+
+    @Test
+    func `non-web source does not replace account action`() {
+        let actions = self.actions(
+            error: ClaudeWebAPIFetcher.FetchError.unauthorized.localizedDescription,
+            source: .oauth)
+
+        #expect(!actions.contains { $0.0 == "Re-login at claude.ai" })
+    }
+
+    @Test
+    func `manual cookies do not show browser relogin action`() {
+        let actions = self.actions(
+            error: ClaudeWebAPIFetcher.FetchError.unauthorized.localizedDescription,
+            source: .web,
+            cookieSource: .manual)
+
+        #expect(!actions.contains { $0.0 == "Re-login at claude.ai" })
+    }
+
+    @Test
+    func `selected session account does not show browser relogin action`() {
+        let actions = self.actions(
+            error: ClaudeWebAPIFetcher.FetchError.unauthorized.localizedDescription,
+            source: .web,
+            cookieSource: .auto,
+            selectedSessionKey: true)
+
+        #expect(!actions.contains { $0.0 == "Re-login at claude.ai" })
+    }
+
+    @Test
+    func `unavailable web strategy shows relogin action`() {
+        let actions = self.actions(
+            error: ProviderFetchError.noAvailableStrategy(.claude).localizedDescription,
+            source: .web,
+            attempts: [
+                ProviderFetchAttempt(
+                    strategyID: "claude.web",
+                    kind: .web,
+                    wasAvailable: false,
+                    errorDescription: nil),
+            ])
+
+        #expect(actions.contains {
+            $0.0 == "Re-login at claude.ai" &&
+                $0.1 == .loginToProvider(url: "https://claude.ai/")
+        })
+    }
+
+    @Test
+    func `generic unavailable error without web attempt keeps account action`() {
+        let actions = self.actions(
+            error: ProviderFetchError.noAvailableStrategy(.claude).localizedDescription,
+            source: .auto,
+            attempts: [
+                ProviderFetchAttempt(
+                    strategyID: "claude.cli",
+                    kind: .cli,
+                    wasAvailable: false,
+                    errorDescription: nil),
+            ])
+
+        #expect(!actions.contains { $0.0 == "Re-login at claude.ai" })
+    }
+
+    @Test
+    func `unrelated web error does not replace account action`() {
+        let actions = self.actions(
+            error: ClaudeWebAPIFetcher.FetchError.serverError(statusCode: 500).localizedDescription,
+            source: .web)
+
+        #expect(!actions.contains { $0.0 == "Re-login at claude.ai" })
+    }
+}
diff --git a/Tests/CodexBarTests/ClaudeWebRefreshResilienceTests.swift b/Tests/CodexBarTests/ClaudeWebRefreshResilienceTests.swift
new file mode 100644
index 0000000000..cc2cec5e37
--- /dev/null
+++ b/Tests/CodexBarTests/ClaudeWebRefreshResilienceTests.swift
@@ -0,0 +1,175 @@
+import Foundation
+import Testing
+@testable import CodexBar
+@testable import CodexBarCore
+
+struct ClaudeWebRefreshResilienceTests {
+    @Test
+    func `web unauthorized respects failure gate while keeping prior Claude snapshot`() async throws {
+        try await ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+            let tempDir = FileManager.default.temporaryDirectory
+                .appendingPathComponent(UUID().uuidString, isDirectory: true)
+            try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+            let fileURL = tempDir.appendingPathComponent("missing-credentials.json")
+
+            try await ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
+                let prior = Self.makePriorSnapshot()
+                let store = try await MainActor.run {
+                    try Self.makeStore(
+                        suite: "ClaudeWebRefreshResilienceTests-web-unauthorized",
+                        prior: prior)
+                }
+
+                await store.refreshProvider(.claude)
+                let firstResult = await MainActor.run {
+                    (
+                        updatedAt: store.snapshot(for: .claude)?.updatedAt,
+                        hasError: store.error(for: .claude) != nil)
+                }
+
+                #expect(firstResult.updatedAt == prior.updatedAt)
+                #expect(!firstResult.hasError)
+
+                await store.refreshProvider(.claude)
+                let secondResult = await MainActor.run {
+                    (
+                        updatedAt: store.snapshot(for: .claude)?.updatedAt,
+                        error: store.error(for: .claude))
+                }
+
+                #expect(secondResult.updatedAt == prior.updatedAt)
+                #expect(secondResult.error == ClaudeWebAPIFetcher.FetchError.unauthorized.localizedDescription)
+            }
+        }
+    }
+
+    @Test
+    func `web unauthorized without prior Claude snapshot still surfaces failure`() async throws {
+        try await ClaudeOAuthCredentialsStore.withIsolatedCredentialsFileTrackingForTesting {
+            let tempDir = FileManager.default.temporaryDirectory
+                .appendingPathComponent(UUID().uuidString, isDirectory: true)
+            try FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+            let fileURL = tempDir.appendingPathComponent("missing-credentials.json")
+
+            try await ClaudeOAuthCredentialsStore.withCredentialsURLOverrideForTesting(fileURL) {
+                let store = try await MainActor.run {
+                    try Self.makeStore(
+                        suite: "ClaudeWebRefreshResilienceTests-web-unauthorized-no-prior",
+                        prior: nil)
+                }
+
+                await store.refreshProvider(.claude)
+                let result = await MainActor.run {
+                    (
+                        hasSnapshot: store.snapshot(for: .claude) != nil,
+                        error: store.error(for: .claude))
+                }
+
+                #expect(!result.hasSnapshot)
+                #expect(result.error == ClaudeWebAPIFetcher.FetchError.unauthorized.localizedDescription)
+            }
+        }
+    }
+
+    @MainActor
+    private static func makeStore(suite: String, prior: UsageSnapshot?) throws -> UsageStore {
+        let settings = self.makeSettingsStore(suite: suite)
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.claudeUsageDataSource = .web
+
+        let metadata = ProviderRegistry.shared.metadata
+        for provider in UsageProvider.allCases {
+            try settings.setProviderEnabled(
+                provider: provider,
+                metadata: #require(metadata[provider]),
+                enabled: provider == .claude)
+        }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing,
+            environmentBase: [:])
+        if let prior {
+            store._setSnapshotForTesting(prior, provider: .claude)
+        }
+
+        let baseSpec = try #require(store.providerSpecs[.claude])
+        let descriptor = ProviderDescriptor(
+            id: .claude,
+            metadata: baseSpec.descriptor.metadata,
+            branding: baseSpec.descriptor.branding,
+            tokenCost: baseSpec.descriptor.tokenCost,
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.web],
+                pipeline: ProviderFetchPipeline { _ in [ClaudeWebUnauthorizedFetchStrategy()] }),
+            cli: baseSpec.descriptor.cli)
+        store.providerSpecs[.claude] = ProviderSpec(
+            style: baseSpec.style,
+            isEnabled: baseSpec.isEnabled,
+            descriptor: descriptor,
+            makeFetchContext: baseSpec.makeFetchContext)
+        return store
+    }
+
+    private static func makePriorSnapshot() -> UsageSnapshot {
+        UsageSnapshot(
+            primary: RateWindow(usedPercent: 12, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: 34,
+                windowMinutes: 10080,
+                resetsAt: nil,
+                resetDescription: nil),
+            updatedAt: Date(timeIntervalSince1970: 1_800_000_000),
+            identity: ProviderIdentitySnapshot(
+                providerID: .claude,
+                accountEmail: "claude@example.com",
+                accountOrganization: nil,
+                loginMethod: "Pro"))
+    }
+
+    @MainActor
+    private static func makeSettingsStore(suite: String) -> SettingsStore {
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore(),
+            codexCookieStore: InMemoryCookieHeaderStore(),
+            claudeCookieStore: InMemoryCookieHeaderStore(),
+            cursorCookieStore: InMemoryCookieHeaderStore(),
+            opencodeCookieStore: InMemoryCookieHeaderStore(),
+            factoryCookieStore: InMemoryCookieHeaderStore(),
+            minimaxCookieStore: InMemoryMiniMaxCookieStore(),
+            minimaxAPITokenStore: InMemoryMiniMaxAPITokenStore(),
+            kimiTokenStore: InMemoryKimiTokenStore(),
+            kimiK2TokenStore: InMemoryKimiK2TokenStore(),
+            augmentCookieStore: InMemoryCookieHeaderStore(),
+            ampCookieStore: InMemoryCookieHeaderStore(),
+            copilotTokenStore: InMemoryCopilotTokenStore(),
+            tokenAccountStore: InMemoryTokenAccountStore())
+        settings.providerDetectionCompleted = true
+        return settings
+    }
+}
+
+private struct ClaudeWebUnauthorizedFetchStrategy: ProviderFetchStrategy {
+    let id = "test.claude-web-unauthorized"
+    let kind: ProviderFetchKind = .web
+
+    func isAvailable(_: ProviderFetchContext) async -> Bool {
+        true
+    }
+
+    func fetch(_: ProviderFetchContext) async throws -> ProviderFetchResult {
+        throw ClaudeWebAPIFetcher.FetchError.unauthorized
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+}
diff --git a/Tests/CodexBarTests/ClaudeWebUsageExtraWindowTests.swift b/Tests/CodexBarTests/ClaudeWebUsageExtraWindowTests.swift
new file mode 100644
index 0000000000..b0d0241c3b
--- /dev/null
+++ b/Tests/CodexBarTests/ClaudeWebUsageExtraWindowTests.swift
@@ -0,0 +1,49 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct ClaudeWebUsageExtraWindowTests {
+    @Test
+    func `parses claude web API sonnet usage response`() throws {
+        let json = """
+        {
+          "five_hour": { "utilization": 9, "resets_at": "2025-12-23T16:00:00.000Z" },
+          "seven_day_sonnet": { "utilization": 6, "resets_at": "2025-12-30T23:00:00.000Z" }
+        }
+        """
+        let data = Data(json.utf8)
+        let parsed = try ClaudeWebAPIFetcher._parseUsageResponseForTesting(data)
+        #expect(parsed.opusPercentUsed == 6)
+    }
+
+    @Test
+    func `ignores merged claude web API omelette usage window`() throws {
+        let json = """
+        {
+          "five_hour": { "utilization": 9, "resets_at": "2025-12-23T16:00:00.000Z" },
+          "seven_day_omelette": { "utilization": 26, "resets_at": "2025-12-30T23:00:00.000Z" },
+          "seven_day_cowork": { "utilization": 11, "resets_at": "2025-12-31T23:00:00.000Z" }
+        }
+        """
+        let data = Data(json.utf8)
+        let parsed = try ClaudeWebAPIFetcher._parseUsageResponseForTesting(data)
+        #expect(parsed.extraRateWindows.count == 1)
+        #expect(parsed.extraRateWindows.contains { $0.id == "claude-design" } == false)
+        #expect(parsed.extraRateWindows.first(where: { $0.id == "claude-routines" })?.window.usedPercent == 11)
+    }
+
+    @Test
+    func `parses claude web API cowork null as zero routines window`() throws {
+        let json = """
+        {
+          "five_hour": { "utilization": 9, "resets_at": "2025-12-23T16:00:00.000Z" },
+          "seven_day_omelette": { "utilization": 26, "resets_at": "2025-12-30T23:00:00.000Z" },
+          "seven_day_cowork": null
+        }
+        """
+        let data = Data(json.utf8)
+        let parsed = try ClaudeWebAPIFetcher._parseUsageResponseForTesting(data)
+        #expect(parsed.extraRateWindows.first(where: { $0.id == "claude-routines" })?.window.usedPercent == 0)
+        #expect(parsed.extraRateWindows.contains { $0.id == "claude-design" } == false)
+    }
+}
diff --git a/Tests/CodexBarTests/ClickToCopyOverlayTests.swift b/Tests/CodexBarTests/ClickToCopyOverlayTests.swift
new file mode 100644
index 0000000000..449e3ad6bb
--- /dev/null
+++ b/Tests/CodexBarTests/ClickToCopyOverlayTests.swift
@@ -0,0 +1,50 @@
+import AppKit
+import Testing
+@testable import CodexBar
+
+@MainActor
+struct ClickToCopyOverlayTests {
+    @Test
+    func `view stores the latest copyText`() {
+        let view = ClickToCopyView(copyText: "original")
+        #expect(view.copyText == "original")
+        view.copyText = "updated"
+        #expect(view.copyText == "updated")
+    }
+
+    @Test
+    func `pasteboard copy waits for deferred scheduler`() {
+        var pendingAction: (() -> Void)?
+        var copiedText: String?
+        var completed = false
+
+        MenuPasteboardCopy.perform(
+            "copy me",
+            scheduler: { pendingAction = $0 },
+            writer: { copiedText = $0 },
+            completion: { completed = true })
+
+        #expect(copiedText == nil)
+        #expect(!completed)
+        pendingAction?()
+        #expect(copiedText == "copy me")
+        #expect(completed)
+    }
+
+    @Test
+    func `mouseDown forwards the latest copyText`() {
+        var copiedText: String?
+        let view = ClickToCopyView(copyText: "original") { copiedText = $0 }
+        view.copyText = "updated"
+
+        view.mouseDown(with: NSEvent())
+
+        #expect(copiedText == "updated")
+    }
+
+    @Test
+    func `accepts first mouse so error text overlay is clickable on first focus`() {
+        let view = ClickToCopyView(copyText: "x")
+        #expect(view.acceptsFirstMouse(for: nil) == true)
+    }
+}
diff --git a/Tests/CodexBarTests/CodebuffSettingsReaderTests.swift b/Tests/CodexBarTests/CodebuffSettingsReaderTests.swift
new file mode 100644
index 0000000000..d86d6e3bed
--- /dev/null
+++ b/Tests/CodexBarTests/CodebuffSettingsReaderTests.swift
@@ -0,0 +1,110 @@
+import CodexBarCore
+import Foundation
+import Testing
+
+struct CodebuffSettingsReaderTests {
+    @Test
+    func `api URL defaults to www codebuff com`() {
+        let url = CodebuffSettingsReader.apiURL(environment: [:])
+        #expect(url.scheme == "https")
+        #expect(url.host() == "www.codebuff.com")
+    }
+
+    @Test
+    func `api URL honors environment override`() {
+        let url = CodebuffSettingsReader.apiURL(environment: [
+            "CODEBUFF_API_URL": "https://staging.codebuff.com",
+        ])
+        #expect(url.host() == "staging.codebuff.com")
+    }
+
+    @Test
+    func `api key reads from CODEBUFF_API_KEY and trims wrapping whitespace`() {
+        let token = CodebuffSettingsReader.apiKey(environment: [
+            CodebuffSettingsReader.apiTokenKey: "  cb-test-token  ",
+        ])
+        #expect(token == "cb-test-token")
+    }
+
+    @Test
+    func `api key strips surrounding quotes`() {
+        let token = CodebuffSettingsReader.apiKey(environment: [
+            CodebuffSettingsReader.apiTokenKey: "\"cb-test-token\"",
+        ])
+        #expect(token == "cb-test-token")
+    }
+
+    @Test
+    func `api key returns nil for empty environment`() {
+        #expect(CodebuffSettingsReader.apiKey(environment: [:]) == nil)
+    }
+
+    @Test
+    func `auth token parses credentials json`() throws {
+        let contents = #"{"authToken":"file-token","fingerprintId":"fp-1","email":"a@b.com"}"#
+        let url = try self.writeTempFile(named: "credentials.json", contents: contents)
+        defer { try? FileManager.default.removeItem(at: url.deletingLastPathComponent()) }
+
+        let token = CodebuffSettingsReader.authToken(authFileURL: url)
+        #expect(token == "file-token")
+    }
+
+    @Test
+    func `auth token parses default profile credentials json`() throws {
+        let contents = #"{"default":{"authToken":"default-token","fingerprintId":"fp-1","email":"a@b.com"}}"#
+        let url = try self.writeTempFile(named: "credentials.json", contents: contents)
+        defer { try? FileManager.default.removeItem(at: url.deletingLastPathComponent()) }
+
+        let token = CodebuffSettingsReader.authToken(authFileURL: url)
+        #expect(token == "default-token")
+    }
+
+    @Test
+    func `auth token returns nil for malformed credentials json`() throws {
+        let url = try self.writeTempFile(named: "credentials.json", contents: "{not-json}")
+        defer { try? FileManager.default.removeItem(at: url.deletingLastPathComponent()) }
+
+        let token = CodebuffSettingsReader.authToken(authFileURL: url)
+        #expect(token == nil)
+    }
+
+    @Test
+    func `auth token returns nil when file missing`() {
+        let url = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+            .appendingPathComponent("credentials.json", isDirectory: false)
+        #expect(CodebuffSettingsReader.authToken(authFileURL: url) == nil)
+    }
+
+    @Test
+    func `descriptor uses codebuff dashboard URL`() {
+        let descriptor = ProviderDescriptorRegistry.descriptor(for: .codebuff)
+        #expect(descriptor.metadata.dashboardURL == "https://www.codebuff.com/usage")
+        #expect(descriptor.metadata.displayName == "Codebuff")
+        #expect(descriptor.metadata.cliName == "codebuff")
+    }
+
+    @Test
+    func `descriptor uses dedicated codebuff icon resource`() {
+        let descriptor = ProviderDescriptorRegistry.descriptor(for: .codebuff)
+        #expect(descriptor.branding.iconResourceName == "ProviderIcon-codebuff")
+    }
+
+    @Test
+    func `descriptor supports auto and API source modes`() {
+        let descriptor = ProviderDescriptorRegistry.descriptor(for: .codebuff)
+        let expected: Set<ProviderSourceMode> = [.auto, .api]
+        #expect(descriptor.fetchPlan.sourceModes == expected)
+    }
+
+    // MARK: - Helpers
+
+    private func writeTempFile(named name: String, contents: String) throws -> URL {
+        let directory = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+        let fileURL = directory.appendingPathComponent(name, isDirectory: false)
+        try contents.write(to: fileURL, atomically: true, encoding: .utf8)
+        return fileURL
+    }
+}
diff --git a/Tests/CodexBarTests/CodebuffUsageFetcherTests.swift b/Tests/CodexBarTests/CodebuffUsageFetcherTests.swift
new file mode 100644
index 0000000000..b76b652af8
--- /dev/null
+++ b/Tests/CodexBarTests/CodebuffUsageFetcherTests.swift
@@ -0,0 +1,492 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct CodebuffUsageFetcherTests {
+    @Test
+    func `usage URL composes the correct endpoint`() throws {
+        let base = try #require(URL(string: "https://www.codebuff.com"))
+        let url = CodebuffUsageFetcher.usageURL(baseURL: base)
+        #expect(url.absoluteString == "https://www.codebuff.com/api/v1/usage")
+    }
+
+    @Test
+    func `subscription URL composes the correct endpoint`() throws {
+        let base = try #require(URL(string: "https://www.codebuff.com"))
+        let url = CodebuffUsageFetcher.subscriptionURL(baseURL: base)
+        #expect(url.absoluteString == "https://www.codebuff.com/api/user/subscription")
+    }
+
+    @Test
+    func `usage request sends required fingerprint id`() async throws {
+        defer {
+            CodebuffStubURLProtocol.handler = nil
+            CodebuffStubURLProtocol.requests = []
+            CodebuffStubURLProtocol.requestBodies = []
+        }
+        CodebuffStubURLProtocol.requests = []
+        CodebuffStubURLProtocol.requestBodies = []
+        CodebuffStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            switch url.path {
+            case "/api/v1/usage":
+                return try Self.makeResponse(url: url, body: #"{"usage":25,"quota":100,"remainingBalance":75}"#)
+            case "/api/user/subscription":
+                return try Self.makeResponse(url: url, body: "{}")
+            default:
+                return try Self.makeResponse(url: url, body: "{}", statusCode: 404)
+            }
+        }
+
+        let snapshot = try await CodebuffUsageFetcher.fetchUsage(apiKey: "cb-test", session: Self.makeSession())
+        let usageIndex = try #require(CodebuffStubURLProtocol.requests.firstIndex {
+            $0.url?.path == "/api/v1/usage"
+        })
+        let body = try #require(CodebuffStubURLProtocol.requestBodies[usageIndex])
+        let payload = try #require(JSONSerialization.jsonObject(with: body) as? [String: String])
+
+        #expect(payload["fingerprintId"] == "codexbar-usage")
+        #expect(snapshot.creditsUsed == 25)
+    }
+
+    @Test
+    func `usage fetch can skip subscription endpoint for API key tokens`() async throws {
+        defer {
+            CodebuffStubURLProtocol.handler = nil
+            CodebuffStubURLProtocol.requests = []
+            CodebuffStubURLProtocol.requestBodies = []
+        }
+        CodebuffStubURLProtocol.requests = []
+        CodebuffStubURLProtocol.requestBodies = []
+        CodebuffStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            switch url.path {
+            case "/api/v1/usage":
+                return try Self.makeResponse(url: url, body: #"{"usage":25,"quota":100,"remainingBalance":75}"#)
+            case "/api/user/subscription":
+                Issue.record("Subscription endpoint should not be called for API key tokens")
+                return try Self.makeResponse(url: url, body: "{}", statusCode: 500)
+            default:
+                return try Self.makeResponse(url: url, body: "{}", statusCode: 404)
+            }
+        }
+
+        let snapshot = try await CodebuffUsageFetcher.fetchUsage(
+            apiKey: "cb-test",
+            includeSubscription: false,
+            session: Self.makeSession())
+
+        #expect(snapshot.creditsUsed == 25)
+        #expect(CodebuffStubURLProtocol.requests.map(\.url?.path) == ["/api/v1/usage"])
+    }
+
+    @Test
+    func `subscription grace does not wait for transport that ignores cancellation`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            if url.path == "/api/v1/usage" {
+                let response = try Self.makeResponse(
+                    url: url,
+                    body: #"{"usage":25,"quota":100,"remainingBalance":75}"#)
+                return (response.1, response.0)
+            }
+            let response = try Self.makeResponse(
+                url: url,
+                body: #"{"subscription":{"displayName":"Pro","status":"active"}}"#)
+            return await withCheckedContinuation { continuation in
+                DispatchQueue.global().asyncAfter(deadline: .now() + 0.5) {
+                    continuation.resume(returning: (response.1, response.0))
+                }
+            }
+        }
+
+        let startedAt = ContinuousClock.now
+        let snapshot = try await CodebuffUsageFetcher._fetchUsageForTesting(
+            apiKey: "cb-test",
+            transport: transport,
+            subscriptionGrace: .milliseconds(20))
+        let elapsed = startedAt.duration(to: .now)
+
+        #expect(snapshot.creditsUsed == 25)
+        #expect(snapshot.tier == nil)
+        #expect(elapsed < .milliseconds(300), "Subscription enrichment delayed usage: \(elapsed)")
+
+        // Let the deliberately cancellation-ignoring test task drain before the test exits.
+        try await Task.sleep(for: .milliseconds(550))
+    }
+
+    @Test
+    func `cancellation stops subscription while usage transport ignores cancellation`() async throws {
+        let usageStarted = CodebuffRequestGate()
+        let subscriptionStarted = CodebuffRequestGate()
+        let subscriptionCancelled = CodebuffRequestGate()
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            if url.path == "/api/v1/usage" {
+                await usageStarted.open()
+                let response = try Self.makeResponse(
+                    url: url,
+                    body: #"{"usage":25,"quota":100,"remainingBalance":75}"#)
+                return await withCheckedContinuation { continuation in
+                    DispatchQueue.global().asyncAfter(deadline: .now() + 0.5) {
+                        continuation.resume(returning: (response.1, response.0))
+                    }
+                }
+            }
+
+            await subscriptionStarted.open()
+            do {
+                try await Task.sleep(for: .seconds(10))
+            } catch {
+                await subscriptionCancelled.open()
+                throw error
+            }
+            let response = try Self.makeResponse(
+                url: url,
+                body: #"{"subscription":{"displayName":"Pro","status":"active"}}"#)
+            return (response.1, response.0)
+        }
+        let task = Task {
+            try await CodebuffUsageFetcher.fetchUsage(
+                apiKey: "cb-test",
+                session: transport)
+        }
+
+        await usageStarted.wait()
+        await subscriptionStarted.wait()
+        let cancellationStartedAt = ContinuousClock.now
+        task.cancel()
+
+        await subscriptionCancelled.wait()
+        #expect(cancellationStartedAt.duration(to: .now) < .milliseconds(300))
+        await #expect(throws: CancellationError.self) {
+            try await task.value
+        }
+    }
+
+    @Test
+    func `api strategy only fetches subscription for credentials file tokens`() {
+        let envResolution = ProviderTokenResolution(token: "env-token", source: .environment)
+        let fileResolution = ProviderTokenResolution(token: "file-token", source: .authFile)
+
+        #expect(CodebuffAPIFetchStrategy.shouldFetchSubscription(for: envResolution) == false)
+        #expect(CodebuffAPIFetchStrategy.shouldFetchSubscription(for: fileResolution) == true)
+    }
+
+    @Test
+    func `status 401 maps to unauthorized`() {
+        #expect(CodebuffUsageFetcher._statusErrorForTesting(401) == .unauthorized)
+        #expect(CodebuffUsageFetcher._statusErrorForTesting(403) == .unauthorized)
+    }
+
+    @Test
+    func `status 404 maps to endpoint not found`() {
+        #expect(CodebuffUsageFetcher._statusErrorForTesting(404) == .endpointNotFound)
+    }
+
+    @Test
+    func `status 500 maps to service unavailable`() {
+        guard case .serviceUnavailable(503) = CodebuffUsageFetcher._statusErrorForTesting(503)
+        else {
+            Issue.record("Expected .serviceUnavailable(503)")
+            return
+        }
+    }
+
+    @Test
+    func `status 200 returns nil`() {
+        #expect(CodebuffUsageFetcher._statusErrorForTesting(200) == nil)
+    }
+
+    @Test
+    func `usage payload parses numeric credit fields`() throws {
+        let json = """
+        {
+          "usage": 1250,
+          "quota": 5000,
+          "remainingBalance": 3750,
+          "autoTopupEnabled": true,
+          "next_quota_reset": "2026-05-01T00:00:00Z"
+        }
+        """
+
+        let payload = try CodebuffUsageFetcher._parseUsagePayloadForTesting(Data(json.utf8))
+        #expect(payload.used == 1250)
+        #expect(payload.total == 5000)
+        #expect(payload.remaining == 3750)
+        #expect(payload.autoTopupEnabled == true)
+        #expect(payload.nextQuotaReset != nil)
+    }
+
+    @Test
+    func `usage payload accepts string-encoded numbers`() throws {
+        let json = """
+        { "usage": "12", "quota": "100", "remainingBalance": "88" }
+        """
+        let payload = try CodebuffUsageFetcher._parseUsagePayloadForTesting(Data(json.utf8))
+        #expect(payload.used == 12)
+        #expect(payload.total == 100)
+        #expect(payload.remaining == 88)
+    }
+
+    @Test
+    func `usage payload returns nil fields when absent`() throws {
+        let payload = try CodebuffUsageFetcher._parseUsagePayloadForTesting(Data("{}".utf8))
+        #expect(payload.used == nil)
+        #expect(payload.total == nil)
+        #expect(payload.remaining == nil)
+        #expect(payload.autoTopupEnabled == nil)
+    }
+
+    @Test
+    func `usage payload throws on malformed JSON`() {
+        #expect {
+            _ = try CodebuffUsageFetcher._parseUsagePayloadForTesting(Data("not-json".utf8))
+        } throws: { error in
+            guard case CodebuffUsageError.parseFailed = error else { return false }
+            return true
+        }
+    }
+
+    @Test
+    func `subscription payload parses tier and weekly window`() throws {
+        let json = """
+        {
+          "hasSubscription": true,
+          "subscription": {
+            "status": "active",
+            "tier": "pro",
+            "billingPeriodEnd": "2026-05-15T00:00:00Z"
+          },
+          "rateLimit": {
+            "weeklyUsed": 2100,
+            "weeklyLimit": 7000,
+            "weeklyResetsAt": "2026-05-08T00:00:00Z"
+          },
+          "email": "user@example.com"
+        }
+        """
+
+        let payload = try CodebuffUsageFetcher._parseSubscriptionPayloadForTesting(Data(json.utf8))
+        #expect(payload.tier == "pro")
+        #expect(payload.status == "active")
+        #expect(payload.weeklyUsed == 2100)
+        #expect(payload.weeklyLimit == 7000)
+        #expect(payload.weeklyResetsAt != nil)
+        #expect(payload.email == "user@example.com")
+        #expect(payload.billingPeriodEnd != nil)
+    }
+
+    @Test
+    func `subscription payload prefers display name over numeric tier`() throws {
+        let json = """
+        { "subscription": { "tier": 2, "displayName": "Pro" } }
+        """
+        let payload = try CodebuffUsageFetcher._parseSubscriptionPayloadForTesting(Data(json.utf8))
+        #expect(payload.tier == "Pro")
+    }
+
+    @Test
+    func `subscription payload falls back to numeric scheduled tier`() throws {
+        let json = """
+        { "subscription": { "scheduledTier": 3 } }
+        """
+        let payload = try CodebuffUsageFetcher._parseSubscriptionPayloadForTesting(Data(json.utf8))
+        #expect(payload.tier == "3")
+    }
+
+    @Test
+    func `subscription payload formats oversized numeric tier without trapping`() throws {
+        let json = """
+        { "subscription": { "scheduledTier": 9223372036854775808 } }
+        """
+        let payload = try CodebuffUsageFetcher._parseSubscriptionPayloadForTesting(Data(json.utf8))
+        #expect(payload.tier == "9223372036854775808")
+    }
+
+    @Test
+    func `subscription payload tolerates missing rate limit`() throws {
+        let json = """
+        { "subscription": { "status": "trialing", "tier": "free" } }
+        """
+        let payload = try CodebuffUsageFetcher._parseSubscriptionPayloadForTesting(Data(json.utf8))
+        #expect(payload.weeklyUsed == nil)
+        #expect(payload.weeklyLimit == nil)
+        #expect(payload.status == "trialing")
+    }
+
+    @Test
+    func `snapshot maps to rate window with credits window`() {
+        let snapshot = CodebuffUsageSnapshot(
+            creditsUsed: 250,
+            creditsTotal: 1000,
+            creditsRemaining: 750,
+            weeklyUsed: 100,
+            weeklyLimit: 500,
+            weeklyResetsAt: Date(timeIntervalSince1970: 1_777_680_000),
+            tier: "pro",
+            autoTopUpEnabled: true,
+            updatedAt: Date())
+
+        let unified = snapshot.toUsageSnapshot()
+        #expect(unified.primary?.usedPercent == 25)
+        // The credit balance is intentionally NOT stored in `resetDescription` —
+        // generic renderers prepend "Resets " when `resetsAt` is absent, which would
+        // surface misleading text like "Resets 250/1,000 credits".
+        #expect(unified.primary?.resetDescription == nil)
+        #expect(unified.secondary?.usedPercent == 20)
+        #expect(unified.secondary?.windowMinutes == 7 * 24 * 60)
+        #expect(unified.secondary?.resetsAt == Date(timeIntervalSince1970: 1_777_680_000))
+        #expect(unified.secondary?.resetDescription == nil)
+        #expect(unified.identity?.providerID == .codebuff)
+        #expect(unified.identity?.loginMethod?.contains("Pro") == true)
+        #expect(unified.identity?.loginMethod?.contains("auto top-up") == true)
+    }
+
+    @Test
+    func `snapshot infers total from used plus remaining`() {
+        let snapshot = CodebuffUsageSnapshot(
+            creditsUsed: 40,
+            creditsTotal: nil,
+            creditsRemaining: 60)
+
+        let unified = snapshot.toUsageSnapshot()
+        #expect(unified.primary?.usedPercent == 40)
+    }
+
+    @Test
+    func `snapshot surfaces exhausted state when quota is missing from payload`() {
+        // Only `creditsUsed` is populated (no total, no remaining) — the API response is
+        // degenerate but we still want the row to be visible so the user notices the
+        // missing configuration instead of seeing an empty/healthy-looking bar.
+        let usedOnly = CodebuffUsageSnapshot(
+            creditsUsed: 42,
+            creditsTotal: nil,
+            creditsRemaining: nil)
+        #expect(usedOnly.toUsageSnapshot().primary?.usedPercent == 100)
+
+        // Only `creditsRemaining` is populated — same fallback should apply.
+        let remainingOnly = CodebuffUsageSnapshot(
+            creditsUsed: nil,
+            creditsTotal: nil,
+            creditsRemaining: 17)
+        #expect(remainingOnly.toUsageSnapshot().primary?.usedPercent == 100)
+    }
+
+    @Test
+    func `snapshot hides credit window when no credit fields are present`() {
+        let empty = CodebuffUsageSnapshot()
+        #expect(empty.toUsageSnapshot().primary == nil)
+    }
+
+    @Test
+    func `missing credentials fetch call throws missing credentials`() async {
+        do {
+            _ = try await CodebuffUsageFetcher.fetchUsage(apiKey: "   ")
+            Issue.record("Expected missingCredentials error")
+        } catch let error as CodebuffUsageError {
+            #expect(error == .missingCredentials)
+        } catch {
+            Issue.record("Unexpected error: \(error)")
+        }
+    }
+
+    private static func makeSession() -> URLSession {
+        let config = URLSessionConfiguration.ephemeral
+        config.protocolClasses = [CodebuffStubURLProtocol.self]
+        return URLSession(configuration: config)
+    }
+
+    private static func makeResponse(
+        url: URL,
+        body: String,
+        statusCode: Int = 200) throws -> (HTTPURLResponse, Data)
+    {
+        guard let response = HTTPURLResponse(
+            url: url,
+            statusCode: statusCode,
+            httpVersion: nil,
+            headerFields: ["Content-Type": "application/json"])
+        else {
+            throw URLError(.badServerResponse)
+        }
+        return (response, Data(body.utf8))
+    }
+}
+
+private actor CodebuffRequestGate {
+    private var isOpen = false
+    private var continuations: [CheckedContinuation<Void, Never>] = []
+
+    func wait() async {
+        guard !self.isOpen else { return }
+        await withCheckedContinuation { continuation in
+            self.continuations.append(continuation)
+        }
+    }
+
+    func open() {
+        self.isOpen = true
+        let continuations = self.continuations
+        self.continuations.removeAll()
+        for continuation in continuations {
+            continuation.resume()
+        }
+    }
+}
+
+final class CodebuffStubURLProtocol: URLProtocol {
+    nonisolated(unsafe) static var handler: ((URLRequest) throws -> (HTTPURLResponse, Data))?
+    nonisolated(unsafe) static var requests: [URLRequest] = []
+    nonisolated(unsafe) static var requestBodies: [Data?] = []
+
+    override static func canInit(with request: URLRequest) -> Bool {
+        request.url?.host == "www.codebuff.com"
+    }
+
+    override static func canonicalRequest(for request: URLRequest) -> URLRequest {
+        request
+    }
+
+    override func startLoading() {
+        Self.requests.append(self.request)
+        Self.requestBodies.append(Self.bodyData(from: self.request))
+        guard let handler = Self.handler else {
+            self.client?.urlProtocol(self, didFailWithError: URLError(.badServerResponse))
+            return
+        }
+        do {
+            let (response, data) = try handler(self.request)
+            self.client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
+            self.client?.urlProtocol(self, didLoad: data)
+            self.client?.urlProtocolDidFinishLoading(self)
+        } catch {
+            self.client?.urlProtocol(self, didFailWithError: error)
+        }
+    }
+
+    override func stopLoading() {}
+
+    private static func bodyData(from request: URLRequest) -> Data? {
+        if let httpBody = request.httpBody {
+            return httpBody
+        }
+        guard let stream = request.httpBodyStream else { return nil }
+
+        stream.open()
+        defer { stream.close() }
+
+        var data = Data()
+        var buffer = [UInt8](repeating: 0, count: 1024)
+        while stream.hasBytesAvailable {
+            let count = stream.read(&buffer, maxLength: buffer.count)
+            if count > 0 {
+                data.append(buffer, count: count)
+            } else {
+                break
+            }
+        }
+        return data.isEmpty ? nil : data
+    }
+}
diff --git a/Tests/CodexBarTests/CodexAccountAuthFingerprintApplyTests.swift b/Tests/CodexBarTests/CodexAccountAuthFingerprintApplyTests.swift
new file mode 100644
index 0000000000..2fa77f04ea
--- /dev/null
+++ b/Tests/CodexBarTests/CodexAccountAuthFingerprintApplyTests.swift
@@ -0,0 +1,1492 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@MainActor
+extension CodexAccountScopedRefreshTests {
+    @Test
+    func `same account token refresh fingerprint change keeps codex usage success`() async {
+        SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = 60
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-token-refresh-fingerprint-change")
+        defer {
+            SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = nil
+            settings._test_liveSystemCodexAccount = nil
+        }
+        settings.refreshFrequency = .manual
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "alpha@example.com",
+            authFingerprint: "old-token-material",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .providerAccount(id: "acct-alpha"))
+        let staleReconciliationSnapshot = settings.codexAccountReconciliationSnapshot
+
+        let store = self.makeUsageStore(settings: settings)
+        let blocker = BlockingCodexFetchStrategy()
+        self.installBlockingCodexProvider(on: store, blocker: blocker)
+
+        let refreshTask = Task { await store.refreshProvider(.codex, allowDisabled: true) }
+        await blocker.waitUntilStarted()
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "alpha@example.com",
+            authFingerprint: "new-token-material",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .providerAccount(id: "acct-alpha"))
+        settings.cachedCodexAccountReconciliationSnapshot = CachedCodexAccountReconciliationSnapshot(
+            activeSource: .liveSystem,
+            loadedAt: Date(),
+            snapshot: staleReconciliationSnapshot)
+        await blocker.resume(with: .success(self.codexSnapshot(email: "alpha@example.com", usedPercent: 25)))
+        await refreshTask.value
+
+        #expect(store.snapshots[.codex]?.primary?.usedPercent == 25)
+        #expect(store.lastCodexAccountScopedRefreshGuard?.authFingerprint == "new-token-material")
+        #expect(store.errors[.codex] == nil)
+    }
+
+    @Test
+    func `same account token refresh fingerprint change keeps reset backfill`() async {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-token-refresh-reset-backfill")
+        defer {
+            settings._test_liveSystemCodexAccount = nil
+        }
+        settings.refreshFrequency = .manual
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "alpha@example.com",
+            authFingerprint: "old-token-material",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .providerAccount(id: "acct-alpha"))
+        let store = self.makeUsageStore(settings: settings)
+        let resetsAt = Date().addingTimeInterval(45 * 60)
+        store.lastCodexAccountScopedRefreshGuard = store.freshCodexAccountScopedRefreshGuard()
+        store.lastKnownResetSnapshots[.codex] = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 10,
+                windowMinutes: 300,
+                resetsAt: resetsAt,
+                resetDescription: "resets soon"),
+            secondary: nil,
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: "alpha@example.com",
+                accountOrganization: nil,
+                loginMethod: "Pro"))
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "alpha@example.com",
+            authFingerprint: "new-token-material",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .providerAccount(id: "acct-alpha"))
+        self.installImmediateCodexProvider(
+            on: store,
+            snapshot: self.codexSnapshot(email: "alpha@example.com", usedPercent: 25))
+
+        await store.refreshProvider(.codex, allowDisabled: true)
+
+        #expect(store.snapshots[.codex]?.primary?.usedPercent == 25)
+        #expect(store.snapshots[.codex]?.primary?.resetsAt == resetsAt)
+        #expect(store.lastKnownResetSnapshots[.codex]?.primary?.resetsAt == resetsAt)
+        #expect(store.lastCodexAccountScopedRefreshGuard?.authFingerprint == "new-token-material")
+    }
+
+    @Test
+    func `same account token refresh fingerprint change keeps scoped state during prepare`() {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-token-refresh-prepare")
+        defer {
+            settings._test_liveSystemCodexAccount = nil
+        }
+        settings.refreshFrequency = .manual
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "alpha@example.com",
+            authFingerprint: "old-token-material",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .providerAccount(id: "acct-alpha"))
+        let store = self.makeUsageStore(settings: settings)
+        let resetsAt = Date().addingTimeInterval(45 * 60)
+        let cached = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 10,
+                windowMinutes: 300,
+                resetsAt: resetsAt,
+                resetDescription: "resets soon"),
+            secondary: nil,
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: "alpha@example.com",
+                accountOrganization: nil,
+                loginMethod: "Pro"))
+        store.snapshots[.codex] = cached
+        store.lastKnownResetSnapshots[.codex] = cached
+        store.credits = self.credits(remaining: 42)
+        store.lastCodexAccountScopedRefreshGuard = store.freshCodexAccountScopedRefreshGuard()
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "alpha@example.com",
+            authFingerprint: "new-token-material",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .providerAccount(id: "acct-alpha"))
+
+        let invalidated = store.prepareCodexAccountScopedRefreshIfNeeded()
+
+        #expect(!invalidated)
+        #expect(store.snapshots[.codex]?.primary?.resetsAt == resetsAt)
+        #expect(store.lastKnownResetSnapshots[.codex]?.primary?.resetsAt == resetsAt)
+        #expect(store.credits?.remaining == 42)
+        #expect(store.lastCodexAccountScopedRefreshGuard?.authFingerprint == "new-token-material")
+    }
+
+    @Test
+    func `usage success applies when auth fingerprint appears after refresh starts`() {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-auth-fingerprint-appears")
+        defer {
+            settings._test_liveSystemCodexAccount = nil
+        }
+        settings.refreshFrequency = .manual
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "alpha@example.com",
+            authFingerprint: nil,
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .emailOnly(normalizedEmail: "alpha@example.com"))
+        let store = self.makeUsageStore(settings: settings)
+        let expectedGuard = store.freshCodexAccountScopedRefreshGuard()
+
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "alpha@example.com",
+            authFingerprint: "new-token-material",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .emailOnly(normalizedEmail: "alpha@example.com"))
+
+        #expect(store.shouldApplyCodexUsageResult(
+            expectedGuard: expectedGuard,
+            usage: self.codexSnapshot(email: "alpha@example.com", usedPercent: 25)))
+    }
+
+    @Test
+    func `same account token refresh fingerprint change discards codex usage failure`() async {
+        SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = 60
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-token-refresh-fingerprint-failure")
+        defer {
+            SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = nil
+            settings._test_liveSystemCodexAccount = nil
+        }
+        settings.refreshFrequency = .manual
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "alpha@example.com",
+            authFingerprint: "old-token-material",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .providerAccount(id: "acct-alpha"))
+        let staleReconciliationSnapshot = settings.codexAccountReconciliationSnapshot
+
+        let store = self.makeUsageStore(settings: settings)
+        let blocker = BlockingCodexFetchStrategy()
+        self.installBlockingCodexProvider(on: store, blocker: blocker)
+
+        let refreshTask = Task { await store.refreshProvider(.codex, allowDisabled: true) }
+        await blocker.waitUntilStarted()
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "alpha@example.com",
+            authFingerprint: "new-token-material",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .providerAccount(id: "acct-alpha"))
+        settings.cachedCodexAccountReconciliationSnapshot = CachedCodexAccountReconciliationSnapshot(
+            activeSource: .liveSystem,
+            loadedAt: Date(),
+            snapshot: staleReconciliationSnapshot)
+        await blocker.resume(with: .failure(TestRefreshError(message: "old token failure")))
+        await refreshTask.value
+
+        #expect(store.snapshots[.codex] == nil)
+        #expect(store.errors[.codex] == nil)
+    }
+
+    @Test
+    func `same account token refresh fingerprint change keeps codex credits success`() async {
+        SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = 60
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-token-refresh-credits-success")
+        defer {
+            SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = nil
+            settings._test_liveSystemCodexAccount = nil
+        }
+        settings.refreshFrequency = .manual
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "alpha@example.com",
+            authFingerprint: "old-token-material",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .providerAccount(id: "acct-alpha"))
+
+        let store = self.makeUsageStore(settings: settings)
+        store._test_codexCreditsLoaderOverride = {
+            settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+                email: "alpha@example.com",
+                authFingerprint: "new-token-material",
+                codexHomePath: "/Users/test/.codex",
+                observedAt: Date(),
+                identity: .providerAccount(id: "acct-alpha"))
+            return CreditsSnapshot(remaining: 42, events: [], updatedAt: Date())
+        }
+        defer { store._test_codexCreditsLoaderOverride = nil }
+
+        await store.refreshCreditsIfNeeded()
+
+        #expect(store.credits?.remaining == 42)
+        #expect(store.lastCreditsSnapshotAccountKey == "alpha@example.com")
+        #expect(store.lastCodexAccountScopedRefreshGuard?.authFingerprint == "new-token-material")
+        #expect(store.lastCreditsError == nil)
+    }
+
+    @Test
+    func `credits refresh key separates same account auth fingerprints`() {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-credits-key-auth-fingerprint")
+        let store = self.makeUsageStore(settings: settings)
+        let oldGuard = CodexAccountScopedRefreshGuard(
+            source: .liveSystem,
+            identity: .providerAccount(id: "acct-alpha"),
+            accountKey: "alpha@example.com",
+            authFingerprint: "old-token-material")
+        let newGuard = CodexAccountScopedRefreshGuard(
+            source: .liveSystem,
+            identity: .providerAccount(id: "acct-alpha"),
+            accountKey: "alpha@example.com",
+            authFingerprint: "new-token-material")
+
+        #expect(store.codexCreditsRefreshKey(expectedGuard: oldGuard) !=
+            store.codexCreditsRefreshKey(expectedGuard: newGuard))
+    }
+
+    @Test
+    func `same account token refresh fingerprint change keeps dashboard success`() async throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-token-refresh-dashboard-success")
+        let codexMetadata = try #require(ProviderDescriptorRegistry.metadata[.codex])
+        settings.setProviderEnabled(provider: .codex, metadata: codexMetadata, enabled: true)
+        settings.refreshFrequency = .manual
+        settings.openAIWebAccessEnabled = true
+        settings.codexCookieSource = .auto
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "alpha@example.com",
+            authFingerprint: "old-token-material",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .providerAccount(id: "acct-alpha"))
+        defer {
+            settings._test_liveSystemCodexAccount = nil
+        }
+
+        let store = self.makeUsageStore(settings: settings)
+        let expectedGuard = store.freshCodexOpenAIWebRefreshGuard()
+        store._test_openAIDashboardLoaderOverride = { _, _, _, _ in
+            settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+                email: "alpha@example.com",
+                authFingerprint: "new-token-material",
+                codexHomePath: "/Users/test/.codex",
+                observedAt: Date(),
+                identity: .providerAccount(id: "acct-alpha"))
+            return self.dashboard(email: "alpha@example.com", creditsRemaining: 64, usedPercent: 27)
+        }
+        defer { store._test_openAIDashboardLoaderOverride = nil }
+
+        await store.refreshOpenAIDashboardIfNeeded(force: true, expectedGuard: expectedGuard)
+
+        #expect(store.openAIDashboard?.creditsRemaining == 64)
+        #expect(store.openAIDashboard?.signedInEmail == "alpha@example.com")
+        #expect(store.lastOpenAIDashboardError == nil)
+        #expect(store.openAIDashboardRequiresLogin == false)
+    }
+
+    @Test
+    func `dashboard refresh key separates same account auth fingerprints`() async throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-dashboard-key-auth-fingerprint")
+        let codexMetadata = try #require(ProviderDescriptorRegistry.metadata[.codex])
+        settings.setProviderEnabled(provider: .codex, metadata: codexMetadata, enabled: true)
+        settings.refreshFrequency = .manual
+        settings.openAIWebAccessEnabled = true
+        settings.codexCookieSource = .auto
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "alpha@example.com",
+            authFingerprint: "old-token-material",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .providerAccount(id: "acct-alpha"))
+        defer {
+            settings._test_liveSystemCodexAccount = nil
+        }
+
+        let store = self.makeUsageStore(settings: settings)
+        let blocker = BlockingManagedOpenAIDashboardLoader()
+        store._test_openAIDashboardLoaderOverride = { _, _, _, _ in
+            try await blocker.awaitResult()
+        }
+        defer { store._test_openAIDashboardLoaderOverride = nil }
+
+        let oldGuard = store.freshCodexOpenAIWebRefreshGuard()
+        let oldRefreshTask = Task {
+            await store.refreshOpenAIDashboardIfNeeded(force: true, expectedGuard: oldGuard)
+        }
+        await blocker.waitUntilStarted(count: 1)
+
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "alpha@example.com",
+            authFingerprint: "new-token-material",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .providerAccount(id: "acct-alpha"))
+        let newGuard = store.freshCodexOpenAIWebRefreshGuard()
+        let newRefreshTask = Task {
+            await store.refreshOpenAIDashboardIfNeeded(force: true, expectedGuard: newGuard)
+        }
+
+        let didStartFreshRefresh = await blocker.waitUntilStartedWithin(count: 2)
+        #expect(didStartFreshRefresh)
+        guard didStartFreshRefresh else {
+            await blocker.resumeNext(with: .failure(TestRefreshError(message: "stale dashboard failure")))
+            await oldRefreshTask.value
+            await newRefreshTask.value
+            return
+        }
+        await blocker.resumeNext(with: .failure(TestRefreshError(message: "old dashboard failure")))
+        await blocker.resumeNext(with: .success(self.dashboard(
+            email: "alpha@example.com",
+            creditsRemaining: 64,
+            usedPercent: 27)))
+        await oldRefreshTask.value
+        await newRefreshTask.value
+
+        #expect(store.openAIDashboard?.creditsRemaining == 64)
+        #expect(store.lastOpenAIDashboardError == nil)
+    }
+
+    @Test
+    func `same account token refresh fingerprint change discards dashboard failure`() async throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-token-refresh-dashboard-failure")
+        let codexMetadata = try #require(ProviderDescriptorRegistry.metadata[.codex])
+        settings.setProviderEnabled(provider: .codex, metadata: codexMetadata, enabled: true)
+        settings.refreshFrequency = .manual
+        settings.openAIWebAccessEnabled = true
+        settings.codexCookieSource = .auto
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "alpha@example.com",
+            authFingerprint: "old-token-material",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .providerAccount(id: "acct-alpha"))
+        defer {
+            settings._test_liveSystemCodexAccount = nil
+        }
+
+        let store = self.makeUsageStore(settings: settings)
+        let expectedGuard = store.freshCodexOpenAIWebRefreshGuard()
+        store._test_openAIDashboardLoaderOverride = { _, _, _, _ in
+            settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+                email: "alpha@example.com",
+                authFingerprint: "new-token-material",
+                codexHomePath: "/Users/test/.codex",
+                observedAt: Date(),
+                identity: .providerAccount(id: "acct-alpha"))
+            throw TestRefreshError(message: "old dashboard failure")
+        }
+        defer { store._test_openAIDashboardLoaderOverride = nil }
+
+        await store.refreshOpenAIDashboardIfNeeded(force: true, expectedGuard: expectedGuard)
+
+        #expect(store.openAIDashboard == nil)
+        #expect(store.lastOpenAIDashboardError == nil)
+        #expect(store.openAIDashboardRequiresLogin == false)
+    }
+
+    @Test
+    func `same account token refresh fingerprint change applies dashboard policy failure`() async throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-token-refresh-dashboard-policy-failure")
+        let codexMetadata = try #require(ProviderDescriptorRegistry.metadata[.codex])
+        settings.setProviderEnabled(provider: .codex, metadata: codexMetadata, enabled: true)
+        settings.refreshFrequency = .manual
+        settings.openAIWebAccessEnabled = true
+        settings.codexCookieSource = .auto
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "alpha@example.com",
+            authFingerprint: "old-token-material",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .providerAccount(id: "acct-alpha"))
+        defer {
+            settings._test_liveSystemCodexAccount = nil
+        }
+
+        let store = self.makeUsageStore(settings: settings)
+        let expectedGuard = store.freshCodexOpenAIWebRefreshGuard()
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "alpha@example.com",
+            authFingerprint: "new-token-material",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .providerAccount(id: "acct-alpha"))
+
+        await store.applyOpenAIDashboard(
+            self.dashboard(email: "other@example.com", creditsRemaining: 64, usedPercent: 27),
+            targetEmail: "alpha@example.com",
+            expectedGuard: expectedGuard)
+
+        #expect(store.openAIDashboard == nil)
+        #expect(store.lastOpenAIDashboardError?.contains("OpenAI dashboard signed in as other@example.com") == true)
+        #expect(store.openAIDashboardRequiresLogin == true)
+    }
+
+    @Test
+    func `stacked visible refresh discards selected failure after managed token fingerprint rotates`() async throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-selected-managed-token-failure")
+        settings.refreshFrequency = .manual
+        settings.multiAccountMenuLayout = .stacked
+
+        let targetID = try #require(UUID(uuidString: "DDDDDDDD-EEEE-FFFF-AAAA-444444444444"))
+        let siblingID = try #require(UUID(uuidString: "DDDDDDDD-EEEE-FFFF-AAAA-333333333333"))
+        let targetHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-managed-token-\(UUID().uuidString)", isDirectory: true)
+        let siblingHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-managed-token-sibling-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: targetHome, withIntermediateDirectories: true)
+        try FileManager.default.createDirectory(at: siblingHome, withIntermediateDirectories: true)
+        let targetAccount = ManagedCodexAccount(
+            id: targetID,
+            email: "managed-token@example.com",
+            providerAccountID: "acct-managed-token",
+            workspaceLabel: "Managed Team",
+            workspaceAccountID: "acct-managed-token",
+            authFingerprint: "old-managed-token",
+            managedHomePath: targetHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let updatedTarget = ManagedCodexAccount(
+            id: targetID,
+            email: "managed-token@example.com",
+            providerAccountID: "acct-managed-token",
+            workspaceLabel: "Managed Team",
+            workspaceAccountID: "acct-managed-token",
+            authFingerprint: "new-managed-token",
+            managedHomePath: targetHome.path,
+            createdAt: 1,
+            updatedAt: 3,
+            lastAuthenticatedAt: 3)
+        let siblingAccount = ManagedCodexAccount(
+            id: siblingID,
+            email: "managed-token-sibling@example.com",
+            providerAccountID: "acct-managed-token-sibling",
+            workspaceLabel: "Sibling Team",
+            workspaceAccountID: "acct-managed-token-sibling",
+            authFingerprint: "sibling-managed-token",
+            managedHomePath: siblingHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [targetAccount, siblingAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            try? FileManager.default.removeItem(at: storeURL)
+            try? FileManager.default.removeItem(at: targetHome)
+            try? FileManager.default.removeItem(at: siblingHome)
+        }
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .managedAccount(id: targetID)
+
+        let snapshotStore = RecordingCodexAccountUsageSnapshotStore(initialSnapshots: [])
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            codexAccountUsageSnapshotStore: snapshotStore,
+            startupBehavior: .testing)
+        let blocker = BlockingCodexFetchStrategy()
+        let targetHomePath = targetHome.path
+        let now = Date()
+        self.installContextualCodexProvider(on: store) { context in
+            if context.env["CODEX_HOME"] == targetHomePath {
+                return try await blocker.awaitResult()
+            }
+            return UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 9,
+                    windowMinutes: 300,
+                    resetsAt: nil,
+                    resetDescription: nil),
+                secondary: nil,
+                updatedAt: now,
+                identity: ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: "managed-token-sibling@example.com",
+                    accountOrganization: nil,
+                    loginMethod: "Sibling Team"))
+        }
+
+        let refreshTask = Task { await store.refreshCodexVisibleAccountsForMenu() }
+        await blocker.waitUntilStarted()
+        try FileManagedCodexAccountStore(fileURL: storeURL).storeAccounts(ManagedCodexAccountSet(
+            version: FileManagedCodexAccountStore.currentVersion,
+            accounts: [updatedTarget, siblingAccount]))
+        await blocker.resume(with: .failure(TestRefreshError(message: "old managed token failure")))
+        await refreshTask.value
+
+        #expect(store.snapshots[.codex] == nil)
+        #expect(store.errors[.codex] == nil)
+        #expect(!store.codexAccountSnapshots.contains {
+            $0.account.workspaceAccountID == "acct-managed-token"
+        })
+        #expect(!snapshotStore.storedSnapshots.contains {
+            $0.account.workspaceAccountID == "acct-managed-token"
+        })
+    }
+
+    @Test
+    func `stacked visible refresh discards selected failure after managed auth file rotates`() async throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-selected-managed-auth-file-failure")
+        settings.refreshFrequency = .manual
+        settings.multiAccountMenuLayout = .stacked
+
+        let targetID = try #require(UUID(uuidString: "DDDDDDDD-EEEE-FFFF-AAAA-121212121212"))
+        let siblingID = try #require(UUID(uuidString: "DDDDDDDD-EEEE-FFFF-AAAA-131313131313"))
+        let targetHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-managed-auth-file-\(UUID().uuidString)", isDirectory: true)
+        let siblingHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-managed-auth-file-sibling-\(UUID().uuidString)", isDirectory: true)
+        try Self.writeCodexAuthFile(
+            homeURL: targetHome,
+            email: "managed-file-token@example.com",
+            plan: "Pro",
+            accountId: "acct-managed-file-token")
+        let oldFingerprint = try #require(CodexAuthFingerprint.fingerprint(homePath: targetHome.path))
+        let targetAccount = ManagedCodexAccount(
+            id: targetID,
+            email: "managed-file-token@example.com",
+            providerAccountID: "acct-managed-file-token",
+            workspaceLabel: "Managed Team",
+            workspaceAccountID: "acct-managed-file-token",
+            authFingerprint: oldFingerprint,
+            managedHomePath: targetHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let siblingAccount = ManagedCodexAccount(
+            id: siblingID,
+            email: "managed-file-token-sibling@example.com",
+            providerAccountID: "acct-managed-file-token-sibling",
+            workspaceLabel: "Sibling Team",
+            workspaceAccountID: "acct-managed-file-token-sibling",
+            authFingerprint: "sibling-managed-file-token",
+            managedHomePath: siblingHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [targetAccount, siblingAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            try? FileManager.default.removeItem(at: storeURL)
+            try? FileManager.default.removeItem(at: targetHome)
+            try? FileManager.default.removeItem(at: siblingHome)
+        }
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .managedAccount(id: targetID)
+
+        let snapshotStore = RecordingCodexAccountUsageSnapshotStore(initialSnapshots: [])
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            codexAccountUsageSnapshotStore: snapshotStore,
+            startupBehavior: .testing)
+        let blocker = BlockingCodexFetchStrategy()
+        let targetHomePath = targetHome.path
+        let now = Date()
+        self.installContextualCodexProvider(on: store) { context in
+            if context.env["CODEX_HOME"] == targetHomePath {
+                return try await blocker.awaitResult()
+            }
+            return UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 9,
+                    windowMinutes: 300,
+                    resetsAt: nil,
+                    resetDescription: nil),
+                secondary: nil,
+                updatedAt: now,
+                identity: ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: "managed-file-token-sibling@example.com",
+                    accountOrganization: nil,
+                    loginMethod: "Sibling Team"))
+        }
+
+        let refreshTask = Task { await store.refreshCodexVisibleAccountsForMenu() }
+        await blocker.waitUntilStarted()
+        try Self.writeCodexAuthFile(
+            homeURL: targetHome,
+            email: "managed-file-token@example.com",
+            plan: "Team",
+            accountId: "acct-managed-file-token")
+        let newFingerprint = try #require(CodexAuthFingerprint.fingerprint(homePath: targetHome.path))
+        #expect(newFingerprint != oldFingerprint)
+        await blocker.resume(with: .failure(TestRefreshError(message: "old managed auth file failure")))
+        await refreshTask.value
+
+        #expect(store.snapshots[.codex] == nil)
+        #expect(store.errors[.codex] == nil)
+        #expect(!store.codexAccountSnapshots.contains {
+            $0.account.workspaceAccountID == "acct-managed-file-token"
+        })
+        #expect(!snapshotStore.storedSnapshots.contains {
+            $0.account.workspaceAccountID == "acct-managed-file-token"
+        })
+    }
+
+    @Test
+    func `stacked visible refresh keeps selected failure when managed auth file rotated before start`() async throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-selected-managed-auth-file-current-failure")
+        settings.refreshFrequency = .manual
+        settings.multiAccountMenuLayout = .stacked
+
+        let targetID = try #require(UUID(uuidString: "DDDDDDDD-EEEE-FFFF-AAAA-161616161616"))
+        let siblingID = try #require(UUID(uuidString: "DDDDDDDD-EEEE-FFFF-AAAA-171717171717"))
+        let targetHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-managed-current-failure-\(UUID().uuidString)", isDirectory: true)
+        let siblingHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-managed-current-sibling-\(UUID().uuidString)", isDirectory: true)
+        try Self.writeCodexAuthFile(
+            homeURL: targetHome,
+            email: "managed-current-failure@example.com",
+            plan: "Pro",
+            accountId: "acct-managed-current-failure")
+        let oldFingerprint = try #require(CodexAuthFingerprint.fingerprint(homePath: targetHome.path))
+        let targetAccount = ManagedCodexAccount(
+            id: targetID,
+            email: "managed-current-failure@example.com",
+            providerAccountID: "acct-managed-current-failure",
+            workspaceLabel: "Managed Team",
+            workspaceAccountID: "acct-managed-current-failure",
+            authFingerprint: oldFingerprint,
+            managedHomePath: targetHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let siblingAccount = ManagedCodexAccount(
+            id: siblingID,
+            email: "managed-current-sibling@example.com",
+            providerAccountID: "acct-managed-current-sibling",
+            workspaceLabel: "Sibling Team",
+            workspaceAccountID: "acct-managed-current-sibling",
+            authFingerprint: "sibling-managed-current",
+            managedHomePath: siblingHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [targetAccount, siblingAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            try? FileManager.default.removeItem(at: storeURL)
+            try? FileManager.default.removeItem(at: targetHome)
+            try? FileManager.default.removeItem(at: siblingHome)
+        }
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .managedAccount(id: targetID)
+
+        try Self.writeCodexAuthFile(
+            homeURL: targetHome,
+            email: "managed-current-failure@example.com",
+            plan: "Team",
+            accountId: "acct-managed-current-failure")
+        let newFingerprint = try #require(CodexAuthFingerprint.fingerprint(homePath: targetHome.path))
+        #expect(newFingerprint != oldFingerprint)
+
+        let snapshotStore = RecordingCodexAccountUsageSnapshotStore(initialSnapshots: [])
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            codexAccountUsageSnapshotStore: snapshotStore,
+            startupBehavior: .testing)
+        let targetHomePath = targetHome.path
+        let now = Date()
+        self.installContextualCodexProvider(on: store) { context in
+            if context.env["CODEX_HOME"] == targetHomePath {
+                throw TestRefreshError(message: "current managed auth file failure")
+            }
+            return UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 9,
+                    windowMinutes: 300,
+                    resetsAt: nil,
+                    resetDescription: nil),
+                secondary: nil,
+                updatedAt: now,
+                identity: ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: "managed-current-sibling@example.com",
+                    accountOrganization: nil,
+                    loginMethod: "Sibling Team"))
+        }
+
+        await store.refreshCodexVisibleAccountsForMenu()
+
+        #expect(store.errors[.codex] == "current managed auth file failure")
+        let targetSnapshot = try #require(store.codexAccountSnapshots.first {
+            $0.account.workspaceAccountID == "acct-managed-current-failure"
+        })
+        #expect(targetSnapshot.error == "current managed auth file failure")
+        #expect(targetSnapshot.account.authFingerprint == newFingerprint)
+        let persistedTargetSnapshot = try #require(snapshotStore.storedSnapshots.first {
+            $0.account.workspaceAccountID == "acct-managed-current-failure"
+        })
+        #expect(persistedTargetSnapshot.error == "current managed auth file failure")
+        #expect(persistedTargetSnapshot.account.authFingerprint == newFingerprint)
+    }
+
+    @Test
+    func `stacked visible refresh discards selected success after managed auth file switches accounts`() async throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-selected-managed-auth-file-success")
+        settings.refreshFrequency = .manual
+        settings.multiAccountMenuLayout = .stacked
+
+        let targetID = try #require(UUID(uuidString: "DDDDDDDD-EEEE-FFFF-AAAA-141414141414"))
+        let siblingID = try #require(UUID(uuidString: "DDDDDDDD-EEEE-FFFF-AAAA-151515151515"))
+        let targetHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-managed-auth-success-\(UUID().uuidString)", isDirectory: true)
+        let siblingHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent(
+                "codex-visible-managed-auth-success-sibling-\(UUID().uuidString)",
+                isDirectory: true)
+        try Self.writeCodexAuthFile(
+            homeURL: targetHome,
+            email: "managed-old-success@example.com",
+            plan: "Pro",
+            accountId: "acct-managed-old-success")
+        let oldFingerprint = try #require(CodexAuthFingerprint.fingerprint(homePath: targetHome.path))
+        let targetAccount = ManagedCodexAccount(
+            id: targetID,
+            email: "managed-old-success@example.com",
+            providerAccountID: "acct-managed-old-success",
+            workspaceLabel: "Managed Team",
+            workspaceAccountID: "acct-managed-old-success",
+            authFingerprint: oldFingerprint,
+            managedHomePath: targetHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let siblingAccount = ManagedCodexAccount(
+            id: siblingID,
+            email: "managed-success-sibling@example.com",
+            providerAccountID: "acct-managed-success-sibling",
+            workspaceLabel: "Sibling Team",
+            workspaceAccountID: "acct-managed-success-sibling",
+            authFingerprint: "sibling-managed-success",
+            managedHomePath: siblingHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [targetAccount, siblingAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            try? FileManager.default.removeItem(at: storeURL)
+            try? FileManager.default.removeItem(at: targetHome)
+            try? FileManager.default.removeItem(at: siblingHome)
+        }
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .managedAccount(id: targetID)
+
+        let snapshotStore = RecordingCodexAccountUsageSnapshotStore(initialSnapshots: [])
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            codexAccountUsageSnapshotStore: snapshotStore,
+            startupBehavior: .testing)
+        let blocker = BlockingCodexFetchStrategy()
+        let targetHomePath = targetHome.path
+        let now = Date()
+        self.installContextualCodexProvider(on: store) { context in
+            if context.env["CODEX_HOME"] == targetHomePath {
+                return try await blocker.awaitResult()
+            }
+            return UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 9,
+                    windowMinutes: 300,
+                    resetsAt: nil,
+                    resetDescription: nil),
+                secondary: nil,
+                updatedAt: now,
+                identity: ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: "managed-success-sibling@example.com",
+                    accountOrganization: nil,
+                    loginMethod: "Sibling Team"))
+        }
+
+        let refreshTask = Task { await store.refreshCodexVisibleAccountsForMenu() }
+        await blocker.waitUntilStarted()
+        try Self.writeCodexAuthFile(
+            homeURL: targetHome,
+            email: "managed-new-success@example.com",
+            plan: "Pro",
+            accountId: "acct-managed-new-success")
+        let newFingerprint = try #require(CodexAuthFingerprint.fingerprint(homePath: targetHome.path))
+        #expect(newFingerprint != oldFingerprint)
+        await blocker.resume(with: .success(UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 64,
+                windowMinutes: 300,
+                resetsAt: nil,
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: now,
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: "managed-old-success@example.com",
+                accountOrganization: nil,
+                loginMethod: "Managed Team"))))
+        await refreshTask.value
+
+        #expect(store.snapshots[.codex] == nil)
+        #expect(store.errors[.codex] == nil)
+        #expect(!store.codexAccountSnapshots.contains {
+            $0.account.workspaceAccountID == "acct-managed-old-success"
+        })
+        #expect(!snapshotStore.storedSnapshots.contains {
+            $0.account.workspaceAccountID == "acct-managed-old-success"
+        })
+    }
+
+    @Test
+    func `stacked visible refresh keeps migrated managed account after token rotation`() async throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-migrated-managed-token-rotation")
+        settings.refreshFrequency = .manual
+        settings.multiAccountMenuLayout = .stacked
+
+        let targetID = try #require(UUID(uuidString: "DDDDDDDD-EEEE-FFFF-AAAA-171717171717"))
+        let siblingID = try #require(UUID(uuidString: "DDDDDDDD-EEEE-FFFF-AAAA-181818181818"))
+        let targetHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-migrated-managed-\(UUID().uuidString)", isDirectory: true)
+        let siblingHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent(
+                "codex-visible-migrated-managed-sibling-\(UUID().uuidString)",
+                isDirectory: true)
+        try Self.writeCodexAuthFile(
+            homeURL: targetHome,
+            email: "migrated-managed@example.com",
+            plan: "Pro",
+            accountId: "acct-migrated-managed")
+        try Self.writeCodexAuthFile(
+            homeURL: siblingHome,
+            email: "migrated-sibling@example.com",
+            plan: "Pro",
+            accountId: "acct-migrated-sibling")
+        let oldFingerprint = try #require(CodexAuthFingerprint.fingerprint(homePath: targetHome.path))
+        let siblingFingerprint = try #require(CodexAuthFingerprint.fingerprint(homePath: siblingHome.path))
+        let targetAccount = ManagedCodexAccount(
+            id: targetID,
+            email: "migrated-managed@example.com",
+            providerAccountID: "acct-migrated-managed",
+            workspaceLabel: "Managed Team",
+            authFingerprint: oldFingerprint,
+            managedHomePath: targetHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let siblingAccount = ManagedCodexAccount(
+            id: siblingID,
+            email: "migrated-sibling@example.com",
+            providerAccountID: "acct-migrated-sibling",
+            workspaceLabel: "Sibling Team",
+            authFingerprint: siblingFingerprint,
+            managedHomePath: siblingHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [targetAccount, siblingAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            try? FileManager.default.removeItem(at: storeURL)
+            try? FileManager.default.removeItem(at: targetHome)
+            try? FileManager.default.removeItem(at: siblingHome)
+        }
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .managedAccount(id: targetID)
+
+        let snapshotStore = RecordingCodexAccountUsageSnapshotStore(initialSnapshots: [])
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            codexAccountUsageSnapshotStore: snapshotStore,
+            startupBehavior: .testing)
+        let blocker = BlockingCodexFetchStrategy()
+        let targetHomePath = targetHome.path
+        let now = Date()
+        self.installContextualCodexProvider(on: store) { context in
+            if context.env["CODEX_HOME"] == targetHomePath {
+                return try await blocker.awaitResult()
+            }
+            return UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 9,
+                    windowMinutes: 300,
+                    resetsAt: nil,
+                    resetDescription: nil),
+                secondary: nil,
+                updatedAt: now,
+                identity: ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: "migrated-sibling@example.com",
+                    accountOrganization: nil,
+                    loginMethod: "Sibling Team"))
+        }
+
+        let refreshTask = Task { await store.refreshCodexVisibleAccountsForMenu() }
+        await blocker.waitUntilStarted()
+        try Self.writeCodexAuthFile(
+            homeURL: targetHome,
+            email: "migrated-managed@example.com",
+            plan: "Team",
+            accountId: "acct-migrated-managed")
+        let newFingerprint = try #require(CodexAuthFingerprint.fingerprint(homePath: targetHome.path))
+        #expect(newFingerprint != oldFingerprint)
+        await blocker.resume(with: .success(UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 64,
+                windowMinutes: 300,
+                resetsAt: nil,
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: now,
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: "migrated-managed@example.com",
+                accountOrganization: nil,
+                loginMethod: "Managed Team"))))
+        await refreshTask.value
+
+        let selectedSnapshot = try #require(store.snapshots[.codex])
+        #expect(selectedSnapshot.primary?.usedPercent == 64)
+        let targetRow = try #require(store.codexAccountSnapshots.first {
+            $0.account.workspaceAccountID == "acct-migrated-managed"
+        })
+        #expect(targetRow.account.authFingerprint == newFingerprint)
+        #expect(targetRow.snapshot?.primary?.usedPercent == 64)
+        let persistedTarget = try #require(snapshotStore.storedSnapshots.first {
+            $0.account.workspaceAccountID == "acct-migrated-managed"
+        })
+        #expect(persistedTarget.account.authFingerprint == newFingerprint)
+        #expect(persistedTarget.snapshot?.primary?.usedPercent == 64)
+    }
+
+    @Test
+    func `stacked visible refresh discards selected success after managed auth file email changes`() async throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-selected-managed-auth-email-success")
+        settings.refreshFrequency = .manual
+        settings.multiAccountMenuLayout = .stacked
+
+        let targetID = try #require(UUID(uuidString: "DDDDDDDD-EEEE-FFFF-AAAA-191919191919"))
+        let siblingID = try #require(UUID(uuidString: "DDDDDDDD-EEEE-FFFF-AAAA-202020202020"))
+        let targetHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-managed-auth-email-\(UUID().uuidString)", isDirectory: true)
+        let siblingHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent(
+                "codex-visible-managed-auth-email-sibling-\(UUID().uuidString)",
+                isDirectory: true)
+        try Self.writeCodexAuthFile(
+            homeURL: targetHome,
+            email: "managed-old-email@example.com",
+            plan: "Pro",
+            accountId: "acct-managed-email-same")
+        try Self.writeCodexAuthFile(
+            homeURL: siblingHome,
+            email: "managed-email-sibling@example.com",
+            plan: "Pro",
+            accountId: "acct-managed-email-sibling")
+        let oldFingerprint = try #require(CodexAuthFingerprint.fingerprint(homePath: targetHome.path))
+        let siblingFingerprint = try #require(CodexAuthFingerprint.fingerprint(homePath: siblingHome.path))
+        let targetAccount = ManagedCodexAccount(
+            id: targetID,
+            email: "managed-old-email@example.com",
+            providerAccountID: "acct-managed-email-same",
+            workspaceLabel: "Managed Team",
+            workspaceAccountID: "acct-managed-email-same",
+            authFingerprint: oldFingerprint,
+            managedHomePath: targetHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let siblingAccount = ManagedCodexAccount(
+            id: siblingID,
+            email: "managed-email-sibling@example.com",
+            providerAccountID: "acct-managed-email-sibling",
+            workspaceLabel: "Sibling Team",
+            workspaceAccountID: "acct-managed-email-sibling",
+            authFingerprint: siblingFingerprint,
+            managedHomePath: siblingHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [targetAccount, siblingAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            try? FileManager.default.removeItem(at: storeURL)
+            try? FileManager.default.removeItem(at: targetHome)
+            try? FileManager.default.removeItem(at: siblingHome)
+        }
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .managedAccount(id: targetID)
+
+        let snapshotStore = RecordingCodexAccountUsageSnapshotStore(initialSnapshots: [])
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            codexAccountUsageSnapshotStore: snapshotStore,
+            startupBehavior: .testing)
+        let blocker = BlockingCodexFetchStrategy()
+        let targetHomePath = targetHome.path
+        let now = Date()
+        self.installContextualCodexProvider(on: store) { context in
+            if context.env["CODEX_HOME"] == targetHomePath {
+                return try await blocker.awaitResult()
+            }
+            return UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 9,
+                    windowMinutes: 300,
+                    resetsAt: nil,
+                    resetDescription: nil),
+                secondary: nil,
+                updatedAt: now,
+                identity: ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: "managed-email-sibling@example.com",
+                    accountOrganization: nil,
+                    loginMethod: "Sibling Team"))
+        }
+
+        let refreshTask = Task { await store.refreshCodexVisibleAccountsForMenu() }
+        await blocker.waitUntilStarted()
+        try Self.writeCodexAuthFile(
+            homeURL: targetHome,
+            email: "managed-new-email@example.com",
+            plan: "Pro",
+            accountId: "acct-managed-email-same")
+        let newFingerprint = try #require(CodexAuthFingerprint.fingerprint(homePath: targetHome.path))
+        #expect(newFingerprint != oldFingerprint)
+        await blocker.resume(with: .success(UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 64,
+                windowMinutes: 300,
+                resetsAt: nil,
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: now,
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: "managed-old-email@example.com",
+                accountOrganization: nil,
+                loginMethod: "Managed Team"))))
+        await refreshTask.value
+
+        #expect(store.snapshots[.codex] == nil)
+        #expect(store.errors[.codex] == nil)
+        #expect(!store.codexAccountSnapshots.contains {
+            $0.account.workspaceAccountID == "acct-managed-email-same"
+        })
+        #expect(!snapshotStore.storedSnapshots.contains {
+            $0.account.workspaceAccountID == "acct-managed-email-same"
+        })
+    }
+
+    @Test
+    func `managed failure guard reads current auth file fingerprint`() throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-managed-auth-file-fingerprint")
+        settings.refreshFrequency = .manual
+        let accountID = try #require(UUID(uuidString: "DDDDDDDD-EEEE-FFFF-AAAA-555555555555"))
+        let managedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-managed-auth-file-\(UUID().uuidString)", isDirectory: true)
+        try Self.writeCodexAuthFile(
+            homeURL: managedHome,
+            email: "managed-auth@example.com",
+            plan: "Pro",
+            accountId: "acct-managed-auth")
+        let oldFingerprint = try #require(CodexAuthFingerprint.fingerprint(homePath: managedHome.path))
+        let managedAccount = ManagedCodexAccount(
+            id: accountID,
+            email: "managed-auth@example.com",
+            providerAccountID: "acct-managed-auth",
+            workspaceLabel: "Managed Auth",
+            workspaceAccountID: "acct-managed-auth",
+            authFingerprint: oldFingerprint,
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            try? FileManager.default.removeItem(at: storeURL)
+            try? FileManager.default.removeItem(at: managedHome)
+        }
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .managedAccount(id: accountID)
+
+        let store = self.makeUsageStore(settings: settings)
+        let expectedGuard = store.freshCodexAccountScopedRefreshGuard()
+        #expect(expectedGuard.authFingerprint == oldFingerprint)
+
+        try Self.writeCodexAuthFile(
+            homeURL: managedHome,
+            email: "managed-auth@example.com",
+            plan: "Team",
+            accountId: "acct-managed-auth")
+        let newFingerprint = try #require(CodexAuthFingerprint.fingerprint(homePath: managedHome.path))
+        #expect(newFingerprint != oldFingerprint)
+
+        #expect(store.freshCodexAccountScopedRefreshGuard().authFingerprint == newFingerprint)
+        #expect(!store.shouldApplyCodexScopedFailure(expectedGuard: expectedGuard))
+        #expect(!store.shouldApplyCodexScopedNonUsageFailure(expectedGuard: expectedGuard))
+
+        try FileManager.default.removeItem(at: managedHome)
+        #expect(store.freshCodexAccountScopedRefreshGuard().authFingerprint == nil)
+        let staleUsage = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 41,
+                windowMinutes: 300,
+                resetsAt: nil,
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: "managed-auth@example.com",
+                accountOrganization: nil,
+                loginMethod: "Managed Auth"))
+        #expect(!store.shouldApplyCodexUsageResult(expectedGuard: expectedGuard, usage: staleUsage))
+        #expect(!store.shouldApplyCodexScopedFailure(expectedGuard: expectedGuard))
+        #expect(!store.shouldApplyCodexScopedNonUsageFailure(expectedGuard: expectedGuard))
+    }
+
+    @Test
+    func `stale auth fingerprint cache at refresh start keeps current codex usage success`() async {
+        SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = 60
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-stale-start-cache-current-auth")
+        defer {
+            SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = nil
+            settings._test_liveSystemCodexAccount = nil
+        }
+        settings.refreshFrequency = .manual
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "alpha@example.com",
+            authFingerprint: "old-email-only-auth",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .emailOnly(normalizedEmail: "alpha@example.com"))
+        let staleReconciliationSnapshot = settings.codexAccountReconciliationSnapshot
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "alpha@example.com",
+            authFingerprint: "new-email-only-auth",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .emailOnly(normalizedEmail: "alpha@example.com"))
+        settings.cachedCodexAccountReconciliationSnapshot = CachedCodexAccountReconciliationSnapshot(
+            activeSource: .liveSystem,
+            loadedAt: Date(),
+            snapshot: staleReconciliationSnapshot)
+
+        let store = self.makeUsageStore(settings: settings)
+        let blocker = BlockingCodexFetchStrategy()
+        self.installBlockingCodexProvider(on: store, blocker: blocker)
+
+        let refreshTask = Task { await store.refreshProvider(.codex, allowDisabled: true) }
+        await blocker.waitUntilStarted()
+        await blocker.resume(with: .success(self.codexSnapshot(email: "alpha@example.com", usedPercent: 33)))
+        await refreshTask.value
+
+        #expect(store.snapshots[.codex]?.primary?.usedPercent == 33)
+        #expect(store.lastCodexAccountScopedRefreshGuard?.authFingerprint == "new-email-only-auth")
+        #expect(store.errors[.codex] == nil)
+    }
+
+    @Test
+    func `same provider account live email change discards stale codex usage success`() async {
+        SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = 60
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-provider-email-change")
+        defer {
+            SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = nil
+            settings._test_liveSystemCodexAccount = nil
+        }
+        settings.refreshFrequency = .manual
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "old@example.com",
+            authFingerprint: "old-provider-auth",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .providerAccount(id: "acct-shared"))
+        let staleReconciliationSnapshot = settings.codexAccountReconciliationSnapshot
+
+        let store = self.makeUsageStore(settings: settings)
+        let blocker = BlockingCodexFetchStrategy()
+        self.installBlockingCodexProvider(on: store, blocker: blocker)
+
+        let refreshTask = Task { await store.refreshProvider(.codex, allowDisabled: true) }
+        await blocker.waitUntilStarted()
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "new@example.com",
+            authFingerprint: "new-provider-auth",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .providerAccount(id: "acct-shared"))
+        settings.cachedCodexAccountReconciliationSnapshot = CachedCodexAccountReconciliationSnapshot(
+            activeSource: .liveSystem,
+            loadedAt: Date(),
+            snapshot: staleReconciliationSnapshot)
+        await blocker.resume(with: .success(self.codexSnapshot(email: "old@example.com", usedPercent: 25)))
+        await refreshTask.value
+
+        #expect(store.snapshots[.codex] == nil)
+        #expect(store.errors[.codex] == nil)
+    }
+
+    @Test
+    func `same provider account managed email change discards stale codex usage success`() async throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-managed-provider-email-change")
+        settings.refreshFrequency = .manual
+
+        let accountID = try #require(UUID(uuidString: "DDDDDDDD-EEEE-FFFF-AAAA-161616161616"))
+        let managedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-managed-provider-email-\(UUID().uuidString)", isDirectory: true)
+        try Self.writeCodexAuthFile(
+            homeURL: managedHome,
+            email: "old-managed@example.com",
+            plan: "Pro",
+            accountId: "acct-managed-shared")
+        let oldFingerprint = try #require(CodexAuthFingerprint.fingerprint(homePath: managedHome.path))
+        let managedAccount = ManagedCodexAccount(
+            id: accountID,
+            email: "old-managed@example.com",
+            providerAccountID: "acct-managed-shared",
+            workspaceLabel: "Managed Team",
+            workspaceAccountID: "acct-managed-shared",
+            authFingerprint: oldFingerprint,
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            try? FileManager.default.removeItem(at: storeURL)
+            try? FileManager.default.removeItem(at: managedHome)
+        }
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .managedAccount(id: accountID)
+
+        let store = self.makeUsageStore(settings: settings)
+        let blocker = BlockingCodexFetchStrategy()
+        self.installBlockingCodexProvider(on: store, blocker: blocker)
+
+        let refreshTask = Task { await store.refreshProvider(.codex, allowDisabled: true) }
+        await blocker.waitUntilStarted()
+        try Self.writeCodexAuthFile(
+            homeURL: managedHome,
+            email: "new-managed@example.com",
+            plan: "Pro",
+            accountId: "acct-managed-shared")
+        let newFingerprint = try #require(CodexAuthFingerprint.fingerprint(homePath: managedHome.path))
+        #expect(newFingerprint != oldFingerprint)
+        await blocker.resume(with: .success(self.codexSnapshot(email: "old-managed@example.com", usedPercent: 25)))
+        await refreshTask.value
+
+        #expect(store.snapshots[.codex] == nil)
+        #expect(store.errors[.codex] == nil)
+    }
+
+    @Test
+    func `managed codex usage success without email applies when auth guard matches`() async throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-managed-usage-without-email")
+        settings.refreshFrequency = .manual
+
+        let accountID = try #require(UUID(uuidString: "DDDDDDDD-EEEE-FFFF-AAAA-171717171717"))
+        let managedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-managed-usage-without-email-\(UUID().uuidString)", isDirectory: true)
+        try Self.writeCodexAuthFile(
+            homeURL: managedHome,
+            email: "email-less-managed@example.com",
+            plan: "Pro",
+            accountId: "acct-managed-email-less")
+        let authFingerprint = try #require(CodexAuthFingerprint.fingerprint(homePath: managedHome.path))
+        let managedAccount = ManagedCodexAccount(
+            id: accountID,
+            email: "email-less-managed@example.com",
+            providerAccountID: "acct-managed-email-less",
+            workspaceLabel: "Managed Team",
+            workspaceAccountID: "acct-managed-email-less",
+            authFingerprint: authFingerprint,
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            try? FileManager.default.removeItem(at: storeURL)
+            try? FileManager.default.removeItem(at: managedHome)
+        }
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .managedAccount(id: accountID)
+
+        let store = self.makeUsageStore(settings: settings)
+        let blocker = BlockingCodexFetchStrategy()
+        self.installBlockingCodexProvider(on: store, blocker: blocker)
+
+        let refreshTask = Task { await store.refreshProvider(.codex, allowDisabled: true) }
+        await blocker.waitUntilStarted()
+        await blocker.resume(with: .success(UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 25,
+                windowMinutes: 300,
+                resetsAt: nil,
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())))
+        await refreshTask.value
+
+        #expect(store.snapshots[.codex]?.primary?.usedPercent == 25)
+        #expect(store.errors[.codex] == nil)
+    }
+
+    @Test
+    func `same provider account managed email change discards stale codex usage success without email`() async throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-managed-provider-email-change-without-email")
+        settings.refreshFrequency = .manual
+
+        let accountID = try #require(UUID(uuidString: "DDDDDDDD-EEEE-FFFF-AAAA-181818181818"))
+        let managedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent(
+                "codex-managed-provider-email-without-email-\(UUID().uuidString)",
+                isDirectory: true)
+        try Self.writeCodexAuthFile(
+            homeURL: managedHome,
+            email: "old-managed-empty@example.com",
+            plan: "Pro",
+            accountId: "acct-managed-shared-empty")
+        let oldFingerprint = try #require(CodexAuthFingerprint.fingerprint(homePath: managedHome.path))
+        let managedAccount = ManagedCodexAccount(
+            id: accountID,
+            email: "old-managed-empty@example.com",
+            providerAccountID: "acct-managed-shared-empty",
+            workspaceLabel: "Managed Team",
+            workspaceAccountID: "acct-managed-shared-empty",
+            authFingerprint: oldFingerprint,
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            try? FileManager.default.removeItem(at: storeURL)
+            try? FileManager.default.removeItem(at: managedHome)
+        }
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .managedAccount(id: accountID)
+
+        let store = self.makeUsageStore(settings: settings)
+        let blocker = BlockingCodexFetchStrategy()
+        self.installBlockingCodexProvider(on: store, blocker: blocker)
+
+        let refreshTask = Task { await store.refreshProvider(.codex, allowDisabled: true) }
+        await blocker.waitUntilStarted()
+        try Self.writeCodexAuthFile(
+            homeURL: managedHome,
+            email: "new-managed-empty@example.com",
+            plan: "Pro",
+            accountId: "acct-managed-shared-empty")
+        let newFingerprint = try #require(CodexAuthFingerprint.fingerprint(homePath: managedHome.path))
+        #expect(newFingerprint != oldFingerprint)
+        await blocker.resume(with: .success(UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 25,
+                windowMinutes: 300,
+                resetsAt: nil,
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())))
+        await refreshTask.value
+
+        #expect(store.snapshots[.codex] == nil)
+        #expect(store.errors[.codex] == nil)
+    }
+
+    @Test
+    func `same email email-only auth fingerprint switch discards stale codex usage success`() async {
+        SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = 60
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-email-only-fingerprint-switch")
+        defer {
+            SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = nil
+            settings._test_liveSystemCodexAccount = nil
+        }
+        settings.refreshFrequency = .manual
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "alpha@example.com",
+            authFingerprint: "old-email-only-auth",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .emailOnly(normalizedEmail: "alpha@example.com"))
+        let staleReconciliationSnapshot = settings.codexAccountReconciliationSnapshot
+
+        let store = self.makeUsageStore(settings: settings)
+        let blocker = BlockingCodexFetchStrategy()
+        self.installBlockingCodexProvider(on: store, blocker: blocker)
+
+        let refreshTask = Task { await store.refreshProvider(.codex, allowDisabled: true) }
+        await blocker.waitUntilStarted()
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "alpha@example.com",
+            authFingerprint: "new-email-only-auth",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .emailOnly(normalizedEmail: "alpha@example.com"))
+        settings.cachedCodexAccountReconciliationSnapshot = CachedCodexAccountReconciliationSnapshot(
+            activeSource: .liveSystem,
+            loadedAt: Date(),
+            snapshot: staleReconciliationSnapshot)
+        await blocker.resume(with: .success(self.codexSnapshot(email: "alpha@example.com", usedPercent: 25)))
+        await refreshTask.value
+
+        #expect(store.snapshots[.codex] == nil)
+        #expect(store.errors[.codex] == nil)
+    }
+}
diff --git a/Tests/CodexBarTests/CodexAccountEmailOnlyHistoryBackfillTests.swift b/Tests/CodexBarTests/CodexAccountEmailOnlyHistoryBackfillTests.swift
new file mode 100644
index 0000000000..1b149c576e
--- /dev/null
+++ b/Tests/CodexBarTests/CodexAccountEmailOnlyHistoryBackfillTests.swift
@@ -0,0 +1,120 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@MainActor
+extension CodexAccountScopedRefreshTests {
+    @Test
+    func `backfills non active email only codex row from own history`() async throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountVisibleHistoryBackfillTests-non-active-email-history")
+        settings.refreshFrequency = .manual
+        settings.multiAccountMenuLayout = .stacked
+
+        let activeID = try #require(UUID(uuidString: "BBBBBBBB-CCCC-DDDD-EEEE-333333333333"))
+        let siblingID = try #require(UUID(uuidString: "BBBBBBBB-CCCC-DDDD-EEEE-444444444444"))
+        let activeHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-active-email-\(UUID().uuidString)", isDirectory: true)
+        let siblingHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-sibling-email-\(UUID().uuidString)", isDirectory: true)
+        try Self.writeCodexAuthFile(
+            homeURL: activeHome,
+            email: "active-email-history@example.com",
+            plan: "Pro")
+        try Self.writeCodexAuthFile(
+            homeURL: siblingHome,
+            email: "sibling-email-history@example.com",
+            plan: "Pro")
+        let activeFingerprint = try #require(CodexAuthFingerprint.fingerprint(homePath: activeHome.path))
+        let siblingFingerprint = try #require(CodexAuthFingerprint.fingerprint(homePath: siblingHome.path))
+        let activeAccount = ManagedCodexAccount(
+            id: activeID,
+            email: "active-email-history@example.com",
+            workspaceLabel: "Active Team",
+            authFingerprint: activeFingerprint,
+            managedHomePath: activeHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let siblingAccount = ManagedCodexAccount(
+            id: siblingID,
+            email: "sibling-email-history@example.com",
+            workspaceLabel: "Sibling Team",
+            authFingerprint: siblingFingerprint,
+            managedHomePath: siblingHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [activeAccount, siblingAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            try? FileManager.default.removeItem(at: storeURL)
+            try? FileManager.default.removeItem(at: activeHome)
+            try? FileManager.default.removeItem(at: siblingHome)
+        }
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .managedAccount(id: activeID)
+
+        let snapshotStore = RecordingCodexAccountUsageSnapshotStore(initialSnapshots: [])
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            codexAccountUsageSnapshotStore: snapshotStore,
+            startupBehavior: .testing)
+        let now = Date()
+        let sessionReset = now.addingTimeInterval(2 * 60 * 60)
+        let weeklyReset = now.addingTimeInterval(4 * 24 * 60 * 60)
+        let siblingHistoryKey = CodexHistoryOwnership.canonicalEmailHashKey(for: "sibling-email-history@example.com")
+        store.planUtilizationHistory[.codex] = PlanUtilizationHistoryBuckets(accounts: [
+            siblingHistoryKey: [
+                planSeries(name: .session, windowMinutes: 300, entries: [
+                    planEntry(at: now.addingTimeInterval(-60), usedPercent: 6, resetsAt: sessionReset),
+                ]),
+                planSeries(name: .weekly, windowMinutes: 10080, entries: [
+                    planEntry(at: now.addingTimeInterval(-60), usedPercent: 36, resetsAt: weeklyReset),
+                ]),
+            ],
+        ])
+        store.lastCodexAccountScopedRefreshGuard = CodexAccountScopedRefreshGuard(
+            source: .managedAccount(id: activeID),
+            identity: .emailOnly(normalizedEmail: "active-email-history@example.com"),
+            accountKey: "active-email-history@example.com",
+            authFingerprint: activeFingerprint)
+        self.installContextualCodexProvider(on: store) { context in
+            let isActive = context.env["CODEX_HOME"] == activeHome.path
+            return UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: isActive ? 3 : 6,
+                    windowMinutes: 0,
+                    resetsAt: nil,
+                    resetDescription: nil),
+                secondary: nil,
+                updatedAt: now)
+        }
+
+        await store.refreshCodexVisibleAccountsForMenu()
+
+        let activeSnapshot = try #require(store.codexAccountSnapshots.first {
+            $0.account.email == "active-email-history@example.com"
+        }?.snapshot)
+        #expect(activeSnapshot.primary?.usedPercent == 3)
+        #expect(activeSnapshot.primary?.windowMinutes == 0)
+        #expect(activeSnapshot.primary?.resetsAt == nil)
+
+        let siblingSnapshot = try #require(store.codexAccountSnapshots.first {
+            $0.account.email == "sibling-email-history@example.com"
+        }?.snapshot)
+        #expect(siblingSnapshot.primary?.usedPercent == 6)
+        #expect(siblingSnapshot.primary?.windowMinutes == 300)
+        #expect(siblingSnapshot.primary?.resetsAt == sessionReset)
+        #expect(siblingSnapshot.secondary?.usedPercent == 36)
+        #expect(siblingSnapshot.secondary?.resetsAt == weeklyReset)
+        let persistedSibling = try #require(snapshotStore.storedSnapshots.first {
+            $0.account.email == "sibling-email-history@example.com"
+        }?.snapshot)
+        #expect(persistedSibling.primary?.resetsAt == sessionReset)
+        #expect(persistedSibling.secondary?.resetsAt == weeklyReset)
+    }
+}
diff --git a/Tests/CodexBarTests/CodexAccountFingerprintReconciliationTests.swift b/Tests/CodexBarTests/CodexAccountFingerprintReconciliationTests.swift
new file mode 100644
index 0000000000..5d87dff585
--- /dev/null
+++ b/Tests/CodexBarTests/CodexAccountFingerprintReconciliationTests.swift
@@ -0,0 +1,102 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@Suite(.serialized)
+struct CodexAccountFingerprintReconciliationTests {
+    @Test
+    func `active source falls back to identity when auth fingerprint rotated`() throws {
+        let accountID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-333333333333"))
+        let managed = ManagedCodexAccount(
+            id: accountID,
+            email: "rotated@example.com",
+            authFingerprint: "old-auth-json",
+            managedHomePath: "/tmp/rotated",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 3)
+        let live = ObservedSystemCodexAccount(
+            email: "rotated@example.com",
+            authFingerprint: "new-auth-json",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .emailOnly(normalizedEmail: "rotated@example.com"))
+        let snapshot = CodexAccountReconciliationSnapshot(
+            storedAccounts: [managed],
+            activeStoredAccount: managed,
+            liveSystemAccount: live,
+            matchingStoredAccountForLiveSystemAccount: managed,
+            activeSource: .managedAccount(id: accountID),
+            hasUnreadableAddedAccountStore: false)
+
+        let resolution = CodexActiveSourceResolver.resolve(from: snapshot)
+
+        #expect(resolution.resolvedSource == .liveSystem)
+        #expect(resolution.requiresPersistenceCorrection)
+    }
+
+    @Test
+    @MainActor
+    func `auth fingerprint matches live account before semantic duplicate identity`() throws {
+        let suite = "CodexAccountFingerprintReconciliationTests-auth-fingerprint"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        let firstID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-111111111111"))
+        let secondID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-222222222222"))
+        let first = ManagedCodexAccount(
+            id: firstID,
+            email: "same@example.com",
+            authFingerprint: "1111",
+            managedHomePath: "/tmp/first",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 3)
+        let second = ManagedCodexAccount(
+            id: secondID,
+            email: "same@example.com",
+            providerAccountID: "account-team",
+            authFingerprint: "2222",
+            managedHomePath: "/tmp/second",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 3)
+        let storeURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-managed-store-\(UUID().uuidString).json")
+        try Self.writeManagedCodexStore(
+            ManagedCodexAccountSet(version: FileManagedCodexAccountStore.currentVersion, accounts: [first, second]),
+            to: storeURL)
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "same@example.com",
+            authFingerprint: "2222",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .emailOnly(normalizedEmail: "same@example.com"))
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            settings._test_liveSystemCodexAccount = nil
+            try? FileManager.default.removeItem(at: storeURL)
+        }
+
+        let snapshot = settings.codexAccountReconciliationSnapshot
+        let projection = settings.codexVisibleAccountProjection
+
+        #expect(snapshot.matchingStoredAccountForLiveSystemAccount?.id == secondID)
+        #expect(projection.liveVisibleAccountID == "live:email:same@example.com")
+        #expect(projection.visibleAccounts.first { $0.storedAccountID == secondID }?.isLive == true)
+        #expect(projection.visibleAccounts.first { $0.storedAccountID == firstID }?.isLive == false)
+    }
+
+    private static func writeManagedCodexStore(_ accounts: ManagedCodexAccountSet, to storeURL: URL) throws {
+        let encoder = JSONEncoder()
+        encoder.outputFormatting = [.sortedKeys]
+        let data = try encoder.encode(accounts)
+        try data.write(to: storeURL, options: [.atomic])
+    }
+}
diff --git a/Tests/CodexBarTests/CodexAccountMenuDisplaySnapshotTests.swift b/Tests/CodexBarTests/CodexAccountMenuDisplaySnapshotTests.swift
new file mode 100644
index 0000000000..5941c8b000
--- /dev/null
+++ b/Tests/CodexBarTests/CodexAccountMenuDisplaySnapshotTests.swift
@@ -0,0 +1,346 @@
+import AppKit
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@Suite(.serialized)
+@MainActor
+struct CodexAccountMenuDisplaySnapshotTests {
+    private func makeSettings() -> SettingsStore {
+        let suite = "CodexAccountMenuDisplaySnapshotTests-\(UUID().uuidString)"
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        defaults.set(true, forKey: "providerDetectionCompleted")
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.providerDetectionCompleted = true
+        return settings
+    }
+
+    private func enableOnlyCodex(_ settings: SettingsStore) {
+        for provider in UsageProvider.allCases {
+            guard let metadata = ProviderRegistry.shared.metadata[provider] else { continue }
+            settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: provider == .codex)
+        }
+    }
+
+    private func liveSnapshot(email: String) -> CodexAccountReconciliationSnapshot {
+        CodexAccountReconciliationSnapshot(
+            storedAccounts: [],
+            activeStoredAccount: nil,
+            liveSystemAccount: ObservedSystemCodexAccount(
+                email: email,
+                codexHomePath: "/tmp/\(email)",
+                observedAt: Date()),
+            matchingStoredAccountForLiveSystemAccount: nil,
+            activeSource: .liveSystem,
+            hasUnreadableAddedAccountStore: false)
+    }
+
+    private func cachedProjection(
+        snapshot: CodexAccountReconciliationSnapshot,
+        loadedAt: Date = Date(timeIntervalSinceNow: -3600)) -> CachedCodexAccountMenuProjection
+    {
+        CachedCodexAccountMenuProjection(
+            activeSource: snapshot.activeSource,
+            loadedAt: loadedAt,
+            projection: CodexVisibleAccountProjection.make(from: snapshot))
+    }
+
+    @Test
+    func `cold menu projection read never loads auth state`() async {
+        let settings = self.makeSettings()
+        let probe = CodexAccountSnapshotLoaderProbe(snapshot: self.liveSnapshot(email: "loaded@example.com"))
+        settings._test_codexAccountSnapshotLoader = { _ in probe.load() }
+        defer { settings._test_codexAccountSnapshotLoader = nil }
+
+        #expect(settings.codexVisibleAccountProjectionForMenuDisplay == nil)
+        #expect(probe.callCount == 0)
+
+        let result = await settings.revalidateCodexAccountMenuProjection()
+
+        #expect(result == .updated)
+        #expect(probe.callCount == 1)
+        #expect(probe.loadedOffMainThread)
+        #expect(
+            settings.codexVisibleAccountProjectionForMenuDisplay?.visibleAccounts.first?.email ==
+                "loaded@example.com")
+    }
+
+    @Test
+    func `override snapshot load preserves persisted account menu projection`() {
+        let settings = self.makeSettings()
+        let activeSnapshot = self.liveSnapshot(email: "active@example.com")
+        settings.cachedCodexAccountMenuProjection = self.cachedProjection(snapshot: activeSnapshot)
+
+        let otherID = UUID()
+        let otherAccount = ManagedCodexAccount(
+            id: otherID,
+            email: "other@example.com",
+            managedHomePath: "/tmp/other",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let overrideSnapshot = CodexAccountReconciliationSnapshot(
+            storedAccounts: [otherAccount],
+            activeStoredAccount: otherAccount,
+            liveSystemAccount: nil,
+            matchingStoredAccountForLiveSystemAccount: nil,
+            activeSource: .managedAccount(id: otherID),
+            hasUnreadableAddedAccountStore: false)
+        settings._test_codexAccountSnapshotLoader = { _ in overrideSnapshot }
+        defer { settings._test_codexAccountSnapshotLoader = nil }
+
+        _ = settings.codexAccountReconciliationSnapshot(activeSourceOverride: .managedAccount(id: otherID))
+
+        #expect(
+            settings.codexVisibleAccountProjectionForMenuDisplay?.visibleAccounts.first?.email ==
+                "active@example.com")
+    }
+
+    @Test
+    func `managed account change refreshes account menu projection`() {
+        let settings = self.makeSettings()
+        let activeSnapshot = self.liveSnapshot(email: "active@example.com")
+        settings.cachedCodexAccountMenuProjection = self.cachedProjection(snapshot: activeSnapshot, loadedAt: Date())
+
+        let addedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "added@example.com",
+            managedHomePath: "/tmp/added",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let refreshedSnapshot = CodexAccountReconciliationSnapshot(
+            storedAccounts: [addedAccount],
+            activeStoredAccount: nil,
+            liveSystemAccount: activeSnapshot.liveSystemAccount,
+            matchingStoredAccountForLiveSystemAccount: nil,
+            activeSource: .liveSystem,
+            hasUnreadableAddedAccountStore: false)
+        settings._test_codexAccountSnapshotLoader = { _ in refreshedSnapshot }
+        defer { settings._test_codexAccountSnapshotLoader = nil }
+
+        settings.refreshCodexAccountReconciliationAfterManagedAccountsDidChange()
+
+        #expect(
+            settings.codexVisibleAccountProjectionForMenuDisplay?.visibleAccounts.contains {
+                $0.email == "added@example.com"
+            } == true)
+    }
+
+    @Test
+    func `stale menu projection returns immediately then refreshes concurrently`() async {
+        let settings = self.makeSettings()
+        let staleSnapshot = self.liveSnapshot(email: "before@example.com")
+        let probe = CodexAccountSnapshotLoaderProbe(snapshot: self.liveSnapshot(email: "after@example.com"))
+        settings.cachedCodexAccountMenuProjection = self.cachedProjection(snapshot: staleSnapshot)
+        settings._test_codexAccountSnapshotLoader = { _ in probe.load() }
+        SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = 60
+        defer {
+            SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = nil
+            settings._test_codexAccountSnapshotLoader = nil
+        }
+
+        #expect(
+            settings.codexVisibleAccountProjectionForMenuDisplay?.visibleAccounts.first?.email ==
+                "before@example.com")
+        #expect(probe.callCount == 0)
+        #expect(settings.codexAccountMenuProjectionNeedsRevalidation)
+
+        let result = await settings.revalidateCodexAccountMenuProjection()
+
+        #expect(result == .updated)
+        #expect(probe.callCount == 1)
+        #expect(probe.loadedOffMainThread)
+        #expect(
+            settings.codexVisibleAccountProjectionForMenuDisplay?.visibleAccounts.first?.email ==
+                "after@example.com")
+    }
+
+    @Test
+    func `revalidation discards result after reconciliation generation changes`() async {
+        let settings = self.makeSettings()
+        let staleSnapshot = self.liveSnapshot(email: "before@example.com")
+        let probe = CodexAccountSnapshotLoaderProbe(
+            snapshot: self.liveSnapshot(email: "discarded@example.com"),
+            blocks: true)
+        settings.cachedCodexAccountMenuProjection = self.cachedProjection(snapshot: staleSnapshot)
+        settings._test_codexAccountSnapshotLoader = { _ in probe.load() }
+        SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = 60
+        defer {
+            probe.release()
+            SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = nil
+            settings._test_codexAccountSnapshotLoader = nil
+        }
+
+        let task = Task { await settings.revalidateCodexAccountMenuProjection() }
+        await probe.waitUntilCalled()
+        settings.invalidateCodexAccountReconciliationSnapshotCache()
+        probe.release()
+
+        #expect(await task.value == .discarded)
+        #expect(
+            settings.codexVisibleAccountProjectionForMenuDisplay?.visibleAccounts.first?.email ==
+                "before@example.com")
+    }
+
+    @Test
+    func `fresh menu open coalesces account projection revalidation and identity stays read only`() async throws {
+        StatusItemController.menuCardRenderingEnabled = false
+        StatusItemController.setMenuRefreshEnabledForTesting(false)
+        StatusItemController.setCodexAccountMenuProjectionRevalidationEnabledForTesting(true)
+        defer {
+            StatusItemController.resetCodexAccountMenuProjectionRevalidationEnabledForTesting()
+            StatusItemController.resetMenuRefreshEnabledForTesting()
+        }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        self.enableOnlyCodex(settings)
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: AccountInfo(email: nil, plan: nil),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let staleSnapshot = self.liveSnapshot(email: "before@example.com")
+        let probe = CodexAccountSnapshotLoaderProbe(
+            snapshot: self.liveSnapshot(email: "after@example.com"),
+            blocks: true)
+        settings.cachedCodexAccountMenuProjection = self.cachedProjection(snapshot: staleSnapshot)
+        settings._test_codexAccountSnapshotLoader = { _ in probe.load() }
+        SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = 60
+        defer {
+            probe.release()
+            SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = nil
+            settings._test_codexAccountSnapshotLoader = nil
+        }
+
+        let menu = NSMenu()
+        controller.menuProviders[ObjectIdentifier(menu)] = .codex
+        controller.markMenuFresh(menu)
+        #expect(controller.codexAccountMenuDisplay(for: .codex) == nil)
+        #expect(probe.callCount == 0)
+
+        let versionBeforeOpen = controller.menuContentVersion
+        controller.menuWillOpen(menu)
+        let revalidation = try #require(controller.codexAccountMenuProjectionRevalidationTask)
+        controller.menuWillOpen(menu)
+        await probe.waitUntilCalled()
+
+        #expect(probe.callCount == 1)
+        #expect(probe.loadedOffMainThread)
+        probe.release()
+        await revalidation.value
+
+        #expect(controller.codexAccountMenuProjectionRevalidationTask == nil)
+        #expect(controller.menuContentVersion == versionBeforeOpen + 1)
+    }
+
+    @Test
+    func `selecting displayed account uses captured source without reconciliation`() throws {
+        let settings = self.makeSettings()
+        let firstID = UUID()
+        let secondID = UUID()
+        let first = ManagedCodexAccount(
+            id: firstID,
+            email: "first@example.com",
+            managedHomePath: "/tmp/first",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let second = ManagedCodexAccount(
+            id: secondID,
+            email: "second@example.com",
+            managedHomePath: "/tmp/second",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let snapshot = CodexAccountReconciliationSnapshot(
+            storedAccounts: [first, second],
+            activeStoredAccount: first,
+            liveSystemAccount: nil,
+            matchingStoredAccountForLiveSystemAccount: nil,
+            activeSource: .managedAccount(id: firstID),
+            hasUnreadableAddedAccountStore: false)
+        let projection = CodexVisibleAccountProjection.make(from: snapshot)
+        let displayedAccount = try #require(projection.visibleAccounts.first {
+            $0.selectionSource == .managedAccount(id: secondID)
+        })
+        let probe = CodexAccountSnapshotLoaderProbe(snapshot: snapshot)
+        settings.cachedCodexAccountMenuProjection = self.cachedProjection(snapshot: snapshot)
+        settings._test_codexAccountSnapshotLoader = { _ in probe.load() }
+        defer { settings._test_codexAccountSnapshotLoader = nil }
+
+        settings.selectDisplayedCodexVisibleAccount(displayedAccount)
+
+        #expect(probe.callCount == 0)
+        #expect(settings.codexActiveSource == .managedAccount(id: secondID))
+        #expect(settings.cachedCodexAccountMenuProjection == nil)
+    }
+}
+
+private final class CodexAccountSnapshotLoaderProbe: @unchecked Sendable {
+    private let lock = NSLock()
+    private let snapshot: CodexAccountReconciliationSnapshot
+    private let blocks: Bool
+    private let releaseSemaphore = DispatchSemaphore(value: 0)
+    private var _callCount = 0
+    private var _loadedOffMainThread = false
+    private var released = false
+
+    init(snapshot: CodexAccountReconciliationSnapshot, blocks: Bool = false) {
+        self.snapshot = snapshot
+        self.blocks = blocks
+    }
+
+    var callCount: Int {
+        self.lock.withLock { self._callCount }
+    }
+
+    var loadedOffMainThread: Bool {
+        self.lock.withLock { self._loadedOffMainThread }
+    }
+
+    func load() -> CodexAccountReconciliationSnapshot {
+        self.lock.withLock {
+            self._callCount += 1
+            self._loadedOffMainThread = self._loadedOffMainThread || !Thread.isMainThread
+        }
+        if self.blocks {
+            self.releaseSemaphore.wait()
+        }
+        return self.snapshot
+    }
+
+    func waitUntilCalled() async {
+        while self.callCount == 0 {
+            await Task.yield()
+        }
+    }
+
+    func release() {
+        let shouldSignal = self.lock.withLock {
+            guard !self.released else { return false }
+            self.released = true
+            return true
+        }
+        if shouldSignal {
+            self.releaseSemaphore.signal()
+        }
+    }
+}
diff --git a/Tests/CodexBarTests/CodexAccountPromotionExecutionTests.swift b/Tests/CodexBarTests/CodexAccountPromotionExecutionTests.swift
new file mode 100644
index 0000000000..049635485c
--- /dev/null
+++ b/Tests/CodexBarTests/CodexAccountPromotionExecutionTests.swift
@@ -0,0 +1,310 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@Suite(.serialized)
+@MainActor
+struct CodexAccountPromotionExecutionTests {
+    @Test
+    func `executor import store failure cleans up imported home and maps managed store error`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionExecutionTests-import-cleanup")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "beta@example.com",
+            authAccountID: "acct-beta")
+        try container.persistAccounts([target])
+        _ = try container.writeLiveOAuthAuthFile(email: "alpha@example.com", accountID: "acct-alpha")
+        let context = try await self.makeContext(container: container, targetID: target.id)
+        let executor = CodexDisplacedLivePreservationExecutor(
+            store: RecordingManagedCodexAccountStore(base: container.fileStore) { _ in
+                throw PromotionTestError.storeWriteFailed
+            },
+            homeFactory: container.homeFactory,
+            fileManager: .default)
+
+        #expect(throws: CodexAccountPromotionError.managedStoreCommitFailed) {
+            try executor.execute(plan: .importNew(reason: .noExistingManagedDestination), context: context)
+        }
+
+        #expect(try container.managedHomeURLs().count == 1)
+        #expect(try container.loadAccounts().accounts.count == 1)
+    }
+
+    @Test
+    func `executor refresh failure leaves live auth untouched and keeps copied managed auth`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionExecutionTests-refresh-failure")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "beta@example.com",
+            authAccountID: "acct-beta")
+        let existingManagedLive = try container.createManagedAccount(
+            persistedEmail: "alpha@example.com",
+            authAccountID: "acct-alpha")
+        try container.persistAccounts([target, existingManagedLive])
+        let originalManagedAuthData = try container.managedAuthData(for: existingManagedLive)
+        let liveAuthData = try container.writeLiveOAuthAuthFile(
+            email: "alpha@example.com",
+            accountID: "acct-alpha",
+            apiKey: "sk-refreshed-live")
+        let originalLiveAuthData = try #require(try container.liveAuthData())
+        let context = try await self.makeContext(container: container, targetID: target.id)
+        let plan = CodexDisplacedLivePreservationPlanner().makePlan(context: context)
+        let executor = CodexDisplacedLivePreservationExecutor(
+            store: RecordingManagedCodexAccountStore(base: container.fileStore) { accounts in
+                if accounts.account(id: existingManagedLive.id)?
+                    .lastAuthenticatedAt != existingManagedLive.lastAuthenticatedAt
+                {
+                    throw PromotionTestError.storeWriteFailed
+                }
+            },
+            homeFactory: container.homeFactory,
+            fileManager: .default)
+
+        #expect(throws: CodexAccountPromotionError.managedStoreCommitFailed) {
+            try executor.execute(plan: plan, context: context)
+        }
+
+        let accounts = try container.loadAccounts().accounts
+        let persistedManagedLive = try #require(accounts.first(where: { $0.id == existingManagedLive.id }))
+        #expect(try container.liveAuthData() == originalLiveAuthData)
+        #expect(try container.managedAuthData(for: persistedManagedLive) != originalManagedAuthData)
+        #expect(try container.managedAuthData(for: persistedManagedLive) == liveAuthData)
+    }
+
+    @Test
+    func `executor import verifies persisted account after concurrent duplicate collision`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionExecutionTests-import-collision-repair")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "beta@example.com",
+            authAccountID: "acct-beta")
+        let concurrentID = UUID()
+        let concurrentHomeURL = container.managedHomesURL.appendingPathComponent(
+            concurrentID.uuidString,
+            isDirectory: true)
+        try FileManager.default.createDirectory(at: concurrentHomeURL, withIntermediateDirectories: true)
+        let concurrentManaged = ManagedCodexAccount(
+            id: concurrentID,
+            email: "alpha@example.com",
+            providerAccountID: "acct-alpha",
+            workspaceLabel: "Personal",
+            workspaceAccountID: "acct-alpha",
+            managedHomePath: concurrentHomeURL.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        try container.persistAccounts([target])
+        let liveAuthData = try container.writeLiveOAuthAuthFile(email: "alpha@example.com", accountID: "acct-alpha")
+        let context = try await self.makeContext(container: container, targetID: target.id)
+        let executor = CodexDisplacedLivePreservationExecutor(
+            store: ConcurrentDuplicateManagedCodexAccountStore(
+                base: container.fileStore,
+                concurrentAccount: concurrentManaged),
+            homeFactory: container.homeFactory,
+            fileManager: .default)
+
+        let result = try executor.execute(plan: .importNew(reason: .noExistingManagedDestination), context: context)
+
+        #expect(result.displacedLiveDisposition == .alreadyManaged(managedAccountID: concurrentManaged.id))
+        let accounts = try container.loadAccounts().accounts
+        let repaired = try #require(accounts.first(where: { $0.id == concurrentManaged.id }))
+        #expect(repaired.managedHomePath != concurrentHomeURL.path)
+        #expect(try container.managedAuthData(for: repaired) == liveAuthData)
+    }
+
+    @Test
+    func `executor refresh filesystem failure maps to managed store error`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionExecutionTests-refresh-filesystem-failure")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "beta@example.com",
+            authAccountID: "acct-beta")
+        let existingManagedLive = try container.createManagedAccount(
+            persistedEmail: "alpha@example.com",
+            authAccountID: "acct-alpha")
+        try container.persistAccounts([target, existingManagedLive])
+        _ = try container.writeLiveOAuthAuthFile(email: "alpha@example.com", accountID: "acct-alpha")
+        let context = try await self.makeContext(container: container, targetID: target.id)
+        let plan = CodexDisplacedLivePreservationPlanner().makePlan(context: context)
+
+        let managedHomeURL = URL(fileURLWithPath: existingManagedLive.managedHomePath, isDirectory: true)
+        try FileManager.default.removeItem(at: managedHomeURL)
+        try Data("blocked".utf8).write(to: managedHomeURL)
+
+        let executor = CodexDisplacedLivePreservationExecutor(
+            store: container.fileStore,
+            homeFactory: container.homeFactory,
+            fileManager: .default)
+
+        #expect(throws: CodexAccountPromotionError.managedStoreCommitFailed) {
+            try executor.execute(plan: plan, context: context)
+        }
+    }
+
+    @Test
+    func `executor legacy import repair ignores provider backed rows with the same email`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionExecutionTests-legacy-import-provider-same-email")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "beta@example.com",
+            authAccountID: "acct-beta")
+        let providerManaged = try container.createManagedAccount(
+            persistedEmail: "alpha@example.com",
+            authAccountID: "acct-existing")
+        try container.persistAccounts([target, providerManaged])
+        _ = try container.writeLiveOAuthAuthFile(email: "alpha@example.com")
+        let context = try await self.makeContext(container: container, targetID: target.id)
+        let originalProviderManaged = try #require(try container.loadAccounts().account(id: providerManaged.id))
+
+        let executor = CodexDisplacedLivePreservationExecutor(
+            store: DroppingLegacyImportedAccountStore(
+                base: container.fileStore,
+                preservedProviderBackedAccount: originalProviderManaged),
+            homeFactory: container.homeFactory,
+            fileManager: .default)
+
+        #expect(throws: CodexAccountPromotionError.managedStoreCommitFailed) {
+            try executor.execute(plan: .importNew(reason: .noExistingManagedDestination), context: context)
+        }
+
+        let persistedProviderManaged = try #require(try container.loadAccounts().account(id: providerManaged.id))
+        #expect(persistedProviderManaged.providerAccountID == originalProviderManaged.providerAccountID)
+        #expect(persistedProviderManaged.managedHomePath == originalProviderManaged.managedHomePath)
+    }
+
+    @Test
+    func `executor reject preserves stable error mapping`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionExecutionTests-reject-mapping")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "beta@example.com",
+            authAccountID: "acct-beta")
+        try container.persistAccounts([target])
+        let context = try await self.makeContext(container: container, targetID: target.id)
+        let executor = CodexDisplacedLivePreservationExecutor(
+            store: container.fileStore,
+            homeFactory: container.homeFactory,
+            fileManager: .default)
+
+        #expect(throws: CodexAccountPromotionError.liveAccountAPIKeyOnlyUnsupported) {
+            try executor.execute(plan: .reject(reason: .liveAPIKeyOnlyUnsupported), context: context)
+        }
+        #expect(throws: CodexAccountPromotionError.liveAccountUnreadable) {
+            try executor.execute(plan: .reject(reason: .liveUnreadable), context: context)
+        }
+        #expect(throws: CodexAccountPromotionError.liveAccountMissingIdentityForPreservation) {
+            try executor.execute(plan: .reject(reason: .liveIdentityMissingForPreservation), context: context)
+        }
+    }
+
+    @Test
+    func `executor rejects target as preservation destination`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionExecutionTests-target-destination")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "beta@example.com",
+            authAccountID: "acct-beta")
+        try container.persistAccounts([target])
+        _ = try container.writeLiveOAuthAuthFile(email: "alpha@example.com", accountID: "acct-alpha")
+        let context = try await self.makeContext(container: container, targetID: target.id)
+        let executor = CodexDisplacedLivePreservationExecutor(
+            store: container.fileStore,
+            homeFactory: container.homeFactory,
+            fileManager: .default)
+
+        #expect(throws: CodexAccountPromotionError.managedStoreCommitFailed) {
+            try executor.execute(
+                plan: .refreshExisting(
+                    destination: context.target,
+                    reason: .readableHomeIdentityMatch),
+                context: context)
+        }
+    }
+
+    private func makeContext(
+        container: CodexAccountPromotionTestContainer,
+        targetID: UUID)
+        async throws -> PreparedPromotionContext
+    {
+        let builder = PreparedPromotionContextBuilder(
+            store: container.fileStore,
+            workspaceResolver: container.workspaceResolver,
+            snapshotLoader: SettingsStoreCodexAccountReconciliationSnapshotLoader(settingsStore: container.settings),
+            authMaterialReader: DefaultCodexAuthMaterialReader(),
+            baseEnvironment: container.baseEnvironment,
+            fileManager: .default)
+        return try await builder.build(targetID: targetID)
+    }
+}
+
+private final class ConcurrentDuplicateManagedCodexAccountStore: ManagedCodexAccountStoring, @unchecked Sendable {
+    let base: any ManagedCodexAccountStoring
+    let concurrentAccount: ManagedCodexAccount
+    private var didInjectConcurrentAccount = false
+
+    init(base: any ManagedCodexAccountStoring, concurrentAccount: ManagedCodexAccount) {
+        self.base = base
+        self.concurrentAccount = concurrentAccount
+    }
+
+    func loadAccounts() throws -> ManagedCodexAccountSet {
+        if self.didInjectConcurrentAccount == false {
+            self.didInjectConcurrentAccount = true
+            let current = try self.base.loadAccounts()
+            try self.base.storeAccounts(ManagedCodexAccountSet(
+                version: current.version,
+                accounts: current.accounts + [self.concurrentAccount]))
+        }
+        return try self.base.loadAccounts()
+    }
+
+    func storeAccounts(_ accounts: ManagedCodexAccountSet) throws {
+        try self.base.storeAccounts(accounts)
+    }
+
+    func ensureFileExists() throws -> URL {
+        try self.base.ensureFileExists()
+    }
+}
+
+private final class DroppingLegacyImportedAccountStore: ManagedCodexAccountStoring, @unchecked Sendable {
+    let base: any ManagedCodexAccountStoring
+    let preservedProviderBackedAccount: ManagedCodexAccount
+
+    init(base: any ManagedCodexAccountStoring, preservedProviderBackedAccount: ManagedCodexAccount) {
+        self.base = base
+        self.preservedProviderBackedAccount = preservedProviderBackedAccount
+    }
+
+    func loadAccounts() throws -> ManagedCodexAccountSet {
+        try self.base.loadAccounts()
+    }
+
+    func storeAccounts(_ accounts: ManagedCodexAccountSet) throws {
+        let filteredAccounts = accounts.accounts.filter {
+            $0.id == self.preservedProviderBackedAccount.id || $0.providerAccountID != nil
+        }
+        try self.base.storeAccounts(ManagedCodexAccountSet(
+            version: accounts.version,
+            accounts: filteredAccounts))
+    }
+
+    func ensureFileExists() throws -> URL {
+        try self.base.ensureFileExists()
+    }
+}
diff --git a/Tests/CodexBarTests/CodexAccountPromotionPlanningTests.swift b/Tests/CodexBarTests/CodexAccountPromotionPlanningTests.swift
new file mode 100644
index 0000000000..f731d69d10
--- /dev/null
+++ b/Tests/CodexBarTests/CodexAccountPromotionPlanningTests.swift
@@ -0,0 +1,227 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@Suite(.serialized)
+@MainActor
+struct CodexAccountPromotionPlanningTests {
+    @Test
+    func `planner converges from direct auth identities without snapshot help`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionPlanningTests-converges")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "alpha@example.com",
+            authAccountID: "acct-alpha")
+        try container.persistAccounts([target])
+        _ = try container.writeLiveOAuthAuthFileWithoutEmail(accountID: "acct-alpha")
+
+        let context = try await self.makeContext(container: container, targetID: target.id)
+        let plan = CodexDisplacedLivePreservationPlanner().makePlan(context: context)
+
+        switch plan {
+        case let .none(reason):
+            #expect(reason == .targetMatchesLiveAuthIdentity)
+        case .reject, .importNew, .refreshExisting, .repairExisting:
+            Issue.record("Expected convergence plan")
+        }
+    }
+
+    @Test
+    func `planner refreshes already managed account when readable home identity matches live`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionPlanningTests-refresh")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "beta@example.com",
+            authAccountID: "acct-beta")
+        let existingManagedLive = try container.createManagedAccount(
+            persistedEmail: "legacy@example.com",
+            authEmail: "alpha@example.com",
+            authAccountID: "acct-alpha",
+            persistedProviderAccountID: nil)
+        try container.persistAccounts([target, existingManagedLive])
+        _ = try container.writeLiveOAuthAuthFile(email: "alpha@example.com", accountID: "acct-alpha")
+
+        let context = try await self.makeContext(container: container, targetID: target.id)
+        let plan = CodexDisplacedLivePreservationPlanner().makePlan(context: context)
+
+        switch plan {
+        case let .refreshExisting(destination, reason):
+            #expect(destination.persisted.id == existingManagedLive.id)
+            #expect(reason == .readableHomeIdentityMatch)
+        case .none, .reject, .importNew, .repairExisting:
+            Issue.record("Expected refresh plan")
+        }
+    }
+
+    @Test
+    func `planner uses repair for persisted provider match before any import fallback`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionPlanningTests-repair-before-import")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "beta@example.com",
+            authAccountID: "acct-beta")
+        let staleManaged = ManagedCodexAccount(
+            id: UUID(),
+            email: "alpha@example.com",
+            providerAccountID: "acct-alpha",
+            workspaceLabel: "Personal",
+            workspaceAccountID: "acct-alpha",
+            managedHomePath: container.managedHomesURL
+                .appendingPathComponent(UUID().uuidString, isDirectory: true).path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        try container.persistAccounts([target, staleManaged])
+        _ = try container.writeLiveOAuthAuthFile(email: "alpha@example.com", accountID: "acct-alpha")
+
+        let context = try await self.makeContext(container: container, targetID: target.id)
+        let plan = CodexDisplacedLivePreservationPlanner().makePlan(context: context)
+
+        switch plan {
+        case let .repairExisting(destination, reason):
+            #expect(destination.persisted.id == staleManaged.id)
+            #expect(reason == .persistedProviderMatchWithMissingHome)
+        case .none, .reject, .importNew, .refreshExisting:
+            Issue.record("Expected repair plan")
+        }
+    }
+
+    @Test
+    func `planner rejects persisted provider match when readable home belongs to a different account`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionPlanningTests-conflicting-readable-home")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "beta@example.com",
+            authAccountID: "acct-beta")
+        let conflictingManaged = try container.createManagedAccount(
+            persistedEmail: "alpha@example.com",
+            authEmail: "gamma@example.com",
+            authAccountID: "acct-gamma",
+            persistedProviderAccountID: "acct-alpha",
+            useAuthAccountIDAsPersistedProviderAccountID: false)
+        try container.persistAccounts([target, conflictingManaged])
+        _ = try container.writeLiveOAuthAuthFile(email: "alpha@example.com", accountID: "acct-alpha")
+
+        let context = try await self.makeContext(container: container, targetID: target.id)
+        let plan = CodexDisplacedLivePreservationPlanner().makePlan(context: context)
+
+        switch plan {
+        case let .reject(reason):
+            #expect(reason == .conflictingReadableManagedHome)
+        case .none, .importNew, .refreshExisting, .repairExisting:
+            Issue.record("Expected reject plan")
+        }
+    }
+
+    @Test
+    func `planner uses legacy email repair instead of import when provider account upgrades old record`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionPlanningTests-legacy-repair")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "beta@example.com",
+            authAccountID: "acct-beta")
+        let legacyManaged = ManagedCodexAccount(
+            id: UUID(),
+            email: "alpha@example.com",
+            providerAccountID: nil,
+            workspaceLabel: nil,
+            workspaceAccountID: nil,
+            managedHomePath: container.managedHomesURL
+                .appendingPathComponent(UUID().uuidString, isDirectory: true).path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: nil)
+        try container.persistAccounts([target, legacyManaged])
+        _ = try container.writeLiveOAuthAuthFile(email: "alpha@example.com", accountID: "acct-alpha")
+
+        let context = try await self.makeContext(container: container, targetID: target.id)
+        let plan = CodexDisplacedLivePreservationPlanner().makePlan(context: context)
+
+        switch plan {
+        case let .repairExisting(destination, reason):
+            #expect(destination.persisted.id == legacyManaged.id)
+            #expect(reason == .persistedLegacyEmailMatch)
+        case .none, .reject, .importNew, .refreshExisting:
+            Issue.record("Expected legacy email repair plan")
+        }
+    }
+
+    @Test
+    func `planner imports when same email belongs to a different provider account workspace`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionPlanningTests-import",
+            workspaceIdentities: [
+                "acct-personal": CodexOpenAIWorkspaceIdentity(
+                    workspaceAccountID: "acct-personal",
+                    workspaceLabel: "Personal"),
+            ])
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "alice@example.com",
+            authAccountID: "acct-team",
+            workspaceLabel: "Team",
+            workspaceAccountID: "acct-team")
+        try container.persistAccounts([target])
+        _ = try container.writeLiveOAuthAuthFile(email: "alice@example.com", accountID: "acct-personal")
+
+        let context = try await self.makeContext(container: container, targetID: target.id)
+        let plan = CodexDisplacedLivePreservationPlanner().makePlan(context: context)
+
+        switch plan {
+        case let .importNew(reason):
+            #expect(reason == .noExistingManagedDestination)
+        case .none, .reject, .refreshExisting, .repairExisting:
+            Issue.record("Expected import plan")
+        }
+    }
+
+    @Test
+    func `planner rejects api key only live auth`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionPlanningTests-api-key")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "beta@example.com",
+            authAccountID: "acct-beta")
+        try container.persistAccounts([target])
+        _ = try container.writeLiveAPIKeyAuthFile()
+
+        let context = try await self.makeContext(container: container, targetID: target.id)
+        let plan = CodexDisplacedLivePreservationPlanner().makePlan(context: context)
+
+        switch plan {
+        case let .reject(reason):
+            #expect(reason == .liveAPIKeyOnlyUnsupported)
+        case .none, .importNew, .refreshExisting, .repairExisting:
+            Issue.record("Expected reject plan")
+        }
+    }
+
+    private func makeContext(
+        container: CodexAccountPromotionTestContainer,
+        targetID: UUID)
+        async throws -> PreparedPromotionContext
+    {
+        let builder = PreparedPromotionContextBuilder(
+            store: container.fileStore,
+            workspaceResolver: container.workspaceResolver,
+            snapshotLoader: SettingsStoreCodexAccountReconciliationSnapshotLoader(settingsStore: container.settings),
+            authMaterialReader: DefaultCodexAuthMaterialReader(),
+            baseEnvironment: container.baseEnvironment,
+            fileManager: .default)
+        return try await builder.build(targetID: targetID)
+    }
+}
diff --git a/Tests/CodexBarTests/CodexAccountPromotionPreparationTests.swift b/Tests/CodexBarTests/CodexAccountPromotionPreparationTests.swift
new file mode 100644
index 0000000000..f32cb1dd39
--- /dev/null
+++ b/Tests/CodexBarTests/CodexAccountPromotionPreparationTests.swift
@@ -0,0 +1,118 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@Suite(.serialized)
+@MainActor
+struct CodexAccountPromotionPreparationTests {
+    @Test
+    func `builder carries direct auth identities for target and live`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionPreparationTests-direct-identities",
+            workspaceIdentities: [
+                "acct-alpha": CodexOpenAIWorkspaceIdentity(
+                    workspaceAccountID: "acct-alpha",
+                    workspaceLabel: "Personal"),
+                "acct-beta": CodexOpenAIWorkspaceIdentity(
+                    workspaceAccountID: "acct-beta",
+                    workspaceLabel: "Team"),
+            ])
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "beta@example.com",
+            authAccountID: "acct-beta")
+        try container.persistAccounts([target])
+        _ = try container.writeLiveOAuthAuthFile(email: "alpha@example.com", accountID: "acct-alpha")
+
+        let builder = PreparedPromotionContextBuilder(
+            store: container.fileStore,
+            workspaceResolver: container.workspaceResolver,
+            snapshotLoader: SettingsStoreCodexAccountReconciliationSnapshotLoader(settingsStore: container.settings),
+            authMaterialReader: DefaultCodexAuthMaterialReader(),
+            baseEnvironment: container.baseEnvironment,
+            fileManager: .default)
+
+        let context = try await builder.build(targetID: target.id)
+
+        #expect(context.target.authIdentity?.identity == .providerAccount(id: "acct-beta"))
+        #expect(context.target.authIdentity?.workspaceLabel == "Team")
+        #expect(context.live.authIdentity?.identity == .providerAccount(id: "acct-alpha"))
+        #expect(context.live.authIdentity?.workspaceLabel == "Personal")
+    }
+
+    @Test
+    func `builder preserves target missing auth as degraded home state`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionPreparationTests-target-missing-auth")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "beta@example.com",
+            authAccountID: "acct-beta")
+        try container.persistAccounts([target])
+        try FileManager.default.removeItem(
+            at: URL(fileURLWithPath: target.managedHomePath, isDirectory: true)
+                .appendingPathComponent("auth.json", isDirectory: false))
+
+        let builder = PreparedPromotionContextBuilder(
+            store: container.fileStore,
+            workspaceResolver: container.workspaceResolver,
+            snapshotLoader: SettingsStoreCodexAccountReconciliationSnapshotLoader(settingsStore: container.settings),
+            authMaterialReader: DefaultCodexAuthMaterialReader(),
+            baseEnvironment: container.baseEnvironment,
+            fileManager: .default)
+
+        let context = try await builder.build(targetID: target.id)
+
+        switch context.target.homeState {
+        case let .missing(homeURL):
+            #expect(homeURL.path == target.managedHomePath)
+        case .readable, .unreadable:
+            Issue.record("Expected target auth to be represented as missing")
+        }
+        #expect(context.target.authIdentity == nil)
+        #expect(context.target.persistedIdentity.identity == .providerAccount(id: "acct-beta"))
+    }
+
+    @Test
+    func `builder keeps persisted and direct home identity views separate`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionPreparationTests-persisted-vs-direct",
+            workspaceIdentities: [
+                "acct-alpha": CodexOpenAIWorkspaceIdentity(
+                    workspaceAccountID: "acct-alpha",
+                    workspaceLabel: "Personal"),
+            ])
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "beta@example.com",
+            authAccountID: "acct-beta")
+        let legacy = try container.createManagedAccount(
+            persistedEmail: "legacy@example.com",
+            authEmail: "alpha@example.com",
+            authAccountID: "acct-alpha",
+            persistedProviderAccountID: nil,
+            useAuthAccountIDAsPersistedProviderAccountID: false)
+        try container.persistAccounts([target, legacy])
+
+        let builder = PreparedPromotionContextBuilder(
+            store: container.fileStore,
+            workspaceResolver: container.workspaceResolver,
+            snapshotLoader: SettingsStoreCodexAccountReconciliationSnapshotLoader(settingsStore: container.settings),
+            authMaterialReader: DefaultCodexAuthMaterialReader(),
+            baseEnvironment: container.baseEnvironment,
+            fileManager: .default)
+
+        let context = try await builder.build(targetID: target.id)
+        let preparedLegacy = try #require(context.storedManagedAccounts.first(where: { $0.persisted.id == legacy.id }))
+
+        #expect(preparedLegacy.persistedIdentity.email == "legacy@example.com")
+        #expect(preparedLegacy.persistedIdentity.identity == .emailOnly(normalizedEmail: "legacy@example.com"))
+        #expect(preparedLegacy.authIdentity?.email == "alpha@example.com")
+        #expect(preparedLegacy.authIdentity?.identity == .providerAccount(id: "acct-alpha"))
+        #expect(preparedLegacy.authIdentity?.workspaceLabel == "Personal")
+    }
+}
diff --git a/Tests/CodexBarTests/CodexAccountPromotionServiceTests.swift b/Tests/CodexBarTests/CodexAccountPromotionServiceTests.swift
new file mode 100644
index 0000000000..cfa3869068
--- /dev/null
+++ b/Tests/CodexBarTests/CodexAccountPromotionServiceTests.swift
@@ -0,0 +1,734 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@Suite(.serialized)
+@MainActor
+struct CodexAccountPromotionServiceTests {
+    @Test
+    func `happy path promotion swaps target auth into live home`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionServiceTests-happy-path")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "beta@example.com",
+            authAccountID: "acct-beta")
+        try container.persistAccounts([target])
+        container.settings.codexActiveSource = .managedAccount(id: target.id)
+        try container.removeLiveAuthFile()
+
+        let targetAuthData = try container.managedAuthData(for: target)
+        let result = try await container.makeService().promoteManagedAccount(id: target.id)
+        let accounts = try container.loadAccounts().accounts
+
+        #expect(result.targetManagedAccountID == target.id)
+        #expect(result.outcome == .promoted)
+        #expect(result.displacedLiveDisposition == .none)
+        #expect(result.didMutateLiveAuth)
+        #expect(result.resultingActiveSource == .liveSystem)
+        #expect(try container.liveAuthData() == targetAuthData)
+        #expect(accounts.count == 1)
+        #expect(accounts.first?.id == target.id)
+        #expect(container.settings.codexActiveSource == .liveSystem)
+        #expect(container.usageStore.snapshots[.codex]?.accountEmail(for: .codex) == "beta@example.com")
+    }
+
+    @Test
+    func `displaced live oauth is imported before target auth is promoted`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionServiceTests-displaced-import",
+            workspaceIdentities: [
+                "acct-alpha": CodexOpenAIWorkspaceIdentity(
+                    workspaceAccountID: "acct-alpha",
+                    workspaceLabel: "Personal"),
+            ])
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "beta@example.com",
+            authAccountID: "acct-beta")
+        try container.persistAccounts([target])
+        container.settings.codexActiveSource = .managedAccount(id: target.id)
+        let displacedLiveAuthData = try container.writeLiveOAuthAuthFile(
+            email: "alpha@example.com",
+            accountID: "acct-alpha")
+
+        let result = try await container.makeService().promoteManagedAccount(id: target.id)
+        let accounts = try container.loadAccounts().accounts
+        let importedID: UUID
+        switch result.displacedLiveDisposition {
+        case let .imported(managedAccountID):
+            importedID = managedAccountID
+        case .none, .alreadyManaged:
+            Issue.record("Expected displaced live account import")
+            throw PromotionTestError.unexpectedDisposition
+        }
+        let imported = try #require(accounts.first(where: { $0.id == importedID }))
+
+        #expect(accounts.count == 2)
+        #expect(imported.email == "alpha@example.com")
+        #expect(imported.providerAccountID == "acct-alpha")
+        #expect(imported.workspaceLabel == "Personal")
+        #expect(imported.workspaceAccountID == "acct-alpha")
+        #expect(imported.authFingerprint == CodexAuthFingerprint.fingerprint(data: displacedLiveAuthData))
+        #expect(try container.managedAuthData(for: imported) == displacedLiveAuthData)
+        #expect(try container.liveAuthData() == container.managedAuthData(for: target))
+    }
+
+    @Test
+    func `displaced live already managed uses reconciliation identity dedupe`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionServiceTests-already-managed")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "beta@example.com",
+            authAccountID: "acct-beta")
+        let existingManagedLive = try container.createManagedAccount(
+            persistedEmail: "legacy@example.com",
+            authEmail: "alpha@example.com",
+            authAccountID: "acct-alpha",
+            persistedProviderAccountID: nil)
+        try container.persistAccounts([target, existingManagedLive])
+        let liveAuthData = try container.writeLiveOAuthAuthFile(
+            email: "alpha@example.com",
+            accountID: "acct-alpha",
+            apiKey: "sk-fresh-live")
+
+        let result = try await container.makeService().promoteManagedAccount(id: target.id)
+        let accounts = try container.loadAccounts().accounts
+        let refreshedManagedLive = try #require(accounts.first(where: { $0.id == existingManagedLive.id }))
+
+        #expect(result.displacedLiveDisposition == .alreadyManaged(managedAccountID: existingManagedLive.id))
+        #expect(accounts.count == 2)
+        #expect(accounts.contains(where: { $0.id == existingManagedLive.id }))
+        #expect(refreshedManagedLive.authFingerprint == CodexAuthFingerprint.fingerprint(data: liveAuthData))
+        #expect(try container.managedAuthData(for: refreshedManagedLive) == liveAuthData)
+        #expect(try container.liveAuthData() == container.managedAuthData(for: target))
+    }
+
+    @Test
+    func `provider only live auth refreshes existing managed account using persisted email`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionServiceTests-already-managed-no-email")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "beta@example.com",
+            authAccountID: "acct-beta")
+        let existingManagedLive = try container.createManagedAccount(
+            persistedEmail: "alpha@example.com",
+            authAccountID: "acct-alpha")
+        try container.persistAccounts([target, existingManagedLive])
+        let liveAuthData = try container.writeLiveOAuthAuthFileWithoutEmail(accountID: "acct-alpha")
+
+        let result = try await container.makeService().promoteManagedAccount(id: target.id)
+        let accounts = try container.loadAccounts().accounts
+        let refreshedManagedLive = try #require(accounts.first(where: { $0.id == existingManagedLive.id }))
+
+        #expect(result.displacedLiveDisposition == .alreadyManaged(managedAccountID: existingManagedLive.id))
+        #expect(refreshedManagedLive.email == "alpha@example.com")
+        #expect(refreshedManagedLive.providerAccountID == "acct-alpha")
+        #expect(refreshedManagedLive.authFingerprint == CodexAuthFingerprint.fingerprint(data: liveAuthData))
+        #expect(try container.managedAuthData(for: refreshedManagedLive) == liveAuthData)
+    }
+
+    @Test
+    func `provider only live auth matching target converges and keeps managed active source`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionServiceTests-provider-only-convergence")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "alpha@example.com",
+            authAccountID: "acct-alpha")
+        try container.persistAccounts([target])
+        let liveAuthData = try container.writeLiveOAuthAuthFileWithoutEmail(accountID: "acct-alpha")
+        container.settings.codexActiveSource = .managedAccount(id: target.id)
+
+        let result = try await container.makeService().promoteManagedAccount(id: target.id)
+
+        #expect(result.outcome == .convergedNoOp)
+        #expect(result.displacedLiveDisposition == .none)
+        #expect(result.didMutateLiveAuth == false)
+        #expect(result.resultingActiveSource == .managedAccount(id: target.id))
+        #expect(try container.liveAuthData() == liveAuthData)
+        #expect(try container.loadAccounts().accounts.count == 1)
+        #expect(container.settings.codexActiveSource == .managedAccount(id: target.id))
+    }
+
+    @Test
+    func `provider only live auth matching target converges when target managed auth is missing`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionServiceTests-provider-only-convergence-missing-target-auth")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "alpha@example.com",
+            authAccountID: "acct-alpha")
+        try container.persistAccounts([target])
+        container.settings.codexActiveSource = .managedAccount(id: target.id)
+        try FileManager.default.removeItem(
+            at: URL(fileURLWithPath: target.managedHomePath, isDirectory: true)
+                .appendingPathComponent("auth.json", isDirectory: false))
+        let liveAuthData = try container.writeLiveOAuthAuthFileWithoutEmail(accountID: "acct-alpha")
+
+        let result = try await container.makeService().promoteManagedAccount(id: target.id)
+
+        #expect(result.outcome == .convergedNoOp)
+        #expect(result.displacedLiveDisposition == .none)
+        #expect(result.didMutateLiveAuth == false)
+        #expect(result.resultingActiveSource == .managedAccount(id: target.id))
+        #expect(try container.liveAuthData() == liveAuthData)
+        #expect(container.settings.codexActiveSource == .managedAccount(id: target.id))
+    }
+
+    @Test
+    func `snapshot convergence no op does not require target managed auth file`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionServiceTests-snapshot-convergence-with-missing-target-auth")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "alpha@example.com",
+            authAccountID: "acct-alpha")
+        try container.persistAccounts([target])
+        try FileManager.default.removeItem(
+            at: URL(fileURLWithPath: target.managedHomePath, isDirectory: true)
+                .appendingPathComponent("auth.json", isDirectory: false))
+        container.settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "alpha@example.com",
+            codexHomePath: container.liveHomeURL.path,
+            observedAt: Date(),
+            identity: .emailOnly(normalizedEmail: "alpha@example.com"))
+        let liveAuthData = try container.writeLiveOAuthAuthFile(
+            email: "alpha@example.com",
+            accountID: "acct-alpha")
+
+        let result = try await container.makeService().promoteManagedAccount(id: target.id)
+
+        #expect(result.outcome == .convergedNoOp)
+        #expect(result.displacedLiveDisposition == .none)
+        #expect(result.didMutateLiveAuth == false)
+        #expect(try container.liveAuthData() == liveAuthData)
+    }
+
+    @Test
+    func `convergence no-op does not rewrite live auth or import displaced live`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionServiceTests-convergence")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "alpha@example.com",
+            authAccountID: "acct-alpha")
+        try container.persistAccounts([target])
+        let liveAuthData = try container.writeLiveOAuthAuthFile(
+            email: "alpha@example.com",
+            accountID: "acct-alpha")
+
+        let result = try await container.makeService().promoteManagedAccount(id: target.id)
+
+        #expect(result.outcome == .convergedNoOp)
+        #expect(result.displacedLiveDisposition == .none)
+        #expect(result.didMutateLiveAuth == false)
+        #expect(try container.liveAuthData() == liveAuthData)
+        #expect(try container.loadAccounts().accounts.count == 1)
+        #expect(container.settings.codexActiveSource == .liveSystem)
+    }
+
+    @Test
+    func `same email different workspace imports displaced live as a distinct managed account`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionServiceTests-same-email-different-workspace",
+            workspaceIdentities: [
+                "acct-personal": CodexOpenAIWorkspaceIdentity(
+                    workspaceAccountID: "acct-personal",
+                    workspaceLabel: "Personal"),
+            ])
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "alice@example.com",
+            authAccountID: "acct-team",
+            workspaceLabel: "Team",
+            workspaceAccountID: "acct-team")
+        try container.persistAccounts([target])
+        _ = try container.writeLiveOAuthAuthFile(email: "alice@example.com", accountID: "acct-personal")
+
+        let result = try await container.makeService().promoteManagedAccount(id: target.id)
+        let importedID: UUID
+        switch result.displacedLiveDisposition {
+        case let .imported(managedAccountID):
+            importedID = managedAccountID
+        case .none, .alreadyManaged:
+            Issue.record("Expected same-email different-workspace import")
+            throw PromotionTestError.unexpectedDisposition
+        }
+        let accounts = try container.loadAccounts().accounts
+        let imported = try #require(accounts.first(where: { $0.id == importedID }))
+
+        #expect(accounts.count == 2)
+        #expect(imported.id != target.id)
+        #expect(imported.email == "alice@example.com")
+        #expect(imported.providerAccountID == "acct-personal")
+        #expect(imported.workspaceLabel == "Personal")
+        #expect(imported.workspaceAccountID == "acct-personal")
+    }
+
+    @Test
+    func `mixed api key and oauth live auth still preserves displaced live identity`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionServiceTests-mixed-auth-preservation",
+            workspaceIdentities: [
+                "acct-alpha": CodexOpenAIWorkspaceIdentity(
+                    workspaceAccountID: "acct-alpha",
+                    workspaceLabel: "Personal"),
+            ])
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "beta@example.com",
+            authAccountID: "acct-beta")
+        try container.persistAccounts([target])
+        _ = try container.writeLiveOAuthAuthFile(
+            email: "alpha@example.com",
+            accountID: "acct-alpha",
+            apiKey: "sk-mixed-live")
+
+        let result = try await container.makeService().promoteManagedAccount(id: target.id)
+        let importedID: UUID
+        switch result.displacedLiveDisposition {
+        case let .imported(managedAccountID):
+            importedID = managedAccountID
+        case .none, .alreadyManaged:
+            Issue.record("Expected displaced live import for mixed auth material")
+            throw PromotionTestError.unexpectedDisposition
+        }
+        let imported = try #require(try container.loadAccounts().accounts.first(where: { $0.id == importedID }))
+
+        #expect(imported.email == "alpha@example.com")
+        #expect(imported.providerAccountID == "acct-alpha")
+        #expect(imported.workspaceLabel == "Personal")
+    }
+
+    @Test
+    func `store commit failure leaves live auth untouched because promotion preserves before mutating`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionServiceTests-store-failure")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "beta@example.com",
+            authAccountID: "acct-beta")
+        try container.persistAccounts([target])
+        let liveAuthData = try container.writeLiveOAuthAuthFile(
+            email: "alpha@example.com",
+            accountID: "acct-alpha")
+        let swapper = RecordingCodexLiveAuthSwapper()
+        let store = RecordingManagedCodexAccountStore(base: container.fileStore) { _ in
+            throw PromotionTestError.storeWriteFailed
+        }
+
+        await #expect(throws: CodexAccountPromotionError.managedStoreCommitFailed) {
+            try await container.makeService(
+                store: store,
+                liveAuthSwapper: swapper).promoteManagedAccount(id: target.id)
+        }
+
+        #expect(swapper.swapCallCount == 0)
+        #expect(try container.liveAuthData() == liveAuthData)
+        #expect(try container.loadAccounts().accounts.count == 1)
+        #expect(try container.loadAccounts().accounts.first?.id == target.id)
+        #expect(try container.managedHomeURLs().count == 1)
+    }
+
+    @Test
+    func `refresh store failure leaves existing managed metadata stale after auth copy`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionServiceTests-refresh-store-failure")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "beta@example.com",
+            authAccountID: "acct-beta")
+        let existingManagedLive = try container.createManagedAccount(
+            persistedEmail: "alpha@example.com",
+            authAccountID: "acct-alpha")
+        try container.persistAccounts([target, existingManagedLive])
+        let originalManagedAuthData = try container.managedAuthData(for: existingManagedLive)
+        let liveAuthData = try container.writeLiveOAuthAuthFile(
+            email: "alpha@example.com",
+            accountID: "acct-alpha",
+            apiKey: "sk-refreshed-live")
+        let swapper = RecordingCodexLiveAuthSwapper()
+        let store = RecordingManagedCodexAccountStore(base: container.fileStore) { accounts in
+            if accounts.account(id: existingManagedLive.id)?
+                .lastAuthenticatedAt != existingManagedLive.lastAuthenticatedAt
+            {
+                throw PromotionTestError.storeWriteFailed
+            }
+        }
+
+        await #expect(throws: CodexAccountPromotionError.managedStoreCommitFailed) {
+            try await container.makeService(
+                store: store,
+                liveAuthSwapper: swapper).promoteManagedAccount(id: target.id)
+        }
+
+        let accounts = try container.loadAccounts().accounts
+        let persistedManagedLive = try #require(accounts.first(where: { $0.id == existingManagedLive.id }))
+        #expect(swapper.swapCallCount == 0)
+        #expect(try container.managedAuthData(for: persistedManagedLive) != originalManagedAuthData)
+        #expect(try container.managedAuthData(for: persistedManagedLive) == liveAuthData)
+        #expect(persistedManagedLive.lastAuthenticatedAt == existingManagedLive.lastAuthenticatedAt)
+    }
+
+    @Test
+    func `already managed refresh resolves workspace metadata from live auth home`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionServiceTests-already-managed-workspace-refresh")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "beta@example.com",
+            authAccountID: "acct-beta")
+        let existingManagedLive = try container.createManagedAccount(
+            persistedEmail: "alpha@example.com",
+            authAccountID: "acct-alpha",
+            workspaceLabel: "Stale",
+            workspaceAccountID: "acct-alpha")
+        try container.persistAccounts([target, existingManagedLive])
+        _ = try container.writeLiveOAuthAuthFile(email: "alpha@example.com", accountID: "acct-alpha")
+
+        let service = CodexAccountPromotionService(
+            store: container.fileStore,
+            homeFactory: container.homeFactory,
+            identityReader: container.identityReader,
+            workspaceResolver: HomePathWorkspaceResolver(
+                byHomePath: [
+                    container.liveHomeURL.path: CodexOpenAIWorkspaceIdentity(
+                        workspaceAccountID: "acct-alpha",
+                        workspaceLabel: "Fresh"),
+                    existingManagedLive.managedHomePath: CodexOpenAIWorkspaceIdentity(
+                        workspaceAccountID: "acct-alpha",
+                        workspaceLabel: "Stale"),
+                ]),
+            snapshotLoader: SettingsStoreCodexAccountReconciliationSnapshotLoader(settingsStore: container.settings),
+            authMaterialReader: DefaultCodexAuthMaterialReader(),
+            liveAuthSwapper: DefaultCodexLiveAuthSwapper(),
+            activeSourceWriter: SettingsStoreCodexActiveSourceWriter(settingsStore: container.settings),
+            accountScopedRefresher: UsageStoreCodexAccountScopedRefresher(usageStore: container.usageStore),
+            baseEnvironment: container.baseEnvironment,
+            fileManager: .default)
+
+        let result = try await service.promoteManagedAccount(id: target.id)
+        let accounts = try container.loadAccounts().accounts
+        let refreshedManagedLive = try #require(accounts.first(where: { $0.id == existingManagedLive.id }))
+
+        #expect(result.displacedLiveDisposition == .alreadyManaged(managedAccountID: existingManagedLive.id))
+        #expect(refreshedManagedLive.workspaceLabel == "Fresh")
+        #expect(refreshedManagedLive.workspaceAccountID == "acct-alpha")
+    }
+
+    @Test
+    func `live swap failure keeps preserved displaced live import in the managed store`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionServiceTests-swap-failure")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "beta@example.com",
+            authAccountID: "acct-beta")
+        try container.persistAccounts([target])
+        container.settings.codexActiveSource = .managedAccount(id: target.id)
+        let liveAuthData = try container.writeLiveOAuthAuthFile(
+            email: "alpha@example.com",
+            accountID: "acct-alpha")
+        let swapper = RecordingCodexLiveAuthSwapper { _, _ in
+            throw PromotionTestError.swapFailed
+        }
+
+        await #expect(throws: CodexAccountPromotionError.liveAuthSwapFailed) {
+            try await container.makeService(liveAuthSwapper: swapper).promoteManagedAccount(id: target.id)
+        }
+
+        let accounts = try container.loadAccounts().accounts
+        let imported = try #require(accounts.first(where: { $0.id != target.id }))
+        #expect(accounts.count == 2)
+        #expect(imported.authFingerprint == CodexAuthFingerprint.fingerprint(data: liveAuthData))
+        #expect(try container.managedAuthData(for: imported) == liveAuthData)
+        #expect(try container.liveAuthData() == liveAuthData)
+        #expect(container.settings.codexActiveSource == .managedAccount(id: target.id))
+    }
+
+    @Test
+    func `target managed auth without email is rejected before swap`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionServiceTests-target-auth-missing-email")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "alpha@example.com",
+            authAccountID: "acct-alpha")
+        try container.persistAccounts([target])
+        container.settings.codexActiveSource = .managedAccount(id: target.id)
+        _ = try container.writeManagedOAuthAuthFileWithoutEmail(for: target, accountID: "acct-alpha")
+        let swapper = RecordingCodexLiveAuthSwapper()
+
+        await #expect(throws: CodexAccountPromotionError.targetManagedAccountAuthUnreadable) {
+            try await container.makeService(liveAuthSwapper: swapper).promoteManagedAccount(id: target.id)
+        }
+
+        #expect(swapper.swapCallCount == 0)
+        #expect(try container.liveAuthData() == nil)
+        #expect(try container.loadAccounts().accounts.count == 1)
+        #expect(container.settings.codexActiveSource == .managedAccount(id: target.id))
+    }
+
+    @Test
+    func `provider account collision after stale managed home repairs existing record to preserved auth`()
+        async throws
+    {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionServiceTests-stale-home-collision")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "beta@example.com",
+            authAccountID: "acct-beta")
+        let existingID = UUID()
+        let staleHomeURL = container.managedHomesURL.appendingPathComponent(existingID.uuidString, isDirectory: true)
+        try FileManager.default.createDirectory(at: staleHomeURL, withIntermediateDirectories: true)
+        let staleManaged = ManagedCodexAccount(
+            id: existingID,
+            email: "alpha@example.com",
+            providerAccountID: "acct-alpha",
+            workspaceLabel: "Personal",
+            workspaceAccountID: "acct-alpha",
+            managedHomePath: staleHomeURL.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        try container.persistAccounts([target, staleManaged])
+        _ = try container.writeLiveOAuthAuthFile(email: "alpha@example.com", accountID: "acct-alpha")
+        let liveAuthData = try #require(try container.liveAuthData())
+
+        let result = try await container.makeService().promoteManagedAccount(id: target.id)
+        let accounts = try container.loadAccounts().accounts
+        let repairedManaged = try #require(accounts.first(where: { $0.id == staleManaged.id }))
+
+        #expect(result.displacedLiveDisposition == .alreadyManaged(managedAccountID: staleManaged.id))
+        #expect(accounts.count == 2)
+        #expect(repairedManaged.managedHomePath == staleHomeURL.path)
+        #expect(repairedManaged.authFingerprint == CodexAuthFingerprint.fingerprint(data: liveAuthData))
+        #expect(try container.managedAuthData(for: repairedManaged) == liveAuthData)
+        #expect(try container.managedHomeURLs().count == 2)
+    }
+
+    @Test
+    func `legacy email only managed account upgrades to provider identity during promotion`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionServiceTests-legacy-email-upgrade",
+            workspaceIdentities: [
+                "acct-alpha": CodexOpenAIWorkspaceIdentity(
+                    workspaceAccountID: "acct-alpha",
+                    workspaceLabel: "Personal"),
+            ])
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "beta@example.com",
+            authAccountID: "acct-beta")
+        let legacyID = UUID()
+        let legacyHomeURL = container.managedHomesURL.appendingPathComponent(legacyID.uuidString, isDirectory: true)
+        try FileManager.default.createDirectory(at: legacyHomeURL, withIntermediateDirectories: true)
+        let legacyManaged = ManagedCodexAccount(
+            id: legacyID,
+            email: "alpha@example.com",
+            providerAccountID: nil,
+            workspaceLabel: nil,
+            workspaceAccountID: nil,
+            managedHomePath: legacyHomeURL.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: nil)
+        try container.persistAccounts([target, legacyManaged])
+        let liveAuthData = try container.writeLiveOAuthAuthFile(email: "alpha@example.com", accountID: "acct-alpha")
+
+        let result = try await container.makeService().promoteManagedAccount(id: target.id)
+        let accounts = try container.loadAccounts().accounts
+        let upgradedManaged = try #require(accounts.first(where: { $0.id == legacyManaged.id }))
+
+        #expect(result.displacedLiveDisposition == .alreadyManaged(managedAccountID: legacyManaged.id))
+        #expect(accounts.count == 2)
+        #expect(upgradedManaged.providerAccountID == "acct-alpha")
+        #expect(upgradedManaged.workspaceLabel == "Personal")
+        #expect(upgradedManaged.workspaceAccountID == "acct-alpha")
+        #expect(try container.managedAuthData(for: upgradedManaged) == liveAuthData)
+    }
+
+    @Test
+    func `unsafe managed home refresh is rejected before auth rewrite`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionServiceTests-unsafe-refresh-home")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "beta@example.com",
+            authAccountID: "acct-beta")
+        let unsafeManagedLive = ManagedCodexAccount(
+            id: UUID(),
+            email: "alpha@example.com",
+            providerAccountID: "acct-alpha",
+            workspaceLabel: nil,
+            workspaceAccountID: "acct-alpha",
+            managedHomePath: container.rootURL.appendingPathComponent("unsafe-home", isDirectory: true).path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        try container.persistAccounts([target, unsafeManagedLive])
+        let liveAuthData = try container.writeLiveOAuthAuthFile(
+            email: "alpha@example.com",
+            accountID: "acct-alpha")
+
+        await #expect(throws: CodexAccountPromotionError.displacedLiveImportFailed) {
+            try await container.makeService().promoteManagedAccount(id: target.id)
+        }
+
+        let accounts = try container.loadAccounts().accounts
+        #expect(try container.liveAuthData() == liveAuthData)
+        #expect(FileManager.default.fileExists(atPath: unsafeManagedLive.managedHomePath) == false)
+        #expect(accounts.count == 2)
+        #expect(accounts.contains(where: { $0.id == target.id }))
+        #expect(accounts.contains(where: { $0.id == unsafeManagedLive.id }))
+    }
+
+    @Test
+    func `promotion rejects conflicting readable managed home before overwriting auth`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionServiceTests-conflicting-readable-home")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "beta@example.com",
+            authAccountID: "acct-beta")
+        let conflictingManaged = try container.createManagedAccount(
+            persistedEmail: "alpha@example.com",
+            authEmail: "gamma@example.com",
+            authAccountID: "acct-gamma",
+            persistedProviderAccountID: "acct-alpha",
+            useAuthAccountIDAsPersistedProviderAccountID: false)
+        try container.persistAccounts([target, conflictingManaged])
+        let liveAuthData = try container.writeLiveOAuthAuthFile(email: "alpha@example.com", accountID: "acct-alpha")
+        let conflictingAuthData = try container.managedAuthData(for: conflictingManaged)
+
+        await #expect(throws: CodexAccountPromotionError.displacedLiveManagedAccountConflict) {
+            try await container.makeService().promoteManagedAccount(id: target.id)
+        }
+
+        let accounts = try container.loadAccounts().accounts
+        let persistedConflict = try #require(accounts.first(where: { $0.id == conflictingManaged.id }))
+        #expect(try container.liveAuthData() == liveAuthData)
+        #expect(try container.managedAuthData(for: persistedConflict) == conflictingAuthData)
+        #expect(accounts.count == 2)
+    }
+
+    @Test
+    func `api key only live auth is rejected fail closed`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionServiceTests-api-key-only")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "beta@example.com",
+            authAccountID: "acct-beta")
+        try container.persistAccounts([target])
+        let liveAuthData = try container.writeLiveAPIKeyAuthFile()
+        let snapshotLoader =
+            StaticCodexAccountReconciliationSnapshotLoader(snapshot: CodexAccountReconciliationSnapshot(
+                storedAccounts: [target],
+                activeStoredAccount: nil,
+                liveSystemAccount: nil,
+                matchingStoredAccountForLiveSystemAccount: nil,
+                activeSource: .liveSystem,
+                hasUnreadableAddedAccountStore: false))
+
+        await #expect(throws: CodexAccountPromotionError.liveAccountAPIKeyOnlyUnsupported) {
+            try await container.makeService(snapshotLoader: snapshotLoader).promoteManagedAccount(id: target.id)
+        }
+
+        #expect(try container.liveAuthData() == liveAuthData)
+        #expect(try container.loadAccounts().accounts.count == 1)
+        #expect(try container.loadAccounts().accounts.first?.id == target.id)
+    }
+
+    @Test
+    func `post promotion refresh re-resolves codex state from the new live auth`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexAccountPromotionServiceTests-state-reresolution")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "beta@example.com",
+            authAccountID: "acct-beta")
+        try container.persistAccounts([target])
+        let snapshotLoader =
+            StaticCodexAccountReconciliationSnapshotLoader(snapshot: CodexAccountReconciliationSnapshot(
+                storedAccounts: [target],
+                activeStoredAccount: nil,
+                liveSystemAccount: nil,
+                matchingStoredAccountForLiveSystemAccount: nil,
+                activeSource: .liveSystem,
+                hasUnreadableAddedAccountStore: false))
+        _ = try container.writeLiveOAuthAuthFile(email: "alpha@example.com", accountID: "acct-alpha")
+        container.seedScopedRefreshState(
+            email: "alpha@example.com",
+            identity: .providerAccount(id: "acct-alpha"))
+        let refresher = ClosureCodexAccountScopedRefresher { _ in
+            let snapshot = UsageSnapshot(
+                primary: RateWindow(usedPercent: 12, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date(),
+                identity: ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: "beta@example.com",
+                    accountOrganization: nil,
+                    loginMethod: "Pro"))
+            let credits = CreditsSnapshot(remaining: 17, events: [], updatedAt: Date())
+            container.usageStore._setSnapshotForTesting(snapshot, provider: .codex)
+            container.usageStore.credits = credits
+            container.usageStore.lastCreditsSnapshot = credits
+            container.usageStore.lastCreditsSnapshotAccountKey = "beta@example.com"
+            container.usageStore.lastCreditsSource = .api
+            container.usageStore.lastCodexAccountScopedRefreshGuard = CodexAccountScopedRefreshGuard(
+                source: .liveSystem,
+                identity: .providerAccount(id: "acct-beta"),
+                accountKey: "beta@example.com")
+        }
+
+        let result = try await container.makeService(
+            snapshotLoader: snapshotLoader,
+            accountScopedRefresher: refresher)
+            .promoteManagedAccount(id: target.id)
+
+        #expect(result.outcome == .promoted)
+        #expect(container.usageStore.snapshots[.codex]?.accountEmail(for: .codex) == "beta@example.com")
+        #expect(container.usageStore.lastCreditsSnapshotAccountKey == "beta@example.com")
+        #expect(container.usageStore.lastCodexAccountScopedRefreshGuard?.identity == .providerAccount(id: "acct-beta"))
+        #expect(container.usageStore.lastCodexAccountScopedRefreshGuard?.accountKey == "beta@example.com")
+    }
+}
+
+private struct HomePathWorkspaceResolver: ManagedCodexWorkspaceResolving {
+    let byHomePath: [String: CodexOpenAIWorkspaceIdentity]
+
+    func resolveWorkspaceIdentity(
+        homePath: String,
+        providerAccountID _: String) async -> CodexOpenAIWorkspaceIdentity?
+    {
+        self.byHomePath[homePath]
+    }
+}
diff --git a/Tests/CodexBarTests/CodexAccountPromotionTestSupport.swift b/Tests/CodexBarTests/CodexAccountPromotionTestSupport.swift
new file mode 100644
index 0000000000..99011ea11a
--- /dev/null
+++ b/Tests/CodexBarTests/CodexAccountPromotionTestSupport.swift
@@ -0,0 +1,492 @@
+import CodexBarCore
+import Foundation
+@testable import CodexBar
+
+@MainActor
+final class CodexAccountPromotionTestContainer {
+    let suiteName: String
+    let rootURL: URL
+    let liveHomeURL: URL
+    let managedHomesURL: URL
+    let managedStoreURL: URL
+    let settings: SettingsStore
+    let usageStore: UsageStore
+    let fileStore: FileManagedCodexAccountStore
+    let homeFactory: ManagedCodexHomeFactory
+    let identityReader: DefaultManagedCodexIdentityReader
+    let workspaceResolver: any ManagedCodexWorkspaceResolving
+    let baseEnvironment: [String: String]
+
+    init(
+        suiteName: String,
+        workspaceIdentities: [String: CodexOpenAIWorkspaceIdentity] = [:]) throws
+    {
+        self.suiteName = suiteName
+        self.rootURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-account-promotion-tests", isDirectory: true)
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        self.liveHomeURL = self.rootURL.appendingPathComponent("liveHome", isDirectory: true)
+        self.managedHomesURL = self.rootURL.appendingPathComponent("managed-codex-homes", isDirectory: true)
+        self.managedStoreURL = self.rootURL.appendingPathComponent("managed-codex-accounts.json", isDirectory: false)
+        self.baseEnvironment = ["CODEX_HOME": self.liveHomeURL.path]
+        self.fileStore = FileManagedCodexAccountStore(fileURL: self.managedStoreURL, fileManager: .default)
+        self.homeFactory = ManagedCodexHomeFactory(root: self.managedHomesURL, fileManager: .default)
+        self.identityReader = DefaultManagedCodexIdentityReader()
+        self.workspaceResolver = StubManagedCodexWorkspaceResolver(identities: workspaceIdentities)
+
+        try FileManager.default.createDirectory(at: self.liveHomeURL, withIntermediateDirectories: true)
+        try FileManager.default.createDirectory(at: self.managedHomesURL, withIntermediateDirectories: true)
+        _ = try self.fileStore.ensureFileExists()
+
+        let defaults = UserDefaults(suiteName: suiteName)!
+        defaults.removePersistentDomain(forName: suiteName)
+        defaults.set(true, forKey: "providerDetectionCompleted")
+        self.settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suiteName),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        self.settings._test_activeManagedCodexAccount = nil
+        self.settings._test_activeManagedCodexRemoteHomePath = nil
+        self.settings._test_unreadableManagedCodexAccountStore = false
+        self.settings._test_managedCodexAccountStoreURL = self.managedStoreURL
+        self.settings._test_liveSystemCodexAccount = nil
+        self.settings._test_codexReconciliationEnvironment = self.baseEnvironment
+        self.settings.providerDetectionCompleted = true
+        self.settings.refreshFrequency = .manual
+        self.settings.codexCookieSource = .off
+
+        self.usageStore = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: self.settings,
+            startupBehavior: .testing)
+        self.installDynamicCodexUsageLoader()
+        self.usageStore._test_codexCreditsLoaderOverride = {
+            CreditsSnapshot(remaining: 17, events: [], updatedAt: Date())
+        }
+    }
+
+    func tearDown() {
+        self.usageStore._test_codexCreditsLoaderOverride = nil
+        self.settings._test_activeManagedCodexAccount = nil
+        self.settings._test_activeManagedCodexRemoteHomePath = nil
+        self.settings._test_unreadableManagedCodexAccountStore = false
+        self.settings._test_managedCodexAccountStoreURL = nil
+        self.settings._test_liveSystemCodexAccount = nil
+        self.settings._test_codexReconciliationEnvironment = nil
+        self.settings.userDefaults.removePersistentDomain(forName: self.suiteName)
+        try? FileManager.default.removeItem(at: self.rootURL)
+    }
+
+    func makeService(
+        store: (any ManagedCodexAccountStoring)? = nil,
+        liveAuthSwapper: (any CodexLiveAuthSwapping)? = nil,
+        activeSourceWriter: (any CodexActiveSourceWriting)? = nil,
+        snapshotLoader: (any CodexAccountReconciliationSnapshotLoading)? = nil,
+        accountScopedRefresher: (any CodexAccountScopedRefreshing)? = nil)
+        -> CodexAccountPromotionService
+    {
+        CodexAccountPromotionService(
+            store: store ?? self.fileStore,
+            homeFactory: self.homeFactory,
+            identityReader: self.identityReader,
+            workspaceResolver: self.workspaceResolver,
+            snapshotLoader: snapshotLoader
+                ?? SettingsStoreCodexAccountReconciliationSnapshotLoader(settingsStore: self.settings),
+            authMaterialReader: DefaultCodexAuthMaterialReader(),
+            liveAuthSwapper: liveAuthSwapper ?? DefaultCodexLiveAuthSwapper(),
+            activeSourceWriter: activeSourceWriter
+                ?? SettingsStoreCodexActiveSourceWriter(settingsStore: self.settings),
+            accountScopedRefresher: accountScopedRefresher
+                ?? UsageStoreCodexAccountScopedRefresher(usageStore: self.usageStore),
+            baseEnvironment: self.baseEnvironment,
+            fileManager: .default)
+    }
+
+    func installDynamicCodexUsageLoader(usedPercent: Double = 12) {
+        let baseSpec = self.usageStore.providerSpecs[.codex]!
+        let liveHomePath = self.liveHomeURL.path
+        let identityReader = self.identityReader
+        self.usageStore
+            .providerSpecs[.codex] = makeCodexProviderSpec(baseSpec: baseSpec) {
+                let liveEmail = (try? identityReader.loadAccountIdentity(homePath: liveHomePath).email)
+                    ?? "unknown@example.com"
+                return UsageSnapshot(
+                    primary: RateWindow(
+                        usedPercent: usedPercent,
+                        windowMinutes: 300,
+                        resetsAt: nil,
+                        resetDescription: nil),
+                    secondary: nil,
+                    updatedAt: Date(),
+                    identity: ProviderIdentitySnapshot(
+                        providerID: .codex,
+                        accountEmail: liveEmail,
+                        accountOrganization: nil,
+                        loginMethod: "Pro"))
+            }
+    }
+
+    @discardableResult
+    func createManagedAccount(
+        id: UUID = UUID(),
+        persistedEmail: String,
+        authEmail: String? = nil,
+        authAccountID: String? = nil,
+        persistedProviderAccountID: String? = nil,
+        useAuthAccountIDAsPersistedProviderAccountID: Bool = true,
+        workspaceLabel: String? = nil,
+        workspaceAccountID: String? = nil,
+        plan: String = "Pro") throws -> ManagedCodexAccount
+    {
+        let homeURL = self.managedHomesURL.appendingPathComponent(id.uuidString, isDirectory: true)
+        let createdAt = Date().timeIntervalSince1970
+        let authData = try self.writeOAuthAuthFile(
+            homeURL: homeURL,
+            email: authEmail ?? persistedEmail,
+            plan: plan,
+            accountID: authAccountID)
+        let persistedProviderAccountIDValue: String? =
+            if useAuthAccountIDAsPersistedProviderAccountID {
+                persistedProviderAccountID ?? authAccountID
+            } else {
+                persistedProviderAccountID
+            }
+        return ManagedCodexAccount(
+            id: id,
+            email: persistedEmail,
+            providerAccountID: persistedProviderAccountIDValue,
+            workspaceLabel: workspaceLabel,
+            workspaceAccountID: workspaceAccountID ?? authAccountID,
+            authFingerprint: CodexAuthFingerprint.fingerprint(data: authData),
+            managedHomePath: homeURL.path,
+            createdAt: createdAt,
+            updatedAt: createdAt,
+            lastAuthenticatedAt: createdAt)
+    }
+
+    func persistAccounts(_ accounts: [ManagedCodexAccount]) throws {
+        try self.fileStore.storeAccounts(ManagedCodexAccountSet(
+            version: FileManagedCodexAccountStore.currentVersion,
+            accounts: accounts))
+    }
+
+    func loadAccounts() throws -> ManagedCodexAccountSet {
+        try self.fileStore.loadAccounts()
+    }
+
+    @discardableResult
+    func writeLiveOAuthAuthFile(
+        email: String,
+        plan: String = "Pro",
+        accountID: String? = nil,
+        apiKey: String? = nil) throws -> Data
+    {
+        try self.writeOAuthAuthFile(
+            homeURL: self.liveHomeURL,
+            email: email,
+            plan: plan,
+            accountID: accountID,
+            apiKey: apiKey)
+    }
+
+    @discardableResult
+    func writeLiveAPIKeyAuthFile(apiKey: String = "sk-live-only") throws -> Data {
+        let data = try JSONSerialization.data(
+            withJSONObject: ["OPENAI_API_KEY": apiKey],
+            options: [.sortedKeys])
+        try FileManager.default.createDirectory(at: self.liveHomeURL, withIntermediateDirectories: true)
+        try data.write(to: Self.authFileURL(for: self.liveHomeURL), options: .atomic)
+        return data
+    }
+
+    @discardableResult
+    func writeLiveOAuthAuthFileWithoutEmail(accountID: String, apiKey: String? = nil) throws -> Data {
+        try self.writeOAuthAuthFileWithoutEmail(
+            homeURL: self.liveHomeURL,
+            accountID: accountID,
+            apiKey: apiKey)
+    }
+
+    @discardableResult
+    func writeManagedOAuthAuthFileWithoutEmail(
+        for account: ManagedCodexAccount,
+        accountID: String,
+        apiKey: String? = nil) throws -> Data
+    {
+        try self.writeOAuthAuthFileWithoutEmail(
+            homeURL: URL(fileURLWithPath: account.managedHomePath, isDirectory: true),
+            accountID: accountID,
+            apiKey: apiKey)
+    }
+
+    @discardableResult
+    private func writeOAuthAuthFileWithoutEmail(
+        homeURL: URL,
+        accountID: String,
+        apiKey: String? = nil) throws -> Data
+    {
+        try FileManager.default.createDirectory(at: homeURL, withIntermediateDirectories: true)
+
+        let tokens: [String: Any] = [
+            "accessToken": "access-\(accountID)",
+            "refreshToken": "refresh-\(accountID)",
+            "accountId": accountID,
+        ]
+        var json: [String: Any] = [
+            "tokens": tokens,
+            "last_refresh": "2026-04-05T00:00:00Z",
+        ]
+        if let apiKey {
+            json["OPENAI_API_KEY"] = apiKey
+        }
+
+        let data = try JSONSerialization.data(withJSONObject: json, options: [.sortedKeys])
+        try data.write(to: Self.authFileURL(for: homeURL), options: .atomic)
+        return data
+    }
+
+    func removeLiveAuthFile() throws {
+        let authFileURL = Self.authFileURL(for: self.liveHomeURL)
+        if FileManager.default.fileExists(atPath: authFileURL.path) {
+            try FileManager.default.removeItem(at: authFileURL)
+        }
+    }
+
+    func liveAuthData() throws -> Data? {
+        let authFileURL = Self.authFileURL(for: self.liveHomeURL)
+        guard FileManager.default.fileExists(atPath: authFileURL.path) else { return nil }
+        return try Data(contentsOf: authFileURL)
+    }
+
+    func managedAuthData(for account: ManagedCodexAccount) throws -> Data {
+        try Data(contentsOf: Self.authFileURL(for: URL(fileURLWithPath: account.managedHomePath, isDirectory: true)))
+    }
+
+    func managedHomeURLs() throws -> [URL] {
+        let urls = try FileManager.default.contentsOfDirectory(
+            at: self.managedHomesURL,
+            includingPropertiesForKeys: nil)
+        return urls.sorted { $0.lastPathComponent < $1.lastPathComponent }
+    }
+
+    func seedScopedRefreshState(email: String, identity: CodexIdentity) {
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 4, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: email,
+                accountOrganization: nil,
+                loginMethod: "Pro"))
+        let credits = CreditsSnapshot(remaining: 3, events: [], updatedAt: Date())
+
+        self.usageStore._setSnapshotForTesting(snapshot, provider: .codex)
+        self.usageStore.credits = credits
+        self.usageStore.lastCreditsSnapshot = credits
+        self.usageStore.lastCreditsSnapshotAccountKey = email
+        self.usageStore.lastCreditsSource = .api
+        self.usageStore.lastCodexAccountScopedRefreshGuard = CodexAccountScopedRefreshGuard(
+            source: .liveSystem,
+            identity: identity,
+            accountKey: email)
+    }
+
+    @discardableResult
+    private func writeOAuthAuthFile(
+        homeURL: URL,
+        email: String,
+        plan: String,
+        accountID: String?,
+        apiKey: String? = nil) throws -> Data
+    {
+        try FileManager.default.createDirectory(at: homeURL, withIntermediateDirectories: true)
+
+        var tokens: [String: Any] = [
+            "accessToken": "access-\(email)",
+            "refreshToken": "refresh-\(email)",
+            "idToken": Self.fakeJWT(email: email, plan: plan, accountID: accountID),
+        ]
+        if let accountID {
+            tokens["accountId"] = accountID
+        }
+
+        var json: [String: Any] = [
+            "tokens": tokens,
+            "last_refresh": "2026-04-05T00:00:00Z",
+        ]
+        if let apiKey {
+            json["OPENAI_API_KEY"] = apiKey
+        }
+
+        let data = try JSONSerialization.data(withJSONObject: json, options: [.sortedKeys])
+        try data.write(to: Self.authFileURL(for: homeURL), options: .atomic)
+        return data
+    }
+
+    private static func fakeJWT(email: String, plan: String, accountID: String?) -> String {
+        let header = (try? JSONSerialization.data(withJSONObject: ["alg": "none"])) ?? Data()
+        var authClaims: [String: Any] = [
+            "chatgpt_plan_type": plan,
+        ]
+        if let accountID {
+            authClaims["chatgpt_account_id"] = accountID
+        }
+        let payload = (try? JSONSerialization.data(withJSONObject: [
+            "email": email,
+            "chatgpt_plan_type": plan,
+            "https://api.openai.com/auth": authClaims,
+        ])) ?? Data()
+
+        func base64URL(_ data: Data) -> String {
+            data.base64EncodedString()
+                .replacingOccurrences(of: "=", with: "")
+                .replacingOccurrences(of: "+", with: "-")
+                .replacingOccurrences(of: "/", with: "_")
+        }
+
+        return "\(base64URL(header)).\(base64URL(payload))."
+    }
+
+    private static func authFileURL(for homeURL: URL) -> URL {
+        homeURL.appendingPathComponent("auth.json", isDirectory: false)
+    }
+}
+
+private func makeCodexProviderSpec(
+    baseSpec: ProviderSpec,
+    loader: @escaping @Sendable () async throws -> UsageSnapshot) -> ProviderSpec
+{
+    let baseDescriptor = baseSpec.descriptor
+    let strategy = TestPromotionCodexFetchStrategy(loader: loader)
+    let descriptor = ProviderDescriptor(
+        id: .codex,
+        metadata: baseDescriptor.metadata,
+        branding: baseDescriptor.branding,
+        tokenCost: baseDescriptor.tokenCost,
+        fetchPlan: ProviderFetchPlan(
+            sourceModes: [.auto, .cli, .oauth],
+            pipeline: ProviderFetchPipeline { _ in [strategy] }),
+        cli: baseDescriptor.cli)
+    return ProviderSpec(
+        style: baseSpec.style,
+        isEnabled: baseSpec.isEnabled,
+        descriptor: descriptor,
+        makeFetchContext: baseSpec.makeFetchContext)
+}
+
+private struct TestPromotionCodexFetchStrategy: ProviderFetchStrategy {
+    let loader: @Sendable () async throws -> UsageSnapshot
+
+    var id: String {
+        "test-promotion-codex"
+    }
+
+    var kind: ProviderFetchKind {
+        .cli
+    }
+
+    func isAvailable(_: ProviderFetchContext) async -> Bool {
+        true
+    }
+
+    func fetch(_: ProviderFetchContext) async throws -> ProviderFetchResult {
+        let snapshot = try await self.loader()
+        return self.makeResult(usage: snapshot, sourceLabel: "test-promotion-codex")
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+}
+
+final class RecordingManagedCodexAccountStore: ManagedCodexAccountStoring, @unchecked Sendable {
+    let base: any ManagedCodexAccountStoring
+    var storedSnapshots: [ManagedCodexAccountSet] = []
+    var onStore: (@Sendable (ManagedCodexAccountSet) throws -> Void)?
+
+    init(
+        base: any ManagedCodexAccountStoring,
+        onStore: (@Sendable (ManagedCodexAccountSet) throws -> Void)? = nil)
+    {
+        self.base = base
+        self.onStore = onStore
+    }
+
+    func loadAccounts() throws -> ManagedCodexAccountSet {
+        try self.base.loadAccounts()
+    }
+
+    func storeAccounts(_ accounts: ManagedCodexAccountSet) throws {
+        self.storedSnapshots.append(accounts)
+        try self.onStore?(accounts)
+        try self.base.storeAccounts(accounts)
+    }
+
+    func ensureFileExists() throws -> URL {
+        try self.base.ensureFileExists()
+    }
+}
+
+final class RecordingCodexLiveAuthSwapper: CodexLiveAuthSwapping, @unchecked Sendable {
+    let base: any CodexLiveAuthSwapping
+    var swapCallCount = 0
+    var swappedData: [Data] = []
+    var onSwap: (@Sendable (Data, URL) throws -> Void)?
+
+    init(
+        base: any CodexLiveAuthSwapping = DefaultCodexLiveAuthSwapper(),
+        onSwap: (@Sendable (Data, URL) throws -> Void)? = nil)
+    {
+        self.base = base
+        self.onSwap = onSwap
+    }
+
+    func swapLiveAuthData(_ data: Data, liveHomeURL: URL) throws {
+        self.swapCallCount += 1
+        self.swappedData.append(data)
+        try self.onSwap?(data, liveHomeURL)
+        try self.base.swapLiveAuthData(data, liveHomeURL: liveHomeURL)
+    }
+}
+
+enum PromotionTestError: Error, Equatable {
+    case storeWriteFailed
+    case swapFailed
+    case unexpectedDisposition
+}
+
+private struct StubManagedCodexWorkspaceResolver: ManagedCodexWorkspaceResolving {
+    let identities: [String: CodexOpenAIWorkspaceIdentity]
+
+    func resolveWorkspaceIdentity(
+        homePath _: String,
+        providerAccountID: String) async -> CodexOpenAIWorkspaceIdentity?
+    {
+        self.identities[providerAccountID]
+    }
+}
+
+@MainActor
+struct StaticCodexAccountReconciliationSnapshotLoader: CodexAccountReconciliationSnapshotLoading {
+    let snapshot: CodexAccountReconciliationSnapshot
+
+    func loadSnapshot() -> CodexAccountReconciliationSnapshot {
+        self.snapshot
+    }
+}
+
+@MainActor
+final class ClosureCodexAccountScopedRefresher: CodexAccountScopedRefreshing {
+    private let onRefresh: @MainActor (Bool) async -> Void
+
+    init(onRefresh: @escaping @MainActor (Bool) async -> Void) {
+        self.onRefresh = onRefresh
+    }
+
+    func refreshCodexAccountScopedState(allowDisabled: Bool) async {
+        await self.onRefresh(allowDisabled)
+    }
+}
diff --git a/Tests/CodexBarTests/CodexAccountProviderIdentityReconciliationTests.swift b/Tests/CodexBarTests/CodexAccountProviderIdentityReconciliationTests.swift
new file mode 100644
index 0000000000..79517f800e
--- /dev/null
+++ b/Tests/CodexBarTests/CodexAccountProviderIdentityReconciliationTests.swift
@@ -0,0 +1,48 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct CodexAccountProviderIdentityReconciliationTests {
+    @Test
+    func `same provider account id with different email does not merge live and managed rows`() {
+        let stored = ManagedCodexAccount(
+            id: UUID(),
+            email: "mi.chaelfmk5542@gmail.com",
+            providerAccountID: "team-4107",
+            workspaceLabel: "4107",
+            workspaceAccountID: "team-4107",
+            managedHomePath: "/tmp/managed-a",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 3)
+        let live = ObservedSystemCodexAccount(
+            email: "mich.aelfmk5542@gmail.com",
+            workspaceLabel: "4107",
+            workspaceAccountID: "team-4107",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .providerAccount(id: "team-4107"))
+        let snapshot = CodexAccountReconciliationSnapshot(
+            storedAccounts: [stored],
+            activeStoredAccount: stored,
+            liveSystemAccount: live,
+            matchingStoredAccountForLiveSystemAccount: nil,
+            activeSource: .managedAccount(id: stored.id),
+            hasUnreadableAddedAccountStore: false,
+            storedAccountRuntimeIdentities: [stored.id: .providerAccount(id: "team-4107")],
+            storedAccountRuntimeEmails: [stored.id: "mi.chaelfmk5542@gmail.com"])
+
+        let resolution = CodexActiveSourceResolver.resolve(from: snapshot)
+        let projection = CodexVisibleAccountProjection.make(from: snapshot)
+
+        #expect(resolution.resolvedSource == .managedAccount(id: stored.id))
+        #expect(projection.visibleAccounts.count == 2)
+        #expect(projection.visibleAccounts.map(\.email).sorted() == [
+            "mi.chaelfmk5542@gmail.com",
+            "mich.aelfmk5542@gmail.com",
+        ])
+        #expect(projection.activeVisibleAccountID == "mi.chaelfmk5542@gmail.com")
+        #expect(projection.liveVisibleAccountID == "mich.aelfmk5542@gmail.com")
+    }
+}
diff --git a/Tests/CodexBarTests/CodexAccountReconciliationTests.swift b/Tests/CodexBarTests/CodexAccountReconciliationTests.swift
new file mode 100644
index 0000000000..cf53f30e82
--- /dev/null
+++ b/Tests/CodexBarTests/CodexAccountReconciliationTests.swift
@@ -0,0 +1,946 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@Suite(.serialized)
+struct CodexAccountReconciliationTests {
+    @MainActor
+    private static func makeSettings(suite: String) throws -> SettingsStore {
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        defaults.set(true, forKey: "providerDetectionCompleted")
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.providerDetectionCompleted = true
+        return settings
+    }
+
+    @Test
+    @MainActor
+    func `settings store exposes codex reconciliation accessors using managed and live overrides`() throws {
+        let suite = "CodexAccountReconciliationTests-settings-store"
+        let settings = try Self.makeSettings(suite: suite)
+        let managed = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-home",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 3)
+        let live = ObservedSystemCodexAccount(
+            email: "system@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        settings._test_activeManagedCodexAccount = managed
+        settings._test_liveSystemCodexAccount = live
+        settings.codexActiveSource = .managedAccount(id: managed.id)
+        defer {
+            settings._test_activeManagedCodexAccount = nil
+            settings._test_liveSystemCodexAccount = nil
+        }
+
+        let snapshot = settings.codexAccountReconciliationSnapshot
+        let projection = settings.codexVisibleAccountProjection
+
+        #expect(settings.codexActiveSource == .managedAccount(id: managed.id))
+        #expect(snapshot.storedAccounts.map(\.id) == [managed.id])
+        #expect(snapshot.storedAccounts.map(\.email) == [managed.email])
+        #expect(snapshot.activeStoredAccount?.id == managed.id)
+        #expect(snapshot.activeStoredAccount?.email == managed.email)
+        #expect(snapshot.liveSystemAccount?.email == live.email)
+        #expect(snapshot.liveSystemAccount?.codexHomePath == live.codexHomePath)
+        #expect(snapshot.liveSystemAccount?.observedAt == live.observedAt)
+        #expect(snapshot.liveSystemAccount?.identity == .emailOnly(normalizedEmail: "system@example.com"))
+        #expect(snapshot.matchingStoredAccountForLiveSystemAccount == nil)
+        #expect(snapshot.activeSource == .managedAccount(id: managed.id))
+        #expect(snapshot.hasUnreadableAddedAccountStore == false)
+        #expect(Set(projection.visibleAccounts.map(\.email)) == ["managed@example.com", "system@example.com"])
+        #expect(settings.codexVisibleAccounts == projection.visibleAccounts)
+        #expect(projection.activeVisibleAccountID == "managed@example.com")
+        #expect(projection.liveVisibleAccountID == "system@example.com")
+    }
+
+    @Test
+    @MainActor
+    func `settings store managed override does not leak ambient live system account`() throws {
+        let suite = "CodexAccountReconciliationTests-managed-only"
+        let settings = try Self.makeSettings(suite: suite)
+        let managed = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-home",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 3)
+        settings._test_activeManagedCodexAccount = managed
+        settings.codexActiveSource = .managedAccount(id: managed.id)
+        defer {
+            settings._test_activeManagedCodexAccount = nil
+        }
+
+        let snapshot = settings.codexAccountReconciliationSnapshot
+        let projection = settings.codexVisibleAccountProjection
+
+        #expect(settings.codexActiveSource == .managedAccount(id: managed.id))
+        #expect(snapshot.liveSystemAccount == nil)
+        #expect(snapshot.matchingStoredAccountForLiveSystemAccount == nil)
+        #expect(snapshot.activeSource == .managedAccount(id: managed.id))
+        #expect(projection.visibleAccounts.map(\.email) == ["managed@example.com"])
+        #expect(projection.activeVisibleAccountID == "managed@example.com")
+        #expect(projection.liveVisibleAccountID == nil)
+    }
+
+    @Test
+    @MainActor
+    func `settings store reconciliation environment override drives live observation with synthetic store`() throws {
+        let suite = "CodexAccountReconciliationTests-environment-only"
+        let settings = try Self.makeSettings(suite: suite)
+        let ambientHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        try Self.writeCodexAuthFile(homeURL: ambientHome, email: "ambient@example.com", plan: "pro")
+        settings._test_codexReconciliationEnvironment = ["CODEX_HOME": ambientHome.path]
+        defer {
+            settings._test_codexReconciliationEnvironment = nil
+            try? FileManager.default.removeItem(at: ambientHome)
+        }
+
+        let snapshot = settings.codexAccountReconciliationSnapshot
+        let projection = settings.codexVisibleAccountProjection
+
+        #expect(settings.codexActiveSource == .liveSystem)
+        #expect(snapshot.storedAccounts.isEmpty)
+        #expect(snapshot.activeStoredAccount == nil)
+        #expect(snapshot.liveSystemAccount?.email == "ambient@example.com")
+        #expect(snapshot.liveSystemAccount?.codexHomePath == ambientHome.path)
+        #expect(snapshot.matchingStoredAccountForLiveSystemAccount == nil)
+        #expect(snapshot.activeSource == .liveSystem)
+        #expect(projection.visibleAccounts.map(\.email) == ["ambient@example.com"])
+        #expect(projection.activeVisibleAccountID == "ambient@example.com")
+        #expect(projection.liveVisibleAccountID == "ambient@example.com")
+    }
+
+    @Test
+    @MainActor
+    func `settings store can reuse short lived codex reconciliation snapshot`() throws {
+        let suite = "CodexAccountReconciliationTests-short-lived-cache"
+        let settings = try Self.makeSettings(suite: suite)
+        let ambientHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        try Self.writeCodexAuthFile(homeURL: ambientHome, email: "cached@example.com", plan: "pro")
+        settings._test_codexReconciliationEnvironment = ["CODEX_HOME": ambientHome.path]
+        SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = 60
+        defer {
+            SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = nil
+            settings._test_codexReconciliationEnvironment = nil
+            try? FileManager.default.removeItem(at: ambientHome)
+        }
+
+        let first = settings.codexAccountReconciliationSnapshot
+        try FileManager.default.removeItem(at: ambientHome)
+        let cached = settings.codexAccountReconciliationSnapshot
+        settings.invalidateCodexAccountReconciliationSnapshotCache()
+        let refreshed = settings.codexAccountReconciliationSnapshot
+
+        #expect(first.liveSystemAccount?.email == "cached@example.com")
+        #expect(cached.liveSystemAccount?.email == "cached@example.com")
+        #expect(refreshed.liveSystemAccount == nil)
+    }
+
+    @Test
+    @MainActor
+    func `codex active source write invalidates short lived reconciliation snapshot`() throws {
+        let suite = "CodexAccountReconciliationTests-active-source-cache-invalidation"
+        let settings = try Self.makeSettings(suite: suite)
+        let ambientHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        try Self.writeCodexAuthFile(homeURL: ambientHome, email: "before@example.com", plan: "pro")
+        settings._test_codexReconciliationEnvironment = ["CODEX_HOME": ambientHome.path]
+        SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = 60
+        defer {
+            SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = nil
+            settings._test_codexReconciliationEnvironment = nil
+            try? FileManager.default.removeItem(at: ambientHome)
+        }
+
+        #expect(settings.codexAccountReconciliationSnapshot.liveSystemAccount?.email == "before@example.com")
+        try Self.writeCodexAuthFile(homeURL: ambientHome, email: "after@example.com", plan: "pro")
+        settings.codexActiveSource = .liveSystem
+
+        #expect(settings.codexAccountReconciliationSnapshot.liveSystemAccount?.email == "after@example.com")
+    }
+
+    @Test
+    @MainActor
+    func `managed account changes invalidate short lived reconciliation snapshot`() throws {
+        let suite = "CodexAccountReconciliationTests-managed-change-cache-invalidation"
+        let settings = try Self.makeSettings(suite: suite)
+        let storeURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-managed-store-\(UUID().uuidString).json")
+        try Self.writeManagedCodexStore(
+            ManagedCodexAccountSet(version: FileManagedCodexAccountStore.currentVersion, accounts: []),
+            to: storeURL)
+        let stored = ManagedCodexAccount(
+            id: UUID(),
+            email: "stored@example.com",
+            managedHomePath: "/tmp/stored-managed-home",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 3)
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .managedAccount(id: stored.id)
+        SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = 60
+        defer {
+            SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = nil
+            settings._test_managedCodexAccountStoreURL = nil
+            try? FileManager.default.removeItem(at: storeURL)
+        }
+
+        #expect(settings.codexAccountReconciliationSnapshot.storedAccounts.isEmpty)
+        try Self.writeManagedCodexStore(
+            ManagedCodexAccountSet(version: FileManagedCodexAccountStore.currentVersion, accounts: [stored]),
+            to: storeURL)
+        settings.refreshCodexAccountReconciliationAfterManagedAccountsDidChange()
+
+        #expect(settings.codexAccountReconciliationSnapshot.storedAccounts.map(\.id) == [stored.id])
+    }
+
+    @Test
+    @MainActor
+    func `settings store home path override also keeps reconciliation hermetic`() throws {
+        let suite = "CodexAccountReconciliationTests-home-path-only"
+        let settings = try Self.makeSettings(suite: suite)
+        settings._test_activeManagedCodexRemoteHomePath = "/tmp/managed-route-home"
+        settings._test_liveSystemCodexAccount = nil
+        settings._test_codexReconciliationEnvironment = nil
+        defer {
+            settings._test_activeManagedCodexRemoteHomePath = nil
+            settings._test_liveSystemCodexAccount = nil
+            settings._test_codexReconciliationEnvironment = nil
+        }
+
+        let snapshot = settings.codexAccountReconciliationSnapshot
+        let projection = settings.codexVisibleAccountProjection
+
+        #expect(snapshot.storedAccounts.isEmpty)
+        #expect(snapshot.activeStoredAccount == nil)
+        #expect(snapshot.liveSystemAccount == nil)
+        #expect(snapshot.matchingStoredAccountForLiveSystemAccount == nil)
+        #expect(projection.visibleAccounts.isEmpty)
+        #expect(projection.activeVisibleAccountID == nil)
+        #expect(projection.liveVisibleAccountID == nil)
+    }
+
+    @Test
+    @MainActor
+    func `settings store home path override keeps active source hermetic without persisted source`() throws {
+        let suite = "CodexAccountReconciliationTests-home-path-hermetic-source"
+        let settings = try Self.makeSettings(suite: suite)
+        let ambient = ManagedCodexAccount(
+            id: UUID(),
+            email: "ambient-managed@example.com",
+            managedHomePath: "/tmp/ambient-managed-home",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 3)
+        let accounts = ManagedCodexAccountSet(
+            version: FileManagedCodexAccountStore.currentVersion,
+            accounts: [ambient])
+        let storeURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-managed-store-\(UUID().uuidString).json")
+        try Self.writeManagedCodexStore(accounts, to: storeURL)
+
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings._test_activeManagedCodexRemoteHomePath = "/tmp/managed-route-home"
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            settings._test_activeManagedCodexRemoteHomePath = nil
+            try? FileManager.default.removeItem(at: storeURL)
+        }
+
+        let snapshot = settings.codexAccountReconciliationSnapshot
+
+        #expect(settings.codexActiveSource == .liveSystem)
+        #expect(settings.providerConfig(for: .codex)?.codexActiveSource == nil)
+        #expect(snapshot.storedAccounts.map(\.id) == [ambient.id])
+        #expect(snapshot.storedAccounts.map(\.email) == [ambient.email])
+        #expect(snapshot.activeStoredAccount == nil)
+        #expect(snapshot.activeSource == .liveSystem)
+    }
+
+    @Test
+    @MainActor
+    func `settings store normal reconciliation path honors persisted active source`() throws {
+        let suite = "CodexAccountReconciliationTests-normal-path-active-source"
+        let settings = try Self.makeSettings(suite: suite)
+        let persistedSource = CodexActiveSource.managedAccount(id: UUID())
+        settings.codexActiveSource = persistedSource
+
+        let snapshot = settings.codexAccountReconciliationSnapshot
+
+        #expect(snapshot.activeSource == persistedSource)
+    }
+
+    @Test
+    @MainActor
+    func `settings store debug managed store U R L override loads on disk accounts`() throws {
+        let suite = "CodexAccountReconciliationTests-debug-store-url"
+        let settings = try Self.makeSettings(suite: suite)
+        let stored = ManagedCodexAccount(
+            id: UUID(),
+            email: "stored@example.com",
+            managedHomePath: "/tmp/stored-managed-home",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 3)
+        let accounts = ManagedCodexAccountSet(
+            version: FileManagedCodexAccountStore.currentVersion,
+            accounts: [stored])
+        let storeURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-managed-store-\(UUID().uuidString).json")
+        try Self.writeManagedCodexStore(accounts, to: storeURL)
+
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .managedAccount(id: stored.id)
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            try? FileManager.default.removeItem(at: storeURL)
+        }
+
+        let snapshot = settings.codexAccountReconciliationSnapshot
+
+        #expect(snapshot.storedAccounts.map(\.id) == [stored.id])
+        #expect(snapshot.storedAccounts.map(\.email) == [stored.email])
+        #expect(snapshot.activeStoredAccount?.id == stored.id)
+        #expect(snapshot.activeStoredAccount?.email == stored.email)
+        #expect(snapshot.activeSource == .managedAccount(id: stored.id))
+    }
+
+    @Test
+    func `live only visible account is active when active source is live system`() {
+        let live = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        let projection = CodexVisibleAccountProjection.make(from: CodexAccountReconciliationSnapshot(
+            storedAccounts: [],
+            activeStoredAccount: nil,
+            liveSystemAccount: live,
+            matchingStoredAccountForLiveSystemAccount: nil,
+            activeSource: .liveSystem,
+            hasUnreadableAddedAccountStore: false))
+
+        #expect(projection.visibleAccounts.map(\.email) == ["live@example.com"])
+        #expect(projection.activeVisibleAccountID == "live@example.com")
+        #expect(projection.liveVisibleAccountID == "live@example.com")
+    }
+
+    @Test
+    func `workspace hydration changes snapshot equality and visible display state`() {
+        let accountID = UUID()
+        let baseAccount = ManagedCodexAccount(
+            id: accountID,
+            email: "user@example.com",
+            providerAccountID: "account-live",
+            managedHomePath: "/tmp/managed-a",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 3)
+        let hydratedAccount = ManagedCodexAccount(
+            id: accountID,
+            email: "user@example.com",
+            providerAccountID: "account-live",
+            workspaceLabel: "Team Alpha",
+            workspaceAccountID: "account-live",
+            managedHomePath: "/tmp/managed-a",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 3)
+        let baseSnapshot = CodexAccountReconciliationSnapshot(
+            storedAccounts: [baseAccount],
+            activeStoredAccount: baseAccount,
+            liveSystemAccount: nil,
+            matchingStoredAccountForLiveSystemAccount: nil,
+            activeSource: .managedAccount(id: accountID),
+            hasUnreadableAddedAccountStore: false)
+        let hydratedSnapshot = CodexAccountReconciliationSnapshot(
+            storedAccounts: [hydratedAccount],
+            activeStoredAccount: hydratedAccount,
+            liveSystemAccount: nil,
+            matchingStoredAccountForLiveSystemAccount: nil,
+            activeSource: .managedAccount(id: accountID),
+            hasUnreadableAddedAccountStore: false)
+
+        let baseProjection = CodexVisibleAccountProjection.make(from: baseSnapshot)
+        let hydratedProjection = CodexVisibleAccountProjection.make(from: hydratedSnapshot)
+
+        #expect(baseSnapshot != hydratedSnapshot)
+        #expect(baseProjection.visibleAccounts.first?.displayName == "user@example.com")
+        #expect(hydratedProjection.visibleAccounts.first?.displayName == "user@example.com — Team Alpha")
+    }
+
+    @Test
+    func `matching live system account does not duplicate stored identity`() {
+        let stored = ManagedCodexAccount(
+            id: UUID(),
+            email: "user@example.com",
+            managedHomePath: "/tmp/managed-a",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 3)
+        let accounts = ManagedCodexAccountSet(version: 1, accounts: [stored])
+        let live = ObservedSystemCodexAccount(
+            email: "USER@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        let reconciler = DefaultCodexAccountReconciler(
+            storeLoader: { accounts },
+            systemObserver: StubSystemObserver(account: live),
+            activeSource: .managedAccount(id: stored.id),
+            baseEnvironment: [:])
+
+        let projection = reconciler.loadVisibleAccounts()
+
+        #expect(projection.visibleAccounts.count == 1)
+        #expect(projection.activeVisibleAccountID == "user@example.com")
+        #expect(projection.liveVisibleAccountID == "user@example.com")
+    }
+
+    @Test
+    func `matching live system account prefers live workspace label and keeps stored fallback`() {
+        let stored = ManagedCodexAccount(
+            id: UUID(),
+            email: "user@example.com",
+            providerAccountID: "account-live",
+            workspaceLabel: "Saved Team",
+            workspaceAccountID: "account-live",
+            managedHomePath: "/tmp/managed-a",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 3)
+        let liveWithLabel = ObservedSystemCodexAccount(
+            email: "USER@example.com",
+            workspaceLabel: "Live Team",
+            workspaceAccountID: "account-live",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .providerAccount(id: "account-live"))
+        let labeledSnapshot = CodexAccountReconciliationSnapshot(
+            storedAccounts: [stored],
+            activeStoredAccount: stored,
+            liveSystemAccount: liveWithLabel,
+            matchingStoredAccountForLiveSystemAccount: stored,
+            activeSource: .managedAccount(id: stored.id),
+            hasUnreadableAddedAccountStore: false,
+            storedAccountRuntimeIdentities: [stored.id: .providerAccount(id: "account-live")],
+            storedAccountRuntimeEmails: [stored.id: "user@example.com"])
+        let liveWithoutLabel = ObservedSystemCodexAccount(
+            email: "USER@example.com",
+            workspaceLabel: nil,
+            workspaceAccountID: "account-live",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .providerAccount(id: "account-live"))
+        let fallbackSnapshot = CodexAccountReconciliationSnapshot(
+            storedAccounts: [stored],
+            activeStoredAccount: stored,
+            liveSystemAccount: liveWithoutLabel,
+            matchingStoredAccountForLiveSystemAccount: stored,
+            activeSource: .managedAccount(id: stored.id),
+            hasUnreadableAddedAccountStore: false,
+            storedAccountRuntimeIdentities: [stored.id: .providerAccount(id: "account-live")],
+            storedAccountRuntimeEmails: [stored.id: "user@example.com"])
+        let liveWithEmptyLabel = ObservedSystemCodexAccount(
+            email: "USER@example.com",
+            workspaceLabel: "   \n\t  ",
+            workspaceAccountID: "account-live",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .providerAccount(id: "account-live"))
+        let emptyLabelSnapshot = CodexAccountReconciliationSnapshot(
+            storedAccounts: [stored],
+            activeStoredAccount: stored,
+            liveSystemAccount: liveWithEmptyLabel,
+            matchingStoredAccountForLiveSystemAccount: stored,
+            activeSource: .managedAccount(id: stored.id),
+            hasUnreadableAddedAccountStore: false,
+            storedAccountRuntimeIdentities: [stored.id: .providerAccount(id: "account-live")],
+            storedAccountRuntimeEmails: [stored.id: "user@example.com"])
+
+        let labeledProjection = CodexVisibleAccountProjection.make(from: labeledSnapshot)
+        let fallbackProjection = CodexVisibleAccountProjection.make(from: fallbackSnapshot)
+        let emptyLabelProjection = CodexVisibleAccountProjection.make(from: emptyLabelSnapshot)
+
+        #expect(labeledProjection.visibleAccounts.count == 1)
+        #expect(labeledProjection.visibleAccounts.first?.workspaceLabel == "Live Team")
+        #expect(labeledProjection.visibleAccounts.first?.displayName == "user@example.com — Live Team")
+        #expect(fallbackProjection.visibleAccounts.count == 1)
+        #expect(fallbackProjection.visibleAccounts.first?.workspaceLabel == "Saved Team")
+        #expect(fallbackProjection.visibleAccounts.first?.displayName == "user@example.com — Saved Team")
+        #expect(emptyLabelProjection.visibleAccounts.count == 1)
+        #expect(emptyLabelProjection.visibleAccounts.first?.workspaceLabel == "Saved Team")
+        #expect(emptyLabelProjection.visibleAccounts.first?.displayName == "user@example.com — Saved Team")
+    }
+
+    @Test
+    func `matching live system account resolves merged row selection to live system`() {
+        let stored = ManagedCodexAccount(
+            id: UUID(),
+            email: "user@example.com",
+            managedHomePath: "/tmp/managed-a",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 3)
+        let live = ObservedSystemCodexAccount(
+            email: "USER@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        let snapshot = CodexAccountReconciliationSnapshot(
+            storedAccounts: [stored],
+            activeStoredAccount: stored,
+            liveSystemAccount: live,
+            matchingStoredAccountForLiveSystemAccount: stored,
+            activeSource: .managedAccount(id: stored.id),
+            hasUnreadableAddedAccountStore: false)
+
+        let resolution = CodexActiveSourceResolver.resolve(from: snapshot)
+        let projection = CodexVisibleAccountProjection.make(from: snapshot)
+
+        #expect(resolution.persistedSource == .managedAccount(id: stored.id))
+        #expect(resolution.resolvedSource == .liveSystem)
+        #expect(resolution.requiresPersistenceCorrection)
+        #expect(projection.activeVisibleAccountID == "user@example.com")
+        #expect(projection.source(forVisibleAccountID: "user@example.com") == .liveSystem)
+    }
+
+    @Test
+    func `provider account does not collapse with email only live account on same email`() throws {
+        let managedHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: managedHome) }
+        try Self.writeCodexAuthFile(
+            homeURL: managedHome,
+            email: "user@example.com",
+            plan: "pro",
+            accountID: "account-managed")
+
+        let stored = ManagedCodexAccount(
+            id: UUID(),
+            email: "user@example.com",
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 3)
+        let accounts = ManagedCodexAccountSet(version: 1, accounts: [stored])
+        let live = ObservedSystemCodexAccount(
+            email: "USER@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .emailOnly(normalizedEmail: "user@example.com"))
+        let reconciler = DefaultCodexAccountReconciler(
+            storeLoader: { accounts },
+            systemObserver: StubSystemObserver(account: live),
+            activeSource: .managedAccount(id: stored.id),
+            baseEnvironment: [:])
+
+        let snapshot = reconciler.loadSnapshot()
+        let resolution = CodexActiveSourceResolver.resolve(from: snapshot)
+        let projection = CodexVisibleAccountProjection.make(from: snapshot)
+
+        #expect(snapshot.matchingStoredAccountForLiveSystemAccount == nil)
+        #expect(resolution.resolvedSource == .managedAccount(id: stored.id))
+        #expect(projection.visibleAccounts.count == 2)
+        #expect(Set(projection.visibleAccounts.map(\.email)) == Set(["user@example.com"]))
+        #expect(Set(projection.visibleAccounts.map(\.id)).count == 2)
+        #expect(projection.activeVisibleAccountID == projection.visibleAccounts
+            .first { $0.selectionSource == .managedAccount(id: stored.id) }?.id)
+        #expect(projection.liveVisibleAccountID == projection.visibleAccounts
+            .first { $0.selectionSource == .liveSystem }?.id)
+    }
+
+    @Test
+    func `missing managed source resolves to live system when live account exists`() {
+        let live = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        let missingID = UUID()
+        let snapshot = CodexAccountReconciliationSnapshot(
+            storedAccounts: [],
+            activeStoredAccount: nil,
+            liveSystemAccount: live,
+            matchingStoredAccountForLiveSystemAccount: nil,
+            activeSource: .managedAccount(id: missingID),
+            hasUnreadableAddedAccountStore: false)
+
+        let resolution = CodexActiveSourceResolver.resolve(from: snapshot)
+
+        #expect(resolution.persistedSource == .managedAccount(id: missingID))
+        #expect(resolution.resolvedSource == .liveSystem)
+        #expect(resolution.requiresPersistenceCorrection)
+    }
+
+    @Test
+    func `unreadable managed source resolves to live system when live account exists`() {
+        let live = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        let unreadableID = UUID()
+        let snapshot = CodexAccountReconciliationSnapshot(
+            storedAccounts: [],
+            activeStoredAccount: nil,
+            liveSystemAccount: live,
+            matchingStoredAccountForLiveSystemAccount: nil,
+            activeSource: .managedAccount(id: unreadableID),
+            hasUnreadableAddedAccountStore: true)
+
+        let resolution = CodexActiveSourceResolver.resolve(from: snapshot)
+
+        #expect(resolution.persistedSource == .managedAccount(id: unreadableID))
+        #expect(resolution.resolvedSource == .liveSystem)
+        #expect(resolution.requiresPersistenceCorrection)
+    }
+
+    @Test
+    func `managed account remains active when active source stays managed while live account changes`() {
+        let managed = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-home",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 3)
+        let live = ObservedSystemCodexAccount(
+            email: "system@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        let projection = CodexVisibleAccountProjection.make(from: CodexAccountReconciliationSnapshot(
+            storedAccounts: [managed],
+            activeStoredAccount: managed,
+            liveSystemAccount: live,
+            matchingStoredAccountForLiveSystemAccount: nil,
+            activeSource: .managedAccount(id: managed.id),
+            hasUnreadableAddedAccountStore: false))
+
+        #expect(Set(projection.visibleAccounts.map(\.email)) == [
+            "managed@example.com",
+            "system@example.com",
+        ])
+        #expect(projection.activeVisibleAccountID == "managed@example.com")
+        #expect(projection.liveVisibleAccountID == "system@example.com")
+    }
+
+    @Test
+    func `live system account that differs from active stored account remains visible`() {
+        let active = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-a",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 3)
+        let accounts = ManagedCodexAccountSet(version: 1, accounts: [active])
+        let live = ObservedSystemCodexAccount(
+            email: "system@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        let reconciler = DefaultCodexAccountReconciler(
+            storeLoader: { accounts },
+            systemObserver: StubSystemObserver(account: live),
+            activeSource: .managedAccount(id: active.id),
+            baseEnvironment: [:])
+
+        let projection = reconciler.loadVisibleAccounts()
+
+        #expect(Set(projection.visibleAccounts.map(\.email)) == ["managed@example.com", "system@example.com"])
+        #expect(projection.activeVisibleAccountID == "managed@example.com")
+        #expect(projection.liveVisibleAccountID == "system@example.com")
+    }
+
+    @Test
+    func `inactive stored account still appears as visible`() {
+        let active = ManagedCodexAccount(
+            id: UUID(),
+            email: "active@example.com",
+            managedHomePath: "/tmp/managed-a",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 3)
+        let inactive = ManagedCodexAccount(
+            id: UUID(),
+            email: "inactive@example.com",
+            managedHomePath: "/tmp/managed-b",
+            createdAt: 4,
+            updatedAt: 5,
+            lastAuthenticatedAt: 6)
+        let accounts = ManagedCodexAccountSet(
+            version: 1,
+            accounts: [active, inactive])
+        let live = ObservedSystemCodexAccount(
+            email: "system@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        let reconciler = DefaultCodexAccountReconciler(
+            storeLoader: { accounts },
+            systemObserver: StubSystemObserver(account: live),
+            activeSource: .managedAccount(id: active.id),
+            baseEnvironment: [:])
+
+        let projection = reconciler.loadVisibleAccounts()
+
+        #expect(Set(projection.visibleAccounts.map(\.email)) == [
+            "active@example.com",
+            "inactive@example.com",
+            "system@example.com",
+        ])
+        #expect(projection.activeVisibleAccountID == "active@example.com")
+        #expect(projection.liveVisibleAccountID == "system@example.com")
+    }
+
+    @Test
+    func `unreadable account store still exposes live system account and degraded flag`() {
+        let live = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        let reconciler = DefaultCodexAccountReconciler(
+            storeLoader: { throw FileManagedCodexAccountStoreError.unsupportedVersion(999) },
+            systemObserver: StubSystemObserver(account: live),
+            baseEnvironment: [:])
+
+        let projection = reconciler.loadVisibleAccounts()
+
+        #expect(projection.visibleAccounts.map(\.email) == ["live@example.com"])
+        #expect(projection.activeVisibleAccountID == "live@example.com")
+        #expect(projection.liveVisibleAccountID == "live@example.com")
+        #expect(projection.hasUnreadableAddedAccountStore)
+    }
+
+    @Test
+    func `whitespace only live email is ignored`() {
+        let accounts = ManagedCodexAccountSet(version: 1, accounts: [])
+        let live = ObservedSystemCodexAccount(
+            email: "   \n\t  ",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        let reconciler = DefaultCodexAccountReconciler(
+            storeLoader: { accounts },
+            systemObserver: StubSystemObserver(account: live),
+            baseEnvironment: [:])
+
+        let projection = reconciler.loadVisibleAccounts()
+
+        #expect(projection.visibleAccounts.isEmpty)
+        #expect(projection.activeVisibleAccountID == nil)
+        #expect(projection.liveVisibleAccountID == nil)
+    }
+
+    @Test
+    @MainActor
+    func `settings store can override active source to live system`() throws {
+        let suite = "CodexAccountReconciliationTests-live-source-override"
+        let settings = try Self.makeSettings(suite: suite)
+        let managed = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-home",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 3)
+        let live = ObservedSystemCodexAccount(
+            email: "system@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        settings._test_activeManagedCodexAccount = managed
+        settings._test_liveSystemCodexAccount = live
+        settings.codexActiveSource = .liveSystem
+        defer {
+            settings._test_activeManagedCodexAccount = nil
+            settings._test_liveSystemCodexAccount = nil
+        }
+
+        let snapshot = settings.codexAccountReconciliationSnapshot
+        let projection = settings.codexVisibleAccountProjection
+
+        #expect(settings.codexActiveSource == .liveSystem)
+        #expect(snapshot.activeSource == .liveSystem)
+        #expect(projection.activeVisibleAccountID == "system@example.com")
+        #expect(projection.liveVisibleAccountID == "system@example.com")
+    }
+
+    @Test
+    @MainActor
+    func `selecting merged visible account persists live system source`() throws {
+        let suite = "CodexAccountReconciliationTests-select-merged-visible-account"
+        let settings = try Self.makeSettings(suite: suite)
+        let managed = ManagedCodexAccount(
+            id: UUID(),
+            email: "same@example.com",
+            managedHomePath: "/tmp/managed-home",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 3)
+        let live = ObservedSystemCodexAccount(
+            email: "SAME@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        settings._test_activeManagedCodexAccount = managed
+        settings._test_liveSystemCodexAccount = live
+        settings.codexActiveSource = .managedAccount(id: managed.id)
+        defer {
+            settings._test_activeManagedCodexAccount = nil
+            settings._test_liveSystemCodexAccount = nil
+        }
+
+        let didSelect = settings.selectCodexVisibleAccount(id: "same@example.com")
+
+        #expect(didSelect)
+        #expect(settings.codexActiveSource == .liveSystem)
+        #expect(settings.codexResolvedActiveSource == .liveSystem)
+    }
+
+    @Test
+    @MainActor
+    func `selecting authenticated managed account prefers live system when visible row is merged`() throws {
+        let suite = "CodexAccountReconciliationTests-select-authenticated-managed-merged"
+        let settings = try Self.makeSettings(suite: suite)
+        let managed = ManagedCodexAccount(
+            id: UUID(),
+            email: "same@example.com",
+            managedHomePath: "/tmp/managed-home",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 3)
+        let live = ObservedSystemCodexAccount(
+            email: "SAME@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        settings._test_activeManagedCodexAccount = managed
+        settings._test_liveSystemCodexAccount = live
+        settings.codexActiveSource = .managedAccount(id: UUID())
+        defer {
+            settings._test_activeManagedCodexAccount = nil
+            settings._test_liveSystemCodexAccount = nil
+        }
+
+        settings.selectAuthenticatedManagedCodexAccount(managed)
+
+        #expect(settings.codexActiveSource == .liveSystem)
+        #expect(settings.codexResolvedActiveSource == .liveSystem)
+    }
+
+    @Test
+    @MainActor
+    func `selecting authenticated managed account keeps managed source for split identity rows`() throws {
+        let suite = "CodexAccountReconciliationTests-select-authenticated-managed-split"
+        let settings = try Self.makeSettings(suite: suite)
+        let managedHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        let storeURL = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            settings._test_liveSystemCodexAccount = nil
+            try? FileManager.default.removeItem(at: managedHome)
+            try? FileManager.default.removeItem(at: storeURL)
+        }
+
+        try Self.writeCodexAuthFile(
+            homeURL: managedHome,
+            email: "same@example.com",
+            plan: "pro",
+            accountID: "account-managed")
+        let managed = ManagedCodexAccount(
+            id: UUID(),
+            email: "same@example.com",
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 3)
+        try Self.writeManagedCodexStore(
+            ManagedCodexAccountSet(version: FileManagedCodexAccountStore.currentVersion, accounts: [managed]),
+            to: storeURL)
+
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "SAME@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .emailOnly(normalizedEmail: "same@example.com"))
+        settings.codexActiveSource = .liveSystem
+
+        let projection = settings.codexVisibleAccountProjection
+        #expect(projection.visibleAccounts.count == 2)
+
+        settings.selectAuthenticatedManagedCodexAccount(managed)
+
+        #expect(settings.codexActiveSource == .managedAccount(id: managed.id))
+        #expect(settings.codexResolvedActiveSource == .managedAccount(id: managed.id))
+    }
+}
+
+private struct StubSystemObserver: CodexSystemAccountObserving {
+    let account: ObservedSystemCodexAccount?
+
+    func loadSystemAccount(environment _: [String: String]) throws -> ObservedSystemCodexAccount? {
+        self.account
+    }
+}
+
+extension CodexAccountReconciliationTests {
+    private static func writeManagedCodexStore(_ accounts: ManagedCodexAccountSet, to storeURL: URL) throws {
+        let store = FileManagedCodexAccountStore(fileURL: storeURL)
+        try store.storeAccounts(accounts)
+    }
+
+    private static func writeCodexAuthFile(
+        homeURL: URL,
+        email: String,
+        plan: String,
+        accountID: String? = nil) throws
+    {
+        try FileManager.default.createDirectory(at: homeURL, withIntermediateDirectories: true)
+        var tokens: [String: Any] = [
+            "accessToken": "access-token",
+            "refreshToken": "refresh-token",
+            "idToken": Self.fakeJWT(email: email, plan: plan, accountID: accountID),
+        ]
+        if let accountID {
+            tokens["account_id"] = accountID
+        }
+        let auth = ["tokens": tokens]
+        let data = try JSONSerialization.data(withJSONObject: auth)
+        try data.write(to: homeURL.appendingPathComponent("auth.json"))
+    }
+
+    private static func fakeJWT(email: String, plan: String, accountID: String? = nil) -> String {
+        let header = (try? JSONSerialization.data(withJSONObject: ["alg": "none"])) ?? Data()
+        var payloadObject: [String: Any] = [
+            "email": email,
+            "chatgpt_plan_type": plan,
+        ]
+        if let accountID {
+            payloadObject["https://api.openai.com/auth"] = [
+                "chatgpt_account_id": accountID,
+            ]
+        }
+        let payload = (try? JSONSerialization.data(withJSONObject: payloadObject)) ?? Data()
+
+        func base64URL(_ data: Data) -> String {
+            data.base64EncodedString()
+                .replacingOccurrences(of: "=", with: "")
+                .replacingOccurrences(of: "+", with: "-")
+                .replacingOccurrences(of: "/", with: "_")
+        }
+
+        return "\(base64URL(header)).\(base64URL(payload))."
+    }
+}
diff --git a/Tests/CodexBarTests/CodexAccountRefreshProjectionTests.swift b/Tests/CodexBarTests/CodexAccountRefreshProjectionTests.swift
new file mode 100644
index 0000000000..b1b5d837a0
--- /dev/null
+++ b/Tests/CodexBarTests/CodexAccountRefreshProjectionTests.swift
@@ -0,0 +1,239 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@MainActor
+extension CodexAccountScopedRefreshTests {
+    @Test
+    func `stale stacked projection collapse runs single codex fetch`() async throws {
+        SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = 60
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-stacked-collapse-single-fetch")
+        defer {
+            SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = nil
+            settings._test_liveSystemCodexAccount = nil
+            settings._test_managedCodexAccountStoreURL = nil
+        }
+        settings.refreshFrequency = .manual
+        settings.multiAccountMenuLayout = .stacked
+        settings.codexActiveSource = .liveSystem
+        settings._test_liveSystemCodexAccount = self.liveAccount(
+            email: "live-collapse@example.com",
+            identity: .providerAccount(id: "acct-live-collapse"))
+
+        let managedAccountID = try #require(UUID(uuidString: "DDDDDDDD-EEEE-FFFF-AAAA-191919191919"))
+        let managedAccount = ManagedCodexAccount(
+            id: managedAccountID,
+            email: "managed-collapse@example.com",
+            managedHomePath: "/tmp/codex-managed-collapse",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let staleStoreURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+        let emptyStoreURL = try self.makeManagedAccountStoreURL(accounts: [])
+        defer {
+            try? FileManager.default.removeItem(at: staleStoreURL)
+            try? FileManager.default.removeItem(at: emptyStoreURL)
+        }
+        settings._test_managedCodexAccountStoreURL = staleStoreURL
+        let staleReconciliationSnapshot = settings.codexAccountReconciliationSnapshot
+        #expect(CodexVisibleAccountProjection.make(from: staleReconciliationSnapshot).visibleAccounts.count == 2)
+
+        settings._test_managedCodexAccountStoreURL = emptyStoreURL
+        settings.cachedCodexAccountReconciliationSnapshot = CachedCodexAccountReconciliationSnapshot(
+            activeSource: .liveSystem,
+            loadedAt: Date(),
+            snapshot: staleReconciliationSnapshot)
+
+        let store = self.makeUsageStore(settings: settings)
+        self.installImmediateCodexProvider(
+            on: store,
+            snapshot: self.codexSnapshot(email: "live-collapse@example.com", usedPercent: 42))
+
+        await store.refreshProvider(.codex, allowDisabled: true)
+
+        #expect(store.snapshots[.codex]?.primary?.usedPercent == 42)
+        #expect(store.codexAccountSnapshots.isEmpty)
+    }
+
+    @Test
+    func `stacked visible refresh discards selected success after managed auth file is removed`() async throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-selected-managed-auth-file-removed")
+        settings.refreshFrequency = .manual
+        settings.multiAccountMenuLayout = .stacked
+
+        let targetID = try #require(UUID(uuidString: "DDDDDDDD-EEEE-FFFF-AAAA-202020202020"))
+        let siblingID = try #require(UUID(uuidString: "DDDDDDDD-EEEE-FFFF-AAAA-212121212121"))
+        let targetHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-managed-auth-removed-\(UUID().uuidString)", isDirectory: true)
+        let siblingHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent(
+                "codex-visible-managed-auth-removed-sibling-\(UUID().uuidString)",
+                isDirectory: true)
+        try Self.writeCodexAuthFile(
+            homeURL: targetHome,
+            email: "managed-removed@example.com",
+            plan: "Pro",
+            accountId: "acct-managed-removed")
+        let oldFingerprint = try #require(CodexAuthFingerprint.fingerprint(homePath: targetHome.path))
+        let targetAccount = ManagedCodexAccount(
+            id: targetID,
+            email: "managed-removed@example.com",
+            providerAccountID: "acct-managed-removed",
+            workspaceLabel: "Managed Team",
+            workspaceAccountID: "acct-managed-removed",
+            authFingerprint: oldFingerprint,
+            managedHomePath: targetHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let siblingAccount = ManagedCodexAccount(
+            id: siblingID,
+            email: "managed-removed-sibling@example.com",
+            providerAccountID: "acct-managed-removed-sibling",
+            workspaceLabel: "Sibling Team",
+            workspaceAccountID: "acct-managed-removed-sibling",
+            authFingerprint: "sibling-managed-removed",
+            managedHomePath: siblingHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [targetAccount, siblingAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            try? FileManager.default.removeItem(at: storeURL)
+            try? FileManager.default.removeItem(at: targetHome)
+            try? FileManager.default.removeItem(at: siblingHome)
+        }
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .managedAccount(id: targetID)
+
+        let snapshotStore = RecordingCodexAccountUsageSnapshotStore(initialSnapshots: [])
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            codexAccountUsageSnapshotStore: snapshotStore,
+            startupBehavior: .testing)
+        let blocker = BlockingCodexFetchStrategy()
+        let targetHomePath = targetHome.path
+        let now = Date()
+        self.installContextualCodexProvider(on: store) { context in
+            if context.env["CODEX_HOME"] == targetHomePath {
+                return try await blocker.awaitResult()
+            }
+            return UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 9,
+                    windowMinutes: 300,
+                    resetsAt: nil,
+                    resetDescription: nil),
+                secondary: nil,
+                updatedAt: now,
+                identity: ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: "managed-removed-sibling@example.com",
+                    accountOrganization: nil,
+                    loginMethod: "Sibling Team"))
+        }
+
+        let refreshTask = Task { await store.refreshCodexVisibleAccountsForMenu() }
+        await blocker.waitUntilStarted()
+        try FileManager.default.removeItem(at: targetHome)
+        await blocker.resume(with: .success(self.codexSnapshot(email: "managed-removed@example.com", usedPercent: 44)))
+        await refreshTask.value
+
+        #expect(store.snapshots[.codex] == nil)
+        #expect(store.errors[.codex] == nil)
+        #expect(!store.codexAccountSnapshots.contains {
+            $0.account.workspaceAccountID == "acct-managed-removed"
+        })
+        #expect(!snapshotStore.storedSnapshots.contains {
+            $0.account.workspaceAccountID == "acct-managed-removed"
+        })
+    }
+
+    @Test
+    func `startup snapshot hydration refreshes managed auth fingerprint from disk`() throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-startup-managed-auth-hydration")
+        settings.refreshFrequency = .manual
+        settings.multiAccountMenuLayout = .stacked
+
+        let accountID = try #require(UUID(uuidString: "DDDDDDDD-EEEE-FFFF-AAAA-222222222222"))
+        let managedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-managed-startup-\(UUID().uuidString)", isDirectory: true)
+        try Self.writeCodexAuthFile(
+            homeURL: managedHome,
+            email: "managed-startup@example.com",
+            plan: "Pro")
+        let oldFingerprint = try #require(CodexAuthFingerprint.fingerprint(homePath: managedHome.path))
+        let managedAccount = ManagedCodexAccount(
+            id: accountID,
+            email: "managed-startup@example.com",
+            authFingerprint: oldFingerprint,
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+        let snapshotURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-managed-startup-\(UUID().uuidString).json")
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            try? FileManager.default.removeItem(at: storeURL)
+            try? FileManager.default.removeItem(at: snapshotURL)
+            try? FileManager.default.removeItem(at: managedHome)
+        }
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .managedAccount(id: accountID)
+
+        let staleAccount = try #require(settings.codexVisibleAccountProjection.visibleAccounts
+            .first { $0.storedAccountID == accountID })
+        #expect(staleAccount.authFingerprint == oldFingerprint)
+
+        try Self.writeCodexAuthFile(
+            homeURL: managedHome,
+            email: "managed-startup@example.com",
+            plan: "Team")
+        let newFingerprint = try #require(CodexAuthFingerprint.fingerprint(homePath: managedHome.path))
+        #expect(newFingerprint != oldFingerprint)
+
+        let freshAccount = CodexVisibleAccount(
+            id: staleAccount.id,
+            email: staleAccount.email,
+            workspaceLabel: staleAccount.workspaceLabel,
+            workspaceAccountID: staleAccount.workspaceAccountID,
+            authFingerprint: newFingerprint,
+            storedAccountID: staleAccount.storedAccountID,
+            selectionSource: staleAccount.selectionSource,
+            isActive: staleAccount.isActive,
+            isLive: staleAccount.isLive,
+            canReauthenticate: staleAccount.canReauthenticate,
+            canRemove: staleAccount.canRemove)
+        let snapshotStore = FileCodexAccountUsageSnapshotStore(fileURL: snapshotURL)
+        snapshotStore.store([
+            CodexAccountUsageSnapshot(
+                account: freshAccount,
+                snapshot: self.codexSnapshot(email: freshAccount.email, usedPercent: 64),
+                error: nil,
+                sourceLabel: "cached"),
+        ])
+        #expect(snapshotStore.load(for: [staleAccount]).isEmpty)
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            codexAccountUsageSnapshotStore: snapshotStore,
+            startupBehavior: .testing)
+
+        let hydrated = try #require(store.codexAccountSnapshots.first)
+        #expect(store.codexAccountSnapshots.count == 1)
+        #expect(hydrated.id == freshAccount.id)
+        #expect(hydrated.account.authFingerprint == newFingerprint)
+        #expect(hydrated.snapshot?.primary?.usedPercent == 64)
+    }
+}
diff --git a/Tests/CodexBarTests/CodexAccountScopedRefreshCreditsTests.swift b/Tests/CodexBarTests/CodexAccountScopedRefreshCreditsTests.swift
new file mode 100644
index 0000000000..97a8aaad57
--- /dev/null
+++ b/Tests/CodexBarTests/CodexAccountScopedRefreshCreditsTests.swift
@@ -0,0 +1,93 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+extension CodexAccountScopedRefreshTests {
+    @Test
+    func `credits refresh honors explicit codex oauth source without raw CLI fallback`() async throws {
+        let settings = self.makeSettingsStore(suite: "CodexAccountScopedRefreshTests-oauth-credits-source")
+        settings.refreshFrequency = .manual
+        settings.codexUsageDataSource = .oauth
+        settings._test_liveSystemCodexAccount = self.liveAccount(email: "alpha@example.com")
+
+        let store = self.makeUsageStore(
+            settings: settings,
+            environmentBase: ["CODEX_CLI_PATH": "/missing/codex"])
+        let usage = self.codexSnapshot(email: "alpha@example.com", usedPercent: 10)
+        store._setSnapshotForTesting(usage, provider: .codex)
+
+        let oauthStrategy = TestCodexFetchStrategy(
+            loader: { usage },
+            credits: self.credits(remaining: 77),
+            id: "codex.oauth",
+            kind: .oauth,
+            sourceLabel: "codex.oauth")
+        let cliStrategy = ThrowingTestCodexFetchStrategy {
+            throw TestRefreshError(message: "CLI strategy should not run for explicit OAuth credits refresh")
+        }
+        let baseSpec = try #require(store.providerSpecs[.codex])
+        store.providerSpecs[.codex] = Self.makeCodexProviderSpec(baseSpec: baseSpec) { context in
+            switch context.sourceMode {
+            case .oauth:
+                [oauthStrategy]
+            case .cli:
+                [cliStrategy]
+            case .auto:
+                [oauthStrategy, cliStrategy]
+            case .web, .api:
+                []
+            }
+        }
+
+        await store.refreshCreditsIfNeeded()
+
+        #expect(store.credits?.remaining == 77)
+        #expect(store.lastCreditsError == nil)
+        #expect(store.lastCreditsSource == .api)
+    }
+
+    @Test
+    func `auto credits refresh falls back when oauth usage omits credits`() async throws {
+        let settings = self.makeSettingsStore(suite: "CodexAccountScopedRefreshTests-auto-credits-fallback")
+        settings.refreshFrequency = .manual
+        settings.codexUsageDataSource = .auto
+        settings._test_liveSystemCodexAccount = self.liveAccount(email: "alpha@example.com")
+
+        let store = self.makeUsageStore(settings: settings)
+        let usage = self.codexSnapshot(email: "alpha@example.com", usedPercent: 10)
+        store._setSnapshotForTesting(usage, provider: .codex)
+
+        let oauthStrategy = TestCodexFetchStrategy(
+            loader: { usage },
+            credits: nil,
+            id: "codex.oauth",
+            kind: .oauth,
+            sourceLabel: "codex.oauth")
+        let cliStrategy = TestCodexFetchStrategy(
+            loader: { usage },
+            credits: self.credits(remaining: 41),
+            id: "codex.cli",
+            kind: .cli,
+            sourceLabel: "codex.cli")
+        let baseSpec = try #require(store.providerSpecs[.codex])
+        store.providerSpecs[.codex] = Self.makeCodexProviderSpec(baseSpec: baseSpec) { context in
+            switch context.sourceMode {
+            case .auto:
+                [oauthStrategy, cliStrategy]
+            case .oauth:
+                [oauthStrategy]
+            case .cli:
+                [cliStrategy]
+            case .web, .api:
+                []
+            }
+        }
+
+        await store.refreshCreditsIfNeeded()
+
+        #expect(store.credits?.remaining == 41)
+        #expect(store.lastCreditsError == nil)
+        #expect(store.lastCreditsSource == .api)
+    }
+}
diff --git a/Tests/CodexBarTests/CodexAccountScopedRefreshDashboardCleanupTests.swift b/Tests/CodexBarTests/CodexAccountScopedRefreshDashboardCleanupTests.swift
new file mode 100644
index 0000000000..719b07c97f
--- /dev/null
+++ b/Tests/CodexBarTests/CodexAccountScopedRefreshDashboardCleanupTests.swift
@@ -0,0 +1,273 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+extension CodexAccountScopedRefreshTests {
+    @Test
+    func `dashboard refresh accepted via unresolved routing fallback during account scoped refresh`() async throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-dashboard-unresolved-routing-fallback")
+        let isolatedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-dashboard-unresolved-routing-\(UUID().uuidString)", isDirectory: true)
+        try? FileManager.default.createDirectory(at: isolatedHome, withIntermediateDirectories: true)
+        let codexMetadata = try #require(ProviderDescriptorRegistry.metadata[.codex])
+        settings.refreshFrequency = .manual
+        settings.setProviderEnabled(provider: .codex, metadata: codexMetadata, enabled: true)
+        settings.openAIWebAccessEnabled = true
+        settings.codexCookieSource = .auto
+        settings.codexActiveSource = .liveSystem
+        settings._test_liveSystemCodexAccount = nil
+        settings._test_codexReconciliationEnvironment = ["CODEX_HOME": isolatedHome.path]
+        defer {
+            settings._test_codexReconciliationEnvironment = nil
+            try? FileManager.default.removeItem(at: isolatedHome)
+        }
+
+        let store = self.makeUsageStore(settings: settings)
+        store.lastKnownLiveSystemCodexEmail = nil
+        self.installImmediateCodexProvider(
+            on: store,
+            snapshot: self.codexSnapshot(email: "work@company.com", usedPercent: 12))
+        store._test_codexCreditsLoaderOverride = { self.credits(remaining: 55) }
+        defer { store._test_codexCreditsLoaderOverride = nil }
+
+        var observedTargetEmail: String?
+        store._test_openAIDashboardLoaderOverride = { accountEmail, _, _, _ in
+            observedTargetEmail = accountEmail
+            #expect(store.currentCodexOpenAIWebRefreshGuard().source == .liveSystem)
+            #expect(store.currentCodexOpenAIWebRefreshGuard().identity == .unresolved)
+            return self.dashboard(email: "work@company.com", creditsRemaining: 33, usedPercent: 12)
+        }
+        defer { store._test_openAIDashboardLoaderOverride = nil }
+
+        await store.refreshCodexAccountScopedState(allowDisabled: true)
+
+        #expect(observedTargetEmail == "work@company.com")
+        #expect(store.currentCodexOpenAIWebRefreshGuard().identity == .unresolved)
+        #expect(store.openAIDashboard?.signedInEmail == "work@company.com")
+        #expect(store.lastOpenAIDashboardSnapshot?.signedInEmail == "work@company.com")
+        #expect(store.openAIDashboardRequiresLogin == false)
+        #expect(store.lastOpenAIDashboardError == nil)
+        #expect(store.snapshots[.codex]?.accountEmail(for: .codex) == "work@company.com")
+        #expect(store.lastSourceLabels[.codex] == "test-codex")
+        #expect(store.credits?.remaining == 55)
+        #expect(store.lastCreditsSource == .api)
+    }
+
+    @Test
+    func `dashboard fail closed clears dashboard derived usage credits cache and visible dashboard`() async throws {
+        OpenAIDashboardCacheStore.clear()
+        defer { OpenAIDashboardCacheStore.clear() }
+
+        let settings = self.makeSettingsStore(suite: "CodexAccountScopedRefreshTests-dashboard-fail-closed-cleanup")
+        let managedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: managedHome) }
+        try Self.writeCodexAuthFile(
+            homeURL: managedHome,
+            email: "managed@example.com",
+            plan: "pro",
+            accountId: "acct-managed")
+
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let managedStoreURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            settings._test_activeManagedCodexAccount = nil
+            try? FileManager.default.removeItem(at: managedStoreURL)
+        }
+
+        settings.refreshFrequency = .manual
+        settings.codexCookieSource = .auto
+        settings._test_managedCodexAccountStoreURL = managedStoreURL
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+
+        let store = self.makeUsageStore(settings: settings)
+        store._setSnapshotForTesting(
+            self.codexSnapshot(email: "managed@example.com", usedPercent: 20),
+            provider: .codex)
+        store.lastSourceLabels[.codex] = "openai-web"
+        let staleCredits = self.credits(remaining: 20)
+        store.credits = staleCredits
+        store.lastCreditsSnapshot = staleCredits
+        store.lastCreditsSnapshotAccountKey = "managed@example.com"
+        store.lastCreditsSource = .dashboardWeb
+        store.openAIDashboard = self.dashboard(email: "managed@example.com", creditsRemaining: 20, usedPercent: 20)
+        store.lastOpenAIDashboardSnapshot = store.openAIDashboard
+        OpenAIDashboardCacheStore.save(OpenAIDashboardCache(
+            accountEmail: "managed@example.com",
+            snapshot: self.dashboard(email: "managed@example.com", creditsRemaining: 20, usedPercent: 20)))
+
+        await store.applyOpenAIDashboard(
+            self.dashboard(email: "other@example.com", creditsRemaining: 9, usedPercent: 35),
+            targetEmail: "managed@example.com")
+
+        #expect(store.openAIDashboard == nil)
+        #expect(store.lastOpenAIDashboardSnapshot == nil)
+        #expect(store.snapshots[.codex] == nil)
+        #expect(store.credits == nil)
+        #expect(store.lastCreditsSource == .none)
+        #expect(OpenAIDashboardCacheStore.load() == nil)
+        #expect(store.openAIDashboardRequiresLogin == true)
+        #expect(store.lastOpenAIDashboardError?.contains("OpenAI dashboard signed in as other@example.com") == true)
+    }
+
+    @Test
+    func `dashboard fail closed cleanup applies after same account managed token rotation`() async throws {
+        OpenAIDashboardCacheStore.clear()
+        defer { OpenAIDashboardCacheStore.clear() }
+
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-dashboard-fail-closed-token-rotation-cleanup")
+        let managedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: managedHome) }
+        try Self.writeCodexAuthFile(
+            homeURL: managedHome,
+            email: "managed@example.com",
+            plan: "pro",
+            accountId: "acct-managed")
+        let oldFingerprint = try #require(CodexAuthFingerprint.fingerprint(homePath: managedHome.path))
+
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            providerAccountID: "acct-managed",
+            workspaceLabel: "Managed",
+            workspaceAccountID: "acct-managed",
+            authFingerprint: oldFingerprint,
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let managedStoreURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            settings._test_activeManagedCodexAccount = nil
+            try? FileManager.default.removeItem(at: managedStoreURL)
+        }
+
+        settings.refreshFrequency = .manual
+        settings.codexCookieSource = .auto
+        settings._test_managedCodexAccountStoreURL = managedStoreURL
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+
+        let store = self.makeUsageStore(settings: settings)
+        let expectedGuard = store.freshCodexOpenAIWebRefreshGuard()
+        #expect(expectedGuard.authFingerprint == oldFingerprint)
+        store._setSnapshotForTesting(
+            self.codexSnapshot(email: "managed@example.com", usedPercent: 20),
+            provider: .codex)
+        store.lastSourceLabels[.codex] = "openai-web"
+        let staleCredits = self.credits(remaining: 20)
+        store.credits = staleCredits
+        store.lastCreditsSnapshot = staleCredits
+        store.lastCreditsSnapshotAccountKey = "managed@example.com"
+        store.lastCreditsSource = .dashboardWeb
+        store.openAIDashboard = self.dashboard(email: "managed@example.com", creditsRemaining: 20, usedPercent: 20)
+        store.lastOpenAIDashboardSnapshot = store.openAIDashboard
+        OpenAIDashboardCacheStore.save(OpenAIDashboardCache(
+            accountEmail: "managed@example.com",
+            snapshot: self.dashboard(email: "managed@example.com", creditsRemaining: 20, usedPercent: 20)))
+
+        try Self.writeCodexAuthFile(
+            homeURL: managedHome,
+            email: "managed@example.com",
+            plan: "team",
+            accountId: "acct-managed")
+        let newFingerprint = try #require(CodexAuthFingerprint.fingerprint(homePath: managedHome.path))
+        #expect(newFingerprint != oldFingerprint)
+        let currentGuard = store.freshCodexOpenAIWebRefreshGuard()
+        #expect(currentGuard.identity == expectedGuard.identity)
+        #expect(currentGuard.accountKey == expectedGuard.accountKey)
+        #expect(currentGuard.authFingerprint == newFingerprint)
+
+        await store.applyOpenAIDashboard(
+            self.dashboard(email: "other@example.com", creditsRemaining: 9, usedPercent: 35),
+            targetEmail: "managed@example.com",
+            expectedGuard: expectedGuard)
+
+        #expect(store.openAIDashboard == nil)
+        #expect(store.lastOpenAIDashboardSnapshot == nil)
+        #expect(store.snapshots[.codex] == nil)
+        #expect(store.credits == nil)
+        #expect(store.lastCreditsSource == .none)
+        #expect(OpenAIDashboardCacheStore.load() == nil)
+        #expect(store.openAIDashboardRequiresLogin == true)
+        #expect(store.lastOpenAIDashboardError?.contains("OpenAI dashboard signed in as other@example.com") == true)
+    }
+
+    @Test
+    func `dashboard fail closed cleanup applies after same live account email changes during token rotation`() async {
+        OpenAIDashboardCacheStore.clear()
+        defer { OpenAIDashboardCacheStore.clear() }
+
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-dashboard-fail-closed-live-email-rotation-cleanup")
+        settings.refreshFrequency = .manual
+        settings.codexCookieSource = .auto
+        settings.codexActiveSource = .liveSystem
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "alpha@example.com",
+            authFingerprint: "old-token-material",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .providerAccount(id: "acct-alpha"))
+        defer {
+            settings._test_liveSystemCodexAccount = nil
+        }
+
+        let store = self.makeUsageStore(settings: settings)
+        let expectedGuard = store.freshCodexOpenAIWebRefreshGuard()
+        #expect(expectedGuard.accountKey == "alpha@example.com")
+        #expect(expectedGuard.authFingerprint == "old-token-material")
+        store._setSnapshotForTesting(
+            self.codexSnapshot(email: "alpha@example.com", usedPercent: 20),
+            provider: .codex)
+        store.lastSourceLabels[.codex] = "openai-web"
+        let staleCredits = self.credits(remaining: 20)
+        store.credits = staleCredits
+        store.lastCreditsSnapshot = staleCredits
+        store.lastCreditsSnapshotAccountKey = "alpha@example.com"
+        store.lastCreditsSource = .dashboardWeb
+        store.openAIDashboard = self.dashboard(email: "alpha@example.com", creditsRemaining: 20, usedPercent: 20)
+        store.lastOpenAIDashboardSnapshot = store.openAIDashboard
+        OpenAIDashboardCacheStore.save(OpenAIDashboardCache(
+            accountEmail: "alpha@example.com",
+            snapshot: self.dashboard(email: "alpha@example.com", creditsRemaining: 20, usedPercent: 20)))
+
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "beta@example.com",
+            authFingerprint: "new-token-material",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .providerAccount(id: "acct-alpha"))
+        let currentGuard = store.freshCodexOpenAIWebRefreshGuard()
+        #expect(currentGuard.identity == expectedGuard.identity)
+        #expect(currentGuard.accountKey == "beta@example.com")
+        #expect(currentGuard.authFingerprint == "new-token-material")
+
+        await store.applyOpenAIDashboard(
+            self.dashboard(email: "alpha@example.com", creditsRemaining: 9, usedPercent: 35),
+            targetEmail: "alpha@example.com",
+            expectedGuard: expectedGuard)
+
+        #expect(store.openAIDashboard == nil)
+        #expect(store.lastOpenAIDashboardSnapshot == nil)
+        #expect(store.snapshots[.codex] == nil)
+        #expect(store.credits == nil)
+        #expect(store.lastCreditsSource == .none)
+        #expect(OpenAIDashboardCacheStore.load() == nil)
+        #expect(store.openAIDashboardRequiresLogin == true)
+        #expect(store.lastOpenAIDashboardError?.contains("OpenAI dashboard signed in as alpha@example.com") == true)
+    }
+}
diff --git a/Tests/CodexBarTests/CodexAccountScopedRefreshTestSupport.swift b/Tests/CodexBarTests/CodexAccountScopedRefreshTestSupport.swift
new file mode 100644
index 0000000000..48e114c133
--- /dev/null
+++ b/Tests/CodexBarTests/CodexAccountScopedRefreshTestSupport.swift
@@ -0,0 +1,513 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+extension CodexAccountScopedRefreshTests {
+    func makeSettingsStore(suite: String) -> SettingsStore {
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        defaults.set(true, forKey: "providerDetectionCompleted")
+        let configStore = testConfigStore(suiteName: suite)
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings._test_activeManagedCodexAccount = nil
+        settings._test_activeManagedCodexRemoteHomePath = nil
+        settings._test_unreadableManagedCodexAccountStore = false
+        settings._test_managedCodexAccountStoreURL = nil
+        settings._test_liveSystemCodexAccount = nil
+        settings._test_codexReconciliationEnvironment = nil
+        settings.providerDetectionCompleted = true
+        return settings
+    }
+
+    static func writeCodexAuthFile(
+        homeURL: URL,
+        email: String,
+        plan: String,
+        accountId: String? = nil) throws
+    {
+        try FileManager.default.createDirectory(at: homeURL, withIntermediateDirectories: true)
+        var tokens: [String: Any] = [
+            "accessToken": "access-token",
+            "refreshToken": "refresh-token",
+            "idToken": Self.fakeJWT(email: email, plan: plan, accountId: accountId),
+        ]
+        if let accountId {
+            tokens["accountId"] = accountId
+        }
+        let data = try JSONSerialization.data(withJSONObject: ["tokens": tokens], options: [.sortedKeys])
+        try data.write(to: homeURL.appendingPathComponent("auth.json"))
+    }
+
+    static func fakeJWT(email: String, plan: String, accountId: String? = nil) -> String {
+        let header = (try? JSONSerialization.data(withJSONObject: ["alg": "none"])) ?? Data()
+        var authClaims: [String: Any] = [
+            "chatgpt_plan_type": plan,
+        ]
+        if let accountId {
+            authClaims["chatgpt_account_id"] = accountId
+        }
+        let payload = (try? JSONSerialization.data(withJSONObject: [
+            "email": email,
+            "chatgpt_plan_type": plan,
+            "https://api.openai.com/auth": authClaims,
+        ])) ?? Data()
+
+        func base64URL(_ data: Data) -> String {
+            data.base64EncodedString()
+                .replacingOccurrences(of: "=", with: "")
+                .replacingOccurrences(of: "+", with: "-")
+                .replacingOccurrences(of: "/", with: "_")
+        }
+
+        return "\(base64URL(header)).\(base64URL(payload))."
+    }
+
+    func makeUsageStore(settings: SettingsStore, environmentBase: [String: String] = [:]) -> UsageStore {
+        UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing,
+            environmentBase: environmentBase)
+    }
+
+    func liveAccount(email: String, identity: CodexIdentity = .unresolved) -> ObservedSystemCodexAccount {
+        ObservedSystemCodexAccount(
+            email: email,
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: identity)
+    }
+
+    func codexSnapshot(email: String, usedPercent: Double) -> UsageSnapshot {
+        UsageSnapshot(
+            primary: RateWindow(usedPercent: usedPercent, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: email,
+                accountOrganization: nil,
+                loginMethod: "Pro"))
+    }
+
+    func credits(remaining: Double) -> CreditsSnapshot {
+        CreditsSnapshot(remaining: remaining, events: [], updatedAt: Date())
+    }
+
+    func dashboard(email: String, creditsRemaining: Double, usedPercent: Double) -> OpenAIDashboardSnapshot {
+        OpenAIDashboardSnapshot(
+            signedInEmail: email,
+            codeReviewRemainingPercent: 88,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            primaryLimit: RateWindow(
+                usedPercent: usedPercent,
+                windowMinutes: 300,
+                resetsAt: nil,
+                resetDescription: nil),
+            secondaryLimit: nil,
+            creditsRemaining: creditsRemaining,
+            accountPlan: "Pro",
+            updatedAt: Date())
+    }
+
+    func makeManagedAccountStoreURL(accounts: [ManagedCodexAccount]) throws -> URL {
+        let storeURL = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        let store = FileManagedCodexAccountStore(fileURL: storeURL)
+        try store.storeAccounts(ManagedCodexAccountSet(
+            version: FileManagedCodexAccountStore.currentVersion,
+            accounts: accounts))
+        return storeURL
+    }
+
+    @MainActor
+    func withCodexVisibleAccountFailureStore(
+        suite: String,
+        errorMessage: String,
+        body: (UsageStore, RecordingCodexAccountUsageSnapshotStore, [CodexAccountUsageSnapshot]) async throws -> Void)
+        async throws
+    {
+        let settings = self.makeSettingsStore(suite: suite)
+        settings.refreshFrequency = .manual
+        settings.multiAccountMenuLayout = .stacked
+        settings._test_liveSystemCodexAccount = self.liveAccount(email: "live@example.com")
+        settings.codexActiveSource = .liveSystem
+
+        let managedAccountID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-111111111111"))
+        let managedAccount = ManagedCodexAccount(
+            id: managedAccountID,
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-home",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            settings._test_liveSystemCodexAccount = nil
+            try? FileManager.default.removeItem(at: storeURL)
+        }
+        settings._test_managedCodexAccountStoreURL = storeURL
+
+        let priorSnapshots = settings.codexVisibleAccountProjection.visibleAccounts.map { account in
+            CodexAccountUsageSnapshot(
+                account: account,
+                snapshot: self.codexSnapshot(email: account.email, usedPercent: 17),
+                error: nil,
+                sourceLabel: "cached")
+        }
+        let snapshotStore = RecordingCodexAccountUsageSnapshotStore(initialSnapshots: priorSnapshots)
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            codexAccountUsageSnapshotStore: snapshotStore,
+            startupBehavior: .testing)
+        self.installFailingCodexProvider(
+            on: store,
+            error: TestRefreshError(message: errorMessage))
+
+        try await body(store, snapshotStore, priorSnapshots)
+    }
+
+    func installBlockingCodexProvider(on store: UsageStore, blocker: BlockingCodexFetchStrategy) {
+        let baseSpec = store.providerSpecs[.codex]!
+        store.providerSpecs[.codex] = Self.makeCodexProviderSpec(baseSpec: baseSpec) {
+            try await blocker.awaitResult()
+        }
+    }
+
+    func installImmediateCodexProvider(on store: UsageStore, snapshot: UsageSnapshot) {
+        let baseSpec = store.providerSpecs[.codex]!
+        store.providerSpecs[.codex] = Self.makeCodexProviderSpec(baseSpec: baseSpec) {
+            snapshot
+        }
+    }
+
+    func installFailingCodexProvider(on store: UsageStore, error: Error) {
+        let baseSpec = store.providerSpecs[.codex]!
+        store.providerSpecs[.codex] = Self.makeThrowingCodexProviderSpec(baseSpec: baseSpec) {
+            throw error
+        }
+    }
+
+    func installContextualCodexProvider(
+        on store: UsageStore,
+        loader: @escaping @Sendable (ProviderFetchContext) async throws -> UsageSnapshot)
+    {
+        let baseSpec = store.providerSpecs[.codex]!
+        store.providerSpecs[.codex] = Self.makeCodexProviderSpec(baseSpec: baseSpec) { _ in
+            [ContextualTestCodexFetchStrategy(loader: loader, sourceLabel: "test-codex")]
+        }
+    }
+
+    static func makeCodexProviderSpec(
+        baseSpec: ProviderSpec,
+        loader: @escaping @Sendable () async throws -> UsageSnapshot) -> ProviderSpec
+    {
+        let baseDescriptor = baseSpec.descriptor
+        let strategy = TestCodexFetchStrategy(loader: loader)
+        let descriptor = ProviderDescriptor(
+            id: .codex,
+            metadata: baseDescriptor.metadata,
+            branding: baseDescriptor.branding,
+            tokenCost: baseDescriptor.tokenCost,
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .cli, .oauth],
+                pipeline: ProviderFetchPipeline { _ in [strategy] }),
+            cli: baseDescriptor.cli)
+        return ProviderSpec(
+            style: baseSpec.style,
+            isEnabled: baseSpec.isEnabled,
+            descriptor: descriptor,
+            makeFetchContext: baseSpec.makeFetchContext)
+    }
+
+    static func makeThrowingCodexProviderSpec(
+        baseSpec: ProviderSpec,
+        loader: @escaping @Sendable () async throws -> UsageSnapshot) -> ProviderSpec
+    {
+        let baseDescriptor = baseSpec.descriptor
+        let strategy = ThrowingTestCodexFetchStrategy(loader: loader)
+        let descriptor = ProviderDescriptor(
+            id: .codex,
+            metadata: baseDescriptor.metadata,
+            branding: baseDescriptor.branding,
+            tokenCost: baseDescriptor.tokenCost,
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .cli, .oauth],
+                pipeline: ProviderFetchPipeline { _ in [strategy] }),
+            cli: baseDescriptor.cli)
+        return ProviderSpec(
+            style: baseSpec.style,
+            isEnabled: baseSpec.isEnabled,
+            descriptor: descriptor,
+            makeFetchContext: baseSpec.makeFetchContext)
+    }
+
+    static func makeCodexProviderSpec(
+        baseSpec: ProviderSpec,
+        resolveStrategies: @escaping @Sendable (ProviderFetchContext) async -> [any ProviderFetchStrategy])
+        -> ProviderSpec
+    {
+        let baseDescriptor = baseSpec.descriptor
+        let descriptor = ProviderDescriptor(
+            id: .codex,
+            metadata: baseDescriptor.metadata,
+            branding: baseDescriptor.branding,
+            tokenCost: baseDescriptor.tokenCost,
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .cli, .oauth],
+                pipeline: ProviderFetchPipeline(resolveStrategies: resolveStrategies)),
+            cli: baseDescriptor.cli)
+        return ProviderSpec(
+            style: baseSpec.style,
+            isEnabled: baseSpec.isEnabled,
+            descriptor: descriptor,
+            makeFetchContext: baseSpec.makeFetchContext)
+    }
+}
+
+struct TestRefreshError: LocalizedError, Equatable {
+    let message: String
+
+    var errorDescription: String? {
+        self.message
+    }
+}
+
+final class RecordingCodexAccountUsageSnapshotStore: CodexAccountUsageSnapshotStoring, @unchecked Sendable {
+    private let lock = NSLock()
+    private var loadedSnapshots: [CodexAccountUsageSnapshot]
+    private var snapshotsStored: [CodexAccountUsageSnapshot] = []
+
+    init(initialSnapshots: [CodexAccountUsageSnapshot]) {
+        self.loadedSnapshots = initialSnapshots
+    }
+
+    var storedSnapshots: [CodexAccountUsageSnapshot] {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        return self.snapshotsStored
+    }
+
+    func load(for accounts: [CodexVisibleAccount]) -> [CodexAccountUsageSnapshot] {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        let accountIDs = Set(accounts.map(\.id))
+        return self.loadedSnapshots.filter { accountIDs.contains($0.id) }
+    }
+
+    func store(_ snapshots: [CodexAccountUsageSnapshot]) {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        self.snapshotsStored = snapshots
+    }
+}
+
+struct TestCodexFetchStrategy: ProviderFetchStrategy {
+    let loader: @Sendable () async throws -> UsageSnapshot
+    var credits: CreditsSnapshot?
+    var id = "test-codex"
+    var kind: ProviderFetchKind = .cli
+    var sourceLabel = "test-codex"
+
+    func isAvailable(_: ProviderFetchContext) async -> Bool {
+        true
+    }
+
+    func fetch(_: ProviderFetchContext) async throws -> ProviderFetchResult {
+        let snapshot = try await self.loader()
+        return self.makeResult(
+            usage: snapshot,
+            credits: self.credits,
+            sourceLabel: self.sourceLabel)
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+}
+
+struct ContextualTestCodexFetchStrategy: ProviderFetchStrategy {
+    let loader: @Sendable (ProviderFetchContext) async throws -> UsageSnapshot
+    let sourceLabel: String
+
+    var id = "contextual-test-codex"
+    var kind: ProviderFetchKind = .cli
+
+    func isAvailable(_: ProviderFetchContext) async -> Bool {
+        true
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        let snapshot = try await self.loader(context)
+        return self.makeResult(
+            usage: snapshot,
+            credits: nil,
+            sourceLabel: self.sourceLabel)
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+}
+
+struct ThrowingTestCodexFetchStrategy: ProviderFetchStrategy {
+    let loader: @Sendable () async throws -> UsageSnapshot
+
+    var id: String {
+        "test-codex-throwing"
+    }
+
+    var kind: ProviderFetchKind {
+        .cli
+    }
+
+    func isAvailable(_: ProviderFetchContext) async -> Bool {
+        true
+    }
+
+    func fetch(_: ProviderFetchContext) async throws -> ProviderFetchResult {
+        let snapshot = try await self.loader()
+        return self.makeResult(usage: snapshot, sourceLabel: "test-codex-throwing")
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+}
+
+actor BlockingCodexFetchStrategy {
+    private var waiters: [CheckedContinuation<Result<UsageSnapshot, Error>, Never>] = []
+    private var startedWaiters: [CheckedContinuation<Void, Never>] = []
+    private var didStart = false
+
+    func awaitResult() async throws -> UsageSnapshot {
+        self.didStart = true
+        self.startedWaiters.forEach { $0.resume() }
+        self.startedWaiters.removeAll()
+        let result = await withCheckedContinuation { continuation in
+            self.waiters.append(continuation)
+        }
+        return try result.get()
+    }
+
+    func waitUntilStarted() async {
+        if self.didStart { return }
+        await withCheckedContinuation { continuation in
+            self.startedWaiters.append(continuation)
+        }
+    }
+
+    func resume(with result: Result<UsageSnapshot, Error>) {
+        self.waiters.forEach { $0.resume(returning: result) }
+        self.waiters.removeAll()
+    }
+}
+
+actor BlockingOpenAIDashboardLoader {
+    private var waiters: [CheckedContinuation<Result<OpenAIDashboardSnapshot, Error>, Never>] = []
+    private var startedWaiters: [CheckedContinuation<Void, Never>] = []
+    private var didStart = false
+
+    func awaitResult() async throws -> OpenAIDashboardSnapshot {
+        self.didStart = true
+        self.startedWaiters.forEach { $0.resume() }
+        self.startedWaiters.removeAll()
+        let result = await withCheckedContinuation { continuation in
+            self.waiters.append(continuation)
+        }
+        return try result.get()
+    }
+
+    func waitUntilStarted() async {
+        if self.didStart { return }
+        await withCheckedContinuation { continuation in
+            self.startedWaiters.append(continuation)
+        }
+    }
+
+    func resume(with result: Result<OpenAIDashboardSnapshot, Error>) {
+        self.waiters.forEach { $0.resume(returning: result) }
+        self.waiters.removeAll()
+    }
+}
+
+actor BlockingWidgetSnapshotSaver {
+    private var snapshots: [WidgetSnapshot] = []
+    private var waiters: [CheckedContinuation<Void, Never>] = []
+    private var startedWaiters: [CheckedContinuation<Void, Never>] = []
+
+    func save(_ snapshot: WidgetSnapshot) async {
+        self.snapshots.append(snapshot)
+        self.startedWaiters.forEach { $0.resume() }
+        self.startedWaiters.removeAll()
+        await withCheckedContinuation { continuation in
+            self.waiters.append(continuation)
+        }
+    }
+
+    func waitUntilStarted(count: Int) async {
+        if self.snapshots.count >= count { return }
+        await withCheckedContinuation { continuation in
+            self.startedWaiters.append(continuation)
+        }
+    }
+
+    func waitUntilStartedWithin(count: Int, timeout: Duration = .seconds(5)) async -> Bool {
+        let startedAt = ContinuousClock.now
+        while self.snapshots.count < count {
+            if startedAt.duration(to: .now) >= timeout {
+                return false
+            }
+            try? await Task.sleep(for: .milliseconds(50))
+        }
+        return true
+    }
+
+    func startedCount() -> Int {
+        self.snapshots.count
+    }
+
+    func resumeNext() {
+        guard !self.waiters.isEmpty else { return }
+        let waiter = self.waiters.removeFirst()
+        waiter.resume()
+    }
+
+    func savedSnapshots() -> [WidgetSnapshot] {
+        self.snapshots
+    }
+}
+
+actor RecordingWidgetSnapshotSaver {
+    private var snapshots: [WidgetSnapshot] = []
+
+    func save(_ snapshot: WidgetSnapshot) {
+        self.snapshots.append(snapshot)
+    }
+
+    func waitUntilSavedWithin(count: Int, timeout: Duration = .seconds(5)) async -> Bool {
+        let startedAt = ContinuousClock.now
+        while self.snapshots.count < count {
+            if startedAt.duration(to: .now) >= timeout {
+                return false
+            }
+            try? await Task.sleep(for: .milliseconds(50))
+        }
+        return true
+    }
+
+    func savedSnapshots() -> [WidgetSnapshot] {
+        self.snapshots
+    }
+}
diff --git a/Tests/CodexBarTests/CodexAccountScopedRefreshTests.swift b/Tests/CodexBarTests/CodexAccountScopedRefreshTests.swift
new file mode 100644
index 0000000000..91f0b5da1f
--- /dev/null
+++ b/Tests/CodexBarTests/CodexAccountScopedRefreshTests.swift
@@ -0,0 +1,925 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@Suite(.serialized)
+@MainActor
+struct CodexAccountScopedRefreshTests {
+    @Test
+    func `account transition invalidates codex scoped state and preserves token usage`() async {
+        let settings = self.makeSettingsStore(suite: "CodexAccountScopedRefreshTests-invalidate")
+        settings.refreshFrequency = .manual
+        settings.codexCookieSource = .auto
+        settings._test_liveSystemCodexAccount = self.liveAccount(email: "alpha@example.com")
+
+        let store = self.makeUsageStore(settings: settings)
+        let staleSnapshot = self.codexSnapshot(email: "alpha@example.com", usedPercent: 10)
+        let staleCredits = self.credits(remaining: 42)
+        let staleDashboard = self.dashboard(email: "alpha@example.com", creditsRemaining: 42, usedPercent: 20)
+        let tokenSnapshot = CostUsageTokenSnapshot(
+            sessionTokens: 120,
+            sessionCostUSD: 1.2,
+            last30DaysTokens: 900,
+            last30DaysCostUSD: 9.0,
+            daily: [],
+            updatedAt: Date())
+        var widgetSnapshots: [WidgetSnapshot] = []
+
+        store._setSnapshotForTesting(staleSnapshot, provider: .codex)
+        store.credits = staleCredits
+        store.lastCreditsSnapshot = staleCredits
+        store.lastCreditsSnapshotAccountKey = "alpha@example.com"
+        store.lastCreditsSource = .api
+        store.openAIDashboard = staleDashboard
+        store.lastOpenAIDashboardSnapshot = staleDashboard
+        store.lastOpenAIDashboardTargetEmail = "alpha@example.com"
+        store._setTokenSnapshotForTesting(tokenSnapshot, provider: .codex)
+        store.lastCodexAccountScopedRefreshGuard = store
+            .currentCodexAccountScopedRefreshGuard(preferCurrentSnapshot: false)
+        store._test_widgetSnapshotSaveOverride = { widgetSnapshots.append($0) }
+        defer { store._test_widgetSnapshotSaveOverride = nil }
+
+        settings._test_liveSystemCodexAccount = self.liveAccount(email: "beta@example.com")
+
+        let didInvalidate = store.prepareCodexAccountScopedRefreshIfNeeded()
+        await store.widgetSnapshotPersistTask?.value
+
+        #expect(didInvalidate)
+        #expect(store.snapshots[.codex] == nil)
+        #expect(store.credits == nil)
+        #expect(store.lastCreditsSnapshot == nil)
+        #expect(store.lastCreditsSnapshotAccountKey == nil)
+        #expect(store.lastCreditsSource == .none)
+        #expect(store.openAIDashboard == nil)
+        #expect(store.lastOpenAIDashboardSnapshot == nil)
+        #expect(store.tokenSnapshots[.codex] == tokenSnapshot)
+        #expect(widgetSnapshots.count == 1)
+        #expect(widgetSnapshots[0].entries.contains(where: { $0.provider == .codex }) == false)
+    }
+
+    @Test
+    func `first switch invalidates after codex refresh seeds the previous account guard`() async {
+        let settings = self.makeSettingsStore(suite: "CodexAccountScopedRefreshTests-first-switch")
+        settings.refreshFrequency = .manual
+        settings.codexCookieSource = .off
+        settings._test_liveSystemCodexAccount = self.liveAccount(email: "alpha@example.com")
+
+        let store = self.makeUsageStore(settings: settings)
+        self.installImmediateCodexProvider(
+            on: store,
+            snapshot: self.codexSnapshot(email: "alpha@example.com", usedPercent: 10))
+
+        await store.refreshProvider(.codex, allowDisabled: true)
+
+        #expect(store.lastCodexAccountScopedRefreshGuard?.accountKey == "alpha@example.com")
+
+        settings._test_liveSystemCodexAccount = self.liveAccount(email: "beta@example.com")
+
+        let didInvalidate = store.prepareCodexAccountScopedRefreshIfNeeded()
+
+        #expect(didInvalidate)
+        #expect(store.snapshots[.codex] == nil)
+    }
+
+    @Test
+    func `stale codex usage success is discarded after account switch`() async {
+        let settings = self.makeSettingsStore(suite: "CodexAccountScopedRefreshTests-stale-success")
+        settings.refreshFrequency = .manual
+        settings._test_liveSystemCodexAccount = self.liveAccount(email: "alpha@example.com")
+
+        let store = self.makeUsageStore(settings: settings)
+        let blocker = BlockingCodexFetchStrategy()
+        self.installBlockingCodexProvider(on: store, blocker: blocker)
+
+        let refreshTask = Task { await store.refreshProvider(.codex, allowDisabled: true) }
+        await blocker.waitUntilStarted()
+        settings._test_liveSystemCodexAccount = self.liveAccount(email: "beta@example.com")
+        await blocker.resume(with: .success(self.codexSnapshot(email: "alpha@example.com", usedPercent: 25)))
+        await refreshTask.value
+
+        #expect(store.snapshots[.codex] == nil)
+        #expect(store.errors[.codex] == nil)
+    }
+
+    @Test
+    func `same email provider account switch discards stale codex usage success`() async {
+        let settings = self.makeSettingsStore(suite: "CodexAccountScopedRefreshTests-stale-same-email-provider-account")
+        settings.refreshFrequency = .manual
+        settings._test_liveSystemCodexAccount = self.liveAccount(
+            email: "alpha@example.com",
+            identity: .providerAccount(id: "acct-alpha"))
+
+        let store = self.makeUsageStore(settings: settings)
+        let blocker = BlockingCodexFetchStrategy()
+        self.installBlockingCodexProvider(on: store, blocker: blocker)
+
+        let refreshTask = Task { await store.refreshProvider(.codex, allowDisabled: true) }
+        await blocker.waitUntilStarted()
+        settings._test_liveSystemCodexAccount = self.liveAccount(
+            email: "alpha@example.com",
+            identity: .providerAccount(id: "acct-beta"))
+        await blocker.resume(with: .success(self.codexSnapshot(email: "alpha@example.com", usedPercent: 25)))
+        await refreshTask.value
+
+        #expect(store.snapshots[.codex] == nil)
+        #expect(store.errors[.codex] == nil)
+    }
+
+    @Test
+    func `stale codex usage failure does not clear newer account snapshot`() async {
+        let settings = self.makeSettingsStore(suite: "CodexAccountScopedRefreshTests-stale-failure")
+        settings.refreshFrequency = .manual
+        settings._test_liveSystemCodexAccount = self.liveAccount(email: "alpha@example.com")
+
+        let store = self.makeUsageStore(settings: settings)
+        let blocker = BlockingCodexFetchStrategy()
+        self.installBlockingCodexProvider(on: store, blocker: blocker)
+
+        let refreshTask = Task { await store.refreshProvider(.codex, allowDisabled: true) }
+        await blocker.waitUntilStarted()
+        settings._test_liveSystemCodexAccount = self.liveAccount(email: "beta@example.com")
+        let freshSnapshot = self.codexSnapshot(email: "beta@example.com", usedPercent: 5)
+        store._setSnapshotForTesting(freshSnapshot, provider: .codex)
+        await blocker.resume(with: .failure(TestRefreshError(message: "stale failure")))
+        await refreshTask.value
+
+        #expect(store.snapshots[.codex]?.accountEmail(for: .codex) == "beta@example.com")
+        #expect(store.errors[.codex] == nil)
+    }
+
+    @Test
+    func `codex visible account refresh preserves prior snapshots when network fails`() async throws {
+        try await self.withCodexVisibleAccountFailureStore(
+            suite: "CodexAccountScopedRefreshTests-preserve-codex-snapshots",
+            errorMessage: "Network error: offline")
+        { store, snapshotStore, priorSnapshots in
+            await store.refreshCodexVisibleAccountsForMenu()
+
+            #expect(store.codexAccountSnapshots.count == priorSnapshots.count)
+            #expect(store.codexAccountSnapshots.allSatisfy { $0.snapshot?.primary?.usedPercent == 17 })
+            #expect(store.codexAccountSnapshots.allSatisfy { $0.error == "Network error: offline" })
+            #expect(store.codexAccountSnapshots.allSatisfy { $0.sourceLabel == "cached" })
+
+            let persisted = snapshotStore.storedSnapshots
+            #expect(persisted.count == priorSnapshots.count)
+            #expect(persisted.allSatisfy { $0.snapshot?.primary?.usedPercent == 17 })
+            #expect(persisted.allSatisfy { $0.error == "Network error: offline" })
+        }
+    }
+
+    @Test
+    func `codex visible account refresh drops prior snapshots when auth fails`() async throws {
+        try await self.withCodexVisibleAccountFailureStore(
+            suite: "CodexAccountScopedRefreshTests-drop-auth-failed-snapshots",
+            errorMessage: "401 Unauthorized")
+        { store, snapshotStore, priorSnapshots in
+            await store.refreshCodexVisibleAccountsForMenu()
+
+            #expect(store.codexAccountSnapshots.count == priorSnapshots.count)
+            #expect(store.codexAccountSnapshots.allSatisfy { $0.snapshot == nil })
+            #expect(store.codexAccountSnapshots.allSatisfy { $0.error == "401 Unauthorized" })
+
+            let persisted = snapshotStore.storedSnapshots
+            #expect(persisted.count == priorSnapshots.count)
+            #expect(persisted.allSatisfy { $0.snapshot == nil })
+            #expect(persisted.allSatisfy { $0.error == "401 Unauthorized" })
+        }
+    }
+
+    @Test
+    func `credits fallback only reuses cache for the same codex account`() async {
+        let settings = self.makeSettingsStore(suite: "CodexAccountScopedRefreshTests-credits")
+        settings.refreshFrequency = .manual
+        settings._test_liveSystemCodexAccount = self.liveAccount(email: "alpha@example.com")
+
+        let store = self.makeUsageStore(settings: settings)
+        let cachedCredits = self.credits(remaining: 12)
+        store._setSnapshotForTesting(self.codexSnapshot(email: "alpha@example.com", usedPercent: 10), provider: .codex)
+        store.lastCreditsSnapshot = cachedCredits
+        store.lastCreditsSnapshotAccountKey = "alpha@example.com"
+        store._test_codexCreditsLoaderOverride = {
+            throw TestRefreshError(message: "Codex credits data not available yet")
+        }
+        defer { store._test_codexCreditsLoaderOverride = nil }
+
+        await store.refreshCreditsIfNeeded()
+        #expect(store.credits == cachedCredits)
+        #expect(store.lastCreditsError == nil)
+
+        settings._test_liveSystemCodexAccount = self.liveAccount(email: "beta@example.com")
+        store._setSnapshotForTesting(self.codexSnapshot(email: "beta@example.com", usedPercent: 10), provider: .codex)
+
+        await store.refreshCreditsIfNeeded()
+        #expect(store.credits == nil)
+        #expect(store.lastCreditsSource == .none)
+        #expect(store.lastCreditsError == "Codex credits are still loading; will retry shortly.")
+    }
+
+    @Test
+    func `managed refresh invalidation keeps state when provider account is unchanged`() throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-managed-renamed-email")
+        let managedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: managedHome) }
+        try Self.writeCodexAuthFile(
+            homeURL: managedHome,
+            email: "renamed@example.com",
+            plan: "pro",
+            accountId: "acct-managed")
+
+        let managedAccountID = UUID()
+        let managedAccount = ManagedCodexAccount(
+            id: managedAccountID,
+            email: "legacy@example.com",
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings.codexActiveSource = .managedAccount(id: managedAccountID)
+        defer { settings._test_activeManagedCodexAccount = nil }
+
+        let store = self.makeUsageStore(settings: settings)
+        let currentSnapshot = self.codexSnapshot(email: "renamed@example.com", usedPercent: 10)
+        let currentCredits = self.credits(remaining: 42)
+        let currentDashboard = self.dashboard(email: "renamed@example.com", creditsRemaining: 42, usedPercent: 20)
+
+        store._setSnapshotForTesting(currentSnapshot, provider: .codex)
+        store.credits = currentCredits
+        store.lastCreditsSnapshot = currentCredits
+        store.lastCreditsSnapshotAccountKey = "renamed@example.com"
+        store.openAIDashboard = currentDashboard
+        store.lastOpenAIDashboardSnapshot = currentDashboard
+        store.lastOpenAIDashboardTargetEmail = "renamed@example.com"
+        store.seedCodexAccountScopedRefreshGuard(
+            source: .managedAccount(id: managedAccountID),
+            accountEmail: "renamed@example.com")
+
+        let currentGuard = store.currentCodexAccountScopedRefreshGuard(
+            preferCurrentSnapshot: false,
+            allowLastKnownLiveFallback: false)
+        let didInvalidate = store.prepareCodexAccountScopedRefreshIfNeeded()
+
+        #expect(currentGuard.identity == .providerAccount(id: "acct-managed"))
+        #expect(currentGuard.accountKey == "renamed@example.com")
+        #expect(didInvalidate == false)
+        #expect(store.snapshots[.codex]?.accountEmail(for: .codex) == "renamed@example.com")
+        #expect(store.credits?.remaining == 42)
+        #expect(store.openAIDashboard?.signedInEmail == "renamed@example.com")
+    }
+
+    @Test
+    func `credits refresh returns quickly when no live codex account is available`() async {
+        let settings = self.makeSettingsStore(suite: "CodexAccountScopedRefreshTests-credits-no-live-account")
+        let isolatedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-credits-no-live-\(UUID().uuidString)", isDirectory: true)
+        try? FileManager.default.createDirectory(at: isolatedHome, withIntermediateDirectories: true)
+        settings.refreshFrequency = .manual
+        settings._test_liveSystemCodexAccount = nil
+        settings._test_codexReconciliationEnvironment = ["CODEX_HOME": isolatedHome.path]
+        defer {
+            settings._test_codexReconciliationEnvironment = nil
+            try? FileManager.default.removeItem(at: isolatedHome)
+        }
+
+        let store = self.makeUsageStore(settings: settings)
+        var loaderCalled = false
+        store._test_codexCreditsLoaderOverride = {
+            loaderCalled = true
+            return self.credits(remaining: 1)
+        }
+        defer { store._test_codexCreditsLoaderOverride = nil }
+
+        let startedAt = ContinuousClock.now
+        await store.refreshCreditsIfNeeded(minimumSnapshotUpdatedAt: Date())
+        let elapsed = startedAt.duration(to: .now)
+
+        #expect(loaderCalled == false)
+        #expect(elapsed < .seconds(3))
+    }
+
+    @Test
+    func `stale dashboard apply is discarded after account switch`() async {
+        let settings = self.makeSettingsStore(suite: "CodexAccountScopedRefreshTests-dashboard")
+        settings.refreshFrequency = .manual
+        settings._test_liveSystemCodexAccount = self.liveAccount(email: "alpha@example.com")
+
+        let store = self.makeUsageStore(settings: settings)
+        let expectedGuard = store.currentCodexAccountScopedRefreshGuard()
+        settings._test_liveSystemCodexAccount = self.liveAccount(email: "beta@example.com")
+
+        await store.applyOpenAIDashboard(
+            self.dashboard(email: "alpha@example.com", creditsRemaining: 11, usedPercent: 35),
+            targetEmail: "alpha@example.com",
+            expectedGuard: expectedGuard,
+            allowCodexUsageBackfill: true)
+
+        #expect(store.openAIDashboard == nil)
+        #expect(store.snapshots[.codex] == nil)
+        #expect(store.credits == nil)
+    }
+
+    @Test
+    func `dashboard refresh fail closes when live identity is unresolved without trusted continuity`() async {
+        let settings = self.makeSettingsStore(suite: "CodexAccountScopedRefreshTests-dashboard-unresolved-fail-closed")
+        let isolatedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-openai-web-unresolved-fail-closed-\(UUID().uuidString)", isDirectory: true)
+        try? FileManager.default.createDirectory(at: isolatedHome, withIntermediateDirectories: true)
+        settings.refreshFrequency = .manual
+        settings.codexCookieSource = .auto
+        settings._test_liveSystemCodexAccount = nil
+        settings._test_codexReconciliationEnvironment = ["CODEX_HOME": isolatedHome.path]
+        defer {
+            settings._test_codexReconciliationEnvironment = nil
+            try? FileManager.default.removeItem(at: isolatedHome)
+        }
+
+        let store = self.makeUsageStore(settings: settings)
+        store.lastKnownLiveSystemCodexEmail = nil
+        store._test_openAIDashboardLoaderOverride = { _, _, _, _ in
+            self.dashboard(email: "seeded@example.com", creditsRemaining: 33, usedPercent: 12)
+        }
+        defer { store._test_openAIDashboardLoaderOverride = nil }
+
+        let expectedGuard = store.currentCodexAccountScopedRefreshGuard()
+        #expect(expectedGuard.source == .liveSystem)
+        #expect(expectedGuard.identity == .unresolved)
+        #expect(expectedGuard.accountKey == nil)
+
+        await store.refreshOpenAIDashboardIfNeeded(force: true, expectedGuard: expectedGuard)
+
+        #expect(store.openAIDashboard == nil)
+        #expect(store.lastOpenAIDashboardSnapshot == nil)
+        #expect(store.snapshots[.codex] == nil)
+        #expect(store.credits == nil)
+        #expect(store.openAIDashboardRequiresLogin == true)
+        #expect(store.lastOpenAIDashboardError?.contains("could not be verified") == true)
+    }
+
+    @Test
+    func `dashboard refresh attaches for unresolved live identity with trusted non dashboard continuity`() async {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-dashboard-unresolved-trusted-continuity")
+        let isolatedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-openai-web-unresolved-trusted-\(UUID().uuidString)", isDirectory: true)
+        try? FileManager.default.createDirectory(at: isolatedHome, withIntermediateDirectories: true)
+        settings.refreshFrequency = .manual
+        settings.codexCookieSource = .auto
+        settings._test_liveSystemCodexAccount = nil
+        settings._test_codexReconciliationEnvironment = ["CODEX_HOME": isolatedHome.path]
+        defer {
+            settings._test_codexReconciliationEnvironment = nil
+            try? FileManager.default.removeItem(at: isolatedHome)
+        }
+
+        let store = self.makeUsageStore(settings: settings)
+        store._setSnapshotForTesting(
+            self.codexSnapshot(email: "trusted@example.com", usedPercent: 12),
+            provider: .codex)
+        store.lastSourceLabels[.codex] = "codex-cli"
+        store._test_openAIDashboardLoaderOverride = { _, _, _, _ in
+            self.dashboard(email: "trusted@example.com", creditsRemaining: 33, usedPercent: 12)
+        }
+        defer { store._test_openAIDashboardLoaderOverride = nil }
+
+        let expectedGuard = store.currentCodexOpenAIWebRefreshGuard()
+        #expect(expectedGuard.identity == .unresolved)
+
+        await store.refreshOpenAIDashboardIfNeeded(force: true, expectedGuard: expectedGuard)
+
+        #expect(store.openAIDashboard?.signedInEmail == "trusted@example.com")
+        #expect(store.snapshots[.codex]?.accountEmail(for: .codex) == "trusted@example.com")
+        #expect(store.lastSourceLabels[.codex] == "codex-cli")
+        #expect(store.credits?.remaining == 33)
+        #expect(store.lastCreditsSource == .dashboardWeb)
+        #expect(store.lastCreditsSnapshotAccountKey == "trusted@example.com")
+        #expect(
+            store.lastCodexAccountScopedRefreshGuard?.identity ==
+                .emailOnly(normalizedEmail: "trusted@example.com"))
+        #expect(store.lastCodexAccountScopedRefreshGuard?.accountKey == "trusted@example.com")
+    }
+
+    @Test
+    func `no usable codex usage does not block weekly only dashboard backfill`() async {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountScopedRefreshTests-no-usable-usage-weekly-dashboard-backfill")
+        settings.refreshFrequency = .manual
+        settings.codexCookieSource = .auto
+        settings._test_liveSystemCodexAccount = self.liveAccount(
+            email: "weekly@example.com",
+            identity: .providerAccount(id: "acct-weekly"))
+
+        let store = self.makeUsageStore(settings: settings)
+        self.installFailingCodexProvider(on: store, error: UsageError.noRateLimitsFound)
+
+        await store.refreshProvider(.codex, allowDisabled: true)
+
+        #expect(store.snapshots[.codex] == nil)
+
+        await store.applyOpenAIDashboard(
+            OpenAIDashboardSnapshot(
+                signedInEmail: "weekly@example.com",
+                codeReviewRemainingPercent: 88,
+                creditEvents: [],
+                dailyBreakdown: [],
+                usageBreakdown: [],
+                creditsPurchaseURL: nil,
+                primaryLimit: nil,
+                secondaryLimit: RateWindow(
+                    usedPercent: 27,
+                    windowMinutes: 10080,
+                    resetsAt: Date(timeIntervalSince1970: 1_775_000_000),
+                    resetDescription: "next week"),
+                creditsRemaining: 14,
+                accountPlan: "Pro",
+                updatedAt: Date(timeIntervalSince1970: 1_774_900_000)),
+            targetEmail: "weekly@example.com",
+            allowCodexUsageBackfill: true)
+
+        #expect(store.openAIDashboard?.signedInEmail == "weekly@example.com")
+        #expect(store.snapshots[.codex]?.primary == nil)
+        #expect(store.snapshots[.codex]?.secondary?.usedPercent == 27)
+        #expect(store.snapshots[.codex]?.secondary?.windowMinutes == 10080)
+        #expect(store.lastSourceLabels[.codex] == "openai-web")
+    }
+
+    @Test
+    func `dashboard display only keeps dashboard visible and clears dashboard derived data`() async throws {
+        let settings = self.makeSettingsStore(suite: "CodexAccountScopedRefreshTests-dashboard-display-only-cleanup")
+        let managedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: managedHome) }
+        try Self.writeCodexAuthFile(
+            homeURL: managedHome,
+            email: "shared@example.com",
+            plan: "pro",
+            accountId: "acct-managed")
+
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "shared@example.com",
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let managedStoreURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            try? FileManager.default.removeItem(at: managedStoreURL)
+            OpenAIDashboardCacheStore.clear()
+        }
+
+        settings.refreshFrequency = .manual
+        settings.codexCookieSource = .auto
+        settings._test_managedCodexAccountStoreURL = managedStoreURL
+        settings._test_liveSystemCodexAccount = self.liveAccount(
+            email: "shared@example.com",
+            identity: .emailOnly(normalizedEmail: "shared@example.com"))
+        settings.codexActiveSource = .liveSystem
+
+        let store = self.makeUsageStore(settings: settings)
+        store._setSnapshotForTesting(self.codexSnapshot(email: "shared@example.com", usedPercent: 20), provider: .codex)
+        store.lastSourceLabels[.codex] = "openai-web"
+        let staleCredits = self.credits(remaining: 20)
+        store.credits = staleCredits
+        store.lastCreditsSnapshot = staleCredits
+        store.lastCreditsSnapshotAccountKey = "shared@example.com"
+        store.lastCreditsSource = .dashboardWeb
+        OpenAIDashboardCacheStore.save(OpenAIDashboardCache(
+            accountEmail: "shared@example.com",
+            snapshot: self.dashboard(email: "shared@example.com", creditsRemaining: 20, usedPercent: 20)))
+
+        await store.applyOpenAIDashboard(
+            self.dashboard(email: "shared@example.com", creditsRemaining: 9, usedPercent: 35),
+            targetEmail: "shared@example.com")
+
+        #expect(store.openAIDashboard?.signedInEmail == "shared@example.com")
+        #expect(store.lastOpenAIDashboardSnapshot?.signedInEmail == "shared@example.com")
+        #expect(store.snapshots[.codex] == nil)
+        #expect(store.lastSourceLabels[.codex] == nil)
+        #expect(store.credits == nil)
+        #expect(store.lastCreditsSource == .none)
+        #expect(OpenAIDashboardCacheStore.load() == nil)
+    }
+
+    @Test
+    func `dashboard downgrade from real attach to display only retires owned state immediately`() async throws {
+        OpenAIDashboardCacheStore.clear()
+        defer { OpenAIDashboardCacheStore.clear() }
+
+        let settings = self.makeSettingsStore(suite: "CodexAccountScopedRefreshTests-dashboard-downgrade")
+        let managedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: managedHome) }
+        try Self.writeCodexAuthFile(
+            homeURL: managedHome,
+            email: "shared@example.com",
+            plan: "pro",
+            accountId: "acct-managed")
+
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "shared@example.com",
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let managedStoreURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            try? FileManager.default.removeItem(at: managedStoreURL)
+        }
+
+        settings.refreshFrequency = .manual
+        settings.codexCookieSource = .auto
+        settings._test_liveSystemCodexAccount = self.liveAccount(
+            email: "shared@example.com",
+            identity: .emailOnly(normalizedEmail: "shared@example.com"))
+        settings.codexActiveSource = .liveSystem
+
+        let store = self.makeUsageStore(settings: settings)
+        await store.applyOpenAIDashboard(
+            self.dashboard(email: "shared@example.com", creditsRemaining: 20, usedPercent: 20),
+            targetEmail: "shared@example.com")
+
+        #expect(store.openAIDashboard?.signedInEmail == "shared@example.com")
+        #expect(store.snapshots[.codex]?.accountEmail(for: .codex) == "shared@example.com")
+        #expect(store.lastSourceLabels[.codex] == "openai-web")
+        #expect(store.credits?.remaining == 20)
+        #expect(store.lastCreditsSource == .dashboardWeb)
+        #expect(OpenAIDashboardCacheStore.load()?.accountEmail == "shared@example.com")
+
+        settings._test_managedCodexAccountStoreURL = managedStoreURL
+
+        await store.applyOpenAIDashboard(
+            self.dashboard(email: "shared@example.com", creditsRemaining: 9, usedPercent: 35),
+            targetEmail: "shared@example.com")
+
+        #expect(store.openAIDashboard?.signedInEmail == "shared@example.com")
+        #expect(store.lastOpenAIDashboardSnapshot?.signedInEmail == "shared@example.com")
+        #expect(store.snapshots[.codex] == nil)
+        #expect(store.lastSourceLabels[.codex] == nil)
+        #expect(store.credits == nil)
+        #expect(store.lastCreditsSource == .none)
+        #expect(OpenAIDashboardCacheStore.load() == nil)
+    }
+
+    @Test
+    func `dashboard refresh rejects stale completion during live account reconciliation lag`() async {
+        let settings = self.makeSettingsStore(suite: "CodexAccountScopedRefreshTests-dashboard-reject-stale-live-lag")
+        let isolatedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-openai-web-stale-live-lag-\(UUID().uuidString)", isDirectory: true)
+        try? FileManager.default.createDirectory(at: isolatedHome, withIntermediateDirectories: true)
+        settings.refreshFrequency = .manual
+        settings.codexCookieSource = .auto
+        settings._test_codexReconciliationEnvironment = ["CODEX_HOME": isolatedHome.path]
+        settings.codexActiveSource = .liveSystem
+        defer {
+            settings._test_codexReconciliationEnvironment = nil
+            try? FileManager.default.removeItem(at: isolatedHome)
+        }
+
+        let store = self.makeUsageStore(settings: settings)
+        store._setSnapshotForTesting(self.codexSnapshot(email: "alpha@example.com", usedPercent: 12), provider: .codex)
+
+        let expectedGuard = store.currentCodexOpenAIWebRefreshGuard()
+        #expect(expectedGuard.accountKey == nil)
+
+        store._setSnapshotForTesting(self.codexSnapshot(email: "beta@example.com", usedPercent: 18), provider: .codex)
+
+        await store.applyOpenAIDashboard(
+            self.dashboard(email: "alpha@example.com", creditsRemaining: 40, usedPercent: 20),
+            targetEmail: nil,
+            expectedGuard: expectedGuard,
+            allowCodexUsageBackfill: true)
+
+        #expect(store.openAIDashboard == nil)
+        #expect(store.credits == nil)
+        #expect(store.snapshots[.codex]?.accountEmail(for: .codex) == "beta@example.com")
+    }
+
+    @Test
+    func `default dashboard refresh path discards stale completion after account switch`() async {
+        let settings = self.makeSettingsStore(suite: "CodexAccountScopedRefreshTests-dashboard-guard")
+        settings.refreshFrequency = .manual
+        settings.openAIWebAccessEnabled = true
+        settings.codexCookieSource = .auto
+        settings.statusChecksEnabled = false
+        settings._test_liveSystemCodexAccount = self.liveAccount(email: "alpha@example.com")
+
+        let store = self.makeUsageStore(settings: settings)
+        self.installImmediateCodexProvider(
+            on: store,
+            snapshot: self.codexSnapshot(email: "alpha@example.com", usedPercent: 18))
+        await store.refresh()
+
+        let dashboardBlocker = BlockingOpenAIDashboardLoader()
+        store._test_openAIDashboardLoaderOverride = { _, _, _, _ in
+            try await dashboardBlocker.awaitResult()
+        }
+        defer { store._test_openAIDashboardLoaderOverride = nil }
+
+        let refreshTask = Task { await store.refresh() }
+        await dashboardBlocker.waitUntilStarted()
+
+        settings._test_liveSystemCodexAccount = self.liveAccount(email: "beta@example.com")
+        store._setSnapshotForTesting(self.codexSnapshot(email: "beta@example.com", usedPercent: 7), provider: .codex)
+        store.openAIDashboard = nil
+        store.credits = nil
+
+        await dashboardBlocker.resume(with: .success(
+            self.dashboard(email: "alpha@example.com", creditsRemaining: 44, usedPercent: 21)))
+        await refreshTask.value
+
+        #expect(store.openAIDashboard == nil)
+        #expect(store.credits == nil)
+        #expect(store.snapshots[.codex]?.accountEmail(for: .codex) == "beta@example.com")
+    }
+
+    @Test
+    func `same email provider account switch discards stale dashboard completion`() async {
+        let settings = self
+            .makeSettingsStore(suite: "CodexAccountScopedRefreshTests-dashboard-same-email-provider-account")
+        settings.refreshFrequency = .manual
+        settings._test_liveSystemCodexAccount = self.liveAccount(
+            email: "alpha@example.com",
+            identity: .providerAccount(id: "acct-alpha"))
+
+        let store = self.makeUsageStore(settings: settings)
+        let expectedGuard = store.currentCodexOpenAIWebRefreshGuard()
+        #expect(expectedGuard.identity == .providerAccount(id: "acct-alpha"))
+
+        settings._test_liveSystemCodexAccount = self.liveAccount(
+            email: "alpha@example.com",
+            identity: .providerAccount(id: "acct-beta"))
+
+        await store.applyOpenAIDashboard(
+            self.dashboard(email: "alpha@example.com", creditsRemaining: 11, usedPercent: 35),
+            targetEmail: "alpha@example.com",
+            expectedGuard: expectedGuard,
+            allowCodexUsageBackfill: true)
+
+        #expect(store.openAIDashboard == nil)
+        #expect(store.snapshots[.codex] == nil)
+        #expect(store.credits == nil)
+    }
+
+    @Test
+    func `live switch invalidates stale codex state even when only last known live email remains`() async {
+        let settings = self.makeSettingsStore(suite: "CodexAccountScopedRefreshTests-invalidate-with-stale-last-known")
+        let isolatedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-invalidate-stale-last-known-\(UUID().uuidString)", isDirectory: true)
+        try? FileManager.default.createDirectory(at: isolatedHome, withIntermediateDirectories: true)
+        settings.refreshFrequency = .manual
+        settings.codexCookieSource = .auto
+        settings._test_liveSystemCodexAccount = self.liveAccount(email: "alpha@example.com")
+        settings._test_codexReconciliationEnvironment = ["CODEX_HOME": isolatedHome.path]
+        defer {
+            settings._test_codexReconciliationEnvironment = nil
+            try? FileManager.default.removeItem(at: isolatedHome)
+        }
+
+        let store = self.makeUsageStore(settings: settings)
+        store._setSnapshotForTesting(self.codexSnapshot(email: "alpha@example.com", usedPercent: 10), provider: .codex)
+        store.credits = self.credits(remaining: 12)
+        store.lastCreditsSnapshot = self.credits(remaining: 12)
+        store.lastCreditsSnapshotAccountKey = "alpha@example.com"
+        store.openAIDashboard = self.dashboard(email: "alpha@example.com", creditsRemaining: 12, usedPercent: 20)
+        store.lastOpenAIDashboardSnapshot = store.openAIDashboard
+        store.lastKnownLiveSystemCodexEmail = "alpha@example.com"
+        store.lastCodexAccountScopedRefreshGuard = store.currentCodexAccountScopedRefreshGuard(
+            preferCurrentSnapshot: false,
+            allowLastKnownLiveFallback: true)
+
+        settings._test_liveSystemCodexAccount = nil
+        store.snapshots.removeValue(forKey: .codex)
+
+        let didInvalidate = store.prepareCodexAccountScopedRefreshIfNeeded()
+        await store.widgetSnapshotPersistTask?.value
+
+        #expect(didInvalidate)
+        #expect(store.snapshots[.codex] == nil)
+        #expect(store.credits == nil)
+        #expect(store.openAIDashboard == nil)
+        #expect(store.lastCodexAccountScopedRefreshGuard?.accountKey == nil)
+    }
+
+    @Test
+    func `codex account refresh persists widget snapshots on invalidation and completion`() async {
+        let settings = self.makeSettingsStore(suite: "CodexAccountScopedRefreshTests-widgets")
+        settings.refreshFrequency = .manual
+        settings.codexCookieSource = .off
+        settings._test_liveSystemCodexAccount = self.liveAccount(email: "alpha@example.com")
+
+        let store = self.makeUsageStore(settings: settings)
+        store._setSnapshotForTesting(self.codexSnapshot(email: "alpha@example.com", usedPercent: 18), provider: .codex)
+        store.lastCodexAccountScopedRefreshGuard = store
+            .currentCodexAccountScopedRefreshGuard(preferCurrentSnapshot: false)
+
+        let blocker = BlockingCodexFetchStrategy()
+        self.installBlockingCodexProvider(on: store, blocker: blocker)
+        store._test_codexCreditsLoaderOverride = { self.credits(remaining: 77) }
+        defer { store._test_codexCreditsLoaderOverride = nil }
+
+        var widgetSnapshots: [WidgetSnapshot] = []
+        store._test_widgetSnapshotSaveOverride = { widgetSnapshots.append($0) }
+        defer { store._test_widgetSnapshotSaveOverride = nil }
+
+        settings._test_liveSystemCodexAccount = self.liveAccount(email: "beta@example.com")
+        let refreshTask = Task { await store.refreshCodexAccountScopedState(allowDisabled: true) }
+        await blocker.waitUntilStarted()
+        await blocker.resume(with: .success(self.codexSnapshot(email: "beta@example.com", usedPercent: 8)))
+        await refreshTask.value
+        await store.widgetSnapshotPersistTask?.value
+
+        #expect(widgetSnapshots.count == 2)
+        #expect(widgetSnapshots[0].entries.contains(where: { $0.provider == .codex }) == false)
+        #expect(widgetSnapshots[1].entries.first { $0.provider == .codex }?.creditsRemaining == 77)
+    }
+
+    @Test
+    func `widget snapshot saves stay ordered across codex account invalidation and completion`() async {
+        let settings = self.makeSettingsStore(suite: "CodexAccountScopedRefreshTests-widget-order")
+        settings.refreshFrequency = .manual
+
+        let store = self.makeUsageStore(settings: settings)
+        let saver = BlockingWidgetSnapshotSaver()
+        store._test_widgetSnapshotSaveOverride = { snapshot in
+            await saver.save(snapshot)
+        }
+        defer { store._test_widgetSnapshotSaveOverride = nil }
+
+        store.persistWidgetSnapshot(reason: "codex-account-invalidate")
+        await saver.waitUntilStarted(count: 1)
+        #expect(await saver.startedCount() == 1)
+
+        store._setSnapshotForTesting(self.codexSnapshot(email: "beta@example.com", usedPercent: 8), provider: .codex)
+        store.credits = self.credits(remaining: 77)
+        store.persistWidgetSnapshot(reason: "codex-account-refresh")
+
+        try? await Task.sleep(nanoseconds: 50_000_000)
+        #expect(await saver.startedCount() == 1)
+
+        await saver.resumeNext()
+        await saver.waitUntilStarted(count: 2)
+        await saver.resumeNext()
+        await store.widgetSnapshotPersistTask?.value
+
+        let snapshots = await saver.savedSnapshots()
+        #expect(snapshots.count == 2)
+        #expect(snapshots[0].entries.contains(where: { $0.provider == .codex }) == false)
+        #expect(snapshots[1].entries.first { $0.provider == .codex }?.creditsRemaining == 77)
+    }
+
+    @Test
+    func `widget snapshot excludes display only dashboard code review`() async throws {
+        let settings = self.makeSettingsStore(suite: "CodexAccountScopedRefreshTests-widget-display-only-dashboard")
+        settings.refreshFrequency = .manual
+
+        let store = self.makeUsageStore(settings: settings)
+        store._setSnapshotForTesting(self.codexSnapshot(email: "alpha@example.com", usedPercent: 18), provider: .codex)
+        store.credits = CreditsSnapshot(remaining: 12, events: [], updatedAt: Date())
+        store.openAIDashboard = self.dashboard(
+            email: "alpha@example.com",
+            creditsRemaining: 12,
+            usedPercent: 20)
+        store.openAIDashboardAttachmentAuthorized = false
+
+        var widgetSnapshots: [WidgetSnapshot] = []
+        store._test_widgetSnapshotSaveOverride = { widgetSnapshots.append($0) }
+        defer { store._test_widgetSnapshotSaveOverride = nil }
+
+        store.persistWidgetSnapshot(reason: "display-only-dashboard")
+        await store.widgetSnapshotPersistTask?.value
+
+        let codexEntry = try #require(widgetSnapshots.last?.entries.first { $0.provider == .codex })
+        #expect(codexEntry.creditsRemaining == nil)
+        #expect(codexEntry.codeReviewRemainingPercent == nil)
+    }
+
+    @Test
+    func `widget snapshot includes attached dashboard code review`() async throws {
+        let settings = self.makeSettingsStore(suite: "CodexAccountScopedRefreshTests-widget-attached-dashboard")
+        settings.refreshFrequency = .manual
+
+        let store = self.makeUsageStore(settings: settings)
+        store._setSnapshotForTesting(self.codexSnapshot(email: "alpha@example.com", usedPercent: 18), provider: .codex)
+        store.openAIDashboard = self.dashboard(
+            email: "alpha@example.com",
+            creditsRemaining: 12,
+            usedPercent: 20)
+        store.openAIDashboardAttachmentAuthorized = true
+
+        var widgetSnapshots: [WidgetSnapshot] = []
+        store._test_widgetSnapshotSaveOverride = { widgetSnapshots.append($0) }
+        defer { store._test_widgetSnapshotSaveOverride = nil }
+
+        store.persistWidgetSnapshot(reason: "attached-dashboard")
+        await store.widgetSnapshotPersistTask?.value
+
+        let codexEntry = try #require(widgetSnapshots.last?.entries.first { $0.provider == .codex })
+        #expect(codexEntry.codeReviewRemainingPercent == 88)
+    }
+
+    @Test
+    func `codex account refresh reports usage and credits phases before completion`() async {
+        let settings = self.makeSettingsStore(suite: "CodexAccountScopedRefreshTests-phases")
+        settings.refreshFrequency = .manual
+        settings.codexCookieSource = .off
+        settings._test_liveSystemCodexAccount = self.liveAccount(email: "alpha@example.com")
+
+        let store = self.makeUsageStore(settings: settings)
+        store._setSnapshotForTesting(self.codexSnapshot(email: "alpha@example.com", usedPercent: 18), provider: .codex)
+        store.lastCodexAccountScopedRefreshGuard = store
+            .currentCodexAccountScopedRefreshGuard(preferCurrentSnapshot: false)
+
+        let blocker = BlockingCodexFetchStrategy()
+        self.installBlockingCodexProvider(on: store, blocker: blocker)
+        store._test_codexCreditsLoaderOverride = { self.credits(remaining: 77) }
+        defer { store._test_codexCreditsLoaderOverride = nil }
+
+        var phases: [CodexAccountScopedRefreshPhase] = []
+        settings._test_liveSystemCodexAccount = self.liveAccount(email: "beta@example.com")
+
+        let refreshTask = Task {
+            await store.refreshCodexAccountScopedState(
+                allowDisabled: true,
+                phaseDidChange: { phases.append($0) })
+        }
+
+        await blocker.waitUntilStarted()
+        #expect(phases == [.invalidated])
+
+        await blocker.resume(with: .success(self.codexSnapshot(email: "beta@example.com", usedPercent: 8)))
+        await refreshTask.value
+
+        #expect(phases == [.invalidated, .usage, .credits, .completed])
+    }
+
+    @Test
+    func `refresh loads credits when codex email is discovered by usage in the same cycle`() async {
+        let settings = self.makeSettingsStore(suite: "CodexAccountScopedRefreshTests-refresh-credits")
+        settings.refreshFrequency = .manual
+        settings.codexCookieSource = .off
+
+        let store = self.makeUsageStore(settings: settings)
+        let blocker = BlockingCodexFetchStrategy()
+        self.installBlockingCodexProvider(on: store, blocker: blocker)
+        store._test_codexCreditsLoaderOverride = { self.credits(remaining: 55) }
+        defer { store._test_codexCreditsLoaderOverride = nil }
+
+        let refreshTask = Task { await store.refresh() }
+        await blocker.waitUntilStarted()
+        await blocker.resume(with: .success(self.codexSnapshot(email: "alpha@example.com", usedPercent: 12)))
+        await refreshTask.value
+        #expect(store.lastCodexAccountScopedRefreshGuard?.accountKey == "alpha@example.com")
+
+        await store.creditsRefreshTask?.value
+
+        #expect(store.credits?.remaining == 55)
+        #expect(store.lastCreditsSource == .api)
+    }
+
+    @Test
+    func `settings codex account selection refreshes credits on the first switch`() async throws {
+        let settings = self.makeSettingsStore(suite: "CodexAccountScopedRefreshTests-settings-selection")
+        settings.refreshFrequency = .manual
+        settings.codexCookieSource = .off
+        let managedAccountID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-111111111111"))
+        let managedAccount = ManagedCodexAccount(
+            id: managedAccountID,
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-home",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            settings._test_liveSystemCodexAccount = nil
+            try? FileManager.default.removeItem(at: storeURL)
+        }
+
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings._test_liveSystemCodexAccount = self.liveAccount(email: "live@example.com")
+
+        let store = self.makeUsageStore(settings: settings)
+        store._setSnapshotForTesting(self.codexSnapshot(email: "live@example.com", usedPercent: 30), provider: .codex)
+        store.lastCodexAccountScopedRefreshGuard = store
+            .currentCodexAccountScopedRefreshGuard(preferCurrentSnapshot: false)
+        self.installImmediateCodexProvider(
+            on: store,
+            snapshot: self.codexSnapshot(email: "managed@example.com", usedPercent: 9))
+        store._test_codexCreditsLoaderOverride = { self.credits(remaining: 55) }
+        defer { store._test_codexCreditsLoaderOverride = nil }
+
+        let pane = ProvidersPane(settings: settings, store: store)
+        await pane._test_selectCodexVisibleAccount(id: "managed@example.com")
+
+        #expect(settings.codexActiveSource == .managedAccount(id: managedAccountID))
+        #expect(store.snapshots[.codex]?.accountEmail(for: .codex) == "managed@example.com")
+        #expect(store.credits?.remaining == 55)
+    }
+}
diff --git a/Tests/CodexBarTests/CodexAccountVisibleHistoryBackfillTests.swift b/Tests/CodexBarTests/CodexAccountVisibleHistoryBackfillTests.swift
new file mode 100644
index 0000000000..b97059d186
--- /dev/null
+++ b/Tests/CodexBarTests/CodexAccountVisibleHistoryBackfillTests.swift
@@ -0,0 +1,1540 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@MainActor
+extension CodexAccountScopedRefreshTests {
+    @Test
+    func `repairs collapsed codex windows from matching provider account history`() async throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountVisibleHistoryBackfillTests")
+        settings.refreshFrequency = .manual
+        settings.multiAccountMenuLayout = .stacked
+
+        let targetID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-222222222222"))
+        let siblingID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-333333333333"))
+        let targetHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-target-\(UUID().uuidString)", isDirectory: true)
+        let siblingHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-sibling-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: targetHome, withIntermediateDirectories: true)
+        try FileManager.default.createDirectory(at: siblingHome, withIntermediateDirectories: true)
+        let targetAccount = ManagedCodexAccount(
+            id: targetID,
+            email: "target@example.com",
+            providerAccountID: "acct-target",
+            workspaceLabel: "Target Team",
+            workspaceAccountID: "acct-target",
+            managedHomePath: targetHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let siblingAccount = ManagedCodexAccount(
+            id: siblingID,
+            email: "sibling@example.com",
+            providerAccountID: "acct-sibling",
+            workspaceLabel: "Sibling Team",
+            workspaceAccountID: "acct-sibling",
+            managedHomePath: siblingHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [targetAccount, siblingAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            try? FileManager.default.removeItem(at: storeURL)
+            try? FileManager.default.removeItem(at: targetHome)
+            try? FileManager.default.removeItem(at: siblingHome)
+        }
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .managedAccount(id: targetID)
+
+        let snapshotStore = RecordingCodexAccountUsageSnapshotStore(initialSnapshots: [])
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            codexAccountUsageSnapshotStore: snapshotStore,
+            startupBehavior: .testing)
+        let now = Date()
+        self.installContextualCodexProvider(on: store) { context in
+            let isTarget = context.env["CODEX_HOME"] == targetHome.path
+            return UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: isTarget ? 1 : 22,
+                    windowMinutes: 0,
+                    resetsAt: nil,
+                    resetDescription: nil),
+                secondary: nil,
+                updatedAt: now)
+        }
+
+        let targetHistoryKey = try #require(CodexHistoryOwnership.canonicalKey(for: .providerAccount(
+            id: "acct-target")))
+        let sessionReset = now.addingTimeInterval(4 * 60 * 60)
+        let weeklyReset = now.addingTimeInterval(4 * 24 * 60 * 60)
+        store.planUtilizationHistory[.codex] = PlanUtilizationHistoryBuckets(accounts: [
+            targetHistoryKey: [
+                planSeries(name: .session, windowMinutes: 300, entries: [
+                    planEntry(at: now.addingTimeInterval(-60), usedPercent: 1, resetsAt: sessionReset),
+                ]),
+                planSeries(name: .weekly, windowMinutes: 10080, entries: [
+                    planEntry(at: now.addingTimeInterval(-60), usedPercent: 13, resetsAt: weeklyReset),
+                ]),
+            ],
+        ])
+
+        await store.refreshCodexVisibleAccountsForMenu()
+
+        let targetSnapshot = try #require(store.codexAccountSnapshots.first {
+            $0.account.workspaceAccountID == "acct-target"
+        }?.snapshot)
+        #expect(targetSnapshot.primary?.usedPercent == 1)
+        #expect(targetSnapshot.primary?.windowMinutes == 300)
+        #expect(targetSnapshot.primary?.resetsAt == sessionReset)
+        #expect(targetSnapshot.secondary?.usedPercent == 13)
+        #expect(targetSnapshot.secondary?.windowMinutes == 10080)
+        #expect(targetSnapshot.secondary?.resetsAt == weeklyReset)
+
+        let siblingSnapshot = try #require(store.codexAccountSnapshots.first {
+            $0.account.workspaceAccountID == "acct-sibling"
+        }?.snapshot)
+        #expect(siblingSnapshot.primary?.windowMinutes == 0)
+        #expect(siblingSnapshot.primary?.resetsAt == nil)
+        #expect(siblingSnapshot.secondary == nil)
+
+        let persistedTarget = try #require(snapshotStore.storedSnapshots.first {
+            $0.account.workspaceAccountID == "acct-target"
+        }?.snapshot)
+        #expect(persistedTarget.primary?.resetsAt == sessionReset)
+        #expect(persistedTarget.secondary?.resetsAt == weeklyReset)
+        #expect(store.snapshots[.codex]?.primary?.resetsAt == sessionReset)
+        #expect(store.snapshots[.codex]?.secondary?.resetsAt == weeklyReset)
+        #expect(store.planUtilizationHistory[.codex]?.accounts[targetHistoryKey]?.count == 2)
+    }
+
+    @Test
+    func `materializes single visible codex account email history into provider account history`() throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountVisibleHistoryBackfillTests-single-account-materialize")
+        let store = self.makeUsageStore(settings: settings)
+        let visibleAccount = CodexVisibleAccount(
+            id: "materialize@example.com",
+            email: "materialize@example.com",
+            workspaceLabel: "Target Team",
+            workspaceAccountID: "acct-materialize",
+            storedAccountID: nil,
+            selectionSource: .managedAccount(id: UUID()),
+            isActive: true,
+            isLive: false,
+            canReauthenticate: true,
+            canRemove: true)
+        let providerHistoryKey = try #require(CodexHistoryOwnership.canonicalKey(for: .providerAccount(
+            id: "acct-materialize")))
+        let emailHistoryKey = CodexHistoryOwnership.canonicalEmailHashKey(for: "materialize@example.com")
+        let legacyEmailHistoryKey = UsageStore._codexLegacyPlanUtilizationEmailHashKeyForTesting(
+            normalizedEmail: "materialize@example.com")
+        let session = planSeries(name: .session, windowMinutes: 300, entries: [
+            planEntry(at: Date(timeIntervalSince1970: 1_800_000_000), usedPercent: 1),
+        ])
+        let weekly = planSeries(name: .weekly, windowMinutes: 10080, entries: [
+            planEntry(at: Date(timeIntervalSince1970: 1_800_086_400), usedPercent: 13),
+        ])
+        store.planUtilizationHistory[.codex] = PlanUtilizationHistoryBuckets(accounts: [
+            emailHistoryKey: [session],
+            legacyEmailHistoryKey: [weekly],
+        ])
+
+        let histories = store.codexPlanUtilizationHistories(forVisibleAccount: visibleAccount)
+
+        #expect(histories == [session, weekly])
+        #expect(store.planUtilizationHistory[.codex]?.accounts[providerHistoryKey] == [session, weekly])
+        #expect(store.planUtilizationHistory[.codex]?.accounts[emailHistoryKey] == nil)
+        #expect(store.planUtilizationHistory[.codex]?.accounts[legacyEmailHistoryKey] == nil)
+    }
+
+    @Test
+    func `materializes provider account email history when sibling visible account uses another email`() throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountVisibleHistoryBackfillTests-different-email-materialize")
+        settings.multiAccountMenuLayout = .stacked
+        let targetID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-121212121212"))
+        let siblingID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-343434343434"))
+        let targetAccount = ManagedCodexAccount(
+            id: targetID,
+            email: "materialize-stack@example.com",
+            providerAccountID: "acct-materialize-stack",
+            workspaceLabel: "Target Team",
+            workspaceAccountID: "acct-materialize-stack",
+            managedHomePath: "/tmp/materialize-stack-target",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let siblingAccount = ManagedCodexAccount(
+            id: siblingID,
+            email: "other-stack@example.com",
+            providerAccountID: "acct-materialize-other",
+            workspaceLabel: "Other Team",
+            workspaceAccountID: "acct-materialize-other",
+            managedHomePath: "/tmp/materialize-stack-other",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [targetAccount, siblingAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            try? FileManager.default.removeItem(at: storeURL)
+        }
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .managedAccount(id: targetID)
+        let store = self.makeUsageStore(settings: settings)
+        let visibleAccount = try #require(settings.codexVisibleAccountProjection.visibleAccounts.first {
+            $0.workspaceAccountID == "acct-materialize-stack"
+        })
+        let providerHistoryKey = try #require(CodexHistoryOwnership.canonicalKey(for: .providerAccount(
+            id: "acct-materialize-stack")))
+        let emailHistoryKey = CodexHistoryOwnership.canonicalEmailHashKey(for: "materialize-stack@example.com")
+        let legacyEmailHistoryKey = UsageStore._codexLegacyPlanUtilizationEmailHashKeyForTesting(
+            normalizedEmail: "materialize-stack@example.com")
+        let session = planSeries(name: .session, windowMinutes: 300, entries: [
+            planEntry(at: Date(timeIntervalSince1970: 1_800_000_000), usedPercent: 1),
+        ])
+        let weekly = planSeries(name: .weekly, windowMinutes: 10080, entries: [
+            planEntry(at: Date(timeIntervalSince1970: 1_800_086_400), usedPercent: 13),
+        ])
+        store.planUtilizationHistory[.codex] = PlanUtilizationHistoryBuckets(accounts: [
+            emailHistoryKey: [session],
+            legacyEmailHistoryKey: [weekly],
+        ])
+
+        let histories = store.codexPlanUtilizationHistories(forVisibleAccount: visibleAccount)
+
+        #expect(histories == [session, weekly])
+        #expect(store.planUtilizationHistory[.codex]?.accounts[providerHistoryKey] == [session, weekly])
+        #expect(store.planUtilizationHistory[.codex]?.accounts[emailHistoryKey] == nil)
+        #expect(store.planUtilizationHistory[.codex]?.accounts[legacyEmailHistoryKey] == nil)
+    }
+
+    @Test
+    func `selected codex refresh keeps ambiguous same email history out of provider account`() async throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountVisibleHistoryBackfillTests-selected-ambiguous-history")
+        settings.refreshFrequency = .manual
+        settings.multiAccountMenuLayout = .stacked
+
+        let targetID = try #require(UUID(uuidString: "CCCCCCCC-DDDD-EEEE-FFFF-111111111111"))
+        let siblingID = try #require(UUID(uuidString: "CCCCCCCC-DDDD-EEEE-FFFF-222222222222"))
+        let targetHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-selected-history-target-\(UUID().uuidString)", isDirectory: true)
+        let siblingHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-selected-history-sibling-\(UUID().uuidString)", isDirectory: true)
+        try Self.writeCodexAuthFile(
+            homeURL: targetHome,
+            email: "selected-shared@example.com",
+            plan: "pro",
+            accountId: "acct-selected-target")
+        try Self.writeCodexAuthFile(
+            homeURL: siblingHome,
+            email: "selected-shared@example.com",
+            plan: "pro",
+            accountId: "acct-selected-sibling")
+        let targetAccount = ManagedCodexAccount(
+            id: targetID,
+            email: "selected-shared@example.com",
+            providerAccountID: "acct-selected-target",
+            workspaceLabel: "Target Team",
+            workspaceAccountID: "acct-selected-target",
+            managedHomePath: targetHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let siblingAccount = ManagedCodexAccount(
+            id: siblingID,
+            email: "selected-shared@example.com",
+            providerAccountID: "acct-selected-sibling",
+            workspaceLabel: "Sibling Team",
+            workspaceAccountID: "acct-selected-sibling",
+            managedHomePath: siblingHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [targetAccount, siblingAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            try? FileManager.default.removeItem(at: storeURL)
+            try? FileManager.default.removeItem(at: targetHome)
+            try? FileManager.default.removeItem(at: siblingHome)
+        }
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .managedAccount(id: targetID)
+
+        let store = self.makeUsageStore(settings: settings)
+        let now = Date(timeIntervalSince1970: 1_800_000_000)
+        let providerHistoryKey = try #require(CodexHistoryOwnership.canonicalKey(for: .providerAccount(
+            id: "acct-selected-target")))
+        let emailHistoryKey = CodexHistoryOwnership.canonicalEmailHashKey(for: "selected-shared@example.com")
+        let legacyEmailHistoryKey = UsageStore._codexLegacyPlanUtilizationEmailHashKeyForTesting(
+            normalizedEmail: "selected-shared@example.com")
+        let staleSession = planSeries(name: .session, windowMinutes: 300, entries: [
+            planEntry(at: now.addingTimeInterval(-2 * 60 * 60), usedPercent: 12),
+        ])
+        let staleWeekly = planSeries(name: .weekly, windowMinutes: 10080, entries: [
+            planEntry(at: now.addingTimeInterval(-2 * 60 * 60), usedPercent: 24),
+        ])
+        store.planUtilizationHistory[.codex] = PlanUtilizationHistoryBuckets(accounts: [
+            emailHistoryKey: [staleSession],
+            legacyEmailHistoryKey: [staleWeekly],
+        ])
+        let currentSnapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 4,
+                windowMinutes: 300,
+                resetsAt: now.addingTimeInterval(3 * 60 * 60),
+                resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: 6,
+                windowMinutes: 10080,
+                resetsAt: now.addingTimeInterval(3 * 24 * 60 * 60),
+                resetDescription: nil),
+            updatedAt: now,
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: "selected-shared@example.com",
+                accountOrganization: nil,
+                loginMethod: "Target Team"))
+
+        await store.recordPlanUtilizationHistorySample(
+            provider: .codex,
+            snapshot: currentSnapshot,
+            now: now)
+
+        let buckets = try #require(store.planUtilizationHistory[.codex])
+        let providerHistory = try #require(buckets.accounts[providerHistoryKey])
+        #expect(providerHistory.flatMap(\.entries).allSatisfy { $0.capturedAt == now })
+        #expect(buckets.accounts[emailHistoryKey] == [staleSession])
+        #expect(buckets.accounts[legacyEmailHistoryKey] == [staleWeekly])
+    }
+
+    @Test
+    func `ignores active reset cache from another visible codex workspace`() async throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountVisibleHistoryBackfillTests-stale-active-cache")
+        settings.refreshFrequency = .manual
+        settings.multiAccountMenuLayout = .stacked
+
+        let targetID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-444444444444"))
+        let siblingID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-555555555555"))
+        let targetHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-cache-target-\(UUID().uuidString)", isDirectory: true)
+        let siblingHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-cache-sibling-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: targetHome, withIntermediateDirectories: true)
+        try FileManager.default.createDirectory(at: siblingHome, withIntermediateDirectories: true)
+        let targetAccount = ManagedCodexAccount(
+            id: targetID,
+            email: "shared@example.com",
+            providerAccountID: "acct-cache-target",
+            workspaceLabel: "Target Team",
+            workspaceAccountID: "acct-cache-target",
+            managedHomePath: targetHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let siblingAccount = ManagedCodexAccount(
+            id: siblingID,
+            email: "shared@example.com",
+            providerAccountID: "acct-cache-sibling",
+            workspaceLabel: "Sibling Team",
+            workspaceAccountID: "acct-cache-sibling",
+            managedHomePath: siblingHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [targetAccount, siblingAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            try? FileManager.default.removeItem(at: storeURL)
+            try? FileManager.default.removeItem(at: targetHome)
+            try? FileManager.default.removeItem(at: siblingHome)
+        }
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .managedAccount(id: targetID)
+
+        let snapshotStore = RecordingCodexAccountUsageSnapshotStore(initialSnapshots: [])
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            codexAccountUsageSnapshotStore: snapshotStore,
+            startupBehavior: .testing)
+        let now = Date()
+        let staleReset = now.addingTimeInterval(2 * 60 * 60)
+        store.lastCodexAccountScopedRefreshGuard = CodexAccountScopedRefreshGuard(
+            source: .managedAccount(id: siblingID),
+            identity: .providerAccount(id: "acct-cache-sibling"),
+            accountKey: "shared@example.com")
+        store.lastKnownResetSnapshots[.codex] = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 44,
+                windowMinutes: 300,
+                resetsAt: staleReset,
+                resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: 55,
+                windowMinutes: 10080,
+                resetsAt: now.addingTimeInterval(2 * 24 * 60 * 60),
+                resetDescription: nil),
+            updatedAt: now,
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: "shared@example.com",
+                accountOrganization: nil,
+                loginMethod: "Sibling Team"))
+        self.installContextualCodexProvider(on: store) { context in
+            let isTarget = context.env["CODEX_HOME"] == targetHome.path
+            return UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: isTarget ? 4 : 9,
+                    windowMinutes: 0,
+                    resetsAt: nil,
+                    resetDescription: nil),
+                secondary: nil,
+                updatedAt: now)
+        }
+
+        await store.refreshCodexVisibleAccountsForMenu()
+
+        let targetSnapshot = try #require(store.codexAccountSnapshots.first {
+            $0.account.workspaceAccountID == "acct-cache-target"
+        }?.snapshot)
+        #expect(targetSnapshot.primary?.usedPercent == 4)
+        #expect(targetSnapshot.primary?.windowMinutes == 0)
+        #expect(targetSnapshot.primary?.resetsAt == nil)
+        #expect(targetSnapshot.secondary == nil)
+        #expect(store.snapshots[.codex]?.primary?.resetsAt == nil)
+        #expect(store.snapshots[.codex]?.secondary == nil)
+        #expect(store.lastKnownResetSnapshots[.codex]?.primary?.resetsAt == nil)
+        #expect(snapshotStore.storedSnapshots.first {
+            $0.account.workspaceAccountID == "acct-cache-target"
+        }?.snapshot?.primary?.resetsAt == nil)
+    }
+
+    @Test
+    func `uses active reset cache when scoped guard matches codex workspace with plan label`() async throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountVisibleHistoryBackfillTests-current-active-cache")
+        settings.refreshFrequency = .manual
+        settings.multiAccountMenuLayout = .stacked
+
+        let targetID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-666666666666"))
+        let siblingID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-777777777777"))
+        let targetHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-current-target-\(UUID().uuidString)", isDirectory: true)
+        let siblingHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-current-sibling-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: targetHome, withIntermediateDirectories: true)
+        try FileManager.default.createDirectory(at: siblingHome, withIntermediateDirectories: true)
+        let targetAccount = ManagedCodexAccount(
+            id: targetID,
+            email: "current@example.com",
+            providerAccountID: "acct-current-target",
+            workspaceLabel: "Target Team",
+            workspaceAccountID: "acct-current-target",
+            managedHomePath: targetHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let siblingAccount = ManagedCodexAccount(
+            id: siblingID,
+            email: "current@example.com",
+            providerAccountID: "acct-current-sibling",
+            workspaceLabel: "Sibling Team",
+            workspaceAccountID: "acct-current-sibling",
+            managedHomePath: siblingHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [targetAccount, siblingAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            try? FileManager.default.removeItem(at: storeURL)
+            try? FileManager.default.removeItem(at: targetHome)
+            try? FileManager.default.removeItem(at: siblingHome)
+        }
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .managedAccount(id: targetID)
+
+        let now = Date()
+        let staleSessionReset = now.addingTimeInterval(3 * 60 * 60)
+        let staleWeeklyReset = now.addingTimeInterval(3 * 24 * 60 * 60)
+        let priorSnapshots = settings.codexVisibleAccountProjection.visibleAccounts.map { account in
+            CodexAccountUsageSnapshot(
+                account: account,
+                snapshot: account.workspaceAccountID == "acct-current-target"
+                    ? UsageSnapshot(
+                        primary: RateWindow(
+                            usedPercent: 2,
+                            windowMinutes: 300,
+                            resetsAt: staleSessionReset,
+                            resetDescription: nil),
+                        secondary: RateWindow(
+                            usedPercent: 3,
+                            windowMinutes: 10080,
+                            resetsAt: staleWeeklyReset,
+                            resetDescription: nil),
+                        updatedAt: now.addingTimeInterval(-60))
+                    : nil,
+                error: nil,
+                sourceLabel: "cached")
+        }
+        let snapshotStore = RecordingCodexAccountUsageSnapshotStore(initialSnapshots: priorSnapshots)
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            codexAccountUsageSnapshotStore: snapshotStore,
+            startupBehavior: .testing)
+        let sessionReset = now.addingTimeInterval(2 * 60 * 60)
+        let weeklyReset = now.addingTimeInterval(2 * 24 * 60 * 60)
+        store.lastCodexAccountScopedRefreshGuard = CodexAccountScopedRefreshGuard(
+            source: .managedAccount(id: targetID),
+            identity: .providerAccount(id: "acct-current-target"),
+            accountKey: "current@example.com")
+        store.lastKnownResetSnapshots[.codex] = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 44,
+                windowMinutes: 300,
+                resetsAt: sessionReset,
+                resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: 55,
+                windowMinutes: 10080,
+                resetsAt: weeklyReset,
+                resetDescription: nil),
+            updatedAt: now,
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: "current@example.com",
+                accountOrganization: nil,
+                loginMethod: "Pro"))
+        self.installContextualCodexProvider(on: store) { context in
+            let isTarget = context.env["CODEX_HOME"] == targetHome.path
+            return UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: isTarget ? 4 : 9,
+                    windowMinutes: 0,
+                    resetsAt: nil,
+                    resetDescription: nil),
+                secondary: nil,
+                updatedAt: now)
+        }
+
+        await store.refreshCodexVisibleAccountsForMenu()
+
+        let targetSnapshot = try #require(store.codexAccountSnapshots.first {
+            $0.account.workspaceAccountID == "acct-current-target"
+        }?.snapshot)
+        #expect(targetSnapshot.primary?.usedPercent == 4)
+        #expect(targetSnapshot.primary?.windowMinutes == 300)
+        #expect(targetSnapshot.primary?.resetsAt == sessionReset)
+        #expect(targetSnapshot.secondary?.usedPercent == 55)
+        #expect(targetSnapshot.secondary?.windowMinutes == 10080)
+        #expect(targetSnapshot.secondary?.resetsAt == weeklyReset)
+        #expect(store.snapshots[.codex]?.primary?.resetsAt == sessionReset)
+        #expect(store.snapshots[.codex]?.secondary?.resetsAt == weeklyReset)
+        #expect(snapshotStore.storedSnapshots.first {
+            $0.account.workspaceAccountID == "acct-current-target"
+        }?.snapshot?.secondary?.resetsAt == weeklyReset)
+    }
+
+    @Test
+    func `ignores prior snapshot from same email different codex workspace`() async throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountVisibleHistoryBackfillTests-prior-workspace")
+        settings.refreshFrequency = .manual
+        settings.multiAccountMenuLayout = .stacked
+
+        let targetID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-888888888888"))
+        let oldID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-999999999999"))
+        let siblingID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-AAAAAAAAAAAA"))
+        let targetHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-prior-target-\(UUID().uuidString)", isDirectory: true)
+        let siblingHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-prior-sibling-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: targetHome, withIntermediateDirectories: true)
+        try FileManager.default.createDirectory(at: siblingHome, withIntermediateDirectories: true)
+        let targetAccount = ManagedCodexAccount(
+            id: targetID,
+            email: "prior@example.com",
+            providerAccountID: "acct-prior-new",
+            workspaceLabel: "New Team",
+            workspaceAccountID: "acct-prior-new",
+            managedHomePath: targetHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let siblingAccount = ManagedCodexAccount(
+            id: siblingID,
+            email: "other-prior@example.com",
+            providerAccountID: "acct-prior-sibling",
+            workspaceLabel: "Sibling Team",
+            workspaceAccountID: "acct-prior-sibling",
+            managedHomePath: siblingHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let oldVisibleAccount = CodexVisibleAccount(
+            id: "prior@example.com",
+            email: "prior@example.com",
+            workspaceLabel: "Old Team",
+            workspaceAccountID: "acct-prior-old",
+            storedAccountID: oldID,
+            selectionSource: .managedAccount(id: oldID),
+            isActive: false,
+            isLive: false,
+            canReauthenticate: false,
+            canRemove: false)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [targetAccount, siblingAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            try? FileManager.default.removeItem(at: storeURL)
+            try? FileManager.default.removeItem(at: targetHome)
+            try? FileManager.default.removeItem(at: siblingHome)
+        }
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .managedAccount(id: targetID)
+
+        let now = Date()
+        let staleReset = now.addingTimeInterval(2 * 60 * 60)
+        let snapshotStore = RecordingCodexAccountUsageSnapshotStore(initialSnapshots: [
+            CodexAccountUsageSnapshot(
+                account: oldVisibleAccount,
+                snapshot: UsageSnapshot(
+                    primary: RateWindow(
+                        usedPercent: 72,
+                        windowMinutes: 300,
+                        resetsAt: staleReset,
+                        resetDescription: nil),
+                    secondary: nil,
+                    updatedAt: now,
+                    identity: ProviderIdentitySnapshot(
+                        providerID: .codex,
+                        accountEmail: "prior@example.com",
+                        accountOrganization: nil,
+                        loginMethod: "Old Team")),
+                error: nil,
+                sourceLabel: "cached"),
+        ])
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            codexAccountUsageSnapshotStore: snapshotStore,
+            startupBehavior: .testing)
+        self.installContextualCodexProvider(on: store) { context in
+            let isTarget = context.env["CODEX_HOME"] == targetHome.path
+            return UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: isTarget ? 4 : 9,
+                    windowMinutes: 0,
+                    resetsAt: nil,
+                    resetDescription: nil),
+                secondary: nil,
+                updatedAt: now)
+        }
+
+        await store.refreshCodexVisibleAccountsForMenu()
+
+        let targetSnapshot = try #require(store.codexAccountSnapshots.first {
+            $0.account.workspaceAccountID == "acct-prior-new"
+        }?.snapshot)
+        #expect(targetSnapshot.primary?.usedPercent == 4)
+        #expect(targetSnapshot.primary?.windowMinutes == 0)
+        #expect(targetSnapshot.primary?.resetsAt == nil)
+        #expect(targetSnapshot.secondary == nil)
+    }
+
+    @Test
+    func `ignores ambiguous email history for same email codex workspaces`() async throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountVisibleHistoryBackfillTests-ambiguous-email-history")
+        settings.refreshFrequency = .manual
+        settings.multiAccountMenuLayout = .stacked
+
+        let targetID = try #require(UUID(uuidString: "BBBBBBBB-CCCC-DDDD-EEEE-111111111111"))
+        let siblingID = try #require(UUID(uuidString: "BBBBBBBB-CCCC-DDDD-EEEE-222222222222"))
+        let targetHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-history-target-\(UUID().uuidString)", isDirectory: true)
+        let siblingHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-history-sibling-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: targetHome, withIntermediateDirectories: true)
+        try FileManager.default.createDirectory(at: siblingHome, withIntermediateDirectories: true)
+        let targetAccount = ManagedCodexAccount(
+            id: targetID,
+            email: "history-shared@example.com",
+            providerAccountID: "acct-history-target",
+            workspaceLabel: "Target Team",
+            workspaceAccountID: "acct-history-target",
+            managedHomePath: targetHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let siblingAccount = ManagedCodexAccount(
+            id: siblingID,
+            email: "history-shared@example.com",
+            providerAccountID: "acct-history-sibling",
+            workspaceLabel: "Sibling Team",
+            workspaceAccountID: "acct-history-sibling",
+            managedHomePath: siblingHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [targetAccount, siblingAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            try? FileManager.default.removeItem(at: storeURL)
+            try? FileManager.default.removeItem(at: targetHome)
+            try? FileManager.default.removeItem(at: siblingHome)
+        }
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .managedAccount(id: targetID)
+
+        let snapshotStore = RecordingCodexAccountUsageSnapshotStore(initialSnapshots: [])
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            codexAccountUsageSnapshotStore: snapshotStore,
+            startupBehavior: .testing)
+        let now = Date()
+        let normalizedEmail = try #require(CodexIdentityResolver.normalizeEmail("history-shared@example.com"))
+        let emailHistoryKey = CodexHistoryOwnership.canonicalEmailHashKey(for: normalizedEmail)
+        store.planUtilizationHistory[.codex] = PlanUtilizationHistoryBuckets(accounts: [
+            emailHistoryKey: [
+                planSeries(name: .session, windowMinutes: 300, entries: [
+                    planEntry(at: now.addingTimeInterval(-60), usedPercent: 2, resetsAt: now.addingTimeInterval(3600)),
+                ]),
+                planSeries(name: .weekly, windowMinutes: 10080, entries: [
+                    planEntry(
+                        at: now.addingTimeInterval(-60),
+                        usedPercent: 33,
+                        resetsAt: now.addingTimeInterval(4 * 24 * 60 * 60)),
+                ]),
+            ],
+        ])
+        self.installContextualCodexProvider(on: store) { context in
+            let isTarget = context.env["CODEX_HOME"] == targetHome.path
+            return UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: isTarget ? 4 : 9,
+                    windowMinutes: 0,
+                    resetsAt: nil,
+                    resetDescription: nil),
+                secondary: nil,
+                updatedAt: now)
+        }
+
+        await store.refreshCodexVisibleAccountsForMenu()
+
+        let targetSnapshot = try #require(store.codexAccountSnapshots.first {
+            $0.account.workspaceAccountID == "acct-history-target"
+        }?.snapshot)
+        #expect(targetSnapshot.primary?.usedPercent == 4)
+        #expect(targetSnapshot.primary?.windowMinutes == 0)
+        #expect(targetSnapshot.primary?.resetsAt == nil)
+        #expect(targetSnapshot.secondary == nil)
+        #expect(store.planUtilizationHistory[.codex]?.histories(for: emailHistoryKey).isEmpty == false)
+    }
+
+    @Test
+    func `backfills live codex row from same id prior snapshot`() async throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountVisibleHistoryBackfillTests-live-prior")
+        settings.refreshFrequency = .manual
+        settings.multiAccountMenuLayout = .stacked
+
+        let managedID = try #require(UUID(uuidString: "DDDDDDDD-EEEE-FFFF-AAAA-111111111111"))
+        let liveHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-live-prior-\(UUID().uuidString)", isDirectory: true)
+        let managedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-live-prior-managed-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: liveHome, withIntermediateDirectories: true)
+        try FileManager.default.createDirectory(at: managedHome, withIntermediateDirectories: true)
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "live-prior@example.com",
+            codexHomePath: liveHome.path,
+            observedAt: Date(),
+            identity: .emailOnly(normalizedEmail: "live-prior@example.com"))
+        let managedAccount = ManagedCodexAccount(
+            id: managedID,
+            email: "managed-prior@example.com",
+            providerAccountID: "acct-managed-prior",
+            workspaceLabel: "Managed Team",
+            workspaceAccountID: "acct-managed-prior",
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            settings._test_liveSystemCodexAccount = nil
+            try? FileManager.default.removeItem(at: storeURL)
+            try? FileManager.default.removeItem(at: liveHome)
+            try? FileManager.default.removeItem(at: managedHome)
+        }
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .managedAccount(id: managedID)
+
+        let now = Date()
+        let priorReset = now.addingTimeInterval(2 * 60 * 60)
+        let priorSnapshots = settings.codexVisibleAccountProjection.visibleAccounts.map { account in
+            CodexAccountUsageSnapshot(
+                account: account,
+                snapshot: account.selectionSource == .liveSystem
+                    ? UsageSnapshot(
+                        primary: RateWindow(
+                            usedPercent: 18,
+                            windowMinutes: 300,
+                            resetsAt: priorReset,
+                            resetDescription: nil),
+                        secondary: nil,
+                        updatedAt: now.addingTimeInterval(-60))
+                    : nil,
+                error: nil,
+                sourceLabel: "cached")
+        }
+        let snapshotStore = RecordingCodexAccountUsageSnapshotStore(initialSnapshots: priorSnapshots)
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            codexAccountUsageSnapshotStore: snapshotStore,
+            startupBehavior: .testing)
+        self.installContextualCodexProvider(on: store) { _ in
+            UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 9,
+                    windowMinutes: 0,
+                    resetsAt: nil,
+                    resetDescription: nil),
+                secondary: nil,
+                updatedAt: now)
+        }
+
+        await store.refreshCodexVisibleAccountsForMenu()
+
+        let liveSnapshot = try #require(store.codexAccountSnapshots.first {
+            $0.account.selectionSource == .liveSystem
+        }?.snapshot)
+        #expect(liveSnapshot.primary?.usedPercent == 9)
+        #expect(liveSnapshot.primary?.windowMinutes == 300)
+        #expect(liveSnapshot.primary?.resetsAt == priorReset)
+    }
+
+    @Test
+    func `ignores live codex prior snapshot after auth fingerprint changes`() async throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountVisibleHistoryBackfillTests-live-prior-auth-change")
+        settings.refreshFrequency = .manual
+        settings.multiAccountMenuLayout = .stacked
+
+        let managedID = try #require(UUID(uuidString: "DDDDDDDD-EEEE-FFFF-AAAA-222222222222"))
+        let liveHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-live-prior-auth-\(UUID().uuidString)", isDirectory: true)
+        let managedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-live-prior-auth-managed-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: liveHome, withIntermediateDirectories: true)
+        try FileManager.default.createDirectory(at: managedHome, withIntermediateDirectories: true)
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "live-prior-auth@example.com",
+            authFingerprint: "current-live-auth-fingerprint",
+            codexHomePath: liveHome.path,
+            observedAt: Date(),
+            identity: .emailOnly(normalizedEmail: "live-prior-auth@example.com"))
+        let managedAccount = ManagedCodexAccount(
+            id: managedID,
+            email: "managed-prior-auth@example.com",
+            providerAccountID: "acct-managed-prior-auth",
+            workspaceLabel: "Managed Team",
+            workspaceAccountID: "acct-managed-prior-auth",
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            settings._test_liveSystemCodexAccount = nil
+            try? FileManager.default.removeItem(at: storeURL)
+            try? FileManager.default.removeItem(at: liveHome)
+            try? FileManager.default.removeItem(at: managedHome)
+        }
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .managedAccount(id: managedID)
+
+        let now = Date()
+        let priorReset = now.addingTimeInterval(2 * 60 * 60)
+        let liveAccount = try #require(settings.codexVisibleAccountProjection.visibleAccounts.first {
+            $0.selectionSource == .liveSystem
+        })
+        let priorLiveAccount = CodexVisibleAccount(
+            id: liveAccount.id,
+            email: liveAccount.email,
+            workspaceLabel: liveAccount.workspaceLabel,
+            workspaceAccountID: liveAccount.workspaceAccountID,
+            authFingerprint: "stale-live-auth-fingerprint",
+            storedAccountID: liveAccount.storedAccountID,
+            selectionSource: liveAccount.selectionSource,
+            isActive: liveAccount.isActive,
+            isLive: liveAccount.isLive,
+            canReauthenticate: liveAccount.canReauthenticate,
+            canRemove: liveAccount.canRemove)
+        let snapshotStore = RecordingCodexAccountUsageSnapshotStore(initialSnapshots: [
+            CodexAccountUsageSnapshot(
+                account: priorLiveAccount,
+                snapshot: UsageSnapshot(
+                    primary: RateWindow(
+                        usedPercent: 18,
+                        windowMinutes: 300,
+                        resetsAt: priorReset,
+                        resetDescription: nil),
+                    secondary: nil,
+                    updatedAt: now.addingTimeInterval(-60)),
+                error: nil,
+                sourceLabel: "cached"),
+        ])
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            codexAccountUsageSnapshotStore: snapshotStore,
+            startupBehavior: .testing)
+        self.installContextualCodexProvider(on: store) { _ in
+            UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 9,
+                    windowMinutes: 0,
+                    resetsAt: nil,
+                    resetDescription: nil),
+                secondary: nil,
+                updatedAt: now)
+        }
+
+        await store.refreshCodexVisibleAccountsForMenu()
+
+        let liveSnapshot = try #require(store.codexAccountSnapshots.first {
+            $0.account.selectionSource == .liveSystem
+        }?.snapshot)
+        #expect(liveSnapshot.primary?.usedPercent == 9)
+        #expect(liveSnapshot.primary?.windowMinutes == 0)
+        #expect(liveSnapshot.primary?.resetsAt == nil)
+    }
+
+    @Test
+    func `ignores active reset cache and email history after live auth fingerprint changes`() async throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountVisibleHistoryBackfillTests-live-active-auth-change")
+        settings.refreshFrequency = .manual
+        settings.multiAccountMenuLayout = .stacked
+
+        let managedID = try #require(UUID(uuidString: "DDDDDDDD-EEEE-FFFF-AAAA-333333333333"))
+        let liveHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-live-active-auth-\(UUID().uuidString)", isDirectory: true)
+        let managedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-live-active-auth-managed-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: liveHome, withIntermediateDirectories: true)
+        try FileManager.default.createDirectory(at: managedHome, withIntermediateDirectories: true)
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "live-active-auth@example.com",
+            authFingerprint: "current-live-active-auth",
+            codexHomePath: liveHome.path,
+            observedAt: Date(),
+            identity: .emailOnly(normalizedEmail: "live-active-auth@example.com"))
+        let managedAccount = ManagedCodexAccount(
+            id: managedID,
+            email: "managed-active-auth@example.com",
+            providerAccountID: "acct-managed-active-auth",
+            workspaceLabel: "Managed Team",
+            workspaceAccountID: "acct-managed-active-auth",
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            settings._test_liveSystemCodexAccount = nil
+            try? FileManager.default.removeItem(at: storeURL)
+            try? FileManager.default.removeItem(at: liveHome)
+            try? FileManager.default.removeItem(at: managedHome)
+        }
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .liveSystem
+
+        let snapshotStore = RecordingCodexAccountUsageSnapshotStore(initialSnapshots: [])
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            codexAccountUsageSnapshotStore: snapshotStore,
+            startupBehavior: .testing)
+        let now = Date()
+        let staleSessionReset = now.addingTimeInterval(2 * 60 * 60)
+        let staleWeeklyReset = now.addingTimeInterval(2 * 24 * 60 * 60)
+        store.lastCodexAccountScopedRefreshGuard = CodexAccountScopedRefreshGuard(
+            source: .liveSystem,
+            identity: .emailOnly(normalizedEmail: "live-active-auth@example.com"),
+            accountKey: "live-active-auth@example.com",
+            authFingerprint: "stale-live-active-auth")
+        store.lastKnownResetSnapshots[.codex] = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 44,
+                windowMinutes: 300,
+                resetsAt: staleSessionReset,
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: now.addingTimeInterval(-60),
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: "live-active-auth@example.com",
+                accountOrganization: nil,
+                loginMethod: nil))
+        let emailHistoryKey = CodexHistoryOwnership.canonicalEmailHashKey(for: "live-active-auth@example.com")
+        store.planUtilizationHistory[.codex] = PlanUtilizationHistoryBuckets(accounts: [
+            emailHistoryKey: [
+                planSeries(name: .session, windowMinutes: 300, entries: [
+                    planEntry(at: now.addingTimeInterval(-60), usedPercent: 44, resetsAt: staleSessionReset),
+                ]),
+                planSeries(name: .weekly, windowMinutes: 10080, entries: [
+                    planEntry(at: now.addingTimeInterval(-60), usedPercent: 55, resetsAt: staleWeeklyReset),
+                ]),
+            ],
+        ])
+        self.installContextualCodexProvider(on: store) { _ in
+            UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 9,
+                    windowMinutes: 0,
+                    resetsAt: nil,
+                    resetDescription: nil),
+                secondary: nil,
+                updatedAt: now)
+        }
+
+        await store.refreshCodexVisibleAccountsForMenu()
+
+        let liveSnapshot = try #require(store.codexAccountSnapshots.first {
+            $0.account.selectionSource == .liveSystem
+        }?.snapshot)
+        #expect(liveSnapshot.primary?.usedPercent == 9)
+        #expect(liveSnapshot.primary?.windowMinutes == 0)
+        #expect(liveSnapshot.primary?.resetsAt == nil)
+        #expect(liveSnapshot.secondary == nil)
+    }
+
+    @Test
+    func `stacked visible refresh skips selected apply after live auth fingerprint changes`() async throws {
+        SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = 60
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountVisibleHistoryBackfillTests-selected-auth-change")
+        settings.refreshFrequency = .manual
+        settings.multiAccountMenuLayout = .stacked
+
+        let managedID = try #require(UUID(uuidString: "DDDDDDDD-EEEE-FFFF-AAAA-444444444444"))
+        let liveHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-selected-auth-\(UUID().uuidString)", isDirectory: true)
+        let managedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-selected-auth-managed-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: liveHome, withIntermediateDirectories: true)
+        try FileManager.default.createDirectory(at: managedHome, withIntermediateDirectories: true)
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "selected-auth@example.com",
+            authFingerprint: "old-live-selected-auth",
+            codexHomePath: liveHome.path,
+            observedAt: Date(),
+            identity: .emailOnly(normalizedEmail: "selected-auth@example.com"))
+        let managedAccount = ManagedCodexAccount(
+            id: managedID,
+            email: "managed-selected-auth@example.com",
+            providerAccountID: "acct-managed-selected-auth",
+            workspaceLabel: "Managed Team",
+            workspaceAccountID: "acct-managed-selected-auth",
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+        defer {
+            SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = nil
+            settings._test_managedCodexAccountStoreURL = nil
+            settings._test_liveSystemCodexAccount = nil
+            try? FileManager.default.removeItem(at: storeURL)
+            try? FileManager.default.removeItem(at: liveHome)
+            try? FileManager.default.removeItem(at: managedHome)
+        }
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .liveSystem
+        let staleReconciliationSnapshot = settings.codexAccountReconciliationSnapshot
+
+        let snapshotStore = RecordingCodexAccountUsageSnapshotStore(initialSnapshots: [])
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            codexAccountUsageSnapshotStore: snapshotStore,
+            startupBehavior: .testing)
+        let now = Date()
+        let staleReset = now.addingTimeInterval(2 * 60 * 60)
+        let priorDisplayedSnapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 11,
+                windowMinutes: 300,
+                resetsAt: staleReset,
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: now,
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: "selected-auth@example.com",
+                accountOrganization: nil,
+                loginMethod: nil))
+        store._setSnapshotForTesting(priorDisplayedSnapshot, provider: .codex)
+        store.lastKnownResetSnapshots[.codex] = priorDisplayedSnapshot
+        store.lastCodexAccountScopedRefreshGuard = store.currentCodexAccountScopedRefreshGuard(
+            preferCurrentSnapshot: false)
+        let blocker = BlockingCodexFetchStrategy()
+        let liveHomePath = liveHome.path
+        self.installContextualCodexProvider(on: store) { context in
+            if context.env["CODEX_HOME"] == liveHomePath {
+                return try await blocker.awaitResult()
+            }
+            return UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 7,
+                    windowMinutes: 300,
+                    resetsAt: nil,
+                    resetDescription: nil),
+                secondary: nil,
+                updatedAt: now,
+                identity: ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: "managed-selected-auth@example.com",
+                    accountOrganization: nil,
+                    loginMethod: "Managed Team"))
+        }
+
+        let refreshTask = Task { await store.refreshCodexVisibleAccountsForMenu() }
+        await blocker.waitUntilStarted()
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "selected-auth@example.com",
+            authFingerprint: "new-live-selected-auth",
+            codexHomePath: liveHome.path,
+            observedAt: Date(),
+            identity: .emailOnly(normalizedEmail: "selected-auth@example.com"))
+        settings.cachedCodexAccountReconciliationSnapshot = CachedCodexAccountReconciliationSnapshot(
+            activeSource: .liveSystem,
+            loadedAt: Date(),
+            snapshot: staleReconciliationSnapshot)
+        await blocker.resume(with: .success(UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 77,
+                windowMinutes: 300,
+                resetsAt: staleReset,
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: now,
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: "selected-auth@example.com",
+                accountOrganization: nil,
+                loginMethod: nil))))
+        await refreshTask.value
+
+        #expect(store.snapshots[.codex] == nil)
+        #expect(store.lastKnownResetSnapshots[.codex] == nil)
+        #expect(!store.codexAccountSnapshots.contains {
+            $0.account.selectionSource == .liveSystem
+        })
+        #expect(!snapshotStore.storedSnapshots.contains {
+            $0.account.selectionSource == .liveSystem
+        })
+    }
+
+    @Test
+    func `stacked visible refresh keeps selected apply after live token fingerprint rotates`() async throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountVisibleHistoryBackfillTests-selected-token-rotation")
+        settings.refreshFrequency = .manual
+        settings.multiAccountMenuLayout = .stacked
+
+        let managedID = try #require(UUID(uuidString: "DDDDDDDD-EEEE-FFFF-AAAA-888888888888"))
+        let liveHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-selected-token-\(UUID().uuidString)", isDirectory: true)
+        let managedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-selected-token-managed-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: liveHome, withIntermediateDirectories: true)
+        try FileManager.default.createDirectory(at: managedHome, withIntermediateDirectories: true)
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "selected-token@example.com",
+            workspaceLabel: "Live Team",
+            workspaceAccountID: "acct-selected-token",
+            authFingerprint: "old-live-selected-token",
+            codexHomePath: liveHome.path,
+            observedAt: Date(),
+            identity: .providerAccount(id: "acct-selected-token"))
+        let managedAccount = ManagedCodexAccount(
+            id: managedID,
+            email: "managed-selected-token@example.com",
+            providerAccountID: "acct-managed-selected-token",
+            workspaceLabel: "Managed Team",
+            workspaceAccountID: "acct-managed-selected-token",
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            settings._test_liveSystemCodexAccount = nil
+            try? FileManager.default.removeItem(at: storeURL)
+            try? FileManager.default.removeItem(at: liveHome)
+            try? FileManager.default.removeItem(at: managedHome)
+        }
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .liveSystem
+
+        let snapshotStore = RecordingCodexAccountUsageSnapshotStore(initialSnapshots: [])
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            codexAccountUsageSnapshotStore: snapshotStore,
+            startupBehavior: .testing)
+        let blocker = BlockingCodexFetchStrategy()
+        let liveHomePath = liveHome.path
+        let now = Date()
+        let reset = now.addingTimeInterval(2 * 60 * 60)
+        self.installContextualCodexProvider(on: store) { context in
+            if context.env["CODEX_HOME"] == liveHomePath {
+                return try await blocker.awaitResult()
+            }
+            return UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 7,
+                    windowMinutes: 300,
+                    resetsAt: nil,
+                    resetDescription: nil),
+                secondary: nil,
+                updatedAt: now,
+                identity: ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: "managed-selected-token@example.com",
+                    accountOrganization: nil,
+                    loginMethod: "Managed Team"))
+        }
+
+        let refreshTask = Task { await store.refreshCodexVisibleAccountsForMenu() }
+        await blocker.waitUntilStarted()
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "selected-token@example.com",
+            workspaceLabel: "Live Team",
+            workspaceAccountID: "acct-selected-token",
+            authFingerprint: "new-live-selected-token",
+            codexHomePath: liveHome.path,
+            observedAt: Date(),
+            identity: .providerAccount(id: "acct-selected-token"))
+        await blocker.resume(with: .success(UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 77,
+                windowMinutes: 300,
+                resetsAt: reset,
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: now,
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: "selected-token@example.com",
+                accountOrganization: nil,
+                loginMethod: "Pro"))))
+        await refreshTask.value
+
+        let selectedSnapshot = try #require(store.snapshots[.codex])
+        #expect(selectedSnapshot.primary?.usedPercent == 77)
+        #expect(selectedSnapshot.accountEmail(for: .codex) == "selected-token@example.com")
+        #expect(selectedSnapshot.loginMethod(for: .codex) == "Pro")
+        #expect(store.lastCodexAccountScopedRefreshGuard?.authFingerprint == "new-live-selected-token")
+
+        let liveRow = try #require(store.codexAccountSnapshots.first {
+            $0.account.selectionSource == .liveSystem
+        })
+        #expect(liveRow.account.authFingerprint == "new-live-selected-token")
+        #expect(liveRow.snapshot?.primary?.usedPercent == 77)
+
+        let persistedLive = try #require(snapshotStore.storedSnapshots.first {
+            $0.account.selectionSource == .liveSystem
+        })
+        #expect(persistedLive.account.authFingerprint == "new-live-selected-token")
+        #expect(persistedLive.snapshot?.primary?.usedPercent == 77)
+    }
+
+    @Test
+    func `stacked visible refresh clears selected state after live account email changes`() async throws {
+        SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = 60
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountVisibleHistoryBackfillTests-selected-email-change")
+        settings.refreshFrequency = .manual
+        settings.multiAccountMenuLayout = .stacked
+
+        let managedID = try #require(UUID(uuidString: "DDDDDDDD-EEEE-FFFF-AAAA-777777777777"))
+        let liveHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-selected-email-\(UUID().uuidString)", isDirectory: true)
+        let managedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-selected-email-managed-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: liveHome, withIntermediateDirectories: true)
+        try FileManager.default.createDirectory(at: managedHome, withIntermediateDirectories: true)
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "old-selected@example.com",
+            workspaceLabel: "Live Team",
+            workspaceAccountID: "acct-selected-email",
+            authFingerprint: "old-live-selected-email",
+            codexHomePath: liveHome.path,
+            observedAt: Date(),
+            identity: .providerAccount(id: "acct-selected-email"))
+        let managedAccount = ManagedCodexAccount(
+            id: managedID,
+            email: "managed-selected-email@example.com",
+            providerAccountID: "acct-managed-selected-email",
+            workspaceLabel: "Managed Team",
+            workspaceAccountID: "acct-managed-selected-email",
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+        defer {
+            SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = nil
+            settings._test_managedCodexAccountStoreURL = nil
+            settings._test_liveSystemCodexAccount = nil
+            try? FileManager.default.removeItem(at: storeURL)
+            try? FileManager.default.removeItem(at: liveHome)
+            try? FileManager.default.removeItem(at: managedHome)
+        }
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .liveSystem
+        let staleReconciliationSnapshot = settings.codexAccountReconciliationSnapshot
+
+        let snapshotStore = RecordingCodexAccountUsageSnapshotStore(initialSnapshots: [])
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            codexAccountUsageSnapshotStore: snapshotStore,
+            startupBehavior: .testing)
+        let now = Date()
+        let staleReset = now.addingTimeInterval(2 * 60 * 60)
+        let priorDisplayedSnapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 11,
+                windowMinutes: 300,
+                resetsAt: staleReset,
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: now,
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: "old-selected@example.com",
+                accountOrganization: nil,
+                loginMethod: nil))
+        store._setSnapshotForTesting(priorDisplayedSnapshot, provider: .codex)
+        store.lastKnownResetSnapshots[.codex] = priorDisplayedSnapshot
+        store.lastCodexAccountScopedRefreshGuard = store.currentCodexAccountScopedRefreshGuard(
+            preferCurrentSnapshot: false)
+        let blocker = BlockingCodexFetchStrategy()
+        let liveHomePath = liveHome.path
+        self.installContextualCodexProvider(on: store) { context in
+            if context.env["CODEX_HOME"] == liveHomePath {
+                return try await blocker.awaitResult()
+            }
+            return UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 7,
+                    windowMinutes: 300,
+                    resetsAt: nil,
+                    resetDescription: nil),
+                secondary: nil,
+                updatedAt: now,
+                identity: ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: "managed-selected-email@example.com",
+                    accountOrganization: nil,
+                    loginMethod: "Managed Team"))
+        }
+
+        let refreshTask = Task { await store.refreshCodexVisibleAccountsForMenu() }
+        await blocker.waitUntilStarted()
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "new-selected@example.com",
+            workspaceLabel: "Live Team",
+            workspaceAccountID: "acct-selected-email",
+            authFingerprint: "new-live-selected-email",
+            codexHomePath: liveHome.path,
+            observedAt: Date(),
+            identity: .providerAccount(id: "acct-selected-email"))
+        settings.cachedCodexAccountReconciliationSnapshot = CachedCodexAccountReconciliationSnapshot(
+            activeSource: .liveSystem,
+            loadedAt: Date(),
+            snapshot: staleReconciliationSnapshot)
+        await blocker.resume(with: .success(UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 77,
+                windowMinutes: 300,
+                resetsAt: staleReset,
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: now,
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: "old-selected@example.com",
+                accountOrganization: nil,
+                loginMethod: nil))))
+        await refreshTask.value
+
+        #expect(store.snapshots[.codex] == nil)
+        #expect(store.lastKnownResetSnapshots[.codex] == nil)
+        #expect(store.codexAccountSnapshots.isEmpty)
+        #expect(!snapshotStore.storedSnapshots.contains {
+            $0.account.selectionSource == .liveSystem
+        })
+    }
+
+    @Test
+    func `stacked visible refresh keeps selected apply after provider account email changes`() async throws {
+        let settings = self.makeSettingsStore(
+            suite: "CodexAccountVisibleHistoryBackfillTests-selected-provider-email-change")
+        settings.refreshFrequency = .manual
+        settings.multiAccountMenuLayout = .stacked
+
+        let targetID = try #require(UUID(uuidString: "DDDDDDDD-EEEE-FFFF-AAAA-555555555555"))
+        let siblingID = try #require(UUID(uuidString: "DDDDDDDD-EEEE-FFFF-AAAA-666666666666"))
+        let targetHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-provider-email-\(UUID().uuidString)", isDirectory: true)
+        let siblingHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-visible-provider-email-sibling-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: targetHome, withIntermediateDirectories: true)
+        try FileManager.default.createDirectory(at: siblingHome, withIntermediateDirectories: true)
+        let originalTarget = ManagedCodexAccount(
+            id: targetID,
+            email: "old-provider@example.com",
+            providerAccountID: "acct-provider-email",
+            workspaceLabel: "Provider Team",
+            workspaceAccountID: "acct-provider-email",
+            managedHomePath: targetHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let updatedTarget = ManagedCodexAccount(
+            id: targetID,
+            email: "new-provider@example.com",
+            providerAccountID: "acct-provider-email",
+            workspaceLabel: "Provider Team",
+            workspaceAccountID: "acct-provider-email",
+            managedHomePath: targetHome.path,
+            createdAt: 1,
+            updatedAt: 3,
+            lastAuthenticatedAt: 3)
+        let siblingAccount = ManagedCodexAccount(
+            id: siblingID,
+            email: "sibling-provider@example.com",
+            providerAccountID: "acct-provider-sibling",
+            workspaceLabel: "Sibling Team",
+            workspaceAccountID: "acct-provider-sibling",
+            managedHomePath: siblingHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [originalTarget, siblingAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            try? FileManager.default.removeItem(at: storeURL)
+            try? FileManager.default.removeItem(at: targetHome)
+            try? FileManager.default.removeItem(at: siblingHome)
+        }
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .managedAccount(id: targetID)
+
+        let snapshotStore = RecordingCodexAccountUsageSnapshotStore(initialSnapshots: [])
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            codexAccountUsageSnapshotStore: snapshotStore,
+            startupBehavior: .testing)
+        let blocker = BlockingCodexFetchStrategy()
+        let targetHomePath = targetHome.path
+        let now = Date()
+        let reset = now.addingTimeInterval(90 * 60)
+        self.installContextualCodexProvider(on: store) { context in
+            if context.env["CODEX_HOME"] == targetHomePath {
+                return try await blocker.awaitResult()
+            }
+            return UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 11,
+                    windowMinutes: 300,
+                    resetsAt: nil,
+                    resetDescription: nil),
+                secondary: nil,
+                updatedAt: now,
+                identity: ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: "sibling-provider@example.com",
+                    accountOrganization: nil,
+                    loginMethod: "Sibling Team"))
+        }
+
+        let refreshTask = Task { await store.refreshCodexVisibleAccountsForMenu() }
+        await blocker.waitUntilStarted()
+        try FileManagedCodexAccountStore(fileURL: storeURL).storeAccounts(ManagedCodexAccountSet(
+            version: FileManagedCodexAccountStore.currentVersion,
+            accounts: [updatedTarget, siblingAccount]))
+        await blocker.resume(with: .success(UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 64,
+                windowMinutes: 300,
+                resetsAt: reset,
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: now,
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: "old-provider@example.com",
+                accountOrganization: nil,
+                loginMethod: "Pro"))))
+        await refreshTask.value
+
+        let selectedSnapshot = try #require(store.snapshots[.codex])
+        #expect(selectedSnapshot.primary?.usedPercent == 64)
+        #expect(selectedSnapshot.accountEmail(for: .codex) == "new-provider@example.com")
+        #expect(selectedSnapshot.loginMethod(for: .codex) == "Pro")
+        #expect(store.lastKnownResetSnapshots[.codex]?.primary?.resetsAt == reset)
+        #expect(store.lastCodexAccountScopedRefreshGuard?.accountKey == "new-provider@example.com")
+
+        let targetRow = try #require(store.codexAccountSnapshots.first {
+            $0.account.workspaceAccountID == "acct-provider-email"
+        })
+        #expect(targetRow.account.email == "new-provider@example.com")
+        #expect(targetRow.snapshot?.primary?.usedPercent == 64)
+        #expect(targetRow.snapshot?.accountEmail(for: .codex) == "new-provider@example.com")
+        #expect(targetRow.snapshot?.loginMethod(for: .codex) == "Pro")
+
+        let persistedTarget = try #require(snapshotStore.storedSnapshots.first {
+            $0.account.workspaceAccountID == "acct-provider-email"
+        })
+        #expect(persistedTarget.account.email == "new-provider@example.com")
+        #expect(persistedTarget.snapshot?.primary?.usedPercent == 64)
+        #expect(persistedTarget.snapshot?.accountEmail(for: .codex) == "new-provider@example.com")
+        #expect(persistedTarget.snapshot?.loginMethod(for: .codex) == "Pro")
+    }
+}
diff --git a/Tests/CodexBarTests/CodexAccountsSectionStateTests.swift b/Tests/CodexBarTests/CodexAccountsSectionStateTests.swift
new file mode 100644
index 0000000000..c25ff69b5b
--- /dev/null
+++ b/Tests/CodexBarTests/CodexAccountsSectionStateTests.swift
@@ -0,0 +1,195 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@MainActor
+struct CodexAccountsSectionStateTests {
+    @Test
+    func `system badge shows for merged live row`() {
+        let accountID = UUID()
+        let mergedLiveAccount = CodexVisibleAccount(
+            id: "merged@example.com",
+            email: "merged@example.com",
+            storedAccountID: accountID,
+            selectionSource: .liveSystem,
+            isActive: true,
+            isLive: true,
+            canReauthenticate: true,
+            canRemove: true)
+        let state = CodexAccountsSectionState(
+            visibleAccounts: [mergedLiveAccount],
+            activeVisibleAccountID: mergedLiveAccount.id,
+            liveVisibleAccountID: mergedLiveAccount.id,
+            hasUnreadableManagedAccountStore: false,
+            isAuthenticatingManagedAccount: false,
+            authenticatingManagedAccountID: nil,
+            isRemovingManagedAccount: false,
+            isAuthenticatingLiveAccount: false,
+            isPromotingSystemAccount: false,
+            notice: nil)
+
+        #expect(state.showsLiveBadge(for: mergedLiveAccount))
+    }
+
+    @Test
+    func `system promotion availability uses live visible account and stored account id`() {
+        let managedAccountID = UUID()
+        let liveAccount = CodexVisibleAccount(
+            id: "live@example.com",
+            email: "live@example.com",
+            storedAccountID: nil,
+            selectionSource: .liveSystem,
+            isActive: false,
+            isLive: true,
+            canReauthenticate: true,
+            canRemove: false)
+        let managedAccount = CodexVisibleAccount(
+            id: "managed:\(managedAccountID.uuidString.lowercased())",
+            email: "managed@example.com",
+            storedAccountID: managedAccountID,
+            selectionSource: .managedAccount(id: managedAccountID),
+            isActive: true,
+            isLive: false,
+            canReauthenticate: true,
+            canRemove: true)
+        let state = CodexAccountsSectionState(
+            visibleAccounts: [liveAccount, managedAccount],
+            activeVisibleAccountID: managedAccount.id,
+            liveVisibleAccountID: liveAccount.id,
+            hasUnreadableManagedAccountStore: false,
+            isAuthenticatingManagedAccount: false,
+            authenticatingManagedAccountID: nil,
+            isRemovingManagedAccount: false,
+            isAuthenticatingLiveAccount: false,
+            isPromotingSystemAccount: false,
+            notice: nil)
+
+        #expect(state.canPromoteToSystem(liveAccount) == false)
+        #expect(state.canPromoteToSystem(managedAccount))
+    }
+
+    @Test
+    func `system promotion controls disable while conflicting work is running`() {
+        let managedAccountID = UUID()
+        let liveAccount = CodexVisibleAccount(
+            id: "live@example.com",
+            email: "live@example.com",
+            storedAccountID: nil,
+            selectionSource: .liveSystem,
+            isActive: false,
+            isLive: true,
+            canReauthenticate: true,
+            canRemove: false)
+        let managedAccount = CodexVisibleAccount(
+            id: "managed:\(managedAccountID.uuidString.lowercased())",
+            email: "managed@example.com",
+            storedAccountID: managedAccountID,
+            selectionSource: .managedAccount(id: managedAccountID),
+            isActive: true,
+            isLive: false,
+            canReauthenticate: true,
+            canRemove: true)
+        let state = CodexAccountsSectionState(
+            visibleAccounts: [liveAccount, managedAccount],
+            activeVisibleAccountID: managedAccount.id,
+            liveVisibleAccountID: liveAccount.id,
+            hasUnreadableManagedAccountStore: false,
+            isAuthenticatingManagedAccount: false,
+            authenticatingManagedAccountID: nil,
+            isRemovingManagedAccount: true,
+            isAuthenticatingLiveAccount: false,
+            isPromotingSystemAccount: false,
+            notice: nil)
+
+        #expect(state.isSystemSelectionDisabled)
+        #expect(state.canPromoteToSystem(managedAccount) == false)
+    }
+
+    @Test
+    func `system display does not fall back when no live account exists`() {
+        let managedAccountID = UUID()
+        let managedAccount = CodexVisibleAccount(
+            id: "managed:\(managedAccountID.uuidString.lowercased())",
+            email: "managed@example.com",
+            storedAccountID: managedAccountID,
+            selectionSource: .managedAccount(id: managedAccountID),
+            isActive: true,
+            isLive: false,
+            canReauthenticate: true,
+            canRemove: true)
+        let state = CodexAccountsSectionState(
+            visibleAccounts: [managedAccount],
+            activeVisibleAccountID: managedAccount.id,
+            liveVisibleAccountID: nil,
+            hasUnreadableManagedAccountStore: false,
+            isAuthenticatingManagedAccount: false,
+            authenticatingManagedAccountID: nil,
+            isRemovingManagedAccount: false,
+            isAuthenticatingLiveAccount: false,
+            isPromotingSystemAccount: false,
+            notice: nil)
+
+        #expect(state.systemVisibleAccount == nil)
+        #expect(state.showsSystemPicker)
+        #expect(state.systemDisplayName == "No system account")
+    }
+
+    @Test
+    func `remove in flight blocks add reauth and remove actions`() {
+        let managedAccountID = UUID()
+        let managedAccount = CodexVisibleAccount(
+            id: "managed:\(managedAccountID.uuidString.lowercased())",
+            email: "managed@example.com",
+            storedAccountID: managedAccountID,
+            selectionSource: .managedAccount(id: managedAccountID),
+            isActive: true,
+            isLive: false,
+            canReauthenticate: true,
+            canRemove: true)
+        let state = CodexAccountsSectionState(
+            visibleAccounts: [managedAccount],
+            activeVisibleAccountID: managedAccount.id,
+            liveVisibleAccountID: nil,
+            hasUnreadableManagedAccountStore: false,
+            isAuthenticatingManagedAccount: false,
+            authenticatingManagedAccountID: nil,
+            isRemovingManagedAccount: true,
+            isAuthenticatingLiveAccount: false,
+            isPromotingSystemAccount: false,
+            notice: nil)
+
+        #expect(state.canAddAccount == false)
+        #expect(state.canReauthenticate(managedAccount) == false)
+        #expect(state.canRemove(managedAccount) == false)
+    }
+
+    @Test
+    func `promotion in flight blocks add reauth and remove actions`() {
+        let managedAccountID = UUID()
+        let managedAccount = CodexVisibleAccount(
+            id: "managed:\(managedAccountID.uuidString.lowercased())",
+            email: "managed@example.com",
+            storedAccountID: managedAccountID,
+            selectionSource: .managedAccount(id: managedAccountID),
+            isActive: true,
+            isLive: false,
+            canReauthenticate: true,
+            canRemove: true)
+        let state = CodexAccountsSectionState(
+            visibleAccounts: [managedAccount],
+            activeVisibleAccountID: managedAccount.id,
+            liveVisibleAccountID: nil,
+            hasUnreadableManagedAccountStore: false,
+            isAuthenticatingManagedAccount: false,
+            authenticatingManagedAccountID: nil,
+            isRemovingManagedAccount: false,
+            isAuthenticatingLiveAccount: false,
+            isPromotingSystemAccount: true,
+            notice: nil)
+
+        #expect(state.canAddAccount == false)
+        #expect(state.canReauthenticate(managedAccount) == false)
+        #expect(state.canRemove(managedAccount) == false)
+    }
+}
diff --git a/Tests/CodexBarTests/CodexAccountsSettingsSectionTests.swift b/Tests/CodexBarTests/CodexAccountsSettingsSectionTests.swift
new file mode 100644
index 0000000000..7ce1ff29a9
--- /dev/null
+++ b/Tests/CodexBarTests/CodexAccountsSettingsSectionTests.swift
@@ -0,0 +1,453 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@MainActor
+struct CodexAccountsSettingsSectionTests {
+    @Test
+    func `codex accounts section shows live badge only for live only multi account row`() throws {
+        let settings = Self.makeSettingsStore(suite: "CodexAccountsSettingsSectionTests-live-badge")
+        let store = Self.makeUsageStore(settings: settings)
+        let managedStoreURL = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        defer { try? FileManager.default.removeItem(at: managedStoreURL) }
+
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let managedStore = FileManagedCodexAccountStore(fileURL: managedStoreURL)
+        try managedStore.storeAccounts(ManagedCodexAccountSet(
+            version: FileManagedCodexAccountStore.currentVersion,
+            accounts: [managedAccount]))
+
+        settings._test_managedCodexAccountStoreURL = managedStoreURL
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+
+        let pane = ProvidersPane(settings: settings, store: store)
+        let state = try #require(pane._test_codexAccountsSectionState())
+        let liveAccount = try #require(state.visibleAccounts.first { $0.email == "live@example.com" })
+        let managedVisibleAccount = try #require(state.visibleAccounts.first { $0.email == "managed@example.com" })
+
+        #expect(state.showsLiveBadge(for: liveAccount))
+        #expect(state.showsLiveBadge(for: managedVisibleAccount) == false)
+    }
+
+    @Test
+    func `single account codex settings uses simple account view instead of picker`() throws {
+        let settings = Self.makeSettingsStore(suite: "CodexAccountsSettingsSectionTests-single-account")
+        let store = Self.makeUsageStore(settings: settings)
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "solo@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+
+        let pane = ProvidersPane(settings: settings, store: store)
+        let state = try #require(pane._test_codexAccountsSectionState())
+
+        #expect(state.visibleAccounts.count == 1)
+        #expect(state.showsActivePicker == false)
+        #expect(state.singleVisibleAccount?.email == "solo@example.com")
+    }
+
+    @Test
+    func `single account codex settings state includes workspace display name`() throws {
+        let settings = Self.makeSettingsStore(suite: "CodexAccountsSettingsSectionTests-single-workspace")
+        let store = Self.makeUsageStore(settings: settings)
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "solo@example.com",
+            workspaceLabel: "Team Alpha",
+            workspaceAccountID: "account-live",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .providerAccount(id: "account-live"))
+
+        let pane = ProvidersPane(settings: settings, store: store)
+        let state = try #require(pane._test_codexAccountsSectionState())
+
+        #expect(state.singleVisibleAccount?.displayName == "solo@example.com — Team Alpha")
+    }
+
+    @Test
+    func `codex accounts section disables managed mutations when store is unreadable`() throws {
+        let settings = Self.makeSettingsStore(suite: "CodexAccountsSettingsSectionTests-unreadable")
+        let store = Self.makeUsageStore(settings: settings)
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        settings._test_unreadableManagedCodexAccountStore = true
+        defer { settings._test_unreadableManagedCodexAccountStore = false }
+
+        let pane = ProvidersPane(settings: settings, store: store)
+        let state = try #require(pane._test_codexAccountsSectionState())
+        let liveAccount = try #require(state.visibleAccounts.first)
+
+        #expect(state.hasUnreadableManagedAccountStore)
+        #expect(state.canAddAccount == false)
+        #expect(state.notice?.tone == .warning)
+        #expect(state.canReauthenticate(liveAccount))
+    }
+
+    @Test
+    func `selecting merged visible account from settings keeps live system source`() async throws {
+        let settings = Self.makeSettingsStore(suite: "CodexAccountsSettingsSectionTests-select-merged")
+        let store = Self.makeUsageStore(settings: settings)
+        let managedStoreURL = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        defer { try? FileManager.default.removeItem(at: managedStoreURL) }
+
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "same@example.com",
+            managedHomePath: "/tmp/managed",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let managedStore = FileManagedCodexAccountStore(fileURL: managedStoreURL)
+        try managedStore.storeAccounts(ManagedCodexAccountSet(
+            version: FileManagedCodexAccountStore.currentVersion,
+            accounts: [managedAccount]))
+
+        settings._test_managedCodexAccountStoreURL = managedStoreURL
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "SAME@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+
+        let pane = ProvidersPane(settings: settings, store: store)
+        await pane._test_selectCodexVisibleAccount(id: "same@example.com")
+
+        #expect(settings.codexActiveSource == .liveSystem)
+        let state = try #require(pane._test_codexAccountsSectionState())
+        #expect(state.activeVisibleAccountID == "same@example.com")
+    }
+
+    @Test
+    func `settings account selection can target the managed row when same email rows split by identity`() async throws {
+        let settings = Self.makeSettingsStore(suite: "CodexAccountsSettingsSectionTests-select-split")
+        let store = Self.makeUsageStore(settings: settings)
+        let managedStoreURL = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        let managedHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            settings._test_liveSystemCodexAccount = nil
+            try? FileManager.default.removeItem(at: managedStoreURL)
+            try? FileManager.default.removeItem(at: managedHome)
+        }
+
+        try Self.writeCodexAuthFile(
+            homeURL: managedHome,
+            email: "same@example.com",
+            plan: "pro",
+            accountID: "account-managed")
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "same@example.com",
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let managedStore = FileManagedCodexAccountStore(fileURL: managedStoreURL)
+        try managedStore.storeAccounts(ManagedCodexAccountSet(
+            version: FileManagedCodexAccountStore.currentVersion,
+            accounts: [managedAccount]))
+
+        settings._test_managedCodexAccountStoreURL = managedStoreURL
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "SAME@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .emailOnly(normalizedEmail: "same@example.com"))
+        settings.codexActiveSource = .liveSystem
+
+        let pane = ProvidersPane(settings: settings, store: store)
+        let initialState = try #require(pane._test_codexAccountsSectionState())
+        let managedVisibleAccount = try #require(initialState.visibleAccounts
+            .first { $0.storedAccountID == managedAccount.id })
+
+        await pane._test_selectCodexVisibleAccount(id: managedVisibleAccount.id)
+
+        #expect(settings.codexActiveSource == .managedAccount(id: managedAccount.id))
+        let updatedState = try #require(pane._test_codexAccountsSectionState())
+        #expect(updatedState.activeVisibleAccountID == managedVisibleAccount.id)
+    }
+
+    @Test
+    func `codex accounts section disables add and reauth while managed authentication is in flight`() async throws {
+        let settings = Self.makeSettingsStore(suite: "CodexAccountsSettingsSectionTests-in-flight")
+        let store = Self.makeUsageStore(settings: settings)
+        let managedStoreURL = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        defer { try? FileManager.default.removeItem(at: managedStoreURL) }
+
+        let managedAccountID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-111111111111"))
+        let managedAccount = ManagedCodexAccount(
+            id: managedAccountID,
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let managedStore = FileManagedCodexAccountStore(fileURL: managedStoreURL)
+        try managedStore.storeAccounts(ManagedCodexAccountSet(
+            version: FileManagedCodexAccountStore.currentVersion,
+            accounts: [managedAccount]))
+        settings._test_managedCodexAccountStoreURL = managedStoreURL
+
+        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+        let runner = BlockingManagedCodexLoginRunnerForSettingsSectionTests()
+        let service = ManagedCodexAccountService(
+            store: managedStore,
+            homeFactory: TestManagedCodexHomeFactoryForSettingsSectionTests(root: root),
+            loginRunner: runner,
+            identityReader: StubManagedCodexIdentityReaderForSettingsSectionTests(emails: ["managed@example.com"]))
+        let coordinator = ManagedCodexAccountCoordinator(service: service)
+        let authTask = Task { try await coordinator.authenticateManagedAccount() }
+        await runner.waitUntilStarted()
+
+        let pane = ProvidersPane(
+            settings: settings,
+            store: store,
+            managedCodexAccountCoordinator: coordinator)
+        let state = try #require(pane._test_codexAccountsSectionState())
+        let visibleAccount = try #require(state.visibleAccounts.first { $0.email == "managed@example.com" })
+
+        #expect(state.canAddAccount == false)
+        #expect(state.addAccountTitle == "Adding Account…")
+        #expect(state.canReauthenticate(visibleAccount) == false)
+
+        await runner.resume()
+        _ = try await authTask.value
+    }
+
+    @Test
+    func `adding managed codex account auto selects the merged live row`() async throws {
+        let settings = Self.makeSettingsStore(suite: "CodexAccountsSettingsSectionTests-add-merged")
+        let store = Self.makeUsageStore(settings: settings)
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "same@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+
+        let coordinator = Self.makeManagedCoordinator(settings: settings, email: "same@example.com")
+        let pane = ProvidersPane(
+            settings: settings,
+            store: store,
+            managedCodexAccountCoordinator: coordinator)
+
+        await pane._test_addManagedCodexAccount()
+
+        #expect(settings.codexActiveSource == .liveSystem)
+        let state = try #require(pane._test_codexAccountsSectionState())
+        #expect(state.activeVisibleAccountID == "same@example.com")
+    }
+
+    @Test
+    func `adding managed codex account selects the new managed account when email differs`() async throws {
+        let settings = Self.makeSettingsStore(suite: "CodexAccountsSettingsSectionTests-add-managed")
+        let store = Self.makeUsageStore(settings: settings)
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+
+        let coordinator = Self.makeManagedCoordinator(settings: settings, email: "managed@example.com")
+        let pane = ProvidersPane(
+            settings: settings,
+            store: store,
+            managedCodexAccountCoordinator: coordinator)
+
+        await pane._test_addManagedCodexAccount()
+
+        guard case .managedAccount = settings.codexActiveSource else {
+            Issue.record("Expected the new managed account to become active")
+            return
+        }
+        let state = try #require(pane._test_codexAccountsSectionState())
+        #expect(state.activeVisibleAccountID == "managed@example.com")
+    }
+
+    @Test
+    func `managed codex login failure message includes codex login output`() {
+        let error = ManagedCodexAccountServiceError.loginFailed(CodexLoginRunner.Result(
+            outcome: .failed(status: 2),
+            output: "Browser selected the existing ChatGPT account"))
+
+        #expect(error.userFacingMessage.contains("codex --version"))
+        #expect(error.userFacingMessage.contains("codex login output:"))
+        #expect(error.userFacingMessage.contains("Browser selected the existing ChatGPT account"))
+    }
+
+    private static func makeManagedCoordinator(
+        settings: SettingsStore,
+        email: String)
+        -> ManagedCodexAccountCoordinator
+    {
+        let storeURL = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        let store = FileManagedCodexAccountStore(fileURL: storeURL)
+        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        settings._test_managedCodexAccountStoreURL = storeURL
+        let service = ManagedCodexAccountService(
+            store: store,
+            homeFactory: TestManagedCodexHomeFactoryForSettingsSectionTests(root: root),
+            loginRunner: StubManagedCodexLoginRunnerForSettingsSectionTests.success,
+            identityReader: StubManagedCodexIdentityReaderForSettingsSectionTests(emails: [email]))
+        return ManagedCodexAccountCoordinator(service: service)
+    }
+
+    private static func makeSettingsStore(suite: String) -> SettingsStore {
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+
+        return SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore(),
+            codexCookieStore: InMemoryCookieHeaderStore(),
+            claudeCookieStore: InMemoryCookieHeaderStore(),
+            cursorCookieStore: InMemoryCookieHeaderStore(),
+            opencodeCookieStore: InMemoryCookieHeaderStore(),
+            factoryCookieStore: InMemoryCookieHeaderStore(),
+            minimaxCookieStore: InMemoryMiniMaxCookieStore(),
+            minimaxAPITokenStore: InMemoryMiniMaxAPITokenStore(),
+            kimiTokenStore: InMemoryKimiTokenStore(),
+            kimiK2TokenStore: InMemoryKimiK2TokenStore(),
+            augmentCookieStore: InMemoryCookieHeaderStore(),
+            ampCookieStore: InMemoryCookieHeaderStore(),
+            copilotTokenStore: InMemoryCopilotTokenStore(),
+            tokenAccountStore: InMemoryTokenAccountStore())
+    }
+
+    private static func makeUsageStore(settings: SettingsStore) -> UsageStore {
+        UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+    }
+}
+
+extension CodexAccountsSettingsSectionTests {
+    private static func writeCodexAuthFile(
+        homeURL: URL,
+        email: String,
+        plan: String,
+        accountID: String? = nil) throws
+    {
+        try FileManager.default.createDirectory(at: homeURL, withIntermediateDirectories: true)
+        var tokens: [String: Any] = [
+            "accessToken": "access-token",
+            "refreshToken": "refresh-token",
+            "idToken": Self.fakeJWT(email: email, plan: plan, accountID: accountID),
+        ]
+        if let accountID {
+            tokens["account_id"] = accountID
+        }
+        let auth = ["tokens": tokens]
+        let data = try JSONSerialization.data(withJSONObject: auth)
+        try data.write(to: homeURL.appendingPathComponent("auth.json"))
+    }
+
+    private static func fakeJWT(email: String, plan: String, accountID: String? = nil) -> String {
+        let header = (try? JSONSerialization.data(withJSONObject: ["alg": "none"])) ?? Data()
+        var payloadObject: [String: Any] = [
+            "email": email,
+            "chatgpt_plan_type": plan,
+        ]
+        if let accountID {
+            payloadObject["https://api.openai.com/auth"] = [
+                "chatgpt_account_id": accountID,
+            ]
+        }
+        let payload = (try? JSONSerialization.data(withJSONObject: payloadObject)) ?? Data()
+
+        func base64URL(_ data: Data) -> String {
+            data.base64EncodedString()
+                .replacingOccurrences(of: "=", with: "")
+                .replacingOccurrences(of: "+", with: "-")
+                .replacingOccurrences(of: "/", with: "_")
+        }
+
+        return "\(base64URL(header)).\(base64URL(payload))."
+    }
+}
+
+private struct TestManagedCodexHomeFactoryForSettingsSectionTests: ManagedCodexHomeProducing {
+    let root: URL
+    private let nextID = UUID().uuidString
+
+    func makeHomeURL() -> URL {
+        self.root.appendingPathComponent(self.nextID, isDirectory: true)
+    }
+
+    func validateManagedHomeForDeletion(_ url: URL) throws {
+        try ManagedCodexHomeFactory(root: self.root).validateManagedHomeForDeletion(url)
+    }
+}
+
+private struct StubManagedCodexLoginRunnerForSettingsSectionTests: ManagedCodexLoginRunning {
+    let result: CodexLoginRunner.Result
+
+    func run(homePath _: String, timeout _: TimeInterval) async -> CodexLoginRunner.Result {
+        self.result
+    }
+
+    static let success = StubManagedCodexLoginRunnerForSettingsSectionTests(
+        result: CodexLoginRunner.Result(outcome: .success, output: "ok"))
+}
+
+private actor BlockingManagedCodexLoginRunnerForSettingsSectionTests: ManagedCodexLoginRunning {
+    private var waiters: [CheckedContinuation<CodexLoginRunner.Result, Never>] = []
+    private var startedWaiters: [CheckedContinuation<Void, Never>] = []
+    private var didStart = false
+
+    func run(homePath _: String, timeout _: TimeInterval) async -> CodexLoginRunner.Result {
+        self.didStart = true
+        self.startedWaiters.forEach { $0.resume() }
+        self.startedWaiters.removeAll()
+        return await withCheckedContinuation { continuation in
+            self.waiters.append(continuation)
+        }
+    }
+
+    func waitUntilStarted() async {
+        if self.didStart { return }
+        await withCheckedContinuation { continuation in
+            self.startedWaiters.append(continuation)
+        }
+    }
+
+    func resume() {
+        let result = CodexLoginRunner.Result(outcome: .success, output: "ok")
+        self.waiters.forEach { $0.resume(returning: result) }
+        self.waiters.removeAll()
+    }
+}
+
+private final class StubManagedCodexIdentityReaderForSettingsSectionTests: ManagedCodexIdentityReading,
+@unchecked Sendable {
+    private var emails: [String]
+
+    init(emails: [String]) {
+        self.emails = emails
+    }
+
+    func loadAccountIdentity(homePath _: String) throws -> CodexAuthBackedAccount {
+        let email = self.emails.isEmpty ? nil : self.emails.removeFirst()
+        return CodexAuthBackedAccount(
+            identity: CodexIdentityResolver.resolve(accountId: nil, email: email),
+            email: email,
+            plan: "Pro")
+    }
+}
diff --git a/Tests/CodexBarTests/CodexActiveSourceConfigTests.swift b/Tests/CodexBarTests/CodexActiveSourceConfigTests.swift
new file mode 100644
index 0000000000..e333f00e7b
--- /dev/null
+++ b/Tests/CodexBarTests/CodexActiveSourceConfigTests.swift
@@ -0,0 +1,242 @@
+import CodexBarCore
+import Foundation
+import Testing
+
+@Suite(.serialized)
+struct CodexActiveSourceConfigTests {
+    @Test
+    func `legacy config without codex active source decodes to nil`() throws {
+        let legacyJSON = """
+        {
+            "version": 1,
+            "providers": [
+                {
+                    "id": "codex"
+                }
+            ]
+        }
+        """
+
+        let decoded = try JSONDecoder().decode(
+            CodexBarConfig.self,
+            from: Data(legacyJSON.utf8))
+
+        #expect(decoded.providerConfig(for: .codex)?.codexActiveSource == nil)
+        #expect(decoded.providerConfig(for: .codex)?.quotaWarnings == nil)
+    }
+
+    @Test
+    func `provider config round trips quota warning overrides`() throws {
+        let config = CodexBarConfig(
+            providers: [
+                ProviderConfig(
+                    id: .codex,
+                    quotaWarnings: QuotaWarningConfig(
+                        session: QuotaWarningWindowConfig(thresholds: [10]),
+                        weekly: QuotaWarningWindowConfig(thresholds: [50, 20]))),
+            ])
+
+        let data = try JSONEncoder().encode(config)
+        let decoded = try JSONDecoder().decode(CodexBarConfig.self, from: data)
+        let quotaWarnings = try #require(decoded.providerConfig(for: .codex)?.quotaWarnings)
+
+        #expect(quotaWarnings.thresholds(for: .session, global: [80]) == [10])
+        #expect(quotaWarnings.thresholds(for: .weekly, global: [80]) == [50, 20])
+    }
+
+    @Test
+    func `quota warning window enabled defaults stay backward compatible`() throws {
+        let legacyJSON = """
+        {
+            "version": 1,
+            "providers": [
+                {
+                    "id": "codex",
+                    "quotaWarnings": {
+                        "session": { "thresholds": [10] },
+                        "weekly": { "enabled": false }
+                    }
+                }
+            ]
+        }
+        """
+
+        let decoded = try JSONDecoder().decode(CodexBarConfig.self, from: Data(legacyJSON.utf8))
+        let quotaWarnings = try #require(decoded.providerConfig(for: .codex)?.quotaWarnings)
+
+        #expect(quotaWarnings.isEnabled(for: .session, global: false) == true)
+        #expect(quotaWarnings.isEnabled(for: .weekly, global: true) == false)
+        #expect(quotaWarnings.hasOverride(for: .session) == true)
+        #expect(quotaWarnings.hasOverride(for: .weekly) == true)
+    }
+
+    @Test
+    func `provider config encodes live system active source with expected schema`() throws {
+        let config = CodexBarConfig(
+            providers: [
+                ProviderConfig(
+                    id: .codex,
+                    codexActiveSource: .liveSystem),
+            ])
+
+        let data = try JSONEncoder().encode(config)
+        let object = try JSONSerialization.jsonObject(with: data) as? [String: Any]
+        let providers = try #require(object?["providers"] as? [[String: Any]])
+        let provider = try #require(providers.first(where: { $0["id"] as? String == "codex" }))
+        let activeSource = try #require(provider["codexActiveSource"] as? [String: Any])
+
+        #expect(activeSource.count == 1)
+        #expect(activeSource["kind"] as? String == "liveSystem")
+        #expect(activeSource["accountID"] == nil)
+    }
+
+    @Test
+    func `provider config encodes managed account active source with expected schema`() throws {
+        let accountID = UUID()
+        let config = CodexBarConfig(
+            providers: [
+                ProviderConfig(
+                    id: .codex,
+                    codexActiveSource: .managedAccount(id: accountID)),
+            ])
+
+        let data = try JSONEncoder().encode(config)
+        let object = try JSONSerialization.jsonObject(with: data) as? [String: Any]
+        let providers = try #require(object?["providers"] as? [[String: Any]])
+        let provider = try #require(providers.first(where: { $0["id"] as? String == "codex" }))
+        let activeSource = try #require(provider["codexActiveSource"] as? [String: Any])
+
+        #expect(activeSource.count == 2)
+        #expect(activeSource["kind"] as? String == "managedAccount")
+        #expect((activeSource["accountID"] as? String) == accountID.uuidString)
+    }
+
+    @Test
+    func `provider config encodes profile home source in downgrade readable envelope`() throws {
+        let config = CodexBarConfig(
+            providers: [
+                ProviderConfig(
+                    id: .codex,
+                    codexActiveSource: .profileHome(path: "/Users/test/.codex-work"),
+                    codexProfileHomePaths: ["/Users/test/.codex-work"]),
+            ])
+
+        let data = try JSONEncoder().encode(config)
+        let object = try JSONSerialization.jsonObject(with: data) as? [String: Any]
+        let providers = try #require(object?["providers"] as? [[String: Any]])
+        let provider = try #require(providers.first(where: { $0["id"] as? String == "codex" }))
+        let activeSource = try #require(provider["codexActiveSource"] as? [String: Any])
+
+        #expect(activeSource.count == 2)
+        #expect(activeSource["kind"] as? String == "liveSystem")
+        #expect(activeSource["homePath"] as? String == "/Users/test/.codex-work")
+        #expect(provider["codexProfileHomePaths"] as? [String] == ["/Users/test/.codex-work"])
+
+        let releasedConfig = try JSONDecoder().decode(ReleasedCodexBarConfig.self, from: data)
+        #expect(releasedConfig.providers.first?.codexActiveSource == .liveSystem)
+    }
+
+    @Test
+    func `provider config round trips live system active source`() throws {
+        let config = CodexBarConfig(
+            providers: [
+                ProviderConfig(
+                    id: .codex,
+                    codexActiveSource: .liveSystem),
+            ])
+
+        let data = try JSONEncoder().encode(config)
+        let decoded = try JSONDecoder().decode(CodexBarConfig.self, from: data)
+
+        #expect(decoded.providerConfig(for: .codex)?.codexActiveSource == .liveSystem)
+    }
+
+    @Test
+    func `provider config round trips managed account active source`() throws {
+        let accountID = UUID()
+        let config = CodexBarConfig(
+            providers: [
+                ProviderConfig(
+                    id: .codex,
+                    codexActiveSource: .managedAccount(id: accountID)),
+            ])
+
+        let data = try JSONEncoder().encode(config)
+        let decoded = try JSONDecoder().decode(CodexBarConfig.self, from: data)
+
+        #expect(decoded.providerConfig(for: .codex)?.codexActiveSource == .managedAccount(id: accountID))
+    }
+
+    @Test
+    func `provider config round trips profile home active source`() throws {
+        let config = CodexBarConfig(
+            providers: [
+                ProviderConfig(
+                    id: .codex,
+                    codexActiveSource: .profileHome(path: "/Users/test/.codex-work"),
+                    codexProfileHomePaths: ["/Users/test/.codex-work"]),
+            ])
+
+        let data = try JSONEncoder().encode(config)
+        let decoded = try JSONDecoder().decode(CodexBarConfig.self, from: data)
+        let providerConfig = decoded.providerConfig(for: .codex)
+
+        #expect(providerConfig?.codexActiveSource == .profileHome(path: "/Users/test/.codex-work"))
+        #expect(providerConfig?.codexProfileHomePaths == ["/Users/test/.codex-work"])
+    }
+
+    @Test
+    func `profile home discriminator written by development builds still decodes`() throws {
+        let data = Data(#"{"kind":"profileHome","homePath":"/Users/test/.codex-work"}"#.utf8)
+
+        let decoded = try JSONDecoder().decode(CodexActiveSource.self, from: data)
+        let canonicalData = try JSONEncoder().encode(decoded)
+        let canonical = try #require(JSONSerialization.jsonObject(with: canonicalData) as? [String: Any])
+
+        #expect(decoded == .profileHome(path: "/Users/test/.codex-work"))
+        #expect(canonical["kind"] as? String == "liveSystem")
+        #expect(canonical["homePath"] as? String == "/Users/test/.codex-work")
+    }
+
+    @Test
+    func `blank profile home sentinel falls back to live system`() throws {
+        let data = Data(#"{"kind":"liveSystem","homePath":"  "}"#.utf8)
+
+        let decoded = try JSONDecoder().decode(CodexActiveSource.self, from: data)
+
+        #expect(decoded == .liveSystem)
+    }
+}
+
+private struct ReleasedCodexBarConfig: Decodable {
+    let providers: [ReleasedProviderConfig]
+}
+
+private struct ReleasedProviderConfig: Decodable {
+    let codexActiveSource: ReleasedCodexActiveSource?
+}
+
+private enum ReleasedCodexActiveSource: Decodable, Equatable {
+    case liveSystem
+    case managedAccount(id: UUID)
+
+    private enum CodingKeys: String, CodingKey {
+        case kind
+        case accountID
+    }
+
+    private enum Kind: String, Decodable {
+        case liveSystem
+        case managedAccount
+    }
+
+    init(from decoder: any Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        switch try container.decode(Kind.self, forKey: .kind) {
+        case .liveSystem:
+            self = .liveSystem
+        case .managedAccount:
+            self = try .managedAccount(id: container.decode(UUID.self, forKey: .accountID))
+        }
+    }
+}
diff --git a/Tests/CodexBarTests/CodexAdditionalRateLimitsTests.swift b/Tests/CodexBarTests/CodexAdditionalRateLimitsTests.swift
new file mode 100644
index 0000000000..3809cb2ca5
--- /dev/null
+++ b/Tests/CodexBarTests/CodexAdditionalRateLimitsTests.swift
@@ -0,0 +1,311 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct CodexAdditionalRateLimitsTests {
+    @Test
+    func `maps additional spark limit into a named extra rate window`() throws {
+        let json = """
+        {
+          "plan_type": "pro",
+          "rate_limit": {
+            "primary_window": {
+              "used_percent": 22,
+              "reset_at": 1766948068,
+              "limit_window_seconds": 18000
+            },
+            "secondary_window": {
+              "used_percent": 43,
+              "reset_at": 1767407914,
+              "limit_window_seconds": 604800
+            }
+          },
+          "additional_rate_limits": [
+            {
+              "limit_name": "GPT-5.3-Codex-Spark",
+              "metered_feature": "gpt_5_3_codex_spark",
+              "rate_limit": {
+                "allowed": true,
+                "limit_reached": false,
+                "primary_window": {
+                  "used_percent": 30,
+                  "reset_at": 1766948068,
+                  "limit_window_seconds": 18000,
+                  "reset_after_seconds": 12345
+                },
+                "secondary_window": {
+                  "used_percent": 100,
+                  "reset_at": 1767407914,
+                  "limit_window_seconds": 604800,
+                  "reset_after_seconds": 56789
+                }
+              }
+            }
+          ]
+        }
+        """
+        let creds = CodexOAuthCredentials(
+            accessToken: "access",
+            refreshToken: "refresh",
+            idToken: nil,
+            accountId: nil,
+            lastRefresh: Date())
+        let mapped = try CodexOAuthFetchStrategy._mapUsageForTesting(Data(json.utf8), credentials: creds)
+        let snapshot = try #require(mapped)
+        // Primary/weekly behavior is unchanged.
+        #expect(snapshot.primary?.usedPercent == 22)
+        #expect(snapshot.secondary?.usedPercent == 43)
+        // Spark surfaces as distinct 5-hour and weekly extra windows.
+        let extras = try #require(snapshot.extraRateWindows)
+        #expect(extras.count == 2)
+        let spark = try #require(extras.first)
+        #expect(spark.id == "codex-spark")
+        #expect(spark.title == "Codex Spark 5-hour")
+        #expect(spark.window.usedPercent == 30)
+        #expect(spark.window.windowMinutes == 300)
+        #expect(spark.window.resetsAt != nil)
+        let weekly = try #require(extras.last)
+        #expect(weekly.id == "codex-spark-weekly")
+        #expect(weekly.title == "Codex Spark Weekly")
+        #expect(weekly.window.usedPercent == 100)
+        #expect(weekly.window.windowMinutes == 10080)
+        #expect(weekly.window.resetsAt != nil)
+    }
+
+    @Test
+    func `keeps valid spark window when an additional limit sibling is malformed`() throws {
+        let json = """
+        {
+          "rate_limit": {
+            "primary_window": { "used_percent": 22, "reset_at": 1766948068, "limit_window_seconds": 18000 },
+            "secondary_window": { "used_percent": 43, "reset_at": 1767407914, "limit_window_seconds": 604800 }
+          },
+          "additional_rate_limits": [
+            "garbage-not-an-object",
+            {
+              "limit_name": "GPT-5.3-Codex-Spark",
+              "metered_feature": "gpt_5_3_codex_spark",
+              "rate_limit": {
+                "primary_window": { "used_percent": 30, "reset_at": 1766948068, "limit_window_seconds": 18000 }
+              }
+            },
+            42
+          ]
+        }
+        """
+        let creds = CodexOAuthCredentials(
+            accessToken: "access",
+            refreshToken: "refresh",
+            idToken: nil,
+            accountId: nil,
+            lastRefresh: Date())
+        let mapped = try CodexOAuthFetchStrategy._mapUsageForTesting(Data(json.utf8), credentials: creds)
+        let snapshot = try #require(mapped)
+        // Valid primary/weekly fields do not regress.
+        #expect(snapshot.primary?.usedPercent == 22)
+        #expect(snapshot.secondary?.usedPercent == 43)
+        // The malformed siblings are skipped, but the valid Spark entry survives.
+        let extras = try #require(snapshot.extraRateWindows)
+        #expect(extras.count == 1)
+        #expect(extras.first?.id == "codex-spark")
+        #expect(extras.first?.window.usedPercent == 30)
+    }
+
+    @Test
+    func `keeps primary usage when every additional limit element is malformed`() throws {
+        let json = """
+        {
+          "rate_limit": {
+            "primary_window": { "used_percent": 22, "reset_at": 1766948068, "limit_window_seconds": 18000 }
+          },
+          "additional_rate_limits": ["garbage", 1, true]
+        }
+        """
+        let creds = CodexOAuthCredentials(
+            accessToken: "access",
+            refreshToken: "refresh",
+            idToken: nil,
+            accountId: nil,
+            lastRefresh: Date())
+        let snapshot = try CodexOAuthFetchStrategy._mapUsageForTesting(Data(json.utf8), credentials: creds)
+        #expect(snapshot?.primary?.usedPercent == 22)
+        #expect(snapshot?.extraRateWindows == nil)
+    }
+
+    @Test
+    func `omits extra rate windows when additional limits are absent`() throws {
+        let json = """
+        {
+          "rate_limit": {
+            "primary_window": {
+              "used_percent": 22,
+              "reset_at": 1766948068,
+              "limit_window_seconds": 18000
+            }
+          }
+        }
+        """
+        let creds = CodexOAuthCredentials(
+            accessToken: "access",
+            refreshToken: "refresh",
+            idToken: nil,
+            accountId: nil,
+            lastRefresh: Date())
+        let snapshot = try CodexOAuthFetchStrategy._mapUsageForTesting(Data(json.utf8), credentials: creds)
+        #expect(snapshot?.primary?.usedPercent == 22)
+        #expect(snapshot?.extraRateWindows == nil)
+    }
+
+    @Test
+    func `tolerates malformed additional limits while keeping primary window`() throws {
+        let json = """
+        {
+          "rate_limit": {
+            "primary_window": {
+              "used_percent": 22,
+              "reset_at": 1766948068,
+              "limit_window_seconds": 18000
+            }
+          },
+          "additional_rate_limits": "unexpected"
+        }
+        """
+        let creds = CodexOAuthCredentials(
+            accessToken: "access",
+            refreshToken: "refresh",
+            idToken: nil,
+            accountId: nil,
+            lastRefresh: Date())
+        let snapshot = try CodexOAuthFetchStrategy._mapUsageForTesting(Data(json.utf8), credentials: creds)
+        #expect(snapshot?.primary?.usedPercent == 22)
+        #expect(snapshot?.extraRateWindows == nil)
+    }
+
+    @Test
+    func `skips additional limits without a usable window`() throws {
+        let json = """
+        {
+          "rate_limit": {
+            "primary_window": {
+              "used_percent": 22,
+              "reset_at": 1766948068,
+              "limit_window_seconds": 18000
+            }
+          },
+          "additional_rate_limits": [
+            {
+              "limit_name": "GPT-5.3-Codex-Spark",
+              "metered_feature": "gpt_5_3_codex_spark",
+              "rate_limit": null
+            }
+          ]
+        }
+        """
+        let creds = CodexOAuthCredentials(
+            accessToken: "access",
+            refreshToken: "refresh",
+            idToken: nil,
+            accountId: nil,
+            lastRefresh: Date())
+        let snapshot = try CodexOAuthFetchStrategy._mapUsageForTesting(Data(json.utf8), credentials: creds)
+        #expect(snapshot?.primary?.usedPercent == 22)
+        #expect(snapshot?.extraRateWindows == nil)
+    }
+
+    @Test
+    func `maps non spark additional limit using a slugged id and api label`() throws {
+        let now = Date(timeIntervalSince1970: 1_800_000_000)
+        let json = """
+        [
+          {
+            "limit_name": "GPT-5.3-Codex-Mini",
+            "metered_feature": "gpt_5_3_codex_mini",
+            "rate_limit": {
+              "allowed": true,
+              "limit_reached": false,
+              "primary_window": {
+                "used_percent": 12,
+                "reset_at": 1766948068,
+                "limit_window_seconds": 18000
+              }
+            }
+          },
+          {
+            "limit_name": "GPT-5.3-Codex-Mini",
+            "metered_feature": "gpt_5_3_codex_mini",
+            "rate_limit": {
+              "allowed": true,
+              "limit_reached": false,
+              "primary_window": {
+                "used_percent": 99,
+                "reset_at": 1766948068,
+                "limit_window_seconds": 18000
+              }
+            }
+          }
+        ]
+        """
+        let entries = try JSONDecoder().decode([CodexUsageResponse.AdditionalRateLimit].self, from: Data(json.utf8))
+        let windows = CodexAdditionalRateLimitMapper.extraRateWindows(from: entries, now: now)
+        // Duplicate ids collapse to the first occurrence.
+        #expect(windows.count == 1)
+        let window = try #require(windows.first)
+        #expect(window.id == "codex-gpt-5-3-codex-mini")
+        #expect(window.title == "GPT-5.3-Codex-Mini")
+        #expect(window.window.usedPercent == 12)
+    }
+
+    @Test
+    func `dedupes split spark entries by window kind`() throws {
+        let now = Date(timeIntervalSince1970: 1_800_000_000)
+        let json = """
+        [
+          {
+            "limit_name": "GPT-5.3-Codex-Spark",
+            "metered_feature": "gpt_5_3_codex_spark",
+            "rate_limit": {
+              "allowed": true,
+              "limit_reached": false,
+              "primary_window": {
+                "used_percent": 20,
+                "reset_at": 1766948068,
+                "limit_window_seconds": 18000
+              }
+            }
+          },
+          {
+            "limit_name": "GPT-5.3-Codex-Spark Weekly",
+            "metered_feature": "gpt_5_3_codex_spark",
+            "rate_limit": {
+              "allowed": true,
+              "limit_reached": false,
+              "primary_window": {
+                "used_percent": 80,
+                "reset_at": 1767407914,
+                "limit_window_seconds": 604800
+              }
+            }
+          },
+          {
+            "limit_name": "GPT-5.3-Codex-Spark Duplicate",
+            "metered_feature": "gpt_5_3_codex_spark",
+            "rate_limit": {
+              "allowed": true,
+              "limit_reached": false,
+              "primary_window": {
+                "used_percent": 99,
+                "reset_at": 1766948068,
+                "limit_window_seconds": 18000
+              }
+            }
+          }
+        ]
+        """
+        let entries = try JSONDecoder().decode([CodexUsageResponse.AdditionalRateLimit].self, from: Data(json.utf8))
+        let windows = CodexAdditionalRateLimitMapper.extraRateWindows(from: entries, now: now)
+
+        #expect(windows.map(\.id) == ["codex-spark", "codex-spark-weekly"])
+        #expect(windows.first?.window.usedPercent == 20)
+        #expect(windows.last?.window.usedPercent == 80)
+    }
+}
diff --git a/Tests/CodexBarTests/CodexBackgroundRefreshCoalescingTests.swift b/Tests/CodexBarTests/CodexBackgroundRefreshCoalescingTests.swift
new file mode 100644
index 0000000000..6b0aa0ab03
--- /dev/null
+++ b/Tests/CodexBarTests/CodexBackgroundRefreshCoalescingTests.swift
@@ -0,0 +1,364 @@
+import Foundation
+import Testing
+@testable import CodexBar
+@testable import CodexBarCore
+
+@Suite(.serialized)
+@MainActor
+struct CodexBackgroundRefreshCoalescingTests {
+    @Test
+    func `rapid regular refreshes coalesce concurrent Codex credits fetches`() async throws {
+        let settings = try self.makeSettingsStore(
+            suite: "CodexBackgroundRefreshCoalescingTests-credits-coalescing")
+        settings.statusChecksEnabled = false
+        settings.openAIWebAccessEnabled = false
+        let managedAccount = try Self.installManagedAccount(
+            email: "managed@example.com",
+            settings: settings)
+        defer { try? FileManager.default.removeItem(atPath: managedAccount.managedHomePath) }
+
+        let store = self.makeStore(settings: settings)
+        let blocker = BlockingCreditsLoader()
+        let firstCompletion = RefreshCompletionProbe()
+        let secondCompletion = RefreshCompletionProbe()
+        store._test_providerRefreshOverride = { _ in }
+        defer { store._test_providerRefreshOverride = nil }
+        store._test_codexCreditsLoaderOverride = {
+            try await blocker.awaitResult()
+        }
+        defer { store._test_codexCreditsLoaderOverride = nil }
+
+        let firstRefreshTask = Task {
+            await store.refresh(forceTokenUsage: false)
+            await firstCompletion.markCompleted()
+        }
+        await blocker.waitUntilStarted(count: 1)
+        #expect(await firstCompletion.waitUntilCompleted() == true)
+
+        let secondRefreshTask = Task {
+            await store.refresh(forceTokenUsage: false)
+            await secondCompletion.markCompleted()
+        }
+
+        #expect(await secondCompletion.waitUntilCompleted() == true)
+        #expect(await blocker.startedCount() == 1)
+
+        await blocker.resumeNext(with: .success(CreditsSnapshot(remaining: 25, events: [], updatedAt: Date())))
+
+        await firstRefreshTask.value
+        await secondRefreshTask.value
+    }
+
+    @Test
+    func `regular credits refresh reschedules when Codex account changes`() async throws {
+        let settings = try self.makeSettingsStore(
+            suite: "CodexBackgroundRefreshCoalescingTests-credits-account-switch")
+        settings.statusChecksEnabled = false
+        settings.openAIWebAccessEnabled = false
+        let alphaAccount = try Self.makeManagedAccount(email: "alpha@example.com")
+        let betaAccount = try Self.makeManagedAccount(email: "beta@example.com")
+        defer {
+            try? FileManager.default.removeItem(atPath: alphaAccount.managedHomePath)
+            try? FileManager.default.removeItem(atPath: betaAccount.managedHomePath)
+        }
+        settings._test_activeManagedCodexAccount = alphaAccount
+        settings.codexActiveSource = .managedAccount(id: alphaAccount.id)
+        defer { settings._test_activeManagedCodexAccount = nil }
+
+        let store = self.makeStore(settings: settings)
+        let blocker = BlockingCreditsLoader()
+        store._test_providerRefreshOverride = { _ in }
+        defer { store._test_providerRefreshOverride = nil }
+        store._test_codexCreditsLoaderOverride = {
+            try await blocker.awaitResult()
+        }
+        defer { store._test_codexCreditsLoaderOverride = nil }
+
+        let alphaRefreshTask = Task {
+            await store.refresh(forceTokenUsage: false)
+        }
+        await blocker.waitUntilStarted(count: 1)
+
+        settings._test_activeManagedCodexAccount = betaAccount
+        settings.codexActiveSource = .managedAccount(id: betaAccount.id)
+        let betaRefreshTask = Task {
+            await store.refresh(forceTokenUsage: false)
+        }
+        await blocker.waitUntilStarted(count: 2)
+
+        await blocker.resumeNext(with: .success(CreditsSnapshot(remaining: 10, events: [], updatedAt: Date())))
+        await blocker.resumeNext(with: .success(CreditsSnapshot(remaining: 25, events: [], updatedAt: Date())))
+
+        await alphaRefreshTask.value
+        await betaRefreshTask.value
+        await store.creditsRefreshTask?.value
+
+        #expect(await blocker.startedCount() == 2)
+        #expect(store.lastCreditsSnapshotAccountKey == "beta@example.com")
+        #expect(store.credits?.remaining == 25)
+    }
+
+    @Test
+    func `force refresh cancels stale background Codex credits fetch`() async throws {
+        let settings = try self.makeSettingsStore(
+            suite: "CodexBackgroundRefreshCoalescingTests-credits-force-cancels-background")
+        settings.statusChecksEnabled = false
+        settings.openAIWebAccessEnabled = false
+        let managedAccount = try Self.installManagedAccount(
+            email: "managed@example.com",
+            settings: settings)
+        defer { try? FileManager.default.removeItem(atPath: managedAccount.managedHomePath) }
+
+        let store = self.makeStore(settings: settings)
+        let blocker = BlockingCreditsLoader()
+        store._test_providerRefreshOverride = { _ in }
+        defer { store._test_providerRefreshOverride = nil }
+        store._test_codexCreditsLoaderOverride = {
+            try await blocker.awaitResult()
+        }
+        defer { store._test_codexCreditsLoaderOverride = nil }
+        let regularCompletion = RefreshCompletionProbe()
+
+        let regularRefreshTask = Task {
+            await store.refresh(forceTokenUsage: false)
+            await regularCompletion.markCompleted()
+        }
+        await blocker.waitUntilStarted(count: 1)
+        #expect(await regularCompletion.waitUntilCompleted() == true)
+
+        let forceRefreshTask = Task {
+            await store.refresh(forceTokenUsage: true)
+        }
+        await blocker.waitUntilStarted(count: 2)
+
+        await blocker.resumeNext(with: .success(CreditsSnapshot(remaining: 10, events: [], updatedAt: Date())))
+        await blocker.resumeNext(with: .success(CreditsSnapshot(remaining: 25, events: [], updatedAt: Date())))
+
+        await regularRefreshTask.value
+        await forceRefreshTask.value
+
+        #expect(await blocker.startedCount() == 2)
+        #expect(store.credits?.remaining == 25)
+    }
+
+    @Test
+    func `rapid regular refreshes coalesce concurrent OpenAI dashboard fetches`() async throws {
+        let settings = try self.makeSettingsStore(
+            suite: "CodexBackgroundRefreshCoalescingTests-dashboard-coalescing")
+        settings.statusChecksEnabled = false
+        let managedAccount = try Self.installManagedAccount(
+            email: "managed@example.com",
+            settings: settings)
+        defer { try? FileManager.default.removeItem(atPath: managedAccount.managedHomePath) }
+
+        let store = self.makeStore(settings: settings)
+        let blocker = BlockingManagedOpenAIDashboardLoader()
+        let firstCompletion = RefreshCompletionProbe()
+        let secondCompletion = RefreshCompletionProbe()
+        store._test_providerRefreshOverride = { _ in }
+        defer { store._test_providerRefreshOverride = nil }
+        store._test_codexCreditsLoaderOverride = {
+            CreditsSnapshot(remaining: 25, events: [], updatedAt: Date())
+        }
+        defer { store._test_codexCreditsLoaderOverride = nil }
+        await store.refresh(forceTokenUsage: false)
+
+        store._test_openAIDashboardLoaderOverride = { _, _, _, _ in
+            try await blocker.awaitResult()
+        }
+        defer { store._test_openAIDashboardLoaderOverride = nil }
+
+        let firstRefreshTask = Task {
+            await store.refresh(forceTokenUsage: false)
+            await firstCompletion.markCompleted()
+        }
+        await blocker.waitUntilStarted(count: 1)
+        #expect(await firstCompletion.waitUntilCompleted() == true)
+
+        let secondRefreshTask = Task {
+            await store.refresh(forceTokenUsage: false)
+            await secondCompletion.markCompleted()
+        }
+
+        #expect(await secondCompletion.waitUntilCompleted() == true)
+        #expect(await blocker.startedCount() == 1)
+
+        let backgroundTask = try #require(store.openAIDashboardBackgroundRefreshTask)
+        await blocker.resumeNext(with: .success(OpenAIDashboardSnapshot(
+            signedInEmail: managedAccount.email,
+            codeReviewRemainingPercent: 95,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            creditsRemaining: 25,
+            accountPlan: "Pro",
+            updatedAt: Date())))
+
+        await firstRefreshTask.value
+        await secondRefreshTask.value
+        await backgroundTask.value
+
+        #expect(store.openAIDashboard?.creditsRemaining == 25)
+    }
+
+    @Test
+    func `cancelled background dashboard import does not publish stale account status`() async throws {
+        let settings = try self.makeSettingsStore(
+            suite: "CodexBackgroundRefreshCoalescingTests-dashboard-cancelled-import")
+        settings.statusChecksEnabled = false
+        let managedAccount = try Self.installManagedAccount(
+            email: "managed@example.com",
+            settings: settings)
+        defer { try? FileManager.default.removeItem(atPath: managedAccount.managedHomePath) }
+
+        let store = self.makeStore(settings: settings)
+        let importBlocker = BlockingOpenAIDashboardCookieImport()
+        store._test_openAIDashboardCookieImportOverride = { _, _, _, _, _ in
+            try await importBlocker.awaitResult()
+        }
+        defer { store._test_openAIDashboardCookieImportOverride = nil }
+
+        let importTask = Task { @MainActor in
+            await store.importOpenAIDashboardCookiesIfNeeded(
+                targetEmail: managedAccount.email,
+                force: true)
+        }
+        await importBlocker.waitUntilStarted()
+        importTask.cancel()
+        await importBlocker.resumeNext(with: .failure(
+            OpenAIDashboardBrowserCookieImporter.ImportError.noMatchingAccount(
+                found: [.init(sourceLabel: "Chrome", email: "other@example.com")])))
+
+        let imported = await importTask.value
+        #expect(imported == nil)
+        #expect(store.openAIDashboard == nil)
+        #expect(store.openAIDashboardCookieImportStatus == nil)
+        #expect(store.openAIDashboardRequiresLogin == false)
+    }
+
+    private func makeSettingsStore(suite: String) throws -> SettingsStore {
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        defaults.set(true, forKey: "providerDetectionCompleted")
+        let configStore = testConfigStore(suiteName: suite)
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        let codexMetadata = try #require(ProviderDescriptorRegistry.metadata[.codex])
+        settings.setProviderEnabled(provider: .codex, metadata: codexMetadata, enabled: true)
+        settings.providerDetectionCompleted = true
+        settings.openAIWebAccessEnabled = true
+        settings.codexCookieSource = .auto
+        return settings
+    }
+
+    private func makeStore(settings: SettingsStore) -> UsageStore {
+        UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+    }
+
+    private static func installManagedAccount(
+        email: String,
+        settings: SettingsStore) throws -> ManagedCodexAccount
+    {
+        let account = try Self.makeManagedAccount(email: email)
+        settings._test_activeManagedCodexAccount = account
+        settings.codexActiveSource = .managedAccount(id: account.id)
+        return account
+    }
+
+    private static func makeManagedAccount(email: String) throws -> ManagedCodexAccount {
+        let managedHomeURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        try Self.writeCodexAuthFile(
+            homeURL: managedHomeURL,
+            email: email,
+            plan: "Pro")
+        return ManagedCodexAccount(
+            id: UUID(),
+            email: email,
+            managedHomePath: managedHomeURL.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+    }
+
+    private static func writeCodexAuthFile(homeURL: URL, email: String, plan: String) throws {
+        try FileManager.default.createDirectory(at: homeURL, withIntermediateDirectories: true)
+        let tokens: [String: Any] = [
+            "accessToken": "access-token",
+            "refreshToken": "refresh-token",
+            "idToken": Self.fakeJWT(email: email, plan: plan),
+        ]
+        let data = try JSONSerialization.data(withJSONObject: ["tokens": tokens], options: [.sortedKeys])
+        try data.write(to: homeURL.appendingPathComponent("auth.json"))
+    }
+
+    private static func fakeJWT(email: String, plan: String) -> String {
+        let header = (try? JSONSerialization.data(withJSONObject: ["alg": "none"])) ?? Data()
+        let payload = (try? JSONSerialization.data(withJSONObject: [
+            "email": email,
+            "chatgpt_plan_type": plan,
+            "https://api.openai.com/auth": [
+                "chatgpt_plan_type": plan,
+            ],
+        ])) ?? Data()
+
+        func base64URL(_ data: Data) -> String {
+            data.base64EncodedString()
+                .replacingOccurrences(of: "=", with: "")
+                .replacingOccurrences(of: "+", with: "-")
+                .replacingOccurrences(of: "/", with: "_")
+        }
+
+        return "\(base64URL(header)).\(base64URL(payload))."
+    }
+}
+
+private actor BlockingOpenAIDashboardCookieImport {
+    private var continuations: [
+        CheckedContinuation<Result<OpenAIDashboardBrowserCookieImporter.ImportResult, Error>, Never>
+    ] = []
+    private var startWaiters: [(count: Int, continuation: CheckedContinuation<Void, Never>)] = []
+    private var started = 0
+
+    func awaitResult() async throws -> OpenAIDashboardBrowserCookieImporter.ImportResult {
+        let result = await withCheckedContinuation { continuation in
+            self.continuations.append(continuation)
+            self.started += 1
+            self.resumeReadyStartWaiters()
+        }
+        return try result.get()
+    }
+
+    func waitUntilStarted(count: Int = 1) async {
+        if self.started >= count { return }
+        await withCheckedContinuation { continuation in
+            self.startWaiters.append((count: count, continuation: continuation))
+        }
+    }
+
+    func resumeNext(with result: Result<OpenAIDashboardBrowserCookieImporter.ImportResult, Error>) {
+        guard !self.continuations.isEmpty else { return }
+        let continuation = self.continuations.removeFirst()
+        continuation.resume(returning: result)
+    }
+
+    private func resumeReadyStartWaiters() {
+        var remaining: [(count: Int, continuation: CheckedContinuation<Void, Never>)] = []
+        for waiter in self.startWaiters {
+            if self.started >= waiter.count {
+                waiter.continuation.resume()
+            } else {
+                remaining.append(waiter)
+            }
+        }
+        self.startWaiters = remaining
+    }
+}
diff --git a/Tests/CodexBarTests/CodexBarConfigMigratorTests.swift b/Tests/CodexBarTests/CodexBarConfigMigratorTests.swift
new file mode 100644
index 0000000000..363341ff01
--- /dev/null
+++ b/Tests/CodexBarTests/CodexBarConfigMigratorTests.swift
@@ -0,0 +1,189 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@Suite(.serialized)
+struct CodexBarConfigMigratorTests {
+    @Test
+    func `legacy secret migration completion flag skips repeated scans`() throws {
+        let suite = "CodexBarConfigMigratorTests-skip-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        defer { defaults.removePersistentDomain(forName: suite) }
+
+        let secrets = CountingLegacySecretStore()
+        let accountStore = CountingTokenAccountStore()
+        let stores = Self.legacyStores(secrets: secrets, accountStore: accountStore)
+        let configStore = testConfigStore(suiteName: suite)
+
+        _ = CodexBarConfigMigrator.loadOrMigrate(configStore: configStore, userDefaults: defaults, stores: stores)
+
+        let firstSecretLoads = secrets.loadCount
+        let firstAccountLoads = accountStore.loadCount
+        #expect(firstSecretLoads > 0)
+        #expect(firstAccountLoads == 1)
+        #expect(defaults.bool(forKey: Self.legacyMigrationCompletedKey) == true)
+
+        _ = CodexBarConfigMigrator.loadOrMigrate(configStore: configStore, userDefaults: defaults, stores: stores)
+
+        #expect(secrets.loadCount == firstSecretLoads)
+        #expect(accountStore.loadCount == firstAccountLoads)
+    }
+
+    @Test
+    func `legacy migration completion waits for successful cleanup`() throws {
+        let suite = "CodexBarConfigMigratorTests-cleanup-failure-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        defer { defaults.removePersistentDomain(forName: suite) }
+
+        let secrets = CountingLegacySecretStore(token: "legacy-token", throwOnStore: true)
+        let accountStore = CountingTokenAccountStore()
+        let stores = Self.legacyStores(secrets: secrets, accountStore: accountStore)
+        let configStore = testConfigStore(suiteName: suite)
+
+        _ = CodexBarConfigMigrator.loadOrMigrate(configStore: configStore, userDefaults: defaults, stores: stores)
+
+        let firstSecretLoads = secrets.loadCount
+        #expect(firstSecretLoads > 0)
+        #expect(secrets.clearAttempts > 0)
+        #expect(defaults.bool(forKey: Self.legacyMigrationCompletedKey) == false)
+
+        secrets.throwOnStore = false
+        _ = CodexBarConfigMigrator.loadOrMigrate(configStore: configStore, userDefaults: defaults, stores: stores)
+
+        #expect(secrets.loadCount > firstSecretLoads)
+        #expect(defaults.bool(forKey: Self.legacyMigrationCompletedKey) == true)
+    }
+
+    @Test
+    func `legacy stores are kept when migrated config save fails`() throws {
+        let suite = "CodexBarConfigMigratorTests-save-failure-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        defer { defaults.removePersistentDomain(forName: suite) }
+
+        let base = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-tests", isDirectory: true)
+            .appendingPathComponent(suite, isDirectory: true)
+        try FileManager.default.createDirectory(at: base, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: base) }
+
+        let blockedDirectory = base.appendingPathComponent("blocked")
+        try Data("not a directory".utf8).write(to: blockedDirectory)
+
+        let secrets = CountingLegacySecretStore(token: "legacy-token")
+        let accountStore = CountingTokenAccountStore()
+        let stores = Self.legacyStores(secrets: secrets, accountStore: accountStore)
+        let configStore = CodexBarConfigStore(
+            fileURL: blockedDirectory.appendingPathComponent("config.json"))
+
+        _ = CodexBarConfigMigrator.loadOrMigrate(configStore: configStore, userDefaults: defaults, stores: stores)
+
+        #expect(secrets.clearAttempts == 0)
+        #expect(try secrets.loadToken() == "legacy-token")
+        #expect(defaults.bool(forKey: Self.legacyMigrationCompletedKey) == false)
+
+        try FileManager.default.removeItem(at: blockedDirectory)
+        _ = CodexBarConfigMigrator.loadOrMigrate(configStore: configStore, userDefaults: defaults, stores: stores)
+
+        #expect(secrets.clearAttempts > 0)
+        #expect(try secrets.loadToken() == nil)
+        #expect(defaults.bool(forKey: Self.legacyMigrationCompletedKey) == true)
+    }
+
+    private static let legacyMigrationCompletedKey = "codexbar.legacySecretsMigrationCompleted"
+
+    private static func legacyStores(
+        secrets: CountingLegacySecretStore,
+        accountStore: CountingTokenAccountStore) -> CodexBarConfigMigrator.LegacyStores
+    {
+        CodexBarConfigMigrator.LegacyStores(
+            zaiTokenStore: secrets,
+            syntheticTokenStore: secrets,
+            codexCookieStore: secrets,
+            claudeCookieStore: secrets,
+            cursorCookieStore: secrets,
+            opencodeCookieStore: secrets,
+            factoryCookieStore: secrets,
+            minimaxCookieStore: secrets,
+            minimaxAPITokenStore: secrets,
+            kimiTokenStore: secrets,
+            kimiK2TokenStore: secrets,
+            augmentCookieStore: secrets,
+            ampCookieStore: secrets,
+            copilotTokenStore: secrets,
+            tokenAccountStore: accountStore)
+    }
+}
+
+private final class CountingLegacySecretStore: ZaiTokenStoring, SyntheticTokenStoring, CookieHeaderStoring,
+    MiniMaxCookieStoring, MiniMaxAPITokenStoring, KimiTokenStoring, KimiK2TokenStoring, CopilotTokenStoring,
+    @unchecked Sendable
+{
+    private let lock = NSLock()
+    private var token: String?
+    var throwOnStore: Bool
+    private(set) var loadCount = 0
+    private(set) var clearAttempts = 0
+
+    init(token: String? = nil, throwOnStore: Bool = false) {
+        self.token = token
+        self.throwOnStore = throwOnStore
+    }
+
+    func loadToken() throws -> String? {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        self.loadCount += 1
+        return self.token
+    }
+
+    func storeToken(_ token: String?) throws {
+        try self.store(token)
+    }
+
+    func loadCookieHeader() throws -> String? {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        self.loadCount += 1
+        return self.token
+    }
+
+    func storeCookieHeader(_ header: String?) throws {
+        try self.store(header)
+    }
+
+    private func store(_ value: String?) throws {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        self.clearAttempts += value == nil ? 1 : 0
+        if self.throwOnStore {
+            throw TestStoreError.storeFailed
+        }
+        self.token = value
+    }
+}
+
+private final class CountingTokenAccountStore: ProviderTokenAccountStoring, @unchecked Sendable {
+    private let lock = NSLock()
+    private(set) var loadCount = 0
+
+    func loadAccounts() throws -> [UsageProvider: ProviderTokenAccountData] {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        self.loadCount += 1
+        return [:]
+    }
+
+    func storeAccounts(_: [UsageProvider: ProviderTokenAccountData]) throws {}
+
+    func ensureFileExists() throws -> URL {
+        FileManager.default.temporaryDirectory.appendingPathComponent("codexbar-empty-accounts.json")
+    }
+}
+
+private enum TestStoreError: Error {
+    case storeFailed
+}
diff --git a/Tests/CodexBarTests/CodexBarWidgetProviderTests.swift b/Tests/CodexBarTests/CodexBarWidgetProviderTests.swift
new file mode 100644
index 0000000000..faf5c9945b
--- /dev/null
+++ b/Tests/CodexBarTests/CodexBarWidgetProviderTests.swift
@@ -0,0 +1,600 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+@testable import CodexBarWidget
+
+struct CodexBarWidgetProviderTests {
+    @Test
+    func `small widget limits custom usage rows`() {
+        let entry = WidgetSnapshot.ProviderEntry(
+            provider: .antigravity,
+            updatedAt: Date(),
+            primary: nil,
+            secondary: nil,
+            tertiary: nil,
+            usageRows: [
+                WidgetSnapshot.WidgetUsageRowSnapshot(id: "one", title: "One", percentLeft: 90),
+                WidgetSnapshot.WidgetUsageRowSnapshot(id: "two", title: "Two", percentLeft: 80),
+                WidgetSnapshot.WidgetUsageRowSnapshot(id: "three", title: "Three", percentLeft: 70),
+                WidgetSnapshot.WidgetUsageRowSnapshot(id: "four", title: "Four", percentLeft: 60),
+            ],
+            creditsRemaining: nil,
+            codeReviewRemainingPercent: nil,
+            tokenUsage: nil,
+            dailyUsage: [])
+
+        #expect(WidgetUsageRow.rows(for: entry, limit: 2).map(\.id) == ["one", "two"])
+        #expect(WidgetUsageRow.rows(for: entry).count == 4)
+    }
+
+    @Test
+    func `small antigravity widget keeps one row per quota family`() {
+        let entry = WidgetSnapshot.ProviderEntry(
+            provider: .antigravity,
+            updatedAt: Date(),
+            primary: nil,
+            secondary: nil,
+            tertiary: nil,
+            usageRows: [
+                WidgetSnapshot.WidgetUsageRowSnapshot(
+                    id: "antigravity-quota-summary-gemini-session",
+                    title: "Gemini Models Five Hour Limit",
+                    percentLeft: 80),
+                WidgetSnapshot.WidgetUsageRowSnapshot(
+                    id: "antigravity-quota-summary-gemini-weekly",
+                    title: "Gemini Models Weekly Limit",
+                    percentLeft: 20),
+                WidgetSnapshot.WidgetUsageRowSnapshot(
+                    id: "antigravity-quota-summary-third-party-session",
+                    title: "Claude and GPT models Five Hour Limit",
+                    percentLeft: 5),
+                WidgetSnapshot.WidgetUsageRowSnapshot(
+                    id: "antigravity-quota-summary-third-party-weekly",
+                    title: "Claude and GPT models Weekly Limit",
+                    percentLeft: 60),
+            ],
+            creditsRemaining: nil,
+            codeReviewRemainingPercent: nil,
+            tokenUsage: nil,
+            dailyUsage: [])
+
+        let rows = WidgetUsageRow.rows(for: entry, limit: 2)
+
+        #expect(rows.map(\.title) == ["Gemini Models Weekly Limit", "Claude and GPT models Five Hour Limit"])
+        #expect(rows.compactMap(\.percentLeft) == [20, 5])
+        #expect(WidgetUsageRow.smallWidgetRowLimit(for: entry) == 2)
+        #expect(WidgetUsageRow.mediumWidgetRowLimit(for: entry) == 3)
+        let mediumRows = WidgetUsageRow.rows(
+            for: entry,
+            limit: WidgetUsageRow.mediumWidgetRowLimit(for: entry))
+        #expect(mediumRows.map(\.title) == [
+            "Gemini Models Weekly Limit",
+            "Claude and GPT models Five Hour Limit",
+            "Claude and GPT models Weekly Limit",
+        ])
+    }
+
+    @Test
+    func `small antigravity widget keeps claude gpt family when fallback rows are more constrained`() {
+        let entry = WidgetSnapshot.ProviderEntry(
+            provider: .antigravity,
+            updatedAt: Date(),
+            primary: nil,
+            secondary: nil,
+            tertiary: nil,
+            usageRows: [
+                WidgetSnapshot.WidgetUsageRowSnapshot(
+                    id: "antigravity-quota-summary-gemini-5h",
+                    title: "Gemini Models Five Hour Limit",
+                    percentLeft: 40),
+                WidgetSnapshot.WidgetUsageRowSnapshot(
+                    id: "antigravity-quota-summary-gemini-weekly",
+                    title: "Gemini Models Weekly Limit",
+                    percentLeft: 70),
+                WidgetSnapshot.WidgetUsageRowSnapshot(
+                    id: "antigravity-quota-summary-3p-5h",
+                    title: "Claude and GPT models Five Hour Limit",
+                    percentLeft: 60),
+                WidgetSnapshot.WidgetUsageRowSnapshot(
+                    id: "antigravity-quota-summary-other-5h",
+                    title: "Other Five Hour Limit",
+                    percentLeft: 1),
+            ],
+            creditsRemaining: nil,
+            codeReviewRemainingPercent: nil,
+            tokenUsage: nil,
+            dailyUsage: [])
+
+        let rows = WidgetUsageRow.rows(for: entry, limit: 2)
+
+        #expect(rows.map(\.id) == [
+            "antigravity-quota-summary-gemini-5h",
+            "antigravity-quota-summary-3p-5h",
+        ])
+    }
+
+    @Test
+    func `small widget preserves tertiary rows for other providers`() {
+        let entry = WidgetSnapshot.ProviderEntry(
+            provider: .cursor,
+            updatedAt: Date(),
+            primary: nil,
+            secondary: nil,
+            tertiary: nil,
+            usageRows: [
+                WidgetSnapshot.WidgetUsageRowSnapshot(id: "one", title: "One", percentLeft: 90),
+                WidgetSnapshot.WidgetUsageRowSnapshot(id: "two", title: "Two", percentLeft: 80),
+                WidgetSnapshot.WidgetUsageRowSnapshot(id: "three", title: "Three", percentLeft: 70),
+            ],
+            creditsRemaining: nil,
+            codeReviewRemainingPercent: nil,
+            tokenUsage: nil,
+            dailyUsage: [])
+
+        let limit = WidgetUsageRow.smallWidgetRowLimit(for: entry)
+
+        #expect(limit == nil)
+        #expect(WidgetUsageRow.rows(for: entry, limit: limit).map(\.id) == ["one", "two", "three"])
+    }
+
+    @Test
+    func `small antigravity widget prefers known quota rows`() {
+        let entry = WidgetSnapshot.ProviderEntry(
+            provider: .antigravity,
+            updatedAt: Date(),
+            primary: nil,
+            secondary: nil,
+            tertiary: nil,
+            usageRows: [
+                WidgetSnapshot.WidgetUsageRowSnapshot(
+                    id: "antigravity-quota-summary-gemini-session",
+                    title: "Gemini Models Five Hour Limit",
+                    percentLeft: nil),
+                WidgetSnapshot.WidgetUsageRowSnapshot(
+                    id: "antigravity-quota-summary-gemini-weekly",
+                    title: "Gemini Models Weekly Limit",
+                    percentLeft: 100),
+                WidgetSnapshot.WidgetUsageRowSnapshot(
+                    id: "antigravity-quota-summary-third-party-session",
+                    title: "Claude and GPT models Five Hour Limit",
+                    percentLeft: 80),
+            ],
+            creditsRemaining: nil,
+            codeReviewRemainingPercent: nil,
+            tokenUsage: nil,
+            dailyUsage: [])
+
+        let rows = WidgetUsageRow.rows(for: entry, limit: 2)
+
+        #expect(rows.map(\.title) == ["Gemini Models Weekly Limit", "Claude and GPT models Five Hour Limit"])
+    }
+
+    @Test
+    func `small antigravity widget keeps nonstandard quota groups visible`() {
+        let entry = WidgetSnapshot.ProviderEntry(
+            provider: .antigravity,
+            updatedAt: Date(),
+            primary: nil,
+            secondary: nil,
+            tertiary: nil,
+            usageRows: [
+                WidgetSnapshot.WidgetUsageRowSnapshot(
+                    id: "antigravity-quota-summary-other-session",
+                    title: "Other Session",
+                    percentLeft: 70),
+                WidgetSnapshot.WidgetUsageRowSnapshot(
+                    id: "antigravity-quota-summary-other-weekly",
+                    title: "Other Weekly",
+                    percentLeft: 40),
+            ],
+            creditsRemaining: nil,
+            codeReviewRemainingPercent: nil,
+            tokenUsage: nil,
+            dailyUsage: [])
+
+        let rows = WidgetUsageRow.rows(for: entry, limit: 2)
+
+        #expect(rows.map(\.title) == ["Other Weekly", "Other Session"])
+    }
+
+    @Test
+    func `provider choice supports alibaba`() {
+        #expect(ProviderChoice(provider: .alibaba) == .alibaba)
+        #expect(ProviderChoice.alibaba.provider == .alibaba)
+    }
+
+    @Test
+    func `provider choice supports alibaba token plan`() {
+        #expect(ProviderChoice(provider: .alibabatokenplan) == .alibabatokenplan)
+        #expect(ProviderChoice.alibabatokenplan.provider == .alibabatokenplan)
+    }
+
+    @Test
+    func `provider choice supports opencode go`() {
+        #expect(ProviderChoice(provider: .opencodego) == .opencodego)
+        #expect(ProviderChoice.opencodego.provider == .opencodego)
+    }
+
+    @Test
+    func `provider choice excludes unsupported Chutes widgets`() {
+        #expect(ProviderChoice(provider: .chutes) == nil)
+    }
+
+    @Test
+    func `supported providers fall back to codex when snapshot is empty`() {
+        let snapshot = WidgetSnapshot(entries: [], enabledProviders: [], generatedAt: Date())
+
+        #expect(CodexBarSwitcherTimelineProvider.supportedProviders(from: snapshot) == [.codex])
+    }
+
+    @Test
+    func `supported providers keep alibaba when it is the only enabled provider`() {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let entry = WidgetSnapshot.ProviderEntry(
+            provider: .alibaba,
+            updatedAt: now,
+            primary: nil,
+            secondary: nil,
+            tertiary: nil,
+            creditsRemaining: nil,
+            codeReviewRemainingPercent: nil,
+            tokenUsage: nil,
+            dailyUsage: [])
+        let snapshot = WidgetSnapshot(entries: [entry], enabledProviders: [.alibaba], generatedAt: now)
+
+        #expect(CodexBarSwitcherTimelineProvider.supportedProviders(from: snapshot) == [.alibaba])
+    }
+
+    @Test
+    func `supported providers keep alibaba token plan when it is the only enabled provider`() {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let entry = WidgetSnapshot.ProviderEntry(
+            provider: .alibabatokenplan,
+            updatedAt: now,
+            primary: nil,
+            secondary: nil,
+            tertiary: nil,
+            creditsRemaining: nil,
+            codeReviewRemainingPercent: nil,
+            tokenUsage: nil,
+            dailyUsage: [])
+        let snapshot = WidgetSnapshot(entries: [entry], enabledProviders: [.alibabatokenplan], generatedAt: now)
+
+        #expect(CodexBarSwitcherTimelineProvider.supportedProviders(from: snapshot) == [.alibabatokenplan])
+    }
+
+    @Test
+    func `codex weekly only widget rows omit session`() {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let entry = WidgetSnapshot.ProviderEntry(
+            provider: .codex,
+            updatedAt: now,
+            primary: nil,
+            secondary: RateWindow(usedPercent: 25, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            tertiary: nil,
+            creditsRemaining: nil,
+            codeReviewRemainingPercent: nil,
+            tokenUsage: nil,
+            dailyUsage: [])
+
+        let rows = WidgetUsageRow.rows(for: entry)
+
+        #expect(rows.count == 1)
+        #expect(rows.first?.title == "Weekly")
+        #expect(rows.first?.percentLeft == 75)
+    }
+
+    @Test
+    func `codex widget usage rows keep code review separate from rate rows`() {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let entry = WidgetSnapshot.ProviderEntry(
+            provider: .codex,
+            updatedAt: now,
+            primary: RateWindow(usedPercent: 10, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 25, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            tertiary: nil,
+            creditsRemaining: nil,
+            codeReviewRemainingPercent: 60,
+            tokenUsage: nil,
+            dailyUsage: [])
+
+        let rows = WidgetUsageRow.rows(for: entry)
+
+        #expect(rows.map(\.title) == ["Session", "Weekly"])
+        #expect(rows.count == 2)
+        #expect(!rows.contains { $0.title == "Code review" })
+    }
+
+    @Test
+    func `widget usage rows prefer projected rows over legacy slots`() {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let entry = WidgetSnapshot.ProviderEntry(
+            provider: .codex,
+            updatedAt: now,
+            primary: RateWindow(usedPercent: 10, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 25, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            tertiary: nil,
+            usageRows: [
+                WidgetSnapshot.WidgetUsageRowSnapshot(id: "weekly", title: "Weekly", percentLeft: 75),
+            ],
+            creditsRemaining: nil,
+            codeReviewRemainingPercent: nil,
+            tokenUsage: nil,
+            dailyUsage: [])
+
+        let rows = WidgetUsageRow.rows(for: entry)
+
+        #expect(rows == [WidgetUsageRow(id: "weekly", title: "Weekly", percentLeft: 75)])
+    }
+
+    @Test
+    func `legacy widget usage rows use antigravity grouped slots`() {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let entry = WidgetSnapshot.ProviderEntry(
+            provider: .antigravity,
+            updatedAt: now,
+            primary: RateWindow(usedPercent: 10, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 20, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            tertiary: RateWindow(usedPercent: 30, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            creditsRemaining: nil,
+            codeReviewRemainingPercent: nil,
+            tokenUsage: nil,
+            dailyUsage: [])
+
+        let rows = WidgetUsageRow.rows(for: entry)
+
+        #expect(rows.map(\.id) == ["primary", "secondary"])
+        #expect(rows.map(\.title) == ["Gemini Models", "Claude and GPT"])
+        #expect(rows.compactMap(\.percentLeft) == [90, 80])
+    }
+
+    @Test
+    func `widget configuration intents default to codex and credits`() {
+        let providerIntent = ProviderSelectionIntent()
+        let compactIntent = CompactMetricSelectionIntent()
+        let burnIntent = BurnDownSelectionIntent()
+        let combinedBurnIntent = BurnProviderSelectionIntent()
+
+        #expect(providerIntent.provider == .codex)
+        #expect(compactIntent.provider == .codex)
+        #expect(compactIntent.metric == .credits)
+        #expect(burnIntent.provider == .codex)
+        #expect(burnIntent.window == .session)
+        #expect(combinedBurnIntent.provider == .codex)
+    }
+
+    @Test
+    func `burn down uses an exact provider entry`() {
+        let snapshot = Self.burnSnapshot(provider: .claude, primaryUsed: 20, secondaryUsed: 30)
+
+        #expect(BurnDownState(snapshot: snapshot, provider: .codex, selection: .session) == nil)
+        #expect(BurnDownState(snapshot: snapshot, provider: .claude, selection: .session) != nil)
+    }
+
+    @Test
+    func `codex exhausted weekly cap blocks the session chart until weekly reset`() throws {
+        let weeklyReset = Date(timeIntervalSince1970: 1_800_000_000)
+        let snapshot = Self.burnSnapshot(
+            provider: .codex,
+            primaryUsed: 80,
+            secondaryUsed: 100,
+            primaryReset: weeklyReset.addingTimeInterval(-3600),
+            secondaryReset: weeklyReset)
+        let state = try #require(BurnDownState(snapshot: snapshot, provider: .codex, selection: .session))
+
+        #expect(state.secondaryGloballyCapsPrimary)
+        #expect(state.primaryWindow?.remainingPercent == 0)
+        #expect(state.blankPrimaryChart)
+        #expect(state.selectedResetOverride == weeklyReset)
+    }
+
+    @Test
+    func `gemini exhausted secondary window does not block the independent primary`() throws {
+        let primaryReset = Date(timeIntervalSince1970: 1_800_000_000)
+        let snapshot = Self.burnSnapshot(
+            provider: .gemini,
+            primaryUsed: 20,
+            secondaryUsed: 100,
+            primaryReset: primaryReset,
+            secondaryReset: primaryReset.addingTimeInterval(-3600))
+        let state = try #require(BurnDownState(snapshot: snapshot, provider: .gemini, selection: .session))
+
+        #expect(!state.secondaryGloballyCapsPrimary)
+        #expect(state.primaryWindow?.remainingPercent == 80)
+        #expect(!state.blankPrimaryChart)
+        #expect(state.selectedResetOverride == nil)
+    }
+
+    @Test
+    func `independent secondary reset never overrides primary reset`() throws {
+        let primaryReset = Date(timeIntervalSince1970: 1_800_000_000)
+        let snapshot = Self.burnSnapshot(
+            provider: .gemini,
+            primaryUsed: 20,
+            secondaryUsed: 30,
+            primaryReset: primaryReset,
+            secondaryReset: primaryReset.addingTimeInterval(-3600))
+        let state = try #require(BurnDownState(snapshot: snapshot, provider: .gemini, selection: .session))
+
+        #expect(state.selectedWindow?.resetsAt == primaryReset)
+        #expect(state.selectedResetOverride == nil)
+    }
+
+    @Test
+    func `burn down preview includes session and weekly windows`() throws {
+        let snapshot = WidgetPreviewData.snapshot()
+
+        let session = try #require(BurnDownState(snapshot: snapshot, provider: .codex, selection: .session))
+        let weekly = try #require(BurnDownState(snapshot: snapshot, provider: .codex, selection: .weekly))
+
+        #expect(session.selectedWindow?.windowMinutes == 300)
+        #expect(weekly.selectedWindow?.windowMinutes == 10080)
+    }
+
+    @Test
+    func `burn down selection does not fall back to another window`() throws {
+        let weeklyOnly = Self.burnSnapshot(provider: .codex, primaryUsed: nil, secondaryUsed: 30)
+        let sessionOnly = Self.burnSnapshot(provider: .codex, primaryUsed: 20, secondaryUsed: nil)
+        let weeklyStoredInPrimary = Self.burnSnapshot(
+            provider: .claude,
+            primaryUsed: 30,
+            secondaryUsed: nil,
+            primaryWindowMinutes: 7 * 24 * 60)
+
+        let weeklyOnlySession = try #require(BurnDownState(
+            snapshot: weeklyOnly,
+            provider: .codex,
+            selection: .session))
+        let weeklyOnlyWeekly = try #require(BurnDownState(
+            snapshot: weeklyOnly,
+            provider: .codex,
+            selection: .weekly))
+        let sessionOnlySession = try #require(BurnDownState(
+            snapshot: sessionOnly,
+            provider: .codex,
+            selection: .session))
+        let sessionOnlyWeekly = try #require(BurnDownState(
+            snapshot: sessionOnly,
+            provider: .codex,
+            selection: .weekly))
+        let weeklyPrimarySession = try #require(BurnDownState(
+            snapshot: weeklyStoredInPrimary,
+            provider: .claude,
+            selection: .session))
+        let weeklyPrimaryWeekly = try #require(BurnDownState(
+            snapshot: weeklyStoredInPrimary,
+            provider: .claude,
+            selection: .weekly))
+
+        #expect(weeklyOnlySession.selectedWindow == nil)
+        #expect(weeklyOnlyWeekly.selectedWindow == weeklyOnlyWeekly.secondaryWindow)
+        #expect(sessionOnlySession.selectedWindow == sessionOnlySession.primaryWindow)
+        #expect(sessionOnlyWeekly.selectedWindow == nil)
+        #expect(weeklyPrimarySession.selectedWindow == nil)
+        #expect(weeklyPrimaryWeekly.selectedWindow?.usedPercent == 30)
+    }
+
+    @Test
+    func `expired weekly reset no longer blocks the session chart`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let snapshot = Self.burnSnapshot(
+            provider: .codex,
+            primaryUsed: 20,
+            secondaryUsed: 100,
+            primaryReset: now.addingTimeInterval(300),
+            secondaryReset: now.addingTimeInterval(-1))
+        let state = try #require(BurnDownState(
+            snapshot: snapshot,
+            provider: .codex,
+            selection: .session,
+            now: now))
+
+        #expect(!state.secondaryExhausted)
+        #expect(state.primaryWindow?.remainingPercent == 80)
+        #expect(!state.blankPrimaryChart)
+        #expect(state.selectedResetOverride == nil)
+    }
+
+    @Test
+    func `explicit reset takes precedence over estimated reset`() {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let future = now.addingTimeInterval(600)
+
+        #expect(burnEffectiveResetDate(
+            explicitResetAt: now.addingTimeInterval(-1),
+            estimatedResetMinutes: 5,
+            now: now) == nil)
+        #expect(burnEffectiveResetDate(
+            explicitResetAt: future,
+            estimatedResetMinutes: 5,
+            now: now) == future)
+        #expect(burnEffectiveResetDate(
+            explicitResetAt: nil,
+            estimatedResetMinutes: 5,
+            now: now) == now.addingTimeInterval(300))
+        #expect(burnEffectiveResetDate(
+            explicitResetAt: nil,
+            estimatedResetMinutes: nil,
+            now: now) == nil)
+    }
+
+    @Test
+    func `burn down axis shares the effective estimated reset`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let effectiveReset = try #require(burnEffectiveResetDate(
+            explicitResetAt: nil,
+            estimatedResetMinutes: 90,
+            now: now))
+
+        let axis = burnAxisDateRange(
+            effectiveResetAt: effectiveReset,
+            windowMinutes: 300,
+            now: now)
+
+        #expect(axis.reset == effectiveReset)
+        #expect(axis.start == effectiveReset.addingTimeInterval(-5 * 60 * 60))
+    }
+
+    @Test
+    func `burn down refreshes immediately after the earliest future reset`() {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let snapshot = Self.burnSnapshot(
+            provider: .codex,
+            primaryUsed: 20,
+            secondaryUsed: 30,
+            primaryReset: now.addingTimeInterval(60),
+            secondaryReset: now.addingTimeInterval(120))
+
+        #expect(BurnDownRefreshSchedule.nextRefresh(snapshot: snapshot, provider: .codex, now: now)
+            == now.addingTimeInterval(61))
+    }
+
+    @Test
+    func `burn down refresh ignores past resets and unrelated provider entries`() {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let snapshot = Self.burnSnapshot(
+            provider: .claude,
+            primaryUsed: 20,
+            secondaryUsed: 30,
+            primaryReset: now.addingTimeInterval(-60),
+            secondaryReset: now.addingTimeInterval(-30))
+        let fallback = now.addingTimeInterval(30 * 60)
+
+        #expect(BurnDownRefreshSchedule.nextRefresh(snapshot: snapshot, provider: .claude, now: now) == fallback)
+        #expect(BurnDownRefreshSchedule.nextRefresh(snapshot: snapshot, provider: .codex, now: now) == fallback)
+    }
+
+    private static func burnSnapshot(
+        provider: UsageProvider,
+        primaryUsed: Double?,
+        secondaryUsed: Double?,
+        primaryReset: Date? = nil,
+        secondaryReset: Date? = nil,
+        primaryWindowMinutes: Int = 5 * 60,
+        secondaryWindowMinutes: Int = 7 * 24 * 60) -> WidgetSnapshot
+    {
+        let entry = WidgetSnapshot.ProviderEntry(
+            provider: provider,
+            updatedAt: Date(timeIntervalSince1970: 1_700_000_000),
+            primary: primaryUsed.map {
+                RateWindow(
+                    usedPercent: $0,
+                    windowMinutes: primaryWindowMinutes,
+                    resetsAt: primaryReset,
+                    resetDescription: nil)
+            },
+            secondary: secondaryUsed.map {
+                RateWindow(
+                    usedPercent: $0,
+                    windowMinutes: secondaryWindowMinutes,
+                    resetsAt: secondaryReset,
+                    resetDescription: nil)
+            },
+            tertiary: nil,
+            creditsRemaining: nil,
+            codeReviewRemainingPercent: nil,
+            tokenUsage: nil,
+            dailyUsage: [])
+        return WidgetSnapshot(entries: [entry], generatedAt: entry.updatedAt)
+    }
+}
diff --git a/Tests/CodexBarTests/CodexBaselineCharacterizationTests.swift b/Tests/CodexBarTests/CodexBaselineCharacterizationTests.swift
new file mode 100644
index 0000000000..4c89c92f63
--- /dev/null
+++ b/Tests/CodexBarTests/CodexBaselineCharacterizationTests.swift
@@ -0,0 +1,363 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct CodexBaselineCharacterizationTests {
+    private func makeContext(
+        runtime: ProviderRuntime,
+        sourceMode: ProviderSourceMode,
+        env: [String: String] = [:],
+        settings: ProviderSettingsSnapshot? = nil,
+        includeCredits: Bool = false,
+        codexArguments: [String]? = nil) -> ProviderFetchContext
+    {
+        let browserDetection = BrowserDetection(cacheTTL: 0)
+        let fetcher = if let codexArguments {
+            UsageFetcher(
+                environment: env,
+                initializeTimeoutSeconds: 20.0,
+                requestTimeoutSeconds: 3.0,
+                codexArguments: codexArguments)
+        } else {
+            UsageFetcher(environment: env, initializeTimeoutSeconds: 20.0, requestTimeoutSeconds: 3.0)
+        }
+        return ProviderFetchContext(
+            runtime: runtime,
+            sourceMode: sourceMode,
+            includeCredits: includeCredits,
+            webTimeout: 1,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: env,
+            settings: settings,
+            fetcher: fetcher,
+            claudeFetcher: ClaudeUsageFetcher(browserDetection: browserDetection),
+            browserDetection: browserDetection)
+    }
+
+    private func strategyIDs(
+        runtime: ProviderRuntime,
+        sourceMode: ProviderSourceMode,
+        env: [String: String] = [:],
+        settings: ProviderSettingsSnapshot? = nil) async -> [String]
+    {
+        let descriptor = ProviderDescriptorRegistry.descriptor(for: .codex)
+        let context = self.makeContext(runtime: runtime, sourceMode: sourceMode, env: env, settings: settings)
+        let strategies = await descriptor.fetchPlan.pipeline.resolveStrategies(context)
+        return strategies.map(\.id)
+    }
+
+    private func fetchOutcome(
+        runtime: ProviderRuntime,
+        sourceMode: ProviderSourceMode,
+        env: [String: String] = [:],
+        settings: ProviderSettingsSnapshot? = nil,
+        includeCredits: Bool = false,
+        codexArguments: [String]? = nil) async -> ProviderFetchOutcome
+    {
+        let descriptor = ProviderDescriptorRegistry.descriptor(for: .codex)
+        let context = self.makeContext(
+            runtime: runtime,
+            sourceMode: sourceMode,
+            env: env,
+            settings: settings,
+            includeCredits: includeCredits,
+            codexArguments: codexArguments)
+        return await descriptor.fetchPlan.fetchOutcome(context: context, provider: .codex)
+    }
+
+    private struct StubCodexCLI {
+        let executable: String
+        let arguments: [String]
+    }
+
+    private func makeStubCodexCLI() -> StubCodexCLI {
+        let script = """
+        if [ -n "${CODEXBAR_STUB_COUNTER:-}" ]; then
+          printf '%s\\n' start >> "$CODEXBAR_STUB_COUNTER"
+        fi
+
+        while IFS= read -r line; do
+          case "$line" in
+            *'"method":"initialized"'*|*'"method": "initialized"'*)
+              ;;
+            *'"method":"initialize"'*|*'"method": "initialize"'*)
+              printf '%s\\n' '{"id":1,"result":{}}'
+              ;;
+            *'"method"'*account*rateLimits*read*)
+              if [ "${CODEXBAR_STUB_CREDITS_ONLY:-}" = "1" ]; then
+                response='{"id":2,"result":{"rateLimits":{"credits":'
+                response="${response}"'{"hasCredits":true,"unlimited":false,"balance":"7"}}}}'
+                printf '%s\\n' "$response"
+              else
+                response='{"id":2,"result":{"rateLimits":{"credits":'
+                response="${response}"'{"hasCredits":true,"unlimited":false,"balance":"7"},'
+                response="${response}"'"primary":{"usedPercent":12,"windowDurationMins":300,"resetsAt":1766948068},'
+                response="${response}"'"secondary":{"usedPercent":43,"windowDurationMins":10080,'
+                response="${response}"'"resetsAt":1767407914}}}}'
+                printf '%s\\n' "$response"
+              fi
+              ;;
+            *'"method"'*account*read*)
+              response='{"id":3,"result":{"account":{"type":"chatgpt","email":"stub@example.com",'
+              response="${response}"'"planType":"pro"},"requiresOpenaiAuth":false}}'
+              printf '%s\\n' "$response"
+              ;;
+          esac
+        done
+        """
+        return StubCodexCLI(executable: "/bin/sh", arguments: ["-c", script])
+    }
+
+    private func makeEmptyCodexHome() throws -> URL {
+        let homeURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-empty-home-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: homeURL, withIntermediateDirectories: true)
+        return homeURL
+    }
+
+    private func makeUnavailableOAuthHome() throws -> URL {
+        let homeURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-oauth-home-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: homeURL, withIntermediateDirectories: true)
+
+        let credentials = CodexOAuthCredentials(
+            accessToken: "access-token",
+            refreshToken: "refresh-token",
+            idToken: nil,
+            accountId: "account-id",
+            lastRefresh: Date())
+        try CodexOAuthCredentialsStore.save(credentials, env: ["CODEX_HOME": homeURL.path])
+
+        let configURL = homeURL.appendingPathComponent("config.toml")
+        try "chatgpt_base_url = \"http://127.0.0.1:9\"".write(to: configURL, atomically: true, encoding: .utf8)
+
+        return homeURL
+    }
+
+    @Test
+    func `app auto pipeline order is OAuth then CLI without web`() async {
+        let strategyIDs = await self.strategyIDs(runtime: .app, sourceMode: .auto)
+        #expect(strategyIDs == ["codex.oauth", "codex.cli"])
+    }
+
+    @Test
+    func `CLI auto pipeline order is OAuth then CLI without web`() async {
+        let strategyIDs = await self.strategyIDs(runtime: .cli, sourceMode: .auto)
+        #expect(strategyIDs == ["codex.oauth", "codex.cli"])
+    }
+
+    @Test
+    func `explicit fetch plan modes keep single Codex strategy selection`() async {
+        let appCases: [(ProviderSourceMode, [String])] = [
+            (.oauth, ["codex.oauth"]),
+            (.cli, ["codex.cli"]),
+            (.web, ["codex.web.dashboard"]),
+        ]
+
+        for (sourceMode, expected) in appCases {
+            let strategyIDs = await self.strategyIDs(runtime: .app, sourceMode: sourceMode)
+            #expect(strategyIDs == expected)
+        }
+
+        for (sourceMode, expected) in appCases {
+            let strategyIDs = await self.strategyIDs(runtime: .cli, sourceMode: sourceMode)
+            #expect(strategyIDs == expected)
+        }
+    }
+
+    @Test
+    func `app auto records unavailable OAuth before successful CLI fallback`() async throws {
+        let stubCLI = self.makeStubCodexCLI()
+        let codexHome = try self.makeEmptyCodexHome()
+        defer { try? FileManager.default.removeItem(at: codexHome) }
+        let env = [
+            "CODEX_CLI_PATH": stubCLI.executable,
+            "CODEX_HOME": codexHome.path,
+        ]
+
+        let outcome = await self.fetchOutcome(
+            runtime: .app,
+            sourceMode: .auto,
+            env: env,
+            codexArguments: stubCLI.arguments)
+
+        #expect(outcome.attempts.map(\.strategyID) == ["codex.oauth", "codex.cli"])
+        #expect(outcome.attempts.map(\.wasAvailable) == [false, true])
+
+        switch outcome.result {
+        case let .success(result):
+            #expect(result.sourceLabel == "codex-cli")
+            #expect(result.usage.accountEmail(for: .codex) == "stub@example.com")
+            #expect(result.usage.loginMethod(for: .codex) == "pro")
+        case let .failure(error):
+            Issue.record("Unexpected failure: \(error)")
+        }
+    }
+
+    @Test
+    func `app auto does not fall back from non auth failing OAuth`() async throws {
+        let stubCLI = self.makeStubCodexCLI()
+        let oauthHome = try self.makeUnavailableOAuthHome()
+        defer { try? FileManager.default.removeItem(at: oauthHome) }
+
+        let env = [
+            "CODEX_CLI_PATH": stubCLI.executable,
+            "CODEX_HOME": oauthHome.path,
+        ]
+
+        let outcome = await self.fetchOutcome(
+            runtime: .app,
+            sourceMode: .auto,
+            env: env,
+            codexArguments: stubCLI.arguments)
+
+        #expect(outcome.attempts.map(\.strategyID) == ["codex.oauth"])
+        #expect(outcome.attempts.map(\.wasAvailable) == [true])
+        #expect(outcome.attempts[0].errorDescription?.isEmpty == false)
+
+        switch outcome.result {
+        case .success:
+            Issue.record("Expected non-auth OAuth failure to stop before CLI fallback")
+        case let .failure(error as CodexOAuthFetchError):
+            switch error {
+            case .networkError:
+                break
+            default:
+                Issue.record("Expected network error, got \(error)")
+            }
+        case let .failure(error):
+            Issue.record("Unexpected failure: \(error)")
+        }
+    }
+
+    @Test
+    func `Codex CLI strategy fetches usage and credits with one app-server process`() async {
+        let stubCLI = self.makeStubCodexCLI()
+        let counterURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-stub-counter-\(UUID().uuidString)", isDirectory: false)
+        defer { try? FileManager.default.removeItem(at: counterURL) }
+
+        let env = [
+            "CODEX_CLI_PATH": stubCLI.executable,
+            "CODEXBAR_STUB_COUNTER": counterURL.path,
+        ]
+
+        let outcome = await self.fetchOutcome(
+            runtime: .app,
+            sourceMode: .cli,
+            env: env,
+            includeCredits: true,
+            codexArguments: stubCLI.arguments)
+
+        switch outcome.result {
+        case let .success(result):
+            #expect(result.sourceLabel == "codex-cli")
+            #expect(result.usage.primary?.usedPercent == 12)
+            #expect(result.credits?.remaining == 7)
+        case let .failure(error):
+            Issue.record("Unexpected failure: \(error)")
+        }
+
+        let count = (try? String(contentsOf: counterURL, encoding: .utf8))?
+            .split(whereSeparator: \.isNewline)
+            .count ?? 0
+        #expect(count == 1)
+    }
+
+    @Test
+    func `Codex CLI strategy keeps credits when rate limit windows are absent`() async {
+        let stubCLI = self.makeStubCodexCLI()
+
+        let outcome = await self.fetchOutcome(
+            runtime: .app,
+            sourceMode: .cli,
+            env: [
+                "CODEX_CLI_PATH": stubCLI.executable,
+                "CODEXBAR_STUB_CREDITS_ONLY": "1",
+            ],
+            includeCredits: true,
+            codexArguments: stubCLI.arguments)
+
+        switch outcome.result {
+        case let .success(result):
+            #expect(result.sourceLabel == "codex-cli")
+            #expect(result.usage.primary == nil)
+            #expect(result.usage.secondary == nil)
+            #expect(result.credits?.remaining == 7)
+        case let .failure(error):
+            Issue.record("Unexpected failure: \(error)")
+        }
+    }
+
+    @Test
+    func `CLI auto records unavailable OAuth before successful CLI`() async throws {
+        let stubCLI = self.makeStubCodexCLI()
+        let codexHome = try self.makeEmptyCodexHome()
+        defer { try? FileManager.default.removeItem(at: codexHome) }
+        let settings = ProviderSettingsSnapshot.make(
+            codex: .init(
+                usageDataSource: .auto,
+                cookieSource: .auto,
+                manualCookieHeader: nil,
+                managedAccountStoreUnreadable: true))
+
+        let outcome = await self.fetchOutcome(
+            runtime: .cli,
+            sourceMode: .auto,
+            env: [
+                "CODEX_CLI_PATH": stubCLI.executable,
+                "CODEX_HOME": codexHome.path,
+            ],
+            settings: settings,
+            codexArguments: stubCLI.arguments)
+
+        #expect(outcome.attempts.map(\.strategyID) == ["codex.oauth", "codex.cli"])
+        #expect(outcome.attempts.map(\.wasAvailable) == [false, true])
+
+        switch outcome.result {
+        case let .success(result):
+            #expect(result.sourceLabel == "codex-cli")
+            #expect(result.usage.accountEmail(for: .codex) == "stub@example.com")
+        case let .failure(error):
+            Issue.record("Unexpected failure: \(error)")
+        }
+    }
+
+    @Test
+    func `CLI auto tries OAuth before missing CLI fallback`() async throws {
+        let oauthHome = try self.makeUnavailableOAuthHome()
+        defer { try? FileManager.default.removeItem(at: oauthHome) }
+        let settings = ProviderSettingsSnapshot.make(
+            codex: .init(
+                usageDataSource: .auto,
+                cookieSource: .auto,
+                manualCookieHeader: nil,
+                managedAccountStoreUnreadable: true))
+
+        let outcome = await self.fetchOutcome(
+            runtime: .cli,
+            sourceMode: .auto,
+            env: [
+                "CODEX_CLI_PATH": "/missing/codex",
+                "CODEX_HOME": oauthHome.path,
+            ],
+            settings: settings)
+
+        #expect(outcome.attempts.map(\.strategyID) == ["codex.oauth"])
+        #expect(outcome.attempts.map(\.wasAvailable) == [true])
+
+        switch outcome.result {
+        case .success:
+            Issue.record("Expected unavailable OAuth endpoint to fail before CLI fallback")
+        case let .failure(error as CodexOAuthFetchError):
+            if case .networkError = error {
+                break
+            }
+            Issue.record("Expected network error, got \(error)")
+        case let .failure(error):
+            Issue.record("Unexpected failure: \(error)")
+        }
+    }
+}
diff --git a/Tests/CodexBarTests/CodexCLILaunchGateTests.swift b/Tests/CodexBarTests/CodexCLILaunchGateTests.swift
new file mode 100644
index 0000000000..bb0babe19c
--- /dev/null
+++ b/Tests/CodexBarTests/CodexCLILaunchGateTests.swift
@@ -0,0 +1,40 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct CodexCLILaunchGateTests {
+    @Test
+    func `background launch failures suppress repeated background launches until cooldown expires`() {
+        let gate = CodexCLILaunchGate.shared
+        gate.resetForTesting()
+        defer { gate.resetForTesting() }
+        let now = Date(timeIntervalSince1970: 100)
+
+        let message = gate.recordLaunchFailure(
+            binary: "/opt/homebrew/bin/codex",
+            message: "\"codex\" was not opened because it contains malware.",
+            now: now)
+
+        #expect(message?.contains("background refresh is paused") == true)
+        #expect(gate.backgroundSkipMessage(
+            binary: "/opt/homebrew/bin/codex",
+            now: now.addingTimeInterval(60),
+            interaction: .background) == message)
+        #expect(gate.backgroundSkipMessage(
+            binary: "/opt/homebrew/bin/codex",
+            now: now.addingTimeInterval(60),
+            interaction: .userInitiated) == nil)
+        #expect(gate.backgroundSkipMessage(
+            binary: "/opt/homebrew/bin/codex",
+            now: now.addingTimeInterval(CodexCLILaunchGate.cooldown + 1),
+            interaction: .background) == nil)
+    }
+
+    @Test
+    func `PTY infrastructure failures do not suppress future Codex launches`() {
+        #expect(CodexCLILaunchGate.shouldThrottleLaunchFailure("openpty failed") == false)
+        #expect(CodexCLILaunchGate.shouldThrottleLaunchFailure("write to PTY failed") == false)
+        #expect(CodexCLILaunchGate.shouldThrottleLaunchFailure("The operation could not be completed") == true)
+    }
+}
diff --git a/Tests/CodexBarTests/CodexCLIWindowNormalizationTests.swift b/Tests/CodexBarTests/CodexCLIWindowNormalizationTests.swift
new file mode 100644
index 0000000000..417517870d
--- /dev/null
+++ b/Tests/CodexBarTests/CodexCLIWindowNormalizationTests.swift
@@ -0,0 +1,226 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct CodexCLIWindowNormalizationTests {
+    @Test
+    func `normalizer maps lone weekly window into secondary`() {
+        let weekly = RateWindow(
+            usedPercent: 5,
+            windowMinutes: 10080,
+            resetsAt: nil,
+            resetDescription: nil)
+
+        let normalized = CodexRateWindowNormalizer._normalizeForTesting(primary: weekly, secondary: nil)
+        #expect(normalized.primary == nil)
+        #expect(normalized.secondary?.usedPercent == 5)
+        #expect(normalized.secondary?.windowMinutes == 10080)
+    }
+
+    @Test
+    func `normalizer keeps lone session window in primary`() {
+        let session = RateWindow(
+            usedPercent: 31,
+            windowMinutes: 300,
+            resetsAt: nil,
+            resetDescription: nil)
+
+        let normalized = CodexRateWindowNormalizer._normalizeForTesting(primary: session, secondary: nil)
+        #expect(normalized.primary?.usedPercent == 31)
+        #expect(normalized.primary?.windowMinutes == 300)
+        #expect(normalized.secondary == nil)
+    }
+
+    @Test
+    func `normalizer keeps session and weekly ordering unchanged`() {
+        let session = RateWindow(
+            usedPercent: 31,
+            windowMinutes: 300,
+            resetsAt: nil,
+            resetDescription: nil)
+        let weekly = RateWindow(
+            usedPercent: 26,
+            windowMinutes: 10080,
+            resetsAt: nil,
+            resetDescription: nil)
+
+        let normalized = CodexRateWindowNormalizer._normalizeForTesting(primary: session, secondary: weekly)
+        #expect(normalized.primary?.usedPercent == 31)
+        #expect(normalized.primary?.windowMinutes == 300)
+        #expect(normalized.secondary?.usedPercent == 26)
+        #expect(normalized.secondary?.windowMinutes == 10080)
+    }
+
+    @Test
+    func `normalizer swaps reversed weekly and unknown windows`() {
+        let weekly = RateWindow(
+            usedPercent: 43,
+            windowMinutes: 10080,
+            resetsAt: nil,
+            resetDescription: nil)
+        let unknown = RateWindow(
+            usedPercent: 17,
+            windowMinutes: 540,
+            resetsAt: nil,
+            resetDescription: nil)
+
+        let normalized = CodexRateWindowNormalizer._normalizeForTesting(primary: weekly, secondary: unknown)
+        #expect(normalized.primary?.usedPercent == 17)
+        #expect(normalized.primary?.windowMinutes == 540)
+        #expect(normalized.secondary?.usedPercent == 43)
+        #expect(normalized.secondary?.windowMinutes == 10080)
+    }
+
+    @Test
+    func `maps weekly only RPC limits into secondary`() throws {
+        let snapshot = try UsageFetcher._mapCodexRPCLimitsForTesting(
+            primary: (usedPercent: 5, windowMinutes: 10080, resetsAt: nil),
+            secondary: nil)
+
+        #expect(snapshot.primary == nil)
+        #expect(snapshot.secondary?.usedPercent == 5)
+        #expect(snapshot.secondary?.windowMinutes == 10080)
+    }
+
+    @Test
+    func `maps session only RPC limits into primary`() throws {
+        let snapshot = try UsageFetcher._mapCodexRPCLimitsForTesting(
+            primary: (usedPercent: 31, windowMinutes: 300, resetsAt: nil),
+            secondary: nil)
+
+        #expect(snapshot.primary?.usedPercent == 31)
+        #expect(snapshot.primary?.windowMinutes == 300)
+        #expect(snapshot.secondary == nil)
+    }
+
+    @Test
+    func `maps reversed weekly and unknown RPC limits`() throws {
+        let snapshot = try UsageFetcher._mapCodexRPCLimitsForTesting(
+            primary: (usedPercent: 43, windowMinutes: 10080, resetsAt: nil),
+            secondary: (usedPercent: 17, windowMinutes: 540, resetsAt: nil))
+
+        #expect(snapshot.primary?.usedPercent == 17)
+        #expect(snapshot.primary?.windowMinutes == 540)
+        #expect(snapshot.secondary?.usedPercent == 43)
+        #expect(snapshot.secondary?.windowMinutes == 10080)
+    }
+
+    @Test
+    func `throws when RPC limits contain no windows`() {
+        #expect(throws: UsageError.noRateLimitsFound) {
+            try UsageFetcher._mapCodexRPCLimitsForTesting(primary: nil, secondary: nil)
+        }
+    }
+
+    @Test
+    func `maps plan only RPC limits into empty identified snapshot`() throws {
+        let snapshot = try UsageFetcher._mapCodexRPCLimitsForTesting(
+            primary: nil,
+            secondary: nil,
+            planType: "pro")
+
+        #expect(snapshot.primary == nil)
+        #expect(snapshot.secondary == nil)
+        #expect(snapshot.loginMethod(for: .codex) == "pro")
+        #expect(snapshot.rateLimitsUnavailable(for: .codex))
+    }
+
+    @Test
+    func `codex no rate limit error means limits unavailable without snapshot`() {
+        let availability = UsageLimitsAvailability.resolve(
+            provider: .codex,
+            snapshot: nil,
+            account: AccountInfo(email: "user@example.com", plan: nil),
+            lastErrorDescription: UsageError.noRateLimitsFound.errorDescription)
+
+        #expect(availability == .unavailable)
+    }
+
+    @Test
+    func `codex no rate limit error stays available without account context`() {
+        let availability = UsageLimitsAvailability.resolve(
+            provider: .codex,
+            snapshot: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            lastErrorDescription: UsageError.noRateLimitsFound.errorDescription)
+
+        #expect(availability == .available)
+    }
+
+    @Test
+    func `codex windowed snapshot wins over stale no rate limit error`() {
+        let identity = ProviderIdentitySnapshot(
+            providerID: .codex,
+            accountEmail: "user@example.com",
+            accountOrganization: nil,
+            loginMethod: "pro")
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 25,
+                windowMinutes: 300,
+                resetsAt: nil,
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date(),
+            identity: identity)
+        let availability = UsageLimitsAvailability.resolve(
+            provider: .codex,
+            snapshot: snapshot,
+            lastErrorDescription: UsageError.noRateLimitsFound.errorDescription)
+
+        #expect(availability == .available)
+    }
+
+    @Test
+    func `maps weekly only status snapshot into secondary`() throws {
+        let status = CodexStatusSnapshot(
+            credits: nil,
+            fiveHourPercentLeft: nil,
+            weeklyPercentLeft: 95,
+            fiveHourResetDescription: nil,
+            weeklyResetDescription: "resets next week",
+            fiveHourResetsAt: nil,
+            weeklyResetsAt: nil,
+            rawText: "Weekly limit: 95% left")
+
+        let snapshot = try UsageFetcher._mapCodexStatusForTesting(status)
+        #expect(snapshot.primary == nil)
+        #expect(snapshot.secondary?.usedPercent == 5)
+        #expect(snapshot.secondary?.windowMinutes == 10080)
+    }
+
+    @Test
+    func `maps five hour only status snapshot into primary`() throws {
+        let status = CodexStatusSnapshot(
+            credits: nil,
+            fiveHourPercentLeft: 69,
+            weeklyPercentLeft: nil,
+            fiveHourResetDescription: "resets soon",
+            weeklyResetDescription: nil,
+            fiveHourResetsAt: nil,
+            weeklyResetsAt: nil,
+            rawText: "5h limit: 69% left")
+
+        let snapshot = try UsageFetcher._mapCodexStatusForTesting(status)
+        #expect(snapshot.primary?.usedPercent == 31)
+        #expect(snapshot.primary?.windowMinutes == 300)
+        #expect(snapshot.secondary == nil)
+    }
+
+    @Test
+    func `throws when status snapshot contains no windows`() {
+        let status = CodexStatusSnapshot(
+            credits: nil,
+            fiveHourPercentLeft: nil,
+            weeklyPercentLeft: nil,
+            fiveHourResetDescription: nil,
+            weeklyResetDescription: nil,
+            fiveHourResetsAt: nil,
+            weeklyResetsAt: nil,
+            rawText: "")
+
+        #expect(throws: UsageError.noRateLimitsFound) {
+            try UsageFetcher._mapCodexStatusForTesting(status)
+        }
+    }
+}
diff --git a/Tests/CodexBarTests/CodexCombinedMetricHighestUsageTests.swift b/Tests/CodexBarTests/CodexCombinedMetricHighestUsageTests.swift
new file mode 100644
index 0000000000..e0975454e4
--- /dev/null
+++ b/Tests/CodexBarTests/CodexCombinedMetricHighestUsageTests.swift
@@ -0,0 +1,101 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@MainActor
+struct CodexCombinedMetricHighestUsageTests {
+    @Test
+    func `combined codex metric uses weekly lane when ranking highest usage`() {
+        let store = self.makeStore(suiteName: "CodexCombinedMetricHighestUsageTests-weekly-ranking")
+
+        let codexSnapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 12, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 91, windowMinutes: 7 * 24 * 60, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+        let claudeSnapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 80, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(codexSnapshot, provider: .codex)
+        store._setSnapshotForTesting(claudeSnapshot, provider: .claude)
+
+        let highest = store.providerWithHighestUsage()
+        #expect(highest?.provider == .codex)
+        #expect(highest?.usedPercent == 91)
+    }
+
+    @Test
+    func `combined codex metric stays eligible when only one lane is exhausted`() {
+        let store = self.makeStore(suiteName: "CodexCombinedMetricHighestUsageTests-one-exhausted")
+
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(usedPercent: 100, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+                secondary: RateWindow(
+                    usedPercent: 30,
+                    windowMinutes: 7 * 24 * 60,
+                    resetsAt: nil,
+                    resetDescription: nil),
+                updatedAt: Date()),
+            provider: .codex)
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(usedPercent: 80, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date()),
+            provider: .claude)
+
+        let highest = store.providerWithHighestUsage()
+        #expect(highest?.provider == .codex)
+        #expect(highest?.usedPercent == 100)
+    }
+
+    @Test
+    func `combined codex metric is excluded when both lanes are exhausted`() {
+        let store = self.makeStore(suiteName: "CodexCombinedMetricHighestUsageTests-both-exhausted")
+
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(usedPercent: 100, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+                secondary: RateWindow(
+                    usedPercent: 100,
+                    windowMinutes: 7 * 24 * 60,
+                    resetsAt: nil,
+                    resetDescription: nil),
+                updatedAt: Date()),
+            provider: .codex)
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(usedPercent: 80, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date()),
+            provider: .claude)
+
+        let highest = store.providerWithHighestUsage()
+        #expect(highest?.provider == .claude)
+        #expect(highest?.usedPercent == 80)
+    }
+
+    private func makeStore(suiteName: String) -> UsageStore {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: suiteName),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.setMenuBarMetricPreference(.primaryAndSecondary, for: .codex)
+
+        let registry = ProviderRegistry.shared
+        if let codexMeta = registry.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+        if let claudeMeta = registry.metadata[.claude] {
+            settings.setProviderEnabled(provider: .claude, metadata: claudeMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        return UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+    }
+}
diff --git a/Tests/CodexBarTests/CodexConsumerProjectionCharacterizationTests.swift b/Tests/CodexBarTests/CodexConsumerProjectionCharacterizationTests.swift
new file mode 100644
index 0000000000..865e6ac15b
--- /dev/null
+++ b/Tests/CodexBarTests/CodexConsumerProjectionCharacterizationTests.swift
@@ -0,0 +1,302 @@
+import AppKit
+import CodexBarCore
+import Testing
+@testable import CodexBar
+
+@MainActor
+@Suite(.serialized)
+struct CodexConsumerProjectionCharacterizationTests {
+    private func makeSettings() -> SettingsStore {
+        testSettingsStore(suiteName: "CodexConsumerProjectionCharacterizationTests")
+    }
+
+    private func makeCodexStore(settings: SettingsStore, dashboardAuthorized: Bool) -> UsageStore {
+        let now = Date()
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 22,
+                    windowMinutes: 300,
+                    resetsAt: now.addingTimeInterval(1800),
+                    resetDescription: nil),
+                secondary: nil,
+                tertiary: nil,
+                updatedAt: now,
+                identity: ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: "codex@example.com",
+                    accountOrganization: nil,
+                    loginMethod: "Plus Plan")),
+            provider: .codex)
+        store.openAIDashboard = OpenAIDashboardSnapshot(
+            signedInEmail: "other@example.com",
+            codeReviewRemainingPercent: 88,
+            codeReviewLimit: RateWindow(
+                usedPercent: 12,
+                windowMinutes: nil,
+                resetsAt: now.addingTimeInterval(3600),
+                resetDescription: nil),
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            updatedAt: now)
+        store.openAIDashboardAttachmentAuthorized = dashboardAuthorized
+        store.openAIDashboardRequiresLogin = false
+        return store
+    }
+
+    private func enableCodexProvider(settings: SettingsStore) {
+        if let codexMeta = ProviderRegistry.shared.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+    }
+
+    private func makeMenuBarController(settings: SettingsStore) -> (UsageStore, StatusItemController) {
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: testStatusBar())
+        return (store, controller)
+    }
+
+    @Test
+    func `snapshot override menu card stays isolated from live codex extras`() throws {
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+
+        let fetcher = UsageFetcher()
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: true)
+        store.credits = CreditsSnapshot(remaining: 42, events: [], updatedAt: Date())
+        store._setTokenSnapshotForTesting(CostUsageTokenSnapshot(
+            sessionTokens: 123,
+            sessionCostUSD: 1.23,
+            last30DaysTokens: 456,
+            last30DaysCostUSD: 4.56,
+            daily: [],
+            updatedAt: Date()), provider: .codex)
+        store._setErrorForTesting("Live store error", provider: .codex)
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: testStatusBar())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let overrideSnapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 15,
+                windowMinutes: 300,
+                resetsAt: Date().addingTimeInterval(1800),
+                resetDescription: nil),
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: "override@example.com",
+                accountOrganization: nil,
+                loginMethod: "Plus Plan"))
+
+        let model = try #require(controller.menuCardModel(
+            for: .codex,
+            snapshotOverride: overrideSnapshot,
+            errorOverride: "Override error"))
+
+        #expect(model.creditsText == "Credits unavailable; keep Codex running to refresh.")
+        #expect(model.tokenUsage == nil)
+        #expect(model.metrics.contains { $0.id == "code-review" } == false)
+        #expect(model.subtitleText == "Override error")
+    }
+
+    @Test
+    func `menu bar display text keeps percent in show used mode when codex is exhausted`() {
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        settings.menuBarDisplayMode = .percent
+        settings.usageBarsShowUsed = true
+        settings.setMenuBarMetricPreference(.primary, for: .codex)
+
+        self.enableCodexProvider(settings: settings)
+
+        let (store, controller) = self.makeMenuBarController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 40, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(snapshot, provider: .codex)
+        store._setErrorForTesting(nil, provider: .codex)
+        store.credits = CreditsSnapshot(remaining: 80, events: [], updatedAt: Date())
+
+        let displayText = controller.menuBarDisplayText(for: .codex, snapshot: snapshot)
+
+        #expect(displayText == "100%")
+    }
+
+    @Test
+    func `menu bar percent mode can show codex session and weekly together`() {
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        settings.menuBarDisplayMode = .percent
+        settings.usageBarsShowUsed = false
+        settings.setMenuBarMetricPreference(.primaryAndSecondary, for: .codex)
+
+        self.enableCodexProvider(settings: settings)
+
+        let (store, controller) = self.makeMenuBarController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 7, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 18, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(snapshot, provider: .codex)
+        store._setErrorForTesting(nil, provider: .codex)
+        store.credits = CreditsSnapshot(remaining: 42.5, events: [], updatedAt: Date())
+
+        let displayText = controller.menuBarDisplayText(for: .codex, snapshot: snapshot)
+
+        #expect(displayText == "5h 93% · W 82%")
+    }
+
+    @Test
+    func `menu bar combined codex percent keeps available weekly lane when session is unavailable`() {
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        settings.menuBarDisplayMode = .percent
+        settings.usageBarsShowUsed = false
+        settings.setMenuBarMetricPreference(.primaryAndSecondary, for: .codex)
+
+        self.enableCodexProvider(settings: settings)
+
+        let (store, controller) = self.makeMenuBarController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: RateWindow(usedPercent: 18, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(snapshot, provider: .codex)
+        store._setErrorForTesting(nil, provider: .codex)
+        store.credits = CreditsSnapshot(remaining: 42.5, events: [], updatedAt: Date())
+
+        let displayText = controller.menuBarDisplayText(for: .codex, snapshot: snapshot)
+
+        #expect(displayText == "W 82%")
+    }
+
+    @Test
+    func `menu bar combined codex percent falls back to credits when no percent lanes are available`() {
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        settings.menuBarDisplayMode = .percent
+        settings.usageBarsShowUsed = false
+        settings.setMenuBarMetricPreference(.primaryAndSecondary, for: .codex)
+
+        self.enableCodexProvider(settings: settings)
+
+        let (store, controller) = self.makeMenuBarController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let snapshot = UsageSnapshot(primary: nil, secondary: nil, updatedAt: Date())
+
+        store._setSnapshotForTesting(snapshot, provider: .codex)
+        store._setErrorForTesting(nil, provider: .codex)
+        store.credits = CreditsSnapshot(remaining: 42.5, events: [], updatedAt: Date())
+
+        let displayText = controller.menuBarDisplayText(for: .codex, snapshot: snapshot)
+
+        #expect(displayText == "42.5")
+    }
+
+    @Test
+    func `menu bar combined codex percent keeps credits fallback when a lane is exhausted`() {
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        settings.menuBarDisplayMode = .percent
+        settings.usageBarsShowUsed = false
+        settings.setMenuBarMetricPreference(.primaryAndSecondary, for: .codex)
+
+        self.enableCodexProvider(settings: settings)
+
+        let (store, controller) = self.makeMenuBarController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 100, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 18, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(snapshot, provider: .codex)
+        store._setErrorForTesting(nil, provider: .codex)
+        store.credits = CreditsSnapshot(remaining: 42.5, events: [], updatedAt: Date())
+
+        let displayText = controller.menuBarDisplayText(for: .codex, snapshot: snapshot)
+
+        #expect(displayText == "42.5")
+    }
+
+    @Test
+    func `menu bar combined codex option preserves single metric choices`() {
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        settings.menuBarDisplayMode = .percent
+        settings.usageBarsShowUsed = false
+
+        self.enableCodexProvider(settings: settings)
+
+        let (store, controller) = self.makeMenuBarController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 7, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 18, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(snapshot, provider: .codex)
+        store._setErrorForTesting(nil, provider: .codex)
+
+        settings.setMenuBarMetricPreference(.primary, for: .codex)
+        let primaryText = controller.menuBarDisplayText(for: .codex, snapshot: snapshot)
+
+        settings.setMenuBarMetricPreference(.secondary, for: .codex)
+        let secondaryText = controller.menuBarDisplayText(for: .codex, snapshot: snapshot)
+
+        #expect(primaryText == "93%")
+        #expect(secondaryText == "82%")
+    }
+}
diff --git a/Tests/CodexBarTests/CodexConsumerProjectionTests.swift b/Tests/CodexBarTests/CodexConsumerProjectionTests.swift
new file mode 100644
index 0000000000..ead6233f38
--- /dev/null
+++ b/Tests/CodexBarTests/CodexConsumerProjectionTests.swift
@@ -0,0 +1,241 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@MainActor
+struct CodexConsumerProjectionTests {
+    @Test
+    func `live card projection compacts weekly lanes and attaches dashboard extras`() {
+        let store = self.makeStore(suite: "CodexConsumerProjectionTests-live-card")
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: nil,
+                secondary: RateWindow(
+                    usedPercent: 25,
+                    windowMinutes: 10080,
+                    resetsAt: now.addingTimeInterval(3600),
+                    resetDescription: nil),
+                updatedAt: now),
+            provider: .codex)
+        store.credits = CreditsSnapshot(remaining: 42, events: [], updatedAt: now)
+        store.openAIDashboard = OpenAIDashboardSnapshot(
+            signedInEmail: "codex@example.com",
+            codeReviewRemainingPercent: 88,
+            codeReviewLimit: RateWindow(
+                usedPercent: 12,
+                windowMinutes: nil,
+                resetsAt: now.addingTimeInterval(7200),
+                resetDescription: nil),
+            creditEvents: [],
+            dailyBreakdown: [OpenAIDashboardDailyBreakdown(day: "2024-01-01", services: [], totalCreditsUsed: 3)],
+            usageBreakdown: [OpenAIDashboardDailyBreakdown(day: "2024-01-01", services: [], totalCreditsUsed: 4)],
+            creditsPurchaseURL: "https://chatgpt.com/settings/billing",
+            updatedAt: now)
+        store.openAIDashboardAttachmentAuthorized = true
+        store.openAIDashboardRequiresLogin = false
+
+        let projection = store.codexConsumerProjection(surface: .liveCard, now: now)
+
+        #expect(projection.visibleRateLanes == [.weekly])
+        #expect(projection.planUtilizationLanes.map(\.role.rawValue) == ["weekly"])
+        #expect(projection.dashboardVisibility == .attached)
+        #expect(projection.supplementalMetrics == [.codeReview])
+        #expect(projection.remainingPercent(for: .codeReview) == 88)
+        #expect(projection.credits?.remaining == 42)
+        #expect(projection.canShowBuyCredits)
+        #expect(projection.hasUsageBreakdown)
+        #expect(projection.hasCreditsHistory)
+    }
+
+    @Test
+    func `display only dashboard stays visible without attached extras`() {
+        let store = self.makeStore(suite: "CodexConsumerProjectionTests-display-only")
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 15,
+                    windowMinutes: 300,
+                    resetsAt: now.addingTimeInterval(1800),
+                    resetDescription: nil),
+                secondary: RateWindow(
+                    usedPercent: 30,
+                    windowMinutes: 10080,
+                    resetsAt: now.addingTimeInterval(3600),
+                    resetDescription: nil),
+                updatedAt: now),
+            provider: .codex)
+        store.openAIDashboard = OpenAIDashboardSnapshot(
+            signedInEmail: "codex@example.com",
+            codeReviewRemainingPercent: 66,
+            creditEvents: [],
+            dailyBreakdown: [OpenAIDashboardDailyBreakdown(day: "2024-01-01", services: [], totalCreditsUsed: 3)],
+            usageBreakdown: [OpenAIDashboardDailyBreakdown(day: "2024-01-01", services: [], totalCreditsUsed: 4)],
+            creditsPurchaseURL: "https://chatgpt.com/settings/billing",
+            updatedAt: now)
+        store.openAIDashboardAttachmentAuthorized = false
+        store.openAIDashboardRequiresLogin = false
+
+        let projection = store.codexConsumerProjection(surface: .liveCard, now: now)
+
+        #expect(projection.dashboardVisibility == .displayOnly)
+        #expect(projection.supplementalMetrics.isEmpty)
+        #expect(projection.canShowBuyCredits)
+        #expect(!projection.hasUsageBreakdown)
+        #expect(!projection.hasCreditsHistory)
+    }
+
+    @Test
+    func `override card projection does not pull live codex adjuncts`() {
+        let store = self.makeStore(suite: "CodexConsumerProjectionTests-override")
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 18,
+                    windowMinutes: 300,
+                    resetsAt: now.addingTimeInterval(1800),
+                    resetDescription: nil),
+                secondary: nil,
+                updatedAt: now),
+            provider: .codex)
+        store.credits = CreditsSnapshot(remaining: 42, events: [], updatedAt: now)
+        store.lastCreditsError = "Frame load interrupted"
+        store.openAIDashboard = OpenAIDashboardSnapshot(
+            signedInEmail: "codex@example.com",
+            codeReviewRemainingPercent: 88,
+            creditEvents: [],
+            dailyBreakdown: [OpenAIDashboardDailyBreakdown(day: "2024-01-01", services: [], totalCreditsUsed: 3)],
+            usageBreakdown: [OpenAIDashboardDailyBreakdown(day: "2024-01-01", services: [], totalCreditsUsed: 4)],
+            creditsPurchaseURL: "https://chatgpt.com/settings/billing",
+            updatedAt: now)
+        store.openAIDashboardAttachmentAuthorized = true
+        store.openAIDashboardRequiresLogin = false
+        store._setErrorForTesting("Live codex error", provider: .codex)
+
+        let overrideSnapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 55,
+                windowMinutes: 300,
+                resetsAt: now.addingTimeInterval(1200),
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: now)
+
+        let projection = store.codexConsumerProjection(
+            surface: .overrideCard,
+            snapshotOverride: overrideSnapshot,
+            errorOverride: "Override error",
+            now: now)
+
+        #expect(projection.visibleRateLanes == [.session])
+        #expect(projection.dashboardVisibility == .hidden)
+        #expect(projection.credits == nil)
+        #expect(projection.supplementalMetrics.isEmpty)
+        #expect(!projection.canShowBuyCredits)
+        #expect(!projection.hasUsageBreakdown)
+        #expect(!projection.hasCreditsHistory)
+        #expect(projection.userFacingErrors.usage == "Override error")
+        #expect(projection.userFacingErrors.credits == nil)
+        #expect(projection.userFacingErrors.dashboard == nil)
+    }
+
+    @Test
+    func `menu bar projection flags credits fallback on exhaustion`() {
+        let store = self.makeStore(suite: "CodexConsumerProjectionTests-menu-bar")
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 100,
+                    windowMinutes: 300,
+                    resetsAt: now.addingTimeInterval(1800),
+                    resetDescription: nil),
+                secondary: RateWindow(
+                    usedPercent: 40,
+                    windowMinutes: 10080,
+                    resetsAt: now.addingTimeInterval(3600),
+                    resetDescription: nil),
+                updatedAt: now),
+            provider: .codex)
+        store.credits = CreditsSnapshot(remaining: 80, events: [], updatedAt: now)
+
+        let projection = store.codexConsumerProjection(surface: .menuBar, now: now)
+
+        #expect(projection.menuBarFallback == .creditsBalance)
+    }
+
+    @Test
+    func `live card projection keeps buy credits available without dashboard purchase URL`() {
+        let store = self.makeStore(suite: "CodexConsumerProjectionTests-buy-credits")
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 20,
+                    windowMinutes: 300,
+                    resetsAt: now.addingTimeInterval(1800),
+                    resetDescription: nil),
+                secondary: nil,
+                updatedAt: now),
+            provider: .codex)
+        store.credits = CreditsSnapshot(remaining: 42, events: [], updatedAt: now)
+        store.openAIDashboardAttachmentAuthorized = false
+        store.openAIDashboardRequiresLogin = false
+
+        let projection = store.codexConsumerProjection(surface: .liveCard, now: now)
+
+        #expect(projection.canShowBuyCredits)
+    }
+
+    @Test
+    func `menu bar projection keeps credits fallback when credits load before usage`() {
+        let store = self.makeStore(suite: "CodexConsumerProjectionTests-menu-bar-credits-only")
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+
+        store._setSnapshotForTesting(nil, provider: .codex)
+        store.credits = CreditsSnapshot(remaining: 80, events: [], updatedAt: now)
+
+        let projection = store.codexConsumerProjection(surface: .menuBar, now: now)
+
+        #expect(projection.menuBarFallback == .creditsBalance)
+        #expect(!projection.hasExhaustedRateLane)
+    }
+
+    private func makeStore(suite: String) -> UsageStore {
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore(),
+            codexCookieStore: InMemoryCookieHeaderStore(),
+            claudeCookieStore: InMemoryCookieHeaderStore(),
+            cursorCookieStore: InMemoryCookieHeaderStore(),
+            opencodeCookieStore: InMemoryCookieHeaderStore(),
+            factoryCookieStore: InMemoryCookieHeaderStore(),
+            minimaxCookieStore: InMemoryMiniMaxCookieStore(),
+            minimaxAPITokenStore: InMemoryMiniMaxAPITokenStore(),
+            kimiTokenStore: InMemoryKimiTokenStore(),
+            kimiK2TokenStore: InMemoryKimiK2TokenStore(),
+            augmentCookieStore: InMemoryCookieHeaderStore(),
+            ampCookieStore: InMemoryCookieHeaderStore(),
+            copilotTokenStore: InMemoryCopilotTokenStore(),
+            tokenAccountStore: InMemoryTokenAccountStore())
+
+        return UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+    }
+}
diff --git a/Tests/CodexBarTests/CodexDashboardAuthorityTests.swift b/Tests/CodexBarTests/CodexDashboardAuthorityTests.swift
new file mode 100644
index 0000000000..1c4cff0fdf
--- /dev/null
+++ b/Tests/CodexBarTests/CodexDashboardAuthorityTests.swift
@@ -0,0 +1,475 @@
+import CodexBarCore
+import Testing
+
+struct CodexDashboardAuthorityTests {
+    @Test
+    func `email only wrong email returns fail closed`() {
+        let input = CodexDashboardAuthorityInput(
+            sourceKind: .liveWeb,
+            proof: CodexDashboardOwnershipProofContext(
+                currentIdentity: .emailOnly(normalizedEmail: "owner@example.com"),
+                expectedScopedEmail: nil,
+                trustedCurrentUsageEmail: nil,
+                dashboardSignedInEmail: "other@example.com",
+                knownOwners: [
+                    CodexDashboardKnownOwnerCandidate(
+                        identity: .emailOnly(normalizedEmail: "owner@example.com"),
+                        normalizedEmail: "owner@example.com"),
+                ]),
+            routing: CodexDashboardRoutingHints(
+                targetEmail: "owner@example.com",
+                lastKnownDashboardRoutingEmail: nil))
+
+        let decision = CodexDashboardAuthority.evaluate(input)
+
+        #expect(decision.disposition == .failClosed)
+        #expect(decision.reason == .wrongEmail(expected: "owner@example.com", actual: "other@example.com"))
+    }
+
+    @Test
+    func `provider account wrong email returns fail closed`() {
+        let input = CodexDashboardAuthorityInput(
+            sourceKind: .liveWeb,
+            proof: CodexDashboardOwnershipProofContext(
+                currentIdentity: .providerAccount(id: "acct-owner"),
+                expectedScopedEmail: "owner@example.com",
+                trustedCurrentUsageEmail: nil,
+                dashboardSignedInEmail: "other@example.com",
+                knownOwners: [
+                    CodexDashboardKnownOwnerCandidate(
+                        identity: .providerAccount(id: "acct-owner"),
+                        normalizedEmail: "owner@example.com"),
+                ]),
+            routing: CodexDashboardRoutingHints(
+                targetEmail: "owner@example.com",
+                lastKnownDashboardRoutingEmail: "stale@example.com"))
+
+        let decision = CodexDashboardAuthority.evaluate(input)
+
+        #expect(decision.disposition == .failClosed)
+        #expect(decision.reason == .wrongEmail(expected: "owner@example.com", actual: "other@example.com"))
+    }
+
+    @Test
+    func `email only same email ambiguity returns display only`() {
+        let input = CodexDashboardAuthorityInput(
+            sourceKind: .liveWeb,
+            proof: CodexDashboardOwnershipProofContext(
+                currentIdentity: .emailOnly(normalizedEmail: "shared@example.com"),
+                expectedScopedEmail: nil,
+                trustedCurrentUsageEmail: nil,
+                dashboardSignedInEmail: "shared@example.com",
+                knownOwners: [
+                    CodexDashboardKnownOwnerCandidate(
+                        identity: .providerAccount(id: "acct-alpha"),
+                        normalizedEmail: "shared@example.com"),
+                    CodexDashboardKnownOwnerCandidate(
+                        identity: .providerAccount(id: "acct-beta"),
+                        normalizedEmail: "shared@example.com"),
+                ]),
+            routing: CodexDashboardRoutingHints(
+                targetEmail: "shared@example.com",
+                lastKnownDashboardRoutingEmail: "shared@example.com"))
+
+        let decision = CodexDashboardAuthority.evaluate(input)
+
+        #expect(decision.disposition == .displayOnly)
+        #expect(decision.reason == .sameEmailAmbiguity(email: "shared@example.com"))
+    }
+
+    @Test
+    func `provider account exact owner match returns attach`() {
+        let input = CodexDashboardAuthorityInput(
+            sourceKind: .liveWeb,
+            proof: CodexDashboardOwnershipProofContext(
+                currentIdentity: .providerAccount(id: "acct-owner"),
+                expectedScopedEmail: "OWNER@example.com",
+                trustedCurrentUsageEmail: nil,
+                dashboardSignedInEmail: "owner@example.com",
+                knownOwners: [
+                    CodexDashboardKnownOwnerCandidate(
+                        identity: .providerAccount(id: "acct-owner"),
+                        normalizedEmail: "OWNER@example.com"),
+                    CodexDashboardKnownOwnerCandidate(
+                        identity: .providerAccount(id: "acct-other"),
+                        normalizedEmail: "other@example.com"),
+                ]),
+            routing: CodexDashboardRoutingHints(
+                targetEmail: "route@example.com",
+                lastKnownDashboardRoutingEmail: "stale@example.com"))
+
+        let decision = CodexDashboardAuthority.evaluate(input)
+
+        #expect(decision.disposition == .attach)
+        #expect(decision.reason == .exactProviderAccountMatch)
+    }
+
+    @Test
+    func `provider account exact owner ignores duplicate profile isolation`() {
+        let input = CodexDashboardAuthorityInput(
+            sourceKind: .liveWeb,
+            proof: CodexDashboardOwnershipProofContext(
+                currentIdentity: .providerAccount(id: "acct-owner"),
+                expectedScopedEmail: "owner@example.com",
+                trustedCurrentUsageEmail: nil,
+                dashboardSignedInEmail: "owner@example.com",
+                knownOwners: [
+                    CodexDashboardKnownOwnerCandidate(
+                        identity: .providerAccount(id: "acct-owner"),
+                        normalizedEmail: "owner@example.com",
+                        sourceIsolationIdentifier: "profile-a"),
+                    CodexDashboardKnownOwnerCandidate(
+                        identity: .providerAccount(id: "acct-owner"),
+                        normalizedEmail: "owner@example.com",
+                        sourceIsolationIdentifier: "profile-b"),
+                ]),
+            routing: CodexDashboardRoutingHints(
+                targetEmail: "owner@example.com",
+                lastKnownDashboardRoutingEmail: nil))
+
+        let decision = CodexDashboardAuthority.evaluate(input)
+
+        #expect(decision.disposition == .attach)
+        #expect(decision.reason == .exactProviderAccountMatch)
+    }
+
+    @Test
+    func `email only owners retain profile isolation ambiguity`() {
+        let input = CodexDashboardAuthorityInput(
+            sourceKind: .liveWeb,
+            proof: CodexDashboardOwnershipProofContext(
+                currentIdentity: .emailOnly(normalizedEmail: "shared@example.com"),
+                expectedScopedEmail: "shared@example.com",
+                trustedCurrentUsageEmail: nil,
+                dashboardSignedInEmail: "shared@example.com",
+                knownOwners: [
+                    CodexDashboardKnownOwnerCandidate(
+                        identity: .emailOnly(normalizedEmail: "shared@example.com"),
+                        normalizedEmail: "shared@example.com",
+                        sourceIsolationIdentifier: "profile-a"),
+                    CodexDashboardKnownOwnerCandidate(
+                        identity: .emailOnly(normalizedEmail: "shared@example.com"),
+                        normalizedEmail: "shared@example.com",
+                        sourceIsolationIdentifier: "profile-b"),
+                ]),
+            routing: CodexDashboardRoutingHints(
+                targetEmail: "shared@example.com",
+                lastKnownDashboardRoutingEmail: nil))
+
+        let decision = CodexDashboardAuthority.evaluate(input)
+
+        #expect(decision.disposition == .displayOnly)
+        #expect(decision.reason == .sameEmailAmbiguity(email: "shared@example.com"))
+    }
+
+    @Test
+    func `provider account exact owner stays display only when email has another owner`() {
+        let input = CodexDashboardAuthorityInput(
+            sourceKind: .liveWeb,
+            proof: CodexDashboardOwnershipProofContext(
+                currentIdentity: .providerAccount(id: "acct-current"),
+                expectedScopedEmail: "shared@example.com",
+                trustedCurrentUsageEmail: nil,
+                dashboardSignedInEmail: "shared@example.com",
+                knownOwners: [
+                    CodexDashboardKnownOwnerCandidate(
+                        identity: .providerAccount(id: "acct-current"),
+                        normalizedEmail: "shared@example.com"),
+                    CodexDashboardKnownOwnerCandidate(
+                        identity: .providerAccount(id: "acct-other"),
+                        normalizedEmail: "shared@example.com"),
+                ]),
+            routing: CodexDashboardRoutingHints(
+                targetEmail: "shared@example.com",
+                lastKnownDashboardRoutingEmail: nil))
+
+        let decision = CodexDashboardAuthority.evaluate(input)
+
+        #expect(decision.disposition == .displayOnly)
+        #expect(decision.reason == .sameEmailAmbiguity(email: "shared@example.com"))
+    }
+
+    @Test
+    func `provider account same email ambiguity without exact match returns display only`() {
+        let input = CodexDashboardAuthorityInput(
+            sourceKind: .liveWeb,
+            proof: CodexDashboardOwnershipProofContext(
+                currentIdentity: .providerAccount(id: "acct-current"),
+                expectedScopedEmail: "shared@example.com",
+                trustedCurrentUsageEmail: nil,
+                dashboardSignedInEmail: "shared@example.com",
+                knownOwners: [
+                    CodexDashboardKnownOwnerCandidate(
+                        identity: .providerAccount(id: "acct-alpha"),
+                        normalizedEmail: "shared@example.com"),
+                    CodexDashboardKnownOwnerCandidate(
+                        identity: .providerAccount(id: "acct-beta"),
+                        normalizedEmail: "shared@example.com"),
+                ]),
+            routing: CodexDashboardRoutingHints(
+                targetEmail: "shared@example.com",
+                lastKnownDashboardRoutingEmail: nil))
+
+        let decision = CodexDashboardAuthority.evaluate(input)
+
+        #expect(decision.disposition == .displayOnly)
+        #expect(decision.reason == .sameEmailAmbiguity(email: "shared@example.com"))
+    }
+
+    @Test
+    func `provider account nil scoped email with dashboard collision returns fail closed`() {
+        let input = CodexDashboardAuthorityInput(
+            sourceKind: .liveWeb,
+            proof: CodexDashboardOwnershipProofContext(
+                currentIdentity: .providerAccount(id: "acct-current"),
+                expectedScopedEmail: nil,
+                trustedCurrentUsageEmail: "shared@example.com",
+                dashboardSignedInEmail: "shared@example.com",
+                knownOwners: [
+                    CodexDashboardKnownOwnerCandidate(
+                        identity: .providerAccount(id: "acct-alpha"),
+                        normalizedEmail: "shared@example.com"),
+                    CodexDashboardKnownOwnerCandidate(
+                        identity: .providerAccount(id: "acct-beta"),
+                        normalizedEmail: "shared@example.com"),
+                ]),
+            routing: CodexDashboardRoutingHints(
+                targetEmail: "shared@example.com",
+                lastKnownDashboardRoutingEmail: nil))
+
+        let decision = CodexDashboardAuthority.evaluate(input)
+
+        #expect(decision.disposition == .failClosed)
+        #expect(decision.reason == .providerAccountMissingScopedEmail)
+    }
+
+    @Test
+    func `unresolved trusted continuity without competing owner returns attach`() {
+        let input = CodexDashboardAuthorityInput(
+            sourceKind: .liveWeb,
+            proof: CodexDashboardOwnershipProofContext(
+                currentIdentity: .unresolved,
+                expectedScopedEmail: nil,
+                trustedCurrentUsageEmail: "owner@example.com",
+                dashboardSignedInEmail: "owner@example.com",
+                knownOwners: [
+                    CodexDashboardKnownOwnerCandidate(
+                        identity: .providerAccount(id: "acct-owner"),
+                        normalizedEmail: "owner@example.com"),
+                ]),
+            routing: CodexDashboardRoutingHints(
+                targetEmail: "owner@example.com",
+                lastKnownDashboardRoutingEmail: "route@example.com"))
+
+        let decision = CodexDashboardAuthority.evaluate(input)
+
+        #expect(decision.disposition == .attach)
+        #expect(decision.reason == .trustedContinuityNoCompetingOwner)
+    }
+
+    @Test
+    func `unresolved trusted continuity with competing owner returns display only`() {
+        let input = CodexDashboardAuthorityInput(
+            sourceKind: .liveWeb,
+            proof: CodexDashboardOwnershipProofContext(
+                currentIdentity: .unresolved,
+                expectedScopedEmail: nil,
+                trustedCurrentUsageEmail: "shared@example.com",
+                dashboardSignedInEmail: "shared@example.com",
+                knownOwners: [
+                    CodexDashboardKnownOwnerCandidate(
+                        identity: .providerAccount(id: "acct-alpha"),
+                        normalizedEmail: "shared@example.com"),
+                    CodexDashboardKnownOwnerCandidate(
+                        identity: .providerAccount(id: "acct-beta"),
+                        normalizedEmail: "shared@example.com"),
+                ]),
+            routing: CodexDashboardRoutingHints(
+                targetEmail: "shared@example.com",
+                lastKnownDashboardRoutingEmail: "route@example.com"))
+
+        let decision = CodexDashboardAuthority.evaluate(input)
+
+        #expect(decision.disposition == .displayOnly)
+        #expect(decision.reason == .sameEmailAmbiguity(email: "shared@example.com"))
+    }
+
+    @Test
+    func `unresolved without trusted evidence returns fail closed`() {
+        let input = CodexDashboardAuthorityInput(
+            sourceKind: .liveWeb,
+            proof: CodexDashboardOwnershipProofContext(
+                currentIdentity: .unresolved,
+                expectedScopedEmail: nil,
+                trustedCurrentUsageEmail: nil,
+                dashboardSignedInEmail: "owner@example.com",
+                knownOwners: []),
+            routing: CodexDashboardRoutingHints(
+                targetEmail: "owner@example.com",
+                lastKnownDashboardRoutingEmail: nil))
+
+        let decision = CodexDashboardAuthority.evaluate(input)
+
+        #expect(decision.disposition == .failClosed)
+        #expect(decision.reason == .unresolvedWithoutTrustedEvidence)
+    }
+
+    @Test
+    func `missing dashboard signed in email returns fail closed`() {
+        let input = CodexDashboardAuthorityInput(
+            sourceKind: .liveWeb,
+            proof: CodexDashboardOwnershipProofContext(
+                currentIdentity: .providerAccount(id: "acct-owner"),
+                expectedScopedEmail: "owner@example.com",
+                trustedCurrentUsageEmail: "owner@example.com",
+                dashboardSignedInEmail: nil,
+                knownOwners: [
+                    CodexDashboardKnownOwnerCandidate(
+                        identity: .providerAccount(id: "acct-owner"),
+                        normalizedEmail: "owner@example.com"),
+                ]),
+            routing: CodexDashboardRoutingHints(
+                targetEmail: "owner@example.com",
+                lastKnownDashboardRoutingEmail: nil))
+
+        let decision = CodexDashboardAuthority.evaluate(input)
+
+        #expect(decision.disposition == .failClosed)
+        #expect(decision.reason == .missingDashboardSignedInEmail)
+    }
+
+    @Test
+    func `live web attach exposes usage credits guard and history effects`() {
+        let input = CodexDashboardAuthorityInput(
+            sourceKind: .liveWeb,
+            proof: CodexDashboardOwnershipProofContext(
+                currentIdentity: .providerAccount(id: "acct-owner"),
+                expectedScopedEmail: "owner@example.com",
+                trustedCurrentUsageEmail: nil,
+                dashboardSignedInEmail: "owner@example.com",
+                knownOwners: [
+                    CodexDashboardKnownOwnerCandidate(
+                        identity: .providerAccount(id: "acct-owner"),
+                        normalizedEmail: "owner@example.com"),
+                ]),
+            routing: CodexDashboardRoutingHints(
+                targetEmail: nil,
+                lastKnownDashboardRoutingEmail: nil))
+
+        let decision = CodexDashboardAuthority.evaluate(input)
+
+        #expect(decision.disposition == .attach)
+        #expect(decision.allowedEffects == Set([
+            .usageBackfill,
+            .creditsAttachment,
+            .refreshGuardSeed,
+            .historicalBackfill,
+        ]))
+        #expect(decision.cleanup.isEmpty)
+    }
+
+    @Test
+    func `cached dashboard attach exposes cached reuse only`() {
+        let input = CodexDashboardAuthorityInput(
+            sourceKind: .cachedDashboard,
+            proof: CodexDashboardOwnershipProofContext(
+                currentIdentity: .emailOnly(normalizedEmail: "owner@example.com"),
+                expectedScopedEmail: nil,
+                trustedCurrentUsageEmail: nil,
+                dashboardSignedInEmail: "owner@example.com",
+                knownOwners: [
+                    CodexDashboardKnownOwnerCandidate(
+                        identity: .providerAccount(id: "acct-owner"),
+                        normalizedEmail: "owner@example.com"),
+                ]),
+            routing: CodexDashboardRoutingHints(
+                targetEmail: "owner@example.com",
+                lastKnownDashboardRoutingEmail: nil))
+
+        let decision = CodexDashboardAuthority.evaluate(input)
+
+        #expect(decision.disposition == .attach)
+        #expect(decision.allowedEffects == Set([.cachedDashboardReuse]))
+        #expect(decision.cleanup.isEmpty)
+    }
+
+    @Test
+    func `display only emits full cleanup set`() {
+        let input = CodexDashboardAuthorityInput(
+            sourceKind: .liveWeb,
+            proof: CodexDashboardOwnershipProofContext(
+                currentIdentity: .emailOnly(normalizedEmail: "shared@example.com"),
+                expectedScopedEmail: nil,
+                trustedCurrentUsageEmail: nil,
+                dashboardSignedInEmail: "shared@example.com",
+                knownOwners: [
+                    CodexDashboardKnownOwnerCandidate(
+                        identity: .providerAccount(id: "acct-alpha"),
+                        normalizedEmail: "shared@example.com"),
+                    CodexDashboardKnownOwnerCandidate(
+                        identity: .providerAccount(id: "acct-beta"),
+                        normalizedEmail: "shared@example.com"),
+                ]),
+            routing: CodexDashboardRoutingHints(
+                targetEmail: nil,
+                lastKnownDashboardRoutingEmail: nil))
+
+        let decision = CodexDashboardAuthority.evaluate(input)
+
+        #expect(decision.disposition == .displayOnly)
+        #expect(decision.allowedEffects.isEmpty)
+        #expect(decision.cleanup == Set(CodexDashboardCleanup.allCases))
+    }
+
+    @Test
+    func `fail closed emits full cleanup set`() {
+        let input = CodexDashboardAuthorityInput(
+            sourceKind: .liveWeb,
+            proof: CodexDashboardOwnershipProofContext(
+                currentIdentity: .unresolved,
+                expectedScopedEmail: nil,
+                trustedCurrentUsageEmail: nil,
+                dashboardSignedInEmail: "owner@example.com",
+                knownOwners: []),
+            routing: CodexDashboardRoutingHints(
+                targetEmail: nil,
+                lastKnownDashboardRoutingEmail: nil))
+
+        let decision = CodexDashboardAuthority.evaluate(input)
+
+        #expect(decision.disposition == .failClosed)
+        #expect(decision.allowedEffects.isEmpty)
+        #expect(decision.cleanup == Set(CodexDashboardCleanup.allCases))
+    }
+
+    @Test
+    func `routing hints do not change evaluation result`() {
+        let proof = CodexDashboardOwnershipProofContext(
+            currentIdentity: .providerAccount(id: "acct-owner"),
+            expectedScopedEmail: "owner@example.com",
+            trustedCurrentUsageEmail: nil,
+            dashboardSignedInEmail: "owner@example.com",
+            knownOwners: [
+                CodexDashboardKnownOwnerCandidate(
+                    identity: .providerAccount(id: "acct-owner"),
+                    normalizedEmail: "owner@example.com"),
+            ])
+        let baseInput = CodexDashboardAuthorityInput(
+            sourceKind: .liveWeb,
+            proof: proof,
+            routing: CodexDashboardRoutingHints(
+                targetEmail: "owner@example.com",
+                lastKnownDashboardRoutingEmail: "owner@example.com"))
+        let conflictingRoutingInput = CodexDashboardAuthorityInput(
+            sourceKind: .liveWeb,
+            proof: proof,
+            routing: CodexDashboardRoutingHints(
+                targetEmail: "wrong@example.com",
+                lastKnownDashboardRoutingEmail: "stale@example.com"))
+
+        let baseDecision = CodexDashboardAuthority.evaluate(baseInput)
+        let conflictingDecision = CodexDashboardAuthority.evaluate(conflictingRoutingInput)
+
+        #expect(baseDecision == conflictingDecision)
+    }
+}
diff --git a/Tests/CodexBarTests/CodexDashboardWorkedExampleParityTests.swift b/Tests/CodexBarTests/CodexDashboardWorkedExampleParityTests.swift
new file mode 100644
index 0000000000..aceb561c39
--- /dev/null
+++ b/Tests/CodexBarTests/CodexDashboardWorkedExampleParityTests.swift
@@ -0,0 +1,596 @@
+import Foundation
+import Testing
+@testable import CodexBar
+@testable import CodexBarCLI
+@testable import CodexBarCore
+
+@Suite(.serialized)
+@MainActor
+struct CodexDashboardWorkedExampleParityTests {
+    @Test
+    func `worked example A wrong email app and CLI both reject and retire owned state`() async throws {
+        try await self.withIsolatedDashboardCache {
+            OpenAIDashboardCacheStore.clear()
+            defer { OpenAIDashboardCacheStore.clear() }
+
+            let store = self.makeAppStore(suite: "CodexDashboardWorkedExampleParityTests-example-a")
+            store.settings._test_liveSystemCodexAccount = self.liveAccount(
+                email: "work@company.com",
+                identity: .emailOnly(normalizedEmail: "work@company.com"))
+            store.settings.codexActiveSource = .liveSystem
+
+            let attachedDashboard = self.makeDashboard(
+                email: "work@company.com",
+                creditsRemaining: 42,
+                usedPercent: 20)
+            let attachedCredits = self.credits(remaining: 42)
+            store._setSnapshotForTesting(
+                self.codexSnapshot(email: "work@company.com", usedPercent: 20),
+                provider: .codex)
+            store.lastSourceLabels[.codex] = "openai-web"
+            store.credits = attachedCredits
+            store.lastCreditsSnapshot = attachedCredits
+            store.lastCreditsSnapshotAccountKey = "work@company.com"
+            store.lastCreditsSource = .dashboardWeb
+            store.openAIDashboard = attachedDashboard
+            store.lastOpenAIDashboardSnapshot = attachedDashboard
+            store.lastOpenAIDashboardTargetEmail = "work@company.com"
+            OpenAIDashboardCacheStore.save(OpenAIDashboardCache(
+                accountEmail: "work@company.com",
+                snapshot: attachedDashboard))
+
+            await store.applyOpenAIDashboard(
+                self.makeDashboard(
+                    email: "personal@gmail.com",
+                    creditsRemaining: 9,
+                    usedPercent: 35),
+                targetEmail: "work@company.com")
+
+            #expect(store.openAIDashboard == nil)
+            #expect(store.lastOpenAIDashboardSnapshot == nil)
+            #expect(store.snapshots[.codex] == nil)
+            #expect(store.credits == nil)
+            #expect(store.lastCreditsSource == .none)
+            #expect(OpenAIDashboardCacheStore.load() == nil)
+            #expect(store.openAIDashboardRequiresLogin == true)
+
+            let authHome = try self.makeAuthHome(
+                email: "work@company.com",
+                accountId: "acct-work")
+            defer { try? FileManager.default.removeItem(at: authHome) }
+            let cliContext = self.makeCLIContext(
+                authHome: authHome,
+                knownOwners: [
+                    CodexDashboardKnownOwnerCandidate(
+                        identity: .providerAccount(id: "acct-work"),
+                        normalizedEmail: "work@company.com"),
+                ])
+            let wrongEmailDashboard = self.makeDashboard(
+                email: "personal@gmail.com",
+                creditsRemaining: 9,
+                usedPercent: 35)
+
+            do {
+                _ = try CodexWebDashboardStrategy.makeAuthorizedDashboardResultForTesting(
+                    dashboard: wrongEmailDashboard,
+                    context: cliContext,
+                    routingTargetEmail: "work@company.com")
+                Issue.record("Expected OpenAIWebCodexError.policyRejected")
+            } catch let error as OpenAIWebCodexError {
+                if case let .policyRejected(decision) = error {
+                    #expect(decision.reason == .wrongEmail(expected: "work@company.com", actual: "personal@gmail.com"))
+                } else {
+                    Issue.record("Expected policyRejected, got \(error)")
+                }
+            } catch {
+                Issue.record("Expected OpenAIWebCodexError.policyRejected, got \(error)")
+            }
+
+            OpenAIDashboardCacheStore.save(OpenAIDashboardCache(
+                accountEmail: "personal@gmail.com",
+                snapshot: wrongEmailDashboard))
+
+            let restored = CodexBarCLI.loadOpenAIDashboardIfAvailable(
+                usage: self.makeUsage(email: "work@company.com"),
+                sourceLabel: "codex-cli",
+                context: cliContext)
+
+            #expect(restored == nil)
+            #expect(OpenAIDashboardCacheStore.load() == nil)
+        }
+    }
+
+    @Test
+    func `worked example B same email ambiguity is display only in app and non attach in CLI`() async throws {
+        try await self.withIsolatedDashboardCache {
+            OpenAIDashboardCacheStore.clear()
+            defer { OpenAIDashboardCacheStore.clear() }
+
+            let managedHome = try self.makeAuthHome(
+                email: "work@company.com",
+                accountId: "acct-managed")
+            defer { try? FileManager.default.removeItem(at: managedHome) }
+            let managedAccount = ManagedCodexAccount(
+                id: UUID(),
+                email: "work@company.com",
+                managedHomePath: managedHome.path,
+                createdAt: 1,
+                updatedAt: 1,
+                lastAuthenticatedAt: 1)
+            let managedStoreURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+            defer { try? FileManager.default.removeItem(at: managedStoreURL) }
+
+            let store = self.makeAppStore(suite: "CodexDashboardWorkedExampleParityTests-example-b")
+            store.settings._test_managedCodexAccountStoreURL = managedStoreURL
+            store.settings._test_liveSystemCodexAccount = self.liveAccount(
+                email: "work@company.com",
+                identity: .emailOnly(normalizedEmail: "work@company.com"))
+            store.settings.codexActiveSource = .liveSystem
+
+            await store.applyOpenAIDashboard(
+                self.makeDashboard(
+                    email: "work@company.com",
+                    creditsRemaining: 14,
+                    usedPercent: 30,
+                    includeUsageBreakdown: true),
+                targetEmail: "work@company.com")
+            try await Task.sleep(for: .milliseconds(250))
+
+            #expect(store.openAIDashboard?.signedInEmail == "work@company.com")
+            #expect(store.snapshots[.codex] == nil)
+            #expect(store.credits == nil)
+            #expect(OpenAIDashboardCacheStore.load() == nil)
+            #expect(store.codexHistoricalDataset == nil)
+
+            let cliAuthHome = try self.makeAuthHome(email: "work@company.com")
+            defer { try? FileManager.default.removeItem(at: cliAuthHome) }
+            let ambiguousOwners = [
+                CodexDashboardKnownOwnerCandidate(
+                    identity: .providerAccount(id: "acct-alpha"),
+                    normalizedEmail: "work@company.com"),
+                CodexDashboardKnownOwnerCandidate(
+                    identity: .providerAccount(id: "acct-beta"),
+                    normalizedEmail: "work@company.com"),
+            ]
+            let cliContext = self.makeCLIContext(
+                authHome: cliAuthHome,
+                knownOwners: ambiguousOwners)
+            let dashboard = self.makeDashboard(
+                email: "work@company.com",
+                creditsRemaining: 14,
+                usedPercent: 30,
+                includeUsageBreakdown: true)
+            let expectedDecision = CodexDashboardAuthority.evaluate(
+                CodexCLIDashboardAuthorityContext.makeLiveWebInput(
+                    dashboard: dashboard,
+                    context: cliContext,
+                    routingTargetEmail: "work@company.com"))
+
+            do {
+                _ = try CodexWebDashboardStrategy.makeAuthorizedDashboardResultForTesting(
+                    dashboard: dashboard,
+                    context: cliContext,
+                    routingTargetEmail: "work@company.com")
+                Issue.record("Expected CodexDashboardPolicyError.displayOnly")
+            } catch let error as CodexDashboardPolicyError {
+                #expect(error == .displayOnly(expectedDecision))
+            } catch {
+                Issue.record("Expected CodexDashboardPolicyError.displayOnly, got \(error)")
+            }
+
+            OpenAIDashboardCacheStore.save(OpenAIDashboardCache(
+                accountEmail: "work@company.com",
+                snapshot: dashboard))
+
+            let restored = CodexBarCLI.loadOpenAIDashboardIfAvailable(
+                usage: self.makeUsage(email: "work@company.com"),
+                sourceLabel: "codex-cli",
+                context: cliContext)
+
+            #expect(restored == nil)
+            #expect(OpenAIDashboardCacheStore.load() == nil)
+        }
+    }
+
+    @Test
+    func `worked example C unresolved but proven continuity attaches in app and CLI`() async {
+        await self.withIsolatedDashboardCache {
+            OpenAIDashboardCacheStore.clear()
+            defer { OpenAIDashboardCacheStore.clear() }
+
+            let emptyHome = self.makeEmptyHome()
+            defer { try? FileManager.default.removeItem(at: emptyHome) }
+
+            let store = self.makeAppStore(suite: "CodexDashboardWorkedExampleParityTests-example-c")
+            store.settings._test_codexReconciliationEnvironment = ["CODEX_HOME": emptyHome.path]
+            store.settings._test_liveSystemCodexAccount = nil
+            store.settings.codexActiveSource = .liveSystem
+            store._setSnapshotForTesting(
+                self.codexSnapshot(email: "work@company.com", usedPercent: 12),
+                provider: .codex)
+            store.lastSourceLabels[.codex] = "codex-cli"
+
+            let dashboard = self.makeDashboard(
+                email: "work@company.com",
+                creditsRemaining: 33,
+                usedPercent: 12)
+            let appAuthority = store.evaluateCodexDashboardAuthority(
+                dashboard: dashboard,
+                sourceKind: .liveWeb,
+                routingTargetEmail: "work@company.com")
+
+            await store.applyOpenAIDashboard(dashboard, targetEmail: "work@company.com")
+
+            #expect(store.openAIDashboard?.signedInEmail == "work@company.com")
+            #expect(store.credits?.remaining == 33)
+            #expect(store.lastCreditsSource == .dashboardWeb)
+            #expect(store.lastCodexAccountScopedRefreshGuard?.accountKey == "work@company.com")
+            #expect(store.openAIDashboardRequiresLogin == false)
+            #expect(store.lastOpenAIDashboardError == nil)
+
+            let cliContext = self.makeCLIContext(authHome: emptyHome, knownOwners: [])
+            OpenAIDashboardCacheStore.save(OpenAIDashboardCache(
+                accountEmail: "stale-route@example.com",
+                snapshot: dashboard))
+
+            let restored = CodexBarCLI.loadOpenAIDashboardIfAvailable(
+                usage: self.makeUsage(email: "work@company.com"),
+                sourceLabel: "codex-cli",
+                context: cliContext)
+            let cliInput = CodexCLIDashboardAuthorityContext.makeCachedDashboardInput(
+                dashboard: dashboard,
+                cachedAccountEmail: "stale-route@example.com",
+                usage: self.makeUsage(email: "work@company.com"),
+                sourceLabel: "codex-cli",
+                context: cliContext)
+            let cliDecision = CodexDashboardAuthority.evaluate(cliInput)
+
+            #expect(restored == dashboard)
+            #expect(appAuthority.decision.disposition == .attach)
+            #expect(cliDecision.disposition == .attach)
+            #expect(appAuthority.decision.reason == .trustedContinuityNoCompetingOwner)
+            #expect(cliDecision.reason == .trustedContinuityNoCompetingOwner)
+        }
+    }
+
+    @Test
+    func `worked example D prior attach downgrades to ambiguity and retires old owned state`() async throws {
+        try await self.withIsolatedDashboardCache {
+            OpenAIDashboardCacheStore.clear()
+            defer { OpenAIDashboardCacheStore.clear() }
+
+            let store = self.makeAppStore(suite: "CodexDashboardWorkedExampleParityTests-example-d")
+            store.settings._test_liveSystemCodexAccount = self.liveAccount(
+                email: "shared@example.com",
+                identity: .emailOnly(normalizedEmail: "shared@example.com"))
+            store.settings.codexActiveSource = .liveSystem
+
+            let initialDashboard = self.makeDashboard(
+                email: "shared@example.com",
+                creditsRemaining: 21,
+                usedPercent: 18)
+            await store.applyOpenAIDashboard(initialDashboard, targetEmail: "shared@example.com")
+
+            #expect(store.openAIDashboard?.signedInEmail == "shared@example.com")
+            #expect(store.snapshots[.codex]?.accountEmail(for: .codex) == "shared@example.com")
+            #expect(store.credits?.remaining == 21)
+            #expect(store.lastSourceLabels[.codex] == "openai-web")
+            #expect(OpenAIDashboardCacheStore.load()?.accountEmail == "shared@example.com")
+
+            let managedHome = try self.makeAuthHome(
+                email: "shared@example.com",
+                accountId: "acct-managed")
+            defer { try? FileManager.default.removeItem(at: managedHome) }
+            let managedAccount = ManagedCodexAccount(
+                id: UUID(),
+                email: "shared@example.com",
+                managedHomePath: managedHome.path,
+                createdAt: 1,
+                updatedAt: 1,
+                lastAuthenticatedAt: 1)
+            let managedStoreURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+            defer { try? FileManager.default.removeItem(at: managedStoreURL) }
+            store.settings._test_managedCodexAccountStoreURL = managedStoreURL
+
+            await store.applyOpenAIDashboard(
+                self.makeDashboard(
+                    email: "shared@example.com",
+                    creditsRemaining: 9,
+                    usedPercent: 35,
+                    includeUsageBreakdown: true),
+                targetEmail: "shared@example.com")
+
+            #expect(store.openAIDashboard?.signedInEmail == "shared@example.com")
+            #expect(store.lastOpenAIDashboardSnapshot?.signedInEmail == "shared@example.com")
+            #expect(store.snapshots[.codex] == nil)
+            #expect(store.credits == nil)
+            #expect(store.lastCreditsSource == .none)
+            #expect(OpenAIDashboardCacheStore.load() == nil)
+
+            OpenAIDashboardCacheStore.clear()
+            let cliAuthHome = try self.makeAuthHome(email: "shared@example.com")
+            defer { try? FileManager.default.removeItem(at: cliAuthHome) }
+            let attachableContext = self.makeCLIContext(
+                authHome: cliAuthHome,
+                knownOwners: [
+                    CodexDashboardKnownOwnerCandidate(
+                        identity: .providerAccount(id: "acct-alpha"),
+                        normalizedEmail: "shared@example.com"),
+                ])
+            OpenAIDashboardCacheStore.save(OpenAIDashboardCache(
+                accountEmail: "shared@example.com",
+                snapshot: initialDashboard))
+
+            let initiallyRestored = CodexBarCLI.loadOpenAIDashboardIfAvailable(
+                usage: self.makeUsage(email: "shared@example.com"),
+                sourceLabel: "codex-cli",
+                context: attachableContext)
+            #expect(initiallyRestored == initialDashboard)
+
+            let ambiguousContext = self.makeCLIContext(
+                authHome: cliAuthHome,
+                knownOwners: [
+                    CodexDashboardKnownOwnerCandidate(
+                        identity: .providerAccount(id: "acct-alpha"),
+                        normalizedEmail: "shared@example.com"),
+                    CodexDashboardKnownOwnerCandidate(
+                        identity: .providerAccount(id: "acct-beta"),
+                        normalizedEmail: "shared@example.com"),
+                ])
+
+            let downgradedRestored = CodexBarCLI.loadOpenAIDashboardIfAvailable(
+                usage: self.makeUsage(email: "shared@example.com"),
+                sourceLabel: "codex-cli",
+                context: ambiguousContext)
+
+            #expect(downgradedRestored == nil)
+            #expect(OpenAIDashboardCacheStore.load() == nil)
+        }
+    }
+
+    private func withIsolatedDashboardCache<T>(
+        _ operation: () async throws -> T) async rethrows -> T
+    {
+        let cacheURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-dashboard-\(UUID().uuidString).json")
+        defer { try? FileManager.default.removeItem(at: cacheURL) }
+        return try await OpenAIDashboardCacheStore.$cacheURLOverride.withValue(cacheURL) {
+            try await operation()
+        }
+    }
+
+    private func makeDashboard(
+        email: String,
+        creditsRemaining: Double,
+        usedPercent: Double,
+        includeUsageBreakdown: Bool = false) -> OpenAIDashboardSnapshot
+    {
+        let updatedAt = Date(timeIntervalSince1970: 2000)
+        let creditEvents = [
+            CreditEvent(
+                date: Date(timeIntervalSince1970: 1000),
+                service: "codex",
+                creditsUsed: 3),
+        ]
+        let usageBreakdown = includeUsageBreakdown
+            ? self.makeUsageBreakdown(endingAt: updatedAt, days: 35, dailyCredits: 10)
+            : []
+        return OpenAIDashboardSnapshot(
+            signedInEmail: email,
+            codeReviewRemainingPercent: 75,
+            codeReviewLimit: RateWindow(
+                usedPercent: 25,
+                windowMinutes: 60,
+                resetsAt: Date(timeIntervalSince1970: 3600),
+                resetDescription: nil),
+            creditEvents: creditEvents,
+            dailyBreakdown: OpenAIDashboardSnapshot.makeDailyBreakdown(from: creditEvents, maxDays: 30),
+            usageBreakdown: usageBreakdown,
+            creditsPurchaseURL: nil,
+            primaryLimit: RateWindow(
+                usedPercent: usedPercent,
+                windowMinutes: 300,
+                resetsAt: Date(timeIntervalSince1970: 7200),
+                resetDescription: nil),
+            secondaryLimit: includeUsageBreakdown
+                ? RateWindow(
+                    usedPercent: usedPercent,
+                    windowMinutes: 10080,
+                    resetsAt: updatedAt.addingTimeInterval(2 * 24 * 60 * 60),
+                    resetDescription: nil)
+                : nil,
+            creditsRemaining: creditsRemaining,
+            accountPlan: "pro",
+            updatedAt: updatedAt)
+    }
+
+    private func makeAppStore(suite: String) -> UsageStore {
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings._test_activeManagedCodexAccount = nil
+        settings._test_activeManagedCodexRemoteHomePath = nil
+        settings._test_unreadableManagedCodexAccountStore = false
+        settings._test_managedCodexAccountStoreURL = nil
+        settings._test_liveSystemCodexAccount = nil
+        settings._test_codexReconciliationEnvironment = nil
+        settings.historicalTrackingEnabled = true
+        let historyURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString)
+            .appendingPathComponent("usage-history.jsonl")
+        let planStore = testPlanUtilizationHistoryStore(
+            suiteName: "CodexDashboardWorkedExampleParityTests-\(UUID().uuidString)")
+        return UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            historicalUsageHistoryStore: HistoricalUsageHistoryStore(fileURL: historyURL),
+            planUtilizationHistoryStore: planStore)
+    }
+
+    private func makeCLIContext(
+        authHome: URL?,
+        knownOwners: [CodexDashboardKnownOwnerCandidate]) -> ProviderFetchContext
+    {
+        let env = authHome.map { ["CODEX_HOME": $0.path] } ?? [:]
+        let browserDetection = BrowserDetection(cacheTTL: 0)
+        return ProviderFetchContext(
+            runtime: .cli,
+            sourceMode: .auto,
+            includeCredits: true,
+            webTimeout: 60,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: env,
+            settings: ProviderSettingsSnapshot.make(
+                codex: .init(
+                    usageDataSource: .auto,
+                    cookieSource: .auto,
+                    manualCookieHeader: nil,
+                    dashboardAuthorityKnownOwners: knownOwners)),
+            fetcher: UsageFetcher(environment: env),
+            claudeFetcher: ClaudeUsageFetcher(browserDetection: browserDetection),
+            browserDetection: browserDetection)
+    }
+
+    private func makeAuthHome(email: String?, accountId: String? = nil) throws -> URL {
+        let homeURL = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        try self.writeCodexAuthFile(homeURL: homeURL, email: email, accountId: accountId)
+        return homeURL
+    }
+
+    private func makeEmptyHome() -> URL {
+        let homeURL = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        try? FileManager.default.createDirectory(at: homeURL, withIntermediateDirectories: true)
+        return homeURL
+    }
+
+    private func writeCodexAuthFile(
+        homeURL: URL,
+        email: String?,
+        accountId: String?) throws
+    {
+        try FileManager.default.createDirectory(at: homeURL, withIntermediateDirectories: true)
+        var tokens: [String: Any] = [
+            "accessToken": "access-token",
+            "refreshToken": "refresh-token",
+            "idToken": Self.fakeJWT(email: email, accountId: accountId),
+        ]
+        if let accountId {
+            tokens["accountId"] = accountId
+        }
+        let auth = ["tokens": tokens]
+        let data = try JSONSerialization.data(withJSONObject: auth)
+        try data.write(to: homeURL.appendingPathComponent("auth.json"))
+    }
+
+    private static func fakeJWT(email: String?, accountId: String?) -> String {
+        let header = (try? JSONSerialization.data(withJSONObject: ["alg": "none"])) ?? Data()
+        var authClaims: [String: Any] = [
+            "chatgpt_plan_type": "pro",
+        ]
+        if let accountId {
+            authClaims["chatgpt_account_id"] = accountId
+        }
+        var claims: [String: Any] = [
+            "chatgpt_plan_type": "pro",
+            "https://api.openai.com/auth": authClaims,
+        ]
+        if let email {
+            claims["email"] = email
+        }
+        let payload = (try? JSONSerialization.data(withJSONObject: claims)) ?? Data()
+
+        func base64URL(_ data: Data) -> String {
+            data.base64EncodedString()
+                .replacingOccurrences(of: "=", with: "")
+                .replacingOccurrences(of: "+", with: "-")
+                .replacingOccurrences(of: "/", with: "_")
+        }
+
+        return "\(base64URL(header)).\(base64URL(payload))."
+    }
+
+    private func makeManagedAccountStoreURL(accounts: [ManagedCodexAccount]) throws -> URL {
+        let storeURL = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        let store = FileManagedCodexAccountStore(fileURL: storeURL)
+        try store.storeAccounts(ManagedCodexAccountSet(
+            version: FileManagedCodexAccountStore.currentVersion,
+            accounts: accounts))
+        return storeURL
+    }
+
+    private func liveAccount(email: String, identity: CodexIdentity = .unresolved) -> ObservedSystemCodexAccount {
+        ObservedSystemCodexAccount(
+            email: email,
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: identity)
+    }
+
+    private func codexSnapshot(email: String, usedPercent: Double) -> UsageSnapshot {
+        UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: usedPercent,
+                windowMinutes: 300,
+                resetsAt: nil,
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date(timeIntervalSince1970: 2000),
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: email,
+                accountOrganization: nil,
+                loginMethod: "Pro"))
+    }
+
+    private func credits(remaining: Double) -> CreditsSnapshot {
+        CreditsSnapshot(remaining: remaining, events: [], updatedAt: Date(timeIntervalSince1970: 2000))
+    }
+
+    private func makeUsage(email: String?) -> UsageSnapshot {
+        UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 10,
+                windowMinutes: 300,
+                resetsAt: Date(timeIntervalSince1970: 7200),
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date(timeIntervalSince1970: 2000),
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: email,
+                accountOrganization: nil,
+                loginMethod: nil))
+    }
+
+    private func makeUsageBreakdown(
+        endingAt endDate: Date,
+        days: Int,
+        dailyCredits: Double) -> [OpenAIDashboardDailyBreakdown]
+    {
+        let formatter = DateFormatter()
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        formatter.timeZone = .current
+        formatter.dateFormat = "yyyy-MM-dd"
+        let calendar = Calendar(identifier: .gregorian)
+        let endDay = calendar.startOfDay(for: endDate)
+        return (0..<days).compactMap { offset in
+            guard let date = calendar.date(byAdding: .day, value: -offset, to: endDay) else { return nil }
+            return OpenAIDashboardDailyBreakdown(
+                day: formatter.string(from: date),
+                services: [
+                    OpenAIDashboardServiceUsage(service: "CLI", creditsUsed: dailyCredits),
+                ],
+                totalCreditsUsed: dailyCredits)
+        }
+    }
+}
diff --git a/Tests/CodexBarTests/CodexHistoryOwnershipTests.swift b/Tests/CodexBarTests/CodexHistoryOwnershipTests.swift
new file mode 100644
index 0000000000..dbe002e1ad
--- /dev/null
+++ b/Tests/CodexBarTests/CodexHistoryOwnershipTests.swift
@@ -0,0 +1,110 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct CodexHistoryOwnershipTests {
+    private let normalizedEmail = "user@example.com"
+    private let legacyEmailHash = "b4c9a289323b21a01c3e940f150eb9b8c542587f1abfd8f0e1cc1ffc5e475514"
+
+    @Test
+    func `serializes canonical provider-account key`() {
+        let key = CodexHistoryOwnership.canonicalKey(for: .providerAccount(id: "acct-123"))
+
+        #expect(key == "codex:v1:provider-account:acct-123")
+    }
+
+    @Test
+    func `serializes canonical email-hash key`() {
+        let key = CodexHistoryOwnership.canonicalKey(for: .emailOnly(normalizedEmail: self.normalizedEmail))
+
+        #expect(key == "codex:v1:email-hash:\(self.legacyEmailHash)")
+    }
+
+    @Test
+    func `unresolved identity has no canonical key`() {
+        let key = CodexHistoryOwnership.canonicalKey(for: .unresolved)
+
+        #expect(key == nil)
+    }
+
+    @Test
+    func `classifies canonical and legacy persisted keys`() {
+        let canonical = "codex:v1:provider-account:acct-123"
+        let legacy = CodexHistoryOwnership.classifyPersistedKey(
+            self.legacyEmailHash,
+            legacyEmailHash: self.legacyEmailHash)
+        let opaque = CodexHistoryOwnership.classifyPersistedKey(
+            "92a40b0d62f5f4f1b3dbd3f9ecb6c7700dd540d2d866e59d1c110f6b4d7f1abc",
+            legacyEmailHash: self.legacyEmailHash)
+
+        #expect(CodexHistoryOwnership.classifyPersistedKey(nil) == .legacyUnscoped)
+        #expect(CodexHistoryOwnership.classifyPersistedKey("") == .legacyUnscoped)
+        #expect(CodexHistoryOwnership.classifyPersistedKey(canonical) == .canonical(canonical))
+        #expect(legacy == .legacyEmailHash(self.legacyEmailHash))
+        #expect(opaque == .legacyOpaqueScoped("92a40b0d62f5f4f1b3dbd3f9ecb6c7700dd540d2d866e59d1c110f6b4d7f1abc"))
+    }
+
+    @Test
+    func `strict continuity passes for a single aliased email-hash owner`() {
+        let canonicalEmailHashKey = "codex:v1:email-hash:\(self.legacyEmailHash)"
+
+        let result = CodexHistoryOwnership.hasStrictSingleAccountContinuity(
+            scopedRawKeys: [self.legacyEmailHash],
+            targetCanonicalKey: canonicalEmailHashKey,
+            canonicalEmailHashKey: canonicalEmailHashKey,
+            legacyEmailHash: self.legacyEmailHash,
+            hasAdjacentMultiAccountVeto: false)
+
+        #expect(result)
+    }
+
+    @Test
+    func `strict continuity fails with ambiguous owners`() {
+        let canonicalEmailHashKey = "codex:v1:email-hash:\(self.legacyEmailHash)"
+
+        let result = CodexHistoryOwnership.hasStrictSingleAccountContinuity(
+            scopedRawKeys: [
+                canonicalEmailHashKey,
+                "codex:v1:provider-account:acct-123",
+            ],
+            targetCanonicalKey: canonicalEmailHashKey,
+            canonicalEmailHashKey: canonicalEmailHashKey,
+            legacyEmailHash: self.legacyEmailHash,
+            hasAdjacentMultiAccountVeto: false)
+
+        #expect(!result)
+    }
+
+    @Test
+    func `strict continuity fails when adjacent persisted evidence vetoes migration`() {
+        let canonicalEmailHashKey = "codex:v1:email-hash:\(self.legacyEmailHash)"
+
+        let result = CodexHistoryOwnership.hasStrictSingleAccountContinuity(
+            scopedRawKeys: [canonicalEmailHashKey],
+            targetCanonicalKey: canonicalEmailHashKey,
+            canonicalEmailHashKey: canonicalEmailHashKey,
+            legacyEmailHash: self.legacyEmailHash,
+            hasAdjacentMultiAccountVeto: true)
+
+        #expect(!result)
+    }
+
+    @Test
+    func `provider-account target inherits email continuity`() {
+        let providerAccountKey = "codex:v1:provider-account:acct-123"
+        let canonicalEmailHashKey = "codex:v1:email-hash:\(self.legacyEmailHash)"
+
+        let legacyMatchesProvider = CodexHistoryOwnership.belongsToTargetContinuity(
+            .legacyEmailHash(self.legacyEmailHash),
+            targetCanonicalKey: providerAccountKey,
+            canonicalEmailHashKey: canonicalEmailHashKey)
+        let canonicalMatchesProvider = CodexHistoryOwnership.belongsToTargetContinuity(
+            .canonical(canonicalEmailHashKey),
+            targetCanonicalKey: providerAccountKey,
+            canonicalEmailHashKey: canonicalEmailHashKey)
+
+        #expect(legacyMatchesProvider)
+        #expect(canonicalMatchesProvider)
+    }
+}
diff --git a/Tests/CodexBarTests/CodexIdentityResolverTests.swift b/Tests/CodexBarTests/CodexIdentityResolverTests.swift
new file mode 100644
index 0000000000..fc44f8f397
--- /dev/null
+++ b/Tests/CodexBarTests/CodexIdentityResolverTests.swift
@@ -0,0 +1,43 @@
+import CodexBarCore
+import Testing
+
+struct CodexIdentityResolverTests {
+    @Test
+    func `resolver prefers provider account over email`() {
+        let identity = CodexIdentityResolver.resolve(
+            accountId: "account-123",
+            email: "Person@example.com")
+
+        #expect(identity == .providerAccount(id: "account-123"))
+    }
+
+    @Test
+    func `resolver falls back to normalized email when provider account missing`() {
+        let identity = CodexIdentityResolver.resolve(
+            accountId: nil,
+            email: " Person@example.com ")
+
+        #expect(identity == .emailOnly(normalizedEmail: "person@example.com"))
+    }
+
+    @Test
+    func `resolver returns unresolved when account data missing`() {
+        let identity = CodexIdentityResolver.resolve(accountId: nil, email: nil)
+
+        #expect(identity == .unresolved)
+    }
+
+    @Test
+    func `provider account does not equal email fallback even when email matches`() {
+        let providerAccount = CodexIdentityResolver.resolve(
+            accountId: "account-123",
+            email: "person@example.com")
+        let emailOnly = CodexIdentityResolver.resolve(
+            accountId: nil,
+            email: "person@example.com")
+
+        #expect(providerAccount == .providerAccount(id: "account-123"))
+        #expect(emailOnly == .emailOnly(normalizedEmail: "person@example.com"))
+        #expect(providerAccount != emailOnly)
+    }
+}
diff --git a/Tests/CodexBarTests/CodexLoginRunnerTests.swift b/Tests/CodexBarTests/CodexLoginRunnerTests.swift
new file mode 100644
index 0000000000..d5c59dfa8f
--- /dev/null
+++ b/Tests/CodexBarTests/CodexLoginRunnerTests.swift
@@ -0,0 +1,88 @@
+import Darwin
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct CodexLoginRunnerTests {
+    @Test
+    func `login runner returns timeout before hung codex exits`() async throws {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-login-runner-\(UUID().uuidString)", isDirectory: true)
+        let binDir = root.appendingPathComponent("bin", isDirectory: true)
+        let homeDir = root.appendingPathComponent("home", isDirectory: true)
+        try FileManager.default.createDirectory(at: binDir, withIntermediateDirectories: true)
+        try FileManager.default.createDirectory(at: homeDir, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let codex = binDir.appendingPathComponent("codex")
+        let script = """
+        #!/usr/bin/python3
+        import time
+
+        print("login-started", flush=True)
+        time.sleep(5)
+        print("login-finished", flush=True)
+        """
+        try script.write(to: codex, atomically: true, encoding: .utf8)
+        try FileManager.default.setAttributes([.posixPermissions: 0o755], ofItemAtPath: codex.path)
+
+        let start = Date()
+        let result = await CodexLoginRunner.run(
+            homePath: homeDir.path,
+            timeout: 0.2,
+            environment: ["PATH": binDir.path],
+            loginPATH: nil)
+        let elapsed = Date().timeIntervalSince(start)
+
+        #expect(result.outcome == .timedOut)
+        #expect(result.output.contains("login-finished") == false)
+        #expect(elapsed < 2.0, "Timeout should return promptly, took \(elapsed)s")
+    }
+
+    @Test
+    func `login runner bounds output drain when detached child keeps pipes open`() async throws {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-login-drain-\(UUID().uuidString)", isDirectory: true)
+        let binDir = root.appendingPathComponent("bin", isDirectory: true)
+        let homeDir = root.appendingPathComponent("home", isDirectory: true)
+        let childPIDFile = root.appendingPathComponent("child.pid")
+        try FileManager.default.createDirectory(at: binDir, withIntermediateDirectories: true)
+        try FileManager.default.createDirectory(at: homeDir, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+        defer {
+            if let text = try? String(contentsOf: childPIDFile, encoding: .utf8),
+               let childPID = pid_t(text.trimmingCharacters(in: .whitespacesAndNewlines))
+            {
+                _ = kill(childPID, SIGKILL)
+            }
+        }
+
+        let codex = binDir.appendingPathComponent("codex")
+        let script = """
+        #!/bin/sh
+        /bin/sh -c 'trap "" TERM; /bin/sleep 5' &
+        child_pid=$!
+        printf '%s\\n' "$child_pid" > "$CODEXBAR_TEST_CHILD_PID_FILE"
+        printf 'login-started\\n'
+        /bin/sleep 5
+        """
+        try script.write(to: codex, atomically: true, encoding: .utf8)
+        try FileManager.default.setAttributes([.posixPermissions: 0o755], ofItemAtPath: codex.path)
+
+        let start = Date()
+        let result = await CodexLoginRunner.run(
+            homePath: homeDir.path,
+            timeout: 1,
+            outputDrainTimeout: 0.2,
+            environment: [
+                "CODEXBAR_TEST_CHILD_PID_FILE": childPIDFile.path,
+                "PATH": binDir.path,
+            ],
+            loginPATH: nil)
+        let elapsed = Date().timeIntervalSince(start)
+
+        #expect(result.outcome == .timedOut)
+        #expect(result.output.contains("login-started"))
+        #expect(elapsed < 3.0, "Output drain should stay bounded, took \(elapsed)s")
+    }
+}
diff --git a/Tests/CodexBarTests/CodexManagedOpenAIWebRefreshTests.swift b/Tests/CodexBarTests/CodexManagedOpenAIWebRefreshTests.swift
new file mode 100644
index 0000000000..a5ed210fca
--- /dev/null
+++ b/Tests/CodexBarTests/CodexManagedOpenAIWebRefreshTests.swift
@@ -0,0 +1,880 @@
+import Foundation
+import Testing
+@testable import CodexBar
+@testable import CodexBarCore
+
+@Suite(.serialized)
+@MainActor
+struct CodexManagedOpenAIWebRefreshTests {
+    @Test
+    func `regular refresh does not await OpenAI web scrape`() async throws {
+        let settings = try self
+            .makeSettingsStore(suite: "CodexManagedOpenAIWebRefreshTests-regular-refresh-nonblocking")
+        settings.statusChecksEnabled = false
+        if let codexMeta = ProviderRegistry.shared.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+        let managedHomeURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        try? Self.writeCodexAuthFile(
+            homeURL: managedHomeURL,
+            email: "managed@example.com",
+            plan: "Pro")
+        defer { try? FileManager.default.removeItem(at: managedHomeURL) }
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: managedHomeURL.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+        settings.openAIWebAccessEnabled = false
+        defer { settings._test_activeManagedCodexAccount = nil }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        let blocker = BlockingManagedOpenAIDashboardLoader()
+        let completion = RefreshCompletionProbe()
+        store._test_providerRefreshOverride = { _ in }
+        defer { store._test_providerRefreshOverride = nil }
+        store._test_codexCreditsLoaderOverride = {
+            CreditsSnapshot(remaining: 25, events: [], updatedAt: Date())
+        }
+        defer { store._test_codexCreditsLoaderOverride = nil }
+
+        await store.refresh(forceTokenUsage: false)
+        settings.openAIWebAccessEnabled = true
+
+        store._test_openAIDashboardLoaderOverride = { _, _, _, _ in
+            try await blocker.awaitResult()
+        }
+        defer { store._test_openAIDashboardLoaderOverride = nil }
+        store._test_openAIDashboardCookieImportOverride = { targetEmail, _, _, _, _ in
+            OpenAIDashboardBrowserCookieImporter.ImportResult(
+                sourceLabel: "Chrome",
+                cookieCount: 2,
+                signedInEmail: targetEmail,
+                matchesCodexEmail: true)
+        }
+        defer { store._test_openAIDashboardCookieImportOverride = nil }
+
+        let refreshTask = Task {
+            await store.refresh(forceTokenUsage: false)
+            await completion.markCompleted()
+        }
+
+        let didStart = await blocker.waitUntilStartedWithin(count: 1, timeout: .seconds(60))
+        #expect(didStart == true)
+        if !didStart {
+            refreshTask.cancel()
+            return
+        }
+
+        let completed = await completion.waitUntilCompleted(timeout: .seconds(2))
+        #expect(completed == true)
+        if !completed {
+            refreshTask.cancel()
+            await blocker.resumeNext(with: .failure(ManagedDashboardTestError.networkTimeout))
+            return
+        }
+        await refreshTask.value
+
+        let backgroundTask = try #require(store.openAIDashboardBackgroundRefreshTask)
+        #expect(await blocker.startedCount() == 1)
+
+        await blocker.resumeNext(with: .success(OpenAIDashboardSnapshot(
+            signedInEmail: managedAccount.email,
+            codeReviewRemainingPercent: 95,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            creditsRemaining: 25,
+            accountPlan: "Pro",
+            updatedAt: Date())))
+
+        await backgroundTask.value
+    }
+
+    @Test
+    func `regular refresh does not await Codex credits fetch`() async throws {
+        let settings = try self.makeSettingsStore(
+            suite: "CodexManagedOpenAIWebRefreshTests-regular-refresh-nonblocking-credits")
+        settings.statusChecksEnabled = false
+        settings.openAIWebAccessEnabled = false
+        if let codexMeta = ProviderRegistry.shared.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+        let managedHomeURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        try? Self.writeCodexAuthFile(
+            homeURL: managedHomeURL,
+            email: "managed@example.com",
+            plan: "Pro")
+        defer { try? FileManager.default.removeItem(at: managedHomeURL) }
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: managedHomeURL.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+        defer { settings._test_activeManagedCodexAccount = nil }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        let blocker = BlockingCreditsLoader()
+        let completion = RefreshCompletionProbe()
+        store._test_providerRefreshOverride = { _ in }
+        defer { store._test_providerRefreshOverride = nil }
+        store._test_codexCreditsLoaderOverride = {
+            try await blocker.awaitResult()
+        }
+        defer { store._test_codexCreditsLoaderOverride = nil }
+
+        let refreshTask = Task {
+            await store.refresh(forceTokenUsage: false)
+            await completion.markCompleted()
+        }
+
+        await blocker.waitUntilStarted(count: 1)
+
+        #expect(await blocker.startedCount() == 1)
+        #expect(await completion.isCompleted == true)
+
+        await blocker.resumeNext(with: .success(CreditsSnapshot(remaining: 25, events: [], updatedAt: Date())))
+
+        await refreshTask.value
+    }
+
+    @Test
+    func `background credits refresh persists updated widget snapshot after refresh returns`() async throws {
+        let settings = try self.makeSettingsStore(
+            suite: "CodexManagedOpenAIWebRefreshTests-widget-background-credits")
+        settings.statusChecksEnabled = false
+        settings.openAIWebAccessEnabled = false
+        if let codexMeta = ProviderRegistry.shared.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+        let managedHomeURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        try? Self.writeCodexAuthFile(
+            homeURL: managedHomeURL,
+            email: "managed@example.com",
+            plan: "Pro")
+        defer { try? FileManager.default.removeItem(at: managedHomeURL) }
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: managedHomeURL.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+        defer { settings._test_activeManagedCodexAccount = nil }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        store.snapshots[.codex] = Self.codexSnapshot(email: managedAccount.email, usedPercent: 18)
+
+        let creditsBlocker = BlockingCreditsLoader()
+        let saver = BlockingWidgetSnapshotSaver()
+        store._test_providerRefreshOverride = { _ in }
+        defer { store._test_providerRefreshOverride = nil }
+        store._test_codexCreditsLoaderOverride = {
+            try await creditsBlocker.awaitResult()
+        }
+        defer { store._test_codexCreditsLoaderOverride = nil }
+        store._test_widgetSnapshotSaveOverride = { snapshot in
+            await saver.save(snapshot)
+        }
+        defer { store._test_widgetSnapshotSaveOverride = nil }
+
+        let refreshTask = Task {
+            await store.refresh(forceTokenUsage: false)
+        }
+
+        await refreshTask.value
+        await saver.waitUntilStarted(count: 1)
+
+        let firstSnapshots = await saver.savedSnapshots()
+        let firstCodexEntry = try #require(firstSnapshots.first?.entries.first { $0.provider == .codex })
+        #expect(firstCodexEntry.creditsRemaining == nil)
+
+        await saver.resumeNext()
+        let backgroundTask = try #require(store.creditsRefreshTask)
+        await creditsBlocker.waitUntilStarted(count: 1)
+        await creditsBlocker.resumeNext(with: .success(CreditsSnapshot(remaining: 25, events: [], updatedAt: Date())))
+        await backgroundTask.value
+        await saver.waitUntilStarted(count: 2)
+
+        #expect(await saver.startedCount() == 2)
+        let secondSnapshots = await saver.savedSnapshots()
+        let secondCodexEntry = try #require(secondSnapshots.last?.entries.first { $0.provider == .codex })
+        #expect(secondCodexEntry.creditsRemaining == 25)
+
+        await saver.resumeNext()
+        await store.widgetSnapshotPersistTask?.value
+    }
+
+    @Test
+    func `background dashboard refresh persists updated widget snapshot after refresh returns`() async throws {
+        let settings = try self.makeSettingsStore(
+            suite: "CodexManagedOpenAIWebRefreshTests-widget-background-dashboard")
+        settings.statusChecksEnabled = false
+        if let codexMeta = ProviderRegistry.shared.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+        let managedHomeURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        try? Self.writeCodexAuthFile(
+            homeURL: managedHomeURL,
+            email: "managed@example.com",
+            plan: "Pro")
+        defer { try? FileManager.default.removeItem(at: managedHomeURL) }
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: managedHomeURL.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+        settings.openAIWebAccessEnabled = false
+        defer { settings._test_activeManagedCodexAccount = nil }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+
+        let dashboardBlocker = BlockingManagedOpenAIDashboardLoader()
+        let saver = RecordingWidgetSnapshotSaver()
+        store._test_providerRefreshOverride = { _ in }
+        defer { store._test_providerRefreshOverride = nil }
+        store._test_codexCreditsLoaderOverride = {
+            CreditsSnapshot(remaining: 25, events: [], updatedAt: Date())
+        }
+        defer { store._test_codexCreditsLoaderOverride = nil }
+
+        await store.refresh(forceTokenUsage: false)
+        await store.widgetSnapshotPersistTask?.value
+        settings.openAIWebAccessEnabled = true
+        store.snapshots[.codex] = Self.codexSnapshot(email: managedAccount.email, usedPercent: 18)
+        store.creditsRefreshTask = Task {}
+        store.creditsRefreshTaskKey = store.codexCreditsRefreshKey(
+            expectedGuard: store.currentCodexAccountScopedRefreshGuard())
+
+        store._test_openAIDashboardLoaderOverride = { _, _, _, _ in
+            try await dashboardBlocker.awaitResult()
+        }
+        defer { store._test_openAIDashboardLoaderOverride = nil }
+        store._test_widgetSnapshotSaveOverride = { snapshot in
+            await saver.save(snapshot)
+        }
+        defer { store._test_widgetSnapshotSaveOverride = nil }
+
+        let refreshTask = Task {
+            await store.refresh(forceTokenUsage: false)
+        }
+
+        await refreshTask.value
+        let didPersistInitialRefreshSnapshot = await saver.waitUntilSavedWithin(count: 1)
+        #expect(didPersistInitialRefreshSnapshot)
+
+        let firstSnapshots = await saver.savedSnapshots()
+        #expect(firstSnapshots.first?.entries.first { $0.provider == .codex }?.codeReviewRemainingPercent == nil)
+
+        let backgroundTask = try #require(store.openAIDashboardBackgroundRefreshTask)
+        let didStartDashboardRefresh = await dashboardBlocker.waitUntilStartedWithin(count: 1)
+        #expect(didStartDashboardRefresh)
+        if didStartDashboardRefresh {
+            await dashboardBlocker.resumeNext(with: .success(OpenAIDashboardSnapshot(
+                signedInEmail: managedAccount.email,
+                codeReviewRemainingPercent: 95,
+                creditEvents: [],
+                dailyBreakdown: [],
+                usageBreakdown: [],
+                creditsPurchaseURL: nil,
+                creditsRemaining: 25,
+                accountPlan: "Pro",
+                updatedAt: Date())))
+            await backgroundTask.value
+        }
+        let didPersistDashboardSnapshot = await saver.waitUntilSavedWithin(count: 2)
+
+        #expect(didPersistDashboardSnapshot)
+        let secondSnapshots = await saver.savedSnapshots()
+        #expect(secondSnapshots.count >= 2)
+    }
+
+    @Test
+    func `manual cookie import bypasses same account refresh coalescing`() async throws {
+        let settings = try self.makeSettingsStore(
+            suite: "CodexManagedOpenAIWebRefreshTests-manual-import-bypass-coalesce")
+        let managedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-managed-openai-web-refresh-\(UUID().uuidString)", isDirectory: true)
+        try Self.writeCodexAuthFile(
+            homeURL: managedHome,
+            email: "managed@example.com",
+            plan: "Pro")
+        defer { try? FileManager.default.removeItem(at: managedHome) }
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+        defer { settings._test_activeManagedCodexAccount = nil }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        let blocker = BlockingManagedOpenAIDashboardLoader()
+        store._test_openAIDashboardLoaderOverride = { _, _, _, _ in
+            try await blocker.awaitResult()
+        }
+        defer { store._test_openAIDashboardLoaderOverride = nil }
+        store._test_openAIDashboardCookieImportOverride = { targetEmail, _, _, _, _ in
+            OpenAIDashboardBrowserCookieImporter.ImportResult(
+                sourceLabel: "Chrome",
+                cookieCount: 2,
+                signedInEmail: targetEmail,
+                matchesCodexEmail: true)
+        }
+        defer { store._test_openAIDashboardCookieImportOverride = nil }
+
+        let expectedGuard = store.currentCodexOpenAIWebRefreshGuard()
+        let firstTask = Task {
+            await store.refreshOpenAIDashboardIfNeeded(force: true, expectedGuard: expectedGuard)
+        }
+        await blocker.waitUntilStarted(count: 1)
+
+        let manualImportTask = Task {
+            await store.importOpenAIDashboardBrowserCookiesNow()
+        }
+        await blocker.waitUntilStarted(count: 2)
+
+        await blocker.resumeNext(with: .success(OpenAIDashboardSnapshot(
+            signedInEmail: managedAccount.email,
+            codeReviewRemainingPercent: 70,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            creditsRemaining: 1,
+            accountPlan: "Free",
+            updatedAt: Date())))
+        await blocker.resumeNext(with: .success(OpenAIDashboardSnapshot(
+            signedInEmail: managedAccount.email,
+            codeReviewRemainingPercent: 95,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            creditsRemaining: 25,
+            accountPlan: "Pro",
+            updatedAt: Date())))
+
+        await firstTask.value
+        await manualImportTask.value
+
+        #expect(await blocker.startedCount() == 2)
+        #expect(store.openAIDashboard?.creditsRemaining == 25)
+        #expect(store.openAIDashboard?.accountPlan == "Pro")
+    }
+
+    @Test
+    func `stale cookie import status does not override later unrelated refresh failure`() async throws {
+        let settings = try self.makeSettingsStore(suite: "CodexManagedOpenAIWebRefreshTests-stale-cookie-status")
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-codex-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+        defer { settings._test_activeManagedCodexAccount = nil }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        store.openAIDashboardCookieImportStatus =
+            "OpenAI cookies are for other@example.com, not managed@example.com."
+        store._test_openAIDashboardLoaderOverride = { _, _, _, _ in
+            throw ManagedDashboardTestError.networkTimeout
+        }
+        defer { store._test_openAIDashboardLoaderOverride = nil }
+
+        let expectedGuard = store.currentCodexOpenAIWebRefreshGuard()
+        await store.refreshOpenAIDashboardIfNeeded(force: true, expectedGuard: expectedGuard)
+
+        #expect(store.lastOpenAIDashboardError == ManagedDashboardTestError.networkTimeout.localizedDescription)
+    }
+
+    @Test
+    func `navigation timeout imports cookies and retries dashboard refresh`() async throws {
+        let settings = try self.makeSettingsStore(suite: "CodexManagedOpenAIWebRefreshTests-timeout-import-retry")
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-codex-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+        defer { settings._test_activeManagedCodexAccount = nil }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        let blocker = BlockingManagedOpenAIDashboardLoader()
+        let importTracker = OpenAIDashboardImportCallTracker()
+        var allowNavigationTimeoutRetries: [Bool] = []
+        store._test_openAIDashboardLoaderOverride = { _, _, allowNavigationTimeoutRetry, _ in
+            allowNavigationTimeoutRetries.append(allowNavigationTimeoutRetry)
+            return try await blocker.awaitResult()
+        }
+        defer { store._test_openAIDashboardLoaderOverride = nil }
+        store._test_openAIDashboardCookieImportOverride = { targetEmail, _, _, _, _ in
+            _ = await importTracker.recordCall()
+            return OpenAIDashboardBrowserCookieImporter.ImportResult(
+                sourceLabel: "Chrome",
+                cookieCount: 2,
+                signedInEmail: targetEmail,
+                matchesCodexEmail: true)
+        }
+        defer { store._test_openAIDashboardCookieImportOverride = nil }
+
+        let expectedGuard = store.currentCodexOpenAIWebRefreshGuard()
+        let refreshTask = Task {
+            await store.refreshOpenAIDashboardIfNeeded(force: true, expectedGuard: expectedGuard)
+        }
+        await blocker.waitUntilStarted(count: 1)
+
+        await blocker.resumeNext(with: .failure(URLError(.timedOut)))
+        await importTracker.waitUntilCalls(count: 1)
+        await blocker.waitUntilStarted(count: 2)
+        await blocker.resumeNext(with: .success(OpenAIDashboardSnapshot(
+            signedInEmail: managedAccount.email,
+            codeReviewRemainingPercent: 90,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            creditsRemaining: 25,
+            accountPlan: "Pro",
+            updatedAt: Date())))
+
+        await refreshTask.value
+
+        #expect(await blocker.startedCount() == 2)
+        #expect(allowNavigationTimeoutRetries == [true, true])
+        #expect(store.openAIDashboard?.creditsRemaining == 25)
+        #expect(store.lastOpenAIDashboardError == nil)
+    }
+
+    @Test
+    func `background navigation timeout skips immediate WebKit retry`() async throws {
+        let settings = try self.makeSettingsStore(
+            suite: "CodexManagedOpenAIWebRefreshTests-background-timeout-no-retry")
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-codex-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+        defer { settings._test_activeManagedCodexAccount = nil }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        let blocker = BlockingManagedOpenAIDashboardLoader()
+        let importTracker = OpenAIDashboardImportCallTracker()
+        var allowNavigationTimeoutRetries: [Bool] = []
+        store._test_openAIDashboardLoaderOverride = { _, _, allowNavigationTimeoutRetry, _ in
+            allowNavigationTimeoutRetries.append(allowNavigationTimeoutRetry)
+            return try await blocker.awaitResult()
+        }
+        defer { store._test_openAIDashboardLoaderOverride = nil }
+        store._test_openAIDashboardCookieImportOverride = { targetEmail, _, _, _, _ in
+            _ = await importTracker.recordCall()
+            return OpenAIDashboardBrowserCookieImporter.ImportResult(
+                sourceLabel: "Chrome",
+                cookieCount: 2,
+                signedInEmail: targetEmail,
+                matchesCodexEmail: true)
+        }
+        defer { store._test_openAIDashboardCookieImportOverride = nil }
+
+        let expectedGuard = store.currentCodexOpenAIWebRefreshGuard()
+        let refreshTask = Task {
+            await store.refreshOpenAIDashboardIfNeeded(force: false, expectedGuard: expectedGuard)
+        }
+        await blocker.waitUntilStarted(count: 1)
+
+        await blocker.resumeNext(with: .failure(URLError(.timedOut)))
+        await refreshTask.value
+
+        #expect(await blocker.startedCount() == 1)
+        #expect(allowNavigationTimeoutRetries == [false])
+        #expect(await importTracker.callCount() == 0)
+        #expect(store.openAIDashboard == nil)
+        #expect(store.lastOpenAIDashboardError?.contains("timed out") == true)
+    }
+
+    @Test
+    func `reset open A I web state blocks stale in flight dashboard completion`() async throws {
+        let settings = try self.makeSettingsStore(suite: "CodexManagedOpenAIWebRefreshTests-reset-invalidates-task")
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-codex-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+        defer { settings._test_activeManagedCodexAccount = nil }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        let blocker = BlockingManagedOpenAIDashboardLoader()
+        store._test_openAIDashboardLoaderOverride = { _, _, _, _ in
+            try await blocker.awaitResult()
+        }
+        defer { store._test_openAIDashboardLoaderOverride = nil }
+
+        let expectedGuard = store.currentCodexOpenAIWebRefreshGuard()
+        let refreshTask = Task {
+            await store.refreshOpenAIDashboardIfNeeded(force: true, expectedGuard: expectedGuard)
+        }
+        await blocker.waitUntilStarted()
+
+        store.resetOpenAIWebState()
+        #expect(store.openAIDashboardRefreshTaskToken == nil)
+
+        await blocker.resumeNext(with: .success(OpenAIDashboardSnapshot(
+            signedInEmail: managedAccount.email,
+            codeReviewRemainingPercent: 85,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            creditsRemaining: 12,
+            accountPlan: "Pro",
+            updatedAt: Date())))
+
+        await refreshTask.value
+
+        #expect(store.openAIDashboard == nil)
+        #expect(store.lastOpenAIDashboardError == nil)
+    }
+
+    @Test
+    func `active refresh failure ignores stale import status from older task`() async throws {
+        let settings = try self.makeSettingsStore(suite: "CodexManagedOpenAIWebRefreshTests-concurrent-import-status")
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-codex-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+        defer { settings._test_activeManagedCodexAccount = nil }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        store.openAIDashboardCookieImportStatus =
+            "OpenAI cookies are for other@example.com, not managed@example.com."
+        store._test_openAIDashboardLoaderOverride = { _, _, _, _ in
+            throw ManagedDashboardTestError.networkTimeout
+        }
+        defer { store._test_openAIDashboardLoaderOverride = nil }
+
+        let expectedGuard = store.currentCodexOpenAIWebRefreshGuard()
+        await store.refreshOpenAIDashboardIfNeeded(force: true, expectedGuard: expectedGuard)
+
+        #expect(store.lastOpenAIDashboardError == ManagedDashboardTestError.networkTimeout.localizedDescription)
+    }
+
+    @Test
+    func `post import retry timeout exceeds normal retry timeout`() {
+        #expect(UsageStore.openAIWebDashboardFetchTimeout(didImportCookies: false) == 25)
+        #expect(UsageStore.openAIWebDashboardFetchTimeout(didImportCookies: true) == 25)
+        #expect(UsageStore.openAIWebRetryDashboardFetchTimeout(afterCookieImport: false) == 8)
+        #expect(UsageStore.openAIWebRetryDashboardFetchTimeout(afterCookieImport: true) == 25)
+    }
+
+    private func makeSettingsStore(suite: String) throws -> SettingsStore {
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        defaults.set(true, forKey: "providerDetectionCompleted")
+        let configStore = testConfigStore(suiteName: suite)
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        let codexMetadata = try #require(ProviderDescriptorRegistry.metadata[.codex])
+        settings.setProviderEnabled(provider: .codex, metadata: codexMetadata, enabled: true)
+        settings.providerDetectionCompleted = true
+        settings.openAIWebAccessEnabled = true
+        settings.codexCookieSource = .auto
+        return settings
+    }
+
+    private static func writeCodexAuthFile(homeURL: URL, email: String, plan: String, accountId: String? = nil) throws {
+        try FileManager.default.createDirectory(at: homeURL, withIntermediateDirectories: true)
+        var tokens: [String: Any] = [
+            "accessToken": "access-token",
+            "refreshToken": "refresh-token",
+            "idToken": Self.fakeJWT(email: email, plan: plan, accountId: accountId),
+        ]
+        if let accountId {
+            tokens["accountId"] = accountId
+        }
+        let data = try JSONSerialization.data(withJSONObject: ["tokens": tokens], options: [.sortedKeys])
+        try data.write(to: homeURL.appendingPathComponent("auth.json"))
+    }
+
+    private static func fakeJWT(email: String, plan: String, accountId: String? = nil) -> String {
+        let header = (try? JSONSerialization.data(withJSONObject: ["alg": "none"])) ?? Data()
+        var authClaims: [String: Any] = [
+            "chatgpt_plan_type": plan,
+        ]
+        if let accountId {
+            authClaims["chatgpt_account_id"] = accountId
+        }
+        let payload = (try? JSONSerialization.data(withJSONObject: [
+            "email": email,
+            "chatgpt_plan_type": plan,
+            "https://api.openai.com/auth": authClaims,
+        ])) ?? Data()
+
+        func base64URL(_ data: Data) -> String {
+            data.base64EncodedString()
+                .replacingOccurrences(of: "=", with: "")
+                .replacingOccurrences(of: "+", with: "-")
+                .replacingOccurrences(of: "/", with: "_")
+        }
+
+        return "\(base64URL(header)).\(base64URL(payload))."
+    }
+
+    private static func codexSnapshot(email: String, usedPercent: Double) -> UsageSnapshot {
+        UsageSnapshot(
+            primary: RateWindow(usedPercent: usedPercent, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: email,
+                accountOrganization: nil,
+                loginMethod: "Pro"))
+    }
+}
+
+private enum ManagedDashboardTestError: LocalizedError {
+    case networkTimeout
+
+    var errorDescription: String? {
+        switch self {
+        case .networkTimeout:
+            "Network timeout"
+        }
+    }
+}
+
+actor RefreshCompletionProbe {
+    private(set) var isCompleted = false
+
+    func markCompleted() {
+        self.isCompleted = true
+    }
+
+    func waitUntilCompleted(timeout: Duration = .seconds(5)) async -> Bool {
+        let startedAt = ContinuousClock.now
+        while !self.isCompleted {
+            if startedAt.duration(to: .now) >= timeout {
+                return false
+            }
+            try? await Task.sleep(for: .milliseconds(50))
+        }
+        return true
+    }
+}
+
+actor BlockingManagedOpenAIDashboardLoader {
+    private var continuations: [CheckedContinuation<Result<OpenAIDashboardSnapshot, Error>, Never>] = []
+    private var startWaiters: [(count: Int, continuation: CheckedContinuation<Void, Never>)] = []
+    private var started: Int = 0
+
+    func awaitResult() async throws -> OpenAIDashboardSnapshot {
+        let result = await withCheckedContinuation { continuation in
+            self.continuations.append(continuation)
+            self.started += 1
+            self.resumeReadyStartWaiters()
+        }
+        return try result.get()
+    }
+
+    func waitUntilStarted(count: Int = 1) async {
+        if self.started >= count { return }
+        await withCheckedContinuation { continuation in
+            self.startWaiters.append((count: count, continuation: continuation))
+        }
+    }
+
+    func waitUntilStartedWithin(count: Int = 1, timeout: Duration = .seconds(5)) async -> Bool {
+        let startedAt = ContinuousClock.now
+        while self.started < count {
+            if startedAt.duration(to: .now) >= timeout {
+                return false
+            }
+            try? await Task.sleep(for: .milliseconds(50))
+        }
+        return true
+    }
+
+    func startedCount() -> Int {
+        self.started
+    }
+
+    func resumeNext(with result: Result<OpenAIDashboardSnapshot, Error>) {
+        guard !self.continuations.isEmpty else { return }
+        let continuation = self.continuations.removeFirst()
+        continuation.resume(returning: result)
+    }
+
+    private func resumeReadyStartWaiters() {
+        var remaining: [(count: Int, continuation: CheckedContinuation<Void, Never>)] = []
+        for waiter in self.startWaiters {
+            if self.started >= waiter.count {
+                waiter.continuation.resume()
+            } else {
+                remaining.append(waiter)
+            }
+        }
+        self.startWaiters = remaining
+    }
+}
+
+actor BlockingCreditsLoader {
+    private var continuations: [CheckedContinuation<Result<CreditsSnapshot, Error>, Never>] = []
+    private var startWaiters: [(count: Int, continuation: CheckedContinuation<Void, Never>)] = []
+    private var started = 0
+
+    func awaitResult() async throws -> CreditsSnapshot {
+        let result = await withCheckedContinuation { continuation in
+            self.continuations.append(continuation)
+            self.started += 1
+            self.resumeReadyStartWaiters()
+        }
+        return try result.get()
+    }
+
+    func waitUntilStarted(count: Int = 1) async {
+        if self.started >= count { return }
+        await withCheckedContinuation { continuation in
+            self.startWaiters.append((count: count, continuation: continuation))
+        }
+    }
+
+    func startedCount() -> Int {
+        self.started
+    }
+
+    func resumeNext(with result: Result<CreditsSnapshot, Error>) {
+        guard !self.continuations.isEmpty else { return }
+        let continuation = self.continuations.removeFirst()
+        continuation.resume(returning: result)
+    }
+
+    private func resumeReadyStartWaiters() {
+        var remaining: [(count: Int, continuation: CheckedContinuation<Void, Never>)] = []
+        for waiter in self.startWaiters {
+            if self.started >= waiter.count {
+                waiter.continuation.resume()
+            } else {
+                remaining.append(waiter)
+            }
+        }
+        self.startWaiters = remaining
+    }
+}
+
+private actor OpenAIDashboardImportCallTracker {
+    private var calls: Int = 0
+    private var waiters: [(count: Int, continuation: CheckedContinuation<Void, Never>)] = []
+
+    func recordCall() -> Int {
+        self.calls += 1
+        self.resumeReadyWaiters()
+        return self.calls
+    }
+
+    func waitUntilCalls(count: Int) async {
+        if self.calls >= count { return }
+        await withCheckedContinuation { continuation in
+            self.waiters.append((count: count, continuation: continuation))
+        }
+    }
+
+    func callCount() -> Int {
+        self.calls
+    }
+
+    private func resumeReadyWaiters() {
+        var remaining: [(count: Int, continuation: CheckedContinuation<Void, Never>)] = []
+        for waiter in self.waiters {
+            if self.calls >= waiter.count {
+                waiter.continuation.resume()
+            } else {
+                remaining.append(waiter)
+            }
+        }
+        self.waiters = remaining
+    }
+}
diff --git a/Tests/CodexBarTests/CodexManagedOpenAIWebTestSupport.swift b/Tests/CodexBarTests/CodexManagedOpenAIWebTestSupport.swift
new file mode 100644
index 0000000000..921cce7abc
--- /dev/null
+++ b/Tests/CodexBarTests/CodexManagedOpenAIWebTestSupport.swift
@@ -0,0 +1,207 @@
+import Foundation
+import Testing
+@testable import CodexBar
+@testable import CodexBarCore
+
+extension CodexManagedOpenAIWebTests {
+    @Test
+    func `same account dashboard refresh requests coalesce while one is in flight`() async throws {
+        let settings = self.makeSettingsStore(suite: "CodexManagedOpenAIWebTests-refresh-coalesce")
+        let managedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-openai-web-coalesce-\(UUID().uuidString)", isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: managedHome) }
+        try Self.writeCodexAuthFile(
+            homeURL: managedHome,
+            email: "managed@example.com",
+            plan: "pro",
+            accountId: "acct-managed")
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            providerAccountID: "acct-managed",
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+        defer { settings._test_activeManagedCodexAccount = nil }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        let blocker = CoalescingManagedOpenAIDashboardLoader()
+        store._test_openAIDashboardLoaderOverride = { _, _, _, _ in
+            try await blocker.awaitResult()
+        }
+        defer { store._test_openAIDashboardLoaderOverride = nil }
+
+        let expectedGuard = store.currentCodexOpenAIWebRefreshGuard()
+        let firstTask = Task {
+            await store.refreshOpenAIDashboardIfNeeded(force: true, expectedGuard: expectedGuard)
+        }
+        await blocker.waitUntilStarted()
+
+        let secondTask = Task {
+            await store.refreshOpenAIDashboardIfNeeded(force: true, expectedGuard: expectedGuard)
+        }
+
+        try? await Task.sleep(nanoseconds: 50_000_000)
+        #expect(await blocker.startedCount() == 1)
+
+        await blocker.resume(with: .success(OpenAIDashboardSnapshot(
+            signedInEmail: managedAccount.email,
+            codeReviewRemainingPercent: 90,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            creditsRemaining: 10,
+            accountPlan: "Pro",
+            updatedAt: Date())))
+
+        await firstTask.value
+        await secondTask.value
+
+        #expect(await blocker.startedCount() == 1)
+        #expect(store.openAIDashboard?.signedInEmail == managedAccount.email)
+    }
+
+    @Test
+    func `friendly error shortens cookie mismatch copy`() {
+        let settings = self.makeSettingsStore(suite: "CodexManagedOpenAIWebTests-friendly-error-short")
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+
+        let message = store.openAIDashboardFriendlyError(
+            body: "Sign in to continue",
+            targetEmail: "ratulsarna@gmail.com",
+            cookieImportStatus: "OpenAI cookies are for rdsarna@gmail.com, not ratulsarna@gmail.com.")
+
+        #expect(
+            message ==
+                "OpenAI cookies are for rdsarna@gmail.com, not ratulsarna@gmail.com. " +
+                "Switch chatgpt.com account, then refresh OpenAI cookies.")
+    }
+
+    func makeSettingsStore(suite: String) -> SettingsStore {
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        defaults.set(true, forKey: "providerDetectionCompleted")
+        let configStore = testConfigStore(suiteName: suite)
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings._test_activeManagedCodexAccount = nil
+        settings._test_activeManagedCodexRemoteHomePath = nil
+        settings._test_unreadableManagedCodexAccountStore = false
+        settings._test_managedCodexAccountStoreURL = nil
+        settings._test_liveSystemCodexAccount = nil
+        settings._test_codexReconciliationEnvironment = nil
+        settings.providerDetectionCompleted = true
+        if let codexMetadata = ProviderDescriptorRegistry.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMetadata, enabled: true)
+        }
+        settings.openAIWebAccessEnabled = true
+        settings.codexCookieSource = .auto
+        return settings
+    }
+
+    static func writeCodexAuthFile(
+        homeURL: URL,
+        email: String,
+        plan: String,
+        accountId: String? = nil) throws
+    {
+        try FileManager.default.createDirectory(at: homeURL, withIntermediateDirectories: true)
+        var tokens: [String: Any] = [
+            "accessToken": "access-token",
+            "refreshToken": "refresh-token",
+            "idToken": Self.fakeJWT(email: email, plan: plan, accountId: accountId),
+        ]
+        if let accountId {
+            tokens["accountId"] = accountId
+        }
+        let data = try JSONSerialization.data(withJSONObject: ["tokens": tokens], options: [.sortedKeys])
+        try data.write(to: homeURL.appendingPathComponent("auth.json"))
+    }
+
+    static func fakeJWT(email: String, plan: String, accountId: String? = nil) -> String {
+        let header = (try? JSONSerialization.data(withJSONObject: ["alg": "none"])) ?? Data()
+        var authClaims: [String: Any] = [
+            "chatgpt_plan_type": plan,
+        ]
+        if let accountId {
+            authClaims["chatgpt_account_id"] = accountId
+        }
+        let payload = (try? JSONSerialization.data(withJSONObject: [
+            "email": email,
+            "chatgpt_plan_type": plan,
+            "https://api.openai.com/auth": authClaims,
+        ])) ?? Data()
+
+        func base64URL(_ data: Data) -> String {
+            data.base64EncodedString()
+                .replacingOccurrences(of: "=", with: "")
+                .replacingOccurrences(of: "+", with: "-")
+                .replacingOccurrences(of: "/", with: "_")
+        }
+
+        return "\(base64URL(header)).\(base64URL(payload))."
+    }
+}
+
+actor CoalescingManagedOpenAIDashboardLoader {
+    private var continuations: [CheckedContinuation<Result<OpenAIDashboardSnapshot, Error>, Never>] = []
+    private var startWaiters: [(count: Int, continuation: CheckedContinuation<Void, Never>)] = []
+    private var started: Int = 0
+
+    func awaitResult() async throws -> OpenAIDashboardSnapshot {
+        self.started += 1
+        self.resumeReadyStartWaiters()
+        let result = await withCheckedContinuation { continuation in
+            self.continuations.append(continuation)
+        }
+        return try result.get()
+    }
+
+    func waitUntilStarted(count: Int = 1) async {
+        if self.started >= count { return }
+        await withCheckedContinuation { continuation in
+            self.startWaiters.append((count: count, continuation: continuation))
+        }
+    }
+
+    func startedCount() -> Int {
+        self.started
+    }
+
+    func resume(with result: Result<OpenAIDashboardSnapshot, Error>) {
+        self.resumeNext(with: result)
+    }
+
+    func resumeNext(with result: Result<OpenAIDashboardSnapshot, Error>) {
+        guard !self.continuations.isEmpty else { return }
+        let continuation = self.continuations.removeFirst()
+        continuation.resume(returning: result)
+    }
+
+    private func resumeReadyStartWaiters() {
+        var remaining: [(count: Int, continuation: CheckedContinuation<Void, Never>)] = []
+        for waiter in self.startWaiters {
+            if self.started >= waiter.count {
+                waiter.continuation.resume()
+            } else {
+                remaining.append(waiter)
+            }
+        }
+        self.startWaiters = remaining
+    }
+}
diff --git a/Tests/CodexBarTests/CodexManagedOpenAIWebTests.swift b/Tests/CodexBarTests/CodexManagedOpenAIWebTests.swift
new file mode 100644
index 0000000000..51cd309c14
--- /dev/null
+++ b/Tests/CodexBarTests/CodexManagedOpenAIWebTests.swift
@@ -0,0 +1,881 @@
+import Foundation
+import Testing
+@testable import CodexBar
+@testable import CodexBarCore
+
+@Suite(.serialized)
+@MainActor
+struct CodexManagedOpenAIWebTests {
+    @Test
+    func `managed codex open A I web uses active managed identity and cache scope`() {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+        let settings = self.makeSettingsStore(suite: "CodexManagedOpenAIWebTests-managed")
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-codex-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+        defer { settings._test_activeManagedCodexAccount = nil }
+
+        let otherAccountID = UUID()
+        CookieHeaderCache.store(
+            provider: .codex,
+            scope: .managedAccount(otherAccountID),
+            cookieHeader: "auth=other-account",
+            sourceLabel: "Chrome")
+        CookieHeaderCache.store(
+            provider: .codex,
+            cookieHeader: "auth=provider-global",
+            sourceLabel: "Safari")
+        defer {
+            CookieHeaderCache.clear(provider: .codex, scope: .managedAccount(otherAccountID))
+            CookieHeaderCache.clear(provider: .codex)
+        }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+
+        #expect(store.codexAccountEmailForOpenAIDashboard() == "managed@example.com")
+        #expect(store.codexCookieCacheScopeForOpenAIWeb() == .managedAccount(managedAccount.id))
+        #expect(CookieHeaderCache.load(provider: .codex, scope: store.codexCookieCacheScopeForOpenAIWeb()) == nil)
+    }
+
+    @Test
+    func `managed codex open A I web targets runtime auth backed email for selected account`() throws {
+        let settings = self.makeSettingsStore(suite: "CodexManagedOpenAIWebTests-managed-runtime-email")
+        let managedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: managedHome) }
+        try Self.writeCodexAuthFile(
+            homeURL: managedHome,
+            email: "renamed@example.com",
+            plan: "pro",
+            accountId: "acct-managed")
+
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "legacy@example.com",
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+        defer { settings._test_activeManagedCodexAccount = nil }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+
+        #expect(store.codexAccountEmailForOpenAIDashboard() == "renamed@example.com")
+        #expect(store.codexAccountEmailForOpenAIDashboard() != managedAccount.email)
+        #expect(store.currentCodexOpenAIWebRefreshGuard().accountKey == "renamed@example.com")
+        #expect(store.currentCodexOpenAIWebRefreshGuard().identity == .providerAccount(id: "acct-managed"))
+    }
+
+    @Test
+    func `live system codex open A I web uses live identity and no managed cache scope`() {
+        let settings = self.makeSettingsStore(suite: "CodexManagedOpenAIWebTests-live-system")
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-codex-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let liveAccount = ObservedSystemCodexAccount(
+            email: "system@example.com",
+            codexHomePath: "/tmp/live-codex-home",
+            observedAt: Date())
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings._test_liveSystemCodexAccount = liveAccount
+        settings.codexActiveSource = .liveSystem
+        defer {
+            settings._test_activeManagedCodexAccount = nil
+            settings._test_liveSystemCodexAccount = nil
+        }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: ["CODEX_HOME": liveAccount.codexHomePath]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+
+        #expect(store.codexAccountEmailForOpenAIDashboard() == liveAccount.email)
+        #expect(store.codexAccountEmailForOpenAIDashboard() != managedAccount.email)
+        #expect(store.codexCookieCacheScopeForOpenAIWeb() == nil)
+    }
+
+    @Test
+    func `live system codex open A I web does not reuse stale managed snapshot email after source switch`() {
+        let settings = self.makeSettingsStore(suite: "CodexManagedOpenAIWebTests-live-system-stale-managed-snapshot")
+        let isolatedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-openai-web-empty-\(UUID().uuidString)", isDirectory: true)
+        try? FileManager.default.createDirectory(at: isolatedHome, withIntermediateDirectories: true)
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-codex-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings._test_codexReconciliationEnvironment = ["CODEX_HOME": isolatedHome.path]
+        settings.codexActiveSource = .liveSystem
+        defer {
+            settings._test_activeManagedCodexAccount = nil
+            settings._test_codexReconciliationEnvironment = nil
+            try? FileManager.default.removeItem(at: isolatedHome)
+        }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: nil,
+                secondary: nil,
+                updatedAt: Date(),
+                identity: ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: managedAccount.email,
+                    accountOrganization: nil,
+                    loginMethod: nil)),
+            provider: .codex)
+
+        #expect(store.codexAccountEmailForOpenAIDashboard() == nil)
+        #expect(store.codexAccountEmailForOpenAIDashboard() != managedAccount.email)
+        #expect(store.codexCookieCacheScopeForOpenAIWeb() == nil)
+    }
+
+    @Test
+    func `live system codex open A I web reuses last known live email without allowing any account`() async {
+        let settings = self.makeSettingsStore(suite: "CodexManagedOpenAIWebTests-live-system-last-known-email")
+        let isolatedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-openai-web-last-known-\(UUID().uuidString)", isDirectory: true)
+        try? FileManager.default.createDirectory(at: isolatedHome, withIntermediateDirectories: true)
+        let liveAccount = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: "/tmp/live-codex-home",
+            observedAt: Date())
+        settings._test_liveSystemCodexAccount = liveAccount
+        settings._test_codexReconciliationEnvironment = ["CODEX_HOME": isolatedHome.path]
+        settings.codexActiveSource = .liveSystem
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+
+        #expect(store.codexAccountEmailForOpenAIDashboard() == liveAccount.email)
+
+        settings._test_liveSystemCodexAccount = nil
+        defer {
+            settings._test_liveSystemCodexAccount = nil
+            settings._test_codexReconciliationEnvironment = nil
+            try? FileManager.default.removeItem(at: isolatedHome)
+        }
+
+        store.openAIDashboard = OpenAIDashboardSnapshot(
+            signedInEmail: "managed@example.com",
+            codeReviewRemainingPercent: 100,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            updatedAt: Date())
+        store.lastOpenAIDashboardCookieImportEmail = "managed-import@example.com"
+
+        var observedTargetEmail: String?
+        var observedAllowAnyAccount: Bool?
+        store._test_openAIDashboardCookieImportOverride = { targetEmail, allowAnyAccount, _, _, _ in
+            observedTargetEmail = targetEmail
+            observedAllowAnyAccount = allowAnyAccount
+            return OpenAIDashboardBrowserCookieImporter.ImportResult(
+                sourceLabel: "test",
+                cookieCount: 1,
+                signedInEmail: targetEmail,
+                matchesCodexEmail: true)
+        }
+        defer { store._test_openAIDashboardCookieImportOverride = nil }
+
+        let targetEmail = store.codexAccountEmailForOpenAIDashboard()
+        let imported = await store.importOpenAIDashboardCookiesIfNeeded(targetEmail: targetEmail, force: true)
+
+        #expect(targetEmail == liveAccount.email)
+        #expect(targetEmail != "managed@example.com")
+        #expect(targetEmail != "managed-import@example.com")
+        #expect(imported == liveAccount.email)
+        #expect(observedTargetEmail == liveAccount.email)
+        #expect(observedAllowAnyAccount == false)
+    }
+
+    @Test
+    func `successful dashboard apply preserves cached open A I web view for same account`() async {
+        let settings = self.makeSettingsStore(suite: "CodexManagedOpenAIWebTests-preserve-cache-on-success")
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-codex-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+        defer { settings._test_activeManagedCodexAccount = nil }
+
+        OpenAIDashboardWebsiteDataStore.clearCacheForTesting()
+        let cache = OpenAIDashboardWebViewCache.shared
+        cache.clearAllForTesting()
+        defer {
+            cache.clearAllForTesting()
+            OpenAIDashboardWebsiteDataStore.clearCacheForTesting()
+        }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        let websiteDataStore = OpenAIDashboardWebsiteDataStore.store(forAccountEmail: managedAccount.email)
+        cache.cacheEntryForTesting(websiteDataStore: websiteDataStore)
+
+        #expect(cache.hasCachedEntry(for: websiteDataStore))
+
+        await store.applyOpenAIDashboard(
+            OpenAIDashboardSnapshot(
+                signedInEmail: managedAccount.email,
+                codeReviewRemainingPercent: 90,
+                creditEvents: [],
+                dailyBreakdown: [],
+                usageBreakdown: [],
+                creditsPurchaseURL: nil,
+                creditsRemaining: 10,
+                accountPlan: "Pro",
+                updatedAt: Date()),
+            targetEmail: managedAccount.email)
+
+        #expect(cache.hasCachedEntry(for: websiteDataStore))
+        #expect(cache.entryCount == 1)
+    }
+
+    @Test
+    func `dashboard refresh does not target stale last known live email`() async {
+        let settings = self.makeSettingsStore(suite: "CodexManagedOpenAIWebTests-live-system-refresh-strict-target")
+        let isolatedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-openai-web-refresh-strict-\(UUID().uuidString)", isDirectory: true)
+        try? FileManager.default.createDirectory(at: isolatedHome, withIntermediateDirectories: true)
+        let liveAccount = ObservedSystemCodexAccount(
+            email: "old@example.com",
+            codexHomePath: "/tmp/live-codex-home",
+            observedAt: Date())
+        settings._test_liveSystemCodexAccount = liveAccount
+        settings._test_codexReconciliationEnvironment = ["CODEX_HOME": isolatedHome.path]
+        settings.codexActiveSource = .liveSystem
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+
+        #expect(store.codexAccountEmailForOpenAIDashboard() == liveAccount.email)
+
+        settings._test_liveSystemCodexAccount = nil
+        defer {
+            settings._test_liveSystemCodexAccount = nil
+            settings._test_codexReconciliationEnvironment = nil
+            try? FileManager.default.removeItem(at: isolatedHome)
+        }
+
+        var observedTargetEmail: String?
+        store._test_openAIDashboardLoaderOverride = { accountEmail, _, _, _ in
+            observedTargetEmail = accountEmail
+            return OpenAIDashboardSnapshot(
+                signedInEmail: "new@example.com",
+                codeReviewRemainingPercent: 88,
+                creditEvents: [],
+                dailyBreakdown: [],
+                usageBreakdown: [],
+                creditsPurchaseURL: nil,
+                primaryLimit: RateWindow(usedPercent: 12, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+                secondaryLimit: nil,
+                creditsRemaining: 22,
+                accountPlan: "Pro",
+                updatedAt: Date())
+        }
+        defer { store._test_openAIDashboardLoaderOverride = nil }
+
+        let expectedGuard = store.currentCodexOpenAIWebRefreshGuard()
+        #expect(expectedGuard.accountKey == nil)
+
+        await store.refreshOpenAIDashboardIfNeeded(force: true, expectedGuard: expectedGuard)
+
+        #expect(observedTargetEmail == nil)
+        #expect(store.openAIDashboard == nil)
+        #expect(store.openAIDashboardRequiresLogin == true)
+        #expect(store.lastOpenAIDashboardError?.contains("could not be verified") == true)
+        #expect(store.lastKnownLiveSystemCodexEmail == "old@example.com")
+    }
+
+    @Test
+    func `dashboard refresh targets usage discovered live email before reconciliation catches up`() async {
+        let settings = self.makeSettingsStore(suite: "CodexManagedOpenAIWebTests-live-system-usage-discovered-target")
+        let isolatedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-openai-web-usage-discovered-\(UUID().uuidString)", isDirectory: true)
+        try? FileManager.default.createDirectory(at: isolatedHome, withIntermediateDirectories: true)
+        settings._test_codexReconciliationEnvironment = ["CODEX_HOME": isolatedHome.path]
+        settings.codexActiveSource = .liveSystem
+        defer {
+            settings._test_codexReconciliationEnvironment = nil
+            try? FileManager.default.removeItem(at: isolatedHome)
+        }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: nil,
+                secondary: nil,
+                updatedAt: Date(),
+                identity: ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: "usage@example.com",
+                    accountOrganization: nil,
+                    loginMethod: nil)),
+            provider: .codex)
+        store.lastSourceLabels[.codex] = "codex-cli"
+
+        var observedTargetEmail: String?
+        store._test_openAIDashboardLoaderOverride = { accountEmail, _, _, _ in
+            observedTargetEmail = accountEmail
+            return OpenAIDashboardSnapshot(
+                signedInEmail: "usage@example.com",
+                codeReviewRemainingPercent: 88,
+                creditEvents: [],
+                dailyBreakdown: [],
+                usageBreakdown: [],
+                creditsPurchaseURL: nil,
+                primaryLimit: RateWindow(usedPercent: 12, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+                secondaryLimit: nil,
+                creditsRemaining: 22,
+                accountPlan: "Pro",
+                updatedAt: Date())
+        }
+        defer { store._test_openAIDashboardLoaderOverride = nil }
+
+        let expectedGuard = store.currentCodexOpenAIWebRefreshGuard()
+        #expect(expectedGuard.accountKey == nil)
+
+        await store.refreshOpenAIDashboardIfNeeded(force: true, expectedGuard: expectedGuard)
+
+        #expect(observedTargetEmail == "usage@example.com")
+        #expect(store.openAIDashboard?.signedInEmail == "usage@example.com")
+    }
+
+    @Test
+    func `usage discovered live email still surfaces open A I web login guidance during reconciliation lag`() async {
+        let settings = self.makeSettingsStore(suite: "CodexManagedOpenAIWebTests-live-system-usage-discovered-failure")
+        let isolatedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-openai-web-usage-discovered-failure-\(UUID().uuidString)", isDirectory: true)
+        try? FileManager.default.createDirectory(at: isolatedHome, withIntermediateDirectories: true)
+        settings._test_codexReconciliationEnvironment = ["CODEX_HOME": isolatedHome.path]
+        settings.codexActiveSource = .liveSystem
+        defer {
+            settings._test_codexReconciliationEnvironment = nil
+            try? FileManager.default.removeItem(at: isolatedHome)
+        }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: nil,
+                secondary: nil,
+                updatedAt: Date(),
+                identity: ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: "usage@example.com",
+                    accountOrganization: nil,
+                    loginMethod: nil)),
+            provider: .codex)
+        store.lastSourceLabels[.codex] = "codex-cli"
+
+        let expectedGuard = store.currentCodexOpenAIWebRefreshGuard()
+        #expect(expectedGuard.accountKey == nil)
+
+        await store.applyOpenAIDashboardLoginRequiredFailure(
+            expectedGuard: expectedGuard,
+            routingTargetEmail: "usage@example.com")
+
+        #expect(store.openAIDashboardRequiresLogin == true)
+        #expect(store.lastOpenAIDashboardError?.contains("requires a signed-in chatgpt.com session") == true)
+    }
+
+    @Test
+    func `open A I web import uses managed account target when live account differs`() async {
+        let settings = self.makeSettingsStore(suite: "CodexManagedOpenAIWebTests-targeting-active-vs-live")
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-codex-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let liveAccount = ObservedSystemCodexAccount(
+            email: "system@example.com",
+            codexHomePath: "/tmp/live-codex-home",
+            observedAt: Date())
+        let expectedScope = CookieHeaderCache.Scope.managedAccount(managedAccount.id)
+        let expectedEmail = managedAccount.email
+        var observedTargetEmail: String?
+        var observedScope: CookieHeaderCache.Scope?
+        var observedCookieSource: ProviderCookieSource?
+        var observedAllowAnyAccount = false
+
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings._test_liveSystemCodexAccount = liveAccount
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+        defer {
+            settings._test_activeManagedCodexAccount = nil
+            settings._test_liveSystemCodexAccount = nil
+        }
+
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: liveAccount.email,
+                accountOrganization: nil,
+                loginMethod: nil))
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: ["CODEX_HOME": liveAccount.codexHomePath]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        store._setSnapshotForTesting(snapshot, provider: .codex)
+        store._test_openAIDashboardCookieImportOverride = { targetEmail, allowAnyAccount, cookieSource, scope, _ in
+            observedTargetEmail = targetEmail
+            observedScope = scope
+            observedCookieSource = cookieSource
+            observedAllowAnyAccount = allowAnyAccount
+            return OpenAIDashboardBrowserCookieImporter.ImportResult(
+                sourceLabel: "test",
+                cookieCount: 1,
+                signedInEmail: targetEmail,
+                matchesCodexEmail: targetEmail == expectedEmail)
+        }
+        defer { store._test_openAIDashboardCookieImportOverride = nil }
+
+        let importerTarget = store.codexAccountEmailForOpenAIDashboard()
+        let imported = await store.importOpenAIDashboardCookiesIfNeeded(targetEmail: importerTarget, force: true)
+
+        #expect(importerTarget == expectedEmail)
+        #expect(importerTarget != liveAccount.email)
+        #expect(imported == expectedEmail)
+        #expect(observedTargetEmail == expectedEmail)
+        #expect(observedScope == expectedScope)
+        #expect(observedAllowAnyAccount == false)
+        #expect(observedCookieSource == .auto)
+        #expect(store.codexCookieCacheScopeForOpenAIWeb() == expectedScope)
+    }
+
+    @Test
+    func `open A I web prefers live identity when managed and live share email`() {
+        let settings = self.makeSettingsStore(suite: "CodexManagedOpenAIWebTests-same-email-prefers-live")
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "person@example.com",
+            managedHomePath: "/tmp/managed-codex-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let liveAccount = ObservedSystemCodexAccount(
+            email: "PERSON@example.com",
+            codexHomePath: "/tmp/live-codex-home",
+            observedAt: Date())
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings._test_liveSystemCodexAccount = liveAccount
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+        defer {
+            settings._test_activeManagedCodexAccount = nil
+            settings._test_liveSystemCodexAccount = nil
+        }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: ["CODEX_HOME": liveAccount.codexHomePath]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+
+        #expect(settings.codexResolvedActiveSource == .liveSystem)
+        #expect(store.codexAccountEmailForOpenAIDashboard() == "person@example.com")
+        #expect(store.codexCookieCacheScopeForOpenAIWeb() == nil)
+    }
+
+    @Test
+    func `unmanaged codex open A I web falls back to provider global cache scope`() {
+        let settings = self.makeSettingsStore(suite: "CodexManagedOpenAIWebTests-unmanaged")
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+
+        #expect(store.codexCookieCacheScopeForOpenAIWeb() == nil)
+    }
+
+    @Test
+    func `unreadable managed codex store fails closed for open A I web`() async {
+        let settings = self.makeSettingsStore(suite: "CodexManagedOpenAIWebTests-unreadable-store")
+        settings._test_unreadableManagedCodexAccountStore = true
+        settings.codexActiveSource = .managedAccount(id: UUID())
+        defer { settings._test_unreadableManagedCodexAccountStore = false }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+
+        #expect(store.codexCookieCacheScopeForOpenAIWeb() == .managedStoreUnreadable)
+        #expect(store.codexAccountEmailForOpenAIDashboard() == nil)
+
+        let imported = await store.importOpenAIDashboardCookiesIfNeeded(targetEmail: nil, force: true)
+
+        #expect(imported == nil)
+        #expect(store.openAIDashboard == nil)
+        #expect(store.openAIDashboardRequiresLogin == true)
+        #expect(store.openAIDashboardCookieImportStatus?.contains("Managed Codex account data is unavailable") == true)
+
+        await store.refreshOpenAIDashboardIfNeeded(force: true)
+
+        #expect(store.openAIDashboard == nil)
+        #expect(store.openAIDashboardRequiresLogin == true)
+        #expect(store.lastOpenAIDashboardError?.contains("Managed Codex account data is unavailable") == true)
+    }
+
+    @Test
+    func `missing managed codex open A I web target fails closed`() async {
+        let settings = self.makeSettingsStore(suite: "CodexManagedOpenAIWebTests-missing-managed-target")
+        let storedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "stored@example.com",
+            managedHomePath: "/tmp/stored-managed-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let storeURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-openai-web-\(UUID().uuidString).json")
+        let managedStore = FileManagedCodexAccountStore(fileURL: storeURL)
+        try? managedStore.storeAccounts(ManagedCodexAccountSet(
+            version: FileManagedCodexAccountStore.currentVersion,
+            accounts: [storedAccount]))
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .managedAccount(id: UUID())
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            try? FileManager.default.removeItem(at: storeURL)
+        }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        var importWasCalled = false
+        store._test_openAIDashboardCookieImportOverride = { _, _, _, _, _ in
+            importWasCalled = true
+            return OpenAIDashboardBrowserCookieImporter.ImportResult(
+                sourceLabel: "test",
+                cookieCount: 1,
+                signedInEmail: "unexpected@example.com",
+                matchesCodexEmail: true)
+        }
+        defer { store._test_openAIDashboardCookieImportOverride = nil }
+        store.openAIDashboard = OpenAIDashboardSnapshot(
+            signedInEmail: "stale-dashboard@example.com",
+            codeReviewRemainingPercent: 100,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            updatedAt: Date())
+        store.lastOpenAIDashboardCookieImportEmail = "stale-import@example.com"
+
+        #expect(store.codexAccountEmailForOpenAIDashboard() == nil)
+        #expect(store.codexCookieCacheScopeForOpenAIWeb() != nil)
+        #expect(store.codexCookieCacheScopeForOpenAIWeb() != .managedStoreUnreadable)
+
+        let imported = await store.importOpenAIDashboardCookiesIfNeeded(targetEmail: nil, force: true)
+        #expect(imported == nil)
+        #expect(importWasCalled == false)
+        #expect(store.openAIDashboard == nil)
+        #expect(store.openAIDashboardRequiresLogin == true)
+        #expect(store.openAIDashboardCookieImportStatus?
+            .contains("selected managed Codex account is unavailable") == true)
+
+        await store.refreshOpenAIDashboardIfNeeded(force: true)
+        #expect(importWasCalled == false)
+        #expect(store.openAIDashboard == nil)
+        #expect(store.lastOpenAIDashboardError?.contains("selected managed Codex account is unavailable") == true)
+    }
+
+    @Test
+    func `managed codex mismatch fail closed blocks stale dashboard restoration`() async {
+        let settings = self.makeSettingsStore(suite: "CodexManagedOpenAIWebTests-mismatch")
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-codex-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+        defer { settings._test_activeManagedCodexAccount = nil }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        let staleSnapshot = OpenAIDashboardSnapshot(
+            signedInEmail: managedAccount.email,
+            codeReviewRemainingPercent: 100,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            updatedAt: Date())
+
+        await store.applyOpenAIDashboard(staleSnapshot, targetEmail: managedAccount.email)
+        await store.applyOpenAIDashboard(
+            OpenAIDashboardSnapshot(
+                signedInEmail: "other@example.com",
+                codeReviewRemainingPercent: 100,
+                creditEvents: [],
+                dailyBreakdown: [],
+                usageBreakdown: [],
+                creditsPurchaseURL: nil,
+                updatedAt: Date()),
+            targetEmail: managedAccount.email)
+
+        #expect(store.openAIDashboard == nil)
+        #expect(store.lastOpenAIDashboardSnapshot == nil)
+        #expect(store.openAIDashboardRequiresLogin == true)
+        #expect(store.lastOpenAIDashboardError?.contains("OpenAI dashboard signed in as other@example.com") == true)
+
+        await store.applyOpenAIDashboardFailure(message: "No dashboard data")
+        #expect(store.openAIDashboard == nil)
+        #expect(store.lastOpenAIDashboardError == "No dashboard data")
+
+        await store.applyOpenAIDashboardLoginRequiredFailure()
+        #expect(store.openAIDashboard == nil)
+        #expect(store.openAIDashboardRequiresLogin == true)
+        #expect(store.lastOpenAIDashboardError?.contains("requires a signed-in chatgpt.com session") == true)
+    }
+
+    @Test
+    func `managed codex import mismatch fail closed blocks stale dashboard restoration`() async {
+        let settings = self.makeSettingsStore(suite: "CodexManagedOpenAIWebTests-import-mismatch")
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-codex-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        settings._test_activeManagedCodexAccount = managedAccount
+        defer { settings._test_activeManagedCodexAccount = nil }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        store._test_openAIDashboardCookieImportOverride = { _, _, _, _, _ in
+            throw OpenAIDashboardBrowserCookieImporter.ImportError.noMatchingAccount(
+                found: [.init(sourceLabel: "Chrome", email: "other@example.com")])
+        }
+
+        let staleSnapshot = OpenAIDashboardSnapshot(
+            signedInEmail: managedAccount.email,
+            codeReviewRemainingPercent: 100,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            updatedAt: Date())
+        await store.applyOpenAIDashboard(staleSnapshot, targetEmail: managedAccount.email)
+
+        let imported = await store.importOpenAIDashboardCookiesIfNeeded(
+            targetEmail: managedAccount.email,
+            force: true)
+
+        #expect(imported == nil)
+        #expect(store.openAIDashboard == nil)
+        #expect(store.openAIDashboardRequiresLogin == true)
+        #expect(
+            store.openAIDashboardCookieImportStatus ==
+                "OpenAI cookies are for other@example.com, not managed@example.com.")
+
+        await store.applyOpenAIDashboardFailure(message: "No dashboard data")
+        #expect(store.openAIDashboard == nil)
+        #expect(store.lastOpenAIDashboardError == "No dashboard data")
+
+        await store.applyOpenAIDashboardLoginRequiredFailure()
+        #expect(store.openAIDashboard == nil)
+        #expect(store.openAIDashboardRequiresLogin == true)
+        #expect(store.lastOpenAIDashboardError?.contains("requires a signed-in chatgpt.com session") == true)
+    }
+
+    @Test
+    func `missing managed target failure handlers do not resurrect stale dashboard state`() async {
+        let settings = self.makeSettingsStore(suite: "CodexManagedOpenAIWebTests-missing-target-failure-handlers")
+        let isolatedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-openai-web-missing-target-\(UUID().uuidString)", isDirectory: true)
+        try? FileManager.default.createDirectory(at: isolatedHome, withIntermediateDirectories: true)
+        settings._test_codexReconciliationEnvironment = ["CODEX_HOME": isolatedHome.path]
+        settings.codexActiveSource = .managedAccount(id: UUID())
+        defer {
+            settings._test_codexReconciliationEnvironment = nil
+            try? FileManager.default.removeItem(at: isolatedHome)
+        }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        let staleSnapshot = OpenAIDashboardSnapshot(
+            signedInEmail: "stale@example.com",
+            codeReviewRemainingPercent: 100,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            updatedAt: Date())
+
+        await store.applyOpenAIDashboard(staleSnapshot, targetEmail: "stale@example.com")
+        await store.applyOpenAIDashboardFailure(message: "No dashboard data")
+
+        #expect(store.openAIDashboard == nil)
+        #expect(store.lastOpenAIDashboardSnapshot == nil)
+        #expect(store.lastOpenAIDashboardError?.contains("selected managed Codex account is unavailable") == true)
+
+        await store.applyOpenAIDashboard(staleSnapshot, targetEmail: "stale@example.com")
+        await store.applyOpenAIDashboardLoginRequiredFailure()
+
+        #expect(store.openAIDashboard == nil)
+        #expect(store.lastOpenAIDashboardSnapshot == nil)
+        #expect(store.openAIDashboardRequiresLogin == true)
+        #expect(store.lastOpenAIDashboardError?.contains("selected managed Codex account is unavailable") == true)
+    }
+
+    @Test
+    func `managed codex refresh stops after cookie mismatch instead of retrying web view`() async {
+        let settings = self.makeSettingsStore(suite: "CodexManagedOpenAIWebTests-mismatch-aborts-retry")
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "ratulsarna@gmail.com",
+            managedHomePath: "/tmp/managed-codex-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+        defer { settings._test_activeManagedCodexAccount = nil }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+
+        var loaderCalls = 0
+        store._test_openAIDashboardLoaderOverride = { _, _, _, _ in
+            loaderCalls += 1
+            throw OpenAIDashboardFetcher.FetchError.loginRequired
+        }
+        defer { store._test_openAIDashboardLoaderOverride = nil }
+        store._test_openAIDashboardCookieImportOverride = { _, _, _, _, _ in
+            throw OpenAIDashboardBrowserCookieImporter.ImportError.noMatchingAccount(
+                found: [.init(sourceLabel: "Chrome", email: "rdsarna@gmail.com")])
+        }
+        defer { store._test_openAIDashboardCookieImportOverride = nil }
+
+        let expectedGuard = store.currentCodexOpenAIWebRefreshGuard()
+        await store.refreshOpenAIDashboardIfNeeded(force: true, expectedGuard: expectedGuard)
+
+        #expect(loaderCalls == 1)
+        #expect(
+            store.lastOpenAIDashboardError ==
+                "OpenAI cookies are for rdsarna@gmail.com, not ratulsarna@gmail.com. " +
+                "Switch chatgpt.com account, then refresh OpenAI cookies.")
+        #expect(store.openAIDashboard == nil)
+    }
+
+    @Test
+    func `managed codex refresh reports no matching web session without fake account`() async {
+        let settings = self.makeSettingsStore(suite: "CodexManagedOpenAIWebTests-no-matching-web-session")
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "ratulsarna@gmail.com",
+            managedHomePath: "/tmp/managed-codex-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+        defer { settings._test_activeManagedCodexAccount = nil }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+
+        store._test_openAIDashboardLoaderOverride = { _, _, _, _ in
+            throw OpenAIDashboardFetcher.FetchError.loginRequired
+        }
+        defer { store._test_openAIDashboardLoaderOverride = nil }
+        store._test_openAIDashboardCookieImportOverride = { _, _, _, _, _ in
+            throw OpenAIDashboardBrowserCookieImporter.ImportError.noMatchingAccount(found: [])
+        }
+        defer { store._test_openAIDashboardCookieImportOverride = nil }
+
+        let expectedGuard = store.currentCodexOpenAIWebRefreshGuard()
+        await store.refreshOpenAIDashboardIfNeeded(force: true, expectedGuard: expectedGuard)
+
+        #expect(
+            store.lastOpenAIDashboardError ==
+                "No matching OpenAI web session found for ratulsarna@gmail.com. " +
+                "Sign in to chatgpt.com as ratulsarna@gmail.com, then refresh OpenAI cookies.")
+        #expect(store.openAIDashboard == nil)
+    }
+}
diff --git a/Tests/CodexBarTests/CodexManagedRoutingTests.swift b/Tests/CodexBarTests/CodexManagedRoutingTests.swift
new file mode 100644
index 0000000000..2a2e2fcec3
--- /dev/null
+++ b/Tests/CodexBarTests/CodexManagedRoutingTests.swift
@@ -0,0 +1,851 @@
+import Foundation
+import Testing
+@testable import CodexBar
+@testable import CodexBarCore
+
+@Suite(.serialized)
+@MainActor
+struct CodexManagedRoutingTests {
+    @Test
+    func `provider registry injects managed home when active source is managed account`() {
+        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-registry")
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: "/tmp/codex-managed-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+        defer {
+            settings._test_activeManagedCodexAccount = nil
+        }
+
+        let codexEnv = ProviderRegistry.makeEnvironment(
+            base: ["PATH": "/usr/bin"],
+            provider: .codex,
+            settings: settings,
+            tokenOverride: nil)
+        let claudeEnv = ProviderRegistry.makeEnvironment(
+            base: ["PATH": "/usr/bin"],
+            provider: .claude,
+            settings: settings,
+            tokenOverride: nil)
+
+        #expect(codexEnv["CODEX_HOME"] == managedAccount.managedHomePath)
+        #expect(claudeEnv["CODEX_HOME"] == nil)
+    }
+
+    @Test
+    func `provider registry scopes codex environment with source override without persisting selection`() throws {
+        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-source-override-env")
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: "/tmp/codex-managed-override-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let storeURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-managed-override-\(UUID().uuidString).json")
+        let store = FileManagedCodexAccountStore(fileURL: storeURL)
+        try store.storeAccounts(ManagedCodexAccountSet(
+            version: FileManagedCodexAccountStore.currentVersion,
+            accounts: [managedAccount]))
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .liveSystem
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            try? FileManager.default.removeItem(at: storeURL)
+        }
+
+        let env = ProviderRegistry.makeEnvironment(
+            base: ["CODEX_HOME": "/Users/example/.codex"],
+            provider: .codex,
+            settings: settings,
+            tokenOverride: nil,
+            codexActiveSourceOverride: .managedAccount(id: managedAccount.id))
+
+        #expect(env["CODEX_HOME"] == managedAccount.managedHomePath)
+        #expect(settings.codexActiveSource == .liveSystem)
+    }
+
+    @Test
+    func `provider registry builds codex snapshot with source override without persisting selection`() throws {
+        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-source-override-snapshot")
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: "/tmp/codex-managed-override-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let storeURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-managed-snapshot-override-\(UUID().uuidString).json")
+        let store = FileManagedCodexAccountStore(fileURL: storeURL)
+        try store.storeAccounts(ManagedCodexAccountSet(
+            version: FileManagedCodexAccountStore.currentVersion,
+            accounts: [managedAccount]))
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .liveSystem
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            try? FileManager.default.removeItem(at: storeURL)
+        }
+
+        let snapshot = ProviderRegistry.makeSettingsSnapshot(
+            settings: settings,
+            tokenOverride: nil,
+            codexActiveSourceOverride: .managedAccount(id: UUID()))
+
+        #expect(snapshot.codex?.managedAccountTargetUnavailable == true)
+        #expect(settings.codexActiveSource == .liveSystem)
+    }
+
+    @Test
+    func `provider registry preserves ambient live system home when active source is live system`() {
+        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-live-system-routing")
+        let managedHomePath = "/tmp/managed-remote-home"
+        let liveHomePath = "/tmp/system-remote-home"
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: managedHomePath,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let liveSystemAccount = ObservedSystemCodexAccount(
+            email: "system@example.com",
+            codexHomePath: liveHomePath,
+            observedAt: Date())
+
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings._test_liveSystemCodexAccount = liveSystemAccount
+        settings.codexActiveSource = .liveSystem
+        defer {
+            settings._test_activeManagedCodexAccount = nil
+            settings._test_liveSystemCodexAccount = nil
+        }
+
+        let env = ProviderRegistry.makeEnvironment(
+            base: ["CODEX_HOME": liveHomePath],
+            provider: .codex,
+            settings: settings,
+            tokenOverride: nil)
+
+        #expect(env["CODEX_HOME"] == liveHomePath)
+        #expect(env["CODEX_HOME"] != managedHomePath)
+    }
+
+    @Test
+    func `provider registry keeps managed home when live account differs`() {
+        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-active-vs-live")
+        let managedHomePath = "/tmp/managed-remote-home"
+        let liveHomePath = "/tmp/system-remote-home"
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: managedHomePath,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let liveSystemAccount = ObservedSystemCodexAccount(
+            email: "system@example.com",
+            codexHomePath: liveHomePath,
+            observedAt: Date())
+
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings._test_liveSystemCodexAccount = liveSystemAccount
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+        defer {
+            settings._test_activeManagedCodexAccount = nil
+            settings._test_liveSystemCodexAccount = nil
+        }
+
+        let env = ProviderRegistry.makeEnvironment(
+            base: ["CODEX_HOME": liveHomePath],
+            provider: .codex,
+            settings: settings,
+            tokenOverride: nil)
+
+        #expect(env["CODEX_HOME"] == managedHomePath)
+        #expect(env["CODEX_HOME"] != liveHomePath)
+    }
+
+    @Test
+    func `provider registry prefers live system routing when managed and live share email`() {
+        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-same-email-prefers-live")
+        let managedHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        let liveHomePath = "/tmp/system-remote-home"
+        defer { try? FileManager.default.removeItem(at: managedHome) }
+
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "person@example.com",
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let liveSystemAccount = ObservedSystemCodexAccount(
+            email: "PERSON@example.com",
+            codexHomePath: liveHomePath,
+            observedAt: Date())
+
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings._test_liveSystemCodexAccount = liveSystemAccount
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+        defer {
+            settings._test_activeManagedCodexAccount = nil
+            settings._test_liveSystemCodexAccount = nil
+        }
+
+        let env = ProviderRegistry.makeEnvironment(
+            base: ["CODEX_HOME": liveHomePath],
+            provider: .codex,
+            settings: settings,
+            tokenOverride: nil)
+
+        #expect(settings.codexResolvedActiveSource == .liveSystem)
+        #expect(env["CODEX_HOME"] == liveHomePath)
+        #expect(env["CODEX_HOME"] != managedHome.path)
+    }
+
+    @Test
+    func `provider registry keeps managed routing when same email rows differ by identity strength`() throws {
+        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-same-email-split-by-identity")
+        let managedHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        let liveHomePath = "/tmp/system-remote-home"
+        defer { try? FileManager.default.removeItem(at: managedHome) }
+
+        try self.writeCodexAuthFile(
+            homeURL: managedHome,
+            email: "person@example.com",
+            plan: "pro",
+            accountId: "account-managed")
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "person@example.com",
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let liveSystemAccount = ObservedSystemCodexAccount(
+            email: "PERSON@example.com",
+            codexHomePath: liveHomePath,
+            observedAt: Date(),
+            identity: .emailOnly(normalizedEmail: "person@example.com"))
+
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings._test_liveSystemCodexAccount = liveSystemAccount
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+        defer {
+            settings._test_activeManagedCodexAccount = nil
+            settings._test_liveSystemCodexAccount = nil
+        }
+
+        let env = ProviderRegistry.makeEnvironment(
+            base: ["CODEX_HOME": liveHomePath],
+            provider: .codex,
+            settings: settings,
+            tokenOverride: nil)
+
+        #expect(settings.codexResolvedActiveSource == .managedAccount(id: managedAccount.id))
+        #expect(env["CODEX_HOME"] == managedHome.path)
+        #expect(env["CODEX_HOME"] != liveHomePath)
+    }
+
+    @Test
+    func `persisted managed source corrects to live system when selected row collapses with live account`() {
+        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-same-email-persist-correction")
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "person@example.com",
+            managedHomePath: "/tmp/managed-remote-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let liveSystemAccount = ObservedSystemCodexAccount(
+            email: "PERSON@example.com",
+            codexHomePath: "/tmp/system-remote-home",
+            observedAt: Date())
+
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings._test_liveSystemCodexAccount = liveSystemAccount
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+        defer {
+            settings._test_activeManagedCodexAccount = nil
+            settings._test_liveSystemCodexAccount = nil
+        }
+
+        let corrected = settings.persistResolvedCodexActiveSourceCorrectionIfNeeded()
+
+        #expect(corrected)
+        #expect(settings.codexActiveSource == .liveSystem)
+    }
+
+    @Test
+    func `codex provider refresh persists live correction for stale managed source`() async {
+        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-provider-refresh-persists-correction")
+        let ambientHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: ambientHome) }
+
+        try? self.writeCodexAuthFile(homeURL: ambientHome, email: "live@example.com", plan: "pro")
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: ambientHome.path,
+            observedAt: Date())
+        settings.codexActiveSource = .managedAccount(id: UUID())
+        defer { settings._test_liveSystemCodexAccount = nil }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: ["CODEX_HOME": ambientHome.path]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+
+        #expect(settings.codexActiveSource != .liveSystem)
+
+        await store.refreshProvider(.codex, allowDisabled: true)
+
+        #expect(settings.codexActiveSource == .liveSystem)
+    }
+
+    @Test
+    func `full refresh persists live correction for stale managed source`() async {
+        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-full-refresh-persists-correction")
+        let ambientHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: ambientHome) }
+
+        try? self.writeCodexAuthFile(homeURL: ambientHome, email: "live@example.com", plan: "pro")
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: ambientHome.path,
+            observedAt: Date())
+        settings.codexActiveSource = .managedAccount(id: UUID())
+        defer { settings._test_liveSystemCodexAccount = nil }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: ["CODEX_HOME": ambientHome.path]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+
+        #expect(settings.codexActiveSource != .liveSystem)
+
+        await store.refresh()
+
+        #expect(settings.codexActiveSource == .liveSystem)
+    }
+
+    @Test
+    func `provider registry fails closed when managed account store is unreadable`() {
+        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-unreadable-store")
+        settings._test_unreadableManagedCodexAccountStore = true
+        settings.codexActiveSource = .managedAccount(id: UUID())
+        defer { settings._test_unreadableManagedCodexAccountStore = false }
+
+        let env = ProviderRegistry.makeEnvironment(
+            base: ["CODEX_HOME": "/Users/example/.codex"],
+            provider: .codex,
+            settings: settings,
+            tokenOverride: nil)
+
+        #expect(env["CODEX_HOME"] != nil)
+        #expect(env["CODEX_HOME"] != "/Users/example/.codex")
+        #expect(env["CODEX_HOME"]?.isEmpty == false)
+    }
+
+    @Test
+    func `provider registry bootstraps live system source instead of inferring managed fallback`() {
+        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-unreadable-legacy-source")
+        settings._test_unreadableManagedCodexAccountStore = true
+        defer { settings._test_unreadableManagedCodexAccountStore = false }
+
+        let ambientHome = "/Users/example/.codex"
+        let env = ProviderRegistry.makeEnvironment(
+            base: ["CODEX_HOME": ambientHome],
+            provider: .codex,
+            settings: settings,
+            tokenOverride: nil)
+        let snapshot = settings.codexSettingsSnapshot(tokenOverride: nil)
+
+        #expect(env["CODEX_HOME"] == ambientHome)
+        #expect(settings.providerConfig(for: .codex)?.codexActiveSource == nil)
+        #expect(snapshot.managedAccountStoreUnreadable == false)
+        #expect(snapshot.managedAccountTargetUnavailable == false)
+    }
+
+    @Test
+    func `provider registry fails closed when selected managed source is missing from readable store`() throws {
+        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-missing-managed-source")
+        let storedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "stored@example.com",
+            managedHomePath: "/tmp/stored-managed-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let storeURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-managed-routing-\(UUID().uuidString).json")
+        let store = FileManagedCodexAccountStore(fileURL: storeURL)
+        try store.storeAccounts(ManagedCodexAccountSet(
+            version: FileManagedCodexAccountStore.currentVersion,
+            accounts: [storedAccount]))
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .managedAccount(id: UUID())
+        settings._test_codexReconciliationEnvironment = ["CODEX_HOME": "/Users/example/.codex"]
+        defer {
+            settings._test_codexReconciliationEnvironment = nil
+            settings._test_managedCodexAccountStoreURL = nil
+            try? FileManager.default.removeItem(at: storeURL)
+        }
+
+        let ambientHome = "/Users/example/.codex"
+        let expectedFailClosedPath = ManagedCodexHomeFactory.defaultRootURL()
+            .appendingPathComponent("managed-store-unreadable", isDirectory: true)
+            .path
+        let env = ProviderRegistry.makeEnvironment(
+            base: ["CODEX_HOME": ambientHome],
+            provider: .codex,
+            settings: settings,
+            tokenOverride: nil)
+
+        #expect(env["CODEX_HOME"] == expectedFailClosedPath)
+        #expect(env["CODEX_HOME"] != ambientHome)
+        #expect(env["CODEX_HOME"] != storedAccount.managedHomePath)
+    }
+
+    @Test
+    func `codex settings snapshot marks missing selected managed source as unavailable`() throws {
+        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-missing-managed-snapshot")
+        let storedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "stored@example.com",
+            managedHomePath: "/tmp/stored-managed-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let storeURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-managed-snapshot-\(UUID().uuidString).json")
+        let store = FileManagedCodexAccountStore(fileURL: storeURL)
+        try store.storeAccounts(ManagedCodexAccountSet(
+            version: FileManagedCodexAccountStore.currentVersion,
+            accounts: [storedAccount]))
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .managedAccount(id: UUID())
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            try? FileManager.default.removeItem(at: storeURL)
+        }
+
+        let snapshot = settings.codexSettingsSnapshot(tokenOverride: nil)
+
+        #expect(snapshot.managedAccountStoreUnreadable == false)
+        #expect(snapshot.managedAccountTargetUnavailable == true)
+    }
+
+    @Test
+    func `codex settings snapshot ignores unreadable added account store when live system is active`() {
+        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-live-system-snapshot")
+        settings._test_unreadableManagedCodexAccountStore = true
+        settings.codexActiveSource = .liveSystem
+        defer { settings._test_unreadableManagedCodexAccountStore = false }
+
+        let snapshot = settings.codexSettingsSnapshot(tokenOverride: nil)
+
+        #expect(snapshot.managedAccountStoreUnreadable == false)
+        #expect(snapshot.managedAccountTargetUnavailable == false)
+    }
+
+    @Test
+    func `codex settings snapshot keeps unreadable managed store fail closed when live account is present`() {
+        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-unreadable-store-live-present")
+        settings._test_unreadableManagedCodexAccountStore = true
+        settings.codexActiveSource = .managedAccount(id: UUID())
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: "/Users/example/.codex",
+            observedAt: Date(),
+            identity: .providerAccount(id: "acct-live"))
+        defer {
+            settings._test_unreadableManagedCodexAccountStore = false
+            settings._test_liveSystemCodexAccount = nil
+        }
+
+        let snapshot = settings.codexSettingsSnapshot(tokenOverride: nil)
+
+        #expect(snapshot.managedAccountStoreUnreadable == true)
+        #expect(snapshot.managedAccountTargetUnavailable == false)
+    }
+
+    @Test
+    func `codex settings snapshot keeps missing managed target fail closed when live account is present`() throws {
+        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-missing-managed-live-present")
+        let storedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "stored@example.com",
+            managedHomePath: "/tmp/stored-managed-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let storeURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-managed-live-present-\(UUID().uuidString).json")
+        let store = FileManagedCodexAccountStore(fileURL: storeURL)
+        try store.storeAccounts(ManagedCodexAccountSet(
+            version: FileManagedCodexAccountStore.currentVersion,
+            accounts: [storedAccount]))
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .managedAccount(id: UUID())
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: "/Users/example/.codex",
+            observedAt: Date(),
+            identity: .providerAccount(id: "acct-live"))
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            settings._test_liveSystemCodexAccount = nil
+            try? FileManager.default.removeItem(at: storeURL)
+        }
+
+        let snapshot = settings.codexSettingsSnapshot(tokenOverride: nil)
+
+        #expect(snapshot.managedAccountStoreUnreadable == false)
+        #expect(snapshot.managedAccountTargetUnavailable == true)
+    }
+
+    @Test
+    func `provider registry ignores debug managed home override without explicit managed source`() throws {
+        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-debug-home-override")
+        let managedHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: managedHome) }
+
+        settings._test_activeManagedCodexRemoteHomePath = managedHome.path
+        defer { settings._test_activeManagedCodexRemoteHomePath = nil }
+        try self.writeCodexAuthFile(homeURL: managedHome, email: "managed@example.com", plan: "pro")
+
+        let ambientHome = "/Users/example/.codex"
+        let env = ProviderRegistry.makeEnvironment(
+            base: ["CODEX_HOME": ambientHome],
+            provider: .codex,
+            settings: settings,
+            tokenOverride: nil)
+
+        #expect(env["CODEX_HOME"] == ambientHome)
+        #expect(settings.providerConfig(for: .codex)?.codexActiveSource == nil)
+    }
+
+    @Test
+    func `provider registry builds codex fetcher scoped to managed home`() throws {
+        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-registry-fetcher")
+        let managedHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: managedHome) }
+
+        settings._test_activeManagedCodexRemoteHomePath = managedHome.path
+        settings.codexActiveSource = .managedAccount(id: UUID())
+        try self.writeCodexAuthFile(homeURL: managedHome, email: "managed@example.com", plan: "pro")
+        defer {
+            settings._test_activeManagedCodexRemoteHomePath = nil
+        }
+
+        let browserDetection = BrowserDetection(cacheTTL: 0)
+        let specs = ProviderRegistry.shared.specs(
+            settings: settings,
+            metadata: ProviderDescriptorRegistry.metadata,
+            codexFetcher: UsageFetcher(environment: [:]),
+            claudeFetcher: ClaudeUsageFetcher(browserDetection: browserDetection),
+            browserDetection: browserDetection)
+        let context = try #require(specs[.codex]?.makeFetchContext())
+
+        let account = context.fetcher.loadAccountInfo()
+        #expect(account.email == "managed@example.com")
+        #expect(account.plan == "pro")
+    }
+
+    @Test
+    func `usage store builds codex fetch context with source override without persisting selection`() throws {
+        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-usage-source-override")
+        let managedHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: managedHome) }
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let storeURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-managed-usage-override-\(UUID().uuidString).json")
+        let managedStore = FileManagedCodexAccountStore(fileURL: storeURL)
+        try managedStore.storeAccounts(ManagedCodexAccountSet(
+            version: FileManagedCodexAccountStore.currentVersion,
+            accounts: [managedAccount]))
+        try self.writeCodexAuthFile(homeURL: managedHome, email: "override@example.com", plan: "pro")
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings.codexActiveSource = .liveSystem
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            try? FileManager.default.removeItem(at: storeURL)
+        }
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+
+        let context = store.makeFetchContext(
+            provider: .codex,
+            override: nil,
+            codexActiveSourceOverride: .managedAccount(id: managedAccount.id))
+
+        let account = context.fetcher.loadAccountInfo()
+        #expect(account.email == "override@example.com")
+        #expect(account.plan == "pro")
+        #expect(settings.codexActiveSource == .liveSystem)
+    }
+
+    @Test
+    func `usage store builds codex token account fetcher scoped to managed home`() throws {
+        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-usage-store")
+        let managedHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: managedHome) }
+
+        settings._test_activeManagedCodexRemoteHomePath = managedHome.path
+        settings.codexActiveSource = .managedAccount(id: UUID())
+        try self.writeCodexAuthFile(homeURL: managedHome, email: "token@example.com", plan: "team")
+        defer {
+            settings._test_activeManagedCodexRemoteHomePath = nil
+        }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        let context = store.makeFetchContext(provider: .codex, override: nil)
+
+        let account = context.fetcher.loadAccountInfo()
+        #expect(account.email == "token@example.com")
+        #expect(account.plan == "team")
+    }
+
+    @Test
+    func `usage store builds codex credits fetcher scoped to managed home`() throws {
+        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-credits-fetcher")
+        let managedHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: managedHome) }
+
+        settings._test_activeManagedCodexRemoteHomePath = managedHome.path
+        settings.codexActiveSource = .managedAccount(id: UUID())
+        try self.writeCodexAuthFile(homeURL: managedHome, email: "credits@example.com", plan: "enterprise")
+        defer {
+            settings._test_activeManagedCodexRemoteHomePath = nil
+        }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        let account = store.codexCreditsFetcher().loadAccountInfo()
+
+        #expect(account.email == "credits@example.com")
+        #expect(account.plan == "enterprise")
+    }
+
+    @Test
+    func `default managed codex identity reader preserves provider account from scoped auth`() throws {
+        let managedHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: managedHome) }
+        try self.writeCodexAuthFile(
+            homeURL: managedHome,
+            email: "managed@example.com",
+            plan: "pro",
+            accountId: "managed-account-id")
+
+        let reader = DefaultManagedCodexIdentityReader()
+        let account = try reader.loadAccountIdentity(homePath: managedHome.path)
+
+        #expect(account.email == "managed@example.com")
+        #expect(account.plan == "pro")
+        #expect(account.identity == .providerAccount(id: "managed-account-id"))
+    }
+
+    @Test
+    func `codex O auth strategy availability reads auth from context env`() async throws {
+        let managedHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: managedHome) }
+
+        let credentials = CodexOAuthCredentials(
+            accessToken: "access-token",
+            refreshToken: "refresh-token",
+            idToken: nil,
+            accountId: nil,
+            lastRefresh: Date())
+        try CodexOAuthCredentialsStore.save(credentials, env: ["CODEX_HOME": managedHome.path])
+
+        let strategy = CodexOAuthFetchStrategy()
+        let available = await strategy.isAvailable(self.makeContext(env: ["CODEX_HOME": managedHome.path]))
+
+        #expect(available)
+    }
+
+    @Test
+    func `codex O auth credentials store loads and saves using explicit env`() throws {
+        let managedHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: managedHome) }
+
+        let credentials = CodexOAuthCredentials(
+            accessToken: "access-token",
+            refreshToken: "refresh-token",
+            idToken: "id-token",
+            accountId: "account-id",
+            lastRefresh: Date())
+        let env = ["CODEX_HOME": managedHome.path]
+
+        try CodexOAuthCredentialsStore.save(credentials, env: env)
+
+        let authURL = CodexOAuthCredentialsStore._authFileURLForTesting(env: env)
+        #expect(authURL.path == managedHome.appendingPathComponent("auth.json").path)
+
+        let loaded = try CodexOAuthCredentialsStore.load(env: env)
+        #expect(loaded.accessToken == credentials.accessToken)
+        #expect(loaded.refreshToken == credentials.refreshToken)
+        #expect(loaded.idToken == credentials.idToken)
+        #expect(loaded.accountId == credentials.accountId)
+    }
+
+    @Test
+    func `codex no data message uses explicit environment home`() {
+        let env = ["CODEX_HOME": "/tmp/managed-codex-home"]
+
+        let message = CodexProviderDescriptor._noDataMessageForTesting(env: env)
+
+        #expect(message.contains("/tmp/managed-codex-home/sessions"))
+        #expect(message.contains("/tmp/managed-codex-home/archived_sessions"))
+    }
+
+    private func makeContext(env: [String: String]) -> ProviderFetchContext {
+        let browserDetection = BrowserDetection(cacheTTL: 0)
+        return ProviderFetchContext(
+            runtime: .app,
+            sourceMode: .auto,
+            includeCredits: false,
+            webTimeout: 60,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: env,
+            settings: nil,
+            fetcher: UsageFetcher(),
+            claudeFetcher: ClaudeUsageFetcher(browserDetection: browserDetection),
+            browserDetection: browserDetection)
+    }
+
+    private func makeSettingsStore(suite: String) -> SettingsStore {
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+        return SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: InMemoryZaiTokenStore(),
+            syntheticTokenStore: InMemorySyntheticTokenStore(),
+            codexCookieStore: InMemoryCookieHeaderStore(),
+            claudeCookieStore: InMemoryCookieHeaderStore(),
+            cursorCookieStore: InMemoryCookieHeaderStore(),
+            opencodeCookieStore: InMemoryCookieHeaderStore(),
+            factoryCookieStore: InMemoryCookieHeaderStore(),
+            minimaxCookieStore: InMemoryMiniMaxCookieStore(),
+            minimaxAPITokenStore: InMemoryMiniMaxAPITokenStore(),
+            kimiTokenStore: InMemoryKimiTokenStore(),
+            kimiK2TokenStore: InMemoryKimiK2TokenStore(),
+            augmentCookieStore: InMemoryCookieHeaderStore(),
+            ampCookieStore: InMemoryCookieHeaderStore(),
+            copilotTokenStore: InMemoryCopilotTokenStore(),
+            tokenAccountStore: InMemoryTokenAccountStore())
+    }
+
+    private func writeCodexAuthFile(
+        homeURL: URL,
+        email: String,
+        plan: String,
+        accountId: String? = nil) throws
+    {
+        try FileManager.default.createDirectory(at: homeURL, withIntermediateDirectories: true)
+        var tokens: [String: Any] = [
+            "accessToken": "access-token",
+            "refreshToken": "refresh-token",
+            "idToken": Self.fakeJWT(email: email, plan: plan, accountId: accountId),
+        ]
+        if let accountId {
+            tokens["accountId"] = accountId
+        }
+        let auth = ["tokens": tokens]
+        let data = try JSONSerialization.data(withJSONObject: auth)
+        try data.write(to: homeURL.appendingPathComponent("auth.json"))
+    }
+
+    private static func fakeJWT(email: String, plan: String, accountId: String? = nil) -> String {
+        let header = (try? JSONSerialization.data(withJSONObject: ["alg": "none"])) ?? Data()
+        var authClaims: [String: Any] = [
+            "chatgpt_plan_type": plan,
+        ]
+        if let accountId {
+            authClaims["chatgpt_account_id"] = accountId
+        }
+        let payload = (try? JSONSerialization.data(withJSONObject: [
+            "email": email,
+            "chatgpt_plan_type": plan,
+            "https://api.openai.com/auth": authClaims,
+        ])) ?? Data()
+
+        func base64URL(_ data: Data) -> String {
+            data.base64EncodedString()
+                .replacingOccurrences(of: "=", with: "")
+                .replacingOccurrences(of: "+", with: "-")
+                .replacingOccurrences(of: "/", with: "_")
+        }
+
+        return "\(base64URL(header)).\(base64URL(payload))."
+    }
+}
+
+private final class InMemoryZaiTokenStore: ZaiTokenStoring, @unchecked Sendable {
+    func loadToken() throws -> String? {
+        nil
+    }
+
+    func storeToken(_: String?) throws {}
+}
+
+private final class InMemorySyntheticTokenStore: SyntheticTokenStoring, @unchecked Sendable {
+    func loadToken() throws -> String? {
+        nil
+    }
+
+    func storeToken(_: String?) throws {}
+}
diff --git a/Tests/CodexBarTests/CodexOAuthCredentialsStorePermissionsTests.swift b/Tests/CodexBarTests/CodexOAuthCredentialsStorePermissionsTests.swift
new file mode 100644
index 0000000000..9d8bf4ef2d
--- /dev/null
+++ b/Tests/CodexBarTests/CodexOAuthCredentialsStorePermissionsTests.swift
@@ -0,0 +1,67 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct CodexOAuthCredentialsStorePermissionsTests {
+    private enum PublishProbeError: Error, Equatable {
+        case stop
+    }
+
+    @Test
+    func `saving O auth credentials keeps auth json private`() throws {
+        #if os(macOS) || os(Linux)
+        let codexHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-oauth-permissions-\(UUID().uuidString)", isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: codexHome) }
+
+        let credentials = CodexOAuthCredentials(
+            accessToken: "access-token",
+            refreshToken: "refresh-token",
+            idToken: "id-token",
+            accountId: "account-123",
+            lastRefresh: Date())
+
+        try CodexOAuthCredentialsStore.save(credentials, env: ["CODEX_HOME": codexHome.path])
+
+        let authURL = codexHome.appendingPathComponent("auth.json")
+        let attributes = try FileManager.default.attributesOfItem(atPath: authURL.path)
+        let permissions = try #require(attributes[.posixPermissions] as? NSNumber)
+        #expect(permissions.intValue & 0o777 == 0o600)
+        #else
+        #expect(Bool(true))
+        #endif
+    }
+
+    @Test
+    func `auth json is private before atomic publication`() throws {
+        #if os(macOS) || os(Linux)
+        let codexHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-oauth-staging-\(UUID().uuidString)", isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: codexHome) }
+        try FileManager.default.createDirectory(at: codexHome, withIntermediateDirectories: true)
+
+        let authURL = codexHome.appendingPathComponent("auth.json")
+        let originalData = Data("original".utf8)
+        try originalData.write(to: authURL)
+
+        #expect(throws: PublishProbeError.stop) {
+            try CodexOAuthCredentialsStore._writePrivateFileForTesting(
+                Data("replacement".utf8),
+                to: authURL)
+            { stagedURL in
+                let attributes = try FileManager.default.attributesOfItem(atPath: stagedURL.path)
+                let permissions = try #require(attributes[.posixPermissions] as? NSNumber)
+                #expect(permissions.intValue & 0o777 == 0o600)
+                #expect(try Data(contentsOf: authURL) == originalData)
+                throw PublishProbeError.stop
+            }
+        }
+
+        #expect(try Data(contentsOf: authURL) == originalData)
+        let entries = try FileManager.default.contentsOfDirectory(atPath: codexHome.path)
+        #expect(entries == ["auth.json"])
+        #else
+        #expect(Bool(true))
+        #endif
+    }
+}
diff --git a/Tests/CodexBarTests/CodexOAuthTests.swift b/Tests/CodexBarTests/CodexOAuthTests.swift
index 10a628aa0b..291c4cb10a 100644
--- a/Tests/CodexBarTests/CodexOAuthTests.swift
+++ b/Tests/CodexBarTests/CodexOAuthTests.swift
@@ -2,10 +2,25 @@ import Foundation
 import Testing
 @testable import CodexBarCore
 
-@Suite
 struct CodexOAuthTests {
+    private func makeContext(sourceMode: ProviderSourceMode = .auto) -> ProviderFetchContext {
+        let browserDetection = BrowserDetection(cacheTTL: 0)
+        return ProviderFetchContext(
+            runtime: .app,
+            sourceMode: sourceMode,
+            includeCredits: true,
+            webTimeout: 60,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: [:],
+            settings: nil,
+            fetcher: UsageFetcher(),
+            claudeFetcher: ClaudeUsageFetcher(browserDetection: browserDetection),
+            browserDetection: browserDetection)
+    }
+
     @Test
-    func parsesOAuthCredentials() throws {
+    func `parses O auth credentials`() throws {
         let json = """
         {
           "OPENAI_API_KEY": null,
@@ -27,7 +42,29 @@ struct CodexOAuthTests {
     }
 
     @Test
-    func parsesAPIKeyCredentials() throws {
+    func `parses legacy camel case O auth credentials`() throws {
+        let json = """
+        {
+          "OPENAI_API_KEY": null,
+          "tokens": {
+            "accessToken": "access-token",
+            "refreshToken": "refresh-token",
+            "idToken": "id-token",
+            "accountId": "account-123"
+          },
+          "last_refresh": "2025-12-20T12:34:56Z"
+        }
+        """
+        let creds = try CodexOAuthCredentialsStore.parse(data: Data(json.utf8))
+        #expect(creds.accessToken == "access-token")
+        #expect(creds.refreshToken == "refresh-token")
+        #expect(creds.idToken == "id-token")
+        #expect(creds.accountId == "account-123")
+        #expect(creds.lastRefresh != nil)
+    }
+
+    @Test
+    func `parses API key credentials`() throws {
         let json = """
         {
           "OPENAI_API_KEY": "sk-test"
@@ -41,7 +78,7 @@ struct CodexOAuthTests {
     }
 
     @Test
-    func decodesCreditsBalanceString() throws {
+    func `decodes credits balance string`() throws {
         let json = """
         {
           "plan_type": "pro",
@@ -67,7 +104,34 @@ struct CodexOAuthTests {
     }
 
     @Test
-    func mapsUsageWindowsFromOAuth() throws {
+    func `decodes prolite plan type without failing usage mapping`() throws {
+        let json = """
+        {
+          "plan_type": "prolite",
+          "rate_limit": {
+            "primary_window": {
+              "used_percent": 12,
+              "reset_at": 1766948068,
+              "limit_window_seconds": 18000
+            }
+          }
+        }
+        """
+        let response = try CodexOAuthUsageFetcher._decodeUsageResponseForTesting(Data(json.utf8))
+        #expect(response.planType?.rawValue == "prolite")
+
+        let creds = CodexOAuthCredentials(
+            accessToken: "access",
+            refreshToken: "refresh",
+            idToken: nil,
+            accountId: nil,
+            lastRefresh: Date())
+        let mapped = try CodexOAuthFetchStrategy._mapUsageForTesting(Data(json.utf8), credentials: creds)
+        #expect(mapped?.primary?.usedPercent == 12)
+    }
+
+    @Test
+    func `maps usage windows from O auth`() throws {
         let json = """
         {
           "rate_limit": {
@@ -90,7 +154,8 @@ struct CodexOAuthTests {
             idToken: nil,
             accountId: nil,
             lastRefresh: Date())
-        let snapshot = try CodexOAuthFetchStrategy._mapUsageForTesting(Data(json.utf8), credentials: creds)
+        let mapped = try CodexOAuthFetchStrategy._mapUsageForTesting(Data(json.utf8), credentials: creds)
+        let snapshot = try #require(mapped)
         #expect(snapshot.primary?.usedPercent == 22)
         #expect(snapshot.primary?.windowMinutes == 300)
         #expect(snapshot.secondary?.usedPercent == 43)
@@ -100,21 +165,663 @@ struct CodexOAuthTests {
     }
 
     @Test
-    func resolvesChatGPTUsageURLFromConfig() {
+    func `O auth response with precise windows maps to exact confidence`() throws {
+        let json = """
+        {
+          "rate_limit": {
+            "primary_window": {
+              "used_percent": 22,
+              "reset_at": 1766948068,
+              "limit_window_seconds": 18000
+            },
+            "secondary_window": {
+              "used_percent": 43,
+              "reset_at": 1767407914,
+              "limit_window_seconds": 604800
+            }
+          }
+        }
+        """
+        let creds = CodexOAuthCredentials(
+            accessToken: "access",
+            refreshToken: "refresh",
+            idToken: nil,
+            accountId: nil,
+            lastRefresh: Date())
+        let result = try CodexOAuthFetchStrategy._mapResultForTesting(Data(json.utf8), credentials: creds)
+
+        #expect(result.sourceLabel == "oauth")
+        #expect(result.usage.dataConfidence == .exact)
+        #expect(result.usage.primary?.usedPercent == 22)
+        #expect(result.usage.secondary?.usedPercent == 43)
+    }
+
+    @Test
+    func `O auth response with malformed additional window maps to unknown confidence`() throws {
+        let json = """
+        {
+          "rate_limit": {
+            "primary_window": {
+              "used_percent": 22,
+              "reset_at": 1766948068,
+              "limit_window_seconds": 18000
+            }
+          },
+          "additional_rate_limits": [
+            {
+              "limit_name": "GPT-5.3-Codex-Spark",
+              "metered_feature": "gpt_5_3_codex_spark",
+              "rate_limit": {
+                "primary_window": { "used_percent": "bad" }
+              }
+            }
+          ]
+        }
+        """
+        let creds = CodexOAuthCredentials(
+            accessToken: "access",
+            refreshToken: "refresh",
+            idToken: nil,
+            accountId: nil,
+            lastRefresh: Date())
+        let result = try CodexOAuthFetchStrategy._mapResultForTesting(Data(json.utf8), credentials: creds)
+
+        #expect(result.usage.primary?.usedPercent == 22)
+        #expect(result.usage.extraRateWindows == nil)
+        #expect(result.usage.dataConfidence == .unknown)
+    }
+
+    @Test
+    func `maps free weekly only window into secondary`() throws {
+        let json = """
+        {
+          "plan_type": "free",
+          "rate_limit": {
+            "primary_window": {
+              "used_percent": 0,
+              "reset_at": 1775468693,
+              "limit_window_seconds": 604800
+            },
+            "secondary_window": null
+          }
+        }
+        """
+        let creds = CodexOAuthCredentials(
+            accessToken: "access",
+            refreshToken: "refresh",
+            idToken: nil,
+            accountId: nil,
+            lastRefresh: Date())
+        let mapped = try CodexOAuthFetchStrategy._mapUsageForTesting(Data(json.utf8), credentials: creds)
+        let snapshot = try #require(mapped)
+        #expect(snapshot.primary == nil)
+        #expect(snapshot.secondary?.usedPercent == 0)
+        #expect(snapshot.secondary?.windowMinutes == 10080)
+    }
+
+    @Test
+    func `keeps single session window as primary`() throws {
+        let json = """
+        {
+          "rate_limit": {
+            "primary_window": {
+              "used_percent": 9,
+              "reset_at": 1766948068,
+              "limit_window_seconds": 18000
+            },
+            "secondary_window": null
+          }
+        }
+        """
+        let creds = CodexOAuthCredentials(
+            accessToken: "access",
+            refreshToken: "refresh",
+            idToken: nil,
+            accountId: nil,
+            lastRefresh: Date())
+        let mapped = try CodexOAuthFetchStrategy._mapUsageForTesting(Data(json.utf8), credentials: creds)
+        let snapshot = try #require(mapped)
+        #expect(snapshot.primary?.usedPercent == 9)
+        #expect(snapshot.primary?.windowMinutes == 300)
+        #expect(snapshot.secondary == nil)
+    }
+
+    @Test
+    func `preserves unknown single window as primary`() throws {
+        let json = """
+        {
+          "rate_limit": {
+            "primary_window": {
+              "used_percent": 17,
+              "reset_at": 1766948068,
+              "limit_window_seconds": 32400
+            },
+            "secondary_window": null
+          }
+        }
+        """
+        let creds = CodexOAuthCredentials(
+            accessToken: "access",
+            refreshToken: "refresh",
+            idToken: nil,
+            accountId: nil,
+            lastRefresh: Date())
+        let mapped = try CodexOAuthFetchStrategy._mapUsageForTesting(Data(json.utf8), credentials: creds)
+        let snapshot = try #require(mapped)
+        #expect(snapshot.primary?.usedPercent == 17)
+        #expect(snapshot.primary?.windowMinutes == 540)
+        #expect(snapshot.secondary == nil)
+    }
+
+    @Test
+    func `preserves unknown secondary only window as primary`() throws {
+        let json = """
+        {
+          "rate_limit": {
+            "primary_window": null,
+            "secondary_window": {
+              "used_percent": 17,
+              "reset_at": 1766948068,
+              "limit_window_seconds": 32400
+            }
+          }
+        }
+        """
+        let creds = CodexOAuthCredentials(
+            accessToken: "access",
+            refreshToken: "refresh",
+            idToken: nil,
+            accountId: nil,
+            lastRefresh: Date())
+        let mapped = try CodexOAuthFetchStrategy._mapUsageForTesting(Data(json.utf8), credentials: creds)
+        let snapshot = try #require(mapped)
+        #expect(snapshot.primary?.usedPercent == 17)
+        #expect(snapshot.primary?.windowMinutes == 540)
+        #expect(snapshot.secondary == nil)
+    }
+
+    @Test
+    func `swaps reversed weekly and unknown windows`() throws {
+        let json = """
+        {
+          "rate_limit": {
+            "primary_window": {
+              "used_percent": 43,
+              "reset_at": 1767407914,
+              "limit_window_seconds": 604800
+            },
+            "secondary_window": {
+              "used_percent": 17,
+              "reset_at": 1766948068,
+              "limit_window_seconds": 32400
+            }
+          }
+        }
+        """
+        let creds = CodexOAuthCredentials(
+            accessToken: "access",
+            refreshToken: "refresh",
+            idToken: nil,
+            accountId: nil,
+            lastRefresh: Date())
+        let mapped = try CodexOAuthFetchStrategy._mapUsageForTesting(Data(json.utf8), credentials: creds)
+        let snapshot = try #require(mapped)
+        #expect(snapshot.primary?.usedPercent == 17)
+        #expect(snapshot.primary?.windowMinutes == 540)
+        #expect(snapshot.secondary?.usedPercent == 43)
+        #expect(snapshot.secondary?.windowMinutes == 10080)
+    }
+
+    @Test
+    func `returns nil when O auth usage has no windows`() throws {
+        let json = """
+        {
+          "rate_limit": {
+            "primary_window": null,
+            "secondary_window": null
+          }
+        }
+        """
+        let creds = CodexOAuthCredentials(
+            accessToken: "access",
+            refreshToken: "refresh",
+            idToken: nil,
+            accountId: nil,
+            lastRefresh: Date())
+        let snapshot = try CodexOAuthFetchStrategy._mapUsageForTesting(Data(json.utf8), credentials: creds)
+        #expect(snapshot == nil)
+    }
+
+    @Test
+    func `keeps valid window when secondary window is malformed`() throws {
+        let json = """
+        {
+          "rate_limit": {
+            "primary_window": {
+              "used_percent": 18,
+              "reset_at": 1766948068,
+              "limit_window_seconds": 18000
+            },
+            "secondary_window": {
+              "used_percent": "bad",
+              "reset_at": 1767407914,
+              "limit_window_seconds": 604800
+            }
+          }
+        }
+        """
+        let creds = CodexOAuthCredentials(
+            accessToken: "access",
+            refreshToken: "refresh",
+            idToken: nil,
+            accountId: nil,
+            lastRefresh: Date())
+        let snapshot = try CodexOAuthFetchStrategy._mapUsageForTesting(Data(json.utf8), credentials: creds)
+        #expect(snapshot?.primary?.usedPercent == 18)
+        #expect(snapshot?.secondary == nil)
+
+        let result = try CodexOAuthFetchStrategy._mapResultForTesting(Data(json.utf8), credentials: creds)
+        #expect(result.usage.primary?.usedPercent == 18)
+        #expect(result.usage.secondary == nil)
+        #expect(result.usage.dataConfidence == .unknown)
+    }
+
+    @Test
+    func `auto mode keeps weekly window when primary window is malformed`() throws {
+        let json = """
+        {
+          "rate_limit": {
+            "primary_window": {
+              "used_percent": "bad",
+              "reset_at": 1766948068,
+              "limit_window_seconds": 18000
+            },
+            "secondary_window": {
+              "used_percent": 43,
+              "reset_at": 1767407914,
+              "limit_window_seconds": 604800
+            }
+          }
+        }
+        """
+        let creds = CodexOAuthCredentials(
+            accessToken: "access",
+            refreshToken: "refresh",
+            idToken: nil,
+            accountId: nil,
+            lastRefresh: Date())
+
+        let result = try CodexOAuthFetchStrategy._mapResultForTesting(
+            Data(json.utf8),
+            credentials: creds,
+            sourceMode: .auto)
+
+        #expect(result.usage.primary == nil)
+        #expect(result.usage.secondary?.usedPercent == 43)
+        #expect(result.usage.secondary?.windowMinutes == 10080)
+    }
+
+    @Test
+    func `explicit oauth keeps weekly window when primary window is malformed`() throws {
+        let json = """
+        {
+          "rate_limit": {
+            "primary_window": {
+              "used_percent": "bad",
+              "reset_at": 1766948068,
+              "limit_window_seconds": 18000
+            },
+            "secondary_window": {
+              "used_percent": 43,
+              "reset_at": 1767407914,
+              "limit_window_seconds": 604800
+            }
+          }
+        }
+        """
+        let creds = CodexOAuthCredentials(
+            accessToken: "access",
+            refreshToken: "refresh",
+            idToken: nil,
+            accountId: nil,
+            lastRefresh: Date())
+
+        let result = try CodexOAuthFetchStrategy._mapResultForTesting(
+            Data(json.utf8),
+            credentials: creds,
+            sourceMode: .oauth)
+
+        #expect(result.usage.primary == nil)
+        #expect(result.usage.secondary?.usedPercent == 43)
+        #expect(result.usage.secondary?.windowMinutes == 10080)
+    }
+
+    @Test
+    func `auto mode preserves reversed session window when primary window is malformed`() throws {
+        let json = """
+        {
+          "rate_limit": {
+            "primary_window": {
+              "used_percent": "bad",
+              "reset_at": 1767407914,
+              "limit_window_seconds": 604800
+            },
+            "secondary_window": {
+              "used_percent": 18,
+              "reset_at": 1766948068,
+              "limit_window_seconds": 18000
+            }
+          }
+        }
+        """
+        let creds = CodexOAuthCredentials(
+            accessToken: "access",
+            refreshToken: "refresh",
+            idToken: nil,
+            accountId: nil,
+            lastRefresh: Date())
+
+        let result = try CodexOAuthFetchStrategy._mapResultForTesting(
+            Data(json.utf8),
+            credentials: creds,
+            sourceMode: .auto)
+
+        #expect(result.usage.primary?.usedPercent == 18)
+        #expect(result.usage.primary?.windowMinutes == 300)
+        #expect(result.usage.secondary == nil)
+    }
+
+    @Test
+    func `auto mode keeps weekly window when reversed session window is malformed`() throws {
+        let json = """
+        {
+          "rate_limit": {
+            "primary_window": {
+              "used_percent": 43,
+              "reset_at": 1767407914,
+              "limit_window_seconds": 604800
+            },
+            "secondary_window": {
+              "used_percent": "bad",
+              "reset_at": 1766948068,
+              "limit_window_seconds": 18000
+            }
+          }
+        }
+        """
+        let creds = CodexOAuthCredentials(
+            accessToken: "access",
+            refreshToken: "refresh",
+            idToken: nil,
+            accountId: nil,
+            lastRefresh: Date())
+
+        let result = try CodexOAuthFetchStrategy._mapResultForTesting(
+            Data(json.utf8),
+            credentials: creds,
+            sourceMode: .auto)
+
+        #expect(result.usage.primary == nil)
+        #expect(result.usage.secondary?.usedPercent == 43)
+        #expect(result.usage.secondary?.windowMinutes == 10080)
+    }
+
+    @Test
+    func `explicit oauth keeps weekly window when reversed session window is malformed`() throws {
+        let json = """
+        {
+          "rate_limit": {
+            "primary_window": {
+              "used_percent": 43,
+              "reset_at": 1767407914,
+              "limit_window_seconds": 604800
+            },
+            "secondary_window": {
+              "used_percent": "bad",
+              "reset_at": 1766948068,
+              "limit_window_seconds": 18000
+            }
+          }
+        }
+        """
+        let creds = CodexOAuthCredentials(
+            accessToken: "access",
+            refreshToken: "refresh",
+            idToken: nil,
+            accountId: nil,
+            lastRefresh: Date())
+
+        let result = try CodexOAuthFetchStrategy._mapResultForTesting(
+            Data(json.utf8),
+            credentials: creds,
+            sourceMode: .oauth)
+
+        #expect(result.usage.primary == nil)
+        #expect(result.usage.secondary?.usedPercent == 43)
+        #expect(result.usage.secondary?.windowMinutes == 10080)
+    }
+
+    @Test
+    func `ignores malformed credits payload while keeping usage`() throws {
+        let json = """
+        {
+          "rate_limit": {
+            "primary_window": {
+              "used_percent": 22,
+              "reset_at": 1766948068,
+              "limit_window_seconds": 18000
+            }
+          },
+          "credits": {
+            "has_credits": false,
+            "unlimited": false,
+            "balance": []
+          }
+        }
+        """
+        let response = try CodexOAuthUsageFetcher._decodeUsageResponseForTesting(Data(json.utf8))
+        #expect(response.credits?.hasCredits == false)
+        #expect(response.credits?.unlimited == false)
+        #expect(response.credits?.balance == nil)
+
+        let creds = CodexOAuthCredentials(
+            accessToken: "access",
+            refreshToken: "refresh",
+            idToken: nil,
+            accountId: nil,
+            lastRefresh: Date())
+        let snapshot = try CodexOAuthFetchStrategy._mapUsageForTesting(Data(json.utf8), credentials: creds)
+        #expect(snapshot?.primary?.usedPercent == 22)
+    }
+
+    @Test
+    func `credits only O auth payload still returns credits result`() throws {
+        let json = """
+        {
+          "rate_limit": {
+            "primary_window": null,
+            "secondary_window": null
+          },
+          "credits": {
+            "has_credits": true,
+            "unlimited": false,
+            "balance": "14.5"
+          }
+        }
+        """
+        let creds = CodexOAuthCredentials(
+            accessToken: "access",
+            refreshToken: "refresh",
+            idToken: nil,
+            accountId: nil,
+            lastRefresh: Date())
+
+        let result = try CodexOAuthFetchStrategy._mapResultForTesting(Data(json.utf8), credentials: creds)
+
+        #expect(result.usage.primary == nil)
+        #expect(result.usage.secondary == nil)
+        #expect(result.credits?.remaining == 14.5)
+        #expect(result.sourceLabel == "oauth")
+    }
+
+    @Test
+    func `credits only O auth payload returns credits in auto mode`() throws {
+        let json = """
+        {
+          "rate_limit": {
+            "primary_window": null,
+            "secondary_window": null
+          },
+          "credits": {
+            "has_credits": true,
+            "unlimited": false,
+            "balance": "14.5"
+          }
+        }
+        """
+        let creds = CodexOAuthCredentials(
+            accessToken: "access",
+            refreshToken: "refresh",
+            idToken: nil,
+            accountId: nil,
+            lastRefresh: Date())
+
+        let result = try CodexOAuthFetchStrategy._mapResultForTesting(
+            Data(json.utf8),
+            credentials: creds,
+            sourceMode: .auto)
+
+        #expect(result.usage.primary == nil)
+        #expect(result.usage.secondary == nil)
+        #expect(result.credits?.remaining == 14.5)
+        #expect(result.sourceLabel == "oauth")
+    }
+
+    @Test
+    func `reset credits only O auth payload still returns usage result`() throws {
+        let json = #"{"rate_limit":{"primary_window":null,"secondary_window":null}}"#
+        let now = Date()
+        let resetCredits = CodexRateLimitResetCreditsSnapshot(
+            credits: [],
+            availableCount: 2,
+            updatedAt: now)
+        let creds = CodexOAuthCredentials(
+            accessToken: "access",
+            refreshToken: "refresh",
+            idToken: nil,
+            accountId: nil,
+            lastRefresh: now)
+
+        let result = try CodexOAuthFetchStrategy._mapResultForTesting(
+            Data(json.utf8),
+            credentials: creds,
+            resetCredits: resetCredits)
+
+        #expect(result.usage.primary == nil)
+        #expect(result.usage.secondary == nil)
+        #expect(result.usage.codexResetCredits?.availableCount == 2)
+        #expect(result.credits == nil)
+        #expect(result.sourceLabel == "oauth")
+    }
+
+    @Test
+    func `empty reset credits do not mask missing O auth usage`() {
+        let json = #"{"rate_limit":{"primary_window":null,"secondary_window":null}}"#
+        let now = Date()
+        let resetCredits = CodexRateLimitResetCreditsSnapshot(
+            credits: [],
+            availableCount: 0,
+            updatedAt: now)
+        let creds = CodexOAuthCredentials(
+            accessToken: "access",
+            refreshToken: "refresh",
+            idToken: nil,
+            accountId: nil,
+            lastRefresh: now)
+
+        #expect(throws: UsageError.self) {
+            try CodexOAuthFetchStrategy._mapResultForTesting(
+                Data(json.utf8),
+                credentials: creds,
+                resetCredits: resetCredits)
+        }
+    }
+
+    @Test
+    func `auto mode only falls back from O auth on auth failures`() {
+        let strategy = CodexOAuthFetchStrategy()
+        let context = self.makeContext(sourceMode: .auto)
+
+        #expect(strategy.shouldFallback(on: CodexOAuthFetchError.unauthorized, context: context))
+        #expect(strategy.shouldFallback(on: CodexOAuthCredentialsError.notFound, context: context))
+        #expect(strategy.shouldFallback(on: CodexOAuthCredentialsError.missingTokens, context: context))
+        #expect(strategy.shouldFallback(on: CodexTokenRefresher.RefreshError.expired, context: context))
+        #expect(strategy.shouldFallback(on: CodexTokenRefresher.RefreshError.revoked, context: context))
+        #expect(strategy.shouldFallback(on: CodexTokenRefresher.RefreshError.reused, context: context))
+
+        #expect(!strategy.shouldFallback(on: UsageError.noRateLimitsFound, context: context))
+        #expect(!strategy.shouldFallback(on: CodexOAuthCredentialsError.decodeFailed("bad json"), context: context))
+        #expect(!strategy.shouldFallback(on: CodexOAuthFetchError.invalidResponse, context: context))
+        #expect(!strategy.shouldFallback(on: CodexOAuthFetchError.serverError(500, "offline"), context: context))
+        #expect(!strategy.shouldFallback(
+            on: CodexOAuthFetchError.networkError(URLError(.notConnectedToInternet)),
+            context: context))
+        #expect(!strategy.shouldFallback(
+            on: CodexTokenRefresher.RefreshError.networkError(URLError(.timedOut)),
+            context: context))
+    }
+
+    @Test
+    func `non 401 invalid grant refresh failure is treated as revoked`() {
+        let data = Data(#"{"error":"invalid_grant"}"#.utf8)
+        let error = CodexTokenRefresher._refreshFailureErrorForTesting(statusCode: 400, data: data)
+
+        switch error {
+        case .revoked:
+            break
+        default:
+            Issue.record("Expected invalid_grant to be treated as revoked")
+        }
+    }
+
+    @Test
+    func `non auth refresh failure remains invalid response`() {
+        let data = Data(#"{"error":"invalid_request"}"#.utf8)
+        let error = CodexTokenRefresher._refreshFailureErrorForTesting(statusCode: 400, data: data)
+
+        switch error {
+        case let .invalidResponse(message):
+            #expect(message == "Status 400")
+        default:
+            Issue.record("Expected invalid_request to remain an invalid response")
+        }
+    }
+
+    @Test
+    func `explicit O auth mode never falls back to CLI`() {
+        let strategy = CodexOAuthFetchStrategy()
+        let context = self.makeContext(sourceMode: .oauth)
+
+        #expect(!strategy.shouldFallback(on: CodexOAuthFetchError.unauthorized, context: context))
+        #expect(!strategy.shouldFallback(on: CodexTokenRefresher.RefreshError.expired, context: context))
+    }
+
+    @Test
+    func `resolves chat GPT usage URL from config`() {
         let config = "chatgpt_base_url = \"https://chatgpt.com/backend-api/\"\n"
         let url = CodexOAuthUsageFetcher._resolveUsageURLForTesting(configContents: config)
         #expect(url.absoluteString == "https://chatgpt.com/backend-api/wham/usage")
     }
 
     @Test
-    func resolvesCodexUsageURLFromConfig() {
+    func `resolves codex usage URL from config`() {
         let config = "chatgpt_base_url = \"https://api.openai.com\"\n"
         let url = CodexOAuthUsageFetcher._resolveUsageURLForTesting(configContents: config)
         #expect(url.absoluteString == "https://api.openai.com/api/codex/usage")
     }
 
     @Test
-    func normalizesChatGPTBaseURLWithoutBackendAPI() {
+    func `normalizes chat GPT base URL without backend API`() {
         let config = "chatgpt_base_url = \"https://chat.openai.com\"\n"
         let url = CodexOAuthUsageFetcher._resolveUsageURLForTesting(configContents: config)
         #expect(url.absoluteString == "https://chat.openai.com/backend-api/wham/usage")
diff --git a/Tests/CodexBarTests/CodexOpenAIWorkspaceResolverTests.swift b/Tests/CodexBarTests/CodexOpenAIWorkspaceResolverTests.swift
new file mode 100644
index 0000000000..b0083f1a92
--- /dev/null
+++ b/Tests/CodexBarTests/CodexOpenAIWorkspaceResolverTests.swift
@@ -0,0 +1,144 @@
+import CodexBarCore
+import Foundation
+import Testing
+
+@Suite(.serialized)
+struct CodexOpenAIWorkspaceResolverTests {
+    @Test
+    func `resolver returns workspace identity and sends expected headers`() async throws {
+        defer {
+            CodexOpenAIWorkspaceStubURLProtocol.handler = nil
+            CodexOpenAIWorkspaceStubURLProtocol.requests = []
+        }
+        CodexOpenAIWorkspaceStubURLProtocol.requests = []
+
+        CodexOpenAIWorkspaceStubURLProtocol.handler = { request in
+            let requestURL = try #require(request.url)
+            let response = HTTPURLResponse(
+                url: requestURL,
+                statusCode: 200,
+                httpVersion: nil,
+                headerFields: nil)!
+            let data = Data("""
+            {
+              "items": [
+                { "id": "account-live", "name": "Team Alpha" }
+              ]
+            }
+            """.utf8)
+            return (response, data)
+        }
+
+        let config = URLSessionConfiguration.ephemeral
+        config.protocolClasses = [CodexOpenAIWorkspaceStubURLProtocol.self]
+        let session = URLSession(configuration: config)
+        let credentials = CodexOAuthCredentials(
+            accessToken: "access-token",
+            refreshToken: "refresh-token",
+            idToken: nil,
+            accountId: " account-live ",
+            lastRefresh: nil)
+
+        let identity = try await CodexOpenAIWorkspaceResolver.resolve(credentials: credentials, session: session)
+
+        #expect(identity == CodexOpenAIWorkspaceIdentity(
+            workspaceAccountID: "account-live",
+            workspaceLabel: "Team Alpha"))
+        #expect(CodexOpenAIWorkspaceStubURLProtocol.requests.count == 1)
+        #expect(CodexOpenAIWorkspaceStubURLProtocol.requests.first?.value(forHTTPHeaderField: "Authorization")
+            == "Bearer access-token")
+        #expect(CodexOpenAIWorkspaceStubURLProtocol.requests.first?.value(forHTTPHeaderField: "ChatGPT-Account-Id")
+            == "account-live")
+        #expect(CodexOpenAIWorkspaceStubURLProtocol.requests.first?.value(forHTTPHeaderField: "User-Agent")
+            == "codex-cli")
+    }
+
+    @Test
+    func `resolver returns personal when account name is empty`() async throws {
+        defer {
+            CodexOpenAIWorkspaceStubURLProtocol.handler = nil
+            CodexOpenAIWorkspaceStubURLProtocol.requests = []
+        }
+        CodexOpenAIWorkspaceStubURLProtocol.requests = []
+
+        CodexOpenAIWorkspaceStubURLProtocol.handler = { request in
+            let requestURL = try #require(request.url)
+            let response = HTTPURLResponse(
+                url: requestURL,
+                statusCode: 200,
+                httpVersion: nil,
+                headerFields: nil)!
+            let data = Data("""
+            {
+              "items": [
+                { "id": "account-live", "name": "   " }
+              ]
+            }
+            """.utf8)
+            return (response, data)
+        }
+
+        let config = URLSessionConfiguration.ephemeral
+        config.protocolClasses = [CodexOpenAIWorkspaceStubURLProtocol.self]
+        let session = URLSession(configuration: config)
+        let credentials = CodexOAuthCredentials(
+            accessToken: "access-token",
+            refreshToken: "refresh-token",
+            idToken: nil,
+            accountId: "account-live",
+            lastRefresh: nil)
+
+        let identity = try await CodexOpenAIWorkspaceResolver.resolve(credentials: credentials, session: session)
+
+        #expect(identity?.workspaceLabel == "Personal")
+    }
+
+    @Test
+    func `workspace identity cache persists and normalizes workspace ids`() throws {
+        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+        let fileURL = root.appendingPathComponent("codex-openai-workspaces.json")
+
+        try CodexOpenAIWorkspaceIdentityCache.withFileURLOverrideForTesting(fileURL) {
+            let cache = CodexOpenAIWorkspaceIdentityCache()
+            try cache.store(CodexOpenAIWorkspaceIdentity(
+                workspaceAccountID: " Account-Live ",
+                workspaceLabel: "Team Alpha"))
+
+            #expect(cache.workspaceLabel(for: "account-live") == "Team Alpha")
+            #expect(cache.workspaceLabel(for: " ACCOUNT-LIVE ") == "Team Alpha")
+        }
+    }
+}
+
+final class CodexOpenAIWorkspaceStubURLProtocol: URLProtocol {
+    nonisolated(unsafe) static var requests: [URLRequest] = []
+    nonisolated(unsafe) static var handler: (@Sendable (URLRequest) throws -> (HTTPURLResponse, Data))?
+
+    override static func canInit(with request: URLRequest) -> Bool {
+        true
+    }
+
+    override static func canonicalRequest(for request: URLRequest) -> URLRequest {
+        request
+    }
+
+    override func startLoading() {
+        Self.requests.append(self.request)
+        guard let handler = Self.handler else {
+            self.client?.urlProtocol(self, didFailWithError: URLError(.badServerResponse))
+            return
+        }
+
+        do {
+            let (response, data) = try handler(self.request)
+            self.client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
+            self.client?.urlProtocol(self, didLoad: data)
+            self.client?.urlProtocolDidFinishLoading(self)
+        } catch {
+            self.client?.urlProtocol(self, didFailWithError: error)
+        }
+    }
+
+    override func stopLoading() {}
+}
diff --git a/Tests/CodexBarTests/CodexPlanFormattingTests.swift b/Tests/CodexBarTests/CodexPlanFormattingTests.swift
new file mode 100644
index 0000000000..ca82b8f00f
--- /dev/null
+++ b/Tests/CodexBarTests/CodexPlanFormattingTests.swift
@@ -0,0 +1,40 @@
+import CodexBarCore
+import Foundation
+import Testing
+
+struct CodexPlanFormattingTests {
+    @Test
+    func `maps Codex pro plans to usage multiplier names`() {
+        #expect(CodexPlanFormatting.displayName("pro") == "Pro 20x")
+        #expect(CodexPlanFormatting.displayName("Pro") == "Pro 20x")
+        #expect(CodexPlanFormatting.displayName("Codex Pro") == "Pro 20x")
+        #expect(CodexPlanFormatting.displayName("prolite") == "Pro 5x")
+        #expect(CodexPlanFormatting.displayName("pro_lite") == "Pro 5x")
+        #expect(CodexPlanFormatting.displayName("pro-lite") == "Pro 5x")
+        #expect(CodexPlanFormatting.displayName("Pro Lite") == "Pro 5x")
+        #expect(CodexPlanFormatting.displayName("Codex Pro Lite") == "Pro 5x")
+    }
+
+    @Test
+    func `returns nil for empty plan values`() {
+        #expect(CodexPlanFormatting.displayName(nil) == nil)
+        #expect(CodexPlanFormatting.displayName("") == nil)
+        #expect(CodexPlanFormatting.displayName("   ") == nil)
+    }
+
+    @Test
+    func `humanizes machine style plan identifiers`() {
+        #expect(
+            CodexPlanFormatting.displayName("enterprise_cbp_usage_based")
+                == "Enterprise CBP Usage Based")
+        #expect(
+            CodexPlanFormatting.displayName("self_serve_business_usage_based")
+                == "Self Serve Business Usage Based")
+        #expect(CodexPlanFormatting.displayName("k12") == "K12")
+    }
+
+    @Test
+    func `preserves unrelated already readable plan text`() {
+        #expect(CodexPlanFormatting.displayName("Enterprise") == "Enterprise")
+    }
+}
diff --git a/Tests/CodexBarTests/CodexPresentationCharacterizationTests.swift b/Tests/CodexBarTests/CodexPresentationCharacterizationTests.swift
new file mode 100644
index 0000000000..670c44cd91
--- /dev/null
+++ b/Tests/CodexBarTests/CodexPresentationCharacterizationTests.swift
@@ -0,0 +1,491 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@Suite(.serialized)
+@MainActor
+struct CodexPresentationCharacterizationTests {
+    @Test
+    func `weekly only Codex menu rendering omits session row`() {
+        let settings = self.makeSettingsStore(suite: "CodexPresentationCharacterizationTests-weekly-only")
+        settings.statusChecksEnabled = false
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(
+            fetcher: fetcher,
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: nil,
+                secondary: RateWindow(
+                    usedPercent: 20,
+                    windowMinutes: 10080,
+                    resetsAt: nil,
+                    resetDescription: "Apr 6, 2026"),
+                updatedAt: Date(),
+                identity: ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: "codex@example.com",
+                    accountOrganization: nil,
+                    loginMethod: "free")),
+            provider: .codex)
+
+        let descriptor = MenuDescriptor.build(
+            provider: .codex,
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updateReady: false,
+            includeContextualActions: false)
+
+        let lines = self.textLines(from: descriptor)
+        #expect(!lines.contains(where: { $0.hasPrefix("Session:") }))
+        #expect(lines.contains(where: { $0.hasPrefix("Weekly:") }))
+    }
+
+    @Test
+    func `Codex menu does not surface identity from another provider snapshot`() {
+        let settings = self.makeSettingsStore(suite: "CodexPresentationCharacterizationTests-provider-silo")
+        settings.statusChecksEnabled = false
+
+        let fetcher = UsageFetcher(environment: [:])
+        let store = UsageStore(
+            fetcher: fetcher,
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(usedPercent: 12, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date(),
+                identity: ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: "codex@example.com",
+                    accountOrganization: nil,
+                    loginMethod: "free")),
+            provider: .codex)
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(usedPercent: 40, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date(),
+                identity: ProviderIdentitySnapshot(
+                    providerID: .claude,
+                    accountEmail: "claude@example.com",
+                    accountOrganization: nil,
+                    loginMethod: "max")),
+            provider: .claude)
+
+        let descriptor = MenuDescriptor.build(
+            provider: .codex,
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updateReady: false,
+            includeContextualActions: false)
+
+        let lines = self.textLines(from: descriptor)
+        #expect(lines.contains("Account: codex@example.com"))
+        #expect(lines.contains("Plan: Free"))
+        #expect(!lines.contains("Account: claude@example.com"))
+        #expect(!lines.contains("Plan: Max"))
+    }
+
+    @Test
+    func `Codex menu maps prolite plan to multiplier display name`() {
+        let settings = self.makeSettingsStore(suite: "CodexPresentationCharacterizationTests-prolite")
+        settings.statusChecksEnabled = false
+
+        let fetcher = UsageFetcher(environment: [:])
+        let store = UsageStore(
+            fetcher: fetcher,
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(usedPercent: 12, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date(),
+                identity: ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: "codex@example.com",
+                    accountOrganization: nil,
+                    loginMethod: "prolite")),
+            provider: .codex)
+
+        let descriptor = MenuDescriptor.build(
+            provider: .codex,
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updateReady: false,
+            includeContextualActions: false)
+
+        let lines = self.textLines(from: descriptor)
+        #expect(lines.contains("Plan: Pro 5x"))
+        #expect(!lines.contains("Plan: Pro Lite"))
+        #expect(!lines.contains("Plan: Prolite"))
+    }
+
+    @Test
+    func `Codex menu prefers snapshot identity over conflicting fallback account info`() throws {
+        let settings = self.makeSettingsStore(suite: "CodexPresentationCharacterizationTests-snapshot-precedence")
+        settings.statusChecksEnabled = false
+        let managedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-presentation-fallback-\(UUID().uuidString)", isDirectory: true)
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "fallback@example.com",
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        try Self.writeCodexAuthFile(homeURL: managedHome, email: "fallback@example.com", plan: "plus")
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings._test_activeManagedCodexRemoteHomePath = managedHome.path
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+        defer {
+            settings._test_activeManagedCodexAccount = nil
+            settings._test_activeManagedCodexRemoteHomePath = nil
+            try? FileManager.default.removeItem(at: managedHome)
+        }
+
+        let fetcher = UsageFetcher(environment: [:])
+        let store = UsageStore(
+            fetcher: fetcher,
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(usedPercent: 12, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date(),
+                identity: ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: "snapshot@example.com",
+                    accountOrganization: nil,
+                    loginMethod: "enterprise")),
+            provider: .codex)
+
+        let fallback = store.accountInfo(for: .codex)
+        #expect(fallback.email == "fallback@example.com")
+        #expect(fallback.plan == "plus")
+
+        let descriptor = MenuDescriptor.build(
+            provider: .codex,
+            store: store,
+            settings: settings,
+            account: AccountInfo(email: nil, plan: nil),
+            updateReady: false,
+            includeContextualActions: false)
+
+        let lines = self.textLines(from: descriptor)
+        #expect(lines.contains("Account: snapshot@example.com"))
+        #expect(lines.contains("Plan: Enterprise"))
+        #expect(!lines.contains("Account: fallback@example.com"))
+        #expect(!lines.contains("Plan: Plus"))
+    }
+
+    @Test
+    func `Codex menu falls back per field when snapshot identity is partial`() {
+        let settings = self.makeSettingsStore(suite: "CodexPresentationCharacterizationTests-partial-fallback")
+        settings.statusChecksEnabled = false
+        let managedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-presentation-partial-\(UUID().uuidString)", isDirectory: true)
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "fallback@example.com",
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        try? Self.writeCodexAuthFile(homeURL: managedHome, email: "fallback@example.com", plan: "plus")
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings._test_activeManagedCodexRemoteHomePath = managedHome.path
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+        defer {
+            settings._test_activeManagedCodexAccount = nil
+            settings._test_activeManagedCodexRemoteHomePath = nil
+            try? FileManager.default.removeItem(at: managedHome)
+        }
+
+        let fetcher = UsageFetcher(environment: [:])
+        let store = UsageStore(
+            fetcher: fetcher,
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(usedPercent: 12, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date(),
+                identity: ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: "snapshot@example.com",
+                    accountOrganization: nil,
+                    loginMethod: nil)),
+            provider: .codex)
+
+        let descriptor = MenuDescriptor.build(
+            provider: .codex,
+            store: store,
+            settings: settings,
+            account: AccountInfo(email: nil, plan: nil),
+            updateReady: false,
+            includeContextualActions: false)
+
+        let lines = self.textLines(from: descriptor)
+        #expect(lines.contains("Account: snapshot@example.com"))
+        #expect(lines.contains("Plan: Plus"))
+        #expect(!lines.contains("Account: fallback@example.com"))
+    }
+
+    @Test
+    func `managed OpenAI web targeting uses active managed Codex identity and scope`() {
+        let settings = self.makeSettingsStore(suite: "CodexPresentationCharacterizationTests-managed-openai-web")
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-codex-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+        defer { settings._test_activeManagedCodexAccount = nil }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+
+        #expect(store.codexAccountEmailForOpenAIDashboard() == managedAccount.email)
+        #expect(store.codexCookieCacheScopeForOpenAIWeb() == .managedAccount(managedAccount.id))
+    }
+
+    @Test
+    func `live OpenAI web targeting uses live Codex identity without managed scope`() {
+        let settings = self.makeSettingsStore(suite: "CodexPresentationCharacterizationTests-live-openai-web")
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-codex-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let liveAccount = ObservedSystemCodexAccount(
+            email: "system@example.com",
+            codexHomePath: "/tmp/live-codex-home",
+            observedAt: Date())
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings._test_liveSystemCodexAccount = liveAccount
+        settings.codexActiveSource = .liveSystem
+        defer {
+            settings._test_activeManagedCodexAccount = nil
+            settings._test_liveSystemCodexAccount = nil
+        }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: ["CODEX_HOME": liveAccount.codexHomePath]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+
+        #expect(store.codexAccountEmailForOpenAIDashboard() == liveAccount.email)
+        #expect(store.codexAccountEmailForOpenAIDashboard() != managedAccount.email)
+        #expect(store.codexCookieCacheScopeForOpenAIWeb() == nil)
+    }
+
+    @Test
+    func `same email managed and live Codex resolves to live for OpenAI web targeting`() {
+        let settings = self.makeSettingsStore(suite: "CodexPresentationCharacterizationTests-same-email-prefers-live")
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "person@example.com",
+            managedHomePath: "/tmp/managed-codex-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let liveAccount = ObservedSystemCodexAccount(
+            email: "PERSON@example.com",
+            codexHomePath: "/tmp/live-codex-home",
+            observedAt: Date())
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings._test_liveSystemCodexAccount = liveAccount
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+        defer {
+            settings._test_activeManagedCodexAccount = nil
+            settings._test_liveSystemCodexAccount = nil
+        }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: ["CODEX_HOME": liveAccount.codexHomePath]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+
+        #expect(settings.codexResolvedActiveSource == .liveSystem)
+        #expect(store.codexAccountEmailForOpenAIDashboard() == "person@example.com")
+        #expect(store.codexAccountEmailForOpenAIDashboard() != liveAccount.email)
+        #expect(store.codexCookieCacheScopeForOpenAIWeb() == nil)
+    }
+
+    @Test
+    func `live OpenAI web targeting does not reuse stale managed Codex snapshot identity`() {
+        let settings = self.makeSettingsStore(suite: "CodexPresentationCharacterizationTests-stale-managed-snapshot")
+        let isolatedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-presentation-openai-web-\(UUID().uuidString)", isDirectory: true)
+        try? FileManager.default.createDirectory(at: isolatedHome, withIntermediateDirectories: true)
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-codex-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings._test_codexReconciliationEnvironment = ["CODEX_HOME": isolatedHome.path]
+        settings.codexActiveSource = .liveSystem
+        defer {
+            settings._test_activeManagedCodexAccount = nil
+            settings._test_codexReconciliationEnvironment = nil
+            try? FileManager.default.removeItem(at: isolatedHome)
+        }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: nil,
+                secondary: nil,
+                updatedAt: Date(),
+                identity: ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: managedAccount.email,
+                    accountOrganization: nil,
+                    loginMethod: nil)),
+            provider: .codex)
+
+        #expect(store.codexAccountEmailForOpenAIDashboard() == nil)
+        #expect(store.codexAccountEmailForOpenAIDashboard() != managedAccount.email)
+        #expect(store.codexCookieCacheScopeForOpenAIWeb() == nil)
+    }
+
+    @Test
+    func `zai menu descriptor includes Tokens MCP and 5-hour rows`() {
+        let settings = self.makeSettingsStore(suite: "CodexPresentationCharacterizationTests-zai-three-quota")
+        settings.statusChecksEnabled = false
+
+        let fetcher = UsageFetcher(environment: [:])
+        let store = UsageStore(
+            fetcher: fetcher,
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 9,
+                    windowMinutes: 10080,
+                    resetsAt: nil,
+                    resetDescription: nil),
+                secondary: RateWindow(
+                    usedPercent: 50,
+                    windowMinutes: nil,
+                    resetsAt: nil,
+                    resetDescription: nil),
+                tertiary: RateWindow(
+                    usedPercent: 25,
+                    windowMinutes: 300,
+                    resetsAt: nil,
+                    resetDescription: nil),
+                updatedAt: Date(),
+                identity: ProviderIdentitySnapshot(
+                    providerID: .zai,
+                    accountEmail: nil,
+                    accountOrganization: nil,
+                    loginMethod: "pro")),
+            provider: .zai)
+
+        let descriptor = MenuDescriptor.build(
+            provider: .zai,
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updateReady: false,
+            includeContextualActions: false)
+
+        let lines = self.textLines(from: descriptor)
+        #expect(lines.contains(where: { $0.hasPrefix("Tokens:") }))
+        #expect(lines.contains(where: { $0.hasPrefix("MCP:") }))
+        #expect(lines.contains(where: { $0.hasPrefix("5-hour:") }))
+    }
+
+    private func makeSettingsStore(suite: String) -> SettingsStore {
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings._test_activeManagedCodexAccount = nil
+        settings._test_activeManagedCodexRemoteHomePath = nil
+        settings._test_unreadableManagedCodexAccountStore = false
+        settings._test_managedCodexAccountStoreURL = nil
+        settings._test_liveSystemCodexAccount = nil
+        settings._test_codexReconciliationEnvironment = nil
+        return settings
+    }
+
+    private func textLines(from descriptor: MenuDescriptor) -> [String] {
+        descriptor.sections
+            .flatMap(\.entries)
+            .compactMap { entry -> String? in
+                guard case let .text(text, _) = entry else { return nil }
+                return text
+            }
+    }
+
+    private static func writeCodexAuthFile(homeURL: URL, email: String, plan: String) throws {
+        try FileManager.default.createDirectory(at: homeURL, withIntermediateDirectories: true)
+        let auth = [
+            "tokens": [
+                "accessToken": "access-token",
+                "refreshToken": "refresh-token",
+                "idToken": Self.fakeJWT(email: email, plan: plan),
+            ],
+        ]
+        let data = try JSONSerialization.data(withJSONObject: auth)
+        try data.write(to: homeURL.appendingPathComponent("auth.json"))
+    }
+
+    private static func fakeJWT(email: String, plan: String) -> String {
+        let header = (try? JSONSerialization.data(withJSONObject: ["alg": "none"])) ?? Data()
+        let payload = (try? JSONSerialization.data(withJSONObject: [
+            "email": email,
+            "chatgpt_plan_type": plan,
+        ])) ?? Data()
+
+        func base64URL(_ data: Data) -> String {
+            data.base64EncodedString()
+                .replacingOccurrences(of: "=", with: "")
+                .replacingOccurrences(of: "+", with: "-")
+                .replacingOccurrences(of: "/", with: "_")
+        }
+
+        return "\(base64URL(header)).\(base64URL(payload))."
+    }
+}
diff --git a/Tests/CodexBarTests/CodexProfileHomeAccountTests.swift b/Tests/CodexBarTests/CodexProfileHomeAccountTests.swift
new file mode 100644
index 0000000000..25dc2983a3
--- /dev/null
+++ b/Tests/CodexBarTests/CodexProfileHomeAccountTests.swift
@@ -0,0 +1,398 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@Suite(.serialized)
+struct CodexProfileHomeAccountTests {
+    @MainActor
+    private static func makeSettings(suite: String) throws -> SettingsStore {
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        defaults.set(true, forKey: "providerDetectionCompleted")
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.providerDetectionCompleted = true
+        return settings
+    }
+
+    @Test
+    @MainActor
+    func `settings store discovers configured codex profile homes`() throws {
+        let suite = "CodexProfileHomeAccountTests-discovery"
+        let settings = try Self.makeSettings(suite: suite)
+        let missingLiveHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        let profileHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        try Self.writeCodexAuthFile(
+            homeURL: profileHome,
+            email: "Profile@Example.com",
+            plan: "pro",
+            accountID: "acct_profile")
+        settings._test_codexReconciliationEnvironment = ["CODEX_HOME": missingLiveHome.path]
+        settings.updateProviderConfig(provider: .codex) { entry in
+            entry.codexProfileHomePaths = [profileHome.path, profileHome.path]
+        }
+        settings.codexActiveSource = .profileHome(path: profileHome.path)
+        defer {
+            settings._test_codexReconciliationEnvironment = nil
+            try? FileManager.default.removeItem(at: missingLiveHome)
+            try? FileManager.default.removeItem(at: profileHome)
+        }
+
+        let normalizedProfilePath = try #require(CodexHomeScope.normalizedHomePath(profileHome.path))
+        let snapshot = settings.codexAccountReconciliationSnapshot
+        let projection = settings.codexVisibleAccountProjection
+
+        #expect(settings.codexResolvedActiveSource == .profileHome(path: normalizedProfilePath))
+        #expect(snapshot.liveSystemAccount == nil)
+        #expect(snapshot.profileHomeAccounts.map(\.email) == ["profile@example.com"])
+        #expect(snapshot.profileHomeAccounts.map(\.codexHomePath) == [normalizedProfilePath])
+        #expect(snapshot.profileHomePaths == [normalizedProfilePath])
+        #expect(projection.visibleAccounts.map(\.email) == ["profile@example.com"])
+        #expect(projection.activeVisibleAccountID == "profile@example.com")
+        #expect(projection.liveVisibleAccountID == nil)
+        #expect(projection.visibleAccounts.first?.selectionSource == .profileHome(path: normalizedProfilePath))
+        #expect(projection.visibleAccounts.first?.isLive == false)
+        #expect(projection.visibleAccounts.first?.canReauthenticate == false)
+        #expect(projection.visibleAccounts.first?.canRemove == false)
+    }
+
+    @Test
+    @MainActor
+    func `provider registry scopes selected codex profile home`() throws {
+        let suite = "CodexProfileHomeAccountTests-routing"
+        let settings = try Self.makeSettings(suite: suite)
+        let profileHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        try Self.writeCodexAuthFile(
+            homeURL: profileHome,
+            email: "profile-route@example.com",
+            plan: "pro")
+        settings.updateProviderConfig(provider: .codex) { entry in
+            entry.codexProfileHomePaths = [profileHome.path]
+            entry.codexActiveSource = .profileHome(path: profileHome.path)
+        }
+        defer {
+            try? FileManager.default.removeItem(at: profileHome)
+        }
+
+        let normalizedProfilePath = try #require(CodexHomeScope.normalizedHomePath(profileHome.path))
+        let environment = ProviderRegistry.makeEnvironment(
+            base: ["CODEX_HOME": "/tmp/ambient-codex"],
+            provider: .codex,
+            settings: settings,
+            tokenOverride: nil)
+
+        #expect(environment["CODEX_HOME"] == normalizedProfilePath)
+    }
+
+    @Test
+    @MainActor
+    func `removed profile home falls back without routing stale path`() throws {
+        let suite = "CodexProfileHomeAccountTests-stale-routing"
+        let settings = try Self.makeSettings(suite: suite)
+        let missingLiveHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        let removedProfileHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        settings._test_codexReconciliationEnvironment = ["CODEX_HOME": missingLiveHome.path]
+        settings.updateProviderConfig(provider: .codex) { entry in
+            entry.codexProfileHomePaths = []
+            entry.codexActiveSource = .profileHome(path: removedProfileHome.path)
+        }
+        defer {
+            settings._test_codexReconciliationEnvironment = nil
+            try? FileManager.default.removeItem(at: missingLiveHome)
+            try? FileManager.default.removeItem(at: removedProfileHome)
+        }
+
+        let environment = ProviderRegistry.makeEnvironment(
+            base: ["CODEX_HOME": "/tmp/ambient-codex"],
+            provider: .codex,
+            settings: settings,
+            tokenOverride: nil)
+
+        #expect(settings.codexResolvedActiveSource == .liveSystem)
+        #expect(environment["CODEX_HOME"] == "/tmp/ambient-codex")
+        let staleOverrideEnvironment = ProviderRegistry.makeEnvironment(
+            base: ["CODEX_HOME": "/tmp/ambient-codex"],
+            provider: .codex,
+            settings: settings,
+            tokenOverride: nil,
+            codexActiveSourceOverride: .profileHome(path: removedProfileHome.path))
+        #expect(staleOverrideEnvironment["CODEX_HOME"] == "/tmp/ambient-codex")
+        #expect(settings.persistResolvedCodexActiveSourceCorrectionIfNeeded())
+        #expect(settings.codexActiveSource == .liveSystem)
+    }
+
+    @Test
+    @MainActor
+    func `external config removal immediately invalidates profile routing caches`() throws {
+        let suite = "CodexProfileHomeAccountTests-external-removal"
+        let settings = try Self.makeSettings(suite: suite)
+        let missingLiveHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        let profileHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        try Self.writeCodexAuthFile(
+            homeURL: profileHome,
+            email: "profile-cache@example.com",
+            plan: "pro")
+        let previousInterval = SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting
+        SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = 60
+        settings._test_codexReconciliationEnvironment = ["CODEX_HOME": missingLiveHome.path]
+        defer {
+            SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = previousInterval
+            settings._test_codexReconciliationEnvironment = nil
+            try? FileManager.default.removeItem(at: missingLiveHome)
+            try? FileManager.default.removeItem(at: profileHome)
+        }
+
+        settings.updateProviderConfig(provider: .codex) { entry in
+            entry.codexProfileHomePaths = [profileHome.path]
+            entry.codexActiveSource = .profileHome(path: profileHome.path)
+        }
+        _ = settings.codexAccountReconciliationSnapshot
+        #expect(settings.cachedCodexAccountReconciliationSnapshot != nil)
+        #expect(settings.cachedCodexAccountMenuProjection != nil)
+
+        settings.applyExternalConfig(
+            CodexBarConfig(providers: [
+                ProviderConfig(
+                    id: .codex,
+                    codexActiveSource: .profileHome(path: profileHome.path),
+                    codexProfileHomePaths: []),
+            ]),
+            reason: "profile-removed")
+
+        #expect(settings.cachedCodexAccountReconciliationSnapshot == nil)
+        #expect(settings.cachedCodexAccountMenuProjection == nil)
+        let environment = ProviderRegistry.makeEnvironment(
+            base: ["CODEX_HOME": "/tmp/ambient-codex"],
+            provider: .codex,
+            settings: settings,
+            tokenOverride: nil)
+        #expect(settings.codexResolvedActiveSource == .liveSystem)
+        #expect(environment["CODEX_HOME"] == "/tmp/ambient-codex")
+    }
+
+    @Test
+    @MainActor
+    func `relative profile homes are ignored by app routing`() throws {
+        let settings = try Self.makeSettings(suite: "CodexProfileHomeAccountTests-relative")
+        settings.updateProviderConfig(provider: .codex) { entry in
+            entry.codexProfileHomePaths = ["relative-codex-home", "~someone/.codex"]
+            entry.codexActiveSource = .profileHome(path: "relative-codex-home")
+        }
+
+        #expect(CodexHomeScope.normalizedHomePath("relative-codex-home") == nil)
+        #expect(CodexHomeScope.normalizedHomePath("~someone/.codex") == nil)
+        #expect(settings.codexProfileHomePaths.isEmpty)
+        let environment = ProviderRegistry.makeEnvironment(
+            base: ["CODEX_HOME": "/tmp/ambient-codex"],
+            provider: .codex,
+            settings: settings,
+            tokenOverride: nil,
+            codexActiveSourceOverride: .profileHome(path: "relative-codex-home"))
+        #expect(environment["CODEX_HOME"] == "/tmp/ambient-codex")
+    }
+
+    @Test
+    @MainActor
+    func `unreadable configured profile home remains selected and routed`() throws {
+        let suite = "CodexProfileHomeAccountTests-unreadable-routing"
+        let settings = try Self.makeSettings(suite: suite)
+        let missingLiveHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        let unreadableProfileHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        settings._test_codexReconciliationEnvironment = ["CODEX_HOME": missingLiveHome.path]
+        settings.updateProviderConfig(provider: .codex) { entry in
+            entry.codexProfileHomePaths = [unreadableProfileHome.path]
+            entry.codexActiveSource = .profileHome(path: unreadableProfileHome.path)
+        }
+        defer {
+            settings._test_codexReconciliationEnvironment = nil
+            try? FileManager.default.removeItem(at: missingLiveHome)
+            try? FileManager.default.removeItem(at: unreadableProfileHome)
+        }
+
+        let normalizedProfilePath = try #require(CodexHomeScope.normalizedHomePath(unreadableProfileHome.path))
+        let environment = ProviderRegistry.makeEnvironment(
+            base: ["CODEX_HOME": "/tmp/ambient-codex"],
+            provider: .codex,
+            settings: settings,
+            tokenOverride: nil)
+
+        #expect(settings.codexResolvedActiveSource == .profileHome(path: normalizedProfilePath))
+        #expect(settings.codexAccountReconciliationSnapshot.profileHomeAccounts.isEmpty)
+        #expect(environment["CODEX_HOME"] == normalizedProfilePath)
+        #expect(!settings.persistResolvedCodexActiveSourceCorrectionIfNeeded())
+        #expect(settings.codexActiveSource == .profileHome(path: normalizedProfilePath))
+    }
+
+    @Test
+    @MainActor
+    func `profile without verified email refuses open A I cookie import`() async throws {
+        let suite = "CodexProfileHomeAccountTests-missing-web-email"
+        let settings = try Self.makeSettings(suite: suite)
+        let missingLiveHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        let unreadableProfileHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        settings._test_codexReconciliationEnvironment = ["CODEX_HOME": missingLiveHome.path]
+        settings.updateProviderConfig(provider: .codex) { entry in
+            entry.codexProfileHomePaths = [unreadableProfileHome.path]
+            entry.codexActiveSource = .profileHome(path: unreadableProfileHome.path)
+        }
+        defer {
+            settings._test_codexReconciliationEnvironment = nil
+            try? FileManager.default.removeItem(at: missingLiveHome)
+            try? FileManager.default.removeItem(at: unreadableProfileHome)
+        }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: ["CODEX_HOME": missingLiveHome.path]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        var importAttempts = 0
+        store._test_openAIDashboardCookieImportOverride = { _, _, _, _, _ in
+            importAttempts += 1
+            return OpenAIDashboardBrowserCookieImporter.ImportResult(
+                sourceLabel: "test",
+                cookieCount: 1,
+                signedInEmail: "other@example.com",
+                matchesCodexEmail: false)
+        }
+
+        let imported = await store.importOpenAIDashboardCookiesIfNeeded(targetEmail: nil, force: true)
+
+        #expect(imported == nil)
+        #expect(importAttempts == 0)
+        #expect(store.openAIDashboardRequiresLogin)
+        #expect(store.openAIDashboardCookieImportStatus?.contains("no verified account email") == true)
+    }
+
+    @Test
+    @MainActor
+    func `profile home matching live home resolves to visible live account`() throws {
+        let suite = "CodexProfileHomeAccountTests-live-duplicate"
+        let settings = try Self.makeSettings(suite: suite)
+        let liveHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        let liveAccount = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: liveHome.path,
+            observedAt: Date())
+        settings._test_liveSystemCodexAccount = liveAccount
+        settings.updateProviderConfig(provider: .codex) { entry in
+            entry.codexProfileHomePaths = [liveHome.path]
+            entry.codexActiveSource = .profileHome(path: liveHome.path)
+        }
+        defer {
+            settings._test_liveSystemCodexAccount = nil
+        }
+
+        let projection = settings.codexVisibleAccountProjection
+
+        #expect(settings.codexResolvedActiveSource == .liveSystem)
+        #expect(projection.visibleAccounts.map(\.email) == ["live@example.com"])
+        #expect(projection.activeVisibleAccountID == "live@example.com")
+        #expect(settings.persistResolvedCodexActiveSourceCorrectionIfNeeded())
+        #expect(settings.codexActiveSource == .liveSystem)
+    }
+
+    @Test
+    @MainActor
+    func `profile home matching managed home resolves to visible managed account`() throws {
+        let suite = "CodexProfileHomeAccountTests-managed-duplicate"
+        let settings = try Self.makeSettings(suite: suite)
+        let managedHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 3)
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings.updateProviderConfig(provider: .codex) { entry in
+            entry.codexProfileHomePaths = [managedHome.path]
+            entry.codexActiveSource = .profileHome(path: managedHome.path)
+        }
+        defer {
+            settings._test_activeManagedCodexAccount = nil
+        }
+
+        let projection = settings.codexVisibleAccountProjection
+
+        #expect(settings.codexResolvedActiveSource == .managedAccount(id: managedAccount.id))
+        #expect(projection.visibleAccounts.map(\.email) == ["managed@example.com"])
+        #expect(projection.activeVisibleAccountID == "managed@example.com")
+        #expect(settings.persistResolvedCodexActiveSourceCorrectionIfNeeded())
+        #expect(settings.codexActiveSource == .managedAccount(id: managedAccount.id))
+    }
+
+    private static func writeCodexAuthFile(
+        homeURL: URL,
+        email: String,
+        plan: String,
+        accountID: String? = nil) throws
+    {
+        try FileManager.default.createDirectory(at: homeURL, withIntermediateDirectories: true)
+        var tokens: [String: Any] = [
+            "accessToken": "access-token",
+            "refreshToken": "refresh-token",
+            "idToken": Self.fakeJWT(email: email, plan: plan, accountID: accountID),
+        ]
+        if let accountID {
+            tokens["account_id"] = accountID
+        }
+        let auth = ["tokens": tokens]
+        let data = try JSONSerialization.data(withJSONObject: auth)
+        try data.write(to: homeURL.appendingPathComponent("auth.json"))
+    }
+
+    private static func fakeJWT(email: String, plan: String, accountID: String? = nil) -> String {
+        let header = (try? JSONSerialization.data(withJSONObject: ["alg": "none"])) ?? Data()
+        var payloadObject: [String: Any] = [
+            "email": email,
+            "chatgpt_plan_type": plan,
+        ]
+        if let accountID {
+            payloadObject["https://api.openai.com/auth"] = [
+                "chatgpt_account_id": accountID,
+            ]
+        }
+        let payload = (try? JSONSerialization.data(withJSONObject: payloadObject)) ?? Data()
+
+        func base64URL(_ data: Data) -> String {
+            data.base64EncodedString()
+                .replacingOccurrences(of: "=", with: "")
+                .replacingOccurrences(of: "+", with: "-")
+                .replacingOccurrences(of: "/", with: "_")
+        }
+
+        return "\(base64URL(header)).\(base64URL(payload))."
+    }
+}
diff --git a/Tests/CodexBarTests/CodexProviderSettingsBuilderTests.swift b/Tests/CodexBarTests/CodexProviderSettingsBuilderTests.swift
new file mode 100644
index 0000000000..ba85f3aaa9
--- /dev/null
+++ b/Tests/CodexBarTests/CodexProviderSettingsBuilderTests.swift
@@ -0,0 +1,200 @@
+import CodexBarCore
+import Foundation
+import Testing
+
+struct CodexProviderSettingsBuilderTests {
+    @Test
+    func `builder keeps managed store unreadable fail closed when selection resolves back to live system`() {
+        let selectedManagedID = UUID()
+        let snapshot = CodexAccountReconciliationSnapshot(
+            storedAccounts: [],
+            activeStoredAccount: nil,
+            liveSystemAccount: ObservedSystemCodexAccount(
+                email: "live@example.com",
+                codexHomePath: "/tmp/live",
+                observedAt: Date(),
+                identity: .providerAccount(id: "acct-live")),
+            matchingStoredAccountForLiveSystemAccount: nil,
+            activeSource: .managedAccount(id: selectedManagedID),
+            hasUnreadableAddedAccountStore: true)
+
+        let settings = CodexProviderSettingsBuilder.make(input: CodexProviderSettingsBuilderInput(
+            usageDataSource: .auto,
+            cookieSource: .auto,
+            manualCookieHeader: nil,
+            reconciliationSnapshot: snapshot,
+            resolvedActiveSource: CodexActiveSourceResolver.resolve(from: snapshot)))
+
+        #expect(settings.managedAccountStoreUnreadable == true)
+        #expect(settings.managedAccountTargetUnavailable == false)
+    }
+
+    @Test
+    func `builder marks missing selected managed account as unavailable`() {
+        let selectedManagedID = UUID()
+        let otherStoredAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "other@example.com",
+            managedHomePath: "/tmp/other",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 3)
+        let snapshot = CodexAccountReconciliationSnapshot(
+            storedAccounts: [otherStoredAccount],
+            activeStoredAccount: nil,
+            liveSystemAccount: nil,
+            matchingStoredAccountForLiveSystemAccount: nil,
+            activeSource: .managedAccount(id: selectedManagedID),
+            hasUnreadableAddedAccountStore: false)
+
+        let settings = CodexProviderSettingsBuilder.make(input: CodexProviderSettingsBuilderInput(
+            usageDataSource: .auto,
+            cookieSource: .auto,
+            manualCookieHeader: nil,
+            reconciliationSnapshot: snapshot,
+            resolvedActiveSource: CodexActiveSourceResolver.resolve(from: snapshot)))
+
+        #expect(settings.managedAccountStoreUnreadable == false)
+        #expect(settings.managedAccountTargetUnavailable == true)
+    }
+
+    @Test
+    func `builder keeps missing managed target fail closed when selection resolves back to live system`() {
+        let selectedManagedID = UUID()
+        let otherStoredAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "other@example.com",
+            managedHomePath: "/tmp/other",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 3)
+        let snapshot = CodexAccountReconciliationSnapshot(
+            storedAccounts: [otherStoredAccount],
+            activeStoredAccount: nil,
+            liveSystemAccount: ObservedSystemCodexAccount(
+                email: "live@example.com",
+                codexHomePath: "/tmp/live",
+                observedAt: Date(),
+                identity: .providerAccount(id: "acct-live")),
+            matchingStoredAccountForLiveSystemAccount: nil,
+            activeSource: .managedAccount(id: selectedManagedID),
+            hasUnreadableAddedAccountStore: false)
+
+        let settings = CodexProviderSettingsBuilder.make(input: CodexProviderSettingsBuilderInput(
+            usageDataSource: .auto,
+            cookieSource: .auto,
+            manualCookieHeader: nil,
+            reconciliationSnapshot: snapshot,
+            resolvedActiveSource: CodexActiveSourceResolver.resolve(from: snapshot)))
+
+        #expect(settings.managedAccountStoreUnreadable == false)
+        #expect(settings.managedAccountTargetUnavailable == true)
+    }
+
+    @Test
+    func `builder marks profile without observed account as unavailable`() {
+        let profilePath = "/tmp/codex-profile-missing-auth"
+        let snapshot = CodexAccountReconciliationSnapshot(
+            storedAccounts: [],
+            activeStoredAccount: nil,
+            liveSystemAccount: nil,
+            profileHomeAccounts: [],
+            profileHomePaths: [profilePath],
+            matchingStoredAccountForLiveSystemAccount: nil,
+            activeSource: .profileHome(path: profilePath),
+            hasUnreadableAddedAccountStore: false)
+
+        let settings = CodexProviderSettingsBuilder.make(input: CodexProviderSettingsBuilderInput(
+            usageDataSource: .auto,
+            cookieSource: .auto,
+            manualCookieHeader: nil,
+            reconciliationSnapshot: snapshot,
+            resolvedActiveSource: CodexActiveSourceResolver.resolve(from: snapshot)))
+
+        #expect(settings.profileAccountTargetUnavailable)
+        #expect(settings.openAIWebCacheScope == .profileHome(profilePath))
+    }
+
+    @Test
+    func `known owner catalog includes runtime managed and live identities`() {
+        let storedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 3)
+        let liveSystemAccount = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: "/tmp/live",
+            observedAt: Date(),
+            identity: .providerAccount(id: "acct-live"))
+        let snapshot = CodexAccountReconciliationSnapshot(
+            storedAccounts: [storedAccount],
+            activeStoredAccount: storedAccount,
+            liveSystemAccount: liveSystemAccount,
+            matchingStoredAccountForLiveSystemAccount: nil,
+            activeSource: .managedAccount(id: storedAccount.id),
+            hasUnreadableAddedAccountStore: false,
+            storedAccountRuntimeIdentities: [storedAccount.id: .providerAccount(id: "acct-managed")],
+            storedAccountRuntimeEmails: [storedAccount.id: "managed-runtime@example.com"])
+
+        let candidates = CodexKnownOwnerCatalog.candidates(from: snapshot)
+
+        #expect(candidates.count == 2)
+        #expect(candidates.contains(CodexDashboardKnownOwnerCandidate(
+            identity: .providerAccount(id: "acct-managed"),
+            normalizedEmail: "managed-runtime@example.com")))
+        #expect(candidates.contains(CodexDashboardKnownOwnerCandidate(
+            identity: .providerAccount(id: "acct-live"),
+            normalizedEmail: "live@example.com")))
+    }
+
+    @Test
+    func `builder preserves same email profile owners and scopes web cache`() {
+        let profileA = ObservedSystemCodexAccount(
+            email: "shared@example.com",
+            codexHomePath: "/tmp/codex-profile-a",
+            observedAt: Date(),
+            identity: .emailOnly(normalizedEmail: "shared@example.com"))
+        let profileB = ObservedSystemCodexAccount(
+            email: "shared@example.com",
+            codexHomePath: "/tmp/codex-profile-b",
+            observedAt: Date(),
+            identity: .emailOnly(normalizedEmail: "shared@example.com"))
+        let snapshot = CodexAccountReconciliationSnapshot(
+            storedAccounts: [],
+            activeStoredAccount: nil,
+            liveSystemAccount: nil,
+            profileHomeAccounts: [profileA, profileB],
+            matchingStoredAccountForLiveSystemAccount: nil,
+            activeSource: .profileHome(path: profileA.codexHomePath),
+            hasUnreadableAddedAccountStore: false)
+
+        let settings = CodexProviderSettingsBuilder.make(input: CodexProviderSettingsBuilderInput(
+            usageDataSource: .auto,
+            cookieSource: .auto,
+            manualCookieHeader: nil,
+            reconciliationSnapshot: snapshot,
+            resolvedActiveSource: CodexActiveSourceResolver.resolve(from: snapshot)))
+
+        #expect(settings.openAIWebCacheScope == .profileHome(profileA.codexHomePath))
+        #expect(!settings.profileAccountTargetUnavailable)
+        #expect(settings.dashboardAuthorityKnownOwners.count == 2)
+        #expect(Set(settings.dashboardAuthorityKnownOwners.map(\.sourceIsolationIdentifier)).count == 2)
+
+        let decision = CodexDashboardAuthority.evaluate(CodexDashboardAuthorityInput(
+            sourceKind: .liveWeb,
+            proof: CodexDashboardOwnershipProofContext(
+                currentIdentity: .emailOnly(normalizedEmail: "shared@example.com"),
+                expectedScopedEmail: "shared@example.com",
+                trustedCurrentUsageEmail: nil,
+                dashboardSignedInEmail: "shared@example.com",
+                knownOwners: settings.dashboardAuthorityKnownOwners),
+            routing: CodexDashboardRoutingHints(
+                targetEmail: "shared@example.com",
+                lastKnownDashboardRoutingEmail: nil)))
+        #expect(decision.disposition == .displayOnly)
+        #expect(decision.reason == .sameEmailAmbiguity(email: "shared@example.com"))
+    }
+}
diff --git a/Tests/CodexBarTests/CodexRateLimitResetCreditsTests.swift b/Tests/CodexBarTests/CodexRateLimitResetCreditsTests.swift
new file mode 100644
index 0000000000..cade97d1a5
--- /dev/null
+++ b/Tests/CodexBarTests/CodexRateLimitResetCreditsTests.swift
@@ -0,0 +1,131 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+struct CodexRateLimitResetCreditsTests {
+    @Test
+    func `resolves URL from chat GPT config`() {
+        let config = "chatgpt_base_url = \"https://chatgpt.com/backend-api/\"\n"
+        let url = CodexOAuthUsageFetcher._resolveRateLimitResetCreditsURLForTesting(configContents: config)
+        #expect(url.absoluteString == "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits")
+    }
+
+    @Test
+    func `request scopes auth and account with bounded timeout`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            #expect(request.url?.absoluteString == "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits")
+            #expect(request.httpMethod == "GET")
+            #expect(request.timeoutInterval == 4)
+            #expect(request.value(forHTTPHeaderField: "Authorization") == "Bearer test-token")
+            #expect(request.value(forHTTPHeaderField: "ChatGPT-Account-ID") == "account-123")
+            #expect(request.value(forHTTPHeaderField: "OpenAI-Beta") == "codex-1")
+            #expect(request.value(forHTTPHeaderField: "originator") == "Codex Desktop")
+            let url = try #require(request.url)
+            let response = try #require(HTTPURLResponse(
+                url: url,
+                statusCode: 200,
+                httpVersion: nil,
+                headerFields: nil))
+            return (Data(#"{"credits":[],"available_count":0}"#.utf8), response)
+        }
+
+        let snapshot = try await CodexOAuthUsageFetcher.fetchRateLimitResetCredits(
+            accessToken: "test-token",
+            accountId: "account-123",
+            env: ["CODEX_HOME": "/tmp/codexbar-reset-credit-request-test"],
+            session: transport)
+
+        #expect(snapshot.availableCount == 0)
+        #expect(await transport.requests().count == 1)
+    }
+
+    @Test
+    func `rejects negative available count`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            let response = try #require(HTTPURLResponse(
+                url: url,
+                statusCode: 200,
+                httpVersion: nil,
+                headerFields: nil))
+            return (Data(#"{"credits":[],"available_count":-1}"#.utf8), response)
+        }
+
+        do {
+            _ = try await CodexOAuthUsageFetcher.fetchRateLimitResetCredits(
+                accessToken: "test-token",
+                accountId: nil,
+                env: ["CODEX_HOME": "/tmp/codexbar-negative-reset-credit-test"],
+                session: transport)
+            Issue.record("Expected invalid response")
+        } catch CodexOAuthFetchError.invalidResponse {
+            // Expected.
+        } catch {
+            Issue.record("Unexpected error: \(error)")
+        }
+    }
+
+    @Test
+    func `decodes credits and skips stale available expiry`() throws {
+        let json = """
+        {
+          "credits": [
+            {
+              "id": "RateLimitResetCredit_expired_available",
+              "reset_type": "codex_rate_limits",
+              "status": "available",
+              "granted_at": "2026-05-18T00:39:53Z",
+              "expires_at": "2026-06-17T00:39:53Z"
+            },
+            {
+              "id": "RateLimitResetCredit_later",
+              "reset_type": "codex_rate_limits",
+              "status": "available",
+              "granted_at": "2026-06-18T00:39:53.731630Z",
+              "expires_at": "2026-07-18T00:39:53.731630Z",
+              "redeem_started_at": null,
+              "redeemed_at": null,
+              "profile_image_url": "https://example.com/codex.png",
+              "profile_user_id": "Codex Team",
+              "title": "One free rate limit reset",
+              "description": "Thanks for using Codex!"
+            },
+            {
+              "id": "RateLimitResetCredit_earlier",
+              "reset_type": "codex_rate_limits",
+              "status": "available",
+              "granted_at": "2026-06-12T04:03:43.263391Z",
+              "expires_at": "2026-07-12T04:03:43.263391Z",
+              "redeem_started_at": null,
+              "redeemed_at": null,
+              "title": "One free rate limit reset",
+              "description": "Thanks for using Codex!"
+            },
+            {
+              "id": "RateLimitResetCredit_future_status",
+              "reset_type": "codex_rate_limits",
+              "status": "future_status",
+              "granted_at": "2026-06-12T04:03:43Z",
+              "expires_at": "2026-07-10T04:03:43Z",
+              "redeem_started_at": null,
+              "redeemed_at": null,
+              "title": "One free rate limit reset",
+              "description": "Thanks for using Codex!"
+            }
+          ],
+          "available_count": 2
+        }
+        """
+
+        let snapshot = try CodexOAuthUsageFetcher._decodeRateLimitResetCreditsForTesting(Data(json.utf8))
+
+        #expect(snapshot.availableCount == 2)
+        #expect(snapshot.credits.count == 4)
+        #expect(snapshot.credits[0].resetType == "codex_rate_limits")
+        #expect(snapshot.credits[3].status == .unknown("future_status"))
+        #expect(snapshot.nextExpiringAvailableCredit?.id == "RateLimitResetCredit_earlier")
+    }
+}
diff --git a/Tests/CodexBarTests/CodexResetCreditsMenuCardTests.swift b/Tests/CodexBarTests/CodexResetCreditsMenuCardTests.swift
new file mode 100644
index 0000000000..4d5baae1bf
--- /dev/null
+++ b/Tests/CodexBarTests/CodexResetCreditsMenuCardTests.swift
@@ -0,0 +1,95 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct CodexResetCreditsMenuCardTests {
+    @Test
+    func `reset credits render when optional usage is enabled`() throws {
+        let metadata = try #require(ProviderDefaults.metadata[.codex])
+        let now = Date(timeIntervalSince1970: 1_781_726_400)
+        let usage = UsageSnapshot(
+            primary: RateWindow(usedPercent: 25, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            codexResetCredits: CodexRateLimitResetCreditsSnapshot(
+                credits: [
+                    CodexRateLimitResetCredit(
+                        id: "reset-1",
+                        resetType: "codex_rate_limits",
+                        status: .available,
+                        grantedAt: now,
+                        expiresAt: now.addingTimeInterval(86400),
+                        redeemStartedAt: nil,
+                        redeemedAt: nil,
+                        title: "One free rate limit reset",
+                        description: nil),
+                ],
+                availableCount: 1,
+                updatedAt: now),
+            updatedAt: now,
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: "user@example.com",
+                accountOrganization: nil,
+                loginMethod: "pro"))
+
+        let model = UsageMenuCardView.Model.make(Self.input(
+            metadata: metadata,
+            snapshot: usage,
+            showOptionalUsage: true,
+            now: now))
+
+        #expect(model.codexResetCreditsText == "1 manual reset available")
+        #expect(model.codexResetCreditsDetailText == "Next expires in 1d")
+    }
+
+    @Test
+    func `reset credits hide with optional usage disabled`() throws {
+        let metadata = try #require(ProviderDefaults.metadata[.codex])
+        let now = Date(timeIntervalSince1970: 1_781_726_400)
+        let usage = UsageSnapshot(
+            primary: RateWindow(usedPercent: 25, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            codexResetCredits: CodexRateLimitResetCreditsSnapshot(
+                credits: [],
+                availableCount: 2,
+                updatedAt: now),
+            updatedAt: now)
+
+        let model = UsageMenuCardView.Model.make(Self.input(
+            metadata: metadata,
+            snapshot: usage,
+            showOptionalUsage: false,
+            now: now))
+
+        #expect(model.codexResetCreditsText == nil)
+        #expect(model.codexResetCreditsDetailText == nil)
+    }
+
+    private static func input(
+        metadata: ProviderMetadata,
+        snapshot: UsageSnapshot,
+        showOptionalUsage: Bool,
+        now: Date) -> UsageMenuCardView.Model.Input
+    {
+        UsageMenuCardView.Model.Input(
+            provider: .codex,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: showOptionalUsage,
+            hidePersonalInfo: false,
+            now: now)
+    }
+}
diff --git a/Tests/CodexBarTests/CodexSystemAccountObserverTests.swift b/Tests/CodexBarTests/CodexSystemAccountObserverTests.swift
new file mode 100644
index 0000000000..6cb9db5ce7
--- /dev/null
+++ b/Tests/CodexBarTests/CodexSystemAccountObserverTests.swift
@@ -0,0 +1,132 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@Suite(.serialized)
+struct CodexSystemAccountObserverTests {
+    @Test
+    func `observer reads ambient CODEX_HOME when present`() throws {
+        let home = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: home) }
+        try Self.writeCodexAuthFile(
+            homeURL: home,
+            email: "  LIVE@Example.com  ",
+            plan: "pro",
+            accountId: "account-live")
+
+        let observer = DefaultCodexSystemAccountObserver()
+        let account = try observer.loadSystemAccount(environment: ["CODEX_HOME": home.path])
+
+        #expect(account?.email == "live@example.com")
+        #expect(account?.codexHomePath == home.path)
+        #expect(account?.identity == .providerAccount(id: "account-live"))
+    }
+
+    @Test
+    func `observer falls back to nil when ambient home has no readable email`() throws {
+        let home = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: home) }
+        try FileManager.default.createDirectory(at: home, withIntermediateDirectories: true)
+
+        let observer = DefaultCodexSystemAccountObserver()
+        let account = try observer.loadSystemAccount(environment: ["CODEX_HOME": home.path])
+
+        #expect(account == nil)
+    }
+
+    @Test
+    func `observer records observation timestamp`() throws {
+        let home = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: home) }
+        try Self.writeCodexAuthFile(homeURL: home, email: "user@example.com", plan: "team")
+
+        let before = Date()
+        let observer = DefaultCodexSystemAccountObserver()
+        let account = try observer.loadSystemAccount(environment: ["CODEX_HOME": home.path])
+        let observed = try #require(account)
+
+        #expect(observed.observedAt >= before)
+    }
+
+    @Test
+    func `observer preserves provider account identity from scoped auth`() throws {
+        let home = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: home) }
+        try Self.writeCodexAuthFile(
+            homeURL: home,
+            email: "user@example.com",
+            plan: "team",
+            accountId: "account-live-123")
+
+        let observer = DefaultCodexSystemAccountObserver()
+        let account = try #require(try observer.loadSystemAccount(environment: ["CODEX_HOME": home.path]))
+
+        #expect(account.identity == .providerAccount(id: "account-live-123"))
+    }
+
+    @Test
+    func `observer uses cached workspace label for provider account`() throws {
+        let home = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        let cacheURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-openai-workspaces-\(UUID().uuidString).json")
+        defer {
+            try? FileManager.default.removeItem(at: home)
+            try? FileManager.default.removeItem(at: cacheURL)
+        }
+        try Self.writeCodexAuthFile(
+            homeURL: home,
+            email: "user@example.com",
+            plan: "team",
+            accountId: "account-live-123")
+
+        try CodexOpenAIWorkspaceIdentityCache.withFileURLOverrideForTesting(cacheURL) {
+            try CodexOpenAIWorkspaceIdentityCache().store(CodexOpenAIWorkspaceIdentity(
+                workspaceAccountID: "account-live-123",
+                workspaceLabel: "Team Alpha"))
+
+            let observer = DefaultCodexSystemAccountObserver()
+            let account = try #require(try observer.loadSystemAccount(environment: ["CODEX_HOME": home.path]))
+
+            #expect(account.workspaceAccountID == "account-live-123")
+            #expect(account.workspaceLabel == "Team Alpha")
+        }
+    }
+
+    private static func writeCodexAuthFile(
+        homeURL: URL,
+        email: String,
+        plan: String,
+        accountId: String? = nil) throws
+    {
+        try FileManager.default.createDirectory(at: homeURL, withIntermediateDirectories: true)
+        var tokens: [String: Any] = [
+            "accessToken": "access-token",
+            "refreshToken": "refresh-token",
+            "idToken": Self.fakeJWT(email: email, plan: plan),
+        ]
+        if let accountId {
+            tokens["accountId"] = accountId
+        }
+        let auth = ["tokens": tokens]
+        let data = try JSONSerialization.data(withJSONObject: auth)
+        try data.write(to: homeURL.appendingPathComponent("auth.json"))
+    }
+
+    private static func fakeJWT(email: String, plan: String) -> String {
+        let header = (try? JSONSerialization.data(withJSONObject: ["alg": "none"])) ?? Data()
+        let payload = (try? JSONSerialization.data(withJSONObject: [
+            "email": email,
+            "chatgpt_plan_type": plan,
+        ])) ?? Data()
+
+        func base64URL(_ data: Data) -> String {
+            data.base64EncodedString()
+                .replacingOccurrences(of: "=", with: "")
+                .replacingOccurrences(of: "+", with: "-")
+                .replacingOccurrences(of: "/", with: "_")
+        }
+
+        return "\(base64URL(header)).\(base64URL(payload))."
+    }
+}
diff --git a/Tests/CodexBarTests/CodexSystemPromotionUITests.swift b/Tests/CodexBarTests/CodexSystemPromotionUITests.swift
new file mode 100644
index 0000000000..0f780686d8
--- /dev/null
+++ b/Tests/CodexBarTests/CodexSystemPromotionUITests.swift
@@ -0,0 +1,153 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@Suite(.serialized)
+@MainActor
+struct CodexSystemPromotionUITests {
+    @Test
+    func `promotion coordinator promotes immediately`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexSystemPromotionUITests-coordinator-immediate")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "managed@example.com",
+            authAccountID: "acct-managed")
+        try container.persistAccounts([target])
+        _ = try container.writeLiveOAuthAuthFile(email: "live@example.com", accountID: "acct-live")
+
+        let managedVisibleAccountID = try #require(container.settings.codexVisibleAccountProjection.visibleAccounts
+            .first(where: { $0.storedAccountID == target.id })?
+            .id)
+        let coordinator = CodexAccountPromotionCoordinator(service: container.makeService())
+
+        let result = await coordinator.promote(managedAccountID: target.id)
+
+        let promotionResult: CodexAccountPromotionResult
+        switch result {
+        case let .success(value):
+            promotionResult = value
+        case let .failure(error):
+            Issue.record("Expected successful promotion, got \(error)")
+            throw PromotionTestError.unexpectedDisposition
+        }
+
+        #expect(promotionResult.outcome == .promoted)
+        #expect(container.settings.codexActiveSource == .liveSystem)
+        #expect(container.settings.codexVisibleAccountProjection.liveVisibleAccountID == managedVisibleAccountID)
+        #expect(coordinator.userFacingError == nil)
+    }
+
+    @Test
+    func `promotion coordinator blocks while live reauthentication is running`() async throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexSystemPromotionUITests-coordinator-live-reauth")
+        defer { container.tearDown() }
+
+        let target = try container.createManagedAccount(
+            persistedEmail: "managed@example.com",
+            authAccountID: "acct-managed")
+        try container.persistAccounts([target])
+        _ = try container.writeLiveOAuthAuthFile(email: "live@example.com", accountID: "acct-live")
+        container.settings.codexActiveSource = .managedAccount(id: target.id)
+
+        let coordinator = CodexAccountPromotionCoordinator(service: container.makeService())
+        coordinator.setLiveReauthenticationInProgress(true)
+
+        let result = await coordinator.promote(managedAccountID: target.id)
+
+        let error: CodexSystemAccountPromotionUserFacingError
+        switch result {
+        case .success:
+            Issue.record("Expected blocked promotion while live reauthentication is running")
+            throw PromotionTestError.unexpectedDisposition
+        case let .failure(value):
+            error = value
+        }
+
+        #expect(error.title == "Could not switch system account")
+        #expect(error.message == "Finish the current managed account change before switching the system account.")
+        #expect(coordinator.userFacingError == error)
+        #expect(coordinator.isInteractionBlocked())
+        #expect(container.settings.codexActiveSource == .managedAccount(id: target.id))
+    }
+
+    @Test
+    func `codex menu descriptor includes system account submenu`() throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexSystemPromotionUITests-menu-descriptor")
+        defer { container.tearDown() }
+
+        let managedAccountID = UUID()
+        let managedAccount = try container.createManagedAccount(
+            id: managedAccountID,
+            persistedEmail: "managed@example.com",
+            authAccountID: "acct-managed")
+        try container.persistAccounts([managedAccount])
+        container.settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: container.liveHomeURL.path,
+            observedAt: Date())
+
+        let descriptor = MenuDescriptor.build(
+            provider: .codex,
+            store: container.usageStore,
+            settings: container.settings,
+            account: UsageFetcher().loadAccountInfo(),
+            managedCodexAccountCoordinator: ManagedCodexAccountCoordinator(),
+            codexAccountPromotionCoordinator: CodexAccountPromotionCoordinator(
+                service: container.makeService()),
+            updateReady: false)
+
+        let submenu = try #require(descriptor.sections
+            .flatMap(\.entries)
+            .compactMap { entry -> (String, String?, [MenuDescriptor.SubmenuItem])? in
+                guard case let .submenu(title, systemImageName, items) = entry else { return nil }
+                return (title, systemImageName, items)
+            }
+            .first(where: { $0.0 == "System Account" }))
+
+        #expect(submenu.1 == MenuDescriptor.MenuActionSystemImage.systemAccount.rawValue)
+        #expect(submenu.2.map(\.title) == ["live@example.com", "managed@example.com"])
+        #expect(submenu.2.count == 2)
+        #expect(submenu.2[0].isChecked)
+        #expect(submenu.2[0].isEnabled == false)
+        #expect(submenu.2[0].action == nil)
+        #expect(submenu.2[1].isChecked == false)
+        #expect(submenu.2[1].isEnabled)
+        #expect(submenu.2[1].action == .requestCodexSystemPromotion(managedAccountID))
+    }
+
+    @Test
+    func `codex menu descriptor hides single live system account submenu`() throws {
+        let container = try CodexAccountPromotionTestContainer(
+            suiteName: "CodexSystemPromotionUITests-menu-single-live")
+        defer { container.tearDown() }
+
+        container.settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: container.liveHomeURL.path,
+            observedAt: Date())
+
+        let descriptor = MenuDescriptor.build(
+            provider: .codex,
+            store: container.usageStore,
+            settings: container.settings,
+            account: UsageFetcher().loadAccountInfo(),
+            managedCodexAccountCoordinator: ManagedCodexAccountCoordinator(),
+            codexAccountPromotionCoordinator: CodexAccountPromotionCoordinator(
+                service: container.makeService()),
+            updateReady: false)
+
+        let hasSystemAccountSubmenu = descriptor.sections
+            .flatMap(\.entries)
+            .contains { entry in
+                guard case let .submenu(title, _, _) = entry else { return false }
+                return title == "System Account"
+            }
+
+        #expect(!hasSystemAccountSubmenu)
+    }
+}
diff --git a/Tests/CodexBarTests/CodexUsageFetcherFallbackTests.swift b/Tests/CodexBarTests/CodexUsageFetcherFallbackTests.swift
new file mode 100644
index 0000000000..e61d9b735b
--- /dev/null
+++ b/Tests/CodexBarTests/CodexUsageFetcherFallbackTests.swift
@@ -0,0 +1,508 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct CodexUsageFetcherFallbackTests {
+    @Test
+    func `missing CLI binary reports install guidance instead of not running`() async throws {
+        let fetcher = UsageFetcher(
+            environment: [:],
+            initializeTimeoutSeconds: 0.1,
+            requestTimeoutSeconds: 0.1,
+            codexExecutableResolver: { _, _ in nil })
+
+        do {
+            _ = try await fetcher.loadLatestCLIAccountSnapshot()
+            Issue.record("Expected missing Codex CLI to throw")
+        } catch CodexStatusProbeError.codexNotInstalled {
+            let message = CodexStatusProbeError.codexNotInstalled.localizedDescription
+            #expect(message.contains("Codex CLI missing"))
+            #expect(!message.contains("Codex not running"))
+        } catch {
+            Issue.record("Expected CodexStatusProbeError.codexNotInstalled, got \(type(of: error)): \(error)")
+        }
+    }
+
+    @Test
+    func `CLI usage recovers from RPC decode mismatch body payload`() {
+        let snapshot = UsageFetcher._recoverCodexRPCUsageFromErrorForTesting(
+            Self.decodeMismatchBodyMessage)
+
+        #expect(snapshot?.primary?.usedPercent == 4)
+        #expect(snapshot?.primary?.windowMinutes == 300)
+        #expect(snapshot?.secondary?.usedPercent == 19)
+        #expect(snapshot?.secondary?.windowMinutes == 10080)
+        #expect(snapshot?.accountEmail(for: UsageProvider.codex) == "prolite-test@example.com")
+        #expect(snapshot?.loginMethod(for: UsageProvider.codex) == "prolite")
+    }
+
+    @Test
+    func `CLI credits recover from RPC decode mismatch body payload`() {
+        let credits = UsageFetcher._recoverCodexRPCCreditsFromErrorForTesting(Self.decodeMismatchBodyMessage)
+
+        #expect(credits?.remaining == 0)
+    }
+
+    @Test
+    func `CLI credits recover from RPC error body when usage windows are unusable`() async throws {
+        let stubCLIPath = try self.makeDecodeMismatchStubCodexCLI(message: Self.creditsOnlyDecodeMismatchBodyMessage)
+        defer { try? FileManager.default.removeItem(atPath: stubCLIPath) }
+
+        let fetcher = self.makeStubUsageFetcher(stubCLIPath)
+        let credits = try await fetcher.loadLatestCredits()
+
+        #expect(credits.remaining == 14.5)
+        await #expect(throws: UsageError.noRateLimitsFound) {
+            _ = try await fetcher.loadLatestUsage()
+        }
+    }
+
+    @Test
+    func `CLI usage does not partially recover malformed RPC body without session lane`() {
+        let snapshot = UsageFetcher._recoverCodexRPCUsageFromErrorForTesting(
+            Self.partialDecodeBodyMessage)
+
+        #expect(snapshot == nil)
+    }
+
+    @Test
+    func `CLI usage recovers from RPC body without TTY fallback`() async throws {
+        let stubCLIPath = try self.makeDecodeMismatchStubCodexCLI(message: Self.decodeMismatchBodyMessage)
+        defer { try? FileManager.default.removeItem(atPath: stubCLIPath) }
+
+        let fetcher = self.makeStubUsageFetcher(stubCLIPath)
+        let snapshot = try await fetcher.loadLatestUsage()
+
+        #expect(snapshot.primary?.usedPercent == 4)
+        #expect(snapshot.primary?.windowMinutes == 300)
+        #expect(snapshot.secondary?.usedPercent == 19)
+        #expect(snapshot.secondary?.windowMinutes == 10080)
+    }
+
+    @Test
+    func `CLI credits recover from RPC body without TTY fallback`() async throws {
+        let stubCLIPath = try self.makeDecodeMismatchStubCodexCLI(message: Self.decodeMismatchBodyMessage)
+        defer { try? FileManager.default.removeItem(atPath: stubCLIPath) }
+
+        let fetcher = self.makeStubUsageFetcher(stubCLIPath)
+        let credits = try await fetcher.loadLatestCredits()
+
+        #expect(credits.remaining == 0)
+    }
+
+    @Test
+    func `CLI credits load from RPC response without usage windows`() async throws {
+        let stubCLIPath = try self.makeCreditsOnlyStubCodexCLI()
+        defer { try? FileManager.default.removeItem(atPath: stubCLIPath) }
+
+        let fetcher = self.makeStubUsageFetcher(stubCLIPath)
+        let credits = try await fetcher.loadLatestCredits()
+
+        #expect(credits.remaining == 21)
+        await #expect(throws: UsageError.noRateLimitsFound) {
+            _ = try await fetcher.loadLatestUsage()
+        }
+    }
+
+    @Test
+    func `CLI usage loads plan only RPC response as unavailable limits`() async throws {
+        let stubCLIPath = try self.makePlanOnlyStubCodexCLI()
+        defer { try? FileManager.default.removeItem(atPath: stubCLIPath) }
+
+        let fetcher = self.makeStubUsageFetcher(stubCLIPath)
+        let snapshot = try await fetcher.loadLatestUsage()
+
+        #expect(snapshot.primary == nil)
+        #expect(snapshot.secondary == nil)
+        #expect(snapshot.accountEmail(for: .codex) == "stub@example.com")
+        #expect(snapshot.loginMethod(for: .codex) == "pro")
+        #expect(snapshot.rateLimitsUnavailable(for: .codex))
+    }
+
+    @Test
+    func `CLI plan and credits response without usage windows keeps unavailable limits`() async throws {
+        let stubCLIPath = try self.makePlanOnlyStubCodexCLI(includeCredits: true)
+        defer { try? FileManager.default.removeItem(atPath: stubCLIPath) }
+
+        let fetcher = self.makeStubUsageFetcher(stubCLIPath)
+        let snapshot = try await fetcher.loadLatestCLIAccountSnapshot()
+
+        #expect(snapshot.usage?.primary == nil)
+        #expect(snapshot.usage?.secondary == nil)
+        #expect(snapshot.usage?.rateLimitsUnavailable(for: .codex) == true)
+        #expect(snapshot.credits?.remaining == 21)
+    }
+
+    @Test
+    func `CLI usage fails when RPC body recovery misses session lane`() async throws {
+        let stubCLIPath = try self.makeDecodeMismatchStubCodexCLI(message: Self.partialDecodeBodyMessage)
+        defer { try? FileManager.default.removeItem(atPath: stubCLIPath) }
+
+        let fetcher = self.makeStubUsageFetcher(stubCLIPath)
+
+        do {
+            _ = try await fetcher.loadLatestUsage()
+            Issue.record("Expected RPC failure without PTY fallback")
+        } catch {
+            #expect(error.localizedDescription.contains("Codex connection failed"))
+        }
+    }
+
+    @Test
+    func `hung CLI RPC rate limits request times out within budget`() async throws {
+        let stubCLIPath = try self.makeHungRateLimitsStubCodexCLI()
+        defer { try? FileManager.default.removeItem(atPath: stubCLIPath) }
+
+        let fetcher = UsageFetcher(
+            environment: ["CODEX_CLI_PATH": stubCLIPath],
+            initializeTimeoutSeconds: 20.0,
+            requestTimeoutSeconds: 0.2)
+
+        let started = Date()
+        do {
+            _ = try await fetcher.loadLatestUsage()
+            Issue.record("Expected hung Codex RPC usage request to time out")
+        } catch let error as RPCWireError {
+            guard case let .timeout(method) = error else {
+                Issue.record("Expected RPC timeout, got \(error)")
+                return
+            }
+            #expect(method == "account/rateLimits/read")
+        } catch {
+            Issue.record("Expected RPCWireError.timeout, got \(type(of: error)): \(error)")
+        }
+
+        let elapsed = Date().timeIntervalSince(started)
+        #expect(elapsed < 5.0, "Hung RPC request must fail fast, took \(elapsed)s")
+    }
+
+    @Test
+    func `repeated hung CLI RPC requests stay bounded`() async throws {
+        let stubCLIPath = try self.makeHungRateLimitsStubCodexCLI()
+        defer { try? FileManager.default.removeItem(atPath: stubCLIPath) }
+
+        let fetcher = UsageFetcher(
+            environment: ["CODEX_CLI_PATH": stubCLIPath],
+            initializeTimeoutSeconds: 20.0,
+            requestTimeoutSeconds: 0.2)
+
+        for attempt in 1...2 {
+            let started = Date()
+            do {
+                _ = try await fetcher.loadLatestCredits()
+                Issue.record("Expected hung Codex RPC credits request \(attempt) to time out")
+            } catch let error as RPCWireError {
+                guard case .timeout = error else {
+                    Issue.record("Expected RPC timeout on attempt \(attempt), got \(error)")
+                    return
+                }
+            } catch {
+                Issue.record("Expected RPCWireError.timeout on attempt \(attempt), got \(type(of: error)): \(error)")
+            }
+
+            let elapsed = Date().timeIntervalSince(started)
+            #expect(elapsed < 5.0, "Hung RPC request \(attempt) must fail fast, took \(elapsed)s")
+        }
+    }
+
+    private static let decodeMismatchBodyMessage = """
+    failed to fetch codex rate limits: Decode error for https://chatgpt.com/backend-api/wham/usage:
+    unknown variant `prolite`, expected one of `guest`, `free`, `go`, `plus`, `pro`;
+    content-type=application/json; body={
+      "user_id": "user-TEST",
+      "account_id": "account-TEST",
+      "email": "prolite-test@example.com",
+      "plan_type": "prolite",
+      "rate_limit": {
+        "allowed": true,
+        "limit_reached": false,
+        "primary_window": {
+          "used_percent": 4,
+          "limit_window_seconds": 18000,
+          "reset_after_seconds": 8657,
+          "reset_at": 1776216359
+        },
+        "secondary_window": {
+          "used_percent": 19,
+          "limit_window_seconds": 604800,
+          "reset_after_seconds": 187681,
+          "reset_at": 1776395384
+        }
+      },
+      "credits": {
+        "has_credits": false,
+        "unlimited": false,
+        "overage_limit_reached": false,
+        "balance": "0E-10"
+      }
+    }
+    """
+
+    private static let partialDecodeBodyMessage = """
+    failed to fetch codex rate limits: Decode error for https://chatgpt.com/backend-api/wham/usage:
+    unknown variant `prolite`, expected one of `guest`, `free`, `go`, `plus`, `pro`;
+    content-type=application/json; body={
+      "email": "prolite-test@example.com",
+      "plan_type": "prolite",
+      "rate_limit": {
+        "allowed": true,
+        "limit_reached": false,
+        "primary_window": {
+          "used_percent": "oops",
+          "limit_window_seconds": 18000,
+          "reset_at": 1776216359
+        },
+        "secondary_window": {
+          "used_percent": 19,
+          "limit_window_seconds": 604800,
+          "reset_after_seconds": 187681,
+          "reset_at": 1776395384
+        }
+      }
+    }
+    """
+
+    private static let creditsOnlyDecodeMismatchBodyMessage = """
+    failed to fetch codex rate limits: Decode error for https://chatgpt.com/backend-api/wham/usage:
+    unknown variant `prolite`, expected one of `guest`, `free`, `go`, `plus`, `pro`;
+    content-type=application/json; body={
+      "email": "prolite-test@example.com",
+      "plan_type": "prolite",
+      "rate_limit": {
+        "allowed": true,
+        "limit_reached": false,
+        "primary_window": {
+          "used_percent": "oops",
+          "limit_window_seconds": 18000,
+          "reset_at": 1776216359
+        }
+      },
+      "credits": {
+        "has_credits": true,
+        "unlimited": false,
+        "overage_limit_reached": false,
+        "balance": "14.5"
+      }
+    }
+    """
+
+    private func makeStubUsageFetcher(_ stubCLIPath: String) -> UsageFetcher {
+        UsageFetcher(
+            environment: ["CODEX_CLI_PATH": stubCLIPath],
+            initializeTimeoutSeconds: 20.0,
+            requestTimeoutSeconds: 3.0)
+    }
+
+    private func makeDecodeMismatchStubCodexCLI(
+        message: String = Self.decodeMismatchBodyMessage)
+        throws -> String
+    {
+        let script = """
+        #!/usr/bin/python3 -S
+        import json
+        import sys
+
+        args = sys.argv[1:]
+        if "app-server" in args:
+            for line in sys.stdin:
+                if not line.strip():
+                    continue
+                message = json.loads(line)
+                method = message.get("method")
+                if method == "initialized":
+                    continue
+
+                identifier = message.get("id")
+                if method == "initialize":
+                    payload = {"id": identifier, "result": {}}
+                elif method == "account/rateLimits/read":
+                    payload = {
+                        "id": identifier,
+                        "error": {
+                            "message": '''\(message)'''
+                        }
+                    }
+                elif method == "account/read":
+                    payload = {
+                        "id": identifier,
+                        "result": {
+                            "account": {
+                                "type": "chatgpt",
+                                "email": "stub@example.com",
+                                "planType": "prolite"
+                            },
+                            "requiresOpenaiAuth": False
+                        }
+                    }
+                else:
+                    payload = {"id": identifier, "result": {}}
+
+                print(json.dumps(payload), flush=True)
+        else:
+            sys.stderr.write("unexpected non app-server Codex invocation\\n")
+            sys.exit(92)
+        """
+        let url = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-fallback-stub-\(UUID().uuidString)", isDirectory: false)
+        try Data(script.utf8).write(to: url)
+        try FileManager.default.setAttributes([.posixPermissions: 0o755], ofItemAtPath: url.path)
+        return url.path
+    }
+
+    private func makePlanOnlyStubCodexCLI(includeCredits: Bool = false) throws -> String {
+        let creditsPayload = includeCredits
+            ? [
+                ",",
+                "                                \"credits\": {",
+                "                                    \"hasCredits\": True,",
+                "                                    \"unlimited\": False,",
+                "                                    \"balance\": \"21\"",
+                "                                }",
+            ].joined(separator: "\n")
+            : ""
+        let script = """
+        #!/usr/bin/python3 -S
+        import json
+        import sys
+
+        args = sys.argv[1:]
+        if "app-server" in args:
+            for line in sys.stdin:
+                if not line.strip():
+                    continue
+                message = json.loads(line)
+                method = message.get("method")
+                if method == "initialized":
+                    continue
+
+                identifier = message.get("id")
+                if method == "initialize":
+                    payload = {"id": identifier, "result": {}}
+                elif method == "account/rateLimits/read":
+                    payload = {
+                        "id": identifier,
+                        "result": {
+                            "rateLimits": {
+                                "planType": "pro"
+                                \(creditsPayload)
+                            }
+                        }
+                    }
+                elif method == "account/read":
+                    payload = {
+                        "id": identifier,
+                        "result": {
+                            "account": {
+                                "type": "chatgpt",
+                                "email": "stub@example.com",
+                                "planType": "pro"
+                            },
+                            "requiresOpenaiAuth": False
+                        }
+                    }
+                else:
+                    payload = {"id": identifier, "result": {}}
+
+                print(json.dumps(payload), flush=True)
+        else:
+            sys.stderr.write("unexpected non app-server Codex invocation\\n")
+            sys.exit(92)
+        """
+        let url = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-plan-only-stub-\(UUID().uuidString)", isDirectory: false)
+        try Data(script.utf8).write(to: url)
+        try FileManager.default.setAttributes([.posixPermissions: 0o755], ofItemAtPath: url.path)
+        return url.path
+    }
+
+    private func makeCreditsOnlyStubCodexCLI() throws -> String {
+        let script = """
+        #!/usr/bin/python3 -S
+        import json
+        import sys
+
+        args = sys.argv[1:]
+        if "app-server" in args:
+            for line in sys.stdin:
+                if not line.strip():
+                    continue
+                message = json.loads(line)
+                method = message.get("method")
+                if method == "initialized":
+                    continue
+
+                identifier = message.get("id")
+                if method == "initialize":
+                    payload = {"id": identifier, "result": {}}
+                elif method == "account/rateLimits/read":
+                    payload = {
+                        "id": identifier,
+                        "result": {
+                            "rateLimits": {
+                                "credits": {
+                                    "hasCredits": True,
+                                    "unlimited": False,
+                                    "balance": "21"
+                                }
+                            }
+                        }
+                    }
+                elif method == "account/read":
+                    payload = {
+                        "id": identifier,
+                        "result": {
+                            "account": {
+                                "type": "chatgpt",
+                                "email": "stub@example.com",
+                                "planType": "pro"
+                            },
+                            "requiresOpenaiAuth": False
+                        }
+                    }
+                else:
+                    payload = {"id": identifier, "result": {}}
+
+                print(json.dumps(payload), flush=True)
+        else:
+            sys.stderr.write("unexpected non app-server Codex invocation\\n")
+            sys.exit(92)
+        """
+        let url = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-credits-only-stub-\(UUID().uuidString)", isDirectory: false)
+        try Data(script.utf8).write(to: url)
+        try FileManager.default.setAttributes([.posixPermissions: 0o755], ofItemAtPath: url.path)
+        return url.path
+    }
+
+    private func makeHungRateLimitsStubCodexCLI() throws -> String {
+        let script = """
+        #!/bin/sh
+        case " $* " in
+          *" app-server "*) ;;
+          *) printf '%s\\n' "unexpected non app-server Codex invocation" >&2; exit 92 ;;
+        esac
+
+        while IFS= read -r line; do
+          case "$line" in
+            *'"method":"initialized"'*|*'"method": "initialized"'*)
+              ;;
+            *'"method":"initialize"'*|*'"method": "initialize"'*)
+              printf '%s\\n' '{"id":1,"result":{}}'
+              ;;
+            *'"method":"account/rateLimits/read"'*|*'"method": "account/rateLimits/read"'*)
+              sleep 30
+              ;;
+            *)
+              printf '%s\\n' '{"id":1,"result":{}}'
+              ;;
+          esac
+        done
+        """
+        let url = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-hung-stub-\(UUID().uuidString)", isDirectory: false)
+        try Data(script.utf8).write(to: url)
+        try FileManager.default.setAttributes([.posixPermissions: 0o755], ofItemAtPath: url.path)
+        return url.path
+    }
+}
diff --git a/Tests/CodexBarTests/CodexUserFacingErrorTests.swift b/Tests/CodexBarTests/CodexUserFacingErrorTests.swift
new file mode 100644
index 0000000000..4fb88fc3c0
--- /dev/null
+++ b/Tests/CodexBarTests/CodexUserFacingErrorTests.swift
@@ -0,0 +1,231 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@MainActor
+struct CodexUserFacingErrorTests {
+    @Test
+    func `missing codex CLI guidance is not collapsed to not running`() {
+        let store = self.makeUsageStore(suite: "CodexUserFacingErrorTests-missing-cli")
+        store.errors[.codex] = "Codex not running. Try running a Codex command first. "
+            + "(Codex CLI not found. Install with `npm i -g @openai/codex`.)"
+
+        #expect(store.userFacingError(for: .codex) == CodexStatusProbeError.codexNotInstalled.localizedDescription)
+    }
+
+    @Test
+    func `logged out codex CLI guidance is not collapsed to temporary outage`() {
+        let store = self.makeUsageStore(suite: "CodexUserFacingErrorTests-cli-login-required")
+        store.errors[.codex] =
+            "Codex connection failed: codex account authentication required to read rate limits"
+
+        #expect(
+            store.userFacingError(for: .codex) ==
+                "Codex CLI is not signed in. Run `codex login --device-auth`, then refresh.")
+    }
+
+    @Test
+    func `cached logged out codex CLI failure preserves cached suffix`() {
+        let store = self.makeUsageStore(suite: "CodexUserFacingErrorTests-cached-cli-login-required")
+        store.lastCreditsError =
+            "Last Codex credits refresh failed: Codex connection failed: "
+                + "codex account authentication required to read rate limits. Cached values from 2m ago."
+
+        #expect(
+            store.userFacingLastCreditsError ==
+                "Codex CLI is not signed in. Run `codex login --device-auth`, then refresh. "
+                + "Cached values from 2m ago.")
+    }
+
+    @Test
+    func `expired codex auth is sanitized`() {
+        let store = self.makeUsageStore(suite: "CodexUserFacingErrorTests-expired-auth")
+        store.errors[.codex] = """
+        Codex connection failed: failed to fetch codex rate limits: GET https://chatgpt.com/backend-api/wham/usage \
+        failed: 401 Unauthorized; content-type=text/plain; body={\"error\":{\"message\":\"Provided authentication \
+        token is expired. Please try signing in again.\",\"code\":\"token_expired\"}}
+        """
+
+        #expect(store.userFacingError(for: .codex) == "Codex session expired. Sign in again.")
+    }
+
+    @Test
+    func `transport codex error is sanitized`() {
+        let store = self.makeUsageStore(suite: "CodexUserFacingErrorTests-transport")
+        store.errors[.codex] =
+            "Codex connection failed: failed to fetch codex rate limits: "
+                + "GET https://chatgpt.com/backend-api/wham/usage failed: 500"
+
+        #expect(store.userFacingError(for: .codex) == "Codex usage is temporarily unavailable. Try refreshing.")
+    }
+
+    @Test
+    func `decode mismatch codex error is sanitized`() {
+        let store = self.makeUsageStore(suite: "CodexUserFacingErrorTests-decode-mismatch")
+        store.errors[.codex] =
+            "Codex connection failed: failed to fetch codex rate limits: "
+                + "Decode error for https://chatgpt.com/backend-api/wham/usage: "
+                + "unknown variant `prolite`, expected one of `guest`, `free`, `go`, `plus`, `pro`"
+
+        #expect(store.userFacingError(for: .codex) == "Codex usage is temporarily unavailable. Try refreshing.")
+    }
+
+    @Test
+    func `cached credits failure preserves cached suffix while sanitizing body`() {
+        let store = self.makeUsageStore(suite: "CodexUserFacingErrorTests-cached-credits")
+        store.lastCreditsError =
+            "Last Codex credits refresh failed: Codex connection failed: failed to fetch codex rate limits: "
+                + "GET https://chatgpt.com/backend-api/wham/usage failed: 500; body={\"error\":{}} "
+                + "Cached values from 2m ago."
+
+        #expect(
+            store.userFacingLastCreditsError ==
+                "Codex usage is temporarily unavailable. Try refreshing. Cached values from 2m ago.")
+    }
+
+    @Test
+    func `cached missing codex CLI failure preserves cached suffix`() {
+        let store = self.makeUsageStore(suite: "CodexUserFacingErrorTests-cached-missing-cli")
+        store.lastCreditsError =
+            "Last Codex credits refresh failed: Codex CLI not found. "
+                + "Install with `npm i -g @openai/codex`. Cached values from 2m ago."
+
+        #expect(
+            store.userFacingLastCreditsError ==
+                CodexStatusProbeError.codexNotInstalled.localizedDescription + " Cached values from 2m ago.")
+    }
+
+    @Test
+    func `browser mismatch remains unchanged`() {
+        let store = self.makeUsageStore(suite: "CodexUserFacingErrorTests-browser-mismatch")
+        store.lastOpenAIDashboardError =
+            "OpenAI cookies are for ratulsarna@gmail.com, not rdsarna@gmail.com. "
+                + "Switch chatgpt.com account, then refresh OpenAI cookies."
+
+        #expect(
+            store.userFacingLastOpenAIDashboardError ==
+                "OpenAI cookies are for ratulsarna@gmail.com, not rdsarna@gmail.com. "
+                + "Switch chatgpt.com account, then refresh OpenAI cookies.")
+    }
+
+    @Test
+    func `frame load interrupted becomes retry guidance`() {
+        let store = self.makeUsageStore(suite: "CodexUserFacingErrorTests-frame-load")
+        store.lastOpenAIDashboardError = "Frame load interrupted"
+
+        #expect(
+            store.userFacingLastOpenAIDashboardError ==
+                "OpenAI web refresh was interrupted. Refresh OpenAI cookies and try again.")
+    }
+
+    @Test
+    func `open A I web timeout becomes retry guidance`() {
+        let store = self.makeUsageStore(suite: "CodexUserFacingErrorTests-openai-web-timeout")
+        store.lastOpenAIDashboardError = "The operation couldn’t be completed. (NSURLErrorDomain error -1001.)"
+
+        #expect(
+            store.userFacingLastOpenAIDashboardError ==
+                "OpenAI web refresh timed out. Refresh OpenAI cookies and try again.")
+    }
+
+    @Test
+    func `open A I web network error becomes connection guidance`() {
+        let store = self.makeUsageStore(suite: "CodexUserFacingErrorTests-openai-web-network")
+        store.lastOpenAIDashboardError = "The operation couldn’t be completed. (NSURLErrorDomain error -1004.)"
+        let expected = [
+            "OpenAI web refresh hit a network error.",
+            "Check your connection, then refresh OpenAI cookies and try again.",
+        ].joined(separator: " ")
+
+        #expect(store.userFacingLastOpenAIDashboardError == expected)
+    }
+
+    @Test
+    func `non codex providers keep raw errors`() {
+        let store = self.makeUsageStore(suite: "CodexUserFacingErrorTests-non-codex")
+        store.errors[.claude] = "Claude probe failed with debug detail"
+
+        #expect(store.userFacingError(for: .claude) == "Claude probe failed with debug detail")
+    }
+
+    @Test
+    func `providers pane codex model uses sanitized values`() {
+        let settings = self.makeSettingsStore(suite: "CodexUserFacingErrorTests-pane-model")
+        let store = self.makeUsageStore(settings: settings)
+        store.errors[.codex] =
+            "Codex connection failed: failed to fetch codex rate limits: "
+                + "GET https://chatgpt.com/backend-api/wham/usage failed: 500"
+        store.lastCreditsError =
+            "Last Codex credits refresh failed: Codex connection failed: failed to fetch codex rate limits: "
+                + "GET https://chatgpt.com/backend-api/wham/usage failed: 500 "
+                + "Cached values from 1m ago."
+        store.lastOpenAIDashboardError = "Frame load interrupted"
+
+        let pane = ProvidersPane(settings: settings, store: store)
+        let model = pane._test_menuCardModel(for: .codex)
+
+        #expect(model.subtitleText == "Codex usage is temporarily unavailable. Try refreshing.")
+        #expect(
+            model.creditsHintText ==
+                "OpenAI web refresh was interrupted. Refresh OpenAI cookies and try again.")
+        #expect(
+            model.creditsHintCopyText ==
+                "OpenAI web refresh was interrupted. Refresh OpenAI cookies and try again.")
+        #expect(
+            model.creditsText == "Codex usage is temporarily unavailable. Try refreshing. Cached values from 1m ago.")
+    }
+
+    @Test
+    func `providers pane codex error display keeps raw full text for copy`() {
+        let settings = self.makeSettingsStore(suite: "CodexUserFacingErrorTests-pane-error-display")
+        let store = self.makeUsageStore(settings: settings)
+        let raw =
+            "Codex connection failed: failed to fetch codex rate limits: "
+                + "GET https://chatgpt.com/backend-api/wham/usage failed: 500; body={\"error\":{}}"
+        store.errors[.codex] = raw
+
+        let pane = ProvidersPane(settings: settings, store: store)
+        let display = pane._test_providerErrorDisplay(for: .codex)
+
+        #expect(display?.preview == "Codex usage is temporarily unavailable. Try refreshing.")
+        #expect(display?.full == raw)
+    }
+
+    private func makeUsageStore(suite: String) -> UsageStore {
+        let settings = self.makeSettingsStore(suite: suite)
+        return self.makeUsageStore(settings: settings)
+    }
+
+    private func makeUsageStore(settings: SettingsStore) -> UsageStore {
+        UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+    }
+
+    private func makeSettingsStore(suite: String) -> SettingsStore {
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+        return SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore(),
+            codexCookieStore: InMemoryCookieHeaderStore(),
+            claudeCookieStore: InMemoryCookieHeaderStore(),
+            cursorCookieStore: InMemoryCookieHeaderStore(),
+            opencodeCookieStore: InMemoryCookieHeaderStore(),
+            factoryCookieStore: InMemoryCookieHeaderStore(),
+            minimaxCookieStore: InMemoryMiniMaxCookieStore(),
+            minimaxAPITokenStore: InMemoryMiniMaxAPITokenStore(),
+            kimiTokenStore: InMemoryKimiTokenStore(),
+            kimiK2TokenStore: InMemoryKimiK2TokenStore(),
+            augmentCookieStore: InMemoryCookieHeaderStore(),
+            ampCookieStore: InMemoryCookieHeaderStore(),
+            copilotTokenStore: InMemoryCopilotTokenStore(),
+            tokenAccountStore: InMemoryTokenAccountStore())
+    }
+}
diff --git a/Tests/CodexBarTests/CodexVisibleAccountTests.swift b/Tests/CodexBarTests/CodexVisibleAccountTests.swift
new file mode 100644
index 0000000000..6b41769dd2
--- /dev/null
+++ b/Tests/CodexBarTests/CodexVisibleAccountTests.swift
@@ -0,0 +1,39 @@
+import Foundation
+import Testing
+@testable import CodexBar
+
+@Suite(.serialized)
+struct CodexVisibleAccountTests {
+    @Test
+    func `menu display name suppresses personal workspace label`() {
+        let personal = CodexVisibleAccount(
+            id: "personal",
+            email: "user@example.com",
+            workspaceLabel: "Personal",
+            workspaceAccountID: "account-personal",
+            storedAccountID: nil,
+            selectionSource: .liveSystem,
+            isActive: true,
+            isLive: true,
+            canReauthenticate: true,
+            canRemove: false)
+        let team = CodexVisibleAccount(
+            id: "team",
+            email: "user@example.com",
+            workspaceLabel: "Team Alpha",
+            workspaceAccountID: "account-team",
+            storedAccountID: nil,
+            selectionSource: .managedAccount(id: UUID()),
+            isActive: false,
+            isLive: false,
+            canReauthenticate: true,
+            canRemove: true)
+
+        #expect(personal.displayName == "user@example.com — Personal")
+        #expect(personal.menuDisplayName == "user@example.com")
+        #expect(personal.menuWorkspaceLabel == nil)
+        #expect(team.displayName == "user@example.com — Team Alpha")
+        #expect(team.menuDisplayName == "user@example.com — Team Alpha")
+        #expect(team.menuWorkspaceLabel == "Team Alpha")
+    }
+}
diff --git a/Tests/CodexBarTests/CodexWebDashboardStrategyAuthorityTests.swift b/Tests/CodexBarTests/CodexWebDashboardStrategyAuthorityTests.swift
new file mode 100644
index 0000000000..90d150594e
--- /dev/null
+++ b/Tests/CodexBarTests/CodexWebDashboardStrategyAuthorityTests.swift
@@ -0,0 +1,436 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+@Suite(.serialized)
+@MainActor
+struct CodexWebDashboardStrategyAuthorityTests {
+    @Test
+    func `web dashboard attach converts snapshot with authority attachment email`() throws {
+        OpenAIDashboardCacheStore.clear()
+        defer { OpenAIDashboardCacheStore.clear() }
+
+        let authHome = try self.makeAuthHome(
+            email: "owner@example.com",
+            accountId: "acct-owner")
+        defer { try? FileManager.default.removeItem(at: authHome) }
+
+        let context = self.makeContext(
+            authHome: authHome,
+            knownOwners: [
+                CodexDashboardKnownOwnerCandidate(
+                    identity: .providerAccount(id: "acct-owner"),
+                    normalizedEmail: "owner@example.com"),
+            ])
+        let result = try CodexWebDashboardStrategy.makeAuthorizedDashboardResultForTesting(
+            dashboard: self.makeDashboard(email: "owner@example.com"),
+            context: context,
+            routingTargetEmail: "route@example.com")
+
+        #expect(result.usage.accountEmail(for: .codex) == "owner@example.com")
+        #expect(result.credits?.remaining == 42)
+    }
+
+    @Test
+    func `web dashboard attach preserves credits when usage limits are absent`() throws {
+        OpenAIDashboardCacheStore.clear()
+        defer { OpenAIDashboardCacheStore.clear() }
+
+        let authHome = try self.makeAuthHome(
+            email: "owner@example.com",
+            accountId: "acct-owner")
+        defer { try? FileManager.default.removeItem(at: authHome) }
+
+        let context = self.makeContext(
+            authHome: authHome,
+            knownOwners: [
+                CodexDashboardKnownOwnerCandidate(
+                    identity: .providerAccount(id: "acct-owner"),
+                    normalizedEmail: "owner@example.com"),
+            ])
+        let dashboard = self.makeDashboardWithoutUsageLimits(email: "owner@example.com")
+
+        let result = try CodexWebDashboardStrategy.makeAuthorizedDashboardResultForTesting(
+            dashboard: dashboard,
+            context: context,
+            routingTargetEmail: "route@example.com")
+
+        #expect(result.usage.primary == nil)
+        #expect(result.usage.secondary == nil)
+        #expect(result.usage.updatedAt == dashboard.updatedAt)
+        #expect(result.usage.identity?.accountEmail == "owner@example.com")
+        #expect(result.usage.identity?.loginMethod == "pro")
+        #expect(result.credits?.remaining == 42)
+        #expect(result.dashboard == dashboard)
+    }
+
+    @Test
+    func `web dashboard display only throws typed policy error`() throws {
+        OpenAIDashboardCacheStore.clear()
+        defer { OpenAIDashboardCacheStore.clear() }
+
+        let authHome = try self.makeAuthHome(email: "shared@example.com")
+        defer { try? FileManager.default.removeItem(at: authHome) }
+
+        let context = self.makeContext(
+            authHome: authHome,
+            knownOwners: [
+                CodexDashboardKnownOwnerCandidate(
+                    identity: .providerAccount(id: "acct-alpha"),
+                    normalizedEmail: "shared@example.com"),
+                CodexDashboardKnownOwnerCandidate(
+                    identity: .providerAccount(id: "acct-beta"),
+                    normalizedEmail: "shared@example.com"),
+            ])
+        let dashboard = self.makeDashboard(email: "shared@example.com")
+        let expectedDecision = CodexDashboardAuthority.evaluate(
+            CodexCLIDashboardAuthorityContext.makeLiveWebInput(
+                dashboard: dashboard,
+                context: context,
+                routingTargetEmail: "route@example.com"))
+
+        do {
+            _ = try CodexWebDashboardStrategy.makeAuthorizedDashboardResultForTesting(
+                dashboard: dashboard,
+                context: context,
+                routingTargetEmail: "route@example.com")
+            Issue.record("Expected CodexDashboardPolicyError.displayOnly")
+        } catch let error as CodexDashboardPolicyError {
+            #expect(error == .displayOnly(expectedDecision))
+        } catch {
+            Issue.record("Expected CodexDashboardPolicyError.displayOnly, got \(error)")
+        }
+    }
+
+    @Test
+    func `web dashboard fail closed throws policy rejection`() throws {
+        OpenAIDashboardCacheStore.clear()
+        defer { OpenAIDashboardCacheStore.clear() }
+
+        let authHome = try self.makeAuthHome(
+            email: "owner@example.com",
+            accountId: "acct-owner")
+        defer { try? FileManager.default.removeItem(at: authHome) }
+
+        let context = self.makeContext(
+            authHome: authHome,
+            knownOwners: [
+                CodexDashboardKnownOwnerCandidate(
+                    identity: .providerAccount(id: "acct-other"),
+                    normalizedEmail: "owner@example.com"),
+            ])
+        let dashboard = self.makeDashboard(email: "owner@example.com")
+        let expectedDecision = CodexDashboardAuthority.evaluate(
+            CodexCLIDashboardAuthorityContext.makeLiveWebInput(
+                dashboard: dashboard,
+                context: context,
+                routingTargetEmail: "route@example.com"))
+
+        do {
+            _ = try CodexWebDashboardStrategy.makeAuthorizedDashboardResultForTesting(
+                dashboard: dashboard,
+                context: context,
+                routingTargetEmail: "route@example.com")
+            Issue.record("Expected OpenAIWebCodexError.policyRejected")
+        } catch let error as OpenAIWebCodexError {
+            #expect(error == .policyRejected(expectedDecision))
+        } catch {
+            Issue.record("Expected OpenAIWebCodexError.policyRejected, got \(error)")
+        }
+    }
+
+    @Test
+    func `web dashboard wrong email throws policy rejection`() throws {
+        OpenAIDashboardCacheStore.clear()
+        defer { OpenAIDashboardCacheStore.clear() }
+
+        let authHome = try self.makeAuthHome(
+            email: "owner@example.com",
+            accountId: "acct-owner")
+        defer { try? FileManager.default.removeItem(at: authHome) }
+
+        let context = self.makeContext(
+            authHome: authHome,
+            knownOwners: [
+                CodexDashboardKnownOwnerCandidate(
+                    identity: .providerAccount(id: "acct-owner"),
+                    normalizedEmail: "owner@example.com"),
+            ])
+        let dashboard = self.makeDashboard(email: "other@example.com")
+        let expectedDecision = CodexDashboardAuthority.evaluate(
+            CodexCLIDashboardAuthorityContext.makeLiveWebInput(
+                dashboard: dashboard,
+                context: context,
+                routingTargetEmail: "owner@example.com"))
+
+        do {
+            _ = try CodexWebDashboardStrategy.makeAuthorizedDashboardResultForTesting(
+                dashboard: dashboard,
+                context: context,
+                routingTargetEmail: "owner@example.com")
+            Issue.record("Expected OpenAIWebCodexError.policyRejected")
+        } catch let error as OpenAIWebCodexError {
+            #expect(error == .policyRejected(expectedDecision))
+            if case let .policyRejected(decision) = error {
+                #expect(decision.reason == .wrongEmail(expected: "owner@example.com", actual: "other@example.com"))
+            }
+        } catch {
+            Issue.record("Expected OpenAIWebCodexError.policyRejected, got \(error)")
+        }
+    }
+
+    @Test
+    func `web dashboard provider account without scoped auth email fail closes on dashboard collision`() throws {
+        OpenAIDashboardCacheStore.clear()
+        defer { OpenAIDashboardCacheStore.clear() }
+
+        let authHome = try self.makeAuthHome(email: nil, accountId: "acct-owner")
+        defer { try? FileManager.default.removeItem(at: authHome) }
+
+        let context = self.makeContext(
+            authHome: authHome,
+            knownOwners: [
+                CodexDashboardKnownOwnerCandidate(
+                    identity: .providerAccount(id: "acct-alpha"),
+                    normalizedEmail: "shared@example.com"),
+                CodexDashboardKnownOwnerCandidate(
+                    identity: .providerAccount(id: "acct-beta"),
+                    normalizedEmail: "shared@example.com"),
+            ])
+        let dashboard = self.makeDashboard(email: "shared@example.com")
+        let expectedDecision = CodexDashboardAuthority.evaluate(
+            CodexCLIDashboardAuthorityContext.makeLiveWebInput(
+                dashboard: dashboard,
+                context: context,
+                routingTargetEmail: "shared@example.com"))
+
+        do {
+            _ = try CodexWebDashboardStrategy.makeAuthorizedDashboardResultForTesting(
+                dashboard: dashboard,
+                context: context,
+                routingTargetEmail: "shared@example.com")
+            Issue.record("Expected OpenAIWebCodexError.policyRejected")
+        } catch let error as OpenAIWebCodexError {
+            #expect(error == .policyRejected(expectedDecision))
+            if case let .policyRejected(decision) = error {
+                #expect(decision.reason == .providerAccountMissingScopedEmail)
+            }
+        } catch {
+            Issue.record("Expected OpenAIWebCodexError.policyRejected, got \(error)")
+        }
+    }
+
+    @Test
+    func `web dashboard attach saves cache with attached email not routing fallback`() throws {
+        OpenAIDashboardCacheStore.clear()
+        defer { OpenAIDashboardCacheStore.clear() }
+
+        let authHome = try self.makeAuthHome(
+            email: "owner@example.com",
+            accountId: "acct-owner")
+        defer { try? FileManager.default.removeItem(at: authHome) }
+
+        let context = self.makeContext(
+            authHome: authHome,
+            knownOwners: [
+                CodexDashboardKnownOwnerCandidate(
+                    identity: .providerAccount(id: "acct-owner"),
+                    normalizedEmail: "owner@example.com"),
+            ])
+
+        _ = try CodexWebDashboardStrategy.makeAuthorizedDashboardResultForTesting(
+            dashboard: self.makeDashboard(email: "owner@example.com"),
+            context: context,
+            routingTargetEmail: "route@example.com")
+
+        let cache = try #require(OpenAIDashboardCacheStore.load())
+        #expect(cache.accountEmail == "owner@example.com")
+        #expect(cache.accountEmail != "route@example.com")
+    }
+
+    @Test
+    func `web dashboard fail closed clears stale cache`() throws {
+        OpenAIDashboardCacheStore.save(OpenAIDashboardCache(
+            accountEmail: "stale@example.com",
+            snapshot: self.makeDashboard(email: "stale@example.com")))
+        defer { OpenAIDashboardCacheStore.clear() }
+
+        let authHome = try self.makeAuthHome(
+            email: "owner@example.com",
+            accountId: "acct-owner")
+        defer { try? FileManager.default.removeItem(at: authHome) }
+
+        let context = self.makeContext(
+            authHome: authHome,
+            knownOwners: [
+                CodexDashboardKnownOwnerCandidate(
+                    identity: .providerAccount(id: "acct-other"),
+                    normalizedEmail: "owner@example.com"),
+            ])
+
+        do {
+            _ = try CodexWebDashboardStrategy.makeAuthorizedDashboardResultForTesting(
+                dashboard: self.makeDashboard(email: "owner@example.com"),
+                context: context,
+                routingTargetEmail: "route@example.com")
+            Issue.record("Expected OpenAIWebCodexError.policyRejected")
+        } catch is OpenAIWebCodexError {}
+
+        #expect(OpenAIDashboardCacheStore.load() == nil)
+    }
+
+    @Test
+    func `web dashboard display only clears stale cache`() throws {
+        OpenAIDashboardCacheStore.save(OpenAIDashboardCache(
+            accountEmail: "stale@example.com",
+            snapshot: self.makeDashboard(email: "stale@example.com")))
+        defer { OpenAIDashboardCacheStore.clear() }
+
+        let authHome = try self.makeAuthHome(email: "shared@example.com")
+        defer { try? FileManager.default.removeItem(at: authHome) }
+
+        let context = self.makeContext(
+            authHome: authHome,
+            knownOwners: [
+                CodexDashboardKnownOwnerCandidate(
+                    identity: .providerAccount(id: "acct-alpha"),
+                    normalizedEmail: "shared@example.com"),
+                CodexDashboardKnownOwnerCandidate(
+                    identity: .providerAccount(id: "acct-beta"),
+                    normalizedEmail: "shared@example.com"),
+            ])
+
+        do {
+            _ = try CodexWebDashboardStrategy.makeAuthorizedDashboardResultForTesting(
+                dashboard: self.makeDashboard(email: "shared@example.com"),
+                context: context,
+                routingTargetEmail: "route@example.com")
+            Issue.record("Expected CodexDashboardPolicyError.displayOnly")
+        } catch is CodexDashboardPolicyError {}
+
+        #expect(OpenAIDashboardCacheStore.load() == nil)
+    }
+
+    private func makeContext(
+        authHome: URL? = nil,
+        knownOwners: [CodexDashboardKnownOwnerCandidate]) -> ProviderFetchContext
+    {
+        let env = authHome.map { ["CODEX_HOME": $0.path] } ?? [:]
+        let browserDetection = BrowserDetection(cacheTTL: 0)
+        return ProviderFetchContext(
+            runtime: .cli,
+            sourceMode: .auto,
+            includeCredits: true,
+            webTimeout: 60,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: env,
+            settings: ProviderSettingsSnapshot.make(
+                codex: .init(
+                    usageDataSource: .auto,
+                    cookieSource: .auto,
+                    manualCookieHeader: nil,
+                    dashboardAuthorityKnownOwners: knownOwners)),
+            fetcher: UsageFetcher(environment: env),
+            claudeFetcher: ClaudeUsageFetcher(browserDetection: browserDetection),
+            browserDetection: browserDetection)
+    }
+
+    private func makeDashboard(email: String) -> OpenAIDashboardSnapshot {
+        OpenAIDashboardSnapshot(
+            signedInEmail: email,
+            codeReviewRemainingPercent: 75,
+            codeReviewLimit: RateWindow(
+                usedPercent: 25,
+                windowMinutes: 60,
+                resetsAt: Date(timeIntervalSince1970: 3600),
+                resetDescription: nil),
+            creditEvents: [
+                CreditEvent(
+                    date: Date(timeIntervalSince1970: 1000),
+                    service: "codex",
+                    creditsUsed: 3),
+            ],
+            dailyBreakdown: [],
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            primaryLimit: RateWindow(
+                usedPercent: 10,
+                windowMinutes: 300,
+                resetsAt: Date(timeIntervalSince1970: 7200),
+                resetDescription: nil),
+            secondaryLimit: nil,
+            creditsRemaining: 42,
+            accountPlan: "pro",
+            updatedAt: Date(timeIntervalSince1970: 2000))
+    }
+
+    private func makeDashboardWithoutUsageLimits(email: String) -> OpenAIDashboardSnapshot {
+        OpenAIDashboardSnapshot(
+            signedInEmail: email,
+            codeReviewRemainingPercent: nil,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            primaryLimit: nil,
+            secondaryLimit: nil,
+            creditsRemaining: 42,
+            accountPlan: "pro",
+            updatedAt: Date(timeIntervalSince1970: 2000))
+    }
+
+    private func makeAuthHome(email: String?, accountId: String? = nil) throws -> URL {
+        let homeURL = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        try self.writeCodexAuthFile(homeURL: homeURL, email: email, accountId: accountId)
+        return homeURL
+    }
+
+    private func writeCodexAuthFile(
+        homeURL: URL,
+        email: String?,
+        accountId: String?) throws
+    {
+        try FileManager.default.createDirectory(at: homeURL, withIntermediateDirectories: true)
+        var tokens: [String: Any] = [
+            "accessToken": "access-token",
+            "refreshToken": "refresh-token",
+            "idToken": Self.fakeJWT(email: email, accountId: accountId),
+        ]
+        if let accountId {
+            tokens["accountId"] = accountId
+        }
+        let auth = ["tokens": tokens]
+        let data = try JSONSerialization.data(withJSONObject: auth)
+        try data.write(to: homeURL.appendingPathComponent("auth.json"))
+    }
+
+    private static func fakeJWT(email: String?, accountId: String?) -> String {
+        let header = (try? JSONSerialization.data(withJSONObject: ["alg": "none"])) ?? Data()
+        var authClaims: [String: Any] = [
+            "chatgpt_plan_type": "pro",
+        ]
+        if let accountId {
+            authClaims["chatgpt_account_id"] = accountId
+        }
+        var claims: [String: Any] = [
+            "chatgpt_plan_type": "pro",
+            "https://api.openai.com/auth": authClaims,
+        ]
+        if let email {
+            claims["email"] = email
+        }
+        let payload = (try? JSONSerialization.data(withJSONObject: claims)) ?? Data()
+
+        func base64URL(_ data: Data) -> String {
+            data.base64EncodedString()
+                .replacingOccurrences(of: "=", with: "")
+                .replacingOccurrences(of: "+", with: "-")
+                .replacingOccurrences(of: "/", with: "_")
+        }
+
+        return "\(base64URL(header)).\(base64URL(payload))."
+    }
+}
diff --git a/Tests/CodexBarTests/CodexbarTests.swift b/Tests/CodexBarTests/CodexbarTests.swift
index 737081635f..169eead114 100644
--- a/Tests/CodexBarTests/CodexbarTests.swift
+++ b/Tests/CodexBarTests/CodexbarTests.swift
@@ -4,10 +4,9 @@ import Foundation
 import Testing
 @testable import CodexBar
 
-@Suite
 struct CodexBarTests {
     @Test
-    func iconRendererProducesTemplateImage() {
+    func `icon renderer produces template image`() {
         let image = IconRenderer.makeIcon(
             primaryRemaining: 50,
             weeklyRemaining: 75,
@@ -19,7 +18,7 @@ struct CodexBarTests {
     }
 
     @Test
-    func iconRendererRendersAtPixelAlignedSize() {
+    func `icon renderer renders at pixel aligned size`() {
         let image = IconRenderer.makeIcon(
             primaryRemaining: 50,
             weeklyRemaining: 75,
@@ -33,7 +32,7 @@ struct CodexBarTests {
     }
 
     @Test
-    func iconRendererCachesStaticIcons() {
+    func `icon renderer caches static icons`() {
         let first = IconRenderer.makeIcon(
             primaryRemaining: 42,
             weeklyRemaining: 17,
@@ -50,7 +49,609 @@ struct CodexBarTests {
     }
 
     @Test
-    func iconRendererCodexEyesPunchThroughWhenUnknown() {
+    func `antigravity icon ignores legacy model quota lanes`() {
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 30, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 60, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            tertiary: RateWindow(usedPercent: 80, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            extraRateWindows: [
+                NamedRateWindow(
+                    id: "antigravity-compact-fallback-model",
+                    title: "New Model",
+                    window: RateWindow(
+                        usedPercent: 64,
+                        windowMinutes: nil,
+                        resetsAt: nil,
+                        resetDescription: nil)),
+            ],
+            updatedAt: Date())
+
+        let remaining = IconRemainingResolver.resolvedRemaining(snapshot: snapshot, style: .antigravity)
+
+        #expect(remaining.primary == nil)
+        #expect(remaining.secondary == nil)
+    }
+
+    @Test
+    func `antigravity quota summary icon shows session on top and weekly on bottom`() {
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 84, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 99, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            tertiary: nil,
+            extraRateWindows: [
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-gemini-weekly",
+                    title: "Gemini Weekly",
+                    window: RateWindow(usedPercent: 84, windowMinutes: 10080, resetsAt: nil, resetDescription: nil)),
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-gemini-5h",
+                    title: "Gemini Session",
+                    window: RateWindow(usedPercent: 97, windowMinutes: 300, resetsAt: nil, resetDescription: nil)),
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-3p-weekly",
+                    title: "Claude + GPT Weekly",
+                    window: RateWindow(usedPercent: 99, windowMinutes: 10080, resetsAt: nil, resetDescription: nil)),
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-3p-5h",
+                    title: "Claude + GPT Session",
+                    window: RateWindow(usedPercent: 98, windowMinutes: 300, resetsAt: nil, resetDescription: nil)),
+            ],
+            updatedAt: Date())
+
+        let windows = IconRemainingResolver.resolvedWindows(snapshot: snapshot, style: .antigravity)
+
+        #expect(windows.primary?.windowMinutes == 300)
+        #expect(windows.primary?.remainingPercent == 3)
+        #expect(windows.secondary?.windowMinutes == 10080)
+        #expect(windows.secondary?.remainingPercent == 16)
+    }
+
+    @Test
+    func `antigravity renderer draws primary above secondary`() throws {
+        let image = IconRenderer.makeIcon(
+            primaryRemaining: 100,
+            weeklyRemaining: 10,
+            creditsRemaining: nil,
+            stale: false,
+            style: .antigravity)
+        let bitmapReps = image.representations.compactMap { $0 as? NSBitmapImageRep }
+        let matchingRep = bitmapReps.first { rep in
+            rep.pixelsWide == 36 && rep.pixelsHigh == 36
+        }
+        let rep = try #require(matchingRep)
+
+        func averageAlpha(xRange: ClosedRange<Int>, yRange: ClosedRange<Int>) -> CGFloat {
+            var total: CGFloat = 0
+            var count: CGFloat = 0
+            for y in yRange {
+                for x in xRange {
+                    total += (rep.colorAt(x: x, y: y) ?? .clear).alphaComponent
+                    count += 1
+                }
+            }
+            return total / count
+        }
+
+        let visualTopRightAlpha = averageAlpha(xRange: 24...30, yRange: 7...10)
+        let visualBottomRightAlpha = averageAlpha(xRange: 24...30, yRange: 22...28)
+
+        #expect(visualTopRightAlpha > visualBottomRightAlpha + 0.2)
+    }
+
+    @Test
+    func `antigravity quota summary icon prefers gemini ids over display titles`() {
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            tertiary: nil,
+            extraRateWindows: [
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-gemini-weekly",
+                    title: "Renamed Weekly",
+                    window: RateWindow(usedPercent: 30, windowMinutes: 10080, resetsAt: nil, resetDescription: nil)),
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-gemini-5h",
+                    title: "Renamed Session",
+                    window: RateWindow(usedPercent: 40, windowMinutes: 300, resetsAt: nil, resetDescription: nil)),
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-3p-weekly",
+                    title: "Gemini Weekly",
+                    window: RateWindow(usedPercent: 99, windowMinutes: 10080, resetsAt: nil, resetDescription: nil)),
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-3p-5h",
+                    title: "Gemini Session",
+                    window: RateWindow(usedPercent: 98, windowMinutes: 300, resetsAt: nil, resetDescription: nil)),
+            ],
+            updatedAt: Date())
+
+        let windows = IconRemainingResolver.resolvedWindows(snapshot: snapshot, style: .antigravity)
+
+        #expect(windows.primary?.remainingPercent == 60)
+        #expect(windows.secondary?.remainingPercent == 70)
+    }
+
+    @Test
+    func `antigravity quota summary icon does not borrow missing gemini weekly from claude gpt`() {
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            tertiary: nil,
+            extraRateWindows: [
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-gemini-5h",
+                    title: "Gemini Session",
+                    window: RateWindow(usedPercent: 40, windowMinutes: 300, resetsAt: nil, resetDescription: nil)),
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-3p-weekly",
+                    title: "Claude + GPT Weekly",
+                    window: RateWindow(usedPercent: 99, windowMinutes: 10080, resetsAt: nil, resetDescription: nil)),
+            ],
+            updatedAt: Date())
+
+        let windows = IconRemainingResolver.resolvedWindows(snapshot: snapshot, style: .antigravity)
+
+        #expect(windows.primary?.remainingPercent == 60)
+        #expect(windows.secondary == nil)
+    }
+
+    @Test
+    func `antigravity quota summary icon treats unknown gemini rows as present`() {
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            tertiary: nil,
+            extraRateWindows: [
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-gemini-weekly",
+                    title: "Gemini Weekly",
+                    window: RateWindow(usedPercent: 100, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+                    usageKnown: false),
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-3p-weekly",
+                    title: "Claude + GPT Weekly",
+                    window: RateWindow(usedPercent: 99, windowMinutes: 10080, resetsAt: nil, resetDescription: nil)),
+            ],
+            updatedAt: Date())
+
+        let windows = IconRemainingResolver.resolvedWindows(snapshot: snapshot, style: .antigravity)
+
+        #expect(windows.primary == nil)
+        #expect(windows.secondary == nil)
+    }
+
+    @Test
+    func `antigravity quota summary icon falls back when gemini rows are absent`() {
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            tertiary: nil,
+            extraRateWindows: [
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-3p-5h",
+                    title: "Claude + GPT Session",
+                    window: RateWindow(usedPercent: 75, windowMinutes: 300, resetsAt: nil, resetDescription: nil)),
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-3p-weekly",
+                    title: "Claude + GPT Weekly",
+                    window: RateWindow(usedPercent: 88, windowMinutes: 10080, resetsAt: nil, resetDescription: nil)),
+            ],
+            updatedAt: Date())
+
+        let windows = IconRemainingResolver.resolvedWindows(snapshot: snapshot, style: .antigravity)
+
+        #expect(windows.primary?.remainingPercent == 25)
+        #expect(windows.secondary?.remainingPercent == 12)
+    }
+
+    @Test
+    func `antigravity quota summary icon tie break is stable`() {
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            tertiary: nil,
+            extraRateWindows: [
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-gemini-z-5h",
+                    title: "Gemini Session",
+                    window: RateWindow(
+                        usedPercent: 50,
+                        windowMinutes: 300,
+                        resetsAt: nil,
+                        resetDescription: "second-by-id")),
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-gemini-a-5h",
+                    title: "Gemini Session",
+                    window: RateWindow(
+                        usedPercent: 50,
+                        windowMinutes: 300,
+                        resetsAt: nil,
+                        resetDescription: "first-by-id")),
+            ],
+            updatedAt: Date())
+
+        let windows = IconRemainingResolver.resolvedWindows(snapshot: snapshot, style: .antigravity)
+
+        #expect(windows.primary?.resetDescription == "first-by-id")
+        #expect(windows.secondary == nil)
+    }
+
+    @Test
+    func `perplexity icon falls back to purchased lane when bonus is exhausted`() {
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            tertiary: RateWindow(usedPercent: 20, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        let remaining = IconRemainingResolver.resolvedRemaining(snapshot: snapshot, style: .perplexity)
+        #expect(remaining.primary == 80)
+        #expect(remaining.secondary == 0)
+    }
+
+    @Test
+    func `perplexity icon skips exhausted recurring lane when purchased credits remain`() {
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            tertiary: RateWindow(usedPercent: 20, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        let remaining = IconRemainingResolver.resolvedRemaining(snapshot: snapshot, style: .perplexity)
+        #expect(remaining.primary == 80)
+        #expect(remaining.secondary == 0)
+    }
+
+    @Test
+    func `perplexity icon prefers purchased lane before bonus`() {
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: RateWindow(usedPercent: 20, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            tertiary: RateWindow(usedPercent: 45, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        let remaining = IconRemainingResolver.resolvedRemaining(snapshot: snapshot, style: .perplexity)
+        #expect(remaining.primary == 55)
+        #expect(remaining.secondary == 80)
+    }
+
+    @Test
+    func `kimi icon renders primary bar when secondary is nil`() throws {
+        // Regression: Kimi account connected with usage, but no progress bar shown (issue #1043).
+        // When secondary (rate limit) is absent, the icon renderer must still show
+        // the primary (weekly quota) bar.
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 18.3, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())
+
+        let remaining = IconRemainingResolver.resolvedRemaining(snapshot: snapshot, style: .kimi)
+
+        guard let primaryRemaining = remaining.primary else {
+            Issue.record("remaining.primary was nil after IconRemainingResolver check")
+            return
+        }
+        #expect(primaryRemaining > 0) // 81.7% remaining
+        #expect(remaining.secondary == nil)
+
+        let image = IconRenderer.makeIcon(
+            primaryRemaining: remaining.primary,
+            weeklyRemaining: remaining.secondary,
+            creditsRemaining: nil,
+            stale: false,
+            style: .kimi)
+        #expect(image.size.width > 0)
+        #expect(image.isTemplate)
+
+        // Prove the primary bar is actually rendered using pixel inspection.
+        // Top bar rect: x ∈ [3, 33], y ∈ [19, 31] in the 36×36 canvas (barXPx=3, barWidthPx=30, y=19, h=12).
+        let bitmapReps = image.representations.compactMap { $0 as? NSBitmapImageRep }
+        let rep = try #require(bitmapReps.first { $0.pixelsWide == 36 && $0.pixelsHigh == 36 })
+
+        func alphaAt(px x: Int, _ y: Int) -> CGFloat {
+            (rep.colorAt(x: x, y: y) ?? .clear).alphaComponent
+        }
+
+        func regionHasFill(xRange: ClosedRange<Int>, yRange: ClosedRange<Int>) -> Bool {
+            for y in yRange {
+                for x in xRange where alphaAt(px: x, y) > 0.05 {
+                    return true
+                }
+            }
+            return false
+        }
+
+        // Primary bar (top track) must have fill to prove the progress bar rendered.
+        #expect(regionHasFill(xRange: 3...33, yRange: 19...31))
+    }
+
+    @Test
+    func `copilot icon can use selected budget as secondary lane`() {
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 20, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 30, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            extraRateWindows: [
+                NamedRateWindow(
+                    id: "copilot-budget-agent",
+                    title: "Budget - Copilot Agent Premium Requests",
+                    window: RateWindow(usedPercent: 65, windowMinutes: nil, resetsAt: nil, resetDescription: nil)),
+            ],
+            updatedAt: Date())
+
+        let remaining = IconRemainingResolver.resolvedRemaining(
+            snapshot: snapshot,
+            style: .copilot,
+            secondaryOverrideWindowID: "copilot-budget-agent")
+
+        #expect(remaining.primary == 80)
+        #expect(remaining.secondary == 35)
+    }
+
+    @Test
+    func `copying extra rate windows preserves subscription dates`() {
+        let expiresAt = Date(timeIntervalSince1970: 1_810_656_000)
+        let renewsAt = Date(timeIntervalSince1970: 1_810_569_600)
+        let ampUsage = AmpUsageDetails(
+            individualCredits: 12.5,
+            workspaceBalances: [AmpWorkspaceBalance(name: "Team", remaining: 7.25)])
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            ampUsage: ampUsage,
+            subscriptionExpiresAt: expiresAt,
+            subscriptionRenewsAt: renewsAt,
+            updatedAt: Date(timeIntervalSince1970: 1_800_000_000))
+
+        let copied = snapshot.with(extraRateWindows: [])
+
+        #expect(copied.subscriptionExpiresAt == expiresAt)
+        #expect(copied.subscriptionRenewsAt == renewsAt)
+        #expect(copied.ampUsage == ampUsage)
+    }
+
+    @Test
+    func `copying rate windows preserves provider payloads`() {
+        let updatedAt = Date(timeIntervalSince1970: 1_800_000_000)
+        let mimoUsage = MiMoUsageSnapshot(
+            balance: 12.5,
+            currency: "USD",
+            tokenUsed: 25,
+            tokenLimit: 100,
+            tokenPercent: 0.25,
+            updatedAt: updatedAt)
+        let identity = ProviderIdentitySnapshot(
+            providerID: .codex,
+            accountEmail: "test@example.com",
+            accountOrganization: "Example",
+            loginMethod: "OAuth")
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            tertiary: RateWindow(usedPercent: 30, windowMinutes: 60, resetsAt: nil, resetDescription: nil),
+            mimoUsage: mimoUsage,
+            cursorRequests: CursorRequestUsage(used: 10, limit: 50),
+            subscriptionExpiresAt: updatedAt.addingTimeInterval(100),
+            subscriptionRenewsAt: updatedAt.addingTimeInterval(200),
+            updatedAt: updatedAt,
+            identity: identity)
+
+        let copied = snapshot.with(
+            primary: RateWindow(usedPercent: 40, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 50, windowMinutes: 10080, resetsAt: nil, resetDescription: nil))
+
+        #expect(copied.primary?.usedPercent == 40)
+        #expect(copied.secondary?.usedPercent == 50)
+        #expect(copied.tertiary?.usedPercent == 30)
+        #expect(copied.mimoUsage?.balance == 12.5)
+        #expect(copied.cursorRequests?.used == 10)
+        #expect(copied.subscriptionExpiresAt == updatedAt.addingTimeInterval(100))
+        #expect(copied.subscriptionRenewsAt == updatedAt.addingTimeInterval(200))
+        #expect(copied.identity?.accountOrganization == "Example")
+    }
+
+    @Test
+    func `copying identity preserves provider payloads`() {
+        let updatedAt = Date(timeIntervalSince1970: 1_800_000_000)
+        let ampUsage = AmpUsageDetails(
+            individualCredits: 12.5,
+            workspaceBalances: [AmpWorkspaceBalance(name: "Team", remaining: 7.25)])
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            ampUsage: ampUsage,
+            cursorRequests: CursorRequestUsage(used: 10, limit: 50),
+            subscriptionExpiresAt: updatedAt.addingTimeInterval(100),
+            subscriptionRenewsAt: updatedAt.addingTimeInterval(200),
+            updatedAt: updatedAt)
+        let identity = ProviderIdentitySnapshot(
+            providerID: .kilo,
+            accountEmail: "test@example.com",
+            accountOrganization: "Example",
+            loginMethod: "API")
+
+        let copied = snapshot.withIdentity(identity)
+
+        #expect(copied.ampUsage == ampUsage)
+        #expect(copied.cursorRequests?.used == 10)
+        #expect(copied.subscriptionExpiresAt == updatedAt.addingTimeInterval(100))
+        #expect(copied.subscriptionRenewsAt == updatedAt.addingTimeInterval(200))
+        #expect(copied.identity?.accountOrganization == "Example")
+    }
+
+    @Test
+    func `copilot icon falls back to chat lane when selected budget is unavailable`() {
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 20, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 30, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            extraRateWindows: nil,
+            updatedAt: Date())
+
+        let remaining = IconRemainingResolver.resolvedRemaining(
+            snapshot: snapshot,
+            style: .copilot,
+            secondaryOverrideWindowID: "copilot-budget-agent")
+
+        #expect(remaining.primary == 80)
+        #expect(remaining.secondary == 70)
+    }
+
+    @Test
+    func `copilot icon uses selected budget in show used mode`() {
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 20, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 30, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            extraRateWindows: [
+                NamedRateWindow(
+                    id: "copilot-budget-agent",
+                    title: "Budget - Copilot Agent Premium Requests",
+                    window: RateWindow(usedPercent: 65, windowMinutes: nil, resetsAt: nil, resetDescription: nil)),
+            ],
+            updatedAt: Date())
+
+        let percents = IconRemainingResolver.resolvedPercents(
+            snapshot: snapshot,
+            style: .copilot,
+            showUsed: true,
+            secondaryOverrideWindowID: "copilot-budget-agent")
+
+        #expect(percents.primary == 20)
+        #expect(percents.secondary == 65)
+    }
+
+    @Test
+    func `warp icon preserves exhausted bonus layout in show used mode`() {
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        let percents = IconRemainingResolver.resolvedPercents(
+            snapshot: snapshot,
+            style: .warp,
+            showUsed: true)
+
+        #expect(percents.primary == 10)
+        #expect(percents.secondary == 0)
+    }
+
+    @Test
+    func `warp icon keeps unused bonus lane visible in show used mode`() {
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 0, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        let percents = IconRemainingResolver.resolvedPercents(
+            snapshot: snapshot,
+            style: .warp,
+            showUsed: true)
+
+        #expect(percents.primary == 10)
+        #expect(percents.secondary != nil)
+        #expect(percents.secondary ?? 1 < 0.01)
+    }
+
+    @Test
+    func `merged icon keeps exhausted warp bonus fully used`() {
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        let percents = IconRemainingResolver.resolvedPercents(
+            snapshot: snapshot,
+            style: .warp,
+            showUsed: true,
+            renderingStyle: .combined)
+
+        #expect(percents.primary == 10)
+        #expect(percents.secondary == 100)
+    }
+
+    @Test
+    @MainActor
+    func `status icon accessibility uses percentage scale`() {
+        #expect(
+            StatusIconView.accessibilityPercentRemaining(50) ==
+                String(format: L("%d percent remaining"), 50))
+    }
+
+    @Test
+    func `codex icon promotes weekly only window into primary display lane`() {
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: RateWindow(usedPercent: 25, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            tertiary: nil,
+            updatedAt: Date())
+
+        let remaining = IconRemainingResolver.resolvedRemaining(snapshot: snapshot, style: .codex)
+        #expect(remaining.primary == 75)
+        #expect(remaining.secondary == nil)
+    }
+
+    @Test
+    func `codex icon uses semantic projection lanes when durations drift`() {
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: RateWindow(usedPercent: 25, windowMinutes: 11040, resetsAt: nil, resetDescription: nil),
+            tertiary: nil,
+            updatedAt: Date())
+
+        let remaining = IconRemainingResolver.resolvedRemaining(snapshot: snapshot, style: .codex)
+        #expect(remaining.primary == 75)
+        #expect(remaining.secondary == nil)
+    }
+
+    @Test
+    func `status overlays cut halos through the quota bar and keep glyphs visible`() throws {
+        let plain = IconRenderer.makeIcon(
+            primaryRemaining: 100,
+            weeklyRemaining: 100,
+            creditsRemaining: nil,
+            stale: false,
+            style: .combined,
+            statusIndicator: .none)
+        let plainRep = try #require(plain.representations.compactMap { $0 as? NSBitmapImageRep }.first {
+            $0.pixelsWide == 36 && $0.pixelsHigh == 36
+        })
+
+        func alpha(_ rep: NSBitmapImageRep, x: Int, y: Int) -> CGFloat {
+            (rep.colorAt(x: x, y: y) ?? .clear).alphaComponent
+        }
+
+        for indicator in [ProviderStatusIndicator.minor, .major] {
+            let marked = IconRenderer.makeIcon(
+                primaryRemaining: 100,
+                weeklyRemaining: 100,
+                creditsRemaining: nil,
+                stale: false,
+                style: .combined,
+                statusIndicator: indicator)
+            let markedRep = try #require(marked.representations.compactMap { $0 as? NSBitmapImageRep }.first {
+                $0.pixelsWide == 36 && $0.pixelsHigh == 36
+            })
+
+            var cutoutPixels = 0
+            var glyphPixels = 0
+            for y in 0..<markedRep.pixelsHigh {
+                for x in 0..<markedRep.pixelsWide {
+                    let plainAlpha = alpha(plainRep, x: x, y: y)
+                    let markedAlpha = alpha(markedRep, x: x, y: y)
+                    if plainAlpha > 0.5, markedAlpha < 0.05 {
+                        cutoutPixels += 1
+                    }
+                    if plainAlpha < 0.05, markedAlpha > 0.5 {
+                        glyphPixels += 1
+                    }
+                }
+            }
+
+            #expect(cutoutPixels >= 8, "Expected halo cutout pixels for \(indicator)")
+            #expect(glyphPixels >= 4, "Expected visible glyph pixels for \(indicator)")
+        }
+    }
+
+    @Test
+    func `icon renderer codex eyes punch through when unknown`() {
         // Regression: when remaining is nil, CoreGraphics inherits the previous fill alpha which caused
         // destinationOut “eyes” to become semi-transparent instead of fully punched through.
         let image = IconRenderer.makeIcon(
@@ -116,7 +717,7 @@ struct CodexBarTests {
     }
 
     @Test
-    func iconRendererWarpEyesCutOutAtExpectedCenters() {
+    func `icon renderer warp eyes cut out at expected centers`() {
         // Regression: Warp eyes should be tilted in-place and remain centered on the face.
         let image = IconRenderer.makeIcon(
             primaryRemaining: 50,
@@ -169,7 +770,28 @@ struct CodexBarTests {
     }
 
     @Test
-    func accountInfoParsesAuthToken() throws {
+    func `account info parses snake case auth token`() throws {
+        let tmp = try FileManager.default.url(
+            for: .itemReplacementDirectory,
+            in: .userDomainMask,
+            appropriateFor: URL(fileURLWithPath: NSTemporaryDirectory()),
+            create: true)
+        defer { try? FileManager.default.removeItem(at: tmp) }
+
+        let token = Self.fakeJWT(email: "user@example.com", plan: "pro")
+        let auth = ["tokens": ["id_token": token, "access_token": "access", "refresh_token": "refresh"]]
+        let data = try JSONSerialization.data(withJSONObject: auth)
+        let authURL = tmp.appendingPathComponent("auth.json")
+        try data.write(to: authURL)
+
+        let fetcher = UsageFetcher(environment: ["CODEX_HOME": tmp.path])
+        let account = fetcher.loadAccountInfo()
+        #expect(account.email == "user@example.com")
+        #expect(account.plan == "pro")
+    }
+
+    @Test
+    func `account info parses legacy camel case auth token`() throws {
         let tmp = try FileManager.default.url(
             for: .itemReplacementDirectory,
             in: .userDomainMask,
@@ -178,7 +800,7 @@ struct CodexBarTests {
         defer { try? FileManager.default.removeItem(at: tmp) }
 
         let token = Self.fakeJWT(email: "user@example.com", plan: "pro")
-        let auth = ["tokens": ["idToken": token]]
+        let auth = ["tokens": ["idToken": token, "accessToken": "access", "refreshToken": "refresh"]]
         let data = try JSONSerialization.data(withJSONObject: auth)
         let authURL = tmp.appendingPathComponent("auth.json")
         try data.write(to: authURL)
diff --git a/Tests/CodexBarTests/CommandCodeProviderTests.swift b/Tests/CodexBarTests/CommandCodeProviderTests.swift
new file mode 100644
index 0000000000..3ddf01f2a2
--- /dev/null
+++ b/Tests/CodexBarTests/CommandCodeProviderTests.swift
@@ -0,0 +1,44 @@
+import Testing
+@testable import CodexBar
+@testable import CodexBarCore
+
+struct CommandCodeProviderTests {
+    @Test
+    func `descriptor metadata is correct`() {
+        let descriptor = ProviderDescriptorRegistry.descriptor(for: .commandcode)
+
+        #expect(descriptor.metadata.displayName == "Command Code")
+        #expect(descriptor.metadata.dashboardURL == "https://commandcode.ai/studio")
+        #expect(descriptor.metadata.subscriptionDashboardURL == "https://commandcode.ai/sixhobbits/settings/billing")
+        #expect(descriptor.metadata.cliName == "commandcode")
+        #expect(descriptor.branding.iconResourceName == "ProviderIcon-commandcode")
+        #expect(descriptor.branding.iconStyle == .commandcode)
+    }
+
+    @Test
+    func `manual cookie makes web strategy available`() async {
+        let browserDetection = BrowserDetection(cacheTTL: 0)
+        let settings = ProviderSettingsSnapshot.make(
+            commandcode: .init(cookieSource: .manual, manualCookieHeader: "session=manual"))
+        let context = ProviderFetchContext(
+            runtime: .cli,
+            sourceMode: .web,
+            includeCredits: true,
+            webTimeout: 1,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: [:],
+            settings: settings,
+            fetcher: UsageFetcher(),
+            claudeFetcher: ClaudeUsageFetcher(browserDetection: browserDetection),
+            browserDetection: browserDetection)
+
+        #expect(await CommandCodeWebFetchStrategy().isAvailable(context))
+    }
+
+    @MainActor
+    @Test
+    func `implementation is registered`() {
+        #expect(ProviderCatalog.implementation(for: .commandcode) != nil)
+    }
+}
diff --git a/Tests/CodexBarTests/CommandCodeQuotaTransitionTests.swift b/Tests/CodexBarTests/CommandCodeQuotaTransitionTests.swift
new file mode 100644
index 0000000000..a718f5037b
--- /dev/null
+++ b/Tests/CodexBarTests/CommandCodeQuotaTransitionTests.swift
@@ -0,0 +1,170 @@
+import Foundation
+import Testing
+@testable import CodexBar
+@testable import CodexBarCore
+
+@MainActor
+struct CommandCodeQuotaTransitionTests {
+    @Test
+    func `display keeps prior primary only during subscription enrichment failure`() throws {
+        let plan = try #require(CommandCodePlanCatalog.plans.first { $0.monthlyCreditsUSD > 0 })
+        let availableWithPlan = self.snapshot(remaining: 6, plan: plan)
+        let missingSubscription = self.snapshot(
+            remaining: 0,
+            purchasedCredits: 5,
+            plan: nil,
+            subscriptionUnavailable: true)
+        let freeTier = self.snapshot(remaining: 0, plan: nil)
+        let freeTierWithPurchasedCredits = self.snapshot(remaining: 0, purchasedCredits: 5, plan: nil)
+
+        #expect(missingSubscription.primary?.usedPercent == 0)
+        #expect(freeTierWithPurchasedCredits.primary?.usedPercent == 0)
+
+        let stabilized = UsageStore.commandCodeSnapshotResolvingDepletionOnEnrichmentFailure(
+            current: missingSubscription,
+            previous: availableWithPlan)
+        #expect(stabilized.primary?.usedPercent == 100)
+
+        let stabilizedAgain = UsageStore.commandCodeSnapshotResolvingDepletionOnEnrichmentFailure(
+            current: missingSubscription,
+            previous: stabilized)
+        #expect(stabilizedAgain.primary?.usedPercent == 100)
+
+        let startupFailure = UsageStore.commandCodeSnapshotResolvingDepletionOnEnrichmentFailure(
+            current: missingSubscription,
+            previous: nil)
+        #expect(startupFailure.primary?.usedPercent == 0)
+
+        let freeTierFailure = UsageStore.commandCodeSnapshotResolvingDepletionOnEnrichmentFailure(
+            current: missingSubscription,
+            previous: freeTierWithPurchasedCredits)
+        #expect(freeTierFailure.primary?.usedPercent == 0)
+
+        let validFreeTier = UsageStore.commandCodeSnapshotResolvingDepletionOnEnrichmentFailure(
+            current: freeTier,
+            previous: availableWithPlan)
+        #expect(validFreeTier.primary == nil)
+    }
+
+    @Test
+    func `depleted notification does not refire across missing subscription window`() throws {
+        let settings = self.makeSettings(suiteName: "CommandCodeDepletedNoRefire")
+        settings.sessionQuotaNotificationsEnabled = true
+        let notifier = NotifierSpy()
+        let store = self.makeStore(settings: settings, notifier: notifier)
+        let plan = try #require(CommandCodePlanCatalog.plans.first { $0.monthlyCreditsUSD > 0 })
+        let depletedWithPlan = self.snapshot(remaining: 0, plan: plan)
+        let freeTier = self.snapshot(remaining: 0, plan: nil)
+        let missingSubscription = self.snapshot(
+            remaining: 0,
+            purchasedCredits: 5,
+            plan: nil,
+            subscriptionUnavailable: true)
+
+        store.handleSessionQuotaTransition(provider: .commandcode, snapshot: freeTier)
+        #expect(notifier.posts.isEmpty)
+
+        store.handleSessionQuotaTransition(provider: .commandcode, snapshot: depletedWithPlan)
+        let stabilizedFailure = UsageStore.commandCodeSnapshotResolvingDepletionOnEnrichmentFailure(
+            current: missingSubscription,
+            previous: depletedWithPlan)
+        store.handleSessionQuotaTransition(provider: .commandcode, snapshot: stabilizedFailure)
+        let repeatedFailure = UsageStore.commandCodeSnapshotResolvingDepletionOnEnrichmentFailure(
+            current: missingSubscription,
+            previous: stabilizedFailure)
+        store.handleSessionQuotaTransition(provider: .commandcode, snapshot: repeatedFailure)
+        store.handleSessionQuotaTransition(provider: .commandcode, snapshot: depletedWithPlan)
+
+        #expect(notifier.posts.count(where: { $0.transition == .depleted }) == 1)
+
+        store.handleSessionQuotaTransition(provider: .commandcode, snapshot: freeTier)
+        store.handleSessionQuotaTransition(provider: .commandcode, snapshot: depletedWithPlan)
+        #expect(notifier.posts.count(where: { $0.transition == .depleted }) == 2)
+    }
+
+    @Test
+    func `quota warning does not refire across missing subscription window`() throws {
+        let settings = self.makeSettings(suiteName: "CommandCodeWarningNoRefire")
+        settings.quotaWarningNotificationsEnabled = true
+        settings.quotaWarningThresholds = [50]
+        let notifier = NotifierSpy()
+        let store = self.makeStore(settings: settings, notifier: notifier)
+        let plan = try #require(CommandCodePlanCatalog.plans.first { $0.monthlyCreditsUSD > 0 })
+
+        store.handleQuotaWarningTransitions(provider: .commandcode, snapshot: self.snapshot(remaining: 6, plan: plan))
+        store.handleQuotaWarningTransitions(provider: .commandcode, snapshot: self.snapshot(remaining: 4, plan: plan))
+        let availableWithPlan = self.snapshot(remaining: 4, plan: plan)
+        let missingSubscription = self.snapshot(
+            remaining: 0,
+            purchasedCredits: 5,
+            plan: nil,
+            subscriptionUnavailable: true)
+        let stabilizedFailure = UsageStore.commandCodeSnapshotResolvingDepletionOnEnrichmentFailure(
+            current: missingSubscription,
+            previous: availableWithPlan)
+        store.handleQuotaWarningTransitions(provider: .commandcode, snapshot: stabilizedFailure)
+        let repeatedFailure = UsageStore.commandCodeSnapshotResolvingDepletionOnEnrichmentFailure(
+            current: missingSubscription,
+            previous: stabilizedFailure)
+        store.handleQuotaWarningTransitions(provider: .commandcode, snapshot: repeatedFailure)
+        store.handleQuotaWarningTransitions(provider: .commandcode, snapshot: self.snapshot(remaining: 4, plan: plan))
+
+        #expect(notifier.quotaWarningPosts.count == 1)
+
+        store.handleQuotaWarningTransitions(provider: .commandcode, snapshot: self.snapshot(remaining: 0, plan: nil))
+        store.handleQuotaWarningTransitions(provider: .commandcode, snapshot: self.snapshot(remaining: 4, plan: plan))
+        #expect(notifier.quotaWarningPosts.count == 2)
+    }
+
+    private func makeSettings(suiteName: String) -> SettingsStore {
+        let defaults = UserDefaults(suiteName: suiteName)!
+        defaults.removePersistentDomain(forName: suiteName)
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suiteName),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        return settings
+    }
+
+    private func makeStore(settings: SettingsStore, notifier: NotifierSpy) -> UsageStore {
+        UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            sessionQuotaNotifier: notifier)
+    }
+
+    private func snapshot(
+        remaining: Double,
+        purchasedCredits: Double = 0,
+        plan: CommandCodePlanCatalog.Plan?,
+        subscriptionUnavailable: Bool = false) -> UsageSnapshot
+    {
+        CommandCodeUsageSnapshot(
+            monthlyCreditsRemaining: remaining,
+            purchasedCredits: purchasedCredits,
+            premiumMonthlyCredits: 0,
+            opensourceMonthlyCredits: 0,
+            plan: plan,
+            billingPeriodEnd: nil,
+            subscriptionStatus: plan == nil ? nil : "active",
+            subscriptionEnrichmentUnavailable: subscriptionUnavailable)
+            .toUsageSnapshot()
+    }
+
+    private final class NotifierSpy: SessionQuotaNotifying {
+        private(set) var posts: [(transition: SessionQuotaTransition, provider: UsageProvider)] = []
+        private(set) var quotaWarningPosts: [QuotaWarningEvent] = []
+
+        func post(transition: SessionQuotaTransition, provider: UsageProvider, badge _: NSNumber?) {
+            self.posts.append((transition, provider))
+        }
+
+        func postQuotaWarning(event: QuotaWarningEvent, provider _: UsageProvider, soundEnabled _: Bool) {
+            self.quotaWarningPosts.append(event)
+        }
+    }
+}
diff --git a/Tests/CodexBarTests/CommandCodeUsageFetcherTests.swift b/Tests/CodexBarTests/CommandCodeUsageFetcherTests.swift
new file mode 100644
index 0000000000..5e76290e27
--- /dev/null
+++ b/Tests/CodexBarTests/CommandCodeUsageFetcherTests.swift
@@ -0,0 +1,416 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+/// Tests for `CommandCodeUsageFetcher` parsers and the cookie/snapshot derivation,
+/// using real responses captured from api.commandcode.ai for an active "individual-go" plan.
+struct CommandCodeUsageFetcherTests {
+    private static let creditsJSON = """
+    {"credits":{"belowThreshold":false,"creditThreshold":0,"monthlyCredits":8.7784,\
+    "purchasedCredits":0,"premiumMonthlyCredits":0,"opensourceMonthlyCredits":8.7784}}
+    """
+
+    private static let subscriptionJSON = """
+    {"success":true,"data":{"id":"sub_1TTzt3DSZgxV3MJKG4ClCWpn","status":"active",\
+    "userId":"915e93a7-a1f9-4c97-a3f0-20a85fcb3a45","orgId":null,\
+    "createdAt":"2026-05-06T07:28:50.000Z","priceId":"price_1TMD8zDSZgxV3MJKxOZMVZrP",\
+    "metadata":{"commandCode":"true","commandCodeUserId":"915e93a7-a1f9-4c97-a3f0-20a85fcb3a45"},\
+    "quantity":1,"cancelAtPeriodEnd":false,\
+    "currentPeriodStart":"2026-05-06T07:28:50.000Z","currentPeriodEnd":"2026-06-06T07:28:50.000Z",\
+    "endedAt":null,"cancelAt":null,"canceledAt":null,"planId":"individual-go"}}
+    """
+
+    @Test
+    func `parses credits payload`() throws {
+        let data = try #require(Self.creditsJSON.data(using: .utf8))
+        let payload = try CommandCodeUsageFetcher.parseCredits(data: data)
+        #expect(payload.monthlyCredits == 8.7784)
+        #expect(payload.purchasedCredits == 0)
+        #expect(payload.premiumMonthlyCredits == 0)
+        #expect(payload.opensourceMonthlyCredits == 8.7784)
+    }
+
+    @Test
+    func `parses subscription payload`() throws {
+        let data = try #require(Self.subscriptionJSON.data(using: .utf8))
+        let payload = try #require(try CommandCodeUsageFetcher.parseSubscription(data: data))
+        #expect(payload.planID == "individual-go")
+        #expect(payload.status == "active")
+        let isoFormatter = ISO8601DateFormatter()
+        isoFormatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        let expectedEnd = isoFormatter.date(from: "2026-06-06T07:28:50.000Z")
+        #expect(payload.currentPeriodEnd == expectedEnd)
+    }
+
+    @Test
+    func `subscription on free tier returns nil`() throws {
+        let data = Data(#"{"success":true,"data":null}"#.utf8)
+        let payload = try CommandCodeUsageFetcher.parseSubscription(data: data)
+        #expect(payload == nil)
+    }
+
+    @Test
+    func `successful free tier lookup has no usage window`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            let path = try #require(request.url?.path)
+            let body = if path.hasSuffix("/credits") {
+                """
+                {"credits":{"monthlyCredits":0,"purchasedCredits":0,
+                "premiumMonthlyCredits":0,"opensourceMonthlyCredits":0}}
+                """
+            } else {
+                #"{"success":true,"data":null}"#
+            }
+            return try Self.response(request: request, statusCode: 200, body: body)
+        }
+
+        let snapshot = try await CommandCodeUsageFetcher.fetchUsage(
+            cookieHeader: "session=valid",
+            session: transport)
+
+        #expect(snapshot.subscriptionEnrichmentUnavailable == false)
+        #expect(snapshot.toUsageSnapshot().primary == nil)
+    }
+
+    @Test
+    func `subscription failure envelope preserves required credits`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            let path = try #require(request.url?.path)
+            if path.hasSuffix("/credits") {
+                return try Self.response(request: request, statusCode: 200, body: Self.creditsJSON)
+            }
+            return try Self.response(
+                request: request,
+                statusCode: 200,
+                body: #"{"success":false,"error":"temporarily unavailable"}"#)
+        }
+
+        let snapshot = try await CommandCodeUsageFetcher.fetchUsage(
+            cookieHeader: "session=valid",
+            session: transport,
+            now: Date(timeIntervalSince1970: 123))
+
+        #expect(snapshot.monthlyCreditsRemaining == 8.7784)
+        #expect(snapshot.plan == nil)
+        #expect(snapshot.subscriptionEnrichmentUnavailable)
+        #expect(snapshot.updatedAt == Date(timeIntervalSince1970: 123))
+    }
+
+    @Test
+    func `successful subscription envelope requires explicit data`() throws {
+        let data = Data(#"{"success":true}"#.utf8)
+
+        #expect(throws: CommandCodeUsageError.self) {
+            try CommandCodeUsageFetcher.parseSubscription(data: data)
+        }
+    }
+
+    @Test
+    func `subscription failure preserves required credits`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            let path = try #require(request.url?.path)
+            if path.hasSuffix("/credits") {
+                return try Self.response(request: request, statusCode: 200, body: Self.creditsJSON)
+            }
+            return try Self.response(request: request, statusCode: 503, body: #"{"error":"unavailable"}"#)
+        }
+
+        let snapshot = try await CommandCodeUsageFetcher.fetchUsage(
+            cookieHeader: "session=valid",
+            session: transport,
+            now: Date(timeIntervalSince1970: 123))
+
+        #expect(snapshot.monthlyCreditsRemaining == 8.7784)
+        #expect(snapshot.plan == nil)
+        #expect(snapshot.billingPeriodEnd == nil)
+        #expect(snapshot.subscriptionEnrichmentUnavailable)
+        #expect(snapshot.updatedAt == Date(timeIntervalSince1970: 123))
+    }
+
+    @Test
+    func `subscription timeout does not hold credits for full request timeout`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            let path = try #require(request.url?.path)
+            if path.hasSuffix("/credits") {
+                return try Self.response(request: request, statusCode: 200, body: Self.creditsJSON)
+            }
+            try await Task.sleep(for: .seconds(10))
+            return try Self.response(request: request, statusCode: 200, body: Self.subscriptionJSON)
+        }
+
+        let startedAt = ContinuousClock.now
+        let snapshot = try await CommandCodeUsageFetcher.fetchUsage(
+            cookieHeader: "session=valid",
+            session: transport)
+        let elapsed = startedAt.duration(to: .now)
+
+        #expect(snapshot.monthlyCreditsRemaining == 8.7784)
+        #expect(snapshot.plan == nil)
+        #expect(snapshot.subscriptionEnrichmentUnavailable)
+        #expect(elapsed < .seconds(3), "Subscription enrichment delayed credits: \(elapsed)")
+    }
+
+    @Test
+    func `subscription grace does not wait for transport that ignores cancellation`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            let path = try #require(request.url?.path)
+            if path.hasSuffix("/credits") {
+                return try Self.response(request: request, statusCode: 200, body: Self.creditsJSON)
+            }
+            let response = try Self.response(request: request, statusCode: 200, body: Self.subscriptionJSON)
+            return await withCheckedContinuation { continuation in
+                DispatchQueue.global().asyncAfter(deadline: .now() + 0.5) {
+                    continuation.resume(returning: response)
+                }
+            }
+        }
+
+        let startedAt = ContinuousClock.now
+        let snapshot = try await CommandCodeUsageFetcher._fetchUsageForTesting(
+            cookieHeader: "session=valid",
+            transport: transport,
+            subscriptionGrace: .milliseconds(20))
+        let elapsed = startedAt.duration(to: .now)
+
+        #expect(snapshot.monthlyCreditsRemaining == 8.7784)
+        #expect(snapshot.plan == nil)
+        #expect(snapshot.subscriptionEnrichmentUnavailable)
+        #expect(elapsed < .milliseconds(300), "Subscription enrichment delayed credits: \(elapsed)")
+
+        // Let the deliberately cancellation-ignoring test task drain before the test exits.
+        try await Task.sleep(for: .milliseconds(550))
+    }
+
+    @Test
+    func `cancellation after credits complete does not return partial snapshot`() async throws {
+        let subscriptionStarted = CommandCodeRequestGate()
+        let transport = ProviderHTTPTransportStub { request in
+            let path = try #require(request.url?.path)
+            if path.hasSuffix("/credits") {
+                return try Self.response(request: request, statusCode: 200, body: Self.creditsJSON)
+            }
+            await subscriptionStarted.open()
+            try await Task.sleep(for: .seconds(10))
+            return try Self.response(request: request, statusCode: 200, body: Self.subscriptionJSON)
+        }
+        let task = Task {
+            try await CommandCodeUsageFetcher.fetchUsage(
+                cookieHeader: "session=valid",
+                session: transport)
+        }
+
+        await subscriptionStarted.wait()
+        try await Task.sleep(for: .milliseconds(50))
+        task.cancel()
+
+        await #expect(throws: CancellationError.self) {
+            try await task.value
+        }
+    }
+
+    @Test
+    func `cancellation cleans up subscription when credits transport ignores cancellation`() async throws {
+        let creditsStarted = CommandCodeRequestGate()
+        let subscriptionStarted = CommandCodeRequestGate()
+        let subscriptionCancelled = CommandCodeRequestGate()
+        let transport = ProviderHTTPTransportStub { request in
+            let path = try #require(request.url?.path)
+            if path.hasSuffix("/credits") {
+                await creditsStarted.open()
+                let response = try Self.response(request: request, statusCode: 200, body: Self.creditsJSON)
+                return await withCheckedContinuation { continuation in
+                    DispatchQueue.global().asyncAfter(deadline: .now() + 0.5) {
+                        continuation.resume(returning: response)
+                    }
+                }
+            }
+            await subscriptionStarted.open()
+            do {
+                try await Task.sleep(for: .seconds(10))
+            } catch {
+                await subscriptionCancelled.open()
+                throw error
+            }
+            return try Self.response(request: request, statusCode: 200, body: Self.subscriptionJSON)
+        }
+        let task = Task {
+            try await CommandCodeUsageFetcher.fetchUsage(
+                cookieHeader: "session=valid",
+                session: transport)
+        }
+
+        await creditsStarted.wait()
+        await subscriptionStarted.wait()
+        let cancellationStartedAt = ContinuousClock.now
+        task.cancel()
+
+        await subscriptionCancelled.wait()
+        #expect(cancellationStartedAt.duration(to: .now) < .milliseconds(300))
+        await #expect(throws: CancellationError.self) {
+            try await task.value
+        }
+    }
+
+    @Test
+    func `cancellation wins when optional transport ignores cancellation then fails`() async throws {
+        let subscriptionStarted = CommandCodeRequestGate()
+        let transport = ProviderHTTPTransportStub { request in
+            let path = try #require(request.url?.path)
+            if path.hasSuffix("/credits") {
+                return try Self.response(request: request, statusCode: 200, body: Self.creditsJSON)
+            }
+            await subscriptionStarted.open()
+            do {
+                try await Task.sleep(for: .seconds(10))
+            } catch {
+                // Simulate a transport that converts cancellation into an ordinary endpoint failure.
+            }
+            return try Self.response(request: request, statusCode: 503, body: #"{"error":"unavailable"}"#)
+        }
+        let task = Task {
+            try await CommandCodeUsageFetcher.fetchUsage(
+                cookieHeader: "session=valid",
+                session: transport)
+        }
+
+        await subscriptionStarted.wait()
+        try await Task.sleep(for: .milliseconds(50))
+        task.cancel()
+
+        await #expect(throws: CancellationError.self) {
+            try await task.value
+        }
+    }
+
+    @Test
+    func `successful unknown active subscription still fails explicitly`() async {
+        let unknownPlanJSON = Self.subscriptionJSON.replacingOccurrences(
+            of: #""planId":"individual-go""#,
+            with: #""planId":"individual-future""#)
+        let transport = ProviderHTTPTransportStub { request in
+            let path = try #require(request.url?.path)
+            let body = path.hasSuffix("/credits") ? Self.creditsJSON : unknownPlanJSON
+            return try Self.response(request: request, statusCode: 200, body: body)
+        }
+
+        await #expect(throws: CommandCodeUsageError.unknownPlan("individual-future")) {
+            try await CommandCodeUsageFetcher.fetchUsage(
+                cookieHeader: "session=valid",
+                session: transport)
+        }
+    }
+
+    @Test
+    func `snapshot derives used and total from plan catalog`() throws {
+        let plan = try #require(CommandCodePlanCatalog.plan(forID: "individual-go"))
+        let snapshot = CommandCodeUsageSnapshot(
+            monthlyCreditsRemaining: 8.7784,
+            purchasedCredits: 0,
+            premiumMonthlyCredits: 0,
+            opensourceMonthlyCredits: 8.7784,
+            plan: plan,
+            billingPeriodEnd: Date(timeIntervalSince1970: 1_780_000_000),
+            subscriptionStatus: "active",
+            updatedAt: Date(timeIntervalSince1970: 0))
+        #expect(snapshot.monthlyCreditsTotal == 10)
+        #expect(abs((snapshot.monthlyCreditsUsed ?? -1) - 1.2216) < 0.0001)
+
+        let usage = snapshot.toUsageSnapshot()
+        let primary = try #require(usage.primary)
+        #expect(abs(primary.usedPercent - 12.216) < 0.001)
+        #expect(primary.resetsAt == Date(timeIntervalSince1970: 1_780_000_000))
+        #expect(usage.identity?.loginMethod == "Go · $1.22 of $10.00")
+    }
+
+    @Test
+    func `free tier with no allowance has no usage window`() {
+        let snapshot = CommandCodeUsageSnapshot(
+            monthlyCreditsRemaining: 0,
+            purchasedCredits: 0,
+            premiumMonthlyCredits: 0,
+            opensourceMonthlyCredits: 0,
+            plan: nil,
+            billingPeriodEnd: nil,
+            subscriptionStatus: nil)
+
+        #expect(snapshot.toUsageSnapshot().primary == nil)
+    }
+
+    @Test
+    func `plan catalog covers known plans`() {
+        #expect(CommandCodePlanCatalog.plan(forID: "individual-go")?.monthlyCreditsUSD == 10)
+        #expect(CommandCodePlanCatalog.plan(forID: "individual-pro")?.monthlyCreditsUSD == 30)
+        #expect(CommandCodePlanCatalog.plan(forID: "individual-max")?.monthlyCreditsUSD == 150)
+        #expect(CommandCodePlanCatalog.plan(forID: "individual-ultra")?.monthlyCreditsUSD == 300)
+        #expect(CommandCodePlanCatalog.plan(forID: "unknown") == nil)
+    }
+
+    @Test
+    func `cookie header extracts secure session cookie`() throws {
+        let raw = "_ga=GA1.2.123; __Secure-better-auth.session_token=abc123; foo=bar"
+        let override = try #require(CommandCodeCookieHeader.override(from: raw))
+        #expect(override.name == "__Secure-better-auth.session_token")
+        #expect(override.token == "abc123")
+        #expect(override.headerValue == "__Secure-better-auth.session_token=abc123")
+    }
+
+    @Test
+    func `cookie header accepts non-secure variant`() throws {
+        let raw = "better-auth.session_token=plain-token"
+        let override = try #require(CommandCodeCookieHeader.override(from: raw))
+        #expect(override.name == "better-auth.session_token")
+        #expect(override.token == "plain-token")
+    }
+
+    @Test
+    func `cookie header accepts bare token and uses secure name`() throws {
+        let override = try #require(CommandCodeCookieHeader.override(from: "bare-value"))
+        #expect(override.name == "__Secure-better-auth.session_token")
+        #expect(override.token == "bare-value")
+    }
+
+    @Test
+    func `cookie header rejects empty input`() {
+        #expect(CommandCodeCookieHeader.override(from: nil) == nil)
+        #expect(CommandCodeCookieHeader.override(from: "") == nil)
+        #expect(CommandCodeCookieHeader.override(from: "   ") == nil)
+    }
+
+    private static func response(
+        request: URLRequest,
+        statusCode: Int,
+        body: String) throws -> (Data, URLResponse)
+    {
+        let url = try #require(request.url)
+        let response = try #require(HTTPURLResponse(
+            url: url,
+            statusCode: statusCode,
+            httpVersion: nil,
+            headerFields: nil))
+        return (Data(body.utf8), response)
+    }
+}
+
+private actor CommandCodeRequestGate {
+    private var isOpen = false
+    private var continuations: [CheckedContinuation<Void, Never>] = []
+
+    func wait() async {
+        guard !self.isOpen else { return }
+        await withCheckedContinuation { continuation in
+            self.continuations.append(continuation)
+        }
+    }
+
+    func open() {
+        self.isOpen = true
+        let continuations = self.continuations
+        self.continuations.removeAll()
+        for continuation in continuations {
+            continuation.resume()
+        }
+    }
+}
diff --git a/Tests/CodexBarTests/ConfigValidationTests.swift b/Tests/CodexBarTests/ConfigValidationTests.swift
index 59c9447c91..37c2ed90ab 100644
--- a/Tests/CodexBarTests/ConfigValidationTests.swift
+++ b/Tests/CodexBarTests/ConfigValidationTests.swift
@@ -2,10 +2,9 @@ import CodexBarCore
 import Foundation
 import Testing
 
-@Suite
 struct ConfigValidationTests {
     @Test
-    func reportsUnsupportedSource() {
+    func `reports unsupported source`() {
         var config = CodexBarConfig.makeDefault()
         config.setProviderConfig(ProviderConfig(id: .codex, source: .api))
         let issues = CodexBarConfigValidator.validate(config)
@@ -13,7 +12,7 @@ struct ConfigValidationTests {
     }
 
     @Test
-    func reportsMissingAPIKeyWhenSourceAPI() {
+    func `reports missing API key when source API`() {
         var config = CodexBarConfig.makeDefault()
         config.setProviderConfig(ProviderConfig(id: .zai, source: .api, apiKey: nil))
         let issues = CodexBarConfigValidator.validate(config)
@@ -21,7 +20,7 @@ struct ConfigValidationTests {
     }
 
     @Test
-    func reportsInvalidRegion() {
+    func `reports invalid region`() {
         var config = CodexBarConfig.makeDefault()
         config.setProviderConfig(ProviderConfig(id: .minimax, region: "nowhere"))
         let issues = CodexBarConfigValidator.validate(config)
@@ -29,7 +28,7 @@ struct ConfigValidationTests {
     }
 
     @Test
-    func warnsOnUnsupportedTokenAccounts() {
+    func `warns on unsupported token accounts`() {
         let accounts = ProviderTokenAccountData(
             version: 1,
             accounts: [ProviderTokenAccount(id: UUID(), label: "a", token: "t", addedAt: 0, lastUsed: nil)],
@@ -41,7 +40,7 @@ struct ConfigValidationTests {
     }
 
     @Test
-    func allowsOllamaTokenAccounts() {
+    func `allows ollama token accounts`() {
         let accounts = ProviderTokenAccountData(
             version: 1,
             accounts: [ProviderTokenAccount(id: UUID(), label: "a", token: "t", addedAt: 0, lastUsed: nil)],
@@ -53,10 +52,172 @@ struct ConfigValidationTests {
     }
 
     @Test
-    func acceptsKiloExtrasConfigField() {
+    func `accepts kilo extras config field`() {
         var config = CodexBarConfig.makeDefault()
         config.setProviderConfig(ProviderConfig(id: .kilo, extrasEnabled: true))
         let issues = CodexBarConfigValidator.validate(config)
         #expect(!issues.contains(where: { $0.provider == .kilo && $0.field == "extrasEnabled" }))
     }
+
+    @Test
+    func `allows deepgram project workspace ID`() {
+        var config = CodexBarConfig.makeDefault()
+        config.setProviderConfig(ProviderConfig(id: .deepgram, workspaceID: "project-123"))
+        let issues = CodexBarConfigValidator.validate(config)
+        #expect(!issues.contains(where: { $0.provider == .deepgram && $0.code == "workspace_unused" }))
+    }
+
+    @Test
+    func `allows Azure OpenAI endpoint and deployment fields`() {
+        var config = CodexBarConfig.makeDefault()
+        config.setProviderConfig(ProviderConfig(
+            id: .azureopenai,
+            workspaceID: "chat-prod",
+            enterpriseHost: "https://example-resource.openai.azure.com"))
+        let issues = CodexBarConfigValidator.validate(config)
+
+        #expect(!issues.contains(where: { $0.provider == .azureopenai && $0.code == "workspace_unused" }))
+        #expect(!issues.contains(where: { $0.provider == .azureopenai && $0.code == "enterprise_host_unused" }))
+    }
+
+    @Test
+    func `allows LiteLLM endpoint`() {
+        var config = CodexBarConfig.makeDefault()
+        config.setProviderConfig(ProviderConfig(
+            id: .litellm,
+            apiKey: "sk-test",
+            enterpriseHost: "https://litellm.example.com"))
+        let issues = CodexBarConfigValidator.validate(config)
+
+        #expect(!issues.contains(where: { $0.provider == .litellm && $0.code == "enterprise_host_unused" }))
+    }
+
+    @Test
+    func `allows OpenAI API project workspace ID`() {
+        var config = CodexBarConfig.makeDefault()
+        config.setProviderConfig(ProviderConfig(id: .openai, workspaceID: "proj_abc"))
+        let issues = CodexBarConfigValidator.validate(config)
+
+        #expect(!issues.contains(where: { $0.provider == .openai && $0.code == "workspace_unused" }))
+    }
+
+    @Test
+    func `warns on unsupported workspace ID`() {
+        var config = CodexBarConfig.makeDefault()
+        config.setProviderConfig(ProviderConfig(id: .gemini, workspaceID: "workspace-123"))
+        let issues = CodexBarConfigValidator.validate(config)
+        #expect(issues.contains(where: { $0.provider == .gemini && $0.code == "workspace_unused" }))
+        #expect(issues.contains(where: { issue in
+            issue.provider == .gemini &&
+                issue.code == "workspace_unused" &&
+                issue.message.contains("openai")
+        }))
+    }
+
+    @Test
+    func `config store default url honors environment override`() {
+        let url = CodexBarConfigStore.defaultURL(environment: [
+            CodexBarConfigStore.pathEnvironmentKey: "~/tmp/codexbar-test-config.json",
+        ])
+
+        #expect(url.path.hasSuffix("/tmp/codexbar-test-config.json"))
+    }
+
+    @Test
+    func `config store default url honors xdg config home`() throws {
+        let fileManager = FileManager.default
+        let home = try Self.makeTemporaryHome()
+        defer { try? fileManager.removeItem(at: home) }
+        let xdgHome = home.appendingPathComponent("custom-config", isDirectory: true)
+
+        let url = CodexBarConfigStore.defaultURL(
+            home: home,
+            environment: [
+                CodexBarConfigStore.xdgConfigHomeEnvironmentKey: xdgHome.path,
+            ],
+            fileManager: fileManager)
+
+        #expect(url == Self.configURL(in: xdgHome))
+    }
+
+    @Test
+    func `config store default url ignores relative xdg config home`() throws {
+        let fileManager = FileManager.default
+        let home = try Self.makeTemporaryHome()
+        defer { try? fileManager.removeItem(at: home) }
+        let legacy = Self.legacyConfigURL(in: home)
+        try Self.touch(legacy, fileManager: fileManager)
+
+        let url = CodexBarConfigStore.defaultURL(
+            home: home,
+            environment: [
+                CodexBarConfigStore.xdgConfigHomeEnvironmentKey: "relative-config",
+            ],
+            fileManager: fileManager)
+
+        #expect(url == legacy)
+    }
+
+    @Test
+    func `config store default url creates in xdg default for new installs`() throws {
+        let fileManager = FileManager.default
+        let home = try Self.makeTemporaryHome()
+        defer { try? fileManager.removeItem(at: home) }
+
+        let url = CodexBarConfigStore.defaultURL(home: home, environment: [:], fileManager: fileManager)
+
+        #expect(url == Self.configURL(in: home.appendingPathComponent(".config", isDirectory: true)))
+    }
+
+    @Test
+    func `config store default url keeps existing legacy config`() throws {
+        let fileManager = FileManager.default
+        let home = try Self.makeTemporaryHome()
+        defer { try? fileManager.removeItem(at: home) }
+        let legacy = Self.legacyConfigURL(in: home)
+        try Self.touch(legacy, fileManager: fileManager)
+
+        let url = CodexBarConfigStore.defaultURL(home: home, environment: [:], fileManager: fileManager)
+
+        #expect(url == legacy)
+    }
+
+    @Test
+    func `config store default url prefers existing xdg default over legacy config`() throws {
+        let fileManager = FileManager.default
+        let home = try Self.makeTemporaryHome()
+        defer { try? fileManager.removeItem(at: home) }
+        let xdgDefault = Self.configURL(in: home.appendingPathComponent(".config", isDirectory: true))
+        let legacy = Self.legacyConfigURL(in: home)
+        try Self.touch(legacy, fileManager: fileManager)
+        try Self.touch(xdgDefault, fileManager: fileManager)
+
+        let url = CodexBarConfigStore.defaultURL(home: home, environment: [:], fileManager: fileManager)
+
+        #expect(url == xdgDefault)
+    }
+
+    private static func makeTemporaryHome() throws -> URL {
+        let url = FileManager.default.temporaryDirectory
+            .appendingPathComponent("CodexBarConfigStoreTests-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: url, withIntermediateDirectories: true)
+        return url
+    }
+
+    private static func touch(_ url: URL, fileManager: FileManager) throws {
+        try fileManager.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true)
+        try Data().write(to: url)
+    }
+
+    private static func configURL(in directory: URL) -> URL {
+        directory
+            .appendingPathComponent("codexbar", isDirectory: true)
+            .appendingPathComponent("config.json")
+    }
+
+    private static func legacyConfigURL(in home: URL) -> URL {
+        home
+            .appendingPathComponent(".codexbar", isDirectory: true)
+            .appendingPathComponent("config.json")
+    }
 }
diff --git a/Tests/CodexBarTests/ConfigurationDocsProviderIDTests.swift b/Tests/CodexBarTests/ConfigurationDocsProviderIDTests.swift
new file mode 100644
index 0000000000..ea14250b4f
--- /dev/null
+++ b/Tests/CodexBarTests/ConfigurationDocsProviderIDTests.swift
@@ -0,0 +1,38 @@
+import CodexBarCore
+import Foundation
+import Testing
+
+struct ConfigurationDocsProviderIDTests {
+    @Test
+    func `configuration docs list every provider id in enum order`() throws {
+        let rootURL = try Self.repoRoot()
+        let docsURL = rootURL.appending(path: "docs/configuration.md")
+        let docs = try String(contentsOf: docsURL, encoding: .utf8)
+
+        let marker = "## Provider IDs"
+        let sectionStart = try #require(docs.range(of: marker)?.upperBound)
+        let section = docs[sectionStart...]
+        let idsLine = try #require(section.split(separator: "\n").first { $0.hasPrefix("`") })
+
+        let documentedIDs = idsLine
+            .split(separator: ",")
+            .map { $0.trimmingCharacters(in: CharacterSet(charactersIn: " `.")) }
+        let expectedIDs = UsageProvider.allCases.map(\.rawValue)
+
+        #expect(documentedIDs == expectedIDs)
+    }
+
+    private static func repoRoot() throws -> URL {
+        var directory = URL(filePath: #filePath).deletingLastPathComponent()
+        for _ in 0..<12 {
+            let packageManifest = directory.appending(path: "Package.swift")
+            if FileManager.default.fileExists(atPath: packageManifest.path(percentEncoded: false)) {
+                return directory
+            }
+            directory.deleteLastPathComponent()
+        }
+        throw NSError(domain: "ConfigurationDocsProviderIDTests", code: 1, userInfo: [
+            NSLocalizedDescriptionKey: "Could not locate repo root (Package.swift) from \(#filePath)",
+        ])
+    }
+}
diff --git a/Tests/CodexBarTests/CookieHeaderCacheConditionalMutationTests.swift b/Tests/CodexBarTests/CookieHeaderCacheConditionalMutationTests.swift
new file mode 100644
index 0000000000..1489ed3325
--- /dev/null
+++ b/Tests/CodexBarTests/CookieHeaderCacheConditionalMutationTests.swift
@@ -0,0 +1,101 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct CookieHeaderCacheConditionalMutationTests {
+    #if os(macOS)
+    @Test
+    func `temporary keychain read permits fresh replacement when legacy state is unchanged`() {
+        self.withIsolatedCookieCache {
+            let legacy = CookieHeaderCache.Entry(
+                cookieHeader: "sessionKey=sk-ant-legacy",
+                storedAt: Date(timeIntervalSince1970: 1),
+                sourceLabel: "Legacy")
+            CookieHeaderCache.store(legacy, to: CookieHeaderCache.legacyURLForTesting(provider: .claude))
+
+            let observation = KeychainCacheStore.withLoadFailureStatusOverrideForTesting(errSecInteractionNotAllowed) {
+                CookieHeaderCache.observeForConditionalMutation(provider: .claude)
+            }
+            let replaced = CookieHeaderCache.storeIfObservationCurrent(
+                provider: .claude,
+                expected: observation,
+                cookieHeader: "sessionKey=sk-ant-fresh",
+                sourceLabel: "Safari")
+
+            #expect(observation.entry == nil)
+            #expect(replaced)
+            #expect(CookieHeaderCache.load(provider: .claude)?.cookieHeader == "sessionKey=sk-ant-fresh")
+            #expect(!CookieHeaderCache.hasLegacyEntryForTesting(provider: .claude))
+        }
+    }
+
+    @Test
+    func `temporary keychain read does not overwrite a concurrent keychain entry`() {
+        self.withIsolatedCookieCache {
+            let observation = KeychainCacheStore.withLoadFailureStatusOverrideForTesting(errSecInteractionNotAllowed) {
+                CookieHeaderCache.observeForConditionalMutation(provider: .claude)
+            }
+            CookieHeaderCache.store(
+                provider: .claude,
+                cookieHeader: "sessionKey=sk-ant-concurrent",
+                sourceLabel: "Chrome")
+
+            let replaced = CookieHeaderCache.storeIfObservationCurrent(
+                provider: .claude,
+                expected: observation,
+                cookieHeader: "sessionKey=sk-ant-fresh",
+                sourceLabel: "Safari")
+
+            #expect(!replaced)
+            #expect(CookieHeaderCache.load(provider: .claude)?.cookieHeader == "sessionKey=sk-ant-concurrent")
+        }
+    }
+    #endif
+
+    @Test
+    func `legacy clear failure still permits replacing the keychain entry`() {
+        self.withIsolatedCookieCache {
+            CookieHeaderCache.store(
+                provider: .claude,
+                cookieHeader: "sessionKey=sk-ant-stale",
+                sourceLabel: "Chrome")
+            let stale = CookieHeaderCache.load(provider: .claude)
+            #expect(stale != nil)
+            guard let stale else { return }
+
+            CookieHeaderCache.store(
+                CookieHeaderCache.Entry(
+                    cookieHeader: "sessionKey=sk-ant-legacy",
+                    storedAt: Date(timeIntervalSince1970: 1),
+                    sourceLabel: "Legacy"),
+                to: CookieHeaderCache.legacyURLForTesting(provider: .claude))
+
+            let cleared = CookieHeaderCache.withLegacyRemovalFailureForTesting {
+                CookieHeaderCache.clearIfCurrent(provider: .claude, expected: stale)
+            }
+            let replaced = CookieHeaderCache.storeIfCurrent(
+                provider: .claude,
+                expected: stale,
+                cookieHeader: "sessionKey=sk-ant-fresh",
+                sourceLabel: "Safari")
+
+            #expect(!cleared)
+            #expect(replaced)
+            #expect(CookieHeaderCache.load(provider: .claude)?.cookieHeader == "sessionKey=sk-ant-fresh")
+            #expect(!CookieHeaderCache.hasLegacyEntryForTesting(provider: .claude))
+        }
+    }
+
+    private func withIsolatedCookieCache<T>(_ operation: () -> T) -> T {
+        KeychainCacheStore.withServiceOverrideForTesting("cookie-conditional-\(UUID().uuidString)") {
+            let legacyBase = FileManager.default.temporaryDirectory
+                .appendingPathComponent(UUID().uuidString, isDirectory: true)
+            return CookieHeaderCache.withLegacyBaseURLOverrideForTesting(legacyBase) {
+                KeychainCacheStore.setTestStoreForTesting(true)
+                defer { KeychainCacheStore.setTestStoreForTesting(false) }
+                return operation()
+            }
+        }
+    }
+}
diff --git a/Tests/CodexBarTests/CookieHeaderCacheTests.swift b/Tests/CodexBarTests/CookieHeaderCacheTests.swift
index f023957225..b09b57fd5c 100644
--- a/Tests/CodexBarTests/CookieHeaderCacheTests.swift
+++ b/Tests/CodexBarTests/CookieHeaderCacheTests.swift
@@ -4,8 +4,12 @@ import Testing
 
 @Suite(.serialized)
 struct CookieHeaderCacheTests {
+    private struct WrongEntry: Codable {
+        let value: String
+    }
+
     @Test
-    func storesAndLoadsEntry() {
+    func `stores and loads entry`() {
         KeychainCacheStore.setTestStoreForTesting(true)
         defer { KeychainCacheStore.setTestStoreForTesting(false) }
 
@@ -26,7 +30,282 @@ struct CookieHeaderCacheTests {
     }
 
     @Test
-    func migratesLegacyFileToKeychain() {
+    func `conditional mutation does not overwrite or clear a newer entry`() {
+        self.withIsolatedCookieCache {
+            CookieHeaderCache.store(
+                provider: .claude,
+                cookieHeader: "sessionKey=sk-ant-initial",
+                sourceLabel: "Chrome")
+            let loaded = CookieHeaderCache.load(provider: .claude)
+            #expect(loaded != nil)
+            guard let initial = loaded else { return }
+
+            let renewed = CookieHeaderCache.storeIfCurrent(
+                provider: .claude,
+                expected: initial,
+                cookieHeader: "sessionKey=sk-ant-newer",
+                sourceLabel: "Chrome")
+            let staleStore = CookieHeaderCache.storeIfCurrent(
+                provider: .claude,
+                expected: initial,
+                cookieHeader: "sessionKey=sk-ant-older",
+                sourceLabel: "Chrome")
+            let staleClear = CookieHeaderCache.clearIfCurrent(provider: .claude, expected: initial)
+
+            #expect(renewed)
+            #expect(!staleStore)
+            #expect(!staleClear)
+            #expect(CookieHeaderCache.load(provider: .claude)?.cookieHeader == "sessionKey=sk-ant-newer")
+        }
+    }
+
+    @Test
+    func `conditional clear failure still permits replacing the same entry`() {
+        self.withIsolatedCookieCache {
+            CookieHeaderCache.store(
+                provider: .claude,
+                cookieHeader: "sessionKey=sk-ant-stale",
+                sourceLabel: "Chrome")
+            let loaded = CookieHeaderCache.load(provider: .claude)
+            #expect(loaded != nil)
+            guard let stale = loaded else { return }
+
+            let cleared = KeychainCacheStore.withClearFailureStatusOverrideForTesting(errSecInteractionNotAllowed) {
+                CookieHeaderCache.clearIfCurrent(provider: .claude, expected: stale)
+            }
+            let replaced = CookieHeaderCache.storeIfCurrent(
+                provider: .claude,
+                expected: stale,
+                cookieHeader: "sessionKey=sk-ant-fresh",
+                sourceLabel: "Safari")
+
+            #expect(!cleared)
+            #expect(replaced)
+            #expect(CookieHeaderCache.load(provider: .claude)?.cookieHeader == "sessionKey=sk-ant-fresh")
+        }
+    }
+
+    @Test
+    func `conditional mutation recognizes a legacy entry after migration failure`() {
+        self.withIsolatedCookieCache {
+            let legacy = CookieHeaderCache.Entry(
+                cookieHeader: "sessionKey=sk-ant-legacy",
+                storedAt: Date(timeIntervalSince1970: 1),
+                sourceLabel: "Chrome")
+            CookieHeaderCache.store(legacy, to: CookieHeaderCache.legacyURLForTesting(provider: .claude))
+
+            let loaded = KeychainCacheStore.withStoreFailureStatusOverrideForTesting(errSecInteractionNotAllowed) {
+                CookieHeaderCache.load(provider: .claude)
+            }
+            #expect(loaded?.cookieHeader == legacy.cookieHeader)
+            guard let loaded else { return }
+
+            let cleared = CookieHeaderCache.clearIfCurrent(provider: .claude, expected: loaded)
+            let replaced = CookieHeaderCache.storeIfCurrent(
+                provider: .claude,
+                expected: nil,
+                cookieHeader: "sessionKey=sk-ant-fresh",
+                sourceLabel: "Safari")
+
+            #expect(cleared)
+            #expect(replaced)
+            #expect(CookieHeaderCache.load(provider: .claude)?.cookieHeader == "sessionKey=sk-ant-fresh")
+        }
+    }
+
+    @Test
+    func `stores separate codex entries per managed account scope`() {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+        let provider: UsageProvider = .codex
+        let accountA = UUID()
+        let accountB = UUID()
+
+        CookieHeaderCache.store(
+            provider: provider,
+            scope: .managedAccount(accountA),
+            cookieHeader: "auth=account-a",
+            sourceLabel: "Chrome")
+        CookieHeaderCache.store(
+            provider: provider,
+            scope: .managedAccount(accountB),
+            cookieHeader: "auth=account-b",
+            sourceLabel: "Safari")
+        defer {
+            CookieHeaderCache.clear(provider: provider, scope: .managedAccount(accountA))
+            CookieHeaderCache.clear(provider: provider, scope: .managedAccount(accountB))
+        }
+
+        #expect(CookieHeaderCache.load(provider: provider, scope: .managedAccount(accountA))?
+            .cookieHeader == "auth=account-a")
+        #expect(CookieHeaderCache.load(provider: provider, scope: .managedAccount(accountB))?
+            .cookieHeader == "auth=account-b")
+        #expect(CookieHeaderCache.load(provider: provider)?.cookieHeader == nil)
+    }
+
+    @Test
+    func `profile home scopes isolate same email sessions without exposing paths`() {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+        let provider: UsageProvider = .codex
+        let profileA = CookieHeaderCache.Scope.profileHome("/tmp/codex-profile-a")
+        let profileB = CookieHeaderCache.Scope.profileHome("/tmp/codex-profile-b")
+        CookieHeaderCache.store(
+            provider: provider,
+            scope: profileA,
+            cookieHeader: "auth=profile-a",
+            sourceLabel: "Chrome")
+        CookieHeaderCache.store(
+            provider: provider,
+            scope: profileB,
+            cookieHeader: "auth=profile-b",
+            sourceLabel: "Chrome")
+        defer {
+            CookieHeaderCache.clear(provider: provider, scope: profileA)
+            CookieHeaderCache.clear(provider: provider, scope: profileB)
+        }
+
+        #expect(CookieHeaderCache.load(provider: provider, scope: profileA)?.cookieHeader == "auth=profile-a")
+        #expect(CookieHeaderCache.load(provider: provider, scope: profileB)?.cookieHeader == "auth=profile-b")
+        #expect(CookieHeaderCache.load(provider: provider) == nil)
+        #expect(profileA.isolationIdentifier != profileB.isolationIdentifier)
+        #expect(!profileA.isolationIdentifier.contains("codex-profile-a"))
+    }
+
+    @Test
+    func `provider global scope remains available without managed account`() {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+        let provider: UsageProvider = .codex
+
+        CookieHeaderCache.store(
+            provider: provider,
+            cookieHeader: "auth=system",
+            sourceLabel: "Chrome")
+        defer { CookieHeaderCache.clear(provider: provider) }
+
+        #expect(CookieHeaderCache.load(provider: provider)?.cookieHeader == "auth=system")
+        #expect(CookieHeaderCache.load(provider: provider, scope: .managedAccount(UUID())) == nil)
+    }
+
+    @Test
+    func `claude cookie scopes isolate browser cache from managed accounts`() {
+        self.withIsolatedCookieCache {
+            let accountA = UUID()
+            let accountB = UUID()
+
+            CookieHeaderCache.store(
+                provider: .claude,
+                cookieHeader: "sessionKey=sk-ant-browser",
+                sourceLabel: "Safari")
+            CookieHeaderCache.store(
+                provider: .claude,
+                scope: .managedAccount(accountA),
+                cookieHeader: "sessionKey=sk-ant-account-a",
+                sourceLabel: "Chrome")
+            CookieHeaderCache.store(
+                provider: .claude,
+                scope: .managedAccount(accountB),
+                cookieHeader: "sessionKey=sk-ant-account-b",
+                sourceLabel: "Edge")
+
+            #expect(CookieHeaderCache.load(provider: .claude)?.cookieHeader == "sessionKey=sk-ant-browser")
+            #expect(CookieHeaderCache.load(provider: .claude, scope: .managedAccount(accountA))?
+                .cookieHeader == "sessionKey=sk-ant-account-a")
+            #expect(CookieHeaderCache.load(provider: .claude, scope: .managedAccount(accountB))?
+                .cookieHeader == "sessionKey=sk-ant-account-b")
+
+            CookieHeaderCache.clear(provider: .claude)
+            #expect(CookieHeaderCache.load(provider: .claude) == nil)
+            #expect(CookieHeaderCache.load(provider: .claude, scope: .managedAccount(accountA))?
+                .cookieHeader == "sessionKey=sk-ant-account-a")
+            #expect(CookieHeaderCache.load(provider: .claude, scope: .managedAccount(accountB))?
+                .cookieHeader == "sessionKey=sk-ant-account-b")
+
+            CookieHeaderCache.clear(provider: .claude, scope: .managedAccount(accountA))
+            #expect(CookieHeaderCache.load(provider: .claude, scope: .managedAccount(accountA)) == nil)
+            #expect(CookieHeaderCache.load(provider: .claude, scope: .managedAccount(accountB))?
+                .cookieHeader == "sessionKey=sk-ant-account-b")
+        }
+    }
+
+    @Test
+    func `claude unreadable managed store sentinel is isolated from account cookies`() {
+        self.withIsolatedCookieCache {
+            let accountID = UUID()
+
+            CookieHeaderCache.store(
+                provider: .claude,
+                cookieHeader: "sessionKey=sk-ant-global",
+                sourceLabel: "Safari")
+            CookieHeaderCache.store(
+                provider: .claude,
+                scope: .managedAccount(accountID),
+                cookieHeader: "sessionKey=sk-ant-account",
+                sourceLabel: "Chrome")
+            CookieHeaderCache.store(
+                provider: .claude,
+                scope: .managedStoreUnreadable,
+                cookieHeader: "sessionKey=sk-ant-unreadable-store",
+                sourceLabel: "Unreadable managed account store")
+
+            CookieHeaderCache.clear(provider: .claude, scope: .managedAccount(accountID))
+            #expect(CookieHeaderCache.load(provider: .claude, scope: .managedAccount(accountID)) == nil)
+            #expect(CookieHeaderCache.load(provider: .claude)?.cookieHeader == "sessionKey=sk-ant-global")
+            #expect(CookieHeaderCache.load(provider: .claude, scope: .managedStoreUnreadable)?
+                .cookieHeader == "sessionKey=sk-ant-unreadable-store")
+
+            CookieHeaderCache.clear(provider: .claude)
+            #expect(CookieHeaderCache.load(provider: .claude) == nil)
+            #expect(CookieHeaderCache.load(provider: .claude, scope: .managedStoreUnreadable)?
+                .cookieHeader == "sessionKey=sk-ant-unreadable-store")
+
+            let cleared = CookieHeaderCache.clearAllScopesDetailed(provider: .claude)
+            #expect(cleared == CookieHeaderCache.ClearSummary(clearedCount: 1, failedCount: 0))
+            #expect(CookieHeaderCache.load(provider: .claude, scope: .managedStoreUnreadable) == nil)
+        }
+    }
+
+    @Test
+    func `claude clear all scopes does not remove other provider cookie caches`() {
+        self.withIsolatedCookieCache {
+            let claudeAccount = UUID()
+            let codexAccount = UUID()
+
+            CookieHeaderCache.store(
+                provider: .claude,
+                cookieHeader: "sessionKey=sk-ant-claude-global",
+                sourceLabel: "Safari")
+            CookieHeaderCache.store(
+                provider: .claude,
+                scope: .managedAccount(claudeAccount),
+                cookieHeader: "sessionKey=sk-ant-claude-account",
+                sourceLabel: "Chrome")
+            CookieHeaderCache.store(provider: .codex, cookieHeader: "auth=codex-global", sourceLabel: "Chrome")
+            CookieHeaderCache.store(
+                provider: .codex,
+                scope: .managedAccount(codexAccount),
+                cookieHeader: "auth=codex-account",
+                sourceLabel: "Safari")
+            CookieHeaderCache.store(provider: .perplexity, cookieHeader: "pplx=web", sourceLabel: "Chrome")
+
+            let cleared = CookieHeaderCache.clearAllScopesDetailed(provider: .claude)
+
+            #expect(cleared == CookieHeaderCache.ClearSummary(clearedCount: 2, failedCount: 0))
+            #expect(CookieHeaderCache.load(provider: .claude) == nil)
+            #expect(CookieHeaderCache.load(provider: .claude, scope: .managedAccount(claudeAccount)) == nil)
+            #expect(CookieHeaderCache.load(provider: .codex)?.cookieHeader == "auth=codex-global")
+            #expect(CookieHeaderCache.load(provider: .codex, scope: .managedAccount(codexAccount))?
+                .cookieHeader == "auth=codex-account")
+            #expect(CookieHeaderCache.load(provider: .perplexity)?.cookieHeader == "pplx=web")
+        }
+    }
+
+    @Test
+    func `migrates legacy file to keychain`() {
         KeychainCacheStore.setTestStoreForTesting(true)
         defer { KeychainCacheStore.setTestStoreForTesting(false) }
 
@@ -57,4 +336,596 @@ struct CookieHeaderCacheTests {
         let loadedAgain = CookieHeaderCache.load(provider: provider)
         #expect(loadedAgain?.cookieHeader == "auth=legacy")
     }
+
+    @Test
+    func `serialized load migrates legacy file to keychain`() {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+        let legacyBase = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        CookieHeaderCache.setLegacyBaseURLOverrideForTesting(legacyBase)
+        defer { CookieHeaderCache.setLegacyBaseURLOverrideForTesting(nil) }
+
+        let provider: UsageProvider = .codex
+        let legacyURL = legacyBase.appendingPathComponent("\(provider.rawValue)-cookie.json")
+        CookieHeaderCache.store(
+            CookieHeaderCache.Entry(
+                cookieHeader: "auth=legacy",
+                storedAt: Date(timeIntervalSince1970: 0),
+                sourceLabel: "Legacy"),
+            to: legacyURL)
+
+        let loaded = CookieHeaderCache.loadSerialized(provider: provider)
+        defer { CookieHeaderCache.clear(provider: provider) }
+
+        #expect(loaded?.cookieHeader == "auth=legacy")
+        #expect(FileManager.default.fileExists(atPath: legacyURL.path) == false)
+        #expect(CookieHeaderCache.load(provider: provider)?.cookieHeader == "auth=legacy")
+    }
+
+    #if os(macOS)
+    @Test
+    func `temporary keychain unavailability returns nil without migrating legacy file`() {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+        let legacyBase = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        CookieHeaderCache.setLegacyBaseURLOverrideForTesting(legacyBase)
+        defer { CookieHeaderCache.setLegacyBaseURLOverrideForTesting(nil) }
+
+        let provider: UsageProvider = .codex
+        let legacyURL = legacyBase.appendingPathComponent("\(provider.rawValue)-cookie.json")
+        CookieHeaderCache.store(
+            CookieHeaderCache.Entry(
+                cookieHeader: "auth=legacy",
+                storedAt: Date(timeIntervalSince1970: 0),
+                sourceLabel: "Legacy"),
+            to: legacyURL)
+        #expect(FileManager.default.fileExists(atPath: legacyURL.path) == true)
+
+        let loaded = KeychainCacheStore.withLoadFailureStatusOverrideForTesting(errSecInteractionNotAllowed) {
+            CookieHeaderCache.load(provider: provider)
+        }
+
+        #expect(loaded == nil)
+        #expect(FileManager.default.fileExists(atPath: legacyURL.path) == true)
+
+        switch KeychainCacheStore.load(key: .cookie(provider: provider), as: CookieHeaderCache.Entry.self) {
+        case .missing:
+            #expect(true)
+        case .found, .temporarilyUnavailable, .invalid:
+            #expect(Bool(false), "Expected temporary miss not to migrate legacy cache")
+        }
+    }
+    #endif
+
+    @Test
+    func `invalid keychain cache is cleared`() {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+        let legacyBase = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        CookieHeaderCache.setLegacyBaseURLOverrideForTesting(legacyBase)
+        defer { CookieHeaderCache.setLegacyBaseURLOverrideForTesting(nil) }
+
+        let provider: UsageProvider = .codex
+        let key = KeychainCacheStore.Key.cookie(provider: provider)
+        KeychainCacheStore.store(key: key, entry: WrongEntry(value: "not-a-cookie-entry"))
+
+        #expect(CookieHeaderCache.load(provider: provider) == nil)
+
+        switch KeychainCacheStore.load(key: key, as: CookieHeaderCache.Entry.self) {
+        case .missing:
+            #expect(true)
+        case .found, .temporarilyUnavailable, .invalid:
+            #expect(Bool(false), "Expected invalid cookie cache to be cleared")
+        }
+    }
+
+    @Test
+    func `clear all scopes removes global scoped invalid and legacy cookie entries`() {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+        let legacyBase = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        CookieHeaderCache.setLegacyBaseURLOverrideForTesting(legacyBase)
+        defer { CookieHeaderCache.setLegacyBaseURLOverrideForTesting(nil) }
+
+        let provider: UsageProvider = .codex
+        let accountID = UUID()
+        CookieHeaderCache.store(provider: provider, cookieHeader: "auth=global", sourceLabel: "Chrome")
+        CookieHeaderCache.store(
+            provider: provider,
+            scope: .managedAccount(accountID),
+            cookieHeader: "auth=scoped",
+            sourceLabel: "Chrome")
+        KeychainCacheStore.store(
+            key: .cookie(provider: provider, scopeIdentifier: "managed-store-unreadable"),
+            entry: WrongEntry(value: "invalid"))
+        CookieHeaderCache.store(
+            CookieHeaderCache.Entry(
+                cookieHeader: "auth=legacy",
+                storedAt: Date(timeIntervalSince1970: 0),
+                sourceLabel: "Legacy"),
+            to: CookieHeaderCache.legacyURLForTesting(provider: provider))
+
+        let cleared = CookieHeaderCache.clearAllScopesDetailed(provider: provider)
+
+        #expect(cleared == CookieHeaderCache.ClearSummary(clearedCount: 4, failedCount: 0))
+        #expect(!CookieHeaderCache.hasKeychainEntryForTesting(provider: provider))
+        #expect(!CookieHeaderCache.hasKeychainEntryForTesting(provider: provider, scope: .managedAccount(accountID)))
+        #expect(!CookieHeaderCache.hasKeychainEntryForTesting(provider: provider, scope: .managedStoreUnreadable))
+        #expect(!CookieHeaderCache.hasLegacyEntryForTesting(provider: provider))
+    }
+
+    @Test
+    func `loadForDisplay memoizes keychain lookups`() {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+        CookieHeaderCache.resetDisplayCacheForTesting()
+        defer { CookieHeaderCache.resetDisplayCacheForTesting() }
+
+        let provider: UsageProvider = .codex
+        CookieHeaderCache.store(provider: provider, cookieHeader: "auth=abc", sourceLabel: "Chrome")
+
+        #expect(CookieHeaderCache.loadForDisplay(provider: provider)?.cookieHeader == "auth=abc")
+
+        // Remove the backing entry without going through CookieHeaderCache: the strict load
+        // sees the change, the display path keeps serving the memoized snapshot.
+        KeychainCacheStore.clear(key: .cookie(provider: provider))
+        #expect(CookieHeaderCache.load(provider: provider) == nil)
+        #expect(CookieHeaderCache.loadForDisplay(provider: provider)?.cookieHeader == "auth=abc")
+    }
+
+    @Test
+    func `loadForDisplay memoizes missing entries`() {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+        CookieHeaderCache.resetDisplayCacheForTesting()
+        defer { CookieHeaderCache.resetDisplayCacheForTesting() }
+
+        let provider: UsageProvider = .codex
+        #expect(CookieHeaderCache.loadForDisplay(provider: provider) == nil)
+
+        KeychainCacheStore.store(
+            key: .cookie(provider: provider),
+            entry: CookieHeaderCache.Entry(
+                cookieHeader: "auth=behind-the-back",
+                storedAt: Date(timeIntervalSince1970: 0),
+                sourceLabel: "Chrome"))
+        defer { KeychainCacheStore.clear(key: .cookie(provider: provider)) }
+        #expect(CookieHeaderCache.loadForDisplay(provider: provider) == nil)
+    }
+
+    @Test
+    func `loadForDisplay migrates legacy cache asynchronously`() async throws {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+        CookieHeaderCache.resetDisplayCacheForTesting()
+        defer { CookieHeaderCache.resetDisplayCacheForTesting() }
+
+        let legacyBase = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        CookieHeaderCache.setLegacyBaseURLOverrideForTesting(legacyBase)
+        defer { CookieHeaderCache.setLegacyBaseURLOverrideForTesting(nil) }
+
+        let provider: UsageProvider = .codex
+        CookieHeaderCache.store(
+            CookieHeaderCache.Entry(
+                cookieHeader: "auth=legacy-display",
+                storedAt: Date(timeIntervalSince1970: 0),
+                sourceLabel: "Legacy"),
+            to: CookieHeaderCache.legacyURLForTesting(provider: provider))
+
+        #expect(CookieHeaderCache.loadForDisplay(provider: provider)?.cookieHeader == "auth=legacy-display")
+        for _ in 0..<500 {
+            if !CookieHeaderCache.hasLegacyEntryForTesting(provider: provider),
+               CookieHeaderCache.hasKeychainEntryForTesting(provider: provider)
+            {
+                break
+            }
+            try await Task.sleep(for: .milliseconds(10))
+        }
+        #expect(!CookieHeaderCache.hasLegacyEntryForTesting(provider: provider))
+        #expect(CookieHeaderCache.hasKeychainEntryForTesting(provider: provider))
+        CookieHeaderCache.clear(provider: provider)
+    }
+
+    @Test
+    func `delayed legacy migration cannot restore a cleared cache`() {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+        CookieHeaderCache.resetDisplayCacheForTesting()
+        defer { CookieHeaderCache.resetDisplayCacheForTesting() }
+
+        let legacyBase = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        CookieHeaderCache.setLegacyBaseURLOverrideForTesting(legacyBase)
+        defer { CookieHeaderCache.setLegacyBaseURLOverrideForTesting(nil) }
+
+        let provider: UsageProvider = .codex
+        CookieHeaderCache.store(
+            CookieHeaderCache.Entry(
+                cookieHeader: "auth=legacy-display",
+                storedAt: Date(timeIntervalSince1970: 0),
+                sourceLabel: "Legacy"),
+            to: CookieHeaderCache.legacyURLForTesting(provider: provider))
+
+        CookieHeaderCache.clear(provider: provider)
+        #expect(CookieHeaderCache.migrateLegacyEntryIfNeededForTesting(provider: provider) == nil)
+        #expect(!CookieHeaderCache.hasLegacyEntryForTesting(provider: provider))
+        #expect(!CookieHeaderCache.hasKeychainEntryForTesting(provider: provider))
+    }
+
+    @Test
+    func `legacy URL override supports concurrent teardown reads`() {
+        let legacyBases = [
+            FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true),
+            FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true),
+        ]
+        defer { CookieHeaderCache.setLegacyBaseURLOverrideForTesting(nil) }
+
+        DispatchQueue.concurrentPerform(iterations: 5000) { index in
+            if index.isMultiple(of: 3) {
+                CookieHeaderCache.setLegacyBaseURLOverrideForTesting(legacyBases[index % legacyBases.count])
+            } else if index.isMultiple(of: 5) {
+                CookieHeaderCache.setLegacyBaseURLOverrideForTesting(nil)
+            } else {
+                _ = CookieHeaderCache.legacyURLForTesting(provider: .codex)
+            }
+        }
+
+        CookieHeaderCache.setLegacyBaseURLOverrideForTesting(legacyBases[0])
+        #expect(
+            CookieHeaderCache.legacyURLForTesting(provider: .codex)
+                == legacyBases[0].appendingPathComponent("codex-cookie.json"))
+    }
+
+    #if os(macOS)
+    @Test
+    func `loadForDisplay throttles temporary keychain unavailability then retries`() async throws {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+        CookieHeaderCache.resetDisplayCacheForTesting()
+        defer { CookieHeaderCache.resetDisplayCacheForTesting() }
+        CookieHeaderCache.setDisplayUnavailableRetryIntervalOverrideForTesting(0.05)
+        defer { CookieHeaderCache.setDisplayUnavailableRetryIntervalOverrideForTesting(nil) }
+
+        let provider: UsageProvider = .codex
+        KeychainCacheStore.store(
+            key: .cookie(provider: provider),
+            entry: CookieHeaderCache.Entry(
+                cookieHeader: "auth=available-after-retry",
+                storedAt: Date(timeIntervalSince1970: 0),
+                sourceLabel: "Chrome"))
+
+        let unavailable = KeychainCacheStore.withLoadFailureStatusOverrideForTesting(errSecInteractionNotAllowed) {
+            CookieHeaderCache.loadForDisplay(provider: provider)
+        }
+
+        #expect(unavailable == nil)
+        #expect(CookieHeaderCache.loadForDisplay(provider: provider) == nil)
+
+        try await Task.sleep(for: .milliseconds(60))
+        var retried: CookieHeaderCache.Entry?
+        for _ in 0..<500 {
+            retried = CookieHeaderCache.loadForDisplay(provider: provider)
+            if retried != nil { break }
+            try await Task.sleep(for: .milliseconds(10))
+        }
+        #expect(retried?.cookieHeader == "auth=available-after-retry")
+    }
+
+    @Test
+    func `temporary first display read returns a concurrent store`() {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+        CookieHeaderCache.resetDisplayCacheForTesting()
+        defer { CookieHeaderCache.resetDisplayCacheForTesting() }
+
+        let provider: UsageProvider = .codex
+        _ = CookieHeaderCache.beginDisplayReadGenerationForTesting(provider: provider)
+        CookieHeaderCache.store(provider: provider, cookieHeader: "auth=concurrent", sourceLabel: "Chrome")
+
+        #expect(CookieHeaderCache.currentDisplayEntryForTesting(provider: provider)?
+            .cookieHeader == "auth=concurrent")
+    }
+
+    @Test
+    func `failed keychain mutations preserve the display snapshot`() {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+        CookieHeaderCache.resetDisplayCacheForTesting()
+        defer { CookieHeaderCache.resetDisplayCacheForTesting() }
+
+        let provider: UsageProvider = .codex
+        CookieHeaderCache.store(provider: provider, cookieHeader: "auth=old", sourceLabel: "Chrome")
+        #expect(CookieHeaderCache.loadForDisplay(provider: provider)?.cookieHeader == "auth=old")
+
+        KeychainCacheStore.withStoreFailureStatusOverrideForTesting(errSecInteractionNotAllowed) {
+            CookieHeaderCache.store(provider: provider, cookieHeader: "auth=new", sourceLabel: "Safari")
+        }
+        #expect(CookieHeaderCache.loadForDisplay(provider: provider)?.cookieHeader == "auth=old")
+
+        let cleared = KeychainCacheStore.withClearFailureStatusOverrideForTesting(errSecInteractionNotAllowed) {
+            CookieHeaderCache.clearDetailed(provider: provider)
+        }
+        #expect(cleared == CookieHeaderCache.ClearSummary(clearedCount: 0, failedCount: 1))
+        #expect(CookieHeaderCache.loadForDisplay(provider: provider)?.cookieHeader == "auth=old")
+        #expect(CookieHeaderCache.load(provider: provider)?.cookieHeader == "auth=old")
+    }
+
+    @Test
+    func `legacy removal invalidates a snapshot after failed keychain clear`() {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+        CookieHeaderCache.resetDisplayCacheForTesting()
+        defer { CookieHeaderCache.resetDisplayCacheForTesting() }
+
+        KeychainCacheStore.withServiceOverrideForTesting("legacy-clear-\(UUID().uuidString)") {
+            let legacyBase = FileManager.default.temporaryDirectory
+                .appendingPathComponent(UUID().uuidString, isDirectory: true)
+            CookieHeaderCache.setLegacyBaseURLOverrideForTesting(legacyBase)
+            defer { CookieHeaderCache.setLegacyBaseURLOverrideForTesting(nil) }
+
+            let provider: UsageProvider = .codex
+            CookieHeaderCache.store(
+                CookieHeaderCache.Entry(
+                    cookieHeader: "auth=legacy",
+                    storedAt: Date(timeIntervalSince1970: 0),
+                    sourceLabel: "Legacy"),
+                to: CookieHeaderCache.legacyURLForTesting(provider: provider))
+
+            let displayed = KeychainCacheStore.withStoreFailureStatusOverrideForTesting(errSecInteractionNotAllowed) {
+                CookieHeaderCache.loadForDisplay(provider: provider)
+            }
+            #expect(displayed?.cookieHeader == "auth=legacy")
+
+            let cleared = KeychainCacheStore.withClearFailureStatusOverrideForTesting(errSecInteractionNotAllowed) {
+                CookieHeaderCache.clearDetailed(provider: provider)
+            }
+
+            #expect(cleared == CookieHeaderCache.ClearSummary(clearedCount: 1, failedCount: 1))
+            #expect(!CookieHeaderCache.hasLegacyEntryForTesting(provider: provider))
+            #expect(CookieHeaderCache.loadForDisplay(provider: provider) == nil)
+        }
+    }
+
+    @Test
+    func `clear all reports keychain enumeration failure`() {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+        let summary = KeychainCacheStore.withKeysFailureStatusOverrideForTesting(errSecInteractionNotAllowed) {
+            CookieHeaderCache.clearAllDetailed()
+        }
+
+        #expect(summary.failedCount >= 1)
+    }
+
+    @Test
+    func `clear reports legacy file deletion failure`() {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+        let legacyBase = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        CookieHeaderCache.setLegacyBaseURLOverrideForTesting(legacyBase)
+        defer { CookieHeaderCache.setLegacyBaseURLOverrideForTesting(nil) }
+
+        let provider: UsageProvider = .codex
+        CookieHeaderCache.store(
+            CookieHeaderCache.Entry(
+                cookieHeader: "auth=legacy",
+                storedAt: Date(timeIntervalSince1970: 0),
+                sourceLabel: "Legacy"),
+            to: CookieHeaderCache.legacyURLForTesting(provider: provider))
+
+        let summary = CookieHeaderCache.withLegacyRemovalFailureForTesting {
+            CookieHeaderCache.clearDetailed(provider: provider)
+        }
+
+        #expect(summary.failedCount == 1)
+        #expect(CookieHeaderCache.hasLegacyEntryForTesting(provider: provider))
+    }
+    #endif
+
+    @Test
+    func `store and clear update the display snapshot immediately`() {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+        CookieHeaderCache.resetDisplayCacheForTesting()
+        defer { CookieHeaderCache.resetDisplayCacheForTesting() }
+
+        let provider: UsageProvider = .codex
+        CookieHeaderCache.store(provider: provider, cookieHeader: "auth=first", sourceLabel: "Chrome")
+        #expect(CookieHeaderCache.loadForDisplay(provider: provider)?.cookieHeader == "auth=first")
+
+        CookieHeaderCache.store(provider: provider, cookieHeader: "auth=second", sourceLabel: "Safari")
+        #expect(CookieHeaderCache.loadForDisplay(provider: provider)?.cookieHeader == "auth=second")
+
+        CookieHeaderCache.clear(provider: provider)
+        #expect(CookieHeaderCache.loadForDisplay(provider: provider) == nil)
+    }
+
+    @Test
+    func `stale refresh cannot overwrite a newer store`() {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+        CookieHeaderCache.resetDisplayCacheForTesting()
+        defer { CookieHeaderCache.resetDisplayCacheForTesting() }
+
+        let provider: UsageProvider = .codex
+        CookieHeaderCache.store(provider: provider, cookieHeader: "auth=old", sourceLabel: "Chrome")
+        #expect(CookieHeaderCache.loadForDisplay(provider: provider)?.cookieHeader == "auth=old")
+
+        // A refresh scheduled now races with a store that lands before it commits.
+        let staleGeneration = CookieHeaderCache.beginDisplayReadGenerationForTesting(provider: provider)
+        let staleEntry = CookieHeaderCache.load(provider: provider)
+        CookieHeaderCache.store(provider: provider, cookieHeader: "auth=new", sourceLabel: "Safari")
+
+        let committed = CookieHeaderCache.commitDisplaySnapshotIfCurrentForTesting(
+            provider: provider,
+            entry: staleEntry,
+            generation: staleGeneration)
+
+        #expect(committed?.cookieHeader == "auth=new")
+        #expect(CookieHeaderCache.loadForDisplay(provider: provider)?.cookieHeader == "auth=new")
+    }
+
+    @Test
+    func `stale refresh cannot resurrect a cleared snapshot`() {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+        CookieHeaderCache.resetDisplayCacheForTesting()
+        defer { CookieHeaderCache.resetDisplayCacheForTesting() }
+
+        let provider: UsageProvider = .codex
+        CookieHeaderCache.store(provider: provider, cookieHeader: "auth=secret", sourceLabel: "Chrome")
+        #expect(CookieHeaderCache.loadForDisplay(provider: provider)?.cookieHeader == "auth=secret")
+
+        let staleGeneration = CookieHeaderCache.beginDisplayReadGenerationForTesting(provider: provider)
+        let staleEntry = CookieHeaderCache.load(provider: provider)
+        CookieHeaderCache.clear(provider: provider)
+
+        let committed = CookieHeaderCache.commitDisplaySnapshotIfCurrentForTesting(
+            provider: provider,
+            entry: staleEntry,
+            generation: staleGeneration)
+
+        #expect(committed == nil)
+        #expect(CookieHeaderCache.loadForDisplay(provider: provider) == nil)
+    }
+
+    @Test
+    func `stale refresh cannot survive clear all`() {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+        CookieHeaderCache.resetDisplayCacheForTesting()
+        defer { CookieHeaderCache.resetDisplayCacheForTesting() }
+
+        let provider: UsageProvider = .codex
+        CookieHeaderCache.store(provider: provider, cookieHeader: "auth=secret", sourceLabel: "Chrome")
+        #expect(CookieHeaderCache.loadForDisplay(provider: provider)?.cookieHeader == "auth=secret")
+
+        let staleGeneration = CookieHeaderCache.beginDisplayReadGenerationForTesting(provider: provider)
+        let staleEntry = CookieHeaderCache.load(provider: provider)
+        CookieHeaderCache.clearAll()
+
+        CookieHeaderCache.commitDisplaySnapshotIfCurrentForTesting(
+            provider: provider,
+            entry: staleEntry,
+            generation: staleGeneration)
+
+        #expect(CookieHeaderCache.loadForDisplay(provider: provider) == nil)
+    }
+
+    @Test
+    func `clear all invalidates an in flight first display population`() {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+        CookieHeaderCache.resetDisplayCacheForTesting()
+        defer { CookieHeaderCache.resetDisplayCacheForTesting() }
+
+        let provider: UsageProvider = .codex
+        KeychainCacheStore.store(
+            key: .cookie(provider: provider),
+            entry: CookieHeaderCache.Entry(
+                cookieHeader: "auth=secret",
+                storedAt: Date(timeIntervalSince1970: 0),
+                sourceLabel: "Chrome"))
+
+        // A first display load registers its key, then reads the Keychain outside the lock.
+        let staleGeneration = CookieHeaderCache.beginDisplayReadGenerationForTesting(provider: provider)
+        let staleEntry = CookieHeaderCache.load(provider: provider)
+        CookieHeaderCache.clearAll()
+
+        let committed = CookieHeaderCache.commitDisplaySnapshotIfCurrentForTesting(
+            provider: provider,
+            entry: staleEntry,
+            generation: staleGeneration)
+
+        #expect(committed == nil)
+        #expect(CookieHeaderCache.loadForDisplay(provider: provider) == nil)
+    }
+
+    @Test
+    func `stale display snapshot revalidates off the calling path`() async throws {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+        CookieHeaderCache.resetDisplayCacheForTesting()
+        defer { CookieHeaderCache.resetDisplayCacheForTesting() }
+        CookieHeaderCache.setDisplayStalenessIntervalOverrideForTesting(0)
+        defer { CookieHeaderCache.setDisplayStalenessIntervalOverrideForTesting(nil) }
+
+        let provider: UsageProvider = .codex
+        KeychainCacheStore.store(
+            key: .cookie(provider: provider),
+            entry: CookieHeaderCache.Entry(
+                cookieHeader: "auth=old",
+                storedAt: Date(timeIntervalSince1970: 0),
+                sourceLabel: "Chrome"))
+        #expect(CookieHeaderCache.loadForDisplay(provider: provider)?.cookieHeader == "auth=old")
+
+        KeychainCacheStore.store(
+            key: .cookie(provider: provider),
+            entry: CookieHeaderCache.Entry(
+                cookieHeader: "auth=new",
+                storedAt: Date(timeIntervalSince1970: 1),
+                sourceLabel: "Chrome"))
+
+        // The stale lookup returns the old snapshot and schedules a revalidation.
+        _ = CookieHeaderCache.loadForDisplay(provider: provider)
+        var refreshed = false
+        for _ in 0..<200 {
+            if CookieHeaderCache.loadForDisplay(provider: provider)?.cookieHeader == "auth=new" {
+                refreshed = true
+                break
+            }
+            try await Task.sleep(nanoseconds: 10_000_000)
+        }
+        #expect(refreshed)
+    }
+
+    @Test
+    func `clear all removes every provider cookie key without decoding entries`() {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+        KeychainCacheStore.withServiceOverrideForTesting("cookie-clear-all-\(UUID().uuidString)") {
+            CookieHeaderCache.store(provider: .claude, cookieHeader: "auth=claude", sourceLabel: "Chrome")
+            CookieHeaderCache.store(
+                provider: .codex,
+                scope: .managedAccount(UUID()),
+                cookieHeader: "auth=codex",
+                sourceLabel: "Chrome")
+            KeychainCacheStore.store(
+                key: .cookie(provider: .cursor),
+                entry: WrongEntry(value: "invalid"))
+
+            let cleared = CookieHeaderCache.clearAllDetailed()
+
+            #expect(cleared.clearedCount >= 3)
+            #expect(cleared.failedCount == 0)
+            #expect(KeychainCacheStore.keys(category: "cookie").isEmpty)
+        }
+    }
+
+    private func withIsolatedCookieCache<T>(_ operation: () -> T) -> T {
+        KeychainCacheStore.withServiceOverrideForTesting("cookie-isolation-\(UUID().uuidString)") {
+            let legacyBase = FileManager.default.temporaryDirectory
+                .appendingPathComponent(UUID().uuidString, isDirectory: true)
+            CookieHeaderCache.setLegacyBaseURLOverrideForTesting(legacyBase)
+            defer { CookieHeaderCache.setLegacyBaseURLOverrideForTesting(nil) }
+            KeychainCacheStore.setTestStoreForTesting(true)
+            defer { KeychainCacheStore.setTestStoreForTesting(false) }
+            CookieHeaderCache.resetDisplayCacheForTesting()
+            defer { CookieHeaderCache.resetDisplayCacheForTesting() }
+            return operation()
+        }
+    }
 }
diff --git a/Tests/CodexBarTests/CookieHeaderNormalizerTests.swift b/Tests/CodexBarTests/CookieHeaderNormalizerTests.swift
new file mode 100644
index 0000000000..2fee1f509a
--- /dev/null
+++ b/Tests/CodexBarTests/CookieHeaderNormalizerTests.swift
@@ -0,0 +1,14 @@
+import CodexBarCore
+import Testing
+
+struct CookieHeaderNormalizerTests {
+    @Test
+    func `compact curl short form without whitespace still parses`() {
+        let normalized = CookieHeaderNormalizer.normalize("curl https://example.com -bfoo=bar")
+
+        #expect(normalized == "foo=bar")
+        #expect(CookieHeaderNormalizer.pairs(from: "curl https://example.com -bfoo=bar").count == 1)
+        #expect(CookieHeaderNormalizer.pairs(from: "curl https://example.com -bfoo=bar").first?.name == "foo")
+        #expect(CookieHeaderNormalizer.pairs(from: "curl https://example.com -bfoo=bar").first?.value == "bar")
+    }
+}
diff --git a/Tests/CodexBarTests/CopilotBudgetCookieRoutingTests.swift b/Tests/CodexBarTests/CopilotBudgetCookieRoutingTests.swift
new file mode 100644
index 0000000000..1518c40bb1
--- /dev/null
+++ b/Tests/CodexBarTests/CopilotBudgetCookieRoutingTests.swift
@@ -0,0 +1,44 @@
+import Testing
+@testable import CodexBarCore
+
+struct CopilotBudgetCookieRoutingTests {
+    @Test
+    func `auto budget cookies ignore stale manual header`() {
+        let settings = ProviderSettingsSnapshot.CopilotProviderSettings(
+            budgetExtrasEnabled: true,
+            budgetCookieSource: .auto,
+            manualBudgetCookieHeader: "user_session=stale")
+
+        #expect(CopilotAPIFetchStrategy.budgetCookieHeaderOverride(from: settings) == nil)
+    }
+
+    @Test
+    func `manual budget cookies use trimmed manual header`() {
+        let settings = ProviderSettingsSnapshot.CopilotProviderSettings(
+            budgetExtrasEnabled: true,
+            budgetCookieSource: .manual,
+            manualBudgetCookieHeader: "  user_session=manual  ")
+
+        #expect(CopilotAPIFetchStrategy.budgetCookieHeaderOverride(from: settings) == "user_session=manual")
+    }
+
+    @Test
+    func `manual budget cookies require non-empty header`() {
+        let settings = ProviderSettingsSnapshot.CopilotProviderSettings(
+            budgetExtrasEnabled: true,
+            budgetCookieSource: .manual,
+            manualBudgetCookieHeader: "  ")
+
+        #expect(CopilotAPIFetchStrategy.budgetCookieHeaderOverride(from: settings) == nil)
+    }
+
+    @Test
+    func `invalid manual budget cookies do not fall back to browser import`() {
+        let settings = ProviderSettingsSnapshot.CopilotProviderSettings(
+            budgetExtrasEnabled: true,
+            budgetCookieSource: .manual,
+            manualBudgetCookieHeader: "Cookie:")
+
+        #expect(CopilotAPIFetchStrategy.budgetCookieHeaderOverride(from: settings) == nil)
+    }
+}
diff --git a/Tests/CodexBarTests/CopilotBudgetWebFetcherTests.swift b/Tests/CodexBarTests/CopilotBudgetWebFetcherTests.swift
new file mode 100644
index 0000000000..2bdba637a1
--- /dev/null
+++ b/Tests/CodexBarTests/CopilotBudgetWebFetcherTests.swift
@@ -0,0 +1,721 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct CopilotBudgetWebFetcherTests {
+    @Test
+    func `maps positive copilot budgets to extra rate windows`() {
+        let budgets: [CopilotBudgetWebFetcher.Budget] = [
+            .init(
+                id: "product-budget",
+                budgetProductSkus: ["copilot"],
+                budgetAmount: 100,
+                currentAmount: 15),
+            .init(
+                id: "agent-budget",
+                budgetProductSkus: ["copilot_agent_premium_request"],
+                budgetAmount: 20,
+                currentAmount: 5),
+            .init(
+                id: "zero-budget",
+                budgetProductSkus: ["spark_premium_request"],
+                budgetAmount: 0,
+                currentAmount: 0),
+        ]
+
+        let windows = CopilotBudgetWebFetcher.extraRateWindows(
+            from: budgets,
+            now: Date(timeIntervalSince1970: 1_780_358_400))
+
+        #expect(windows.map(\.id) == ["copilot-budget-product-budget", "copilot-budget-agent-budget"])
+        #expect(windows.map(\.title) == ["Budget - Copilot", "Budget - Copilot Agent Premium Requests"])
+        #expect(windows[0].window.usedPercent == 15)
+        #expect(windows[1].window.usedPercent == 25)
+        #expect(windows.allSatisfy { $0.window.resetsAt != nil })
+    }
+
+    @Test
+    func `decodes github web budget response shape`() throws {
+        let data = Data("""
+        {
+          "payload": {
+            "budgets": [
+              {
+                "uuid": "budget-1",
+                "targetName": "Example",
+                "pricingTargetType": "BundlePricing",
+                "pricingTargetId": "premium_requests",
+                "targetAmount": 30.0,
+                "currentAmount": 0.0
+              }
+            ],
+            "has_next_page": false
+          }
+        }
+        """.utf8)
+
+        let response = try JSONDecoder().decode(CopilotBudgetWebFetcher.BudgetResponse.self, from: data)
+        let budget = try #require(response.budgets.first)
+        #expect(response.hasNextPage == false)
+        #expect(budget.id == "budget-1")
+        #expect(budget.budgetEntityName == "Example")
+        #expect(budget.budgetAmount == 30)
+        #expect(budget.currentAmount == 0)
+
+        let windows = CopilotBudgetWebFetcher.extraRateWindows(
+            from: response.budgets,
+            now: Date(timeIntervalSince1970: 1_780_358_400))
+        #expect(windows.map(\.title) == ["Budget - All Premium Request SKUs"])
+        #expect(windows.first?.window.usedPercent == 0)
+    }
+
+    @Test
+    func `ignores malformed embedded minus amounts`() throws {
+        let data = Data("""
+        {
+          "budgets": [
+            {
+              "uuid": "budget-1",
+              "pricingTargetId": "premium_requests",
+              "targetAmount": "1-5",
+              "currentAmount": "$5.00"
+            },
+            {
+              "uuid": "budget-2",
+              "pricingTargetId": "premium_requests",
+              "targetAmount": "-$15.00",
+              "currentAmount": "$5.00"
+            }
+          ]
+        }
+        """.utf8)
+
+        let response = try JSONDecoder().decode(CopilotBudgetWebFetcher.BudgetResponse.self, from: data)
+
+        #expect(response.budgets.map(\.budgetAmount) == [0, -15])
+        #expect(CopilotBudgetWebFetcher.extraRateWindows(
+            from: response.budgets,
+            now: Date(timeIntervalSince1970: 1_780_358_400)).isEmpty)
+    }
+
+    @Test
+    func `normalizes documented copilot billing names`() {
+        #expect(CopilotBudgetWebFetcher.normalizedBillingIdentifier("Copilot") == "copilot")
+        #expect(
+            CopilotBudgetWebFetcher.normalizedBillingIdentifier("Copilot Premium Request") ==
+                "copilot_premium_request")
+        #expect(
+            CopilotBudgetWebFetcher.normalizedBillingIdentifier("Copilot Agent Premium Request") ==
+                "copilot_agent_premium_request")
+        #expect(
+            CopilotBudgetWebFetcher.normalizedBillingIdentifier("Spark Premium Request") ==
+                "spark_premium_request")
+        #expect(
+            CopilotBudgetWebFetcher.normalizedBillingIdentifier("Premium requests") ==
+                "copilot_premium_request")
+        #expect(
+            CopilotBudgetWebFetcher.normalizedBillingIdentifier("Bundled premium request budget") ==
+                "copilot_premium_request")
+        #expect(
+            CopilotBudgetWebFetcher.normalizedBillingIdentifier("Copilot cloud agent premium requests") ==
+                "copilot_agent_premium_request")
+        #expect(
+            CopilotBudgetWebFetcher.normalizedBillingIdentifier("coding_agent_premium_request") ==
+                "copilot_agent_premium_request")
+    }
+
+    @Test
+    func `extracts github fetch nonce from html`() {
+        let html = #"<meta name="x-fetch-nonce" content="v2:abc-123">"#
+        #expect(CopilotBudgetWebFetcher.extractFetchNonce(from: html) == "v2:abc-123")
+    }
+
+    @Test
+    func `extracts github web identity from html`() throws {
+        let html = """
+        <meta name="octolytics-actor-id" content="123">
+        <meta content = "octocat" name = "user-login">
+        """
+
+        let identity = try #require(CopilotBudgetWebFetcher.extractGitHubWebIdentity(from: html))
+
+        #expect(identity.id == "123")
+        #expect(identity.login == "octocat")
+        #expect(CopilotBudgetWebFetcher.webIdentity(identity, matches: "github:user:123"))
+        #expect(CopilotBudgetWebFetcher.webIdentity(identity, matches: "OctoCat"))
+        #expect(!CopilotBudgetWebFetcher.webIdentity(identity, matches: "github:user:456"))
+    }
+
+    @Test
+    func `missing github web identity with expected account maps to unknown account mismatch`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            guard let url = request.url,
+                  let response = HTTPURLResponse(
+                      url: url,
+                      statusCode: 200,
+                      httpVersion: "HTTP/1.1",
+                      headerFields: nil)
+            else {
+                throw URLError(.badServerResponse)
+            }
+            if request.url?.query?.contains("page=") == true {
+                Issue.record("Missing identity should not reach budget JSON endpoint")
+                return (Data(#"{"budgets":[],"has_next_page":false}"#.utf8), response)
+            }
+            return (Data(#"<meta name="x-fetch-nonce" content="nonce">"#.utf8), response)
+        }
+        let fetcher = CopilotBudgetWebFetcher(
+            cookieHeaderOverride: "user_session=missing-identity",
+            expectedGitHubAccountIdentifier: "github:user:123",
+            transport: transport)
+
+        do {
+            _ = try await fetcher.fetchBudgetWindows()
+            Issue.record("Expected account mismatch")
+        } catch let error as CopilotBudgetWebFetcher.Error {
+            #expect(error == .accountMismatch(expected: "github:user:123", actual: nil))
+        }
+
+        #expect(await transport.requests().count == 1)
+    }
+
+    @Test
+    func `invalid github budget page html encoding maps to invalid response`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            guard let url = request.url,
+                  let response = HTTPURLResponse(
+                      url: url,
+                      statusCode: 200,
+                      httpVersion: "HTTP/1.1",
+                      headerFields: nil)
+            else {
+                throw URLError(.badServerResponse)
+            }
+            if request.url?.query?.contains("page=") == true {
+                Issue.record("Invalid HTML encoding should not reach budget JSON endpoint")
+                return (Data(#"{"budgets":[],"has_next_page":false}"#.utf8), response)
+            }
+            return (Data([0xC3, 0x28]), response)
+        }
+        let fetcher = CopilotBudgetWebFetcher(
+            cookieHeaderOverride: "user_session=invalid-html",
+            expectedGitHubAccountIdentifier: "github:user:123",
+            transport: transport)
+
+        do {
+            _ = try await fetcher.fetchBudgetWindows()
+            Issue.record("Expected invalid response")
+        } catch let error as CopilotBudgetWebFetcher.Error {
+            #expect(error == .invalidResponse)
+        }
+
+        #expect(await transport.requests().count == 1)
+    }
+
+    @Test
+    func `manual budget cookie for different github account is ignored before budget request`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            guard let url = request.url,
+                  let response = HTTPURLResponse(
+                      url: url,
+                      statusCode: 200,
+                      httpVersion: "HTTP/1.1",
+                      headerFields: nil)
+            else {
+                throw URLError(.badServerResponse)
+            }
+            if request.url?.query?.contains("page=") == true {
+                Issue.record("Mismatched cookie should not reach budget JSON endpoint")
+                return (Data(#"{"budgets":[],"has_next_page":false}"#.utf8), response)
+            }
+            return (
+                Data("""
+                <meta name="x-fetch-nonce" content="nonce">
+                <meta name="octolytics-actor-id" content="456">
+                <meta name="user-login" content="otheruser">
+                """.utf8),
+                response)
+        }
+        let fetcher = CopilotBudgetWebFetcher(
+            cookieHeaderOverride: "user_session=other",
+            expectedGitHubAccountIdentifier: "github:user:123",
+            transport: transport)
+
+        do {
+            _ = try await fetcher.fetchBudgetWindows()
+            Issue.record("Expected account mismatch")
+        } catch let error as CopilotBudgetWebFetcher.Error {
+            #expect(error == .accountMismatch(expected: "github:user:123", actual: "otheruser"))
+        }
+
+        #expect(await transport.requests().count == 1)
+    }
+
+    @Test
+    func `manual budget cookie with matching github account appends budget windows`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            guard let url = request.url,
+                  let response = HTTPURLResponse(
+                      url: url,
+                      statusCode: 200,
+                      httpVersion: "HTTP/1.1",
+                      headerFields: nil)
+            else {
+                throw URLError(.badServerResponse)
+            }
+            if request.url?.query?.contains("page=") == true {
+                return (
+                    Data("""
+                    {
+                      "budgets": [
+                        {
+                          "uuid": "budget-1",
+                          "pricingTargetId": "premium_requests",
+                          "targetAmount": 100.0,
+                          "currentAmount": 40.0
+                        }
+                      ],
+                      "has_next_page": false
+                    }
+                    """.utf8),
+                    response)
+            }
+            return (
+                Data("""
+                <meta name="x-fetch-nonce" content="nonce">
+                <meta name="octolytics-actor-id" content="123">
+                <meta name="user-login" content="octocat">
+                """.utf8),
+                response)
+        }
+        let fetcher = CopilotBudgetWebFetcher(
+            cookieHeaderOverride: "user_session=matching",
+            expectedGitHubAccountIdentifier: "github:user:123",
+            transport: transport,
+            now: { Date(timeIntervalSince1970: 1_780_358_400) })
+
+        let windows = try await fetcher.fetchBudgetWindows()
+
+        #expect(windows.map(\.id) == ["copilot-budget-budget-1"])
+        #expect(windows.first?.window.usedPercent == 40)
+        #expect(await transport.requests().count == 2)
+    }
+
+    @Test
+    func `mismatched manual budget cookie leaves normal copilot usage unchanged`() async {
+        let registered = URLProtocol.registerClass(CopilotBudgetBindingStubURLProtocol.self)
+        defer {
+            if registered {
+                URLProtocol.unregisterClass(CopilotBudgetBindingStubURLProtocol.self)
+            }
+            CopilotBudgetBindingStubURLProtocol.reset()
+        }
+        CopilotBudgetBindingStubURLProtocol.reset()
+        CopilotBudgetBindingStubURLProtocol.handler = { request in
+            guard let url = request.url else {
+                throw URLError(.badURL)
+            }
+            if url.host == "api.github.com", url.path == "/copilot_internal/user" {
+                return Self.stubResponse(
+                    url: url,
+                    data: Data("""
+                    {
+                      "quota_snapshots": {
+                        "premium_interactions": {
+                          "entitlement": 300,
+                          "remaining": 240,
+                          "percent_remaining": 80,
+                          "quota_id": "premium"
+                        }
+                      },
+                      "copilot_plan": "pro"
+                    }
+                    """.utf8))
+            }
+            if url.host == "api.github.com", url.path == "/user" {
+                return Self.stubResponse(
+                    url: url,
+                    data: Data(#"{"id":123,"login":"expecteduser"}"#.utf8))
+            }
+            if url.host == "github.com", url.path == "/settings/billing/budgets", url.query == nil {
+                return Self.stubResponse(
+                    url: url,
+                    data: Data("""
+                    <meta name="x-fetch-nonce" content="nonce">
+                    <meta name="octolytics-actor-id" content="456">
+                    <meta name="user-login" content="otheruser">
+                    """.utf8))
+            }
+            Issue.record("Unexpected request: \(url.absoluteString)")
+            return Self.stubResponse(url: url, data: Data("{}".utf8), statusCode: 404)
+        }
+        let descriptor = ProviderDescriptorRegistry.descriptor(for: .copilot)
+        let settings = ProviderSettingsSnapshot.make(copilot: .init(
+            apiToken: "selected-token",
+            selectedAccountExternalIdentifier: "github:user:123",
+            budgetExtrasEnabled: true,
+            budgetCookieSource: .manual,
+            manualBudgetCookieHeader: "user_session=other"))
+        let context = Self.makeFetchContext(settings: settings)
+
+        let outcome = await descriptor.fetchPlan.fetchOutcome(context: context, provider: .copilot)
+
+        guard case let .success(result) = outcome.result else {
+            Issue.record("Expected Copilot usage fetch to succeed")
+            return
+        }
+        #expect(result.usage.primary?.usedPercent == 20)
+        #expect(result.usage.extraRateWindows == nil)
+        #expect(CopilotBudgetBindingStubURLProtocol.requests().contains {
+            $0.url?.query?.contains("page=") == true
+        } == false)
+    }
+
+    @Test
+    func `stale selected account identifier is ignored for budget cookie binding`() async {
+        let registered = URLProtocol.registerClass(CopilotBudgetBindingStubURLProtocol.self)
+        defer {
+            if registered {
+                URLProtocol.unregisterClass(CopilotBudgetBindingStubURLProtocol.self)
+            }
+            CopilotBudgetBindingStubURLProtocol.reset()
+        }
+        CopilotBudgetBindingStubURLProtocol.reset()
+        CopilotBudgetBindingStubURLProtocol.handler = { request in
+            guard let url = request.url else {
+                throw URLError(.badURL)
+            }
+            if url.host == "api.github.com", url.path == "/copilot_internal/user" {
+                return Self.stubResponse(
+                    url: url,
+                    data: Data("""
+                    {
+                      "quota_snapshots": {
+                        "premium_interactions": {
+                          "entitlement": 300,
+                          "remaining": 240,
+                          "percent_remaining": 80,
+                          "quota_id": "premium"
+                        }
+                      },
+                      "copilot_plan": "pro"
+                    }
+                    """.utf8))
+            }
+            if url.host == "api.github.com", url.path == "/user" {
+                return Self.stubResponse(
+                    url: url,
+                    data: Data(#"{"id":999,"login":"newuser"}"#.utf8))
+            }
+            if url.host == "github.com", url.path == "/settings/billing/budgets", url.query == nil {
+                return Self.stubResponse(
+                    url: url,
+                    data: Data("""
+                    <meta name="x-fetch-nonce" content="nonce">
+                    <meta name="octolytics-actor-id" content="123">
+                    <meta name="user-login" content="olduser">
+                    """.utf8))
+            }
+            Issue.record("Unexpected request: \(url.absoluteString)")
+            return Self.stubResponse(url: url, data: Data("{}".utf8), statusCode: 404)
+        }
+        let descriptor = ProviderDescriptorRegistry.descriptor(for: .copilot)
+        let settings = ProviderSettingsSnapshot.make(copilot: .init(
+            apiToken: "new-selected-token",
+            selectedAccountExternalIdentifier: "github:user:123",
+            budgetExtrasEnabled: true,
+            budgetCookieSource: .manual,
+            manualBudgetCookieHeader: "user_session=old-browser-account"))
+        let context = Self.makeFetchContext(settings: settings)
+
+        let outcome = await descriptor.fetchPlan.fetchOutcome(context: context, provider: .copilot)
+
+        guard case let .success(result) = outcome.result else {
+            Issue.record("Expected Copilot usage fetch to succeed")
+            return
+        }
+        #expect(result.usage.primary?.usedPercent == 20)
+        #expect(result.usage.extraRateWindows == nil)
+        #expect(CopilotBudgetBindingStubURLProtocol.requests().contains {
+            $0.url?.path == "/user"
+        })
+        #expect(CopilotBudgetBindingStubURLProtocol.requests().contains {
+            $0.url?.query?.contains("page=") == true
+        } == false)
+    }
+
+    @Test
+    func `invalid github budget JSON maps to invalid response`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            guard let url = request.url,
+                  let response = HTTPURLResponse(
+                      url: url,
+                      statusCode: 200,
+                      httpVersion: "HTTP/1.1",
+                      headerFields: nil)
+            else {
+                throw URLError(.badServerResponse)
+            }
+            if request.url?.query?.contains("page=") == true {
+                return (Data("{".utf8), response)
+            }
+            return (Data(#"<meta name="x-fetch-nonce" content="nonce">"#.utf8), response)
+        }
+        let fetcher = CopilotBudgetWebFetcher(
+            transport: transport,
+            now: { Date(timeIntervalSince1970: 1_780_358_400) })
+
+        do {
+            _ = try await fetcher.fetchBudgetWindows(cookieHeader: "user_session=abc")
+            Issue.record("Expected invalidResponse")
+        } catch let error as CopilotBudgetWebFetcher.Error {
+            #expect(error == .invalidResponse)
+        }
+    }
+
+    @Test
+    func `cached cookie non auth errors do not fall back to browser import`() async throws {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+        CookieHeaderCache.store(provider: .copilot, cookieHeader: "user_session=cached", sourceLabel: "Chrome")
+        defer { CookieHeaderCache.clear(provider: .copilot) }
+
+        let transport = ProviderHTTPTransportStub { request in
+            guard let url = request.url,
+                  let response = HTTPURLResponse(
+                      url: url,
+                      statusCode: 500,
+                      httpVersion: "HTTP/1.1",
+                      headerFields: nil)
+            else {
+                throw URLError(.badServerResponse)
+            }
+            return (Data("{}".utf8), response)
+        }
+        let fetcher = CopilotBudgetWebFetcher(transport: transport)
+
+        do {
+            _ = try await fetcher.fetchBudgetWindows()
+            Issue.record("Expected badStatus")
+        } catch let error as CopilotBudgetWebFetcher.Error {
+            #expect(error == .badStatus(500))
+        }
+
+        #expect(await transport.requests().count == 2)
+        #expect(CookieHeaderCache.load(provider: .copilot)?.cookieHeader == "user_session=cached")
+    }
+
+    @Test
+    func `cached cookie account mismatch clears cache before browser fallback`() async throws {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+        CookieHeaderCache.store(provider: .copilot, cookieHeader: "user_session=cached", sourceLabel: "Chrome")
+        defer { CookieHeaderCache.clear(provider: .copilot) }
+
+        let temp = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        try FileManager.default.createDirectory(at: temp, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: temp) }
+
+        let transport = ProviderHTTPTransportStub { request in
+            guard let url = request.url,
+                  let response = HTTPURLResponse(
+                      url: url,
+                      statusCode: 200,
+                      httpVersion: "HTTP/1.1",
+                      headerFields: nil)
+            else {
+                throw URLError(.badServerResponse)
+            }
+            if request.url?.query?.contains("page=") == true {
+                Issue.record("Mismatched cached cookie should not reach budget JSON endpoint")
+                return (Data(#"{"budgets":[],"has_next_page":false}"#.utf8), response)
+            }
+            return (
+                Data("""
+                <meta name="x-fetch-nonce" content="nonce">
+                <meta name="octolytics-actor-id" content="456">
+                <meta name="user-login" content="otheruser">
+                """.utf8),
+                response)
+        }
+        let fetcher = CopilotBudgetWebFetcher(
+            expectedGitHubAccountIdentifier: "github:user:123",
+            browserDetection: BrowserDetection(homeDirectory: temp.path, cacheTTL: 0),
+            transport: transport)
+
+        do {
+            _ = try await fetcher.fetchBudgetWindows()
+            Issue.record("Expected browser fallback to exhaust without a session")
+        } catch let error as CopilotBudgetWebFetcher.Error {
+            #expect(error == .noSessionCookie)
+        }
+
+        #expect(await transport.requests().count == 1)
+        #expect(CookieHeaderCache.load(provider: .copilot) == nil)
+    }
+
+    @Test
+    func `cached cookie missing identity clears cache before browser fallback`() async throws {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+        CookieHeaderCache.store(provider: .copilot, cookieHeader: "user_session=cached", sourceLabel: "Chrome")
+        defer { CookieHeaderCache.clear(provider: .copilot) }
+
+        let temp = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        try FileManager.default.createDirectory(at: temp, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: temp) }
+
+        let transport = ProviderHTTPTransportStub { request in
+            guard let url = request.url,
+                  let response = HTTPURLResponse(
+                      url: url,
+                      statusCode: 200,
+                      httpVersion: "HTTP/1.1",
+                      headerFields: nil)
+            else {
+                throw URLError(.badServerResponse)
+            }
+            if request.url?.query?.contains("page=") == true {
+                Issue.record("Unverifiable cached cookie should not reach budget JSON endpoint")
+                return (Data(#"{"budgets":[],"has_next_page":false}"#.utf8), response)
+            }
+            return (Data(#"<meta name="x-fetch-nonce" content="nonce">"#.utf8), response)
+        }
+        let fetcher = CopilotBudgetWebFetcher(
+            expectedGitHubAccountIdentifier: "github:user:123",
+            browserDetection: BrowserDetection(homeDirectory: temp.path, cacheTTL: 0),
+            transport: transport)
+
+        do {
+            _ = try await fetcher.fetchBudgetWindows()
+            Issue.record("Expected browser fallback to exhaust without a session")
+        } catch let error as CopilotBudgetWebFetcher.Error {
+            #expect(error == .noSessionCookie)
+        }
+
+        #expect(await transport.requests().count == 1)
+        #expect(CookieHeaderCache.load(provider: .copilot) == nil)
+    }
+
+    @Test
+    func `budget page request omits content type on get`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            guard let url = request.url,
+                  let response = HTTPURLResponse(
+                      url: url,
+                      statusCode: 200,
+                      httpVersion: "HTTP/1.1",
+                      headerFields: nil)
+            else {
+                throw URLError(.badServerResponse)
+            }
+            if request.url?.query?.contains("page=") == true {
+                return (Data(#"{"budgets":[],"has_next_page":false}"#.utf8), response)
+            }
+            return (Data(#"<meta name="x-fetch-nonce" content="nonce">"#.utf8), response)
+        }
+        let fetcher = CopilotBudgetWebFetcher(transport: transport)
+
+        _ = try await fetcher.fetchBudgetWindows(cookieHeader: "user_session=abc")
+
+        let pageRequest = try #require(await transport.requests().first { $0.url?.query?.contains("page=") == true })
+        #expect(pageRequest.value(forHTTPHeaderField: "Content-Type") == nil)
+    }
+
+    private static func makeFetchContext(settings: ProviderSettingsSnapshot) -> ProviderFetchContext {
+        let browserDetection = BrowserDetection(cacheTTL: 0)
+        return ProviderFetchContext(
+            runtime: .app,
+            sourceMode: .api,
+            includeCredits: false,
+            webTimeout: 1,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: [:],
+            settings: settings,
+            fetcher: UsageFetcher(environment: [:]),
+            claudeFetcher: ClaudeUsageFetcher(browserDetection: browserDetection),
+            browserDetection: browserDetection)
+    }
+
+    private static func stubResponse(
+        url: URL,
+        data: Data,
+        statusCode: Int = 200) -> (Data, URLResponse)
+    {
+        let response = HTTPURLResponse(
+            url: url,
+            statusCode: statusCode,
+            httpVersion: "HTTP/1.1",
+            headerFields: ["Content-Type": "application/json"])!
+        return (data, response)
+    }
+}
+
+final class CopilotBudgetBindingStubURLProtocol: URLProtocol {
+    private static let lock = NSLock()
+    nonisolated(unsafe) static var handler: (@Sendable (URLRequest) throws -> (Data, URLResponse))?
+    private nonisolated(unsafe) static var recordedRequests: [URLRequest] = []
+
+    static func reset() {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        self.handler = nil
+        self.recordedRequests = []
+    }
+
+    static func requests() -> [URLRequest] {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        return self.recordedRequests
+    }
+
+    override static func canInit(with request: URLRequest) -> Bool {
+        guard self.hasHandler else { return false }
+        guard request.url?.scheme == "https" else { return false }
+        switch (request.url?.host, request.url?.path) {
+        case ("api.github.com", "/copilot_internal/user"),
+             ("api.github.com", "/user"),
+             ("github.com", "/settings/billing/budgets"):
+            return true
+        default:
+            return false
+        }
+    }
+
+    override static func canonicalRequest(for request: URLRequest) -> URLRequest {
+        request
+    }
+
+    override func startLoading() {
+        Self.lock.lock()
+        Self.recordedRequests.append(self.request)
+        let handler = Self.handler
+        Self.lock.unlock()
+
+        guard let handler else {
+            self.client?.urlProtocol(self, didFailWithError: URLError(.badServerResponse))
+            return
+        }
+
+        do {
+            let (data, response) = try handler(self.request)
+            self.client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
+            self.client?.urlProtocol(self, didLoad: data)
+            self.client?.urlProtocolDidFinishLoading(self)
+        } catch {
+            self.client?.urlProtocol(self, didFailWithError: error)
+        }
+    }
+
+    override func stopLoading() {}
+}
+
+extension CopilotBudgetBindingStubURLProtocol {
+    fileprivate static var hasHandler: Bool {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        return self.handler != nil
+    }
+}
diff --git a/Tests/CodexBarTests/CopilotDeviceFlowTests.swift b/Tests/CodexBarTests/CopilotDeviceFlowTests.swift
new file mode 100644
index 0000000000..a79ac02ffc
--- /dev/null
+++ b/Tests/CodexBarTests/CopilotDeviceFlowTests.swift
@@ -0,0 +1,91 @@
+import CodexBarCore
+import Foundation
+import Testing
+
+struct CopilotDeviceFlowTests {
+    @Test
+    func `prefers verification uri complete when available`() throws {
+        let response = try JSONDecoder().decode(
+            CopilotDeviceFlow.DeviceCodeResponse.self,
+            from: Data(
+                """
+                {
+                  "device_code": "device-code",
+                  "user_code": "ABCD-EFGH",
+                  "verification_uri": "https://github.com/login/device",
+                  "verification_uri_complete": "https://github.com/login/device?user_code=ABCD-EFGH",
+                  "expires_in": 900,
+                  "interval": 5
+                }
+                """.utf8))
+
+        #expect(response.verificationURLToOpen == "https://github.com/login/device?user_code=ABCD-EFGH")
+    }
+
+    @Test
+    func `falls back to verification uri when complete url missing`() throws {
+        let response = try JSONDecoder().decode(
+            CopilotDeviceFlow.DeviceCodeResponse.self,
+            from: Data(
+                """
+                {
+                  "device_code": "device-code",
+                  "user_code": "ABCD-EFGH",
+                  "verification_uri": "https://github.com/login/device",
+                  "expires_in": 900,
+                  "interval": 5
+                }
+                """.utf8))
+
+        #expect(response.verificationURLToOpen == "https://github.com/login/device")
+    }
+
+    @Test
+    func `device flow uses github by default`() throws {
+        let flow = CopilotDeviceFlow()
+        let deviceCodeURL = try #require(flow.deviceCodeURL)
+        let accessTokenURL = try #require(flow.accessTokenURL)
+
+        #expect(deviceCodeURL.absoluteString == "https://github.com/login/device/code")
+        #expect(accessTokenURL.absoluteString == "https://github.com/login/oauth/access_token")
+    }
+
+    @Test
+    func `device flow uses enterprise host`() throws {
+        let flow = CopilotDeviceFlow(enterpriseHost: "https://octocorp.ghe.com/login")
+        let deviceCodeURL = try #require(flow.deviceCodeURL)
+        let accessTokenURL = try #require(flow.accessTokenURL)
+
+        #expect(deviceCodeURL.absoluteString == "https://octocorp.ghe.com/login/device/code")
+        #expect(accessTokenURL.absoluteString == "https://octocorp.ghe.com/login/oauth/access_token")
+    }
+
+    @Test
+    func `device flow rejects invalid enterprise host without crashing`() {
+        let flow = CopilotDeviceFlow(enterpriseHost: "foo bar")
+
+        #expect(flow.deviceCodeURL == nil)
+        #expect(flow.accessTokenURL == nil)
+    }
+
+    @Test
+    func `device flow preserves enterprise host port`() throws {
+        let flow = CopilotDeviceFlow(enterpriseHost: "https://octocorp.ghe.com:8443/login")
+        let deviceCodeURL = try #require(flow.deviceCodeURL)
+        let accessTokenURL = try #require(flow.accessTokenURL)
+
+        #expect(deviceCodeURL.absoluteString == "https://octocorp.ghe.com:8443/login/device/code")
+        #expect(accessTokenURL.absoluteString == "https://octocorp.ghe.com:8443/login/oauth/access_token")
+    }
+
+    @Test
+    func `usage url uses enterprise api host`() throws {
+        let defaultURL = try #require(CopilotUsageFetcher.usageURL(enterpriseHost: nil))
+        let enterpriseURL = try #require(CopilotUsageFetcher.usageURL(enterpriseHost: "octocorp.ghe.com"))
+        let enterprisePortURL = try #require(CopilotUsageFetcher.usageURL(enterpriseHost: "octocorp.ghe.com:8443"))
+
+        #expect(defaultURL.absoluteString == "https://api.github.com/copilot_internal/user")
+        #expect(enterpriseURL.absoluteString == "https://api.octocorp.ghe.com/copilot_internal/user")
+        #expect(enterprisePortURL.absoluteString == "https://api.octocorp.ghe.com:8443/copilot_internal/user")
+    }
+}
diff --git a/Tests/CodexBarTests/CopilotMenuCardModelTests.swift b/Tests/CodexBarTests/CopilotMenuCardModelTests.swift
new file mode 100644
index 0000000000..5c1a238928
--- /dev/null
+++ b/Tests/CodexBarTests/CopilotMenuCardModelTests.swift
@@ -0,0 +1,44 @@
+import CodexBarCore
+import Foundation
+import SwiftUI
+import Testing
+@testable import CodexBar
+
+struct CopilotMenuCardModelTests {
+    @Test
+    func `hides copilot budget bars when budget extras are disabled`() throws {
+        let now = Date()
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 20, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 30, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            extraRateWindows: [
+                NamedRateWindow(
+                    id: "copilot-budget-agent",
+                    title: "Budget - Copilot Agent Premium Requests",
+                    window: RateWindow(usedPercent: 65, windowMinutes: nil, resetsAt: nil, resetDescription: nil)),
+            ],
+            updatedAt: now)
+        let metadata = try #require(ProviderDefaults.metadata[.copilot])
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .copilot,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.metrics.map(\.title) == ["Premium", "Chat"])
+    }
+}
diff --git a/Tests/CodexBarTests/CopilotMultiAccountTests.swift b/Tests/CodexBarTests/CopilotMultiAccountTests.swift
new file mode 100644
index 0000000000..0dc6ae673d
--- /dev/null
+++ b/Tests/CodexBarTests/CopilotMultiAccountTests.swift
@@ -0,0 +1,409 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+// MARK: - Catalog
+
+@Test
+func `copilot catalog entry exists`() {
+    let support = TokenAccountSupportCatalog.support(for: .copilot)
+    #expect(support != nil)
+    #expect(support?.requiresManualCookieSource == false)
+    #expect(support?.cookieName == nil)
+}
+
+@Test
+func `copilot catalog entry uses environment injection`() {
+    let support = TokenAccountSupportCatalog.support(for: .copilot)
+    guard let support else {
+        Issue.record("Copilot catalog entry missing")
+        return
+    }
+    if case let .environment(key) = support.injection {
+        #expect(key == "COPILOT_API_TOKEN")
+    } else {
+        Issue.record("Expected .environment injection, got cookieHeader")
+    }
+}
+
+@Test
+func `copilot env override uses correct key`() {
+    let override = TokenAccountSupportCatalog.envOverride(for: .copilot, token: "gh_abc")
+    #expect(override == ["COPILOT_API_TOKEN": "gh_abc"])
+}
+
+// MARK: - Username Fetch (parsing only)
+
+@Test
+func `GitHub user response parses stable id and login`() throws {
+    let json = #"{"login": "testuser", "id": 123, "name": "Test User"}"#
+    let user = try JSONDecoder().decode(CopilotUsageFetcher.GitHubUserIdentity.self, from: Data(json.utf8))
+    #expect(user.id == 123)
+    #expect(user.login == "testuser")
+}
+
+@Test
+func `GitHub user response requires stable id`() throws {
+    let json = #"{"login": "minimaluser"}"#
+    #expect(throws: DecodingError.self) {
+        try JSONDecoder().decode(CopilotUsageFetcher.GitHubUserIdentity.self, from: Data(json.utf8))
+    }
+}
+
+// MARK: - API Key Fallback
+
+@MainActor
+struct CopilotAPIKeyFallbackTests {
+    @Test
+    func `ensure loader preserves config token`() {
+        let settings = Self.makeSettingsStore(suite: "copilot-api-key-loader")
+        settings.copilotAPIToken = "gh_token_123"
+
+        settings.ensureCopilotAPITokenLoaded()
+
+        #expect(settings.copilotAPIToken == "gh_token_123")
+        #expect(settings.tokenAccounts(for: .copilot).isEmpty)
+    }
+
+    @Test
+    func `token accounts clear legacy config token`() {
+        let settings = Self.makeSettingsStore(suite: "copilot-api-key-with-accounts")
+        settings.copilotAPIToken = "gh_token_old"
+        settings.addTokenAccount(provider: .copilot, label: "existing", token: "gh_token_existing")
+
+        settings.ensureCopilotAPITokenLoaded()
+
+        #expect(settings.tokenAccounts(for: .copilot).count == 1)
+        #expect(settings.copilotAPIToken.isEmpty)
+        #expect(settings.copilotSettingsSnapshot(tokenOverride: nil).apiToken == "gh_token_existing")
+        #expect(settings.tokenAccounts(for: .copilot).first?.label == "existing")
+    }
+
+    private static func makeSettingsStore(suite: String) -> SettingsStore {
+        SettingsStore(
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore(),
+            codexCookieStore: InMemoryCookieHeaderStore(),
+            claudeCookieStore: InMemoryCookieHeaderStore(),
+            cursorCookieStore: InMemoryCookieHeaderStore(),
+            opencodeCookieStore: InMemoryCookieHeaderStore(),
+            factoryCookieStore: InMemoryCookieHeaderStore(),
+            minimaxCookieStore: InMemoryMiniMaxCookieStore(),
+            minimaxAPITokenStore: InMemoryMiniMaxAPITokenStore(),
+            kimiTokenStore: InMemoryKimiTokenStore(),
+            kimiK2TokenStore: InMemoryKimiK2TokenStore(),
+            augmentCookieStore: InMemoryCookieHeaderStore(),
+            ampCookieStore: InMemoryCookieHeaderStore(),
+            copilotTokenStore: InMemoryCopilotTokenStore(),
+            tokenAccountStore: InMemoryTokenAccountStore())
+    }
+}
+
+// MARK: - Environment Precedence
+
+@MainActor
+struct CopilotEnvironmentPrecedenceTests {
+    @Test
+    func `token account overrides config API key`() throws {
+        let settings = Self.makeSettingsStore(suite: "copilot-env-override")
+        settings.copilotAPIToken = "old_config_token"
+        settings.addTokenAccount(provider: .copilot, label: "new", token: "new_account_token")
+
+        let account = try #require(settings.selectedTokenAccount(for: .copilot))
+        let override = TokenAccountOverride(provider: .copilot, account: account)
+        let env = ProviderRegistry.makeEnvironment(
+            base: [:],
+            provider: .copilot,
+            settings: settings,
+            tokenOverride: override)
+        let snapshot = ProviderRegistry.makeSettingsSnapshot(settings: settings, tokenOverride: override)
+
+        #expect(env["COPILOT_API_TOKEN"] == "new_account_token")
+        #expect(snapshot.copilot?.apiToken == "new_account_token")
+    }
+
+    @Test
+    func `selected token account is included in copilot settings snapshot`() {
+        let settings = Self.makeSettingsStore(suite: "copilot-settings-snapshot-account")
+        settings.copilotAPIToken = "old_config_token"
+        settings.addTokenAccount(provider: .copilot, label: "new", token: "new_account_token")
+
+        let snapshot = ProviderRegistry.makeSettingsSnapshot(settings: settings, tokenOverride: nil)
+
+        #expect(snapshot.copilot?.apiToken == "new_account_token")
+    }
+
+    @Test
+    func `config API key used when no token accounts`() {
+        let settings = Self.makeSettingsStore(suite: "copilot-env-config-only")
+        settings.copilotAPIToken = "config_token"
+
+        let env = ProviderRegistry.makeEnvironment(
+            base: [:],
+            provider: .copilot,
+            settings: settings,
+            tokenOverride: nil)
+        let snapshot = ProviderRegistry.makeSettingsSnapshot(settings: settings, tokenOverride: nil)
+
+        #expect(env["COPILOT_API_TOKEN"] == "config_token")
+        #expect(snapshot.copilot?.apiToken == "config_token")
+    }
+
+    private static func makeSettingsStore(suite: String) -> SettingsStore {
+        SettingsStore(
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore(),
+            codexCookieStore: InMemoryCookieHeaderStore(),
+            claudeCookieStore: InMemoryCookieHeaderStore(),
+            cursorCookieStore: InMemoryCookieHeaderStore(),
+            opencodeCookieStore: InMemoryCookieHeaderStore(),
+            factoryCookieStore: InMemoryCookieHeaderStore(),
+            minimaxCookieStore: InMemoryMiniMaxCookieStore(),
+            minimaxAPITokenStore: InMemoryMiniMaxAPITokenStore(),
+            kimiTokenStore: InMemoryKimiTokenStore(),
+            kimiK2TokenStore: InMemoryKimiK2TokenStore(),
+            augmentCookieStore: InMemoryCookieHeaderStore(),
+            ampCookieStore: InMemoryCookieHeaderStore(),
+            copilotTokenStore: InMemoryCopilotTokenStore(),
+            tokenAccountStore: InMemoryTokenAccountStore())
+    }
+}
+
+// MARK: - External Identifier Dedup
+
+@MainActor
+struct CopilotExternalIdentifierTests {
+    @Test
+    func `addTokenAccount persists external identifier`() throws {
+        let settings = Self.makeSettingsStore(suite: "copilot-ext-id-add")
+        settings.addTokenAccount(
+            provider: .copilot,
+            label: "octocat (Pro)",
+            token: "gh_token_1",
+            externalIdentifier: "octocat")
+
+        let account = try #require(settings.tokenAccounts(for: .copilot).first)
+        #expect(account.externalIdentifier == "octocat")
+    }
+
+    @Test
+    func `updateTokenAccount preserves identifier when not provided`() throws {
+        let settings = Self.makeSettingsStore(suite: "copilot-ext-id-preserve")
+        settings.addTokenAccount(
+            provider: .copilot,
+            label: "octocat (Pro)",
+            token: "gh_token_1",
+            externalIdentifier: "octocat")
+        let original = try #require(settings.tokenAccounts(for: .copilot).first)
+
+        settings.updateTokenAccount(
+            provider: .copilot,
+            accountID: original.id,
+            label: "octocat (Business)",
+            token: "gh_token_2")
+
+        let updated = try #require(settings.tokenAccounts(for: .copilot).first)
+        #expect(updated.id == original.id)
+        #expect(updated.token == "gh_token_2")
+        #expect(updated.externalIdentifier == "octocat")
+    }
+
+    @Test
+    func `updateTokenAccount writes identifier back for legacy accounts`() throws {
+        let settings = Self.makeSettingsStore(suite: "copilot-ext-id-backfill")
+        // Legacy account: no externalIdentifier (pre-feature).
+        settings.addTokenAccount(provider: .copilot, label: "octocat (Pro)", token: "gh_legacy")
+        let legacy = try #require(settings.tokenAccounts(for: .copilot).first)
+        #expect(legacy.externalIdentifier == nil)
+
+        settings.updateTokenAccount(
+            provider: .copilot,
+            accountID: legacy.id,
+            label: "octocat (Pro)",
+            token: "gh_refreshed",
+            externalIdentifier: .some("octocat"))
+
+        let updated = try #require(settings.tokenAccounts(for: .copilot).first)
+        #expect(updated.id == legacy.id)
+        #expect(updated.externalIdentifier == "octocat")
+    }
+
+    @Test
+    func `legacy Account N account matches reauth by stored token identity`() async {
+        let legacy = Self.makeAccount(label: "Account 1", token: "old-token", externalIdentifier: nil)
+        let matched = await CopilotLoginFlow.matchExistingAccount(
+            existingAccounts: [legacy],
+            identity: Self.identity(id: 123, login: "octocat"),
+            label: "octocat (Pro)",
+            legacyIdentityResolver: { account in
+                account.token == "old-token" ? Self.identity(id: 123, login: "octocat") : nil
+            })
+
+        #expect(matched?.id == legacy.id)
+    }
+
+    @Test
+    func `user renamed legacy account matches reauth by stored token identity`() async {
+        let legacy = Self.makeAccount(label: "Work GitHub", token: "old-token", externalIdentifier: nil)
+        let matched = await CopilotLoginFlow.matchExistingAccount(
+            existingAccounts: [legacy],
+            identity: Self.identity(id: 123, login: "octocat"),
+            label: "octocat (Pro)",
+            legacyIdentityResolver: { account in
+                account.token == "old-token" ? Self.identity(id: 123, login: "OctoCat") : nil
+            })
+
+        #expect(matched?.id == legacy.id)
+    }
+
+    @Test
+    func `stable external identifier match is preferred`() async {
+        let identified = Self.makeAccount(
+            label: "Personal",
+            token: "identified",
+            externalIdentifier: "github:user:123")
+        let legacy = Self.makeAccount(label: "octocat", token: "legacy", externalIdentifier: nil)
+        let matched = await CopilotLoginFlow.matchExistingAccount(
+            existingAccounts: [legacy, identified],
+            identity: Self.identity(id: 123, login: "octocat"),
+            label: "octocat (Pro)",
+            legacyIdentityResolver: { _ in
+                Issue.record("Resolver should not run when externalIdentifier matches")
+                return nil
+            })
+
+        #expect(matched?.id == identified.id)
+    }
+
+    @Test
+    func `legacy login external identifier still matches and can be backfilled`() async {
+        let identified = Self.makeAccount(label: "Personal", token: "identified", externalIdentifier: "OctoCat")
+        let matched = await CopilotLoginFlow.matchExistingAccount(
+            existingAccounts: [identified],
+            identity: Self.identity(id: 123, login: "octocat"),
+            label: "octocat (Pro)",
+            legacyIdentityResolver: { _ in
+                Issue.record("Resolver should not run when legacy externalIdentifier matches")
+                return nil
+            })
+
+        #expect(matched?.id == identified.id)
+        #expect(CopilotLoginFlow.externalIdentifier(for: Self.identity(id: 123, login: "octocat")) == "github:user:123")
+    }
+
+    @Test
+    func `decoding legacy token account JSON yields nil identifier`() throws {
+        let json = """
+        {
+          "id": "11111111-1111-1111-1111-111111111111",
+          "label": "octocat",
+          "token": "gh_legacy",
+          "addedAt": 1700000000.0
+        }
+        """
+        let account = try JSONDecoder().decode(ProviderTokenAccount.self, from: Data(json.utf8))
+        #expect(account.label == "octocat")
+        #expect(account.externalIdentifier == nil)
+        #expect(account.lastUsed == nil)
+    }
+
+    private nonisolated static func identity(id: Int64, login: String) -> CopilotUsageFetcher.GitHubUserIdentity {
+        CopilotUsageFetcher.GitHubUserIdentity(id: id, login: login)
+    }
+
+    private static func makeAccount(
+        label: String,
+        token: String,
+        externalIdentifier: String?) -> ProviderTokenAccount
+    {
+        ProviderTokenAccount(
+            id: UUID(),
+            label: label,
+            token: token,
+            addedAt: 1_700_000_000,
+            lastUsed: nil,
+            externalIdentifier: externalIdentifier)
+    }
+
+    private static func makeSettingsStore(suite: String) -> SettingsStore {
+        SettingsStore(
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore(),
+            codexCookieStore: InMemoryCookieHeaderStore(),
+            claudeCookieStore: InMemoryCookieHeaderStore(),
+            cursorCookieStore: InMemoryCookieHeaderStore(),
+            opencodeCookieStore: InMemoryCookieHeaderStore(),
+            factoryCookieStore: InMemoryCookieHeaderStore(),
+            minimaxCookieStore: InMemoryMiniMaxCookieStore(),
+            minimaxAPITokenStore: InMemoryMiniMaxAPITokenStore(),
+            kimiTokenStore: InMemoryKimiTokenStore(),
+            kimiK2TokenStore: InMemoryKimiK2TokenStore(),
+            augmentCookieStore: InMemoryCookieHeaderStore(),
+            ampCookieStore: InMemoryCookieHeaderStore(),
+            copilotTokenStore: InMemoryCopilotTokenStore(),
+            tokenAccountStore: InMemoryTokenAccountStore())
+    }
+}
+
+// MARK: - Token Account Snapshot Error Messages
+
+@MainActor
+struct TokenAccountSnapshotErrorMessageTests {
+    @Test
+    func `cancellation is suppressed for global error path`() {
+        let store = Self.makeUsageStore()
+        #expect(store.tokenAccountErrorMessage(CancellationError()) == nil)
+        #expect(store.tokenAccountErrorMessage(URLError(.cancelled)) == nil)
+    }
+
+    @Test
+    func `cancellation-like localized errors are suppressed`() {
+        let store = Self.makeUsageStore()
+        struct Cancelled: LocalizedError {
+            var errorDescription: String? {
+                "cancelled"
+            }
+        }
+        #expect(store.tokenAccountErrorMessage(Cancelled()) == nil)
+    }
+
+    @Test
+    func `non-cancellation error preserves localized message`() {
+        let store = Self.makeUsageStore()
+        struct Boom: LocalizedError {
+            var errorDescription: String? {
+                "kaboom"
+            }
+        }
+        #expect(store.tokenAccountSnapshotErrorMessage(Boom()) == "kaboom")
+        #expect(store.tokenAccountErrorMessage(Boom()) == "kaboom")
+    }
+
+    private static func makeUsageStore() -> UsageStore {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "copilot-snapshot-error-\(UUID().uuidString)"),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore(),
+            codexCookieStore: InMemoryCookieHeaderStore(),
+            claudeCookieStore: InMemoryCookieHeaderStore(),
+            cursorCookieStore: InMemoryCookieHeaderStore(),
+            opencodeCookieStore: InMemoryCookieHeaderStore(),
+            factoryCookieStore: InMemoryCookieHeaderStore(),
+            minimaxCookieStore: InMemoryMiniMaxCookieStore(),
+            minimaxAPITokenStore: InMemoryMiniMaxAPITokenStore(),
+            kimiTokenStore: InMemoryKimiTokenStore(),
+            kimiK2TokenStore: InMemoryKimiK2TokenStore(),
+            augmentCookieStore: InMemoryCookieHeaderStore(),
+            ampCookieStore: InMemoryCookieHeaderStore(),
+            copilotTokenStore: InMemoryCopilotTokenStore(),
+            tokenAccountStore: InMemoryTokenAccountStore())
+        return UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings)
+    }
+}
diff --git a/Tests/CodexBarTests/CopilotUsageFetcherTests.swift b/Tests/CodexBarTests/CopilotUsageFetcherTests.swift
new file mode 100644
index 0000000000..7ecd9d40ae
--- /dev/null
+++ b/Tests/CodexBarTests/CopilotUsageFetcherTests.swift
@@ -0,0 +1,200 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct CopilotUsageFetcherTests {
+    @Test
+    func `fetchGitHubIdentity uses shared client`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            guard request.value(forHTTPHeaderField: "Authorization") == "token abc123" else {
+                throw URLError(.userAuthenticationRequired)
+            }
+            let response = try HTTPURLResponse(
+                url: #require(request.url),
+                statusCode: 200,
+                httpVersion: "HTTP/1.1",
+                headerFields: ["Content-Type": "application/json"])!
+            return (Data(#"{"login":"testuser","id":123}"#.utf8), response)
+        }
+
+        let identity = try await CopilotUsageFetcher.fetchGitHubIdentity(token: "abc123", transport: transport)
+
+        #expect(identity.login == "testuser")
+        #expect(identity.id == 123)
+        let requests = await transport.requests()
+        #expect(requests.count == 1)
+        #expect(requests.first?.url?.host == "api.github.com")
+    }
+
+    @Test
+    func `fetch returns unavailable snapshot for business token billing placeholders`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            #expect(request.value(forHTTPHeaderField: "Authorization") == "token gh-token")
+            let response = try HTTPURLResponse(
+                url: #require(request.url),
+                statusCode: 200,
+                httpVersion: "HTTP/1.1",
+                headerFields: ["Content-Type": "application/json"])!
+            let data = Data(
+                """
+                {
+                  "copilot_plan": "business",
+                  "token_based_billing": true,
+                  "quota_snapshots": {
+                    "premium_interactions": {
+                      "entitlement": 0,
+                      "remaining": 0,
+                      "percent_remaining": 100,
+                      "quota_id": "premium_interactions"
+                    },
+                    "chat": {
+                      "entitlement": 0,
+                      "remaining": 0,
+                      "percent_remaining": 100,
+                      "quota_id": "chat"
+                    }
+                  }
+                }
+                """.utf8)
+            return (data, response)
+        }
+        let fetcher = CopilotUsageFetcher(token: "gh-token", transport: transport)
+
+        let snapshot = try await fetcher.fetch()
+
+        #expect(snapshot.primary == nil)
+        #expect(snapshot.secondary == nil)
+        #expect(snapshot.identity?.loginMethod == "Business")
+    }
+
+    @Test
+    func `fetch keeps explicitly unlimited chat quota`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            #expect(request.value(forHTTPHeaderField: "Authorization") == "token gh-token")
+            let response = try HTTPURLResponse(
+                url: #require(request.url),
+                statusCode: 200,
+                httpVersion: "HTTP/1.1",
+                headerFields: ["Content-Type": "application/json"])!
+            let data = Data(
+                """
+                {
+                  "copilot_plan": "individual",
+                  "quota_reset_date": "2026-07-01",
+                  "quota_snapshots": {
+                    "chat_messages": {
+                      "entitlement": 0,
+                      "remaining": 0,
+                      "quota_id": "chat_messages",
+                      "unlimited": true
+                    }
+                  }
+                }
+                """.utf8)
+            return (data, response)
+        }
+        let fetcher = CopilotUsageFetcher(token: "gh-token", transport: transport)
+
+        let snapshot = try await fetcher.fetch()
+
+        #expect(snapshot.primary == nil)
+        #expect(snapshot.secondary?.usedPercent == 0)
+        #expect(snapshot.secondary?.resetsAt == nil)
+        #expect(snapshot.identity?.loginMethod == "Individual")
+    }
+
+    @Test
+    func `fetch attaches quota reset date to copilot windows`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            #expect(request.value(forHTTPHeaderField: "Authorization") == "token gh-token")
+            let response = try HTTPURLResponse(
+                url: #require(request.url),
+                statusCode: 200,
+                httpVersion: "HTTP/1.1",
+                headerFields: ["Content-Type": "application/json"])!
+            let data = Data(
+                """
+                {
+                  "copilot_plan": "individual",
+                  "quota_reset_date": "2026-07-01",
+                  "quota_snapshots": {
+                    "premium_interactions": {
+                      "entitlement": 500,
+                      "remaining": 125,
+                      "percent_remaining": 25,
+                      "quota_id": "premium_interactions"
+                    },
+                    "chat": {
+                      "entitlement": 300,
+                      "remaining": 240,
+                      "percent_remaining": 80,
+                      "quota_id": "chat"
+                    }
+                  }
+                }
+                """.utf8)
+            return (data, response)
+        }
+        let fetcher = CopilotUsageFetcher(token: "gh-token", transport: transport)
+        let expectedReset = try #require(CopilotUsageFetcher.parseQuotaResetDate("2026-07-01"))
+
+        let snapshot = try await fetcher.fetch()
+
+        #expect(snapshot.primary?.usedPercent == 75)
+        #expect(snapshot.primary?.resetsAt == expectedReset)
+        #expect(snapshot.secondary?.usedPercent == 20)
+        #expect(snapshot.secondary?.resetsAt == expectedReset)
+    }
+
+    @Test
+    func `makeRateWindow drops business token billing placeholder quota`() {
+        // entitlement=0/remaining=0/percent_remaining=100 must not become a "0% used"
+        // rate window for Copilot Business token-based billing accounts. (#1258)
+        let placeholder = CopilotUsageResponse.QuotaSnapshot(
+            entitlement: 0,
+            remaining: 0,
+            percentRemaining: 100,
+            quotaId: "premium_interactions")
+        #expect(CopilotUsageFetcher.makeRateWindow(from: placeholder) == nil)
+    }
+
+    @Test
+    func `makeRateWindow keeps real quota window`() {
+        let real = CopilotUsageResponse.QuotaSnapshot(
+            entitlement: 500,
+            remaining: 125,
+            percentRemaining: 25,
+            quotaId: "premium_interactions")
+        let window = CopilotUsageFetcher.makeRateWindow(from: real)
+        #expect(window?.usedPercent == 75)
+    }
+
+    @Test
+    func `makeRateWindow carries reset date`() {
+        let resetDate = Date(timeIntervalSince1970: 1_783_468_800)
+        let real = CopilotUsageResponse.QuotaSnapshot(
+            entitlement: 500,
+            remaining: 125,
+            percentRemaining: 25,
+            quotaId: "premium_interactions")
+
+        let window = CopilotUsageFetcher.makeRateWindow(from: real, resetsAt: resetDate)
+
+        #expect(window?.usedPercent == 75)
+        #expect(window?.resetsAt == resetDate)
+    }
+
+    @Test
+    func `parseQuotaResetDate supports date only and ISO timestamps`() throws {
+        let dateOnly = try #require(ISO8601DateFormatter().date(from: "2026-07-01T00:00:00Z"))
+        let iso = try #require(ISO8601DateFormatter().date(from: "2026-07-01T08:30:45Z"))
+        let fractionalFormatter = ISO8601DateFormatter()
+        fractionalFormatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        let fractionalISO = try #require(fractionalFormatter.date(from: "2026-07-01T08:30:45.123Z"))
+
+        #expect(CopilotUsageFetcher.parseQuotaResetDate("2026-07-01") == dateOnly)
+        #expect(CopilotUsageFetcher.parseQuotaResetDate("2026-07-01T08:30:45Z") == iso)
+        #expect(CopilotUsageFetcher.parseQuotaResetDate("2026-07-01T08:30:45.123Z") == fractionalISO)
+        #expect(CopilotUsageFetcher.parseQuotaResetDate(" ") == nil)
+    }
+}
diff --git a/Tests/CodexBarTests/CopilotUsageModelsTests.swift b/Tests/CodexBarTests/CopilotUsageModelsTests.swift
index b2dac88097..4d42656c77 100644
--- a/Tests/CodexBarTests/CopilotUsageModelsTests.swift
+++ b/Tests/CodexBarTests/CopilotUsageModelsTests.swift
@@ -1,11 +1,10 @@
-import CodexBarCore
 import Foundation
 import Testing
+@testable import CodexBarCore
 
-@Suite
 struct CopilotUsageModelsTests {
     @Test
-    func decodesQuotaSnapshotsPayload() throws {
+    func `decodes quota snapshots payload`() throws {
         let response = try Self.decodeFixture(
             """
             {
@@ -37,7 +36,7 @@ struct CopilotUsageModelsTests {
     }
 
     @Test
-    func decodesChatOnlyQuotaSnapshotsPayload() throws {
+    func `decodes chat only quota snapshots payload`() throws {
         let response = try Self.decodeFixture(
             """
             {
@@ -60,7 +59,7 @@ struct CopilotUsageModelsTests {
     }
 
     @Test
-    func preservesMissingDateFieldsAsNil() throws {
+    func `preserves missing date fields as nil`() throws {
         let response = try Self.decodeFixture(
             """
             {
@@ -81,7 +80,7 @@ struct CopilotUsageModelsTests {
     }
 
     @Test
-    func preservesExplicitEmptyDateFields() throws {
+    func `preserves explicit empty date fields`() throws {
         let response = try Self.decodeFixture(
             """
             {
@@ -104,7 +103,7 @@ struct CopilotUsageModelsTests {
     }
 
     @Test
-    func decodesMonthlyAndLimitedQuotaPayload() throws {
+    func `decodes monthly and limited quota payload`() throws {
         let response = try Self.decodeFixture(
             """
             {
@@ -132,7 +131,7 @@ struct CopilotUsageModelsTests {
     }
 
     @Test
-    func doesNotAssumeFullQuotaWhenLimitedQuotasAreMissing() throws {
+    func `does not assume full quota when limited quotas are missing`() throws {
         let response = try Self.decodeFixture(
             """
             {
@@ -149,7 +148,7 @@ struct CopilotUsageModelsTests {
     }
 
     @Test
-    func computesMonthlyFallbackPerQuotaOnlyWhenLimitedValueExists() throws {
+    func `computes monthly fallback per quota only when limited value exists`() throws {
         let response = try Self.decodeFixture(
             """
             {
@@ -172,7 +171,7 @@ struct CopilotUsageModelsTests {
     }
 
     @Test
-    func mergesDirectAndMonthlyFallbackLanesWhenDirectIsPartial() throws {
+    func `merges direct and monthly fallback lanes when direct is partial`() throws {
         let response = try Self.decodeFixture(
             """
             {
@@ -208,7 +207,7 @@ struct CopilotUsageModelsTests {
     }
 
     @Test
-    func decodesUnknownQuotaSnapshotKeysUsingFallback() throws {
+    func `decodes unknown quota snapshot keys using fallback`() throws {
         let response = try Self.decodeFixture(
             """
             {
@@ -232,7 +231,7 @@ struct CopilotUsageModelsTests {
     }
 
     @Test
-    func ignoresPlaceholderKnownSnapshotWhenSelectingUnknownKeyFallback() throws {
+    func `ignores placeholder known snapshot when selecting unknown key fallback`() throws {
         let response = try Self.decodeFixture(
             """
             {
@@ -255,7 +254,7 @@ struct CopilotUsageModelsTests {
     }
 
     @Test
-    func derivesPercentRemainingWhenMissingButEntitlementExists() throws {
+    func `derives percent remaining when missing but entitlement exists`() throws {
         let response = try Self.decodeFixture(
             """
             {
@@ -275,7 +274,56 @@ struct CopilotUsageModelsTests {
     }
 
     @Test
-    func marksPercentRemainingAsUnavailableWhenUnderdetermined() throws {
+    func `preserves over quota percent remaining`() throws {
+        let response = try Self.decodeFixture(
+            """
+            {
+              "copilot_plan": "paid",
+              "quota_snapshots": {
+                "premium_interactions": {
+                  "entitlement": 500,
+                  "remaining": -75,
+                  "percent_remaining": -15,
+                  "quota_id": "premium_interactions"
+                }
+              }
+            }
+            """)
+
+        let snapshot = try #require(response.quotaSnapshots.premiumInteractions)
+        #expect(snapshot.percentRemaining == -15)
+        #expect(snapshot.usedPercent == 115)
+        #expect(snapshot.overQuotaUsedPercent == 115)
+        let window = try #require(CopilotUsageFetcher.makeRateWindow(from: snapshot))
+        #expect(window.usedPercent == 115)
+        #expect(window.resetDescription == "115% used")
+    }
+
+    @Test
+    func `derives over quota percent from negative remaining`() throws {
+        let response = try Self.decodeFixture(
+            """
+            {
+              "copilot_plan": "paid",
+              "quota_snapshots": {
+                "chat": {
+                  "entitlement": 500,
+                  "remaining": -75,
+                  "quota_id": "chat"
+                }
+              }
+            }
+            """)
+
+        let snapshot = try #require(response.quotaSnapshots.chat)
+        #expect(snapshot.hasPercentRemaining)
+        #expect(snapshot.percentRemaining == -15)
+        #expect(snapshot.usedPercent == 115)
+        #expect(snapshot.overQuotaUsedPercent == 115)
+    }
+
+    @Test
+    func `marks percent remaining as unavailable when underdetermined`() throws {
         let response = try Self.decodeFixture(
             """
             {
@@ -294,7 +342,7 @@ struct CopilotUsageModelsTests {
     }
 
     @Test
-    func marksPercentRemainingAsUnavailableWhenRemainingIsMissing() throws {
+    func `marks percent remaining as unavailable when remaining is missing`() throws {
         let response = try Self.decodeFixture(
             """
             {
@@ -313,7 +361,7 @@ struct CopilotUsageModelsTests {
     }
 
     @Test
-    func fallsBackToMonthlyWhenDirectSnapshotIsMissingRemaining() throws {
+    func `falls back to monthly when direct snapshot is missing remaining`() throws {
         let response = try Self.decodeFixture(
             """
             {
@@ -342,7 +390,7 @@ struct CopilotUsageModelsTests {
     }
 
     @Test
-    func fallsBackToMonthlyWhenDirectSnapshotsLackComputablePercent() throws {
+    func `falls back to monthly when direct snapshots lack computable percent`() throws {
         let response = try Self.decodeFixture(
             """
             {
@@ -371,7 +419,7 @@ struct CopilotUsageModelsTests {
     }
 
     @Test
-    func skipsMonthlyFallbackWhenMonthlyDenominatorIsZero() throws {
+    func `skips monthly fallback when monthly denominator is zero`() throws {
         let response = try Self.decodeFixture(
             """
             {
@@ -389,6 +437,140 @@ struct CopilotUsageModelsTests {
         #expect(response.quotaSnapshots.chat == nil)
     }
 
+    @Test
+    func `treats business token billing zero entitlement quotas as unavailable`() throws {
+        // GitHub Copilot Business token-based billing reports every quota as
+        // entitlement=0, remaining=0, percent_remaining=100. That previously rendered as a
+        // misleading "0% used" (100 - 100). A zero-entitlement quota carries no usage signal,
+        // so the snapshots must drop out instead of showing as usage. (#1258)
+        let response = try Self.decodeFixture(
+            """
+            {
+              "copilot_plan": "business",
+              "token_based_billing": true,
+              "quota_snapshots": {
+                "premium_interactions": {
+                  "entitlement": 0,
+                  "remaining": 0,
+                  "percent_remaining": 100,
+                  "quota_id": "premium_interactions"
+                },
+                "chat": {
+                  "entitlement": 0,
+                  "remaining": 0,
+                  "percent_remaining": 100,
+                  "quota_id": "chat"
+                },
+                "completions": {
+                  "entitlement": 0,
+                  "remaining": 0,
+                  "percent_remaining": 100,
+                  "quota_id": "completions"
+                }
+              }
+            }
+            """)
+
+        #expect(response.tokenBasedBilling)
+        #expect(response.quotaSnapshots.premiumInteractions == nil)
+        #expect(response.quotaSnapshots.chat == nil)
+    }
+
+    @Test
+    func `keeps unlimited chat fallback quota without percent remaining`() throws {
+        let response = try Self.decodeFixture(
+            """
+            {
+              "copilot_plan": "individual",
+              "quota_snapshots": {
+                "premium_interactions": {
+                  "entitlement": 200,
+                  "remaining": 191,
+                  "percent_remaining": 95.5,
+                  "quota_id": "premium_interactions"
+                },
+                "chat_messages": {
+                  "entitlement": 0,
+                  "remaining": 0,
+                  "quota_id": "chat_messages",
+                  "unlimited": true
+                }
+              }
+            }
+            """)
+
+        #expect(response.quotaSnapshots.premiumInteractions?.quotaId == "premium_interactions")
+        #expect(response.quotaSnapshots.chat?.quotaId == "chat_messages")
+        #expect(response.quotaSnapshots.chat?.unlimited == true)
+        #expect(response.quotaSnapshots.chat?.usedPercent == 0)
+    }
+
+    @Test
+    func `unlimited quota overrides placeholder percent remaining`() throws {
+        let response = try Self.decodeFixture(
+            """
+            {
+              "copilot_plan": "individual",
+              "quota_snapshots": {
+                "chat": {
+                  "entitlement": 0,
+                  "remaining": 0,
+                  "percent_remaining": 0,
+                  "quota_id": "chat",
+                  "unlimited": true
+                }
+              }
+            }
+            """)
+
+        let chat = try #require(response.quotaSnapshots.chat)
+        #expect(chat.percentRemaining == 100)
+        #expect(chat.usedPercent == 0)
+        #expect(!chat.isPlaceholder)
+    }
+
+    @Test
+    func `flags zero entitlement snapshot as placeholder`() {
+        let snapshot = CopilotUsageResponse.QuotaSnapshot(
+            entitlement: 0,
+            remaining: 0,
+            percentRemaining: 100,
+            quotaId: "chat")
+        #expect(snapshot.isPlaceholder)
+    }
+
+    @Test
+    func `keeps fully consumed quota with positive entitlement`() {
+        // entitlement > 0 with remaining 0 is a real "100% used" window, not a placeholder.
+        let snapshot = CopilotUsageResponse.QuotaSnapshot(
+            entitlement: 500,
+            remaining: 0,
+            percentRemaining: 0,
+            quotaId: "premium_interactions")
+        #expect(!snapshot.isPlaceholder)
+        #expect(snapshot.usedPercent == 100)
+    }
+
+    @Test
+    func `keeps percent only quota snapshots available`() throws {
+        let response = try Self.decodeFixture(
+            """
+            {
+              "copilot_plan": "business",
+              "quota_snapshots": {
+                "chat": {
+                  "percent_remaining": 40,
+                  "quota_id": "chat"
+                }
+              }
+            }
+            """)
+
+        #expect(response.quotaSnapshots.chat?.percentRemaining == 40)
+        #expect(response.quotaSnapshots.chat?.usedPercent == 60)
+        #expect(response.quotaSnapshots.chat?.isPlaceholder == false)
+    }
+
     private static func decodeFixture(_ fixture: String) throws -> CopilotUsageResponse {
         try JSONDecoder().decode(CopilotUsageResponse.self, from: Data(fixture.utf8))
     }
diff --git a/Tests/CodexBarTests/CostHistoryChartMenuViewTests.swift b/Tests/CodexBarTests/CostHistoryChartMenuViewTests.swift
new file mode 100644
index 0000000000..188532812f
--- /dev/null
+++ b/Tests/CodexBarTests/CostHistoryChartMenuViewTests.swift
@@ -0,0 +1,185 @@
+import CodexBarCore
+import SwiftUI
+import Testing
+@testable import CodexBar
+
+struct CostHistoryChartMenuViewTests {
+    @Test
+    @MainActor
+    func `model breakdown keeps every item behind a bounded scrolling viewport`() {
+        let breakdown = (1...6).map { index in
+            CostUsageDailyReport.ModelBreakdown(
+                modelName: "model-\(index)",
+                costUSD: Double(index),
+                totalTokens: index * 100)
+        }
+
+        let ordered = CostHistoryChartMenuView.orderedBreakdownItems(breakdown)
+
+        #expect(ordered.map(\.modelName) == [
+            "model-6",
+            "model-5",
+            "model-4",
+            "model-3",
+            "model-2",
+            "model-1",
+        ])
+        #expect(CostHistoryChartMenuView.detailViewportRowCount(itemCount: ordered.count) == 4)
+        #expect(CostHistoryChartMenuView.detailRowsNeedScrolling(itemCount: ordered.count))
+    }
+
+    @Test
+    @MainActor
+    func `menu hosting view publishes measured height through intrinsic size`() {
+        let hosting = MenuHostingView(rootView: EmptyView())
+        hosting.frame = CGRect(x: 0, y: 0, width: 320, height: 1)
+
+        hosting.applyMeasuredHeight(width: 320, height: 123.2)
+
+        #expect(hosting.frame.size == CGSize(width: 320, height: 124))
+        #expect(hosting.intrinsicContentSize.height == 124)
+    }
+
+    @Test
+    @MainActor
+    func `cost history defaults selection to latest day`() {
+        let daily = [
+            CostUsageDailyReport.Entry(
+                date: "2026-06-07",
+                inputTokens: 100,
+                outputTokens: 50,
+                totalTokens: 150,
+                costUSD: 1.25,
+                modelsUsed: ["gpt-5.5"],
+                modelBreakdowns: nil),
+            CostUsageDailyReport.Entry(
+                date: "2026-06-09",
+                inputTokens: 200,
+                outputTokens: 75,
+                totalTokens: 275,
+                costUSD: 2.5,
+                modelsUsed: ["gpt-5.5"],
+                modelBreakdowns: nil),
+        ]
+
+        #expect(
+            CostHistoryChartMenuView._defaultSelectedDateKeyForTesting(
+                provider: .codex,
+                daily: daily) == "2026-06-09")
+    }
+
+    @Test
+    @MainActor
+    func `cost history detail height follows visible rows and caps at viewport limit`() {
+        let singleRowHeight = CostHistoryChartMenuView._detailViewportHeightForTesting(modeSubtitlePresence: [false])
+        let twoRowHeight = CostHistoryChartMenuView._detailViewportHeightForTesting(modeSubtitlePresence: [false, true])
+        let fourRowHeight = CostHistoryChartMenuView._detailViewportHeightForTesting(
+            modeSubtitlePresence: [false, false, false, false])
+        let fiveRowHeight = CostHistoryChartMenuView._detailViewportHeightForTesting(
+            modeSubtitlePresence: [false, false, false, false, true])
+
+        #expect(singleRowHeight < twoRowHeight)
+        #expect(twoRowHeight < fourRowHeight)
+        #expect(fiveRowHeight == fourRowHeight)
+
+        let emptyBlockHeight = CostHistoryChartMenuView._detailBlockHeightForTesting(modeSubtitlePresence: [])
+        let populatedBlockHeight = CostHistoryChartMenuView._detailBlockHeightForTesting(modeSubtitlePresence: [false])
+        #expect(emptyBlockHeight < populatedBlockHeight)
+    }
+
+    @Test
+    @MainActor
+    func `axis dates span first to last for multi-day data`() {
+        let daily = [
+            CostUsageDailyReport.Entry(
+                date: "2026-05-21",
+                inputTokens: nil,
+                outputTokens: nil,
+                totalTokens: nil,
+                costUSD: 1.0,
+                modelsUsed: nil,
+                modelBreakdowns: nil),
+            CostUsageDailyReport.Entry(
+                date: "2026-06-17",
+                inputTokens: nil,
+                outputTokens: nil,
+                totalTokens: nil,
+                costUSD: 2.0,
+                modelsUsed: nil,
+                modelBreakdowns: nil),
+        ]
+        let dates = CostHistoryChartMenuView._axisDatesForTesting(provider: .codex, daily: daily)
+        let cal = Calendar.current
+        #expect(dates.count == 2)
+        #expect(cal.component(.month, from: dates[0]) == 5)
+        #expect(cal.component(.day, from: dates[0]) == 21)
+        #expect(cal.component(.month, from: dates[1]) == 6)
+        #expect(cal.component(.day, from: dates[1]) == 17)
+        #expect(
+            CostHistoryChartMenuView._axisLabelPlacementForTesting(
+                provider: .codex,
+                daily: daily) == .edges)
+    }
+
+    @Test
+    @MainActor
+    func `axis dates collapse to one for single-day data`() {
+        let daily = [
+            CostUsageDailyReport.Entry(
+                date: "2026-06-17",
+                inputTokens: nil,
+                outputTokens: nil,
+                totalTokens: nil,
+                costUSD: 1.0,
+                modelsUsed: nil,
+                modelBreakdowns: nil),
+        ]
+        let dates = CostHistoryChartMenuView._axisDatesForTesting(provider: .codex, daily: daily)
+        #expect(dates.count == 1)
+        #expect(
+            CostHistoryChartMenuView._axisLabelPlacementForTesting(
+                provider: .codex,
+                daily: daily) == .centered)
+    }
+
+    @Test
+    @MainActor
+    func `axis dates are empty when there is no cost data`() {
+        let daily = [
+            CostUsageDailyReport.Entry(
+                date: "2026-06-17",
+                inputTokens: nil,
+                outputTokens: nil,
+                totalTokens: nil,
+                costUSD: nil,
+                modelsUsed: nil,
+                modelBreakdowns: nil),
+        ]
+        let dates = CostHistoryChartMenuView._axisDatesForTesting(provider: .codex, daily: daily)
+        #expect(dates.isEmpty)
+        #expect(
+            CostHistoryChartMenuView._axisLabelPlacementForTesting(
+                provider: .codex,
+                daily: daily) == .hidden)
+    }
+
+    @Test
+    @MainActor
+    func `cost history total card height grows with rows and the total line`() {
+        let oneRow = CostHistoryChartMenuView._totalCardHeightForTesting(
+            modeSubtitlePresence: [false],
+            hasTotal: false)
+        let threeRows = CostHistoryChartMenuView._totalCardHeightForTesting(
+            modeSubtitlePresence: [false, false, false],
+            hasTotal: false)
+        #expect(oneRow < threeRows)
+
+        let withoutTotal = CostHistoryChartMenuView._totalCardHeightForTesting(
+            modeSubtitlePresence: [false],
+            hasTotal: false)
+        let withTotal = CostHistoryChartMenuView._totalCardHeightForTesting(
+            modeSubtitlePresence: [false],
+            hasTotal: true)
+        #expect(withTotal > withoutTotal)
+    }
+}
diff --git a/Tests/CodexBarTests/CostUsageCacheTests.swift b/Tests/CodexBarTests/CostUsageCacheTests.swift
new file mode 100644
index 0000000000..b7252a246d
--- /dev/null
+++ b/Tests/CodexBarTests/CostUsageCacheTests.swift
@@ -0,0 +1,159 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct CostUsageCacheTests {
+    @Test
+    func `cache file URL uses provider artifact versions`() {
+        let root = URL(fileURLWithPath: "/tmp/codexbar-cost-cache", isDirectory: true)
+
+        let codexURL = CostUsageCacheIO.cacheFileURL(provider: .codex, cacheRoot: root)
+        let claudeURL = CostUsageCacheIO.cacheFileURL(provider: .claude, cacheRoot: root)
+        let vertexURL = CostUsageCacheIO.cacheFileURL(provider: .vertexai, cacheRoot: root)
+
+        #expect(codexURL.lastPathComponent == "codex-v8.json")
+        #expect(claudeURL.lastPathComponent == "claude-v4.json")
+        #expect(vertexURL.lastPathComponent == "vertexai-v4.json")
+    }
+
+    @Test
+    func `cache load requires matching producer key`() throws {
+        let root = try self.makeTemporaryCacheRoot()
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        var cache = CostUsageCache()
+        cache.lastScanUnixMs = 123
+        cache.days = ["2026-05-18": ["gpt-5.5": [1, 2, 3]]]
+
+        CostUsageCacheIO.save(
+            provider: .codex,
+            cache: cache,
+            cacheRoot: root,
+            producerKey: "codex:cu:p1111111111111111")
+
+        let loaded = CostUsageCacheIO.load(
+            provider: .codex,
+            cacheRoot: root,
+            producerKey: "codex:cu:p1111111111111111")
+        #expect(loaded.producerKey == "codex:cu:p1111111111111111")
+        #expect(loaded.lastScanUnixMs == 123)
+        #expect(loaded.days["2026-05-18"]?["gpt-5.5"] == [1, 2, 3])
+
+        let stale = CostUsageCacheIO.load(
+            provider: .codex,
+            cacheRoot: root,
+            producerKey: "codex:cu:p2222222222222222")
+        #expect(stale.lastScanUnixMs == 0)
+        #expect(stale.files.isEmpty)
+        #expect(stale.days.isEmpty)
+    }
+
+    @Test
+    func `legacy cache without producer key is ignored`() throws {
+        let root = try self.makeTemporaryCacheRoot()
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let url = CostUsageCacheIO.cacheFileURL(provider: .codex, cacheRoot: root)
+        try FileManager.default.createDirectory(
+            at: url.deletingLastPathComponent(),
+            withIntermediateDirectories: true)
+        let legacy = """
+        {
+          "version": 1,
+          "lastScanUnixMs": 999,
+          "files": {},
+          "days": {
+            "2026-05-18": {
+              "gpt-5": [1, 0, 0]
+            }
+          }
+        }
+        """
+        try legacy.write(to: url, atomically: false, encoding: .utf8)
+
+        let loaded = CostUsageCacheIO.load(
+            provider: .codex,
+            cacheRoot: root,
+            producerKey: "codex:cu:p1111111111111111")
+
+        #expect(loaded.lastScanUnixMs == 0)
+        #expect(loaded.days.isEmpty)
+    }
+
+    @Test
+    func `current codex cache accepts parser compatible 0_33 producer`() throws {
+        let root = try self.makeTemporaryCacheRoot()
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        var cache = CostUsageCache()
+        cache.lastScanUnixMs = 123
+        cache.days = ["2026-05-18": ["gpt-5.5": [1, 2, 3]]]
+        CostUsageCacheIO.save(
+            provider: .codex,
+            cache: cache,
+            cacheRoot: root,
+            producerKey: "codex:cu:p3c27f997569eb3c5")
+
+        let loaded = CostUsageCacheIO.load(provider: .codex, cacheRoot: root)
+
+        #expect(loaded.lastScanUnixMs == 123)
+        #expect(loaded.days["2026-05-18"]?["gpt-5.5"] == [1, 2, 3])
+    }
+
+    @Test
+    func `non codex cache does not require producer key`() throws {
+        let root = try self.makeTemporaryCacheRoot()
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let url = CostUsageCacheIO.cacheFileURL(provider: .claude, cacheRoot: root)
+        try FileManager.default.createDirectory(
+            at: url.deletingLastPathComponent(),
+            withIntermediateDirectories: true)
+        let legacy = """
+        {
+          "version": 1,
+          "lastScanUnixMs": 999,
+          "files": {},
+          "days": {
+            "2026-05-18": {
+              "claude-sonnet-4-5": [1, 0, 0]
+            }
+          }
+        }
+        """
+        try legacy.write(to: url, atomically: false, encoding: .utf8)
+
+        let loaded = CostUsageCacheIO.load(provider: .claude, cacheRoot: root)
+
+        #expect(loaded.lastScanUnixMs == 999)
+        #expect(loaded.days["2026-05-18"]?["claude-sonnet-4-5"] == [1, 0, 0])
+    }
+
+    @Test
+    func `current producer key uses generated parser hash for codex only`() {
+        let codexKey = CostUsageCacheIO.currentProducerKey(
+            provider: .codex,
+            parserHash: "abc1234567890def")
+        let standaloneKey = CostUsageCacheIO.currentProducerKey(
+            provider: .claude,
+            parserHash: "abc1234567890def")
+
+        #expect(codexKey == "codex:cu:pabc1234567890def")
+        #expect(standaloneKey == nil)
+    }
+
+    @Test
+    func `generated parser hash is stable short lowercase hex`() {
+        let hash = CodexParserHash.value
+
+        #expect(hash.range(of: #"^[0-9a-f]{16}$"#, options: .regularExpression) != nil)
+        #expect(CostUsageCacheIO.currentProducerKey(provider: .codex) == "codex:cu:p\(hash)")
+    }
+
+    private func makeTemporaryCacheRoot() throws -> URL {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-cost-cache-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
+        return root
+    }
+}
diff --git a/Tests/CodexBarTests/CostUsageCancellationTests.swift b/Tests/CodexBarTests/CostUsageCancellationTests.swift
new file mode 100644
index 0000000000..246603dbca
--- /dev/null
+++ b/Tests/CodexBarTests/CostUsageCancellationTests.swift
@@ -0,0 +1,147 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct CostUsageCancellationTests {
+    @Test
+    func `fetcher honors cancellation before token scan`() async throws {
+        let gate = AsyncCancellationGate()
+        let task = Task {
+            await gate.wait()
+            _ = try await CostUsageFetcher.loadTokenSnapshot(
+                provider: .codex,
+                scannerOptions: CostUsageScanner.Options())
+        }
+        await gate.waitUntilBlocked()
+        task.cancel()
+        await gate.open()
+
+        await #expect(throws: CancellationError.self) {
+            _ = try await task.value
+        }
+    }
+
+    @Test
+    func `codex scanner cancellation preserves existing cache`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 1, day: 2)
+        let iso = env.isoString(for: day)
+        let fileURL = try env.writeCodexSessionFile(
+            day: day,
+            filename: "session.jsonl",
+            contents: self.codexSessionContents(iso: iso, tokenLineCount: 1))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 0
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+        #expect(report.data.count == 1)
+
+        let cacheURL = CostUsageCacheIO.cacheFileURL(provider: .codex, cacheRoot: env.cacheRoot)
+        let cacheBefore = try Data(contentsOf: cacheURL)
+
+        try self.codexSessionContents(iso: iso, tokenLineCount: 20000)
+            .write(to: fileURL, atomically: true, encoding: .utf8)
+
+        var checks = 0
+        let checkCancellation: CostUsageScanner.CancellationCheck = {
+            checks += 1
+            if checks >= 8 {
+                throw CancellationError()
+            }
+        }
+
+        #expect(throws: CancellationError.self) {
+            _ = try CostUsageScanner.loadDailyReportCancellable(
+                provider: .codex,
+                since: day,
+                until: day,
+                now: day,
+                options: options,
+                checkCancellation: checkCancellation)
+        }
+        #expect(checks >= 8)
+        #expect(try Data(contentsOf: cacheURL) == cacheBefore)
+    }
+
+    @Test
+    func `codex metadata pre scan honors cancellation`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 1, day: 2)
+        let iso = env.isoString(for: day)
+        let fileURL = try env.writeCodexSessionFile(
+            day: day,
+            filename: "session-without-metadata.jsonl",
+            contents: Array(repeating: self.codexTokenLine(iso: iso), count: 20000).joined(separator: "\n") + "\n")
+
+        var checks = 0
+        let checkCancellation: CostUsageScanner.CancellationCheck = {
+            checks += 1
+            if checks >= 3 {
+                throw CancellationError()
+            }
+        }
+
+        #expect(throws: CancellationError.self) {
+            _ = try CostUsageScanner.parseCodexFileCancellable(
+                fileURL: fileURL,
+                range: CostUsageScanner.CostUsageDayRange(since: day, until: day),
+                checkCancellation: checkCancellation)
+        }
+        #expect(checks >= 3)
+    }
+
+    private func codexSessionContents(iso: String, tokenLineCount: Int) -> String {
+        let session = #"{"type":"session_meta","payload":{"session_id":"session-1"}}"#
+        let context = #"{"type":"turn_context","timestamp":"\#(iso)","payload":{"model":"gpt-5"}}"#
+        return ([session, context] + Array(repeating: self.codexTokenLine(iso: iso), count: tokenLineCount))
+            .joined(separator: "\n") + "\n"
+    }
+
+    private func codexTokenLine(iso: String) -> String {
+        #"{"type":"event_msg","timestamp":"\#(iso)","payload":{"#
+            + #""type":"token_count","info":{"last_token_usage":{"#
+            + #""input_tokens":10,"cached_input_tokens":2,"output_tokens":4}}}}"#
+    }
+}
+
+private actor AsyncCancellationGate {
+    private var blockedContinuation: CheckedContinuation<Void, Never>?
+    private var openContinuation: CheckedContinuation<Void, Never>?
+    private var isBlocked = false
+    private var isOpen = false
+
+    func wait() async {
+        self.isBlocked = true
+        self.blockedContinuation?.resume()
+        self.blockedContinuation = nil
+        if self.isOpen { return }
+        await withCheckedContinuation { continuation in
+            self.openContinuation = continuation
+        }
+    }
+
+    func waitUntilBlocked() async {
+        if self.isBlocked { return }
+        await withCheckedContinuation { continuation in
+            self.blockedContinuation = continuation
+        }
+    }
+
+    func open() {
+        self.isOpen = true
+        self.openContinuation?.resume()
+        self.openContinuation = nil
+    }
+}
diff --git a/Tests/CodexBarTests/CostUsageDailyReportMergeTests.swift b/Tests/CodexBarTests/CostUsageDailyReportMergeTests.swift
new file mode 100644
index 0000000000..e7a42293c9
--- /dev/null
+++ b/Tests/CodexBarTests/CostUsageDailyReportMergeTests.swift
@@ -0,0 +1,166 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct CostUsageDailyReportMergeTests {
+    @Test
+    func `merged report sums overlapping day totals and model breakdowns`() {
+        let native = CostUsageDailyReport(
+            data: [
+                CostUsageDailyReport.Entry(
+                    date: "2026-04-04",
+                    inputTokens: 100,
+                    outputTokens: 20,
+                    cacheReadTokens: 10,
+                    cacheCreationTokens: nil,
+                    totalTokens: 130,
+                    costUSD: 1.25,
+                    modelsUsed: ["gpt-5.4"],
+                    modelBreakdowns: [
+                        CostUsageDailyReport.ModelBreakdown(
+                            modelName: "gpt-5.4",
+                            costUSD: 1.25,
+                            totalTokens: 130,
+                            standardCostUSD: 0.75,
+                            priorityCostUSD: 0.50,
+                            standardTokens: 80,
+                            priorityTokens: 50),
+                    ]),
+            ],
+            summary: CostUsageDailyReport.Summary(
+                totalInputTokens: 100,
+                totalOutputTokens: 20,
+                cacheReadTokens: 10,
+                cacheCreationTokens: nil,
+                totalTokens: 130,
+                totalCostUSD: 1.25))
+        let pi = CostUsageDailyReport(
+            data: [
+                CostUsageDailyReport.Entry(
+                    date: "2026-04-04",
+                    inputTokens: 50,
+                    outputTokens: 10,
+                    cacheReadTokens: 5,
+                    cacheCreationTokens: 2,
+                    totalTokens: 67,
+                    costUSD: 0.75,
+                    modelsUsed: ["gpt-5.4"],
+                    modelBreakdowns: [
+                        CostUsageDailyReport.ModelBreakdown(
+                            modelName: "gpt-5.4",
+                            costUSD: 0.75,
+                            totalTokens: 67,
+                            standardCostUSD: 0.25,
+                            priorityCostUSD: 0.50,
+                            standardTokens: 20,
+                            priorityTokens: 47),
+                    ]),
+            ],
+            summary: CostUsageDailyReport.Summary(
+                totalInputTokens: 50,
+                totalOutputTokens: 10,
+                cacheReadTokens: 5,
+                cacheCreationTokens: 2,
+                totalTokens: 67,
+                totalCostUSD: 0.75))
+
+        let merged = native.merged(with: pi)
+        #expect(merged.data.count == 1)
+        #expect(merged.data.first?.inputTokens == 150)
+        #expect(merged.data.first?.outputTokens == 30)
+        #expect(merged.data.first?.cacheReadTokens == 15)
+        #expect(merged.data.first?.cacheCreationTokens == 2)
+        #expect(merged.data.first?.totalTokens == 197)
+        #expect(abs((merged.data.first?.costUSD ?? 0) - 2.0) < 0.000001)
+        #expect(merged.data.first?.modelBreakdowns == [
+            CostUsageDailyReport.ModelBreakdown(
+                modelName: "gpt-5.4",
+                costUSD: 2.0,
+                totalTokens: 197,
+                standardCostUSD: 1.0,
+                priorityCostUSD: 1.0,
+                standardTokens: 100,
+                priorityTokens: 97),
+        ])
+        #expect(merged.summary?.totalTokens == 197)
+        #expect(abs((merged.summary?.totalCostUSD ?? 0) - 2.0) < 0.000001)
+    }
+
+    @Test
+    func `merged report unions days and orders model breakdowns deterministically`() {
+        let first = CostUsageDailyReport(
+            data: [
+                CostUsageDailyReport.Entry(
+                    date: "2026-04-04",
+                    inputTokens: nil,
+                    outputTokens: nil,
+                    cacheReadTokens: nil,
+                    cacheCreationTokens: nil,
+                    totalTokens: 30,
+                    costUSD: 0.30,
+                    modelsUsed: ["gpt-5.3-codex"],
+                    modelBreakdowns: [
+                        CostUsageDailyReport.ModelBreakdown(modelName: "gpt-5.3-codex", costUSD: 0.30, totalTokens: 30),
+                    ]),
+            ],
+            summary: nil)
+        let second = CostUsageDailyReport(
+            data: [
+                CostUsageDailyReport.Entry(
+                    date: "2026-04-05",
+                    inputTokens: nil,
+                    outputTokens: nil,
+                    cacheReadTokens: nil,
+                    cacheCreationTokens: nil,
+                    totalTokens: 40,
+                    costUSD: 0.40,
+                    modelsUsed: ["gpt-5.4", "gpt-5.3-codex"],
+                    modelBreakdowns: [
+                        CostUsageDailyReport.ModelBreakdown(modelName: "gpt-5.4", costUSD: 0.40, totalTokens: 40),
+                        CostUsageDailyReport.ModelBreakdown(modelName: "gpt-5.3-codex", costUSD: 0.00, totalTokens: 0),
+                    ]),
+            ],
+            summary: nil)
+
+        let merged = CostUsageDailyReport.merged([first, second])
+        #expect(merged.data.map(\.date) == ["2026-04-04", "2026-04-05"])
+        #expect(merged.data.last?.modelBreakdowns?.map(\.modelName) == ["gpt-5.4", "gpt-5.3-codex"])
+        #expect(merged.summary?.totalTokens == 70)
+        #expect(abs((merged.summary?.totalCostUSD ?? 0) - 0.70) < 0.000001)
+    }
+
+    @Test
+    func `merged report includes derived totals when another same day entry has explicit total`() {
+        let explicit = CostUsageDailyReport(
+            data: [
+                CostUsageDailyReport.Entry(
+                    date: "2026-04-04",
+                    inputTokens: 70,
+                    outputTokens: 30,
+                    totalTokens: 100,
+                    costUSD: 1.0,
+                    modelsUsed: ["gpt-5.4"],
+                    modelBreakdowns: nil),
+            ],
+            summary: nil)
+        let derived = CostUsageDailyReport(
+            data: [
+                CostUsageDailyReport.Entry(
+                    date: "2026-04-04",
+                    inputTokens: 10,
+                    outputTokens: 5,
+                    cacheReadTokens: 3,
+                    cacheCreationTokens: 2,
+                    totalTokens: nil,
+                    costUSD: 0.25,
+                    modelsUsed: ["gpt-5.3-codex"],
+                    modelBreakdowns: nil),
+            ],
+            summary: nil)
+
+        let merged = CostUsageDailyReport.merged([explicit, derived])
+        #expect(merged.data.first?.totalTokens == 120)
+        #expect(merged.summary?.totalTokens == 120)
+        #expect(abs((merged.data.first?.costUSD ?? 0) - 1.25) < 0.000001)
+    }
+}
diff --git a/Tests/CodexBarTests/CostUsageDecodingTests.swift b/Tests/CodexBarTests/CostUsageDecodingTests.swift
index 178b9e0706..33eb9df2c1 100644
--- a/Tests/CodexBarTests/CostUsageDecodingTests.swift
+++ b/Tests/CodexBarTests/CostUsageDecodingTests.swift
@@ -2,10 +2,9 @@ import Foundation
 import Testing
 @testable import CodexBarCore
 
-@Suite
 struct CostUsageDecodingTests {
     @Test
-    func decodesDailyReportTypeFormat() throws {
+    func `decodes daily report type format`() throws {
         let json = """
         {
           "type": "daily",
@@ -44,7 +43,7 @@ struct CostUsageDecodingTests {
     }
 
     @Test
-    func decodesDailyReportLegacyFormat() throws {
+    func `decodes daily report legacy format`() throws {
         let json = """
         {
           "daily": [
@@ -80,7 +79,7 @@ struct CostUsageDecodingTests {
     }
 
     @Test
-    func decodesLegacyCacheTokenKeys() throws {
+    func `decodes legacy cache token keys`() throws {
         let json = """
         {
           "type": "daily",
@@ -108,7 +107,7 @@ struct CostUsageDecodingTests {
     }
 
     @Test
-    func decodesDailyReportLegacyFormatWithModelMap() throws {
+    func `decodes daily report legacy format with model map`() throws {
         let json = """
         {
           "daily": [
@@ -119,7 +118,7 @@ struct CostUsageDecodingTests {
               "totalTokens": 30,
               "costUSD": 0.12,
               "models": {
-                "gpt-5.2": {
+                "gpt-5.2-codex": {
                   "inputTokens": 10,
                   "outputTokens": 20,
                   "totalTokens": 30,
@@ -138,11 +137,11 @@ struct CostUsageDecodingTests {
         let report = try JSONDecoder().decode(CostUsageDailyReport.self, from: Data(json.utf8))
         #expect(report.data.count == 1)
         #expect(report.data[0].costUSD == 0.12)
-        #expect(report.data[0].modelsUsed == ["gpt-5.2"])
+        #expect(report.data[0].modelsUsed == ["gpt-5.2-codex"])
     }
 
     @Test
-    func decodesDailyReportLegacyFormatWithModelMapSorted() throws {
+    func `decodes daily report legacy format with model map sorted`() throws {
         let json = """
         {
           "daily": [
@@ -165,7 +164,7 @@ struct CostUsageDecodingTests {
     }
 
     @Test
-    func decodesDailyReportLegacyFormatWithEmptyModelMapAsNil() throws {
+    func `decodes daily report legacy format with empty model map as nil`() throws {
         let json = """
         {
           "daily": [
@@ -184,7 +183,7 @@ struct CostUsageDecodingTests {
     }
 
     @Test
-    func decodesDailyReportLegacyFormatPrefersModelsUsedListOverModelsMap() throws {
+    func `decodes daily report legacy format prefers models used list over models map`() throws {
         let json = """
         {
           "daily": [
@@ -192,7 +191,7 @@ struct CostUsageDecodingTests {
               "date": "Dec 20, 2025",
               "totalTokens": 30,
               "costUSD": 0.12,
-              "modelsUsed": ["gpt-5.2"],
+              "modelsUsed": ["gpt-5.2-codex"],
               "models": {
                 "ignored-model": { "totalTokens": 30 }
               }
@@ -202,11 +201,11 @@ struct CostUsageDecodingTests {
         """
 
         let report = try JSONDecoder().decode(CostUsageDailyReport.self, from: Data(json.utf8))
-        #expect(report.data[0].modelsUsed == ["gpt-5.2"])
+        #expect(report.data[0].modelsUsed == ["gpt-5.2-codex"])
     }
 
     @Test
-    func decodesDailyReportLegacyFormatWithModelsList() throws {
+    func `decodes daily report legacy format with models list`() throws {
         let json = """
         {
           "daily": [
@@ -214,18 +213,46 @@ struct CostUsageDecodingTests {
               "date": "Dec 20, 2025",
               "totalTokens": 30,
               "costUSD": 0.12,
-              "models": ["gpt-5.2", "gpt-5.2-mini"]
+              "models": ["gpt-5.2-codex", "gpt-5.2-mini"]
             }
           ]
         }
         """
 
         let report = try JSONDecoder().decode(CostUsageDailyReport.self, from: Data(json.utf8))
-        #expect(report.data[0].modelsUsed == ["gpt-5.2", "gpt-5.2-mini"])
+        #expect(report.data[0].modelsUsed == ["gpt-5.2-codex", "gpt-5.2-mini"])
     }
 
     @Test
-    func decodesDailyReportLegacyFormatWithInvalidModelsField() throws {
+    func `decodes model breakdown total tokens`() throws {
+        let json = """
+        {
+          "type": "daily",
+          "data": [
+            {
+              "date": "2025-12-20",
+              "totalTokens": 30,
+              "costUSD": 0.12,
+              "modelBreakdowns": [
+                {
+                  "modelName": "gpt-5.2-codex",
+                  "costUSD": 0.12,
+                  "totalTokens": 30
+                }
+              ]
+            }
+          ]
+        }
+        """
+
+        let report = try JSONDecoder().decode(CostUsageDailyReport.self, from: Data(json.utf8))
+        #expect(report.data[0].modelBreakdowns == [
+            CostUsageDailyReport.ModelBreakdown(modelName: "gpt-5.2-codex", costUSD: 0.12, totalTokens: 30),
+        ])
+    }
+
+    @Test
+    func `decodes daily report legacy format with invalid models field`() throws {
         let json = """
         {
           "daily": [
@@ -244,7 +271,7 @@ struct CostUsageDecodingTests {
     }
 
     @Test
-    func decodesMonthlyReportLegacyFormat() throws {
+    func `decodes monthly report legacy format`() throws {
         let json = """
         {
           "monthly": [
@@ -269,7 +296,7 @@ struct CostUsageDecodingTests {
     }
 
     @Test
-    func selectsMostRecentSession() throws {
+    func `selects most recent session`() throws {
         let json = """
         {
           "type": "session",
@@ -305,7 +332,56 @@ struct CostUsageDecodingTests {
     }
 
     @Test
-    func tokenSnapshotSelectsMostRecentDay() throws {
+    func `selects most recent supported month format`() throws {
+        let json = """
+        {
+          "type": "monthly",
+          "data": [
+            { "month": "Dec 2025", "totalTokens": 100, "costUSD": 1.00 },
+            { "month": "January 2026", "totalTokens": 200, "costUSD": 2.00 },
+            { "month": "2026-02", "totalTokens": 300, "costUSD": 3.00 }
+          ]
+        }
+        """
+
+        let report = try JSONDecoder().decode(CostUsageMonthlyReport.self, from: Data(json.utf8))
+        let selected = CostUsageFetcher.selectMostRecentMonth(from: report.data)
+        #expect(selected?.month == "2026-02")
+        #expect(selected?.totalTokens == 300)
+    }
+
+    @Test
+    func `date parsers handle concurrent mixed formats`() async {
+        let dateInputs = [
+            "2026-02-03T04:05:06.789Z",
+            "2026-02-03T04:05:06Z",
+            "2026-02-03",
+            "Feb 3, 2026",
+        ]
+        let monthInputs = ["Feb 2026", "February 2026", "2026-02"]
+
+        await withTaskGroup(of: Bool.self) { group in
+            for _ in 0..<32 {
+                group.addTask {
+                    for _ in 0..<250 {
+                        guard dateInputs.allSatisfy({ CostUsageDateParser.parse($0) != nil }),
+                              monthInputs.allSatisfy({ CostUsageDateParser.parseMonth($0) != nil })
+                        else {
+                            return false
+                        }
+                    }
+                    return true
+                }
+            }
+
+            for await succeeded in group {
+                #expect(succeeded)
+            }
+        }
+    }
+
+    @Test
+    func `token snapshot selects most recent day`() throws {
         let json = """
         {
           "type": "daily",
@@ -338,7 +414,34 @@ struct CostUsageDecodingTests {
     }
 
     @Test
-    func tokenSnapshotUsesSummaryTotalCostWhenAvailable() throws {
+    func `token snapshot rejects impossible later calendar day`() throws {
+        let json = """
+        {
+          "type": "daily",
+          "data": [
+            {
+              "date": "2026-05-13",
+              "totalTokens": 30,
+              "costUSD": 23.45
+            },
+            {
+              "date": "2026-06-31",
+              "totalTokens": 40,
+              "costUSD": 99.00
+            }
+          ]
+        }
+        """
+
+        let report = try JSONDecoder().decode(CostUsageDailyReport.self, from: Data(json.utf8))
+        let snapshot = CostUsageFetcher.tokenSnapshot(from: report, now: Date())
+
+        #expect(snapshot.sessionTokens == 30)
+        #expect(snapshot.sessionCostUSD == 23.45)
+    }
+
+    @Test
+    func `token snapshot uses summary total cost when available`() throws {
         let json = """
         {
           "type": "daily",
@@ -358,7 +461,7 @@ struct CostUsageDecodingTests {
     }
 
     @Test
-    func tokenSnapshotFallsBackToSummedEntriesWhenSummaryMissing() throws {
+    func `token snapshot falls back to summed entries when summary missing`() throws {
         let json = """
         {
           "type": "daily",
@@ -375,7 +478,7 @@ struct CostUsageDecodingTests {
     }
 
     @Test
-    func tokenSnapshotReturnsNilTotalWhenNoCostsPresent() throws {
+    func `token snapshot returns nil total when no costs present`() throws {
         let json = """
         {
           "type": "daily",
diff --git a/Tests/CodexBarTests/CostUsageFetcherCacheSnapshotTests.swift b/Tests/CodexBarTests/CostUsageFetcherCacheSnapshotTests.swift
new file mode 100644
index 0000000000..df7761a316
--- /dev/null
+++ b/Tests/CodexBarTests/CostUsageFetcherCacheSnapshotTests.swift
@@ -0,0 +1,286 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct CostUsageFetcherCacheSnapshotTests {
+    @Test
+    func `cached codex token snapshot loads from existing cache without rescanning`() async throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 4, day: 8)
+        try Self.writeCodexSessionFile(
+            homeRoot: env.codexHomeRoot,
+            env: env,
+            day: day,
+            filename: "cached.jsonl",
+            tokens: 42)
+
+        let options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            cacheRoot: env.cacheRoot)
+        _ = try await CostUsageFetcher.loadTokenSnapshot(
+            provider: .codex,
+            now: day,
+            historyDays: 1,
+            scannerOptions: options)
+
+        let cached = await CostUsageFetcher.loadCachedCodexTokenSnapshot(
+            now: day,
+            historyDays: 1,
+            scannerOptions: options)
+
+        #expect(cached?.sessionTokens == 42)
+        #expect(cached?.last30DaysTokens == 42)
+        #expect(cached?.daily.map(\.date) == ["2026-04-08"])
+    }
+
+    @Test
+    func `cached codex token snapshot refuses expanded or managed scopes`() async throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 4, day: 8)
+        try Self.writeCodexSessionFile(
+            homeRoot: env.codexHomeRoot,
+            env: env,
+            day: day,
+            filename: "cached.jsonl",
+            tokens: 42)
+
+        let options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            cacheRoot: env.cacheRoot)
+        _ = try await CostUsageFetcher.loadTokenSnapshot(
+            provider: .codex,
+            now: day,
+            historyDays: 1,
+            scannerOptions: options)
+
+        let expanded = await CostUsageFetcher.loadCachedCodexTokenSnapshot(
+            now: day,
+            historyDays: 7,
+            scannerOptions: options)
+        let managed = await CostUsageFetcher.loadCachedCodexTokenSnapshot(
+            now: day,
+            codexHomePath: env.codexHomeRoot.path,
+            historyDays: 1,
+            scannerOptions: options)
+
+        #expect(expanded == nil)
+        #expect(managed == nil)
+    }
+
+    @Test
+    func `cached codex token snapshot refuses mismatched roots fingerprint`() async throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 4, day: 8)
+        try Self.writeCodexSessionFile(
+            homeRoot: env.codexHomeRoot,
+            env: env,
+            day: day,
+            filename: "cached.jsonl",
+            tokens: 42)
+
+        let options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            cacheRoot: env.cacheRoot)
+        _ = try await CostUsageFetcher.loadTokenSnapshot(
+            provider: .codex,
+            now: day,
+            historyDays: 1,
+            scannerOptions: options)
+
+        var cache = CostUsageCacheIO.load(provider: .codex, cacheRoot: env.cacheRoot)
+        cache.roots = [env.root.appendingPathComponent("other/sessions", isDirectory: true).path: 0]
+        CostUsageCacheIO.save(provider: .codex, cache: cache, cacheRoot: env.cacheRoot)
+
+        let cached = await CostUsageFetcher.loadCachedCodexTokenSnapshot(
+            now: day,
+            historyDays: 1,
+            scannerOptions: options)
+
+        #expect(cached == nil)
+    }
+
+    @Test
+    func `cached codex token snapshot merges cached pi sessions`() async throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 4, day: 8)
+        try Self.writeCodexSessionFile(
+            homeRoot: env.codexHomeRoot,
+            env: env,
+            day: day,
+            filename: "cached.jsonl",
+            tokens: 42)
+        try Self.writePiCodexSessionFile(env: env, day: day, tokens: 165)
+
+        let options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            cacheRoot: env.cacheRoot)
+        let piOptions = PiSessionCostScanner.Options(
+            piSessionsRoot: env.piSessionsRoot,
+            cacheRoot: env.cacheRoot,
+            refreshMinIntervalSeconds: 0)
+        _ = try await CostUsageFetcher.loadTokenSnapshot(
+            provider: .codex,
+            now: day,
+            historyDays: 1,
+            refreshPricingInBackground: false,
+            scannerOptions: options,
+            piScannerOptions: piOptions)
+
+        let cached = await CostUsageFetcher.loadCachedCodexTokenSnapshot(
+            now: day,
+            historyDays: 1,
+            scannerOptions: options)
+
+        #expect(cached?.sessionTokens == 207)
+        #expect(cached?.last30DaysTokens == 207)
+    }
+
+    @Test
+    func `cached codex token snapshot loads cached pi sessions without native codex cache`() async throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 4, day: 8)
+        try Self.writePiCodexSessionFile(env: env, day: day, tokens: 165)
+
+        let piOptions = PiSessionCostScanner.Options(
+            piSessionsRoot: env.piSessionsRoot,
+            cacheRoot: env.cacheRoot,
+            refreshMinIntervalSeconds: 0)
+        _ = PiSessionCostScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: piOptions)
+
+        let cached = await CostUsageFetcher.loadCachedCodexTokenSnapshot(
+            now: day,
+            historyDays: 1,
+            scannerOptions: CostUsageScanner.Options(
+                codexSessionsRoot: env.codexSessionsRoot,
+                cacheRoot: env.cacheRoot))
+
+        #expect(cached?.sessionTokens == 165)
+        #expect(cached?.last30DaysTokens == 165)
+    }
+
+    @Test
+    func `cached codex token snapshot still loads pi sessions when native cache roots mismatch`() async throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 4, day: 8)
+        try Self.writeCodexSessionFile(
+            homeRoot: env.codexHomeRoot,
+            env: env,
+            day: day,
+            filename: "cached.jsonl",
+            tokens: 42)
+        try Self.writePiCodexSessionFile(env: env, day: day, tokens: 165)
+
+        let options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            cacheRoot: env.cacheRoot)
+        let piOptions = PiSessionCostScanner.Options(
+            piSessionsRoot: env.piSessionsRoot,
+            cacheRoot: env.cacheRoot,
+            refreshMinIntervalSeconds: 0)
+        _ = try await CostUsageFetcher.loadTokenSnapshot(
+            provider: .codex,
+            now: day,
+            historyDays: 1,
+            refreshPricingInBackground: false,
+            scannerOptions: options,
+            piScannerOptions: piOptions)
+
+        var cache = CostUsageCacheIO.load(provider: .codex, cacheRoot: env.cacheRoot)
+        cache.roots = [env.root.appendingPathComponent("other/sessions", isDirectory: true).path: 0]
+        CostUsageCacheIO.save(provider: .codex, cache: cache, cacheRoot: env.cacheRoot)
+
+        let cached = await CostUsageFetcher.loadCachedCodexTokenSnapshot(
+            now: day,
+            historyDays: 1,
+            scannerOptions: options)
+
+        #expect(cached?.sessionTokens == 165)
+        #expect(cached?.last30DaysTokens == 165)
+    }
+
+    private static func writeCodexSessionFile(
+        homeRoot: URL,
+        env: CostUsageTestEnvironment,
+        day: Date,
+        filename: String,
+        tokens: Int) throws
+    {
+        let comps = Calendar.current.dateComponents([.year, .month, .day], from: day)
+        let dir = homeRoot
+            .appendingPathComponent("sessions", isDirectory: true)
+            .appendingPathComponent(String(format: "%04d", comps.year ?? 1970), isDirectory: true)
+            .appendingPathComponent(String(format: "%02d", comps.month ?? 1), isDirectory: true)
+            .appendingPathComponent(String(format: "%02d", comps.day ?? 1), isDirectory: true)
+        try FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+
+        let model = "openai/gpt-5.4"
+        let url = dir.appendingPathComponent(filename, isDirectory: false)
+        try env.jsonl([
+            [
+                "type": "turn_context",
+                "timestamp": env.isoString(for: day),
+                "payload": ["model": model],
+            ],
+            [
+                "type": "event_msg",
+                "timestamp": env.isoString(for: day.addingTimeInterval(1)),
+                "payload": [
+                    "type": "token_count",
+                    "info": [
+                        "last_token_usage": [
+                            "input_tokens": tokens,
+                            "cached_input_tokens": 0,
+                            "output_tokens": 0,
+                        ],
+                        "model": model,
+                    ],
+                ],
+            ],
+        ]).write(to: url, atomically: true, encoding: .utf8)
+    }
+
+    private static func writePiCodexSessionFile(
+        env: CostUsageTestEnvironment,
+        day: Date,
+        tokens: Int) throws
+    {
+        _ = try env.writePiSessionFile(
+            relativePath: "nested/run-0/2026-04-08T10-00-00-000Z_test.jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "message",
+                    "timestamp": env.isoString(for: day),
+                    "message": [
+                        "role": "assistant",
+                        "provider": "openai-codex",
+                        "model": "openai/gpt-5.4",
+                        "timestamp": Int(day.timeIntervalSince1970 * 1000),
+                        "usage": [
+                            "input": tokens,
+                            "output": 0,
+                            "cacheRead": 0,
+                            "cacheWrite": 0,
+                            "totalTokens": tokens,
+                        ],
+                    ],
+                ],
+            ]))
+    }
+}
diff --git a/Tests/CodexBarTests/CostUsageFetcherTests.swift b/Tests/CodexBarTests/CostUsageFetcherTests.swift
new file mode 100644
index 0000000000..d58c63a378
--- /dev/null
+++ b/Tests/CodexBarTests/CostUsageFetcherTests.swift
@@ -0,0 +1,867 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct CostUsageFetcherTests {
+    @Test
+    func `fetcher scopes codex history to selected codex home`() async throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 4, day: 8)
+        let otherHome = env.root.appendingPathComponent("other-codex-home", isDirectory: true)
+        try Self.writeCodexSessionFile(
+            homeRoot: env.codexHomeRoot,
+            env: env,
+            day: day,
+            filename: "ambient.jsonl",
+            tokens: 100)
+        try Self.writeCodexSessionFile(homeRoot: otherHome, env: env, day: day, filename: "managed.jsonl", tokens: 10)
+
+        let options = CostUsageScanner.Options(cacheRoot: env.cacheRoot)
+        let ambient = try await CostUsageFetcher.loadTokenSnapshot(
+            provider: .codex,
+            now: day,
+            codexHomePath: env.codexHomeRoot.path,
+            scannerOptions: options)
+        let managed = try await CostUsageFetcher.loadTokenSnapshot(
+            provider: .codex,
+            now: day,
+            codexHomePath: otherHome.path,
+            scannerOptions: options)
+
+        #expect(ambient.sessionTokens == 100)
+        #expect(managed.sessionTokens == 10)
+    }
+
+    @Test
+    func `fetcher refreshes codex cache when legacy roots metadata is missing`() async throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 4, day: 8)
+        let managedHome = env.root.appendingPathComponent("managed-codex-home", isDirectory: true)
+        try Self.writeCodexSessionFile(
+            homeRoot: env.codexHomeRoot,
+            env: env,
+            day: day,
+            filename: "ambient.jsonl",
+            tokens: 100)
+        try Self.writeCodexSessionFile(homeRoot: managedHome, env: env, day: day, filename: "managed.jsonl", tokens: 10)
+
+        let options = CostUsageScanner.Options(cacheRoot: env.cacheRoot)
+        let piOptions = PiSessionCostScanner.Options(piSessionsRoot: env.piSessionsRoot, cacheRoot: env.cacheRoot)
+        let ambient = try await CostUsageFetcher.loadTokenSnapshot(
+            provider: .codex,
+            now: day,
+            codexHomePath: env.codexHomeRoot.path,
+            scannerOptions: options,
+            piScannerOptions: piOptions)
+        #expect(ambient.sessionTokens == 100)
+
+        var cache = CostUsageCacheIO.load(provider: .codex, cacheRoot: env.cacheRoot)
+        cache.roots = nil
+        CostUsageCacheIO.save(provider: .codex, cache: cache, cacheRoot: env.cacheRoot)
+
+        let managed = try await CostUsageFetcher.loadTokenSnapshot(
+            provider: .codex,
+            now: day.addingTimeInterval(1),
+            codexHomePath: managedHome.path,
+            scannerOptions: options,
+            piScannerOptions: piOptions)
+
+        #expect(managed.sessionTokens == 10)
+    }
+
+    @Test
+    func `fetcher refreshes codex cache when history window expands`() async throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let oldDay = try env.makeLocalNoon(year: 2026, month: 4, day: 2)
+        let newDay = try env.makeLocalNoon(year: 2026, month: 4, day: 8)
+        try Self.writeCodexSessionFile(
+            homeRoot: env.codexHomeRoot,
+            env: env,
+            day: oldDay,
+            filename: "old.jsonl",
+            tokens: 15)
+        try Self.writeCodexSessionFile(
+            homeRoot: env.codexHomeRoot,
+            env: env,
+            day: newDay,
+            filename: "new.jsonl",
+            tokens: 30)
+
+        var options = CostUsageScanner.Options(cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 3600
+
+        let narrow = try await CostUsageFetcher.loadTokenSnapshot(
+            provider: .codex,
+            now: newDay,
+            codexHomePath: env.codexHomeRoot.path,
+            historyDays: 1,
+            scannerOptions: options)
+        #expect(narrow.daily.map(\.date) == ["2026-04-08"])
+        #expect(narrow.last30DaysTokens == 30)
+
+        var legacyCache = CostUsageCacheIO.load(provider: .codex, cacheRoot: env.cacheRoot)
+        legacyCache.scanSinceKey = nil
+        legacyCache.scanUntilKey = nil
+        CostUsageCacheIO.save(provider: .codex, cache: legacyCache, cacheRoot: env.cacheRoot)
+
+        let expanded = try await CostUsageFetcher.loadTokenSnapshot(
+            provider: .codex,
+            now: newDay.addingTimeInterval(1),
+            codexHomePath: env.codexHomeRoot.path,
+            historyDays: 7,
+            scannerOptions: options)
+        #expect(expanded.daily.map(\.date) == ["2026-04-02", "2026-04-08"])
+        #expect(expanded.last30DaysTokens == 45)
+    }
+
+    @Test
+    func `fetcher resolves fork parent outside requested codex window`() async throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let parentDay = try env.makeLocalNoon(year: 2026, month: 4, day: 2)
+        let childDay = try env.makeLocalNoon(year: 2026, month: 4, day: 8)
+        let model = "openai/gpt-5.4"
+        let parentID = "parent-session"
+        let parentTimestamp = env.isoString(for: parentDay.addingTimeInterval(1))
+        let childTimestamp = env.isoString(for: childDay.addingTimeInterval(1))
+        _ = try env.writeCodexSessionFile(
+            day: parentDay,
+            filename: "parent.jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "session_meta",
+                    "timestamp": env.isoString(for: parentDay),
+                    "payload": ["session_id": parentID],
+                ],
+                [
+                    "type": "event_msg",
+                    "timestamp": parentTimestamp,
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "model": model,
+                            "total_token_usage": [
+                                "input_tokens": 100,
+                                "cached_input_tokens": 0,
+                                "output_tokens": 0,
+                            ],
+                        ],
+                    ],
+                ],
+            ]))
+        _ = try env.writeCodexSessionFile(
+            day: childDay,
+            filename: "child.jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "session_meta",
+                    "timestamp": env.isoString(for: childDay),
+                    "payload": [
+                        "session_id": "child-session",
+                        "forked_from_id": parentID,
+                        "timestamp": parentTimestamp,
+                    ],
+                ],
+                [
+                    "type": "event_msg",
+                    "timestamp": childTimestamp,
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "model": model,
+                            "total_token_usage": [
+                                "input_tokens": 125,
+                                "cached_input_tokens": 0,
+                                "output_tokens": 5,
+                            ],
+                        ],
+                    ],
+                ],
+            ]))
+
+        let options = CostUsageScanner.Options(cacheRoot: env.cacheRoot)
+        let snapshot = try await CostUsageFetcher.loadTokenSnapshot(
+            provider: .codex,
+            now: childDay,
+            codexHomePath: env.codexHomeRoot.path,
+            historyDays: 1,
+            scannerOptions: options)
+
+        #expect(snapshot.daily.map(\.date) == ["2026-04-08"])
+        #expect(snapshot.last30DaysTokens == 30)
+    }
+
+    @Test
+    func `force refresh only scans requested codex date window`() async throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let oldDay = try env.makeLocalNoon(year: 2026, month: 3, day: 1)
+        let newDay = try env.makeLocalNoon(year: 2026, month: 4, day: 8)
+        let oldURL = try env.writeCodexSessionFile(
+            day: oldDay,
+            filename: "old.jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "event_msg",
+                    "timestamp": env.isoString(for: oldDay),
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "model": "openai/gpt-5.4",
+                            "last_token_usage": [
+                                "input_tokens": 10,
+                                "cached_input_tokens": 0,
+                                "output_tokens": 0,
+                            ],
+                        ],
+                    ],
+                ],
+            ]))
+        try FileManager.default.setAttributes([.modificationDate: oldDay], ofItemAtPath: oldURL.path)
+        _ = try env.writeCodexSessionFile(
+            day: newDay,
+            filename: "new.jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "event_msg",
+                    "timestamp": env.isoString(for: newDay),
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "model": "openai/gpt-5.4",
+                            "last_token_usage": [
+                                "input_tokens": 30,
+                                "cached_input_tokens": 0,
+                                "output_tokens": 0,
+                            ],
+                        ],
+                    ],
+                ],
+            ]))
+
+        let options = CostUsageScanner.Options(
+            cacheRoot: env.cacheRoot,
+            codexTraceDatabaseURL: env.root.appendingPathComponent("missing-traces.sqlite"))
+        let snapshot = try await CostUsageFetcher.loadTokenSnapshot(
+            provider: .codex,
+            now: newDay,
+            forceRefresh: true,
+            codexHomePath: env.codexHomeRoot.path,
+            historyDays: 1,
+            scannerOptions: options)
+        let cache = CostUsageCacheIO.load(provider: .codex, cacheRoot: env.cacheRoot)
+        let cacheFileExists = FileManager.default.fileExists(
+            atPath: CostUsageCacheIO.cacheFileURL(provider: .codex, cacheRoot: env.cacheRoot).path)
+
+        #expect(snapshot.daily.map(\.date) == ["2026-04-08"])
+        #expect(snapshot.last30DaysTokens == 30)
+        #expect(cacheFileExists)
+        #expect(cache.files.keys.sorted().map(URL.init(fileURLWithPath:)).map(\.lastPathComponent) == ["new.jsonl"])
+    }
+
+    @Test
+    func `narrow codex refresh preserves wider cache window`() async throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let oldDay = try env.makeLocalNoon(year: 2026, month: 4, day: 2)
+        let newDay = try env.makeLocalNoon(year: 2026, month: 4, day: 8)
+        _ = try env.writeCodexSessionFile(
+            day: oldDay,
+            filename: "old.jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "event_msg",
+                    "timestamp": env.isoString(for: oldDay),
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "model": "openai/gpt-5.4",
+                            "last_token_usage": [
+                                "input_tokens": 15,
+                                "cached_input_tokens": 0,
+                                "output_tokens": 0,
+                            ],
+                        ],
+                    ],
+                ],
+            ]))
+        _ = try env.writeCodexSessionFile(
+            day: newDay,
+            filename: "new.jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "event_msg",
+                    "timestamp": env.isoString(for: newDay),
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "model": "openai/gpt-5.4",
+                            "last_token_usage": [
+                                "input_tokens": 30,
+                                "cached_input_tokens": 0,
+                                "output_tokens": 0,
+                            ],
+                        ],
+                    ],
+                ],
+            ]))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            cacheRoot: env.cacheRoot,
+            codexTraceDatabaseURL: env.root.appendingPathComponent("missing-traces.sqlite"))
+        options.refreshMinIntervalSeconds = 0
+        _ = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: newDay,
+            until: newDay,
+            now: newDay,
+            options: options)
+        let wide = try await CostUsageFetcher.loadTokenSnapshot(
+            provider: .codex,
+            now: newDay.addingTimeInterval(1),
+            codexHomePath: env.codexHomeRoot.path,
+            historyDays: 7,
+            refreshPricingInBackground: false,
+            scannerOptions: options)
+        let narrow = try await CostUsageFetcher.loadTokenSnapshot(
+            provider: .codex,
+            now: newDay.addingTimeInterval(2),
+            codexHomePath: env.codexHomeRoot.path,
+            historyDays: 1,
+            refreshPricingInBackground: false,
+            scannerOptions: options)
+        let cache = CostUsageCacheIO.load(provider: .codex, cacheRoot: env.cacheRoot)
+
+        #expect(wide.last30DaysTokens == 45)
+        #expect(narrow.last30DaysTokens == 30)
+        #expect(cache.files.keys.map(URL.init(fileURLWithPath:)).map(\.lastPathComponent).sorted() == [
+            "new.jsonl",
+            "old.jsonl",
+        ])
+        #expect(cache.scanSinceKey == "2026-04-01")
+        #expect(cache.scanUntilKey == "2026-04-09")
+    }
+
+    @Test
+    func `force codex rescan narrows cache window to refreshed range`() async throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let oldDay = try env.makeLocalNoon(year: 2026, month: 4, day: 2)
+        let newDay = try env.makeLocalNoon(year: 2026, month: 4, day: 8)
+        _ = try env.writeCodexSessionFile(
+            day: oldDay,
+            filename: "old.jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "event_msg",
+                    "timestamp": env.isoString(for: oldDay),
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "model": "openai/gpt-5.4",
+                            "last_token_usage": [
+                                "input_tokens": 15,
+                                "cached_input_tokens": 0,
+                                "output_tokens": 0,
+                            ],
+                        ],
+                    ],
+                ],
+            ]))
+        _ = try env.writeCodexSessionFile(
+            day: newDay,
+            filename: "new.jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "event_msg",
+                    "timestamp": env.isoString(for: newDay),
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "model": "openai/gpt-5.4",
+                            "last_token_usage": [
+                                "input_tokens": 30,
+                                "cached_input_tokens": 0,
+                                "output_tokens": 0,
+                            ],
+                        ],
+                    ],
+                ],
+            ]))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            cacheRoot: env.cacheRoot,
+            codexTraceDatabaseURL: env.root.appendingPathComponent("missing-traces.sqlite"))
+        options.refreshMinIntervalSeconds = 0
+        _ = try await CostUsageFetcher.loadTokenSnapshot(
+            provider: .codex,
+            now: newDay,
+            codexHomePath: env.codexHomeRoot.path,
+            historyDays: 7,
+            refreshPricingInBackground: false,
+            scannerOptions: options)
+
+        var rescanOptions = options
+        rescanOptions.forceRescan = true
+        _ = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: newDay,
+            until: newDay,
+            now: newDay.addingTimeInterval(1),
+            options: rescanOptions)
+        let cache = CostUsageCacheIO.load(provider: .codex, cacheRoot: env.cacheRoot)
+
+        #expect(cache.files.keys.map(URL.init(fileURLWithPath:)).map(\.lastPathComponent).sorted() == ["new.jsonl"])
+        #expect(cache.scanSinceKey == "2026-04-07")
+        #expect(cache.scanUntilKey == "2026-04-09")
+    }
+
+    @Test
+    func `codex refresh drops stale cache entry when session moves to archive`() async throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 4, day: 8)
+        let contents = try env.jsonl([
+            [
+                "type": "session_meta",
+                "timestamp": env.isoString(for: day),
+                "payload": ["session_id": "moved-session"],
+            ],
+            [
+                "type": "event_msg",
+                "timestamp": env.isoString(for: day.addingTimeInterval(1)),
+                "payload": [
+                    "type": "token_count",
+                    "info": [
+                        "model": "openai/gpt-5.4",
+                        "last_token_usage": [
+                            "input_tokens": 30,
+                            "cached_input_tokens": 0,
+                            "output_tokens": 0,
+                        ],
+                    ],
+                ],
+            ],
+        ])
+        let originalURL = try env.writeCodexSessionFile(day: day, filename: "moved.jsonl", contents: contents)
+
+        var options = CostUsageScanner.Options(cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 0
+        let first = try await CostUsageFetcher.loadTokenSnapshot(
+            provider: .codex,
+            now: day,
+            codexHomePath: env.codexHomeRoot.path,
+            historyDays: 1,
+            scannerOptions: options)
+
+        let archivedURL = env.codexArchivedSessionsRoot.appendingPathComponent("moved.jsonl", isDirectory: false)
+        try FileManager.default.moveItem(at: originalURL, to: archivedURL)
+
+        let second = try await CostUsageFetcher.loadTokenSnapshot(
+            provider: .codex,
+            now: day.addingTimeInterval(1),
+            codexHomePath: env.codexHomeRoot.path,
+            historyDays: 1,
+            scannerOptions: options)
+        let cache = CostUsageCacheIO.load(provider: .codex, cacheRoot: env.cacheRoot)
+
+        #expect(first.last30DaysTokens == 30)
+        #expect(second.last30DaysTokens == 30)
+        #expect(cache.files.count == 1)
+        #expect(cache.files.keys.first.map { URL(fileURLWithPath: $0).resolvingSymlinksInPath().path } ==
+            archivedURL.resolvingSymlinksInPath().path)
+    }
+
+    @Test
+    func `fetcher merges native and pi codex history with normalized model names`() async throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 4, day: 8)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+
+        let nativeTurnContext: [String: Any] = [
+            "type": "turn_context",
+            "timestamp": iso0,
+            "payload": [
+                "model": "openai/gpt-5.4",
+            ],
+        ]
+        let nativeTokenCount: [String: Any] = [
+            "type": "event_msg",
+            "timestamp": iso1,
+            "payload": [
+                "type": "token_count",
+                "info": [
+                    "total_token_usage": [
+                        "input_tokens": 100,
+                        "cached_input_tokens": 20,
+                        "output_tokens": 10,
+                    ],
+                    "model": "openai/gpt-5.4",
+                ],
+            ],
+        ]
+        _ = try env.writeCodexSessionFile(
+            day: day,
+            filename: "session.jsonl",
+            contents: env.jsonl([nativeTurnContext, nativeTokenCount]))
+
+        let piAssistant: [String: Any] = [
+            "type": "message",
+            "timestamp": iso1,
+            "message": [
+                "role": "assistant",
+                "provider": "openai-codex",
+                "model": "openai/gpt-5.4",
+                "timestamp": Int(day.timeIntervalSince1970 * 1000),
+                "usage": [
+                    "input": 50,
+                    "cacheRead": 5,
+                    "output": 5,
+                    "totalTokens": 60,
+                ],
+            ],
+        ]
+        _ = try env.writePiSessionFile(
+            relativePath: "2026-04-08T10-00-00-000Z_test.jsonl",
+            contents: env.jsonl([piAssistant]))
+
+        let nativeOptions = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: [env.claudeProjectsRoot],
+            cacheRoot: env.cacheRoot)
+        let piOptions = PiSessionCostScanner.Options(
+            piSessionsRoot: env.piSessionsRoot,
+            cacheRoot: env.cacheRoot,
+            refreshMinIntervalSeconds: 0)
+
+        let snapshot = try await CostUsageFetcher.loadTokenSnapshot(
+            provider: .codex,
+            now: day,
+            scannerOptions: nativeOptions,
+            piScannerOptions: piOptions)
+
+        let nativeCost = CostUsagePricing.codexCostUSD(
+            model: "gpt-5.4",
+            inputTokens: 100,
+            cachedInputTokens: 20,
+            outputTokens: 10) ?? 0
+        let piCost = CostUsagePricing.codexCostUSD(
+            model: "gpt-5.4",
+            inputTokens: 55,
+            cachedInputTokens: 5,
+            outputTokens: 5) ?? 0
+
+        #expect(snapshot.daily.count == 1)
+        #expect(snapshot.daily.first?.date == "2026-04-08")
+        #expect(snapshot.daily.first?.totalTokens == 170)
+        #expect(abs((snapshot.daily.first?.costUSD ?? 0) - (nativeCost + piCost)) < 0.000001)
+        #expect(snapshot.daily.first?.modelBreakdowns == [
+            CostUsageDailyReport.ModelBreakdown(
+                modelName: "gpt-5.4",
+                costUSD: nativeCost + piCost,
+                totalTokens: 170),
+        ])
+    }
+
+    @Test
+    func `fetcher merges native and pi claude history and ignores unsupported pi providers`() async throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 4, day: 9)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+
+        let nativeAssistant: [String: Any] = [
+            "type": "assistant",
+            "timestamp": iso0,
+            "message": [
+                "model": "anthropic.foo.claude-sonnet-4-6-v1:0",
+                "usage": [
+                    "input_tokens": 100,
+                    "cache_creation_input_tokens": 10,
+                    "cache_read_input_tokens": 5,
+                    "output_tokens": 20,
+                ],
+            ],
+        ]
+        _ = try env.writeClaudeProjectFile(
+            relativePath: "project-a/session.jsonl",
+            contents: env.jsonl([nativeAssistant]))
+
+        let supportedPiAssistant: [String: Any] = [
+            "type": "message",
+            "timestamp": iso1,
+            "message": [
+                "role": "assistant",
+                "provider": "anthropic",
+                "model": "claude-sonnet-4-6",
+                "timestamp": Int(day.addingTimeInterval(60).timeIntervalSince1970 * 1000),
+                "usage": [
+                    "input": 50,
+                    "cacheRead": 4,
+                    "cacheWrite": 6,
+                    "output": 10,
+                    "totalTokens": 70,
+                ],
+            ],
+        ]
+        let unsupportedPiAssistant: [String: Any] = [
+            "type": "message",
+            "timestamp": iso1,
+            "message": [
+                "role": "assistant",
+                "provider": "openrouter",
+                "model": "claude-sonnet-4-6",
+                "timestamp": Int(day.addingTimeInterval(120).timeIntervalSince1970 * 1000),
+                "usage": [
+                    "input": 999,
+                    "output": 1,
+                    "totalTokens": 1000,
+                ],
+            ],
+        ]
+        _ = try env.writePiSessionFile(
+            relativePath: "2026-04-09T10-00-00-000Z_test.jsonl",
+            contents: env.jsonl([supportedPiAssistant, unsupportedPiAssistant]))
+
+        let nativeOptions = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: [env.claudeProjectsRoot],
+            cacheRoot: env.cacheRoot)
+        let piOptions = PiSessionCostScanner.Options(
+            piSessionsRoot: env.piSessionsRoot,
+            cacheRoot: env.cacheRoot,
+            refreshMinIntervalSeconds: 0)
+
+        let snapshot = try await CostUsageFetcher.loadTokenSnapshot(
+            provider: .claude,
+            now: day,
+            scannerOptions: nativeOptions,
+            piScannerOptions: piOptions)
+
+        let nativeCost = CostUsagePricing.claudeCostUSD(
+            model: "claude-sonnet-4-6",
+            inputTokens: 100,
+            cacheReadInputTokens: 5,
+            cacheCreationInputTokens: 10,
+            outputTokens: 20) ?? 0
+        let piCost = CostUsagePricing.claudeCostUSD(
+            model: "claude-sonnet-4-6",
+            inputTokens: 50,
+            cacheReadInputTokens: 4,
+            cacheCreationInputTokens: 6,
+            outputTokens: 10) ?? 0
+
+        #expect(snapshot.daily.count == 1)
+        #expect(snapshot.daily.first?.date == "2026-04-09")
+        #expect(snapshot.daily.first?.totalTokens == 205)
+        #expect(abs((snapshot.daily.first?.costUSD ?? 0) - (nativeCost + piCost)) < 0.000001)
+        #expect(snapshot.daily.first?.modelBreakdowns == [
+            CostUsageDailyReport.ModelBreakdown(
+                modelName: "claude-sonnet-4-6",
+                costUSD: nativeCost + piCost,
+                totalTokens: 205),
+        ])
+    }
+
+    @Test
+    func `fetcher prefers turn context model over token count fallback`() async throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 4, day: 10)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+
+        let nativeTurnContext: [String: Any] = [
+            "type": "turn_context",
+            "timestamp": iso0,
+            "payload": [
+                "model": "openai/gpt-5.4",
+            ],
+        ]
+        let nativeTokenCount: [String: Any] = [
+            "type": "event_msg",
+            "timestamp": iso1,
+            "payload": [
+                "type": "token_count",
+                "info": [
+                    "model": "gpt-5",
+                    "total_token_usage": [
+                        "input_tokens": 100,
+                        "cached_input_tokens": 20,
+                        "output_tokens": 10,
+                    ],
+                ],
+            ],
+        ]
+        _ = try env.writeCodexSessionFile(
+            day: day,
+            filename: "session.jsonl",
+            contents: env.jsonl([nativeTurnContext, nativeTokenCount]))
+
+        let nativeOptions = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: [env.claudeProjectsRoot],
+            cacheRoot: env.cacheRoot)
+        let piOptions = PiSessionCostScanner.Options(
+            piSessionsRoot: env.piSessionsRoot,
+            cacheRoot: env.cacheRoot,
+            refreshMinIntervalSeconds: 0)
+
+        let snapshot = try await CostUsageFetcher.loadTokenSnapshot(
+            provider: .codex,
+            now: day,
+            scannerOptions: nativeOptions,
+            piScannerOptions: piOptions)
+        let cost = CostUsagePricing.codexCostUSD(
+            model: "gpt-5.4",
+            inputTokens: 100,
+            cachedInputTokens: 20,
+            outputTokens: 10) ?? 0
+
+        #expect(snapshot.daily.first?.modelBreakdowns == [
+            CostUsageDailyReport.ModelBreakdown(
+                modelName: "gpt-5.4",
+                costUSD: cost,
+                totalTokens: 110),
+        ])
+    }
+
+    @Test
+    func `force refresh keeps incremental cost cache`() async throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 4, day: 11)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let iso2 = env.isoString(for: day.addingTimeInterval(2))
+        let model = "openai/gpt-5.4"
+
+        let turnContext: [String: Any] = [
+            "type": "turn_context",
+            "timestamp": iso0,
+            "payload": ["model": model],
+        ]
+        let firstTokenCount: [String: Any] = [
+            "type": "event_msg",
+            "timestamp": iso1,
+            "payload": [
+                "type": "token_count",
+                "info": [
+                    "model": model,
+                    "total_token_usage": [
+                        "input_tokens": 100,
+                        "cached_input_tokens": 20,
+                        "output_tokens": 10,
+                    ],
+                ],
+            ],
+        ]
+        let fileURL = try env.writeCodexSessionFile(
+            day: day,
+            filename: "session.jsonl",
+            contents: env.jsonl([turnContext, firstTokenCount]))
+
+        let nativeOptions = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: [env.claudeProjectsRoot],
+            cacheRoot: env.cacheRoot)
+        let piOptions = PiSessionCostScanner.Options(
+            piSessionsRoot: env.piSessionsRoot,
+            cacheRoot: env.cacheRoot)
+
+        let first = try await CostUsageFetcher.loadTokenSnapshot(
+            provider: .codex,
+            now: day,
+            scannerOptions: nativeOptions,
+            piScannerOptions: piOptions)
+        #expect(first.daily.first?.totalTokens == 110)
+
+        let appendedTokenCount: [String: Any] = [
+            "type": "event_msg",
+            "timestamp": iso2,
+            "payload": [
+                "type": "token_count",
+                "info": [
+                    "model": model,
+                    "total_token_usage": [
+                        "input_tokens": 160,
+                        "cached_input_tokens": 40,
+                        "output_tokens": 16,
+                    ],
+                ],
+            ],
+        ]
+        try env.jsonl([turnContext, firstTokenCount, appendedTokenCount])
+            .write(to: fileURL, atomically: true, encoding: .utf8)
+
+        let refreshed = try await CostUsageFetcher.loadTokenSnapshot(
+            provider: .codex,
+            now: day,
+            forceRefresh: true,
+            scannerOptions: nativeOptions,
+            piScannerOptions: piOptions)
+
+        #expect(refreshed.daily.first?.totalTokens == 176)
+    }
+
+    private static func writeCodexSessionFile(
+        homeRoot: URL,
+        env: CostUsageTestEnvironment,
+        day: Date,
+        filename: String,
+        tokens: Int) throws
+    {
+        let comps = Calendar.current.dateComponents([.year, .month, .day], from: day)
+        let dir = homeRoot
+            .appendingPathComponent("sessions", isDirectory: true)
+            .appendingPathComponent(String(format: "%04d", comps.year ?? 1970), isDirectory: true)
+            .appendingPathComponent(String(format: "%02d", comps.month ?? 1), isDirectory: true)
+            .appendingPathComponent(String(format: "%02d", comps.day ?? 1), isDirectory: true)
+        try FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+
+        let model = "openai/gpt-5.4"
+        let url = dir.appendingPathComponent(filename, isDirectory: false)
+        try env.jsonl([
+            [
+                "type": "turn_context",
+                "timestamp": env.isoString(for: day),
+                "payload": ["model": model],
+            ],
+            [
+                "type": "event_msg",
+                "timestamp": env.isoString(for: day.addingTimeInterval(1)),
+                "payload": [
+                    "type": "token_count",
+                    "info": [
+                        "last_token_usage": [
+                            "input_tokens": tokens,
+                            "cached_input_tokens": 0,
+                            "output_tokens": 0,
+                        ],
+                        "model": model,
+                    ],
+                ],
+            ],
+        ]).write(to: url, atomically: true, encoding: .utf8)
+    }
+}
diff --git a/Tests/CodexBarTests/CostUsageJsonlPerformanceTests.swift b/Tests/CodexBarTests/CostUsageJsonlPerformanceTests.swift
index 7e08ae0fe8..70c3c14f0e 100644
--- a/Tests/CodexBarTests/CostUsageJsonlPerformanceTests.swift
+++ b/Tests/CodexBarTests/CostUsageJsonlPerformanceTests.swift
@@ -5,7 +5,7 @@ import Testing
 @Suite(.serialized)
 struct CostUsageJsonlPerformanceTests {
     @Test
-    func scannerBenchmarkBeatsFrontBufferBaseline() throws {
+    func `scanner benchmark beats front buffer baseline`() throws {
         let root = FileManager.default.temporaryDirectory.appendingPathComponent(
             "codexbar-cost-usage-bench-\(UUID().uuidString)",
             isDirectory: true)
@@ -62,7 +62,10 @@ struct CostUsageJsonlPerformanceTests {
             scanner: scanWithFrontBufferBaseline)
 
         let speedup = Double(baselineFastest) / Double(currentFastest)
-        #expect(speedup >= 5.0)
+        print(
+            "Cost usage JSONL scanner benchmark: current=\(currentFastest)ns " +
+                "baseline=\(baselineFastest)ns speedup=\(String(format: "%.2f", speedup))x")
+        #expect(currentFastest < baselineFastest)
     }
 }
 
diff --git a/Tests/CodexBarTests/CostUsageJsonlScannerTests.swift b/Tests/CodexBarTests/CostUsageJsonlScannerTests.swift
new file mode 100644
index 0000000000..0bf27a4cfa
--- /dev/null
+++ b/Tests/CodexBarTests/CostUsageJsonlScannerTests.swift
@@ -0,0 +1,68 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct CostUsageJsonlScannerTests {
+    @Test
+    func `jsonl scanner handles lines across read chunks`() throws {
+        let root = try self.makeTemporaryRoot()
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let fileURL = root.appendingPathComponent("large-lines.jsonl", isDirectory: false)
+        let largeLine = String(repeating: "x", count: 300_000)
+        let contents = "\(largeLine)\nsmall\n"
+        try contents.write(to: fileURL, atomically: true, encoding: .utf8)
+
+        var scanned: [(count: Int, truncated: Bool)] = []
+        let endOffset = try CostUsageJsonl.scan(
+            fileURL: fileURL,
+            maxLineBytes: 400_000,
+            prefixBytes: 400_000)
+        { line in
+            scanned.append((line.bytes.count, line.wasTruncated))
+        }
+
+        #expect(endOffset == Int64(Data(contents.utf8).count))
+        #expect(scanned.count == 2)
+        #expect(scanned[0].count == 300_000)
+        #expect(scanned[0].truncated == false)
+        #expect(scanned[1].count == 5)
+        #expect(scanned[1].truncated == false)
+    }
+
+    @Test
+    func `jsonl scanner retains prefix for truncated lines`() throws {
+        let root = try self.makeTemporaryRoot()
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let fileURL = root.appendingPathComponent("truncated-lines.jsonl", isDirectory: false)
+        let shortLine = "ok"
+        let longLine = String(repeating: "a", count: 2000)
+        let contents = "\(shortLine)\n\(longLine)\n"
+        try contents.write(to: fileURL, atomically: true, encoding: .utf8)
+
+        var scanned: [CostUsageJsonl.Line] = []
+        _ = try CostUsageJsonl.scan(
+            fileURL: fileURL,
+            maxLineBytes: 10000,
+            prefixBytes: 64)
+        { line in
+            scanned.append(line)
+        }
+
+        #expect(scanned.count == 2)
+        #expect(String(data: scanned[0].bytes, encoding: .utf8) == "ok")
+        #expect(scanned[0].wasTruncated == false)
+        #expect(scanned[1].bytes.count == 64)
+        #expect(String(data: scanned[1].bytes, encoding: .utf8) == String(repeating: "a", count: 64))
+        #expect(scanned[1].wasTruncated == true)
+    }
+
+    private func makeTemporaryRoot() throws -> URL {
+        let root = FileManager.default.temporaryDirectory.appendingPathComponent(
+            "codexbar-cost-usage-jsonl-\(UUID().uuidString)",
+            isDirectory: true)
+        try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
+        return root
+    }
+}
diff --git a/Tests/CodexBarTests/CostUsageJsonlShapeBenchmarkTests.swift b/Tests/CodexBarTests/CostUsageJsonlShapeBenchmarkTests.swift
new file mode 100644
index 0000000000..b8d302436f
--- /dev/null
+++ b/Tests/CodexBarTests/CostUsageJsonlShapeBenchmarkTests.swift
@@ -0,0 +1,407 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct CostUsageJsonlShapeBenchmarkTests {
+    @Test
+    func `scanner benchmark covers codex session history shape`() throws {
+        let root = FileManager.default.temporaryDirectory.appendingPathComponent(
+            "codexbar-cost-jsonl-shape-\(UUID().uuidString)",
+            isDirectory: true)
+        try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let divisor = Self.shapeDivisor()
+        let plan = CodexJsonlShapePlan.localThirtyDaySample.scaled(divisor: divisor)
+        let fileURL = root.appendingPathComponent("codex-shape.jsonl", isDirectory: false)
+        let fixture = try CodexJsonlShapeFixture.write(plan: plan, to: fileURL)
+
+        let maxLineBytes = 256 * 1024
+        let prefixBytes = 32 * 1024
+
+        let currentSummary = try self.summarizeScan(
+            fileURL: fileURL,
+            maxLineBytes: maxLineBytes,
+            prefixBytes: prefixBytes,
+            scanner: CostUsageJsonl.scan)
+        let baselineSummary = try self.summarizeScan(
+            fileURL: fileURL,
+            maxLineBytes: maxLineBytes,
+            prefixBytes: prefixBytes,
+            scanner: self.scanWithFrontBufferBaseline)
+
+        #expect(currentSummary.lineCount == fixture.lineCount)
+        #expect(currentSummary.truncatedCount == fixture.truncatedLineCount)
+        #expect(currentSummary.endOffset == fixture.byteCount)
+        #expect(baselineSummary.lineCount == currentSummary.lineCount)
+        #expect(baselineSummary.truncatedCount == currentSummary.truncatedCount)
+        #expect(baselineSummary.endOffset == currentSummary.endOffset)
+
+        _ = try self.summarizeScan(
+            fileURL: fileURL,
+            maxLineBytes: maxLineBytes,
+            prefixBytes: prefixBytes,
+            scanner: CostUsageJsonl.scan)
+        _ = try self.summarizeScan(
+            fileURL: fileURL,
+            maxLineBytes: maxLineBytes,
+            prefixBytes: prefixBytes,
+            scanner: self.scanWithFrontBufferBaseline)
+
+        let currentFastest = try self.fastestScanDurationNanoseconds(
+            runs: 3,
+            fileURL: fileURL,
+            maxLineBytes: maxLineBytes,
+            prefixBytes: prefixBytes,
+            scanner: CostUsageJsonl.scan)
+        let baselineFastest = try self.fastestScanDurationNanoseconds(
+            runs: 3,
+            fileURL: fileURL,
+            maxLineBytes: maxLineBytes,
+            prefixBytes: prefixBytes,
+            scanner: self.scanWithFrontBufferBaseline)
+
+        let currentMBps = Self.megabytesPerSecond(byteCount: fixture.byteCount, nanoseconds: currentFastest)
+        let baselineMBps = Self.megabytesPerSecond(byteCount: fixture.byteCount, nanoseconds: baselineFastest)
+        let speedup = Double(baselineFastest) / Double(currentFastest)
+        print(
+            "Codex JSONL shape benchmark: divisor=\(divisor) " +
+                "bytes=\(fixture.byteCount) lines=\(fixture.lineCount) " +
+                "truncated=\(fixture.truncatedLineCount) " +
+                "current=\(Self.format(currentMBps))MB/s " +
+                "baseline=\(Self.format(baselineMBps))MB/s " +
+                "speedup=\(Self.format(speedup))x")
+    }
+
+    @Test
+    func `synthetic codex rows preserve model attribution`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 18)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let iso2 = env.isoString(for: day.addingTimeInterval(2))
+        let model = "openai/gpt-5.5"
+        let turnContext: [String: Any] = [
+            "type": "turn_context",
+            "timestamp": iso0,
+            "payload": [
+                "model": model,
+                "instructions": "synthetic",
+            ],
+        ]
+        let firstTokenCount = self.tokenCountWithoutModel(
+            timestamp: iso1,
+            input: 100,
+            cached: 40,
+            output: 10)
+        let secondTokenCount = self.tokenCountWithoutModel(
+            timestamp: iso2,
+            input: 50,
+            cached: 20,
+            output: 5)
+        let fileURL = try env.writeCodexSessionFile(
+            day: day,
+            filename: "synthetic-attribution.jsonl",
+            contents: env.jsonl([turnContext, firstTokenCount, secondTokenCount]))
+
+        let parsed = CostUsageScanner.parseCodexFile(
+            fileURL: fileURL,
+            range: CostUsageScanner.CostUsageDayRange(since: day, until: day))
+        let dayKey = CostUsageScanner.CostUsageDayRange.dayKey(from: day)
+
+        #expect(parsed.days[dayKey]?["gpt-5.5"] == [150, 60, 15])
+        #expect(parsed.days[dayKey]?["gpt-5"] == nil)
+    }
+
+    private static func shapeDivisor() -> Int {
+        let value = ProcessInfo.processInfo.environment["CODEXBAR_COST_JSONL_SHAPE_DIVISOR"] ?? "20"
+        return max(1, Int(value) ?? 20)
+    }
+
+    private static func megabytesPerSecond(byteCount: Int64, nanoseconds: UInt64) -> Double {
+        let seconds = Double(nanoseconds) / 1_000_000_000
+        guard seconds > 0 else { return 0 }
+        return (Double(byteCount) / 1_000_000) / seconds
+    }
+
+    private static func format(_ value: Double) -> String {
+        String(format: "%.1f", value)
+    }
+
+    private func tokenCountWithoutModel(timestamp: String, input: Int, cached: Int, output: Int) -> [String: Any] {
+        [
+            "type": "event_msg",
+            "timestamp": timestamp,
+            "payload": [
+                "type": "token_count",
+                "info": [
+                    "last_token_usage": [
+                        "input_tokens": input,
+                        "cached_input_tokens": cached,
+                        "output_tokens": output,
+                    ],
+                ],
+            ],
+        ]
+    }
+
+    private func summarizeScan(
+        fileURL: URL,
+        maxLineBytes: Int,
+        prefixBytes: Int,
+        scanner: JsonlShapeScanner) throws -> JsonlShapeScanSummary
+    {
+        var lineCount = 0
+        var truncatedCount = 0
+        let endOffset = try scanner(fileURL, 0, maxLineBytes, prefixBytes) { line in
+            lineCount += 1
+            if line.wasTruncated {
+                truncatedCount += 1
+            }
+        }
+
+        return JsonlShapeScanSummary(
+            lineCount: lineCount,
+            truncatedCount: truncatedCount,
+            endOffset: endOffset)
+    }
+
+    private func fastestScanDurationNanoseconds(
+        runs: Int,
+        fileURL: URL,
+        maxLineBytes: Int,
+        prefixBytes: Int,
+        scanner: JsonlShapeScanner) throws -> UInt64
+    {
+        var fastest = UInt64.max
+        for _ in 0..<runs {
+            let startedAt = DispatchTime.now().uptimeNanoseconds
+            _ = try self.summarizeScan(
+                fileURL: fileURL,
+                maxLineBytes: maxLineBytes,
+                prefixBytes: prefixBytes,
+                scanner: scanner)
+            let elapsed = DispatchTime.now().uptimeNanoseconds - startedAt
+            fastest = min(fastest, elapsed)
+        }
+        return fastest
+    }
+
+    @discardableResult
+    private func scanWithFrontBufferBaseline(
+        fileURL: URL,
+        offset: Int64 = 0,
+        maxLineBytes: Int,
+        prefixBytes: Int,
+        onLine: (CostUsageJsonl.Line) -> Void) throws
+        -> Int64
+    {
+        let handle = try FileHandle(forReadingFrom: fileURL)
+        defer { try? handle.close() }
+
+        let startOffset = max(0, offset)
+        if startOffset > 0 {
+            try handle.seek(toOffset: UInt64(startOffset))
+        }
+
+        var buffer = Data()
+        buffer.reserveCapacity(64 * 1024)
+
+        var current = Data()
+        current.reserveCapacity(4 * 1024)
+        var lineBytes = 0
+        var truncated = false
+        var bytesRead: Int64 = 0
+
+        func flushLine() {
+            guard lineBytes > 0 else { return }
+            onLine(.init(bytes: current, wasTruncated: truncated))
+            current.removeAll(keepingCapacity: true)
+            lineBytes = 0
+            truncated = false
+        }
+
+        while true {
+            let chunk = try handle.read(upToCount: 256 * 1024) ?? Data()
+            if chunk.isEmpty {
+                flushLine()
+                break
+            }
+
+            bytesRead += Int64(chunk.count)
+            buffer.append(chunk)
+
+            while true {
+                guard let nl = buffer.firstIndex(of: 0x0A) else { break }
+                let linePart = buffer[..<nl]
+                buffer.removeSubrange(...nl)
+
+                lineBytes += linePart.count
+                if !truncated {
+                    if lineBytes > maxLineBytes || lineBytes > prefixBytes {
+                        truncated = true
+                        current.removeAll(keepingCapacity: true)
+                    } else {
+                        current.append(contentsOf: linePart)
+                    }
+                }
+
+                flushLine()
+            }
+        }
+
+        return startOffset + bytesRead
+    }
+}
+
+private typealias JsonlShapeScanner = (
+    _ fileURL: URL,
+    _ offset: Int64,
+    _ maxLineBytes: Int,
+    _ prefixBytes: Int,
+    _ onLine: (CostUsageJsonl.Line) -> Void) throws -> Int64
+
+private struct JsonlShapeScanSummary: Equatable {
+    let lineCount: Int
+    let truncatedCount: Int
+    let endOffset: Int64
+}
+
+private struct CodexJsonlShapePlan {
+    static let localThirtyDaySample = CodexJsonlShapePlan(
+        totalLines: 145_797,
+        relevantLines: 57063,
+        tokenCountWithoutModelLines: 22235,
+        turnContextLines: 1935,
+        longTurnContextLines: 207,
+        linesOver32KiB: 2584,
+        linesOver256KiB: 697)
+
+    let totalLines: Int
+    let relevantLines: Int
+    let tokenCountWithoutModelLines: Int
+    let turnContextLines: Int
+    let longTurnContextLines: Int
+    let linesOver32KiB: Int
+    let linesOver256KiB: Int
+
+    func scaled(divisor: Int) -> CodexJsonlShapePlan {
+        CodexJsonlShapePlan(
+            totalLines: self.scaled(self.totalLines, divisor: divisor),
+            relevantLines: self.scaled(self.relevantLines, divisor: divisor),
+            tokenCountWithoutModelLines: self.scaled(self.tokenCountWithoutModelLines, divisor: divisor),
+            turnContextLines: self.scaled(self.turnContextLines, divisor: divisor),
+            longTurnContextLines: self.scaled(self.longTurnContextLines, divisor: divisor),
+            linesOver32KiB: self.scaled(self.linesOver32KiB, divisor: divisor),
+            linesOver256KiB: self.scaled(self.linesOver256KiB, divisor: divisor))
+    }
+
+    private func scaled(_ value: Int, divisor: Int) -> Int {
+        max(1, Int((Double(value) / Double(divisor)).rounded()))
+    }
+}
+
+private struct CodexJsonlShapeFixture {
+    let byteCount: Int64
+    let lineCount: Int
+    let truncatedLineCount: Int
+
+    static func write(plan: CodexJsonlShapePlan, to fileURL: URL) throws -> CodexJsonlShapeFixture {
+        FileManager.default.createFile(atPath: fileURL.path, contents: nil)
+        let handle = try FileHandle(forWritingTo: fileURL)
+        defer { try? handle.close() }
+
+        var byteCount: Int64 = 0
+        var lineCount = 0
+
+        func writeLine(_ line: String) throws {
+            let data = Data((line + "\n").utf8)
+            try handle.write(contentsOf: data)
+            byteCount += Int64(data.count)
+            lineCount += 1
+        }
+
+        let longTurnContextCount = min(plan.longTurnContextLines, plan.turnContextLines)
+        let shortTurnContextCount = plan.turnContextLines - longTurnContextCount
+        let largeIrrelevantOver256Count = plan.linesOver256KiB
+        let largeIrrelevantOver32Count = max(
+            0,
+            plan.linesOver32KiB - longTurnContextCount - largeIrrelevantOver256Count)
+        let otherRelevantCount = max(
+            0,
+            plan.relevantLines - plan.tokenCountWithoutModelLines - plan.turnContextLines)
+        let writtenBeforeSmallIrrelevant = plan.tokenCountWithoutModelLines
+            + shortTurnContextCount
+            + longTurnContextCount
+            + otherRelevantCount
+            + largeIrrelevantOver32Count
+            + largeIrrelevantOver256Count
+        let smallIrrelevantCount = max(0, plan.totalLines - writtenBeforeSmallIrrelevant)
+
+        try self.writeRepeated(
+            count: plan.tokenCountWithoutModelLines,
+            line: self.tokenCountWithoutModelLine,
+            writer: writeLine)
+        try self.writeRepeated(
+            count: shortTurnContextCount,
+            line: self.turnContextLine(fillerBytes: 2048),
+            writer: writeLine)
+        try self.writeRepeated(
+            count: longTurnContextCount,
+            line: self.turnContextLine(fillerBytes: 40 * 1024),
+            writer: writeLine)
+        try self.writeRepeated(
+            count: otherRelevantCount,
+            line: self.taskStartedLine,
+            writer: writeLine)
+        try self.writeRepeated(
+            count: largeIrrelevantOver32Count,
+            line: self.irrelevantLine(fillerBytes: 64 * 1024),
+            writer: writeLine)
+        try self.writeRepeated(
+            count: largeIrrelevantOver256Count,
+            line: self.irrelevantLine(fillerBytes: 300 * 1024),
+            writer: writeLine)
+        try self.writeRepeated(
+            count: smallIrrelevantCount,
+            line: self.irrelevantLine(fillerBytes: 512),
+            writer: writeLine)
+
+        return CodexJsonlShapeFixture(
+            byteCount: byteCount,
+            lineCount: lineCount,
+            truncatedLineCount: longTurnContextCount + largeIrrelevantOver32Count + largeIrrelevantOver256Count)
+    }
+
+    private static let tokenCountWithoutModelLine =
+        #"{"type":"event_msg","timestamp":"2026-05-18T00:00:00Z","payload":{"type":"token_count","info":"#
+            + #"{"last_token_usage":{"input_tokens":100,"cached_input_tokens":40,"output_tokens":10}}}}"#
+
+    private static let taskStartedLine =
+        #"{"type":"event_msg","timestamp":"2026-05-18T00:00:00Z","payload":"#
+            + #"{"type":"task_started","turn_id":"turn-0001"}}"#
+
+    private static func turnContextLine(fillerBytes: Int) -> String {
+        #"{"type":"turn_context","timestamp":"2026-05-18T00:00:00Z","payload":"#
+            + #"{"model":"openai/gpt-5.5","instructions":""#
+            + String(repeating: "x", count: fillerBytes)
+            + #""}}"#
+    }
+
+    private static func irrelevantLine(fillerBytes: Int) -> String {
+        #"{"type":"response_item","payload":""# + String(repeating: "x", count: fillerBytes) + #""}"#
+    }
+
+    private static func writeRepeated(
+        count: Int,
+        line: String,
+        writer: (String) throws -> Void) throws
+    {
+        for _ in 0..<count {
+            try writer(line)
+        }
+    }
+}
diff --git a/Tests/CodexBarTests/CostUsagePerformanceGateTests.swift b/Tests/CodexBarTests/CostUsagePerformanceGateTests.swift
new file mode 100644
index 0000000000..387e5bf28d
--- /dev/null
+++ b/Tests/CodexBarTests/CostUsagePerformanceGateTests.swift
@@ -0,0 +1,149 @@
+import Foundation
+#if canImport(SQLite3)
+import SQLite3
+import Testing
+@testable import CodexBarCore
+
+/// Regression gates for the two cost-usage scan-storm classes that have shipped before:
+/// re-parsing unchanged session files on every refresh (#1387, #1392) and re-running the
+/// full trace-database scan on every refresh (#1392, the pre-memo priority-turns path).
+@Suite(.serialized)
+struct CostUsagePerformanceGateTests {
+    @Test
+    func `warm codex refresh over an unchanged session corpus must not re-parse it`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 10)
+        let fileURLs = try Self.writeSyntheticCodexCorpus(env: env, day: day, files: 2, turnsPerFile: 4)
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: nil,
+            cacheRoot: env.cacheRoot,
+            codexTraceDatabaseURL: env.root.appendingPathComponent("missing.sqlite"))
+        options.refreshMinIntervalSeconds = 0
+
+        let cold = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+
+        let changedFile = try #require(fileURLs.first)
+        let originalAttributes = try FileManager.default.attributesOfItem(atPath: changedFile.path)
+        let originalModificationDate = try #require(originalAttributes[.modificationDate] as? Date)
+        let original = try String(contentsOf: changedFile, encoding: .utf8)
+        let modified = original.replacingOccurrences(
+            of: #""input_tokens":100,"#,
+            with: #""input_tokens":900,"#)
+        #expect(modified != original)
+        #expect(modified.utf8.count == original.utf8.count)
+        try modified.write(to: changedFile, atomically: false, encoding: .utf8)
+        try FileManager.default.setAttributes(
+            [.modificationDate: originalModificationDate],
+            ofItemAtPath: changedFile.path)
+
+        let warm = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+
+        #expect(cold.data.count == 1)
+        #expect(warm.data.first?.totalTokens == cold.data.first?.totalTokens)
+    }
+
+    @Test
+    func `priority turns refresh must scan only appended trace rows`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+        let dbURL = env.root.appendingPathComponent("logs_2.sqlite")
+        try CostUsageScannerCodexPriorityTests.createTestLogsDatabase(at: dbURL)
+
+        let epoch: Int64 = 1_760_000_000
+        var rows: [(epochSeconds: Int64, body: String)] = (0..<50).map { index in
+            (epochSeconds: epoch, body: "thread_id=t-\(index) turn.id=u-\(index) routine trace row")
+        }
+        rows.append((
+            epochSeconds: epoch,
+            body: "thread_id=thread-a turn.id=turn-a websocket request: "
+                + #"{"type":"response.create","model":"gpt-5.5","service_tier":"priority"}"#))
+        try CostUsageScannerCodexPriorityTests.insertTestLogs(dbURL: dbURL, rows: rows)
+
+        let full = CostUsageScanner.codexPriorityTurns(databaseURL: dbURL)
+        #expect(full.keys.sorted() == ["turn-a"])
+        let scanned = try #require(CostUsageScanner._test_codexPriorityTurnsMemoState(forPath: dbURL.path))
+
+        try Self.replaceTraceBody(
+            dbURL: dbURL,
+            rowID: 1,
+            body: "thread_id=mutated turn.id=mutated-old websocket request: "
+                + #"{"type":"response.create","model":"gpt-5.5","service_tier":"priority"}"#)
+        try CostUsageScannerCodexPriorityTests.insertTestLogs(dbURL: dbURL, rows: [(
+            epochSeconds: epoch,
+            body: "thread_id=thread-b turn.id=turn-b websocket request: "
+                + #"{"type":"response.create","model":"gpt-5.5","service_tier":"priority"}"#)])
+
+        let refreshed = CostUsageScanner.codexPriorityTurns(databaseURL: dbURL)
+
+        #expect(refreshed.keys.sorted() == ["turn-a", "turn-b"])
+        let advanced = try #require(CostUsageScanner._test_codexPriorityTurnsMemoState(forPath: dbURL.path))
+        #expect(advanced.lastRowID == scanned.lastRowID + 1)
+    }
+
+    private static func writeSyntheticCodexCorpus(
+        env: CostUsageTestEnvironment,
+        day: Date,
+        files: Int,
+        turnsPerFile: Int) throws -> [URL]
+    {
+        let model = "openai/gpt-5.2-codex"
+        let baseISO = env.isoString(for: day)
+        var fileURLs: [URL] = []
+        for fileIndex in 0..<files {
+            var lines: [String] = []
+            lines.reserveCapacity(turnsPerFile + 2)
+            lines.append(
+                #"{"type":"session_meta","timestamp":"\#(baseISO)","payload":{"session_id":"perf-\#(fileIndex)"}}"#)
+            lines.append(
+                #"{"type":"turn_context","timestamp":"\#(baseISO)","payload":{"model":"\#(model)"}}"#)
+            for turn in 1...turnsPerFile {
+                lines.append(
+                    #"{"type":"event_msg","timestamp":"\#(baseISO)","payload":{"type":"token_count","info":"#
+                        + #"{"total_token_usage":{"input_tokens":\#(turn * 100),"cached_input_tokens":\#(turn * 20),"#
+                        + #""output_tokens":\#(turn * 10)},"model":"\#(model)"}}}"#)
+            }
+            let fileURL = try env.writeCodexSessionFile(
+                day: day,
+                filename: "session-\(fileIndex).jsonl",
+                contents: lines.joined(separator: "\n") + "\n")
+            fileURLs.append(fileURL)
+        }
+        return fileURLs
+    }
+
+    private static func replaceTraceBody(dbURL: URL, rowID: Int64, body: String) throws {
+        var db: OpaquePointer?
+        guard sqlite3_open(dbURL.path, &db) == SQLITE_OK else {
+            throw CocoaError(.fileReadUnknown)
+        }
+        defer { sqlite3_close(db) }
+
+        var statement: OpaquePointer?
+        guard sqlite3_prepare_v2(db, "update logs set feedback_log_body = ? where id = ?", -1, &statement, nil)
+            == SQLITE_OK
+        else {
+            throw CocoaError(.fileWriteUnknown)
+        }
+        defer { sqlite3_finalize(statement) }
+
+        sqlite3_bind_text(statement, 1, body, -1, unsafeBitCast(-1, to: sqlite3_destructor_type.self))
+        sqlite3_bind_int64(statement, 2, rowID)
+        guard sqlite3_step(statement) == SQLITE_DONE else {
+            throw CocoaError(.fileWriteUnknown)
+        }
+    }
+}
+#endif
diff --git a/Tests/CodexBarTests/CostUsagePricingTests.swift b/Tests/CodexBarTests/CostUsagePricingTests.swift
index f70e8d555d..b1d5e14b7e 100644
--- a/Tests/CodexBarTests/CostUsagePricingTests.swift
+++ b/Tests/CodexBarTests/CostUsagePricingTests.swift
@@ -1,18 +1,24 @@
+import Foundation
 import Testing
 @testable import CodexBarCore
 
-@Suite
 struct CostUsagePricingTests {
     @Test
-    func normalizesCodexModelVariants() {
-        #expect(CostUsagePricing.normalizeCodexModel("openai/gpt-5-codex") == "gpt-5")
-        #expect(CostUsagePricing.normalizeCodexModel("gpt-5.2-codex") == "gpt-5.2")
-        #expect(CostUsagePricing.normalizeCodexModel("gpt-5.1-codex-max") == "gpt-5.1")
-        #expect(CostUsagePricing.normalizeCodexModel("gpt-5.3-codex-max") == "gpt-5.3")
+    func `normalizes codex model variants exactly`() {
+        #expect(CostUsagePricing.normalizeCodexModel("openai/gpt-5-codex") == "gpt-5-codex")
+        #expect(CostUsagePricing.normalizeCodexModel("gpt-5.2-codex") == "gpt-5.2-codex")
+        #expect(CostUsagePricing.normalizeCodexModel("gpt-5.1-codex-max") == "gpt-5.1-codex-max")
+        #expect(CostUsagePricing.normalizeCodexModel("gpt-5.4-pro-2026-03-05") == "gpt-5.4-pro")
+        #expect(CostUsagePricing.normalizeCodexModel("gpt-5.4-mini-2026-03-17") == "gpt-5.4-mini")
+        #expect(CostUsagePricing.normalizeCodexModel("gpt-5.4-nano-2026-03-17") == "gpt-5.4-nano")
+        #expect(CostUsagePricing.normalizeCodexModel("gpt-5.5-2026-04-23") == "gpt-5.5")
+        #expect(CostUsagePricing.normalizeCodexModel("gpt-5.5-pro-2026-04-23") == "gpt-5.5-pro")
+        #expect(CostUsagePricing.normalizeCodexModel("gpt-5.3-codex-2026-03-05") == "gpt-5.3-codex")
+        #expect(CostUsagePricing.normalizeCodexModel("gpt-5.3-codex-spark") == "gpt-5.3-codex-spark")
     }
 
     @Test
-    func codexCostSupportsGpt51CodexMax() {
+    func `codex cost supports gpt51 codex max`() {
         let cost = CostUsagePricing.codexCostUSD(
             model: "gpt-5.1-codex-max",
             inputTokens: 100,
@@ -22,9 +28,9 @@ struct CostUsagePricingTests {
     }
 
     @Test
-    func codexCostSupportsGpt53CodexMax() {
+    func `codex cost supports gpt53 codex`() {
         let cost = CostUsagePricing.codexCostUSD(
-            model: "gpt-5.3-codex-max",
+            model: "gpt-5.3-codex",
             inputTokens: 100,
             cachedInputTokens: 10,
             outputTokens: 5)
@@ -32,12 +38,296 @@ struct CostUsagePricingTests {
     }
 
     @Test
-    func normalizesClaudeOpus41DatedVariants() {
+    func `codex cost supports gpt54 mini and nano`() {
+        let mini = CostUsagePricing.codexCostUSD(
+            model: "gpt-5.4-mini-2026-03-17",
+            inputTokens: 100,
+            cachedInputTokens: 10,
+            outputTokens: 5)
+        let nano = CostUsagePricing.codexCostUSD(
+            model: "gpt-5.4-nano",
+            inputTokens: 100,
+            cachedInputTokens: 10,
+            outputTokens: 5)
+
+        #expect(mini != nil)
+        #expect(nano != nil)
+    }
+
+    @Test
+    func `codex cost supports gpt55 bundled fallback`() throws {
+        let root = try Self.cacheRoot()
+        let cost = CostUsagePricing.codexCostUSD(
+            model: "openai/gpt-5.5-2026-04-23",
+            inputTokens: 100,
+            cachedInputTokens: 10,
+            outputTokens: 5,
+            modelsDevCacheRoot: root)
+
+        let expected = (90.0 * 5e-6) + (10.0 * 5e-7) + (5.0 * 3e-5)
+        #expect(cost == expected)
+    }
+
+    @Test
+    func `codex cost applies gpt54 and gpt55 long context rates to full session`() throws {
+        let root = try Self.cacheRoot()
+        let gpt54 = CostUsagePricing.codexCostUSD(
+            model: "gpt-5.4",
+            inputTokens: 272_001,
+            cachedInputTokens: 0,
+            outputTokens: 10,
+            modelsDevCacheRoot: root)
+        let gpt55 = CostUsagePricing.codexCostUSD(
+            model: "gpt-5.5",
+            inputTokens: 272_001,
+            cachedInputTokens: 0,
+            outputTokens: 10,
+            modelsDevCacheRoot: root)
+
+        #expect(gpt54 == (272_001.0 * 5e-6) + (10.0 * 2.25e-5))
+        #expect(gpt55 == (272_001.0 * 1e-5) + (10.0 * 4.5e-5))
+    }
+
+    @Test
+    func `codex cost keeps normal rates at long context input boundary`() throws {
+        let root = try Self.cacheRoot()
+        let gpt55 = CostUsagePricing.codexCostUSD(
+            model: "gpt-5.5",
+            inputTokens: 272_000,
+            cachedInputTokens: 0,
+            outputTokens: 128_000,
+            modelsDevCacheRoot: root)
+
+        #expect(gpt55 == (272_000.0 * 5e-6) + (128_000.0 * 3e-5))
+    }
+
+    @Test
+    func `codex cost applies long context rates to all cached and non cached input`() throws {
+        let root = try Self.cacheRoot()
+        let gpt55 = CostUsagePricing.codexCostUSD(
+            model: "gpt-5.5",
+            inputTokens: 300_000,
+            cachedInputTokens: 200_000,
+            outputTokens: 10,
+            modelsDevCacheRoot: root)
+
+        let cached = 200_000.0 * 1e-6
+        let nonCached = 100_000.0 * 1e-5
+        let output = 10.0 * 4.5e-5
+
+        #expect(gpt55 == cached + nonCached + output)
+    }
+
+    @Test
+    func `codex priority cost applies model specific fast rates`() {
+        let gpt54 = CostUsagePricing.codexPriorityCostUSD(
+            model: "gpt-5.4",
+            inputTokens: 100,
+            cachedInputTokens: 20,
+            outputTokens: 10)
+        let gpt55 = CostUsagePricing.codexPriorityCostUSD(
+            model: "gpt-5.5",
+            inputTokens: 100,
+            cachedInputTokens: 20,
+            outputTokens: 10)
+        let gpt54Mini = CostUsagePricing.codexPriorityCostUSD(
+            model: "gpt-5.4-mini",
+            inputTokens: 100,
+            cachedInputTokens: 20,
+            outputTokens: 10)
+
+        #expect(gpt54 == (80.0 * 5e-6) + (20.0 * 5e-7) + (10.0 * 3e-5))
+        #expect(gpt55 == (80.0 * 1.25e-5) + (20.0 * 1.25e-6) + (10.0 * 7.5e-5))
+        #expect(gpt54Mini == (80.0 * 1.5e-6) + (20.0 * 1.5e-7) + (10.0 * 9e-6))
+    }
+
+    @Test
+    func `codex priority cost is unavailable for long context requests`() {
+        let gpt55 = CostUsagePricing.codexPriorityCostUSD(
+            model: "gpt-5.5",
+            inputTokens: 272_001,
+            cachedInputTokens: 0,
+            outputTokens: 10)
+        let gpt54Mini = CostUsagePricing.codexPriorityCostUSD(
+            model: "gpt-5.4-mini",
+            inputTokens: 272_001,
+            cachedInputTokens: 0,
+            outputTokens: 10)
+
+        #expect(gpt55 == nil)
+        #expect(gpt54Mini == nil)
+    }
+
+    @Test
+    func `codex priority cost remains available at priority input boundary`() {
+        let gpt55 = CostUsagePricing.codexPriorityCostUSD(
+            model: "gpt-5.5",
+            inputTokens: 272_000,
+            cachedInputTokens: 0,
+            outputTokens: 10)
+
+        #expect(gpt55 == (272_000.0 * 1.25e-5) + (10.0 * 7.5e-5))
+    }
+
+    @Test
+    func `codex models dev pricing uses codex long context threshold`() throws {
+        let root = try Self.seedModelsDevCache("""
+        {
+          "openai": {
+            "id": "openai",
+            "models": {
+              "gpt-5.5": {
+                "id": "gpt-5.5",
+                "cost": {
+                  "input": 5,
+                  "output": 30,
+                  "cache_read": 0.5,
+                  "context_over_200k": {
+                    "input": 10,
+                    "output": 45,
+                    "cache_read": 1
+                  }
+                }
+              }
+            }
+          }
+        }
+        """)
+
+        let atBoundary = CostUsagePricing.codexCostUSD(
+            model: "gpt-5.5",
+            inputTokens: 272_000,
+            cachedInputTokens: 0,
+            outputTokens: 10,
+            modelsDevCacheRoot: root)
+        let aboveBoundary = CostUsagePricing.codexCostUSD(
+            model: "gpt-5.5",
+            inputTokens: 272_001,
+            cachedInputTokens: 0,
+            outputTokens: 10,
+            modelsDevCacheRoot: root)
+
+        #expect(atBoundary == (272_000.0 * 5e-6) + (10.0 * 3e-5))
+        #expect(aboveBoundary == (272_001.0 * 1e-5) + (10.0 * 4.5e-5))
+    }
+
+    @Test
+    func `codex cost supports gpt55 pro bundled fallback`() throws {
+        let root = try Self.cacheRoot()
+        let cost = CostUsagePricing.codexCostUSD(
+            model: "openai/gpt-5.5-pro-2026-04-23",
+            inputTokens: 100,
+            cachedInputTokens: 10,
+            outputTokens: 5,
+            modelsDevCacheRoot: root)
+
+        let expected = (100.0 * 3e-5) + (5.0 * 1.8e-4)
+        #expect(cost == expected)
+    }
+
+    @Test
+    func `codex cost returns zero for research preview fallback model`() throws {
+        let root = try Self.cacheRoot()
+        let cost = CostUsagePricing.codexCostUSD(
+            model: "gpt-5.3-codex-spark",
+            inputTokens: 100,
+            cachedInputTokens: 10,
+            outputTokens: 5,
+            modelsDevCacheRoot: root)
+        #expect(cost == 0)
+        #expect(CostUsagePricing.codexDisplayLabel(model: "gpt-5.3-codex-spark") == "Research Preview")
+        #expect(CostUsagePricing.codexDisplayLabel(model: "gpt-5.2-codex") == nil)
+    }
+
+    @Test
+    func `codex cost prefers models dev cache over bundled fallback`() throws {
+        let root = try Self.seedModelsDevCache("""
+        {
+          "openai": {
+            "id": "openai",
+            "models": {
+              "gpt-5.5": {
+                "id": "gpt-5.5",
+                "cost": { "input": 10, "output": 20, "cache_read": 1 }
+              }
+            }
+          }
+        }
+        """)
+
+        let cost = CostUsagePricing.codexCostUSD(
+            model: "openai/gpt-5.5",
+            inputTokens: 100,
+            cachedInputTokens: 10,
+            outputTokens: 5,
+            modelsDevCacheRoot: root)
+
+        let expected = (90.0 * 10e-6) + (10.0 * 1e-6) + (5.0 * 20e-6)
+        #expect(cost == expected)
+    }
+
+    @Test
+    func `codex cost lets models dev override research preview fallback`() throws {
+        let root = try Self.seedModelsDevCache("""
+        {
+          "openai": {
+            "id": "openai",
+            "models": {
+              "gpt-5.3-codex-spark": {
+                "id": "gpt-5.3-codex-spark",
+                "cost": { "input": 2, "output": 8, "cache_read": 0.2 }
+              }
+            }
+          }
+        }
+        """)
+
+        let cost = CostUsagePricing.codexCostUSD(
+            model: "gpt-5.3-codex-spark",
+            inputTokens: 100,
+            cachedInputTokens: 10,
+            outputTokens: 5,
+            modelsDevCacheRoot: root)
+
+        let expected = (90.0 * 2e-6) + (10.0 * 0.2e-6) + (5.0 * 8e-6)
+        #expect(cost == expected)
+        #expect(CostUsagePricing.codexDisplayLabel(model: "gpt-5.3-codex-spark") == "Research Preview")
+    }
+
+    @Test
+    func `codex cost falls back to bundled pricing when models dev misses provider model`() throws {
+        let root = try Self.seedModelsDevCache("""
+        {
+          "anthropic": {
+            "id": "anthropic",
+            "models": {
+              "gpt-5.5": {
+                "id": "gpt-5.5",
+                "cost": { "input": 10, "output": 20, "cache_read": 1 }
+              }
+            }
+          }
+        }
+        """)
+
+        let cost = CostUsagePricing.codexCostUSD(
+            model: "openai/gpt-5.5",
+            inputTokens: 100,
+            cachedInputTokens: 10,
+            outputTokens: 5,
+            modelsDevCacheRoot: root)
+
+        let expected = (90.0 * 5e-6) + (10.0 * 5e-7) + (5.0 * 3e-5)
+        #expect(cost == expected)
+    }
+
+    @Test
+    func `normalizes claude opus41 dated variants`() {
         #expect(CostUsagePricing.normalizeClaudeModel("claude-opus-4-1-20250805") == "claude-opus-4-1")
     }
 
     @Test
-    func claudeCostSupportsOpus41DatedVariant() {
+    func `claude cost supports opus41 dated variant`() {
         let cost = CostUsagePricing.claudeCostUSD(
             model: "claude-opus-4-1-20250805",
             inputTokens: 10,
@@ -48,7 +338,7 @@ struct CostUsagePricingTests {
     }
 
     @Test
-    func claudeCostSupportsOpus46DatedVariant() {
+    func `claude cost supports opus46 dated variant`() {
         let cost = CostUsagePricing.claudeCostUSD(
             model: "claude-opus-4-6-20260205",
             inputTokens: 10,
@@ -59,7 +349,182 @@ struct CostUsagePricingTests {
     }
 
     @Test
-    func claudeCostReturnsNilForUnknownModels() {
+    func `claude cost supports opus47`() {
+        let cost = CostUsagePricing.claudeCostUSD(
+            model: "claude-opus-4-7",
+            inputTokens: 10,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+            outputTokens: 5)
+        let expected = (10.0 * 5e-6) + (5.0 * 2.5e-5)
+        #expect(cost == expected)
+    }
+
+    @Test
+    func `claude cost supports opus48`() throws {
+        // Point at a fresh, empty cache root so the models.dev lookup misses and this
+        // exercises the built-in fallback table specifically — not a local cache hit.
+        let emptyCacheRoot = try Self.cacheRoot()
+        let cost = CostUsagePricing.claudeCostUSD(
+            model: "claude-opus-4-8",
+            inputTokens: 10,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+            outputTokens: 5,
+            modelsDevCacheRoot: emptyCacheRoot)
+        let expected = (10.0 * 5e-6) + (5.0 * 2.5e-5)
+        #expect(cost == expected)
+    }
+
+    @Test
+    func `claude cost supports fable5 bundled fallback`() throws {
+        let emptyCacheRoot = try Self.cacheRoot()
+        let cost = CostUsagePricing.claudeCostUSD(
+            model: "claude-fable-5",
+            inputTokens: 100,
+            cacheReadInputTokens: 20,
+            cacheCreationInputTokens: 10,
+            outputTokens: 5,
+            modelsDevCacheRoot: emptyCacheRoot)
+        let expected = (100.0 * 1e-5) + (20.0 * 1e-6) + (10.0 * 1.25e-5) + (5.0 * 5e-5)
+        #expect(cost == expected)
+    }
+
+    @Test
+    func `claude cost preserves historical sonnet46 long context pricing`() throws {
+        let emptyCacheRoot = try Self.cacheRoot()
+        let historical = CostUsagePricing.claudeCostUSD(
+            model: "claude-sonnet-4-6",
+            inputTokens: 240_000,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+            outputTokens: 0,
+            pricingDate: Date(timeIntervalSince1970: 1_773_359_999),
+            modelsDevCacheRoot: emptyCacheRoot)
+        let current = CostUsagePricing.claudeCostUSD(
+            model: "claude-sonnet-4-6",
+            inputTokens: 240_000,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+            outputTokens: 0,
+            pricingDate: Date(timeIntervalSince1970: 1_773_360_000),
+            modelsDevCacheRoot: emptyCacheRoot)
+
+        #expect(historical == 1.44)
+        #expect(current == 0.72)
+    }
+
+    @Test
+    func `claude cost ignores stale sonnet46 threshold catalog after cutover`() throws {
+        let cacheRoot = try Self.seedModelsDevCache("""
+        {
+          "anthropic": {
+            "id": "anthropic",
+            "models": {
+              "claude-sonnet-4-6": {
+                "id": "claude-sonnet-4-6",
+                "cost": {
+                  "input": 3,
+                  "output": 15,
+                  "cache_read": 0.3,
+                  "cache_write": 3.75,
+                  "context_over_200k": {
+                    "input": 6,
+                    "output": 22.5,
+                    "cache_read": 0.6,
+                    "cache_write": 7.5
+                  }
+                }
+              }
+            }
+          }
+        }
+        """)
+        let cost = CostUsagePricing.claudeCostUSD(
+            model: "claude-sonnet-4-6",
+            inputTokens: 240_000,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+            outputTokens: 0,
+            pricingDate: Date(timeIntervalSince1970: 1_773_360_000),
+            modelsDevCacheRoot: cacheRoot)
+
+        #expect(cost == 0.72)
+    }
+
+    @Test
+    func `claude cost prices one hour cache writes separately`() throws {
+        let emptyCacheRoot = try Self.cacheRoot()
+        let cost = CostUsagePricing.claudeCostUSD(
+            model: "claude-fable-5",
+            inputTokens: 100,
+            cacheReadInputTokens: 20,
+            cacheCreationInputTokens: 30,
+            cacheCreationInputTokens1h: 20,
+            outputTokens: 5,
+            modelsDevCacheRoot: emptyCacheRoot)
+        let expected = (100.0 * 1e-5)
+            + (20.0 * 1e-6)
+            + (10.0 * 1.25e-5)
+            + (20.0 * 2e-5)
+            + (5.0 * 5e-5)
+        #expect(cost == expected)
+    }
+
+    @Test
+    func `claude cost applies long context rates across cache write durations`() throws {
+        let cacheRoot = try Self.seedModelsDevCache("""
+        {
+          "anthropic": {
+            "id": "anthropic",
+            "models": {
+              "claude-threshold-model": {
+                "id": "claude-threshold-model",
+                "cost": {
+                  "input": 3,
+                  "output": 15,
+                  "cache_read": 0.3,
+                  "cache_write": 3.75,
+                  "context_over_200k": {
+                    "input": 6,
+                    "output": 22.5,
+                    "cache_read": 0.6,
+                    "cache_write": 7.5
+                  }
+                }
+              }
+            }
+          }
+        }
+        """)
+        let cost = CostUsagePricing.claudeCostUSD(
+            model: "claude-threshold-model",
+            inputTokens: 0,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 240_000,
+            cacheCreationInputTokens1h: 120_000,
+            outputTokens: 0,
+            modelsDevCacheRoot: cacheRoot)
+        let expected = (120_000.0 * 12e-6)
+            + (120_000.0 * 7.5e-6)
+        #expect(cost == expected)
+    }
+
+    @Test
+    func `claude sonnet46 uses standard pricing across full context`() throws {
+        let emptyCacheRoot = try Self.cacheRoot()
+        let cost = CostUsagePricing.claudeCostUSD(
+            model: "claude-sonnet-4-6",
+            inputTokens: 0,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 240_000,
+            outputTokens: 0,
+            modelsDevCacheRoot: emptyCacheRoot)
+        #expect(cost == 240_000.0 * 3.75e-6)
+    }
+
+    @Test
+    func `claude cost returns nil for unknown models`() {
         let cost = CostUsagePricing.claudeCostUSD(
             model: "glm-4.6",
             inputTokens: 100,
@@ -68,4 +533,60 @@ struct CostUsagePricingTests {
             outputTokens: 40)
         #expect(cost == nil)
     }
+
+    @Test
+    func `claude cost prefers models dev cache with threshold pricing`() throws {
+        let root = try Self.seedModelsDevCache("""
+        {
+          "anthropic": {
+            "id": "anthropic",
+            "models": {
+              "claude-sonnet-4-6": {
+                "id": "claude-sonnet-4-6",
+                "cost": {
+                  "input": 3,
+                  "output": 15,
+                  "cache_read": 0.3,
+                  "cache_write": 3.75,
+                  "context_over_200k": {
+                    "input": 6,
+                    "output": 22.5,
+                    "cache_read": 0.6,
+                    "cache_write": 7.5
+                  }
+                }
+              }
+            }
+          }
+        }
+        """)
+
+        let cost = CostUsagePricing.claudeCostUSD(
+            model: "claude-sonnet-4-6",
+            inputTokens: 200_010,
+            cacheReadInputTokens: 5,
+            cacheCreationInputTokens: 5,
+            outputTokens: 5,
+            modelsDevCacheRoot: root)
+
+        let expected = (200_010.0 * 6e-6)
+            + (5.0 * 0.6e-6)
+            + (5.0 * 7.5e-6)
+            + (5.0 * 22.5e-6)
+        #expect(cost == expected)
+    }
+
+    private static func seedModelsDevCache(_ json: String) throws -> URL {
+        let root = try Self.cacheRoot()
+        let catalog = try JSONDecoder().decode(ModelsDevCatalog.self, from: Data(json.utf8))
+        ModelsDevCache.save(catalog: catalog, fetchedAt: Date(), cacheRoot: root)
+        return root
+    }
+
+    private static func cacheRoot() throws -> URL {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-pricing-tests-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
+        return root
+    }
 }
diff --git a/Tests/CodexBarTests/CostUsageScanExecutorTests.swift b/Tests/CodexBarTests/CostUsageScanExecutorTests.swift
new file mode 100644
index 0000000000..8ea5a03b44
--- /dev/null
+++ b/Tests/CodexBarTests/CostUsageScanExecutorTests.swift
@@ -0,0 +1,156 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct CostUsageScanExecutorTests {
+    @Test
+    func `runs work on the dedicated scan queue and returns its value`() async throws {
+        let queue = self.makeQueue()
+        let label = try await CostUsageScanExecutor.run(on: queue) { _ in
+            String(cString: __dispatch_queue_get_label(nil))
+        }
+        #expect(label == queue.label)
+    }
+
+    @Test
+    func `propagates thrown errors`() async {
+        struct ScanFailure: Error {}
+        let queue = self.makeQueue()
+        await #expect(throws: ScanFailure.self) {
+            try await CostUsageScanExecutor.run(on: queue) { _ -> Int in
+                throw ScanFailure()
+            }
+        }
+    }
+
+    @Test
+    func `serializes overlapping scans`() async throws {
+        let queue = self.makeQueue()
+        let state = LockedValue((active: 0, maxActive: 0))
+        try await withThrowingTaskGroup(of: Void.self) { group in
+            for _ in 0..<4 {
+                group.addTask {
+                    try await CostUsageScanExecutor.run(on: queue) { _ in
+                        state.update {
+                            $0.active += 1
+                            $0.maxActive = max($0.maxActive, $0.active)
+                        }
+                        Thread.sleep(forTimeInterval: 0.02)
+                        state.update { $0.active -= 1 }
+                    }
+                }
+            }
+            try await group.waitForAll()
+        }
+        #expect(state.read { $0.maxActive } == 1)
+    }
+
+    @Test
+    func `cancellation reaches in-flight work through checkCancellation`() async {
+        let queue = self.makeQueue()
+        let workStarted = LockedValue(false)
+        let task = Task {
+            try await CostUsageScanExecutor.run(on: queue) { checkCancellation in
+                workStarted.set(true)
+                while true {
+                    try checkCancellation()
+                    Thread.sleep(forTimeInterval: 0.005)
+                }
+            }
+        }
+        #expect(await self.waitUntil { workStarted.value })
+        task.cancel()
+        await #expect(throws: CancellationError.self) {
+            try await task.value
+        }
+    }
+
+    @Test
+    func `work cancelled while queued resumes with CancellationError`() async {
+        let queue = self.makeQueue()
+        let blockerStarted = LockedValue(false)
+        let releaseBlocker = LockedValue(false)
+        let blocker = Task {
+            try await CostUsageScanExecutor.run(on: queue) { _ in
+                blockerStarted.set(true)
+                while !releaseBlocker.value {
+                    Thread.sleep(forTimeInterval: 0.002)
+                }
+            }
+        }
+        #expect(await self.waitUntil { blockerStarted.value })
+
+        let queuedWorkStarted = LockedValue(false)
+        let queued = Task {
+            try await CostUsageScanExecutor.run(on: queue) { _ in
+                queuedWorkStarted.set(true)
+                Issue.record("queued work should not run after cancellation")
+            }
+        }
+        try? await Task.sleep(for: .milliseconds(50))
+
+        let cancellationObserved = LockedValue<Bool?>(nil)
+        let observer = Task {
+            do {
+                try await queued.value
+                cancellationObserved.set(false)
+            } catch is CancellationError {
+                cancellationObserved.set(true)
+            } catch {
+                cancellationObserved.set(false)
+            }
+        }
+        queued.cancel()
+
+        #expect(await self.waitUntil { cancellationObserved.value != nil })
+        #expect(cancellationObserved.value == true)
+        #expect(!queuedWorkStarted.value)
+        #expect(!releaseBlocker.value)
+
+        releaseBlocker.set(true)
+        await observer.value
+        _ = try? await blocker.value
+    }
+
+    private func makeQueue() -> DispatchQueue {
+        DispatchQueue(label: "\(CostUsageScanExecutor.queueLabel).tests.\(UUID().uuidString)")
+    }
+
+    private func waitUntil(
+        timeout: Duration = .seconds(1),
+        condition: @escaping @Sendable () -> Bool) async -> Bool
+    {
+        let clock = ContinuousClock()
+        let deadline = clock.now.advanced(by: timeout)
+        while clock.now < deadline {
+            if condition() { return true }
+            try? await Task.sleep(for: .milliseconds(5))
+        }
+        return condition()
+    }
+}
+
+private final class LockedValue<Value>: @unchecked Sendable {
+    private let lock = NSLock()
+    private var storage: Value
+
+    init(_ value: Value) {
+        self.storage = value
+    }
+
+    var value: Value {
+        self.lock.withLock { self.storage }
+    }
+
+    func read<Result>(_ body: (Value) -> Result) -> Result {
+        self.lock.withLock { body(self.storage) }
+    }
+
+    func set(_ value: Value) {
+        self.lock.withLock { self.storage = value }
+    }
+
+    func update(_ body: (inout Value) -> Void) {
+        self.lock.withLock { body(&self.storage) }
+    }
+}
diff --git a/Tests/CodexBarTests/CostUsageScannerBreakdownTests.swift b/Tests/CodexBarTests/CostUsageScannerBreakdownTests.swift
new file mode 100644
index 0000000000..bb77320af6
--- /dev/null
+++ b/Tests/CodexBarTests/CostUsageScannerBreakdownTests.swift
@@ -0,0 +1,3478 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+// swiftlint:disable file_length
+// swiftlint:disable type_body_length
+struct CostUsageScannerBreakdownTests {
+    private typealias Usage = (input: Int, cached: Int, output: Int)
+
+    private func codexTurnContext(timestamp: String, model: String) -> [String: Any] {
+        [
+            "type": "turn_context",
+            "timestamp": timestamp,
+            "payload": [
+                "model": model,
+            ],
+        ]
+    }
+
+    private func codexTokenCount(
+        timestamp: String,
+        model: String,
+        total: Usage? = nil,
+        last: Usage? = nil) -> [String: Any]
+    {
+        var info: [String: Any] = [
+            "model": model,
+        ]
+        if let total {
+            info["total_token_usage"] = [
+                "input_tokens": total.input,
+                "cached_input_tokens": total.cached,
+                "output_tokens": total.output,
+            ]
+        }
+        if let last {
+            info["last_token_usage"] = [
+                "input_tokens": last.input,
+                "cached_input_tokens": last.cached,
+                "output_tokens": last.output,
+            ]
+        }
+        return [
+            "type": "event_msg",
+            "timestamp": timestamp,
+            "payload": [
+                "type": "token_count",
+                "info": info,
+            ],
+        ]
+    }
+
+    private func codexTokenCountWithoutModel(timestamp: String, last: Usage) -> [String: Any] {
+        [
+            "type": "event_msg",
+            "timestamp": timestamp,
+            "payload": [
+                "type": "token_count",
+                "info": [
+                    "last_token_usage": [
+                        "input_tokens": last.input,
+                        "cached_input_tokens": last.cached,
+                        "output_tokens": last.output,
+                    ],
+                ],
+            ],
+        ]
+    }
+
+    private func oversizedCodexTurnContextLine(timestamp: String, model: String) -> String {
+        let largeInstructions = String(repeating: "x", count: 300 * 1024)
+        return #"{"type":"turn_context","timestamp":""#
+            + timestamp
+            + #"","payload":{"model":""#
+            + model
+            + #"","instructions":""#
+            + largeInstructions
+            + #""}}"#
+    }
+
+    private func oversizedCodexTurnContextInfoModelLine(timestamp: String, model: String) -> String {
+        let largeInstructions = String(repeating: "x", count: 300 * 1024)
+        return #"{"type":"turn_context","timestamp":""#
+            + timestamp
+            + #"","payload":{"empty":"","info":{"model":""#
+            + model
+            + #""},"instructions":""#
+            + largeInstructions
+            + #""}}"#
+    }
+
+    private func oversizedCodexTurnContextPromptOnlyLine(timestamp: String, promptModel: String) -> String {
+        let prompt = #"example: {\"type\":\"turn_context\",\"payload\":{\"model\":\"\#(promptModel)\"}}"#
+            + String(repeating: "x", count: 300 * 1024)
+        return #"{"type":"turn_context","timestamp":""#
+            + timestamp
+            + #"","payload":{"instructions":""#
+            + prompt
+            + #""}}"#
+    }
+
+    @Test
+    func `codex daily report parses token counts and caches`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2025, month: 12, day: 20)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let iso2 = env.isoString(for: day.addingTimeInterval(2))
+
+        let model = "openai/gpt-5.2-codex"
+        let turnContext: [String: Any] = [
+            "type": "turn_context",
+            "timestamp": iso0,
+            "payload": [
+                "model": model,
+            ],
+        ]
+        let firstTokenCount: [String: Any] = [
+            "type": "event_msg",
+            "timestamp": iso1,
+            "payload": [
+                "type": "token_count",
+                "info": [
+                    "total_token_usage": [
+                        "input_tokens": 100,
+                        "cached_input_tokens": 20,
+                        "output_tokens": 10,
+                    ],
+                    "model": model,
+                ],
+            ],
+        ]
+
+        let fileURL = try env.writeCodexSessionFile(
+            day: day,
+            filename: "session.jsonl",
+            contents: env.jsonl([turnContext, firstTokenCount]))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: nil,
+            cacheRoot: env.cacheRoot,
+            codexTraceDatabaseURL: env.root.appendingPathComponent("missing-traces.sqlite"))
+        options.refreshMinIntervalSeconds = 0
+
+        let first = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+        #expect(first.data.count == 1)
+        #expect(first.data[0].modelsUsed == ["gpt-5.2-codex"])
+        #expect(first.data[0].modelBreakdowns == [
+            CostUsageDailyReport.ModelBreakdown(
+                modelName: "gpt-5.2-codex",
+                costUSD: first.data[0].costUSD,
+                totalTokens: 110),
+        ])
+        #expect(first.data[0].totalTokens == 110)
+        #expect((first.data[0].costUSD ?? 0) > 0)
+        let firstCache = CostUsageCacheIO.load(provider: .codex, cacheRoot: env.cacheRoot)
+        #expect(firstCache.codexPricingKey?.hasPrefix("builtin-") == true)
+
+        let secondTokenCount: [String: Any] = [
+            "type": "event_msg",
+            "timestamp": iso2,
+            "payload": [
+                "type": "token_count",
+                "info": [
+                    "total_token_usage": [
+                        "input_tokens": 160,
+                        "cached_input_tokens": 40,
+                        "output_tokens": 16,
+                    ],
+                    "model": model,
+                ],
+            ],
+        ]
+        try env.jsonl([turnContext, firstTokenCount, secondTokenCount])
+            .write(to: fileURL, atomically: true, encoding: .utf8)
+
+        let second = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+        #expect(second.data.count == 1)
+        #expect(second.data[0].modelsUsed == ["gpt-5.2-codex"])
+        #expect(second.data[0].totalTokens == 176)
+        #expect((second.data[0].costUSD ?? 0) > (first.data[0].costUSD ?? 0))
+    }
+
+    @Test
+    func `codex incremental append falls back to rescan when fork metadata appears late`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 3, day: 11)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let iso2 = env.isoString(for: day.addingTimeInterval(2))
+        let iso3 = env.isoString(for: day.addingTimeInterval(3))
+        let model = "gpt-5.4"
+        let sessionMeta: [String: Any] = [
+            "type": "session_meta",
+            "timestamp": iso0,
+            "payload": ["id": "late-fork-child"],
+        ]
+        let turnContext = self.codexTurnContext(timestamp: iso0, model: model)
+        let firstTokenCount = self.codexTokenCount(
+            timestamp: iso1,
+            model: model,
+            total: (input: 10, cached: 0, output: 0),
+            last: (input: 10, cached: 0, output: 0))
+        let fileURL = try env.writeCodexSessionFile(
+            day: day,
+            filename: "late-fork-child.jsonl",
+            contents: env.jsonl([sessionMeta, turnContext, firstTokenCount]))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: nil,
+            cacheRoot: env.cacheRoot,
+            codexTraceDatabaseURL: env.root.appendingPathComponent("missing-traces.sqlite"))
+        options.refreshMinIntervalSeconds = 0
+
+        let first = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+        #expect(first.data.first?.totalTokens == 10)
+
+        let lateForkMeta: [String: Any] = [
+            "type": "session_meta",
+            "timestamp": iso2,
+            "payload": [
+                "id": "late-fork-child",
+                "forked_from_id": "missing-parent",
+                "timestamp": iso2,
+            ],
+        ]
+        let replayedForkUsage = self.codexTokenCount(
+            timestamp: iso3,
+            model: model,
+            total: (input: 1000, cached: 900, output: 100),
+            last: (input: 1000, cached: 900, output: 100))
+        let handle = try FileHandle(forWritingTo: fileURL)
+        try handle.seekToEnd()
+        try handle.write(contentsOf: Data(("\n" + env.jsonl([lateForkMeta, replayedForkUsage])).utf8))
+        try handle.close()
+
+        let second = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+        #expect(second.data.first?.totalTokens == 10)
+    }
+
+    @Test
+    func `codex daily report reprices cached sessions when models dev pricing changes`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 10)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let olderDay = try env.makeLocalNoon(year: 2026, month: 5, day: 5)
+        let olderFileURL = try env.writeCodexSessionFile(
+            day: olderDay,
+            filename: "older-session.jsonl",
+            contents: env.jsonl([
+                self.codexTurnContext(timestamp: env.isoString(for: olderDay), model: "custom-codex-model"),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: olderDay.addingTimeInterval(1)),
+                    model: "custom-codex-model",
+                    last: (input: 100, cached: 20, output: 10)),
+            ]))
+        try FileManager.default.setAttributes(
+            [.modificationDate: olderDay],
+            ofItemAtPath: olderFileURL.path)
+
+        let model = "custom-codex-model"
+        _ = try env.writeCodexSessionFile(
+            day: day,
+            filename: "session.jsonl",
+            contents: env.jsonl([
+                self.codexTurnContext(timestamp: iso0, model: model),
+                self.codexTokenCount(timestamp: iso1, model: model, last: (input: 100, cached: 20, output: 10)),
+            ]))
+
+        try ModelsDevCache.save(
+            catalog: Self.modelsDevCatalog(model: model, input: 1, output: 2, cacheRead: 0.5),
+            fetchedAt: Date(timeIntervalSince1970: 1),
+            cacheRoot: env.cacheRoot)
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: nil,
+            cacheRoot: env.cacheRoot,
+            codexTraceDatabaseURL: env.root.appendingPathComponent("missing-traces.sqlite"))
+        options.refreshMinIntervalSeconds = 0
+
+        let first = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: olderDay,
+            until: day,
+            now: day,
+            options: options)
+        let oldDailyCost = (80.0 / 1_000_000.0) + (20.0 * 0.5 / 1_000_000.0)
+            + (10.0 * 2.0 / 1_000_000.0)
+        #expect(first.summary?.totalCostUSD == oldDailyCost * 2)
+
+        try ModelsDevCache.save(
+            catalog: Self.modelsDevCatalog(model: model, input: 1, output: 2, cacheRead: 0.5),
+            fetchedAt: Date(timeIntervalSince1970: 2),
+            cacheRoot: env.cacheRoot)
+
+        options.refreshMinIntervalSeconds = 60
+        let samePricing = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day.addingTimeInterval(1),
+            options: options)
+        let samePricingCache = CostUsageCacheIO.load(provider: .codex, cacheRoot: env.cacheRoot)
+        #expect(samePricing.summary?.totalCostUSD == oldDailyCost)
+        #expect(samePricingCache.scanSinceKey == "2026-05-04")
+
+        try ModelsDevCache.save(
+            catalog: Self.modelsDevCatalog(model: model, input: 10, output: 20, cacheRead: 5),
+            fetchedAt: Date(timeIntervalSince1970: 2),
+            cacheRoot: env.cacheRoot)
+
+        options.refreshMinIntervalSeconds = 60
+        let narrowRepriced = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day.addingTimeInterval(2),
+            options: options)
+        let newDailyCost = (80.0 * 10.0 / 1_000_000.0)
+            + (20.0 * 5.0 / 1_000_000.0)
+            + (10.0 * 20.0 / 1_000_000.0)
+        #expect(narrowRepriced.summary?.totalCostUSD == newDailyCost)
+
+        let wideRepriced = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: olderDay,
+            until: day,
+            now: day.addingTimeInterval(3),
+            options: options)
+
+        #expect(wideRepriced.summary?.totalCostUSD == newDailyCost * 2)
+    }
+
+    @Test
+    func `codex incremental cache preserves divergent total baseline`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 18)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let iso2 = env.isoString(for: day.addingTimeInterval(2))
+        let model = "openai/gpt-5.4"
+        let sessionMeta: [String: Any] = [
+            "type": "session_meta",
+            "timestamp": iso0,
+            "payload": ["session_id": "divergent-session"],
+        ]
+        let turnContext = self.codexTurnContext(timestamp: iso0, model: model)
+        let firstTokenCount = self.codexTokenCount(
+            timestamp: iso1,
+            model: model,
+            total: (input: 50, cached: 0, output: 0),
+            last: (input: 100, cached: 0, output: 0))
+        let fileURL = try env.writeCodexSessionFile(
+            day: day,
+            filename: "session.jsonl",
+            contents: env.jsonl([sessionMeta, turnContext, firstTokenCount]))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: nil,
+            cacheRoot: env.cacheRoot,
+            codexTraceDatabaseURL: env.root.appendingPathComponent("missing-traces.sqlite"))
+        options.refreshMinIntervalSeconds = 0
+
+        let first = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+        #expect(first.data.first?.totalTokens == 100)
+
+        let secondTokenCount = self.codexTokenCount(
+            timestamp: iso2,
+            model: model,
+            total: (input: 80, cached: 0, output: 0))
+        try env.jsonl([sessionMeta, turnContext, firstTokenCount, secondTokenCount])
+            .write(to: fileURL, atomically: true, encoding: .utf8)
+
+        let second = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day.addingTimeInterval(1),
+            options: options)
+        let cache = CostUsageCacheIO.load(provider: .codex, cacheRoot: env.cacheRoot)
+        let usage = cache.files.first { URL(fileURLWithPath: $0.key).lastPathComponent == fileURL.lastPathComponent }?
+            .value
+
+        #expect(second.data.first?.totalTokens == 130)
+        #expect(usage?.lastTotals == nil)
+        #expect(usage?.lastCountedTotals?.input == 130)
+        #expect(usage?.lastRawTotalsBaseline?.input == 80)
+        #expect(usage?.hasDivergentTotals == true)
+    }
+
+    @Test
+    func `codex incremental cache migrates legacy rows before appending delta costs`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 18)
+        let olderDay = try env.makeLocalNoon(year: 2026, month: 5, day: 10)
+        let olderDayKey = CostUsageScanner.CostUsageDayRange.dayKey(from: olderDay)
+        let dayKey = CostUsageScanner.CostUsageDayRange.dayKey(from: day)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let iso2 = env.isoString(for: day.addingTimeInterval(2))
+        let model = "gpt-5.4"
+        let sessionMeta: [String: Any] = [
+            "type": "session_meta",
+            "timestamp": iso0,
+            "payload": ["session_id": "legacy-cost-session"],
+        ]
+        let turnContext = self.codexTurnContext(timestamp: iso0, model: model)
+        let firstTokenCount = self.codexTokenCount(
+            timestamp: iso1,
+            model: model,
+            total: (input: 10, cached: 0, output: 0))
+        let fileURL = try env.writeCodexSessionFile(
+            day: day,
+            filename: "session.jsonl",
+            contents: env.jsonl([sessionMeta, turnContext, firstTokenCount]))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: nil,
+            cacheRoot: env.cacheRoot,
+            codexTraceDatabaseURL: env.root.appendingPathComponent("missing-traces.sqlite"))
+        options.refreshMinIntervalSeconds = 0
+
+        _ = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+
+        var cache = CostUsageCacheIO.load(provider: .codex, cacheRoot: env.cacheRoot)
+        let path = try #require(cache.files.keys.first)
+        var cachedUsage = try #require(cache.files[path])
+        #expect(cachedUsage.sessionId == "legacy-cost-session")
+        #expect(cachedUsage.lastCountedTotals?.input == 10)
+        cachedUsage.codexCostNanos = nil
+        cachedUsage.codexRows = [
+            CostUsageScanner.CodexUsageRow(
+                day: olderDayKey,
+                model: CostUsagePricing.normalizeCodexModel(model),
+                turnID: nil,
+                input: 20,
+                cached: 0,
+                output: 0),
+            CostUsageScanner.CodexUsageRow(
+                day: dayKey,
+                model: CostUsagePricing.normalizeCodexModel(model),
+                turnID: nil,
+                input: 10,
+                cached: 0,
+                output: 0),
+        ]
+        cache.files[path] = cachedUsage
+        CostUsageCacheIO.save(provider: .codex, cache: cache, cacheRoot: env.cacheRoot)
+        let savedUsage = try #require(CostUsageCacheIO.load(provider: .codex, cacheRoot: env.cacheRoot).files[path])
+        #expect(savedUsage.codexRows?.map(\.day) == [olderDayKey, dayKey])
+
+        let secondTokenCount = self.codexTokenCount(
+            timestamp: iso2,
+            model: model,
+            total: (input: 15, cached: 0, output: 0))
+        let appended = try "\n" + env.jsonl([secondTokenCount])
+        let handle = try FileHandle(forWritingTo: fileURL)
+        try handle.seekToEnd()
+        try handle.write(contentsOf: Data(appended.utf8))
+        try handle.close()
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day.addingTimeInterval(1),
+            options: options)
+        let expectedCost = 15.0 * 2.5e-6
+
+        #expect(report.data.first?.totalTokens == 15)
+        #expect(abs((report.summary?.totalCostUSD ?? 0) - expectedCost) < 0.000_000_001)
+
+        var migratedCache = CostUsageCacheIO.load(provider: .codex, cacheRoot: env.cacheRoot)
+        let migratedUsage = try #require(migratedCache.files[path])
+        #expect(migratedUsage.codexRows?.map(\.day) == [olderDayKey])
+        #expect(migratedUsage.codexCostNanos?[dayKey] != nil)
+
+        let parsedBytes = migratedUsage.parsedBytes
+        options.refreshMinIntervalSeconds = 60
+        let repeated = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day.addingTimeInterval(2),
+            options: options)
+        migratedCache = CostUsageCacheIO.load(provider: .codex, cacheRoot: env.cacheRoot)
+        #expect(repeated.data.first?.totalTokens == 15)
+        #expect(migratedCache.files[path]?.parsedBytes == parsedBytes)
+    }
+
+    @Test
+    func `codex split cache migration does not double count existing cost maps`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 18)
+        let dayKey = CostUsageScanner.CostUsageDayRange.dayKey(from: day)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let model = "gpt-5.4"
+        let normalizedModel = CostUsagePricing.normalizeCodexModel(model)
+        _ = try env.writeCodexSessionFile(
+            day: day,
+            filename: "session.jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "session_meta",
+                    "timestamp": iso0,
+                    "payload": ["session_id": "split-cache-session"],
+                ],
+                self.codexTurnContext(timestamp: iso0, model: model),
+                self.codexTokenCount(
+                    timestamp: iso1,
+                    model: model,
+                    total: (input: 10, cached: 0, output: 0)),
+            ]))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: nil,
+            cacheRoot: env.cacheRoot,
+            codexTraceDatabaseURL: env.root.appendingPathComponent("missing-traces.sqlite"))
+        options.refreshMinIntervalSeconds = 0
+
+        _ = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+
+        var cache = CostUsageCacheIO.load(provider: .codex, cacheRoot: env.cacheRoot)
+        let path = try #require(cache.files.keys.first)
+        var cachedUsage = try #require(cache.files[path])
+        let originalCostNanos = try #require(cachedUsage.codexCostNanos?[dayKey]?[normalizedModel])
+        let addedModel = CostUsagePricing.normalizeCodexModel("gpt-5.5")
+        cachedUsage.codexRows = [
+            CostUsageScanner.CodexUsageRow(
+                day: dayKey,
+                model: normalizedModel,
+                turnID: nil,
+                input: 10,
+                cached: 0,
+                output: 0),
+            CostUsageScanner.CodexUsageRow(
+                day: dayKey,
+                model: addedModel,
+                turnID: nil,
+                input: 10,
+                cached: 0,
+                output: 0),
+        ]
+        cachedUsage.codexStandardCostNanos = nil
+        cachedUsage.codexPriorityCostNanos = nil
+        cachedUsage.codexStandardTokens = nil
+        cachedUsage.codexPriorityTokens = nil
+        cache.files[path] = cachedUsage
+        CostUsageCacheIO.save(provider: .codex, cache: cache, cacheRoot: env.cacheRoot)
+
+        options.refreshMinIntervalSeconds = 60
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day.addingTimeInterval(1),
+            options: options)
+
+        let expectedCost = 10.0 * 2.5e-6
+        #expect(abs((report.summary?.totalCostUSD ?? 0) - expectedCost) < 0.000_000_001)
+        let migratedUsage = try #require(CostUsageCacheIO.load(provider: .codex, cacheRoot: env.cacheRoot).files[path])
+        #expect(migratedUsage.codexRows == nil)
+        #expect(migratedUsage.codexCostNanos?[dayKey]?[normalizedModel] == originalCostNanos)
+        #expect(migratedUsage.codexCostNanos?[dayKey]?[addedModel] == Int64((10.0 * 5e-6 * 1_000_000_000).rounded()))
+        #expect(migratedUsage.codexStandardTokens?[dayKey]?[normalizedModel] == 10)
+        #expect(migratedUsage.codexStandardTokens?[dayKey]?[addedModel] == 10)
+    }
+
+    @Test
+    func `codex narrow full rescan preserves cached days outside scan window`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let olderDay = try env.makeLocalNoon(year: 2026, month: 5, day: 10)
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 18)
+        let model = "gpt-5.4"
+        let fileURL = try env.writeCodexSessionFile(
+            day: day,
+            filename: "multi-day-session.jsonl",
+            contents: env.jsonl([
+                self.codexTurnContext(timestamp: env.isoString(for: olderDay), model: model),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: olderDay.addingTimeInterval(1)),
+                    model: model,
+                    last: (input: 20, cached: 0, output: 0)),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: day.addingTimeInterval(1)),
+                    model: model,
+                    last: (input: 10, cached: 0, output: 0)),
+            ]))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: nil,
+            cacheRoot: env.cacheRoot,
+            codexTraceDatabaseURL: env.root.appendingPathComponent("missing-traces.sqlite"))
+        options.refreshMinIntervalSeconds = 0
+
+        let wide = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: olderDay,
+            until: day,
+            now: day,
+            options: options)
+        #expect(wide.summary?.totalTokens == 30)
+
+        try env.jsonl([
+            self.codexTurnContext(timestamp: env.isoString(for: olderDay), model: model),
+            self.codexTokenCount(
+                timestamp: env.isoString(for: olderDay.addingTimeInterval(1)),
+                model: model,
+                last: (input: 20, cached: 0, output: 0)),
+            self.codexTokenCount(
+                timestamp: env.isoString(for: day.addingTimeInterval(1)),
+                model: model,
+                last: (input: 12, cached: 0, output: 0)),
+        ]).write(to: fileURL, atomically: true, encoding: .utf8)
+
+        let narrow = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day.addingTimeInterval(1),
+            options: options)
+        #expect(narrow.summary?.totalTokens == 12)
+
+        options.refreshMinIntervalSeconds = 60
+        let repeatedWide = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: olderDay,
+            until: day,
+            now: day.addingTimeInterval(2),
+            options: options)
+        #expect(repeatedWide.summary?.totalTokens == 32)
+    }
+
+    @Test
+    func `codex turn id cache migration narrows retained cache window`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let olderDay = try env.makeLocalNoon(year: 2026, month: 5, day: 10)
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 18)
+        let olderDayKey = CostUsageScanner.CostUsageDayRange.dayKey(from: olderDay)
+        let model = "gpt-5.4"
+        let fileURL = try env.writeCodexSessionFile(
+            day: day,
+            filename: "legacy-turn-ids.jsonl",
+            contents: env.jsonl([
+                self.codexTurnContext(timestamp: env.isoString(for: olderDay), model: model),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: olderDay.addingTimeInterval(1)),
+                    model: model,
+                    last: (input: 20, cached: 0, output: 0)),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: day.addingTimeInterval(1)),
+                    model: model,
+                    last: (input: 10, cached: 0, output: 0)),
+            ]))
+        let dbURL = env.root.appendingPathComponent("logs_2.sqlite")
+        try CostUsageScannerCodexPriorityTests.createTestLogsDatabase(at: dbURL)
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: nil,
+            cacheRoot: env.cacheRoot,
+            codexTraceDatabaseURL: dbURL)
+        options.refreshMinIntervalSeconds = 0
+
+        let wide = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: olderDay,
+            until: day,
+            now: day,
+            options: options)
+        #expect(wide.summary?.totalTokens == 30)
+
+        var cache = CostUsageCacheIO.load(provider: .codex, cacheRoot: env.cacheRoot)
+        let path = try #require(cache.files.keys.first)
+        cache.files[path]?.codexTurnIDs = nil
+        CostUsageCacheIO.save(provider: .codex, cache: cache, cacheRoot: env.cacheRoot)
+
+        try env.jsonl([
+            self.codexTurnContext(timestamp: env.isoString(for: olderDay), model: model),
+            self.codexTokenCount(
+                timestamp: env.isoString(for: olderDay.addingTimeInterval(1)),
+                model: model,
+                last: (input: 20, cached: 0, output: 0)),
+            self.codexTokenCount(
+                timestamp: env.isoString(for: day.addingTimeInterval(1)),
+                model: model,
+                last: (input: 12, cached: 0, output: 0)),
+        ]).write(to: fileURL, atomically: true, encoding: .utf8)
+
+        options.refreshMinIntervalSeconds = 60
+        let narrow = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day.addingTimeInterval(1),
+            options: options)
+        #expect(narrow.summary?.totalTokens == 12)
+
+        cache = CostUsageCacheIO.load(provider: .codex, cacheRoot: env.cacheRoot)
+        #expect(cache.scanSinceKey == "2026-05-17")
+        #expect(cache.scanUntilKey == "2026-05-19")
+        #expect(cache.files[path]?.days[olderDayKey] == nil)
+
+        let repeatedWide = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: olderDay,
+            until: day,
+            now: day.addingTimeInterval(2),
+            options: options)
+        #expect(repeatedWide.summary?.totalTokens == 32)
+    }
+
+    @Test
+    func `codex long turn context preserves model attribution`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 18)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let model = "openai/gpt-5.5"
+        let turnContext: [String: Any] = [
+            "type": "turn_context",
+            "timestamp": iso0,
+            "payload": [
+                "model": model,
+                "instructions": String(repeating: "x", count: 40 * 1024),
+            ],
+        ]
+        let tokenCount: [String: Any] = [
+            "type": "event_msg",
+            "timestamp": iso1,
+            "payload": [
+                "type": "token_count",
+                "info": [
+                    "last_token_usage": [
+                        "input_tokens": 100,
+                        "cached_input_tokens": 40,
+                        "output_tokens": 10,
+                    ],
+                ],
+            ],
+        ]
+
+        let fileURL = try env.writeCodexSessionFile(
+            day: day,
+            filename: "long-turn-context.jsonl",
+            contents: env.jsonl([turnContext, tokenCount]))
+
+        let parsed = CostUsageScanner.parseCodexFile(
+            fileURL: fileURL,
+            range: CostUsageScanner.CostUsageDayRange(since: day, until: day))
+        let dayKey = CostUsageScanner.CostUsageDayRange.dayKey(from: day)
+
+        #expect(parsed.days[dayKey]?["gpt-5.5"] == [100, 40, 10])
+        #expect(parsed.days[dayKey]?["gpt-5"] == nil)
+    }
+
+    @Test
+    func `codex oversized turn context prefix preserves model attribution`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 18)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let model = "openai/gpt-5.5"
+        let turnContextLine = self.oversizedCodexTurnContextLine(timestamp: iso0, model: model)
+        let tokenCountLine = try env.jsonl([
+            self.codexTokenCountWithoutModel(timestamp: iso1, last: (input: 120, cached: 30, output: 12)),
+        ])
+
+        let fileURL = try env.writeCodexSessionFile(
+            day: day,
+            filename: "oversized-turn-context.jsonl",
+            contents: turnContextLine + "\n" + tokenCountLine)
+
+        let parsed = CostUsageScanner.parseCodexFile(
+            fileURL: fileURL,
+            range: CostUsageScanner.CostUsageDayRange(since: day, until: day))
+        let dayKey = CostUsageScanner.CostUsageDayRange.dayKey(from: day)
+
+        #expect(parsed.days[dayKey]?["gpt-5.5"] == [120, 30, 12])
+        #expect(parsed.days[dayKey]?["gpt-5"] == nil)
+    }
+
+    @Test
+    func `codex oversized turn context prefix supports nested info model`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 18)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let model = "openai/gpt-5.5"
+        let turnContextLine = self.oversizedCodexTurnContextInfoModelLine(timestamp: iso0, model: model)
+        let tokenCountLine = try env.jsonl([
+            self.codexTokenCountWithoutModel(timestamp: iso1, last: (input: 120, cached: 30, output: 12)),
+        ])
+
+        let fileURL = try env.writeCodexSessionFile(
+            day: day,
+            filename: "oversized-turn-context-info-model.jsonl",
+            contents: turnContextLine + "\n" + tokenCountLine)
+
+        let parsed = CostUsageScanner.parseCodexFile(
+            fileURL: fileURL,
+            range: CostUsageScanner.CostUsageDayRange(since: day, until: day))
+        let dayKey = CostUsageScanner.CostUsageDayRange.dayKey(from: day)
+
+        #expect(parsed.days[dayKey]?["gpt-5.5"] == [120, 30, 12])
+        #expect(parsed.days[dayKey]?["gpt-5"] == nil)
+    }
+
+    @Test
+    func `codex oversized turn context ignores prompt model examples`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 18)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let iso2 = env.isoString(for: day.addingTimeInterval(2))
+        let turnContextLine = self.oversizedCodexTurnContextPromptOnlyLine(
+            timestamp: iso1,
+            promptModel: "openai/gpt-5.5")
+        let tokenCountLine = try env.jsonl([
+            self.codexTokenCountWithoutModel(timestamp: iso2, last: (input: 120, cached: 30, output: 12)),
+        ])
+
+        let fileURL = try env.writeCodexSessionFile(
+            day: day,
+            filename: "oversized-turn-context-prompt-example.jsonl",
+            contents: env.jsonl([self.codexTurnContext(timestamp: iso0, model: "openai/gpt-5.4")])
+                + turnContextLine + "\n" + tokenCountLine)
+
+        let parsed = CostUsageScanner.parseCodexFile(
+            fileURL: fileURL,
+            range: CostUsageScanner.CostUsageDayRange(since: day, until: day))
+        let dayKey = CostUsageScanner.CostUsageDayRange.dayKey(from: day)
+
+        #expect(parsed.days[dayKey]?["gpt-5.4"] == [120, 30, 12])
+        #expect(parsed.days[dayKey]?["gpt-5.5"] == nil)
+    }
+
+    @Test
+    func `codex token count model applies without turn context model`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 18)
+
+        let contents = try env.jsonl([
+            self.codexTokenCount(
+                timestamp: env.isoString(for: day.addingTimeInterval(1)),
+                model: "openai/gpt-5.5",
+                last: (input: 50, cached: 10, output: 5)),
+        ])
+        let fileURL = try env.writeCodexSessionFile(
+            day: day,
+            filename: "token-count-model.jsonl",
+            contents: contents)
+
+        let parsed = CostUsageScanner.parseCodexFile(
+            fileURL: fileURL,
+            range: CostUsageScanner.CostUsageDayRange(since: day, until: day))
+        let dayKey = CostUsageScanner.CostUsageDayRange.dayKey(from: day)
+
+        #expect(parsed.days[dayKey]?["gpt-5.5"] == [50, 10, 5])
+        #expect(parsed.days[dayKey]?["gpt-5"] == nil)
+    }
+
+    @Test
+    func `codex daily report writes corrected cache artifact for oversized turn context`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 18)
+        let dayKey = CostUsageScanner.CostUsageDayRange.dayKey(from: day)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let model = "openai/gpt-5.5"
+        let turnContextLine = self.oversizedCodexTurnContextLine(timestamp: iso0, model: model)
+        let tokenCountLine = try env.jsonl([
+            self.codexTokenCountWithoutModel(timestamp: iso1, last: (input: 120, cached: 30, output: 12)),
+        ])
+
+        _ = try env.writeCodexSessionFile(
+            day: day,
+            filename: "cached-oversized-turn-context.jsonl",
+            contents: turnContextLine + "\n" + tokenCountLine)
+
+        let oldCacheDir = env.cacheRoot.appendingPathComponent("cost-usage", isDirectory: true)
+        try FileManager.default.createDirectory(at: oldCacheDir, withIntermediateDirectories: true)
+        let oldCacheURL = oldCacheDir.appendingPathComponent("codex-v7.json", isDirectory: false)
+        let oldCache = #"{"version":1,"lastScanUnixMs":9999999999999,"files":{},"days":{"\#(dayKey)":"#
+            + #"{"gpt-5":[999,0,0]}}}"#
+        try oldCache.write(to: oldCacheURL, atomically: true, encoding: .utf8)
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: nil,
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 3600
+
+        let first = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+        #expect(first.data.count == 1)
+        #expect(first.data[0].modelsUsed == ["gpt-5.5"])
+        #expect(first.data[0].modelBreakdowns?.map(\.modelName) == ["gpt-5.5"])
+        #expect(first.data[0].totalTokens == 132)
+
+        let newCacheURL = CostUsageCacheIO.cacheFileURL(provider: .codex, cacheRoot: env.cacheRoot)
+        #expect(newCacheURL.lastPathComponent == "codex-v8.json")
+        #expect(FileManager.default.fileExists(atPath: newCacheURL.path))
+        #expect(FileManager.default.fileExists(atPath: oldCacheURL.path))
+
+        let second = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day.addingTimeInterval(60),
+            options: options)
+        #expect(second.data.count == 1)
+        #expect(second.data[0].modelsUsed == ["gpt-5.5"])
+        #expect(second.data[0].totalTokens == 132)
+    }
+
+    @Test
+    func `codex daily report prefers last token usage over divergent totals`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 15)
+        let iso0 = env.isoString(for: day)
+        let model = "openai/gpt-5.5"
+        let turnContext = self.codexTurnContext(timestamp: iso0, model: model)
+
+        _ = try env.writeCodexSessionFile(
+            day: day,
+            filename: "session.jsonl",
+            contents: env.jsonl([
+                turnContext,
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: day.addingTimeInterval(1)),
+                    model: model,
+                    total: (input: 100, cached: 20, output: 10),
+                    last: (input: 100, cached: 20, output: 10)),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: day.addingTimeInterval(2)),
+                    model: model,
+                    total: (input: 160, cached: 40, output: 16),
+                    last: (input: 60, cached: 20, output: 6)),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: day.addingTimeInterval(3)),
+                    model: model,
+                    total: (input: 1000, cached: 900, output: 100),
+                    last: (input: 40, cached: 30, output: 5)),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: day.addingTimeInterval(4)),
+                    model: model,
+                    total: (input: 1050, cached: 930, output: 110),
+                    last: (input: 50, cached: 30, output: 10)),
+            ]))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: nil,
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 0
+        options.forceRescan = true
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+        let expectedCost = CostUsagePricing.codexCostUSD(
+            model: model,
+            inputTokens: 250,
+            cachedInputTokens: 100,
+            outputTokens: 31)
+
+        #expect(report.data.count == 1)
+        #expect(report.data[0].inputTokens == 250)
+        #expect(report.data[0].outputTokens == 31)
+        #expect(report.data[0].totalTokens == 281)
+        #expect(abs((report.data[0].costUSD ?? 0) - (expectedCost ?? 0)) < 0.000001)
+    }
+
+    @Test
+    func `codex repeated total token snapshots do not recount last usage`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 20)
+        let model = "openai/gpt-5.5"
+        let fileURL = try env.writeCodexSessionFile(
+            day: day,
+            filename: "repeated-total-snapshot.jsonl",
+            contents: env.jsonl([
+                self.codexTurnContext(timestamp: env.isoString(for: day), model: model),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: day.addingTimeInterval(1)),
+                    model: model,
+                    total: (input: 100, cached: 20, output: 10),
+                    last: (input: 100, cached: 20, output: 10)),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: day.addingTimeInterval(2)),
+                    model: model,
+                    total: (input: 100, cached: 20, output: 10),
+                    last: (input: 100, cached: 20, output: 10)),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: day.addingTimeInterval(3)),
+                    model: model,
+                    total: (input: 130, cached: 20, output: 12),
+                    last: (input: 100, cached: 20, output: 10)),
+            ]))
+
+        let parsed = CostUsageScanner.parseCodexFile(
+            fileURL: fileURL,
+            range: CostUsageScanner.CostUsageDayRange(since: day, until: day))
+        let dayKey = CostUsageScanner.CostUsageDayRange.dayKey(from: day)
+        let packed = parsed.days[dayKey]?["gpt-5.5"] ?? []
+
+        #expect(packed[safe: 0] == 130)
+        #expect(packed[safe: 1] == 20)
+        #expect(packed[safe: 2] == 12)
+        #expect(parsed.rows.count == 2)
+    }
+
+    @Test
+    func `codex total only after divergent totals uses raw delta when it continues`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 15)
+        let model = "openai/gpt-5.5"
+        let fileURL = try env.writeCodexSessionFile(
+            day: day,
+            filename: "mixed-raw-continuing.jsonl",
+            contents: env.jsonl([
+                self.codexTurnContext(timestamp: env.isoString(for: day), model: model),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: day.addingTimeInterval(1)),
+                    model: model,
+                    total: (input: 100, cached: 0, output: 0),
+                    last: (input: 100, cached: 0, output: 0)),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: day.addingTimeInterval(2)),
+                    model: model,
+                    total: (input: 1000, cached: 0, output: 0),
+                    last: (input: 40, cached: 0, output: 0)),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: day.addingTimeInterval(3)),
+                    model: model,
+                    total: (input: 1050, cached: 0, output: 0)),
+            ]))
+
+        let parsed = CostUsageScanner.parseCodexFile(
+            fileURL: fileURL,
+            range: CostUsageScanner.CostUsageDayRange(since: day, until: day))
+        let dayKey = CostUsageScanner.CostUsageDayRange.dayKey(from: day)
+        let packed = parsed.days[dayKey]?["gpt-5.5"] ?? []
+
+        #expect(packed[safe: 0] == 190)
+        #expect(parsed.lastTotals == nil)
+    }
+
+    @Test
+    func `codex total only after divergent totals preserves zero raw dimensions`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 15)
+        let model = "openai/gpt-5.5"
+        let fileURL = try env.writeCodexSessionFile(
+            day: day,
+            filename: "mixed-stale-dimension.jsonl",
+            contents: env.jsonl([
+                self.codexTurnContext(timestamp: env.isoString(for: day), model: model),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: day.addingTimeInterval(1)),
+                    model: model,
+                    total: (input: 100, cached: 0, output: 0),
+                    last: (input: 100, cached: 0, output: 0)),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: day.addingTimeInterval(2)),
+                    model: model,
+                    total: (input: 1000, cached: 900, output: 0),
+                    last: (input: 40, cached: 0, output: 0)),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: day.addingTimeInterval(3)),
+                    model: model,
+                    total: (input: 1050, cached: 900, output: 0)),
+            ]))
+
+        let parsed = CostUsageScanner.parseCodexFile(
+            fileURL: fileURL,
+            range: CostUsageScanner.CostUsageDayRange(since: day, until: day))
+        let dayKey = CostUsageScanner.CostUsageDayRange.dayKey(from: day)
+        let packed = parsed.days[dayKey]?["gpt-5.5"] ?? []
+
+        #expect(packed[safe: 0] == 190)
+        #expect(packed[safe: 1] == 0)
+        #expect(parsed.lastTotals == nil)
+    }
+
+    @Test
+    func `codex total only after divergent totals can resume from counted baseline`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 15)
+        let model = "openai/gpt-5.5"
+        let fileURL = try env.writeCodexSessionFile(
+            day: day,
+            filename: "mixed-counted-resume.jsonl",
+            contents: env.jsonl([
+                self.codexTurnContext(timestamp: env.isoString(for: day), model: model),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: day.addingTimeInterval(1)),
+                    model: model,
+                    total: (input: 100, cached: 0, output: 0),
+                    last: (input: 100, cached: 0, output: 0)),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: day.addingTimeInterval(2)),
+                    model: model,
+                    total: (input: 1000, cached: 0, output: 0),
+                    last: (input: 40, cached: 0, output: 0)),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: day.addingTimeInterval(3)),
+                    model: model,
+                    total: (input: 180, cached: 0, output: 0)),
+            ]))
+
+        let parsed = CostUsageScanner.parseCodexFile(
+            fileURL: fileURL,
+            range: CostUsageScanner.CostUsageDayRange(since: day, until: day))
+        let dayKey = CostUsageScanner.CostUsageDayRange.dayKey(from: day)
+        let packed = parsed.days[dayKey]?["gpt-5.5"] ?? []
+
+        #expect(packed[safe: 0] == 180)
+        #expect(parsed.lastTotals?.input == 180)
+    }
+
+    @Test
+    func `codex total only after last only counts from last based baseline`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 15)
+        let model = "openai/gpt-5.5"
+        let fileURL = try env.writeCodexSessionFile(
+            day: day,
+            filename: "last-then-total.jsonl",
+            contents: env.jsonl([
+                self.codexTurnContext(timestamp: env.isoString(for: day), model: model),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: day.addingTimeInterval(1)),
+                    model: model,
+                    last: (input: 100, cached: 0, output: 0)),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: day.addingTimeInterval(2)),
+                    model: model,
+                    total: (input: 150, cached: 0, output: 0)),
+            ]))
+
+        let parsed = CostUsageScanner.parseCodexFile(
+            fileURL: fileURL,
+            range: CostUsageScanner.CostUsageDayRange(since: day, until: day))
+        let dayKey = CostUsageScanner.CostUsageDayRange.dayKey(from: day)
+        let packed = parsed.days[dayKey]?["gpt-5.5"] ?? []
+
+        #expect(packed[safe: 0] == 150)
+        #expect(parsed.lastTotals?.input == 150)
+    }
+
+    @Test
+    func `codex daily report includes archived sessions and dedupes`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2025, month: 12, day: 22)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+
+        let model = "openai/gpt-5.2-codex"
+        let sessionMeta: [String: Any] = [
+            "type": "session_meta",
+            "payload": [
+                "session_id": "sess-archived-1",
+            ],
+        ]
+        let turnContext: [String: Any] = [
+            "type": "turn_context",
+            "timestamp": iso0,
+            "payload": [
+                "model": model,
+            ],
+        ]
+        let tokenCount: [String: Any] = [
+            "type": "event_msg",
+            "timestamp": iso1,
+            "payload": [
+                "type": "token_count",
+                "info": [
+                    "total_token_usage": [
+                        "input_tokens": 100,
+                        "cached_input_tokens": 20,
+                        "output_tokens": 10,
+                    ],
+                    "model": model,
+                ],
+            ],
+        ]
+
+        let comps = Calendar.current.dateComponents([.year, .month, .day], from: day)
+        let dayKey = String(format: "%04d-%02d-%02d", comps.year ?? 1970, comps.month ?? 1, comps.day ?? 1)
+        let archivedName = "rollout-\(dayKey)T12-00-00-archived.jsonl"
+        let contents = try env.jsonl([sessionMeta, turnContext, tokenCount])
+        _ = try env.writeCodexArchivedSessionFile(filename: archivedName, contents: contents)
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: nil,
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 0
+
+        let first = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+        #expect(first.data.count == 1)
+        #expect(first.data[0].totalTokens == 110)
+
+        _ = try env.writeCodexSessionFile(day: day, filename: "session.jsonl", contents: contents)
+        let second = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+        #expect(second.data.count == 1)
+        #expect(second.data[0].totalTokens == 110)
+    }
+
+    @Test
+    func `codex daily report includes long lived sessions stored under older date partitions`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let fileDay = try env.makeLocalNoon(year: 2026, month: 2, day: 27)
+        let reportDay = try env.makeLocalNoon(year: 2026, month: 3, day: 11)
+        let model = "openai/gpt-5.2-codex"
+
+        _ = try env.writeCodexSessionFile(
+            day: fileDay,
+            filename: "rollout-2026-02-27T11-29-28-cross-day.jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "session_meta",
+                    "payload": [
+                        "id": "cross-day-session",
+                    ],
+                ],
+                [
+                    "type": "turn_context",
+                    "timestamp": env.isoString(for: reportDay),
+                    "payload": [
+                        "model": model,
+                    ],
+                ],
+                [
+                    "type": "event_msg",
+                    "timestamp": env.isoString(for: reportDay.addingTimeInterval(1)),
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "total_token_usage": [
+                                "input_tokens": 100,
+                                "cached_input_tokens": 20,
+                                "output_tokens": 10,
+                            ],
+                            "model": model,
+                        ],
+                    ],
+                ],
+            ]))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: nil,
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 0
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: reportDay,
+            until: reportDay,
+            now: reportDay,
+            options: options)
+
+        #expect(report.data.count == 1)
+        #expect(report.data[0].inputTokens == 100)
+        #expect(report.data[0].outputTokens == 10)
+        #expect(report.data[0].totalTokens == 110)
+    }
+
+    @Test
+    func `codex cold cache includes very old active date partition session`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let fileDay = try env.makeLocalNoon(year: 2026, month: 1, day: 1)
+        let reportDay = try env.makeLocalNoon(year: 2026, month: 5, day: 18)
+        let model = "openai/gpt-5.2-codex"
+
+        let fileURL = try env.writeCodexSessionFile(
+            day: fileDay,
+            filename: "rollout-2026-01-01T11-29-28-active.jsonl",
+            contents: env.jsonl([
+                self.codexTurnContext(timestamp: env.isoString(for: fileDay), model: model),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: reportDay.addingTimeInterval(1)),
+                    model: model,
+                    last: (input: 70, cached: 20, output: 7)),
+            ]))
+        try FileManager.default.setAttributes([.modificationDate: reportDay], ofItemAtPath: fileURL.path)
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: nil,
+            cacheRoot: env.cacheRoot,
+            codexTraceDatabaseURL: env.root.appendingPathComponent("missing-traces.sqlite"))
+        options.refreshMinIntervalSeconds = 0
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: reportDay,
+            until: reportDay,
+            now: reportDay,
+            options: options)
+
+        #expect(report.data.count == 1)
+        #expect(report.data[0].totalTokens == 77)
+    }
+
+    @Test
+    func `codex cold cache includes recent legacy file in mixed root`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let reportDay = try env.makeLocalNoon(year: 2026, month: 5, day: 18)
+        let model = "openai/gpt-5.2-codex"
+        _ = try env.writeCodexSessionFile(
+            day: reportDay,
+            filename: "partitioned.jsonl",
+            contents: env.jsonl([
+                self.codexTurnContext(timestamp: env.isoString(for: reportDay), model: model),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: reportDay.addingTimeInterval(1)),
+                    model: model,
+                    last: (input: 1, cached: 0, output: 1)),
+            ]))
+
+        let legacyDir = env.codexSessionsRoot.appendingPathComponent("project/subdir", isDirectory: true)
+        try FileManager.default.createDirectory(at: legacyDir, withIntermediateDirectories: true)
+        let legacyURL = legacyDir.appendingPathComponent("legacy-active.jsonl")
+        try env.jsonl([
+            self.codexTurnContext(timestamp: env.isoString(for: reportDay), model: model),
+            self.codexTokenCount(
+                timestamp: env.isoString(for: reportDay.addingTimeInterval(2)),
+                model: model,
+                last: (input: 30, cached: 10, output: 3)),
+        ]).write(to: legacyURL, atomically: true, encoding: .utf8)
+        try FileManager.default.setAttributes([.modificationDate: reportDay], ofItemAtPath: legacyURL.path)
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: nil,
+            cacheRoot: env.cacheRoot,
+            codexTraceDatabaseURL: env.root.appendingPathComponent("missing-traces.sqlite"))
+        options.refreshMinIntervalSeconds = 0
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: reportDay,
+            until: reportDay,
+            now: reportDay,
+            options: options)
+
+        #expect(report.data.count == 1)
+        #expect(report.data[0].totalTokens == 35)
+    }
+
+    @Test
+    func `codex forked child subtracts parent totals at fork timestamp`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let parentDay = try env.makeLocalNoon(year: 2026, month: 2, day: 27)
+        let childDay = try env.makeLocalNoon(year: 2026, month: 3, day: 11)
+        let parentTs0 = env.isoString(for: parentDay)
+        let parentTs1 = env.isoString(for: parentDay.addingTimeInterval(1))
+        let parentTs2 = env.isoString(for: parentDay.addingTimeInterval(2))
+        let parentTs3 = env.isoString(for: parentDay.addingTimeInterval(3))
+        let childForkTs = env.isoString(for: parentDay.addingTimeInterval(2.5))
+        let childTs1 = env.isoString(for: childDay.addingTimeInterval(1))
+        let childTs2 = env.isoString(for: childDay.addingTimeInterval(2))
+
+        let model = "openai/gpt-5.2-codex"
+        let parentSessionId = "sess-parent"
+        let childSessionId = "sess-child"
+
+        _ = try env.writeCodexSessionFile(
+            day: parentDay,
+            filename: "rollout-2026-02-27T11-29-28-\(parentSessionId).jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "session_meta",
+                    "payload": [
+                        "id": parentSessionId,
+                    ],
+                ],
+                [
+                    "type": "turn_context",
+                    "timestamp": parentTs0,
+                    "payload": [
+                        "model": model,
+                    ],
+                ],
+                [
+                    "type": "event_msg",
+                    "timestamp": parentTs1,
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "total_token_usage": [
+                                "input_tokens": 10,
+                                "cached_input_tokens": 2,
+                                "output_tokens": 1,
+                            ],
+                            "model": model,
+                        ],
+                    ],
+                ],
+                [
+                    "type": "event_msg",
+                    "timestamp": parentTs2,
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "total_token_usage": [
+                                "input_tokens": 20,
+                                "cached_input_tokens": 5,
+                                "output_tokens": 2,
+                            ],
+                            "model": model,
+                        ],
+                    ],
+                ],
+                [
+                    "type": "event_msg",
+                    "timestamp": parentTs3,
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "total_token_usage": [
+                                "input_tokens": 30,
+                                "cached_input_tokens": 8,
+                                "output_tokens": 3,
+                            ],
+                            "model": model,
+                        ],
+                    ],
+                ],
+            ]))
+
+        _ = try env.writeCodexSessionFile(
+            day: childDay,
+            filename: "rollout-2026-03-11T11-30-27-\(childSessionId).jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "session_meta",
+                    "payload": [
+                        "id": childSessionId,
+                        "forked_from_id": parentSessionId,
+                        "timestamp": childForkTs,
+                    ],
+                ],
+                [
+                    "type": "turn_context",
+                    "timestamp": childDay.ISO8601Format(),
+                    "payload": [
+                        "model": model,
+                    ],
+                ],
+                [
+                    "type": "event_msg",
+                    "timestamp": childTs1,
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "total_token_usage": [
+                                "input_tokens": 20,
+                                "cached_input_tokens": 5,
+                                "output_tokens": 2,
+                            ],
+                            "model": model,
+                        ],
+                    ],
+                ],
+                [
+                    "type": "event_msg",
+                    "timestamp": childTs2,
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "total_token_usage": [
+                                "input_tokens": 27,
+                                "cached_input_tokens": 7,
+                                "output_tokens": 4,
+                            ],
+                            "model": model,
+                        ],
+                    ],
+                ],
+            ]))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: nil,
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 0
+        options.forceRescan = true
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: childDay,
+            until: childDay,
+            now: childDay,
+            options: options)
+
+        let expectedCost = CostUsagePricing.codexCostUSD(
+            model: "gpt-5.2-codex",
+            inputTokens: 7,
+            cachedInputTokens: 2,
+            outputTokens: 2)
+
+        #expect(report.data.count == 1)
+        #expect(report.data[0].inputTokens == 7)
+        #expect(report.data[0].outputTokens == 2)
+        #expect(report.data[0].totalTokens == 9)
+        #expect(abs((report.data[0].costUSD ?? 0) - (expectedCost ?? 0)) < 0.000001)
+    }
+
+    @Test
+    func `codex forked child skips cumulative totals when parent session is missing`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let parentDay = try env.makeLocalNoon(year: 2026, month: 2, day: 27)
+        let childDay = try env.makeLocalNoon(year: 2026, month: 3, day: 11)
+        let model = "openai/gpt-5.2-codex"
+        let missingParentSessionId = "sess-parent-deleted"
+        let childSessionId = "sess-child-deleted-parent"
+        let forkTs = env.isoString(for: parentDay.addingTimeInterval(2.5))
+
+        _ = try env.writeCodexSessionFile(
+            day: childDay,
+            filename: "rollout-2026-03-11T11-30-27-\(childSessionId).jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "session_meta",
+                    "payload": [
+                        "id": childSessionId,
+                        "forked_from_id": missingParentSessionId,
+                        "timestamp": forkTs,
+                    ],
+                ],
+                self.codexTurnContext(timestamp: env.isoString(for: childDay), model: model),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: childDay.addingTimeInterval(1)),
+                    model: model,
+                    total: (input: 1_000_000, cached: 100_000, output: 10000)),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: childDay.addingTimeInterval(2)),
+                    model: model,
+                    total: (input: 1_000_120, cached: 100_010, output: 10020)),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: childDay.addingTimeInterval(3)),
+                    model: model,
+                    total: (input: 1_000_140, cached: 100_012, output: 10023),
+                    last: (input: 20, cached: 2, output: 3)),
+            ]))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: nil,
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 0
+        options.forceRescan = true
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: childDay,
+            until: childDay,
+            now: childDay,
+            options: options)
+
+        #expect(report.data.count == 1)
+        #expect(report.data[0].inputTokens == 20)
+        #expect(report.data[0].outputTokens == 3)
+        #expect(report.data[0].totalTokens == 23)
+    }
+
+    @Test
+    func `codex fork with total usage ignores replayed last snapshots`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 3, day: 11)
+        let iso0 = env.isoString(for: day)
+        let model = "openai/gpt-5.4"
+
+        let fileURL = try env.writeCodexSessionFile(
+            day: day,
+            filename: "rollout-\(iso0)-child-session.jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "session_meta",
+                    "timestamp": iso0,
+                    "payload": [
+                        "id": "child-session",
+                        "forked_from_id": "parent-session",
+                        "timestamp": iso0,
+                    ],
+                ],
+                self.codexTurnContext(timestamp: iso0, model: model),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: day.addingTimeInterval(1)),
+                    model: model,
+                    total: (input: 1000, cached: 900, output: 100),
+                    last: (input: 1000, cached: 900, output: 100)),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: day.addingTimeInterval(2)),
+                    model: model,
+                    total: (input: 1100, cached: 920, output: 110),
+                    last: (input: 40, cached: 20, output: 5)),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: day.addingTimeInterval(3)),
+                    model: model,
+                    total: (input: 1100, cached: 920, output: 110),
+                    last: (input: 40, cached: 20, output: 5)),
+            ]))
+        let range = CostUsageScanner.CostUsageDayRange(since: day, until: day)
+        let parsed = CostUsageScanner.parseCodexFile(
+            fileURL: fileURL,
+            range: range,
+            inheritedTotalsResolver: { parentSessionId, forkedAt in
+                #expect(parentSessionId == "parent-session")
+                #expect(forkedAt == iso0)
+                return .resolved(.init(input: 1000, cached: 900, output: 100))
+            })
+
+        let dayKey = CostUsageScanner.CostUsageDayRange.dayKey(from: day)
+        let normalized = CostUsagePricing.normalizeCodexModel(model)
+        let packed = parsed.days[dayKey]?[normalized] ?? []
+        #expect(packed.count >= 3)
+        #expect(packed[0] == 100)
+        #expect(packed[1] == 20)
+        #expect(packed[2] == 10)
+        #expect(parsed.rows.count == 1)
+        #expect(parsed.rows.first?.input == 100)
+        #expect(parsed.rows.first?.cached == 20)
+        #expect(parsed.rows.first?.output == 10)
+    }
+
+    @Test
+    func `codex fork skips last usage when parent baseline is unresolved`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 3, day: 11)
+        let iso0 = env.isoString(for: day)
+        let model = "openai/gpt-5.4"
+
+        let fileURL = try env.writeCodexSessionFile(
+            day: day,
+            filename: "rollout-\(iso0)-missing-parent.jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "session_meta",
+                    "timestamp": iso0,
+                    "payload": [
+                        "id": "child-session",
+                        "forked_from_id": "missing-parent",
+                        "timestamp": iso0,
+                    ],
+                ],
+                self.codexTurnContext(timestamp: iso0, model: model),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: day.addingTimeInterval(1)),
+                    model: model,
+                    total: (input: 1000, cached: 900, output: 100),
+                    last: (input: 1000, cached: 900, output: 100)),
+            ]))
+        let range = CostUsageScanner.CostUsageDayRange(since: day, until: day)
+        let parsed = CostUsageScanner.parseCodexFile(
+            fileURL: fileURL,
+            range: range,
+            inheritedTotalsResolver: { parentSessionId, _ in
+                #expect(parentSessionId == "missing-parent")
+                return .unresolved
+            })
+
+        let dayKey = CostUsageScanner.CostUsageDayRange.dayKey(from: day)
+        let normalized = CostUsagePricing.normalizeCodexModel(model)
+        #expect(parsed.days[dayKey]?[normalized] == nil)
+        #expect(parsed.rows.isEmpty)
+    }
+
+    @Test
+    func `codex unresolved fork ignores duplicated total and last replay after prefix`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 3, day: 11)
+        let iso0 = env.isoString(for: day)
+        let model = "openai/gpt-5.4"
+
+        let fileURL = try env.writeCodexSessionFile(
+            day: day,
+            filename: "rollout-\(iso0)-missing-parent-replay.jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "session_meta",
+                    "timestamp": iso0,
+                    "payload": [
+                        "id": "child-session",
+                        "forked_from_id": "missing-parent",
+                        "timestamp": iso0,
+                    ],
+                ],
+                self.codexTurnContext(timestamp: iso0, model: model),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: day.addingTimeInterval(1)),
+                    model: model,
+                    total: (input: 1000, cached: 900, output: 100)),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: day.addingTimeInterval(2)),
+                    model: model,
+                    total: (input: 1020, cached: 905, output: 105),
+                    last: (input: 20, cached: 5, output: 5)),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: day.addingTimeInterval(3)),
+                    model: model,
+                    total: (input: 1020, cached: 905, output: 105),
+                    last: (input: 20, cached: 5, output: 5)),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: day.addingTimeInterval(4)),
+                    model: model,
+                    total: (input: 1030, cached: 907, output: 108),
+                    last: (input: 10, cached: 2, output: 3)),
+            ]))
+        let range = CostUsageScanner.CostUsageDayRange(since: day, until: day)
+        let parsed = CostUsageScanner.parseCodexFile(
+            fileURL: fileURL,
+            range: range,
+            inheritedTotalsResolver: { parentSessionId, _ in
+                #expect(parentSessionId == "missing-parent")
+                return .unresolved
+            })
+
+        let dayKey = CostUsageScanner.CostUsageDayRange.dayKey(from: day)
+        let normalized = CostUsagePricing.normalizeCodexModel(model)
+        let packed = try #require(parsed.days[dayKey]?[normalized])
+        #expect(packed[0] == 30)
+        #expect(packed[1] == 7)
+        #expect(packed[2] == 8)
+        #expect(parsed.rows.count == 2)
+    }
+
+    @Test
+    func `codex empty fork parent id still counts cumulative totals`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 3, day: 11)
+        let model = "openai/gpt-5.2-codex"
+        let sessionId = "sess-empty-fork-parent"
+
+        _ = try env.writeCodexSessionFile(
+            day: day,
+            filename: "rollout-2026-03-11T11-30-27-\(sessionId).jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "session_meta",
+                    "payload": [
+                        "id": sessionId,
+                        "forked_from_id": "",
+                        "timestamp": env.isoString(for: day),
+                    ],
+                ],
+                self.codexTurnContext(timestamp: env.isoString(for: day.addingTimeInterval(1)), model: model),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: day.addingTimeInterval(2)),
+                    model: model,
+                    total: (input: 100, cached: 10, output: 5)),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: day.addingTimeInterval(3)),
+                    model: model,
+                    total: (input: 125, cached: 12, output: 8)),
+            ]))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: nil,
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 0
+        options.forceRescan = true
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+
+        #expect(report.data.count == 1)
+        #expect(report.data[0].inputTokens == 125)
+        #expect(report.data[0].outputTokens == 8)
+        #expect(report.data[0].totalTokens == 133)
+    }
+
+    @Test
+    func `codex forked child inherits counted parent totals when totals diverge`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let parentDay = try env.makeLocalNoon(year: 2026, month: 2, day: 27)
+        let childDay = try env.makeLocalNoon(year: 2026, month: 3, day: 11)
+        let model = "openai/gpt-5.2-codex"
+        let parentSessionId = "sess-parent-diverged"
+        let childSessionId = "sess-child-diverged"
+        let forkTs = env.isoString(for: parentDay.addingTimeInterval(2.5))
+
+        _ = try env.writeCodexSessionFile(
+            day: parentDay,
+            filename: "rollout-2026-02-27T11-29-28-\(parentSessionId).jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "session_meta",
+                    "payload": [
+                        "id": parentSessionId,
+                    ],
+                ],
+                self.codexTurnContext(timestamp: env.isoString(for: parentDay), model: model),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: parentDay.addingTimeInterval(1)),
+                    model: model,
+                    total: (input: 100, cached: 0, output: 0),
+                    last: (input: 100, cached: 0, output: 0)),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: parentDay.addingTimeInterval(2)),
+                    model: model,
+                    total: (input: 1000, cached: 0, output: 0),
+                    last: (input: 40, cached: 0, output: 0)),
+            ]))
+
+        _ = try env.writeCodexSessionFile(
+            day: childDay,
+            filename: "rollout-2026-03-11T11-30-27-\(childSessionId).jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "session_meta",
+                    "payload": [
+                        "id": childSessionId,
+                        "forked_from_id": parentSessionId,
+                        "timestamp": forkTs,
+                    ],
+                ],
+                self.codexTurnContext(timestamp: env.isoString(for: childDay), model: model),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: childDay.addingTimeInterval(1)),
+                    model: model,
+                    total: (input: 140, cached: 0, output: 0)),
+                self.codexTokenCount(
+                    timestamp: env.isoString(for: childDay.addingTimeInterval(2)),
+                    model: model,
+                    total: (input: 170, cached: 0, output: 0)),
+            ]))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: nil,
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 0
+        options.forceRescan = true
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: childDay,
+            until: childDay,
+            now: childDay,
+            options: options)
+
+        #expect(report.data.count == 1)
+        #expect(report.data[0].inputTokens == 30)
+        #expect(report.data[0].totalTokens == 30)
+    }
+
+    @Test
+    func `codex forked child subtracts inherited replay from last token usage`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let parentDay = try env.makeLocalNoon(year: 2026, month: 2, day: 27)
+        let childDay = try env.makeLocalNoon(year: 2026, month: 3, day: 11)
+        let parentTs0 = env.isoString(for: parentDay)
+        let parentTs1 = env.isoString(for: parentDay.addingTimeInterval(1))
+        let parentTs2 = env.isoString(for: parentDay.addingTimeInterval(2))
+        let childTs1 = env.isoString(for: childDay.addingTimeInterval(1))
+        let childTs2 = env.isoString(for: childDay.addingTimeInterval(2))
+        let childTs3 = env.isoString(for: childDay.addingTimeInterval(3))
+
+        let model = "openai/gpt-5.2-codex"
+        let parentSessionId = "sess-parent-last"
+        let childSessionId = "sess-child-last"
+        let forkTs = env.isoString(for: parentDay.addingTimeInterval(2.5))
+
+        _ = try env.writeCodexSessionFile(
+            day: parentDay,
+            filename: "rollout-2026-02-27T11-29-28-\(parentSessionId).jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "session_meta",
+                    "payload": [
+                        "id": parentSessionId,
+                    ],
+                ],
+                [
+                    "type": "turn_context",
+                    "timestamp": parentTs0,
+                    "payload": [
+                        "model": model,
+                    ],
+                ],
+                [
+                    "type": "event_msg",
+                    "timestamp": parentTs1,
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "total_token_usage": [
+                                "input_tokens": 10,
+                                "cached_input_tokens": 2,
+                                "output_tokens": 1,
+                            ],
+                            "model": model,
+                        ],
+                    ],
+                ],
+                [
+                    "type": "event_msg",
+                    "timestamp": parentTs2,
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "total_token_usage": [
+                                "input_tokens": 20,
+                                "cached_input_tokens": 5,
+                                "output_tokens": 2,
+                            ],
+                            "model": model,
+                        ],
+                    ],
+                ],
+            ]))
+
+        _ = try env.writeCodexSessionFile(
+            day: childDay,
+            filename: "rollout-2026-03-11T11-30-27-\(childSessionId).jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "session_meta",
+                    "payload": [
+                        "id": childSessionId,
+                        "forked_from_id": parentSessionId,
+                        "timestamp": forkTs,
+                    ],
+                ],
+                [
+                    "type": "turn_context",
+                    "timestamp": childDay.ISO8601Format(),
+                    "payload": [
+                        "model": model,
+                    ],
+                ],
+                [
+                    "type": "event_msg",
+                    "timestamp": childTs1,
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "last_token_usage": [
+                                "input_tokens": 10,
+                                "cached_input_tokens": 2,
+                                "output_tokens": 1,
+                            ],
+                            "model": model,
+                        ],
+                    ],
+                ],
+                [
+                    "type": "event_msg",
+                    "timestamp": childTs2,
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "last_token_usage": [
+                                "input_tokens": 10,
+                                "cached_input_tokens": 3,
+                                "output_tokens": 1,
+                            ],
+                            "model": model,
+                        ],
+                    ],
+                ],
+                [
+                    "type": "event_msg",
+                    "timestamp": childTs3,
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "last_token_usage": [
+                                "input_tokens": 7,
+                                "cached_input_tokens": 2,
+                                "output_tokens": 2,
+                            ],
+                            "model": model,
+                        ],
+                    ],
+                ],
+            ]))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: nil,
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 0
+        options.forceRescan = true
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: childDay,
+            until: childDay,
+            now: childDay,
+            options: options)
+
+        let expectedCost = CostUsagePricing.codexCostUSD(
+            model: model,
+            inputTokens: 7,
+            cachedInputTokens: 2,
+            outputTokens: 2)
+
+        #expect(report.data.count == 1)
+        #expect(report.data[0].inputTokens == 7)
+        #expect(report.data[0].outputTokens == 2)
+        #expect(report.data[0].totalTokens == 9)
+        #expect(abs((report.data[0].costUSD ?? 0) - (expectedCost ?? 0)) < 0.000001)
+    }
+
+    @Test
+    // swiftlint:disable:next function_body_length
+    func `codex forked child ignores replayed parent prefix sequence`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let parentDay = try env.makeLocalNoon(year: 2026, month: 2, day: 27)
+        let childDay = try env.makeLocalNoon(year: 2026, month: 3, day: 11)
+        let model = "openai/gpt-5.2-codex"
+        let parentSessionId = "sess-parent-prefix"
+        let childSessionId = "sess-child-prefix"
+        let forkTs = env.isoString(for: parentDay.addingTimeInterval(5))
+
+        let parentEvents: [[String: Any]] = [
+            [
+                "type": "session_meta",
+                "payload": [
+                    "id": parentSessionId,
+                ],
+            ],
+            [
+                "type": "turn_context",
+                "timestamp": env.isoString(for: parentDay),
+                "payload": [
+                    "model": model,
+                ],
+            ],
+            [
+                "type": "event_msg",
+                "timestamp": env.isoString(for: parentDay.addingTimeInterval(1)),
+                "payload": [
+                    "type": "token_count",
+                    "info": [
+                        "total_token_usage": [
+                            "input_tokens": 10,
+                            "cached_input_tokens": 2,
+                            "output_tokens": 1,
+                        ],
+                        "model": model,
+                    ],
+                ],
+            ],
+            [
+                "type": "event_msg",
+                "timestamp": env.isoString(for: parentDay.addingTimeInterval(2)),
+                "payload": [
+                    "type": "token_count",
+                    "info": [
+                        "total_token_usage": [
+                            "input_tokens": 20,
+                            "cached_input_tokens": 5,
+                            "output_tokens": 2,
+                        ],
+                        "model": model,
+                    ],
+                ],
+            ],
+            [
+                "type": "event_msg",
+                "timestamp": env.isoString(for: parentDay.addingTimeInterval(3)),
+                "payload": [
+                    "type": "token_count",
+                    "info": [
+                        "total_token_usage": [
+                            "input_tokens": 30,
+                            "cached_input_tokens": 8,
+                            "output_tokens": 3,
+                        ],
+                        "model": model,
+                    ],
+                ],
+            ],
+        ]
+        _ = try env.writeCodexSessionFile(
+            day: parentDay,
+            filename: "rollout-2026-02-27T11-29-28-\(parentSessionId).jsonl",
+            contents: env.jsonl(parentEvents))
+
+        let childEvents: [[String: Any]] = [
+            [
+                "type": "session_meta",
+                "payload": [
+                    "id": childSessionId,
+                    "forked_from_id": parentSessionId,
+                    "timestamp": forkTs,
+                ],
+            ],
+            [
+                "type": "turn_context",
+                "timestamp": env.isoString(for: childDay),
+                "payload": [
+                    "model": model,
+                ],
+            ],
+            [
+                "type": "event_msg",
+                "timestamp": env.isoString(for: childDay.addingTimeInterval(1)),
+                "payload": [
+                    "type": "token_count",
+                    "info": [
+                        "total_token_usage": [
+                            "input_tokens": 10,
+                            "cached_input_tokens": 2,
+                            "output_tokens": 1,
+                        ],
+                        "model": model,
+                    ],
+                ],
+            ],
+            [
+                "type": "event_msg",
+                "timestamp": env.isoString(for: childDay.addingTimeInterval(2)),
+                "payload": [
+                    "type": "token_count",
+                    "info": [
+                        "total_token_usage": [
+                            "input_tokens": 20,
+                            "cached_input_tokens": 5,
+                            "output_tokens": 2,
+                        ],
+                        "model": model,
+                    ],
+                ],
+            ],
+            [
+                "type": "event_msg",
+                "timestamp": env.isoString(for: childDay.addingTimeInterval(3)),
+                "payload": [
+                    "type": "token_count",
+                    "info": [
+                        "total_token_usage": [
+                            "input_tokens": 30,
+                            "cached_input_tokens": 8,
+                            "output_tokens": 3,
+                        ],
+                        "model": model,
+                    ],
+                ],
+            ],
+            [
+                "type": "event_msg",
+                "timestamp": env.isoString(for: childDay.addingTimeInterval(4)),
+                "payload": [
+                    "type": "token_count",
+                    "info": [
+                        "total_token_usage": [
+                            "input_tokens": 30,
+                            "cached_input_tokens": 8,
+                            "output_tokens": 3,
+                        ],
+                        "model": model,
+                    ],
+                ],
+            ],
+            [
+                "type": "event_msg",
+                "timestamp": env.isoString(for: childDay.addingTimeInterval(5)),
+                "payload": [
+                    "type": "token_count",
+                    "info": [
+                        "total_token_usage": [
+                            "input_tokens": 35,
+                            "cached_input_tokens": 9,
+                            "output_tokens": 4,
+                        ],
+                        "model": model,
+                    ],
+                ],
+            ],
+            [
+                "type": "event_msg",
+                "timestamp": env.isoString(for: childDay.addingTimeInterval(6)),
+                "payload": [
+                    "type": "token_count",
+                    "info": [
+                        "total_token_usage": [
+                            "input_tokens": 42,
+                            "cached_input_tokens": 11,
+                            "output_tokens": 5,
+                        ],
+                        "model": model,
+                    ],
+                ],
+            ],
+        ]
+        _ = try env.writeCodexSessionFile(
+            day: childDay,
+            filename: "rollout-2026-03-11T11-30-27-\(childSessionId).jsonl",
+            contents: env.jsonl(childEvents))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: nil,
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 0
+        options.forceRescan = true
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: childDay,
+            until: childDay,
+            now: childDay,
+            options: options)
+
+        let expectedCost = CostUsagePricing.codexCostUSD(
+            model: "gpt-5.2-codex",
+            inputTokens: 12,
+            cachedInputTokens: 3,
+            outputTokens: 2)
+
+        #expect(report.data.count == 1)
+        #expect(report.data[0].inputTokens == 12)
+        #expect(report.data[0].outputTokens == 2)
+        #expect(report.data[0].totalTokens == 14)
+        #expect(abs((report.data[0].costUSD ?? 0) - (expectedCost ?? 0)) < 0.000001)
+    }
+
+    @Test
+    // swiftlint:disable:next function_body_length
+    func `codex forked child subtracts inherited replay even when session meta appears late`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let parentDay = try env.makeLocalNoon(year: 2026, month: 2, day: 27)
+        let childDay = try env.makeLocalNoon(year: 2026, month: 3, day: 11)
+        let model = "openai/gpt-5.2-codex"
+        let parentSessionId = "sess-parent-late-meta"
+        let childSessionId = "sess-child-late-meta"
+        let forkTs = env.isoString(for: parentDay.addingTimeInterval(5))
+
+        let parentEvents: [[String: Any]] = [
+            [
+                "type": "session_meta",
+                "payload": [
+                    "id": parentSessionId,
+                ],
+            ],
+            [
+                "type": "turn_context",
+                "timestamp": env.isoString(for: parentDay),
+                "payload": [
+                    "model": model,
+                ],
+            ],
+            [
+                "type": "event_msg",
+                "timestamp": env.isoString(for: parentDay.addingTimeInterval(1)),
+                "payload": [
+                    "type": "token_count",
+                    "info": [
+                        "total_token_usage": [
+                            "input_tokens": 10,
+                            "cached_input_tokens": 2,
+                            "output_tokens": 1,
+                        ],
+                        "model": model,
+                    ],
+                ],
+            ],
+            [
+                "type": "event_msg",
+                "timestamp": env.isoString(for: parentDay.addingTimeInterval(2)),
+                "payload": [
+                    "type": "token_count",
+                    "info": [
+                        "total_token_usage": [
+                            "input_tokens": 20,
+                            "cached_input_tokens": 5,
+                            "output_tokens": 2,
+                        ],
+                        "model": model,
+                    ],
+                ],
+            ],
+            [
+                "type": "event_msg",
+                "timestamp": env.isoString(for: parentDay.addingTimeInterval(3)),
+                "payload": [
+                    "type": "token_count",
+                    "info": [
+                        "total_token_usage": [
+                            "input_tokens": 30,
+                            "cached_input_tokens": 8,
+                            "output_tokens": 3,
+                        ],
+                        "model": model,
+                    ],
+                ],
+            ],
+        ]
+        _ = try env.writeCodexSessionFile(
+            day: parentDay,
+            filename: "rollout-2026-02-27T11-29-28-\(parentSessionId).jsonl",
+            contents: env.jsonl(parentEvents))
+
+        let childEvents: [[String: Any]] = [
+            [
+                "type": "turn_context",
+                "timestamp": env.isoString(for: childDay),
+                "payload": [
+                    "model": model,
+                ],
+            ],
+            [
+                "type": "event_msg",
+                "timestamp": env.isoString(for: childDay.addingTimeInterval(1)),
+                "payload": [
+                    "type": "token_count",
+                    "info": [
+                        "total_token_usage": [
+                            "input_tokens": 10,
+                            "cached_input_tokens": 2,
+                            "output_tokens": 1,
+                        ],
+                        "model": model,
+                    ],
+                ],
+            ],
+            [
+                "type": "event_msg",
+                "timestamp": env.isoString(for: childDay.addingTimeInterval(2)),
+                "payload": [
+                    "type": "token_count",
+                    "info": [
+                        "total_token_usage": [
+                            "input_tokens": 20,
+                            "cached_input_tokens": 5,
+                            "output_tokens": 2,
+                        ],
+                        "model": model,
+                    ],
+                ],
+            ],
+            [
+                "type": "event_msg",
+                "timestamp": env.isoString(for: childDay.addingTimeInterval(3)),
+                "payload": [
+                    "type": "token_count",
+                    "info": [
+                        "total_token_usage": [
+                            "input_tokens": 30,
+                            "cached_input_tokens": 8,
+                            "output_tokens": 3,
+                        ],
+                        "model": model,
+                    ],
+                ],
+            ],
+            [
+                "type": "session_meta",
+                "payload": [
+                    "id": childSessionId,
+                    "forked_from_id": parentSessionId,
+                    "timestamp": forkTs,
+                ],
+            ],
+            [
+                "type": "event_msg",
+                "timestamp": env.isoString(for: childDay.addingTimeInterval(4)),
+                "payload": [
+                    "type": "token_count",
+                    "info": [
+                        "total_token_usage": [
+                            "input_tokens": 35,
+                            "cached_input_tokens": 9,
+                            "output_tokens": 4,
+                        ],
+                        "model": model,
+                    ],
+                ],
+            ],
+            [
+                "type": "event_msg",
+                "timestamp": env.isoString(for: childDay.addingTimeInterval(5)),
+                "payload": [
+                    "type": "token_count",
+                    "info": [
+                        "total_token_usage": [
+                            "input_tokens": 42,
+                            "cached_input_tokens": 11,
+                            "output_tokens": 5,
+                        ],
+                        "model": model,
+                    ],
+                ],
+            ],
+        ]
+        _ = try env.writeCodexSessionFile(
+            day: childDay,
+            filename: "rollout-2026-03-11T11-30-27-\(childSessionId).jsonl",
+            contents: env.jsonl(childEvents))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: nil,
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 0
+        options.forceRescan = true
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: childDay,
+            until: childDay,
+            now: childDay,
+            options: options)
+
+        let expectedCost = CostUsagePricing.codexCostUSD(
+            model: "gpt-5.2-codex",
+            inputTokens: 12,
+            cachedInputTokens: 3,
+            outputTokens: 2)
+
+        #expect(report.data.count == 1)
+        #expect(report.data[0].inputTokens == 12)
+        #expect(report.data[0].outputTokens == 2)
+        #expect(report.data[0].totalTokens == 14)
+        #expect(abs((report.data[0].costUSD ?? 0) - (expectedCost ?? 0)) < 0.000001)
+    }
+
+    @Test
+    func `codex forked child resolves parent when parent session file is a symlink`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let parentDay = try env.makeLocalNoon(year: 2026, month: 2, day: 27)
+        let childDay = try env.makeLocalNoon(year: 2026, month: 3, day: 11)
+        let model = "openai/gpt-5.2-codex"
+        let parentSessionId = "sess-parent-symlink"
+        let childSessionId = "sess-child-symlink"
+        let forkTs = env.isoString(for: parentDay.addingTimeInterval(3))
+
+        let parentContents = try env.jsonl([
+            [
+                "type": "session_meta",
+                "payload": [
+                    "id": parentSessionId,
+                ],
+            ],
+            [
+                "type": "turn_context",
+                "timestamp": env.isoString(for: parentDay),
+                "payload": [
+                    "model": model,
+                ],
+            ],
+            [
+                "type": "event_msg",
+                "timestamp": env.isoString(for: parentDay.addingTimeInterval(1)),
+                "payload": [
+                    "type": "token_count",
+                    "info": [
+                        "total_token_usage": [
+                            "input_tokens": 10,
+                            "cached_input_tokens": 2,
+                            "output_tokens": 1,
+                        ],
+                        "model": model,
+                    ],
+                ],
+            ],
+            [
+                "type": "event_msg",
+                "timestamp": env.isoString(for: parentDay.addingTimeInterval(2)),
+                "payload": [
+                    "type": "token_count",
+                    "info": [
+                        "total_token_usage": [
+                            "input_tokens": 20,
+                            "cached_input_tokens": 5,
+                            "output_tokens": 2,
+                        ],
+                        "model": model,
+                    ],
+                ],
+            ],
+        ])
+
+        let parentTarget = env.root.appendingPathComponent("parent-target.jsonl", isDirectory: false)
+        try parentContents.write(to: parentTarget, atomically: true, encoding: .utf8)
+
+        let comps = Calendar.current.dateComponents([.year, .month, .day], from: parentDay)
+        let parentDir = env.codexSessionsRoot
+            .appendingPathComponent(String(format: "%04d", comps.year ?? 1970), isDirectory: true)
+            .appendingPathComponent(String(format: "%02d", comps.month ?? 1), isDirectory: true)
+            .appendingPathComponent(String(format: "%02d", comps.day ?? 1), isDirectory: true)
+        try FileManager.default.createDirectory(at: parentDir, withIntermediateDirectories: true)
+        let parentLink = parentDir.appendingPathComponent(
+            "rollout-2026-02-27T11-29-28-\(parentSessionId).jsonl",
+            isDirectory: false)
+        try FileManager.default.createSymbolicLink(at: parentLink, withDestinationURL: parentTarget)
+
+        _ = try env.writeCodexSessionFile(
+            day: childDay,
+            filename: "rollout-2026-03-11T11-30-27-\(childSessionId).jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "session_meta",
+                    "payload": [
+                        "id": childSessionId,
+                        "forked_from_id": parentSessionId,
+                        "timestamp": forkTs,
+                    ],
+                ],
+                [
+                    "type": "turn_context",
+                    "timestamp": env.isoString(for: childDay),
+                    "payload": [
+                        "model": model,
+                    ],
+                ],
+                [
+                    "type": "event_msg",
+                    "timestamp": env.isoString(for: childDay.addingTimeInterval(1)),
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "total_token_usage": [
+                                "input_tokens": 20,
+                                "cached_input_tokens": 5,
+                                "output_tokens": 2,
+                            ],
+                            "model": model,
+                        ],
+                    ],
+                ],
+                [
+                    "type": "event_msg",
+                    "timestamp": env.isoString(for: childDay.addingTimeInterval(2)),
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "total_token_usage": [
+                                "input_tokens": 27,
+                                "cached_input_tokens": 7,
+                                "output_tokens": 4,
+                            ],
+                            "model": model,
+                        ],
+                    ],
+                ],
+            ]))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: nil,
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 0
+        options.forceRescan = true
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: childDay,
+            until: childDay,
+            now: childDay,
+            options: options)
+
+        let expectedCost = CostUsagePricing.codexCostUSD(
+            model: "gpt-5.2-codex",
+            inputTokens: 7,
+            cachedInputTokens: 2,
+            outputTokens: 2)
+
+        #expect(report.data.count == 1)
+        #expect(report.data[0].inputTokens == 7)
+        #expect(report.data[0].outputTokens == 2)
+        #expect(report.data[0].totalTokens == 9)
+        #expect(abs((report.data[0].costUSD ?? 0) - (expectedCost ?? 0)) < 0.000001)
+    }
+
+    @Test
+    // swiftlint:disable:next function_body_length
+    func `codex forked child resolves parent by exact session meta id`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let parentDay = try env.makeLocalNoon(year: 2026, month: 2, day: 27)
+        let childDay = try env.makeLocalNoon(year: 2026, month: 3, day: 11)
+        let model = "openai/gpt-5.2-codex"
+        let wantedParentSessionId = "sess-parent-exact"
+        let wrongParentSessionId = "sess-parent-exact-extra"
+        let childSessionId = "sess-child-exact"
+        let forkTs = env.isoString(for: parentDay.addingTimeInterval(3))
+
+        _ = try env.writeCodexSessionFile(
+            day: parentDay,
+            filename: "rollout-2026-02-27T11-29-28-\(wrongParentSessionId).jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "session_meta",
+                    "payload": [
+                        "id": wrongParentSessionId,
+                    ],
+                ],
+                [
+                    "type": "turn_context",
+                    "timestamp": env.isoString(for: parentDay),
+                    "payload": [
+                        "model": model,
+                    ],
+                ],
+                [
+                    "type": "event_msg",
+                    "timestamp": env.isoString(for: parentDay.addingTimeInterval(1)),
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "total_token_usage": [
+                                "input_tokens": 1000,
+                                "cached_input_tokens": 100,
+                                "output_tokens": 100,
+                            ],
+                            "model": model,
+                        ],
+                    ],
+                ],
+            ]))
+
+        _ = try env.writeCodexSessionFile(
+            day: parentDay,
+            filename: "rollout-2026-02-27T11-29-29-\(wantedParentSessionId).jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "session_meta",
+                    "payload": [
+                        "id": wantedParentSessionId,
+                    ],
+                ],
+                [
+                    "type": "turn_context",
+                    "timestamp": env.isoString(for: parentDay),
+                    "payload": [
+                        "model": model,
+                    ],
+                ],
+                [
+                    "type": "event_msg",
+                    "timestamp": env.isoString(for: parentDay.addingTimeInterval(1)),
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "total_token_usage": [
+                                "input_tokens": 20,
+                                "cached_input_tokens": 5,
+                                "output_tokens": 2,
+                            ],
+                            "model": model,
+                        ],
+                    ],
+                ],
+                [
+                    "type": "event_msg",
+                    "timestamp": env.isoString(for: parentDay.addingTimeInterval(2)),
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "total_token_usage": [
+                                "input_tokens": 30,
+                                "cached_input_tokens": 8,
+                                "output_tokens": 3,
+                            ],
+                            "model": model,
+                        ],
+                    ],
+                ],
+            ]))
+
+        _ = try env.writeCodexSessionFile(
+            day: childDay,
+            filename: "rollout-2026-03-11T11-30-27-\(childSessionId).jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "session_meta",
+                    "payload": [
+                        "id": childSessionId,
+                        "forked_from_id": wantedParentSessionId,
+                        "timestamp": forkTs,
+                    ],
+                ],
+                [
+                    "type": "turn_context",
+                    "timestamp": env.isoString(for: childDay),
+                    "payload": [
+                        "model": model,
+                    ],
+                ],
+                [
+                    "type": "event_msg",
+                    "timestamp": env.isoString(for: childDay.addingTimeInterval(1)),
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "total_token_usage": [
+                                "input_tokens": 35,
+                                "cached_input_tokens": 9,
+                                "output_tokens": 4,
+                            ],
+                            "model": model,
+                        ],
+                    ],
+                ],
+                [
+                    "type": "event_msg",
+                    "timestamp": env.isoString(for: childDay.addingTimeInterval(2)),
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "total_token_usage": [
+                                "input_tokens": 42,
+                                "cached_input_tokens": 11,
+                                "output_tokens": 5,
+                            ],
+                            "model": model,
+                        ],
+                    ],
+                ],
+            ]))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: nil,
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 0
+        options.forceRescan = true
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: childDay,
+            until: childDay,
+            now: childDay,
+            options: options)
+
+        let expectedCost = CostUsagePricing.codexCostUSD(
+            model: "gpt-5.2-codex",
+            inputTokens: 12,
+            cachedInputTokens: 3,
+            outputTokens: 2)
+
+        #expect(report.data.count == 1)
+        #expect(report.data[0].inputTokens == 12)
+        #expect(report.data[0].outputTokens == 2)
+        #expect(report.data[0].totalTokens == 14)
+        #expect(abs((report.data[0].costUSD ?? 0) - (expectedCost ?? 0)) < 0.000001)
+    }
+
+    @Test
+    func `codex forked child compares parent snapshots by parsed timestamp`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let parentDay = try env.makeLocalNoon(year: 2026, month: 2, day: 27)
+        let childDay = try env.makeLocalNoon(year: 2026, month: 3, day: 11)
+        let model = "openai/gpt-5.2-codex"
+        let parentSessionId = "sess-parent-timestamp"
+        let childSessionId = "sess-child-timestamp"
+
+        _ = try env.writeCodexSessionFile(
+            day: parentDay,
+            filename: "rollout-2026-02-27T11-29-28-\(parentSessionId).jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "session_meta",
+                    "payload": [
+                        "id": parentSessionId,
+                    ],
+                ],
+                [
+                    "type": "turn_context",
+                    "timestamp": "2026-02-27T23:59:58Z",
+                    "payload": [
+                        "model": model,
+                    ],
+                ],
+                [
+                    "type": "event_msg",
+                    "timestamp": "2026-02-27T23:59:59Z",
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "total_token_usage": [
+                                "input_tokens": 20,
+                                "cached_input_tokens": 5,
+                                "output_tokens": 2,
+                            ],
+                            "model": model,
+                        ],
+                    ],
+                ],
+                [
+                    "type": "event_msg",
+                    "timestamp": "2026-02-28T00:00:01Z",
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "total_token_usage": [
+                                "input_tokens": 100,
+                                "cached_input_tokens": 20,
+                                "output_tokens": 10,
+                            ],
+                            "model": model,
+                        ],
+                    ],
+                ],
+            ]))
+
+        _ = try env.writeCodexSessionFile(
+            day: childDay,
+            filename: "rollout-2026-03-11T11-30-27-\(childSessionId).jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "session_meta",
+                    "payload": [
+                        "id": childSessionId,
+                        "forked_from_id": parentSessionId,
+                        "timestamp": "2026-02-28T08:00:00+08:00",
+                    ],
+                ],
+                [
+                    "type": "turn_context",
+                    "timestamp": env.isoString(for: childDay),
+                    "payload": [
+                        "model": model,
+                    ],
+                ],
+                [
+                    "type": "event_msg",
+                    "timestamp": env.isoString(for: childDay.addingTimeInterval(1)),
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "total_token_usage": [
+                                "input_tokens": 25,
+                                "cached_input_tokens": 7,
+                                "output_tokens": 4,
+                            ],
+                            "model": model,
+                        ],
+                    ],
+                ],
+                [
+                    "type": "event_msg",
+                    "timestamp": env.isoString(for: childDay.addingTimeInterval(2)),
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "total_token_usage": [
+                                "input_tokens": 30,
+                                "cached_input_tokens": 10,
+                                "output_tokens": 6,
+                            ],
+                            "model": model,
+                        ],
+                    ],
+                ],
+            ]))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: nil,
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 0
+        options.forceRescan = true
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: childDay,
+            until: childDay,
+            now: childDay,
+            options: options)
+
+        let expectedCost = CostUsagePricing.codexCostUSD(
+            model: model,
+            inputTokens: 10,
+            cachedInputTokens: 5,
+            outputTokens: 4)
+
+        #expect(report.data.count == 1)
+        #expect(report.data[0].inputTokens == 10)
+        #expect(report.data[0].outputTokens == 4)
+        #expect(report.data[0].totalTokens == 14)
+        #expect(abs((report.data[0].costUSD ?? 0) - (expectedCost ?? 0)) < 0.000001)
+    }
+
+    @Test
+    func `codex first refresh keeps unrelated archived sessions out of cache`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let reportDay = try env.makeLocalNoon(year: 2026, month: 3, day: 11)
+        let archivedDay = try env.makeLocalNoon(year: 2025, month: 1, day: 1)
+        let model = "openai/gpt-5.2-codex"
+
+        _ = try env.writeCodexSessionFile(
+            day: reportDay,
+            filename: "rollout-2026-03-11T11-30-27-session-recent.jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "turn_context",
+                    "timestamp": env.isoString(for: reportDay),
+                    "payload": [
+                        "model": model,
+                    ],
+                ],
+                [
+                    "type": "event_msg",
+                    "timestamp": env.isoString(for: reportDay.addingTimeInterval(1)),
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "last_token_usage": [
+                                "input_tokens": 7,
+                                "cached_input_tokens": 2,
+                                "output_tokens": 2,
+                            ],
+                            "model": model,
+                        ],
+                    ],
+                ],
+            ]))
+
+        let archivedURL = try env.writeCodexArchivedSessionFile(
+            filename: "rollout-2025-01-01T12-00-00-session-archived.jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "turn_context",
+                    "timestamp": env.isoString(for: archivedDay),
+                    "payload": [
+                        "model": model,
+                    ],
+                ],
+                [
+                    "type": "event_msg",
+                    "timestamp": env.isoString(for: archivedDay.addingTimeInterval(1)),
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "last_token_usage": [
+                                "input_tokens": 100,
+                                "cached_input_tokens": 10,
+                                "output_tokens": 5,
+                            ],
+                            "model": model,
+                        ],
+                    ],
+                ],
+            ]))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: nil,
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 0
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: reportDay,
+            until: reportDay,
+            now: reportDay,
+            options: options)
+
+        let cache = CostUsageCacheIO.load(provider: .codex, cacheRoot: env.cacheRoot)
+
+        #expect(report.data.count == 1)
+        #expect(cache.files.keys.contains { $0.hasSuffix("session-recent.jsonl") })
+        #expect(!cache.files.keys.contains(archivedURL.path))
+    }
+
+    @Test
+    func `codex root switch reloads long lived sessions from older partitions`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        func writeSessionFile(
+            root: URL,
+            day: Date,
+            filename: String,
+            contents: String) throws -> URL
+        {
+            let comps = Calendar.current.dateComponents([.year, .month, .day], from: day)
+            let dir = root
+                .appendingPathComponent(String(format: "%04d", comps.year ?? 1970), isDirectory: true)
+                .appendingPathComponent(String(format: "%02d", comps.month ?? 1), isDirectory: true)
+                .appendingPathComponent(String(format: "%02d", comps.day ?? 1), isDirectory: true)
+            try FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+            let url = dir.appendingPathComponent(filename, isDirectory: false)
+            try contents.write(to: url, atomically: true, encoding: .utf8)
+            return url
+        }
+
+        let fileDay = try env.makeLocalNoon(year: 2026, month: 2, day: 27)
+        let reportDay = try env.makeLocalNoon(year: 2026, month: 3, day: 11)
+        let model = "openai/gpt-5.2-codex"
+        let otherSessionsRoot = env.root
+            .appendingPathComponent("other-codex-home", isDirectory: true)
+            .appendingPathComponent("sessions", isDirectory: true)
+        try FileManager.default.createDirectory(at: otherSessionsRoot, withIntermediateDirectories: true)
+
+        let oldRootURL = try env.writeCodexSessionFile(
+            day: reportDay,
+            filename: "rollout-2026-03-11T11-30-27-session-old-root.jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "turn_context",
+                    "timestamp": env.isoString(for: reportDay),
+                    "payload": [
+                        "model": model,
+                    ],
+                ],
+                [
+                    "type": "event_msg",
+                    "timestamp": env.isoString(for: reportDay.addingTimeInterval(1)),
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "last_token_usage": [
+                                "input_tokens": 7,
+                                "cached_input_tokens": 2,
+                                "output_tokens": 2,
+                            ],
+                            "model": model,
+                        ],
+                    ],
+                ],
+            ]))
+
+        _ = try writeSessionFile(
+            root: otherSessionsRoot,
+            day: fileDay,
+            filename: "rollout-2026-02-27T11-30-27-session-new-root.jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "turn_context",
+                    "timestamp": env.isoString(for: reportDay),
+                    "payload": [
+                        "model": model,
+                    ],
+                ],
+                [
+                    "type": "event_msg",
+                    "timestamp": env.isoString(for: reportDay.addingTimeInterval(1)),
+                    "payload": [
+                        "type": "token_count",
+                        "info": [
+                            "last_token_usage": [
+                                "input_tokens": 10,
+                                "cached_input_tokens": 5,
+                                "output_tokens": 4,
+                            ],
+                            "model": model,
+                        ],
+                    ],
+                ],
+            ]))
+
+        var firstOptions = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: nil,
+            cacheRoot: env.cacheRoot)
+        firstOptions.refreshMinIntervalSeconds = 0
+
+        _ = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: reportDay,
+            until: reportDay,
+            now: reportDay,
+            options: firstOptions)
+
+        var secondOptions = CostUsageScanner.Options(
+            codexSessionsRoot: otherSessionsRoot,
+            claudeProjectsRoots: nil,
+            cacheRoot: env.cacheRoot)
+        secondOptions.refreshMinIntervalSeconds = 0
+
+        let secondReport = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: reportDay,
+            until: reportDay,
+            now: reportDay,
+            options: secondOptions)
+
+        let cache = CostUsageCacheIO.load(provider: .codex, cacheRoot: env.cacheRoot)
+
+        #expect(secondReport.data.count == 1)
+        #expect(secondReport.data[0].inputTokens == 10)
+        #expect(secondReport.data[0].outputTokens == 4)
+        #expect(secondReport.data[0].totalTokens == 14)
+        #expect(!cache.files.keys.contains(oldRootURL.path))
+    }
+
+    @Test
+    func `claude daily report parses usage and caches`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2025, month: 12, day: 20)
+        let iso0 = env.isoString(for: day)
+
+        let assistant: [String: Any] = [
+            "type": "assistant",
+            "timestamp": iso0,
+            "message": [
+                "model": "claude-sonnet-4-20250514",
+                "usage": [
+                    "input_tokens": 200,
+                    "cache_creation_input_tokens": 50,
+                    "cache_read_input_tokens": 25,
+                    "output_tokens": 80,
+                ],
+            ],
+        ]
+        _ = try env.writeClaudeProjectFile(
+            relativePath: "project-a/session-a.jsonl",
+            contents: env.jsonl([assistant]))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: nil,
+            claudeProjectsRoots: [env.claudeProjectsRoot],
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 0
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .claude,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+        #expect(report.data.count == 1)
+        #expect(report.data[0].modelsUsed == ["claude-sonnet-4-20250514"])
+        #expect(report.data[0].inputTokens == 200)
+        #expect(report.data[0].cacheCreationTokens == 50)
+        #expect(report.data[0].cacheReadTokens == 25)
+        #expect(report.data[0].outputTokens == 80)
+        #expect(report.data[0].totalTokens == 355)
+        #expect(report.data[0].modelBreakdowns == [
+            CostUsageDailyReport.ModelBreakdown(
+                modelName: "claude-sonnet-4-20250514",
+                costUSD: report.data[0].costUSD,
+                totalTokens: 355),
+        ])
+        #expect((report.data[0].costUSD ?? 0) > 0)
+    }
+
+    @Test
+    func `codex daily report preserves full sorted model breakdowns`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2025, month: 12, day: 23)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let iso2 = env.isoString(for: day.addingTimeInterval(2))
+        let iso3 = env.isoString(for: day.addingTimeInterval(3))
+        let iso4 = env.isoString(for: day.addingTimeInterval(4))
+        let iso5 = env.isoString(for: day.addingTimeInterval(5))
+        let iso6 = env.isoString(for: day.addingTimeInterval(6))
+        let iso7 = env.isoString(for: day.addingTimeInterval(7))
+
+        let events: [[String: Any]] = [
+            [
+                "type": "turn_context",
+                "timestamp": iso0,
+                "payload": ["model": "openai/gpt-5.2-pro"],
+            ],
+            [
+                "type": "event_msg",
+                "timestamp": iso1,
+                "payload": [
+                    "type": "token_count",
+                    "info": [
+                        "last_token_usage": [
+                            "input_tokens": 100,
+                            "cached_input_tokens": 0,
+                            "output_tokens": 10,
+                        ],
+                    ],
+                ],
+            ],
+            [
+                "type": "turn_context",
+                "timestamp": iso2,
+                "payload": ["model": "openai/gpt-5.3-codex"],
+            ],
+            [
+                "type": "event_msg",
+                "timestamp": iso3,
+                "payload": [
+                    "type": "token_count",
+                    "info": [
+                        "last_token_usage": [
+                            "input_tokens": 30,
+                            "cached_input_tokens": 0,
+                            "output_tokens": 10,
+                        ],
+                    ],
+                ],
+            ],
+            [
+                "type": "turn_context",
+                "timestamp": iso4,
+                "payload": ["model": "openai/gpt-5.2-codex"],
+            ],
+            [
+                "type": "event_msg",
+                "timestamp": iso5,
+                "payload": [
+                    "type": "token_count",
+                    "info": [
+                        "last_token_usage": [
+                            "input_tokens": 20,
+                            "cached_input_tokens": 0,
+                            "output_tokens": 10,
+                        ],
+                    ],
+                ],
+            ],
+            [
+                "type": "turn_context",
+                "timestamp": iso6,
+                "payload": ["model": "openai/gpt-5.3-codex-spark"],
+            ],
+            [
+                "type": "event_msg",
+                "timestamp": iso7,
+                "payload": [
+                    "type": "token_count",
+                    "info": [
+                        "last_token_usage": [
+                            "input_tokens": 10,
+                            "cached_input_tokens": 0,
+                            "output_tokens": 5,
+                        ],
+                    ],
+                ],
+            ],
+        ]
+
+        _ = try env.writeCodexSessionFile(
+            day: day,
+            filename: "session.jsonl",
+            contents: env.jsonl(events))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            claudeProjectsRoots: nil,
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 0
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+
+        #expect(report.data.count == 1)
+        #expect(report.data[0].modelBreakdowns?.map(\.modelName) == [
+            "gpt-5.2-pro",
+            "gpt-5.3-codex",
+            "gpt-5.2-codex",
+            "gpt-5.3-codex-spark",
+        ])
+        #expect(report.data[0].modelBreakdowns?.map(\.totalTokens) == [110, 40, 30, 15])
+    }
+
+    @Test
+    func `codex force rescan finds stale nested legacy sessions`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let legacyRoot = env.root.appendingPathComponent("legacy-codex-sessions", isDirectory: true)
+        let nestedDir = legacyRoot.appendingPathComponent("project/subdir", isDirectory: true)
+        try FileManager.default.createDirectory(at: nestedDir, withIntermediateDirectories: true)
+        try FileManager.default.createDirectory(
+            at: legacyRoot
+                .appendingPathComponent("2026", isDirectory: true)
+                .appendingPathComponent("05", isDirectory: true)
+                .appendingPathComponent("18", isDirectory: true),
+            withIntermediateDirectories: true)
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 18)
+        let fileURL = nestedDir.appendingPathComponent("session.jsonl", isDirectory: false)
+        try env.jsonl([
+            self.codexTurnContext(timestamp: env.isoString(for: day), model: "openai/gpt-5.5"),
+            self.codexTokenCount(
+                timestamp: env.isoString(for: day.addingTimeInterval(1)),
+                model: "openai/gpt-5.5",
+                last: (input: 40, cached: 10, output: 4)),
+        ]).write(to: fileURL, atomically: true, encoding: .utf8)
+        try FileManager.default.setAttributes(
+            [.modificationDate: day.addingTimeInterval(-10 * 24 * 60 * 60)],
+            ofItemAtPath: fileURL.path)
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: legacyRoot,
+            claudeProjectsRoots: nil,
+            cacheRoot: env.cacheRoot)
+        options.forceRescan = true
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+
+        #expect(report.data.count == 1)
+        #expect(report.data[0].totalTokens == 44)
+    }
+
+    private static func modelsDevCatalog(
+        model: String,
+        input: Double,
+        output: Double,
+        cacheRead: Double) throws -> ModelsDevCatalog
+    {
+        let json = """
+        {
+          "openai": {
+            "id": "openai",
+            "name": "OpenAI",
+            "models": {
+              "\(model)": {
+                "id": "\(model)",
+                "cost": {
+                  "input": \(input),
+                  "output": \(output),
+                  "cache_read": \(cacheRead)
+                }
+              }
+            }
+          }
+        }
+        """
+        return try JSONDecoder().decode(ModelsDevCatalog.self, from: Data(json.utf8))
+    }
+}
+
+// swiftlint:enable type_body_length
diff --git a/Tests/CodexBarTests/CostUsageScannerClaudeFableTests.swift b/Tests/CodexBarTests/CostUsageScannerClaudeFableTests.swift
new file mode 100644
index 0000000000..0d8beb4b75
--- /dev/null
+++ b/Tests/CodexBarTests/CostUsageScannerClaudeFableTests.swift
@@ -0,0 +1,457 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct CostUsageScannerClaudeFableTests {
+    @Test
+    func `claude fable 5 issue row gets priced`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 6, day: 9)
+        let fileURL = try env.writeClaudeProjectFile(
+            relativePath: "project-a/fable-5.jsonl",
+            contents: env.jsonl([
+                [
+                    "message": [
+                        "model": "claude-fable-5",
+                        "id": "msg_fable_5",
+                        "type": "message",
+                        "role": "assistant",
+                        "usage": [
+                            "input_tokens": 100,
+                            "cache_creation_input_tokens": 10,
+                            "cache_read_input_tokens": 20,
+                            "output_tokens": 5,
+                        ],
+                    ],
+                    "requestId": "req_fable_5",
+                    "type": "assistant",
+                    "timestamp": "2026-06-09T12:00:00.000Z",
+                    "sessionId": "session_fable_5",
+                ],
+            ]))
+
+        let parsed = CostUsageScanner.parseClaudeFile(
+            fileURL: fileURL,
+            range: CostUsageScanner.CostUsageDayRange(since: day, until: day),
+            providerFilter: .all)
+
+        #expect(parsed.rows.count == 1)
+        #expect(parsed.rows[0].model == "claude-fable-5")
+        let expected = 0.001395
+        #expect(abs((Double(parsed.rows[0].costNanos) / 1_000_000_000) - expected) < 0.000000001)
+    }
+
+    @Test
+    func `claude transcript refusal remains priced without billing provenance`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 6, day: 9)
+        let fileURL = try env.writeClaudeProjectFile(
+            relativePath: "project-a/fable-5-refusal.jsonl",
+            contents: env.jsonl([
+                [
+                    "message": [
+                        "model": "claude-fable-5",
+                        "id": "msg_fable_5_refusal",
+                        "type": "message",
+                        "role": "assistant",
+                        "stop_reason": "refusal",
+                        "usage": [
+                            "input_tokens": 100,
+                            "cache_creation_input_tokens": 10,
+                            "cache_read_input_tokens": 20,
+                            "output_tokens": 0,
+                        ],
+                    ],
+                    "requestId": "req_fable_5_refusal",
+                    "type": "assistant",
+                    "timestamp": "2026-06-09T12:00:00.000Z",
+                    "sessionId": "session_fable_5_refusal",
+                ],
+            ]))
+
+        let parsed = CostUsageScanner.parseClaudeFile(
+            fileURL: fileURL,
+            range: CostUsageScanner.CostUsageDayRange(since: day, until: day),
+            providerFilter: .all)
+
+        #expect(parsed.rows.count == 1)
+        #expect(parsed.rows[0].input == 100)
+        #expect(parsed.rows[0].cacheCreate == 10)
+        #expect(parsed.rows[0].cacheRead == 20)
+        #expect(parsed.rows[0].output == 0)
+        let expected = 0.001145
+        #expect(abs((Double(parsed.rows[0].costNanos) / 1_000_000_000) - expected) < 0.000000001)
+        #expect(parsed.rows[0].costPriced == true)
+    }
+
+    @Test
+    func `claude fable 5 prices one hour cache creation tokens`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 6, day: 9)
+        let fileURL = try env.writeClaudeProjectFile(
+            relativePath: "project-a/fable-5-cache-ttl.jsonl",
+            contents: env.jsonl([
+                [
+                    "message": [
+                        "model": "claude-fable-5",
+                        "id": "msg_fable_5_cache_ttl",
+                        "type": "message",
+                        "role": "assistant",
+                        "usage": [
+                            "input_tokens": 100,
+                            "cache_creation_input_tokens": 30,
+                            "cache_creation": [
+                                "ephemeral_5m_input_tokens": 10,
+                                "ephemeral_1h_input_tokens": 20,
+                            ],
+                            "cache_read_input_tokens": 20,
+                            "output_tokens": 5,
+                        ],
+                    ],
+                    "requestId": "req_fable_5_cache_ttl",
+                    "type": "assistant",
+                    "timestamp": "2026-06-09T12:00:00.000Z",
+                    "sessionId": "session_fable_5_cache_ttl",
+                ],
+            ]))
+
+        let parsed = CostUsageScanner.parseClaudeFile(
+            fileURL: fileURL,
+            range: CostUsageScanner.CostUsageDayRange(since: day, until: day),
+            providerFilter: .all)
+
+        #expect(parsed.rows.count == 1)
+        #expect(parsed.rows[0].cacheCreate == 30)
+        #expect(parsed.rows[0].cacheCreate1h == 20)
+        let expected = 0.001795
+        #expect(abs((Double(parsed.rows[0].costNanos) / 1_000_000_000) - expected) < 0.000000001)
+    }
+
+    @Test
+    func `claude cached rows preserve one hour writes for deferred pricing`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 6, day: 9)
+        _ = try env.writeClaudeProjectFile(
+            relativePath: "project-a/custom-cache-ttl.jsonl",
+            contents: env.jsonl([
+                [
+                    "message": [
+                        "model": "claude-custom-cache-model",
+                        "id": "msg_custom_cache_ttl",
+                        "type": "message",
+                        "role": "assistant",
+                        "usage": [
+                            "input_tokens": 100,
+                            "cache_creation_input_tokens": 30,
+                            "cache_creation": [
+                                "ephemeral_5m_input_tokens": 10,
+                                "ephemeral_1h_input_tokens": 20,
+                            ],
+                            "cache_read_input_tokens": 20,
+                            "output_tokens": 5,
+                        ],
+                    ],
+                    "requestId": "req_custom_cache_ttl",
+                    "type": "assistant",
+                    "timestamp": "2026-06-09T12:00:00.000Z",
+                    "sessionId": "session_custom_cache_ttl",
+                ],
+            ]))
+
+        var options = CostUsageScanner.Options(
+            claudeProjectsRoots: [env.claudeProjectsRoot],
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 0
+
+        let unpriced = CostUsageScanner.loadDailyReport(
+            provider: .claude,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+        #expect(unpriced.summary?.totalCostUSD == nil)
+
+        let cached = CostUsageCacheIO.load(provider: .claude, cacheRoot: env.cacheRoot)
+        #expect(cached.days["2026-06-09"]?["claude-custom-cache-model"]?[safe: 7] == 20)
+
+        try ModelsDevCache.save(
+            catalog: Self.anthropicModelsDevCatalog(model: "claude-custom-cache-model"),
+            fetchedAt: day,
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 3600
+
+        let repriced = CostUsageScanner.loadDailyReport(
+            provider: .claude,
+            since: day,
+            until: day,
+            now: day.addingTimeInterval(1),
+            options: options)
+
+        let expected = 0.001795
+        #expect(abs((repriced.summary?.totalCostUSD ?? 0) - expected) < 0.000000001)
+    }
+
+    @Test
+    func `claude deferred pricing preserves request long context boundaries`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 6, day: 9)
+        _ = try env.writeClaudeProjectFile(
+            relativePath: "project-a/custom-threshold.jsonl",
+            contents: env.jsonl([
+                Self.claudeUsageEvent(
+                    model: "claude-custom-threshold-model",
+                    messageID: "msg_custom_threshold_1",
+                    requestID: "req_custom_threshold_1",
+                    inputTokens: 150_000),
+                Self.claudeUsageEvent(
+                    model: "claude-custom-threshold-model",
+                    messageID: "msg_custom_threshold_2",
+                    requestID: "req_custom_threshold_2",
+                    inputTokens: 150_000),
+            ]))
+
+        var options = CostUsageScanner.Options(
+            claudeProjectsRoots: [env.claudeProjectsRoot],
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 0
+
+        let unpriced = CostUsageScanner.loadDailyReport(
+            provider: .claude,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+        #expect(unpriced.summary?.totalCostUSD == nil)
+
+        try ModelsDevCache.save(
+            catalog: Self.anthropicThresholdModelsDevCatalog(model: "claude-custom-threshold-model"),
+            fetchedAt: day,
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 3600
+
+        let repriced = CostUsageScanner.loadDailyReport(
+            provider: .claude,
+            since: day,
+            until: day,
+            now: day.addingTimeInterval(1),
+            options: options)
+
+        #expect(abs((repriced.summary?.totalCostUSD ?? 0) - 3) < 0.000000001)
+    }
+
+    @Test
+    func `claude cached rows reprice after models dev catalog changes`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 6, day: 9)
+        let model = "claude-custom-repricing-model"
+        _ = try env.writeClaudeProjectFile(
+            relativePath: "project-a/custom-repricing.jsonl",
+            contents: env.jsonl([
+                Self.claudeUsageEvent(
+                    model: model,
+                    messageID: "msg_custom_repricing",
+                    requestID: "req_custom_repricing",
+                    inputTokens: 240_000),
+            ]))
+        try ModelsDevCache.save(
+            catalog: Self.anthropicThresholdModelsDevCatalog(model: model),
+            fetchedAt: day,
+            cacheRoot: env.cacheRoot)
+
+        var options = CostUsageScanner.Options(
+            claudeProjectsRoots: [env.claudeProjectsRoot],
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 0
+
+        let premium = CostUsageScanner.loadDailyReport(
+            provider: .claude,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+        #expect(abs((premium.summary?.totalCostUSD ?? 0) - 4.8) < 0.000000001)
+
+        try ModelsDevCache.save(
+            catalog: Self.anthropicModelsDevCatalog(model: model),
+            fetchedAt: day.addingTimeInterval(1),
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 3600
+
+        let repriced = CostUsageScanner.loadDailyReport(
+            provider: .claude,
+            since: day,
+            until: day,
+            now: day.addingTimeInterval(2),
+            options: options)
+
+        #expect(abs((repriced.summary?.totalCostUSD ?? 0) - 2.4) < 0.000000001)
+    }
+
+    @Test
+    func `claude cached historical rows keep original tariff`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 3, day: 12)
+        _ = try env.writeClaudeProjectFile(
+            relativePath: "project-a/sonnet-46-historical.jsonl",
+            contents: env.jsonl([
+                [
+                    "message": [
+                        "model": "claude-sonnet-4-6",
+                        "id": "msg_sonnet_46_historical",
+                        "type": "message",
+                        "role": "assistant",
+                        "usage": [
+                            "input_tokens": 240_000,
+                            "cache_creation_input_tokens": 0,
+                            "cache_read_input_tokens": 0,
+                            "output_tokens": 0,
+                        ],
+                    ],
+                    "requestId": "req_sonnet_46_historical",
+                    "type": "assistant",
+                    "timestamp": "2026-03-12T12:00:00.000Z",
+                    "sessionId": "session_sonnet_46_historical",
+                ],
+            ]))
+
+        var options = CostUsageScanner.Options(
+            claudeProjectsRoots: [env.claudeProjectsRoot],
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 0
+
+        let initial = CostUsageScanner.loadDailyReport(
+            provider: .claude,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+        #expect(abs((initial.summary?.totalCostUSD ?? 0) - 1.44) < 0.000000001)
+
+        try ModelsDevCache.save(
+            catalog: Self.anthropicSonnet46StandardCatalog(),
+            fetchedAt: day,
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 3600
+
+        let cached = CostUsageScanner.loadDailyReport(
+            provider: .claude,
+            since: day,
+            until: day,
+            now: day.addingTimeInterval(1),
+            options: options)
+
+        #expect(abs((cached.summary?.totalCostUSD ?? 0) - 1.44) < 0.000000001)
+    }
+
+    private static func anthropicModelsDevCatalog(model: String) throws -> ModelsDevCatalog {
+        let json = """
+        {
+          "anthropic": {
+            "id": "anthropic",
+            "models": {
+              "\(model)": {
+                "id": "\(model)",
+                "cost": {
+                  "input": 10,
+                  "output": 50,
+                  "cache_read": 1,
+                  "cache_write": 12.5
+                }
+              }
+            }
+          }
+        }
+        """
+        return try JSONDecoder().decode(ModelsDevCatalog.self, from: Data(json.utf8))
+    }
+
+    private static func anthropicThresholdModelsDevCatalog(model: String) throws -> ModelsDevCatalog {
+        let json = """
+        {
+          "anthropic": {
+            "id": "anthropic",
+            "models": {
+              "\(model)": {
+                "id": "\(model)",
+                "cost": {
+                  "input": 10,
+                  "output": 50,
+                  "cache_read": 1,
+                  "cache_write": 12.5,
+                  "context_over_200k": {
+                    "input": 20,
+                    "output": 75,
+                    "cache_read": 2,
+                    "cache_write": 25
+                  }
+                }
+              }
+            }
+          }
+        }
+        """
+        return try JSONDecoder().decode(ModelsDevCatalog.self, from: Data(json.utf8))
+    }
+
+    private static func anthropicSonnet46StandardCatalog() throws -> ModelsDevCatalog {
+        let json = """
+        {
+          "anthropic": {
+            "id": "anthropic",
+            "models": {
+              "claude-sonnet-4-6": {
+                "id": "claude-sonnet-4-6",
+                "cost": {
+                  "input": 3,
+                  "output": 15,
+                  "cache_read": 0.3,
+                  "cache_write": 3.75
+                }
+              }
+            }
+          }
+        }
+        """
+        return try JSONDecoder().decode(ModelsDevCatalog.self, from: Data(json.utf8))
+    }
+
+    private static func claudeUsageEvent(
+        model: String,
+        messageID: String,
+        requestID: String,
+        inputTokens: Int) -> [String: Any]
+    {
+        [
+            "message": [
+                "model": model,
+                "id": messageID,
+                "type": "message",
+                "role": "assistant",
+                "usage": [
+                    "input_tokens": inputTokens,
+                    "cache_creation_input_tokens": 0,
+                    "cache_read_input_tokens": 0,
+                    "output_tokens": 0,
+                ],
+            ],
+            "requestId": requestID,
+            "type": "assistant",
+            "timestamp": "2026-06-09T12:00:00.000Z",
+            "sessionId": "session_\(requestID)",
+        ]
+    }
+}
diff --git a/Tests/CodexBarTests/CostUsageScannerClaudeRegressionTests.swift b/Tests/CodexBarTests/CostUsageScannerClaudeRegressionTests.swift
new file mode 100644
index 0000000000..5cacd77a4e
--- /dev/null
+++ b/Tests/CodexBarTests/CostUsageScannerClaudeRegressionTests.swift
@@ -0,0 +1,778 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct CostUsageScannerClaudeRegressionTests {
+    @Test
+    func `parseClaudeFile snapshots keep the last streaming chunk`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2025, month: 12, day: 21)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+
+        let fileURL = try env.writeClaudeProjectFile(
+            relativePath: "project-a/parse-stream-last.jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "assistant",
+                    "timestamp": iso0,
+                    "sessionId": "parse-session",
+                    "requestId": "req_parse_stream",
+                    "isSidechain": false,
+                    "message": [
+                        "id": "msg_parse_stream",
+                        "model": "claude-sonnet-4-20250514",
+                        "usage": [
+                            "input_tokens": 50,
+                            "cache_creation_input_tokens": 5,
+                            "cache_read_input_tokens": 0,
+                            "output_tokens": 7,
+                        ],
+                    ],
+                ],
+                [
+                    "type": "assistant",
+                    "timestamp": iso1,
+                    "sessionId": "parse-session",
+                    "requestId": "req_parse_stream",
+                    "isSidechain": false,
+                    "message": [
+                        "id": "msg_parse_stream",
+                        "model": "claude-sonnet-4-20250514",
+                        "usage": [
+                            "input_tokens": 50,
+                            "cache_creation_input_tokens": 5,
+                            "cache_read_input_tokens": 0,
+                            "output_tokens": 19,
+                        ],
+                    ],
+                ],
+            ]))
+
+        let parsed = CostUsageScanner.parseClaudeFile(
+            fileURL: fileURL,
+            range: CostUsageScanner.CostUsageDayRange(since: day, until: day),
+            providerFilter: .all)
+
+        #expect(parsed.rows.count == 1)
+        #expect(parsed.rows[0].sessionId == "parse-session")
+        #expect(parsed.rows[0].messageId == "msg_parse_stream")
+        #expect(parsed.rows[0].requestId == "req_parse_stream")
+        #expect(parsed.rows[0].output == 19)
+    }
+
+    @Test
+    func `parseClaudeFile snapshots keep missing id rows distinct`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2025, month: 12, day: 21)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+
+        let fileURL = try env.writeClaudeProjectFile(
+            relativePath: "project-a/parse-missing-ids.jsonl",
+            contents: env.jsonl([
+                [
+                    "type": "assistant",
+                    "timestamp": iso0,
+                    "message": [
+                        "model": "claude-sonnet-4-20250514",
+                        "usage": [
+                            "input_tokens": 11,
+                            "cache_creation_input_tokens": 0,
+                            "cache_read_input_tokens": 0,
+                            "output_tokens": 3,
+                        ],
+                    ],
+                ],
+                [
+                    "type": "assistant",
+                    "timestamp": iso1,
+                    "message": [
+                        "model": "claude-sonnet-4-20250514",
+                        "usage": [
+                            "input_tokens": 13,
+                            "cache_creation_input_tokens": 0,
+                            "cache_read_input_tokens": 0,
+                            "output_tokens": 5,
+                        ],
+                    ],
+                ],
+            ]))
+
+        let parsed = CostUsageScanner.parseClaudeFile(
+            fileURL: fileURL,
+            range: CostUsageScanner.CostUsageDayRange(since: day, until: day),
+            providerFilter: .all)
+
+        #expect(parsed.rows.count == 2)
+        #expect(parsed.rows.map(\.input).sorted() == [11, 13])
+        #expect(parsed.rows.allSatisfy { $0.messageId == nil && $0.requestId == nil })
+    }
+
+    @Test
+    func `claude opus 4 7 issue row gets priced`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 4, day: 23)
+        let fileURL = try env.writeClaudeProjectFile(
+            relativePath: "project-a/opus-47.jsonl",
+            contents: env.jsonl([
+                [
+                    "message": [
+                        "model": "claude-opus-4-7",
+                        "id": "msg_01NrvWoSMk2Eig6vkCgyRZqc",
+                        "type": "message",
+                        "role": "assistant",
+                        "usage": [
+                            "input_tokens": 6,
+                            "cache_creation_input_tokens": 1389,
+                            "cache_read_input_tokens": 50352,
+                            "output_tokens": 3922,
+                        ],
+                    ],
+                    "requestId": "req_011CaLLcFQD712ZnCTxHFk71",
+                    "type": "assistant",
+                    "timestamp": "2026-04-23T07:51:34.428Z",
+                    "sessionId": "39d4b923-8273-4c35-ad9c-e098395286f1",
+                ],
+            ]))
+
+        let parsed = CostUsageScanner.parseClaudeFile(
+            fileURL: fileURL,
+            range: CostUsageScanner.CostUsageDayRange(since: day, until: day),
+            providerFilter: .all)
+
+        #expect(parsed.rows.count == 1)
+        #expect(parsed.rows[0].model == "claude-opus-4-7")
+        #expect(parsed.rows[0].input == 6)
+        #expect(parsed.rows[0].cacheCreate == 1389)
+        #expect(parsed.rows[0].cacheRead == 50352)
+        #expect(parsed.rows[0].output == 3922)
+
+        let expected = 0.13193725
+        #expect(abs((Double(parsed.rows[0].costNanos) / 1_000_000_000) - expected) < 0.000000001)
+    }
+
+    /// Regression for https://github.com/steipete/CodexBar/issues/1210: an Opus 4.8 row
+    /// priced to an empty cost because the built-in Claude pricing table had no
+    /// claude-opus-4-8 entry (used when the models.dev cache is missing/stale).
+    @Test
+    func `claude opus 4 8 issue row gets priced`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 29)
+        let fileURL = try env.writeClaudeProjectFile(
+            relativePath: "project-a/opus-48.jsonl",
+            contents: env.jsonl([
+                [
+                    "message": [
+                        "model": "claude-opus-4-8",
+                        "id": "msg_01NrvWoSMk2Eig6vkCgyRZqc",
+                        "type": "message",
+                        "role": "assistant",
+                        "usage": [
+                            "input_tokens": 6,
+                            "cache_creation_input_tokens": 1389,
+                            "cache_read_input_tokens": 50352,
+                            "output_tokens": 3922,
+                        ],
+                    ],
+                    "requestId": "req_011CaLLcFQD712ZnCTxHFk71",
+                    "type": "assistant",
+                    "timestamp": "2026-05-29T07:51:34.428Z",
+                    "sessionId": "39d4b923-8273-4c35-ad9c-e098395286f1",
+                ],
+            ]))
+
+        let parsed = CostUsageScanner.parseClaudeFile(
+            fileURL: fileURL,
+            range: CostUsageScanner.CostUsageDayRange(since: day, until: day),
+            providerFilter: .all)
+
+        #expect(parsed.rows.count == 1)
+        #expect(parsed.rows[0].model == "claude-opus-4-8")
+        #expect(parsed.rows[0].input == 6)
+        #expect(parsed.rows[0].cacheCreate == 1389)
+        #expect(parsed.rows[0].cacheRead == 50352)
+        #expect(parsed.rows[0].output == 3922)
+
+        let expected = 0.13193725
+        #expect(abs((Double(parsed.rows[0].costNanos) / 1_000_000_000) - expected) < 0.000000001)
+    }
+
+    @Test
+    func `claude streaming keeps the last cumulative chunk`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2025, month: 12, day: 21)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let iso2 = env.isoString(for: day.addingTimeInterval(2))
+
+        let model = "claude-sonnet-4-20250514"
+        let sessionId = "session-stream-last-wins"
+        let messageId = "msg_stream_last_wins"
+        let requestId = "req_stream_last_wins"
+
+        let chunk1: [String: Any] = [
+            "type": "assistant",
+            "timestamp": iso0,
+            "sessionId": sessionId,
+            "requestId": requestId,
+            "isSidechain": false,
+            "message": [
+                "id": messageId,
+                "model": model,
+                "usage": [
+                    "input_tokens": 120,
+                    "cache_creation_input_tokens": 10,
+                    "cache_read_input_tokens": 5,
+                    "output_tokens": 12,
+                ],
+            ],
+        ]
+        let chunk2: [String: Any] = [
+            "type": "assistant",
+            "timestamp": iso1,
+            "sessionId": sessionId,
+            "requestId": requestId,
+            "isSidechain": false,
+            "message": [
+                "id": messageId,
+                "model": model,
+                "usage": [
+                    "input_tokens": 120,
+                    "cache_creation_input_tokens": 10,
+                    "cache_read_input_tokens": 5,
+                    "output_tokens": 48,
+                ],
+            ],
+        ]
+        let chunk3: [String: Any] = [
+            "type": "assistant",
+            "timestamp": iso2,
+            "sessionId": sessionId,
+            "requestId": requestId,
+            "isSidechain": false,
+            "message": [
+                "id": messageId,
+                "model": model,
+                "usage": [
+                    "input_tokens": 120,
+                    "cache_creation_input_tokens": 10,
+                    "cache_read_input_tokens": 5,
+                    "output_tokens": 90,
+                ],
+            ],
+        ]
+
+        _ = try env.writeClaudeProjectFile(
+            relativePath: "project-a/stream-last-wins.jsonl",
+            contents: env.jsonl([chunk1, chunk2, chunk3]))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: nil,
+            claudeProjectsRoots: [env.claudeProjectsRoot],
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 0
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .claude,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+
+        #expect(report.data.count == 1)
+        #expect(report.data[0].inputTokens == 120)
+        #expect(report.data[0].cacheCreationTokens == 10)
+        #expect(report.data[0].cacheReadTokens == 5)
+        #expect(report.data[0].outputTokens == 90)
+        #expect(report.data[0].totalTokens == 225)
+    }
+
+    @Test
+    func `claude cross file dedup prefers parent and keeps unique sidechain rows`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2025, month: 12, day: 22)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let iso2 = env.isoString(for: day.addingTimeInterval(2))
+        let iso3 = env.isoString(for: day.addingTimeInterval(3))
+
+        let model = "claude-sonnet-4-20250514"
+        let sessionId = "session-cross-file"
+
+        let parentOverlap: [String: Any] = [
+            "type": "assistant",
+            "timestamp": iso0,
+            "sessionId": sessionId,
+            "requestId": "req_overlap",
+            "isSidechain": false,
+            "message": [
+                "id": "msg_overlap",
+                "model": model,
+                "usage": [
+                    "input_tokens": 100,
+                    "cache_creation_input_tokens": 20,
+                    "cache_read_input_tokens": 10,
+                    "output_tokens": 30,
+                ],
+            ],
+        ]
+        let compactOverlap: [String: Any] = [
+            "type": "assistant",
+            "timestamp": iso1,
+            "sessionId": sessionId,
+            "requestId": "req_overlap",
+            "isSidechain": true,
+            "message": [
+                "id": "msg_overlap",
+                "model": model,
+                "usage": [
+                    "input_tokens": 100,
+                    "cache_creation_input_tokens": 20,
+                    "cache_read_input_tokens": 10,
+                    "output_tokens": 30,
+                ],
+            ],
+        ]
+        let nonCompactOverlap: [String: Any] = [
+            "type": "assistant",
+            "timestamp": iso2,
+            "sessionId": sessionId,
+            "requestId": "req_overlap",
+            "isSidechain": true,
+            "message": [
+                "id": "msg_overlap",
+                "model": model,
+                "usage": [
+                    "input_tokens": 100,
+                    "cache_creation_input_tokens": 20,
+                    "cache_read_input_tokens": 10,
+                    "output_tokens": 30,
+                ],
+            ],
+        ]
+        let uniqueSidechain: [String: Any] = [
+            "type": "assistant",
+            "timestamp": iso3,
+            "sessionId": sessionId,
+            "requestId": "req_unique_sidechain",
+            "isSidechain": true,
+            "message": [
+                "id": "msg_unique_sidechain",
+                "model": model,
+                "usage": [
+                    "input_tokens": 70,
+                    "cache_creation_input_tokens": 5,
+                    "cache_read_input_tokens": 0,
+                    "output_tokens": 20,
+                ],
+            ],
+        ]
+
+        _ = try env.writeClaudeProjectFile(
+            relativePath: "project-a/\(sessionId).jsonl",
+            contents: env.jsonl([parentOverlap]))
+        _ = try env.writeClaudeProjectFile(
+            relativePath: "project-a/\(sessionId)/subagents/agent-acompact-overlap.jsonl",
+            contents: env.jsonl([compactOverlap]))
+        _ = try env.writeClaudeProjectFile(
+            relativePath: "project-a/\(sessionId)/subagents/agent-aside_question-overlap.jsonl",
+            contents: env.jsonl([nonCompactOverlap, uniqueSidechain]))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: nil,
+            claudeProjectsRoots: [env.claudeProjectsRoot],
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 0
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .claude,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+
+        #expect(report.data.count == 1)
+        #expect(report.data[0].inputTokens == 170)
+        #expect(report.data[0].cacheCreationTokens == 25)
+        #expect(report.data[0].cacheReadTokens == 10)
+        #expect(report.data[0].outputTokens == 50)
+        #expect(report.data[0].totalTokens == 255)
+    }
+
+    @Test
+    func `claude forked transcript history dedups globally while new fork rows count`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2025, month: 12, day: 22)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let iso2 = env.isoString(for: day.addingTimeInterval(2))
+        let model = "claude-sonnet-4-20250514"
+
+        let copiedHistoryInOriginal: [String: Any] = [
+            "type": "assistant",
+            "timestamp": iso0,
+            "sessionId": "session-original",
+            "requestId": "req_copied_history",
+            "isSidechain": false,
+            "uuid": "assistant-uuid-copied",
+            "parentUuid": "parent-uuid-copied",
+            "message": [
+                "id": "msg_copied_history",
+                "model": model,
+                "usage": [
+                    "input_tokens": 100,
+                    "cache_creation_input_tokens": 20,
+                    "cache_read_input_tokens": 10,
+                    "output_tokens": 30,
+                ],
+            ],
+        ]
+        var copiedHistoryInFork = copiedHistoryInOriginal
+        copiedHistoryInFork["sessionId"] = "session-fork"
+
+        let originalContinuation: [String: Any] = [
+            "type": "assistant",
+            "timestamp": iso1,
+            "sessionId": "session-original",
+            "requestId": "req_original_new",
+            "isSidechain": false,
+            "message": [
+                "id": "msg_original_new",
+                "model": model,
+                "usage": [
+                    "input_tokens": 40,
+                    "cache_creation_input_tokens": 0,
+                    "cache_read_input_tokens": 0,
+                    "output_tokens": 10,
+                ],
+            ],
+        ]
+        let forkContinuation: [String: Any] = [
+            "type": "assistant",
+            "timestamp": iso2,
+            "sessionId": "session-fork",
+            "requestId": "req_fork_new",
+            "isSidechain": false,
+            "message": [
+                "id": "msg_fork_new",
+                "model": model,
+                "usage": [
+                    "input_tokens": 70,
+                    "cache_creation_input_tokens": 5,
+                    "cache_read_input_tokens": 0,
+                    "output_tokens": 20,
+                ],
+            ],
+        ]
+
+        _ = try env.writeClaudeProjectFile(
+            relativePath: "project-a/session-original.jsonl",
+            contents: env.jsonl([copiedHistoryInOriginal, originalContinuation]))
+        _ = try env.writeClaudeProjectFile(
+            relativePath: "project-a/session-fork.jsonl",
+            contents: env.jsonl([copiedHistoryInFork, forkContinuation]))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: nil,
+            claudeProjectsRoots: [env.claudeProjectsRoot],
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 0
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .claude,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+
+        #expect(report.data.count == 1)
+        #expect(report.data[0].inputTokens == 210)
+        #expect(report.data[0].cacheCreationTokens == 25)
+        #expect(report.data[0].cacheReadTokens == 10)
+        #expect(report.data[0].outputTokens == 60)
+        #expect(report.data[0].totalTokens == 305)
+    }
+
+    @Test
+    func `claude cross file dedup uses stable path order for same rank sidechains`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2025, month: 12, day: 23)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+
+        let model = "claude-sonnet-4-20250514"
+        let sessionId = "session-sidechain-path-order"
+
+        let firstSidechain: [String: Any] = [
+            "type": "assistant",
+            "timestamp": iso0,
+            "sessionId": sessionId,
+            "requestId": "req_path_order",
+            "isSidechain": true,
+            "message": [
+                "id": "msg_path_order",
+                "model": model,
+                "usage": [
+                    "input_tokens": 10,
+                    "cache_creation_input_tokens": 0,
+                    "cache_read_input_tokens": 0,
+                    "output_tokens": 1,
+                ],
+            ],
+        ]
+        let secondSidechain: [String: Any] = [
+            "type": "assistant",
+            "timestamp": iso1,
+            "sessionId": sessionId,
+            "requestId": "req_path_order",
+            "isSidechain": true,
+            "message": [
+                "id": "msg_path_order",
+                "model": model,
+                "usage": [
+                    "input_tokens": 999,
+                    "cache_creation_input_tokens": 0,
+                    "cache_read_input_tokens": 0,
+                    "output_tokens": 999,
+                ],
+            ],
+        ]
+
+        _ = try env.writeClaudeProjectFile(
+            relativePath: "project-a/\(sessionId)/subagents/agent-a-first.jsonl",
+            contents: env.jsonl([firstSidechain]))
+        _ = try env.writeClaudeProjectFile(
+            relativePath: "project-a/\(sessionId)/subagents/agent-b-second.jsonl",
+            contents: env.jsonl([secondSidechain]))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: nil,
+            claudeProjectsRoots: [env.claudeProjectsRoot],
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 0
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .claude,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+
+        #expect(report.data.count == 1)
+        #expect(report.data[0].inputTokens == 10)
+        #expect(report.data[0].outputTokens == 1)
+        #expect(report.data[0].totalTokens == 11)
+    }
+
+    @Test
+    func `claude cross file dedup uses provider ids when session id is missing`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2025, month: 12, day: 23)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+
+        let model = "claude-sonnet-4-20250514"
+
+        let missingSession: [String: Any] = [
+            "type": "assistant",
+            "timestamp": iso0,
+            "requestId": "req_shared",
+            "isSidechain": false,
+            "message": [
+                "id": "msg_shared",
+                "model": model,
+                "usage": [
+                    "input_tokens": 10,
+                    "cache_creation_input_tokens": 0,
+                    "cache_read_input_tokens": 0,
+                    "output_tokens": 1,
+                ],
+            ],
+        ]
+        let sessionScoped: [String: Any] = [
+            "type": "assistant",
+            "timestamp": iso1,
+            "sessionId": "session-has-id",
+            "requestId": "req_shared",
+            "isSidechain": true,
+            "message": [
+                "id": "msg_shared",
+                "model": model,
+                "usage": [
+                    "input_tokens": 20,
+                    "cache_creation_input_tokens": 0,
+                    "cache_read_input_tokens": 0,
+                    "output_tokens": 2,
+                ],
+            ],
+        ]
+
+        _ = try env.writeClaudeProjectFile(
+            relativePath: "project-a/missing-session-parent.jsonl",
+            contents: env.jsonl([missingSession]))
+        _ = try env.writeClaudeProjectFile(
+            relativePath: "project-a/session-has-id/subagents/agent-a-sidechain.jsonl",
+            contents: env.jsonl([sessionScoped]))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: nil,
+            claudeProjectsRoots: [env.claudeProjectsRoot],
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 0
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .claude,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+
+        #expect(report.data.count == 1)
+        #expect(report.data[0].inputTokens == 10)
+        #expect(report.data[0].outputTokens == 1)
+        #expect(report.data[0].totalTokens == 11)
+    }
+
+    @Test
+    func `claude rescans sessions when a new parent file overlaps cached sidechain data`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2025, month: 12, day: 24)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+
+        let model = "claude-sonnet-4-20250514"
+        let sessionId = "session-cache-recompute"
+
+        let sidechainOverlap: [String: Any] = [
+            "type": "assistant",
+            "timestamp": iso0,
+            "sessionId": sessionId,
+            "requestId": "req_overlap",
+            "isSidechain": true,
+            "message": [
+                "id": "msg_overlap",
+                "model": model,
+                "usage": [
+                    "input_tokens": 40,
+                    "cache_creation_input_tokens": 0,
+                    "cache_read_input_tokens": 0,
+                    "output_tokens": 10,
+                ],
+            ],
+        ]
+        let uniqueSidechain: [String: Any] = [
+            "type": "assistant",
+            "timestamp": iso1,
+            "sessionId": sessionId,
+            "requestId": "req_unique",
+            "isSidechain": true,
+            "message": [
+                "id": "msg_unique",
+                "model": model,
+                "usage": [
+                    "input_tokens": 5,
+                    "cache_creation_input_tokens": 0,
+                    "cache_read_input_tokens": 0,
+                    "output_tokens": 1,
+                ],
+            ],
+        ]
+
+        _ = try env.writeClaudeProjectFile(
+            relativePath: "project-a/\(sessionId)/subagents/agent-acompact-cached.jsonl",
+            contents: env.jsonl([sidechainOverlap, uniqueSidechain]))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: nil,
+            claudeProjectsRoots: [env.claudeProjectsRoot],
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 0
+
+        let firstReport = CostUsageScanner.loadDailyReport(
+            provider: .claude,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+
+        #expect(firstReport.data.count == 1)
+        #expect(firstReport.data[0].inputTokens == 45)
+        #expect(firstReport.data[0].outputTokens == 11)
+        #expect(firstReport.data[0].totalTokens == 56)
+
+        let parentOverlap: [String: Any] = [
+            "type": "assistant",
+            "timestamp": iso0,
+            "sessionId": sessionId,
+            "requestId": "req_overlap",
+            "isSidechain": false,
+            "message": [
+                "id": "msg_overlap",
+                "model": model,
+                "usage": [
+                    "input_tokens": 40,
+                    "cache_creation_input_tokens": 0,
+                    "cache_read_input_tokens": 0,
+                    "output_tokens": 10,
+                ],
+            ],
+        ]
+
+        _ = try env.writeClaudeProjectFile(
+            relativePath: "project-a/\(sessionId).jsonl",
+            contents: env.jsonl([parentOverlap]))
+
+        let secondReport = CostUsageScanner.loadDailyReport(
+            provider: .claude,
+            since: day,
+            until: day,
+            now: day.addingTimeInterval(10),
+            options: options)
+
+        #expect(secondReport.data.count == 1)
+        #expect(secondReport.data[0].inputTokens == 45)
+        #expect(secondReport.data[0].outputTokens == 11)
+        #expect(secondReport.data[0].totalTokens == 56)
+    }
+
+    @Test
+    func `claude sonnet 4 6 pricing is available for base and dated models`() {
+        let baseCost = CostUsagePricing.claudeCostUSD(
+            model: "claude-sonnet-4-6",
+            inputTokens: 1000,
+            cacheReadInputTokens: 100,
+            cacheCreationInputTokens: 50,
+            outputTokens: 25)
+        let datedCost = CostUsagePricing.claudeCostUSD(
+            model: "claude-sonnet-4-6-20260219",
+            inputTokens: 1000,
+            cacheReadInputTokens: 100,
+            cacheCreationInputTokens: 50,
+            outputTokens: 25)
+
+        #expect(baseCost != nil)
+        #expect(datedCost != nil)
+        #expect(baseCost == datedCost)
+    }
+}
diff --git a/Tests/CodexBarTests/CostUsageScannerCodexPriorityTests.swift b/Tests/CodexBarTests/CostUsageScannerCodexPriorityTests.swift
new file mode 100644
index 0000000000..65f8698850
--- /dev/null
+++ b/Tests/CodexBarTests/CostUsageScannerCodexPriorityTests.swift
@@ -0,0 +1,692 @@
+import Foundation
+#if canImport(SQLite3)
+import SQLite3
+import Testing
+@testable import CodexBarCore
+
+struct CostUsageScannerCodexPriorityTests {
+    @Test
+    func `parses priority turn metadata without exposing request body`() {
+        let body = "INFO thread_id=11111111-1111-1111-1111-111111111111 "
+            + "turn.id=22222222-2222-2222-2222-222222222222 websocket request: "
+            + #"{"type":"response.create","model":"request-model","service_tier":"priority","#
+            + #""instructions":"secret prompt"}"#
+
+        let parsed = CostUsageScanner.parseCodexPriorityTraceRow(timestamp: "2026-05-10T12:00:00Z", body: body)
+
+        #expect(parsed?.threadID == "11111111-1111-1111-1111-111111111111")
+        #expect(parsed?.turnID == "22222222-2222-2222-2222-222222222222")
+        #expect(parsed?.model == "request-model")
+        #expect(parsed?.timestamp == "2026-05-10T12:00:00Z")
+    }
+
+    @Test
+    func `ignores non priority malformed and non response request rows`() {
+        let prefix = "thread_id=thread turn.id=turn websocket request: "
+
+        #expect(CostUsageScanner.parseCodexPriorityTraceRow(
+            timestamp: nil,
+            body: prefix + #"{"type":"session.update","service_tier":"priority"}"#) == nil)
+        #expect(CostUsageScanner.parseCodexPriorityTraceRow(
+            timestamp: nil,
+            body: prefix + #"{"type":"response.create"}"#) == nil)
+        #expect(CostUsageScanner.parseCodexPriorityTraceRow(
+            timestamp: nil,
+            body: prefix + #"{"type":"response.create","service_tier":"default"}"#) == nil)
+        #expect(CostUsageScanner.parseCodexPriorityTraceRow(
+            timestamp: nil,
+            body: prefix + #"{"#) == nil)
+    }
+
+    @Test
+    func `parses completed response model without exposing response body`() {
+        let body = "INFO thread_id=thread turn.id=turn websocket event: "
+            + #"{"type":"response.completed","response":{"model":"completed-model","output":[{"content":"private"}]}}"#
+
+        let parsed = CostUsageScanner.parseCodexCompletedTraceRow(body: body)
+
+        #expect(parsed?.turnID == "turn")
+        #expect(parsed?.model == "completed-model")
+    }
+
+    @Test
+    func `reads priority turns from sqlite logs table`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+        let dbURL = env.root.appendingPathComponent("logs_2.sqlite")
+        try Self.createTestLogsDatabase(at: dbURL)
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            timestamp: "2026-05-10T12:00:00Z",
+            body: "thread_id=thread-a turn.id=turn-a websocket request: "
+                + #"{"type":"response.create","model":"request-model","service_tier":"priority","input":"private"}"#)
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            timestamp: "2026-05-10T12:01:00Z",
+            body: """
+            thread_id=thread-b turn.id=turn-b websocket request: {"type":"response.create","model":"request-model"}
+            """)
+
+        let turns = CostUsageScanner.codexPriorityTurns(databaseURL: dbURL)
+
+        #expect(turns.keys.sorted() == ["turn-a"])
+        #expect(turns["turn-a"]?.threadID == "thread-a")
+        #expect(turns["turn-a"]?.model == "request-model")
+    }
+
+    @Test
+    func `cold scan uses timestamp index and warm scan uses rowid cursor`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+        let dbURL = env.root.appendingPathComponent("logs_2.sqlite")
+        try Self.createTestLogsDatabase(at: dbURL)
+
+        var db: OpaquePointer?
+        guard sqlite3_open_v2(dbURL.path, &db, SQLITE_OPEN_READONLY, nil) == SQLITE_OK else {
+            throw SQLiteTestError.open
+        }
+        defer { sqlite3_close(db) }
+
+        let coldQuery = CostUsageScanner._test_codexPriorityAccumulationQuery(
+            db,
+            lastRowID: 0,
+            coverageSinceEpoch: 1)
+        let coldPlan = try Self.queryPlan(db: db, query: coldQuery, bindings: [1])
+        #expect(coldPlan.contains { $0.contains("USING INDEX idx_logs_ts") })
+
+        let unboundedColdQuery = CostUsageScanner._test_codexPriorityAccumulationQuery(
+            db,
+            lastRowID: 0,
+            coverageSinceEpoch: 0)
+        let unboundedColdPlan = try Self.queryPlan(
+            db: db,
+            query: unboundedColdQuery,
+            bindings: [0, 0])
+        #expect(unboundedColdPlan.contains { $0.contains("USING INTEGER PRIMARY KEY") })
+        #expect(!unboundedColdPlan.contains { $0.contains("USE TEMP B-TREE") })
+
+        let warmQuery = CostUsageScanner._test_codexPriorityAccumulationQuery(
+            db,
+            lastRowID: 1,
+            coverageSinceEpoch: 0)
+        let warmPlan = try Self.queryPlan(db: db, query: warmQuery, bindings: [1, 0])
+        #expect(warmPlan.contains { $0.contains("USING INTEGER PRIMARY KEY") })
+    }
+
+    @Test
+    func `sqlite scan upgrades priority request alias with completed response model`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+        let dbURL = env.root.appendingPathComponent("logs_2.sqlite")
+        try Self.createTestLogsDatabase(at: dbURL)
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            timestamp: "2026-05-10T12:00:00Z",
+            body: "thread_id=thread turn.id=turn websocket request: "
+                + #"{"type":"response.create","model":"request-alias","service_tier":"priority"}"#)
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            timestamp: "2026-05-10T12:00:01Z",
+            body: "thread_id=thread turn.id=turn websocket event: "
+                + #"{"type":"response.completed","response":{"model":"completed-model","input":"private"}}"#)
+
+        let turns = CostUsageScanner.codexPriorityTurns(databaseURL: dbURL)
+
+        #expect(turns["turn"]?.model == "completed-model")
+    }
+
+    @Test
+    func `sqlite scan matches spaced completed response json`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+        let dbURL = env.root.appendingPathComponent("logs_2.sqlite")
+        try Self.createTestLogsDatabase(at: dbURL)
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            timestamp: "2026-05-10T12:00:00Z",
+            body: "thread_id=thread turn.id=turn websocket request: "
+                + #"{"type":"response.create","model":"request-alias","service_tier":"priority"}"#)
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            timestamp: "2026-05-10T12:00:01Z",
+            body: "thread_id=thread turn.id=turn websocket event: "
+                + #"{"type": "response.completed", "response": {"model": "completed-model"}}"#)
+
+        let turns = CostUsageScanner.codexPriorityTurns(databaseURL: dbURL)
+
+        #expect(turns["turn"]?.model == "completed-model")
+    }
+
+    @Test
+    func `sqlite scan only returns priority turns in requested day range`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+        let dbURL = env.root.appendingPathComponent("logs_2.sqlite")
+        try Self.createTestLogsDatabase(at: dbURL)
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 10)
+        let previousDay = try #require(Calendar.current.date(byAdding: .day, value: -1, to: day))
+        let dayKey = CostUsageScanner.CostUsageDayRange.dayKey(from: day)
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            timestamp: env.isoString(for: previousDay),
+            body: "thread_id=thread-old turn.id=turn-old websocket request: "
+                + #"{"type":"response.create","model":"request-model","service_tier":"priority"}"#)
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            timestamp: env.isoString(for: day),
+            body: "thread_id=thread-new turn.id=turn-new websocket request: "
+                + #"{"type":"response.create","model":"request-model","service_tier":"priority"}"#)
+
+        let turns = CostUsageScanner.codexPriorityTurns(
+            databaseURL: dbURL,
+            sinceDayKey: dayKey,
+            untilDayKey: dayKey)
+
+        #expect(turns.keys.sorted() == ["turn-new"])
+    }
+
+    @Test
+    func `sqlite scan uses local day boundaries for integer timestamps`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+        let dbURL = env.root.appendingPathComponent("logs_2.sqlite")
+        try Self.createTestLogsDatabase(at: dbURL)
+
+        var components = DateComponents()
+        components.calendar = Calendar.current
+        components.year = 2026
+        components.month = 5
+        components.day = 10
+        let dayStart = try #require(components.date)
+        let dayKey = CostUsageScanner.CostUsageDayRange.dayKey(from: dayStart)
+        let previousSecond = try #require(Calendar.current.date(byAdding: .second, value: -1, to: dayStart))
+        let nextSecond = try #require(Calendar.current.date(byAdding: .second, value: 1, to: dayStart))
+
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            epochSeconds: Int64(previousSecond.timeIntervalSince1970),
+            body: "thread_id=thread-before turn.id=turn-before websocket request: "
+                + #"{"type":"response.create","model":"request-model","service_tier":"priority"}"#)
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            epochSeconds: Int64(nextSecond.timeIntervalSince1970),
+            body: "thread_id=thread-after turn.id=turn-after websocket request: "
+                + #"{"type":"response.create","model":"request-model","service_tier":"priority"}"#)
+
+        let turns = CostUsageScanner.codexPriorityTurns(
+            databaseURL: dbURL,
+            sinceDayKey: dayKey,
+            untilDayKey: dayKey)
+
+        #expect(turns.keys.sorted() == ["turn-after"])
+    }
+
+    @Test
+    func `incremental memo picks up rows appended after the first query`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+        let dbURL = env.root.appendingPathComponent("logs_2.sqlite")
+        try Self.createTestLogsDatabase(at: dbURL)
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            timestamp: "2026-05-10T12:00:00Z",
+            body: "thread_id=thread-a turn.id=turn-a websocket request: "
+                + #"{"type":"response.create","model":"request-model","service_tier":"priority"}"#)
+
+        #expect(CostUsageScanner.codexPriorityTurns(databaseURL: dbURL).keys.sorted() == ["turn-a"])
+
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            timestamp: "2026-05-10T12:05:00Z",
+            body: "thread_id=thread-b turn.id=turn-b websocket request: "
+                + #"{"type":"response.create","model":"request-model","service_tier":"priority"}"#)
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            timestamp: "2026-05-10T12:05:01Z",
+            body: "thread_id=thread-a turn.id=turn-a websocket event: "
+                + #"{"type":"response.completed","response":{"model":"resolved-model"}}"#)
+
+        let merged = CostUsageScanner.codexPriorityTurns(databaseURL: dbURL)
+        #expect(merged.keys.sorted() == ["turn-a", "turn-b"])
+        // A completed event appended later still upgrades the model of a turn accumulated earlier.
+        #expect(merged["turn-a"]?.model == "resolved-model")
+    }
+
+    @Test
+    func `memo drops pruned requests while ids keep increasing`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+        let dbURL = env.root.appendingPathComponent("logs_2.sqlite")
+        try Self.createTestLogsDatabase(at: dbURL)
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            timestamp: "2026-05-10T12:00:00Z",
+            body: "thread_id=thread-a turn.id=turn-a websocket request: "
+                + #"{"type":"response.create","model":"request-model","service_tier":"priority"}"#)
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            timestamp: "2026-05-10T12:01:00Z",
+            body: "thread_id=thread-b turn.id=turn-b websocket request: "
+                + #"{"type":"response.create","model":"request-model","service_tier":"priority"}"#)
+        #expect(CostUsageScanner.codexPriorityTurns(databaseURL: dbURL).keys.sorted() == ["turn-a", "turn-b"])
+
+        try Self.execDatabase(dbURL: dbURL, sql: "delete from logs where rowid = 1")
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            timestamp: "2026-05-10T12:02:00Z",
+            body: "thread_id=thread-c turn.id=turn-c websocket request: "
+                + #"{"type":"response.create","model":"request-model","service_tier":"priority"}"#)
+
+        let rebuilt = CostUsageScanner.codexPriorityTurns(databaseURL: dbURL)
+        #expect(rebuilt.keys.sorted() == ["turn-b", "turn-c"])
+    }
+
+    @Test
+    func `memo drops a pruned completion model without losing its request`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+        let dbURL = env.root.appendingPathComponent("logs_2.sqlite")
+        try Self.createTestLogsDatabase(at: dbURL)
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            timestamp: "2026-05-10T12:00:00Z",
+            body: "thread_id=thread-a turn.id=turn-a websocket request: "
+                + #"{"type":"response.create","model":"request-alias","service_tier":"priority"}"#)
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            timestamp: "2026-05-10T12:00:01Z",
+            body: "thread_id=thread-a turn.id=turn-a websocket event: "
+                + #"{"type":"response.completed","response":{"model":"resolved-model"}}"#)
+        #expect(CostUsageScanner.codexPriorityTurns(databaseURL: dbURL)["turn-a"]?.model == "resolved-model")
+
+        try Self.execDatabase(dbURL: dbURL, sql: "delete from logs where rowid = 2")
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            timestamp: "2026-05-10T12:01:00Z",
+            body: "thread_id=thread-b turn.id=turn-b websocket request: "
+                + #"{"type":"response.create","model":"request-model","service_tier":"priority"}"#)
+
+        let pruned = CostUsageScanner.codexPriorityTurns(databaseURL: dbURL)
+        #expect(pruned["turn-a"]?.model == "request-alias")
+        #expect(pruned["turn-b"]?.model == "request-model")
+    }
+
+    @Test
+    func `memo falls back to retained duplicate request and completion rows`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+        let dbURL = env.root.appendingPathComponent("logs_2.sqlite")
+        try Self.createTestLogsDatabase(at: dbURL)
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            timestamp: "2026-05-10T12:00:00Z",
+            body: "thread_id=thread-old turn.id=turn-a websocket request: "
+                + #"{"type":"response.create","model":"request-old","service_tier":"priority"}"#)
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            timestamp: "2026-05-10T12:00:01Z",
+            body: "thread_id=thread-new turn.id=turn-a websocket request: "
+                + #"{"type":"response.create","model":"request-new","service_tier":"priority"}"#)
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            timestamp: "2026-05-10T12:00:02Z",
+            body: "thread_id=thread-old turn.id=turn-a websocket event: "
+                + #"{"type":"response.completed","response":{"model":"completed-old"}}"#)
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            timestamp: "2026-05-10T12:00:03Z",
+            body: "thread_id=thread-new turn.id=turn-a websocket event: "
+                + #"{"type":"response.completed","response":{"model":"completed-new"}}"#)
+
+        let initial = CostUsageScanner.codexPriorityTurns(databaseURL: dbURL)
+        #expect(initial["turn-a"]?.threadID == "thread-new")
+        #expect(initial["turn-a"]?.model == "completed-new")
+
+        try Self.execDatabase(dbURL: dbURL, sql: "delete from logs where rowid in (2, 4)")
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            timestamp: "2026-05-10T12:01:00Z",
+            body: "thread_id=thread-b turn.id=turn-b websocket request: "
+                + #"{"type":"response.create","model":"request-model","service_tier":"priority"}"#)
+
+        let pruned = CostUsageScanner.codexPriorityTurns(databaseURL: dbURL)
+        #expect(pruned["turn-a"]?.threadID == "thread-old")
+        #expect(pruned["turn-a"]?.model == "completed-old")
+        #expect(pruned["turn-b"]?.model == "request-model")
+    }
+
+    @Test
+    func `failed incremental scan does not report completion`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+        let dbURL = env.root.appendingPathComponent("logs_2.sqlite")
+        try Self.createTestLogsDatabase(at: dbURL)
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            timestamp: "2026-05-10T12:00:00Z",
+            body: "thread_id=thread-a turn.id=turn-a websocket request: "
+                + #"{"type":"response.create","model":"request-model","service_tier":"priority"}"#)
+
+        var db: OpaquePointer?
+        guard sqlite3_open_v2(dbURL.path, &db, SQLITE_OPEN_READONLY, nil) == SQLITE_OK else {
+            throw SQLiteTestError.open
+        }
+        defer { sqlite3_close(db) }
+        sqlite3_progress_handler(db, 1, { _ in 1 }, nil)
+
+        var state = CostUsageScanner.CodexPriorityTurnsMemoState(
+            observationID: 1,
+            coverageSinceEpoch: 0,
+            lastRowID: 0,
+            fileIdentity: nil,
+            turns: [:],
+            requestSourcesByTurnID: [:],
+            priorityCompletedModelsByTurnID: [:],
+            completedModelsByTurnID: [:],
+            completedTurnIDInsertionOrder: [],
+            completedTurnIDInsertionOrderStartIndex: 0)
+
+        #expect(!CostUsageScanner._test_accumulateCodexPriorityTurns(db, into: &state))
+    }
+
+    @Test
+    func `memo rescans when requested window expands earlier than accumulated coverage`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+        let dbURL = env.root.appendingPathComponent("logs_2.sqlite")
+        try Self.createTestLogsDatabase(at: dbURL)
+        // Live refreshes always query through today, which is the memoized path.
+        let today = Date()
+        let yesterday = try #require(Calendar.current.date(byAdding: .day, value: -1, to: today))
+        let todayKey = CostUsageScanner.CostUsageDayRange.dayKey(from: today)
+        let yesterdayKey = CostUsageScanner.CostUsageDayRange.dayKey(from: yesterday)
+        let formatter = ISO8601DateFormatter()
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            timestamp: formatter.string(from: yesterday),
+            body: "thread_id=thread-old turn.id=turn-old websocket request: "
+                + #"{"type":"response.create","model":"request-model","service_tier":"priority"}"#)
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            timestamp: formatter.string(from: today),
+            body: "thread_id=thread-new turn.id=turn-new websocket request: "
+                + #"{"type":"response.create","model":"request-model","service_tier":"priority"}"#)
+
+        let narrow = CostUsageScanner.codexPriorityTurns(
+            databaseURL: dbURL,
+            sinceDayKey: todayKey,
+            untilDayKey: todayKey)
+        #expect(narrow.keys.sorted() == ["turn-new"])
+
+        let expanded = CostUsageScanner.codexPriorityTurns(
+            databaseURL: dbURL,
+            sinceDayKey: yesterdayKey,
+            untilDayKey: todayKey)
+        #expect(expanded.keys.sorted() == ["turn-new", "turn-old"])
+    }
+
+    @Test
+    func `memo rescans when the database shrinks or is replaced`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+        let dbURL = env.root.appendingPathComponent("logs_2.sqlite")
+        try Self.createTestLogsDatabase(at: dbURL)
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            timestamp: "2026-05-10T12:00:00Z",
+            body: "thread_id=thread-a turn.id=turn-a websocket request: "
+                + #"{"type":"response.create","model":"request-model","service_tier":"priority"}"#)
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            timestamp: "2026-05-10T12:01:00Z",
+            body: "thread_id=thread-b turn.id=turn-b websocket request: "
+                + #"{"type":"response.create","model":"request-model","service_tier":"priority"}"#)
+        #expect(CostUsageScanner.codexPriorityTurns(databaseURL: dbURL).count == 2)
+
+        try FileManager.default.removeItem(at: dbURL)
+        try Self.createTestLogsDatabase(at: dbURL)
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            timestamp: "2026-05-11T09:00:00Z",
+            body: "thread_id=thread-c turn.id=turn-c websocket request: "
+                + #"{"type":"response.create","model":"request-model","service_tier":"priority"}"#)
+
+        let replaced = CostUsageScanner.codexPriorityTurns(databaseURL: dbURL)
+        #expect(replaced.keys.sorted() == ["turn-c"])
+    }
+
+    @Test
+    func `database replacement during open is rejected`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+        let dbURL = env.root.appendingPathComponent("logs_2.sqlite")
+        let oldURL = env.root.appendingPathComponent("logs-old.sqlite")
+        try Self.createTestLogsDatabase(at: dbURL)
+        var replacementError: Error?
+
+        let opened = CostUsageScanner.openCodexPriorityDatabase(at: dbURL) {
+            do {
+                try FileManager.default.moveItem(at: dbURL, to: oldURL)
+                try Self.createTestLogsDatabase(at: dbURL)
+            } catch {
+                replacementError = error
+            }
+        }
+        if let opened {
+            sqlite3_close(opened.db)
+        }
+
+        #expect(replacementError == nil)
+        #expect(opened == nil)
+    }
+
+    @Test
+    func `overlapping refresh writeback cannot replace newer memo state`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+        let dbURL = env.root.appendingPathComponent("logs_2.sqlite")
+        try Self.createTestLogsDatabase(at: dbURL)
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            timestamp: "2026-05-10T12:00:00Z",
+            body: "thread_id=thread-a turn.id=turn-a websocket request: "
+                + #"{"type":"response.create","model":"request-model","service_tier":"priority"}"#)
+        try Self.insertTestLog(
+            dbURL: dbURL,
+            timestamp: "2026-05-10T12:01:00Z",
+            body: "thread_id=thread-b turn.id=turn-b websocket request: "
+                + #"{"type":"response.create","model":"request-model","service_tier":"priority"}"#)
+        #expect(CostUsageScanner.codexPriorityTurns(databaseURL: dbURL).count == 2)
+        let stored = try #require(CostUsageScanner._test_codexPriorityTurnsMemoState(forPath: dbURL.path))
+
+        // A slower overlapping refresh writes back a snapshot read before the second row was
+        // appended: an older cursor that only observed the first turn. It must not win.
+        var stale = stored
+        stale.lastRowID -= 1
+        stale.turns = stored.turns.filter { $0.key == "turn-a" }
+        CostUsageScanner.storeCodexPriorityTurnsMemoIfNewer(stale, forPath: dbURL.path)
+
+        let retained = try #require(CostUsageScanner._test_codexPriorityTurnsMemoState(forPath: dbURL.path))
+        #expect(retained.lastRowID == stored.lastRowID)
+        #expect(retained.turns.keys.sorted() == ["turn-a", "turn-b"])
+
+        // A snapshot with a newer cursor still replaces the stored state.
+        var newer = stored
+        newer.lastRowID += 1
+        CostUsageScanner.storeCodexPriorityTurnsMemoIfNewer(newer, forPath: dbURL.path)
+        #expect(
+            CostUsageScanner._test_codexPriorityTurnsMemoState(forPath: dbURL.path)?
+                .lastRowID == stored.lastRowID + 1)
+
+        // A full rescan that expanded coverage earlier than the stored window also replaces,
+        // even when its cursor is not ahead, so broader history is never discarded.
+        var broader = stored
+        broader.coverageSinceEpoch -= 1
+        CostUsageScanner.storeCodexPriorityTurnsMemoIfNewer(broader, forPath: dbURL.path)
+        #expect(
+            CostUsageScanner._test_codexPriorityTurnsMemoState(forPath: dbURL.path)?
+                .coverageSinceEpoch == broader.coverageSinceEpoch)
+    }
+
+    @Test
+    func `memo bounds retained completion metadata for non-priority turns`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+        let dbURL = env.root.appendingPathComponent("logs_2.sqlite")
+        try Self.createTestLogsDatabase(at: dbURL)
+        let limit = CostUsageScanner.codexPriorityCompletedModelRetentionLimit
+        let overflow = limit + 8
+        let epoch = Self.epochSeconds("2026-05-10T12:00:00Z")
+
+        // A known priority turn keeps its resolved completion outside the bounded pending
+        // cache while thousands of unrelated completions flow through the process.
+        var rows = [
+            (
+                epochSeconds: epoch,
+                body: "thread_id=priority turn.id=priority websocket request: "
+                    + #"{"type":"response.create","model":"priority-alias","service_tier":"priority"}"#),
+            (
+                epochSeconds: epoch,
+                body: "thread_id=priority turn.id=priority websocket event: "
+                    + #"{"type":"response.completed","response":{"model":"resolved-model"}}"#),
+        ]
+        rows.append(contentsOf: (0..<(limit + overflow)).map { index in
+            (
+                epochSeconds: epoch,
+                body: "thread_id=thread-\(index) turn.id=turn-\(index) websocket event: "
+                    + #"{"type":"response.completed","response":{"model":"completed-model"}}"#)
+        })
+        rows.append((
+            epochSeconds: epoch,
+            body: "thread_id=thread-0 turn.id=turn-0 websocket request: "
+                + #"{"type":"response.create","model":"alias-evicted","service_tier":"priority"}"#))
+        let newest = limit + overflow - 1
+        rows.append((
+            epochSeconds: epoch,
+            body: "thread_id=thread-\(newest) turn.id=turn-\(newest) "
+                + "websocket request: "
+                + #"{"type":"response.create","model":"alias-retained","service_tier":"priority"}"#))
+        try Self.insertTestLogs(dbURL: dbURL, rows: rows)
+
+        let turns = CostUsageScanner.codexPriorityTurns(databaseURL: dbURL)
+
+        let memo = try #require(CostUsageScanner._test_codexPriorityTurnsMemoState(forPath: dbURL.path))
+        #expect(memo.completedModelsByTurnID.count == limit - 1)
+        #expect(
+            memo.completedTurnIDInsertionOrder.count
+                - memo.completedTurnIDInsertionOrderStartIndex == limit - 1)
+        #expect(memo.completedTurnIDInsertionOrder.count < limit * 2)
+        #expect(memo.priorityCompletedModelsByTurnID.count == 2)
+        // The oldest completions were evicted, so the early request keeps its alias; the
+        // recent completion is still retained and upgrades its request.
+        #expect(turns["priority"]?.model == "resolved-model")
+        #expect(turns["turn-0"]?.model == "alias-evicted")
+        #expect(turns["turn-\(newest)"]?.model == "completed-model")
+    }
+
+    static func insertTestLogs(dbURL: URL, rows: [(epochSeconds: Int64, body: String)]) throws {
+        var db: OpaquePointer?
+        guard sqlite3_open(dbURL.path, &db) == SQLITE_OK else { throw SQLiteTestError.open }
+        defer { sqlite3_close(db) }
+
+        var stmt: OpaquePointer?
+        guard sqlite3_prepare_v2(db, "insert into logs (ts, feedback_log_body) values (?, ?)", -1, &stmt, nil)
+            == SQLITE_OK
+        else { throw SQLiteTestError.prepare }
+        defer { sqlite3_finalize(stmt) }
+
+        try self.exec(db, "begin transaction")
+        let transient = unsafeBitCast(-1, to: sqlite3_destructor_type.self)
+        for row in rows {
+            sqlite3_bind_int64(stmt, 1, row.epochSeconds)
+            sqlite3_bind_text(stmt, 2, row.body, -1, transient)
+            guard sqlite3_step(stmt) == SQLITE_DONE else { throw SQLiteTestError.step }
+            sqlite3_reset(stmt)
+        }
+        try self.exec(db, "commit")
+    }
+
+    static func createTestLogsDatabase(at dbURL: URL) throws {
+        var db: OpaquePointer?
+        guard sqlite3_open(dbURL.path, &db) == SQLITE_OK else { throw SQLiteTestError.open }
+        defer { sqlite3_close(db) }
+        try self.exec(
+            db,
+            "create table logs (id integer primary key autoincrement, ts integer not null, feedback_log_body text)")
+        try self.exec(db, "create index idx_logs_ts on logs(ts desc, id desc)")
+    }
+
+    static func queryPlan(
+        db: OpaquePointer?,
+        query: String,
+        bindings: [Int64]) throws -> [String]
+    {
+        var stmt: OpaquePointer?
+        guard sqlite3_prepare_v2(db, "explain query plan \(query)", -1, &stmt, nil) == SQLITE_OK else {
+            throw SQLiteTestError.prepare
+        }
+        defer { sqlite3_finalize(stmt) }
+        for (offset, value) in bindings.enumerated() {
+            sqlite3_bind_int64(stmt, Int32(offset + 1), value)
+        }
+
+        var details: [String] = []
+        while sqlite3_step(stmt) == SQLITE_ROW {
+            if let detail = sqlite3_column_text(stmt, 3) {
+                details.append(String(cString: detail))
+            }
+        }
+        return details
+    }
+
+    static func insertTestLog(dbURL: URL, timestamp: String, body: String) throws {
+        try self.insertTestLog(dbURL: dbURL, epochSeconds: self.epochSeconds(timestamp), body: body)
+    }
+
+    static func insertTestLog(dbURL: URL, epochSeconds: Int64, body: String) throws {
+        var db: OpaquePointer?
+        guard sqlite3_open(dbURL.path, &db) == SQLITE_OK else { throw SQLiteTestError.open }
+        defer { sqlite3_close(db) }
+
+        var stmt: OpaquePointer?
+        guard sqlite3_prepare_v2(db, "insert into logs (ts, feedback_log_body) values (?, ?)", -1, &stmt, nil)
+            == SQLITE_OK
+        else { throw SQLiteTestError.prepare }
+        defer { sqlite3_finalize(stmt) }
+
+        let transient = unsafeBitCast(-1, to: sqlite3_destructor_type.self)
+        sqlite3_bind_int64(stmt, 1, epochSeconds)
+        sqlite3_bind_text(stmt, 2, body, -1, transient)
+        guard sqlite3_step(stmt) == SQLITE_DONE else { throw SQLiteTestError.step }
+    }
+
+    private static func execDatabase(dbURL: URL, sql: String) throws {
+        var db: OpaquePointer?
+        guard sqlite3_open(dbURL.path, &db) == SQLITE_OK else { throw SQLiteTestError.open }
+        defer { sqlite3_close(db) }
+        try self.exec(db, sql)
+    }
+
+    private static func epochSeconds(_ timestamp: String) -> Int64 {
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime]
+        guard let date = formatter.date(from: timestamp) else { return 0 }
+        return Int64(date.timeIntervalSince1970)
+    }
+
+    private static func exec(_ db: OpaquePointer?, _ sql: String) throws {
+        var message: UnsafeMutablePointer<CChar>?
+        guard sqlite3_exec(db, sql, nil, nil, &message) == SQLITE_OK else {
+            sqlite3_free(message)
+            throw SQLiteTestError.exec
+        }
+    }
+
+    private enum SQLiteTestError: Error {
+        case open
+        case prepare
+        case step
+        case exec
+    }
+}
+#endif
diff --git a/Tests/CodexBarTests/CostUsageScannerPriorityTests.swift b/Tests/CodexBarTests/CostUsageScannerPriorityTests.swift
new file mode 100644
index 0000000000..8bdaaf5e26
--- /dev/null
+++ b/Tests/CodexBarTests/CostUsageScannerPriorityTests.swift
@@ -0,0 +1,680 @@
+import Foundation
+#if canImport(SQLite3)
+import Testing
+@testable import CodexBarCore
+
+struct CostUsageScannerPriorityTests {
+    @Test
+    func `codex daily report applies gpt55 priority rates`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 10)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let iso2 = env.isoString(for: day.addingTimeInterval(2))
+        let iso3 = env.isoString(for: day.addingTimeInterval(3))
+
+        let entries: [[String: Any]] = [
+            ["type": "turn_context", "timestamp": iso0, "payload": ["model": "gpt-5.5"]],
+            ["type": "event_msg", "timestamp": iso1, "payload": ["type": "task_started", "turn_id": "standard-turn"]],
+            self.tokenCount(timestamp: iso2, input: 100, cached: 20, output: 10),
+            ["type": "event_msg", "timestamp": iso3, "payload": ["type": "task_started", "turn_id": "priority-turn"]],
+            self.tokenCount(timestamp: iso3, input: 100, cached: 20, output: 10),
+        ]
+        _ = try env.writeCodexSessionFile(day: day, filename: "session.jsonl", contents: env.jsonl(entries))
+
+        let dbURL = env.root.appendingPathComponent("logs_2.sqlite")
+        try CostUsageScannerCodexPriorityTests.createTestLogsDatabase(at: dbURL)
+        try self.insertPriorityTrace(dbURL: dbURL, timestamp: iso3)
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            cacheRoot: env.cacheRoot,
+            codexTraceDatabaseURL: dbURL)
+        options.refreshMinIntervalSeconds = 0
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+        let standardCost = (80.0 * 5e-6) + (20.0 * 5e-7) + (10.0 * 3e-5)
+        let priorityCost = (80.0 * 1.25e-5) + (20.0 * 1.25e-6) + (10.0 * 7.5e-5)
+
+        #expect(report.summary?.totalCostUSD == standardCost + priorityCost)
+        let breakdown = try #require(report.data.first?.modelBreakdowns?.first)
+        #expect(breakdown.costUSD == standardCost + priorityCost)
+        #expect(breakdown.standardCostUSD == standardCost)
+        #expect(breakdown.priorityCostUSD == priorityCost)
+        #expect(breakdown.standardTokens == 110)
+        #expect(breakdown.priorityTokens == 110)
+    }
+
+    @Test
+    func `codex daily report keeps cached priority surcharge without live sqlite metadata`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 10)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let entries: [[String: Any]] = [
+            ["type": "turn_context", "timestamp": iso0, "payload": ["model": "gpt-5.5"]],
+            ["type": "event_msg", "timestamp": iso1, "payload": ["type": "task_started", "turn_id": "priority-turn"]],
+            self.tokenCount(timestamp: iso1, input: 100, cached: 20, output: 10),
+        ]
+        _ = try env.writeCodexSessionFile(day: day, filename: "session.jsonl", contents: env.jsonl(entries))
+
+        let dbURL = env.root.appendingPathComponent("logs_2.sqlite")
+        try CostUsageScannerCodexPriorityTests.createTestLogsDatabase(at: dbURL)
+        try self.insertPriorityTrace(dbURL: dbURL, timestamp: iso1)
+
+        var refreshOptions = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            cacheRoot: env.cacheRoot,
+            codexTraceDatabaseURL: dbURL)
+        refreshOptions.refreshMinIntervalSeconds = 0
+
+        _ = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: refreshOptions)
+
+        var cachedOptions = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            cacheRoot: env.cacheRoot,
+            codexTraceDatabaseURL: env.root.appendingPathComponent("missing.sqlite"))
+        cachedOptions.refreshMinIntervalSeconds = 60
+
+        let cached = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day.addingTimeInterval(1),
+            options: cachedOptions)
+        let priorityCost = (80.0 * 1.25e-5) + (20.0 * 1.25e-6) + (10.0 * 7.5e-5)
+
+        #expect(cached.summary?.totalCostUSD == priorityCost)
+        let breakdown = try #require(cached.data.first?.modelBreakdowns?.first)
+        #expect(breakdown.priorityCostUSD == priorityCost)
+        #expect(breakdown.priorityTokens == 110)
+    }
+
+    @Test
+    func `codex daily report rescans when priority metadata appears`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 10)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let entries: [[String: Any]] = [
+            ["type": "turn_context", "timestamp": iso0, "payload": ["model": "gpt-5.5"]],
+            ["type": "event_msg", "timestamp": iso1, "payload": ["type": "task_started", "turn_id": "priority-turn"]],
+            self.tokenCount(timestamp: iso1, input: 100, cached: 20, output: 10),
+        ]
+        _ = try env.writeCodexSessionFile(day: day, filename: "session.jsonl", contents: env.jsonl(entries))
+
+        let dbURL = env.root.appendingPathComponent("logs_2.sqlite")
+        var missingOptions = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            cacheRoot: env.cacheRoot,
+            codexTraceDatabaseURL: dbURL)
+        missingOptions.refreshMinIntervalSeconds = 0
+
+        let first = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: missingOptions)
+        let baseCost = (80.0 * 5e-6) + (20.0 * 5e-7) + (10.0 * 3e-5)
+        #expect(first.summary?.totalCostUSD == baseCost)
+
+        try CostUsageScannerCodexPriorityTests.createTestLogsDatabase(at: dbURL)
+        try self.insertPriorityTrace(dbURL: dbURL, timestamp: iso1)
+
+        var liveOptions = missingOptions
+        liveOptions.refreshMinIntervalSeconds = 60
+        let rescanned = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day.addingTimeInterval(1),
+            options: liveOptions)
+        let priorityCost = (80.0 * 1.25e-5) + (20.0 * 1.25e-6) + (10.0 * 7.5e-5)
+
+        #expect(rescanned.summary?.totalCostUSD == priorityCost)
+    }
+
+    @Test
+    func `codex daily report ignores unrelated priority wal changes`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 10)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let entries: [[String: Any]] = [
+            ["type": "turn_context", "timestamp": iso0, "payload": ["model": "gpt-5.5"]],
+            ["type": "event_msg", "timestamp": iso1, "payload": ["type": "task_started", "turn_id": "priority-turn"]],
+            self.tokenCount(timestamp: iso1, input: 100, cached: 20, output: 10),
+        ]
+        _ = try env.writeCodexSessionFile(day: day, filename: "session.jsonl", contents: env.jsonl(entries))
+
+        let dbURL = env.root.appendingPathComponent("logs_2.sqlite")
+        try CostUsageScannerCodexPriorityTests.createTestLogsDatabase(at: dbURL)
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            cacheRoot: env.cacheRoot,
+            codexTraceDatabaseURL: dbURL)
+        options.refreshMinIntervalSeconds = 0
+
+        let first = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+        let baseCost = (80.0 * 5e-6) + (20.0 * 5e-7) + (10.0 * 3e-5)
+        #expect(first.summary?.totalCostUSD == baseCost)
+
+        let walURL = URL(fileURLWithPath: dbURL.path + "-wal")
+        try Data("wal-changed".utf8).write(to: walURL)
+
+        options.refreshMinIntervalSeconds = 60
+        let cached = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day.addingTimeInterval(1),
+            options: options)
+
+        #expect(cached.summary?.totalCostUSD == baseCost)
+    }
+
+    @Test
+    func `codex daily report reprices cached file when priority turn appears`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 10)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let entries: [[String: Any]] = [
+            ["type": "turn_context", "timestamp": iso0, "payload": ["model": "gpt-5.5"]],
+            ["type": "event_msg", "timestamp": iso1, "payload": ["type": "task_started", "turn_id": "priority-turn"]],
+            self.tokenCount(timestamp: iso1, input: 100, cached: 20, output: 10),
+        ]
+        _ = try env.writeCodexSessionFile(day: day, filename: "session.jsonl", contents: env.jsonl(entries))
+
+        let dbURL = env.root.appendingPathComponent("logs_2.sqlite")
+        try CostUsageScannerCodexPriorityTests.createTestLogsDatabase(at: dbURL)
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            cacheRoot: env.cacheRoot,
+            codexTraceDatabaseURL: dbURL)
+        options.refreshMinIntervalSeconds = 0
+
+        let first = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+        let baseCost = (80.0 * 5e-6) + (20.0 * 5e-7) + (10.0 * 3e-5)
+        #expect(first.summary?.totalCostUSD == baseCost)
+
+        try self.insertPriorityTrace(dbURL: dbURL, timestamp: iso1)
+
+        options.refreshMinIntervalSeconds = 60
+        let repriced = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day.addingTimeInterval(61),
+            options: options)
+        let priorityCost = (80.0 * 1.25e-5) + (20.0 * 1.25e-6) + (10.0 * 7.5e-5)
+
+        #expect(repriced.summary?.totalCostUSD == priorityCost)
+    }
+
+    @Test
+    func `codex daily report applies gpt54 priority rates`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 10)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let iso2 = env.isoString(for: day.addingTimeInterval(2))
+        let iso3 = env.isoString(for: day.addingTimeInterval(3))
+
+        let entries: [[String: Any]] = [
+            ["type": "turn_context", "timestamp": iso0, "payload": ["model": "gpt-5.4"]],
+            ["type": "event_msg", "timestamp": iso1, "payload": ["type": "task_started", "turn_id": "standard-turn"]],
+            self.tokenCount(timestamp: iso2, input: 100, cached: 20, output: 10),
+            ["type": "event_msg", "timestamp": iso3, "payload": ["type": "task_started", "turn_id": "priority-turn"]],
+            self.tokenCount(timestamp: iso3, input: 100, cached: 20, output: 10),
+        ]
+        _ = try env.writeCodexSessionFile(day: day, filename: "session.jsonl", contents: env.jsonl(entries))
+
+        let dbURL = env.root.appendingPathComponent("logs_2.sqlite")
+        try CostUsageScannerCodexPriorityTests.createTestLogsDatabase(at: dbURL)
+        try self.insertPriorityTrace(dbURL: dbURL, timestamp: iso3, model: "gpt-5.4")
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            cacheRoot: env.cacheRoot,
+            codexTraceDatabaseURL: dbURL)
+        options.refreshMinIntervalSeconds = 0
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+        let standardCost = (80.0 * 2.5e-6) + (20.0 * 2.5e-7) + (10.0 * 1.5e-5)
+        let priorityCost = (80.0 * 5e-6) + (20.0 * 5e-7) + (10.0 * 3e-5)
+
+        #expect(report.summary?.totalCostUSD == standardCost + priorityCost)
+    }
+
+    @Test
+    func `codex daily report prices priority alias with completed response model`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 10)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let entries: [[String: Any]] = [
+            ["type": "turn_context", "timestamp": iso0, "payload": ["model": "codex-auto-review"]],
+            ["type": "event_msg", "timestamp": iso1, "payload": ["type": "task_started", "turn_id": "priority-turn"]],
+            self.tokenCount(timestamp: iso1, input: 100, cached: 20, output: 10),
+        ]
+        _ = try env.writeCodexSessionFile(day: day, filename: "session.jsonl", contents: env.jsonl(entries))
+
+        let dbURL = env.root.appendingPathComponent("logs_2.sqlite")
+        try CostUsageScannerCodexPriorityTests.createTestLogsDatabase(at: dbURL)
+        try self.insertPriorityTrace(dbURL: dbURL, timestamp: iso1, model: "codex-auto-review")
+        try CostUsageScannerCodexPriorityTests.insertTestLog(
+            dbURL: dbURL,
+            timestamp: iso1,
+            body: "thread_id=thread turn.id=priority-turn websocket event: "
+                + #"{"type":"response.completed","response":{"model":"gpt-5.4"}}"#)
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            cacheRoot: env.cacheRoot,
+            codexTraceDatabaseURL: dbURL)
+        options.refreshMinIntervalSeconds = 0
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+        let priorityCost = (80.0 * 5e-6) + (20.0 * 5e-7) + (10.0 * 3e-5)
+
+        #expect(report.summary?.totalCostUSD == priorityCost)
+        let breakdown = try #require(report.data.first?.modelBreakdowns?.first)
+        #expect(breakdown.priorityCostUSD == priorityCost)
+        #expect(breakdown.priorityTokens == 110)
+    }
+
+    @Test
+    func `codex daily report totals use completed model priority cost`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 10)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let entries: [[String: Any]] = [
+            ["type": "turn_context", "timestamp": iso0, "payload": ["model": "gpt-5.4"]],
+            ["type": "event_msg", "timestamp": iso1, "payload": ["type": "task_started", "turn_id": "priority-turn"]],
+            self.tokenCount(timestamp: iso1, input: 100, cached: 20, output: 10),
+        ]
+        _ = try env.writeCodexSessionFile(day: day, filename: "session.jsonl", contents: env.jsonl(entries))
+
+        let dbURL = env.root.appendingPathComponent("logs_2.sqlite")
+        try CostUsageScannerCodexPriorityTests.createTestLogsDatabase(at: dbURL)
+        try self.insertPriorityTrace(dbURL: dbURL, timestamp: iso1, model: "gpt-5.4")
+        try CostUsageScannerCodexPriorityTests.insertTestLog(
+            dbURL: dbURL,
+            timestamp: iso1,
+            body: "thread_id=thread turn.id=priority-turn websocket event: "
+                + #"{"type":"response.completed","response":{"model":"gpt-5.5"}}"#)
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            cacheRoot: env.cacheRoot,
+            codexTraceDatabaseURL: dbURL)
+        options.refreshMinIntervalSeconds = 0
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+        let priorityCost = (80.0 * 1.25e-5) + (20.0 * 1.25e-6) + (10.0 * 7.5e-5)
+
+        #expect(report.summary?.totalCostUSD == priorityCost)
+        let breakdown = try #require(report.data.first?.modelBreakdowns?.first)
+        #expect(breakdown.costUSD == priorityCost)
+        #expect(breakdown.priorityCostUSD == priorityCost)
+    }
+
+    @Test
+    func `codex daily report reprices cached priority alias when completed model arrives`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 10)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let entries: [[String: Any]] = [
+            ["type": "turn_context", "timestamp": iso0, "payload": ["model": "codex-auto-review"]],
+            ["type": "event_msg", "timestamp": iso1, "payload": ["type": "task_started", "turn_id": "priority-turn"]],
+            self.tokenCount(timestamp: iso1, input: 100, cached: 20, output: 10),
+        ]
+        _ = try env.writeCodexSessionFile(day: day, filename: "session.jsonl", contents: env.jsonl(entries))
+
+        let dbURL = env.root.appendingPathComponent("logs_2.sqlite")
+        try CostUsageScannerCodexPriorityTests.createTestLogsDatabase(at: dbURL)
+        try self.insertPriorityTrace(dbURL: dbURL, timestamp: iso1, model: "codex-auto-review")
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            cacheRoot: env.cacheRoot,
+            codexTraceDatabaseURL: dbURL)
+        options.refreshMinIntervalSeconds = 0
+
+        let first = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+        #expect(first.summary?.totalCostUSD == nil)
+
+        try CostUsageScannerCodexPriorityTests.insertTestLog(
+            dbURL: dbURL,
+            timestamp: iso1,
+            body: "thread_id=thread turn.id=priority-turn websocket event: "
+                + #"{"type":"response.completed","response":{"model":"gpt-5.4"}}"#)
+
+        options.refreshMinIntervalSeconds = 60
+        let repriced = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day.addingTimeInterval(61),
+            options: options)
+        let priorityCost = (80.0 * 5e-6) + (20.0 * 5e-7) + (10.0 * 3e-5)
+
+        #expect(repriced.summary?.totalCostUSD == priorityCost)
+        let breakdown = try #require(repriced.data.first?.modelBreakdowns?.first)
+        #expect(breakdown.priorityCostUSD == priorityCost)
+        #expect(breakdown.priorityTokens == 110)
+    }
+
+    @Test
+    func `codex daily report falls back to session model for unpriced priority alias`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 10)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let entries: [[String: Any]] = [
+            ["type": "turn_context", "timestamp": iso0, "payload": ["model": "gpt-5.4"]],
+            ["type": "event_msg", "timestamp": iso1, "payload": ["type": "task_started", "turn_id": "priority-turn"]],
+            self.tokenCount(timestamp: iso1, input: 100, cached: 20, output: 10),
+        ]
+        _ = try env.writeCodexSessionFile(day: day, filename: "session.jsonl", contents: env.jsonl(entries))
+
+        let dbURL = env.root.appendingPathComponent("logs_2.sqlite")
+        try CostUsageScannerCodexPriorityTests.createTestLogsDatabase(at: dbURL)
+        try self.insertPriorityTrace(dbURL: dbURL, timestamp: iso1, model: "codex-auto-review")
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            cacheRoot: env.cacheRoot,
+            codexTraceDatabaseURL: dbURL)
+        options.refreshMinIntervalSeconds = 0
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+        let priorityCost = (80.0 * 5e-6) + (20.0 * 5e-7) + (10.0 * 3e-5)
+
+        #expect(report.summary?.totalCostUSD == priorityCost)
+        let breakdown = try #require(report.data.first?.modelBreakdowns?.first)
+        #expect(breakdown.priorityCostUSD == priorityCost)
+        #expect(breakdown.priorityTokens == 110)
+    }
+
+    @Test
+    func `codex daily report keeps base cost when sqlite metadata is missing`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 10)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let entries: [[String: Any]] = [
+            ["type": "turn_context", "timestamp": iso0, "payload": ["model": "gpt-5.5"]],
+            ["type": "event_msg", "timestamp": iso1, "payload": ["type": "task_started", "turn_id": "priority-turn"]],
+            self.tokenCount(timestamp: iso1, input: 100, cached: 20, output: 10),
+        ]
+        _ = try env.writeCodexSessionFile(day: day, filename: "session.jsonl", contents: env.jsonl(entries))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            cacheRoot: env.cacheRoot,
+            codexTraceDatabaseURL: env.root.appendingPathComponent("missing.sqlite"))
+        options.refreshMinIntervalSeconds = 0
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+        let expected = (80.0 * 5e-6) + (20.0 * 5e-7) + (10.0 * 3e-5)
+
+        #expect(report.summary?.totalCostUSD == expected)
+        let breakdown = try #require(report.data.first?.modelBreakdowns?.first)
+        #expect(breakdown.costUSD == expected)
+        #expect(breakdown.standardCostUSD == nil)
+        #expect(breakdown.priorityCostUSD == nil)
+        #expect(breakdown.standardTokens == nil)
+        #expect(breakdown.priorityTokens == nil)
+    }
+
+    @Test
+    func `codex daily report attributes base priced priority rows to fast bucket`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 10)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let entries: [[String: Any]] = [
+            ["type": "turn_context", "timestamp": iso0, "payload": ["model": "gpt-5.4-nano"]],
+            ["type": "event_msg", "timestamp": iso1, "payload": ["type": "task_started", "turn_id": "priority-turn"]],
+            self.tokenCount(timestamp: iso1, input: 100, cached: 20, output: 10),
+        ]
+        _ = try env.writeCodexSessionFile(day: day, filename: "session.jsonl", contents: env.jsonl(entries))
+
+        let dbURL = env.root.appendingPathComponent("logs_2.sqlite")
+        try CostUsageScannerCodexPriorityTests.createTestLogsDatabase(at: dbURL)
+        try self.insertPriorityTrace(dbURL: dbURL, timestamp: iso1, model: "gpt-5.4-nano")
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            cacheRoot: env.cacheRoot,
+            codexTraceDatabaseURL: dbURL)
+        options.refreshMinIntervalSeconds = 0
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+        let expected = (80.0 * 2e-7) + (20.0 * 2e-8) + (10.0 * 1.25e-6)
+
+        let breakdown = try #require(report.data.first?.modelBreakdowns?.first)
+        #expect(abs((report.summary?.totalCostUSD ?? 0) - expected) < 0.000_000_001)
+        #expect(abs((breakdown.costUSD ?? 0) - expected) < 0.000_000_001)
+        #expect(breakdown.standardCostUSD == nil)
+        #expect(abs((breakdown.priorityCostUSD ?? 0) - expected) < 0.000_000_001)
+        #expect(breakdown.standardTokens == nil)
+        #expect(breakdown.priorityTokens == 110)
+    }
+
+    @Test
+    func `codex pricing skips priority surcharge for long context rows`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 10)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let iso2 = env.isoString(for: day.addingTimeInterval(2))
+        let iso3 = env.isoString(for: day.addingTimeInterval(3))
+        let entries: [[String: Any]] = [
+            ["type": "turn_context", "timestamp": iso0, "payload": ["model": "gpt-5.5"]],
+            ["type": "event_msg", "timestamp": iso1, "payload": ["type": "task_started", "turn_id": "standard-turn"]],
+            self.tokenCount(timestamp: iso1, input: 272_001, cached: 0, output: 10),
+            ["type": "event_msg", "timestamp": iso2, "payload": ["type": "task_started", "turn_id": "priority-turn"]],
+            self.tokenCount(timestamp: iso2, input: 300_000, cached: 0, output: 5),
+            self.tokenCount(timestamp: iso3, input: 100_001, cached: 0, output: 5),
+        ]
+        _ = try env.writeCodexSessionFile(day: day, filename: "session.jsonl", contents: env.jsonl(entries))
+
+        let dbURL = env.root.appendingPathComponent("logs_2.sqlite")
+        try CostUsageScannerCodexPriorityTests.createTestLogsDatabase(at: dbURL)
+        try self.insertPriorityTrace(dbURL: dbURL, timestamp: iso2)
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            cacheRoot: env.cacheRoot,
+            codexTraceDatabaseURL: dbURL)
+        options.refreshMinIntervalSeconds = 0
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+        let standardTurnBase = (272_001.0 * 1e-5) + (10.0 * 4.5e-5)
+        let standardFirstRow = (300_000.0 * 1e-5) + (5.0 * 4.5e-5)
+        let prioritySecondRow = (100_001.0 * 1.25e-5) + (5.0 * 7.5e-5)
+
+        let expected = standardTurnBase + standardFirstRow + prioritySecondRow
+        #expect(abs((report.summary?.totalCostUSD ?? 0) - expected) < 0.000_000_001)
+    }
+
+    @Test
+    func `codex cumulative totals do not trigger long context pricing`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 10)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let iso2 = env.isoString(for: day.addingTimeInterval(2))
+        let iso3 = env.isoString(for: day.addingTimeInterval(3))
+        let entries: [[String: Any]] = [
+            ["type": "turn_context", "timestamp": iso0, "payload": ["model": "gpt-5.5"]],
+            ["type": "event_msg", "timestamp": iso1, "payload": ["type": "task_started", "turn_id": "standard-turn"]],
+            self.totalTokenCount(timestamp: iso1, input: 120_000, cached: 60000, output: 100),
+            self.totalTokenCount(timestamp: iso2, input: 240_000, cached: 120_000, output: 200),
+            ["type": "event_msg", "timestamp": iso3, "payload": ["type": "task_started", "turn_id": "priority-turn"]],
+            self.totalTokenCount(timestamp: iso3, input: 360_000, cached: 180_000, output: 300),
+        ]
+        _ = try env.writeCodexSessionFile(day: day, filename: "session.jsonl", contents: env.jsonl(entries))
+
+        let dbURL = env.root.appendingPathComponent("logs_2.sqlite")
+        try CostUsageScannerCodexPriorityTests.createTestLogsDatabase(at: dbURL)
+        try self.insertPriorityTrace(dbURL: dbURL, timestamp: iso3)
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            cacheRoot: env.cacheRoot,
+            codexTraceDatabaseURL: dbURL)
+        options.refreshMinIntervalSeconds = 0
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+        let standardRow = (Double(60000) * 5e-6) + (Double(60000) * 5e-7) + (Double(100) * 3e-5)
+        let priorityRow = (Double(60000) * 1.25e-5) + (Double(60000) * 1.25e-6) + (Double(100) * 7.5e-5)
+        let expected = standardRow + standardRow + priorityRow
+
+        #expect(abs((report.summary?.totalCostUSD ?? 0) - expected) < 0.000_000_001)
+    }
+
+    private func tokenCount(timestamp: String, input: Int, cached: Int, output: Int) -> [String: Any] {
+        [
+            "type": "event_msg",
+            "timestamp": timestamp,
+            "payload": [
+                "type": "token_count",
+                "info": [
+                    "last_token_usage": [
+                        "input_tokens": input,
+                        "cached_input_tokens": cached,
+                        "output_tokens": output,
+                    ],
+                ],
+            ],
+        ]
+    }
+
+    private func totalTokenCount(timestamp: String, input: Int, cached: Int, output: Int) -> [String: Any] {
+        [
+            "type": "event_msg",
+            "timestamp": timestamp,
+            "payload": [
+                "type": "token_count",
+                "info": [
+                    "total_token_usage": [
+                        "input_tokens": input,
+                        "cached_input_tokens": cached,
+                        "output_tokens": output,
+                    ],
+                ],
+            ],
+        ]
+    }
+
+    private func insertPriorityTrace(dbURL: URL, timestamp: String, model: String = "gpt-5.5") throws {
+        try CostUsageScannerCodexPriorityTests.insertTestLog(
+            dbURL: dbURL,
+            timestamp: timestamp,
+            body: "thread_id=thread turn.id=priority-turn websocket request: "
+                + #"{"type":"response.create","model":""# + model + #"","service_tier":"priority"}"#)
+    }
+}
+#endif
diff --git a/Tests/CodexBarTests/CostUsageScannerTests.swift b/Tests/CodexBarTests/CostUsageScannerTests.swift
index ecad8208d7..c94ce42a2a 100644
--- a/Tests/CodexBarTests/CostUsageScannerTests.swift
+++ b/Tests/CodexBarTests/CostUsageScannerTests.swift
@@ -2,213 +2,49 @@ import Foundation
 import Testing
 @testable import CodexBarCore
 
-@Suite
 struct CostUsageScannerTests {
     @Test
-    func codexDailyReportParsesTokenCountsAndCaches() throws {
-        let env = try CostUsageTestEnvironment()
-        defer { env.cleanup() }
-
-        let day = try env.makeLocalNoon(year: 2025, month: 12, day: 20)
-        let iso0 = env.isoString(for: day)
-        let iso1 = env.isoString(for: day.addingTimeInterval(1))
-        let iso2 = env.isoString(for: day.addingTimeInterval(2))
-
-        let model = "openai/gpt-5.2-codex"
-        let turnContext: [String: Any] = [
-            "type": "turn_context",
-            "timestamp": iso0,
-            "payload": [
-                "model": model,
-            ],
-        ]
-        let firstTokenCount: [String: Any] = [
-            "type": "event_msg",
-            "timestamp": iso1,
-            "payload": [
-                "type": "token_count",
-                "info": [
-                    "total_token_usage": [
-                        "input_tokens": 100,
-                        "cached_input_tokens": 20,
-                        "output_tokens": 10,
-                    ],
-                    "model": model,
-                ],
-            ],
-        ]
-
-        let fileURL = try env.writeCodexSessionFile(
-            day: day,
-            filename: "session.jsonl",
-            contents: env.jsonl([turnContext, firstTokenCount]))
-
-        var options = CostUsageScanner.Options(
-            codexSessionsRoot: env.codexSessionsRoot,
-            claudeProjectsRoots: nil,
-            cacheRoot: env.cacheRoot)
-        options.refreshMinIntervalSeconds = 0
-
-        let first = CostUsageScanner.loadDailyReport(
-            provider: .codex,
-            since: day,
-            until: day,
-            now: day,
-            options: options)
-        #expect(first.data.count == 1)
-        #expect(first.data[0].modelsUsed == ["gpt-5.2"])
-        #expect(first.data[0].totalTokens == 110)
-        #expect((first.data[0].costUSD ?? 0) > 0)
-
-        let secondTokenCount: [String: Any] = [
-            "type": "event_msg",
-            "timestamp": iso2,
-            "payload": [
-                "type": "token_count",
-                "info": [
-                    "total_token_usage": [
-                        "input_tokens": 160,
-                        "cached_input_tokens": 40,
-                        "output_tokens": 16,
-                    ],
-                    "model": model,
-                ],
-            ],
-        ]
-        try env.jsonl([turnContext, firstTokenCount, secondTokenCount])
-            .write(to: fileURL, atomically: true, encoding: .utf8)
-
-        let second = CostUsageScanner.loadDailyReport(
-            provider: .codex,
-            since: day,
-            until: day,
-            now: day,
-            options: options)
-        #expect(second.data.count == 1)
-        #expect(second.data[0].totalTokens == 176)
-        #expect((second.data[0].costUSD ?? 0) > (first.data[0].costUSD ?? 0))
-    }
-
-    @Test
-    func codexDailyReportIncludesArchivedSessionsAndDedupes() throws {
-        let env = try CostUsageTestEnvironment()
-        defer { env.cleanup() }
-
-        let day = try env.makeLocalNoon(year: 2025, month: 12, day: 22)
-        let iso0 = env.isoString(for: day)
-        let iso1 = env.isoString(for: day.addingTimeInterval(1))
-
-        let model = "openai/gpt-5.2-codex"
-        let sessionMeta: [String: Any] = [
-            "type": "session_meta",
-            "payload": [
-                "session_id": "sess-archived-1",
-            ],
-        ]
-        let turnContext: [String: Any] = [
-            "type": "turn_context",
-            "timestamp": iso0,
-            "payload": [
-                "model": model,
-            ],
-        ]
-        let tokenCount: [String: Any] = [
-            "type": "event_msg",
-            "timestamp": iso1,
-            "payload": [
-                "type": "token_count",
-                "info": [
-                    "total_token_usage": [
-                        "input_tokens": 100,
-                        "cached_input_tokens": 20,
-                        "output_tokens": 10,
-                    ],
-                    "model": model,
-                ],
-            ],
-        ]
-
-        let comps = Calendar.current.dateComponents([.year, .month, .day], from: day)
-        let dayKey = String(format: "%04d-%02d-%02d", comps.year ?? 1970, comps.month ?? 1, comps.day ?? 1)
-        let archivedName = "rollout-\(dayKey)T12-00-00-archived.jsonl"
-        let contents = try env.jsonl([sessionMeta, turnContext, tokenCount])
-        _ = try env.writeCodexArchivedSessionFile(filename: archivedName, contents: contents)
-
-        var options = CostUsageScanner.Options(
-            codexSessionsRoot: env.codexSessionsRoot,
-            claudeProjectsRoots: nil,
-            cacheRoot: env.cacheRoot)
-        options.refreshMinIntervalSeconds = 0
-
-        let first = CostUsageScanner.loadDailyReport(
-            provider: .codex,
-            since: day,
-            until: day,
-            now: day,
-            options: options)
-        #expect(first.data.count == 1)
-        #expect(first.data[0].totalTokens == 110)
-
-        _ = try env.writeCodexSessionFile(day: day, filename: "session.jsonl", contents: contents)
-        let second = CostUsageScanner.loadDailyReport(
-            provider: .codex,
-            since: day,
-            until: day,
-            now: day,
-            options: options)
-        #expect(second.data.count == 1)
-        #expect(second.data[0].totalTokens == 110)
-    }
-
-    @Test
-    func claudeDailyReportParsesUsageAndCaches() throws {
-        let env = try CostUsageTestEnvironment()
-        defer { env.cleanup() }
-
-        let day = try env.makeLocalNoon(year: 2025, month: 12, day: 20)
-        let iso0 = env.isoString(for: day)
-
-        let assistant: [String: Any] = [
-            "type": "assistant",
-            "timestamp": iso0,
-            "message": [
-                "model": "claude-sonnet-4-20250514",
-                "usage": [
-                    "input_tokens": 200,
-                    "cache_creation_input_tokens": 50,
-                    "cache_read_input_tokens": 25,
-                    "output_tokens": 80,
-                ],
-            ],
-        ]
-        _ = try env.writeClaudeProjectFile(
-            relativePath: "project-a/session-a.jsonl",
-            contents: env.jsonl([assistant]))
-
-        var options = CostUsageScanner.Options(
-            codexSessionsRoot: nil,
-            claudeProjectsRoots: [env.claudeProjectsRoot],
-            cacheRoot: env.cacheRoot)
-        options.refreshMinIntervalSeconds = 0
-
-        let report = CostUsageScanner.loadDailyReport(
-            provider: .claude,
-            since: day,
-            until: day,
-            now: day,
-            options: options)
-        #expect(report.data.count == 1)
-        #expect(report.data[0].modelsUsed == ["claude-sonnet-4-20250514"])
-        #expect(report.data[0].inputTokens == 200)
-        #expect(report.data[0].cacheCreationTokens == 50)
-        #expect(report.data[0].cacheReadTokens == 25)
-        #expect(report.data[0].outputTokens == 80)
-        #expect(report.data[0].totalTokens == 355)
-        #expect((report.data[0].costUSD ?? 0) > 0)
+    func `codex file metadata detects append truncation and replacement`() throws {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-codex-metadata-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+        let fileURL = root.appendingPathComponent("session.jsonl")
+        try Data("abc".utf8).write(to: fileURL)
+
+        let initial = CostUsageScanner.codexFileMetadata(fileURL: fileURL)
+        #expect(initial.size == 3)
+        #expect(initial.fileId != nil)
+        let linkURL = root.appendingPathComponent("linked-session.jsonl")
+        try FileManager.default.createSymbolicLink(at: linkURL, withDestinationURL: fileURL)
+        let linked = CostUsageScanner.codexFileMetadata(fileURL: linkURL)
+        #expect(linked.size == initial.size)
+        #expect(linked.fileId == initial.fileId)
+
+        let handle = try FileHandle(forWritingTo: fileURL)
+        try handle.seekToEnd()
+        try handle.write(contentsOf: Data("def".utf8))
+        try handle.close()
+        let appended = CostUsageScanner.codexFileMetadata(fileURL: fileURL)
+        #expect(appended.size == 6)
+        #expect(appended.fileId == initial.fileId)
+
+        let truncateHandle = try FileHandle(forWritingTo: fileURL)
+        try truncateHandle.truncate(atOffset: 2)
+        try truncateHandle.close()
+        let truncated = CostUsageScanner.codexFileMetadata(fileURL: fileURL)
+        #expect(truncated.size == 2)
+        #expect(truncated.fileId == initial.fileId)
+
+        try FileManager.default.removeItem(at: fileURL)
+        try Data("replacement".utf8).write(to: fileURL)
+        let replaced = CostUsageScanner.codexFileMetadata(fileURL: fileURL)
+        #expect(replaced.size == 11)
+        #expect(replaced.fileId != initial.fileId)
     }
 
     @Test
-    func vertexDailyReportFiltersClaudeLogs() throws {
+    func `vertex daily report filters claude logs`() throws {
         let env = try CostUsageTestEnvironment()
         defer { env.cleanup() }
 
@@ -274,7 +110,7 @@ struct CostUsageScannerTests {
     }
 
     @Test
-    func vertexDailyReportDetectsByVrtxIdPrefix() throws {
+    func `vertex daily report detects by vrtx id prefix`() throws {
         let env = try CostUsageTestEnvironment()
         defer { env.cleanup() }
 
@@ -355,7 +191,82 @@ struct CostUsageScannerTests {
     }
 
     @Test
-    func claudeParsesLargeLinesWithUsageAtTail() throws {
+    func `claude report preserves per-request threshold pricing`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 9)
+        let first = env.isoString(for: day)
+        let second = env.isoString(for: day.addingTimeInterval(1))
+        let model = "claude-sonnet-4-5"
+        let firstEntry: [String: Any] = [
+            "type": "assistant",
+            "timestamp": first,
+            "requestId": "req_one",
+            "message": [
+                "id": "msg_one",
+                "model": model,
+                "usage": [
+                    "input_tokens": 150_000,
+                    "output_tokens": 0,
+                ],
+            ],
+        ]
+        let secondEntry: [String: Any] = [
+            "type": "assistant",
+            "timestamp": second,
+            "requestId": "req_two",
+            "message": [
+                "id": "msg_two",
+                "model": model,
+                "usage": [
+                    "input_tokens": 150_000,
+                    "output_tokens": 0,
+                ],
+            ],
+        ]
+
+        _ = try env.writeClaudeProjectFile(
+            relativePath: "project-a/threshold.jsonl",
+            contents: env.jsonl([firstEntry, secondEntry]))
+
+        var options = CostUsageScanner.Options(
+            codexSessionsRoot: nil,
+            claudeProjectsRoots: [env.claudeProjectsRoot],
+            cacheRoot: env.cacheRoot)
+        options.refreshMinIntervalSeconds = 0
+
+        let report = CostUsageScanner.loadDailyReport(
+            provider: .claude,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+        let expectedRequestCost = CostUsagePricing.claudeCostUSD(
+            model: model,
+            inputTokens: 150_000,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+            outputTokens: 0,
+            modelsDevCacheRoot: env.cacheRoot) ?? 0
+        let aggregateCost = CostUsagePricing.claudeCostUSD(
+            model: model,
+            inputTokens: 300_000,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+            outputTokens: 0,
+            modelsDevCacheRoot: env.cacheRoot) ?? 0
+        let expectedCost = expectedRequestCost * 2
+
+        #expect(report.data.count == 1)
+        #expect(report.data.first?.inputTokens == 300_000)
+        #expect(abs((report.data.first?.costUSD ?? 0) - expectedCost) < 0.000001)
+        #expect(abs((report.data.first?.costUSD ?? 0) - aggregateCost) > 0.000001)
+        #expect(abs((report.data.first?.modelBreakdowns?.first?.costUSD ?? 0) - expectedCost) < 0.000001)
+    }
+
+    @Test
+    func `claude parses large lines with usage at tail`() throws {
         let env = try CostUsageTestEnvironment()
         defer { env.cleanup() }
 
@@ -400,7 +311,7 @@ struct CostUsageScannerTests {
     }
 
     @Test
-    func claudeDailyReportRefreshesWhenFileChanges() throws {
+    func `claude daily report refreshes when file changes`() throws {
         let env = try CostUsageTestEnvironment()
         defer { env.cleanup() }
 
@@ -465,7 +376,7 @@ struct CostUsageScannerTests {
     }
 
     @Test
-    func codexIncrementalParsingUsesPreviousTotals() throws {
+    func `codex incremental parsing uses previous totals`() throws {
         let env = try CostUsageTestEnvironment()
         defer { env.cleanup() }
 
@@ -476,6 +387,7 @@ struct CostUsageScannerTests {
 
         let model = "openai/gpt-5.2-codex"
         let normalized = CostUsagePricing.normalizeCodexModel(model)
+        #expect(normalized == "gpt-5.2-codex")
         let turnContext: [String: Any] = [
             "type": "turn_context",
             "timestamp": iso0,
@@ -544,7 +456,118 @@ struct CostUsageScannerTests {
     }
 
     @Test
-    func claudeIncrementalParsingReadsAppendedLinesOnly() throws {
+    func `codex incremental parsing keeps current turn id`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 10)
+        let iso0 = env.isoString(for: day)
+        let iso1 = env.isoString(for: day.addingTimeInterval(1))
+        let iso2 = env.isoString(for: day.addingTimeInterval(2))
+        let iso3 = env.isoString(for: day.addingTimeInterval(3))
+
+        let model = "openai/gpt-5.5"
+        let turnID = "22222222-2222-2222-2222-222222222222"
+        let turnContext: [String: Any] = [
+            "type": "turn_context",
+            "timestamp": iso0,
+            "payload": [
+                "model": model,
+            ],
+        ]
+        let taskStarted: [String: Any] = [
+            "type": "event_msg",
+            "timestamp": iso1,
+            "payload": [
+                "type": "task_started",
+                "id": turnID,
+            ],
+        ]
+        let firstTokenCount: [String: Any] = [
+            "type": "event_msg",
+            "timestamp": iso2,
+            "payload": [
+                "type": "token_count",
+                "info": [
+                    "total_token_usage": [
+                        "input_tokens": 100,
+                        "cached_input_tokens": 20,
+                        "output_tokens": 10,
+                    ],
+                ],
+            ],
+        ]
+
+        let fileURL = try env.writeCodexSessionFile(
+            day: day,
+            filename: "priority-session.jsonl",
+            contents: env.jsonl([turnContext, taskStarted, firstTokenCount]))
+        let range = CostUsageScanner.CostUsageDayRange(since: day, until: day)
+
+        let first = CostUsageScanner.parseCodexFile(fileURL: fileURL, range: range)
+        #expect(first.lastCodexTurnID == turnID)
+        #expect(first.rows.map(\.turnID) == [turnID])
+
+        let secondTokenCount: [String: Any] = [
+            "type": "event_msg",
+            "timestamp": iso3,
+            "payload": [
+                "type": "token_count",
+                "info": [
+                    "total_token_usage": [
+                        "input_tokens": 160,
+                        "cached_input_tokens": 40,
+                        "output_tokens": 16,
+                    ],
+                ],
+            ],
+        ]
+        try env.jsonl([turnContext, taskStarted, firstTokenCount, secondTokenCount])
+            .write(to: fileURL, atomically: true, encoding: .utf8)
+
+        let delta = CostUsageScanner.parseCodexFile(
+            fileURL: fileURL,
+            range: range,
+            startOffset: first.parsedBytes,
+            initialModel: first.lastModel,
+            initialTotals: first.lastTotals,
+            initialCodexTurnID: first.lastCodexTurnID)
+
+        #expect(delta.lastCodexTurnID == turnID)
+        #expect(delta.rows.map(\.turnID) == [turnID])
+        #expect(delta.rows.first?.input == 60)
+        #expect(delta.rows.first?.cached == 20)
+        #expect(delta.rows.first?.output == 6)
+    }
+
+    @Test
+    func `codex fast parser does not trap on overflowing token integers`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 10)
+        let iso = env.isoString(for: day)
+        let hugeInteger = String(repeating: "9", count: 100)
+        let line = """
+        {"type":"event_msg","timestamp":"\(
+            iso)","payload":{"type":"token_count","info":{"last_token_usage":{"input_tokens":\(
+            hugeInteger),"cached_input_tokens":0,"output_tokens":5},"model":"openai/gpt-5.5"}}}
+        """
+        let fileURL = try env.writeCodexSessionFile(day: day, filename: "overflow.jsonl", contents: line + "\n")
+        let range = CostUsageScanner.CostUsageDayRange(since: day, until: day)
+
+        let parsed = CostUsageScanner.parseCodexFile(fileURL: fileURL, range: range)
+        let dayKey = CostUsageScanner.CostUsageDayRange.dayKey(from: day)
+        let packed = parsed.days[dayKey]?["gpt-5.5"] ?? []
+
+        #expect(packed.count >= 3)
+        #expect(packed[0] == 0)
+        #expect(packed[1] == 0)
+        #expect(packed[2] == 5)
+    }
+
+    @Test
+    func `claude incremental parsing reads appended lines only`() throws {
         let env = try CostUsageTestEnvironment()
         defer { env.cleanup() }
 
@@ -608,7 +631,7 @@ struct CostUsageScannerTests {
     }
 
     @Test
-    func dayKeyFromTimestampMatchesISOParsing() {
+    func `day key from timestamp matches ISO parsing`() {
         let timestamps = [
             "2025-12-20T23:59:59Z",
             "2025-12-20T23:59:59+02:00",
@@ -622,7 +645,7 @@ struct CostUsageScannerTests {
     }
 
     @Test
-    func claudeDeduplicatesStreamingChunks() throws {
+    func `claude deduplicates streaming chunks`() throws {
         let env = try CostUsageTestEnvironment()
         defer { env.cleanup() }
 
@@ -710,7 +733,7 @@ struct CostUsageScannerTests {
     }
 
     @Test
-    func claudeCountsEntriesWithoutIdsAsSeparate() throws {
+    func `claude counts entries without ids as separate`() throws {
         let env = try CostUsageTestEnvironment()
         defer { env.cleanup() }
 
@@ -774,7 +797,7 @@ struct CostUsageScannerTests {
     }
 
     @Test
-    func claudeCountsDifferentRequestIdsSeparately() throws {
+    func `claude counts different request ids separately`() throws {
         let env = try CostUsageTestEnvironment()
         defer { env.cleanup() }
 
@@ -838,69 +861,16 @@ struct CostUsageScannerTests {
         #expect(report.data[0].outputTokens == 15)
         #expect(report.data[0].totalTokens == 45)
     }
-
-    @Test
-    func jsonlScannerHandlesLinesAcrossReadChunks() throws {
-        let env = try CostUsageTestEnvironment()
-        defer { env.cleanup() }
-
-        let fileURL = env.root.appendingPathComponent("large-lines.jsonl", isDirectory: false)
-        let largeLine = String(repeating: "x", count: 300_000)
-        let contents = "\(largeLine)\nsmall\n"
-        try contents.write(to: fileURL, atomically: true, encoding: .utf8)
-
-        var scanned: [(count: Int, truncated: Bool)] = []
-        let endOffset = try CostUsageJsonl.scan(
-            fileURL: fileURL,
-            maxLineBytes: 400_000,
-            prefixBytes: 400_000)
-        { line in
-            scanned.append((line.bytes.count, line.wasTruncated))
-        }
-
-        #expect(endOffset == Int64(Data(contents.utf8).count))
-        #expect(scanned.count == 2)
-        #expect(scanned[0].count == 300_000)
-        #expect(scanned[0].truncated == false)
-        #expect(scanned[1].count == 5)
-        #expect(scanned[1].truncated == false)
-    }
-
-    @Test
-    func jsonlScannerMarksPrefixLimitedLinesAsTruncated() throws {
-        let env = try CostUsageTestEnvironment()
-        defer { env.cleanup() }
-
-        let fileURL = env.root.appendingPathComponent("truncated-lines.jsonl", isDirectory: false)
-        let shortLine = "ok"
-        let longLine = String(repeating: "a", count: 2000)
-        let contents = "\(shortLine)\n\(longLine)\n"
-        try contents.write(to: fileURL, atomically: true, encoding: .utf8)
-
-        var scanned: [CostUsageJsonl.Line] = []
-        _ = try CostUsageJsonl.scan(
-            fileURL: fileURL,
-            maxLineBytes: 10000,
-            prefixBytes: 64)
-        { line in
-            scanned.append(line)
-        }
-
-        #expect(scanned.count == 2)
-        #expect(String(data: scanned[0].bytes, encoding: .utf8) == "ok")
-        #expect(scanned[0].wasTruncated == false)
-        #expect(scanned[1].bytes.isEmpty)
-        #expect(scanned[1].wasTruncated == true)
-    }
 }
 
-private struct CostUsageTestEnvironment {
+struct CostUsageTestEnvironment {
     let root: URL
     let cacheRoot: URL
     let codexHomeRoot: URL
     let codexSessionsRoot: URL
     let codexArchivedSessionsRoot: URL
     let claudeProjectsRoot: URL
+    let piSessionsRoot: URL
 
     init() throws {
         let root = FileManager.default.temporaryDirectory.appendingPathComponent(
@@ -914,10 +884,12 @@ private struct CostUsageTestEnvironment {
         self.codexArchivedSessionsRoot = self.codexHomeRoot
             .appendingPathComponent("archived_sessions", isDirectory: true)
         self.claudeProjectsRoot = root.appendingPathComponent("claude-projects", isDirectory: true)
+        self.piSessionsRoot = root.appendingPathComponent("pi-sessions", isDirectory: true)
         try FileManager.default.createDirectory(at: self.cacheRoot, withIntermediateDirectories: true)
         try FileManager.default.createDirectory(at: self.codexSessionsRoot, withIntermediateDirectories: true)
         try FileManager.default.createDirectory(at: self.codexArchivedSessionsRoot, withIntermediateDirectories: true)
         try FileManager.default.createDirectory(at: self.claudeProjectsRoot, withIntermediateDirectories: true)
+        try FileManager.default.createDirectory(at: self.piSessionsRoot, withIntermediateDirectories: true)
     }
 
     func cleanup() {
@@ -974,6 +946,13 @@ private struct CostUsageTestEnvironment {
         return url
     }
 
+    func writePiSessionFile(relativePath: String, contents: String) throws -> URL {
+        let url = self.piSessionsRoot.appendingPathComponent(relativePath, isDirectory: false)
+        try FileManager.default.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true)
+        try contents.write(to: url, atomically: true, encoding: .utf8)
+        return url
+    }
+
     func jsonl(_ objects: [Any]) throws -> String {
         let lines = try objects.map { obj in
             let data = try JSONSerialization.data(withJSONObject: obj)
diff --git a/Tests/CodexBarTests/CrofMenuCardTests.swift b/Tests/CodexBarTests/CrofMenuCardTests.swift
new file mode 100644
index 0000000000..ade932a3a2
--- /dev/null
+++ b/Tests/CodexBarTests/CrofMenuCardTests.swift
@@ -0,0 +1,44 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct CrofMenuCardTests {
+    @Test
+    func `model shows request count and avoids duplicate credits section`() throws {
+        let now = Date()
+        let metadata = try #require(ProviderDefaults.metadata[.crof])
+        let snapshot = CrofUsageSnapshot(
+            credits: 10,
+            requestsPlan: 1000,
+            usableRequests: 998,
+            updatedAt: now).toUsageSnapshot()
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .crof,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.creditsText == nil)
+        #expect(model.metrics.map(\.title) == ["Requests", "Credits"])
+        #expect(model.metrics.first?.percent == 99)
+        #expect(model.metrics.first?.resetText?.hasPrefix("Resets") == true)
+        #expect(model.metrics.first?.detailRightText == "998 requests left")
+        #expect(model.metrics.last?.resetText == "$10.00")
+    }
+}
diff --git a/Tests/CodexBarTests/CrofProviderImplementationTests.swift b/Tests/CodexBarTests/CrofProviderImplementationTests.swift
new file mode 100644
index 0000000000..ed30b52002
--- /dev/null
+++ b/Tests/CodexBarTests/CrofProviderImplementationTests.swift
@@ -0,0 +1,52 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@MainActor
+struct CrofProviderImplementationTests {
+    @Test
+    func `availability uses crof environment token`() throws {
+        let settings = try Self.makeSettings(suite: "CrofProviderImplementationTests-env")
+        let implementation = CrofProviderImplementation()
+
+        let context = ProviderAvailabilityContext(
+            provider: .crof,
+            settings: settings,
+            environment: [CrofSettingsReader.apiKeyEnvironmentKeys[0]: "env-token"])
+
+        #expect(implementation.isAvailable(context: context))
+    }
+
+    @Test
+    func `availability uses stored crof API token`() throws {
+        let settings = try Self.makeSettings(suite: "CrofProviderImplementationTests-settings")
+        settings.crofAPIToken = "stored-token"
+        let implementation = CrofProviderImplementation()
+
+        let context = ProviderAvailabilityContext(provider: .crof, settings: settings, environment: [:])
+
+        #expect(implementation.isAvailable(context: context))
+    }
+
+    @Test
+    func `availability rejects missing crof API token`() throws {
+        let settings = try Self.makeSettings(suite: "CrofProviderImplementationTests-missing")
+        settings.crofAPIToken = "   "
+        let implementation = CrofProviderImplementation()
+
+        let context = ProviderAvailabilityContext(provider: .crof, settings: settings, environment: [:])
+
+        #expect(!implementation.isAvailable(context: context))
+    }
+
+    private static func makeSettings(suite: String) throws -> SettingsStore {
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        return SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+    }
+}
diff --git a/Tests/CodexBarTests/CrofUsageFetcherTests.swift b/Tests/CodexBarTests/CrofUsageFetcherTests.swift
new file mode 100644
index 0000000000..43ae3d99d9
--- /dev/null
+++ b/Tests/CodexBarTests/CrofUsageFetcherTests.swift
@@ -0,0 +1,236 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct CrofUsageFetcherTests {
+    @Test
+    func `usage URL points at public usage API`() {
+        #expect(CrofUsageFetcher.usageURL.absoluteString == "https://crof.ai/usage_api/")
+    }
+
+    @Test
+    func `usage response parses credits and request quota`() throws {
+        let json = """
+        {"credits":10.0,"requests_plan":1000,"usable_requests":998}
+        """
+
+        let snapshot = try CrofUsageFetcher._parseSnapshotForTesting(Data(json.utf8))
+
+        #expect(snapshot.credits == 10)
+        #expect(snapshot.requestsPlan == 1000)
+        #expect(snapshot.usableRequests == 998)
+    }
+
+    @Test
+    func `usage snapshot maps usable requests to remaining quota`() {
+        let snapshot = CrofUsageSnapshot(
+            credits: 10,
+            requestsPlan: 1000,
+            usableRequests: 998,
+            updatedAt: Date(timeIntervalSince1970: 1_777_800_000))
+
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.primary?.usedPercent == 1)
+        #expect(usage.primary?.windowMinutes == 1440)
+        #expect(usage.primary?.resetDescription == "998 requests left")
+        #expect(usage.secondary?.usedPercent == 0)
+        #expect(usage.secondary?.resetDescription == "$10.00")
+        #expect(usage.identity?.providerID == .crof)
+        #expect(usage.identity?.loginMethod == "API key")
+    }
+
+    @Test
+    func `usage snapshot floors credit balance to cents`() {
+        let snapshot = CrofUsageSnapshot(
+            credits: 9.9999,
+            requestsPlan: 1000,
+            usableRequests: 998)
+
+        #expect(snapshot.toUsageSnapshot().secondary?.resetDescription == "$9.99")
+    }
+
+    @Test
+    func `usage snapshot resets requests at next America Chicago midnight`() throws {
+        var utc = Calendar(identifier: .gregorian)
+        utc.timeZone = try #require(TimeZone(secondsFromGMT: 0))
+        let updatedAt = try #require(utc.date(from: DateComponents(
+            year: 2026,
+            month: 5,
+            day: 8,
+            hour: 18,
+            minute: 30)))
+        let expectedReset = try #require(utc.date(from: DateComponents(
+            year: 2026,
+            month: 5,
+            day: 9,
+            hour: 5)))
+        let snapshot = CrofUsageSnapshot(
+            credits: 10,
+            requestsPlan: 1000,
+            usableRequests: 998,
+            updatedAt: updatedAt)
+
+        #expect(snapshot.toUsageSnapshot().primary?.resetsAt == expectedReset)
+    }
+
+    @Test
+    func `usage snapshot clamps overreported usable requests`() {
+        let snapshot = CrofUsageSnapshot(
+            credits: 0,
+            requestsPlan: 1000,
+            usableRequests: 1200)
+
+        #expect(snapshot.toUsageSnapshot().primary?.usedPercent == 0)
+    }
+
+    @Test
+    func `usage snapshot treats zero plan as exhausted`() {
+        let snapshot = CrofUsageSnapshot(
+            credits: 0,
+            requestsPlan: 0,
+            usableRequests: 0)
+
+        #expect(snapshot.toUsageSnapshot().primary?.usedPercent == 100)
+    }
+
+    @Test
+    func `fetch sends bearer token`() async throws {
+        defer {
+            CrofStubURLProtocol.handler = nil
+            CrofStubURLProtocol.requests = []
+        }
+        CrofStubURLProtocol.requests = []
+        CrofStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            #expect(request.value(forHTTPHeaderField: "Authorization") == "Bearer crof-test")
+            #expect(request.value(forHTTPHeaderField: "Accept") == "application/json")
+            return try Self.makeResponse(
+                url: url,
+                body: #"{"credits":10.0,"requests_plan":1000,"usable_requests":998}"#)
+        }
+
+        let snapshot = try await CrofUsageFetcher.fetchUsage(apiKey: "crof-test", session: Self.makeSession())
+
+        #expect(snapshot.usableRequests == 998)
+        #expect(CrofStubURLProtocol.requests.map(\.url?.absoluteString) == ["https://crof.ai/usage_api/"])
+    }
+
+    @Test
+    func `descriptor supports auto and API source modes`() {
+        let descriptor = ProviderDescriptorRegistry.descriptor(for: .crof)
+        #expect(descriptor.metadata.displayName == "Crof")
+        #expect(descriptor.metadata.dashboardURL == "https://crof.ai/dashboard")
+        #expect(descriptor.fetchPlan.sourceModes == [.auto, .api])
+        #expect(descriptor.branding.iconResourceName == "ProviderIcon-crof")
+    }
+
+    @Test
+    func `settings reader uses CROF_API_KEY`() {
+        let token = CrofSettingsReader.apiKey(environment: [
+            CrofSettingsReader.apiKeyEnvironmentKeys[0]: "  crof-token  ",
+        ])
+
+        #expect(token == "crof-token")
+    }
+
+    @Test
+    func `token resolver uses crof environment token`() {
+        let env = [CrofSettingsReader.apiKeyEnvironmentKeys[0]: "crof-token"]
+        let resolution = ProviderTokenResolver.crofResolution(environment: env)
+
+        #expect(resolution?.token == "crof-token")
+        #expect(resolution?.source == .environment)
+    }
+
+    @Test
+    func `config API key override feeds crof environment`() {
+        let config = ProviderConfig(id: .crof, apiKey: "config-token")
+        let env = ProviderConfigEnvironment.applyAPIKeyOverride(
+            base: [:],
+            provider: .crof,
+            config: config)
+
+        #expect(env[CrofSettingsReader.apiKeyEnvironmentKeys[0]] == "config-token")
+        #expect(ProviderTokenResolver.crofToken(environment: env) == "config-token")
+    }
+
+    @Test
+    func `config API key leaves existing crof environment token alone`() {
+        let key = CrofSettingsReader.apiKeyEnvironmentKeys[0]
+        let config = ProviderConfig(id: .crof, apiKey: "config-token")
+        let env = ProviderConfigEnvironment.applyAPIKeyOverride(
+            base: [key: "env-token"],
+            provider: .crof,
+            config: config)
+
+        #expect(env[key] == "env-token")
+        #expect(ProviderTokenResolver.crofToken(environment: env) == "env-token")
+    }
+
+    @Test
+    func `missing credentials fetch call throws missing credentials`() async {
+        do {
+            _ = try await CrofUsageFetcher.fetchUsage(apiKey: "   ")
+            Issue.record("Expected missingCredentials error")
+        } catch let error as CrofUsageError {
+            #expect(error == .missingCredentials)
+        } catch {
+            Issue.record("Unexpected error: \(error)")
+        }
+    }
+
+    private static func makeSession() -> URLSession {
+        let config = URLSessionConfiguration.ephemeral
+        config.protocolClasses = [CrofStubURLProtocol.self]
+        return URLSession(configuration: config)
+    }
+
+    private static func makeResponse(
+        url: URL,
+        body: String,
+        statusCode: Int = 200) throws -> (HTTPURLResponse, Data)
+    {
+        guard let response = HTTPURLResponse(
+            url: url,
+            statusCode: statusCode,
+            httpVersion: nil,
+            headerFields: ["Content-Type": "application/json"])
+        else {
+            throw URLError(.badServerResponse)
+        }
+        return (response, Data(body.utf8))
+    }
+}
+
+final class CrofStubURLProtocol: URLProtocol {
+    nonisolated(unsafe) static var handler: ((URLRequest) throws -> (HTTPURLResponse, Data))?
+    nonisolated(unsafe) static var requests: [URLRequest] = []
+
+    override static func canInit(with request: URLRequest) -> Bool {
+        request.url?.host == "crof.ai"
+    }
+
+    override static func canonicalRequest(for request: URLRequest) -> URLRequest {
+        request
+    }
+
+    override func startLoading() {
+        Self.requests.append(self.request)
+        guard let handler = Self.handler else {
+            self.client?.urlProtocol(self, didFailWithError: URLError(.badServerResponse))
+            return
+        }
+        do {
+            let (response, data) = try handler(self.request)
+            self.client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
+            self.client?.urlProtocol(self, didLoad: data)
+            self.client?.urlProtocolDidFinishLoading(self)
+        } catch {
+            self.client?.urlProtocol(self, didFailWithError: error)
+        }
+    }
+
+    override func stopLoading() {}
+}
diff --git a/Tests/CodexBarTests/CursorEnterpriseUsageTests.swift b/Tests/CodexBarTests/CursorEnterpriseUsageTests.swift
new file mode 100644
index 0000000000..8e55b9f6aa
--- /dev/null
+++ b/Tests/CodexBarTests/CursorEnterpriseUsageTests.swift
@@ -0,0 +1,258 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct CursorEnterpriseUsageTests {
+    @Test
+    func `legacy provider cost snapshot decodes without personal spend`() throws {
+        let json = """
+        {
+            "used": 12.5,
+            "limit": 100,
+            "currencyCode": "USD",
+            "period": "Monthly",
+            "resetsAt": null,
+            "nextRegenAmount": null,
+            "updatedAt": 0
+        }
+        """
+
+        let snapshot = try JSONDecoder().decode(ProviderCostSnapshot.self, from: Data(json.utf8))
+
+        #expect(snapshot.used == 12.5)
+        #expect(snapshot.personalUsed == nil)
+    }
+
+    @Test
+    func `parses enterprise overall and pooled usage summary`() throws {
+        // Live Cursor Enterprise payload (sanitized). The Pro/Hobby `plan` block is absent;
+        // instead Cursor reports `individualUsage.overall` (personal cap) and `teamUsage.pooled`
+        // (shared team pool). Both blocks use cents like the existing `plan` block.
+        let json = """
+        {
+            "billingCycleStart": "2026-04-01T00:00:00.000Z",
+            "billingCycleEnd": "2026-05-01T00:00:00.000Z",
+            "membershipType": "enterprise",
+            "limitType": "team",
+            "isUnlimited": false,
+            "individualUsage": {
+                "overall": {
+                    "enabled": true,
+                    "used": 7384,
+                    "limit": 10000,
+                    "remaining": 2616
+                }
+            },
+            "teamUsage": {
+                "onDemand": {
+                    "enabled": true,
+                    "used": 0,
+                    "limit": null,
+                    "remaining": null
+                },
+                "pooled": {
+                    "enabled": true,
+                    "used": 12725135,
+                    "limit": 28122000,
+                    "remaining": 15396865
+                }
+            }
+        }
+        """
+        let data = try #require(json.data(using: .utf8))
+        let summary = try JSONDecoder().decode(CursorUsageSummary.self, from: data)
+
+        #expect(summary.membershipType == "enterprise")
+        #expect(summary.limitType == "team")
+        #expect(summary.individualUsage?.plan == nil)
+        #expect(summary.individualUsage?.overall?.used == 7384)
+        #expect(summary.individualUsage?.overall?.limit == 10000)
+        #expect(summary.individualUsage?.overall?.remaining == 2616)
+        #expect(summary.teamUsage?.pooled?.used == 12_725_135)
+        #expect(summary.teamUsage?.pooled?.limit == 28_122_000)
+    }
+
+    @Test
+    func `enterprise overall drives headline percent and dollars`() throws {
+        // Regression: Cursor Enterprise/Team accounts ship `individualUsage.overall` instead of
+        // `individualUsage.plan`. Without a model for `overall`, the parser used to report 0%
+        // (i.e. the menu showed "100% remaining"). The personal cap must take precedence over
+        // any team pool, and USD figures must reflect the same source.
+        let snapshot = CursorStatusProbe(browserDetection: BrowserDetection(cacheTTL: 0))
+            .parseUsageSummary(
+                CursorUsageSummary(
+                    billingCycleStart: "2026-04-01T00:00:00.000Z",
+                    billingCycleEnd: "2026-05-01T00:00:00.000Z",
+                    membershipType: "enterprise",
+                    limitType: "team",
+                    isUnlimited: false,
+                    autoModelSelectedDisplayMessage: nil,
+                    namedModelSelectedDisplayMessage: nil,
+                    individualUsage: CursorIndividualUsage(
+                        plan: nil,
+                        onDemand: nil,
+                        overall: CursorOverallUsage(enabled: true, used: 7384, limit: 10000, remaining: 2616)),
+                    teamUsage: CursorTeamUsage(
+                        onDemand: CursorOnDemandUsage(enabled: true, used: 0, limit: nil, remaining: nil),
+                        pooled: CursorPooledUsage(
+                            enabled: true,
+                            used: 12_725_135,
+                            limit: 28_122_000,
+                            remaining: 15_396_865))),
+                userInfo: nil,
+                rawJSON: nil)
+
+        // Headline: $73.84 / $100 -> 73.84% (matches Cursor's own dashboard).
+        // Allow a tiny tolerance for floating-point division (7384/10000 * 100).
+        #expect(abs(snapshot.planPercentUsed - 73.84) < 0.0001)
+        #expect(snapshot.planUsedUSD == 73.84)
+        #expect(snapshot.planLimitUSD == 100.0)
+        #expect(snapshot.autoPercentUsed == nil)
+        #expect(snapshot.apiPercentUsed == nil)
+
+        let primaryPercent = try #require(snapshot.toUsageSnapshot().primary?.usedPercent)
+        #expect(abs(primaryPercent - 73.84) < 0.0001)
+    }
+
+    @Test
+    func `enterprise pooled fallback used when no individual data`() {
+        // When Cursor only reports a shared team pool (no `plan`, no `overall`) we should still surface
+        // a non-zero headline so the menu reflects pool consumption rather than appearing "all clear".
+        let snapshot = CursorStatusProbe(browserDetection: BrowserDetection(cacheTTL: 0))
+            .parseUsageSummary(
+                CursorUsageSummary(
+                    billingCycleStart: nil,
+                    billingCycleEnd: nil,
+                    membershipType: "enterprise",
+                    limitType: "team",
+                    isUnlimited: false,
+                    autoModelSelectedDisplayMessage: nil,
+                    namedModelSelectedDisplayMessage: nil,
+                    individualUsage: nil,
+                    teamUsage: CursorTeamUsage(
+                        onDemand: nil,
+                        pooled: CursorPooledUsage(
+                            enabled: true,
+                            used: 12_725_135,
+                            limit: 28_122_000,
+                            remaining: 15_396_865))),
+                userInfo: nil,
+                rawJSON: nil)
+
+        #expect(snapshot.planPercentUsed > 45.0)
+        #expect(snapshot.planPercentUsed < 45.5)
+        #expect(snapshot.planUsedUSD == 127_251.35)
+        #expect(snapshot.planLimitUSD == 281_220.0)
+    }
+
+    @Test
+    func `team on-demand pool is the budget and personal spend rides along`() {
+        // Live team-plan payload (sanitized): the user's own on-demand spend has no personal limit,
+        // so the team pool is the headline budget. The personal spend must still be surfaced.
+        let snapshot = CursorStatusProbe(browserDetection: BrowserDetection(cacheTTL: 0))
+            .parseUsageSummary(
+                CursorUsageSummary(
+                    billingCycleStart: "2026-06-01T00:00:00.000Z",
+                    billingCycleEnd: "2026-07-01T00:00:00.000Z",
+                    membershipType: "enterprise",
+                    limitType: "team",
+                    isUnlimited: false,
+                    autoModelSelectedDisplayMessage: nil,
+                    namedModelSelectedDisplayMessage: nil,
+                    individualUsage: CursorIndividualUsage(
+                        plan: CursorPlanUsage(
+                            enabled: true,
+                            used: 2000,
+                            limit: 2000,
+                            remaining: 0,
+                            breakdown: nil,
+                            autoPercentUsed: 0,
+                            apiPercentUsed: 100,
+                            totalPercentUsed: 100),
+                        onDemand: CursorOnDemandUsage(enabled: true, used: 4471, limit: nil, remaining: nil),
+                        overall: nil),
+                    teamUsage: CursorTeamUsage(
+                        onDemand: CursorOnDemandUsage(
+                            enabled: true,
+                            used: 1_311_125,
+                            limit: 2_000_000,
+                            remaining: 688_875),
+                        pooled: nil)),
+                userInfo: nil,
+                rawJSON: nil)
+
+        let cost = snapshot.toUsageSnapshot().providerCost
+        #expect(cost?.used == 13111.25) // team pool used
+        #expect(cost?.limit == 20000.0) // team pool limit
+        #expect(cost?.personalUsed == 44.71) // this account's own on-demand spend
+    }
+
+    @Test
+    func `personal on-demand limit keeps personal budget with no rider`() {
+        // When the user has their own on-demand limit, that is the budget and there is no separate rider.
+        let snapshot = CursorStatusProbe(browserDetection: BrowserDetection(cacheTTL: 0))
+            .parseUsageSummary(
+                CursorUsageSummary(
+                    billingCycleStart: nil,
+                    billingCycleEnd: nil,
+                    membershipType: "pro",
+                    limitType: "user",
+                    isUnlimited: false,
+                    autoModelSelectedDisplayMessage: nil,
+                    namedModelSelectedDisplayMessage: nil,
+                    individualUsage: CursorIndividualUsage(
+                        plan: nil,
+                        onDemand: CursorOnDemandUsage(enabled: true, used: 4471, limit: 10000, remaining: 5529),
+                        overall: nil),
+                    teamUsage: nil),
+                userInfo: nil,
+                rawJSON: nil)
+
+        let cost = snapshot.toUsageSnapshot().providerCost
+        #expect(cost?.used == 44.71)
+        #expect(cost?.limit == 100.0)
+        #expect(cost?.personalUsed == nil)
+    }
+
+    @Test
+    func `existing plan block still wins over overall and pooled`() {
+        // Guard against future drift: when Cursor sends both legacy `plan` and the newer `overall`
+        // blocks, the existing percent precedence must remain intact.
+        let snapshot = CursorStatusProbe(browserDetection: BrowserDetection(cacheTTL: 0))
+            .parseUsageSummary(
+                CursorUsageSummary(
+                    billingCycleStart: nil,
+                    billingCycleEnd: nil,
+                    membershipType: "pro",
+                    limitType: "user",
+                    isUnlimited: false,
+                    autoModelSelectedDisplayMessage: nil,
+                    namedModelSelectedDisplayMessage: nil,
+                    individualUsage: CursorIndividualUsage(
+                        plan: CursorPlanUsage(
+                            enabled: true,
+                            used: 1500,
+                            limit: 5000,
+                            remaining: 3500,
+                            breakdown: nil,
+                            autoPercentUsed: nil,
+                            apiPercentUsed: nil,
+                            totalPercentUsed: 30.0),
+                        onDemand: nil,
+                        overall: CursorOverallUsage(enabled: true, used: 7384, limit: 10000, remaining: 2616)),
+                    teamUsage: CursorTeamUsage(
+                        onDemand: nil,
+                        pooled: CursorPooledUsage(
+                            enabled: true,
+                            used: 12_725_135,
+                            limit: 28_122_000,
+                            remaining: 15_396_865))),
+                userInfo: nil,
+                rawJSON: nil)
+
+        #expect(snapshot.planPercentUsed == 30.0)
+        #expect(snapshot.planUsedUSD == 15.0)
+        #expect(snapshot.planLimitUSD == 50.0)
+    }
+}
diff --git a/Tests/CodexBarTests/CursorLegacyRequestProjectionTests.swift b/Tests/CodexBarTests/CursorLegacyRequestProjectionTests.swift
new file mode 100644
index 0000000000..3ee0cf47ed
--- /dev/null
+++ b/Tests/CodexBarTests/CursorLegacyRequestProjectionTests.swift
@@ -0,0 +1,59 @@
+import Testing
+@testable import CodexBarCore
+
+struct CursorLegacyRequestProjectionTests {
+    @Test
+    func `legacy plan hides token-based auto and api bars`() {
+        let snapshot = Self.snapshot(requestsUsed: 347, requestsLimit: 500)
+
+        let usageSnapshot = snapshot.toUsageSnapshot()
+
+        #expect(abs((usageSnapshot.primary?.usedPercent ?? 0) - 69.4) < 0.01)
+        #expect(usageSnapshot.cursorRequests?.used == 347)
+        #expect(usageSnapshot.cursorRequests?.limit == 500)
+        #expect(usageSnapshot.secondary == nil)
+        #expect(usageSnapshot.tertiary == nil)
+    }
+
+    @Test
+    func `unusable legacy request quota preserves token bars`() {
+        let requestCases: [(used: Int?, limit: Int?)] = [
+            (nil, 500),
+            (12, 0),
+        ]
+
+        for requestCase in requestCases {
+            let usageSnapshot = Self.snapshot(
+                requestsUsed: requestCase.used,
+                requestsLimit: requestCase.limit).toUsageSnapshot()
+
+            #expect(usageSnapshot.primary?.usedPercent == 7.0)
+            #expect(usageSnapshot.cursorRequests == nil)
+            #expect(usageSnapshot.secondary?.usedPercent == 11.0)
+            #expect(usageSnapshot.tertiary?.usedPercent == 22.0)
+        }
+    }
+
+    private static func snapshot(
+        requestsUsed: Int?,
+        requestsLimit: Int?) -> CursorStatusSnapshot
+    {
+        CursorStatusSnapshot(
+            planPercentUsed: 7.0,
+            autoPercentUsed: 11.0,
+            apiPercentUsed: 22.0,
+            planUsedUSD: 1.4,
+            planLimitUSD: 20.0,
+            onDemandUsedUSD: 0,
+            onDemandLimitUSD: nil,
+            teamOnDemandUsedUSD: nil,
+            teamOnDemandLimitUSD: nil,
+            billingCycleEnd: nil,
+            membershipType: "pro",
+            accountEmail: "user@example.com",
+            accountName: nil,
+            rawJSON: nil,
+            requestsUsed: requestsUsed,
+            requestsLimit: requestsLimit)
+    }
+}
diff --git a/Tests/CodexBarTests/CursorLoginRunnerTests.swift b/Tests/CodexBarTests/CursorLoginRunnerTests.swift
new file mode 100644
index 0000000000..16632ebe0b
--- /dev/null
+++ b/Tests/CodexBarTests/CursorLoginRunnerTests.swift
@@ -0,0 +1,115 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@MainActor
+struct CursorLoginRunnerTests {
+    private final class LockedArray<Element>: @unchecked Sendable {
+        private let lock = NSLock()
+        private var values: [Element] = []
+
+        func append(_ value: Element) {
+            self.lock.lock()
+            defer { self.lock.unlock() }
+            self.values.append(value)
+        }
+
+        func snapshot() -> [Element] {
+            self.lock.lock()
+            defer { self.lock.unlock() }
+            return self.values
+        }
+    }
+
+    @Test
+    func `login opens Cursor auth URL in browser before polling cookies`() async {
+        var openedURLs: [URL] = []
+        var phases: [String] = []
+
+        let runner = CursorLoginRunner(
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            timeout: 1,
+            pollInterval: 0.01,
+            openURL: { url in
+                openedURLs.append(url)
+                return true
+            },
+            loadSnapshot: {
+                CursorStatusSnapshot(
+                    planPercentUsed: 12,
+                    planUsedUSD: 1,
+                    planLimitUSD: 20,
+                    onDemandUsedUSD: 0,
+                    onDemandLimitUSD: nil,
+                    teamOnDemandUsedUSD: nil,
+                    teamOnDemandLimitUSD: nil,
+                    billingCycleEnd: nil,
+                    membershipType: "pro",
+                    accountEmail: "cursor@example.com",
+                    accountName: nil,
+                    rawJSON: nil)
+            },
+            sleeper: { _ in },
+            resetSessionCache: {})
+
+        let result = await runner.run { phase in
+            switch phase {
+            case .loading: phases.append("loading")
+            case .waitingLogin: phases.append("waitingLogin")
+            case .success: phases.append("success")
+            case let .failed(message): phases.append("failed:\(message)")
+            }
+        }
+
+        #expect(openedURLs == [CursorLoginRunner.authURL])
+        #expect(phases == ["loading", "waitingLogin", "success"])
+        #expect(result.email == "cursor@example.com")
+    }
+
+    @Test
+    func `login clears stale session state before opening auth URL`() async {
+        let events = LockedArray<String>()
+        let runner = CursorLoginRunner(
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            timeout: 1,
+            pollInterval: 0.01,
+            openURL: { _ in
+                events.append("open")
+                return true
+            },
+            loadSnapshot: {
+                events.append("poll")
+                throw CursorStatusProbeError.noSessionCookie
+            },
+            sleeper: { _ in },
+            resetSessionCache: {
+                events.append("reset")
+            })
+
+        _ = await runner.run { _ in }
+
+        #expect(Array(events.snapshot().prefix(2)) == ["reset", "open"])
+    }
+
+    @Test
+    func `login reports launch failure when browser cannot open`() async {
+        let runner = CursorLoginRunner(
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            openURL: { _ in false },
+            loadSnapshot: {
+                Issue.record("Should not poll cookies when browser launch fails")
+                throw CursorStatusProbeError.noSessionCookie
+            },
+            sleeper: { _ in },
+            resetSessionCache: {})
+
+        let result = await runner.run { _ in }
+
+        guard case let .failed(message) = result.outcome else {
+            Issue.record("Expected failed outcome")
+            return
+        }
+        #expect(message.contains("Could not open Cursor login"))
+    }
+}
diff --git a/Tests/CodexBarTests/CursorMenuCardModelTests.swift b/Tests/CodexBarTests/CursorMenuCardModelTests.swift
new file mode 100644
index 0000000000..0ecb5c9ea9
--- /dev/null
+++ b/Tests/CodexBarTests/CursorMenuCardModelTests.swift
@@ -0,0 +1,145 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct CursorMenuCardModelTests {
+    @Test
+    func `team pool shows personal spend and changes height fingerprint`() throws {
+        let now = Date(timeIntervalSince1970: 0)
+        let metadata = try #require(ProviderDefaults.metadata[.cursor])
+
+        func makeModel(personalUsed: Double?) -> UsageMenuCardView.Model {
+            let snapshot = UsageSnapshot(
+                primary: nil,
+                secondary: nil,
+                tertiary: nil,
+                providerCost: ProviderCostSnapshot(
+                    used: 13111.25,
+                    limit: 20000,
+                    currencyCode: "USD",
+                    period: "Monthly",
+                    personalUsed: personalUsed,
+                    updatedAt: now),
+                updatedAt: now,
+                identity: nil)
+            return UsageMenuCardView.Model.make(.init(
+                provider: .cursor,
+                metadata: metadata,
+                snapshot: snapshot,
+                credits: nil,
+                creditsError: nil,
+                dashboard: nil,
+                dashboardError: nil,
+                tokenSnapshot: nil,
+                tokenError: nil,
+                account: AccountInfo(email: nil, plan: nil),
+                isRefreshing: false,
+                lastError: nil,
+                usageBarsShowUsed: false,
+                resetTimeDisplayStyle: .countdown,
+                tokenCostUsageEnabled: false,
+                showOptionalCreditsAndExtraUsage: true,
+                hidePersonalInfo: false,
+                now: now))
+        }
+
+        let personal = makeModel(personalUsed: 44.71)
+        let absent = makeModel(personalUsed: nil)
+        let zero = makeModel(personalUsed: 0)
+
+        #expect(personal.providerCost?.personalSpendLine == "Your spend: $44.71")
+        #expect(absent.providerCost?.personalSpendLine == nil)
+        #expect(zero.providerCost?.personalSpendLine == nil)
+        #expect(personal.heightFingerprint(section: "card") != absent.heightFingerprint(section: "card"))
+        #expect(!personal.hasCompatibleTrackedLayout(with: absent))
+        #expect(!absent.hasCompatibleTrackedLayout(with: personal))
+    }
+
+    @Test
+    func `cursor billing cycle metrics show deficit and run out details`() throws {
+        let now = Date(timeIntervalSince1970: 0)
+        let reset = now.addingTimeInterval(6 * 24 * 3600)
+        let cycleMinutes = 30 * 24 * 60
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 90, windowMinutes: cycleMinutes, resetsAt: reset, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 90, windowMinutes: cycleMinutes, resetsAt: reset, resetDescription: nil),
+            tertiary: RateWindow(usedPercent: 90, windowMinutes: cycleMinutes, resetsAt: reset, resetDescription: nil),
+            updatedAt: now,
+            identity: nil)
+        let metadata = try #require(ProviderDefaults.metadata[.cursor])
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .cursor,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.metrics.map(\.title) == ["Total", "Auto", "API"])
+        for metric in model.metrics {
+            #expect(metric.percentLabel == "10% left")
+            #expect(metric.detailLeftText == "10% in deficit")
+            #expect(metric.detailRightText == "Runs out in 2d 16h")
+            #expect(metric.pacePercent == 20)
+            #expect(metric.paceOnTop == false)
+        }
+    }
+
+    @Test
+    func `legacy request plan shows single requests bar with count`() throws {
+        let now = Date(timeIntervalSince1970: 0)
+        let reset = now.addingTimeInterval(6 * 24 * 3600)
+        let cycleMinutes = 30 * 24 * 60
+        // A legacy snapshot, as produced by CursorStatusSnapshot.toUsageSnapshot(): only the request
+        // window survives, Auto/API are dropped, and the request count rides along.
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 69.4,
+                windowMinutes: cycleMinutes,
+                resetsAt: reset,
+                resetDescription: nil),
+            secondary: nil,
+            tertiary: nil,
+            cursorRequests: CursorRequestUsage(used: 347, limit: 500),
+            updatedAt: now,
+            identity: nil)
+        let metadata = try #require(ProviderDefaults.metadata[.cursor])
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .cursor,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.metrics.map(\.title) == ["Requests"])
+        #expect(model.metrics.first?.detailText == "Request quota: 347 / 500")
+    }
+}
diff --git a/Tests/CodexBarTests/CursorStatusProbeTests.swift b/Tests/CodexBarTests/CursorStatusProbeTests.swift
index b92ec265e8..921a4ed8b9 100644
--- a/Tests/CodexBarTests/CursorStatusProbeTests.swift
+++ b/Tests/CodexBarTests/CursorStatusProbeTests.swift
@@ -1,13 +1,14 @@
 import Foundation
+import SQLite3
 import Testing
 @testable import CodexBarCore
 
-@Suite
+@Suite(.serialized)
 struct CursorStatusProbeTests {
     // MARK: - Usage Summary Parsing
 
     @Test
-    func parsesBasicUsageSummary() throws {
+    func `parses basic usage summary`() throws {
         let json = """
         {
             "billingCycleStart": "2025-01-01T00:00:00.000Z",
@@ -51,7 +52,7 @@ struct CursorStatusProbeTests {
     }
 
     @Test
-    func parsesMinimalUsageSummary() throws {
+    func `parses minimal usage summary`() throws {
         let json = """
         {
             "membershipType": "hobby",
@@ -73,7 +74,7 @@ struct CursorStatusProbeTests {
     }
 
     @Test
-    func parsesEnterpriseUsageSummary() throws {
+    func `parses enterprise usage summary`() throws {
         let json = """
         {
             "membershipType": "enterprise",
@@ -99,7 +100,7 @@ struct CursorStatusProbeTests {
     // MARK: - User Info Parsing
 
     @Test
-    func parsesUserInfo() throws {
+    func `parses user info`() throws {
         let json = """
         {
             "email": "user@example.com",
@@ -120,7 +121,7 @@ struct CursorStatusProbeTests {
     // MARK: - Snapshot Conversion
 
     @Test
-    func prefersPlanRatioOverPercentField() {
+    func `prefers plan ratio over percent field`() {
         let snapshot = CursorStatusProbe(browserDetection: BrowserDetection(cacheTTL: 0))
             .parseUsageSummary(
                 CursorUsageSummary(
@@ -146,11 +147,12 @@ struct CursorStatusProbeTests {
                 userInfo: nil,
                 rawJSON: nil)
 
-        #expect(snapshot.planPercentUsed == 9.8)
+        // totalPercentUsed is already expressed in percentage units.
+        #expect(snapshot.planPercentUsed == 0.40625)
     }
 
     @Test
-    func usesPercentFieldWhenLimitMissing() {
+    func `uses percent field when limit missing`() {
         let snapshot = CursorStatusProbe(browserDetection: BrowserDetection(cacheTTL: 0))
             .parseUsageSummary(
                 CursorUsageSummary(
@@ -176,19 +178,164 @@ struct CursorStatusProbeTests {
                 userInfo: nil,
                 rawJSON: nil)
 
-        #expect(snapshot.planPercentUsed == 50.0)
+        #expect(snapshot.planPercentUsed == 0.5)
     }
 
     @Test
-    func convertsSnapshotToUsageSnapshot() {
+    func `headline total prefers provided total percent over lane average`() {
+        let snapshot = CursorStatusProbe(browserDetection: BrowserDetection(cacheTTL: 0))
+            .parseUsageSummary(
+                CursorUsageSummary(
+                    billingCycleStart: nil,
+                    billingCycleEnd: nil,
+                    membershipType: "pro",
+                    limitType: nil,
+                    isUnlimited: false,
+                    autoModelSelectedDisplayMessage: nil,
+                    namedModelSelectedDisplayMessage: nil,
+                    individualUsage: CursorIndividualUsage(
+                        plan: CursorPlanUsage(
+                            enabled: true,
+                            used: 5400,
+                            limit: 2000,
+                            remaining: nil,
+                            breakdown: nil,
+                            autoPercentUsed: 0,
+                            apiPercentUsed: 0.01,
+                            totalPercentUsed: 0.27),
+                        onDemand: nil),
+                    teamUsage: nil),
+                userInfo: nil,
+                rawJSON: nil)
+
+        #expect(snapshot.planPercentUsed == 0.27)
+        #expect(snapshot.autoPercentUsed == 0)
+        #expect(snapshot.apiPercentUsed == 0.01)
+    }
+
+    @Test
+    func `sub pool percents accept plain percent scale`() {
+        let snapshot = CursorStatusProbe(browserDetection: BrowserDetection(cacheTTL: 0))
+            .parseUsageSummary(
+                CursorUsageSummary(
+                    billingCycleStart: nil,
+                    billingCycleEnd: nil,
+                    membershipType: "pro",
+                    limitType: nil,
+                    isUnlimited: false,
+                    autoModelSelectedDisplayMessage: nil,
+                    namedModelSelectedDisplayMessage: nil,
+                    individualUsage: CursorIndividualUsage(
+                        plan: CursorPlanUsage(
+                            enabled: true,
+                            used: 0,
+                            limit: 2000,
+                            remaining: nil,
+                            breakdown: nil,
+                            autoPercentUsed: 12.5,
+                            apiPercentUsed: 3.0,
+                            totalPercentUsed: nil),
+                        onDemand: nil),
+                    teamUsage: nil),
+                userInfo: nil,
+                rawJSON: nil)
+
+        #expect(snapshot.autoPercentUsed == 12.5)
+        #expect(snapshot.apiPercentUsed == 3.0)
+        // Dashboard-style total ≈ average of Auto and API lanes
+        #expect(snapshot.planPercentUsed == 7.75)
+    }
+
+    @Test
+    func `headline total matches dashboard blend when lanes match totalPercentUsed`() {
+        let snapshot = CursorStatusProbe(browserDetection: BrowserDetection(cacheTTL: 0))
+            .parseUsageSummary(
+                CursorUsageSummary(
+                    billingCycleStart: nil,
+                    billingCycleEnd: nil,
+                    membershipType: "pro",
+                    limitType: nil,
+                    isUnlimited: false,
+                    autoModelSelectedDisplayMessage: nil,
+                    namedModelSelectedDisplayMessage: nil,
+                    individualUsage: CursorIndividualUsage(
+                        plan: CursorPlanUsage(
+                            enabled: true,
+                            used: 0,
+                            limit: 2000,
+                            remaining: nil,
+                            breakdown: nil,
+                            autoPercentUsed: 35,
+                            apiPercentUsed: 97,
+                            totalPercentUsed: 66),
+                        onDemand: nil),
+                    teamUsage: nil),
+                userInfo: nil,
+                rawJSON: nil)
+
+        #expect(snapshot.planPercentUsed == 66)
+        #expect(snapshot.autoPercentUsed == 35)
+        #expect(snapshot.apiPercentUsed == 97)
+    }
+
+    @Test
+    func `live cursor payload keeps fractional percents without scaling`() {
+        let snapshot = CursorStatusProbe(browserDetection: BrowserDetection(cacheTTL: 0))
+            .parseUsageSummary(
+                CursorUsageSummary(
+                    billingCycleStart: "2026-03-18T20:45:42.000Z",
+                    billingCycleEnd: "2026-04-18T20:45:42.000Z",
+                    membershipType: "pro",
+                    limitType: "user",
+                    isUnlimited: false,
+                    autoModelSelectedDisplayMessage: "You've used 1% of your included total usage",
+                    namedModelSelectedDisplayMessage: "You've used 1% of your included API usage",
+                    individualUsage: CursorIndividualUsage(
+                        plan: CursorPlanUsage(
+                            enabled: true,
+                            used: 86,
+                            limit: 2000,
+                            remaining: 1914,
+                            breakdown: CursorPlanBreakdown(
+                                included: 86,
+                                bonus: 0,
+                                total: 86),
+                            autoPercentUsed: 0.36,
+                            apiPercentUsed: 0.7111111111111111,
+                            totalPercentUsed: 0.441025641025641),
+                        onDemand: CursorOnDemandUsage(
+                            enabled: false,
+                            used: 0,
+                            limit: nil,
+                            remaining: nil)),
+                    teamUsage: CursorTeamUsage(onDemand: nil)),
+                userInfo: nil,
+                rawJSON: nil)
+
+        #expect(snapshot.planPercentUsed == 0.441025641025641)
+        #expect(snapshot.autoPercentUsed == 0.36)
+        #expect(snapshot.apiPercentUsed == 0.7111111111111111)
+        #expect(snapshot.billingCycleStart != nil)
+        let usageSnapshot = snapshot.toUsageSnapshot()
+        #expect(usageSnapshot.primary?.remainingPercent == 99.55897435897436)
+        #expect(usageSnapshot.primary?.windowMinutes == 44640)
+        #expect(usageSnapshot.secondary?.windowMinutes == 44640)
+        #expect(usageSnapshot.tertiary?.windowMinutes == 44640)
+    }
+
+    @Test
+    func `converts snapshot to usage snapshot`() {
         let snapshot = CursorStatusSnapshot(
             planPercentUsed: 45.0,
+            autoPercentUsed: 5.0,
+            apiPercentUsed: nil,
             planUsedUSD: 22.50,
             planLimitUSD: 50.0,
             onDemandUsedUSD: 5.0,
             onDemandLimitUSD: 100.0,
             teamOnDemandUsedUSD: 25.0,
             teamOnDemandLimitUSD: 500.0,
+            billingCycleStart: Date(timeIntervalSince1970: 1_735_689_600), // Jan 1, 2025
             billingCycleEnd: Date(timeIntervalSince1970: 1_738_368_000), // Feb 1, 2025
             membershipType: "pro",
             accountEmail: "user@example.com",
@@ -201,17 +348,46 @@ struct CursorStatusProbeTests {
         #expect(usageSnapshot.accountEmail(for: .cursor) == "user@example.com")
         #expect(usageSnapshot.loginMethod(for: .cursor) == "Cursor Pro")
         #expect(usageSnapshot.secondary != nil)
-        // Uses individual on-demand values (what users see in their dashboard)
         #expect(usageSnapshot.secondary?.usedPercent == 5.0)
+        #expect(usageSnapshot.primary?.windowMinutes == 44640)
+        #expect(usageSnapshot.secondary?.windowMinutes == 44640)
         #expect(usageSnapshot.providerCost?.used == 5.0)
         #expect(usageSnapshot.providerCost?.limit == 100.0)
         #expect(usageSnapshot.providerCost?.currencyCode == "USD")
     }
 
     @Test
-    func usesIndividualOnDemandWhenNoTeamUsage() {
+    func `provider cost includes on demand budget before first spend`() {
+        let snapshot = CursorStatusSnapshot(
+            planPercentUsed: 10.0,
+            autoPercentUsed: 5.0,
+            apiPercentUsed: nil,
+            planUsedUSD: 5.0,
+            planLimitUSD: 50.0,
+            onDemandUsedUSD: 0,
+            onDemandLimitUSD: 75.0,
+            teamOnDemandUsedUSD: nil,
+            teamOnDemandLimitUSD: nil,
+            billingCycleEnd: nil,
+            membershipType: "pro",
+            accountEmail: nil,
+            accountName: nil,
+            rawJSON: nil)
+
+        let usageSnapshot = snapshot.toUsageSnapshot()
+
+        #expect(usageSnapshot.providerCost != nil)
+        #expect(usageSnapshot.providerCost?.used == 0.0)
+        #expect(usageSnapshot.providerCost?.limit == 75.0)
+        #expect(usageSnapshot.providerCost?.period == "Monthly")
+    }
+
+    @Test
+    func `uses individual on demand when no team usage`() {
         let snapshot = CursorStatusSnapshot(
             planPercentUsed: 10.0,
+            autoPercentUsed: 20.0,
+            apiPercentUsed: nil,
             planUsedUSD: 5.0,
             planLimitUSD: 50.0,
             onDemandUsedUSD: 12.0,
@@ -232,7 +408,32 @@ struct CursorStatusProbeTests {
     }
 
     @Test
-    func formatsMembershipTypes() {
+    func `uses team on demand budget when individual usage has no cap`() {
+        let snapshot = CursorStatusSnapshot(
+            planPercentUsed: 0,
+            autoPercentUsed: 0,
+            apiPercentUsed: 0,
+            planUsedUSD: 0,
+            planLimitUSD: 20,
+            onDemandUsedUSD: 0,
+            onDemandLimitUSD: nil,
+            teamOnDemandUsedUSD: 0,
+            teamOnDemandLimitUSD: 2349,
+            billingCycleEnd: nil,
+            membershipType: "enterprise",
+            accountEmail: nil,
+            accountName: nil,
+            rawJSON: nil)
+
+        let usageSnapshot = snapshot.toUsageSnapshot()
+
+        #expect(usageSnapshot.providerCost?.used == 0)
+        #expect(usageSnapshot.providerCost?.limit == 2349)
+        #expect(usageSnapshot.providerCost?.currencyCode == "USD")
+    }
+
+    @Test
+    func `formats membership types`() {
         let testCases: [(input: String, expected: String)] = [
             ("pro", "Cursor Pro"),
             ("hobby", "Cursor Hobby"),
@@ -262,7 +463,7 @@ struct CursorStatusProbeTests {
     }
 
     @Test
-    func handlesNilOnDemandLimit() {
+    func `handles nil on demand limit`() {
         let snapshot = CursorStatusSnapshot(
             planPercentUsed: 50.0,
             planUsedUSD: 25.0,
@@ -290,7 +491,7 @@ struct CursorStatusProbeTests {
     // MARK: - Legacy Request-Based Plan
 
     @Test
-    func parsesLegacyRequestBasedPlan() {
+    func `parses legacy request based plan`() {
         let snapshot = CursorStatusSnapshot(
             planPercentUsed: 100.0,
             planUsedUSD: 0,
@@ -324,7 +525,7 @@ struct CursorStatusProbeTests {
     }
 
     @Test
-    func legacyPlanPrimaryUsesRequestsNotDollars() {
+    func `legacy plan primary uses requests not dollars`() {
         // Regression: Legacy plans report planPercentUsed as 0 while requests are used
         let snapshot = CursorStatusSnapshot(
             planPercentUsed: 0.0, // Dollar-based shows 0
@@ -352,7 +553,7 @@ struct CursorStatusProbeTests {
     }
 
     @Test
-    func parseUsageSummaryPrefersRequestTotal() {
+    func `parse usage summary prefers request total`() {
         let summary = CursorUsageSummary(
             billingCycleStart: nil,
             billingCycleEnd: nil,
@@ -382,8 +583,201 @@ struct CursorStatusProbeTests {
         #expect(snapshot.requestsLimit == 500)
     }
 
+    // MARK: - Imported Session Scanning
+
+    @Test
+    func `imported session scan continues after non auth failure until later success`() async {
+        let probe = CursorStatusProbe(browserDetection: BrowserDetection(cacheTTL: 0))
+        let expected = CursorStatusSnapshot(
+            planPercentUsed: 0.441025641025641,
+            autoPercentUsed: 0.36,
+            apiPercentUsed: 0.7111111111111111,
+            planUsedUSD: 0.86,
+            planLimitUSD: 20.0,
+            onDemandUsedUSD: 0,
+            onDemandLimitUSD: nil,
+            teamOnDemandUsedUSD: nil,
+            teamOnDemandLimitUSD: nil,
+            billingCycleEnd: nil,
+            membershipType: "pro",
+            accountEmail: nil,
+            accountName: nil,
+            rawJSON: nil)
+
+        let result = await probe.scanImportedSessions([
+            Self.makeSessionInfo(sourceLabel: "Chrome"),
+            Self.makeSessionInfo(sourceLabel: "Safari"),
+        ]) { session in
+            switch session.sourceLabel {
+            case "Chrome":
+                .failed(.networkError("HTTP 500"))
+            case "Safari":
+                .succeeded(expected)
+            default:
+                .tryNextBrowser
+            }
+        }
+
+        switch result {
+        case let .succeeded(snapshot):
+            #expect(snapshot.planPercentUsed == expected.planPercentUsed)
+            #expect(snapshot.autoPercentUsed == expected.autoPercentUsed)
+            #expect(snapshot.apiPercentUsed == expected.apiPercentUsed)
+        case .exhausted:
+            Issue.record("Expected scan to continue to the later successful browser session")
+        }
+    }
+
+    @Test
+    func `imported session scan preserves first non auth failure after exhausting sessions`() async {
+        let probe = CursorStatusProbe(browserDetection: BrowserDetection(cacheTTL: 0))
+
+        let result = await probe.scanImportedSessions([
+            Self.makeSessionInfo(sourceLabel: "Chrome"),
+            Self.makeSessionInfo(sourceLabel: "Safari"),
+            Self.makeSessionInfo(sourceLabel: "Arc"),
+        ]) { session in
+            switch session.sourceLabel {
+            case "Chrome":
+                .failed(.networkError("HTTP 500"))
+            case "Safari":
+                .tryNextBrowser
+            case "Arc":
+                .failed(.parseFailed("bad payload"))
+            default:
+                .tryNextBrowser
+            }
+        }
+
+        switch result {
+        case .succeeded:
+            Issue.record("Expected scan to report the first recoverable error after exhausting sessions")
+        case let .exhausted(error):
+            guard let error else {
+                Issue.record("Expected first recoverable error to be preserved")
+                return
+            }
+            guard case let .networkError(message) = error else {
+                Issue.record("Expected first recoverable error to be the Chrome network failure")
+                return
+            }
+            #expect(message == "HTTP 500")
+        }
+    }
+
+    @Test
+    func `browser scan stops importing after later browser succeeds`() async {
+        let probe = CursorStatusProbe(browserDetection: BrowserDetection(cacheTTL: 0))
+        let expected = CursorStatusSnapshot(
+            planPercentUsed: 42,
+            autoPercentUsed: 12,
+            apiPercentUsed: 85,
+            planUsedUSD: 8.4,
+            planLimitUSD: 20,
+            onDemandUsedUSD: 0,
+            onDemandLimitUSD: nil,
+            teamOnDemandUsedUSD: nil,
+            teamOnDemandLimitUSD: nil,
+            billingCycleEnd: nil,
+            membershipType: "pro",
+            accountEmail: nil,
+            accountName: nil,
+            rawJSON: nil)
+        var importedLabels: [String] = []
+
+        let result = await probe.scanBrowsers(
+            [.chrome, .safari, .chromeBeta],
+            importSessions: { browser in
+                importedLabels.append(browser.displayName)
+                switch browser {
+                case .chrome:
+                    return [Self.makeSessionInfo(sourceLabel: "Chrome")]
+                case .safari:
+                    return [Self.makeSessionInfo(sourceLabel: "Safari")]
+                case .chromeBeta:
+                    return [Self.makeSessionInfo(sourceLabel: "Chrome Beta")]
+                default:
+                    return []
+                }
+            },
+            attemptFetch: { session in
+                switch session.sourceLabel {
+                case "Chrome":
+                    .failed(.networkError("HTTP 500"))
+                case "Safari":
+                    .succeeded(expected)
+                default:
+                    .tryNextBrowser
+                }
+            })
+
+        switch result {
+        case let .succeeded(snapshot):
+            #expect(snapshot.planPercentUsed == expected.planPercentUsed)
+            #expect(importedLabels == ["Chrome", "Safari"])
+        case .exhausted:
+            Issue.record("Expected browser scan to stop after the later successful browser")
+        }
+    }
+
     @Test
-    func detectsNonLegacyPlan() {
+    func `browser scan keeps trying later sources within the same browser`() async {
+        let probe = CursorStatusProbe(browserDetection: BrowserDetection(cacheTTL: 0))
+        let expected = CursorStatusSnapshot(
+            planPercentUsed: 12,
+            autoPercentUsed: 3,
+            apiPercentUsed: 45,
+            planUsedUSD: 2.4,
+            planLimitUSD: 20,
+            onDemandUsedUSD: 0,
+            onDemandLimitUSD: nil,
+            teamOnDemandUsedUSD: nil,
+            teamOnDemandLimitUSD: nil,
+            billingCycleEnd: nil,
+            membershipType: "pro",
+            accountEmail: nil,
+            accountName: nil,
+            rawJSON: nil)
+        var attemptedSources: [String] = []
+
+        let result = await probe.scanBrowsers(
+            [.chrome, .safari],
+            importSessions: { browser in
+                switch browser {
+                case .chrome:
+                    [
+                        Self.makeSessionInfo(sourceLabel: "Chrome Profile 1"),
+                        Self.makeSessionInfo(sourceLabel: "Chrome Profile 2 (domain cookies)"),
+                    ]
+                case .safari:
+                    [Self.makeSessionInfo(sourceLabel: "Safari")]
+                default:
+                    []
+                }
+            },
+            attemptFetch: { session in
+                attemptedSources.append(session.sourceLabel)
+                switch session.sourceLabel {
+                case "Chrome Profile 1":
+                    return CursorStatusProbe.ImportedSessionFetchOutcome.failed(.networkError("HTTP 500"))
+                case "Chrome Profile 2 (domain cookies)":
+                    return CursorStatusProbe.ImportedSessionFetchOutcome.succeeded(expected)
+                default:
+                    return CursorStatusProbe.ImportedSessionFetchOutcome.tryNextBrowser
+                }
+            })
+
+        switch result {
+        case let .succeeded(snapshot):
+            #expect(snapshot.planPercentUsed == expected.planPercentUsed)
+            #expect(attemptedSources == ["Chrome Profile 1", "Chrome Profile 2 (domain cookies)"])
+        case .exhausted:
+            Issue.record("Expected browser scan to continue to later sources within the same browser")
+        }
+    }
+
+    @Test
+    func `detects non legacy plan`() {
         let snapshot = CursorStatusSnapshot(
             planPercentUsed: 50.0,
             planUsedUSD: 25.0,
@@ -409,7 +803,7 @@ struct CursorStatusProbeTests {
     // MARK: - Session Store Serialization
 
     @Test
-    func sessionStoreSavesAndLoadsCookies() async {
+    func `session store saves and loads cookies`() async {
         let store = CursorSessionStore.shared
 
         // Clear any existing cookies
@@ -444,7 +838,7 @@ struct CursorStatusProbeTests {
     }
 
     @Test
-    func sessionStoreReloadsFromDiskWhenNeeded() async {
+    func `session store reloads from disk when needed`() async {
         let store = CursorSessionStore.shared
         await store.resetForTesting()
 
@@ -474,7 +868,7 @@ struct CursorStatusProbeTests {
     }
 
     @Test
-    func sessionStoreHasValidSessionLoadsFromDisk() async {
+    func `session store has valid session loads from disk`() async {
         let store = CursorSessionStore.shared
         await store.resetForTesting()
 
@@ -500,4 +894,606 @@ struct CursorStatusProbeTests {
 
         await store.clearCookies()
     }
+
+    private static func makeSessionInfo(sourceLabel: String) -> CursorCookieImporter.SessionInfo {
+        let cookieProps: [HTTPCookiePropertyKey: Any] = [
+            .name: "WorkosCursorSessionToken",
+            .value: sourceLabel.lowercased(),
+            .domain: "cursor.com",
+            .path: "/",
+            .secure: true,
+        ]
+
+        let cookie = HTTPCookie(properties: cookieProps)!
+        return CursorCookieImporter.SessionInfo(cookies: [cookie], sourceLabel: sourceLabel)
+    }
+}
+
+private final class CursorStatusProbeTestSession {
+    let urlSession: URLSession
+    private let sessionID: String
+
+    init(handler: @escaping @Sendable (URLRequest) throws -> (HTTPURLResponse, Data)) {
+        let config = URLSessionConfiguration.ephemeral
+        config.protocolClasses = [CursorStatusProbeStubURLProtocol.self]
+        self.sessionID = CursorStatusProbeStubURLProtocol.configure(config, handler: handler)
+        self.urlSession = URLSession(configuration: config)
+    }
+
+    deinit {
+        self.urlSession.invalidateAndCancel()
+        CursorStatusProbeStubURLProtocol.removeSession(self.sessionID)
+    }
+
+    var requestCount: Int {
+        CursorStatusProbeStubURLProtocol.requests(for: self.sessionID).count
+    }
+
+    var requestPaths: [String] {
+        CursorStatusProbeStubURLProtocol.requests(for: self.sessionID).compactMap { $0.url?.path }
+    }
+
+    var requestCookies: [String] {
+        CursorStatusProbeStubURLProtocol.requests(for: self.sessionID)
+            .compactMap { $0.value(forHTTPHeaderField: "Cookie") }
+    }
+}
+
+private func makeCursorStatusProbeResponse(
+    url: URL,
+    body: String,
+    statusCode: Int,
+    contentType: String = "application/json") -> (HTTPURLResponse, Data)
+{
+    let response = HTTPURLResponse(
+        url: url,
+        statusCode: statusCode,
+        httpVersion: nil,
+        headerFields: ["Content-Type": contentType])!
+    return (response, Data(body.utf8))
+}
+
+extension CursorStatusProbeTests {
+    @Test
+    func `app auth store reads Cursor global state database`() throws {
+        let directory = FileManager.default.temporaryDirectory
+            .appendingPathComponent("cursor-app-auth-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: directory) }
+
+        let dbURL = directory.appendingPathComponent("state.vscdb")
+        var db: OpaquePointer?
+        try #require(sqlite3_open(dbURL.path, &db) == SQLITE_OK)
+        defer { sqlite3_close(db) }
+
+        let sql = """
+        CREATE TABLE ItemTable(key TEXT PRIMARY KEY, value BLOB);
+        INSERT INTO ItemTable VALUES('cursorAuth/accessToken', 'app-token');
+        """
+        try #require(sqlite3_exec(db, sql, nil, nil, nil) == SQLITE_OK)
+
+        let session = try #require(try CursorAppAuthStore(dbPath: dbURL.path).loadSession())
+        #expect(session == CursorAppAuthSession(accessToken: "app-token"))
+    }
+
+    @Test
+    func `fetch ignores user info failure when usage summary succeeds`() async throws {
+        let testSession = CursorStatusProbeTestSession { request in
+            let requestURL = try #require(request.url)
+
+            switch requestURL.path {
+            case "/api/usage-summary":
+                return makeCursorStatusProbeResponse(
+                    url: requestURL,
+                    body: """
+                    {
+                      "membershipType": "pro",
+                      "individualUsage": {
+                        "plan": {
+                          "used": 1500,
+                          "limit": 5000,
+                          "totalPercentUsed": 30.0
+                        }
+                      }
+                    }
+                    """,
+                    statusCode: 200)
+            case "/api/auth/me":
+                return makeCursorStatusProbeResponse(
+                    url: requestURL,
+                    body: #"{"error":"nope"}"#,
+                    statusCode: 500)
+            default:
+                throw URLError(.badURL)
+            }
+        }
+
+        let baseURL = try #require(URL(string: "https://cursor.test"))
+        let snapshot = try await CursorStatusProbe(
+            baseURL: baseURL,
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            urlSession: testSession.urlSession).fetchWithManualCookies("auth=test")
+
+        #expect(snapshot.planPercentUsed == 30.0)
+        #expect(snapshot.accountEmail == nil)
+        #expect(testSession.requestCount == 2)
+    }
+
+    @Test
+    func `fetch fails cleanly when usage summary fails`() async {
+        let testSession = CursorStatusProbeTestSession { request in
+            let requestURL = try #require(request.url)
+
+            switch requestURL.path {
+            case "/api/usage-summary":
+                return makeCursorStatusProbeResponse(
+                    url: requestURL,
+                    body: #"{"error":"denied"}"#,
+                    statusCode: 500)
+            case "/api/auth/me":
+                return makeCursorStatusProbeResponse(
+                    url: requestURL,
+                    body: """
+                    {
+                      "email": "user@example.com",
+                      "email_verified": true,
+                      "name": "Test User",
+                      "sub": "auth0|12345"
+                    }
+                    """,
+                    statusCode: 200)
+            default:
+                throw URLError(.badURL)
+            }
+        }
+
+        do {
+            let baseURL = try #require(URL(string: "https://cursor.test"))
+            _ = try await CursorStatusProbe(
+                baseURL: baseURL,
+                browserDetection: BrowserDetection(cacheTTL: 0),
+                urlSession: testSession.urlSession).fetchWithManualCookies("auth=test")
+            Issue.record("Expected usage summary failure to be surfaced")
+        } catch let error as CursorStatusProbeError {
+            guard case let .networkError(message) = error else {
+                Issue.record("Expected networkError, got: \(error)")
+                return
+            }
+            #expect(message == "HTTP 500")
+            #expect(testSession.requestPaths.contains("/api/usage-summary"))
+        } catch {
+            Issue.record("Expected CursorStatusProbeError, got: \(error)")
+        }
+    }
+
+    @Test
+    func `fetch uses Cursor app local auth when browser cookies are unavailable`() async throws {
+        let accessToken = try makeCursorAppAuthToken()
+        let expectedCookie = "WorkosCursorSessionToken=user_test%3A%3A\(accessToken)"
+        let testSession = CursorStatusProbeTestSession { request in
+            let requestURL = try #require(request.url)
+            #expect(request.value(forHTTPHeaderField: "Authorization") == nil)
+            #expect(request.value(forHTTPHeaderField: "Cookie") == expectedCookie)
+            #expect(request.httpMethod == "GET")
+
+            switch requestURL.path {
+            case "/api/usage-summary":
+                return makeCursorStatusProbeResponse(
+                    url: requestURL,
+                    body: """
+                    {
+                      "membershipType": "pro",
+                      "billingCycleStart": "2026-05-23T10:27:04.000Z",
+                      "billingCycleEnd": "2026-06-23T10:27:04.000Z",
+                      "individualUsage": {
+                        "plan": {
+                          "used": 388,
+                          "limit": 2000,
+                          "totalPercentUsed": 19.4
+                        },
+                        "onDemand": {
+                          "used": 450,
+                          "limit": 1000
+                        }
+                      }
+                    }
+                    """,
+                    statusCode: 200)
+            case "/api/auth/me":
+                return makeCursorStatusProbeResponse(
+                    url: requestURL,
+                    body: #"{"email":"user@example.com","name":"Test User"}"#,
+                    statusCode: 200)
+            case "/api/usage":
+                return makeCursorStatusProbeResponse(
+                    url: requestURL,
+                    body: #"{"gpt-4":{},"startOfMonth":"2026-05-23"}"#,
+                    statusCode: 200)
+            default:
+                throw URLError(.badURL)
+            }
+        }
+
+        let baseURL = try #require(URL(string: "https://cursor-web.test"))
+        let snapshot = try await CursorStatusProbe(
+            baseURL: baseURL,
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            browserCookieImportOrder: [],
+            urlSession: testSession.urlSession,
+            appAuthStore: CursorAppAuthSessionProviderStub(session: CursorAppAuthSession(
+                accessToken: accessToken))).fetch(allowCachedSessions: false)
+
+        #expect(abs(snapshot.planPercentUsed - 19.4) < 0.0001)
+        #expect(snapshot.planUsedUSD == 3.88)
+        #expect(snapshot.planLimitUSD == 20.0)
+        #expect(snapshot.onDemandUsedUSD == 4.5)
+        #expect(snapshot.onDemandLimitUSD == 10.0)
+        #expect(snapshot.membershipType == "pro")
+        #expect(snapshot.accountEmail == "user@example.com")
+        #expect(snapshot.accountName == "Test User")
+        #expect(testSession.requestPaths.sorted() == [
+            "/api/auth/me",
+            "/api/usage",
+            "/api/usage-summary",
+        ])
+    }
+
+    @Test
+    func `fetch can disable Cursor app auth during browser login verification`() async throws {
+        let testSession = CursorStatusProbeTestSession { request in
+            Issue.record("Disabled app auth unexpectedly requested \(request.url?.path ?? "<unknown>")")
+            throw URLError(.badURL)
+        }
+
+        let baseURL = try #require(URL(string: "https://cursor-web.test"))
+        let accessToken = try makeCursorAppAuthToken()
+        let probe = CursorStatusProbe(
+            baseURL: baseURL,
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            browserCookieImportOrder: [],
+            urlSession: testSession.urlSession,
+            appAuthStore: CursorAppAuthSessionProviderStub(session: CursorAppAuthSession(
+                accessToken: accessToken)))
+
+        await #expect(throws: CursorStatusProbeError.self) {
+            _ = try await probe.fetch(
+                allowCachedSessions: false,
+                allowAppAuthFallback: false)
+        }
+        #expect(testSession.requestCount == 0)
+    }
+
+    @Test
+    func `fetch prefers stored session cookies before Cursor app auth fallback`() async throws {
+        let store = CursorSessionStore.shared
+        await store.clearCookies()
+        defer {
+            Task { await store.clearCookies() }
+        }
+
+        guard let cookie = HTTPCookie(properties: [
+            .name: "WorkosCursorSessionToken",
+            .value: "stored-session",
+            .domain: "cursor.com",
+            .path: "/",
+            .secure: true,
+        ]) else {
+            Issue.record("Failed to create stored Cursor session cookie")
+            return
+        }
+        await store.setCookies([cookie])
+
+        let testSession = CursorStatusProbeTestSession { request in
+            let requestURL = try #require(request.url)
+            #expect(request.value(forHTTPHeaderField: "Authorization") == nil)
+            #expect(request.value(forHTTPHeaderField: "Cookie") == "WorkosCursorSessionToken=stored-session")
+
+            switch requestURL.path {
+            case "/api/usage-summary":
+                return makeCursorStatusProbeResponse(
+                    url: requestURL,
+                    body: """
+                    {
+                      "membershipType": "pro",
+                      "individualUsage": {
+                        "plan": {
+                          "used": 1500,
+                          "limit": 5000,
+                          "totalPercentUsed": 30.0
+                        }
+                      }
+                    }
+                    """,
+                    statusCode: 200)
+            case "/api/auth/me":
+                return makeCursorStatusProbeResponse(
+                    url: requestURL,
+                    body: #"{"email":"stored@example.com","name":"Stored User"}"#,
+                    statusCode: 200)
+            default:
+                Issue.record("Stored-session precedence test unexpectedly requested \(requestURL.path)")
+                throw URLError(.badURL)
+            }
+        }
+
+        let baseURL = try #require(URL(string: "https://cursor.test"))
+        let accessToken = try makeCursorAppAuthToken()
+        let snapshot = try await CursorStatusProbe(
+            baseURL: baseURL,
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            browserCookieImportOrder: [],
+            urlSession: testSession.urlSession,
+            appAuthStore: CursorAppAuthSessionProviderStub(session: CursorAppAuthSession(
+                accessToken: accessToken))).fetch()
+
+        #expect(snapshot.planPercentUsed == 30.0)
+        #expect(snapshot.accountEmail == "stored@example.com")
+        #expect(testSession.requestPaths.sorted() == [
+            "/api/auth/me",
+            "/api/usage-summary",
+        ])
+    }
+
+    @Test
+    func `fetch with Cursor app auth preserves legacy request quotas`() async throws {
+        let accessToken = try makeCursorAppAuthToken()
+        let expectedCookie = "WorkosCursorSessionToken=user_test%3A%3A\(accessToken)"
+        let testSession = CursorStatusProbeTestSession { request in
+            let requestURL = try #require(request.url)
+            #expect(request.value(forHTTPHeaderField: "Cookie") == expectedCookie)
+
+            switch requestURL.path {
+            case "/api/usage-summary":
+                return makeCursorStatusProbeResponse(
+                    url: requestURL,
+                    body: """
+                    {
+                      "membershipType": "enterprise",
+                      "individualUsage": {}
+                    }
+                    """,
+                    statusCode: 200)
+            case "/api/auth/me":
+                return makeCursorStatusProbeResponse(
+                    url: requestURL,
+                    body: #"{"error":"temporary"}"#,
+                    statusCode: 500)
+            case "/api/usage":
+                #expect(URLComponents(url: requestURL, resolvingAgainstBaseURL: false)?
+                    .queryItems?.first(where: { $0.name == "user" })?.value == "user_test")
+                return makeCursorStatusProbeResponse(
+                    url: requestURL,
+                    body: """
+                    {
+                      "gpt-4": {
+                        "numRequests": 200,
+                        "numRequestsTotal": 240,
+                        "maxRequestUsage": 500
+                      }
+                    }
+                    """,
+                    statusCode: 200)
+            default:
+                throw URLError(.badURL)
+            }
+        }
+
+        let baseURL = try #require(URL(string: "https://cursor.test"))
+        let probe = CursorStatusProbe(
+            baseURL: baseURL,
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            urlSession: testSession.urlSession)
+
+        let snapshot = try await probe.fetchWithAppAuthSession(CursorAppAuthSession(accessToken: accessToken))
+        #expect(snapshot.requestsUsed == 240)
+        #expect(snapshot.requestsLimit == 500)
+        #expect(snapshot.toUsageSnapshot().primary?.usedPercent == 48)
+        #expect(snapshot.accountEmail == nil)
+        #expect(testSession.requestPaths.sorted() == [
+            "/api/auth/me",
+            "/api/usage",
+            "/api/usage-summary",
+        ])
+    }
+
+    @Test
+    func `malformed Cursor app auth token is rejected before network access`() {
+        let session = CursorAppAuthSession(accessToken: "not-a-jwt")
+        #expect(throws: CursorStatusProbeError.self) {
+            _ = try session.cookieHeader()
+        }
+        #expect(!session.isUsable)
+    }
+
+    @Test
+    func `expired Cursor app auth token is skipped before network access`() async throws {
+        let testSession = CursorStatusProbeTestSession { request in
+            Issue.record("Expired app auth unexpectedly requested \(request.url?.path ?? "<unknown>")")
+            throw URLError(.badURL)
+        }
+
+        let accessToken = try makeCursorAppAuthToken(expiration: Date(timeIntervalSinceNow: -60))
+        let baseURL = try #require(URL(string: "https://cursor-web.test"))
+        let probe = CursorStatusProbe(
+            baseURL: baseURL,
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            browserCookieImportOrder: [],
+            urlSession: testSession.urlSession,
+            appAuthStore: CursorAppAuthSessionProviderStub(session: CursorAppAuthSession(
+                accessToken: accessToken)))
+
+        await #expect(throws: CursorStatusProbeError.self) {
+            _ = try await probe.fetch(allowCachedSessions: false)
+        }
+        #expect(testSession.requestCount == 0)
+    }
+
+    @Test
+    func `Cursor app auth transient failure is preserved`() async throws {
+        let testSession = CursorStatusProbeTestSession { request in
+            let requestURL = try #require(request.url)
+            return makeCursorStatusProbeResponse(
+                url: requestURL,
+                body: #"{"error":"temporary"}"#,
+                statusCode: 500)
+        }
+
+        let accessToken = try makeCursorAppAuthToken()
+        let baseURL = try #require(URL(string: "https://cursor-web.test"))
+        let probe = CursorStatusProbe(
+            baseURL: baseURL,
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            browserCookieImportOrder: [],
+            urlSession: testSession.urlSession,
+            appAuthStore: CursorAppAuthSessionProviderStub(session: CursorAppAuthSession(
+                accessToken: accessToken)))
+
+        do {
+            _ = try await probe.fetch(allowCachedSessions: false)
+            Issue.record("Expected Cursor.app auth request to fail")
+        } catch let error as CursorStatusProbeError {
+            guard case .networkError = error else {
+                Issue.record("Expected network error, got \(error)")
+                return
+            }
+        }
+    }
+
+    @Test
+    func `cached session transient failure does not switch to Cursor app auth`() async throws {
+        CookieHeaderCache.store(provider: .cursor, cookieHeader: "cached=bad", sourceLabel: "test")
+        defer {
+            CookieHeaderCache.clear(provider: .cursor)
+        }
+
+        let accessToken = try makeCursorAppAuthToken()
+        let appCookie = "WorkosCursorSessionToken=user_test%3A%3A\(accessToken)"
+        let testSession = CursorStatusProbeTestSession { request in
+            let requestURL = try #require(request.url)
+            let cookie = request.value(forHTTPHeaderField: "Cookie")
+            switch requestURL.path {
+            case "/api/usage-summary" where cookie == "cached=bad":
+                return makeCursorStatusProbeResponse(
+                    url: requestURL,
+                    body: #"{"error":"temporary"}"#,
+                    statusCode: 500)
+            case _ where cookie == appCookie:
+                Issue.record("Transient cached-session failure unexpectedly switched to Cursor.app auth")
+                throw URLError(.userAuthenticationRequired)
+            default:
+                throw URLError(.badURL)
+            }
+        }
+
+        let baseURL = try #require(URL(string: "https://cursor-web.test"))
+        let probe = CursorStatusProbe(
+            baseURL: baseURL,
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            browserCookieImportOrder: [],
+            urlSession: testSession.urlSession,
+            appAuthStore: CursorAppAuthSessionProviderStub(session: CursorAppAuthSession(
+                accessToken: accessToken)))
+
+        await #expect(throws: CursorStatusProbeError.self) {
+            _ = try await probe.fetch()
+        }
+        #expect(testSession.requestCookies.contains("cached=bad"))
+        #expect(!testSession.requestCookies.contains(appCookie))
+    }
+}
+
+private func makeCursorAppAuthToken(
+    subject: String = "auth0|user_test",
+    expiration: Date = Date(timeIntervalSinceNow: 3600)) throws -> String
+{
+    let payload = try JSONSerialization.data(
+        withJSONObject: [
+            "exp": Int(expiration.timeIntervalSince1970),
+            "sub": subject,
+        ],
+        options: [.sortedKeys])
+    let encodedPayload = payload.base64EncodedString()
+        .replacingOccurrences(of: "+", with: "-")
+        .replacingOccurrences(of: "/", with: "_")
+        .replacingOccurrences(of: "=", with: "")
+    return "header.\(encodedPayload).signature"
+}
+
+private struct CursorAppAuthSessionProviderStub: CursorAppAuthSessionProviding {
+    let session: CursorAppAuthSession?
+
+    func loadSession() throws -> CursorAppAuthSession? {
+        self.session
+    }
+}
+
+final class CursorStatusProbeStubURLProtocol: URLProtocol {
+    private struct SessionState {
+        var requests: [URLRequest] = []
+        let handler: @Sendable (URLRequest) throws -> (HTTPURLResponse, Data)
+    }
+
+    private static let sessionHeader = "X-CodexBar-Cursor-Test-Session"
+    private static let lock = NSLock()
+    private nonisolated(unsafe) static var sessions: [String: SessionState] = [:]
+
+    static func configure(
+        _ configuration: URLSessionConfiguration,
+        handler: @escaping @Sendable (URLRequest) throws -> (HTTPURLResponse, Data)) -> String
+    {
+        let sessionID = UUID().uuidString
+        self.lock.lock()
+        self.sessions[sessionID] = SessionState(handler: handler)
+        self.lock.unlock()
+        configuration.httpAdditionalHeaders = [self.sessionHeader: sessionID]
+        return sessionID
+    }
+
+    static func removeSession(_ sessionID: String) {
+        self.lock.lock()
+        self.sessions.removeValue(forKey: sessionID)
+        self.lock.unlock()
+    }
+
+    static func requests(for sessionID: String) -> [URLRequest] {
+        self.lock.lock()
+        defer { Self.lock.unlock() }
+        return self.sessions[sessionID]?.requests ?? []
+    }
+
+    override static func canInit(with request: URLRequest) -> Bool {
+        true
+    }
+
+    override static func canonicalRequest(for request: URLRequest) -> URLRequest {
+        request
+    }
+
+    override func startLoading() {
+        let handler: (@Sendable (URLRequest) throws -> (HTTPURLResponse, Data))?
+        let sessionID = self.request.value(forHTTPHeaderField: Self.sessionHeader)
+        Self.lock.lock()
+        if let sessionID, var state = Self.sessions[sessionID] {
+            state.requests.append(self.request)
+            handler = state.handler
+            Self.sessions[sessionID] = state
+        } else {
+            handler = nil
+        }
+        Self.lock.unlock()
+
+        do {
+            guard let handler else {
+                throw URLError(.cancelled)
+            }
+            let (response, data) = try handler(self.request)
+            self.client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
+            self.client?.urlProtocol(self, didLoad: data)
+            self.client?.urlProtocolDidFinishLoading(self)
+        } catch {
+            self.client?.urlProtocol(self, didFailWithError: error)
+        }
+    }
+
+    override func stopLoading() {}
 }
diff --git a/Tests/CodexBarTests/DeepSeekSettingsReaderTests.swift b/Tests/CodexBarTests/DeepSeekSettingsReaderTests.swift
new file mode 100644
index 0000000000..0aba8b4a83
--- /dev/null
+++ b/Tests/CodexBarTests/DeepSeekSettingsReaderTests.swift
@@ -0,0 +1,73 @@
+import CodexBarCore
+import Testing
+
+struct DeepSeekSettingsReaderTests {
+    @Test
+    func `reads DEEPSEEK_API_KEY`() {
+        let env = ["DEEPSEEK_API_KEY": "sk-abc123"]
+        #expect(DeepSeekSettingsReader.apiKey(environment: env) == "sk-abc123")
+    }
+
+    @Test
+    func `falls back to DEEPSEEK_KEY`() {
+        let env = ["DEEPSEEK_KEY": "sk-fallback"]
+        #expect(DeepSeekSettingsReader.apiKey(environment: env) == "sk-fallback")
+    }
+
+    @Test
+    func `DEEPSEEK_API_KEY takes priority over DEEPSEEK_KEY`() {
+        let env = ["DEEPSEEK_API_KEY": "sk-primary", "DEEPSEEK_KEY": "sk-secondary"]
+        #expect(DeepSeekSettingsReader.apiKey(environment: env) == "sk-primary")
+    }
+
+    @Test
+    func `trims whitespace`() {
+        let env = ["DEEPSEEK_API_KEY": "  sk-trimmed  "]
+        #expect(DeepSeekSettingsReader.apiKey(environment: env) == "sk-trimmed")
+    }
+
+    @Test
+    func `strips double quotes`() {
+        let env = ["DEEPSEEK_API_KEY": "\"sk-quoted\""]
+        #expect(DeepSeekSettingsReader.apiKey(environment: env) == "sk-quoted")
+    }
+
+    @Test
+    func `strips single quotes`() {
+        let env = ["DEEPSEEK_KEY": "'sk-single'"]
+        #expect(DeepSeekSettingsReader.apiKey(environment: env) == "sk-single")
+    }
+
+    @Test
+    func `returns nil when no key present`() {
+        #expect(DeepSeekSettingsReader.apiKey(environment: [:]) == nil)
+    }
+
+    @Test
+    func `returns nil for empty key`() {
+        let env = ["DEEPSEEK_API_KEY": ""]
+        #expect(DeepSeekSettingsReader.apiKey(environment: env) == nil)
+    }
+
+    @Test
+    func `returns nil for whitespace-only key`() {
+        let env = ["DEEPSEEK_API_KEY": "   "]
+        #expect(DeepSeekSettingsReader.apiKey(environment: env) == nil)
+    }
+}
+
+struct DeepSeekProviderTokenResolverTests {
+    @Test
+    func `resolves from environment`() {
+        let env = ["DEEPSEEK_API_KEY": "sk-resolve-test"]
+        let resolution = ProviderTokenResolver.deepseekResolution(environment: env)
+        #expect(resolution?.token == "sk-resolve-test")
+        #expect(resolution?.source == .environment)
+    }
+
+    @Test
+    func `returns nil when key absent`() {
+        let resolution = ProviderTokenResolver.deepseekResolution(environment: [:])
+        #expect(resolution == nil)
+    }
+}
diff --git a/Tests/CodexBarTests/DeepSeekUsageCostParserTests.swift b/Tests/CodexBarTests/DeepSeekUsageCostParserTests.swift
new file mode 100644
index 0000000000..c7cc32b925
--- /dev/null
+++ b/Tests/CodexBarTests/DeepSeekUsageCostParserTests.swift
@@ -0,0 +1,855 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct DeepSeekUsageCostParserTests {
+    // Fixtures use date 2026-05-26
+    private let fixtureNow = Date(timeIntervalSince1970: 1_779_796_800) // 2026-05-26 12:00:00 UTC
+    private let fixtureCalendar: Calendar = {
+        var cal = Calendar.current
+        cal.timeZone = TimeZone(identifier: "UTC") ?? .current
+        return cal
+    }()
+
+    // MARK: - Amount Parser Tests
+
+    @Test
+    func `amount parser decodes total and days`() throws {
+        let json = """
+        {
+          "code": 0,
+          "msg": "",
+          "data": {
+            "biz_code": 0,
+            "biz_msg": "",
+            "biz_data": {
+              "total": [
+                {
+                  "model": "deepseek-v4-flash",
+                  "usage": [
+                    {"type": "PROMPT_CACHE_HIT_TOKEN", "amount": "100686720"},
+                    {"type": "PROMPT_CACHE_MISS_TOKEN", "amount": "1305432"},
+                    {"type": "RESPONSE_TOKEN", "amount": "656338"},
+                    {"type": "REQUEST", "amount": "1212"}
+                  ]
+                }
+              ],
+              "days": [
+                {
+                  "date": "2026-05-26",
+                  "data": [
+                    {
+                      "model": "deepseek-v4-flash",
+                      "usage": [
+                        {"type": "PROMPT_CACHE_HIT_TOKEN", "amount": "100686720"},
+                        {"type": "PROMPT_CACHE_MISS_TOKEN", "amount": "1305432"},
+                        {"type": "RESPONSE_TOKEN", "amount": "656338"},
+                        {"type": "REQUEST", "amount": "1212"}
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          }
+        }
+        """
+        let payload = try DeepSeekUsageCostParser.decodeAmountPayload(data: Data(json.utf8))
+        #expect(payload.code == 0)
+        #expect(payload.data?.bizCode == 0)
+        #expect(payload.data?.bizData?.total?.count == 1)
+        #expect(payload.data?.bizData?.total?[0].model == "deepseek-v4-flash")
+        #expect(payload.data?.bizData?.days?.count == 1)
+        #expect(payload.data?.bizData?.days?[0].date == "2026-05-26")
+    }
+
+    @Test
+    func `amount parser handles missing biz_data gracefully`() throws {
+        let json = """
+        {
+          "code": 0,
+          "msg": "",
+          "data": null
+        }
+        """
+        let payload = try DeepSeekUsageCostParser.decodeAmountPayload(data: Data(json.utf8))
+        #expect(payload.code == 0)
+        #expect(payload.data?.bizData?.total == nil)
+        #expect(payload.data?.bizData?.days == nil)
+    }
+
+    // MARK: - Cost Parser Tests
+
+    @Test
+    func `cost parser decodes total, days, and currency`() throws {
+        let json = """
+        {
+          "code": 0,
+          "msg": "",
+          "data": {
+            "biz_code": 0,
+            "biz_msg": "",
+            "biz_data": [
+              {
+                "total": [
+                  {
+                    "model": "deepseek-v4-flash",
+                    "usage": [
+                      {"type": "PROMPT_CACHE_HIT_TOKEN", "amount": "2.0137344000000000"},
+                      {"type": "PROMPT_CACHE_MISS_TOKEN", "amount": "1.3054320000000000"},
+                      {"type": "RESPONSE_TOKEN", "amount": "1.3126760000000000"},
+                      {"type": "REQUEST", "amount": "0"}
+                    ]
+                  }
+                ],
+                "days": [
+                  {
+                    "date": "2026-05-26",
+                    "data": [
+                      {
+                        "model": "deepseek-v4-flash",
+                        "usage": [
+                          {"type": "PROMPT_CACHE_HIT_TOKEN", "amount": "2.0137344000000000"},
+                          {"type": "PROMPT_CACHE_MISS_TOKEN", "amount": "1.3054320000000000"},
+                          {"type": "RESPONSE_TOKEN", "amount": "1.3126760000000000"},
+                          {"type": "REQUEST", "amount": "0"}
+                        ]
+                      }
+                    ]
+                  }
+                ],
+                "currency": "CNY"
+              }
+            ]
+          }
+        }
+        """
+        let payload = try DeepSeekUsageCostParser.decodeCostPayload(data: Data(json.utf8))
+        #expect(payload.code == 0)
+        #expect(payload.data?.bizCode == 0)
+        #expect(payload.data?.bizData?[0].currency == "CNY")
+        #expect(payload.data?.bizData?[0].total?.count == 1)
+        #expect(payload.data?.bizData?[0].days?.count == 1)
+        #expect(payload.data?.bizData?[0].days?[0].date == "2026-05-26")
+    }
+
+    @Test
+    func `cost parser handles empty biz_data`() throws {
+        let json = """
+        {
+          "code": 0,
+          "msg": "",
+          "data": {
+            "biz_code": 0,
+            "biz_msg": "",
+            "biz_data": []
+          }
+        }
+        """
+        let payload = try DeepSeekUsageCostParser.decodeCostPayload(data: Data(json.utf8))
+        #expect(payload.code == 0)
+        #expect(payload.data?.bizData?.isEmpty == true)
+    }
+
+    // MARK: - String Parsing Tests
+
+    @Test
+    func `string token parsing works`() throws {
+        let json = """
+        {
+          "code": 0,
+          "msg": "",
+          "data": {
+            "biz_code": 0,
+            "biz_msg": "",
+            "biz_data": {
+              "total": [
+                {
+                  "model": "deepseek-v4-flash",
+                  "usage": [
+                    {"type": "PROMPT_CACHE_HIT_TOKEN", "amount": "100686720"},
+                    {"type": "RESPONSE_TOKEN", "amount": "656338"}
+                  ]
+                }
+              ],
+              "days": []
+            }
+          }
+        }
+        """
+        let payload = try DeepSeekUsageCostParser.decodeAmountPayload(data: Data(json.utf8))
+        #expect(payload.data?.bizData?.total?[0].usage?[0].type == "PROMPT_CACHE_HIT_TOKEN")
+        #expect(payload.data?.bizData?.total?[0].usage?[0].amount == "100686720")
+    }
+
+    @Test
+    func `decimal cost parsing works`() throws {
+        let json = """
+        {
+          "code": 0,
+          "msg": "",
+          "data": {
+            "biz_code": 0,
+            "biz_msg": "",
+            "biz_data": [
+              {
+                "total": [
+                  {
+                    "model": "deepseek-v4-flash",
+                    "usage": [
+                      {"type": "PROMPT_CACHE_HIT_TOKEN", "amount": "2.0137344000000000"}
+                    ]
+                  }
+                ],
+                "days": [],
+                "currency": "CNY"
+              }
+            ]
+          }
+        }
+        """
+        let payload = try DeepSeekUsageCostParser.decodeCostPayload(data: Data(json.utf8))
+        #expect(payload.data?.bizData?[0].total?[0].usage?[0].amount == "2.0137344000000000")
+    }
+
+    // MARK: - Aggregation Tests
+
+    @Test
+    func `aggregation computes today token totals`() throws {
+        let amountJSON = """
+        {
+          "code": 0,
+          "msg": "",
+          "data": {
+            "biz_code": 0,
+            "biz_msg": "",
+            "biz_data": {
+              "total": [
+                {
+                  "model": "deepseek-v4-flash",
+                  "usage": [
+                    {"type": "PROMPT_CACHE_HIT_TOKEN", "amount": "100686720"},
+                    {"type": "PROMPT_CACHE_MISS_TOKEN", "amount": "1305432"},
+                    {"type": "RESPONSE_TOKEN", "amount": "656338"},
+                    {"type": "REQUEST", "amount": "1212"}
+                  ]
+                }
+              ],
+              "days": [
+                {
+                  "date": "2026-05-26",
+                  "data": [
+                    {
+                      "model": "deepseek-v4-flash",
+                      "usage": [
+                        {"type": "PROMPT_CACHE_HIT_TOKEN", "amount": "100686720"},
+                        {"type": "PROMPT_CACHE_MISS_TOKEN", "amount": "1305432"},
+                        {"type": "RESPONSE_TOKEN", "amount": "656338"},
+                        {"type": "REQUEST", "amount": "1212"}
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          }
+        }
+        """
+
+        let costJSON = """
+        {
+          "code": 0,
+          "msg": "",
+          "data": {
+            "biz_code": 0,
+            "biz_msg": "",
+            "biz_data": [
+              {
+                "total": [
+                  {
+                    "model": "deepseek-v4-flash",
+                    "usage": [
+                      {"type": "PROMPT_CACHE_HIT_TOKEN", "amount": "2.0137344000000000"},
+                      {"type": "PROMPT_CACHE_MISS_TOKEN", "amount": "1.3054320000000000"},
+                      {"type": "RESPONSE_TOKEN", "amount": "1.3126760000000000"},
+                      {"type": "REQUEST", "amount": "0"}
+                    ]
+                  }
+                ],
+                "days": [
+                  {
+                    "date": "2026-05-26",
+                    "data": [
+                      {
+                        "model": "deepseek-v4-flash",
+                        "usage": [
+                          {"type": "PROMPT_CACHE_HIT_TOKEN", "amount": "2.0137344000000000"},
+                          {"type": "PROMPT_CACHE_MISS_TOKEN", "amount": "1.3054320000000000"},
+                          {"type": "RESPONSE_TOKEN", "amount": "1.3126760000000000"},
+                          {"type": "REQUEST", "amount": "0"}
+                        ]
+                      }
+                    ]
+                  }
+                ],
+                "currency": "CNY"
+              }
+            ]
+          }
+        }
+        """
+
+        let summary = try DeepSeekUsageFetcher._parseUsageSummaryForTesting(
+            amountData: Data(amountJSON.utf8),
+            costData: Data(costJSON.utf8),
+            now: self.fixtureNow,
+            calendar: self.fixtureCalendar)
+
+        // Today is 2026-05-26 per the test data
+        #expect(summary.todayTokens == 102_648_490) // 100_686_720 + 1_305_432 + 656_338
+        #expect(summary.requestCount == 1212)
+        #expect(summary.currency == "CNY")
+    }
+
+    @Test
+    func `aggregation uses injected now and calendar for today bucket`() throws {
+        let amountJSON = """
+        {
+          "code": 0,
+          "msg": "",
+          "data": {
+            "biz_code": 0,
+            "biz_msg": "",
+            "biz_data": {
+              "total": [
+                {
+                  "model": "deepseek-v4-flash",
+                  "usage": [
+                    {"type": "PROMPT_CACHE_HIT_TOKEN", "amount": "100"},
+                    {"type": "REQUEST", "amount": "1"}
+                  ]
+                }
+              ],
+              "days": [
+                {
+                  "date": "2026-05-26",
+                  "data": [
+                    {
+                      "model": "deepseek-v4-flash",
+                      "usage": [
+                        {"type": "PROMPT_CACHE_HIT_TOKEN", "amount": "100"},
+                        {"type": "REQUEST", "amount": "1"}
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          }
+        }
+        """
+        let costJSON = """
+        {
+          "code": 0,
+          "msg": "",
+          "data": {
+            "biz_code": 0,
+            "biz_msg": "",
+            "biz_data": [
+              {
+                "total": [],
+                "days": [],
+                "currency": "CNY"
+              }
+            ]
+          }
+        }
+        """
+
+        var nextMonthUTC = Calendar(identifier: .gregorian)
+        nextMonthUTC.timeZone = TimeZone(identifier: "UTC") ?? .current
+        let injectedNow = try #require(nextMonthUTC.date(from: DateComponents(year: 2026, month: 6, day: 1, hour: 12)))
+
+        let summary = try DeepSeekUsageFetcher._parseUsageSummaryForTesting(
+            amountData: Data(amountJSON.utf8),
+            costData: Data(costJSON.utf8),
+            now: injectedNow,
+            calendar: nextMonthUTC)
+
+        #expect(summary.todayTokens == 0)
+        #expect(summary.currentMonthTokens == 0)
+    }
+
+    @Test
+    func `aggregation computes today cost totals`() throws {
+        let amountJSON = """
+        {
+          "code": 0,
+          "msg": "",
+          "data": {
+            "biz_code": 0,
+            "biz_msg": "",
+            "biz_data": {
+              "total": [
+                {
+                  "model": "deepseek-v4-flash",
+                  "usage": [
+                    {"type": "PROMPT_CACHE_HIT_TOKEN", "amount": "100686720"},
+                    {"type": "RESPONSE_TOKEN", "amount": "656338"}
+                  ]
+                }
+              ],
+              "days": [
+                {
+                  "date": "2026-05-26",
+                  "data": [
+                    {
+                      "model": "deepseek-v4-flash",
+                      "usage": [
+                        {"type": "PROMPT_CACHE_HIT_TOKEN", "amount": "100686720"},
+                        {"type": "RESPONSE_TOKEN", "amount": "656338"}
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          }
+        }
+        """
+
+        let costJSON = """
+        {
+          "code": 0,
+          "msg": "",
+          "data": {
+            "biz_code": 0,
+            "biz_msg": "",
+            "biz_data": [
+              {
+                "total": [
+                  {
+                    "model": "deepseek-v4-flash",
+                    "usage": [
+                      {"type": "PROMPT_CACHE_HIT_TOKEN", "amount": "2.0137344000000000"},
+                      {"type": "RESPONSE_TOKEN", "amount": "1.3126760000000000"}
+                    ]
+                  }
+                ],
+                "days": [
+                  {
+                    "date": "2026-05-26",
+                    "data": [
+                      {
+                        "model": "deepseek-v4-flash",
+                        "usage": [
+                          {"type": "PROMPT_CACHE_HIT_TOKEN", "amount": "2.0137344000000000"},
+                          {"type": "RESPONSE_TOKEN", "amount": "1.3126760000000000"}
+                        ]
+                      }
+                    ]
+                  }
+                ],
+                "currency": "CNY"
+              }
+            ]
+          }
+        }
+        """
+
+        let summary = try DeepSeekUsageFetcher._parseUsageSummaryForTesting(
+            amountData: Data(amountJSON.utf8),
+            costData: Data(costJSON.utf8),
+            now: self.fixtureNow,
+            calendar: self.fixtureCalendar)
+
+        #expect(abs((summary.todayCost ?? 0) - 3.3264104) < 0.0001)
+        #expect(summary.currentMonthCost != nil)
+    }
+
+    @Test
+    func `aggregation computes model and category breakdown`() throws {
+        let amountJSON = """
+        {
+          "code": 0,
+          "msg": "",
+          "data": {
+            "biz_code": 0,
+            "biz_msg": "",
+            "biz_data": {
+              "total": [
+                {
+                  "model": "deepseek-v4-flash",
+                  "usage": [
+                    {"type": "PROMPT_CACHE_HIT_TOKEN", "amount": "100686720"},
+                    {"type": "PROMPT_CACHE_MISS_TOKEN", "amount": "1305432"},
+                    {"type": "RESPONSE_TOKEN", "amount": "656338"}
+                  ]
+                }
+              ],
+              "days": []
+            }
+          }
+        }
+        """
+
+        let costJSON = """
+        {
+          "code": 0,
+          "msg": "",
+          "data": {
+            "biz_code": 0,
+            "biz_msg": "",
+            "biz_data": [
+              {
+                "total": [
+                  {
+                    "model": "deepseek-v4-flash",
+                    "usage": [
+                      {"type": "PROMPT_CACHE_HIT_TOKEN", "amount": "2.0137344000000000"},
+                      {"type": "PROMPT_CACHE_MISS_TOKEN", "amount": "1.3054320000000000"},
+                      {"type": "RESPONSE_TOKEN", "amount": "1.3126760000000000"}
+                    ]
+                  }
+                ],
+                "days": [],
+                "currency": "CNY"
+              }
+            ]
+          }
+        }
+        """
+
+        let summary = try DeepSeekUsageFetcher._parseUsageSummaryForTesting(
+            amountData: Data(amountJSON.utf8),
+            costData: Data(costJSON.utf8),
+            now: self.fixtureNow,
+            calendar: self.fixtureCalendar)
+
+        #expect(summary.topModel == "deepseek-v4-flash")
+        #expect(summary.categoryBreakdown.count == 3)
+
+        let cacheHit = summary.categoryBreakdown.first { $0.category == DeepSeekUsageCategory.promptCacheHitToken }
+        #expect(cacheHit?.tokens == 100_686_720)
+        #expect(abs((cacheHit?.cost ?? 0) - 2.0137344) < 0.0001)
+
+        let cacheMiss = summary.categoryBreakdown.first { $0.category == DeepSeekUsageCategory.promptCacheMissToken }
+        #expect(cacheMiss?.tokens == 1_305_432)
+        #expect(abs((cacheMiss?.cost ?? 0) - 1.305432) < 0.0001)
+
+        let response = summary.categoryBreakdown.first { $0.category == DeepSeekUsageCategory.responseToken }
+        #expect(response?.tokens == 656_338)
+        #expect(abs((response?.cost ?? 0) - 1.312676) < 0.0001)
+    }
+
+    // MARK: - Unknown Types Handling
+
+    @Test
+    func `unknown usage types are ignored safely`() throws {
+        let amountJSON = """
+        {
+          "code": 0,
+          "msg": "",
+          "data": {
+            "biz_code": 0,
+            "biz_msg": "",
+            "biz_data": {
+              "total": [
+                {
+                  "model": "deepseek-v4-flash",
+                  "usage": [
+                    {"type": "PROMPT_CACHE_HIT_TOKEN", "amount": "100"},
+                    {"type": "UNKNOWN_TYPE", "amount": "999"},
+                    {"type": "RESPONSE_TOKEN", "amount": "200"}
+                  ]
+                }
+              ],
+              "days": []
+            }
+          }
+        }
+        """
+
+        let costJSON = """
+        {
+          "code": 0,
+          "msg": "",
+          "data": {
+            "biz_code": 0,
+            "biz_msg": "",
+            "biz_data": [
+              {
+                "total": [
+                  {
+                    "model": "deepseek-v4-flash",
+                    "usage": [
+                      {"type": "PROMPT_CACHE_HIT_TOKEN", "amount": "1.0"},
+                      {"type": "UNKNOWN_TYPE", "amount": "99.0"},
+                      {"type": "RESPONSE_TOKEN", "amount": "2.0"}
+                    ]
+                  }
+                ],
+                "days": [],
+                "currency": "CNY"
+              }
+            ]
+          }
+        }
+        """
+
+        let summary = try DeepSeekUsageFetcher._parseUsageSummaryForTesting(
+            amountData: Data(amountJSON.utf8),
+            costData: Data(costJSON.utf8),
+            now: self.fixtureNow,
+            calendar: self.fixtureCalendar)
+
+        // Unknown type should be ignored - only known categories with non-zero tokens appear in breakdown
+        // todayTokens comes from daily data which is empty in this test, so it's 0
+        #expect(summary.todayTokens == 0)
+        #expect(summary.categoryBreakdown.count == 3) // Always 3 categories, even if some have 0 tokens
+    }
+
+    // MARK: - Error Handling
+
+    @Test
+    func `missing fields fails closed`() {
+        let amountJSON = """
+        {
+          "code": 0,
+          "msg": "",
+          "data": null
+        }
+        """
+
+        let costJSON = """
+        {
+          "code": 0,
+          "msg": "",
+          "data": {
+            "biz_code": 0,
+            "biz_msg": "",
+            "biz_data": [
+              {
+                "total": [],
+                "days": [],
+                "currency": "CNY"
+              }
+            ]
+          }
+        }
+        """
+
+        #expect {
+            _ = try DeepSeekUsageFetcher._parseUsageSummaryForTesting(
+                amountData: Data(amountJSON.utf8),
+                costData: Data(costJSON.utf8),
+                now: fixtureNow,
+                calendar: fixtureCalendar)
+        } throws: { error in
+            guard case DeepSeekUsageError.parseFailed = error else { return false }
+            return true
+        }
+    }
+
+    @Test
+    func `non-zero biz_code fails closed`() {
+        let amountJSON = """
+        {
+          "code": 0,
+          "msg": "",
+          "data": {
+            "biz_code": 1001,
+            "biz_msg": "some error",
+            "biz_data": {
+              "total": [],
+              "days": []
+            }
+          }
+        }
+        """
+
+        let costJSON = """
+        {
+          "code": 0,
+          "msg": "",
+          "data": {
+            "biz_code": 0,
+            "biz_msg": "",
+            "biz_data": [
+              {
+                "total": [],
+                "days": [],
+                "currency": "CNY"
+              }
+            ]
+          }
+        }
+        """
+
+        #expect {
+            _ = try DeepSeekUsageFetcher._parseUsageSummaryForTesting(
+                amountData: Data(amountJSON.utf8),
+                costData: Data(costJSON.utf8))
+        } throws: { error in
+            guard case DeepSeekUsageError.apiError = error else { return false }
+            return true
+        }
+    }
+
+    @Test
+    func `invalid JSON fails closed`() {
+        #expect {
+            _ = try DeepSeekUsageFetcher._parseUsageSummaryForTesting(
+                amountData: Data("not json".utf8),
+                costData: Data("{}".utf8))
+        } throws: { error in
+            guard case DeepSeekUsageError.parseFailed = error else { return false }
+            return true
+        }
+    }
+
+    // MARK: - Edge Cases
+
+    @Test
+    func `empty days array works`() throws {
+        let amountJSON = """
+        {
+          "code": 0,
+          "msg": "",
+          "data": {
+            "biz_code": 0,
+            "biz_msg": "",
+            "biz_data": {
+              "total": [],
+              "days": []
+            }
+          }
+        }
+        """
+
+        let costJSON = """
+        {
+          "code": 0,
+          "msg": "",
+          "data": {
+            "biz_code": 0,
+            "biz_msg": "",
+            "biz_data": [
+              {
+                "total": [],
+                "days": [],
+                "currency": "CNY"
+              }
+            ]
+          }
+        }
+        """
+
+        let summary = try DeepSeekUsageFetcher._parseUsageSummaryForTesting(
+            amountData: Data(amountJSON.utf8),
+            costData: Data(costJSON.utf8),
+            now: self.fixtureNow,
+            calendar: self.fixtureCalendar)
+
+        #expect(summary.todayTokens == 0)
+        #expect(summary.currentMonthTokens == 0)
+        #expect(summary.todayCost == nil)
+        #expect(summary.currentMonthCost == nil)
+        #expect(summary.daily.isEmpty)
+    }
+
+    @Test
+    func `multiple models works`() throws {
+        let amountJSON = """
+        {
+          "code": 0,
+          "msg": "",
+          "data": {
+            "biz_code": 0,
+            "biz_msg": "",
+            "biz_data": {
+              "total": [
+                {
+                  "model": "deepseek-v4-flash",
+                  "usage": [
+                    {"type": "PROMPT_CACHE_HIT_TOKEN", "amount": "100"},
+                    {"type": "RESPONSE_TOKEN", "amount": "50"}
+                  ]
+                },
+                {
+                  "model": "deepseek-chat",
+                  "usage": [
+                    {"type": "PROMPT_CACHE_HIT_TOKEN", "amount": "200"},
+                    {"type": "RESPONSE_TOKEN", "amount": "100"}
+                  ]
+                }
+              ],
+              "days": [
+                {
+                  "date": "2026-05-26",
+                  "data": [
+                    {
+                      "model": "deepseek-v4-flash",
+                      "usage": [
+                        {"type": "PROMPT_CACHE_HIT_TOKEN", "amount": "100"},
+                        {"type": "RESPONSE_TOKEN", "amount": "50"}
+                      ]
+                    },
+                    {
+                      "model": "deepseek-chat",
+                      "usage": [
+                        {"type": "PROMPT_CACHE_HIT_TOKEN", "amount": "200"},
+                        {"type": "RESPONSE_TOKEN", "amount": "100"}
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          }
+        }
+        """
+
+        let costJSON = """
+        {
+          "code": 0,
+          "msg": "",
+          "data": {
+            "biz_code": 0,
+            "biz_msg": "",
+            "biz_data": [
+              {
+                "total": [
+                  {
+                    "model": "deepseek-v4-flash",
+                    "usage": [
+                      {"type": "PROMPT_CACHE_HIT_TOKEN", "amount": "1.0"},
+                      {"type": "RESPONSE_TOKEN", "amount": "0.5"}
+                    ]
+                  },
+                  {
+                    "model": "deepseek-chat",
+                    "usage": [
+                      {"type": "PROMPT_CACHE_HIT_TOKEN", "amount": "2.0"},
+                      {"type": "RESPONSE_TOKEN", "amount": "1.0"}
+                    ]
+                  }
+                ],
+                "days": [],
+                "currency": "CNY"
+              }
+            ]
+          }
+        }
+        """
+
+        let summary = try DeepSeekUsageFetcher._parseUsageSummaryForTesting(
+            amountData: Data(amountJSON.utf8),
+            costData: Data(costJSON.utf8),
+            now: self.fixtureNow,
+            calendar: self.fixtureCalendar)
+
+        #expect(summary.topModel == "deepseek-chat") // 300 tokens vs 150 tokens
+        #expect(summary.todayTokens == 450) // 150 + 300
+    }
+}
diff --git a/Tests/CodexBarTests/DeepSeekUsageFetcherTests.swift b/Tests/CodexBarTests/DeepSeekUsageFetcherTests.swift
new file mode 100644
index 0000000000..5ebb3abbf4
--- /dev/null
+++ b/Tests/CodexBarTests/DeepSeekUsageFetcherTests.swift
@@ -0,0 +1,614 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct DeepSeekUsageFetcherTests {
+    private struct TimeoutError: Error {}
+
+    private actor SummaryCancellationProbe {
+        private var started = false
+        private var cancelled = false
+        private var startedWaiters: [CheckedContinuation<Void, Never>] = []
+        private var cancelledWaiters: [CheckedContinuation<Void, Never>] = []
+
+        func markStarted() {
+            self.started = true
+            for waiter in self.startedWaiters {
+                waiter.resume()
+            }
+            self.startedWaiters.removeAll()
+        }
+
+        func waitUntilStarted() async {
+            if self.started { return }
+            await withCheckedContinuation { continuation in
+                self.startedWaiters.append(continuation)
+            }
+        }
+
+        func markCancelled() {
+            self.cancelled = true
+            for waiter in self.cancelledWaiters {
+                waiter.resume()
+            }
+            self.cancelledWaiters.removeAll()
+        }
+
+        func waitUntilCancelled() async {
+            if self.cancelled { return }
+            await withCheckedContinuation { continuation in
+                self.cancelledWaiters.append(continuation)
+            }
+        }
+
+        func wasCancelled() -> Bool {
+            self.cancelled
+        }
+    }
+
+    private static func withTimeout<T: Sendable>(
+        _ timeout: Duration,
+        operation: @escaping @Sendable () async throws -> T) async throws -> T
+    {
+        try await withThrowingTaskGroup(of: T.self) { group in
+            group.addTask {
+                try await operation()
+            }
+            group.addTask {
+                try await Task.sleep(for: timeout)
+                throw TimeoutError()
+            }
+
+            let result = try await group.next()
+            group.cancelAll()
+            guard let result else { throw TimeoutError() }
+            return result
+        }
+    }
+
+    private static func waitForCancellation(_ probe: SummaryCancellationProbe) async -> Bool {
+        for _ in 0..<100 {
+            if await probe.wasCancelled() { return true }
+            try? await Task.sleep(for: .milliseconds(20))
+        }
+        return await probe.wasCancelled()
+    }
+
+    private static let sampleBalanceJSON = """
+    {
+      "is_available": true,
+      "balance_infos": [
+        {
+          "currency": "USD",
+          "total_balance": "50.00",
+          "granted_balance": "10.00",
+          "topped_up_balance": "40.00"
+        }
+      ]
+    }
+    """
+
+    private static func sampleSummary(updatedAt: Date = Date()) -> DeepSeekUsageSummary {
+        DeepSeekUsageSummary(
+            todayTokens: 123,
+            currentMonthTokens: 456,
+            todayCost: 1.23,
+            currentMonthCost: 4.56,
+            requestCount: 7,
+            currentMonthRequestCount: 8,
+            topModel: "deepseek-v4-flash",
+            categoryBreakdown: [
+                DeepSeekCategoryBreakdown(category: .promptCacheHitToken, tokens: 123, cost: 1.23),
+            ],
+            daily: [],
+            currency: "USD",
+            updatedAt: updatedAt)
+    }
+
+    @Test
+    func `parses USD balance response`() throws {
+        let json = """
+        {
+          "is_available": true,
+          "balance_infos": [
+            {
+              "currency": "USD",
+              "total_balance": "50.00",
+              "granted_balance": "10.00",
+              "topped_up_balance": "40.00"
+            }
+          ]
+        }
+        """
+        let snapshot = try DeepSeekUsageFetcher._parseSnapshotForTesting(Data(json.utf8))
+        #expect(snapshot.isAvailable == true)
+        #expect(snapshot.currency == "USD")
+        #expect(snapshot.totalBalance == 50.0)
+        #expect(snapshot.grantedBalance == 10.0)
+        #expect(snapshot.toppedUpBalance == 40.0)
+    }
+
+    @Test
+    func `parses CNY balance response`() throws {
+        let json = """
+        {
+          "is_available": true,
+          "balance_infos": [
+            {
+              "currency": "CNY",
+              "total_balance": "110.00",
+              "granted_balance": "10.00",
+              "topped_up_balance": "100.00"
+            }
+          ]
+        }
+        """
+        let snapshot = try DeepSeekUsageFetcher._parseSnapshotForTesting(Data(json.utf8))
+        #expect(snapshot.currency == "CNY")
+        #expect(snapshot.totalBalance == 110.0)
+        #expect(snapshot.toppedUpBalance == 100.0)
+    }
+
+    @Test
+    func `prefers USD when both currencies present`() throws {
+        let json = """
+        {
+          "is_available": true,
+          "balance_infos": [
+            {
+              "currency": "CNY",
+              "total_balance": "100.00",
+              "granted_balance": "0.00",
+              "topped_up_balance": "100.00"
+            },
+            {
+              "currency": "USD",
+              "total_balance": "20.00",
+              "granted_balance": "5.00",
+              "topped_up_balance": "15.00"
+            }
+          ]
+        }
+        """
+        let snapshot = try DeepSeekUsageFetcher._parseSnapshotForTesting(Data(json.utf8))
+        #expect(snapshot.currency == "USD")
+        #expect(snapshot.totalBalance == 20.0)
+    }
+
+    @Test
+    func `prefers positive CNY balance over empty USD balance`() throws {
+        let json = """
+        {
+          "is_available": true,
+          "balance_infos": [
+            {
+              "currency": "USD",
+              "total_balance": "0.00",
+              "granted_balance": "0.00",
+              "topped_up_balance": "0.00"
+            },
+            {
+              "currency": "CNY",
+              "total_balance": "100.00",
+              "granted_balance": "0.00",
+              "topped_up_balance": "100.00"
+            }
+          ]
+        }
+        """
+        let snapshot = try DeepSeekUsageFetcher._parseSnapshotForTesting(Data(json.utf8))
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(snapshot.currency == "CNY")
+        #expect(snapshot.totalBalance == 100.0)
+        #expect(usage.primary?.resetDescription?.contains("¥100.00") == true)
+    }
+
+    @Test
+    func `zero balance prompts top up even when unavailable`() throws {
+        let json = """
+        {
+          "is_available": false,
+          "balance_infos": [
+            {
+              "currency": "USD",
+              "total_balance": "0.00",
+              "granted_balance": "0.00",
+              "topped_up_balance": "0.00"
+            }
+          ]
+        }
+        """
+        let snapshot = try DeepSeekUsageFetcher._parseSnapshotForTesting(Data(json.utf8))
+        #expect(snapshot.isAvailable == false)
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary?.usedPercent == 100)
+        #expect(usage.primary?.resetDescription == "$0.00 — add credits at platform.deepseek.com")
+        #expect(usage.identity?.loginMethod == nil)
+    }
+
+    @Test
+    func `full bar when balance available`() throws {
+        let json = """
+        {
+          "is_available": true,
+          "balance_infos": [
+            {
+              "currency": "USD",
+              "total_balance": "5.00",
+              "granted_balance": "0.00",
+              "topped_up_balance": "5.00"
+            }
+          ]
+        }
+        """
+        let snapshot = try DeepSeekUsageFetcher._parseSnapshotForTesting(Data(json.utf8))
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary?.usedPercent == 0)
+        #expect(usage.primary?.resetDescription?.contains("$5.00") == true)
+        #expect(usage.identity?.loginMethod == nil)
+    }
+
+    @Test
+    func `throws on malformed balance string`() {
+        let json = """
+        {
+          "is_available": true,
+          "balance_infos": [
+            {
+              "currency": "USD",
+              "total_balance": "not-a-number",
+              "granted_balance": "0.00",
+              "topped_up_balance": "0.00"
+            }
+          ]
+        }
+        """
+        #expect {
+            _ = try DeepSeekUsageFetcher._parseSnapshotForTesting(Data(json.utf8))
+        } throws: { error in
+            guard case DeepSeekUsageError.parseFailed = error else { return false }
+            return true
+        }
+    }
+
+    @Test
+    func `empty balance_infos returns unavailable snapshot`() throws {
+        let json = """
+        {
+          "is_available": true,
+          "balance_infos": []
+        }
+        """
+        let snapshot = try DeepSeekUsageFetcher._parseSnapshotForTesting(Data(json.utf8))
+        #expect(snapshot.isAvailable == false)
+        #expect(snapshot.totalBalance == 0.0)
+    }
+
+    @Test
+    func `throws on invalid JSON root`() {
+        let json = "[{ \"is_available\": true }]"
+        #expect {
+            _ = try DeepSeekUsageFetcher._parseSnapshotForTesting(Data(json.utf8))
+        } throws: { error in
+            guard case DeepSeekUsageError.parseFailed = error else { return false }
+            return true
+        }
+    }
+
+    @Test
+    func `balance description includes paid and granted breakdown`() throws {
+        let json = """
+        {
+          "is_available": true,
+          "balance_infos": [
+            {
+              "currency": "USD",
+              "total_balance": "50.00",
+              "granted_balance": "10.00",
+              "topped_up_balance": "40.00"
+            }
+          ]
+        }
+        """
+        let snapshot = try DeepSeekUsageFetcher._parseSnapshotForTesting(Data(json.utf8))
+        let usage = snapshot.toUsageSnapshot()
+        let detail = usage.primary?.resetDescription ?? ""
+        #expect(detail.contains("$50.00"))
+        #expect(detail.contains("$40.00"))
+        #expect(detail.contains("$10.00"))
+    }
+
+    @Test
+    func `CNY balance uses yen symbol`() throws {
+        let json = """
+        {
+          "is_available": true,
+          "balance_infos": [
+            {
+              "currency": "CNY",
+              "total_balance": "100.00",
+              "granted_balance": "0.00",
+              "topped_up_balance": "100.00"
+            }
+          ]
+        }
+        """
+        let snapshot = try DeepSeekUsageFetcher._parseSnapshotForTesting(Data(json.utf8))
+        let usage = snapshot.toUsageSnapshot()
+        let detail = usage.primary?.resetDescription ?? ""
+        #expect(detail.contains("¥"))
+    }
+
+    @Test
+    func `balance snapshot has nil usage summary`() throws {
+        let json = """
+        {
+          "is_available": true,
+          "balance_infos": [
+            {
+              "currency": "USD",
+              "total_balance": "50.00",
+              "granted_balance": "10.00",
+              "topped_up_balance": "40.00"
+            }
+          ]
+        }
+        """
+        let snapshot = try DeepSeekUsageFetcher._parseSnapshotForTesting(Data(json.utf8))
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.deepseekUsage == nil)
+    }
+
+    @Test
+    func `balance returns promptly when optional usage summary is slow`() async throws {
+        let probe = SummaryCancellationProbe()
+        let snapshot = try await Self.withTimeout(.seconds(10)) {
+            try await DeepSeekUsageFetcher._fetchUsageForTesting(
+                apiKey: "test-key",
+                includeOptionalUsage: true,
+                optionalSummaryJoinGrace: .milliseconds(50),
+                fetchBalanceData: { _ in
+                    Data(Self.sampleBalanceJSON.utf8)
+                },
+                fetchSummary: { _ in
+                    await probe.markStarted()
+                    do {
+                        try await Task.sleep(for: .seconds(60))
+                        return Self.sampleSummary()
+                    } catch is CancellationError {
+                        await probe.markCancelled()
+                        throw CancellationError()
+                    }
+                })
+        }
+
+        #expect(snapshot.totalBalance == 50.0)
+        #expect(snapshot.usageSummary == nil)
+        #expect(await Self.waitForCancellation(probe))
+    }
+
+    @Test
+    func `balance grace does not wait for optional summary that ignores cancellation`() async throws {
+        let startedAt = ContinuousClock.now
+        let snapshot = try await DeepSeekUsageFetcher._fetchUsageForTesting(
+            apiKey: "test-key",
+            includeOptionalUsage: true,
+            optionalSummaryJoinGrace: .milliseconds(20),
+            fetchBalanceData: { _ in
+                Data(Self.sampleBalanceJSON.utf8)
+            },
+            fetchSummary: { _ in
+                await withCheckedContinuation { continuation in
+                    DispatchQueue.global().asyncAfter(deadline: .now() + 0.5) {
+                        continuation.resume(returning: Self.sampleSummary())
+                    }
+                }
+            })
+        let elapsed = startedAt.duration(to: .now)
+
+        #expect(snapshot.totalBalance == 50.0)
+        #expect(snapshot.usageSummary == nil)
+        #expect(elapsed < .milliseconds(300), "Optional summary delayed balance: \(elapsed)")
+
+        // Let the deliberately cancellation-ignoring test task drain before the test exits.
+        try await Task.sleep(for: .milliseconds(550))
+    }
+
+    @Test
+    func `balance returns when optional usage summary fails closed`() async throws {
+        let snapshot = try await DeepSeekUsageFetcher._fetchUsageForTesting(
+            apiKey: "test-key",
+            includeOptionalUsage: true,
+            optionalSummaryJoinGrace: .seconds(2),
+            fetchBalanceData: { _ in
+                Data(Self.sampleBalanceJSON.utf8)
+            },
+            fetchSummary: { _ in
+                throw DeepSeekUsageError.networkError("simulated failure")
+            })
+
+        #expect(snapshot.totalBalance == 50.0)
+        #expect(snapshot.usageSummary == nil)
+    }
+
+    @Test
+    func `cancels optional usage summary when balance fetch fails`() async throws {
+        let probe = SummaryCancellationProbe()
+
+        do {
+            _ = try await DeepSeekUsageFetcher._fetchUsageForTesting(
+                apiKey: "test-key",
+                includeOptionalUsage: true,
+                optionalSummaryJoinGrace: .seconds(2),
+                fetchBalanceData: { _ in
+                    await probe.waitUntilStarted()
+                    throw DeepSeekUsageError.networkError("simulated balance failure")
+                },
+                fetchSummary: { _ in
+                    await probe.markStarted()
+                    do {
+                        try await Task.sleep(for: .seconds(1))
+                        return Self.sampleSummary()
+                    } catch is CancellationError {
+                        await probe.markCancelled()
+                        throw DeepSeekUsageError.networkError("cancelled")
+                    }
+                })
+            Issue.record("Expected balance failure")
+        } catch DeepSeekUsageError.networkError {
+            #expect(await Self.waitForCancellation(probe))
+        }
+    }
+
+    @Test
+    func `cancels optional usage summary when balance parsing fails`() async throws {
+        let probe = SummaryCancellationProbe()
+
+        do {
+            _ = try await DeepSeekUsageFetcher._fetchUsageForTesting(
+                apiKey: "test-key",
+                includeOptionalUsage: true,
+                optionalSummaryJoinGrace: .seconds(2),
+                fetchBalanceData: { _ in
+                    await probe.waitUntilStarted()
+                    return Data("{\"is_available\":true,\"balance_infos\":[".utf8)
+                },
+                fetchSummary: { _ in
+                    await probe.markStarted()
+                    do {
+                        try await Task.sleep(for: .seconds(1))
+                        return Self.sampleSummary()
+                    } catch is CancellationError {
+                        await probe.markCancelled()
+                        throw DeepSeekUsageError.networkError("cancelled")
+                    }
+                })
+            Issue.record("Expected balance parse failure")
+        } catch DeepSeekUsageError.parseFailed {
+            #expect(await Self.waitForCancellation(probe))
+        }
+    }
+
+    @Test
+    func `parent cancellation propagates while waiting for optional usage summary`() async throws {
+        let probe = SummaryCancellationProbe()
+        let task = Task {
+            try await DeepSeekUsageFetcher._fetchUsageForTesting(
+                apiKey: "test-key",
+                includeOptionalUsage: true,
+                optionalSummaryJoinGrace: .seconds(30),
+                fetchBalanceData: { _ in
+                    Data(Self.sampleBalanceJSON.utf8)
+                },
+                fetchSummary: { _ in
+                    await probe.markStarted()
+                    do {
+                        try await Task.sleep(for: .seconds(60))
+                        return Self.sampleSummary()
+                    } catch is CancellationError {
+                        await probe.markCancelled()
+                        throw CancellationError()
+                    }
+                })
+        }
+
+        await probe.waitUntilStarted()
+        task.cancel()
+
+        do {
+            _ = try await Self.withTimeout(.seconds(10)) {
+                try await task.value
+            }
+            Issue.record("Expected cancellation")
+        } catch is CancellationError {
+            #expect(await Self.waitForCancellation(probe))
+        }
+    }
+
+    @Test
+    func `parent cancellation stops summary while balance transport ignores cancellation`() async throws {
+        let balanceStarted = AsyncStream<Void>.makeStream(of: Void.self)
+        let probe = SummaryCancellationProbe()
+        let task = Task {
+            try await DeepSeekUsageFetcher._fetchUsageForTesting(
+                apiKey: "test-key",
+                includeOptionalUsage: true,
+                optionalSummaryJoinGrace: .seconds(30),
+                fetchBalanceData: { _ in
+                    balanceStarted.continuation.yield(())
+                    return await withCheckedContinuation { continuation in
+                        DispatchQueue.global().asyncAfter(deadline: .now() + 0.5) {
+                            continuation.resume(returning: Data(Self.sampleBalanceJSON.utf8))
+                        }
+                    }
+                },
+                fetchSummary: { _ in
+                    await probe.markStarted()
+                    do {
+                        try await Task.sleep(for: .seconds(60))
+                        return Self.sampleSummary()
+                    } catch is CancellationError {
+                        await probe.markCancelled()
+                        throw CancellationError()
+                    }
+                })
+        }
+
+        var balanceIterator = balanceStarted.stream.makeAsyncIterator()
+        _ = await balanceIterator.next()
+        await probe.waitUntilStarted()
+        let cancellationStartedAt = ContinuousClock.now
+        task.cancel()
+
+        await probe.waitUntilCancelled()
+        #expect(cancellationStartedAt.duration(to: .now) < .milliseconds(300))
+        await #expect(throws: CancellationError.self) {
+            try await task.value
+        }
+    }
+
+    @Test
+    func `usage period defaults to Gregorian API calendar`() throws {
+        let date = try #require(Self.utcDate(year: 2026, month: 5, day: 26))
+        let period = try DeepSeekUsageFetcher._apiUsagePeriodForTesting(now: date)
+
+        #expect(period.month == 5)
+        #expect(period.year == 2026)
+    }
+
+    @Test
+    func `usage period supports injected test calendar`() throws {
+        var calendar = Calendar(identifier: .buddhist)
+        calendar.timeZone = TimeZone(secondsFromGMT: 0) ?? .gmt
+        let date = try #require(Self.utcDate(year: 2026, month: 5, day: 26))
+        let period = try DeepSeekUsageFetcher._apiUsagePeriodForTesting(now: date, calendar: calendar)
+
+        #expect(period.month == 5)
+        #expect(period.year == 2569)
+    }
+
+    @Test
+    func `production path can populate usage summary when optional fetch succeeds`() async throws {
+        let expected = Self.sampleSummary()
+        let snapshot = try await DeepSeekUsageFetcher._fetchUsageForTesting(
+            apiKey: "test-key",
+            includeOptionalUsage: true,
+            optionalSummaryJoinGrace: .seconds(2),
+            fetchBalanceData: { _ in
+                Data(Self.sampleBalanceJSON.utf8)
+            },
+            fetchSummary: { _ in
+                expected
+            })
+
+        #expect(snapshot.totalBalance == 50.0)
+        #expect(snapshot.usageSummary == expected)
+    }
+
+    private static func utcDate(year: Int, month: Int, day: Int) -> Date? {
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = TimeZone(secondsFromGMT: 0) ?? .gmt
+        return calendar.date(from: DateComponents(year: year, month: month, day: day))
+    }
+}
diff --git a/Tests/CodexBarTests/DeepgramProviderTests.swift b/Tests/CodexBarTests/DeepgramProviderTests.swift
new file mode 100644
index 0000000000..0d818695d6
--- /dev/null
+++ b/Tests/CodexBarTests/DeepgramProviderTests.swift
@@ -0,0 +1,252 @@
+import Foundation
+import SwiftUI
+import Testing
+@testable import CodexBar
+@testable import CodexBarCore
+
+@MainActor
+struct DeepgramProviderTests {
+    @Test
+    func `deepgram field kinds and bindings`() throws {
+        let suite = "DeepgramProviderTests-field-kinds"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings)
+
+        let context = ProviderSettingsContext(
+            provider: .deepgram,
+            settings: settings,
+            store: store,
+            boolBinding: { keyPath in
+                Binding(
+                    get: { settings[keyPath: keyPath] },
+                    set: { settings[keyPath: keyPath] = $0 })
+            },
+            stringBinding: { keyPath in
+                Binding(
+                    get: { settings[keyPath: keyPath] },
+                    set: { settings[keyPath: keyPath] = $0 })
+            },
+            statusText: { _ in nil },
+            setStatusText: { _, _ in },
+            lastAppActiveRunAt: { _ in nil },
+            setLastAppActiveRunAt: { _, _ in },
+            requestConfirmation: { _ in },
+            runLoginFlow: {})
+
+        let implementation = DeepgramProviderImplementation()
+        let fields = implementation.settingsFields(context: context)
+
+        let apiField = try #require(fields.first(where: { $0.id == "deepgram-api-key" }))
+        let projectField = try #require(fields.first(where: { $0.id == "deepgram-project-id" }))
+
+        #expect(apiField.kind == .secure)
+        #expect(projectField.kind == .plain)
+
+        // Verify bindings update the SettingsStore
+        apiField.binding.wrappedValue = "dg_test_token"
+        #expect(settings.deepgramAPIKey == "dg_test_token")
+
+        projectField.binding.wrappedValue = "proj-1234"
+        #expect(settings.deepgramProjectID == "proj-1234")
+    }
+
+    @Test
+    nonisolated func `parses usage breakdown response into visible usage notes`() throws {
+        let body = #"""
+        {
+          "start": "2025-01-16",
+          "end": "2025-01-23",
+          "resolution": {
+            "units": "day",
+            "amount": 1
+          },
+          "results": [
+            {
+              "hours": 1619.7242069444444,
+              "total_hours": 1621.7395791666668,
+              "agent_hours": 41.33564388888889,
+              "tokens_in": 1200,
+              "tokens_out": 340,
+              "tts_characters": 9158866,
+              "requests": 373381,
+              "grouping": {
+                "start": "2025-01-16",
+                "end": "2025-01-16",
+                "endpoint": "listen"
+              }
+            },
+            {
+              "hours": 2.25,
+              "total_hours": 3.5,
+              "requests": 19,
+              "grouping": {
+                "start": "2025-01-17",
+                "end": "2025-01-17",
+                "endpoint": "speak"
+              }
+            }
+          ]
+        }
+        """#
+
+        let updatedAt = Date(timeIntervalSince1970: 123)
+        let snapshot = try DeepgramUsageFetcher._parseSnapshotForTesting(
+            Data(body.utf8),
+            projectID: "project-123",
+            updatedAt: updatedAt)
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(snapshot.requests == 373_400)
+        #expect(snapshot.hours == 1621.9742069444444)
+        #expect(snapshot.totalHours == 1625.2395791666668)
+        #expect(snapshot.agentHours == 41.33564388888889)
+        #expect(snapshot.tokensIn == 1200)
+        #expect(snapshot.tokensOut == 340)
+        #expect(snapshot.ttsCharacters == 9_158_866)
+        #expect(usage.deepgramUsage?.requests == 373_400)
+        #expect(usage.loginMethod(for: .deepgram) == "Project: project-123")
+        #expect(usage.deepgramUsage?.displayLines == [
+            "Requests: 373,400",
+            "1,622.0 audio hours · 1,625.2 billable hours",
+            "41.3 agent hours · 1,540 tokens · 9,158,866 TTS chars",
+            "Period: 2025-01-16 to 2025-01-23",
+        ])
+    }
+
+    @Test
+    nonisolated func `fetch usage calls breakdown endpoint with token auth`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            #expect(url.path == "/v1/projects/project-123/usage/breakdown")
+            let components = URLComponents(url: url, resolvingAgainstBaseURL: false)
+            #expect(components?.queryItems?.contains(URLQueryItem(name: "start", value: "2025-01-16")) == true)
+            #expect(components?.queryItems?.contains(URLQueryItem(name: "end", value: "2025-01-23")) == true)
+            #expect(request.value(forHTTPHeaderField: "Authorization") == "Token dg-test")
+            #expect(request.value(forHTTPHeaderField: "Accept") == "application/json")
+            #expect(request.timeoutInterval == 15)
+
+            let body = #"""
+            {
+              "start": "2025-01-16",
+              "end": "2025-01-23",
+              "resolution": {
+                "units": "day",
+                "amount": 1
+              },
+              "results": [
+                {
+                  "hours": 1.5,
+                  "total_hours": 2,
+                  "requests": 7
+                }
+              ]
+            }
+            """#
+            return Self.makeResponse(url: url, body: body)
+        }
+
+        let usage = try await DeepgramUsageFetcher.fetchUsage(
+            apiKey: " dg-test ",
+            projectID: " project-123 ",
+            query: DeepgramUsageQuery(start: "2025-01-16", end: "2025-01-23"),
+            environment: ["DEEPGRAM_API_URL": "https://deepgram.test/v1"],
+            transport: transport)
+
+        #expect(usage.projectID == "project-123")
+        #expect(usage.requests == 7)
+        #expect(usage.hours == 1.5)
+        #expect(usage.totalHours == 2)
+
+        let requests = await transport.requests()
+        #expect(requests.count == 1)
+    }
+
+    @Test
+    nonisolated func `fetch usage discovers projects when project id is omitted`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            #expect(request.value(forHTTPHeaderField: "Authorization") == "Token dg-test")
+
+            switch url.path {
+            case "/v1/projects":
+                return Self.makeResponse(url: url, body: #"""
+                {
+                  "projects": [
+                    { "project_id": "project-a", "name": "Alpha" },
+                    { "project_id": "project-b", "name": "Beta" }
+                  ]
+                }
+                """#)
+
+            case "/v1/projects/project-a/usage/breakdown":
+                return Self.makeResponse(url: url, body: #"""
+                {
+                  "start": "2025-01-16",
+                  "end": "2025-01-23",
+                  "results": [
+                    { "hours": 1, "total_hours": 2, "requests": 3 }
+                  ]
+                }
+                """#)
+
+            case "/v1/projects/project-b/usage/breakdown":
+                return Self.makeResponse(url: url, body: #"""
+                {
+                  "start": "2025-01-17",
+                  "end": "2025-01-24",
+                  "results": [
+                    { "hours": 4, "total_hours": 5, "requests": 6 }
+                  ]
+                }
+                """#)
+
+            default:
+                throw URLError(.badURL)
+            }
+        }
+
+        let usage = try await DeepgramUsageFetcher.fetchUsage(
+            apiKey: "dg-test",
+            environment: ["DEEPGRAM_API_URL": "https://deepgram.test/v1"],
+            transport: transport)
+
+        #expect(usage.projectID == "all")
+        #expect(usage.projectCount == 2)
+        #expect(usage.requests == 9)
+        #expect(usage.hours == 5)
+        #expect(usage.totalHours == 7)
+        #expect(usage.start == "2025-01-16")
+        #expect(usage.end == "2025-01-24")
+        #expect(usage.toUsageSnapshot().loginMethod(for: .deepgram) == "2 projects")
+
+        let requests = await transport.requests()
+        #expect(requests.map { $0.url?.path } == [
+            "/v1/projects",
+            "/v1/projects/project-a/usage/breakdown",
+            "/v1/projects/project-b/usage/breakdown",
+        ])
+    }
+
+    private nonisolated static func makeResponse(
+        url: URL,
+        body: String,
+        statusCode: Int = 200) -> (Data, URLResponse)
+    {
+        let response = HTTPURLResponse(
+            url: url,
+            statusCode: statusCode,
+            httpVersion: "HTTP/1.1",
+            headerFields: ["Content-Type": "application/json"])!
+        return (Data(body.utf8), response)
+    }
+}
diff --git a/Tests/CodexBarTests/DevinUsageFetcherTests.swift b/Tests/CodexBarTests/DevinUsageFetcherTests.swift
new file mode 100644
index 0000000000..7590df20c0
--- /dev/null
+++ b/Tests/CodexBarTests/DevinUsageFetcherTests.swift
@@ -0,0 +1,392 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct DevinUsageFetcherTests {
+    private static let now = Date(timeIntervalSince1970: 1_780_000_000)
+
+    @Test
+    func `parses quota usage response into daily and weekly windows`() throws {
+        let response: [String: Any] = [
+            "plan_name": "pro",
+            "quota_usage": [
+                "daily_quota": [
+                    "used": 3,
+                    "limit": 10,
+                    "reset_at": "2026-06-01T08:00:00Z",
+                ],
+                "weekly_quota": [
+                    "remaining_percent": 0.25,
+                    "next_reset_at": 1_780_560_000,
+                ],
+            ],
+        ]
+
+        let snapshot = try DevinUsageParser.parse(response, organization: "org/example-org", now: Self.now)
+
+        #expect(snapshot.daily?.usedPercent == 30)
+        #expect(snapshot.weekly?.usedPercent == 75)
+        #expect(snapshot.daily?.resetsAt?.timeIntervalSince1970 == 1_780_300_800)
+        #expect(snapshot.weekly?.resetsAt?.timeIntervalSince1970 == 1_780_560_000)
+        #expect(snapshot.planName == "Pro")
+        #expect(snapshot.organization == "example-org")
+    }
+
+    @Test
+    func `parses current Devin quota response with reset timestamps`() throws {
+        let response: [String: Any] = [
+            "is_quota_plan": true,
+            "has_quota_allocation": true,
+            "daily_percentage": 0.12,
+            "weekly_percentage": 42,
+            "daily_reset_at": "2026-06-11T00:00:00-08:00",
+            "weekly_reset_at": "2026-06-14T00:00:00-08:00",
+            "hide_daily_quota": false,
+        ]
+
+        let snapshot = try DevinUsageParser.parse(response, organization: "org/example-org", now: Self.now)
+
+        #expect(snapshot.daily?.usedPercent == 12)
+        #expect(snapshot.weekly?.usedPercent == 42)
+        #expect(snapshot.daily?.resetsAt?.timeIntervalSince1970 == 1_781_164_800)
+        #expect(snapshot.weekly?.resetsAt?.timeIntervalSince1970 == 1_781_424_000)
+    }
+
+    @Test
+    func `keeps weekly quota when current plan hides daily quota`() throws {
+        let response: [String: Any] = [
+            "weekly_percentage": 25,
+            "weekly_reset_at": "2026-06-14T00:00:00-08:00",
+            "hide_daily_quota": true,
+        ]
+
+        let usage = try DevinUsageParser.parse(response, organization: nil, now: Self.now).toUsageSnapshot()
+
+        #expect(usage.primary == nil)
+        #expect(usage.secondary?.usedPercent == 25)
+    }
+
+    @Test
+    func `parses zero percentages from JSON response`() throws {
+        let data = Data("""
+        {
+          "daily_percentage": 0,
+          "weekly_percentage": 0,
+          "daily_reset_at": "2026-06-11T00:00:00-08:00",
+          "weekly_reset_at": "2026-06-14T00:00:00-08:00"
+        }
+        """.utf8)
+
+        let snapshot = try DevinUsageParser.parse(data, organization: nil, now: Self.now)
+
+        #expect(snapshot.daily?.usedPercent == 0)
+        #expect(snapshot.weekly?.usedPercent == 0)
+    }
+
+    @Test
+    func `usage snapshot maps Devin quotas to primary and secondary windows`() {
+        let snapshot = DevinUsageSnapshot(
+            daily: DevinQuotaWindow(usedPercent: 12),
+            weekly: DevinQuotaWindow(usedPercent: 42),
+            planName: "Free",
+            organization: "example-org",
+            updatedAt: Self.now)
+
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.primary?.usedPercent == 12)
+        #expect(usage.primary?.windowMinutes == 1440)
+        #expect(usage.primary?.resetDescription == "Daily")
+        #expect(usage.secondary?.usedPercent == 42)
+        #expect(usage.secondary?.windowMinutes == 10080)
+        #expect(usage.secondary?.resetDescription == "Weekly")
+        #expect(usage.identity?.providerID == .devin)
+        #expect(usage.identity?.accountOrganization == "example-org")
+        #expect(usage.identity?.loginMethod == "Free")
+    }
+
+    @Test
+    func `fetch sends bearer token and organization header`() async throws {
+        let auth = DevinUsageFetcher.RequestAuth(
+            bearerToken: "secret-token",
+            organization: "org/example-org",
+            internalOrganizationID: "org_GQ6LhcfkW1TSinM6",
+            sourceLabel: "test")
+        let stub = ProviderHTTPTransportStub { request in
+            #expect(request.url?.host == "app.devin.ai")
+            #expect(request.url?.path == "/api/org_GQ6LhcfkW1TSinM6/billing/quota/usage")
+            #expect(request.value(forHTTPHeaderField: "Authorization") == "Bearer secret-token")
+            #expect(request.value(forHTTPHeaderField: "x-cog-org-id") == "org_GQ6LhcfkW1TSinM6")
+            let body = """
+            {"daily":{"used_percent":10},"weekly":{"used_percent":20},"plan":"free"}
+            """
+            let response = HTTPURLResponse(
+                url: request.url!,
+                statusCode: 200,
+                httpVersion: nil,
+                headerFields: nil)!
+            return (Data(body.utf8), response)
+        }
+
+        let snapshot = try await DevinUsageFetcher.fetchQuotaUsage(
+            auth: auth,
+            now: Self.now,
+            transport: stub)
+
+        #expect(snapshot.daily?.usedPercent == 10)
+        #expect(snapshot.weekly?.usedPercent == 20)
+        #expect(snapshot.planName == "Free")
+    }
+
+    @Test
+    func `fetch does not mask parser failure with fallback endpoint errors`() async {
+        let auth = DevinUsageFetcher.RequestAuth(
+            bearerToken: "secret-token",
+            organization: "org/example-org",
+            internalOrganizationID: "org_GQ6LhcfkW1TSinM6",
+            sourceLabel: "test")
+        let stub = ProviderHTTPTransportStub { request in
+            let response = HTTPURLResponse(
+                url: request.url!,
+                statusCode: request.url?.path == "/api/org_GQ6LhcfkW1TSinM6/billing/quota/usage" ? 200 : 404,
+                httpVersion: nil,
+                headerFields: nil)!
+            return (Data("{}".utf8), response)
+        }
+
+        do {
+            _ = try await DevinUsageFetcher.fetchQuotaUsage(
+                auth: auth,
+                now: Self.now,
+                transport: stub)
+            Issue.record("Expected quota parsing to fail")
+        } catch let error as DevinUsageError {
+            guard case .parseFailed = error else {
+                Issue.record("Expected parseFailed, got \(error)")
+                return
+            }
+        } catch {
+            Issue.record("Expected DevinUsageError, got \(error)")
+        }
+
+        #expect(await stub.requests().count == 1)
+    }
+
+    @Test
+    func `normalizes organization inputs`() {
+        #expect(DevinUsageFetcher.normalizedOrganization("example-org") == "org/example-org")
+        #expect(DevinUsageFetcher.normalizedOrganization("org/example-org") == "org/example-org")
+        #expect(DevinUsageFetcher.normalizedOrganization("org_GQ6LhcfkW1TSinM6") ==
+            "organizations/org_GQ6LhcfkW1TSinM6")
+        #expect(DevinUsageFetcher.normalizedOrganization("org-b31f951cd01d4c6da84991cf5b970cfb") ==
+            "organizations/org-b31f951cd01d4c6da84991cf5b970cfb")
+        #expect(DevinUsageFetcher.normalizedOrganization("https://app.devin.ai/org/example-org/settings/usage") ==
+            "org/example-org")
+    }
+
+    @Test
+    func `manual auth strips Authorization and Bearer prefixes`() throws {
+        let auth = try #require(DevinUsageFetcher.manualAuth(
+            from: "Authorization: Bearer secret-token",
+            organization: "example-org"))
+
+        #expect(auth.bearerToken == "secret-token")
+        #expect(auth.organization == "org/example-org")
+        #expect(auth.sourceLabel == "manual")
+    }
+
+    #if os(macOS)
+    @Test
+    func `empty app organization setting preserves imported organization`() async throws {
+        defer { DevinSessionImporter.importSessionOverrideForTesting = nil }
+        DevinSessionImporter.importSessionOverrideForTesting = { _, organizationOverride, _ in
+            #expect(organizationOverride == nil)
+            return DevinSessionImporter.SessionInfo(
+                accessToken: "auth1_abcdefghijklmnopqrstuvwxyz0123456789",
+                organization: "org/example-org",
+                internalOrganizationID: "org_GQ6LhcfkW1TSinM6",
+                sourceLabel: "Chrome Default")
+        }
+        let stub = ProviderHTTPTransportStub { request in
+            #expect(request.url?.path == "/api/org_GQ6LhcfkW1TSinM6/billing/quota/usage")
+            let response = HTTPURLResponse(
+                url: request.url!,
+                statusCode: 200,
+                httpVersion: nil,
+                headerFields: nil)!
+            return (Data(#"{"daily_percentage":0,"weekly_percentage":0}"#.utf8), response)
+        }
+
+        let snapshot = try await DevinUsageFetcher(browserDetection: BrowserDetection(cacheTTL: 0)).fetch(
+            organizationOverride: "",
+            now: Self.now,
+            transport: stub)
+
+        #expect(snapshot.organization == "example-org")
+        #expect(snapshot.daily?.usedPercent == 0)
+        #expect(snapshot.weekly?.usedPercent == 0)
+    }
+
+    @Test
+    func `session importer extracts current auth1 token and matching org`() throws {
+        let accessToken = "auth1_abcdefghijklmnopqrstuvwxyz0123456789"
+        let storage = [
+            "_https://app.devin.ai\u{0000}\u{0001}auth1_session":
+                #"{"token":"\#(accessToken)","userId":"github|123"}"#,
+            "_https://app.devin.ai\u{0000}\u{0001}last-internal-org-for-external-org-v1-example-org":
+                "\"org_GQ6LhcfkW1TSinM6\"",
+        ]
+
+        let session = try #require(DevinSessionImporter.session(
+            from: storage,
+            organizationOverride: "example-org",
+            sourceLabel: "Chrome Default"))
+
+        #expect(session.accessToken == accessToken)
+        #expect(session.organization == "org/example-org")
+        #expect(session.internalOrganizationID == "org_GQ6LhcfkW1TSinM6")
+        #expect(session.sourceLabel == "Chrome Default")
+    }
+
+    @Test
+    func `session importer infers organization from post auth storage`() throws {
+        let accessToken = "eyJhbGciOiJub25lIn0.eyJpc3MiOiJodHRwczovL2F1dGguZGV2aW4uYWkvIn0.signature"
+        let storage = [
+            "_https://app.devin.ai\u{0000}\u{0001}@@auth0spajs@@::client::audience::scope":
+                #"{"body":{"access_token":"\#(accessToken)"}}"#,
+            "_https://app.devin.ai\u{0000}\u{0001}post-auth-v3-null-github|123-org_name-example-org": """
+            {
+              "externalOrgId": null,
+              "userId": "github|123",
+              "internalOrgId": "org_GQ6LhcfkW1TSinM6",
+              "orgName": "example-org"
+            }
+            """,
+        ]
+
+        let session = try #require(DevinSessionImporter.session(
+            from: storage,
+            organizationOverride: nil,
+            sourceLabel: "Brave Default"))
+
+        #expect(session.organization == "org/example-org")
+        #expect(session.internalOrganizationID == "org_GQ6LhcfkW1TSinM6")
+    }
+
+    @Test
+    func `session importer infers organization from member info storage`() throws {
+        let accessToken = "eyJhbGciOiJub25lIn0.eyJpc3MiOiJodHRwczovL2F1dGguZGV2aW4uYWkvIn0.signature"
+        let storage = [
+            "_https://app.devin.ai\u{0000}\u{0001}@@auth0spajs@@::client::audience::scope":
+                #"{"body":{"access_token":"\#(accessToken)"}}"#,
+            "_https://app.devin.ai\u{0000}\u{0001}member-info-v1-org-github|123": """
+            {
+              "value": {
+                "org_id": "org_GQ6LhcfkW1TSinM6",
+                "org_name": "example-org"
+              }
+            }
+            """,
+        ]
+
+        let session = try #require(DevinSessionImporter.session(
+            from: storage,
+            organizationOverride: nil,
+            sourceLabel: "Brave Default"))
+
+        #expect(session.organization == "org/example-org")
+        #expect(session.internalOrganizationID == "org_GQ6LhcfkW1TSinM6")
+    }
+
+    @Test
+    func `session importer falls back to internal organization id`() {
+        let result = DevinSessionImporter.organizationInfo(
+            from: [
+                "_https://app.devin.ai\u{0000}\u{0001}feature-flags-cache:org_GQ6LhcfkW1TSinM6": "{}",
+                "_https://app.devin.ai\u{0000}\u{0001}member-info-v1-org-github|123": """
+                {"value":{"org_id":"org_GQ6LhcfkW1TSinM6"}}
+                """,
+            ],
+            organizationOverride: nil)
+
+        #expect(result.organization == "organizations/org_GQ6LhcfkW1TSinM6")
+        #expect(result.internalOrganizationID == "org_GQ6LhcfkW1TSinM6")
+    }
+
+    @Test
+    func `session importer ignores org words inside storage key names`() {
+        let result = DevinSessionImporter.organizationInfo(
+            from: [
+                "_https://app.devin.ai\u{0000}\u{0001}last-internal-org-for-external-org-v1-null": "\"null\"",
+                "_https://app.devin.ai\u{0000}\u{0001}feature-flags-cache:org_GQ6LhcfkW1TSinM6": "{}",
+            ],
+            organizationOverride: nil)
+
+        #expect(result.organization == "organizations/org_GQ6LhcfkW1TSinM6")
+        #expect(result.internalOrganizationID == "org_GQ6LhcfkW1TSinM6")
+    }
+
+    @Test
+    func `session importer deduplicates repeated browser tokens using richest organization metadata`() {
+        let sessions = [
+            DevinSessionImporter.SessionInfo(
+                accessToken: "auth1_abcdefghijklmnopqrstuvwxyz0123456789",
+                organization: nil,
+                internalOrganizationID: nil,
+                sourceLabel: "Chrome Default"),
+            DevinSessionImporter.SessionInfo(
+                accessToken: "auth1_abcdefghijklmnopqrstuvwxyz0123456789",
+                organization: "org/example",
+                internalOrganizationID: "org_GQ6LhcfkW1TSinM6",
+                sourceLabel: "Chrome Profile 1"),
+        ]
+
+        let deduplicated = DevinSessionImporter.deduplicateSessions(sessions)
+
+        #expect(deduplicated.count == 1)
+        #expect(deduplicated.first?.sourceLabel == "Chrome Profile 1")
+        #expect(deduplicated.first?.organization == "org/example")
+        #expect(deduplicated.first?.internalOrganizationID == "org_GQ6LhcfkW1TSinM6")
+    }
+
+    @Test
+    func `session importer ranks organization aware profiles first`() {
+        let incomplete = DevinSessionImporter.SessionInfo(
+            accessToken: "auth1_incomplete",
+            organization: nil,
+            internalOrganizationID: nil,
+            sourceLabel: "Chrome Default")
+        let complete = DevinSessionImporter.SessionInfo(
+            accessToken: "auth1_complete",
+            organization: "org/example",
+            internalOrganizationID: "org_GQ6LhcfkW1TSinM6",
+            sourceLabel: "Chrome Profile 1")
+
+        let ranked = DevinSessionImporter.rankSessions([incomplete, complete])
+
+        #expect(ranked.map(\.sourceLabel) == ["Chrome Profile 1", "Chrome Default"])
+    }
+
+    @Test
+    func `missing organization retries the next browser profile`() {
+        #expect(DevinUsageFetcher.shouldTryNextSession(after: DevinUsageError.missingOrganization))
+        #expect(!DevinUsageFetcher.shouldTryNextSession(after: DevinUsageError.parseFailed("invalid response")))
+    }
+
+    @Test
+    func `automatic local storage import does not fall back beyond Chrome`() throws {
+        let temp = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        defer { try? FileManager.default.removeItem(at: temp) }
+
+        let braveRoot = temp
+            .appendingPathComponent("Library/Application Support/BraveSoftware/Brave-Browser/Default")
+        try FileManager.default.createDirectory(at: braveRoot, withIntermediateDirectories: true)
+        let detection = BrowserDetection(homeDirectory: temp.path, cacheTTL: 0)
+
+        #expect(detection.hasUsableProfileData(.brave))
+        #expect(!detection.hasUsableProfileData(.chrome))
+        #expect(DevinSessionImporter.localStorageBrowsers(browserDetection: detection).isEmpty)
+    }
+    #endif
+}
diff --git a/Tests/CodexBarTests/DocumentationLinkTests.swift b/Tests/CodexBarTests/DocumentationLinkTests.swift
new file mode 100644
index 0000000000..f19414a323
--- /dev/null
+++ b/Tests/CodexBarTests/DocumentationLinkTests.swift
@@ -0,0 +1,379 @@
+import Foundation
+import Testing
+
+struct DocumentationLinkTests {
+    private enum DocumentationLinkError: Error, Equatable {
+        case invalidURL(String)
+        case missingAnchor(String)
+        case missingTarget(String)
+        case outsideDocumentationRoot(String)
+    }
+
+    @Test
+    func `readme local documentation destinations resolve`() throws {
+        let root = try Self.repoRoot()
+        let readme = try String(contentsOf: root.appending(path: "README.md"), encoding: .utf8)
+        let links = try (
+            Self.markdownLinks(in: readme) +
+                Self.markdownImageLinks(in: readme) +
+                Self.htmlLinks(in: readme))
+            .filter(Self.isRepositoryDocReference)
+
+        #expect(!links.isEmpty)
+        for link in links {
+            try Self.validateLocalDocLink(link, existsUnder: root)
+        }
+    }
+
+    @Test
+    func `provider overview detail docs resolve`() throws {
+        let root = try Self.repoRoot()
+        let providers = try String(
+            contentsOf: root.appending(path: "docs/providers.md"),
+            encoding: .utf8)
+        let links = Self.inlineCodeDocLinks(in: providers)
+
+        #expect(!links.isEmpty)
+        for link in links {
+            try Self.validateLocalDocLink(link, existsUnder: root)
+        }
+    }
+
+    @Test
+    func `markdown links support standard destination syntax`() throws {
+        let markdown = [
+            "[fragment](#section)",
+            "[query](docs/guide%20name.md?mode=print#topic)",
+            #"[title](docs/title.md "Title")"#,
+            "[angle](<docs/with space.md>)",
+            "[reference][guide]",
+            "",
+            "[guide]: docs/reference.md?view=1#top",
+            "`[code](docs/not-a-link.md)`",
+            "![image](docs/image.png)",
+            "[external](https://example.com/docs/remote.md)",
+        ].joined(separator: "\n")
+
+        let links = try Self.markdownLinks(in: markdown)
+
+        #expect(links == [
+            "#section",
+            "docs/guide%20name.md?mode=print#topic",
+            "docs/title.md",
+            "docs/with%20space.md",
+            "docs/reference.md?view=1#top",
+            "https://example.com/docs/remote.md",
+        ])
+        #expect(links.filter(Self.isRepositoryDocReference).count == 4)
+    }
+
+    @Test
+    func `markdown images support standard inline destination syntax`() {
+        let markdown = """
+        ![simple](docs/simple.png)
+        ![query](docs/query.png?raw=1#preview)
+        ![title](docs/title.png "Title")
+        ![angle](<docs/with space.png>)
+        `![inline code](docs/not-an-image.png)`
+        ~~~markdown
+        ![fenced code](docs/not-an-image-either.png)
+        ~~~
+        """
+
+        #expect(Self.markdownImageLinks(in: markdown) == [
+            "docs/simple.png",
+            "docs/query.png?raw=1#preview",
+            "docs/title.png",
+            "docs/with space.png",
+        ])
+    }
+
+    @Test
+    func `html links support quoted and unquoted destinations`() {
+        let html = """
+        <img src="docs/double.png" alt="double">
+        <a href='docs/single.md#section'>single</a>
+        <img src=docs/unquoted.png alt=unquoted>
+        <a href="https://example.com/docs/remote.md">external</a>
+        `<img src="docs/not-an-image.png">`
+        ~~~html
+        <img src="docs/not-an-image-either.png">
+        ~~~
+        """
+
+        #expect(Self.htmlLinks(in: html) == [
+            "docs/double.png",
+            "docs/single.md#section",
+            "docs/unquoted.png",
+            "https://example.com/docs/remote.md",
+        ])
+    }
+
+    @Test
+    func `local documentation paths normalize safely`() throws {
+        let root = URL(filePath: "/tmp/CodexBar-documentation-links", directoryHint: .isDirectory)
+
+        let target = try Self.localDocURL(
+            for: "./docs/guide%20name.md?mode=print#topic",
+            repositoryRoot: root)
+        #expect(target.path == "/tmp/CodexBar-documentation-links/docs/guide name.md")
+
+        #expect(throws: DocumentationLinkError.outsideDocumentationRoot("docs/../README.md")) {
+            try Self.localDocURL(for: "docs/%2E%2E/README.md", repositoryRoot: root)
+        }
+        #expect(!Self.isRepositoryDocReference("#section"))
+        #expect(!Self.isRepositoryDocReference("https://example.com/docs/remote.md"))
+    }
+
+    @Test
+    func `markdown fragments resolve to rendered heading anchors`() throws {
+        let root = FileManager.default.temporaryDirectory
+            .appending(path: "DocumentationLinkTests-\(UUID().uuidString)", directoryHint: .isDirectory)
+        let docs = root.appending(path: "docs", directoryHint: .isDirectory)
+        try FileManager.default.createDirectory(at: docs, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let guide = docs.appending(path: "guide.md")
+        try """
+        # Guide
+        ## T3 Chat
+        ## CLI default selection (`--source auto`)
+        ## Repeated
+        ## Repeated
+        ~~~markdown
+        ## Code Only
+        ~~~
+        """.write(to: guide, atomically: true, encoding: .utf8)
+
+        try Self.validateLocalDocLink("docs/guide.md#t3-chat", existsUnder: root)
+        try Self.validateLocalDocLink("docs/guide.md#cli-default-selection---source-auto", existsUnder: root)
+        try Self.validateLocalDocLink("docs/guide.md#repeated-1", existsUnder: root)
+        #expect(throws: DocumentationLinkError.missingAnchor("docs/guide.md#cli-default-selection")) {
+            try Self.validateLocalDocLink("docs/guide.md#cli-default-selection", existsUnder: root)
+        }
+        #expect(throws: DocumentationLinkError.missingAnchor("docs/guide.md#renamed")) {
+            try Self.validateLocalDocLink("docs/guide.md#renamed", existsUnder: root)
+        }
+        #expect(throws: DocumentationLinkError.missingAnchor("docs/guide.md#code-only")) {
+            try Self.validateLocalDocLink("docs/guide.md#code-only", existsUnder: root)
+        }
+    }
+
+    @Test
+    func `provider detail extraction ignores unrelated inline code`() {
+        let markdown = """
+        - Details: `docs/first.md#section`.
+        - Example: `docs/not-a-detail.md`.
+          - Details: `docs/second%20guide.md?mode=print`.
+        See also: `docs/not-a-detail-either.md`.
+        """
+
+        #expect(Self.inlineCodeDocLinks(in: markdown) == [
+            "docs/first.md#section",
+            "docs/second%20guide.md?mode=print",
+        ])
+    }
+
+    private static func markdownLinks(in text: String) throws -> [String] {
+        let markdown = try AttributedString(markdown: text)
+        return markdown.runs.compactMap { $0.link?.relativeString }
+    }
+
+    private static func markdownImageLinks(in text: String) -> [String] {
+        let pattern =
+            #"\!\[(?:\\.|[^\]\\])*\]\(\s*(?:<([^>\n]+)>|([^\s)]+))"# +
+            #"(?:\s+(?:"[^"\n]*"|'[^'\n]*'|\([^)\n]*\)))?\s*\)"#
+        guard let regex = try? NSRegularExpression(pattern: pattern) else { return [] }
+        let source = Self.markdownTextOutsideCode(in: text)
+        let range = NSRange(source.startIndex..<source.endIndex, in: source)
+        return regex.matches(in: source, range: range).compactMap { match in
+            for index in 1...2 {
+                if let linkRange = Range(match.range(at: index), in: source) {
+                    return String(source[linkRange])
+                }
+            }
+            return nil
+        }
+    }
+
+    private static func htmlLinks(in text: String) -> [String] {
+        let pattern =
+            #"<\s*(?:a|img)\b[^>]*?\b(?:href|src)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+))"#
+        guard let regex = try? NSRegularExpression(pattern: pattern, options: .caseInsensitive) else { return [] }
+        let source = Self.markdownTextOutsideCode(in: text)
+        let range = NSRange(source.startIndex..<source.endIndex, in: source)
+        return regex.matches(in: source, range: range).compactMap { match in
+            for index in 1...3 {
+                if let linkRange = Range(match.range(at: index), in: source) {
+                    return String(source[linkRange])
+                }
+            }
+            return nil
+        }
+    }
+
+    private static func inlineCodeDocLinks(in text: String) -> [String] {
+        text.split(separator: "\n").compactMap { line in
+            let trimmed = line.trimmingCharacters(in: .whitespaces)
+            let prefix = "- Details: `"
+            guard trimmed.hasPrefix(prefix) else { return nil }
+            let valueStart = trimmed.index(trimmed.startIndex, offsetBy: prefix.count)
+            guard let valueEnd = trimmed[valueStart...].firstIndex(of: "`") else { return nil }
+            return String(trimmed[valueStart..<valueEnd])
+        }
+    }
+
+    private static func validateLocalDocLink(_ rawLink: String, existsUnder root: URL) throws {
+        let url = try Self.localDocURL(for: rawLink, repositoryRoot: root)
+        guard FileManager.default.fileExists(atPath: url.path(percentEncoded: false)) else {
+            throw DocumentationLinkError.missingTarget(rawLink)
+        }
+
+        guard url.pathExtension.lowercased() == "md",
+              let fragment = URLComponents(string: rawLink)?.fragment,
+              !fragment.isEmpty
+        else {
+            return
+        }
+        let markdown = try String(contentsOf: url, encoding: .utf8)
+        guard Self.markdownHeadingAnchors(in: markdown).contains(fragment) else {
+            throw DocumentationLinkError.missingAnchor(rawLink)
+        }
+    }
+
+    private static func isRepositoryDocReference(_ rawLink: String) -> Bool {
+        guard let components = URLComponents(string: rawLink),
+              components.scheme == nil,
+              components.host == nil
+        else {
+            return false
+        }
+        var path = components.path[...]
+        while path.hasPrefix("./") {
+            path = path.dropFirst(2)
+        }
+        return path == "docs" || path.hasPrefix("docs/")
+    }
+
+    private static func localDocURL(for rawLink: String, repositoryRoot root: URL) throws -> URL {
+        guard let components = URLComponents(string: rawLink),
+              components.scheme == nil,
+              components.host == nil,
+              !components.path.isEmpty
+        else {
+            throw DocumentationLinkError.invalidURL(rawLink)
+        }
+
+        let target = root.appending(path: components.path).standardizedFileURL
+        let docsRoot = root.appending(path: "docs", directoryHint: .isDirectory).standardizedFileURL
+        guard target.path == docsRoot.path || target.path.hasPrefix(docsRoot.path + "/") else {
+            throw DocumentationLinkError.outsideDocumentationRoot(components.path)
+        }
+        return target
+    }
+
+    private static func markdownHeadingAnchors(in markdown: String) -> Set<String> {
+        var occurrences: [String: Int] = [:]
+        var anchors: Set<String> = []
+        let source = Self.markdownTextOutsideFencedCode(in: markdown)
+        for line in source.split(separator: "\n", omittingEmptySubsequences: false) {
+            let trimmed = line.drop(while: { $0 == " " || $0 == "\t" })
+            let markerCount = trimmed.prefix(while: { $0 == "#" }).count
+            guard (1...6).contains(markerCount),
+                  trimmed.dropFirst(markerCount).first?.isWhitespace == true
+            else {
+                continue
+            }
+            let heading = trimmed.dropFirst(markerCount).trimmingCharacters(in: .whitespaces)
+            guard let base = Self.markdownHeadingSlug(heading), !base.isEmpty else { continue }
+            let occurrence = occurrences[base, default: 0]
+            anchors.insert(occurrence == 0 ? base : "\(base)-\(occurrence)")
+            occurrences[base] = occurrence + 1
+        }
+        return anchors
+    }
+
+    private static func markdownHeadingSlug(_ heading: String) -> String? {
+        guard let rendered = try? AttributedString(markdown: heading) else { return nil }
+        var slug = ""
+        for scalar in String(rendered.characters).lowercased().unicodeScalars {
+            if CharacterSet.alphanumerics.contains(scalar) || scalar == "-" || scalar == "_" {
+                slug.unicodeScalars.append(scalar)
+            } else if CharacterSet.whitespacesAndNewlines.contains(scalar) {
+                slug.append("-")
+            }
+        }
+        return slug
+    }
+
+    private static func markdownTextOutsideCode(in markdown: String) -> String {
+        self.markdownTextOutsideFencedCode(in: markdown)
+            .split(separator: "\n", omittingEmptySubsequences: false)
+            .map { self.removingInlineCode(from: String($0)) }
+            .joined(separator: "\n")
+    }
+
+    private static func markdownTextOutsideFencedCode(in markdown: String) -> String {
+        var fence: (marker: Character, count: Int)?
+        return markdown.split(separator: "\n", omittingEmptySubsequences: false).map { line in
+            if let activeFence = fence {
+                if Self.isClosingFence(line, marker: activeFence.marker, minimumCount: activeFence.count) {
+                    fence = nil
+                }
+                return ""
+            }
+            if let openingFence = Self.openingFence(in: line) {
+                fence = openingFence
+                return ""
+            }
+            return String(line)
+        }.joined(separator: "\n")
+    }
+
+    private static func openingFence(in line: Substring) -> (marker: Character, count: Int)? {
+        let leadingSpaces = line.prefix(while: { $0 == " " }).count
+        guard leadingSpaces <= 3 else { return nil }
+        let candidate = line.dropFirst(leadingSpaces)
+        guard let marker = candidate.first, marker == "`" || marker == "~" else { return nil }
+        let count = candidate.prefix(while: { $0 == marker }).count
+        guard count >= 3 else { return nil }
+        let suffix = candidate.dropFirst(count)
+        guard marker != "`" || !suffix.contains("`") else { return nil }
+        return (marker, count)
+    }
+
+    private static func isClosingFence(
+        _ line: Substring,
+        marker: Character,
+        minimumCount: Int) -> Bool
+    {
+        let leadingSpaces = line.prefix(while: { $0 == " " }).count
+        guard leadingSpaces <= 3 else { return false }
+        let candidate = line.dropFirst(leadingSpaces)
+        let count = candidate.prefix(while: { $0 == marker }).count
+        return count >= minimumCount && candidate.dropFirst(count).allSatisfy(\.isWhitespace)
+    }
+
+    private static func removingInlineCode(from line: String) -> String {
+        let pattern = #"(?<!`)(`+)(?!`)(.*?)(?<!`)\1(?!`)"#
+        guard let regex = try? NSRegularExpression(pattern: pattern) else { return line }
+        let range = NSRange(line.startIndex..<line.endIndex, in: line)
+        return regex.stringByReplacingMatches(in: line, range: range, withTemplate: "")
+    }
+
+    private static func repoRoot() throws -> URL {
+        var dir = URL(filePath: #filePath).deletingLastPathComponent()
+        while true {
+            let candidate = dir.appending(path: "Package.swift")
+            if FileManager.default.fileExists(atPath: candidate.path(percentEncoded: false)) {
+                return dir
+            }
+            let parent = dir.deletingLastPathComponent()
+            guard parent != dir else { break }
+            dir = parent
+        }
+        throw NSError(domain: "DocumentationLinkTests", code: 2, userInfo: [
+            NSLocalizedDescriptionKey: "Could not locate repo root (Package.swift) from \(#filePath)",
+        ])
+    }
+}
diff --git a/Tests/CodexBarTests/DoubaoMenuCardModelTests.swift b/Tests/CodexBarTests/DoubaoMenuCardModelTests.swift
new file mode 100644
index 0000000000..53215f4707
--- /dev/null
+++ b/Tests/CodexBarTests/DoubaoMenuCardModelTests.swift
@@ -0,0 +1,44 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct DoubaoMenuCardModelTests {
+    @Test
+    func `unknown request limit renders unavailable instead of full quota`() throws {
+        let now = Date(timeIntervalSince1970: 1_742_771_200)
+        let metadata = try #require(ProviderDefaults.metadata[.doubao])
+        let snapshot = DoubaoUsageSnapshot(
+            remainingRequests: 0,
+            limitRequests: 1000,
+            resetTime: nil,
+            updatedAt: now,
+            apiKeyValid: true,
+            requestLimitsReliable: false)
+            .toUsageSnapshot()
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .doubao,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.metrics.isEmpty)
+        #expect(model.placeholder == "Limits not available")
+        #expect(model.subtitleStyle == .info)
+    }
+}
diff --git a/Tests/CodexBarTests/DoubaoProviderTests.swift b/Tests/CodexBarTests/DoubaoProviderTests.swift
new file mode 100644
index 0000000000..bc69da7b76
--- /dev/null
+++ b/Tests/CodexBarTests/DoubaoProviderTests.swift
@@ -0,0 +1,39 @@
+import CodexBarCore
+import Foundation
+import Testing
+
+struct DoubaoProviderTests {
+    @Test
+    func `usage snapshot exposes request usage window`() {
+        let resetDate = Date(timeIntervalSince1970: 1_742_771_200)
+        let snapshot = DoubaoUsageSnapshot(
+            remainingRequests: 80,
+            limitRequests: 100,
+            resetTime: resetDate,
+            updatedAt: resetDate,
+            apiKeyValid: true)
+
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.primary?.usedPercent == 20)
+        #expect(usage.primary?.resetDescription == "20/100 requests")
+        #expect(usage.primary?.resetsAt == resetDate)
+        #expect(usage.identity?.providerID == .doubao)
+    }
+
+    @Test
+    func `usage snapshot omits unknown request limit when headers are absent`() {
+        let now = Date(timeIntervalSince1970: 1_742_771_200)
+        let snapshot = DoubaoUsageSnapshot(
+            remainingRequests: 0,
+            limitRequests: 0,
+            resetTime: nil,
+            updatedAt: now,
+            apiKeyValid: true)
+
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.primary == nil)
+        #expect(usage.rateLimitsUnavailable(for: .doubao))
+    }
+}
diff --git a/Tests/CodexBarTests/DoubaoUsageFetcherTests.swift b/Tests/CodexBarTests/DoubaoUsageFetcherTests.swift
new file mode 100644
index 0000000000..ce727088a9
--- /dev/null
+++ b/Tests/CodexBarTests/DoubaoUsageFetcherTests.swift
@@ -0,0 +1,259 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct DoubaoUsageSnapshotTests {
+    @Test
+    func `normal usage with both headers present and non-empty reports correct percent`() {
+        let snapshot = DoubaoUsageSnapshot(
+            remainingRequests: 750,
+            limitRequests: 1000,
+            resetTime: nil,
+            updatedAt: Date(),
+            apiKeyValid: true)
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary?.usedPercent == 25)
+        #expect(usage.primary?.resetDescription == "250/1000 requests")
+    }
+
+    @Test
+    func `boundary normal usage at near-full reports correct percent`() {
+        let snapshot = DoubaoUsageSnapshot(
+            remainingRequests: 1,
+            limitRequests: 1000,
+            resetTime: nil,
+            updatedAt: Date(),
+            apiKeyValid: true)
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary?.usedPercent == 99.9)
+        #expect(usage.primary?.resetDescription == "999/1000 requests")
+    }
+
+    @Test
+    func `unreliable headers omit the request limit window`() {
+        let snapshot = DoubaoUsageSnapshot(
+            remainingRequests: 0,
+            limitRequests: 1000,
+            resetTime: nil,
+            updatedAt: Date(),
+            apiKeyValid: true,
+            requestLimitsReliable: false)
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary == nil)
+        #expect(usage.rateLimitsUnavailable(for: .doubao))
+    }
+
+    @Test
+    func `explicit rate limit with zero remaining reports exhausted quota`() {
+        let snapshot = DoubaoUsageSnapshot(
+            remainingRequests: 0,
+            limitRequests: 1000,
+            resetTime: nil,
+            updatedAt: Date(),
+            apiKeyValid: true)
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary?.usedPercent == 100)
+        #expect(usage.primary?.resetDescription == "1000/1000 requests")
+    }
+
+    @Test
+    func `both headers missing but key valid omit the request limit window`() {
+        let snapshot = DoubaoUsageSnapshot(
+            remainingRequests: 0,
+            limitRequests: 0,
+            resetTime: nil,
+            updatedAt: Date(),
+            apiKeyValid: true)
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary == nil)
+        #expect(usage.rateLimitsUnavailable(for: .doubao))
+    }
+
+    @Test
+    func `invalid key with no headers reports No usage data`() {
+        let snapshot = DoubaoUsageSnapshot(
+            remainingRequests: 0,
+            limitRequests: 0,
+            resetTime: nil,
+            updatedAt: Date(),
+            apiKeyValid: false)
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary?.usedPercent == 0)
+        #expect(usage.primary?.resetDescription == "No usage data")
+    }
+
+    @Test
+    func `provider identity is correctly tagged as doubao`() {
+        let snapshot = DoubaoUsageSnapshot(
+            remainingRequests: 500,
+            limitRequests: 1000,
+            resetTime: nil,
+            updatedAt: Date(),
+            apiKeyValid: true)
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.identity?.providerID == .doubao)
+        #expect(usage.identity?.accountEmail == nil)
+    }
+}
+
+struct DoubaoUsageFetcherTests {
+    @Test
+    func `repeated successful zero remaining responses omit unknown request limit`() async throws {
+        let transport = DoubaoScriptedTransport(results: [
+            .response(statusCode: 200, limit: 1000, remaining: 0),
+            .response(statusCode: 200, limit: 1000, remaining: 0),
+        ])
+
+        let snapshot = try await DoubaoUsageFetcher.fetchUsage(apiKey: "test-key", session: transport)
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.primary == nil)
+        #expect(usage.rateLimitsUnavailable(for: .doubao))
+        #expect(await transport.requestCount() == 2)
+    }
+
+    @Test
+    func `successful final request followed by rate limit reports exhausted quota`() async throws {
+        let transport = DoubaoScriptedTransport(results: [
+            .response(statusCode: 200, limit: 1000, remaining: 0),
+            .response(statusCode: 429, limit: 1000, remaining: 0),
+        ])
+
+        let snapshot = try await DoubaoUsageFetcher.fetchUsage(apiKey: "test-key", session: transport)
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.primary?.usedPercent == 100)
+        #expect(usage.primary?.resetDescription == "1000/1000 requests")
+        #expect(await transport.requestCount() == 2)
+    }
+
+    @Test
+    func `headerless rate limit confirmation preserves exhausted quota`() async throws {
+        let transport = DoubaoScriptedTransport(results: [
+            .response(statusCode: 200, limit: 1000, remaining: 0),
+            .response(statusCode: 429, limit: nil, remaining: nil),
+        ])
+
+        let snapshot = try await DoubaoUsageFetcher.fetchUsage(apiKey: "test-key", session: transport)
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.primary?.usedPercent == 100)
+        #expect(usage.primary?.resetDescription == "1000/1000 requests")
+        #expect(await transport.requestCount() == 2)
+    }
+
+    @Test
+    func `rate limit with request limit header reports exhausted quota`() async throws {
+        let transport = DoubaoScriptedTransport(results: [
+            .response(statusCode: 429, limit: 1000, remaining: nil),
+        ])
+
+        let snapshot = try await DoubaoUsageFetcher.fetchUsage(apiKey: "test-key", session: transport)
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.primary?.usedPercent == 100)
+        #expect(usage.primary?.resetDescription == "1000/1000 requests")
+        #expect(await transport.requestCount() == 1)
+    }
+
+    @Test
+    func `bare rate limit omits unknown request limit`() async throws {
+        let transport = DoubaoScriptedTransport(results: [
+            .response(statusCode: 429, limit: nil, remaining: nil),
+        ])
+
+        let snapshot = try await DoubaoUsageFetcher.fetchUsage(apiKey: "test-key", session: transport)
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.primary == nil)
+        #expect(usage.rateLimitsUnavailable(for: .doubao))
+        #expect(await transport.requestCount() == 1)
+    }
+
+    @Test
+    func `failed zero remaining confirmation preserves exhausted quota`() async throws {
+        let transport = DoubaoScriptedTransport(results: [
+            .response(statusCode: 200, limit: 1000, remaining: 0),
+            .failure(URLError(.timedOut)),
+        ])
+
+        let snapshot = try await DoubaoUsageFetcher.fetchUsage(apiKey: "test-key", session: transport)
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.primary?.usedPercent == 100)
+        #expect(usage.primary?.resetDescription == "1000/1000 requests")
+        #expect(await transport.requestCount() == 2)
+    }
+
+    @Test
+    func `task cancellation during confirmation propagates`() async {
+        let transport = DoubaoScriptedTransport(results: [
+            .response(statusCode: 200, limit: 1000, remaining: 0),
+            .cancellation,
+        ])
+
+        await #expect(throws: CancellationError.self) {
+            _ = try await DoubaoUsageFetcher.fetchUsage(apiKey: "test-key", session: transport)
+        }
+        #expect(await transport.requestCount() == 2)
+    }
+
+    @Test
+    func `url cancellation during confirmation propagates`() async {
+        let transport = DoubaoScriptedTransport(results: [
+            .response(statusCode: 200, limit: 1000, remaining: 0),
+            .failure(URLError(.cancelled)),
+        ])
+
+        await #expect {
+            _ = try await DoubaoUsageFetcher.fetchUsage(apiKey: "test-key", session: transport)
+        } throws: { error in
+            (error as? URLError)?.code == .cancelled
+        }
+        #expect(await transport.requestCount() == 2)
+    }
+}
+
+private actor DoubaoScriptedTransport: ProviderHTTPTransport {
+    enum Result {
+        case response(statusCode: Int, limit: Int?, remaining: Int?)
+        case failure(URLError)
+        case cancellation
+    }
+
+    private var results: [Result]
+    private var requests = 0
+
+    init(results: [Result]) {
+        self.results = results
+    }
+
+    func requestCount() -> Int {
+        self.requests
+    }
+
+    func data(for request: URLRequest) throws -> (Data, URLResponse) {
+        self.requests += 1
+        let result = self.results.removeFirst()
+        switch result {
+        case let .response(statusCode, limit, remaining):
+            var headers: [String: String] = [:]
+            if let limit {
+                headers["x-ratelimit-limit-requests"] = String(limit)
+            }
+            if let remaining {
+                headers["x-ratelimit-remaining-requests"] = String(remaining)
+            }
+            let response = HTTPURLResponse(
+                url: request.url!,
+                statusCode: statusCode,
+                httpVersion: "HTTP/1.1",
+                headerFields: headers)!
+            return (Data(#"{"usage":{"total_tokens":1}}"#.utf8), response)
+        case let .failure(error):
+            throw error
+        case .cancellation:
+            throw CancellationError()
+        }
+    }
+}
diff --git a/Tests/CodexBarTests/ElevenLabsUsageFetcherTests.swift b/Tests/CodexBarTests/ElevenLabsUsageFetcherTests.swift
new file mode 100644
index 0000000000..26ce7014af
--- /dev/null
+++ b/Tests/CodexBarTests/ElevenLabsUsageFetcherTests.swift
@@ -0,0 +1,178 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct ElevenLabsUsageFetcherTests {
+    @Test
+    func `parses subscription response into usage snapshot`() throws {
+        let body = #"""
+        {
+          "tier": "creator",
+          "character_count": 25000,
+          "character_limit": 100000,
+          "voice_slots_used": 2,
+          "voice_limit": 10,
+          "professional_voice_slots_used": 1,
+          "professional_voice_limit": 2,
+          "current_overage": {"amount": "0", "currency": "usd"},
+          "status": "active",
+          "next_character_count_reset_unix": 1738356858
+        }
+        """#
+
+        let snapshot = try ElevenLabsUsageFetcher._parseSnapshotForTesting(
+            Data(body.utf8),
+            updatedAt: Date(timeIntervalSince1970: 1))
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(snapshot.characterCount == 25000)
+        #expect(snapshot.characterLimit == 100_000)
+        #expect(snapshot.usedPercent == 25)
+        #expect(snapshot.remainingCharacters == 75000)
+        #expect(usage.primary?.usedPercent == 25)
+        #expect(usage.primary?.resetDescription == "25,000 / 100,000 credits")
+        #expect(usage.primary?.resetsAt == Date(timeIntervalSince1970: 1_738_356_858))
+        #expect(usage.loginMethod(for: .elevenlabs) == "Creator")
+        #expect(usage.extraRateWindows?.count == 2)
+    }
+
+    @Test
+    func `fetch usage sends xi api key header`() async throws {
+        let registered = URLProtocol.registerClass(ElevenLabsStubURLProtocol.self)
+        defer {
+            if registered {
+                URLProtocol.unregisterClass(ElevenLabsStubURLProtocol.self)
+            }
+            ElevenLabsStubURLProtocol.handler = nil
+        }
+
+        ElevenLabsStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            #expect(url.path == "/v1/user/subscription")
+            #expect(request.value(forHTTPHeaderField: "xi-api-key") == "xi-test")
+            #expect(request.timeoutInterval == 15)
+
+            let body = #"""
+            {
+              "tier": "starter",
+              "character_count": 1000,
+              "character_limit": 10000,
+              "status": "active"
+            }
+            """#
+            return Self.makeResponse(url: url, body: body, statusCode: 200)
+        }
+
+        let usage = try await ElevenLabsUsageFetcher.fetchUsage(
+            apiKey: " xi-test ",
+            environment: [ElevenLabsSettingsReader.apiURLEnvironmentKey: "https://elevenlabs.test"])
+
+        #expect(usage.characterCount == 1000)
+        #expect(usage.characterLimit == 10000)
+        #expect(usage.usedPercent == 10)
+    }
+
+    @Test
+    func `fetch usage accepts versioned API base with trailing slash`() async throws {
+        let registered = URLProtocol.registerClass(ElevenLabsStubURLProtocol.self)
+        defer {
+            if registered {
+                URLProtocol.unregisterClass(ElevenLabsStubURLProtocol.self)
+            }
+            ElevenLabsStubURLProtocol.handler = nil
+        }
+
+        ElevenLabsStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            #expect(url.path == "/v1/user/subscription")
+
+            let body = #"""
+            {
+              "tier": "starter",
+              "character_count": 1000,
+              "character_limit": 10000,
+              "status": "active"
+            }
+            """#
+            return Self.makeResponse(url: url, body: body, statusCode: 200)
+        }
+
+        let usage = try await ElevenLabsUsageFetcher.fetchUsage(
+            apiKey: "xi-test",
+            environment: [ElevenLabsSettingsReader.apiURLEnvironmentKey: "https://elevenlabs.test/v1/"])
+
+        #expect(usage.characterCount == 1000)
+    }
+
+    @Test
+    func `non success fetch throws generic HTTP error`() async throws {
+        let registered = URLProtocol.registerClass(ElevenLabsStubURLProtocol.self)
+        defer {
+            if registered {
+                URLProtocol.unregisterClass(ElevenLabsStubURLProtocol.self)
+            }
+            ElevenLabsStubURLProtocol.handler = nil
+        }
+
+        ElevenLabsStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            return Self.makeResponse(url: url, body: #"{"detail":"bad xi-test"}"#, statusCode: 500)
+        }
+
+        do {
+            _ = try await ElevenLabsUsageFetcher.fetchUsage(
+                apiKey: "xi-test",
+                environment: [ElevenLabsSettingsReader.apiURLEnvironmentKey: "https://elevenlabs.test"])
+            Issue.record("Expected ElevenLabsUsageError.apiError")
+        } catch let error as ElevenLabsUsageError {
+            guard case let .apiError(message) = error else {
+                Issue.record("Expected apiError, got \(error)")
+                return
+            }
+            #expect(message == "HTTP 500")
+        }
+    }
+
+    private static func makeResponse(
+        url: URL,
+        body: String,
+        statusCode: Int = 200) -> (HTTPURLResponse, Data)
+    {
+        let response = HTTPURLResponse(
+            url: url,
+            statusCode: statusCode,
+            httpVersion: "HTTP/1.1",
+            headerFields: ["Content-Type": "application/json"])!
+        return (response, Data(body.utf8))
+    }
+}
+
+final class ElevenLabsStubURLProtocol: URLProtocol {
+    nonisolated(unsafe) static var handler: ((URLRequest) throws -> (HTTPURLResponse, Data))?
+
+    override static func canInit(with request: URLRequest) -> Bool {
+        request.url?.host == "elevenlabs.test"
+    }
+
+    override static func canonicalRequest(for request: URLRequest) -> URLRequest {
+        request
+    }
+
+    override func startLoading() {
+        guard let handler = Self.handler else {
+            self.client?.urlProtocol(self, didFailWithError: URLError(.badServerResponse))
+            return
+        }
+        do {
+            let (response, data) = try handler(self.request)
+            self.client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
+            self.client?.urlProtocol(self, didLoad: data)
+            self.client?.urlProtocolDidFinishLoading(self)
+        } catch {
+            self.client?.urlProtocol(self, didFailWithError: error)
+        }
+    }
+
+    override func stopLoading() {}
+}
diff --git a/Tests/CodexBarTests/FactoryManualCredentialTests.swift b/Tests/CodexBarTests/FactoryManualCredentialTests.swift
new file mode 100644
index 0000000000..33edb0f9b9
--- /dev/null
+++ b/Tests/CodexBarTests/FactoryManualCredentialTests.swift
@@ -0,0 +1,135 @@
+import CodexBarCore
+import Foundation
+import Testing
+
+extension FactoryStatusProbeFetchTests {
+    @Test
+    func `rejects malformed manual override before cached cookies`() async throws {
+        let registered = URLProtocol.registerClass(FactoryStubURLProtocol.self)
+        defer {
+            if registered {
+                URLProtocol.unregisterClass(FactoryStubURLProtocol.self)
+            }
+            FactoryStubURLProtocol.handler = nil
+            FactoryStubURLProtocol.requests = []
+            CookieHeaderCache.clear(provider: .factory)
+        }
+        FactoryStubURLProtocol.requests = []
+        CookieHeaderCache.store(provider: .factory, cookieHeader: "session=cached", sourceLabel: "Chrome")
+        FactoryStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            return Self.makeResponse(url: url, body: "{}", statusCode: 200)
+        }
+
+        let probe = FactoryStatusProbe(browserDetection: BrowserDetection(cacheTTL: 0))
+        await #expect {
+            _ = try await probe.fetch(cookieHeaderOverride: "definitely not a cookie or bearer")
+        } throws: { error in
+            guard case FactoryStatusProbeError.noSessionCookie = error else { return false }
+            return true
+        }
+        #expect(FactoryStubURLProtocol.requests.isEmpty)
+    }
+
+    @Test
+    func `falls back to bearer authorization when pasted cookie is stale`() async throws {
+        let registered = URLProtocol.registerClass(FactoryStubURLProtocol.self)
+        defer {
+            if registered {
+                URLProtocol.unregisterClass(FactoryStubURLProtocol.self)
+            }
+            FactoryStubURLProtocol.handler = nil
+            FactoryStubURLProtocol.requests = []
+        }
+        FactoryStubURLProtocol.requests = []
+
+        FactoryStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            if request.value(forHTTPHeaderField: "Cookie")?.contains("stale-session") == true {
+                return Self.makeResponse(url: url, body: "{}", statusCode: 401)
+            }
+            guard request.value(forHTTPHeaderField: "Authorization") == "Bearer factory-access-token" else {
+                return Self.makeResponse(url: url, body: "{}", statusCode: 401)
+            }
+            #expect(request.value(forHTTPHeaderField: "Cookie") == nil)
+            if url.host == "api.factory.ai", url.path == "/api/app/auth/me" {
+                let body = """
+                {
+                  "organization": {
+                    "id": "org_1",
+                    "name": "Acme",
+                    "subscription": {
+                      "factoryTier": "team",
+                      "orbSubscription": {
+                        "plan": { "name": "Team", "id": "plan_1" },
+                        "status": "active"
+                      }
+                    }
+                  },
+                  "userProfile": {
+                    "id": "user-1",
+                    "email": "user@example.com"
+                  }
+                }
+                """
+                return Self.makeResponse(url: url, body: body)
+            }
+            if url.host == "api.factory.ai", url.path == "/api/billing/limits" {
+                return Self.makeResponse(url: url, body: "{}", statusCode: 404)
+            }
+            if url.host == "api.factory.ai", url.path == "/api/organization/subscription/usage" {
+                let body = """
+                {
+                  "usage": {
+                    "standard": {
+                      "userTokens": 100,
+                      "totalAllowance": 1000,
+                      "usedRatio": 0.10
+                    }
+                  },
+                  "userId": "user-1"
+                }
+                """
+                return Self.makeResponse(url: url, body: body)
+            }
+            return Self.makeResponse(url: url, body: "{}", statusCode: 404)
+        }
+
+        let probe = FactoryStatusProbe(browserDetection: BrowserDetection(cacheTTL: 0))
+        let snapshot = try await probe.fetch(
+            cookieHeaderOverride: "Cookie: session=stale-session\nAuthorization: Bearer factory-access-token")
+
+        #expect(snapshot.userId == "user-1")
+        #expect(snapshot.standardUserTokens == 100)
+        #expect(snapshot.standardAllowance == 1000)
+        #expect(Self.requestTrace() == [
+            "GET app.factory.ai/api/app/auth/me",
+            "GET auth.factory.ai/api/app/auth/me",
+            "GET api.factory.ai/api/app/auth/me",
+            "GET api.factory.ai/api/app/auth/me",
+            "GET api.factory.ai/api/billing/limits",
+            "GET api.factory.ai/api/organization/subscription/usage?useCache=true&userId=user-1",
+        ])
+    }
+
+    private static func makeResponse(
+        url: URL,
+        body: String,
+        statusCode: Int = 200) -> (HTTPURLResponse, Data)
+    {
+        let response = HTTPURLResponse(
+            url: url,
+            statusCode: statusCode,
+            httpVersion: "HTTP/1.1",
+            headerFields: ["Content-Type": "application/json"])!
+        return (response, Data(body.utf8))
+    }
+
+    private static func requestTrace() -> [String] {
+        FactoryStubURLProtocol.requests.compactMap { request in
+            guard let url = request.url else { return nil }
+            let query = url.query.map { "?\($0)" } ?? ""
+            return "\(request.httpMethod ?? "?") \(url.host ?? "unknown")\(url.path)\(query)"
+        }
+    }
+}
diff --git a/Tests/CodexBarTests/FactoryProviderImplementationTests.swift b/Tests/CodexBarTests/FactoryProviderImplementationTests.swift
new file mode 100644
index 0000000000..f37f194461
--- /dev/null
+++ b/Tests/CodexBarTests/FactoryProviderImplementationTests.swift
@@ -0,0 +1,82 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@MainActor
+struct FactoryProviderImplementationTests {
+    @Test
+    func `extra usage balance respects optional usage setting`() throws {
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            providerCost: ProviderCostSnapshot(
+                used: 25,
+                limit: 0,
+                currencyCode: "USD",
+                period: "Extra usage balance",
+                updatedAt: Date(timeIntervalSince1970: 0)),
+            updatedAt: Date(timeIntervalSince1970: 0))
+
+        var hiddenEntries: [ProviderMenuEntry] = []
+        let hiddenContext = try Self.context(snapshot: snapshot, showOptionalUsage: false)
+        FactoryProviderImplementation().appendUsageMenuEntries(
+            context: hiddenContext,
+            entries: &hiddenEntries)
+        #expect(hiddenEntries.isEmpty)
+
+        var visibleEntries: [ProviderMenuEntry] = []
+        let visibleContext = try Self.context(snapshot: snapshot, showOptionalUsage: true)
+        FactoryProviderImplementation().appendUsageMenuEntries(
+            context: visibleContext,
+            entries: &visibleEntries)
+
+        guard case let .text(title, style) = try #require(visibleEntries.first) else {
+            Issue.record("Expected Factory extra usage balance menu text")
+            return
+        }
+        #expect(title == "Extra usage balance: $25.00")
+        #expect(style == .primary)
+    }
+
+    private static func context(
+        snapshot: UsageSnapshot,
+        showOptionalUsage: Bool) throws -> ProviderMenuUsageContext
+    {
+        let suite = "FactoryProviderImplementationTests-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore(),
+            codexCookieStore: InMemoryCookieHeaderStore(),
+            claudeCookieStore: InMemoryCookieHeaderStore(),
+            cursorCookieStore: InMemoryCookieHeaderStore(),
+            opencodeCookieStore: InMemoryCookieHeaderStore(),
+            factoryCookieStore: InMemoryCookieHeaderStore(),
+            minimaxCookieStore: InMemoryMiniMaxCookieStore(),
+            minimaxAPITokenStore: InMemoryMiniMaxAPITokenStore(),
+            kimiTokenStore: InMemoryKimiTokenStore(),
+            kimiK2TokenStore: InMemoryKimiK2TokenStore(),
+            augmentCookieStore: InMemoryCookieHeaderStore(),
+            ampCookieStore: InMemoryCookieHeaderStore(),
+            copilotTokenStore: InMemoryCopilotTokenStore(),
+            tokenAccountStore: InMemoryTokenAccountStore())
+        settings.showOptionalCreditsAndExtraUsage = showOptionalUsage
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing,
+            environmentBase: [:])
+
+        return ProviderMenuUsageContext(
+            provider: .factory,
+            store: store,
+            settings: settings,
+            metadata: FactoryProviderDescriptor.descriptor.metadata,
+            snapshot: snapshot)
+    }
+}
diff --git a/Tests/CodexBarTests/FactoryStatusProbeFetchTests.swift b/Tests/CodexBarTests/FactoryStatusProbeFetchTests.swift
index d1c09f6491..5c01dd2d27 100644
--- a/Tests/CodexBarTests/FactoryStatusProbeFetchTests.swift
+++ b/Tests/CodexBarTests/FactoryStatusProbeFetchTests.swift
@@ -1,18 +1,244 @@
-import CodexBarCore
 import Foundation
 import Testing
+@testable import CodexBarCore
 
 @Suite(.serialized)
 struct FactoryStatusProbeFetchTests {
     @Test
-    func fetchesSnapshotUsingCookieHeaderOverride() async throws {
+    func `keeps stored Factory cookies available when cached header is not logged in`() async throws {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+        let registered = URLProtocol.registerClass(FactoryStubURLProtocol.self)
+        defer {
+            if registered {
+                URLProtocol.unregisterClass(FactoryStubURLProtocol.self)
+            }
+            FactoryStubURLProtocol.handler = nil
+            FactoryStubURLProtocol.requests = []
+        }
+        FactoryStubURLProtocol.requests = []
+
+        FactoryStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            if url.host == "app.factory.ai",
+               url.path == "/api/app/auth/me",
+               request.value(forHTTPHeaderField: "Cookie")?.contains("stale-cache") == true
+            {
+                return Self.makeResponse(url: url, body: "{}", statusCode: 401)
+            }
+            if url.host == "api.factory.ai", url.path == "/api/app/auth/me" {
+                let body = """
+                {
+                  "organization": {
+                    "id": "org_1",
+                    "name": "Acme",
+                    "subscription": {
+                      "factoryTier": "team",
+                      "orbSubscription": {
+                        "plan": { "name": "Team", "id": "plan_1" },
+                        "status": "active"
+                      }
+                    }
+                  }
+                }
+                """
+                return Self.makeResponse(url: url, body: body)
+            }
+            if url.host == "api.factory.ai", url.path == "/api/organization/subscription/usage" {
+                let body = """
+                {
+                  "usage": {
+                    "standard": {
+                      "userTokens": 100,
+                      "totalAllowance": 1000
+                    }
+                  },
+                  "userId": "user-1"
+                }
+                """
+                return Self.makeResponse(url: url, body: body)
+            }
+            return Self.makeResponse(url: url, body: "{}", statusCode: 404)
+        }
+
+        let cookie = try #require(HTTPCookie(properties: [
+            .domain: "app.factory.ai",
+            .path: "/",
+            .name: "session",
+            .value: "valid-session",
+        ]))
+
+        let sessionFile = try await Self.isolateFactorySessionStore()
+        defer {
+            try? FileManager.default.removeItem(at: sessionFile)
+        }
+
+        await FactorySessionStore.shared.clearSession()
+        CookieHeaderCache.store(provider: .factory, cookieHeader: "session=stale-cache", sourceLabel: "Chrome")
+        await FactorySessionStore.shared.setCookies([cookie])
+        await FactorySessionStore.shared.resetInMemoryForTesting()
+        defer {
+            CookieHeaderCache.clear(provider: .factory)
+        }
+
+        let probe = FactoryStatusProbe(
+            timeout: 1.0,
+            browserDetection: BrowserDetection(
+                homeDirectory: "/tmp/codexbar-empty-browser-home",
+                cacheTTL: 0,
+                fileExists: { _ in false },
+                directoryContents: { _ in nil }),
+            transport: FactoryStubTransport())
+
+        let snapshot = try await probe.fetch()
+
+        #expect(CookieHeaderCache.load(provider: .factory) == nil)
+        #expect(snapshot.userId == "user-1")
+        #expect(await FactorySessionStore.shared.getCookies().map(\.value) == ["valid-session"])
+        #expect(Self.requestTrace() == [
+            "GET app.factory.ai/api/app/auth/me",
+            "GET api.factory.ai/api/app/auth/me",
+            "GET api.factory.ai/api/billing/limits",
+            "GET api.factory.ai/api/organization/subscription/usage?useCache=true",
+        ])
+        await FactorySessionStore.shared.clearSession()
+    }
+
+    @Test
+    func `preserves stored Factory refresh token when stored cookies are not logged in`() async throws {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
         let registered = URLProtocol.registerClass(FactoryStubURLProtocol.self)
         defer {
             if registered {
                 URLProtocol.unregisterClass(FactoryStubURLProtocol.self)
             }
             FactoryStubURLProtocol.handler = nil
+            FactoryStubURLProtocol.requests = []
         }
+        FactoryStubURLProtocol.requests = []
+
+        FactoryStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            if url.host == "app.factory.ai", url.path == "/api/app/auth/me" {
+                return Self.makeResponse(url: url, body: "{}", statusCode: 401)
+            }
+            if url.host == "api.factory.ai",
+               url.path == "/api/app/auth/me",
+               request.value(forHTTPHeaderField: "Cookie")?.contains("stale-session") == true
+            {
+                return Self.makeResponse(url: url, body: "{}", statusCode: 401)
+            }
+            if url.host == "api.workos.com", url.path == "/user_management/authenticate" {
+                let requestBody = try Self.requestJSONBody(from: request)
+                guard requestBody["refresh_token"] as? String == "stale-refresh" else {
+                    throw URLError(.userAuthenticationRequired)
+                }
+                let body = """
+                {
+                  "access_token": "fresh-access",
+                  "refresh_token": "fresh-refresh"
+                }
+                """
+                return Self.makeResponse(url: url, body: body)
+            }
+            if url.host == "api.factory.ai", url.path == "/api/app/auth/me" {
+                let body = """
+                {
+                  "organization": {
+                    "id": "org_1",
+                    "name": "Acme",
+                    "subscription": {
+                      "factoryTier": "team",
+                      "orbSubscription": {
+                        "plan": { "name": "Team", "id": "plan_1" },
+                        "status": "active"
+                      }
+                    }
+                  }
+                }
+                """
+                return Self.makeResponse(url: url, body: body)
+            }
+            if url.host == "api.factory.ai", url.path == "/api/organization/subscription/usage" {
+                let body = """
+                {
+                  "usage": {
+                    "standard": {
+                      "userTokens": 100,
+                      "totalAllowance": 1000
+                    }
+                  },
+                  "userId": "user-1"
+                }
+                """
+                return Self.makeResponse(url: url, body: body)
+            }
+            return Self.makeResponse(url: url, body: "{}", statusCode: 404)
+        }
+
+        let cookie = try #require(HTTPCookie(properties: [
+            .domain: "app.factory.ai",
+            .path: "/",
+            .name: "session",
+            .value: "stale-session",
+        ]))
+
+        let sessionFile = try await Self.isolateFactorySessionStore()
+        defer {
+            try? FileManager.default.removeItem(at: sessionFile)
+        }
+
+        await FactorySessionStore.shared.clearSession()
+        CookieHeaderCache.store(provider: .factory, cookieHeader: "session=stale-cache", sourceLabel: "Chrome")
+        await FactorySessionStore.shared.setCookies([cookie])
+        await FactorySessionStore.shared.setRefreshToken("stale-refresh")
+        await FactorySessionStore.shared.resetInMemoryForTesting()
+        defer {
+            CookieHeaderCache.clear(provider: .factory)
+        }
+
+        let probe = FactoryStatusProbe(
+            timeout: 1.0,
+            browserDetection: BrowserDetection(
+                homeDirectory: "/tmp/codexbar-empty-browser-home",
+                cacheTTL: 0,
+                fileExists: { _ in false },
+                directoryContents: { _ in nil }),
+            transport: FactoryStubTransport())
+
+        let snapshot = try await probe.fetch()
+
+        #expect(CookieHeaderCache.load(provider: .factory) == nil)
+        #expect(snapshot.userId == "user-1")
+        #expect(await FactorySessionStore.shared.getCookies().isEmpty)
+        #expect(await FactorySessionStore.shared.getBearerToken() == "fresh-access")
+        #expect(await FactorySessionStore.shared.getRefreshToken() == "fresh-refresh")
+        #expect(Self.requestTrace() == [
+            "GET app.factory.ai/api/app/auth/me",
+            "GET api.factory.ai/api/app/auth/me",
+            "GET app.factory.ai/api/app/auth/me",
+            "POST api.workos.com/user_management/authenticate",
+            "GET api.factory.ai/api/app/auth/me",
+            "GET api.factory.ai/api/billing/limits",
+            "GET api.factory.ai/api/organization/subscription/usage?useCache=true",
+        ])
+        await FactorySessionStore.shared.clearSession()
+    }
+
+    @Test
+    func `fetches snapshot using cookie header override`() async throws {
+        let registered = URLProtocol.registerClass(FactoryStubURLProtocol.self)
+        defer {
+            if registered {
+                URLProtocol.unregisterClass(FactoryStubURLProtocol.self)
+            }
+            FactoryStubURLProtocol.handler = nil
+            FactoryStubURLProtocol.requests = []
+        }
+        FactoryStubURLProtocol.requests = []
 
         FactoryStubURLProtocol.handler = { request in
             guard let url = request.url else { throw URLError(.badURL) }
@@ -78,6 +304,385 @@ struct FactoryStatusProbeFetchTests {
         #expect(usage.secondary?.usedPercent == 10)
     }
 
+    @Test
+    func `uses bearer subject when auth profile omits user id`() async throws {
+        let registered = URLProtocol.registerClass(FactoryStubURLProtocol.self)
+        defer {
+            if registered {
+                URLProtocol.unregisterClass(FactoryStubURLProtocol.self)
+            }
+            FactoryStubURLProtocol.handler = nil
+            FactoryStubURLProtocol.requests = []
+        }
+        FactoryStubURLProtocol.requests = []
+
+        FactoryStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            if url.path == "/api/app/auth/me" {
+                let body = """
+                {
+                  "organization": {
+                    "id": "org_1",
+                    "name": "Acme",
+                    "subscription": {
+                      "factoryTier": "team",
+                      "orbSubscription": {
+                        "plan": { "name": "Team", "id": "plan_1" },
+                        "status": "active"
+                      }
+                    }
+                  },
+                  "userProfile": {
+                    "email": "user@example.com",
+                    "role": "member"
+                  }
+                }
+                """
+                return Self.makeResponse(url: url, body: body)
+            }
+            if url.host == "api.factory.ai", url.path == "/api/billing/limits" {
+                return Self.makeResponse(url: url, body: "{}", statusCode: 404)
+            }
+            if url.path == "/api/organization/subscription/usage" {
+                guard URLComponents(url: url, resolvingAgainstBaseURL: false)?
+                    .queryItems?
+                    .contains(where: { $0.name == "userId" && $0.value == "user_jwt" }) == true
+                else {
+                    return Self.makeResponse(
+                        url: url,
+                        body: #"{"detail":"Must be manager to get usage for other users"}"#,
+                        statusCode: 403)
+                }
+                let body = """
+                {
+                  "usage": {
+                    "standard": {
+                      "userTokens": 100,
+                      "totalAllowance": 1000,
+                      "usedRatio": 0.10
+                    }
+                  },
+                  "userId": "user_jwt"
+                }
+                """
+                return Self.makeResponse(url: url, body: body)
+            }
+            return Self.makeResponse(url: url, body: "{}", statusCode: 404)
+        }
+
+        let token = Self.makeJWT(payload: ["sub": "user_jwt"])
+        let probe = FactoryStatusProbe(browserDetection: BrowserDetection(cacheTTL: 0))
+        let snapshot = try await probe.fetch(cookieHeaderOverride: "access-token=\(token); session=abc")
+
+        #expect(snapshot.userId == "user_jwt")
+        #expect(snapshot.standardUserTokens == 100)
+        #expect(Self.requestTrace() == [
+            "GET app.factory.ai/api/app/auth/me",
+            "GET api.factory.ai/api/billing/limits",
+            "GET app.factory.ai/api/organization/subscription/usage?useCache=true&userId=user_jwt",
+        ])
+    }
+
+    @Test
+    func `falls back to legacy usage when billing limits request fails`() async throws {
+        let registered = URLProtocol.registerClass(FactoryStubURLProtocol.self)
+        defer {
+            if registered {
+                URLProtocol.unregisterClass(FactoryStubURLProtocol.self)
+            }
+            FactoryStubURLProtocol.handler = nil
+            FactoryStubURLProtocol.requests = []
+        }
+        FactoryStubURLProtocol.requests = []
+
+        FactoryStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            if url.path == "/api/app/auth/me" {
+                let body = """
+                {
+                  "organization": {
+                    "id": "org_1",
+                    "name": "Acme",
+                    "subscription": {
+                      "factoryTier": "team",
+                      "orbSubscription": {
+                        "plan": { "name": "Team", "id": "plan_1" },
+                        "status": "active"
+                      }
+                    }
+                  }
+                }
+                """
+                return Self.makeResponse(url: url, body: body)
+            }
+            if url.host == "api.factory.ai", url.path == "/api/billing/limits" {
+                throw URLError(.timedOut)
+            }
+            if url.path == "/api/organization/subscription/usage" {
+                let body = """
+                {
+                  "usage": {
+                    "standard": {
+                      "userTokens": 100,
+                      "totalAllowance": 1000,
+                      "usedRatio": 0.10
+                    },
+                    "premium": {
+                      "userTokens": 20,
+                      "totalAllowance": 100,
+                      "usedRatio": 0.20
+                    }
+                  },
+                  "userId": "user-1"
+                }
+                """
+                return Self.makeResponse(url: url, body: body)
+            }
+            return Self.makeResponse(url: url, body: "{}", statusCode: 404)
+        }
+
+        let probe = FactoryStatusProbe(browserDetection: BrowserDetection(cacheTTL: 0))
+        let snapshot = try await probe.fetch(cookieHeaderOverride: "access-token=test.jwt.token; session=abc")
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(snapshot.tokenRateLimits == nil)
+        #expect(usage.primary?.usedPercent == 10)
+        #expect(usage.secondary?.usedPercent == 20)
+        #expect(Self.requestTrace() == [
+            "GET app.factory.ai/api/app/auth/me",
+            "GET api.factory.ai/api/billing/limits",
+            "GET app.factory.ai/api/organization/subscription/usage?useCache=true",
+        ])
+    }
+
+    @Test
+    func `falls back to legacy usage when billing limits rejects auth`() async throws {
+        let registered = URLProtocol.registerClass(FactoryStubURLProtocol.self)
+        defer {
+            if registered {
+                URLProtocol.unregisterClass(FactoryStubURLProtocol.self)
+            }
+            FactoryStubURLProtocol.handler = nil
+            FactoryStubURLProtocol.requests = []
+        }
+        FactoryStubURLProtocol.requests = []
+
+        FactoryStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            if url.path == "/api/app/auth/me" {
+                let body = """
+                {
+                  "organization": {
+                    "id": "org_1",
+                    "name": "Acme",
+                    "subscription": {
+                      "factoryTier": "team",
+                      "orbSubscription": {
+                        "plan": { "name": "Team", "id": "plan_1" },
+                        "status": "active"
+                      }
+                    }
+                  }
+                }
+                """
+                return Self.makeResponse(url: url, body: body)
+            }
+            if url.host == "api.factory.ai", url.path == "/api/billing/limits" {
+                return Self.makeResponse(url: url, body: "{}", statusCode: 403)
+            }
+            if url.path == "/api/organization/subscription/usage" {
+                let body = """
+                {
+                  "usage": {
+                    "standard": {
+                      "userTokens": 100,
+                      "totalAllowance": 1000,
+                      "usedRatio": 0.10
+                    },
+                    "premium": {
+                      "userTokens": 20,
+                      "totalAllowance": 100,
+                      "usedRatio": 0.20
+                    }
+                  },
+                  "userId": "user-1"
+                }
+                """
+                return Self.makeResponse(url: url, body: body)
+            }
+            return Self.makeResponse(url: url, body: "{}", statusCode: 404)
+        }
+
+        let probe = FactoryStatusProbe(browserDetection: BrowserDetection(cacheTTL: 0))
+        let snapshot = try await probe.fetch(cookieHeaderOverride: "access-token=test.jwt.token; session=abc")
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(snapshot.tokenRateLimits == nil)
+        #expect(usage.primary?.usedPercent == 10)
+        #expect(usage.secondary?.usedPercent == 20)
+        #expect(Self.requestTrace() == [
+            "GET app.factory.ai/api/app/auth/me",
+            "GET api.factory.ai/api/billing/limits",
+            "GET app.factory.ai/api/organization/subscription/usage?useCache=true",
+        ])
+    }
+
+    @Test
+    func `uses token rate limits billing when core pool is absent`() async throws {
+        let registered = URLProtocol.registerClass(FactoryStubURLProtocol.self)
+        defer {
+            if registered {
+                URLProtocol.unregisterClass(FactoryStubURLProtocol.self)
+            }
+            FactoryStubURLProtocol.handler = nil
+            FactoryStubURLProtocol.requests = []
+        }
+        FactoryStubURLProtocol.requests = []
+
+        FactoryStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            if url.path == "/api/app/auth/me" {
+                let body = """
+                {
+                  "organization": {
+                    "id": "org_1",
+                    "name": "Acme",
+                    "subscription": {
+                      "factoryTier": "team",
+                      "orbSubscription": {
+                        "plan": { "name": "Team", "id": "plan_1" },
+                        "status": "active"
+                      }
+                    }
+                  }
+                }
+                """
+                return Self.makeResponse(url: url, body: body)
+            }
+            if url.host == "api.factory.ai", url.path == "/api/billing/limits" {
+                let body = """
+                {
+                  "usesTokenRateLimitsBilling": true,
+                  "extraUsageBalanceCents": 2500,
+                  "overagePreference": null,
+                  "extraUsageAllowed": false,
+                  "tokenRateLimitsRolloutEligible": true,
+                  "limits": {
+                    "standard": {
+                      "fiveHour": { "usedPercent": 12, "secondsRemaining": 3600 },
+                      "weekly": { "usedPercent": 34, "secondsRemaining": 7200 },
+                      "monthly": { "usedPercent": 56, "secondsRemaining": 10800 }
+                    }
+                  }
+                }
+                """
+                return Self.makeResponse(url: url, body: body)
+            }
+            if url.path == "/api/organization/subscription/usage" {
+                return Self.makeResponse(url: url, body: "{}", statusCode: 500)
+            }
+            return Self.makeResponse(url: url, body: "{}", statusCode: 404)
+        }
+
+        let probe = FactoryStatusProbe(browserDetection: BrowserDetection(cacheTTL: 0))
+        let snapshot = try await probe.fetch(cookieHeaderOverride: "access-token=test.jwt.token; session=abc")
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(snapshot.tokenRateLimits != nil)
+        #expect(usage.primary?.usedPercent == 12)
+        #expect(usage.secondary?.usedPercent == 34)
+        #expect(usage.tertiary?.usedPercent == 56)
+        #expect(usage.extraRateWindows == nil)
+        #expect(usage.providerCost?.used == 25)
+        #expect(Self.requestTrace() == [
+            "GET app.factory.ai/api/app/auth/me",
+            "GET api.factory.ai/api/billing/limits",
+        ])
+    }
+
+    @Test
+    func `uses token rate limits billing when enabled`() async throws {
+        let registered = URLProtocol.registerClass(FactoryStubURLProtocol.self)
+        defer {
+            if registered {
+                URLProtocol.unregisterClass(FactoryStubURLProtocol.self)
+            }
+            FactoryStubURLProtocol.handler = nil
+            FactoryStubURLProtocol.requests = []
+        }
+        FactoryStubURLProtocol.requests = []
+
+        FactoryStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            if url.path == "/api/app/auth/me" {
+                let body = """
+                {
+                  "organization": {
+                    "id": "org_1",
+                    "name": "Acme",
+                    "subscription": {
+                      "factoryTier": "team",
+                      "orbSubscription": {
+                        "plan": { "name": "Team", "id": "plan_1" },
+                        "status": "active"
+                      }
+                    }
+                  }
+                }
+                """
+                return Self.makeResponse(url: url, body: body)
+            }
+            if url.host == "api.factory.ai", url.path == "/api/billing/limits" {
+                let body = """
+                {
+                  "usesTokenRateLimitsBilling": true,
+                  "extraUsageBalanceCents": 2500,
+                  "overagePreference": "core",
+                  "extraUsageAllowed": true,
+                  "tokenRateLimitsRolloutEligible": true,
+                  "limits": {
+                    "standard": {
+                      "fiveHour": { "usedPercent": 12, "secondsRemaining": 3600 },
+                      "weekly": { "usedPercent": 34, "secondsRemaining": 7200 },
+                      "monthly": { "usedPercent": 56, "secondsRemaining": 10800 }
+                    },
+                    "core": {
+                      "fiveHour": { "usedPercent": 7, "secondsRemaining": 1800 },
+                      "weekly": { "usedPercent": 8, "secondsRemaining": 2800 },
+                      "monthly": { "usedPercent": 9, "secondsRemaining": 3800 }
+                    }
+                  }
+                }
+                """
+                return Self.makeResponse(url: url, body: body)
+            }
+            if url.path == "/api/organization/subscription/usage" {
+                return Self.makeResponse(url: url, body: "{}", statusCode: 500)
+            }
+            return Self.makeResponse(url: url, body: "{}", statusCode: 404)
+        }
+
+        let probe = FactoryStatusProbe(browserDetection: BrowserDetection(cacheTTL: 0))
+        let snapshot = try await probe.fetch(cookieHeaderOverride: "access-token=test.jwt.token; session=abc")
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(snapshot.tokenRateLimits != nil)
+        #expect(usage.primary?.usedPercent == 12)
+        #expect(usage.primary?.windowMinutes == 300)
+        #expect(usage.secondary?.usedPercent == 34)
+        #expect(usage.secondary?.windowMinutes == 10080)
+        #expect(usage.tertiary?.usedPercent == 56)
+        #expect(usage.extraRateWindows?.map(\.id) == ["factory-core-5h", "factory-core-7d", "factory-core-monthly"])
+        #expect(usage.extraRateWindows?.first?.window.usedPercent == 7)
+        #expect(usage.providerCost?.used == 25)
+        #expect(usage.providerCost?.limit == 0)
+        #expect(usage.loginMethod(for: .factory) == "Factory Team - Team - Fallback: core")
+        #expect(Self.requestTrace() == [
+            "GET app.factory.ai/api/app/auth/me",
+            "GET api.factory.ai/api/billing/limits",
+        ])
+    }
+
     private static func makeResponse(
         url: URL,
         body: String,
@@ -90,10 +695,73 @@ struct FactoryStatusProbeFetchTests {
             headerFields: ["Content-Type": "application/json"])!
         return (response, Data(body.utf8))
     }
+
+    private static func makeJWT(payload: [String: Any]) -> String {
+        func base64URL(_ data: Data) -> String {
+            data.base64EncodedString()
+                .replacingOccurrences(of: "=", with: "")
+                .replacingOccurrences(of: "+", with: "-")
+                .replacingOccurrences(of: "/", with: "_")
+        }
+
+        let header = ["alg": "none", "typ": "JWT"]
+        let headerData = (try? JSONSerialization.data(withJSONObject: header)) ?? Data()
+        let payloadData = (try? JSONSerialization.data(withJSONObject: payload)) ?? Data()
+        return "\(base64URL(headerData)).\(base64URL(payloadData))."
+    }
+
+    private static func requestTrace() -> [String] {
+        FactoryStubURLProtocol.requests.compactMap { request in
+            guard let url = request.url else { return nil }
+            let query = url.query.map { "?\($0)" } ?? ""
+            return "\(request.httpMethod ?? "?") \(url.host ?? "unknown")\(url.path)\(query)"
+        }
+    }
+
+    private static func isolateFactorySessionStore() async throws -> URL {
+        let directory = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-factory-tests", isDirectory: true)
+        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+        let fileURL = directory.appendingPathComponent("\(UUID().uuidString).json")
+        await FactorySessionStore.shared.useFileURLForTesting(fileURL)
+        return fileURL
+    }
+
+    private static func requestJSONBody(from request: URLRequest) throws -> [String: Any] {
+        let data = try self.requestBodyData(from: request)
+        return try #require(JSONSerialization.jsonObject(with: data) as? [String: Any])
+    }
+
+    private static func requestBodyData(from request: URLRequest) throws -> Data {
+        if let body = request.httpBody {
+            return body
+        }
+        guard let stream = request.httpBodyStream else {
+            throw URLError(.badServerResponse)
+        }
+
+        stream.open()
+        defer { stream.close() }
+
+        var data = Data()
+        var buffer = [UInt8](repeating: 0, count: 1024)
+        while stream.hasBytesAvailable {
+            let count = stream.read(&buffer, maxLength: buffer.count)
+            if count < 0 {
+                throw stream.streamError ?? URLError(.cannotDecodeRawData)
+            }
+            if count == 0 {
+                break
+            }
+            data.append(buffer, count: count)
+        }
+        return data
+    }
 }
 
 final class FactoryStubURLProtocol: URLProtocol {
     nonisolated(unsafe) static var handler: ((URLRequest) throws -> (HTTPURLResponse, Data))?
+    nonisolated(unsafe) static var requests: [URLRequest] = []
 
     override static func canInit(with request: URLRequest) -> Bool {
         guard let host = request.url?.host else { return false }
@@ -110,6 +778,7 @@ final class FactoryStubURLProtocol: URLProtocol {
             return
         }
         do {
+            Self.requests.append(self.request)
             let (response, data) = try handler(self.request)
             self.client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
             self.client?.urlProtocol(self, didLoad: data)
@@ -121,3 +790,14 @@ final class FactoryStubURLProtocol: URLProtocol {
 
     override func stopLoading() {}
 }
+
+private struct FactoryStubTransport: ProviderHTTPTransport {
+    func data(for request: URLRequest) async throws -> (Data, URLResponse) {
+        guard let handler = FactoryStubURLProtocol.handler else {
+            throw URLError(.badServerResponse)
+        }
+        FactoryStubURLProtocol.requests.append(request)
+        let (response, data) = try handler(request)
+        return (data, response)
+    }
+}
diff --git a/Tests/CodexBarTests/FactoryStatusProbeTests.swift b/Tests/CodexBarTests/FactoryStatusProbeTests.swift
index f9aa8fe0b3..f5481d074b 100644
--- a/Tests/CodexBarTests/FactoryStatusProbeTests.swift
+++ b/Tests/CodexBarTests/FactoryStatusProbeTests.swift
@@ -2,10 +2,21 @@ import Foundation
 import Testing
 @testable import CodexBarCore
 
-@Suite
+struct FactoryProviderDescriptorTests {
+    @Test
+    func `descriptor keeps legacy labels by default`() {
+        let metadata = FactoryProviderDescriptor.descriptor.metadata
+
+        #expect(metadata.sessionLabel == "Standard")
+        #expect(metadata.weeklyLabel == "Premium")
+        #expect(metadata.opusLabel == nil)
+        #expect(!metadata.supportsOpus)
+    }
+}
+
 struct FactoryStatusSnapshotTests {
     @Test
-    func mapsUsageSnapshotWindowsAndLoginMethod() {
+    func `maps usage snapshot windows and login method`() {
         let periodEnd = Date(timeIntervalSince1970: 1_738_368_000) // Feb 1, 2025
         let snapshot = FactoryStatusSnapshot(
             standardUserTokens: 50,
@@ -33,7 +44,7 @@ struct FactoryStatusSnapshotTests {
     }
 
     @Test
-    func treatsLargeAllowancesAsUnlimited() {
+    func `treats large allowances as unlimited`() {
         let snapshot = FactoryStatusSnapshot(
             standardUserTokens: 50_000_000,
             standardOrgTokens: 0,
@@ -56,7 +67,7 @@ struct FactoryStatusSnapshotTests {
     }
 
     @Test
-    func prefersAPIUsedRatioWhenAllowanceMissing() {
+    func `prefers API used ratio when allowance missing`() {
         let snapshot = FactoryStatusSnapshot(
             standardUserTokens: 72_311_737,
             standardOrgTokens: 72_311_737,
@@ -82,7 +93,7 @@ struct FactoryStatusSnapshotTests {
     }
 
     @Test
-    func usesPercentScaleRatioWhenAllowanceMissing() {
+    func `uses percent scale ratio when allowance missing`() {
         let snapshot = FactoryStatusSnapshot(
             standardUserTokens: 0,
             standardOrgTokens: 0,
@@ -107,7 +118,34 @@ struct FactoryStatusSnapshotTests {
     }
 
     @Test
-    func fallsBackToCalculationWhenAPIRatioMissing() {
+    func `falls back to calculation when API ratio is zero but usage and allowance are present`() {
+        let snapshot = FactoryStatusSnapshot(
+            standardUserTokens: 5_826_293,
+            standardOrgTokens: 0,
+            standardAllowance: 20_000_000,
+            standardUsedRatio: 0,
+            premiumUserTokens: 0,
+            premiumOrgTokens: 0,
+            premiumAllowance: 0,
+            premiumUsedRatio: 0,
+            periodStart: nil,
+            periodEnd: nil,
+            planName: nil,
+            tier: nil,
+            organizationName: nil,
+            accountEmail: nil,
+            userId: nil,
+            rawJSON: nil)
+
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.primary?.usedPercent ?? 0 > 29)
+        #expect(usage.primary?.usedPercent ?? 0 < 30)
+        #expect(usage.secondary?.usedPercent == 0)
+    }
+
+    @Test
+    func `falls back to calculation when API ratio missing`() {
         let snapshot = FactoryStatusSnapshot(
             standardUserTokens: 50_000_000,
             standardOrgTokens: 0,
@@ -132,7 +170,7 @@ struct FactoryStatusSnapshotTests {
     }
 
     @Test
-    func fallsBackWhenAPIRatioIsInvalid() {
+    func `falls back when API ratio is invalid`() {
         let snapshot = FactoryStatusSnapshot(
             standardUserTokens: 50_000_000,
             standardOrgTokens: 0,
@@ -157,7 +195,7 @@ struct FactoryStatusSnapshotTests {
     }
 
     @Test
-    func clampsSlightlyOutOfRangeRatios() {
+    func `clamps slightly out of range ratios`() {
         let snapshot = FactoryStatusSnapshot(
             standardUserTokens: 100_000_000,
             standardOrgTokens: 0,
@@ -182,10 +220,9 @@ struct FactoryStatusSnapshotTests {
     }
 }
 
-@Suite
 struct FactoryStatusProbeWorkOSTests {
     @Test
-    func detectsMissingRefreshTokenPayload() {
+    func `detects missing refresh token payload`() {
         let payload = Data("""
         {"error":"invalid_request","error_description":"Missing refresh token."}
         """.utf8)
diff --git a/Tests/CodexBarTests/Fixtures/Providers/Claude/weekly-limit.json b/Tests/CodexBarTests/Fixtures/Providers/Claude/weekly-limit.json
new file mode 100644
index 0000000000..89beecb8e3
--- /dev/null
+++ b/Tests/CodexBarTests/Fixtures/Providers/Claude/weekly-limit.json
@@ -0,0 +1,8 @@
+{
+  "ok": true,
+  "account_email": "user@example.com",
+  "login_method": "Claude Max",
+  "session_5h": { "pct_used": 7, "resets": "11am (Europe/Vienna)" },
+  "week_all_models": { "pct_used": 21, "resets": "Nov 21 at 5am (Europe/Vienna)" },
+  "week_sonnet": { "pct_used": 3, "resets": "Nov 21 at 5am (Europe/Vienna)" }
+}
diff --git a/Tests/CodexBarTests/Fixtures/Providers/MiniMax/token-plan-missing-reset.json b/Tests/CodexBarTests/Fixtures/Providers/MiniMax/token-plan-missing-reset.json
new file mode 100644
index 0000000000..dd055a6b42
--- /dev/null
+++ b/Tests/CodexBarTests/Fixtures/Providers/MiniMax/token-plan-missing-reset.json
@@ -0,0 +1,17 @@
+{
+  "base_resp": { "status_code": 0, "status_msg": "success" },
+  "data": {
+    "current_subscribe_title": "Token Plan Plus",
+    "model_remains": [
+      {
+        "model_name": "general",
+        "current_interval_total_count": 100,
+        "current_interval_usage_count": 25,
+        "current_interval_remaining_percent": 75,
+        "current_weekly_total_count": 100,
+        "current_weekly_usage_count": 40,
+        "current_weekly_remaining_percent": 60
+      }
+    ]
+  }
+}
diff --git a/Tests/CodexBarTests/Fixtures/Providers/MiniMax/token-plan-normal.json b/Tests/CodexBarTests/Fixtures/Providers/MiniMax/token-plan-normal.json
new file mode 100644
index 0000000000..1401c2386a
--- /dev/null
+++ b/Tests/CodexBarTests/Fixtures/Providers/MiniMax/token-plan-normal.json
@@ -0,0 +1,22 @@
+{
+  "base_resp": { "status_code": 0, "status_msg": "success" },
+  "data": {
+    "current_subscribe_title": "Token Plan Plus",
+    "points_balance": "14000",
+    "model_remains": [
+      {
+        "model_name": "general",
+        "current_interval_total_count": 0,
+        "current_interval_usage_count": 0,
+        "current_interval_remaining_percent": "96",
+        "start_time": 1780279200000,
+        "end_time": 1780297200000,
+        "current_weekly_total_count": 0,
+        "current_weekly_usage_count": 0,
+        "current_weekly_remaining_percent": "99",
+        "weekly_start_time": 1780243200000,
+        "weekly_end_time": 1780848000000
+      }
+    ]
+  }
+}
diff --git a/Tests/CodexBarTests/Fixtures/Providers/OpenAI/pro-normal.html b/Tests/CodexBarTests/Fixtures/Providers/OpenAI/pro-normal.html
new file mode 100644
index 0000000000..0e05f39c78
--- /dev/null
+++ b/Tests/CodexBarTests/Fixtures/Providers/OpenAI/pro-normal.html
@@ -0,0 +1,16 @@
+<html>
+<body>
+<script type="application/json" id="client-bootstrap">
+{"session":{"user":{"email":"user@example.com"}},"planType":"prolite"}
+</script>
+<main>
+Usage limits
+5h limit
+72% remaining
+Resets today at 2:15 PM
+Weekly limit
+41% remaining
+Resets Fri at 9:00 AM
+</main>
+</body>
+</html>
diff --git a/Tests/CodexBarTests/Fixtures/codex-historical-usage-real-legacy.jsonl b/Tests/CodexBarTests/Fixtures/codex-historical-usage-real-legacy.jsonl
new file mode 100644
index 0000000000..24c52e180c
--- /dev/null
+++ b/Tests/CodexBarTests/Fixtures/codex-historical-usage-real-legacy.jsonl
@@ -0,0 +1,6 @@
+{"accountKey":"d12264663b6c957df161c4eaa04268ee1eba54730fc206d6d1530a333fbc1bf5","provider":"codex","resetsAt":"2026-02-17T05:37:00Z","sampledAt":"2026-02-10T05:37:00Z","source":"backfill","usedPercent":0,"v":1,"windowKind":"secondary","windowMinutes":10080}
+{"accountKey":"d12264663b6c957df161c4eaa04268ee1eba54730fc206d6d1530a333fbc1bf5","provider":"codex","resetsAt":"2026-02-17T05:37:00Z","sampledAt":"2026-02-10T17:37:00Z","source":"backfill","usedPercent":15.888694315201283,"v":1,"windowKind":"secondary","windowMinutes":10080}
+{"accountKey":"d12264663b6c957df161c4eaa04268ee1eba54730fc206d6d1530a333fbc1bf5","provider":"codex","resetsAt":"2026-02-17T05:37:00Z","sampledAt":"2026-02-11T05:37:00Z","source":"backfill","usedPercent":36.46543073970202,"v":1,"windowKind":"secondary","windowMinutes":10080}
+{"accountKey":"d12264663b6c957df161c4eaa04268ee1eba54730fc206d6d1530a333fbc1bf5","provider":"codex","resetsAt":"2026-02-17T05:37:00Z","sampledAt":"2026-02-16T05:37:00Z","source":"backfill","usedPercent":100,"v":1,"windowKind":"secondary","windowMinutes":10080}
+{"accountKey":"d12264663b6c957df161c4eaa04268ee1eba54730fc206d6d1530a333fbc1bf5","provider":"codex","resetsAt":"2026-02-17T05:37:00Z","sampledAt":"2026-02-16T17:37:00Z","source":"backfill","usedPercent":100,"v":1,"windowKind":"secondary","windowMinutes":10080}
+{"accountKey":"d12264663b6c957df161c4eaa04268ee1eba54730fc206d6d1530a333fbc1bf5","provider":"codex","resetsAt":"2026-02-17T05:37:00Z","sampledAt":"2026-02-17T05:37:00Z","source":"backfill","usedPercent":100,"v":1,"windowKind":"secondary","windowMinutes":10080}
diff --git a/Tests/CodexBarTests/Fixtures/codex-plan-utilization-real-migration.json b/Tests/CodexBarTests/Fixtures/codex-plan-utilization-real-migration.json
new file mode 100644
index 0000000000..0b52361658
--- /dev/null
+++ b/Tests/CodexBarTests/Fixtures/codex-plan-utilization-real-migration.json
@@ -0,0 +1,211 @@
+{
+  "version": 1,
+  "preferredAccountKey": "codex:v1:provider-account:0c2a5eef-a612-45bb-9796-9aa83ce1bed7",
+  "unscoped": [],
+  "accounts": {
+    "3e31a7fdc57ea26c62fd7061d25dcab74a91b0da2d8f514b07e99aad800ee897": [
+      {
+        "name": "session",
+        "windowMinutes": 300,
+        "entries": [
+          {
+            "capturedAt": "2026-03-23T09:55:44Z",
+            "resetsAt": "2026-03-23T10:28:16Z",
+            "usedPercent": 9
+          },
+          {
+            "capturedAt": "2026-03-23T10:27:49Z",
+            "resetsAt": "2026-03-23T10:28:16Z",
+            "usedPercent": 13
+          },
+          {
+            "capturedAt": "2026-04-01T07:07:28Z",
+            "resetsAt": "2026-04-01T12:07:28Z",
+            "usedPercent": 0
+          },
+          {
+            "capturedAt": "2026-04-01T07:59:25Z",
+            "resetsAt": "2026-04-01T12:57:12Z",
+            "usedPercent": 0
+          },
+          {
+            "capturedAt": "2026-04-01T08:30:22Z",
+            "resetsAt": "2026-04-01T12:57:12Z",
+            "usedPercent": 6
+          }
+        ]
+      },
+      {
+        "name": "weekly",
+        "windowMinutes": 10080,
+        "entries": [
+          {
+            "capturedAt": "2026-03-23T09:55:44Z",
+            "resetsAt": "2026-03-25T17:41:02Z",
+            "usedPercent": 51
+          },
+          {
+            "capturedAt": "2026-03-23T10:54:47Z",
+            "resetsAt": "2026-03-25T17:41:02Z",
+            "usedPercent": 53
+          },
+          {
+            "capturedAt": "2026-03-23T11:59:59Z",
+            "resetsAt": "2026-03-25T17:41:02Z",
+            "usedPercent": 53
+          },
+          {
+            "capturedAt": "2026-04-01T07:43:34Z",
+            "resetsAt": "2026-04-03T05:42:22Z",
+            "usedPercent": 62
+          },
+          {
+            "capturedAt": "2026-04-01T07:59:25Z",
+            "resetsAt": "2026-04-08T07:57:12Z",
+            "usedPercent": 0
+          },
+          {
+            "capturedAt": "2026-04-01T08:30:22Z",
+            "resetsAt": "2026-04-08T07:57:12Z",
+            "usedPercent": 2
+          }
+        ]
+      }
+    ],
+    "ae933d834c92219543c3f3ee7d5117b129f89174b6c47b2ab793df968f3616f4": [
+      {
+        "name": "weekly",
+        "windowMinutes": 10080,
+        "entries": [
+          {
+            "capturedAt": "2026-03-28T06:50:16Z",
+            "resetsAt": "2026-04-02T20:34:15Z",
+            "usedPercent": 1
+          },
+          {
+            "capturedAt": "2026-03-29T13:32:29Z",
+            "resetsAt": "2026-04-02T20:34:15Z",
+            "usedPercent": 1
+          },
+          {
+            "capturedAt": "2026-03-29T14:45:59Z",
+            "resetsAt": "2026-04-02T20:34:15Z",
+            "usedPercent": 1
+          },
+          {
+            "capturedAt": "2026-03-31T13:49:22Z",
+            "resetsAt": "2026-04-02T20:34:16Z",
+            "usedPercent": 1
+          },
+          {
+            "capturedAt": "2026-03-31T16:58:41Z",
+            "resetsAt": "2026-04-02T20:34:15Z",
+            "usedPercent": 1
+          },
+          {
+            "capturedAt": "2026-03-31T17:07:31Z",
+            "resetsAt": "2026-04-02T20:34:15Z",
+            "usedPercent": 1
+          }
+        ]
+      }
+    ],
+    "codex:v1:email-hash:e0905a26346930c615f5517913dad1a23312d882159719fbc429819216ff42b2": [
+      {
+        "name": "session",
+        "windowMinutes": 300,
+        "entries": [
+          {
+            "capturedAt": "2026-03-29T16:53:28Z",
+            "usedPercent": 18
+          },
+          {
+            "capturedAt": "2026-03-29T17:24:28Z",
+            "usedPercent": 18
+          },
+          {
+            "capturedAt": "2026-04-01T15:03:43Z",
+            "usedPercent": 10
+          },
+          {
+            "capturedAt": "2026-04-01T16:37:42Z",
+            "usedPercent": 10
+          },
+          {
+            "capturedAt": "2026-04-01T19:49:10Z",
+            "usedPercent": 10
+          }
+        ]
+      }
+    ],
+    "codex:v1:provider-account:0c2a5eef-a612-45bb-9796-9aa83ce1bed7": [
+      {
+        "name": "session",
+        "windowMinutes": 300,
+        "entries": [
+          {
+            "capturedAt": "2026-04-01T08:58:21Z",
+            "resetsAt": "2026-04-01T12:57:13Z",
+            "usedPercent": 6
+          },
+          {
+            "capturedAt": "2026-04-01T09:54:18Z",
+            "resetsAt": "2026-04-01T12:57:13Z",
+            "usedPercent": 8
+          },
+          {
+            "capturedAt": "2026-04-01T18:58:52Z",
+            "resetsAt": "2026-04-01T22:57:27Z",
+            "usedPercent": 4
+          },
+          {
+            "capturedAt": "2026-04-01T19:44:58Z",
+            "resetsAt": "2026-04-01T22:57:27Z",
+            "usedPercent": 8
+          },
+          {
+            "capturedAt": "2026-04-01T20:33:41Z",
+            "resetsAt": "2026-04-01T22:57:27Z",
+            "usedPercent": 10
+          }
+        ]
+      },
+      {
+        "name": "weekly",
+        "windowMinutes": 10080,
+        "entries": [
+          {
+            "capturedAt": "2026-04-01T08:58:21Z",
+            "resetsAt": "2026-04-08T07:57:13Z",
+            "usedPercent": 2
+          },
+          {
+            "capturedAt": "2026-04-01T09:54:18Z",
+            "resetsAt": "2026-04-08T07:57:13Z",
+            "usedPercent": 2
+          },
+          {
+            "capturedAt": "2026-04-01T10:54:30Z",
+            "resetsAt": "2026-04-08T07:57:12Z",
+            "usedPercent": 3
+          },
+          {
+            "capturedAt": "2026-04-01T18:58:52Z",
+            "resetsAt": "2026-04-08T07:57:12Z",
+            "usedPercent": 10
+          },
+          {
+            "capturedAt": "2026-04-01T19:44:58Z",
+            "resetsAt": "2026-04-08T07:57:13Z",
+            "usedPercent": 12
+          },
+          {
+            "capturedAt": "2026-04-01T20:33:41Z",
+            "resetsAt": "2026-04-08T07:57:12Z",
+            "usedPercent": 12
+          }
+        ]
+      }
+    ]
+  }
+}
diff --git a/Tests/CodexBarTests/Fixtures/models-dev-subset.json b/Tests/CodexBarTests/Fixtures/models-dev-subset.json
new file mode 100644
index 0000000000..f2a0c0857e
--- /dev/null
+++ b/Tests/CodexBarTests/Fixtures/models-dev-subset.json
@@ -0,0 +1,89 @@
+{
+  "openai": {
+    "id": "openai",
+    "name": "OpenAI",
+    "models": {
+      "gpt-4o-mini": {
+        "id": "gpt-4o-mini",
+        "name": "GPT-4o mini",
+        "cost": {
+          "input": 0.15,
+          "output": 0.6,
+          "cache_read": 0.08
+        },
+        "limit": {
+          "context": 128000,
+          "output": 16384
+        }
+      },
+      "shared-model": {
+        "id": "shared-model",
+        "name": "Shared model via OpenAI",
+        "cost": {
+          "input": 1,
+          "output": 2
+        },
+        "limit": {
+          "context": 128000
+        }
+      }
+    }
+  },
+  "anthropic": {
+    "id": "anthropic",
+    "name": "Anthropic",
+    "models": {
+      "shared-model": {
+        "id": "shared-model",
+        "name": "Shared model via Anthropic",
+        "cost": {
+          "input": 3,
+          "output": 4
+        },
+        "limit": {
+          "context": 200000
+        }
+      },
+      "claude-sonnet-4-6": {
+        "id": "claude-sonnet-4-6",
+        "name": "Claude Sonnet 4.6",
+        "cost": {
+          "input": 3,
+          "output": 15,
+          "cache_read": 0.3,
+          "cache_write": 3.75,
+          "context_over_200k": {
+            "input": 6,
+            "output": 22.5,
+            "cache_read": 0.6,
+            "cache_write": 7.5
+          }
+        },
+        "limit": {
+          "context": 1000000,
+          "output": 64000
+        }
+      }
+    }
+  },
+  "google-vertex-anthropic": {
+    "id": "google-vertex-anthropic",
+    "name": "Vertex (Anthropic)",
+    "models": {
+      "claude-sonnet-4-6": {
+        "id": "claude-sonnet-4-6",
+        "name": "Claude Sonnet 4.6",
+        "cost": {
+          "input": 3.1,
+          "output": 15.1,
+          "cache_read": 0.31,
+          "cache_write": 3.76
+        },
+        "limit": {
+          "context": 1000000,
+          "output": 64000
+        }
+      }
+    }
+  }
+}
diff --git a/Tests/CodexBarTests/GeminiAPITestHelpers.swift b/Tests/CodexBarTests/GeminiAPITestHelpers.swift
index 0e20efc340..b243f22ab7 100644
--- a/Tests/CodexBarTests/GeminiAPITestHelpers.swift
+++ b/Tests/CodexBarTests/GeminiAPITestHelpers.swift
@@ -37,6 +37,11 @@ enum GeminiAPITestHelpers {
                     "remainingFraction": 0.9,
                     "resetTime": "2025-01-01T00:00:00Z",
                 ],
+                [
+                    "modelId": "gemini-2.5-flash-lite",
+                    "remainingFraction": 0.8,
+                    "resetTime": "2025-01-01T00:00:00Z",
+                ],
             ],
         ])
     }
diff --git a/Tests/CodexBarTests/GeminiLoginAlertTests.swift b/Tests/CodexBarTests/GeminiLoginAlertTests.swift
index ce919a897c..5905904b64 100644
--- a/Tests/CodexBarTests/GeminiLoginAlertTests.swift
+++ b/Tests/CodexBarTests/GeminiLoginAlertTests.swift
@@ -1,10 +1,9 @@
 import Testing
 @testable import CodexBar
 
-@Suite
 struct GeminiLoginAlertTests {
     @Test
-    func returnsAlertForMissingBinary() {
+    func `returns alert for missing binary`() {
         let result = GeminiLoginRunner.Result(outcome: .missingBinary)
         let info = StatusItemController.geminiLoginAlertInfo(for: result)
         #expect(info?.title == "Gemini CLI not found")
@@ -12,7 +11,7 @@ struct GeminiLoginAlertTests {
     }
 
     @Test
-    func returnsAlertForLaunchFailure() {
+    func `returns alert for launch failure`() {
         let result = GeminiLoginRunner.Result(outcome: .launchFailed("Boom"))
         let info = StatusItemController.geminiLoginAlertInfo(for: result)
         #expect(info?.title == "Could not open Terminal for Gemini")
@@ -20,7 +19,7 @@ struct GeminiLoginAlertTests {
     }
 
     @Test
-    func returnsNilOnSuccess() {
+    func `returns nil on success`() {
         let result = GeminiLoginRunner.Result(outcome: .success)
         let info = StatusItemController.geminiLoginAlertInfo(for: result)
         #expect(info == nil)
diff --git a/Tests/CodexBarTests/GeminiMenuCardTests.swift b/Tests/CodexBarTests/GeminiMenuCardTests.swift
new file mode 100644
index 0000000000..bf7e89afff
--- /dev/null
+++ b/Tests/CodexBarTests/GeminiMenuCardTests.swift
@@ -0,0 +1,57 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct GeminiMenuCardTests {
+    @Test
+    func `gemini model uses flash lite title for tertiary metric`() throws {
+        let now = Date()
+        let identity = ProviderIdentitySnapshot(
+            providerID: .gemini,
+            accountEmail: "gemini@example.com",
+            accountOrganization: nil,
+            loginMethod: "Paid")
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 0,
+                windowMinutes: 1440,
+                resetsAt: now.addingTimeInterval(3600),
+                resetDescription: "Resets in 1h"),
+            secondary: RateWindow(
+                usedPercent: 25,
+                windowMinutes: 1440,
+                resetsAt: now.addingTimeInterval(7200),
+                resetDescription: "Resets in 2h"),
+            tertiary: RateWindow(
+                usedPercent: 40,
+                windowMinutes: 1440,
+                resetsAt: now.addingTimeInterval(10800),
+                resetDescription: "Resets in 3h"),
+            updatedAt: now,
+            identity: identity)
+        let metadata = try #require(ProviderDefaults.metadata[.gemini])
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .gemini,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: "gemini@example.com", plan: "Paid"),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.metrics.map(\.title) == ["Pro", "Flash", "Flash Lite"])
+    }
+}
diff --git a/Tests/CodexBarTests/GeminiSourceLabelTests.swift b/Tests/CodexBarTests/GeminiSourceLabelTests.swift
new file mode 100644
index 0000000000..8ba8ee11c5
--- /dev/null
+++ b/Tests/CodexBarTests/GeminiSourceLabelTests.swift
@@ -0,0 +1,9 @@
+import Testing
+@testable import CodexBarCore
+
+struct GeminiSourceLabelTests {
+    @Test
+    func `Gemini source label reflects OAuth backed API requests`() {
+        #expect(GeminiStatusFetchStrategy.sourceLabel == "oauth-api")
+    }
+}
diff --git a/Tests/CodexBarTests/GeminiStatusProbeAPITests.swift b/Tests/CodexBarTests/GeminiStatusProbeAPITests.swift
index 8cbff0e447..57c8b003eb 100644
--- a/Tests/CodexBarTests/GeminiStatusProbeAPITests.swift
+++ b/Tests/CodexBarTests/GeminiStatusProbeAPITests.swift
@@ -1,11 +1,16 @@
 import CodexBarCore
 import Foundation
 import Testing
+#if canImport(Darwin)
+import Darwin
+#else
+import Glibc
+#endif
 
-@Suite("Gemini API", .serialized)
+@Suite(.serialized)
 struct GeminiStatusProbeAPITests {
     @Test
-    func missingCredentialsThrowsNotLoggedIn() async throws {
+    func `missing credentials throws not logged in`() async throws {
         let env = try GeminiTestEnvironment()
         defer { env.cleanup() }
 
@@ -15,11 +20,11 @@ struct GeminiStatusProbeAPITests {
         }
     }
 
-    @Test
-    func rejectsApiKeyAuthType() async throws {
+    @Test(arguments: ["gemini-api-key", "api-key"])
+    func `rejects api key auth types`(authType: String) async throws {
         let env = try GeminiTestEnvironment()
         defer { env.cleanup() }
-        try env.writeSettings(authType: "api-key")
+        try env.writeSettings(authType: authType)
 
         let probe = GeminiStatusProbe(timeout: 1, homeDirectory: env.homeURL.path)
         await Self.expectError(.unsupportedAuthType("API key")) {
@@ -28,7 +33,7 @@ struct GeminiStatusProbeAPITests {
     }
 
     @Test
-    func rejectsVertexAuthType() async throws {
+    func `rejects vertex auth type`() async throws {
         let env = try GeminiTestEnvironment()
         defer { env.cleanup() }
         try env.writeSettings(authType: "vertex-ai")
@@ -40,7 +45,7 @@ struct GeminiStatusProbeAPITests {
     }
 
     @Test
-    func refreshesExpiredTokenAndUpdatesStoredCredentials() async throws {
+    func `refreshes expired token and updates stored credentials`() async throws {
         let env = try GeminiTestEnvironment()
         defer { env.cleanup() }
         try env.writeCredentials(
@@ -67,6 +72,13 @@ struct GeminiStatusProbeAPITests {
 
             switch host {
             case "oauth2.googleapis.com":
+                // Fail the refresh if the client_id did not come from the test stub.
+                // This guards against the probe accidentally extracting OAuth creds
+                // from an unrelated Gemini install on the developer's machine.
+                let body = request.httpBody.flatMap { String(data: $0, encoding: .utf8) } ?? ""
+                guard body.contains("client_id=test-client-id") else {
+                    return GeminiAPITestHelpers.response(url: url.absoluteString, status: 400, body: Data())
+                }
                 let json = GeminiAPITestHelpers.jsonData([
                     "access_token": "new-token",
                     "expires_in": 3600,
@@ -112,7 +124,78 @@ struct GeminiStatusProbeAPITests {
     }
 
     @Test
-    func refreshesExpiredTokenWithNixShareLayout() async throws {
+    func `refreshes when stored Gemini credentials only have refresh token`() async throws {
+        let env = try GeminiTestEnvironment()
+        defer { env.cleanup() }
+        try env.writeCredentials(
+            accessToken: nil,
+            refreshToken: "refresh-token",
+            expiry: Date().addingTimeInterval(3600),
+            idToken: nil)
+
+        let binURL = try env.writeFakeGeminiCLI()
+        let previousValue = ProcessInfo.processInfo.environment["GEMINI_CLI_PATH"]
+        setenv("GEMINI_CLI_PATH", binURL.path, 1)
+        defer {
+            if let previousValue {
+                setenv("GEMINI_CLI_PATH", previousValue, 1)
+            } else {
+                unsetenv("GEMINI_CLI_PATH")
+            }
+        }
+
+        let dataLoader = GeminiAPITestHelpers.dataLoader { request in
+            guard let url = request.url, let host = url.host else {
+                throw URLError(.badURL)
+            }
+
+            switch host {
+            case "oauth2.googleapis.com":
+                let body = request.httpBody.flatMap { String(data: $0, encoding: .utf8) } ?? ""
+                guard body.contains("client_id=test-client-id") else {
+                    return GeminiAPITestHelpers.response(url: url.absoluteString, status: 400, body: Data())
+                }
+                let json = GeminiAPITestHelpers.jsonData([
+                    "access_token": "new-token",
+                    "expires_in": 3600,
+                    "id_token": GeminiAPITestHelpers.makeIDToken(email: "user@example.com"),
+                ])
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 200, body: json)
+            case "cloudresourcemanager.googleapis.com":
+                return GeminiAPITestHelpers.response(
+                    url: url.absoluteString,
+                    status: 200,
+                    body: GeminiAPITestHelpers.jsonData(["projects": []]))
+            case "cloudcode-pa.googleapis.com":
+                if url.path == "/v1internal:loadCodeAssist" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: GeminiAPITestHelpers.loadCodeAssistStandardTierResponse())
+                }
+                let auth = request.value(forHTTPHeaderField: "Authorization")
+                guard auth == "Bearer new-token" else {
+                    return GeminiAPITestHelpers.response(url: url.absoluteString, status: 401, body: Data())
+                }
+                return GeminiAPITestHelpers.response(
+                    url: url.absoluteString,
+                    status: 200,
+                    body: GeminiAPITestHelpers.sampleQuotaResponse())
+            default:
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            }
+        }
+
+        let probe = GeminiStatusProbe(timeout: 2, homeDirectory: env.homeURL.path, dataLoader: dataLoader)
+        let snapshot = try await probe.fetch()
+        #expect(snapshot.accountEmail == "user@example.com")
+
+        let updated = try env.readCredentials()
+        #expect(updated["access_token"] as? String == "new-token")
+    }
+
+    @Test
+    func `refreshes expired token with nix share layout`() async throws {
         let env = try GeminiTestEnvironment()
         defer { env.cleanup() }
         try env.writeCredentials(
@@ -139,6 +222,139 @@ struct GeminiStatusProbeAPITests {
 
             switch host {
             case "oauth2.googleapis.com":
+                // Fail the refresh if the client_id did not come from the test stub.
+                // This guards against the probe accidentally extracting OAuth creds
+                // from an unrelated Gemini install on the developer's machine.
+                let body = request.httpBody.flatMap { String(data: $0, encoding: .utf8) } ?? ""
+                guard body.contains("client_id=test-client-id") else {
+                    return GeminiAPITestHelpers.response(url: url.absoluteString, status: 400, body: Data())
+                }
+                let json = GeminiAPITestHelpers.jsonData([
+                    "access_token": "new-token",
+                    "expires_in": 3600,
+                    "id_token": GeminiAPITestHelpers.makeIDToken(email: "user@example.com"),
+                ])
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 200, body: json)
+            case "cloudresourcemanager.googleapis.com":
+                let json = GeminiAPITestHelpers.jsonData(["projects": []])
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 200, body: json)
+            case "cloudcode-pa.googleapis.com":
+                if url.path == "/v1internal:loadCodeAssist" {
+                    let auth = request.value(forHTTPHeaderField: "Authorization")
+                    if auth != "Bearer new-token" {
+                        return GeminiAPITestHelpers.response(url: url.absoluteString, status: 401, body: Data())
+                    }
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: GeminiAPITestHelpers.loadCodeAssistStandardTierResponse())
+                }
+                if url.path != "/v1internal:retrieveUserQuota" {
+                    return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+                }
+                let auth = request.value(forHTTPHeaderField: "Authorization")
+                if auth != "Bearer new-token" {
+                    return GeminiAPITestHelpers.response(url: url.absoluteString, status: 401, body: Data())
+                }
+                return GeminiAPITestHelpers.response(
+                    url: url.absoluteString,
+                    status: 200,
+                    body: GeminiAPITestHelpers.sampleQuotaResponse())
+            default:
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            }
+        }
+
+        let probe = GeminiStatusProbe(timeout: 2, homeDirectory: env.homeURL.path, dataLoader: dataLoader)
+        let snapshot = try await probe.fetch()
+        #expect(snapshot.accountPlan == "Paid")
+    }
+
+    @Test
+    func `refreshes expired token with fnm bundle layout when fnm keeps stdout open`() async throws {
+        let env = try GeminiTestEnvironment()
+        defer { env.cleanup() }
+        let childPIDFile = env.homeURL.appendingPathComponent("fnm-child.pid")
+        defer {
+            if let text = try? String(contentsOf: childPIDFile, encoding: .utf8),
+               let childPID = pid_t(text.trimmingCharacters(in: .whitespacesAndNewlines))
+            {
+                _ = kill(childPID, SIGKILL)
+            }
+        }
+        try env.writeCredentials(
+            accessToken: "old-token",
+            refreshToken: "refresh-token",
+            expiry: Date().addingTimeInterval(-3600),
+            idToken: GeminiAPITestHelpers.makeIDToken(email: "user@example.com"))
+
+        let binURL = try env.writeFakeGeminiCLI(layout: .fnmBundle)
+        // Match the real fnm layout: package root is inside the same multishell
+        // dir as the bin symlink target, under lib/node_modules/@google/gemini-cli.
+        let multishellRoot = binURL.deletingLastPathComponent().deletingLastPathComponent()
+        let packageJSONPath = multishellRoot
+            .appendingPathComponent("lib")
+            .appendingPathComponent("node_modules")
+            .appendingPathComponent("@google")
+            .appendingPathComponent("gemini-cli")
+            .appendingPathComponent("package.json")
+        let npmRoot = packageJSONPath
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+            .path
+        _ = try env.writeFakeFnm(
+            npmRoot: npmRoot,
+            geminiPackageJSONPath: packageJSONPath.path,
+            holdNpmRootStdoutOpen: true)
+
+        let previousPath = ProcessInfo.processInfo.environment["PATH"]
+        let previousPIDFile = ProcessInfo.processInfo.environment["CODEXBAR_TEST_CHILD_PID_FILE"]
+        let fakeBinDir = env.homeURL.appendingPathComponent("bin").path
+        let pathValue = if let previousPath, !previousPath.isEmpty {
+            "\(fakeBinDir):\(binURL.deletingLastPathComponent().path):\(previousPath)"
+        } else {
+            "\(fakeBinDir):\(binURL.deletingLastPathComponent().path)"
+        }
+        setenv("PATH", pathValue, 1)
+        setenv("CODEXBAR_TEST_CHILD_PID_FILE", childPIDFile.path, 1)
+
+        let previousGeminiPath = ProcessInfo.processInfo.environment["GEMINI_CLI_PATH"]
+        setenv("GEMINI_CLI_PATH", binURL.path, 1)
+        defer {
+            if let previousPath {
+                setenv("PATH", previousPath, 1)
+            } else {
+                unsetenv("PATH")
+            }
+
+            if let previousPIDFile {
+                setenv("CODEXBAR_TEST_CHILD_PID_FILE", previousPIDFile, 1)
+            } else {
+                unsetenv("CODEXBAR_TEST_CHILD_PID_FILE")
+            }
+
+            if let previousGeminiPath {
+                setenv("GEMINI_CLI_PATH", previousGeminiPath, 1)
+            } else {
+                unsetenv("GEMINI_CLI_PATH")
+            }
+        }
+
+        let dataLoader = GeminiAPITestHelpers.dataLoader { request in
+            guard let url = request.url, let host = url.host else {
+                throw URLError(.badURL)
+            }
+
+            switch host {
+            case "oauth2.googleapis.com":
+                // Fail the refresh if the client_id did not come from the test stub.
+                // This guards against the probe accidentally extracting OAuth creds
+                // from an unrelated Gemini install on the developer's machine.
+                let body = request.httpBody.flatMap { String(data: $0, encoding: .utf8) } ?? ""
+                guard body.contains("client_id=test-client-id") else {
+                    return GeminiAPITestHelpers.response(url: url.absoluteString, status: 400, body: Data())
+                }
                 let json = GeminiAPITestHelpers.jsonData([
                     "access_token": "new-token",
                     "expires_in": 3600,
@@ -175,13 +391,144 @@ struct GeminiStatusProbeAPITests {
             }
         }
 
+        let probe = GeminiStatusProbe(timeout: 2, homeDirectory: env.homeURL.path, dataLoader: dataLoader)
+        let start = Date()
+        let snapshot = try await probe.fetch()
+        let elapsed = Date().timeIntervalSince(start)
+        #expect(snapshot.accountPlan == "Paid")
+        #expect(elapsed < 3, "fnm package discovery should not wait for inherited stdout EOF, took \(elapsed)s")
+
+        let updated = try env.readCredentials()
+        #expect(updated["access_token"] as? String == "new-token")
+    }
+
+    @Test
+    func `fnm helper timeout hard stops a process that ignores SIGTERM`() throws {
+        let env = try GeminiTestEnvironment()
+        defer { env.cleanup() }
+        let pidFile = env.homeURL.appendingPathComponent("fnm-timeout.pid")
+        let helper = env.homeURL.appendingPathComponent("fnm-timeout")
+        try """
+        #!/bin/sh
+        printf '%s\\n' "$$" > "$1"
+        trap '' TERM
+        while true; do sleep 1; done
+        """.write(to: helper, atomically: true, encoding: .utf8)
+        try FileManager.default.setAttributes([.posixPermissions: 0o755], ofItemAtPath: helper.path)
+
+        let start = Date()
+        let result = GeminiStatusProbe.runProcess(
+            executable: helper.path,
+            arguments: [pidFile.path],
+            environment: [:],
+            timeout: 0.5)
+        let elapsed = Date().timeIntervalSince(start)
+        let text = try String(contentsOf: pidFile, encoding: .utf8)
+        let processID = try #require(pid_t(text.trimmingCharacters(in: .whitespacesAndNewlines)))
+        defer { _ = kill(processID, SIGKILL) }
+
+        #expect(result == nil)
+        #expect(kill(processID, 0) == -1)
+        #expect(elapsed < 2, "Ignored SIGTERM should escalate to SIGKILL, took \(elapsed)s")
+    }
+
+    @Test
+    func `fnm helper completed no-output failure returns promptly`() throws {
+        let env = try GeminiTestEnvironment()
+        defer { env.cleanup() }
+        let helper = env.homeURL.appendingPathComponent("fnm-failure")
+        try """
+        #!/bin/sh
+        exit 23
+        """.write(to: helper, atomically: true, encoding: .utf8)
+        try FileManager.default.setAttributes([.posixPermissions: 0o755], ofItemAtPath: helper.path)
+
+        let start = Date()
+        let result = GeminiStatusProbe.runProcess(
+            executable: helper.path,
+            arguments: [],
+            environment: [:],
+            timeout: 2)
+
+        #expect(result == nil)
+        #expect(Date().timeIntervalSince(start) < 1)
+    }
+
+    @Test
+    func `refreshes expired token with homebrew bundle layout`() async throws {
+        let env = try GeminiTestEnvironment()
+        defer { env.cleanup() }
+        try env.writeCredentials(
+            accessToken: "old-token",
+            refreshToken: "refresh-token",
+            expiry: Date().addingTimeInterval(-3600),
+            idToken: GeminiAPITestHelpers.makeIDToken(email: "user@example.com"))
+
+        let binURL = try env.writeFakeGeminiCLI(layout: .homebrewBundle)
+        let previousGeminiPath = ProcessInfo.processInfo.environment["GEMINI_CLI_PATH"]
+        setenv("GEMINI_CLI_PATH", binURL.path, 1)
+        defer {
+            if let previousGeminiPath {
+                setenv("GEMINI_CLI_PATH", previousGeminiPath, 1)
+            } else {
+                unsetenv("GEMINI_CLI_PATH")
+            }
+        }
+
+        let dataLoader = GeminiAPITestHelpers.dataLoader { request in
+            guard let url = request.url, let host = url.host else {
+                throw URLError(.badURL)
+            }
+
+            switch host {
+            case "oauth2.googleapis.com":
+                let body = request.httpBody.flatMap { String(data: $0, encoding: .utf8) } ?? ""
+                guard body.contains("client_id=test-client-id") else {
+                    return GeminiAPITestHelpers.response(url: url.absoluteString, status: 400, body: Data())
+                }
+                let json = GeminiAPITestHelpers.jsonData([
+                    "access_token": "new-token",
+                    "expires_in": 3600,
+                    "id_token": GeminiAPITestHelpers.makeIDToken(email: "user@example.com"),
+                ])
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 200, body: json)
+            case "cloudresourcemanager.googleapis.com":
+                return GeminiAPITestHelpers.response(
+                    url: url.absoluteString,
+                    status: 200,
+                    body: GeminiAPITestHelpers.jsonData(["projects": []]))
+            case "cloudcode-pa.googleapis.com":
+                guard request.value(forHTTPHeaderField: "Authorization") == "Bearer new-token" else {
+                    return GeminiAPITestHelpers.response(url: url.absoluteString, status: 401, body: Data())
+                }
+                if url.path == "/v1internal:loadCodeAssist" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: GeminiAPITestHelpers.loadCodeAssistStandardTierResponse())
+                }
+                if url.path == "/v1internal:retrieveUserQuota" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: GeminiAPITestHelpers.sampleQuotaResponse())
+                }
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            default:
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            }
+        }
+
         let probe = GeminiStatusProbe(timeout: 2, homeDirectory: env.homeURL.path, dataLoader: dataLoader)
         let snapshot = try await probe.fetch()
         #expect(snapshot.accountPlan == "Paid")
+
+        let updated = try env.readCredentials()
+        #expect(updated["access_token"] as? String == "new-token")
     }
 
     @Test
-    func usesCodeAssistProjectForQuota() async throws {
+    func `uses code assist project for quota`() async throws {
         let env = try GeminiTestEnvironment()
         defer { env.cleanup() }
         try env.writeCredentials(
@@ -250,7 +597,66 @@ struct GeminiStatusProbeAPITests {
     }
 
     @Test
-    func failsRefreshWhenOAuthConfigMissing() async throws {
+    func `falls back to curl loader when URL session times out`() async throws {
+        let calls = LoaderCalls()
+        let url = try #require(URL(string: "https://cloudcode-pa.googleapis.com/v1internal:retrieveUserQuota"))
+        let request = URLRequest(url: url)
+        let body = Data("{\"ok\":true}".utf8)
+        let loader = GeminiStatusProbe.dataLoaderWithCurlFallback(
+            primary: { _ in
+                calls.incrementPrimary()
+                throw URLError(.timedOut)
+            },
+            fallback: { request in
+                calls.incrementFallback()
+                let (response, data) = GeminiAPITestHelpers.response(
+                    url: request.url!.absoluteString,
+                    status: 200,
+                    body: body)
+                return (data, response)
+            })
+
+        let (loadedBody, loadedResponse) = try await loader(request)
+        let counts = calls.counts()
+        #expect(loadedBody == body)
+        #expect((loadedResponse as? HTTPURLResponse)?.statusCode == 200)
+        #expect(counts.primary == 1)
+        #expect(counts.fallback == 1)
+    }
+
+    @Test
+    func `does not fall back to curl loader for non-timeout errors`() async throws {
+        let calls = LoaderCalls()
+        let url = try #require(URL(string: "https://cloudcode-pa.googleapis.com/v1internal:retrieveUserQuota"))
+        let request = URLRequest(url: url)
+        let loader = GeminiStatusProbe.dataLoaderWithCurlFallback(
+            primary: { _ in
+                calls.incrementPrimary()
+                throw URLError(.cannotFindHost)
+            },
+            fallback: { request in
+                calls.incrementFallback()
+                let (response, data) = GeminiAPITestHelpers.response(
+                    url: request.url!.absoluteString,
+                    status: 200,
+                    body: Data())
+                return (data, response)
+            })
+
+        do {
+            _ = try await loader(request)
+            Issue.record("Expected non-timeout URLSession error")
+        } catch let error as URLError {
+            #expect(error.code == .cannotFindHost)
+        }
+
+        let counts = calls.counts()
+        #expect(counts.primary == 1)
+        #expect(counts.fallback == 0)
+    }
+
+    @Test
+    func `fails refresh when O auth config missing`() async throws {
         let env = try GeminiTestEnvironment()
         defer { env.cleanup() }
         try env.writeCredentials(
@@ -277,7 +683,7 @@ struct GeminiStatusProbeAPITests {
     }
 
     @Test
-    func reportsApiErrors() async throws {
+    func `reports api errors`() async throws {
         let env = try GeminiTestEnvironment()
         defer { env.cleanup() }
         try env.writeCredentials(
@@ -313,7 +719,7 @@ struct GeminiStatusProbeAPITests {
     }
 
     @Test
-    func reportsNotLoggedInWhenAccessTokenMissing() async throws {
+    func `reports not logged in when access token missing`() async throws {
         let env = try GeminiTestEnvironment()
         defer { env.cleanup() }
         try env.writeCredentials(
@@ -329,7 +735,7 @@ struct GeminiStatusProbeAPITests {
     }
 
     @Test
-    func reportsNotLoggedInOn401() async throws {
+    func `reports not logged in on401`() async throws {
         let env = try GeminiTestEnvironment()
         defer { env.cleanup() }
         try env.writeCredentials(
@@ -365,7 +771,7 @@ struct GeminiStatusProbeAPITests {
     }
 
     @Test
-    func reportsParseErrorsForInvalidPayload() async throws {
+    func `reports parse errors for invalid payload`() async throws {
         let env = try GeminiTestEnvironment()
         defer { env.cleanup() }
         try env.writeCredentials(
@@ -418,4 +824,28 @@ struct GeminiStatusProbeAPITests {
             #expect(error as? GeminiStatusProbeError == expected)
         }
     }
+
+    private final class LoaderCalls: @unchecked Sendable {
+        private let lock = NSLock()
+        private var primaryCount = 0
+        private var fallbackCount = 0
+
+        func incrementPrimary() {
+            self.lock.lock()
+            self.primaryCount += 1
+            self.lock.unlock()
+        }
+
+        func incrementFallback() {
+            self.lock.lock()
+            self.fallbackCount += 1
+            self.lock.unlock()
+        }
+
+        func counts() -> (primary: Int, fallback: Int) {
+            self.lock.lock()
+            defer { self.lock.unlock() }
+            return (self.primaryCount, self.fallbackCount)
+        }
+    }
 }
diff --git a/Tests/CodexBarTests/GeminiStatusProbePlanTests.swift b/Tests/CodexBarTests/GeminiStatusProbePlanTests.swift
index a8b2656dd7..9e38fb8534 100644
--- a/Tests/CodexBarTests/GeminiStatusProbePlanTests.swift
+++ b/Tests/CodexBarTests/GeminiStatusProbePlanTests.swift
@@ -2,10 +2,10 @@ import CodexBarCore
 import Foundation
 import Testing
 
-@Suite("Gemini Plan", .serialized)
+@Suite(.serialized)
 struct GeminiStatusProbePlanTests {
     @Test
-    func selectsProjectIdForQuotaRequests() async throws {
+    func `selects project id for quota requests`() async throws {
         let env = try GeminiTestEnvironment()
         defer { env.cleanup() }
         try env.writeCredentials(
@@ -53,10 +53,13 @@ struct GeminiStatusProbePlanTests {
         let probe = GeminiStatusProbe(timeout: 1, homeDirectory: env.homeURL.path, dataLoader: dataLoader)
         let snapshot = try await probe.fetch()
         #expect(snapshot.modelQuotas.contains { $0.percentLeft == 40 })
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.secondary?.remainingPercent == 40)
+        #expect(usage.tertiary == nil)
     }
 
     @Test
-    func prefersLoadCodeAssistProjectForQuotaRequests() async throws {
+    func `prefers load code assist project for quota requests`() async throws {
         let env = try GeminiTestEnvironment()
         defer { env.cleanup() }
         try env.writeCredentials(
@@ -107,10 +110,61 @@ struct GeminiStatusProbePlanTests {
         let probe = GeminiStatusProbe(timeout: 1, homeDirectory: env.homeURL.path, dataLoader: dataLoader)
         let snapshot = try await probe.fetch()
         #expect(snapshot.modelQuotas.contains { $0.percentLeft == 40 })
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.secondary?.remainingPercent == 40)
+        #expect(usage.tertiary == nil)
     }
 
     @Test
-    func detectsPaidFromStandardTier() async throws {
+    func `separates flash and flash lite quota buckets from api response`() async throws {
+        let env = try GeminiTestEnvironment()
+        defer { env.cleanup() }
+        try env.writeCredentials(
+            accessToken: "token",
+            refreshToken: nil,
+            expiry: Date().addingTimeInterval(3600),
+            idToken: nil)
+
+        let dataLoader = GeminiAPITestHelpers.dataLoader { request in
+            guard let url = request.url, let host = url.host else {
+                throw URLError(.badURL)
+            }
+            switch host {
+            case "cloudresourcemanager.googleapis.com":
+                return GeminiAPITestHelpers.response(
+                    url: url.absoluteString,
+                    status: 200,
+                    body: GeminiAPITestHelpers.jsonData(["projects": []]))
+            case "cloudcode-pa.googleapis.com":
+                if url.path == "/v1internal:loadCodeAssist" {
+                    return GeminiAPITestHelpers.response(
+                        url: url.absoluteString,
+                        status: 200,
+                        body: GeminiAPITestHelpers.loadCodeAssistStandardTierResponse())
+                }
+                if url.path != "/v1internal:retrieveUserQuota" {
+                    return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+                }
+                return GeminiAPITestHelpers.response(
+                    url: url.absoluteString,
+                    status: 200,
+                    body: GeminiAPITestHelpers.sampleQuotaResponse())
+            default:
+                return GeminiAPITestHelpers.response(url: url.absoluteString, status: 404, body: Data())
+            }
+        }
+
+        let probe = GeminiStatusProbe(timeout: 1, homeDirectory: env.homeURL.path, dataLoader: dataLoader)
+        let snapshot = try await probe.fetch()
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.primary?.remainingPercent == 60.0)
+        #expect(usage.secondary?.remainingPercent == 90.0)
+        #expect(usage.tertiary?.remainingPercent == 80.0)
+    }
+
+    @Test
+    func `detects paid from standard tier`() async throws {
         let env = try GeminiTestEnvironment()
         defer { env.cleanup() }
         try env.writeCredentials(
@@ -154,7 +208,7 @@ struct GeminiStatusProbePlanTests {
     }
 
     @Test
-    func detectsWorkspaceFromFreeTierWithHostedDomain() async throws {
+    func `detects workspace from free tier with hosted domain`() async throws {
         let env = try GeminiTestEnvironment()
         defer { env.cleanup() }
         let idToken = GeminiAPITestHelpers.makeIDToken(email: "user@company.com", hostedDomain: "company.com")
@@ -199,7 +253,7 @@ struct GeminiStatusProbePlanTests {
     }
 
     @Test
-    func detectsFreeFromFreeTierWithoutHostedDomain() async throws {
+    func `detects free from free tier without hosted domain`() async throws {
         let env = try GeminiTestEnvironment()
         defer { env.cleanup() }
         let idToken = GeminiAPITestHelpers.makeIDToken(email: "user@gmail.com")
@@ -244,7 +298,7 @@ struct GeminiStatusProbePlanTests {
     }
 
     @Test
-    func detectsLegacyFromLegacyTier() async throws {
+    func `detects legacy from legacy tier`() async throws {
         let env = try GeminiTestEnvironment()
         defer { env.cleanup() }
         try env.writeCredentials(
@@ -288,7 +342,7 @@ struct GeminiStatusProbePlanTests {
     }
 
     @Test
-    func leavesBlankWhenLoadCodeAssistFails() async throws {
+    func `leaves blank when load code assist fails`() async throws {
         let env = try GeminiTestEnvironment()
         defer { env.cleanup() }
         try env.writeCredentials(
diff --git a/Tests/CodexBarTests/GeminiStatusProbeTests.swift b/Tests/CodexBarTests/GeminiStatusProbeTests.swift
index 7ede0ffc33..a3994c64f1 100644
--- a/Tests/CodexBarTests/GeminiStatusProbeTests.swift
+++ b/Tests/CodexBarTests/GeminiStatusProbeTests.swift
@@ -2,7 +2,6 @@ import CodexBarCore
 import Foundation
 import Testing
 
-@Suite
 struct GeminiStatusProbeTests {
     /// Sample /stats output from Gemini CLI (actual format with box-drawing chars)
     static let sampleStatsOutput = """
@@ -17,14 +16,14 @@ struct GeminiStatusProbeTests {
     // MARK: - Legacy CLI parsing tests (kept for fallback support)
 
     @Test
-    func parsesMinimumPercentFromMultipleModels() throws {
+    func `parses minimum percent from multiple models`() throws {
         let snap = try GeminiStatusProbe.parse(text: Self.sampleStatsOutput)
         #expect(snap.dailyPercentLeft == 99.8)
         #expect(snap.resetDescription == "Resets in 20h 37m")
     }
 
     @Test
-    func parsesLowerPercentCorrectly() throws {
+    func `parses lower percent correctly`() throws {
         let output = """
         │  Model Usage                                                  Reqs                  Usage left  │
         │  gemini-2.5-flash                                               10       85.5% (Resets in 12h)  │
@@ -36,7 +35,7 @@ struct GeminiStatusProbeTests {
     }
 
     @Test
-    func handlesZeroPercentUsage() throws {
+    func `handles zero percent usage`() throws {
         let output = """
         │  gemini-2.5-flash                                               50        0.0% (Resets in 6h)  │
         │  gemini-2.5-pro                                                 20       15.0% (Resets in 6h)  │
@@ -47,7 +46,7 @@ struct GeminiStatusProbeTests {
     }
 
     @Test
-    func handles100PercentRemaining() throws {
+    func `handles100 percent remaining`() throws {
         let output = """
         │  gemini-2.5-flash                                                -      100.0% (Resets in 24h)  │
         """
@@ -56,14 +55,14 @@ struct GeminiStatusProbeTests {
     }
 
     @Test
-    func throwsOnEmptyOutput() {
+    func `throws on empty output`() {
         #expect(throws: GeminiStatusProbeError.self) {
             try GeminiStatusProbe.parse(text: "")
         }
     }
 
     @Test
-    func throwsOnNoUsageData() {
+    func `throws on no usage data`() {
         let output = """
         Welcome to Gemini CLI!
         Type /help for available commands.
@@ -74,7 +73,7 @@ struct GeminiStatusProbeTests {
     }
 
     @Test
-    func stripsANSICodesBeforeParsing() throws {
+    func `strips ANSI codes before parsing`() throws {
         let output =
             "\u{1B}[32m│\u{1B}[0m  gemini-2.5-flash                                                -       75.5% " +
             "(Resets in 18h)  │"
@@ -83,7 +82,7 @@ struct GeminiStatusProbeTests {
     }
 
     @Test
-    func preservesRawText() throws {
+    func `preserves raw text`() throws {
         let snap = try GeminiStatusProbe.parse(text: Self.sampleStatsOutput)
         #expect(snap.rawText == Self.sampleStatsOutput)
         #expect(snap.accountEmail == nil) // Legacy parse doesn't extract email
@@ -91,7 +90,7 @@ struct GeminiStatusProbeTests {
     }
 
     @Test
-    func parsesVariousResetDescriptions() throws {
+    func `parses various reset descriptions`() throws {
         let cases: [(String, String)] = [
             ("Resets in 24h", "Resets in 24h"),
             ("Resets in 1h 30m", "Resets in 1h 30m"),
@@ -107,7 +106,7 @@ struct GeminiStatusProbeTests {
     }
 
     @Test
-    func throwsNotLoggedInOnAuthPrompt() {
+    func `throws not logged in on auth prompt`() {
         let authOutputs = [
             "Waiting for auth... (Press ESC or CTRL+C to cancel)",
             "Login with Google\nUse Gemini API key",
@@ -123,7 +122,7 @@ struct GeminiStatusProbeTests {
     // MARK: - Model quota grouping tests
 
     @Test
-    func parsesModelsIntoQuotaArray() throws {
+    func `parses models into quota array`() throws {
         let snap = try GeminiStatusProbe.parse(text: Self.sampleStatsOutput)
         // Should parse multiple models (exact count may change as Google adds/removes models)
         #expect(snap.modelQuotas.count >= 2)
@@ -135,27 +134,29 @@ struct GeminiStatusProbeTests {
     }
 
     @Test
-    func lowestPercentLeftReturnsMinimum() throws {
+    func `lowest percent left returns minimum`() throws {
         let snap = try GeminiStatusProbe.parse(text: Self.sampleStatsOutput)
         // Flash models are 99.8%, Pro models are 100%, so min should be 99.8
         #expect(snap.lowestPercentLeft == 99.8)
     }
 
     @Test
-    func tierGroupingByKeyword() throws {
+    func `tier grouping by keyword`() throws {
         // Test that flash/pro keyword filtering works (model names may change)
         let snap = try GeminiStatusProbe.parse(text: Self.sampleStatsOutput)
 
-        let flashQuotas = snap.modelQuotas.filter { $0.modelId.contains("flash") }
+        let flashQuotas = snap.modelQuotas.filter { $0.modelId.contains("flash") && !$0.modelId.contains("flash-lite") }
+        let flashLiteQuotas = snap.modelQuotas.filter { $0.modelId.contains("flash-lite") }
         let proQuotas = snap.modelQuotas.filter { $0.modelId.contains("pro") }
 
         // Should have at least one of each tier in sample
         #expect(!flashQuotas.isEmpty)
+        #expect(!flashLiteQuotas.isEmpty)
         #expect(!proQuotas.isEmpty)
     }
 
     @Test
-    func tierMinimumCalculation() throws {
+    func `tier minimum calculation`() throws {
         // Use controlled test data to verify min-per-tier logic
         // Model names must start with "gemini-" to match the parser regex
         let output = """
@@ -177,7 +178,7 @@ struct GeminiStatusProbeTests {
     }
 
     @Test
-    func quotasHaveResetDescriptions() throws {
+    func `quotas have reset descriptions`() throws {
         let snap = try GeminiStatusProbe.parse(text: Self.sampleStatsOutput)
 
         // At least some quotas should have reset descriptions
@@ -185,10 +186,74 @@ struct GeminiStatusProbeTests {
         #expect(hasResets)
     }
 
+    @Test
+    func `to usage snapshot creates separate flash and flash lite meters`() throws {
+        let snap = try GeminiStatusProbe.parse(text: Self.sampleStatsOutput)
+        let usage = snap.toUsageSnapshot()
+
+        #expect(usage.primary?.remainingPercent == 100.0)
+        #expect(usage.secondary?.remainingPercent == 99.8)
+        #expect(usage.tertiary?.remainingPercent == 99.8)
+        #expect(usage.primary?.windowMinutes == 1440)
+        #expect(usage.secondary?.windowMinutes == 1440)
+        #expect(usage.tertiary?.windowMinutes == 1440)
+        #expect(usage.secondary?.resetDescription == "Resets in 20h 37m")
+        #expect(usage.tertiary?.resetDescription == "Resets in 20h 37m")
+    }
+
+    @Test
+    func `to usage snapshot does not let flash lite contaminate flash bucket`() throws {
+        let output = """
+        │  gemini-2.5-flash                           10       91.0% (Resets in 12h)  │
+        │  gemini-2.5-flash-lite                       5       33.0% (Resets in 6h)   │
+        │  gemini-2.5-pro                              2       80.0% (Resets in 24h)  │
+        """
+        let snap = try GeminiStatusProbe.parse(text: output)
+        let usage = snap.toUsageSnapshot()
+
+        #expect(usage.secondary?.remainingPercent == 91.0)
+        #expect(usage.tertiary?.remainingPercent == 33.0)
+        #expect(usage.secondary?.resetDescription == "Resets in 12h")
+        #expect(usage.tertiary?.resetDescription == "Resets in 6h")
+    }
+
+    @Test
+    func `to usage snapshot omits tertiary when no flash lite exists`() throws {
+        let output = """
+        │  gemini-2.5-flash                           10       85.0% (Resets in 12h)  │
+        │  gemini-2.5-pro                              2       95.0% (Resets in 24h)  │
+        """
+        let snap = try GeminiStatusProbe.parse(text: output)
+        let usage = snap.toUsageSnapshot()
+
+        #expect(usage.secondary?.remainingPercent == 85.0)
+        #expect(usage.tertiary == nil)
+    }
+
+    @Test
+    func `to usage snapshot uses lowest remaining quota per tier`() throws {
+        let output = """
+        │  gemini-a-flash                            10       91.0% (Resets in 12h)  │
+        │  gemini-b-flash                             5       74.0% (Resets in 10h)  │
+        │  gemini-c-flash-lite                        8       66.0% (Resets in 9h)   │
+        │  gemini-d-flash-lite                        1       42.0% (Resets in 7h)   │
+        │  gemini-e-pro                               2       88.0% (Resets in 24h)  │
+        │  gemini-f-pro                               1       97.0% (Resets in 25h)  │
+        """
+        let snap = try GeminiStatusProbe.parse(text: output)
+        let usage = snap.toUsageSnapshot()
+
+        #expect(usage.primary?.remainingPercent == 88.0)
+        #expect(usage.secondary?.remainingPercent == 74.0)
+        #expect(usage.tertiary?.remainingPercent == 42.0)
+        #expect(usage.secondary?.resetDescription == "Resets in 10h")
+        #expect(usage.tertiary?.resetDescription == "Resets in 7h")
+    }
+
     // MARK: - Live API test
 
     @Test
-    func liveGeminiFetch() async throws {
+    func `live gemini fetch`() async throws {
         guard ProcessInfo.processInfo.environment["LIVE_GEMINI_FETCH"] == "1" else {
             return
         }
diff --git a/Tests/CodexBarTests/GeminiTestEnvironment.swift b/Tests/CodexBarTests/GeminiTestEnvironment.swift
index 3d6b0b4bb6..1d2a427644 100644
--- a/Tests/CodexBarTests/GeminiTestEnvironment.swift
+++ b/Tests/CodexBarTests/GeminiTestEnvironment.swift
@@ -4,18 +4,26 @@ struct GeminiTestEnvironment {
     enum GeminiCLILayout {
         case npmNested
         case nixShare
+        case fnmBundle
+        case homebrewBundle
     }
 
     let homeURL: URL
     private let geminiDir: URL
+    private let antigravityDir: URL
 
     init() throws {
         let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
         try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
         let geminiDir = root.appendingPathComponent(".gemini")
         try FileManager.default.createDirectory(at: geminiDir, withIntermediateDirectories: true)
+        let antigravityDir = root
+            .appendingPathComponent(".codexbar")
+            .appendingPathComponent("antigravity")
+        try FileManager.default.createDirectory(at: antigravityDir, withIntermediateDirectories: true)
         self.homeURL = root
         self.geminiDir = geminiDir
+        self.antigravityDir = antigravityDir
     }
 
     func cleanup() {
@@ -34,11 +42,16 @@ struct GeminiTestEnvironment {
         try data.write(to: self.geminiDir.appendingPathComponent("settings.json"), options: .atomic)
     }
 
-    func writeCredentials(accessToken: String, refreshToken: String?, expiry: Date, idToken: String?) throws {
+    func writeCredentials(
+        accessToken: String?,
+        refreshToken: String?,
+        expiry: Date,
+        idToken: String?) throws
+    {
         var payload: [String: Any] = [
-            "access_token": accessToken,
             "expiry_date": expiry.timeIntervalSince1970 * 1000,
         ]
+        if let accessToken { payload["access_token"] = accessToken }
         if let refreshToken { payload["refresh_token"] = refreshToken }
         if let idToken { payload["id_token"] = idToken }
         let data = try JSONSerialization.data(withJSONObject: payload)
@@ -52,14 +65,45 @@ struct GeminiTestEnvironment {
         return object as? [String: Any] ?? [:]
     }
 
+    func writeAntigravityCredentials(
+        accessToken: String,
+        refreshToken: String?,
+        expiry: Date,
+        idToken: String? = nil,
+        email: String? = nil,
+        projectID: String? = nil,
+        clientID: String? = nil,
+        clientSecret: String? = nil) throws
+    {
+        var payload: [String: Any] = [
+            "access_token": accessToken,
+            "expiry_date": expiry.timeIntervalSince1970 * 1000,
+        ]
+        if let refreshToken { payload["refresh_token"] = refreshToken }
+        if let idToken { payload["id_token"] = idToken }
+        if let email { payload["email"] = email }
+        if let projectID { payload["project_id"] = projectID }
+        if let clientID { payload["client_id"] = clientID }
+        if let clientSecret { payload["client_secret"] = clientSecret }
+        let data = try JSONSerialization.data(withJSONObject: payload)
+        try data.write(to: self.antigravityDir.appendingPathComponent("oauth_creds.json"), options: .atomic)
+    }
+
+    func readAntigravityCredentials() throws -> [String: Any] {
+        let url = self.antigravityDir.appendingPathComponent("oauth_creds.json")
+        let data = try Data(contentsOf: url)
+        let object = try JSONSerialization.jsonObject(with: data)
+        return object as? [String: Any] ?? [:]
+    }
+
     func writeFakeGeminiCLI(includeOAuth: Bool = true, layout: GeminiCLILayout = .npmNested) throws -> URL {
         let base = self.homeURL.appendingPathComponent("gemini-cli")
         let binDir = base.appendingPathComponent("bin")
         try FileManager.default.createDirectory(at: binDir, withIntermediateDirectories: true)
 
-        let oauthPath: URL = switch layout {
+        switch layout {
         case .npmNested:
-            base
+            let oauthPath = base
                 .appendingPathComponent("lib")
                 .appendingPathComponent("node_modules")
                 .appendingPathComponent("@google")
@@ -71,8 +115,28 @@ struct GeminiTestEnvironment {
                 .appendingPathComponent("src")
                 .appendingPathComponent("code_assist")
                 .appendingPathComponent("oauth2.js")
+
+            if includeOAuth {
+                try FileManager.default.createDirectory(
+                    at: oauthPath.deletingLastPathComponent(),
+                    withIntermediateDirectories: true)
+
+                let oauthContent = """
+                const OAUTH_CLIENT_ID = 'test-client-id';
+                const OAUTH_CLIENT_SECRET = 'test-client-secret';
+                """
+                try oauthContent.write(to: oauthPath, atomically: true, encoding: .utf8)
+            }
+
+            let geminiBinary = binDir.appendingPathComponent("gemini")
+            try "#!/bin/bash\nexit 0\n".write(to: geminiBinary, atomically: true, encoding: .utf8)
+            try FileManager.default.setAttributes(
+                [.posixPermissions: 0o755],
+                ofItemAtPath: geminiBinary.path)
+            return geminiBinary
+
         case .nixShare:
-            base
+            let oauthPath = base
                 .appendingPathComponent("share")
                 .appendingPathComponent("gemini-cli")
                 .appendingPathComponent("node_modules")
@@ -82,25 +146,226 @@ struct GeminiTestEnvironment {
                 .appendingPathComponent("src")
                 .appendingPathComponent("code_assist")
                 .appendingPathComponent("oauth2.js")
+
+            if includeOAuth {
+                try FileManager.default.createDirectory(
+                    at: oauthPath.deletingLastPathComponent(),
+                    withIntermediateDirectories: true)
+
+                let oauthContent = """
+                const OAUTH_CLIENT_ID = 'test-client-id';
+                const OAUTH_CLIENT_SECRET = 'test-client-secret';
+                """
+                try oauthContent.write(to: oauthPath, atomically: true, encoding: .utf8)
+            }
+
+            let geminiBinary = binDir.appendingPathComponent("gemini")
+            try "#!/bin/bash\nexit 0\n".write(to: geminiBinary, atomically: true, encoding: .utf8)
+            try FileManager.default.setAttributes(
+                [.posixPermissions: 0o755],
+                ofItemAtPath: geminiBinary.path)
+            return geminiBinary
+
+        case .fnmBundle:
+            // Mirror a real fnm multishell layout: bin/gemini is a single relative
+            // symlink into the same multishell's lib/node_modules/@google/gemini-cli,
+            // which is a plain directory with the real package.json + bundle/*.js.
+            let multishellRoot = self.homeURL
+                .appendingPathComponent("Library")
+                .appendingPathComponent("Caches")
+                .appendingPathComponent("fnm_multishells")
+                .appendingPathComponent("12345_67890")
+            let binDir = multishellRoot.appendingPathComponent("bin")
+            let packageRoot = multishellRoot
+                .appendingPathComponent("lib")
+                .appendingPathComponent("node_modules")
+                .appendingPathComponent("@google")
+                .appendingPathComponent("gemini-cli")
+            let bundleDir = packageRoot.appendingPathComponent("bundle")
+            try FileManager.default.createDirectory(at: binDir, withIntermediateDirectories: true)
+            try FileManager.default.createDirectory(at: bundleDir, withIntermediateDirectories: true)
+
+            let packageJSON = """
+            {
+              "name": "@google/gemini-cli"
+            }
+            """
+            try packageJSON.write(
+                to: packageRoot.appendingPathComponent("package.json"),
+                atomically: true,
+                encoding: .utf8)
+
+            let chunkName = "chunk-TEST123.js"
+            let geminiEntry = bundleDir.appendingPathComponent("gemini.js")
+            let geminiContent = """
+            #!/usr/bin/env node
+            import { start } from "./\(chunkName)";
+            start();
+            """
+            try geminiContent.write(to: geminiEntry, atomically: true, encoding: .utf8)
+            try FileManager.default.setAttributes(
+                [.posixPermissions: 0o755],
+                ofItemAtPath: geminiEntry.path)
+
+            let chunkContent = if includeOAuth {
+                """
+                export const start = () => {};
+                const OAUTH_CLIENT_ID = 'test-client-id';
+                const OAUTH_CLIENT_SECRET = 'test-client-secret';
+                """
+            } else {
+                "export const start = () => {};\n"
+            }
+            try chunkContent.write(
+                to: bundleDir.appendingPathComponent(chunkName),
+                atomically: true,
+                encoding: .utf8)
+
+            // Relative symlink matching what fnm actually creates:
+            //   fnm_multishells/XXX/bin/gemini -> ../lib/node_modules/@google/gemini-cli/bundle/gemini.js
+            // Use the path-based API so the target is stored as a literal relative
+            // string; the URL-based API resolves URL(fileURLWithPath: "../...") against
+            // the process CWD, which produces a bogus absolute target.
+            let geminiBinary = binDir.appendingPathComponent("gemini")
+            try FileManager.default.createSymbolicLink(
+                atPath: geminiBinary.path,
+                withDestinationPath: "../lib/node_modules/@google/gemini-cli/bundle/gemini.js")
+
+            return geminiBinary
+
+        case .homebrewBundle:
+            return try self.writeFakeHomebrewGeminiCLI(base: base, includeOAuth: includeOAuth)
         }
+    }
 
-        if includeOAuth {
-            try FileManager.default.createDirectory(
-                at: oauthPath.deletingLastPathComponent(),
-                withIntermediateDirectories: true)
+    private func writeFakeHomebrewGeminiCLI(base: URL, includeOAuth: Bool) throws -> URL {
+        let cellarRoot = base
+            .appendingPathComponent("Cellar")
+            .appendingPathComponent("gemini-cli")
+            .appendingPathComponent("0.41.2")
+        let binDir = cellarRoot.appendingPathComponent("bin")
+        let packageRoot = cellarRoot
+            .appendingPathComponent("libexec")
+            .appendingPathComponent("lib")
+            .appendingPathComponent("node_modules")
+            .appendingPathComponent("@google")
+            .appendingPathComponent("gemini-cli")
+        let bundleDir = packageRoot.appendingPathComponent("bundle")
+        try FileManager.default.createDirectory(at: binDir, withIntermediateDirectories: true)
+        try FileManager.default.createDirectory(at: bundleDir, withIntermediateDirectories: true)
 
-            let oauthContent = """
-            const OAUTH_CLIENT_ID = 'test-client-id';
-            const OAUTH_CLIENT_SECRET = 'test-client-secret';
+        let packageJSON = """
+        {
+          "name": "@google/gemini-cli"
+        }
+        """
+        try packageJSON.write(
+            to: packageRoot.appendingPathComponent("package.json"),
+            atomically: true,
+            encoding: .utf8)
+
+        let entry = bundleDir.appendingPathComponent("gemini.js")
+        try "#!/usr/bin/env node\nawait import('./gemini-HASH.js');\n".write(
+            to: entry,
+            atomically: true,
+            encoding: .utf8)
+        try FileManager.default.setAttributes(
+            [.posixPermissions: 0o755],
+            ofItemAtPath: entry.path)
+        try "export const run = () => {};\n".write(
+            to: bundleDir.appendingPathComponent("gemini-HASH.js"),
+            atomically: true,
+            encoding: .utf8)
+
+        let chunkContent = if includeOAuth {
             """
-            try oauthContent.write(to: oauthPath, atomically: true, encoding: .utf8)
+            var OAUTH_CLIENT_ID = "test-client-id";
+            var OAUTH_CLIENT_SECRET = "test-client-secret";
+            """
+        } else {
+            "export const unrelated = true;\n"
         }
+        try chunkContent.write(
+            to: bundleDir.appendingPathComponent("chunk-OAUTH.js"),
+            atomically: true,
+            encoding: .utf8)
 
         let geminiBinary = binDir.appendingPathComponent("gemini")
-        try "#!/bin/bash\nexit 0\n".write(to: geminiBinary, atomically: true, encoding: .utf8)
+        try FileManager.default.createSymbolicLink(
+            atPath: geminiBinary.path,
+            withDestinationPath: "../libexec/lib/node_modules/@google/gemini-cli/bundle/gemini.js")
+        return geminiBinary
+    }
+
+    func writeFakeFnm(
+        currentVersion: String = "v24.6.0",
+        npmRoot: String? = nil,
+        geminiPackageJSONPath: String,
+        holdNpmRootStdoutOpen: Bool = false) throws -> URL
+    {
+        let binDir = self.homeURL.appendingPathComponent("bin")
+        try FileManager.default.createDirectory(at: binDir, withIntermediateDirectories: true)
+
+        let fnmPath = binDir.appendingPathComponent("fnm")
+        let stdoutHolder = holdNpmRootStdoutOpen
+            ? #"""
+            python3 - <<'PY'
+            import os
+            import subprocess
+            import sys
+
+            child = subprocess.Popen(
+                [sys.executable, "-c", "import time; time.sleep(5)"],
+                stdin=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                start_new_session=True,
+            )
+            with open(os.environ["CODEXBAR_TEST_CHILD_PID_FILE"], "w") as handle:
+                handle.write(str(child.pid))
+            PY
+            """#
+            : ":"
+        let script = if let npmRoot {
+            """
+            #!/bin/bash
+            if [ "$1" = "current" ]; then
+              printf '%s\n' "\(currentVersion)"
+              exit 0
+            fi
+
+            if [ "$1" = "exec" ] && [ "$4" = "npm" ] && [ "$5" = "root" ] && [ "$6" = "-g" ]; then
+              \(stdoutHolder)
+              printf '%s\n' "\(npmRoot)"
+              exit 0
+            fi
+
+            if [ "$1" = "exec" ] && [ "$4" = "node" ]; then
+              printf '%s\n' "\(geminiPackageJSONPath)"
+              exit 0
+            fi
+
+            exit 1
+            """
+        } else {
+            """
+            #!/bin/bash
+            if [ "$1" = "current" ]; then
+              printf '%s\n' "\(currentVersion)"
+              exit 0
+            fi
+
+            if [ "$1" = "exec" ]; then
+              printf '%s\n' "\(geminiPackageJSONPath)"
+              exit 0
+            fi
+
+            exit 1
+            """
+        }
+        try script.write(to: fnmPath, atomically: true, encoding: .utf8)
         try FileManager.default.setAttributes(
             [.posixPermissions: 0o755],
-            ofItemAtPath: geminiBinary.path)
-        return geminiBinary
+            ofItemAtPath: fnmPath.path)
+        return fnmPath
     }
 }
diff --git a/Tests/CodexBarTests/GoogleWorkspaceStatusNetworkTests.swift b/Tests/CodexBarTests/GoogleWorkspaceStatusNetworkTests.swift
new file mode 100644
index 0000000000..1d51d3dfa2
--- /dev/null
+++ b/Tests/CodexBarTests/GoogleWorkspaceStatusNetworkTests.swift
@@ -0,0 +1,70 @@
+import Foundation
+import os
+import Testing
+@testable import CodexBar
+
+@MainActor
+struct GoogleWorkspaceStatusNetworkTests {
+    @Test
+    func `fetchWorkspaceStatus uses shared client`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            let response = try HTTPURLResponse(
+                url: #require(request.url),
+                statusCode: 200,
+                httpVersion: "HTTP/1.1",
+                headerFields: ["Content-Type": "application/json"])!
+            let body = Data(#"""
+            [
+              {
+                "begin": "2026-05-10T10:00:00+00:00",
+                "end": null,
+                "affected_products": [
+                  {"title": "Gemini", "id": "npdyhgECDJ6tB66MxXyo"}
+                ],
+                "most_recent_update": {
+                  "when": "2026-05-10T10:15:00+00:00",
+                  "status": "SERVICE_OUTAGE",
+                  "text": "**Summary**\nGemini API error.\n"
+                }
+              }
+            ]
+            """#.utf8)
+            return (body, response)
+        }
+
+        let status = try await UsageStore.fetchWorkspaceStatus(
+            productID: "npdyhgECDJ6tB66MxXyo",
+            transport: transport)
+
+        #expect(status.indicator == .critical)
+        #expect(status.description == "Gemini API error.")
+        let requests = await transport.requests()
+        #expect(requests.count == 1)
+        #expect(requests.first?.url?.host == "www.google.com")
+    }
+
+    @Test
+    func `fetchWorkspaceStatus decodes off the main thread when called from the main actor`() async throws {
+        // The incidents feed can run to hundreds of kilobytes; decoding it on the main
+        // actor stalls the UI for 150-340ms per Google-status provider per refresh (#1399).
+        let decodedOffMainThread = OSAllocatedUnfairLock(initialState: false)
+        let transport = ProviderHTTPTransportStub { request in
+            let response = try HTTPURLResponse(
+                url: #require(request.url),
+                statusCode: 200,
+                httpVersion: "HTTP/1.1",
+                headerFields: ["Content-Type": "application/json"])!
+            return (Data("[]".utf8), response)
+        }
+
+        let status = try await UsageStore.fetchWorkspaceStatus(
+            productID: "npdyhgECDJ6tB66MxXyo",
+            transport: transport,
+            beforeDecoding: {
+                decodedOffMainThread.withLock { $0 = !Thread.isMainThread }
+            })
+
+        #expect(status.indicator == .none)
+        #expect(decodedOffMainThread.withLock { $0 })
+    }
+}
diff --git a/Tests/CodexBarTests/GoogleWorkspaceStatusTests.swift b/Tests/CodexBarTests/GoogleWorkspaceStatusTests.swift
index bcab931a80..1b37b9bb19 100644
--- a/Tests/CodexBarTests/GoogleWorkspaceStatusTests.swift
+++ b/Tests/CodexBarTests/GoogleWorkspaceStatusTests.swift
@@ -2,13 +2,12 @@ import Foundation
 import Testing
 @testable import CodexBar
 
-@Suite
 @MainActor
 struct GoogleWorkspaceStatusTests {
     private let productID = "npdyhgECDJ6tB66MxXyo"
 
     @Test
-    func parseWorkspaceStatusSelectsWorstIncident() throws {
+    func `parse workspace status selects worst incident`() throws {
         let data = Data(#"""
         [
           {
@@ -47,7 +46,7 @@ struct GoogleWorkspaceStatusTests {
     }
 
     @Test
-    func parseWorkspaceStatusIgnoresResolvedIncidents() throws {
+    func `parse workspace status ignores resolved incidents`() throws {
         let data = Data(#"""
         [
           {
diff --git a/Tests/CodexBarTests/GrokAuthTests.swift b/Tests/CodexBarTests/GrokAuthTests.swift
new file mode 100644
index 0000000000..a2ed52e554
--- /dev/null
+++ b/Tests/CodexBarTests/GrokAuthTests.swift
@@ -0,0 +1,188 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct GrokAuthTests {
+    @Test
+    func `parses OIDC SuperGrok entry`() throws {
+        let json = #"""
+        {
+          "https://auth.x.ai::b1a00492-073a-47ea-816f-4c329264a828": {
+            "key": "secret-access-token-123",
+            "auth_mode": "oidc",
+            "create_time": "2026-05-15T13:31:33.384327Z",
+            "user_id": "user-uuid",
+            "email": "user@example.com",
+            "first_name": "Ada",
+            "last_name": "Lovelace",
+            "team_id": "team-uuid",
+            "refresh_token": "refresh-secret",
+            "expires_at": "2026-05-22T19:31:33.384327Z",
+            "oidc_issuer": "https://auth.x.ai",
+            "oidc_client_id": "b1a00492-073a-47ea-816f-4c329264a828"
+          }
+        }
+        """#
+        let data = Data(json.utf8)
+        let creds = try GrokCredentialsStore.parse(data: data)
+
+        #expect(creds.accessToken == "secret-access-token-123")
+        #expect(creds.refreshToken == "refresh-secret")
+        #expect(creds.email == "user@example.com")
+        #expect(creds.teamId == "team-uuid")
+        #expect(creds.authMode == "oidc")
+        #expect(creds.displayName == "Ada Lovelace")
+        #expect(creds.loginMethod == "SuperGrok")
+        #expect(creds.expiresAt != nil)
+    }
+
+    @Test
+    func `falls back to legacy session scope when OIDC absent`() throws {
+        let json = #"""
+        {
+          "https://accounts.x.ai/sign-in": {
+            "key": "legacy-token",
+            "auth_mode": "session",
+            "email": "legacy@example.com"
+          }
+        }
+        """#
+        let data = Data(json.utf8)
+        let creds = try GrokCredentialsStore.parse(data: data)
+        #expect(creds.accessToken == "legacy-token")
+        #expect(creds.email == "legacy@example.com")
+        #expect(creds.loginMethod == "session")
+    }
+
+    @Test
+    func `throws missingTokens when key absent`() {
+        let json = #"{"https://auth.x.ai::abc": {"auth_mode": "oidc"}}"#
+        let data = Data(json.utf8)
+        #expect(throws: GrokCredentialsError.self) {
+            _ = try GrokCredentialsStore.parse(data: data)
+        }
+    }
+
+    @Test
+    func `throws decodeFailed when JSON is invalid`() {
+        let data = Data("not-json".utf8)
+        #expect(throws: GrokCredentialsError.self) {
+            _ = try GrokCredentialsStore.parse(data: data)
+        }
+    }
+
+    @Test
+    func `isExpired reflects past expires_at`() throws {
+        // Past expiry
+        let pastJson = #"""
+        {
+          "https://auth.x.ai::client": {
+            "key": "stale-token",
+            "expires_at": "2020-01-01T00:00:00Z"
+          }
+        }
+        """#
+        let past = try GrokCredentialsStore.parse(data: Data(pastJson.utf8))
+        #expect(past.isExpired == true)
+
+        // Future expiry
+        let futureJson = #"""
+        {
+          "https://auth.x.ai::client": {
+            "key": "fresh-token",
+            "expires_at": "2099-01-01T00:00:00Z"
+          }
+        }
+        """#
+        let future = try GrokCredentialsStore.parse(data: Data(futureJson.utf8))
+        #expect(future.isExpired == false)
+
+        // Missing expires_at — treated as non-expired so we never spuriously lock
+        // out clients whose auth.json shape predates this field.
+        let noExpiryJson = #"""
+        {
+          "https://auth.x.ai::client": {
+            "key": "ageless-token"
+          }
+        }
+        """#
+        let noExpiry = try GrokCredentialsStore.parse(data: Data(noExpiryJson.utf8))
+        #expect(noExpiry.isExpired == false)
+    }
+
+    @Test
+    func `expired credentials are preserved when billing succeeds`() throws {
+        let pastJson = #"""
+        {
+          "https://auth.x.ai::client": {
+            "key": "stale-token",
+            "email": "grok@example.com",
+            "team_id": "team_123",
+            "expires_at": "2020-01-01T00:00:00Z"
+          }
+        }
+        """#
+        let expired = try GrokCredentialsStore.parse(data: Data(pastJson.utf8))
+        let billing = try JSONDecoder().decode(GrokBillingResponse.self, from: Data(#"{}"#.utf8))
+        let webBilling = GrokWebBillingSnapshot(
+            usedPercent: 42,
+            resetsAt: Date(timeIntervalSince1970: 1_800_000_000))
+
+        #expect(GrokStatusProbe.credentialsForSnapshot(credentials: expired, billing: nil) == nil)
+        #expect(GrokStatusProbe.credentialsForSnapshot(credentials: expired, billing: billing)?
+            .email == "grok@example.com")
+        #expect(GrokStatusProbe.credentialsForSnapshot(credentials: expired, billing: nil, webBilling: webBilling)?
+            .email == "grok@example.com")
+    }
+
+    @Test
+    func `remote auth failures surface even with fresh local credentials`() {
+        #expect(GrokStatusProbe.shouldSurfaceRemoteAuthError(GrokWebBillingError.requestFailed(401, "unauthorized")))
+        #expect(GrokStatusProbe.shouldSurfaceRemoteAuthError(GrokWebBillingError.requestFailed(403, "forbidden")))
+        #expect(GrokStatusProbe.shouldSurfaceRemoteAuthError(GrokWebBillingError.rpcFailed(16, "token expired")))
+        #expect(!GrokStatusProbe.shouldSurfaceRemoteAuthError(GrokWebBillingError.parseFailed))
+    }
+
+    @Test
+    func `falls back to legacy when OIDC entry has no key`() throws {
+        // A stale/partial OIDC record must not shadow a healthy legacy session.
+        let json = #"""
+        {
+          "https://auth.x.ai::stale-client": {
+            "auth_mode": "oidc",
+            "email": "stale@example.com"
+          },
+          "https://accounts.x.ai/sign-in": {
+            "key": "healthy-legacy-token",
+            "auth_mode": "session",
+            "email": "healthy@example.com"
+          }
+        }
+        """#
+        let data = Data(json.utf8)
+        let creds = try GrokCredentialsStore.parse(data: data)
+        #expect(creds.accessToken == "healthy-legacy-token")
+        #expect(creds.email == "healthy@example.com")
+    }
+
+    @Test
+    func `prefers OIDC entry over legacy session when both present`() throws {
+        let json = #"""
+        {
+          "https://accounts.x.ai/sign-in": {
+            "key": "legacy-should-not-win",
+            "auth_mode": "session"
+          },
+          "https://auth.x.ai::client-id": {
+            "key": "oidc-wins",
+            "auth_mode": "oidc",
+            "email": "preferred@example.com"
+          }
+        }
+        """#
+        let data = Data(json.utf8)
+        let creds = try GrokCredentialsStore.parse(data: data)
+        #expect(creds.accessToken == "oidc-wins")
+        #expect(creds.email == "preferred@example.com")
+    }
+}
diff --git a/Tests/CodexBarTests/GrokBillingResponseTests.swift b/Tests/CodexBarTests/GrokBillingResponseTests.swift
new file mode 100644
index 0000000000..f0c5e27af6
--- /dev/null
+++ b/Tests/CodexBarTests/GrokBillingResponseTests.swift
@@ -0,0 +1,69 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct GrokBillingResponseTests {
+    @Test
+    func `decodes full BillingConfigResponse and computes percent`() throws {
+        let json = #"""
+        {
+          "billingCycle": {
+            "billingPeriodStart": "2026-05-01T00:00:00Z",
+            "billingPeriodEnd": "2026-06-01T00:00:00Z"
+          },
+          "monthlyLimit": { "val": 99900 },
+          "onDemandCap": { "val": 0 },
+          "on_demand_enabled": false,
+          "disabledByConfig": false,
+          "usage": {
+            "includedUsed": { "val": 49950 },
+            "onDemandUsed": { "val": 0 },
+            "totalUsed": { "val": 49950 }
+          }
+        }
+        """#
+        let data = Data(json.utf8)
+        let response = try JSONDecoder().decode(GrokBillingResponse.self, from: data)
+
+        #expect(response.monthlyLimit?.val == 99900)
+        #expect(response.usage?.totalUsed?.val == 49950)
+        #expect(response.monthlyUsedPercent == 50.0)
+        #expect(response.billingPeriodEndDate != nil)
+        #expect(response.billingPeriodMinutes == 31 * 24 * 60)
+    }
+
+    @Test
+    func `monthlyUsedPercent returns nil when limit missing`() throws {
+        let json = #"""
+        {
+          "usage": { "totalUsed": { "val": 100 } }
+        }
+        """#
+        let data = Data(json.utf8)
+        let response = try JSONDecoder().decode(GrokBillingResponse.self, from: data)
+        #expect(response.monthlyUsedPercent == nil)
+    }
+
+    @Test
+    func `monthlyUsedPercent clamps over-100 usage`() throws {
+        let json = #"""
+        {
+          "monthlyLimit": { "val": 1000 },
+          "usage": { "totalUsed": { "val": 5000 } }
+        }
+        """#
+        let data = Data(json.utf8)
+        let response = try JSONDecoder().decode(GrokBillingResponse.self, from: data)
+        #expect(response.monthlyUsedPercent == 100.0)
+    }
+
+    @Test
+    func `handles missing optional fields gracefully`() throws {
+        let json = #"{}"#
+        let data = Data(json.utf8)
+        let response = try JSONDecoder().decode(GrokBillingResponse.self, from: data)
+        #expect(response.billingCycle == nil)
+        #expect(response.monthlyLimit == nil)
+        #expect(response.monthlyUsedPercent == nil)
+    }
+}
diff --git a/Tests/CodexBarTests/GrokWebBillingFetcherTests.swift b/Tests/CodexBarTests/GrokWebBillingFetcherTests.swift
new file mode 100644
index 0000000000..408b6a7f87
--- /dev/null
+++ b/Tests/CodexBarTests/GrokWebBillingFetcherTests.swift
@@ -0,0 +1,883 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct GrokWebBillingFetcherTests {
+    private final class AttemptCounter: @unchecked Sendable {
+        private let lock = NSLock()
+        private var value = 0
+
+        func increment() -> Int {
+            self.lock.lock()
+            defer { self.lock.unlock() }
+            self.value += 1
+            return self.value
+        }
+
+        func current() -> Int {
+            self.lock.lock()
+            defer { self.lock.unlock() }
+            return self.value
+        }
+    }
+
+    @Test
+    func `provider exposes cli and web source modes`() {
+        #expect(GrokProviderDescriptor.descriptor.fetchPlan.sourceModes == [.auto, .cli, .web])
+    }
+
+    @Test
+    func `descriptor uses Credits label for primary usage window`() {
+        let metadata = GrokProviderDescriptor.descriptor.metadata
+        #expect(metadata.sessionLabel == "Credits")
+        #expect(metadata.weeklyLabel == "On-demand")
+        #expect(!metadata.supportsOpus)
+    }
+
+    @Test
+    func `primaryLabel derives Weekly or Monthly from resetsAt`() {
+        let now = Date()
+        let in6Days = now.addingTimeInterval(6 * 86400)
+        let in30Days = now.addingTimeInterval(30 * 86400)
+        let in90Days = now.addingTimeInterval(90 * 86400)
+        let lateWeeklyWindow = RateWindow(
+            usedPercent: 25,
+            windowMinutes: 7 * 24 * 60,
+            resetsAt: now.addingTimeInterval(86400),
+            resetDescription: nil)
+
+        #expect(GrokProviderDescriptor.primaryLabel(resetsAt: in6Days, now: now) == "Weekly")
+        #expect(GrokProviderDescriptor.primaryLabel(resetsAt: in30Days, now: now) == "Monthly")
+        #expect(GrokProviderDescriptor.primaryLabel(resetsAt: in90Days, now: now) == nil)
+        #expect(GrokProviderDescriptor.primaryLabel(window: lateWeeklyWindow, now: now) == "Weekly")
+        #expect(GrokProviderDescriptor.primaryLabel(resetsAt: nil) == nil)
+    }
+
+    @Test
+    func `cli runtime does not import browser cookies unless explicitly enabled`() {
+        #expect(GrokWebFetchStrategy.canImportBrowserCookies(runtime: .app, env: [:]))
+        #expect(!GrokWebFetchStrategy.canImportBrowserCookies(runtime: .cli, env: [:]))
+        #expect(GrokWebFetchStrategy.canImportBrowserCookies(
+            runtime: .cli,
+            env: ["CODEXBAR_ALLOW_BROWSER_COOKIE_IMPORT": "1"]))
+    }
+
+    @Test
+    func `web strategy tries later browser session when first cookie is stale`() async throws {
+        let stale = try #require(Self.cookie(name: "sso", value: "stale"))
+        let valid = try #require(Self.cookie(name: "sso", value: "valid"))
+        let sessions = [
+            GrokCookieImporter.SessionInfo(cookies: [stale], sourceLabel: "Chrome Profile 1"),
+            GrokCookieImporter.SessionInfo(cookies: [valid], sourceLabel: "Chrome Profile 2"),
+        ]
+        var attemptedHeaders: [String] = []
+
+        let result = try await GrokWebFetchStrategy.fetchFirstValidCookieSession(sessions) { cookieHeader, _ in
+            attemptedHeaders.append(cookieHeader)
+            guard cookieHeader.contains("valid") else {
+                throw GrokWebBillingError.requestFailed(401, "stale")
+            }
+            return GrokWebBillingSnapshot(
+                usedPercent: 12,
+                resetsAt: Date(timeIntervalSince1970: 1_800_000_000))
+        }
+
+        #expect(attemptedHeaders == ["sso=stale", "sso=valid"])
+        #expect(result.0.usedPercent == 12)
+        #expect(result.1 == "Chrome Profile 2")
+    }
+
+    @Test
+    func `cookie authenticated web billing does not reuse auth file identity`() {
+        #expect(GrokWebFetchStrategy.credentialsForWebBillingSnapshot(
+            credentials: Self.credentials,
+            authenticatedByAuthFile: false) == nil)
+        #expect(GrokWebFetchStrategy.credentialsForWebBillingSnapshot(
+            credentials: Self.credentials,
+            authenticatedByAuthFile: true)?
+            .email == "grok@example.com")
+    }
+
+    @Test
+    func `parses grok grpc web billing frame`() throws {
+        let reset = UInt64(1_800_000_000)
+        let payload = Self.protobufPayload(usedPercent: 42.5, resetEpoch: reset)
+        let data = Self.grpcFrame(payload)
+
+        let snapshot = try GrokWebBillingFetcher.parseGRPCWebResponse(
+            data,
+            now: Date(timeIntervalSince1970: 1_799_000_000))
+
+        #expect(snapshot.usedPercent == 42.5)
+        #expect(snapshot.resetsAt == Date(timeIntervalSince1970: TimeInterval(reset)))
+    }
+
+    @Test
+    func `parses unframed grok billing protobuf payload`() throws {
+        let hex =
+            "0a3f0d7f6a9c3f12001a002206088097f3d0062a060880b191d2063a07080215a9389b3f3a07080115d6ea183c" +
+            "421208011206088097f3d0061a060880b191d206"
+        let data = try #require(Self.data(hexString: hex))
+
+        let snapshot = try GrokWebBillingFetcher.parseGRPCWebResponse(
+            data,
+            now: Date(timeIntervalSince1970: 1_780_000_000))
+
+        #expect(snapshot.usedPercent == 1.222000002861023)
+        #expect(snapshot.resetsAt == Date(timeIntervalSince1970: 1_782_864_000))
+    }
+
+    @Test
+    func `parses unframed zero percent payload that resembles an empty grpc frame`() throws {
+        let reset = UInt64(1_800_000_000)
+        let payload = Self.protobufPayload(usedPercent: 0, resetEpoch: reset)
+
+        #expect(GrokWebBillingFetcher.grpcWebDataFrames(from: payload).isEmpty)
+
+        let snapshot = try GrokWebBillingFetcher.parseGRPCWebResponse(
+            payload,
+            now: Date(timeIntervalSince1970: 1_799_000_000))
+
+        #expect(snapshot.usedPercent == 0)
+        #expect(snapshot.resetsAt == Date(timeIntervalSince1970: TimeInterval(reset)))
+    }
+
+    @Test
+    func `does not treat grpc frame prefix as raw protobuf`() {
+        #expect(!GrokWebBillingFetcher.looksLikeProtobufPayload(Data([0, 0, 0, 0, 10])))
+    }
+
+    @Test
+    func `web strategy tries cookie plus bearer before cookie only`() async throws {
+        let cookie = try #require(Self.cookie(name: "sso", value: "session"))
+        let sessions = [GrokCookieImporter.SessionInfo(cookies: [cookie], sourceLabel: "Chrome")]
+        var attempts: [String] = []
+
+        let result = try await GrokWebFetchStrategy.fetchFirstValidCookieSession(
+            sessions,
+            credentials: Self.credentials)
+        { _, authCredentials in
+            let mode = authCredentials == nil ? "cookie-only" : "cookie+bearer"
+            attempts.append(mode)
+            guard mode == "cookie+bearer" else {
+                throw GrokWebBillingError.requestFailed(401, "needs bearer")
+            }
+            return GrokWebBillingSnapshot(usedPercent: 9, resetsAt: nil)
+        }
+
+        #expect(attempts == ["cookie+bearer"])
+        #expect(result.0.usedPercent == 9)
+    }
+
+    @Test
+    func `web strategy skips expired bearer for browser cookies`() async throws {
+        let cookie = try #require(Self.cookie(name: "sso", value: "session"))
+        let sessions = [GrokCookieImporter.SessionInfo(cookies: [cookie], sourceLabel: "Chrome")]
+        let expired = GrokCredentials(
+            accessToken: "expired-token",
+            refreshToken: nil,
+            scope: "https://auth.x.ai::client",
+            authMode: "oidc",
+            userId: nil,
+            email: nil,
+            firstName: nil,
+            lastName: nil,
+            teamId: nil,
+            oidcIssuer: nil,
+            oidcClientId: nil,
+            expiresAt: .distantPast,
+            createTime: nil)
+        var attempts: [String] = []
+
+        _ = try await GrokWebFetchStrategy.fetchFirstValidCookieSession(
+            sessions,
+            credentials: expired)
+        { _, authCredentials in
+            attempts.append(authCredentials == nil ? "cookie-only" : "cookie+bearer")
+            return GrokWebBillingSnapshot(usedPercent: 9, resetsAt: nil)
+        }
+
+        #expect(attempts == ["cookie-only"])
+    }
+
+    @Test
+    func `web strategy preserves malformed auth file error`() async throws {
+        let grokHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("CodexBar-GrokWebBilling-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: grokHome, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: grokHome) }
+        try Data("not-json".utf8).write(to: grokHome.appendingPathComponent("auth.json"))
+
+        let browserDetection = BrowserDetection(cacheTTL: 0)
+        let context = ProviderFetchContext(
+            runtime: .cli,
+            sourceMode: .web,
+            includeCredits: true,
+            webTimeout: 1,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: ["GROK_HOME": grokHome.path],
+            settings: nil,
+            fetcher: UsageFetcher(),
+            claudeFetcher: ClaudeUsageFetcher(browserDetection: browserDetection),
+            browserDetection: browserDetection)
+
+        await #expect {
+            _ = try await GrokWebFetchStrategy().fetch(context)
+        } throws: { error in
+            guard case GrokCredentialsError.decodeFailed = error else { return false }
+            return true
+        }
+    }
+
+    @Test
+    func `status seven scope failure is not classified as bad credentials`() {
+        #expect(!GrokWebBillingError.isAuthenticationFailure(
+            status: 7,
+            message: "OAuth2 access token lacks the required billing scope"))
+    }
+
+    @Test
+    func `ignores grpc web trailer frames`() {
+        let payload = Self.protobufPayload(usedPercent: 12.25, resetEpoch: 1_800_000_001)
+        let trailer = Data("grpc-status: 0\r\n".utf8)
+        let data = Self.grpcFrame(payload) + Self.grpcFrame(trailer, flags: 0x80)
+
+        let frames = GrokWebBillingFetcher.grpcWebDataFrames(from: data)
+
+        #expect(frames == [payload])
+    }
+
+    @Test
+    func `web fetch turns grpc unauthenticated trailer into reauth guidance`() async throws {
+        defer {
+            GrokWebBillingStubURLProtocol.requests = []
+            GrokWebBillingStubURLProtocol.requestBodies = []
+            GrokWebBillingStubURLProtocol.handler = nil
+        }
+
+        let config = URLSessionConfiguration.ephemeral
+        config.protocolClasses = [GrokWebBillingStubURLProtocol.self]
+        let session = URLSession(configuration: config)
+        let endpoint = try #require(URL(string: "https://grok.test/grok_api_v2.GrokBuildBilling/GetGrokCreditsConfig"))
+        let body = Self.grpcFrame(Data("grpc-status: 16\r\ngrpc-message: token%20expired\r\n".utf8), flags: 0x80)
+
+        #expect(GrokWebBillingFetcher.grpcWebTrailerFields(from: body)["grpc-status"] == "16")
+
+        GrokWebBillingStubURLProtocol.requests = []
+        GrokWebBillingStubURLProtocol.requestBodies = []
+        GrokWebBillingStubURLProtocol.handler = { request in
+            let url = try #require(request.url)
+            let response = HTTPURLResponse(
+                url: url,
+                statusCode: 200,
+                httpVersion: nil,
+                headerFields: ["Content-Type": "application/grpc-web+proto"])!
+            return (response, body)
+        }
+
+        await #expect {
+            _ = try await GrokWebBillingFetcher.fetch(
+                credentials: Self.credentials,
+                session: session,
+                endpoint: endpoint)
+        } throws: { error in
+            error.localizedDescription.contains("grok login")
+        }
+    }
+
+    @Test
+    func `web fetch turns grpc unauthenticated headers into reauth guidance`() async throws {
+        defer {
+            GrokWebBillingStubURLProtocol.requests = []
+            GrokWebBillingStubURLProtocol.requestBodies = []
+            GrokWebBillingStubURLProtocol.handler = nil
+        }
+
+        let config = URLSessionConfiguration.ephemeral
+        config.protocolClasses = [GrokWebBillingStubURLProtocol.self]
+        let session = URLSession(configuration: config)
+        let endpoint = try #require(URL(string: "https://grok.test/grok_api_v2.GrokBuildBilling/GetGrokCreditsConfig"))
+
+        GrokWebBillingStubURLProtocol.requests = []
+        GrokWebBillingStubURLProtocol.requestBodies = []
+        GrokWebBillingStubURLProtocol.handler = { request in
+            let url = try #require(request.url)
+            let response = HTTPURLResponse(
+                url: url,
+                statusCode: 200,
+                httpVersion: nil,
+                headerFields: [
+                    "Content-Type": "application/grpc-web+proto",
+                    "grpc-status": "16",
+                    "grpc-message": "Invalid%20bearer%20token.",
+                ])!
+            return (response, Data())
+        }
+
+        await #expect {
+            _ = try await GrokWebBillingFetcher.fetch(
+                credentials: Self.credentials,
+                session: session,
+                endpoint: endpoint)
+        } throws: { error in
+            error.localizedDescription.contains("grok login")
+        }
+    }
+
+    @Test
+    func `web fetch turns grpc permission denied bad credentials into reauth guidance`() async throws {
+        defer {
+            GrokWebBillingStubURLProtocol.requests = []
+            GrokWebBillingStubURLProtocol.requestBodies = []
+            GrokWebBillingStubURLProtocol.handler = nil
+        }
+
+        let config = URLSessionConfiguration.ephemeral
+        config.protocolClasses = [GrokWebBillingStubURLProtocol.self]
+        let session = URLSession(configuration: config)
+        let endpoint = try #require(URL(string: "https://grok.test/grok_api_v2.GrokBuildBilling/GetGrokCreditsConfig"))
+        let message = "The OAuth2 access token could not be validated. [WKE=unauthenticated:bad-credentials]"
+        let encodedMessage = message.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) ?? message
+        let body = Self.grpcFrame(
+            Data("grpc-status: 7\r\ngrpc-message: \(encodedMessage)\r\n".utf8),
+            flags: 0x80)
+
+        GrokWebBillingStubURLProtocol.requests = []
+        GrokWebBillingStubURLProtocol.requestBodies = []
+        GrokWebBillingStubURLProtocol.handler = { request in
+            let url = try #require(request.url)
+            let response = HTTPURLResponse(
+                url: url,
+                statusCode: 200,
+                httpVersion: nil,
+                headerFields: ["Content-Type": "application/grpc-web+proto"])!
+            return (response, body)
+        }
+
+        await #expect {
+            _ = try await GrokWebBillingFetcher.fetch(
+                credentials: Self.credentials,
+                session: session,
+                endpoint: endpoint)
+        } throws: { error in
+            error.localizedDescription.contains("grok.com") &&
+                error.localizedDescription.contains("grok login") &&
+                !error.localizedDescription.contains("status 7")
+        }
+    }
+
+    @Test
+    func `rejects reset only billing because it cannot render usage`() {
+        var payload = Data()
+        payload.append(0x10) // field 2, varint reset timestamp
+        payload.append(contentsOf: Self.varint(1_800_000_001))
+
+        #expect {
+            _ = try GrokWebBillingFetcher.parseGRPCWebResponse(Self.grpcFrame(payload))
+        } throws: { error in
+            guard case GrokWebBillingError.parseFailed = error else { return false }
+            return true
+        }
+    }
+
+    @Test
+    func `parses grok no usage yet billing response as zero percent`() throws {
+        let data = Data([
+            0x00, 0x00, 0x00, 0x00, 0x37, 0x0A, 0x35, 0x12,
+            0x00, 0x1A, 0x00, 0x22, 0x06, 0x08, 0x80, 0xDA,
+            0xCF, 0xCF, 0x06, 0x2A, 0x06, 0x08, 0x80, 0x97,
+            0xF3, 0xD0, 0x06, 0x32, 0x09, 0x0A, 0x05, 0x08,
+            0xEA, 0x0F, 0x10, 0x04, 0x12, 0x00, 0x32, 0x09,
+            0x0A, 0x05, 0x08, 0xEA, 0x0F, 0x10, 0x03, 0x12,
+            0x00, 0x32, 0x09, 0x0A, 0x05, 0x08, 0xEA, 0x0F,
+            0x10, 0x02, 0x12, 0x00, 0x80, 0x00, 0x00, 0x00,
+            0x0F, 0x67, 0x72, 0x70, 0x63, 0x2D, 0x73, 0x74,
+            0x61, 0x74, 0x75, 0x73, 0x3A, 0x30, 0x0D, 0x0A,
+        ])
+
+        let snapshot = try GrokWebBillingFetcher.parseGRPCWebResponse(
+            data,
+            now: Date(timeIntervalSince1970: 1_768_000_000))
+
+        #expect(snapshot.usedPercent == 0)
+        #expect(snapshot.resetsAt == Date(timeIntervalSince1970: 1_780_272_000))
+    }
+
+    @Test
+    func `parses omitted zero percent with current billing period`() throws {
+        let data = Data([
+            0x00, 0x00, 0x00, 0x00, 0x2A, 0x0A, 0x28, 0x12,
+            0x00, 0x1A, 0x00, 0x22, 0x06, 0x08, 0x80, 0x97,
+            0xF3, 0xD0, 0x06, 0x2A, 0x06, 0x08, 0x80, 0xB1,
+            0x91, 0xD2, 0x06, 0x42, 0x12, 0x08, 0x01, 0x12,
+            0x06, 0x08, 0x80, 0x97, 0xF3, 0xD0, 0x06, 0x1A,
+            0x06, 0x08, 0x80, 0xB1, 0x91, 0xD2, 0x06, 0x80,
+            0x00, 0x00, 0x00, 0x0F, 0x67, 0x72, 0x70, 0x63,
+            0x2D, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x3A,
+            0x30, 0x0D, 0x0A,
+        ])
+
+        let snapshot = try GrokWebBillingFetcher.parseGRPCWebResponse(
+            data,
+            now: Date(timeIntervalSince1970: 1_781_000_000))
+
+        #expect(snapshot.usedPercent == 0)
+        #expect(snapshot.resetsAt == Date(timeIntervalSince1970: 1_782_864_000))
+    }
+
+    @Test
+    func `uses billing field one instead of earlier unrelated float`() throws {
+        var payload = Data()
+        payload.append(0x4D) // field 9, fixed32 unrelated in-range float
+        var unrelatedBits = Float(7).bitPattern.littleEndian
+        withUnsafeBytes(of: &unrelatedBits) { payload.append(contentsOf: $0) }
+        payload.append(0x0D) // field 1, fixed32 billing usage percent
+        var usageBits = Float(42).bitPattern.littleEndian
+        withUnsafeBytes(of: &usageBits) { payload.append(contentsOf: $0) }
+        payload.append(0x10) // field 2, varint reset timestamp
+        payload.append(contentsOf: Self.varint(1_800_000_001))
+
+        let snapshot = try GrokWebBillingFetcher.parseGRPCWebResponse(Self.grpcFrame(payload))
+
+        #expect(snapshot.usedPercent == 42)
+    }
+
+    @Test
+    func `chooses future billing end instead of recent billing start`() throws {
+        let recentStart = UInt64(1_800_000_000)
+        let billingEnd = UInt64(1_802_592_000)
+        var payload = Data()
+        payload.append(0x0D) // field 1, fixed32 usage percent
+        var percentBits = Float(33).bitPattern.littleEndian
+        withUnsafeBytes(of: &percentBits) { payload.append(contentsOf: $0) }
+        payload.append(0x10) // field 2, varint billing start
+        payload.append(contentsOf: Self.varint(recentStart))
+        payload.append(0x18) // field 3, varint billing end
+        payload.append(contentsOf: Self.varint(billingEnd))
+
+        let snapshot = try GrokWebBillingFetcher.parseGRPCWebResponse(
+            Self.grpcFrame(payload),
+            now: Date(timeIntervalSince1970: TimeInterval(recentStart + 1800)))
+
+        #expect(snapshot.resetsAt == Date(timeIntervalSince1970: TimeInterval(billingEnd)))
+    }
+
+    @Test
+    func `web fetch posts grpc web request with bearer token`() async throws {
+        defer {
+            GrokWebBillingStubURLProtocol.requests = []
+            GrokWebBillingStubURLProtocol.requestBodies = []
+            GrokWebBillingStubURLProtocol.handler = nil
+        }
+
+        let config = URLSessionConfiguration.ephemeral
+        config.protocolClasses = [GrokWebBillingStubURLProtocol.self]
+        let session = URLSession(configuration: config)
+        let endpoint = try #require(URL(string: "https://grok.test/grok_api_v2.GrokBuildBilling/GetGrokCreditsConfig"))
+        let reset = UInt64(1_800_000_002)
+
+        GrokWebBillingStubURLProtocol.requests = []
+        GrokWebBillingStubURLProtocol.requestBodies = []
+        GrokWebBillingStubURLProtocol.handler = { request in
+            let url = try #require(request.url)
+            #expect(url == endpoint)
+            #expect(request.httpMethod == "POST")
+            #expect(request.value(forHTTPHeaderField: "Authorization") == "Bearer token-123")
+            #expect(request.value(forHTTPHeaderField: "Origin") == "https://grok.com")
+            #expect(request.value(forHTTPHeaderField: "Referer") == "https://grok.com/?_s=usage")
+            #expect(request.value(forHTTPHeaderField: "Accept") == "*/*")
+            #expect(request.value(forHTTPHeaderField: "Content-Type") == "application/grpc-web+proto")
+            #expect(request.value(forHTTPHeaderField: "x-grpc-web") == "1")
+            #expect(request.timeoutInterval == 15)
+
+            let response = HTTPURLResponse(
+                url: url,
+                statusCode: 200,
+                httpVersion: nil,
+                headerFields: ["Content-Type": "application/grpc-web+proto"])!
+            let body = Self.grpcFrame(Self.protobufPayload(usedPercent: 55.5, resetEpoch: reset))
+            return (response, body)
+        }
+
+        let snapshot = try await GrokWebBillingFetcher.fetch(
+            credentials: Self.credentials,
+            session: session,
+            endpoint: endpoint)
+
+        #expect(GrokWebBillingStubURLProtocol.requests.count == 1)
+        #expect(GrokWebBillingStubURLProtocol.requestBodies == [Data([0x00, 0x00, 0x00, 0x00, 0x00])])
+        #expect(snapshot.usedPercent == 55.5)
+        #expect(snapshot.resetsAt == Date(timeIntervalSince1970: TimeInterval(reset)))
+    }
+
+    @Test
+    func `web fetch retries transient grpc timeout once`() async throws {
+        defer {
+            GrokWebBillingStubURLProtocol.requests = []
+            GrokWebBillingStubURLProtocol.requestBodies = []
+            GrokWebBillingStubURLProtocol.handler = nil
+        }
+
+        let config = URLSessionConfiguration.ephemeral
+        config.protocolClasses = [GrokWebBillingStubURLProtocol.self]
+        let session = URLSession(configuration: config)
+        let endpoint = try #require(URL(string: "https://grok.test/grok_api_v2.GrokBuildBilling/GetGrokCreditsConfig"))
+        let reset = UInt64(1_800_000_005)
+        let attempts = AttemptCounter()
+
+        GrokWebBillingStubURLProtocol.requests = []
+        GrokWebBillingStubURLProtocol.requestBodies = []
+        GrokWebBillingStubURLProtocol.handler = { request in
+            let attempt = attempts.increment()
+            let url = try #require(request.url)
+            let response = HTTPURLResponse(
+                url: url,
+                statusCode: 200,
+                httpVersion: nil,
+                headerFields: ["Content-Type": "application/grpc-web+proto"])!
+            if attempt == 1 {
+                let body = Self.grpcFrame(
+                    Data("grpc-status: 1\r\ngrpc-message: Timeout%20expired\r\n".utf8),
+                    flags: 0x80)
+                return (response, body)
+            }
+            return (response, Self.grpcFrame(Self.protobufPayload(usedPercent: 25, resetEpoch: reset)))
+        }
+
+        let snapshot = try await GrokWebBillingFetcher.fetch(
+            credentials: Self.credentials,
+            session: session,
+            endpoint: endpoint)
+
+        #expect(attempts.current() == 2)
+        #expect(GrokWebBillingStubURLProtocol.requests.count == 2)
+        #expect(snapshot.usedPercent == 25)
+        #expect(snapshot.resetsAt == Date(timeIntervalSince1970: TimeInterval(reset)))
+    }
+
+    @Test
+    func `web fetch retries grpc deadline exceeded without message`() async throws {
+        defer {
+            GrokWebBillingStubURLProtocol.requests = []
+            GrokWebBillingStubURLProtocol.requestBodies = []
+            GrokWebBillingStubURLProtocol.handler = nil
+        }
+
+        let config = URLSessionConfiguration.ephemeral
+        config.protocolClasses = [GrokWebBillingStubURLProtocol.self]
+        let session = URLSession(configuration: config)
+        let endpoint = try #require(URL(string: "https://grok.test/grok_api_v2.GrokBuildBilling/GetGrokCreditsConfig"))
+        let attempts = AttemptCounter()
+
+        GrokWebBillingStubURLProtocol.requests = []
+        GrokWebBillingStubURLProtocol.requestBodies = []
+        GrokWebBillingStubURLProtocol.handler = { request in
+            let attempt = attempts.increment()
+            let url = try #require(request.url)
+            let response = HTTPURLResponse(
+                url: url,
+                statusCode: 200,
+                httpVersion: nil,
+                headerFields: ["Content-Type": "application/grpc-web+proto"])!
+            if attempt == 1 {
+                return (response, Self.grpcFrame(Data("grpc-status: 4\r\n".utf8), flags: 0x80))
+            }
+            return (response, Self.grpcFrame(Self.protobufPayload(usedPercent: 25, resetEpoch: 1_800_000_005)))
+        }
+
+        let snapshot = try await GrokWebBillingFetcher.fetch(
+            credentials: Self.credentials,
+            session: session,
+            endpoint: endpoint)
+
+        #expect(attempts.current() == 2)
+        #expect(snapshot.usedPercent == 25)
+    }
+
+    @Test
+    func `web fetch retries HTTP gateway timeout once`() async throws {
+        defer {
+            GrokWebBillingStubURLProtocol.requests = []
+            GrokWebBillingStubURLProtocol.requestBodies = []
+            GrokWebBillingStubURLProtocol.handler = nil
+        }
+
+        let config = URLSessionConfiguration.ephemeral
+        config.protocolClasses = [GrokWebBillingStubURLProtocol.self]
+        let session = URLSession(configuration: config)
+        let endpoint = try #require(URL(string: "https://grok.test/grok_api_v2.GrokBuildBilling/GetGrokCreditsConfig"))
+        let attempts = AttemptCounter()
+
+        GrokWebBillingStubURLProtocol.requests = []
+        GrokWebBillingStubURLProtocol.requestBodies = []
+        GrokWebBillingStubURLProtocol.handler = { request in
+            let attempt = attempts.increment()
+            let url = try #require(request.url)
+            let statusCode = attempt == 1 ? 504 : 200
+            let response = HTTPURLResponse(
+                url: url,
+                statusCode: statusCode,
+                httpVersion: nil,
+                headerFields: ["Content-Type": "application/grpc-web+proto"])!
+            if attempt == 1 {
+                return (response, Data("gateway timeout".utf8))
+            }
+            return (response, Self.grpcFrame(Self.protobufPayload(usedPercent: 25, resetEpoch: 1_800_000_005)))
+        }
+
+        let snapshot = try await GrokWebBillingFetcher.fetch(
+            credentials: Self.credentials,
+            session: session,
+            endpoint: endpoint)
+
+        #expect(attempts.current() == 2)
+        #expect(snapshot.usedPercent == 25)
+    }
+
+    @Test
+    func `web fetch can authenticate with browser cookies`() async throws {
+        defer {
+            GrokWebBillingStubURLProtocol.requests = []
+            GrokWebBillingStubURLProtocol.requestBodies = []
+            GrokWebBillingStubURLProtocol.handler = nil
+        }
+
+        let config = URLSessionConfiguration.ephemeral
+        config.protocolClasses = [GrokWebBillingStubURLProtocol.self]
+        let session = URLSession(configuration: config)
+        let endpoint = try #require(URL(string: "https://grok.test/grok_api_v2.GrokBuildBilling/GetGrokCreditsConfig"))
+
+        GrokWebBillingStubURLProtocol.requests = []
+        GrokWebBillingStubURLProtocol.requestBodies = []
+        GrokWebBillingStubURLProtocol.handler = { request in
+            #expect(request.value(forHTTPHeaderField: "Cookie") == "sso=session; sso-rw=session")
+            #expect(request.value(forHTTPHeaderField: "Authorization") == nil)
+            #expect(request.value(forHTTPHeaderField: "x-user-agent") == "connect-es/2.1.1")
+            let response = HTTPURLResponse(
+                url: endpoint,
+                statusCode: 200,
+                httpVersion: nil,
+                headerFields: ["Content-Type": "application/grpc-web+proto"])!
+            let body = Self.grpcFrame(Self.protobufPayload(usedPercent: 9, resetEpoch: 1_800_000_004))
+            return (response, body)
+        }
+
+        let snapshot = try await GrokWebBillingFetcher.fetch(
+            cookieHeader: "sso=session; sso-rw=session",
+            session: session,
+            endpoint: endpoint)
+
+        #expect(snapshot.usedPercent == 9)
+    }
+
+    @Test
+    func `web fetch sends browser cookies with bearer credentials`() async throws {
+        defer {
+            GrokWebBillingStubURLProtocol.requests = []
+            GrokWebBillingStubURLProtocol.requestBodies = []
+            GrokWebBillingStubURLProtocol.handler = nil
+        }
+
+        let config = URLSessionConfiguration.ephemeral
+        config.protocolClasses = [GrokWebBillingStubURLProtocol.self]
+        let session = URLSession(configuration: config)
+        let endpoint = try #require(URL(string: "https://grok.test/grok_api_v2.GrokBuildBilling/GetGrokCreditsConfig"))
+
+        GrokWebBillingStubURLProtocol.requests = []
+        GrokWebBillingStubURLProtocol.requestBodies = []
+        GrokWebBillingStubURLProtocol.handler = { request in
+            #expect(request.value(forHTTPHeaderField: "Cookie") == "sso=session")
+            #expect(request.value(forHTTPHeaderField: "Authorization") == "Bearer token-123")
+            let response = HTTPURLResponse(
+                url: endpoint,
+                statusCode: 200,
+                httpVersion: nil,
+                headerFields: ["Content-Type": "application/grpc-web+proto"])!
+            return (response, Self.protobufPayload(usedPercent: 9, resetEpoch: 1_800_000_004))
+        }
+
+        let snapshot = try await GrokWebBillingFetcher.fetch(
+            cookieHeader: "sso=session",
+            credentials: Self.credentials,
+            session: session,
+            endpoint: endpoint)
+
+        #expect(snapshot.usedPercent == 9)
+    }
+
+    @Test
+    func `web fetch turns unauthorized response into reauth guidance`() async throws {
+        defer {
+            GrokWebBillingStubURLProtocol.requests = []
+            GrokWebBillingStubURLProtocol.requestBodies = []
+            GrokWebBillingStubURLProtocol.handler = nil
+        }
+
+        let config = URLSessionConfiguration.ephemeral
+        config.protocolClasses = [GrokWebBillingStubURLProtocol.self]
+        let session = URLSession(configuration: config)
+        let endpoint = try #require(URL(string: "https://grok.test/grok_api_v2.GrokBuildBilling/GetGrokCreditsConfig"))
+
+        GrokWebBillingStubURLProtocol.requests = []
+        GrokWebBillingStubURLProtocol.requestBodies = []
+        GrokWebBillingStubURLProtocol.handler = { request in
+            let url = try #require(request.url)
+            let response = HTTPURLResponse(
+                url: url,
+                statusCode: 401,
+                httpVersion: nil,
+                headerFields: ["Content-Type": "text/plain"])!
+            return (response, Data("unauthorized".utf8))
+        }
+
+        await #expect {
+            _ = try await GrokWebBillingFetcher.fetch(
+                credentials: Self.credentials,
+                session: session,
+                endpoint: endpoint)
+        } throws: { error in
+            error.localizedDescription.contains("grok login")
+        }
+    }
+
+    @Test
+    func `usage snapshot maps web billing when cli billing is absent`() {
+        let snapshot = GrokUsageSnapshot(
+            billing: nil,
+            webBilling: GrokWebBillingSnapshot(
+                usedPercent: 67.25,
+                resetsAt: Date(timeIntervalSince1970: 1_800_000_003)),
+            credentials: Self.credentials,
+            localSummary: nil,
+            cliVersion: nil,
+            updatedAt: Date(timeIntervalSince1970: 1_799_000_000))
+
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.primary?.usedPercent == 67.25)
+        #expect(usage.primary?.windowMinutes == nil)
+        #expect(usage.primary?.resetsAt == Date(timeIntervalSince1970: 1_800_000_003))
+        #expect(usage.accountEmail(for: .grok) == "grok@example.com")
+        #expect(usage.loginMethod(for: .grok) == "SuperGrok")
+    }
+
+    private static let credentials = GrokCredentials(
+        accessToken: "token-123",
+        refreshToken: "refresh-123",
+        scope: "https://auth.x.ai::client",
+        authMode: "oidc",
+        userId: "user-123",
+        email: "grok@example.com",
+        firstName: "G",
+        lastName: "Rok",
+        teamId: "team-123",
+        oidcIssuer: "https://auth.x.ai",
+        oidcClientId: "client",
+        expiresAt: Date(timeIntervalSince1970: 1_900_000_000),
+        createTime: Date(timeIntervalSince1970: 1_799_000_000))
+
+    private static func protobufPayload(usedPercent: Float, resetEpoch: UInt64) -> Data {
+        var data = Data()
+        data.append(0x0D) // field 1, fixed32
+        var percentBits = usedPercent.bitPattern.littleEndian
+        withUnsafeBytes(of: &percentBits) { data.append(contentsOf: $0) }
+        data.append(0x10) // field 2, varint
+        data.append(contentsOf: Self.varint(resetEpoch))
+        return data
+    }
+
+    private static func grpcFrame(_ payload: Data, flags: UInt8 = 0x00) -> Data {
+        var data = Data([flags])
+        let length = UInt32(payload.count).bigEndian
+        withUnsafeBytes(of: length) { data.append(contentsOf: $0) }
+        data.append(payload)
+        return data
+    }
+
+    private static func varint(_ value: UInt64) -> [UInt8] {
+        var remaining = value
+        var bytes: [UInt8] = []
+        repeat {
+            var byte = UInt8(remaining & 0x7F)
+            remaining >>= 7
+            if remaining != 0 { byte |= 0x80 }
+            bytes.append(byte)
+        } while remaining != 0
+        return bytes
+    }
+
+    private static func cookie(name: String, value: String) -> HTTPCookie? {
+        HTTPCookie(properties: [
+            .domain: "grok.com",
+            .path: "/",
+            .name: name,
+            .value: value,
+        ])
+    }
+
+    private static func data(hexString: String) -> Data? {
+        var data = Data()
+        var index = hexString.startIndex
+        while index < hexString.endIndex {
+            let next = hexString.index(index, offsetBy: 2, limitedBy: hexString.endIndex) ?? hexString.endIndex
+            guard let byte = UInt8(hexString[index..<next], radix: 16) else { return nil }
+            data.append(byte)
+            index = next
+        }
+        return data
+    }
+}
+
+final class GrokWebBillingStubURLProtocol: URLProtocol {
+    nonisolated(unsafe) static var requests: [URLRequest] = []
+    nonisolated(unsafe) static var requestBodies: [Data?] = []
+    nonisolated(unsafe) static var handler: (@Sendable (URLRequest) throws -> (HTTPURLResponse, Data))?
+
+    override static func canInit(with _: URLRequest) -> Bool {
+        true
+    }
+
+    override static func canonicalRequest(for request: URLRequest) -> URLRequest {
+        request
+    }
+
+    override func startLoading() {
+        Self.requests.append(self.request)
+        Self.requestBodies.append(Self.readBody(from: self.request))
+        guard let handler = Self.handler else {
+            self.client?.urlProtocol(self, didFailWithError: URLError(.badServerResponse))
+            return
+        }
+
+        do {
+            let (response, data) = try handler(self.request)
+            self.client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
+            self.client?.urlProtocol(self, didLoad: data)
+            self.client?.urlProtocolDidFinishLoading(self)
+        } catch {
+            self.client?.urlProtocol(self, didFailWithError: error)
+        }
+    }
+
+    override func stopLoading() {}
+
+    private static func readBody(from request: URLRequest) -> Data? {
+        if let body = request.httpBody { return body }
+        guard let stream = request.httpBodyStream else { return nil }
+        stream.open()
+        defer { stream.close() }
+        var data = Data()
+        var buffer = [UInt8](repeating: 0, count: 1024)
+        while stream.hasBytesAvailable {
+            let count = stream.read(&buffer, maxLength: buffer.count)
+            if count > 0 {
+                data.append(buffer, count: count)
+            } else {
+                break
+            }
+        }
+        return data
+    }
+}
diff --git a/Tests/CodexBarTests/GroqUsageFetcherTests.swift b/Tests/CodexBarTests/GroqUsageFetcherTests.swift
new file mode 100644
index 0000000000..2924e9501e
--- /dev/null
+++ b/Tests/CodexBarTests/GroqUsageFetcherTests.swift
@@ -0,0 +1,41 @@
+import CodexBarCore
+import Foundation
+import Testing
+
+struct GroqUsageFetcherTests {
+    @Test
+    func `parses prometheus scalar response`() throws {
+        let json = """
+        {
+          "status": "success",
+          "data": {
+            "result": [
+              { "value": [1710000000, "2.5"] },
+              { "value": [1710000000, "1.5"] }
+            ]
+          }
+        }
+        """
+
+        let value = try GroqUsageFetcher._parseScalarForTesting(Data(json.utf8))
+
+        #expect(value == 4)
+    }
+
+    @Test
+    func `snapshot maps prometheus rates to menu windows`() {
+        let snapshot = GroqUsageSnapshot(
+            requestRatePerSecond: 2,
+            inputTokenRatePerSecond: 100,
+            outputTokenRatePerSecond: 50,
+            promptCacheHitRatePerSecond: 3,
+            updatedAt: Date(timeIntervalSince1970: 1))
+            .toUsageSnapshot()
+
+        #expect(snapshot.identity?.providerID == .groq)
+        #expect(snapshot.identity?.loginMethod == "Prometheus metrics")
+        #expect(snapshot.primary?.resetDescription == "120 req/min")
+        #expect(snapshot.secondary?.resetDescription == "9000 tok/min")
+        #expect(snapshot.tertiary?.resetDescription == "180 cache/min")
+    }
+}
diff --git a/Tests/CodexBarTests/HistoricalUsagePaceBackfillAuthorityTests.swift b/Tests/CodexBarTests/HistoricalUsagePaceBackfillAuthorityTests.swift
new file mode 100644
index 0000000000..f49dbc31f1
--- /dev/null
+++ b/Tests/CodexBarTests/HistoricalUsagePaceBackfillAuthorityTests.swift
@@ -0,0 +1,510 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+extension HistoricalUsagePaceTests {
+    @MainActor
+    @Test
+    func `backfill skips when dashboard authority is display only`() async throws {
+        let store = try Self.makeUsageStoreForBackfillTests(
+            suite: "HistoricalUsagePaceTests-backfill-display-only",
+            historyFileURL: Self.makeTempURL())
+        store._setCodexHistoricalDatasetForTesting(nil)
+
+        let snapshotNow = Date(timeIntervalSince1970: 1_770_000_000)
+        let dashboard = OpenAIDashboardSnapshot(
+            signedInEmail: "shared@example.com",
+            codeReviewRemainingPercent: nil,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: Self.syntheticBreakdown(endingAt: snapshotNow, days: 35, dailyCredits: 10),
+            creditsPurchaseURL: nil,
+            primaryLimit: nil,
+            secondaryLimit: RateWindow(
+                usedPercent: 50,
+                windowMinutes: 10080,
+                resetsAt: snapshotNow.addingTimeInterval(2 * 24 * 60 * 60),
+                resetDescription: nil),
+            creditsRemaining: nil,
+            accountPlan: nil,
+            updatedAt: snapshotNow)
+
+        store.backfillCodexHistoricalFromDashboardIfNeeded(
+            dashboard,
+            authorityDecision: CodexDashboardAuthorityDecision(
+                disposition: .displayOnly,
+                reason: .sameEmailAmbiguity(email: "shared@example.com"),
+                allowedEffects: [],
+                cleanup: Set(CodexDashboardCleanup.allCases)),
+            attachedAccountEmail: "shared@example.com")
+
+        try await Task.sleep(for: .milliseconds(250))
+        #expect(store.codexHistoricalDataset == nil)
+    }
+
+    @MainActor
+    @Test
+    func `backfill skips when dashboard authority fail closes`() async throws {
+        let store = try Self.makeUsageStoreForBackfillTests(
+            suite: "HistoricalUsagePaceTests-backfill-fail-closed",
+            historyFileURL: Self.makeTempURL())
+        store._setCodexHistoricalDatasetForTesting(nil)
+
+        let snapshotNow = Date(timeIntervalSince1970: 1_770_000_000)
+        let dashboard = OpenAIDashboardSnapshot(
+            signedInEmail: "wrong@example.com",
+            codeReviewRemainingPercent: nil,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: Self.syntheticBreakdown(endingAt: snapshotNow, days: 35, dailyCredits: 10),
+            creditsPurchaseURL: nil,
+            primaryLimit: nil,
+            secondaryLimit: RateWindow(
+                usedPercent: 50,
+                windowMinutes: 10080,
+                resetsAt: snapshotNow.addingTimeInterval(2 * 24 * 60 * 60),
+                resetDescription: nil),
+            creditsRemaining: nil,
+            accountPlan: nil,
+            updatedAt: snapshotNow)
+
+        store.backfillCodexHistoricalFromDashboardIfNeeded(
+            dashboard,
+            authorityDecision: CodexDashboardAuthorityDecision(
+                disposition: .failClosed,
+                reason: .wrongEmail(expected: "expected@example.com", actual: "wrong@example.com"),
+                allowedEffects: [],
+                cleanup: Set(CodexDashboardCleanup.allCases)),
+            attachedAccountEmail: "expected@example.com")
+
+        try await Task.sleep(for: .milliseconds(250))
+        #expect(store.codexHistoricalDataset == nil)
+    }
+
+    @MainActor
+    @Test
+    func `backfill uses dashboard secondary when available`() async throws {
+        let store = try Self.makeUsageStoreForBackfillTests(
+            suite: "HistoricalUsagePaceTests-backfill-dashboard-secondary",
+            historyFileURL: Self.makeTempURL())
+        store._setCodexHistoricalDatasetForTesting(nil)
+
+        let snapshotNow = Date(timeIntervalSince1970: 1_770_000_000)
+        let staleSnapshot = UsageSnapshot(
+            primary: nil,
+            secondary: RateWindow(
+                usedPercent: 5,
+                windowMinutes: 10080,
+                resetsAt: snapshotNow.addingTimeInterval(2 * 24 * 60 * 60),
+                resetDescription: nil),
+            tertiary: nil,
+            providerCost: nil,
+            updatedAt: snapshotNow.addingTimeInterval(-30 * 60),
+            identity: nil)
+        store._setSnapshotForTesting(staleSnapshot, provider: .codex)
+
+        let dashboard = OpenAIDashboardSnapshot(
+            signedInEmail: nil,
+            codeReviewRemainingPercent: nil,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: Self.syntheticBreakdown(endingAt: snapshotNow, days: 35, dailyCredits: 10),
+            creditsPurchaseURL: nil,
+            primaryLimit: nil,
+            secondaryLimit: RateWindow(
+                usedPercent: 50,
+                windowMinutes: 10080,
+                resetsAt: snapshotNow.addingTimeInterval(2 * 24 * 60 * 60),
+                resetDescription: nil),
+            creditsRemaining: nil,
+            accountPlan: nil,
+            updatedAt: snapshotNow)
+        store.backfillCodexHistoricalFromDashboardIfNeeded(
+            dashboard,
+            authorityDecision: CodexDashboardAuthorityDecision(
+                disposition: .attach,
+                reason: .trustedEmailMatchNoCompetingOwner,
+                allowedEffects: [.historicalBackfill],
+                cleanup: []),
+            attachedAccountEmail: "attached@example.com")
+
+        for _ in 0..<40 {
+            if (store.codexHistoricalDataset?.weeks.count ?? 0) >= 3 {
+                break
+            }
+            try await Task.sleep(for: .milliseconds(50))
+        }
+        #expect((store.codexHistoricalDataset?.weeks.count ?? 0) >= 3)
+    }
+
+    @MainActor
+    @Test
+    func `backfill uses normalized dashboard weekly when only primary window is weekly`() async throws {
+        let store = try Self.makeUsageStoreForBackfillTests(
+            suite: "HistoricalUsagePaceTests-backfill-normalized-dashboard-weekly",
+            historyFileURL: Self.makeTempURL())
+        store._setCodexHistoricalDatasetForTesting(nil)
+
+        let snapshotNow = Date(timeIntervalSince1970: 1_770_000_000)
+        let seededSnapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 22,
+                windowMinutes: 300,
+                resetsAt: snapshotNow.addingTimeInterval(2 * 60 * 60),
+                resetDescription: nil),
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: snapshotNow,
+            identity: nil)
+        store._setSnapshotForTesting(seededSnapshot, provider: .codex)
+
+        let dashboard = OpenAIDashboardSnapshot(
+            signedInEmail: nil,
+            codeReviewRemainingPercent: nil,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: Self.syntheticBreakdown(endingAt: snapshotNow, days: 35, dailyCredits: 10),
+            creditsPurchaseURL: nil,
+            primaryLimit: RateWindow(
+                usedPercent: 50,
+                windowMinutes: 10080,
+                resetsAt: snapshotNow.addingTimeInterval(2 * 24 * 60 * 60),
+                resetDescription: nil),
+            secondaryLimit: nil,
+            creditsRemaining: nil,
+            accountPlan: nil,
+            updatedAt: snapshotNow)
+        store.backfillCodexHistoricalFromDashboardIfNeeded(
+            dashboard,
+            authorityDecision: CodexDashboardAuthorityDecision(
+                disposition: .attach,
+                reason: .trustedEmailMatchNoCompetingOwner,
+                allowedEffects: [.historicalBackfill],
+                cleanup: []),
+            attachedAccountEmail: "attached@example.com")
+
+        for _ in 0..<40 {
+            if (store.codexHistoricalDataset?.weeks.count ?? 0) >= 3 {
+                break
+            }
+            try await Task.sleep(for: .milliseconds(50))
+        }
+        #expect((store.codexHistoricalDataset?.weeks.count ?? 0) >= 3)
+    }
+
+    @MainActor
+    @Test
+    func `backfill uses attached account email from authority instead of dashboard email`() async throws {
+        let store = try Self.makeUsageStoreForBackfillTests(
+            suite: "HistoricalUsagePaceTests-backfill-attached-email",
+            historyFileURL: Self.makeTempURL())
+        let isolatedHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-historical-attached-email-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: isolatedHome, withIntermediateDirectories: true)
+        store.settings._test_liveSystemCodexAccount = nil
+        store.settings._test_codexReconciliationEnvironment = ["CODEX_HOME": isolatedHome.path]
+        defer {
+            store.settings._test_codexReconciliationEnvironment = nil
+            try? FileManager.default.removeItem(at: isolatedHome)
+        }
+        store._setCodexHistoricalDatasetForTesting(nil)
+
+        let snapshotNow = Date(timeIntervalSince1970: 1_770_000_000)
+        let dashboard = OpenAIDashboardSnapshot(
+            signedInEmail: "dashboard@example.com",
+            codeReviewRemainingPercent: nil,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: Self.syntheticBreakdown(endingAt: snapshotNow, days: 35, dailyCredits: 10),
+            creditsPurchaseURL: nil,
+            primaryLimit: nil,
+            secondaryLimit: RateWindow(
+                usedPercent: 50,
+                windowMinutes: 10080,
+                resetsAt: snapshotNow.addingTimeInterval(2 * 24 * 60 * 60),
+                resetDescription: nil),
+            creditsRemaining: nil,
+            accountPlan: nil,
+            updatedAt: snapshotNow)
+
+        store.backfillCodexHistoricalFromDashboardIfNeeded(
+            dashboard,
+            authorityDecision: CodexDashboardAuthorityDecision(
+                disposition: .attach,
+                reason: .trustedEmailMatchNoCompetingOwner,
+                allowedEffects: [.historicalBackfill],
+                cleanup: []),
+            attachedAccountEmail: "attached@example.com")
+
+        for _ in 0..<40 {
+            if store.codexHistoricalDatasetAccountKey != nil {
+                break
+            }
+            try await Task.sleep(for: .milliseconds(50))
+        }
+
+        #expect(
+            store.codexHistoricalDatasetAccountKey ==
+                CodexHistoryOwnership.canonicalEmailHashKey(for: "attached@example.com"))
+        #expect(
+            store.codexHistoricalDatasetAccountKey !=
+                CodexHistoryOwnership.canonicalEmailHashKey(for: "dashboard@example.com"))
+    }
+
+    @Test
+    func `will last decision uses smoothed probability when risk hidden`() throws {
+        let now = Date(timeIntervalSince1970: 0)
+        let windowMinutes = 10080
+        let duration = TimeInterval(windowMinutes) * 60
+        let currentResetsAt = now.addingTimeInterval(duration / 2)
+        let window = RateWindow(
+            usedPercent: 50,
+            windowMinutes: windowMinutes,
+            resetsAt: currentResetsAt,
+            resetDescription: nil)
+
+        let weeks = (0..<4).map { index in
+            HistoricalWeekProfile(
+                resetsAt: currentResetsAt.addingTimeInterval(-duration * Double(index + 1)),
+                windowMinutes: windowMinutes,
+                curve: Self.linearCurve(end: 100))
+        }
+        let pace = try #require(CodexHistoricalPaceEvaluator.evaluate(
+            window: window,
+            now: now,
+            dataset: CodexHistoricalDataset(weeks: weeks)))
+        #expect(pace.runOutProbability == nil)
+
+        let totalWeight = weeks.enumerated().reduce(0.0) { partial, element in
+            let ageWeeks = currentResetsAt.timeIntervalSince(element.element.resetsAt) / duration
+            return partial + exp(-ageWeeks / 3.0)
+        }
+        let smoothedProbability = (totalWeight + 0.5) / (totalWeight + 1.0)
+        #expect(pace.willLastToReset == (smoothedProbability < 0.5))
+    }
+
+    @MainActor
+    @Test
+    func `usage store falls back to linear when history disabled or insufficient`() throws {
+        let suite = "HistoricalUsagePaceTests-usage-store"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore(),
+            codexCookieStore: InMemoryCookieHeaderStore(),
+            claudeCookieStore: InMemoryCookieHeaderStore(),
+            cursorCookieStore: InMemoryCookieHeaderStore(),
+            opencodeCookieStore: InMemoryCookieHeaderStore(),
+            factoryCookieStore: InMemoryCookieHeaderStore(),
+            minimaxCookieStore: InMemoryMiniMaxCookieStore(),
+            minimaxAPITokenStore: InMemoryMiniMaxAPITokenStore(),
+            kimiTokenStore: InMemoryKimiTokenStore(),
+            kimiK2TokenStore: InMemoryKimiK2TokenStore(),
+            augmentCookieStore: InMemoryCookieHeaderStore(),
+            ampCookieStore: InMemoryCookieHeaderStore(),
+            copilotTokenStore: InMemoryCopilotTokenStore(),
+            tokenAccountStore: InMemoryTokenAccountStore())
+        settings.historicalTrackingEnabled = true
+        settings.weeklyProgressWorkDays = 5
+
+        let planHistoryStore = testPlanUtilizationHistoryStore(
+            suiteName: "HistoricalUsagePaceTests-\(UUID().uuidString)")
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            historicalUsageHistoryStore: HistoricalUsageHistoryStore(fileURL: Self.makeTempURL()),
+            planUtilizationHistoryStore: planHistoryStore)
+
+        let now = Date(timeIntervalSince1970: 0)
+        let window = RateWindow(
+            usedPercent: 50,
+            windowMinutes: 10080,
+            resetsAt: now.addingTimeInterval(4 * 24 * 60 * 60),
+            resetDescription: nil)
+
+        let twoWeeksDataset = CodexHistoricalDataset(weeks: [
+            HistoricalWeekProfile(
+                resetsAt: now.addingTimeInterval(-7 * 24 * 60 * 60),
+                windowMinutes: 10080,
+                curve: Self.linearCurve(end: 100)),
+            HistoricalWeekProfile(
+                resetsAt: now.addingTimeInterval(-14 * 24 * 60 * 60),
+                windowMinutes: 10080,
+                curve: Self.linearCurve(end: 100)),
+        ])
+        store._setCodexHistoricalDatasetForTesting(twoWeeksDataset)
+
+        let computed = store.weeklyPace(provider: .codex, window: window, now: now)
+        let workdayAware = UsagePace.weekly(
+            window: window,
+            now: now,
+            defaultWindowMinutes: 10080,
+            workDays: 5)
+        #expect(computed != nil)
+        #expect(abs((computed?.deltaPercent ?? 0) - (workdayAware?.deltaPercent ?? 0)) < 0.001)
+    }
+
+    @MainActor
+    @Test
+    func `usage store preserves historical Codex pace when work days are off`() throws {
+        let suite = "HistoricalUsagePaceTests-workdays-off-preserve-history-\(UUID().uuidString)"
+        let store = try Self.makeUsageStoreForBackfillTests(
+            suite: suite,
+            historyFileURL: Self.makeTempURL())
+        store.settings.weeklyProgressWorkDays = nil
+
+        let now = Date(timeIntervalSince1970: 0)
+        let duration = TimeInterval(10080 * 60)
+        let resetsAt = now.addingTimeInterval(duration / 2)
+        let window = RateWindow(
+            usedPercent: 60,
+            windowMinutes: 10080,
+            resetsAt: resetsAt,
+            resetDescription: nil)
+        let dataset = CodexHistoricalDataset(weeks: (0..<4).map { index in
+            HistoricalWeekProfile(
+                resetsAt: resetsAt.addingTimeInterval(-duration * Double(index + 1)),
+                windowMinutes: 10080,
+                curve: Self.linearCurve(end: 80))
+        })
+        let expected = try #require(CodexHistoricalPaceEvaluator.evaluate(
+            window: window,
+            now: now,
+            dataset: dataset))
+        let linear = try #require(UsagePace.weekly(window: window, now: now, workDays: nil))
+        store._setCodexHistoricalDatasetForTesting(
+            dataset,
+            accountKey: store.codexOwnershipContext().canonicalKey)
+
+        let computed = try #require(store.weeklyPace(provider: .codex, window: window, now: now))
+
+        #expect(abs(expected.expectedUsedPercent - linear.expectedUsedPercent) > 0.001)
+        #expect(abs(computed.expectedUsedPercent - expected.expectedUsedPercent) < 0.001)
+        #expect(abs(computed.deltaPercent - expected.deltaPercent) < 0.001)
+        #expect(computed.etaSeconds == expected.etaSeconds)
+        #expect(computed.willLastToReset == expected.willLastToReset)
+        #expect(computed.runOutProbability == expected.runOutProbability)
+    }
+
+    @MainActor
+    @Test
+    func `usage store preserves historical Codex pace when work days are configured`() throws {
+        let suite = "HistoricalUsagePaceTests-workdays-preserve-history-\(UUID().uuidString)"
+        let store = try Self.makeUsageStoreForBackfillTests(
+            suite: suite,
+            historyFileURL: Self.makeTempURL())
+        store.settings.weeklyProgressWorkDays = 5
+
+        let now = Date(timeIntervalSince1970: 0)
+        let duration = TimeInterval(10080 * 60)
+        let resetsAt = now.addingTimeInterval(duration / 2)
+        let window = RateWindow(
+            usedPercent: 60,
+            windowMinutes: 10080,
+            resetsAt: resetsAt,
+            resetDescription: nil)
+        let weeks = (0..<4).map { index in
+            HistoricalWeekProfile(
+                resetsAt: resetsAt.addingTimeInterval(-duration * Double(index + 1)),
+                windowMinutes: 10080,
+                curve: Self.linearCurve(end: 80))
+        }
+        let dataset = CodexHistoricalDataset(weeks: weeks)
+        let expected = try #require(CodexHistoricalPaceEvaluator.evaluate(
+            window: window,
+            now: now,
+            dataset: dataset))
+        store._setCodexHistoricalDatasetForTesting(
+            dataset,
+            accountKey: store.codexOwnershipContext().canonicalKey)
+
+        let computed = try #require(store.weeklyPace(provider: .codex, window: window, now: now))
+
+        #expect(abs(computed.expectedUsedPercent - expected.expectedUsedPercent) < 0.001)
+        #expect(abs(computed.deltaPercent - expected.deltaPercent) < 0.001)
+        #expect(computed.etaSeconds == expected.etaSeconds)
+        #expect(computed.willLastToReset == expected.willLastToReset)
+        #expect(computed.runOutProbability == expected.runOutProbability)
+    }
+
+    @MainActor
+    @Test
+    func `usage store computes linear pace for providers with quota windows`() throws {
+        let suite = "HistoricalUsagePaceTests-generic-provider-\(UUID().uuidString)"
+        let store = try Self.makeUsageStoreForBackfillTests(
+            suite: suite,
+            historyFileURL: Self.makeTempURL())
+
+        let now = Date(timeIntervalSince1970: 0)
+        let window = RateWindow(
+            usedPercent: 40,
+            windowMinutes: 10080,
+            resetsAt: now.addingTimeInterval(4 * 24 * 60 * 60),
+            resetDescription: nil)
+
+        let pace = store.weeklyPace(provider: .zai, window: window, now: now)
+
+        #expect(pace != nil)
+        #expect(abs((pace?.deltaPercent ?? 0) - (40 - (3.0 / 7.0 * 100.0))) < 0.001)
+    }
+
+    @MainActor
+    @Test
+    func `usage store applies configured work days to generic weekly pace`() throws {
+        let suite = "HistoricalUsagePaceTests-generic-workdays-\(UUID().uuidString)"
+        let store = try Self.makeUsageStoreForBackfillTests(
+            suite: suite,
+            historyFileURL: Self.makeTempURL())
+        store.settings.weeklyProgressWorkDays = 5
+
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = .current
+        let resetsAt = try #require(calendar.date(from: DateComponents(
+            calendar: calendar,
+            timeZone: calendar.timeZone,
+            year: 2026,
+            month: 6,
+            day: 14)))
+        let now = try #require(calendar.date(from: DateComponents(
+            calendar: calendar,
+            timeZone: calendar.timeZone,
+            year: 2026,
+            month: 6,
+            day: 11)))
+        let window = RateWindow(
+            usedPercent: 60,
+            windowMinutes: 10080,
+            resetsAt: resetsAt,
+            resetDescription: nil)
+
+        let pace = try #require(store.weeklyPace(provider: .zai, window: window, now: now))
+
+        #expect(abs(pace.expectedUsedPercent - 60) < 0.001)
+        #expect(abs(pace.deltaPercent) < 0.001)
+    }
+
+    @MainActor
+    @Test
+    func `usage store returns nil pace when generic window lacks explicit duration`() throws {
+        let suite = "HistoricalUsagePaceTests-no-window-minutes-\(UUID().uuidString)"
+        let store = try Self.makeUsageStoreForBackfillTests(
+            suite: suite,
+            historyFileURL: Self.makeTempURL())
+
+        let now = Date(timeIntervalSince1970: 0)
+        let window = RateWindow(
+            usedPercent: 40,
+            windowMinutes: nil,
+            resetsAt: now.addingTimeInterval(4 * 24 * 60 * 60),
+            resetDescription: nil)
+
+        let pace = store.weeklyPace(provider: .factory, window: window, now: now)
+
+        #expect(pace == nil)
+    }
+}
diff --git a/Tests/CodexBarTests/HistoricalUsagePaceOwnershipTests.swift b/Tests/CodexBarTests/HistoricalUsagePaceOwnershipTests.swift
new file mode 100644
index 0000000000..9cfa9ede16
--- /dev/null
+++ b/Tests/CodexBarTests/HistoricalUsagePaceOwnershipTests.swift
@@ -0,0 +1,444 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+extension HistoricalUsagePaceTests {
+    @Test
+    func `history store ownership aware load aliases legacy email hash into canonical email hash`() async {
+        let fileURL = Self.makeTempURL()
+        let store = HistoricalUsageHistoryStore(fileURL: fileURL)
+        let resetsAt = Date(timeIntervalSince1970: 1_770_000_000)
+        let normalizedEmail = "person@example.com"
+        let legacyEmailHash = CodexHistoryOwnership.legacyEmailHash(normalizedEmail: normalizedEmail)
+        let canonicalKey = CodexHistoryOwnership.canonicalEmailHashKey(for: normalizedEmail)
+
+        await Self.recordCompleteWeek(into: store, resetsAt: resetsAt, accountKey: legacyEmailHash)
+
+        let dataset = await store.loadCodexDataset(
+            canonicalAccountKey: canonicalKey,
+            canonicalEmailHashKey: canonicalKey,
+            legacyEmailHash: legacyEmailHash,
+            hasAdjacentMultiAccountVeto: false)
+
+        #expect(dataset?.weeks.count == 1)
+    }
+
+    @Test
+    func `history store ownership aware load keeps ambiguous nil key history unscoped`() async {
+        let fileURL = Self.makeTempURL()
+        let store = HistoricalUsageHistoryStore(fileURL: fileURL)
+        let resetsAt = Date(timeIntervalSince1970: 1_770_000_000)
+        let targetEmail = "person@example.com"
+        let targetCanonicalKey = CodexHistoryOwnership.canonicalEmailHashKey(for: targetEmail)
+        let targetLegacyEmailHash = CodexHistoryOwnership.legacyEmailHash(normalizedEmail: targetEmail)
+        let otherCanonicalKey = CodexHistoryOwnership.canonicalKey(for: .providerAccount(id: "acct-other"))
+
+        await Self.recordCompleteWeek(into: store, resetsAt: resetsAt, accountKey: nil)
+        _ = await store.recordCodexWeekly(
+            window: RateWindow(
+                usedPercent: 12,
+                windowMinutes: 10080,
+                resetsAt: resetsAt,
+                resetDescription: nil),
+            sampledAt: resetsAt.addingTimeInterval(-(10080 * 60)),
+            accountKey: targetLegacyEmailHash)
+        _ = await store.recordCodexWeekly(
+            window: RateWindow(
+                usedPercent: 18,
+                windowMinutes: 10080,
+                resetsAt: resetsAt,
+                resetDescription: nil),
+            sampledAt: resetsAt.addingTimeInterval(-(10080 * 60) + 60),
+            accountKey: otherCanonicalKey)
+
+        let dataset = await store.loadCodexDataset(
+            canonicalAccountKey: targetCanonicalKey,
+            canonicalEmailHashKey: targetCanonicalKey,
+            legacyEmailHash: targetLegacyEmailHash,
+            hasAdjacentMultiAccountVeto: false)
+
+        #expect(dataset == nil)
+    }
+
+    @Test
+    func `history store ownership aware load adopts nil key history only for strict single owner continuity`() async {
+        let fileURL = Self.makeTempURL()
+        let store = HistoricalUsageHistoryStore(fileURL: fileURL)
+        let resetsAt = Date(timeIntervalSince1970: 1_770_000_000)
+        let normalizedEmail = "person@example.com"
+        let legacyEmailHash = CodexHistoryOwnership.legacyEmailHash(normalizedEmail: normalizedEmail)
+        let canonicalKey = CodexHistoryOwnership.canonicalEmailHashKey(for: normalizedEmail)
+
+        await Self.recordCompleteWeek(into: store, resetsAt: resetsAt, accountKey: nil)
+        _ = await store.recordCodexWeekly(
+            window: RateWindow(
+                usedPercent: 12,
+                windowMinutes: 10080,
+                resetsAt: resetsAt,
+                resetDescription: nil),
+            sampledAt: resetsAt.addingTimeInterval(-(10080 * 60)),
+            accountKey: legacyEmailHash)
+
+        let dataset = await store.loadCodexDataset(
+            canonicalAccountKey: canonicalKey,
+            canonicalEmailHashKey: canonicalKey,
+            legacyEmailHash: legacyEmailHash,
+            hasAdjacentMultiAccountVeto: false)
+
+        #expect(dataset?.weeks.count == 1)
+    }
+
+    @Test
+    func `history store ignores later unrelated owners when evaluating nil key continuity`() async throws {
+        let fileURL = Self.makeTempURL()
+        let store = HistoricalUsageHistoryStore(fileURL: fileURL)
+        let resetsAt = Date(timeIntervalSince1970: 1_770_000_000)
+        let laterResetsAt = resetsAt.addingTimeInterval(21 * 24 * 60 * 60)
+        let normalizedEmail = "person@example.com"
+        let legacyEmailHash = CodexHistoryOwnership.legacyEmailHash(normalizedEmail: normalizedEmail)
+        let canonicalKey = CodexHistoryOwnership.canonicalEmailHashKey(for: normalizedEmail)
+        let otherCanonicalKey = try #require(
+            CodexHistoryOwnership.canonicalKey(for: .providerAccount(id: "acct-other")))
+
+        await Self.recordCompleteWeek(into: store, resetsAt: resetsAt, accountKey: nil)
+        _ = await store.recordCodexWeekly(
+            window: RateWindow(
+                usedPercent: 12,
+                windowMinutes: 10080,
+                resetsAt: resetsAt,
+                resetDescription: nil),
+            sampledAt: resetsAt.addingTimeInterval(-(10080 * 60)),
+            accountKey: legacyEmailHash)
+        _ = await store.recordCodexWeekly(
+            window: RateWindow(
+                usedPercent: 18,
+                windowMinutes: 10080,
+                resetsAt: laterResetsAt,
+                resetDescription: nil),
+            sampledAt: laterResetsAt.addingTimeInterval(-(10080 * 60)),
+            accountKey: otherCanonicalKey)
+
+        let dataset = await store.loadCodexDataset(
+            canonicalAccountKey: canonicalKey,
+            canonicalEmailHashKey: canonicalKey,
+            legacyEmailHash: legacyEmailHash,
+            hasAdjacentMultiAccountVeto: false)
+
+        #expect(dataset?.weeks.count == 1)
+        #expect(dataset?.weeks.first?.resetsAt == resetsAt)
+    }
+
+    @MainActor
+    @Test
+    func `refresh historical dataset keeps nil key history unscoped when managed and live accounts are distinct`()
+        async throws
+    {
+        let historyStore = HistoricalUsageHistoryStore(fileURL: Self.makeTempURL())
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-codex-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let liveAccount = Self.liveAccount(
+            email: "live@example.com",
+            identity: .providerAccount(id: "live-acct"))
+        let resetsAt = Date(timeIntervalSince1970: 1_770_000_000)
+        let managedLegacyEmailHash = CodexHistoryOwnership.legacyEmailHash(normalizedEmail: managedAccount.email)
+        let managedCanonicalKey = CodexHistoryOwnership.canonicalEmailHashKey(for: managedAccount.email)
+
+        await Self.recordCompleteWeek(into: historyStore, resetsAt: resetsAt, accountKey: nil)
+        _ = await historyStore.recordCodexWeekly(
+            window: RateWindow(
+                usedPercent: 12,
+                windowMinutes: 10080,
+                resetsAt: resetsAt,
+                resetDescription: nil),
+            sampledAt: resetsAt.addingTimeInterval(-(10080 * 60)),
+            accountKey: managedLegacyEmailHash)
+
+        let store = try Self.makeUsageStoreForHistoricalTests(
+            suite: "HistoricalUsagePaceTests-adjacent-veto",
+            historicalUsageHistoryStore: historyStore)
+        store.settings._test_activeManagedCodexAccount = managedAccount
+        store.settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+        store.settings._test_liveSystemCodexAccount = liveAccount
+        defer {
+            store.settings._test_activeManagedCodexAccount = nil
+            store.settings._test_liveSystemCodexAccount = nil
+            store.settings.codexActiveSource = .liveSystem
+        }
+
+        await store.refreshHistoricalDatasetIfNeeded()
+
+        #expect(store.codexHistoricalDataset == nil)
+        #expect(store.codexHistoricalDatasetAccountKey == managedCanonicalKey)
+    }
+
+    @MainActor
+    @Test
+    func `refresh historical dataset ignores extra saved managed accounts for adjacent veto`() async throws {
+        let historyStore = HistoricalUsageHistoryStore(fileURL: Self.makeTempURL())
+        let activeManagedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-codex-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let inactiveManagedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "other@example.com",
+            managedHomePath: "/tmp/other-codex-home",
+            createdAt: 2,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let resetsAt = Date(timeIntervalSince1970: 1_770_000_000)
+        let managedLegacyEmailHash = CodexHistoryOwnership.legacyEmailHash(normalizedEmail: activeManagedAccount.email)
+        let managedCanonicalKey = CodexHistoryOwnership.canonicalEmailHashKey(for: activeManagedAccount.email)
+
+        await Self.recordCompleteWeek(into: historyStore, resetsAt: resetsAt, accountKey: nil)
+        _ = await historyStore.recordCodexWeekly(
+            window: RateWindow(
+                usedPercent: 12,
+                windowMinutes: 10080,
+                resetsAt: resetsAt,
+                resetDescription: nil),
+            sampledAt: resetsAt.addingTimeInterval(-(10080 * 60)),
+            accountKey: managedLegacyEmailHash)
+
+        let store = try Self.makeUsageStoreForHistoricalTests(
+            suite: "HistoricalUsagePaceTests-saved-managed-accounts",
+            historicalUsageHistoryStore: historyStore)
+        let managedStoreURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent("HistoricalUsagePaceTests-\(UUID().uuidString)-managed-accounts.json")
+        let managedStore = FileManagedCodexAccountStore(fileURL: managedStoreURL)
+        try managedStore.storeAccounts(ManagedCodexAccountSet(
+            version: FileManagedCodexAccountStore.currentVersion,
+            accounts: [activeManagedAccount, inactiveManagedAccount]))
+        store.settings._test_managedCodexAccountStoreURL = managedStoreURL
+        store.settings._test_activeManagedCodexAccount = activeManagedAccount
+        store.settings.codexActiveSource = .managedAccount(id: activeManagedAccount.id)
+        defer {
+            store.settings._test_managedCodexAccountStoreURL = nil
+            store.settings._test_activeManagedCodexAccount = nil
+            store.settings.codexActiveSource = .liveSystem
+        }
+
+        await store.refreshHistoricalDatasetIfNeeded()
+
+        #expect(store.codexHistoricalDataset?.weeks.count == 1)
+        #expect(store.codexHistoricalDatasetAccountKey == managedCanonicalKey)
+    }
+
+    @Test
+    func `history store ownership aware load merges legacy email hash into provider account continuity`() async throws {
+        let fileURL = Self.makeTempURL()
+        let store = HistoricalUsageHistoryStore(fileURL: fileURL)
+        let resetsAt = Date(timeIntervalSince1970: 1_770_000_000)
+        let normalizedEmail = "person@example.com"
+        let legacyEmailHash = CodexHistoryOwnership.legacyEmailHash(normalizedEmail: normalizedEmail)
+        let canonicalEmailHashKey = CodexHistoryOwnership.canonicalEmailHashKey(for: normalizedEmail)
+        let providerAccountKey = try #require(CodexHistoryOwnership.canonicalKey(for: .providerAccount(id: "acct-1")))
+
+        await Self.recordCompleteWeek(into: store, resetsAt: resetsAt, accountKey: legacyEmailHash)
+
+        let dataset = await store.loadCodexDataset(
+            canonicalAccountKey: providerAccountKey,
+            canonicalEmailHashKey: canonicalEmailHashKey,
+            legacyEmailHash: legacyEmailHash,
+            hasAdjacentMultiAccountVeto: false)
+
+        #expect(dataset?.weeks.count == 1)
+    }
+
+    @Test
+    func `history store real local fixture aliases bare email hash into canonical continuity`() async throws {
+        let fileURL = Self.makeTempURL()
+        try Self.writeHistoricalFixture(named: "codex-historical-usage-real-legacy.jsonl", to: fileURL)
+        let store = HistoricalUsageHistoryStore(fileURL: fileURL)
+        let formatter = ISO8601DateFormatter()
+        let normalizedEmail = "rdsarna@gmail.com"
+        let legacyEmailHash = CodexHistoryOwnership.legacyEmailHash(normalizedEmail: normalizedEmail)
+        let canonicalEmailHashKey = CodexHistoryOwnership.canonicalEmailHashKey(for: normalizedEmail)
+        let providerAccountKey = try #require(CodexHistoryOwnership.canonicalKey(for: .providerAccount(id: "acct-123")))
+        let fixtureResetAt = try #require(formatter.date(from: "2026-02-17T05:37:00Z"))
+        let weekSeconds = TimeInterval(7 * 24 * 60 * 60)
+        let weeksToShift = max(0, Int(ceil(Date().timeIntervalSince(fixtureResetAt) / weekSeconds)))
+        let dateShift = TimeInterval(weeksToShift) * weekSeconds
+        let records = try Self.readHistoricalRecords(from: fileURL)
+        try Self.writeHistoricalRecords(
+            records.map { record in
+                HistoricalUsageRecord(
+                    v: record.v,
+                    provider: record.provider,
+                    windowKind: record.windowKind,
+                    source: record.source,
+                    accountKey: record.accountKey,
+                    sampledAt: record.sampledAt.addingTimeInterval(dateShift),
+                    usedPercent: record.usedPercent,
+                    resetsAt: record.resetsAt.addingTimeInterval(dateShift),
+                    windowMinutes: record.windowMinutes)
+            },
+            to: fileURL)
+        let expectedResetAt = Self.normalizeReset(fixtureResetAt.addingTimeInterval(dateShift))
+
+        let dataset = await store.loadCodexDataset(
+            canonicalAccountKey: providerAccountKey,
+            canonicalEmailHashKey: canonicalEmailHashKey,
+            legacyEmailHash: legacyEmailHash,
+            hasAdjacentMultiAccountVeto: false)
+
+        #expect(dataset?.weeks.count == 1)
+        #expect(dataset?.weeks.first?.resetsAt == expectedResetAt)
+    }
+
+    @MainActor
+    @Test
+    func `usage store records historical pace with canonical provider account key`() async throws {
+        let historyFileURL = Self.makeTempURL()
+        let store = try Self.makeUsageStoreForBackfillTests(
+            suite: "HistoricalUsagePaceTests-provider-account-write",
+            historyFileURL: historyFileURL)
+        store.settings._test_liveSystemCodexAccount = Self.liveAccount(
+            email: "person@example.com",
+            identity: .providerAccount(id: "acct-123"))
+        defer { store.settings._test_liveSystemCodexAccount = nil }
+
+        let updatedAt = Date(timeIntervalSince1970: 1_770_000_000)
+        let snapshot = Self.weeklySnapshot(
+            email: "person@example.com",
+            usedPercent: 42,
+            resetsAt: updatedAt.addingTimeInterval(2 * 24 * 60 * 60),
+            updatedAt: updatedAt)
+
+        store.recordCodexHistoricalSampleIfNeeded(snapshot: snapshot)
+        let expectedKey = try #require(CodexHistoryOwnership.canonicalKey(for: .providerAccount(id: "acct-123")))
+        let records = try await Self.waitForHistoricalWrite(
+            store: store,
+            at: historyFileURL,
+            minimumCount: 1,
+            expectedAccountKey: expectedKey)
+
+        #expect(records.last?.accountKey == expectedKey)
+        #expect(store.codexHistoricalDatasetAccountKey == expectedKey)
+    }
+
+    @MainActor
+    @Test
+    func `usage store records historical pace with canonical email hash key`() async throws {
+        let historyFileURL = Self.makeTempURL()
+        let store = try Self.makeUsageStoreForBackfillTests(
+            suite: "HistoricalUsagePaceTests-email-hash-write",
+            historyFileURL: historyFileURL)
+        store.settings._test_liveSystemCodexAccount = Self.liveAccount(email: "person@example.com")
+        defer { store.settings._test_liveSystemCodexAccount = nil }
+
+        let updatedAt = Date(timeIntervalSince1970: 1_770_000_000)
+        let snapshot = Self.weeklySnapshot(
+            email: "Person@example.com",
+            usedPercent: 42,
+            resetsAt: updatedAt.addingTimeInterval(2 * 24 * 60 * 60),
+            updatedAt: updatedAt)
+
+        store.recordCodexHistoricalSampleIfNeeded(snapshot: snapshot)
+        let expectedKey = CodexHistoryOwnership.canonicalEmailHashKey(for: "person@example.com")
+        let records = try await Self.waitForHistoricalWrite(
+            store: store,
+            at: historyFileURL,
+            minimumCount: 1,
+            expectedAccountKey: expectedKey)
+
+        #expect(records.last?.accountKey == expectedKey)
+        #expect(store.codexHistoricalDatasetAccountKey == expectedKey)
+    }
+
+    @MainActor
+    @Test
+    func `refresh historical dataset aliases legacy email hash into canonical email hash`() async throws {
+        let historyFileURL = Self.makeTempURL()
+        let historyStore = HistoricalUsageHistoryStore(fileURL: historyFileURL)
+        let normalizedEmail = "person@example.com"
+        let legacyEmailHash = CodexHistoryOwnership.legacyEmailHash(normalizedEmail: normalizedEmail)
+        let canonicalKey = CodexHistoryOwnership.canonicalEmailHashKey(for: normalizedEmail)
+        let resetsAt = Date(timeIntervalSince1970: 1_770_000_000)
+        await Self.recordCompleteWeek(into: historyStore, resetsAt: resetsAt, accountKey: legacyEmailHash)
+
+        let store = try Self.makeUsageStoreForHistoricalTests(
+            suite: "HistoricalUsagePaceTests-refresh-legacy-alias",
+            historicalUsageHistoryStore: historyStore)
+        store.settings._test_liveSystemCodexAccount = Self.liveAccount(email: normalizedEmail)
+        defer { store.settings._test_liveSystemCodexAccount = nil }
+
+        await store.refreshHistoricalDatasetIfNeeded()
+
+        #expect(store.codexHistoricalDatasetAccountKey == canonicalKey)
+        #expect(store.codexHistoricalDataset?.weeks.count == 1)
+    }
+
+    @MainActor
+    @Test
+    func `refresh historical dataset carries matching email continuity into provider account`() async throws {
+        let historyFileURL = Self.makeTempURL()
+        let historyStore = HistoricalUsageHistoryStore(fileURL: historyFileURL)
+        let normalizedEmail = "person@example.com"
+        let legacyEmailHash = CodexHistoryOwnership.legacyEmailHash(normalizedEmail: normalizedEmail)
+        let providerAccountKey = try #require(CodexHistoryOwnership.canonicalKey(for: .providerAccount(id: "acct-123")))
+        let resetsAt = Date(timeIntervalSince1970: 1_770_000_000)
+        await Self.recordCompleteWeek(into: historyStore, resetsAt: resetsAt, accountKey: legacyEmailHash)
+
+        let store = try Self.makeUsageStoreForHistoricalTests(
+            suite: "HistoricalUsagePaceTests-refresh-provider-account-continuity",
+            historicalUsageHistoryStore: historyStore)
+        store.settings._test_liveSystemCodexAccount = Self.liveAccount(
+            email: normalizedEmail,
+            identity: .providerAccount(id: "acct-123"))
+        defer { store.settings._test_liveSystemCodexAccount = nil }
+
+        await store.refreshHistoricalDatasetIfNeeded()
+
+        #expect(store.codexHistoricalDatasetAccountKey == providerAccountKey)
+        #expect(store.codexHistoricalDataset?.weeks.count == 1)
+    }
+
+    @MainActor
+    @Test
+    func `refresh historical dataset ignores stale dashboard signals and uses active account ownership`() async throws {
+        let historyFileURL = Self.makeTempURL()
+        let historyStore = HistoricalUsageHistoryStore(fileURL: historyFileURL)
+        let staleEmail = "old@example.com"
+        let staleLegacyEmailHash = CodexHistoryOwnership.legacyEmailHash(normalizedEmail: staleEmail)
+        let staleResetsAt = Date(timeIntervalSince1970: 1_770_000_000)
+        await Self.recordCompleteWeek(into: historyStore, resetsAt: staleResetsAt, accountKey: staleLegacyEmailHash)
+
+        let store = try Self.makeUsageStoreForHistoricalTests(
+            suite: "HistoricalUsagePaceTests-refresh-prefers-active-email",
+            historicalUsageHistoryStore: historyStore)
+        let activeProviderAccountKey = try #require(
+            CodexHistoryOwnership.canonicalKey(for: .providerAccount(id: "acct-new")))
+        store.settings._test_liveSystemCodexAccount = Self.liveAccount(
+            email: "new@example.com",
+            identity: .providerAccount(id: "acct-new"))
+        store.openAIDashboard = OpenAIDashboardSnapshot(
+            signedInEmail: staleEmail,
+            codeReviewRemainingPercent: nil,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            primaryLimit: nil,
+            secondaryLimit: nil,
+            creditsRemaining: nil,
+            accountPlan: nil,
+            updatedAt: staleResetsAt)
+        store.lastOpenAIDashboardTargetEmail = staleEmail
+        defer { store.settings._test_liveSystemCodexAccount = nil }
+
+        await store.refreshHistoricalDatasetIfNeeded()
+
+        #expect(store.codexHistoricalDatasetAccountKey == activeProviderAccountKey)
+        #expect(store.codexHistoricalDataset == nil)
+    }
+}
diff --git a/Tests/CodexBarTests/HistoricalUsagePaceTestSupport.swift b/Tests/CodexBarTests/HistoricalUsagePaceTestSupport.swift
index 9a04cb2736..bb6102c7d2 100644
--- a/Tests/CodexBarTests/HistoricalUsagePaceTestSupport.swift
+++ b/Tests/CodexBarTests/HistoricalUsagePaceTestSupport.swift
@@ -4,15 +4,7 @@ import Testing
 @testable import CodexBar
 
 extension HistoricalUsagePaceTests {
-    private static let utcTimeZone: TimeZone = {
-        if let zone = TimeZone(identifier: "UTC") {
-            return zone
-        }
-        if let zone = TimeZone(secondsFromGMT: 0) {
-            return zone
-        }
-        return TimeZone.current
-    }()
+    private static let dashboardTimeZone: TimeZone = .current
 
     static func linearCurve(end: Double) -> [Double] {
         let clampedEnd = max(0, min(100, end))
@@ -45,10 +37,10 @@ extension HistoricalUsagePaceTests {
         overridesByDayOffset: [Int: Double] = [:]) -> [OpenAIDashboardDailyBreakdown]
     {
         var calendar = Calendar(identifier: .gregorian)
-        calendar.timeZone = Self.utcTimeZone
+        calendar.timeZone = Self.dashboardTimeZone
         let formatter = DateFormatter()
         formatter.locale = Locale(identifier: "en_US_POSIX")
-        formatter.timeZone = Self.utcTimeZone
+        formatter.timeZone = Self.dashboardTimeZone
         formatter.dateFormat = "yyyy-MM-dd"
 
         let endDay = calendar.startOfDay(for: endDate)
@@ -65,10 +57,10 @@ extension HistoricalUsagePaceTests {
 
     static func gregorianDate(year: Int, month: Int, day: Int, hour: Int) -> Date {
         var calendar = Calendar(identifier: .gregorian)
-        calendar.timeZone = Self.utcTimeZone
+        calendar.timeZone = Self.dashboardTimeZone
         var components = DateComponents()
         components.calendar = calendar
-        components.timeZone = Self.utcTimeZone
+        components.timeZone = Self.dashboardTimeZone
         components.year = year
         components.month = month
         components.day = day
@@ -91,10 +83,10 @@ extension HistoricalUsagePaceTests {
             return nil
         }
         var calendar = Calendar(identifier: .gregorian)
-        calendar.timeZone = Self.utcTimeZone
+        calendar.timeZone = Self.dashboardTimeZone
         var dateComponents = DateComponents()
         dateComponents.calendar = calendar
-        dateComponents.timeZone = Self.utcTimeZone
+        dateComponents.timeZone = Self.dashboardTimeZone
         dateComponents.year = year
         dateComponents.month = month
         dateComponents.day = day
@@ -102,7 +94,7 @@ extension HistoricalUsagePaceTests {
     }
 
     static func normalizeReset(_ value: Date) -> Date {
-        let bucket = 60.0
+        let bucket = 5 * 60.0
         let rounded = (value.timeIntervalSinceReferenceDate / bucket).rounded() * bucket
         return Date(timeIntervalSinceReferenceDate: rounded)
     }
@@ -119,6 +111,35 @@ extension HistoricalUsagePaceTests {
             }
     }
 
+    static func writeHistoricalFixture(named name: String, to fileURL: URL) throws {
+        let fixtureURL = URL(fileURLWithPath: #filePath)
+            .deletingLastPathComponent()
+            .appendingPathComponent("Fixtures", isDirectory: true)
+            .appendingPathComponent(name, isDirectory: false)
+        try FileManager.default.createDirectory(
+            at: fileURL.deletingLastPathComponent(),
+            withIntermediateDirectories: true)
+        let data = try Data(contentsOf: fixtureURL)
+        try data.write(to: fileURL, options: .atomic)
+    }
+
+    static func writeHistoricalRecords(_ records: [HistoricalUsageRecord], to fileURL: URL) throws {
+        let encoder = JSONEncoder()
+        encoder.dateEncodingStrategy = .iso8601
+        encoder.outputFormatting = [.sortedKeys]
+        let lines = try records.map { record -> String in
+            let data = try encoder.encode(record)
+            guard let line = String(bytes: data, encoding: .utf8) else {
+                throw CocoaError(.fileWriteUnknown)
+            }
+            return line
+        }
+        try FileManager.default.createDirectory(
+            at: fileURL.deletingLastPathComponent(),
+            withIntermediateDirectories: true)
+        try (lines.joined(separator: "\n") + "\n").write(to: fileURL, atomically: true, encoding: .utf8)
+    }
+
     static func recordDedupKeyCount(_ records: [HistoricalUsageRecord]) -> Int {
         struct Key: Hashable {
             let resetsAt: Date
@@ -147,8 +168,114 @@ extension HistoricalUsagePaceTests {
             .joined(separator: "||")
     }
 
+    static func liveAccount(
+        email: String,
+        identity: CodexIdentity = .unresolved) -> ObservedSystemCodexAccount
+    {
+        ObservedSystemCodexAccount(
+            email: email,
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: identity)
+    }
+
+    static func weeklySnapshot(
+        email: String? = nil,
+        usedPercent: Double,
+        resetsAt: Date,
+        updatedAt: Date) -> UsageSnapshot
+    {
+        UsageSnapshot(
+            primary: nil,
+            secondary: RateWindow(
+                usedPercent: usedPercent,
+                windowMinutes: 10080,
+                resetsAt: resetsAt,
+                resetDescription: nil),
+            tertiary: nil,
+            providerCost: nil,
+            updatedAt: updatedAt,
+            identity: email.map {
+                ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: $0,
+                    accountOrganization: nil,
+                    loginMethod: "Pro")
+            })
+    }
+
+    static func recordCompleteWeek(
+        into store: HistoricalUsageHistoryStore,
+        resetsAt: Date,
+        accountKey: String?) async
+    {
+        let windowMinutes = 10080
+        let duration = TimeInterval(windowMinutes) * 60
+        let windowStart = resetsAt.addingTimeInterval(-duration)
+        let samples: [(u: Double, used: Double)] = [
+            (0.02, 3),
+            (0.10, 10),
+            (0.40, 40),
+            (0.60, 60),
+            (0.80, 80),
+            (0.98, 95),
+        ]
+
+        for sample in samples {
+            _ = await store.recordCodexWeekly(
+                window: RateWindow(
+                    usedPercent: sample.used,
+                    windowMinutes: windowMinutes,
+                    resetsAt: resetsAt,
+                    resetDescription: nil),
+                sampledAt: windowStart.addingTimeInterval(sample.u * duration),
+                accountKey: accountKey)
+        }
+    }
+
+    static func waitForHistoricalRecords(
+        at fileURL: URL,
+        minimumCount: Int,
+        timeoutMilliseconds: UInt64 = 10000) async throws -> [HistoricalUsageRecord]
+    {
+        let deadline = ContinuousClock.now + .milliseconds(timeoutMilliseconds)
+        while ContinuousClock.now < deadline {
+            if let records = try? Self.readHistoricalRecords(from: fileURL), records.count >= minimumCount {
+                return records
+            }
+            try await Task.sleep(for: .milliseconds(25))
+        }
+
+        return try Self.readHistoricalRecords(from: fileURL)
+    }
+
     @MainActor
-    static func makeUsageStoreForBackfillTests(suite: String, historyFileURL: URL) throws -> UsageStore {
+    static func waitForHistoricalWrite(
+        store: UsageStore,
+        at fileURL: URL,
+        minimumCount: Int,
+        expectedAccountKey: String?,
+        timeoutMilliseconds: UInt64 = 10000) async throws -> [HistoricalUsageRecord]
+    {
+        let deadline = ContinuousClock.now + .milliseconds(timeoutMilliseconds)
+        while ContinuousClock.now < deadline {
+            let records = (try? Self.readHistoricalRecords(from: fileURL)) ?? []
+            if records.count >= minimumCount,
+               store.codexHistoricalDatasetAccountKey == expectedAccountKey
+            {
+                return records
+            }
+            try await Task.sleep(for: .milliseconds(25))
+        }
+
+        return try Self.readHistoricalRecords(from: fileURL)
+    }
+
+    @MainActor
+    static func makeUsageStoreForHistoricalTests(
+        suite: String,
+        historicalUsageHistoryStore: HistoricalUsageHistoryStore) throws -> UsageStore
+    {
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
         let settings = SettingsStore(
@@ -170,10 +297,20 @@ extension HistoricalUsagePaceTests {
             copilotTokenStore: InMemoryCopilotTokenStore(),
             tokenAccountStore: InMemoryTokenAccountStore())
         settings.historicalTrackingEnabled = true
+        let planHistoryStore = testPlanUtilizationHistoryStore(
+            suiteName: "HistoricalUsagePaceTests-\(UUID().uuidString)")
         return UsageStore(
             fetcher: UsageFetcher(environment: [:]),
             browserDetection: BrowserDetection(cacheTTL: 0),
             settings: settings,
+            historicalUsageHistoryStore: historicalUsageHistoryStore,
+            planUtilizationHistoryStore: planHistoryStore)
+    }
+
+    @MainActor
+    static func makeUsageStoreForBackfillTests(suite: String, historyFileURL: URL) throws -> UsageStore {
+        try self.makeUsageStoreForHistoricalTests(
+            suite: suite,
             historicalUsageHistoryStore: HistoricalUsageHistoryStore(fileURL: historyFileURL))
     }
 }
diff --git a/Tests/CodexBarTests/HistoricalUsagePaceTests.swift b/Tests/CodexBarTests/HistoricalUsagePaceTests.swift
index 642add9aa7..103a6cd83b 100644
--- a/Tests/CodexBarTests/HistoricalUsagePaceTests.swift
+++ b/Tests/CodexBarTests/HistoricalUsagePaceTests.swift
@@ -3,10 +3,10 @@ import Foundation
 import Testing
 @testable import CodexBar
 
-@Suite
+@Suite(.serialized)
 struct HistoricalUsagePaceTests {
     @Test
-    func historyStore_reconstructsDeterministicMonotoneCurve() async throws {
+    func `history store reconstructs deterministic monotone curve`() async throws {
         let fileURL = Self.makeTempURL()
         let store = HistoricalUsageHistoryStore(fileURL: fileURL)
         let windowMinutes = 10080
@@ -47,7 +47,7 @@ struct HistoricalUsagePaceTests {
     }
 
     @Test
-    func reconstructWeekCurve_anchorsAtZeroAtWindowStart() async throws {
+    func `reconstruct week curve anchors at zero at window start`() async throws {
         let fileURL = Self.makeTempURL()
         let store = HistoricalUsageHistoryStore(fileURL: fileURL)
         let windowMinutes = 10080
@@ -80,7 +80,7 @@ struct HistoricalUsagePaceTests {
     }
 
     @Test
-    func reconstructWeekCurve_addsEndAnchorWithoutBreakingMonotonicity() async throws {
+    func `reconstruct week curve adds end anchor without breaking monotonicity`() async throws {
         let fileURL = Self.makeTempURL()
         let store = HistoricalUsageHistoryStore(fileURL: fileURL)
         let windowMinutes = 10080
@@ -116,7 +116,7 @@ struct HistoricalUsagePaceTests {
     }
 
     @Test
-    func historyStore_requiresStartAndEndCoverageForCompleteWeek() async {
+    func `history store requires start and end coverage for complete week`() async {
         let fileURL = Self.makeTempURL()
         let store = HistoricalUsageHistoryStore(fileURL: fileURL)
         let windowMinutes = 10080
@@ -149,7 +149,7 @@ struct HistoricalUsagePaceTests {
     }
 
     @Test
-    func evaluator_appliesSmoothedProbabilityAndHidesRiskBelowThreshold() throws {
+    func `evaluator applies smoothed probability and hides risk below threshold`() throws {
         let now = Date(timeIntervalSince1970: 0)
         let windowMinutes = 10080
         let duration = TimeInterval(windowMinutes) * 60
@@ -197,7 +197,7 @@ struct HistoricalUsagePaceTests {
     }
 
     @Test
-    func evaluator_neverReturnsNegativeEtaWithOutlierWeek() {
+    func `evaluator never returns negative eta with outlier week`() {
         let now = Date(timeIntervalSince1970: 0)
         let windowMinutes = 10080
         let duration = TimeInterval(windowMinutes) * 60
@@ -229,7 +229,7 @@ struct HistoricalUsagePaceTests {
     }
 
     @Test
-    func historyStore_backfillsFromUsageBreakdownWhenHistoryIsEmpty() async {
+    func `history store backfills from usage breakdown when history is empty`() async {
         let fileURL = Self.makeTempURL()
         let store = HistoricalUsageHistoryStore(fileURL: fileURL)
         let now = Date(timeIntervalSince1970: 1_770_000_000)
@@ -252,7 +252,7 @@ struct HistoricalUsagePaceTests {
     }
 
     @Test
-    func historyStore_backfillIsIdempotentForExistingWeeks() async {
+    func `history store backfill is idempotent for existing weeks`() async {
         let fileURL = Self.makeTempURL()
         let store = HistoricalUsageHistoryStore(fileURL: fileURL)
         let now = Date(timeIntervalSince1970: 1_770_000_000)
@@ -286,7 +286,45 @@ struct HistoricalUsagePaceTests {
     }
 
     @Test
-    func historyStore_backfillFillsIncompleteExistingWeek() async {
+    func `history store backfill is idempotent across minute scale reset jitter`() async {
+        let fileURL = Self.makeTempURL()
+        let store = HistoricalUsageHistoryStore(fileURL: fileURL)
+        let now = Date(timeIntervalSince1970: 1_770_000_000)
+        let windowMinutes = 10080
+        let canonicalReset = Self.normalizeReset(now.addingTimeInterval(2 * 24 * 60 * 60))
+        let firstWindow = RateWindow(
+            usedPercent: 50,
+            windowMinutes: windowMinutes,
+            resetsAt: canonicalReset.addingTimeInterval(-90),
+            resetDescription: nil)
+        let secondWindow = RateWindow(
+            usedPercent: 50,
+            windowMinutes: windowMinutes,
+            resetsAt: canonicalReset.addingTimeInterval(90),
+            resetDescription: nil)
+
+        let breakdown = Self.syntheticBreakdown(endingAt: now, days: 35, dailyCredits: 10)
+        let first = await store.backfillCodexWeeklyFromUsageBreakdown(
+            breakdown,
+            referenceWindow: firstWindow,
+            now: now,
+            accountKey: nil)
+        let recordsAfterFirst = (try? Self.readHistoricalRecords(from: fileURL)) ?? []
+        let second = await store.backfillCodexWeeklyFromUsageBreakdown(
+            breakdown,
+            referenceWindow: secondWindow,
+            now: now,
+            accountKey: nil)
+        let recordsAfterSecond = (try? Self.readHistoricalRecords(from: fileURL)) ?? []
+
+        #expect((first?.weeks.count ?? 0) >= 3)
+        #expect(first?.weeks.count == second?.weeks.count)
+        #expect(recordsAfterSecond.count == recordsAfterFirst.count)
+        #expect(Self.datasetCurveSignature(first) == Self.datasetCurveSignature(second))
+    }
+
+    @Test
+    func `history store backfill fills incomplete existing week`() async {
         let fileURL = Self.makeTempURL()
         let store = HistoricalUsageHistoryStore(fileURL: fileURL)
         let now = Date(timeIntervalSince1970: 1_770_000_000)
@@ -321,7 +359,7 @@ struct HistoricalUsagePaceTests {
     }
 
     @Test
-    func historyStore_shouldAcceptDoesNotCrossWindowMinutesRegimes() async throws {
+    func `history store should accept does not cross window minutes regimes`() async throws {
         let fileURL = Self.makeTempURL()
         let store = HistoricalUsageHistoryStore(fileURL: fileURL)
         let sampledAt = Date(timeIntervalSince1970: 1_770_000_000)
@@ -353,12 +391,12 @@ struct HistoricalUsagePaceTests {
     }
 
     @Test
-    func weeksWithResetJitter_areGroupedTogether() async {
+    func `weeks with reset jitter are grouped together`() async {
         let fileURL = Self.makeTempURL()
         let store = HistoricalUsageHistoryStore(fileURL: fileURL)
         let windowMinutes = 10080
         let duration = TimeInterval(windowMinutes) * 60
-        let canonicalReset = Date(timeIntervalSince1970: 1_770_000_000)
+        let canonicalReset = Self.normalizeReset(Date(timeIntervalSince1970: 1_770_000_000))
         let windowStart = canonicalReset.addingTimeInterval(-duration)
 
         let samples: [(u: Double, used: Double)] = [
@@ -370,7 +408,7 @@ struct HistoricalUsagePaceTests {
             (0.98, 95),
         ]
         for (index, sample) in samples.enumerated() {
-            let jitteredReset = canonicalReset.addingTimeInterval(index.isMultiple(of: 2) ? -20 : 20)
+            let jitteredReset = canonicalReset.addingTimeInterval(index.isMultiple(of: 2) ? -100 : 100)
             _ = await store.recordCodexWeekly(
                 window: RateWindow(
                     usedPercent: sample.used,
@@ -386,7 +424,7 @@ struct HistoricalUsagePaceTests {
     }
 
     @Test
-    func backfill_matchesIncompleteWeek_whenResetJitterExists() async throws {
+    func `backfill matches incomplete week when reset jitter exists`() async throws {
         let fileURL = Self.makeTempURL()
         let store = HistoricalUsageHistoryStore(fileURL: fileURL)
         let now = Date(timeIntervalSince1970: 1_770_000_000)
@@ -400,7 +438,7 @@ struct HistoricalUsagePaceTests {
             window: RateWindow(
                 usedPercent: 35,
                 windowMinutes: windowMinutes,
-                resetsAt: targetReset.addingTimeInterval(30),
+                resetsAt: targetReset.addingTimeInterval(120),
                 resetDescription: nil),
             sampledAt: targetStart.addingTimeInterval(duration * 0.5),
             accountKey: nil)
@@ -428,7 +466,7 @@ struct HistoricalUsagePaceTests {
     }
 
     @Test
-    func backfill_doesNotStopAtThreeWeeks_whenMoreBackfillableWeeksExist() async throws {
+    func `backfill does not stop at three weeks when more backfillable weeks exist`() async throws {
         let fileURL = Self.makeTempURL()
         let store = HistoricalUsageHistoryStore(fileURL: fileURL)
         let now = Date(timeIntervalSince1970: 1_770_000_000)
@@ -474,7 +512,7 @@ struct HistoricalUsagePaceTests {
     }
 
     @Test
-    func loadDataset_usesOnlyCurrentAccountKey() async throws {
+    func `load dataset uses only current account key`() async throws {
         let fileURL = Self.makeTempURL()
         let store = HistoricalUsageHistoryStore(fileURL: fileURL)
         let windowMinutes = 10080
@@ -514,7 +552,7 @@ struct HistoricalUsagePaceTests {
     }
 
     @Test
-    func backfill_filtersByAccountKey() async throws {
+    func `backfill filters by account key`() async throws {
         let fileURL = Self.makeTempURL()
         let store = HistoricalUsageHistoryStore(fileURL: fileURL)
         let now = Date(timeIntervalSince1970: 1_770_000_000)
@@ -548,7 +586,7 @@ struct HistoricalUsagePaceTests {
     }
 
     @Test
-    func coverageTolerance_allowsDayBoundaryShiftWithoutNoOp() async {
+    func `coverage tolerance allows day boundary shift without no op`() async {
         let fileURL = Self.makeTempURL()
         let store = HistoricalUsageHistoryStore(fileURL: fileURL)
         let now = Date(timeIntervalSince1970: 1_770_000_000)
@@ -573,7 +611,7 @@ struct HistoricalUsagePaceTests {
     }
 
     @Test
-    func backfill_treatsOmittedRecentZeroUsageDaysAsCoverage() async {
+    func `backfill treats omitted recent zero usage days as coverage`() async {
         let fileURL = Self.makeTempURL()
         let store = HistoricalUsageHistoryStore(fileURL: fileURL)
         let now = Self.gregorianDate(year: 2026, month: 2, day: 26, hour: 20)
@@ -604,7 +642,39 @@ struct HistoricalUsagePaceTests {
     }
 
     @Test
-    func partialDayCredits_areNotUndercountedAtAsOfTime() {
+    func `backfill treats omitted leading zero usage days as coverage`() async {
+        let fileURL = Self.makeTempURL()
+        let store = HistoricalUsageHistoryStore(fileURL: fileURL)
+        let now = Self.gregorianDate(year: 2026, month: 2, day: 26, hour: 20)
+        let resetsAt = now.addingTimeInterval(2 * 24 * 60 * 60)
+        let referenceWindow = RateWindow(
+            usedPercent: 50,
+            windowMinutes: 10080,
+            resetsAt: resetsAt,
+            resetDescription: nil)
+
+        let breakdown = Self.syntheticBreakdown(
+            endingAt: now,
+            days: 35,
+            dailyCredits: 10,
+            overridesByDayOffset: [
+                3: 0,
+                4: 0,
+                5: 0,
+            ])
+            .filter { $0.totalCreditsUsed > 0 }
+
+        let dataset = await store.backfillCodexWeeklyFromUsageBreakdown(
+            breakdown,
+            referenceWindow: referenceWindow,
+            now: now,
+            accountKey: nil)
+
+        #expect((dataset?.weeks.count ?? 0) >= 3)
+    }
+
+    @Test
+    func `partial day credits are not undercounted at as of time`() {
         let asOf = Self.gregorianDate(year: 2026, month: 2, day: 26, hour: 12)
         let start = Self.gregorianDate(year: 2026, month: 2, day: 20, hour: 0)
         let breakdown = Self.syntheticBreakdown(
@@ -626,7 +696,7 @@ struct HistoricalUsagePaceTests {
     }
 
     @Test
-    func gregorianDayParsing_isStableForYYYYMMDD() {
+    func `gregorian day parsing is stable for YYYYMMDD`() {
         let parsed = HistoricalUsageHistoryStore._dayStartForTesting("2026-02-26")
         let expected = Self.gregorianDate(year: 2026, month: 2, day: 26, hour: 0)
         #expect(parsed == expected)
@@ -634,7 +704,7 @@ struct HistoricalUsagePaceTests {
 
     @MainActor
     @Test
-    func backfill_skipsWhenTimestampMismatchExceeds5Minutes() async throws {
+    func `backfill skips when timestamp mismatch exceeds5 minutes`() async throws {
         let store = try Self.makeUsageStoreForBackfillTests(
             suite: "HistoricalUsagePaceTests-backfill-mismatch",
             historyFileURL: Self.makeTempURL())
@@ -667,147 +737,87 @@ struct HistoricalUsagePaceTests {
             creditsRemaining: nil,
             accountPlan: nil,
             updatedAt: snapshotNow.addingTimeInterval(-10 * 60))
-        store.backfillCodexHistoricalFromDashboardIfNeeded(dashboard)
+        store.backfillCodexHistoricalFromDashboardIfNeeded(
+            dashboard,
+            authorityDecision: CodexDashboardAuthorityDecision(
+                disposition: .attach,
+                reason: .trustedEmailMatchNoCompetingOwner,
+                allowedEffects: [.historicalBackfill],
+                cleanup: []),
+            attachedAccountEmail: "attached@example.com")
 
         try await Task.sleep(for: .milliseconds(250))
         #expect(store.codexHistoricalDataset == nil)
     }
 
-    @MainActor
     @Test
-    func backfill_usesDashboardSecondaryWhenAvailable() async throws {
-        let store = try Self.makeUsageStoreForBackfillTests(
-            suite: "HistoricalUsagePaceTests-backfill-dashboard-secondary",
-            historyFileURL: Self.makeTempURL())
-        store._setCodexHistoricalDatasetForTesting(nil)
-
-        let snapshotNow = Date(timeIntervalSince1970: 1_770_000_000)
-        let staleSnapshot = UsageSnapshot(
-            primary: nil,
-            secondary: RateWindow(
-                usedPercent: 5,
-                windowMinutes: 10080,
-                resetsAt: snapshotNow.addingTimeInterval(2 * 24 * 60 * 60),
-                resetDescription: nil),
-            tertiary: nil,
-            providerCost: nil,
-            updatedAt: snapshotNow.addingTimeInterval(-30 * 60),
-            identity: nil)
-        store._setSnapshotForTesting(staleSnapshot, provider: .codex)
-
-        let dashboard = OpenAIDashboardSnapshot(
-            signedInEmail: nil,
-            codeReviewRemainingPercent: nil,
-            creditEvents: [],
-            dailyBreakdown: [],
-            usageBreakdown: Self.syntheticBreakdown(endingAt: snapshotNow, days: 35, dailyCredits: 10),
-            creditsPurchaseURL: nil,
-            primaryLimit: nil,
-            secondaryLimit: RateWindow(
-                usedPercent: 50,
-                windowMinutes: 10080,
-                resetsAt: snapshotNow.addingTimeInterval(2 * 24 * 60 * 60),
-                resetDescription: nil),
-            creditsRemaining: nil,
-            accountPlan: nil,
-            updatedAt: snapshotNow)
-        store.backfillCodexHistoricalFromDashboardIfNeeded(dashboard)
-
-        for _ in 0..<40 {
-            if (store.codexHistoricalDataset?.weeks.count ?? 0) >= 3 {
-                break
+    func `exhausted historical weeks extend linearly and don't flatline at 100`() throws {
+        // Build a historical dataset where a week reaches 100% at u = 0.5
+        var earlyExhaustedCurve = [Double]()
+        for i in 0..<CodexHistoricalDataset.gridPointCount {
+            let u = Double(i) / Double(CodexHistoricalDataset.gridPointCount - 1)
+            if u <= 0.5 {
+                earlyExhaustedCurve.append((u / 0.5) * 100)
+            } else {
+                earlyExhaustedCurve.append(100)
             }
-            try await Task.sleep(for: .milliseconds(50))
         }
-        #expect((store.codexHistoricalDataset?.weeks.count ?? 0) >= 3)
-    }
+        let now = Date()
+        let week = HistoricalWeekProfile(
+            resetsAt: now.addingTimeInterval(-10080 * 60),
+            windowMinutes: 10080,
+            curve: earlyExhaustedCurve)
+        let dataset = CodexHistoricalDataset(weeks: [week, week, week, week, week])
 
-    @Test
-    func willLastDecision_usesSmoothedProbabilityWhenRiskHidden() throws {
-        let now = Date(timeIntervalSince1970: 0)
-        let windowMinutes = 10080
-        let duration = TimeInterval(windowMinutes) * 60
-        let currentResetsAt = now.addingTimeInterval(duration / 2)
         let window = RateWindow(
-            usedPercent: 50,
-            windowMinutes: windowMinutes,
-            resetsAt: currentResetsAt,
+            usedPercent: 80,
+            windowMinutes: 10080,
+            resetsAt: now.addingTimeInterval(0.25 * 10080 * 60),
             resetDescription: nil)
 
-        let weeks = (0..<4).map { index in
-            HistoricalWeekProfile(
-                resetsAt: currentResetsAt.addingTimeInterval(-duration * Double(index + 1)),
-                windowMinutes: windowMinutes,
-                curve: Self.linearCurve(end: 100))
-        }
         let pace = try #require(CodexHistoricalPaceEvaluator.evaluate(
             window: window,
             now: now,
-            dataset: CodexHistoricalDataset(weeks: weeks)))
-        #expect(pace.runOutProbability == nil)
+            dataset: dataset))
 
-        let totalWeight = weeks.enumerated().reduce(0.0) { partial, element in
-            let ageWeeks = currentResetsAt.timeIntervalSince(element.element.resetsAt) / duration
-            return partial + exp(-ageWeeks / 3.0)
-        }
-        let smoothedProbability = (totalWeight + 0.5) / (totalWeight + 1.0)
-        #expect(pace.willLastToReset == (smoothedProbability < 0.5))
+        #expect(pace.willLastToReset == false)
+        #expect(pace.runOutProbability != nil)
+        #expect(try #require(pace.runOutProbability) > 0)
+        #expect(pace.deltaPercent > 0)
+
+        let detail = UsagePaceText.weeklyDetail(pace: pace, now: now)
+        #expect(detail.leftLabel == "5% in deficit")
+        #expect(detail.rightLabel?.contains("Lasts until reset") == false)
     }
 
-    @MainActor
     @Test
-    func usageStore_fallsBackToLinearWhenHistoryDisabledOrInsufficient() throws {
-        let suite = "HistoricalUsagePaceTests-usage-store"
-        let defaults = try #require(UserDefaults(suiteName: suite))
-        defaults.removePersistentDomain(forName: suite)
-        let settings = SettingsStore(
-            userDefaults: defaults,
-            configStore: testConfigStore(suiteName: suite),
-            zaiTokenStore: NoopZaiTokenStore(),
-            syntheticTokenStore: NoopSyntheticTokenStore(),
-            codexCookieStore: InMemoryCookieHeaderStore(),
-            claudeCookieStore: InMemoryCookieHeaderStore(),
-            cursorCookieStore: InMemoryCookieHeaderStore(),
-            opencodeCookieStore: InMemoryCookieHeaderStore(),
-            factoryCookieStore: InMemoryCookieHeaderStore(),
-            minimaxCookieStore: InMemoryMiniMaxCookieStore(),
-            minimaxAPITokenStore: InMemoryMiniMaxAPITokenStore(),
-            kimiTokenStore: InMemoryKimiTokenStore(),
-            kimiK2TokenStore: InMemoryKimiK2TokenStore(),
-            augmentCookieStore: InMemoryCookieHeaderStore(),
-            ampCookieStore: InMemoryCookieHeaderStore(),
-            copilotTokenStore: InMemoryCopilotTokenStore(),
-            tokenAccountStore: InMemoryTokenAccountStore())
-        settings.historicalTrackingEnabled = true
-
-        let store = UsageStore(
-            fetcher: UsageFetcher(environment: [:]),
-            browserDetection: BrowserDetection(cacheTTL: 0),
-            settings: settings,
-            historicalUsageHistoryStore: HistoricalUsageHistoryStore(fileURL: Self.makeTempURL()))
-
-        let now = Date(timeIntervalSince1970: 0)
-        let window = RateWindow(
-            usedPercent: 50,
+    func `exhausted actual returns zero eta`() throws {
+        let now = Date()
+        let resetsAt = now.addingTimeInterval(3600)
+        let week = HistoricalWeekProfile(
+            resetsAt: now.addingTimeInterval(-10080 * 60),
             windowMinutes: 10080,
-            resetsAt: now.addingTimeInterval(4 * 24 * 60 * 60),
-            resetDescription: nil)
+            curve: Array(repeating: 100.0, count: 169))
+        let dataset = CodexHistoricalDataset(weeks: [week, week, week])
 
-        let twoWeeksDataset = CodexHistoricalDataset(weeks: [
-            HistoricalWeekProfile(
-                resetsAt: now.addingTimeInterval(-7 * 24 * 60 * 60),
+        for usedPercent in [100.0, 120.0] {
+            let window = RateWindow(
+                usedPercent: usedPercent,
                 windowMinutes: 10080,
-                curve: Self.linearCurve(end: 100)),
-            HistoricalWeekProfile(
-                resetsAt: now.addingTimeInterval(-14 * 24 * 60 * 60),
-                windowMinutes: 10080,
-                curve: Self.linearCurve(end: 100)),
-        ])
-        store._setCodexHistoricalDatasetForTesting(twoWeeksDataset)
-
-        let computed = store.weeklyPace(provider: .codex, window: window, now: now)
-        let linear = UsagePace.weekly(window: window, now: now, defaultWindowMinutes: 10080)
-        #expect(computed != nil)
-        #expect(abs((computed?.deltaPercent ?? 0) - (linear?.deltaPercent ?? 0)) < 0.001)
+                resetsAt: resetsAt,
+                resetDescription: nil,
+                nextRegenPercent: nil)
+
+            let pace = try #require(CodexHistoricalPaceEvaluator.evaluate(
+                window: window,
+                now: now,
+                dataset: dataset))
+            #expect(pace.willLastToReset == false)
+            #expect(pace.etaSeconds == 0)
+            #expect(pace.runOutProbability == 1)
+
+            let detail = UsagePaceText.weeklyDetail(pace: pace, now: now)
+            #expect(detail.rightLabel == "Runs out now · ≈ 100% run-out risk")
+        }
     }
 }
diff --git a/Tests/CodexBarTests/IconRendererHideCrittersTests.swift b/Tests/CodexBarTests/IconRendererHideCrittersTests.swift
new file mode 100644
index 0000000000..eb879f1b2c
--- /dev/null
+++ b/Tests/CodexBarTests/IconRendererHideCrittersTests.swift
@@ -0,0 +1,79 @@
+import AppKit
+import CodexBarCore
+import Testing
+@testable import CodexBar
+
+@MainActor
+@Suite(.serialized)
+struct IconRendererHideCrittersTests {
+    private func pixels(_ image: NSImage) throws -> Data {
+        try #require(image.tiffRepresentation)
+    }
+
+    private func icon(style: IconStyle, weeklyRemaining: Double? = 40, hideCritters: Bool) -> NSImage {
+        IconRenderer.makeIcon(
+            primaryRemaining: 60,
+            weeklyRemaining: weeklyRemaining,
+            creditsRemaining: nil,
+            stale: false,
+            style: style,
+            hideCritters: hideCritters)
+    }
+
+    @Test(arguments: [
+        IconStyle.codex,
+        .claude,
+        .gemini,
+        .antigravity,
+        .factory,
+        .warp,
+    ])
+    func `hiding critters removes every decorated style twist`(style: IconStyle) throws {
+        let decorated = self.icon(style: style, hideCritters: false)
+        let plain = self.icon(style: style, hideCritters: true)
+
+        #expect(try self.pixels(decorated) != self.pixels(plain))
+    }
+
+    @Test(arguments: [
+        IconStyle.codex,
+        .claude,
+        .gemini,
+        .antigravity,
+        .factory,
+        .warp,
+    ])
+    func `hidden decorated styles match plain capsule bars`(style: IconStyle) throws {
+        let hidden = self.icon(style: style, hideCritters: true)
+        let reference = self.icon(style: .cursor, hideCritters: true)
+
+        #expect(try self.pixels(hidden) == self.pixels(reference))
+    }
+
+    @Test
+    func `hiding critters removes warp eyes without weekly quota`() throws {
+        let decorated = self.icon(style: .warp, weeklyRemaining: nil, hideCritters: false)
+        let plain = self.icon(style: .warp, weeklyRemaining: nil, hideCritters: true)
+
+        #expect(try self.pixels(decorated) != self.pixels(plain))
+    }
+
+    @Test
+    func `hiding critters is a no-op for an undecorated style`() throws {
+        // Cursor has no critter twist, so the flag must not alter its bars.
+        let withFlag = self.icon(style: .cursor, hideCritters: true)
+        let withoutFlag = self.icon(style: .cursor, hideCritters: false)
+
+        #expect(try self.pixels(withFlag) == self.pixels(withoutFlag))
+    }
+
+    @Test
+    func `morph icon honors hide critters at full progress`() throws {
+        // At full progress the morph cross-fades into the bar icon, which carries
+        // the Codex face. A distinct cache key must keep the two renders separate.
+        let decorated = IconRenderer.makeMorphIcon(progress: 1, style: .codex, hideCritters: false)
+        let plain = IconRenderer.makeMorphIcon(progress: 1, style: .codex, hideCritters: true)
+
+        #expect(try self.pixels(decorated) != self.pixels(plain))
+    }
+}
diff --git a/Tests/CodexBarTests/InlineCostHistoryDashboardLabelTests.swift b/Tests/CodexBarTests/InlineCostHistoryDashboardLabelTests.swift
new file mode 100644
index 0000000000..2584e5dfed
--- /dev/null
+++ b/Tests/CodexBarTests/InlineCostHistoryDashboardLabelTests.swift
@@ -0,0 +1,124 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct InlineCostHistoryDashboardLabelTests {
+    @Test
+    func `local cost history KPI titles preserve one day and dynamic windows`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_179_200)
+        let metadata = try #require(ProviderDefaults.metadata[.claude])
+        let daily = [
+            CostUsageDailyReport.Entry(
+                date: "2023-11-14",
+                inputTokens: 100,
+                outputTokens: 50,
+                totalTokens: 150,
+                costUSD: 0.12,
+                modelsUsed: ["claude-sonnet-4"],
+                modelBreakdowns: nil),
+            CostUsageDailyReport.Entry(
+                date: "2023-11-15",
+                inputTokens: 200,
+                outputTokens: 75,
+                totalTokens: 275,
+                costUSD: 0.25,
+                modelsUsed: ["claude-opus-4"],
+                modelBreakdowns: nil),
+        ]
+
+        func makeModel(historyDays: Int) -> UsageMenuCardView.Model {
+            let tokenSnapshot = CostUsageTokenSnapshot(
+                sessionTokens: 275,
+                sessionCostUSD: 0.25,
+                last30DaysTokens: 425,
+                last30DaysCostUSD: 0.37,
+                historyDays: historyDays,
+                daily: daily,
+                updatedAt: now)
+            return UsageMenuCardView.Model.make(.init(
+                provider: .claude,
+                metadata: metadata,
+                snapshot: UsageSnapshot(
+                    primary: RateWindow(usedPercent: 10, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                    secondary: nil,
+                    updatedAt: now),
+                credits: nil,
+                creditsError: nil,
+                dashboard: nil,
+                dashboardError: nil,
+                tokenSnapshot: tokenSnapshot,
+                tokenError: nil,
+                account: AccountInfo(email: nil, plan: nil),
+                isRefreshing: false,
+                lastError: nil,
+                usageBarsShowUsed: false,
+                resetTimeDisplayStyle: .countdown,
+                tokenCostUsageEnabled: true,
+                showOptionalCreditsAndExtraUsage: true,
+                hidePersonalInfo: false,
+                now: now))
+        }
+
+        let oneDay = makeModel(historyDays: 1)
+        #expect(oneDay.inlineUsageDashboard?.kpis[1].title == "Today")
+        #expect(oneDay.inlineUsageDashboard?.kpis[2].title == "Today tokens")
+
+        let sevenDays = makeModel(historyDays: 7)
+        #expect(sevenDays.inlineUsageDashboard?.kpis[1].title == "Last 7 days Cost")
+        #expect(sevenDays.inlineUsageDashboard?.kpis[2].title == "Last 7 days tokens")
+
+        let thirtyDays = makeModel(historyDays: 30)
+        #expect(thirtyDays.inlineUsageDashboard?.kpis[1].title == "30d cost")
+        #expect(thirtyDays.inlineUsageDashboard?.kpis[2].title == "30d tokens")
+    }
+
+    @Test
+    func `custom cost history KPI title keeps token label distinct`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_179_200)
+        let metadata = try #require(ProviderDefaults.metadata[.claude])
+        let tokenSnapshot = CostUsageTokenSnapshot(
+            sessionTokens: 275,
+            sessionCostUSD: 0.25,
+            last30DaysTokens: 425,
+            last30DaysCostUSD: 0.37,
+            historyLabel: "This month",
+            daily: [
+                CostUsageDailyReport.Entry(
+                    date: "2023-11-15",
+                    inputTokens: 200,
+                    outputTokens: 75,
+                    totalTokens: 275,
+                    costUSD: 0.25,
+                    modelsUsed: nil,
+                    modelBreakdowns: nil),
+            ],
+            updatedAt: now)
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .claude,
+            metadata: metadata,
+            snapshot: UsageSnapshot(
+                primary: nil,
+                secondary: nil,
+                updatedAt: now),
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: tokenSnapshot,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: true,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.inlineUsageDashboard?.kpis[1].title == "This month")
+        #expect(model.inlineUsageDashboard?.kpis[2].title == "This month tokens")
+    }
+}
diff --git a/Tests/CodexBarTests/InlineUsageDashboardBarColorTests.swift b/Tests/CodexBarTests/InlineUsageDashboardBarColorTests.swift
new file mode 100644
index 0000000000..78b34b2c14
--- /dev/null
+++ b/Tests/CodexBarTests/InlineUsageDashboardBarColorTests.swift
@@ -0,0 +1,88 @@
+import CodexBarCore
+import Foundation
+import SwiftUI
+import Testing
+@testable import CodexBar
+
+struct InlineUsageDashboardBarColorTests {
+    /// The inline usage bars must be tinted with each provider's branding color (the same color
+    /// used by the switcher tab and the detailed cost-history chart) rather than a fixed palette.
+    @Test
+    func `bar color matches branding for every provider`() {
+        for provider in UsageProvider.allCases {
+            let branding = ProviderDescriptorRegistry.descriptor(for: provider).branding.color
+            let expected = Color(red: branding.red, green: branding.green, blue: branding.blue)
+            #expect(
+                UsageMenuCardView.Model.inlineDashboardBarColor(for: provider) == expected,
+                "inline bar color did not match branding for \(provider.rawValue)")
+        }
+    }
+
+    /// The resolved dashboard model must actually carry the provider's branding color, and two
+    /// providers with different branding must end up with different bar colors.
+    @Test
+    func `resolved dashboard carries provider branding color`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_179_200)
+        let daily = [
+            CostUsageDailyReport.Entry(
+                date: "2023-11-14",
+                inputTokens: 100,
+                outputTokens: 50,
+                totalTokens: 150,
+                costUSD: 0.12,
+                modelsUsed: ["gpt-5"],
+                modelBreakdowns: nil),
+            CostUsageDailyReport.Entry(
+                date: "2023-11-15",
+                inputTokens: 200,
+                outputTokens: 75,
+                totalTokens: 275,
+                costUSD: 0.25,
+                modelsUsed: ["gpt-5"],
+                modelBreakdowns: nil),
+        ]
+
+        func makeModel(provider: UsageProvider) throws -> UsageMenuCardView.Model {
+            let metadata = try #require(ProviderDefaults.metadata[provider])
+            let tokenSnapshot = CostUsageTokenSnapshot(
+                sessionTokens: 275,
+                sessionCostUSD: 0.25,
+                last30DaysTokens: 425,
+                last30DaysCostUSD: 0.37,
+                historyDays: 30,
+                daily: daily,
+                updatedAt: now)
+            return UsageMenuCardView.Model.make(.init(
+                provider: provider,
+                metadata: metadata,
+                snapshot: UsageSnapshot(
+                    primary: RateWindow(usedPercent: 10, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                    secondary: nil,
+                    updatedAt: now),
+                credits: nil,
+                creditsError: nil,
+                dashboard: nil,
+                dashboardError: nil,
+                tokenSnapshot: tokenSnapshot,
+                tokenError: nil,
+                account: AccountInfo(email: nil, plan: nil),
+                isRefreshing: false,
+                lastError: nil,
+                usageBarsShowUsed: false,
+                resetTimeDisplayStyle: .countdown,
+                tokenCostUsageEnabled: true,
+                showOptionalCreditsAndExtraUsage: true,
+                hidePersonalInfo: false,
+                now: now))
+        }
+
+        let codex = try makeModel(provider: .codex)
+        let claude = try makeModel(provider: .claude)
+
+        #expect(codex.inlineUsageDashboard?.barColor
+            == UsageMenuCardView.Model.inlineDashboardBarColor(for: .codex))
+        #expect(claude.inlineUsageDashboard?.barColor
+            == UsageMenuCardView.Model.inlineDashboardBarColor(for: .claude))
+        #expect(codex.inlineUsageDashboard?.barColor != claude.inlineUsageDashboard?.barColor)
+    }
+}
diff --git a/Tests/CodexBarTests/InstallOriginTests.swift b/Tests/CodexBarTests/InstallOriginTests.swift
index 6257229a25..7099bb6c85 100644
--- a/Tests/CodexBarTests/InstallOriginTests.swift
+++ b/Tests/CodexBarTests/InstallOriginTests.swift
@@ -2,10 +2,9 @@ import Foundation
 import Testing
 @testable import CodexBar
 
-@Suite
 struct InstallOriginTests {
     @Test
-    func detectsHomebrewCaskroom() {
+    func `detects homebrew caskroom`() {
         #expect(
             InstallOrigin
                 .isHomebrewCask(
diff --git a/Tests/CodexBarTests/JetBrainsIDEDetectorTests.swift b/Tests/CodexBarTests/JetBrainsIDEDetectorTests.swift
index 2e7eeeef9b..ecbee841ed 100644
--- a/Tests/CodexBarTests/JetBrainsIDEDetectorTests.swift
+++ b/Tests/CodexBarTests/JetBrainsIDEDetectorTests.swift
@@ -1,10 +1,9 @@
 import CodexBarCore
 import Testing
 
-@Suite
 struct JetBrainsIDEDetectorTests {
     @Test
-    func parsesIDEDirectoryCaseInsensitive() {
+    func `parses IDE directory case insensitive`() {
         let info = JetBrainsIDEDetector._parseIDEDirectoryForTesting(
             dirname: "Webstorm2024.1",
             basePath: "/test")
diff --git a/Tests/CodexBarTests/JetBrainsStatusProbeTests.swift b/Tests/CodexBarTests/JetBrainsStatusProbeTests.swift
index 8e64863a7b..d5fc20945e 100644
--- a/Tests/CodexBarTests/JetBrainsStatusProbeTests.swift
+++ b/Tests/CodexBarTests/JetBrainsStatusProbeTests.swift
@@ -2,10 +2,9 @@ import CodexBarCore
 import Foundation
 import Testing
 
-@Suite
 struct JetBrainsStatusProbeTests {
     @Test
-    func parsesQuotaXMLWithTariffQuota() throws {
+    func `parses quota XML with tariff quota`() throws {
         // Real-world format with tariffQuota containing available credits
         let quotaInfo = [
             "{&#10;  &quot;type&quot;: &quot;Available&quot;,",
@@ -57,7 +56,7 @@ struct JetBrainsStatusProbeTests {
     }
 
     @Test
-    func parsesQuotaXMLWithoutTariffQuota() throws {
+    func `parses quota XML without tariff quota`() throws {
         // Fallback format without tariffQuota
         let quotaInfo = [
             "{&#10;  &quot;type&quot;: &quot;paid&quot;,",
@@ -104,7 +103,7 @@ struct JetBrainsStatusProbeTests {
     }
 
     @Test
-    func calculatesUsagePercentageFromAvailable() {
+    func `calculates usage percentage from available`() {
         // available = 75_000, maximum = 100_000 -> 75% remaining, 25% used
         let quotaInfo = JetBrainsQuotaInfo(
             type: "paid",
@@ -118,7 +117,7 @@ struct JetBrainsStatusProbeTests {
     }
 
     @Test
-    func calculatesUsagePercentageAtZero() {
+    func `calculates usage percentage at zero`() {
         let quotaInfo = JetBrainsQuotaInfo(
             type: "paid",
             used: 0,
@@ -131,7 +130,7 @@ struct JetBrainsStatusProbeTests {
     }
 
     @Test
-    func calculatesUsagePercentageAtMax() {
+    func `calculates usage percentage at max`() {
         let quotaInfo = JetBrainsQuotaInfo(
             type: "paid",
             used: 100_000,
@@ -144,7 +143,7 @@ struct JetBrainsStatusProbeTests {
     }
 
     @Test
-    func handlesZeroMaximum() {
+    func `handles zero maximum`() {
         let quotaInfo = JetBrainsQuotaInfo(
             type: "free",
             used: 1000,
@@ -157,7 +156,7 @@ struct JetBrainsStatusProbeTests {
     }
 
     @Test
-    func convertsToUsageSnapshot() throws {
+    func `converts to usage snapshot`() throws {
         let quotaInfo = JetBrainsQuotaInfo(
             type: "Available",
             used: 7478.3,
@@ -196,7 +195,7 @@ struct JetBrainsStatusProbeTests {
     }
 
     @Test
-    func usageSnapshotUsesRefillDateForReset() throws {
+    func `usage snapshot uses refill date for reset`() throws {
         let refillDate = Date().addingTimeInterval(86400 * 6) // 6 days from now
         let untilDate = Date().addingTimeInterval(86400 * 300) // 300 days from now
 
@@ -225,7 +224,7 @@ struct JetBrainsStatusProbeTests {
     }
 
     @Test
-    func parsesIDEDirectory() {
+    func `parses IDE directory`() {
         let ides = [
             ("IntelliJIdea2024.3", "IntelliJ IDEA", "2024.3"),
             ("PyCharm2024.2", "PyCharm", "2024.2"),
@@ -249,7 +248,7 @@ struct JetBrainsStatusProbeTests {
     }
 
     @Test
-    func expandsTildeInCustomPath() async throws {
+    func `expands tilde in custom path`() async throws {
         let fileManager = FileManager.default
         let home = fileManager.homeDirectoryForCurrentUser
         let testRoot = home
@@ -300,7 +299,7 @@ struct JetBrainsStatusProbeTests {
     }
 
     @Test
-    func handlesHTMLEntities() throws {
+    func `handles HTML entities`() throws {
         let quotaInfo = [
             "{&quot;type&quot;:&quot;free&quot;",
             ",&quot;current&quot;:&quot;0&quot;",
@@ -326,7 +325,7 @@ struct JetBrainsStatusProbeTests {
     }
 
     @Test
-    func throwsOnMissingQuotaInfo() throws {
+    func `throws on missing quota info`() throws {
         let xml = """
         <?xml version="1.0" encoding="UTF-8"?>
         <application>
@@ -342,7 +341,7 @@ struct JetBrainsStatusProbeTests {
     }
 
     @Test
-    func throwsOnEmptyQuotaInfo() throws {
+    func `throws on empty quota info`() throws {
         let xml = """
         <?xml version="1.0" encoding="UTF-8"?>
         <application>
diff --git a/Tests/CodexBarTests/KeyboardShortcutsBundleTests.swift b/Tests/CodexBarTests/KeyboardShortcutsBundleTests.swift
index 61e511225a..2541001d17 100644
--- a/Tests/CodexBarTests/KeyboardShortcutsBundleTests.swift
+++ b/Tests/CodexBarTests/KeyboardShortcutsBundleTests.swift
@@ -1,9 +1,19 @@
 import KeyboardShortcuts
 import Testing
+@testable import CodexBar
 
 @MainActor
-@Suite struct KeyboardShortcutsBundleTests {
-    @Test func recorderInitializesWithoutCrashing() {
+struct KeyboardShortcutsBundleTests {
+    @Test func `recorder initializes without crashing`() {
         _ = KeyboardShortcuts.RecorderCocoa(for: .init("test.keyboardshortcuts.bundle"))
     }
+
+    @Test func `open menu recorder expands beyond dependency intrinsic width`() {
+        let recorder = KeyboardShortcuts.RecorderCocoa(for: .init("test.keyboardshortcuts.width"))
+        let size = OpenMenuShortcutRecorder.fittedSize(intrinsicHeight: recorder.intrinsicContentSize.height)
+
+        #expect(size.width == OpenMenuShortcutRecorder.preferredWidth)
+        #expect(size.width > recorder.intrinsicContentSize.width)
+        #expect(size.height == recorder.intrinsicContentSize.height)
+    }
 }
diff --git a/Tests/CodexBarTests/KeychainCacheStoreTests.swift b/Tests/CodexBarTests/KeychainCacheStoreTests.swift
index 3bf24ca8fd..186534dd0e 100644
--- a/Tests/CodexBarTests/KeychainCacheStoreTests.swift
+++ b/Tests/CodexBarTests/KeychainCacheStoreTests.swift
@@ -10,7 +10,36 @@ struct KeychainCacheStoreTests {
     }
 
     @Test
-    func storesAndLoadsEntry() {
+    func `tests suppress real keychain access by default`() {
+        guard ProcessInfo.processInfo.environment["CODEXBAR_ALLOW_TEST_KEYCHAIN_ACCESS"] != "1" else { return }
+
+        #expect(KeychainCacheStore.canUseRealKeychainForTesting == false)
+        let key = KeychainCacheStore.Key(category: "test", identifier: UUID().uuidString)
+        let entry = TestEntry(value: "implicit", storedAt: Date(timeIntervalSince1970: 0))
+
+        KeychainCacheStore.store(key: key, entry: entry)
+        defer { KeychainCacheStore.clear(key: key) }
+
+        switch KeychainCacheStore.load(key: key, as: TestEntry.self) {
+        case let .found(loaded):
+            #expect(loaded == entry)
+        case .missing, .temporarilyUnavailable, .invalid:
+            #expect(Bool(false), "Expected implicit test cache entry")
+        }
+    }
+
+    @Test
+    func `background interaction keeps real keychain cache available for no UI reads writes and deletes`() {
+        KeychainAccessGate.withTaskOverrideForTesting(false) {
+            ProviderInteractionContext.$current.withValue(.background) {
+                #expect(KeychainCacheStore.canUseRealKeychainForTesting == true)
+                #expect(KeychainCacheStore.canEnumerateOrDeleteRealKeychainForTesting == true)
+            }
+        }
+    }
+
+    @Test
+    func `stores and loads entry`() {
         KeychainCacheStore.setTestStoreForTesting(true)
         defer { KeychainCacheStore.setTestStoreForTesting(false) }
 
@@ -24,13 +53,13 @@ struct KeychainCacheStoreTests {
         switch KeychainCacheStore.load(key: key, as: TestEntry.self) {
         case let .found(loaded):
             #expect(loaded == entry)
-        case .missing, .invalid:
+        case .missing, .temporarilyUnavailable, .invalid:
             #expect(Bool(false), "Expected keychain cache entry")
         }
     }
 
     @Test
-    func overwritesExistingEntry() {
+    func `overwrites existing entry`() {
         KeychainCacheStore.setTestStoreForTesting(true)
         defer { KeychainCacheStore.setTestStoreForTesting(false) }
 
@@ -45,13 +74,13 @@ struct KeychainCacheStoreTests {
         switch KeychainCacheStore.load(key: key, as: TestEntry.self) {
         case let .found(loaded):
             #expect(loaded == second)
-        case .missing, .invalid:
+        case .missing, .temporarilyUnavailable, .invalid:
             #expect(Bool(false), "Expected overwritten keychain cache entry")
         }
     }
 
     @Test
-    func clearRemovesEntry() {
+    func `clear removes entry`() {
         KeychainCacheStore.setTestStoreForTesting(true)
         defer { KeychainCacheStore.setTestStoreForTesting(false) }
 
@@ -64,8 +93,125 @@ struct KeychainCacheStoreTests {
         switch KeychainCacheStore.load(key: key, as: TestEntry.self) {
         case .missing:
             #expect(true)
-        case .found, .invalid:
+        case .found, .temporarilyUnavailable, .invalid:
             #expect(Bool(false), "Expected keychain cache entry to be cleared")
         }
     }
+
+    @Test
+    func `clear reports whether an entry was removed`() {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+        let key = KeychainCacheStore.Key(category: "test", identifier: UUID().uuidString)
+        let entry = TestEntry(value: "gone", storedAt: Date(timeIntervalSince1970: 0))
+        KeychainCacheStore.store(key: key, entry: entry)
+
+        #expect(KeychainCacheStore.clear(key: key) == true)
+        #expect(KeychainCacheStore.clear(key: key) == false)
+    }
+
+    @Test
+    func `keys lists only matching category for current service`() {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+        let serviceA = "cache-keys-a-\(UUID().uuidString)"
+        let serviceB = "cache-keys-b-\(UUID().uuidString)"
+        let cookieA = KeychainCacheStore.Key(category: "cookie", identifier: "codex")
+        let scopedCookieA = KeychainCacheStore.Key(category: "cookie", identifier: "codex.managed.account")
+        let oauthA = KeychainCacheStore.Key(category: "oauth", identifier: "codex")
+        let cookieB = KeychainCacheStore.Key(category: "cookie", identifier: "claude")
+        let entry = TestEntry(value: "value", storedAt: Date(timeIntervalSince1970: 0))
+
+        KeychainCacheStore.withServiceOverrideForTesting(serviceA) {
+            KeychainCacheStore.store(key: cookieA, entry: entry)
+            KeychainCacheStore.store(key: scopedCookieA, entry: entry)
+            KeychainCacheStore.store(key: oauthA, entry: entry)
+        }
+        KeychainCacheStore.withServiceOverrideForTesting(serviceB) {
+            KeychainCacheStore.store(key: cookieB, entry: entry)
+        }
+
+        let keys = KeychainCacheStore.withServiceOverrideForTesting(serviceA) {
+            KeychainCacheStore.keys(category: "cookie")
+        }
+
+        #expect(keys == [cookieA, scopedCookieA])
+    }
+
+    #if os(macOS)
+    @Test
+    func `interaction not allowed is treated as temporarily unavailable`() {
+        let key = KeychainCacheStore.Key(category: "test", identifier: UUID().uuidString)
+        let result: KeychainCacheStore.LoadResult<TestEntry> = KeychainCacheStore.loadResultForKeychainReadFailure(
+            status: errSecInteractionNotAllowed,
+            key: key)
+
+        switch result {
+        case .temporarilyUnavailable:
+            #expect(true)
+        case .found, .missing, .invalid:
+            #expect(Bool(false), "Expected temporary keychain lock to be retry-later")
+        }
+    }
+
+    @Test
+    func `delete interaction not allowed is non fatal`() {
+        let key = KeychainCacheStore.Key(category: "test", identifier: UUID().uuidString)
+        #expect(KeychainCacheStore.clearResultForKeychainDeleteStatus(
+            errSecInteractionNotAllowed,
+            key: key) == .failed)
+    }
+
+    @Test
+    func `load failure override bypasses test store without affecting store or clear`() {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+
+        let key = KeychainCacheStore.Key(category: "test", identifier: UUID().uuidString)
+        let entry = TestEntry(value: "stored", storedAt: Date(timeIntervalSince1970: 0))
+        KeychainCacheStore.store(key: key, entry: entry)
+        defer { KeychainCacheStore.clear(key: key) }
+
+        KeychainCacheStore.withLoadFailureStatusOverrideForTesting(errSecInteractionNotAllowed) {
+            switch KeychainCacheStore.load(key: key, as: TestEntry.self) {
+            case .temporarilyUnavailable:
+                #expect(true)
+            case .found, .missing, .invalid:
+                #expect(Bool(false), "Expected override to run before test store")
+            }
+        }
+
+        switch KeychainCacheStore.load(key: key, as: TestEntry.self) {
+        case let .found(loaded):
+            #expect(loaded == entry)
+        case .missing, .temporarilyUnavailable, .invalid:
+            #expect(Bool(false), "Expected override not to mutate test store")
+        }
+    }
+
+    @Test
+    func `cache ACL trusts bundled app and CLI helper`() {
+        let root = URL(fileURLWithPath: "/Applications/CodexBar.app")
+        let executable = root.appendingPathComponent("Contents/MacOS/CodexBar")
+        let helper = root.appendingPathComponent("Contents/Helpers/CodexBarCLI")
+        let existing = Set([
+            root.path,
+            executable.path,
+            helper.path,
+        ])
+
+        let paths = KeychainCacheStore.trustedApplicationPathsForCacheAccess(
+            bundleURL: root,
+            executableURL: executable,
+            fileExists: { existing.contains($0) })
+
+        #expect(paths == [
+            root.path,
+            helper.path,
+            executable.path,
+        ])
+    }
+    #endif
 }
diff --git a/Tests/CodexBarTests/KeychainMigrationTests.swift b/Tests/CodexBarTests/KeychainMigrationTests.swift
index a6357b11e1..7b3084b61b 100644
--- a/Tests/CodexBarTests/KeychainMigrationTests.swift
+++ b/Tests/CodexBarTests/KeychainMigrationTests.swift
@@ -1,12 +1,11 @@
 import Testing
 @testable import CodexBar
 
-@Suite
 struct KeychainMigrationTests {
     @Test
-    func migrationListCoversKnownKeychainItems() {
+    func `migration list covers known keychain items`() {
         let items = Set(KeychainMigration.itemsToMigrate.map(\.label))
-        let expected: Set<String> = [
+        let expected: Set = [
             "com.steipete.CodexBar:codex-cookie",
             "com.steipete.CodexBar:claude-cookie",
             "com.steipete.CodexBar:cursor-cookie",
diff --git a/Tests/CodexBarTests/KeychainNoUIQueryTests.swift b/Tests/CodexBarTests/KeychainNoUIQueryTests.swift
new file mode 100644
index 0000000000..58591543f0
--- /dev/null
+++ b/Tests/CodexBarTests/KeychainNoUIQueryTests.swift
@@ -0,0 +1,62 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+#if os(macOS)
+import Darwin
+import LocalAuthentication
+import Security
+
+struct KeychainNoUIQueryTests {
+    private func resolveSecurityUIFailValue() -> String {
+        let securityPath = "/System/Library/Frameworks/Security.framework/Security"
+        guard let handle = dlopen(securityPath, RTLD_NOW) else {
+            return "u_AuthUIF"
+        }
+        defer { dlclose(handle) }
+        guard let symbol = dlsym(handle, "kSecUseAuthenticationUIFail") else {
+            return "u_AuthUIF"
+        }
+        let valuePointer = symbol.assumingMemoryBound(to: CFString?.self)
+        return (valuePointer.pointee as String?) ?? "u_AuthUIF"
+    }
+
+    @Test
+    func `apply sets non interactive context and UI fail policy`() {
+        var query: [String: Any] = [:]
+
+        KeychainNoUIQuery.apply(to: &query)
+
+        let context = query[kSecUseAuthenticationContext as String] as? LAContext
+        #expect(context != nil)
+        #expect(context?.interactionNotAllowed == true)
+
+        let uiPolicy = query[kSecUseAuthenticationUI as String] as? String
+        #expect(uiPolicy == self.resolveSecurityUIFailValue())
+        #expect(uiPolicy == (KeychainNoUIQuery.uiFailPolicyForTesting() as String))
+        #expect(uiPolicy != "kSecUseAuthenticationUIFail")
+    }
+
+    @Test
+    func `preflight query is strictly non interactive and does not request secret data`() {
+        let query = KeychainAccessPreflight.makeGenericPasswordPreflightQuery(
+            service: "test.service",
+            account: "test.account")
+
+        #expect(query[kSecReturnData as String] == nil)
+        #expect(query[kSecReturnAttributes as String] as? Bool == true)
+        #expect((query[kSecUseAuthenticationContext as String] as? LAContext)?.interactionNotAllowed == true)
+        #expect((query[kSecUseAuthenticationUI as String] as? String) == self.resolveSecurityUIFailValue())
+    }
+
+    @Test
+    func `preflight query executes without invalid UI policy`() {
+        let query = KeychainAccessPreflight.makeGenericPasswordPreflightQuery(
+            service: "codexbar.keychain.noui.\(UUID().uuidString)",
+            account: nil)
+        var result: AnyObject?
+        let status = SecItemCopyMatching(query as CFDictionary, &result)
+        #expect(status == errSecItemNotFound || status == errSecInteractionNotAllowed)
+    }
+}
+#endif
diff --git a/Tests/CodexBarTests/KeychainPromptCoordinatorTests.swift b/Tests/CodexBarTests/KeychainPromptCoordinatorTests.swift
new file mode 100644
index 0000000000..215efc1a58
--- /dev/null
+++ b/Tests/CodexBarTests/KeychainPromptCoordinatorTests.swift
@@ -0,0 +1,40 @@
+import Testing
+@testable import CodexBar
+
+struct KeychainPromptCoordinatorTests {
+    @Test
+    func `detects raw SwiftPM debug executable`() {
+        #expect(KeychainPromptCoordinator.isUnbundledCodexBarExecutable(
+            "/Users/me/CodexBar/.build/arm64-apple-macosx/debug/CodexBar"))
+        #expect(KeychainPromptCoordinator.isUnbundledCodexBarExecutable(
+            "/Users/me/CodexBar/.build/debug/CodexBar"))
+    }
+
+    @Test
+    func `detects raw SwiftPM release executable`() {
+        #expect(KeychainPromptCoordinator.isUnbundledCodexBarExecutable(
+            "/Users/me/CodexBar/.build/arm64-apple-macosx/release/CodexBar"))
+    }
+
+    @Test
+    func `detects custom SwiftPM scratch path`() {
+        #expect(KeychainPromptCoordinator.isUnbundledCodexBarExecutable(
+            "/tmp/codexbar-build/arm64-apple-macosx/debug/CodexBar"))
+    }
+
+    @Test
+    func `keeps packaged app keychain behavior`() {
+        #expect(!KeychainPromptCoordinator.isUnbundledCodexBarExecutable(
+            "/Applications/CodexBar.app/Contents/MacOS/CodexBar"))
+        #expect(!KeychainPromptCoordinator.isUnbundledCodexBarExecutable(
+            "/Users/me/CodexBar/.build/package/CodexBar.app/Contents/MacOS/CodexBar"))
+    }
+
+    @Test
+    func `ignores unrelated executable paths`() {
+        #expect(!KeychainPromptCoordinator.isUnbundledCodexBarExecutable(
+            "/Users/me/CodexBar/.build/debug/CodexBarCLI"))
+        #expect(!KeychainPromptCoordinator.isUnbundledCodexBarExecutable(""))
+        #expect(!KeychainPromptCoordinator.isUnbundledCodexBarExecutable("CodexBar"))
+    }
+}
diff --git a/Tests/CodexBarTests/KeychainPromptSafetyAuditTests.swift b/Tests/CodexBarTests/KeychainPromptSafetyAuditTests.swift
new file mode 100644
index 0000000000..fb00d1ae64
--- /dev/null
+++ b/Tests/CodexBarTests/KeychainPromptSafetyAuditTests.swift
@@ -0,0 +1,133 @@
+import Foundation
+import Testing
+
+struct KeychainPromptSafetyAuditTests {
+    @Test
+    func `agent instructions forbid keychain prompt validation`() throws {
+        let agents = try Self.readRepoFile("AGENTS.md")
+
+        #expect(agents.contains("Never run tests/checks or ad-hoc validation that can display macOS Keychain prompts"))
+        #expect(agents.contains("use parser tests, stubs, test stores, or `KeychainNoUIQuery`"))
+    }
+
+    @Test
+    func `live TTY integration tests are opt in`() throws {
+        let ttyTests = try Self.readRepoFile("Tests/CodexBarTests/TTYIntegrationTests.swift")
+
+        #expect(ttyTests.contains("LIVE_CODEX_TTY"))
+        #expect(ttyTests.contains("LIVE_CLAUDE_TTY"))
+        #expect(ttyTests.contains("guard ProcessInfo.processInfo.environment[\"LIVE_CODEX_TTY\"] == \"1\""))
+        #expect(ttyTests.contains("guard ProcessInfo.processInfo.environment[\"LIVE_CLAUDE_TTY\"] == \"1\""))
+    }
+
+    @Test
+    func `interactive keychain prompt test paths use test doubles`() throws {
+        let promptLiteral = "allowKeychainPrompt: true"
+        let testFiles = try Self.swiftTestFiles(excludingSelf: true)
+        let promptCallSites = try testFiles.flatMap { file in
+            try Self.lines(in: file)
+                .enumerated()
+                .filter { _, line in line.contains(promptLiteral) }
+                .map { lineNumber, _ in PromptCallSite(file: file, lineNumber: lineNumber + 1) }
+        }
+
+        #expect(promptCallSites.isEmpty == false)
+        for callSite in promptCallSites {
+            let lines = try Self.lines(in: callSite.file)
+            let usesScopedKeychainDouble = Self.hasOpenKeychainTestDouble(lines: lines, before: callSite.lineNumber)
+            let failureMessage = "\(callSite.file.path):\(callSite.lineNumber) has \(promptLiteral) "
+                + "without an enclosing keychain test double"
+            #expect(usesScopedKeychainDouble, "\(failureMessage)")
+        }
+    }
+
+    @Test
+    func `tests do not call SecItemCopyMatching except no UI query coverage`() throws {
+        let offenders = try Self.swiftTestFiles().filter { file in
+            let text = try Self.readFile(file)
+            return text.contains("SecItemCopyMatching")
+                && !file.path.hasSuffix("Tests/CodexBarTests/KeychainNoUIQueryTests.swift")
+                && !file.path.hasSuffix("Tests/CodexBarTests/KeychainPromptSafetyAuditTests.swift")
+        }
+
+        #expect(offenders.isEmpty, "Unexpected direct SecItemCopyMatching in tests: \(offenders.map(\.path))")
+    }
+
+    private static func repoRoot() -> URL {
+        URL(fileURLWithPath: #filePath)
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+    }
+
+    private static func readRepoFile(_ relativePath: String) throws -> String {
+        try self.readFile(self.repoRoot().appendingPathComponent(relativePath))
+    }
+
+    private static func readFile(_ url: URL) throws -> String {
+        try String(contentsOf: url, encoding: .utf8)
+    }
+
+    private static func lines(in url: URL) throws -> [Substring] {
+        try self.readFile(url).split(separator: "\n", omittingEmptySubsequences: false)
+    }
+
+    private static func swiftTestFiles(excludingSelf: Bool = false) throws -> [URL] {
+        let testsRoot = self.repoRoot().appendingPathComponent("Tests/CodexBarTests", isDirectory: true)
+        guard let enumerator = FileManager.default.enumerator(
+            at: testsRoot,
+            includingPropertiesForKeys: [.isRegularFileKey],
+            options: [.skipsHiddenFiles])
+        else { return [] }
+
+        var files: [URL] = []
+        for case let file as URL in enumerator where file.pathExtension == "swift" {
+            let values = try file.resourceValues(forKeys: [.isRegularFileKey])
+            if values.isRegularFile == true {
+                if excludingSelf, file.path.hasSuffix("Tests/CodexBarTests/KeychainPromptSafetyAuditTests.swift") {
+                    continue
+                }
+                files.append(file)
+            }
+        }
+        return files
+    }
+
+    private static func hasOpenKeychainTestDouble(lines: [Substring], before oneBasedLineNumber: Int) -> Bool {
+        let helperNames = [
+            "withClaudeKeychainOverridesForTesting",
+            "withSecurityCLIReadOverrideForTesting",
+            "KeychainAccessPreflight.withCheckGenericPasswordOverrideForTesting",
+        ]
+        let targetIndex = oneBasedLineNumber - 1
+        let lineRange = lines.indices.prefix(through: targetIndex)
+        return lineRange.contains { index in
+            helperNames.contains { lines[index].contains($0) }
+                && self.hasOpenBraceScope(lines: lines, from: index, through: targetIndex)
+        }
+    }
+
+    private static func hasOpenBraceScope(lines: [Substring], from startIndex: Int, through endIndex: Int) -> Bool {
+        var balance = 0
+        var sawOpeningBrace = false
+        for line in lines[startIndex...endIndex] {
+            for character in line {
+                switch character {
+                case "{":
+                    balance += 1
+                    sawOpeningBrace = true
+                case "}":
+                    balance -= 1
+                default:
+                    continue
+                }
+            }
+        }
+        return sawOpeningBrace && balance > 0
+    }
+
+    private struct PromptCallSite {
+        let file: URL
+        let lineNumber: Int
+    }
+}
diff --git a/Tests/CodexBarTests/KiloBearerTokenResolverTests.swift b/Tests/CodexBarTests/KiloBearerTokenResolverTests.swift
new file mode 100644
index 0000000000..371bc3bfb1
--- /dev/null
+++ b/Tests/CodexBarTests/KiloBearerTokenResolverTests.swift
@@ -0,0 +1,124 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct KiloBearerTokenResolverTests {
+    private func writeAuthFile(_ json: String) throws -> URL {
+        let directory = FileManager.default.temporaryDirectory
+            .appendingPathComponent("kilo-resolver-tests-\(UUID().uuidString)", isDirectory: true)
+        let kiloDir = directory
+            .appendingPathComponent(".local", isDirectory: true)
+            .appendingPathComponent("share", isDirectory: true)
+            .appendingPathComponent("kilo", isDirectory: true)
+        try FileManager.default.createDirectory(at: kiloDir, withIntermediateDirectories: true)
+        let authURL = kiloDir.appendingPathComponent("auth.json", isDirectory: false)
+        try json.write(to: authURL, atomically: true, encoding: .utf8)
+        return directory
+    }
+
+    @Test
+    func `api mode uses provided apiKey`() throws {
+        let resolved = try KiloBearerTokenResolver.resolve(
+            source: .api,
+            apiKey: "kilo_abc",
+            environment: [:])
+        #expect(resolved.token == "kilo_abc")
+        #expect(resolved.sourceLabel == "api")
+    }
+
+    @Test
+    func `api mode falls back to KILO_API_KEY env var when apiKey is empty`() throws {
+        let resolved = try KiloBearerTokenResolver.resolve(
+            source: .api,
+            apiKey: nil,
+            environment: ["KILO_API_KEY": "kilo_from_env"])
+        #expect(resolved.token == "kilo_from_env")
+        #expect(resolved.sourceLabel == "api")
+    }
+
+    @Test
+    func `api mode throws missingCredentials when nothing available`() {
+        #expect(throws: KiloUsageError.missingCredentials) {
+            try KiloBearerTokenResolver.resolve(
+                source: .api,
+                apiKey: nil,
+                environment: [:])
+        }
+    }
+
+    @Test
+    func `cli mode reads token from auth.json`() throws {
+        let home = try self.writeAuthFile(#"{ "kilo": { "access": "cli-token" } }"#)
+        defer { try? FileManager.default.removeItem(at: home) }
+
+        let resolved = try KiloBearerTokenResolver.resolve(
+            source: .cli,
+            apiKey: nil,
+            environment: ["HOME": home.path])
+        #expect(resolved.token == "cli-token")
+        #expect(resolved.sourceLabel == "cli")
+    }
+
+    @Test
+    func `cli mode throws cliSessionMissing when auth.json missing`() {
+        let nonexistentHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("kilo-no-such-home-\(UUID().uuidString)", isDirectory: true)
+        #expect(throws: (any Error).self) {
+            try KiloBearerTokenResolver.resolve(
+                source: .cli,
+                apiKey: nil,
+                environment: ["HOME": nonexistentHome.path])
+        }
+    }
+
+    @Test
+    func `cli mode throws cliSessionInvalid for malformed JSON`() throws {
+        let home = try self.writeAuthFile(#"{ "kilo": { } }"#)
+        defer { try? FileManager.default.removeItem(at: home) }
+
+        #expect(throws: (any Error).self) {
+            try KiloBearerTokenResolver.resolve(
+                source: .cli,
+                apiKey: nil,
+                environment: ["HOME": home.path])
+        }
+    }
+
+    @Test
+    func `auto mode prefers API key when available`() throws {
+        let home = try self.writeAuthFile(#"{ "kilo": { "access": "cli-token" } }"#)
+        defer { try? FileManager.default.removeItem(at: home) }
+
+        let resolved = try KiloBearerTokenResolver.resolve(
+            source: .auto,
+            apiKey: "kilo_api",
+            environment: ["HOME": home.path])
+        #expect(resolved.token == "kilo_api")
+        #expect(resolved.sourceLabel == "api")
+    }
+
+    @Test
+    func `auto mode falls back to CLI when API key missing`() throws {
+        let home = try self.writeAuthFile(#"{ "kilo": { "access": "cli-fallback" } }"#)
+        defer { try? FileManager.default.removeItem(at: home) }
+
+        let resolved = try KiloBearerTokenResolver.resolve(
+            source: .auto,
+            apiKey: nil,
+            environment: ["HOME": home.path])
+        #expect(resolved.token == "cli-fallback")
+        #expect(resolved.sourceLabel == "cli")
+    }
+
+    @Test
+    func `auto mode surfaces CLI error when neither path available`() {
+        let nonexistentHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("kilo-no-such-home-\(UUID().uuidString)", isDirectory: true)
+        #expect(throws: (any Error).self) {
+            try KiloBearerTokenResolver.resolve(
+                source: .auto,
+                apiKey: nil,
+                environment: ["HOME": nonexistentHome.path])
+        }
+    }
+}
diff --git a/Tests/CodexBarTests/KiloOrganizationTests.swift b/Tests/CodexBarTests/KiloOrganizationTests.swift
new file mode 100644
index 0000000000..7b12e273e5
--- /dev/null
+++ b/Tests/CodexBarTests/KiloOrganizationTests.swift
@@ -0,0 +1,72 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct KiloOrganizationTests {
+    @Test
+    func `decodes from canonical Kilo profile payload`() throws {
+        let json = #"""
+        { "id": "org_123", "name": "Acme Corp", "role": "owner" }
+        """#
+        let data = Data(json.utf8)
+        let org = try JSONDecoder().decode(KiloOrganization.self, from: data)
+        #expect(org.id == "org_123")
+        #expect(org.name == "Acme Corp")
+        #expect(org.role == "owner")
+    }
+
+    @Test
+    func `decodes when role missing`() throws {
+        let json = #"""
+        { "id": "org_xyz", "name": "No Role Org" }
+        """#
+        let data = Data(json.utf8)
+        let org = try JSONDecoder().decode(KiloOrganization.self, from: data)
+        #expect(org.role == nil)
+    }
+
+    @Test
+    func `equality covers all stored fields`() {
+        let a = KiloOrganization(id: "org_1", name: "A", role: "member")
+        let b = KiloOrganization(id: "org_1", name: "A", role: "member")
+        let differentRole = KiloOrganization(id: "org_1", name: "A", role: "owner")
+        #expect(a == b)
+        #expect(a != differentRole)
+    }
+}
+
+struct KiloUsageScopeTests {
+    @Test
+    func `personal scope identifier is stable`() {
+        let scope: KiloUsageScope = .personal
+        #expect(scope.scopeIdentifier == "personal")
+    }
+
+    @Test
+    func `organization scope identifier prefixes id`() {
+        let scope: KiloUsageScope = .organization(id: "org_42", name: "Acme")
+        #expect(scope.scopeIdentifier == "org:org_42")
+    }
+
+    @Test
+    func `organizationID is nil for personal`() {
+        #expect(KiloUsageScope.personal.organizationID == nil)
+    }
+
+    @Test
+    func `organizationID returns id for organization`() {
+        let scope: KiloUsageScope = .organization(id: "org_42", name: "Acme")
+        #expect(scope.organizationID == "org_42")
+    }
+
+    @Test
+    func `displayName falls back to Personal for personal`() {
+        #expect(KiloUsageScope.personal.displayName == "Personal")
+    }
+
+    @Test
+    func `displayName uses org name for organization`() {
+        let scope: KiloUsageScope = .organization(id: "org_42", name: "Acme")
+        #expect(scope.displayName == "Acme")
+    }
+}
diff --git a/Tests/CodexBarTests/KiloSettingsReaderTests.swift b/Tests/CodexBarTests/KiloSettingsReaderTests.swift
index 239729fe19..40335b4779 100644
--- a/Tests/CodexBarTests/KiloSettingsReaderTests.swift
+++ b/Tests/CodexBarTests/KiloSettingsReaderTests.swift
@@ -1,10 +1,9 @@
 import CodexBarCore
 import Testing
 
-@Suite
 struct KiloSettingsReaderTests {
     @Test
-    func apiURLDefaultsToAppKiloAITrpc() {
+    func `api URL defaults to app kilo AI trpc`() {
         let url = KiloSettingsReader.apiURL(environment: [:])
 
         #expect(url.scheme == "https")
@@ -13,7 +12,7 @@ struct KiloSettingsReaderTests {
     }
 
     @Test
-    func apiURLIgnoresEnvironmentOverride() {
+    func `api URL ignores environment override`() {
         let url = KiloSettingsReader.apiURL(environment: ["KILO_API_URL": "https://proxy.example.com/trpc"])
 
         #expect(url.host() == "app.kilo.ai")
@@ -21,19 +20,19 @@ struct KiloSettingsReaderTests {
     }
 
     @Test
-    func descriptorUsesAppKiloAIDashboard() {
+    func `descriptor uses app kilo AI dashboard`() {
         let descriptor = ProviderDescriptorRegistry.descriptor(for: .kilo)
-        #expect(descriptor.metadata.dashboardURL == "https://app.kilo.ai/account/usage")
+        #expect(descriptor.metadata.dashboardURL == "https://app.kilo.ai/usage")
     }
 
     @Test
-    func descriptorUsesDedicatedKiloIconResource() {
+    func `descriptor uses dedicated kilo icon resource`() {
         let descriptor = ProviderDescriptorRegistry.descriptor(for: .kilo)
         #expect(descriptor.branding.iconResourceName == "ProviderIcon-kilo")
     }
 
     @Test
-    func descriptorSupportsAutoAPIAndCLISourceModes() {
+    func `descriptor supports auto API and CLI source modes`() {
         let descriptor = ProviderDescriptorRegistry.descriptor(for: .kilo)
         let expected: Set<ProviderSourceMode> = [.auto, .api, .cli]
         #expect(descriptor.fetchPlan.sourceModes == expected)
diff --git a/Tests/CodexBarTests/KiloSettingsStoreTests.swift b/Tests/CodexBarTests/KiloSettingsStoreTests.swift
new file mode 100644
index 0000000000..c5156a854c
--- /dev/null
+++ b/Tests/CodexBarTests/KiloSettingsStoreTests.swift
@@ -0,0 +1,57 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@MainActor
+struct KiloSettingsStoreTests {
+    private func makeSettings() throws -> SettingsStore {
+        let suite = "KiloSettingsStoreTests-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        return SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+    }
+
+    @Test
+    func `defaults to empty known organizations and empty enabled ids`() throws {
+        let settings = try self.makeSettings()
+        #expect(settings.kiloKnownOrganizations.isEmpty)
+        #expect(settings.kiloEnabledOrganizationIDs.isEmpty)
+    }
+
+    @Test
+    func `setting known organizations persists them`() throws {
+        let settings = try self.makeSettings()
+        let orgs = [
+            KiloOrganization(id: "org_1", name: "Alpha", role: "owner"),
+            KiloOrganization(id: "org_2", name: "Beta", role: "member"),
+        ]
+        settings.kiloKnownOrganizations = orgs
+        #expect(settings.kiloKnownOrganizations == orgs)
+    }
+
+    @Test
+    func `setting enabled org ids persists them`() throws {
+        let settings = try self.makeSettings()
+        settings.kiloEnabledOrganizationIDs = ["org_1", "org_2"]
+        #expect(settings.kiloEnabledOrganizationIDs == ["org_1", "org_2"])
+    }
+
+    @Test
+    func `setKiloKnownOrganizations prunes stale enabled ids`() throws {
+        let settings = try self.makeSettings()
+        settings.kiloKnownOrganizations = [
+            KiloOrganization(id: "org_1", name: "Alpha", role: nil),
+            KiloOrganization(id: "org_2", name: "Beta", role: nil),
+        ]
+        settings.kiloEnabledOrganizationIDs = ["org_1", "org_2"]
+        settings.setKiloKnownOrganizationsPruningEnabled(
+            [KiloOrganization(id: "org_2", name: "Beta", role: nil)])
+        #expect(settings.kiloKnownOrganizations.map(\.id) == ["org_2"])
+        #expect(settings.kiloEnabledOrganizationIDs == ["org_2"])
+    }
+}
diff --git a/Tests/CodexBarTests/KiloUsageFetcherTests.swift b/Tests/CodexBarTests/KiloUsageFetcherTests.swift
index b61f5e0a1a..bd2828c503 100644
--- a/Tests/CodexBarTests/KiloUsageFetcherTests.swift
+++ b/Tests/CodexBarTests/KiloUsageFetcherTests.swift
@@ -2,7 +2,6 @@ import Foundation
 import Testing
 @testable import CodexBarCore
 
-@Suite
 struct KiloUsageFetcherTests {
     private struct StubClaudeFetcher: ClaudeUsageFetching {
         func loadLatestUsage(model _: String) async throws -> ClaudeUsageSnapshot {
@@ -38,7 +37,7 @@ struct KiloUsageFetcherTests {
     }
 
     @Test
-    func batchURLUsesAuthenticatedTRPCBatchFormat() throws {
+    func `batch URL uses authenticated TRPC batch format`() throws {
         let baseURL = try #require(URL(string: "https://kilo.example/trpc"))
         let url = try KiloUsageFetcher._buildBatchURLForTesting(baseURL: baseURL)
 
@@ -65,7 +64,7 @@ struct KiloUsageFetcherTests {
     }
 
     @Test
-    func parseSnapshotMapsBusinessFieldsAndIdentity() throws {
+    func `parse snapshot maps business fields and identity`() throws {
         let json = """
         [
           {
@@ -117,7 +116,7 @@ struct KiloUsageFetcherTests {
     }
 
     @Test
-    func parseSnapshotMapsKiloPassWindowFromSubscriptionState() throws {
+    func `parse snapshot maps kilo pass window from subscription state`() throws {
         let json = """
         [
           {
@@ -174,7 +173,7 @@ struct KiloUsageFetcherTests {
     }
 
     @Test
-    func parseSnapshotMapsKnownTierNamesAndDefaultsToKiloPass() throws {
+    func `parse snapshot maps known tier names and defaults to kilo pass`() throws {
         let proTierJSON = """
         [
           { "result": { "data": { "creditBlocks": [], "totalBalance_mUsd": 0, "autoTopUpEnabled": false } } },
@@ -200,7 +199,7 @@ struct KiloUsageFetcherTests {
     }
 
     @Test
-    func parseSnapshotUsesAutoTopUpAmountWhenEnabledWithoutPaymentMethod() throws {
+    func `parse snapshot uses auto top up amount when enabled without payment method`() throws {
         let json = """
         [
           { "result": { "data": { "creditBlocks": [], "totalBalance_mUsd": 0, "autoTopUpEnabled": true } } },
@@ -214,7 +213,7 @@ struct KiloUsageFetcherTests {
     }
 
     @Test
-    func parseSnapshotFallbackPassFieldsUseMicroDollarScale() throws {
+    func `parse snapshot fallback pass fields use micro dollar scale`() throws {
         let json = """
         [
           {
@@ -264,7 +263,7 @@ struct KiloUsageFetcherTests {
     }
 
     @Test
-    func parseSnapshotTreatsEmptyAndNullBusinessFieldsAsNoDataSuccess() throws {
+    func `parse snapshot treats empty and null business fields as no data success`() throws {
         let json = """
         [
           {
@@ -309,7 +308,7 @@ struct KiloUsageFetcherTests {
     }
 
     @Test
-    func parseSnapshotKeepsSparseIndexedObjectRoutingByProcedureIndex() throws {
+    func `parse snapshot keeps sparse indexed object routing by procedure index`() throws {
         let json = """
         {
           "0": {
@@ -344,7 +343,7 @@ struct KiloUsageFetcherTests {
     }
 
     @Test
-    func parseSnapshotUsesTopLevelCreditsUsedFallback() throws {
+    func `parse snapshot uses top level credits used fallback`() throws {
         let json = """
         [
           {
@@ -368,7 +367,7 @@ struct KiloUsageFetcherTests {
     }
 
     @Test
-    func parseSnapshotKeepsZeroTotalVisibleWhenActivityExists() throws {
+    func `parse snapshot keeps zero total visible when activity exists`() throws {
         let json = """
         [
           {
@@ -413,7 +412,7 @@ struct KiloUsageFetcherTests {
     }
 
     @Test
-    func parseSnapshotTreatsZeroBalanceWithoutCreditBlocksAsVisibleZeroTotal() throws {
+    func `parse snapshot treats zero balance without credit blocks as visible zero total`() throws {
         let json = """
         [
           {
@@ -455,7 +454,7 @@ struct KiloUsageFetcherTests {
     }
 
     @Test
-    func parseSnapshotDegradesOptionalAutoTopUpTRPCError() throws {
+    func `parse snapshot degrades optional auto top up TRPC error`() throws {
         let json = """
         [
           {
@@ -498,7 +497,7 @@ struct KiloUsageFetcherTests {
     }
 
     @Test
-    func parseSnapshotKeepsRequiredProcedureTRPCErrorFatal() {
+    func `parse snapshot keeps required procedure TRPC error fatal`() {
         let json = """
         [
           {
@@ -534,7 +533,7 @@ struct KiloUsageFetcherTests {
     }
 
     @Test
-    func parseSnapshotMapsUnauthorizedTRPCError() {
+    func `parse snapshot maps unauthorized TRPC error`() {
         let json = """
         [
           {
@@ -560,7 +559,7 @@ struct KiloUsageFetcherTests {
     }
 
     @Test
-    func parseSnapshotMapsInvalidJSONToParseError() {
+    func `parse snapshot maps invalid JSON to parse error`() {
         #expect {
             _ = try KiloUsageFetcher._parseSnapshotForTesting(Data("not-json".utf8))
         } throws: { error in
@@ -571,7 +570,7 @@ struct KiloUsageFetcherTests {
     }
 
     @Test
-    func statusErrorMappingCoversAuthAndServerFailures() {
+    func `status error mapping covers auth and server failures`() {
         #expect(KiloUsageFetcher._statusErrorForTesting(401) == .unauthorized)
         #expect(KiloUsageFetcher._statusErrorForTesting(403) == .unauthorized)
         #expect(KiloUsageFetcher._statusErrorForTesting(404) == .endpointNotFound)
@@ -588,14 +587,14 @@ struct KiloUsageFetcherTests {
     }
 
     @Test
-    func fetchUsageWithoutCredentialsFailsFast() async {
+    func `fetch usage without credentials fails fast`() async {
         await #expect(throws: KiloUsageError.missingCredentials) {
             _ = try await KiloUsageFetcher.fetchUsage(apiKey: "  ", environment: [:])
         }
     }
 
     @Test
-    func descriptorFetchOutcomeWithoutCredentialsReturnsActionableError() async {
+    func `descriptor fetch outcome without credentials returns actionable error`() async {
         let descriptor = ProviderDescriptorRegistry.descriptor(for: .kilo)
         let outcome = await descriptor.fetchOutcome(context: self.makeContext())
 
@@ -612,7 +611,7 @@ struct KiloUsageFetcherTests {
     }
 
     @Test
-    func descriptorAPIModeIgnoresCLISessionFallback() async throws {
+    func `descriptor API mode ignores CLI session fallback`() async throws {
         let homeDirectory = try self.makeTemporaryHomeDirectory()
         defer { try? FileManager.default.removeItem(at: homeDirectory) }
         try self.writeKiloAuthFile(
@@ -636,7 +635,7 @@ struct KiloUsageFetcherTests {
     }
 
     @Test
-    func descriptorCLIModeMissingSessionReturnsActionableError() async throws {
+    func `descriptor CLI mode missing session returns actionable error`() async throws {
         let homeDirectory = try self.makeTemporaryHomeDirectory()
         defer { try? FileManager.default.removeItem(at: homeDirectory) }
         let expectedPath = KiloSettingsReader.defaultAuthFileURL(homeDirectory: homeDirectory).path
@@ -658,7 +657,7 @@ struct KiloUsageFetcherTests {
     }
 
     @Test
-    func descriptorAutoModeFallsBackFromAPIToCLI() async throws {
+    func `descriptor auto mode falls back from API to CLI`() async throws {
         let homeDirectory = try self.makeTemporaryHomeDirectory()
         defer { try? FileManager.default.removeItem(at: homeDirectory) }
         let expectedPath = KiloSettingsReader.defaultAuthFileURL(homeDirectory: homeDirectory).path
@@ -680,7 +679,7 @@ struct KiloUsageFetcherTests {
     }
 
     @Test
-    func apiStrategyFallsBackOnUnauthorizedOnlyInAutoMode() {
+    func `api strategy falls back on unauthorized only in auto mode`() {
         let strategy = KiloAPIFetchStrategy()
         #expect(strategy.shouldFallback(
             on: KiloUsageError.unauthorized,
@@ -691,7 +690,7 @@ struct KiloUsageFetcherTests {
     }
 
     @Test
-    func apiStrategyFallsBackOnMissingCredentialsOnlyInAutoMode() {
+    func `api strategy falls back on missing credentials only in auto mode`() {
         let strategy = KiloAPIFetchStrategy()
         #expect(strategy.shouldFallback(
             on: KiloUsageError.missingCredentials,
@@ -701,6 +700,78 @@ struct KiloUsageFetcherTests {
             context: self.makeContext(sourceMode: .api)))
     }
 
+    @Test
+    func `request builder adds org header for organization scope`() throws {
+        let baseURL = try #require(URL(string: "https://kilo.example/trpc"))
+        let request = try KiloUsageFetcher._buildRequestForTesting(
+            baseURL: baseURL,
+            apiKey: "test-token",
+            scope: .organization(id: "org_42", name: "Acme"))
+        #expect(request.value(forHTTPHeaderField: "X-KILOCODE-ORGANIZATIONID") == "org_42")
+        #expect(request.value(forHTTPHeaderField: "Authorization") == "Bearer test-token")
+    }
+
+    @Test
+    func `request builder omits org header for personal scope`() throws {
+        let baseURL = try #require(URL(string: "https://kilo.example/trpc"))
+        let request = try KiloUsageFetcher._buildRequestForTesting(
+            baseURL: baseURL,
+            apiKey: "test-token",
+            scope: .personal)
+        #expect(request.value(forHTTPHeaderField: "X-KILOCODE-ORGANIZATIONID") == nil)
+        #expect(request.value(forHTTPHeaderField: "Authorization") == "Bearer test-token")
+    }
+
+    @Test
+    func `parseOrganizations decodes tRPC array shape`() throws {
+        let json = #"""
+        [
+          {
+            "result": {
+              "data": {
+                "json": [
+                  { "id": "org_1", "name": "Alpha", "role": "owner" },
+                  { "id": "org_2", "name": "Beta", "role": "member" }
+                ]
+              }
+            }
+          }
+        ]
+        """#
+        let orgs = try KiloUsageFetcher._parseOrganizationsForTesting(Data(json.utf8))
+        #expect(orgs.count == 2)
+        #expect(orgs[0].id == "org_1")
+        #expect(orgs[0].name == "Alpha")
+        #expect(orgs[0].role == "owner")
+        #expect(orgs[1].id == "org_2")
+        #expect(orgs[1].role == "member")
+    }
+
+    @Test
+    func `parseOrganizations decodes profile REST shape`() throws {
+        let json = #"""
+        {
+          "user": { "email": "test@example.com" },
+          "organizations": [
+            { "id": "org_42", "name": "Gamma" }
+          ]
+        }
+        """#
+        let orgs = try KiloUsageFetcher._parseOrganizationsForTesting(Data(json.utf8))
+        #expect(orgs.count == 1)
+        #expect(orgs[0].id == "org_42")
+        #expect(orgs[0].role == nil)
+    }
+
+    @Test
+    func `parseOrganizations returns empty for no orgs`() throws {
+        let json = #"""
+        { "user": { "email": "x@y" }, "organizations": [] }
+        """#
+        let orgs = try KiloUsageFetcher._parseOrganizationsForTesting(Data(json.utf8))
+        #expect(orgs.isEmpty)
+    }
+
     private func makeTemporaryHomeDirectory() throws -> URL {
         let directory = FileManager.default.temporaryDirectory
             .appendingPathComponent(UUID().uuidString, isDirectory: true)
diff --git a/Tests/CodexBarTests/KimiK2SettingsReaderTests.swift b/Tests/CodexBarTests/KimiK2SettingsReaderTests.swift
index d291a921f7..32d311704a 100644
--- a/Tests/CodexBarTests/KimiK2SettingsReaderTests.swift
+++ b/Tests/CodexBarTests/KimiK2SettingsReaderTests.swift
@@ -1,25 +1,23 @@
 import CodexBarCore
 import Testing
 
-@Suite
 struct KimiK2SettingsReaderTests {
     @Test
-    func apiKeyIsTrimmed() {
+    func `api key is trimmed`() {
         let env = ["KIMI_API_KEY": "  key-123  "]
         #expect(KimiK2SettingsReader.apiKey(environment: env) == "key-123")
     }
 
     @Test
-    func apiKeyStripsQuotes() {
+    func `api key strips quotes`() {
         let env = ["KIMI_KEY": "\"quoted-456\""]
         #expect(KimiK2SettingsReader.apiKey(environment: env) == "quoted-456")
     }
 }
 
-@Suite
 struct KimiK2ProviderTokenResolverTests {
     @Test
-    func resolvesFromEnvironment() {
+    func `resolves from environment`() {
         let env = ["KIMI_API_KEY": "env-token"]
         let resolution = ProviderTokenResolver.kimiK2Resolution(environment: env)
         #expect(resolution?.token == "env-token")
diff --git a/Tests/CodexBarTests/KimiK2UsageFetcherTests.swift b/Tests/CodexBarTests/KimiK2UsageFetcherTests.swift
index 0fdb74f42c..9b549bfbf7 100644
--- a/Tests/CodexBarTests/KimiK2UsageFetcherTests.swift
+++ b/Tests/CodexBarTests/KimiK2UsageFetcherTests.swift
@@ -2,10 +2,9 @@ import Foundation
 import Testing
 @testable import CodexBarCore
 
-@Suite
 struct KimiK2UsageFetcherTests {
     @Test
-    func parsesUsageFromNestedUsage() throws {
+    func `parses usage from nested usage`() throws {
         let json = """
         {
           "data": {
@@ -29,7 +28,7 @@ struct KimiK2UsageFetcherTests {
     }
 
     @Test
-    func usesHeaderFallbackForRemainingCredits() throws {
+    func `uses header fallback for remaining credits`() throws {
         let json = """
         { "total_credits_consumed": 50 }
         """
@@ -42,7 +41,7 @@ struct KimiK2UsageFetcherTests {
     }
 
     @Test
-    func parsesNumericTimestampSeconds() throws {
+    func `parses numeric timestamp seconds`() throws {
         let json = """
         {
           "timestamp": 1700000000,
@@ -58,7 +57,7 @@ struct KimiK2UsageFetcherTests {
     }
 
     @Test
-    func parsesNumericTimestampMilliseconds() throws {
+    func `parses numeric timestamp milliseconds`() throws {
         let json = """
         {
           "timestamp": 1700000000000,
@@ -74,7 +73,7 @@ struct KimiK2UsageFetcherTests {
     }
 
     @Test
-    func invalidRootReturnsParseError() {
+    func `invalid root returns parse error`() {
         let json = """
         [{ "total": 1 }]
         """
@@ -86,4 +85,17 @@ struct KimiK2UsageFetcherTests {
             return message == "Root JSON is not an object."
         }
     }
+
+    @Test
+    func `converts api key credits into text only snapshot`() {
+        let usage = KimiK2UsageSummary(
+            consumed: 10,
+            remaining: 25,
+            averageTokens: nil,
+            updatedAt: Date()).toUsageSnapshot()
+
+        #expect(usage.primary == nil)
+        #expect(usage.identity?.providerID == .kimik2)
+        #expect(usage.identity?.loginMethod == "Credits: 25 left")
+    }
 }
diff --git a/Tests/CodexBarTests/KimiProviderTests.swift b/Tests/CodexBarTests/KimiProviderTests.swift
index c8e375a434..2d2bd20014 100644
--- a/Tests/CodexBarTests/KimiProviderTests.swift
+++ b/Tests/CodexBarTests/KimiProviderTests.swift
@@ -2,48 +2,203 @@ import Foundation
 import Testing
 @testable import CodexBarCore
 
-@Suite
+private struct KimiStubClaudeFetcher: ClaudeUsageFetching {
+    func loadLatestUsage(model _: String) async throws -> ClaudeUsageSnapshot {
+        throw ClaudeUsageError.parseFailed("stub")
+    }
+
+    func debugRawProbe(model _: String) async -> String {
+        "stub"
+    }
+
+    func detectVersion() -> String? {
+        nil
+    }
+}
+
+private func makeKimiFetchContext(sourceMode: ProviderSourceMode) -> ProviderFetchContext {
+    let env: [String: String] = [:]
+    return ProviderFetchContext(
+        runtime: .app,
+        sourceMode: sourceMode,
+        includeCredits: false,
+        webTimeout: 1,
+        webDebugDumpHTML: false,
+        verbose: false,
+        env: env,
+        settings: nil,
+        fetcher: UsageFetcher(environment: env),
+        claudeFetcher: KimiStubClaudeFetcher(),
+        browserDetection: BrowserDetection(cacheTTL: 0))
+}
+
 struct KimiSettingsReaderTests {
     @Test
-    func readsTokenFromEnvironmentVariable() {
+    func `reads token from environment variable`() {
         let env = ["KIMI_AUTH_TOKEN": "test.jwt.token"]
         let token = KimiSettingsReader.authToken(environment: env)
         #expect(token == "test.jwt.token")
     }
 
     @Test
-    func normalizesQuotedToken() {
+    func `reads API key from preferred environment variable`() {
+        let env = ["KIMI_CODE_API_KEY": "kimi-code-token"]
+        let token = KimiSettingsReader.apiKey(environment: env)
+        #expect(token == "kimi-code-token")
+    }
+
+    @Test
+    func `does not consume generic Kimi K2 API key environment variable`() {
+        let env = ["KIMI_API_KEY": "'kimi-api-token'"]
+        let token = KimiSettingsReader.apiKey(environment: env)
+        #expect(token == nil)
+    }
+
+    @Test
+    func `uses code specific API key when generic Kimi K2 key also exists`() {
+        let env = [
+            "KIMI_API_KEY": "generic-kimi-token",
+            "KIMI_CODE_API_KEY": "kimi-code-token",
+        ]
+        let token = KimiSettingsReader.apiKey(environment: env)
+        #expect(token == "kimi-code-token")
+    }
+
+    @Test
+    func `uses default code API base URL when override is absent`() throws {
+        let url = try KimiSettingsReader.codeAPIBaseURL(environment: [:])
+        #expect(url == KimiSettingsReader.defaultCodeAPIBaseURL)
+    }
+
+    @Test
+    func `uses custom code API base URL when valid`() throws {
+        let env = ["KIMI_CODE_BASE_URL": "https://proxy.example.com/kimi"]
+        let url = try KimiSettingsReader.codeAPIBaseURL(environment: env)
+        #expect(url.absoluteString == "https://proxy.example.com/kimi")
+    }
+
+    @Test
+    func `rejects invalid code API base URL`() {
+        let env = ["KIMI_CODE_BASE_URL": "not a url"]
+
+        #expect(throws: KimiAPIError.invalidRequest(
+            "Kimi Code API base URL must use HTTPS without user info"))
+        {
+            try KimiSettingsReader.codeAPIBaseURL(environment: env)
+        }
+    }
+
+    @Test
+    func `rejects insecure code API base URL`() {
+        let env = ["KIMI_CODE_BASE_URL": "http://proxy.example.com/kimi"]
+
+        #expect(throws: KimiAPIError.invalidRequest(
+            "Kimi Code API base URL must use HTTPS without user info"))
+        {
+            try KimiSettingsReader.codeAPIBaseURL(environment: env)
+        }
+    }
+
+    @Test
+    func `rejects code API base URL containing user info`() {
+        let env = ["KIMI_CODE_BASE_URL": "https://api.kimi.com@proxy.example.com/kimi"]
+
+        #expect(throws: KimiAPIError.invalidRequest(
+            "Kimi Code API base URL must use HTTPS without user info"))
+        {
+            try KimiSettingsReader.codeAPIBaseURL(environment: env)
+        }
+    }
+
+    @Test
+    func `normalizes quoted token`() {
         let env = ["KIMI_AUTH_TOKEN": "\"test.jwt.token\""]
         let token = KimiSettingsReader.authToken(environment: env)
         #expect(token == "test.jwt.token")
     }
 
     @Test
-    func returnsNilWhenMissing() {
+    func `returns nil when missing`() {
         let env: [String: String] = [:]
         let token = KimiSettingsReader.authToken(environment: env)
         #expect(token == nil)
     }
 
     @Test
-    func returnsNilWhenEmpty() {
+    func `returns nil when empty`() {
         let env = ["KIMI_AUTH_TOKEN": ""]
         let token = KimiSettingsReader.authToken(environment: env)
         #expect(token == nil)
     }
 
     @Test
-    func normalizesLowercaseEnvironmentKey() {
+    func `normalizes lowercase environment key`() {
         let env = ["kimi_auth_token": "test.jwt.token"]
         let token = KimiSettingsReader.authToken(environment: env)
         #expect(token == "test.jwt.token")
     }
 }
 
-@Suite
+struct KimiAPIFetchStrategyTests {
+    @Test
+    func `auto mode falls back from invalid API key to web cookies`() {
+        let strategy = KimiAPIFetchStrategy()
+        let context = makeKimiFetchContext(sourceMode: .auto)
+
+        #expect(strategy.shouldFallback(on: KimiAPIError.invalidAPIKey, context: context))
+    }
+
+    @Test
+    func `explicit API mode does not fall back from invalid API key`() {
+        let strategy = KimiAPIFetchStrategy()
+        let context = makeKimiFetchContext(sourceMode: .api)
+
+        #expect(strategy.shouldFallback(on: KimiAPIError.invalidAPIKey, context: context) == false)
+    }
+
+    @Test
+    func `explicit API mode reports API key remediation when key is missing`() async {
+        let strategy = KimiAPIFetchStrategy()
+        let context = makeKimiFetchContext(sourceMode: .api)
+
+        await #expect(throws: KimiAPIError.missingAPIKey) {
+            try await strategy.fetch(context)
+        }
+    }
+
+    @Test
+    func `auto mode falls back from API response decoding failure`() {
+        let strategy = KimiAPIFetchStrategy()
+        let context = makeKimiFetchContext(sourceMode: .auto)
+        let error = DecodingError.dataCorrupted(
+            DecodingError.Context(codingPath: [], debugDescription: "Unexpected Kimi payload"))
+
+        #expect(strategy.shouldFallback(on: error, context: context))
+    }
+
+    @Test
+    func `explicit API mode surfaces response decoding failure`() {
+        let strategy = KimiAPIFetchStrategy()
+        let context = makeKimiFetchContext(sourceMode: .api)
+        let error = DecodingError.dataCorrupted(
+            DecodingError.Context(codingPath: [], debugDescription: "Unexpected Kimi payload"))
+
+        #expect(strategy.shouldFallback(on: error, context: context) == false)
+    }
+
+    @Test
+    func `auto mode does not start web fallback after cancellation`() {
+        let strategy = KimiAPIFetchStrategy()
+        let context = makeKimiFetchContext(sourceMode: .auto)
+
+        #expect(strategy.shouldFallback(on: CancellationError(), context: context) == false)
+        #expect(strategy.shouldFallback(on: URLError(.cancelled), context: context) == false)
+    }
+}
+
 struct KimiUsageResponseParsingTests {
     @Test
-    func parsesValidResponse() throws {
+    func `parses valid response`() throws {
         let json = """
         {
           "usages": [
@@ -92,7 +247,7 @@ struct KimiUsageResponseParsingTests {
     }
 
     @Test
-    func parsesResponseWithoutRateLimits() throws {
+    func `parses response without rate limits`() throws {
         let json = """
         {
           "usages": [
@@ -115,7 +270,7 @@ struct KimiUsageResponseParsingTests {
     }
 
     @Test
-    func parsesResponseWithNullLimits() throws {
+    func `parses response with null limits`() throws {
         let json = """
         {
           "usages": [
@@ -138,7 +293,138 @@ struct KimiUsageResponseParsingTests {
     }
 
     @Test
-    func throwsOnInvalidJson() {
+    func `parses code API usage response`() throws {
+        let json = """
+        {
+          "usage": {
+            "limit": "2048",
+            "used": "375",
+            "remaining": "1673",
+            "resetTime": "2026-01-09T15:23:13.373329235Z"
+          },
+          "limits": [
+            {
+              "window": {
+                "duration": 300,
+                "timeUnit": "TIME_UNIT_MINUTE"
+              },
+              "detail": {
+                "limit": "200",
+                "used": "19",
+                "remaining": "181",
+                "resetTime": "2026-01-06T15:05:24.374187075Z"
+              }
+            }
+          ]
+        }
+        """
+
+        let snapshot = try KimiUsageFetcher._parseCodeAPIUsageForTesting(Data(json.utf8))
+        #expect(snapshot.weekly.limit == "2048")
+        #expect(snapshot.weekly.used == "375")
+        #expect(snapshot.rateLimit?.limit == "200")
+        #expect(snapshot.rateLimit?.used == "19")
+    }
+
+    @Test
+    func `parses official numeric values and reset key variants`() throws {
+        let json = """
+        {
+          "usage": {
+            "limit": 1000,
+            "used": 40,
+            "remaining": 960,
+            "resetAt": "2026-01-09T15:23:13Z"
+          },
+          "limits": [
+            {
+              "window": {
+                "duration": 300,
+                "timeUnit": "TIME_UNIT_MINUTE"
+              },
+              "detail": {
+                "limit": 100,
+                "remaining": 99,
+                "reset_at": "2026-01-06T13:33:02Z"
+              }
+            }
+          ]
+        }
+        """
+
+        let snapshot = try KimiUsageFetcher._parseCodeAPIUsageForTesting(Data(json.utf8))
+
+        #expect(snapshot.weekly.limit == "1000")
+        #expect(snapshot.weekly.used == "40")
+        #expect(snapshot.weekly.remaining == "960")
+        #expect(snapshot.weekly.resetTime == "2026-01-09T15:23:13Z")
+        #expect(snapshot.rateLimit?.limit == "100")
+        #expect(snapshot.rateLimit?.used == nil)
+        #expect(snapshot.rateLimit?.remaining == "99")
+        #expect(snapshot.rateLimit?.resetTime == "2026-01-06T13:33:02Z")
+    }
+
+    @Test
+    func `builds default code API usage endpoint`() throws {
+        let baseURL = try #require(URL(string: "https://api.kimi.com"))
+        let endpoint = KimiUsageFetcher._codeAPIUsageEndpointForTesting(baseURL: baseURL)
+
+        #expect(endpoint.absoluteString == "https://api.kimi.com/coding/v1/usages")
+    }
+
+    @Test
+    func `appends code API path to custom proxy root`() throws {
+        let baseURL = try #require(URL(string: "https://proxy.example.com/kimi"))
+        let endpoint = KimiUsageFetcher._codeAPIUsageEndpointForTesting(baseURL: baseURL)
+
+        #expect(endpoint.absoluteString == "https://proxy.example.com/kimi/coding/v1/usages")
+    }
+
+    @Test
+    func `does not duplicate code API path when base URL already includes it`() throws {
+        let baseURL = try #require(URL(string: "https://api.kimi.com/coding/v1"))
+        let endpoint = KimiUsageFetcher._codeAPIUsageEndpointForTesting(baseURL: baseURL)
+
+        #expect(endpoint.absoluteString == "https://api.kimi.com/coding/v1/usages")
+    }
+
+    @Test
+    func `does not duplicate code API path with trailing slash`() throws {
+        let baseURL = try #require(URL(string: "https://proxy.example.com/kimi/coding/v1/"))
+        let endpoint = KimiUsageFetcher._codeAPIUsageEndpointForTesting(baseURL: baseURL)
+
+        #expect(endpoint.absoluteString == "https://proxy.example.com/kimi/coding/v1/usages")
+    }
+
+    @Test
+    func `does not duplicate coding path prefix`() throws {
+        let baseURL = try #require(URL(string: "https://proxy.example.com/kimi/coding/"))
+        let endpoint = KimiUsageFetcher._codeAPIUsageEndpointForTesting(baseURL: baseURL)
+
+        #expect(endpoint.absoluteString == "https://proxy.example.com/kimi/coding/v1/usages")
+    }
+
+    @Test
+    func `rejects insecure code API base URL before sending bearer token`() async throws {
+        let baseURL = try #require(URL(string: "http://proxy.example.com/kimi"))
+
+        await #expect(throws: KimiAPIError.invalidRequest(
+            "Kimi Code API base URL must use HTTPS without user info"))
+        {
+            _ = try await KimiUsageFetcher.fetchCodeAPIUsage(apiKey: "secret-token", baseURL: baseURL)
+        }
+    }
+
+    @Test
+    func `maps code API authentication and permission errors separately`() {
+        #expect(KimiUsageFetcher._codeAPIErrorForTesting(statusCode: 401) == .invalidAPIKey)
+        #expect(
+            KimiUsageFetcher._codeAPIErrorForTesting(statusCode: 403)
+                == .apiError("HTTP 403 (permission or quota denied)"))
+    }
+
+    @Test
+    func `throws on invalid json`() {
         let invalidJson = "{ invalid json }"
 
         #expect(throws: DecodingError.self) {
@@ -147,7 +433,7 @@ struct KimiUsageResponseParsingTests {
     }
 
     @Test
-    func throwsOnMissingFeatureCodingScope() throws {
+    func `throws on missing feature coding scope`() throws {
         let json = """
         {
           "usages": [
@@ -170,10 +456,9 @@ struct KimiUsageResponseParsingTests {
     }
 }
 
-@Suite
 struct KimiUsageSnapshotConversionTests {
     @Test
-    func convertsToUsageSnapshotWithBothWindows() {
+    func `converts to usage snapshot with both windows`() {
         let now = Date()
         let weeklyDetail = KimiUsageDetail(
             limit: "2048",
@@ -210,7 +495,7 @@ struct KimiUsageSnapshotConversionTests {
     }
 
     @Test
-    func convertsToUsageSnapshotWithoutRateLimit() {
+    func `converts to usage snapshot without rate limit`() {
         let now = Date()
         let weeklyDetail = KimiUsageDetail(
             limit: "2048",
@@ -233,7 +518,7 @@ struct KimiUsageSnapshotConversionTests {
     }
 
     @Test
-    func handlesZeroValuesCorrectly() {
+    func `handles zero values correctly`() {
         let now = Date()
         let weeklyDetail = KimiUsageDetail(
             limit: "2048",
@@ -251,7 +536,7 @@ struct KimiUsageSnapshotConversionTests {
     }
 
     @Test
-    func handlesHundredPercentCorrectly() {
+    func `handles hundred percent correctly`() {
         let now = Date()
         let weeklyDetail = KimiUsageDetail(
             limit: "2048",
@@ -269,10 +554,9 @@ struct KimiUsageSnapshotConversionTests {
     }
 }
 
-@Suite
 struct KimiTokenResolverTests {
     @Test
-    func resolvesTokenFromEnvironment() {
+    func `resolves token from environment`() {
         KeychainAccessGate.withTaskOverrideForTesting(true) {
             let env = ["KIMI_AUTH_TOKEN": "test.jwt.token"]
             let token = ProviderTokenResolver.kimiAuthToken(environment: env)
@@ -281,7 +565,7 @@ struct KimiTokenResolverTests {
     }
 
     @Test
-    func resolvesTokenFromKeychainFirst() {
+    func `resolves token from keychain first`() {
         // This test would require mocking the keychain.
         KeychainAccessGate.withTaskOverrideForTesting(true) {
             let env = ["KIMI_AUTH_TOKEN": "test.env.token"]
@@ -291,7 +575,7 @@ struct KimiTokenResolverTests {
     }
 
     @Test
-    func resolutionIncludesSource() {
+    func `resolution includes source`() {
         KeychainAccessGate.withTaskOverrideForTesting(true) {
             let env = ["KIMI_AUTH_TOKEN": "test.jwt.token"]
             let resolution = ProviderTokenResolver.kimiAuthResolution(environment: env)
@@ -302,12 +586,14 @@ struct KimiTokenResolverTests {
     }
 }
 
-@Suite
 struct KimiAPIErrorTests {
     @Test
-    func errorDescriptionsAreHelpful() {
+    func `error descriptions are helpful`() {
         #expect(KimiAPIError.missingToken.errorDescription?.contains("missing") == true)
         #expect(KimiAPIError.invalidToken.errorDescription?.contains("invalid") == true)
+        #expect(KimiAPIError.missingAPIKey.errorDescription?.contains("Settings > Providers > Kimi") == true)
+        #expect(KimiAPIError.missingAPIKey.errorDescription?.contains("KIMI_CODE_API_KEY") == true)
+        #expect(KimiAPIError.invalidAPIKey.errorDescription?.contains("API key") == true)
         #expect(KimiAPIError.invalidRequest("Bad request").errorDescription?.contains("Bad request") == true)
         #expect(KimiAPIError.networkError("Timeout").errorDescription?.contains("Timeout") == true)
         #expect(KimiAPIError.apiError("HTTP 500").errorDescription?.contains("HTTP 500") == true)
diff --git a/Tests/CodexBarTests/KiroMenuCardModelTests.swift b/Tests/CodexBarTests/KiroMenuCardModelTests.swift
new file mode 100644
index 0000000000..af7a2885ab
--- /dev/null
+++ b/Tests/CodexBarTests/KiroMenuCardModelTests.swift
@@ -0,0 +1,108 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct KiroMenuCardModelTests {
+    @Test
+    func `kiro model shows account plan credits bonus and overages`() throws {
+        let now = Date()
+        let snapshot = KiroUsageSnapshot(
+            planName: "KIRO FREE",
+            accountEmail: "person@example.com",
+            authMethod: "Google",
+            creditsUsed: 0.17,
+            creditsTotal: 50,
+            creditsPercent: 0,
+            bonusCreditsUsed: 45.53,
+            bonusCreditsTotal: 2000,
+            bonusExpiryDays: 19,
+            overagesStatus: "Enabled billed at $0.04 per request",
+            overageCreditsUsed: 40.29,
+            estimatedOverageCostUSD: 1.61,
+            manageURL: "https://app.kiro.dev/account/usage",
+            contextUsage: KiroContextUsageSnapshot(
+                totalPercentUsed: 1.3,
+                contextFilesPercent: 0.5,
+                toolsPercent: 0.8,
+                kiroResponsesPercent: 0,
+                promptsPercent: 0),
+            resetsAt: now.addingTimeInterval(3600),
+            updatedAt: now).toUsageSnapshot()
+        let metadata = try #require(ProviderDefaults.metadata[.kiro])
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .kiro,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.email == "person@example.com")
+        #expect(model.planText == "Kiro Free")
+        #expect(model.metrics.map(\.title) == ["Credits", "Bonus"])
+        #expect(model.metrics.first?.detailLeftText == "49.83 of 50 credits left")
+        #expect(model.metrics.dropFirst().first?.detailLeftText == "1954.47 of 2000 bonus credits left")
+        #expect(model.usageNotes.contains("Auth: Google"))
+        #expect(model.usageNotes.contains("Overages: Enabled billed at $0.04 per request"))
+        #expect(model.usageNotes.contains("Overage usage: 40.29 credits"))
+        #expect(model.usageNotes.contains("Overage cost: $1.61"))
+        #expect(model.usageNotes.contains { $0.localizedCaseInsensitiveContains("Context window") } == false)
+    }
+
+    @Test
+    func `kiro model hides overage spend when overages are disabled`() throws {
+        let now = Date()
+        let snapshot = KiroUsageSnapshot(
+            planName: "KIRO FREE",
+            creditsUsed: 0.17,
+            creditsTotal: 50,
+            creditsPercent: 0,
+            bonusCreditsUsed: nil,
+            bonusCreditsTotal: nil,
+            bonusExpiryDays: nil,
+            overagesStatus: "Disabled",
+            overageCreditsUsed: 40.29,
+            estimatedOverageCostUSD: 1.61,
+            resetsAt: nil,
+            updatedAt: now).toUsageSnapshot()
+        let metadata = try #require(ProviderDefaults.metadata[.kiro])
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .kiro,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.usageNotes.contains("Overages: Disabled"))
+        #expect(model.usageNotes.contains("Overage usage: 40.29 credits") == false)
+        #expect(model.usageNotes.contains("Overage cost: $1.61") == false)
+    }
+}
diff --git a/Tests/CodexBarTests/KiroStatusProbeTests.swift b/Tests/CodexBarTests/KiroStatusProbeTests.swift
index e1b35be148..240bb2495c 100644
--- a/Tests/CodexBarTests/KiroStatusProbeTests.swift
+++ b/Tests/CodexBarTests/KiroStatusProbeTests.swift
@@ -1,13 +1,511 @@
 import Foundation
 import Testing
 @testable import CodexBarCore
+#if canImport(Darwin)
+import Darwin
+#else
+import Glibc
+#endif
+
+private func waitForFile(_ url: URL) async throws {
+    for _ in 0..<100 where !FileManager.default.fileExists(atPath: url.path) {
+        try await Task.sleep(for: .milliseconds(20))
+    }
+    #expect(FileManager.default.fileExists(atPath: url.path))
+}
 
-@Suite
+@Suite(.serialized)
 struct KiroStatusProbeTests {
+    @Test
+    func `fetch returns usage when account probe times out`() async throws {
+        let cliURL = try self.makeCLI(
+            """
+            #!/bin/sh
+            if [ "$1" = "whoami" ]; then
+              sleep 5
+              printf 'Logged in with Google\\nEmail: person@example.com\\n'
+              exit 0
+            fi
+
+            if [ "$1" = "chat" ] && [ "$3" = "/usage" ]; then
+              printf 'Estimated Usage | resets on 2026-06-01 | KIRO FREE\\n'
+              printf 'Credits (12.50 of 50 covered in plan)\\n'
+              printf '████████████████████ 25%%\\n'
+              exit 0
+            fi
+
+            if [ "$1" = "chat" ] && [ "$3" = "/context" ]; then
+              exit 0
+            fi
+
+            exit 1
+            """)
+        defer { try? FileManager.default.removeItem(at: cliURL.deletingLastPathComponent()) }
+
+        let probe = KiroStatusProbe(cliBinaryResolver: { cliURL.path }, accountProbeTimeout: 0.2)
+        let snapshot = try await probe.fetch()
+
+        #expect(snapshot.planName == "KIRO FREE")
+        #expect(snapshot.creditsUsed == 12.50)
+        #expect(snapshot.accountEmail == nil)
+        #expect(snapshot.authMethod == nil)
+    }
+
+    @Test
+    func `fetch preserves account info when account probe succeeds`() async throws {
+        let cliURL = try self.makeCLI(
+            """
+            #!/bin/sh
+            if [ "$1" = "whoami" ]; then
+              printf 'Logged in with Google\\nEmail: person@example.com\\n'
+              exit 0
+            fi
+
+            if [ "$1" = "chat" ] && [ "$3" = "/usage" ]; then
+              printf 'Estimated Usage | resets on 2026-06-01 | KIRO FREE\\n'
+              printf 'Credits (12.50 of 50 covered in plan)\\n'
+              printf '████████████████████ 25%%\\n'
+              exit 0
+            fi
+
+            if [ "$1" = "chat" ] && [ "$3" = "/context" ]; then
+              exit 0
+            fi
+
+            exit 1
+            """)
+        defer { try? FileManager.default.removeItem(at: cliURL.deletingLastPathComponent()) }
+
+        let probe = KiroStatusProbe(cliBinaryResolver: { cliURL.path })
+        let snapshot = try await probe.fetch()
+
+        #expect(snapshot.accountEmail == "person@example.com")
+        #expect(snapshot.authMethod == "Google")
+    }
+
+    @Test
+    func `fetch preserves not logged in when usage fails without auth detail`() async throws {
+        let cliURL = try self.makeCLI(
+            """
+            #!/bin/sh
+            if [ "$1" = "whoami" ]; then
+              printf 'Not logged in\\n'
+              exit 1
+            fi
+
+            if [ "$1" = "chat" ] && [ "$3" = "/usage" ]; then
+              exit 1
+            fi
+
+            if [ "$1" = "chat" ] && [ "$3" = "/context" ]; then
+              exit 0
+            fi
+
+            exit 1
+            """)
+        defer { try? FileManager.default.removeItem(at: cliURL.deletingLastPathComponent()) }
+
+        let probe = KiroStatusProbe(cliBinaryResolver: { cliURL.path })
+        await #expect {
+            _ = try await probe.fetch()
+        } throws: { error in
+            guard case KiroStatusProbeError.notLoggedIn = error else { return false }
+            return true
+        }
+    }
+
+    @Test
+    func `fetch preserves not logged in when usage output cannot be parsed`() async throws {
+        let cliURL = try self.makeCLI(
+            """
+            #!/bin/sh
+            if [ "$1" = "whoami" ]; then
+              printf 'Not logged in\\n'
+              exit 1
+            fi
+
+            if [ "$1" = "chat" ] && [ "$3" = "/usage" ]; then
+              exit 0
+            fi
+
+            if [ "$1" = "chat" ] && [ "$3" = "/context" ]; then
+              exit 0
+            fi
+
+            exit 1
+            """)
+        defer { try? FileManager.default.removeItem(at: cliURL.deletingLastPathComponent()) }
+
+        let probe = KiroStatusProbe(cliBinaryResolver: { cliURL.path })
+        await #expect {
+            _ = try await probe.fetch()
+        } throws: { error in
+            guard case KiroStatusProbeError.notLoggedIn = error else { return false }
+            return true
+        }
+    }
+
+    @Test
+    func `fetch cancellation during context probe is preserved`() async throws {
+        let contextStarted = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-kiro-context-\(UUID().uuidString).started")
+        let cliURL = try self.makeCLI(
+            """
+            #!/bin/sh
+            if [ "$1" = "whoami" ]; then
+              printf 'Logged in with Google\nEmail: person@example.com\n'
+              exit 0
+            fi
+
+            if [ "$1" = "chat" ] && [ "$3" = "/usage" ]; then
+              printf 'Estimated Usage | resets on 2026-06-01 | KIRO FREE\n'
+              printf 'Credits (12.50 of 50 covered in plan)\n'
+              printf '████████████████████ 25%%\n'
+              exit 0
+            fi
+
+            if [ "$1" = "chat" ] && [ "$3" = "/context" ]; then
+              : > '\(contextStarted.path)'
+              trap '' TERM
+              while true; do sleep 1; done
+            fi
+
+            exit 1
+            """)
+        defer {
+            try? FileManager.default.removeItem(at: cliURL.deletingLastPathComponent())
+            try? FileManager.default.removeItem(at: contextStarted)
+        }
+
+        let probe = KiroStatusProbe(cliBinaryResolver: { cliURL.path })
+        let task = Task { try await probe.fetch() }
+        defer { task.cancel() }
+
+        try await waitForFile(contextStarted)
+
+        task.cancel()
+        await #expect(throws: CancellationError.self) {
+            try await task.value
+        }
+    }
+
+    @Test
+    func `fetch cancellation while waiting for account probe is preserved`() async throws {
+        let accountStarted = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-kiro-account-\(UUID().uuidString).started")
+        let cliURL = try self.makeCLI(
+            """
+            #!/bin/sh
+            if [ "$1" = "whoami" ]; then
+              : > '\(accountStarted.path)'
+              trap '' TERM
+              while true; do sleep 1; done
+            fi
+
+            if [ "$1" = "chat" ] && [ "$3" = "/usage" ]; then
+              printf 'Estimated Usage | resets on 2026-06-01 | KIRO FREE\\n'
+              printf 'Credits (12.50 of 50 covered in plan)\\n'
+              printf '████████████████████ 25%%\\n'
+              exit 0
+            fi
+
+            if [ "$1" = "chat" ] && [ "$3" = "/context" ]; then
+              exit 0
+            fi
+
+            exit 1
+            """)
+        defer {
+            try? FileManager.default.removeItem(at: cliURL.deletingLastPathComponent())
+            try? FileManager.default.removeItem(at: accountStarted)
+        }
+
+        let probe = KiroStatusProbe(cliBinaryResolver: { cliURL.path })
+        let task = Task { try await probe.fetch() }
+        defer { task.cancel() }
+
+        try await waitForFile(accountStarted)
+
+        task.cancel()
+        await #expect(throws: CancellationError.self) {
+            try await task.value
+        }
+    }
+
+    @Test
+    func `fetch returns when usage helper leaves inherited pipes open`() async throws {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-kiro-pipe-\(UUID().uuidString)", isDirectory: true)
+        let childPIDFile = root.appendingPathComponent("child.pid")
+        let cliURL = root.appendingPathComponent("kiro-cli")
+        try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+        defer {
+            if let text = try? String(contentsOf: childPIDFile, encoding: .utf8),
+               let childPID = pid_t(text.trimmingCharacters(in: .whitespacesAndNewlines))
+            {
+                _ = kill(childPID, SIGKILL)
+            }
+        }
+
+        let script = """
+        #!/bin/bash
+        set -e
+        if [ "$1" = "whoami" ]; then
+          printf 'Logged in with Google\\nEmail: person@example.com\\n'
+          exit 0
+        fi
+
+        if [ "$1" = "chat" ] && [ "$3" = "/usage" ]; then
+          /usr/bin/python3 -c '
+        import os
+        import subprocess
+        import sys
+
+        ready_read, ready_write = os.pipe()
+        child = subprocess.Popen(
+            [
+                sys.executable,
+                "-c",
+                "import os,signal,sys,time; "
+                "signal.signal(signal.SIGHUP, signal.SIG_IGN); "
+                "signal.signal(signal.SIGTERM, signal.SIG_IGN); "
+                "handle=open(sys.argv[1], \\\"w\\\"); handle.write(str(os.getpid())); handle.close(); "
+                "os.write(int(sys.argv[2]), b\\\"1\\\"); os.close(int(sys.argv[2])); time.sleep(30)",
+                os.environ["CODEXBAR_TEST_CHILD_PID_FILE"],
+                str(ready_write),
+            ],
+            start_new_session=True,
+            pass_fds=(ready_write,),
+        )
+        os.close(ready_write)
+        if os.read(ready_read, 1) != b"1":
+            raise RuntimeError("detached helper exited before signaling readiness")
+        os.close(ready_read)
+        '
+          test -s "$CODEXBAR_TEST_CHILD_PID_FILE"
+          printf 'Estimated Usage | resets on 2026-06-01 | KIRO FREE\\n'
+          printf 'Credits (12.50 of 50 covered in plan)\\n'
+          printf '████████████████████ 25%%\\n'
+          exit 0
+        fi
+
+        if [ "$1" = "chat" ] && [ "$3" = "/context" ]; then
+          exit 0
+        fi
+
+        exit 1
+        """
+        try script.write(to: cliURL, atomically: true, encoding: .utf8)
+        try FileManager.default.setAttributes([.posixPermissions: 0o755], ofItemAtPath: cliURL.path)
+
+        let previousPIDFile = ProcessInfo.processInfo.environment["CODEXBAR_TEST_CHILD_PID_FILE"]
+        setenv("CODEXBAR_TEST_CHILD_PID_FILE", childPIDFile.path, 1)
+        defer {
+            if let previousPIDFile {
+                setenv("CODEXBAR_TEST_CHILD_PID_FILE", previousPIDFile, 1)
+            } else {
+                unsetenv("CODEXBAR_TEST_CHILD_PID_FILE")
+            }
+        }
+
+        let probe = KiroStatusProbe(cliBinaryResolver: { cliURL.path })
+        let start = Date()
+        let snapshot = try await probe.fetch()
+        let elapsed = Date().timeIntervalSince(start)
+
+        #expect(snapshot.planName == "KIRO FREE")
+        #expect(snapshot.creditsUsed == 12.50)
+        #expect(elapsed < 8, "Kiro usage capture should return before the 10s idle timeout, took \(elapsed)s")
+
+        let childPIDText = try String(contentsOf: childPIDFile, encoding: .utf8)
+        let childPID = try #require(pid_t(childPIDText.trimmingCharacters(in: .whitespacesAndNewlines)))
+        let cleanupDeadline = Date().addingTimeInterval(1)
+        while kill(childPID, 0) == 0, Date() < cleanupDeadline {
+            try await Task.sleep(for: .milliseconds(20))
+        }
+        #expect(kill(childPID, 0) == -1, "Kiro usage capture should terminate pipe-holding helpers")
+    }
+
+    @Test
+    func `run command hard stops a process that ignores SIGTERM`() async throws {
+        let cliURL = try self.makeCLI(
+            """
+            #!/bin/sh
+            trap '' TERM
+            printf 'partial output\\n'
+            while true; do sleep 1; done
+            """)
+        defer { try? FileManager.default.removeItem(at: cliURL.deletingLastPathComponent()) }
+
+        let probe = KiroStatusProbe(cliBinaryResolver: { cliURL.path })
+        let start = Date()
+        let result = try await probe.runCommand(arguments: [], timeout: 2, idleTimeout: 0.1)
+        let elapsed = Date().timeIntervalSince(start)
+
+        #expect(result.terminatedForIdle)
+        #expect(result.stdout.contains("partial output"))
+        #expect(result.terminationStatus != 0)
+        #expect(elapsed < 2, "Ignored SIGTERM should escalate to SIGKILL, took \(elapsed)s")
+    }
+
+    @Test
+    func `run command kills a pipe holder that escapes the process group`() async throws {
+        let childPIDFile = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-kiro-escaped-\(UUID().uuidString).pid")
+        let cliURL = try self.makeCLI(
+            """
+            #!/usr/bin/python3
+            import subprocess
+            import sys
+            import time
+
+            child = subprocess.Popen(
+                [
+                    sys.executable,
+                    "-c",
+                    "import signal,time; signal.signal(signal.SIGTERM, signal.SIG_IGN); time.sleep(30)",
+                ],
+                start_new_session=True,
+            )
+            with open(sys.argv[1], "w") as handle:
+                handle.write(str(child.pid))
+            print("partial output", flush=True)
+            time.sleep(30)
+            """)
+        defer {
+            try? FileManager.default.removeItem(at: cliURL.deletingLastPathComponent())
+            try? FileManager.default.removeItem(at: childPIDFile)
+        }
+
+        let probe = KiroStatusProbe(cliBinaryResolver: { cliURL.path })
+        let result = try await probe.runCommand(
+            arguments: [childPIDFile.path],
+            timeout: 2,
+            idleTimeout: 0.1)
+
+        #expect(result.terminatedForIdle)
+        #expect(result.stdout.contains("partial output"))
+
+        let childPIDText = try String(contentsOf: childPIDFile, encoding: .utf8)
+        let childPID = try #require(pid_t(childPIDText.trimmingCharacters(in: .whitespacesAndNewlines)))
+        defer { _ = kill(childPID, SIGKILL) }
+
+        let cleanupDeadline = Date().addingTimeInterval(1)
+        while kill(childPID, 0) == 0, Date() < cleanupDeadline {
+            try await Task.sleep(for: .milliseconds(20))
+        }
+        #expect(kill(childPID, 0) == -1)
+    }
+
+    @Test
+    func `run command cleans a same group helper after normal exit`() async throws {
+        let childPIDFile = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-kiro-normal-exit-\(UUID().uuidString).pid")
+        let cliURL = try self.makeCLI(
+            """
+            #!/usr/bin/python3
+            import os
+            import signal
+            import sys
+            import time
+
+            child = os.fork()
+            if child == 0:
+                os.close(1)
+                os.close(2)
+                signal.signal(signal.SIGTERM, signal.SIG_IGN)
+                with open(sys.argv[1], "w") as handle:
+                    handle.write(str(os.getpid()))
+                time.sleep(30)
+                os._exit(0)
+
+            while not os.path.exists(sys.argv[1]):
+                time.sleep(0.01)
+            print("parent complete", flush=True)
+            os._exit(0)
+            """)
+        defer {
+            try? FileManager.default.removeItem(at: cliURL.deletingLastPathComponent())
+            try? FileManager.default.removeItem(at: childPIDFile)
+        }
+
+        let probe = KiroStatusProbe(cliBinaryResolver: { cliURL.path })
+        let result = try await probe.runCommand(arguments: [childPIDFile.path], timeout: 2)
+
+        #expect(result.terminationStatus == 0)
+        #expect(result.stdout.contains("parent complete"))
+
+        let childPIDText = try String(contentsOf: childPIDFile, encoding: .utf8)
+        let childPID = try #require(pid_t(childPIDText.trimmingCharacters(in: .whitespacesAndNewlines)))
+        defer { _ = kill(childPID, SIGKILL) }
+        #expect(kill(childPID, 0) == -1)
+    }
+
+    @Test
+    func `run command preserves completed no-output failure status`() async throws {
+        let cliURL = try self.makeCLI(
+            """
+            #!/bin/sh
+            exit 23
+            """)
+        defer { try? FileManager.default.removeItem(at: cliURL.deletingLastPathComponent()) }
+
+        let probe = KiroStatusProbe(cliBinaryResolver: { cliURL.path })
+        let result = try await probe.runCommand(arguments: [], timeout: 2)
+
+        #expect(result.stdout.isEmpty)
+        #expect(result.stderr.isEmpty)
+        #expect(result.terminationStatus == 23)
+        #expect(!result.terminatedForIdle)
+    }
+
+    @Test
+    func `run command cancellation terminates the process`() async throws {
+        let pidFile = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-kiro-cancel-\(UUID().uuidString).pid")
+        let cliURL = try self.makeCLI(
+            """
+            #!/bin/sh
+            printf '%s\\n' "$$" > "$1"
+            trap '' TERM
+            while true; do sleep 1; done
+            """)
+        defer {
+            try? FileManager.default.removeItem(at: cliURL.deletingLastPathComponent())
+            try? FileManager.default.removeItem(at: pidFile)
+        }
+
+        let probe = KiroStatusProbe(cliBinaryResolver: { cliURL.path })
+        let task = Task {
+            try await probe.runCommand(arguments: [pidFile.path], timeout: 20)
+        }
+        defer { task.cancel() }
+
+        var capturedProcessID: pid_t?
+        for _ in 0..<100 {
+            if let text = try? String(contentsOf: pidFile, encoding: .utf8) {
+                capturedProcessID = pid_t(text.trimmingCharacters(in: .whitespacesAndNewlines))
+                break
+            }
+            try await Task.sleep(for: .milliseconds(20))
+        }
+        let processID = try #require(capturedProcessID)
+        defer { _ = kill(processID, SIGKILL) }
+
+        task.cancel()
+        await #expect(throws: CancellationError.self) {
+            try await task.value
+        }
+        #expect(kill(processID, 0) == -1)
+    }
+}
+
+extension KiroStatusProbeTests {
     // MARK: - Happy Path Parsing
 
     @Test
-    func parsesBasicUsageOutput() throws {
+    func `parses basic usage output`() throws {
         let output = """
         | KIRO FREE                                          |
         ████████████████████████████████████████████████████ 25%
@@ -18,6 +516,7 @@ struct KiroStatusProbeTests {
         let snapshot = try probe.parse(output: output)
 
         #expect(snapshot.planName == "KIRO FREE")
+        #expect(snapshot.displayPlanName == "Kiro Free")
         #expect(snapshot.creditsPercent == 25)
         #expect(snapshot.creditsUsed == 12.50)
         #expect(snapshot.creditsTotal == 50)
@@ -27,8 +526,18 @@ struct KiroStatusProbeTests {
         #expect(snapshot.resetsAt != nil)
     }
 
+    private func makeCLI(_ script: String) throws -> URL {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-kiro-cli-\(UUID().uuidString)", isDirectory: true)
+        let cliURL = root.appendingPathComponent("kiro-cli")
+        try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
+        try script.write(to: cliURL, atomically: true, encoding: .utf8)
+        try FileManager.default.setAttributes([.posixPermissions: 0o755], ofItemAtPath: cliURL.path)
+        return cliURL
+    }
+
     @Test
-    func parsesOutputWithBonusCredits() throws {
+    func `parses output with bonus credits`() throws {
         let output = """
         | KIRO PRO                                           |
         ████████████████████████████████████████████████████ 80%
@@ -40,6 +549,7 @@ struct KiroStatusProbeTests {
         let snapshot = try probe.parse(output: output)
 
         #expect(snapshot.planName == "KIRO PRO")
+        #expect(snapshot.displayPlanName == "Kiro Pro")
         #expect(snapshot.creditsPercent == 80)
         #expect(snapshot.creditsUsed == 40.00)
         #expect(snapshot.creditsTotal == 50)
@@ -49,7 +559,7 @@ struct KiroStatusProbeTests {
     }
 
     @Test
-    func parsesOutputWithoutPercentFallbacksToCreditsRatio() throws {
+    func `parses output without percent fallbacks to credits ratio`() throws {
         let output = """
         | KIRO FREE                                          |
         (12.50 of 50 covered in plan), resets on 01/15
@@ -62,7 +572,7 @@ struct KiroStatusProbeTests {
     }
 
     @Test
-    func parsesBonusCreditsWithoutExpiry() throws {
+    func `parses bonus credits without expiry`() throws {
         let output = """
         | KIRO FREE                                          |
         ████████████████████████████████████████████████████ 60%
@@ -79,7 +589,7 @@ struct KiroStatusProbeTests {
     }
 
     @Test
-    func parsesOutputWithANSICodes() throws {
+    func `parses output with ANSI codes`() throws {
         let output = """
         \u{001B}[32m| KIRO FREE                                          |\u{001B}[0m
         \u{001B}[38;5;11m████████████████████████████████████████████████████\u{001B}[0m 50%
@@ -96,7 +606,7 @@ struct KiroStatusProbeTests {
     }
 
     @Test
-    func parsesOutputWithSingleDay() throws {
+    func `parses output with single day`() throws {
         let output = """
         | KIRO FREE                                          |
         ████████████████████████████████████████████████████ 10%
@@ -111,7 +621,7 @@ struct KiroStatusProbeTests {
     }
 
     @Test
-    func rejectsOutputMissingUsageMarkers() throws {
+    func `rejects output missing usage markers`() throws {
         let output = """
         | KIRO FREE                                          |
         """
@@ -125,7 +635,7 @@ struct KiroStatusProbeTests {
     // MARK: - New Format (kiro-cli 1.24+, Q Developer)
 
     @Test
-    func parsesQDeveloperManagedPlan() throws {
+    func `parses Q developer managed plan`() throws {
         let output = """
         Plan: Q Developer Pro
         Your plan is managed by admin
@@ -145,7 +655,7 @@ struct KiroStatusProbeTests {
     }
 
     @Test
-    func parsesQDeveloperFreePlan() throws {
+    func `parses Q developer free plan`() throws {
         let output = """
         Plan: Q Developer Free
         Your plan is managed by admin
@@ -159,7 +669,7 @@ struct KiroStatusProbeTests {
     }
 
     @Test
-    func parsesNewFormatWithANSICodes() throws {
+    func `parses new format with ANSI codes`() throws {
         let output = """
         \u{001B}[38;5;141mPlan: Q Developer Pro\u{001B}[0m
         Your plan is managed by admin
@@ -172,7 +682,7 @@ struct KiroStatusProbeTests {
     }
 
     @Test
-    func rejectsHeaderOnlyNewFormatWithoutManagedMarker() {
+    func `rejects header only new format without managed marker`() {
         let output = """
         Plan: Q Developer Pro
         Tip: to see context window usage, run /context
@@ -185,7 +695,7 @@ struct KiroStatusProbeTests {
     }
 
     @Test
-    func preservesParsedUsageForManagedPlanWithMetrics() throws {
+    func `preserves parsed usage for managed plan with metrics`() throws {
         let output = """
         Plan: Q Developer Enterprise
         Your plan is managed by admin
@@ -203,10 +713,94 @@ struct KiroStatusProbeTests {
         #expect(snapshot.resetsAt != nil)
     }
 
+    @Test
+    func `parses kiro cli two usage format`() throws {
+        let output = """
+        \u{001B}[1mEstimated Usage\u{001B}[0m | resets on 2026-06-01 | \u{001B}[mKIRO FREE\u{001B}[0m
+
+        🎁 Bonus credits: 45.53/2000 credits used, expires in 19 days
+
+        \u{001B}[1mCredits\u{001B}[0m (0.17 of 50 covered in plan)
+        ████████████████████████████████████████████████████████████████████████████████ 0%
+
+        Overages: \u{001B}[1mDisabled\u{001B}[0m
+
+        To manage your plan or configure overages navigate to https://app.kiro.dev/account/usage
+        """
+
+        let probe = KiroStatusProbe()
+        let snapshot = try probe.parse(
+            output: output,
+            accountEmail: "person@example.com",
+            authMethod: "Google")
+
+        #expect(snapshot.planName == "KIRO FREE")
+        #expect(snapshot.displayPlanName == "Kiro Free")
+        #expect(snapshot.accountEmail == "person@example.com")
+        #expect(snapshot.authMethod == "Google")
+        #expect(snapshot.creditsUsed == 0.17)
+        #expect(snapshot.creditsTotal == 50)
+        #expect(snapshot.creditsRemaining == 49.83)
+        #expect(snapshot.bonusCreditsUsed == 45.53)
+        #expect(snapshot.bonusCreditsTotal == 2000)
+        #expect(snapshot.bonusCreditsRemaining == 1954.47)
+        #expect(snapshot.bonusExpiryDays == 19)
+        #expect(snapshot.overagesStatus == "Disabled")
+        #expect(snapshot.manageURL == "https://app.kiro.dev/account/usage")
+        #expect(snapshot.resetsAt != nil)
+    }
+
+    @Test
+    func `parses kiro overage credits and estimated cost`() throws {
+        let output = """
+        Estimated Usage | resets on 2026-06-01 | KIRO PRO
+        Credits (1000.00 of 1000 covered in plan)
+        ████████████████████████████████████████████████████████████████████████████████ 100%
+
+        Overages: Enabled  billed at $0.04 per request
+        Credits used: 40.29
+        Est. cost: $1.61 USD
+
+        To manage your plan or configure overages navigate to https://app.kiro.dev/account/usage
+        """
+
+        let probe = KiroStatusProbe()
+        let snapshot = try probe.parse(output: output)
+
+        #expect(snapshot.planName == "KIRO PRO")
+        #expect(snapshot.creditsUsed == 1000)
+        #expect(snapshot.creditsTotal == 1000)
+        #expect(snapshot.overagesStatus == "Enabled  billed at $0.04 per request")
+        #expect(snapshot.overageCreditsUsed == 40.29)
+        #expect(snapshot.estimatedOverageCostUSD == 1.61)
+    }
+
+    @Test
+    func `parses context usage`() throws {
+        let output = """
+        Context window: 1.3% used (estimated)
+        ██████████████████████████████████████████████████████████████████████████████ 1.3%
+
+        █ Context files 0.5% (estimated)
+        █ Tools 0.8% (estimated)
+        █ Kiro responses 0.0% (estimated)
+        █ Your prompts 0.0% (estimated)
+        """
+
+        let probe = KiroStatusProbe()
+        let context = try #require(probe.parseContextUsage(output: output))
+
+        #expect(context.totalPercentUsed == 1.3)
+        #expect(context.contextFilesPercent == 0.5)
+        #expect(context.toolsPercent == 0.8)
+        #expect(context.kiroResponsesPercent == 0)
+        #expect(context.promptsPercent == 0)
+    }
+
     // MARK: - Snapshot Conversion
 
     @Test
-    func convertsSnapshotToUsageSnapshot() throws {
+    func `converts snapshot to usage snapshot`() throws {
         let now = Date()
         let resetDate = try #require(Calendar.current.date(byAdding: .day, value: 7, to: now))
 
@@ -226,12 +820,14 @@ struct KiroStatusProbeTests {
         #expect(usage.primary?.usedPercent == 25.0)
         #expect(usage.primary?.resetsAt == resetDate)
         #expect(usage.secondary?.usedPercent == 25.0) // 5/20 * 100
-        #expect(usage.loginMethod(for: .kiro) == "KIRO PRO")
-        #expect(usage.accountOrganization(for: .kiro) == "KIRO PRO")
+        #expect(usage.loginMethod(for: .kiro) == nil)
+        #expect(usage.accountOrganization(for: .kiro) == nil)
+        #expect(usage.kiroUsage?.displayPlanName == "Kiro Pro")
+        #expect(usage.kiroUsage?.creditsRemaining == 75)
     }
 
     @Test
-    func convertsSnapshotWithoutBonusCredits() {
+    func `converts snapshot without bonus credits`() {
         let snapshot = KiroUsageSnapshot(
             planName: "KIRO FREE",
             creditsUsed: 10.0,
@@ -252,7 +848,7 @@ struct KiroStatusProbeTests {
     // MARK: - Error Cases
 
     @Test
-    func emptyOutputThrowsParseError() {
+    func `empty output throws parse error`() {
         let probe = KiroStatusProbe()
 
         #expect(throws: KiroStatusProbeError.self) {
@@ -261,7 +857,7 @@ struct KiroStatusProbeTests {
     }
 
     @Test
-    func warningOutputThrowsParseError() {
+    func `warning output throws parse error`() {
         let output = """
         \u{001B}[38;5;11m⚠️  Warning: Could not retrieve usage information from backend
         \u{001B}[38;5;8mError: dispatch failure (io error): an i/o error occurred
@@ -275,7 +871,7 @@ struct KiroStatusProbeTests {
     }
 
     @Test
-    func unrecognizedFormatThrowsParseError() {
+    func `unrecognized format throws parse error`() {
         // Simulates a CLI format change where none of the expected patterns match
         let output = """
         Welcome to Kiro!
@@ -294,7 +890,7 @@ struct KiroStatusProbeTests {
     }
 
     @Test
-    func loginPromptThrowsNotLoggedIn() {
+    func `login prompt throws not logged in`() {
         let output = """
         Failed to initialize auth portal.
         Please try again with: kiro-cli login --use-device-flow
@@ -314,7 +910,7 @@ struct KiroStatusProbeTests {
     // MARK: - WhoAmI Validation
 
     @Test
-    func whoamiNotLoggedInThrows() {
+    func `whoami not logged in throws`() {
         let probe = KiroStatusProbe()
 
         #expect {
@@ -326,7 +922,7 @@ struct KiroStatusProbeTests {
     }
 
     @Test
-    func whoamiLoginRequiredThrows() {
+    func `whoami login required throws`() {
         let probe = KiroStatusProbe()
 
         #expect {
@@ -338,7 +934,7 @@ struct KiroStatusProbeTests {
     }
 
     @Test
-    func whoamiEmptyOutputWithZeroStatusThrows() {
+    func `whoami empty output with zero status throws`() {
         let probe = KiroStatusProbe()
 
         #expect {
@@ -350,7 +946,7 @@ struct KiroStatusProbeTests {
     }
 
     @Test
-    func whoamiNonZeroStatusWithMessageThrows() {
+    func `whoami non zero status with message throws`() {
         let probe = KiroStatusProbe()
 
         #expect {
@@ -362,12 +958,70 @@ struct KiroStatusProbeTests {
     }
 
     @Test
-    func whoamiSuccessDoesNotThrow() throws {
+    func `whoami success does not throw`() throws {
         let probe = KiroStatusProbe()
 
-        try probe.validateWhoAmIOutput(
+        let account = try probe.validateWhoAmIOutput(
+            stdout: """
+            Logged in with Google
+            Email: user@example.com
+            """,
+            stderr: "",
+            terminationStatus: 0)
+
+        #expect(account.authMethod == "Google")
+        #expect(account.email == "user@example.com")
+    }
+
+    @Test
+    func `whoami legacy bare email parses account`() throws {
+        let probe = KiroStatusProbe()
+
+        let account = try probe.validateWhoAmIOutput(
             stdout: "user@example.com",
             stderr: "",
             terminationStatus: 0)
+
+        #expect(account.authMethod == nil)
+        #expect(account.email == "user@example.com")
+    }
+}
+
+extension KiroStatusProbeTests {
+    @Test
+    func `fetch cancellation while joining account after usage failure is preserved`() async throws {
+        let accountStarted = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-kiro-failed-usage-account-\(UUID().uuidString).started")
+        let cliURL = try self.makeCLI(
+            """
+            #!/bin/sh
+            if [ "$1" = "whoami" ]; then
+              : > '\(accountStarted.path)'
+              trap '' TERM
+              while true; do sleep 1; done
+            fi
+
+            if [ "$1" = "chat" ] && [ "$3" = "/usage" ]; then
+              exit 1
+            fi
+
+            exit 1
+            """)
+        defer {
+            try? FileManager.default.removeItem(at: cliURL.deletingLastPathComponent())
+            try? FileManager.default.removeItem(at: accountStarted)
+        }
+
+        let probe = KiroStatusProbe(cliBinaryResolver: { cliURL.path }, accountProbeTimeout: 2.0)
+        let task = Task { try await probe.fetch() }
+        defer { task.cancel() }
+
+        try await waitForFile(accountStarted)
+        try await Task.sleep(for: .milliseconds(300))
+
+        task.cancel()
+        await #expect(throws: CancellationError.self) {
+            try await task.value
+        }
     }
 }
diff --git a/Tests/CodexBarTests/LLMProxyUsageFetcherTests.swift b/Tests/CodexBarTests/LLMProxyUsageFetcherTests.swift
new file mode 100644
index 0000000000..3c61b3016a
--- /dev/null
+++ b/Tests/CodexBarTests/LLMProxyUsageFetcherTests.swift
@@ -0,0 +1,120 @@
+import CodexBarCore
+import Foundation
+import Testing
+
+struct LLMProxyUsageFetcherTests {
+    @Test
+    func `parses quota stats summary`() throws {
+        let json = """
+        {
+          "providers": {
+            "openai": {
+              "credential_count": 3,
+              "active_count": 2,
+              "exhausted_count": 1,
+              "total_requests": 120,
+              "tokens": {
+                "input_cached": 1000,
+                "input_uncached": 2000,
+                "output": 3000
+              },
+              "approx_cost": 12.5,
+              "quota_groups": {
+                "default": {
+                  "remaining_percent": 42,
+                  "reset_time": "2026-05-18T12:00:00Z"
+                }
+              }
+            },
+            "anthropic": {
+              "credential_count": 1,
+              "active_count": 1,
+              "exhausted_count": 0,
+              "total_requests": 40,
+              "tokens": {
+                "input_cached": 0,
+                "input_uncached": 500,
+                "output": 500
+              },
+              "approx_cost": 3.0,
+              "quota_groups": [
+                { "remaining_percent": 80 }
+              ]
+            }
+          },
+          "summary": {
+            "total_requests": 160,
+            "total_tokens": 7000,
+            "approx_cost": 15.5
+          }
+        }
+        """
+
+        let parsed = try LLMProxyUsageFetcher._parseSnapshotForTesting(
+            Data(json.utf8),
+            updatedAt: Date(timeIntervalSince1970: 1))
+
+        #expect(parsed.providerCount == 2)
+        #expect(parsed.credentialCount == 4)
+        #expect(parsed.activeCredentialCount == 3)
+        #expect(parsed.exhaustedCredentialCount == 1)
+        #expect(parsed.totalRequests == 160)
+        #expect(parsed.totalTokens == 7000)
+        #expect(parsed.approximateCostUSD == 15.5)
+        #expect(parsed.minimumRemainingPercent == 42)
+
+        let snapshot = parsed.toUsageSnapshot()
+        #expect(snapshot.identity?.providerID == .llmproxy)
+        #expect(snapshot.primary?.usedPercent == 58)
+        #expect(snapshot.secondary?.resetDescription == "160 requests")
+        #expect(snapshot.tertiary?.resetDescription == "7,000 tokens")
+        #expect(snapshot.providerCost?.used == 15.5)
+    }
+
+    @Test
+    func `quota stats url accepts versioned or root base urls`() throws {
+        #expect(
+            try LLMProxyUsageFetcher
+                ._quotaStatsURLForTesting(baseURL: #require(URL(string: "https://proxy.example.com")))
+                .absoluteString == "https://proxy.example.com/v1/quota-stats")
+        #expect(
+            try LLMProxyUsageFetcher
+                ._quotaStatsURLForTesting(baseURL: #require(URL(string: "https://proxy.example.com/v1")))
+                .absoluteString == "https://proxy.example.com/v1/quota-stats")
+    }
+
+    @Test
+    func `parses fractional second quota reset times`() throws {
+        let json = """
+        {
+          "providers": {
+            "openai": {
+              "quota_groups": [
+                {
+                  "remaining_percent": 42,
+                  "reset_time": "2026-05-18T12:00:00.123Z"
+                }
+              ]
+            }
+          }
+        }
+        """
+
+        let parsed = try LLMProxyUsageFetcher._parseSnapshotForTesting(
+            Data(json.utf8),
+            updatedAt: Date(timeIntervalSince1970: 1))
+        let components = DateComponents(
+            calendar: Calendar(identifier: .gregorian),
+            timeZone: TimeZone(secondsFromGMT: 0),
+            year: 2026,
+            month: 5,
+            day: 18,
+            hour: 12,
+            minute: 0,
+            second: 0,
+            nanosecond: 123_000_000)
+        let expected = try #require(components.date)
+
+        #expect(try abs(#require(parsed.nextResetAt).timeIntervalSince(expected)) < 0.001)
+    }
+}
diff --git a/Tests/CodexBarTests/LaunchAtLoginManagerTests.swift b/Tests/CodexBarTests/LaunchAtLoginManagerTests.swift
new file mode 100644
index 0000000000..6248e07472
--- /dev/null
+++ b/Tests/CodexBarTests/LaunchAtLoginManagerTests.swift
@@ -0,0 +1,126 @@
+import ServiceManagement
+import Testing
+@testable import CodexBar
+
+@MainActor
+struct LaunchAtLoginManagerTests {
+    @Test
+    func `set enabled skips registration when service is already enabled`() {
+        var registerCalls = 0
+        var unregisterCalls = 0
+
+        LaunchAtLoginManager.setEnabled(
+            true,
+            status: { .enabled },
+            register: { registerCalls += 1 },
+            unregister: { unregisterCalls += 1 })
+
+        #expect(registerCalls == 0)
+        #expect(unregisterCalls == 0)
+    }
+
+    @Test
+    func `set enabled registers when service is not registered`() {
+        var registerCalls = 0
+        var unregisterCalls = 0
+
+        LaunchAtLoginManager.setEnabled(
+            true,
+            status: { .notRegistered },
+            register: { registerCalls += 1 },
+            unregister: { unregisterCalls += 1 })
+
+        #expect(registerCalls == 1)
+        #expect(unregisterCalls == 0)
+    }
+
+    @Test
+    func `set enabled skips registration when service requires approval`() {
+        var registerCalls = 0
+        var unregisterCalls = 0
+
+        LaunchAtLoginManager.setEnabled(
+            true,
+            status: { .requiresApproval },
+            register: { registerCalls += 1 },
+            unregister: { unregisterCalls += 1 })
+
+        #expect(registerCalls == 0)
+        #expect(unregisterCalls == 0)
+    }
+
+    @Test
+    func `set enabled registers when service is not found`() {
+        var registerCalls = 0
+        var unregisterCalls = 0
+
+        LaunchAtLoginManager.setEnabled(
+            true,
+            status: { .notFound },
+            register: { registerCalls += 1 },
+            unregister: { unregisterCalls += 1 })
+
+        #expect(registerCalls == 1)
+        #expect(unregisterCalls == 0)
+    }
+
+    @Test
+    func `set disabled unregisters when service is enabled`() {
+        var registerCalls = 0
+        var unregisterCalls = 0
+
+        LaunchAtLoginManager.setEnabled(
+            false,
+            status: { .enabled },
+            register: { registerCalls += 1 },
+            unregister: { unregisterCalls += 1 })
+
+        #expect(registerCalls == 0)
+        #expect(unregisterCalls == 1)
+    }
+
+    @Test
+    func `set disabled unregisters when service requires approval`() {
+        var registerCalls = 0
+        var unregisterCalls = 0
+
+        LaunchAtLoginManager.setEnabled(
+            false,
+            status: { .requiresApproval },
+            register: { registerCalls += 1 },
+            unregister: { unregisterCalls += 1 })
+
+        #expect(registerCalls == 0)
+        #expect(unregisterCalls == 1)
+    }
+
+    @Test
+    func `set disabled skips unregister when service is not registered`() {
+        var registerCalls = 0
+        var unregisterCalls = 0
+
+        LaunchAtLoginManager.setEnabled(
+            false,
+            status: { .notRegistered },
+            register: { registerCalls += 1 },
+            unregister: { unregisterCalls += 1 })
+
+        #expect(registerCalls == 0)
+        #expect(unregisterCalls == 0)
+    }
+
+    @Test
+    func `set disabled skips unregister when service is not found`() {
+        var registerCalls = 0
+        var unregisterCalls = 0
+
+        LaunchAtLoginManager.setEnabled(
+            false,
+            status: { .notFound },
+            register: { registerCalls += 1 },
+            unregister: { unregisterCalls += 1 })
+
+        #expect(registerCalls == 0)
+        #expect(unregisterCalls == 0)
+    }
+}
diff --git a/Tests/CodexBarTests/LiteLLMMenuCardModelTests.swift b/Tests/CodexBarTests/LiteLLMMenuCardModelTests.swift
new file mode 100644
index 0000000000..141c4ee3c7
--- /dev/null
+++ b/Tests/CodexBarTests/LiteLLMMenuCardModelTests.swift
@@ -0,0 +1,220 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct LiteLLMMenuCardModelTests {
+    @Test
+    func `litellm budget rows show spend detail with reset time`() throws {
+        let now = Date(timeIntervalSince1970: 0)
+        let metadata = try #require(ProviderDefaults.metadata[.litellm])
+        let json = """
+        {
+          "user_id": "user-123",
+          "user_info": {
+            "user_id": "user-123",
+            "max_budget": 900.0,
+            "spend": 403.99,
+            "budget_reset_at": "1970-01-07T00:00:00Z"
+          },
+          "teams": [
+            {
+              "team_alias": "Platform",
+              "team_id": "team-123",
+              "max_budget": 1000.0,
+              "spend": 70.0,
+              "budget_duration": "30d",
+              "budget_reset_at": "1970-01-07T00:00:00Z"
+            }
+          ]
+        }
+        """
+        let snapshot = try LiteLLMUsageFetcher._parseUserInfoForTesting(
+            Data(json.utf8),
+            keyInfo: LiteLLMKeyInfoSnapshot(
+                userID: "user-123",
+                teamID: "team-123",
+                keyName: nil,
+                spendUSD: 403.99,
+                expiresAt: nil),
+            updatedAt: now)
+            .toUsageSnapshot()
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .litellm,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        let personal = try #require(model.metrics.first { $0.id == "primary" })
+        #expect(personal.title == "Personal budget")
+        #expect(personal.percentLabel == "55% left")
+        #expect(personal.resetText?.hasPrefix("Resets") == true)
+        #expect(personal.detailText == "$403.99 / $900.00")
+
+        let team = try #require(model.metrics.first { $0.id == "secondary" })
+        #expect(team.title == "Team budget")
+        #expect(team.percentLabel == "93% left")
+        #expect(team.resetText?.hasPrefix("Resets") == true)
+        #expect(team.detailText == "Team Platform: $70.00 / $1,000.00")
+
+        #expect(model.providerCost == nil)
+    }
+
+    @Test
+    func `litellm budget row details redact team aliases when hiding personal info`() throws {
+        let now = Date(timeIntervalSince1970: 0)
+        let metadata = try #require(ProviderDefaults.metadata[.litellm])
+        let teamAlias = "Private Workspace"
+        let json = """
+        {
+          "user_id": "user-123",
+          "user_info": {
+            "user_id": "user-123",
+            "max_budget": 900.0,
+            "spend": 403.99
+          },
+          "teams": [
+            {
+              "team_alias": "\(teamAlias)",
+              "team_id": "team-123",
+              "max_budget": 1000.0,
+              "spend": 70.0
+            }
+          ]
+        }
+        """
+        let snapshot = try LiteLLMUsageFetcher._parseUserInfoForTesting(
+            Data(json.utf8),
+            keyInfo: LiteLLMKeyInfoSnapshot(
+                userID: "user-123",
+                teamID: "team-123",
+                keyName: nil,
+                spendUSD: 403.99,
+                expiresAt: nil),
+            updatedAt: now)
+            .toUsageSnapshot()
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .litellm,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: true,
+            now: now))
+
+        let team = try #require(model.metrics.first { $0.id == "secondary" })
+        #expect(team.detailText == "Team Hidden: $70.00 / $1,000.00")
+        #expect(team.detailText?.contains(teamAlias) == false)
+    }
+
+    @Test
+    func `litellm team-only budget stays on the team row`() throws {
+        let now = Date(timeIntervalSince1970: 0)
+        let metadata = try #require(ProviderDefaults.metadata[.litellm])
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: RateWindow(
+                usedPercent: 25,
+                windowMinutes: nil,
+                resetsAt: now.addingTimeInterval(7 * 24 * 60 * 60),
+                resetDescription: "Team Platform: $250.00 / $1,000.00"),
+            providerCost: ProviderCostSnapshot(
+                used: 250,
+                limit: 1000,
+                currencyCode: "USD",
+                period: "Team budget",
+                updatedAt: now),
+            updatedAt: now)
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .litellm,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.metrics.map(\.id) == ["secondary"])
+        #expect(model.metrics.first?.detailText == "Team Platform: $250.00 / $1,000.00")
+        #expect(model.providerCost == nil)
+    }
+
+    @Test
+    func `litellm spend without budget remains visible`() throws {
+        let now = Date()
+        let metadata = try #require(ProviderDefaults.metadata[.litellm])
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            providerCost: ProviderCostSnapshot(
+                used: 12.5,
+                limit: 0,
+                currencyCode: "USD",
+                period: "Personal spend",
+                updatedAt: now),
+            updatedAt: now)
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .litellm,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.providerCost?.title == "API spend")
+        #expect(model.providerCost?.spendLine == "Personal spend: $12.50")
+        #expect(model.providerCost?.percentUsed == nil)
+    }
+}
diff --git a/Tests/CodexBarTests/LiteLLMUsageFetcherTests.swift b/Tests/CodexBarTests/LiteLLMUsageFetcherTests.swift
new file mode 100644
index 0000000000..d21cf30ec5
--- /dev/null
+++ b/Tests/CodexBarTests/LiteLLMUsageFetcherTests.swift
@@ -0,0 +1,364 @@
+import CodexBarCore
+import Foundation
+import Testing
+
+struct LiteLLMUsageFetcherTests {
+    @Test
+    func `parses user usage with personal and team budgets`() throws {
+        let json = """
+        {
+          "user_id": "user-123",
+          "user_info": {
+            "user_id": "user-123",
+            "user_alias": "litellm-user@example.com",
+            "max_budget": 300.0,
+            "spend": 212.3537162499998,
+            "user_email": "litellm-user@example.com",
+            "budget_reset_at": null,
+            "teams": ["team-456"],
+            "metadata": {
+              "source": "keycloak",
+              "preferred_username": "litellm-user@example.com",
+              "budget": 300,
+              "flags": {
+                "keycloak": true
+              }
+            }
+          },
+          "keys": [
+            {
+              "key_name": "sk-...OTHER",
+              "user_id": "user-123",
+              "team_id": "team-other"
+            },
+            {
+              "key_name": "sk-...IAAw",
+              "spend": 212.3537162499998,
+              "expires": "2026-09-11T00:12:55.950000+00:00",
+              "user_id": "user-123",
+              "team_id": "team-456"
+            }
+          ],
+          "teams": [
+            {
+              "team_alias": "unrelated",
+              "team_id": "team-other",
+              "max_budget": 5.0,
+              "spend": 4.0
+            },
+            {
+              "team_alias": "ai",
+              "team_id": "team-456",
+              "max_budget": 1000.0,
+              "spend": 215.3245658499998,
+              "budget_duration": "7d",
+              "budget_reset_at": "2026-06-15T00:00:00Z"
+            }
+          ]
+        }
+        """
+
+        let parsed = try LiteLLMUsageFetcher._parseUserInfoForTesting(
+            Data(json.utf8),
+            keyInfo: LiteLLMKeyInfoSnapshot(
+                userID: "user-123",
+                teamID: "team-456",
+                keyName: "sk-...IAAw",
+                spendUSD: 212.3537162499998,
+                expiresAt: Date(timeIntervalSince1970: 2)),
+            updatedAt: Date(timeIntervalSince1970: 1))
+
+        #expect(parsed.userID == "user-123")
+        #expect(parsed.accountEmail == "litellm-user@example.com")
+        #expect(abs(parsed.personalSpendUSD - 212.3537162499998) < 0.000001)
+        #expect(parsed.personalBudgetUSD == 300)
+        #expect(parsed.teamUsage?.alias == "ai")
+        #expect(parsed.teamUsage?.spendUSD == 215.3245658499998)
+        #expect(parsed.teamUsage?.budgetUSD == 1000)
+        #expect(parsed.keyName == "sk-...IAAw")
+        #expect(parsed.keyExpiresAt == Date(timeIntervalSince1970: 2))
+
+        let snapshot = parsed.toUsageSnapshot()
+        #expect(snapshot.identity?.providerID == .litellm)
+        #expect(snapshot.identity?.accountEmail == "litellm-user@example.com")
+        let primary = try #require(snapshot.primary)
+        #expect(abs(primary.usedPercent - 70.78457208333327) < 0.000001)
+        #expect(primary.resetDescription == "$212.35 / $300.00")
+        let secondary = try #require(snapshot.secondary)
+        #expect(abs(secondary.usedPercent - 21.53245658499998) < 0.000001)
+        #expect(secondary.resetDescription == "Team ai: $215.32 / $1,000.00")
+        #expect(snapshot.providerCost?.used == 212.3537162499998)
+        #expect(snapshot.providerCost?.limit == 300)
+        #expect(snapshot.providerCost?.period == "Personal budget")
+    }
+
+    @Test
+    func `preserves personal spend when no budget is configured`() throws {
+        let json = """
+        {
+          "user_id": "user-123",
+          "user_info": {
+            "user_id": "user-123",
+            "max_budget": null,
+            "spend": 12.5
+          }
+        }
+        """
+
+        let parsed = try LiteLLMUsageFetcher._parseUserInfoForTesting(
+            Data(json.utf8),
+            keyInfo: LiteLLMKeyInfoSnapshot(
+                userID: "user-123",
+                teamID: nil,
+                keyName: "personal-key",
+                spendUSD: 12.5,
+                expiresAt: nil),
+            updatedAt: Date(timeIntervalSince1970: 1))
+
+        let snapshot = parsed.toUsageSnapshot()
+        #expect(snapshot.primary == nil)
+        #expect(snapshot.providerCost?.used == 12.5)
+        #expect(snapshot.providerCost?.limit == 0)
+        #expect(snapshot.providerCost?.period == "Personal spend")
+    }
+
+    @Test
+    func `parses key info identity for user lookup`() throws {
+        let json = """
+        {
+          "key": "sk-redacted",
+          "info": {
+            "key_name": "sk-...IAAw",
+            "spend": 212.3537162499998,
+            "expires": "2026-09-11T00:12:55.950000+00:00",
+            "user_id": "user-123",
+            "team_id": "team-456",
+            "max_budget": null
+          }
+        }
+        """
+
+        let parsed = try LiteLLMUsageFetcher._parseKeyInfoForTesting(Data(json.utf8))
+
+        #expect(parsed.userID == "user-123")
+        #expect(parsed.teamID == "team-456")
+        #expect(parsed.keyName == "sk-...IAAw")
+        #expect(parsed.spendUSD == 212.3537162499998)
+    }
+
+    @Test
+    func `parses team-only key info without user identity`() throws {
+        let json = """
+        {
+          "info": {
+            "key_name": "team-service-key",
+            "spend": 25.0,
+            "team_id": "team-456"
+          }
+        }
+        """
+
+        let parsed = try LiteLLMUsageFetcher._parseKeyInfoForTesting(Data(json.utf8))
+
+        #expect(parsed.userID == nil)
+        #expect(parsed.teamID == "team-456")
+        #expect(parsed.keyName == "team-service-key")
+    }
+
+    @Test
+    func `management urls accept root or v1 base urls`() throws {
+        let root = try #require(URL(string: "https://litellm.example.com"))
+        let versioned = try #require(URL(string: "https://litellm.example.com/v1"))
+        let nestedVersioned = try #require(URL(string: "https://gateway.example.com/litellm/v1/"))
+
+        #expect(
+            LiteLLMUsageFetcher
+                ._keyInfoURLForTesting(baseURL: root)
+                .absoluteString == "https://litellm.example.com/key/info")
+        #expect(
+            LiteLLMUsageFetcher
+                ._keyInfoURLForTesting(baseURL: versioned)
+                .absoluteString == "https://litellm.example.com/key/info")
+        #expect(
+            LiteLLMUsageFetcher
+                ._userInfoURLForTesting(baseURL: nestedVersioned, userID: "user-123")
+                .absoluteString == "https://gateway.example.com/litellm/user/info?user_id=user-123")
+        #expect(
+            LiteLLMUsageFetcher
+                ._teamInfoURLForTesting(baseURL: nestedVersioned, teamID: "team-456")
+                .absoluteString == "https://gateway.example.com/litellm/team/info?team_id=team-456")
+    }
+
+    @Test
+    func `settings reader trims quoted environment values`() {
+        let environment = [
+            "LITELLM_API_KEY": " 'sk-test' ",
+            "LITELLM_BASE_URL": #" "https://litellm.example.com/v1" "#,
+        ]
+
+        #expect(LiteLLMSettingsReader.apiKey(environment: environment) == "sk-test")
+        #expect(LiteLLMSettingsReader.baseURL(environment: environment)?
+            .absoluteString == "https://litellm.example.com/v1")
+    }
+
+    @Test
+    func `fetch trims api key before sending management requests`() async throws {
+        let baseURL = try #require(URL(string: "https://litellm.example.com/v1"))
+        let transport = ProviderHTTPTransportStub { request in
+            #expect(request.value(forHTTPHeaderField: "Authorization") == "Bearer sk-test")
+
+            let path = request.url?.path
+            let query = request.url?.query
+            let body: String
+            switch path {
+            case "/key/info":
+                #expect(query == nil)
+                body = """
+                {
+                  "info": {
+                    "user_id": "user-123",
+                    "team_id": "team-456",
+                    "spend": 1
+                  }
+                }
+                """
+            case "/user/info":
+                #expect(query == "user_id=user-123")
+                body = """
+                {
+                  "user_id": "user-123",
+                  "user_info": {
+                    "user_id": "user-123",
+                    "max_budget": 10,
+                    "spend": 1
+                  }
+                }
+                """
+            default:
+                Issue.record("unexpected LiteLLM request path: \(path ?? "nil")")
+                body = "{}"
+            }
+
+            let url = try #require(request.url)
+            let response = try #require(HTTPURLResponse(
+                url: url,
+                statusCode: 200,
+                httpVersion: nil,
+                headerFields: nil))
+            return (Data(body.utf8), response)
+        }
+
+        let snapshot = try await LiteLLMUsageFetcher.fetchUsage(
+            apiKey: " sk-test\n",
+            baseURL: baseURL,
+            transport: transport)
+
+        #expect(snapshot.userID == "user-123")
+        let requests = await transport.requests()
+        #expect(requests.count == 2)
+    }
+
+    @Test
+    func `fetches team usage for team-only virtual keys`() async throws {
+        let baseURL = try #require(URL(string: "https://litellm.example.com/v1"))
+        let transport = ProviderHTTPTransportStub { request in
+            #expect(request.value(forHTTPHeaderField: "Authorization") == "Bearer sk-team")
+
+            let path = request.url?.path
+            let query = request.url?.query
+            let body: String
+            switch path {
+            case "/key/info":
+                #expect(query == nil)
+                body = """
+                {
+                  "info": {
+                    "key_name": "team-service-key",
+                    "team_id": "team-456",
+                    "spend": 25
+                  }
+                }
+                """
+            case "/team/info":
+                #expect(query == "team_id=team-456")
+                body = """
+                {
+                  "team_id": "team-456",
+                  "team_info": {
+                    "team_id": "team-456",
+                    "team_alias": "platform",
+                    "max_budget": 100,
+                    "spend": 25,
+                    "budget_duration": "30d",
+                    "budget_reset_at": "2026-07-01T00:00:00Z"
+                  }
+                }
+                """
+            default:
+                Issue.record("unexpected LiteLLM request path: \(path ?? "nil")")
+                body = "{}"
+            }
+
+            let url = try #require(request.url)
+            let response = try #require(HTTPURLResponse(
+                url: url,
+                statusCode: 200,
+                httpVersion: nil,
+                headerFields: nil))
+            return (Data(body.utf8), response)
+        }
+
+        let snapshot = try await LiteLLMUsageFetcher.fetchUsage(
+            apiKey: "sk-team",
+            baseURL: baseURL,
+            transport: transport,
+            updatedAt: Date(timeIntervalSince1970: 1))
+
+        #expect(snapshot.userID == nil)
+        #expect(snapshot.teamUsage?.id == "team-456")
+        #expect(snapshot.teamUsage?.alias == "platform")
+        #expect(snapshot.teamUsage?.spendUSD == 25)
+        #expect(snapshot.teamUsage?.budgetUSD == 100)
+
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary == nil)
+        #expect(usage.secondary?.usedPercent == 25)
+        #expect(usage.providerCost?.used == 25)
+        #expect(usage.providerCost?.limit == 100)
+        #expect(usage.providerCost?.period == "Team budget")
+
+        let requests = await transport.requests()
+        #expect(requests.count == 2)
+    }
+
+    @Test
+    func `fetch surfaces rejected virtual key`() async throws {
+        let baseURL = try #require(URL(string: "https://litellm.example.com"))
+        let transport = ProviderHTTPTransportStub { request in
+            #expect(request.value(forHTTPHeaderField: "Authorization") == "Bearer sk-target")
+            let url = try #require(request.url)
+            let response = try #require(HTTPURLResponse(
+                url: url,
+                statusCode: 401,
+                httpVersion: nil,
+                headerFields: nil))
+            return (Data(#"{"detail":"Unauthorized"}"#.utf8), response)
+        }
+
+        do {
+            _ = try await LiteLLMUsageFetcher.fetchUsage(
+                apiKey: "sk-target",
+                baseURL: baseURL,
+                transport: transport)
+            Issue.record("expected LiteLLMUsageError.apiError")
+        } catch let LiteLLMUsageError.apiError(message) {
+            #expect(message.contains("HTTP 401"))
+            #expect(message.contains("Unauthorized"))
+        } catch {
+            Issue.record("expected LiteLLMUsageError.apiError, got \(error)")
+        }
+
+        let requests = await transport.requests()
+        #expect(requests.count == 1)
+    }
+}
diff --git a/Tests/CodexBarTests/LiveAccountTests.swift b/Tests/CodexBarTests/LiveAccountTests.swift
index 7622400322..a4d5e11892 100644
--- a/Tests/CodexBarTests/LiveAccountTests.swift
+++ b/Tests/CodexBarTests/LiveAccountTests.swift
@@ -3,10 +3,10 @@ import Foundation
 import Testing
 @testable import CodexBar
 
-@Suite("Live RPC account checks", .serialized)
+@Suite(.serialized)
 struct LiveAccountTests {
     @Test(.disabled("Set LIVE_TEST=1 to run live Codex account checks."))
-    func codexAccountEmailIsPresent() async throws {
+    func `codex account email is present`() async throws {
         guard ProcessInfo.processInfo.environment["LIVE_TEST"] == "1" else { return }
 
         let fetcher = UsageFetcher()
diff --git a/Tests/CodexBarTests/LoadingPatternTests.swift b/Tests/CodexBarTests/LoadingPatternTests.swift
index d476b02e95..535f2b7413 100644
--- a/Tests/CodexBarTests/LoadingPatternTests.swift
+++ b/Tests/CodexBarTests/LoadingPatternTests.swift
@@ -2,10 +2,9 @@ import Foundation
 import Testing
 @testable import CodexBar
 
-@Suite
 struct LoadingPatternTests {
     @Test
-    func valuesStayWithinBounds() {
+    func `values stay within bounds`() {
         for pattern in LoadingPattern.allCases {
             for phase in stride(from: 0.0, through: Double.pi * 2, by: Double.pi / 6) {
                 let v = pattern.value(phase: phase)
@@ -15,7 +14,7 @@ struct LoadingPatternTests {
     }
 
     @Test
-    func knightRiderPingPongs() {
+    func `knight rider ping pongs`() {
         let pattern = LoadingPattern.knightRider
         let mid = pattern.value(phase: 0) // sin 0 = 0 => 50
         let min = pattern.value(phase: -Double.pi / 2) // sin -pi/2 = -1 => 0
@@ -26,7 +25,7 @@ struct LoadingPatternTests {
     }
 
     @Test
-    func secondaryOffsetDiffers() {
+    func `secondary offset differs`() {
         let pattern = LoadingPattern.cylon
         let primary = pattern.value(phase: 0)
         let secondary = pattern.value(phase: pattern.secondaryOffset)
diff --git a/Tests/CodexBarTests/LocalizationBundleCacheTests.swift b/Tests/CodexBarTests/LocalizationBundleCacheTests.swift
new file mode 100644
index 0000000000..7a7d2572c2
--- /dev/null
+++ b/Tests/CodexBarTests/LocalizationBundleCacheTests.swift
@@ -0,0 +1,71 @@
+import Foundation
+import Testing
+@testable import CodexBar
+
+/// Regression coverage for the localized-bundle caching added for #1347.
+///
+/// The cache is process-global and these tests run in a parallel suite, so identity (`===`) assertions
+/// would race against any other test that resolves a different language. Instead these assert the
+/// concurrency-safe property that matters for correctness: every call resolves to the right `.lproj`
+/// regardless of what is currently cached, so a language switch (and switch-back) is always honored and
+/// the cache can never serve a stale localization.
+struct LocalizationBundleCacheTests {
+    @Test
+    func `resolves the correct lproj per language and re-resolves on switch`() {
+        resetCodexBarLocalizationCacheForTesting()
+
+        let fr = CodexBarLocalizationOverride.$appLanguage.withValue("fr") {
+            codexBarLocalizedBundleForTesting()
+        }
+        #expect(fr.bundleURL.lastPathComponent == "fr.lproj")
+
+        // Switching language must re-resolve rather than return the cached French bundle.
+        let es = CodexBarLocalizationOverride.$appLanguage.withValue("es") {
+            codexBarLocalizedBundleForTesting()
+        }
+        #expect(es.bundleURL.lastPathComponent == "es.lproj")
+
+        // Switching back must still produce the French bundle (cache key is the language).
+        let frAgain = CodexBarLocalizationOverride.$appLanguage.withValue("fr") {
+            codexBarLocalizedBundleForTesting()
+        }
+        #expect(frAgain.bundleURL.lastPathComponent == "fr.lproj")
+    }
+
+    @Test
+    func `repeated same-language calls keep resolving the same lproj`() {
+        resetCodexBarLocalizationCacheForTesting()
+
+        for _ in 0..<5 {
+            let bundle = CodexBarLocalizationOverride.$appLanguage.withValue("es") {
+                codexBarLocalizedBundleForTesting()
+            }
+            #expect(bundle.bundleURL.lastPathComponent == "es.lproj")
+        }
+    }
+
+    @Test
+    func `unknown language falls back to en lproj`() {
+        resetCodexBarLocalizationCacheForTesting()
+
+        let bundle = CodexBarLocalizationOverride.$appLanguage.withValue("zz-unknown") {
+            codexBarLocalizedBundleForTesting()
+        }
+        #expect(bundle.bundleURL.lastPathComponent == "en.lproj")
+    }
+
+    @Test
+    func `resolution survives an explicit cache reset`() {
+        let first = CodexBarLocalizationOverride.$appLanguage.withValue("uk") {
+            codexBarLocalizedBundleForTesting()
+        }
+        #expect(first.bundleURL.lastPathComponent == "uk.lproj")
+
+        resetCodexBarLocalizationCacheForTesting()
+
+        let afterReset = CodexBarLocalizationOverride.$appLanguage.withValue("uk") {
+            codexBarLocalizedBundleForTesting()
+        }
+        #expect(afterReset.bundleURL.lastPathComponent == "uk.lproj")
+    }
+}
diff --git a/Tests/CodexBarTests/LocalizationBundleTests.swift b/Tests/CodexBarTests/LocalizationBundleTests.swift
new file mode 100644
index 0000000000..1bf64988ef
--- /dev/null
+++ b/Tests/CodexBarTests/LocalizationBundleTests.swift
@@ -0,0 +1,125 @@
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct LocalizationBundleTests {
+    @Test
+    func `packaged app resolves localization bundle from resources`() throws {
+        let fixture = try Self.makeAppBundleFixture(includeLocalizationBundle: true)
+        defer { try? FileManager.default.removeItem(at: fixture.root) }
+
+        let bundle = codexBarLocalizationResourceBundle(mainBundle: fixture.appBundle)
+
+        #expect(bundle.bundleURL.lastPathComponent == "CodexBar_CodexBar.bundle")
+        #expect(bundle.path(forResource: "en", ofType: "lproj") != nil)
+    }
+
+    @Test
+    func `packaged app falls back to main bundle without touching SwiftPM module`() throws {
+        let fixture = try Self.makeAppBundleFixture(includeLocalizationBundle: false)
+        defer { try? FileManager.default.removeItem(at: fixture.root) }
+
+        let bundle = codexBarLocalizationResourceBundle(mainBundle: fixture.appBundle)
+
+        #expect(bundle.bundleURL == fixture.appBundle.bundleURL)
+    }
+
+    @Test
+    func `packaged app resolves raw copied localization resources from main bundle`() throws {
+        let fixture = try Self.makeAppBundleFixture(
+            includeLocalizationBundle: false,
+            includeMainLocalization: true)
+        defer { try? FileManager.default.removeItem(at: fixture.root) }
+
+        let bundle = codexBarLocalizationResourceBundle(mainBundle: fixture.appBundle)
+
+        #expect(bundle.bundleURL == fixture.appBundle.bundleURL)
+        #expect(bundle.path(forResource: "en", ofType: "lproj") != nil)
+    }
+
+    @Test
+    func `empty localized values fall back to English`() throws {
+        let fixture = try Self.makeAppBundleFixture(
+            includeLocalizationBundle: true,
+            includeEmptyChineseLocalization: true)
+        defer { try? FileManager.default.removeItem(at: fixture.root) }
+
+        let resourceBundle = codexBarLocalizationResourceBundle(mainBundle: fixture.appBundle)
+        let zhPath = try #require(resourceBundle.path(forResource: "zh-Hans", ofType: "lproj"))
+        let zhBundle = try #require(Bundle(path: zhPath))
+
+        #expect(codexBarLocalizedString("Settings", bundle: zhBundle, resourceBundle: resourceBundle) == "Settings")
+        #expect(codexBarLocalizedString("Missing", bundle: zhBundle, resourceBundle: resourceBundle) == "Missing")
+    }
+
+    @Test
+    func `managed Codex login failure includes CLI recovery guidance`() {
+        let message = L("managed_login_failed")
+
+        #expect(message.contains("codex --version"))
+        #expect(message.contains("@openai/codex@latest"))
+    }
+
+    private static func makeAppBundleFixture(
+        includeLocalizationBundle: Bool,
+        includeMainLocalization: Bool = false,
+        includeEmptyChineseLocalization: Bool = false) throws -> (root: URL, appBundle: Bundle)
+    {
+        let root = FileManager.default.temporaryDirectory.appendingPathComponent(
+            "codexbar-localization-\(UUID().uuidString)",
+            isDirectory: true)
+        let appURL = root.appendingPathComponent("CodexBar.app", isDirectory: true)
+        let contentsURL = appURL.appendingPathComponent("Contents", isDirectory: true)
+        let resourcesURL = contentsURL.appendingPathComponent("Resources", isDirectory: true)
+        try FileManager.default.createDirectory(at: resourcesURL, withIntermediateDirectories: true)
+
+        let info = """
+        <?xml version="1.0" encoding="UTF-8"?>
+        <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+        <plist version="1.0">
+        <dict>
+            <key>CFBundleExecutable</key><string>CodexBar</string>
+            <key>CFBundleIdentifier</key><string>com.steipete.codexbar.tests</string>
+            <key>CFBundleName</key><string>CodexBar</string>
+            <key>CFBundlePackageType</key><string>APPL</string>
+        </dict>
+        </plist>
+        """
+        try info.write(
+            to: contentsURL.appendingPathComponent("Info.plist"),
+            atomically: true,
+            encoding: .utf8)
+
+        if includeMainLocalization {
+            try Self.writeEnglishLocalization(to: resourcesURL.appendingPathComponent("en.lproj", isDirectory: true))
+        }
+
+        if includeLocalizationBundle {
+            let bundleURL = resourcesURL.appendingPathComponent("CodexBar_CodexBar.bundle", isDirectory: true)
+            try Self.writeEnglishLocalization(to: bundleURL.appendingPathComponent("en.lproj", isDirectory: true))
+            if includeEmptyChineseLocalization {
+                try Self.writeEmptyChineseLocalization(
+                    to: bundleURL.appendingPathComponent("zh-Hans.lproj", isDirectory: true))
+            }
+        }
+
+        let appBundle = try #require(Bundle(url: appURL))
+        return (root, appBundle)
+    }
+
+    private static func writeEnglishLocalization(to lprojURL: URL) throws {
+        try FileManager.default.createDirectory(at: lprojURL, withIntermediateDirectories: true)
+        try "\"Settings\" = \"Settings\";\n".write(
+            to: lprojURL.appendingPathComponent("Localizable.strings"),
+            atomically: true,
+            encoding: .utf8)
+    }
+
+    private static func writeEmptyChineseLocalization(to lprojURL: URL) throws {
+        try FileManager.default.createDirectory(at: lprojURL, withIntermediateDirectories: true)
+        try "\"Settings\" = \"\";\n".write(
+            to: lprojURL.appendingPathComponent("Localizable.strings"),
+            atomically: true,
+            encoding: .utf8)
+    }
+}
diff --git a/Tests/CodexBarTests/LocalizationLanguageCatalogTests.swift b/Tests/CodexBarTests/LocalizationLanguageCatalogTests.swift
new file mode 100644
index 0000000000..d66f185213
--- /dev/null
+++ b/Tests/CodexBarTests/LocalizationLanguageCatalogTests.swift
@@ -0,0 +1,406 @@
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct LocalizationLanguageCatalogTests {
+    private let languageKeys = [
+        "language_system",
+        "language_english",
+        "language_german",
+        "language_spanish",
+        "language_catalan",
+        "language_chinese_simplified",
+        "language_chinese_traditional",
+        "language_portuguese_brazilian",
+        "language_swedish",
+        "language_french",
+        "language_dutch",
+        "language_ukrainian",
+        "language_italian",
+        "language_vietnamese",
+        "language_japanese",
+        "language_korean",
+        "language_turkish",
+        "language_indonesian",
+        "language_polish",
+        "language_arabic",
+        "language_persian",
+        "language_thai",
+    ]
+
+    @Test
+    func `app language catalog includes Ukrainian`() {
+        #expect(AppLanguage.allCases.contains(.ukrainian))
+        #expect(AppLanguage.ukrainian.rawValue == "uk")
+    }
+
+    @Test
+    func `app language catalog includes Korean`() {
+        #expect(AppLanguage.allCases.contains(.korean))
+        #expect(AppLanguage.korean.rawValue == "ko")
+    }
+
+    @Test
+    func `app language catalog includes Turkish`() {
+        #expect(AppLanguage.allCases.contains(.turkish))
+        #expect(AppLanguage.turkish.rawValue == "tr")
+    }
+
+    @Test
+    func `app language catalog includes Italian`() {
+        #expect(AppLanguage.allCases.contains(.italian))
+        #expect(AppLanguage.italian.rawValue == "it")
+    }
+
+    @Test
+    func `app language catalog includes Indonesian`() {
+        #expect(AppLanguage.allCases.contains(.indonesian))
+        #expect(AppLanguage.indonesian.rawValue == "id")
+    }
+
+    @Test
+    func `app language catalog includes Polish`() {
+        #expect(AppLanguage.allCases.contains(.polish))
+        #expect(AppLanguage.polish.rawValue == "pl")
+    }
+
+    @Test
+    func `app language catalog includes Arabic Persian and Thai`() {
+        #expect(AppLanguage.arabic.rawValue == "ar")
+        #expect(AppLanguage.persian.rawValue == "fa")
+        #expect(AppLanguage.thai.rawValue == "th")
+    }
+
+    @Test
+    func `new language bundles include representative native labels`() throws {
+        let root = URL(fileURLWithPath: #filePath)
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+        let resourcesURL = root.appendingPathComponent("Sources/CodexBar/Resources")
+        let expectations: [String: [String: String]] = [
+            "ar": [
+                "language_arabic": "العربية",
+                "tab_general": "عام",
+                "quit_app": "إنهاء CodexBar",
+                "usage_percent_suffix_left": "متبقٍ",
+            ],
+            "fa": [
+                "language_persian": "فارسی",
+                "tab_general": "عمومی",
+                "quit_app": "خروج از CodexBar",
+                "usage_percent_suffix_left": "باقی مانده",
+            ],
+            "th": [
+                "language_thai": "ไทย",
+                "tab_general": "ทั่วไป",
+                "quit_app": "ออกจาก CodexBar",
+                "usage_percent_suffix_left": "คงเหลือ",
+            ],
+        ]
+
+        for (locale, expectedValues) in expectations {
+            let url = resourcesURL.appendingPathComponent("\(locale).lproj/Localizable.strings")
+            let catalog = try #require(NSDictionary(contentsOf: url) as? [String: String])
+            for (key, expectedValue) in expectedValues {
+                #expect(catalog[key] == expectedValue, "\(locale).\(key)")
+            }
+        }
+    }
+
+    @Test
+    func `localized catalogs include every app language label`() throws {
+        #expect(self.languageKeys.count == AppLanguage.allCases.count)
+
+        let root = URL(fileURLWithPath: #filePath)
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+        let resourcesURL = root.appendingPathComponent("Sources/CodexBar/Resources")
+        let catalogs = try FileManager.default.contentsOfDirectory(
+            at: resourcesURL,
+            includingPropertiesForKeys: nil)
+            .filter { $0.pathExtension == "lproj" }
+
+        for catalogURL in catalogs {
+            let stringsURL = catalogURL.appendingPathComponent("Localizable.strings")
+            let contents = try String(contentsOf: stringsURL, encoding: .utf8)
+            for key in self.languageKeys {
+                #expect(contents.contains("\"\(key)\""), "Missing \(key) in \(catalogURL.lastPathComponent)")
+            }
+        }
+    }
+
+    @Test
+    func `localized catalogs include workday pace setting copy`() throws {
+        let root = URL(fileURLWithPath: #filePath)
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+        let resourcesURL = root.appendingPathComponent("Sources/CodexBar/Resources")
+        let catalogs = try FileManager.default.contentsOfDirectory(
+            at: resourcesURL,
+            includingPropertiesForKeys: nil)
+            .filter { $0.pathExtension == "lproj" }
+
+        for catalogURL in catalogs {
+            let stringsURL = catalogURL.appendingPathComponent("Localizable.strings")
+            let catalog = try #require(NSDictionary(contentsOf: stringsURL) as? [String: String])
+            let title = catalog["weekly_progress_work_days_title"]?.trimmingCharacters(in: .whitespacesAndNewlines)
+            let subtitle = catalog["weekly_progress_work_days_subtitle"]?
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+
+            #expect(title?.isEmpty == false, "Missing workday title in \(catalogURL.lastPathComponent)")
+            #expect(subtitle?.isEmpty == false, "Missing workday subtitle in \(catalogURL.lastPathComponent)")
+        }
+    }
+
+    @Test
+    func `ukrainian localization bundle exists and contains key UI labels`() throws {
+        let root = URL(fileURLWithPath: #filePath)
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+        let ukURL = root.appendingPathComponent("Sources/CodexBar/Resources/uk.lproj/Localizable.strings")
+        let contents = try String(contentsOf: ukURL, encoding: .utf8)
+
+        let requiredKeys = [
+            "\"language_title\"",
+            "\"language_subtitle\"",
+            "\"language_system\"",
+            "\"language_ukrainian\"",
+            "\"tab_general\"",
+            "\"quit_app\"",
+        ]
+        for key in requiredKeys {
+            #expect(contents.contains(key), "Missing localization key: \(key)")
+        }
+    }
+
+    @Test
+    func `korean localization bundle includes representative native labels`() throws {
+        let root = URL(fileURLWithPath: #filePath)
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+        let koURL = root.appendingPathComponent("Sources/CodexBar/Resources/ko.lproj/Localizable.strings")
+        let catalog = try #require(NSDictionary(contentsOf: koURL) as? [String: String])
+
+        #expect(catalog["language_korean"] == "한국어")
+        #expect(catalog["tab_general"] == "일반")
+        #expect(catalog["quota_warning_session"] == "세션")
+        #expect(catalog["quota_warning_warn_at"] == "경고 기준")
+        #expect(catalog["quit_app"] == "CodexBar 종료")
+    }
+
+    @Test
+    func `turkish localization matches English catalog and preserves format placeholders`() throws {
+        let root = URL(fileURLWithPath: #filePath)
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+        let resourcesURL = root.appendingPathComponent("Sources/CodexBar/Resources")
+        let enURL = resourcesURL.appendingPathComponent("en.lproj/Localizable.strings")
+        let trURL = resourcesURL.appendingPathComponent("tr.lproj/Localizable.strings")
+        let english = try #require(NSDictionary(contentsOf: enURL) as? [String: String])
+        let turkish = try #require(NSDictionary(contentsOf: trURL) as? [String: String])
+
+        #expect(Set(turkish.keys) == Set(english.keys))
+        #expect(turkish["language_turkish"] == "Türkçe")
+        #expect(turkish["tab_general"] == "Genel")
+        #expect(turkish["quit_app"] == "CodexBar'dan Çık")
+        #expect(turkish["display_mode_percent_desc"]?.contains("%45") == true)
+        #expect(turkish["session_depleted_notification_body"]?.hasPrefix("0% kaldı.") == true)
+
+        let format = try #require(turkish["quota_warning_notification_body"])
+        let rendered = String(
+            format: format,
+            locale: Locale(identifier: "tr_TR"),
+            arguments: ["%20", 15, "oturum"])
+        #expect(rendered.contains("15%"))
+        #expect(!rendered.contains("%2$d"))
+
+        let historyFormat = try #require(turkish["%@: %@%% used"])
+        let historyLabel = String(
+            format: historyFormat,
+            locale: Locale(identifier: "tr_TR"),
+            arguments: ["12 Haz", "45"])
+        #expect(historyLabel == "12 Haz: 45% kullanıldı")
+
+        let miniMaxFormat = try #require(turkish["minimax_used_percent_format"])
+        let miniMaxLabel = String(
+            format: miniMaxFormat,
+            locale: Locale(identifier: "tr_TR"),
+            arguments: ["45%"])
+        #expect(miniMaxLabel == "45% kullanıldı")
+    }
+
+    @Test
+    func `italian localization matches English catalog and includes current UI labels`() throws {
+        let root = URL(fileURLWithPath: #filePath)
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+        let resourcesURL = root.appendingPathComponent("Sources/CodexBar/Resources")
+        let enURL = resourcesURL.appendingPathComponent("en.lproj/Localizable.strings")
+        let itURL = resourcesURL.appendingPathComponent("it.lproj/Localizable.strings")
+        let english = try #require(NSDictionary(contentsOf: enURL) as? [String: String])
+        let italian = try #require(NSDictionary(contentsOf: itURL) as? [String: String])
+
+        #expect(Set(italian.keys) == Set(english.keys))
+        #expect(italian["Individual credits"] == "Crediti individuali")
+        #expect(italian["Workspace"] == "Spazio di lavoro")
+        #expect(italian["display_mode_reset_time"] == "Ora di reimpostazione")
+        #expect(italian["display_mode_reset_time_desc"]?.contains("↻ 15:56") == true)
+        #expect(italian["ory_session_…=…; csrftoken=…"] == "ory_session_…=…; csrftoken=…")
+        #expect(italian["quota_warning_notifications_subtitle"]?.contains("scende sotto") == true)
+        #expect(italian["metric_mistral_payg"] == "A consumo")
+        #expect(italian["metric_mistral_monthly_plan"] == "Piano mensile")
+
+        let intentionallyUnchanged: Set = [
+            "Account",
+            "Build",
+            "Chrome",
+            "Cookie: ...",
+            "Cookie: …",
+            "Deployment",
+            "Email",
+            "Endpoint",
+            "Gemini Flash",
+            "GitHub",
+            "Google OAuth",
+            "No",
+            "Oasis-Token",
+            "Password",
+            "Provider",
+            "Token",
+            "byte_unit_byte",
+            "byte_unit_gigabyte",
+            "byte_unit_kilobyte",
+            "byte_unit_megabyte",
+            "language_arabic",
+            "language_italian",
+            "language_persian",
+            "language_thai",
+            "link_email",
+            "link_github",
+            "ory_session_…=…; csrftoken=…",
+        ]
+        let unchanged = Set(english.keys.filter { italian[$0] == english[$0] })
+        #expect(unchanged == intentionallyUnchanged)
+
+        let warningFormat = try #require(italian["quota_warning_notification_body"])
+        let warning = String(
+            format: warningFormat,
+            locale: Locale(identifier: "it_IT"),
+            arguments: ["20%", 15, "settimanale"])
+        #expect(warning == "Rimane 20%. Hai raggiunto la soglia di avviso del 15% per la quota settimanale.")
+
+        let titleFormat = try #require(italian["quota_warning_notification_title"])
+        let title = String(
+            format: titleFormat,
+            locale: Locale(identifier: "it_IT"),
+            arguments: ["Codex", "settimanale"])
+        #expect(title == "Quota settimanale di Codex quasi esaurita")
+    }
+
+    @Test
+    func `indonesian localization matches English catalog and preserves format placeholders`() throws {
+        let root = URL(fileURLWithPath: #filePath)
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+        let resourcesURL = root.appendingPathComponent("Sources/CodexBar/Resources")
+        let enURL = resourcesURL.appendingPathComponent("en.lproj/Localizable.strings")
+        let idURL = resourcesURL.appendingPathComponent("id.lproj/Localizable.strings")
+        let english = try #require(NSDictionary(contentsOf: enURL) as? [String: String])
+        let indonesian = try #require(NSDictionary(contentsOf: idURL) as? [String: String])
+
+        #expect(Set(indonesian.keys) == Set(english.keys))
+        #expect(indonesian["language_indonesian"] == "Bahasa Indonesia")
+        #expect(indonesian["tab_general"] == "Umum")
+        #expect(indonesian["quit_app"] == "Keluar CodexBar")
+        #expect(indonesian["30d"] == "30 hari")
+        #expect(indonesian["On"] == "Aktif")
+        #expect(indonesian["Off"] == "Nonaktif")
+
+        let warningFormat = try #require(indonesian["quota_warning_notification_body"])
+        let warning = String(
+            format: warningFormat,
+            locale: Locale(identifier: "id_ID"),
+            arguments: ["20%", 15, "sesi"])
+        #expect(warning.contains("15%"))
+        #expect(!warning.contains("%2$d"))
+
+        let historyFormat = try #require(indonesian["%@: %@%% used"])
+        let historyLabel = String(
+            format: historyFormat,
+            locale: Locale(identifier: "id_ID"),
+            arguments: ["12 Jun", "45"])
+        #expect(historyLabel == "12 Jun: 45% terpakai")
+
+        let daysFormat = try #require(indonesian["%dd"])
+        let daysLabel = String(
+            format: daysFormat,
+            locale: Locale(identifier: "id_ID"),
+            arguments: [30])
+        #expect(daysLabel == "30 hari")
+    }
+
+    @Test
+    func `polish localization matches English catalog and includes current UI labels`() throws {
+        let root = URL(fileURLWithPath: #filePath)
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+        let resourcesURL = root.appendingPathComponent("Sources/CodexBar/Resources")
+        let enURL = resourcesURL.appendingPathComponent("en.lproj/Localizable.strings")
+        let plURL = resourcesURL.appendingPathComponent("pl.lproj/Localizable.strings")
+        let english = try #require(NSDictionary(contentsOf: enURL) as? [String: String])
+        let polish = try #require(NSDictionary(contentsOf: plURL) as? [String: String])
+
+        #expect(Set(polish.keys) == Set(english.keys))
+        #expect(polish["Individual credits"] == "Kredyty indywidualne")
+        #expect(polish["Workspace"] == "Obszar roboczy")
+        #expect(polish["display_mode_reset_time"] == "Godzina resetu")
+        #expect(polish["display_mode_reset_time_desc"]?.contains("↻ 15:56") == true)
+    }
+
+    @Test
+    func `japanese usage chart accessibility text preserves argument meanings`() throws {
+        let root = URL(fileURLWithPath: #filePath)
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+        let jaURL = root.appendingPathComponent("Sources/CodexBar/Resources/ja.lproj/Localizable.strings")
+        let catalog = try #require(NSDictionary(contentsOf: jaURL) as? [String: String])
+        let format = try #require(catalog["%d days of usage data across %d services"])
+
+        let rendered = String(
+            format: format,
+            locale: Locale(identifier: "ja_JP"),
+            arguments: [7, 3])
+
+        #expect(rendered.contains("7日間"))
+        #expect(rendered.contains("3サービス"))
+    }
+
+    @Test
+    func `korean usage chart accessibility text preserves argument meanings`() throws {
+        let root = URL(fileURLWithPath: #filePath)
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+        let koURL = root.appendingPathComponent("Sources/CodexBar/Resources/ko.lproj/Localizable.strings")
+        let catalog = try #require(NSDictionary(contentsOf: koURL) as? [String: String])
+        let format = try #require(catalog["%d days of usage data across %d services"])
+
+        let rendered = String(
+            format: format,
+            locale: Locale(identifier: "ko_KR"),
+            arguments: [7, 3])
+
+        #expect(rendered.contains("7일간"))
+        #expect(rendered.contains("3개 서비스"))
+    }
+}
diff --git a/Tests/CodexBarTests/LoginNotificationLogicTests.swift b/Tests/CodexBarTests/LoginNotificationLogicTests.swift
new file mode 100644
index 0000000000..68f4ab9111
--- /dev/null
+++ b/Tests/CodexBarTests/LoginNotificationLogicTests.swift
@@ -0,0 +1,19 @@
+import Testing
+@testable import CodexBar
+
+@Suite(.serialized)
+struct LoginNotificationLogicTests {
+    @Test
+    func `login success notification copy follows Traditional Chinese app language`() {
+        Self.withAppLanguage("zh-Hant") {
+            let copy = LoginNotificationLogic.notificationCopy(providerName: "Codex")
+
+            #expect(copy.title == "Codex 登入成功")
+            #expect(copy.body == "你可以回到 App；認證已完成。")
+        }
+    }
+
+    private static func withAppLanguage(_ language: String, perform body: () -> Void) {
+        CodexBarLocalizationOverride.$appLanguage.withValue(language, operation: body)
+    }
+}
diff --git a/Tests/CodexBarTests/MainThreadHangWatchdogTests.swift b/Tests/CodexBarTests/MainThreadHangWatchdogTests.swift
new file mode 100644
index 0000000000..ed18749e94
--- /dev/null
+++ b/Tests/CodexBarTests/MainThreadHangWatchdogTests.swift
@@ -0,0 +1,196 @@
+import Foundation
+import Testing
+@testable import CodexBar
+
+#if DEBUG
+@Suite(.serialized)
+struct MainThreadHangWatchdogTests {
+    @MainActor
+    @Test
+    func `breadcrumb tracks nested activity`() {
+        #expect(MainThreadActivityBreadcrumb.current == nil)
+        MainThreadActivityBreadcrumb.push("outer")
+        MainThreadActivityBreadcrumb.push("inner")
+        #expect(MainThreadActivityBreadcrumb.current == "inner")
+        MainThreadActivityBreadcrumb.pop()
+        #expect(MainThreadActivityBreadcrumb.current == "outer")
+        MainThreadActivityBreadcrumb.pop()
+        #expect(MainThreadActivityBreadcrumb.current == nil)
+    }
+
+    @Test
+    func `watchdog reports a breadcrumb for a delayed main thread response`() throws {
+        let watchdog = MainThreadHangWatchdog(
+            pingInterval: 0.01,
+            hangThreshold: 0.05,
+            sampleThreshold: 60,
+            sampleCooldown: 3600)
+
+        let reported = OSAllocatedBox<[(TimeInterval, [String])]>([])
+        watchdog.onHangForTesting = { duration, activities in
+            reported.append((duration, activities))
+        }
+
+        MainThreadActivityBreadcrumb.push("testStall")
+        watchdog.traceHangForTesting(responseDelay: 0.25)
+        MainThreadActivityBreadcrumb.pop()
+
+        let report = try #require(reported.get().first)
+        #expect(report.1.contains("testStall"))
+        #expect(report.0 >= 0.05)
+    }
+
+    @Test
+    func `watchdog polling loop reports a delayed ping response`() {
+        let pingScheduled = DispatchSemaphore(value: 0)
+        let hangDetected = DispatchSemaphore(value: 0)
+        let reported = DispatchSemaphore(value: 0)
+        let pendingResponse = OSAllocatedBox<(@Sendable () -> Void)?>(nil)
+        let watchdog = MainThreadHangWatchdog(
+            pingInterval: 1,
+            hangThreshold: 0.02,
+            sampleThreshold: 60,
+            sampleCooldown: 3600,
+            schedulePing: { response in
+                pendingResponse.set(response)
+                pingScheduled.signal()
+            })
+        watchdog.onHangForTesting = { _, _ in
+            reported.signal()
+        }
+        watchdog.onHangDetectionForTesting = {
+            hangDetected.signal()
+        }
+
+        watchdog.start()
+        defer { watchdog.stop() }
+
+        #expect(pingScheduled.wait(timeout: .now() + 10) == .success)
+        #expect(hangDetected.wait(timeout: .now() + 10) == .success)
+        pendingResponse.get()?()
+        #expect(reported.wait(timeout: .now() + 10) == .success)
+    }
+
+    @Test
+    func `sample capture cannot inflate reported hang duration`() throws {
+        let sampleRequested = OSAllocatedBox(false)
+        let watchdog = MainThreadHangWatchdog(
+            pingInterval: 0.01,
+            hangThreshold: 0.03,
+            sampleThreshold: 0.05,
+            sampleCooldown: 3600,
+            sampleCaptureOverride: {
+                sampleRequested.set(true)
+                Thread.sleep(forTimeInterval: 1)
+                return "/tmp/codexbar-watchdog-test-sample.txt"
+            })
+
+        let reported = OSAllocatedBox<[(TimeInterval, [String])]>([])
+        watchdog.onHangForTesting = { duration, activities in
+            reported.append((duration, activities))
+        }
+
+        MainThreadActivityBreadcrumb.push("sampledStall")
+        watchdog.traceHangForTesting(responseDelay: 0.05, waitForSampleAttempt: true)
+        MainThreadActivityBreadcrumb.pop()
+
+        let report = try #require(reported.get().first)
+        #expect(sampleRequested.get())
+        #expect(report.1.contains("sampledStall"))
+        #expect(report.0 >= 0.03)
+        #expect(report.0 < 0.75)
+    }
+
+    @Test
+    func `failed sample capture is attempted once per hang`() {
+        let attempts = OSAllocatedBox(0)
+        let watchdog = MainThreadHangWatchdog(
+            pingInterval: 0.01,
+            hangThreshold: 0.01,
+            sampleThreshold: 0,
+            sampleCooldown: 3600,
+            sampleCaptureOverride: {
+                attempts.withValue { $0 += 1 }
+                return nil
+            })
+
+        watchdog.traceHangForTesting(responseDelay: 0.05, waitForSampleAttempt: true)
+
+        #expect(attempts.get() == 1)
+    }
+
+    @Test
+    func `missed sample window does not consume cooldown`() {
+        let attempts = OSAllocatedBox(0)
+        let watchdog = MainThreadHangWatchdog(
+            pingInterval: 0.01,
+            hangThreshold: 0.01,
+            sampleThreshold: 0.02,
+            sampleCooldown: 3600,
+            sampleCaptureOverride: {
+                attempts.withValue { $0 += 1 }
+                return nil
+            })
+
+        watchdog.traceHangForTesting(responseDelay: 0.05, responseBeforeTrace: true)
+        #expect(attempts.get() == 0)
+
+        watchdog.traceHangForTesting(responseDelay: 0.05, waitForSampleAttempt: true)
+        #expect(attempts.get() == 1)
+    }
+
+    @Test
+    func `cooldown blocked hang samples when cooldown expires`() {
+        let attempts = OSAllocatedBox(0)
+        let watchdog = MainThreadHangWatchdog(
+            pingInterval: 0.01,
+            hangThreshold: 0.01,
+            sampleThreshold: 0,
+            sampleCooldown: 0.2,
+            sampleCaptureOverride: {
+                attempts.withValue { $0 += 1 }
+                return nil
+            })
+
+        watchdog.traceHangForTesting(responseDelay: 0.05, waitForSampleAttempt: true)
+        watchdog.traceHangForTesting(responseDelay: 1)
+
+        #expect(attempts.get() == 2)
+    }
+}
+#endif
+
+private final class OSAllocatedBox<T>: @unchecked Sendable {
+    private let lock = NSLock()
+    private var value: T
+
+    init(_ value: T) {
+        self.value = value
+    }
+
+    func set(_ newValue: T) {
+        self.lock.lock()
+        self.value = newValue
+        self.lock.unlock()
+    }
+
+    func get() -> T {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        return self.value
+    }
+}
+
+extension OSAllocatedBox {
+    func append<Element>(_ element: Element) where T == [Element] {
+        self.lock.lock()
+        self.value.append(element)
+        self.lock.unlock()
+    }
+
+    func withValue(_ body: (inout T) -> Void) {
+        self.lock.lock()
+        body(&self.value)
+        self.lock.unlock()
+    }
+}
diff --git a/Tests/CodexBarTests/ManagedCodexAccountCoordinatorTests.swift b/Tests/CodexBarTests/ManagedCodexAccountCoordinatorTests.swift
new file mode 100644
index 0000000000..9e042d7ebb
--- /dev/null
+++ b/Tests/CodexBarTests/ManagedCodexAccountCoordinatorTests.swift
@@ -0,0 +1,157 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@Suite(.serialized)
+@MainActor
+struct ManagedCodexAccountCoordinatorTests {
+    @Test
+    func `coordinator exposes in flight state and rejects overlapping managed authentication`() async throws {
+        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let existingAccountID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-111111111111"))
+        let runner = BlockingManagedCodexLoginRunner()
+        let service = ManagedCodexAccountService(
+            store: InMemoryManagedCodexAccountStoreForCoordinatorTests(
+                accounts: ManagedCodexAccountSet(version: 1, accounts: [])),
+            homeFactory: CoordinatorTestManagedCodexHomeFactory(root: root),
+            loginRunner: runner,
+            identityReader: CoordinatorStubManagedCodexIdentityReader(email: "user@example.com"))
+        let coordinator = ManagedCodexAccountCoordinator(service: service)
+
+        let authTask = Task { try await coordinator.authenticateManagedAccount(existingAccountID: existingAccountID) }
+        await runner.waitUntilStarted()
+
+        #expect(coordinator.isAuthenticatingManagedAccount)
+        #expect(coordinator.authenticatingManagedAccountID == existingAccountID)
+
+        await #expect(throws: ManagedCodexAccountCoordinatorError.authenticationInProgress) {
+            try await coordinator.authenticateManagedAccount()
+        }
+
+        await runner.resume()
+        let account = try await authTask.value
+
+        #expect(account.email == "user@example.com")
+        #expect(coordinator.isAuthenticatingManagedAccount == false)
+        #expect(coordinator.authenticatingManagedAccountID == nil)
+    }
+
+    @Test
+    func `coordinator clears in flight state after managed login timeout`() async throws {
+        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let loginResult = CodexLoginRunner.Result(outcome: .timedOut, output: "timed out")
+        let existingAccountID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-222222222222"))
+        let service = ManagedCodexAccountService(
+            store: InMemoryManagedCodexAccountStoreForCoordinatorTests(
+                accounts: ManagedCodexAccountSet(version: 1, accounts: [])),
+            homeFactory: CoordinatorTestManagedCodexHomeFactory(root: root),
+            loginRunner: TimedOutManagedCodexLoginRunner(result: loginResult),
+            identityReader: CoordinatorStubManagedCodexIdentityReader(email: "user@example.com"))
+        let coordinator = ManagedCodexAccountCoordinator(service: service)
+
+        do {
+            _ = try await coordinator.authenticateManagedAccount(existingAccountID: existingAccountID, timeout: 0.2)
+            Issue.record("Expected managed login timeout to throw")
+        } catch let error as ManagedCodexAccountServiceError {
+            #expect(error == .loginFailed(loginResult))
+        } catch {
+            Issue.record("Expected ManagedCodexAccountServiceError.loginFailed, got \(error)")
+        }
+
+        #expect(coordinator.isAuthenticatingManagedAccount == false)
+        #expect(coordinator.authenticatingManagedAccountID == nil)
+    }
+}
+
+private actor BlockingManagedCodexLoginRunner: ManagedCodexLoginRunning {
+    private var waiters: [CheckedContinuation<CodexLoginRunner.Result, Never>] = []
+    private var startedWaiters: [CheckedContinuation<Void, Never>] = []
+    private var didStart = false
+
+    func run(homePath _: String, timeout _: TimeInterval) async -> CodexLoginRunner.Result {
+        self.didStart = true
+        self.startedWaiters.forEach { $0.resume() }
+        self.startedWaiters.removeAll()
+        return await withCheckedContinuation { continuation in
+            self.waiters.append(continuation)
+        }
+    }
+
+    func waitUntilStarted() async {
+        if self.didStart { return }
+        await withCheckedContinuation { continuation in
+            self.startedWaiters.append(continuation)
+        }
+    }
+
+    func resume() {
+        let result = CodexLoginRunner.Result(outcome: .success, output: "ok")
+        self.waiters.forEach { $0.resume(returning: result) }
+        self.waiters.removeAll()
+    }
+}
+
+private struct TimedOutManagedCodexLoginRunner: ManagedCodexLoginRunning {
+    let result: CodexLoginRunner.Result
+
+    func run(homePath _: String, timeout _: TimeInterval) async -> CodexLoginRunner.Result {
+        self.result
+    }
+}
+
+private final class InMemoryManagedCodexAccountStoreForCoordinatorTests: ManagedCodexAccountStoring,
+@unchecked Sendable {
+    var snapshot: ManagedCodexAccountSet
+
+    init(accounts: ManagedCodexAccountSet) {
+        self.snapshot = accounts
+    }
+
+    func loadAccounts() throws -> ManagedCodexAccountSet {
+        self.snapshot
+    }
+
+    func storeAccounts(_ accounts: ManagedCodexAccountSet) throws {
+        self.snapshot = accounts
+    }
+
+    func ensureFileExists() throws -> URL {
+        FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+    }
+}
+
+private final class CoordinatorTestManagedCodexHomeFactory: ManagedCodexHomeProducing, @unchecked Sendable {
+    let root: URL
+
+    init(root: URL) {
+        self.root = root
+    }
+
+    func makeHomeURL() -> URL {
+        self.root.appendingPathComponent(UUID().uuidString, isDirectory: true)
+    }
+
+    func validateManagedHomeForDeletion(_ url: URL) throws {
+        try ManagedCodexHomeFactory(root: self.root).validateManagedHomeForDeletion(url)
+    }
+}
+
+private final class CoordinatorStubManagedCodexIdentityReader: ManagedCodexIdentityReading, @unchecked Sendable {
+    let email: String
+
+    init(email: String) {
+        self.email = email
+    }
+
+    func loadAccountIdentity(homePath _: String) throws -> CodexAuthBackedAccount {
+        CodexAuthBackedAccount(
+            identity: CodexIdentityResolver.resolve(accountId: nil, email: self.email),
+            email: self.email,
+            plan: "Pro")
+    }
+}
diff --git a/Tests/CodexBarTests/ManagedCodexAccountServiceTests.swift b/Tests/CodexBarTests/ManagedCodexAccountServiceTests.swift
new file mode 100644
index 0000000000..44ba8a5e1a
--- /dev/null
+++ b/Tests/CodexBarTests/ManagedCodexAccountServiceTests.swift
@@ -0,0 +1,958 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@Suite(.serialized)
+@MainActor
+struct ManagedCodexAccountServiceTests {
+    @Test
+    func `upsert preserves uuid for matching canonical email`() async throws {
+        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let fileURL = root.appendingPathComponent("managed.json", isDirectory: false)
+        let store = FileManagedCodexAccountStore(fileURL: fileURL, fileManager: .default)
+        let service = ManagedCodexAccountService(
+            store: store,
+            homeFactory: TestManagedCodexHomeFactory(root: root),
+            loginRunner: StubManagedCodexLoginRunner.success,
+            identityReader: StubManagedCodexIdentityReader.accounts([
+                .init(identity: .providerAccount(id: "account-live"), email: "user@example.com", plan: "Pro"),
+                .init(identity: .providerAccount(id: "account-live"), email: "user@example.com", plan: "Pro"),
+            ]),
+            workspaceResolver: StubManagedCodexWorkspaceResolver())
+
+        let first = try await service.authenticateManagedAccount()
+        let second = try await service.authenticateManagedAccount()
+        let snapshot = try store.loadAccounts()
+
+        #expect(first.id == second.id)
+        #expect(second.email == "user@example.com")
+        #expect(second.providerAccountID == "account-live")
+        #expect(snapshot.accounts.count == 1)
+        #expect(second.managedHomePath.hasPrefix(root.standardizedFileURL.path + "/"))
+    }
+
+    @Test
+    func `new authentication appends managed account without implicit selection side effect`() async throws {
+        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let firstID = try #require(UUID(uuidString: "11111111-1111-1111-1111-111111111111"))
+        let firstAccount = ManagedCodexAccount(
+            id: firstID,
+            email: "first@example.com",
+            managedHomePath: root.appendingPathComponent("accounts/first", isDirectory: true).path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let store = InMemoryManagedCodexAccountStore(
+            accounts: ManagedCodexAccountSet(
+                version: 1,
+                accounts: [firstAccount]))
+        let service = ManagedCodexAccountService(
+            store: store,
+            homeFactory: TestManagedCodexHomeFactory(root: root),
+            loginRunner: StubManagedCodexLoginRunner.success,
+            identityReader: StubManagedCodexIdentityReader.accounts([
+                .init(identity: .providerAccount(id: "account-second"), email: "second@example.com", plan: "Pro"),
+            ]),
+            workspaceResolver: StubManagedCodexWorkspaceResolver())
+
+        let authenticated = try await service.authenticateManagedAccount()
+
+        #expect(store.snapshot.accounts.count == 2)
+        #expect(authenticated.email == "second@example.com")
+        #expect(authenticated.providerAccountID == "account-second")
+    }
+
+    @Test
+    func `same email provider backed workspaces coexist across sequential add account flows`() async throws {
+        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let store = InMemoryManagedCodexAccountStore(
+            accounts: ManagedCodexAccountSet(
+                version: FileManagedCodexAccountStore.currentVersion,
+                accounts: []))
+        let service = ManagedCodexAccountService(
+            store: store,
+            homeFactory: TestManagedCodexHomeFactory(root: root),
+            loginRunner: StubManagedCodexLoginRunner.success,
+            identityReader: StubManagedCodexIdentityReader.accounts([
+                .init(identity: .providerAccount(id: "workspace-personal"), email: "alice@example.com", plan: "Pro"),
+                .init(identity: .providerAccount(id: "workspace-team"), email: "alice@example.com", plan: "Pro"),
+            ]),
+            workspaceResolver: StubManagedCodexWorkspaceResolver(identities: [
+                "workspace-personal": CodexOpenAIWorkspaceIdentity(
+                    workspaceAccountID: "workspace-personal",
+                    workspaceLabel: "Personal"),
+                "workspace-team": CodexOpenAIWorkspaceIdentity(
+                    workspaceAccountID: "workspace-team",
+                    workspaceLabel: "Team"),
+            ]))
+
+        let personal = try await service.authenticateManagedAccount()
+        let team = try await service.authenticateManagedAccount()
+
+        let storedPersonal = try #require(
+            store.snapshot.account(email: "alice@example.com", providerAccountID: "workspace-personal"))
+        let storedTeam = try #require(
+            store.snapshot.account(email: "alice@example.com", providerAccountID: "workspace-team"))
+        #expect(store.snapshot.accounts.count == 2)
+        #expect(personal.id == storedPersonal.id)
+        #expect(team.id == storedTeam.id)
+        #expect(personal.id != team.id)
+        #expect(storedPersonal.providerAccountID == "workspace-personal")
+        #expect(storedPersonal.workspaceLabel == "Personal")
+        #expect(storedTeam.providerAccountID == "workspace-team")
+        #expect(storedTeam.workspaceLabel == "Team")
+        #expect(storedPersonal.managedHomePath != storedTeam.managedHomePath)
+        #expect(FileManager.default.fileExists(atPath: storedPersonal.managedHomePath))
+        #expect(FileManager.default.fileExists(atPath: storedTeam.managedHomePath))
+    }
+
+    @Test
+    func `same workspace provider id with different emails does not overwrite existing account`() async throws {
+        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        let existingHome = root.appendingPathComponent("accounts/existing", isDirectory: true)
+        try FileManager.default.createDirectory(at: existingHome, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let existingID = try #require(UUID(uuidString: "10101010-2020-3030-4040-505050505050"))
+        let existingAccount = ManagedCodexAccount(
+            id: existingID,
+            email: "mi.chaelfmk5542@gmail.com",
+            providerAccountID: "team-4107",
+            workspaceLabel: "4107",
+            workspaceAccountID: "team-4107",
+            managedHomePath: existingHome.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let store = InMemoryManagedCodexAccountStore(
+            accounts: ManagedCodexAccountSet(
+                version: FileManagedCodexAccountStore.currentVersion,
+                accounts: [existingAccount]))
+        let service = ManagedCodexAccountService(
+            store: store,
+            homeFactory: TestManagedCodexHomeFactory(root: root),
+            loginRunner: StubManagedCodexLoginRunner.success,
+            identityReader: StubManagedCodexIdentityReader.accounts([
+                .init(identity: .providerAccount(id: "team-4107"), email: "mich.aelfmk5542@gmail.com", plan: "Team"),
+            ]),
+            workspaceResolver: StubManagedCodexWorkspaceResolver(identities: [
+                "team-4107": CodexOpenAIWorkspaceIdentity(
+                    workspaceAccountID: "team-4107",
+                    workspaceLabel: "4107"),
+            ]))
+
+        let added = try await service.authenticateManagedAccount()
+
+        let original = try #require(
+            store.snapshot.account(email: "mi.chaelfmk5542@gmail.com", providerAccountID: "team-4107"))
+        let newAccount = try #require(
+            store.snapshot.account(email: "mich.aelfmk5542@gmail.com", providerAccountID: "team-4107"))
+        #expect(store.snapshot.accounts.count == 2)
+        #expect(original.id == existingID)
+        #expect(original.managedHomePath == existingHome.path)
+        #expect(newAccount.id == added.id)
+        #expect(newAccount.id != existingID)
+        #expect(newAccount.workspaceLabel == "4107")
+        #expect(FileManager.default.fileExists(atPath: existingHome.path))
+        #expect(FileManager.default.fileExists(atPath: newAccount.managedHomePath))
+    }
+
+    @Test
+    func `selected workspace is persisted and used as account identity`() async throws {
+        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let store = InMemoryManagedCodexAccountStore(
+            accounts: ManagedCodexAccountSet(
+                version: FileManagedCodexAccountStore.currentVersion,
+                accounts: []))
+        let workspaces = [
+            CodexOpenAIWorkspaceIdentity(
+                workspaceAccountID: "workspace-personal",
+                workspaceLabel: "Personal"),
+            CodexOpenAIWorkspaceIdentity(
+                workspaceAccountID: "workspace-team",
+                workspaceLabel: "Team"),
+        ]
+        let service = ManagedCodexAccountService(
+            store: store,
+            homeFactory: TestManagedCodexHomeFactory(root: root),
+            loginRunner: WritingManagedCodexLoginRunner(
+                credentials: CodexOAuthCredentials(
+                    accessToken: "access-token",
+                    refreshToken: "refresh-token",
+                    idToken: nil,
+                    accountId: "workspace-personal",
+                    lastRefresh: nil)),
+            identityReader: StubManagedCodexIdentityReader.accounts([
+                .init(identity: .providerAccount(id: "workspace-personal"), email: "alice@example.com", plan: "Pro"),
+            ]),
+            workspaceResolver: StubManagedCodexWorkspaceResolver(
+                identities: Dictionary(uniqueKeysWithValues: workspaces.map { ($0.workspaceAccountID, $0) }),
+                availableIdentities: workspaces),
+            workspaceSelector: StubManagedCodexWorkspaceSelector(selectedWorkspaceID: "workspace-team"))
+
+        let account = try await service.authenticateManagedAccount()
+        let credentials = try CodexOAuthCredentialsStore.load(env: ["CODEX_HOME": account.managedHomePath])
+
+        #expect(account.providerAccountID == "workspace-team")
+        #expect(account.workspaceLabel == "Team")
+        #expect(credentials.accountId == "workspace-team")
+        #expect(store.snapshot.accounts.count == 1)
+    }
+
+    @Test
+    func `reauth keeps previous home when store write fails`() async throws {
+        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        let existingHome = root.appendingPathComponent("accounts/existing", isDirectory: true)
+        try FileManager.default.createDirectory(at: existingHome, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let existingAccountID = try #require(UUID(uuidString: "11111111-2222-3333-4444-555555555555"))
+        let existingAccount = ManagedCodexAccount(
+            id: existingAccountID,
+            email: "user@example.com",
+            managedHomePath: existingHome.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let store = FailingManagedCodexAccountStore(
+            accounts: ManagedCodexAccountSet(
+                version: 1,
+                accounts: [existingAccount]))
+        let service = ManagedCodexAccountService(
+            store: store,
+            homeFactory: TestManagedCodexHomeFactory(root: root),
+            loginRunner: StubManagedCodexLoginRunner.success,
+            identityReader: StubManagedCodexIdentityReader.accounts([
+                .init(identity: .providerAccount(id: "account-live"), email: "user@example.com", plan: "Pro"),
+            ]),
+            workspaceResolver: StubManagedCodexWorkspaceResolver())
+
+        await #expect(throws: TestManagedCodexAccountStoreError.writeFailed) {
+            try await service.authenticateManagedAccount()
+        }
+
+        let newHome = root.appendingPathComponent("accounts/account-1", isDirectory: true)
+        #expect(FileManager.default.fileExists(atPath: existingHome.path))
+        #expect(FileManager.default.fileExists(atPath: newHome.path) == false)
+        #expect(store.snapshot.accounts.count == 1)
+        #expect(store.snapshot.accounts.first?.managedHomePath == existingHome.path)
+    }
+
+    @Test
+    func `reauth reconciles by provider account id before existing account id`() async throws {
+        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        let alphaHome = root.appendingPathComponent("accounts/alpha", isDirectory: true)
+        let betaHome = root.appendingPathComponent("accounts/beta", isDirectory: true)
+        try FileManager.default.createDirectory(at: alphaHome, withIntermediateDirectories: true)
+        try FileManager.default.createDirectory(at: betaHome, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let alphaID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-111111111111"))
+        let betaID = try #require(UUID(uuidString: "BBBBBBBB-CCCC-DDDD-EEEE-222222222222"))
+        let alphaAccount = ManagedCodexAccount(
+            id: alphaID,
+            email: "shared@example.com",
+            providerAccountID: "account-alpha",
+            managedHomePath: alphaHome.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let betaAccount = ManagedCodexAccount(
+            id: betaID,
+            email: "shared@example.com",
+            providerAccountID: "account-beta",
+            managedHomePath: betaHome.path,
+            createdAt: 2,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let store = InMemoryManagedCodexAccountStore(
+            accounts: ManagedCodexAccountSet(
+                version: 1,
+                accounts: [alphaAccount, betaAccount]))
+        let service = ManagedCodexAccountService(
+            store: store,
+            homeFactory: TestManagedCodexHomeFactory(root: root),
+            loginRunner: StubManagedCodexLoginRunner.success,
+            identityReader: StubManagedCodexIdentityReader.accounts([
+                .init(identity: .providerAccount(id: "account-beta"), email: "SHARED@example.com", plan: "Pro"),
+            ]),
+            workspaceResolver: StubManagedCodexWorkspaceResolver())
+
+        let account = try await service.authenticateManagedAccount(existingAccountID: alphaAccount.id)
+
+        let storedAlpha = try #require(store.snapshot.account(id: alphaAccount.id))
+        let storedBeta = try #require(store.snapshot.account(id: betaAccount.id))
+        #expect(account.id == betaAccount.id)
+        #expect(store.snapshot.accounts.count == 2)
+        #expect(storedAlpha.email == "shared@example.com")
+        #expect(storedAlpha.providerAccountID == "account-alpha")
+        #expect(storedAlpha.managedHomePath == alphaHome.path)
+        #expect(storedBeta.email == "shared@example.com")
+        #expect(storedBeta.providerAccountID == "account-beta")
+        #expect(storedBeta.managedHomePath.hasPrefix(root.standardizedFileURL.path + "/"))
+        #expect(storedBeta.managedHomePath != betaHome.path)
+        #expect(FileManager.default.fileExists(atPath: alphaHome.path))
+        #expect(FileManager.default.fileExists(atPath: betaHome.path) == false)
+        #expect(FileManager.default.fileExists(atPath: storedBeta.managedHomePath))
+    }
+
+    @Test
+    func `reauth to different account does not overwrite existing account id match`() async throws {
+        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        let aliceHome = root.appendingPathComponent("accounts/alice", isDirectory: true)
+        try FileManager.default.createDirectory(at: aliceHome, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let aliceID = try #require(UUID(uuidString: "12121212-3434-5656-7878-909090909090"))
+        let aliceAccount = ManagedCodexAccount(
+            id: aliceID,
+            email: "alice@example.com",
+            providerAccountID: "account-alice",
+            managedHomePath: aliceHome.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let store = InMemoryManagedCodexAccountStore(accounts: ManagedCodexAccountSet(
+            version: FileManagedCodexAccountStore.currentVersion,
+            accounts: [aliceAccount]))
+        let service = ManagedCodexAccountService(
+            store: store,
+            homeFactory: TestManagedCodexHomeFactory(root: root),
+            loginRunner: StubManagedCodexLoginRunner.success,
+            identityReader: StubManagedCodexIdentityReader.accounts([
+                .init(identity: .providerAccount(id: "account-bob"), email: "bob@example.com", plan: "Pro"),
+            ]),
+            workspaceResolver: StubManagedCodexWorkspaceResolver())
+
+        let account = try await service.authenticateManagedAccount(existingAccountID: aliceID)
+
+        let storedAlice = try #require(store.snapshot.account(id: aliceID))
+        let storedBob = try #require(store.snapshot.account(email: "bob@example.com"))
+        #expect(account.id != aliceID)
+        #expect(account.id == storedBob.id)
+        #expect(store.snapshot.accounts.count == 2)
+        #expect(storedAlice.email == "alice@example.com")
+        #expect(storedAlice.providerAccountID == "account-alice")
+        #expect(storedAlice.managedHomePath == aliceHome.path)
+        #expect(storedBob.email == "bob@example.com")
+        #expect(storedBob.providerAccountID == "account-bob")
+        #expect(storedBob.managedHomePath.hasPrefix(root.standardizedFileURL.path + "/"))
+        #expect(storedBob.managedHomePath != aliceHome.path)
+        #expect(FileManager.default.fileExists(atPath: aliceHome.path))
+        #expect(FileManager.default.fileExists(atPath: storedBob.managedHomePath))
+    }
+
+    @Test
+    func `reauth on same email different workspace does not overwrite selected workspace`() async throws {
+        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        let personalHome = root.appendingPathComponent("accounts/personal", isDirectory: true)
+        try FileManager.default.createDirectory(at: personalHome, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let personalID = try #require(UUID(uuidString: "31313131-4242-5353-6464-757575757575"))
+        let personalAccount = ManagedCodexAccount(
+            id: personalID,
+            email: "alice@example.com",
+            providerAccountID: "workspace-personal",
+            workspaceLabel: "Personal",
+            workspaceAccountID: "workspace-personal",
+            managedHomePath: personalHome.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let store = InMemoryManagedCodexAccountStore(accounts: ManagedCodexAccountSet(
+            version: FileManagedCodexAccountStore.currentVersion,
+            accounts: [personalAccount]))
+        let service = ManagedCodexAccountService(
+            store: store,
+            homeFactory: TestManagedCodexHomeFactory(root: root),
+            loginRunner: StubManagedCodexLoginRunner.success,
+            identityReader: StubManagedCodexIdentityReader.accounts([
+                .init(identity: .providerAccount(id: "workspace-team"), email: "alice@example.com", plan: "Pro"),
+            ]),
+            workspaceResolver: StubManagedCodexWorkspaceResolver(identities: [
+                "workspace-team": CodexOpenAIWorkspaceIdentity(
+                    workspaceAccountID: "workspace-team",
+                    workspaceLabel: "Team"),
+            ]))
+
+        let account = try await service.authenticateManagedAccount(existingAccountID: personalID)
+
+        let storedPersonal = try #require(store.snapshot.account(id: personalID))
+        let storedTeam = try #require(
+            store.snapshot.account(email: "alice@example.com", providerAccountID: "workspace-team"))
+        #expect(account.id == storedTeam.id)
+        #expect(account.id != personalID)
+        #expect(store.snapshot.accounts.count == 2)
+        #expect(storedPersonal.providerAccountID == "workspace-personal")
+        #expect(storedPersonal.workspaceLabel == "Personal")
+        #expect(storedPersonal.managedHomePath == personalHome.path)
+        #expect(storedTeam.providerAccountID == "workspace-team")
+        #expect(storedTeam.workspaceLabel == "Team")
+        #expect(storedTeam.managedHomePath != personalHome.path)
+        #expect(FileManager.default.fileExists(atPath: personalHome.path))
+        #expect(FileManager.default.fileExists(atPath: storedTeam.managedHomePath))
+    }
+
+    @Test
+    func `legacy row collapses onto provider backed row when provider id resolves elsewhere`() async throws {
+        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        let legacyHome = root.appendingPathComponent("accounts/legacy", isDirectory: true)
+        let providerHome = root.appendingPathComponent("accounts/provider", isDirectory: true)
+        try FileManager.default.createDirectory(at: legacyHome, withIntermediateDirectories: true)
+        try FileManager.default.createDirectory(at: providerHome, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let legacyID = try #require(UUID(uuidString: "AAAAAAAA-1111-2222-3333-444444444444"))
+        let providerID = try #require(UUID(uuidString: "BBBBBBBB-1111-2222-3333-444444444444"))
+        let legacyAccount = ManagedCodexAccount(
+            id: legacyID,
+            email: "shared@example.com",
+            managedHomePath: legacyHome.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let providerAccount = ManagedCodexAccount(
+            id: providerID,
+            email: "shared@example.com",
+            providerAccountID: "account-real",
+            managedHomePath: providerHome.path,
+            createdAt: 2,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let store = InMemoryManagedCodexAccountStore(accounts: ManagedCodexAccountSet(
+            version: FileManagedCodexAccountStore.currentVersion,
+            accounts: [legacyAccount, providerAccount]))
+        let service = ManagedCodexAccountService(
+            store: store,
+            homeFactory: TestManagedCodexHomeFactory(root: root),
+            loginRunner: StubManagedCodexLoginRunner.success,
+            identityReader: StubManagedCodexIdentityReader.accounts([
+                .init(identity: .providerAccount(id: "account-real"), email: "shared@example.com", plan: "Pro"),
+            ]),
+            workspaceResolver: StubManagedCodexWorkspaceResolver())
+
+        let account = try await service.authenticateManagedAccount(existingAccountID: legacyAccount.id)
+
+        #expect(account.id == providerAccount.id)
+        #expect(store.snapshot.accounts.count == 1)
+        #expect(store.snapshot.accounts.first?.id == providerAccount.id)
+        #expect(store.snapshot.accounts.first?.providerAccountID == "account-real")
+        #expect(FileManager.default.fileExists(atPath: legacyHome.path) == false)
+        #expect(FileManager.default.fileExists(atPath: providerHome.path) == false)
+        #expect(FileManager.default.fileExists(atPath: account.managedHomePath))
+    }
+
+    @Test
+    func `fresh provider login removes stale legacy row without explicit existing account id`() async throws {
+        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        let legacyHome = root.appendingPathComponent("accounts/legacy", isDirectory: true)
+        let providerHome = root.appendingPathComponent("accounts/provider", isDirectory: true)
+        try FileManager.default.createDirectory(at: legacyHome, withIntermediateDirectories: true)
+        try FileManager.default.createDirectory(at: providerHome, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let legacyID = try #require(UUID(uuidString: "CCCCCCCC-1111-2222-3333-444444444444"))
+        let providerID = try #require(UUID(uuidString: "DDDDDDDD-1111-2222-3333-444444444444"))
+        let legacyAccount = ManagedCodexAccount(
+            id: legacyID,
+            email: "shared@example.com",
+            managedHomePath: legacyHome.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let providerAccount = ManagedCodexAccount(
+            id: providerID,
+            email: "shared@example.com",
+            providerAccountID: "account-real",
+            managedHomePath: providerHome.path,
+            createdAt: 2,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let store = InMemoryManagedCodexAccountStore(accounts: ManagedCodexAccountSet(
+            version: FileManagedCodexAccountStore.currentVersion,
+            accounts: [legacyAccount, providerAccount]))
+        let service = ManagedCodexAccountService(
+            store: store,
+            homeFactory: TestManagedCodexHomeFactory(root: root),
+            loginRunner: StubManagedCodexLoginRunner.success,
+            identityReader: StubManagedCodexIdentityReader.accounts([
+                .init(identity: .providerAccount(id: "account-real"), email: "shared@example.com", plan: "Pro"),
+            ]),
+            workspaceResolver: StubManagedCodexWorkspaceResolver())
+
+        let account = try await service.authenticateManagedAccount()
+
+        #expect(account.id == providerAccount.id)
+        #expect(store.snapshot.accounts.count == 1)
+        #expect(store.snapshot.accounts.first?.id == providerAccount.id)
+        #expect(FileManager.default.fileExists(atPath: legacyHome.path) == false)
+        #expect(FileManager.default.fileExists(atPath: providerHome.path) == false)
+        #expect(FileManager.default.fileExists(atPath: account.managedHomePath))
+    }
+
+    @Test
+    func `authentication persists workspace metadata and tolerates missing workspace label`() async throws {
+        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let store = InMemoryManagedCodexAccountStore(
+            accounts: ManagedCodexAccountSet(version: FileManagedCodexAccountStore.currentVersion, accounts: []))
+        let service = ManagedCodexAccountService(
+            store: store,
+            homeFactory: TestManagedCodexHomeFactory(root: root),
+            loginRunner: StubManagedCodexLoginRunner.success,
+            identityReader: StubManagedCodexIdentityReader.accounts([
+                .init(identity: .providerAccount(id: "account-live"), email: "user@example.com", plan: "Pro"),
+                .init(identity: .providerAccount(id: "account-fallback"), email: "fallback@example.com", plan: "Pro"),
+            ]),
+            workspaceResolver: StubManagedCodexWorkspaceResolver(identities: [
+                "account-live": CodexOpenAIWorkspaceIdentity(
+                    workspaceAccountID: "account-live",
+                    workspaceLabel: "Team Alpha"),
+                "account-fallback": CodexOpenAIWorkspaceIdentity(
+                    workspaceAccountID: "account-fallback",
+                    workspaceLabel: nil),
+            ]))
+
+        let labeled = try await service.authenticateManagedAccount()
+        let fallback = try await service.authenticateManagedAccount()
+
+        #expect(labeled.providerAccountID == "account-live")
+        #expect(labeled.workspaceAccountID == "account-live")
+        #expect(labeled.workspaceLabel == "Team Alpha")
+        #expect(fallback.providerAccountID == "account-fallback")
+        #expect(fallback.workspaceAccountID == "account-fallback")
+        #expect(fallback.workspaceLabel == nil)
+    }
+
+    @Test
+    func `reauth preserves stored provider metadata when refresh cannot resolve account id`() async throws {
+        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        let existingHome = root.appendingPathComponent("accounts/existing", isDirectory: true)
+        try FileManager.default.createDirectory(at: existingHome, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let existingID = try #require(UUID(uuidString: "EEEEEEEE-1111-2222-3333-444444444444"))
+        let existingAccount = ManagedCodexAccount(
+            id: existingID,
+            email: "user@example.com",
+            providerAccountID: "account-live",
+            workspaceLabel: "Team Alpha",
+            workspaceAccountID: "account-live",
+            managedHomePath: existingHome.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let store = InMemoryManagedCodexAccountStore(accounts: ManagedCodexAccountSet(
+            version: FileManagedCodexAccountStore.currentVersion,
+            accounts: [existingAccount]))
+        let service = ManagedCodexAccountService(
+            store: store,
+            homeFactory: TestManagedCodexHomeFactory(root: root),
+            loginRunner: StubManagedCodexLoginRunner.success,
+            identityReader: StubManagedCodexIdentityReader.accounts([
+                .init(
+                    identity: .emailOnly(normalizedEmail: "user@example.com"),
+                    email: "user@example.com",
+                    plan: "Pro"),
+            ]),
+            workspaceResolver: StubManagedCodexWorkspaceResolver())
+
+        let account = try await service.authenticateManagedAccount(existingAccountID: existingID)
+        let stored = try #require(store.snapshot.account(id: existingID))
+
+        #expect(account.id == existingID)
+        #expect(account.providerAccountID == "account-live")
+        #expect(account.workspaceAccountID == "account-live")
+        #expect(account.workspaceLabel == "Team Alpha")
+        #expect(stored.providerAccountID == "account-live")
+        #expect(stored.workspaceAccountID == "account-live")
+        #expect(stored.workspaceLabel == "Team Alpha")
+        #expect(FileManager.default.fileExists(atPath: existingHome.path) == false)
+        #expect(FileManager.default.fileExists(atPath: account.managedHomePath))
+    }
+
+    @Test
+    func `auth failure cleanup uses managed root safety check`() async throws {
+        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        let outsideHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        defer {
+            try? FileManager.default.removeItem(at: root)
+            try? FileManager.default.removeItem(at: outsideHome)
+        }
+
+        let store = InMemoryManagedCodexAccountStore(
+            accounts: ManagedCodexAccountSet(version: 1, accounts: []))
+        let service = ManagedCodexAccountService(
+            store: store,
+            homeFactory: UnsafeManagedCodexHomeFactory(root: root, homeURL: outsideHome),
+            loginRunner: StubManagedCodexLoginRunner(
+                result: CodexLoginRunner.Result(outcome: .failed(status: 1), output: "nope")),
+            identityReader: StubManagedCodexIdentityReader.emails([]),
+            workspaceResolver: StubManagedCodexWorkspaceResolver())
+
+        await #expect(throws: ManagedCodexAccountServiceError.self) {
+            try await service.authenticateManagedAccount()
+        }
+
+        #expect(FileManager.default.fileExists(atPath: outsideHome.path))
+        #expect(store.snapshot.accounts.isEmpty)
+    }
+
+    @Test
+    func `auth failure preserves codex login result output`() async throws {
+        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let loginResult = CodexLoginRunner.Result(
+            outcome: .failed(status: 42),
+            output: "OAuth callback used the wrong browser profile")
+        let service = ManagedCodexAccountService(
+            store: InMemoryManagedCodexAccountStore(
+                accounts: ManagedCodexAccountSet(version: 1, accounts: [])),
+            homeFactory: TestManagedCodexHomeFactory(root: root),
+            loginRunner: StubManagedCodexLoginRunner(result: loginResult),
+            identityReader: StubManagedCodexIdentityReader.emails([]),
+            workspaceResolver: StubManagedCodexWorkspaceResolver())
+
+        do {
+            _ = try await service.authenticateManagedAccount()
+            Issue.record("Expected managed Codex login failure")
+        } catch let error as ManagedCodexAccountServiceError {
+            guard case let .loginFailed(capturedResult) = error else {
+                Issue.record("Expected loginFailed, got \(error)")
+                return
+            }
+            #expect(capturedResult == loginResult)
+            #expect(error.userFacingMessage.contains("codex --version"))
+            #expect(error.userFacingMessage.contains("OAuth callback used the wrong browser profile"))
+        }
+    }
+
+    @Test
+    func `remove deletes managed home under managed root`() async throws {
+        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        let home = root.appendingPathComponent("accounts/account-a", isDirectory: true)
+        try FileManager.default.createDirectory(at: home, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let accountID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE"))
+        let account = ManagedCodexAccount(
+            id: accountID,
+            email: "user@example.com",
+            managedHomePath: home.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let store = InMemoryManagedCodexAccountStore(
+            accounts: ManagedCodexAccountSet(version: 1, accounts: [account]))
+        let service = ManagedCodexAccountService(
+            store: store,
+            homeFactory: TestManagedCodexHomeFactory(root: root),
+            loginRunner: StubManagedCodexLoginRunner.success,
+            identityReader: StubManagedCodexIdentityReader.emails([]),
+            workspaceResolver: StubManagedCodexWorkspaceResolver())
+
+        try await service.removeManagedAccount(id: account.id)
+
+        #expect(store.snapshot.accounts.isEmpty)
+        #expect(FileManager.default.fileExists(atPath: home.path) == false)
+    }
+
+    @Test
+    func `remove keeps remaining managed account records`() async throws {
+        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        let firstHome = root.appendingPathComponent("accounts/account-a", isDirectory: true)
+        let secondHome = root.appendingPathComponent("accounts/account-b", isDirectory: true)
+        try FileManager.default.createDirectory(at: firstHome, withIntermediateDirectories: true)
+        try FileManager.default.createDirectory(at: secondHome, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let firstID = try #require(UUID(uuidString: "AAAAAAAA-1111-1111-1111-111111111111"))
+        let secondID = try #require(UUID(uuidString: "BBBBBBBB-2222-2222-2222-222222222222"))
+        let first = ManagedCodexAccount(
+            id: firstID,
+            email: "first@example.com",
+            managedHomePath: firstHome.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let second = ManagedCodexAccount(
+            id: secondID,
+            email: "second@example.com",
+            managedHomePath: secondHome.path,
+            createdAt: 2,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let store = InMemoryManagedCodexAccountStore(
+            accounts: ManagedCodexAccountSet(
+                version: 1,
+                accounts: [first, second]))
+        let service = ManagedCodexAccountService(
+            store: store,
+            homeFactory: TestManagedCodexHomeFactory(root: root),
+            loginRunner: StubManagedCodexLoginRunner.success,
+            identityReader: StubManagedCodexIdentityReader.emails([]),
+            workspaceResolver: StubManagedCodexWorkspaceResolver())
+
+        try await service.removeManagedAccount(id: second.id)
+
+        #expect(store.snapshot.accounts.count == 1)
+        #expect(store.snapshot.accounts.first?.id == first.id)
+        #expect(FileManager.default.fileExists(atPath: secondHome.path) == false)
+    }
+
+    @Test
+    func `remove keeps persisted account when store write fails`() async throws {
+        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        let home = root.appendingPathComponent("accounts/account-a", isDirectory: true)
+        try FileManager.default.createDirectory(at: home, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let accountID = try #require(UUID(uuidString: "CCCCCCCC-DDDD-EEEE-FFFF-000000000000"))
+        let account = ManagedCodexAccount(
+            id: accountID,
+            email: "user@example.com",
+            managedHomePath: home.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let store = FailingManagedCodexAccountStore(
+            accounts: ManagedCodexAccountSet(version: 1, accounts: [account]))
+        let service = ManagedCodexAccountService(
+            store: store,
+            homeFactory: TestManagedCodexHomeFactory(root: root),
+            loginRunner: StubManagedCodexLoginRunner.success,
+            identityReader: StubManagedCodexIdentityReader.emails([]),
+            workspaceResolver: StubManagedCodexWorkspaceResolver())
+
+        await #expect(throws: TestManagedCodexAccountStoreError.writeFailed) {
+            try await service.removeManagedAccount(id: account.id)
+        }
+
+        #expect(store.snapshot.accounts.count == 1)
+        #expect(store.snapshot.accounts.first?.managedHomePath == home.path)
+        #expect(FileManager.default.fileExists(atPath: home.path))
+    }
+
+    @Test
+    func `remove drops account but leaves unsafe home untouched`() async throws {
+        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        let outsideRoot = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        try FileManager.default.createDirectory(at: outsideRoot, withIntermediateDirectories: true)
+        defer {
+            try? FileManager.default.removeItem(at: root)
+            try? FileManager.default.removeItem(at: outsideRoot)
+        }
+
+        let accountID = try #require(UUID(uuidString: "BBBBBBBB-CCCC-DDDD-EEEE-FFFFFFFFFFFF"))
+        let account = ManagedCodexAccount(
+            id: accountID,
+            email: "user@example.com",
+            managedHomePath: outsideRoot.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let store = InMemoryManagedCodexAccountStore(
+            accounts: ManagedCodexAccountSet(version: 1, accounts: [account]))
+        let service = ManagedCodexAccountService(
+            store: store,
+            homeFactory: TestManagedCodexHomeFactory(root: root),
+            loginRunner: StubManagedCodexLoginRunner.success,
+            identityReader: StubManagedCodexIdentityReader.emails([]),
+            workspaceResolver: StubManagedCodexWorkspaceResolver())
+
+        try await service.removeManagedAccount(id: account.id)
+
+        #expect(store.snapshot.accounts.isEmpty)
+        #expect(FileManager.default.fileExists(atPath: outsideRoot.path))
+    }
+}
+
+private final class InMemoryManagedCodexAccountStore: ManagedCodexAccountStoring, @unchecked Sendable {
+    var snapshot: ManagedCodexAccountSet
+
+    init(accounts: ManagedCodexAccountSet) {
+        self.snapshot = accounts
+    }
+
+    func loadAccounts() throws -> ManagedCodexAccountSet {
+        self.snapshot
+    }
+
+    func storeAccounts(_ accounts: ManagedCodexAccountSet) throws {
+        self.snapshot = accounts
+    }
+
+    func ensureFileExists() throws -> URL {
+        FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+    }
+}
+
+private final class FailingManagedCodexAccountStore: ManagedCodexAccountStoring, @unchecked Sendable {
+    var snapshot: ManagedCodexAccountSet
+
+    init(accounts: ManagedCodexAccountSet) {
+        self.snapshot = accounts
+    }
+
+    func loadAccounts() throws -> ManagedCodexAccountSet {
+        self.snapshot
+    }
+
+    func storeAccounts(_ accounts: ManagedCodexAccountSet) throws {
+        _ = accounts
+        throw TestManagedCodexAccountStoreError.writeFailed
+    }
+
+    func ensureFileExists() throws -> URL {
+        FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+    }
+}
+
+private final class TestManagedCodexHomeFactory: ManagedCodexHomeProducing, @unchecked Sendable {
+    let root: URL
+    private let lock = NSLock()
+    private var index: Int = 0
+
+    init(root: URL) {
+        self.root = root
+    }
+
+    private func nextPathComponent() -> String {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        self.index += 1
+        return "accounts/account-\(self.index)"
+    }
+
+    func makeHomeURL() -> URL {
+        self.root.appendingPathComponent(self.nextPathComponent(), isDirectory: true)
+    }
+
+    func validateManagedHomeForDeletion(_ url: URL) throws {
+        try ManagedCodexHomeFactory(root: self.root).validateManagedHomeForDeletion(url)
+    }
+}
+
+private struct UnsafeManagedCodexHomeFactory: ManagedCodexHomeProducing {
+    let root: URL
+    let homeURL: URL
+
+    func makeHomeURL() -> URL {
+        self.homeURL
+    }
+
+    func validateManagedHomeForDeletion(_ url: URL) throws {
+        try ManagedCodexHomeFactory(root: self.root).validateManagedHomeForDeletion(url)
+    }
+}
+
+private struct StubManagedCodexLoginRunner: ManagedCodexLoginRunning {
+    let result: CodexLoginRunner.Result
+
+    func run(homePath: String, timeout: TimeInterval) async -> CodexLoginRunner.Result {
+        self.result
+    }
+
+    static let success = StubManagedCodexLoginRunner(
+        result: CodexLoginRunner.Result(outcome: .success, output: "ok"))
+}
+
+private struct WritingManagedCodexLoginRunner: ManagedCodexLoginRunning {
+    let credentials: CodexOAuthCredentials
+
+    func run(homePath: String, timeout _: TimeInterval) async -> CodexLoginRunner.Result {
+        do {
+            try CodexOAuthCredentialsStore.save(self.credentials, env: ["CODEX_HOME": homePath])
+            return CodexLoginRunner.Result(outcome: .success, output: "ok")
+        } catch {
+            return CodexLoginRunner.Result(outcome: .failed(status: 1), output: String(describing: error))
+        }
+    }
+}
+
+private enum TestManagedCodexAccountStoreError: Error, Equatable {
+    case writeFailed
+}
+
+private final class StubManagedCodexIdentityReader: ManagedCodexIdentityReading, @unchecked Sendable {
+    private let lock = NSLock()
+    private var identities: [CodexAuthBackedAccount]
+
+    init(identities: [CodexAuthBackedAccount]) {
+        self.identities = identities
+    }
+
+    func loadAccountIdentity(homePath _: String) throws -> CodexAuthBackedAccount {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        guard !self.identities.isEmpty else {
+            return CodexAuthBackedAccount(identity: .unresolved, email: nil, plan: nil)
+        }
+        return self.identities.removeFirst()
+    }
+
+    static func emails(_ emails: [String]) -> StubManagedCodexIdentityReader {
+        StubManagedCodexIdentityReader(identities: emails.map { email in
+            CodexAuthBackedAccount(
+                identity: CodexIdentityResolver.resolve(accountId: nil, email: email),
+                email: email,
+                plan: "Pro")
+        })
+    }
+
+    static func accounts(_ accounts: [CodexAuthBackedAccount]) -> StubManagedCodexIdentityReader {
+        StubManagedCodexIdentityReader(identities: accounts)
+    }
+}
+
+private struct StubManagedCodexWorkspaceResolver: ManagedCodexWorkspaceResolving {
+    let identities: [String: CodexOpenAIWorkspaceIdentity]
+    let availableIdentities: [CodexOpenAIWorkspaceIdentity]
+
+    init(
+        identities: [String: CodexOpenAIWorkspaceIdentity] = [:],
+        availableIdentities: [CodexOpenAIWorkspaceIdentity] = [])
+    {
+        self.identities = identities
+        self.availableIdentities = availableIdentities
+    }
+
+    func resolveWorkspaceIdentity(
+        homePath _: String,
+        providerAccountID: String) async -> CodexOpenAIWorkspaceIdentity?
+    {
+        self.identities[providerAccountID]
+    }
+
+    func availableWorkspaceIdentities(homePath _: String) async -> [CodexOpenAIWorkspaceIdentity] {
+        self.availableIdentities
+    }
+}
+
+private struct StubManagedCodexWorkspaceSelector: ManagedCodexWorkspaceSelecting {
+    let selectedWorkspaceID: String?
+
+    func selectWorkspace(
+        email _: String,
+        currentWorkspaceID _: String?,
+        workspaces: [CodexOpenAIWorkspaceIdentity]) async -> CodexOpenAIWorkspaceIdentity?
+    {
+        workspaces.first { $0.workspaceAccountID == self.selectedWorkspaceID }
+    }
+}
diff --git a/Tests/CodexBarTests/ManagedCodexAccountStoreTests.swift b/Tests/CodexBarTests/ManagedCodexAccountStoreTests.swift
new file mode 100644
index 0000000000..274761cf53
--- /dev/null
+++ b/Tests/CodexBarTests/ManagedCodexAccountStoreTests.swift
@@ -0,0 +1,542 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@Test
+func `FileManagedCodexAccountStore round trip`() throws {
+    let tempDir = FileManager.default.temporaryDirectory
+    let fileURL = tempDir.appendingPathComponent("codexbar-managed-codex-accounts-test.json")
+    defer { try? FileManager.default.removeItem(at: fileURL) }
+
+    let firstID = UUID()
+    let secondID = UUID()
+    let firstAccount = ManagedCodexAccount(
+        id: firstID,
+        email: "  FIRST@Example.COM ",
+        providerAccountID: "account-first",
+        managedHomePath: "/tmp/managed-home-1",
+        createdAt: 1000,
+        updatedAt: 2000,
+        lastAuthenticatedAt: 3000)
+    let secondAccount = ManagedCodexAccount(
+        id: secondID,
+        email: "second@example.com",
+        providerAccountID: "account-second",
+        managedHomePath: "/tmp/managed-home-2",
+        createdAt: 4000,
+        updatedAt: 5000,
+        lastAuthenticatedAt: nil)
+    let payload = ManagedCodexAccountSet(
+        version: FileManagedCodexAccountStore.currentVersion,
+        accounts: [firstAccount, secondAccount])
+    let store = FileManagedCodexAccountStore(fileURL: fileURL)
+
+    try store.storeAccounts(payload)
+    let contents = try String(contentsOf: fileURL, encoding: .utf8)
+    let loaded = try store.loadAccounts()
+    let accountsRange = try #require(contents.range(of: "\"accounts\""))
+    let versionRange = try #require(contents.range(of: "\"version\""))
+
+    #expect(loaded.version == FileManagedCodexAccountStore.currentVersion)
+    #expect(loaded.accounts.count == 2)
+    #expect(loaded.accounts[0].email == "first@example.com")
+    #expect(loaded.accounts[0].providerAccountID == "account-first")
+    #expect(loaded.account(id: firstID)?.managedHomePath == "/tmp/managed-home-1")
+    #expect(loaded.account(email: "SECOND@example.com", providerAccountID: "account-second")?.id == secondID)
+    #expect(contents.contains("\n  \"accounts\""))
+    #expect(accountsRange.lowerBound < versionRange.lowerBound)
+    #expect(contents.contains("\"activeAccountID\"") == false)
+}
+
+@Test
+func `FileManagedCodexAccountStore missing file loads empty set`() throws {
+    let tempDir = FileManager.default.temporaryDirectory
+    let fileURL = tempDir.appendingPathComponent("codexbar-managed-codex-accounts-nil-active-test.json")
+    defer { try? FileManager.default.removeItem(at: fileURL) }
+    try? FileManager.default.removeItem(at: fileURL)
+
+    let store = FileManagedCodexAccountStore(fileURL: fileURL)
+    let initial = try store.loadAccounts()
+
+    #expect(initial.version == FileManagedCodexAccountStore.currentVersion)
+    #expect(initial.accounts.isEmpty)
+
+    let account = ManagedCodexAccount(
+        id: UUID(),
+        email: "user@example.com",
+        managedHomePath: "/tmp/managed-home",
+        createdAt: 10,
+        updatedAt: 20,
+        lastAuthenticatedAt: nil)
+    let payload = ManagedCodexAccountSet(
+        version: 1,
+        accounts: [account])
+
+    try store.storeAccounts(payload)
+    let loaded = try store.loadAccounts()
+
+    #expect(loaded.version == FileManagedCodexAccountStore.currentVersion)
+    #expect(loaded.accounts.count == 1)
+    #expect(loaded.account(email: "USER@example.com")?.id == account.id)
+}
+
+@Test
+func `FileManagedCodexAccountStore canonicalizes decoded emails`() throws {
+    let tempDir = FileManager.default.temporaryDirectory
+    let fileURL = tempDir.appendingPathComponent("codexbar-managed-codex-accounts-decode-test.json")
+    defer { try? FileManager.default.removeItem(at: fileURL) }
+
+    let accountID = UUID()
+    let json = """
+    {
+      "accounts" : [
+        {
+          "createdAt" : 10,
+          "email" : "  MIXED@Example.COM  ",
+          "id" : "\(accountID.uuidString)",
+          "lastAuthenticatedAt" : null,
+          "managedHomePath" : "/tmp/managed-home",
+          "updatedAt" : 20
+        }
+      ],
+      "version" : 1
+    }
+    """
+
+    try json.write(to: fileURL, atomically: true, encoding: .utf8)
+
+    let store = FileManagedCodexAccountStore(fileURL: fileURL)
+    let loaded = try store.loadAccounts()
+
+    #expect(loaded.version == FileManagedCodexAccountStore.currentVersion)
+    #expect(loaded.accounts.first?.email == "mixed@example.com")
+    #expect(loaded.account(email: "mixed@example.com")?.id == accountID)
+}
+
+@Test
+func `FileManagedCodexAccountStore drops duplicate canonical emails on load`() throws {
+    let tempDir = FileManager.default.temporaryDirectory
+    let fileURL = tempDir.appendingPathComponent("codexbar-managed-codex-accounts-duplicate-email-test.json")
+    defer { try? FileManager.default.removeItem(at: fileURL) }
+
+    let firstID = UUID()
+    let secondID = UUID()
+    let json = """
+    {
+      "accounts" : [
+        {
+          "createdAt" : 10,
+          "email" : " First@Example.com ",
+          "id" : "\(firstID.uuidString)",
+          "lastAuthenticatedAt" : null,
+          "managedHomePath" : "/tmp/managed-home-1",
+          "updatedAt" : 20
+        },
+        {
+          "createdAt" : 30,
+          "email" : "first@example.com",
+          "id" : "\(secondID.uuidString)",
+          "lastAuthenticatedAt" : null,
+          "managedHomePath" : "/tmp/managed-home-2",
+          "updatedAt" : 40
+        }
+      ],
+      "version" : 1
+    }
+    """
+
+    try json.write(to: fileURL, atomically: true, encoding: .utf8)
+
+    let store = FileManagedCodexAccountStore(fileURL: fileURL)
+    let loaded = try store.loadAccounts()
+
+    #expect(loaded.accounts.count == 1)
+    #expect(loaded.accounts.first?.id == firstID)
+    #expect(loaded.accounts.first?.managedHomePath == "/tmp/managed-home-1")
+}
+
+@Test
+func `FileManagedCodexAccountStore keeps same email rows when hydrated provider account I Ds differ`() throws {
+    let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+    defer { try? FileManager.default.removeItem(at: root) }
+
+    let fileURL = root.appendingPathComponent("managed.json", isDirectory: false)
+    let firstHome = root.appendingPathComponent("first-home", isDirectory: true)
+    let secondHome = root.appendingPathComponent("second-home", isDirectory: true)
+    try writeCodexAuthFile(homeURL: firstHome, email: "user@example.com", accountId: "account-alpha")
+    try writeCodexAuthFile(homeURL: secondHome, email: "user@example.com", accountId: "account-beta")
+
+    let firstID = UUID()
+    let secondID = UUID()
+    let json = """
+    {
+      "accounts" : [
+        {
+          "createdAt" : 10,
+          "email" : " user@example.com ",
+          "id" : "\(firstID.uuidString)",
+          "lastAuthenticatedAt" : null,
+          "managedHomePath" : "\(firstHome.path)",
+          "updatedAt" : 20
+        },
+        {
+          "createdAt" : 30,
+          "email" : "USER@example.com",
+          "id" : "\(secondID.uuidString)",
+          "lastAuthenticatedAt" : null,
+          "managedHomePath" : "\(secondHome.path)",
+          "updatedAt" : 40
+        }
+      ],
+      "version" : 1
+    }
+    """
+
+    try json.write(to: fileURL, atomically: true, encoding: .utf8)
+
+    let store = FileManagedCodexAccountStore(fileURL: fileURL)
+    let loaded = try store.loadAccounts()
+
+    #expect(loaded.version == FileManagedCodexAccountStore.currentVersion)
+    #expect(loaded.accounts.count == 2)
+    #expect(loaded.account(email: "user@example.com", providerAccountID: "account-alpha")?.id == firstID)
+    #expect(loaded.account(email: "user@example.com", providerAccountID: "account-beta")?.id == secondID)
+}
+
+@Test
+func `managed account set keeps same provider account I D when emails differ`() {
+    let firstID = UUID()
+    let secondID = UUID()
+    let first = ManagedCodexAccount(
+        id: firstID,
+        email: "mi.chaelfmk5542@gmail.com",
+        providerAccountID: "team-4107",
+        managedHomePath: "/tmp/managed-home-1",
+        createdAt: 10,
+        updatedAt: 20,
+        lastAuthenticatedAt: nil)
+    let second = ManagedCodexAccount(
+        id: secondID,
+        email: "mich.aelfmk5542@gmail.com",
+        providerAccountID: "team-4107",
+        managedHomePath: "/tmp/managed-home-2",
+        createdAt: 30,
+        updatedAt: 40,
+        lastAuthenticatedAt: nil)
+
+    let set = ManagedCodexAccountSet(
+        version: FileManagedCodexAccountStore.currentVersion,
+        accounts: [first, second])
+
+    #expect(set.accounts.count == 2)
+    #expect(set.account(email: "mi.chaelfmk5542@gmail.com", providerAccountID: "team-4107")?.id == firstID)
+    #expect(set.account(email: "mich.aelfmk5542@gmail.com", providerAccountID: "team-4107")?.id == secondID)
+}
+
+@Test
+func `FileManagedCodexAccountStore hydrates provider account I D from id token when account field is absent`() throws {
+    let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+    defer { try? FileManager.default.removeItem(at: root) }
+
+    let fileURL = root.appendingPathComponent("managed.json", isDirectory: false)
+    let home = root.appendingPathComponent("jwt-only-home", isDirectory: true)
+    try writeCodexAuthFile(
+        homeURL: home,
+        email: "user@example.com",
+        accountId: "account-jwt-only",
+        includeAccountIdField: false)
+
+    let accountID = UUID()
+    let json = """
+    {
+      "accounts" : [
+        {
+          "createdAt" : 10,
+          "email" : "user@example.com",
+          "id" : "\(accountID.uuidString)",
+          "lastAuthenticatedAt" : null,
+          "managedHomePath" : "\(home.path)",
+          "updatedAt" : 20
+        }
+      ],
+      "version" : 1
+    }
+    """
+
+    try json.write(to: fileURL, atomically: true, encoding: .utf8)
+
+    let store = FileManagedCodexAccountStore(fileURL: fileURL)
+    let loaded = try store.loadAccounts()
+
+    #expect(loaded.version == FileManagedCodexAccountStore.currentVersion)
+    #expect(loaded.accounts.count == 1)
+    #expect(loaded.accounts.first?.providerAccountID == "account-jwt-only")
+    #expect(loaded.account(email: "user@example.com", providerAccountID: "account-jwt-only")?.id == accountID)
+}
+
+@Test
+func `FileManagedCodexAccountStore drops duplicate IDs on load`() throws {
+    let tempDir = FileManager.default.temporaryDirectory
+    let fileURL = tempDir.appendingPathComponent("codexbar-managed-codex-accounts-duplicate-id-test.json")
+    defer { try? FileManager.default.removeItem(at: fileURL) }
+
+    let sharedID = UUID()
+    let json = """
+    {
+      "accounts" : [
+        {
+          "createdAt" : 10,
+          "email" : "first@example.com",
+          "id" : "\(sharedID.uuidString)",
+          "lastAuthenticatedAt" : null,
+          "managedHomePath" : "/tmp/managed-home-1",
+          "updatedAt" : 20
+        },
+        {
+          "createdAt" : 30,
+          "email" : "second@example.com",
+          "id" : "\(sharedID.uuidString)",
+          "lastAuthenticatedAt" : null,
+          "managedHomePath" : "/tmp/managed-home-2",
+          "updatedAt" : 40
+        }
+      ],
+      "version" : 1
+    }
+    """
+
+    try json.write(to: fileURL, atomically: true, encoding: .utf8)
+
+    let store = FileManagedCodexAccountStore(fileURL: fileURL)
+    let loaded = try store.loadAccounts()
+
+    #expect(loaded.accounts.count == 1)
+    #expect(loaded.accounts.first?.id == sharedID)
+    #expect(loaded.accounts.first?.email == "first@example.com")
+    #expect(loaded.accounts.first?.managedHomePath == "/tmp/managed-home-1")
+}
+
+@Test
+func `FileManagedCodexAccountStore v1 upgrade keeps deleted home row with nil provider account I D`() throws {
+    let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+    defer { try? FileManager.default.removeItem(at: root) }
+    try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
+
+    let fileURL = root.appendingPathComponent("managed.json", isDirectory: false)
+    let missingHome = root.appendingPathComponent("missing-home", isDirectory: true)
+    let accountID = UUID()
+    let json = """
+    {
+      "accounts" : [
+        {
+          "createdAt" : 10,
+          "email" : "user@example.com",
+          "id" : "\(accountID.uuidString)",
+          "lastAuthenticatedAt" : null,
+          "managedHomePath" : "\(missingHome.path)",
+          "updatedAt" : 20
+        }
+      ],
+      "version" : 1
+    }
+    """
+
+    try json.write(to: fileURL, atomically: true, encoding: .utf8)
+
+    let store = FileManagedCodexAccountStore(fileURL: fileURL)
+    let loaded = try store.loadAccounts()
+
+    #expect(loaded.version == FileManagedCodexAccountStore.currentVersion)
+    #expect(loaded.accounts.count == 1)
+    #expect(loaded.accounts.first?.id == accountID)
+    #expect(loaded.accounts.first?.providerAccountID == nil)
+}
+
+@Test
+func `FileManagedCodexAccountStore ignores legacy active account key on load`() throws {
+    let tempDir = FileManager.default.temporaryDirectory
+    let fileURL = tempDir.appendingPathComponent("codexbar-managed-codex-accounts-legacy-active-key-test.json")
+    defer { try? FileManager.default.removeItem(at: fileURL) }
+
+    let accountID = UUID()
+    let danglingID = UUID()
+    let json = """
+    {
+      "accounts" : [
+        {
+          "createdAt" : 10,
+          "email" : "user@example.com",
+          "id" : "\(accountID.uuidString)",
+          "lastAuthenticatedAt" : null,
+          "managedHomePath" : "/tmp/managed-home",
+          "updatedAt" : 20
+        }
+      ],
+      "activeAccountID" : "\(danglingID.uuidString)",
+      "version" : 1
+    }
+    """
+
+    try json.write(to: fileURL, atomically: true, encoding: .utf8)
+
+    let store = FileManagedCodexAccountStore(fileURL: fileURL)
+    let loaded = try store.loadAccounts()
+
+    #expect(loaded.accounts.count == 1)
+    #expect(loaded.account(id: accountID)?.email == "user@example.com")
+}
+
+@Test
+func `FileManagedCodexAccountStore upgrades v1 rows and writes readable v2 file without reauth`() throws {
+    let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+    defer { try? FileManager.default.removeItem(at: root) }
+
+    let fileURL = root.appendingPathComponent("managed.json", isDirectory: false)
+    let firstHome = root.appendingPathComponent("first-home", isDirectory: true)
+    let secondHome = root.appendingPathComponent("second-home", isDirectory: true)
+    try writeCodexAuthFile(homeURL: firstHome, email: "user@example.com", accountId: "account-alpha")
+    try writeCodexAuthFile(homeURL: secondHome, email: "second@example.com", accountId: "account-beta")
+
+    let firstID = UUID()
+    let secondID = UUID()
+    let json = """
+    {
+      "accounts" : [
+        {
+          "createdAt" : 10,
+          "email" : "user@example.com",
+          "id" : "\(firstID.uuidString)",
+          "lastAuthenticatedAt" : null,
+          "managedHomePath" : "\(firstHome.path)",
+          "updatedAt" : 20
+        },
+        {
+          "createdAt" : 30,
+          "email" : "second@example.com",
+          "id" : "\(secondID.uuidString)",
+          "lastAuthenticatedAt" : null,
+          "managedHomePath" : "\(secondHome.path)",
+          "updatedAt" : 40
+        }
+      ],
+      "version" : 1
+    }
+    """
+
+    try json.write(to: fileURL, atomically: true, encoding: .utf8)
+
+    let store = FileManagedCodexAccountStore(fileURL: fileURL)
+    let loaded = try store.loadAccounts()
+    try store.storeAccounts(loaded)
+    let reloaded = try store.loadAccounts()
+    let contents = try String(contentsOf: fileURL, encoding: .utf8)
+
+    #expect(loaded.accounts.count == 2)
+    #expect(loaded.account(email: "user@example.com", providerAccountID: "account-alpha")?.id == firstID)
+    #expect(loaded.account(email: "second@example.com", providerAccountID: "account-beta")?.id == secondID)
+    #expect(reloaded.accounts.count == 2)
+    #expect(contents.contains("account-alpha"))
+    #expect(contents.contains("account-beta"))
+    #expect(contents.contains("\"version\" : \(FileManagedCodexAccountStore.currentVersion)"))
+}
+
+@Test
+func `FileManagedCodexAccountStore rejects unsupported on disk versions`() throws {
+    let tempDir = FileManager.default.temporaryDirectory
+    let fileURL = tempDir.appendingPathComponent("codexbar-managed-codex-accounts-unsupported-version-test.json")
+    defer { try? FileManager.default.removeItem(at: fileURL) }
+
+    let accountID = UUID()
+    let json = """
+    {
+      "accounts" : [
+        {
+          "createdAt" : 10,
+          "email" : "user@example.com",
+          "id" : "\(accountID.uuidString)",
+          "lastAuthenticatedAt" : null,
+          "managedHomePath" : "/tmp/managed-home",
+          "updatedAt" : 20
+        }
+      ],
+      "version" : 999
+    }
+    """
+
+    try json.write(to: fileURL, atomically: true, encoding: .utf8)
+
+    let store = FileManagedCodexAccountStore(fileURL: fileURL)
+
+    #expect(throws: FileManagedCodexAccountStoreError.unsupportedVersion(999)) {
+        try store.loadAccounts()
+    }
+}
+
+@Test
+func `FileManagedCodexAccountStore normalizes stored version to current schema`() throws {
+    let tempDir = FileManager.default.temporaryDirectory
+    let fileURL = tempDir.appendingPathComponent("codexbar-managed-codex-accounts-version-normalization-test.json")
+    defer { try? FileManager.default.removeItem(at: fileURL) }
+
+    let accountID = UUID()
+    let account = ManagedCodexAccount(
+        id: accountID,
+        email: "user@example.com",
+        providerAccountID: "account-id",
+        managedHomePath: "/tmp/managed-home",
+        createdAt: 10,
+        updatedAt: 20,
+        lastAuthenticatedAt: nil)
+    let payload = ManagedCodexAccountSet(
+        version: 999,
+        accounts: [account])
+    let store = FileManagedCodexAccountStore(fileURL: fileURL)
+
+    try store.storeAccounts(payload)
+    let loaded = try store.loadAccounts()
+    let contents = try String(contentsOf: fileURL, encoding: .utf8)
+
+    #expect(loaded.version == FileManagedCodexAccountStore.currentVersion)
+    #expect(contents.contains("\"version\" : \(FileManagedCodexAccountStore.currentVersion)"))
+    #expect(!contents.contains("\"version\" : 999"))
+}
+
+private func writeCodexAuthFile(
+    homeURL: URL,
+    email: String,
+    accountId: String,
+    includeAccountIdField: Bool = true) throws
+{
+    try FileManager.default.createDirectory(at: homeURL, withIntermediateDirectories: true)
+    var tokens: [String: Any] = [
+        "accessToken": "access-token",
+        "refreshToken": "refresh-token",
+        "idToken": fakeJWT(email: email, accountId: accountId),
+    ]
+    if includeAccountIdField {
+        tokens["accountId"] = accountId
+    }
+    let data = try JSONSerialization.data(withJSONObject: ["tokens": tokens], options: [.sortedKeys])
+    try data.write(to: homeURL.appendingPathComponent("auth.json"))
+}
+
+private func fakeJWT(email: String, accountId: String) -> String {
+    let header = (try? JSONSerialization.data(withJSONObject: ["alg": "none"])) ?? Data()
+    let payload = (try? JSONSerialization.data(withJSONObject: [
+        "email": email,
+        "https://api.openai.com/auth": [
+            "chatgpt_account_id": accountId,
+            "chatgpt_plan_type": "pro",
+        ],
+    ])) ?? Data()
+
+    func base64URL(_ data: Data) -> String {
+        data.base64EncodedString()
+            .replacingOccurrences(of: "=", with: "")
+            .replacingOccurrences(of: "+", with: "-")
+            .replacingOccurrences(of: "/", with: "_")
+    }
+
+    return "\(base64URL(header)).\(base64URL(payload))."
+}
diff --git a/Tests/CodexBarTests/ManusCookieHeaderTests.swift b/Tests/CodexBarTests/ManusCookieHeaderTests.swift
new file mode 100644
index 0000000000..6f760d3d93
--- /dev/null
+++ b/Tests/CodexBarTests/ManusCookieHeaderTests.swift
@@ -0,0 +1,48 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct ManusCookieHeaderTests {
+    @Test
+    func `bare token resolves directly`() {
+        #expect(ManusCookieHeader.token(from: "abc123") == "abc123")
+    }
+
+    @Test
+    func `extracts session_id from cookie header`() {
+        let header = "foo=bar; session_id=token-a; baz=qux"
+        #expect(ManusCookieHeader.token(from: header) == "token-a")
+    }
+
+    @Test
+    func `extracts mixed case session id from cookie header`() {
+        let header = "foo=bar; Session_ID=token-b; baz=qux"
+        #expect(ManusCookieHeader.token(from: header) == "token-b")
+    }
+
+    @Test
+    func `unsupported cookie header returns nil`() {
+        #expect(ManusCookieHeader.token(from: "foo=bar; hello=world") == nil)
+    }
+
+    #if os(macOS)
+    @Test
+    func `importer session info extracts session token`() throws {
+        let cookies = try [
+            #require(self.makeCookie(name: "session_id", value: "cookie-token")),
+        ]
+        let session = ManusCookieImporter.SessionInfo(cookies: cookies, sourceLabel: "Chrome")
+        #expect(session.sessionToken == "cookie-token")
+    }
+
+    private func makeCookie(name: String, value: String) -> HTTPCookie? {
+        HTTPCookie(properties: [
+            .domain: "manus.im",
+            .path: "/",
+            .name: name,
+            .value: value,
+            .secure: "TRUE",
+        ])
+    }
+    #endif
+}
diff --git a/Tests/CodexBarTests/ManusProviderTests.swift b/Tests/CodexBarTests/ManusProviderTests.swift
new file mode 100644
index 0000000000..be69fdf519
--- /dev/null
+++ b/Tests/CodexBarTests/ManusProviderTests.swift
@@ -0,0 +1,310 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct ManusProviderTests {
+    private static let now = Date(timeIntervalSince1970: 1_744_000_000)
+
+    private final class LockedArray<Element>: @unchecked Sendable {
+        private let lock = NSLock()
+        private var values: [Element] = []
+
+        func append(_ value: Element) {
+            self.lock.lock()
+            defer { self.lock.unlock() }
+            self.values.append(value)
+        }
+
+        func snapshot() -> [Element] {
+            self.lock.lock()
+            defer { self.lock.unlock() }
+            return self.values
+        }
+    }
+
+    private struct StubClaudeFetcher: ClaudeUsageFetching {
+        func loadLatestUsage(model _: String) async throws -> ClaudeUsageSnapshot {
+            throw ClaudeUsageError.parseFailed("stub")
+        }
+
+        func debugRawProbe(model _: String) async -> String {
+            "stub"
+        }
+
+        func detectVersion() -> String? {
+            nil
+        }
+    }
+
+    private func makeContext(
+        settings: ProviderSettingsSnapshot?,
+        env: [String: String] = [:]) -> ProviderFetchContext
+    {
+        ProviderFetchContext(
+            runtime: .app,
+            sourceMode: .auto,
+            includeCredits: false,
+            webTimeout: 1,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: env,
+            settings: settings,
+            fetcher: UsageFetcher(environment: env),
+            claudeFetcher: StubClaudeFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0))
+    }
+
+    private func stubResponse() -> ManusCreditsResponse {
+        ManusCreditsResponse(
+            totalCredits: 120,
+            freeCredits: 20,
+            periodicCredits: 80,
+            addonCredits: 10,
+            refreshCredits: 30,
+            maxRefreshCredits: 300,
+            proMonthlyCredits: 100,
+            eventCredits: 10,
+            nextRefreshTime: Date(timeIntervalSince1970: 1_744_003_600),
+            refreshInterval: "daily")
+    }
+
+    private func withIsolatedCacheStore<T>(operation: () async throws -> T) async rethrows -> T {
+        let service = "manus-provider-tests-\(UUID().uuidString)"
+        return try await KeychainCacheStore.withServiceOverrideForTesting(service) {
+            KeychainCacheStore.setTestStoreForTesting(true)
+            defer { KeychainCacheStore.setTestStoreForTesting(false) }
+            return try await operation()
+        }
+    }
+
+    @Test
+    func `off mode ignores environment session token`() async {
+        let strategy = ManusWebFetchStrategy()
+        let settings = ProviderSettingsSnapshot.make(
+            manus: ProviderSettingsSnapshot.ManusProviderSettings(
+                cookieSource: .off,
+                manualCookieHeader: nil))
+        let context = self.makeContext(
+            settings: settings,
+            env: ["MANUS_SESSION_TOKEN": "env-token"])
+
+        #expect(await strategy.isAvailable(context) == false)
+    }
+
+    @Test
+    func `manual mode invalid cookie does not fall back to cache or environment`() async {
+        await self.withIsolatedCacheStore {
+            CookieHeaderCache.store(
+                provider: .manus,
+                cookieHeader: "session_id=cached-token",
+                sourceLabel: "web")
+
+            let strategy = ManusWebFetchStrategy()
+            let settings = ProviderSettingsSnapshot.make(
+                manus: ProviderSettingsSnapshot.ManusProviderSettings(
+                    cookieSource: .manual,
+                    manualCookieHeader: "foo=bar"))
+            let context = self.makeContext(
+                settings: settings,
+                env: ["MANUS_SESSION_TOKEN": "env-token"])
+
+            do {
+                _ = try await strategy.fetch(context)
+                Issue.record("Expected invalid manual cookie instead of falling back to cache/environment")
+            } catch let error as ManusAPIError {
+                #expect(error == .invalidCookie)
+            } catch {
+                Issue.record("Expected ManusAPIError.invalidCookie, got \(error)")
+            }
+        }
+    }
+
+    @Test
+    func `environment token does not populate browser cache`() async throws {
+        try await self.withIsolatedCacheStore {
+            #if os(macOS)
+            ManusCookieImporter.importSessionsOverrideForTesting = { _, _ in
+                throw ManusCookieImportError.noCookies
+            }
+            ManusCookieImporter.importSessionOverrideForTesting = nil
+            defer {
+                ManusCookieImporter.importSessionsOverrideForTesting = nil
+                ManusCookieImporter.importSessionOverrideForTesting = nil
+            }
+            #endif
+
+            let strategy = ManusWebFetchStrategy()
+            let settings = ProviderSettingsSnapshot.make(
+                manus: ProviderSettingsSnapshot.ManusProviderSettings(
+                    cookieSource: .auto,
+                    manualCookieHeader: nil))
+            let context = self.makeContext(
+                settings: settings,
+                env: ["MANUS_SESSION_TOKEN": "env-token"])
+            let fetchOverride: @Sendable (String, Date) async throws -> ManusCreditsResponse = { token, _ in
+                #expect(token == "env-token")
+                return self.stubResponse()
+            }
+
+            _ = try await ManusUsageFetcher.$fetchCreditsOverride.withValue(fetchOverride, operation: {
+                try await strategy.fetch(context)
+            })
+
+            #expect(CookieHeaderCache.load(provider: .manus) == nil)
+        }
+    }
+
+    #if os(macOS)
+    @Test
+    func `invalid browser token falls back to environment token`() async throws {
+        try await self.withIsolatedCacheStore {
+            let browserCookie = try #require(HTTPCookie(properties: [
+                .domain: "manus.im",
+                .path: "/",
+                .name: "session_id",
+                .value: "browser-token",
+                .secure: "TRUE",
+            ]))
+            ManusCookieImporter.importSessionOverrideForTesting = { _, _ in
+                ManusCookieImporter.SessionInfo(cookies: [browserCookie], sourceLabel: "Chrome")
+            }
+            ManusCookieImporter.importSessionsOverrideForTesting = nil
+            defer {
+                ManusCookieImporter.importSessionOverrideForTesting = nil
+                ManusCookieImporter.importSessionsOverrideForTesting = nil
+            }
+
+            let attempts = LockedArray<String>()
+            let strategy = ManusWebFetchStrategy()
+            let settings = ProviderSettingsSnapshot.make(
+                manus: ProviderSettingsSnapshot.ManusProviderSettings(
+                    cookieSource: .auto,
+                    manualCookieHeader: nil))
+            let context = self.makeContext(
+                settings: settings,
+                env: ["MANUS_SESSION_TOKEN": "env-token"])
+            let fetchOverride: @Sendable (String, Date) async throws -> ManusCreditsResponse = { token, _ in
+                attempts.append(token)
+                if token == "browser-token" {
+                    throw ManusAPIError.invalidToken
+                }
+                #expect(token == "env-token")
+                return self.stubResponse()
+            }
+
+            _ = try await ManusUsageFetcher.$fetchCreditsOverride.withValue(fetchOverride, operation: {
+                try await strategy.fetch(context)
+            })
+
+            #expect(attempts.snapshot() == ["browser-token", "env-token"])
+            #expect(CookieHeaderCache.load(provider: .manus) == nil)
+        }
+    }
+
+    @Test
+    func `browser token populates cache after successful fetch`() async throws {
+        try await self.withIsolatedCacheStore {
+            let browserCookie = try #require(HTTPCookie(properties: [
+                .domain: "manus.im",
+                .path: "/",
+                .name: "session_id",
+                .value: "browser-token",
+                .secure: "TRUE",
+            ]))
+            ManusCookieImporter.importSessionOverrideForTesting = { _, _ in
+                ManusCookieImporter.SessionInfo(cookies: [browserCookie], sourceLabel: "Chrome")
+            }
+            ManusCookieImporter.importSessionsOverrideForTesting = nil
+            defer {
+                ManusCookieImporter.importSessionOverrideForTesting = nil
+                ManusCookieImporter.importSessionsOverrideForTesting = nil
+            }
+
+            let strategy = ManusWebFetchStrategy()
+            let settings = ProviderSettingsSnapshot.make(
+                manus: ProviderSettingsSnapshot.ManusProviderSettings(
+                    cookieSource: .auto,
+                    manualCookieHeader: nil))
+            let context = self.makeContext(settings: settings)
+            let fetchOverride: @Sendable (String, Date) async throws -> ManusCreditsResponse = { token, _ in
+                #expect(token == "browser-token")
+                return self.stubResponse()
+            }
+
+            _ = try await ManusUsageFetcher.$fetchCreditsOverride.withValue(fetchOverride, operation: {
+                try await strategy.fetch(context)
+            })
+
+            let cached = CookieHeaderCache.load(provider: .manus)
+            #expect(cached?.cookieHeader == "session_id=browser-token")
+        }
+    }
+    #endif
+
+    @Test
+    func `settings reader accepts full cookie header from environment`() {
+        let env = ["MANUS_COOKIE": "foo=bar; session_id=env-cookie-token; baz=qux"]
+        #expect(ManusSettingsReader.sessionToken(environment: env) == "env-cookie-token")
+    }
+
+    @Test
+    func `parse response tolerates sparse live payload`() throws {
+        let data = Data("""
+        {
+          "totalCredits": 2869,
+          "freeCredits": 1500,
+          "periodicCredits": 1369,
+          "proMonthlyCredits": 4000,
+          "maxRefreshCredits": 300,
+          "nextRefreshTime": "2026-04-13T00:00:00Z",
+          "refreshInterval": "daily",
+          "userFlag": { "drc16": true }
+        }
+        """.utf8)
+
+        let response = try ManusUsageFetcher.parseResponse(data)
+        #expect(response.totalCredits == 2869)
+        #expect(response.periodicCredits == 1369)
+        #expect(response.proMonthlyCredits == 4000)
+        #expect(response.refreshCredits == 0)
+        #expect(response.addonCredits == 0)
+        #expect(response.maxRefreshCredits == 300)
+        #expect(response.nextRefreshTime != nil)
+
+        let snapshot = response.toUsageSnapshot(now: Self.now)
+        #expect(snapshot.providerCost == nil)
+        #expect(snapshot.primary?.usedPercent ?? 0 > 65)
+        #expect(snapshot.primary?.resetDescription == "Total 2,869 • Free 1,500")
+        #expect(snapshot.secondary?.usedPercent == 100)
+        #expect(snapshot.secondary?.resetDescription == "Daily: 0 / 300")
+    }
+
+    @Test
+    func `parse response rejects payload without credits fields`() {
+        let data = Data(#"{"error":"unauthorized","message":"session expired"}"#.utf8)
+
+        #expect(throws: ManusAPIError.self) {
+            try ManusUsageFetcher.parseResponse(data)
+        }
+    }
+
+    @Test
+    func `parse response accepts wrapped envelope`() throws {
+        let data = Data("""
+        {
+          "data": {
+            "totalCredits": 100,
+            "proMonthlyCredits": 200,
+            "periodicCredits": 50,
+            "maxRefreshCredits": 10,
+            "refreshCredits": 5
+          }
+        }
+        """.utf8)
+
+        let response = try ManusUsageFetcher.parseResponse(data)
+        #expect(response.totalCredits == 100)
+        #expect(response.periodicCredits == 50)
+    }
+}
diff --git a/Tests/CodexBarTests/MemoryPressureCacheTrimTests.swift b/Tests/CodexBarTests/MemoryPressureCacheTrimTests.swift
new file mode 100644
index 0000000000..1f028030ea
--- /dev/null
+++ b/Tests/CodexBarTests/MemoryPressureCacheTrimTests.swift
@@ -0,0 +1,217 @@
+import AppKit
+import CodexBarCore
+import Dispatch
+import Testing
+@testable import CodexBar
+
+@MainActor
+struct MemoryPressureCacheTrimTests {
+    @Test
+    func `memory pressure monitor invokes app cache trim and allocator relief handlers`() async {
+        var handlerCalls = 0
+        let releaseProbe = MemoryPressureReleaseProbe()
+        let monitor = MemoryPressureMonitor(
+            trimAppCaches: {
+                handlerCalls += 1
+                return MemoryPressureCacheTrimSummary(menuCardHeights: 1)
+            },
+            releaseFreeMallocPages: {
+                releaseProbe.signal()
+            })
+
+        monitor.handleMemoryPressureForTesting(isWarning: true, isCritical: false)
+
+        #expect(handlerCalls == 1)
+        let releaseCompleted = await Task.detached {
+            releaseProbe.wait(timeout: .now() + 2)
+        }.value
+        #expect(releaseCompleted)
+    }
+
+    @Test
+    func `memory pressure event handler runs from utility queue and hops to main actor`() async {
+        let probe = MemoryPressureEventHandlerProbe()
+        let handler = MemoryPressureMonitor.makeEventHandler(
+            eventReader: { [.warning] },
+            handle: { isWarning, isCritical in
+                probe.record(
+                    isWarning: isWarning,
+                    isCritical: isCritical,
+                    handledOnMainThread: Thread.isMainThread)
+            })
+
+        DispatchQueue.global(qos: .utility).async {
+            probe.recordInvocationThread(isMainThread: Thread.isMainThread)
+            handler()
+        }
+
+        let completed = await Task.detached {
+            probe.wait(timeout: .now() + 2)
+        }.value
+        #expect(completed)
+
+        let snapshot = probe.snapshot()
+        #expect(snapshot.invokedOnMainThread == false)
+        #expect(snapshot.isWarning)
+        #expect(!snapshot.isCritical)
+        #expect(snapshot.handledOnMainThread)
+    }
+
+    @Test
+    func `status controller trims rebuildable menu caches on memory pressure`() {
+        let controller = self.makeController()
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let key = StatusItemController.MenuCardHeightCacheKey(
+            id: "card",
+            scope: UsageProvider.codex.rawValue,
+            width: 30000,
+            textScale: StatusItemController.menuCardHeightTextScaleToken(),
+            fingerprint: "content:stable")
+        let menu = NSMenu()
+        let entry = CachedMergedSwitcherMenuContent(
+            requiredMenuContentVersion: 0,
+            menuWidth: 300,
+            codexAccountDisplay: nil,
+            tokenAccountDisplay: nil,
+            localizationSignature: "",
+            items: [])
+
+        controller.menuCardHeightCache[key] = 42
+        controller.measuredStandardMenuWidthCache["width"] = 300
+        controller.mergedSwitcherContentCaches[ObjectIdentifier(menu)] = [
+            .overview: entry,
+            .provider(.codex): entry,
+        ]
+        controller.menuCardViewRecyclePool["card"] = NSView()
+
+        let summary = controller.trimRebuildableCachesForMemoryPressure()
+
+        #expect(summary.menuCardHeights == 1)
+        #expect(summary.menuWidths == 1)
+        #expect(summary.mergedSwitcherSelections == 2)
+        #expect(summary.recycledMenuCardViews == 1)
+        #expect(controller.menuCardHeightCache.isEmpty)
+        #expect(controller.measuredStandardMenuWidthCache.isEmpty)
+        #expect(controller.mergedSwitcherContentCaches.isEmpty)
+        #expect(controller.menuCardViewRecyclePool.isEmpty)
+    }
+
+    @Test
+    func `usage store trims OpenAI web debug cache without interrupting active refresh state`() {
+        let store = self.makeStore()
+        let taskToken = UUID()
+
+        store.openAIWebDebugLines = ["line 1", "line 2", "line 3"]
+        store.openAIDashboardCookieImportDebugLog = "line 1\nline 2\nline 3"
+        store.isRefreshing = true
+        store.refreshingProviders = [.codex]
+        store.tokenRefreshInFlight = [.codex]
+        store.openAIDashboardRefreshTaskKey = "codex@example.com:manual"
+        store.openAIDashboardRefreshTaskToken = taskToken
+
+        let summary = store.trimRebuildableCachesForMemoryPressure()
+
+        #expect(summary.openAIWebDebugLines == 3)
+        #expect(store.openAIWebDebugLines.isEmpty)
+        #expect(store.openAIDashboardCookieImportDebugLog == nil)
+        #expect(store.isRefreshing)
+        #expect(store.refreshingProviders == [.codex])
+        #expect(store.tokenRefreshInFlight == [.codex])
+        #expect(store.openAIDashboardRefreshTaskKey == "codex@example.com:manual")
+        #expect(store.openAIDashboardRefreshTaskToken == taskToken)
+    }
+
+    private func makeController() -> StatusItemController {
+        let settings = self.makeSettings()
+        let store = self.makeStore(settings: settings)
+        return StatusItemController(
+            store: store,
+            settings: settings,
+            account: AccountInfo(email: nil, plan: nil),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system)
+    }
+
+    private func makeStore(settings: SettingsStore? = nil) -> UsageStore {
+        let resolvedSettings = settings ?? self.makeSettings()
+        return UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: resolvedSettings)
+    }
+
+    private func makeSettings() -> SettingsStore {
+        let suite = "MemoryPressureCacheTrimTests-\(UUID().uuidString)"
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.providerDetectionCompleted = true
+        return settings
+    }
+}
+
+private final class MemoryPressureReleaseProbe: @unchecked Sendable {
+    private let semaphore = DispatchSemaphore(value: 0)
+
+    func signal() {
+        self.semaphore.signal()
+    }
+
+    func wait(timeout: DispatchTime) -> Bool {
+        self.semaphore.wait(timeout: timeout) == .success
+    }
+}
+
+private final class MemoryPressureEventHandlerProbe: @unchecked Sendable {
+    struct Snapshot {
+        let invokedOnMainThread: Bool?
+        let isWarning: Bool
+        let isCritical: Bool
+        let handledOnMainThread: Bool
+    }
+
+    private let lock = NSLock()
+    private let semaphore = DispatchSemaphore(value: 0)
+    private var invokedOnMainThread: Bool?
+    private var isWarning = false
+    private var isCritical = false
+    private var handledOnMainThread = false
+
+    func recordInvocationThread(isMainThread: Bool) {
+        self.lock.withLock {
+            self.invokedOnMainThread = isMainThread
+        }
+    }
+
+    func record(isWarning: Bool, isCritical: Bool, handledOnMainThread: Bool) {
+        self.lock.withLock {
+            self.isWarning = isWarning
+            self.isCritical = isCritical
+            self.handledOnMainThread = handledOnMainThread
+        }
+        self.semaphore.signal()
+    }
+
+    func wait(timeout: DispatchTime) -> Bool {
+        self.semaphore.wait(timeout: timeout) == .success
+    }
+
+    func snapshot() -> Snapshot {
+        self.lock.withLock {
+            Snapshot(
+                invokedOnMainThread: self.invokedOnMainThread,
+                isWarning: self.isWarning,
+                isCritical: self.isCritical,
+                handledOnMainThread: self.handledOnMainThread)
+        }
+    }
+}
diff --git a/Tests/CodexBarTests/MenuBarCountdownRefreshTests.swift b/Tests/CodexBarTests/MenuBarCountdownRefreshTests.swift
new file mode 100644
index 0000000000..e17b9508db
--- /dev/null
+++ b/Tests/CodexBarTests/MenuBarCountdownRefreshTests.swift
@@ -0,0 +1,102 @@
+import AppKit
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@MainActor
+@Suite(.serialized)
+struct MenuBarCountdownRefreshTests {
+    @Test
+    func `countdown refresh delay follows the next displayed minute boundary`() {
+        let now = Date(timeIntervalSince1970: 1_800_000_000)
+
+        let delay = StatusItemController.menuBarCountdownRefreshDelay(
+            resetDates: [
+                now.addingTimeInterval(2 * 3600 + 15 * 60 + 30),
+                now.addingTimeInterval(45),
+            ],
+            now: now)
+
+        #expect(abs((delay ?? 0) - 30.05) < 0.001)
+    }
+
+    @Test
+    func `countdown refresh ignores elapsed reset dates`() {
+        let now = Date(timeIntervalSince1970: 1_800_000_000)
+
+        let delay = StatusItemController.menuBarCountdownRefreshDelay(
+            resetDates: [now.addingTimeInterval(-1)],
+            now: now)
+
+        #expect(delay == nil)
+    }
+
+    @Test
+    func `status item schedules countdown refresh only for countdown reset dates`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "MenuBarCountdownRefreshTests-scheduling"),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.menuBarShowsBrandIconWithPercent = true
+        settings.menuBarDisplayMode = .resetTime
+        settings.resetTimesShowAbsolute = false
+        if let metadata = ProviderRegistry.shared.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: metadata, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(
+            fetcher: fetcher,
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings)
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 42,
+                    windowMinutes: 300,
+                    resetsAt: Date().addingTimeInterval(90),
+                    resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date()),
+            provider: .codex)
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        #expect(controller._test_isMenuBarCountdownRefreshScheduled())
+
+        settings.resetTimesShowAbsolute = true
+        controller.updateIcons()
+        #expect(!controller._test_isMenuBarCountdownRefreshScheduled())
+
+        settings.resetTimesShowAbsolute = false
+        store._setSnapshotForTesting(nil, provider: .codex)
+        controller.updateIcons()
+        #expect(!controller._test_isMenuBarCountdownRefreshScheduled())
+
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 42,
+                    windowMinutes: 300,
+                    resetsAt: Date().addingTimeInterval(90),
+                    resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date()),
+            provider: .codex)
+        controller.updateIcons()
+        #expect(controller._test_isMenuBarCountdownRefreshScheduled())
+
+        controller.prepareForAppShutdown()
+        #expect(!controller._test_isMenuBarCountdownRefreshScheduled())
+    }
+}
diff --git a/Tests/CodexBarTests/MenuBarMetricWindowResolverTests.swift b/Tests/CodexBarTests/MenuBarMetricWindowResolverTests.swift
new file mode 100644
index 0000000000..26dfd63ccd
--- /dev/null
+++ b/Tests/CodexBarTests/MenuBarMetricWindowResolverTests.swift
@@ -0,0 +1,469 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct MenuBarMetricWindowResolverTests {
+    @Test
+    func `automatic metric uses zai 5-hour token lane when it is most constrained`() {
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 12, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 10, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            tertiary: RateWindow(usedPercent: 92, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        let window = MenuBarMetricWindowResolver.rateWindow(
+            preference: .automatic,
+            provider: .zai,
+            snapshot: snapshot,
+            supportsAverage: false)
+
+        #expect(window?.usedPercent == 92)
+    }
+
+    @Test
+    func `automatic metric uses minimax weekly token lane when it is most constrained`() {
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 0, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 97, windowMinutes: 7 * 24 * 60, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        let window = MenuBarMetricWindowResolver.rateWindow(
+            preference: .automatic,
+            provider: .minimax,
+            snapshot: snapshot,
+            supportsAverage: false)
+
+        #expect(window?.usedPercent == 97)
+        #expect(window?.windowMinutes == 7 * 24 * 60)
+    }
+
+    @Test
+    func `combined primary and secondary metric uses the most constrained lane`() {
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 12, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 91, windowMinutes: 7 * 24 * 60, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        let window = MenuBarMetricWindowResolver.rateWindow(
+            preference: .primaryAndSecondary,
+            provider: .codex,
+            snapshot: snapshot,
+            supportsAverage: false)
+
+        #expect(window?.usedPercent == 91)
+        #expect(window?.windowMinutes == 7 * 24 * 60)
+    }
+
+    @Test
+    func `automatic metric skips exhausted cursor subquota when total remains usable`() {
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 67, windowMinutes: 30 * 24 * 60, resetsAt: nil, resetDescription: "Total"),
+            secondary: RateWindow(
+                usedPercent: 34,
+                windowMinutes: 30 * 24 * 60,
+                resetsAt: nil,
+                resetDescription: "Auto"),
+            tertiary: RateWindow(usedPercent: 100, windowMinutes: 30 * 24 * 60, resetsAt: nil, resetDescription: "API"),
+            updatedAt: Date())
+
+        let window = MenuBarMetricWindowResolver.rateWindow(
+            preference: .automatic,
+            provider: .cursor,
+            snapshot: snapshot,
+            supportsAverage: false)
+
+        #expect(window?.remainingPercent == 33)
+        #expect(window?.resetDescription == "Total")
+    }
+
+    @Test
+    func `automatic metric still reports cursor exhausted when every subquota is exhausted`() {
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 100,
+                windowMinutes: 30 * 24 * 60,
+                resetsAt: nil,
+                resetDescription: "Total"),
+            secondary: RateWindow(
+                usedPercent: 100,
+                windowMinutes: 30 * 24 * 60,
+                resetsAt: nil,
+                resetDescription: "Auto"),
+            tertiary: RateWindow(usedPercent: 100, windowMinutes: 30 * 24 * 60, resetsAt: nil, resetDescription: "API"),
+            updatedAt: Date())
+
+        let window = MenuBarMetricWindowResolver.rateWindow(
+            preference: .automatic,
+            provider: .cursor,
+            snapshot: snapshot,
+            supportsAverage: false)
+
+        #expect(window?.remainingPercent == 0)
+    }
+
+    @Test
+    func `automatic metric keeps exhausted cursor total when a subquota remains usable`() {
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 100,
+                windowMinutes: 30 * 24 * 60,
+                resetsAt: nil,
+                resetDescription: "Total"),
+            secondary: RateWindow(
+                usedPercent: 60,
+                windowMinutes: 30 * 24 * 60,
+                resetsAt: nil,
+                resetDescription: "Auto"),
+            tertiary: nil,
+            updatedAt: Date())
+
+        let window = MenuBarMetricWindowResolver.rateWindow(
+            preference: .automatic,
+            provider: .cursor,
+            snapshot: snapshot,
+            supportsAverage: false)
+
+        #expect(window?.remainingPercent == 0)
+        #expect(window?.resetDescription == "Total")
+    }
+
+    @Test
+    func `automatic metric reports cursor exhausted when all present subquotas are exhausted`() {
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 67, windowMinutes: 30 * 24 * 60, resetsAt: nil, resetDescription: "Total"),
+            secondary: RateWindow(
+                usedPercent: 100,
+                windowMinutes: 30 * 24 * 60,
+                resetsAt: nil,
+                resetDescription: "Auto"),
+            tertiary: RateWindow(usedPercent: 100, windowMinutes: 30 * 24 * 60, resetsAt: nil, resetDescription: "API"),
+            updatedAt: Date())
+
+        let window = MenuBarMetricWindowResolver.rateWindow(
+            preference: .automatic,
+            provider: .cursor,
+            snapshot: snapshot,
+            supportsAverage: false)
+
+        #expect(window?.remainingPercent == 0)
+    }
+
+    @Test
+    func `automatic metric preserves exhausted minimax session lane`() {
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 100, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 97, windowMinutes: 7 * 24 * 60, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        let window = MenuBarMetricWindowResolver.rateWindow(
+            preference: .automatic,
+            provider: .minimax,
+            snapshot: snapshot,
+            supportsAverage: false)
+
+        #expect(window?.usedPercent == 100)
+        #expect(window?.windowMinutes == 300)
+    }
+
+    @Test
+    func `automatic metric uses team budget for team-bound LiteLLM keys`() {
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 10,
+                windowMinutes: nil,
+                resetsAt: nil,
+                resetDescription: "Personal"),
+            secondary: RateWindow(
+                usedPercent: 80,
+                windowMinutes: nil,
+                resetsAt: nil,
+                resetDescription: "Team"),
+            updatedAt: Date())
+
+        let window = MenuBarMetricWindowResolver.rateWindow(
+            preference: .automatic,
+            provider: .litellm,
+            snapshot: snapshot,
+            supportsAverage: false)
+
+        #expect(window?.usedPercent == 80)
+        #expect(window?.resetDescription == "Team")
+    }
+
+    @Test
+    func `automatic metric uses constrained antigravity family lane`() {
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 0, windowMinutes: nil, resetsAt: nil, resetDescription: "Claude"),
+            secondary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: "Gemini Pro"),
+            tertiary: RateWindow(usedPercent: 40, windowMinutes: nil, resetsAt: nil, resetDescription: "Gemini Flash"),
+            updatedAt: Date())
+
+        let window = MenuBarMetricWindowResolver.rateWindow(
+            preference: .automatic,
+            provider: .antigravity,
+            snapshot: snapshot,
+            supportsAverage: false)
+
+        #expect(window?.usedPercent == 100)
+        #expect(window?.resetDescription == "Gemini Pro")
+    }
+
+    @Test
+    func `automatic metric skips exhausted antigravity five hour bucket when another remains usable`() {
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 30, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 67, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            extraRateWindows: [
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-gemini-5h",
+                    title: "Gemini Models Five Hour Limit",
+                    window: RateWindow(usedPercent: 71, windowMinutes: 300, resetsAt: nil, resetDescription: nil)),
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-gemini-weekly",
+                    title: "Gemini Models Weekly Limit",
+                    window: RateWindow(usedPercent: 30, windowMinutes: 10080, resetsAt: nil, resetDescription: nil)),
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-3p-5h",
+                    title: "Claude and GPT models Five Hour Limit",
+                    window: RateWindow(usedPercent: 100, windowMinutes: 300, resetsAt: nil, resetDescription: nil)),
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-3p-weekly",
+                    title: "Claude and GPT models Weekly Limit",
+                    window: RateWindow(usedPercent: 67, windowMinutes: 10080, resetsAt: nil, resetDescription: nil)),
+            ],
+            updatedAt: Date())
+
+        let window = MenuBarMetricWindowResolver.rateWindow(
+            preference: .automatic,
+            provider: .antigravity,
+            snapshot: snapshot,
+            supportsAverage: false)
+
+        #expect(window?.remainingPercent == 29)
+        #expect(window?.windowMinutes == 300)
+    }
+
+    @Test
+    func `automatic metric uses recognized antigravity gemini pool when claude gpt is reset only`() throws {
+        let resetOnlyReset = Date(timeIntervalSince1970: 1000)
+        let exhaustedReset = Date(timeIntervalSince1970: 2000)
+        let antigravitySnapshot = AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "Claude Sonnet 4.6",
+                    modelId: "claude-sonnet-4-6",
+                    remainingFraction: nil,
+                    resetTime: resetOnlyReset,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Gemini 3.1 Pro",
+                    modelId: "gemini-3-1-pro",
+                    remainingFraction: 0,
+                    resetTime: exhaustedReset,
+                    resetDescription: nil),
+            ],
+            accountEmail: nil,
+            accountPlan: nil,
+            source: .local)
+        let snapshot = try antigravitySnapshot.toUsageSnapshot()
+        #expect(snapshot.primary?.usedPercent == 100)
+        #expect(snapshot.primary?.resetsAt == exhaustedReset)
+        #expect(snapshot.secondary == nil)
+
+        let window = MenuBarMetricWindowResolver.rateWindow(
+            preference: .automatic,
+            provider: .antigravity,
+            snapshot: snapshot,
+            supportsAverage: false)
+
+        #expect(window?.usedPercent == 100)
+        #expect(window?.resetsAt == exhaustedReset)
+    }
+
+    @Test
+    func `automatic metric uses unclassified antigravity compact fallback`() throws {
+        let antigravitySnapshot = AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "Experimental Model",
+                    modelId: "MODEL_PLACEHOLDER_NEW",
+                    remainingFraction: 0.36,
+                    resetTime: nil,
+                    resetDescription: nil),
+            ],
+            accountEmail: nil,
+            accountPlan: nil,
+            source: .local)
+        let snapshot = try antigravitySnapshot.toUsageSnapshot()
+
+        let window = MenuBarMetricWindowResolver.rateWindow(
+            preference: .automatic,
+            provider: .antigravity,
+            snapshot: snapshot,
+            supportsAverage: false)
+
+        #expect(window?.usedPercent == 64)
+    }
+
+    @Test
+    func `explicit antigravity metric keeps requested family lane`() {
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 0, windowMinutes: nil, resetsAt: nil, resetDescription: "Claude"),
+            secondary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: "Gemini Pro"),
+            tertiary: RateWindow(usedPercent: 40, windowMinutes: nil, resetsAt: nil, resetDescription: "Gemini Flash"),
+            updatedAt: Date())
+
+        let primary = MenuBarMetricWindowResolver.rateWindow(
+            preference: .primary,
+            provider: .antigravity,
+            snapshot: snapshot,
+            supportsAverage: false)
+        let secondary = MenuBarMetricWindowResolver.rateWindow(
+            preference: .secondary,
+            provider: .antigravity,
+            snapshot: snapshot,
+            supportsAverage: false)
+        let tertiary = MenuBarMetricWindowResolver.rateWindow(
+            preference: .tertiary,
+            provider: .antigravity,
+            snapshot: snapshot,
+            supportsAverage: false)
+
+        #expect(primary?.resetDescription == "Claude")
+        #expect(secondary?.resetDescription == "Gemini Pro")
+        #expect(tertiary?.resetDescription == "Gemini Flash")
+    }
+
+    @Test
+    func `monthly plan metric selects Mistral subscription window`() {
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            extraRateWindows: [
+                NamedRateWindow(
+                    id: "mistral-monthly-plan",
+                    title: "Monthly Plan",
+                    window: RateWindow(usedPercent: 42, windowMinutes: nil, resetsAt: nil, resetDescription: nil)),
+            ],
+            updatedAt: Date())
+
+        let window = MenuBarMetricWindowResolver.rateWindow(
+            preference: .monthlyPlan,
+            provider: .mistral,
+            snapshot: snapshot,
+            supportsAverage: false)
+
+        #expect(window?.usedPercent == 42)
+    }
+
+    @Test
+    func `extra usage metric maps provider cost into a menu bar window`() {
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 12, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            providerCost: ProviderCostSnapshot(
+                used: 37.5,
+                limit: 150,
+                currencyCode: "USD",
+                updatedAt: Date()),
+            updatedAt: Date())
+
+        let window = MenuBarMetricWindowResolver.rateWindow(
+            preference: .extraUsage,
+            provider: .cursor,
+            snapshot: snapshot,
+            supportsAverage: false)
+
+        #expect(window?.usedPercent == 25)
+    }
+
+    @Test
+    func `automatic metric uses claude enterprise spend limit`() {
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            providerCost: ProviderCostSnapshot(
+                used: 67.03,
+                limit: 1000,
+                currencyCode: "USD",
+                period: "Spend limit",
+                updatedAt: Date()),
+            updatedAt: Date())
+
+        let window = MenuBarMetricWindowResolver.rateWindow(
+            preference: .automatic,
+            provider: .claude,
+            snapshot: snapshot,
+            supportsAverage: false)
+
+        #expect(abs((window?.usedPercent ?? 0) - 6.703) < 0.0001)
+    }
+
+    @Test
+    func `automatic metric uses claude web spend limit placeholder`() {
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 0, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            providerCost: ProviderCostSnapshot(
+                used: 67.03,
+                limit: 1000,
+                currencyCode: "USD",
+                period: "Monthly",
+                updatedAt: Date()),
+            updatedAt: Date())
+
+        let window = MenuBarMetricWindowResolver.rateWindow(
+            preference: .automatic,
+            provider: .claude,
+            snapshot: snapshot,
+            supportsAverage: false)
+
+        #expect(abs((window?.usedPercent ?? 0) - 6.703) < 0.0001)
+    }
+
+    @Test
+    func `automatic metric keeps claude quota window when extra usage is optional`() {
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 42, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            providerCost: ProviderCostSnapshot(
+                used: 67.03,
+                limit: 1000,
+                currencyCode: "USD",
+                period: "Monthly",
+                updatedAt: Date()),
+            updatedAt: Date())
+
+        let window = MenuBarMetricWindowResolver.rateWindow(
+            preference: .automatic,
+            provider: .claude,
+            snapshot: snapshot,
+            supportsAverage: false)
+
+        #expect(window?.usedPercent == 42)
+    }
+
+    @Test
+    func `automatic metric keeps claude zero quota window when reset exists`() {
+        let reset = Date(timeIntervalSince1970: 1000)
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 0, windowMinutes: 300, resetsAt: reset, resetDescription: "later"),
+            secondary: nil,
+            providerCost: ProviderCostSnapshot(
+                used: 67.03,
+                limit: 1000,
+                currencyCode: "USD",
+                period: "Monthly",
+                updatedAt: Date()),
+            updatedAt: Date())
+
+        let window = MenuBarMetricWindowResolver.rateWindow(
+            preference: .automatic,
+            provider: .claude,
+            snapshot: snapshot,
+            supportsAverage: false)
+
+        #expect(window?.resetsAt == reset)
+    }
+}
diff --git a/Tests/CodexBarTests/MenuBarResetTimeDisplayTests.swift b/Tests/CodexBarTests/MenuBarResetTimeDisplayTests.swift
new file mode 100644
index 0000000000..231e3b2e6d
--- /dev/null
+++ b/Tests/CodexBarTests/MenuBarResetTimeDisplayTests.swift
@@ -0,0 +1,136 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct MenuBarResetTimeDisplayTests {
+    @Test
+    func `reset time mode formats the selected window reset`() {
+        let now = Date(timeIntervalSince1970: 1_800_000_000)
+        let resetsAt = now.addingTimeInterval(2 * 3600)
+        let window = RateWindow(
+            usedPercent: 42,
+            windowMinutes: 300,
+            resetsAt: resetsAt,
+            resetDescription: nil)
+
+        let text = MenuBarDisplayText.displayText(
+            mode: .resetTime,
+            percentWindow: window,
+            showUsed: true,
+            resetTimeDisplayStyle: .absolute,
+            now: now)
+
+        #expect(text == "↻ \(UsageFormatter.resetDescription(from: resetsAt, now: now))")
+    }
+
+    @Test
+    func `reset time mode uses countdown preference`() {
+        let now = Date(timeIntervalSince1970: 1_800_000_000)
+        let resetsAt = now.addingTimeInterval(2 * 3600 + 15 * 60)
+        let window = RateWindow(
+            usedPercent: 42,
+            windowMinutes: 300,
+            resetsAt: resetsAt,
+            resetDescription: nil)
+
+        let text = MenuBarDisplayText.displayText(
+            mode: .resetTime,
+            percentWindow: window,
+            showUsed: true,
+            resetTimeDisplayStyle: .countdown,
+            now: now)
+
+        #expect(text == "↻ in 2h 15m")
+    }
+
+    @Test
+    func `reset time mode falls back to used percent without reset metadata`() {
+        let window = RateWindow(
+            usedPercent: 42,
+            windowMinutes: 300,
+            resetsAt: nil,
+            resetDescription: nil)
+
+        let text = MenuBarDisplayText.displayText(
+            mode: .resetTime,
+            percentWindow: window,
+            showUsed: true)
+
+        #expect(text == "42%")
+    }
+
+    @Test
+    func `reset time mode uses text reset metadata`() {
+        let window = RateWindow(
+            usedPercent: 42,
+            windowMinutes: 300,
+            resetsAt: nil,
+            resetDescription: "in 2h 15m")
+
+        let text = MenuBarDisplayText.displayText(
+            mode: .resetTime,
+            percentWindow: window,
+            showUsed: true)
+
+        #expect(text == "↻ in 2h 15m")
+    }
+
+    @Test(arguments: [
+        "Resets in 2h",
+        "tomorrow, 3:00 PM",
+        "next week",
+        "expires in 4d",
+    ])
+    func `reset time mode accepts reset timing phrases`(_ description: String) {
+        let window = RateWindow(
+            usedPercent: 42,
+            windowMinutes: 300,
+            resetsAt: nil,
+            resetDescription: description)
+
+        let text = MenuBarDisplayText.displayText(
+            mode: .resetTime,
+            percentWindow: window,
+            showUsed: true)
+
+        #expect(text == "↻ \(description)")
+    }
+
+    @Test(arguments: [
+        "250/1000 requests",
+        "160 requests",
+        "5 hours window",
+        "$10.00 available",
+    ])
+    func `reset time mode rejects non-reset provider summaries`(_ description: String) {
+        let window = RateWindow(
+            usedPercent: 42,
+            windowMinutes: 300,
+            resetsAt: nil,
+            resetDescription: description)
+
+        let text = MenuBarDisplayText.displayText(
+            mode: .resetTime,
+            percentWindow: window,
+            showUsed: true)
+
+        #expect(text == "42%")
+    }
+
+    @Test
+    func `reset time mode falls back to remaining percent without reset metadata`() {
+        let window = RateWindow(
+            usedPercent: 42,
+            windowMinutes: 300,
+            resetsAt: nil,
+            resetDescription: nil)
+
+        let text = MenuBarDisplayText.displayText(
+            mode: .resetTime,
+            percentWindow: window,
+            showUsed: false)
+
+        #expect(text == "58%")
+    }
+}
diff --git a/Tests/CodexBarTests/MenuBarVisibilityWatcherTests.swift b/Tests/CodexBarTests/MenuBarVisibilityWatcherTests.swift
new file mode 100644
index 0000000000..d61069995a
--- /dev/null
+++ b/Tests/CodexBarTests/MenuBarVisibilityWatcherTests.swift
@@ -0,0 +1,490 @@
+import CoreGraphics
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct MenuBarVisibilityWatcherTests {
+    @Test
+    func `does not flag intentionally hidden status item`() {
+        let snapshot = StatusItemVisibilitySnapshot(
+            isVisible: false,
+            hasButton: true,
+            hasWindow: false,
+            hasScreen: false,
+            buttonWidth: 0)
+
+        #expect(!MenuBarVisibilityWatcher.isBlockedSnapshot(snapshot: snapshot))
+    }
+
+    @Test
+    func `flags visible item without attached window`() {
+        let snapshot = StatusItemVisibilitySnapshot(
+            isVisible: true,
+            hasButton: true,
+            hasWindow: false,
+            hasScreen: false,
+            buttonWidth: 18)
+
+        #expect(MenuBarVisibilityWatcher.isBlockedSnapshot(snapshot: snapshot))
+    }
+
+    @Test
+    func `flags visible item without button`() {
+        let snapshot = StatusItemVisibilitySnapshot(
+            isVisible: true,
+            hasButton: false,
+            hasWindow: false,
+            hasScreen: false,
+            buttonWidth: 0)
+
+        #expect(MenuBarVisibilityWatcher.isBlockedSnapshot(snapshot: snapshot))
+    }
+
+    @Test
+    func `flags visible item with zero width`() {
+        let snapshot = StatusItemVisibilitySnapshot(
+            isVisible: true,
+            hasButton: true,
+            hasWindow: true,
+            hasScreen: true,
+            buttonWidth: 0)
+
+        #expect(MenuBarVisibilityWatcher.isBlockedSnapshot(snapshot: snapshot))
+    }
+
+    @Test
+    func `allows visible item attached to a screen with width`() {
+        let snapshot = StatusItemVisibilitySnapshot(
+            isVisible: true,
+            hasButton: true,
+            hasWindow: true,
+            hasScreen: true,
+            buttonWidth: 18)
+
+        #expect(!MenuBarVisibilityWatcher.isBlockedSnapshot(snapshot: snapshot))
+    }
+
+    @Test
+    func `window probe matches autosave name and reports display bounds`() {
+        let snapshots = MenuBarStatusItemWindowProbe.snapshots(
+            matching: ["codexbar-merged"],
+            windowInfo: [[
+                kCGWindowName as String: "codexbar-merged",
+                kCGWindowOwnerName as String: "Control Center",
+                kCGWindowIsOnscreen as String: true,
+                kCGWindowBounds as String: [
+                    "X": 1680,
+                    "Y": 0,
+                    "Width": 70,
+                    "Height": 24,
+                ],
+            ]],
+            displayBounds: [CGRect(x: 0, y: 0, width: 2056, height: 1329)])
+
+        #expect(snapshots.count == 1)
+        #expect(snapshots.first?.name == "codexbar-merged")
+        #expect(snapshots.first?.ownerName == "Control Center")
+        #expect(snapshots.first?.isOnscreen == true)
+        #expect(snapshots.first?.isWithinDisplayBounds == true)
+    }
+
+    @Test
+    func `window probe detects offscreen status item by bounds`() {
+        let snapshots = MenuBarStatusItemWindowProbe.snapshots(
+            matching: ["codexbar-merged"],
+            windowInfo: [[
+                kCGWindowName as String: "codexbar-merged",
+                kCGWindowOwnerName as String: "Control Center",
+                kCGWindowIsOnscreen as String: true,
+                kCGWindowBounds as String: [
+                    "X": 2023,
+                    "Y": 0,
+                    "Width": 71,
+                    "Height": 24,
+                ],
+            ]],
+            displayBounds: [CGRect(x: 0, y: 0, width: 2056, height: 1329)])
+
+        #expect(snapshots.count == 1)
+        #expect(snapshots.first?.isOnscreen == true)
+        #expect(snapshots.first?.isWithinDisplayBounds == false)
+    }
+
+    @Test
+    func `window probe identifies Tahoe Control Center blocked proxy geometry`() {
+        let snapshot = MenuBarStatusItemWindowSnapshot(
+            name: "codexbar-merged",
+            ownerName: "Control Center",
+            bounds: CGRect(x: 0, y: -22, width: 76, height: 22),
+            isOnscreen: true,
+            displayBounds: nil)
+
+        #expect(snapshot.isTahoeBlockedProxy)
+    }
+
+    @Test
+    func `window probe does not classify generic offscreen manager placement as Tahoe proxy`() {
+        let snapshot = MenuBarStatusItemWindowSnapshot(
+            name: "codexbar-merged",
+            ownerName: "Control Center",
+            bounds: CGRect(x: 2023, y: 0, width: 71, height: 24),
+            isOnscreen: true,
+            displayBounds: nil)
+
+        #expect(!snapshot.isTahoeBlockedProxy)
+    }
+
+    @Test
+    func `window probe does not classify stale hidden Control Center record as Tahoe proxy`() {
+        let snapshot = MenuBarStatusItemWindowSnapshot(
+            name: "codexbar-merged",
+            ownerName: "Control Center",
+            bounds: CGRect(x: 0, y: -22, width: 76, height: 22),
+            isOnscreen: false,
+            displayBounds: nil)
+
+        #expect(!snapshot.isTahoeBlockedProxy)
+    }
+
+    @Test
+    func `allows visible item attached to a detached screen`() {
+        let snapshot = StatusItemVisibilitySnapshot(
+            isVisible: true,
+            hasButton: true,
+            hasWindow: true,
+            hasScreen: true,
+            isOnCurrentScreen: false,
+            buttonWidth: 18)
+
+        #expect(!MenuBarVisibilityWatcher.isBlockedSnapshot(snapshot: snapshot))
+    }
+
+    @Test
+    func `classifies detached live item as displaced but not blocked`() {
+        let snapshot = StatusItemVisibilitySnapshot(
+            isVisible: true,
+            hasButton: true,
+            hasWindow: true,
+            hasScreen: false,
+            isOnCurrentScreen: false,
+            buttonWidth: 18)
+
+        #expect(!MenuBarVisibilityWatcher.isBlockedSnapshot(snapshot: snapshot))
+        #expect(MenuBarVisibilityWatcher.isDisplacedSnapshot(snapshot: snapshot))
+    }
+
+    @Test
+    func `classifies stale screen live item as displaced but not blocked`() {
+        let snapshot = StatusItemVisibilitySnapshot(
+            isVisible: true,
+            hasButton: true,
+            hasWindow: true,
+            hasScreen: true,
+            isOnCurrentScreen: false,
+            buttonWidth: 18)
+
+        #expect(!MenuBarVisibilityWatcher.isBlockedSnapshot(snapshot: snapshot))
+        #expect(MenuBarVisibilityWatcher.isDisplacedSnapshot(snapshot: snapshot))
+    }
+
+    @Test
+    func `guidance shows once then repeats after a day`() throws {
+        let defaults = try #require(UserDefaults(suiteName: "MenuBarVisibilityWatcherTests"))
+        defaults.removePersistentDomain(forName: "MenuBarVisibilityWatcherTests")
+        let now = Date(timeIntervalSince1970: 1000)
+
+        #expect(MenuBarVisibilityWatcher.shouldShowGuidance(defaults: defaults, now: now))
+
+        MenuBarVisibilityWatcher.markGuidanceShown(defaults: defaults, now: now)
+
+        #expect(!MenuBarVisibilityWatcher.shouldShowGuidance(
+            defaults: defaults,
+            now: now.addingTimeInterval(MenuBarVisibilityWatcher.guidanceRepeatInterval - 1)))
+        #expect(MenuBarVisibilityWatcher.shouldShowGuidance(
+            defaults: defaults,
+            now: now.addingTimeInterval(MenuBarVisibilityWatcher.guidanceRepeatInterval)))
+    }
+
+    @Test
+    func `startup recovery triggers for blocked visible snapshot`() {
+        let launchedAt = Date(timeIntervalSince1970: 1000)
+        let blocked = StatusItemVisibilitySnapshot(
+            isVisible: true,
+            hasButton: true,
+            hasWindow: false,
+            hasScreen: false,
+            buttonWidth: 18)
+
+        #expect(MenuBarVisibilityWatcher.shouldAttemptStartupRecovery(
+            appLaunchedAt: launchedAt,
+            now: launchedAt.addingTimeInterval(2),
+            snapshots: [blocked]))
+    }
+
+    @Test
+    func `startup recovery retries detached Tahoe proxy corroborated by Control Center geometry`() {
+        let launchedAt = Date(timeIntervalSince1970: 1000)
+        let detachedProxy = StatusItemVisibilitySnapshot(
+            isVisible: true,
+            hasButton: true,
+            hasWindow: true,
+            hasScreen: false,
+            isOnCurrentScreen: false,
+            buttonWidth: 76)
+        let blockedWindow = MenuBarStatusItemWindowSnapshot(
+            name: "codexbar-merged",
+            ownerName: "Control Center",
+            bounds: CGRect(x: 0, y: -22, width: 76, height: 22),
+            isOnscreen: true,
+            displayBounds: nil)
+
+        #expect(!MenuBarVisibilityWatcher.isBlockedSnapshot(snapshot: detachedProxy))
+        #expect(MenuBarVisibilityWatcher.shouldAttemptStartupRecovery(
+            appLaunchedAt: launchedAt,
+            now: launchedAt.addingTimeInterval(2),
+            snapshots: [detachedProxy],
+            windowSnapshots: [blockedWindow],
+            detectTahoeBlockedProxy: true))
+    }
+
+    @Test
+    func `startup recovery ignores detached live item without Tahoe proxy corroboration`() {
+        let launchedAt = Date(timeIntervalSince1970: 1000)
+        let managed = StatusItemVisibilitySnapshot(
+            isVisible: true,
+            hasButton: true,
+            hasWindow: true,
+            hasScreen: false,
+            isOnCurrentScreen: false,
+            buttonWidth: 18)
+
+        #expect(!MenuBarVisibilityWatcher.shouldAttemptStartupRecovery(
+            appLaunchedAt: launchedAt,
+            now: launchedAt.addingTimeInterval(2),
+            snapshots: [managed],
+            detectTahoeBlockedProxy: true))
+    }
+
+    @Test
+    func `startup recovery ignores live item attached to a stale screen`() {
+        let launchedAt = Date(timeIntervalSince1970: 1000)
+        let managed = StatusItemVisibilitySnapshot(
+            isVisible: true,
+            hasButton: true,
+            hasWindow: true,
+            hasScreen: true,
+            isOnCurrentScreen: false,
+            buttonWidth: 18)
+
+        #expect(!MenuBarVisibilityWatcher.shouldAttemptStartupRecovery(
+            appLaunchedAt: launchedAt,
+            now: launchedAt.addingTimeInterval(2),
+            snapshots: [managed]))
+    }
+
+    @Test
+    func `startup recovery triggers when one split status item is blocked`() {
+        let launchedAt = Date(timeIntervalSince1970: 1000)
+        let healthy = StatusItemVisibilitySnapshot(
+            isVisible: true,
+            hasButton: true,
+            hasWindow: true,
+            hasScreen: true,
+            buttonWidth: 18)
+        let blocked = StatusItemVisibilitySnapshot(
+            isVisible: true,
+            hasButton: true,
+            hasWindow: false,
+            hasScreen: false,
+            buttonWidth: 18)
+
+        #expect(MenuBarVisibilityWatcher.shouldAttemptStartupRecovery(
+            appLaunchedAt: launchedAt,
+            now: launchedAt.addingTimeInterval(2),
+            snapshots: [healthy, blocked]))
+    }
+
+    @Test
+    func `startup recovery ignores stale checks`() {
+        let launchedAt = Date(timeIntervalSince1970: 1000)
+        let blocked = StatusItemVisibilitySnapshot(
+            isVisible: true,
+            hasButton: true,
+            hasWindow: false,
+            hasScreen: false,
+            buttonWidth: 18)
+
+        #expect(!MenuBarVisibilityWatcher.shouldAttemptStartupRecovery(
+            appLaunchedAt: launchedAt,
+            now: launchedAt.addingTimeInterval(MenuBarVisibilityWatcher.startupFreshnessInterval + 1),
+            snapshots: [blocked]))
+    }
+
+    @Test
+    func `startup recovery ignores healthy visible snapshot`() {
+        let launchedAt = Date(timeIntervalSince1970: 1000)
+        let healthy = StatusItemVisibilitySnapshot(
+            isVisible: true,
+            hasButton: true,
+            hasWindow: true,
+            hasScreen: true,
+            buttonWidth: 18)
+
+        #expect(!MenuBarVisibilityWatcher.shouldAttemptStartupRecovery(
+            appLaunchedAt: launchedAt,
+            now: launchedAt.addingTimeInterval(2),
+            snapshots: [healthy]))
+    }
+
+    @Test
+    func `screen change placement refresh ignores display removal with healthy status item`() {
+        let healthy = StatusItemVisibilitySnapshot(
+            isVisible: true,
+            hasButton: true,
+            hasWindow: true,
+            hasScreen: true,
+            buttonWidth: 18)
+
+        #expect(!MenuBarVisibilityWatcher.shouldRefreshScreenChangePlacement(
+            previousScreenCount: 2,
+            currentScreenCount: 1,
+            snapshots: [healthy]))
+    }
+
+    @Test
+    func `screen change placement refresh ignores display removal when no status item is visible`() {
+        let hidden = StatusItemVisibilitySnapshot(
+            isVisible: false,
+            hasButton: true,
+            hasWindow: true,
+            hasScreen: true,
+            buttonWidth: 18)
+
+        #expect(!MenuBarVisibilityWatcher.shouldRefreshScreenChangePlacement(
+            previousScreenCount: 2,
+            currentScreenCount: 1,
+            snapshots: [hidden]))
+    }
+
+    @Test
+    func `screen change recovery triggers for blocked status item without display count change`() {
+        let blocked = StatusItemVisibilitySnapshot(
+            isVisible: true,
+            hasButton: true,
+            hasWindow: false,
+            hasScreen: false,
+            buttonWidth: 18)
+
+        #expect(MenuBarVisibilityWatcher.shouldAttemptScreenChangeRecovery(snapshots: [blocked]))
+    }
+
+    @Test
+    func `screen change placement refresh triggers for detached live item after display removal`() {
+        let displaced = StatusItemVisibilitySnapshot(
+            isVisible: true,
+            hasButton: true,
+            hasWindow: true,
+            hasScreen: false,
+            isOnCurrentScreen: false,
+            buttonWidth: 18)
+
+        #expect(MenuBarVisibilityWatcher.shouldRefreshScreenChangePlacement(
+            previousScreenCount: 2,
+            currentScreenCount: 1,
+            snapshots: [displaced]))
+    }
+
+    @Test
+    func `screen change placement refresh triggers for stale screen live item after display removal`() {
+        let displaced = StatusItemVisibilitySnapshot(
+            isVisible: true,
+            hasButton: true,
+            hasWindow: true,
+            hasScreen: true,
+            isOnCurrentScreen: false,
+            buttonWidth: 18)
+
+        #expect(MenuBarVisibilityWatcher.shouldRefreshScreenChangePlacement(
+            previousScreenCount: 2,
+            currentScreenCount: 1,
+            snapshots: [displaced]))
+    }
+
+    @Test
+    func `screen change placement refresh ignores healthy item when display count does not shrink`() {
+        let healthy = StatusItemVisibilitySnapshot(
+            isVisible: true,
+            hasButton: true,
+            hasWindow: true,
+            hasScreen: true,
+            buttonWidth: 18)
+
+        #expect(!MenuBarVisibilityWatcher.shouldRefreshScreenChangePlacement(
+            previousScreenCount: 1,
+            currentScreenCount: 2,
+            snapshots: [healthy]))
+    }
+
+    @Test
+    func `screen change placement refresh triggers for displaced live item when display count is unchanged`() {
+        let displaced = StatusItemVisibilitySnapshot(
+            isVisible: true,
+            hasButton: true,
+            hasWindow: true,
+            hasScreen: true,
+            isOnCurrentScreen: false,
+            buttonWidth: 18)
+
+        #expect(MenuBarVisibilityWatcher.shouldRefreshScreenChangePlacement(
+            previousScreenCount: 2,
+            currentScreenCount: 2,
+            snapshots: [displaced]))
+    }
+
+    @Test
+    func `manager parked item with live window is not blocked`() {
+        // A menu bar manager parks items off the active screen with the window intact.
+        // hasAnyBlockedVisibleSnapshot must return false so verifyScreenChangeRecoveryIfNeeded
+        // does not trigger repeated recreation that corrupts Control Center.
+        let managed = StatusItemVisibilitySnapshot(
+            isVisible: true,
+            hasButton: true,
+            hasWindow: true,
+            hasScreen: false,
+            isOnCurrentScreen: false,
+            buttonWidth: 18)
+
+        #expect(!MenuBarVisibilityWatcher.hasAnyBlockedVisibleSnapshot([managed]))
+        #expect(MenuBarVisibilityWatcher.hasAnyDisplacedVisibleSnapshot([managed]))
+    }
+
+    @Test
+    func `manager parked item with live window on stale screen is not blocked`() {
+        let managed = StatusItemVisibilitySnapshot(
+            isVisible: true,
+            hasButton: true,
+            hasWindow: true,
+            hasScreen: true,
+            isOnCurrentScreen: false,
+            buttonWidth: 18)
+
+        #expect(!MenuBarVisibilityWatcher.hasAnyBlockedVisibleSnapshot([managed]))
+        #expect(MenuBarVisibilityWatcher.hasAnyDisplacedVisibleSnapshot([managed]))
+    }
+
+    @Test
+    func `item without window is blocked regardless of screen state`() {
+        // A missing window cannot be caused by a manager parking the item; it signals
+        // a genuine system block and must trigger recovery.
+        let blocked = StatusItemVisibilitySnapshot(
+            isVisible: true,
+            hasButton: true,
+            hasWindow: false,
+            hasScreen: false,
+            isOnCurrentScreen: false,
+            buttonWidth: 18)
+
+        #expect(MenuBarVisibilityWatcher.hasAnyBlockedVisibleSnapshot([blocked]))
+        #expect(!MenuBarVisibilityWatcher.hasAnyDisplacedVisibleSnapshot([blocked]))
+    }
+}
diff --git a/Tests/CodexBarTests/MenuCardAntigravityTests.swift b/Tests/CodexBarTests/MenuCardAntigravityTests.swift
new file mode 100644
index 0000000000..cd48764d91
--- /dev/null
+++ b/Tests/CodexBarTests/MenuCardAntigravityTests.swift
@@ -0,0 +1,411 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct MenuCardAntigravityTests {
+    @Test
+    func `antigravity identity only snapshot shows limits unavailable`() throws {
+        let now = Date(timeIntervalSince1970: 1_742_771_200)
+        let metadata = try #require(ProviderDefaults.metadata[.antigravity])
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            updatedAt: now,
+            identity: ProviderIdentitySnapshot(
+                providerID: .antigravity,
+                accountEmail: "user@example.com",
+                accountOrganization: nil,
+                loginMethod: "Paid"))
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .antigravity,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.metrics.isEmpty)
+        #expect(model.placeholder == "Limits not available")
+        #expect(model.subtitleStyle == .info)
+        #expect(model.email == "user@example.com")
+        #expect(model.planText == "Paid")
+    }
+
+    @Test
+    func `antigravity metrics omit missing groups`() throws {
+        let now = Date()
+        let identity = ProviderIdentitySnapshot(
+            providerID: .antigravity,
+            accountEmail: nil,
+            accountOrganization: nil,
+            loginMethod: "Pro")
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 5,
+                windowMinutes: nil,
+                resetsAt: now.addingTimeInterval(3600),
+                resetDescription: nil),
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: now,
+            identity: identity)
+        let metadata = try #require(ProviderDefaults.metadata[.antigravity])
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .antigravity,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.metrics.count == 1)
+        #expect(model.metrics.map(\.title) == ["Gemini Models"])
+        #expect(model.metrics[0].percent == 95)
+        #expect(model.metrics[0].percentLabel == "95% left")
+    }
+
+    @Test
+    func `antigravity untracked known row does not duplicate grouped summary`() throws {
+        let now = Date(timeIntervalSince1970: 1_735_000_000)
+        let resetTime = now.addingTimeInterval(3600)
+        let antigravitySnapshot = AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "Claude Thinking",
+                    modelId: "MODEL_PLACEHOLDER_M35",
+                    remainingFraction: 0.4,
+                    resetTime: resetTime,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Gemini 3.1 Pro (Low)",
+                    modelId: "MODEL_PLACEHOLDER_M36",
+                    remainingFraction: nil,
+                    resetTime: resetTime,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Gemini 3 Flash",
+                    modelId: "MODEL_PLACEHOLDER_M47",
+                    remainingFraction: 1,
+                    resetTime: resetTime,
+                    resetDescription: nil),
+            ],
+            accountEmail: nil,
+            accountPlan: "Pro")
+        let snapshot = try antigravitySnapshot.toUsageSnapshot()
+        let metadata = try #require(ProviderDefaults.metadata[.antigravity])
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .antigravity,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.metrics.map(\.title) == ["Gemini Models", "Claude and GPT"])
+        #expect(!model.metrics.contains { $0.title == "Gemini 3.1 Pro (Low)" })
+    }
+
+    @Test
+    func `antigravity metrics collapse complete per model quota windows`() throws {
+        let now = Date(timeIntervalSince1970: 1_735_000_000)
+        let resetTime = now.addingTimeInterval(3600)
+        let antigravitySnapshot = AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "GPT-OSS 120B (Medium)",
+                    modelId: "MODEL_PLACEHOLDER_M55",
+                    remainingFraction: 0.25,
+                    resetTime: resetTime,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Gemini 3 Pro (Low)",
+                    modelId: "MODEL_PLACEHOLDER_M53",
+                    remainingFraction: 0.5,
+                    resetTime: resetTime,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Claude Opus 4.6 (Thinking)",
+                    modelId: "MODEL_PLACEHOLDER_M50",
+                    remainingFraction: 0.75,
+                    resetTime: resetTime,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Gemini 3 Pro (High)",
+                    modelId: "MODEL_PLACEHOLDER_M52",
+                    remainingFraction: 1,
+                    resetTime: resetTime,
+                    resetDescription: nil),
+            ],
+            accountEmail: nil,
+            accountPlan: "Pro",
+            source: .local)
+        let snapshot = try antigravitySnapshot.toUsageSnapshot()
+        let metadata = try #require(ProviderDefaults.metadata[.antigravity])
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .antigravity,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.metrics.map(\.title) == [
+            "Gemini Models",
+            "Claude and GPT",
+        ])
+        #expect(model.metrics.map(\.percentLabel) == [
+            "50% left",
+            "25% left",
+        ])
+    }
+
+    @Test
+    func `antigravity distinct extra windows still render when optional extras are disabled`() throws {
+        // Regression: the optional-credits/extra-usage setting is Codex-specific and must NOT hide
+        // other providers' core extra windows.
+        let now = Date(timeIntervalSince1970: 1_735_000_000)
+        let resetTime = now.addingTimeInterval(3600)
+        let antigravitySnapshot = AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "Experimental Tool",
+                    modelId: "MODEL_PLACEHOLDER_UNKNOWN",
+                    remainingFraction: 0.5,
+                    resetTime: resetTime,
+                    resetDescription: nil),
+                AntigravityModelQuota(
+                    label: "Gemini 3 Pro (High)",
+                    modelId: "MODEL_PLACEHOLDER_M52",
+                    remainingFraction: 1,
+                    resetTime: resetTime,
+                    resetDescription: nil),
+            ],
+            accountEmail: nil,
+            accountPlan: "Pro")
+        let snapshot = try antigravitySnapshot.toUsageSnapshot()
+        let metadata = try #require(ProviderDefaults.metadata[.antigravity])
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .antigravity,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: false,
+            hidePersonalInfo: false,
+            now: now))
+
+        // Distinct extra windows remain visible even with optional extras disabled.
+        #expect(model.metrics.contains { $0.title == "Experimental Tool" })
+        #expect(model.metrics.contains { $0.title == "Gemini Models" })
+    }
+
+    @Test
+    func `antigravity quota summary renders named session and weekly rows`() throws {
+        let now = Date(timeIntervalSince1970: 1_735_000_000)
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 27,
+                windowMinutes: 300,
+                resetsAt: nil,
+                resetDescription: "You have used some of your 5-hour limit, it will fully refresh in 3 hours."),
+            secondary: RateWindow(
+                usedPercent: 18,
+                windowMinutes: 10080,
+                resetsAt: nil,
+                resetDescription: "You have used some of your weekly limit, it will fully refresh in 5 days."),
+            tertiary: nil,
+            extraRateWindows: [
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-gemini-5h",
+                    title: "Gemini Models Five Hour Limit",
+                    window: RateWindow(
+                        usedPercent: 9,
+                        windowMinutes: 300,
+                        resetsAt: nil,
+                        resetDescription: "You have used some of your 5-hour limit, it will fully refresh in "
+                            + "4 hours.")),
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-gemini-weekly",
+                    title: "Gemini Models Weekly Limit",
+                    window: RateWindow(
+                        usedPercent: 18,
+                        windowMinutes: 10080,
+                        resetsAt: nil,
+                        resetDescription: "You have used some of your weekly limit, it will fully refresh in 5 days.")),
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-3p-5h",
+                    title: "Claude and GPT models Five Hour Limit",
+                    window: RateWindow(
+                        usedPercent: 27,
+                        windowMinutes: 300,
+                        resetsAt: nil,
+                        resetDescription: "You have used some of your 5-hour limit, it will fully refresh in "
+                            + "3 hours.")),
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-3p-weekly",
+                    title: "Claude and GPT models Weekly Limit",
+                    window: RateWindow(
+                        usedPercent: 36,
+                        windowMinutes: 10080,
+                        resetsAt: nil,
+                        resetDescription: "You have used some of your weekly limit, it will fully refresh in 6 days.")),
+            ],
+            updatedAt: now,
+            identity: ProviderIdentitySnapshot(
+                providerID: .antigravity,
+                accountEmail: nil,
+                accountOrganization: nil,
+                loginMethod: "Pro"))
+        let metadata = try #require(ProviderDefaults.metadata[.antigravity])
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .antigravity,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: false,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.metrics.map(\.id) == [
+            "antigravity-quota-summary-gemini-5h",
+            "antigravity-quota-summary-gemini-weekly",
+            "antigravity-quota-summary-3p-5h",
+            "antigravity-quota-summary-3p-weekly",
+        ])
+        #expect(model.metrics.map(\.title) == [
+            "Gemini Models Five Hour Limit",
+            "Gemini Models Weekly Limit",
+            "Claude and GPT models Five Hour Limit",
+            "Claude and GPT models Weekly Limit",
+        ])
+        #expect(model.metrics.map(\.percentLabel) == [
+            "91% left",
+            "82% left",
+            "73% left",
+            "64% left",
+        ])
+        #expect(model.metrics[2].resetText == "Resets in 3 hours")
+    }
+
+    @Test
+    func `antigravity missing groups are omitted in used mode`() throws {
+        let now = Date()
+        let identity = ProviderIdentitySnapshot(
+            providerID: .antigravity,
+            accountEmail: nil,
+            accountOrganization: nil,
+            loginMethod: "Pro")
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 5,
+                windowMinutes: nil,
+                resetsAt: now.addingTimeInterval(3600),
+                resetDescription: nil),
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: now,
+            identity: identity)
+        let metadata = try #require(ProviderDefaults.metadata[.antigravity])
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .antigravity,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: true,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.metrics.count == 1)
+        #expect(model.metrics[0].title == "Gemini Models")
+        #expect(model.metrics[0].percent == 5)
+        #expect(model.metrics[0].percentLabel == "5% used")
+    }
+}
diff --git a/Tests/CodexBarTests/MenuCardCostHintTests.swift b/Tests/CodexBarTests/MenuCardCostHintTests.swift
new file mode 100644
index 0000000000..086e9c6336
--- /dev/null
+++ b/Tests/CodexBarTests/MenuCardCostHintTests.swift
@@ -0,0 +1,96 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct MenuCardCostHintTests {
+    @Test
+    func `claude cost hint explains cache tokens and status line drift`() throws {
+        let now = Date()
+        let metadata = try #require(ProviderDefaults.metadata[.claude])
+        let snapshot = CostUsageTokenSnapshot(
+            sessionTokens: 123,
+            sessionCostUSD: 1.23,
+            last30DaysTokens: 456,
+            last30DaysCostUSD: 78.9,
+            daily: [
+                CostUsageDailyReport.Entry(
+                    date: "2026-05-14",
+                    inputTokens: 1,
+                    outputTokens: 2,
+                    cacheReadTokens: 300,
+                    cacheCreationTokens: 400,
+                    totalTokens: 703,
+                    costUSD: 1.23,
+                    modelsUsed: ["claude-sonnet-4-6"],
+                    modelBreakdowns: nil),
+            ],
+            updatedAt: now)
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .claude,
+            metadata: metadata,
+            snapshot: nil,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: snapshot,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: true,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.tokenUsage?.hintLine?.contains("cache read/write tokens") == true)
+        #expect(model.tokenUsage?.hintLine?.contains("Claude Code /status") == true)
+    }
+
+    @Test
+    func `one day history label stays today`() throws {
+        let now = Date()
+        let metadata = try #require(ProviderDefaults.metadata[.claude])
+        let snapshot = CostUsageTokenSnapshot(
+            sessionTokens: 120,
+            sessionCostUSD: 1.2,
+            last30DaysTokens: 120,
+            last30DaysCostUSD: 1.2,
+            historyDays: 1,
+            daily: [
+                .init(
+                    date: "2026-05-14",
+                    inputTokens: 100,
+                    outputTokens: 20,
+                    totalTokens: 120,
+                    costUSD: 1.2,
+                    modelsUsed: ["claude-sonnet-4-6"],
+                    modelBreakdowns: nil),
+            ],
+            updatedAt: now)
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .claude,
+            metadata: metadata,
+            snapshot: nil,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: snapshot,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: true,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.tokenUsage?.monthLine.hasPrefix("Today: ") == true)
+    }
+}
diff --git a/Tests/CodexBarTests/MenuCardDeepSeekTests.swift b/Tests/CodexBarTests/MenuCardDeepSeekTests.swift
new file mode 100644
index 0000000000..3a17f9b107
--- /dev/null
+++ b/Tests/CodexBarTests/MenuCardDeepSeekTests.swift
@@ -0,0 +1,146 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct MenuCardDeepSeekTests {
+    private static func sampleDeepSeekSummary(now: Date = Date()) -> DeepSeekUsageSummary {
+        DeepSeekUsageSummary(
+            todayTokens: 123,
+            currentMonthTokens: 456,
+            todayCost: 0.0123,
+            currentMonthCost: 0.0456,
+            requestCount: 7,
+            currentMonthRequestCount: 8,
+            topModel: "deepseek-chat",
+            categoryBreakdown: [
+                DeepSeekCategoryBreakdown(category: .promptCacheHitToken, tokens: 10, cost: 0.001),
+                DeepSeekCategoryBreakdown(category: .promptCacheMissToken, tokens: 20, cost: 0.002),
+                DeepSeekCategoryBreakdown(category: .responseToken, tokens: 30, cost: 0.003),
+            ],
+            daily: [
+                DeepSeekDailyUsage(date: "2026-05-26", totalTokens: 456, cost: 0.0456, requestCount: 8),
+            ],
+            currency: "CNY",
+            updatedAt: now)
+    }
+
+    private static func makeSnapshot(now: Date, usageSummary: DeepSeekUsageSummary? = nil) -> UsageSnapshot {
+        DeepSeekUsageSnapshot(
+            isAvailable: true,
+            currency: "USD",
+            totalBalance: 9.32,
+            grantedBalance: 0,
+            toppedUpBalance: 9.32,
+            usageSummary: usageSummary,
+            updatedAt: now)
+            .toUsageSnapshot()
+    }
+
+    @Test
+    func `model shows balance as status text instead of percentage detail`() throws {
+        let now = Date()
+        let identity = ProviderIdentitySnapshot(
+            providerID: .deepseek,
+            accountEmail: nil,
+            accountOrganization: nil,
+            loginMethod: nil)
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 0,
+                windowMinutes: nil,
+                resetsAt: nil,
+                resetDescription: "$9.32 (Paid: $9.32 / Granted: $0.00)"),
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: now,
+            identity: identity)
+        let metadata = try #require(ProviderDefaults.metadata[.deepseek])
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .deepseek,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        let primary = try #require(model.metrics.first)
+        #expect(primary.title == "Balance")
+        #expect(primary.statusText == "$9.32 (Paid: $9.32 / Granted: $0.00)")
+        #expect(primary.detailText == nil)
+        #expect(primary.resetText == nil)
+    }
+
+    @Test
+    func `model hides optional deepseek usage when extras disabled`() throws {
+        let now = Date()
+        let metadata = try #require(ProviderDefaults.metadata[.deepseek])
+        let snapshot = Self.makeSnapshot(now: now, usageSummary: Self.sampleDeepSeekSummary(now: now))
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .deepseek,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: false,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.inlineUsageDashboard == nil)
+        #expect(model.usageNotes.isEmpty)
+    }
+
+    @Test
+    func `model shows optional deepseek usage when extras enabled`() throws {
+        let now = Date()
+        let metadata = try #require(ProviderDefaults.metadata[.deepseek])
+        let snapshot = Self.makeSnapshot(now: now, usageSummary: Self.sampleDeepSeekSummary(now: now))
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .deepseek,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.inlineUsageDashboard?.accessibilityLabel == "DeepSeek 30 day token usage trend")
+        #expect(model.usageNotes.contains { $0.contains("Today:") })
+    }
+}
diff --git a/Tests/CodexBarTests/MenuCardHeightFingerprintTests.swift b/Tests/CodexBarTests/MenuCardHeightFingerprintTests.swift
new file mode 100644
index 0000000000..e81a293315
--- /dev/null
+++ b/Tests/CodexBarTests/MenuCardHeightFingerprintTests.swift
@@ -0,0 +1,73 @@
+import SwiftUI
+import Testing
+@testable import CodexBar
+
+struct MenuCardHeightFingerprintTests {
+    @Test
+    func `height fingerprint does not retain raw text fields`() {
+        let model = Self.model()
+
+        let fingerprint = model.heightFingerprint(section: "card")
+
+        #expect(!fingerprint.contains("very-secret@example.com"))
+        #expect(!fingerprint.contains("Secret Provider Name"))
+        #expect(!fingerprint.contains("Secret Metric"))
+        #expect(!fingerprint.contains("Secret note"))
+    }
+
+    @Test
+    func `height fingerprint field distinguishes nil from empty string`() {
+        let nilField = UsageMenuCardView.Model.heightFingerprintField("storage", nil)
+        let emptyField = UsageMenuCardView.Model.heightFingerprintField("storage", "")
+
+        #expect(nilField != emptyField)
+    }
+
+    @Test
+    func `height fingerprint keeps cheap metric percent identity`() {
+        let left = Self.model(percent: 42, percentStyle: .left).heightFingerprint(section: "card")
+        let used = Self.model(percent: 42, percentStyle: .used).heightFingerprint(section: "card")
+        let changedPercent = Self.model(percent: 43, percentStyle: .left).heightFingerprint(section: "card")
+
+        #expect(left != used)
+        #expect(left != changedPercent)
+    }
+
+    private static func model(
+        percent: Double = 42,
+        percentStyle: UsageMenuCardView.Model.PercentStyle = .left) -> UsageMenuCardView.Model
+    {
+        UsageMenuCardView.Model(
+            provider: .codex,
+            providerName: "Secret Provider Name",
+            email: "very-secret@example.com",
+            subtitleText: "Signed in as very-secret@example.com",
+            subtitleStyle: .info,
+            planText: "Secret Plan",
+            metrics: [
+                .init(
+                    id: "primary",
+                    title: "Secret Metric",
+                    percent: percent,
+                    percentStyle: percentStyle,
+                    statusText: "Secret status",
+                    resetText: nil,
+                    detailText: nil,
+                    detailLeftText: nil,
+                    detailRightText: nil,
+                    pacePercent: nil,
+                    paceOnTop: true),
+            ],
+            usageNotes: ["Secret note"],
+            openAIAPIUsage: nil,
+            inlineUsageDashboard: nil,
+            creditsText: nil,
+            creditsRemaining: nil,
+            creditsHintText: nil,
+            creditsHintCopyText: nil,
+            providerCost: nil,
+            tokenUsage: nil,
+            placeholder: nil,
+            progressColor: .blue)
+    }
+}
diff --git a/Tests/CodexBarTests/MenuCardKiloPassTests.swift b/Tests/CodexBarTests/MenuCardKiloPassTests.swift
index a888ca4c8b..f15cfdcba9 100644
--- a/Tests/CodexBarTests/MenuCardKiloPassTests.swift
+++ b/Tests/CodexBarTests/MenuCardKiloPassTests.swift
@@ -3,10 +3,9 @@ import Foundation
 import Testing
 @testable import CodexBar
 
-@Suite
 struct MenuCardKiloPassTests {
     @Test
-    func kiloModelShowsPassBeforeCreditsAndKeepsResetWithDetail() throws {
+    func `kilo model shows pass before credits and keeps reset with detail`() throws {
         let now = Date()
         let metadata = try #require(ProviderDefaults.metadata[.kilo])
         let snapshot = UsageSnapshot(
diff --git a/Tests/CodexBarTests/MenuCardModelCodexDegradedQuotaTests.swift b/Tests/CodexBarTests/MenuCardModelCodexDegradedQuotaTests.swift
new file mode 100644
index 0000000000..a1c0817e2e
--- /dev/null
+++ b/Tests/CodexBarTests/MenuCardModelCodexDegradedQuotaTests.swift
@@ -0,0 +1,245 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct MenuCardModelCodexDegradedQuotaTests {
+    @Test
+    func `codex local token usage keeps remote quota unavailable error visible`() throws {
+        let now = Date(timeIntervalSince1970: 1_800_000_000)
+        let metadata = try #require(ProviderDefaults.metadata[.codex])
+        let tokenSnapshot = CostUsageTokenSnapshot(
+            sessionTokens: 721_966,
+            sessionCostUSD: 1.081155,
+            last30DaysTokens: 824_405_060,
+            last30DaysCostUSD: 583.1287345,
+            daily: [
+                .init(
+                    date: "2026-06-05",
+                    inputTokens: 710_217,
+                    outputTokens: 11749,
+                    totalTokens: 721_966,
+                    costUSD: 1.081155,
+                    modelsUsed: ["gpt-5.5"],
+                    modelBreakdowns: nil),
+            ],
+            updatedAt: now)
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .codex,
+            metadata: metadata,
+            snapshot: nil,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: tokenSnapshot,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: "Codex usage is temporarily unavailable. Try refreshing.",
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: true,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.placeholder == nil)
+        #expect(model.subtitleStyle == .error)
+        #expect(model.subtitleText == "Codex usage is temporarily unavailable. Try refreshing.")
+        #expect(model.usesStackedDetailLayout)
+        #expect(model.tokenUsage?.sessionLine.contains("$1.08") == true)
+        #expect(model.tokenUsage?.sessionLine.contains("tokens") == true)
+        #expect(model.tokenUsage?.monthLine.contains("$583.13") == true)
+        #expect(model.tokenUsage?.monthLine.contains("tokens") == true)
+    }
+
+    @Test
+    func `codex remote quota unavailable error stays visible when token usage is hidden`() throws {
+        let now = Date(timeIntervalSince1970: 1_800_000_000)
+        let metadata = try #require(ProviderDefaults.metadata[.codex])
+        let tokenSnapshot = CostUsageTokenSnapshot(
+            sessionTokens: 721_966,
+            sessionCostUSD: 1.081155,
+            last30DaysTokens: 824_405_060,
+            last30DaysCostUSD: 583.1287345,
+            daily: [],
+            updatedAt: now)
+        let error = "Codex usage is temporarily unavailable. Try refreshing."
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .codex,
+            metadata: metadata,
+            snapshot: nil,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: tokenSnapshot,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: error,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.placeholder == nil)
+        #expect(model.subtitleStyle == .error)
+        #expect(model.subtitleText == error)
+        #expect(model.tokenUsage == nil)
+    }
+
+    @Test
+    func `codex local token usage preserves limits unavailable placeholder`() throws {
+        let now = Date(timeIntervalSince1970: 1_800_000_000)
+        let metadata = try #require(ProviderDefaults.metadata[.codex])
+        let tokenSnapshot = CostUsageTokenSnapshot(
+            sessionTokens: 721_966,
+            sessionCostUSD: 1.081155,
+            last30DaysTokens: 824_405_060,
+            last30DaysCostUSD: 583.1287345,
+            daily: [],
+            updatedAt: now)
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .codex,
+            metadata: metadata,
+            snapshot: nil,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: tokenSnapshot,
+            tokenError: nil,
+            account: AccountInfo(email: "user@example.com", plan: "Pro"),
+            isRefreshing: false,
+            lastError: UsageError.noRateLimitsFound.errorDescription,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: true,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.placeholder == "Limits not available")
+        #expect(model.subtitleStyle == .info)
+        #expect(model.tokenUsage != nil)
+        #expect(model.usesStackedDetailLayout)
+    }
+
+    @Test
+    func `codex local token usage preserves sign-in guidance`() throws {
+        let model = try self.makeModel(
+            tokenCostUsageEnabled: true,
+            lastError: "Codex CLI is not signed in. Run `codex login --device-auth`, then refresh.")
+
+        #expect(model.subtitleStyle == .error)
+        #expect(model.subtitleText.contains("codex login"))
+        #expect(model.tokenUsage != nil)
+        #expect(model.usesStackedDetailLayout)
+    }
+
+    @Test
+    func `codex local token usage preserves mapped transport error`() throws {
+        let now = Date(timeIntervalSince1970: 1_800_000_000)
+        let metadata = try #require(ProviderDefaults.metadata[.codex])
+        let tokenSnapshot = CostUsageTokenSnapshot(
+            sessionTokens: 721_966,
+            sessionCostUSD: 1.081155,
+            last30DaysTokens: 824_405_060,
+            last30DaysCostUSD: 583.1287345,
+            daily: [],
+            updatedAt: now)
+        let error = try #require(CodexUIErrorMapper.userFacingMessage("Codex connection failed: timed out."))
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .codex,
+            metadata: metadata,
+            snapshot: nil,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: tokenSnapshot,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: error,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: true,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.placeholder == nil)
+        #expect(model.subtitleStyle == .error)
+        #expect(model.subtitleText == "Codex usage is temporarily unavailable. Try refreshing.")
+        #expect(model.tokenUsage?.sessionLine.contains("$1.08") == true)
+    }
+
+    @Test
+    func `credits select stacked detail layout without quota metrics`() {
+        let model = UsageMenuCardView.Model(
+            provider: .codex,
+            providerName: "Codex",
+            email: "user@example.com",
+            subtitleText: "Not fetched yet",
+            subtitleStyle: .info,
+            planText: nil,
+            metrics: [],
+            usageNotes: [],
+            openAIAPIUsage: nil,
+            inlineUsageDashboard: nil,
+            creditsText: "$12.34 remaining",
+            creditsRemaining: 12.34,
+            creditsHintText: nil,
+            creditsHintCopyText: nil,
+            providerCost: nil,
+            tokenUsage: nil,
+            placeholder: "No usage yet",
+            progressColor: .blue)
+
+        #expect(model.usesStackedDetailLayout)
+    }
+
+    private func makeModel(
+        tokenCostUsageEnabled: Bool,
+        lastError: String?) throws -> UsageMenuCardView.Model
+    {
+        let now = Date(timeIntervalSince1970: 1_800_000_000)
+        let metadata = try #require(ProviderDefaults.metadata[.codex])
+        let tokenSnapshot = CostUsageTokenSnapshot(
+            sessionTokens: 721_966,
+            sessionCostUSD: 1.081155,
+            last30DaysTokens: 824_405_060,
+            last30DaysCostUSD: 583.1287345,
+            daily: [],
+            updatedAt: now)
+
+        return UsageMenuCardView.Model.make(.init(
+            provider: .codex,
+            metadata: metadata,
+            snapshot: nil,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: tokenSnapshot,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: lastError,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: tokenCostUsageEnabled,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+    }
+}
diff --git a/Tests/CodexBarTests/MenuCardModelCodexProjectionTests.swift b/Tests/CodexBarTests/MenuCardModelCodexProjectionTests.swift
new file mode 100644
index 0000000000..506f4b23e2
--- /dev/null
+++ b/Tests/CodexBarTests/MenuCardModelCodexProjectionTests.swift
@@ -0,0 +1,838 @@
+import CodexBarCore
+import Foundation
+import SwiftUI
+import Testing
+@testable import CodexBar
+
+struct MenuCardModelCodexProjectionTests {
+    @Test
+    func `codex weekly lane derives pace from its visible window`() throws {
+        let now = Date(timeIntervalSince1970: 1_800_000_000)
+        let metadata = try #require(ProviderDefaults.metadata[.codex])
+        let identity = ProviderIdentitySnapshot(
+            providerID: .codex,
+            accountEmail: "user@example.com",
+            accountOrganization: nil,
+            loginMethod: "Pro")
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 2,
+                windowMinutes: 300,
+                resetsAt: now.addingTimeInterval(4 * 60 * 60),
+                resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: 4,
+                windowMinutes: 10080,
+                resetsAt: now.addingTimeInterval(6 * 24 * 60 * 60),
+                resetDescription: nil),
+            tertiary: nil,
+            updatedAt: now,
+            identity: identity)
+        let projection = CodexConsumerProjection.make(
+            surface: .liveCard,
+            context: CodexConsumerProjection.Context(
+                snapshot: snapshot,
+                rawUsageError: nil,
+                liveCredits: nil,
+                rawCreditsError: nil,
+                liveDashboard: nil,
+                rawDashboardError: nil,
+                dashboardAttachmentAuthorized: false,
+                dashboardRequiresLogin: false,
+                now: now))
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .codex,
+            metadata: metadata,
+            snapshot: snapshot,
+            codexProjection: projection,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: "user@example.com", plan: "Pro"),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        let weekly = try #require(model.metrics.first { $0.id == "secondary" })
+        #expect(weekly.detailLeftText == "10% in reserve")
+        #expect(weekly.detailRightText == "Lasts until reset")
+    }
+
+    @Test
+    func `codex weekly lane includes workday markers when workDaysPerWeek is set`() throws {
+        let now = Date(timeIntervalSince1970: 1_800_000_000)
+        let metadata = try #require(ProviderDefaults.metadata[.codex])
+        let identity = ProviderIdentitySnapshot(
+            providerID: .codex,
+            accountEmail: "user@example.com",
+            accountOrganization: nil,
+            loginMethod: "Pro")
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 2,
+                windowMinutes: 300,
+                resetsAt: now.addingTimeInterval(4 * 60 * 60),
+                resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: 4,
+                windowMinutes: 10080,
+                resetsAt: now.addingTimeInterval(6 * 24 * 60 * 60),
+                resetDescription: nil),
+            tertiary: nil,
+            updatedAt: now,
+            identity: identity)
+        let projection = CodexConsumerProjection.make(
+            surface: .liveCard,
+            context: CodexConsumerProjection.Context(
+                snapshot: snapshot,
+                rawUsageError: nil,
+                liveCredits: nil,
+                rawCreditsError: nil,
+                liveDashboard: nil,
+                rawDashboardError: nil,
+                dashboardAttachmentAuthorized: false,
+                dashboardRequiresLogin: false,
+                now: now))
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .codex,
+            metadata: metadata,
+            snapshot: snapshot,
+            codexProjection: projection,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: "user@example.com", plan: "Pro"),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            quotaWarningThresholds: [.session: [], .weekly: []],
+            workDaysPerWeek: 5,
+            now: now))
+
+        let weekly = try #require(model.metrics.first { $0.id == "secondary" })
+        #expect(weekly.warningMarkerPercents == [20.0, 40.0, 60.0, 80.0])
+
+        let session = try #require(model.metrics.first { $0.id == "primary" })
+        #expect(session.warningMarkerPercents.isEmpty)
+    }
+
+    @Test
+    func `codex weekly lane workday markers merge with quota warning markers`() throws {
+        let now = Date(timeIntervalSince1970: 1_800_000_000)
+        let metadata = try #require(ProviderDefaults.metadata[.codex])
+        let identity = ProviderIdentitySnapshot(
+            providerID: .codex,
+            accountEmail: "user@example.com",
+            accountOrganization: nil,
+            loginMethod: "Pro")
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 2,
+                windowMinutes: 300,
+                resetsAt: now.addingTimeInterval(4 * 60 * 60),
+                resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: 4,
+                windowMinutes: 10080,
+                resetsAt: now.addingTimeInterval(6 * 24 * 60 * 60),
+                resetDescription: nil),
+            tertiary: nil,
+            updatedAt: now,
+            identity: identity)
+        let projection = CodexConsumerProjection.make(
+            surface: .liveCard,
+            context: CodexConsumerProjection.Context(
+                snapshot: snapshot,
+                rawUsageError: nil,
+                liveCredits: nil,
+                rawCreditsError: nil,
+                liveDashboard: nil,
+                rawDashboardError: nil,
+                dashboardAttachmentAuthorized: false,
+                dashboardRequiresLogin: false,
+                now: now))
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .codex,
+            metadata: metadata,
+            snapshot: snapshot,
+            codexProjection: projection,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: "user@example.com", plan: "Pro"),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            quotaWarningThresholds: [.session: [], .weekly: [50]],
+            workDaysPerWeek: 5,
+            now: now))
+
+        let weekly = try #require(model.metrics.first { $0.id == "secondary" })
+        #expect(weekly.warningMarkerPercents == [20.0, 40.0, 50.0, 60.0, 80.0])
+    }
+
+    @Test
+    func `codex weekly lane workday markers not inverted by usageBarsShowUsed`() throws {
+        let now = Date(timeIntervalSince1970: 1_800_000_000)
+        let metadata = try #require(ProviderDefaults.metadata[.codex])
+        let identity = ProviderIdentitySnapshot(
+            providerID: .codex,
+            accountEmail: "user@example.com",
+            accountOrganization: nil,
+            loginMethod: "Pro")
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 2,
+                windowMinutes: 300,
+                resetsAt: now.addingTimeInterval(4 * 60 * 60),
+                resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: 4,
+                windowMinutes: 10080,
+                resetsAt: now.addingTimeInterval(6 * 24 * 60 * 60),
+                resetDescription: nil),
+            tertiary: nil,
+            updatedAt: now,
+            identity: identity)
+        let projection = CodexConsumerProjection.make(
+            surface: .liveCard,
+            context: CodexConsumerProjection.Context(
+                snapshot: snapshot,
+                rawUsageError: nil,
+                liveCredits: nil,
+                rawCreditsError: nil,
+                liveDashboard: nil,
+                rawDashboardError: nil,
+                dashboardAttachmentAuthorized: false,
+                dashboardRequiresLogin: false,
+                now: now))
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .codex,
+            metadata: metadata,
+            snapshot: snapshot,
+            codexProjection: projection,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: "user@example.com", plan: "Pro"),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: true,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            quotaWarningThresholds: [.session: [], .weekly: []],
+            workDaysPerWeek: 5,
+            now: now))
+
+        let weekly = try #require(model.metrics.first { $0.id == "secondary" })
+        #expect(weekly.warningMarkerPercents == [20.0, 40.0, 60.0, 80.0])
+    }
+
+    @Test
+    func `codex plan only snapshot shows limits unavailable placeholder`() throws {
+        let now = Date()
+        let metadata = try #require(ProviderDefaults.metadata[.codex])
+        let identity = ProviderIdentitySnapshot(
+            providerID: .codex,
+            accountEmail: "user@example.com",
+            accountOrganization: nil,
+            loginMethod: "pro")
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: now,
+            identity: identity)
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .codex,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: UsageError.noRateLimitsFound.errorDescription,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.placeholder == "Limits not available")
+        #expect(model.metrics.isEmpty)
+        #expect(model.subtitleStyle == .info)
+        #expect(!model.subtitleText.contains("Found sessions"))
+        #expect(model.planText == "Pro 20x")
+    }
+
+    @Test
+    func `codex plan only snapshot keeps actionable refresh errors visible`() throws {
+        let now = Date()
+        let metadata = try #require(ProviderDefaults.metadata[.codex])
+        let identity = ProviderIdentitySnapshot(
+            providerID: .codex,
+            accountEmail: "user@example.com",
+            accountOrganization: nil,
+            loginMethod: "pro")
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: now,
+            identity: identity)
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .codex,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: "Codex connection failed: timed out.",
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.placeholder == nil)
+        #expect(model.subtitleStyle == .error)
+        #expect(model.subtitleText == "Codex connection failed: timed out.")
+        #expect(model.planText == "Pro 20x")
+    }
+
+    @Test
+    func `codex account fallback shows limits unavailable instead of no limits error`() throws {
+        let now = Date()
+        let metadata = try #require(ProviderDefaults.metadata[.codex])
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .codex,
+            metadata: metadata,
+            snapshot: nil,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: "user@example.com", plan: "pro"),
+            isRefreshing: false,
+            lastError: UsageError.noRateLimitsFound.errorDescription,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.placeholder == "Limits not available")
+        #expect(model.subtitleStyle == .info)
+        #expect(!model.subtitleText.contains("Found sessions"))
+        #expect(model.email == "user@example.com")
+        #expect(model.planText == "Pro 20x")
+    }
+
+    @Test
+    func `codex no account fallback keeps no limits error visible`() throws {
+        let now = Date()
+        let metadata = try #require(ProviderDefaults.metadata[.codex])
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .codex,
+            metadata: metadata,
+            snapshot: nil,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: UsageError.noRateLimitsFound.errorDescription,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.placeholder == nil)
+        #expect(model.subtitleStyle == .error)
+        #expect(model.subtitleText == UsageError.noRateLimitsFound.errorDescription)
+    }
+
+    @Test
+    func `builds metrics using used percent when enabled`() throws {
+        let now = Date()
+        let identity = ProviderIdentitySnapshot(
+            providerID: .codex,
+            accountEmail: "codex@example.com",
+            accountOrganization: nil,
+            loginMethod: "Plus Plan")
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 22,
+                windowMinutes: 300,
+                resetsAt: now.addingTimeInterval(3000),
+                resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: 40,
+                windowMinutes: 10080,
+                resetsAt: now.addingTimeInterval(6000),
+                resetDescription: nil),
+            updatedAt: now,
+            identity: identity)
+        let metadata = try #require(ProviderDefaults.metadata[.codex])
+        let dashboard = OpenAIDashboardSnapshot(
+            signedInEmail: "codex@example.com",
+            codeReviewRemainingPercent: 73,
+            codeReviewLimit: RateWindow(
+                usedPercent: 27,
+                windowMinutes: nil,
+                resetsAt: now.addingTimeInterval(3600),
+                resetDescription: nil),
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            updatedAt: now)
+        let codexProjection = CodexConsumerProjection.make(
+            surface: .liveCard,
+            context: CodexConsumerProjection.Context(
+                snapshot: snapshot,
+                rawUsageError: nil,
+                liveCredits: nil,
+                rawCreditsError: nil,
+                liveDashboard: dashboard,
+                rawDashboardError: nil,
+                dashboardAttachmentAuthorized: true,
+                dashboardRequiresLogin: false,
+                now: now))
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .codex,
+            metadata: metadata,
+            snapshot: snapshot,
+            codexProjection: codexProjection,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: "codex@example.com", plan: "Plus Plan"),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: true,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.metrics.first?.title == "Session")
+        #expect(model.metrics.first?.percent == 22)
+        #expect(model.metrics.first?.percentLabel.contains("used") == true)
+        #expect(model.metrics.contains { $0.title == "Code review" && $0.percent == 27 })
+    }
+
+    @Test
+    func `shows code review metric when dashboard present`() throws {
+        let now = Date()
+        let identity = ProviderIdentitySnapshot(
+            providerID: .codex,
+            accountEmail: "codex@example.com",
+            accountOrganization: nil,
+            loginMethod: nil)
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 0, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: now,
+            identity: identity)
+        let metadata = try #require(ProviderDefaults.metadata[.codex])
+        let dashboard = OpenAIDashboardSnapshot(
+            signedInEmail: "codex@example.com",
+            codeReviewRemainingPercent: 73,
+            codeReviewLimit: RateWindow(
+                usedPercent: 27,
+                windowMinutes: nil,
+                resetsAt: now.addingTimeInterval(3600),
+                resetDescription: nil),
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            updatedAt: now)
+        let codexProjection = CodexConsumerProjection.make(
+            surface: .liveCard,
+            context: CodexConsumerProjection.Context(
+                snapshot: snapshot,
+                rawUsageError: nil,
+                liveCredits: nil,
+                rawCreditsError: nil,
+                liveDashboard: dashboard,
+                rawDashboardError: nil,
+                dashboardAttachmentAuthorized: true,
+                dashboardRequiresLogin: false,
+                now: now))
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .codex,
+            metadata: metadata,
+            snapshot: snapshot,
+            codexProjection: codexProjection,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: "codex@example.com", plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.metrics.contains { $0.title == "Code review" && $0.percent == 73 })
+        let codeReviewMetric = model.metrics.first { $0.id == "code-review" }
+        #expect(codeReviewMetric?.resetText?.contains("Resets") == true)
+    }
+
+    @Test
+    func `uses semantic codex lanes when weekly duration drifts`() throws {
+        let now = Date()
+        let identity = ProviderIdentitySnapshot(
+            providerID: .codex,
+            accountEmail: "codex@example.com",
+            accountOrganization: nil,
+            loginMethod: nil)
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: RateWindow(
+                usedPercent: 25,
+                windowMinutes: 11040,
+                resetsAt: now.addingTimeInterval(3600),
+                resetDescription: nil),
+            tertiary: nil,
+            updatedAt: now,
+            identity: identity)
+        let metadata = try #require(ProviderDefaults.metadata[.codex])
+        let codexProjection = CodexConsumerProjection.make(
+            surface: .liveCard,
+            context: CodexConsumerProjection.Context(
+                snapshot: snapshot,
+                rawUsageError: nil,
+                liveCredits: nil,
+                rawCreditsError: nil,
+                liveDashboard: nil,
+                rawDashboardError: nil,
+                dashboardAttachmentAuthorized: false,
+                dashboardRequiresLogin: false,
+                now: now))
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .codex,
+            metadata: metadata,
+            snapshot: snapshot,
+            codexProjection: codexProjection,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: "codex@example.com", plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.metrics.count == 1)
+        #expect(model.metrics.first?.id == "secondary")
+        #expect(model.metrics.first?.title == "Weekly")
+        #expect(model.metrics.first?.percent == 75)
+    }
+
+    @Test
+    func `renders codex spark as a named extra metric after the core lanes`() throws {
+        let now = Date(timeIntervalSince1970: 1_800_000_000)
+        let metadata = try #require(ProviderDefaults.metadata[.codex])
+        let identity = ProviderIdentitySnapshot(
+            providerID: .codex,
+            accountEmail: "user@example.com",
+            accountOrganization: nil,
+            loginMethod: "Pro")
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 2,
+                windowMinutes: 300,
+                resetsAt: now.addingTimeInterval(4 * 60 * 60),
+                resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: 4,
+                windowMinutes: 10080,
+                resetsAt: now.addingTimeInterval(6 * 24 * 60 * 60),
+                resetDescription: nil),
+            tertiary: nil,
+            extraRateWindows: [
+                NamedRateWindow(
+                    id: "codex-spark",
+                    title: "Codex Spark 5-hour",
+                    window: RateWindow(
+                        usedPercent: 80,
+                        windowMinutes: 300,
+                        resetsAt: now.addingTimeInterval(2 * 60 * 60),
+                        resetDescription: nil)),
+                NamedRateWindow(
+                    id: "codex-spark-weekly",
+                    title: "Codex Spark Weekly",
+                    window: RateWindow(
+                        usedPercent: 100,
+                        windowMinutes: 10080,
+                        resetsAt: now.addingTimeInterval(6 * 24 * 60 * 60),
+                        resetDescription: nil)),
+            ],
+            updatedAt: now,
+            identity: identity)
+        let projection = CodexConsumerProjection.make(
+            surface: .liveCard,
+            context: CodexConsumerProjection.Context(
+                snapshot: snapshot,
+                rawUsageError: nil,
+                liveCredits: nil,
+                rawCreditsError: nil,
+                liveDashboard: nil,
+                rawDashboardError: nil,
+                dashboardAttachmentAuthorized: false,
+                dashboardRequiresLogin: false,
+                now: now))
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .codex,
+            metadata: metadata,
+            snapshot: snapshot,
+            codexProjection: projection,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: "user@example.com", plan: "Pro"),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        let spark = try #require(model.metrics.first { $0.id == "codex-spark" })
+        #expect(spark.title == "Codex Spark 5-hour")
+        #expect(spark.percent == 20)
+        #expect(spark.percentLabel == "20% left")
+        #expect(spark.resetText != nil)
+        #expect(spark.detailLeftText == "20% in deficit")
+        #expect(spark.detailRightText == "Projected empty in 45m")
+        let sparkWeekly = try #require(model.metrics.first { $0.id == "codex-spark-weekly" })
+        #expect(sparkWeekly.title == "Codex Spark Weekly")
+        #expect(sparkWeekly.percent == 0)
+        #expect(sparkWeekly.percentLabel == "0% left")
+        #expect(sparkWeekly.resetText != nil)
+        #expect(sparkWeekly.detailLeftText == "86% in deficit")
+        #expect(sparkWeekly.detailRightText == "Runs out now")
+        // Spark trails the core session/weekly lanes rather than replacing them.
+        let sparkIndex = try #require(model.metrics.firstIndex { $0.id == "codex-spark" })
+        let sparkWeeklyIndex = try #require(model.metrics.firstIndex { $0.id == "codex-spark-weekly" })
+        let sessionIndex = try #require(model.metrics.firstIndex { $0.id == "primary" })
+        #expect(sparkIndex > sessionIndex)
+        #expect(sparkWeeklyIndex > sparkIndex)
+    }
+
+    @Test
+    func `hides codex credits when disabled`() throws {
+        let now = Date()
+        let identity = ProviderIdentitySnapshot(
+            providerID: .codex,
+            accountEmail: "codex@example.com",
+            accountOrganization: nil,
+            loginMethod: nil)
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 0, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: now,
+            identity: identity)
+        let metadata = try #require(ProviderDefaults.metadata[.codex])
+        let codexProjection = CodexConsumerProjection.make(
+            surface: .liveCard,
+            context: CodexConsumerProjection.Context(
+                snapshot: snapshot,
+                rawUsageError: nil,
+                liveCredits: CreditsSnapshot(remaining: 12, events: [], updatedAt: now),
+                rawCreditsError: nil,
+                liveDashboard: nil,
+                rawDashboardError: nil,
+                dashboardAttachmentAuthorized: false,
+                dashboardRequiresLogin: false,
+                now: now))
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .codex,
+            metadata: metadata,
+            snapshot: snapshot,
+            codexProjection: codexProjection,
+            credits: CreditsSnapshot(remaining: 12, events: [], updatedAt: now),
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: "codex@example.com", plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: false,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.creditsText == nil)
+    }
+
+    @Test
+    func `hides codex spark extra metric when showOptionalCreditsAndExtraUsage is false`() throws {
+        let now = Date(timeIntervalSince1970: 1_800_000_000)
+        let metadata = try #require(ProviderDefaults.metadata[.codex])
+        let identity = ProviderIdentitySnapshot(
+            providerID: .codex,
+            accountEmail: "user@example.com",
+            accountOrganization: nil,
+            loginMethod: "Pro")
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 2,
+                windowMinutes: 300,
+                resetsAt: now.addingTimeInterval(4 * 60 * 60),
+                resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: 4,
+                windowMinutes: 10080,
+                resetsAt: now.addingTimeInterval(6 * 24 * 60 * 60),
+                resetDescription: nil),
+            tertiary: nil,
+            extraRateWindows: [
+                NamedRateWindow(
+                    id: "codex-spark",
+                    title: "Codex Spark 5-hour",
+                    window: RateWindow(
+                        usedPercent: 30,
+                        windowMinutes: 300,
+                        resetsAt: now.addingTimeInterval(60 * 60),
+                        resetDescription: nil)),
+                NamedRateWindow(
+                    id: "codex-spark-weekly",
+                    title: "Codex Spark Weekly",
+                    window: RateWindow(
+                        usedPercent: 100,
+                        windowMinutes: 10080,
+                        resetsAt: now.addingTimeInterval(6 * 24 * 60 * 60),
+                        resetDescription: nil)),
+            ],
+            updatedAt: now,
+            identity: identity)
+        let projection = CodexConsumerProjection.make(
+            surface: .liveCard,
+            context: CodexConsumerProjection.Context(
+                snapshot: snapshot,
+                rawUsageError: nil,
+                liveCredits: nil,
+                rawCreditsError: nil,
+                liveDashboard: nil,
+                rawDashboardError: nil,
+                dashboardAttachmentAuthorized: false,
+                dashboardRequiresLogin: false,
+                now: now))
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .codex,
+            metadata: metadata,
+            snapshot: snapshot,
+            codexProjection: projection,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: "user@example.com", plan: "Pro"),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: false,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(!model.metrics.contains { $0.id == "codex-spark" })
+        #expect(!model.metrics.contains { $0.id == "codex-spark-weekly" })
+        #expect(model.metrics.contains { $0.id == "primary" })
+        #expect(model.metrics.contains { $0.id == "secondary" })
+    }
+}
diff --git a/Tests/CodexBarTests/MenuCardModelTests.swift b/Tests/CodexBarTests/MenuCardModelTests.swift
index 48e2a78030..18dfc1443a 100644
--- a/Tests/CodexBarTests/MenuCardModelTests.swift
+++ b/Tests/CodexBarTests/MenuCardModelTests.swift
@@ -4,72 +4,783 @@ import SwiftUI
 import Testing
 @testable import CodexBar
 
-@Suite
-struct MenuCardModelTests {
+struct OverviewMenuCardVisibilityTests {
+    @Test
+    func `overview hides cards that only contain an error`() throws {
+        let metadata = try #require(ProviderDefaults.metadata[.cursor])
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .cursor,
+            metadata: metadata,
+            snapshot: nil,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: "No Cursor session found.",
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: Date()))
+
+        #expect(model.isOverviewErrorOnly)
+    }
+
+    @Test
+    func `overview keeps cards with graceful unavailable placeholders`() throws {
+        let metadata = try #require(ProviderDefaults.metadata[.codex])
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .codex,
+            metadata: metadata,
+            snapshot: nil,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: "user@example.com", plan: "pro"),
+            isRefreshing: false,
+            lastError: UsageError.noRateLimitsFound.errorDescription,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: Date()))
+
+        #expect(model.placeholder == "Limits not available")
+        #expect(!model.isOverviewErrorOnly)
+    }
+}
+
+struct ProviderInlineDashboardModelTests {
+    @Test
+    func `claude admin api usage gets inline dashboard`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_179_200)
+        let metadata = try #require(ProviderDefaults.metadata[.claude])
+        let usage = ClaudeAdminAPIUsageSnapshot(
+            daily: [
+                ClaudeAdminAPIUsageSnapshot.DailyBucket(
+                    day: "2023-11-14",
+                    startTime: now,
+                    endTime: now.addingTimeInterval(86400),
+                    costUSD: 1.25,
+                    inputTokens: 1000,
+                    cacheCreationInputTokens: 400,
+                    cacheReadInputTokens: 300,
+                    outputTokens: 250,
+                    totalTokens: 1950,
+                    costItems: [
+                        ClaudeAdminAPIUsageSnapshot.CostBreakdown(name: "Claude Sonnet Usage", costUSD: 1.25),
+                    ],
+                    models: [
+                        ClaudeAdminAPIUsageSnapshot.ModelBreakdown(
+                            name: "claude-sonnet-4-20250514",
+                            inputTokens: 1000,
+                            cacheCreationInputTokens: 400,
+                            cacheReadInputTokens: 300,
+                            outputTokens: 250,
+                            totalTokens: 1950),
+                    ]),
+            ],
+            updatedAt: now)
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .claude,
+            metadata: metadata,
+            snapshot: usage.toUsageSnapshot(),
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.metrics.isEmpty)
+        #expect(model.inlineUsageDashboard?.kpis.first?.value == "$1.25")
+        #expect(model.inlineUsageDashboard?.points.first?.accessibilityValue == "2023-11-14: $1.25")
+        #expect(model.inlineUsageDashboard?.detailLines
+            .contains { $0.hasPrefix("30d:") && $0.contains("tokens") } == true)
+        #expect(model.inlineUsageDashboard?.detailLines.contains("Top model: claude-sonnet-4-20250514") == true)
+        #expect(model.planText == "Admin API")
+    }
+
+    @Test
+    func `openrouter period usage gets inline dashboard`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_179_200)
+        let metadata = try #require(ProviderDefaults.metadata[.openrouter])
+        let usage = OpenRouterUsageSnapshot(
+            totalCredits: 100,
+            totalUsage: 40,
+            balance: 60,
+            usedPercent: 40,
+            keyDataFetched: true,
+            keyLimit: 25,
+            keyUsage: 10,
+            keyUsageDaily: 1.25,
+            keyUsageWeekly: 7.5,
+            keyUsageMonthly: 18.75,
+            rateLimit: OpenRouterRateLimit(requests: 100, interval: "10s"),
+            updatedAt: now)
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .openrouter,
+            metadata: metadata,
+            snapshot: usage.toUsageSnapshot(),
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.inlineUsageDashboard?.kpis.first?.value == "$60.00")
+        #expect(model.inlineUsageDashboard?.points.map(\.label) == ["Today", "Week", "Month"])
+        #expect(model.inlineUsageDashboard?.detailLines.contains("Rate limit: 100 / 10s") == true)
+    }
+
+    @Test
+    func `local cost history gets inline dashboard`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_179_200)
+        let metadata = try #require(ProviderDefaults.metadata[.claude])
+        let daily = [
+            CostUsageDailyReport.Entry(
+                date: "2023-11-14",
+                inputTokens: 100,
+                outputTokens: 50,
+                totalTokens: 150,
+                costUSD: 0.12,
+                modelsUsed: ["claude-sonnet-4"],
+                modelBreakdowns: [
+                    CostUsageDailyReport.ModelBreakdown(
+                        modelName: "claude-sonnet-4",
+                        costUSD: 0.12,
+                        totalTokens: 150),
+                ]),
+            CostUsageDailyReport.Entry(
+                date: "2023-11-15",
+                inputTokens: 200,
+                outputTokens: 75,
+                totalTokens: 275,
+                costUSD: 0.25,
+                modelsUsed: ["claude-opus-4"],
+                modelBreakdowns: [
+                    CostUsageDailyReport.ModelBreakdown(
+                        modelName: "claude-opus-4",
+                        costUSD: 0.25,
+                        totalTokens: 275),
+                ]),
+        ]
+        let tokenSnapshot = CostUsageTokenSnapshot(
+            sessionTokens: 275,
+            sessionCostUSD: 0.25,
+            last30DaysTokens: 425,
+            last30DaysCostUSD: 0.37,
+            daily: daily,
+            updatedAt: now)
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .claude,
+            metadata: metadata,
+            snapshot: UsageSnapshot(
+                primary: RateWindow(usedPercent: 10, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: now),
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: tokenSnapshot,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: true,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.inlineUsageDashboard?.kpis.first?.value == "$0.25")
+        #expect(model.inlineUsageDashboard?.points.count == 2)
+        #expect(model.inlineUsageDashboard?.detailLines.contains { $0.contains("claude-opus-4") } == true)
+        #expect(model.tokenUsage?.sessionLine.contains("$0.25") == true)
+        #expect(model.tokenUsage?.monthLine.contains("$0.37") == true)
+    }
+
+    @Test
+    func `mistral daily buckets get inline dashboard`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_179_200)
+        let metadata = try #require(ProviderDefaults.metadata[.mistral])
+        let snapshot = MistralUsageSnapshot(
+            totalCost: 1.5,
+            currency: "EUR",
+            currencySymbol: "€",
+            totalInputTokens: 100,
+            totalOutputTokens: 50,
+            totalCachedTokens: 0,
+            modelCount: 1,
+            daily: [
+                MistralDailyUsageBucket(
+                    day: "2023-11-14",
+                    cost: 1.5,
+                    inputTokens: 100,
+                    cachedTokens: 0,
+                    outputTokens: 50,
+                    models: [
+                        MistralDailyUsageBucket.ModelBreakdown(
+                            name: "mistral-large",
+                            cost: 1.5,
+                            inputTokens: 100,
+                            cachedTokens: 0,
+                            outputTokens: 50),
+                    ]),
+            ],
+            startDate: nil,
+            endDate: nil,
+            updatedAt: now)
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .mistral,
+            metadata: metadata,
+            snapshot: snapshot.toUsageSnapshot(),
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.inlineUsageDashboard?.kpis.first?.value == "€1.50")
+        #expect(model.inlineUsageDashboard?.points.first?.accessibilityValue == "2023-11-14: €1.50")
+        #expect(model.inlineUsageDashboard?.detailLines.contains("Top model: mistral-large") == true)
+    }
+
+    @Test
+    func `mistral billing usage can show cost card summary`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_179_200)
+        let metadata = try #require(ProviderDefaults.metadata[.mistral])
+        let snapshot = MistralUsageSnapshot(
+            totalCost: 1.5,
+            currency: "EUR",
+            currencySymbol: "€",
+            totalInputTokens: 100,
+            totalOutputTokens: 50,
+            totalCachedTokens: 25,
+            modelCount: 1,
+            daily: [
+                MistralDailyUsageBucket(
+                    day: "2023-11-14",
+                    cost: 1.5,
+                    inputTokens: 100,
+                    cachedTokens: 25,
+                    outputTokens: 50,
+                    models: [
+                        MistralDailyUsageBucket.ModelBreakdown(
+                            name: "mistral-large",
+                            cost: 1.5,
+                            inputTokens: 100,
+                            cachedTokens: 25,
+                            outputTokens: 50),
+                    ]),
+            ],
+            startDate: nil,
+            endDate: nil,
+            updatedAt: now)
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .mistral,
+            metadata: metadata,
+            snapshot: snapshot.toUsageSnapshot(),
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: snapshot.toCostUsageTokenSnapshot(historyDays: 30),
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: true,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(ProviderDescriptorRegistry.descriptor(for: .mistral).tokenCost.supportsTokenCost)
+        #expect(model.tokenUsage?.sessionLine == "Latest billing day (Nov 14): €1.50 · 175 tokens")
+        #expect(model.tokenUsage?.monthLine == "This month: €1.50 · 175 tokens")
+        #expect(model.tokenUsage?.hintLine == "Reported by Mistral billing usage.")
+    }
+
+    @Test
+    func `zai hourly usage gets inline dashboard`() throws {
+        let now = try #require(Self.zaiDate("2023-11-15 12:00"))
+        let metadata = try #require(ProviderDefaults.metadata[.zai])
+        let usage = ZaiUsageSnapshot(
+            tokenLimit: nil,
+            timeLimit: nil,
+            planName: "Pro",
+            modelUsage: ZaiModelUsageData(
+                xTime: ["2023-11-14 12:00", "2023-11-15 12:00"],
+                modelDataList: [
+                    ZaiModelDataItem(modelName: "glm-4.5", tokensUsage: [100, 200]),
+                ]),
+            updatedAt: now)
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .zai,
+            metadata: metadata,
+            snapshot: usage.toUsageSnapshot(),
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.inlineUsageDashboard?.kpis.first?.value == "300")
+        #expect(model.inlineUsageDashboard?.points.map(\.label) == ["12", "12"])
+        #expect(Set(model.inlineUsageDashboard?.points.map(\.id) ?? []).count == 2)
+        #expect(model.inlineUsageDashboard?.detailLines.contains("Top model: glm-4.5") == true)
+    }
+
+    private static func zaiDate(_ text: String) -> Date? {
+        let formatter = DateFormatter()
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        formatter.dateFormat = "yyyy-MM-dd HH:mm"
+        return formatter.date(from: text)
+    }
+}
+
+struct FactoryMenuCardModelTests {
+    @Test
+    func `factory token rate billing uses time window labels`() throws {
+        let now = Date()
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 12, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 34, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            tertiary: RateWindow(usedPercent: 56, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            updatedAt: now,
+            identity: nil)
+        let metadata = try #require(ProviderDefaults.metadata[.factory])
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .factory,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: true,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.metrics.map(\.title) == ["5-hour", "Weekly", "Monthly"])
+    }
+
+    @Test
+    func `factory legacy billing keeps pool labels`() throws {
+        let now = Date()
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 12, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 34, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            updatedAt: now,
+            identity: nil)
+        let metadata = try #require(ProviderDefaults.metadata[.factory])
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .factory,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: true,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.metrics.map(\.title) == ["Standard", "Premium"])
+    }
+
+    @Test
+    func `factory extra usage balance renders as optional balance`() throws {
+        let now = Date()
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 12, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 34, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            tertiary: RateWindow(usedPercent: 56, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            providerCost: ProviderCostSnapshot(
+                used: 25,
+                limit: 0,
+                currencyCode: "USD",
+                period: "Extra usage balance",
+                updatedAt: now),
+            updatedAt: now,
+            identity: nil)
+        let metadata = try #require(ProviderDefaults.metadata[.factory])
+
+        let visible = UsageMenuCardView.Model.make(.init(
+            provider: .factory,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: true,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+        #expect(visible.providerCost?.title == "Extra usage")
+        #expect(visible.providerCost?.spendLine == "Balance: $25.00")
+        #expect(visible.providerCost?.percentUsed == nil)
+        #expect(visible.providerCost?.percentLine == nil)
+
+        let hidden = UsageMenuCardView.Model.make(.init(
+            provider: .factory,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: true,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: false,
+            hidePersonalInfo: false,
+            now: now))
+        #expect(hidden.providerCost == nil)
+    }
+}
+
+struct MiniMaxMenuCardModelTests {
+    @Test
+    func `minimax service metrics use codex aligned quota copy`() throws {
+        let now = Date()
+        let minimax = MiniMaxUsageSnapshot(
+            planName: "Max",
+            availablePrompts: nil,
+            currentPrompts: nil,
+            remainingPrompts: nil,
+            windowMinutes: nil,
+            usedPercent: nil,
+            resetsAt: nil,
+            updatedAt: now,
+            services: [
+                MiniMaxServiceUsage(
+                    serviceType: "text-generation",
+                    windowType: "5 hours",
+                    timeRange: "10:00-15:00(UTC+8)",
+                    usage: 2,
+                    limit: 10,
+                    percent: 20,
+                    resetsAt: now.addingTimeInterval(3600),
+                    resetDescription: "Resets in 1 hour"),
+            ])
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 20, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            minimaxUsage: minimax,
+            updatedAt: now,
+            identity: ProviderIdentitySnapshot(
+                providerID: .minimax,
+                accountEmail: nil,
+                accountOrganization: nil,
+                loginMethod: "Max"))
+        let metadata = try #require(ProviderDefaults.metadata[.minimax])
+
+        let used = UsageMenuCardView.Model.make(.init(
+            provider: .minimax,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: true,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(used.metrics.first?.title == "Text Generation")
+        #expect(used.metrics.first?.detailLeftText == "Usage: 2 / 10")
+        #expect(used.metrics.first?.detailRightText == nil)
+        #expect(used.metrics.first?.detailText == nil)
+        #expect(used.metrics.first?.percent == 20)
+        #expect(used.metrics.first?.cardStyle == false)
+    }
+
     @Test
-    func buildsMetricsUsingRemainingPercent() throws {
+    func `text generation badge uses real window type when multiple windows exist`() throws {
         let now = Date()
-        let identity = ProviderIdentitySnapshot(
-            providerID: .codex,
-            accountEmail: "codex@example.com",
-            accountOrganization: nil,
-            loginMethod: "Plus Plan")
-        let snapshot = UsageSnapshot(
-            primary: RateWindow(
-                usedPercent: 22,
-                windowMinutes: 300,
-                resetsAt: now.addingTimeInterval(3000),
-                resetDescription: nil),
-            secondary: RateWindow(
-                usedPercent: 40,
-                windowMinutes: 10080,
-                resetsAt: now.addingTimeInterval(6000),
-                resetDescription: nil),
+        let minimax = MiniMaxUsageSnapshot(
+            planName: "Max",
+            availablePrompts: nil,
+            currentPrompts: nil,
+            remainingPrompts: nil,
+            windowMinutes: nil,
+            usedPercent: nil,
+            resetsAt: nil,
             updatedAt: now,
-            identity: identity)
-        let metadata = try #require(ProviderDefaults.metadata[.codex])
-        let updatedSnap = try UsageSnapshot(
-            primary: snapshot.primary,
-            secondary: RateWindow(
-                usedPercent: #require(snapshot.secondary?.usedPercent),
-                windowMinutes: #require(snapshot.secondary?.windowMinutes),
-                resetsAt: now.addingTimeInterval(3600),
-                resetDescription: nil),
-            tertiary: snapshot.tertiary,
+            services: [
+                MiniMaxServiceUsage(
+                    serviceType: "text-generation",
+                    windowType: "Today",
+                    timeRange: "2026/05/16 00:00 - 2026/05/17 00:00",
+                    usage: 2,
+                    limit: 10,
+                    percent: 20,
+                    resetsAt: now.addingTimeInterval(3600),
+                    resetDescription: "Resets in 1 hour"),
+                MiniMaxServiceUsage(
+                    serviceType: "text-generation",
+                    windowType: "Weekly",
+                    timeRange: "05/11 00:00 - 05/18 00:00(UTC+8)",
+                    usage: 20,
+                    limit: 100,
+                    percent: 20,
+                    resetsAt: now.addingTimeInterval(7200),
+                    resetDescription: "Resets in 2 hours"),
+            ])
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 20, windowMinutes: 1440, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            minimaxUsage: minimax,
             updatedAt: now,
-            identity: identity)
+            identity: ProviderIdentitySnapshot(
+                providerID: .minimax,
+                accountEmail: nil,
+                accountOrganization: nil,
+                loginMethod: "Max"))
+        let metadata = try #require(ProviderDefaults.metadata[.minimax])
 
         let model = UsageMenuCardView.Model.make(.init(
-            provider: .codex,
+            provider: .minimax,
             metadata: metadata,
-            snapshot: updatedSnap,
-            credits: CreditsSnapshot(remaining: 12, events: [], updatedAt: now),
+            snapshot: snapshot,
+            credits: nil,
             creditsError: nil,
             dashboard: nil,
             dashboardError: nil,
             tokenSnapshot: nil,
             tokenError: nil,
-            account: AccountInfo(email: "codex@example.com", plan: "Plus Plan"),
+            account: AccountInfo(email: nil, plan: nil),
             isRefreshing: false,
             lastError: nil,
-            usageBarsShowUsed: false,
+            usageBarsShowUsed: true,
             resetTimeDisplayStyle: .countdown,
             tokenCostUsageEnabled: false,
             showOptionalCreditsAndExtraUsage: true,
             hidePersonalInfo: false,
             now: now))
 
-        #expect(model.providerName == "Codex")
         #expect(model.metrics.count == 2)
-        #expect(model.metrics.first?.percent == 78)
+        #expect(model.metrics[0].title == "Text Generation · Today")
+        #expect(model.metrics[1].title == "Text Generation · Weekly")
+    }
+
+    @Test
+    func `minimax token plan model shows weekly quota and points balance`() throws {
+        let now = Date()
+        let minimax = MiniMaxUsageSnapshot(
+            planName: "Token Plan · TokenPlanPlus-年度会员",
+            availablePrompts: nil,
+            currentPrompts: nil,
+            remainingPrompts: nil,
+            windowMinutes: nil,
+            usedPercent: nil,
+            resetsAt: nil,
+            updatedAt: now,
+            services: [
+                MiniMaxServiceUsage(
+                    serviceType: "text-generation",
+                    windowType: "5 hours",
+                    timeRange: "10:00-15:00(UTC+8)",
+                    usage: 4,
+                    limit: 100,
+                    percent: 4,
+                    resetsAt: now.addingTimeInterval(4 * 3600),
+                    resetDescription: "Resets in 4 hours"),
+                MiniMaxServiceUsage(
+                    serviceType: "text-generation",
+                    windowType: "Weekly",
+                    timeRange: "06/01 00:00 - 06/08 00:00(UTC+8)",
+                    usage: 1,
+                    limit: 100,
+                    percent: 1,
+                    resetsAt: now.addingTimeInterval(6 * 24 * 3600),
+                    resetDescription: "Resets in 6 days"),
+            ],
+            pointsBalance: 14000,
+            subscriptionRenewsAt: Date(timeIntervalSince1970: 1_810_569_600))
+        let snapshot = minimax.toUsageSnapshot()
+        let metadata = try #require(ProviderDefaults.metadata[.minimax])
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .minimax,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: true,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
         #expect(model.planText == "Plus")
-        #expect(model.subtitleText.hasPrefix("Updated"))
-        #expect(model.progressColor != Color.clear)
-        #expect(model.metrics[1].resetText?.isEmpty == false)
+        #expect(model.metrics[0].title == "Text Generation · 5h")
+        #expect(model.metrics[1].title == "Text Generation · Weekly")
+        #expect(model.metrics[0].detailLeftText == "Usage: 4 / 100")
+        #expect(model.metrics[1].detailLeftText == "Usage: 1 / 100")
+        #expect(model.metrics[0].detailRightText == nil)
+        #expect(model.metrics[1].detailRightText == nil)
+        #expect(model.metrics[0].detailText == nil)
+        #expect(model.metrics[1].detailText == nil)
+        #expect(model.metrics[0].cardStyle == false)
+        #expect(model.metrics[1].cardStyle == false)
+        #expect(model.providerCost?.title == "Credits")
+        #expect(model.providerCost?.spendLine == "Balance: 14000")
+        #expect(model.usageNotes == [String(format: L("Renews: %@"), minimaxRenewDate(1_810_569_600))])
+    }
+}
+
+struct ClaudeMenuCardCostTests {
+    @Test
+    func `claude extra usage labels monthly denominator as cap`() throws {
+        let now = Date()
+        let metadata = try #require(ProviderDefaults.metadata[.claude])
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 0, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            tertiary: nil,
+            providerCost: ProviderCostSnapshot(
+                used: 5,
+                limit: 20,
+                currencyCode: "USD",
+                period: "Monthly cap",
+                updatedAt: now),
+            updatedAt: now,
+            identity: nil)
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .claude,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.providerCost?.spendLine == "Monthly cap: $5.00 / $20.00")
     }
+}
 
+struct MenuCardModelTests {
     @Test
-    func buildsMetricsUsingUsedPercentWhenEnabled() throws {
+    func `builds metrics using remaining percent`() throws {
         let now = Date()
         let identity = ProviderIdentitySnapshot(
             providerID: .codex,
@@ -90,77 +801,92 @@ struct MenuCardModelTests {
             updatedAt: now,
             identity: identity)
         let metadata = try #require(ProviderDefaults.metadata[.codex])
-
-        let dashboard = OpenAIDashboardSnapshot(
-            signedInEmail: "codex@example.com",
-            codeReviewRemainingPercent: 73,
-            creditEvents: [],
-            dailyBreakdown: [],
-            usageBreakdown: [],
-            creditsPurchaseURL: nil,
-            updatedAt: now)
+        let updatedSnap = try UsageSnapshot(
+            primary: snapshot.primary,
+            secondary: RateWindow(
+                usedPercent: #require(snapshot.secondary?.usedPercent),
+                windowMinutes: #require(snapshot.secondary?.windowMinutes),
+                resetsAt: now.addingTimeInterval(3600),
+                resetDescription: nil),
+            tertiary: snapshot.tertiary,
+            updatedAt: now,
+            identity: identity)
+        let codexProjection = CodexConsumerProjection.make(
+            surface: .liveCard,
+            context: CodexConsumerProjection.Context(
+                snapshot: updatedSnap,
+                rawUsageError: nil,
+                liveCredits: nil,
+                rawCreditsError: nil,
+                liveDashboard: nil,
+                rawDashboardError: nil,
+                dashboardAttachmentAuthorized: false,
+                dashboardRequiresLogin: false,
+                now: now))
 
         let model = UsageMenuCardView.Model.make(.init(
             provider: .codex,
             metadata: metadata,
-            snapshot: snapshot,
-            credits: nil,
+            snapshot: updatedSnap,
+            codexProjection: codexProjection,
+            credits: CreditsSnapshot(remaining: 12, events: [], updatedAt: now),
             creditsError: nil,
-            dashboard: dashboard,
+            dashboard: nil,
             dashboardError: nil,
             tokenSnapshot: nil,
             tokenError: nil,
             account: AccountInfo(email: "codex@example.com", plan: "Plus Plan"),
             isRefreshing: false,
             lastError: nil,
-            usageBarsShowUsed: true,
+            usageBarsShowUsed: false,
             resetTimeDisplayStyle: .countdown,
             tokenCostUsageEnabled: false,
             showOptionalCreditsAndExtraUsage: true,
             hidePersonalInfo: false,
+            quotaWarningThresholds: [.session: [50, 20], .weekly: [25, 0]],
             now: now))
 
-        #expect(model.metrics.first?.title == "Session")
-        #expect(model.metrics.first?.percent == 22)
-        #expect(model.metrics.first?.percentLabel.contains("used") == true)
-        #expect(model.metrics.contains { $0.title == "Code review" && $0.percent == 27 })
+        #expect(model.providerName == "Codex")
+        #expect(model.metrics.count == 2)
+        #expect(model.metrics.first?.percent == 78)
+        #expect(model.metrics.first?.warningMarkerPercents == [50, 20])
+        #expect(model.metrics[1].warningMarkerPercents == [25])
+        #expect(model.planText == "Plus")
+        #expect(model.subtitleText.hasPrefix("Updated"))
+        #expect(model.progressColor != Color.clear)
+        #expect(model.metrics[1].resetText?.isEmpty == false)
     }
 
     @Test
-    func showsCodeReviewMetricWhenDashboardPresent() throws {
+    func `claude model hides weekly when unavailable`() throws {
         let now = Date()
         let identity = ProviderIdentitySnapshot(
-            providerID: .codex,
-            accountEmail: "codex@example.com",
+            providerID: .claude,
+            accountEmail: nil,
             accountOrganization: nil,
-            loginMethod: nil)
+            loginMethod: "Max")
         let snapshot = UsageSnapshot(
-            primary: RateWindow(usedPercent: 0, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            primary: RateWindow(
+                usedPercent: 2,
+                windowMinutes: nil,
+                resetsAt: now.addingTimeInterval(3600),
+                resetDescription: nil),
             secondary: nil,
             tertiary: nil,
             updatedAt: now,
             identity: identity)
-        let metadata = try #require(ProviderDefaults.metadata[.codex])
-
-        let dashboard = OpenAIDashboardSnapshot(
-            signedInEmail: "codex@example.com",
-            codeReviewRemainingPercent: 73,
-            creditEvents: [],
-            dailyBreakdown: [],
-            usageBreakdown: [],
-            creditsPurchaseURL: nil,
-            updatedAt: now)
+        let metadata = try #require(ProviderDefaults.metadata[.claude])
         let model = UsageMenuCardView.Model.make(.init(
-            provider: .codex,
+            provider: .claude,
             metadata: metadata,
             snapshot: snapshot,
             credits: nil,
             creditsError: nil,
-            dashboard: dashboard,
+            dashboard: nil,
             dashboardError: nil,
             tokenSnapshot: nil,
             tokenError: nil,
-            account: AccountInfo(email: "codex@example.com", plan: nil),
+            account: AccountInfo(email: "codex@example.com", plan: "plus"),
             isRefreshing: false,
             lastError: nil,
             usageBarsShowUsed: false,
@@ -170,11 +896,13 @@ struct MenuCardModelTests {
             hidePersonalInfo: false,
             now: now))
 
-        #expect(model.metrics.contains { $0.title == "Code review" && $0.percent == 73 })
+        #expect(model.metrics.count == 1)
+        #expect(model.metrics.first?.title == "Session")
+        #expect(model.planText == "Max")
     }
 
     @Test
-    func claudeModelHidesWeeklyWhenUnavailable() throws {
+    func `claude model includes routines bar when present`() throws {
         let now = Date()
         let identity = ProviderIdentitySnapshot(
             providerID: .claude,
@@ -187,8 +915,26 @@ struct MenuCardModelTests {
                 windowMinutes: nil,
                 resetsAt: now.addingTimeInterval(3600),
                 resetDescription: nil),
-            secondary: nil,
-            tertiary: nil,
+            secondary: RateWindow(
+                usedPercent: 8,
+                windowMinutes: 10080,
+                resetsAt: now.addingTimeInterval(7200),
+                resetDescription: nil),
+            tertiary: RateWindow(
+                usedPercent: 16,
+                windowMinutes: 10080,
+                resetsAt: now.addingTimeInterval(7800),
+                resetDescription: nil),
+            extraRateWindows: [
+                NamedRateWindow(
+                    id: "claude-routines",
+                    title: "Daily Routines",
+                    window: RateWindow(
+                        usedPercent: 7,
+                        windowMinutes: 10080,
+                        resetsAt: now.addingTimeInterval(9200),
+                        resetDescription: nil)),
+            ],
             updatedAt: now,
             identity: identity)
         let metadata = try #require(ProviderDefaults.metadata[.claude])
@@ -212,13 +958,11 @@ struct MenuCardModelTests {
             hidePersonalInfo: false,
             now: now))
 
-        #expect(model.metrics.count == 1)
-        #expect(model.metrics.first?.title == "Session")
-        #expect(model.planText == "Max")
+        #expect(model.metrics.map(\.title) == ["Session", "Weekly", "Sonnet", "Daily Routines"])
     }
 
     @Test
-    func showsErrorSubtitleWhenPresent() throws {
+    func `shows error subtitle when present`() throws {
         let metadata = try #require(ProviderDefaults.metadata[.codex])
         let model = UsageMenuCardView.Model.make(.init(
             provider: .codex,
@@ -246,7 +990,7 @@ struct MenuCardModelTests {
     }
 
     @Test
-    func costSectionIncludesLast30DaysTokens() throws {
+    func `cost section includes last30 days tokens`() throws {
         let now = Date()
         let metadata = try #require(ProviderDefaults.metadata[.codex])
         let snapshot = UsageSnapshot(
@@ -283,10 +1027,11 @@ struct MenuCardModelTests {
 
         #expect(model.tokenUsage?.monthLine.contains("456") == true)
         #expect(model.tokenUsage?.monthLine.contains("tokens") == true)
+        #expect(model.tokenUsage?.hintLine == "Estimated from local Codex logs for the selected account.")
     }
 
     @Test
-    func claudeModelDoesNotLeakCodexPlan() throws {
+    func `claude model does not leak codex plan`() throws {
         let metadata = try #require(ProviderDefaults.metadata[.claude])
         let model = UsageMenuCardView.Model.make(.init(
             provider: .claude,
@@ -313,46 +1058,7 @@ struct MenuCardModelTests {
     }
 
     @Test
-    func hidesCodexCreditsWhenDisabled() throws {
-        let now = Date()
-        let identity = ProviderIdentitySnapshot(
-            providerID: .codex,
-            accountEmail: "codex@example.com",
-            accountOrganization: nil,
-            loginMethod: nil)
-        let snapshot = UsageSnapshot(
-            primary: RateWindow(usedPercent: 0, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
-            secondary: nil,
-            tertiary: nil,
-            updatedAt: now,
-            identity: identity)
-        let metadata = try #require(ProviderDefaults.metadata[.codex])
-
-        let model = UsageMenuCardView.Model.make(.init(
-            provider: .codex,
-            metadata: metadata,
-            snapshot: snapshot,
-            credits: CreditsSnapshot(remaining: 12, events: [], updatedAt: now),
-            creditsError: nil,
-            dashboard: nil,
-            dashboardError: nil,
-            tokenSnapshot: nil,
-            tokenError: nil,
-            account: AccountInfo(email: "codex@example.com", plan: nil),
-            isRefreshing: false,
-            lastError: nil,
-            usageBarsShowUsed: false,
-            resetTimeDisplayStyle: .countdown,
-            tokenCostUsageEnabled: false,
-            showOptionalCreditsAndExtraUsage: false,
-            hidePersonalInfo: false,
-            now: now))
-
-        #expect(model.creditsText == nil)
-    }
-
-    @Test
-    func hidesClaudeExtraUsageWhenDisabled() throws {
+    func `hides claude extra usage when disabled`() throws {
         let now = Date()
         let identity = ProviderIdentitySnapshot(
             providerID: .claude,
@@ -393,7 +1099,7 @@ struct MenuCardModelTests {
 
     @Test
     @MainActor
-    func openRouterModel_usesAPIKeyQuotaBarAndQuotaDetail() throws {
+    func `open router model uses API key quota bar and quota detail`() throws {
         let now = Date()
         let metadata = try #require(ProviderDefaults.metadata[.openrouter])
         let snapshot = OpenRouterUsageSnapshot(
@@ -439,7 +1145,7 @@ struct MenuCardModelTests {
     }
 
     @Test
-    func openRouterModel_withoutKeyLimitShowsTextOnlySummary() throws {
+    func `open router model without key limit shows text only summary`() throws {
         let now = Date()
         let metadata = try #require(ProviderDefaults.metadata[.openrouter])
         let snapshot = OpenRouterUsageSnapshot(
@@ -480,7 +1186,7 @@ struct MenuCardModelTests {
     }
 
     @Test
-    func openRouterModel_whenKeyFetchUnavailableShowsUnavailableNote() throws {
+    func `open router model when key fetch unavailable shows unavailable note`() throws {
         let now = Date()
         let metadata = try #require(ProviderDefaults.metadata[.openrouter])
         let snapshot = OpenRouterUsageSnapshot(
@@ -519,7 +1225,7 @@ struct MenuCardModelTests {
     }
 
     @Test
-    func hidesEmailWhenPersonalInfoHidden() throws {
+    func `hides email when personal info hidden`() throws {
         let now = Date()
         let identity = ProviderIdentitySnapshot(
             providerID: .codex,
@@ -561,7 +1267,7 @@ struct MenuCardModelTests {
     }
 
     @Test
-    func kiloModelSplitsPassAndActivityAndShowsFallbackNote() throws {
+    func `kilo model splits pass and activity and shows fallback note`() throws {
         let now = Date()
         let metadata = try #require(ProviderDefaults.metadata[.kilo])
         let snapshot = UsageSnapshot(
@@ -607,7 +1313,7 @@ struct MenuCardModelTests {
     }
 
     @Test
-    func kiloModelTreatsAutoTopUpOnlyLoginAsActivity() throws {
+    func `kilo model treats auto top up only login as activity`() throws {
         let now = Date()
         let metadata = try #require(ProviderDefaults.metadata[.kilo])
         let snapshot = UsageSnapshot(
@@ -646,7 +1352,7 @@ struct MenuCardModelTests {
     }
 
     @Test
-    func kiloModelDoesNotShowFallbackNoteWhenNotAutoToCLI() throws {
+    func `kilo model does not show fallback note when not auto to CLI`() throws {
         let now = Date()
         let metadata = try #require(ProviderDefaults.metadata[.kilo])
         let snapshot = UsageSnapshot(
@@ -713,7 +1419,7 @@ struct MenuCardModelTests {
     }
 
     @Test
-    func kiloModelShowsPrimaryDetailWhenResetDateMissing() throws {
+    func `kilo model shows primary detail when reset date missing`() throws {
         let now = Date()
         let metadata = try #require(ProviderDefaults.metadata[.kilo])
         let snapshot = UsageSnapshot(
@@ -757,7 +1463,7 @@ struct MenuCardModelTests {
     }
 
     @Test
-    func kiloModelKeepsZeroTotalEdgeStateVisible() throws {
+    func `kilo model keeps zero total edge state visible`() throws {
         let now = Date()
         let metadata = try #require(ProviderDefaults.metadata[.kilo])
         let snapshot = KiloUsageSnapshot(
@@ -796,7 +1502,7 @@ struct MenuCardModelTests {
     }
 
     @Test
-    func warpModelShowsPrimaryDetailWhenResetDateMissing() throws {
+    func `warp model shows primary detail when reset date missing`() throws {
         let now = Date()
         let identity = ProviderIdentitySnapshot(
             providerID: .warp,
@@ -839,4 +1545,50 @@ struct MenuCardModelTests {
         #expect(primary.resetText == nil)
         #expect(primary.detailText == "10/100 credits")
     }
+
+    @Test
+    func `mistral model surfaces monthly cost as primary detail text`() throws {
+        let now = Date()
+        let resetsAt = now.addingTimeInterval(3 * 24 * 60 * 60)
+        let identity = ProviderIdentitySnapshot(
+            providerID: .mistral,
+            accountEmail: nil,
+            accountOrganization: nil,
+            loginMethod: nil)
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 0,
+                windowMinutes: nil,
+                resetsAt: resetsAt,
+                resetDescription: "€1.2345 this month"),
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: now,
+            identity: identity)
+        let metadata = try #require(ProviderDefaults.metadata[.mistral])
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .mistral,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: true,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        let primary = try #require(model.metrics.first)
+        #expect(primary.detailText == "€1.2345 this month")
+        #expect(primary.resetText?.hasPrefix("Resets") == true)
+    }
 }
diff --git a/Tests/CodexBarTests/MenuCardOptionalUsageModelTests.swift b/Tests/CodexBarTests/MenuCardOptionalUsageModelTests.swift
new file mode 100644
index 0000000000..7784c571d8
--- /dev/null
+++ b/Tests/CodexBarTests/MenuCardOptionalUsageModelTests.swift
@@ -0,0 +1,97 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct MenuCardOptionalUsageModelTests {
+    @Test
+    func `hides codex credits when disabled`() throws {
+        let now = Date()
+        let identity = ProviderIdentitySnapshot(
+            providerID: .codex,
+            accountEmail: "codex@example.com",
+            accountOrganization: nil,
+            loginMethod: nil)
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 0, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: now,
+            identity: identity)
+        let metadata = try #require(ProviderDefaults.metadata[.codex])
+        let credits = CreditsSnapshot(remaining: 12, events: [], updatedAt: now)
+        let codexProjection = CodexConsumerProjection.make(
+            surface: .liveCard,
+            context: CodexConsumerProjection.Context(
+                snapshot: snapshot,
+                rawUsageError: nil,
+                liveCredits: credits,
+                rawCreditsError: nil,
+                liveDashboard: nil,
+                rawDashboardError: nil,
+                dashboardAttachmentAuthorized: true,
+                dashboardRequiresLogin: false,
+                now: now))
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .codex,
+            metadata: metadata,
+            snapshot: snapshot,
+            codexProjection: codexProjection,
+            credits: credits,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: "codex@example.com", plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: false,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.creditsText == nil)
+    }
+
+    @Test
+    func `claude model does not show obsolete peak hours note`() throws {
+        let now = Date()
+        let identity = ProviderIdentitySnapshot(
+            providerID: .claude,
+            accountEmail: "claude@example.com",
+            accountOrganization: nil,
+            loginMethod: nil)
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 30, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: now,
+            identity: identity)
+        let metadata = try #require(ProviderDefaults.metadata[.claude])
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .claude,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.usageNotes.isEmpty)
+    }
+}
diff --git a/Tests/CodexBarTests/MenuCardProviderRegressionTests.swift b/Tests/CodexBarTests/MenuCardProviderRegressionTests.swift
new file mode 100644
index 0000000000..08bcc94eeb
--- /dev/null
+++ b/Tests/CodexBarTests/MenuCardProviderRegressionTests.swift
@@ -0,0 +1,88 @@
+import CodexBarCore
+import Foundation
+import SwiftUI
+import Testing
+@testable import CodexBar
+
+struct MenuCardProviderRegressionTests {
+    @Test
+    func `elevenlabs progress color stays visible in light menus`() {
+        #expect(UsageMenuCardView.Model.progressColor(for: .elevenlabs) == Color(nsColor: .labelColor))
+    }
+
+    @Test
+    func `open router model shows daily and weekly key spend`() throws {
+        let now = Date()
+        let metadata = try #require(ProviderDefaults.metadata[.openrouter])
+        let snapshot = OpenRouterUsageSnapshot(
+            totalCredits: 50,
+            totalUsage: 45.3895596325,
+            balance: 4.6104403675,
+            usedPercent: 90.779119265,
+            keyLimit: 20,
+            keyUsage: 0.5,
+            keyUsageDaily: 0.12,
+            keyUsageWeekly: 0.74,
+            rateLimit: nil,
+            updatedAt: now).toUsageSnapshot()
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .openrouter,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.usageNotes == ["Today: $0.12 · This week: $0.74"])
+    }
+
+    @Test
+    func `copilot over quota usage keeps used percentage detail`() throws {
+        let now = Date()
+        let metadata = try #require(ProviderDefaults.metadata[.copilot])
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 115, windowMinutes: nil, resetsAt: nil, resetDescription: "115% used"),
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: now,
+            identity: nil)
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .copilot,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        let metric = try #require(model.metrics.first)
+        #expect(metric.percent == 0)
+        #expect(metric.percentLabel == "0% left")
+        #expect(metric.detailLeftText == "115% used")
+    }
+}
diff --git a/Tests/CodexBarTests/MenuCardQuotaWarningMarkerTests.swift b/Tests/CodexBarTests/MenuCardQuotaWarningMarkerTests.swift
new file mode 100644
index 0000000000..89c8ca9e16
--- /dev/null
+++ b/Tests/CodexBarTests/MenuCardQuotaWarningMarkerTests.swift
@@ -0,0 +1,131 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct MenuCardQuotaWarningMarkerTests {
+    @Test
+    func `progress fill matches rounded edge labels`() {
+        #expect(UsageProgressBar.renderedFillPercent(0.4) == 0)
+        #expect(UsageProgressBar.renderedFillPercent(0.6) == 0.6)
+        #expect(UsageProgressBar.renderedFillPercent(99.4) == 99.4)
+        #expect(UsageProgressBar.renderedFillPercent(99.6) == 100)
+    }
+
+    @Test
+    func `quota warning marker geometry is inset and hairline`() {
+        let rect = UsageProgressBar.warningMarkerRect(
+            x: 50,
+            size: CGSize(width: 100, height: 6),
+            scale: 2)
+
+        #expect(rect.width == 1)
+        #expect(rect.height < 6)
+        #expect(rect.minY > 0)
+        #expect(abs(rect.midX - 50) <= 0.5)
+    }
+
+    @Test
+    func `omits quota warning markers for disabled windows`() throws {
+        let now = Date()
+        let metadata = try #require(ProviderDefaults.metadata[.codex])
+        let identity = ProviderIdentitySnapshot(
+            providerID: .codex,
+            accountEmail: nil,
+            accountOrganization: nil,
+            loginMethod: "Plus Plan")
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 20,
+                windowMinutes: 300,
+                resetsAt: nil,
+                resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: 40,
+                windowMinutes: 10080,
+                resetsAt: nil,
+                resetDescription: nil),
+            updatedAt: now,
+            identity: identity)
+        let codexProjection = CodexConsumerProjection.make(
+            surface: .liveCard,
+            context: CodexConsumerProjection.Context(
+                snapshot: snapshot,
+                rawUsageError: nil,
+                liveCredits: nil,
+                rawCreditsError: nil,
+                liveDashboard: nil,
+                rawDashboardError: nil,
+                dashboardAttachmentAuthorized: false,
+                dashboardRequiresLogin: false,
+                now: now))
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .codex,
+            metadata: metadata,
+            snapshot: snapshot,
+            codexProjection: codexProjection,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: false,
+            hidePersonalInfo: false,
+            quotaWarningThresholds: [.session: [50], .weekly: []],
+            now: now))
+
+        #expect(model.metrics.count == 2)
+        #expect(model.metrics.first?.warningMarkerPercents == [50])
+        #expect(model.metrics[1].warningMarkerPercents.isEmpty)
+    }
+
+    @Test
+    func `work day marker percents for 5-day week`() {
+        #expect(workDayMarkerPercents(workDays: 5, windowMinutes: 10080) == [20.0, 40.0, 60.0, 80.0])
+    }
+
+    @Test
+    func `work day marker percents for 4-day week`() {
+        #expect(workDayMarkerPercents(workDays: 4, windowMinutes: 10080) == [25.0, 50.0, 75.0])
+    }
+
+    @Test
+    func `work day marker percents for 7-day week`() {
+        let markers = workDayMarkerPercents(workDays: 7, windowMinutes: 10080)
+        #expect(markers.count == 6)
+        #expect(abs(markers[0] - 14.2857) < 0.001)
+        #expect(abs(markers[5] - 85.7143) < 0.001)
+    }
+
+    @Test
+    func `work day marker percents nil work days returns empty`() {
+        #expect(workDayMarkerPercents(workDays: nil, windowMinutes: 10080).isEmpty)
+    }
+
+    @Test
+    func `work day marker percents nil window minutes returns empty`() {
+        #expect(workDayMarkerPercents(workDays: 5, windowMinutes: nil).isEmpty)
+    }
+
+    @Test
+    func `work day marker percents non-weekly window returns empty`() {
+        #expect(workDayMarkerPercents(workDays: 5, windowMinutes: 300).isEmpty)
+        #expect(workDayMarkerPercents(workDays: 5, windowMinutes: 1440).isEmpty)
+    }
+
+    @Test
+    func `work day marker percents invalid work days returns empty`() {
+        #expect(workDayMarkerPercents(workDays: 1, windowMinutes: 10080).isEmpty)
+        #expect(workDayMarkerPercents(workDays: 0, windowMinutes: 10080).isEmpty)
+        #expect(workDayMarkerPercents(workDays: 8, windowMinutes: 10080).isEmpty)
+        #expect(workDayMarkerPercents(workDays: -1, windowMinutes: 10080).isEmpty)
+    }
+}
diff --git a/Tests/CodexBarTests/MenuCardRefreshTests.swift b/Tests/CodexBarTests/MenuCardRefreshTests.swift
new file mode 100644
index 0000000000..3b57fa212c
--- /dev/null
+++ b/Tests/CodexBarTests/MenuCardRefreshTests.swift
@@ -0,0 +1,74 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct MenuCardRefreshTests {
+    private static func makeModel(
+        provider: UsageProvider,
+        snapshot: UsageSnapshot,
+        isRefreshing: Bool,
+        now: Date) throws -> UsageMenuCardView.Model
+    {
+        let metadata = try #require(ProviderDefaults.metadata[provider])
+        return UsageMenuCardView.Model.make(.init(
+            provider: provider,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: isRefreshing,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+    }
+
+    @Test
+    func `background refresh keeps quota timing current`() throws {
+        let updatedAt = Date(timeIntervalSince1970: 1_800_000_000)
+        for provider in [UsageProvider.claude, .codex] {
+            let snapshot = UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 21,
+                    windowMinutes: 300,
+                    resetsAt: updatedAt.addingTimeInterval(4 * 60 * 60 + 40 * 60),
+                    resetDescription: nil),
+                secondary: nil,
+                updatedAt: updatedAt,
+                identity: ProviderIdentitySnapshot(
+                    providerID: provider,
+                    accountEmail: nil,
+                    accountOrganization: nil,
+                    loginMethod: "Pro"))
+            let completedModel = try Self.makeModel(
+                provider: provider,
+                snapshot: snapshot,
+                isRefreshing: false,
+                now: updatedAt)
+            let refreshingModel = try Self.makeModel(
+                provider: provider,
+                snapshot: snapshot,
+                isRefreshing: true,
+                now: updatedAt.addingTimeInterval(10 * 60))
+
+            let completedMetric = try #require(completedModel.metrics.first)
+            let refreshingMetric = try #require(refreshingModel.metrics.first)
+            #expect(refreshingModel.subtitleText == "Refreshing…")
+            #expect(refreshingMetric.percentLabel == completedMetric.percentLabel)
+            #expect(completedMetric.resetText == "Resets in 4h 40m")
+            #expect(refreshingMetric.resetText == "Resets in 4h 30m")
+            #expect(refreshingMetric.detailLeftText != completedMetric.detailLeftText)
+            #expect(refreshingMetric.detailRightText != completedMetric.detailRightText)
+            #expect(refreshingMetric.pacePercent != completedMetric.pacePercent)
+        }
+    }
+}
diff --git a/Tests/CodexBarTests/MenuCardSubtitleTests.swift b/Tests/CodexBarTests/MenuCardSubtitleTests.swift
new file mode 100644
index 0000000000..6cda8e0d51
--- /dev/null
+++ b/Tests/CodexBarTests/MenuCardSubtitleTests.swift
@@ -0,0 +1,94 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct MenuCardSubtitleTests {
+    @Test
+    func `subtitle uses injected current time`() throws {
+        let updatedAt = Date(timeIntervalSinceReferenceDate: 0)
+        let now = updatedAt.addingTimeInterval(5 * 3600)
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 22,
+                windowMinutes: 300,
+                resetsAt: now.addingTimeInterval(3000),
+                resetDescription: nil),
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: updatedAt,
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: "codex@example.com",
+                accountOrganization: nil,
+                loginMethod: "Plus Plan"))
+        let metadata = try #require(ProviderDefaults.metadata[.codex])
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .codex,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: "codex@example.com", plan: "Plus Plan"),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.subtitleText == UsageFormatter.updatedString(from: updatedAt, now: now))
+    }
+
+    @Test
+    func `subtitle shows refreshing while cached snapshot remains visible`() throws {
+        let updatedAt = Date(timeIntervalSinceReferenceDate: 0)
+        let now = updatedAt.addingTimeInterval(5 * 3600)
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 22,
+                windowMinutes: 300,
+                resetsAt: now.addingTimeInterval(3000),
+                resetDescription: nil),
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: updatedAt,
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: "codex@example.com",
+                accountOrganization: nil,
+                loginMethod: "Plus Plan"))
+        let metadata = try #require(ProviderDefaults.metadata[.codex])
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .codex,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: "codex@example.com", plan: "Plus Plan"),
+            isRefreshing: true,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.subtitleText == "Refreshing…")
+        #expect(model.subtitleStyle == .loading)
+        #expect(!model.metrics.isEmpty)
+    }
+}
diff --git a/Tests/CodexBarTests/MenuCardTestDateFormatting.swift b/Tests/CodexBarTests/MenuCardTestDateFormatting.swift
new file mode 100644
index 0000000000..4f94f865d1
--- /dev/null
+++ b/Tests/CodexBarTests/MenuCardTestDateFormatting.swift
@@ -0,0 +1,9 @@
+import Foundation
+
+func minimaxRenewDate(_ timestamp: TimeInterval) -> String {
+    let formatter = DateFormatter()
+    formatter.locale = .current
+    formatter.timeZone = TimeZone(identifier: "Asia/Shanghai")
+    formatter.setLocalizedDateFormatFromTemplate("MMM d, yyyy")
+    return formatter.string(from: Date(timeIntervalSince1970: timestamp))
+}
diff --git a/Tests/CodexBarTests/MenuCardViewRecyclingTests.swift b/Tests/CodexBarTests/MenuCardViewRecyclingTests.swift
new file mode 100644
index 0000000000..70e30e4978
--- /dev/null
+++ b/Tests/CodexBarTests/MenuCardViewRecyclingTests.swift
@@ -0,0 +1,716 @@
+import AppKit
+import CodexBarCore
+import SwiftUI
+import Testing
+@testable import CodexBar
+
+@MainActor
+private final class RecordingMenuHighlightView: NSView, MenuCardHighlighting {
+    private(set) var isHighlighted = false
+
+    func setHighlighted(_ highlighted: Bool) {
+        self.isHighlighted = highlighted
+    }
+}
+
+extension StatusMenuTests {
+    private func makeRecyclingController(settings: SettingsStore) -> StatusItemController {
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        return StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+    }
+
+    private func cardViewIdentities(in menu: NSMenu) -> [String: ObjectIdentifier] {
+        var identities: [String: ObjectIdentifier] = [:]
+        for item in menu.items {
+            guard let id = item.representedObject as? String else { continue }
+            guard let view = item.view, view is any MenuCardMeasuring else { continue }
+            identities[id] = ObjectIdentifier(view)
+        }
+        return identities
+    }
+
+    @Test
+    func `menu card enabled state follows interaction affordances`() {
+        let previousRendering = StatusItemController.menuCardRenderingEnabled
+        defer { StatusItemController.menuCardRenderingEnabled = previousRendering }
+
+        for renderingEnabled in [false, true] {
+            StatusItemController.menuCardRenderingEnabled = renderingEnabled
+            let settings = self.makeSettings()
+            settings.statusChecksEnabled = false
+            let controller = self.makeRecyclingController(settings: settings)
+            defer { controller.releaseStatusItemsForTesting() }
+
+            let informational = controller.makeMenuCardItem(Text("Info"), id: "info", width: 300)
+            let embedded = controller.makeMenuCardItem(
+                Text("Embedded"),
+                id: "embedded",
+                width: 300,
+                containsInteractiveControls: true)
+            let clickable = controller.makeMenuCardItem(Text("Click"), id: "click", width: 300, onClick: {})
+            let submenu = controller.makeMenuCardItem(
+                Text("Submenu"),
+                id: "submenu",
+                width: 300,
+                submenu: NSMenu())
+
+            #expect(!informational.isEnabled)
+            #expect(embedded.isEnabled == renderingEnabled)
+            #expect(clickable.isEnabled)
+            #expect(submenu.isEnabled)
+        }
+    }
+
+    @Test
+    func `embedded controls stay enabled without highlighting the card`() {
+        StatusItemController.setMenuRefreshEnabledForTesting(false)
+        let previousRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = true
+        defer { StatusItemController.menuCardRenderingEnabled = previousRendering }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        let controller = self.makeRecyclingController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = NSMenu()
+        let item = controller.makeMenuCardItem(
+            Text("Embedded"),
+            id: "embedded",
+            width: 300,
+            containsInteractiveControls: true)
+        menu.addItem(item)
+
+        controller.menu(menu, willHighlight: item)
+
+        #expect(item.isEnabled)
+        #expect(controller.highlightedMenuItems[ObjectIdentifier(menu)] == nil)
+        guard let hosting = item.view as? MenuCardItemHostingView<MenuCardSectionContainerView<Text>>
+        else {
+            Issue.record("expected a card hosting view")
+            return
+        }
+        #expect(!hosting.allowsMenuHighlight)
+        #expect(!hosting.highlightState.isHighlighted)
+    }
+
+    @Test
+    func `merged menu width uses widest provider action set`() {
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        let controller = self.makeRecyclingController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let narrow = [
+            MenuDescriptor.Section(entries: [
+                .action("Usage Dashboard", .dashboard),
+            ]),
+        ]
+        let wide = [
+            MenuDescriptor.Section(entries: [
+                .action(String(repeating: "W", count: 60), .dashboard),
+            ]),
+        ]
+
+        let narrowWidth = controller.measuredMenuCardWidth(for: [narrow])
+        let stableWidth = controller.measuredMenuCardWidth(for: [narrow, wide])
+
+        #expect(narrowWidth == StatusItemController.menuCardBaseWidth)
+        #expect(stableWidth > narrowWidth)
+        #expect(controller.measuredMenuCardWidth(for: [wide, narrow]) == stableWidth)
+    }
+
+    @Test
+    func `menu width normalization includes usage history submenu row`() {
+        let previousRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = true
+        defer { StatusItemController.menuCardRenderingEnabled = previousRendering }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        let controller = self.makeRecyclingController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = NSMenu()
+        let usageHistoryItem = controller.makeMenuCardItem(
+            Text("Subscription Utilization"),
+            id: "usageHistorySubmenu",
+            width: StatusItemController.menuCardBaseWidth)
+        menu.addItem(usageHistoryItem)
+        menu.addItem(NSMenuItem(
+            title: String(repeating: "W", count: 60),
+            action: nil,
+            keyEquivalent: ""))
+
+        let expectedWidth = controller.renderedMenuWidth(for: menu)
+        #expect(expectedWidth > StatusItemController.menuCardBaseWidth)
+
+        controller.refreshMenuCardHeights(in: menu)
+
+        #expect(abs((usageHistoryItem.view?.frame.width ?? 0) - expectedWidth) <= 0.5)
+    }
+
+    @Test
+    func `rendered menu width keeps tracked window width after AppKit shrink`() {
+        let width = StatusItemController.resolvedRenderedMenuWidth(
+            menuWidth: 310,
+            trackedWindowWidth: 356)
+
+        #expect(width == 356)
+        #expect(StatusItemController.resolvedRenderedMenuWidth(
+            menuWidth: 310,
+            trackedWindowWidth: nil) == 310)
+    }
+
+    @Test
+    func `data only repopulate reuses menu card hosting views`() {
+        StatusItemController.setMenuRefreshEnabledForTesting(false)
+        let previousRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = true
+        defer { StatusItemController.menuCardRenderingEnabled = previousRendering }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            if let metadata = registry.metadata[provider] {
+                settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: provider == .codex)
+            }
+        }
+
+        let controller = self.makeRecyclingController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.populateMenu(menu, provider: .codex)
+        let firstPass = self.cardViewIdentities(in: menu)
+        #expect(!firstPass.isEmpty)
+
+        controller.invalidateMenus(allowStaleContentDuringDataRefresh: true)
+        controller.populateMenu(menu, provider: .codex)
+        let secondPass = self.cardViewIdentities(in: menu)
+
+        #expect(secondPass.keys.sorted() == firstPass.keys.sorted())
+        for (id, identity) in firstPass {
+            #expect(secondPass[id] == identity, "card \(id) should reuse its hosting view")
+        }
+        #expect(controller.menuCardViewRecyclePool.isEmpty)
+    }
+
+    @Test
+    func `merged data tick keeps row count and card views stable`() {
+        StatusItemController.setMenuRefreshEnabledForTesting(false)
+        let previousRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = true
+        defer { StatusItemController.menuCardRenderingEnabled = previousRendering }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.mergedMenuLastSelectedWasOverview = false
+        let registry = ProviderRegistry.shared
+        let enabled: Set<UsageProvider> = [.codex, .claude]
+        for provider in UsageProvider.allCases {
+            if let metadata = registry.metadata[provider] {
+                settings.setProviderEnabled(
+                    provider: provider,
+                    metadata: metadata,
+                    enabled: enabled.contains(provider))
+            }
+        }
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        controller.selectedMenuProvider = .codex
+        let menu = controller.makeMenu()
+        controller.populateMenu(menu, provider: .codex)
+        let itemCountBefore = menu.items.count
+        let cardViewsBefore = self.cardViewIdentities(in: menu)
+        #expect(!cardViewsBefore.isEmpty)
+
+        controller.invalidateMenus(allowStaleContentDuringDataRefresh: true)
+        controller.populateMenu(menu, provider: .codex)
+
+        #expect(menu.items.count == itemCountBefore, "data-only repopulate should keep row count stable")
+        let cardViewsAfter = self.cardViewIdentities(in: menu)
+        for (id, identity) in cardViewsBefore {
+            #expect(cardViewsAfter[id] == identity, "card \(id) should reuse its hosting view")
+        }
+    }
+
+    @Test
+    func `reconcile keeps matching edge rows when the middle differs`() {
+        StatusItemController.setMenuRefreshEnabledForTesting(false)
+        let previousRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = true
+        defer { StatusItemController.menuCardRenderingEnabled = previousRendering }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        let controller = self.makeRecyclingController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        func plainItem(_ title: String) -> NSMenuItem {
+            NSMenuItem(title: title, action: nil, keyEquivalent: "")
+        }
+
+        let menu = NSMenu()
+        menu.addItem(controller.makeMenuCardItem(Text("card"), id: "menuCard", width: 300))
+        menu.addItem(.separator())
+        menu.addItem(plainItem("Old Provider Action"))
+        menu.addItem(plainItem("Old Provider Detail"))
+        menu.addItem(.separator())
+        menu.addItem(plainItem("Settings"))
+        let cardItem = menu.items[0]
+        let cardView = cardItem.view
+        let settingsItem = menu.items[5]
+
+        let shapes = controller.menuContentShapes(in: menu, fromIndex: 0)
+        controller.harvestRecyclableMenuCardViews(in: menu, fromIndex: 0, displacedSelection: nil)
+        defer { controller.clearMenuCardViewRecyclePool() }
+
+        let scratch = NSMenu()
+        scratch.addItem(controller.makeMenuCardItem(Text("other provider card"), id: "menuCard", width: 300))
+        scratch.addItem(.separator())
+        scratch.addItem(plainItem("New Provider Action"))
+        scratch.addItem(.separator())
+        scratch.addItem(plainItem("Settings"))
+
+        controller.reconcileMenuContent(menu, fromIndex: 0, shapes: shapes, with: scratch)
+
+        #expect(menu.items.count == 5)
+        #expect(menu.items[0] === cardItem, "card row should be updated in place")
+        #expect(menu.items[0].view === cardView, "card hosting view should be recycled in place")
+        #expect(menu.items[4] === settingsItem, "shared trailing row should be updated in place")
+        #expect(menu.items[2].title == "New Provider Action")
+    }
+
+    @Test
+    func `cached provider content replaces native image rows and preserves switch back items`() {
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        let controller = self.makeRecyclingController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let outgoing = NSMenuItem(title: "Status Page", action: nil, keyEquivalent: "")
+        outgoing.image = NSImage(size: NSSize(width: 16, height: 16))
+        let incoming = NSMenuItem(title: "Dashboard", action: nil, keyEquivalent: "")
+        incoming.image = NSImage(size: NSSize(width: 16, height: 16))
+        let menu = NSMenu()
+        menu.addItem(outgoing)
+
+        let displacedOutgoing = controller.replaceMenuContentKeepingRowsVisible(
+            menu,
+            fromIndex: 0,
+            with: [incoming])
+
+        #expect(menu.items.first === incoming)
+        #expect(displacedOutgoing.first === outgoing)
+
+        let displacedIncoming = controller.replaceMenuContentKeepingRowsVisible(
+            menu,
+            fromIndex: 0,
+            with: displacedOutgoing)
+
+        #expect(menu.items.first === outgoing)
+        #expect(displacedIncoming.first === incoming)
+    }
+
+    @Test
+    func `cached provider content swap preserves both item sets for switch back`() {
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        let controller = self.makeRecyclingController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let switcher = NSMenuItem(title: "Switcher", action: nil, keyEquivalent: "")
+        let outgoing = [
+            NSMenuItem(title: "Overview Card", action: nil, keyEquivalent: ""),
+            NSMenuItem.separator(),
+            NSMenuItem(title: "Overview Action", action: nil, keyEquivalent: ""),
+        ]
+        let incoming = [
+            NSMenuItem(title: "Codex Card", action: nil, keyEquivalent: ""),
+            NSMenuItem.separator(),
+            NSMenuItem(title: "Codex Usage", action: nil, keyEquivalent: ""),
+            NSMenuItem(title: "Codex Settings", action: nil, keyEquivalent: ""),
+        ]
+        let menu = NSMenu()
+        menu.addItem(switcher)
+        outgoing.forEach(menu.addItem)
+
+        let displacedOutgoing = controller.replaceMenuContentKeepingRowsVisible(
+            menu,
+            fromIndex: 1,
+            with: incoming)
+
+        #expect(menu.items.first === switcher)
+        #expect(menu.items.dropFirst().map(\.title) == ["Codex Card", "", "Codex Usage", "Codex Settings"])
+        #expect(Array(menu.items[1...3]).map(ObjectIdentifier.init) == outgoing.map(ObjectIdentifier.init))
+        #expect(displacedOutgoing.map(ObjectIdentifier.init) == incoming.prefix(3).map(ObjectIdentifier.init))
+        #expect(displacedOutgoing.map(\.title) == ["Overview Card", "", "Overview Action"])
+
+        let displacedIncoming = controller.replaceMenuContentKeepingRowsVisible(
+            menu,
+            fromIndex: 1,
+            with: displacedOutgoing)
+
+        #expect(Array(menu.items.dropFirst()).map(ObjectIdentifier.init) == outgoing.map(ObjectIdentifier.init))
+        #expect(displacedIncoming.map(ObjectIdentifier.init) == incoming.map(ObjectIdentifier.init))
+        #expect(displacedIncoming.allSatisfy { $0.menu == nil })
+        #expect(displacedIncoming.map(\.title) == ["Codex Card", "", "Codex Usage", "Codex Settings"])
+    }
+
+    @Test
+    func `reconcile preserves highlight on a retained custom action row`() {
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        let controller = self.makeRecyclingController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = NSMenu()
+        let liveItem = NSMenuItem()
+        liveItem.isEnabled = true
+        liveItem.representedObject = "action"
+        liveItem.view = RecordingMenuHighlightView()
+        menu.addItem(liveItem)
+        controller.menu(menu, willHighlight: liveItem)
+
+        let replacementView = RecordingMenuHighlightView()
+        let replacementItem = NSMenuItem()
+        replacementItem.isEnabled = true
+        replacementItem.representedObject = "action"
+        replacementItem.view = replacementView
+        let scratch = NSMenu()
+        scratch.addItem(replacementItem)
+
+        let shapes = controller.menuContentShapes(in: menu, fromIndex: 0)
+        controller.reconcileMenuContent(menu, fromIndex: 0, shapes: shapes, with: scratch)
+
+        #expect(menu.items[0] === liveItem)
+        #expect(liveItem.view === replacementView)
+        #expect(replacementView.isHighlighted)
+        #expect(controller.highlightedMenuItems[ObjectIdentifier(menu)] === liveItem)
+    }
+
+    @Test
+    func `reconcile restores highlight on a retained recycled card`() {
+        StatusItemController.setMenuRefreshEnabledForTesting(false)
+        let previousRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = true
+        defer { StatusItemController.menuCardRenderingEnabled = previousRendering }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        let controller = self.makeRecyclingController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = NSMenu()
+        let liveItem = controller.makeMenuCardItem(Text("before"), id: "menuCard", width: 300, onClick: {})
+        menu.addItem(liveItem)
+        controller.menu(menu, willHighlight: liveItem)
+        guard let hosting = liveItem.view as? MenuCardItemHostingView<MenuCardSectionContainerView<Text>>
+        else {
+            Issue.record("expected a card hosting view")
+            return
+        }
+
+        let shapes = controller.menuContentShapes(in: menu, fromIndex: 0)
+        controller.harvestRecyclableMenuCardViews(
+            in: menu,
+            fromIndex: 0,
+            displacedSelection: nil,
+            preserveHighlightedItem: true)
+        defer { controller.clearMenuCardViewRecyclePool() }
+        #expect(!hosting.highlightState.isHighlighted)
+        #expect(controller.highlightedMenuItems[ObjectIdentifier(menu)] === liveItem)
+
+        let scratch = NSMenu()
+        scratch.addItem(controller.makeMenuCardItem(Text("after"), id: "menuCard", width: 300, onClick: {}))
+        controller.reconcileMenuContent(menu, fromIndex: 0, shapes: shapes, with: scratch)
+
+        #expect(menu.items[0] === liveItem)
+        #expect(liveItem.view === hosting)
+        #expect(hosting.highlightState.isHighlighted)
+        #expect(controller.highlightedMenuItems[ObjectIdentifier(menu)] === liveItem)
+    }
+
+    @Test
+    func `reconcile clears highlight when a retained card becomes disabled`() {
+        StatusItemController.setMenuRefreshEnabledForTesting(false)
+        let previousRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = true
+        defer { StatusItemController.menuCardRenderingEnabled = previousRendering }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        let controller = self.makeRecyclingController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = NSMenu()
+        let liveItem = controller.makeMenuCardItem(Text("before"), id: "menuCard", width: 300, onClick: {})
+        menu.addItem(liveItem)
+        controller.menu(menu, willHighlight: liveItem)
+        guard let liveView = liveItem.view as? MenuCardItemHostingView<MenuCardSectionContainerView<Text>>
+        else {
+            Issue.record("expected a card hosting view")
+            return
+        }
+        #expect(liveView.highlightState.isHighlighted)
+        #expect(controller.highlightedMenuItems[ObjectIdentifier(menu)] === liveItem)
+
+        let shapes = controller.menuContentShapes(in: menu, fromIndex: 0)
+        let scratch = NSMenu()
+        scratch.addItem(controller.makeMenuCardItem(Text("after"), id: "menuCard", width: 300))
+        controller.reconcileMenuContent(menu, fromIndex: 0, shapes: shapes, with: scratch)
+
+        #expect(menu.items[0] === liveItem)
+        #expect(!liveItem.isEnabled)
+        #expect(controller.highlightedMenuItems[ObjectIdentifier(menu)] == nil)
+        guard let rebuiltView = liveItem.view as? MenuCardItemHostingView<MenuCardSectionContainerView<Text>>
+        else {
+            Issue.record("expected the rebuilt card hosting view")
+            return
+        }
+        #expect(!rebuiltView.highlightState.isHighlighted)
+    }
+
+    @Test
+    func `harvesting consumes only the displaced selection cache entry`() {
+        StatusItemController.setMenuRefreshEnabledForTesting(false)
+        let previousRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = true
+        defer { StatusItemController.menuCardRenderingEnabled = previousRendering }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        let controller = self.makeRecyclingController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = NSMenu()
+        let item = controller.makeMenuCardItem(Text("card"), id: "menuCard", width: 300, onClick: {})
+        menu.addItem(item)
+
+        let entry = CachedMergedSwitcherMenuContent(
+            requiredMenuContentVersion: 0,
+            menuWidth: 300,
+            codexAccountDisplay: nil,
+            tokenAccountDisplay: nil,
+            localizationSignature: "",
+            items: [])
+        controller.mergedSwitcherContentCaches[ObjectIdentifier(menu)] = [
+            .overview: entry,
+            .provider(.codex): entry,
+        ]
+        controller.harvestRecyclableMenuCardViews(
+            in: menu,
+            fromIndex: 0,
+            displacedSelection: .provider(.codex))
+        defer { controller.clearMenuCardViewRecyclePool() }
+
+        #expect(controller.menuCardViewRecyclePool.count == 1)
+        #expect(item.view == nil)
+        let remaining = controller.mergedSwitcherContentCaches[ObjectIdentifier(menu)]
+        #expect(remaining?[.provider(.codex)] == nil)
+        #expect(remaining?[.overview] != nil)
+    }
+
+    @Test
+    func `harvesting consumes displaced cache when card rendering is disabled`() {
+        let previousRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = false
+        defer { StatusItemController.menuCardRenderingEnabled = previousRendering }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        let controller = self.makeRecyclingController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = NSMenu()
+        let entry = CachedMergedSwitcherMenuContent(
+            requiredMenuContentVersion: 0,
+            menuWidth: 300,
+            codexAccountDisplay: nil,
+            tokenAccountDisplay: nil,
+            localizationSignature: "",
+            items: [])
+        controller.mergedSwitcherContentCaches[ObjectIdentifier(menu)] = [
+            .overview: entry,
+            .provider(.codex): entry,
+        ]
+
+        controller.harvestRecyclableMenuCardViews(
+            in: menu,
+            fromIndex: 0,
+            displacedSelection: .provider(.codex))
+
+        let remaining = controller.mergedSwitcherContentCaches[ObjectIdentifier(menu)]
+        #expect(remaining?[.provider(.codex)] == nil)
+        #expect(remaining?[.overview] != nil)
+    }
+
+    @Test
+    func `type compatible leftover is adopted across card identifiers`() {
+        StatusItemController.setMenuRefreshEnabledForTesting(false)
+        let previousRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = true
+        defer { StatusItemController.menuCardRenderingEnabled = previousRendering }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        let controller = self.makeRecyclingController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = NSMenu()
+        let original = controller.makeMenuCardItem(Text("codex usage"), id: "menuCard-0", width: 300)
+        menu.addItem(original)
+        let originalView = original.view
+
+        controller.harvestRecyclableMenuCardViews(in: menu, fromIndex: 0, displacedSelection: nil)
+        defer { controller.clearMenuCardViewRecyclePool() }
+        let switched = controller.makeMenuCardItem(Text("claude usage"), id: "menuCard", width: 300)
+
+        #expect(switched.view === originalView)
+        #expect(controller.menuCardViewRecyclePool.isEmpty)
+    }
+
+    @Test
+    func `recycled card keeps its hosting view and highlight state`() {
+        StatusItemController.setMenuRefreshEnabledForTesting(false)
+        let previousRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = true
+        defer { StatusItemController.menuCardRenderingEnabled = previousRendering }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        let controller = self.makeRecyclingController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = NSMenu()
+        let original = controller.makeMenuCardItem(Text("before"), id: "menuCard", width: 300)
+        menu.addItem(original)
+        guard let originalView = original.view as? MenuCardItemHostingView<MenuCardSectionContainerView<Text>>
+        else {
+            Issue.record("expected a card hosting view")
+            return
+        }
+
+        controller.harvestRecyclableMenuCardViews(in: menu, fromIndex: 0, displacedSelection: nil)
+        defer { controller.clearMenuCardViewRecyclePool() }
+        let rebuilt = controller.makeMenuCardItem(Text("after"), id: "menuCard", width: 300)
+
+        #expect(rebuilt.view === originalView)
+        guard let rebuiltView = rebuilt.view as? MenuCardItemHostingView<MenuCardSectionContainerView<Text>>
+        else {
+            Issue.record("expected the recycled hosting view")
+            return
+        }
+        #expect(rebuiltView.highlightState === originalView.highlightState)
+        rebuiltView.setHighlighted(true)
+        #expect(rebuiltView.highlightState.isHighlighted)
+        rebuiltView.setHighlighted(false)
+    }
+
+    @Test
+    func `recycled card clears button role when click action is removed`() {
+        let highlightState = MenuCardHighlightState()
+        let hosting = MenuCardItemHostingView(
+            rootView: Text("clickable"),
+            highlightState: highlightState,
+            allowsMenuHighlight: true,
+            onClick: {})
+
+        #expect(hosting.accessibilityRole() == .button)
+
+        hosting.prepareForReuse(
+            rootView: Text("informational"),
+            allowsMenuHighlight: false,
+            onClick: nil)
+
+        #expect(hosting.accessibilityRole() == .group)
+    }
+
+    @Test
+    func `harvesting a highlighted card clears its highlight and tracking entry`() {
+        StatusItemController.setMenuRefreshEnabledForTesting(false)
+        let previousRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = true
+        defer { StatusItemController.menuCardRenderingEnabled = previousRendering }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        let controller = self.makeRecyclingController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = NSMenu()
+        let item = controller.makeMenuCardItem(Text("card"), id: "menuCard", width: 300, onClick: {})
+        menu.addItem(item)
+        controller.menu(menu, willHighlight: item)
+        guard let hosting = item.view as? MenuCardItemHostingView<MenuCardSectionContainerView<Text>>
+        else {
+            Issue.record("expected a card hosting view")
+            return
+        }
+        #expect(hosting.highlightState.isHighlighted)
+        #expect(controller.highlightedMenuItems[ObjectIdentifier(menu)] === item)
+
+        controller.harvestRecyclableMenuCardViews(in: menu, fromIndex: 0, displacedSelection: nil)
+        defer { controller.clearMenuCardViewRecyclePool() }
+
+        #expect(!hosting.highlightState.isHighlighted)
+        #expect(controller.highlightedMenuItems[ObjectIdentifier(menu)] == nil)
+
+        let rebuilt = controller.makeMenuCardItem(Text("rebuilt"), id: "menuCard", width: 300, onClick: {})
+        #expect(rebuilt.view === hosting)
+        #expect(!hosting.highlightState.isHighlighted)
+    }
+
+    @Test
+    func `same id with different content type builds a fresh view`() {
+        StatusItemController.setMenuRefreshEnabledForTesting(false)
+        let previousRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = true
+        defer { StatusItemController.menuCardRenderingEnabled = previousRendering }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        let controller = self.makeRecyclingController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = NSMenu()
+        let original = controller.makeMenuCardItem(Text("text card"), id: "menuCard", width: 300)
+        menu.addItem(original)
+        let originalView = original.view
+
+        controller.harvestRecyclableMenuCardViews(in: menu, fromIndex: 0, displacedSelection: nil)
+        defer { controller.clearMenuCardViewRecyclePool() }
+        let rebuilt = controller.makeMenuCardItem(Image(systemName: "clock"), id: "menuCard", width: 300)
+
+        #expect(rebuilt.view != nil)
+        #expect(rebuilt.view !== originalView)
+        // The incompatible pool entry is consumed rather than left behind.
+        #expect(controller.menuCardViewRecyclePool.isEmpty)
+    }
+}
diff --git a/Tests/CodexBarTests/MenuCardWorkdayPaceTests.swift b/Tests/CodexBarTests/MenuCardWorkdayPaceTests.swift
new file mode 100644
index 0000000000..b712a0ccb5
--- /dev/null
+++ b/Tests/CodexBarTests/MenuCardWorkdayPaceTests.swift
@@ -0,0 +1,79 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct MenuCardWorkdayPaceTests {
+    @Test
+    func `codex weekly lane shows exhausted pace before first configured workday`() throws {
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = .current
+        let now = try #require(calendar.date(from: DateComponents(
+            calendar: calendar,
+            timeZone: calendar.timeZone,
+            year: 2026,
+            month: 6,
+            day: 7,
+            hour: 12)))
+        let resetsAt = try #require(calendar.date(from: DateComponents(
+            calendar: calendar,
+            timeZone: calendar.timeZone,
+            year: 2026,
+            month: 6,
+            day: 14)))
+        let metadata = try #require(ProviderDefaults.metadata[.codex])
+        let identity = ProviderIdentitySnapshot(
+            providerID: .codex,
+            accountEmail: "user@example.com",
+            accountOrganization: nil,
+            loginMethod: "Pro")
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: RateWindow(
+                usedPercent: 100,
+                windowMinutes: 10080,
+                resetsAt: resetsAt,
+                resetDescription: nil),
+            tertiary: nil,
+            updatedAt: now,
+            identity: identity)
+        let projection = CodexConsumerProjection.make(
+            surface: .liveCard,
+            context: CodexConsumerProjection.Context(
+                snapshot: snapshot,
+                rawUsageError: nil,
+                liveCredits: nil,
+                rawCreditsError: nil,
+                liveDashboard: nil,
+                rawDashboardError: nil,
+                dashboardAttachmentAuthorized: false,
+                dashboardRequiresLogin: false,
+                now: now))
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .codex,
+            metadata: metadata,
+            snapshot: snapshot,
+            codexProjection: projection,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: "user@example.com", plan: "Pro"),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            workDaysPerWeek: 5,
+            now: now))
+
+        let weekly = try #require(model.metrics.first { $0.id == "secondary" })
+        #expect(weekly.detailLeftText == "100% in deficit")
+        #expect(weekly.detailRightText == "Runs out now")
+    }
+}
diff --git a/Tests/CodexBarTests/MenuDescriptorAntigravityTests.swift b/Tests/CodexBarTests/MenuDescriptorAntigravityTests.swift
new file mode 100644
index 0000000000..392c114d36
--- /dev/null
+++ b/Tests/CodexBarTests/MenuDescriptorAntigravityTests.swift
@@ -0,0 +1,107 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@MainActor
+struct MenuDescriptorAntigravityTests {
+    @Test
+    func `antigravity identity only snapshot shows limits unavailable`() throws {
+        let suite = "MenuDescriptorAntigravityTests-unavailable"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.statusChecksEnabled = false
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings)
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .antigravity,
+                accountEmail: "user@example.com",
+                accountOrganization: nil,
+                loginMethod: "Paid"))
+        store._setSnapshotForTesting(snapshot, provider: .antigravity)
+
+        let descriptor = MenuDescriptor.build(
+            provider: .antigravity,
+            store: store,
+            settings: settings,
+            account: AccountInfo(email: nil, plan: nil),
+            updateReady: false,
+            includeContextualActions: false)
+
+        let lines = descriptor.sections
+            .flatMap(\.entries)
+            .compactMap { entry -> String? in
+                guard case let .text(text, _) = entry else { return nil }
+                return text
+            }
+
+        #expect(lines.contains("Limits not available"))
+    }
+
+    @Test
+    func `antigravity menu does not add unavailable notes for missing families`() throws {
+        let suite = "MenuDescriptorAntigravityTests-missing-gemini"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.statusChecksEnabled = false
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings)
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 10,
+                windowMinutes: nil,
+                resetsAt: Date().addingTimeInterval(3600),
+                resetDescription: nil),
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .antigravity,
+                accountEmail: nil,
+                accountOrganization: nil,
+                loginMethod: "Pro"))
+        store._setSnapshotForTesting(snapshot, provider: .antigravity)
+
+        let descriptor = MenuDescriptor.build(
+            provider: .antigravity,
+            store: store,
+            settings: settings,
+            account: AccountInfo(email: nil, plan: nil),
+            updateReady: false,
+            includeContextualActions: false)
+
+        let lines = descriptor.sections
+            .flatMap(
+                \.entries)
+            .compactMap { entry -> String? in
+                guard case let .text(text, _) = entry else { return nil }
+                return text
+            }
+
+        #expect(!lines.contains("Gemini Pro unavailable."))
+        #expect(!lines.contains("Gemini Flash unavailable."))
+        #expect(!lines.contains("Limits not available"))
+    }
+}
diff --git a/Tests/CodexBarTests/MenuDescriptorCodexManagedFallbackTests.swift b/Tests/CodexBarTests/MenuDescriptorCodexManagedFallbackTests.swift
new file mode 100644
index 0000000000..218bb0abcd
--- /dev/null
+++ b/Tests/CodexBarTests/MenuDescriptorCodexManagedFallbackTests.swift
@@ -0,0 +1,181 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@MainActor
+struct MenuDescriptorCodexManagedFallbackTests {
+    @Test
+    func `codex account section prefers managed fallback over ambient account`() throws {
+        let suite = "MenuDescriptorCodexManagedFallbackTests"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore(),
+            codexCookieStore: InMemoryCookieHeaderStore(),
+            claudeCookieStore: InMemoryCookieHeaderStore(),
+            cursorCookieStore: InMemoryCookieHeaderStore(),
+            opencodeCookieStore: InMemoryCookieHeaderStore(),
+            factoryCookieStore: InMemoryCookieHeaderStore(),
+            minimaxCookieStore: InMemoryMiniMaxCookieStore(),
+            minimaxAPITokenStore: InMemoryMiniMaxAPITokenStore(),
+            kimiTokenStore: InMemoryKimiTokenStore(),
+            kimiK2TokenStore: InMemoryKimiK2TokenStore(),
+            augmentCookieStore: InMemoryCookieHeaderStore(),
+            ampCookieStore: InMemoryCookieHeaderStore(),
+            copilotTokenStore: InMemoryCopilotTokenStore(),
+            tokenAccountStore: InMemoryTokenAccountStore())
+        settings.statusChecksEnabled = false
+
+        let ambientHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        let managedHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        defer {
+            try? FileManager.default.removeItem(at: ambientHome)
+            try? FileManager.default.removeItem(at: managedHome)
+        }
+
+        try Self.writeCodexAuthFile(homeURL: ambientHome, email: "ambient@example.com", plan: "plus")
+        try Self.writeCodexAuthFile(homeURL: managedHome, email: "managed@example.com", plan: "enterprise")
+        settings.codexActiveSource = .managedAccount(id: UUID())
+        settings._test_activeManagedCodexRemoteHomePath = managedHome.path
+
+        let fetcher = UsageFetcher(environment: ["CODEX_HOME": ambientHome.path])
+        let store = UsageStore(
+            fetcher: fetcher,
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(usedPercent: 10, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+                secondary: RateWindow(usedPercent: 20, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+                updatedAt: Date(),
+                identity: nil),
+            provider: .codex)
+
+        let descriptor = MenuDescriptor.build(
+            provider: .codex,
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updateReady: false,
+            includeContextualActions: false)
+
+        let lines = descriptor.sections
+            .flatMap(\.entries)
+            .compactMap { entry -> String? in
+                guard case let .text(text, _) = entry else { return nil }
+                return text
+            }
+
+        #expect(lines.contains("Account: managed@example.com"))
+        #expect(lines.contains("Plan: Enterprise"))
+        #expect(!lines.contains("Account: ambient@example.com"))
+        #expect(!lines.contains("Plan: Plus"))
+    }
+
+    @Test
+    func `codex weekly only window renders without session row`() throws {
+        let suite = "MenuDescriptorCodexManagedFallbackTests-weekly-only"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore(),
+            codexCookieStore: InMemoryCookieHeaderStore(),
+            claudeCookieStore: InMemoryCookieHeaderStore(),
+            cursorCookieStore: InMemoryCookieHeaderStore(),
+            opencodeCookieStore: InMemoryCookieHeaderStore(),
+            factoryCookieStore: InMemoryCookieHeaderStore(),
+            minimaxCookieStore: InMemoryMiniMaxCookieStore(),
+            minimaxAPITokenStore: InMemoryMiniMaxAPITokenStore(),
+            kimiTokenStore: InMemoryKimiTokenStore(),
+            kimiK2TokenStore: InMemoryKimiK2TokenStore(),
+            augmentCookieStore: InMemoryCookieHeaderStore(),
+            ampCookieStore: InMemoryCookieHeaderStore(),
+            copilotTokenStore: InMemoryCopilotTokenStore(),
+            tokenAccountStore: InMemoryTokenAccountStore())
+        settings.statusChecksEnabled = false
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(
+            fetcher: fetcher,
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: nil,
+                secondary: RateWindow(
+                    usedPercent: 20,
+                    windowMinutes: 10080,
+                    resetsAt: nil,
+                    resetDescription: "Apr 6, 2026"),
+                updatedAt: Date(),
+                identity: ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: "ratulanimation@gmail.com",
+                    accountOrganization: nil,
+                    loginMethod: "free")),
+            provider: .codex)
+
+        let descriptor = MenuDescriptor.build(
+            provider: .codex,
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updateReady: false,
+            includeContextualActions: false)
+
+        let lines = descriptor.sections
+            .flatMap(\.entries)
+            .compactMap { entry -> String? in
+                guard case let .text(text, _) = entry else { return nil }
+                return text
+            }
+
+        #expect(!lines.contains(where: { $0.hasPrefix("Session:") }))
+        #expect(lines.contains(where: { $0.hasPrefix("Weekly:") }))
+    }
+
+    private static func writeCodexAuthFile(homeURL: URL, email: String, plan: String) throws {
+        try FileManager.default.createDirectory(at: homeURL, withIntermediateDirectories: true)
+        let auth = [
+            "tokens": [
+                "accessToken": "access-token",
+                "refreshToken": "refresh-token",
+                "idToken": Self.fakeJWT(email: email, plan: plan),
+            ],
+        ]
+        let data = try JSONSerialization.data(withJSONObject: auth)
+        try data.write(to: homeURL.appendingPathComponent("auth.json"))
+    }
+
+    private static func fakeJWT(email: String, plan: String) -> String {
+        let header = (try? JSONSerialization.data(withJSONObject: ["alg": "none"])) ?? Data()
+        let payload = (try? JSONSerialization.data(withJSONObject: [
+            "email": email,
+            "chatgpt_plan_type": plan,
+        ])) ?? Data()
+
+        func base64URL(_ data: Data) -> String {
+            data.base64EncodedString()
+                .replacingOccurrences(of: "=", with: "")
+                .replacingOccurrences(of: "+", with: "-")
+                .replacingOccurrences(of: "/", with: "_")
+        }
+
+        return "\(base64URL(header)).\(base64URL(payload))."
+    }
+}
diff --git a/Tests/CodexBarTests/MenuDescriptorKiloTests.swift b/Tests/CodexBarTests/MenuDescriptorKiloTests.swift
index adf6f41d1e..a3dba9cb34 100644
--- a/Tests/CodexBarTests/MenuDescriptorKiloTests.swift
+++ b/Tests/CodexBarTests/MenuDescriptorKiloTests.swift
@@ -4,10 +4,9 @@ import Testing
 @testable import CodexBar
 
 @MainActor
-@Suite
 struct MenuDescriptorKiloTests {
     @Test
-    func kiloCreditsDetailDoesNotRenderAsResetLine() throws {
+    func `kilo credits detail does not render as reset line`() throws {
         let suite = "MenuDescriptorKiloTests-kilo-detail"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -59,7 +58,7 @@ struct MenuDescriptorKiloTests {
     }
 
     @Test
-    func kiloPassDetailKeepsResetLineWhenResetDateExists() throws {
+    func `kilo pass detail keeps reset line when reset date exists`() throws {
         let suite = "MenuDescriptorKiloTests-kilo-pass-reset"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -115,7 +114,7 @@ struct MenuDescriptorKiloTests {
     }
 
     @Test
-    func kiloAutoTopUpOnlyRendersActivityWithoutPlanLabel() throws {
+    func `kilo auto top up only renders activity without plan label`() throws {
         let suite = "MenuDescriptorKiloTests-kilo-activity-only"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
diff --git a/Tests/CodexBarTests/MenuDescriptorOpenAIAPITests.swift b/Tests/CodexBarTests/MenuDescriptorOpenAIAPITests.swift
new file mode 100644
index 0000000000..d45b96429e
--- /dev/null
+++ b/Tests/CodexBarTests/MenuDescriptorOpenAIAPITests.swift
@@ -0,0 +1,92 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@MainActor
+struct MenuDescriptorOpenAIAPITests {
+    @Test
+    func `openai api admin usage appears in descriptor summaries`() throws {
+        let suite = "MenuDescriptorOpenAIAPITests-admin-summary"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.statusChecksEnabled = false
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings)
+        let now = Date(timeIntervalSince1970: 1_700_179_200)
+        let usage = OpenAIAPIUsageSnapshot(
+            daily: [
+                OpenAIAPIUsageSnapshot.DailyBucket(
+                    day: "2023-11-13",
+                    startTime: now.addingTimeInterval(-86400),
+                    endTime: now,
+                    costUSD: 5,
+                    requests: 8,
+                    inputTokens: 100,
+                    cachedInputTokens: 0,
+                    outputTokens: 50,
+                    totalTokens: 150,
+                    lineItems: [],
+                    models: [
+                        OpenAIAPIUsageSnapshot.ModelBreakdown(
+                            name: "gpt-5.2",
+                            requests: 8,
+                            inputTokens: 100,
+                            cachedInputTokens: 0,
+                            outputTokens: 50,
+                            totalTokens: 150),
+                    ]),
+                OpenAIAPIUsageSnapshot.DailyBucket(
+                    day: "2023-11-14",
+                    startTime: now,
+                    endTime: now.addingTimeInterval(86400),
+                    costUSD: 12.5,
+                    requests: 40,
+                    inputTokens: 1000,
+                    cachedInputTokens: 250,
+                    outputTokens: 500,
+                    totalTokens: 1500,
+                    lineItems: [],
+                    models: [
+                        OpenAIAPIUsageSnapshot.ModelBreakdown(
+                            name: "gpt-5.2-codex",
+                            requests: 40,
+                            inputTokens: 1000,
+                            cachedInputTokens: 250,
+                            outputTokens: 500,
+                            totalTokens: 1500),
+                    ]),
+            ],
+            updatedAt: now)
+        store._setSnapshotForTesting(usage.toUsageSnapshot(), provider: .openai)
+
+        let descriptor = MenuDescriptor.build(
+            provider: .openai,
+            store: store,
+            settings: settings,
+            account: AccountInfo(email: nil, plan: nil),
+            updateReady: false,
+            includeContextualActions: false)
+        let lines = descriptor.sections
+            .flatMap(\.entries)
+            .compactMap { entry -> String? in
+                guard case let .text(text, _) = entry else { return nil }
+                return text
+            }
+
+        #expect(lines.contains("Today: $12.50 · 1.5K tokens"))
+        #expect(lines.contains("7d: $17.50 · 48 requests"))
+        #expect(lines.contains("30d: $17.50 · 48 requests"))
+        #expect(lines.contains("Top model: gpt-5.2-codex"))
+        #expect(!lines.contains("No usage yet"))
+    }
+}
diff --git a/Tests/CodexBarTests/MenuDescriptorPoeTests.swift b/Tests/CodexBarTests/MenuDescriptorPoeTests.swift
new file mode 100644
index 0000000000..1f5dc5b212
--- /dev/null
+++ b/Tests/CodexBarTests/MenuDescriptorPoeTests.swift
@@ -0,0 +1,135 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@MainActor
+struct MenuDescriptorPoeTests {
+    @Test
+    func `poe balance renders as balance text not plan label`() throws {
+        let suite = "MenuDescriptorPoeTests-balance"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.statusChecksEnabled = false
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings)
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            tertiary: nil,
+            providerCost: nil,
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .poe,
+                accountEmail: nil,
+                accountOrganization: nil,
+                loginMethod: "Balance: 1,500 points"))
+        store._setSnapshotForTesting(snapshot, provider: .poe)
+
+        let descriptor = MenuDescriptor.build(
+            provider: .poe,
+            store: store,
+            settings: settings,
+            account: AccountInfo(email: nil, plan: nil),
+            updateReady: false,
+            includeContextualActions: false)
+
+        let textLines = descriptor.sections
+            .flatMap(\.entries)
+            .compactMap { entry -> String? in
+                guard case let .text(text, _) = entry else { return nil }
+                return text
+            }
+
+        #expect(textLines.contains(where: { $0.contains("Balance: 1,500 points") }))
+        #expect(!textLines.contains(where: { $0.contains("Plan: Balance:") }))
+    }
+
+    @Test
+    func `poe usage history renders today week month and top breakdown`() throws {
+        let suite = "MenuDescriptorPoeTests-history"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.statusChecksEnabled = false
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings)
+
+        let now = Date(timeIntervalSince1970: 1_717_171_717)
+        let history = PoeUsageHistorySnapshot(
+            entries: [
+                .init(
+                    id: "a",
+                    createdAt: now.addingTimeInterval(-1000),
+                    model: "GPT-4o",
+                    usageType: "chat",
+                    points: 100,
+                    costUSD: nil),
+                .init(
+                    id: "b",
+                    createdAt: now.addingTimeInterval(-86000),
+                    model: "Claude-3.7-Sonnet",
+                    usageType: "chat",
+                    points: 200,
+                    costUSD: nil),
+            ],
+            daily: [
+                .init(day: "2026-05-30", points: 200, requests: 1, costUSD: nil),
+                .init(day: "2026-05-31", points: 100, requests: 1, costUSD: nil),
+            ],
+            updatedAt: now)
+
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            tertiary: nil,
+            providerCost: nil,
+            poeUsage: history,
+            updatedAt: now,
+            identity: ProviderIdentitySnapshot(
+                providerID: .poe,
+                accountEmail: nil,
+                accountOrganization: nil,
+                loginMethod: "Balance: 300 points"))
+        store._setSnapshotForTesting(snapshot, provider: .poe)
+
+        let descriptor = MenuDescriptor.build(
+            provider: .poe,
+            store: store,
+            settings: settings,
+            account: AccountInfo(email: nil, plan: nil),
+            updateReady: false,
+            includeContextualActions: false)
+
+        let textLines = descriptor.sections
+            .flatMap(\.entries)
+            .compactMap { entry -> String? in
+                guard case let .text(text, _) = entry else { return nil }
+                return text
+            }
+
+        #expect(textLines.contains(where: { $0.contains("Today: 100 points") }))
+        #expect(textLines.contains(where: { $0.contains("7d: 300 points") }))
+        #expect(textLines.contains(where: { $0.contains("30d: 300 points") }))
+        #expect(textLines.contains(where: { $0.contains("Top model: Claude-3.7-Sonnet") }))
+        #expect(textLines.contains(where: { $0.contains("Usage mix: chat: 300 points") }))
+        #expect(textLines.contains(where: { $0.contains("Recent activity:") }))
+    }
+}
diff --git a/Tests/CodexBarTests/MenuSessionCoordinatorTests.swift b/Tests/CodexBarTests/MenuSessionCoordinatorTests.swift
new file mode 100644
index 0000000000..551e017fbd
--- /dev/null
+++ b/Tests/CodexBarTests/MenuSessionCoordinatorTests.swift
@@ -0,0 +1,114 @@
+import Testing
+@testable import CodexBar
+
+struct MenuSessionCoordinatorTests {
+    @Test
+    func `invalidation records data structural and required generations independently`() {
+        var coordinator = MenuSessionCoordinator<String>()
+
+        coordinator.invalidate(allowsStaleContent: false, requiresRebuild: true)
+        #expect(coordinator.contentVersion == 1)
+        #expect(coordinator.latestStructuralContentVersion == 1)
+        #expect(coordinator.latestRequiredRebuildVersion == 1)
+        #expect(coordinator.latestDataOnlyContentVersion == 0)
+
+        coordinator.invalidate(allowsStaleContent: true, requiresRebuild: false)
+        #expect(coordinator.contentVersion == 2)
+        #expect(coordinator.latestDataOnlyContentVersion == 2)
+        #expect(coordinator.latestStructuralContentVersion == 1)
+        #expect(coordinator.latestRequiredRebuildVersion == 1)
+
+        coordinator.invalidate(allowsStaleContent: false, requiresRebuild: false)
+        #expect(coordinator.contentVersion == 3)
+        #expect(coordinator.latestStructuralContentVersion == 3)
+        #expect(coordinator.latestRequiredRebuildVersion == 1)
+    }
+
+    @Test
+    func `closed preparation distinguishes no work deferred work and required work`() {
+        var coordinator = MenuSessionCoordinator<String>()
+        let menu = "menu"
+
+        #expect(coordinator.closedPreparationPlan(for: [menu]) == .nonDeferred)
+
+        coordinator.invalidate(allowsStaleContent: true, requiresRebuild: false)
+        #expect(coordinator.closedPreparationPlan(for: [menu]) == .none)
+
+        coordinator.invalidate(allowsStaleContent: false, requiresRebuild: true)
+        #expect(coordinator.closedPreparationPlan(for: [menu]) == .required(version: 2))
+
+        coordinator.markFresh(menu)
+        #expect(coordinator.closedPreparationPlan(for: [menu]) == .nonDeferred)
+    }
+
+    @Test
+    func `stale content survives only a data generation after latest structural render`() {
+        var coordinator = MenuSessionCoordinator<String>()
+        let menu = "menu"
+
+        coordinator.invalidate(allowsStaleContent: false, requiresRebuild: true)
+        coordinator.markFresh(menu)
+        coordinator.invalidate(allowsStaleContent: true, requiresRebuild: false)
+        #expect(coordinator.canPreserveStaleContent(for: menu))
+
+        coordinator.invalidate(allowsStaleContent: false, requiresRebuild: false)
+        coordinator.invalidate(allowsStaleContent: true, requiresRebuild: false)
+        #expect(!coordinator.canPreserveStaleContent(for: menu))
+    }
+
+    @Test
+    func `removing menu clears all menu scoped lifecycle state`() {
+        var coordinator = MenuSessionCoordinator<String>()
+        let menu = "menu"
+
+        coordinator.markFresh(menu)
+        coordinator.deferUntilNextOpen(menu)
+        coordinator.deferParentRebuild(menu)
+        coordinator.removeMenu(menu)
+
+        #expect(coordinator.renderedVersion(for: menu) == nil)
+        #expect(!coordinator.isDeferredUntilNextOpen(menu))
+        #expect(!coordinator.isParentRebuildDeferred(menu))
+    }
+}
+
+struct MenuRebuildRequestRegistryTests {
+    @Test
+    func `replacement request invalidates prior token without affecting other menus`() {
+        var registry = MenuRebuildRequestRegistry<String>()
+
+        let first = registry.replaceRequest(for: "parent")
+        let child = registry.replaceRequest(for: "child")
+        let replacement = registry.replaceRequest(for: "parent")
+
+        #expect(!registry.isCurrent(first, for: "parent"))
+        #expect(registry.isCurrent(replacement, for: "parent"))
+        #expect(registry.isCurrent(child, for: "child"))
+    }
+
+    @Test
+    func `stale completion cannot clear replacement request`() {
+        var registry = MenuRebuildRequestRegistry<String>()
+        let stale = registry.replaceRequest(for: "menu")
+        let current = registry.replaceRequest(for: "menu")
+
+        let staleDidFinish = registry.finish(stale, for: "menu")
+        #expect(!staleDidFinish)
+        #expect(registry.isCurrent(current, for: "menu"))
+        let currentDidFinish = registry.finish(current, for: "menu")
+        #expect(currentDidFinish)
+        #expect(!registry.isCurrent(current, for: "menu"))
+    }
+
+    @Test
+    func `cancelling all requests keeps future tokens distinct`() {
+        var registry = MenuRebuildRequestRegistry<String>()
+        let cancelled = registry.replaceRequest(for: "menu")
+
+        registry.cancelAll()
+        let replacement = registry.replaceRequest(for: "menu")
+
+        #expect(cancelled != replacement)
+        #expect(registry.isCurrent(replacement, for: "menu"))
+    }
+}
diff --git a/Tests/CodexBarTests/MiMoLocalUsageFallbackTests.swift b/Tests/CodexBarTests/MiMoLocalUsageFallbackTests.swift
new file mode 100644
index 0000000000..6811b3d05f
--- /dev/null
+++ b/Tests/CodexBarTests/MiMoLocalUsageFallbackTests.swift
@@ -0,0 +1,122 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct MiMoLocalUsageFallbackTests {
+    @Test
+    func `returns nil when cache file is missing`() {
+        let snap = MiMoLocalUsageFallback.snapshot(
+            cachePath: "/nonexistent/path/that/should/never/exist.json",
+            now: Date())
+        #expect(snap == nil)
+    }
+
+    @Test
+    func `returns nil when cache file is malformed JSON`() throws {
+        let dir = FileManager.default.temporaryDirectory
+            .appendingPathComponent("mimo-fallback-test-\(UUID().uuidString)")
+        try FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: dir) }
+        let file = dir.appendingPathComponent("malformed.json")
+        try "{not json".write(to: file, atomically: true, encoding: .utf8)
+
+        let snap = MiMoLocalUsageFallback.snapshot(cachePath: file.path, now: Date())
+        #expect(snap == nil)
+    }
+
+    @Test
+    func `returns nil when cache schema is incomplete`() throws {
+        let dir = FileManager.default.temporaryDirectory
+            .appendingPathComponent("mimo-fallback-test-\(UUID().uuidString)")
+        try FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: dir) }
+        let file = dir.appendingPathComponent("incomplete.json")
+        try Data("{}".utf8).write(to: file)
+
+        let snap = MiMoLocalUsageFallback.snapshot(cachePath: file.path, now: Date())
+        #expect(snap == nil)
+    }
+
+    @Test
+    func `parses all token buckets without fabricating a quota window`() throws {
+        let dir = FileManager.default.temporaryDirectory
+            .appendingPathComponent("mimo-fallback-test-\(UUID().uuidString)")
+        try FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: dir) }
+        let file = dir.appendingPathComponent("usage.json")
+        let updatedAt = "2026-06-03T05:04:03.123456+00:00"
+        let payload: [String: Any] = [
+            "updated_at": updatedAt,
+            "sessions_scanned": 1296,
+            "windows": [
+                "today": ["input": 1500, "output": 500, "cache_read": 0, "cache_create": 250, "messages": 3],
+                "week": [
+                    "input": 30000,
+                    "output": 10000,
+                    "cache_read": 60000,
+                    "cache_create": 10000,
+                    "messages": 25,
+                ],
+                "all_time": [
+                    "input": 3_600_000,
+                    "output": 1_100_000,
+                    "cache_read": 16_100_000,
+                    "cache_create": 2_000_000,
+                    "messages": 1315,
+                ],
+            ],
+        ]
+        try JSONSerialization.data(withJSONObject: payload).write(to: file)
+
+        let snap = try #require(MiMoLocalUsageFallback.snapshot(cachePath: file.path, now: Date()))
+
+        // planCode packs today/week/total/sessions in one row.
+        let plan = try #require(snap.planCode)
+        #expect(plan.contains("today"))
+        #expect(plan.contains("week"))
+        #expect(plan.contains("total"))
+        #expect(plan.contains("1296 sessions"))
+        #expect(plan.contains("110.0k week"))
+        #expect(plan.contains("22.8M total"))
+        #expect(snap.tokenUsed == 0)
+        #expect(snap.tokenLimit == 0)
+        #expect(snap.tokenPercent == 0)
+        let usage = snap.toUsageSnapshot(includeBalance: false)
+        #expect(usage.primary == nil)
+        #expect(usage.mimoUsage == nil)
+
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        #expect(snap.updatedAt == formatter.date(from: updatedAt))
+    }
+
+    @Test
+    func `idle week keeps local accounting in the plan summary`() throws {
+        let dir = FileManager.default.temporaryDirectory
+            .appendingPathComponent("mimo-fallback-test-\(UUID().uuidString)")
+        try FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: dir) }
+        let file = dir.appendingPathComponent("idle.json")
+        let payload: [String: Any] = [
+            "sessions_scanned": 100,
+            "windows": [
+                "today": ["input": 0, "output": 0, "cache_read": 0],
+                "week": ["input": 0, "output": 0, "cache_read": 0],
+                "all_time": ["input": 500_000, "output": 250_000, "cache_read": 1_250_000],
+            ],
+        ]
+        try JSONSerialization.data(withJSONObject: payload).write(to: file)
+
+        let snap = try #require(MiMoLocalUsageFallback.snapshot(cachePath: file.path, now: Date()))
+        #expect(snap.tokenUsed == 0)
+        #expect(snap.tokenLimit == 0)
+        #expect(snap.tokenPercent == 0)
+        #expect(snap.toUsageSnapshot(includeBalance: false).mimoUsage == nil)
+        let plan = try #require(snap.planCode)
+        #expect(plan.hasPrefix("Local"))
+        #expect(!plan.contains("today"))
+        #expect(!plan.contains("week"))
+        #expect(plan.contains("total"))
+        #expect(plan.contains("100 sessions"))
+    }
+}
diff --git a/Tests/CodexBarTests/MiMoProviderTests.swift b/Tests/CodexBarTests/MiMoProviderTests.swift
new file mode 100644
index 0000000000..4d23d3da13
--- /dev/null
+++ b/Tests/CodexBarTests/MiMoProviderTests.swift
@@ -0,0 +1,1213 @@
+import Foundation
+import SwiftUI
+import Testing
+@testable import CodexBar
+@testable import CodexBarCore
+#if os(macOS)
+import SweetCookieKit
+#endif
+
+@Suite(.serialized)
+struct MiMoProviderTests {
+    private struct StubClaudeFetcher: ClaudeUsageFetching {
+        func loadLatestUsage(model _: String) async throws -> ClaudeUsageSnapshot {
+            throw ClaudeUsageError.parseFailed("stub")
+        }
+
+        func debugRawProbe(model _: String) async -> String {
+            "stub"
+        }
+
+        func detectVersion() -> String? {
+            nil
+        }
+    }
+
+    @Test
+    func `cookie header normalizer keeps required mimo cookies`() {
+        let raw = """
+        curl 'https://platform.xiaomimimo.com/api/v1/balance' \
+          -H 'Cookie: userId=123; api-platform_serviceToken=svc-token; ignored=value; api-platform_ph=ph-token'
+        """
+
+        let normalized = MiMoCookieHeader.normalizedHeader(from: raw)
+
+        #expect(normalized == "api-platform_ph=ph-token; api-platform_serviceToken=svc-token; userId=123")
+    }
+
+    @Test
+    func `cookie header normalizer rejects missing auth cookies`() {
+        let normalized = MiMoCookieHeader.normalizedHeader(from: "Cookie: userId=123")
+
+        #expect(normalized == nil)
+    }
+
+    @Test
+    func `cookie header builder keeps mimo auth cookies from one scope`() throws {
+        let cookies = try [
+            self.makeCookie(
+                name: "userId",
+                value: "root-user",
+                domain: "xiaomimimo.com",
+                expiresAt: Date(timeIntervalSince1970: 1_800_000_000)),
+            self.makeCookie(
+                name: "api-platform_serviceToken",
+                value: "platform-token",
+                domain: "platform.xiaomimimo.com",
+                expiresAt: Date(timeIntervalSince1970: 1_900_000_000)),
+            self.makeCookie(
+                name: "userId",
+                value: "platform-user",
+                domain: "platform.xiaomimimo.com",
+                expiresAt: Date(timeIntervalSince1970: 1_900_000_000)),
+            self.makeCookie(
+                name: "api-platform_ph",
+                value: "platform-ph",
+                domain: "platform.xiaomimimo.com",
+                expiresAt: Date(timeIntervalSince1970: 1_900_000_000)),
+        ]
+
+        let header = MiMoCookieHeader.header(from: cookies)
+
+        #expect(header == "api-platform_ph=platform-ph; api-platform_serviceToken=platform-token; userId=platform-user")
+    }
+
+    @Test
+    func `cookie header builder prefers more specific matching cookie`() throws {
+        let cookies = try [
+            self.makeCookie(
+                name: "userId",
+                value: "root-user",
+                domain: "xiaomimimo.com",
+                expiresAt: Date(timeIntervalSince1970: 1_900_000_000)),
+            self.makeCookie(
+                name: "userId",
+                value: "api-user",
+                domain: "platform.xiaomimimo.com",
+                path: "/api",
+                expiresAt: Date(timeIntervalSince1970: 1_800_000_000)),
+            self.makeCookie(
+                name: "api-platform_serviceToken",
+                value: "platform-token",
+                domain: ".xiaomimimo.com",
+                expiresAt: Date(timeIntervalSince1970: 1_900_000_000)),
+            self.makeCookie(
+                name: "irrelevant",
+                value: "ignored",
+                domain: "platform.xiaomimimo.com",
+                expiresAt: Date(timeIntervalSince1970: 1_900_000_000)),
+        ]
+
+        let header = MiMoCookieHeader.header(from: cookies)
+
+        #expect(header == "api-platform_serviceToken=platform-token; userId=api-user")
+    }
+
+    @Test
+    func `cookie header builder rejects partial path prefix matches`() throws {
+        let cookies = try [
+            self.makeCookie(
+                name: "userId",
+                value: "partial-path-user",
+                domain: "platform.xiaomimimo.com",
+                path: "/api/v1/bal",
+                expiresAt: Date(timeIntervalSince1970: 1_900_000_000)),
+            self.makeCookie(
+                name: "userId",
+                value: "valid-user",
+                domain: "platform.xiaomimimo.com",
+                path: "/api",
+                expiresAt: Date(timeIntervalSince1970: 1_800_000_000)),
+            self.makeCookie(
+                name: "api-platform_serviceToken",
+                value: "partial-path-token",
+                domain: "platform.xiaomimimo.com",
+                path: "/api/v1/bal",
+                expiresAt: Date(timeIntervalSince1970: 1_900_000_000)),
+            self.makeCookie(
+                name: "api-platform_serviceToken",
+                value: "valid-token",
+                domain: "platform.xiaomimimo.com",
+                path: "/api",
+                expiresAt: Date(timeIntervalSince1970: 1_800_000_000)),
+        ]
+
+        let header = MiMoCookieHeader.header(from: cookies)
+
+        #expect(header == "api-platform_serviceToken=valid-token; userId=valid-user")
+    }
+
+    @Test
+    func `cookie header builder accepts slash terminated path prefixes`() throws {
+        let cookies = try [
+            self.makeCookie(
+                name: "userId",
+                value: "slash-user",
+                domain: "platform.xiaomimimo.com",
+                path: "/api/",
+                expiresAt: Date(timeIntervalSince1970: 1_900_000_000)),
+            self.makeCookie(
+                name: "api-platform_serviceToken",
+                value: "slash-token",
+                domain: "platform.xiaomimimo.com",
+                path: "/api/",
+                expiresAt: Date(timeIntervalSince1970: 1_900_000_000)),
+        ]
+
+        let header = MiMoCookieHeader.header(from: cookies)
+
+        #expect(header == "api-platform_serviceToken=slash-token; userId=slash-user")
+    }
+
+    @Test
+    func `usage snapshot exposes balance without duplicating identity`() {
+        let snapshot = MiMoUsageSnapshot(
+            balance: 25.51,
+            currency: "USD",
+            updatedAt: Date(timeIntervalSince1970: 1_742_771_200))
+
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.primary == nil)
+        #expect(usage.secondary == nil)
+        #expect(usage.mimoUsage?.balanceDetail == "$25.51")
+        #expect(usage.loginMethod(for: .mimo) == nil)
+    }
+
+    @Test
+    func `usage snapshot exposes paid and granted balance components`() {
+        let snapshot = MiMoUsageSnapshot(
+            balance: 25.51,
+            currency: "USD",
+            cashBalance: 20,
+            giftBalance: 5.51,
+            updatedAt: Date(timeIntervalSince1970: 1_742_771_200))
+
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.primary == nil)
+        #expect(usage.mimoUsage?.balanceDetail == "$25.51 (Paid: $20.00 / Granted: $5.51)")
+        #expect(usage.loginMethod(for: .mimo) == nil)
+    }
+
+    @Test
+    func `usage snapshot shows token plan as primary when available`() {
+        let resetDate = Date(timeIntervalSince1970: 1_778_025_599)
+        let snapshot = MiMoUsageSnapshot(
+            balance: 25.51,
+            currency: "USD",
+            planCode: "standard",
+            planPeriodEnd: resetDate,
+            planExpired: false,
+            tokenUsed: 10_100_158,
+            tokenLimit: 200_000_000,
+            tokenPercent: 0.0505,
+            updatedAt: Date(timeIntervalSince1970: 1_742_771_200))
+
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.primary != nil)
+        #expect(abs((usage.primary?.usedPercent ?? .nan) - 5.05) < 0.0001)
+        #expect(usage.primary?.resetDescription == "10,100,158 / 200,000,000 Credits")
+        #expect(usage.primary?.resetsAt == resetDate)
+        #expect(usage.secondary == nil)
+        #expect(usage.mimoUsage?.balanceDetail == "$25.51")
+        #expect(usage.loginMethod(for: .mimo) == "Standard")
+    }
+
+    @Test
+    func `menu card shows balance as status text with and without token plan`() throws {
+        let now = Date(timeIntervalSince1970: 1_742_771_200)
+        let metadata = try #require(ProviderDefaults.metadata[.mimo])
+        let balanceOnly = MiMoUsageSnapshot(
+            balance: 25.51,
+            currency: "USD",
+            cashBalance: 20,
+            giftBalance: 5.51,
+            updatedAt: now)
+            .toUsageSnapshot()
+        let withPlan = MiMoUsageSnapshot(
+            balance: 25.51,
+            currency: "USD",
+            cashBalance: 20,
+            giftBalance: 5.51,
+            planCode: "standard",
+            tokenUsed: 10,
+            tokenLimit: 100,
+            tokenPercent: 0.1,
+            updatedAt: now)
+            .toUsageSnapshot()
+
+        let balanceModel = Self.makeMenuCardModel(snapshot: balanceOnly, metadata: metadata, now: now)
+        let planModel = Self.makeMenuCardModel(snapshot: withPlan, metadata: metadata, now: now)
+
+        #expect(balanceModel.metrics.first?.title == "Balance")
+        #expect(balanceModel.metrics.first?.statusText == "$25.51 (Paid: $20.00 / Granted: $5.51)")
+        #expect(planModel.metrics.first?.title == "Credits")
+        #expect(planModel.metrics.last?.title == "Balance")
+        #expect(planModel.metrics.last?.statusText == "$25.51 (Paid: $20.00 / Granted: $5.51)")
+    }
+
+    @Test
+    func `usage snapshot falls back to balance when no token plan`() {
+        let snapshot = MiMoUsageSnapshot(
+            balance: 0,
+            currency: "USD",
+            planCode: nil,
+            planPeriodEnd: nil,
+            planExpired: false,
+            tokenUsed: 0,
+            tokenLimit: 0,
+            tokenPercent: 0,
+            updatedAt: Date(timeIntervalSince1970: 1_742_771_200))
+
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.primary == nil)
+        #expect(usage.mimoUsage?.balanceDetail == "$0.00")
+        #expect(usage.loginMethod(for: .mimo) == nil)
+    }
+
+    @Test
+    func `usage snapshot persists mimo balance details`() throws {
+        let usage = MiMoUsageSnapshot(
+            balance: 25.51,
+            currency: "USD",
+            cashBalance: 20,
+            giftBalance: 5.51,
+            updatedAt: Date(timeIntervalSince1970: 1_742_771_200))
+            .toUsageSnapshot()
+
+        let decoded = try JSONDecoder().decode(UsageSnapshot.self, from: JSONEncoder().encode(usage))
+
+        #expect(decoded.primary == nil)
+        #expect(decoded.mimoUsage?.balanceDetail == "$25.51 (Paid: $20.00 / Granted: $5.51)")
+    }
+
+    @Test
+    func `balance does not participate in icon or switcher quota percentages`() {
+        let balanceOnly = MiMoUsageSnapshot(
+            balance: 25.51,
+            currency: "USD",
+            updatedAt: Date())
+            .toUsageSnapshot()
+        let withPlan = MiMoUsageSnapshot(
+            balance: 25.51,
+            currency: "USD",
+            planCode: "standard",
+            tokenUsed: 10,
+            tokenLimit: 100,
+            tokenPercent: 0.1,
+            updatedAt: Date())
+            .toUsageSnapshot()
+
+        let balanceIcon = IconRemainingResolver.resolvedRemaining(snapshot: balanceOnly, style: .mimo)
+        let planIcon = IconRemainingResolver.resolvedRemaining(snapshot: withPlan, style: .mimo)
+
+        #expect(balanceIcon.primary == nil)
+        #expect(balanceIcon.secondary == nil)
+        #expect(StatusItemController.switcherWeeklyMetricPercent(
+            for: .mimo,
+            snapshot: balanceOnly,
+            showUsed: false) == nil)
+        #expect(planIcon.primary == 90)
+        #expect(planIcon.secondary == nil)
+        #expect(StatusItemController.switcherWeeklyMetricPercent(
+            for: .mimo,
+            snapshot: withPlan,
+            showUsed: false) == 90)
+    }
+
+    @Test
+    func `parses balance payload`() throws {
+        let now = Date(timeIntervalSince1970: 1_742_771_200)
+        let json = """
+        {
+          "code": 0,
+          "message": "",
+          "data": {
+            "balance": "25.51",
+            "frozenBalance": null,
+            "currency": "USD",
+            "overdraftLimit": null
+          }
+        }
+        """
+
+        let snapshot = try MiMoUsageFetcher.parseUsageSnapshot(from: Data(json.utf8), now: now)
+
+        #expect(snapshot.balance == 25.51)
+        #expect(snapshot.currency == "USD")
+        #expect(snapshot.cashBalance == nil)
+        #expect(snapshot.giftBalance == nil)
+        #expect(snapshot.updatedAt == now)
+    }
+
+    @Test
+    func `parses paid and granted balance fields when available`() throws {
+        let now = Date(timeIntervalSince1970: 1_742_771_200)
+        let json = """
+        {
+          "code": 0,
+          "message": "",
+          "data": {
+            "balance": "50.00",
+            "frozenBalance": null,
+            "currency": "USD",
+            "overdraftLimit": null,
+            "remainingOverdraftLimit": null,
+            "giftBalance": "20.00",
+            "cashBalance": "30.00"
+          }
+        }
+        """
+
+        let snapshot = try MiMoUsageFetcher.parseUsageSnapshot(from: Data(json.utf8), now: now)
+
+        #expect(snapshot.balance == 50)
+        #expect(snapshot.cashBalance == 30)
+        #expect(snapshot.giftBalance == 20)
+        #expect(snapshot.currency == "USD")
+    }
+
+    @Test
+    func `ignores malformed optional balance components`() throws {
+        let json = """
+        {
+          "code": 0,
+          "message": "",
+          "data": {
+            "balance": "25.51",
+            "currency": "USD",
+            "giftBalance": "",
+            "cashBalance": "unknown"
+          }
+        }
+        """
+
+        let snapshot = try MiMoUsageFetcher.parseUsageSnapshot(from: Data(json.utf8))
+
+        #expect(snapshot.balance == 25.51)
+        #expect(snapshot.cashBalance == nil)
+        #expect(snapshot.giftBalance == nil)
+    }
+
+    @Test
+    func `parses token plan detail payload`() throws {
+        let json = """
+        {
+          "code": 0,
+          "message": "",
+          "data": {
+            "planCode": "standard",
+            "currentPeriodEnd": "2026-05-04 23:59:59",
+            "expired": false
+          }
+        }
+        """
+
+        let detail = try MiMoUsageFetcher.parseTokenPlanDetail(from: Data(json.utf8))
+
+        #expect(detail.planCode == "standard")
+        #expect(detail.expired == false)
+        #expect(detail.periodEnd != nil)
+    }
+
+    @Test
+    func `parses token plan usage payload`() throws {
+        let json = """
+        {
+          "code": 0,
+          "message": "",
+          "data": {
+            "monthUsage": {
+              "percent": 0.0505,
+              "items": [
+                {
+                  "name": "month_total_token",
+                  "used": 10100158,
+                  "limit": 200000000,
+                  "percent": 0.0505
+                }
+              ]
+            }
+          }
+        }
+        """
+
+        let usage = try MiMoUsageFetcher.parseTokenPlanUsage(from: Data(json.utf8))
+
+        #expect(usage.used == 10_100_158)
+        #expect(usage.limit == 200_000_000)
+        #expect(usage.percent == 0.0505)
+    }
+
+    @Test
+    func `combined snapshot merges balance and token plan`() throws {
+        let now = Date(timeIntervalSince1970: 1_742_771_200)
+        let balanceJSON = """
+        {"code":0,"message":"","data":{"balance":"25.51","currency":"USD","cashBalance":"20","giftBalance":"5.51"}}
+        """
+        let detailJSON = """
+        {"code":0,"message":"","data":{"planCode":"standard","currentPeriodEnd":"2026-05-04 23:59:59","expired":false}}
+        """
+        let usageJSON = """
+        {
+          "code": 0,
+          "message": "",
+          "data": {
+            "monthUsage": {
+              "percent": 0.0505,
+              "items": [
+                {
+                  "name": "month_total_token",
+                  "used": 10100158,
+                  "limit": 200000000,
+                  "percent": 0.0505
+                }
+              ]
+            }
+          }
+        }
+        """
+
+        let snapshot = try MiMoUsageFetcher.parseCombinedSnapshot(
+            balanceData: Data(balanceJSON.utf8),
+            tokenDetailData: Data(detailJSON.utf8),
+            tokenUsageData: Data(usageJSON.utf8),
+            now: now)
+
+        #expect(snapshot.balance == 25.51)
+        #expect(snapshot.currency == "USD")
+        #expect(snapshot.cashBalance == 20)
+        #expect(snapshot.giftBalance == 5.51)
+        #expect(snapshot.planCode == "standard")
+        #expect(snapshot.tokenUsed == 10_100_158)
+        #expect(snapshot.tokenLimit == 200_000_000)
+        #expect(snapshot.tokenPercent == 0.0505)
+    }
+
+    @Test
+    func `fetch usage hits mimo balance endpoint with browser headers`() async throws {
+        let registered = URLProtocol.registerClass(MiMoStubURLProtocol.self)
+        defer {
+            if registered {
+                URLProtocol.unregisterClass(MiMoStubURLProtocol.self)
+            }
+            MiMoStubURLProtocol.handler = nil
+        }
+
+        let lock = NSLock()
+        var requestedPaths: [String] = []
+        MiMoStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            lock.withLock {
+                requestedPaths.append(url.path)
+            }
+            #expect(request.value(forHTTPHeaderField: "Cookie") == "api-platform_serviceToken=svc-token; userId=123")
+            #expect(request.value(forHTTPHeaderField: "Accept-Language") == "en-US,en;q=0.9")
+            #expect(request.value(forHTTPHeaderField: "x-timeZone") == "UTC+01:00")
+            #expect(request.value(forHTTPHeaderField: "Referer") == "https://platform.xiaomimimo.com/#/console/balance")
+            let body = """
+            {
+              "code": 0,
+              "message": "",
+              "data": {
+                "balance": "25.51",
+                "currency": "USD"
+              }
+            }
+            """
+            return Self.makeResponse(url: url, body: body)
+        }
+
+        let snapshot = try await MiMoUsageFetcher.fetchUsage(
+            cookieHeader: "Cookie: userId=123; api-platform_serviceToken=svc-token",
+            environment: ["MIMO_API_URL": "https://mimo.test/api/v1"],
+            now: Date(timeIntervalSince1970: 1_742_771_200))
+
+        #expect(snapshot.balance == 25.51)
+        #expect(snapshot.currency == "USD")
+        #expect(requestedPaths.contains("/api/v1/balance"))
+    }
+
+    @Test
+    func `required balance failure cancels optional mimo requests promptly`() async throws {
+        let optionalStarted = MiMoOptionalRequestGate()
+        let transport = ProviderHTTPTransportStub { request in
+            let path = try #require(request.url?.path)
+            if path.hasSuffix("/balance") {
+                await optionalStarted.wait()
+                throw URLError(.userAuthenticationRequired)
+            }
+
+            await optionalStarted.open()
+            try await Task.sleep(for: .seconds(5))
+            let (response, data) = try Self.makeResponse(url: #require(request.url), body: "{}")
+            return (data, response)
+        }
+
+        let startedAt = ContinuousClock.now
+        do {
+            _ = try await MiMoUsageFetcher.fetchUsage(
+                cookieHeader: "userId=123; api-platform_serviceToken=svc-token",
+                environment: ["MIMO_API_URL": "https://mimo.test/api/v1"],
+                session: transport)
+            Issue.record("Expected required balance request to fail")
+        } catch let error as URLError {
+            #expect(error.code == .userAuthenticationRequired)
+        }
+        let elapsed = startedAt.duration(to: .now)
+
+        #expect(elapsed < .seconds(1), "Required failure was delayed by optional requests: \(elapsed)")
+    }
+
+    @Test
+    func `fetch usage treats auth redirect as login required`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            let (response, data) = Self.makeResponse(url: url, body: "", statusCode: 302)
+            return (data, response)
+        }
+
+        do {
+            _ = try await MiMoUsageFetcher.fetchUsage(
+                cookieHeader: "userId=123; api-platform_serviceToken=expired-token",
+                environment: ["MIMO_API_URL": "https://mimo.test/api/v1"],
+                session: transport)
+            Issue.record("Expected MiMo auth redirect to require login")
+        } catch MiMoUsageError.loginRequired {
+            // Expected.
+        }
+    }
+}
+
+private actor MiMoOptionalRequestGate {
+    private var isOpen = false
+    private var continuations: [CheckedContinuation<Void, Never>] = []
+
+    func wait() async {
+        guard !self.isOpen else { return }
+        await withCheckedContinuation { continuation in
+            self.continuations.append(continuation)
+        }
+    }
+
+    func open() {
+        self.isOpen = true
+        let continuations = self.continuations
+        self.continuations.removeAll()
+        for continuation in continuations {
+            continuation.resume()
+        }
+    }
+}
+
+extension MiMoProviderTests {
+    @Test
+    @MainActor
+    func `provider detail plan row formats mimo as balance`() {
+        CodexBarLocalizationOverride.$appLanguage.withValue("en") {
+            let legacyBalance = ProviderDetailView<Text>.planRow(provider: .mimo, planText: "Balance: $25.51")
+            let tokenPlan = ProviderDetailView<Text>.planRow(provider: .mimo, planText: "Standard")
+
+            #expect(legacyBalance?.label == "Balance")
+            #expect(legacyBalance?.value == "$25.51")
+            #expect(tokenPlan?.label == "Plan")
+            #expect(tokenPlan?.value == "Standard")
+        }
+    }
+
+    @Test(arguments: [UsageProvider.openrouter, .mimo])
+    @MainActor
+    func `menu descriptor renders balance providers without duplicate prefix`(provider: UsageProvider) throws {
+        let suite = "MiMoProviderTests-menu-balance-\(provider.rawValue)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.statusChecksEnabled = false
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings)
+        store._setSnapshotForTesting(self.makeBalanceSnapshot(provider: provider), provider: provider)
+
+        let descriptor = MenuDescriptor.build(
+            provider: provider,
+            store: store,
+            settings: settings,
+            account: AccountInfo(email: nil, plan: nil),
+            updateReady: false,
+            includeContextualActions: false)
+
+        let lines = descriptor.sections
+            .flatMap(\.entries)
+            .compactMap { entry -> String? in
+                guard case let .text(text, _) = entry else { return nil }
+                return text
+            }
+
+        #expect(lines.contains("Balance: $25.51"))
+        #expect(!lines.contains("Balance: Balance: $25.51"))
+        if provider == .mimo {
+            #expect(!lines.contains(where: { $0.hasPrefix("Balance: 100%") }))
+        }
+    }
+
+    @Test
+    @MainActor
+    func `menu descriptor renders mimo token detail without reset date`() throws {
+        let suite = "MiMoProviderTests-menu-token-detail"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.statusChecksEnabled = false
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings)
+        let snapshot = MiMoUsageSnapshot(
+            balance: 25.51,
+            currency: "USD",
+            planCode: "standard",
+            tokenUsed: 10,
+            tokenLimit: 100,
+            tokenPercent: 0.1,
+            updatedAt: Date(timeIntervalSince1970: 1_742_771_200))
+            .toUsageSnapshot()
+        store._setSnapshotForTesting(snapshot, provider: .mimo)
+
+        let descriptor = MenuDescriptor.build(
+            provider: .mimo,
+            store: store,
+            settings: settings,
+            account: AccountInfo(email: nil, plan: nil),
+            updateReady: false,
+            includeContextualActions: false)
+        let lines = descriptor.sections
+            .flatMap(\.entries)
+            .compactMap { entry -> String? in
+                guard case let .text(text, _) = entry else { return nil }
+                return text
+            }
+
+        #expect(lines.contains("10 / 100 Credits"))
+        #expect(!lines.contains("Resets 10 / 100 Credits"))
+    }
+
+    @Test
+    func `mimo web strategy unavailable when cookie source is off`() async {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+        CookieHeaderCache.store(
+            provider: .mimo,
+            cookieHeader: "api-platform_serviceToken=svc-token; userId=123",
+            sourceLabel: "cached")
+        defer { CookieHeaderCache.clear(provider: .mimo) }
+
+        let strategy = MiMoWebFetchStrategy()
+        let context = self.makeContext(settings: ProviderSettingsSnapshot.make(
+            mimo: ProviderSettingsSnapshot.MiMoProviderSettings(
+                cookieSource: .off,
+                manualCookieHeader: nil)))
+
+        let available = await strategy.isAvailable(context)
+
+        #expect(available == false)
+    }
+
+    @Test
+    func `mimo local strategy works when web cookies are disabled or invalid`() async throws {
+        let dir = FileManager.default.temporaryDirectory
+            .appendingPathComponent("mimo-local-strategy-test-\(UUID().uuidString)")
+        try FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: dir) }
+        let file = dir.appendingPathComponent("usage.json")
+        let payload: [String: Any] = [
+            "updated_at": "2026-06-03T05:04:03+00:00",
+            "sessions_scanned": 2,
+            "windows": [
+                "today": ["input": 100, "output": 50, "cache_read": 0, "cache_create": 0],
+                "week": ["input": 100, "output": 50, "cache_read": 0, "cache_create": 0],
+                "all_time": ["input": 100, "output": 50, "cache_read": 0, "cache_create": 0],
+            ],
+        ]
+        try JSONSerialization.data(withJSONObject: payload).write(to: file)
+
+        let settings = [
+            ProviderSettingsSnapshot.make(mimo: .init(cookieSource: .off, manualCookieHeader: nil)),
+            ProviderSettingsSnapshot.make(
+                mimo: .init(cookieSource: .manual, manualCookieHeader: "Cookie: userId=123")),
+        ]
+
+        for setting in settings {
+            let context = self.makeContext(
+                settings: setting,
+                environment: ["MIMO_LOCAL_USAGE_PATH": file.path])
+            let outcome = await MiMoProviderDescriptor.descriptor.fetchPlan.fetchOutcome(
+                context: context,
+                provider: .mimo)
+
+            switch outcome.result {
+            case let .success(result):
+                #expect(result.sourceLabel == "local")
+                #expect(result.strategyID == "mimo.local")
+                #expect(result.usage.primary == nil)
+                #expect(result.usage.mimoUsage == nil)
+                #expect(result.usage.loginMethod(for: .mimo)?.contains("Local") == true)
+            case let .failure(error):
+                Issue.record("Expected local MiMo fallback, got \(error)")
+            }
+        }
+    }
+
+    @Test
+    func `mimo malformed local cache stays available and reports its cache error`() async throws {
+        let dir = FileManager.default.temporaryDirectory
+            .appendingPathComponent("mimo-invalid-local-strategy-test-\(UUID().uuidString)")
+        try FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: dir) }
+        let file = dir.appendingPathComponent("usage.json")
+        try Data("{}".utf8).write(to: file)
+
+        let context = self.makeContext(environment: ["MIMO_LOCAL_USAGE_PATH": file.path])
+        let strategy = MiMoLocalFetchStrategy()
+
+        #expect(await strategy.isAvailable(context))
+        await #expect(throws: MiMoLocalUsageError.self) {
+            try await strategy.fetch(context)
+        }
+    }
+
+    @Test
+    func `mimo explicit web mode does not use local fallback`() async throws {
+        let dir = FileManager.default.temporaryDirectory
+            .appendingPathComponent("mimo-web-mode-test-\(UUID().uuidString)")
+        try FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: dir) }
+        let file = dir.appendingPathComponent("usage.json")
+        let payload: [String: Any] = [
+            "updated_at": "2026-06-03T05:04:03+00:00",
+            "sessions_scanned": 1,
+            "windows": [
+                "today": ["input": 100, "output": 50, "cache_read": 0, "cache_create": 0],
+                "week": ["input": 100, "output": 50, "cache_read": 0, "cache_create": 0],
+                "all_time": ["input": 100, "output": 50, "cache_read": 0, "cache_create": 0],
+            ],
+        ]
+        try JSONSerialization.data(withJSONObject: payload).write(to: file)
+
+        let context = self.makeContext(
+            sourceMode: .web,
+            settings: ProviderSettingsSnapshot.make(
+                mimo: .init(cookieSource: .off, manualCookieHeader: nil)),
+            environment: ["MIMO_LOCAL_USAGE_PATH": file.path])
+        let outcome = await MiMoProviderDescriptor.descriptor.fetchPlan.fetchOutcome(
+            context: context,
+            provider: .mimo)
+
+        switch outcome.result {
+        case let .success(result):
+            Issue.record("Expected explicit web mode to reject local fallback, got \(result.strategyID)")
+        case .failure:
+            break
+        }
+    }
+
+    @Test
+    func `mimo manual mode does not report available from cached browser session`() async {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+        CookieHeaderCache.store(
+            provider: .mimo,
+            cookieHeader: "api-platform_serviceToken=svc-token; userId=123",
+            sourceLabel: "cached")
+        defer { CookieHeaderCache.clear(provider: .mimo) }
+
+        let strategy = MiMoWebFetchStrategy()
+        let context = self.makeContext(settings: ProviderSettingsSnapshot.make(
+            mimo: ProviderSettingsSnapshot.MiMoProviderSettings(
+                cookieSource: .manual,
+                manualCookieHeader: "Cookie: userId=123")))
+
+        let available = await strategy.isAvailable(context)
+
+        #expect(available == false)
+    }
+
+    @Test
+    func `mimo manual mode rejects invalid header instead of falling back to cached session`() async {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+        CookieHeaderCache.store(
+            provider: .mimo,
+            cookieHeader: "api-platform_serviceToken=svc-token; userId=123",
+            sourceLabel: "cached")
+        defer { CookieHeaderCache.clear(provider: .mimo) }
+
+        let strategy = MiMoWebFetchStrategy()
+        let context = self.makeContext(settings: ProviderSettingsSnapshot.make(
+            mimo: ProviderSettingsSnapshot.MiMoProviderSettings(
+                cookieSource: .manual,
+                manualCookieHeader: "Cookie: userId=123")))
+
+        await #expect(throws: MiMoSettingsError.invalidCookie) {
+            _ = try await strategy.fetch(context)
+        }
+    }
+
+    @Test
+    func `mimo cookie importer surfaces safari access denial`() throws {
+        let detection = BrowserDetection(
+            homeDirectory: "/tmp/codexbar-mimo-browser-test",
+            cacheTTL: 0,
+            fileExists: { _ in false },
+            directoryContents: { _ in nil })
+
+        do {
+            _ = try MiMoCookieImporter.importSessions(
+                browserDetection: detection,
+                loadRecords: { browser, _, _ in
+                    throw BrowserCookieError.accessDenied(
+                        browser: browser,
+                        details: "Grant CodexBar Full Disk Access to read Safari cookies.")
+                })
+            Issue.record("Expected Safari access denial")
+        } catch let error as MiMoSettingsError {
+            #expect(error.localizedDescription.contains("Full Disk Access"))
+            #expect(error.localizedDescription.contains("Safari"))
+        }
+    }
+
+    @Test
+    func `mimo web strategy retries imported sessions after decode failure`() async throws {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+        let registered = URLProtocol.registerClass(MiMoStubURLProtocol.self)
+        defer {
+            if registered {
+                URLProtocol.unregisterClass(MiMoStubURLProtocol.self)
+            }
+            MiMoStubURLProtocol.handler = nil
+            MiMoCookieImporter.importSessionsOverrideForTesting = nil
+            CookieHeaderCache.clear(provider: .mimo)
+        }
+
+        CookieHeaderCache.clear(provider: .mimo)
+        CookieHeaderCache.store(provider: .mimo, cookieHeader: "invalid", sourceLabel: "invalid")
+
+        MiMoCookieImporter.importSessionsOverrideForTesting = { _, _ in
+            [
+                .init(
+                    cookieHeader: "api-platform_serviceToken=expired-token; userId=111",
+                    sourceLabel: "Expired Chrome"),
+                .init(
+                    cookieHeader: "api-platform_serviceToken=valid-token; userId=222",
+                    sourceLabel: "Active Chrome"),
+            ]
+        }
+
+        let lock = NSLock()
+        var requestedCookies: [String] = []
+        MiMoStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            let cookie = request.value(forHTTPHeaderField: "Cookie") ?? ""
+            lock.withLock {
+                requestedCookies.append(cookie)
+            }
+
+            if cookie.contains("expired-token") {
+                let response = HTTPURLResponse(
+                    url: url,
+                    statusCode: 200,
+                    httpVersion: "HTTP/1.1",
+                    headerFields: ["Content-Type": "text/html"])!
+                return (response, Data("<html>login</html>".utf8))
+            }
+
+            let body = """
+            {
+              "code": 0,
+              "message": "",
+              "data": {
+                "balance": "25.51",
+                "currency": "USD"
+              }
+            }
+            """
+            return Self.makeResponse(url: url, body: body)
+        }
+
+        let strategy = MiMoWebFetchStrategy()
+        let result = try await strategy
+            .fetch(self.makeContext(environment: ["MIMO_API_URL": "https://mimo.test/api/v1"]))
+
+        #expect(requestedCookies.count == 6)
+        #expect(requestedCookies.contains(where: { $0.contains("expired-token") }))
+        #expect(requestedCookies.contains(where: { $0.contains("valid-token") }))
+        #expect(result.usage.mimoUsage?.balanceDetail == "$25.51")
+        #expect(CookieHeaderCache.load(provider: .mimo)?.sourceLabel == "Active Chrome")
+    }
+
+    @Test
+    func `mimo web strategy retries safari after stale chrome auth redirect`() async throws {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer { KeychainCacheStore.setTestStoreForTesting(false) }
+        let registered = URLProtocol.registerClass(MiMoStubURLProtocol.self)
+        defer {
+            if registered {
+                URLProtocol.unregisterClass(MiMoStubURLProtocol.self)
+            }
+            MiMoStubURLProtocol.handler = nil
+            MiMoCookieImporter.importSessionsOverrideForTesting = nil
+            CookieHeaderCache.clear(provider: .mimo)
+        }
+
+        CookieHeaderCache.clear(provider: .mimo)
+        CookieHeaderCache.store(
+            provider: .mimo,
+            cookieHeader: "api-platform_serviceToken=stale-chrome-token; userId=111",
+            sourceLabel: "Chrome")
+
+        MiMoCookieImporter.importSessionsOverrideForTesting = { _, _ in
+            [
+                .init(
+                    cookieHeader: "api-platform_serviceToken=stale-chrome-token; userId=111",
+                    sourceLabel: "Chrome"),
+                .init(
+                    cookieHeader: "api-platform_serviceToken=valid-safari-token; userId=222",
+                    sourceLabel: "Safari"),
+            ]
+        }
+
+        let lock = NSLock()
+        var requestedCookies: [String] = []
+        MiMoStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            let cookie = request.value(forHTTPHeaderField: "Cookie") ?? ""
+            lock.withLock {
+                requestedCookies.append(cookie)
+            }
+
+            if cookie.contains("stale-chrome-token") {
+                return Self.makeResponse(url: url, body: "", statusCode: 302)
+            }
+
+            let body = """
+            {
+              "code": 0,
+              "message": "",
+              "data": {
+                "balance": "25.51",
+                "currency": "USD"
+              }
+            }
+            """
+            return Self.makeResponse(url: url, body: body)
+        }
+
+        let strategy = MiMoWebFetchStrategy()
+        let result = try await strategy
+            .fetch(self.makeContext(environment: ["MIMO_API_URL": "https://mimo.test/api/v1"]))
+
+        #expect(requestedCookies.contains(where: { $0.contains("stale-chrome-token") }))
+        #expect(requestedCookies.contains(where: { $0.contains("valid-safari-token") }))
+        #expect(result.usage.mimoUsage?.balanceDetail == "$25.51")
+        #expect(CookieHeaderCache.load(provider: .mimo)?.sourceLabel == "Safari")
+    }
+
+    #if os(macOS)
+    @Test
+    func `mimo importer merges profile stores before validating auth cookies`() {
+        let profile = BrowserProfile(id: "Default", name: "Default")
+        let primaryStore = BrowserCookieStore(
+            browser: .chrome,
+            profile: profile,
+            kind: .primary,
+            label: "Chrome Default",
+            databaseURL: nil)
+        let networkStore = BrowserCookieStore(
+            browser: .chrome,
+            profile: profile,
+            kind: .network,
+            label: "Chrome Default (Network)",
+            databaseURL: nil)
+        let expires = Date(timeIntervalSince1970: 1_900_000_000)
+
+        let sessions = MiMoCookieImporter.sessionInfos(from: [
+            BrowserCookieStoreRecords(store: primaryStore, records: [
+                BrowserCookieRecord(
+                    domain: "platform.xiaomimimo.com",
+                    name: "userId",
+                    path: "/",
+                    value: "123",
+                    expires: expires,
+                    isSecure: true,
+                    isHTTPOnly: false),
+            ]),
+            BrowserCookieStoreRecords(store: networkStore, records: [
+                BrowserCookieRecord(
+                    domain: "platform.xiaomimimo.com",
+                    name: "api-platform_serviceToken",
+                    path: "/",
+                    value: "token",
+                    expires: expires,
+                    isSecure: true,
+                    isHTTPOnly: true),
+            ]),
+        ])
+
+        #expect(sessions.count == 1)
+        #expect(sessions.first?.sourceLabel == "Chrome Default")
+        #expect(sessions.first?.cookieHeader == "api-platform_serviceToken=token; userId=123")
+    }
+    #endif
+
+    private static func makeResponse(
+        url: URL,
+        body: String,
+        statusCode: Int = 200) -> (HTTPURLResponse, Data)
+    {
+        let response = HTTPURLResponse(
+            url: url,
+            statusCode: statusCode,
+            httpVersion: "HTTP/1.1",
+            headerFields: ["Content-Type": "application/json"])!
+        return (response, Data(body.utf8))
+    }
+
+    private static func makeMenuCardModel(
+        snapshot: UsageSnapshot,
+        metadata: ProviderMetadata,
+        now: Date) -> UsageMenuCardView.Model
+    {
+        UsageMenuCardView.Model.make(.init(
+            provider: .mimo,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+    }
+
+    private func makeBalanceSnapshot(provider: UsageProvider) -> UsageSnapshot {
+        let updatedAt = Date(timeIntervalSince1970: 1_742_771_200)
+        switch provider {
+        case .openrouter:
+            return OpenRouterUsageSnapshot(
+                totalCredits: 50,
+                totalUsage: 24.49,
+                balance: 25.51,
+                usedPercent: 49,
+                keyDataFetched: false,
+                keyLimit: nil,
+                keyUsage: nil,
+                rateLimit: nil,
+                updatedAt: updatedAt).toUsageSnapshot()
+        case .mimo:
+            return MiMoUsageSnapshot(
+                balance: 25.51,
+                currency: "USD",
+                updatedAt: updatedAt).toUsageSnapshot()
+        default:
+            Issue.record("Unexpected provider \(provider.rawValue)")
+            return UsageSnapshot(
+                primary: nil,
+                secondary: nil,
+                tertiary: nil,
+                updatedAt: updatedAt)
+        }
+    }
+
+    private func makeContext(
+        sourceMode: ProviderSourceMode = .auto,
+        settings: ProviderSettingsSnapshot? = nil,
+        environment: [String: String] = [:]) -> ProviderFetchContext
+    {
+        let browserDetection = BrowserDetection(cacheTTL: 0)
+        return ProviderFetchContext(
+            runtime: .app,
+            sourceMode: sourceMode,
+            includeCredits: false,
+            webTimeout: 1,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: environment,
+            settings: settings,
+            fetcher: UsageFetcher(environment: [:]),
+            claudeFetcher: StubClaudeFetcher(),
+            browserDetection: browserDetection)
+    }
+
+    private func makeCookie(
+        name: String,
+        value: String,
+        domain: String,
+        path: String = "/",
+        expiresAt: Date) throws -> HTTPCookie
+    {
+        let properties: [HTTPCookiePropertyKey: Any] = [
+            .name: name,
+            .value: value,
+            .domain: domain,
+            .path: path,
+            .expires: expiresAt,
+            .secure: "TRUE",
+        ]
+        return try #require(HTTPCookie(properties: properties))
+    }
+}
+
+final class MiMoStubURLProtocol: URLProtocol {
+    nonisolated(unsafe) static var handler: ((URLRequest) throws -> (HTTPURLResponse, Data))?
+
+    override static func canInit(with request: URLRequest) -> Bool {
+        request.url?.host == "mimo.test"
+    }
+
+    override static func canonicalRequest(for request: URLRequest) -> URLRequest {
+        request
+    }
+
+    override func startLoading() {
+        guard let handler = Self.handler else {
+            self.client?.urlProtocol(self, didFailWithError: URLError(.badServerResponse))
+            return
+        }
+
+        do {
+            let (response, data) = try handler(self.request)
+            self.client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
+            self.client?.urlProtocol(self, didLoad: data)
+            self.client?.urlProtocolDidFinishLoading(self)
+        } catch {
+            self.client?.urlProtocol(self, didFailWithError: error)
+        }
+    }
+
+    override func stopLoading() {}
+}
diff --git a/Tests/CodexBarTests/MiMoUsageScriptTests.swift b/Tests/CodexBarTests/MiMoUsageScriptTests.swift
new file mode 100644
index 0000000000..27be4f4257
--- /dev/null
+++ b/Tests/CodexBarTests/MiMoUsageScriptTests.swift
@@ -0,0 +1,195 @@
+import Foundation
+import Testing
+
+struct MiMoUsageScriptTests {
+    @Test
+    func `script keeps final cumulative streaming usage`() throws {
+        let rows = [
+            self.assistantRow(outputTokens: 10),
+            self.assistantRow(outputTokens: 40),
+            self.assistantRow(outputTokens: 90),
+        ]
+        let allTime = try self.runScript(files: ["session.jsonl": rows])
+
+        self.assertUsage(
+            allTime,
+            expected: .init(input: 120, cacheCreate: 10, cacheRead: 5, output: 90, messages: 1))
+    }
+
+    @Test
+    func `script keeps final cumulative streaming usage without session id`() throws {
+        let rows = [
+            self.assistantRow(outputTokens: 10, sessionID: nil),
+            self.assistantRow(outputTokens: 40, sessionID: nil),
+            self.assistantRow(outputTokens: 90, sessionID: nil),
+        ]
+        let allTime = try self.runScript(files: ["session.jsonl": rows])
+
+        self.assertUsage(
+            allTime,
+            expected: .init(input: 120, cacheCreate: 10, cacheRead: 5, output: 90, messages: 1))
+    }
+
+    @Test
+    func `script keeps final cumulative usage without request id`() throws {
+        let rows = [
+            self.assistantRow(outputTokens: 10, requestID: nil),
+            self.assistantRow(outputTokens: 40, requestID: nil),
+            self.assistantRow(outputTokens: 90, requestID: nil),
+        ]
+        let allTime = try self.runScript(files: ["session.jsonl": rows])
+
+        self.assertUsage(
+            allTime,
+            expected: .init(input: 120, cacheCreate: 10, cacheRead: 5, output: 90, messages: 1))
+    }
+
+    @Test
+    func `script counts rows without session identity conservatively`() throws {
+        let rows = [
+            self.assistantRow(outputTokens: 10, sessionID: nil, requestID: nil),
+            self.assistantRow(outputTokens: 40, sessionID: nil, requestID: nil),
+            self.assistantRow(outputTokens: 90, sessionID: nil, requestID: nil),
+        ]
+        let allTime = try self.runScript(files: ["session.jsonl": rows])
+
+        self.assertUsage(
+            allTime,
+            expected: .init(input: 360, cacheCreate: 30, cacheRead: 15, output: 140, messages: 3))
+    }
+
+    @Test
+    func `script keeps distinct requests sharing a message id`() throws {
+        let rows = [
+            self.assistantRow(outputTokens: 40, requestID: "req_one"),
+            self.assistantRow(outputTokens: 90, requestID: "req_two"),
+        ]
+        let allTime = try self.runScript(files: ["session.jsonl": rows])
+
+        self.assertUsage(
+            allTime,
+            expected: .init(input: 240, cacheCreate: 20, cacheRead: 10, output: 130, messages: 2))
+    }
+
+    @Test
+    func `script deduplicates copied rows from the same session`() throws {
+        let rows = [self.assistantRow(outputTokens: 90)]
+        let allTime = try self.runScript(files: [
+            "session.jsonl": rows,
+            "session-copy.jsonl": rows,
+        ])
+
+        self.assertUsage(
+            allTime,
+            expected: .init(input: 120, cacheCreate: 10, cacheRead: 5, output: 90, messages: 1))
+    }
+
+    @Test
+    func `script deduplicates copied requests from different sessions`() throws {
+        let allTime = try self.runScript(files: [
+            "session-a.jsonl": [self.assistantRow(outputTokens: 90, sessionID: "session_a")],
+            "session-b.jsonl": [self.assistantRow(outputTokens: 90, sessionID: "session_b")],
+        ])
+
+        self.assertUsage(
+            allTime,
+            expected: .init(input: 120, cacheCreate: 10, cacheRead: 5, output: 90, messages: 1))
+    }
+
+    private func runScript(files: [String: [[String: Any]]]) throws -> [String: Any] {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent("mimo-usage-script-\(UUID().uuidString)")
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let mimoHome = root.appendingPathComponent("mimo")
+        let projects = mimoHome
+            .appendingPathComponent(".claude")
+            .appendingPathComponent("projects")
+            .appendingPathComponent("project-a")
+        try FileManager.default.createDirectory(at: projects, withIntermediateDirectories: true)
+
+        for (name, rows) in files {
+            let session = projects.appendingPathComponent(name)
+            let jsonl = try rows
+                .map { try JSONSerialization.data(withJSONObject: $0) }
+                .map { try #require(String(bytes: $0, encoding: .utf8)) }
+                .joined(separator: "\n")
+            try jsonl.write(to: session, atomically: true, encoding: .utf8)
+        }
+
+        let cache = root.appendingPathComponent("usage.json")
+        let process = Process()
+        process.executableURL = URL(fileURLWithPath: "/usr/bin/env")
+        process.arguments = ["python3", self.scriptURL.path, "--update"]
+        process.environment = ProcessInfo.processInfo.environment.merging([
+            "MIMO_CLAUDE_HOME": mimoHome.path,
+            "MIMO_LOCAL_USAGE_PATH": cache.path,
+        ]) { _, new in new }
+        let stderr = Pipe()
+        process.standardError = stderr
+
+        try process.run()
+        process.waitUntilExit()
+
+        let errorText = try #require(String(
+            bytes: stderr.fileHandleForReading.readDataToEndOfFile(),
+            encoding: .utf8))
+        #expect(process.terminationStatus == 0, Comment(rawValue: errorText))
+
+        let payload = try #require(
+            JSONSerialization.jsonObject(with: Data(contentsOf: cache)) as? [String: Any])
+        let windows = try #require(payload["windows"] as? [String: Any])
+        return try #require(windows["all_time"] as? [String: Any])
+    }
+
+    private func assertUsage(_ allTime: [String: Any], expected: UsageExpectation) {
+        #expect(allTime["input"] as? Int == expected.input)
+        #expect(allTime["cache_create"] as? Int == expected.cacheCreate)
+        #expect(allTime["cache_read"] as? Int == expected.cacheRead)
+        #expect(allTime["output"] as? Int == expected.output)
+        #expect(allTime["messages"] as? Int == expected.messages)
+    }
+
+    private var scriptURL: URL {
+        URL(fileURLWithPath: #filePath)
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+            .appendingPathComponent("Scripts/mimo-usage.py")
+    }
+
+    private func assistantRow(
+        outputTokens: Int,
+        sessionID: String? = "session_stream",
+        requestID: String? = "req_stream") -> [String: Any]
+    {
+        var row: [String: Any] = [
+            "type": "assistant",
+            "timestamp": ISO8601DateFormatter().string(from: Date()),
+            "message": [
+                "id": "msg_stream",
+                "usage": [
+                    "input_tokens": 120,
+                    "cache_creation_input_tokens": 10,
+                    "cache_read_input_tokens": 5,
+                    "output_tokens": outputTokens,
+                ],
+            ],
+        ]
+        if let sessionID {
+            row["sessionId"] = sessionID
+        }
+        if let requestID {
+            row["requestId"] = requestID
+        }
+        return row
+    }
+
+    private struct UsageExpectation {
+        let input: Int
+        let cacheCreate: Int
+        let cacheRead: Int
+        let output: Int
+        let messages: Int
+    }
+}
diff --git a/Tests/CodexBarTests/MiniMaxAPITokenFetchTests.swift b/Tests/CodexBarTests/MiniMaxAPITokenFetchTests.swift
index e427484f86..09145a3323 100644
--- a/Tests/CodexBarTests/MiniMaxAPITokenFetchTests.swift
+++ b/Tests/CodexBarTests/MiniMaxAPITokenFetchTests.swift
@@ -5,15 +5,12 @@ import Testing
 @Suite(.serialized)
 struct MiniMaxAPITokenFetchTests {
     @Test
-    func retriesChinaHostWhenGlobalRejectsToken() async throws {
-        let registered = URLProtocol.registerClass(MiniMaxAPITokenStubURLProtocol.self)
+    func `retries china host when global rejects token`() async throws {
         defer {
-            if registered {
-                URLProtocol.unregisterClass(MiniMaxAPITokenStubURLProtocol.self)
-            }
             MiniMaxAPITokenStubURLProtocol.handler = nil
             MiniMaxAPITokenStubURLProtocol.requests = []
         }
+        MiniMaxAPITokenStubURLProtocol.requests = []
 
         MiniMaxAPITokenStubURLProtocol.handler = { request in
             guard let url = request.url else { throw URLError(.badURL) }
@@ -45,24 +42,32 @@ struct MiniMaxAPITokenFetchTests {
         }
 
         let now = Date(timeIntervalSince1970: 1_700_000_000)
-        let snapshot = try await MiniMaxUsageFetcher.fetchUsage(apiToken: "sk-cp-test", region: .global, now: now)
+        let snapshot = try await MiniMaxUsageFetcher.fetchUsage(
+            apiToken: "sk-cp-test",
+            region: .global,
+            now: now,
+            session: Self.makeSession())
 
         #expect(snapshot.planName == "Max")
-        #expect(MiniMaxAPITokenStubURLProtocol.requests.count == 2)
-        #expect(MiniMaxAPITokenStubURLProtocol.requests.first?.url?.host == "api.minimax.io")
-        #expect(MiniMaxAPITokenStubURLProtocol.requests.last?.url?.host == "api.minimaxi.com")
+        #expect(MiniMaxAPITokenStubURLProtocol.requests.map { $0.url?.host } == [
+            "api.minimax.io",
+            "api.minimax.io",
+            "api.minimaxi.com",
+        ])
+        #expect(MiniMaxAPITokenStubURLProtocol.requests.map { $0.url?.path } == [
+            "/v1/token_plan/remains",
+            "/v1/api/openplatform/coding_plan/remains",
+            "/v1/token_plan/remains",
+        ])
     }
 
     @Test
-    func preservesInvalidCredentialsWhenChinaRetryFailsTransport() async throws {
-        let registered = URLProtocol.registerClass(MiniMaxAPITokenStubURLProtocol.self)
+    func `preserves invalid credentials when china retry fails transport`() async throws {
         defer {
-            if registered {
-                URLProtocol.unregisterClass(MiniMaxAPITokenStubURLProtocol.self)
-            }
             MiniMaxAPITokenStubURLProtocol.handler = nil
             MiniMaxAPITokenStubURLProtocol.requests = []
         }
+        MiniMaxAPITokenStubURLProtocol.requests = []
 
         MiniMaxAPITokenStubURLProtocol.handler = { request in
             guard let url = request.url else { throw URLError(.badURL) }
@@ -78,24 +83,65 @@ struct MiniMaxAPITokenFetchTests {
 
         let now = Date(timeIntervalSince1970: 1_700_000_000)
         await #expect(throws: MiniMaxUsageError.invalidCredentials) {
-            _ = try await MiniMaxUsageFetcher.fetchUsage(apiToken: "sk-cp-test", region: .global, now: now)
+            _ = try await MiniMaxUsageFetcher.fetchUsage(
+                apiToken: "sk-cp-test",
+                region: .global,
+                now: now,
+                session: Self.makeSession())
         }
 
-        #expect(MiniMaxAPITokenStubURLProtocol.requests.count == 2)
-        #expect(MiniMaxAPITokenStubURLProtocol.requests.first?.url?.host == "api.minimax.io")
-        #expect(MiniMaxAPITokenStubURLProtocol.requests.last?.url?.host == "api.minimaxi.com")
+        #expect(MiniMaxAPITokenStubURLProtocol.requests.map { $0.url?.host } == [
+            "api.minimax.io",
+            "api.minimax.io",
+            "api.minimaxi.com",
+            "api.minimaxi.com",
+        ])
+        #expect(MiniMaxAPITokenStubURLProtocol.requests.map { $0.url?.path } == [
+            "/v1/token_plan/remains",
+            "/v1/api/openplatform/coding_plan/remains",
+            "/v1/token_plan/remains",
+            "/v1/api/openplatform/coding_plan/remains",
+        ])
     }
 
     @Test
-    func doesNotRetryWhenRegionIsChinaMainland() async throws {
-        let registered = URLProtocol.registerClass(MiniMaxAPITokenStubURLProtocol.self)
+    func `explicit china region preserves structured invalid credentials across legacy fallback`() async throws {
         defer {
-            if registered {
-                URLProtocol.unregisterClass(MiniMaxAPITokenStubURLProtocol.self)
+            MiniMaxAPITokenStubURLProtocol.handler = nil
+            MiniMaxAPITokenStubURLProtocol.requests = []
+        }
+        MiniMaxAPITokenStubURLProtocol.requests = []
+
+        MiniMaxAPITokenStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            if url.path == "/v1/token_plan/remains" {
+                return Self.makeResponse(
+                    url: url,
+                    body: #"{"base_resp":{"status_code":1004,"status_msg":"invalid api key"}}"#)
             }
+            return Self.makeResponse(url: url, body: "{}", statusCode: 404)
+        }
+
+        await #expect(throws: MiniMaxUsageError.invalidCredentials) {
+            _ = try await MiniMaxUsageFetcher.fetchUsage(
+                apiToken: "sk-cp-test",
+                region: .chinaMainland,
+                session: Self.makeSession())
+        }
+
+        #expect(MiniMaxAPITokenStubURLProtocol.requests.map { $0.url?.path } == [
+            "/v1/token_plan/remains",
+            "/v1/api/openplatform/coding_plan/remains",
+        ])
+    }
+
+    @Test
+    func `does not retry when region is china mainland`() async throws {
+        defer {
             MiniMaxAPITokenStubURLProtocol.handler = nil
             MiniMaxAPITokenStubURLProtocol.requests = []
         }
+        MiniMaxAPITokenStubURLProtocol.requests = []
 
         MiniMaxAPITokenStubURLProtocol.handler = { request in
             guard let url = request.url else { throw URLError(.badURL) }
@@ -124,12 +170,22 @@ struct MiniMaxAPITokenFetchTests {
         }
 
         let now = Date(timeIntervalSince1970: 1_700_000_000)
-        _ = try await MiniMaxUsageFetcher.fetchUsage(apiToken: "sk-cp-test", region: .chinaMainland, now: now)
+        _ = try await MiniMaxUsageFetcher.fetchUsage(
+            apiToken: "sk-cp-test",
+            region: .chinaMainland,
+            now: now,
+            session: Self.makeSession())
 
         #expect(MiniMaxAPITokenStubURLProtocol.requests.count == 1)
         #expect(MiniMaxAPITokenStubURLProtocol.requests.first?.url?.host == "api.minimaxi.com")
     }
 
+    private static func makeSession() -> URLSession {
+        let config = URLSessionConfiguration.ephemeral
+        config.protocolClasses = [MiniMaxAPITokenStubURLProtocol.self]
+        return URLSession(configuration: config)
+    }
+
     private static func makeResponse(
         url: URL,
         body: String,
diff --git a/Tests/CodexBarTests/MiniMaxCurrentTokenPlanResponseTests.swift b/Tests/CodexBarTests/MiniMaxCurrentTokenPlanResponseTests.swift
new file mode 100644
index 0000000000..8a1d1c9999
--- /dev/null
+++ b/Tests/CodexBarTests/MiniMaxCurrentTokenPlanResponseTests.swift
@@ -0,0 +1,218 @@
+import Foundation
+import Testing
+@testable import CodexBar
+@testable import CodexBarCore
+
+struct MiniMaxCurrentTokenPlanResponseTests {
+    @Test
+    func `coarse html plan name does not replace remains api plan name`() {
+        let remainsSnapshot = MiniMaxUsageSnapshot(
+            planName: "Token Plan Pro",
+            availablePrompts: nil,
+            currentPrompts: nil,
+            remainingPrompts: nil,
+            windowMinutes: nil,
+            usedPercent: nil,
+            resetsAt: nil,
+            updatedAt: Date())
+
+        let enriched = remainsSnapshot.withPlanNameIfMissing("Plus")
+
+        #expect(enriched.planName == "Token Plan Pro")
+    }
+
+    @Test
+    func `parses token plan boosted weekly lane with permille spelling`() throws {
+        let now = Date(timeIntervalSince1970: 1_782_050_596)
+
+        let snapshot = try MiniMaxUsageParser.parseCodingPlanRemains(
+            data: Data(Self.currentTokenPlanRemainsJSON.utf8),
+            now: now)
+        let services = try #require(snapshot.services)
+
+        #expect(services.map(\.windowType) == ["5 hours", "Weekly"])
+        #expect(services[0].usage == 0)
+        #expect(services[0].limit == 100)
+        #expect(services[0].percent == 0)
+        #expect(services[1].usage == 45)
+        #expect(services[1].limit == 150)
+        #expect(services[1].percent == 30)
+        #expect(snapshot.toUsageSnapshot().primary?.usedPercent == 0)
+        #expect(snapshot.toUsageSnapshot().secondary?.usedPercent == 30)
+    }
+
+    @Test
+    func `web usage fetch enriches parsed html without service quota data from remains api`() async throws {
+        let now = Date(timeIntervalSince1970: 1_780_282_340)
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            if url.path.contains("coding-plan") {
+                return Self.httpResponse(
+                    url: url,
+                    body: "<html><main>Coding Plan Plus available usage 1000 prompts 5 hours</main></html>",
+                    contentType: "text/html")
+            }
+            #expect(url.host == "platform.minimaxi.com")
+            #expect(url.path == "/v1/api/openplatform/coding_plan/remains")
+            return Self.httpResponse(url: url, body: Self.percentBasedRemainsJSON, contentType: "application/json")
+        }
+
+        let snapshot = try await MiniMaxUsageFetcher.fetchUsage(
+            cookieHeader: "HERTZ-SESSION=abc",
+            region: .chinaMainland,
+            environment: [:],
+            includeBillingHistory: false,
+            session: transport,
+            now: now)
+        let requests = await transport.requests()
+
+        #expect(snapshot.services?.count == 2)
+        #expect(snapshot.planName == "Plus")
+        #expect(snapshot.toUsageSnapshot().primary?.usedPercent == 4)
+        #expect(requests.map { $0.url?.host } == [
+            "platform.minimaxi.com",
+            "platform.minimaxi.com",
+        ])
+    }
+
+    @Test
+    func `web usage fetch preserves auth failure from parseable html remains fallback`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            if url.path.contains("coding-plan") {
+                return Self.httpResponse(
+                    url: url,
+                    body: "<html><main>Coding Plan Plus available usage 1000 prompts / 5 hours</main></html>",
+                    contentType: "text/html")
+            }
+            return Self.httpResponse(
+                url: url,
+                body: #"{"base_resp":{"status_code":1004,"status_msg":"cookie is missing, log in again"}}"#,
+                contentType: "application/json")
+        }
+
+        await #expect(throws: MiniMaxUsageError.invalidCredentials) {
+            try await MiniMaxUsageFetcher.fetchUsage(
+                cookieHeader: "HERTZ-SESSION=expired",
+                region: .chinaMainland,
+                environment: [:],
+                includeBillingHistory: false,
+                session: transport)
+        }
+        let requests = await transport.requests()
+        #expect(requests.map { $0.url?.path } == [
+            "/user-center/payment/coding-plan",
+            "/v1/api/openplatform/coding_plan/remains",
+        ])
+    }
+
+    @Test
+    func `web usage fetch preserves cancellation from parseable html remains fallback`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            if url.path.contains("coding-plan") {
+                return Self.httpResponse(
+                    url: url,
+                    body: "<html><main>Coding Plan Plus available usage 1000 prompts / 5 hours</main></html>",
+                    contentType: "text/html")
+            }
+            throw CancellationError()
+        }
+
+        await #expect(throws: CancellationError.self) {
+            try await MiniMaxUsageFetcher.fetchUsage(
+                cookieHeader: "HERTZ-SESSION=abc",
+                region: .chinaMainland,
+                environment: [:],
+                includeBillingHistory: false,
+                session: transport)
+        }
+        let requests = await transport.requests()
+        #expect(requests.map { $0.url?.path } == [
+            "/user-center/payment/coding-plan",
+            "/v1/api/openplatform/coding_plan/remains",
+        ])
+    }
+
+    private static let currentTokenPlanRemainsJSON = """
+    {
+      "model_remains": [
+        {
+          "start_time": 1782043200000,
+          "end_time": 1782057600000,
+          "remains_time": 7003536,
+          "current_interval_total_count": 0,
+          "current_interval_usage_count": 0,
+          "model_name": "general",
+          "current_weekly_total_count": 0,
+          "current_weekly_usage_count": 0,
+          "weekly_start_time": 1781452800000,
+          "weekly_end_time": 1782057600000,
+          "weekly_remains_time": 7003536,
+          "current_interval_status": 1,
+          "current_interval_remaining_percent": 100,
+          "current_weekly_status": 1,
+          "current_weekly_remaining_percent": 70,
+          "weekly_boost_permille": 1500
+        },
+        {
+          "start_time": 1781971200000,
+          "end_time": 1782057600000,
+          "remains_time": 7003536,
+          "current_interval_total_count": 0,
+          "current_interval_usage_count": 0,
+          "model_name": "video",
+          "current_weekly_total_count": 0,
+          "current_weekly_usage_count": 0,
+          "weekly_start_time": 1781452800000,
+          "weekly_end_time": 1782057600000,
+          "weekly_remains_time": 7003536,
+          "current_interval_status": 3,
+          "current_interval_remaining_percent": 100,
+          "current_weekly_status": 3,
+          "current_weekly_remaining_percent": 100
+        }
+      ],
+      "base_resp": { "status_code": 0, "status_msg": "success" }
+    }
+    """
+
+    private static let percentBasedRemainsJSON = """
+    {
+      "model_remains": [
+        {
+          "start_time": 1780279200000,
+          "end_time": 1780297200000,
+          "remains_time": 16659830,
+          "current_interval_total_count": 0,
+          "current_interval_usage_count": 0,
+          "model_name": "general",
+          "current_weekly_total_count": 0,
+          "current_weekly_usage_count": 0,
+          "weekly_start_time": 1780243200000,
+          "weekly_end_time": 1780848000000,
+          "weekly_remains_time": 567459830,
+          "current_interval_status": 1,
+          "current_interval_remaining_percent": 96,
+          "current_weekly_status": 1,
+          "current_weekly_remaining_percent": 99
+        }
+      ],
+      "base_resp": { "status_code": 0, "status_msg": "success" }
+    }
+    """
+
+    private static func httpResponse(
+        url: URL,
+        body: String,
+        statusCode: Int = 200,
+        contentType: String) -> (Data, URLResponse)
+    {
+        let response = HTTPURLResponse(
+            url: url,
+            statusCode: statusCode,
+            httpVersion: "HTTP/1.1",
+            headerFields: ["Content-Type": contentType])!
+        return (Data(body.utf8), response)
+    }
+}
diff --git a/Tests/CodexBarTests/MiniMaxLocalStorageImporterTests.swift b/Tests/CodexBarTests/MiniMaxLocalStorageImporterTests.swift
index d35b65024c..e8a188d78e 100644
--- a/Tests/CodexBarTests/MiniMaxLocalStorageImporterTests.swift
+++ b/Tests/CodexBarTests/MiniMaxLocalStorageImporterTests.swift
@@ -2,10 +2,9 @@ import Foundation
 import Testing
 @testable import CodexBarCore
 
-@Suite
 struct MiniMaxLocalStorageImporterTests {
     @Test
-    func extractsAccessTokensFromJSONPreferringLongTokens() {
+    func `extracts access tokens from JSON preferring long tokens`() {
         let shortToken = String(repeating: "b", count: 24)
         let longToken = String(repeating: "a", count: 72)
         let payload = """
@@ -19,7 +18,7 @@ struct MiniMaxLocalStorageImporterTests {
     }
 
     @Test
-    func extractsGroupIDFromJSONString() {
+    func `extracts group ID from JSON string`() {
         let payload = """
         {"user":{"groupId":"98765"}}
         """
@@ -30,7 +29,7 @@ struct MiniMaxLocalStorageImporterTests {
     }
 
     @Test
-    func resolvesGroupIDFromJWTClaims() {
+    func `resolves group ID from JWT claims`() {
         let token = Self.makeJWT(payload: [
             "iss": "minimax",
             "group_id": "12345",
@@ -42,7 +41,7 @@ struct MiniMaxLocalStorageImporterTests {
     }
 
     @Test
-    func rejectsNonMiniMaxJWTsWithoutSignal() {
+    func `rejects non mini max JW ts without signal`() {
         let token = Self.makeJWT(payload: [
             "iss": "other",
             "pad": String(repeating: "y", count: 80),
diff --git a/Tests/CodexBarTests/MiniMaxLogRedactorTests.swift b/Tests/CodexBarTests/MiniMaxLogRedactorTests.swift
new file mode 100644
index 0000000000..d37ed2251e
--- /dev/null
+++ b/Tests/CodexBarTests/MiniMaxLogRedactorTests.swift
@@ -0,0 +1,105 @@
+import CodexBarCore
+import Foundation
+import Testing
+
+@Suite(.serialized)
+struct MiniMaxLogRedactorTests {
+    private static var miniMaxCpPlaceholder: String {
+        ["sk", "cp", "placeholder"].joined(separator: "-")
+    }
+
+    private static var miniMaxApiPlaceholder: String {
+        ["sk", "api", "placeholder"].joined(separator: "-")
+    }
+
+    @Test
+    func `sk-cp token is redacted`() {
+        let input = Self.miniMaxCpPlaceholder
+        let redacted = LogRedactor.redact(input)
+        #expect(redacted.contains("sk-cp-") == false)
+        #expect(redacted.contains("<redacted-minimax-token>"))
+        #expect(redacted.contains("placeholder") == false)
+    }
+
+    @Test
+    func `sk-api token is redacted`() {
+        let input = Self.miniMaxApiPlaceholder
+        let redacted = LogRedactor.redact(input)
+        #expect(redacted.contains("sk-api-") == false)
+        #expect(redacted.contains("<redacted-minimax-token>"))
+        #expect(redacted.contains("placeholder") == false)
+    }
+
+    @Test
+    func `cookie header is redacted`() {
+        let input = "Cookie: session=cookie-session-placeholder; token=\(Self.miniMaxCpPlaceholder)"
+        let redacted = LogRedactor.redact(input)
+        #expect(redacted.contains("session=cookie-session-placeholder") == false)
+        #expect(redacted.contains(Self.miniMaxCpPlaceholder) == false)
+        #expect(redacted.contains("Cookie: <redacted>"))
+    }
+
+    @Test
+    func `authorization header value is redacted`() {
+        // Short obvious placeholder, not JWT-like
+        let input = "Authorization: Bearer fake-bearer-token"
+        let redacted = LogRedactor.redact(input)
+        #expect(redacted.contains("fake-bearer-token") == false)
+        #expect(redacted.contains("Authorization:"))
+    }
+
+    @Test
+    func `bearer token is not present in raw form`() {
+        let input = "Authorization: bearer \(Self.miniMaxApiPlaceholder)"
+        let redacted = LogRedactor.redact(input)
+        #expect(redacted.contains(Self.miniMaxApiPlaceholder) == false)
+    }
+
+    @Test
+    func `email is redacted`() {
+        let input = "Contact: user@example.com"
+        let redacted = LogRedactor.redact(input)
+        #expect(redacted.contains("user@example.com") == false)
+        #expect(redacted.contains("<redacted-email>"))
+    }
+
+    @Test
+    func `minimax token in cookie is not present in raw form`() {
+        let input = "Cookie: session=session-placeholder; token=\(Self.miniMaxCpPlaceholder)"
+        let redacted = LogRedactor.redact(input)
+        #expect(redacted.contains("session=session-placeholder") == false)
+        #expect(redacted.contains(Self.miniMaxCpPlaceholder) == false)
+    }
+
+    @Test
+    func `redacted text no longer matches original token pattern`() {
+        let originalToken = Self.miniMaxCpPlaceholder
+        let input = "Token: \(originalToken)"
+        let redacted = LogRedactor.redact(input)
+
+        #expect(redacted.contains(originalToken) == false)
+        #expect(redacted.contains("<redacted-minimax-token>"))
+    }
+
+    @Test
+    func `minimax token with punctuation suffix is fully redacted`() {
+        let punctuatedToken = "\(Self.miniMaxApiPlaceholder).suffix-more"
+        let input = "Error: token=\(punctuatedToken)"
+        let redacted = LogRedactor.redact(input)
+
+        #expect(redacted.contains("sk-api-") == false)
+        #expect(redacted.contains("suffix-more") == false)
+        #expect(redacted.contains("<redacted-minimax-token>"))
+    }
+
+    @Test
+    func `authorization header minimax token leaves no suffix fragment`() {
+        let punctuatedToken = "\(Self.miniMaxCpPlaceholder)-part.two"
+        let input = "Authorization: Bearer \(punctuatedToken)"
+        let redacted = LogRedactor.redact(input)
+
+        #expect(redacted.contains("sk-cp-") == false)
+        #expect(redacted.contains("part.two") == false)
+        #expect(redacted.contains("Authorization: <redacted>"))
+    }
+}
diff --git a/Tests/CodexBarTests/MiniMaxMenuCardBillingTests.swift b/Tests/CodexBarTests/MiniMaxMenuCardBillingTests.swift
new file mode 100644
index 0000000000..461c7f66ae
--- /dev/null
+++ b/Tests/CodexBarTests/MiniMaxMenuCardBillingTests.swift
@@ -0,0 +1,103 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct MiniMaxMenuCardBillingTests {
+    @Test
+    func `minimax billing history renders inline dashboard`() throws {
+        let now = Date()
+        let billing = MiniMaxBillingSummary(
+            todayTokens: 1234,
+            last30DaysTokens: 5678,
+            todayCash: 1.5,
+            last30DaysCash: 4.25,
+            daily: [
+                MiniMaxBillingDay(day: "2026-05-16", tokens: 1111, cash: 2.75),
+                MiniMaxBillingDay(day: "2026-05-17", tokens: 1234, cash: 1.5),
+            ],
+            topMethods: [MiniMaxBillingBreakdown(name: "chat", tokens: 2345, cash: 4.25)],
+            topModels: [MiniMaxBillingBreakdown(name: "MiniMax-M1", tokens: 2345, cash: 4.25)],
+            updatedAt: now)
+        let minimax = MiniMaxUsageSnapshot(
+            planName: "Max",
+            availablePrompts: nil,
+            currentPrompts: nil,
+            remainingPrompts: nil,
+            windowMinutes: nil,
+            usedPercent: nil,
+            resetsAt: nil,
+            updatedAt: now,
+            services: [
+                MiniMaxServiceUsage(
+                    serviceType: "text-generation",
+                    windowType: "Today",
+                    timeRange: "2026/05/17 00:00 - 2026/05/18 00:00",
+                    usage: 2,
+                    limit: 10,
+                    percent: 20,
+                    resetsAt: now.addingTimeInterval(3600),
+                    resetDescription: "Resets in 1 hour"),
+            ],
+            billingSummary: billing)
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 20, windowMinutes: 1440, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            minimaxUsage: minimax,
+            updatedAt: now,
+            identity: ProviderIdentitySnapshot(
+                providerID: .minimax,
+                accountEmail: nil,
+                accountOrganization: nil,
+                loginMethod: "Max"))
+        let metadata = try #require(ProviderDefaults.metadata[.minimax])
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .minimax,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: true,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.inlineUsageDashboard?.accessibilityLabel == "MiniMax 30 day token usage trend")
+        #expect(model.inlineUsageDashboard?.kpis.first?.value == "1.2K")
+        #expect(model.inlineUsageDashboard?.points.count == 2)
+        #expect(model.usageNotes.contains("Last 30 days: 5.7K tokens"))
+
+        let hiddenModel = UsageMenuCardView.Model.make(.init(
+            provider: .minimax,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: true,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: false,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(hiddenModel.inlineUsageDashboard == nil)
+        #expect(!hiddenModel.usageNotes.contains("Last 30 days: 5.7K tokens"))
+    }
+}
diff --git a/Tests/CodexBarTests/MiniMaxMenuCardModelPlanTests.swift b/Tests/CodexBarTests/MiniMaxMenuCardModelPlanTests.swift
new file mode 100644
index 0000000000..23740cb502
--- /dev/null
+++ b/Tests/CodexBarTests/MiniMaxMenuCardModelPlanTests.swift
@@ -0,0 +1,286 @@
+import CodexBarCore
+import Foundation
+import SwiftUI
+import Testing
+@testable import CodexBar
+
+struct MiniMaxMenuCardModelPlanTests {
+    @Test
+    func `minimax loginMethod maps to planText in MenuCardModel`() throws {
+        let now = Date()
+        let minimax = MiniMaxUsageSnapshot(
+            planName: "MiniMax Star",
+            availablePrompts: nil,
+            currentPrompts: nil,
+            remainingPrompts: nil,
+            windowMinutes: nil,
+            usedPercent: nil,
+            resetsAt: nil,
+            updatedAt: now)
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 0, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            minimaxUsage: minimax,
+            updatedAt: now,
+            identity: ProviderIdentitySnapshot(
+                providerID: .minimax,
+                accountEmail: nil,
+                accountOrganization: nil,
+                loginMethod: "MiniMax Star"))
+        let metadata = try #require(ProviderDefaults.metadata[.minimax])
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .minimax,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: true,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.planText == "MiniMax Star")
+    }
+
+    @Test
+    func `minimax nil loginMethod results in nil planText`() throws {
+        let now = Date()
+        let minimax = MiniMaxUsageSnapshot(
+            planName: nil,
+            availablePrompts: nil,
+            currentPrompts: nil,
+            remainingPrompts: nil,
+            windowMinutes: nil,
+            usedPercent: nil,
+            resetsAt: nil,
+            updatedAt: now)
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 0, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            minimaxUsage: minimax,
+            updatedAt: now,
+            identity: ProviderIdentitySnapshot(
+                providerID: .minimax,
+                accountEmail: nil,
+                accountOrganization: nil,
+                loginMethod: nil))
+        let metadata = try #require(ProviderDefaults.metadata[.minimax])
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .minimax,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: true,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.planText == nil)
+    }
+
+    @Test
+    func `minimax quota rows include configured warning markers`() throws {
+        let now = Date()
+        let minimax = MiniMaxUsageSnapshot(
+            planName: "TokenPlanPlus-年度会员",
+            availablePrompts: nil,
+            currentPrompts: nil,
+            remainingPrompts: nil,
+            windowMinutes: nil,
+            usedPercent: nil,
+            resetsAt: nil,
+            updatedAt: now,
+            services: [
+                MiniMaxServiceUsage(
+                    serviceType: "general",
+                    windowType: "5 hours",
+                    timeRange: "15:00-20:00(UTC+8)",
+                    usage: 31,
+                    limit: 100,
+                    percent: 31,
+                    resetsAt: now.addingTimeInterval(3600),
+                    resetDescription: "Resets in 1 hour"),
+                MiniMaxServiceUsage(
+                    serviceType: "general",
+                    windowType: "Weekly",
+                    timeRange: "06/01 00:00 - 06/08 00:00(UTC+8)",
+                    usage: 4,
+                    limit: 100,
+                    percent: 4,
+                    resetsAt: now.addingTimeInterval(6 * 24 * 3600),
+                    resetDescription: "Resets in 6 days"),
+            ])
+        let metadata = try #require(ProviderDefaults.metadata[.minimax])
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .minimax,
+            metadata: metadata,
+            snapshot: minimax.toUsageSnapshot(),
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: true,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            quotaWarningThresholds: [.session: [50, 20], .weekly: [50, 20]],
+            now: now))
+
+        #expect(model.metrics.map(\.warningMarkerPercents) == [[50, 80], [50, 80]])
+    }
+
+    @Test
+    func `minimax quota rows use canonical general first order`() throws {
+        let now = Date()
+        let minimax = MiniMaxUsageSnapshot(
+            planName: "TokenPlanMax-年度会员",
+            availablePrompts: nil,
+            currentPrompts: nil,
+            remainingPrompts: nil,
+            windowMinutes: nil,
+            usedPercent: nil,
+            resetsAt: nil,
+            updatedAt: now,
+            services: [
+                MiniMaxServiceUsage(
+                    serviceType: "video",
+                    windowType: "Today",
+                    timeRange: "06/01 00:00 - 06/02 00:00(UTC+8)",
+                    usage: 70,
+                    limit: 100,
+                    percent: 70,
+                    resetsAt: now.addingTimeInterval(3600),
+                    resetDescription: "Resets in 1 hour"),
+                MiniMaxServiceUsage(
+                    serviceType: "general",
+                    windowType: "5 hours",
+                    timeRange: "15:00-20:00(UTC+8)",
+                    usage: 4,
+                    limit: 100,
+                    percent: 4,
+                    resetsAt: now.addingTimeInterval(3600),
+                    resetDescription: "Resets in 1 hour"),
+                MiniMaxServiceUsage(
+                    serviceType: "general",
+                    windowType: "Weekly",
+                    timeRange: "06/01 00:00 - 06/08 00:00(UTC+8)",
+                    usage: 1,
+                    limit: 100,
+                    percent: 1,
+                    resetsAt: now.addingTimeInterval(6 * 24 * 3600),
+                    resetDescription: "Resets in 6 days"),
+            ])
+        let metadata = try #require(ProviderDefaults.metadata[.minimax])
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .minimax,
+            metadata: metadata,
+            snapshot: minimax.toUsageSnapshot(),
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: true,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.metrics.map(\.title) == ["General · 5h", "General · Weekly", "Video"])
+        #expect(model.metrics.map(\.percent) == [4, 1, 70])
+    }
+
+    @Test
+    func `minimax unlimited quota rows omit usage copy and warning markers`() throws {
+        let now = Date()
+        let minimax = MiniMaxUsageSnapshot(
+            planName: "Plus",
+            availablePrompts: nil,
+            currentPrompts: nil,
+            remainingPrompts: nil,
+            windowMinutes: nil,
+            usedPercent: nil,
+            resetsAt: nil,
+            updatedAt: now,
+            services: [
+                MiniMaxServiceUsage(
+                    serviceType: "general",
+                    windowType: "5 hours",
+                    timeRange: "15:00-20:00(UTC+8)",
+                    usage: 2,
+                    limit: 200,
+                    percent: 2,
+                    resetsAt: now.addingTimeInterval(3600),
+                    resetDescription: "Resets in 1 hour"),
+                MiniMaxServiceUsage(
+                    serviceType: "general",
+                    windowType: "Weekly",
+                    timeRange: "06/01 00:00 - 06/08 00:00(UTC+8)",
+                    usage: 0,
+                    limit: 0,
+                    percent: 0,
+                    isUnlimited: true,
+                    resetsAt: nil,
+                    resetDescription: "Unlimited"),
+            ])
+        let metadata = try #require(ProviderDefaults.metadata[.minimax])
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .minimax,
+            metadata: metadata,
+            snapshot: minimax.toUsageSnapshot(),
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: true,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            quotaWarningThresholds: [.session: [50, 20], .weekly: [50, 20]],
+            now: now))
+
+        #expect(model.metrics.count == 2)
+        #expect(model.metrics[1].title == "General · Weekly")
+        #expect(model.metrics[1].statusText == "∞ Unlimited")
+        #expect(model.metrics[1].detailLeftText == nil)
+        #expect(model.metrics[1].warningMarkerPercents == [])
+    }
+}
diff --git a/Tests/CodexBarTests/MiniMaxProviderTests.swift b/Tests/CodexBarTests/MiniMaxProviderTests.swift
index ff9eb83970..03dd11c874 100644
--- a/Tests/CodexBarTests/MiniMaxProviderTests.swift
+++ b/Tests/CodexBarTests/MiniMaxProviderTests.swift
@@ -2,38 +2,265 @@ import Foundation
 import Testing
 @testable import CodexBarCore
 
-@Suite
+struct MiniMaxAPISettingsReaderTests {
+    @Test
+    func `api token prefers coding plan specific environment key`() {
+        let token = MiniMaxAPISettingsReader.apiToken(environment: [
+            "MINIMAX_API_KEY": "sk-api-standard",
+            "MINIMAX_CODING_API_KEY": "sk-cp-coding-plan",
+        ])
+
+        #expect(token == "sk-cp-coding-plan")
+        #expect(MiniMaxAPISettingsReader.apiKeyKind(token: token) == .codingPlan)
+    }
+
+    @Test
+    func `api token falls back to generic environment key`() {
+        let token = MiniMaxAPISettingsReader.apiToken(environment: [
+            "MINIMAX_API_KEY": "\"sk-api-standard\"",
+        ])
+
+        #expect(token == "sk-api-standard")
+        #expect(MiniMaxAPISettingsReader.apiKeyKind(token: token) == .standard)
+    }
+}
+
+struct MiniMaxEndpointOverrideSettingsTests {
+    @Test
+    func `strict endpoint overrides reject non MiniMax hosts`() {
+        let env = [
+            MiniMaxSettingsReader.requireProviderEndpointOverridesKey: "true",
+            MiniMaxSettingsReader.hostKey: "https://attacker.example",
+            MiniMaxSettingsReader.codingPlanURLKey: "https://attacker.example/coding-plan",
+            MiniMaxSettingsReader.remainsURLKey: "https://attacker.example/remains",
+            MiniMaxSettingsReader.billingHistoryURLKey: "https://attacker.example/account/amount",
+        ]
+
+        #expect(MiniMaxSettingsReader.hostOverride(environment: env) == nil)
+        #expect(MiniMaxSettingsReader.codingPlanURL(environment: env) == nil)
+        #expect(MiniMaxSettingsReader.remainsURL(environment: env) == nil)
+        #expect(MiniMaxSettingsReader.billingHistoryURL(environment: env) == nil)
+    }
+
+    @Test
+    func `endpoint overrides reject encoded host delimiters before suffix matching`() {
+        let encodedSlash = "https://attacker.example%2f.platform.minimax.io"
+        let doubleEncodedSlash = "https://attacker.example%252f.platform.minimax.io"
+        let env = [
+            MiniMaxSettingsReader.hostKey: encodedSlash,
+            MiniMaxSettingsReader.codingPlanURLKey: "\(encodedSlash)/coding-plan",
+            MiniMaxSettingsReader.remainsURLKey: "\(encodedSlash)/remains",
+            MiniMaxSettingsReader.billingHistoryURLKey: "\(encodedSlash)/account/amount",
+        ]
+
+        #expect(MiniMaxSettingsReader.hostOverride(environment: env) == nil)
+        #expect(MiniMaxSettingsReader.codingPlanURL(environment: env) == nil)
+        #expect(MiniMaxSettingsReader.remainsURL(environment: env) == nil)
+        #expect(MiniMaxSettingsReader.billingHistoryURL(environment: env) == nil)
+        #expect(MiniMaxSettingsReader.hostOverride(environment: [
+            MiniMaxSettingsReader.hostKey: doubleEncodedSlash,
+        ]) == nil)
+    }
+
+    @Test
+    func `endpoint overrides reject whitespace and control characters in hosts`() {
+        for host in ["https://bad host", "https://bad%20host", "https://bad%09host"] {
+            #expect(MiniMaxSettingsReader.hostOverride(environment: [
+                MiniMaxSettingsReader.hostKey: host,
+            ]) == nil)
+            #expect(MiniMaxSettingsReader.remainsURL(environment: [
+                MiniMaxSettingsReader.remainsURLKey: "\(host)/remains",
+            ]) == nil)
+        }
+    }
+
+    @Test
+    func `endpoint overrides require https and no userinfo`() {
+        #expect(MiniMaxSettingsReader.hostOverride(environment: [
+            MiniMaxSettingsReader.hostKey: "http://platform.minimax.io",
+        ]) == nil)
+        #expect(MiniMaxSettingsReader.remainsURL(environment: [
+            MiniMaxSettingsReader.remainsURLKey: "https://user:pass@platform.minimax.io/remains",
+        ]) == nil)
+        #expect(MiniMaxSettingsReader.rejectedEndpointOverrideKey(environment: [
+            MiniMaxSettingsReader.hostKey: ":443",
+        ]) == MiniMaxSettingsReader.hostKey)
+    }
+
+    @Test
+    func `endpoint overrides allow MiniMax and custom https hosts`() {
+        let env = [
+            MiniMaxSettingsReader.hostKey: "platform.minimaxi.com",
+            MiniMaxSettingsReader.remainsURLKey: "https://platform.minimax.io/custom/remains",
+        ]
+
+        #expect(MiniMaxSettingsReader.hostOverride(environment: env) == "platform.minimaxi.com")
+        #expect(MiniMaxSettingsReader.remainsURL(environment: env)?.host == "platform.minimax.io")
+
+        let customEnv = [
+            MiniMaxSettingsReader.hostKey: "proxy.example.test",
+            MiniMaxSettingsReader.remainsURLKey: "https://proxy.example.test/custom/remains",
+        ]
+        #expect(MiniMaxSettingsReader.hostOverride(environment: customEnv) == "proxy.example.test")
+        #expect(MiniMaxSettingsReader.remainsURL(environment: customEnv)?.host == "proxy.example.test")
+        #expect(MiniMaxSettingsReader.rejectedEndpointOverrideKey(environment: customEnv) == nil)
+    }
+
+    @Test
+    func `host endpoint overrides preserve explicit port`() {
+        let env = [MiniMaxSettingsReader.hostKey: "proxy.example.test:8443"]
+
+        #expect(MiniMaxSettingsReader.hostOverride(environment: env) == "proxy.example.test:8443")
+        #expect(
+            MiniMaxUsageFetcher.resolveCodingPlanURL(region: .global, environment: env).absoluteString ==
+                "https://proxy.example.test:8443/user-center/payment/coding-plan?cycle_type=3")
+        #expect(
+            MiniMaxUsageFetcher.resolveRemainsURL(region: .global, environment: env).absoluteString ==
+                "https://proxy.example.test:8443/v1/api/openplatform/coding_plan/remains")
+    }
+
+    @Test
+    func `subscription metadata accepts host names beginning with http`() throws {
+        let url = try MiniMaxSubscriptionMetadataFetcher.resolveComboURL(
+            region: .global,
+            environment: [MiniMaxSettingsReader.hostKey: "https://http-proxy.example.test"])
+
+        #expect(url.host == "http-proxy.example.test")
+        #expect(url.scheme == "https")
+    }
+
+    @Test
+    func `scheme less endpoint preserves colon in path`() {
+        let env = [MiniMaxSettingsReader.remainsURLKey: "proxy.example.test/api:v1"]
+
+        #expect(
+            MiniMaxSettingsReader.remainsURL(environment: env)?.absoluteString ==
+                "https://proxy.example.test/api:v1")
+    }
+
+    @Test
+    func `custom https endpoints allow bracketed IPv6 literals`() {
+        let env = [
+            MiniMaxSettingsReader.hostKey: "[::1]:8443",
+            MiniMaxSettingsReader.remainsURLKey: "https://[::1]:8443/remains",
+        ]
+
+        #expect(MiniMaxSettingsReader.hostOverride(environment: env) == "[::1]:8443")
+        #expect(MiniMaxSettingsReader.remainsURL(environment: env)?.host == "::1")
+        #expect(MiniMaxSettingsReader.rejectedEndpointOverrideKey(environment: env) == nil)
+    }
+
+    @Test
+    func `strict provider endpoint mode rejects custom hosts`() {
+        let env = [
+            MiniMaxSettingsReader.requireProviderEndpointOverridesKey: "true",
+            MiniMaxSettingsReader.hostKey: "proxy.example.test",
+            MiniMaxSettingsReader.remainsURLKey: "https://proxy.example.test/custom/remains",
+        ]
+
+        #expect(MiniMaxSettingsReader.hostOverride(environment: env) == nil)
+        #expect(MiniMaxSettingsReader.remainsURL(environment: env) == nil)
+        #expect(MiniMaxSettingsReader.rejectedEndpointOverrideKey(environment: env) == MiniMaxSettingsReader.hostKey)
+    }
+
+    @Test
+    func `custom https compatibility mode still rejects http and userinfo`() {
+        #expect(MiniMaxSettingsReader.hostOverride(environment: [
+            MiniMaxSettingsReader.hostKey: "http://proxy.example.test",
+        ]) == nil)
+        #expect(MiniMaxSettingsReader.rejectedEndpointOverrideKey(environment: [
+            MiniMaxSettingsReader.remainsURLKey: "https://user:pass@proxy.example.test/remains",
+        ]) == MiniMaxSettingsReader.remainsURLKey)
+    }
+
+    @Test
+    func `explicit endpoint override rejects invalid scheme before network`() async {
+        await #expect(throws: ProviderEndpointOverrideError.minimax(MiniMaxSettingsReader.codingPlanURLKey)) {
+            _ = try await MiniMaxUsageFetcher.fetchUsage(
+                cookieHeader: "session=abc123",
+                environment: [MiniMaxSettingsReader.codingPlanURLKey: "http://platform.minimax.io/coding-plan"],
+                includeBillingHistory: false)
+        }
+    }
+}
+
+struct MiniMaxProviderStrategyTests {
+    private struct StubClaudeFetcher: ClaudeUsageFetching {
+        func loadLatestUsage(model _: String) async throws -> ClaudeUsageSnapshot {
+            throw ClaudeUsageError.parseFailed("stub")
+        }
+
+        func debugRawProbe(model _: String) async -> String {
+            "stub"
+        }
+
+        func detectVersion() -> String? {
+            nil
+        }
+    }
+
+    @Test
+    func `browser cookie import is user initiated app only`() {
+        let appContext = self.makeContext(runtime: .app)
+        let cliContext = self.makeContext(runtime: .cli)
+
+        #expect(MiniMaxCodingPlanFetchStrategy.allowsBrowserCookieImport(context: appContext) == false)
+        #expect(MiniMaxCodingPlanFetchStrategy.allowsBrowserCookieImport(context: cliContext) == false)
+
+        ProviderInteractionContext.$current.withValue(.userInitiated) {
+            #expect(MiniMaxCodingPlanFetchStrategy.allowsBrowserCookieImport(context: appContext))
+            #expect(MiniMaxCodingPlanFetchStrategy.allowsBrowserCookieImport(context: cliContext) == false)
+        }
+    }
+
+    private func makeContext(runtime: ProviderRuntime) -> ProviderFetchContext {
+        let env: [String: String] = [:]
+        return ProviderFetchContext(
+            runtime: runtime,
+            sourceMode: .web,
+            includeCredits: false,
+            webTimeout: 1,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: env,
+            settings: nil,
+            fetcher: UsageFetcher(environment: env),
+            claudeFetcher: StubClaudeFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0))
+    }
+}
+
 struct MiniMaxCookieHeaderTests {
     @Test
-    func normalizesRawCookieHeader() {
+    func `normalizes raw cookie header`() {
         let raw = "foo=bar; session=abc123"
         let normalized = MiniMaxCookieHeader.normalized(from: raw)
         #expect(normalized == "foo=bar; session=abc123")
     }
 
     @Test
-    func extractsFromCookieHeaderLine() {
+    func `extracts from cookie header line`() {
         let raw = "Cookie: foo=bar; session=abc123"
         let normalized = MiniMaxCookieHeader.normalized(from: raw)
         #expect(normalized == "foo=bar; session=abc123")
     }
 
     @Test
-    func extractsFromCurlHeader() {
+    func `extracts from curl header`() {
         let raw = "curl https://platform.minimax.io -H 'Cookie: foo=bar; session=abc123' -H 'accept: */*'"
         let normalized = MiniMaxCookieHeader.normalized(from: raw)
         #expect(normalized == "foo=bar; session=abc123")
     }
 
     @Test
-    func extractsFromCurlCookieFlag() {
+    func `extracts from curl cookie flag`() {
         let raw = "curl https://platform.minimax.io --cookie 'foo=bar; session=abc123'"
         let normalized = MiniMaxCookieHeader.normalized(from: raw)
         #expect(normalized == "foo=bar; session=abc123")
     }
 
     @Test
-    func extractsAuthAndGroupIDFromCurl() {
+    func `extracts auth and group ID from curl`() {
         let raw = """
         curl 'https://platform.minimax.io/v1/api/openplatform/coding_plan/remains?GroupId=123456' \
           -H 'authorization: Bearer token123' \
@@ -46,7 +273,7 @@ struct MiniMaxCookieHeaderTests {
     }
 
     @Test
-    func extractsAuthFromUppercaseHeader() {
+    func `extracts auth from uppercase header`() {
         let raw = """
         curl 'https://platform.minimax.io/v1/api/openplatform/coding_plan/remains?GROUP_ID=98765' \
           -H 'Authorization: Bearer token-abc' \
@@ -56,12 +283,154 @@ struct MiniMaxCookieHeaderTests {
         #expect(override?.authorizationToken == "token-abc")
         #expect(override?.groupID == "98765")
     }
+
+    @Test
+    func `extracts group ID from combo curl header and cookie`() {
+        let raw = """
+        curl 'https://www.minimaxi.com/v1/api/openplatform/charge/combo/cycle_audio_resource_package' \
+          -b 'foo=bar; minimax_group_id_v2=2013894056999916075' \
+          -H 'x-group-id: 2013894056999916075'
+        """
+        let override = MiniMaxCookieHeader.override(from: raw)
+        #expect(override?.cookieHeader == "foo=bar; minimax_group_id_v2=2013894056999916075")
+        #expect(override?.groupID == "2013894056999916075")
+    }
 }
 
-@Suite
 struct MiniMaxUsageParserTests {
     @Test
-    func parsesCodingPlanSnapshot() throws {
+    func `signed out check ignores login copy inside scripts`() {
+        let html = """
+        <html>
+          <head>
+            <script id="__NEXT_DATA__" type="application/json">
+              {
+                "props": {
+                  "pageProps": {
+                    "_nextI18Next": {
+                      "initialI18nStore": {
+                        "zh": {
+                          "common": {
+                            "landing_common_login": "登录",
+                            "login": "Log in"
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            </script>
+          </head>
+          <body><div id="__next">Coding Plan</div></body>
+        </html>
+        """
+
+        #expect(!MiniMaxUsageFetcher._looksSignedOutForTesting(html: html))
+    }
+
+    @Test
+    func `signed out check still detects visible login copy`() {
+        let html = """
+        <html>
+          <head><script>{"landing_common_login":"登录"}</script></head>
+          <body><main><a>Log in</a></main></body>
+        </html>
+        """
+
+        #expect(MiniMaxUsageFetcher._looksSignedOutForTesting(html: html))
+    }
+
+    @Test
+    func `parses planName from concrete fields in remains response`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+
+        // 1. plan_name
+        let jsonPlanName = """
+        {
+          "base_resp": { "status_code": 0 },
+          "plan_name": "MiniMax Star",
+          "model_remains": [{"model_name": "abab6.5"}]
+        }
+        """
+        let snapshot1 = try MiniMaxUsageParser.parseCodingPlanRemains(data: Data(jsonPlanName.utf8), now: now)
+        #expect(snapshot1.planName == "MiniMax Star")
+
+        // 2. current_plan_title
+        let jsonCurrentPlan = """
+        {
+          "base_resp": { "status_code": 0 },
+          "current_plan_title": "Coding Plan Pro",
+          "model_remains": [{"model_name": "abab6.5"}]
+        }
+        """
+        let snapshot2 = try MiniMaxUsageParser.parseCodingPlanRemains(data: Data(jsonCurrentPlan.utf8), now: now)
+        #expect(snapshot2.planName == "Coding Plan Pro")
+
+        // 3. current_subscribe_title
+        let jsonSubscribe = """
+        {
+          "base_resp": { "status_code": 0 },
+          "current_subscribe_title": "Max",
+          "model_remains": [{"model_name": "abab6.5"}]
+        }
+        """
+        let snapshot3 = try MiniMaxUsageParser.parseCodingPlanRemains(data: Data(jsonSubscribe.utf8), now: now)
+        #expect(snapshot3.planName == "Max")
+
+        // 4. combo_title
+        let jsonCombo = """
+        {
+          "base_resp": { "status_code": 0 },
+          "combo_title": "Combo Star",
+          "model_remains": [{"model_name": "abab6.5"}]
+        }
+        """
+        let snapshot4 = try MiniMaxUsageParser.parseCodingPlanRemains(data: Data(jsonCombo.utf8), now: now)
+        #expect(snapshot4.planName == "Combo Star")
+
+        // 5. current_combo_card.title
+        let jsonComboCard = """
+        {
+          "base_resp": { "status_code": 0 },
+          "current_combo_card": { "title": "Card Title" },
+          "model_remains": [{"model_name": "abab6.5"}]
+        }
+        """
+        let snapshot5 = try MiniMaxUsageParser.parseCodingPlanRemains(data: Data(jsonComboCard.utf8), now: now)
+        #expect(snapshot5.planName == "Card Title")
+    }
+
+    @Test
+    func `toUsageSnapshot maps planName to loginMethod`() {
+        let now = Date()
+        let snapshot1 = MiniMaxUsageSnapshot(
+            planName: "MiniMax Star",
+            availablePrompts: nil,
+            currentPrompts: nil,
+            remainingPrompts: nil,
+            windowMinutes: nil,
+            usedPercent: nil,
+            resetsAt: nil,
+            updatedAt: now)
+        let usage1 = snapshot1.toUsageSnapshot()
+        #expect(usage1.identity?.loginMethod == "MiniMax Star")
+
+        let snapshot2 = MiniMaxUsageSnapshot(
+            planName: nil,
+            availablePrompts: nil,
+            currentPrompts: nil,
+            remainingPrompts: nil,
+            windowMinutes: nil,
+            usedPercent: nil,
+            resetsAt: nil,
+            updatedAt: now)
+        let usage2 = snapshot2.toUsageSnapshot()
+        #expect(usage2.identity?.loginMethod == nil)
+    }
+
+    @Test
+    func `parses coding plan snapshot`() throws {
         let now = Date(timeIntervalSince1970: 1_700_000_000)
         let html = """
         <div>Coding Plan</div>
@@ -85,7 +454,7 @@ struct MiniMaxUsageParserTests {
     }
 
     @Test
-    func parsesCodingPlanRemainsResponse() throws {
+    func `parses coding plan remains response`() throws {
         let now = Date(timeIntervalSince1970: 1_700_000_000)
         let start = 1_700_000_000_000
         let end = start + 5 * 60 * 60 * 1000
@@ -118,7 +487,159 @@ struct MiniMaxUsageParserTests {
     }
 
     @Test
-    func parsesCodingPlanRemainsFromDataWrapper() throws {
+    func `parses model remains services using used quota semantics`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let start = 1_700_000_000_000
+        let end = start + 5 * 60 * 60 * 1000
+        let json = """
+        {
+          "base_resp": { "status_code": 0 },
+          "current_subscribe_title": "Max",
+          "model_remains": [
+            {
+              "model_name": "M2.7-highspeed",
+              "current_interval_total_count": 1000,
+              "current_interval_usage_count": 250,
+              "start_time": \(start),
+              "end_time": \(end),
+              "remains_time": 240000
+            }
+          ]
+        }
+        """
+
+        let snapshot = try MiniMaxUsageParser.parseCodingPlanRemains(data: Data(json.utf8), now: now)
+        let service = try #require(snapshot.services?.first)
+
+        #expect(service.displayName == "Text Generation")
+        #expect(service.usage == 750)
+        #expect(service.remaining == 250)
+        #expect(service.limit == 1000)
+        #expect(service.percent == 75)
+        #expect(snapshot.toUsageSnapshot().primary?.usedPercent == 75)
+    }
+
+    @Test
+    func `text generation includes weekly window when provided`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let start = 1_700_000_000_000
+        let end = start + 5 * 60 * 60 * 1000
+        let weekStart = start - 2 * 24 * 60 * 60 * 1000
+        let weekEnd = weekStart + 7 * 24 * 60 * 60 * 1000
+        let json = """
+        {
+          "base_resp": { "status_code": 0 },
+          "model_remains": [
+            {
+              "model_name": "MiniMax-M1",
+              "current_interval_total_count": 1000,
+              "current_interval_usage_count": 250,
+              "start_time": \(start),
+              "end_time": \(end),
+              "current_weekly_total_count": 6000,
+              "current_weekly_usage_count": 5376,
+              "weekly_start_time": \(weekStart),
+              "weekly_end_time": \(weekEnd)
+            }
+          ]
+        }
+        """
+        let snapshot = try MiniMaxUsageParser.parseCodingPlanRemains(data: Data(json.utf8), now: now)
+        let services = try #require(snapshot.services)
+        #expect(services.count == 2)
+        #expect(services[0].serviceType == "Text Generation")
+        #expect(services[0].windowType == "5 hours")
+        #expect(services[1].serviceType == "Text Generation")
+        #expect(services[1].windowType == "Weekly")
+        #expect(services[1].usage == 624)
+        #expect(services[1].limit == 6000)
+        #expect(services[1].timeRange.contains("/"))
+        #expect(services[1].timeRange.contains("UTC+8"))
+        #expect(!services[1].timeRange.hasPrefix("10:00-10:00"))
+    }
+
+    @Test
+    func `legacy plan hides weekly when weekly total is missing or zero`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let start = 1_700_000_000_000
+        let end = start + 5 * 60 * 60 * 1000
+        let json = """
+        {
+          "base_resp": { "status_code": 0 },
+          "model_remains": [
+            {
+              "model_name": "MiniMax-M1",
+              "current_interval_total_count": 1000,
+              "current_interval_usage_count": 250,
+              "start_time": \(start),
+              "end_time": \(end),
+              "current_weekly_total_count": 0,
+              "current_weekly_usage_count": 0
+            }
+          ]
+        }
+        """
+        let snapshot = try MiniMaxUsageParser.parseCodingPlanRemains(data: Data(json.utf8), now: now)
+        let services = try #require(snapshot.services)
+        #expect(services.count == 1)
+        #expect(services[0].windowType == "5 hours")
+    }
+
+    @Test
+    func `parses multi service payload and utc offset reset`() throws {
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = try #require(TimeZone(secondsFromGMT: 8 * 3600))
+        let now = try #require(calendar.date(from: DateComponents(
+            year: 2026,
+            month: 3,
+            day: 25,
+            hour: 11,
+            minute: 0)))
+        let expectedReset = try #require(calendar.date(from: DateComponents(
+            year: 2026,
+            month: 3,
+            day: 25,
+            hour: 15,
+            minute: 0)))
+        let json = """
+        {
+          "data": {
+            "services": [
+              {
+                "service_type": "Text Generation",
+                "window_type": "5 hours",
+                "time_range": "10:00-15:00(UTC+8)",
+                "usage": 2,
+                "limit": 10
+              },
+              {
+                "service_type": "Image",
+                "window_type": "Today",
+                "time_range": "2026/03/25 00:00 - 2026/03/26 00:00",
+                "usage": "5",
+                "limit": "50",
+                "percent": "10"
+              }
+            ]
+          }
+        }
+        """
+
+        let snapshot = try MiniMaxUsageParser.parseCodingPlanRemains(data: Data(json.utf8), now: now)
+        let services = try #require(snapshot.services)
+
+        #expect(services.count == 2)
+        #expect(services[0].usage == 2)
+        #expect(services[0].remaining == 8)
+        #expect(services[0].percent == 20)
+        #expect(services[0].resetsAt == expectedReset)
+        #expect(services[1].usage == 5)
+        #expect(services[1].remaining == 45)
+        #expect(services[1].percent == 10)
+    }
+
+    @Test
+    func `parses coding plan remains from data wrapper`() throws {
         let now = Date(timeIntervalSince1970: 1_700_000_100)
         let start = 1_700_000_000_000
         let end = start + 5 * 60 * 60 * 1000
@@ -154,7 +675,7 @@ struct MiniMaxUsageParserTests {
     }
 
     @Test
-    func parsesCodingPlanFromNextData() throws {
+    func `parses coding plan from next data`() throws {
         let now = Date(timeIntervalSince1970: 1_700_000_000)
         let start = 1_700_000_000_000
         let end = start + 5 * 60 * 60 * 1000
@@ -198,7 +719,7 @@ struct MiniMaxUsageParserTests {
     }
 
     @Test
-    func parsesHTMLWithUsedPrefixAndResetTime() throws {
+    func `parses HTML with used prefix and reset time`() throws {
         var calendar = Calendar(identifier: .gregorian)
         calendar.timeZone = TimeZone(identifier: "UTC") ?? .current
         let now = try #require(calendar.date(from: DateComponents(year: 2025, month: 1, day: 1, hour: 10, minute: 0)))
@@ -226,7 +747,7 @@ struct MiniMaxUsageParserTests {
     }
 
     @Test
-    func throwsOnMissingCookieResponse() {
+    func `throws on missing cookie response`() {
         let json = """
         {
           "base_resp": { "status_code": 1004, "status_msg": "cookie is missing, log in again" }
@@ -239,7 +760,7 @@ struct MiniMaxUsageParserTests {
     }
 
     @Test
-    func throwsOnStringStatusCodeWhenLoggedOut() {
+    func `throws on string status code when logged out`() {
         let json = """
         {
           "base_resp": { "status_code": "1004", "status_msg": "login required" }
@@ -252,7 +773,7 @@ struct MiniMaxUsageParserTests {
     }
 
     @Test
-    func throwsOnErrorInDataWrapper() {
+    func `throws on error in data wrapper`() {
         let json = """
         {
           "data": {
@@ -265,12 +786,385 @@ struct MiniMaxUsageParserTests {
             try MiniMaxUsageParser.parseCodingPlanRemains(data: Data(json.utf8))
         }
     }
+
+    @Test
+    func `billing history aggregates records locally`() throws {
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = try #require(TimeZone(secondsFromGMT: 0))
+        let now = try #require(ISO8601DateFormatter().date(from: "2026-05-17T12:00:00Z"))
+        let json = """
+        {
+          "base_resp": { "status_code": 0 },
+          "consume_token_sum": 999999,
+          "total_cnt": 4,
+          "charge_records": [
+            {
+              "consume_token": 1000,
+              "consume_cash_after_voucher": 1.25,
+              "ymd": "2026-05-17",
+              "method": "chat",
+              "model": "MiniMax-M1"
+            },
+            {
+              "consume_token": "2000",
+              "consume_cash": "2.50",
+              "ymd": "2026-05-16",
+              "method": "chat",
+              "model": "MiniMax-M2"
+            },
+            {
+              "consume_input_token": 1200,
+              "consume_output_token": 1800,
+              "ymd": "2026-04-18",
+              "method": "audio",
+              "model": "speech-2.8"
+            },
+            {
+              "consume_token": 4000,
+              "ymd": "2026-04-17",
+              "method": "old",
+              "model": "ignored"
+            }
+          ]
+        }
+        """
+
+        let summary = try MiniMaxBillingHistoryParser.parse(
+            data: Data(json.utf8),
+            now: now,
+            calendar: calendar)
+
+        #expect(summary.todayTokens == 1000)
+        #expect(summary.last30DaysTokens == 6000)
+        #expect(summary.todayCash == 1.25)
+        #expect(summary.last30DaysCash == 3.75)
+        #expect(summary.daily.map(\.day) == ["2026-04-18", "2026-05-16", "2026-05-17"])
+        #expect(summary.topMethods.first?.name == "audio")
+        #expect(summary.topModels.first?.name == "speech-2.8")
+    }
+
+    @Test
+    func `billing history preserves date only days in local calendar`() throws {
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = try #require(TimeZone(secondsFromGMT: -7 * 60 * 60))
+        let now = try #require(ISO8601DateFormatter().date(from: "2026-05-17T12:00:00Z"))
+        let json = """
+        {
+          "base_resp": { "status_code": 0 },
+          "total_cnt": 1,
+          "charge_records": [
+            {
+              "consume_token": 1234,
+              "ymd": "2026-05-17",
+              "method": "chat",
+              "model": "MiniMax-M1"
+            }
+          ]
+        }
+        """
+
+        let summary = try MiniMaxBillingHistoryParser.parse(
+            data: Data(json.utf8),
+            now: now,
+            calendar: calendar)
+
+        #expect(summary.todayTokens == 1234)
+        #expect(summary.daily.map(\.day) == ["2026-05-17"])
+    }
+
+    @Test
+    func `billing history filters failed records`() throws {
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = try #require(TimeZone(secondsFromGMT: 0))
+        let now = try #require(ISO8601DateFormatter().date(from: "2026-05-17T12:00:00Z"))
+        let json = """
+        {
+          "base_resp": { "status_code": 0 },
+          "total_cnt": 5,
+          "charge_records": [
+            {
+              "consume_token": 1000,
+              "ymd": "2026-05-17",
+              "method": "chat",
+              "model": "MiniMax-M1",
+              "result": "SUCCESS"
+            },
+            {
+              "consume_token": 2000,
+              "ymd": "2026-05-17",
+              "method": "chat",
+              "model": "MiniMax-M1",
+              "result": "FAILED"
+            },
+            {
+              "consume_token": 3000,
+              "ymd": "2026-05-17",
+              "method": "chat",
+              "model": "MiniMax-M1",
+              "status": "fail"
+            },
+            {
+              "consume_token": 4000,
+              "ymd": "2026-05-17",
+              "method": "audio",
+              "model": "speech-2.8"
+            },
+            {
+              "consume_token": 5000,
+              "ymd": "2026-05-17",
+              "method": "video",
+              "model": "video-1",
+              "status": 0
+            }
+          ]
+        }
+        """
+
+        let summary = try MiniMaxBillingHistoryParser.parse(
+            data: Data(json.utf8),
+            now: now,
+            calendar: calendar)
+
+        // Only SUCCESS (1000) and missing/empty result status (4000) should be included.
+        // FAILED (2000), status "fail" (3000), and numeric status 0 (5000) should be skipped.
+        #expect(summary.todayTokens == 5000)
+        #expect(summary.last30DaysTokens == 5000)
+        #expect(summary.daily.map(\.day) == ["2026-05-17"])
+
+        // Top methods should aggregate only SUCCESS/missing records.
+        #expect(summary.topMethods.count == 2)
+        #expect(summary.topMethods[0].name == "audio")
+        #expect(summary.topMethods[0].tokens == 4000)
+        #expect(summary.topMethods[1].name == "chat")
+        #expect(summary.topMethods[1].tokens == 1000)
+    }
+
+    @Test
+    func `web usage fetch attaches billing history when available`() async throws {
+        let now = try #require(ISO8601DateFormatter().date(from: "2026-05-17T12:00:00Z"))
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            if url.path.contains("coding-plan") {
+                return Self.httpResponse(
+                    url: url,
+                    body: Self.codingPlanJSON,
+                    contentType: "application/json")
+            }
+            #expect(url.path == "/account/amount")
+            #expect(url.query?.contains("aggregate=false") == true)
+            #expect(request.value(forHTTPHeaderField: "Cookie") == "HERTZ-SESSION=abc")
+            let body = """
+            {
+              "base_resp": { "status_code": 0 },
+              "total_cnt": 1,
+              "charge_records": [
+                {
+                  "consume_token": 1234,
+                  "ymd": "2026-05-17",
+                  "method": "chat",
+                  "model": "MiniMax-M1"
+                }
+              ]
+            }
+            """
+            return Self.httpResponse(url: url, body: body, contentType: "application/json")
+        }
+
+        let snapshot = try await MiniMaxUsageFetcher.fetchUsage(
+            cookieHeader: "HERTZ-SESSION=abc",
+            region: .global,
+            environment: [:],
+            session: transport,
+            now: now)
+
+        #expect(snapshot.currentPrompts == 2)
+        #expect(snapshot.billingSummary?.todayTokens == 1234)
+        #expect(snapshot.billingSummary?.last30DaysTokens == 1234)
+    }
+
+    @Test
+    func `web usage fetch keeps paginating billing history until 30 day cutoff`() async throws {
+        let now = try #require(ISO8601DateFormatter().date(from: "2026-05-17T12:00:00Z"))
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            if url.path.contains("coding-plan") {
+                return Self.httpResponse(
+                    url: url,
+                    body: Self.codingPlanJSON,
+                    contentType: "application/json")
+            }
+            let page = URLComponents(url: url, resolvingAgainstBaseURL: false)?
+                .queryItems?
+                .first { $0.name == "page" }?
+                .value ?? "1"
+            let recordDay = page == "3" ? "2026-04-17" : "2026-05-17"
+            let records = (0..<100)
+                .map { _ in
+                    """
+                    {"consume_token":1,"ymd":"\(recordDay)","method":"chat","model":"MiniMax-M1"}
+                    """
+                }
+                .joined(separator: ",")
+            let body = """
+            {
+              "base_resp": { "status_code": 0 },
+              "total_cnt": 250,
+              "charge_records": [\(records)]
+            }
+            """
+            return Self.httpResponse(url: url, body: body, contentType: "application/json")
+        }
+
+        let snapshot = try await MiniMaxUsageFetcher.fetchUsage(
+            cookieHeader: "HERTZ-SESSION=abc",
+            region: .global,
+            environment: [:],
+            session: transport,
+            now: now)
+
+        let billingRequests = await transport.requests().filter { $0.url?.path == "/account/amount" }
+        #expect(billingRequests.count == 3)
+        #expect(snapshot.billingSummary?.last30DaysTokens == 200)
+    }
+
+    @Test
+    func `web usage fetch skips billing history when optional usage is disabled`() async throws {
+        let now = try #require(ISO8601DateFormatter().date(from: "2026-05-17T12:00:00Z"))
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            #expect(url.path.contains("coding-plan"))
+            return Self.httpResponse(
+                url: url,
+                body: Self.codingPlanJSON,
+                contentType: "application/json")
+        }
+
+        let snapshot = try await MiniMaxUsageFetcher.fetchUsage(
+            cookieHeader: "HERTZ-SESSION=abc",
+            region: .global,
+            environment: [:],
+            includeBillingHistory: false,
+            session: transport,
+            now: now)
+
+        let requests = await transport.requests()
+        #expect(snapshot.currentPrompts == 2)
+        #expect(snapshot.billingSummary == nil)
+        #expect(requests.count == 1)
+    }
+
+    @Test
+    func `web usage fetch keeps quota when billing history is forbidden`() async throws {
+        let now = try #require(ISO8601DateFormatter().date(from: "2026-05-17T12:00:00Z"))
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            if url.path.contains("coding-plan") {
+                return Self.httpResponse(
+                    url: url,
+                    body: Self.codingPlanJSON,
+                    contentType: "application/json")
+            }
+            return Self.httpResponse(url: url, body: "{}", statusCode: 403, contentType: "application/json")
+        }
+
+        let snapshot = try await MiniMaxUsageFetcher.fetchUsage(
+            cookieHeader: "HERTZ-SESSION=abc",
+            region: .global,
+            environment: [:],
+            session: transport,
+            now: now)
+
+        #expect(snapshot.currentPrompts == 2)
+        #expect(snapshot.billingSummary == nil)
+    }
+
+    @Test
+    func `web usage fetch preserves stale bearer failure during billing history`() async throws {
+        let now = try #require(ISO8601DateFormatter().date(from: "2026-05-17T12:00:00Z"))
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            if url.path.contains("coding-plan") {
+                return Self.httpResponse(
+                    url: url,
+                    body: Self.codingPlanJSON,
+                    contentType: "application/json")
+            }
+            #expect(request.value(forHTTPHeaderField: "Authorization") == "Bearer stale")
+            return Self.httpResponse(url: url, body: "{}", statusCode: 403, contentType: "application/json")
+        }
+
+        await #expect(throws: MiniMaxUsageError.invalidCredentials) {
+            try await MiniMaxUsageFetcher.fetchUsage(
+                cookieHeader: "HERTZ-SESSION=abc",
+                authorizationToken: "stale",
+                region: .global,
+                environment: [:],
+                session: transport,
+                now: now)
+        }
+    }
+
+    @Test
+    func `web usage fetch preserves billing history cancellation`() async throws {
+        let now = try #require(ISO8601DateFormatter().date(from: "2026-05-17T12:00:00Z"))
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            if url.path.contains("coding-plan") {
+                return Self.httpResponse(
+                    url: url,
+                    body: Self.codingPlanJSON,
+                    contentType: "application/json")
+            }
+            throw CancellationError()
+        }
+
+        await #expect(throws: CancellationError.self) {
+            try await MiniMaxUsageFetcher.fetchUsage(
+                cookieHeader: "HERTZ-SESSION=abc",
+                region: .global,
+                environment: [:],
+                session: transport,
+                now: now)
+        }
+    }
+
+    private static let codingPlanJSON = """
+    {
+      "base_resp": { "status_code": 0 },
+      "data": {
+        "plan_name": "Max",
+        "model_remains": [
+          {
+            "model_name": "MiniMax-M1",
+            "current_interval_total_count": 10,
+            "current_interval_usage_count": 8,
+            "start_time": 1779019200,
+            "end_time": 1779037200,
+            "remains_time": 3600
+          }
+        ]
+      }
+    }
+    """
+
+    private static func httpResponse(
+        url: URL,
+        body: String,
+        statusCode: Int = 200,
+        contentType: String) -> (Data, URLResponse)
+    {
+        let response = HTTPURLResponse(
+            url: url,
+            statusCode: statusCode,
+            httpVersion: "HTTP/1.1",
+            headerFields: ["Content-Type": contentType])!
+        return (Data(body.utf8), response)
+    }
 }
 
-@Suite
 struct MiniMaxAPIRegionTests {
     @Test
-    func defaultsToGlobalHosts() {
+    func `defaults to global hosts`() {
         let codingPlan = MiniMaxUsageFetcher.resolveCodingPlanURL(region: .global, environment: [:])
         let remains = MiniMaxUsageFetcher.resolveRemainsURL(region: .global, environment: [:])
         #expect(codingPlan.host == "platform.minimax.io")
@@ -278,7 +1172,7 @@ struct MiniMaxAPIRegionTests {
     }
 
     @Test
-    func usesChinaMainlandHosts() {
+    func `uses china mainland hosts`() {
         let codingPlan = MiniMaxUsageFetcher.resolveCodingPlanURL(region: .chinaMainland, environment: [:])
         let remains = MiniMaxUsageFetcher.resolveRemainsURL(region: .chinaMainland, environment: [:])
         #expect(codingPlan.host == "platform.minimaxi.com")
@@ -287,7 +1181,25 @@ struct MiniMaxAPIRegionTests {
     }
 
     @Test
-    func hostOverrideWinsForRemainsAndCodingPlan() {
+    func `resolves web remains fallback hosts`() {
+        let global = MiniMaxUsageFetcher.resolveRemainsURLs(region: .global, environment: [:])
+        let china = MiniMaxUsageFetcher.resolveRemainsURLs(region: .chinaMainland, environment: [:])
+
+        #expect(global.map(\.host).contains("platform.minimax.io"))
+        #expect(global.map(\.host).contains("www.minimax.io"))
+        #expect(china.map(\.host).contains("platform.minimaxi.com"))
+        #expect(china.map(\.host).contains("www.minimaxi.com"))
+    }
+
+    @Test
+    func `resolves official token plan remains URL`() {
+        let url = MiniMaxUsageFetcher.resolveTokenPlanRemainsURL(region: .chinaMainland)
+        #expect(url.host == "api.minimaxi.com")
+        #expect(url.path == "/v1/token_plan/remains")
+    }
+
+    @Test
+    func `host override wins for remains and coding plan`() {
         let env = [MiniMaxSettingsReader.hostKey: "api.minimaxi.com"]
         let codingPlan = MiniMaxUsageFetcher.resolveCodingPlanURL(region: .global, environment: env)
         let remains = MiniMaxUsageFetcher.resolveRemainsURL(region: .global, environment: env)
@@ -296,14 +1208,24 @@ struct MiniMaxAPIRegionTests {
     }
 
     @Test
-    func remainsUrlOverrideBeatsHost() {
+    func `billing history url uses account amount endpoint`() {
+        let url = MiniMaxUsageFetcher.resolveBillingHistoryURL(region: .chinaMainland, environment: [:], page: 2)
+        #expect(url.host == "platform.minimaxi.com")
+        #expect(url.path == "/account/amount")
+        #expect(url.query?.contains("page=2") == true)
+        #expect(url.query?.contains("limit=100") == true)
+        #expect(url.query?.contains("aggregate=false") == true)
+    }
+
+    @Test
+    func `remains url override beats host`() {
         let env = [MiniMaxSettingsReader.remainsURLKey: "https://platform.minimaxi.com/custom/remains"]
         let remains = MiniMaxUsageFetcher.resolveRemainsURL(region: .global, environment: env)
         #expect(remains.absoluteString == "https://platform.minimaxi.com/custom/remains")
     }
 
     @Test
-    func originUsesCodingPlanOverrideHost() {
+    func `origin uses coding plan override host`() {
         let env = [MiniMaxSettingsReader.codingPlanURLKey: "https://api.minimaxi.com/custom/path?cycle_type=3"]
         let codingPlan = MiniMaxUsageFetcher.resolveCodingPlanURL(region: .global, environment: env)
         let origin = MiniMaxUsageFetcher.originURL(from: codingPlan)
@@ -311,7 +1233,7 @@ struct MiniMaxAPIRegionTests {
     }
 
     @Test
-    func originStripsHostOverridePath() {
+    func `origin strips host override path`() {
         let env = [MiniMaxSettingsReader.hostKey: "https://api.minimaxi.com/custom/path"]
         let codingPlan = MiniMaxUsageFetcher.resolveCodingPlanURL(region: .global, environment: env)
         let origin = MiniMaxUsageFetcher.originURL(from: codingPlan)
diff --git a/Tests/CodexBarTests/MiniMaxTokenPlanChangeTests.swift b/Tests/CodexBarTests/MiniMaxTokenPlanChangeTests.swift
new file mode 100644
index 0000000000..b7a0045722
--- /dev/null
+++ b/Tests/CodexBarTests/MiniMaxTokenPlanChangeTests.swift
@@ -0,0 +1,791 @@
+import Foundation
+import Testing
+@testable import CodexBar
+@testable import CodexBarCore
+
+struct MiniMaxTokenPlanChangeTests {
+    @Test
+    func `parses percent based general token plan remains`() throws {
+        let now = Date(timeIntervalSince1970: 1_780_282_340)
+
+        let snapshot = try MiniMaxUsageParser.parseCodingPlanRemains(
+            data: Data(Self.percentBasedRemainsJSON.utf8),
+            now: now)
+        let services = try #require(snapshot.services)
+
+        #expect(snapshot.availablePrompts == nil)
+        #expect(snapshot.currentPrompts == nil)
+        #expect(snapshot.remainingPrompts == nil)
+        #expect(snapshot.usedPercent == 4)
+        #expect(services.count == 2)
+        #expect(services[0].serviceType == "general")
+        #expect(services[0].displayName == "General")
+        #expect(services[0].windowType == "5 hours")
+        #expect(services[0].usage == 4)
+        #expect(services[0].limit == 100)
+        #expect(services[0].percent == 4)
+        #expect(services[1].windowType == "Weekly")
+        #expect(services[1].usage == 1)
+        #expect(services[1].limit == 100)
+        #expect(services[1].percent == 1)
+
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary?.usedPercent == 4)
+        #expect(usage.primary?.windowMinutes == 300)
+        #expect(usage.secondary?.usedPercent == 1)
+        #expect(usage.secondary?.windowMinutes == 10080)
+    }
+
+    @Test
+    func `zero count fields do not suppress percent based quota windows`() throws {
+        let now = Date(timeIntervalSince1970: 1_780_282_340)
+        let json = """
+        {
+          "base_resp": { "status_code": "0" },
+          "data": {
+            "current_subscribe_title": "Token Plan · TokenPlanPlus-年度会员",
+            "points_balance": "14000",
+            "model_remains": [
+              {
+                "model_name": "general",
+                "current_interval_total_count": 0,
+                "current_interval_usage_count": 0,
+                "current_interval_remaining_percent": "96",
+                "start_time": 1780279200000,
+                "end_time": 1780297200000,
+                "current_weekly_total_count": 0,
+                "current_weekly_usage_count": 0,
+                "current_weekly_remaining_percent": "99",
+                "weekly_start_time": 1780243200000,
+                "weekly_end_time": 1780848000000
+              }
+            ]
+          }
+        }
+        """
+
+        let snapshot = try MiniMaxUsageParser.parseCodingPlanRemains(data: Data(json.utf8), now: now)
+
+        #expect(snapshot.planName == "Token Plan · TokenPlanPlus-年度会员")
+        #expect(snapshot.pointsBalance == 14000)
+        #expect(snapshot.services?.count == 2)
+        #expect(snapshot.toUsageSnapshot().providerCost?.used == 14000)
+    }
+
+    @Test
+    func `video first token plan still uses general quota as primary and weekly secondary`() throws {
+        let now = Date(timeIntervalSince1970: 1_780_282_340)
+        let json = """
+        {
+          "base_resp": { "status_code": "0" },
+          "model_remains": [
+            {
+              "model_name": "video",
+              "current_interval_total_count": 100,
+              "current_interval_usage_count": 70,
+              "current_interval_remaining_percent": 30,
+              "start_time": 1780243200000,
+              "end_time": 1780329600000
+            },
+            {
+              "model_name": "general",
+              "current_interval_total_count": 0,
+              "current_interval_usage_count": 0,
+              "current_interval_remaining_percent": 96,
+              "start_time": 1780279200000,
+              "end_time": 1780297200000,
+              "current_weekly_total_count": 0,
+              "current_weekly_usage_count": 0,
+              "current_weekly_remaining_percent": 99,
+              "weekly_start_time": 1780243200000,
+              "weekly_end_time": 1780848000000
+            }
+          ]
+        }
+        """
+
+        let snapshot = try MiniMaxUsageParser.parseCodingPlanRemains(data: Data(json.utf8), now: now)
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(snapshot.services?.map(\.serviceType) == ["video", "general", "general"])
+        #expect(usage.primary?.usedPercent == 4)
+        #expect(usage.primary?.windowMinutes == 300)
+        #expect(usage.secondary?.usedPercent == 1)
+        #expect(usage.secondary?.windowMinutes == 10080)
+        #expect(usage.tertiary?.usedPercent == 70)
+    }
+
+    @Test
+    func `plus token plan omits unavailable video quota lane`() throws {
+        let now = Date(timeIntervalSince1970: 1_780_282_340)
+        let json = """
+        {
+          "base_resp": { "status_code": 0, "status_msg": "success" },
+          "model_remains": [
+            {
+              "start_time": 1780279200000,
+              "end_time": 1780297200000,
+              "remains_time": 16659830,
+              "current_interval_total_count": 0,
+              "current_interval_usage_count": 0,
+              "model_name": "general",
+              "current_weekly_total_count": 0,
+              "current_weekly_usage_count": 0,
+              "weekly_start_time": 1780243200000,
+              "weekly_end_time": 1780848000000,
+              "weekly_remains_time": 567459830,
+              "current_interval_status": 1,
+              "current_interval_remaining_percent": 96,
+              "current_weekly_status": 1,
+              "current_weekly_remaining_percent": 99
+            },
+            {
+              "start_time": 1780243200000,
+              "end_time": 1780329600000,
+              "remains_time": 49059830,
+              "current_interval_total_count": 0,
+              "current_interval_usage_count": 0,
+              "model_name": "video",
+              "current_weekly_total_count": 0,
+              "current_weekly_usage_count": 0,
+              "weekly_start_time": 1780243200000,
+              "weekly_end_time": 1780848000000,
+              "weekly_remains_time": 567459830,
+              "current_interval_status": 3,
+              "current_interval_remaining_percent": 100,
+              "current_weekly_status": 3,
+              "current_weekly_remaining_percent": 100
+            }
+          ]
+        }
+        """
+
+        let snapshot = try MiniMaxUsageParser.parseCodingPlanRemains(data: Data(json.utf8), now: now)
+        let services = try #require(snapshot.services)
+
+        #expect(snapshot.planName == "Plus")
+        #expect(snapshot.toUsageSnapshot().identity?.loginMethod == "Plus")
+        #expect(services.map(\.serviceType) == ["general", "general"])
+        #expect(services.map(\.displayName) == ["General", "General"])
+        #expect(snapshot.toUsageSnapshot().primary?.usedPercent == 4)
+        #expect(snapshot.toUsageSnapshot().secondary?.usedPercent == 1)
+        #expect(snapshot.toUsageSnapshot().tertiary == nil)
+    }
+
+    @Test
+    func `plus token plan renders boosted interval and unlimited weekly lane`() throws {
+        let now = Date(timeIntervalSince1970: 1_780_347_620)
+        let json = """
+        {
+          "model_remains": [
+            {
+              "start_time": 1780347600000,
+              "end_time": 1780365600000,
+              "remains_time": 4650822,
+              "current_interval_total_count": 0,
+              "current_interval_usage_count": 0,
+              "model_name": "general",
+              "current_weekly_total_count": 0,
+              "current_weekly_usage_count": 0,
+              "weekly_start_time": 1780243200000,
+              "weekly_end_time": 1780848000000,
+              "weekly_remains_time": 487050822,
+              "current_interval_status": 1,
+              "current_interval_remaining_percent": 99,
+              "current_weekly_status": 3,
+              "current_weekly_remaining_percent": 100,
+              "interval_boost_permill": 2000,
+              "weekly_boost_permill": 2000
+            },
+            {
+              "start_time": 1780329600000,
+              "end_time": 1780416000000,
+              "remains_time": 55050822,
+              "current_interval_total_count": 0,
+              "current_interval_usage_count": 0,
+              "model_name": "video",
+              "current_weekly_total_count": 0,
+              "current_weekly_usage_count": 0,
+              "weekly_start_time": 1780243200000,
+              "weekly_end_time": 1780848000000,
+              "weekly_remains_time": 487050822,
+              "current_interval_status": 3,
+              "current_interval_remaining_percent": 100,
+              "current_weekly_status": 3,
+              "current_weekly_remaining_percent": 100
+            }
+          ],
+          "base_resp": { "status_code": 0, "status_msg": "success" }
+        }
+        """
+
+        let snapshot = try MiniMaxUsageParser.parseCodingPlanRemains(data: Data(json.utf8), now: now)
+        let services = try #require(snapshot.services)
+
+        #expect(services.count == 2)
+        #expect(services[0].serviceType == "general")
+        #expect(services[0].displayName == "General")
+        #expect(services[0].windowType == "5 hours")
+        #expect(services[0].usage == 2)
+        #expect(services[0].limit == 200)
+        #expect(services[0].percent == 1)
+        #expect(services[0].isUnlimited == false)
+        #expect(services[1].serviceType == "general")
+        #expect(services[1].displayName == "General")
+        #expect(services[1].windowType == "Weekly")
+        #expect(services[1].usage == 0)
+        #expect(services[1].limit == 0)
+        #expect(services[1].percent == 0)
+        #expect(services[1].isUnlimited)
+        #expect(snapshot.toUsageSnapshot().primary?.usedPercent == 1)
+        #expect(snapshot.toUsageSnapshot().secondary?.resetDescription == "Unlimited")
+    }
+
+    @Test
+    func `web usage fetch falls back to www remains host after platform parse failure`() async throws {
+        let now = Date(timeIntervalSince1970: 1_780_282_340)
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            if url.path.contains("coding-plan") {
+                return Self.httpResponse(
+                    url: url,
+                    body: "<html><main>Coding Plan</main></html>",
+                    contentType: "text/html")
+            }
+            if url.host == "platform.minimaxi.com", url.path.contains("coding_plan/remains") {
+                return Self.httpResponse(url: url, body: "not json", contentType: "application/json")
+            }
+            #expect(url.host == "www.minimaxi.com")
+            #expect(url.path == "/v1/api/openplatform/coding_plan/remains")
+            return Self.httpResponse(url: url, body: Self.percentBasedRemainsJSON, contentType: "application/json")
+        }
+
+        let snapshot = try await MiniMaxUsageFetcher.fetchUsage(
+            cookieHeader: "HERTZ-SESSION=abc",
+            region: .chinaMainland,
+            environment: [:],
+            includeBillingHistory: false,
+            session: transport,
+            now: now)
+        let requests = await transport.requests()
+
+        #expect(snapshot.toUsageSnapshot().primary?.usedPercent == 4)
+        #expect(requests.contains {
+            $0.url?.host == "platform.minimaxi.com" && $0.url?.path.contains("remains") == true
+        })
+        #expect(requests.contains {
+            $0.url?.host == "www.minimaxi.com" && $0.url?.path.contains("remains") == true
+        })
+    }
+
+    @Test
+    func `web usage fetch falls back to www remains host after platform transport failure`() async throws {
+        let now = Date(timeIntervalSince1970: 1_780_282_340)
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            if url.path.contains("coding-plan") {
+                return Self.httpResponse(
+                    url: url,
+                    body: "<html><main>Coding Plan</main></html>",
+                    contentType: "text/html")
+            }
+            if url.host == "platform.minimaxi.com", url.path.contains("coding_plan/remains") {
+                throw URLError(.timedOut)
+            }
+            #expect(url.host == "www.minimaxi.com")
+            #expect(url.path == "/v1/api/openplatform/coding_plan/remains")
+            return Self.httpResponse(url: url, body: Self.percentBasedRemainsJSON, contentType: "application/json")
+        }
+
+        let snapshot = try await MiniMaxUsageFetcher.fetchUsage(
+            cookieHeader: "HERTZ-SESSION=abc",
+            region: .chinaMainland,
+            environment: [:],
+            includeBillingHistory: false,
+            session: transport,
+            now: now)
+        let requests = await transport.requests()
+
+        #expect(snapshot.toUsageSnapshot().primary?.usedPercent == 4)
+        #expect(requests.map { $0.url?.host } == [
+            "platform.minimaxi.com",
+            "platform.minimaxi.com",
+            "www.minimaxi.com",
+        ])
+    }
+
+    @Test
+    func `web usage fetch preserves coding plan json auth failure`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            #expect(url.path.contains("coding-plan"))
+            return Self.httpResponse(
+                url: url,
+                body: #"{"base_resp":{"status_code":1004,"status_msg":"cookie is missing, log in again"}}"#,
+                contentType: "application/json")
+        }
+
+        await #expect(throws: MiniMaxUsageError.invalidCredentials) {
+            try await MiniMaxUsageFetcher.fetchUsage(
+                cookieHeader: "HERTZ-SESSION=expired",
+                region: .chinaMainland,
+                environment: [:],
+                includeBillingHistory: false,
+                session: transport)
+        }
+        let requests = await transport.requests()
+        #expect(requests.count == 1)
+    }
+
+    @Test
+    func `web usage fetch preserves remains json auth failure`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            if url.path.contains("coding-plan") {
+                return Self.httpResponse(
+                    url: url,
+                    body: "<html><main>Coding Plan</main></html>",
+                    contentType: "text/html")
+            }
+            #expect(url.path.contains("coding_plan/remains"))
+            return Self.httpResponse(
+                url: url,
+                body: #"{"base_resp":{"status_code":1004,"status_msg":"cookie is missing, log in again"}}"#,
+                contentType: "application/json")
+        }
+
+        await #expect(throws: MiniMaxUsageError.invalidCredentials) {
+            try await MiniMaxUsageFetcher.fetchUsage(
+                cookieHeader: "HERTZ-SESSION=expired",
+                region: .chinaMainland,
+                environment: [:],
+                includeBillingHistory: false,
+                session: transport)
+        }
+        let requests = await transport.requests()
+        #expect(requests.map { $0.url?.path } == [
+            "/user-center/payment/coding-plan",
+            "/v1/api/openplatform/coding_plan/remains",
+        ])
+    }
+
+    @Test
+    func `api token fetch uses official token plan remains endpoint`() async throws {
+        let now = Date(timeIntervalSince1970: 1_780_282_340)
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            #expect(url.host == "api.minimaxi.com")
+            #expect(url.path == "/v1/token_plan/remains")
+            #expect(request.value(forHTTPHeaderField: "Authorization") == "Bearer sk-cp-test")
+            return Self.httpResponse(url: url, body: Self.percentBasedRemainsJSON, contentType: "application/json")
+        }
+
+        let snapshot = try await MiniMaxUsageFetcher.fetchUsage(
+            apiToken: "sk-cp-test",
+            region: .chinaMainland,
+            now: now,
+            session: transport)
+
+        #expect(snapshot.toUsageSnapshot().primary?.usedPercent == 4)
+    }
+
+    @Test
+    func `api token fetch falls back to legacy coding plan endpoint after official auth failure`() async throws {
+        let now = Date(timeIntervalSince1970: 1_780_282_340)
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            #expect(url.host == "api.minimaxi.com")
+            #expect(request.value(forHTTPHeaderField: "Authorization") == "Bearer sk-standard-test")
+            if url.path == "/v1/token_plan/remains" {
+                return Self.httpResponse(url: url, body: "{}", statusCode: 401, contentType: "application/json")
+            }
+            #expect(url.path == "/v1/api/openplatform/coding_plan/remains")
+            return Self.httpResponse(url: url, body: Self.percentBasedRemainsJSON, contentType: "application/json")
+        }
+
+        let snapshot = try await MiniMaxUsageFetcher.fetchUsage(
+            apiToken: "sk-standard-test",
+            region: .chinaMainland,
+            now: now,
+            session: transport)
+        let requests = await transport.requests()
+
+        #expect(snapshot.toUsageSnapshot().primary?.usedPercent == 4)
+        #expect(requests.map { $0.url?.path } == [
+            "/v1/token_plan/remains",
+            "/v1/api/openplatform/coding_plan/remains",
+        ])
+    }
+
+    @Test
+    func `global api token fetch preserves structured credential failure across legacy error`() async throws {
+        let now = Date(timeIntervalSince1970: 1_780_282_340)
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            #expect(request.value(forHTTPHeaderField: "Authorization") == "Bearer sk-cp-test")
+
+            switch (url.host, url.path) {
+            case ("api.minimax.io", "/v1/token_plan/remains"):
+                return Self.httpResponse(
+                    url: url,
+                    body: #"{"base_resp":{"status_code":1001,"status_msg":"invalid api key"}}"#,
+                    contentType: "application/json")
+            case ("api.minimax.io", "/v1/api/openplatform/coding_plan/remains"):
+                return Self.httpResponse(
+                    url: url,
+                    body: #"{"error":"legacy endpoint unavailable"}"#,
+                    statusCode: 404,
+                    contentType: "application/json")
+            case ("api.minimaxi.com", "/v1/token_plan/remains"):
+                return Self.httpResponse(
+                    url: url,
+                    body: Self.percentBasedRemainsJSON,
+                    contentType: "application/json")
+            default:
+                Issue.record("Unexpected MiniMax API request: \(url.absoluteString)")
+                return Self.httpResponse(url: url, body: "{}", statusCode: 500, contentType: "application/json")
+            }
+        }
+
+        let snapshot = try await MiniMaxUsageFetcher.fetchUsage(
+            apiToken: "sk-cp-test",
+            region: .global,
+            now: now,
+            session: transport)
+        let requests = await transport.requests()
+
+        #expect(snapshot.toUsageSnapshot().primary?.usedPercent == 4)
+        #expect(requests.map { $0.url?.host } == [
+            "api.minimax.io",
+            "api.minimax.io",
+            "api.minimaxi.com",
+        ])
+        #expect(requests.map { $0.url?.path } == [
+            "/v1/token_plan/remains",
+            "/v1/api/openplatform/coding_plan/remains",
+            "/v1/token_plan/remains",
+        ])
+    }
+
+    @Test
+    func `api token fetch falls back to legacy coding plan endpoint after official parse failure`() async throws {
+        let now = Date(timeIntervalSince1970: 1_780_282_340)
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            #expect(url.host == "api.minimaxi.com")
+            #expect(request.value(forHTTPHeaderField: "Authorization") == "Bearer sk-standard-test")
+            if url.path == "/v1/token_plan/remains" {
+                return Self.httpResponse(url: url, body: "{}", contentType: "application/json")
+            }
+            #expect(url.path == "/v1/api/openplatform/coding_plan/remains")
+            return Self.httpResponse(url: url, body: Self.percentBasedRemainsJSON, contentType: "application/json")
+        }
+
+        let snapshot = try await MiniMaxUsageFetcher.fetchUsage(
+            apiToken: "sk-standard-test",
+            region: .chinaMainland,
+            now: now,
+            session: transport)
+        let requests = await transport.requests()
+
+        #expect(snapshot.toUsageSnapshot().primary?.usedPercent == 4)
+        #expect(requests.map { $0.url?.path } == [
+            "/v1/token_plan/remains",
+            "/v1/api/openplatform/coding_plan/remains",
+        ])
+    }
+
+    @Test
+    func `api token fetch falls back to legacy coding plan endpoint after official transport failure`() async throws {
+        let now = Date(timeIntervalSince1970: 1_780_282_340)
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            #expect(url.host == "api.minimaxi.com")
+            #expect(request.value(forHTTPHeaderField: "Authorization") == "Bearer sk-standard-test")
+            if url.path == "/v1/token_plan/remains" {
+                throw URLError(.timedOut)
+            }
+            #expect(url.path == "/v1/api/openplatform/coding_plan/remains")
+            return Self.httpResponse(url: url, body: Self.percentBasedRemainsJSON, contentType: "application/json")
+        }
+
+        let snapshot = try await MiniMaxUsageFetcher.fetchUsage(
+            apiToken: "sk-standard-test",
+            region: .chinaMainland,
+            now: now,
+            session: transport)
+        let requests = await transport.requests()
+
+        #expect(snapshot.toUsageSnapshot().primary?.usedPercent == 4)
+        #expect(requests.map { $0.url?.path } == [
+            "/v1/token_plan/remains",
+            "/v1/api/openplatform/coding_plan/remains",
+        ])
+    }
+
+    @Test
+    func `api token fetch rejects after official and legacy endpoint auth failures`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            #expect(url.host == "api.minimaxi.com")
+            #expect([
+                "/v1/token_plan/remains",
+                "/v1/api/openplatform/coding_plan/remains",
+            ].contains(url.path))
+            return Self.httpResponse(url: url, body: "{}", statusCode: 401, contentType: "application/json")
+        }
+
+        await #expect(throws: MiniMaxUsageError.invalidCredentials) {
+            try await MiniMaxUsageFetcher.fetchUsage(
+                apiToken: "sk-standard-test",
+                region: .chinaMainland,
+                session: transport)
+        }
+        let requests = await transport.requests()
+
+        #expect(requests.map { $0.url?.path } == [
+            "/v1/token_plan/remains",
+            "/v1/api/openplatform/coding_plan/remains",
+        ])
+    }
+
+    @Test
+    func `combo metadata parser extracts token plan subscription label`() throws {
+        let metadata = try MiniMaxSubscriptionMetadataFetcher.parse(data: Data(Self.comboMetadataJSON.utf8))
+        #expect(metadata.planName == "TokenPlanMax-年度会员")
+        #expect(metadata.subscriptionExpiresAt == Date(timeIntervalSince1970: 1_810_656_000))
+        #expect(metadata.subscriptionRenewsAt == Date(timeIntervalSince1970: 1_810_569_600))
+    }
+
+    @Test
+    func `combo metadata parser prefers current subscription over package catalog`() throws {
+        let json = """
+        {
+          "base_resp": { "status_code": 0, "status_msg": "success" },
+          "data": {
+            "current_subscribe": {
+              "current_subscribe_title": "TokenPlanUltra-年度会员"
+            },
+            "packages": [
+              { "resource_package_name": "TokenPlanPlus" },
+              { "resource_package_name": "TokenPlanMax" },
+              { "resource_package_name": "TokenPlanUltra" }
+            ]
+          }
+        }
+        """
+
+        let metadata = try MiniMaxSubscriptionMetadataFetcher.parse(data: Data(json.utf8))
+
+        #expect(metadata.planName == "TokenPlanUltra-年度会员")
+    }
+
+    @Test
+    func `web usage fetch merges combo subscription metadata`() async throws {
+        let now = Date(timeIntervalSince1970: 1_780_282_340)
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            if url.path.contains("coding-plan") {
+                return Self.httpResponse(
+                    url: url,
+                    body: "<html><main>Coding Plan</main></html>",
+                    contentType: "text/html")
+            }
+            if url.path.contains("coding_plan/remains") {
+                return Self.httpResponse(url: url, body: Self.percentBasedRemainsJSON, contentType: "application/json")
+            }
+            #expect(url.host == "www.minimaxi.com")
+            #expect(url.path == "/v1/api/openplatform/charge/combo/cycle_audio_resource_package")
+            #expect(url.query?.contains("biz_line=2") == true)
+            #expect(request.value(forHTTPHeaderField: "x-group-id") == "2013894056999916075")
+            #expect(request.value(forHTTPHeaderField: "origin") == "https://platform.minimaxi.com")
+            return Self.httpResponse(url: url, body: Self.comboMetadataJSON, contentType: "application/json")
+        }
+
+        let snapshot = try await MiniMaxUsageFetcher.fetchUsage(
+            cookieHeader: "_token=abc; minimax_group_id_v2=2013894056999916075",
+            groupID: "2013894056999916075",
+            region: .chinaMainland,
+            environment: [:],
+            includeBillingHistory: false,
+            session: transport,
+            now: now)
+        let requests = await transport.requests()
+
+        #expect(snapshot.planName == "TokenPlanMax-年度会员")
+        #expect(snapshot.subscriptionExpiresAt == Date(timeIntervalSince1970: 1_810_656_000))
+        #expect(snapshot.subscriptionRenewsAt == Date(timeIntervalSince1970: 1_810_569_600))
+        #expect(snapshot.toUsageSnapshot().subscriptionExpiresAt == Date(timeIntervalSince1970: 1_810_656_000))
+        #expect(snapshot.toUsageSnapshot().subscriptionRenewsAt == Date(timeIntervalSince1970: 1_810_569_600))
+        #expect(snapshot.toUsageSnapshot().primary?.usedPercent == 4)
+        #expect(requests.contains { $0.url?.path.contains("cycle_audio_resource_package") == true })
+    }
+
+    @Test
+    func `combo metadata rejects non https host override before sending credentials`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            Issue.record("Unexpected request to \(request.url?.absoluteString ?? "<nil>")")
+            return Self.httpResponse(
+                url: URL(string: "https://unused.example")!,
+                body: "{}",
+                contentType: "application/json")
+        }
+
+        await #expect(throws: ProviderEndpointOverrideError.minimax(MiniMaxSettingsReader.hostKey)) {
+            try await MiniMaxSubscriptionMetadataFetcher.fetch(
+                cookieHeader: "_token=secret",
+                groupID: "2013894056999916075",
+                region: .chinaMainland,
+                environment: [MiniMaxSettingsReader.hostKey: "http://metadata.test"],
+                transport: transport)
+        }
+
+        let requests = await transport.requests()
+        #expect(requests.isEmpty)
+    }
+
+    @Test
+    func `combo metadata rejects malformed host override before sending credentials`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            Issue.record("Unexpected request to \(request.url?.absoluteString ?? "<nil>")")
+            return Self.httpResponse(
+                url: URL(string: "https://unused.example")!,
+                body: "{}",
+                contentType: "application/json")
+        }
+
+        await #expect(throws: ProviderEndpointOverrideError.minimax(MiniMaxSettingsReader.hostKey)) {
+            try await MiniMaxSubscriptionMetadataFetcher.fetch(
+                cookieHeader: "_token=secret",
+                groupID: "2013894056999916075",
+                region: .chinaMainland,
+                environment: [MiniMaxSettingsReader.hostKey: "bad host"],
+                transport: transport)
+        }
+
+        let requests = await transport.requests()
+        #expect(requests.isEmpty)
+    }
+
+    @Test
+    func `web usage fetch preserves combo metadata cancellation`() async throws {
+        let now = Date(timeIntervalSince1970: 1_780_282_340)
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            if url.path.contains("coding-plan") {
+                return Self.httpResponse(
+                    url: url,
+                    body: "<html><main>Coding Plan</main></html>",
+                    contentType: "text/html")
+            }
+            if url.path.contains("coding_plan/remains") {
+                return Self.httpResponse(url: url, body: Self.percentBasedRemainsJSON, contentType: "application/json")
+            }
+            throw CancellationError()
+        }
+
+        await #expect(throws: CancellationError.self) {
+            try await MiniMaxUsageFetcher.fetchUsage(
+                cookieHeader: "_token=abc",
+                groupID: "2013894056999916075",
+                region: .chinaMainland,
+                environment: [:],
+                includeBillingHistory: false,
+                session: transport,
+                now: now)
+        }
+    }
+
+    @Test
+    func `combo metadata failure does not block quota rendering`() async throws {
+        let now = Date(timeIntervalSince1970: 1_780_282_340)
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            if url.path.contains("coding-plan") {
+                return Self.httpResponse(
+                    url: url,
+                    body: "<html><main>Coding Plan</main></html>",
+                    contentType: "text/html")
+            }
+            if url.path.contains("coding_plan/remains") {
+                return Self.httpResponse(url: url, body: Self.percentBasedRemainsJSON, contentType: "application/json")
+            }
+            return Self.httpResponse(
+                url: url,
+                body: #"{"base_resp":{"status_code":1004,"status_msg":"cookie is missing, log in again"}}"#,
+                contentType: "application/json")
+        }
+
+        let snapshot = try await MiniMaxUsageFetcher.fetchUsage(
+            cookieHeader: "_token=abc",
+            groupID: "2013894056999916075",
+            region: .chinaMainland,
+            environment: [:],
+            includeBillingHistory: false,
+            session: transport,
+            now: now)
+
+        #expect(snapshot.planName == nil)
+        #expect(snapshot.toUsageSnapshot().primary?.usedPercent == 4)
+    }
+
+    private static let comboMetadataJSON = """
+    {
+      "base_resp": { "status_code": 0, "status_msg": "success" },
+      "data": {
+        "current_subscribe": {
+          "current_subscribe_title": "TokenPlanMax-年度会员",
+          "current_subscribe_end_time": "05/19/2027",
+          "renewal_date": "05/18/2027",
+          "current_subscribe_end_time_ts": 1810656000000,
+          "renewal_trigger_time_ts": 1810569600000
+        },
+        "packages": [
+          {
+            "resource_package_name": "TokenPlanMax",
+            "display_name": "Token Plan · TokenPlanMax-年度会员"
+          }
+        ]
+      }
+    }
+    """
+
+    private static let percentBasedRemainsJSON = """
+    {
+      "model_remains": [
+        {
+          "start_time": 1780279200000,
+          "end_time": 1780297200000,
+          "remains_time": 16659830,
+          "current_interval_total_count": 0,
+          "current_interval_usage_count": 0,
+          "model_name": "general",
+          "current_weekly_total_count": 0,
+          "current_weekly_usage_count": 0,
+          "weekly_start_time": 1780243200000,
+          "weekly_end_time": 1780848000000,
+          "weekly_remains_time": 567459830,
+          "current_interval_status": 1,
+          "current_interval_remaining_percent": 96,
+          "current_weekly_status": 1,
+          "current_weekly_remaining_percent": 99
+        }
+      ],
+      "base_resp": { "status_code": 0, "status_msg": "success" }
+    }
+    """
+
+    private static func httpResponse(
+        url: URL,
+        body: String,
+        statusCode: Int = 200,
+        contentType: String) -> (Data, URLResponse)
+    {
+        let response = HTTPURLResponse(
+            url: url,
+            statusCode: statusCode,
+            httpVersion: "HTTP/1.1",
+            headerFields: ["Content-Type": contentType])!
+        return (Data(body.utf8), response)
+    }
+}
diff --git a/Tests/CodexBarTests/MistralUsageParserTests.swift b/Tests/CodexBarTests/MistralUsageParserTests.swift
new file mode 100644
index 0000000000..b380175365
--- /dev/null
+++ b/Tests/CodexBarTests/MistralUsageParserTests.swift
@@ -0,0 +1,400 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct MistralUsageParserTests {
+    // swiftlint:disable line_length
+
+    private static let novemberResponseJSON = """
+    {"completion":{"models":{"mistral-large-latest::mistral-large-2411":{"input":[{"usage_type":"usage","event_type":"api_tokens","billing_metric":"mistral-large-2411","billing_display_name":"mistral-large-latest","billing_group":"input","timestamp":"2025-11-14","value":11121,"value_paid":11121}],"output":[{"usage_type":"usage","event_type":"api_tokens","billing_metric":"mistral-large-2411","billing_display_name":"mistral-large-latest","billing_group":"output","timestamp":"2025-11-14","value":1115,"value_paid":1115}]},"mistral-small-latest::mistral-small-2506":{"input":[{"usage_type":"usage","event_type":"api_tokens","billing_metric":"mistral-small-2506","billing_display_name":"mistral-small-latest","billing_group":"input","timestamp":"2025-11-14","value":20,"value_paid":20},{"usage_type":"usage","event_type":"api_tokens","billing_metric":"mistral-small-2506","billing_display_name":"mistral-small-latest","billing_group":"input","timestamp":"2025-11-24","value":100,"value_paid":100}],"output":[{"usage_type":"usage","event_type":"api_tokens","billing_metric":"mistral-small-2506","billing_display_name":"mistral-small-latest","billing_group":"output","timestamp":"2025-11-14","value":500,"value_paid":500},{"usage_type":"usage","event_type":"api_tokens","billing_metric":"mistral-small-2506","billing_display_name":"mistral-small-latest","billing_group":"output","timestamp":"2025-11-24","value":2482,"value_paid":2482}]}}},"ocr":{"models":{}},"connectors":{"models":{}},"libraries_api":{"pages":{"models":{}},"tokens":{"models":{}}},"fine_tuning":{"training":{},"storage":{}},"audio":{"models":{}},"vibe_usage":0.0,"date":"2025-11-01T00:00:00Z","previous_month":"2025-10","next_month":"2025-12","start_date":"2025-11-01T00:00:00Z","end_date":"2025-11-30T23:59:59.999Z","currency":"EUR","currency_symbol":"\\u20ac","prices":[{"event_type":"api_tokens","billing_metric":"mistral-large-2411","billing_group":"input","price":"0.0000017000"},{"event_type":"api_tokens","billing_metric":"mistral-large-2411","billing_group":"output","price":"0.0000051000"},{"event_type":"api_tokens","billing_metric":"mistral-small-2506","billing_group":"input","price":"8.50E-8"},{"event_type":"api_tokens","billing_metric":"mistral-small-2506","billing_group":"output","price":"2.550E-7"}]}
+    """
+
+    private static let emptyResponseJSON = """
+    {"completion":{"models":{}},"ocr":{"models":{}},"connectors":{"models":{}},"libraries_api":{"pages":{"models":{}},"tokens":{"models":{}}},"fine_tuning":{"training":{},"storage":{}},"audio":{"models":{}},"vibe_usage":0.0,"date":"2026-02-01T00:00:00Z","previous_month":"2026-01","next_month":"2026-03","start_date":"2026-02-01T00:00:00Z","end_date":"2026-02-28T23:59:59.999Z","currency":"EUR","currency_symbol":"\\u20ac","prices":[]}
+    """
+
+    // swiftlint:enable line_length
+
+    @Test
+    func `parses response with usage data and computes token totals`() throws {
+        let data = try #require(Self.novemberResponseJSON.data(using: .utf8))
+        let snapshot = try MistralUsageFetcher.parseResponse(data: data, updatedAt: Date())
+
+        // mistral-large input: 11121, mistral-small input: 20+100=120
+        #expect(snapshot.totalInputTokens == 11121 + 120)
+        // mistral-large output: 1115, mistral-small output: 500+2482=2982
+        #expect(snapshot.totalOutputTokens == 1115 + 2982)
+        #expect(snapshot.totalCachedTokens == 0)
+        #expect(snapshot.modelCount == 2)
+        #expect(snapshot.currency == "EUR")
+        #expect(snapshot.currencySymbol == "€")
+        #expect(snapshot.daily.map(\.day) == ["2025-11-14", "2025-11-24"])
+        #expect(snapshot.daily.first?.totalTokens == 11121 + 1115 + 20 + 500)
+        #expect(snapshot.daily.first?.models.first?.name == "mistral-large-latest")
+    }
+
+    @Test
+    func `computes cost from tokens and prices`() throws {
+        let data = try #require(Self.novemberResponseJSON.data(using: .utf8))
+        let snapshot = try MistralUsageFetcher.parseResponse(data: data, updatedAt: Date())
+
+        // mistral-large-2411 input: 11121 * 0.0000017 = 0.0189057
+        // mistral-large-2411 output: 1115 * 0.0000051 = 0.0056865
+        // mistral-small-2506 input: 120 * 0.000000085 = 0.0000102
+        // mistral-small-2506 output: 2982 * 0.000000255 = 0.00076041
+        let expectedCost = 0.0189057 + 0.0056865 + 0.0000102 + 0.00076041
+        #expect(abs(snapshot.totalCost - expectedCost) < 0.0001)
+        #expect(snapshot.totalCost > 0)
+    }
+
+    @Test
+    func `parses empty response with no usage`() throws {
+        let data = try #require(Self.emptyResponseJSON.data(using: .utf8))
+        let snapshot = try MistralUsageFetcher.parseResponse(data: data, updatedAt: Date())
+
+        #expect(snapshot.totalInputTokens == 0)
+        #expect(snapshot.totalOutputTokens == 0)
+        #expect(snapshot.totalCost == 0)
+        #expect(snapshot.modelCount == 0)
+        #expect(snapshot.currency == "EUR")
+    }
+
+    @Test
+    func `daily spend keeps non token Mistral units out of token totals`() throws {
+        let json = """
+        {
+          "libraries_api": {
+            "pages": {
+              "models": {
+                "mistral-ocr-latest": {
+                  "input": [
+                    {
+                      "billing_metric": "pages",
+                      "billing_display_name": "OCR pages",
+                      "billing_group": "input",
+                      "timestamp": "2025-11-15",
+                      "value": 42,
+                      "value_paid": 42
+                    }
+                  ]
+                }
+              }
+            }
+          },
+          "currency": "EUR",
+          "currency_symbol": "€",
+          "prices": [
+            {
+              "billing_metric": "pages",
+              "billing_group": "input",
+              "price": "0.01"
+            }
+          ]
+        }
+        """
+        let snapshot = try MistralUsageFetcher.parseResponse(data: Data(json.utf8), updatedAt: Date())
+
+        #expect(abs(snapshot.totalCost - 0.42) < 0.0001)
+        #expect(snapshot.totalInputTokens == 0)
+        #expect(abs((snapshot.daily.first?.cost ?? 0) - 0.42) < 0.0001)
+        #expect(snapshot.daily.first?.totalTokens == 0)
+        #expect(abs((snapshot.daily.first?.models.first?.cost ?? 0) - 0.42) < 0.0001)
+        #expect(snapshot.daily.first?.models.first?.totalTokens == 0)
+    }
+
+    @Test
+    func `parses dates from response`() throws {
+        let data = try #require(Self.novemberResponseJSON.data(using: .utf8))
+        let snapshot = try MistralUsageFetcher.parseResponse(data: data, updatedAt: Date())
+
+        #expect(snapshot.startDate != nil)
+        #expect(snapshot.endDate != nil)
+
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = try #require(TimeZone(secondsFromGMT: 0))
+        if let start = snapshot.startDate {
+            #expect(calendar.component(.month, from: start) == 11)
+            #expect(calendar.component(.year, from: start) == 2025)
+        }
+    }
+
+    @Test
+    func `throws parseFailed for invalid JSON`() {
+        let data = Data("not json".utf8)
+        #expect(throws: MistralUsageError.self) {
+            try MistralUsageFetcher.parseResponse(data: data, updatedAt: Date())
+        }
+    }
+}
+
+struct MistralUsageSnapshotConversionTests {
+    @Test
+    func `converts cost into text only current month api spend`() {
+        let snapshot = MistralUsageSnapshot(
+            totalCost: 1.2345,
+            currency: "EUR",
+            currencySymbol: "€",
+            totalInputTokens: 10000,
+            totalOutputTokens: 5000,
+            totalCachedTokens: 0,
+            modelCount: 2,
+            startDate: nil,
+            endDate: Date(),
+            updatedAt: Date())
+
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary == nil)
+        #expect(usage.identity?.providerID == .mistral)
+        #expect(usage.identity?.loginMethod == "API spend: €1.2345 this month")
+        #expect(usage.providerCost == nil)
+    }
+
+    @Test
+    func `converts zero cost into zero spend text`() {
+        let snapshot = MistralUsageSnapshot(
+            totalCost: 0,
+            currency: "USD",
+            currencySymbol: "$",
+            totalInputTokens: 0,
+            totalOutputTokens: 0,
+            totalCachedTokens: 0,
+            modelCount: 0,
+            startDate: nil,
+            endDate: nil,
+            updatedAt: Date())
+
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary == nil)
+        #expect(usage.identity?.loginMethod == "API spend: $0.0000 this month")
+    }
+
+    @Test
+    func `converts billing usage into cost token snapshot`() {
+        let now = Date(timeIntervalSince1970: 1_700_179_200)
+        let snapshot = MistralUsageSnapshot(
+            totalCost: 1.75,
+            currency: "eur",
+            currencySymbol: "€",
+            totalInputTokens: 300,
+            totalOutputTokens: 150,
+            totalCachedTokens: 50,
+            modelCount: 2,
+            daily: [
+                MistralDailyUsageBucket(
+                    day: "2023-11-14",
+                    cost: 1.5,
+                    inputTokens: 100,
+                    cachedTokens: 20,
+                    outputTokens: 50,
+                    models: [
+                        MistralDailyUsageBucket.ModelBreakdown(
+                            name: "mistral-large",
+                            cost: 1.5,
+                            inputTokens: 100,
+                            cachedTokens: 20,
+                            outputTokens: 50),
+                    ]),
+                MistralDailyUsageBucket(
+                    day: "2023-11-15",
+                    cost: 0.25,
+                    inputTokens: 200,
+                    cachedTokens: 30,
+                    outputTokens: 100,
+                    models: [
+                        MistralDailyUsageBucket.ModelBreakdown(
+                            name: "mistral-small",
+                            cost: 0.25,
+                            inputTokens: 200,
+                            cachedTokens: 30,
+                            outputTokens: 100),
+                    ]),
+            ],
+            startDate: nil,
+            endDate: nil,
+            updatedAt: now)
+
+        let cost = snapshot.toCostUsageTokenSnapshot(historyDays: 1)
+        #expect(cost.currencyCode == "EUR")
+        #expect(cost.historyLabel == "This month")
+        #expect(cost.historyDays == 2)
+        #expect(cost.sessionCostUSD == 0.25)
+        #expect(cost.sessionTokens == 330)
+        #expect(cost.last30DaysCostUSD == 1.75)
+        #expect(cost.last30DaysTokens == 500)
+        #expect(cost.daily.count == 2)
+        #expect(cost.daily.last?.modelsUsed == ["mistral-small"])
+    }
+
+    @Test
+    func `clamps negative billing adjustments in cost token snapshot`() {
+        let now = Date(timeIntervalSince1970: 1_700_179_200)
+        let snapshot = MistralUsageSnapshot(
+            totalCost: -2,
+            currency: "EUR",
+            currencySymbol: "€",
+            totalInputTokens: 100,
+            totalOutputTokens: 25,
+            totalCachedTokens: 0,
+            modelCount: 1,
+            daily: [
+                MistralDailyUsageBucket(
+                    day: "2023-11-14",
+                    cost: -1.5,
+                    inputTokens: 100,
+                    cachedTokens: 0,
+                    outputTokens: 25,
+                    models: [
+                        MistralDailyUsageBucket.ModelBreakdown(
+                            name: "mistral-large",
+                            cost: -1.5,
+                            inputTokens: 100,
+                            cachedTokens: 0,
+                            outputTokens: 25),
+                    ]),
+            ],
+            startDate: nil,
+            endDate: nil,
+            updatedAt: now)
+
+        let cost = snapshot.toCostUsageTokenSnapshot()
+        #expect(cost.sessionCostUSD == 0)
+        #expect(cost.last30DaysCostUSD == 0)
+        #expect(cost.daily.first?.costUSD == 0)
+        #expect(cost.daily.first?.modelBreakdowns?.first?.costUSD == 0)
+    }
+
+    @Test
+    func `preserves net monthly cost when billing includes credits`() {
+        let now = Date(timeIntervalSince1970: 1_700_179_200)
+        let snapshot = MistralUsageSnapshot(
+            totalCost: 8,
+            currency: "EUR",
+            currencySymbol: "€",
+            totalInputTokens: 100,
+            totalOutputTokens: 25,
+            totalCachedTokens: 0,
+            modelCount: 1,
+            daily: [
+                MistralDailyUsageBucket(
+                    day: "2023-11-14",
+                    cost: 10,
+                    inputTokens: 100,
+                    cachedTokens: 0,
+                    outputTokens: 25,
+                    models: []),
+                MistralDailyUsageBucket(
+                    day: "2023-11-15",
+                    cost: -2,
+                    inputTokens: 0,
+                    cachedTokens: 0,
+                    outputTokens: 0,
+                    models: []),
+            ],
+            startDate: nil,
+            endDate: nil,
+            updatedAt: now)
+
+        let cost = snapshot.toCostUsageTokenSnapshot()
+        #expect(cost.last30DaysCostUSD == 8)
+        #expect(cost.sessionCostUSD == 0)
+        #expect(cost.daily.map(\.costUSD) == [10, 0])
+    }
+}
+
+struct MistralStrategyTests {
+    private struct StubClaudeFetcher: ClaudeUsageFetching {
+        func loadLatestUsage(model _: String) async throws -> ClaudeUsageSnapshot {
+            throw ClaudeUsageError.parseFailed("stub")
+        }
+
+        func debugRawProbe(model _: String) async -> String {
+            "stub"
+        }
+
+        func detectVersion() -> String? {
+            nil
+        }
+    }
+
+    private func makeContext(
+        sourceMode: ProviderSourceMode = .auto,
+        settings: ProviderSettingsSnapshot? = nil,
+        env: [String: String] = [:]) -> ProviderFetchContext
+    {
+        let browserDetection = BrowserDetection(cacheTTL: 0)
+        return ProviderFetchContext(
+            runtime: .cli,
+            sourceMode: sourceMode,
+            includeCredits: false,
+            webTimeout: 1,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: env,
+            settings: settings,
+            fetcher: UsageFetcher(environment: env),
+            claudeFetcher: StubClaudeFetcher(),
+            browserDetection: browserDetection)
+    }
+
+    @Test
+    func `strategy is unavailable when cookie source is off`() async {
+        let settings = ProviderSettingsSnapshot.make(
+            mistral: ProviderSettingsSnapshot.MistralProviderSettings(
+                cookieSource: .off,
+                manualCookieHeader: nil))
+        let context = self.makeContext(settings: settings)
+        let strategy = MistralWebFetchStrategy()
+
+        let available = await strategy.isAvailable(context)
+        #expect(available == false)
+    }
+
+    @Test
+    func `strategy is available when cookie source is auto`() async {
+        let settings = ProviderSettingsSnapshot.make(
+            mistral: ProviderSettingsSnapshot.MistralProviderSettings(
+                cookieSource: .auto,
+                manualCookieHeader: nil))
+        let context = self.makeContext(settings: settings)
+        let strategy = MistralWebFetchStrategy()
+
+        let available = await strategy.isAvailable(context)
+        #expect(available == true)
+    }
+
+    @Test
+    func `strategy is available when cookie source is manual`() async {
+        let settings = ProviderSettingsSnapshot.make(
+            mistral: ProviderSettingsSnapshot.MistralProviderSettings(
+                cookieSource: .manual,
+                manualCookieHeader: "ory_session_x=abc; csrftoken=xyz"))
+        let context = self.makeContext(settings: settings)
+        let strategy = MistralWebFetchStrategy()
+
+        let available = await strategy.isAvailable(context)
+        #expect(available == true)
+    }
+
+    @Test
+    func `strategy never falls back (single strategy provider)`() {
+        let strategy = MistralWebFetchStrategy()
+        let context = self.makeContext()
+        let shouldFallback = strategy.shouldFallback(
+            on: MistralUsageError.invalidCredentials,
+            context: context)
+        #expect(shouldFallback == false)
+    }
+
+    @Test
+    func `descriptor metadata is correct`() {
+        let descriptor = MistralProviderDescriptor.descriptor
+        #expect(descriptor.id == .mistral)
+        #expect(descriptor.metadata.displayName == "Mistral")
+        #expect(descriptor.metadata.cliName == "mistral")
+        #expect(descriptor.metadata.defaultEnabled == false)
+        #expect(descriptor.cli.name == "mistral")
+        #expect(descriptor.fetchPlan.sourceModes == [.auto, .web])
+        #expect(descriptor.branding.iconResourceName == "ProviderIcon-mistral")
+        #expect(descriptor.tokenCost.supportsTokenCost)
+    }
+}
diff --git a/Tests/CodexBarTests/MistralVibeUsageTests.swift b/Tests/CodexBarTests/MistralVibeUsageTests.swift
new file mode 100644
index 0000000000..ee81be58d4
--- /dev/null
+++ b/Tests/CodexBarTests/MistralVibeUsageTests.swift
@@ -0,0 +1,153 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+import Testing
+@testable import CodexBarCore
+
+private final class MistralRequestCapture: @unchecked Sendable {
+    private let lock = NSLock()
+    private var storedRequest: URLRequest?
+
+    var request: URLRequest? {
+        self.lock.withLock { self.storedRequest }
+    }
+
+    func record(_ request: URLRequest) {
+        self.lock.withLock { self.storedRequest = request }
+    }
+}
+
+struct MistralVibeUsageTests {
+    @Test
+    func `parses subscription percentage and reset`() throws {
+        let data = Data(Self.responseJSON(usagePercentage: 2.8141356666666666).utf8)
+
+        let result = try MistralUsageFetcher.parseVibeUsage(data: data)
+
+        #expect(result.usagePercentage == 2.8141356666666666)
+        #expect(result.resetAt == ISO8601DateFormatter().date(from: "2026-07-01T00:00:00Z"))
+    }
+
+    @Test
+    func `rejects subscription percentages outside rate window range`() {
+        let data = Data(Self.responseJSON(usagePercentage: 101).utf8)
+
+        #expect(throws: MistralUsageError.self) {
+            try MistralUsageFetcher.parseVibeUsage(data: data)
+        }
+    }
+
+    @Test
+    func `subscription request sends only csrf cookie`() async throws {
+        let capture = MistralRequestCapture()
+        let data = Data(Self.responseJSON(usagePercentage: 12.5).utf8)
+        let transport = ProviderHTTPTransportHandler { request in
+            capture.record(request)
+            guard let url = request.url,
+                  let response = HTTPURLResponse(
+                      url: url,
+                      statusCode: 200,
+                      httpVersion: nil,
+                      headerFields: nil)
+            else {
+                throw URLError(.badURL)
+            }
+            return (data, response)
+        }
+
+        let result = try await MistralUsageFetcher.fetchVibeUsage(
+            csrfToken: " csrf-value ",
+            timeout: 2,
+            transport: transport)
+        let request = try #require(capture.request)
+
+        #expect(result.usagePercentage == 12.5)
+        #expect(request.url?.host == "console.mistral.ai")
+        #expect(request.timeoutInterval == 2)
+        #expect(request.httpShouldHandleCookies == false)
+        #expect(request.value(forHTTPHeaderField: "Cookie") == "csrftoken=csrf-value")
+        #expect(request.value(forHTTPHeaderField: "X-CSRFToken") == "csrf-value")
+        #expect(request.allHTTPHeaderFields?.values.contains { $0.contains("ory_session") } != true)
+    }
+
+    @Test
+    func `rejects csrf values that could add cookies or headers`() {
+        #expect(throws: MistralUsageError.self) {
+            try MistralUsageFetcher.vibeCookieHeader(csrfToken: "csrf; ory_session_secret=leak")
+        }
+        #expect(throws: MistralUsageError.self) {
+            try MistralUsageFetcher.vibeCookieHeader(csrfToken: "csrf\r\nX-Leak: value")
+        }
+    }
+
+    @Test
+    func `optional subscription request propagates in flight cancellation`() async throws {
+        let started = AsyncStream<Void>.makeStream(of: Void.self)
+        let transport = ProviderHTTPTransportHandler { _ in
+            started.continuation.yield(())
+            try await Task.sleep(for: .seconds(30))
+            throw URLError(.timedOut)
+        }
+        let task = Task {
+            try await MistralWebFetchStrategy.fetchOptionalVibeUsage(
+                csrfToken: "csrf-value",
+                timeout: 30,
+                transport: transport)
+        }
+
+        var iterator = started.stream.makeAsyncIterator()
+        _ = await iterator.next()
+        task.cancel()
+
+        await #expect(throws: CancellationError.self) {
+            try await task.value
+        }
+        started.continuation.finish()
+    }
+
+    @Test
+    func `optional subscription request ignores ordinary endpoint failures`() async throws {
+        let transport = ProviderHTTPTransportHandler { _ in
+            throw URLError(.cannotConnectToHost)
+        }
+
+        let result = try await MistralWebFetchStrategy.fetchOptionalVibeUsage(
+            csrfToken: "csrf-value",
+            timeout: 2,
+            transport: transport)
+
+        #expect(result == nil)
+    }
+
+    @Test
+    func `monthly plan window preserves existing extras`() {
+        let existing = NamedRateWindow(
+            id: "existing",
+            title: "Existing",
+            window: RateWindow(usedPercent: 5, windowMinutes: nil, resetsAt: nil, resetDescription: nil))
+        let usage = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            extraRateWindows: [existing],
+            updatedAt: Date())
+
+        let updated = MistralWebFetchStrategy.attachVibeWindow(
+            to: usage,
+            vibeResult: .init(usagePercentage: 25, resetAt: nil))
+
+        #expect(updated.extraRateWindows?.map(\.id) == ["existing", "mistral-monthly-plan"])
+        #expect(updated.extraRateWindows?.last?.window.usedPercent == 25)
+    }
+
+    private static func responseJSON(usagePercentage: Double) -> String {
+        """
+        [{"result":{"data":{"json":{
+          "usage_percentage":\(usagePercentage),
+          "quota_changed_this_month":false,
+          "payg_enabled":false,
+          "reset_at":"2026-07-01T00:00:00Z"
+        }}}}]
+        """
+    }
+}
diff --git a/Tests/CodexBarTests/ModelsDevPricingTests.swift b/Tests/CodexBarTests/ModelsDevPricingTests.swift
new file mode 100644
index 0000000000..d1a2fdcf91
--- /dev/null
+++ b/Tests/CodexBarTests/ModelsDevPricingTests.swift
@@ -0,0 +1,1058 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+import Testing
+@testable import CodexBarCore
+
+struct ModelsDevPricingTests {
+    @Test
+    func `parses models dev subset`() throws {
+        let catalog = try Self.fixtureCatalog()
+
+        #expect(catalog.providers["openai"]?.name == "OpenAI")
+        #expect(catalog.providers["anthropic"]?.models["claude-sonnet-4-6"]?.cost?.cacheWrite == 3.75)
+        #expect(catalog.providers["anthropic"]?.models["claude-sonnet-4-6"]?.limit?.context == 1_000_000)
+    }
+
+    @Test
+    func `looks up pricing by provider and model`() throws {
+        let catalog = try Self.fixtureCatalog()
+
+        let openAI = try #require(catalog.pricing(providerID: "openai", modelID: "shared-model"))
+        let anthropic = try #require(catalog.pricing(providerID: "anthropic", modelID: "shared-model"))
+
+        #expect(openAI.pricing.inputCostPerToken == 1 / 1_000_000.0)
+        #expect(openAI.pricing.outputCostPerToken == 2 / 1_000_000.0)
+        #expect(anthropic.pricing.inputCostPerToken == 3 / 1_000_000.0)
+        #expect(anthropic.pricing.outputCostPerToken == 4 / 1_000_000.0)
+    }
+
+    @Test
+    func `does not fall back across providers`() throws {
+        let catalog = try Self.fixtureCatalog()
+
+        #expect(catalog.pricing(providerID: "openai", modelID: "claude-sonnet-4-6") == nil)
+        #expect(catalog.pricing(providerID: "anthropic", modelID: "gpt-4o-mini") == nil)
+    }
+
+    @Test
+    func `supports provider scoped model normalization`() throws {
+        let catalog = try Self.fixtureCatalog()
+
+        let anthropic = try #require(catalog.pricing(
+            providerID: "anthropic",
+            modelID: "us.anthropic.claude-sonnet-4-6"))
+        let vertex = try #require(catalog.pricing(
+            providerID: "google-vertex-anthropic",
+            modelID: "claude-sonnet-4-6"))
+
+        #expect(anthropic.normalizedModelID == "claude-sonnet-4-6")
+        #expect(vertex.normalizedModelID == "claude-sonnet-4-6")
+        #expect(vertex.pricing.inputCostPerToken == 3.1 / 1_000_000.0)
+    }
+
+    @Test
+    func `converts models dev per million token prices to per token prices`() throws {
+        let pricing = try #require(try Self.fixtureCatalog().pricing(
+            providerID: "anthropic",
+            modelID: "claude-sonnet-4-6")?
+            .pricing)
+
+        #expect(pricing.inputCostPerToken == 3 / 1_000_000.0)
+        #expect(pricing.outputCostPerToken == 15 / 1_000_000.0)
+        #expect(pricing.cacheReadInputCostPerToken == 0.3 / 1_000_000.0)
+        #expect(pricing.cacheCreationInputCostPerToken == 3.75 / 1_000_000.0)
+        #expect(pricing.thresholdTokens == 200_000)
+        #expect(pricing.inputCostPerTokenAboveThreshold == 6 / 1_000_000.0)
+        #expect(pricing.outputCostPerTokenAboveThreshold == 22.5 / 1_000_000.0)
+        #expect(pricing.cacheReadInputCostPerTokenAboveThreshold == 0.6 / 1_000_000.0)
+        #expect(pricing.cacheCreationInputCostPerTokenAboveThreshold == 7.5 / 1_000_000.0)
+    }
+
+    @Test
+    func `stale cache is still readable`() throws {
+        let root = try Self.cacheRoot()
+        let old = Date(timeIntervalSince1970: 1)
+        try ModelsDevCache.save(catalog: Self.fixtureCatalog(), fetchedAt: old, cacheRoot: root)
+
+        let load = ModelsDevCache.load(
+            now: Date(timeIntervalSince1970: 1 + ModelsDevCache.ttlSeconds + 1),
+            cacheRoot: root)
+
+        #expect(load.artifact != nil)
+        #expect(load.isStale)
+        #expect(load.error == nil)
+    }
+
+    @Test
+    func `pipeline lookup reads cached pricing`() throws {
+        let root = try Self.cacheRoot()
+        try ModelsDevCache.save(catalog: Self.fixtureCatalog(), fetchedAt: Date(), cacheRoot: root)
+
+        let lookup = try #require(ModelsDevPricingPipeline.lookup(
+            providerID: "openai",
+            modelID: "gpt-4o-mini",
+            cacheRoot: root))
+
+        #expect(lookup.pricing.inputCostPerToken == 0.15 / 1_000_000.0)
+    }
+
+    @Test
+    func `network failure preserves last valid cache`() async throws {
+        let root = try Self.cacheRoot()
+        let old = Date(timeIntervalSince1970: 1)
+        try ModelsDevCache.save(catalog: Self.fixtureCatalog(), fetchedAt: old, cacheRoot: root)
+
+        await ModelsDevPricingPipeline.refreshIfNeeded(
+            now: Date(timeIntervalSince1970: 1 + ModelsDevCache.ttlSeconds + 1),
+            cacheRoot: root,
+            client: ModelsDevClient(transport: MockTransport(result: .failure(MockError.failed))))
+
+        let lookup = try #require(ModelsDevPricingPipeline.lookup(
+            providerID: "openai",
+            modelID: "gpt-4o-mini",
+            cacheRoot: root))
+
+        #expect(lookup.pricing.inputCostPerToken == 0.15 / 1_000_000.0)
+    }
+
+    @Test
+    func `refresh preserves cache when fetched catalog drops cached provider`() async throws {
+        let root = try Self.cacheRoot()
+        let old = Date(timeIntervalSince1970: 1)
+        try ModelsDevCache.save(catalog: Self.fixtureCatalog(), fetchedAt: old, cacheRoot: root)
+
+        let partialCatalog = Data("""
+        {
+          "openai": { "id": 7, "models": [] },
+          "anthropic": {
+            "id": "anthropic",
+            "models": {
+              "shared-model": {
+                "id": "shared-model",
+                "cost": { "input": 99, "output": 99 }
+              }
+            }
+          }
+        }
+        """.utf8)
+        await ModelsDevPricingPipeline.refreshIfNeeded(
+            now: Date(timeIntervalSince1970: 1 + ModelsDevCache.ttlSeconds + 1),
+            cacheRoot: root,
+            client: ModelsDevClient(transport: MockTransport(
+                result: .success((partialCatalog, Self.response(status: 200))))))
+
+        let lookup = try #require(ModelsDevPricingPipeline.lookup(
+            providerID: "openai",
+            modelID: "gpt-4o-mini",
+            cacheRoot: root))
+
+        #expect(lookup.pricing.inputCostPerToken == 0.15 / 1_000_000.0)
+    }
+}
+
+extension ModelsDevPricingTests {
+    @Test
+    func `refresh accepts model churn and preserves removed pricing as fallback`() async throws {
+        let root = try Self.cacheRoot()
+        let old = Date(timeIntervalSince1970: 1)
+        try ModelsDevCache.save(catalog: Self.fixtureCatalog(), fetchedAt: old, cacheRoot: root)
+
+        let partialCatalog = Data("""
+        {
+          "openai": {
+            "id": "openai",
+            "models": {
+              "shared-model": {
+                "id": "shared-model",
+                "cost": { "input": 99, "output": 99 }
+              },
+              "provider-a-new": {
+                "id": "provider-a-new",
+                "cost": { "input": 7, "output": 8 }
+              }
+            }
+          },
+          "anthropic": {
+            "id": "anthropic",
+            "models": {
+              "shared-model": {
+                "id": "shared-model",
+                "cost": { "input": 99, "output": 99 }
+              }
+            }
+          },
+          "google-vertex-anthropic": {
+            "id": "google-vertex-anthropic",
+            "models": {
+              "claude-sonnet-4-6": {
+                "id": "claude-sonnet-4-6",
+                "cost": { "input": 99, "output": 99 }
+              }
+            }
+          }
+        }
+        """.utf8)
+        await ModelsDevPricingPipeline.refreshIfNeeded(
+            now: Date(timeIntervalSince1970: 1 + ModelsDevCache.ttlSeconds + 1),
+            cacheRoot: root,
+            client: ModelsDevClient(transport: MockTransport(
+                result: .success((partialCatalog, Self.response(status: 200))))))
+
+        let oldLookup = try #require(ModelsDevPricingPipeline.lookup(
+            providerID: "openai",
+            modelID: "gpt-4o-mini",
+            cacheRoot: root))
+        let newLookup = try #require(ModelsDevPricingPipeline.lookup(
+            providerID: "openai",
+            modelID: "provider-a-new",
+            cacheRoot: root))
+        let updatedLookup = try #require(ModelsDevPricingPipeline.lookup(
+            providerID: "openai",
+            modelID: "shared-model",
+            cacheRoot: root))
+
+        #expect(oldLookup.pricing.inputCostPerToken == 0.15 / 1_000_000.0)
+        #expect(newLookup.pricing.inputCostPerToken == 7 / 1_000_000.0)
+        #expect(updatedLookup.pricing.inputCostPerToken == 99 / 1_000_000.0)
+    }
+
+    @Test
+    func `accumulated fallback models do not freeze later refreshes`() async throws {
+        let root = try Self.cacheRoot()
+        let old = Date(timeIntervalSince1970: 1)
+        let cachedCatalog = try Self.catalog("""
+        {
+          "openai": {
+            "id": "openai",
+            "models": {
+              "provider-a-old": { "id": "provider-a-old", "cost": { "input": 1, "output": 2 } }
+            }
+          },
+          "anthropic": {
+            "id": "anthropic",
+            "models": {
+              "provider-b-old": { "id": "provider-b-old", "cost": { "input": 3, "output": 4 } }
+            }
+          },
+          "stale-a": {
+            "id": "stale-a",
+            "models": {
+              "model-a": { "id": "model-a", "cost": { "input": 5, "output": 6 } }
+            }
+          },
+          "stale-b": {
+            "id": "stale-b",
+            "models": {
+              "model-b": { "id": "model-b", "cost": { "input": 7, "output": 8 } }
+            }
+          },
+          "stale-c": {
+            "id": "stale-c",
+            "models": {
+              "model-c": { "id": "model-c", "cost": { "input": 9, "output": 10 } }
+            }
+          }
+        }
+        """)
+        ModelsDevCache.save(catalog: cachedCatalog, fetchedAt: old, cacheRoot: root)
+
+        let fetchedCatalog = Data("""
+        {
+          "openai": {
+            "id": "openai",
+            "models": {
+              "provider-a-new": { "id": "provider-a-new", "cost": { "input": 11, "output": 12 } }
+            }
+          },
+          "anthropic": {
+            "id": "anthropic",
+            "models": {
+              "provider-b-new": { "id": "provider-b-new", "cost": { "input": 13, "output": 14 } }
+            }
+          }
+        }
+        """.utf8)
+        await ModelsDevPricingPipeline.refreshIfNeeded(
+            now: Date(timeIntervalSince1970: 1 + ModelsDevCache.ttlSeconds + 1),
+            cacheRoot: root,
+            client: ModelsDevClient(transport: MockTransport(
+                result: .success((fetchedCatalog, Self.response(status: 200))))))
+
+        let newLookup = try #require(ModelsDevPricingPipeline.lookup(
+            providerID: "openai",
+            modelID: "provider-a-new",
+            cacheRoot: root))
+        let fallbackLookup = try #require(ModelsDevPricingPipeline.lookup(
+            providerID: "stale-a",
+            modelID: "model-a",
+            cacheRoot: root))
+
+        #expect(newLookup.pricing.inputCostPerToken == 11 / 1_000_000.0)
+        #expect(fallbackLookup.pricing.inputCostPerToken == 5 / 1_000_000.0)
+    }
+
+    @Test
+    func `historical fallback does not overwrite a refreshed model that reuses its map key`() async throws {
+        let root = try Self.cacheRoot()
+        let old = Date(timeIntervalSince1970: 1)
+        let cachedCatalog = try Self.catalog("""
+        {
+          "openai": {
+            "id": "openai",
+            "models": {
+              "rolling": { "id": "provider-a-old", "cost": { "input": 1, "output": 2 } }
+            }
+          },
+          "anthropic": {
+            "id": "anthropic",
+            "models": {
+              "provider-b-anchor": { "id": "provider-b-anchor", "cost": { "input": 3, "output": 4 } }
+            }
+          }
+        }
+        """)
+        ModelsDevCache.save(catalog: cachedCatalog, fetchedAt: old, cacheRoot: root)
+
+        let fetchedCatalog = Data("""
+        {
+          "openai": {
+            "id": "openai",
+            "models": {
+              "rolling": { "id": "provider-a-new", "cost": { "input": 99, "output": 100 } }
+            }
+          },
+          "anthropic": {
+            "id": "anthropic",
+            "models": {
+              "provider-b-anchor": { "id": "provider-b-anchor", "cost": { "input": 3, "output": 4 } }
+            }
+          }
+        }
+        """.utf8)
+        await ModelsDevPricingPipeline.refreshIfNeeded(
+            now: Date(timeIntervalSince1970: 1 + ModelsDevCache.ttlSeconds + 1),
+            cacheRoot: root,
+            client: ModelsDevClient(transport: MockTransport(
+                result: .success((fetchedCatalog, Self.response(status: 200))))))
+
+        let freshLookup = try #require(ModelsDevPricingPipeline.lookup(
+            providerID: "openai",
+            modelID: "provider-a-new",
+            cacheRoot: root))
+        let fallbackLookup = try #require(ModelsDevPricingPipeline.lookup(
+            providerID: "openai",
+            modelID: "provider-a-old",
+            cacheRoot: root))
+
+        #expect(freshLookup.pricing.inputCostPerToken == 99 / 1_000_000.0)
+        #expect(fallbackLookup.pricing.inputCostPerToken == 1 / 1_000_000.0)
+    }
+
+    @Test
+    func `refresh updates cache when fetched catalog renames model key but keeps id`() async throws {
+        let root = try Self.cacheRoot()
+        let old = Date(timeIntervalSince1970: 1)
+        try ModelsDevCache.save(catalog: Self.fixtureCatalog(), fetchedAt: old, cacheRoot: root)
+
+        let renamedCatalog = Data("""
+        {
+          "openai": {
+            "id": "openai",
+            "models": {
+              "renamed-model-key": {
+                "id": "gpt-4o-mini",
+                "cost": { "input": 99, "output": 99 }
+              },
+              "shared-model": {
+                "id": "shared-model",
+                "cost": { "input": 99, "output": 99 }
+              }
+            }
+          },
+          "anthropic": {
+            "id": "anthropic",
+            "models": {
+              "claude-sonnet-4-6": {
+                "id": "claude-sonnet-4-6",
+                "cost": { "input": 99, "output": 99 }
+              },
+              "shared-model": {
+                "id": "shared-model",
+                "cost": { "input": 99, "output": 99 }
+              }
+            }
+          },
+          "google-vertex-anthropic": {
+            "id": "google-vertex-anthropic",
+            "models": {
+              "renamed-vertex-key": {
+                "id": "claude-sonnet-4-6",
+                "cost": { "input": 99, "output": 99 }
+              }
+            }
+          }
+        }
+        """.utf8)
+        await ModelsDevPricingPipeline.refreshIfNeeded(
+            now: Date(timeIntervalSince1970: 1 + ModelsDevCache.ttlSeconds + 1),
+            cacheRoot: root,
+            client: ModelsDevClient(transport: MockTransport(
+                result: .success((renamedCatalog, Self.response(status: 200))))))
+
+        let lookup = try #require(ModelsDevPricingPipeline.lookup(
+            providerID: "openai",
+            modelID: "gpt-4o-mini",
+            cacheRoot: root))
+
+        #expect(lookup.normalizedModelID == "gpt-4o-mini")
+        #expect(lookup.pricing.inputCostPerToken == 99 / 1_000_000.0)
+    }
+
+    @Test
+    func `refresh preserves cache when fetched matching model is not priceable`() async throws {
+        let root = try Self.cacheRoot()
+        let old = Date(timeIntervalSince1970: 1)
+        try ModelsDevCache.save(catalog: Self.fixtureCatalog(), fetchedAt: old, cacheRoot: root)
+
+        let partialCatalog = Data("""
+        {
+          "openai": {
+            "id": "openai",
+            "models": {
+              "gpt-4o-mini": {
+                "id": "gpt-4o-mini",
+                "cost": { "input": 99 }
+              },
+              "shared-model": {
+                "id": "shared-model",
+                "cost": { "input": 99, "output": 99 }
+              }
+            }
+          },
+          "anthropic": {
+            "id": "anthropic",
+            "models": {
+              "claude-sonnet-4-6": {
+                "id": "claude-sonnet-4-6",
+                "cost": { "input": 99, "output": 99 }
+              },
+              "shared-model": {
+                "id": "shared-model",
+                "cost": { "input": 99, "output": 99 }
+              }
+            }
+          },
+          "google-vertex-anthropic": {
+            "id": "google-vertex-anthropic",
+            "models": {
+              "claude-sonnet-4-6": {
+                "id": "claude-sonnet-4-6",
+                "cost": { "input": 99, "output": 99 }
+              }
+            }
+          }
+        }
+        """.utf8)
+        await ModelsDevPricingPipeline.refreshIfNeeded(
+            now: Date(timeIntervalSince1970: 1 + ModelsDevCache.ttlSeconds + 1),
+            cacheRoot: root,
+            client: ModelsDevClient(transport: MockTransport(
+                result: .success((partialCatalog, Self.response(status: 200))))))
+
+        let lookup = try #require(ModelsDevPricingPipeline.lookup(
+            providerID: "openai",
+            modelID: "gpt-4o-mini",
+            cacheRoot: root))
+        let updatedLookup = try #require(ModelsDevPricingPipeline.lookup(
+            providerID: "openai",
+            modelID: "shared-model",
+            cacheRoot: root))
+
+        #expect(lookup.pricing.inputCostPerToken == 0.15 / 1_000_000.0)
+        #expect(updatedLookup.pricing.inputCostPerToken == 99 / 1_000_000.0)
+    }
+
+    @Test
+    func `refresh updates cache when fetched catalog canonicalizes alias model id`() async throws {
+        let root = try Self.cacheRoot()
+        let old = Date(timeIntervalSince1970: 1)
+        let cachedCatalog = try Self.catalog("""
+        {
+          "openai": {
+            "id": "openai",
+            "models": {
+              "gpt-4o-mini": {
+                "id": "gpt-4o-mini",
+                "cost": { "input": 0.15, "output": 0.6 }
+              }
+            }
+          },
+          "anthropic": {
+            "id": "anthropic",
+            "models": {
+              "claude-sonnet-4-6": {
+                "id": "claude-sonnet-4-6",
+                "cost": { "input": 3, "output": 15 }
+              }
+            }
+          },
+          "google-vertex-anthropic": {
+            "id": "google-vertex-anthropic",
+            "models": {
+              "snapshot-model@20250101": {
+                "id": "snapshot-model@20250101",
+                "cost": { "input": 3.1, "output": 15.1 }
+              }
+            }
+          }
+        }
+        """)
+        ModelsDevCache.save(catalog: cachedCatalog, fetchedAt: old, cacheRoot: root)
+
+        let canonicalizedCatalog = Data("""
+        {
+          "openai": {
+            "id": "openai",
+            "models": {
+              "gpt-4o-mini": {
+                "id": "gpt-4o-mini",
+                "cost": { "input": 99, "output": 99 }
+              },
+              "shared-model": {
+                "id": "shared-model",
+                "cost": { "input": 99, "output": 99 }
+              }
+            }
+          },
+          "anthropic": {
+            "id": "anthropic",
+            "models": {
+              "claude-sonnet-4-6": {
+                "id": "claude-sonnet-4-6",
+                "cost": { "input": 99, "output": 99 }
+              },
+              "shared-model": {
+                "id": "shared-model",
+                "cost": { "input": 99, "output": 99 }
+              }
+            }
+          },
+          "google-vertex-anthropic": {
+            "id": "google-vertex-anthropic",
+            "models": {
+              "snapshot-model-20250101": {
+                "id": "snapshot-model-20250101",
+                "cost": { "input": 99, "output": 99 }
+              }
+            }
+          }
+        }
+        """.utf8)
+        await ModelsDevPricingPipeline.refreshIfNeeded(
+            now: Date(timeIntervalSince1970: 1 + ModelsDevCache.ttlSeconds + 1),
+            cacheRoot: root,
+            client: ModelsDevClient(transport: MockTransport(
+                result: .success((canonicalizedCatalog, Self.response(status: 200))))))
+
+        let aliasLookup = try #require(ModelsDevPricingPipeline.lookup(
+            providerID: "google-vertex-anthropic",
+            modelID: "snapshot-model@20250101",
+            cacheRoot: root))
+        let canonicalLookup = try #require(ModelsDevPricingPipeline.lookup(
+            providerID: "google-vertex-anthropic",
+            modelID: "snapshot-model-20250101",
+            cacheRoot: root))
+
+        #expect(aliasLookup.pricing.inputCostPerToken == 99 / 1_000_000.0)
+        #expect(canonicalLookup.pricing.inputCostPerToken == 99 / 1_000_000.0)
+    }
+
+    @Test
+    func `fallback merge treats default alias as the canonical base model`() throws {
+        let cachedCatalog = try Self.catalog("""
+        {
+          "anthropic": {
+            "id": "anthropic",
+            "models": {
+              "base-model@default": {
+                "id": "base-model@default",
+                "cost": { "input": 3, "output": 15 }
+              }
+            }
+          }
+        }
+        """)
+        let refreshedCatalog = try Self.catalog("""
+        {
+          "anthropic": {
+            "id": "anthropic",
+            "models": {
+              "base-model": {
+                "id": "base-model",
+                "cost": { "input": 99, "output": 100 }
+              }
+            }
+          }
+        }
+        """)
+
+        let merged = refreshedCatalog.mergingFallbackPricing(from: cachedCatalog)
+        let aliasLookup = try #require(merged.pricing(
+            providerID: "anthropic",
+            modelID: "base-model@default"))
+
+        #expect(aliasLookup.pricing.inputCostPerToken == 99 / 1_000_000.0)
+        #expect(merged.providers["anthropic"]?.models.count == 1)
+    }
+
+    @Test
+    func `fallback merge treats provider version alias as the canonical base model`() throws {
+        let cachedCatalog = try Self.catalog("""
+        {
+          "openai": {
+            "id": "openai",
+            "models": {
+              "openai/base-model-v1:0": {
+                "id": "openai/base-model-v1:0",
+                "cost": { "input": 3, "output": 15 }
+              }
+            }
+          }
+        }
+        """)
+        let refreshedCatalog = try Self.catalog("""
+        {
+          "openai": {
+            "id": "openai",
+            "models": {
+              "base-model": {
+                "id": "base-model",
+                "cost": { "input": 99, "output": 100 }
+              }
+            }
+          }
+        }
+        """)
+
+        let merged = refreshedCatalog.mergingFallbackPricing(from: cachedCatalog)
+        let aliasLookup = try #require(merged.pricing(
+            providerID: "openai",
+            modelID: "openai/base-model-v1:0"))
+
+        #expect(aliasLookup.pricing.inputCostPerToken == 99 / 1_000_000.0)
+        #expect(merged.providers["openai"]?.models.count == 1)
+    }
+
+    @Test
+    func `refresh keeps historical pinned pricing while accepting a new snapshot`() async throws {
+        let root = try Self.cacheRoot()
+        let old = Date(timeIntervalSince1970: 1)
+        let cachedCatalog = try Self.catalog("""
+        {
+          "google-vertex-anthropic": {
+            "id": "google-vertex-anthropic",
+            "models": {
+              "snapshot-model@20250101": {
+                "id": "snapshot-model@20250101",
+                "cost": { "input": 3, "output": 15 }
+              }
+            }
+          }
+        }
+        """)
+        ModelsDevCache.save(catalog: cachedCatalog, fetchedAt: old, cacheRoot: root)
+
+        let fetchedCatalog = Data("""
+        {
+          "openai": {
+            "id": "openai",
+            "models": {
+              "provider-a-anchor": {
+                "id": "provider-a-anchor",
+                "cost": { "input": 1, "output": 2 }
+              }
+            }
+          },
+          "anthropic": {
+            "id": "anthropic",
+            "models": {
+              "provider-b-anchor": {
+                "id": "provider-b-anchor",
+                "cost": { "input": 3, "output": 4 }
+              }
+            }
+          },
+          "google-vertex-anthropic": {
+            "id": "google-vertex-anthropic",
+            "models": {
+              "snapshot-model@20250201": {
+                "id": "snapshot-model@20250201",
+                "cost": { "input": 99, "output": 99 }
+              }
+            }
+          }
+        }
+        """.utf8)
+        await ModelsDevPricingPipeline.refreshIfNeeded(
+            now: Date(timeIntervalSince1970: 1 + ModelsDevCache.ttlSeconds + 1),
+            cacheRoot: root,
+            client: ModelsDevClient(transport: MockTransport(
+                result: .success((fetchedCatalog, Self.response(status: 200))))))
+
+        let oldLookup = try #require(ModelsDevPricingPipeline.lookup(
+            providerID: "google-vertex-anthropic",
+            modelID: "snapshot-model@20250101",
+            cacheRoot: root))
+        let newLookup = try #require(ModelsDevPricingPipeline.lookup(
+            providerID: "google-vertex-anthropic",
+            modelID: "snapshot-model@20250201",
+            cacheRoot: root))
+
+        #expect(oldLookup.pricing.inputCostPerToken == 3 / 1_000_000.0)
+        #expect(newLookup.pricing.inputCostPerToken == 99 / 1_000_000.0)
+    }
+
+    @Test
+    func `refresh preserves dated snapshot when fetched catalog only keeps base model`() async throws {
+        let root = try Self.cacheRoot()
+        let old = Date(timeIntervalSince1970: 1)
+        let cachedCatalog = try Self.catalog("""
+        {
+          "openai": {
+            "id": "openai",
+            "models": {
+              "historical-map-key": {
+                "id": "snapshot-model-2025-01-01",
+                "cost": { "input": 3, "output": 15 }
+              }
+            }
+          },
+          "anthropic": {
+            "id": "anthropic",
+            "models": {
+              "provider-b-anchor": {
+                "id": "provider-b-anchor",
+                "cost": { "input": 3, "output": 4 }
+              }
+            }
+          }
+        }
+        """)
+        ModelsDevCache.save(catalog: cachedCatalog, fetchedAt: old, cacheRoot: root)
+
+        let fetchedCatalog = Data("""
+        {
+          "openai": {
+            "id": "openai",
+            "models": {
+              "snapshot-model": {
+                "id": "snapshot-model",
+                "cost": { "input": 99, "output": 99 }
+              }
+            }
+          },
+          "anthropic": {
+            "id": "anthropic",
+            "models": {
+              "provider-b-anchor": {
+                "id": "provider-b-anchor",
+                "cost": { "input": 3, "output": 4 }
+              }
+            }
+          }
+        }
+        """.utf8)
+        await ModelsDevPricingPipeline.refreshIfNeeded(
+            now: Date(timeIntervalSince1970: 1 + ModelsDevCache.ttlSeconds + 1),
+            cacheRoot: root,
+            client: ModelsDevClient(transport: MockTransport(
+                result: .success((fetchedCatalog, Self.response(status: 200))))))
+
+        let snapshotLookup = try #require(ModelsDevPricingPipeline.lookup(
+            providerID: "openai",
+            modelID: "snapshot-model-2025-01-01",
+            cacheRoot: root))
+        let baseLookup = try #require(ModelsDevPricingPipeline.lookup(
+            providerID: "openai",
+            modelID: "snapshot-model",
+            cacheRoot: root))
+
+        #expect(snapshotLookup.pricing.inputCostPerToken == 3 / 1_000_000.0)
+        #expect(baseLookup.pricing.inputCostPerToken == 99 / 1_000_000.0)
+    }
+
+    @Test
+    func `compact snapshot alias prefers snapshot pricing over base pricing`() throws {
+        let catalog = try Self.catalog("""
+        {
+          "openai": {
+            "id": "openai",
+            "models": {
+              "snapshot-model": {
+                "id": "snapshot-model",
+                "cost": { "input": 99, "output": 100 }
+              },
+              "snapshot-model-20250101": {
+                "id": "snapshot-model-20250101",
+                "cost": { "input": 3, "output": 15 }
+              }
+            }
+          }
+        }
+        """)
+
+        let lookup = try #require(catalog.pricing(
+            providerID: "openai",
+            modelID: "snapshot-model@20250101"))
+
+        #expect(lookup.pricing.inputCostPerToken == 3 / 1_000_000.0)
+        #expect(lookup.normalizedModelID == "snapshot-model-20250101")
+    }
+
+    @Test
+    func `refresh ignores unpriceable models in old cache continuity check`() async throws {
+        let root = try Self.cacheRoot()
+        let old = Date(timeIntervalSince1970: 1)
+        let cachedCatalog = try Self.catalog("""
+        {
+          "openai": {
+            "id": "openai",
+            "models": {
+              "gpt-4o-mini": {
+                "id": "gpt-4o-mini",
+                "cost": { "input": 0.15, "output": 0.6 }
+              },
+              "unpriced-model": {
+                "id": "unpriced-model"
+              }
+            }
+          }
+        }
+        """)
+        ModelsDevCache.save(catalog: cachedCatalog, fetchedAt: old, cacheRoot: root)
+
+        let fetchedCatalog = Data("""
+        {
+          "openai": {
+            "id": "openai",
+            "models": {
+              "gpt-4o-mini": {
+                "id": "gpt-4o-mini",
+                "cost": { "input": 99, "output": 99 }
+              }
+            }
+          },
+          "anthropic": {
+            "id": "anthropic",
+            "models": {
+              "provider-b-anchor": {
+                "id": "provider-b-anchor",
+                "cost": { "input": 3, "output": 4 }
+              }
+            }
+          }
+        }
+        """.utf8)
+        await ModelsDevPricingPipeline.refreshIfNeeded(
+            now: Date(timeIntervalSince1970: 1 + ModelsDevCache.ttlSeconds + 1),
+            cacheRoot: root,
+            client: ModelsDevClient(transport: MockTransport(
+                result: .success((fetchedCatalog, Self.response(status: 200))))))
+
+        let lookup = try #require(ModelsDevPricingPipeline.lookup(
+            providerID: "openai",
+            modelID: "gpt-4o-mini",
+            cacheRoot: root))
+
+        #expect(lookup.pricing.inputCostPerToken == 99 / 1_000_000.0)
+    }
+
+    @Test
+    func `fresh cache does not refresh`() async throws {
+        let root = try Self.cacheRoot()
+        try ModelsDevCache.save(catalog: Self.fixtureCatalog(), fetchedAt: Date(), cacheRoot: root)
+        let transport = TrackingTransport(result: .failure(MockError.failed))
+
+        await ModelsDevPricingPipeline.refreshIfNeeded(
+            now: Date(),
+            cacheRoot: root,
+            client: ModelsDevClient(transport: transport))
+
+        #expect(transport.calls == 0)
+    }
+
+    @Test
+    func `corrupt cache is ignored safely`() throws {
+        let root = try Self.cacheRoot()
+        let url = ModelsDevCache.cacheFileURL(cacheRoot: root)
+        try FileManager.default.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true)
+        try Data("not json".utf8).write(to: url)
+
+        let load = ModelsDevCache.load(cacheRoot: root)
+
+        #expect(load.artifact == nil)
+        #expect(load.isStale)
+        #expect(load.error == .invalidJSON)
+    }
+
+    @Test
+    func `serves decoded catalog from memo while the file is unchanged`() throws {
+        let root = try Self.cacheRoot()
+        try ModelsDevCache.save(catalog: Self.fixtureCatalog(), fetchedAt: Date(), cacheRoot: root)
+        let url = ModelsDevCache.cacheFileURL(cacheRoot: root)
+
+        // Pin a whole-second modification date so the memo key (which compares modification dates) round-trips
+        // deterministically through the filesystem.
+        let pinnedDate = Date(timeIntervalSince1970: 1_700_000_000)
+        try FileManager.default.setAttributes([.modificationDate: pinnedDate], ofItemAtPath: url.path)
+
+        // Prime the in-memory memo with a successful decode.
+        let primed = ModelsDevCache.load(cacheRoot: root)
+        let cachedArtifact = try #require(primed.artifact)
+
+        // Corrupt the file contents while preserving its size and modification date, so the on-disk identity
+        // the memo keys on is unchanged. A re-decode would now fail; a memo hit returns the cached artifact.
+        let size = try #require(
+            try (FileManager.default.attributesOfItem(atPath: url.path)[.size]) as? NSNumber).intValue
+        try Data(repeating: 0, count: size).write(to: url)
+        try FileManager.default.setAttributes([.modificationDate: pinnedDate], ofItemAtPath: url.path)
+
+        let reloaded = ModelsDevCache.load(cacheRoot: root)
+
+        #expect(reloaded.error == nil)
+        #expect(reloaded.artifact == cachedArtifact)
+    }
+
+    @Test
+    func `saving a new catalog invalidates the memo`() throws {
+        let root = try Self.cacheRoot()
+        try ModelsDevCache.save(catalog: Self.fixtureCatalog(), fetchedAt: Date(), cacheRoot: root)
+        #expect(ModelsDevCache.load(cacheRoot: root).artifact?.catalog.providers["openai"] != nil)
+
+        // Overwriting the cache must drop the memo so the next load reflects the freshly written catalog.
+        ModelsDevCache.save(catalog: ModelsDevCatalog(providers: [:]), fetchedAt: Date(), cacheRoot: root)
+        let reloaded = ModelsDevCache.load(cacheRoot: root)
+
+        #expect(reloaded.error == nil)
+        #expect(reloaded.artifact?.catalog.providers.isEmpty == true)
+    }
+
+    @Test
+    func `serves a failed load from memo while the file is unchanged`() throws {
+        let root = try Self.cacheRoot()
+        let url = ModelsDevCache.cacheFileURL(cacheRoot: root)
+        try FileManager.default.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true)
+        let validData = try Self.encodedArtifactData()
+
+        // Write invalid JSON of the same size as a valid encoding, with a pinned modification date, then prime
+        // the memo with the resulting failure.
+        let pinnedDate = Date(timeIntervalSince1970: 1_700_000_000)
+        try Data(repeating: 0x7B, count: validData.count).write(to: url)
+        try FileManager.default.setAttributes([.modificationDate: pinnedDate], ofItemAtPath: url.path)
+        #expect(ModelsDevCache.load(cacheRoot: root).error == .invalidJSON)
+
+        // Replace the bytes with a valid encoding of identical size + modification date. A re-read would now
+        // succeed, so a returned failure proves the unchanged-identity file was not read and decoded again.
+        try validData.write(to: url)
+        try FileManager.default.setAttributes([.modificationDate: pinnedDate], ofItemAtPath: url.path)
+        let reloaded = ModelsDevCache.load(cacheRoot: root)
+
+        #expect(reloaded.error == .invalidJSON)
+        #expect(reloaded.artifact == nil)
+    }
+
+    @Test
+    func `client fetches with mock transport`() async throws {
+        let data = try Self.fixtureData()
+        let client = ModelsDevClient(transport: MockTransport(result: .success((data, Self.response(status: 200)))))
+
+        let catalog = try await client.fetchCatalog()
+
+        #expect(catalog.providers["google-vertex-anthropic"]?.models["claude-sonnet-4-6"]?.cost?.input == 3.1)
+    }
+
+    @Test
+    func `client reports http and json failures`() async throws {
+        let data = try Self.fixtureData()
+        let httpClient = ModelsDevClient(transport: MockTransport(result: .success((data, Self.response(status: 500)))))
+        let jsonClient = ModelsDevClient(transport: MockTransport(
+            result: .success((Data("not json".utf8), Self.response(status: 200)))))
+
+        await #expect(throws: ModelsDevClient.Error.httpStatus(500)) {
+            _ = try await httpClient.fetchCatalog()
+        }
+        await #expect(throws: ModelsDevClient.Error.invalidJSON) {
+            _ = try await jsonClient.fetchCatalog()
+        }
+    }
+
+    private static func fixtureData() throws -> Data {
+        let url = try #require(Bundle.module.url(
+            forResource: "models-dev-subset",
+            withExtension: "json",
+            subdirectory: "Fixtures"))
+        return try Data(contentsOf: url)
+    }
+
+    private static func fixtureCatalog() throws -> ModelsDevCatalog {
+        try JSONDecoder().decode(ModelsDevCatalog.self, from: self.fixtureData())
+    }
+
+    /// A valid `ModelsDevCacheArtifact` encoding, written the same way `ModelsDevCache.save` writes the file.
+    private static func encodedArtifactData() throws -> Data {
+        let artifact = try ModelsDevCacheArtifact(
+            version: ModelsDevCache.artifactVersion,
+            fetchedAt: Date(timeIntervalSince1970: 0),
+            catalog: self.fixtureCatalog())
+        let encoder = JSONEncoder()
+        encoder.dateEncodingStrategy = .iso8601
+        return try encoder.encode(artifact)
+    }
+
+    private static func catalog(_ json: String) throws -> ModelsDevCatalog {
+        try JSONDecoder().decode(ModelsDevCatalog.self, from: Data(json.utf8))
+    }
+
+    private static func cacheRoot() throws -> URL {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-modelsdev-tests-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
+        return root
+    }
+
+    private static func response(status: Int) -> HTTPURLResponse {
+        HTTPURLResponse(
+            url: URL(string: "https://models.dev/api.json")!,
+            statusCode: status,
+            httpVersion: nil,
+            headerFields: nil)!
+    }
+}
+
+private enum MockError: Error {
+    case failed
+}
+
+private struct MockTransport: ModelsDevHTTPTransport {
+    let result: Result<(Data, URLResponse), Error>
+
+    func data(for _: URLRequest) async throws -> (Data, URLResponse) {
+        try self.result.get()
+    }
+}
+
+private final class TrackingTransport: ModelsDevHTTPTransport, @unchecked Sendable {
+    private(set) var calls = 0
+    let result: Result<(Data, URLResponse), Error>
+
+    init(result: Result<(Data, URLResponse), Error>) {
+        self.result = result
+    }
+
+    func data(for _: URLRequest) async throws -> (Data, URLResponse) {
+        self.calls += 1
+        return try self.result.get()
+    }
+}
diff --git a/Tests/CodexBarTests/MoonshotSettingsReaderTests.swift b/Tests/CodexBarTests/MoonshotSettingsReaderTests.swift
new file mode 100644
index 0000000000..3188f5dd64
--- /dev/null
+++ b/Tests/CodexBarTests/MoonshotSettingsReaderTests.swift
@@ -0,0 +1,68 @@
+import CodexBarCore
+import Testing
+
+struct MoonshotSettingsReaderTests {
+    @Test
+    func `api key prefers MOONSHOT API KEY`() {
+        let env = [
+            "MOONSHOT_API_KEY": "primary-token",
+            "MOONSHOT_KEY": "fallback-token",
+        ]
+
+        #expect(MoonshotSettingsReader.apiKey(environment: env) == "primary-token")
+    }
+
+    @Test
+    func `api key strips quotes`() {
+        let env = ["MOONSHOT_KEY": "\"quoted-token\""]
+
+        #expect(MoonshotSettingsReader.apiKey(environment: env) == "quoted-token")
+    }
+
+    @Test
+    func `region parses china`() {
+        let env = ["MOONSHOT_REGION": "china"]
+
+        #expect(MoonshotSettingsReader.region(environment: env) == .china)
+    }
+
+    @Test
+    func `default settings snapshot does not mask environment region`() {
+        let settings = ProviderSettingsSnapshot.MoonshotProviderSettings()
+
+        #expect(settings.region == nil)
+    }
+
+    @Test
+    func `region defaults to international for unknown values`() {
+        let env = ["MOONSHOT_REGION": "moon"]
+
+        #expect(MoonshotSettingsReader.region(environment: env) == .international)
+    }
+}
+
+struct MoonshotProviderTokenResolverTests {
+    @Test
+    func `resolves from environment`() {
+        let env = ["MOONSHOT_API_KEY": "env-token"]
+        let resolution = ProviderTokenResolver.moonshotResolution(environment: env)
+
+        #expect(resolution?.token == "env-token")
+        #expect(resolution?.source == .environment)
+    }
+
+    @Test
+    func `uses kimi branding icon`() {
+        let branding = MoonshotProviderDescriptor.descriptor.branding
+
+        #expect(branding.iconStyle == .kimi)
+        #expect(branding.iconResourceName == "ProviderIcon-kimi")
+    }
+
+    @Test
+    func `dashboard url opens account console`() {
+        #expect(
+            MoonshotProviderDescriptor.descriptor.metadata.dashboardURL
+                == "https://platform.moonshot.ai/console/account")
+    }
+}
diff --git a/Tests/CodexBarTests/MoonshotUsageFetcherTests.swift b/Tests/CodexBarTests/MoonshotUsageFetcherTests.swift
new file mode 100644
index 0000000000..7d69af2af9
--- /dev/null
+++ b/Tests/CodexBarTests/MoonshotUsageFetcherTests.swift
@@ -0,0 +1,220 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct MoonshotUsageFetcherTests {
+    @Test
+    func `parses documented response`() throws {
+        let json = """
+        {
+          "code": 0,
+          "data": {
+            "available_balance": 49.58,
+            "voucher_balance": 50.00,
+            "cash_balance": 12.34
+          },
+          "scode": "0x0",
+          "status": true
+        }
+        """
+
+        let summary = try MoonshotUsageFetcher._parseSummaryForTesting(Data(json.utf8))
+
+        #expect(summary.availableBalance == 49.58)
+        #expect(summary.voucherBalance == 50.00)
+        #expect(summary.cashBalance == 12.34)
+
+        let usage = MoonshotUsageSnapshot(summary: summary).toUsageSnapshot()
+        #expect(usage.primary == nil)
+        #expect(usage.secondary == nil)
+        #expect(usage.loginMethod(for: .moonshot) == "Balance: $49.58")
+    }
+
+    @Test
+    func `negative cash balance is surfaced as deficit`() throws {
+        let json = """
+        {
+          "code": 0,
+          "data": {
+            "available_balance": 49.58,
+            "voucher_balance": 50.00,
+            "cash_balance": -0.42
+          },
+          "scode": "0x0",
+          "status": true
+        }
+        """
+
+        let summary = try MoonshotUsageFetcher._parseSummaryForTesting(Data(json.utf8))
+        let usage = MoonshotUsageSnapshot(summary: summary).toUsageSnapshot()
+
+        #expect(summary.cashBalance == -0.42)
+        #expect(usage.loginMethod(for: .moonshot)?.contains("in deficit") == true)
+    }
+
+    @Test
+    func `invalid root returns parse error`() {
+        let json = """
+        [{ "available_balance": 1 }]
+        """
+
+        #expect {
+            _ = try MoonshotUsageFetcher._parseSummaryForTesting(Data(json.utf8))
+        } throws: { error in
+            guard case MoonshotUsageError.parseFailed = error else { return false }
+            return true
+        }
+    }
+
+    @Test
+    func `api code failure returns api error`() {
+        let json = """
+        {
+          "code": 401,
+          "data": {
+            "available_balance": 0,
+            "voucher_balance": 0,
+            "cash_balance": 0
+          },
+          "scode": "unauthorized",
+          "status": false
+        }
+        """
+
+        #expect {
+            _ = try MoonshotUsageFetcher._parseSummaryForTesting(Data(json.utf8))
+        } throws: { error in
+            guard case let MoonshotUsageError.apiError(message) = error else { return false }
+            return message == "code 401, scode unauthorized"
+        }
+    }
+
+    @Test
+    func `international host uses moonshot ai`() {
+        let url = MoonshotUsageFetcher.resolveBalanceURL(region: .international)
+
+        #expect(url.absoluteString == "https://api.moonshot.ai/v1/users/me/balance")
+    }
+
+    @Test
+    func `china host uses moonshot cn`() {
+        let url = MoonshotUsageFetcher.resolveBalanceURL(region: .china)
+
+        #expect(url.absoluteString == "https://api.moonshot.cn/v1/users/me/balance")
+    }
+
+    @Test
+    func `fetch usage sends bearer token and bounded request`() async throws {
+        defer {
+            MoonshotStubURLProtocol.requests = []
+            MoonshotStubURLProtocol.handler = nil
+        }
+
+        let config = URLSessionConfiguration.ephemeral
+        config.protocolClasses = [MoonshotStubURLProtocol.self]
+        let session = URLSession(configuration: config)
+
+        MoonshotStubURLProtocol.requests = []
+        MoonshotStubURLProtocol.handler = { request in
+            let url = try #require(request.url)
+            #expect(url.absoluteString == "https://api.moonshot.cn/v1/users/me/balance")
+            #expect(request.httpMethod == "GET")
+            #expect(request.value(forHTTPHeaderField: "Authorization") == "Bearer live-token")
+            #expect(request.value(forHTTPHeaderField: "Accept") == "application/json")
+            #expect(request.timeoutInterval == 15)
+
+            let body = """
+            {
+              "code": 0,
+              "data": {
+                "available_balance": 9.87,
+                "voucher_balance": 1.23,
+                "cash_balance": 8.64
+              },
+              "scode": "0x0",
+              "status": true
+            }
+            """
+            let response = HTTPURLResponse(
+                url: url,
+                statusCode: 200,
+                httpVersion: nil,
+                headerFields: ["Content-Type": "application/json"])!
+            return (response, Data(body.utf8))
+        }
+
+        let snapshot = try await MoonshotUsageFetcher.fetchUsage(
+            apiKey: " live-token ",
+            region: .china,
+            session: session)
+
+        #expect(MoonshotStubURLProtocol.requests.count == 1)
+        #expect(snapshot.summary.availableBalance == 9.87)
+        #expect(snapshot.toUsageSnapshot().loginMethod(for: .moonshot) == "Balance: $9.87")
+    }
+
+    @Test
+    func `fetch usage surfaces http failure without leaking body`() async throws {
+        defer {
+            MoonshotStubURLProtocol.requests = []
+            MoonshotStubURLProtocol.handler = nil
+        }
+
+        let config = URLSessionConfiguration.ephemeral
+        config.protocolClasses = [MoonshotStubURLProtocol.self]
+        let session = URLSession(configuration: config)
+
+        MoonshotStubURLProtocol.requests = []
+        MoonshotStubURLProtocol.handler = { request in
+            let url = try #require(request.url)
+            let response = HTTPURLResponse(
+                url: url,
+                statusCode: 401,
+                httpVersion: nil,
+                headerFields: ["Content-Type": "application/json"])!
+            return (response, Data(#"{"error":"secret-ish provider body"}"#.utf8))
+        }
+
+        await #expect {
+            _ = try await MoonshotUsageFetcher.fetchUsage(
+                apiKey: "live-token",
+                session: session)
+        } throws: { error in
+            guard case let MoonshotUsageError.apiError(message) = error else { return false }
+            return message == "HTTP 401"
+        }
+    }
+}
+
+final class MoonshotStubURLProtocol: URLProtocol {
+    nonisolated(unsafe) static var requests: [URLRequest] = []
+    nonisolated(unsafe) static var handler: (@Sendable (URLRequest) throws -> (HTTPURLResponse, Data))?
+
+    override static func canInit(with _: URLRequest) -> Bool {
+        true
+    }
+
+    override static func canonicalRequest(for request: URLRequest) -> URLRequest {
+        request
+    }
+
+    override func startLoading() {
+        Self.requests.append(self.request)
+        guard let handler = Self.handler else {
+            self.client?.urlProtocol(self, didFailWithError: URLError(.badServerResponse))
+            return
+        }
+
+        do {
+            let (response, data) = try handler(self.request)
+            self.client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
+            self.client?.urlProtocol(self, didLoad: data)
+            self.client?.urlProtocolDidFinishLoading(self)
+        } catch {
+            self.client?.urlProtocol(self, didFailWithError: error)
+        }
+    }
+
+    override func stopLoading() {}
+}
diff --git a/Tests/CodexBarTests/OllamaUsageFetcherRetryMappingTests.swift b/Tests/CodexBarTests/OllamaUsageFetcherRetryMappingTests.swift
index ceff208135..cb42bccce0 100644
--- a/Tests/CodexBarTests/OllamaUsageFetcherRetryMappingTests.swift
+++ b/Tests/CodexBarTests/OllamaUsageFetcherRetryMappingTests.swift
@@ -4,8 +4,115 @@ import Testing
 
 @Suite(.serialized)
 struct OllamaUsageFetcherRetryMappingTests {
+    private func makeContext(
+        sourceMode: ProviderSourceMode,
+        env: [String: String] = [:],
+        settings: ProviderSettingsSnapshot? = nil) -> ProviderFetchContext
+    {
+        let browserDetection = BrowserDetection(cacheTTL: 0)
+        return ProviderFetchContext(
+            runtime: .cli,
+            sourceMode: sourceMode,
+            includeCredits: false,
+            webTimeout: 1,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: env,
+            settings: settings,
+            fetcher: UsageFetcher(),
+            claudeFetcher: ClaudeUsageFetcher(browserDetection: browserDetection),
+            browserDetection: browserDetection)
+    }
+
+    @Test
+    func `api key reader trims configured environment key`() {
+        let token = OllamaAPISettingsReader.apiKey(environment: ["OLLAMA_API_KEY": " 'ollama-test' "])
+
+        #expect(token == "ollama-test")
+    }
+
+    @Test
+    func `api tags response maps to API key identity`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let snapshot = try OllamaAPIUsageFetcher._parseTagsForTesting(
+            Data(#"{"models":[{"name":"gpt-oss:120b"}]}"#.utf8),
+            now: now)
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(snapshot.modelCount == 1)
+        #expect(usage.primary == nil)
+        #expect(usage.identity?.providerID == .ollama)
+        #expect(usage.identity?.loginMethod == "API key")
+        #expect(usage.updatedAt == now)
+    }
+
+    @Test
+    func `auto mode keeps web quota strategy before api key verification`() async {
+        let descriptor = OllamaProviderDescriptor.makeDescriptor()
+        let context = self.makeContext(
+            sourceMode: .auto,
+            env: ["OLLAMA_API_KEY": "ollama-test"],
+            settings: ProviderSettingsSnapshot.make(
+                ollama: .init(cookieSource: .auto, manualCookieHeader: nil)))
+
+        let strategies = await descriptor.fetchPlan.pipeline.resolveStrategies(context)
+
+        #expect(strategies.map(\.id) == ["ollama.web", "ollama.api"])
+    }
+
+    @Test
+    func `auto mode uses api only when ollama cookies are off`() async {
+        let descriptor = OllamaProviderDescriptor.makeDescriptor()
+        let context = self.makeContext(
+            sourceMode: .auto,
+            env: ["OLLAMA_API_KEY": "ollama-test"],
+            settings: ProviderSettingsSnapshot.make(
+                ollama: .init(cookieSource: .off, manualCookieHeader: nil)))
+
+        let strategies = await descriptor.fetchPlan.pipeline.resolveStrategies(context)
+
+        #expect(strategies.map(\.id) == ["ollama.api"])
+    }
+
+    @Test
+    func `web strategy falls back to api key in auto mode`() {
+        let context = self.makeContext(
+            sourceMode: .auto,
+            env: ["OLLAMA_API_KEY": "ollama-test"])
+        let strategy = OllamaStatusFetchStrategy()
+
+        #expect(strategy.shouldFallback(on: OllamaUsageError.parseFailed("missing"), context: context))
+    }
+
+    @Test
+    func `api fetch sends bearer token and rejects unauthorized key`() async throws {
+        let url = try #require(URL(string: "https://ollama.com/api/tags"))
+        let transport = ProviderHTTPTransportHandler { request in
+            #expect(request.url == url)
+            #expect(request.value(forHTTPHeaderField: "Authorization") == "Bearer ollama-test")
+            let response = HTTPURLResponse(
+                url: url,
+                statusCode: 401,
+                httpVersion: "HTTP/1.1",
+                headerFields: nil)!
+            return (Data("{}".utf8), response)
+        }
+
+        do {
+            _ = try await OllamaAPIUsageFetcher.fetchUsage(apiKey: "ollama-test", transport: transport)
+            Issue.record("Expected unauthorized API error")
+        } catch let error as OllamaUsageError {
+            guard case .apiUnauthorized = error else {
+                Issue.record("Expected apiUnauthorized, got \(error)")
+                return
+            }
+        } catch {
+            Issue.record("Expected OllamaUsageError.apiUnauthorized, got \(error)")
+        }
+    }
+
     @Test
-    func missingUsageShapeSurfacesPublicParseFailedMessage() async {
+    func `missing usage shape surfaces public parse failed message`() async {
         defer { OllamaRetryMappingStubURLProtocol.handler = nil }
 
         OllamaRetryMappingStubURLProtocol.handler = { request in
diff --git a/Tests/CodexBarTests/OllamaUsageFetcherTests.swift b/Tests/CodexBarTests/OllamaUsageFetcherTests.swift
index 8020638f8b..e25283f5b0 100644
--- a/Tests/CodexBarTests/OllamaUsageFetcherTests.swift
+++ b/Tests/CodexBarTests/OllamaUsageFetcherTests.swift
@@ -2,24 +2,30 @@ import Foundation
 import Testing
 @testable import CodexBarCore
 
-@Suite
 struct OllamaUsageFetcherTests {
     @Test
-    func attachesCookieForOllamaHosts() {
+    func `attaches cookie for ollama hosts`() {
         #expect(OllamaUsageFetcher.shouldAttachCookie(to: URL(string: "https://ollama.com/settings")))
         #expect(OllamaUsageFetcher.shouldAttachCookie(to: URL(string: "https://www.ollama.com")))
         #expect(OllamaUsageFetcher.shouldAttachCookie(to: URL(string: "https://app.ollama.com/path")))
     }
 
     @Test
-    func rejectsNonOllamaHosts() {
+    func `rejects non ollama hosts`() {
         #expect(!OllamaUsageFetcher.shouldAttachCookie(to: URL(string: "https://example.com")))
         #expect(!OllamaUsageFetcher.shouldAttachCookie(to: URL(string: "https://ollama.com.evil.com")))
         #expect(!OllamaUsageFetcher.shouldAttachCookie(to: nil))
     }
 
     @Test
-    func manualModeWithoutValidHeaderThrowsNoSessionCookie() {
+    func `rejects non https ollama urls`() {
+        #expect(!OllamaUsageFetcher.shouldAttachCookie(to: URL(string: "http://ollama.com/settings")))
+        #expect(!OllamaUsageFetcher.shouldAttachCookie(to: URL(string: "http://www.ollama.com")))
+        #expect(!OllamaUsageFetcher.shouldAttachCookie(to: URL(string: "http://app.ollama.com/path")))
+    }
+
+    @Test
+    func `manual mode without valid header throws no session cookie`() {
         do {
             _ = try OllamaUsageFetcher.resolveManualCookieHeader(
                 override: nil,
@@ -33,7 +39,7 @@ struct OllamaUsageFetcherTests {
     }
 
     @Test
-    func autoModeWithoutHeaderDoesNotForceManualError() throws {
+    func `auto mode without header does not force manual error`() throws {
         let resolved = try OllamaUsageFetcher.resolveManualCookieHeader(
             override: nil,
             manualCookieMode: false)
@@ -41,7 +47,7 @@ struct OllamaUsageFetcherTests {
     }
 
     @Test
-    func manualModeWithoutRecognizedSessionCookieThrowsNoSessionCookie() {
+    func `manual mode without recognized session cookie throws no session cookie`() {
         do {
             _ = try OllamaUsageFetcher.resolveManualCookieHeader(
                 override: "analytics_session_id=noise; theme=dark",
@@ -55,7 +61,7 @@ struct OllamaUsageFetcherTests {
     }
 
     @Test
-    func manualModeWithRecognizedSessionCookieAcceptsHeader() throws {
+    func `manual mode with recognized session cookie accepts header`() throws {
         let resolved = try OllamaUsageFetcher.resolveManualCookieHeader(
             override: "next-auth.session-token.0=abc; theme=dark",
             manualCookieMode: true)
@@ -63,7 +69,15 @@ struct OllamaUsageFetcherTests {
     }
 
     @Test
-    func retryPolicyRetriesOnlyForAuthErrors() {
+    func `manual mode accepts secure session cookie header`() throws {
+        let resolved = try OllamaUsageFetcher.resolveManualCookieHeader(
+            override: "__Secure-session=abc; theme=dark",
+            manualCookieMode: true)
+        #expect(resolved?.contains("__Secure-session=abc") == true)
+    }
+
+    @Test
+    func `retry policy retries only for auth errors`() {
         #expect(OllamaUsageFetcher.shouldRetryWithNextCookieCandidate(after: OllamaUsageError.invalidCredentials))
         #expect(OllamaUsageFetcher.shouldRetryWithNextCookieCandidate(after: OllamaUsageError.notLoggedIn))
         #expect(OllamaUsageFetcher.shouldRetryWithNextCookieCandidate(
@@ -77,12 +91,13 @@ struct OllamaUsageFetcherTests {
 
     #if os(macOS)
     @Test
-    func cookieImporterDefaultsToChromeFirst() {
+    func `cookie importer defaults to chrome first`() {
         #expect(OllamaCookieImporter.defaultPreferredBrowsers == [.chrome])
+        #expect(OllamaCookieImporter.defaultAllowFallbackBrowsers)
     }
 
     @Test
-    func cookieSelectorSkipsSessionLikeNoiseAndFindsRecognizedCookie() throws {
+    func `cookie selector skips session like noise and finds recognized cookie`() throws {
         let first = OllamaCookieImporter.SessionInfo(
             cookies: [Self.makeCookie(name: "analytics_session_id", value: "noise")],
             sourceLabel: "Profile A")
@@ -95,7 +110,7 @@ struct OllamaUsageFetcherTests {
     }
 
     @Test
-    func cookieSelectorThrowsWhenNoRecognizedSessionCookieExists() {
+    func `cookie selector throws when no recognized session cookie exists`() {
         let candidates = [
             OllamaCookieImporter.SessionInfo(
                 cookies: [Self.makeCookie(name: "analytics_session_id", value: "noise")],
@@ -116,7 +131,7 @@ struct OllamaUsageFetcherTests {
     }
 
     @Test
-    func cookieSelectorAcceptsChunkedNextAuthSessionTokenCookie() throws {
+    func `cookie selector accepts chunked next auth session token cookie`() throws {
         let candidate = OllamaCookieImporter.SessionInfo(
             cookies: [Self.makeCookie(name: "next-auth.session-token.0", value: "chunk0")],
             sourceLabel: "Profile C")
@@ -126,7 +141,17 @@ struct OllamaUsageFetcherTests {
     }
 
     @Test
-    func cookieSelectorKeepsRecognizedCandidatesInOrder() throws {
+    func `cookie selector accepts secure session cookie`() throws {
+        let candidate = OllamaCookieImporter.SessionInfo(
+            cookies: [Self.makeCookie(name: "__Secure-session", value: "auth")],
+            sourceLabel: "Profile D")
+
+        let selected = try OllamaCookieImporter.selectSessionInfo(from: [candidate])
+        #expect(selected.sourceLabel == "Profile D")
+    }
+
+    @Test
+    func `cookie selector keeps recognized candidates in order`() throws {
         let first = OllamaCookieImporter.SessionInfo(
             cookies: [Self.makeCookie(name: "session", value: "stale")],
             sourceLabel: "Chrome Profile A")
@@ -142,7 +167,7 @@ struct OllamaUsageFetcherTests {
     }
 
     @Test
-    func cookieSelectorDoesNotFallbackWhenFallbackDisabled() {
+    func `cookie selector does not fallback when fallback disabled`() {
         let preferred = [
             OllamaCookieImporter.SessionInfo(
                 cookies: [Self.makeCookie(name: "analytics_session_id", value: "noise")],
@@ -168,7 +193,7 @@ struct OllamaUsageFetcherTests {
     }
 
     @Test
-    func cookieSelectorFallsBackToNonChromeCandidateWhenFallbackEnabled() throws {
+    func `cookie selector falls back to non chrome candidate when fallback enabled`() throws {
         let preferred = [
             OllamaCookieImporter.SessionInfo(
                 cookies: [Self.makeCookie(name: "analytics_session_id", value: "noise")],
@@ -187,6 +212,21 @@ struct OllamaUsageFetcherTests {
         #expect(selected.sourceLabel == "Safari Profile")
     }
 
+    @Test
+    func `cookie selector can fall back to comet secure session cookie`() throws {
+        let fallback = [
+            OllamaCookieImporter.SessionInfo(
+                cookies: [Self.makeCookie(name: "__Secure-session", value: "auth")],
+                sourceLabel: "Comet Profile"),
+        ]
+
+        let selected = try OllamaCookieImporter.selectSessionInfoWithFallback(
+            preferredCandidates: [],
+            allowFallbackBrowsers: true,
+            loadFallbackCandidates: { fallback })
+        #expect(selected.sourceLabel == "Comet Profile")
+    }
+
     private static func makeCookie(
         name: String,
         value: String,
diff --git a/Tests/CodexBarTests/OllamaUsageParserTests.swift b/Tests/CodexBarTests/OllamaUsageParserTests.swift
index e01d167aee..bdec926067 100644
--- a/Tests/CodexBarTests/OllamaUsageParserTests.swift
+++ b/Tests/CodexBarTests/OllamaUsageParserTests.swift
@@ -2,10 +2,9 @@ import Foundation
 import Testing
 @testable import CodexBarCore
 
-@Suite
 struct OllamaUsageParserTests {
     @Test
-    func parsesCloudUsageFromSettingsHTML() throws {
+    func `parses cloud usage from settings HTML`() throws {
         let now = Date(timeIntervalSince1970: 1_700_000_000)
         let html = """
         <div>
@@ -44,10 +43,12 @@ struct OllamaUsageParserTests {
         let usage = snapshot.toUsageSnapshot()
         #expect(usage.identity?.loginMethod == "free")
         #expect(usage.identity?.accountEmail == "user@example.com")
+        #expect(usage.primary?.windowMinutes == 5 * 60)
+        #expect(usage.secondary?.windowMinutes == 7 * 24 * 60)
     }
 
     @Test
-    func missingUsageThrowsParseFailed() {
+    func `missing usage throws parse failed`() {
         let html = "<html><body>No usage here. login status unknown.</body></html>"
 
         #expect {
@@ -59,7 +60,7 @@ struct OllamaUsageParserTests {
     }
 
     @Test
-    func classifiedParseMissingUsageReturnsTypedFailure() {
+    func `classified parse missing usage returns typed failure`() {
         let html = "<html><body>No usage here. login status unknown.</body></html>"
         let result = OllamaUsageParser.parseClassified(html: html)
 
@@ -72,7 +73,7 @@ struct OllamaUsageParserTests {
     }
 
     @Test
-    func signedOutThrowsNotLoggedIn() {
+    func `signed out throws not logged in`() {
         let html = """
         <html>
           <body>
@@ -94,7 +95,7 @@ struct OllamaUsageParserTests {
     }
 
     @Test
-    func classifiedParseSignedOutReturnsTypedFailure() {
+    func `classified parse signed out returns typed failure`() {
         let html = """
         <html>
           <body>
@@ -117,7 +118,7 @@ struct OllamaUsageParserTests {
     }
 
     @Test
-    func genericSignInTextWithoutAuthMarkersThrowsParseFailed() {
+    func `generic sign in text without auth markers throws parse failed`() {
         let html = """
         <html>
           <body>
@@ -137,7 +138,7 @@ struct OllamaUsageParserTests {
     }
 
     @Test
-    func parsesHourlyUsageAsPrimaryWindow() throws {
+    func `parses hourly usage as primary window`() throws {
         let now = Date(timeIntervalSince1970: 1_700_000_000)
         let html = """
         <div>
@@ -154,10 +155,39 @@ struct OllamaUsageParserTests {
 
         #expect(snapshot.sessionUsedPercent == 2.5)
         #expect(snapshot.weeklyUsedPercent == 4.2)
+
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary?.windowMinutes == nil)
+        #expect(usage.secondary?.windowMinutes == 7 * 24 * 60)
+    }
+
+    @Test
+    func `weekly usage parser finds reset timestamp in long usage block`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let filler = String(repeating: "<span class=\"grid-cell\"></span>", count: 40)
+        let html = """
+        <div>
+          <span>Session usage</span>
+          <span>0.1% used</span>
+          <span>Weekly usage</span>
+          <span>0.7% used</span>
+          \(filler)
+          <div class=\"local-time\" data-time=\"2026-02-02T00:00:00Z\">Resets in 2 days</div>
+        </div>
+        """
+
+        let snapshot = try OllamaUsageParser.parse(html: html, now: now)
+
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime]
+        let expectedWeekly = formatter.date(from: "2026-02-02T00:00:00Z")
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary?.resetsAt == nil)
+        #expect(usage.secondary?.resetsAt == expectedWeekly)
     }
 
     @Test
-    func parsesUsageWhenUsedIsCapitalized() throws {
+    func `parses usage when used is capitalized`() throws {
         let now = Date(timeIntervalSince1970: 1_700_000_000)
         let html = """
         <div>
diff --git a/Tests/CodexBarTests/OpenAIAPICreditBalanceTests.swift b/Tests/CodexBarTests/OpenAIAPICreditBalanceTests.swift
new file mode 100644
index 0000000000..88860dd5f6
--- /dev/null
+++ b/Tests/CodexBarTests/OpenAIAPICreditBalanceTests.swift
@@ -0,0 +1,217 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct OpenAIAPICreditBalanceTests {
+    private func makeContext(
+        apiKey: String = "sk-test",
+        usesAdminKey: Bool = false,
+        projectID: String? = nil,
+        selectedTokenAccountID: UUID? = nil,
+        historyDays: Int = 30) -> ProviderFetchContext
+    {
+        let browserDetection = BrowserDetection(cacheTTL: 0)
+        let apiKeyEnvironmentKey = usesAdminKey
+            ? OpenAIAPISettingsReader.adminAPIKeyEnvironmentKey
+            : OpenAIAPISettingsReader.apiKeyEnvironmentKey
+        var env = [apiKeyEnvironmentKey: apiKey]
+        if let projectID {
+            env[OpenAIAPISettingsReader.projectIDEnvironmentKey] = projectID
+        }
+        return ProviderFetchContext(
+            runtime: .app,
+            sourceMode: .api,
+            includeCredits: false,
+            webTimeout: 1,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: env,
+            settings: nil,
+            fetcher: UsageFetcher(environment: env),
+            claudeFetcher: ClaudeUsageFetcher(browserDetection: browserDetection),
+            browserDetection: browserDetection,
+            selectedTokenAccountID: selectedTokenAccountID,
+            costUsageHistoryDays: historyDays)
+    }
+
+    @Test
+    func `prefers admin key environment variable`() {
+        let token = OpenAIAPISettingsReader.apiKey(environment: [
+            "OPENAI_API_KEY": "sk-project",
+            "OPENAI_ADMIN_KEY": "sk-admin",
+        ])
+
+        #expect(token == "sk-admin")
+    }
+
+    @Test
+    func `parses credit grants balance`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let json = """
+        {
+          "object": "credit_summary",
+          "total_granted": 25.5,
+          "total_used": 7.25,
+          "total_available": 18.25,
+          "grants": {
+            "object": "list",
+            "data": [
+              {
+                "grant_amount": 10.0,
+                "used_amount": 1.0,
+                "effective_at": 1690000000,
+                "expires_at": 1800000000
+              }
+            ]
+          }
+        }
+        """
+
+        let snapshot = try OpenAIAPICreditBalanceFetcher._parseSnapshotForTesting(Data(json.utf8), now: now)
+
+        #expect(snapshot.totalGranted == 25.5)
+        #expect(snapshot.totalUsed == 7.25)
+        #expect(snapshot.totalAvailable == 18.25)
+        #expect(snapshot.nextGrantExpiry == Date(timeIntervalSince1970: 1_800_000_000))
+    }
+
+    @Test
+    func `maps balance to usage snapshot`() {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let balance = OpenAIAPICreditBalanceSnapshot(
+            totalGranted: 100,
+            totalUsed: 40,
+            totalAvailable: 60,
+            nextGrantExpiry: Date(timeIntervalSince1970: 1_800_000_000),
+            updatedAt: now)
+
+        let usage = balance.toUsageSnapshot()
+
+        #expect(usage.primary?.usedPercent == 40)
+        #expect(usage.primary?.resetDescription == "$60.00 available")
+        #expect(usage.providerCost?.used == 40)
+        #expect(usage.providerCost?.limit == 100)
+        #expect(usage.identity?.providerID == .openai)
+        #expect(usage.identity?.loginMethod == "API balance: $60.00")
+    }
+
+    @Test
+    func `falls back to legacy billing when admin usage rejects credentials`() async throws {
+        let strategy = OpenAIAPIBalanceFetchStrategy(
+            usageFetcher: { _, _ in
+                throw OpenAIAPIUsageError.apiError(endpoint: "costs", statusCode: 403)
+            },
+            balanceFetcher: { _ in
+                OpenAIAPICreditBalanceSnapshot(
+                    totalGranted: 100,
+                    totalUsed: 25,
+                    totalAvailable: 75,
+                    nextGrantExpiry: nil,
+                    updatedAt: Date(timeIntervalSince1970: 1_700_000_000))
+            })
+
+        let result = try await strategy.fetch(self.makeContext())
+
+        #expect(result.sourceLabel == "billing-api")
+        #expect(result.usage.identity?.loginMethod == "API balance: $75.00")
+    }
+
+    @Test
+    func `legacy API key without project ID falls back to legacy billing`() async throws {
+        let strategy = OpenAIAPIBalanceFetchStrategy(
+            usageFetcher: { credential, historyDays in
+                #expect(credential.apiKey == "sk-test")
+                #expect(credential.projectID == nil)
+                #expect(historyDays == 30)
+                throw OpenAIAPIUsageError.apiError(endpoint: "costs", statusCode: 403)
+            },
+            balanceFetcher: { apiKey in
+                #expect(apiKey == "sk-test")
+                return OpenAIAPICreditBalanceSnapshot(
+                    totalGranted: 100,
+                    totalUsed: 25,
+                    totalAvailable: 75,
+                    nextGrantExpiry: nil,
+                    updatedAt: Date(timeIntervalSince1970: 1_700_000_000))
+            })
+
+        let result = try await strategy.fetch(self.makeContext())
+
+        #expect(result.sourceLabel == "billing-api")
+        #expect(result.usage.identity?.loginMethod == "API balance: $75.00")
+        #expect(result.usage.identity?.accountOrganization == nil)
+    }
+
+    @Test
+    func `selected token account uses scrubbed final environment for legacy fallback`() async throws {
+        let accountID = UUID()
+        let strategy = OpenAIAPIBalanceFetchStrategy(
+            usageFetcher: { credential, historyDays in
+                #expect(credential.apiKey == "account-token")
+                #expect(credential.projectID == nil)
+                #expect(historyDays == 30)
+                throw OpenAIAPIUsageError.apiError(endpoint: "costs", statusCode: 403)
+            },
+            balanceFetcher: { apiKey in
+                #expect(apiKey == "account-token")
+                return OpenAIAPICreditBalanceSnapshot(
+                    totalGranted: 100,
+                    totalUsed: 25,
+                    totalAvailable: 75,
+                    nextGrantExpiry: nil,
+                    updatedAt: Date(timeIntervalSince1970: 1_700_000_000))
+            })
+
+        let result = try await strategy.fetch(self.makeContext(
+            apiKey: "account-token",
+            usesAdminKey: true,
+            selectedTokenAccountID: accountID))
+
+        #expect(result.sourceLabel == "billing-api")
+        #expect(result.usage.identity?.loginMethod == "API balance: $75.00")
+        #expect(result.usage.identity?.accountOrganization == nil)
+    }
+
+    @Test
+    func `preserves admin usage error when legacy fallback also fails`() async {
+        let usageFailure = OpenAIAPIUsageError.parseFailed(endpoint: "costs", message: "changed")
+        let strategy = OpenAIAPIBalanceFetchStrategy(
+            usageFetcher: { _, _ in throw usageFailure },
+            balanceFetcher: { _ in throw OpenAIAPICreditBalanceError.forbidden })
+
+        do {
+            _ = try await strategy.fetch(self.makeContext())
+            Issue.record("Expected admin usage failure")
+        } catch let error as OpenAIAPIUsageError {
+            #expect(error == usageFailure)
+        } catch {
+            Issue.record("Expected OpenAIAPIUsageError, got \(error)")
+        }
+    }
+
+    @Test
+    func `falls back to credit balance when admin usage endpoint is unavailable`() async throws {
+        let strategy = OpenAIAPIBalanceFetchStrategy(
+            usageFetcher: { credential, historyDays in
+                #expect(credential.apiKey == "sk-test")
+                #expect(credential.projectID == nil)
+                #expect(historyDays == 90)
+                throw OpenAIAPIUsageError.apiError(endpoint: "costs", statusCode: 500)
+            },
+            balanceFetcher: { apiKey in
+                #expect(apiKey == "sk-test")
+                return OpenAIAPICreditBalanceSnapshot(
+                    totalGranted: 100,
+                    totalUsed: 25,
+                    totalAvailable: 75,
+                    nextGrantExpiry: nil,
+                    updatedAt: Date(timeIntervalSince1970: 1_700_000_000))
+            })
+
+        let result = try await strategy.fetch(self.makeContext(historyDays: 90))
+
+        #expect(result.sourceLabel == "billing-api")
+        #expect(result.usage.providerCost?.used == 25)
+        #expect(result.usage.providerCost?.limit == 100)
+    }
+}
diff --git a/Tests/CodexBarTests/OpenAIAPIMenuCardModelTests.swift b/Tests/CodexBarTests/OpenAIAPIMenuCardModelTests.swift
new file mode 100644
index 0000000000..b13eabe477
--- /dev/null
+++ b/Tests/CodexBarTests/OpenAIAPIMenuCardModelTests.swift
@@ -0,0 +1,166 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct OpenAIAPIMenuCardModelTests {
+    @Test
+    func `admin usage model shows summaries and spend without fake quota bars`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_179_200)
+        let metadata = try #require(ProviderDefaults.metadata[.openai])
+        let apiUsage = OpenAIAPIUsageSnapshot(
+            daily: [
+                OpenAIAPIUsageSnapshot.DailyBucket(
+                    day: "2023-11-14",
+                    startTime: now,
+                    endTime: now.addingTimeInterval(86400),
+                    costUSD: 12.5,
+                    requests: 40,
+                    inputTokens: 1000,
+                    cachedInputTokens: 250,
+                    outputTokens: 500,
+                    totalTokens: 1500,
+                    lineItems: [
+                        OpenAIAPIUsageSnapshot.LineItemBreakdown(name: "Text tokens", costUSD: 12.5),
+                    ],
+                    models: [
+                        OpenAIAPIUsageSnapshot.ModelBreakdown(
+                            name: "gpt-5.2",
+                            requests: 40,
+                            inputTokens: 1000,
+                            cachedInputTokens: 250,
+                            outputTokens: 500,
+                            totalTokens: 1500),
+                    ]),
+            ],
+            updatedAt: now)
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .openai,
+            metadata: metadata,
+            snapshot: apiUsage.toUsageSnapshot(),
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.metrics.isEmpty)
+        #expect(model.openAIAPIUsage != nil)
+        #expect(model.inlineUsageDashboard?.kpis.first?.value == "$12.50")
+        #expect(model.inlineUsageDashboard?.kpis.last?.title == "Requests")
+        #expect(model.inlineUsageDashboard?.kpis.last?.value == "40")
+        #expect(model.inlineUsageDashboard?.points.count == 1)
+        #expect(model.inlineUsageDashboard?.detailLines.contains("30d requests: 40 requests") == true)
+        #expect(model.providerCost == nil)
+        #expect(model.usageNotes.contains { $0.contains("Today: $12.50") })
+        #expect(model.usageNotes.contains("Top model: gpt-5.2"))
+        #expect(model.creditsText == nil)
+        #expect(model.planText == "Admin API")
+    }
+
+    @Test
+    func `admin usage dashboard ignores stale token snapshot after fallback refresh`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_179_200)
+        let metadata = try #require(ProviderDefaults.metadata[.openai])
+        let staleTokenSnapshot = CostUsageTokenSnapshot(
+            sessionTokens: 1500,
+            sessionCostUSD: 12.5,
+            last30DaysTokens: 1500,
+            last30DaysCostUSD: 12.5,
+            daily: [
+                CostUsageDailyReport.Entry(
+                    date: "2023-11-14",
+                    inputTokens: 1000,
+                    outputTokens: 500,
+                    totalTokens: 1500,
+                    costUSD: 12.5,
+                    modelsUsed: nil,
+                    modelBreakdowns: nil),
+            ],
+            updatedAt: now)
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .openai,
+            metadata: metadata,
+            snapshot: UsageSnapshot(
+                primary: nil,
+                secondary: nil,
+                updatedAt: now),
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: staleTokenSnapshot,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: true,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.inlineUsageDashboard == nil)
+        #expect(model.tokenUsage == nil)
+    }
+
+    @Test
+    func `admin usage model can show cost card summary`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_179_200)
+        let metadata = try #require(ProviderDefaults.metadata[.openai])
+        let apiUsage = OpenAIAPIUsageSnapshot(
+            daily: [
+                OpenAIAPIUsageSnapshot.DailyBucket(
+                    day: "2023-11-14",
+                    startTime: now,
+                    endTime: now.addingTimeInterval(86400),
+                    costUSD: 12.5,
+                    requests: 40,
+                    inputTokens: 1000,
+                    cachedInputTokens: 250,
+                    outputTokens: 500,
+                    totalTokens: 1500,
+                    lineItems: [],
+                    models: []),
+            ],
+            updatedAt: now)
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .openai,
+            metadata: metadata,
+            snapshot: apiUsage.toUsageSnapshot(),
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: apiUsage.toCostUsageTokenSnapshot(),
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: true,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(ProviderDescriptorRegistry.descriptor(for: .openai).tokenCost.supportsTokenCost)
+        #expect(model.tokenUsage?.sessionLine == "Today: $12.50 · 1.5K tokens")
+        #expect(model.tokenUsage?.monthLine == "Last 30 days: $12.50 · 1.5K tokens")
+        #expect(model.tokenUsage?.hintLine == "Reported by OpenAI Admin API organization usage.")
+    }
+}
diff --git a/Tests/CodexBarTests/OpenAIAPIProjectScopeTests.swift b/Tests/CodexBarTests/OpenAIAPIProjectScopeTests.swift
new file mode 100644
index 0000000000..a8a0f3f515
--- /dev/null
+++ b/Tests/CodexBarTests/OpenAIAPIProjectScopeTests.swift
@@ -0,0 +1,334 @@
+import Foundation
+import Testing
+@testable import CodexBar
+@testable import CodexBarCLI
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct OpenAIAPIProjectScopeTests {
+    @Test
+    @MainActor
+    func `token account strips configured project in app environment builder`() {
+        let settings = Self.makeSettingsStore(suite: "OpenAIAPIProjectScopeTests-app")
+        settings.openAIAPIKey = "config-token"
+        settings.openAIAPIProjectID = "proj_config"
+        settings.addTokenAccount(provider: .openai, label: "Configured account", token: "first-account-token")
+        settings.addTokenAccount(provider: .openai, label: "Selected account", token: "selected-account-token")
+        let selectedAccount = settings.tokenAccounts(for: .openai)[1]
+
+        let env = ProviderRegistry.makeEnvironment(
+            base: [OpenAIAPISettingsReader.projectIDEnvironmentKey: "proj_env"],
+            provider: .openai,
+            settings: settings,
+            tokenOverride: TokenAccountOverride(provider: .openai, account: selectedAccount))
+
+        #expect(env[OpenAIAPISettingsReader.adminAPIKeyEnvironmentKey] == "selected-account-token")
+        #expect(env[OpenAIAPISettingsReader.adminAPIKeyEnvironmentKey] != "config-token")
+        #expect(env[OpenAIAPISettingsReader.adminAPIKeyEnvironmentKey] != "first-account-token")
+        #expect(env[OpenAIAPISettingsReader.projectIDEnvironmentKey] == nil)
+    }
+
+    @Test
+    func `token account strips configured project in CLI environment builder`() throws {
+        let account = ProviderTokenAccount(
+            id: UUID(),
+            label: "Project account",
+            token: "account-token",
+            addedAt: Date().timeIntervalSince1970,
+            lastUsed: nil)
+        let accounts = ProviderTokenAccountData(version: 1, accounts: [account], activeIndex: 0)
+        let config = CodexBarConfig(
+            providers: [
+                ProviderConfig(
+                    id: .openai,
+                    apiKey: "config-token",
+                    workspaceID: "proj_config",
+                    tokenAccounts: accounts),
+            ])
+        let selection = TokenAccountCLISelection(label: nil, index: nil, allAccounts: false)
+        let tokenContext = try TokenAccountCLIContext(selection: selection, config: config, verbose: false)
+
+        let env = tokenContext.environment(
+            base: [OpenAIAPISettingsReader.projectIDEnvironmentKey: "proj_env"],
+            provider: .openai,
+            account: account)
+
+        #expect(env[OpenAIAPISettingsReader.adminAPIKeyEnvironmentKey] == "account-token")
+        #expect(env[OpenAIAPISettingsReader.adminAPIKeyEnvironmentKey] != "config-token")
+        #expect(env[OpenAIAPISettingsReader.projectIDEnvironmentKey] == nil)
+    }
+
+    @Test
+    @MainActor
+    func `configured app project scopes admin usage strategy`() async throws {
+        let settings = Self.makeSettingsStore(suite: "OpenAIAPIProjectScopeTests-configured-project")
+        settings.openAIAPIKey = "config-token"
+        settings.openAIAPIProjectID = "proj_config"
+        let env = ProviderRegistry.makeEnvironment(
+            base: [:],
+            provider: .openai,
+            settings: settings,
+            tokenOverride: nil)
+        let strategy = OpenAIAPIBalanceFetchStrategy(
+            usageFetcher: { credential, historyDays in
+                #expect(credential.apiKey == "config-token")
+                #expect(credential.projectID == "proj_config")
+                #expect(historyDays == 30)
+                return OpenAIAPIUsageSnapshot(
+                    daily: [],
+                    updatedAt: Date(timeIntervalSince1970: 1_700_000_000),
+                    projectID: credential.projectID)
+            },
+            balanceFetcher: { _ in
+                Issue.record("Configured project usage should not fetch legacy organization balance.")
+                return OpenAIAPICreditBalanceSnapshot(
+                    totalGranted: 100,
+                    totalUsed: 25,
+                    totalAvailable: 75,
+                    nextGrantExpiry: nil,
+                    updatedAt: Date(timeIntervalSince1970: 1_700_000_000))
+            })
+
+        let result = try await strategy.fetch(Self.makeContext(env: env))
+
+        #expect(result.sourceLabel == "admin-api:project")
+        #expect(result.usage.identity?.loginMethod == "Admin API: proj_config")
+        #expect(result.usage.identity?.accountOrganization == "Project: proj_config")
+    }
+
+    @Test
+    func `legacy API key environment can scope admin usage by project`() async throws {
+        let strategy = OpenAIAPIBalanceFetchStrategy(
+            usageFetcher: { credential, historyDays in
+                #expect(credential.apiKey == "sk-admin-legacy")
+                #expect(credential.projectID == "proj_legacy")
+                #expect(credential.usesAdminKey == false)
+                #expect(historyDays == 30)
+                return OpenAIAPIUsageSnapshot(
+                    daily: [],
+                    updatedAt: Date(timeIntervalSince1970: 1_700_000_000),
+                    projectID: credential.projectID)
+            },
+            balanceFetcher: { _ in
+                Issue.record("Legacy OPENAI_API_KEY project usage should not fetch unscoped balance.")
+                return OpenAIAPICreditBalanceSnapshot(
+                    totalGranted: 100,
+                    totalUsed: 25,
+                    totalAvailable: 75,
+                    nextGrantExpiry: nil,
+                    updatedAt: Date(timeIntervalSince1970: 1_700_000_000))
+            })
+
+        let result = try await strategy.fetch(Self.makeContext(
+            env: [
+                OpenAIAPISettingsReader.apiKeyEnvironmentKey: "sk-admin-legacy",
+                OpenAIAPISettingsReader.projectIDEnvironmentKey: "proj_legacy",
+            ]))
+
+        #expect(result.sourceLabel == "admin-api:project")
+        #expect(result.usage.identity?.loginMethod == "Admin API: proj_legacy")
+        #expect(result.usage.identity?.accountOrganization == "Project: proj_legacy")
+    }
+
+    @Test
+    func `ambient project with legacy API key preserves billing fallback`() async throws {
+        let strategy = OpenAIAPIBalanceFetchStrategy(
+            usageFetcher: { credential, historyDays in
+                #expect(credential.apiKey == "sk-ambient")
+                #expect(credential.projectID == "proj_ambient")
+                #expect(credential.usesAdminKey == false)
+                #expect(historyDays == 30)
+                throw OpenAIAPIUsageError.apiError(endpoint: "costs", statusCode: 403)
+            },
+            balanceFetcher: { apiKey in
+                #expect(apiKey == "sk-ambient")
+                return OpenAIAPICreditBalanceSnapshot(
+                    totalGranted: 100,
+                    totalUsed: 25,
+                    totalAvailable: 75,
+                    nextGrantExpiry: nil,
+                    updatedAt: Date(timeIntervalSince1970: 1_700_000_000))
+            })
+
+        let result = try await strategy.fetch(Self.makeContext(
+            env: [
+                OpenAIAPISettingsReader.apiKeyEnvironmentKey: "sk-ambient",
+                OpenAIAPISettingsReader.projectIDEnvironmentKey: "proj_ambient",
+            ]))
+
+        #expect(result.sourceLabel == "billing-api")
+        #expect(result.usage.identity?.loginMethod == "API balance: $75.00")
+        #expect(result.usage.identity?.accountOrganization == nil)
+    }
+
+    @Test
+    func `project filtered admin usage does not fall back on service failure`() async {
+        let usageFailure = OpenAIAPIUsageError.apiError(endpoint: "costs", statusCode: 500)
+        let strategy = OpenAIAPIBalanceFetchStrategy(
+            usageFetcher: { credential, historyDays in
+                #expect(credential.apiKey == "sk-test")
+                #expect(credential.projectID == "proj_abc")
+                #expect(credential.usesAdminKey == true)
+                #expect(historyDays == 30)
+                throw usageFailure
+            },
+            balanceFetcher: { _ in
+                Issue.record("Project-filtered usage must not fall back to organization balance.")
+                return OpenAIAPICreditBalanceSnapshot(
+                    totalGranted: 100,
+                    totalUsed: 25,
+                    totalAvailable: 75,
+                    nextGrantExpiry: nil,
+                    updatedAt: Date(timeIntervalSince1970: 1_700_000_000))
+            })
+
+        do {
+            _ = try await strategy.fetch(Self.makeContext(
+                env: [
+                    OpenAIAPISettingsReader.adminAPIKeyEnvironmentKey: "sk-test",
+                    OpenAIAPISettingsReader.projectIDEnvironmentKey: "proj_abc",
+                ]))
+            Issue.record("Expected project-filtered admin usage failure.")
+        } catch let error as OpenAIAPIUsageError {
+            #expect(error == usageFailure)
+        } catch {
+            Issue.record("Expected OpenAIAPIUsageError, got \(error)")
+        }
+    }
+
+    @Test
+    func `project filtered admin usage does not fall back on credential rejection`() async {
+        let usageFailure = OpenAIAPIUsageError.apiError(endpoint: "costs", statusCode: 403)
+        let strategy = OpenAIAPIBalanceFetchStrategy(
+            usageFetcher: { credential, historyDays in
+                #expect(credential.apiKey == "sk-test")
+                #expect(credential.projectID == "proj_abc")
+                #expect(historyDays == 30)
+                throw usageFailure
+            },
+            balanceFetcher: { _ in
+                Issue.record("Project-filtered usage must fail closed instead of showing unscoped balance.")
+                return OpenAIAPICreditBalanceSnapshot(
+                    totalGranted: 100,
+                    totalUsed: 25,
+                    totalAvailable: 75,
+                    nextGrantExpiry: nil,
+                    updatedAt: Date(timeIntervalSince1970: 1_700_000_000))
+            })
+
+        do {
+            _ = try await strategy.fetch(Self.makeContext(
+                env: [
+                    OpenAIAPISettingsReader.adminAPIKeyEnvironmentKey: "sk-test",
+                    OpenAIAPISettingsReader.projectIDEnvironmentKey: "proj_abc",
+                ]))
+            Issue.record("Expected project-filtered admin credential failure.")
+        } catch let error as OpenAIAPIUsageError {
+            #expect(error == usageFailure)
+        } catch {
+            Issue.record("Expected OpenAIAPIUsageError, got \(error)")
+        }
+    }
+
+    @Test
+    func `project filtered admin usage reports project source label`() async throws {
+        let strategy = OpenAIAPIBalanceFetchStrategy(
+            usageFetcher: { credential, _ in
+                #expect(credential.apiKey == "sk-test")
+                #expect(credential.projectID == "proj_abc")
+                return OpenAIAPIUsageSnapshot(
+                    daily: [],
+                    updatedAt: Date(timeIntervalSince1970: 1_700_000_000),
+                    projectID: credential.projectID)
+            },
+            balanceFetcher: { _ in
+                Issue.record("Project-filtered usage should not fetch legacy balance after admin usage succeeds.")
+                return OpenAIAPICreditBalanceSnapshot(
+                    totalGranted: 100,
+                    totalUsed: 25,
+                    totalAvailable: 75,
+                    nextGrantExpiry: nil,
+                    updatedAt: Date(timeIntervalSince1970: 1_700_000_000))
+            })
+
+        let result = try await strategy.fetch(Self.makeContext(
+            env: [
+                OpenAIAPISettingsReader.adminAPIKeyEnvironmentKey: "sk-test",
+                OpenAIAPISettingsReader.projectIDEnvironmentKey: "proj_abc",
+            ]))
+
+        #expect(result.sourceLabel == "admin-api:project")
+        #expect(result.usage.identity?.loginMethod == "Admin API: proj_abc")
+        #expect(result.usage.identity?.accountOrganization == "Project: proj_abc")
+    }
+
+    @Test
+    func `project scope follows final environment even when selected account flag is present`() async throws {
+        let accountID = UUID()
+        let strategy = OpenAIAPIBalanceFetchStrategy(
+            usageFetcher: { credential, historyDays in
+                #expect(credential.apiKey == "sk-test")
+                #expect(credential.projectID == "proj_env")
+                #expect(historyDays == 30)
+                return OpenAIAPIUsageSnapshot(
+                    daily: [],
+                    updatedAt: Date(timeIntervalSince1970: 1_700_000_000),
+                    projectID: credential.projectID)
+            },
+            balanceFetcher: { _ in
+                Issue.record("Final project-scoped environments should not fetch legacy balance.")
+                return OpenAIAPICreditBalanceSnapshot(
+                    totalGranted: 100,
+                    totalUsed: 25,
+                    totalAvailable: 75,
+                    nextGrantExpiry: nil,
+                    updatedAt: Date(timeIntervalSince1970: 1_700_000_000))
+            })
+
+        let result = try await strategy.fetch(Self.makeContext(
+            env: [
+                OpenAIAPISettingsReader.adminAPIKeyEnvironmentKey: "sk-test",
+                OpenAIAPISettingsReader.projectIDEnvironmentKey: "proj_env",
+            ],
+            selectedTokenAccountID: accountID))
+
+        #expect(result.sourceLabel == "admin-api:project")
+        #expect(result.usage.identity?.loginMethod == "Admin API: proj_env")
+        #expect(result.usage.identity?.accountOrganization == "Project: proj_env")
+    }
+
+    private static func makeContext(
+        env: [String: String],
+        selectedTokenAccountID: UUID? = nil,
+        historyDays: Int = 30) -> ProviderFetchContext
+    {
+        let browserDetection = BrowserDetection(cacheTTL: 0)
+        return ProviderFetchContext(
+            runtime: .app,
+            sourceMode: .api,
+            includeCredits: false,
+            webTimeout: 1,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: env,
+            settings: nil,
+            fetcher: UsageFetcher(environment: env),
+            claudeFetcher: ClaudeUsageFetcher(browserDetection: browserDetection),
+            browserDetection: browserDetection,
+            selectedTokenAccountID: selectedTokenAccountID,
+            costUsageHistoryDays: historyDays)
+    }
+
+    @MainActor
+    private static func makeSettingsStore(suite: String) -> SettingsStore {
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+
+        return SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore(),
+            tokenAccountStore: InMemoryTokenAccountStore())
+    }
+}
diff --git a/Tests/CodexBarTests/OpenAIAPIStatusMenuTests.swift b/Tests/CodexBarTests/OpenAIAPIStatusMenuTests.swift
new file mode 100644
index 0000000000..002d2bd9cb
--- /dev/null
+++ b/Tests/CodexBarTests/OpenAIAPIStatusMenuTests.swift
@@ -0,0 +1,53 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+extension StatusMenuTests {
+    @Test
+    func `open AI API usage submenu ignores stale token snapshot without current admin usage`() throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.selectedMenuProvider = .openai
+
+        let registry = ProviderRegistry.shared
+        let metadata = try #require(registry.metadata[.openai])
+        settings.setProviderEnabled(provider: .openai, metadata: metadata, enabled: true)
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        store._setSnapshotForTesting(
+            UsageSnapshot(primary: nil, secondary: nil, updatedAt: now),
+            provider: .openai)
+        store._setTokenSnapshotForTesting(CostUsageTokenSnapshot(
+            sessionTokens: 123,
+            sessionCostUSD: 0.12,
+            last30DaysTokens: 123,
+            last30DaysCostUSD: 1.23,
+            daily: [
+                CostUsageDailyReport.Entry(
+                    date: "2025-12-23",
+                    inputTokens: nil,
+                    outputTokens: nil,
+                    totalTokens: 123,
+                    costUSD: 1.23,
+                    modelsUsed: nil,
+                    modelBreakdowns: nil),
+            ],
+            updatedAt: now), provider: .openai)
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        #expect(controller.makeOpenAIAPIUsageSubmenu(provider: .openai) == nil)
+    }
+}
diff --git a/Tests/CodexBarTests/OpenAIAPIUsageFetcherTests.swift b/Tests/CodexBarTests/OpenAIAPIUsageFetcherTests.swift
new file mode 100644
index 0000000000..a9cd8f50ee
--- /dev/null
+++ b/Tests/CodexBarTests/OpenAIAPIUsageFetcherTests.swift
@@ -0,0 +1,687 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct OpenAIAPIUsageFetcherTests {
+    @Test
+    func `parses admin costs and completions usage into daily summaries`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_179_200)
+        let costs = """
+        {
+          "object": "page",
+          "data": [
+            {
+              "object": "bucket",
+              "start_time": 1700000000,
+              "end_time": 1700086400,
+              "results": [
+                {
+                  "object": "organization.costs.result",
+                  "amount": { "value": 12.50, "currency": "usd" },
+                  "line_item": "Text tokens"
+                },
+                {
+                  "object": "organization.costs.result",
+                  "amount": { "value": "2.25", "currency": "usd" },
+                  "line_item": "Web search tool calls"
+                }
+              ]
+            },
+            {
+              "object": "bucket",
+              "start_time": 1700086400,
+              "end_time": 1700172800,
+              "results": [
+                {
+                  "object": "organization.costs.result",
+                  "amount": { "value": 4.00, "currency": "usd" },
+                  "line_item": "Text tokens"
+                }
+              ]
+            }
+          ],
+          "has_more": false,
+          "next_page": null
+        }
+        """
+        let completions = """
+        {
+          "object": "page",
+          "data": [
+            {
+              "object": "bucket",
+              "start_time": 1700000000,
+              "end_time": 1700086400,
+              "results": [
+                {
+                  "object": "organization.usage.completions.result",
+                  "input_tokens": 1000,
+                  "input_cached_tokens": 250,
+                  "output_tokens": 500,
+                  "num_model_requests": 7,
+                  "model": "gpt-5.2"
+                },
+                {
+                  "object": "organization.usage.completions.result",
+                  "input_tokens": 300,
+                  "output_tokens": 200,
+                  "num_model_requests": 3,
+                  "model": "gpt-5.2-codex"
+                }
+              ]
+            },
+            {
+              "object": "bucket",
+              "start_time": 1700086400,
+              "end_time": 1700172800,
+              "results": [
+                {
+                  "object": "organization.usage.completions.result",
+                  "input_tokens": 200,
+                  "output_tokens": 100,
+                  "num_model_requests": 2,
+                  "model": "gpt-5.2"
+                }
+              ]
+            }
+          ],
+          "has_more": false,
+          "next_page": null
+        }
+        """
+
+        let snapshot = try OpenAIAPIUsageFetcher._parseSnapshotForTesting(
+            costs: Data(costs.utf8),
+            completions: Data(completions.utf8),
+            now: now,
+            historyDays: 90)
+
+        #expect(snapshot.historyDays == 90)
+        #expect(snapshot.historyWindowLabel == "90d")
+        #expect(snapshot.daily.count == 2)
+        #expect(snapshot.daily[0].costUSD == 14.75)
+        #expect(snapshot.daily[0].requests == 10)
+        #expect(snapshot.daily[0].totalTokens == 2000)
+        #expect(snapshot.daily[0].cachedInputTokens == 250)
+        #expect(snapshot.daily[0].lineItems.first?.name == "Text tokens")
+        #expect(snapshot.last30Days.costUSD == 18.75)
+        #expect(snapshot.last30Days.requests == 12)
+        #expect(snapshot.last30Days.totalTokens == 2300)
+        #expect(snapshot.topModels.first?.name == "gpt-5.2")
+        #expect(snapshot.topModels.first?.totalTokens == 1800)
+    }
+
+    @Test
+    func `admin usage fetch pages long history within endpoint bucket limit`() async throws {
+        let now = Date(timeIntervalSince1970: 1_700_179_200)
+        let emptyPage = Data(#"{"object":"page","data":[],"has_more":false,"next_page":null}"#.utf8)
+        let transport = ProviderHTTPTransportStub { request in
+            let response = try HTTPURLResponse(
+                url: #require(request.url),
+                statusCode: 200,
+                httpVersion: nil,
+                headerFields: nil)!
+            return (emptyPage, response)
+        }
+
+        let snapshot = try await OpenAIAPIUsageFetcher.fetchUsage(
+            apiKey: "sk-test",
+            costsURL: #require(URL(string: "https://api.openai.test/v1/organization/costs")),
+            completionsURL: #require(URL(string: "https://api.openai.test/v1/organization/usage/completions")),
+            session: transport,
+            now: now,
+            historyDays: 90)
+
+        let requests = await transport.requests()
+        let limits = requests.compactMap { request -> Int? in
+            guard let url = request.url,
+                  let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
+                  let raw = components.queryItems?.first(where: { $0.name == "limit" })?.value
+            else { return nil }
+            return Int(raw)
+        }
+
+        #expect(snapshot.historyDays == 90)
+        #expect(requests.count == 6)
+        #expect(limits == [31, 31, 28, 31, 31, 28])
+        #expect(limits.allSatisfy { $0 <= 31 })
+    }
+
+    @Test
+    func `admin usage filters costs and completions by project`() async throws {
+        let now = Date(timeIntervalSince1970: 1_700_179_200)
+        let emptyPage = Data(#"{"object":"page","data":[],"has_more":false,"next_page":null}"#.utf8)
+        let transport = ProviderHTTPTransportStub { request in
+            let response = try HTTPURLResponse(
+                url: #require(request.url),
+                statusCode: 200,
+                httpVersion: nil,
+                headerFields: nil)!
+            return (emptyPage, response)
+        }
+
+        let snapshot = try await OpenAIAPIUsageFetcher.fetchUsage(
+            apiKey: "sk-test",
+            projectID: " proj_abc ",
+            costsURL: #require(URL(string: "https://api.openai.test/v1/organization/costs")),
+            completionsURL: #require(URL(string: "https://api.openai.test/v1/organization/usage/completions")),
+            session: transport,
+            now: now,
+            historyDays: 1)
+
+        let requests = await transport.requests()
+        let projectIDs = requests.compactMap { request -> String? in
+            guard let url = request.url,
+                  let components = URLComponents(url: url, resolvingAgainstBaseURL: false)
+            else { return nil }
+            return components.queryItems?.first(where: { $0.name == "project_ids" })?.value
+        }
+        let groupBys = requests.compactMap { request -> String? in
+            guard let url = request.url,
+                  let components = URLComponents(url: url, resolvingAgainstBaseURL: false)
+            else { return nil }
+            return components.queryItems?.first(where: { $0.name == "group_by" })?.value
+        }
+
+        #expect(snapshot.projectID == "proj_abc")
+        #expect(snapshot.toUsageSnapshot().identity?.accountOrganization == "Project: proj_abc")
+        #expect(requests.count == 2)
+        #expect(projectIDs == ["proj_abc", "proj_abc"])
+        #expect(groupBys == ["line_item", "model"])
+    }
+
+    @Test
+    func `admin usage follows costs and completions pagination cursors`() async throws {
+        let now = Date(timeIntervalSince1970: 1_700_179_200)
+        let transport = OpenAIAdminUsagePaginationScript()
+
+        let snapshot = try await OpenAIAPIUsageFetcher.fetchUsage(
+            apiKey: "sk-test",
+            projectID: "proj_abc",
+            costsURL: #require(URL(string: "https://api.openai.test/v1/organization/costs")),
+            completionsURL: #require(URL(string: "https://api.openai.test/v1/organization/usage/completions")),
+            session: transport,
+            now: now,
+            historyDays: 1)
+
+        let requests = await transport.requests()
+        let costsRequests = requests.filter { $0.url?.path.contains("/organization/costs") == true }
+        let completionRequests = requests.filter { $0.url?.path.contains("/usage/completions") == true }
+
+        #expect(snapshot.daily.count == 1)
+        #expect(snapshot.latestDay.costUSD == 4.0)
+        #expect(snapshot.latestDay.requests == 3)
+        #expect(snapshot.latestDay.totalTokens == 45)
+        #expect(costsRequests.count == 2)
+        #expect(completionRequests.count == 2)
+        #expect(Self.queryValue("page", in: costsRequests[0]) == nil)
+        #expect(Self.queryValue("page", in: costsRequests[1]) == "costs_page_2")
+        #expect(Self.queryValue("page", in: completionRequests[0]) == nil)
+        #expect(Self.queryValue("page", in: completionRequests[1]) == "completions_page_2")
+        #expect(requests.allSatisfy { Self.queryValue("project_ids", in: $0) == "proj_abc" })
+    }
+
+    @Test
+    func `admin usage rejects repeated pagination cursor`() async throws {
+        let transport = OpenAIAdminUsageRepeatingCursorScript()
+
+        await #expect(throws: OpenAIAPIUsageError.parseFailed(
+            endpoint: "costs",
+            message: "Pagination cursor repeated."))
+        {
+            try await OpenAIAPIUsageFetcher.fetchUsage(
+                apiKey: "sk-test",
+                costsURL: #require(URL(string: "https://api.openai.test/v1/organization/costs")),
+                completionsURL: #require(URL(string: "https://api.openai.test/v1/organization/usage/completions")),
+                session: transport,
+                now: Date(timeIntervalSince1970: 1_700_179_200),
+                historyDays: 1)
+        }
+    }
+
+    @Test
+    func `admin usage rejects missing pagination cursor`() async throws {
+        let transport = OpenAIAdminUsageMissingCursorScript()
+
+        await #expect(throws: OpenAIAPIUsageError.parseFailed(
+            endpoint: "costs",
+            message: "Pagination cursor missing."))
+        {
+            try await OpenAIAPIUsageFetcher.fetchUsage(
+                apiKey: "sk-test",
+                costsURL: #require(URL(string: "https://api.openai.test/v1/organization/costs")),
+                completionsURL: #require(URL(string: "https://api.openai.test/v1/organization/usage/completions")),
+                session: transport,
+                now: Date(timeIntervalSince1970: 1_700_179_200),
+                historyDays: 1)
+        }
+    }
+
+    @Test
+    func `admin usage rejects page without costs data`() async throws {
+        let transport = OpenAIAdminUsageMalformedPageScript(
+            costs: #"{"object":"page","has_more":false,"next_page":null}"#,
+            completions: #"{"object":"page","data":[],"has_more":false,"next_page":null}"#)
+
+        do {
+            _ = try await OpenAIAPIUsageFetcher.fetchUsage(
+                apiKey: "sk-test",
+                costsURL: #require(URL(string: "https://api.openai.test/v1/organization/costs")),
+                completionsURL: #require(URL(string: "https://api.openai.test/v1/organization/usage/completions")),
+                session: transport,
+                now: Date(timeIntervalSince1970: 1_700_179_200),
+                historyDays: 1)
+            Issue.record("Expected costs parse failure.")
+        } catch let error as OpenAIAPIUsageError {
+            guard case let .parseFailed(endpoint, message) = error else {
+                Issue.record("Expected parse failure, got \(error).")
+                return
+            }
+            #expect(endpoint == "costs")
+            #expect(message.contains("data"))
+        } catch {
+            Issue.record("Expected OpenAIAPIUsageError, got \(error).")
+        }
+    }
+
+    @Test
+    func `admin usage rejects page without completions pagination state`() async throws {
+        let transport = OpenAIAdminUsageMalformedPageScript(
+            costs: #"{"object":"page","data":[],"has_more":false,"next_page":null}"#,
+            completions: #"{"object":"page","data":[],"next_page":null}"#)
+
+        do {
+            _ = try await OpenAIAPIUsageFetcher.fetchUsage(
+                apiKey: "sk-test",
+                costsURL: #require(URL(string: "https://api.openai.test/v1/organization/costs")),
+                completionsURL: #require(URL(string: "https://api.openai.test/v1/organization/usage/completions")),
+                session: transport,
+                now: Date(timeIntervalSince1970: 1_700_179_200),
+                historyDays: 1)
+            Issue.record("Expected completions parse failure.")
+        } catch let error as OpenAIAPIUsageError {
+            guard case let .parseFailed(endpoint, message) = error else {
+                Issue.record("Expected parse failure, got \(error).")
+                return
+            }
+            #expect(endpoint == "completions")
+            #expect(message.contains("missing"))
+        } catch {
+            Issue.record("Expected OpenAIAPIUsageError, got \(error).")
+        }
+    }
+
+    @Test
+    func `admin usage retries transient completions failure once`() async throws {
+        let now = Date(timeIntervalSince1970: 1_700_179_200)
+        let emptyPage = Data(#"{"object":"page","data":[],"has_more":false,"next_page":null}"#.utf8)
+        let completions = Data("""
+        {
+          "object": "page",
+          "data": [
+            {
+              "object": "bucket",
+              "start_time": 1700000000,
+              "end_time": 1700086400,
+              "results": [
+                {
+                  "object": "organization.usage.completions.result",
+                  "input_tokens": 10,
+                  "output_tokens": 5,
+                  "num_model_requests": 1,
+                  "model": "gpt-5.2"
+                }
+              ]
+            }
+          ],
+          "has_more": false,
+          "next_page": null
+        }
+        """.utf8)
+        let transport = OpenAIAdminUsageRetryScript(costs: emptyPage, completions: completions)
+
+        let snapshot = try await OpenAIAPIUsageFetcher.fetchUsage(
+            apiKey: "sk-test",
+            costsURL: #require(URL(string: "https://api.openai.test/v1/organization/costs")),
+            completionsURL: #require(URL(string: "https://api.openai.test/v1/organization/usage/completions")),
+            session: transport,
+            now: now,
+            historyDays: 1,
+            retryPolicy: ProviderHTTPRetryPolicy(maxRetries: 1, baseDelaySeconds: 0, maxDelaySeconds: 0))
+
+        #expect(snapshot.latestDay.totalTokens == 15)
+        #expect(snapshot.latestDay.requests == 1)
+        #expect(await transport.completionsRequestCount() == 2)
+    }
+
+    @Test
+    func `maps admin usage to openai usage snapshot`() {
+        let now = Date(timeIntervalSince1970: 1_700_179_200)
+        let apiUsage = OpenAIAPIUsageSnapshot(
+            daily: [
+                OpenAIAPIUsageSnapshot.DailyBucket(
+                    day: "2023-11-14",
+                    startTime: now,
+                    endTime: now.addingTimeInterval(86400),
+                    costUSD: 8.5,
+                    requests: 42,
+                    inputTokens: 1000,
+                    cachedInputTokens: 400,
+                    outputTokens: 250,
+                    totalTokens: 1250,
+                    lineItems: [],
+                    models: []),
+            ],
+            updatedAt: now)
+
+        let usage = apiUsage.toUsageSnapshot()
+
+        #expect(usage.primary == nil)
+        #expect(usage.providerCost?.used == 8.5)
+        #expect(usage.providerCost?.limit == 0)
+        #expect(usage.providerCost?.period == "Last 30 days")
+        #expect(usage.openAIAPIUsage?.last30Days.requests == 42)
+        #expect(usage.identity?.loginMethod == "Admin API")
+    }
+
+    @Test
+    func `maps project scoped admin usage to cost token snapshot`() {
+        let now = Date(timeIntervalSince1970: 1_700_179_200)
+        let apiUsage = OpenAIAPIUsageSnapshot(
+            daily: [
+                OpenAIAPIUsageSnapshot.DailyBucket(
+                    day: "2023-11-13",
+                    startTime: now.addingTimeInterval(-86400),
+                    endTime: now,
+                    costUSD: 2.25,
+                    requests: 3,
+                    inputTokens: 300,
+                    cachedInputTokens: 100,
+                    outputTokens: 200,
+                    totalTokens: 500,
+                    lineItems: [],
+                    models: [
+                        OpenAIAPIUsageSnapshot.ModelBreakdown(
+                            name: "gpt-5.2",
+                            requests: 3,
+                            inputTokens: 300,
+                            cachedInputTokens: 100,
+                            outputTokens: 200,
+                            totalTokens: 500),
+                    ]),
+                OpenAIAPIUsageSnapshot.DailyBucket(
+                    day: "2023-11-14",
+                    startTime: now,
+                    endTime: now.addingTimeInterval(86400),
+                    costUSD: 8.5,
+                    requests: 42,
+                    inputTokens: 1000,
+                    cachedInputTokens: 400,
+                    outputTokens: 250,
+                    totalTokens: 1250,
+                    lineItems: [],
+                    models: [
+                        OpenAIAPIUsageSnapshot.ModelBreakdown(
+                            name: "gpt-5.2-codex",
+                            requests: 42,
+                            inputTokens: 1000,
+                            cachedInputTokens: 400,
+                            outputTokens: 250,
+                            totalTokens: 1250),
+                    ]),
+            ],
+            updatedAt: now,
+            historyDays: 7,
+            projectID: " proj_abc ")
+
+        let usage = apiUsage.toUsageSnapshot()
+        let snapshot = apiUsage.toCostUsageTokenSnapshot()
+
+        #expect(apiUsage.projectID == "proj_abc")
+        #expect(usage.identity?.loginMethod == "Admin API: proj_abc")
+        #expect(usage.identity?.accountOrganization == "Project: proj_abc")
+        #expect(snapshot.historyDays == 7)
+        #expect(snapshot.currencyCode == "USD")
+        #expect(snapshot.sessionCostUSD == 8.5)
+        #expect(snapshot.sessionTokens == 1250)
+        #expect(snapshot.sessionRequests == 42)
+        #expect(snapshot.last30DaysCostUSD == 10.75)
+        #expect(snapshot.last30DaysTokens == 1750)
+        #expect(snapshot.last30DaysRequests == 45)
+        #expect(snapshot.daily.count == 2)
+        #expect(snapshot.daily[1].cacheReadTokens == 400)
+        #expect(snapshot.daily[1].requestCount == 42)
+        #expect(snapshot.daily[1].modelBreakdowns?.first?.requestCount == 42)
+        #expect(snapshot.daily[1].modelBreakdowns?.first?.modelName == "gpt-5.2-codex")
+    }
+
+    private static func queryValue(_ name: String, in request: URLRequest) -> String? {
+        guard let url = request.url,
+              let components = URLComponents(url: url, resolvingAgainstBaseURL: false)
+        else { return nil }
+        return components.queryItems?.first(where: { $0.name == name })?.value
+    }
+}
+
+private actor OpenAIAdminUsagePaginationScript: ProviderHTTPTransport {
+    private var recordedRequests: [URLRequest] = []
+
+    func requests() -> [URLRequest] {
+        self.recordedRequests
+    }
+
+    func data(for request: URLRequest) throws -> (Data, URLResponse) {
+        self.recordedRequests.append(request)
+        let url = request.url ?? URL(string: "https://api.openai.test")!
+        let page = Self.queryValue("page", in: url)
+        let body: String = if url.path.contains("/organization/costs") {
+            page == "costs_page_2" ? Self.costsPage2 : Self.costsPage1
+        } else if url.path.contains("/usage/completions") {
+            page == "completions_page_2" ? Self.completionsPage2 : Self.completionsPage1
+        } else {
+            #"{"object":"page","data":[],"has_more":false,"next_page":null}"#
+        }
+        return (Data(body.utf8), HTTPURLResponse(
+            url: url,
+            statusCode: 200,
+            httpVersion: "HTTP/1.1",
+            headerFields: nil)!)
+    }
+
+    private static func queryValue(_ name: String, in url: URL) -> String? {
+        URLComponents(url: url, resolvingAgainstBaseURL: false)?
+            .queryItems?
+            .first(where: { $0.name == name })?
+            .value
+    }
+
+    private static let costsPage1 = """
+    {
+      "object": "page",
+      "data": [
+        {
+          "object": "bucket",
+          "start_time": 1700000000,
+          "end_time": 1700086400,
+          "results": [
+            {
+              "object": "organization.costs.result",
+              "amount": { "value": 1.25, "currency": "usd" },
+              "line_item": "Text tokens"
+            }
+          ]
+        }
+      ],
+      "has_more": true,
+      "next_page": "costs_page_2"
+    }
+    """
+
+    private static let costsPage2 = """
+    {
+      "object": "page",
+      "data": [
+        {
+          "object": "bucket",
+          "start_time": 1700000000,
+          "end_time": 1700086400,
+          "results": [
+            {
+              "object": "organization.costs.result",
+              "amount": { "value": 2.75, "currency": "usd" },
+              "line_item": "Web search tool calls"
+            }
+          ]
+        }
+      ],
+      "has_more": false,
+      "next_page": null
+    }
+    """
+
+    private static let completionsPage1 = """
+    {
+      "object": "page",
+      "data": [
+        {
+          "object": "bucket",
+          "start_time": 1700000000,
+          "end_time": 1700086400,
+          "results": [
+            {
+              "object": "organization.usage.completions.result",
+              "input_tokens": 10,
+              "output_tokens": 5,
+              "num_model_requests": 1,
+              "model": "gpt-5.2"
+            }
+          ]
+        }
+      ],
+      "has_more": true,
+      "next_page": "completions_page_2"
+    }
+    """
+
+    private static let completionsPage2 = """
+    {
+      "object": "page",
+      "data": [
+        {
+          "object": "bucket",
+          "start_time": 1700000000,
+          "end_time": 1700086400,
+          "results": [
+            {
+              "object": "organization.usage.completions.result",
+              "input_tokens": 20,
+              "output_tokens": 10,
+              "num_model_requests": 2,
+              "model": "gpt-5.2"
+            }
+          ]
+        }
+      ],
+      "has_more": false,
+      "next_page": null
+    }
+    """
+}
+
+private actor OpenAIAdminUsageRepeatingCursorScript: ProviderHTTPTransport {
+    func data(for request: URLRequest) throws -> (Data, URLResponse) {
+        let url = request.url ?? URL(string: "https://api.openai.test")!
+        let body = """
+        {
+          "object": "page",
+          "data": [],
+          "has_more": true,
+          "next_page": "same_page"
+        }
+        """
+        return (Data(body.utf8), HTTPURLResponse(
+            url: url,
+            statusCode: 200,
+            httpVersion: "HTTP/1.1",
+            headerFields: nil)!)
+    }
+}
+
+private actor OpenAIAdminUsageMissingCursorScript: ProviderHTTPTransport {
+    func data(for request: URLRequest) throws -> (Data, URLResponse) {
+        let url = request.url ?? URL(string: "https://api.openai.test")!
+        let body = """
+        {
+          "object": "page",
+          "data": [],
+          "has_more": true,
+          "next_page": null
+        }
+        """
+        return (Data(body.utf8), HTTPURLResponse(
+            url: url,
+            statusCode: 200,
+            httpVersion: "HTTP/1.1",
+            headerFields: nil)!)
+    }
+}
+
+private actor OpenAIAdminUsageMalformedPageScript: ProviderHTTPTransport {
+    private let costs: String
+    private let completions: String
+
+    init(costs: String, completions: String) {
+        self.costs = costs
+        self.completions = completions
+    }
+
+    func data(for request: URLRequest) throws -> (Data, URLResponse) {
+        let url = request.url ?? URL(string: "https://api.openai.test")!
+        let body = url.path.contains("/usage/completions") ? self.completions : self.costs
+        return (Data(body.utf8), HTTPURLResponse(
+            url: url,
+            statusCode: 200,
+            httpVersion: "HTTP/1.1",
+            headerFields: nil)!)
+    }
+}
+
+private actor OpenAIAdminUsageRetryScript: ProviderHTTPTransport {
+    private let costs: Data
+    private let completions: Data
+    private var completionsRequests = 0
+
+    init(costs: Data, completions: Data) {
+        self.costs = costs
+        self.completions = completions
+    }
+
+    func completionsRequestCount() -> Int {
+        self.completionsRequests
+    }
+
+    func data(for request: URLRequest) throws -> (Data, URLResponse) {
+        let url = request.url ?? URL(string: "https://api.openai.test")!
+        if url.path.contains("/usage/completions") {
+            self.completionsRequests += 1
+            if self.completionsRequests == 1 {
+                return (Data(), HTTPURLResponse(
+                    url: url,
+                    statusCode: 503,
+                    httpVersion: "HTTP/1.1",
+                    headerFields: nil)!)
+            }
+            return (self.completions, HTTPURLResponse(
+                url: url,
+                statusCode: 200,
+                httpVersion: "HTTP/1.1",
+                headerFields: nil)!)
+        }
+
+        return (self.costs, HTTPURLResponse(
+            url: url,
+            statusCode: 200,
+            httpVersion: "HTTP/1.1",
+            headerFields: nil)!)
+    }
+}
diff --git a/Tests/CodexBarTests/OpenAIDashboardBrowserCookieImporterTests.swift b/Tests/CodexBarTests/OpenAIDashboardBrowserCookieImporterTests.swift
index cad9598841..dc505e79cd 100644
--- a/Tests/CodexBarTests/OpenAIDashboardBrowserCookieImporterTests.swift
+++ b/Tests/CodexBarTests/OpenAIDashboardBrowserCookieImporterTests.swift
@@ -1,10 +1,282 @@
-import CodexBarCore
+import Foundation
 import Testing
+@testable import CodexBarCore
+
+private final class CookieCallbackHarness: @unchecked Sendable {
+    private let lock = NSLock()
+    private var callback: (@Sendable () -> Void)?
+
+    func capture(_ callback: @escaping @Sendable () -> Void) {
+        self.lock.withLock { self.callback = callback }
+    }
+
+    func finish() {
+        let callback = self.lock.withLock {
+            let callback = self.callback
+            self.callback = nil
+            return callback
+        }
+        callback?()
+    }
+}
+
+private final class CookieCallbackFlag: @unchecked Sendable {
+    private let lock = NSLock()
+    private var storedValue = false
+
+    var value: Bool {
+        self.lock.withLock { self.storedValue }
+    }
+
+    func set() {
+        self.lock.withLock { self.storedValue = true }
+    }
+}
+
+private final class CookieOperationLog: @unchecked Sendable {
+    private let lock = NSLock()
+    private var entries: [String] = []
+
+    var snapshot: [String] {
+        self.lock.withLock { self.entries }
+    }
+
+    func append(_ entry: String) {
+        self.lock.withLock { self.entries.append(entry) }
+    }
+}
+
+private final class CookieTimeoutProbe: @unchecked Sendable {
+    private let lock = NSLock()
+    private var storedFiredAt: Date?
+
+    var firedAt: Date? {
+        self.lock.withLock { self.storedFiredAt }
+    }
+
+    func record() {
+        self.lock.withLock {
+            if self.storedFiredAt == nil {
+                self.storedFiredAt = Date()
+            }
+        }
+    }
+}
 
-@Suite
 struct OpenAIDashboardBrowserCookieImporterTests {
     @Test
-    func mismatchErrorMentionsSourceLabel() {
+    func `shared deadline clamps each local timeout to remaining budget`() throws {
+        let start = Date(timeIntervalSinceReferenceDate: 1000)
+        let deadline = start.addingTimeInterval(30)
+
+        let remaining = try OpenAIDashboardBrowserCookieImporter.remainingTimeout(
+            until: deadline,
+            cappedAt: 10,
+            now: start.addingTimeInterval(27))
+
+        #expect(remaining == 3)
+    }
+
+    @Test
+    func `shared deadline preserves smaller local timeout`() throws {
+        let start = Date(timeIntervalSinceReferenceDate: 1000)
+        let deadline = start.addingTimeInterval(30)
+
+        let remaining = try OpenAIDashboardBrowserCookieImporter.remainingTimeout(
+            until: deadline,
+            cappedAt: 10,
+            now: start.addingTimeInterval(5))
+
+        #expect(remaining == 10)
+    }
+
+    @Test
+    func `expired shared deadline throws structured timeout`() {
+        let deadline = Date(timeIntervalSinceReferenceDate: 1000)
+
+        do {
+            _ = try OpenAIDashboardBrowserCookieImporter.remainingTimeout(
+                until: deadline,
+                now: deadline)
+            Issue.record("Expected deadline timeout")
+        } catch let error as URLError {
+            #expect(error.code == .timedOut)
+        } catch {
+            Issue.record("Unexpected error: \(error)")
+        }
+    }
+
+    @Test
+    func `blocking browser cookie load cannot exceed shared deadline`() async throws {
+        let start = Date()
+        let timeoutProbe = CookieTimeoutProbe()
+
+        do {
+            _ = try await OpenAIDashboardBrowserCookieImporter.runBoundedCookieLoad(
+                deadline: start.addingTimeInterval(0.05),
+                timeoutObserver: timeoutProbe.record)
+            {
+                Thread.sleep(forTimeInterval: 0.5)
+                return true
+            }
+            Issue.record("Expected cookie load timeout")
+        } catch let error as URLError {
+            #expect(error.code == .timedOut)
+        } catch {
+            Issue.record("Unexpected error: \(error)")
+        }
+        let firedAt = try #require(timeoutProbe.firedAt)
+        #expect(firedAt.timeIntervalSince(start) < 0.3)
+    }
+
+    @Test
+    func `timeout observer stays silent when operation wins`() async throws {
+        let timeoutProbe = CookieTimeoutProbe()
+
+        let value = try await OpenAIDashboardBrowserCookieImporter.runBoundedCookieLoad(
+            deadline: Date().addingTimeInterval(0.05),
+            timeoutObserver: timeoutProbe.record)
+        {
+            true
+        }
+        try await Task.sleep(for: .milliseconds(100))
+
+        #expect(value)
+        #expect(timeoutProbe.firedAt == nil)
+    }
+
+    @Test
+    func `timed out cookie cache work stays ordered before retry`() async throws {
+        let log = CookieOperationLog()
+        let firstOperationStarted = DispatchSemaphore(value: 0)
+        let allowFirstOperationToFinish = DispatchSemaphore(value: 0)
+
+        do {
+            _ = try await OpenAIDashboardBrowserCookieImporter.runBoundedCookieCacheOperation(
+                deadline: Date().addingTimeInterval(0.05))
+            {
+                log.append("first-start")
+                firstOperationStarted.signal()
+                _ = allowFirstOperationToFinish.wait(timeout: .now() + 5)
+                log.append("first-end")
+                return true
+            }
+            Issue.record("Expected first cache operation timeout")
+        } catch let error as URLError {
+            #expect(error.code == .timedOut)
+        } catch {
+            Issue.record("Unexpected error: \(error)")
+        }
+        let firstOperationStartResult = await withCheckedContinuation { continuation in
+            DispatchQueue.global(qos: .userInitiated).async {
+                continuation.resume(returning: firstOperationStarted.wait(timeout: .now() + 5))
+            }
+        }
+        #expect(firstOperationStartResult == .success)
+        do {
+            _ = try await OpenAIDashboardBrowserCookieImporter.runBoundedCookieCacheOperation(
+                deadline: Date().addingTimeInterval(0.05))
+            {
+                log.append("second")
+                return true
+            }
+            Issue.record("Expected retry to wait behind first cache operation")
+        } catch let error as URLError {
+            #expect(error.code == .timedOut)
+        } catch {
+            Issue.record("Unexpected error: \(error)")
+        }
+        allowFirstOperationToFinish.signal()
+
+        _ = try await OpenAIDashboardBrowserCookieImporter.runBoundedCookieCacheOperation(
+            deadline: Date().addingTimeInterval(1)) { true }
+        #expect(log.snapshot == ["first-start", "first-end", "second"])
+    }
+
+    @Test @MainActor
+    func `slow callback times out before completion`() async throws {
+        let start = Date()
+        let timeoutProbe = CookieTimeoutProbe()
+
+        do {
+            try await OpenAIDashboardBrowserCookieImporter.runBoundedCallback(
+                deadline: start.addingTimeInterval(0.05),
+                timeoutObserver: timeoutProbe.record)
+            { completion in
+                DispatchQueue.global(qos: .userInitiated).asyncAfter(deadline: .now() + 0.5) {
+                    completion()
+                }
+            }
+            Issue.record("Expected callback timeout")
+        } catch let error as URLError {
+            #expect(error.code == .timedOut)
+        } catch {
+            Issue.record("Unexpected error: \(error)")
+        }
+        let firedAt = try #require(timeoutProbe.firedAt)
+        #expect(firedAt.timeIntervalSince(start) < 0.3)
+    }
+
+    @Test @MainActor
+    func `slow value callback times out before completion`() async throws {
+        let start = Date()
+        let timeoutProbe = CookieTimeoutProbe()
+
+        do {
+            let _: [String] = try await OpenAIDashboardBrowserCookieImporter.runBoundedValueCallback(
+                deadline: start.addingTimeInterval(0.05),
+                timeoutObserver: timeoutProbe.record)
+            { completion in
+                DispatchQueue.global(qos: .userInitiated).asyncAfter(deadline: .now() + 0.5) {
+                    completion([])
+                }
+            }
+            Issue.record("Expected value callback timeout")
+        } catch let error as URLError {
+            #expect(error.code == .timedOut)
+        } catch {
+            Issue.record("Unexpected error: \(error)")
+        }
+        let firedAt = try #require(timeoutProbe.firedAt)
+        #expect(firedAt.timeIntervalSince(start) < 0.3)
+    }
+
+    @Test @MainActor
+    func `retry waits for timed out cookie store mutation`() async throws {
+        let keyOwner = NSObject()
+        let key = ObjectIdentifier(keyOwner)
+        let first = CookieCallbackHarness()
+
+        do {
+            try await OpenAIDashboardBrowserCookieImporter.runSerializedCallback(
+                key: key,
+                deadline: Date().addingTimeInterval(0.05),
+                start: first.capture)
+            Issue.record("Expected first mutation timeout")
+        } catch let error as URLError {
+            #expect(error.code == .timedOut)
+        }
+
+        let secondStarted = CookieCallbackFlag()
+        let second = Task { @MainActor in
+            try await OpenAIDashboardBrowserCookieImporter.runSerializedCallback(
+                key: key,
+                deadline: Date().addingTimeInterval(1))
+            { completion in
+                secondStarted.set()
+                completion()
+            }
+        }
+
+        try await Task.sleep(for: .milliseconds(50))
+        #expect(!secondStarted.value)
+        first.finish()
+        try await second.value
+        #expect(secondStarted.value)
+    }
+
+    @Test
+    func `mismatch error mentions source label`() {
         let err = OpenAIDashboardBrowserCookieImporter.ImportError.noMatchingAccount(
             found: [
                 .init(sourceLabel: "Safari", email: "a@example.com"),
@@ -14,4 +286,23 @@ struct OpenAIDashboardBrowserCookieImporterTests {
         #expect(msg.contains("Safari=a@example.com"))
         #expect(msg.contains("Chrome=b@example.com"))
     }
+
+    @Test
+    func `timed out persistent validation keeps verified session`() {
+        let failure = OpenAIDashboardBrowserCookieImporter.persistentValidationFailure(URLError(.timedOut))
+        #expect(OpenAIDashboardBrowserCookieImporter.shouldTrustVerifiedSession(
+            afterPersistFailure: failure))
+    }
+
+    @Test
+    func `raw cookie mutation timeout is not trusted`() {
+        #expect(!OpenAIDashboardBrowserCookieImporter.shouldTrustVerifiedSession(
+            afterPersistFailure: URLError(.timedOut)))
+    }
+
+    @Test
+    func `non-timeout persistent validation failures are not trusted`() {
+        #expect(!OpenAIDashboardBrowserCookieImporter.shouldTrustVerifiedSession(
+            afterPersistFailure: OpenAIDashboardBrowserCookieImporter.ImportError.dashboardStillRequiresLogin))
+    }
 }
diff --git a/Tests/CodexBarTests/OpenAIDashboardFetcherCreditsWaitTests.swift b/Tests/CodexBarTests/OpenAIDashboardFetcherCreditsWaitTests.swift
index d8f0a7f4bc..f501fcf1ba 100644
--- a/Tests/CodexBarTests/OpenAIDashboardFetcherCreditsWaitTests.swift
+++ b/Tests/CodexBarTests/OpenAIDashboardFetcherCreditsWaitTests.swift
@@ -2,10 +2,9 @@ import Foundation
 import Testing
 @testable import CodexBarCore
 
-@Suite
 struct OpenAIDashboardFetcherCreditsWaitTests {
     @Test
-    func waitsAfterScrollRequest() {
+    func `waits after scroll request`() {
         let now = Date()
         let shouldWait = OpenAIDashboardFetcher.shouldWaitForCreditsHistory(.init(
             now: now,
@@ -18,7 +17,7 @@ struct OpenAIDashboardFetcherCreditsWaitTests {
     }
 
     @Test
-    func waitsBrieflyWhenHeaderVisibleButTableEmpty() {
+    func `waits briefly when header visible but table empty`() {
         let now = Date()
         let visibleAt = now.addingTimeInterval(-1.0)
         let shouldWait = OpenAIDashboardFetcher.shouldWaitForCreditsHistory(.init(
@@ -32,7 +31,7 @@ struct OpenAIDashboardFetcherCreditsWaitTests {
     }
 
     @Test
-    func stopsWaitingAfterHeaderHasBeenVisibleLongEnough() {
+    func `stops waiting after header has been visible long enough`() {
         let now = Date()
         let visibleAt = now.addingTimeInterval(-3.0)
         let shouldWait = OpenAIDashboardFetcher.shouldWaitForCreditsHistory(.init(
@@ -46,7 +45,7 @@ struct OpenAIDashboardFetcherCreditsWaitTests {
     }
 
     @Test
-    func waitsBrieflyAfterFirstDashboardSignalEvenWhenHeaderNotPresentYet() {
+    func `waits briefly after first dashboard signal even when header not present yet`() {
         let now = Date()
         let startedAt = now.addingTimeInterval(-2.0)
         let shouldWait = OpenAIDashboardFetcher.shouldWaitForCreditsHistory(.init(
@@ -60,7 +59,7 @@ struct OpenAIDashboardFetcherCreditsWaitTests {
     }
 
     @Test
-    func stopsWaitingEventuallyWhenHeaderNeverAppears() {
+    func `stops waiting eventually when header never appears`() {
         let now = Date()
         let startedAt = now.addingTimeInterval(-7.0)
         let shouldWait = OpenAIDashboardFetcher.shouldWaitForCreditsHistory(.init(
@@ -74,14 +73,106 @@ struct OpenAIDashboardFetcherCreditsWaitTests {
     }
 
     @Test
-    func sanitizedTimeoutPreservesPositiveCallerDeadline() {
+    func `usage breakdown recovery waits briefly after chart classification error`() {
+        let now = Date()
+        let shouldWait = OpenAIDashboardFetcher.shouldWaitForUsageBreakdownRecovery(.init(
+            now: now,
+            errorFirstSeenAt: now.addingTimeInterval(-1.0)))
+        #expect(shouldWait == true)
+    }
+
+    @Test
+    func `usage breakdown recovery stops blocking partial snapshots`() {
+        let now = Date()
+        let shouldWait = OpenAIDashboardFetcher.shouldWaitForUsageBreakdownRecovery(.init(
+            now: now,
+            errorFirstSeenAt: now.addingTimeInterval(-5.0)))
+        #expect(shouldWait == false)
+    }
+
+    @Test
+    func `probe waits briefly after reaching usage route without email or dashboard signals`() {
+        let now = Date()
+        let shouldWait = OpenAIDashboardFetcher.shouldWaitForProbeReadiness(.init(
+            now: now,
+            usageRouteSeenAt: now.addingTimeInterval(-1.0),
+            dashboardSignalSeenAt: nil,
+            signedInEmail: nil,
+            hasDashboardSignal: false))
+        #expect(shouldWait == true)
+    }
+
+    @Test
+    func `probe waits briefly for email after dashboard signals appear`() {
+        let now = Date()
+        let shouldWait = OpenAIDashboardFetcher.shouldWaitForProbeReadiness(.init(
+            now: now,
+            usageRouteSeenAt: now.addingTimeInterval(-3.0),
+            dashboardSignalSeenAt: now.addingTimeInterval(-1.0),
+            signedInEmail: nil,
+            hasDashboardSignal: true))
+        #expect(shouldWait == true)
+    }
+
+    @Test
+    func `probe stops waiting once signed in email is available`() {
+        let now = Date()
+        let shouldWait = OpenAIDashboardFetcher.shouldWaitForProbeReadiness(.init(
+            now: now,
+            usageRouteSeenAt: now.addingTimeInterval(-0.2),
+            dashboardSignalSeenAt: now.addingTimeInterval(-0.2),
+            signedInEmail: "user@example.com",
+            hasDashboardSignal: true))
+        #expect(shouldWait == false)
+    }
+
+    @Test
+    func `probe handoff preserves page only after confirmed signed in email`() {
+        let result = OpenAIDashboardFetcher.ProbeResult(
+            href: "https://chatgpt.com/codex/cloud/settings/analytics#usage",
+            loginRequired: false,
+            workspacePicker: false,
+            cloudflareInterstitial: false,
+            signedInEmail: "user@example.com",
+            bodyText: "Credits remaining 42")
+
+        #expect(OpenAIDashboardFetcher.shouldPreserveLoadedPageAfterProbe(result))
+    }
+
+    @Test
+    func `probe handoff does not preserve timed out usage page without email`() {
+        let result = OpenAIDashboardFetcher.ProbeResult(
+            href: "https://chatgpt.com/codex/cloud/settings/analytics#usage",
+            loginRequired: false,
+            workspacePicker: false,
+            cloudflareInterstitial: false,
+            signedInEmail: nil,
+            bodyText: "Codex Analytics")
+
+        #expect(!OpenAIDashboardFetcher.shouldPreserveLoadedPageAfterProbe(result))
+    }
+
+    @Test
+    func `probe grace restarts after route reload resets readiness timestamps`() {
+        let now = Date()
+        let shouldWait = OpenAIDashboardFetcher.shouldWaitForProbeReadiness(.init(
+            now: now,
+            usageRouteSeenAt: now,
+            dashboardSignalSeenAt: nil,
+            signedInEmail: nil,
+            hasDashboardSignal: false))
+        #expect(shouldWait == true)
+    }
+
+    @Test
+    func `sanitized timeout preserves positive caller deadline`() {
         #expect(OpenAIDashboardFetcher.sanitizedTimeout(60) == 60)
         #expect(OpenAIDashboardFetcher.sanitizedTimeout(25) == 25)
         #expect(OpenAIDashboardFetcher.sanitizedTimeout(0.5) == 0.5)
     }
 
     @Test
-    func sanitizedTimeoutFallsBackForInvalidValues() {
+    func `sanitized timeout falls back for invalid values`() {
         #expect(OpenAIDashboardFetcher.sanitizedTimeout(0) == 1)
         #expect(OpenAIDashboardFetcher.sanitizedTimeout(-5) == 1)
         #expect(OpenAIDashboardFetcher.sanitizedTimeout(.infinity) == 1)
@@ -89,7 +180,7 @@ struct OpenAIDashboardFetcherCreditsWaitTests {
     }
 
     @Test
-    func deadlineStartsAtCallStartAndRemainingTimeoutShrinksFromThere() {
+    func `deadline starts at call start and remaining timeout shrinks from there`() {
         let start = Date(timeIntervalSinceReferenceDate: 1000)
         let deadline = OpenAIDashboardFetcher.deadline(startingAt: start, timeout: 15)
 
@@ -102,11 +193,156 @@ struct OpenAIDashboardFetcherCreditsWaitTests {
     }
 
     @Test
-    func remainingTimeoutDoesNotGoNegative() {
+    func `remaining timeout does not go negative`() {
         let deadline = Date(timeIntervalSinceReferenceDate: 2000)
         let remaining = OpenAIDashboardFetcher.remainingTimeout(
             until: deadline,
             now: deadline.addingTimeInterval(3))
         #expect(remaining == 0)
     }
+
+    @Test
+    func `usage route matcher accepts legacy settings route`() {
+        #expect(OpenAIDashboardFetcher.isUsageRoute("https://chatgpt.com/codex/settings/usage"))
+    }
+
+    @Test
+    func `usage route matcher accepts cloud settings route`() {
+        #expect(OpenAIDashboardFetcher.isUsageRoute("https://chatgpt.com/codex/cloud/settings/usage"))
+    }
+
+    @Test
+    func `usage route matcher accepts analytics route`() {
+        #expect(OpenAIDashboardFetcher.isUsageRoute("https://chatgpt.com/codex/cloud/settings/analytics"))
+    }
+
+    @Test
+    func `usage route matcher accepts analytics usage hash route`() {
+        #expect(OpenAIDashboardFetcher.isUsageRoute("https://chatgpt.com/codex/cloud/settings/analytics#usage"))
+    }
+
+    @Test
+    func `usage route matcher accepts trailing slash variants`() {
+        #expect(OpenAIDashboardFetcher.isUsageRoute("https://chatgpt.com/codex/settings/usage/"))
+        #expect(OpenAIDashboardFetcher.isUsageRoute("https://chatgpt.com/codex/cloud/settings/usage/"))
+        #expect(OpenAIDashboardFetcher.isUsageRoute("https://chatgpt.com/codex/cloud/settings/analytics/"))
+    }
+
+    @Test
+    func `usage route matcher rejects unrelated routes`() {
+        #expect(!OpenAIDashboardFetcher.isUsageRoute("https://chatgpt.com/"))
+        #expect(!OpenAIDashboardFetcher.isUsageRoute("https://chatgpt.com/codex"))
+        #expect(!OpenAIDashboardFetcher.isUsageRoute(nil))
+    }
+
+    @Test(arguments: [
+        ("https://chatgpt.com/#usage", true, false, false, false),
+        ("https://chatgpt.com/", false, false, true, false),
+        ("https://chatgpt.com/", false, false, false, true)
+    ])
+    func `usage route reload skips blocking states`(
+        href: String,
+        loginRequired: Bool,
+        workspacePicker: Bool,
+        cloudflareInterstitial: Bool,
+        expected: Bool)
+    {
+        #expect(OpenAIDashboardFetcher.shouldReloadUsageRoute(
+            href: href,
+            loginRequired: loginRequired,
+            workspacePicker: workspacePicker,
+            cloudflareInterstitial: cloudflareInterstitial) == expected)
+    }
+
+    @Test
+    func `dashboard requests prefer English localization`() throws {
+        let url = try #require(URL(string: "https://chatgpt.com/codex/cloud/settings/analytics#usage"))
+        let request = OpenAIDashboardFetcher.usageURLRequest(url: url)
+        #expect(request.value(forHTTPHeaderField: "Accept-Language") == "en-US,en;q=0.9")
+    }
+
+    @Test
+    func `usage api request carries cookies and English localization`() {
+        let request = OpenAIDashboardFetcher.dashboardUsageAPIRequest(cookieHeader: "a=b")
+        #expect(request.url?.absoluteString == "https://chatgpt.com/backend-api/wham/usage")
+        #expect(request.value(forHTTPHeaderField: "Cookie") == "a=b")
+        #expect(request.value(forHTTPHeaderField: "Accept") == "application/json")
+        #expect(request.value(forHTTPHeaderField: "Accept-Language") == "en-US,en;q=0.9")
+    }
+
+    @Test
+    func `identity api request carries cookies and English localization`() throws {
+        let url = try #require(URL(string: "https://chatgpt.com/backend-api/me"))
+        let request = OpenAIDashboardFetcher.dashboardIdentityAPIRequest(url: url, cookieHeader: "a=b")
+
+        #expect(request.url?.absoluteString == "https://chatgpt.com/backend-api/me")
+        #expect(request.value(forHTTPHeaderField: "Cookie") == "a=b")
+        #expect(request.value(forHTTPHeaderField: "Accept") == "application/json")
+        #expect(request.value(forHTTPHeaderField: "Accept-Language") == "en-US,en;q=0.9")
+    }
+
+    @Test
+    func `dashboard api requests accept shared deadline timeout clamps`() throws {
+        let url = try #require(URL(string: "https://chatgpt.com/backend-api/me"))
+        let usageRequest = OpenAIDashboardFetcher.dashboardUsageAPIRequest(
+            cookieHeader: "a=b",
+            timeout: 1.25)
+        let identityRequest = OpenAIDashboardFetcher.dashboardIdentityAPIRequest(
+            url: url,
+            cookieHeader: "a=b",
+            timeout: 0.75)
+
+        #expect(usageRequest.timeoutInterval == 1.25)
+        #expect(identityRequest.timeoutInterval == 0.75)
+    }
+
+    @Test
+    func `usage api data maps language independent rate limits and credits`() throws {
+        let json = """
+        {
+          "plan_type": "pro",
+          "rate_limit": {
+            "primary_window": {
+              "used_percent": 12,
+              "reset_at": 1700003600,
+              "limit_window_seconds": 18000
+            },
+            "secondary_window": {
+              "used_percent": 34,
+              "reset_at": 1700604800,
+              "limit_window_seconds": 604800
+            }
+          },
+          "credits": {
+            "has_credits": true,
+            "unlimited": false,
+            "balance": 42.5
+          }
+        }
+        """
+        let response = try CodexOAuthUsageFetcher._decodeUsageResponseForTesting(Data(json.utf8))
+        let data = OpenAIDashboardFetcher.dashboardAPIData(from: response)
+
+        #expect(data.primaryLimit?.usedPercent == 12)
+        #expect(data.primaryLimit?.windowMinutes == 300)
+        #expect(data.secondaryLimit?.usedPercent == 34)
+        #expect(data.secondaryLimit?.windowMinutes == 10080)
+        #expect(data.creditsRemaining == 42.5)
+        #expect(data.accountPlan == "pro")
+        #expect(data.hasUsageData)
+    }
+
+    @Test
+    func `find first email searches nested api payloads`() {
+        let json = """
+        {
+          "accounts": [
+            { "profile": { "name": "Test" } },
+            { "profile": { "email": "nested@example.com" } }
+          ]
+        }
+        """
+
+        #expect(OpenAIDashboardFetcher.findFirstEmail(inJSONData: Data(json.utf8)) == "nested@example.com")
+    }
 }
diff --git a/Tests/CodexBarTests/OpenAIDashboardModelsTests.swift b/Tests/CodexBarTests/OpenAIDashboardModelsTests.swift
new file mode 100644
index 0000000000..b6547e14fe
--- /dev/null
+++ b/Tests/CodexBarTests/OpenAIDashboardModelsTests.swift
@@ -0,0 +1,94 @@
+import CodexBarCore
+import Foundation
+import Testing
+
+struct OpenAIDashboardModelsTests {
+    @Test
+    func `removes skill usage services from usage breakdown`() {
+        let breakdown = [
+            OpenAIDashboardDailyBreakdown(
+                day: "2026-04-30",
+                services: [
+                    OpenAIDashboardServiceUsage(service: "Desktop App", creditsUsed: 10),
+                    OpenAIDashboardServiceUsage(service: "Skillusage:imagegen", creditsUsed: 7),
+                    OpenAIDashboardServiceUsage(service: " skillusage:github:github ", creditsUsed: 2),
+                ],
+                totalCreditsUsed: 19),
+            OpenAIDashboardDailyBreakdown(
+                day: "2026-04-29",
+                services: [
+                    OpenAIDashboardServiceUsage(service: "Skillusage:deep Research", creditsUsed: 3),
+                ],
+                totalCreditsUsed: 3),
+        ]
+
+        let filtered = OpenAIDashboardDailyBreakdown.removingSkillUsageServices(from: breakdown)
+
+        #expect(filtered == [
+            OpenAIDashboardDailyBreakdown(
+                day: "2026-04-30",
+                services: [
+                    OpenAIDashboardServiceUsage(service: "Desktop App", creditsUsed: 10),
+                ],
+                totalCreditsUsed: 10),
+        ])
+    }
+
+    @Test
+    func `snapshot initializer sanitizes usage breakdown`() {
+        let snapshot = OpenAIDashboardSnapshot(
+            signedInEmail: "codex@example.com",
+            codeReviewRemainingPercent: nil,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: [
+                OpenAIDashboardDailyBreakdown(
+                    day: "2026-04-30",
+                    services: [
+                        OpenAIDashboardServiceUsage(service: "CLI", creditsUsed: 4),
+                        OpenAIDashboardServiceUsage(service: "Skillusage:pdf Renderer", creditsUsed: 6),
+                    ],
+                    totalCreditsUsed: 10),
+            ],
+            creditsPurchaseURL: nil,
+            updatedAt: Date(timeIntervalSince1970: 1_700_000_000))
+
+        #expect(snapshot.usageBreakdown == [
+            OpenAIDashboardDailyBreakdown(
+                day: "2026-04-30",
+                services: [
+                    OpenAIDashboardServiceUsage(service: "CLI", creditsUsed: 4),
+                ],
+                totalCreditsUsed: 4),
+        ])
+    }
+
+    @Test
+    func `snapshot decoder drops empty zero usage buckets`() throws {
+        let json = """
+        {
+          "signedInEmail": "codex@example.com",
+          "codeReviewRemainingPercent": null,
+          "creditEvents": [],
+          "dailyBreakdown": [],
+          "usageBreakdown": [
+            { "day": "2026-04-30", "services": [], "totalCreditsUsed": 0 },
+            { "day": "2026-04-29", "services": [], "totalCreditsUsed": 4 }
+          ],
+          "creditsPurchaseURL": null,
+          "updatedAt": "2026-04-30T19:27:07Z"
+        }
+        """
+        let decoder = JSONDecoder()
+        decoder.dateDecodingStrategy = .iso8601
+
+        let snapshot = try decoder.decode(OpenAIDashboardSnapshot.self, from: Data(json.utf8))
+
+        #expect(snapshot.usageBreakdown == [
+            OpenAIDashboardDailyBreakdown(
+                day: "2026-04-29",
+                services: [],
+                totalCreditsUsed: 4),
+        ])
+    }
+}
diff --git a/Tests/CodexBarTests/OpenAIDashboardNavigationDelegateTests.swift b/Tests/CodexBarTests/OpenAIDashboardNavigationDelegateTests.swift
index c1045f5dad..37db0483a6 100644
--- a/Tests/CodexBarTests/OpenAIDashboardNavigationDelegateTests.swift
+++ b/Tests/CodexBarTests/OpenAIDashboardNavigationDelegateTests.swift
@@ -3,23 +3,46 @@ import Testing
 import WebKit
 @testable import CodexBarCore
 
-@Suite
+@Suite(.serialized)
 struct OpenAIDashboardNavigationDelegateTests {
-    @Test("ignores NSURLErrorCancelled")
-    func ignoresCancelledNavigationError() {
+    final class DelegateBox: @unchecked Sendable {
+        var delegate: NavigationDelegate?
+    }
+
+    @MainActor
+    private func waitForResult(
+        _ result: @escaping () -> Result<Void, Error>?,
+        timeout: TimeInterval = NavigationDelegate.postCommitSuccessDelay + 10.0) async -> Result<Void, Error>?
+    {
+        let deadline = Date().addingTimeInterval(timeout)
+        while Date() < deadline {
+            if let result = result() { return result }
+            try? await Task.sleep(nanoseconds: 50_000_000)
+        }
+        return result()
+    }
+
+    @Test
+    func `ignores NSURLErrorCancelled`() {
         let error = NSError(domain: NSURLErrorDomain, code: NSURLErrorCancelled)
         #expect(NavigationDelegate.shouldIgnoreNavigationError(error))
     }
 
-    @Test("does not ignore non-cancelled URL errors")
-    func doesNotIgnoreOtherURLErrors() {
+    @Test
+    func `ignores WebKit frame load interrupted by policy change`() {
+        let error = NSError(domain: "WebKitErrorDomain", code: 102)
+        #expect(NavigationDelegate.shouldIgnoreNavigationError(error))
+    }
+
+    @Test
+    func `does not ignore non-cancelled URL errors`() {
         let error = NSError(domain: NSURLErrorDomain, code: NSURLErrorTimedOut)
         #expect(!NavigationDelegate.shouldIgnoreNavigationError(error))
     }
 
     @MainActor
-    @Test("cancelled failure is ignored until finish")
-    func cancelledFailureIsIgnoredUntilFinish() {
+    @Test
+    func `cancelled failure is ignored until finish`() {
         let webView = WKWebView()
         var result: Result<Void, Error>?
         let delegate = NavigationDelegate { result = $0 }
@@ -37,8 +60,70 @@ struct OpenAIDashboardNavigationDelegateTests {
     }
 
     @MainActor
-    @Test("cancelled provisional failure is ignored until real failure")
-    func cancelledProvisionalFailureIsIgnoredUntilRealFailure() {
+    @Test
+    func `explicit cancel completes with cancellation error`() {
+        var result: Result<Void, Error>?
+        let delegate = NavigationDelegate { result = $0 }
+
+        delegate.cancel()
+
+        switch result {
+        case let .failure(error)?:
+            #expect(error is CancellationError)
+        default:
+            #expect(Bool(false))
+        }
+    }
+
+    @MainActor
+    @Test
+    func `commit completes navigation successfully after grace period`() async {
+        let webView = WKWebView()
+        var result: Result<Void, Error>?
+        let box = DelegateBox()
+        box.delegate = NavigationDelegate { result = $0 }
+
+        box.delegate?.webView(webView, didCommit: nil)
+        #expect(result == nil)
+
+        let completed = await self.waitForResult { result }
+        box.delegate = nil
+
+        switch completed {
+        case .success?:
+            #expect(Bool(true))
+        default:
+            #expect(Bool(false))
+        }
+    }
+
+    @MainActor
+    @Test
+    func `post commit failure wins before delayed success`() async {
+        let webView = WKWebView()
+        var result: Result<Void, Error>?
+        let box = DelegateBox()
+        box.delegate = NavigationDelegate { result = $0 }
+
+        box.delegate?.webView(webView, didCommit: nil)
+        let timeout = NSError(domain: NSURLErrorDomain, code: NSURLErrorTimedOut)
+        box.delegate?.webView(webView, didFail: nil, withError: timeout)
+
+        let completed = await self.waitForResult { result }
+        box.delegate = nil
+
+        switch completed {
+        case let .failure(error as NSError)?:
+            #expect(error.domain == NSURLErrorDomain)
+            #expect(error.code == NSURLErrorTimedOut)
+        default:
+            #expect(Bool(false))
+        }
+    }
+
+    @MainActor
+    @Test
+    func `cancelled provisional failure is ignored until real failure`() {
         let webView = WKWebView()
         var result: Result<Void, Error>?
         let delegate = NavigationDelegate { result = $0 }
@@ -62,16 +147,43 @@ struct OpenAIDashboardNavigationDelegateTests {
     }
 
     @MainActor
-    @Test("navigation timeout fails with timed out error")
-    func navigationTimeoutFailsWithTimedOutError() async {
+    @Test
+    func `frame load interrupted provisional failure is ignored until finish`() {
+        let webView = WKWebView()
         var result: Result<Void, Error>?
         let delegate = NavigationDelegate { result = $0 }
 
-        delegate.armTimeout(seconds: 0.01)
-        try? await Task.sleep(for: .milliseconds(30))
+        delegate.webView(
+            webView,
+            didFailProvisionalNavigation: nil,
+            withError: NSError(domain: "WebKitErrorDomain", code: 102))
+        #expect(result == nil)
+
+        delegate.webView(webView, didFinish: nil)
+
+        switch result {
+        case .success?:
+            #expect(Bool(true))
+        default:
+            #expect(Bool(false))
+        }
+    }
+
+    @Test
+    func `navigation timeout fails with timed out error`() async {
+        let result = await withCheckedContinuation { (continuation: CheckedContinuation<Result<Void, Error>, Never>) in
+            Task { @MainActor in
+                let box = DelegateBox()
+                box.delegate = NavigationDelegate { result in
+                    continuation.resume(returning: result)
+                    box.delegate = nil
+                }
+                box.delegate?.armTimeout(seconds: 0.01)
+            }
+        }
 
         switch result {
-        case let .failure(error as URLError)?:
+        case let .failure(error as URLError):
             #expect(error.code == .timedOut)
         default:
             #expect(Bool(false))
diff --git a/Tests/CodexBarTests/OpenAIDashboardOffscreenHostTests.swift b/Tests/CodexBarTests/OpenAIDashboardOffscreenHostTests.swift
index 74d1de6a67..b39e5a5716 100644
--- a/Tests/CodexBarTests/OpenAIDashboardOffscreenHostTests.swift
+++ b/Tests/CodexBarTests/OpenAIDashboardOffscreenHostTests.swift
@@ -2,10 +2,9 @@ import Foundation
 import Testing
 @testable import CodexBarCore
 
-@Suite
 struct OpenAIDashboardOffscreenHostTests {
     @Test
-    func offscreenHostFrameOnlyIntersectsByASliver() {
+    func `offscreen host frame only intersects by A sliver`() {
         let visibleFrame = CGRect(x: 0, y: 0, width: 1000, height: 800)
         let frame = OpenAIDashboardFetcher.offscreenHostWindowFrame(for: visibleFrame)
         let intersection = frame.intersection(visibleFrame)
@@ -19,7 +18,7 @@ struct OpenAIDashboardOffscreenHostTests {
     }
 
     @Test
-    func offscreenHostAlphaValueIsNonZeroButTiny() {
+    func `offscreen host alpha value is non zero but tiny`() {
         let alpha = OpenAIDashboardFetcher.offscreenHostAlphaValue()
         #expect(alpha > 0)
         #expect(alpha <= 0.001)
diff --git a/Tests/CodexBarTests/OpenAIDashboardParserTests.swift b/Tests/CodexBarTests/OpenAIDashboardParserTests.swift
index c84391dfbf..acb41ae822 100644
--- a/Tests/CodexBarTests/OpenAIDashboardParserTests.swift
+++ b/Tests/CodexBarTests/OpenAIDashboardParserTests.swift
@@ -3,10 +3,9 @@ import Foundation
 import Testing
 @testable import CodexBar
 
-@Suite
 struct OpenAIDashboardParserTests {
     @Test
-    func parsesSignedInEmailFromClientBootstrapHTML() {
+    func `parses signed in email from client bootstrap HTML`() {
         let html = """
         <html>
         <head></head>
@@ -22,26 +21,52 @@ struct OpenAIDashboardParserTests {
     }
 
     @Test
-    func parsesCodeReviewRemainingPercent_inline() {
+    func `parses code review remaining percent inline`() {
         let body = "Balance\nCode review 42% remaining\nCredits remaining 291"
         #expect(OpenAIDashboardParser.parseCodeReviewRemainingPercent(bodyText: body) == 42)
     }
 
     @Test
-    func parsesCodeReviewRemainingPercent_multiline() {
+    func `parses code review remaining percent multiline`() {
         let body = "Balance\nCode review\n100% remaining\nWeekly usage limit\n0% remaining"
         #expect(OpenAIDashboardParser.parseCodeReviewRemainingPercent(bodyText: body) == 100)
     }
 
     @Test
-    func parsesCreditsRemaining() {
+    func `parses code review limit with reset`() {
+        let body = """
+        Balance
+        Code review
+        42% remaining
+        Resets tomorrow at 2:15 PM
+        """
+        let limit = OpenAIDashboardParser.parseCodeReviewLimit(bodyText: body)
+        #expect(abs((limit?.usedPercent ?? 0) - 58) < 0.001)
+        #expect(limit?.resetDescription?.lowercased().contains("resets") == true)
+    }
+
+    @Test
+    func `parses core review limit with reset`() {
+        let body = """
+        Balance
+        Core review
+        42% remaining
+        Resets tomorrow at 2:15 PM
+        """
+        let limit = OpenAIDashboardParser.parseCodeReviewLimit(bodyText: body)
+        #expect(abs((limit?.usedPercent ?? 0) - 58) < 0.001)
+        #expect(limit?.resetDescription?.lowercased().contains("resets") == true)
+    }
+
+    @Test
+    func `parses credits remaining`() {
         let body = "Balance\nCredits remaining 1,234.56\nUsage"
         let value = OpenAIDashboardParser.parseCreditsRemaining(bodyText: body)
         #expect(abs((value ?? 0) - 1234.56) < 0.001)
     }
 
     @Test
-    func parsesRateLimits() {
+    func `parses rate limits`() {
         let body = """
         Usage limits
         5h limit
@@ -60,7 +85,18 @@ struct OpenAIDashboardParserTests {
     }
 
     @Test
-    func parsesPlanFromClientBootstrap() {
+    func `parses spaced five hour limit label`() {
+        let body = """
+        Limite 5 h
+        72 % restant
+        """
+        let limits = OpenAIDashboardParser.parseRateLimits(bodyText: body)
+        #expect(abs((limits.primary?.usedPercent ?? 0) - 28) < 0.001)
+        #expect(limits.primary?.windowMinutes == 300)
+    }
+
+    @Test
+    func `parses plan from client bootstrap`() {
         let html = """
         <html>
         <body>
@@ -74,7 +110,21 @@ struct OpenAIDashboardParserTests {
     }
 
     @Test
-    func parsesCreditEventsFromTableRows() {
+    func `parses prolite plan from client bootstrap`() {
+        let html = """
+        <html>
+        <body>
+        <script type="application/json" id="client-bootstrap">
+        {"session":{"user":{"email":"user@example.com"}},"planType":"prolite"}
+        </script>
+        </body>
+        </html>
+        """
+        #expect(OpenAIDashboardParser.parsePlanFromHTML(html: html) == "Pro 5x")
+    }
+
+    @Test
+    func `parses credit events from table rows`() {
         let rows: [[String]] = [
             ["Dec 18, 2025", "CLI", "397.205 credits"],
             ["Dec 17, 2025", "GitHub Code Review", "506.235 credits"],
@@ -88,7 +138,27 @@ struct OpenAIDashboardParserTests {
     }
 
     @Test
-    func buildsDailyBreakdownFromEvents() throws {
+    func `parses credit event amount with localized credit label`() {
+        let rows: [[String]] = [
+            ["Dec 18, 2025", "CLI", "397,205 crédits"],
+        ]
+        let events = OpenAIDashboardParser.parseCreditEvents(rows: rows)
+        #expect(events.count == 1)
+        #expect(abs((events.first?.creditsUsed ?? 0) - 397.205) < 0.0001)
+    }
+
+    @Test
+    func `parses credit event amount with english comma thousands`() {
+        let rows: [[String]] = [
+            ["Dec 18, 2025", "CLI", "1,234 credits"],
+        ]
+        let events = OpenAIDashboardParser.parseCreditEvents(rows: rows)
+        #expect(events.count == 1)
+        #expect(events.first?.creditsUsed == 1234)
+    }
+
+    @Test
+    func `builds daily breakdown from events`() throws {
         let calendar = Calendar(identifier: .gregorian)
         var components = DateComponents()
         components.calendar = calendar
@@ -116,7 +186,7 @@ struct OpenAIDashboardParserTests {
     }
 
     @Test
-    func decodesSnapshotWithoutUsageBreakdownField() throws {
+    func `decodes snapshot without usage breakdown field`() throws {
         let json = """
         {
           "signedInEmail": "user@example.com",
@@ -131,4 +201,50 @@ struct OpenAIDashboardParserTests {
         let snapshot = try decoder.decode(OpenAIDashboardSnapshot.self, from: Data(json.utf8))
         #expect(snapshot.usageBreakdown.isEmpty)
     }
+
+    @Test
+    func `weekly only dashboard usage projects into secondary slot`() {
+        let snapshot = OpenAIDashboardSnapshot(
+            signedInEmail: "user@example.com",
+            codeReviewRemainingPercent: nil,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            primaryLimit: RateWindow(
+                usedPercent: 25,
+                windowMinutes: 10080,
+                resetsAt: nil,
+                resetDescription: nil),
+            secondaryLimit: nil,
+            creditsRemaining: nil,
+            accountPlan: "pro",
+            updatedAt: Date(timeIntervalSince1970: 1_700_000_000))
+
+        let usage = snapshot.toUsageSnapshot(provider: .codex)
+
+        #expect(usage?.primary == nil)
+        #expect(usage?.secondary?.usedPercent == 25)
+        #expect(usage?.secondary?.windowMinutes == 10080)
+        #expect(usage?.identity?.providerID == .codex)
+        #expect(usage?.identity?.accountEmail == "user@example.com")
+    }
+
+    @Test
+    func `dashboard usage projection returns nil when all limits are absent`() {
+        let snapshot = OpenAIDashboardSnapshot(
+            signedInEmail: "user@example.com",
+            codeReviewRemainingPercent: nil,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            primaryLimit: nil,
+            secondaryLimit: nil,
+            creditsRemaining: nil,
+            accountPlan: "pro",
+            updatedAt: Date(timeIntervalSince1970: 1_700_000_000))
+
+        #expect(snapshot.toUsageSnapshot(provider: .codex) == nil)
+    }
 }
diff --git a/Tests/CodexBarTests/OpenAIDashboardScrapeScriptTests.swift b/Tests/CodexBarTests/OpenAIDashboardScrapeScriptTests.swift
new file mode 100644
index 0000000000..56901c24b7
--- /dev/null
+++ b/Tests/CodexBarTests/OpenAIDashboardScrapeScriptTests.swift
@@ -0,0 +1,236 @@
+#if os(macOS)
+import Foundation
+import Testing
+import WebKit
+@testable import CodexBarCore
+
+@MainActor
+@Suite(.serialized)
+struct OpenAIDashboardScrapeScriptTests {
+    @Test
+    func `scraper returns structured account fields without full html`() async throws {
+        if Self.shouldSkipOnCI() { return }
+
+        let webView = WKWebView(frame: .zero, configuration: WKWebViewConfiguration())
+        _ = webView.loadHTMLString(Self.bootstrapAccountHTML, baseURL: nil)
+        try await Self.waitForFixture(webView, elementID: "account-fixture")
+
+        let any = try await webView.evaluateJavaScript(openAIDashboardScrapeScript)
+        let dict = try #require(any as? [String: Any])
+
+        #expect(dict["bodyHTML"] == nil)
+        #expect(dict["signedInEmail"] as? String == "user@example.com")
+        #expect(dict["authStatus"] as? String == "logged_in")
+        #expect(dict["accountPlan"] as? String == "Pro 5x")
+    }
+
+    @Test
+    func `usage breakdown scraper ignores neighboring client charts`() async throws {
+        if Self.shouldSkipOnCI() { return }
+
+        let webView = WKWebView(frame: .zero, configuration: WKWebViewConfiguration())
+        _ = webView.loadHTMLString(Self.multiChartHTML, baseURL: nil)
+        try await Self.waitForFixture(webView)
+
+        let any = try await webView.evaluateJavaScript(openAIDashboardScrapeScript)
+        let dict = try #require(any as? [String: Any])
+        let debug = dict["usageBreakdownDebug"] as? String
+        let raw = try #require(dict["usageBreakdownJSON"] as? String, "debug: \(debug ?? "nil")")
+        let decoded = try JSONDecoder().decode([OpenAIDashboardDailyBreakdown].self, from: Data(raw.utf8))
+
+        #expect(decoded.count == 1)
+        #expect(decoded.first?.day == "2026-05-01")
+        #expect(decoded.first?.totalCreditsUsed == 30)
+        #expect((decoded.first?.services.map(\.service) ?? []) == ["Desktop", "CLI"])
+    }
+
+    @Test
+    func `usage breakdown scraper reports wrong chart instead of accepting it`() async throws {
+        if Self.shouldSkipOnCI() { return }
+
+        let webView = WKWebView(frame: .zero, configuration: WKWebViewConfiguration())
+        _ = webView.loadHTMLString(Self.clientOnlyChartHTML, baseURL: nil)
+        try await Self.waitForFixture(webView, elementID: "client-chart")
+
+        let any = try await webView.evaluateJavaScript(openAIDashboardScrapeScript)
+        let dict = try #require(any as? [String: Any])
+
+        #expect((dict["usageBreakdownJSON"] as? String) == nil)
+        #expect((dict["usageBreakdownError"] as? String)?.contains("Threads and turns by client") == true)
+    }
+
+    @Test
+    func `usage breakdown scraper rejects non english chart titles`() async throws {
+        if Self.shouldSkipOnCI() { return }
+
+        let webView = WKWebView(frame: .zero, configuration: WKWebViewConfiguration())
+        _ = webView.loadHTMLString(Self.localizedUsageChartHTML, baseURL: nil)
+        try await Self.waitForFixture(webView)
+
+        let any = try await webView.evaluateJavaScript(openAIDashboardScrapeScript)
+        let dict = try #require(any as? [String: Any])
+
+        #expect((dict["usageBreakdownJSON"] as? String) == nil)
+        #expect(
+            (dict["usageBreakdownError"] as? String)?
+                .contains("No English usage breakdown chart title found") == true)
+    }
+
+    private static func shouldSkipOnCI() -> Bool {
+        let env = ProcessInfo.processInfo.environment
+        return env["GITHUB_ACTIONS"] == "true" || env["CI"] == "true"
+    }
+
+    private static func waitForFixture(_ webView: WKWebView, elementID: String = "usage-chart") async throws {
+        let deadline = Date().addingTimeInterval(2)
+        while Date() < deadline {
+            let loaded = try? await webView.evaluateJavaScript(
+                "document.getElementById('\(elementID)') !== null") as? Bool
+            if loaded == true { return }
+            try await Task.sleep(for: .milliseconds(50))
+        }
+    }
+
+    private static let bootstrapAccountHTML = """
+    <html>
+    <body>
+      <div id="account-fixture">Usage limits</div>
+      <script type="application/json" id="__NEXT_DATA__">
+      {
+        "props": {
+          "pageProps": {
+            "user": {
+              "email": "next@example.com"
+            }
+          }
+        },
+        "planType": "pro"
+      }
+      </script>
+      <script type="application/json" id="client-bootstrap">
+      {
+        "authStatus": "logged_in",
+        "session": {
+          "user": {
+            "email": "user@example.com"
+          }
+        },
+        "subscription": {
+          "tier": "Codex Pro Lite"
+        }
+      }
+      </script>
+    </body>
+    </html>
+    """
+
+    private static let multiChartHTML = """
+    <html>
+    <body>
+      <section>
+        <h2>Usage breakdown</h2>
+        <div>
+          <h3>Personal usage</h3>
+        </div>
+        <span>Daily threads by client</span>
+        <svg class="recharts-surface">
+          <g class="recharts-bar-rectangle">
+            <path id="usage-chart" class="recharts-rectangle" d="M0 0H10V10Z"></path>
+          </g>
+        </svg>
+      </section>
+      <section>
+        <h2>Product activity</h2>
+        <button type="button">1,000 threads</button>
+        <button type="button">2,000 turns</button>
+        <span>Daily threads by client</span>
+        <svg class="recharts-surface">
+          <g class="recharts-bar-rectangle">
+            <path id="client-chart" class="recharts-rectangle" d="M0 0H10V10Z"></path>
+          </g>
+        </svg>
+      </section>
+      <section>
+        <h2>Tokens by model</h2>
+        <svg class="recharts-surface">
+          <g class="recharts-bar-rectangle">
+            <path id="model-chart" class="recharts-rectangle" d="M0 0H10V10Z"></path>
+          </g>
+        </svg>
+      </section>
+      <script>
+        document.getElementById('client-chart')['__reactProps$test'] = {
+          dataKey: 'values',
+          payload: {
+            day: '2026-05-01',
+            values: { cli: 1000, desktop: 2000 }
+          }
+        };
+        document.getElementById('usage-chart')['__reactProps$test'] = {
+          dataKey: 'values',
+          payload: {
+            day: '2026-05-01',
+            values: { cli: 10, desktop: 20 }
+          }
+        };
+        document.getElementById('model-chart')['__reactProps$test'] = {
+          dataKey: 'values',
+          payload: {
+            day: '2026-05-01',
+            values: { cli: 1000, desktop: 2000, vscode: 3000 }
+          }
+        };
+      </script>
+    </body>
+    </html>
+    """
+
+    private static let clientOnlyChartHTML = """
+    <html>
+    <body>
+      <section>
+        <h2>Threads and turns by client</h2>
+        <svg class="recharts-surface">
+          <g class="recharts-bar-rectangle">
+            <path id="client-chart" class="recharts-rectangle" d="M0 0H10V10Z"></path>
+          </g>
+        </svg>
+      </section>
+      <script>
+        document.getElementById('client-chart')['__reactProps$test'] = {
+          dataKey: 'values',
+          payload: {
+            day: '2026-05-01',
+            values: { cli: 1000, desktop: 2000 }
+          }
+        };
+      </script>
+    </body>
+    </html>
+    """
+
+    private static let localizedUsageChartHTML = """
+    <html>
+    <body>
+      <section>
+        <h2>Desglose de uso</h2>
+        <svg class="recharts-surface">
+          <g class="recharts-bar-rectangle">
+            <path id="usage-chart" class="recharts-rectangle" d="M0 0H10V10Z"></path>
+          </g>
+        </svg>
+      </section>
+      <script>
+        document.getElementById('usage-chart')['__reactProps$test'] = {
+          dataKey: 'values',
+          payload: {
+            day: '2026-05-01',
+            values: { cli: 10, desktop: 20 }
+          }
+        };
+      </script>
+    </body>
+    </html>
+    """
+}
+#endif
diff --git a/Tests/CodexBarTests/OpenAIDashboardSparkTests.swift b/Tests/CodexBarTests/OpenAIDashboardSparkTests.swift
new file mode 100644
index 0000000000..45ad343f8b
--- /dev/null
+++ b/Tests/CodexBarTests/OpenAIDashboardSparkTests.swift
@@ -0,0 +1,232 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+/// Dashboard-path coverage for Codex `additional_rate_limits` (e.g. GPT-5.3-Codex-Spark): the
+/// OpenAI web dashboard usage API decodes the same `wham/usage` JSON as the OAuth path, so Spark
+/// limits must survive the `dashboardAPIData -> DashboardSnapshotComponents -> OpenAIDashboardSnapshot
+/// -> fromAttachedDashboard -> UsageSnapshot.extraRateWindows` chain without disturbing the
+/// existing primary/weekly/credits/plan mapping.
+struct OpenAIDashboardSparkTests {
+    private static func response(from json: String) throws -> CodexUsageResponse {
+        try JSONDecoder().decode(CodexUsageResponse.self, from: Data(json.utf8))
+    }
+
+    @Test
+    func `dashboard api data maps additional spark limit into extra windows`() throws {
+        let json = """
+        {
+          "plan_type": "pro",
+          "rate_limit": {
+            "primary_window": { "used_percent": 22, "reset_at": 1766948068, "limit_window_seconds": 18000 },
+            "secondary_window": { "used_percent": 43, "reset_at": 1767407914, "limit_window_seconds": 604800 }
+          },
+          "additional_rate_limits": [
+            {
+              "limit_name": "GPT-5.3-Codex-Spark",
+              "metered_feature": "gpt_5_3_codex_spark",
+              "rate_limit": {
+                "primary_window": { "used_percent": 30, "reset_at": 1766948068, "limit_window_seconds": 18000 },
+                "secondary_window": { "used_percent": 100, "reset_at": 1767407914, "limit_window_seconds": 604800 }
+              }
+            }
+          ]
+        }
+        """
+        let response = try Self.response(from: json)
+        let apiData = OpenAIDashboardFetcher.dashboardAPIData(from: response)
+        // Primary/weekly/credits/plan continue to map exactly as before.
+        #expect(apiData.primaryLimit?.usedPercent == 22)
+        #expect(apiData.secondaryLimit?.usedPercent == 43)
+        #expect(apiData.accountPlan == "pro")
+        // Spark surfaces with stable ids/titles for the additional 5-hour and weekly windows.
+        #expect(apiData.extraRateWindows.count == 2)
+        let spark = try #require(apiData.extraRateWindows.first)
+        #expect(spark.id == "codex-spark")
+        #expect(spark.title == "Codex Spark 5-hour")
+        #expect(spark.window.usedPercent == 30)
+        #expect(spark.window.windowMinutes == 300)
+        #expect(spark.window.resetsAt != nil)
+        let weekly = try #require(apiData.extraRateWindows.last)
+        #expect(weekly.id == "codex-spark-weekly")
+        #expect(weekly.title == "Codex Spark Weekly")
+        #expect(weekly.window.usedPercent == 100)
+        #expect(weekly.window.windowMinutes == 10080)
+        #expect(weekly.window.resetsAt != nil)
+    }
+
+    @Test
+    func `dashboard api data has empty extra windows when additional limits are absent`() throws {
+        let json = """
+        {
+          "rate_limit": {
+            "primary_window": { "used_percent": 22, "reset_at": 1766948068, "limit_window_seconds": 18000 }
+          }
+        }
+        """
+        let response = try Self.response(from: json)
+        let apiData = OpenAIDashboardFetcher.dashboardAPIData(from: response)
+        #expect(apiData.primaryLimit?.usedPercent == 22)
+        #expect(apiData.extraRateWindows.isEmpty)
+    }
+
+    @Test
+    func `dashboard api data tolerates non array additional limits while keeping primary`() throws {
+        let json = """
+        {
+          "rate_limit": {
+            "primary_window": { "used_percent": 22, "reset_at": 1766948068, "limit_window_seconds": 18000 }
+          },
+          "additional_rate_limits": "unexpected"
+        }
+        """
+        let response = try Self.response(from: json)
+        let apiData = OpenAIDashboardFetcher.dashboardAPIData(from: response)
+        #expect(apiData.primaryLimit?.usedPercent == 22)
+        #expect(apiData.extraRateWindows.isEmpty)
+    }
+
+    @Test
+    func `dashboard api data keeps valid spark when a malformed sibling is present`() throws {
+        // Lossy per-element decode (shared with the OAuth path via CodexUsageResponse) means a single
+        // malformed entry cannot discard its valid siblings.
+        let json = """
+        {
+          "rate_limit": {
+            "primary_window": { "used_percent": 22, "reset_at": 1766948068, "limit_window_seconds": 18000 }
+          },
+          "additional_rate_limits": [
+            "garbage-not-an-object",
+            {
+              "limit_name": "GPT-5.3-Codex-Spark",
+              "metered_feature": "gpt_5_3_codex_spark",
+              "rate_limit": {
+                "primary_window": { "used_percent": 30, "reset_at": 1766948068, "limit_window_seconds": 18000 }
+              }
+            },
+            42
+          ]
+        }
+        """
+        let response = try Self.response(from: json)
+        let apiData = OpenAIDashboardFetcher.dashboardAPIData(from: response)
+        #expect(apiData.primaryLimit?.usedPercent == 22)
+        #expect(apiData.extraRateWindows.count == 1)
+        #expect(apiData.extraRateWindows.first?.id == "codex-spark")
+        #expect(apiData.extraRateWindows.first?.window.usedPercent == 30)
+    }
+
+    @Test
+    func `dashboard snapshot exposes extra rate windows via to usage snapshot`() throws {
+        let now = Date(timeIntervalSince1970: 1_766_948_000)
+        let snapshot = OpenAIDashboardSnapshot(
+            signedInEmail: "codex@example.com",
+            codeReviewRemainingPercent: nil,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            primaryLimit: RateWindow(
+                usedPercent: 22,
+                windowMinutes: 300,
+                resetsAt: now.addingTimeInterval(3600),
+                resetDescription: nil),
+            secondaryLimit: RateWindow(
+                usedPercent: 43,
+                windowMinutes: 10080,
+                resetsAt: now.addingTimeInterval(6 * 24 * 60 * 60),
+                resetDescription: nil),
+            extraRateWindows: [
+                NamedRateWindow(
+                    id: "codex-spark",
+                    title: "Codex Spark 5-hour",
+                    window: RateWindow(
+                        usedPercent: 30,
+                        windowMinutes: 300,
+                        resetsAt: now.addingTimeInterval(60 * 60),
+                        resetDescription: nil)),
+                NamedRateWindow(
+                    id: "codex-spark-weekly",
+                    title: "Codex Spark Weekly",
+                    window: RateWindow(
+                        usedPercent: 100,
+                        windowMinutes: 10080,
+                        resetsAt: now.addingTimeInterval(6 * 24 * 60 * 60),
+                        resetDescription: nil)),
+            ],
+            updatedAt: now)
+
+        let usage = try #require(snapshot.toUsageSnapshot(provider: .codex))
+        // Primary/weekly behavior preserved.
+        #expect(usage.primary?.usedPercent == 22)
+        #expect(usage.secondary?.usedPercent == 43)
+        // Spark surfaces through UsageSnapshot.extraRateWindows for dashboard-source users.
+        let extras = try #require(usage.extraRateWindows)
+        #expect(extras.map(\.id) == ["codex-spark", "codex-spark-weekly"])
+        #expect(extras.first?.window.usedPercent == 30)
+        #expect(extras.last?.window.usedPercent == 100)
+    }
+
+    @Test
+    func `dashboard snapshot codable round trips extra rate windows`() throws {
+        let now = Date(timeIntervalSince1970: 1_766_948_000)
+        let snapshot = OpenAIDashboardSnapshot(
+            signedInEmail: nil,
+            codeReviewRemainingPercent: nil,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            extraRateWindows: [
+                NamedRateWindow(
+                    id: "codex-spark",
+                    title: "Codex Spark 5-hour",
+                    window: RateWindow(
+                        usedPercent: 30,
+                        windowMinutes: 300,
+                        resetsAt: now.addingTimeInterval(60 * 60),
+                        resetDescription: nil)),
+                NamedRateWindow(
+                    id: "codex-spark-weekly",
+                    title: "Codex Spark Weekly",
+                    window: RateWindow(
+                        usedPercent: 100,
+                        windowMinutes: 10080,
+                        resetsAt: now.addingTimeInterval(6 * 24 * 60 * 60),
+                        resetDescription: nil)),
+            ],
+            updatedAt: now)
+
+        let encoder = JSONEncoder()
+        encoder.dateEncodingStrategy = .iso8601
+        let decoder = JSONDecoder()
+        decoder.dateDecodingStrategy = .iso8601
+
+        let data = try encoder.encode(snapshot)
+        let decoded = try decoder.decode(OpenAIDashboardSnapshot.self, from: data)
+        #expect(decoded.extraRateWindows?.map(\.id) == ["codex-spark", "codex-spark-weekly"])
+        #expect(decoded.extraRateWindows?.first?.window.usedPercent == 30)
+        #expect(decoded.extraRateWindows?.last?.window.usedPercent == 100)
+    }
+
+    @Test
+    func `dashboard snapshot decoder preserves absence of extra rate windows`() throws {
+        // Older cached snapshots predate the field; decoding such payloads must yield nil and never
+        // throw, so existing dashboard caches keep working.
+        let json = """
+        {
+          "signedInEmail": "codex@example.com",
+          "codeReviewRemainingPercent": null,
+          "creditEvents": [],
+          "dailyBreakdown": [],
+          "usageBreakdown": [],
+          "creditsPurchaseURL": null,
+          "updatedAt": "2026-04-30T19:27:07Z"
+        }
+        """
+        let decoder = JSONDecoder()
+        decoder.dateDecodingStrategy = .iso8601
+        let snapshot = try decoder.decode(OpenAIDashboardSnapshot.self, from: Data(json.utf8))
+        #expect(snapshot.extraRateWindows == nil)
+    }
+}
diff --git a/Tests/CodexBarTests/OpenAIDashboardWebViewCacheTests.swift b/Tests/CodexBarTests/OpenAIDashboardWebViewCacheTests.swift
index c53cb7394c..dce9826433 100644
--- a/Tests/CodexBarTests/OpenAIDashboardWebViewCacheTests.swift
+++ b/Tests/CodexBarTests/OpenAIDashboardWebViewCacheTests.swift
@@ -12,10 +12,44 @@ import WebKit
 @MainActor
 @Suite(.serialized)
 struct OpenAIDashboardWebViewCacheTests {
+    private func shouldSkipOnCI() -> Bool {
+        let env = ProcessInfo.processInfo.environment
+        return env["GITHUB_ACTIONS"] == "true" || env["CI"] == "true"
+    }
+
     // MARK: - Data Store Identity Tests
 
-    @Test("WKWebsiteDataStore should return same instance for same email")
-    func dataStoreReturnsSameInstance() {
+    @Test
+    func `navigation retry uses only remaining shared deadline`() throws {
+        let start = Date(timeIntervalSinceReferenceDate: 1000)
+        let deadline = start.addingTimeInterval(10)
+
+        let remaining = try OpenAIDashboardWebViewCache.remainingNavigationTimeout(
+            until: deadline,
+            now: start.addingTimeInterval(9.75))
+
+        #expect(remaining == 0.25)
+    }
+
+    @Test
+    func `navigation retry refuses expired shared deadline`() {
+        let deadline = Date(timeIntervalSinceReferenceDate: 1000)
+
+        do {
+            _ = try OpenAIDashboardWebViewCache.remainingNavigationTimeout(
+                until: deadline,
+                now: deadline)
+            Issue.record("Expected deadline timeout")
+        } catch let error as URLError {
+            #expect(error.code == .timedOut)
+        } catch {
+            Issue.record("Unexpected error: \(error)")
+        }
+    }
+
+    @Test
+    func `WKWebsiteDataStore should return same instance for same email`() {
+        if self.shouldSkipOnCI() { return }
         OpenAIDashboardWebsiteDataStore.clearCacheForTesting()
 
         let store1 = OpenAIDashboardWebsiteDataStore.store(forAccountEmail: "test@example.com")
@@ -32,10 +66,48 @@ struct OpenAIDashboardWebViewCacheTests {
         OpenAIDashboardWebsiteDataStore.clearCacheForTesting()
     }
 
+    @Test
+    func `same email profile homes use distinct website data stores`() {
+        OpenAIDashboardWebsiteDataStore.clearCacheForTesting()
+        defer { OpenAIDashboardWebsiteDataStore.clearCacheForTesting() }
+
+        let profileA = CookieHeaderCache.Scope.profileHome("/tmp/codex-profile-a")
+        let profileB = CookieHeaderCache.Scope.profileHome("/tmp/codex-profile-b")
+        let storeA = OpenAIDashboardWebsiteDataStore.store(
+            forAccountEmail: "shared@example.com",
+            scope: profileA)
+        let storeAAgain = OpenAIDashboardWebsiteDataStore.store(
+            forAccountEmail: "SHARED@example.com",
+            scope: profileA)
+        let storeB = OpenAIDashboardWebsiteDataStore.store(
+            forAccountEmail: "shared@example.com",
+            scope: profileB)
+        let liveStore = OpenAIDashboardWebsiteDataStore.store(forAccountEmail: "shared@example.com")
+
+        #expect(storeA === storeAAgain)
+        #expect(storeA !== storeB)
+        #expect(storeA !== liveStore)
+        #expect(storeB !== liveStore)
+        #expect(storeA.identifier != storeB.identifier)
+        #expect(storeA.identifier != liveStore.identifier)
+        #expect(storeB.identifier != liveStore.identifier)
+    }
+
+    @Test
+    func `live website data store preserves legacy email identifier`() {
+        OpenAIDashboardWebsiteDataStore.clearCacheForTesting()
+        defer { OpenAIDashboardWebsiteDataStore.clearCacheForTesting() }
+
+        let store = OpenAIDashboardWebsiteDataStore.store(forAccountEmail: " SHARED@EXAMPLE.COM ")
+
+        #expect(store.identifier?.uuidString == "CC61BD27-6855-439F-9D11-F470B7977B90")
+    }
+
     // MARK: - WebView Reuse Tests
 
-    @Test("WebView should be cached after release, not destroyed")
-    func webViewCachedAfterRelease() async throws {
+    @Test
+    func `WebView should be cached after release, not destroyed`() async throws {
+        if self.shouldSkipOnCI() { return }
         let cache = OpenAIDashboardWebViewCache()
         let store = WKWebsiteDataStore.nonPersistent()
         let url = try #require(URL(string: "about:blank"))
@@ -67,8 +139,9 @@ struct OpenAIDashboardWebViewCacheTests {
         cache.clearAllForTesting()
     }
 
-    @Test("Different data stores should have separate cached WebViews")
-    func separateCachesPerDataStore() async throws {
+    @Test
+    func `Different data stores should have separate cached WebViews`() async throws {
+        if self.shouldSkipOnCI() { return }
         let cache = OpenAIDashboardWebViewCache()
         let store1 = WKWebsiteDataStore.nonPersistent()
         let store2 = WKWebsiteDataStore.nonPersistent()
@@ -98,53 +171,206 @@ struct OpenAIDashboardWebViewCacheTests {
 
     // MARK: - Idle Timeout / Pruning Tests
 
-    @Test("WebView should be pruned after idle timeout")
-    func webViewPrunedAfterIdleTimeout() async throws {
+    @Test
+    func `WebView should be pruned after idle timeout`() {
+        if self.shouldSkipOnCI() { return }
+        let cache = OpenAIDashboardWebViewCache()
+        let store = WKWebsiteDataStore.nonPersistent()
+        cache.cacheEntryForTesting(websiteDataStore: store)
+
+        #expect(cache.hasCachedEntry(for: store), "Should be cached immediately after release")
+
+        // Simulate time passing beyond the configured idle timeout.
+        let futureTime = Date().addingTimeInterval(cache.idleTimeoutForTesting + 5)
+        cache.pruneForTesting(now: futureTime)
+
+        #expect(!cache.hasCachedEntry(for: store), "Should be pruned after idle timeout")
+        #expect(cache.entryCount == 0, "Should have no cached entries after prune")
+    }
+
+    @Test
+    func `Recently used WebView should not be pruned`() {
+        if self.shouldSkipOnCI() { return }
+        let cache = OpenAIDashboardWebViewCache()
+        let store = WKWebsiteDataStore.nonPersistent()
+        cache.cacheEntryForTesting(websiteDataStore: store)
+
+        // Simulate time passing comfortably within the configured idle timeout.
+        let nearFutureTime = Date().addingTimeInterval(max(1, cache.idleTimeoutForTesting / 2))
+        cache.pruneForTesting(now: nearFutureTime)
+
+        #expect(cache.hasCachedEntry(for: store), "Should still be cached within idle timeout")
+        cache.clearAllForTesting()
+    }
+
+    @Test
+    func `Preserved page handoff is consumed only once`() {
+        if self.shouldSkipOnCI() { return }
         let cache = OpenAIDashboardWebViewCache()
         let store = WKWebsiteDataStore.nonPersistent()
+        cache.cacheEntryForTesting(websiteDataStore: store)
+        cache.markPreservedPageForTesting(
+            websiteDataStore: store,
+            expiresAt: Date().addingTimeInterval(cache.preservedPageHandoffTimeoutForTesting))
+
+        #expect(cache.hasPreservedPageForTesting(for: store), "Expected preserved page handoff to be armed")
+        #expect(cache.consumePreservedPageForTesting(websiteDataStore: store), "First acquire should reuse handoff")
+        #expect(
+            !cache.consumePreservedPageForTesting(websiteDataStore: store),
+            "Second acquire should not keep reusing preserved page")
+
+        cache.clearAllForTesting()
+    }
+
+    @Test
+    func `Expired preserved page is cleared before idle eviction`() {
+        if self.shouldSkipOnCI() { return }
+        let cache = OpenAIDashboardWebViewCache()
+        let store = WKWebsiteDataStore.nonPersistent()
+        cache.cacheEntryForTesting(websiteDataStore: store)
+        cache.markPreservedPageForTesting(
+            websiteDataStore: store,
+            expiresAt: Date().addingTimeInterval(1))
+
+        let afterExpiry = Date().addingTimeInterval(cache.preservedPageHandoffTimeoutForTesting + 1)
+        cache.pruneForTesting(now: afterExpiry)
+
+        #expect(!cache.hasPreservedPageForTesting(for: store), "Expired preserved page should be cleared")
+        #expect(cache.hasCachedEntry(for: store), "Entry should remain cached after page handoff expires")
+
+        cache.clearAllForTesting()
+    }
+
+    @Test
+    func `Preserved page expiry is scheduled without future cache activity`() async throws {
+        if self.shouldSkipOnCI() { return }
+        let cache = OpenAIDashboardWebViewCache()
+        let store = WKWebsiteDataStore.nonPersistent()
+        let webView = cache.cacheEntryForTesting(websiteDataStore: store)
+
+        _ = webView.loadHTMLString("<html><body>alive</body></html>", baseURL: nil)
+        try? await Task.sleep(for: .milliseconds(150))
+
+        cache.markPreservedPageForTesting(
+            websiteDataStore: store,
+            expiresAt: Date().addingTimeInterval(0.2))
+
+        #expect(cache.hasPreservedPageForTesting(for: store), "Expected preserved page handoff to be armed")
+
+        var bodyText: String?
+        let deadline = Date().addingTimeInterval(2)
+        repeat {
+            try? await Task.sleep(for: .milliseconds(100))
+            bodyText = try await webView.evaluateJavaScript(
+                "document.body ? String(document.body.innerText || '') : ''") as? String
+        } while (cache.hasPreservedPageForTesting(for: store) || bodyText?.isEmpty != true) && Date() < deadline
+
+        #expect(!cache.hasPreservedPageForTesting(for: store), "Expected scheduled expiry to clear preserved page")
+        #expect(bodyText?.isEmpty == true, "Expected scheduled expiry to detach the preserved page to about:blank")
+
+        cache.clearAllForTesting()
+    }
+
+    @Test
+    func `Idle prune is scheduled without future cache activity`() async throws {
+        if self.shouldSkipOnCI() { return }
+        let cache = OpenAIDashboardWebViewCache(idleTimeout: 0.2)
+        let store = WKWebsiteDataStore.nonPersistent()
         let url = try #require(URL(string: "about:blank"))
 
-        // Acquire and release
-        let lease = try await cache.acquire(
+        var lease: OpenAIDashboardWebViewLease? = try await cache.acquire(
             websiteDataStore: store,
             usageURL: url,
             logger: nil)
-        lease.release()
+        lease?.release()
+        lease = nil
 
-        #expect(cache.hasCachedEntry(for: store), "Should be cached immediately after release")
+        #expect(cache.hasCachedEntry(for: store), "WebView should remain cached right after release")
 
-        // Simulate time passing beyond idle timeout (10 minutes + buffer)
-        let futureTime = Date().addingTimeInterval(11 * 60)
-        cache.pruneForTesting(now: futureTime)
+        let deadline = Date().addingTimeInterval(5)
+        while cache.hasCachedEntry(for: store), Date() < deadline {
+            try? await Task.sleep(for: .milliseconds(100))
+        }
 
-        #expect(!cache.hasCachedEntry(for: store), "Should be pruned after idle timeout")
-        #expect(cache.entryCount == 0, "Should have no cached entries after prune")
+        #expect(
+            !cache.hasCachedEntry(for: store),
+            "Expected the scheduled idle prune to evict the WebView without any further cache activity")
+
+        cache.clearAllForTesting()
     }
 
-    @Test("Recently used WebView should not be pruned")
-    func recentlyUsedWebViewNotPruned() async throws {
+    @Test
+    func `Later release does not postpone an older idle entry`() async throws {
+        if self.shouldSkipOnCI() { return }
+        let cache = OpenAIDashboardWebViewCache(idleTimeout: 5)
+        let firstStore = WKWebsiteDataStore.nonPersistent()
+        let secondStore = WKWebsiteDataStore.nonPersistent()
+        let url = try #require(URL(string: "about:blank"))
+
+        let firstLease = try await cache.acquire(
+            websiteDataStore: firstStore,
+            usageURL: url,
+            logger: nil)
+        firstLease.release()
+        let firstDeadline = try #require(cache.idlePruneDeadlineForTesting)
+
+        try await Task.sleep(for: .milliseconds(50))
+
+        let secondLease = try await cache.acquire(
+            websiteDataStore: secondStore,
+            usageURL: url,
+            logger: nil)
+        secondLease.release()
+        let rescheduledDeadline = try #require(cache.idlePruneDeadlineForTesting)
+
+        #expect(
+            abs(rescheduledDeadline.timeIntervalSince(firstDeadline)) < 0.001,
+            "A later release should keep the prune scheduled for the oldest idle entry")
+        #expect(cache.hasCachedEntry(for: firstStore))
+        #expect(cache.hasCachedEntry(for: secondStore), "A later release should keep its own idle window")
+        cache.clearAllForTesting()
+    }
+
+    @Test
+    func `Reused page reset clears one shot scraper globals`() async throws {
+        if self.shouldSkipOnCI() { return }
         let cache = OpenAIDashboardWebViewCache()
         let store = WKWebsiteDataStore.nonPersistent()
         let url = try #require(URL(string: "about:blank"))
 
-        // Acquire and release
         let lease = try await cache.acquire(
             websiteDataStore: store,
             usageURL: url,
             logger: nil)
-        lease.release()
 
-        // Simulate time passing within idle timeout (5 minutes)
-        let nearFutureTime = Date().addingTimeInterval(5 * 60)
-        cache.pruneForTesting(now: nearFutureTime)
+        _ = try await lease.webView.evaluateJavaScript(
+            """
+            window.__codexbarDidScrollToCredits = true;
+            window.__codexbarUsageBreakdownJSON = '[{"day":"2026-04-19"}]';
+            window.__codexbarUsageBreakdownDebug = 'debug';
+            true;
+            """)
 
-        #expect(cache.hasCachedEntry(for: store), "Should still be cached within idle timeout")
+        #expect(await cache.resetReusablePageStateForTesting(lease.webView))
+
+        let reset = try await lease.webView.evaluateJavaScript(
+            """
+            typeof window.__codexbarDidScrollToCredits === 'undefined' &&
+            typeof window.__codexbarUsageBreakdownJSON === 'undefined' &&
+            typeof window.__codexbarUsageBreakdownDebug === 'undefined'
+            """) as? Bool
+
+        #expect(reset == true, "Expected one-shot scraper globals to be cleared before reuse")
+
+        lease.release()
+        cache.clearAllForTesting()
     }
 
     // MARK: - Eviction Tests
 
-    @Test("Evict should remove specific WebView from cache")
-    func evictRemovesSpecificWebView() async throws {
+    @Test
+    func `Evict should remove specific WebView from cache`() async throws {
+        if self.shouldSkipOnCI() { return }
         let cache = OpenAIDashboardWebViewCache()
         let store1 = WKWebsiteDataStore.nonPersistent()
         let store2 = WKWebsiteDataStore.nonPersistent()
@@ -168,10 +394,113 @@ struct OpenAIDashboardWebViewCacheTests {
         cache.clearAllForTesting()
     }
 
+    @Test
+    func `Evicted WebView should not be reused on next acquire`() async throws {
+        if self.shouldSkipOnCI() { return }
+        let cache = OpenAIDashboardWebViewCache()
+        let store = WKWebsiteDataStore.nonPersistent()
+        let url = try #require(URL(string: "about:blank"))
+
+        let lease1 = try await cache.acquire(websiteDataStore: store, usageURL: url, logger: nil)
+        let webView1 = lease1.webView
+        lease1.release()
+
+        cache.evict(websiteDataStore: store)
+
+        let lease2 = try await cache.acquire(websiteDataStore: store, usageURL: url, logger: nil)
+        let webView2 = lease2.webView
+
+        #expect(webView1 !== webView2, "Acquire after eviction should create a fresh WebView")
+
+        lease2.release()
+        cache.clearAllForTesting()
+    }
+
+    @Test
+    func `Evict all should remove every cached WebView`() async throws {
+        if self.shouldSkipOnCI() { return }
+        let cache = OpenAIDashboardWebViewCache()
+        let store1 = WKWebsiteDataStore.nonPersistent()
+        let store2 = WKWebsiteDataStore.nonPersistent()
+        let url = try #require(URL(string: "about:blank"))
+
+        let lease1 = try await cache.acquire(websiteDataStore: store1, usageURL: url, logger: nil)
+        lease1.release()
+        let lease2 = try await cache.acquire(websiteDataStore: store2, usageURL: url, logger: nil)
+        lease2.release()
+
+        #expect(cache.entryCount == 2, "Should have two cached entries")
+
+        cache.evictAll()
+
+        #expect(cache.entryCount == 0, "Evict all should remove every cached entry")
+        #expect(!cache.hasCachedEntry(for: store1), "First store should be evicted")
+        #expect(!cache.hasCachedEntry(for: store2), "Second store should be evicted")
+    }
+
+    @Test
+    func `Evict idle removes idle WebViews without interrupting busy WebViews`() {
+        if self.shouldSkipOnCI() { return }
+        let cache = OpenAIDashboardWebViewCache()
+        let idleStore = WKWebsiteDataStore.nonPersistent()
+        let busyStore = WKWebsiteDataStore.nonPersistent()
+
+        cache.cacheEntryForTesting(websiteDataStore: idleStore)
+        cache.cacheEntryForTesting(websiteDataStore: busyStore, isBusy: true)
+
+        cache.evictIdle()
+
+        #expect(!cache.hasCachedEntry(for: idleStore), "Idle WebView should be evicted")
+        #expect(cache.hasCachedEntry(for: busyStore), "Busy WebView should remain cached")
+        #expect(cache.entryCount == 1, "Only the busy entry should remain")
+
+        cache.clearAllForTesting()
+    }
+
+    @Test
+    func `Memory pressure monitor evicts idle shared WebViews without interrupting busy WebViews`() {
+        if self.shouldSkipOnCI() { return }
+        let cache = OpenAIDashboardWebViewCache.shared
+        cache.clearAllForTesting()
+        defer { cache.clearAllForTesting() }
+
+        let idleStore = WKWebsiteDataStore.nonPersistent()
+        let busyStore = WKWebsiteDataStore.nonPersistent()
+
+        cache.cacheEntryForTesting(websiteDataStore: idleStore)
+        cache.cacheEntryForTesting(websiteDataStore: busyStore, isBusy: true)
+
+        #expect(cache.entryCount == 2, "Should have one idle entry and one busy entry before pressure")
+
+        let monitor = MemoryPressureMonitor()
+        monitor.handleMemoryPressureForTesting(isWarning: true, isCritical: false)
+
+        #expect(!cache.hasCachedEntry(for: idleStore), "Memory pressure should evict the idle shared WebView")
+        #expect(cache.hasCachedEntry(for: busyStore), "Memory pressure should not interrupt a busy shared WebView")
+        #expect(cache.entryCount == 1, "Only the busy shared entry should remain")
+    }
+
+    @Test
+    func `Memory pressure malloc relief runs off the main thread`() async {
+        let probe = MemoryPressureThreadProbe()
+        let monitor = MemoryPressureMonitor(releaseFreeMallocPages: {
+            probe.recordCurrentThread()
+        })
+
+        monitor.handleMemoryPressureForTesting(isWarning: true, isCritical: false)
+
+        let completed = await Task.detached {
+            probe.wait(timeout: .now() + 2)
+        }.value
+        #expect(completed)
+        #expect(probe.wasMainThread == false)
+    }
+
     // MARK: - Busy WebView Tests
 
-    @Test("Busy WebView should create temporary WebView for concurrent access")
-    func busyWebViewCreatesTemporary() async throws {
+    @Test
+    func `Busy WebView should create temporary WebView for concurrent access`() async throws {
+        if self.shouldSkipOnCI() { return }
         let cache = OpenAIDashboardWebViewCache()
         let store = WKWebsiteDataStore.nonPersistent()
         let url = try #require(URL(string: "about:blank"))
@@ -205,8 +534,9 @@ struct OpenAIDashboardWebViewCacheTests {
 
     // MARK: - Network Traffic Regression Prevention
 
-    @Test("Multiple sequential fetches should reuse same WebView (network optimization)")
-    func sequentialFetchesReuseWebView() async throws {
+    @Test
+    func `Multiple sequential fetches should reuse same WebView (network optimization)`() async throws {
+        if self.shouldSkipOnCI() { return }
         let cache = OpenAIDashboardWebViewCache()
         let store = WKWebsiteDataStore.nonPersistent()
         let url = try #require(URL(string: "about:blank"))
@@ -239,8 +569,9 @@ struct OpenAIDashboardWebViewCacheTests {
 
     // MARK: - Integration Test with Real Data Store Factory
 
-    @Test("Sequential fetches with OpenAIDashboardWebsiteDataStore should reuse WebView")
-    func sequentialFetchesWithRealDataStoreFactory() async throws {
+    @Test
+    func `Sequential fetches with OpenAIDashboardWebsiteDataStore should reuse WebView`() async throws {
+        if self.shouldSkipOnCI() { return }
         OpenAIDashboardWebsiteDataStore.clearCacheForTesting()
         let cache = OpenAIDashboardWebViewCache()
         let url = try #require(URL(string: "about:blank"))
@@ -274,3 +605,24 @@ struct OpenAIDashboardWebViewCacheTests {
         OpenAIDashboardWebsiteDataStore.clearCacheForTesting()
     }
 }
+
+private final class MemoryPressureThreadProbe: @unchecked Sendable {
+    private let lock = NSLock()
+    private let semaphore = DispatchSemaphore(value: 0)
+    private var recordedMainThread: Bool?
+
+    var wasMainThread: Bool? {
+        self.lock.withLock { self.recordedMainThread }
+    }
+
+    func recordCurrentThread() {
+        self.lock.withLock {
+            self.recordedMainThread = Thread.isMainThread
+        }
+        self.semaphore.signal()
+    }
+
+    func wait(timeout: DispatchTime) -> Bool {
+        self.semaphore.wait(timeout: timeout) == .success
+    }
+}
diff --git a/Tests/CodexBarTests/OpenAIWebAccountSwitchTests.swift b/Tests/CodexBarTests/OpenAIWebAccountSwitchTests.swift
index 7113583f54..1bab839623 100644
--- a/Tests/CodexBarTests/OpenAIWebAccountSwitchTests.swift
+++ b/Tests/CodexBarTests/OpenAIWebAccountSwitchTests.swift
@@ -4,10 +4,9 @@ import Testing
 @testable import CodexBar
 
 @MainActor
-@Suite
 struct OpenAIWebAccountSwitchTests {
     @Test
-    func clearsDashboardWhenCodexEmailChanges() {
+    func `clears dashboard when codex email changes`() {
         let settings = SettingsStore(
             configStore: testConfigStore(suiteName: "OpenAIWebAccountSwitchTests-clears"),
             zaiTokenStore: NoopZaiTokenStore(),
@@ -36,7 +35,7 @@ struct OpenAIWebAccountSwitchTests {
     }
 
     @Test
-    func keepsDashboardWhenCodexEmailStaysSame() {
+    func `keeps dashboard when codex email stays same`() {
         let settings = SettingsStore(
             configStore: testConfigStore(suiteName: "OpenAIWebAccountSwitchTests-keeps"),
             zaiTokenStore: NoopZaiTokenStore(),
@@ -62,4 +61,36 @@ struct OpenAIWebAccountSwitchTests {
         store.handleOpenAIWebTargetEmailChangeIfNeeded(targetEmail: "a@example.com")
         #expect(store.openAIDashboard == dash)
     }
+
+    @Test
+    func `clears dashboard when profile source changes with the same email`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "OpenAIWebAccountSwitchTests-profile-source"),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings)
+
+        store.handleOpenAIWebTargetEmailChangeIfNeeded(
+            targetEmail: "shared@example.com",
+            targetScope: .profileHome("/tmp/codex-profile-a"))
+        store.openAIDashboard = OpenAIDashboardSnapshot(
+            signedInEmail: "shared@example.com",
+            codeReviewRemainingPercent: 100,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            updatedAt: Date())
+
+        store.handleOpenAIWebTargetEmailChangeIfNeeded(
+            targetEmail: "shared@example.com",
+            targetScope: .profileHome("/tmp/codex-profile-b"))
+
+        #expect(store.openAIDashboard == nil)
+        #expect(store.openAIWebAccountDidChange)
+        #expect(store.openAIDashboardRequiresLogin)
+    }
 }
diff --git a/Tests/CodexBarTests/OpenAIWebRefreshGateTests.swift b/Tests/CodexBarTests/OpenAIWebRefreshGateTests.swift
new file mode 100644
index 0000000000..e9a016db5d
--- /dev/null
+++ b/Tests/CodexBarTests/OpenAIWebRefreshGateTests.swift
@@ -0,0 +1,188 @@
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct OpenAIWebRefreshGateTests {
+    @Test
+    func `Battery saver keeps background OpenAI web refreshes off`() {
+        let shouldRun = UsageStore.shouldRunOpenAIWebRefresh(.init(
+            accessEnabled: true,
+            batterySaverEnabled: true,
+            force: false,
+            refreshPhase: .regular))
+
+        #expect(shouldRun == false)
+    }
+
+    @Test
+    func `Disabling battery saver restores normal OpenAI web refreshes`() {
+        let shouldRun = UsageStore.shouldRunOpenAIWebRefresh(.init(
+            accessEnabled: true,
+            batterySaverEnabled: false,
+            force: false,
+            refreshPhase: .regular))
+
+        #expect(shouldRun == true)
+    }
+
+    @Test
+    func `Manual refresh still forces OpenAI web refreshes with battery saver enabled`() {
+        let shouldRun = UsageStore.shouldRunOpenAIWebRefresh(.init(
+            accessEnabled: true,
+            batterySaverEnabled: true,
+            force: true,
+            refreshPhase: .regular))
+
+        #expect(shouldRun == true)
+    }
+
+    @Test
+    func `Startup skips automatic OpenAI web refreshes`() {
+        let shouldRun = UsageStore.shouldRunOpenAIWebRefresh(.init(
+            accessEnabled: true,
+            batterySaverEnabled: false,
+            force: false,
+            refreshPhase: .startup))
+
+        #expect(shouldRun == false)
+    }
+
+    @Test
+    func `Startup connectivity retry remains startup only for OpenAI web refresh gate`() {
+        let providerPhase = UsageStore.refreshPhase(
+            hasCompletedInitialRefresh: true)
+        let openAIWebPhase = UsageStore.openAIWebRefreshPhase(
+            providerRefreshPhase: providerPhase,
+            startupConnectivityRetryAttempt: 1)
+        let shouldRun = UsageStore.shouldRunOpenAIWebRefresh(.init(
+            accessEnabled: true,
+            batterySaverEnabled: false,
+            force: false,
+            refreshPhase: openAIWebPhase))
+
+        #expect(providerPhase == .regular)
+        #expect(openAIWebPhase == .startup)
+        #expect(shouldRun == false)
+    }
+
+    @Test
+    func `Manual startup refresh still forces OpenAI web refreshes`() {
+        let shouldRun = UsageStore.shouldRunOpenAIWebRefresh(.init(
+            accessEnabled: true,
+            batterySaverEnabled: true,
+            force: true,
+            refreshPhase: .startup))
+
+        #expect(shouldRun == true)
+    }
+
+    @Test
+    func `Battery saver stale-submenu refresh respects the cooldown`() {
+        let shouldForce = UsageStore.forceOpenAIWebRefreshForStaleRequest(batterySaverEnabled: true)
+
+        #expect(shouldForce == false)
+    }
+
+    @Test
+    func `Normal stale-submenu refresh still forces when battery saver is off`() {
+        let shouldForce = UsageStore.forceOpenAIWebRefreshForStaleRequest(batterySaverEnabled: false)
+
+        #expect(shouldForce == true)
+    }
+
+    @Test
+    func `Recent successful dashboard refresh stays throttled`() {
+        let now = Date()
+
+        let shouldSkip = UsageStore.shouldSkipOpenAIWebRefresh(.init(
+            force: false,
+            accountDidChange: false,
+            lastError: nil,
+            lastSnapshotAt: now.addingTimeInterval(-60),
+            lastAttemptAt: now.addingTimeInterval(-60),
+            now: now,
+            refreshInterval: 300))
+
+        #expect(shouldSkip == true)
+    }
+
+    @Test
+    func `Recent failed dashboard refresh also stays throttled`() {
+        let now = Date()
+
+        let shouldSkip = UsageStore.shouldSkipOpenAIWebRefresh(.init(
+            force: false,
+            accountDidChange: false,
+            lastError: "login required",
+            lastSnapshotAt: nil,
+            lastAttemptAt: now.addingTimeInterval(-60),
+            now: now,
+            refreshInterval: 300))
+
+        #expect(shouldSkip == true)
+    }
+
+    @Test
+    func `Force refresh bypasses throttle after failures`() {
+        let now = Date()
+
+        let shouldSkip = UsageStore.shouldSkipOpenAIWebRefresh(.init(
+            force: true,
+            accountDidChange: false,
+            lastError: "login required",
+            lastSnapshotAt: nil,
+            lastAttemptAt: now.addingTimeInterval(-60),
+            now: now,
+            refreshInterval: 300))
+
+        #expect(shouldSkip == false)
+    }
+
+    @Test
+    func `Account switches bypass the prior-attempt cooldown`() {
+        let now = Date()
+
+        let shouldSkip = UsageStore.shouldSkipOpenAIWebRefresh(.init(
+            force: false,
+            accountDidChange: true,
+            lastError: "mismatch",
+            lastSnapshotAt: nil,
+            lastAttemptAt: now.addingTimeInterval(-60),
+            now: now,
+            refreshInterval: 300))
+
+        #expect(shouldSkip == false)
+    }
+
+    @Test
+    func `Empty dashboard history retry is throttled after a recent attempt`() {
+        let now = Date()
+
+        let shouldSkip = UsageStore.shouldSkipOpenAIWebEmptyHistoryRetry(.init(
+            force: false,
+            accountDidChange: false,
+            lastError: nil,
+            lastSnapshotAt: now.addingTimeInterval(-120),
+            lastAttemptAt: now.addingTimeInterval(-60),
+            now: now,
+            refreshInterval: 300))
+
+        #expect(shouldSkip == true)
+    }
+
+    @Test
+    func `Empty dashboard history retry runs once for a newer empty snapshot`() {
+        let now = Date()
+
+        let shouldSkip = UsageStore.shouldSkipOpenAIWebEmptyHistoryRetry(.init(
+            force: false,
+            accountDidChange: false,
+            lastError: nil,
+            lastSnapshotAt: now.addingTimeInterval(-60),
+            lastAttemptAt: now.addingTimeInterval(-120),
+            now: now,
+            refreshInterval: 300))
+
+        #expect(shouldSkip == false)
+    }
+}
diff --git a/Tests/CodexBarTests/OpenCodeGoLocalUsageReaderTests.swift b/Tests/CodexBarTests/OpenCodeGoLocalUsageReaderTests.swift
new file mode 100644
index 0000000000..ca060b0a33
--- /dev/null
+++ b/Tests/CodexBarTests/OpenCodeGoLocalUsageReaderTests.swift
@@ -0,0 +1,299 @@
+#if os(macOS)
+
+import Foundation
+import SQLite3
+import Testing
+@testable import CodexBarCore
+
+struct OpenCodeGoLocalUsageReaderTests {
+    @Test
+    func `reads local OpenCode Go history into usage windows`() throws {
+        let env = try Self.makeEnvironment()
+        defer { try? FileManager.default.removeItem(at: env.root) }
+
+        try Self.writeAuth(to: env.authURL)
+        try Self.createDatabase(at: env.databaseURL)
+        try Self.insertMessage(
+            databaseURL: env.databaseURL,
+            createdMs: Self.ms("2026-03-06T11:00:00.000Z"),
+            cost: 3.0)
+        try Self.insertMessage(
+            databaseURL: env.databaseURL,
+            createdMs: Self.ms("2026-03-05T12:00:00.000Z"),
+            cost: 6.0)
+        try Self.insertMessage(
+            databaseURL: env.databaseURL,
+            createdMs: Self.ms("2026-02-25T07:53:16.000Z"),
+            cost: 2.0)
+
+        let reader = OpenCodeGoLocalUsageReader(authURL: env.authURL, databaseURL: env.databaseURL)
+        let snapshot = try reader.fetch(now: Date(timeIntervalSince1970: 1_772_798_400))
+
+        #expect(snapshot.rollingUsagePercent == 25)
+        #expect(snapshot.weeklyUsagePercent == 30)
+        #expect(snapshot.monthlyUsagePercent == 18.3)
+        #expect(snapshot.rollingResetInSec == 14400)
+        #expect(snapshot.weeklyResetInSec == 216_000)
+        #expect(snapshot.monthlyResetInSec == 1_626_796)
+    }
+
+    @Test
+    func `auth without history falls through to web strategy`() throws {
+        let env = try Self.makeEnvironment()
+        defer { try? FileManager.default.removeItem(at: env.root) }
+
+        try Self.writeAuth(to: env.authURL)
+
+        let reader = OpenCodeGoLocalUsageReader(authURL: env.authURL, databaseURL: env.databaseURL)
+
+        #expect(throws: OpenCodeGoLocalUsageError.historyUnavailable("database not found")) {
+            _ = try reader.fetch(now: Date(timeIntervalSince1970: 1_772_798_400))
+        }
+    }
+
+    @Test
+    func `auth with unreadable history falls through to web strategy`() throws {
+        let env = try Self.makeEnvironment()
+        defer { try? FileManager.default.removeItem(at: env.root) }
+
+        try Self.writeAuth(to: env.authURL)
+        var db: OpaquePointer?
+        guard sqlite3_open(env.databaseURL.path, &db) == SQLITE_OK else { throw SQLiteTestError.open }
+        sqlite3_close(db)
+
+        let reader = OpenCodeGoLocalUsageReader(authURL: env.authURL, databaseURL: env.databaseURL)
+
+        #expect(throws: OpenCodeGoLocalUsageError.self) {
+            _ = try reader.fetch(now: Date(timeIntervalSince1970: 1_772_798_400))
+        }
+    }
+
+    @Test
+    func `monthly window keeps original anchor after shorter month clamp`() throws {
+        let env = try Self.makeEnvironment()
+        defer { try? FileManager.default.removeItem(at: env.root) }
+
+        try Self.writeAuth(to: env.authURL)
+        try Self.createDatabase(at: env.databaseURL)
+        try Self.insertMessage(
+            databaseURL: env.databaseURL,
+            createdMs: Self.ms("2026-01-31T00:00:00.000Z"),
+            cost: 1.0)
+        try Self.insertMessage(
+            databaseURL: env.databaseURL,
+            createdMs: Self.ms("2026-03-29T10:00:00.000Z"),
+            cost: 6.0)
+
+        let reader = OpenCodeGoLocalUsageReader(authURL: env.authURL, databaseURL: env.databaseURL)
+        let now = Date(timeIntervalSince1970: TimeInterval(Self.ms("2026-03-29T12:00:00.000Z")) / 1000)
+        let snapshot = try reader.fetch(now: now)
+
+        #expect(snapshot.monthlyUsagePercent == 10)
+        #expect(snapshot.monthlyResetInSec == 129_600)
+    }
+
+    @Test
+    func `reads step finish parts when message only stores metadata`() throws {
+        let env = try Self.makeEnvironment()
+        defer { try? FileManager.default.removeItem(at: env.root) }
+
+        try Self.writeAuth(to: env.authURL)
+        try Self.createDatabase(at: env.databaseURL)
+        let messageID = try Self.insertMessage(
+            databaseURL: env.databaseURL,
+            createdMs: Self.ms("2026-03-06T11:00:00.000Z"),
+            cost: nil)
+        try Self.insertStepFinishPart(
+            databaseURL: env.databaseURL,
+            messageID: messageID,
+            createdMs: Self.ms("2026-03-06T11:00:00.000Z"),
+            cost: 3.0)
+
+        let reader = OpenCodeGoLocalUsageReader(authURL: env.authURL, databaseURL: env.databaseURL)
+        let snapshot = try reader.fetch(now: Date(timeIntervalSince1970: 1_772_798_400))
+
+        #expect(snapshot.rollingUsagePercent == 25)
+        #expect(snapshot.weeklyUsagePercent == 10)
+        #expect(snapshot.monthlyUsagePercent == 5)
+    }
+
+    @Test
+    func `does not double count step finish parts when message has cost`() throws {
+        let env = try Self.makeEnvironment()
+        defer { try? FileManager.default.removeItem(at: env.root) }
+
+        try Self.writeAuth(to: env.authURL)
+        try Self.createDatabase(at: env.databaseURL)
+        let messageID = try Self.insertMessage(
+            databaseURL: env.databaseURL,
+            createdMs: Self.ms("2026-03-06T11:00:00.000Z"),
+            cost: 3.0)
+        try Self.insertStepFinishPart(
+            databaseURL: env.databaseURL,
+            messageID: messageID,
+            createdMs: Self.ms("2026-03-06T11:00:00.000Z"),
+            cost: 3.0)
+
+        let reader = OpenCodeGoLocalUsageReader(authURL: env.authURL, databaseURL: env.databaseURL)
+        let snapshot = try reader.fetch(now: Date(timeIntervalSince1970: 1_772_798_400))
+
+        #expect(snapshot.rollingUsagePercent == 25)
+        #expect(snapshot.weeklyUsagePercent == 10)
+        #expect(snapshot.monthlyUsagePercent == 5)
+    }
+
+    @Test
+    func `missing auth and history is not detected`() throws {
+        let env = try Self.makeEnvironment()
+        defer { try? FileManager.default.removeItem(at: env.root) }
+
+        let reader = OpenCodeGoLocalUsageReader(authURL: env.authURL, databaseURL: env.databaseURL)
+
+        #expect(throws: OpenCodeGoLocalUsageError.notDetected) {
+            _ = try reader.fetch(now: Date(timeIntervalSince1970: 1_772_798_400))
+        }
+    }
+
+    private static func makeEnvironment() throws -> (root: URL, authURL: URL, databaseURL: URL) {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent("OpenCodeGoLocalUsageReaderTests-\(UUID().uuidString)", isDirectory: true)
+        let directory = root
+            .appendingPathComponent(".local", isDirectory: true)
+            .appendingPathComponent("share", isDirectory: true)
+            .appendingPathComponent("opencode", isDirectory: true)
+        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+        return (
+            root,
+            directory.appendingPathComponent("auth.json", isDirectory: false),
+            directory.appendingPathComponent("opencode.db", isDirectory: false))
+    }
+
+    private static func writeAuth(to url: URL) throws {
+        let data = Data(#"{"opencode-go":{"type":"api-key","key":"go-key"}}"#.utf8)
+        try data.write(to: url)
+    }
+
+    private static func createDatabase(at url: URL) throws {
+        var db: OpaquePointer?
+        guard sqlite3_open(url.path, &db) == SQLITE_OK else { throw SQLiteTestError.open }
+        defer { sqlite3_close(db) }
+        try Self.exec(
+            db: db,
+            sql: """
+                CREATE TABLE message (
+                  id TEXT PRIMARY KEY,
+                  session_id TEXT NOT NULL,
+                  data TEXT NOT NULL,
+                  time_created INTEGER,
+                  time_updated INTEGER
+                );
+                CREATE TABLE part (
+                  id TEXT PRIMARY KEY,
+                  message_id TEXT NOT NULL,
+                  session_id TEXT NOT NULL,
+                  data TEXT NOT NULL,
+                  time_created INTEGER,
+                  time_updated INTEGER
+                );
+            """)
+    }
+
+    @discardableResult
+    private static func insertMessage(databaseURL: URL, createdMs: Int64, cost: Double?) throws -> String {
+        var db: OpaquePointer?
+        guard sqlite3_open(databaseURL.path, &db) == SQLITE_OK else { throw SQLiteTestError.open }
+        defer { sqlite3_close(db) }
+
+        let messageID = UUID().uuidString
+        var payload: [String: Any] = [
+            "providerID": "opencode-go",
+            "role": "assistant",
+            "time": ["created": createdMs],
+        ]
+        if let cost {
+            payload["cost"] = cost
+        }
+        let data = try JSONSerialization.data(withJSONObject: payload)
+        let json = String(data: data, encoding: .utf8) ?? "{}"
+
+        var stmt: OpaquePointer?
+        guard sqlite3_prepare_v2(
+            db,
+            "INSERT INTO message (id, session_id, data, time_created, time_updated) VALUES (?, ?, ?, ?, ?)",
+            -1,
+            &stmt,
+            nil) == SQLITE_OK
+        else { throw SQLiteTestError.prepare }
+        defer { sqlite3_finalize(stmt) }
+
+        let transient = unsafeBitCast(-1, to: sqlite3_destructor_type.self)
+        sqlite3_bind_text(stmt, 1, messageID, -1, transient)
+        sqlite3_bind_text(stmt, 2, "session-1", -1, transient)
+        sqlite3_bind_text(stmt, 3, json, -1, transient)
+        sqlite3_bind_int64(stmt, 4, createdMs)
+        sqlite3_bind_int64(stmt, 5, createdMs)
+        guard sqlite3_step(stmt) == SQLITE_DONE else { throw SQLiteTestError.step }
+        return messageID
+    }
+
+    private static func insertStepFinishPart(
+        databaseURL: URL,
+        messageID: String,
+        createdMs: Int64,
+        cost: Double) throws
+    {
+        var db: OpaquePointer?
+        guard sqlite3_open(databaseURL.path, &db) == SQLITE_OK else { throw SQLiteTestError.open }
+        defer { sqlite3_close(db) }
+
+        let payload: [String: Any] = [
+            "type": "step-finish",
+            "cost": cost,
+            "tokens": ["input": 1, "output": 1, "total": 2],
+        ]
+        let data = try JSONSerialization.data(withJSONObject: payload)
+        let json = String(data: data, encoding: .utf8) ?? "{}"
+
+        var stmt: OpaquePointer?
+        guard sqlite3_prepare_v2(
+            db,
+            "INSERT INTO part (id, message_id, session_id, data, time_created, time_updated) VALUES (?, ?, ?, ?, ?, ?)",
+            -1,
+            &stmt,
+            nil) == SQLITE_OK
+        else { throw SQLiteTestError.prepare }
+        defer { sqlite3_finalize(stmt) }
+
+        let transient = unsafeBitCast(-1, to: sqlite3_destructor_type.self)
+        sqlite3_bind_text(stmt, 1, UUID().uuidString, -1, transient)
+        sqlite3_bind_text(stmt, 2, messageID, -1, transient)
+        sqlite3_bind_text(stmt, 3, "session-1", -1, transient)
+        sqlite3_bind_text(stmt, 4, json, -1, transient)
+        sqlite3_bind_int64(stmt, 5, createdMs)
+        sqlite3_bind_int64(stmt, 6, createdMs)
+        guard sqlite3_step(stmt) == SQLITE_DONE else { throw SQLiteTestError.step }
+    }
+
+    private static func exec(db: OpaquePointer?, sql: String) throws {
+        var message: UnsafeMutablePointer<CChar>?
+        guard sqlite3_exec(db, sql, nil, nil, &message) == SQLITE_OK else {
+            sqlite3_free(message)
+            throw SQLiteTestError.exec
+        }
+    }
+
+    private static func ms(_ iso: String) -> Int64 {
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        return Int64((formatter.date(from: iso)?.timeIntervalSince1970 ?? 0) * 1000)
+    }
+
+    private enum SQLiteTestError: Error {
+        case open
+        case prepare
+        case step
+        case exec
+    }
+}
+
+#endif
diff --git a/Tests/CodexBarTests/OpenCodeGoMenuCardModelTests.swift b/Tests/CodexBarTests/OpenCodeGoMenuCardModelTests.swift
new file mode 100644
index 0000000000..b5cda37f5a
--- /dev/null
+++ b/Tests/CodexBarTests/OpenCodeGoMenuCardModelTests.swift
@@ -0,0 +1,130 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct OpenCodeGoMenuCardModelTests {
+    @Test
+    func `zen balance renders as optional balance`() throws {
+        let now = Date()
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 12, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 34, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            tertiary: nil,
+            providerCost: ProviderCostSnapshot(
+                used: 98.76,
+                limit: 0,
+                currencyCode: "USD",
+                period: "Zen balance",
+                updatedAt: now),
+            updatedAt: now,
+            identity: nil)
+        let metadata = try #require(ProviderDefaults.metadata[.opencodego])
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .opencodego,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: true,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.providerCost?.title == "Zen balance")
+        #expect(model.providerCost?.spendLine == "Balance: $98.76")
+        #expect(model.providerCost?.percentUsed == nil)
+        #expect(model.providerCost?.percentLine == nil)
+    }
+
+    @Test
+    func `required zen balance renders when optional usage is disabled`() throws {
+        let now = Date()
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            tertiary: nil,
+            providerCost: ProviderCostSnapshot(
+                used: 98.76,
+                limit: 0,
+                currencyCode: "USD",
+                period: "Zen balance",
+                updatedAt: now),
+            updatedAt: now,
+            identity: nil)
+        let metadata = try #require(ProviderDefaults.metadata[.opencodego])
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .opencodego,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: true,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: false,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.providerCost?.title == "Zen balance")
+        #expect(model.providerCost?.spendLine == "Balance: $98.76")
+    }
+
+    @Test
+    func `subscription zen balance hides when optional usage is disabled`() throws {
+        let now = Date()
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 12, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 34, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            tertiary: nil,
+            providerCost: ProviderCostSnapshot(
+                used: 98.76,
+                limit: 0,
+                currencyCode: "USD",
+                period: "Zen balance",
+                updatedAt: now),
+            updatedAt: now,
+            identity: nil)
+        let metadata = try #require(ProviderDefaults.metadata[.opencodego])
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .opencodego,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: true,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: false,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.providerCost == nil)
+    }
+}
diff --git a/Tests/CodexBarTests/OpenCodeGoProviderStrategyTests.swift b/Tests/CodexBarTests/OpenCodeGoProviderStrategyTests.swift
new file mode 100644
index 0000000000..4c4d4d3989
--- /dev/null
+++ b/Tests/CodexBarTests/OpenCodeGoProviderStrategyTests.swift
@@ -0,0 +1,64 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct OpenCodeGoProviderStrategyTests {
+    private struct StubClaudeFetcher: ClaudeUsageFetching {
+        func loadLatestUsage(model _: String) async throws -> ClaudeUsageSnapshot {
+            throw ClaudeUsageError.parseFailed("stub")
+        }
+
+        func debugRawProbe(model _: String) async -> String {
+            "stub"
+        }
+
+        func detectVersion() -> String? {
+            nil
+        }
+    }
+
+    private func makeContext(sourceMode: ProviderSourceMode = .auto) -> ProviderFetchContext {
+        let env: [String: String] = [:]
+        return ProviderFetchContext(
+            runtime: .app,
+            sourceMode: sourceMode,
+            includeCredits: false,
+            webTimeout: 1,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: env,
+            settings: nil,
+            fetcher: UsageFetcher(environment: env),
+            claudeFetcher: StubClaudeFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0))
+    }
+
+    @Test
+    func `auto source prefers web before local fallback`() async {
+        let descriptor = OpenCodeGoProviderDescriptor.makeDescriptor()
+        let strategies = await descriptor.fetchPlan.pipeline.resolveStrategies(self.makeContext())
+
+        #expect(strategies.map(\.id) == ["opencodego.web", "opencodego.local"])
+    }
+
+    @Test
+    func `web source does not include local fallback`() async {
+        let descriptor = OpenCodeGoProviderDescriptor.makeDescriptor()
+        let strategies = await descriptor.fetchPlan.pipeline.resolveStrategies(self.makeContext(sourceMode: .web))
+
+        #expect(strategies.map(\.id) == ["opencodego.web"])
+    }
+
+    @Test
+    func `web strategy falls back to local only for auth setup failures in auto mode`() {
+        let strategy = OpenCodeGoUsageFetchStrategy()
+        let autoContext = self.makeContext()
+        let webContext = self.makeContext(sourceMode: .web)
+
+        #expect(strategy.shouldFallback(on: OpenCodeGoSettingsError.missingCookie, context: autoContext))
+        #expect(strategy.shouldFallback(on: OpenCodeGoSettingsError.invalidCookie, context: autoContext))
+        #expect(strategy.shouldFallback(on: OpenCodeGoUsageError.invalidCredentials, context: autoContext))
+        #expect(!strategy.shouldFallback(on: OpenCodeGoUsageError.networkError("timeout"), context: autoContext))
+        #expect(!strategy.shouldFallback(on: OpenCodeGoSettingsError.missingCookie, context: webContext))
+    }
+}
diff --git a/Tests/CodexBarTests/OpenCodeGoUsageFetcherErrorTests.swift b/Tests/CodexBarTests/OpenCodeGoUsageFetcherErrorTests.swift
new file mode 100644
index 0000000000..b5e397dd17
--- /dev/null
+++ b/Tests/CodexBarTests/OpenCodeGoUsageFetcherErrorTests.swift
@@ -0,0 +1,873 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+private final class OpenCodeGoRequestRecorder<Value: Sendable>: @unchecked Sendable {
+    private let lock = NSLock()
+    private var storage: [Value] = []
+
+    func append(_ value: Value) {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        self.storage.append(value)
+    }
+
+    var values: [Value] {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        return self.storage
+    }
+}
+
+private final class OpenCodeGoContinuationBox<Value: Sendable>: @unchecked Sendable {
+    private let lock = NSLock()
+    private var continuation: CheckedContinuation<Value, Never>?
+
+    func wait(onReady: @Sendable () -> Void) async -> Value {
+        await withCheckedContinuation { continuation in
+            self.lock.lock()
+            self.continuation = continuation
+            self.lock.unlock()
+            onReady()
+        }
+    }
+
+    func resume(returning value: Value) {
+        self.lock.lock()
+        let continuation = self.continuation
+        self.continuation = nil
+        self.lock.unlock()
+        continuation?.resume(returning: value)
+    }
+}
+
+@Suite(.serialized)
+struct OpenCodeGoUsageFetcherErrorTests {
+    @Test
+    func `dashboard URL uses normalized workspace ID`() {
+        #expect(
+            OpenCodeGoUsageFetcher.dashboardURL(workspaceID: "https://opencode.ai/workspace/wrk_abc123/go")
+                .absoluteString == "https://opencode.ai/workspace/wrk_abc123/go")
+        #expect(
+            OpenCodeGoUsageFetcher.dashboardURL(workspaceID: "workspace=wrk_def456")
+                .absoluteString == "https://opencode.ai/workspace/wrk_def456/go")
+        #expect(
+            OpenCodeGoUsageFetcher.dashboardURL(workspaceID: nil)
+                .absoluteString == "https://opencode.ai")
+    }
+
+    private struct UsageWindow {
+        let percent: Double
+        let resetInSec: Int
+    }
+
+    private func makeSession() -> URLSession {
+        let config = URLSessionConfiguration.ephemeral
+        config.protocolClasses = [OpenCodeGoStubURLProtocol.self]
+        return URLSession(configuration: config)
+    }
+
+    @Test
+    func `redirect guard allows only same-host https redirects`() {
+        #expect(OpenCodeGoUsageFetcher.allowsRedirect(
+            from: URL(string: "https://opencode.ai/_server"),
+            to: URL(string: "https://opencode.ai/workspace/wrk_TEST123/go")))
+
+        #expect(!OpenCodeGoUsageFetcher.allowsRedirect(
+            from: URL(string: "https://opencode.ai/_server"),
+            to: URL(string: "https://evil.example/steal")))
+
+        #expect(!OpenCodeGoUsageFetcher.allowsRedirect(
+            from: URL(string: "https://opencode.ai/_server"),
+            to: URL(string: "http://opencode.ai/insecure")))
+    }
+
+    @Test
+    func `extracts api error from detail field`() async throws {
+        defer {
+            OpenCodeGoStubURLProtocol.handler = nil
+        }
+
+        OpenCodeGoStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            let body = #"{"detail":"Workspace missing"}"#
+            return Self.makeResponse(url: url, body: body, statusCode: 500, contentType: "application/json")
+        }
+
+        do {
+            _ = try await OpenCodeGoUsageFetcher.fetchUsage(
+                cookieHeader: "auth=test",
+                timeout: 2,
+                workspaceIDOverride: "wrk_TEST123",
+                session: self.makeSession())
+            Issue.record("Expected OpenCodeGoUsageError.apiError")
+        } catch let error as OpenCodeGoUsageError {
+            switch error {
+            case let .apiError(message):
+                #expect(message.contains("HTTP 500"))
+                #expect(message.contains("Workspace missing"))
+            default:
+                Issue.record("Expected apiError, got: \(error)")
+            }
+        }
+    }
+
+    @Test
+    func `workspace get missing ids falls back to post before loading go page`() async throws {
+        defer {
+            OpenCodeGoStubURLProtocol.handler = nil
+        }
+
+        let requests = OpenCodeGoRequestRecorder<String>()
+        OpenCodeGoStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            requests.append("\(request.httpMethod ?? "GET") \(url.path)")
+
+            let workspaceServerID = "def39973159c7f0483d8793a822b8dbb10d067e12c65455fcb4608459ba0234f"
+            if url.query?.contains(workspaceServerID) == true,
+               request.httpMethod?.uppercased() == "GET"
+            {
+                return Self.makeResponse(
+                    url: url,
+                    body: #"{"ok":true}"#,
+                    statusCode: 200,
+                    contentType: "application/json")
+            }
+
+            if url.path == "/_server",
+               request.httpMethod?.uppercased() == "POST",
+               request.value(forHTTPHeaderField: "X-Server-Id") == workspaceServerID
+            {
+                return Self.makeResponse(
+                    url: url,
+                    body: #"{"data":[{"id":"wrk_TEST123"}]}"#,
+                    statusCode: 200,
+                    contentType: "application/json")
+            }
+
+            return Self.makeResponse(
+                url: url,
+                body: Self.goUsagePageHTML(
+                    workspaceID: "wrk_TEST123",
+                    rolling: UsageWindow(percent: 22, resetInSec: 300),
+                    weekly: UsageWindow(percent: 44, resetInSec: 3600),
+                    monthly: UsageWindow(percent: 55, resetInSec: 7200)),
+                statusCode: 200,
+                contentType: "text/html")
+        }
+
+        let snapshot = try await OpenCodeGoUsageFetcher.fetchUsage(
+            cookieHeader: "auth=test",
+            timeout: 2,
+            includeZenBalance: false,
+            session: self.makeSession())
+
+        #expect(snapshot.rollingUsagePercent == 22)
+        #expect(snapshot.weeklyUsagePercent == 44)
+        #expect(snapshot.monthlyUsagePercent == 55)
+        #expect(requests.values == [
+            "GET /_server",
+            "POST /_server",
+            "GET /workspace/wrk_TEST123/go",
+        ])
+    }
+
+    @Test
+    func `workspace get public actor error is treated as invalid credentials without post retry`() async throws {
+        defer {
+            OpenCodeGoStubURLProtocol.handler = nil
+        }
+
+        let methods = OpenCodeGoRequestRecorder<String>()
+        OpenCodeGoStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            methods.append(request.httpMethod ?? "GET")
+            let body = [
+                #";0x00000263;((self.$R=self.$R||{})["server-fn:test"]=[],"#,
+                #"($R=>$R[0]=Object.assign(new Error("actor of type \"public\" is not associated with an account"),"#,
+                #"{stack:"Error: actor of type \"public\" is not associated with an account"}))"#,
+                #"($R["server-fn:test"]))"#,
+            ].joined()
+            return Self.makeResponse(
+                url: url,
+                body: body,
+                statusCode: 200,
+                contentType: "text/javascript")
+        }
+
+        do {
+            _ = try await OpenCodeGoUsageFetcher.fetchUsage(
+                cookieHeader: "auth=test",
+                timeout: 2,
+                session: self.makeSession())
+            Issue.record("Expected OpenCodeGoUsageError.invalidCredentials")
+        } catch let error as OpenCodeGoUsageError {
+            switch error {
+            case .invalidCredentials:
+                break
+            default:
+                Issue.record("Expected invalidCredentials, got: \(error)")
+            }
+        }
+
+        #expect(methods.values == ["GET"])
+    }
+
+    @Test
+    func `go page missing usage fields returns parse failed without post retry`() async throws {
+        defer {
+            OpenCodeGoStubURLProtocol.handler = nil
+        }
+
+        let methods = OpenCodeGoRequestRecorder<String>()
+        OpenCodeGoStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            methods.append(request.httpMethod ?? "GET")
+            return Self.makeResponse(
+                url: url,
+                body: "<html><title>opencode</title><body>No usage yet</body></html>",
+                statusCode: 200,
+                contentType: "text/html")
+        }
+
+        do {
+            _ = try await OpenCodeGoUsageFetcher.fetchUsage(
+                cookieHeader: "auth=test",
+                timeout: 2,
+                workspaceIDOverride: "wrk_TEST123",
+                session: self.makeSession())
+            Issue.record("Expected OpenCodeGoUsageError.parseFailed")
+        } catch let error as OpenCodeGoUsageError {
+            switch error {
+            case let .parseFailed(message):
+                #expect(message.contains("Missing usage fields"))
+            default:
+                Issue.record("Expected parseFailed, got: \(error)")
+            }
+        }
+
+        #expect(methods.values == ["GET", "GET", "GET"])
+    }
+
+    @Test
+    func `zen only account waits for balance beyond optional grace`() async throws {
+        defer {
+            OpenCodeGoStubURLProtocol.handler = nil
+        }
+
+        let observedPaths = OpenCodeGoRequestRecorder<String>()
+        OpenCodeGoStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            observedPaths.append(url.path)
+            if url.path == "/workspace/wrk_TEST123" {
+                Thread.sleep(forTimeInterval: 0.4)
+                return Self.makeResponse(
+                    url: url,
+                    body: #"<html><body><h2>現在の残高 $42.50</h2></body></html>"#,
+                    statusCode: 200,
+                    contentType: "text/html")
+            }
+            return Self.makeResponse(
+                url: url,
+                body: "<html><title>opencode</title><body>No Go subscription usage</body></html>",
+                statusCode: 200,
+                contentType: "text/html")
+        }
+
+        let snapshot = try await OpenCodeGoUsageFetcher.fetchUsage(
+            cookieHeader: "auth=test",
+            timeout: 2,
+            workspaceIDOverride: "wrk_TEST123",
+            session: self.makeSession())
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(snapshot.isBalanceOnly)
+        #expect(snapshot.zenBalanceUSD == 42.5)
+        #expect(usage.primary == nil)
+        #expect(usage.secondary == nil)
+        #expect(usage.providerCost?.used == 42.5)
+        #expect(usage.providerCost?.period == "Zen balance")
+        #expect(observedPaths.values.count == 2)
+        #expect(Set(observedPaths.values) == ["/workspace/wrk_TEST123/go", "/workspace/wrk_TEST123"])
+    }
+
+    @Test
+    func `zen only account fetches required balance when optional usage is disabled`() async throws {
+        defer {
+            OpenCodeGoStubURLProtocol.handler = nil
+        }
+
+        let observedPaths = OpenCodeGoRequestRecorder<String>()
+        OpenCodeGoStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            observedPaths.append(url.path)
+            if url.path == "/workspace/wrk_TEST123" {
+                return Self.makeResponse(
+                    url: url,
+                    body: #"<html><body><h2>Current balance $23.75</h2></body></html>"#,
+                    statusCode: 200,
+                    contentType: "text/html")
+            }
+            return Self.makeResponse(
+                url: url,
+                body: "<html><title>opencode</title><body>No Go subscription usage</body></html>",
+                statusCode: 200,
+                contentType: "text/html")
+        }
+
+        let snapshot = try await OpenCodeGoUsageFetcher.fetchUsage(
+            cookieHeader: "auth=test",
+            timeout: 2,
+            workspaceIDOverride: "wrk_TEST123",
+            includeZenBalance: false,
+            session: self.makeSession())
+
+        #expect(snapshot.isBalanceOnly)
+        #expect(snapshot.zenBalanceUSD == 23.75)
+        #expect(observedPaths.values == ["/workspace/wrk_TEST123/go", "/workspace/wrk_TEST123"])
+    }
+
+    @Test
+    func `zen only account propagates invalid credentials from required balance fetch`() async throws {
+        defer {
+            OpenCodeGoStubURLProtocol.handler = nil
+        }
+
+        OpenCodeGoStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            if url.path == "/workspace/wrk_TEST123" {
+                return Self.makeResponse(
+                    url: url,
+                    body: "Unauthorized",
+                    statusCode: 401,
+                    contentType: "text/plain")
+            }
+            return Self.makeResponse(
+                url: url,
+                body: "<html><title>opencode</title><body>No Go subscription usage</body></html>",
+                statusCode: 200,
+                contentType: "text/html")
+        }
+
+        do {
+            _ = try await OpenCodeGoUsageFetcher.fetchUsage(
+                cookieHeader: "auth=stale",
+                timeout: 2,
+                workspaceIDOverride: "wrk_TEST123",
+                session: self.makeSession())
+            Issue.record("Expected invalid credentials to propagate.")
+        } catch OpenCodeGoUsageError.invalidCredentials {
+            // Expected.
+        } catch {
+            Issue.record("Expected invalidCredentials, got: \(error)")
+        }
+    }
+
+    @Test
+    func `zen only account falls back after final subscription parse failure`() async throws {
+        defer {
+            OpenCodeGoStubURLProtocol.handler = nil
+        }
+
+        var rootTimeout: TimeInterval?
+        OpenCodeGoStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            if url.path == "/workspace/wrk_TEST123" {
+                rootTimeout = request.timeoutInterval
+                return Self.makeResponse(
+                    url: url,
+                    body: #"<html><body><h2>Current balance $17.25</h2></body></html>"#,
+                    statusCode: 200,
+                    contentType: "text/html")
+            }
+            return Self.makeResponse(
+                url: url,
+                body: #"<script>rollingUsage:{usagePercent:12}</script>"#,
+                statusCode: 200,
+                contentType: "text/html")
+        }
+
+        let snapshot = try await OpenCodeGoUsageFetcher.fetchUsage(
+            cookieHeader: "auth=test",
+            timeout: 12,
+            workspaceIDOverride: "wrk_TEST123",
+            session: self.makeSession())
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(snapshot.isBalanceOnly)
+        #expect(snapshot.zenBalanceUSD == 17.25)
+        #expect(usage.primary == nil)
+        #expect(usage.secondary == nil)
+        #expect(usage.providerCost?.used == 17.25)
+        #expect(rootTimeout == 12)
+    }
+
+    @Test
+    func `zen only fallback promptly cancels when balance task ignores cancellation`() async throws {
+        let balanceStarted = AsyncStream<Void>.makeStream(of: Void.self)
+        let balanceContinuation = OpenCodeGoContinuationBox<Double?>()
+        let balanceTask = Task<Double?, Error> {
+            await balanceContinuation.wait {
+                balanceStarted.continuation.yield(())
+            }
+        }
+        let fallbackTask = Task {
+            try await OpenCodeGoUsageFetcher.requiredZenBalanceFallback(
+                from: balanceTask,
+                for: .parseFailed("Missing usage fields."),
+                request: OpenCodeGoUsageFetcher.ZenBalanceRequest(
+                    workspaceID: "wrk_TEST123",
+                    cookieHeader: "auth=test",
+                    timeout: 2,
+                    session: self.makeSession()),
+                now: Date())
+        }
+
+        var iterator = balanceStarted.stream.makeAsyncIterator()
+        _ = await iterator.next()
+        let start = ContinuousClock.now
+        fallbackTask.cancel()
+
+        do {
+            _ = try await fallbackTask.value
+            Issue.record("Expected cancellation to propagate.")
+        } catch is CancellationError {
+            // Expected.
+        } catch {
+            Issue.record("Expected CancellationError, got: \(error)")
+        }
+
+        #expect(start.duration(to: .now) < .milliseconds(500))
+        #expect(balanceTask.isCancelled)
+        balanceContinuation.resume(returning: 42.5)
+        #expect(try await balanceTask.value == 42.5)
+    }
+
+    @Test
+    func `normalizes workspace override from URL into go page path`() async throws {
+        defer {
+            OpenCodeGoStubURLProtocol.handler = nil
+        }
+
+        let observedPaths = OpenCodeGoRequestRecorder<String>()
+        OpenCodeGoStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            observedPaths.append(url.path)
+            return Self.makeResponse(
+                url: url,
+                body: Self.goUsagePageHTML(
+                    workspaceID: "wrk_URL123",
+                    rolling: UsageWindow(percent: 17, resetInSec: 600),
+                    weekly: UsageWindow(percent: 75, resetInSec: 7200),
+                    monthly: nil),
+                statusCode: 200,
+                contentType: "text/html")
+        }
+
+        _ = try await OpenCodeGoUsageFetcher.fetchUsage(
+            cookieHeader: "auth=test",
+            timeout: 2,
+            workspaceIDOverride: "https://opencode.ai/workspace/wrk_URL123/billing",
+            session: self.makeSession())
+
+        #expect(observedPaths.values.count == 3)
+        #expect(Set(observedPaths.values) == [
+            "/workspace/wrk_URL123/go",
+            "/workspace/wrk_URL123",
+            "/_server",
+        ])
+    }
+
+    @Test
+    func `fetcher attaches optional zen balance from workspace root`() async throws {
+        defer {
+            OpenCodeGoStubURLProtocol.handler = nil
+        }
+
+        OpenCodeGoStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            if url.path == "/workspace/wrk_TEST123" {
+                return Self.makeResponse(
+                    url: url,
+                    body: #"<html><body><h2>現在の残高 $98.76</h2></body></html>"#,
+                    statusCode: 200,
+                    contentType: "text/html")
+            }
+            return Self.makeResponse(
+                url: url,
+                body: Self.goUsagePageHTML(
+                    workspaceID: "wrk_TEST123",
+                    rolling: UsageWindow(percent: 17, resetInSec: 600),
+                    weekly: UsageWindow(percent: 75, resetInSec: 7200),
+                    monthly: nil),
+                statusCode: 200,
+                contentType: "text/html")
+        }
+
+        let snapshot = try await OpenCodeGoUsageFetcher.fetchUsage(
+            cookieHeader: "auth=test",
+            timeout: 2,
+            workspaceIDOverride: "wrk_TEST123",
+            session: self.makeSession())
+
+        #expect(snapshot.zenBalanceUSD == 98.76)
+        #expect(snapshot.toUsageSnapshot().providerCost?.period == "Zen balance")
+    }
+
+    @Test
+    func `fetcher falls back to billing server when workspace page omits balance`() async throws {
+        defer {
+            OpenCodeGoStubURLProtocol.handler = nil
+        }
+
+        let observedRequests = OpenCodeGoRequestRecorder<URLRequest>()
+        OpenCodeGoStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            observedRequests.append(request)
+            if url.path == "/workspace/wrk_TEST123" {
+                return Self.makeResponse(
+                    url: url,
+                    body: "<html><body>Workspace dashboard without hydrated billing data</body></html>",
+                    statusCode: 200,
+                    contentType: "text/html")
+            }
+            if url.path == "/_server" {
+                return Self.makeResponse(
+                    url: url,
+                    body: #"$R[0]={customerID:"cus_test",balance:$R[1]=9876000000,reload:!1}"#,
+                    statusCode: 200,
+                    contentType: "text/javascript")
+            }
+            return Self.makeResponse(
+                url: url,
+                body: Self.goUsagePageHTML(
+                    workspaceID: "wrk_TEST123",
+                    rolling: UsageWindow(percent: 17, resetInSec: 600),
+                    weekly: UsageWindow(percent: 75, resetInSec: 7200),
+                    monthly: nil),
+                statusCode: 200,
+                contentType: "text/html")
+        }
+
+        let snapshot = try await OpenCodeGoUsageFetcher.fetchUsage(
+            cookieHeader: "auth=test",
+            timeout: 2,
+            workspaceIDOverride: "wrk_TEST123",
+            session: self.makeSession())
+
+        #expect(snapshot.zenBalanceUSD == 98.76)
+        let billingRequest = try #require(observedRequests.values.first { $0.url?.path == "/_server" })
+        let billingURL = try #require(billingRequest.url)
+        let components = try #require(URLComponents(url: billingURL, resolvingAgainstBaseURL: false))
+        let query = Dictionary(uniqueKeysWithValues: (components.queryItems ?? []).map { ($0.name, $0.value ?? "") })
+        #expect(query["id"] == "c83b78a614689c38ebee981f9b39a8b377716db85c1fd7dbab604adc02d3313d")
+        #expect(query["args"] == #"["wrk_TEST123"]"#)
+        #expect(billingRequest.value(forHTTPHeaderField: "Cookie") == "auth=test")
+        #expect(billingRequest.value(forHTTPHeaderField: "Referer") == "https://opencode.ai/workspace/wrk_TEST123")
+    }
+
+    @Test
+    func `optional zen balance helper uses normalized cookie and workspace override`() async throws {
+        defer {
+            OpenCodeGoStubURLProtocol.handler = nil
+        }
+
+        var observedCookie: String?
+        OpenCodeGoStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            observedCookie = request.value(forHTTPHeaderField: "Cookie")
+            #expect(url.path == "/workspace/wrk_TEST123")
+            return Self.makeResponse(
+                url: url,
+                body: #"<html><body><h2>現在の残高 $98.76</h2></body></html>"#,
+                statusCode: 200,
+                contentType: "text/html")
+        }
+
+        let balance = try await OpenCodeGoUsageFetcher.fetchOptionalZenBalance(
+            cookieHeader: "provider=google; auth=test",
+            timeout: 2,
+            workspaceIDOverride: "https://opencode.ai/workspace/wrk_TEST123/go",
+            session: self.makeSession())
+
+        #expect(balance == 98.76)
+        #expect(observedCookie == "auth=test")
+    }
+
+    @Test
+    func `optional zen balance failure does not fail subscription usage`() async throws {
+        defer {
+            OpenCodeGoStubURLProtocol.handler = nil
+        }
+
+        var rootTimeout: TimeInterval?
+        OpenCodeGoStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            if url.path == "/workspace/wrk_TEST123" {
+                rootTimeout = request.timeoutInterval
+                throw URLError(.timedOut)
+            }
+            return Self.makeResponse(
+                url: url,
+                body: Self.goUsagePageHTML(
+                    workspaceID: "wrk_TEST123",
+                    rolling: UsageWindow(percent: 17, resetInSec: 600),
+                    weekly: UsageWindow(percent: 75, resetInSec: 7200),
+                    monthly: nil),
+                statusCode: 200,
+                contentType: "text/html")
+        }
+
+        let snapshot = try await OpenCodeGoUsageFetcher.fetchUsage(
+            cookieHeader: "auth=test",
+            timeout: 60,
+            workspaceIDOverride: "wrk_TEST123",
+            session: self.makeSession())
+
+        #expect(snapshot.rollingUsagePercent == 17)
+        #expect(snapshot.zenBalanceUSD == nil)
+        #expect(rootTimeout == 60)
+    }
+
+    @Test
+    func `optional zen balance does not stall subscription usage`() async throws {
+        defer {
+            OpenCodeGoStubURLProtocol.handler = nil
+        }
+
+        OpenCodeGoStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            if url.path == "/workspace/wrk_TEST123" {
+                Thread.sleep(forTimeInterval: 1)
+                return Self.makeResponse(
+                    url: url,
+                    body: #"<html><body><h2>現在の残高 $98.76</h2></body></html>"#,
+                    statusCode: 200,
+                    contentType: "text/html")
+            }
+            return Self.makeResponse(
+                url: url,
+                body: Self.goUsagePageHTML(
+                    workspaceID: "wrk_TEST123",
+                    rolling: UsageWindow(percent: 17, resetInSec: 600),
+                    weekly: UsageWindow(percent: 75, resetInSec: 7200),
+                    monthly: nil),
+                statusCode: 200,
+                contentType: "text/html")
+        }
+
+        let start = ContinuousClock.now
+        let snapshot = try await OpenCodeGoUsageFetcher.fetchUsage(
+            cookieHeader: "auth=test",
+            timeout: 60,
+            workspaceIDOverride: "wrk_TEST123",
+            session: self.makeSession())
+        let elapsed = start.duration(to: ContinuousClock.now)
+
+        #expect(snapshot.rollingUsagePercent == 17)
+        #expect(snapshot.zenBalanceUSD == nil)
+        #expect(elapsed < .milliseconds(700))
+    }
+
+    @Test
+    func `optional zen balance can be skipped by settings`() async throws {
+        defer {
+            OpenCodeGoStubURLProtocol.handler = nil
+        }
+
+        var observedPaths: [String] = []
+        OpenCodeGoStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            observedPaths.append(url.path)
+            return Self.makeResponse(
+                url: url,
+                body: Self.goUsagePageHTML(
+                    workspaceID: "wrk_TEST123",
+                    rolling: UsageWindow(percent: 17, resetInSec: 600),
+                    weekly: UsageWindow(percent: 75, resetInSec: 7200),
+                    monthly: nil),
+                statusCode: 200,
+                contentType: "text/html")
+        }
+
+        let snapshot = try await OpenCodeGoUsageFetcher.fetchUsage(
+            cookieHeader: "auth=test",
+            timeout: 60,
+            workspaceIDOverride: "wrk_TEST123",
+            includeZenBalance: false,
+            session: self.makeSession())
+
+        #expect(snapshot.rollingUsagePercent == 17)
+        #expect(snapshot.zenBalanceUSD == nil)
+        #expect(observedPaths == ["/workspace/wrk_TEST123/go"])
+    }
+
+    @Test
+    func `optional zen balance cancellation propagates`() async throws {
+        defer {
+            OpenCodeGoStubURLProtocol.handler = nil
+        }
+
+        let rootStarted = AsyncStream<Void>.makeStream(of: Void.self)
+        OpenCodeGoStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            if url.path == "/workspace/wrk_TEST123" {
+                rootStarted.continuation.yield(())
+                Thread.sleep(forTimeInterval: 0.2)
+                return Self.makeResponse(
+                    url: url,
+                    body: #"<html><body><h2>現在の残高 $98.76</h2></body></html>"#,
+                    statusCode: 200,
+                    contentType: "text/html")
+            }
+            return Self.makeResponse(
+                url: url,
+                body: Self.goUsagePageHTML(
+                    workspaceID: "wrk_TEST123",
+                    rolling: UsageWindow(percent: 17, resetInSec: 600),
+                    weekly: UsageWindow(percent: 75, resetInSec: 7200),
+                    monthly: nil),
+                statusCode: 200,
+                contentType: "text/html")
+        }
+
+        let task = Task {
+            try await OpenCodeGoUsageFetcher.fetchUsage(
+                cookieHeader: "auth=test",
+                timeout: 60,
+                workspaceIDOverride: "wrk_TEST123",
+                session: self.makeSession())
+        }
+
+        let started = await withTaskGroup(of: Bool.self) { group in
+            group.addTask {
+                var iterator = rootStarted.stream.makeAsyncIterator()
+                return await iterator.next() != nil
+            }
+            group.addTask {
+                try? await Task.sleep(for: .seconds(2))
+                return false
+            }
+            let result = await group.next() ?? false
+            group.cancelAll()
+            return result
+        }
+        #expect(started)
+        task.cancel()
+
+        do {
+            _ = try await task.value
+            Issue.record("Expected cancellation to propagate.")
+        } catch is CancellationError {
+            // Expected.
+        } catch {
+            Issue.record("Expected CancellationError, got: \(error)")
+        }
+    }
+
+    @Test
+    func `fetcher sends only auth cookie to opencode host`() async throws {
+        defer {
+            OpenCodeGoStubURLProtocol.handler = nil
+        }
+
+        var observedCookie: String?
+        OpenCodeGoStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            observedCookie = request.value(forHTTPHeaderField: "Cookie")
+            return Self.makeResponse(
+                url: url,
+                body: Self.goUsagePageHTML(
+                    workspaceID: "wrk_TEST123",
+                    rolling: UsageWindow(percent: 17, resetInSec: 600),
+                    weekly: UsageWindow(percent: 75, resetInSec: 7200),
+                    monthly: nil),
+                statusCode: 200,
+                contentType: "text/html")
+        }
+
+        _ = try await OpenCodeGoUsageFetcher.fetchUsage(
+            cookieHeader: "provider=google; auth=test",
+            timeout: 2,
+            workspaceIDOverride: "wrk_TEST123",
+            session: self.makeSession())
+
+        #expect(observedCookie == "auth=test")
+    }
+
+    private static func goUsagePageHTML(
+        workspaceID: String,
+        rolling: UsageWindow,
+        weekly: UsageWindow,
+        monthly: UsageWindow?) -> String
+    {
+        let monthlyField: String? = if let monthly {
+            #"monthlyUsage:{status:"ok",resetInSec:\#(monthly.resetInSec),usagePercent:\#(monthly.percent)}"#
+        } else {
+            nil
+        }
+
+        let usageFields = [
+            #"rollingUsage:{status:"ok",resetInSec:\#(rolling.resetInSec),usagePercent:\#(rolling.percent)}"#,
+            #"weeklyUsage:{status:"ok",resetInSec:\#(weekly.resetInSec),usagePercent:\#(weekly.percent)}"#,
+            monthlyField,
+        ]
+            .compactMap(\.self)
+            .joined(separator: ",")
+
+        return """
+        <!DOCTYPE html>
+        <html>
+        <body>
+        <script>
+        _$HY.r["lite.subscription.get[\\"\(workspaceID)\\"]"]=$R[17]=$R[2]($R[18]={p:0,s:0,f:0});
+        $R[24]($R[18],$R[27]={mine:!0,useBalance:!1,\(usageFields)});
+        </script>
+        </body>
+        </html>
+        """
+    }
+
+    private static func makeResponse(
+        url: URL,
+        body: String,
+        statusCode: Int,
+        contentType: String) -> (HTTPURLResponse, Data)
+    {
+        let response = HTTPURLResponse(
+            url: url,
+            statusCode: statusCode,
+            httpVersion: "HTTP/1.1",
+            headerFields: ["Content-Type": contentType])!
+        return (response, Data(body.utf8))
+    }
+}
+
+final class OpenCodeGoStubURLProtocol: URLProtocol {
+    nonisolated(unsafe) static var handler: ((URLRequest) throws -> (HTTPURLResponse, Data))?
+
+    override static func canInit(with request: URLRequest) -> Bool {
+        request.url?.host == "opencode.ai"
+    }
+
+    override static func canonicalRequest(for request: URLRequest) -> URLRequest {
+        request
+    }
+
+    override func startLoading() {
+        guard let handler = Self.handler else {
+            self.client?.urlProtocol(self, didFailWithError: URLError(.badServerResponse))
+            return
+        }
+        do {
+            let (response, data) = try handler(self.request)
+            self.client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
+            self.client?.urlProtocol(self, didLoad: data)
+            self.client?.urlProtocolDidFinishLoading(self)
+        } catch {
+            self.client?.urlProtocol(self, didFailWithError: error)
+        }
+    }
+
+    override func stopLoading() {}
+}
diff --git a/Tests/CodexBarTests/OpenCodeGoUsageParserTests.swift b/Tests/CodexBarTests/OpenCodeGoUsageParserTests.swift
new file mode 100644
index 0000000000..4676d80cd0
--- /dev/null
+++ b/Tests/CodexBarTests/OpenCodeGoUsageParserTests.swift
@@ -0,0 +1,470 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct OpenCodeGoUsageParserTests {
+    @Test
+    func `parses workspace ids`() {
+        let text = ";0x00000089;((self.$R=self.$R||{})[\"codexbar\"]=[]," +
+            "($R=>$R[0]=[$R[1]={id:\"wrk_01K6AR1ZET89H8NB691FQ2C2VB\",name:\"Default\",slug:null}])" +
+            "($R[\"codexbar\"]))"
+        let ids = OpenCodeGoUsageFetcher.parseWorkspaceIDs(text: text)
+        #expect(ids == ["wrk_01K6AR1ZET89H8NB691FQ2C2VB"])
+    }
+
+    @Test
+    func `parses subscription usage from seroval response`() throws {
+        let text =
+            "$R[16]($R[30],$R[41]={rollingUsage:$R[42]={status:\"ok\",resetInSec:5944,usagePercent:17}," +
+            "weeklyUsage:$R[43]={status:\"ok\",resetInSec:278201,usagePercent:75}," +
+            "monthlyUsage:$R[44]={status:\"ok\",resetInSec:880201,usagePercent:91}});"
+        let now = Date(timeIntervalSince1970: 0)
+
+        let snapshot = try OpenCodeGoUsageFetcher.parseSubscription(text: text, now: now)
+
+        #expect(snapshot.rollingUsagePercent == 17)
+        #expect(snapshot.weeklyUsagePercent == 75)
+        #expect(snapshot.hasMonthlyUsage == true)
+        #expect(snapshot.monthlyUsagePercent == 91)
+        #expect(snapshot.rollingResetInSec == 5944)
+        #expect(snapshot.weeklyResetInSec == 278_201)
+        #expect(snapshot.monthlyResetInSec == 880_201)
+    }
+
+    @Test
+    func `parses zen balance from workspace page text`() {
+        let text = """
+        <main>
+        <h2>現在の残高 $1,234.56</h2>
+        <p>Claude Opus and GPT-5 models enabled</p>
+        </main>
+        """
+
+        #expect(OpenCodeGoUsageFetcher.parseZenBalance(text: text) == 1234.56)
+    }
+
+    @Test
+    func `parses zen balance from nested JSON`() throws {
+        let payload: [String: Any] = [
+            "data": [
+                "billing": [
+                    "balanceEnabled": true,
+                    "zenBalance": "1,042.75",
+                ],
+            ],
+        ]
+        let data = try JSONSerialization.data(withJSONObject: payload)
+        let text = String(data: data, encoding: .utf8) ?? ""
+
+        #expect(OpenCodeGoUsageFetcher.parseZenBalance(text: text) == 1042.75)
+    }
+
+    @Test
+    func `parses scaled zen balance from billing server response`() {
+        let text =
+            #";0x00000120;((self.$R=self.$R||{})["server-fn:test"]=[],"# +
+            #"($R=>$R[0]=$R[1]={customerID:"cus_test",balance:$R[2]=2375000000,reload:!1})"# +
+            #"($R["server-fn:test"]))"#
+
+        #expect(OpenCodeGoZenBalanceParser.parseBillingServerResponse(text: text) == 23.75)
+    }
+
+    @Test
+    func `billing server parser ignores unrelated balance metadata`() {
+        let text = #"$R[0]={balanceEnabled:!0,balanceUpdatedAt:1800000000}"#
+
+        #expect(OpenCodeGoZenBalanceParser.parseBillingServerResponse(text: text) == nil)
+    }
+
+    @Test
+    func `billing server parser ignores balance when billing is disabled`() {
+        let text = #"$R[0]={customerID:null,balance:0,reload:!1}"#
+
+        #expect(OpenCodeGoZenBalanceParser.parseBillingServerResponse(text: text) == nil)
+    }
+
+    @Test
+    func `zen balance parser ignores metadata before amount`() throws {
+        let payload: [String: Any] = [
+            "data": [
+                "billing": [
+                    "balanceUpdatedAt": 1_800_000_000,
+                    "balanceRefreshInterval": 60,
+                    "zenBalance": "42.50",
+                ],
+            ],
+        ]
+        let data = try JSONSerialization.data(withJSONObject: payload)
+        let text = String(data: data, encoding: .utf8) ?? ""
+
+        #expect(OpenCodeGoUsageFetcher.parseZenBalance(text: text) == 42.50)
+    }
+
+    @Test
+    func `parses subscription usage from live go page hydration`() throws {
+        let rollingResetInSec = 17591
+        let weeklyResetInSec = 444_552
+        let monthlyResetInSec = 2_591_424
+        let text =
+            "_$HY.r[\"lite.subscription.get[\\\"wrk_LIVE123\\\"]\"]=$R[17]=$R[2]($R[18]={p:0,s:0,f:0});" +
+            "$R[24]($R[18],$R[27]={mine:!0,useBalance:!1," +
+            "rollingUsage:$R[28]={status:\"ok\",resetInSec:\(rollingResetInSec),usagePercent:0}," +
+            "weeklyUsage:$R[29]={status:\"ok\",resetInSec:\(weeklyResetInSec),usagePercent:0}," +
+            "monthlyUsage:$R[30]={status:\"ok\",resetInSec:\(monthlyResetInSec),usagePercent:0}});"
+        let now = Date(timeIntervalSince1970: 0)
+
+        let snapshot = try OpenCodeGoUsageFetcher.parseSubscription(text: text, now: now)
+
+        #expect(snapshot.rollingUsagePercent == 0)
+        #expect(snapshot.weeklyUsagePercent == 0)
+        #expect(snapshot.hasMonthlyUsage == true)
+        #expect(snapshot.monthlyUsagePercent == 0)
+        #expect(snapshot.rollingResetInSec == rollingResetInSec)
+        #expect(snapshot.weeklyResetInSec == weeklyResetInSec)
+        #expect(snapshot.monthlyResetInSec == monthlyResetInSec)
+    }
+
+    @Test
+    func `parses subscription from JSON with reset at and ratio percentages`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let rollingResetAt = now.addingTimeInterval(3600)
+        let monthlyResetAt = now.addingTimeInterval(86400)
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        let payload: [String: Any] = [
+            "usage": [
+                "rollingUsage": [
+                    "usagePercent": 0.25,
+                    "resetAt": formatter.string(from: rollingResetAt),
+                ],
+                "weeklyUsage": [
+                    "usagePercent": 75,
+                    "resetInSec": 7200,
+                ],
+                "monthlyUsage": [
+                    "usagePercent": 0.9,
+                    "resetAt": formatter.string(from: monthlyResetAt),
+                ],
+            ],
+        ]
+        let data = try JSONSerialization.data(withJSONObject: payload)
+        let text = String(data: data, encoding: .utf8) ?? ""
+
+        let snapshot = try OpenCodeGoUsageFetcher.parseSubscription(text: text, now: now)
+
+        #expect(snapshot.rollingUsagePercent == 25)
+        #expect(snapshot.weeklyUsagePercent == 75)
+        #expect(snapshot.hasMonthlyUsage == true)
+        #expect(snapshot.monthlyUsagePercent == 90)
+        #expect(snapshot.rollingResetInSec == 3600)
+        #expect(snapshot.weeklyResetInSec == 7200)
+        #expect(snapshot.monthlyResetInSec == 86400)
+    }
+
+    @Test
+    func `computes usage percent from totals and treats monthly as optional`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let payload: [String: Any] = [
+            "rollingUsage": [
+                "used": 25,
+                "limit": 100,
+                "resetInSec": 600,
+            ],
+            "weeklyUsage": [
+                "used": 50,
+                "limit": 200,
+                "resetInSec": 3600,
+            ],
+        ]
+        let data = try JSONSerialization.data(withJSONObject: payload)
+        let text = String(data: data, encoding: .utf8) ?? ""
+
+        let snapshot = try OpenCodeGoUsageFetcher.parseSubscription(text: text, now: now)
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(snapshot.rollingUsagePercent == 25)
+        #expect(snapshot.weeklyUsagePercent == 25)
+        #expect(snapshot.hasMonthlyUsage == false)
+        #expect(snapshot.monthlyUsagePercent == 0)
+        #expect(snapshot.monthlyResetInSec == 0)
+        #expect(usage.tertiary == nil)
+    }
+
+    @Test
+    func `snapshot exposes zen balance as provider cost`() {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let snapshot = OpenCodeGoUsageSnapshot(
+            hasMonthlyUsage: false,
+            rollingUsagePercent: 10,
+            weeklyUsagePercent: 20,
+            monthlyUsagePercent: 0,
+            rollingResetInSec: 600,
+            weeklyResetInSec: 3600,
+            monthlyResetInSec: 0,
+            zenBalanceUSD: 12.34,
+            updatedAt: now)
+
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.providerCost?.period == "Zen balance")
+        #expect(usage.providerCost?.used == 12.34)
+        #expect(usage.providerCost?.limit == 0)
+        #expect(usage.providerCost?.currencyCode == "USD")
+    }
+
+    @Test
+    func `zen balance parser ignores balance flags without amounts`() throws {
+        let payload: [String: Any] = [
+            "billing": [
+                "balanceEnabled": true,
+                "useBalance": false,
+            ],
+        ]
+        let data = try JSONSerialization.data(withJSONObject: payload)
+        let text = String(data: data, encoding: .utf8) ?? ""
+
+        #expect(OpenCodeGoUsageFetcher.parseZenBalance(text: text) == nil)
+    }
+
+    @Test
+    func `parses subscription from nested candidate windows`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let payload: [String: Any] = [
+            "windows": [
+                "primaryWindow": [
+                    "used": 15,
+                    "limit": 100,
+                    "resetInSec": 600,
+                ],
+                "weeklyQuota": [
+                    "used": 80,
+                    "limit": 200,
+                    "resetInSec": 7200,
+                ],
+                "monthlyBucket": [
+                    "used": 90,
+                    "limit": 300,
+                    "resetInSec": 86400,
+                ],
+            ],
+        ]
+        let data = try JSONSerialization.data(withJSONObject: payload)
+        let text = String(data: data, encoding: .utf8) ?? ""
+
+        let snapshot = try OpenCodeGoUsageFetcher.parseSubscription(text: text, now: now)
+
+        #expect(snapshot.rollingUsagePercent == 15)
+        #expect(snapshot.weeklyUsagePercent == 40)
+        #expect(snapshot.hasMonthlyUsage == true)
+        #expect(snapshot.monthlyUsagePercent == 30)
+        #expect(snapshot.monthlyResetInSec == 86400)
+    }
+
+    @Test
+    func `candidate fallback does not fabricate weekly from non weekly windows`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let payload: [String: Any] = [
+            "windows": [
+                "primaryWindow": [
+                    "used": 15,
+                    "limit": 100,
+                    "resetInSec": 600,
+                ],
+                "monthlyBucket": [
+                    "used": 90,
+                    "limit": 300,
+                    "resetInSec": 86400,
+                ],
+            ],
+        ]
+        let data = try JSONSerialization.data(withJSONObject: payload)
+        let text = String(data: data, encoding: .utf8) ?? ""
+
+        #expect(throws: OpenCodeGoUsageError.self) {
+            _ = try OpenCodeGoUsageFetcher.parseSubscription(text: text, now: now)
+        }
+    }
+
+    @Test
+    func `clamps invalid percentages`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let payload: [String: Any] = [
+            "rollingUsage": [
+                "usagePercent": 150,
+                "resetInSec": 60,
+            ],
+            "weeklyUsage": [
+                "usagePercent": -10,
+                "resetInSec": 120,
+            ],
+        ]
+        let data = try JSONSerialization.data(withJSONObject: payload)
+        let text = String(data: data, encoding: .utf8) ?? ""
+
+        let snapshot = try OpenCodeGoUsageFetcher.parseSubscription(text: text, now: now)
+
+        #expect(snapshot.rollingUsagePercent == 100)
+        #expect(snapshot.weeklyUsagePercent == 0)
+    }
+
+    @Test
+    func `parse subscription throws when required fields are missing`() {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let text = "{\"monthlyUsage\":{\"usagePercent\":50,\"resetInSec\":123}}"
+
+        #expect(throws: OpenCodeGoUsageError.self) {
+            _ = try OpenCodeGoUsageFetcher.parseSubscription(text: text, now: now)
+        }
+    }
+
+    @Test
+    func `renewsAt parses from ISO8601 renewAt key`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let renewAt = now.addingTimeInterval(86400 * 30)
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        let payload: [String: Any] = [
+            "rollingUsage": ["usagePercent": 10, "resetInSec": 600],
+            "weeklyUsage": ["usagePercent": 50, "resetInSec": 3600],
+            "monthlyUsage": ["usagePercent": 25, "resetInSec": 7200],
+            "renewAt": formatter.string(from: renewAt),
+        ]
+        let data = try JSONSerialization.data(withJSONObject: payload)
+        let text = String(data: data, encoding: .utf8) ?? ""
+
+        let snapshot = try OpenCodeGoUsageFetcher.parseSubscription(text: text, now: now)
+
+        #expect(snapshot.renewsAt != nil)
+        #expect(snapshot.renewsAt == renewAt)
+    }
+
+    @Test
+    func `renewsAt parses from renew_at key`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let renewAt = now.addingTimeInterval(86400 * 30)
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        let payload: [String: Any] = [
+            "rollingUsage": ["usagePercent": 10, "resetInSec": 600],
+            "weeklyUsage": ["usagePercent": 50, "resetInSec": 3600],
+            "monthlyUsage": ["usagePercent": 25, "resetInSec": 7200],
+            "renew_at": formatter.string(from: renewAt),
+        ]
+        let data = try JSONSerialization.data(withJSONObject: payload)
+        let text = String(data: data, encoding: .utf8) ?? ""
+
+        let snapshot = try OpenCodeGoUsageFetcher.parseSubscription(text: text, now: now)
+
+        #expect(snapshot.renewsAt != nil)
+        #expect(snapshot.renewsAt == renewAt)
+    }
+
+    @Test
+    func `renewsAt is nil when absent`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let payload: [String: Any] = [
+            "rollingUsage": ["usagePercent": 10, "resetInSec": 600],
+            "weeklyUsage": ["usagePercent": 50, "resetInSec": 3600],
+            "monthlyUsage": ["usagePercent": 25, "resetInSec": 7200],
+        ]
+        let data = try JSONSerialization.data(withJSONObject: payload)
+        let text = String(data: data, encoding: .utf8) ?? ""
+
+        let snapshot = try OpenCodeGoUsageFetcher.parseSubscription(text: text, now: now)
+
+        #expect(snapshot.renewsAt == nil)
+    }
+
+    @Test
+    func `top level renewAt is preserved for nested usage object`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let renewAt = now.addingTimeInterval(86400 * 30)
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        let payload: [String: Any] = [
+            "renewAt": formatter.string(from: renewAt),
+            "usage": [
+                "rollingUsage": ["usagePercent": 10, "resetInSec": 600],
+                "weeklyUsage": ["usagePercent": 50, "resetInSec": 3600],
+                "monthlyUsage": ["usagePercent": 25, "resetInSec": 7200],
+            ],
+        ]
+        let data = try JSONSerialization.data(withJSONObject: payload)
+        let text = String(data: data, encoding: .utf8) ?? ""
+
+        let snapshot = try OpenCodeGoUsageFetcher.parseSubscription(text: text, now: now)
+
+        #expect(snapshot.renewsAt == renewAt)
+    }
+
+    @Test
+    func `top level renew_at is preserved for nested usage object`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let renewAt = now.addingTimeInterval(86400 * 30)
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        let payload: [String: Any] = [
+            "renew_at": formatter.string(from: renewAt),
+            "usage": [
+                "rollingUsage": ["usagePercent": 10, "resetInSec": 600],
+                "weeklyUsage": ["usagePercent": 50, "resetInSec": 3600],
+                "monthlyUsage": ["usagePercent": 25, "resetInSec": 7200],
+            ],
+        ]
+        let data = try JSONSerialization.data(withJSONObject: payload)
+        let text = String(data: data, encoding: .utf8) ?? ""
+
+        let snapshot = try OpenCodeGoUsageFetcher.parseSubscription(text: text, now: now)
+
+        #expect(snapshot.renewsAt == renewAt)
+    }
+
+    @Test
+    func `child renewAt overrides parent renewAt`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let parentRenewAt = now.addingTimeInterval(86400 * 30)
+        let childRenewAt = now.addingTimeInterval(86400 * 45)
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        let payload: [String: Any] = [
+            "renewAt": formatter.string(from: parentRenewAt),
+            "usage": [
+                "renewAt": formatter.string(from: childRenewAt),
+                "rollingUsage": ["usagePercent": 10, "resetInSec": 600],
+                "weeklyUsage": ["usagePercent": 50, "resetInSec": 3600],
+                "monthlyUsage": ["usagePercent": 25, "resetInSec": 7200],
+            ],
+        ]
+        let data = try JSONSerialization.data(withJSONObject: payload)
+        let text = String(data: data, encoding: .utf8) ?? ""
+
+        let snapshot = try OpenCodeGoUsageFetcher.parseSubscription(text: text, now: now)
+
+        #expect(snapshot.renewsAt == childRenewAt)
+    }
+
+    @Test
+    func `toUsageSnapshot includes renewal NamedRateWindow when renewsAt present`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let renewAt = now.addingTimeInterval(86400 * 30)
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        let payload: [String: Any] = [
+            "rollingUsage": ["usagePercent": 10, "resetInSec": 600],
+            "weeklyUsage": ["usagePercent": 50, "resetInSec": 3600],
+            "monthlyUsage": ["usagePercent": 25, "resetInSec": 7200],
+            "renewAt": formatter.string(from: renewAt),
+        ]
+        let data = try JSONSerialization.data(withJSONObject: payload)
+        let text = String(data: data, encoding: .utf8) ?? ""
+
+        let snapshot = try OpenCodeGoUsageFetcher.parseSubscription(text: text, now: now)
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.extraRateWindows != nil)
+        #expect(usage.extraRateWindows?.count == 1)
+        #expect(usage.extraRateWindows?[0].id == "renewal")
+        #expect(usage.extraRateWindows?[0].title == "Renews")
+        #expect(usage.extraRateWindows?[0].window.resetsAt == renewAt)
+    }
+}
diff --git a/Tests/CodexBarTests/OpenCodeUsageFetcherErrorTests.swift b/Tests/CodexBarTests/OpenCodeUsageFetcherErrorTests.swift
index d64ffb06bf..c934d35205 100644
--- a/Tests/CodexBarTests/OpenCodeUsageFetcherErrorTests.swift
+++ b/Tests/CodexBarTests/OpenCodeUsageFetcherErrorTests.swift
@@ -4,13 +4,15 @@ import Testing
 
 @Suite(.serialized)
 struct OpenCodeUsageFetcherErrorTests {
+    private func makeSession() -> URLSession {
+        let config = URLSessionConfiguration.ephemeral
+        config.protocolClasses = [OpenCodeStubURLProtocol.self]
+        return URLSession(configuration: config)
+    }
+
     @Test
-    func extractsApiErrorFromUppercaseHTMLTitle() async throws {
-        let registered = URLProtocol.registerClass(OpenCodeStubURLProtocol.self)
+    func `extracts api error from uppercase HTML title`() async throws {
         defer {
-            if registered {
-                URLProtocol.unregisterClass(OpenCodeStubURLProtocol.self)
-            }
             OpenCodeStubURLProtocol.handler = nil
         }
 
@@ -24,7 +26,8 @@ struct OpenCodeUsageFetcherErrorTests {
             _ = try await OpenCodeUsageFetcher.fetchUsage(
                 cookieHeader: "auth=test",
                 timeout: 2,
-                workspaceIDOverride: "wrk_TEST123")
+                workspaceIDOverride: "wrk_TEST123",
+                session: self.makeSession())
             Issue.record("Expected OpenCodeUsageError.apiError")
         } catch let error as OpenCodeUsageError {
             switch error {
@@ -38,12 +41,8 @@ struct OpenCodeUsageFetcherErrorTests {
     }
 
     @Test
-    func extractsApiErrorFromDetailField() async throws {
-        let registered = URLProtocol.registerClass(OpenCodeStubURLProtocol.self)
+    func `extracts api error from detail field`() async throws {
         defer {
-            if registered {
-                URLProtocol.unregisterClass(OpenCodeStubURLProtocol.self)
-            }
             OpenCodeStubURLProtocol.handler = nil
         }
 
@@ -57,7 +56,8 @@ struct OpenCodeUsageFetcherErrorTests {
             _ = try await OpenCodeUsageFetcher.fetchUsage(
                 cookieHeader: "auth=test",
                 timeout: 2,
-                workspaceIDOverride: "wrk_TEST123")
+                workspaceIDOverride: "wrk_TEST123",
+                session: self.makeSession())
             Issue.record("Expected OpenCodeUsageError.apiError")
         } catch let error as OpenCodeUsageError {
             switch error {
@@ -71,12 +71,8 @@ struct OpenCodeUsageFetcherErrorTests {
     }
 
     @Test
-    func subscriptionGetNullSkipsPostAndReturnsGracefulError() async throws {
-        let registered = URLProtocol.registerClass(OpenCodeStubURLProtocol.self)
+    func `subscription get null skips post and returns graceful error`() async throws {
         defer {
-            if registered {
-                URLProtocol.unregisterClass(OpenCodeStubURLProtocol.self)
-            }
             OpenCodeStubURLProtocol.handler = nil
         }
 
@@ -103,7 +99,8 @@ struct OpenCodeUsageFetcherErrorTests {
             _ = try await OpenCodeUsageFetcher.fetchUsage(
                 cookieHeader: "auth=test",
                 timeout: 2,
-                workspaceIDOverride: "wrk_TEST123")
+                workspaceIDOverride: "wrk_TEST123",
+                session: self.makeSession())
             Issue.record("Expected OpenCodeUsageError.apiError")
         } catch let error as OpenCodeUsageError {
             switch error {
@@ -123,12 +120,8 @@ struct OpenCodeUsageFetcherErrorTests {
     }
 
     @Test
-    func subscriptionGetPayloadDoesNotFallbackToPost() async throws {
-        let registered = URLProtocol.registerClass(OpenCodeStubURLProtocol.self)
+    func `subscription get payload does not fallback to post`() async throws {
         defer {
-            if registered {
-                URLProtocol.unregisterClass(OpenCodeStubURLProtocol.self)
-            }
             OpenCodeStubURLProtocol.handler = nil
         }
 
@@ -149,7 +142,8 @@ struct OpenCodeUsageFetcherErrorTests {
         let snapshot = try await OpenCodeUsageFetcher.fetchUsage(
             cookieHeader: "auth=test",
             timeout: 2,
-            workspaceIDOverride: "wrk_TEST123")
+            workspaceIDOverride: "wrk_TEST123",
+            session: self.makeSession())
 
         #expect(snapshot.rollingUsagePercent == 17)
         #expect(snapshot.weeklyUsagePercent == 75)
@@ -157,12 +151,49 @@ struct OpenCodeUsageFetcherErrorTests {
     }
 
     @Test
-    func subscriptionGetMissingFieldsFallsBackToPost() async throws {
-        let registered = URLProtocol.registerClass(OpenCodeStubURLProtocol.self)
+    func `workspace get public actor error is treated as invalid credentials without post retry`() async throws {
         defer {
-            if registered {
-                URLProtocol.unregisterClass(OpenCodeStubURLProtocol.self)
+            OpenCodeStubURLProtocol.handler = nil
+        }
+
+        var methods: [String] = []
+        OpenCodeStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            methods.append(request.httpMethod ?? "GET")
+            let body = [
+                #";0x00000263;((self.$R=self.$R||{})["server-fn:test"]=[],"#,
+                #"($R=>$R[0]=Object.assign(new Error("actor of type \"public\" is not associated with an account"),"#,
+                #"{stack:"Error: actor of type \"public\" is not associated with an account"}))"#,
+                #"($R["server-fn:test"]))"#,
+            ].joined()
+            return Self.makeResponse(
+                url: url,
+                body: body,
+                statusCode: 200,
+                contentType: "text/javascript")
+        }
+
+        do {
+            _ = try await OpenCodeUsageFetcher.fetchUsage(
+                cookieHeader: "auth=test",
+                timeout: 2,
+                session: self.makeSession())
+            Issue.record("Expected OpenCodeUsageError.invalidCredentials")
+        } catch let error as OpenCodeUsageError {
+            switch error {
+            case .invalidCredentials:
+                break
+            default:
+                Issue.record("Expected invalidCredentials, got: \(error)")
             }
+        }
+
+        #expect(methods == ["GET"])
+    }
+
+    @Test
+    func `subscription get missing fields falls back to post`() async throws {
+        defer {
             OpenCodeStubURLProtocol.handler = nil
         }
 
@@ -195,13 +226,43 @@ struct OpenCodeUsageFetcherErrorTests {
         let snapshot = try await OpenCodeUsageFetcher.fetchUsage(
             cookieHeader: "auth=test",
             timeout: 2,
-            workspaceIDOverride: "wrk_TEST123")
+            workspaceIDOverride: "wrk_TEST123",
+            session: self.makeSession())
 
         #expect(snapshot.rollingUsagePercent == 22)
         #expect(snapshot.weeklyUsagePercent == 44)
         #expect(methods == ["GET", "POST"])
     }
 
+    @Test
+    func `fetcher sends only auth cookie to opencode host`() async throws {
+        defer {
+            OpenCodeStubURLProtocol.handler = nil
+        }
+
+        var observedCookie: String?
+        OpenCodeStubURLProtocol.handler = { request in
+            guard let url = request.url else { throw URLError(.badURL) }
+            observedCookie = request.value(forHTTPHeaderField: "Cookie")
+
+            let body = """
+            {
+              "rollingUsage": { "usagePercent": 17, "resetInSec": 600 },
+              "weeklyUsage": { "usagePercent": 75, "resetInSec": 7200 }
+            }
+            """
+            return Self.makeResponse(url: url, body: body, statusCode: 200, contentType: "application/json")
+        }
+
+        _ = try await OpenCodeUsageFetcher.fetchUsage(
+            cookieHeader: "provider=google; auth=test",
+            timeout: 2,
+            workspaceIDOverride: "wrk_TEST123",
+            session: self.makeSession())
+
+        #expect(observedCookie == "auth=test")
+    }
+
     private static func makeResponse(
         url: URL,
         body: String,
diff --git a/Tests/CodexBarTests/OpenCodeUsageParserTests.swift b/Tests/CodexBarTests/OpenCodeUsageParserTests.swift
index fe7e1a345a..ab7359cb19 100644
--- a/Tests/CodexBarTests/OpenCodeUsageParserTests.swift
+++ b/Tests/CodexBarTests/OpenCodeUsageParserTests.swift
@@ -2,10 +2,9 @@ import Foundation
 import Testing
 @testable import CodexBarCore
 
-@Suite
 struct OpenCodeUsageParserTests {
     @Test
-    func parsesWorkspaceIDs() {
+    func `parses workspace I ds`() {
         let text = ";0x00000089;((self.$R=self.$R||{})[\"codexbar\"]=[]," +
             "($R=>$R[0]=[$R[1]={id:\"wrk_01K6AR1ZET89H8NB691FQ2C2VB\",name:\"Default\",slug:null}])" +
             "($R[\"codexbar\"]))"
@@ -14,7 +13,7 @@ struct OpenCodeUsageParserTests {
     }
 
     @Test
-    func parsesSubscriptionUsage() throws {
+    func `parses subscription usage`() throws {
         let text = "$R[16]($R[30],$R[41]={rollingUsage:$R[42]={status:\"ok\",resetInSec:5944,usagePercent:17}," +
             "weeklyUsage:$R[43]={status:\"ok\",resetInSec:278201,usagePercent:75}});"
         let now = Date(timeIntervalSince1970: 0)
@@ -26,7 +25,7 @@ struct OpenCodeUsageParserTests {
     }
 
     @Test
-    func parsesSubscriptionFromJSONWithResetAt() throws {
+    func `parses subscription from JSON with reset at`() throws {
         let now = Date(timeIntervalSince1970: 1_700_000_000)
         let resetAt = now.addingTimeInterval(3600)
         let formatter = ISO8601DateFormatter()
@@ -55,7 +54,7 @@ struct OpenCodeUsageParserTests {
     }
 
     @Test
-    func parsesSubscriptionFromCandidateWindows() throws {
+    func `parses subscription from candidate windows`() throws {
         let now = Date(timeIntervalSince1970: 1_700_000_000)
         let payload: [String: Any] = [
             "windows": [
@@ -81,7 +80,7 @@ struct OpenCodeUsageParserTests {
     }
 
     @Test
-    func computesUsagePercentFromTotals() throws {
+    func `computes usage percent from totals`() throws {
         let now = Date(timeIntervalSince1970: 1_700_000_000)
         let payload: [String: Any] = [
             "rollingUsage": [
@@ -105,7 +104,7 @@ struct OpenCodeUsageParserTests {
     }
 
     @Test
-    func parseSubscriptionThrowsWhenFieldsMissing() {
+    func `parse subscription throws when fields missing`() {
         let now = Date(timeIntervalSince1970: 1_700_000_000)
         let text = "{\"ok\":true}"
 
@@ -113,4 +112,148 @@ struct OpenCodeUsageParserTests {
             _ = try OpenCodeUsageFetcher.parseSubscription(text: text, now: now)
         }
     }
+
+    @Test
+    func `renewsAt parses from ISO8601 renewAt key`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let renewAt = now.addingTimeInterval(86400 * 30)
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        let payload: [String: Any] = [
+            "rollingUsage": ["usagePercent": 10, "resetInSec": 600],
+            "weeklyUsage": ["usagePercent": 50, "resetInSec": 3600],
+            "renewAt": formatter.string(from: renewAt),
+        ]
+        let data = try JSONSerialization.data(withJSONObject: payload)
+        let text = String(data: data, encoding: .utf8) ?? ""
+
+        let snapshot = try OpenCodeUsageFetcher.parseSubscription(text: text, now: now)
+
+        #expect(snapshot.renewsAt != nil)
+        #expect(snapshot.renewsAt == renewAt)
+    }
+
+    @Test
+    func `renewsAt parses from renew_at key`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let renewAt = now.addingTimeInterval(86400 * 30)
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        let payload: [String: Any] = [
+            "rollingUsage": ["usagePercent": 10, "resetInSec": 600],
+            "weeklyUsage": ["usagePercent": 50, "resetInSec": 3600],
+            "renew_at": formatter.string(from: renewAt),
+        ]
+        let data = try JSONSerialization.data(withJSONObject: payload)
+        let text = String(data: data, encoding: .utf8) ?? ""
+
+        let snapshot = try OpenCodeUsageFetcher.parseSubscription(text: text, now: now)
+
+        #expect(snapshot.renewsAt != nil)
+        #expect(snapshot.renewsAt == renewAt)
+    }
+
+    @Test
+    func `renewsAt is nil when absent`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let payload: [String: Any] = [
+            "rollingUsage": ["usagePercent": 10, "resetInSec": 600],
+            "weeklyUsage": ["usagePercent": 50, "resetInSec": 3600],
+        ]
+        let data = try JSONSerialization.data(withJSONObject: payload)
+        let text = String(data: data, encoding: .utf8) ?? ""
+
+        let snapshot = try OpenCodeUsageFetcher.parseSubscription(text: text, now: now)
+
+        #expect(snapshot.renewsAt == nil)
+    }
+
+    @Test
+    func `top level renewAt is preserved for nested usage object`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let renewAt = now.addingTimeInterval(86400 * 30)
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        let payload: [String: Any] = [
+            "renewAt": formatter.string(from: renewAt),
+            "usage": [
+                "rollingUsage": ["usagePercent": 10, "resetInSec": 600],
+                "weeklyUsage": ["usagePercent": 50, "resetInSec": 3600],
+            ],
+        ]
+        let data = try JSONSerialization.data(withJSONObject: payload)
+        let text = String(data: data, encoding: .utf8) ?? ""
+
+        let snapshot = try OpenCodeUsageFetcher.parseSubscription(text: text, now: now)
+
+        #expect(snapshot.renewsAt == renewAt)
+    }
+
+    @Test
+    func `top level renew_at is preserved for nested usage object`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let renewAt = now.addingTimeInterval(86400 * 30)
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        let payload: [String: Any] = [
+            "renew_at": formatter.string(from: renewAt),
+            "usage": [
+                "rollingUsage": ["usagePercent": 10, "resetInSec": 600],
+                "weeklyUsage": ["usagePercent": 50, "resetInSec": 3600],
+            ],
+        ]
+        let data = try JSONSerialization.data(withJSONObject: payload)
+        let text = String(data: data, encoding: .utf8) ?? ""
+
+        let snapshot = try OpenCodeUsageFetcher.parseSubscription(text: text, now: now)
+
+        #expect(snapshot.renewsAt == renewAt)
+    }
+
+    @Test
+    func `child renewAt overrides parent renewAt`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let parentRenewAt = now.addingTimeInterval(86400 * 30)
+        let childRenewAt = now.addingTimeInterval(86400 * 45)
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        let payload: [String: Any] = [
+            "renewAt": formatter.string(from: parentRenewAt),
+            "usage": [
+                "renewAt": formatter.string(from: childRenewAt),
+                "rollingUsage": ["usagePercent": 10, "resetInSec": 600],
+                "weeklyUsage": ["usagePercent": 50, "resetInSec": 3600],
+            ],
+        ]
+        let data = try JSONSerialization.data(withJSONObject: payload)
+        let text = String(data: data, encoding: .utf8) ?? ""
+
+        let snapshot = try OpenCodeUsageFetcher.parseSubscription(text: text, now: now)
+
+        #expect(snapshot.renewsAt == childRenewAt)
+    }
+
+    @Test
+    func `toUsageSnapshot includes renewal NamedRateWindow when renewsAt present`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let renewAt = now.addingTimeInterval(86400 * 30)
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        let payload: [String: Any] = [
+            "rollingUsage": ["usagePercent": 10, "resetInSec": 600],
+            "weeklyUsage": ["usagePercent": 50, "resetInSec": 3600],
+            "renewAt": formatter.string(from: renewAt),
+        ]
+        let data = try JSONSerialization.data(withJSONObject: payload)
+        let text = String(data: data, encoding: .utf8) ?? ""
+
+        let snapshot = try OpenCodeUsageFetcher.parseSubscription(text: text, now: now)
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.extraRateWindows != nil)
+        #expect(usage.extraRateWindows?.count == 1)
+        #expect(usage.extraRateWindows?[0].id == "renewal")
+        #expect(usage.extraRateWindows?[0].title == "Renews")
+        #expect(usage.extraRateWindows?[0].window.resetsAt == renewAt)
+    }
 }
diff --git a/Tests/CodexBarTests/OpenCodeWebCookieSupportTests.swift b/Tests/CodexBarTests/OpenCodeWebCookieSupportTests.swift
new file mode 100644
index 0000000000..be73d4e50c
--- /dev/null
+++ b/Tests/CodexBarTests/OpenCodeWebCookieSupportTests.swift
@@ -0,0 +1,19 @@
+import Testing
+@testable import CodexBarCore
+
+struct OpenCodeWebCookieSupportTests {
+    @Test
+    func `request cookie header keeps only opencode auth cookies`() {
+        let header = OpenCodeWebCookieSupport.requestCookieHeader(
+            from: "provider=google; auth=session123; theme=dark; __Host-auth=host456")
+
+        #expect(header == "auth=session123; __Host-auth=host456")
+    }
+
+    @Test
+    func `request cookie header returns nil when auth cookie is missing`() {
+        let header = OpenCodeWebCookieSupport.requestCookieHeader(from: "provider=google; theme=dark")
+
+        #expect(header == nil)
+    }
+}
diff --git a/Tests/CodexBarTests/OpenRouterUsageStatsTests.swift b/Tests/CodexBarTests/OpenRouterUsageStatsTests.swift
index 25ec01bcf1..b06015e6e4 100644
--- a/Tests/CodexBarTests/OpenRouterUsageStatsTests.swift
+++ b/Tests/CodexBarTests/OpenRouterUsageStatsTests.swift
@@ -5,7 +5,7 @@ import Testing
 @Suite(.serialized)
 struct OpenRouterUsageStatsTests {
     @Test
-    func toUsageSnapshot_usesKeyQuotaForPrimaryWindow() {
+    func `to usage snapshot uses key quota for primary window`() {
         let snapshot = OpenRouterUsageSnapshot(
             totalCredits: 50,
             totalUsage: 45.3895596325,
@@ -25,7 +25,7 @@ struct OpenRouterUsageStatsTests {
     }
 
     @Test
-    func toUsageSnapshot_withoutValidKeyLimitOmitsPrimaryWindow() {
+    func `to usage snapshot without valid key limit omits primary window`() {
         let snapshot = OpenRouterUsageSnapshot(
             totalCredits: 50,
             totalUsage: 45.3895596325,
@@ -43,7 +43,7 @@ struct OpenRouterUsageStatsTests {
     }
 
     @Test
-    func toUsageSnapshot_whenNoLimitConfiguredOmitsPrimaryAndMarksNoLimit() {
+    func `to usage snapshot when no limit configured omits primary and marks no limit`() {
         let snapshot = OpenRouterUsageSnapshot(
             totalCredits: 50,
             totalUsage: 45.3895596325,
@@ -62,7 +62,7 @@ struct OpenRouterUsageStatsTests {
     }
 
     @Test
-    func sanitizers_redactSensitiveTokenShapes() {
+    func `sanitizers redact sensitive token shapes`() {
         let body = """
         {"error":"bad token sk-or-v1-abc123","token":"secret-token","authorization":"Bearer sk-or-v1-xyz789"}
         """
@@ -82,7 +82,7 @@ struct OpenRouterUsageStatsTests {
     }
 
     @Test
-    func non200FetchThrowsGenericHTTPErrorWithoutBodyDetails() async throws {
+    func `non200 fetch throws generic HTTP error without body details`() async throws {
         let registered = URLProtocol.registerClass(OpenRouterStubURLProtocol.self)
         defer {
             if registered {
@@ -114,7 +114,7 @@ struct OpenRouterUsageStatsTests {
     }
 
     @Test
-    func fetchUsage_setsCreditsTimeoutAndClientHeaders() async throws {
+    func `fetch usage sets credits timeout and client headers`() async throws {
         let registered = URLProtocol.registerClass(OpenRouterStubURLProtocol.self)
         defer {
             if registered {
@@ -133,7 +133,16 @@ struct OpenRouterUsageStatsTests {
                 let body = #"{"data":{"total_credits":100,"total_usage":40}}"#
                 return Self.makeResponse(url: url, body: body, statusCode: 200)
             case "/api/v1/key":
-                let body = #"{"data":{"limit":20,"usage":0.5,"rate_limit":{"requests":120,"interval":"10s"}}}"#
+                let body = #"""
+                {"data":{
+                  "limit":20,
+                  "usage":0.5,
+                  "usage_daily":0.12,
+                  "usage_weekly":0.74,
+                  "usage_monthly":4.56,
+                  "rate_limit":{"requests":120,"interval":"10s"}
+                }}
+                """#
                 return Self.makeResponse(url: url, body: body, statusCode: 200)
             default:
                 return Self.makeResponse(url: url, body: "{}", statusCode: 404)
@@ -153,13 +162,16 @@ struct OpenRouterUsageStatsTests {
         #expect(usage.keyDataFetched)
         #expect(usage.keyLimit == 20)
         #expect(usage.keyUsage == 0.5)
+        #expect(usage.keyUsageDaily == 0.12)
+        #expect(usage.keyUsageWeekly == 0.74)
+        #expect(usage.keyUsageMonthly == 4.56)
         #expect(usage.keyRemaining == 19.5)
         #expect(usage.keyUsedPercent == 2.5)
         #expect(usage.keyQuotaStatus == .available)
     }
 
     @Test
-    func fetchUsage_whenKeyEndpointFailsMarksQuotaUnavailable() async throws {
+    func `fetch usage when key endpoint fails marks quota unavailable`() async throws {
         let registered = URLProtocol.registerClass(OpenRouterStubURLProtocol.self)
         defer {
             if registered {
@@ -190,7 +202,28 @@ struct OpenRouterUsageStatsTests {
     }
 
     @Test
-    func usageSnapshot_roundTripPersistsOpenRouterUsageMetadata() throws {
+    func `key enrichment timeout does not wait for operation that ignores cancellation`() async throws {
+        let startedAt = ContinuousClock.now
+
+        let fetched = try await OpenRouterUsageFetcher._boundedKeyFetchForTesting(
+            timeout: .milliseconds(20))
+        {
+            await withCheckedContinuation { continuation in
+                DispatchQueue.global().asyncAfter(deadline: .now() + 0.5) {
+                    continuation.resume()
+                }
+            }
+        }
+
+        let elapsed = startedAt.duration(to: .now)
+        #expect(!fetched)
+        #expect(elapsed < .milliseconds(300))
+
+        try await Task.sleep(for: .milliseconds(550))
+    }
+
+    @Test
+    func `usage snapshot round trip persists open router usage metadata`() throws {
         let openRouter = OpenRouterUsageSnapshot(
             totalCredits: 50,
             totalUsage: 45.3895596325,
@@ -199,6 +232,9 @@ struct OpenRouterUsageStatsTests {
             keyDataFetched: true,
             keyLimit: nil,
             keyUsage: nil,
+            keyUsageDaily: 0.12,
+            keyUsageWeekly: 0.74,
+            keyUsageMonthly: 4.56,
             rateLimit: nil,
             updatedAt: Date(timeIntervalSince1970: 1_739_841_600))
         let snapshot = openRouter.toUsageSnapshot()
@@ -209,6 +245,9 @@ struct OpenRouterUsageStatsTests {
 
         #expect(decoded.openRouterUsage?.keyDataFetched == true)
         #expect(decoded.openRouterUsage?.keyQuotaStatus == .noLimitConfigured)
+        #expect(decoded.openRouterUsage?.keyUsageDaily == 0.12)
+        #expect(decoded.openRouterUsage?.keyUsageWeekly == 0.74)
+        #expect(decoded.openRouterUsage?.keyUsageMonthly == 4.56)
     }
 
     private static func makeResponse(
diff --git a/Tests/CodexBarTests/PathBuilderTests.swift b/Tests/CodexBarTests/PathBuilderTests.swift
index 014dae6e00..a8172cbb34 100644
--- a/Tests/CodexBarTests/PathBuilderTests.swift
+++ b/Tests/CodexBarTests/PathBuilderTests.swift
@@ -1,12 +1,11 @@
-import CodexBarCore
 import Foundation
 import Testing
 @testable import CodexBar
+@testable import CodexBarCore
 
-@Suite
 struct PathBuilderTests {
     @Test
-    func mergesLoginShellPathWhenAvailable() {
+    func `merges login shell path when available`() {
         let seeded = PathBuilder.effectivePATH(
             purposes: [.rpc],
             env: ["PATH": "/custom/bin:/usr/bin"],
@@ -15,7 +14,7 @@ struct PathBuilderTests {
     }
 
     @Test
-    func fallsBackToExistingPathWhenNoLoginPath() {
+    func `falls back to existing path when no login path`() {
         let seeded = PathBuilder.effectivePATH(
             purposes: [.tty],
             env: ["PATH": "/custom/bin:/usr/bin"],
@@ -24,7 +23,7 @@ struct PathBuilderTests {
     }
 
     @Test
-    func usesFallbackWhenNoPathAvailable() {
+    func `uses fallback when no path available`() {
         let seeded = PathBuilder.effectivePATH(
             purposes: [.tty],
             env: [:],
@@ -33,7 +32,7 @@ struct PathBuilderTests {
     }
 
     @Test
-    func debugSnapshotAsyncMatchesSync() async {
+    func `debug snapshot async matches sync`() async {
         let env = [
             "CODEX_CLI_PATH": "/usr/bin/true",
             "CLAUDE_CLI_PATH": "/usr/bin/true",
@@ -46,7 +45,85 @@ struct PathBuilderTests {
     }
 
     @Test
-    func resolvesCodexFromEnvOverride() {
+    func `login shell cache retries after timed out nil capture`() async {
+        let capture = LoginShellPathCaptureStub([
+            nil,
+            ["/login/bin", "/usr/bin"],
+        ])
+
+        let cache = LoginShellPathCache { _, _ in capture.next() }
+        let firstResult: [String]? = await withCheckedContinuation { continuation in
+            cache.captureOnce(shell: "/unused", timeout: 0.01) { result in
+                continuation.resume(returning: result)
+            }
+        }
+
+        #expect(firstResult == nil)
+        #expect(cache.current == nil)
+
+        let recovered = cache.currentOrCapture(shell: "/unused", timeout: 2.0)
+        #expect(recovered == ["/login/bin", "/usr/bin"])
+        #expect(cache.current == ["/login/bin", "/usr/bin"])
+        #expect(capture.callCount == 2)
+    }
+
+    @Test
+    func `shell runner drains noisy stdout and stderr`() throws {
+        let script = """
+        i=0
+        while [ "$i" -lt 4000 ]; do
+          printf 'out-%04d\\n' "$i"
+          printf 'err-%04d\\n' "$i" >&2
+          i=$((i + 1))
+        done
+        printf '__CODEXBAR_DONE__\\n'
+        """
+        let data = try #require(ShellCommandLocator.test_runShellCommand(
+            shell: "/bin/sh",
+            arguments: ["-c", script],
+            timeout: 4.0))
+        let output = try #require(String(data: data, encoding: .utf8))
+
+        #expect(output.contains("out-3999"))
+        #expect(output.contains("__CODEXBAR_DONE__"))
+    }
+
+    @Test
+    func `shell runner terminates background children after normal exit`() throws {
+        let marker = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-shell-runner-\(UUID().uuidString)")
+            .path
+        let escapedMarker = Self.shellSingleQuoted(marker)
+        let script = """
+        (
+          trap '' TERM
+          touch \(escapedMarker)
+          while :; do sleep 1; done
+        ) &
+        printf '%s\\n' "$!"
+        """
+        let data = try #require(ShellCommandLocator.test_runShellCommand(
+            shell: "/bin/sh",
+            arguments: ["-c", script],
+            timeout: 2.0))
+        let pidText = try #require(String(data: data, encoding: .utf8)?.trimmingCharacters(in: .whitespacesAndNewlines))
+        let pid = try #require(pid_t(pidText))
+
+        defer {
+            kill(pid, SIGKILL)
+            try? FileManager.default.removeItem(atPath: marker)
+        }
+
+        let deadline = Date().addingTimeInterval(2.0)
+        while kill(pid, 0) == 0, Date() < deadline {
+            usleep(50000 as useconds_t)
+        }
+
+        #expect(kill(pid, 0) != 0)
+    }
+
+    @Test
+    func `resolves codex from env override`() {
         let overridePath = "/custom/bin/codex"
         let fm = MockFileManager(executables: [overridePath])
 
@@ -59,7 +136,7 @@ struct PathBuilderTests {
     }
 
     @Test
-    func resolvesCodexFromLoginPath() {
+    func `resolves codex from login path`() {
         let fm = MockFileManager(executables: ["/login/bin/codex"])
         let resolved = BinaryLocator.resolveCodexBinary(
             env: ["PATH": "/env/bin"],
@@ -70,7 +147,7 @@ struct PathBuilderTests {
     }
 
     @Test
-    func resolvesCodexFromEnvPath() {
+    func `resolves codex from env path`() {
         let fm = MockFileManager(executables: ["/env/bin/codex"])
         let resolved = BinaryLocator.resolveCodexBinary(
             env: ["PATH": "/env/bin:/usr/bin"],
@@ -81,7 +158,213 @@ struct PathBuilderTests {
     }
 
     @Test
-    func resolvesCodexFromInteractiveShell() {
+    func `skips blocked codex path and falls back to signed app binary`() {
+        let blockedPath = "/usr/local/bin/codex"
+        let appPath = "/Applications/Codex.app/Contents/Resources/codex"
+        let fm = MockFileManager(executables: [blockedPath, appPath])
+        var checked: [String] = []
+
+        let resolved = BinaryLocator.resolveCodexBinary(
+            env: ["PATH": "/usr/local/bin"],
+            loginPATH: nil,
+            commandV: { _, _, _, _ in nil },
+            aliasResolver: { _, _, _, _, _ in nil },
+            launchCandidateFilter: { path, _ in
+                checked.append(path)
+                return path != blockedPath
+            },
+            fileManager: fm,
+            home: "/Users/test")
+
+        #expect(resolved == appPath)
+        #expect(checked == [blockedPath, appPath])
+    }
+
+    @Test
+    func `explicit codex override bypasses launch candidate fallback`() {
+        let overridePath = "/custom/bin/codex"
+        let appPath = "/Applications/Codex.app/Contents/Resources/codex"
+        let fm = MockFileManager(executables: [overridePath, appPath])
+        var checked: [String] = []
+
+        let resolved = BinaryLocator.resolveCodexBinary(
+            env: ["CODEX_CLI_PATH": overridePath],
+            loginPATH: nil,
+            launchCandidateFilter: { path, _ in
+                checked.append(path)
+                return false
+            },
+            fileManager: fm,
+            home: "/Users/test")
+
+        #expect(resolved == overridePath)
+        #expect(checked.isEmpty)
+    }
+
+    @Test
+    func `Codex CLI strategy availability uses filtered binary resolution`() {
+        let commandV: (String, String?, TimeInterval, FileManager) -> String? = { _, _, _, _ in nil }
+        let aliasResolver: (String, String?, TimeInterval, FileManager, String) -> String? = { _, _, _, _, _ in nil }
+
+        let unavailable = CodexCLIUsageStrategy.resolvedBinary(
+            env: ["PATH": "/missing/bin", "SHELL": "/bin/sh"],
+            loginPATH: nil,
+            commandV: commandV,
+            aliasResolver: aliasResolver,
+            fileManager: MockFileManager(executables: []),
+            home: "/home/test")
+        #expect(unavailable == nil)
+
+        let available = CodexCLIUsageStrategy.resolvedBinary(
+            env: ["PATH": "/tools/bin", "SHELL": "/bin/sh"],
+            loginPATH: nil,
+            commandV: commandV,
+            aliasResolver: aliasResolver,
+            fileManager: MockFileManager(executables: ["/tools/bin/codex"]),
+            home: "/home/test")
+        #expect(available == "/tools/bin/codex")
+    }
+
+    #if os(macOS)
+    @Test
+    func `Codex launch preflight allows quarantined notarized native binary`() {
+        let allowed = CodexLaunchPreflight.isLaunchCandidateAllowed(
+            path: "/Applications/Codex.app/Contents/Resources/codex",
+            fileManager: MockFileManager(executables: []),
+            hasExtendedAttribute: { _, name in name == "com.apple.quarantine" },
+            spctlAssessment: { _ in "accepted\nsource=Notarized Developer ID" },
+            isMachOExecutable: { _ in true })
+
+        #expect(allowed)
+    }
+
+    @Test
+    func `Codex launch preflight blocks malware attribute before assessment`() {
+        var assessed = false
+        let allowed = CodexLaunchPreflight.isLaunchCandidateAllowed(
+            path: "/Applications/Codex.app/Contents/Resources/codex",
+            fileManager: MockFileManager(executables: []),
+            hasExtendedAttribute: { _, name in name == "com.apple.malware" },
+            spctlAssessment: { _ in
+                assessed = true
+                return "accepted\nsource=Notarized Developer ID"
+            },
+            isMachOExecutable: { _ in true })
+
+        #expect(!allowed)
+        #expect(!assessed)
+    }
+
+    @Test
+    func `Codex launch preflight blocks quarantined script without native assessment`() {
+        let allowed = CodexLaunchPreflight.isLaunchCandidateAllowed(
+            path: "/opt/homebrew/bin/codex",
+            fileManager: MockFileManager(executables: []),
+            hasExtendedAttribute: { _, name in name == "com.apple.quarantine" },
+            spctlAssessment: { _ in nil },
+            isMachOExecutable: { _ in false })
+
+        #expect(!allowed)
+    }
+
+    @Test
+    func `Codex launch preflight blocks revoked assessment`() {
+        let allowed = CodexLaunchPreflight.isLaunchCandidateAllowed(
+            path: "/Applications/Codex.app/Contents/Resources/codex",
+            fileManager: MockFileManager(executables: []),
+            hasExtendedAttribute: { _, _ in false },
+            spctlAssessment: { _ in "rejected\nCSSMERR_TP_CERT_REVOKED" },
+            isMachOExecutable: { _ in true })
+
+        #expect(!allowed)
+    }
+
+    @Test
+    func `Codex launch preflight blocks generic Gatekeeper rejection`() {
+        let allowed = CodexLaunchPreflight.isLaunchCandidateAllowed(
+            path: "/opt/homebrew/bin/codex",
+            fileManager: MockFileManager(executables: []),
+            hasExtendedAttribute: { _, _ in false },
+            spctlAssessment: { _ in "rejected\nsource=no usable signature" },
+            isMachOExecutable: { _ in true })
+
+        #expect(!allowed)
+    }
+
+    @Test
+    func `Codex launch preflight allows valid signed command line binary assessment`() {
+        let allowed = CodexLaunchPreflight.isLaunchCandidateAllowed(
+            path: "/opt/homebrew/bin/codex",
+            fileManager: MockFileManager(executables: []),
+            hasExtendedAttribute: { _, name in name == "com.apple.quarantine" },
+            spctlAssessment: { path in "\(path): rejected (the code is valid but does not seem to be an app)" },
+            isMachOExecutable: { _ in true })
+
+        #expect(allowed)
+    }
+
+    @Test
+    func `Codex launch preflight blocks revoked assessment even with non app rejection text`() {
+        let allowed = CodexLaunchPreflight.isLaunchCandidateAllowed(
+            path: "/opt/homebrew/bin/codex",
+            fileManager: MockFileManager(executables: []),
+            hasExtendedAttribute: { _, name in name == "com.apple.quarantine" },
+            spctlAssessment: { _ in
+                """
+                rejected (the code is valid but does not seem to be an app)
+                CSSMERR_TP_CERT_REVOKED
+                """
+            },
+            isMachOExecutable: { _ in true })
+
+        #expect(!allowed)
+    }
+
+    @Test
+    func `Codex launch preflight ignores benign text in path when verdict is generic rejection`() {
+        let allowed = CodexLaunchPreflight.isLaunchCandidateAllowed(
+            path: "/tmp/code is valid but does not seem to be an app/codex",
+            fileManager: MockFileManager(executables: []),
+            hasExtendedAttribute: { _, name in name == "com.apple.quarantine" },
+            spctlAssessment: { path in "\(path): rejected\nsource=no usable signature" },
+            isMachOExecutable: { _ in true })
+
+        #expect(!allowed)
+    }
+
+    @Test
+    func `Codex launch preflight ignores benign text before verdict separator`() {
+        let allowed = CodexLaunchPreflight.isLaunchCandidateAllowed(
+            path: "/tmp/x: code is valid but does not seem to be an app/codex",
+            fileManager: MockFileManager(executables: []),
+            hasExtendedAttribute: { _, name in name == "com.apple.quarantine" },
+            spctlAssessment: { path in "\(path): rejected\nsource=no usable signature" },
+            isMachOExecutable: { _ in true })
+
+        #expect(!allowed)
+    }
+
+    @Test
+    func `Codex launch preflight ignores blocked words in accepted path and source fields`() {
+        let allowed = CodexLaunchPreflight.isLaunchCandidateAllowed(
+            path: "/tmp/rejected/quarantine/codex",
+            fileManager: MockFileManager(executables: []),
+            hasExtendedAttribute: { _, name in name == "com.apple.quarantine" },
+            spctlAssessment: { path in
+                """
+                \(path): accepted
+                source=revoked quarantine marker
+                origin=malware test fixture
+                """
+            },
+            isMachOExecutable: { _ in true })
+
+        #expect(allowed)
+    }
+    #endif
+
+    @Test
+    func `resolves codex from interactive shell`() {
         let fm = MockFileManager(executables: ["/shell/bin/codex"])
         let commandV: (String, String?, TimeInterval, FileManager) -> String? = { tool, shell, timeout, fileManager in
             #expect(tool == "codex")
@@ -101,7 +384,7 @@ struct PathBuilderTests {
     }
 
     @Test
-    func resolvesClaudeFromInteractiveShell() {
+    func `resolves claude from interactive shell`() {
         let fm = MockFileManager(executables: ["/shell/bin/claude"])
         let commandV: (String, String?, TimeInterval, FileManager) -> String? = { tool, shell, timeout, fileManager in
             #expect(tool == "claude")
@@ -121,7 +404,7 @@ struct PathBuilderTests {
     }
 
     @Test
-    func resolvesGeminiFromInteractiveShell() {
+    func `resolves gemini from interactive shell`() {
         let fm = MockFileManager(executables: ["/shell/bin/gemini"])
         let commandV: (String, String?, TimeInterval, FileManager) -> String? = { tool, shell, timeout, fileManager in
             #expect(tool == "gemini")
@@ -141,7 +424,7 @@ struct PathBuilderTests {
     }
 
     @Test
-    func resolvesClaudeFromLoginPath() {
+    func `resolves claude from login path`() {
         let fm = MockFileManager(executables: ["/login/bin/claude"])
         let resolved = BinaryLocator.resolveClaudeBinary(
             env: ["PATH": "/env/bin"],
@@ -152,7 +435,7 @@ struct PathBuilderTests {
     }
 
     @Test
-    func resolvesClaudeFromAliasWhenOtherLookupsFail() {
+    func `resolves claude from alias when other lookups fail`() {
         let aliasPath = "/home/test/.claude/local/bin/claude"
         let fm = MockFileManager(executables: [aliasPath])
         var aliasCalled = false
@@ -182,7 +465,7 @@ struct PathBuilderTests {
     }
 
     @Test
-    func resolvesCodexFromAliasWhenOtherLookupsFail() {
+    func `resolves codex from alias when other lookups fail`() {
         let aliasPath = "/home/test/.codex/bin/codex"
         let fm = MockFileManager(executables: [aliasPath])
         var aliasCalled = false
@@ -212,7 +495,134 @@ struct PathBuilderTests {
     }
 
     @Test
-    func skipsAliasWhenCommandVResolves() {
+    func `resolves claude from well-known cmux path when shell lookups fail`() {
+        let cmuxPath = "/Applications/cmux.app/Contents/Resources/bin/claude"
+        let fm = MockFileManager(executables: [cmuxPath])
+        let commandV: (String, String?, TimeInterval, FileManager) -> String? = { _, _, _, _ in nil }
+        let aliasResolver: (String, String?, TimeInterval, FileManager, String) -> String? = { _, _, _, _, _ in nil }
+
+        let resolved = BinaryLocator.resolveClaudeBinary(
+            env: ["SHELL": "/bin/zsh"],
+            loginPATH: nil,
+            commandV: commandV,
+            aliasResolver: aliasResolver,
+            fileManager: fm,
+            home: "/Users/test")
+        #expect(resolved == cmuxPath)
+    }
+
+    @Test
+    func `resolves claude from well-known home dir path`() {
+        let homePath = "/Users/test/.claude/bin/claude"
+        let fm = MockFileManager(executables: [homePath])
+        let commandV: (String, String?, TimeInterval, FileManager) -> String? = { _, _, _, _ in nil }
+        let aliasResolver: (String, String?, TimeInterval, FileManager, String) -> String? = { _, _, _, _, _ in nil }
+
+        let resolved = BinaryLocator.resolveClaudeBinary(
+            env: ["SHELL": "/bin/zsh"],
+            loginPATH: nil,
+            commandV: commandV,
+            aliasResolver: aliasResolver,
+            fileManager: fm,
+            home: "/Users/test")
+        #expect(resolved == homePath)
+    }
+
+    @Test
+    func `resolves claude from native installer path`() {
+        let nativePath = "/Users/test/.local/bin/claude"
+        let fm = MockFileManager(executables: [nativePath])
+        let commandV: (String, String?, TimeInterval, FileManager) -> String? = { _, _, _, _ in nil }
+        let aliasResolver: (String, String?, TimeInterval, FileManager, String) -> String? = { _, _, _, _, _ in nil }
+
+        let resolved = BinaryLocator.resolveClaudeBinary(
+            env: ["SHELL": "/bin/zsh"],
+            loginPATH: nil,
+            commandV: commandV,
+            aliasResolver: aliasResolver,
+            fileManager: fm,
+            home: "/Users/test")
+        #expect(resolved == nativePath)
+    }
+
+    @Test
+    func `prefers migrated local claude path over legacy home dir path`() {
+        let migratedPath = "/Users/test/.claude/local/claude"
+        let legacyPath = "/Users/test/.claude/bin/claude"
+        let fm = MockFileManager(executables: [migratedPath, legacyPath])
+        let commandV: (String, String?, TimeInterval, FileManager) -> String? = { _, _, _, _ in nil }
+        let aliasResolver: (String, String?, TimeInterval, FileManager, String) -> String? = { _, _, _, _, _ in nil }
+
+        let resolved = BinaryLocator.resolveClaudeBinary(
+            env: ["SHELL": "/bin/zsh"],
+            loginPATH: nil,
+            commandV: commandV,
+            aliasResolver: aliasResolver,
+            fileManager: fm,
+            home: "/Users/test")
+        #expect(resolved == migratedPath)
+    }
+
+    @Test
+    func `prefers user managed well-known path over cmux path`() {
+        let homePath = "/Users/test/.claude/bin/claude"
+        let cmuxPath = "/Applications/cmux.app/Contents/Resources/bin/claude"
+        let fm = MockFileManager(executables: [homePath, cmuxPath])
+        let commandV: (String, String?, TimeInterval, FileManager) -> String? = { _, _, _, _ in nil }
+        let aliasResolver: (String, String?, TimeInterval, FileManager, String) -> String? = { _, _, _, _, _ in nil }
+
+        let resolved = BinaryLocator.resolveClaudeBinary(
+            env: ["SHELL": "/bin/zsh"],
+            loginPATH: nil,
+            commandV: commandV,
+            aliasResolver: aliasResolver,
+            fileManager: fm,
+            home: "/Users/test")
+        #expect(resolved == homePath)
+    }
+
+    @Test
+    func `prefers homebrew arm path over usr local fallback`() {
+        let fm = MockFileManager(executables: [
+            "/opt/homebrew/bin/claude",
+            "/usr/local/bin/claude",
+        ])
+        let commandV: (String, String?, TimeInterval, FileManager) -> String? = { _, _, _, _ in nil }
+        let aliasResolver: (String, String?, TimeInterval, FileManager, String) -> String? = { _, _, _, _, _ in nil }
+
+        let resolved = BinaryLocator.resolveClaudeBinary(
+            env: ["SHELL": "/bin/zsh"],
+            loginPATH: nil,
+            commandV: commandV,
+            aliasResolver: aliasResolver,
+            fileManager: fm,
+            home: "/Users/test")
+        #expect(resolved == "/opt/homebrew/bin/claude")
+    }
+
+    @Test
+    func `prefers well-known paths over interactive shell lookup`() {
+        let shellPath = "/custom/bin/claude"
+        let cmuxPath = "/Applications/cmux.app/Contents/Resources/bin/claude"
+        let fm = MockFileManager(executables: [shellPath, cmuxPath])
+        var shellLookupCalled = false
+        let commandV: (String, String?, TimeInterval, FileManager) -> String? = { _, _, _, _ in
+            shellLookupCalled = true
+            return shellPath
+        }
+
+        let resolved = BinaryLocator.resolveClaudeBinary(
+            env: ["SHELL": "/bin/zsh"],
+            loginPATH: nil,
+            commandV: commandV,
+            fileManager: fm,
+            home: "/Users/test")
+        #expect(!shellLookupCalled)
+        #expect(resolved == cmuxPath)
+    }
+
+    @Test
+    func `skips alias when command V resolves`() {
         let path = "/shell/bin/claude"
         let fm = MockFileManager(executables: [path])
         var aliasCalled = false
@@ -235,6 +645,33 @@ struct PathBuilderTests {
         #expect(!aliasCalled)
         #expect(resolved == path)
     }
+
+    private static func shellSingleQuoted(_ value: String) -> String {
+        "'\(value.replacingOccurrences(of: "'", with: "'\\''"))'"
+    }
+}
+
+private final class LoginShellPathCaptureStub: @unchecked Sendable {
+    private let lock = NSLock()
+    private var results: [[String]?]
+    private var callCountStorage = 0
+
+    var callCount: Int {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        return self.callCountStorage
+    }
+
+    init(_ results: [[String]?]) {
+        self.results = results
+    }
+
+    func next() -> [String]? {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        self.callCountStorage += 1
+        return self.results.isEmpty ? nil : self.results.removeFirst()
+    }
 }
 
 private final class MockFileManager: FileManager {
diff --git a/Tests/CodexBarTests/PerplexityCookieCacheTests.swift b/Tests/CodexBarTests/PerplexityCookieCacheTests.swift
new file mode 100644
index 0000000000..a734d9edf6
--- /dev/null
+++ b/Tests/CodexBarTests/PerplexityCookieCacheTests.swift
@@ -0,0 +1,203 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct PerplexityCookieCacheTests {
+    private static let testToken = "eyJhbGciOiJkaXIiLCJlbmMiOiJBMjU2R0NNIn0.fake-test-token"
+    private static let testCookieName = PerplexityCookieHeader.defaultSessionCookieName
+
+    private struct StubClaudeFetcher: ClaudeUsageFetching {
+        func loadLatestUsage(model _: String) async throws -> ClaudeUsageSnapshot {
+            throw ClaudeUsageError.parseFailed("stub")
+        }
+
+        func debugRawProbe(model _: String) async -> String {
+            "stub"
+        }
+
+        func detectVersion() -> String? {
+            nil
+        }
+    }
+
+    // MARK: - Cache round-trip
+
+    @Test
+    func `cache round trip produces valid cookie override`() {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer {
+            CookieHeaderCache.clear(provider: .perplexity)
+            KeychainCacheStore.setTestStoreForTesting(false)
+        }
+
+        CookieHeaderCache.store(
+            provider: .perplexity,
+            cookieHeader: "\(Self.testCookieName)=\(Self.testToken)",
+            sourceLabel: "web")
+
+        let cached = CookieHeaderCache.load(provider: .perplexity)
+        #expect(cached != nil)
+        #expect(cached?.sourceLabel == "web")
+
+        let override = PerplexityCookieHeader.override(from: cached?.cookieHeader)
+        #expect(override?.name == Self.testCookieName)
+        #expect(override?.token == Self.testToken)
+    }
+
+    // MARK: - isAvailable returns true when cache has entry
+
+    @Test
+    func `is available returns true when cache populated`() {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer {
+            CookieHeaderCache.clear(provider: .perplexity)
+            KeychainCacheStore.setTestStoreForTesting(false)
+        }
+
+        // With no cache and no other sources, load should return nil
+        let beforeStore = CookieHeaderCache.load(provider: .perplexity)
+        #expect(beforeStore == nil)
+
+        // After storing, cache should be available
+        CookieHeaderCache.store(
+            provider: .perplexity,
+            cookieHeader: "\(Self.testCookieName)=\(Self.testToken)",
+            sourceLabel: "web")
+
+        let afterStore = CookieHeaderCache.load(provider: .perplexity)
+        #expect(afterStore != nil)
+    }
+
+    // MARK: - Cache cleared on invalidToken
+
+    @Test
+    func `cache cleared on invalid token`() {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer {
+            CookieHeaderCache.clear(provider: .perplexity)
+            KeychainCacheStore.setTestStoreForTesting(false)
+        }
+
+        CookieHeaderCache.store(
+            provider: .perplexity,
+            cookieHeader: "\(Self.testCookieName)=\(Self.testToken)",
+            sourceLabel: "web")
+
+        // Verify it's cached
+        #expect(CookieHeaderCache.load(provider: .perplexity) != nil)
+
+        // Simulate what fetch() does on invalidToken: clear the cache
+        CookieHeaderCache.clear(provider: .perplexity)
+
+        #expect(CookieHeaderCache.load(provider: .perplexity) == nil)
+    }
+
+    // MARK: - Cache NOT cleared on non-auth errors
+
+    @Test
+    func `cache not cleared on network error`() {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer {
+            CookieHeaderCache.clear(provider: .perplexity)
+            KeychainCacheStore.setTestStoreForTesting(false)
+        }
+
+        CookieHeaderCache.store(
+            provider: .perplexity,
+            cookieHeader: "\(Self.testCookieName)=\(Self.testToken)",
+            sourceLabel: "web")
+
+        // Simulate a networkError — cache should NOT be cleared
+        let error = PerplexityAPIError.networkError("timeout")
+        switch error {
+        case .invalidToken:
+            CookieHeaderCache.clear(provider: .perplexity)
+        default:
+            break // non-auth errors do not clear cache
+        }
+
+        #expect(CookieHeaderCache.load(provider: .perplexity) != nil)
+    }
+
+    @Test
+    func `cache not cleared on API error`() {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer {
+            CookieHeaderCache.clear(provider: .perplexity)
+            KeychainCacheStore.setTestStoreForTesting(false)
+        }
+
+        CookieHeaderCache.store(
+            provider: .perplexity,
+            cookieHeader: "\(Self.testCookieName)=\(Self.testToken)",
+            sourceLabel: "web")
+
+        // Simulate an apiError (e.g. HTTP 500) — cache should NOT be cleared
+        let error = PerplexityAPIError.apiError("HTTP 500")
+        switch error {
+        case .invalidToken:
+            CookieHeaderCache.clear(provider: .perplexity)
+        default:
+            break // non-auth errors do not clear cache
+        }
+
+        #expect(CookieHeaderCache.load(provider: .perplexity) != nil)
+    }
+
+    // MARK: - Bare token stored as default cookie name
+
+    @Test
+    func `bare token round trips with default cookie name`() {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer {
+            CookieHeaderCache.clear(provider: .perplexity)
+            KeychainCacheStore.setTestStoreForTesting(false)
+        }
+
+        // Store with default cookie name format
+        CookieHeaderCache.store(
+            provider: .perplexity,
+            cookieHeader: "\(Self.testCookieName)=\(Self.testToken)",
+            sourceLabel: "web")
+
+        let cached = CookieHeaderCache.load(provider: .perplexity)
+        let override = PerplexityCookieHeader.override(from: cached?.cookieHeader)
+        #expect(override?.name == Self.testCookieName)
+        #expect(override?.token == Self.testToken)
+    }
+
+    @Test
+    func `off mode ignores cached session cookie`() async {
+        KeychainCacheStore.setTestStoreForTesting(true)
+        defer {
+            CookieHeaderCache.clear(provider: .perplexity)
+            KeychainCacheStore.setTestStoreForTesting(false)
+        }
+
+        CookieHeaderCache.store(
+            provider: .perplexity,
+            cookieHeader: "\(Self.testCookieName)=cached-token",
+            sourceLabel: "web")
+
+        let strategy = PerplexityWebFetchStrategy()
+        let settings = ProviderSettingsSnapshot.make(
+            perplexity: ProviderSettingsSnapshot.PerplexityProviderSettings(
+                cookieSource: .off,
+                manualCookieHeader: nil))
+        let context = ProviderFetchContext(
+            runtime: .app,
+            sourceMode: .auto,
+            includeCredits: false,
+            webTimeout: 1,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: [:],
+            settings: settings,
+            fetcher: UsageFetcher(environment: [:]),
+            claudeFetcher: StubClaudeFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0))
+
+        #expect(await strategy.isAvailable(context) == false)
+    }
+}
diff --git a/Tests/CodexBarTests/PerplexityCookieHeaderTests.swift b/Tests/CodexBarTests/PerplexityCookieHeaderTests.swift
new file mode 100644
index 0000000000..39b7d2a52b
--- /dev/null
+++ b/Tests/CodexBarTests/PerplexityCookieHeaderTests.swift
@@ -0,0 +1,89 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct PerplexityCookieHeaderTests {
+    @Test
+    func `bare token uses default session cookie name`() {
+        let override = PerplexityCookieHeader.override(from: "abc123")
+        #expect(override?.name == PerplexityCookieHeader.defaultSessionCookieName)
+        #expect(override?.token == "abc123")
+        #expect(override?.requestCookieNames == PerplexityCookieHeader.supportedSessionCookieNames)
+    }
+
+    @Test
+    func `extracts secure next auth session cookie from header`() {
+        let header = "foo=bar; __Secure-next-auth.session-token=token-a; baz=qux"
+        let override = PerplexityCookieHeader.override(from: header)
+        #expect(override?.name == "__Secure-next-auth.session-token")
+        #expect(override?.token == "token-a")
+    }
+
+    @Test
+    func `extracts auth JS session cookie from header`() {
+        let header = "foo=bar; __Secure-authjs.session-token=token-b; baz=qux"
+        let override = PerplexityCookieHeader.override(from: header)
+        #expect(override?.name == "__Secure-authjs.session-token")
+        #expect(override?.token == "token-b")
+    }
+
+    @Test
+    func `prefers auth JS session cookie when both names exist`() {
+        let header = """
+        __Secure-next-auth.session-token=legacy-token; __Secure-authjs.session-token=live-token
+        """
+        let override = PerplexityCookieHeader.override(from: header)
+        #expect(override?.name == "__Secure-authjs.session-token")
+        #expect(override?.token == "live-token")
+    }
+
+    @Test
+    func `reassembles chunked next auth session cookie from header`() {
+        let header = """
+        foo=bar; __Secure-next-auth.session-token.1=chunk-b; __Secure-next-auth.session-token.0=chunk-a
+        """
+        let override = PerplexityCookieHeader.override(from: header)
+        #expect(override?.name == "__Secure-next-auth.session-token")
+        #expect(override?.token == "chunk-achunk-b")
+    }
+
+    @Test
+    func `reassembles chunked auth JS session cookie from header`() {
+        let header = "foo=bar; authjs.session-token.0=chunk-a; authjs.session-token.1=chunk-b"
+        let override = PerplexityCookieHeader.override(from: header)
+        #expect(override?.name == "authjs.session-token")
+        #expect(override?.token == "chunk-achunk-b")
+    }
+
+    @Test
+    func `unsupported cookie header returns nil`() {
+        let override = PerplexityCookieHeader.override(from: "foo=bar; hello=world")
+        #expect(override == nil)
+    }
+
+    #if os(macOS)
+    @Test
+    func `importer session info reassembles chunked session cookies`() throws {
+        let cookies = try [
+            #require(self.makeCookie(name: "__Secure-authjs.session-token.0", value: "chunk-a")),
+            #require(self.makeCookie(name: "__Secure-authjs.session-token.1", value: "chunk-b")),
+        ]
+        let session = PerplexityCookieImporter.SessionInfo(cookies: cookies, sourceLabel: "Chrome")
+
+        #expect(session.sessionCookie?.name == "__Secure-authjs.session-token")
+        #expect(session.sessionCookie?.token == "chunk-achunk-b")
+    }
+    #endif
+
+    #if os(macOS)
+    private func makeCookie(name: String, value: String) -> HTTPCookie? {
+        HTTPCookie(properties: [
+            .domain: "www.perplexity.ai",
+            .path: "/",
+            .name: name,
+            .value: value,
+            .secure: "TRUE",
+        ])
+    }
+    #endif
+}
diff --git a/Tests/CodexBarTests/PerplexityProviderTests.swift b/Tests/CodexBarTests/PerplexityProviderTests.swift
new file mode 100644
index 0000000000..b81a468447
--- /dev/null
+++ b/Tests/CodexBarTests/PerplexityProviderTests.swift
@@ -0,0 +1,397 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct PerplexityProviderTests {
+    private static let now = Date(timeIntervalSince1970: 1_740_000_000)
+
+    private final class LockedArray<Element>: @unchecked Sendable {
+        private let lock = NSLock()
+        private var values: [Element] = []
+
+        func append(_ value: Element) {
+            self.lock.lock()
+            defer { self.lock.unlock() }
+            self.values.append(value)
+        }
+
+        func snapshot() -> [Element] {
+            self.lock.lock()
+            defer { self.lock.unlock() }
+            return self.values
+        }
+    }
+
+    private final class LockedCounter: @unchecked Sendable {
+        private let lock = NSLock()
+        private var value: Int = 0
+
+        func increment() {
+            self.lock.lock()
+            defer { self.lock.unlock() }
+            self.value += 1
+        }
+
+        func snapshot() -> Int {
+            self.lock.lock()
+            defer { self.lock.unlock() }
+            return self.value
+        }
+    }
+
+    private struct StubClaudeFetcher: ClaudeUsageFetching {
+        func loadLatestUsage(model _: String) async throws -> ClaudeUsageSnapshot {
+            throw ClaudeUsageError.parseFailed("stub")
+        }
+
+        func debugRawProbe(model _: String) async -> String {
+            "stub"
+        }
+
+        func detectVersion() -> String? {
+            nil
+        }
+    }
+
+    private func makeContext(
+        settings: ProviderSettingsSnapshot?,
+        env: [String: String] = [:]) -> ProviderFetchContext
+    {
+        ProviderFetchContext(
+            runtime: .app,
+            sourceMode: .auto,
+            includeCredits: false,
+            webTimeout: 1,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: env,
+            settings: settings,
+            fetcher: UsageFetcher(environment: env),
+            claudeFetcher: StubClaudeFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0))
+    }
+
+    private func stubSnapshot(now: Date = Self.now) -> PerplexityUsageSnapshot {
+        PerplexityUsageSnapshot(
+            response: PerplexityCreditsResponse(
+                balanceCents: 500,
+                renewalDateTs: now.addingTimeInterval(3600).timeIntervalSince1970,
+                currentPeriodPurchasedCents: 0,
+                creditGrants: [
+                    PerplexityCreditGrant(type: "recurring", amountCents: 1000, expiresAtTs: nil),
+                ],
+                totalUsageCents: 500),
+            now: now)
+    }
+
+    private func withIsolatedCacheStore<T>(operation: () async throws -> T) async rethrows -> T {
+        let service = "perplexity-provider-tests-\(UUID().uuidString)"
+        return try await KeychainCacheStore.withServiceOverrideForTesting(service) {
+            KeychainCacheStore.setTestStoreForTesting(true)
+            defer { KeychainCacheStore.setTestStoreForTesting(false) }
+            return try await operation()
+        }
+    }
+
+    @Test
+    func `off mode ignores environment session cookie`() async {
+        let strategy = PerplexityWebFetchStrategy()
+        let settings = ProviderSettingsSnapshot.make(
+            perplexity: ProviderSettingsSnapshot.PerplexityProviderSettings(
+                cookieSource: .off,
+                manualCookieHeader: nil))
+        let context = self.makeContext(
+            settings: settings,
+            env: ["PERPLEXITY_COOKIE": "authjs.session-token=env-token"])
+
+        #expect(await strategy.isAvailable(context) == false)
+    }
+
+    @Test
+    func `manual mode invalid cookie does not fall back to cache or environment`() async {
+        await self.withIsolatedCacheStore {
+            CookieHeaderCache.store(
+                provider: .perplexity,
+                cookieHeader: "\(PerplexityCookieHeader.defaultSessionCookieName)=cached-token",
+                sourceLabel: "web")
+
+            let strategy = PerplexityWebFetchStrategy()
+            let settings = ProviderSettingsSnapshot.make(
+                perplexity: ProviderSettingsSnapshot.PerplexityProviderSettings(
+                    cookieSource: .manual,
+                    manualCookieHeader: "foo=bar"))
+            let context = self.makeContext(
+                settings: settings,
+                env: ["PERPLEXITY_COOKIE": "authjs.session-token=env-token"])
+            let fetchOverride: @Sendable (String, String, Date) async throws -> PerplexityUsageSnapshot = { _, _, _ in
+                self.stubSnapshot()
+            }
+
+            do {
+                _ = try await PerplexityUsageFetcher.$fetchCreditsOverride.withValue(fetchOverride, operation: {
+                    try await strategy.fetch(context)
+                })
+                Issue.record("Expected invalid manual-cookie error instead of falling back to cache/environment")
+            } catch let error as PerplexityAPIError {
+                #expect(error == .invalidCookie)
+            } catch {
+                Issue.record("Expected PerplexityAPIError.invalidCookie, got \(error)")
+            }
+        }
+    }
+
+    @Test
+    func `environment token does not populate browser cookie cache`() async throws {
+        try await self.withIsolatedCacheStore {
+            PerplexityCookieImporter.invalidateImportSessionCache()
+            PerplexityCookieImporter.importSessionsOverrideForTesting = nil
+            PerplexityCookieImporter.importSessionOverrideForTesting = { _, _ in
+                throw PerplexityCookieImportError.noCookies
+            }
+            defer {
+                PerplexityCookieImporter.importSessionsOverrideForTesting = nil
+                PerplexityCookieImporter.importSessionOverrideForTesting = nil
+                PerplexityCookieImporter.invalidateImportSessionCache()
+            }
+
+            let strategy = PerplexityWebFetchStrategy()
+            let settings = ProviderSettingsSnapshot.make(
+                perplexity: ProviderSettingsSnapshot.PerplexityProviderSettings(
+                    cookieSource: .auto,
+                    manualCookieHeader: nil))
+            let context = self.makeContext(
+                settings: settings,
+                env: ["PERPLEXITY_COOKIE": "authjs.session-token=env-token"])
+            let fetchOverride: @Sendable (String, String, Date) async throws -> PerplexityUsageSnapshot = { _, _, _ in
+                self.stubSnapshot()
+            }
+
+            _ = try await PerplexityUsageFetcher.$fetchCreditsOverride.withValue(fetchOverride, operation: {
+                try await strategy.fetch(context)
+            })
+
+            #expect(CookieHeaderCache.load(provider: .perplexity) == nil)
+        }
+    }
+
+    @Test
+    func `manual token does not populate browser cookie cache`() async throws {
+        try await self.withIsolatedCacheStore {
+            let strategy = PerplexityWebFetchStrategy()
+            let settings = ProviderSettingsSnapshot.make(
+                perplexity: ProviderSettingsSnapshot.PerplexityProviderSettings(
+                    cookieSource: .manual,
+                    manualCookieHeader: "authjs.session-token=manual-token"))
+            let context = self.makeContext(settings: settings)
+            let fetchOverride: @Sendable (String, String, Date) async throws -> PerplexityUsageSnapshot = { _, _, _ in
+                self.stubSnapshot()
+            }
+
+            _ = try await PerplexityUsageFetcher.$fetchCreditsOverride.withValue(fetchOverride, operation: {
+                try await strategy.fetch(context)
+            })
+
+            #expect(CookieHeaderCache.load(provider: .perplexity) == nil)
+        }
+    }
+
+    @Test
+    func `bare environment token falls back to auth JS cookie name`() async throws {
+        try await self.withIsolatedCacheStore {
+            PerplexityCookieImporter.invalidateImportSessionCache()
+            PerplexityCookieImporter.importSessionsOverrideForTesting = nil
+            PerplexityCookieImporter.importSessionOverrideForTesting = { _, _ in
+                throw PerplexityCookieImportError.noCookies
+            }
+            defer {
+                PerplexityCookieImporter.importSessionsOverrideForTesting = nil
+                PerplexityCookieImporter.importSessionOverrideForTesting = nil
+                PerplexityCookieImporter.invalidateImportSessionCache()
+            }
+
+            let attemptedCookieNames = LockedArray<String>()
+            let strategy = PerplexityWebFetchStrategy()
+            let settings = ProviderSettingsSnapshot.make(
+                perplexity: ProviderSettingsSnapshot.PerplexityProviderSettings(
+                    cookieSource: .auto,
+                    manualCookieHeader: nil))
+            let context = self.makeContext(
+                settings: settings,
+                env: ["PERPLEXITY_SESSION_TOKEN": "env-token"])
+            let fetchOverride: @Sendable (String, String, Date) async throws
+                -> PerplexityUsageSnapshot = { token, cookieName, _ in
+                    #expect(token == "env-token")
+                    attemptedCookieNames.append(cookieName)
+                    if cookieName == "authjs.session-token" {
+                        return self.stubSnapshot()
+                    }
+                    throw PerplexityAPIError.invalidToken
+                }
+
+            _ = try await PerplexityUsageFetcher.$fetchCreditsOverride.withValue(fetchOverride, operation: {
+                try await strategy.fetch(context)
+            })
+
+            #expect(attemptedCookieNames.snapshot() == [
+                "__Secure-authjs.session-token",
+                "authjs.session-token",
+            ])
+        }
+    }
+
+    @Test
+    func `valid environment cookie wins after invalid browser session`() async throws {
+        try await self.withIsolatedCacheStore {
+            PerplexityCookieImporter.invalidateImportSessionCache()
+            PerplexityCookieImporter.importSessionsOverrideForTesting = nil
+            PerplexityCookieImporter.importSessionOverrideForTesting = { _, _ in
+                let cookie = try #require(HTTPCookie(properties: [
+                    .domain: "www.perplexity.ai",
+                    .path: "/",
+                    .name: PerplexityCookieHeader.defaultSessionCookieName,
+                    .value: "browser-token",
+                    .secure: "TRUE",
+                ]))
+                return PerplexityCookieImporter.SessionInfo(cookies: [cookie], sourceLabel: "Chrome")
+            }
+            defer {
+                PerplexityCookieImporter.importSessionsOverrideForTesting = nil
+                PerplexityCookieImporter.importSessionOverrideForTesting = nil
+                PerplexityCookieImporter.invalidateImportSessionCache()
+            }
+
+            let attemptedTokens = LockedArray<String>()
+            let strategy = PerplexityWebFetchStrategy()
+            let settings = ProviderSettingsSnapshot.make(
+                perplexity: ProviderSettingsSnapshot.PerplexityProviderSettings(
+                    cookieSource: .auto,
+                    manualCookieHeader: nil))
+            let context = self.makeContext(
+                settings: settings,
+                env: ["PERPLEXITY_COOKIE": "authjs.session-token=env-token"])
+            let fetchOverride: @Sendable (String, String, Date) async throws
+                -> PerplexityUsageSnapshot = { token, _, _ in
+                    attemptedTokens.append(token)
+                    if token == "browser-token" {
+                        throw PerplexityAPIError.invalidToken
+                    }
+                    if token == "env-token" {
+                        return self.stubSnapshot()
+                    }
+                    Issue.record("Unexpected token \(token)")
+                    throw PerplexityAPIError.invalidToken
+                }
+
+            _ = try await PerplexityUsageFetcher.$fetchCreditsOverride.withValue(fetchOverride, operation: {
+                try await strategy.fetch(context)
+            })
+
+            #expect(attemptedTokens.snapshot() == ["browser-token", "env-token"])
+        }
+    }
+
+    @Test
+    func `later browser session wins after earlier imported session fails auth`() async throws {
+        try await self.withIsolatedCacheStore {
+            PerplexityCookieImporter.invalidateImportSessionCache()
+            PerplexityCookieImporter.importSessionOverrideForTesting = nil
+            PerplexityCookieImporter.importSessionsOverrideForTesting = { _, _ in
+                let staleCookie = try #require(HTTPCookie(properties: [
+                    .domain: "www.perplexity.ai",
+                    .path: "/",
+                    .name: "__Secure-authjs.session-token",
+                    .value: "stale-browser-token",
+                    .secure: "TRUE",
+                ]))
+                let liveCookie = try #require(HTTPCookie(properties: [
+                    .domain: "www.perplexity.ai",
+                    .path: "/",
+                    .name: "__Secure-authjs.session-token",
+                    .value: "live-browser-token",
+                    .secure: "TRUE",
+                ]))
+                return [
+                    PerplexityCookieImporter.SessionInfo(cookies: [staleCookie], sourceLabel: "Chrome"),
+                    PerplexityCookieImporter.SessionInfo(cookies: [liveCookie], sourceLabel: "Safari"),
+                ]
+            }
+            defer {
+                PerplexityCookieImporter.importSessionsOverrideForTesting = nil
+                PerplexityCookieImporter.importSessionOverrideForTesting = nil
+                PerplexityCookieImporter.invalidateImportSessionCache()
+            }
+
+            let attemptedTokens = LockedArray<String>()
+            let strategy = PerplexityWebFetchStrategy()
+            let settings = ProviderSettingsSnapshot.make(
+                perplexity: ProviderSettingsSnapshot.PerplexityProviderSettings(
+                    cookieSource: .auto,
+                    manualCookieHeader: nil))
+            let context = self.makeContext(settings: settings)
+            let fetchOverride: @Sendable (String, String, Date) async throws
+                -> PerplexityUsageSnapshot = { token, _, _ in
+                    attemptedTokens.append(token)
+                    if token == "stale-browser-token" {
+                        throw PerplexityAPIError.invalidToken
+                    }
+                    if token == "live-browser-token" {
+                        return self.stubSnapshot()
+                    }
+                    Issue.record("Unexpected token \(token)")
+                    throw PerplexityAPIError.invalidToken
+                }
+
+            _ = try await PerplexityUsageFetcher.$fetchCreditsOverride.withValue(fetchOverride, operation: {
+                try await strategy.fetch(context)
+            })
+
+            #expect(attemptedTokens.snapshot() == ["stale-browser-token", "live-browser-token"])
+        }
+    }
+
+    @Test
+    func `auto mode reuses browser import between availability and fetch`() async throws {
+        try await self.withIsolatedCacheStore {
+            let importCount = LockedCounter()
+            PerplexityCookieImporter.invalidateImportSessionCache()
+            PerplexityCookieImporter.importSessionsOverrideForTesting = nil
+            PerplexityCookieImporter.importSessionOverrideForTesting = { _, _ in
+                importCount.increment()
+                let cookie = try #require(HTTPCookie(properties: [
+                    .domain: "www.perplexity.ai",
+                    .path: "/",
+                    .name: PerplexityCookieHeader.defaultSessionCookieName,
+                    .value: "browser-token",
+                    .secure: "TRUE",
+                ]))
+                return PerplexityCookieImporter.SessionInfo(cookies: [cookie], sourceLabel: "Chrome")
+            }
+            defer {
+                PerplexityCookieImporter.importSessionsOverrideForTesting = nil
+                PerplexityCookieImporter.importSessionOverrideForTesting = nil
+                PerplexityCookieImporter.invalidateImportSessionCache()
+            }
+
+            let strategy = PerplexityWebFetchStrategy()
+            let settings = ProviderSettingsSnapshot.make(
+                perplexity: ProviderSettingsSnapshot.PerplexityProviderSettings(
+                    cookieSource: .auto,
+                    manualCookieHeader: nil))
+            let context = self.makeContext(settings: settings)
+            let fetchOverride: @Sendable (String, String, Date) async throws
+                -> PerplexityUsageSnapshot = { token, _, _ in
+                    #expect(token == "browser-token")
+                    return self.stubSnapshot()
+                }
+
+            #expect(await strategy.isAvailable(context))
+
+            _ = try await PerplexityUsageFetcher.$fetchCreditsOverride.withValue(fetchOverride, operation: {
+                try await strategy.fetch(context)
+            })
+
+            #expect(importCount.snapshot() == 1)
+        }
+    }
+}
diff --git a/Tests/CodexBarTests/PerplexitySettingsReaderTests.swift b/Tests/CodexBarTests/PerplexitySettingsReaderTests.swift
new file mode 100644
index 0000000000..2f7b1ff7ad
--- /dev/null
+++ b/Tests/CodexBarTests/PerplexitySettingsReaderTests.swift
@@ -0,0 +1,38 @@
+import Testing
+@testable import CodexBarCore
+
+struct PerplexitySettingsReaderTests {
+    @Test
+    func `PERPLEXITY_COOKIE preserves the original supported cookie name`() {
+        let override = PerplexitySettingsReader.sessionCookieOverride(environment: [
+            "PERPLEXITY_COOKIE": "authjs.session-token=env-token",
+        ])
+
+        #expect(override?.name == "authjs.session-token")
+        #expect(override?.token == "env-token")
+        #expect(PerplexitySettingsReader.sessionToken(environment: [
+            "PERPLEXITY_COOKIE": "authjs.session-token=env-token",
+        ]) == "env-token")
+    }
+
+    @Test
+    func `PERPLEXITY_COOKIE reassembles chunked session cookies`() {
+        let override = PerplexitySettingsReader.sessionCookieOverride(environment: [
+            "PERPLEXITY_COOKIE": "authjs.session-token.0=chunk-a; authjs.session-token.1=chunk-b",
+        ])
+
+        #expect(override?.name == "authjs.session-token")
+        #expect(override?.token == "chunk-achunk-b")
+    }
+
+    @Test
+    func `PERPLEXITY_SESSION_TOKEN tries all supported cookie names`() {
+        let override = PerplexitySettingsReader.sessionCookieOverride(environment: [
+            "PERPLEXITY_SESSION_TOKEN": "env-token",
+        ])
+
+        #expect(override?.name == PerplexityCookieHeader.defaultSessionCookieName)
+        #expect(override?.token == "env-token")
+        #expect(override?.requestCookieNames == PerplexityCookieHeader.supportedSessionCookieNames)
+    }
+}
diff --git a/Tests/CodexBarTests/PerplexityUsageFetcherTests.swift b/Tests/CodexBarTests/PerplexityUsageFetcherTests.swift
new file mode 100644
index 0000000000..0afd0cbcc2
--- /dev/null
+++ b/Tests/CodexBarTests/PerplexityUsageFetcherTests.swift
@@ -0,0 +1,362 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct PerplexityUsageFetcherTests {
+    // Fixed "now" so expiry comparisons are deterministic
+    private static let now = Date(timeIntervalSince1970: 1_740_000_000) // Feb 20, 2026
+    private static let futureTs: TimeInterval = 1_750_000_000 // ~Jun 2025, after now
+    private static let pastTs: TimeInterval = 1_700_000_000 // ~Nov 2023, before now
+    private static let renewalTs: TimeInterval = 1_743_000_000 // ~Mar 26, 2026
+
+    // MARK: - JSON Parsing
+
+    @Test
+    func `parses full response with recurring and promotional credits`() throws {
+        let json = """
+        {
+          "balance_cents": 7250,
+          "renewal_date_ts": \(Self.renewalTs),
+          "current_period_purchased_cents": 0,
+          "credit_grants": [
+            { "type": "recurring", "amount_cents": 10000, "expires_at_ts": \(Self.futureTs) },
+            { "type": "promotional", "amount_cents": 20000, "expires_at_ts": \(Self.futureTs) }
+          ],
+          "total_usage_cents": 2750
+        }
+        """
+        let snapshot = try PerplexityUsageFetcher._parseResponseForTesting(Data(json.utf8), now: Self.now)
+
+        #expect(snapshot.recurringTotal == 10000)
+        #expect(snapshot.recurringUsed == 2750)
+        #expect(snapshot.promoTotal == 20000)
+        #expect(snapshot.promoUsed == 0)
+        #expect(snapshot.purchasedTotal == 0)
+        #expect(snapshot.purchasedUsed == 0)
+        #expect(snapshot.balanceCents == 7250)
+        #expect(snapshot.totalUsageCents == 2750)
+        #expect(abs(snapshot.renewalDate.timeIntervalSince1970 - Self.renewalTs) < 1)
+    }
+
+    @Test
+    func `waterfall attribution recurring then purchased then promo`() throws {
+        // Usage exceeds recurring, spills into purchased, then promo
+        let json = """
+        {
+          "balance_cents": 0,
+          "renewal_date_ts": \(Self.renewalTs),
+          "current_period_purchased_cents": 3000,
+          "credit_grants": [
+            { "type": "recurring",    "amount_cents": 5000, "expires_at_ts": \(Self.futureTs) },
+            { "type": "promotional",  "amount_cents": 4000, "expires_at_ts": \(Self.futureTs) }
+          ],
+          "total_usage_cents": 9000
+        }
+        """
+        let snapshot = try PerplexityUsageFetcher._parseResponseForTesting(Data(json.utf8), now: Self.now)
+
+        #expect(snapshot.recurringUsed == 5000) // recurring fully consumed
+        #expect(snapshot.purchasedUsed == 3000) // purchased fully consumed
+        #expect(snapshot.promoUsed == 1000) // 9000 - 5000 - 3000 = 1000 from promo
+    }
+
+    @Test
+    func `expired promotional grants are excluded`() throws {
+        let json = """
+        {
+          "balance_cents": 0,
+          "renewal_date_ts": \(Self.renewalTs),
+          "current_period_purchased_cents": 0,
+          "credit_grants": [
+            { "type": "recurring",   "amount_cents": 10000, "expires_at_ts": \(Self.futureTs) },
+            { "type": "promotional", "amount_cents": 5000,  "expires_at_ts": \(Self.pastTs) }
+          ],
+          "total_usage_cents": 1000
+        }
+        """
+        let snapshot = try PerplexityUsageFetcher._parseResponseForTesting(Data(json.utf8), now: Self.now)
+
+        #expect(snapshot.promoTotal == 0) // expired grant excluded
+        #expect(snapshot.promoUsed == 0)
+        #expect(snapshot.promoExpiration == nil)
+    }
+
+    @Test
+    func `empty credit grants produces zero recurring`() throws {
+        let json = """
+        {
+          "balance_cents": 0,
+          "renewal_date_ts": \(Self.renewalTs),
+          "current_period_purchased_cents": 0,
+          "credit_grants": [],
+          "total_usage_cents": 0
+        }
+        """
+        let snapshot = try PerplexityUsageFetcher._parseResponseForTesting(Data(json.utf8), now: Self.now)
+
+        #expect(snapshot.recurringTotal == 0)
+        #expect(snapshot.promoTotal == 0)
+        #expect(snapshot.purchasedTotal == 0)
+        #expect(snapshot.planName == nil)
+    }
+
+    @Test
+    func `malformed JSON throws parse failed`() {
+        let json = """
+        { "balance_cents": "not a number", "credit_grants": null }
+        """
+        #expect {
+            _ = try PerplexityUsageFetcher._parseResponseForTesting(Data(json.utf8), now: Self.now)
+        } throws: { error in
+            guard case PerplexityAPIError.parseFailed = error else { return false }
+            return true
+        }
+    }
+
+    // MARK: - Plan Name Inference
+
+    @Test
+    func `plan name inference`() throws {
+        func makeSnapshot(recurringCents: Double) throws -> PerplexityUsageSnapshot {
+            let json = """
+            {
+              "balance_cents": 0,
+              "renewal_date_ts": \(Self.renewalTs),
+              "current_period_purchased_cents": 0,
+              "credit_grants": [
+                { "type": "recurring", "amount_cents": \(recurringCents), "expires_at_ts": \(Self.futureTs) }
+              ],
+              "total_usage_cents": 0
+            }
+            """
+            return try PerplexityUsageFetcher._parseResponseForTesting(Data(json.utf8), now: Self.now)
+        }
+
+        #expect(try makeSnapshot(recurringCents: 0).planName == nil)
+        #expect(try makeSnapshot(recurringCents: 500).planName == "Pro")
+        #expect(try makeSnapshot(recurringCents: 1000).planName == "Pro")
+        #expect(try makeSnapshot(recurringCents: 10000).planName == "Max")
+    }
+
+    // MARK: - toUsageSnapshot
+
+    @Test
+    func `to usage snapshot always has secondary and tertiary`() throws {
+        let json = """
+        {
+          "balance_cents": 0,
+          "renewal_date_ts": \(Self.renewalTs),
+          "current_period_purchased_cents": 0,
+          "credit_grants": [
+            { "type": "recurring", "amount_cents": 10000, "expires_at_ts": \(Self.futureTs) }
+          ],
+          "total_usage_cents": 0
+        }
+        """
+        let snapshot = try PerplexityUsageFetcher._parseResponseForTesting(Data(json.utf8), now: Self.now)
+            .toUsageSnapshot()
+
+        // secondary and tertiary always present even when no promo/purchased credits
+        #expect(snapshot.secondary != nil)
+        #expect(snapshot.tertiary != nil)
+    }
+
+    @Test
+    func `to usage snapshot zero recurring bar is fully depleted`() throws {
+        let json = """
+        {
+          "balance_cents": 0,
+          "renewal_date_ts": \(Self.renewalTs),
+          "current_period_purchased_cents": 0,
+          "credit_grants": [],
+          "total_usage_cents": 0
+        }
+        """
+        let snapshot = try PerplexityUsageFetcher._parseResponseForTesting(Data(json.utf8), now: Self.now)
+            .toUsageSnapshot()
+        let primary = try #require(snapshot.primary)
+
+        // No recurring credits → bar renders as empty (100% used), not full (0% used)
+        #expect(primary.usedPercent == 100.0)
+    }
+
+    @Test
+    func `to usage snapshot omits primary when only fallback credits remain`() throws {
+        let json = """
+        {
+          "balance_cents": 6000,
+          "renewal_date_ts": \(Self.renewalTs),
+          "current_period_purchased_cents": 2000,
+          "credit_grants": [
+            { "type": "promotional", "amount_cents": 4000, "expires_at_ts": \(Self.futureTs) }
+          ],
+          "total_usage_cents": 0
+        }
+        """
+        let snapshot = try PerplexityUsageFetcher._parseResponseForTesting(Data(json.utf8), now: Self.now)
+            .toUsageSnapshot()
+
+        #expect(snapshot.primary == nil)
+        #expect(snapshot.secondary?.usedPercent == 0.0)
+        #expect(snapshot.tertiary?.usedPercent == 0.0)
+    }
+
+    @Test
+    func `to usage snapshot empty pools bars are fully depleted`() throws {
+        let json = """
+        {
+          "balance_cents": 0,
+          "renewal_date_ts": \(Self.renewalTs),
+          "current_period_purchased_cents": 0,
+          "credit_grants": [
+            { "type": "recurring", "amount_cents": 10000, "expires_at_ts": \(Self.futureTs) }
+          ],
+          "total_usage_cents": 0
+        }
+        """
+        let snapshot = try PerplexityUsageFetcher._parseResponseForTesting(Data(json.utf8), now: Self.now)
+            .toUsageSnapshot()
+        let secondary = try #require(snapshot.secondary)
+        let tertiary = try #require(snapshot.tertiary)
+
+        // Empty pools render as 100% used (empty bar) not 0% used (full bar)
+        #expect(secondary.usedPercent == 100.0)
+        #expect(tertiary.usedPercent == 100.0)
+    }
+
+    // MARK: - Purchased credits from credit_grants
+
+    @Test
+    func `purchased credits from credit grants array`() throws {
+        // Purchased credits appear as credit_grant type="purchased" instead of
+        // current_period_purchased_cents. The snapshot should pick them up.
+        let json = """
+        {
+          "balance_cents": 23065,
+          "renewal_date_ts": \(Self.renewalTs),
+          "current_period_purchased_cents": 0,
+          "credit_grants": [
+            { "type": "recurring",    "amount_cents": 10000, "expires_at_ts": \(Self.futureTs) },
+            { "type": "purchased",    "amount_cents": 40000 },
+            { "type": "promotional",  "amount_cents": 55000, "expires_at_ts": \(Self.futureTs) }
+          ],
+          "total_usage_cents": 81935
+        }
+        """
+        let snapshot = try PerplexityUsageFetcher._parseResponseForTesting(Data(json.utf8), now: Self.now)
+
+        #expect(snapshot.recurringTotal == 10000)
+        #expect(snapshot.purchasedTotal == 40000)
+        #expect(snapshot.promoTotal == 55000)
+
+        // Waterfall: recurring eats 10000, purchased eats 40000, promo eats 31935
+        #expect(snapshot.recurringUsed == 10000)
+        #expect(snapshot.purchasedUsed == 40000)
+        #expect(snapshot.promoUsed == 31935)
+    }
+
+    @Test
+    func `purchased credits prefer grants over field when both present`() throws {
+        // When both current_period_purchased_cents AND credit_grants type="purchased"
+        // are provided, the larger value wins.
+        let json = """
+        {
+          "balance_cents": 0,
+          "renewal_date_ts": \(Self.renewalTs),
+          "current_period_purchased_cents": 3000,
+          "credit_grants": [
+            { "type": "recurring",   "amount_cents": 5000, "expires_at_ts": \(Self.futureTs) },
+            { "type": "purchased",   "amount_cents": 8000 },
+            { "type": "promotional", "amount_cents": 4000, "expires_at_ts": \(Self.futureTs) }
+          ],
+          "total_usage_cents": 14000
+        }
+        """
+        let snapshot = try PerplexityUsageFetcher._parseResponseForTesting(Data(json.utf8), now: Self.now)
+
+        // Purchased should use max(8000, 3000) = 8000
+        #expect(snapshot.purchasedTotal == 8000)
+        // Waterfall: 5000 recurring + 8000 purchased + 1000 promo = 14000
+        #expect(snapshot.recurringUsed == 5000)
+        #expect(snapshot.purchasedUsed == 8000)
+        #expect(snapshot.promoUsed == 1000)
+    }
+
+    @Test
+    func `purchased credits from field when no grant type`() throws {
+        // Legacy path: current_period_purchased_cents is set but no "purchased" grant
+        let json = """
+        {
+          "balance_cents": 0,
+          "renewal_date_ts": \(Self.renewalTs),
+          "current_period_purchased_cents": 3000,
+          "credit_grants": [
+            { "type": "recurring",    "amount_cents": 5000, "expires_at_ts": \(Self.futureTs) },
+            { "type": "promotional",  "amount_cents": 4000, "expires_at_ts": \(Self.futureTs) }
+          ],
+          "total_usage_cents": 9000
+        }
+        """
+        let snapshot = try PerplexityUsageFetcher._parseResponseForTesting(Data(json.utf8), now: Self.now)
+
+        // Still picks up purchased from the top-level field
+        #expect(snapshot.purchasedTotal == 3000)
+        #expect(snapshot.recurringUsed == 5000)
+        #expect(snapshot.purchasedUsed == 3000)
+        #expect(snapshot.promoUsed == 1000)
+    }
+
+    @Test
+    func `real world max plan with all three pools`() throws {
+        // Real-world scenario: Max plan, 10k recurring + 40k purchased + 55k bonus
+        // Total 105,000 available, 23,065 remaining → 81,935 used
+        let json = """
+        {
+          "balance_cents": 23065,
+          "renewal_date_ts": \(Self.renewalTs),
+          "current_period_purchased_cents": 0,
+          "credit_grants": [
+            { "type": "recurring",    "amount_cents": 10000, "expires_at_ts": \(Self.futureTs) },
+            { "type": "purchased",    "amount_cents": 40000 },
+            { "type": "promotional",  "amount_cents": 55000, "expires_at_ts": \(Self.futureTs) }
+          ],
+          "total_usage_cents": 81935
+        }
+        """
+        let snapshot = try PerplexityUsageFetcher._parseResponseForTesting(Data(json.utf8), now: Self.now)
+        let usage = snapshot.toUsageSnapshot()
+
+        // Primary (recurring): fully consumed → 100%
+        let primary = try #require(usage.primary)
+        #expect(primary.usedPercent == 100.0)
+
+        // Tertiary (purchased): fully consumed → 100%
+        let tertiary = try #require(usage.tertiary)
+        #expect(tertiary.usedPercent == 100.0)
+
+        // Secondary (bonus): 31935/55000 ≈ 58.06% used → ~42% remaining
+        let secondary = try #require(usage.secondary)
+        let expectedPromoPercent = 31935.0 / 55000.0 * 100.0
+        #expect(abs(secondary.usedPercent - expectedPromoPercent) < 0.1)
+    }
+
+    @Test
+    func `to usage snapshot primary percent matches usage`() throws {
+        let json = """
+        {
+          "balance_cents": 0,
+          "renewal_date_ts": \(Self.renewalTs),
+          "current_period_purchased_cents": 0,
+          "credit_grants": [
+            { "type": "recurring", "amount_cents": 10000, "expires_at_ts": \(Self.futureTs) }
+          ],
+          "total_usage_cents": 2500
+        }
+        """
+        let snapshot = try PerplexityUsageFetcher._parseResponseForTesting(Data(json.utf8), now: Self.now)
+            .toUsageSnapshot()
+        let primary = try #require(snapshot.primary)
+
+        #expect(primary.usedPercent == 25.0)
+    }
+}
diff --git a/Tests/CodexBarTests/PiSessionCostScannerTests.swift b/Tests/CodexBarTests/PiSessionCostScannerTests.swift
new file mode 100644
index 0000000000..14a6bfe3a2
--- /dev/null
+++ b/Tests/CodexBarTests/PiSessionCostScannerTests.swift
@@ -0,0 +1,731 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct PiSessionCostScannerTests {
+    @Test
+    func `pi scanner maps assistant usage to codex and claude reports`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let codexDay = try env.makeLocalNoon(year: 2026, month: 4, day: 2)
+        let claudeDay = try env.makeLocalNoon(year: 2026, month: 4, day: 3)
+
+        let codexEntry: [String: Any] = [
+            "type": "message",
+            "timestamp": env.isoString(for: codexDay),
+            "message": [
+                "role": "assistant",
+                "provider": "openai-codex",
+                "model": "openai/gpt-5.4",
+                "timestamp": Int(codexDay.timeIntervalSince1970 * 1000),
+                "usage": [
+                    "input": 120,
+                    "output": 30,
+                    "cacheRead": 10,
+                    "cacheWrite": 5,
+                    "totalTokens": 165,
+                ],
+            ],
+        ]
+        let claudeEntry: [String: Any] = [
+            "type": "message",
+            "timestamp": env.isoString(for: claudeDay),
+            "message": [
+                "role": "assistant",
+                "provider": "anthropic",
+                "model": "anthropic.foo.claude-sonnet-4-6-v1:0",
+                "timestamp": Int(claudeDay.timeIntervalSince1970 * 1000),
+                "usage": [
+                    "input": 80,
+                    "output": 20,
+                    "cacheRead": 4,
+                    "cacheWrite": 6,
+                    "totalTokens": 110,
+                ],
+            ],
+        ]
+
+        _ = try env.writePiSessionFile(
+            relativePath: "nested/run-0/2026-04-02T10-00-00-000Z_test.jsonl",
+            contents: env.jsonl([codexEntry, claudeEntry]))
+
+        let options = PiSessionCostScanner.Options(
+            piSessionsRoot: env.piSessionsRoot,
+            cacheRoot: env.cacheRoot,
+            refreshMinIntervalSeconds: 0)
+
+        let codexReport = PiSessionCostScanner.loadDailyReport(
+            provider: .codex,
+            since: codexDay,
+            until: claudeDay,
+            now: claudeDay,
+            options: options)
+        let expectedCodexCost = CostUsagePricing.codexCostUSD(
+            model: "gpt-5.4",
+            inputTokens: 135,
+            cachedInputTokens: 10,
+            outputTokens: 30)
+        #expect(codexReport.data.count == 1)
+        #expect(codexReport.data.first?.date == "2026-04-02")
+        #expect(codexReport.data.first?.totalTokens == 165)
+        #expect(abs((codexReport.data.first?.costUSD ?? 0) - (expectedCodexCost ?? 0)) < 0.000001)
+        #expect(codexReport.data.first?.modelBreakdowns?.map(\.modelName) == ["gpt-5.4"])
+
+        let claudeReport = PiSessionCostScanner.loadDailyReport(
+            provider: .claude,
+            since: codexDay,
+            until: claudeDay,
+            now: claudeDay,
+            options: options)
+        let expectedClaudeCost = CostUsagePricing.claudeCostUSD(
+            model: "claude-sonnet-4-6",
+            inputTokens: 80,
+            cacheReadInputTokens: 4,
+            cacheCreationInputTokens: 6,
+            outputTokens: 20)
+        #expect(claudeReport.data.count == 1)
+        #expect(claudeReport.data.first?.date == "2026-04-03")
+        #expect(claudeReport.data.first?.totalTokens == 110)
+        #expect(abs((claudeReport.data.first?.costUSD ?? 0) - (expectedClaudeCost ?? 0)) < 0.000001)
+        #expect(claudeReport.data.first?.modelBreakdowns?.map(\.modelName) == ["claude-sonnet-4-6"])
+    }
+
+    @Test
+    func `pi scanner keeps ambiguous claude errors priced`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 6, day: 9)
+        let claudeEntry: [String: Any] = [
+            "type": "message",
+            "timestamp": env.isoString(for: day),
+            "message": [
+                "role": "assistant",
+                "provider": "anthropic",
+                "model": "claude-fable-5",
+                "stopReason": "error",
+                "errorMessage": "An unknown error occurred",
+                "timestamp": Int(day.timeIntervalSince1970 * 1000),
+                "usage": [
+                    "input": 100,
+                    "output": 0,
+                    "cacheRead": 20,
+                    "cacheWrite": 10,
+                    "totalTokens": 130,
+                ],
+            ],
+        ]
+
+        _ = try env.writePiSessionFile(
+            relativePath: "2026-06-09T10-00-00-000Z_refusal.jsonl",
+            contents: env.jsonl([claudeEntry]))
+
+        let report = PiSessionCostScanner.loadDailyReport(
+            provider: .claude,
+            since: day,
+            until: day,
+            now: day,
+            options: PiSessionCostScanner.Options(
+                piSessionsRoot: env.piSessionsRoot,
+                cacheRoot: env.cacheRoot,
+                refreshMinIntervalSeconds: 0))
+
+        #expect(report.data.count == 1)
+        #expect(report.data.first?.totalTokens == 130)
+        let expectedCost = CostUsagePricing.claudeCostUSD(
+            model: "claude-fable-5",
+            inputTokens: 100,
+            cacheReadInputTokens: 20,
+            cacheCreationInputTokens: 10,
+            outputTokens: 0)
+
+        #expect(abs((report.data.first?.costUSD ?? 0) - (expectedCost ?? 0)) < 0.000001)
+    }
+
+    @Test
+    func `pi scanner uses model change fallback and assistant timestamp day`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let sessionStart = try env.makeLocalNoon(year: 2026, month: 4, day: 1)
+        let assistantDay = try env.makeLocalNoon(year: 2026, month: 4, day: 2)
+
+        let modelChange: [String: Any] = [
+            "type": "model_change",
+            "timestamp": env.isoString(for: sessionStart),
+            "provider": "openai-codex",
+            "modelId": "openai/gpt-5.3-codex",
+        ]
+        let assistant: [String: Any] = [
+            "type": "message",
+            "timestamp": env.isoString(for: sessionStart),
+            "message": [
+                "role": "assistant",
+                "timestamp": Int(assistantDay.timeIntervalSince1970 * 1000),
+                "usage": [
+                    "input": 20,
+                    "cacheRead": 2,
+                    "output": 20,
+                    "totalTokens": 42,
+                ],
+            ],
+        ]
+
+        _ = try env.writePiSessionFile(
+            relativePath: "2026-04-01T09-00-00-000Z_test.jsonl",
+            contents: env.jsonl([modelChange, assistant]))
+
+        let report = PiSessionCostScanner.loadDailyReport(
+            provider: .codex,
+            since: sessionStart,
+            until: assistantDay,
+            now: assistantDay,
+            options: PiSessionCostScanner.Options(
+                piSessionsRoot: env.piSessionsRoot,
+                cacheRoot: env.cacheRoot,
+                refreshMinIntervalSeconds: 0))
+
+        let expectedCost = CostUsagePricing.codexCostUSD(
+            model: "gpt-5.3-codex",
+            inputTokens: 22,
+            cachedInputTokens: 2,
+            outputTokens: 20)
+        #expect(report.data.count == 1)
+        #expect(report.data.first?.date == "2026-04-02")
+        #expect(report.data.first?.totalTokens == 42)
+        #expect(abs((report.data.first?.costUSD ?? 0) - (expectedCost ?? 0)) < 0.000001)
+        #expect(report.data.first?.modelBreakdowns?.map(\.modelName) == ["gpt-5.3-codex"])
+    }
+
+    @Test
+    func `pi scanner refreshes appended file without duplicating existing usage`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 4, day: 4)
+        let firstTimestamp = Int(day.timeIntervalSince1970 * 1000)
+        let secondTimestamp = Int(day.addingTimeInterval(60).timeIntervalSince1970 * 1000)
+
+        let firstAssistant: [String: Any] = [
+            "type": "message",
+            "timestamp": env.isoString(for: day),
+            "message": [
+                "role": "assistant",
+                "provider": "openai-codex",
+                "model": "openai/gpt-5.4",
+                "timestamp": firstTimestamp,
+                "usage": [
+                    "input": 10,
+                    "output": 5,
+                    "totalTokens": 15,
+                ],
+            ],
+        ]
+        let secondAssistant: [String: Any] = [
+            "type": "message",
+            "timestamp": env.isoString(for: day),
+            "message": [
+                "role": "assistant",
+                "provider": "openai-codex",
+                "model": "gpt-5.4",
+                "timestamp": secondTimestamp,
+                "usage": [
+                    "input": 20,
+                    "output": 10,
+                    "totalTokens": 30,
+                ],
+            ],
+        ]
+
+        let url = try env.writePiSessionFile(
+            relativePath: "2026-04-04T10-00-00-000Z_test.jsonl",
+            contents: env.jsonl([firstAssistant]))
+
+        let options = PiSessionCostScanner.Options(
+            piSessionsRoot: env.piSessionsRoot,
+            cacheRoot: env.cacheRoot,
+            refreshMinIntervalSeconds: 0)
+        let firstReport = PiSessionCostScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+        let firstExpectedCost = CostUsagePricing.codexCostUSD(
+            model: "gpt-5.4",
+            inputTokens: 10,
+            cachedInputTokens: 0,
+            outputTokens: 5)
+        #expect(firstReport.data.count == 1)
+        #expect(firstReport.data.first?.totalTokens == 15)
+        #expect(abs((firstReport.data.first?.costUSD ?? 0) - (firstExpectedCost ?? 0)) < 0.000001)
+
+        try env.jsonl([firstAssistant, secondAssistant]).write(to: url, atomically: true, encoding: .utf8)
+
+        let secondReport = PiSessionCostScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: options)
+        let secondExpectedCost = (firstExpectedCost ?? 0) + (CostUsagePricing.codexCostUSD(
+            model: "gpt-5.4",
+            inputTokens: 20,
+            cachedInputTokens: 0,
+            outputTokens: 10) ?? 0)
+        #expect(secondReport.data.count == 1)
+        #expect(secondReport.data.first?.totalTokens == 45)
+        #expect(abs((secondReport.data.first?.costUSD ?? 0) - secondExpectedCost) < 0.000001)
+    }
+
+    @Test
+    func `pi scanner ignores explicit unsupported provider even with fallback context`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 4, day: 5)
+        let modelChange: [String: Any] = [
+            "type": "model_change",
+            "timestamp": env.isoString(for: day),
+            "provider": "openai-codex",
+            "modelId": "gpt-5.4",
+        ]
+        let unsupportedAssistant: [String: Any] = [
+            "type": "message",
+            "timestamp": env.isoString(for: day),
+            "message": [
+                "role": "assistant",
+                "provider": "openrouter",
+                "model": "gpt-5.4",
+                "timestamp": Int(day.timeIntervalSince1970 * 1000),
+                "usage": [
+                    "input": 99,
+                    "output": 1,
+                    "totalTokens": 100,
+                ],
+            ],
+        ]
+        let fallbackAssistant: [String: Any] = [
+            "type": "message",
+            "timestamp": env.isoString(for: day.addingTimeInterval(60)),
+            "message": [
+                "role": "assistant",
+                "timestamp": Int(day.addingTimeInterval(60).timeIntervalSince1970 * 1000),
+                "usage": [
+                    "input": 10,
+                    "output": 5,
+                    "totalTokens": 15,
+                ],
+            ],
+        ]
+
+        _ = try env.writePiSessionFile(
+            relativePath: "2026-04-05T10-00-00-000Z_test.jsonl",
+            contents: env.jsonl([modelChange, unsupportedAssistant, fallbackAssistant]))
+
+        let report = PiSessionCostScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: PiSessionCostScanner.Options(
+                piSessionsRoot: env.piSessionsRoot,
+                cacheRoot: env.cacheRoot,
+                refreshMinIntervalSeconds: 0))
+
+        #expect(report.data.count == 1)
+        #expect(report.data.first?.totalTokens == 15)
+        #expect(report.data.first?.modelBreakdowns?.map(\.modelName) == ["gpt-5.4"])
+    }
+
+    @Test
+    func `pi scanner force rescan bypasses stale same size metadata cache`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 4, day: 6)
+        let assistantOne: [String: Any] = [
+            "type": "message",
+            "timestamp": env.isoString(for: day),
+            "message": [
+                "role": "assistant",
+                "provider": "openai-codex",
+                "model": "gpt-5.4",
+                "timestamp": Int(day.timeIntervalSince1970 * 1000),
+                "usage": [
+                    "input": 10,
+                    "output": 5,
+                    "totalTokens": 15,
+                ],
+            ],
+        ]
+        let assistantTwo: [String: Any] = [
+            "type": "message",
+            "timestamp": env.isoString(for: day),
+            "message": [
+                "role": "assistant",
+                "provider": "openai-codex",
+                "model": "gpt-5.4",
+                "timestamp": Int(day.timeIntervalSince1970 * 1000),
+                "usage": [
+                    "input": 20,
+                    "output": 5,
+                    "totalTokens": 25,
+                ],
+            ],
+        ]
+
+        let firstContents = try env.jsonl([assistantOne])
+        let secondContents = try env.jsonl([assistantTwo])
+        #expect(firstContents.utf8.count == secondContents.utf8.count)
+
+        let url = try env.writePiSessionFile(
+            relativePath: "2026-04-06T10-00-00-000Z_test.jsonl",
+            contents: firstContents)
+        let originalModifiedAt = try #require(
+            FileManager.default.attributesOfItem(atPath: url.path)[.modificationDate] as? Date)
+
+        let cachedOptions = PiSessionCostScanner.Options(
+            piSessionsRoot: env.piSessionsRoot,
+            cacheRoot: env.cacheRoot,
+            refreshMinIntervalSeconds: 0)
+        let firstReport = PiSessionCostScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: cachedOptions)
+        #expect(firstReport.data.first?.totalTokens == 15)
+
+        try secondContents.write(to: url, atomically: true, encoding: .utf8)
+        try FileManager.default.setAttributes([.modificationDate: originalModifiedAt], ofItemAtPath: url.path)
+
+        let staleReport = PiSessionCostScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: cachedOptions)
+        #expect(staleReport.data.first?.totalTokens == 15)
+
+        let refreshedReport = PiSessionCostScanner.loadDailyReport(
+            provider: .codex,
+            since: day,
+            until: day,
+            now: day,
+            options: PiSessionCostScanner.Options(
+                piSessionsRoot: env.piSessionsRoot,
+                cacheRoot: env.cacheRoot,
+                refreshMinIntervalSeconds: 0,
+                forceRescan: true))
+        #expect(refreshedReport.data.first?.totalTokens == 25)
+    }
+
+    @Test
+    func `pi scanner derives cost when explicit cost is absent`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 4, day: 7)
+        let assistant: [String: Any] = [
+            "type": "message",
+            "timestamp": env.isoString(for: day),
+            "message": [
+                "role": "assistant",
+                "provider": "anthropic",
+                "model": "claude-sonnet-4-6",
+                "timestamp": Int(day.timeIntervalSince1970 * 1000),
+                "usage": [
+                    "input": 70,
+                    "cacheRead": 4,
+                    "cacheWrite": 6,
+                    "output": 19,
+                    "totalTokens": 99,
+                ],
+            ],
+        ]
+
+        _ = try env.writePiSessionFile(
+            relativePath: "2026-04-07T10-00-00-000Z_test.jsonl",
+            contents: env.jsonl([assistant]))
+
+        let report = PiSessionCostScanner.loadDailyReport(
+            provider: .claude,
+            since: day,
+            until: day,
+            now: day,
+            options: PiSessionCostScanner.Options(
+                piSessionsRoot: env.piSessionsRoot,
+                cacheRoot: env.cacheRoot,
+                refreshMinIntervalSeconds: 0))
+
+        let expectedCost = CostUsagePricing.claudeCostUSD(
+            model: "claude-sonnet-4-6",
+            inputTokens: 70,
+            cacheReadInputTokens: 4,
+            cacheCreationInputTokens: 6,
+            outputTokens: 19)
+        #expect(report.data.count == 1)
+        #expect(report.data.first?.totalTokens == 99)
+        #expect(abs((report.data.first?.costUSD ?? 0) - (expectedCost ?? 0)) < 0.000001)
+    }
+
+    @Test
+    func `pi scanner preserves per-message threshold pricing`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 9)
+        let model = "claude-sonnet-4-5"
+        let firstAssistant: [String: Any] = [
+            "type": "message",
+            "timestamp": env.isoString(for: day),
+            "message": [
+                "role": "assistant",
+                "provider": "anthropic",
+                "model": model,
+                "timestamp": Int(day.timeIntervalSince1970 * 1000),
+                "usage": [
+                    "input": 150_000,
+                    "output": 0,
+                    "totalTokens": 150_000,
+                ],
+            ],
+        ]
+        let secondAssistant: [String: Any] = [
+            "type": "message",
+            "timestamp": env.isoString(for: day.addingTimeInterval(1)),
+            "message": [
+                "role": "assistant",
+                "provider": "anthropic",
+                "model": model,
+                "timestamp": Int(day.addingTimeInterval(1).timeIntervalSince1970 * 1000),
+                "usage": [
+                    "input": 150_000,
+                    "output": 0,
+                    "totalTokens": 150_000,
+                ],
+            ],
+        ]
+
+        _ = try env.writePiSessionFile(
+            relativePath: "2026-05-09T10-00-00-000Z_threshold.jsonl",
+            contents: env.jsonl([firstAssistant, secondAssistant]))
+
+        let report = PiSessionCostScanner.loadDailyReport(
+            provider: .claude,
+            since: day,
+            until: day,
+            now: day,
+            options: PiSessionCostScanner.Options(
+                piSessionsRoot: env.piSessionsRoot,
+                cacheRoot: env.cacheRoot,
+                refreshMinIntervalSeconds: 0))
+        let expectedRequestCost = CostUsagePricing.claudeCostUSD(
+            model: model,
+            inputTokens: 150_000,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+            outputTokens: 0,
+            modelsDevCacheRoot: env.cacheRoot) ?? 0
+        let aggregateCost = CostUsagePricing.claudeCostUSD(
+            model: model,
+            inputTokens: 300_000,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+            outputTokens: 0,
+            modelsDevCacheRoot: env.cacheRoot) ?? 0
+        let expectedCost = expectedRequestCost * 2
+
+        #expect(report.data.count == 1)
+        #expect(report.data.first?.totalTokens == 300_000)
+        #expect(abs((report.data.first?.costUSD ?? 0) - expectedCost) < 0.000001)
+        #expect(abs((report.data.first?.costUSD ?? 0) - aggregateCost) > 0.000001)
+        #expect(abs((report.data.first?.modelBreakdowns?.first?.costUSD ?? 0) - expectedCost) < 0.000001)
+    }
+
+    @Test
+    func `pi scanner ignores v2 cache with stale claude pricing`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 5, day: 10)
+        let model = "claude-sonnet-4-5"
+        let firstAssistant: [String: Any] = [
+            "type": "message",
+            "timestamp": env.isoString(for: day),
+            "message": [
+                "role": "assistant",
+                "provider": "anthropic",
+                "model": model,
+                "timestamp": Int(day.timeIntervalSince1970 * 1000),
+                "usage": [
+                    "input": 150_000,
+                    "output": 0,
+                    "totalTokens": 150_000,
+                ],
+            ],
+        ]
+        let secondAssistant: [String: Any] = [
+            "type": "message",
+            "timestamp": env.isoString(for: day.addingTimeInterval(1)),
+            "message": [
+                "role": "assistant",
+                "provider": "anthropic",
+                "model": model,
+                "timestamp": Int(day.addingTimeInterval(1).timeIntervalSince1970 * 1000),
+                "usage": [
+                    "input": 150_000,
+                    "output": 0,
+                    "totalTokens": 150_000,
+                ],
+            ],
+        ]
+
+        let fileURL = try env.writePiSessionFile(
+            relativePath: "2026-05-10T10-00-00-000Z_threshold.jsonl",
+            contents: env.jsonl([firstAssistant, secondAssistant]))
+        let attrs = try FileManager.default.attributesOfItem(atPath: fileURL.path)
+        let mtime = try #require(attrs[.modificationDate] as? Date)
+        let size = try #require((attrs[.size] as? NSNumber)?.int64Value)
+
+        let requestCost = CostUsagePricing.claudeCostUSD(
+            model: model,
+            inputTokens: 150_000,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+            outputTokens: 0,
+            modelsDevCacheRoot: env.cacheRoot) ?? 0
+        let aggregateCost = CostUsagePricing.claudeCostUSD(
+            model: model,
+            inputTokens: 300_000,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+            outputTokens: 0,
+            modelsDevCacheRoot: env.cacheRoot) ?? 0
+        let aggregatePacked = PiPackedUsage(
+            inputTokens: 300_000,
+            totalTokens: 300_000,
+            costNanos: Int64((aggregateCost * 1_000_000_000).rounded()),
+            costSampleCount: 2,
+            usageSampleCount: 2)
+        let dayKey = "2026-05-10"
+        let contributions = [
+            UsageProvider.claude.rawValue: [
+                dayKey: [
+                    model: aggregatePacked,
+                ],
+            ],
+        ]
+        let oldFileUsage = PiSessionFileUsage(
+            mtimeUnixMs: Int64(mtime.timeIntervalSince1970 * 1000),
+            size: size,
+            parsedBytes: size,
+            lastModelContext: nil,
+            contributions: contributions)
+        var oldCache = PiSessionCostCache(version: 2)
+        oldCache.lastScanUnixMs = Int64(day.timeIntervalSince1970 * 1000)
+        oldCache.scanSinceKey = dayKey
+        oldCache.scanUntilKey = dayKey
+        oldCache.daysByProvider = contributions
+        oldCache.files = [fileURL.path: oldFileUsage]
+        let oldCacheURL = env.cacheRoot
+            .appendingPathComponent("cost-usage", isDirectory: true)
+            .appendingPathComponent("pi-sessions-v2.json", isDirectory: false)
+        try FileManager.default.createDirectory(
+            at: oldCacheURL.deletingLastPathComponent(),
+            withIntermediateDirectories: true)
+        try JSONEncoder().encode(oldCache).write(to: oldCacheURL)
+
+        let report = PiSessionCostScanner.loadDailyReport(
+            provider: .claude,
+            since: day,
+            until: day,
+            now: day,
+            options: PiSessionCostScanner.Options(
+                piSessionsRoot: env.piSessionsRoot,
+                cacheRoot: env.cacheRoot,
+                refreshMinIntervalSeconds: 3600))
+
+        let expectedCost = requestCost * 2
+        #expect(report.data.count == 1)
+        #expect(report.data.first?.totalTokens == 300_000)
+        #expect(abs((report.data.first?.costUSD ?? 0) - expectedCost) < 0.000001)
+        #expect(abs((report.data.first?.costUSD ?? 0) - aggregateCost) > 0.000001)
+
+        let newCacheURL = PiSessionCostCacheIO.cacheFileURL(cacheRoot: env.cacheRoot)
+        #expect(FileManager.default.fileExists(atPath: newCacheURL.path))
+        let newCache = PiSessionCostCacheIO.load(cacheRoot: env.cacheRoot)
+        let rebuilt = newCache.daysByProvider[UsageProvider.claude.rawValue]?[dayKey]?[model]
+        #expect(newCacheURL.lastPathComponent == "pi-sessions-v3.json")
+        #expect(newCache.version == 3)
+        #expect(rebuilt?.usageSampleCount == 2)
+        #expect(rebuilt?.costSampleCount == 2)
+    }
+
+    @Test
+    func `pi scanner reparses unchanged cached file when scan window expands`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let oldDay = try env.makeLocalNoon(year: 2026, month: 4, day: 2)
+        let newDay = try env.makeLocalNoon(year: 2026, month: 4, day: 8)
+        let oldAssistant: [String: Any] = [
+            "type": "message",
+            "timestamp": env.isoString(for: oldDay),
+            "message": [
+                "role": "assistant",
+                "provider": "openai-codex",
+                "model": "gpt-5.4",
+                "timestamp": Int(oldDay.timeIntervalSince1970 * 1000),
+                "usage": [
+                    "input": 10,
+                    "output": 5,
+                    "totalTokens": 15,
+                ],
+            ],
+        ]
+        let newAssistant: [String: Any] = [
+            "type": "message",
+            "timestamp": env.isoString(for: newDay),
+            "message": [
+                "role": "assistant",
+                "provider": "openai-codex",
+                "model": "gpt-5.4",
+                "timestamp": Int(newDay.timeIntervalSince1970 * 1000),
+                "usage": [
+                    "input": 20,
+                    "output": 10,
+                    "totalTokens": 30,
+                ],
+            ],
+        ]
+
+        _ = try env.writePiSessionFile(
+            relativePath: "2026-04-08T10-00-00-000Z_test.jsonl",
+            contents: env.jsonl([oldAssistant, newAssistant]))
+
+        let options = PiSessionCostScanner.Options(
+            piSessionsRoot: env.piSessionsRoot,
+            cacheRoot: env.cacheRoot,
+            refreshMinIntervalSeconds: 3600)
+        let narrowReport = PiSessionCostScanner.loadDailyReport(
+            provider: .codex,
+            since: newDay,
+            until: newDay,
+            now: newDay,
+            options: options)
+        #expect(narrowReport.data.map(\.date) == ["2026-04-08"])
+        #expect(narrowReport.data.first?.totalTokens == 30)
+
+        let expandedReport = PiSessionCostScanner.loadDailyReport(
+            provider: .codex,
+            since: oldDay,
+            until: newDay,
+            now: newDay.addingTimeInterval(1),
+            options: options)
+        #expect(expandedReport.data.map(\.date) == ["2026-04-02", "2026-04-08"])
+        #expect(expandedReport.summary?.totalTokens == 45)
+    }
+}
diff --git a/Tests/CodexBarTests/PlanUtilizationHistoryChartMenuViewTests.swift b/Tests/CodexBarTests/PlanUtilizationHistoryChartMenuViewTests.swift
new file mode 100644
index 0000000000..dd86189a39
--- /dev/null
+++ b/Tests/CodexBarTests/PlanUtilizationHistoryChartMenuViewTests.swift
@@ -0,0 +1,88 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct PlanUtilizationHistoryChartMenuViewTests {
+    @Test
+    func `merged entries preserve first occurrence order while removing duplicates`() {
+        let first = PlanUtilizationHistoryEntry(
+            capturedAt: Date(timeIntervalSince1970: 100),
+            usedPercent: 10,
+            resetsAt: Date(timeIntervalSince1970: 200))
+        let second = PlanUtilizationHistoryEntry(
+            capturedAt: Date(timeIntervalSince1970: 300),
+            usedPercent: 20,
+            resetsAt: nil)
+
+        let merged = PlanUtilizationHistoryChartMenuView.mergedEntries([
+            first,
+            second,
+            first,
+            second,
+        ])
+
+        #expect(merged == [first, second])
+    }
+
+    @Test
+    func `generic primary weekly window keeps weekly history visible`() {
+        let history = PlanUtilizationSeriesHistory(
+            name: .weekly,
+            windowMinutes: 10080,
+            entries: [
+                PlanUtilizationHistoryEntry(
+                    capturedAt: Date(timeIntervalSince1970: 1_700_000_000),
+                    usedPercent: 42,
+                    resetsAt: nil),
+            ])
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 42, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date(timeIntervalSince1970: 1_700_000_000))
+
+        let model = PlanUtilizationHistoryChartMenuView._modelSnapshotForTesting(
+            histories: [history],
+            provider: .zai,
+            snapshot: snapshot)
+
+        #expect(model.visibleSeries == ["weekly:10080"])
+        #expect(model.selectedSeries == "weekly:10080")
+    }
+
+    @Test
+    func `generic unknown weekly extra window does not filter saved history`() {
+        let history = PlanUtilizationSeriesHistory(
+            name: .weekly,
+            windowMinutes: 10080,
+            entries: [
+                PlanUtilizationHistoryEntry(
+                    capturedAt: Date(timeIntervalSince1970: 1_700_000_000),
+                    usedPercent: 42,
+                    resetsAt: nil),
+            ])
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            extraRateWindows: [
+                NamedRateWindow(
+                    id: "weekly-reset-only",
+                    title: "Weekly reset",
+                    window: RateWindow(
+                        usedPercent: 0,
+                        windowMinutes: 10080,
+                        resetsAt: Date(timeIntervalSince1970: 1_700_003_600),
+                        resetDescription: nil),
+                    usageKnown: false),
+            ],
+            updatedAt: Date(timeIntervalSince1970: 1_700_000_000))
+
+        let model = PlanUtilizationHistoryChartMenuView._modelSnapshotForTesting(
+            histories: [history],
+            provider: .zed,
+            snapshot: snapshot)
+
+        #expect(model.visibleSeries == ["weekly:10080"])
+        #expect(model.selectedSeries == "weekly:10080")
+    }
+}
diff --git a/Tests/CodexBarTests/PoeSettingsReaderTests.swift b/Tests/CodexBarTests/PoeSettingsReaderTests.swift
new file mode 100644
index 0000000000..efc3f8095e
--- /dev/null
+++ b/Tests/CodexBarTests/PoeSettingsReaderTests.swift
@@ -0,0 +1,11 @@
+import CodexBarCore
+import Foundation
+import Testing
+
+struct PoeSettingsReaderTests {
+    @Test
+    func `api key trims quotes`() {
+        let env = [PoeSettingsReader.apiKeyEnvironmentKey: " 'poe-key' "]
+        #expect(PoeSettingsReader.apiKey(environment: env) == "poe-key")
+    }
+}
diff --git a/Tests/CodexBarTests/PoeUsageFetcherTests.swift b/Tests/CodexBarTests/PoeUsageFetcherTests.swift
new file mode 100644
index 0000000000..840541d95b
--- /dev/null
+++ b/Tests/CodexBarTests/PoeUsageFetcherTests.swift
@@ -0,0 +1,251 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct PoeUsageFetcherTests {
+    @Test
+    func `parse snapshot extracts current point balance`() throws {
+        let json = #"{"current_point_balance": 1500}"#
+        let data = Data(json.utf8)
+        let snapshot = try PoeUsageFetcher._parseSnapshotForTesting(data)
+        #expect(snapshot.currentPointBalance == 1500)
+    }
+
+    @Test
+    func `parse snapshot accepts string-encoded balance`() throws {
+        let json = #"{"current_point_balance": "2500"}"#
+        let snapshot = try PoeUsageFetcher._parseSnapshotForTesting(Data(json.utf8))
+        #expect(snapshot.currentPointBalance == 2500)
+    }
+
+    @Test
+    func `parse snapshot returns nil balance when absent`() throws {
+        let json = #"{}"#
+        let snapshot = try PoeUsageFetcher._parseSnapshotForTesting(Data(json.utf8))
+        #expect(snapshot.currentPointBalance == nil)
+    }
+
+    @Test
+    func `parse snapshot throws on malformed JSON`() {
+        #expect {
+            _ = try PoeUsageFetcher._parseSnapshotForTesting(Data("not-json".utf8))
+        } throws: { error in
+            guard case PoeUsageError.parseFailed = error else { return false }
+            return true
+        }
+    }
+
+    @Test
+    func `snapshot maps balance to identity loginMethod only, not RateWindow`() {
+        let snapshot = PoeUsageSnapshot(
+            currentPointBalance: 500,
+            updatedAt: Date())
+
+        let unified = snapshot.toUsageSnapshot()
+        // No rate windows — balance is not a usage percentage
+        #expect(unified.primary == nil)
+        #expect(unified.secondary == nil)
+        #expect(unified.tertiary == nil)
+        // Balance lives in identity.loginMethod as "Balance: X points"
+        #expect(unified.identity?.providerID == .poe)
+        #expect(unified.identity?.loginMethod == "Balance: 500 points")
+    }
+
+    @Test
+    func `snapshot hides balance when balance is absent`() {
+        let snapshot = PoeUsageSnapshot(
+            currentPointBalance: nil,
+            updatedAt: Date())
+
+        let unified = snapshot.toUsageSnapshot()
+        #expect(unified.primary == nil)
+        #expect(unified.identity?.loginMethod == nil)
+    }
+
+    @Test
+    func `missing credentials fetch call throws missing credentials`() async {
+        do {
+            _ = try await PoeUsageFetcher.fetchUsage(apiKey: "   ")
+            Issue.record("Expected missingCredentials error")
+        } catch let error as PoeUsageError {
+            guard case .missingCredentials = error else {
+                Issue.record("Expected .missingCredentials but got \(error)")
+                return
+            }
+        } catch {
+            Issue.record("Unexpected error: \(error)")
+        }
+    }
+
+    @Test
+    func `compact number formats thousands with no decimals`() {
+        #expect(PoeUsageSnapshot.compactNumber(1500) == "1,500")
+        #expect(PoeUsageSnapshot.compactNumber(999) == "999")
+        #expect(PoeUsageSnapshot.compactNumber(10000) == "10,000")
+    }
+
+    @Test
+    func `history page parser extracts entries and cursor`() throws {
+        let json = """
+        {
+          "data": [
+            {
+              "query_id": "a1",
+              "creation_time": 1717000000000000,
+              "bot_name": "GPT-4o",
+              "usage_type": "API",
+              "cost_points": 12.5,
+              "cost_usd": "0.03"
+            },
+            {
+              "query_id": "a2",
+              "creation_time": 1717003600,
+              "bot_name": "Claude Sonnet",
+              "usage_type": "Chat",
+              "cost_points": "8",
+              "usd": "0.02"
+            }
+          ],
+          "next_cursor": "cursor-2"
+        }
+        """
+
+        let parsed = try PoeUsageFetcher._parseHistoryPageForTesting(Data(json.utf8))
+        #expect(parsed.entries.count == 2)
+        #expect(parsed.entries[0].model == "GPT-4o")
+        #expect(parsed.entries[0].points == 12.5)
+        #expect(parsed.entries[0].id == "a1")
+        #expect(parsed.entries[1].costUSD == 0.02)
+        #expect(parsed.nextCursor == "cursor-2")
+    }
+
+    @Test
+    func `history parser derives cursor from has_more and last query id`() throws {
+        let json = """
+        {
+          "has_more": true,
+          "data": [
+            {
+              "query_id": "q-1",
+              "creation_time": 1717000000,
+              "bot_name": "GPT-4o",
+              "usage_type": "API",
+              "cost_points": 3
+            },
+            {
+              "query_id": "q-2",
+              "creation_time": 1717003600,
+              "bot_name": "Claude Sonnet",
+              "usage_type": "Chat",
+              "cost_points": 9
+            }
+          ]
+        }
+        """
+
+        let parsed = try PoeUsageFetcher._parseHistoryPageForTesting(Data(json.utf8))
+        #expect(parsed.entries.count == 2)
+        #expect(parsed.nextCursor == "q-2")
+    }
+
+    @Test
+    func `history daily aggregation groups by utc day`() {
+        let entries = [
+            PoeUsageHistorySnapshot.Entry(
+                id: "1",
+                createdAt: Date(timeIntervalSince1970: 1_717_000_000),
+                model: "GPT-4o",
+                usageType: "inference",
+                points: 10,
+                costUSD: 0.02),
+            PoeUsageHistorySnapshot.Entry(
+                id: "2",
+                createdAt: Date(timeIntervalSince1970: 1_717_000_100),
+                model: "GPT-4o",
+                usageType: "inference",
+                points: 5,
+                costUSD: 0.01),
+        ]
+
+        let daily = PoeUsageFetcher._buildDailyBucketsForTesting(entries: entries)
+        #expect(daily.count == 1)
+        #expect(daily[0].requests == 2)
+        #expect(daily[0].points == 15)
+        #expect(daily[0].costUSD == 0.03)
+    }
+
+    @Test
+    func `fetch usage returns balance when points history endpoint fails`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            let path = url.path
+            let response: (Data, Int)
+            if path.contains("current_balance") {
+                response = (Data(#"{"current_point_balance": 1500}"#.utf8), 200)
+            } else if path.contains("points_history") {
+                // Simulate a 500 from the optional history endpoint.
+                response = (Data("server error".utf8), 500)
+            } else {
+                Issue.record("Unexpected request: \(url.absoluteString)")
+                return Self.httpResponse(url: nil, status: 0)
+            }
+            return Self.httpResponse(url: nil, status: response.1, body: response.0)
+        }
+
+        let snapshot = try await PoeUsageFetcher._fetchUsage(
+            apiKey: "test-key",
+            transport: transport)
+
+        #expect(snapshot.currentPointBalance == 1500)
+        // History should be nil, not propagate the failure.
+        #expect(snapshot.history == nil)
+    }
+
+    @Test
+    func `fetch usage surfaces history snapshot when history endpoint succeeds`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            let url = try #require(request.url)
+            let path = url.path
+            if path.contains("current_balance") {
+                return Self.httpResponse(
+                    url: nil,
+                    status: 200,
+                    body: Data(#"{"current_point_balance": 2500}"#.utf8))
+            }
+            if path.contains("points_history") {
+                return Self.httpResponse(
+                    url: nil,
+                    status: 200,
+                    body: Data("""
+                    {"data":[],"next_cursor":null}
+                    """.utf8))
+            }
+            Issue.record("Unexpected request: \(url.absoluteString)")
+            return Self.httpResponse(url: nil, status: 0)
+        }
+
+        let snapshot = try await PoeUsageFetcher._fetchUsage(
+            apiKey: "test-key",
+            transport: transport)
+
+        #expect(snapshot.currentPointBalance == 2500)
+        // Empty history page still produces a non-nil snapshot with empty buckets.
+        #expect(snapshot.history == nil)
+    }
+}
+
+extension PoeUsageFetcherTests {
+    fileprivate static func httpResponse(
+        url: URL?,
+        status: Int,
+        body: Data = Data()) -> (Data, URLResponse)
+    {
+        let response = HTTPURLResponse(
+            url: url ?? URL(string: "https://example.invalid")!,
+            statusCode: status,
+            httpVersion: "HTTP/1.1",
+            headerFields: nil) ?? HTTPURLResponse()
+        return (body, response)
+    }
+}
diff --git a/Tests/CodexBarTests/PoeUsageHistorySnapshotTests.swift b/Tests/CodexBarTests/PoeUsageHistorySnapshotTests.swift
new file mode 100644
index 0000000000..c24fc82f5b
--- /dev/null
+++ b/Tests/CodexBarTests/PoeUsageHistorySnapshotTests.swift
@@ -0,0 +1,416 @@
+import CodexBarCore
+import Foundation
+import Testing
+
+struct PoeUsageHistorySnapshotTests {
+    // MARK: - summary(days:)
+
+    @Test
+    func `summary over empty daily returns zeroed summary with nil cost`() {
+        let snapshot = PoeUsageHistorySnapshot(
+            entries: [],
+            daily: [],
+            updatedAt: Date())
+
+        let summary = snapshot.summary(days: 7)
+
+        #expect(summary.points == 0)
+        #expect(summary.requests == 0)
+        #expect(summary.costUSD == nil)
+    }
+
+    @Test
+    func `summary over single day reports that day's points and requests`() {
+        let snapshot = PoeUsageHistorySnapshot(
+            entries: [],
+            daily: [PoeUsageHistorySnapshot.DailyBucket(
+                day: "2026-05-31",
+                points: 250,
+                requests: 3,
+                costUSD: 0.05)],
+            updatedAt: Date())
+
+        let summary = snapshot.summary(days: 1)
+
+        #expect(summary.points == 250)
+        #expect(summary.requests == 3)
+        #expect(summary.costUSD == 0.05)
+    }
+
+    @Test
+    func `summary over seven days uses the last seven daily buckets`() {
+        let daily: [PoeUsageHistorySnapshot.DailyBucket] = (1...10).map { offset in
+            PoeUsageHistorySnapshot.DailyBucket(
+                day: String(format: "2026-05-%02d", offset),
+                points: Double(offset * 10),
+                requests: offset,
+                costUSD: nil)
+        }
+        let snapshot = PoeUsageHistorySnapshot(
+            entries: [],
+            daily: daily,
+            updatedAt: Date())
+
+        // Last 7 buckets: offsets 4..10 → 40+50+60+70+80+90+100 = 490
+        let summary = snapshot.summary(days: 7)
+
+        #expect(summary.points == 490)
+        #expect(summary.requests == 4 + 5 + 6 + 7 + 8 + 9 + 10)
+        #expect(summary.costUSD == nil)
+    }
+
+    @Test
+    func `summary clamps zero and negative day counts up to one`() {
+        let snapshot = PoeUsageHistorySnapshot(
+            entries: [],
+            daily: [
+                PoeUsageHistorySnapshot.DailyBucket(day: "2026-05-29", points: 100, requests: 1, costUSD: nil),
+                PoeUsageHistorySnapshot.DailyBucket(day: "2026-05-30", points: 200, requests: 2, costUSD: nil),
+                PoeUsageHistorySnapshot.DailyBucket(day: "2026-05-31", points: 300, requests: 3, costUSD: nil),
+            ],
+            updatedAt: Date())
+
+        #expect(snapshot.summary(days: 0).points == 300) // last bucket only
+        #expect(snapshot.summary(days: 0).requests == 3)
+        #expect(snapshot.summary(days: -5).points == 300) // clamped up to 1
+    }
+
+    @Test
+    func `summary ignores daily buckets beyond the requested window`() {
+        let snapshot = PoeUsageHistorySnapshot(
+            entries: [],
+            daily: (1...30).map { offset in
+                PoeUsageHistorySnapshot.DailyBucket(
+                    day: String(format: "2026-04-%02d", offset),
+                    points: 1,
+                    requests: 1,
+                    costUSD: nil)
+            },
+            updatedAt: Date())
+
+        let last30 = snapshot.summary(days: 30)
+        let last7 = snapshot.summary(days: 7)
+
+        #expect(last30.points == 30)
+        #expect(last7.points == 7)
+    }
+
+    @Test
+    func `summary reports nil cost when every daily bucket has nil cost`() {
+        let snapshot = PoeUsageHistorySnapshot(
+            entries: [],
+            daily: (1...3).map { offset in
+                PoeUsageHistorySnapshot.DailyBucket(
+                    day: "2026-05-\(28 + offset)",
+                    points: 50,
+                    requests: 1,
+                    costUSD: nil)
+            },
+            updatedAt: Date())
+
+        #expect(snapshot.summary(days: 7).costUSD == nil)
+    }
+
+    @Test
+    func `summary sums only the non-nil cost buckets and keeps the rest invisible`() throws {
+        let snapshot = PoeUsageHistorySnapshot(
+            entries: [],
+            daily: [
+                PoeUsageHistorySnapshot.DailyBucket(day: "2026-05-29", points: 100, requests: 1, costUSD: nil),
+                PoeUsageHistorySnapshot.DailyBucket(day: "2026-05-30", points: 200, requests: 1, costUSD: 0.10),
+                PoeUsageHistorySnapshot.DailyBucket(day: "2026-05-31", points: 300, requests: 1, costUSD: 0.20),
+            ],
+            updatedAt: Date())
+
+        // Skips the nil bucket, sums 0.10 + 0.20 (allow IEEE-754 round-trip)
+        let cost = try #require(snapshot.summary(days: 7).costUSD)
+        #expect(abs(cost - 0.30) < 1e-9)
+    }
+
+    // MARK: - latestDay / last7Days / last30Days shortcuts
+
+    @Test
+    func `latest day, last 7 and last 30 days agree with summary by day count`() {
+        let daily: [PoeUsageHistorySnapshot.DailyBucket] = (1...40).map { offset in
+            PoeUsageHistorySnapshot.DailyBucket(
+                day: String(format: "2026-04-%02d", offset),
+                points: Double(offset),
+                requests: 1,
+                costUSD: nil)
+        }
+        let snapshot = PoeUsageHistorySnapshot(
+            entries: [],
+            daily: daily,
+            updatedAt: Date())
+
+        #expect(snapshot.latestDay == snapshot.summary(days: 1))
+        #expect(snapshot.last7Days == snapshot.summary(days: 7))
+        #expect(snapshot.last30Days == snapshot.summary(days: 30))
+    }
+
+    // MARK: - topModels / topModel
+
+    @Test
+    func `top models is empty when entries is empty`() {
+        let snapshot = PoeUsageHistorySnapshot(
+            entries: [],
+            daily: [],
+            updatedAt: Date())
+
+        #expect(snapshot.topModels.isEmpty)
+        #expect(snapshot.topModel == nil)
+    }
+
+    @Test
+    func `top models groups by model and sums points and requests`() {
+        let entries = [
+            self.makeEntry(id: "1", model: "GPT-4o", usageType: "chat", points: 10, costUSD: 0.01),
+            self.makeEntry(id: "2", model: "GPT-4o", usageType: "chat", points: 5, costUSD: 0.01),
+            self.makeEntry(id: "3", model: "Claude-3.7", usageType: "chat", points: 20, costUSD: 0.02),
+        ]
+        let snapshot = PoeUsageHistorySnapshot(
+            entries: entries,
+            daily: [],
+            updatedAt: Date())
+
+        let top = snapshot.topModels
+
+        #expect(top.count == 2)
+        #expect(top[0].name == "Claude-3.7")
+        #expect(top[0].points == 20)
+        #expect(top[0].requests == 1)
+        #expect(top[1].name == "GPT-4o")
+        #expect(top[1].points == 15)
+        #expect(top[1].requests == 2)
+    }
+
+    @Test
+    func `top models breaks ties by name ascending`() {
+        let entries = [
+            self.makeEntry(id: "1", model: "Z-Model", usageType: "chat", points: 10, costUSD: nil),
+            self.makeEntry(id: "2", model: "A-Model", usageType: "chat", points: 10, costUSD: nil),
+            self.makeEntry(id: "3", model: "M-Model", usageType: "chat", points: 10, costUSD: nil),
+        ]
+        let snapshot = PoeUsageHistorySnapshot(
+            entries: entries,
+            daily: [],
+            updatedAt: Date())
+
+        let top = snapshot.topModels
+        #expect(top.map(\.name) == ["A-Model", "M-Model", "Z-Model"])
+    }
+
+    @Test
+    func `top models falls back to unknown for empty or whitespace model strings`() {
+        let entries = [
+            self.makeEntry(id: "1", model: "GPT-4o", usageType: "chat", points: 5, costUSD: nil),
+            self.makeEntry(id: "2", model: "", usageType: "chat", points: 5, costUSD: nil),
+            self.makeEntry(id: "3", model: "   ", usageType: "chat", points: 5, costUSD: nil),
+        ]
+        let snapshot = PoeUsageHistorySnapshot(
+            entries: entries,
+            daily: [],
+            updatedAt: Date())
+
+        let top = snapshot.topModels
+        let names = top.map(\.name)
+        #expect(names.contains("unknown"))
+        #expect(names.contains("GPT-4o"))
+    }
+
+    @Test
+    func `top models omits cost when no entry reported cost`() {
+        let entries = [
+            self.makeEntry(id: "1", model: "GPT-4o", usageType: "chat", points: 5, costUSD: nil),
+        ]
+        let snapshot = PoeUsageHistorySnapshot(
+            entries: entries,
+            daily: [],
+            updatedAt: Date())
+
+        #expect(snapshot.topModels.first?.costUSD == nil)
+    }
+
+    @Test
+    func `top models sums cost across entries for the same model`() {
+        let entries = [
+            self.makeEntry(id: "1", model: "GPT-4o", usageType: "chat", points: 5, costUSD: 0.01),
+            self.makeEntry(id: "2", model: "GPT-4o", usageType: "chat", points: 5, costUSD: 0.02),
+        ]
+        let snapshot = PoeUsageHistorySnapshot(
+            entries: entries,
+            daily: [],
+            updatedAt: Date())
+
+        #expect(snapshot.topModels.first?.costUSD == 0.03)
+    }
+
+    // MARK: - topUsageTypes / topUsageType
+
+    @Test
+    func `top usage types groups by usage type independent of model`() {
+        let entries = [
+            self.makeEntry(id: "1", model: "GPT-4o", usageType: "chat", points: 5, costUSD: nil),
+            self.makeEntry(id: "2", model: "Claude", usageType: "chat", points: 10, costUSD: nil),
+            self.makeEntry(id: "3", model: "GPT-4o", usageType: "api", points: 8, costUSD: nil),
+        ]
+        let snapshot = PoeUsageHistorySnapshot(
+            entries: entries,
+            daily: [],
+            updatedAt: Date())
+
+        let top = snapshot.topUsageTypes
+        #expect(top.map(\.name) == ["chat", "api"])
+        #expect(top[0].points == 15)
+        #expect(top[0].requests == 2)
+    }
+
+    @Test
+    func `top usage type is the first entry in top usage types`() {
+        let entries = [
+            self.makeEntry(id: "1", model: "GPT-4o", usageType: "chat", points: 5, costUSD: nil),
+            self.makeEntry(id: "2", model: "GPT-4o", usageType: "api", points: 10, costUSD: nil),
+        ]
+        let snapshot = PoeUsageHistorySnapshot(
+            entries: entries,
+            daily: [],
+            updatedAt: Date())
+
+        #expect(snapshot.topUsageType == "api")
+        #expect(snapshot.topUsageType == snapshot.topUsageTypes.first?.name)
+    }
+
+    @Test
+    func `top usage type is nil for empty entries`() {
+        let snapshot = PoeUsageHistorySnapshot(
+            entries: [],
+            daily: [],
+            updatedAt: Date())
+
+        #expect(snapshot.topUsageType == nil)
+    }
+
+    // MARK: - recentEntries(limit:)
+
+    @Test
+    func `recent entries returns up to the requested limit, newest first`() {
+        let now = Date(timeIntervalSince1970: 1_717_000_000)
+        let entries = (0..<5).map { offset in
+            self.makeEntry(
+                id: "\(offset)",
+                createdAt: now.addingTimeInterval(TimeInterval(offset * 60)),
+                model: "GPT-4o",
+                usageType: "chat",
+                points: 1,
+                costUSD: nil)
+        }
+        // entries are passed in order they came back; init should sort
+        let snapshot = PoeUsageHistorySnapshot(
+            entries: entries,
+            daily: [],
+            updatedAt: now)
+
+        let recent = snapshot.recentEntries(limit: 3)
+
+        #expect(recent.count == 3)
+        // Newest three (offsets 4, 3, 2) should be first
+        #expect(recent[0].id == "4")
+        #expect(recent[1].id == "3")
+        #expect(recent[2].id == "2")
+    }
+
+    @Test
+    func `recent entries clamps non-positive limit up to one`() {
+        let now = Date(timeIntervalSince1970: 1_717_000_000)
+        let entries = (0..<3).map { offset in
+            self.makeEntry(
+                id: "\(offset)",
+                createdAt: now.addingTimeInterval(TimeInterval(offset * 60)),
+                model: "GPT-4o",
+                usageType: "chat",
+                points: 1,
+                costUSD: nil)
+        }
+        let snapshot = PoeUsageHistorySnapshot(
+            entries: entries,
+            daily: [],
+            updatedAt: now)
+
+        #expect(snapshot.recentEntries(limit: 0).count == 1)
+        #expect(snapshot.recentEntries(limit: -3).count == 1)
+        #expect(snapshot.recentEntries(limit: 0).first?.id == "2")
+    }
+
+    @Test
+    func `recent entries returns everything when limit exceeds entries count`() {
+        let now = Date(timeIntervalSince1970: 1_717_000_000)
+        let entries = [
+            self.makeEntry(id: "1", createdAt: now, model: "A", usageType: "t", points: 1, costUSD: nil),
+            self.makeEntry(
+                id: "2",
+                createdAt: now.addingTimeInterval(60),
+                model: "A",
+                usageType: "t",
+                points: 1,
+                costUSD: nil),
+        ]
+        let snapshot = PoeUsageHistorySnapshot(
+            entries: entries,
+            daily: [],
+            updatedAt: now)
+
+        let recent = snapshot.recentEntries(limit: 10)
+        #expect(recent.count == 2)
+    }
+
+    // MARK: - Init sorting invariants
+
+    @Test
+    func `init sorts entries ascending by created at and daily ascending by day string`() {
+        let now = Date(timeIntervalSince1970: 1_717_000_000)
+        let entries = [
+            self.makeEntry(
+                id: "newer",
+                createdAt: now.addingTimeInterval(120),
+                model: "A",
+                usageType: "t",
+                points: 1,
+                costUSD: nil),
+            self.makeEntry(id: "older", createdAt: now, model: "A", usageType: "t", points: 1, costUSD: nil),
+        ]
+        let daily = [
+            PoeUsageHistorySnapshot.DailyBucket(day: "2026-05-31", points: 1, requests: 1, costUSD: nil),
+            PoeUsageHistorySnapshot.DailyBucket(day: "2026-05-30", points: 1, requests: 1, costUSD: nil),
+        ]
+        let snapshot = PoeUsageHistorySnapshot(
+            entries: entries,
+            daily: daily,
+            updatedAt: now)
+
+        // Public init sorts entries ASC by createdAt, daily ASC by day
+        // (consumers wanting newest-first should use recentEntries(limit:))
+        #expect(snapshot.entries.first?.id == "older")
+        #expect(snapshot.entries.last?.id == "newer")
+        #expect(snapshot.daily.first?.day == "2026-05-30")
+        #expect(snapshot.daily.last?.day == "2026-05-31")
+    }
+
+    // MARK: - Helpers
+
+    private func makeEntry(
+        id: String,
+        createdAt: Date = Date(timeIntervalSince1970: 1_717_000_000),
+        model: String,
+        usageType: String,
+        points: Double,
+        costUSD: Double?) -> PoeUsageHistorySnapshot.Entry
+    {
+        PoeUsageHistorySnapshot.Entry(
+            id: id,
+            createdAt: createdAt,
+            model: model,
+            usageType: usageType,
+            points: points,
+            costUSD: costUSD)
+    }
+}
diff --git a/Tests/CodexBarTests/PopupLocalizationTests.swift b/Tests/CodexBarTests/PopupLocalizationTests.swift
new file mode 100644
index 0000000000..8389645f91
--- /dev/null
+++ b/Tests/CodexBarTests/PopupLocalizationTests.swift
@@ -0,0 +1,183 @@
+import CodexBarCore
+import Foundation
+import SwiftUI
+import Testing
+@testable import CodexBar
+
+@MainActor
+@Suite(.serialized)
+struct PopupLocalizationTests {
+    @Test
+    func `descriptor account labels use selected localization`() throws {
+        try CodexBarLocalizationOverride.$appLanguage.withValue("zh-Hant") {
+            let suite = "PopupLocalizationTests-descriptor"
+            let settings = try Self.makeSettingsStore(suite: suite)
+            let store = UsageStore(
+                fetcher: UsageFetcher(environment: [:]),
+                browserDetection: BrowserDetection(cacheTTL: 0),
+                settings: settings,
+                startupBehavior: .testing)
+            store._setSnapshotForTesting(
+                UsageSnapshot(
+                    primary: RateWindow(usedPercent: 12, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+                    secondary: nil,
+                    updatedAt: Date(),
+                    identity: ProviderIdentitySnapshot(
+                        providerID: .codex,
+                        accountEmail: "codex@example.com",
+                        accountOrganization: nil,
+                        loginMethod: "free")),
+                provider: .codex)
+
+            let descriptor = MenuDescriptor.build(
+                provider: .codex,
+                store: store,
+                settings: settings,
+                account: AccountInfo(email: nil, plan: nil),
+                updateReady: false,
+                includeContextualActions: false)
+
+            let lines = Self.textLines(from: descriptor)
+
+            #expect(lines.contains("帳號: codex@example.com"))
+            #expect(lines.contains("方案: Free"))
+            #expect(!lines.contains("Account: codex@example.com"))
+            #expect(!lines.contains("Plan: Free"))
+        }
+    }
+
+    @Test
+    func `inline dashboard labels use selected localization`() throws {
+        try CodexBarLocalizationOverride.$appLanguage.withValue("zh-Hant") {
+            let now = Date(timeIntervalSince1970: 1_700_179_200)
+            let metadata = try #require(ProviderDefaults.metadata[.openrouter])
+            let usage = OpenRouterUsageSnapshot(
+                totalCredits: 100,
+                totalUsage: 40,
+                balance: 60,
+                usedPercent: 40,
+                keyDataFetched: true,
+                keyLimit: 25,
+                keyUsage: 10,
+                keyUsageDaily: 1.25,
+                keyUsageWeekly: 7.5,
+                keyUsageMonthly: 18.75,
+                rateLimit: OpenRouterRateLimit(requests: 100, interval: "10s"),
+                updatedAt: now)
+
+            let model = UsageMenuCardView.Model.make(.init(
+                provider: .openrouter,
+                metadata: metadata,
+                snapshot: usage.toUsageSnapshot(),
+                credits: nil,
+                creditsError: nil,
+                dashboard: nil,
+                dashboardError: nil,
+                tokenSnapshot: nil,
+                tokenError: nil,
+                account: AccountInfo(email: nil, plan: nil),
+                isRefreshing: false,
+                lastError: nil,
+                usageBarsShowUsed: false,
+                resetTimeDisplayStyle: .countdown,
+                tokenCostUsageEnabled: false,
+                showOptionalCreditsAndExtraUsage: true,
+                hidePersonalInfo: false,
+                now: now))
+
+            let dashboard = try #require(model.inlineUsageDashboard)
+
+            #expect(dashboard.kpis.map(\.title) == ["餘額", "今天", "週", "月"])
+            #expect(dashboard.points.map(\.label) == ["今天", "週", "月"])
+            #expect(dashboard.detailLines.contains("速率限制: 100 / 10s"))
+        }
+    }
+
+    @Test
+    func `cookie source dynamic subtitles use selected localization`() {
+        CodexBarLocalizationOverride.$appLanguage.withValue("zh-Hant") {
+            let subtitle = ProviderCookieSourceUI.subtitle(
+                source: .manual,
+                keychainDisabled: false,
+                auto: "Automatically imports browser cookies.",
+                manual: "Paste a Cookie header or cURL capture from T3 Chat settings.",
+                off: "T3 Chat cookies are disabled.")
+            let disabledSubtitle = ProviderCookieSourceUI.subtitle(
+                source: .manual,
+                keychainDisabled: true,
+                auto: "Automatically imports browser cookies.",
+                manual: "Paste a Cookie header or cURL capture from T3 Chat settings.",
+                off: "T3 Chat cookies are disabled.")
+            let jsonBundleSubtitle = ProviderCookieSourceUI.subtitle(
+                source: .manual,
+                keychainDisabled: false,
+                auto: "Automatically imports browser cookies.",
+                manual: "Paste the localStorage JSON bundle from Windsurf session.",
+                off: "Windsurf cookies are disabled.")
+
+            #expect(subtitle.contains("貼上"))
+            #expect(!subtitle.contains("Paste a Cookie"))
+            #expect(disabledSubtitle.contains("鑰匙圈"))
+            #expect(!disabledSubtitle.contains("Keychain access"))
+            #expect(jsonBundleSubtitle.contains("來自 Windsurf session 的 localStorage JSON"))
+        }
+    }
+
+    @Test
+    func `provider organization entries preserve provider supplied text`() throws {
+        let settings = try Self.makeSettingsStore(suite: "PopupLocalizationTests-organizations")
+        settings.kiloKnownOrganizations = [
+            KiloOrganization(id: "org_cost", name: "Cost", role: "Today"),
+        ]
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        let context = ProviderSettingsContext(
+            provider: .kilo,
+            settings: settings,
+            store: store,
+            boolBinding: { keyPath in
+                Binding(
+                    get: { settings[keyPath: keyPath] },
+                    set: { settings[keyPath: keyPath] = $0 })
+            },
+            stringBinding: { keyPath in
+                Binding(
+                    get: { settings[keyPath: keyPath] },
+                    set: { settings[keyPath: keyPath] = $0 })
+            },
+            statusText: { _ in nil },
+            setStatusText: { _, _ in },
+            lastAppActiveRunAt: { _ in nil },
+            setLastAppActiveRunAt: { _, _ in },
+            requestConfirmation: { _ in })
+        let descriptor = try #require(KiloProviderImplementation().settingsOrganizations(context: context))
+        let orgEntry = try #require(descriptor.entries().first { $0.id == "org_cost" })
+
+        #expect(orgEntry.title == "Cost")
+        #expect(orgEntry.localizesTitle == false)
+        #expect(orgEntry.subtitle == "Today")
+        #expect(orgEntry.localizesSubtitle == false)
+    }
+
+    private static func makeSettingsStore(suite: String) throws -> SettingsStore {
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.statusChecksEnabled = false
+        return settings
+    }
+
+    private static func textLines(from descriptor: MenuDescriptor) -> [String] {
+        descriptor.sections.flatMap(\.entries).compactMap { entry -> String? in
+            guard case let .text(text, _) = entry else { return nil }
+            return text
+        }
+    }
+}
diff --git a/Tests/CodexBarTests/PreferencesPaneSmokeTests.swift b/Tests/CodexBarTests/PreferencesPaneSmokeTests.swift
index bb6d8f43a4..3245c08b58 100644
--- a/Tests/CodexBarTests/PreferencesPaneSmokeTests.swift
+++ b/Tests/CodexBarTests/PreferencesPaneSmokeTests.swift
@@ -4,10 +4,10 @@ import Testing
 @testable import CodexBar
 
 @MainActor
-@Suite
+@Suite(.serialized)
 struct PreferencesPaneSmokeTests {
     @Test
-    func buildsPreferencePanesWithDefaultSettings() {
+    func `builds preference panes with default settings`() {
         let settings = Self.makeSettingsStore(suite: "PreferencesPaneSmokeTests-default")
         let store = Self.makeUsageStore(settings: settings)
 
@@ -22,11 +22,11 @@ struct PreferencesPaneSmokeTests {
     }
 
     @Test
-    func buildsPreferencePanesWithToggledSettings() {
+    func `builds preference panes with toggled settings`() {
         let settings = Self.makeSettingsStore(suite: "PreferencesPaneSmokeTests-toggled")
         settings.menuBarShowsBrandIconWithPercent = true
         settings.menuBarShowsHighestUsage = true
-        settings.showAllTokenAccountsInMenu = true
+        settings.multiAccountMenuLayout = .stacked
         settings.hidePersonalInfo = true
         settings.resetTimesShowAbsolute = true
         settings.debugDisableKeychainAccess = true
@@ -44,6 +44,106 @@ struct PreferencesPaneSmokeTests {
         _ = AboutPane(updater: DisabledUpdaterController()).body
     }
 
+    @Test
+    func `overview provider limit text formats numeric limit as object argument`() {
+        let text = DisplayPane.overviewProviderLimitText(limit: 3)
+
+        #expect(text.contains("3"))
+        #expect(!text.contains("%@"))
+    }
+
+    @Test
+    func `cost history days editor builds with clamped settings binding`() {
+        let settings = Self.makeSettingsStore(suite: "PreferencesPaneSmokeTests-cost-history-days")
+
+        settings.costUsageHistoryDays = 999
+        #expect(settings.costUsageHistoryDays == 365)
+        #expect(CostHistoryDaysEditor.title(days: 365).contains("365"))
+        #expect(!CostHistoryDaysEditor.title(days: 365).contains("%d"))
+
+        _ = CostHistoryDaysEditor(settings: settings).body
+    }
+
+    @Test
+    func `language preference updates global localization resolver`() {
+        let previousLanguage = UserDefaults.standard.object(forKey: "appLanguage")
+        let previousAppleLanguages = UserDefaults.standard.object(forKey: "AppleLanguages")
+        defer {
+            if let previousLanguage {
+                UserDefaults.standard.set(previousLanguage, forKey: "appLanguage")
+            } else {
+                UserDefaults.standard.removeObject(forKey: "appLanguage")
+            }
+            if let previousAppleLanguages {
+                UserDefaults.standard.set(previousAppleLanguages, forKey: "AppleLanguages")
+            } else {
+                UserDefaults.standard.removeObject(forKey: "AppleLanguages")
+            }
+        }
+
+        let settings = Self.makeSettingsStore(suite: "PreferencesPaneSmokeTests-language")
+
+        settings.appLanguage = "zh-Hans"
+
+        #expect(UserDefaults.standard.string(forKey: "appLanguage") == "zh-Hans")
+        CodexBarLocalizationOverride.$appLanguage.withValue("zh-Hans") {
+            #expect(L("tab_general") == "通用")
+            #expect(L("quota_warning_notifications_title") == "配额预警通知")
+            #expect(L("show_provider_storage_usage_title") == "显示提供商存储用量")
+        }
+
+        settings.appLanguage = "ja"
+
+        #expect(UserDefaults.standard.string(forKey: "appLanguage") == "ja")
+        CodexBarLocalizationOverride.$appLanguage.withValue("ja") {
+            #expect(L("language_title") == "言語")
+            #expect(L("start_at_login_title") == "ログイン時に起動")
+            #expect(L("quit_app") == "CodexBar を終了")
+        }
+
+        settings.appLanguage = "id"
+
+        #expect(UserDefaults.standard.string(forKey: "appLanguage") == "id")
+        CodexBarLocalizationOverride.$appLanguage.withValue("id") {
+            #expect(L("language_title") == "Bahasa")
+            #expect(L("start_at_login_title") == "Mulai saat Login")
+            #expect(L("quit_app") == "Keluar CodexBar")
+        }
+    }
+
+    @Test
+    func `german app language resolves localized labels`() {
+        let settings = Self.makeSettingsStore(suite: "PreferencesPaneSmokeTests-language-de")
+        settings.appLanguage = "de"
+
+        #expect(UserDefaults.standard.string(forKey: "appLanguage") == "de")
+        CodexBarLocalizationOverride.$appLanguage.withValue("de") {
+            #expect(L("tab_general") == "Allgemein")
+            #expect(L("language_title") == "Sprache")
+            #expect(L("quit_app") == "CodexBar beenden")
+            #expect(L("display_mode_reset_time") == "Zurücksetzungszeit")
+            #expect(L("display_mode_reset_time_desc").contains("↻ 15:56"))
+            #expect(L("vertex_ai_login_instructions").contains("\n\n1. Öffnen Sie Terminal"))
+            #expect(!L("vertex_ai_login_instructions").contains("\\n"))
+        }
+    }
+
+    @Test
+    func `italian language preference resolves italian strings`() {
+        let settings = Self.makeSettingsStore(suite: "PreferencesPaneSmokeTests-language-italian")
+        settings.appLanguage = "it"
+
+        #expect(UserDefaults.standard.string(forKey: "appLanguage") == "it")
+        CodexBarLocalizationOverride.$appLanguage.withValue("it") {
+            #expect(L("language_title") == "Lingua")
+            #expect(L("section_system") == "Sistema")
+            #expect(L("language_italian") == "Italiano")
+            #expect(L("tab_display") == "Aspetto")
+            #expect(L("tab_advanced") == "Avanzate")
+            #expect(L("quit_app") == "Esci da CodexBar")
+        }
+    }
+
     private static func makeSettingsStore(suite: String) -> SettingsStore {
         let defaults = UserDefaults(suiteName: suite)!
         defaults.removePersistentDomain(forName: suite)
diff --git a/Tests/CodexBarTests/PreferencesTabLayoutCoordinatorTests.swift b/Tests/CodexBarTests/PreferencesTabLayoutCoordinatorTests.swift
new file mode 100644
index 0000000000..7471028f6d
--- /dev/null
+++ b/Tests/CodexBarTests/PreferencesTabLayoutCoordinatorTests.swift
@@ -0,0 +1,64 @@
+import Testing
+@testable import CodexBar
+
+struct PreferencesTabLayoutCoordinatorTests {
+    @Test
+    func `binding selection defers one layout and suppresses observed duplicate`() {
+        var coordinator = PreferencesTabLayoutCoordinator()
+
+        let beganSelection = coordinator.beginBindingSelection(from: .general, to: .providers)
+        #expect(beganSelection)
+        #expect(coordinator.bindingHandledTab == .providers)
+        let observedLayout = coordinator.layoutForObservedSelection(.providers, current: .providers)
+        #expect(observedLayout == nil)
+        #expect(coordinator.bindingHandledTab == nil)
+        #expect(coordinator.layoutForDeferredSelection(.providers, current: .providers) == .providers)
+    }
+
+    @Test
+    func `same tab selection schedules no layout`() {
+        var coordinator = PreferencesTabLayoutCoordinator()
+
+        let beganSelection = coordinator.beginBindingSelection(from: .general, to: .general)
+        #expect(!beganSelection)
+        #expect(coordinator.bindingHandledTab == nil)
+    }
+
+    @Test
+    func `programmatic selection performs observed layout`() {
+        var coordinator = PreferencesTabLayoutCoordinator()
+
+        let observedLayout = coordinator.layoutForObservedSelection(.about, current: .about)
+        #expect(observedLayout == .about)
+        #expect(coordinator.bindingHandledTab == nil)
+    }
+
+    @Test
+    func `rapid tab clicks ignore stale observation and deferred layout`() {
+        var coordinator = PreferencesTabLayoutCoordinator()
+
+        let beganProviders = coordinator.beginBindingSelection(from: .general, to: .providers)
+        let beganAbout = coordinator.beginBindingSelection(from: .providers, to: .about)
+        let staleObservedLayout = coordinator.layoutForObservedSelection(.providers, current: .about)
+        #expect(beganProviders)
+        #expect(beganAbout)
+        #expect(staleObservedLayout == nil)
+        #expect(coordinator.bindingHandledTab == .about)
+        #expect(coordinator.layoutForDeferredSelection(.providers, current: .about) == nil)
+        let currentObservedLayout = coordinator.layoutForObservedSelection(.about, current: .about)
+        #expect(currentObservedLayout == nil)
+        #expect(coordinator.layoutForDeferredSelection(.about, current: .about) == .about)
+    }
+
+    @Test
+    func `programmatic selection replaces pending binding layout`() {
+        var coordinator = PreferencesTabLayoutCoordinator()
+
+        let beganSelection = coordinator.beginBindingSelection(from: .general, to: .providers)
+        let programmaticLayout = coordinator.layoutForObservedSelection(.advanced, current: .advanced)
+        #expect(beganSelection)
+        #expect(programmaticLayout == .advanced)
+        #expect(coordinator.bindingHandledTab == nil)
+        #expect(coordinator.layoutForDeferredSelection(.providers, current: .advanced) == nil)
+    }
+}
diff --git a/Tests/CodexBarTests/ProviderCandidateRetryRunnerTests.swift b/Tests/CodexBarTests/ProviderCandidateRetryRunnerTests.swift
index 4632d1b95f..efe66f1c80 100644
--- a/Tests/CodexBarTests/ProviderCandidateRetryRunnerTests.swift
+++ b/Tests/CodexBarTests/ProviderCandidateRetryRunnerTests.swift
@@ -1,7 +1,6 @@
 import Testing
 @testable import CodexBarCore
 
-@Suite
 struct ProviderCandidateRetryRunnerTests {
     private enum TestError: Error, Equatable {
         case retryable(Int)
@@ -9,7 +8,7 @@ struct ProviderCandidateRetryRunnerTests {
     }
 
     @Test
-    func retriesThenSucceeds() async throws {
+    func `retries then succeeds`() async throws {
         let candidates = [1, 2, 3]
         var attempted: [Int] = []
         var retried: [Int] = []
@@ -39,7 +38,7 @@ struct ProviderCandidateRetryRunnerTests {
     }
 
     @Test
-    func nonRetryableFailsImmediately() async {
+    func `non retryable fails immediately`() async {
         let candidates = [1, 2, 3]
         var attempted: [Int] = []
         var retried: [Int] = []
@@ -71,7 +70,7 @@ struct ProviderCandidateRetryRunnerTests {
     }
 
     @Test
-    func exhaustedRetryableThrowsLastError() async {
+    func `exhausted retryable throws last error`() async {
         let candidates = [1, 2]
         var attempted: [Int] = []
         var retried: [Int] = []
@@ -103,7 +102,7 @@ struct ProviderCandidateRetryRunnerTests {
     }
 
     @Test
-    func emptyCandidatesThrowsNoCandidates() async {
+    func `empty candidates throws no candidates`() async {
         do {
             let candidates: [Int] = []
             _ = try await ProviderCandidateRetryRunner.run(
diff --git a/Tests/CodexBarTests/ProviderChangelogLinkTests.swift b/Tests/CodexBarTests/ProviderChangelogLinkTests.swift
new file mode 100644
index 0000000000..a1923a4abf
--- /dev/null
+++ b/Tests/CodexBarTests/ProviderChangelogLinkTests.swift
@@ -0,0 +1,79 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@MainActor
+struct ProviderChangelogLinkTests {
+    @Test
+    func `known CLI providers declare changelog URLs`() {
+        let metadata = ProviderDefaults.metadata
+
+        #expect(metadata[.codex]?.changelogURL == "https://github.com/openai/codex/releases")
+        #expect(metadata[.claude]?.changelogURL == "https://github.com/anthropics/claude-code/releases")
+        #expect(metadata[.gemini]?.changelogURL == "https://github.com/google-gemini/gemini-cli/releases")
+    }
+
+    @Test
+    func `provider menu hides changelog action until enabled`() {
+        let codexDescriptor = self.makeDescriptor(
+            provider: .codex,
+            suite: "ProviderChangelogLinkTests-codex-default")
+        #expect(!self.actionTitles(from: codexDescriptor).contains("Changelog"))
+    }
+
+    @Test
+    func `provider menu shows changelog action only when setting and URL are present`() {
+        let codexDescriptor = self.makeDescriptor(
+            provider: .codex,
+            suite: "ProviderChangelogLinkTests-codex",
+            changelogLinksEnabled: true)
+        #expect(self.actionTitles(from: codexDescriptor).contains("Changelog"))
+
+        let openRouterDescriptor = self.makeDescriptor(
+            provider: .openrouter,
+            suite: "ProviderChangelogLinkTests-openrouter",
+            changelogLinksEnabled: true)
+        #expect(!self.actionTitles(from: openRouterDescriptor).contains("Changelog"))
+    }
+
+    private func makeDescriptor(
+        provider: UsageProvider,
+        suite: String,
+        changelogLinksEnabled: Bool = false) -> MenuDescriptor
+    {
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.statusChecksEnabled = false
+        settings.providerChangelogLinksEnabled = changelogLinksEnabled
+
+        let fetcher = UsageFetcher(environment: [:])
+        let store = UsageStore(
+            fetcher: fetcher,
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+
+        return MenuDescriptor.build(
+            provider: provider,
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updateReady: false,
+            includeContextualActions: true)
+    }
+
+    private func actionTitles(from descriptor: MenuDescriptor) -> [String] {
+        descriptor.sections
+            .flatMap(\.entries)
+            .compactMap { entry -> String? in
+                guard case let .action(title, _) = entry else { return nil }
+                return title
+            }
+    }
+}
diff --git a/Tests/CodexBarTests/ProviderConfigEnvironmentTests.swift b/Tests/CodexBarTests/ProviderConfigEnvironmentTests.swift
index 702a508436..084a591643 100644
--- a/Tests/CodexBarTests/ProviderConfigEnvironmentTests.swift
+++ b/Tests/CodexBarTests/ProviderConfigEnvironmentTests.swift
@@ -1,10 +1,21 @@
 import CodexBarCore
 import Testing
 
-@Suite
 struct ProviderConfigEnvironmentTests {
     @Test
-    func appliesAPIKeyOverrideForZai() {
+    func `applies API key override for amp`() {
+        let config = ProviderConfig(id: .amp, apiKey: "sgamp-config")
+        let env = ProviderConfigEnvironment.applyAPIKeyOverride(
+            base: [:],
+            provider: .amp,
+            config: config)
+
+        #expect(env[AmpSettingsReader.apiTokenKey] == "sgamp-config")
+        #expect(ProviderTokenResolver.ampToken(environment: env) == "sgamp-config")
+    }
+
+    @Test
+    func `applies API key override for zai`() {
         let config = ProviderConfig(id: .zai, apiKey: "z-token")
         let env = ProviderConfigEnvironment.applyAPIKeyOverride(
             base: [:],
@@ -15,7 +26,7 @@ struct ProviderConfigEnvironmentTests {
     }
 
     @Test
-    func appliesAPIKeyOverrideForWarp() {
+    func `applies API key override for warp`() {
         let config = ProviderConfig(id: .warp, apiKey: "w-token")
         let env = ProviderConfigEnvironment.applyAPIKeyOverride(
             base: [:],
@@ -30,7 +41,7 @@ struct ProviderConfigEnvironmentTests {
     }
 
     @Test
-    func appliesAPIKeyOverrideForOpenRouter() {
+    func `applies API key override for open router`() {
         let config = ProviderConfig(id: .openrouter, apiKey: "or-token")
         let env = ProviderConfigEnvironment.applyAPIKeyOverride(
             base: [:],
@@ -41,7 +52,340 @@ struct ProviderConfigEnvironmentTests {
     }
 
     @Test
-    func appliesAPIKeyOverrideForKilo() {
+    func `applies API key override for doubao`() {
+        let config = ProviderConfig(id: .doubao, apiKey: "db-token")
+        let env = ProviderConfigEnvironment.applyAPIKeyOverride(
+            base: [:],
+            provider: .doubao,
+            config: config)
+
+        #expect(env[DoubaoSettingsReader.apiKeyEnvironmentKeys[0]] == "db-token")
+        #expect(ProviderTokenResolver.doubaoToken(environment: env) == "db-token")
+    }
+
+    @Test
+    func `applies API key override for moonshot`() {
+        let config = ProviderConfig(id: .moonshot, apiKey: "moon-token")
+        let env = ProviderConfigEnvironment.applyAPIKeyOverride(
+            base: [:],
+            provider: .moonshot,
+            config: config)
+
+        let key = MoonshotSettingsReader.apiKeyEnvironmentKeys.first
+        #expect(key != nil)
+        guard let key else { return }
+
+        #expect(env[key] == "moon-token")
+    }
+
+    @Test
+    func `applies Kimi API key and base URL config overrides`() throws {
+        let config = ProviderConfig(
+            id: .kimi,
+            apiKey: "kimi-api-token",
+            enterpriseHost: "https://proxy.example.com/kimi")
+        let env = ProviderConfigEnvironment.applyProviderConfigOverrides(
+            base: [:],
+            provider: .kimi,
+            config: config)
+
+        #expect(env["KIMI_CODE_API_KEY"] == "kimi-api-token")
+        #expect(env["KIMI_API_KEY"] == nil)
+        #expect(env[KimiSettingsReader.codeAPIBaseURLEnvironmentKey] == "https://proxy.example.com/kimi")
+        #expect(ProviderTokenResolver.kimiAPIToken(environment: env) == "kimi-api-token")
+        #expect(try KimiSettingsReader.codeAPIBaseURL(environment: env).absoluteString ==
+            "https://proxy.example.com/kimi")
+    }
+
+    @Test
+    func `applies API key override for elevenlabs`() {
+        let config = ProviderConfig(id: .elevenlabs, apiKey: "xi-token")
+        let env = ProviderConfigEnvironment.applyAPIKeyOverride(
+            base: [:],
+            provider: .elevenlabs,
+            config: config)
+
+        #expect(env[ElevenLabsSettingsReader.apiKeyEnvironmentKey] == "xi-token")
+        #expect(ProviderTokenResolver.elevenLabsToken(environment: env) == "xi-token")
+    }
+
+    @Test
+    func `applies API key override for groq`() {
+        let config = ProviderConfig(id: .groq, apiKey: "gsk-token")
+        let env = ProviderConfigEnvironment.applyAPIKeyOverride(
+            base: [:],
+            provider: .groq,
+            config: config)
+
+        #expect(env[GroqSettingsReader.apiKeyEnvironmentKey] == "gsk-token")
+        #expect(ProviderTokenResolver.groqToken(environment: env) == "gsk-token")
+    }
+
+    @Test
+    func `applies LLM Proxy config overrides`() {
+        let config = ProviderConfig(
+            id: .llmproxy,
+            apiKey: "proxy-token",
+            enterpriseHost: "https://proxy.example.com")
+        let env = ProviderConfigEnvironment.applyProviderConfigOverrides(
+            base: [:],
+            provider: .llmproxy,
+            config: config)
+
+        #expect(env[LLMProxySettingsReader.apiKeyEnvironmentKey] == "proxy-token")
+        #expect(env[LLMProxySettingsReader.baseURLEnvironmentKey] == "https://proxy.example.com")
+        #expect(ProviderTokenResolver.llmProxyToken(environment: env) == "proxy-token")
+    }
+
+    @Test
+    func `applies LiteLLM config overrides`() {
+        let config = ProviderConfig(
+            id: .litellm,
+            apiKey: "litellm-token",
+            enterpriseHost: "https://litellm.example.com/v1")
+        let env = ProviderConfigEnvironment.applyProviderConfigOverrides(
+            base: [:],
+            provider: .litellm,
+            config: config)
+
+        #expect(env[LiteLLMSettingsReader.apiKeyEnvironmentKey] == "litellm-token")
+        #expect(env[LiteLLMSettingsReader.baseURLEnvironmentKey] == "https://litellm.example.com/v1")
+        #expect(ProviderTokenResolver.liteLLMToken(environment: env) == "litellm-token")
+    }
+
+    @Test
+    func `openai config override uses preferred admin key environment`() {
+        let config = ProviderConfig(id: .openai, apiKey: "config-openai-token")
+        let env = ProviderConfigEnvironment.applyAPIKeyOverride(
+            base: [
+                OpenAIAPISettingsReader.adminAPIKeyEnvironmentKey: "env-admin-token",
+                OpenAIAPISettingsReader.apiKeyEnvironmentKey: "env-api-token",
+            ],
+            provider: .openai,
+            config: config)
+
+        #expect(env[OpenAIAPISettingsReader.adminAPIKeyEnvironmentKey] == "config-openai-token")
+        #expect(env[OpenAIAPISettingsReader.apiKeyEnvironmentKey] == "env-api-token")
+        #expect(ProviderTokenResolver.openAIAPIToken(environment: env) == "config-openai-token")
+    }
+
+    @Test
+    func `openai config override applies project ID without replacing environment key`() {
+        let config = ProviderConfig(id: .openai, workspaceID: "proj_config")
+        let env = ProviderConfigEnvironment.applyAPIKeyOverride(
+            base: [
+                OpenAIAPISettingsReader.adminAPIKeyEnvironmentKey: "env-admin-token",
+            ],
+            provider: .openai,
+            config: config)
+
+        #expect(env[OpenAIAPISettingsReader.adminAPIKeyEnvironmentKey] == "env-admin-token")
+        #expect(env[OpenAIAPISettingsReader.projectIDEnvironmentKey] == "proj_config")
+        #expect(OpenAIAPISettingsReader.projectID(environment: env) == "proj_config")
+    }
+
+    @Test
+    func `applies Azure OpenAI config overrides`() {
+        let config = ProviderConfig(
+            id: .azureopenai,
+            apiKey: "config-azure-token",
+            workspaceID: "chat-prod",
+            enterpriseHost: "https://example-resource.openai.azure.com")
+        let env = ProviderConfigEnvironment.applyProviderConfigOverrides(
+            base: [
+                AzureOpenAISettingsReader.apiKeyEnvironmentKey: "env-azure-token",
+                AzureOpenAISettingsReader.endpointEnvironmentKey: "https://env-resource.openai.azure.com",
+                AzureOpenAISettingsReader.deploymentNameEnvironmentKey: "env-deployment",
+            ],
+            provider: .azureopenai,
+            config: config)
+
+        #expect(env[AzureOpenAISettingsReader.apiKeyEnvironmentKey] == "config-azure-token")
+        #expect(env[AzureOpenAISettingsReader.endpointEnvironmentKey] == "https://example-resource.openai.azure.com")
+        #expect(env[AzureOpenAISettingsReader.deploymentNameEnvironmentKey] == "chat-prod")
+        #expect(ProviderTokenResolver.azureOpenAIToken(environment: env) == "config-azure-token")
+        #expect(AzureOpenAISettingsReader.deploymentName(environment: env) == "chat-prod")
+    }
+
+    @Test
+    func `bedrock config maps AWS credential fields`() {
+        let config = ProviderConfig(
+            id: .bedrock,
+            apiKey: "AKIATEST",
+            secretKey: "secret",
+            cookieHeader: "legacy-cookie-secret",
+            region: "us-west-2")
+        let env = ProviderConfigEnvironment.applyAPIKeyOverride(
+            base: [:],
+            provider: .bedrock,
+            config: config)
+
+        #expect(env[BedrockSettingsReader.accessKeyIDKey] == "AKIATEST")
+        #expect(env[BedrockSettingsReader.secretAccessKeyKey] == "secret")
+        #expect(env[BedrockSettingsReader.regionKeys[0]] == "us-west-2")
+        #expect(!env.values.contains("legacy-cookie-secret"))
+    }
+
+    @Test
+    func `bedrock config merges secret and region without replacing environment access key`() {
+        let config = ProviderConfig(
+            id: .bedrock,
+            apiKey: nil,
+            secretKey: "config-secret",
+            region: "eu-central-1")
+        let env = ProviderConfigEnvironment.applyAPIKeyOverride(
+            base: [BedrockSettingsReader.accessKeyIDKey: "env-access"],
+            provider: .bedrock,
+            config: config)
+
+        #expect(env[BedrockSettingsReader.accessKeyIDKey] == "env-access")
+        #expect(env[BedrockSettingsReader.secretAccessKeyKey] == "config-secret")
+        #expect(env[BedrockSettingsReader.regionKeys[0]] == "eu-central-1")
+        #expect(BedrockSettingsReader.hasCredentials(environment: env))
+    }
+
+    @Test
+    func `bedrock merged static credentials win over inherited AWS_PROFILE`() {
+        let config = ProviderConfig(
+            id: .bedrock,
+            secretKey: "config-secret",
+            region: "eu-central-1")
+        let env = ProviderConfigEnvironment.applyAPIKeyOverride(
+            base: [
+                BedrockSettingsReader.profileKey: "work",
+                BedrockSettingsReader.accessKeyIDKey: "env-access",
+            ],
+            provider: .bedrock,
+            config: config)
+
+        #expect(env[BedrockSettingsReader.accessKeyIDKey] == "env-access")
+        #expect(env[BedrockSettingsReader.secretAccessKeyKey] == "config-secret")
+        #expect(env[BedrockSettingsReader.regionKeys[0]] == "eu-central-1")
+        #expect(BedrockSettingsReader.authMode(environment: env) == .keys)
+    }
+
+    @Test
+    func `bedrock profile mode projects AWS_PROFILE without saved static keys`() {
+        let config = ProviderConfig(
+            id: .bedrock,
+            apiKey: "AKIATEST",
+            secretKey: "secret",
+            region: "eu-west-1",
+            awsProfile: "work",
+            awsAuthMode: "profile")
+        let env = ProviderConfigEnvironment.applyAPIKeyOverride(
+            base: [:],
+            provider: .bedrock,
+            config: config)
+        #expect(env[BedrockSettingsReader.authModeKey] == "profile")
+        #expect(env[BedrockSettingsReader.profileKey] == "work")
+        #expect(env[BedrockSettingsReader.regionKeys[0]] == "eu-west-1")
+        #expect(env[BedrockSettingsReader.accessKeyIDKey] == nil)
+        #expect(env[BedrockSettingsReader.secretAccessKeyKey] == nil)
+    }
+
+    @Test
+    func `bedrock config without explicit mode preserves env profile inference`() {
+        let config = ProviderConfig(id: .bedrock, region: "us-east-1")
+        let env = ProviderConfigEnvironment.applyAPIKeyOverride(
+            base: [BedrockSettingsReader.profileKey: "work"],
+            provider: .bedrock,
+            config: config)
+        #expect(env[BedrockSettingsReader.authModeKey] == nil)
+        #expect(env[BedrockSettingsReader.profileKey] == "work")
+        #expect(BedrockSettingsReader.authMode(environment: env) == .profile)
+    }
+
+    @Test
+    func `bedrock saved static keys survive base AWS_PROFILE when auth mode is unset`() {
+        let config = ProviderConfig(
+            id: .bedrock,
+            apiKey: "AKIASAVED",
+            secretKey: "saved-secret",
+            region: "us-east-1")
+        let env = ProviderConfigEnvironment.applyAPIKeyOverride(
+            base: [BedrockSettingsReader.profileKey: "work"],
+            provider: .bedrock,
+            config: config)
+        // Upgrade path: saved keys win over an inherited AWS_PROFILE, no silent switch.
+        #expect(env[BedrockSettingsReader.accessKeyIDKey] == "AKIASAVED")
+        #expect(env[BedrockSettingsReader.secretAccessKeyKey] == "saved-secret")
+        #expect(BedrockSettingsReader.authMode(environment: env) == .keys)
+    }
+
+    @Test
+    func `bedrock profile mode preserves inherited static credentials for environment source profiles`() {
+        let config = ProviderConfig(id: .bedrock, awsProfile: "work", awsAuthMode: "profile")
+        let env = ProviderConfigEnvironment.applyAPIKeyOverride(
+            base: [
+                BedrockSettingsReader.accessKeyIDKey: "AKIAINHERITED",
+                BedrockSettingsReader.secretAccessKeyKey: "inherited-secret",
+                BedrockSettingsReader.sessionTokenKey: "inherited-token",
+            ],
+            provider: .bedrock,
+            config: config)
+        #expect(env[BedrockSettingsReader.accessKeyIDKey] == "AKIAINHERITED")
+        #expect(env[BedrockSettingsReader.secretAccessKeyKey] == "inherited-secret")
+        #expect(env[BedrockSettingsReader.sessionTokenKey] == "inherited-token")
+        #expect(env[BedrockSettingsReader.profileKey] == "work")
+    }
+
+    @Test
+    func `bedrock env profile mode does not project saved static credentials`() {
+        let config = ProviderConfig(
+            id: .bedrock,
+            apiKey: "AKIASAVED",
+            secretKey: "saved-secret")
+        let env = ProviderConfigEnvironment.applyAPIKeyOverride(
+            base: [
+                BedrockSettingsReader.authModeKey: "profile",
+                BedrockSettingsReader.profileKey: "work",
+            ],
+            provider: .bedrock,
+            config: config)
+
+        #expect(env[BedrockSettingsReader.authModeKey] == "profile")
+        #expect(env[BedrockSettingsReader.profileKey] == "work")
+        #expect(env[BedrockSettingsReader.accessKeyIDKey] == nil)
+        #expect(env[BedrockSettingsReader.secretAccessKeyKey] == nil)
+    }
+
+    @Test
+    func `bedrock keys mode still projects static credentials`() {
+        let config = ProviderConfig(
+            id: .bedrock,
+            apiKey: "AKIATEST",
+            secretKey: "secret",
+            region: "us-west-2",
+            awsAuthMode: "keys")
+        let env = ProviderConfigEnvironment.applyAPIKeyOverride(
+            base: [:],
+            provider: .bedrock,
+            config: config)
+        #expect(env[BedrockSettingsReader.authModeKey] == "keys")
+        #expect(env[BedrockSettingsReader.accessKeyIDKey] == "AKIATEST")
+        #expect(env[BedrockSettingsReader.secretAccessKeyKey] == "secret")
+        #expect(env[BedrockSettingsReader.profileKey] == nil)
+    }
+
+    @Test
+    func `ignores legacy API key override for deepseek`() {
+        let config = ProviderConfig(id: .deepseek, apiKey: "ds-token")
+        let env = ProviderConfigEnvironment.applyAPIKeyOverride(
+            base: [:],
+            provider: .deepseek,
+            config: config)
+
+        let key = DeepSeekSettingsReader.apiKeyEnvironmentKeys.first
+        #expect(key != nil)
+        guard let key else { return }
+
+        #expect(env[key] == nil)
+        #expect(ProviderTokenResolver.deepseekToken(environment: env) == nil)
+    }
+
+    @Test
+    func `applies API key override for kilo`() {
         let config = ProviderConfig(id: .kilo, apiKey: "kilo-token")
         let env = ProviderConfigEnvironment.applyAPIKeyOverride(
             base: [:],
@@ -53,7 +397,7 @@ struct ProviderConfigEnvironmentTests {
     }
 
     @Test
-    func openRouterConfigOverrideWinsOverEnvironmentToken() {
+    func `open router config override wins over environment token`() {
         let config = ProviderConfig(id: .openrouter, apiKey: "config-token")
         let env = ProviderConfigEnvironment.applyAPIKeyOverride(
             base: [OpenRouterSettingsReader.envKey: "env-token"],
@@ -65,7 +409,85 @@ struct ProviderConfigEnvironmentTests {
     }
 
     @Test
-    func leavesEnvironmentWhenAPIKeyMissing() {
+    func `deepseek config override leaves environment token alone`() {
+        let config = ProviderConfig(id: .deepseek, apiKey: "config-token")
+        let envKey = DeepSeekSettingsReader.apiKeyEnvironmentKeys[0]
+        let env = ProviderConfigEnvironment.applyAPIKeyOverride(
+            base: [envKey: "env-token"],
+            provider: .deepseek,
+            config: config)
+
+        #expect(env[envKey] == "env-token")
+        #expect(ProviderTokenResolver.deepseekToken(environment: env) == "env-token")
+    }
+
+    @Test
+    func `applies API key override for codebuff`() {
+        let config = ProviderConfig(id: .codebuff, apiKey: "cb-config-token")
+        let env = ProviderConfigEnvironment.applyAPIKeyOverride(
+            base: [:],
+            provider: .codebuff,
+            config: config)
+
+        #expect(env[CodebuffSettingsReader.apiTokenKey] == "cb-config-token")
+        #expect(
+            ProviderTokenResolver.codebuffToken(environment: env, authFileURL: nil)
+                == "cb-config-token")
+    }
+
+    @Test
+    func `applies API key override for deepgram`() {
+        let config = ProviderConfig(id: .deepgram, apiKey: "dg-token")
+        let env = ProviderConfigEnvironment.applyAPIKeyOverride(
+            base: [:],
+            provider: .deepgram,
+            config: config)
+
+        #expect(env[DeepgramSettingsReader.apiKeyEnvironmentKey] == "dg-token")
+        #expect(ProviderTokenResolver.deepgramResolution(
+            type: .apiKey,
+            environment: env)
+            == "dg-token")
+    }
+
+    @Test
+    func `applies Deepgram project ID override from provider config`() {
+        let config = ProviderConfig(id: .deepgram, workspaceID: "proj-123")
+        let env = ProviderConfigEnvironment.applyProviderConfigOverrides(
+            base: [:],
+            provider: .deepgram,
+            config: config)
+
+        #expect(env[DeepgramSettingsReader.projectIDEnvironmentKey] == "proj-123")
+    }
+
+    @Test
+    func `Deepgram project ID config overrides environment`() {
+        let config = ProviderConfig(id: .deepgram, workspaceID: "config-project")
+        let env = ProviderConfigEnvironment.applyProviderConfigOverrides(
+            base: [DeepgramSettingsReader.projectIDEnvironmentKey: "env-project"],
+            provider: .deepgram,
+            config: config)
+
+        #expect(env[DeepgramSettingsReader.projectIDEnvironmentKey] == "config-project")
+    }
+
+    @Test
+    func `codebuff config override leaves environment token alone`() {
+        let config = ProviderConfig(id: .codebuff, apiKey: "config-token")
+        let env = ProviderConfigEnvironment.applyAPIKeyOverride(
+            base: [CodebuffSettingsReader.apiTokenKey: "env-token"],
+            provider: .codebuff,
+            config: config)
+
+        #expect(env[CodebuffSettingsReader.apiTokenKey] == "env-token")
+        #expect(
+            ProviderTokenResolver.codebuffToken(environment: env, authFileURL: nil)
+                == "env-token")
+    }
+
+    @Test
+    func `leaves environment when API key missing`() {
         let config = ProviderConfig(id: .zai, apiKey: nil)
         let env = ProviderConfigEnvironment.applyAPIKeyOverride(
             base: [ZaiSettingsReader.apiTokenKey: "existing"],
@@ -74,4 +496,21 @@ struct ProviderConfigEnvironmentTests {
 
         #expect(env[ZaiSettingsReader.apiTokenKey] == "existing")
     }
+
+    @Test
+    func `applies API key override for poe`() {
+        let config = ProviderConfig(id: .poe, apiKey: "poe-token")
+        let env = ProviderConfigEnvironment.applyAPIKeyOverride(
+            base: [:],
+            provider: .poe,
+            config: config)
+
+        #expect(env[PoeSettingsReader.apiKeyEnvironmentKey] == "poe-token")
+        #expect(ProviderTokenResolver.poeToken(environment: env) == "poe-token")
+    }
+
+    @Test
+    func `poe supports API key override`() {
+        #expect(ProviderConfigEnvironment.supportsAPIKeyOverride(for: .poe) == true)
+    }
 }
diff --git a/Tests/CodexBarTests/ProviderCookieSettingsResolverTests.swift b/Tests/CodexBarTests/ProviderCookieSettingsResolverTests.swift
new file mode 100644
index 0000000000..5d88ebf17c
--- /dev/null
+++ b/Tests/CodexBarTests/ProviderCookieSettingsResolverTests.swift
@@ -0,0 +1,91 @@
+import CodexBarCore
+import Foundation
+import Testing
+
+struct ProviderCookieSettingsResolverTests {
+    @Test
+    func `shared cookie settings preserve Alibaba token plan defaults`() {
+        let settings = ProviderSettingsSnapshot.AlibabaTokenPlanProviderSettings()
+
+        #expect(settings.cookieSource == .auto)
+        #expect(settings.manualCookieHeader == nil)
+    }
+
+    @Test
+    func `provider cookie settings remain distinct nominal types`() {
+        let cursor = ProviderSettingsSnapshot.CursorProviderSettings(
+            cookieSource: .auto,
+            manualCookieHeader: nil)
+        let factory = ProviderSettingsSnapshot.FactoryProviderSettings(
+            cookieSource: .auto,
+            manualCookieHeader: nil)
+
+        #expect(Self.providerName(cursor) == "cursor")
+        #expect(Self.providerName(factory) == "factory")
+    }
+
+    @Test
+    func `selected cookie account overrides configured credentials`() {
+        let settings = ProviderCookieSettingsResolver.resolve(
+            provider: .manus,
+            configuredSource: .auto,
+            configuredHeader: "session_id=config",
+            selectedAccount: Self.account(token: "account"))
+
+        #expect(settings.cookieSource == .manual)
+        #expect(settings.manualCookieHeader == "session_id=account")
+    }
+
+    @Test
+    func `configured credentials remain when no account is selected`() {
+        let settings = ProviderCookieSettingsResolver.resolve(
+            provider: .cursor,
+            configuredSource: .manual,
+            configuredHeader: "Cookie: session=config",
+            selectedAccount: nil)
+
+        #expect(settings.cookieSource == .manual)
+        #expect(settings.manualCookieHeader == "Cookie: session=config")
+    }
+
+    @Test
+    func `environment token accounts do not become cookie credentials`() {
+        let settings = ProviderCookieSettingsResolver.resolve(
+            provider: .zai,
+            configuredSource: .off,
+            configuredHeader: nil,
+            selectedAccount: Self.account(token: "api-token"))
+
+        #expect(settings.cookieSource == .off)
+        #expect(settings.manualCookieHeader == nil)
+    }
+
+    @Test
+    func `providers without token account support ignore selected account`() {
+        let settings = ProviderCookieSettingsResolver.resolve(
+            provider: .mimo,
+            configuredSource: .auto,
+            configuredHeader: "configured=true",
+            selectedAccount: Self.account(token: "account=true"))
+
+        #expect(settings.cookieSource == .auto)
+        #expect(settings.manualCookieHeader == "configured=true")
+    }
+
+    private static func account(token: String) -> ProviderTokenAccount {
+        ProviderTokenAccount(
+            id: UUID(),
+            label: "Test",
+            token: token,
+            addedAt: 0,
+            lastUsed: nil)
+    }
+
+    private static func providerName(_: ProviderSettingsSnapshot.CursorProviderSettings) -> String {
+        "cursor"
+    }
+
+    private static func providerName(_: ProviderSettingsSnapshot.FactoryProviderSettings) -> String {
+        "factory"
+    }
+}
diff --git a/Tests/CodexBarTests/ProviderDiagnosticExportTests.swift b/Tests/CodexBarTests/ProviderDiagnosticExportTests.swift
new file mode 100644
index 0000000000..5209e3596f
--- /dev/null
+++ b/Tests/CodexBarTests/ProviderDiagnosticExportTests.swift
@@ -0,0 +1,594 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct ProviderDiagnosticExportTests {
+    @Test
+    func `generic diagnostic export encodes safe provider envelope`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let export = ProviderDiagnosticExport(
+            timestamp: now,
+            provider: "openai",
+            displayName: "OpenAI",
+            source: "api",
+            sourceMode: "auto",
+            auth: ProviderDiagnosticAuthSummary(configured: true, modes: ["api"]),
+            usage: ProviderDiagnosticUsageSummary(from: UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 25,
+                    windowMinutes: 300,
+                    resetsAt: now.addingTimeInterval(18000),
+                    resetDescription: "raw local text"),
+                secondary: nil,
+                updatedAt: now)),
+            fetchAttempts: [
+                ProviderDiagnosticFetchAttempt(
+                    kind: "api",
+                    wasAvailable: true,
+                    errorCategory: nil),
+            ],
+            error: nil,
+            settings: ProviderDiagnosticSettingsSummary(sourceMode: .auto),
+            details: nil)
+
+        let json = try self.json(export)
+
+        #expect(json.contains("\"provider\""))
+        #expect(json.contains("\"openai\""))
+        #expect(json.contains("\"platform\""))
+        #expect(json.contains("\"auth\""))
+        #expect(json.contains("\"dataConfidence\""))
+        #expect(json.contains("\"unknown\""))
+        #expect(json.contains("\"hasResetDescription\""))
+        #expect(!json.contains("sk-cp-"))
+        #expect(!json.contains("sk-api-"))
+        #expect(!json.contains("Bearer"))
+        #expect(!json.contains("raw local text"))
+        #expect(!json.contains("errorMessage"))
+        #expect(!json.contains("localizedDescription"))
+    }
+
+    @Test
+    func `diagnostic export decodes legacy schema without platform metadata`() throws {
+        let export = ProviderDiagnosticExport(
+            timestamp: Date(timeIntervalSince1970: 1_700_000_000),
+            provider: "openai",
+            displayName: "OpenAI",
+            source: "api",
+            sourceMode: "auto",
+            auth: ProviderDiagnosticAuthSummary(configured: true, modes: ["api"]),
+            usage: nil,
+            fetchAttempts: [],
+            error: nil,
+            settings: ProviderDiagnosticSettingsSummary(sourceMode: .auto),
+            details: nil)
+        var object = try #require(
+            try JSONSerialization.jsonObject(with: Data(self.json(export).utf8)) as? [String: Any])
+        object.removeValue(forKey: "platform")
+        object.removeValue(forKey: "appVersion")
+
+        let decoder = JSONDecoder()
+        decoder.dateDecodingStrategy = .iso8601
+        let decoded = try decoder.decode(
+            ProviderDiagnosticExport.self,
+            from: JSONSerialization.data(withJSONObject: object))
+
+        #expect(decoded.platform == ProviderDiagnosticPlatform.current)
+        #expect(decoded.appVersion == nil)
+    }
+
+    @Test
+    func `usage snapshot defaults legacy payloads to unknown confidence without reencoding unknown`() throws {
+        let json = """
+        {
+          "primary": {
+            "usedPercent": 42,
+            "windowMinutes": 300,
+            "hasResetDescription": false
+          },
+          "secondary": null,
+          "tertiary": null,
+          "updatedAt": "2023-11-14T22:13:20Z"
+        }
+        """
+
+        let decoder = JSONDecoder()
+        decoder.dateDecodingStrategy = .iso8601
+        let snapshot = try decoder.decode(UsageSnapshot.self, from: Data(json.utf8))
+        #expect(snapshot.dataConfidence == .unknown)
+
+        let encoded = try self.json(snapshot)
+        #expect(!encoded.contains("dataConfidence"))
+    }
+
+    @Test
+    func `usage snapshot preserves explicit confidence through Codable`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 12,
+                windowMinutes: 300,
+                resetsAt: now.addingTimeInterval(18000),
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: now,
+            dataConfidence: .exact)
+
+        let encoded = try self.json(snapshot)
+        #expect(encoded.contains("\"dataConfidence\" : \"exact\""))
+
+        let decoder = JSONDecoder()
+        decoder.dateDecodingStrategy = .iso8601
+        let decoded = try decoder.decode(UsageSnapshot.self, from: Data(encoded.utf8))
+        #expect(decoded.dataConfidence == .exact)
+    }
+
+    @Test
+    func `usage snapshot treats future confidence values as unknown`() throws {
+        let json = """
+        {
+          "primary": null,
+          "secondary": null,
+          "tertiary": null,
+          "updatedAt": "2023-11-14T22:13:20Z",
+          "dataConfidence": "future"
+        }
+        """
+
+        let decoder = JSONDecoder()
+        decoder.dateDecodingStrategy = .iso8601
+        let snapshot = try decoder.decode(UsageSnapshot.self, from: Data(json.utf8))
+
+        #expect(snapshot.dataConfidence == .unknown)
+        #expect(try !self.json(snapshot).contains("dataConfidence"))
+    }
+
+    @Test
+    func `diagnostic usage summary includes confidence`() {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let summary = ProviderDiagnosticUsageSummary(from: UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 12,
+                windowMinutes: 300,
+                resetsAt: now.addingTimeInterval(18000),
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: now,
+            dataConfidence: .exact))
+
+        #expect(summary.dataConfidence == "exact")
+    }
+
+    @Test
+    func `diagnostic usage summary defaults legacy payloads to unknown confidence`() throws {
+        let json = """
+        {
+          "updatedAt": "2023-11-14T22:13:20Z",
+          "windows": [],
+          "extraWindowCount": 0,
+          "providerCostPresent": false,
+          "providerSpecificData": []
+        }
+        """
+
+        let decoder = JSONDecoder()
+        decoder.dateDecodingStrategy = .iso8601
+        let summary = try decoder.decode(
+            ProviderDiagnosticUsageSummary.self,
+            from: Data(json.utf8))
+
+        #expect(summary.dataConfidence == "unknown")
+        #expect(try self.json(summary).contains("\"dataConfidence\" : \"unknown\""))
+    }
+
+    @Test
+    func `unwired provider diagnostics remain unknown confidence`() {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let snapshot = MiniMaxUsageSnapshot(
+            planName: "Max",
+            availablePrompts: 1000,
+            currentPrompts: 250,
+            remainingPrompts: 750,
+            windowMinutes: 300,
+            usedPercent: 25,
+            resetsAt: now.addingTimeInterval(18000),
+            updatedAt: now)
+
+        let usage = snapshot.toUsageSnapshot()
+        let summary = ProviderDiagnosticUsageSummary(from: usage)
+
+        #expect(usage.dataConfidence == .unknown)
+        #expect(summary.dataConfidence == "unknown")
+        #expect(summary.windows.first?.usedPercent == 25)
+    }
+
+    @Test
+    func `diagnostic export marks named windows with unknown usage`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let summary = ProviderDiagnosticUsageSummary(from: UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            extraRateWindows: [
+                NamedRateWindow(
+                    id: "nebula-window",
+                    title: "Nebula Window",
+                    window: RateWindow(
+                        usedPercent: 100,
+                        windowMinutes: nil,
+                        resetsAt: now.addingTimeInterval(3600),
+                        resetDescription: nil),
+                    usageKnown: false),
+            ],
+            updatedAt: now))
+
+        let json = try self.json(summary)
+        let object = try #require(
+            JSONSerialization.jsonObject(with: Data(json.utf8)) as? [String: Any])
+        let windows = try #require(object["windows"] as? [[String: Any]])
+
+        #expect(windows.first?["usageKnown"] as? Bool == false)
+    }
+
+    @Test
+    func `diagnostic rate window defaults legacy payloads to known usage`() throws {
+        let json = """
+        {
+          "label": "Legacy Window",
+          "usedPercent": 42,
+          "hasResetDescription": false
+        }
+        """
+
+        let window = try JSONDecoder().decode(
+            ProviderDiagnosticRateWindow.self,
+            from: Data(json.utf8))
+
+        #expect(window.usageKnown)
+    }
+
+    @Test
+    func `raw error text never appears in encoded JSON`() throws {
+        let export = ProviderDiagnosticExport(
+            timestamp: Date(timeIntervalSince1970: 1_700_000_000),
+            provider: "minimax",
+            displayName: "MiniMax",
+            source: "failed",
+            sourceMode: "auto",
+            auth: ProviderDiagnosticAuthSummary(configured: true, modes: ["api"]),
+            usage: nil,
+            fetchAttempts: [
+                ProviderDiagnosticFetchAttempt(
+                    kind: "api",
+                    wasAvailable: true,
+                    errorCategory: "network"),
+            ],
+            error: ProviderDiagnosticError(
+                category: "network",
+                safeDescription: "Network error - check your connection"),
+            settings: ProviderDiagnosticSettingsSummary(sourceMode: .auto, apiRegion: "global"),
+            details: nil)
+
+        let json = try self.json(export)
+
+        #expect(!json.contains("connection refused"))
+        #expect(!json.contains("network probe"))
+        #expect(!json.contains("not safe to expose"))
+        #expect(!json.contains("localizedDescription"))
+        #expect(!json.contains("raw"))
+        #expect(!json.contains("errorMessage"))
+        #expect(json.contains("errorCategory"))
+        #expect(json.contains("\"network\""))
+    }
+
+    @Test
+    func `diagnostic error maps MiniMaxUsageError categories safely`() {
+        let networkError = MiniMaxUsageError.networkError("connection refused")
+        let invalidCreds = MiniMaxUsageError.invalidCredentials
+        let apiError = MiniMaxUsageError.apiError("HTTP 404")
+        let parseError = MiniMaxUsageError.parseFailed("unexpected")
+
+        let diagNetwork = ProviderDiagnosticError(from: networkError, authConfigured: true)
+        #expect(diagNetwork.category == "network")
+        #expect(!diagNetwork.safeDescription.contains("connection refused"))
+
+        let diagCreds = ProviderDiagnosticError(from: invalidCreds, authConfigured: true)
+        #expect(diagCreds.category == "auth")
+
+        let diagAPI = ProviderDiagnosticError(from: apiError, authConfigured: true)
+        #expect(diagAPI.category == "api")
+
+        let diagParse = ProviderDiagnosticError(from: parseError, authConfigured: true)
+        #expect(diagParse.category == "parse")
+    }
+
+    @Test
+    func `diagnostic error maps Alibaba invalid endpoint override to configuration`() {
+        let error = ProviderEndpointOverrideError.alibabaCodingPlan("ALIBABA_CODING_PLAN_QUOTA_URL")
+        let diag = ProviderDiagnosticError(from: error, authConfigured: true)
+
+        #expect(diag.category == "configuration")
+        #expect(diag.safeDescription == "Configuration issue - check provider source and settings")
+    }
+
+    @Test
+    func `endpoint override fetch attempt stays in configuration category`() {
+        let error = ProviderEndpointOverrideError.minimax("MINIMAX_HOST")
+        let attempt = ProviderFetchAttempt(
+            strategyID: "minimax.web",
+            kind: .web,
+            wasAvailable: true,
+            errorDescription: error.localizedDescription)
+
+        let diagError = ProviderDiagnosticError(from: error, authConfigured: true)
+        let diagAttempt = ProviderDiagnosticFetchAttempt(from: attempt)
+
+        #expect(diagError.category == "configuration")
+        #expect(diagAttempt.errorCategory == "configuration")
+    }
+
+    @Test
+    func `no available strategy maps missing auth to auth category`() {
+        let error = ProviderFetchError.noAvailableStrategy(.minimax)
+        let diag = ProviderDiagnosticError(from: error, authConfigured: false)
+
+        #expect(diag.category == "auth")
+        #expect(diag.safeDescription.contains("Authentication"))
+    }
+
+    @Test
+    func `available failed strategy does not imply auth is configured`() {
+        let outcome = ProviderFetchOutcome(
+            result: .failure(ProviderFetchError.noAvailableStrategy(.antigravity)),
+            attempts: [
+                ProviderFetchAttempt(
+                    strategyID: "antigravity.ide-local",
+                    kind: .localProbe,
+                    wasAvailable: true,
+                    errorDescription: "unauthenticated local probe"),
+            ])
+
+        let summary = ProviderDiagnosticAuthSummary(configured: false, modes: []).resolved(with: outcome)
+
+        #expect(!summary.configured)
+        #expect(summary.modes.isEmpty)
+    }
+
+    @Test
+    func `fetch attempt error maps to safe category, never raw text`() {
+        let attemptWithRawError = ProviderFetchAttempt(
+            strategyID: "minimax.api",
+            kind: .apiToken,
+            wasAvailable: true,
+            errorDescription: "MiniMax API timeout after 30 seconds - connection refused for host platform.minimax.io")
+        let diagAttempt = ProviderDiagnosticFetchAttempt(from: attemptWithRawError)
+        #expect(diagAttempt.kind == "api")
+        #expect(diagAttempt.wasAvailable == true)
+        let errorCategoryOne = diagAttempt.errorCategory
+        #expect(errorCategoryOne == "network")
+        let cat1 = errorCategoryOne ?? ""
+        #expect(!cat1.contains("timeout"))
+        #expect(!cat1.contains("connection refused"))
+        #expect(!cat1.contains("platform.minimax.io"))
+
+        let attemptWithAuthError = ProviderFetchAttempt(
+            strategyID: "minimax.web",
+            kind: .web,
+            wasAvailable: false,
+            errorDescription: "invalid auth token cookie HERTZ-SESSION=abc123")
+        let diagAuthAttempt = ProviderDiagnosticFetchAttempt(from: attemptWithAuthError)
+        #expect(diagAuthAttempt.wasAvailable == false)
+        let errorCategoryTwo = diagAuthAttempt.errorCategory
+        #expect(errorCategoryTwo == "auth")
+        let cat2 = errorCategoryTwo ?? ""
+        #expect(!cat2.contains("HERTZ-SESSION"))
+    }
+
+    @Test
+    func `missing api key setup errors map to auth before api`() {
+        let category = ProviderDiagnosticFetchAttempt.errorCategoryLabel(
+            "Azure OpenAI API key not configured. Set AZURE_OPENAI_API_KEY.")
+
+        #expect(category == "auth")
+    }
+
+    @Test
+    func `MiniMax details map from MiniMaxUsageSnapshot correctly`() {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let snapshot = MiniMaxUsageSnapshot(
+            planName: "Max",
+            availablePrompts: 1000,
+            currentPrompts: 250,
+            remainingPrompts: 750,
+            windowMinutes: 300,
+            usedPercent: 25,
+            resetsAt: now.addingTimeInterval(18000),
+            updatedAt: now,
+            services: nil)
+
+        let details = MiniMaxDiagnosticDetails(from: snapshot)
+        #expect(details.planName == "Max")
+        #expect(details.availablePrompts == 1000)
+        #expect(details.currentPrompts == 250)
+        #expect(details.remainingPrompts == 750)
+        #expect(details.windowMinutes == 300)
+        #expect(details.usedPercent == 25)
+    }
+
+    @Test
+    func `service usage maps from MiniMaxServiceUsage correctly`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let service = MiniMaxServiceUsage(
+            serviceType: "General",
+            windowType: "Weekly",
+            timeRange: "Jun 15-Jun 22",
+            usage: 6,
+            limit: 150,
+            percent: 4,
+            resetsAt: now.addingTimeInterval(18000),
+            resetDescription: "Weekly")
+
+        let diagService = MiniMaxDiagnosticServiceUsage(from: service)
+        #expect(diagService.displayName == "General")
+        #expect(diagService.percent == 4)
+        #expect(diagService.usage == 6)
+        #expect(diagService.limit == 150)
+        #expect(diagService.remaining == 144)
+        #expect(diagService.isUnlimited == false)
+        #expect(diagService.windowType == "Weekly")
+        #expect(diagService.hasResetDescription == true)
+
+        let json = try self.json(diagService)
+        #expect(json.contains("hasResetDescription"))
+        #expect(json.contains(#""usage" : 6"#))
+        #expect(json.contains(#""limit" : 150"#))
+        #expect(json.contains(#""remaining" : 144"#))
+        #expect(!json.contains("resetDescription"))
+    }
+
+    @Test
+    func `unlimited MiniMax diagnostic omits remaining quota`() throws {
+        let service = MiniMaxServiceUsage(
+            serviceType: "General",
+            windowType: "Weekly",
+            timeRange: "",
+            usage: 0,
+            limit: 0,
+            percent: 0,
+            isUnlimited: true,
+            resetsAt: nil,
+            resetDescription: "Unlimited")
+
+        let diagnostic = MiniMaxDiagnosticServiceUsage(from: service)
+        #expect(diagnostic.isUnlimited)
+        #expect(diagnostic.remaining == nil)
+
+        let json = try self.json(diagnostic)
+        #expect(!json.contains("remaining"))
+    }
+
+    @Test
+    func `legacy MiniMax service diagnostic decodes without quota values`() throws {
+        let data = Data(#"""
+        {
+          "displayName": "General",
+          "percent": 4,
+          "windowType": "Weekly",
+          "resetsAt": null,
+          "hasResetDescription": true
+        }
+        """#.utf8)
+
+        let diagnostic = try JSONDecoder().decode(MiniMaxDiagnosticServiceUsage.self, from: data)
+
+        #expect(diagnostic.displayName == "General")
+        #expect(diagnostic.percent == 4)
+        #expect(diagnostic.usage == 0)
+        #expect(diagnostic.limit == 0)
+        #expect(diagnostic.remaining == nil)
+        #expect(!diagnostic.isUnlimited)
+        #expect(diagnostic.windowType == "Weekly")
+        #expect(diagnostic.hasResetDescription)
+    }
+
+    @Test
+    func `builder creates generic safe diagnostic with error on failure`() {
+        let outcome = ProviderFetchOutcome(
+            result: .failure(MiniMaxUsageError.networkError("timeout")),
+            attempts: [
+                ProviderFetchAttempt(
+                    strategyID: "minimax.api",
+                    kind: .apiToken,
+                    wasAvailable: true,
+                    errorDescription: "timeout"),
+            ])
+
+        let diag = ProviderDiagnosticExportBuilder.build(.init(
+            provider: .minimax,
+            descriptor: ProviderDescriptorRegistry.descriptor(for: .minimax),
+            outcome: outcome,
+            sourceMode: .auto,
+            settings: nil,
+            auth: ProviderDiagnosticAuthSummary(configured: true, modes: ["apiToken"]),
+            appVersion: "9.8.7"))
+
+        #expect(diag.provider == "minimax")
+        #expect(diag.platform == ProviderDiagnosticPlatform.current)
+        #expect(diag.appVersion == "9.8.7")
+        #expect(diag.source == "failed")
+        #expect(diag.auth.configured == true)
+        #expect(diag.usage == nil)
+        #expect(diag.error != nil)
+        #expect(diag.error?.category == "network")
+        #expect(diag.fetchAttempts.count == 1)
+        #expect(diag.fetchAttempts[0].errorCategory == "network")
+    }
+
+    @Test
+    func `builder creates generic safe diagnostic with MiniMax details on success`() {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let snapshot = MiniMaxUsageSnapshot(
+            planName: "Max",
+            availablePrompts: 1000,
+            currentPrompts: 250,
+            remainingPrompts: 750,
+            windowMinutes: 300,
+            usedPercent: 25,
+            resetsAt: now.addingTimeInterval(18000),
+            updatedAt: now)
+
+        let result = ProviderFetchResult(
+            usage: UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 25,
+                    windowMinutes: 300,
+                    resetsAt: now.addingTimeInterval(18000),
+                    resetDescription: nil),
+                secondary: nil,
+                tertiary: nil,
+                minimaxUsage: snapshot,
+                updatedAt: now),
+            credits: nil,
+            dashboard: nil,
+            sourceLabel: "api",
+            strategyID: "minimax.api",
+            strategyKind: .apiToken)
+
+        let outcome = ProviderFetchOutcome(
+            result: .success(result),
+            attempts: [
+                ProviderFetchAttempt(
+                    strategyID: "minimax.api",
+                    kind: .apiToken,
+                    wasAvailable: true,
+                    errorDescription: nil),
+            ])
+
+        let diag = ProviderDiagnosticExportBuilder.build(.init(
+            provider: .minimax,
+            descriptor: ProviderDescriptorRegistry.descriptor(for: .minimax),
+            outcome: outcome,
+            sourceMode: .auto,
+            settings: nil,
+            auth: ProviderDiagnosticAuthSummary(configured: true, modes: ["apiToken"])))
+
+        #expect(diag.provider == "minimax")
+        #expect(diag.source == "api")
+        #expect(diag.auth.configured == true)
+        #expect(diag.usage != nil)
+        #expect(diag.error == nil)
+
+        guard case let .minimax(details) = diag.details else {
+            Issue.record("Expected MiniMax diagnostic details")
+            return
+        }
+        #expect(details.planName == "Max")
+    }
+
+    private func json(_ value: some Encodable) throws -> String {
+        let encoder = JSONEncoder()
+        encoder.dateEncodingStrategy = .iso8601
+        encoder.outputFormatting = .prettyPrinted
+        let data = try encoder.encode(value)
+        return String(data: data, encoding: .utf8) ?? ""
+    }
+}
diff --git a/Tests/CodexBarTests/ProviderEndpointOverrideSecurityTests.swift b/Tests/CodexBarTests/ProviderEndpointOverrideSecurityTests.swift
new file mode 100644
index 0000000000..aec2741f4c
--- /dev/null
+++ b/Tests/CodexBarTests/ProviderEndpointOverrideSecurityTests.swift
@@ -0,0 +1,232 @@
+import CodexBarCore
+import Foundation
+import Testing
+
+struct ProviderEndpointOverrideSecurityTests {
+    @Test
+    func `sibling endpoint overrides allow bracketed IPv6 literals`() throws {
+        let endpoint = "https://[::1]:8443/v1"
+
+        try OpenRouterSettingsReader.validateEndpointOverrides(
+            environment: ["OPENROUTER_API_URL": endpoint])
+        #expect(OpenRouterSettingsReader.apiURL(
+            environment: ["OPENROUTER_API_URL": endpoint]).absoluteString == endpoint)
+
+        try CodebuffSettingsReader.validateEndpointOverrides(
+            environment: ["CODEBUFF_API_URL": endpoint])
+        #expect(CodebuffSettingsReader.apiURL(
+            environment: ["CODEBUFF_API_URL": endpoint]).absoluteString == endpoint)
+
+        try GroqSettingsReader.validateEndpointOverrides(
+            environment: [GroqSettingsReader.apiURLEnvironmentKey: endpoint])
+        #expect(GroqSettingsReader.apiURL(
+            environment: [GroqSettingsReader.apiURLEnvironmentKey: endpoint]).absoluteString == endpoint)
+
+        try ElevenLabsSettingsReader.validateEndpointOverrides(
+            environment: [ElevenLabsSettingsReader.apiURLEnvironmentKey: endpoint])
+        #expect(ElevenLabsSettingsReader.apiURL(
+            environment: [ElevenLabsSettingsReader.apiURLEnvironmentKey: endpoint]).absoluteString == endpoint)
+    }
+
+    @Test
+    func `sibling endpoint overrides reject userinfo and encoded host delimiters`() {
+        let userInfoURL = "https://user:pass@proxy.test/v1"
+        let malformedHostURLs = [
+            "https://proxy.test%2f.attacker.test/v1",
+            "https://bad host/v1",
+            "https://bad%20host/v1",
+            "https://bad%09host/v1",
+        ]
+
+        #expect(OpenRouterSettingsReader.apiURL(
+            environment: ["OPENROUTER_API_URL": userInfoURL]).host == "openrouter.ai")
+        for malformedHostURL in malformedHostURLs {
+            #expect(throws: OpenRouterSettingsError.invalidEndpointOverride("OPENROUTER_API_URL")) {
+                try OpenRouterSettingsReader.validateEndpointOverrides(
+                    environment: ["OPENROUTER_API_URL": malformedHostURL])
+            }
+        }
+
+        #expect(CodebuffSettingsReader.apiURL(
+            environment: ["CODEBUFF_API_URL": userInfoURL]).host == "www.codebuff.com")
+        for malformedHostURL in malformedHostURLs {
+            #expect(throws: CodebuffSettingsError.invalidEndpointOverride("CODEBUFF_API_URL")) {
+                try CodebuffSettingsReader.validateEndpointOverrides(
+                    environment: ["CODEBUFF_API_URL": malformedHostURL])
+            }
+        }
+
+        #expect(GroqSettingsReader.apiURL(
+            environment: [GroqSettingsReader.apiURLEnvironmentKey: userInfoURL]).host == "api.groq.com")
+        for malformedHostURL in malformedHostURLs {
+            #expect(throws: GroqSettingsError.invalidEndpointOverride(GroqSettingsReader.apiURLEnvironmentKey)) {
+                try GroqSettingsReader.validateEndpointOverrides(
+                    environment: [GroqSettingsReader.apiURLEnvironmentKey: malformedHostURL])
+            }
+        }
+
+        #expect(ElevenLabsSettingsReader.apiURL(
+            environment: [ElevenLabsSettingsReader.apiURLEnvironmentKey: userInfoURL]).host == "api.elevenlabs.io")
+        for malformedHostURL in malformedHostURLs {
+            #expect(throws: ElevenLabsSettingsError.invalidEndpointOverride(
+                ElevenLabsSettingsReader.apiURLEnvironmentKey))
+            {
+                try ElevenLabsSettingsReader.validateEndpointOverrides(
+                    environment: [ElevenLabsSettingsReader.apiURLEnvironmentKey: malformedHostURL])
+            }
+        }
+    }
+
+    @Test
+    func `credentialed fetchers reject insecure overrides before sending requests`() async {
+        let insecureURL = "http://attacker.test/v1"
+
+        do {
+            _ = try await OpenRouterUsageFetcher.fetchUsage(
+                apiKey: "openrouter-test",
+                environment: ["OPENROUTER_API_URL": insecureURL])
+            Issue.record("Expected OpenRouterSettingsError.invalidEndpointOverride")
+        } catch {
+            #expect(error as? OpenRouterSettingsError == .invalidEndpointOverride("OPENROUTER_API_URL"))
+        }
+
+        do {
+            _ = try await CodebuffUsageFetcher.fetchUsage(
+                apiKey: "codebuff-test",
+                environment: ["CODEBUFF_API_URL": insecureURL])
+            Issue.record("Expected CodebuffSettingsError.invalidEndpointOverride")
+        } catch {
+            #expect(error as? CodebuffSettingsError == .invalidEndpointOverride("CODEBUFF_API_URL"))
+        }
+
+        do {
+            _ = try await GroqUsageFetcher.fetchUsage(
+                apiKey: "groq-test",
+                environment: [GroqSettingsReader.apiURLEnvironmentKey: insecureURL])
+            Issue.record("Expected GroqSettingsError.invalidEndpointOverride")
+        } catch {
+            #expect(error as? GroqSettingsError == .invalidEndpointOverride(GroqSettingsReader.apiURLEnvironmentKey))
+        }
+
+        do {
+            _ = try await ElevenLabsUsageFetcher.fetchUsage(
+                apiKey: "elevenlabs-test",
+                environment: [ElevenLabsSettingsReader.apiURLEnvironmentKey: insecureURL])
+            Issue.record("Expected ElevenLabsSettingsError.invalidEndpointOverride")
+        } catch {
+            #expect(error as? ElevenLabsSettingsError == .invalidEndpointOverride(
+                ElevenLabsSettingsReader.apiURLEnvironmentKey))
+        }
+    }
+
+    @Test
+    func `OpenRouter endpoint override must be HTTPS or a bare host`() throws {
+        let httpsURL = OpenRouterSettingsReader.apiURL(
+            environment: ["OPENROUTER_API_URL": "https://router.test/v1"])
+        #expect(httpsURL.absoluteString == "https://router.test/v1")
+
+        let bareURL = OpenRouterSettingsReader.apiURL(environment: ["OPENROUTER_API_URL": "router.test/v1"])
+        #expect(bareURL.absoluteString == "https://router.test/v1")
+
+        let hostPortURL = OpenRouterSettingsReader.apiURL(
+            environment: ["OPENROUTER_API_URL": "localhost:8080/v1"])
+        #expect(hostPortURL.absoluteString == "https://localhost:8080/v1")
+
+        let httpURL = OpenRouterSettingsReader.apiURL(
+            environment: ["OPENROUTER_API_URL": "http://attacker.test/v1"])
+        #expect(httpURL.absoluteString == "https://openrouter.ai/api/v1")
+
+        do {
+            try OpenRouterSettingsReader.validateEndpointOverrides(
+                environment: ["OPENROUTER_API_URL": "http://attacker.test/v1"])
+            Issue.record("Expected OpenRouterSettingsError.invalidEndpointOverride")
+        } catch OpenRouterSettingsError.invalidEndpointOverride("OPENROUTER_API_URL") {
+            // Expected.
+        } catch {
+            Issue.record("Expected OpenRouterSettingsError.invalidEndpointOverride, got \(error)")
+        }
+    }
+
+    @Test
+    func `Codebuff endpoint override must be HTTPS or a bare host`() throws {
+        let httpsURL = CodebuffSettingsReader.apiURL(environment: ["CODEBUFF_API_URL": "https://codebuff.test"])
+        #expect(httpsURL.absoluteString == "https://codebuff.test")
+
+        let bareURL = CodebuffSettingsReader.apiURL(environment: ["CODEBUFF_API_URL": "codebuff.test"])
+        #expect(bareURL.absoluteString == "https://codebuff.test")
+
+        let hostPortURL = CodebuffSettingsReader.apiURL(environment: ["CODEBUFF_API_URL": "localhost:8080"])
+        #expect(hostPortURL.absoluteString == "https://localhost:8080")
+
+        let httpURL = CodebuffSettingsReader.apiURL(environment: ["CODEBUFF_API_URL": "http://attacker.test"])
+        #expect(httpURL.absoluteString == "https://www.codebuff.com")
+
+        do {
+            try CodebuffSettingsReader.validateEndpointOverrides(
+                environment: ["CODEBUFF_API_URL": "http://attacker.test"])
+            Issue.record("Expected CodebuffSettingsError.invalidEndpointOverride")
+        } catch CodebuffSettingsError.invalidEndpointOverride("CODEBUFF_API_URL") {
+            // Expected.
+        } catch {
+            Issue.record("Expected CodebuffSettingsError.invalidEndpointOverride, got \(error)")
+        }
+    }
+
+    @Test
+    func `Groq endpoint override must be HTTPS or a bare host`() throws {
+        let httpsURL = GroqSettingsReader.apiURL(
+            environment: [GroqSettingsReader.apiURLEnvironmentKey: "https://groq.test/v1"])
+        #expect(httpsURL.absoluteString == "https://groq.test/v1")
+
+        let bareURL = GroqSettingsReader.apiURL(
+            environment: [GroqSettingsReader.apiURLEnvironmentKey: "groq.test/v1"])
+        #expect(bareURL.absoluteString == "https://groq.test/v1")
+
+        let hostPortURL = GroqSettingsReader.apiURL(
+            environment: [GroqSettingsReader.apiURLEnvironmentKey: "localhost:8080/v1"])
+        #expect(hostPortURL.absoluteString == "https://localhost:8080/v1")
+
+        let httpURL = GroqSettingsReader.apiURL(
+            environment: [GroqSettingsReader.apiURLEnvironmentKey: "http://attacker.test/v1"])
+        #expect(httpURL.absoluteString == "https://api.groq.com/v1")
+
+        do {
+            try GroqSettingsReader.validateEndpointOverrides(
+                environment: [GroqSettingsReader.apiURLEnvironmentKey: "http://attacker.test/v1"])
+            Issue.record("Expected GroqSettingsError.invalidEndpointOverride")
+        } catch GroqSettingsError.invalidEndpointOverride(GroqSettingsReader.apiURLEnvironmentKey) {
+            // Expected.
+        } catch {
+            Issue.record("Expected GroqSettingsError.invalidEndpointOverride, got \(error)")
+        }
+    }
+
+    @Test
+    func `ElevenLabs endpoint override must be HTTPS or a bare host`() throws {
+        let httpsURL = ElevenLabsSettingsReader.apiURL(
+            environment: [ElevenLabsSettingsReader.apiURLEnvironmentKey: "https://eleven.test"])
+        #expect(httpsURL.absoluteString == "https://eleven.test")
+
+        let bareURL = ElevenLabsSettingsReader.apiURL(
+            environment: [ElevenLabsSettingsReader.apiURLEnvironmentKey: "eleven.test"])
+        #expect(bareURL.absoluteString == "https://eleven.test")
+
+        let hostPortURL = ElevenLabsSettingsReader.apiURL(
+            environment: [ElevenLabsSettingsReader.apiURLEnvironmentKey: "localhost:8080"])
+        #expect(hostPortURL.absoluteString == "https://localhost:8080")
+
+        let httpURL = ElevenLabsSettingsReader.apiURL(
+            environment: [ElevenLabsSettingsReader.apiURLEnvironmentKey: "http://attacker.test"])
+        #expect(httpURL.absoluteString == "https://api.elevenlabs.io")
+
+        do {
+            try ElevenLabsSettingsReader.validateEndpointOverrides(
+                environment: [ElevenLabsSettingsReader.apiURLEnvironmentKey: "http://attacker.test"])
+            Issue.record("Expected ElevenLabsSettingsError.invalidEndpointOverride")
+        } catch ElevenLabsSettingsError.invalidEndpointOverride(ElevenLabsSettingsReader.apiURLEnvironmentKey) {
+            // Expected.
+        } catch {
+            Issue.record("Expected ElevenLabsSettingsError.invalidEndpointOverride, got \(error)")
+        }
+    }
+}
diff --git a/Tests/CodexBarTests/ProviderEnvironmentResolverTests.swift b/Tests/CodexBarTests/ProviderEnvironmentResolverTests.swift
new file mode 100644
index 0000000000..52bb2fd5cd
--- /dev/null
+++ b/Tests/CodexBarTests/ProviderEnvironmentResolverTests.swift
@@ -0,0 +1,91 @@
+import CodexBarCore
+import Foundation
+import Testing
+
+struct ProviderEnvironmentResolverTests {
+    @Test
+    func `selected API account overrides saved and ambient credentials`() {
+        let account = Self.account(token: "account-token")
+        let environment = ProviderEnvironmentResolver.resolve(
+            base: [ZaiSettingsReader.apiTokenKey: "ambient-token"],
+            provider: .zai,
+            config: ProviderConfig(id: .zai, apiKey: "saved-token"),
+            selectedAccount: account)
+
+        #expect(environment[ZaiSettingsReader.apiTokenKey] == "account-token")
+    }
+
+    @Test
+    func `OpenAI account removes project scoping from saved config`() {
+        let account = Self.account(token: "sk-admin-account")
+        let environment = ProviderEnvironmentResolver.resolve(
+            base: [
+                OpenAIAPISettingsReader.adminAPIKeyEnvironmentKey: "ambient-token",
+                OpenAIAPISettingsReader.projectIDEnvironmentKey: "ambient-project",
+            ],
+            provider: .openai,
+            config: ProviderConfig(
+                id: .openai,
+                apiKey: "saved-token",
+                workspaceID: "saved-project"),
+            selectedAccount: account)
+
+        #expect(environment[OpenAIAPISettingsReader.adminAPIKeyEnvironmentKey] == "sk-admin-account")
+        #expect(environment[OpenAIAPISettingsReader.projectIDEnvironmentKey] == nil)
+    }
+
+    @Test
+    func `Claude session account removes API and OAuth credentials`() {
+        let environment = ProviderEnvironmentResolver.resolve(
+            base: [
+                ClaudeAdminAPISettingsReader.alternateAdminAPIKeyEnvironmentKey: "ambient-admin",
+                ClaudeOAuthCredentialsStore.environmentTokenKey: "ambient-oauth",
+            ],
+            provider: .claude,
+            config: ProviderConfig(id: .claude, apiKey: "saved-admin"),
+            selectedAccount: Self.account(token: "sk-ant-session-account"))
+
+        for key in ClaudeAdminAPISettingsReader.apiKeyEnvironmentKeys {
+            #expect(environment[key] == nil)
+        }
+        #expect(environment[ClaudeOAuthCredentialsStore.environmentTokenKey] == nil)
+    }
+
+    @Test
+    func `Claude OAuth account replaces incompatible credentials`() {
+        let environment = ProviderEnvironmentResolver.resolve(
+            base: [
+                ClaudeAdminAPISettingsReader.alternateAdminAPIKeyEnvironmentKey: "ambient-admin",
+                ClaudeOAuthCredentialsStore.environmentTokenKey: "ambient-oauth",
+            ],
+            provider: .claude,
+            config: ProviderConfig(id: .claude, apiKey: "saved-admin"),
+            selectedAccount: Self.account(token: "Bearer sk-ant-oat-account"))
+
+        for key in ClaudeAdminAPISettingsReader.apiKeyEnvironmentKeys {
+            #expect(environment[key] == nil)
+        }
+        #expect(environment[ClaudeOAuthCredentialsStore.environmentTokenKey] == "sk-ant-oat-account")
+    }
+
+    @Test
+    func `cookie account leaves unrelated provider environment intact`() {
+        let base = ["FOO": "bar"]
+        let environment = ProviderEnvironmentResolver.resolve(
+            base: base,
+            provider: .cursor,
+            config: ProviderConfig(id: .cursor),
+            selectedAccount: Self.account(token: "session=account"))
+
+        #expect(environment == base)
+    }
+
+    private static func account(token: String) -> ProviderTokenAccount {
+        ProviderTokenAccount(
+            id: UUID(),
+            label: "Test",
+            token: token,
+            addedAt: 0,
+            lastUsed: nil)
+    }
+}
diff --git a/Tests/CodexBarTests/ProviderHTTPClientTests.swift b/Tests/CodexBarTests/ProviderHTTPClientTests.swift
new file mode 100644
index 0000000000..c2fa5fc063
--- /dev/null
+++ b/Tests/CodexBarTests/ProviderHTTPClientTests.swift
@@ -0,0 +1,273 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct ProviderHTTPClientTests {
+    @Test
+    func `default client configuration fails blocked connections promptly`() {
+        let configuration = ProviderHTTPClient.defaultConfiguration()
+
+        #expect(configuration.timeoutIntervalForRequest == 30)
+        #expect(configuration.timeoutIntervalForResource == 90)
+        #if !os(Linux)
+        #expect(configuration.waitsForConnectivity == false)
+        #endif
+    }
+
+    @Test
+    func `client loads requests through an injected session`() async throws {
+        StubURLProtocol.requests = []
+        StubURLProtocol.handler = { request in
+            StubURLProtocol.requests.append(request)
+            let response = try HTTPURLResponse(
+                url: #require(request.url),
+                statusCode: 200,
+                httpVersion: "HTTP/1.1",
+                headerFields: ["Content-Type": "application/json"])!
+            return (Data(#"{"ok":true}"#.utf8), response)
+        }
+        defer {
+            StubURLProtocol.handler = nil
+            StubURLProtocol.requests = []
+        }
+
+        let configuration = URLSessionConfiguration.ephemeral
+        configuration.protocolClasses = [StubURLProtocol.self]
+        let client = ProviderHTTPClient(session: URLSession(configuration: configuration))
+        let request = try URLRequest(url: #require(URL(string: "https://example.com/status")))
+
+        let (data, response) = try await client.data(for: request)
+
+        let body = try #require(String(data: data, encoding: .utf8))
+        #expect(body == #"{"ok":true}"#)
+        #expect((response as? HTTPURLResponse)?.statusCode == 200)
+        #expect(StubURLProtocol.requests.count == 1)
+        #expect(StubURLProtocol.requests.first?.url?.host == "example.com")
+    }
+
+    @Test
+    func `response helper unwraps HTTP responses`() async throws {
+        let transport = ProviderHTTPTransportHandler { request in
+            let response = try HTTPURLResponse(
+                url: #require(request.url),
+                statusCode: 204,
+                httpVersion: "HTTP/1.1",
+                headerFields: ["X-Test": "ok"])!
+            return (Data("done".utf8), response)
+        }
+        let request = try URLRequest(url: #require(URL(string: "https://example.com/ok")))
+
+        let response = try await transport.response(for: request)
+
+        #expect(response.statusCode == 204)
+        #expect(response.response.value(forHTTPHeaderField: "X-Test") == "ok")
+        #expect(String(data: response.data, encoding: .utf8) == "done")
+    }
+
+    @Test
+    func `response helper rejects non HTTP responses`() async throws {
+        let transport = ProviderHTTPTransportHandler { request in
+            let response = URLResponse(
+                url: request.url ?? URL(string: "https://example.com/not-http")!,
+                mimeType: nil,
+                expectedContentLength: 0,
+                textEncodingName: nil)
+            return (Data(), response)
+        }
+        let request = try URLRequest(url: #require(URL(string: "https://example.com/not-http")))
+
+        await #expect(throws: URLError.self) {
+            _ = try await transport.response(for: request)
+        }
+    }
+
+    @Test
+    func `response helper retries transient HTTP status once`() async throws {
+        let script = ScriptedHTTPTransport(statusCodes: [503, 200])
+        let request = try URLRequest(url: #require(URL(string: "https://example.com/retry")))
+
+        let response = try await script.response(for: request, retryPolicy: .testOneRetry)
+
+        #expect(response.statusCode == 200)
+        #expect(await script.requestCount() == 2)
+    }
+
+    @Test
+    func `response helper retries transient URL error once`() async throws {
+        let script = ScriptedHTTPTransport(results: [
+            .failure(URLError(.timedOut)),
+            .success(200),
+        ])
+        let request = try URLRequest(url: #require(URL(string: "https://example.com/retry-error")))
+
+        let response = try await script.response(for: request, retryPolicy: .testOneRetry)
+
+        #expect(response.statusCode == 200)
+        #expect(await script.requestCount() == 2)
+    }
+
+    @Test
+    func `response helper does not retry non idempotent methods`() async throws {
+        let script = ScriptedHTTPTransport(statusCodes: [503, 200])
+        var request = try URLRequest(url: #require(URL(string: "https://example.com/post")))
+        request.httpMethod = "POST"
+
+        let response = try await script.response(for: request, retryPolicy: .testOneRetry)
+
+        #expect(response.statusCode == 503)
+        #expect(await script.requestCount() == 1)
+    }
+
+    @Test
+    func `response helper does not retry auth failures`() async throws {
+        let script = ScriptedHTTPTransport(statusCodes: [403, 200])
+        let request = try URLRequest(url: #require(URL(string: "https://example.com/forbidden")))
+
+        let response = try await script.response(for: request, retryPolicy: .testOneRetry)
+
+        #expect(response.statusCode == 403)
+        #expect(await script.requestCount() == 1)
+    }
+
+    @Test
+    func `redirect guard blocks cross origin redirects`() throws {
+        var redirectRequest = try URLRequest(url: #require(URL(string: "https://attacker.example/capture")))
+        redirectRequest.setValue("[REDACTED]", forHTTPHeaderField: "Cookie")
+        redirectRequest.setValue("[REDACTED]", forHTTPHeaderField: "x-api-key")
+
+        let guarded = ProviderHTTPRedirectGuardDelegate.guardedRedirectRequest(
+            originalURL: URL(string: "https://provider.example/usage"),
+            redirectRequest: redirectRequest)
+
+        #expect(guarded == nil)
+    }
+
+    @Test
+    func `redirect guard blocks non HTTPS redirects`() throws {
+        var redirectRequest = try URLRequest(url: #require(URL(string: "http://provider.example/capture")))
+        redirectRequest.setValue("[REDACTED]", forHTTPHeaderField: "Cookie")
+
+        let guarded = ProviderHTTPRedirectGuardDelegate.guardedRedirectRequest(
+            originalURL: URL(string: "https://provider.example/usage"),
+            redirectRequest: redirectRequest)
+
+        #expect(guarded == nil)
+    }
+
+    @Test
+    func `redirect guard blocks redirects without an original URL`() throws {
+        let redirectRequest = try URLRequest(url: #require(URL(string: "https://provider.example/usage/next")))
+
+        let guarded = ProviderHTTPRedirectGuardDelegate.guardedRedirectRequest(
+            originalURL: nil,
+            redirectRequest: redirectRequest)
+
+        #expect(guarded == nil)
+    }
+
+    @Test
+    func `redirect guard blocks port changes`() throws {
+        let redirectRequest = try URLRequest(url: #require(URL(string: "https://provider.example:8443/usage")))
+
+        let guarded = ProviderHTTPRedirectGuardDelegate.guardedRedirectRequest(
+            originalURL: URL(string: "https://provider.example/usage"),
+            redirectRequest: redirectRequest)
+
+        #expect(guarded == nil)
+    }
+
+    @Test
+    func `redirect guard preserves same origin HTTPS requests`() throws {
+        var redirectRequest = try URLRequest(url: #require(URL(string: "https://provider.example/usage/next")))
+        redirectRequest.setValue("[REDACTED]", forHTTPHeaderField: "Cookie")
+        redirectRequest.setValue("[REDACTED]", forHTTPHeaderField: "Authorization")
+        redirectRequest.setValue("[REDACTED]", forHTTPHeaderField: "x-api-key")
+        redirectRequest.setValue("application/json", forHTTPHeaderField: "Accept")
+
+        let guarded = try #require(ProviderHTTPRedirectGuardDelegate.guardedRedirectRequest(
+            originalURL: URL(string: "https://provider.example/usage"),
+            redirectRequest: redirectRequest))
+
+        #expect(guarded.value(forHTTPHeaderField: "Cookie") == "[REDACTED]")
+        #expect(guarded.value(forHTTPHeaderField: "Authorization") == "[REDACTED]")
+        #expect(guarded.value(forHTTPHeaderField: "x-api-key") == "[REDACTED]")
+        #expect(guarded.value(forHTTPHeaderField: "Accept") == "application/json")
+    }
+}
+
+extension ProviderHTTPRetryPolicy {
+    fileprivate static let testOneRetry = ProviderHTTPRetryPolicy(
+        maxRetries: 1,
+        baseDelaySeconds: 0,
+        maxDelaySeconds: 0)
+}
+
+private actor ScriptedHTTPTransport: ProviderHTTPTransport {
+    enum Result {
+        case success(Int)
+        case failure(URLError)
+    }
+
+    private var results: [Result]
+    private var requests: [URLRequest] = []
+
+    init(statusCodes: [Int]) {
+        self.results = statusCodes.map(Result.success)
+    }
+
+    init(results: [Result]) {
+        self.results = results
+    }
+
+    func requestCount() -> Int {
+        self.requests.count
+    }
+
+    func data(for request: URLRequest) throws -> (Data, URLResponse) {
+        self.requests.append(request)
+        let next = self.results.isEmpty ? .success(200) : self.results.removeFirst()
+        switch next {
+        case let .success(statusCode):
+            let response = HTTPURLResponse(
+                url: request.url ?? URL(string: "https://example.com")!,
+                statusCode: statusCode,
+                httpVersion: "HTTP/1.1",
+                headerFields: nil)!
+            return (Data(#"{"ok":true}"#.utf8), response)
+        case let .failure(error):
+            throw error
+        }
+    }
+}
+
+final class StubURLProtocol: URLProtocol {
+    nonisolated(unsafe) static var handler: ((URLRequest) throws -> (Data, URLResponse))?
+    nonisolated(unsafe) static var requests: [URLRequest] = []
+
+    override static func canInit(with request: URLRequest) -> Bool {
+        true
+    }
+
+    override static func canonicalRequest(for request: URLRequest) -> URLRequest {
+        request
+    }
+
+    override func startLoading() {
+        guard let handler = Self.handler else {
+            self.client?.urlProtocol(self, didFailWithError: URLError(.cannotLoadFromNetwork))
+            return
+        }
+
+        do {
+            let (data, response) = try handler(self.request)
+            self.client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
+            self.client?.urlProtocol(self, didLoad: data)
+            self.client?.urlProtocolDidFinishLoading(self)
+        } catch {
+            self.client?.urlProtocol(self, didFailWithError: error)
+        }
+    }
+
+    override func stopLoading() {}
+}
diff --git a/Tests/CodexBarTests/ProviderHTTPTransportStub.swift b/Tests/CodexBarTests/ProviderHTTPTransportStub.swift
new file mode 100644
index 0000000000..1c01e75cc6
--- /dev/null
+++ b/Tests/CodexBarTests/ProviderHTTPTransportStub.swift
@@ -0,0 +1,20 @@
+import Foundation
+@testable import CodexBarCore
+
+actor ProviderHTTPTransportStub: ProviderHTTPTransport {
+    private let handler: @Sendable (URLRequest) async throws -> (Data, URLResponse)
+    private var recordedRequests: [URLRequest] = []
+
+    init(handler: @escaping @Sendable (URLRequest) async throws -> (Data, URLResponse)) {
+        self.handler = handler
+    }
+
+    func requests() -> [URLRequest] {
+        self.recordedRequests
+    }
+
+    func data(for request: URLRequest) async throws -> (Data, URLResponse) {
+        self.recordedRequests.append(request)
+        return try await self.handler(request)
+    }
+}
diff --git a/Tests/CodexBarTests/ProviderIconResourcesTests.swift b/Tests/CodexBarTests/ProviderIconResourcesTests.swift
index 7ecbe7b260..2d00a9ca44 100644
--- a/Tests/CodexBarTests/ProviderIconResourcesTests.swift
+++ b/Tests/CodexBarTests/ProviderIconResourcesTests.swift
@@ -1,12 +1,13 @@
 import AppKit
+import CodexBarCore
 import Foundation
 import Testing
+@testable import CodexBar
 
 @MainActor
-@Suite
 struct ProviderIconResourcesTests {
     @Test
-    func providerIconSVGsExist() throws {
+    func `provider icon SV gs exist`() throws {
         let root = try Self.repoRoot()
         let resources = root.appending(path: "Sources/CodexBar/Resources", directoryHint: .isDirectory)
 
@@ -17,10 +18,24 @@ struct ProviderIconResourcesTests {
             "minimax",
             "cursor",
             "opencode",
+            "opencodego",
+            "alibaba",
             "gemini",
             "antigravity",
             "factory",
             "copilot",
+            "devin",
+            "crof",
+            "commandcode",
+            "t3chat",
+            "kimi",
+            "bedrock",
+            "elevenlabs",
+            "groq",
+            "llmproxy",
+            "litellm",
+            "deepgram",
+            "ollama",
         ]
         for slug in slugs {
             let url = resources.appending(path: "ProviderIcon-\(slug).svg")
@@ -33,6 +48,82 @@ struct ProviderIconResourcesTests {
         }
     }
 
+    @Test
+    func `groq and grok provider icons are distinct`() throws {
+        let root = try Self.repoRoot()
+        let resources = root.appending(path: "Sources/CodexBar/Resources", directoryHint: .isDirectory)
+        let groq = try String(contentsOf: resources.appending(path: "ProviderIcon-groq.svg"), encoding: .utf8)
+        let grok = try String(contentsOf: resources.appending(path: "ProviderIcon-grok.svg"), encoding: .utf8)
+
+        #expect(groq != grok)
+    }
+
+    @Test
+    func `provider brand icons are cached after first load`() throws {
+        ProviderBrandIcon.resetCacheForTesting()
+        defer { ProviderBrandIcon.resetCacheForTesting() }
+
+        let first = try #require(ProviderBrandIcon.image(for: .codex))
+        let second = try #require(ProviderBrandIcon.image(for: .codex))
+
+        #expect(first === second)
+        #expect(first.size == NSSize(width: 16, height: 16))
+        #expect(first.isTemplate)
+    }
+
+    @Test
+    func `ollama provider icon uses template rendering`() throws {
+        ProviderBrandIcon.resetCacheForTesting()
+        defer { ProviderBrandIcon.resetCacheForTesting() }
+
+        let image = try #require(ProviderBrandIcon.image(for: .ollama))
+
+        #expect(image.size == NSSize(width: 16, height: 16))
+        #expect(image.isTemplate)
+
+        let bitmap = try #require(NSBitmapImageRep(
+            bitmapDataPlanes: nil,
+            pixelsWide: 16,
+            pixelsHigh: 16,
+            bitsPerSample: 8,
+            samplesPerPixel: 4,
+            hasAlpha: true,
+            isPlanar: false,
+            colorSpaceName: .deviceRGB,
+            bytesPerRow: 0,
+            bitsPerPixel: 0))
+        let context = try #require(NSGraphicsContext(bitmapImageRep: bitmap))
+        NSGraphicsContext.saveGraphicsState()
+        NSGraphicsContext.current = context
+        context.cgContext.clear(CGRect(x: 0, y: 0, width: 16, height: 16))
+        image.draw(in: NSRect(x: 0, y: 0, width: 16, height: 16))
+        NSGraphicsContext.restoreGraphicsState()
+
+        var visiblePixels = 0
+        for y in 0..<bitmap.pixelsHigh {
+            for x in 0..<bitmap.pixelsWide
+                where (bitmap.colorAt(x: x, y: y)?.alphaComponent ?? 0) > 0
+            {
+                visiblePixels += 1
+            }
+        }
+        #expect(visiblePixels > 40)
+        #expect(visiblePixels < 240)
+    }
+
+    @Test
+    func `registered providers resolve bundled brand icons`() {
+        ProviderBrandIcon.resetCacheForTesting()
+        defer { ProviderBrandIcon.resetCacheForTesting() }
+
+        for provider in UsageProvider.allCases {
+            let descriptor = ProviderDescriptorRegistry.descriptor(for: provider)
+            #expect(
+                ProviderBrandIcon.image(for: provider) != nil,
+                "Missing icon resource \(descriptor.branding.iconResourceName).svg for \(provider.rawValue)")
+        }
+    }
+
     private static func repoRoot() throws -> URL {
         var dir = URL(filePath: #filePath).deletingLastPathComponent()
         for _ in 0..<12 {
diff --git a/Tests/CodexBarTests/ProviderLabelMetadataCharacterizationTests.swift b/Tests/CodexBarTests/ProviderLabelMetadataCharacterizationTests.swift
new file mode 100644
index 0000000000..9d3c01e9b4
--- /dev/null
+++ b/Tests/CodexBarTests/ProviderLabelMetadataCharacterizationTests.swift
@@ -0,0 +1,63 @@
+import CodexBarCore
+import Testing
+
+struct ProviderLabelMetadataCharacterizationTests {
+    // MARK: - Label non-empty constraints
+
+    @Test
+    func `displayName is non-empty for all providers`() {
+        for descriptor in ProviderDescriptorRegistry.all {
+            #expect(
+                !descriptor.metadata.displayName.isEmpty,
+                "Provider \(descriptor.id.rawValue) has empty displayName.")
+        }
+    }
+
+    @Test
+    func `sessionLabel is non-empty for all providers`() {
+        for descriptor in ProviderDescriptorRegistry.all {
+            #expect(
+                !descriptor.metadata.sessionLabel.isEmpty,
+                "Provider \(descriptor.id.rawValue) has empty sessionLabel.")
+        }
+    }
+
+    // MARK: - Known empty weeklyLabel exceptions
+
+    @Test
+    func `weeklyLabel empty providers are explicitly characterized`() {
+        // Allowlist of providers known to have empty weeklyLabel on current main.
+        // If a new provider is added with empty weeklyLabel, this test fails and
+        // requires a deliberate decision to add it here — preventing silent regressions.
+        let knownEmptyWeeklyLabelProviders: Set<UsageProvider> = [.mistral]
+        for descriptor in ProviderDescriptorRegistry.all where descriptor.metadata.weeklyLabel.isEmpty {
+            #expect(
+                knownEmptyWeeklyLabelProviders.contains(descriptor.id),
+                "Provider \(descriptor.id.rawValue) has empty weeklyLabel and is not in the known exception list.")
+        }
+    }
+
+    // MARK: - Invariant: supportsOpus implies opusLabel
+
+    @Test
+    func `supportsOpus providers declare non-empty opusLabel`() {
+        for descriptor in ProviderDescriptorRegistry.all where descriptor.metadata.supportsOpus {
+            #expect(
+                descriptor.metadata.opusLabel != nil && !descriptor.metadata.opusLabel!.isEmpty,
+                "Provider \(descriptor.id.rawValue) has supportsOpus=true but opusLabel is nil or empty.")
+        }
+    }
+
+    // MARK: - opusLabel structural constraint
+
+    @Test
+    func `opusLabel is nil or non-empty`() {
+        for descriptor in ProviderDescriptorRegistry.all {
+            if let opusLabel = descriptor.metadata.opusLabel {
+                #expect(
+                    !opusLabel.isEmpty,
+                    "Provider \(descriptor.id.rawValue) has empty opusLabel string instead of nil.")
+            }
+        }
+    }
+}
diff --git a/Tests/CodexBarTests/ProviderMetadataStatusLinkTests.swift b/Tests/CodexBarTests/ProviderMetadataStatusLinkTests.swift
index c4f3f23673..3ca12b2336 100644
--- a/Tests/CodexBarTests/ProviderMetadataStatusLinkTests.swift
+++ b/Tests/CodexBarTests/ProviderMetadataStatusLinkTests.swift
@@ -1,10 +1,9 @@
 import Testing
 @testable import CodexBarCore
 
-@Suite
 struct ProviderMetadataStatusLinkTests {
     @Test
-    func workspaceStatusLinkMatchesProductID() {
+    func `workspace status link matches product ID`() {
         for (provider, meta) in ProviderDefaults.metadata {
             guard let productID = meta.statusWorkspaceProductID else { continue }
             let expected = "https://www.google.com/appsstatus/dashboard/products/\(productID)/history"
@@ -13,4 +12,13 @@ struct ProviderMetadataStatusLinkTests {
                 "Expected \(provider.rawValue) statusLinkURL to be \(expected)")
         }
     }
+
+    @Test
+    func `kimi K2 metadata does not present legacy endpoint as official`() throws {
+        let meta = try #require(ProviderDefaults.metadata[.kimik2])
+
+        #expect(meta.displayName == "Kimi K2 (unofficial)")
+        #expect(meta.toggleTitle == "Show unofficial Kimi K2 usage")
+        #expect(meta.dashboardURL == nil)
+    }
 }
diff --git a/Tests/CodexBarTests/ProviderPlanLineParsingTests.swift b/Tests/CodexBarTests/ProviderPlanLineParsingTests.swift
new file mode 100644
index 0000000000..11ef471b7c
--- /dev/null
+++ b/Tests/CodexBarTests/ProviderPlanLineParsingTests.swift
@@ -0,0 +1,72 @@
+import Testing
+@testable import CodexBarCore
+
+struct ProviderPlanLineParsingTests {
+    @Test
+    func `Claude plan matching does not bridge usage lines`() {
+        let usageText = """
+        Skills, subagents, plugins, and MCP servers
+        Noattributiondatayet·accumulatesasyouuseClaude
+
+        dtoday·wtoweek
+
+        Usagecredits
+        Usagecreditsareoff·/usage-creditstoturnthemon
+        """
+
+        let identity = ClaudeStatusProbe.parseIdentity(usageText: usageText, statusText: nil)
+
+        #expect(identity.loginMethod == nil)
+    }
+
+    @Test
+    func `Claude plan matching keeps single line phrases`() {
+        let identity = ClaudeStatusProbe.parseIdentity(
+            usageText: nil,
+            statusText: "Sonnet 4.6 · Claude Max · you@example.com")
+
+        #expect(identity.loginMethod == "Max")
+    }
+
+    @Test
+    func `Kiro legacy plan matching does not bridge lines`() throws {
+        let output = """
+        |
+        KIRO FREE
+        ████████████████████████████████████████████████████ 25%
+        (12.50 of 50 covered in plan), resets on 01/15
+        """
+
+        let snapshot = try KiroStatusProbe().parse(output: output)
+
+        #expect(snapshot.planName == "Kiro")
+    }
+
+    @Test
+    func `Kiro estimated usage plan matching does not bridge lines`() throws {
+        let output = """
+        Estimated Usage | resets on 2026-06-01 |
+        KIRO FREE
+        ████████████████████████████████████████████████████ 25%
+        (12.50 of 50 covered in plan), resets on 01/15
+        """
+
+        let snapshot = try KiroStatusProbe().parse(output: output)
+
+        #expect(snapshot.planName == "Kiro")
+    }
+
+    @Test
+    func `Kiro labeled plan matching does not bridge lines`() throws {
+        let output = """
+        Plan:
+        Q Developer Pro
+        ████████████████████████████████████████████████████ 25%
+        (12.50 of 50 covered in plan), resets on 01/15
+        """
+
+        let snapshot = try KiroStatusProbe().parse(output: output)
+
+        #expect(snapshot.planName == "Kiro")
+    }
+}
diff --git a/Tests/CodexBarTests/ProviderQuotaFixtureContractTests.swift b/Tests/CodexBarTests/ProviderQuotaFixtureContractTests.swift
new file mode 100644
index 0000000000..2eda0ad14d
--- /dev/null
+++ b/Tests/CodexBarTests/ProviderQuotaFixtureContractTests.swift
@@ -0,0 +1,79 @@
+import Foundation
+import Testing
+@testable import CodexBar
+@testable import CodexBarCore
+
+struct ProviderQuotaFixtureContractTests {
+    @Test
+    func `MiniMax fixture preserves quota windows and plan`() throws {
+        let data = try Self.fixtureData(provider: "MiniMax", name: "token-plan-normal", fileExtension: "json")
+        let snapshot = try MiniMaxUsageParser.parseCodingPlanRemains(
+            data: data,
+            now: Date(timeIntervalSince1970: 1_780_282_340))
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.identity(for: .minimax)?.loginMethod == "Token Plan Plus")
+        #expect(usage.primary?.usedPercent == 4)
+        #expect(usage.primary?.windowMinutes == 300)
+        #expect(usage.primary?.resetsAt == Date(timeIntervalSince1970: 1_780_297_200))
+        #expect(usage.secondary?.usedPercent == 1)
+        #expect(usage.secondary?.windowMinutes == 10080)
+        #expect(usage.secondary?.resetsAt == Date(timeIntervalSince1970: 1_780_848_000))
+    }
+
+    @Test
+    func `MiniMax fixture keeps windows when reset timestamps are absent`() throws {
+        let data = try Self.fixtureData(
+            provider: "MiniMax",
+            name: "token-plan-missing-reset",
+            fileExtension: "json")
+        let snapshot = try MiniMaxUsageParser.parseCodingPlanRemains(
+            data: data,
+            now: Date(timeIntervalSince1970: 1_780_282_340))
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.identity(for: .minimax)?.loginMethod == "Token Plan Plus")
+        #expect(usage.primary?.usedPercent == 25)
+        #expect(usage.primary?.resetsAt == nil)
+        #expect(usage.secondary?.usedPercent == 40)
+        #expect(usage.secondary?.windowMinutes == 10080)
+        #expect(usage.secondary?.resetsAt == nil)
+    }
+
+    @Test
+    func `OpenAI fixture preserves quota windows and plan`() throws {
+        let data = try Self.fixtureData(provider: "OpenAI", name: "pro-normal", fileExtension: "html")
+        let body = try #require(String(data: data, encoding: .utf8))
+        let limits = OpenAIDashboardParser.parseRateLimits(bodyText: body)
+
+        #expect(OpenAIDashboardParser.parsePlanFromHTML(html: body) == "Pro 5x")
+        #expect(limits.primary?.usedPercent == 28)
+        #expect(limits.primary?.windowMinutes == 300)
+        #expect(limits.primary?.resetDescription?.localizedCaseInsensitiveContains("resets") == true)
+        #expect(limits.secondary?.usedPercent == 59)
+        #expect(limits.secondary?.windowMinutes == 10080)
+        #expect(limits.secondary?.resetDescription?.localizedCaseInsensitiveContains("resets") == true)
+    }
+
+    @Test
+    func `Claude fixture preserves quota windows and plan`() throws {
+        let data = try Self.fixtureData(provider: "Claude", name: "weekly-limit", fileExtension: "json")
+        let snapshot = try #require(ClaudeUsageFetcher.parse(json: data))
+
+        #expect(snapshot.loginMethod == "Claude Max")
+        #expect(snapshot.primary.usedPercent == 7)
+        #expect(snapshot.primary.windowMinutes == 300)
+        #expect(snapshot.primary.resetDescription?.contains("Europe/Vienna") == true)
+        #expect(snapshot.secondary?.usedPercent == 21)
+        #expect(snapshot.secondary?.windowMinutes == 10080)
+        #expect(snapshot.secondary?.resetDescription?.contains("Europe/Vienna") == true)
+    }
+
+    private static func fixtureData(provider: String, name: String, fileExtension: String) throws -> Data {
+        let url = try #require(Bundle.module.url(
+            forResource: name,
+            withExtension: fileExtension,
+            subdirectory: "Fixtures/Providers/\(provider)"))
+        return try Data(contentsOf: url)
+    }
+}
diff --git a/Tests/CodexBarTests/ProviderRefreshCoordinatorTests.swift b/Tests/CodexBarTests/ProviderRefreshCoordinatorTests.swift
new file mode 100644
index 0000000000..9829410b79
--- /dev/null
+++ b/Tests/CodexBarTests/ProviderRefreshCoordinatorTests.swift
@@ -0,0 +1,122 @@
+import Testing
+@testable import CodexBar
+
+@MainActor
+struct ProviderRefreshCoordinatorTests {
+    @Test
+    func `replacement cancels and orders predecessor while advancing current generation`() async {
+        let coordinator = ProviderRefreshCoordinator<String>()
+        let first = coordinator.beginReplacingRequest(for: "codex")
+        let firstTask = Task {
+            while !Task.isCancelled {
+                await Task.yield()
+            }
+        }
+        first.state.install(task: firstTask)
+
+        let second = coordinator.beginReplacingRequest(for: "codex")
+
+        #expect(firstTask.isCancelled)
+        #expect(second.predecessorStates.count == 1)
+        #expect(second.predecessorStates[0] === first.state)
+        #expect(!coordinator.isCurrent(first.generation, for: "codex"))
+        #expect(coordinator.isCurrent(second.generation, for: "codex"))
+        await firstTask.value
+    }
+
+    @Test
+    func `coalescing returns latest request independently per key`() {
+        let coordinator = ProviderRefreshCoordinator<String>()
+        let firstCodex = coordinator.beginReplacingRequest(for: "codex")
+        let claude = coordinator.beginReplacingRequest(for: "claude")
+        let latestCodex = coordinator.beginReplacingRequest(for: "codex")
+
+        #expect(coordinator.coalescingState(for: "codex") === latestCodex.state)
+        #expect(coordinator.coalescingState(for: "claude") === claude.state)
+        #expect(coordinator.coalescingState(for: "codex") !== firstCodex.state)
+    }
+
+    @Test
+    func `canceling one of two waiters keeps shared task alive`() async {
+        let coordinator = ProviderRefreshCoordinator<String>()
+        let request = coordinator.beginReplacingRequest(for: "codex")
+        let gate = ProviderRefreshCoordinatorGate()
+        let task = Task {
+            await gate.wait()
+        }
+        request.state.install(task: task)
+
+        let owner = Task {
+            await coordinator.wait(for: "codex", state: request.state)
+        }
+        let shared = Task {
+            await coordinator.wait(for: "codex", state: request.state)
+        }
+        await Task.yield()
+        owner.cancel()
+        await Task.yield()
+
+        #expect(!task.isCancelled)
+
+        await gate.resume()
+        coordinator.complete(request.state, for: "codex", retryRequired: false)
+        _ = await owner.value
+        _ = await shared.value
+    }
+
+    @Test
+    func `wait result exposes retry without leaking task state`() async {
+        let coordinator = ProviderRefreshCoordinator<String>()
+        let request = coordinator.beginReplacingRequest(for: "codex")
+        let task = Task {}
+        request.state.install(task: task)
+        coordinator.complete(request.state, for: "codex", retryRequired: true)
+
+        let result = await coordinator.wait(for: "codex", state: request.state)
+
+        #expect(result == .retryRequired)
+    }
+
+    @Test
+    func `completion removal and activity counts are key scoped`() async {
+        let coordinator = ProviderRefreshCoordinator<String>()
+        let codex = coordinator.beginReplacingRequest(for: "codex")
+        let claude = coordinator.beginReplacingRequest(for: "claude")
+        let codexTask = Task {}
+        let claudeTask = Task {}
+        codex.state.install(task: codexTask)
+        claude.state.install(task: claudeTask)
+
+        #expect(coordinator.beginActivity(for: "codex"))
+        #expect(!coordinator.beginActivity(for: "codex"))
+        #expect(coordinator.beginActivity(for: "claude"))
+        #expect(!coordinator.endActivity(for: "codex"))
+        #expect(coordinator.endActivity(for: "codex"))
+        #expect(coordinator.endActivity(for: "claude"))
+
+        coordinator.complete(codex.state, for: "codex", retryRequired: true)
+        coordinator.complete(claude.state, for: "claude", retryRequired: false)
+        await codexTask.value
+        await claudeTask.value
+        await Task.yield()
+        await Task.yield()
+
+        #expect(coordinator.coalescingState(for: "codex") == nil)
+        #expect(coordinator.coalescingState(for: "claude") == nil)
+    }
+}
+
+private actor ProviderRefreshCoordinatorGate {
+    private var continuation: CheckedContinuation<Void, Never>?
+
+    func wait() async {
+        await withCheckedContinuation { continuation in
+            self.continuation = continuation
+        }
+    }
+
+    func resume() {
+        self.continuation?.resume()
+        self.continuation = nil
+    }
+}
diff --git a/Tests/CodexBarTests/ProviderRegistryTests.swift b/Tests/CodexBarTests/ProviderRegistryTests.swift
index 9bb79053dd..ec839ef6b4 100644
--- a/Tests/CodexBarTests/ProviderRegistryTests.swift
+++ b/Tests/CodexBarTests/ProviderRegistryTests.swift
@@ -1,10 +1,10 @@
 import CodexBarCore
 import Testing
+@testable import CodexBar
 
-@Suite
 struct ProviderRegistryTests {
     @Test
-    func descriptorRegistryIsCompleteAndDeterministic() {
+    func `descriptor registry is complete and deterministic`() {
         let descriptors = ProviderDescriptorRegistry.all
         let ids = descriptors.map(\.id)
 
@@ -19,7 +19,22 @@ struct ProviderRegistryTests {
     }
 
     @Test
-    func minimaxSortsAfterZaiInRegistry() {
+    func `implementation registry is complete and deterministic`() {
+        let implementations = ProviderImplementationRegistry.all
+        let ids = implementations.map(\.id)
+
+        #expect(!implementations.isEmpty, "ProviderImplementationRegistry must not be empty.")
+        #expect(Set(ids).count == ids.count, "ProviderImplementationRegistry contains duplicate IDs.")
+
+        let missing = Set(UsageProvider.allCases).subtracting(ids)
+        #expect(missing.isEmpty, "Missing implementations for providers: \(missing).")
+
+        let secondPass = ProviderImplementationRegistry.all.map(\.id)
+        #expect(ids == secondPass, "ProviderImplementationRegistry order changed between reads.")
+    }
+
+    @Test
+    func `minimax sorts after zai in registry`() {
         let ids = ProviderDescriptorRegistry.all.map(\.id)
         guard let zaiIndex = ids.firstIndex(of: .zai),
               let minimaxIndex = ids.firstIndex(of: .minimax)
diff --git a/Tests/CodexBarTests/ProviderSettingsDescriptorTests.swift b/Tests/CodexBarTests/ProviderSettingsDescriptorTests.swift
index 9d77ac5a76..c115258d6f 100644
--- a/Tests/CodexBarTests/ProviderSettingsDescriptorTests.swift
+++ b/Tests/CodexBarTests/ProviderSettingsDescriptorTests.swift
@@ -5,63 +5,16 @@ import Testing
 @testable import CodexBar
 
 @MainActor
-@Suite
 struct ProviderSettingsDescriptorTests {
     @Test
-    func toggleIDsAreUniqueAcrossProviders() throws {
-        let suite = "ProviderSettingsDescriptorTests-unique"
-        let defaults = try #require(UserDefaults(suiteName: suite))
-        defaults.removePersistentDomain(forName: suite)
-        let configStore = testConfigStore(suiteName: suite)
-        let settings = SettingsStore(
-            userDefaults: defaults,
-            configStore: configStore,
-            zaiTokenStore: NoopZaiTokenStore(),
-            syntheticTokenStore: NoopSyntheticTokenStore())
-        let store = UsageStore(
-            fetcher: UsageFetcher(environment: [:]),
-            browserDetection: BrowserDetection(cacheTTL: 0),
-            settings: settings)
-
-        var statusByID: [String: String] = [:]
-        var lastRunAtByID: [String: Date] = [:]
+    func `toggle I ds are unique across providers`() throws {
+        let fixture = try self.makeSettingsFixture(suite: "ProviderSettingsDescriptorTests-unique")
         var seenToggleIDs: Set<String> = []
         var seenActionIDs: Set<String> = []
         var seenPickerIDs: Set<String> = []
 
         for provider in UsageProvider.allCases {
-            let context = ProviderSettingsContext(
-                provider: provider,
-                settings: settings,
-                store: store,
-                boolBinding: { keyPath in
-                    Binding(
-                        get: { settings[keyPath: keyPath] },
-                        set: { settings[keyPath: keyPath] = $0 })
-                },
-                stringBinding: { keyPath in
-                    Binding(
-                        get: { settings[keyPath: keyPath] },
-                        set: { settings[keyPath: keyPath] = $0 })
-                },
-                statusText: { id in statusByID[id] },
-                setStatusText: { id, text in
-                    if let text {
-                        statusByID[id] = text
-                    } else {
-                        statusByID.removeValue(forKey: id)
-                    }
-                },
-                lastAppActiveRunAt: { id in lastRunAtByID[id] },
-                setLastAppActiveRunAt: { id, date in
-                    if let date {
-                        lastRunAtByID[id] = date
-                    } else {
-                        lastRunAtByID.removeValue(forKey: id)
-                    }
-                },
-                requestConfirmation: { _ in })
-
+            let context = fixture.settingsContext(provider: provider)
             let impl = try #require(ProviderCatalog.implementation(for: provider))
             let toggles = impl.settingsToggles(context: context)
             for toggle in toggles {
@@ -83,40 +36,24 @@ struct ProviderSettingsDescriptorTests {
     }
 
     @Test
-    func codexExposesUsageAndCookiePickers() throws {
-        let suite = "ProviderSettingsDescriptorTests-codex"
-        let defaults = try #require(UserDefaults(suiteName: suite))
-        defaults.removePersistentDomain(forName: suite)
-        let configStore = testConfigStore(suiteName: suite)
-        let settings = SettingsStore(
-            userDefaults: defaults,
-            configStore: configStore,
-            zaiTokenStore: NoopZaiTokenStore(),
-            syntheticTokenStore: NoopSyntheticTokenStore())
-        let store = UsageStore(
-            fetcher: UsageFetcher(environment: [:]),
-            browserDetection: BrowserDetection(cacheTTL: 0),
-            settings: settings)
+    func `openai exposes project id setting`() throws {
+        let fixture = try self.makeSettingsFixture(suite: "ProviderSettingsDescriptorTests-openai-project")
+        let context = fixture.settingsContext(provider: .openai)
+
+        let fields = OpenAIAPIProviderImplementation().settingsFields(context: context)
+        let project = try #require(fields.first(where: { $0.id == "openai-project-id" }))
+        project.binding.wrappedValue = "proj_abc"
+
+        #expect(project.title == "Project ID")
+        #expect(project.subtitle.contains(OpenAIAPISettingsReader.projectIDEnvironmentKey))
+        #expect(fixture.settings.openAIAPIProjectID == "proj_abc")
+        #expect(fixture.settings.providerConfig(for: .openai)?.sanitizedWorkspaceID == "proj_abc")
+    }
 
-        let context = ProviderSettingsContext(
-            provider: .codex,
-            settings: settings,
-            store: store,
-            boolBinding: { keyPath in
-                Binding(
-                    get: { settings[keyPath: keyPath] },
-                    set: { settings[keyPath: keyPath] = $0 })
-            },
-            stringBinding: { keyPath in
-                Binding(
-                    get: { settings[keyPath: keyPath] },
-                    set: { settings[keyPath: keyPath] = $0 })
-            },
-            statusText: { _ in nil },
-            setStatusText: { _, _ in },
-            lastAppActiveRunAt: { _ in nil },
-            setLastAppActiveRunAt: { _, _ in },
-            requestConfirmation: { _ in })
+    @Test
+    func `codex exposes usage and cookie pickers`() throws {
+        let fixture = try self.makeSettingsFixture(suite: "ProviderSettingsDescriptorTests-codex")
+        let context = fixture.settingsContext(provider: .codex)
 
         let pickers = CodexProviderImplementation().settingsPickers(context: context)
         let toggles = CodexProviderImplementation().settingsToggles(context: context)
@@ -126,44 +63,48 @@ struct ProviderSettingsDescriptorTests {
     }
 
     @Test
-    func claudeExposesUsageAndCookiePickers() throws {
-        let suite = "ProviderSettingsDescriptorTests-claude"
-        let defaults = try #require(UserDefaults(suiteName: suite))
-        defaults.removePersistentDomain(forName: suite)
-        let configStore = testConfigStore(suiteName: suite)
-        let settings = SettingsStore(
-            userDefaults: defaults,
-            configStore: configStore,
-            zaiTokenStore: NoopZaiTokenStore(),
-            syntheticTokenStore: NoopSyntheticTokenStore())
-        settings.debugDisableKeychainAccess = false
-        let store = UsageStore(
-            fetcher: UsageFetcher(environment: [:]),
-            browserDetection: BrowserDetection(cacheTTL: 0),
-            settings: settings)
+    func `antigravity usage source picker clarifies local ide and agy`() throws {
+        let fixture = try self.makeSettingsFixture(suite: "ProviderSettingsDescriptorTests-antigravity-source")
+        let context = fixture.settingsContext(provider: .antigravity)
+
+        let pickers = AntigravityProviderImplementation().settingsPickers(context: context)
+        let usagePicker = try #require(pickers.first(where: { $0.id == "antigravity-usage-source" }))
+
+        #expect(usagePicker.options.map(\.title) == ["Auto", "Google OAuth", "Local API / agy CLI"])
+        #expect(usagePicker.subtitle ==
+            "Auto tries Antigravity app, agy CLI, then IDE; OAuth follows for selected or signed-in accounts.")
+    }
+
+    @Test
+    func `codex exposes open AI web extras toggle as default off opt in`() throws {
+        let fixture = try self.makeSettingsFixture(suite: "ProviderSettingsDescriptorTests-codex-openai-toggle")
+        let context = fixture.settingsContext(provider: .codex)
+
+        let toggles = CodexProviderImplementation().settingsToggles(context: context)
+        let extrasToggle = try #require(toggles.first(where: { $0.id == "codex-openai-web-extras" }))
+        #expect(extrasToggle.binding.wrappedValue == false)
+        #expect(extrasToggle.subtitle.contains("Optional."))
+        #expect(extrasToggle.subtitle.contains("Turn this on"))
+
+        let batterySaverToggle = try #require(toggles.first(where: { $0.id == "codex-openai-web-battery-saver" }))
+        #expect(batterySaverToggle.binding.wrappedValue == false)
+        #expect(batterySaverToggle.isVisible?() == false)
+
+        fixture.settings.openAIWebAccessEnabled = true
+        #expect(batterySaverToggle.isVisible?() == true)
+    }
+
+    @Test
+    func `claude exposes usage and cookie pickers`() throws {
+        let fixture = try self.makeSettingsFixture(suite: "ProviderSettingsDescriptorTests-claude")
+        fixture.settings.debugDisableKeychainAccess = false
+        let context = fixture.settingsContext(provider: .claude)
 
-        let context = ProviderSettingsContext(
-            provider: .claude,
-            settings: settings,
-            store: store,
-            boolBinding: { keyPath in
-                Binding(
-                    get: { settings[keyPath: keyPath] },
-                    set: { settings[keyPath: keyPath] = $0 })
-            },
-            stringBinding: { keyPath in
-                Binding(
-                    get: { settings[keyPath: keyPath] },
-                    set: { settings[keyPath: keyPath] = $0 })
-            },
-            statusText: { _ in nil },
-            setStatusText: { _, _ in },
-            lastAppActiveRunAt: { _ in nil },
-            setLastAppActiveRunAt: { _, _ in },
-            requestConfirmation: { _ in })
         let pickers = ClaudeProviderImplementation().settingsPickers(context: context)
         #expect(pickers.contains(where: { $0.id == "claude-usage-source" }))
         #expect(pickers.contains(where: { $0.id == "claude-cookie-source" }))
+        let toggles = ClaudeProviderImplementation().settingsToggles(context: context)
+        #expect(!toggles.contains(where: { $0.id == "claude-peak-hours" }))
         let keychainPicker = try #require(pickers.first(where: { $0.id == "claude-keychain-prompt-policy" }))
         let optionIDs = Set(keychainPicker.options.map(\.id))
         #expect(optionIDs.contains(ClaudeOAuthKeychainPromptMode.never.rawValue))
@@ -173,43 +114,12 @@ struct ProviderSettingsDescriptorTests {
     }
 
     @Test
-    func claudePromptPolicyPickerHiddenWhenExperimentalReaderSelected() throws {
-        let suite = "ProviderSettingsDescriptorTests-claude-prompt-hidden-experimental"
-        let defaults = try #require(UserDefaults(suiteName: suite))
-        defaults.removePersistentDomain(forName: suite)
-        let configStore = testConfigStore(suiteName: suite)
-        let settings = SettingsStore(
-            userDefaults: defaults,
-            configStore: configStore,
-            zaiTokenStore: NoopZaiTokenStore(),
-            syntheticTokenStore: NoopSyntheticTokenStore())
-        settings.debugDisableKeychainAccess = false
-        settings.claudeOAuthKeychainReadStrategy = .securityCLIExperimental
-
-        let store = UsageStore(
-            fetcher: UsageFetcher(environment: [:]),
-            browserDetection: BrowserDetection(cacheTTL: 0),
-            settings: settings)
-
-        let context = ProviderSettingsContext(
-            provider: .claude,
-            settings: settings,
-            store: store,
-            boolBinding: { keyPath in
-                Binding(
-                    get: { settings[keyPath: keyPath] },
-                    set: { settings[keyPath: keyPath] = $0 })
-            },
-            stringBinding: { keyPath in
-                Binding(
-                    get: { settings[keyPath: keyPath] },
-                    set: { settings[keyPath: keyPath] = $0 })
-            },
-            statusText: { _ in nil },
-            setStatusText: { _, _ in },
-            lastAppActiveRunAt: { _ in nil },
-            setLastAppActiveRunAt: { _, _ in },
-            requestConfirmation: { _ in })
+    func `claude prompt policy picker hidden when experimental reader selected`() throws {
+        let fixture = try self.makeSettingsFixture(
+            suite: "ProviderSettingsDescriptorTests-claude-prompt-hidden-experimental")
+        fixture.settings.debugDisableKeychainAccess = false
+        fixture.settings.claudeOAuthKeychainReadStrategy = .securityCLIExperimental
+        let context = fixture.settingsContext(provider: .claude)
 
         let pickers = ClaudeProviderImplementation().settingsPickers(context: context)
         let keychainPicker = try #require(pickers.first(where: { $0.id == "claude-keychain-prompt-policy" }))
@@ -217,41 +127,30 @@ struct ProviderSettingsDescriptorTests {
     }
 
     @Test
-    func claudeKeychainPromptPolicyPickerDisabledWhenGlobalKeychainDisabled() throws {
-        let suite = "ProviderSettingsDescriptorTests-claude-keychain-disabled"
-        let defaults = try #require(UserDefaults(suiteName: suite))
-        defaults.removePersistentDomain(forName: suite)
-        let configStore = testConfigStore(suiteName: suite)
-        let settings = SettingsStore(
-            userDefaults: defaults,
-            configStore: configStore,
-            zaiTokenStore: NoopZaiTokenStore(),
-            syntheticTokenStore: NoopSyntheticTokenStore())
-        settings.debugDisableKeychainAccess = true
-        let store = UsageStore(
-            fetcher: UsageFetcher(environment: [:]),
-            browserDetection: BrowserDetection(cacheTTL: 0),
-            settings: settings)
+    func `claude avoid keychain prompts toggle is disabled when global keychain disabled`() throws {
+        let fixture = try self.makeSettingsFixture(suite: "ProviderSettingsDescriptorTests-claude-prompt-free-disabled")
+        fixture.settings.debugDisableKeychainAccess = true
+        fixture.settings.claudeOAuthPromptFreeCredentialsEnabled = true
+        let context = fixture.settingsContext(provider: .claude)
+
+        let toggles = ClaudeProviderImplementation().settingsToggles(context: context)
+        let promptFreeToggle = try #require(toggles.first(where: { $0.id == "claude-oauth-prompt-free-credentials" }))
+        #expect(promptFreeToggle.isEnabled?() == false)
+        #expect(promptFreeToggle.binding.wrappedValue == true)
+
+        promptFreeToggle.binding.wrappedValue = false
+        #expect(fixture.settings.claudeOAuthPromptFreeCredentialsEnabled == true)
 
-        let context = ProviderSettingsContext(
-            provider: .claude,
-            settings: settings,
-            store: store,
-            boolBinding: { keyPath in
-                Binding(
-                    get: { settings[keyPath: keyPath] },
-                    set: { settings[keyPath: keyPath] = $0 })
-            },
-            stringBinding: { keyPath in
-                Binding(
-                    get: { settings[keyPath: keyPath] },
-                    set: { settings[keyPath: keyPath] = $0 })
-            },
-            statusText: { _ in nil },
-            setStatusText: { _, _ in },
-            lastAppActiveRunAt: { _ in nil },
-            setLastAppActiveRunAt: { _, _ in },
-            requestConfirmation: { _ in })
+        fixture.settings.debugDisableKeychainAccess = false
+        #expect(promptFreeToggle.isEnabled?() == true)
+        #expect(promptFreeToggle.binding.wrappedValue == true)
+    }
+
+    @Test
+    func `claude keychain prompt policy picker disabled when global keychain disabled`() throws {
+        let fixture = try self.makeSettingsFixture(suite: "ProviderSettingsDescriptorTests-claude-keychain-disabled")
+        fixture.settings.debugDisableKeychainAccess = true
+        let context = fixture.settingsContext(provider: .claude)
 
         let pickers = ClaudeProviderImplementation().settingsPickers(context: context)
         let keychainPicker = try #require(pickers.first(where: { $0.id == "claude-keychain-prompt-policy" }))
@@ -261,16 +160,9 @@ struct ProviderSettingsDescriptorTests {
     }
 
     @Test
-    func claudeWebExtrasAutoDisablesWhenLeavingCLI() throws {
-        let suite = "ProviderSettingsDescriptorTests-claude-invariant"
-        let defaults = try #require(UserDefaults(suiteName: suite))
-        defaults.removePersistentDomain(forName: suite)
-        let configStore = testConfigStore(suiteName: suite)
-        let settings = SettingsStore(
-            userDefaults: defaults,
-            configStore: configStore,
-            zaiTokenStore: NoopZaiTokenStore(),
-            syntheticTokenStore: NoopSyntheticTokenStore())
+    func `claude web extras auto disables when leaving CLI`() throws {
+        let fixture = try self.makeSettingsFixture(suite: "ProviderSettingsDescriptorTests-claude-invariant")
+        let settings = fixture.settings
         settings.debugMenuEnabled = true
         settings.claudeUsageDataSource = .cli
         settings.claudeWebExtrasEnabled = true
@@ -280,48 +172,204 @@ struct ProviderSettingsDescriptorTests {
     }
 
     @Test
-    func kiloExposesUsageSourcePickerAndApiFieldOnly() throws {
-        let suite = "ProviderSettingsDescriptorTests-kilo"
+    func `kilo exposes usage source picker and api field only`() throws {
+        let fixture = try self.makeSettingsFixture(suite: "ProviderSettingsDescriptorTests-kilo")
+        let context = fixture.settingsContext(provider: .kilo)
+
+        let implementation = KiloProviderImplementation()
+        let toggles = implementation.settingsToggles(context: context)
+        let pickers = implementation.settingsPickers(context: context)
+        let fields = implementation.settingsFields(context: context)
+
+        #expect(toggles.isEmpty)
+        #expect(pickers.contains(where: { $0.id == "kilo-usage-source" }))
+        #expect(fields.contains(where: { $0.id == "kilo-api-key" }))
+    }
+
+    @Test
+    func `copilot budget secondary picker appears before cookie picker`() throws {
+        let fixture = try self.makeSettingsFixture(suite: "ProviderSettingsDescriptorTests-copilot-budget-pickers")
+        fixture.settings.copilotBudgetExtrasEnabled = true
+        let context = fixture.settingsContext(provider: .copilot)
+
+        let pickers = CopilotProviderImplementation().settingsPickers(context: context)
+
+        #expect(pickers.map(\.id) == ["copilot-icon-secondary-window", "copilot-budget-cookie-source"])
+        #expect(pickers.first?.title == "Menu bar secondary metric")
+    }
+
+    @Test
+    func `copilot manual cookie field is labelled and refreshable`() throws {
+        let fixture = try self.makeSettingsFixture(suite: "ProviderSettingsDescriptorTests-copilot-budget-field")
+        fixture.settings.copilotBudgetExtrasEnabled = true
+        fixture.settings.copilotBudgetCookieSource = .manual
+        let context = fixture.settingsContext(provider: .copilot)
+
+        let fields = CopilotProviderImplementation().settingsFields(context: context)
+        let field = try #require(fields.first { $0.id == "copilot-budget-cookie-header" })
+
+        #expect(field.title == "Manual GitHub Cookie header")
+        #expect(field.subtitle.contains("Treat this value like a password"))
+        #expect(field.actions.map(\.id) == ["refresh-copilot-budget-cookie"])
+    }
+
+    @Test
+    func `kimi exposes usage source picker plus api and cookie fields`() throws {
+        let fixture = try self.makeSettingsFixture(suite: "ProviderSettingsDescriptorTests-kimi")
+        let context = fixture.settingsContext(provider: .kimi)
+
+        let implementation = KimiProviderImplementation()
+        let pickers = implementation.settingsPickers(context: context)
+        let fields = implementation.settingsFields(context: context)
+
+        #expect(pickers.contains(where: { $0.id == "kimi-usage-source" }))
+        #expect(pickers.contains(where: { $0.id == "kimi-cookie-source" }))
+        #expect(fields.contains(where: { $0.id == "kimi-api-key" }))
+        #expect(fields.contains(where: { $0.id == "kimi-cookie" }))
+    }
+
+    @Test
+    func `kimi presentation follows selected source label`() throws {
+        let fixture = try self.makeSettingsFixture(suite: "ProviderSettingsDescriptorTests-kimi-presentation")
+        fixture.settings.kimiUsageDataSource = .api
+        let metadata = try #require(ProviderDescriptorRegistry.metadata[.kimi])
+        let context = fixture.presentationContext(provider: .kimi, metadata: metadata)
+
+        let detailLine = KimiProviderImplementation()
+            .presentation(context: context)
+            .detailLine(context)
+
+        #expect(detailLine == "api")
+    }
+
+    @Test
+    func `deepgram exposes api key and project id fields`() throws {
+        let fixture = try self.makeSettingsFixture(suite: "ProviderSettingsDescriptorTests-deepgram")
+        let context = fixture.settingsContext(provider: .deepgram)
+
+        let implementation = DeepgramProviderImplementation()
+        let fields = implementation.settingsFields(context: context)
+
+        #expect(fields.contains(where: { $0.id == "deepgram-api-key" }))
+        #expect(fields.contains(where: { $0.id == "deepgram-project-id" }))
+
+        // Basic presence checks for Deepgram settings fields (layout copied from OpenRouter)
+        _ = try #require(fields.first(where: { $0.id == "deepgram-project-id" }))
+        _ = try #require(fields.first(where: { $0.id == "deepgram-api-key" }))
+    }
+
+    @Test
+    func `alibaba presentation follows store source label`() throws {
+        let fixture = try self.makeSettingsFixture(suite: "ProviderSettingsDescriptorTests-alibaba-presentation")
+        let metadata = try #require(ProviderDescriptorRegistry.metadata[.alibaba])
+        let context = fixture.presentationContext(provider: .alibaba, metadata: metadata)
+
+        let detailLine = AlibabaCodingPlanProviderImplementation()
+            .presentation(context: context)
+            .detailLine(context)
+
+        #expect(detailLine == fixture.store.sourceLabel(for: .alibaba))
+    }
+
+    @Test
+    func `devin presentation follows store source label`() throws {
+        let fixture = try self.makeSettingsFixture(suite: "ProviderSettingsDescriptorTests-devin-presentation")
+        fixture.store.lastSourceLabels[.devin] = "web"
+        let metadata = try #require(ProviderDescriptorRegistry.metadata[.devin])
+        let context = fixture.presentationContext(provider: .devin, metadata: metadata)
+
+        let detailLine = DevinProviderImplementation()
+            .presentation(context: context)
+            .detailLine(context)
+
+        #expect(detailLine == "web")
+    }
+
+    @Test
+    func `alibaba token plan settings expose cookie controls`() throws {
+        let fixture = try self.makeSettingsFixture(suite: "ProviderSettingsDescriptorTests-alibaba-token-plan-settings")
+        fixture.settings.alibabaTokenPlanCookieSource = .manual
+        let context = fixture.settingsContext(provider: .alibabatokenplan)
+        let implementation = AlibabaTokenPlanProviderImplementation()
+        let pickers = implementation.settingsPickers(context: context)
+        let fields = implementation.settingsFields(context: context)
+
+        #expect(pickers.contains(where: { $0.id == "alibaba-token-plan-cookie-source" }))
+        #expect(fields.contains(where: { $0.id == "alibaba-token-plan-cookie" }))
+        #expect(fields.first?.actions.contains(where: { $0.id == "alibaba-token-plan-open-dashboard" }) == true)
+    }
+
+    private func makeSettingsFixture(suite: String) throws -> ProviderSettingsFixture {
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
-        let configStore = testConfigStore(suiteName: suite)
         let settings = SettingsStore(
             userDefaults: defaults,
-            configStore: configStore,
+            configStore: testConfigStore(suiteName: suite),
             zaiTokenStore: NoopZaiTokenStore(),
             syntheticTokenStore: NoopSyntheticTokenStore())
         let store = UsageStore(
             fetcher: UsageFetcher(environment: [:]),
             browserDetection: BrowserDetection(cacheTTL: 0),
             settings: settings)
+        return ProviderSettingsFixture(settings: settings, store: store)
+    }
 
-        let context = ProviderSettingsContext(
-            provider: .kilo,
-            settings: settings,
-            store: store,
-            boolBinding: { keyPath in
-                Binding(
-                    get: { settings[keyPath: keyPath] },
-                    set: { settings[keyPath: keyPath] = $0 })
-            },
-            stringBinding: { keyPath in
-                Binding(
-                    get: { settings[keyPath: keyPath] },
-                    set: { settings[keyPath: keyPath] = $0 })
-            },
-            statusText: { _ in nil },
-            setStatusText: { _, _ in },
-            lastAppActiveRunAt: { _ in nil },
-            setLastAppActiveRunAt: { _, _ in },
-            requestConfirmation: { _ in })
+    private struct ProviderSettingsFixture {
+        let settings: SettingsStore
+        let store: UsageStore
+        private let state = ProviderSettingsContextState()
 
-        let implementation = KiloProviderImplementation()
-        let toggles = implementation.settingsToggles(context: context)
-        let pickers = implementation.settingsPickers(context: context)
-        let fields = implementation.settingsFields(context: context)
+        @MainActor
+        func settingsContext(provider: UsageProvider) -> ProviderSettingsContext {
+            let settings = self.settings
+            let store = self.store
+            let state = self.state
+            return ProviderSettingsContext(
+                provider: provider,
+                settings: settings,
+                store: store,
+                boolBinding: { keyPath in
+                    Binding(
+                        get: { settings[keyPath: keyPath] },
+                        set: { settings[keyPath: keyPath] = $0 })
+                },
+                stringBinding: { keyPath in
+                    Binding(
+                        get: { settings[keyPath: keyPath] },
+                        set: { settings[keyPath: keyPath] = $0 })
+                },
+                statusText: { id in state.statusByID[id] },
+                setStatusText: { id, text in
+                    if let text {
+                        state.statusByID[id] = text
+                    } else {
+                        state.statusByID.removeValue(forKey: id)
+                    }
+                },
+                lastAppActiveRunAt: { id in state.lastRunAtByID[id] },
+                setLastAppActiveRunAt: { id, date in
+                    if let date {
+                        state.lastRunAtByID[id] = date
+                    } else {
+                        state.lastRunAtByID.removeValue(forKey: id)
+                    }
+                },
+                requestConfirmation: { _ in },
+                runLoginFlow: {})
+        }
 
-        #expect(toggles.isEmpty)
-        #expect(pickers.contains(where: { $0.id == "kilo-usage-source" }))
-        #expect(fields.contains(where: { $0.id == "kilo-api-key" }))
+        @MainActor
+        func presentationContext(provider: UsageProvider, metadata: ProviderMetadata) -> ProviderPresentationContext {
+            ProviderPresentationContext(
+                provider: provider,
+                settings: self.settings,
+                store: self.store,
+                metadata: metadata)
+        }
+    }
+
+    private final class ProviderSettingsContextState {
+        var statusByID: [String: String] = [:]
+        var lastRunAtByID: [String: Date] = [:]
     }
 }
diff --git a/Tests/CodexBarTests/ProviderStorageFootprintTests.swift b/Tests/CodexBarTests/ProviderStorageFootprintTests.swift
new file mode 100644
index 0000000000..78898609b1
--- /dev/null
+++ b/Tests/CodexBarTests/ProviderStorageFootprintTests.swift
@@ -0,0 +1,552 @@
+import AppKit
+import CodexBarCore
+import Foundation
+import Observation
+import Testing
+@testable import CodexBar
+
+struct ProviderStorageFootprintTests {
+    private final class ObservationFlag: @unchecked Sendable {
+        private let lock = NSLock()
+        private var value = false
+
+        func set() {
+            self.lock.lock()
+            self.value = true
+            self.lock.unlock()
+        }
+
+        func get() -> Bool {
+            self.lock.lock()
+            defer { self.lock.unlock() }
+            return self.value
+        }
+    }
+
+    @Test
+    func `scanner sums nested regular files and skips symlink targets`() throws {
+        let root = try Self.makeTemporaryDirectory()
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let nested = root.appendingPathComponent("nested", isDirectory: true)
+        try FileManager.default.createDirectory(at: nested, withIntermediateDirectories: true)
+        try Data(repeating: 1, count: 5).write(to: root.appendingPathComponent("a.jsonl"))
+        try Data(repeating: 2, count: 7).write(to: nested.appendingPathComponent("b.jsonl"))
+
+        let external = try Self.makeTemporaryDirectory()
+        defer { try? FileManager.default.removeItem(at: external) }
+        let target = external.appendingPathComponent("outside.bin")
+        try Data(repeating: 3, count: 100).write(to: target)
+        let link = root.appendingPathComponent("linked.bin")
+        try FileManager.default.createSymbolicLink(at: link, withDestinationURL: target)
+
+        let footprint = ProviderStorageScanner().scan(provider: .codex, candidatePaths: [root.path])
+
+        #expect(footprint.totalBytes == 12)
+        #expect(footprint.paths == [root.path])
+        #expect(footprint.missingPaths.isEmpty)
+        #expect(footprint.components.map(\.name) == ["nested", "a.jsonl"])
+        #expect(footprint.components.map(\.totalBytes) == [7, 5])
+    }
+
+    @Test
+    func `scanner does not follow symlinked candidate roots`() throws {
+        let root = try Self.makeTemporaryDirectory()
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let target = root.appendingPathComponent("target", isDirectory: true)
+        try FileManager.default.createDirectory(at: target, withIntermediateDirectories: true)
+        try Data(repeating: 1, count: 64).write(to: target.appendingPathComponent("session.jsonl"))
+        let symlinkRoot = root.appendingPathComponent("codex-link", isDirectory: true)
+        try FileManager.default.createSymbolicLink(at: symlinkRoot, withDestinationURL: target)
+
+        let footprint = ProviderStorageScanner().scan(provider: .codex, candidatePaths: [symlinkRoot.path])
+
+        #expect(footprint.paths == [symlinkRoot.path])
+        #expect(footprint.totalBytes == 0)
+        #expect(footprint.components.isEmpty)
+    }
+
+    @Test
+    func `scanner records missing paths without failing`() throws {
+        let root = try Self.makeTemporaryDirectory()
+        let missing = root.appendingPathComponent("missing")
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let footprint = ProviderStorageScanner().scan(provider: .claude, candidatePaths: [missing.path])
+
+        #expect(footprint.totalBytes == 0)
+        #expect(footprint.paths.isEmpty)
+        #expect(footprint.missingPaths == [missing.path])
+    }
+
+    @Test
+    func `codex path catalog uses CODEX_HOME and managed homes`() {
+        let managed = ManagedCodexAccount(
+            id: UUID(),
+            email: "user@example.com",
+            managedHomePath: "/tmp/codex-managed-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: nil)
+
+        let paths = ProviderStoragePathCatalog.candidatePaths(
+            for: .codex,
+            environment: ["CODEX_HOME": "/tmp/codex-home"],
+            managedCodexAccounts: [managed])
+
+        #expect(paths == ["/tmp/codex-home", "/tmp/codex-managed-home"])
+    }
+
+    @Test
+    func `codex path catalog falls back to default home`() {
+        let paths = ProviderStoragePathCatalog.candidatePaths(for: .codex, environment: [:])
+        let expected = FileManager.default.homeDirectoryForCurrentUser
+            .appendingPathComponent(".codex", isDirectory: true)
+            .path
+
+        #expect(paths.first == expected)
+    }
+
+    @Test
+    func `cursor path catalog includes application data and caches`() {
+        let home = FileManager.default.homeDirectoryForCurrentUser
+        let paths = ProviderStoragePathCatalog.candidatePaths(for: .cursor, environment: [:])
+
+        #expect(paths == [
+            home.appendingPathComponent("Library/Application Support/Cursor", isDirectory: true).path,
+            home.appendingPathComponent(
+                "Library/Application Support/Caches/cursor-updater",
+                isDirectory: true).path,
+            home.appendingPathComponent(".cursor", isDirectory: true).path,
+            home.appendingPathComponent("Library/Caches/Cursor", isDirectory: true).path,
+            home.appendingPathComponent("Library/Caches/com.todesktop.230313mzl4w4u92", isDirectory: true).path,
+            home.appendingPathComponent("Library/Caches/com.todesktop.230313mzl4w4u92.ShipIt", isDirectory: true).path,
+            home.appendingPathComponent("Library/Caches/cursor-compile-cache", isDirectory: true).path,
+            home.appendingPathComponent(
+                "Library/HTTPStorages/com.todesktop.230313mzl4w4u92",
+                isDirectory: true).path,
+        ])
+    }
+
+    @Test
+    func `claude recommendations use documented cleanup categories`() {
+        let root = "/Users/test/.claude"
+        let footprint = ProviderStorageFootprint(
+            provider: .claude,
+            totalBytes: 28,
+            paths: [root],
+            missingPaths: [],
+            unreadablePaths: [],
+            components: [
+                .init(path: "\(root)/projects", totalBytes: 10),
+                .init(path: "\(root)/file-history", totalBytes: 8),
+                .init(path: "\(root)/paste-cache", totalBytes: 6),
+                .init(path: "\(root)/settings.json", totalBytes: 4),
+            ],
+            updatedAt: Date(timeIntervalSince1970: 0))
+
+        let recommendations = footprint.cleanupRecommendations
+
+        #expect(recommendations.map(\.path) == [
+            "\(root)/projects",
+            "\(root)/file-history",
+            "\(root)/paste-cache",
+        ])
+        #expect(recommendations[0].consequence.contains("resume"))
+        #expect(recommendations.allSatisfy { $0.riskLevel == .manualCleanup })
+    }
+
+    @Test
+    func `codex recommendations stay under known homes and exclude auth and config`() {
+        let root = "/Users/test/.codex"
+        let footprint = ProviderStorageFootprint(
+            provider: .codex,
+            totalBytes: 51,
+            paths: [root],
+            missingPaths: [],
+            unreadablePaths: [],
+            components: [
+                .init(path: "\(root)/sessions", totalBytes: 20),
+                .init(path: "\(root)/archived_sessions", totalBytes: 15),
+                .init(path: "\(root)/log", totalBytes: 12),
+                .init(path: "\(root)/logs_2.sqlite", totalBytes: 11),
+                .init(path: "\(root)/cache", totalBytes: 10),
+                .init(path: "\(root)/shell_snapshots", totalBytes: 9),
+                .init(path: "\(root)/auth.json", totalBytes: 4),
+                .init(path: "\(root)/config.toml", totalBytes: 2),
+                .init(path: "/tmp/outside/sessions", totalBytes: 99),
+            ],
+            updatedAt: Date(timeIntervalSince1970: 0))
+
+        let recommendations = footprint.cleanupRecommendations
+
+        #expect(recommendations.map(\.path) == [
+            "\(root)/sessions",
+            "\(root)/archived_sessions",
+            "\(root)/cache",
+            "\(root)/log",
+            "\(root)/logs_2.sqlite",
+            "\(root)/shell_snapshots",
+        ])
+        #expect(recommendations.map(\.bytes) == [20, 15, 10, 12, 11, 9])
+    }
+
+    @Test
+    func `unknown provider storage returns no cleanup recommendations`() {
+        let footprint = ProviderStorageFootprint(
+            provider: .gemini,
+            totalBytes: 10,
+            paths: ["/Users/test/.gemini"],
+            missingPaths: [],
+            unreadablePaths: [],
+            components: [
+                .init(path: "/Users/test/.gemini/cache", totalBytes: 10),
+            ],
+            updatedAt: Date(timeIntervalSince1970: 0))
+
+        #expect(footprint.cleanupRecommendations.isEmpty)
+    }
+
+    @Test
+    @MainActor
+    func `overview row carries storage text outside provider detail model`() throws {
+        let now = Date()
+        let metadata = try #require(ProviderDefaults.metadata[.claude])
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 25,
+                windowMinutes: nil,
+                resetsAt: now.addingTimeInterval(3600),
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: now,
+            identity: nil)
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .claude,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        let overview = OverviewMenuCardRowView(model: model, storageText: "1.5 GB", width: 310)
+        let detail = UsageMenuCardView(model: model, width: 310)
+
+        #expect(overview.storageText == "1.5 GB")
+        #expect(detail.model.provider == UsageProvider.claude)
+    }
+
+    @Test
+    @MainActor
+    func `storage detail view exposes cleanup recommendations while overview remains number only`() throws {
+        let root = "/Users/test/.claude"
+        let footprint = ProviderStorageFootprint(
+            provider: .claude,
+            totalBytes: 10,
+            paths: [root],
+            missingPaths: [],
+            unreadablePaths: [],
+            components: [
+                .init(path: "\(root)/projects", totalBytes: 10),
+            ],
+            updatedAt: Date(timeIntervalSince1970: 0))
+        let detailView = StorageBreakdownMenuView(footprint: footprint, width: 310)
+        let metadata = try #require(ProviderDefaults.metadata[.claude])
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .claude,
+            metadata: metadata,
+            snapshot: nil,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: Date(timeIntervalSince1970: 0)))
+        let overview = OverviewMenuCardRowView(model: model, storageText: "10 B", width: 310)
+
+        #expect(detailView.cleanupRecommendations.map(\.path) == ["\(root)/projects"])
+        #expect(overview.storageText == "10 B")
+    }
+
+    @Test
+    @MainActor
+    func `storage detail view exposes copyable exact paths`() {
+        let root = "/Users/test/.claude"
+        let footprint = ProviderStorageFootprint(
+            provider: .claude,
+            totalBytes: 110,
+            paths: [root],
+            missingPaths: [],
+            unreadablePaths: [],
+            components: [
+                .init(path: "\(root)/projects", totalBytes: 100),
+                .init(path: "\(root)/file-history", totalBytes: 10),
+            ],
+            updatedAt: Date(timeIntervalSince1970: 0))
+        let detailView = StorageBreakdownMenuView(footprint: footprint, width: 310)
+
+        #expect(detailView.copyablePaths.contains("\(root)/projects"))
+        #expect(detailView.copyablePaths.contains("\(root)/file-history"))
+    }
+
+    @Test
+    @MainActor
+    func `manual storage refresh updates deleted provider data`() async throws {
+        let home = try Self.makeTemporaryDirectory()
+        defer { try? FileManager.default.removeItem(at: home) }
+
+        let codexHome = home.appendingPathComponent(".codex", isDirectory: true)
+        let sessions = codexHome.appendingPathComponent("sessions", isDirectory: true)
+        try FileManager.default.createDirectory(at: sessions, withIntermediateDirectories: true)
+        try Data(repeating: 1, count: 32).write(to: sessions.appendingPathComponent("session.jsonl"))
+
+        let suite = "ProviderStorageFootprintTests-storage-refresh-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        if let codexMetadata = ProviderDefaults.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMetadata, enabled: true)
+        }
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            environmentBase: ["CODEX_HOME": codexHome.path])
+        settings.providerStorageFootprintsEnabled = true
+        store.managedCodexAccountsForStorageOverride = []
+
+        await store.refreshStorageFootprintsForOverviewNow()
+        #expect(store.storageFootprint(for: .codex)?.totalBytes == 32)
+
+        try FileManager.default.removeItem(at: sessions)
+        await store.refreshStorageFootprintsForOverviewNow()
+
+        #expect(store.storageFootprint(for: .codex)?.totalBytes == 0)
+        #expect(store.storageFootprintText(for: .codex) == "No local data found")
+    }
+
+    @Test
+    @MainActor
+    func `repeated identical storage refresh does not republish observable footprints`() async throws {
+        let home = try Self.makeTemporaryDirectory()
+        defer { try? FileManager.default.removeItem(at: home) }
+
+        let codexHome = home.appendingPathComponent(".codex", isDirectory: true)
+        let sessions = codexHome.appendingPathComponent("sessions", isDirectory: true)
+        try FileManager.default.createDirectory(at: sessions, withIntermediateDirectories: true)
+        try Data(repeating: 1, count: 32).write(to: sessions.appendingPathComponent("session.jsonl"))
+
+        let suite = "ProviderStorageFootprintTests-identity-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        if let codexMetadata = ProviderDefaults.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMetadata, enabled: true)
+        }
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            environmentBase: ["CODEX_HOME": codexHome.path])
+        settings.providerStorageFootprintsEnabled = true
+        store.managedCodexAccountsForStorageOverride = []
+
+        await store.refreshStorageFootprintsNow(for: [.codex])
+        #expect(store.storageFootprint(for: .codex)?.totalBytes == 32)
+
+        // A second scan over identical on-disk data must not re-assign the observable property.
+        // Storage scans run on every menu open and every ~5 min; an unconditional re-publish wakes
+        // the controller's `menuObservationToken` -> `invalidateMenus` path for no value change.
+        let didRepublish = ObservationFlag()
+        withObservationTracking {
+            _ = store.providerStorageFootprints
+        } onChange: {
+            didRepublish.set()
+        }
+        await store.refreshStorageFootprintsNow(for: [.codex])
+        try? await Task.sleep(for: .milliseconds(50))
+
+        #expect(didRepublish.get() == false)
+        #expect(store.storageFootprint(for: .codex)?.totalBytes == 32)
+    }
+
+    @Test
+    @MainActor
+    func `storage refresh is opt in and clears stale footprints when disabled`() async throws {
+        let home = try Self.makeTemporaryDirectory()
+        defer { try? FileManager.default.removeItem(at: home) }
+
+        let codexHome = home.appendingPathComponent(".codex", isDirectory: true)
+        try FileManager.default.createDirectory(at: codexHome, withIntermediateDirectories: true)
+        try Data(repeating: 1, count: 16).write(to: codexHome.appendingPathComponent("session.jsonl"))
+
+        let suite = "ProviderStorageFootprintTests-storage-opt-in-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        if let codexMetadata = ProviderDefaults.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMetadata, enabled: true)
+        }
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            environmentBase: ["CODEX_HOME": codexHome.path])
+        store.managedCodexAccountsForStorageOverride = []
+
+        await store.refreshStorageFootprintsForOverviewNow()
+        #expect(store.storageFootprint(for: .codex) == nil)
+
+        settings.providerStorageFootprintsEnabled = true
+        await store.refreshStorageFootprintsForOverviewNow()
+        #expect(store.storageFootprint(for: .codex)?.totalBytes == 16)
+
+        settings.providerStorageFootprintsEnabled = false
+        await store.refreshStorageFootprintsForOverviewNow()
+        #expect(store.storageFootprint(for: .codex) == nil)
+        #expect(store.providerStorageFootprints.isEmpty)
+    }
+
+    @Test
+    @MainActor
+    func `forced scheduled storage refresh does not restart identical in flight scan`() throws {
+        let home = try Self.makeTemporaryDirectory()
+        defer { try? FileManager.default.removeItem(at: home) }
+
+        let codexHome = home.appendingPathComponent(".codex", isDirectory: true)
+        try FileManager.default.createDirectory(at: codexHome, withIntermediateDirectories: true)
+
+        let suite = "ProviderStorageFootprintTests-storage-in-flight-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            environmentBase: ["CODEX_HOME": codexHome.path])
+        settings.providerStorageFootprintsEnabled = true
+        store.storageRefreshGeneration = 41
+        store.storageRefreshInFlightSignature = "codex=\(codexHome.path)"
+        store.storageRefreshTask = Task.detached {
+            try? await Task.sleep(for: .seconds(30))
+        }
+        defer {
+            store.storageRefreshTask?.cancel()
+            store.storageRefreshTask = nil
+            store.storageRefreshInFlightSignature = nil
+        }
+
+        store.scheduleStorageFootprintRefresh(for: [.codex], force: true)
+
+        #expect(store.storageRefreshGeneration == 41)
+    }
+
+    @Test
+    @MainActor
+    func `scheduled storage refresh notices managed Codex home changes`() async throws {
+        let home = try Self.makeTemporaryDirectory()
+        defer { try? FileManager.default.removeItem(at: home) }
+
+        let ambientHome = home.appendingPathComponent("ambient", isDirectory: true)
+        let firstManagedHome = home.appendingPathComponent("managed-a", isDirectory: true)
+        let secondManagedHome = home.appendingPathComponent("managed-b", isDirectory: true)
+        try FileManager.default.createDirectory(at: ambientHome, withIntermediateDirectories: true)
+        try FileManager.default.createDirectory(at: firstManagedHome, withIntermediateDirectories: true)
+        try FileManager.default.createDirectory(at: secondManagedHome, withIntermediateDirectories: true)
+        try Data(repeating: 1, count: 16).write(to: firstManagedHome.appendingPathComponent("session.jsonl"))
+        try Data(repeating: 2, count: 32).write(to: secondManagedHome.appendingPathComponent("session.jsonl"))
+
+        let suite = "ProviderStorageFootprintTests-managed-refresh-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        if let codexMetadata = ProviderDefaults.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMetadata, enabled: true)
+        }
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            environmentBase: ["CODEX_HOME": ambientHome.path])
+        settings.providerStorageFootprintsEnabled = true
+        store.managedCodexAccountsForStorageOverride = [
+            Self.managedCodexAccount(homePath: firstManagedHome.path),
+        ]
+
+        store.scheduleStorageFootprintRefresh(for: [.codex])
+        for _ in 0..<100 where store.isStorageRefreshInFlight {
+            try await Task.sleep(for: .milliseconds(10))
+        }
+        #expect(store.storageFootprint(for: .codex)?.totalBytes == 16)
+
+        store.managedCodexAccountsForStorageOverride = [
+            Self.managedCodexAccount(homePath: secondManagedHome.path),
+        ]
+        store.scheduleStorageFootprintRefresh(for: [.codex])
+        for _ in 0..<100 where store.isStorageRefreshInFlight {
+            try await Task.sleep(for: .milliseconds(10))
+        }
+
+        #expect(store.storageFootprint(for: .codex)?.totalBytes == 32)
+    }
+
+    private static func managedCodexAccount(homePath: String) -> ManagedCodexAccount {
+        ManagedCodexAccount(
+            id: UUID(),
+            email: "storage@example.com",
+            managedHomePath: homePath,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: nil)
+    }
+
+    private static func makeTemporaryDirectory() throws -> URL {
+        let url = FileManager.default.temporaryDirectory
+            .appendingPathComponent("ProviderStorageFootprintTests-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: url, withIntermediateDirectories: true)
+        return url
+    }
+}
diff --git a/Tests/CodexBarTests/ProviderSwitcherEventPeekGateTests.swift b/Tests/CodexBarTests/ProviderSwitcherEventPeekGateTests.swift
new file mode 100644
index 0000000000..27cc01113c
--- /dev/null
+++ b/Tests/CodexBarTests/ProviderSwitcherEventPeekGateTests.swift
@@ -0,0 +1,149 @@
+import AppKit
+import CoreGraphics
+import Testing
+@testable import CodexBar
+
+@MainActor
+struct ProviderSwitcherEventPeekGateTests {
+    @Test
+    func `first check always peeks`() {
+        let gate = ProviderSwitcherEventPeekGate(eventTypes: [.keyDown], counterProvider: { _ in 7 })
+        #expect(gate.shouldPeek())
+    }
+
+    @Test
+    func `unchanged counters skip the peek`() {
+        let gate = ProviderSwitcherEventPeekGate(eventTypes: [.keyDown, .leftMouseDown], counterProvider: { _ in 7 })
+        #expect(gate.shouldPeek())
+        gate.observeQueueEmpty(afterFindingEvent: false)
+        #expect(gate.shouldPeek())
+        gate.observeQueueEmpty(afterFindingEvent: false)
+        #expect(!gate.shouldPeek())
+        #expect(!gate.shouldPeek())
+    }
+
+    @Test
+    func `any advanced counter re-enables the peek`() {
+        var keyDownCount: UInt32 = 1
+        let gate = ProviderSwitcherEventPeekGate(
+            eventTypes: [.keyDown, .leftMouseDown],
+            counterProvider: { type in type == .keyDown ? keyDownCount : 3 })
+        #expect(gate.shouldPeek())
+        gate.observeQueueEmpty(afterFindingEvent: false)
+        #expect(gate.shouldPeek())
+        gate.observeQueueEmpty(afterFindingEvent: false)
+        #expect(!gate.shouldPeek())
+        keyDownCount += 1
+        #expect(gate.shouldPeek())
+        gate.observeQueueEmpty(afterFindingEvent: false)
+        #expect(gate.shouldPeek())
+        gate.observeQueueEmpty(afterFindingEvent: false)
+        #expect(!gate.shouldPeek())
+    }
+
+    @Test
+    func `counter change keeps one follow up peek for AppKit queue delivery`() {
+        var keyDownCount: UInt32 = 1
+        let gate = ProviderSwitcherEventPeekGate(
+            eventTypes: [.keyDown],
+            counterProvider: { _ in keyDownCount })
+        #expect(gate.shouldPeek())
+        gate.observeQueueEmpty(afterFindingEvent: false)
+        #expect(gate.shouldPeek())
+        gate.observeQueueEmpty(afterFindingEvent: false)
+        #expect(!gate.shouldPeek())
+
+        keyDownCount += 1
+        #expect(gate.shouldPeek())
+        gate.observeQueueEmpty(afterFindingEvent: false)
+        #expect(gate.shouldPeek())
+        gate.observeQueueEmpty(afterFindingEvent: false)
+        #expect(!gate.shouldPeek())
+    }
+
+    @Test
+    func `queued unhandled event burst keeps peeking until the queue is empty`() throws {
+        var eventCount: UInt32 = 1
+        let gate = ProviderSwitcherEventPeekGate(
+            eventTypes: [.keyUp],
+            counterProvider: { _ in eventCount })
+        #expect(gate.shouldPeek())
+        gate.observeQueueEmpty(afterFindingEvent: false)
+        #expect(gate.shouldPeek())
+        gate.observeQueueEmpty(afterFindingEvent: false)
+        #expect(!gate.shouldPeek())
+
+        eventCount += 3
+        #expect(gate.shouldPeek())
+        try gate.observe(Self.keyEvent(type: .keyUp, keyCode: 124))
+        #expect(gate.shouldPeek())
+        try gate.observe(Self.keyEvent(type: .keyUp, keyCode: 124))
+        #expect(gate.shouldPeek())
+        try gate.observe(Self.keyEvent(type: .keyUp, keyCode: 124))
+        #expect(gate.shouldPeek())
+
+        gate.observeQueueEmpty(afterFindingEvent: false)
+        #expect(gate.shouldPeek())
+        gate.observeQueueEmpty(afterFindingEvent: false)
+        #expect(!gate.shouldPeek())
+    }
+
+    @Test
+    func `handled event keeps peeking for delayed sibling from same counter snapshot`() throws {
+        var eventCount: UInt32 = 1
+        let gate = ProviderSwitcherEventPeekGate(
+            eventTypes: [.keyUp],
+            counterProvider: { _ in eventCount })
+        #expect(gate.shouldPeek())
+        gate.observeQueueEmpty(afterFindingEvent: false)
+        #expect(gate.shouldPeek())
+        gate.observeQueueEmpty(afterFindingEvent: false)
+        #expect(!gate.shouldPeek())
+
+        eventCount += 2
+        #expect(gate.shouldPeek())
+        try gate.observe(Self.keyEvent(type: .keyUp, keyCode: 124))
+        gate.observeQueueEmpty(afterFindingEvent: true)
+
+        #expect(gate.shouldPeek())
+        try gate.observe(Self.keyEvent(type: .keyUp, keyCode: 124))
+        gate.observeQueueEmpty(afterFindingEvent: true)
+
+        #expect(gate.shouldPeek())
+        gate.observeQueueEmpty(afterFindingEvent: false)
+        #expect(!gate.shouldPeek())
+    }
+
+    @Test
+    func `held key keeps peeking for uncounted autorepeat events`() throws {
+        let gate = ProviderSwitcherEventPeekGate(eventTypes: [.keyDown, .keyUp], counterProvider: { _ in 7 })
+        #expect(gate.shouldPeek())
+        gate.observeQueueEmpty(afterFindingEvent: false)
+        #expect(gate.shouldPeek())
+        gate.observeQueueEmpty(afterFindingEvent: false)
+        #expect(!gate.shouldPeek())
+
+        try gate.observe(Self.keyEvent(type: .keyDown, keyCode: 124))
+        #expect(gate.shouldPeek())
+        #expect(gate.shouldPeek())
+
+        try gate.observe(Self.keyEvent(type: .keyUp, keyCode: 124))
+        #expect(gate.shouldPeek())
+        gate.observeQueueEmpty(afterFindingEvent: false)
+        #expect(!gate.shouldPeek())
+    }
+
+    private static func keyEvent(type: NSEvent.EventType, keyCode: UInt16) throws -> NSEvent {
+        try #require(NSEvent.keyEvent(
+            with: type,
+            location: .zero,
+            modifierFlags: [],
+            timestamp: 0,
+            windowNumber: 0,
+            context: nil,
+            characters: "",
+            charactersIgnoringModifiers: "",
+            isARepeat: false,
+            keyCode: keyCode))
+    }
+}
diff --git a/Tests/CodexBarTests/ProviderToggleStoreTests.swift b/Tests/CodexBarTests/ProviderToggleStoreTests.swift
index 6de1adfd78..ce4f812af4 100644
--- a/Tests/CodexBarTests/ProviderToggleStoreTests.swift
+++ b/Tests/CodexBarTests/ProviderToggleStoreTests.swift
@@ -3,10 +3,9 @@ import Testing
 @testable import CodexBar
 
 @MainActor
-@Suite
 struct ProviderToggleStoreTests {
     @Test
-    func defaultsMatchMetadata() throws {
+    func `defaults match metadata`() throws {
         let defaults = try #require(UserDefaults(suiteName: "ProviderToggleStoreTests-defaults"))
         defaults.removePersistentDomain(forName: "ProviderToggleStoreTests-defaults")
         let store = ProviderToggleStore(userDefaults: defaults)
@@ -19,7 +18,7 @@ struct ProviderToggleStoreTests {
     }
 
     @Test
-    func persistsChanges() throws {
+    func `persists changes`() throws {
         let suite = "ProviderToggleStoreTests-persist"
         let defaultsA = try #require(UserDefaults(suiteName: suite))
         defaultsA.removePersistentDomain(forName: suite)
@@ -35,7 +34,7 @@ struct ProviderToggleStoreTests {
     }
 
     @Test
-    func purgesLegacyKeys() throws {
+    func `purges legacy keys`() throws {
         let suite = "ProviderToggleStoreTests-purge"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
diff --git a/Tests/CodexBarTests/ProviderTokenResolverTests.swift b/Tests/CodexBarTests/ProviderTokenResolverTests.swift
index fcfc5bd74f..e7887cd795 100644
--- a/Tests/CodexBarTests/ProviderTokenResolverTests.swift
+++ b/Tests/CodexBarTests/ProviderTokenResolverTests.swift
@@ -2,10 +2,9 @@ import CodexBarCore
 import Foundation
 import Testing
 
-@Suite
 struct ProviderTokenResolverTests {
     @Test
-    func zaiResolutionUsesEnvironmentToken() {
+    func `zai resolution uses environment token`() {
         let env = [ZaiSettingsReader.apiTokenKey: "token"]
         let resolution = ProviderTokenResolver.zaiResolution(environment: env)
         #expect(resolution?.token == "token")
@@ -13,14 +12,14 @@ struct ProviderTokenResolverTests {
     }
 
     @Test
-    func copilotResolutionTrimsToken() {
+    func `copilot resolution trims token`() {
         let env = ["COPILOT_API_TOKEN": "  token  "]
         let resolution = ProviderTokenResolver.copilotResolution(environment: env)
         #expect(resolution?.token == "token")
     }
 
     @Test
-    func warpResolutionUsesEnvironmentToken() {
+    func `warp resolution uses environment token`() {
         let env = ["WARP_API_KEY": "wk-test-token"]
         let resolution = ProviderTokenResolver.warpResolution(environment: env)
         #expect(resolution?.token == "wk-test-token")
@@ -28,21 +27,35 @@ struct ProviderTokenResolverTests {
     }
 
     @Test
-    func warpResolutionTrimsToken() {
+    func `warp resolution trims token`() {
         let env = ["WARP_API_KEY": "  wk-token  "]
         let resolution = ProviderTokenResolver.warpResolution(environment: env)
         #expect(resolution?.token == "wk-token")
     }
 
     @Test
-    func warpResolutionReturnsNilWhenMissing() {
+    func `warp resolution returns nil when missing`() {
         let env: [String: String] = [:]
         let resolution = ProviderTokenResolver.warpResolution(environment: env)
         #expect(resolution == nil)
     }
 
     @Test
-    func kiloResolutionPrefersEnvironmentOverAuthFile() throws {
+    func `doubao resolution uses first supported environment token`() {
+        let env = ["ARK_API_KEY": "ark-token"]
+        let resolution = ProviderTokenResolver.doubaoResolution(environment: env)
+        #expect(resolution?.token == "ark-token")
+        #expect(resolution?.source == .environment)
+    }
+
+    @Test
+    func `doubao settings reader trims quoted token`() {
+        let env = ["DOUBAO_API_KEY": " 'doubao-token' "]
+        #expect(DoubaoSettingsReader.apiKey(environment: env) == "doubao-token")
+    }
+
+    @Test
+    func `kilo resolution prefers environment over auth file`() throws {
         let fileURL = try self.makeKiloAuthFile(contents: #"{"kilo":{"access":"file-token"}}"#)
         defer { try? FileManager.default.removeItem(at: fileURL.deletingLastPathComponent()) }
 
@@ -54,7 +67,7 @@ struct ProviderTokenResolverTests {
     }
 
     @Test
-    func kiloResolutionFallsBackToAuthFile() throws {
+    func `kilo resolution falls back to auth file`() throws {
         let fileURL = try self.makeKiloAuthFile(contents: #"{"kilo":{"access":"file-token"}}"#)
         defer { try? FileManager.default.removeItem(at: fileURL.deletingLastPathComponent()) }
 
@@ -65,7 +78,7 @@ struct ProviderTokenResolverTests {
     }
 
     @Test
-    func kiloResolutionReturnsNilForMalformedAuthFile() throws {
+    func `kilo resolution returns nil for malformed auth file`() throws {
         let fileURL = try self.makeKiloAuthFile(contents: #"{not-json}"#)
         defer { try? FileManager.default.removeItem(at: fileURL.deletingLastPathComponent()) }
 
@@ -81,4 +94,61 @@ struct ProviderTokenResolverTests {
         try contents.write(to: fileURL, atomically: true, encoding: .utf8)
         return fileURL
     }
+
+    @Test
+    func `codebuff resolution prefers environment over credentials file`() throws {
+        let fileURL = try self.makeCodebuffCredentialsFile(
+            contents: #"{"authToken":"file-token"}"#)
+        defer { try? FileManager.default.removeItem(at: fileURL.deletingLastPathComponent()) }
+
+        let env = [CodebuffSettingsReader.apiTokenKey: "env-token"]
+        let resolution = ProviderTokenResolver.codebuffResolution(
+            environment: env,
+            authFileURL: fileURL)
+
+        #expect(resolution?.token == "env-token")
+        #expect(resolution?.source == .environment)
+    }
+
+    @Test
+    func `codebuff resolution falls back to credentials file`() throws {
+        let fileURL = try self.makeCodebuffCredentialsFile(
+            contents: #"{"authToken":"file-token","fingerprintId":"fp"}"#)
+        defer { try? FileManager.default.removeItem(at: fileURL.deletingLastPathComponent()) }
+
+        let resolution = ProviderTokenResolver.codebuffResolution(
+            environment: [:],
+            authFileURL: fileURL)
+
+        #expect(resolution?.token == "file-token")
+        #expect(resolution?.source == .authFile)
+    }
+
+    @Test
+    func `codebuff resolution returns nil for malformed credentials file`() throws {
+        let fileURL = try self.makeCodebuffCredentialsFile(contents: #"{not-json}"#)
+        defer { try? FileManager.default.removeItem(at: fileURL.deletingLastPathComponent()) }
+
+        let resolution = ProviderTokenResolver.codebuffResolution(
+            environment: [:],
+            authFileURL: fileURL)
+        #expect(resolution == nil)
+    }
+
+    @Test
+    func `poe resolution uses manual api key`() {
+        let env = [PoeSettingsReader.apiKeyEnvironmentKey: "manual-key"]
+        let resolution = ProviderTokenResolver.poeResolution(environment: env)
+        #expect(resolution?.token == "manual-key")
+        #expect(resolution?.source == .environment)
+    }
+
+    private func makeCodebuffCredentialsFile(contents: String) throws -> URL {
+        let directory = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+        let fileURL = directory.appendingPathComponent("credentials.json", isDirectory: false)
+        try contents.write(to: fileURL, atomically: true, encoding: .utf8)
+        return fileURL
+    }
 }
diff --git a/Tests/CodexBarTests/ProviderVersionDetectorTests.swift b/Tests/CodexBarTests/ProviderVersionDetectorTests.swift
new file mode 100644
index 0000000000..320a4e4a2e
--- /dev/null
+++ b/Tests/CodexBarTests/ProviderVersionDetectorTests.swift
@@ -0,0 +1,70 @@
+import XCTest
+@testable import CodexBarCore
+
+#if canImport(Darwin)
+import Darwin
+#else
+import Glibc
+#endif
+
+final class ProviderVersionDetectorTests: XCTestCase {
+    func test_run_returnsFirstLineForSuccessfulCommand() {
+        let version = ProviderVersionDetector.run(
+            path: "/bin/sh",
+            args: ["-c", "printf 'gemini 1.2.3\\nextra\\n'"],
+            timeout: 1.0)
+
+        XCTAssertEqual(version, "gemini 1.2.3")
+    }
+
+    func test_run_returnsNilAfterTimeout() {
+        let start = Date()
+        let version = ProviderVersionDetector.run(
+            path: "/bin/sh",
+            args: ["-c", "sleep 5"],
+            timeout: 0.1)
+        let duration = Date().timeIntervalSince(start)
+
+        XCTAssertNil(version)
+        XCTAssertLessThan(duration, 2.0)
+    }
+
+    func test_run_returnsOutputWhenDetachedChildKeepsPipeOpen() throws {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-version-drain-\(UUID().uuidString)", isDirectory: true)
+        let childPIDFile = root.appendingPathComponent("child.pid")
+        try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+        defer {
+            if let text = try? String(contentsOf: childPIDFile, encoding: .utf8),
+               let childPID = pid_t(text.trimmingCharacters(in: .whitespacesAndNewlines))
+            {
+                _ = kill(childPID, SIGKILL)
+            }
+        }
+
+        var environment = ProcessInfo.processInfo.environment
+        environment["CODEXBAR_TEST_CHILD_PID_FILE"] = childPIDFile.path
+        let script = """
+        (trap '' HUP; sleep 5) &
+        child=$!
+        printf '%s' "$child" > "$CODEXBAR_TEST_CHILD_PID_FILE"
+        printf 'grok 1.2.3\\n'
+        """
+
+        let start = Date()
+        let version = ProviderVersionDetector.run(
+            path: "/bin/sh",
+            args: ["-c", script],
+            timeout: 1.0,
+            environment: environment)
+        let duration = Date().timeIntervalSince(start)
+
+        XCTAssertEqual(version, "grok 1.2.3")
+        XCTAssertLessThan(duration, 2.0)
+        let childPID = try XCTUnwrap(
+            pid_t(String(contentsOf: childPIDFile, encoding: .utf8)
+                .trimmingCharacters(in: .whitespacesAndNewlines)))
+        XCTAssertEqual(kill(childPID, 0), 0, "Descendant should still hold the inherited pipe open")
+    }
+}
diff --git a/Tests/CodexBarTests/ProvidersPaneCoverageTests.swift b/Tests/CodexBarTests/ProvidersPaneCoverageTests.swift
index e5ea668def..446aeef862 100644
--- a/Tests/CodexBarTests/ProvidersPaneCoverageTests.swift
+++ b/Tests/CodexBarTests/ProvidersPaneCoverageTests.swift
@@ -1,13 +1,14 @@
+import AppKit
 import CodexBarCore
 import Foundation
+import SwiftUI
 import Testing
 @testable import CodexBar
 
 @MainActor
-@Suite
 struct ProvidersPaneCoverageTests {
     @Test
-    func exercisesProvidersPaneViews() {
+    func `exercises providers pane views`() {
         let settings = Self.makeSettingsStore(suite: "ProvidersPaneCoverageTests")
         let store = Self.makeUsageStore(settings: settings)
 
@@ -15,36 +16,474 @@ struct ProvidersPaneCoverageTests {
     }
 
     @Test
-    func openRouterMenuBarMetricPicker_showsOnlyAutomaticAndPrimary() {
-        let settings = Self.makeSettingsStore(suite: "ProvidersPaneCoverageTests-openrouter-picker")
+    func `claude token account descriptor shows organization field`() throws {
+        let settings = Self.makeSettingsStore(suite: "ProvidersPaneCoverageTests-claude-org-field")
         let store = Self.makeUsageStore(settings: settings)
         let pane = ProvidersPane(settings: settings, store: store)
 
-        let picker = pane._test_menuBarMetricPicker(for: .openrouter)
-        #expect(picker?.options.map(\.id) == [
+        let claudeDescriptor = try #require(pane._test_tokenAccountDescriptor(for: .claude))
+        #expect(claudeDescriptor.showsOrganizationField)
+
+        let copilotDescriptor = try #require(pane._test_tokenAccountDescriptor(for: .copilot))
+        #expect(!copilotDescriptor.showsOrganizationField)
+    }
+
+    @Test
+    func `provider search filters display names and raw ids`() {
+        let providers: [UsageProvider] = [.codex, .claude, .openrouter, .deepseek]
+        let names: [UsageProvider: String] = [
+            .codex: "Codex",
+            .claude: "Claude",
+            .openrouter: "OpenRouter",
+            .deepseek: "DeepSeek",
+        ]
+
+        #expect(
+            ProvidersPane.filteredProviders(providers, query: "  ", displayName: { names[$0] ?? $0.rawValue })
+                == providers)
+        #expect(
+            ProvidersPane.filteredProviders(providers, query: "router", displayName: { names[$0] ?? $0.rawValue })
+                == [.openrouter])
+        #expect(
+            ProvidersPane.filteredProviders(providers, query: "CLA", displayName: { names[$0] ?? $0.rawValue })
+                == [.claude])
+        #expect(
+            ProvidersPane.filteredProviders(providers, query: "deepseek", displayName: { _ in "API" })
+                == [.deepseek])
+    }
+
+    @Test
+    func `provider reordering is inert while alphabetical sorting is enabled`() {
+        let settings = Self.makeSettingsStore(suite: "ProvidersPaneCoverageTests-sorted-reorder")
+        let store = Self.makeUsageStore(settings: settings)
+        let pane = ProvidersPane(settings: settings, store: store)
+        let original = settings.orderedProviders()
+
+        settings.providersSortedAlphabetically = true
+        pane._test_moveProviders(fromOffsets: IndexSet(integer: 0), toOffset: original.count)
+        #expect(settings.orderedProviders() == original)
+
+        settings.providersSortedAlphabetically = false
+        pane._test_moveProviders(fromOffsets: IndexSet(integer: 0), toOffset: original.count)
+        #expect(settings.orderedProviders().last == original.first)
+    }
+
+    @Test
+    func `selected provider sidebar palette uses contrasting selected text colors`() {
+        let palette = ProviderSidebarRowPalette(isSelected: true)
+
+        #expect(palette.primary.isEqual(NSColor.alternateSelectedControlTextColor))
+        #expect(palette.secondary.alphaComponent == 0.82)
+        #expect(palette.tertiary.alphaComponent == 0.65)
+    }
+
+    @Test
+    func `unselected provider sidebar palette uses standard label colors`() {
+        let palette = ProviderSidebarRowPalette(isSelected: false)
+
+        #expect(palette.primary.isEqual(NSColor.labelColor))
+        #expect(palette.secondary.isEqual(NSColor.secondaryLabelColor))
+        #expect(palette.tertiary.isEqual(NSColor.tertiaryLabelColor))
+    }
+
+    @Test
+    func `copilot menu card preview follows budget extras setting`() {
+        let settings = Self.makeSettingsStore(suite: "ProvidersPaneCoverageTests-copilot-budget-preview")
+        let store = Self.makeUsageStore(settings: settings)
+        let budgetTitle = "Budget - Copilot Agent Premium Requests"
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(usedPercent: 20, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                secondary: RateWindow(usedPercent: 30, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                extraRateWindows: [
+                    NamedRateWindow(
+                        id: "copilot-budget-agent",
+                        title: budgetTitle,
+                        window: RateWindow(
+                            usedPercent: 65,
+                            windowMinutes: nil,
+                            resetsAt: nil,
+                            resetDescription: nil)),
+                ],
+                updatedAt: Date()),
+            provider: .copilot)
+        let pane = ProvidersPane(settings: settings, store: store)
+
+        #expect(!pane._test_menuCardModel(for: .copilot).metrics.map(\.title).contains(budgetTitle))
+
+        settings.copilotBudgetExtrasEnabled = true
+        #expect(pane._test_menuCardModel(for: .copilot).metrics.map(\.title).contains(budgetTitle))
+    }
+
+    @Test
+    func `open router menu bar metric picker shows only automatic and primary`() {
+        Self.withEnglishLocalization {
+            let settings = Self.makeSettingsStore(suite: "ProvidersPaneCoverageTests-openrouter-picker")
+            let store = Self.makeUsageStore(settings: settings)
+            let pane = ProvidersPane(settings: settings, store: store)
+
+            let picker = pane._test_menuBarMetricPicker(for: .openrouter)
+            #expect(picker?.options.map(\.id) == [
+                MenuBarMetricPreference.automatic.rawValue,
+                MenuBarMetricPreference.primary.rawValue,
+            ])
+            #expect(picker?.options.map(\.title) == [
+                "Automatic",
+                "Primary (API key limit)",
+            ])
+        }
+    }
+
+    @Test
+    func `deepseek menu bar metric picker shows balance only copy`() {
+        Self.withEnglishLocalization {
+            let settings = Self.makeSettingsStore(suite: "ProvidersPaneCoverageTests-deepseek-picker")
+            let store = Self.makeUsageStore(settings: settings)
+            let pane = ProvidersPane(settings: settings, store: store)
+
+            let picker = pane._test_menuBarMetricPicker(for: .deepseek)
+            #expect(picker?.options.map(\.id) == [
+                MenuBarMetricPreference.automatic.rawValue,
+            ])
+            #expect(picker?.subtitle == "Shows the DeepSeek balance in the menu bar.")
+        }
+    }
+
+    @Test
+    func `moonshot menu bar metric picker shows balance only copy`() {
+        Self.withEnglishLocalization {
+            let settings = Self.makeSettingsStore(suite: "ProvidersPaneCoverageTests-moonshot-picker")
+            let store = Self.makeUsageStore(settings: settings)
+            let pane = ProvidersPane(settings: settings, store: store)
+
+            let picker = pane._test_menuBarMetricPicker(for: .moonshot)
+            #expect(picker?.options.map(\.id) == [
+                MenuBarMetricPreference.automatic.rawValue,
+            ])
+            #expect(picker?.subtitle == "Shows the Moonshot / Kimi API balance in the menu bar.")
+        }
+    }
+
+    @Test
+    func `mistral menu bar metric picker shows payg and monthly plan options`() {
+        Self.withEnglishLocalization {
+            let settings = Self.makeSettingsStore(suite: "ProvidersPaneCoverageTests-mistral-picker")
+            let store = Self.makeUsageStore(settings: settings)
+            let pane = ProvidersPane(settings: settings, store: store)
+
+            let picker = pane._test_menuBarMetricPicker(for: .mistral)
+            #expect(picker?.options.map(\.id) == [
+                MenuBarMetricPreference.automatic.rawValue,
+                MenuBarMetricPreference.monthlyPlan.rawValue,
+            ])
+            #expect(picker?.options.first?.title == "Pay-as-you-go")
+            #expect(picker?.options.last?.title == "Monthly Plan")
+            #expect(picker?.subtitle == "Shows current-month Mistral API spend in the menu bar.")
+        }
+    }
+
+    @Test
+    func `kimi k2 menu bar metric picker shows credits only copy`() {
+        Self.withEnglishLocalization {
+            let settings = Self.makeSettingsStore(suite: "ProvidersPaneCoverageTests-kimik2-picker")
+            let store = Self.makeUsageStore(settings: settings)
+            let pane = ProvidersPane(settings: settings, store: store)
+
+            let picker = pane._test_menuBarMetricPicker(for: .kimik2)
+            #expect(picker?.options.map(\.id) == [
+                MenuBarMetricPreference.automatic.rawValue,
+            ])
+            #expect(picker?.subtitle == "Shows Kimi K2 API-key credits in the menu bar.")
+        }
+    }
+
+    @Test
+    func `cursor menu bar metric picker omits tertiary api lane when snapshot has no api metric`() {
+        let settings = Self.makeSettingsStore(suite: "ProvidersPaneCoverageTests-cursor-no-tertiary-picker")
+        let store = Self.makeUsageStore(settings: settings)
+        let pane = ProvidersPane(settings: settings, store: store)
+
+        let picker = pane._test_menuBarMetricPicker(for: .cursor)
+        let ids = picker?.options.map(\.id) ?? []
+        #expect(!ids.contains(MenuBarMetricPreference.tertiary.rawValue))
+    }
+
+    @Test
+    func `cursor menu bar metric picker includes tertiary api lane when snapshot has api metric`() {
+        Self.withEnglishLocalization {
+            let settings = Self.makeSettingsStore(suite: "ProvidersPaneCoverageTests-cursor-tertiary-picker")
+            let store = Self.makeUsageStore(settings: settings)
+            store._setSnapshotForTesting(
+                UsageSnapshot(
+                    primary: RateWindow(usedPercent: 12, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                    secondary: RateWindow(usedPercent: 34, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                    tertiary: RateWindow(usedPercent: 56, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                    updatedAt: Date()),
+                provider: .cursor)
+            let pane = ProvidersPane(settings: settings, store: store)
+
+            let picker = pane._test_menuBarMetricPicker(for: .cursor)
+            let ids = picker?.options.map(\.id) ?? []
+            #expect(ids.contains(MenuBarMetricPreference.tertiary.rawValue))
+            let tertiaryOption = picker?.options.first { $0.id == MenuBarMetricPreference.tertiary.rawValue }
+            #expect(tertiaryOption?.title == "Tertiary (API)")
+        }
+    }
+
+    @Test
+    func `cursor menu bar metric picker omits extra usage when on demand budget is missing`() {
+        let settings = Self.makeSettingsStore(suite: "ProvidersPaneCoverageTests-cursor-no-extra-usage-picker")
+        let store = Self.makeUsageStore(settings: settings)
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(usedPercent: 12, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                secondary: RateWindow(usedPercent: 34, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                updatedAt: Date()),
+            provider: .cursor)
+        let pane = ProvidersPane(settings: settings, store: store)
+
+        let picker = pane._test_menuBarMetricPicker(for: .cursor)
+        let ids = picker?.options.map(\.id) ?? []
+        #expect(!ids.contains(MenuBarMetricPreference.extraUsage.rawValue))
+    }
+
+    @Test
+    func `cursor menu bar metric picker includes extra usage when on demand budget is available`() {
+        Self.withEnglishLocalization {
+            let settings = Self.makeSettingsStore(suite: "ProvidersPaneCoverageTests-cursor-extra-usage-picker")
+            let store = Self.makeUsageStore(settings: settings)
+            store._setSnapshotForTesting(
+                UsageSnapshot(
+                    primary: RateWindow(usedPercent: 12, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                    secondary: RateWindow(usedPercent: 34, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                    tertiary: RateWindow(usedPercent: 56, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                    providerCost: ProviderCostSnapshot(
+                        used: 15,
+                        limit: 100,
+                        currencyCode: "USD",
+                        updatedAt: Date()),
+                    updatedAt: Date()),
+                provider: .cursor)
+            let pane = ProvidersPane(settings: settings, store: store)
+
+            let picker = pane._test_menuBarMetricPicker(for: .cursor)
+            let ids = picker?.options.map(\.id) ?? []
+            #expect(ids.contains(MenuBarMetricPreference.extraUsage.rawValue))
+            let option = picker?.options.first { $0.id == MenuBarMetricPreference.extraUsage.rawValue }
+            #expect(option?.title == "Extra usage")
+        }
+    }
+
+    @Test
+    func `claude menu bar metric picker includes extra usage when spend limit is available`() {
+        let settings = Self.makeSettingsStore(suite: "ProvidersPaneCoverageTests-claude-extra-usage-picker")
+        let store = Self.makeUsageStore(settings: settings)
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: nil,
+                secondary: nil,
+                providerCost: ProviderCostSnapshot(
+                    used: 67.03,
+                    limit: 1000,
+                    currencyCode: "USD",
+                    period: "Spend limit",
+                    updatedAt: Date()),
+                updatedAt: Date()),
+            provider: .claude)
+        let pane = ProvidersPane(settings: settings, store: store)
+
+        let picker = pane._test_menuBarMetricPicker(for: .claude)
+        let ids = picker?.options.map(\.id) ?? []
+        #expect(ids.contains(MenuBarMetricPreference.extraUsage.rawValue))
+    }
+
+    @Test
+    func `zai menu bar metric picker omits tertiary lane when snapshot has no 5-hour metric`() {
+        let settings = Self.makeSettingsStore(suite: "ProvidersPaneCoverageTests-zai-no-tertiary-picker")
+        let store = Self.makeUsageStore(settings: settings)
+        let pane = ProvidersPane(settings: settings, store: store)
+
+        let picker = pane._test_menuBarMetricPicker(for: .zai)
+        let ids = picker?.options.map(\.id) ?? []
+        #expect(ids == [
             MenuBarMetricPreference.automatic.rawValue,
             MenuBarMetricPreference.primary.rawValue,
+            MenuBarMetricPreference.secondary.rawValue,
         ])
-        #expect(picker?.options.map(\.title) == [
-            "Automatic",
-            "Primary (API key limit)",
-        ])
     }
 
     @Test
-    func providerDetailPlanRow_formatsOpenRouterAsBalance() {
-        let row = ProviderDetailView.planRow(provider: .openrouter, planText: "Balance: $4.61")
+    func `zai menu bar metric picker includes tertiary 5-hour lane when snapshot has it`() {
+        Self.withEnglishLocalization {
+            let settings = Self.makeSettingsStore(suite: "ProvidersPaneCoverageTests-zai-tertiary-picker")
+            let store = Self.makeUsageStore(settings: settings)
+            store._setSnapshotForTesting(
+                UsageSnapshot(
+                    primary: RateWindow(usedPercent: 12, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+                    secondary: RateWindow(usedPercent: 34, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                    tertiary: RateWindow(usedPercent: 56, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+                    updatedAt: Date()),
+                provider: .zai)
+            let pane = ProvidersPane(settings: settings, store: store)
+
+            let picker = pane._test_menuBarMetricPicker(for: .zai)
+            let ids = picker?.options.map(\.id) ?? []
+            #expect(ids.contains(MenuBarMetricPreference.tertiary.rawValue))
+            let tertiaryOption = picker?.options.first { $0.id == MenuBarMetricPreference.tertiary.rawValue }
+            #expect(tertiaryOption?.title == "Tertiary (5-hour)")
+        }
+    }
+
+    @Test
+    func `gemini menu bar metric picker omits tertiary lane`() {
+        let settings = Self.makeSettingsStore(suite: "ProvidersPaneCoverageTests-gemini-no-tertiary-picker")
+        let store = Self.makeUsageStore(settings: settings)
+        let pane = ProvidersPane(settings: settings, store: store)
+
+        let picker = pane._test_menuBarMetricPicker(for: .gemini)
+        let ids = picker?.options.map(\.id) ?? []
+        #expect(!ids.contains(MenuBarMetricPreference.tertiary.rawValue))
+    }
+
+    @Test
+    func `provider detail plan row formats open router as balance`() {
+        Self.withEnglishLocalization {
+            let row = ProviderDetailView<EmptyView>.planRow(provider: .openrouter, planText: "Balance: $4.61")
+
+            #expect(row?.label == "Balance")
+            #expect(row?.value == "$4.61")
+        }
+    }
+
+    @Test
+    func `provider detail plan row formats moonshot as balance`() {
+        Self.withEnglishLocalization {
+            let row = ProviderDetailView<EmptyView>.planRow(provider: .moonshot, planText: "Balance: $49.58")
+
+            #expect(row?.label == "Balance")
+            #expect(row?.value == "$49.58")
+        }
+    }
+
+    @Test
+    func `provider detail plan row keeps plan label for non open router`() {
+        Self.withEnglishLocalization {
+            let row = ProviderDetailView<EmptyView>.planRow(provider: .codex, planText: "Pro")
+
+            #expect(row?.label == "Plan")
+            #expect(row?.value == "Pro")
+        }
+    }
+
+    @Test
+    func `provider detail renders metric status without progress`() {
+        let metric = UsageMenuCardView.Model.Metric(
+            id: "fixture",
+            title: "Example quota",
+            percent: 0,
+            percentStyle: .left,
+            statusText: "Unavailable",
+            resetText: nil,
+            detailText: nil,
+            detailLeftText: nil,
+            detailRightText: nil,
+            pacePercent: nil,
+            paceOnTop: false)
 
-        #expect(row?.label == "Balance")
-        #expect(row?.value == "$4.61")
+        #expect(ProviderDetailView<EmptyView>.metricInlinePresentation(metric) == .status("Unavailable"))
     }
 
     @Test
-    func providerDetailPlanRow_keepsPlanLabelForNonOpenRouter() {
-        let row = ProviderDetailView.planRow(provider: .codex, planText: "Pro")
+    func `provider detail renders ordinary metric progress`() {
+        let metric = UsageMenuCardView.Model.Metric(
+            id: "fixture",
+            title: "Example quota",
+            percent: 50,
+            percentStyle: .left,
+            resetText: nil,
+            detailText: nil,
+            detailLeftText: nil,
+            detailRightText: nil,
+            pacePercent: nil,
+            paceOnTop: false)
+
+        #expect(ProviderDetailView<EmptyView>.metricInlinePresentation(metric) == .progress)
+    }
+
+    @Test
+    func `opencode manual cookie source hides cached browser trailing text`() {
+        let settings = Self.makeSettingsStore(suite: "ProvidersPaneCoverageTests-opencode-manual")
+        let store = Self.makeUsageStore(settings: settings)
+        settings.opencodeCookieSource = .manual
+        CookieHeaderCache.store(provider: .opencode, cookieHeader: "auth=cache", sourceLabel: "Chrome")
+        defer { CookieHeaderCache.clear(provider: .opencode) }
+
+        let pane = ProvidersPane(settings: settings, store: store)
+        let picker = pane._test_settingsPickers(for: .opencode).first { $0.id == "opencode-cookie-source" }
 
-        #expect(row?.label == "Plan")
-        #expect(row?.value == "Pro")
+        #expect(picker?.dynamicSubtitle?() == "Paste a Cookie header captured from the billing page.")
+        #expect(picker?.trailingText?() == nil)
+    }
+
+    @Test
+    func `opencode go manual cookie source hides cached browser trailing text`() {
+        let settings = Self.makeSettingsStore(suite: "ProvidersPaneCoverageTests-opencodego-manual")
+        let store = Self.makeUsageStore(settings: settings)
+        settings.opencodegoCookieSource = .manual
+        CookieHeaderCache.store(provider: .opencodego, cookieHeader: "auth=cache", sourceLabel: "Chrome")
+        defer { CookieHeaderCache.clear(provider: .opencodego) }
+
+        let pane = ProvidersPane(settings: settings, store: store)
+        let picker = pane._test_settingsPickers(for: .opencodego).first { $0.id == "opencodego-cookie-source" }
+
+        #expect(picker?.dynamicSubtitle?() == "Paste a Cookie header captured from the billing page.")
+        #expect(picker?.trailingText?() == nil)
+    }
+
+    @Test
+    func `codex providers pane uses managed account fallback instead of ambient account`() throws {
+        let settings = Self.makeSettingsStore(suite: "ProvidersPaneCoverageTests-codex-managed-fallback")
+        let ambientHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        let managedHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        defer {
+            try? FileManager.default.removeItem(at: ambientHome)
+            try? FileManager.default.removeItem(at: managedHome)
+        }
+
+        try Self.writeCodexAuthFile(homeURL: ambientHome, email: "ambient@example.com", plan: "plus")
+        try Self.writeCodexAuthFile(homeURL: managedHome, email: "managed@example.com", plan: "enterprise")
+        let managedAccountID = UUID()
+        settings.codexActiveSource = .managedAccount(id: managedAccountID)
+        settings._test_activeManagedCodexAccount = ManagedCodexAccount(
+            id: managedAccountID,
+            email: "managed@example.com",
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: ["CODEX_HOME": ambientHome.path]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing)
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(usedPercent: 12, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+                secondary: RateWindow(usedPercent: 34, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+                updatedAt: Date(),
+                identity: nil),
+            provider: .codex)
+
+        let pane = ProvidersPane(settings: settings, store: store)
+        let model = pane._test_menuCardModel(for: .codex)
+
+        #expect(model.email == "managed@example.com")
+        #expect(model.planText == "Enterprise")
     }
 
     private static func makeSettingsStore(suite: String) -> SettingsStore {
@@ -78,4 +517,38 @@ struct ProvidersPaneCoverageTests {
             browserDetection: BrowserDetection(cacheTTL: 0),
             settings: settings)
     }
+
+    private static func withEnglishLocalization(perform body: () -> Void) {
+        CodexBarLocalizationOverride.$appLanguage.withValue("en", operation: body)
+    }
+
+    private static func writeCodexAuthFile(homeURL: URL, email: String, plan: String) throws {
+        try FileManager.default.createDirectory(at: homeURL, withIntermediateDirectories: true)
+        let auth = [
+            "tokens": [
+                "accessToken": "access-token",
+                "refreshToken": "refresh-token",
+                "idToken": Self.fakeJWT(email: email, plan: plan),
+            ],
+        ]
+        let data = try JSONSerialization.data(withJSONObject: auth)
+        try data.write(to: homeURL.appendingPathComponent("auth.json"))
+    }
+
+    private static func fakeJWT(email: String, plan: String) -> String {
+        let header = (try? JSONSerialization.data(withJSONObject: ["alg": "none"])) ?? Data()
+        let payload = (try? JSONSerialization.data(withJSONObject: [
+            "email": email,
+            "chatgpt_plan_type": plan,
+        ])) ?? Data()
+
+        func base64URL(_ data: Data) -> String {
+            data.base64EncodedString()
+                .replacingOccurrences(of: "=", with: "")
+                .replacingOccurrences(of: "+", with: "-")
+                .replacingOccurrences(of: "/", with: "_")
+        }
+
+        return "\(base64URL(header)).\(base64URL(payload))."
+    }
 }
diff --git a/Tests/CodexBarTests/QuotaWarningNotificationLogicTests.swift b/Tests/CodexBarTests/QuotaWarningNotificationLogicTests.swift
new file mode 100644
index 0000000000..b0bd32c7f1
--- /dev/null
+++ b/Tests/CodexBarTests/QuotaWarningNotificationLogicTests.swift
@@ -0,0 +1,152 @@
+import Testing
+@testable import CodexBar
+
+@Suite(.serialized)
+struct QuotaWarningNotificationLogicTests {
+    @Test
+    func `quota warning copy includes current remaining and threshold`() {
+        Self.withAppLanguage("en") {
+            let copy = QuotaWarningNotificationLogic.notificationCopy(
+                providerName: "Codex",
+                window: .session,
+                threshold: 20,
+                currentRemaining: 12.4)
+
+            #expect(copy.title == "Codex session quota low")
+            #expect(copy.body == "12% left. Reached your 20% session warning threshold.")
+        }
+    }
+
+    @Test
+    func `quota warning copy clamps current remaining`() {
+        Self.withAppLanguage("en") {
+            let copy = QuotaWarningNotificationLogic.notificationCopy(
+                providerName: "Codex",
+                window: .weekly,
+                threshold: 50,
+                currentRemaining: -3)
+
+            #expect(copy.title == "Codex weekly quota low")
+            #expect(copy.body == "0% left. Reached your 50% weekly warning threshold.")
+        }
+    }
+
+    @Test
+    func `quota warning copy includes account when provided`() {
+        Self.withAppLanguage("en") {
+            let copy = QuotaWarningNotificationLogic.notificationCopy(
+                providerName: "Codex",
+                window: .session,
+                threshold: 50,
+                currentRemaining: 45,
+                accountDisplayName: "person@example.com")
+
+            #expect(copy.title == "Codex session quota low")
+            #expect(copy.body == "Account person@example.com. 45% left. Reached your 50% session warning threshold.")
+        }
+    }
+
+    @Test
+    func `quota warning copy follows Traditional Chinese app language`() {
+        Self.withAppLanguage("zh-Hant") {
+            let copy = QuotaWarningNotificationLogic.notificationCopy(
+                providerName: "Codex",
+                window: .session,
+                threshold: 50,
+                currentRemaining: 45,
+                accountDisplayName: "person@example.com")
+
+            #expect(copy.title == "Codex 工作階段配額偏低")
+            #expect(copy.body == "帳號 person@example.com。剩餘 45%。已達到 50% 工作階段提醒門檻。")
+        }
+    }
+
+    @Test
+    func `does nothing without crossing`() {
+        let crossed = QuotaWarningNotificationLogic.crossedThreshold(
+            previousRemaining: 60,
+            currentRemaining: 55,
+            thresholds: [50, 20],
+            alreadyFired: [])
+
+        #expect(crossed == nil)
+    }
+
+    @Test
+    func `detects downward crossing`() {
+        let crossed = QuotaWarningNotificationLogic.crossedThreshold(
+            previousRemaining: 55,
+            currentRemaining: 45,
+            thresholds: [50, 20],
+            alreadyFired: [])
+
+        #expect(crossed == 50)
+    }
+
+    @Test
+    func `skips already fired thresholds`() {
+        let crossed = QuotaWarningNotificationLogic.crossedThreshold(
+            previousRemaining: 55,
+            currentRemaining: 45,
+            thresholds: [50, 20],
+            alreadyFired: [50])
+
+        #expect(crossed == nil)
+    }
+
+    @Test
+    func `chooses most severe threshold when crossing several at once`() {
+        let crossed = QuotaWarningNotificationLogic.crossedThreshold(
+            previousRemaining: 80,
+            currentRemaining: 10,
+            thresholds: [50, 20],
+            alreadyFired: [])
+
+        #expect(crossed == 20)
+    }
+
+    @Test
+    func `startup below threshold warns once at most severe threshold`() {
+        let crossed = QuotaWarningNotificationLogic.crossedThreshold(
+            previousRemaining: nil,
+            currentRemaining: 10,
+            thresholds: [50, 20],
+            alreadyFired: [])
+
+        #expect(crossed == 20)
+    }
+
+    @Test
+    func `warning marks threshold and higher thresholds fired`() {
+        let fired = QuotaWarningNotificationLogic.firedThresholdsAfterWarning(
+            threshold: 20,
+            thresholds: [50, 20])
+
+        #expect(fired == [50, 20])
+    }
+
+    @Test
+    func `recovery clears only thresholds below current remaining`() {
+        let cleared = QuotaWarningNotificationLogic.thresholdsToClear(
+            currentRemaining: 30,
+            alreadyFired: [50, 20])
+
+        #expect(cleared == [20])
+    }
+
+    @Test
+    func `zero threshold does not post quota warning`() {
+        let crossed = QuotaWarningNotificationLogic.crossedThreshold(
+            previousRemaining: 10,
+            currentRemaining: 0,
+            thresholds: [10, 0],
+            alreadyFired: [10])
+
+        #expect(crossed == nil)
+        #expect(QuotaWarningNotificationLogic.firedThresholdsAfterWarning(threshold: 10, thresholds: [10, 0]) == [10])
+    }
+
+    private static func withAppLanguage(_ language: String, perform body: () -> Void) {
+        CodexBarLocalizationOverride.$appLanguage.withValue(language, operation: body)
+    }
+}
diff --git a/Tests/CodexBarTests/ResetTimeBackfillTests.swift b/Tests/CodexBarTests/ResetTimeBackfillTests.swift
new file mode 100644
index 0000000000..e03bcf36ce
--- /dev/null
+++ b/Tests/CodexBarTests/ResetTimeBackfillTests.swift
@@ -0,0 +1,142 @@
+import CodexBarCore
+import Foundation
+import XCTest
+
+final class ResetTimeBackfillTests: XCTestCase {
+    func test_backfillsMissingResetMetadataFromCachedWindow() {
+        let now = Date(timeIntervalSince1970: 1_800_000_000)
+        let reset = now.addingTimeInterval(3600)
+        let cached = RateWindow(
+            usedPercent: 50,
+            windowMinutes: 300,
+            resetsAt: reset,
+            resetDescription: "Resets in 1h",
+            nextRegenPercent: 9)
+        let fresh = RateWindow(
+            usedPercent: 62,
+            windowMinutes: nil,
+            resetsAt: nil,
+            resetDescription: nil,
+            nextRegenPercent: 4)
+
+        let result = fresh.backfillingResetTime(from: cached, now: now)
+
+        XCTAssertEqual(result.usedPercent, 62)
+        XCTAssertEqual(result.windowMinutes, 300)
+        XCTAssertEqual(result.resetsAt, reset)
+        XCTAssertEqual(result.resetDescription, "Resets in 1h")
+        XCTAssertEqual(result.nextRegenPercent, 4)
+    }
+
+    func test_backfillsZeroWindowDurationFromCachedWindow() {
+        let now = Date(timeIntervalSince1970: 1_800_000_000)
+        let reset = now.addingTimeInterval(3600)
+        let cached = RateWindow(
+            usedPercent: 50,
+            windowMinutes: 300,
+            resetsAt: reset,
+            resetDescription: nil)
+        let fresh = RateWindow(usedPercent: 62, windowMinutes: 0, resetsAt: nil, resetDescription: nil)
+
+        let result = fresh.backfillingResetTime(from: cached, now: now)
+
+        XCTAssertEqual(result.windowMinutes, 300)
+        XCTAssertEqual(result.resetsAt, reset)
+    }
+
+    func test_skipsExpiredCachedReset() {
+        let now = Date(timeIntervalSince1970: 1_800_000_000)
+        let cached = RateWindow(
+            usedPercent: 50,
+            windowMinutes: 300,
+            resetsAt: now.addingTimeInterval(-60),
+            resetDescription: "Expired")
+        let fresh = RateWindow(usedPercent: 62, windowMinutes: nil, resetsAt: nil, resetDescription: nil)
+
+        let result = fresh.backfillingResetTime(from: cached, now: now)
+
+        XCTAssertNil(result.resetsAt)
+        XCTAssertNil(result.windowMinutes)
+        XCTAssertNil(result.resetDescription)
+    }
+
+    func test_snapshotBackfillPreservesCurrentSnapshotFields() {
+        let now = Date(timeIntervalSince1970: 1_800_000_000)
+        let reset = now.addingTimeInterval(3600)
+        let identity = ProviderIdentitySnapshot(
+            providerID: .claude,
+            accountEmail: "peter@example.com",
+            accountOrganization: "Org",
+            loginMethod: "OAuth")
+        let cached = UsageSnapshot(
+            primary: RateWindow(usedPercent: 40, windowMinutes: 300, resetsAt: reset, resetDescription: "Soon"),
+            secondary: nil,
+            updatedAt: now.addingTimeInterval(-300),
+            identity: identity)
+        let extra = NamedRateWindow(
+            id: "overflow",
+            title: "Overflow",
+            window: RateWindow(
+                usedPercent: 12,
+                windowMinutes: nil,
+                resetsAt: nil,
+                resetDescription: nil,
+                nextRegenPercent: 2))
+        let fresh = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 66,
+                windowMinutes: nil,
+                resetsAt: nil,
+                resetDescription: nil,
+                nextRegenPercent: 7),
+            secondary: nil,
+            extraRateWindows: [extra],
+            cursorRequests: CursorRequestUsage(used: 10, limit: 50),
+            subscriptionExpiresAt: reset.addingTimeInterval(86400),
+            subscriptionRenewsAt: reset.addingTimeInterval(43200),
+            updatedAt: now,
+            identity: identity)
+
+        let result = fresh.backfillingResetTimes(from: cached, now: now)
+
+        XCTAssertEqual(result.primary?.resetsAt, reset)
+        XCTAssertEqual(result.primary?.usedPercent, 66)
+        XCTAssertEqual(result.primary?.nextRegenPercent, 7)
+        XCTAssertEqual(result.extraRateWindows?.first?.id, "overflow")
+        XCTAssertEqual(result.extraRateWindows?.first?.window.nextRegenPercent, 2)
+        XCTAssertEqual(result.cursorRequests?.used, 10)
+        XCTAssertEqual(result.subscriptionExpiresAt, reset.addingTimeInterval(86400))
+        XCTAssertEqual(result.subscriptionRenewsAt, reset.addingTimeInterval(43200))
+        XCTAssertEqual(result.identity?.accountEmail, "peter@example.com")
+    }
+
+    func test_snapshotBackfillSkipsDifferentAccounts() {
+        let now = Date(timeIntervalSince1970: 1_800_000_000)
+        let cached = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 40,
+                windowMinutes: 300,
+                resetsAt: now.addingTimeInterval(3600),
+                resetDescription: "Soon"),
+            secondary: nil,
+            updatedAt: now.addingTimeInterval(-300),
+            identity: ProviderIdentitySnapshot(
+                providerID: .claude,
+                accountEmail: "old@example.com",
+                accountOrganization: nil,
+                loginMethod: nil))
+        let fresh = UsageSnapshot(
+            primary: RateWindow(usedPercent: 66, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: now,
+            identity: ProviderIdentitySnapshot(
+                providerID: .claude,
+                accountEmail: "new@example.com",
+                accountOrganization: nil,
+                loginMethod: nil))
+
+        let result = fresh.backfillingResetTimes(from: cached, now: now)
+
+        XCTAssertNil(result.primary?.resetsAt)
+    }
+}
diff --git a/Tests/CodexBarTests/SessionQuotaNotificationLogicTests.swift b/Tests/CodexBarTests/SessionQuotaNotificationLogicTests.swift
index 96cbcc52e5..2c43d31791 100644
--- a/Tests/CodexBarTests/SessionQuotaNotificationLogicTests.swift
+++ b/Tests/CodexBarTests/SessionQuotaNotificationLogicTests.swift
@@ -1,36 +1,64 @@
 import Testing
 @testable import CodexBar
 
-@Suite
+@Suite(.serialized)
 struct SessionQuotaNotificationLogicTests {
     @Test
-    func doesNothingWithoutPreviousValue() {
+    func `does nothing without previous value`() {
         let transition = SessionQuotaNotificationLogic.transition(previousRemaining: nil, currentRemaining: 0)
         #expect(transition == .none)
     }
 
     @Test
-    func detectsDepletedTransition() {
+    func `detects depleted transition`() {
         let transition = SessionQuotaNotificationLogic.transition(previousRemaining: 12, currentRemaining: 0)
         #expect(transition == .depleted)
     }
 
     @Test
-    func detectsRestoredTransition() {
+    func `detects restored transition`() {
         let transition = SessionQuotaNotificationLogic.transition(previousRemaining: 0, currentRemaining: 5)
         #expect(transition == .restored)
     }
 
     @Test
-    func ignoresNonTransitions() {
+    func `ignores non transitions`() {
         #expect(SessionQuotaNotificationLogic.transition(previousRemaining: 0, currentRemaining: 0) == .none)
         #expect(SessionQuotaNotificationLogic.transition(previousRemaining: 10, currentRemaining: 10) == .none)
         #expect(SessionQuotaNotificationLogic.transition(previousRemaining: 10, currentRemaining: 9) == .none)
     }
 
     @Test
-    func treatsTinyPositiveRemainingAsDepleted() {
+    func `treats tiny positive remaining as depleted`() {
         let transition = SessionQuotaNotificationLogic.transition(previousRemaining: 0, currentRemaining: 0.00001)
         #expect(transition == .none)
     }
+
+    @Test
+    func `depleted notification copy follows Traditional Chinese app language`() {
+        Self.withAppLanguage("zh-Hant") {
+            let copy = SessionQuotaNotificationLogic.notificationCopy(
+                transition: .depleted,
+                providerName: "Codex")
+
+            #expect(copy.title == "Codex 工作階段已用完")
+            #expect(copy.body == "剩餘 0%。恢復可用時會再通知。")
+        }
+    }
+
+    @Test
+    func `restored notification copy follows Traditional Chinese app language`() {
+        Self.withAppLanguage("zh-Hant") {
+            let copy = SessionQuotaNotificationLogic.notificationCopy(
+                transition: .restored,
+                providerName: "Codex")
+
+            #expect(copy.title == "Codex 工作階段已恢復")
+            #expect(copy.body == "工作階段配額已恢復可用。")
+        }
+    }
+
+    private static func withAppLanguage(_ language: String, perform body: () -> Void) {
+        CodexBarLocalizationOverride.$appLanguage.withValue(language, operation: body)
+    }
 }
diff --git a/Tests/CodexBarTests/SettingsStoreAdditionalTests.swift b/Tests/CodexBarTests/SettingsStoreAdditionalTests.swift
index 7ec91584c5..145630cb5d 100644
--- a/Tests/CodexBarTests/SettingsStoreAdditionalTests.swift
+++ b/Tests/CodexBarTests/SettingsStoreAdditionalTests.swift
@@ -4,24 +4,123 @@ import Testing
 @testable import CodexBar
 
 @MainActor
-@Suite
 struct SettingsStoreAdditionalTests {
     @Test
-    func menuBarMetricPreferenceHandlesZaiAndAverage() {
+    @MainActor
+    func `antigravity two pool migration preserves released metric meaning`() {
+        let primaryDefaults = UserDefaults(suiteName: #function + ".primary")!
+        primaryDefaults.removePersistentDomain(forName: #function + ".primary")
+        primaryDefaults.set(
+            [UsageProvider.antigravity.rawValue: MenuBarMetricPreference.primary.rawValue],
+            forKey: "menuBarMetricPreferences")
+
+        let primarySettings = SettingsStore(userDefaults: primaryDefaults)
+
+        #expect(primarySettings.menuBarMetricPreference(for: .antigravity) == .secondary)
+        #expect(primaryDefaults.bool(forKey: "antigravityTwoPoolMetricPreferenceMigrated"))
+
+        let secondaryDefaults = UserDefaults(suiteName: #function + ".secondary")!
+        secondaryDefaults.removePersistentDomain(forName: #function + ".secondary")
+        secondaryDefaults.set(
+            [UsageProvider.antigravity.rawValue: MenuBarMetricPreference.secondary.rawValue],
+            forKey: "menuBarMetricPreferences")
+
+        let secondarySettings = SettingsStore(userDefaults: secondaryDefaults)
+
+        #expect(secondarySettings.menuBarMetricPreference(for: .antigravity) == .primary)
+
+        let reloadedSettings = SettingsStore(userDefaults: secondaryDefaults)
+        #expect(reloadedSettings.menuBarMetricPreference(for: .antigravity) == .primary)
+
+        let tertiaryDefaults = UserDefaults(suiteName: #function + ".tertiary")!
+        tertiaryDefaults.removePersistentDomain(forName: #function + ".tertiary")
+        tertiaryDefaults.set(
+            [UsageProvider.antigravity.rawValue: MenuBarMetricPreference.tertiary.rawValue],
+            forKey: "menuBarMetricPreferences")
+
+        let tertiarySettings = SettingsStore(userDefaults: tertiaryDefaults)
+
+        #expect(tertiarySettings.menuBarMetricPreference(for: .antigravity) == .primary)
+
+        let migratedDefaults = UserDefaults(suiteName: #function + ".migrated")!
+        migratedDefaults.removePersistentDomain(forName: #function + ".migrated")
+        migratedDefaults.set(
+            [UsageProvider.antigravity.rawValue: MenuBarMetricPreference.primary.rawValue],
+            forKey: "menuBarMetricPreferences")
+        migratedDefaults.set(true, forKey: "antigravityTwoPoolMetricPreferenceMigrated")
+
+        let migratedSettings = SettingsStore(userDefaults: migratedDefaults)
+
+        #expect(migratedSettings.menuBarMetricPreference(for: .antigravity) == .primary)
+    }
+
+    @Test
+    func `menu bar metric preference handles zai and average`() {
         let settings = Self.makeSettingsStore(suite: "SettingsStoreAdditionalTests-metric")
 
+        #expect(settings.menuBarMetricPreference(for: .zai) == .automatic)
+
         settings.setMenuBarMetricPreference(.average, for: .zai)
-        #expect(settings.menuBarMetricPreference(for: .zai) == .primary)
+        #expect(settings.menuBarMetricPreference(for: .zai) == .automatic)
+
+        settings.setMenuBarMetricPreference(.secondary, for: .zai)
+        #expect(settings.menuBarMetricPreference(for: .zai) == .secondary)
+
+        settings.setMenuBarMetricPreference(.tertiary, for: .zai)
+        #expect(settings.menuBarMetricPreference(for: .zai) == .tertiary)
+        #expect(settings.menuBarMetricPreference(for: .zai, snapshot: nil) == .automatic)
+        #expect(settings.menuBarMetricSupportsTertiary(for: .zai, snapshot: nil) == false)
 
         settings.setMenuBarMetricPreference(.average, for: .codex)
         #expect(settings.menuBarMetricPreference(for: .codex) == .automatic)
 
+        settings.setMenuBarMetricPreference(.primaryAndSecondary, for: .codex)
+        #expect(settings.menuBarMetricPreference(for: .codex) == .primaryAndSecondary)
+        #expect(settings.menuBarMetricSupportsPrimaryAndSecondary(for: .codex))
+
+        settings.setMenuBarMetricPreference(.primaryAndSecondary, for: .claude)
+        #expect(settings.menuBarMetricPreference(for: .claude) == .automatic)
+        #expect(!settings.menuBarMetricSupportsPrimaryAndSecondary(for: .claude))
+
+        settings.setMenuBarMetricPreference(.monthlyPlan, for: .codex)
+        #expect(settings.menuBarMetricPreference(for: .codex) == .automatic)
+
+        settings.menuBarMetricPreferencesRaw[UsageProvider.codex.rawValue] = MenuBarMetricPreference.monthlyPlan
+            .rawValue
+        #expect(settings.menuBarMetricPreference(for: .codex) == .automatic)
+
         settings.setMenuBarMetricPreference(.average, for: .gemini)
         #expect(settings.menuBarMetricPreference(for: .gemini) == .average)
+
+        settings.setMenuBarMetricPreference(.tertiary, for: .codex)
+        #expect(settings.menuBarMetricPreference(for: .codex) == .automatic)
+
+        settings.setMenuBarMetricPreference(.tertiary, for: .cursor)
+        #expect(settings.menuBarMetricPreference(for: .cursor) == .tertiary)
+        #expect(settings.menuBarMetricPreference(for: .cursor, snapshot: nil) == .automatic)
+        #expect(settings.menuBarMetricSupportsTertiary(for: .cursor, snapshot: nil) == false)
+
+        settings.setMenuBarMetricPreference(.extraUsage, for: .cursor)
+        #expect(settings.menuBarMetricPreference(for: .cursor) == .extraUsage)
+        #expect(settings.menuBarMetricPreference(for: .cursor, snapshot: nil) == .automatic)
+        #expect(settings.menuBarMetricSupportsExtraUsage(for: .cursor, snapshot: nil) == false)
+
+        settings.setMenuBarMetricPreference(.extraUsage, for: .claude)
+        #expect(settings.menuBarMetricPreference(for: .claude) == .extraUsage)
+        #expect(settings.menuBarMetricPreference(for: .claude, snapshot: nil) == .automatic)
+        #expect(settings.menuBarMetricSupportsExtraUsage(for: .claude, snapshot: nil) == false)
+
+        settings.setMenuBarMetricPreference(.tertiary, for: .perplexity)
+        #expect(settings.menuBarMetricPreference(for: .perplexity) == .tertiary)
+        #expect(settings.menuBarMetricPreference(for: .perplexity, snapshot: nil) == .tertiary)
+        #expect(settings.menuBarMetricSupportsTertiary(for: .perplexity, snapshot: nil))
+
+        settings.setMenuBarMetricPreference(.tertiary, for: .gemini)
+        #expect(settings.menuBarMetricPreference(for: .gemini) == .automatic)
     }
 
     @Test
-    func menuBarMetricPreferenceRestrictsOpenRouterToAutomaticOrPrimary() {
+    func `menu bar metric preference restricts open router to automatic or primary`() {
         let settings = Self.makeSettingsStore(suite: "SettingsStoreAdditionalTests-openrouter-metric")
 
         settings.setMenuBarMetricPreference(.secondary, for: .openrouter)
@@ -32,10 +131,40 @@ struct SettingsStoreAdditionalTests {
 
         settings.setMenuBarMetricPreference(.primary, for: .openrouter)
         #expect(settings.menuBarMetricPreference(for: .openrouter) == .primary)
+
+        settings.setMenuBarMetricPreference(.tertiary, for: .openrouter)
+        #expect(settings.menuBarMetricPreference(for: .openrouter) == .automatic)
+
+        settings.setMenuBarMetricPreference(.extraUsage, for: .openrouter)
+        #expect(settings.menuBarMetricPreference(for: .openrouter) == .automatic)
+    }
+
+    @Test
+    func `menu bar metric preference restricts mistral to payg or monthly plan`() {
+        let settings = Self.makeSettingsStore(suite: "SettingsStoreAdditionalTests-mistral-metric")
+
+        settings.setMenuBarMetricPreference(.monthlyPlan, for: .mistral)
+        #expect(settings.menuBarMetricPreference(for: .mistral) == .monthlyPlan)
+
+        settings.setMenuBarMetricPreference(.secondary, for: .mistral)
+        #expect(settings.menuBarMetricPreference(for: .mistral) == .automatic)
+    }
+
+    @Test
+    func `menu bar metric preference restricts text only balance providers to automatic`() {
+        let settings = Self.makeSettingsStore(suite: "SettingsStoreAdditionalTests-text-only-metric")
+
+        for provider in [UsageProvider.deepseek, .kimik2, .poe] {
+            settings.setMenuBarMetricPreference(.primary, for: provider)
+            #expect(settings.menuBarMetricPreference(for: provider) == .automatic)
+
+            settings.setMenuBarMetricPreference(.secondary, for: provider)
+            #expect(settings.menuBarMetricPreference(for: provider) == .automatic)
+        }
     }
 
     @Test
-    func minimaxAuthModeUsesStoredValues() {
+    func `minimax auth mode uses stored values`() {
         let settings = Self.makeSettingsStore(suite: "SettingsStoreAdditionalTests-minimax")
         settings.minimaxAPIToken = "sk-api-test-token"
         settings.minimaxCookieHeader = "cookie=value"
@@ -47,7 +176,7 @@ struct SettingsStoreAdditionalTests {
     }
 
     @Test
-    func tokenAccountsSetManualCookieSourceWhenRequired() {
+    func `token accounts set manual cookie source when required`() {
         let settings = Self.makeSettingsStore(suite: "SettingsStoreAdditionalTests-token-accounts")
 
         settings.addTokenAccount(provider: .claude, label: "Primary", token: "token-1")
@@ -57,7 +186,7 @@ struct SettingsStoreAdditionalTests {
     }
 
     @Test
-    func ollamaTokenAccountsSetManualCookieSourceWhenRequired() {
+    func `ollama token accounts set manual cookie source when required`() {
         let settings = Self.makeSettingsStore(suite: "SettingsStoreAdditionalTests-ollama-token-accounts")
 
         settings.addTokenAccount(provider: .ollama, label: "Primary", token: "session=token-1")
@@ -67,7 +196,7 @@ struct SettingsStoreAdditionalTests {
     }
 
     @Test
-    func detectsTokenCostUsageSourcesFromFilesystem() throws {
+    func `detects token cost usage sources from filesystem`() throws {
         let fm = FileManager.default
         let root = fm.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
         let sessions = root.appendingPathComponent("sessions", isDirectory: true)
diff --git a/Tests/CodexBarTests/SettingsStoreCoverageTests.swift b/Tests/CodexBarTests/SettingsStoreCoverageTests.swift
index 242de898ff..4c42e461a3 100644
--- a/Tests/CodexBarTests/SettingsStoreCoverageTests.swift
+++ b/Tests/CodexBarTests/SettingsStoreCoverageTests.swift
@@ -4,10 +4,9 @@ import Testing
 @testable import CodexBar
 
 @MainActor
-@Suite
 struct SettingsStoreCoverageTests {
     @Test
-    func providerOrderingAndCaching() throws {
+    func `provider ordering and caching`() throws {
         let suite = "SettingsStoreCoverageTests-ordering"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -37,7 +36,22 @@ struct SettingsStoreCoverageTests {
     }
 
     @Test
-    func menuBarMetricPreferencesAndDisplayModes() {
+    func `disabling selected provider clears menu selection`() throws {
+        let settings = Self.makeSettingsStore()
+        let metadata = ProviderRegistry.shared.metadata
+
+        try settings.setProviderEnabled(provider: .codex, metadata: #require(metadata[.codex]), enabled: true)
+        try settings.setProviderEnabled(provider: .claude, metadata: #require(metadata[.claude]), enabled: true)
+        settings.selectedMenuProvider = .claude
+
+        try settings.setProviderEnabled(provider: .claude, metadata: #require(metadata[.claude]), enabled: false)
+
+        #expect(settings.selectedMenuProvider == nil)
+        #expect(settings.enabledProvidersOrdered(metadataByProvider: metadata) == [.codex])
+    }
+
+    @Test
+    func `menu bar metric preferences and display modes`() {
         let settings = Self.makeSettingsStore()
 
         settings.setMenuBarMetricPreference(.average, for: .codex)
@@ -48,7 +62,7 @@ struct SettingsStoreCoverageTests {
         #expect(settings.menuBarMetricSupportsAverage(for: .gemini))
 
         settings.setMenuBarMetricPreference(.secondary, for: .zai)
-        #expect(settings.menuBarMetricPreference(for: .zai) == .primary)
+        #expect(settings.menuBarMetricPreference(for: .zai) == .secondary)
 
         settings.menuBarDisplayMode = .pace
         #expect(settings.menuBarDisplayMode == .pace)
@@ -61,7 +75,83 @@ struct SettingsStoreCoverageTests {
     }
 
     @Test
-    func tokenAccountMutationsApplySideEffects() {
+    func `minimax settings snapshot uses selected token account as manual cookie`() {
+        let settings = Self.makeSettingsStore(suiteName: "SettingsStoreCoverageTests-minimax-token-account")
+        settings.minimaxCookieSource = .auto
+        settings.minimaxCookieHeader = "HERTZ-SESSION=global"
+        settings.addTokenAccount(provider: .minimax, label: "account", token: "HERTZ-SESSION=selected")
+
+        let snapshot = settings.minimaxSettingsSnapshot(tokenOverride: nil)
+
+        #expect(snapshot.cookieSource == .manual)
+        #expect(snapshot.manualCookieHeader == "HERTZ-SESSION=selected")
+    }
+
+    @Test
+    func `minimax settings snapshot falls back to global cookie without token accounts`() {
+        let settings = Self.makeSettingsStore(suiteName: "SettingsStoreCoverageTests-minimax-global-cookie")
+        settings.minimaxCookieSource = .auto
+        settings.minimaxCookieHeader = "HERTZ-SESSION=global"
+
+        let snapshot = settings.minimaxSettingsSnapshot(tokenOverride: nil)
+
+        #expect(snapshot.cookieSource == .auto)
+        #expect(snapshot.manualCookieHeader == "HERTZ-SESSION=global")
+    }
+
+    @Test
+    func `copilot budget extras default off and persist in provider snapshot`() throws {
+        let suite = "SettingsStoreCoverageTests-copilot-budget-extras"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+
+        let initial = Self.makeSettingsStore(userDefaults: defaults, configStore: configStore)
+        #expect(initial.copilotBudgetExtrasEnabled == false)
+        #expect(initial.copilotSettingsSnapshot(tokenOverride: nil).budgetExtrasEnabled == false)
+
+        initial.copilotBudgetExtrasEnabled = true
+
+        let reloaded = Self.makeSettingsStore(userDefaults: defaults, configStore: configStore)
+        #expect(reloaded.copilotBudgetExtrasEnabled)
+        #expect(reloaded.copilotSettingsSnapshot(tokenOverride: nil).budgetExtrasEnabled)
+    }
+
+    @Test
+    func `multi account menu layout persists and bridges legacy show all token accounts`() throws {
+        let suite = "SettingsStoreCoverageTests-multi-account-layout"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+
+        let initial = Self.makeSettingsStore(userDefaults: defaults, configStore: configStore)
+        #expect(initial.multiAccountMenuLayout == .segmented)
+
+        initial.multiAccountMenuLayout = .stacked
+        #expect(defaults.string(forKey: "multiAccountMenuLayout") == MultiAccountMenuLayout.stacked.rawValue)
+        #expect(initial.showAllTokenAccountsInMenu)
+
+        let reloaded = Self.makeSettingsStore(userDefaults: defaults, configStore: configStore)
+        #expect(reloaded.multiAccountMenuLayout == .stacked)
+        reloaded.showAllTokenAccountsInMenu = false
+        #expect(reloaded.multiAccountMenuLayout == .segmented)
+    }
+
+    @Test
+    func `legacy show all token accounts migrates to stacked layout`() throws {
+        let suite = "SettingsStoreCoverageTests-legacy-token-account-layout"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        defaults.set(true, forKey: "showAllTokenAccountsInMenu")
+        let configStore = testConfigStore(suiteName: suite)
+
+        let settings = Self.makeSettingsStore(userDefaults: defaults, configStore: configStore)
+
+        #expect(settings.multiAccountMenuLayout == .stacked)
+    }
+
+    @Test
+    func `token account mutations apply side effects`() {
         let settings = Self.makeSettingsStore()
 
         settings.addTokenAccount(provider: .claude, label: "Primary", token: "token")
@@ -83,7 +173,174 @@ struct SettingsStoreCoverageTests {
     }
 
     @Test
-    func tokenCostUsageSourceDetection() throws {
+    func `token account update preserves identity and selection`() throws {
+        let settings = Self.makeSettingsStore()
+
+        settings.addTokenAccount(provider: .copilot, label: "Primary", token: "token-1")
+        settings.addTokenAccount(provider: .copilot, label: "Secondary", token: "token-2")
+        settings.setActiveTokenAccountIndex(0, for: .copilot)
+
+        let original = try #require(settings.selectedTokenAccount(for: .copilot))
+        settings.updateTokenAccount(
+            provider: .copilot,
+            accountID: original.id,
+            label: "Primary (Pro)",
+            token: "token-1b")
+
+        let updated = try #require(settings.selectedTokenAccount(for: .copilot))
+        #expect(updated.id == original.id)
+        #expect(updated.label == "Primary (Pro)")
+        #expect(updated.token == "token-1b")
+        #expect(settings.tokenAccounts(for: .copilot).count == 2)
+    }
+
+    @Test
+    func `copilot token accounts clear legacy api key fallback`() throws {
+        let settings = Self.makeSettingsStore()
+        settings.copilotAPIToken = "legacy-token"
+
+        settings.addTokenAccount(provider: .copilot, label: "Primary", token: "token-1")
+
+        #expect(settings.copilotAPIToken.isEmpty)
+        #expect(settings.copilotSettingsSnapshot(tokenOverride: nil).apiToken == "token-1")
+
+        settings.copilotAPIToken = "legacy-token"
+        let account = try #require(settings.selectedTokenAccount(for: .copilot))
+        settings.removeTokenAccount(provider: .copilot, accountID: account.id)
+
+        #expect(settings.tokenAccounts(for: .copilot).isEmpty)
+        #expect(settings.copilotAPIToken.isEmpty)
+        #expect(settings.copilotSettingsSnapshot(tokenOverride: nil).apiToken == nil)
+    }
+
+    @Test
+    func `copilot settings snapshot carries selected account identifier`() {
+        let settings = Self.makeSettingsStore()
+        settings.addTokenAccount(
+            provider: .copilot,
+            label: "octocat (Pro)",
+            token: "token-1",
+            externalIdentifier: "github:user:123")
+
+        let snapshot = settings.copilotSettingsSnapshot(tokenOverride: nil)
+
+        #expect(snapshot.apiToken == "token-1")
+        #expect(snapshot.selectedAccountExternalIdentifier == "github:user:123")
+    }
+
+    @Test
+    func `copilot enterprise host persists in provider config`() throws {
+        let suite = "SettingsStoreCoverageTests-copilot-enterprise-host"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+        let first = Self.makeSettingsStore(userDefaults: defaults, configStore: configStore)
+
+        first.copilotEnterpriseHost = "https://octocorp.ghe.com/login"
+        #expect(first.copilotEnterpriseHost == "https://octocorp.ghe.com/login")
+        #expect(first.copilotSettingsSnapshot(tokenOverride: nil).enterpriseHost == "octocorp.ghe.com")
+
+        let second = Self.makeSettingsStore(userDefaults: defaults, configStore: configStore)
+        #expect(second.copilotEnterpriseHost == "https://octocorp.ghe.com/login")
+
+        second.copilotEnterpriseHost = "github.com"
+        #expect(second.copilotEnterpriseHost == "github.com")
+        #expect(second.copilotSettingsSnapshot(tokenOverride: nil).enterpriseHost == nil)
+    }
+
+    @Test
+    func `removing another token account preserves active selection`() throws {
+        let settings = Self.makeSettingsStore()
+
+        settings.addTokenAccount(provider: .copilot, label: "A", token: "token-a")
+        settings.addTokenAccount(provider: .copilot, label: "B", token: "token-b")
+        settings.addTokenAccount(provider: .copilot, label: "C", token: "token-c")
+        settings.setActiveTokenAccountIndex(1, for: .copilot)
+
+        let activeBefore = try #require(settings.selectedTokenAccount(for: .copilot))
+        let accountToRemove = try #require(settings.tokenAccounts(for: .copilot).first)
+        settings.removeTokenAccount(provider: .copilot, accountID: accountToRemove.id)
+
+        let activeAfter = try #require(settings.selectedTokenAccount(for: .copilot))
+        #expect(activeAfter.id == activeBefore.id)
+        #expect(activeAfter.label == "B")
+        #expect(settings.tokenAccounts(for: .copilot).map(\.label) == ["B", "C"])
+    }
+
+    @Test
+    func `claude snapshot uses OAuth routing for OAuth token accounts`() {
+        let settings = Self.makeSettingsStore()
+        settings.addTokenAccount(provider: .claude, label: "OAuth", token: "Bearer sk-ant-oat-account-token")
+
+        let snapshot = settings.claudeSettingsSnapshot(tokenOverride: nil)
+
+        #expect(snapshot.usageDataSource == .auto)
+        #expect(snapshot.cookieSource == .off)
+        #expect(snapshot.manualCookieHeader?.isEmpty == true)
+    }
+
+    @Test
+    func `claude snapshot uses manual cookie routing for session key accounts`() {
+        let settings = Self.makeSettingsStore()
+        settings.addTokenAccount(provider: .claude, label: "Cookie", token: "sk-ant-session-token")
+
+        let snapshot = settings.claudeSettingsSnapshot(tokenOverride: nil)
+
+        #expect(snapshot.usageDataSource == .auto)
+        #expect(snapshot.cookieSource == .manual)
+        #expect(snapshot.manualCookieHeader == "sessionKey=sk-ant-session-token")
+    }
+
+    @Test
+    func `claude snapshot normalizes config manual cookie input through shared route`() {
+        let settings = Self.makeSettingsStore()
+        settings.claudeCookieSource = .manual
+        settings.claudeCookieHeader = "Cookie: sessionKey=sk-ant-session-token; foo=bar"
+
+        let snapshot = settings.claudeSettingsSnapshot(tokenOverride: nil)
+
+        #expect(snapshot.usageDataSource == .auto)
+        #expect(snapshot.cookieSource == .manual)
+        #expect(snapshot.manualCookieHeader == "sessionKey=sk-ant-session-token; foo=bar")
+    }
+
+    @Test
+    func `claude snapshot does not fall back to config cookie for malformed selected token account`() {
+        let settings = Self.makeSettingsStore()
+        settings.claudeCookieSource = .manual
+        settings.claudeCookieHeader = "Cookie: sessionKey=sk-ant-config-cookie"
+        settings.addTokenAccount(provider: .claude, label: "Malformed", token: "Cookie:")
+
+        let snapshot = settings.claudeSettingsSnapshot(tokenOverride: nil)
+
+        #expect(snapshot.cookieSource == .manual)
+        #expect(snapshot.manualCookieHeader?.isEmpty == true)
+    }
+
+    @Test
+    func `opencode go token accounts force manual cookie routing`() {
+        let settings = Self.makeSettingsStore()
+        settings.addTokenAccount(provider: .opencodego, label: "Go", token: "auth=go-cookie")
+
+        let snapshot = settings.opencodegoSettingsSnapshot(tokenOverride: nil)
+
+        #expect(settings.opencodegoCookieSource == .manual)
+        #expect(snapshot.cookieSource == .manual)
+        #expect(snapshot.manualCookieHeader == "auth=go-cookie")
+    }
+
+    @Test
+    func `opencode go snapshot preserves nil workspace id when settings are unset`() {
+        let settings = Self.makeSettingsStore()
+
+        let snapshot = settings.opencodegoSettingsSnapshot(tokenOverride: nil)
+
+        #expect(settings.opencodegoWorkspaceID.isEmpty)
+        #expect(snapshot.workspaceID == nil)
+    }
+
+    @Test
+    func `token cost usage source detection`() throws {
         let fileManager = FileManager.default
         let root = fileManager.temporaryDirectory.appendingPathComponent(
             "token-cost-\(UUID().uuidString)",
@@ -111,7 +368,7 @@ struct SettingsStoreCoverageTests {
     }
 
     @Test
-    func ensureTokenLoadersExecute() {
+    func `ensure token loaders execute`() {
         let settings = Self.makeSettingsStore()
 
         settings.ensureZaiAPITokenLoaded()
@@ -136,7 +393,7 @@ struct SettingsStoreCoverageTests {
     }
 
     @Test
-    func keychainDisableForcesManualCookieSources() throws {
+    func `keychain disable forces manual cookie sources`() throws {
         let suite = "SettingsStoreCoverageTests-keychain"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -154,13 +411,13 @@ struct SettingsStoreCoverageTests {
     }
 
     @Test
-    func claudeKeychainPromptMode_defaultsToOnlyOnUserAction() {
+    func `claude keychain prompt mode defaults to only on user action`() {
         let settings = Self.makeSettingsStore()
         #expect(settings.claudeOAuthKeychainPromptMode == .onlyOnUserAction)
     }
 
     @Test
-    func claudeKeychainPromptMode_persistsAcrossStoreReload() throws {
+    func `claude keychain prompt mode persists across store reload`() throws {
         let suite = "SettingsStoreCoverageTests-claude-keychain-prompt-mode"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -177,7 +434,7 @@ struct SettingsStoreCoverageTests {
     }
 
     @Test
-    func claudeKeychainPromptMode_invalidRawFallsBackToOnlyOnUserAction() throws {
+    func `claude keychain prompt mode invalid raw falls back to only on user action`() throws {
         let suite = "SettingsStoreCoverageTests-claude-keychain-prompt-mode-invalid"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -189,13 +446,13 @@ struct SettingsStoreCoverageTests {
     }
 
     @Test
-    func claudeKeychainReadStrategy_defaultsToSecurityFramework() {
+    func `claude keychain read strategy defaults to security CLI experimental`() {
         let settings = Self.makeSettingsStore()
-        #expect(settings.claudeOAuthKeychainReadStrategy == .securityFramework)
+        #expect(settings.claudeOAuthKeychainReadStrategy == .securityCLIExperimental)
     }
 
     @Test
-    func claudeKeychainReadStrategy_persistsAcrossStoreReload() throws {
+    func `claude keychain read strategy persists across store reload`() throws {
         let suite = "SettingsStoreCoverageTests-claude-keychain-read-strategy"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -212,7 +469,7 @@ struct SettingsStoreCoverageTests {
     }
 
     @Test
-    func claudeKeychainReadStrategy_invalidRawFallsBackToSecurityFramework() throws {
+    func `claude keychain read strategy invalid raw falls back to security framework`() throws {
         let suite = "SettingsStoreCoverageTests-claude-keychain-read-strategy-invalid"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -224,28 +481,211 @@ struct SettingsStoreCoverageTests {
     }
 
     @Test
-    func claudePromptFreeCredentialsToggle_mapsToReadStrategy() {
+    func `claude prompt free credentials toggle maps to read strategy`() {
         let settings = Self.makeSettingsStore()
-        #expect(settings.claudeOAuthPromptFreeCredentialsEnabled == false)
+        #expect(settings.claudeOAuthPromptFreeCredentialsEnabled == true)
+
+        settings.claudeOAuthPromptFreeCredentialsEnabled = false
+        #expect(settings.claudeOAuthKeychainReadStrategy == .securityFramework)
 
         settings.claudeOAuthPromptFreeCredentialsEnabled = true
         #expect(settings.claudeOAuthKeychainReadStrategy == .securityCLIExperimental)
+    }
 
-        settings.claudeOAuthPromptFreeCredentialsEnabled = false
-        #expect(settings.claudeOAuthKeychainReadStrategy == .securityFramework)
+    @Test
+    func `upsert antigravity oauth account adds and updates active token account`() throws {
+        let settings = Self.makeSettingsStore()
+        let first = AntigravityOAuthCredentials(
+            accessToken: "first-access",
+            refreshToken: "first-refresh",
+            expiryDate: Date(timeIntervalSince1970: 1_700_000_000),
+            email: "user@example.com")
+        let updated = AntigravityOAuthCredentials(
+            accessToken: "updated-access",
+            refreshToken: "first-refresh",
+            expiryDate: Date(timeIntervalSince1970: 1_700_000_100),
+            email: "user@example.com")
+
+        settings.upsertAntigravityOAuthAccount(first)
+        settings.upsertAntigravityOAuthAccount(updated)
+
+        let accounts = settings.tokenAccounts(for: .antigravity)
+        #expect(accounts.count == 1)
+        let account = try #require(accounts.first)
+        #expect(account.label == "user@example.com")
+        #expect(account.externalIdentifier == "user@example.com")
+        #expect(settings.selectedTokenAccount(for: .antigravity)?.id == account.id)
+
+        let decoded = try #require(AntigravityOAuthCredentialsStore.credentials(fromTokenAccountValue: account.token))
+        #expect(decoded.accessToken == "updated-access")
+    }
+
+    @Test
+    func `upsert antigravity oauth account does not merge missing email accounts by fallback label`() {
+        let settings = Self.makeSettingsStore()
+        let first = AntigravityOAuthCredentials(
+            accessToken: "first-access",
+            refreshToken: "first-refresh",
+            expiryDate: Date(timeIntervalSince1970: 1_700_000_000),
+            email: nil)
+        let second = AntigravityOAuthCredentials(
+            accessToken: "second-access",
+            refreshToken: "second-refresh",
+            expiryDate: Date(timeIntervalSince1970: 1_700_000_100),
+            email: nil)
+
+        settings.upsertAntigravityOAuthAccount(first)
+        settings.upsertAntigravityOAuthAccount(second)
+
+        let accounts = settings.tokenAccounts(for: .antigravity)
+        #expect(accounts.count == 2)
+        #expect(accounts.map(\.label) == ["Google Account 1", "Google Account 2"])
+        #expect(settings.selectedTokenAccount(for: .antigravity)?.id == accounts.last?.id)
+    }
+
+    @Test
+    func `removing last antigravity oauth account clears matching shared credentials`() throws {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent("antigravity-shared-removal-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let sharedStore = AntigravityOAuthCredentialsStore(
+            fileURL: root.appendingPathComponent("oauth_creds.json"))
+        let credentials = AntigravityOAuthCredentials(
+            accessToken: "shared-access",
+            refreshToken: "shared-refresh",
+            expiryDate: Date(timeIntervalSince1970: 1_700_000_000),
+            email: "user@example.com")
+        try sharedStore.save(credentials)
+        let settings = Self.makeSettingsStore(
+            suiteName: "SettingsStoreCoverageTests-antigravity-remove-shared",
+            antigravityOAuthCredentialsStore: sharedStore)
+
+        settings.upsertAntigravityOAuthAccount(credentials)
+        let account = try #require(settings.selectedTokenAccount(for: .antigravity))
+        settings.removeTokenAccount(provider: .antigravity, accountID: account.id)
+
+        #expect(settings.tokenAccounts(for: .antigravity).isEmpty)
+        #expect(try sharedStore.load() == nil)
+    }
+
+    @Test
+    func `removing antigravity oauth account preserves freshly reauthenticated credentials`() throws {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent("antigravity-shared-reauth-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let sharedStore = AntigravityOAuthCredentialsStore(
+            fileURL: root.appendingPathComponent("oauth_creds.json"))
+        let removed = AntigravityOAuthCredentials(
+            accessToken: "removed-access",
+            refreshToken: "removed-refresh",
+            expiryDate: Date(timeIntervalSince1970: 1_700_000_000),
+            email: "user@example.com")
+        let refreshed = AntigravityOAuthCredentials(
+            accessToken: "fresh-access",
+            refreshToken: "fresh-refresh",
+            expiryDate: Date(timeIntervalSince1970: 1_700_000_100),
+            email: "user@example.com")
+        try sharedStore.save(refreshed)
+        let settings = Self.makeSettingsStore(
+            suiteName: "SettingsStoreCoverageTests-antigravity-preserve-reauth",
+            antigravityOAuthCredentialsStore: sharedStore)
+
+        settings.upsertAntigravityOAuthAccount(removed)
+        let account = try #require(settings.selectedTokenAccount(for: .antigravity))
+        settings.removeTokenAccount(provider: .antigravity, accountID: account.id)
+
+        #expect(try sharedStore.load() == refreshed)
+    }
+
+    @Test
+    func `removing antigravity oauth account preserves different shared credentials`() async throws {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent("antigravity-shared-preserve-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let sharedStore = AntigravityOAuthCredentialsStore(
+            fileURL: root.appendingPathComponent("oauth_creds.json"))
+        let removed = AntigravityOAuthCredentials(
+            accessToken: "removed-access",
+            refreshToken: "removed-refresh",
+            expiryDate: Date(timeIntervalSince1970: 1_700_000_000),
+            email: "removed@example.com")
+        let shared = AntigravityOAuthCredentials(
+            accessToken: "shared-access",
+            refreshToken: "shared-refresh",
+            expiryDate: Date(timeIntervalSince1970: 1_700_000_000),
+            email: "shared@example.com")
+        try sharedStore.save(shared)
+        let settings = Self.makeSettingsStore(
+            suiteName: "SettingsStoreCoverageTests-antigravity-preserve-shared",
+            antigravityOAuthCredentialsStore: sharedStore)
+
+        settings.upsertAntigravityOAuthAccount(removed)
+        let account = try #require(settings.selectedTokenAccount(for: .antigravity))
+        settings.removeTokenAccount(provider: .antigravity, accountID: account.id)
+
+        #expect(settings.tokenAccounts(for: .antigravity).isEmpty)
+        try await Task.sleep(nanoseconds: 50_000_000)
+        #expect(try sharedStore.load() == shared)
     }
 
-    private static func makeSettingsStore(suiteName: String = "SettingsStoreCoverageTests") -> SettingsStore {
+    @Test
+    func `weekly progress work days defaults to nil and persists across store reload`() throws {
+        let suite = "SettingsStoreCoverageTests-weekly-progress-work-days"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+
+        let fresh = Self.makeSettingsStore(userDefaults: defaults, configStore: configStore)
+        #expect(fresh.weeklyProgressWorkDays == nil)
+
+        fresh.weeklyProgressWorkDays = 5
+        #expect(defaults.object(forKey: "weeklyProgressWorkDays") as? Int == 5)
+
+        let reloaded = Self.makeSettingsStore(userDefaults: defaults, configStore: configStore)
+        #expect(reloaded.weeklyProgressWorkDays == 5)
+
+        fresh.weeklyProgressWorkDays = 4
+        #expect(reloaded.weeklyProgressWorkDays == 5)
+
+        let reloaded2 = Self.makeSettingsStore(userDefaults: defaults, configStore: configStore)
+        #expect(reloaded2.weeklyProgressWorkDays == 4)
+
+        reloaded2.weeklyProgressWorkDays = 7
+        let reloaded3 = Self.makeSettingsStore(userDefaults: defaults, configStore: configStore)
+        #expect(reloaded3.weeklyProgressWorkDays == 7)
+
+        reloaded3.weeklyProgressWorkDays = nil
+        #expect(defaults.object(forKey: "weeklyProgressWorkDays") == nil)
+        let reloaded4 = Self.makeSettingsStore(userDefaults: defaults, configStore: configStore)
+        #expect(reloaded4.weeklyProgressWorkDays == nil)
+    }
+
+    private static func makeSettingsStore(
+        suiteName: String = "SettingsStoreCoverageTests",
+        antigravityOAuthCredentialsStore: AntigravityOAuthCredentialsStore = AntigravityOAuthCredentialsStore())
+        -> SettingsStore
+    {
         let defaults = UserDefaults(suiteName: suiteName)!
         defaults.removePersistentDomain(forName: suiteName)
         defaults.set(false, forKey: "debugDisableKeychainAccess")
         let configStore = testConfigStore(suiteName: suiteName)
-        return Self.makeSettingsStore(userDefaults: defaults, configStore: configStore)
+        return Self.makeSettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            antigravityOAuthCredentialsStore: antigravityOAuthCredentialsStore)
     }
 
     private static func makeSettingsStore(
         userDefaults: UserDefaults,
-        configStore: CodexBarConfigStore) -> SettingsStore
+        configStore: CodexBarConfigStore,
+        antigravityOAuthCredentialsStore: AntigravityOAuthCredentialsStore = AntigravityOAuthCredentialsStore())
+        -> SettingsStore
     {
         SettingsStore(
             userDefaults: userDefaults,
@@ -264,6 +704,22 @@ struct SettingsStoreCoverageTests {
             augmentCookieStore: InMemoryCookieHeaderStore(),
             ampCookieStore: InMemoryCookieHeaderStore(),
             copilotTokenStore: InMemoryCopilotTokenStore(),
-            tokenAccountStore: InMemoryTokenAccountStore())
+            tokenAccountStore: InMemoryTokenAccountStore(),
+            antigravityOAuthCredentialsStore: antigravityOAuthCredentialsStore)
+    }
+
+    private static func waitForSharedAntigravityCredentials(
+        in store: AntigravityOAuthCredentialsStore,
+        matches predicate: (AntigravityOAuthCredentials?) -> Bool) async throws
+        -> AntigravityOAuthCredentials?
+    {
+        for _ in 0..<100 {
+            let credentials = try store.load()
+            if predicate(credentials) {
+                return credentials
+            }
+            try await Task.sleep(nanoseconds: 10_000_000)
+        }
+        return try store.load()
     }
 }
diff --git a/Tests/CodexBarTests/SettingsStoreTests.swift b/Tests/CodexBarTests/SettingsStoreTests.swift
index 04ca555165..7785f655f8 100644
--- a/Tests/CodexBarTests/SettingsStoreTests.swift
+++ b/Tests/CodexBarTests/SettingsStoreTests.swift
@@ -4,11 +4,29 @@ import Observation
 import Testing
 @testable import CodexBar
 
+@Suite(.serialized)
 @MainActor
-@Suite
+// swiftlint:disable:next type_body_length
 struct SettingsStoreTests {
+    private final class ObservationFlag: @unchecked Sendable {
+        private let lock = NSLock()
+        private var value = false
+
+        func set() {
+            self.lock.lock()
+            self.value = true
+            self.lock.unlock()
+        }
+
+        func get() -> Bool {
+            self.lock.lock()
+            defer { self.lock.unlock() }
+            return self.value
+        }
+    }
+
     @Test
-    func defaultRefreshFrequencyIsFiveMinutes() throws {
+    func `default refresh frequency is five minutes`() throws {
         let suite = "SettingsStoreTests-default"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -22,10 +40,29 @@ struct SettingsStoreTests {
 
         #expect(store.refreshFrequency == .fiveMinutes)
         #expect(store.refreshFrequency.seconds == 300)
+        #expect(defaults.string(forKey: "refreshFrequency") == RefreshFrequency.fiveMinutes.rawValue)
+    }
+
+    @Test
+    func `repairs unrecognized refresh frequency raw value`() throws {
+        let suite = "SettingsStoreTests-invalid-refresh"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        defaults.set("legacyValue", forKey: "refreshFrequency")
+        let configStore = testConfigStore(suiteName: suite)
+
+        let store = SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        #expect(store.refreshFrequency == .fiveMinutes)
+        #expect(defaults.string(forKey: "refreshFrequency") == RefreshFrequency.fiveMinutes.rawValue)
     }
 
     @Test
-    func persistsRefreshFrequencyAcrossInstances() throws {
+    func `persists refresh frequency across instances`() throws {
         let suite = "SettingsStoreTests-persist"
         let defaultsA = try #require(UserDefaults(suiteName: suite))
         defaultsA.removePersistentDomain(forName: suite)
@@ -50,7 +87,159 @@ struct SettingsStoreTests {
     }
 
     @Test
-    func persistsSelectedMenuProviderAcrossInstances() throws {
+    func `weekly confetti setting defaults off and persists`() throws {
+        let suite = "SettingsStoreTests-weekly-confetti"
+        let defaultsA = try #require(UserDefaults(suiteName: suite))
+        defaultsA.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+        let storeA = SettingsStore(
+            userDefaults: defaultsA,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        #expect(storeA.confettiOnWeeklyLimitResetsEnabled == false)
+        storeA.confettiOnWeeklyLimitResetsEnabled = true
+
+        let defaultsB = try #require(UserDefaults(suiteName: suite))
+        let storeB = SettingsStore(
+            userDefaults: defaultsB,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        #expect(storeB.confettiOnWeeklyLimitResetsEnabled == true)
+    }
+
+    @Test
+    func `provider storage setting defaults off and persists`() throws {
+        let suite = "SettingsStoreTests-provider-storage"
+        let defaultsA = try #require(UserDefaults(suiteName: suite))
+        defaultsA.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+        let storeA = SettingsStore(
+            userDefaults: defaultsA,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        #expect(storeA.providerStorageFootprintsEnabled == false)
+        #expect(defaultsA.bool(forKey: "providerStorageFootprintsEnabled") == false)
+        storeA.providerStorageFootprintsEnabled = true
+
+        let defaultsB = try #require(UserDefaults(suiteName: suite))
+        let storeB = SettingsStore(
+            userDefaults: defaultsB,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        #expect(storeB.providerStorageFootprintsEnabled == true)
+    }
+
+    @Test
+    func `providers sorted alphabetically defaults off and persists`() throws {
+        let suite = "SettingsStoreTests-providers-sorted-alpha"
+        let defaultsA = try #require(UserDefaults(suiteName: suite))
+        defaultsA.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+        let storeA = SettingsStore(
+            userDefaults: defaultsA,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        #expect(storeA.providersSortedAlphabetically == false)
+        storeA.providersSortedAlphabetically = true
+
+        let defaultsB = try #require(UserDefaults(suiteName: suite))
+        let storeB = SettingsStore(
+            userDefaults: defaultsB,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        #expect(storeB.providersSortedAlphabetically == true)
+    }
+
+    @Test
+    func `alphabetical provider order puts enabled first then sorts by name`() {
+        let metadata = ProviderDescriptorRegistry.metadata
+        let enabled: Set<UsageProvider> = [.cursor, .claude, .codex]
+        let ordered = CodexBarConfig.alphabeticalProviderOrder(
+            enablement: { enabled.contains($0) })
+
+        #expect(Set(ordered) == Set(UsageProvider.allCases))
+
+        let displayName: (UsageProvider) -> String = { metadata[$0]?.displayName ?? $0.rawValue }
+        let enabledPart = ordered.filter { enabled.contains($0) }
+        let disabledPart = ordered.filter { !enabled.contains($0) }
+        // Enabled providers occupy the top of the list, ahead of every disabled provider.
+        #expect(Array(ordered.prefix(enabled.count)) == enabledPart)
+        #expect(ordered == enabledPart + disabledPart)
+        let isSortedByName: ([UsageProvider]) -> Bool = { group in
+            group == group.sorted {
+                displayName($0).localizedCaseInsensitiveCompare(displayName($1)) == .orderedAscending
+            }
+        }
+        #expect(isSortedByName(enabledPart))
+        #expect(isSortedByName(disabledPart))
+    }
+
+    @Test
+    func `provider changelog links setting defaults off and persists`() throws {
+        let suite = "SettingsStoreTests-provider-changelog-links"
+        let defaultsA = try #require(UserDefaults(suiteName: suite))
+        defaultsA.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+        let storeA = SettingsStore(
+            userDefaults: defaultsA,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        #expect(storeA.providerChangelogLinksEnabled == false)
+        #expect(defaultsA.bool(forKey: "providerChangelogLinksEnabled") == false)
+        storeA.providerChangelogLinksEnabled = true
+
+        let defaultsB = try #require(UserDefaults(suiteName: suite))
+        let storeB = SettingsStore(
+            userDefaults: defaultsB,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        #expect(storeB.providerChangelogLinksEnabled == true)
+    }
+
+    @Test
+    func `hide critters setting defaults off and persists`() throws {
+        let suite = "SettingsStoreTests-hide-critters"
+        let defaultsA = try #require(UserDefaults(suiteName: suite))
+        defaultsA.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+        let storeA = SettingsStore(
+            userDefaults: defaultsA,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        #expect(storeA.menuBarHidesCritters == false)
+        #expect(defaultsA.bool(forKey: "menuBarHidesCritters") == false)
+        storeA.menuBarHidesCritters = true
+
+        let defaultsB = try #require(UserDefaults(suiteName: suite))
+        let storeB = SettingsStore(
+            userDefaults: defaultsB,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        #expect(storeB.menuBarHidesCritters == true)
+    }
+
+    @Test
+    func `persists selected menu provider across instances`() throws {
         let suite = "SettingsStoreTests-selectedMenuProvider"
         let defaultsA = try #require(UserDefaults(suiteName: suite))
         defaultsA.removePersistentDomain(forName: suite)
@@ -74,7 +263,7 @@ struct SettingsStoreTests {
     }
 
     @Test
-    func persistsMergedMenuLastSelectedWasOverviewAcrossInstances() throws {
+    func `persists merged menu last selected was overview across instances`() throws {
         let suite = "SettingsStoreTests-merged-last-overview"
         let defaultsA = try #require(UserDefaults(suiteName: suite))
         defaultsA.removePersistentDomain(forName: suite)
@@ -98,7 +287,7 @@ struct SettingsStoreTests {
     }
 
     @Test
-    func mergedOverviewSelectedProvidersPersistsAndNormalizesAcrossInstances() throws {
+    func `merged overview selected providers persists and normalizes across instances`() throws {
         let suite = "SettingsStoreTests-merged-overview-selection"
         let defaultsA = try #require(UserDefaults(suiteName: suite))
         defaultsA.removePersistentDomain(forName: suite)
@@ -123,7 +312,7 @@ struct SettingsStoreTests {
     }
 
     @Test
-    func mergedOverviewSelectedProvidersIgnoresInvalidRawValues() throws {
+    func `merged overview selected providers ignores invalid raw values`() throws {
         let suite = "SettingsStoreTests-merged-overview-invalid-raw"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -139,7 +328,7 @@ struct SettingsStoreTests {
     }
 
     @Test
-    func resolvedMergedOverviewProvidersDefaultsToFirstThreeWhenSelectionEmpty() throws {
+    func `resolved merged overview providers defaults to first three when selection empty`() throws {
         let suite = "SettingsStoreTests-merged-overview-default-first-three"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -157,7 +346,7 @@ struct SettingsStoreTests {
     }
 
     @Test
-    func resolvedMergedOverviewProvidersHonorsExplicitEmptySelection() throws {
+    func `resolved merged overview providers honors explicit empty selection`() throws {
         let suite = "SettingsStoreTests-merged-overview-explicit-empty"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -176,7 +365,7 @@ struct SettingsStoreTests {
     }
 
     @Test
-    func resolvedMergedOverviewProvidersUsesProviderOrderNotSelectionOrder() throws {
+    func `resolved merged overview providers uses provider order not selection order`() throws {
         let suite = "SettingsStoreTests-merged-overview-order"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -195,7 +384,7 @@ struct SettingsStoreTests {
     }
 
     @Test
-    func reconcileMergedOverviewSelectionRemovesUnavailableWithoutAutoFill() throws {
+    func `reconcile merged overview selection removes unavailable without auto fill`() throws {
         let suite = "SettingsStoreTests-merged-overview-reconcile"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -216,7 +405,7 @@ struct SettingsStoreTests {
     }
 
     @Test
-    func reconcileMergedOverviewSelectionDoesNotClobberStoredPreferenceWhenThreeOrFewer() throws {
+    func `reconcile merged overview selection does not clobber stored preference when three or fewer`() throws {
         let suite = "SettingsStoreTests-merged-overview-three-or-fewer"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -237,7 +426,9 @@ struct SettingsStoreTests {
     }
 
     @Test
-    func reconcileMergedOverviewSelectionIgnoresStaleSubsetWithoutPersistingAutoFillWhenThreeOrFewer() throws {
+    func `reconcile merged overview selection ignores stale subset without persisting auto fill when three or fewer`()
+        throws
+    {
         let suite = "SettingsStoreTests-merged-overview-three-or-fewer-subset"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -258,7 +449,7 @@ struct SettingsStoreTests {
     }
 
     @Test
-    func mergedOverviewSelectionAllowsDeselectingProvidersWhenThreeOrFewer() throws {
+    func `merged overview selection allows deselecting providers when three or fewer`() throws {
         let suite = "SettingsStoreTests-merged-overview-deselect-three-or-fewer"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -282,7 +473,7 @@ struct SettingsStoreTests {
     }
 
     @Test
-    func mergedOverviewSelectionAppliesWhenSameActiveSetIsReordered() throws {
+    func `merged overview selection applies when same active set is reordered`() throws {
         let suite = "SettingsStoreTests-merged-overview-ordered-context"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -306,7 +497,7 @@ struct SettingsStoreTests {
     }
 
     @Test
-    func mergedOverviewSelectionAllowsDeselectingProvidersWhenMoreThanThreeActive() throws {
+    func `merged overview selection allows deselecting providers when more than three active`() throws {
         let suite = "SettingsStoreTests-merged-overview-deselect-subset"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -330,7 +521,7 @@ struct SettingsStoreTests {
     }
 
     @Test
-    func reconcileMergedOverviewSelectionPreservesStoredSubsetWhenActiveDropsToThreeOrFewer() throws {
+    func `reconcile merged overview selection preserves stored subset when active drops to three or fewer`() throws {
         let suite = "SettingsStoreTests-merged-overview-preserve-subset-across-drop"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -364,7 +555,7 @@ struct SettingsStoreTests {
     }
 
     @Test
-    func reconcileMergedOverviewSelectionClearsPreferenceWhenNoProvidersActive() throws {
+    func `reconcile merged overview selection clears preference when no providers active`() throws {
         let suite = "SettingsStoreTests-merged-overview-clear-on-empty-active"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -390,7 +581,7 @@ struct SettingsStoreTests {
     }
 
     @Test
-    func persistsOpenCodeWorkspaceIDAcrossInstances() throws {
+    func `persists open code workspace ID across instances`() throws {
         let suite = "SettingsStoreTests-opencode-workspace"
         let defaultsA = try #require(UserDefaults(suiteName: suite))
         defaultsA.removePersistentDomain(forName: suite)
@@ -412,7 +603,7 @@ struct SettingsStoreTests {
     }
 
     @Test
-    func defaultsSessionQuotaNotificationsToEnabled() throws {
+    func `defaults session quota notifications to enabled`() throws {
         let key = "sessionQuotaNotificationsEnabled"
         let suite = "SettingsStoreTests-sessionQuotaNotifications"
         let defaults = try #require(UserDefaults(suiteName: suite))
@@ -428,7 +619,145 @@ struct SettingsStoreTests {
     }
 
     @Test
-    func defaultsClaudeUsageSourceToAuto() throws {
+    func `defaults quota warnings to disabled with global thresholds and sound`() throws {
+        let suite = "SettingsStoreTests-quota-warning-defaults"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+        let store = SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        #expect(store.quotaWarningNotificationsEnabled == false)
+        #expect(store.quotaWarningThresholds == [50, 20])
+        #expect(store.quotaWarningWindowEnabled(.session) == true)
+        #expect(store.quotaWarningWindowEnabled(.weekly) == true)
+        #expect(store.quotaWarningSoundEnabled == true)
+        #expect(store.quotaWarningMarkersVisible == true)
+        #expect(defaults.array(forKey: "quotaWarningThresholds") as? [Int] == [50, 20])
+        #expect(defaults.object(forKey: "quotaWarningSessionEnabled") as? Bool == true)
+        #expect(defaults.object(forKey: "quotaWarningWeeklyEnabled") as? Bool == true)
+        #expect(defaults.bool(forKey: "quotaWarningSoundEnabled") == true)
+        #expect(defaults.object(forKey: "quotaWarningMarkersVisible") as? Bool == true)
+    }
+
+    @Test
+    func `global quota warning windows persist independently`() throws {
+        let suite = "SettingsStoreTests-quota-warning-window-enabled"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+        let store = SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        store.setQuotaWarningWindowEnabled(.weekly, enabled: false)
+
+        #expect(store.quotaWarningWindowEnabled(.session) == true)
+        #expect(store.quotaWarningWindowEnabled(.weekly) == false)
+        #expect(defaults.object(forKey: "quotaWarningWeeklyEnabled") as? Bool == false)
+    }
+
+    @Test
+    func `sanitizes invalid quota warning thresholds from defaults`() throws {
+        let suite = "SettingsStoreTests-quota-warning-sanitize"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        defaults.set([120, 20, 20, -5, 50], forKey: "quotaWarningThresholds")
+        let configStore = testConfigStore(suiteName: suite)
+        let store = SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        #expect(store.quotaWarningThresholds == [99, 50, 20, 0])
+        #expect(defaults.array(forKey: "quotaWarningThresholds") as? [Int] == [99, 50, 20, 0])
+    }
+
+    @Test
+    func `quota warning threshold pair resolves blanks and clamps bounds`() {
+        #expect(QuotaWarningThresholds.resolved(upper: nil, lower: nil) == [50, 20])
+        #expect(QuotaWarningThresholds.resolved(upper: nil, lower: 10) == [50, 10])
+        #expect(QuotaWarningThresholds.resolved(upper: 10, lower: nil) == [10, 0])
+        #expect(QuotaWarningThresholds.resolved(upper: 120, lower: -5) == [99, 0])
+    }
+
+    @Test
+    func `provider quota warning override resolves before global thresholds`() throws {
+        let suite = "SettingsStoreTests-quota-warning-provider-override"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+        let store = SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        store.quotaWarningThresholds = [50, 20]
+
+        #expect(store.resolvedQuotaWarningThresholds(provider: .codex, window: .session) == [50, 20])
+        store.setQuotaWarningThresholds(provider: .codex, window: .session, thresholds: [10])
+        #expect(store.resolvedQuotaWarningThresholds(provider: .codex, window: .session) == [10])
+        #expect(store.resolvedQuotaWarningThresholds(provider: .codex, window: .weekly) == [50, 20])
+
+        store.setQuotaWarningThresholds(provider: .codex, window: .session, thresholds: nil)
+        #expect(store.resolvedQuotaWarningThresholds(provider: .codex, window: .session) == [50, 20])
+    }
+
+    @Test
+    func `global quota warning thresholds resolve independently by window`() throws {
+        let suite = "SettingsStoreTests-quota-warning-window-thresholds"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+        let store = SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        store.setQuotaWarningThresholds(.session, thresholds: [25])
+        store.setQuotaWarningThresholds(.weekly, thresholds: [75, 10])
+
+        #expect(store.quotaWarningThresholds(.session) == [25])
+        #expect(store.quotaWarningThresholds(.weekly) == [75, 10])
+        #expect(store.resolvedQuotaWarningThresholds(provider: .codex, window: .session) == [25])
+        #expect(store.resolvedQuotaWarningThresholds(provider: .codex, window: .weekly) == [75, 10])
+    }
+
+    @Test
+    func `provider quota warning windows override global enablement independently`() throws {
+        let suite = "SettingsStoreTests-quota-warning-provider-window-override"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+        let store = SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        store.setQuotaWarningWindowEnabled(.weekly, enabled: false)
+        #expect(store.quotaWarningEnabled(provider: .codex, window: .weekly) == false)
+
+        store.setQuotaWarningWindowEnabled(provider: .codex, window: .weekly, enabled: true)
+        store.setQuotaWarningWindowEnabled(provider: .codex, window: .session, enabled: false)
+        #expect(store.quotaWarningEnabled(provider: .codex, window: .weekly) == true)
+        #expect(store.quotaWarningEnabled(provider: .codex, window: .session) == false)
+        #expect(store.hasQuotaWarningOverride(provider: .codex, window: .weekly) == true)
+        #expect(store.hasQuotaWarningOverride(provider: .codex, window: .session) == true)
+
+        store.setQuotaWarningWindowEnabled(provider: .codex, window: .weekly, enabled: nil)
+        #expect(store.quotaWarningEnabled(provider: .codex, window: .weekly) == false)
+    }
+
+    @Test
+    func `defaults claude usage source to auto`() throws {
         let suite = "SettingsStoreTests-claude-source"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -444,7 +773,7 @@ struct SettingsStoreTests {
     }
 
     @Test
-    func defaultsCodexUsageSourceToAuto() throws {
+    func `defaults codex usage source to auto`() throws {
         let suite = "SettingsStoreTests-codex-source"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -460,7 +789,7 @@ struct SettingsStoreTests {
     }
 
     @Test
-    func defaultsKiloUsageSourceToAuto() throws {
+    func `defaults kilo usage source to auto`() throws {
         let suite = "SettingsStoreTests-kilo-source"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -476,7 +805,7 @@ struct SettingsStoreTests {
     }
 
     @Test
-    func persistsKiloUsageSourceAcrossInstances() throws {
+    func `persists kilo usage source across instances`() throws {
         let suite = "SettingsStoreTests-kilo-source-persist"
         let defaultsA = try #require(UserDefaults(suiteName: suite))
         defaultsA.removePersistentDomain(forName: suite)
@@ -500,7 +829,7 @@ struct SettingsStoreTests {
     }
 
     @Test
-    func kiloExtrasOnlyApplyInAutoMode() throws {
+    func `kilo extras only apply in auto mode`() throws {
         let suite = "SettingsStoreTests-kilo-extras"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -523,7 +852,7 @@ struct SettingsStoreTests {
 
     @Test
     @MainActor
-    func applyExternalConfigDoesNotBroadcast() throws {
+    func `apply external config does not broadcast`() throws {
         let suite = "SettingsStoreTests-external-config"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -567,7 +896,7 @@ struct SettingsStoreTests {
     }
 
     @Test
-    func persistsZaiAPIRegionAcrossInstances() throws {
+    func `persists zai API region across instances`() throws {
         let suite = "SettingsStoreTests-zai-region"
         let defaultsA = try #require(UserDefaults(suiteName: suite))
         defaultsA.removePersistentDomain(forName: suite)
@@ -589,7 +918,7 @@ struct SettingsStoreTests {
     }
 
     @Test
-    func persistsMiniMaxAPIRegionAcrossInstances() throws {
+    func `persists mini max API region across instances`() throws {
         let suite = "SettingsStoreTests-minimax-region"
         let defaultsA = try #require(UserDefaults(suiteName: suite))
         defaultsA.removePersistentDomain(forName: suite)
@@ -611,13 +940,86 @@ struct SettingsStoreTests {
     }
 
     @Test
-    func defaultsOpenAIWebAccessToEnabled() throws {
+    func `defaults open AI web access to disabled`() throws {
         let suite = "SettingsStoreTests-openai-web"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
         defaults.set(false, forKey: "debugDisableKeychainAccess")
         let configStore = testConfigStore(suiteName: suite)
 
+        let store = SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        #expect(store.openAIWebAccessEnabled == false)
+        #expect(defaults.bool(forKey: "openAIWebAccessEnabled") == false)
+        #expect(store.openAIWebBatterySaverEnabled == false)
+        #expect(defaults.bool(forKey: "openAIWebBatterySaverEnabled") == false)
+        #expect(store.codexCookieSource == .off)
+    }
+
+    @Test
+    func `infers open AI web access enabled for legacy configured codex cookies`() throws {
+        let suite = "SettingsStoreTests-openai-web-legacy"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        defaults.removeObject(forKey: "openAIWebAccessEnabled")
+        defaults.set(false, forKey: "debugDisableKeychainAccess")
+        let configStore = testConfigStore(suiteName: suite)
+        try configStore.save(CodexBarConfig(providers: [
+            ProviderConfig(id: .codex, cookieSource: .auto),
+        ]))
+
+        let store = SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        #expect(store.openAIWebAccessEnabled == true)
+        #expect(defaults.bool(forKey: "openAIWebAccessEnabled") == true)
+        #expect(store.openAIWebBatterySaverEnabled == false)
+        #expect(defaults.bool(forKey: "openAIWebBatterySaverEnabled") == false)
+        #expect(store.codexCookieSource == .auto)
+    }
+
+    @Test
+    func `imports legacy open AI web access defaults key`() throws {
+        let suite = "SettingsStoreTests-openai-web-legacy-key"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        defaults.removeObject(forKey: "openAIWebAccessEnabled")
+        defaults.set(false, forKey: "openAIWebAccess")
+        defaults.set(false, forKey: "debugDisableKeychainAccess")
+        let configStore = testConfigStore(suiteName: suite)
+        try configStore.save(CodexBarConfig(providers: [
+            ProviderConfig(id: .codex, cookieSource: .auto),
+        ]))
+
+        let store = SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        #expect(store.openAIWebAccessEnabled == false)
+        #expect(defaults.bool(forKey: "openAIWebAccessEnabled") == false)
+    }
+
+    @Test
+    func `infers open AI web access enabled for legacy codex config with implicit auto cookies`() throws {
+        let suite = "SettingsStoreTests-openai-web-legacy-implicit-auto"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        defaults.removeObject(forKey: "openAIWebAccessEnabled")
+        defaults.set(false, forKey: "debugDisableKeychainAccess")
+        let configStore = testConfigStore(suiteName: suite)
+        try configStore.save(CodexBarConfig(providers: [
+            ProviderConfig(id: .codex),
+        ]))
+
         let store = SettingsStore(
             userDefaults: defaults,
             configStore: configStore,
@@ -626,11 +1028,62 @@ struct SettingsStoreTests {
 
         #expect(store.openAIWebAccessEnabled == true)
         #expect(defaults.bool(forKey: "openAIWebAccessEnabled") == true)
+        #expect(store.openAIWebBatterySaverEnabled == false)
+        #expect(defaults.bool(forKey: "openAIWebBatterySaverEnabled") == false)
+        #expect(store.codexCookieSource == .auto)
+    }
+
+    @Test
+    func `disabling open AI web access turns codex cookie source off`() throws {
+        let suite = "SettingsStoreTests-openai-web-toggle"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        defaults.set(false, forKey: "debugDisableKeychainAccess")
+        let configStore = testConfigStore(suiteName: suite)
+
+        let store = SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        store.codexCookieSource = .auto
+        #expect(store.codexCookieSource == .auto)
+
+        store.openAIWebAccessEnabled = false
+        #expect(store.codexCookieSource == .off)
+        #expect(defaults.bool(forKey: "openAIWebAccessEnabled") == false)
+
+        store.openAIWebAccessEnabled = true
         #expect(store.codexCookieSource == .auto)
+        #expect(defaults.bool(forKey: "openAIWebAccessEnabled") == true)
+    }
+
+    @Test
+    func `open AI web battery saver persists separately from extras availability`() throws {
+        let suite = "SettingsStoreTests-openai-web-battery-saver"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        defaults.set(false, forKey: "debugDisableKeychainAccess")
+        let configStore = testConfigStore(suiteName: suite)
+
+        let store = SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        #expect(store.openAIWebBatterySaverEnabled == false)
+
+        store.openAIWebBatterySaverEnabled = false
+        #expect(defaults.bool(forKey: "openAIWebBatterySaverEnabled") == false)
+
+        store.openAIWebAccessEnabled = true
+        #expect(store.openAIWebBatterySaverEnabled == false)
     }
 
     @Test
-    func menuObservationTokenUpdatesOnDefaultsChange() async throws {
+    func `menu observation token updates on defaults change`() async throws {
         let suite = "SettingsStoreTests-observation-defaults"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -642,24 +1095,111 @@ struct SettingsStoreTests {
             zaiTokenStore: NoopZaiTokenStore(),
             syntheticTokenStore: NoopSyntheticTokenStore())
 
-        var didChange = false
+        let didChange = ObservationFlag()
 
         withObservationTracking {
             _ = store.menuObservationToken
         } onChange: {
-            Task { @MainActor in
-                didChange = true
-            }
+            didChange.set()
         }
 
         store.statusChecksEnabled.toggle()
         try? await Task.sleep(nanoseconds: 50_000_000)
 
-        #expect(didChange == true)
+        #expect(didChange.get() == true)
+    }
+
+    @Test
+    func `menu observation token ignores merged switcher selection churn`() async throws {
+        let suite = "SettingsStoreTests-observation-switcher-selection"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+
+        let store = SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        let didChange = ObservationFlag()
+
+        withObservationTracking {
+            _ = store.menuObservationToken
+        } onChange: {
+            didChange.set()
+        }
+
+        store.selectedMenuProvider = .claude
+        store.mergedMenuLastSelectedWasOverview.toggle()
+        try? await Task.sleep(nanoseconds: 50_000_000)
+
+        #expect(didChange.get() == false)
+    }
+
+    @Test
+    func `menu observation token updates on per-window quota threshold changes`() async throws {
+        let suite = "SettingsStoreTests-observation-quota-threshold-windows"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+
+        let store = SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        func expectObservation(
+            for window: QuotaWarningWindow,
+            thresholds: [Int]) async
+        {
+            let didChange = ObservationFlag()
+            withObservationTracking {
+                _ = store.menuObservationToken
+            } onChange: {
+                didChange.set()
+            }
+
+            store.setQuotaWarningThresholds(window, thresholds: thresholds)
+            try? await Task.sleep(nanoseconds: 50_000_000)
+
+            #expect(didChange.get() == true)
+        }
+
+        await expectObservation(for: .session, thresholds: [70, 30])
+        await expectObservation(for: .weekly, thresholds: [80, 40])
+    }
+
+    @Test
+    func `menu observation token updates on weekly progress work days changes`() async throws {
+        let suite = "SettingsStoreTests-observation-weekly-progress-work-days"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+
+        let store = SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        let didChange = ObservationFlag()
+
+        withObservationTracking {
+            _ = store.menuObservationToken
+        } onChange: {
+            didChange.set()
+        }
+
+        store.weeklyProgressWorkDays = 5
+        try? await Task.sleep(nanoseconds: 50_000_000)
+
+        #expect(didChange.get() == true)
     }
 
     @Test
-    func configBackedSettingsTriggerObservation() async throws {
+    func `config backed settings trigger observation`() async throws {
         let suite = "SettingsStoreTests-observation-config"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -671,24 +1211,49 @@ struct SettingsStoreTests {
             zaiTokenStore: NoopZaiTokenStore(),
             syntheticTokenStore: NoopSyntheticTokenStore())
 
-        var didChange = false
+        let didChange = ObservationFlag()
 
         withObservationTracking {
             _ = store.codexCookieSource
         } onChange: {
-            Task { @MainActor in
-                didChange = true
-            }
+            didChange.set()
         }
 
         store.codexCookieSource = .manual
         try? await Task.sleep(nanoseconds: 50_000_000)
 
-        #expect(didChange == true)
+        #expect(didChange.get() == true)
+    }
+
+    @Test
+    func `menu observation token updates on codex active source change`() async throws {
+        let suite = "SettingsStoreTests-observation-codex-active-source"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+
+        let store = SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        let didChange = ObservationFlag()
+
+        withObservationTracking {
+            _ = store.menuObservationToken
+        } onChange: {
+            didChange.set()
+        }
+
+        store.codexActiveSource = .liveSystem
+        try? await Task.sleep(nanoseconds: 50_000_000)
+
+        #expect(didChange.get() == true)
     }
 
     @Test
-    func providerOrder_defaultsToAllCases() throws {
+    func `provider order defaults to all cases`() throws {
         let suite = "SettingsStoreTests-providerOrder-default"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -704,7 +1269,7 @@ struct SettingsStoreTests {
     }
 
     @Test
-    func providerOrder_persistsAndAppendsNewProviders() throws {
+    func `provider order persists and appends new providers`() throws {
         let suite = "SettingsStoreTests-providerOrder-persist"
         let defaultsA = try #require(UserDefaults(suiteName: suite))
         defaultsA.removePersistentDomain(forName: suite)
@@ -723,30 +1288,9 @@ struct SettingsStoreTests {
             zaiTokenStore: NoopZaiTokenStore(),
             syntheticTokenStore: NoopSyntheticTokenStore())
 
-        #expect(storeA.orderedProviders() == [
-            .gemini,
-            .codex,
-            .claude,
-            .cursor,
-            .opencode,
-            .factory,
-            .antigravity,
-            .copilot,
-            .zai,
-            .minimax,
-            .kimi,
-            .kilo,
-            .kiro,
-            .vertexai,
-            .augment,
-            .jetbrains,
-            .kimik2,
-            .amp,
-            .ollama,
-            .synthetic,
-            .warp,
-            .openrouter,
-        ])
+        let legacyOrder: [UsageProvider] = [.gemini, .codex]
+        let appendedProviders = UsageProvider.allCases.filter { !legacyOrder.contains($0) }
+        #expect(storeA.orderedProviders() == legacyOrder + appendedProviders)
 
         // Move one provider; ensure it's persisted across instances.
         let antigravityIndex = try #require(storeA.orderedProviders().firstIndex(of: .antigravity))
@@ -761,4 +1305,47 @@ struct SettingsStoreTests {
 
         #expect(storeB.orderedProviders().first == .antigravity)
     }
+
+    @Test
+    func `setting alibaba API key enables provider`() throws {
+        let suite = "SettingsStoreTests-alibaba-enable-on-token"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+
+        let store = SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        let metadata = try #require(ProviderDescriptorRegistry.metadata[.alibaba])
+        store.setProviderEnabled(provider: .alibaba, metadata: metadata, enabled: false)
+
+        store.alibabaCodingPlanAPIToken = "cpk-test-token"
+
+        #expect(store.isProviderEnabled(provider: .alibaba, metadata: metadata))
+    }
+
+    @Test
+    func `alibaba provider auto enables on startup when token exists`() throws {
+        let suite = "SettingsStoreTests-alibaba-auto-enable-startup"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+
+        let config = CodexBarConfig(providers: [
+            ProviderConfig(id: .alibaba, enabled: false, apiKey: "cpk-startup-token"),
+        ])
+        try configStore.save(config)
+
+        let store = SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+
+        let metadata = try #require(ProviderDescriptorRegistry.metadata[.alibaba])
+        #expect(store.isProviderEnabled(provider: .alibaba, metadata: metadata))
+    }
 }
diff --git a/Tests/CodexBarTests/SettingsWindowAppearanceTests.swift b/Tests/CodexBarTests/SettingsWindowAppearanceTests.swift
new file mode 100644
index 0000000000..79bbdebd0a
--- /dev/null
+++ b/Tests/CodexBarTests/SettingsWindowAppearanceTests.swift
@@ -0,0 +1,66 @@
+import AppKit
+import SwiftUI
+import Testing
+@testable import CodexBar
+
+@MainActor
+struct SettingsWindowAppearanceTests {
+    @Test
+    func `bridge pulses exact effective appearance then restores inheritance`() {
+        let application = NSApplication.shared
+        let effectiveAppearance = application.effectiveAppearance
+        let staleSource = NSView()
+        staleSource.appearance = NSAppearance(named: .aqua)
+        let resetCapture = ResetCapture()
+        let bridge = SettingsWindowAppearanceView { resetCapture.actions.append($0) }
+
+        let window = NSWindow(
+            contentRect: NSRect(x: 0, y: 0, width: 400, height: 300),
+            styleMask: [.titled],
+            backing: .buffered,
+            defer: false)
+        window.appearance = NSAppearance(named: .aqua)
+        window.appearanceSource = staleSource
+        window.contentView = bridge
+
+        let pulseMatchesEffectiveAppearance = window.appearance === effectiveAppearance
+        let sourceIsApplication = (window.appearanceSource as AnyObject?) === application
+        #expect(pulseMatchesEffectiveAppearance)
+        #expect(sourceIsApplication)
+        #expect(resetCapture.actions.count == 1)
+
+        resetCapture.actions[0]()
+
+        #expect(window.appearance == nil)
+        #expect(window.viewsNeedDisplay)
+    }
+
+    @Test
+    func `repeated theme updates cannot leave an explicit appearance`() {
+        let resetCapture = ResetCapture()
+        let bridge = SettingsWindowAppearanceView { resetCapture.actions.append($0) }
+        let window = NSWindow(
+            contentRect: NSRect(x: 0, y: 0, width: 400, height: 300),
+            styleMask: [.titled],
+            backing: .buffered,
+            defer: false)
+        window.contentView = bridge
+
+        bridge.refreshWindowAppearance(for: .light)
+        bridge.refreshWindowAppearance(for: .light)
+        bridge.refreshWindowAppearance(for: .dark)
+        #expect(resetCapture.actions.count == 3)
+        for action in resetCapture.actions {
+            action()
+        }
+
+        let sourceIsApplication = (window.appearanceSource as AnyObject?) === NSApplication.shared
+        #expect(window.appearance == nil)
+        #expect(sourceIsApplication)
+    }
+}
+
+@MainActor
+private final class ResetCapture {
+    var actions: [SettingsWindowAppearance.ResetAction] = []
+}
diff --git a/Tests/CodexBarTests/SpawnedProcessGroupTests.swift b/Tests/CodexBarTests/SpawnedProcessGroupTests.swift
new file mode 100644
index 0000000000..f0906bfb6d
--- /dev/null
+++ b/Tests/CodexBarTests/SpawnedProcessGroupTests.swift
@@ -0,0 +1,604 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+#if canImport(Darwin)
+import Darwin
+#else
+import Glibc
+#endif
+
+struct SpawnedProcessGroupTests {
+    @Test
+    func `pipe cleanup preserves standard descriptors`() {
+        let descriptors = SpawnedProcessGroup.pipeDescriptorsToClose([0, 1, 2, 3, 4, 3])
+
+        #expect(descriptors == [3, 4])
+    }
+
+    @Test
+    func `musl close-from selects numeric descriptors at or above minimum`() throws {
+        let descriptors = try PosixSpawnFileActionsCloseFrom.descriptorsToClose(startingAt: 4) { path in
+            #expect(path == "/proc/self/fd")
+            return ["8", "cwd", "3", "4"]
+        }
+
+        #expect(descriptors == [4, 8])
+    }
+
+    @Test
+    func `musl close-from fails when descriptor enumeration fails`() {
+        #expect(throws: PosixSpawnFileActionsCloseFrom.CloseFromError.self) {
+            try PosixSpawnFileActionsCloseFrom.descriptorsToClose(startingAt: 3) { _ in
+                throw CocoaError(.fileReadNoPermission)
+            }
+        }
+    }
+
+    @Test
+    func `launch captures child output`() async throws {
+        let stdoutPipe = Pipe()
+        let stderrPipe = Pipe()
+        let stdoutCapture = ProcessPipeCapture(pipe: stdoutPipe)
+        let stderrCapture = ProcessPipeCapture(pipe: stderrPipe)
+        stdoutCapture.start()
+        stderrCapture.start()
+
+        let process = try SpawnedProcessGroup.launch(
+            binary: "/bin/sh",
+            arguments: ["-c", "printf stdout-value; printf stderr-value >&2"],
+            environment: ProcessInfo.processInfo.environment,
+            stdoutPipe: stdoutPipe,
+            stderrPipe: stderrPipe)
+        while process.isRunning {
+            try await Task.sleep(for: .milliseconds(20))
+        }
+        await process.terminateResidualProcesses()
+        await process.finish()
+
+        async let stdout = stdoutCapture.finish(timeout: .seconds(1))
+        async let stderr = stderrCapture.finish(timeout: .seconds(1))
+        let output = await (stdout, stderr)
+
+        #expect(process.terminationStatus == 0)
+        #expect(String(data: output.0, encoding: .utf8) == "stdout-value")
+        #expect(String(data: output.1, encoding: .utf8) == "stderr-value")
+    }
+
+    @Test
+    func `launch closes unrelated parent descriptors`() async throws {
+        let sourceFD = open("/dev/null", O_RDONLY)
+        let inheritedFD = fcntl(sourceFD, F_DUPFD, 200)
+        close(sourceFD)
+        let resolvedFD = try #require(inheritedFD >= 200 ? inheritedFD : nil)
+        defer { close(resolvedFD) }
+        _ = fcntl(resolvedFD, F_SETFD, 0)
+
+        #if canImport(Darwin)
+        let descriptorPath = "/dev/fd/\(resolvedFD)"
+        #else
+        let descriptorPath = "/proc/self/fd/\(resolvedFD)"
+        #endif
+        let stdoutPipe = Pipe()
+        let stderrPipe = Pipe()
+        let process = try SpawnedProcessGroup.launch(
+            binary: "/bin/sh",
+            arguments: ["-c", "test ! -e \(descriptorPath)"],
+            environment: ProcessInfo.processInfo.environment,
+            stdoutPipe: stdoutPipe,
+            stderrPipe: stderrPipe)
+
+        while process.isRunning {
+            try await Task.sleep(for: .milliseconds(20))
+        }
+        await process.terminateResidualProcesses()
+        await process.finish()
+
+        #expect(process.terminationStatus == 0)
+    }
+
+    @Test
+    func `termination waits for grace before killing escaped descendants`() async throws {
+        let childPIDFile = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-process-group-\(UUID().uuidString).pid")
+        defer { try? FileManager.default.removeItem(at: childPIDFile) }
+
+        let script = """
+        import subprocess
+        import sys
+        import time
+
+        child = subprocess.Popen(
+            [
+                sys.executable,
+                "-c",
+                "import signal,time; signal.signal(signal.SIGTERM, signal.SIG_IGN); time.sleep(30)",
+            ],
+            start_new_session=True,
+        )
+        with open(sys.argv[1], "w") as handle:
+            handle.write(str(child.pid))
+        time.sleep(30)
+        """
+        let stdoutPipe = Pipe()
+        let stderrPipe = Pipe()
+        let process = try SpawnedProcessGroup.launch(
+            binary: "/usr/bin/python3",
+            arguments: ["-c", script, childPIDFile.path],
+            environment: ProcessInfo.processInfo.environment,
+            stdoutPipe: stdoutPipe,
+            stderrPipe: stderrPipe)
+
+        var childPID: pid_t?
+        for _ in 0..<500 {
+            if let text = try? String(contentsOf: childPIDFile, encoding: .utf8),
+               let parsedPID = pid_t(text.trimmingCharacters(in: .whitespacesAndNewlines))
+            {
+                childPID = parsedPID
+                break
+            }
+            try await Task.sleep(for: .milliseconds(20))
+        }
+        guard let escapedPID = childPID else {
+            await process.terminate(grace: 0)
+            Issue.record("Timed out waiting for escaped child PID")
+            return
+        }
+        defer { _ = kill(escapedPID, SIGKILL) }
+
+        let start = Date()
+        await process.terminate(grace: 0.3)
+        let elapsed = Date().timeIntervalSince(start)
+
+        #expect(elapsed >= 0.25, "Termination should honor the grace period before SIGKILL")
+        #expect(kill(escapedPID, 0) == -1)
+    }
+
+    @Test
+    func `termination kills reparented process group members after root exit`() async throws {
+        let childPIDFile = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-process-group-member-\(UUID().uuidString).pid")
+        defer { try? FileManager.default.removeItem(at: childPIDFile) }
+
+        let script = """
+        import os
+        import signal
+        import sys
+        import time
+
+        intermediate = os.fork()
+        if intermediate == 0:
+            child = os.fork()
+            if child > 0:
+                os._exit(0)
+            os.close(1)
+            os.close(2)
+            signal.signal(signal.SIGTERM, signal.SIG_IGN)
+            with open(sys.argv[1], "w") as handle:
+                handle.write(str(os.getpid()))
+            time.sleep(30)
+            os._exit(0)
+
+        os.waitpid(intermediate, 0)
+        time.sleep(30)
+        """
+        let stdoutPipe = Pipe()
+        let stderrPipe = Pipe()
+        let process = try SpawnedProcessGroup.launch(
+            binary: "/usr/bin/python3",
+            arguments: ["-c", script, childPIDFile.path],
+            environment: ProcessInfo.processInfo.environment,
+            stdoutPipe: stdoutPipe,
+            stderrPipe: stderrPipe)
+
+        var childPID: pid_t?
+        for _ in 0..<100 {
+            if let text = try? String(contentsOf: childPIDFile, encoding: .utf8),
+               let parsedPID = pid_t(text.trimmingCharacters(in: .whitespacesAndNewlines))
+            {
+                childPID = parsedPID
+                break
+            }
+            try await Task.sleep(for: .milliseconds(20))
+        }
+        let reparentedPID = try #require(childPID)
+        defer { _ = kill(reparentedPID, SIGKILL) }
+
+        await process.terminate(grace: 0.2)
+
+        #expect(kill(reparentedPID, 0) == -1)
+    }
+
+    @Test
+    func `termination gives reparented process group members grace`() async throws {
+        let childPIDFile = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-process-group-grace-\(UUID().uuidString).pid")
+        let termReceivedFile = childPIDFile.appendingPathExtension("term")
+        let gracefulExitFile = childPIDFile.appendingPathExtension("graceful")
+        defer {
+            try? FileManager.default.removeItem(at: childPIDFile)
+            try? FileManager.default.removeItem(at: termReceivedFile)
+            try? FileManager.default.removeItem(at: gracefulExitFile)
+        }
+
+        let script = """
+        import os
+        import signal
+        import sys
+        import time
+
+        intermediate = os.fork()
+        if intermediate == 0:
+            child = os.fork()
+            if child > 0:
+                os._exit(0)
+            os.close(1)
+            os.close(2)
+            def handle_term(_signal, _frame):
+                with open(sys.argv[2], "w") as handle:
+                    handle.write("term")
+                time.sleep(0.1)
+                with open(sys.argv[3], "w") as handle:
+                    handle.write("graceful")
+                os._exit(0)
+            signal.signal(signal.SIGTERM, handle_term)
+            signal.pthread_sigmask(signal.SIG_UNBLOCK, {signal.SIGTERM})
+            with open(sys.argv[1], "w") as handle:
+                handle.write(str(os.getpid()))
+            time.sleep(30)
+            os._exit(0)
+
+        os.waitpid(intermediate, 0)
+        time.sleep(30)
+        """
+        let stdoutPipe = Pipe()
+        let stderrPipe = Pipe()
+        let process = try SpawnedProcessGroup.launch(
+            binary: "/usr/bin/python3",
+            arguments: ["-c", script, childPIDFile.path, termReceivedFile.path, gracefulExitFile.path],
+            environment: ProcessInfo.processInfo.environment,
+            stdoutPipe: stdoutPipe,
+            stderrPipe: stderrPipe)
+
+        var childPID: pid_t?
+        for _ in 0..<100 {
+            if let text = try? String(contentsOf: childPIDFile, encoding: .utf8),
+               let parsedPID = pid_t(text.trimmingCharacters(in: .whitespacesAndNewlines))
+            {
+                childPID = parsedPID
+                break
+            }
+            try await Task.sleep(for: .milliseconds(20))
+        }
+        let reparentedPID = try #require(childPID)
+        defer { _ = kill(reparentedPID, SIGKILL) }
+        for _ in 0..<100
+            where TTYProcessTreeTerminator.descendantPIDs(of: process.pid).contains(reparentedPID)
+        {
+            try await Task.sleep(for: .milliseconds(20))
+        }
+        #expect(!TTYProcessTreeTerminator.descendantPIDs(of: process.pid).contains(reparentedPID))
+        #expect(getpgid(reparentedPID) == process.processGroup)
+
+        await process.terminate(grace: 0.3)
+
+        #expect(FileManager.default.fileExists(atPath: termReceivedFile.path))
+        #expect(FileManager.default.fileExists(atPath: gracefulExitFile.path))
+        #expect(kill(reparentedPID, 0) == -1)
+    }
+
+    @Test
+    func `residual termination cleans same group helpers spawned during SIGTERM`() async throws {
+        let readyFile = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-process-group-term-\(UUID().uuidString).ready")
+        let childPIDFile = readyFile.appendingPathExtension("pid")
+        let heartbeatFile = readyFile.appendingPathExtension("heartbeat")
+        defer {
+            try? FileManager.default.removeItem(at: readyFile)
+            try? FileManager.default.removeItem(at: childPIDFile)
+            try? FileManager.default.removeItem(at: heartbeatFile)
+        }
+
+        let script = """
+        import os
+        import signal
+        import sys
+        import time
+
+        def handle_term(_signal, _frame):
+            reader, writer = os.pipe()
+            child = os.fork()
+            if child == 0:
+                os.close(reader)
+                os.close(1)
+                os.close(2)
+                signal.signal(signal.SIGTERM, signal.SIG_IGN)
+                with open(sys.argv[2], "w") as handle:
+                    handle.write(str(os.getpid()))
+                with open(sys.argv[3], "w") as heartbeat:
+                    heartbeat.write("1")
+                    heartbeat.flush()
+                    os.write(writer, b"1")
+                    os.close(writer)
+                    counter = 1
+                    while True:
+                        counter += 1
+                        heartbeat.seek(0)
+                        heartbeat.write(str(counter))
+                        heartbeat.truncate()
+                        heartbeat.flush()
+                        time.sleep(0.02)
+            os.close(writer)
+            os.read(reader, 1)
+            os.close(reader)
+            os._exit(0)
+
+        signal.signal(signal.SIGTERM, handle_term)
+        signal.pthread_sigmask(signal.SIG_UNBLOCK, {signal.SIGTERM})
+        with open(sys.argv[1], "w") as handle:
+            handle.write("ready")
+        time.sleep(30)
+        """
+        let stdoutPipe = Pipe()
+        let stderrPipe = Pipe()
+        let process = try SpawnedProcessGroup.launch(
+            binary: "/usr/bin/python3",
+            arguments: ["-c", script, readyFile.path, childPIDFile.path, heartbeatFile.path],
+            environment: ProcessInfo.processInfo.environment,
+            stdoutPipe: stdoutPipe,
+            stderrPipe: stderrPipe)
+
+        for _ in 0..<100 where !FileManager.default.fileExists(atPath: readyFile.path) {
+            try await Task.sleep(for: .milliseconds(20))
+        }
+        #expect(FileManager.default.fileExists(atPath: readyFile.path))
+
+        await process.terminateResidualProcesses(grace: 0.2)
+        await process.finish()
+
+        var childPID: pid_t?
+        for _ in 0..<100 {
+            if let text = try? String(contentsOf: childPIDFile, encoding: .utf8),
+               let parsedPID = pid_t(text.trimmingCharacters(in: .whitespacesAndNewlines))
+            {
+                childPID = parsedPID
+                break
+            }
+            try await Task.sleep(for: .milliseconds(20))
+        }
+        let resolvedChildPID = try #require(childPID)
+        defer { _ = kill(resolvedChildPID, SIGKILL) }
+        let heartbeatAfterCleanup = try String(contentsOf: heartbeatFile, encoding: .utf8)
+        try await Task.sleep(for: .milliseconds(200))
+        let heartbeatAfterSettle = try String(contentsOf: heartbeatFile, encoding: .utf8)
+        #expect(heartbeatAfterSettle == heartbeatAfterCleanup)
+    }
+
+    @Test
+    func `normal exit cleans a session escaped output holder`() async throws {
+        let childPIDFile = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-process-holder-\(UUID().uuidString).pid")
+        defer { try? FileManager.default.removeItem(at: childPIDFile) }
+
+        let script = """
+        import subprocess
+        import sys
+
+        child = subprocess.Popen(
+            [
+                sys.executable,
+                "-c",
+                "import signal,time; signal.signal(signal.SIGTERM, signal.SIG_IGN); time.sleep(30)",
+            ],
+            start_new_session=True,
+        )
+        with open(sys.argv[1], "w") as handle:
+            handle.write(str(child.pid))
+        print("parent complete", flush=True)
+        """
+        let stdoutPipe = Pipe()
+        let stderrPipe = Pipe()
+        let process = try SpawnedProcessGroup.launch(
+            binary: "/usr/bin/python3",
+            arguments: ["-c", script, childPIDFile.path],
+            environment: ProcessInfo.processInfo.environment,
+            stdoutPipe: stdoutPipe,
+            stderrPipe: stderrPipe)
+
+        while process.isRunning {
+            try await Task.sleep(for: .milliseconds(20))
+        }
+        var childPID: pid_t?
+        for _ in 0..<100 {
+            if let text = try? String(contentsOf: childPIDFile, encoding: .utf8),
+               let parsedPID = pid_t(text.trimmingCharacters(in: .whitespacesAndNewlines))
+            {
+                childPID = parsedPID
+                break
+            }
+            try await Task.sleep(for: .milliseconds(20))
+        }
+        let resolvedChildPID = try #require(childPID)
+        defer { _ = kill(resolvedChildPID, SIGKILL) }
+        #expect(kill(resolvedChildPID, 0) == 0)
+
+        await process.terminateResidualProcesses(grace: 0.2)
+        await process.finish()
+
+        #expect(kill(resolvedChildPID, 0) == -1)
+    }
+
+    @Test
+    func `normal exit cleans a same group helper without output pipes`() async throws {
+        let childPIDFile = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-process-group-holder-\(UUID().uuidString).pid")
+        let heartbeatFile = childPIDFile.appendingPathExtension("heartbeat")
+        defer {
+            try? FileManager.default.removeItem(at: childPIDFile)
+            try? FileManager.default.removeItem(at: heartbeatFile)
+        }
+
+        let script = """
+        import os
+        import signal
+        import sys
+        import time
+
+        child = os.fork()
+        if child == 0:
+            os.close(1)
+            os.close(2)
+            signal.signal(signal.SIGTERM, signal.SIG_IGN)
+            with open(sys.argv[1], "w") as handle:
+                handle.write(str(os.getpid()))
+            counter = 0
+            with open(sys.argv[2], "w") as heartbeat:
+                while True:
+                    counter += 1
+                    heartbeat.seek(0)
+                    heartbeat.write(str(counter))
+                    heartbeat.truncate()
+                    heartbeat.flush()
+                    time.sleep(0.02)
+            os._exit(0)
+        """
+        let stdoutPipe = Pipe()
+        let stderrPipe = Pipe()
+        let process = try SpawnedProcessGroup.launch(
+            binary: "/usr/bin/python3",
+            arguments: ["-c", script, childPIDFile.path, heartbeatFile.path],
+            environment: ProcessInfo.processInfo.environment,
+            stdoutPipe: stdoutPipe,
+            stderrPipe: stderrPipe)
+
+        while process.isRunning {
+            try await Task.sleep(for: .milliseconds(20))
+        }
+        var childPID: pid_t?
+        for _ in 0..<100 {
+            if let text = try? String(contentsOf: childPIDFile, encoding: .utf8),
+               let parsedPID = pid_t(text.trimmingCharacters(in: .whitespacesAndNewlines))
+            {
+                childPID = parsedPID
+                break
+            }
+            try await Task.sleep(for: .milliseconds(20))
+        }
+        let resolvedChildPID = try #require(childPID)
+        defer { _ = kill(resolvedChildPID, SIGKILL) }
+        #expect(getpgid(resolvedChildPID) == process.processGroup)
+        #expect(kill(resolvedChildPID, 0) == 0)
+        for _ in 0..<100 where !FileManager.default.fileExists(atPath: heartbeatFile.path) {
+            try await Task.sleep(for: .milliseconds(20))
+        }
+        let heartbeatBefore = try String(contentsOf: heartbeatFile, encoding: .utf8)
+        var heartbeatWhileRunning = heartbeatBefore
+        for _ in 0..<100 where heartbeatWhileRunning == heartbeatBefore {
+            try await Task.sleep(for: .milliseconds(20))
+            heartbeatWhileRunning = try String(contentsOf: heartbeatFile, encoding: .utf8)
+        }
+        #expect(heartbeatWhileRunning != heartbeatBefore)
+
+        await process.terminateResidualProcesses(grace: 0.2)
+        await process.finish()
+
+        try await Task.sleep(for: .milliseconds(100))
+        let heartbeatAfterCleanup = try String(contentsOf: heartbeatFile, encoding: .utf8)
+        try await Task.sleep(for: .milliseconds(200))
+        let heartbeatAfterSettle = try String(contentsOf: heartbeatFile, encoding: .utf8)
+        #expect(heartbeatAfterSettle == heartbeatAfterCleanup)
+    }
+
+    @Test
+    func `normal exit cleanup catches helper spawned during SIGTERM`() async throws {
+        let readyFile = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-process-group-post-exit-\(UUID().uuidString).ready")
+        let childPIDFile = readyFile.appendingPathExtension("pid")
+        let heartbeatFile = readyFile.appendingPathExtension("heartbeat")
+        defer {
+            try? FileManager.default.removeItem(at: readyFile)
+            try? FileManager.default.removeItem(at: childPIDFile)
+            try? FileManager.default.removeItem(at: heartbeatFile)
+        }
+
+        let script = """
+        import os
+        import signal
+        import sys
+        import time
+
+        helper = os.fork()
+        if helper == 0:
+            os.close(1)
+            os.close(2)
+            def handle_term(_signal, _frame):
+                reader, writer = os.pipe()
+                child = os.fork()
+                if child == 0:
+                    os.close(reader)
+                    signal.signal(signal.SIGTERM, signal.SIG_IGN)
+                    with open(sys.argv[2], "w") as handle:
+                        handle.write(str(os.getpid()))
+                    with open(sys.argv[3], "w") as heartbeat:
+                        heartbeat.write("1")
+                        heartbeat.flush()
+                        os.write(writer, b"1")
+                        os.close(writer)
+                        counter = 1
+                        while True:
+                            counter += 1
+                            heartbeat.seek(0)
+                            heartbeat.write(str(counter))
+                            heartbeat.truncate()
+                            heartbeat.flush()
+                            time.sleep(0.02)
+                os.close(writer)
+                os.read(reader, 1)
+                os.close(reader)
+                os._exit(0)
+
+            signal.signal(signal.SIGTERM, handle_term)
+            signal.pthread_sigmask(signal.SIG_UNBLOCK, {signal.SIGTERM})
+            with open(sys.argv[1], "w") as handle:
+                handle.write("ready")
+            time.sleep(30)
+            os._exit(0)
+
+        while not os.path.exists(sys.argv[1]):
+            time.sleep(0.01)
+        os._exit(0)
+        """
+        let stdoutPipe = Pipe()
+        let stderrPipe = Pipe()
+        let process = try SpawnedProcessGroup.launch(
+            binary: "/usr/bin/python3",
+            arguments: ["-c", script, readyFile.path, childPIDFile.path, heartbeatFile.path],
+            environment: ProcessInfo.processInfo.environment,
+            stdoutPipe: stdoutPipe,
+            stderrPipe: stderrPipe)
+
+        while process.isRunning {
+            try await Task.sleep(for: .milliseconds(20))
+        }
+        #expect(FileManager.default.fileExists(atPath: readyFile.path))
+
+        await process.terminateResidualProcesses(grace: 0.2)
+        await process.finish()
+
+        var childPID: pid_t?
+        for _ in 0..<100 {
+            if let text = try? String(contentsOf: childPIDFile, encoding: .utf8),
+               let parsedPID = pid_t(text.trimmingCharacters(in: .whitespacesAndNewlines))
+            {
+                childPID = parsedPID
+                break
+            }
+            try await Task.sleep(for: .milliseconds(20))
+        }
+        let resolvedChildPID = try #require(childPID)
+        defer { _ = kill(resolvedChildPID, SIGKILL) }
+        let heartbeatAfterCleanup = try String(contentsOf: heartbeatFile, encoding: .utf8)
+        try await Task.sleep(for: .milliseconds(200))
+        let heartbeatAfterSettle = try String(contentsOf: heartbeatFile, encoding: .utf8)
+        #expect(heartbeatAfterSettle == heartbeatAfterCleanup)
+    }
+}
diff --git a/Tests/CodexBarTests/StatusItemAnimationCodexCreditsTests.swift b/Tests/CodexBarTests/StatusItemAnimationCodexCreditsTests.swift
new file mode 100644
index 0000000000..25dc34b444
--- /dev/null
+++ b/Tests/CodexBarTests/StatusItemAnimationCodexCreditsTests.swift
@@ -0,0 +1,51 @@
+import AppKit
+import CodexBarCore
+import Testing
+@testable import CodexBar
+
+@Suite(.serialized)
+@MainActor
+struct StatusItemAnimationCodexCreditsTests {
+    @Test
+    func `codex icon keeps credits only rendering when usage is missing`() {
+        let settings = testSettingsStore(suiteName: "StatusItemAnimationTests-credits-only-icon")
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.menuBarShowsBrandIconWithPercent = false
+
+        let registry = ProviderRegistry.shared
+        if let codexMeta = registry.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        store._setSnapshotForTesting(nil, provider: .codex)
+        store.credits = CreditsSnapshot(remaining: 80, events: [], updatedAt: Date())
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: testStatusBar())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        controller.applyIcon(for: .codex, phase: nil)
+
+        guard let image = controller.statusItems[.codex]?.button?.image else {
+            #expect(Bool(false))
+            return
+        }
+        let rep = image.representations.compactMap { $0 as? NSBitmapImageRep }.first(where: {
+            $0.pixelsWide == 36 && $0.pixelsHigh == 36
+        })
+        #expect(rep != nil)
+        guard let rep else { return }
+
+        let creditsOnlyAlpha = (rep.colorAt(x: 18, y: 17) ?? .clear).alphaComponent
+        #expect(creditsOnlyAlpha > 0.05)
+    }
+}
diff --git a/Tests/CodexBarTests/StatusItemAnimationSignatureTests.swift b/Tests/CodexBarTests/StatusItemAnimationSignatureTests.swift
new file mode 100644
index 0000000000..a2451ff737
--- /dev/null
+++ b/Tests/CodexBarTests/StatusItemAnimationSignatureTests.swift
@@ -0,0 +1,503 @@
+import AppKit
+import CodexBarCore
+import Testing
+@testable import CodexBar
+
+@MainActor
+@Suite(.serialized)
+struct StatusItemAnimationSignatureTests {
+    @Test
+    func `merged render signature changes when unified icon style changes`() {
+        let suite = "StatusItemAnimationSignatureTests-merged-style-signature"
+        let settings = testSettingsStore(suiteName: suite)
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        settings.menuBarShowsBrandIconWithPercent = false
+        settings.syntheticAPIToken = "synthetic-test-token"
+
+        let registry = ProviderRegistry.shared
+        if let codexMeta = registry.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+        if let syntheticMeta = registry.metadata[.synthetic] {
+            settings.setProviderEnabled(provider: .synthetic, metadata: syntheticMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: testStatusBar())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(usedPercent: 50, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date()),
+            provider: .codex)
+
+        #expect(store.enabledProvidersForDisplay() == [.codex, .synthetic])
+        #expect(store.enabledProviders() == [.codex, .synthetic])
+        #expect(store.iconStyle == .combined)
+        controller.applyIcon(phase: nil)
+        let combinedSignature = controller.lastAppliedMergedIconRenderSignature
+
+        if let syntheticMeta = registry.metadata[.synthetic] {
+            settings.setProviderEnabled(provider: .synthetic, metadata: syntheticMeta, enabled: false)
+        }
+
+        #expect(store.enabledProvidersForDisplay() == [.codex])
+        #expect(store.enabledProviders() == [.codex])
+        #expect(store.iconStyle == .codex)
+        controller.applyIcon(phase: nil)
+        let codexSignature = controller.lastAppliedMergedIconRenderSignature
+
+        #expect(combinedSignature != nil)
+        #expect(codexSignature != nil)
+        #expect(combinedSignature != codexSignature)
+        #expect(codexSignature?.contains("style=codex") == true)
+    }
+
+    @Test
+    func `merged antigravity icon resolves quota summary with provider style`() throws {
+        let suite = "StatusItemAnimationSignatureTests-merged-antigravity-provider-style"
+        let settings = testSettingsStore(suiteName: suite)
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .antigravity
+        settings.menuBarShowsBrandIconWithPercent = false
+        settings.usageBarsShowUsed = false
+        settings.syntheticAPIToken = "synthetic-test-token"
+
+        let registry = ProviderRegistry.shared
+        if let antigravityMeta = registry.metadata[.antigravity] {
+            settings.setProviderEnabled(provider: .antigravity, metadata: antigravityMeta, enabled: true)
+        }
+        if let syntheticMeta = registry.metadata[.synthetic] {
+            settings.setProviderEnabled(provider: .synthetic, metadata: syntheticMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: testStatusBar())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(usedPercent: 99, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+                secondary: RateWindow(usedPercent: 16, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+                tertiary: nil,
+                extraRateWindows: [
+                    NamedRateWindow(
+                        id: "antigravity-quota-summary-gemini-5h",
+                        title: "Gemini Session",
+                        window: RateWindow(usedPercent: 1, windowMinutes: 300, resetsAt: nil, resetDescription: nil)),
+                    NamedRateWindow(
+                        id: "antigravity-quota-summary-gemini-weekly",
+                        title: "Gemini Weekly",
+                        window: RateWindow(
+                            usedPercent: 99,
+                            windowMinutes: 10080,
+                            resetsAt: nil,
+                            resetDescription: nil)),
+                    NamedRateWindow(
+                        id: "antigravity-quota-summary-3p-5h",
+                        title: "Claude + GPT Session",
+                        window: RateWindow(usedPercent: 2, windowMinutes: 300, resetsAt: nil, resetDescription: nil)),
+                    NamedRateWindow(
+                        id: "antigravity-quota-summary-3p-weekly",
+                        title: "Claude + GPT Weekly",
+                        window: RateWindow(
+                            usedPercent: 16,
+                            windowMinutes: 10080,
+                            resetsAt: nil,
+                            resetDescription: nil)),
+                ],
+                updatedAt: Date()),
+            provider: .antigravity)
+
+        #expect(store.iconStyle == .combined)
+        #expect(controller.primaryProviderForUnifiedIcon() == .antigravity)
+
+        controller.applyIcon(phase: nil)
+        let signature = try #require(controller.lastAppliedMergedIconRenderSignature)
+
+        #expect(signature.contains("provider=antigravity"))
+        #expect(signature.contains("style=combined"))
+        #expect(signature.contains("primary=99.000"))
+        #expect(signature.contains("weekly=1.000"))
+    }
+
+    @Test
+    func `merged brand percent reapplies title when cached render is skipped`() throws {
+        let suite = "StatusItemAnimationSignatureTests-merged-brand-percent-title-restore"
+        let settings = testSettingsStore(suiteName: suite)
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        settings.menuBarShowsBrandIconWithPercent = true
+        settings.menuBarDisplayMode = .percent
+        settings.usageBarsShowUsed = false
+        settings.syntheticAPIToken = "synthetic-test-token"
+
+        let registry = ProviderRegistry.shared
+        if let codexMeta = registry.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+        if let syntheticMeta = registry.metadata[.synthetic] {
+            settings.setProviderEnabled(provider: .synthetic, metadata: syntheticMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: testStatusBar())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 23, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())
+        store._setSnapshotForTesting(snapshot, provider: .codex)
+
+        let displayText = try #require(controller.menuBarDisplayText(for: .codex, snapshot: snapshot))
+        let expectedTitle = StatusItemController.buttonTitle(displayText, hasImage: true)
+        controller.applyIcon(phase: nil)
+        let button = try #require(controller.statusItem.button)
+        #expect(button.title == expectedTitle)
+        #expect(button.imagePosition == .imageLeft)
+
+        button.title = ""
+        button.imagePosition = .imageOnly
+
+        let skipped = controller.applyIcon(phase: nil)
+
+        #expect(skipped)
+        #expect(button.title == expectedTitle)
+        #expect(button.imagePosition == .imageLeft)
+    }
+
+    @Test
+    func `merged icon render defers while merged menu is tracking`() async throws {
+        let suite = "StatusItemAnimationSignatureTests-merged-icon-defers-during-tracking"
+        let settings = testSettingsStore(suiteName: suite)
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        settings.menuBarShowsBrandIconWithPercent = false
+        settings.syntheticAPIToken = "synthetic-test-token"
+
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            settings.setProviderEnabled(
+                provider: provider,
+                metadata: metadata,
+                enabled: provider == .codex || provider == .synthetic)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: testStatusBar())
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        func snapshot(usedPercent: Double) -> UsageSnapshot {
+            UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: usedPercent,
+                    windowMinutes: nil,
+                    resetsAt: nil,
+                    resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date())
+        }
+
+        store._setSnapshotForTesting(snapshot(usedPercent: 20), provider: .codex)
+        controller.updateIcons()
+        #expect(controller.animationDriver == nil)
+        controller.applyIcon(phase: nil)
+        let initialSignature = try #require(controller.lastAppliedMergedIconRenderSignature)
+
+        let menu = controller.makeMenu()
+        controller.mergedMenu = menu
+        controller.statusItem.menu = menu
+        controller.menuWillOpen(menu)
+        #expect(controller.isMergedMenuOpen)
+
+        store._setSnapshotForTesting(nil, provider: .codex)
+        controller.updateIcons()
+        #expect(controller.animationDriver != nil)
+        #expect(controller.deferredMergedIconRenderAfterTracking)
+
+        store._setSnapshotForTesting(snapshot(usedPercent: 80), provider: .codex)
+        controller.updateIcons()
+        #expect(controller.animationDriver == nil)
+        #expect(controller.deferredMergedIconRenderAfterTracking)
+        #expect(controller.lastAppliedMergedIconRenderSignature == initialSignature)
+
+        controller.startQuotaWarningFlash(provider: .codex)
+        #expect(controller.lastAppliedMergedIconRenderSignature?.contains("warningFlash=1") == true)
+
+        let quotaWarningTask = controller.quotaWarningFlashTasks[.codex]
+        controller.clearExpiredQuotaWarningFlash(provider: .codex, now: .distantFuture)
+        quotaWarningTask?.cancel()
+        #expect(controller.lastAppliedMergedIconRenderSignature?.contains("warningFlash=0") == true)
+
+        controller.menuDidClose(menu)
+
+        #expect(!controller.deferredMergedIconRenderAfterTracking)
+        #expect(controller.lastAppliedMergedIconRenderSignature?.contains("warningFlash=0") == true)
+
+        controller.menuWillOpen(menu)
+        settings.selectedMenuProvider = .synthetic
+        #expect(controller.primaryProviderForUnifiedIcon() == .synthetic)
+        #expect(controller.lastAppliedMergedIconRenderSignature?.contains("provider=codex") == true)
+
+        controller.startQuotaWarningFlash(provider: .codex)
+        let switchedProviderWarningTask = controller.quotaWarningFlashTasks[.codex]
+        #expect(controller.lastAppliedMergedIconRenderSignature?.contains("provider=synthetic") == true)
+        controller.clearExpiredQuotaWarningFlash(provider: .codex, now: .distantFuture)
+        switchedProviderWarningTask?.cancel()
+        controller.menuDidClose(menu)
+
+        settings.selectedMenuProvider = .codex
+        for _ in 0..<10 where controller.primaryProviderForUnifiedIcon() != .codex {
+            await Task.yield()
+        }
+
+        controller.menuWillOpen(menu)
+        store._setSnapshotForTesting(nil, provider: .codex)
+        controller.updateAnimationState()
+        controller.applyIcon(phase: controller.animationPhase)
+        #expect(controller.animationDriver != nil)
+        #expect(controller.deferredMergedIconRenderAfterTracking)
+
+        controller.animationDriver?.stop()
+        controller.animationDriver = nil
+        controller.animationPhase = 0
+        controller.menuDidClose(menu)
+
+        #expect(controller.animationDriver == nil)
+        #expect(controller.lastAppliedMergedIconRenderSignature?.contains("primary=nil") == true)
+    }
+
+    @Test
+    func `merged fallback provider follows enabled provider order`() {
+        let suite = "StatusItemAnimationSignatureTests-merged-provider-order"
+        let settings = testSettingsStore(suiteName: suite)
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.menuBarShowsBrandIconWithPercent = false
+        settings.syntheticAPIToken = "synthetic-test-token"
+        settings.setProviderOrder([.synthetic, .codex])
+
+        let registry = ProviderRegistry.shared
+        if let codexMeta = registry.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+        if let syntheticMeta = registry.metadata[.synthetic] {
+            settings.setProviderEnabled(provider: .synthetic, metadata: syntheticMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: testStatusBar())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 50, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())
+        store._setSnapshotForTesting(snapshot, provider: .codex)
+        store._setSnapshotForTesting(snapshot, provider: .synthetic)
+
+        controller.applyIcon(phase: nil)
+
+        #expect(store.enabledProviders().prefix(2) == [.synthetic, .codex])
+        #expect(controller.lastAppliedMergedIconRenderSignature?.contains("provider=synthetic") == true)
+    }
+
+    @Test
+    func `merged icon status indicator follows rendered provider`() throws {
+        let suite = "StatusItemAnimationSignatureTests-merged-status-provider-scope"
+        let settings = testSettingsStore(suiteName: suite)
+        settings.statusChecksEnabled = true
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        settings.menuBarShowsBrandIconWithPercent = false
+
+        let registry = ProviderRegistry.shared
+        let codexMeta = try #require(registry.metadata[.codex])
+        let claudeMeta = try #require(registry.metadata[.claude])
+        settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        settings.setProviderEnabled(provider: .claude, metadata: claudeMeta, enabled: true)
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: testStatusBar())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 50, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())
+        store._setSnapshotForTesting(snapshot, provider: .codex)
+        store._setSnapshotForTesting(snapshot, provider: .claude)
+        store.statuses[.claude] = ProviderStatus(
+            indicator: .major,
+            description: "Claude status issue",
+            updatedAt: Date(timeIntervalSince1970: 20))
+
+        controller.applyIcon(phase: nil)
+
+        #expect(controller.primaryProviderForUnifiedIcon() == .codex)
+        #expect(controller.lastAppliedMergedIconRenderSignature?.contains("provider=codex") == true)
+        #expect(controller.lastAppliedMergedIconRenderSignature?.contains("status=none") == true)
+
+        settings.selectedMenuProvider = .claude
+        controller.applyIcon(phase: nil)
+
+        #expect(controller.primaryProviderForUnifiedIcon() == .claude)
+        #expect(controller.lastAppliedMergedIconRenderSignature?.contains("provider=claude") == true)
+        #expect(controller.lastAppliedMergedIconRenderSignature?.contains("status=major") == true)
+    }
+
+    @Test
+    func `merged icon follows overview provider order when first overview provider is loading`() {
+        let suite = "StatusItemAnimationSignatureTests-merged-overview-provider-order"
+        let settings = testSettingsStore(suiteName: suite)
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        settings.mergedMenuLastSelectedWasOverview = true
+        settings.menuBarShowsBrandIconWithPercent = false
+        settings.setProviderOrder([.cursor, .codex, .claude])
+
+        let registry = ProviderRegistry.shared
+        if let cursorMeta = registry.metadata[.cursor] {
+            settings.setProviderEnabled(provider: .cursor, metadata: cursorMeta, enabled: true)
+        }
+        if let codexMeta = registry.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+        if let claudeMeta = registry.metadata[.claude] {
+            settings.setProviderEnabled(provider: .claude, metadata: claudeMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: testStatusBar())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 50, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())
+        store._setSnapshotForTesting(snapshot, provider: .codex)
+        store._setSnapshotForTesting(snapshot, provider: .claude)
+
+        #expect(store.enabledProvidersForDisplay().prefix(3) == [.cursor, .codex, .claude])
+        #expect(settings.resolvedMergedOverviewProviders(activeProviders: store.enabledProvidersForDisplay()) == [
+            .cursor,
+            .codex,
+            .claude,
+        ])
+
+        controller.applyIcon(phase: nil)
+
+        #expect(controller.lastAppliedMergedIconRenderSignature?.contains("provider=cursor") == true)
+    }
+
+    @Test
+    func `split provider icon skips unchanged render signature`() {
+        let suite = "StatusItemAnimationSignatureTests-split-provider-signature"
+        let settings = testSettingsStore(suiteName: suite)
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.menuBarShowsBrandIconWithPercent = false
+
+        if let codexMeta = ProviderRegistry.shared.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: testStatusBar())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(usedPercent: 25, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date()),
+            provider: .codex)
+
+        #expect(controller.applyIcon(for: .codex, phase: nil) == false)
+        #expect(controller.applyIcon(for: .codex, phase: nil) == true)
+
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(usedPercent: 50, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date()),
+            provider: .codex)
+
+        #expect(controller.applyIcon(for: .codex, phase: nil) == false)
+    }
+}
diff --git a/Tests/CodexBarTests/StatusItemAnimationTests.swift b/Tests/CodexBarTests/StatusItemAnimationTests.swift
index 0e6f0e33f9..f019d0f71c 100644
--- a/Tests/CodexBarTests/StatusItemAnimationTests.swift
+++ b/Tests/CodexBarTests/StatusItemAnimationTests.swift
@@ -4,7 +4,8 @@ import Testing
 @testable import CodexBar
 
 @MainActor
-@Suite
+@Suite(.serialized)
+// swiftlint:disable:next type_body_length
 struct StatusItemAnimationTests {
     private func maxAlpha(in rep: NSBitmapImageRep) -> CGFloat {
         var maxAlpha: CGFloat = 0
@@ -20,15 +21,13 @@ struct StatusItemAnimationTests {
     }
 
     private func makeStatusBarForTesting() -> NSStatusBar {
-        let env = ProcessInfo.processInfo.environment
-        if env["GITHUB_ACTIONS"] == "true" || env["CI"] == "true" {
-            return .system
-        }
-        return NSStatusBar()
+        // Use the real system status bar in tests. Creating standalone NSStatusBar instances
+        // has caused AppKit teardown crashes under swiftpm-testing-helper.
+        .system
     }
 
     @Test
-    func mergedIconLoadingAnimationTracksSelectedProviderOnly() {
+    func `merged icon loading animation tracks selected provider only`() {
         let settings = SettingsStore(
             configStore: testConfigStore(suiteName: "StatusItemAnimationTests-merged"),
             zaiTokenStore: NoopZaiTokenStore(),
@@ -42,9 +41,10 @@ struct StatusItemAnimationTests {
         if let codexMeta = registry.metadata[.codex] {
             settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
         }
-        if let claudeMeta = registry.metadata[.claude] {
-            settings.setProviderEnabled(provider: .claude, metadata: claudeMeta, enabled: true)
+        if let openRouterMeta = registry.metadata[.openrouter] {
+            settings.setProviderEnabled(provider: .openrouter, metadata: openRouterMeta, enabled: true)
         }
+        settings.openRouterAPIToken = "or-token"
         if let geminiMeta = registry.metadata[.gemini] {
             settings.setProviderEnabled(provider: .gemini, metadata: geminiMeta, enabled: false)
         }
@@ -58,6 +58,7 @@ struct StatusItemAnimationTests {
             updater: DisabledUpdaterController(),
             preferencesSelection: PreferencesSelection(),
             statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
 
         let snapshot = UsageSnapshot(
             primary: RateWindow(usedPercent: 50, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
@@ -73,7 +74,7 @@ struct StatusItemAnimationTests {
     }
 
     @Test
-    func mergedIconLoadingAnimationDoesNotFlipLayoutWhenWeeklyHitsZero() {
+    func `merged icon loading animation does not flip layout when weekly hits zero`() {
         let settings = SettingsStore(
             configStore: testConfigStore(suiteName: "StatusItemAnimationTests-weekly"),
             zaiTokenStore: NoopZaiTokenStore(),
@@ -88,9 +89,10 @@ struct StatusItemAnimationTests {
         if let codexMeta = registry.metadata[.codex] {
             settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
         }
-        if let claudeMeta = registry.metadata[.claude] {
-            settings.setProviderEnabled(provider: .claude, metadata: claudeMeta, enabled: true)
+        if let openRouterMeta = registry.metadata[.openrouter] {
+            settings.setProviderEnabled(provider: .openrouter, metadata: openRouterMeta, enabled: true)
         }
+        settings.openRouterAPIToken = "or-token"
 
         let fetcher = UsageFetcher()
         let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
@@ -109,6 +111,7 @@ struct StatusItemAnimationTests {
             updater: DisabledUpdaterController(),
             preferencesSelection: PreferencesSelection(),
             statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
 
         // Enter loading state: no data, no stale error.
         store._setSnapshotForTesting(nil, provider: .codex)
@@ -138,7 +141,7 @@ struct StatusItemAnimationTests {
     }
 
     @Test
-    func warpNoBonusLayoutIsPreservedInShowUsedModeWhenBonusIsExhausted() {
+    func `warp no bonus layout is preserved in show used mode when bonus is exhausted`() {
         let settings = SettingsStore(
             configStore: testConfigStore(suiteName: "StatusItemAnimationTests-warp-no-bonus-used"),
             zaiTokenStore: NoopZaiTokenStore(),
@@ -163,6 +166,7 @@ struct StatusItemAnimationTests {
             updater: DisabledUpdaterController(),
             preferencesSelection: PreferencesSelection(),
             statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
 
         // Primary used=10%. Bonus exhausted: used=100% (remaining=0%).
         let snapshot = UsageSnapshot(
@@ -191,7 +195,7 @@ struct StatusItemAnimationTests {
     }
 
     @Test
-    func warpBonusLaneIsPreservedInShowUsedModeWhenBonusIsUnused() {
+    func `warp bonus lane is preserved in show used mode when bonus is unused`() {
         let settings = SettingsStore(
             configStore: testConfigStore(suiteName: "StatusItemAnimationTests-warp-unused-bonus-used"),
             zaiTokenStore: NoopZaiTokenStore(),
@@ -216,6 +220,7 @@ struct StatusItemAnimationTests {
             updater: DisabledUpdaterController(),
             preferencesSelection: PreferencesSelection(),
             statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
 
         // Bonus exists but is unused: used=0% (remaining=100%).
         let snapshot = UsageSnapshot(
@@ -244,7 +249,139 @@ struct StatusItemAnimationTests {
     }
 
     @Test
-    func menuBarPercentUsesConfiguredMetric() {
+    func `open router without key limit uses meter icon when brand percent is disabled`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "StatusItemAnimationTests-openrouter-no-limit-meter"),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.menuBarShowsBrandIconWithPercent = false
+
+        let registry = ProviderRegistry.shared
+        if let openRouterMeta = registry.metadata[.openrouter] {
+            settings.setProviderEnabled(provider: .openrouter, metadata: openRouterMeta, enabled: true)
+        }
+        settings.openRouterAPIToken = "or-token"
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let snapshot = OpenRouterUsageSnapshot(
+            totalCredits: 50,
+            totalUsage: 45,
+            balance: 5,
+            usedPercent: 90,
+            keyDataFetched: true,
+            keyLimit: nil,
+            keyUsage: nil,
+            rateLimit: nil,
+            updatedAt: Date()).toUsageSnapshot()
+
+        store._setSnapshotForTesting(snapshot, provider: .openrouter)
+        store._setErrorForTesting(nil, provider: .openrouter)
+
+        controller.applyIcon(for: .openrouter, phase: nil)
+
+        guard let image = controller.statusItems[.openrouter]?.button?.image else {
+            #expect(Bool(false))
+            return
+        }
+
+        #expect(image.size.width == 18)
+        #expect(image.size.height == 18)
+        #expect(snapshot.openRouterUsage?.keyQuotaStatus == .noLimitConfigured)
+        #expect(controller.statusItems[.openrouter]?.button?.title.isEmpty == true)
+        #expect(MenuBarDisplayText.percentText(window: snapshot.primary, showUsed: false) == nil)
+
+        // With no key limit, the primary bar has no fill — just the dim track.
+        // A brand logo would be fully opaque here; the track is not.
+        let rep = image.representations.compactMap { $0 as? NSBitmapImageRep }.first(where: {
+            $0.pixelsWide == 36 && $0.pixelsHigh == 36
+        })
+        #expect(rep != nil)
+        if let rep {
+            let alpha = (rep.colorAt(x: 8, y: 25) ?? .clear).alphaComponent
+            #expect(alpha < 0.5)
+        }
+    }
+
+    @Test
+    func `open router key data not fetched still uses meter icon when brand percent is disabled`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "StatusItemAnimationTests-openrouter-no-fetch-meter"),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.menuBarShowsBrandIconWithPercent = false
+
+        let registry = ProviderRegistry.shared
+        if let openRouterMeta = registry.metadata[.openrouter] {
+            settings.setProviderEnabled(provider: .openrouter, metadata: openRouterMeta, enabled: true)
+        }
+        settings.openRouterAPIToken = "or-token"
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let snapshot = OpenRouterUsageSnapshot(
+            totalCredits: 50,
+            totalUsage: 45,
+            balance: 5,
+            usedPercent: 90,
+            keyDataFetched: false,
+            keyLimit: nil,
+            keyUsage: nil,
+            rateLimit: nil,
+            updatedAt: Date()).toUsageSnapshot()
+
+        store._setSnapshotForTesting(snapshot, provider: .openrouter)
+        store._setErrorForTesting(nil, provider: .openrouter)
+
+        controller.applyIcon(for: .openrouter, phase: nil)
+
+        guard let image = controller.statusItems[.openrouter]?.button?.image else {
+            #expect(Bool(false))
+            return
+        }
+
+        #expect(image.size.width == 18)
+        #expect(image.size.height == 18)
+        #expect(snapshot.openRouterUsage?.keyQuotaStatus == .unavailable)
+
+        // Even with no key data, OpenRouter still renders a meter rather than the brand logo.
+        // A brand logo would be fully opaque here; the unfilled track is not.
+        let rep = image.representations.compactMap { $0 as? NSBitmapImageRep }.first(where: {
+            $0.pixelsWide == 36 && $0.pixelsHigh == 36
+        })
+        #expect(rep != nil)
+        if let rep {
+            let alpha = (rep.colorAt(x: 8, y: 25) ?? .clear).alphaComponent
+            #expect(alpha < 0.5)
+        }
+    }
+
+    @Test
+    func `menu bar percent uses configured metric`() {
         let settings = SettingsStore(
             configStore: testConfigStore(suiteName: "StatusItemAnimationTests-metric"),
             zaiTokenStore: NoopZaiTokenStore())
@@ -268,6 +405,7 @@ struct StatusItemAnimationTests {
             updater: DisabledUpdaterController(),
             preferencesSelection: PreferencesSelection(),
             statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
 
         let snapshot = UsageSnapshot(
             primary: RateWindow(usedPercent: 12, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
@@ -283,7 +421,48 @@ struct StatusItemAnimationTests {
     }
 
     @Test
-    func menuBarPercentAutomaticPrefersRateLimitForKimi() {
+    func `combined codex menu bar metric window uses most constrained visible lane`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "StatusItemAnimationTests-codex-combined-window"),
+            zaiTokenStore: NoopZaiTokenStore())
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        settings.setMenuBarMetricPreference(.primaryAndSecondary, for: .codex)
+
+        let registry = ProviderRegistry.shared
+        if let codexMeta = registry.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 12, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 91, windowMinutes: 7 * 24 * 60, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(snapshot, provider: .codex)
+        store._setErrorForTesting(nil, provider: .codex)
+
+        let window = controller.menuBarMetricWindow(for: .codex, snapshot: snapshot)
+
+        #expect(window?.usedPercent == 91)
+        #expect(window?.windowMinutes == 7 * 24 * 60)
+    }
+
+    @Test
+    func `menu bar percent automatic prefers rate limit for kimi`() {
         let settings = SettingsStore(
             configStore: testConfigStore(suiteName: "StatusItemAnimationTests-kimi-automatic"),
             zaiTokenStore: NoopZaiTokenStore())
@@ -322,7 +501,7 @@ struct StatusItemAnimationTests {
     }
 
     @Test
-    func menuBarPercentUsesAverageForGemini() {
+    func `menu bar percent uses average for gemini`() {
         let settings = SettingsStore(
             configStore: testConfigStore(suiteName: "StatusItemAnimationTests-average"),
             zaiTokenStore: NoopZaiTokenStore())
@@ -346,6 +525,7 @@ struct StatusItemAnimationTests {
             updater: DisabledUpdaterController(),
             preferencesSelection: PreferencesSelection(),
             statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
 
         let snapshot = UsageSnapshot(
             primary: RateWindow(usedPercent: 20, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
@@ -361,7 +541,370 @@ struct StatusItemAnimationTests {
     }
 
     @Test
-    func menuBarDisplayTextFormatsPercentAndPace() {
+    func `menu bar percent automatic keeps gemini primary over higher tertiary`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "StatusItemAnimationTests-gemini-automatic-primary"),
+            zaiTokenStore: NoopZaiTokenStore())
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .gemini
+        settings.setMenuBarMetricPreference(.automatic, for: .gemini)
+
+        let registry = ProviderRegistry.shared
+        if let geminiMeta = registry.metadata[.gemini] {
+            settings.setProviderEnabled(provider: .gemini, metadata: geminiMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 20, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 40, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            tertiary: RateWindow(usedPercent: 95, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(snapshot, provider: .gemini)
+        store._setErrorForTesting(nil, provider: .gemini)
+
+        let window = controller.menuBarMetricWindow(for: .gemini, snapshot: snapshot)
+
+        #expect(window?.usedPercent == 20)
+    }
+
+    @Test
+    func `menu bar percent automatic picks highest cursor lane including api`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "StatusItemAnimationTests-cursor-automatic-tertiary"),
+            zaiTokenStore: NoopZaiTokenStore())
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .cursor
+        settings.setMenuBarMetricPreference(.automatic, for: .cursor)
+
+        let registry = ProviderRegistry.shared
+        if let cursorMeta = registry.metadata[.cursor] {
+            settings.setProviderEnabled(provider: .cursor, metadata: cursorMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 25, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            tertiary: RateWindow(usedPercent: 90, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(snapshot, provider: .cursor)
+        store._setErrorForTesting(nil, provider: .cursor)
+
+        let window = controller.menuBarMetricWindow(for: .cursor, snapshot: snapshot)
+
+        #expect(window?.usedPercent == 90)
+    }
+
+    @Test
+    func `menu bar percent automatic falls back to purchased perplexity lane when bonus is exhausted`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "StatusItemAnimationTests-perplexity-automatic-purchased"),
+            zaiTokenStore: NoopZaiTokenStore())
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .perplexity
+        settings.setMenuBarMetricPreference(.automatic, for: .perplexity)
+
+        let registry = ProviderRegistry.shared
+        if let perplexityMeta = registry.metadata[.perplexity] {
+            settings.setProviderEnabled(provider: .perplexity, metadata: perplexityMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            tertiary: RateWindow(usedPercent: 20, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(snapshot, provider: .perplexity)
+        store._setErrorForTesting(nil, provider: .perplexity)
+
+        let window = controller.menuBarMetricWindow(for: .perplexity, snapshot: snapshot)
+
+        #expect(window?.usedPercent == 20)
+    }
+
+    @Test
+    func `menu bar percent automatic falls through after recurring perplexity credits are exhausted`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(
+                suiteName: "StatusItemAnimationTests-perplexity-automatic-recurring-exhausted"),
+            zaiTokenStore: NoopZaiTokenStore())
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .perplexity
+        settings.setMenuBarMetricPreference(.automatic, for: .perplexity)
+
+        let registry = ProviderRegistry.shared
+        if let perplexityMeta = registry.metadata[.perplexity] {
+            settings.setProviderEnabled(provider: .perplexity, metadata: perplexityMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            tertiary: RateWindow(usedPercent: 32, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(snapshot, provider: .perplexity)
+        store._setErrorForTesting(nil, provider: .perplexity)
+
+        let window = controller.menuBarMetricWindow(for: .perplexity, snapshot: snapshot)
+
+        #expect(window?.usedPercent == 32)
+    }
+
+    @Test
+    func `menu bar percent automatic prefers purchased perplexity credits before bonus`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(
+                suiteName: "StatusItemAnimationTests-perplexity-automatic-purchased-before-bonus"),
+            zaiTokenStore: NoopZaiTokenStore())
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .perplexity
+        settings.setMenuBarMetricPreference(.automatic, for: .perplexity)
+
+        let registry = ProviderRegistry.shared
+        if let perplexityMeta = registry.metadata[.perplexity] {
+            settings.setProviderEnabled(provider: .perplexity, metadata: perplexityMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 20, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            tertiary: RateWindow(usedPercent: 45, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(snapshot, provider: .perplexity)
+        store._setErrorForTesting(nil, provider: .perplexity)
+
+        let window = controller.menuBarMetricWindow(for: .perplexity, snapshot: snapshot)
+
+        #expect(window?.usedPercent == 45)
+    }
+
+    @Test
+    func `menu bar percent primary preference stays on recurring perplexity credits`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(
+                suiteName: "StatusItemAnimationTests-perplexity-primary-recurring-exhausted"),
+            zaiTokenStore: NoopZaiTokenStore())
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .perplexity
+        settings.setMenuBarMetricPreference(.primary, for: .perplexity)
+
+        let registry = ProviderRegistry.shared
+        if let perplexityMeta = registry.metadata[.perplexity] {
+            settings.setProviderEnabled(provider: .perplexity, metadata: perplexityMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            tertiary: RateWindow(usedPercent: 32, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(snapshot, provider: .perplexity)
+        store._setErrorForTesting(nil, provider: .perplexity)
+
+        let window = controller.menuBarMetricWindow(for: .perplexity, snapshot: snapshot)
+
+        #expect(window?.usedPercent == 100)
+    }
+
+    @Test
+    func `menu bar percent tertiary preference uses purchased perplexity lane`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "StatusItemAnimationTests-perplexity-tertiary-pref"),
+            zaiTokenStore: NoopZaiTokenStore())
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .perplexity
+        settings.setMenuBarMetricPreference(.tertiary, for: .perplexity)
+
+        let registry = ProviderRegistry.shared
+        if let perplexityMeta = registry.metadata[.perplexity] {
+            settings.setProviderEnabled(provider: .perplexity, metadata: perplexityMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            tertiary: RateWindow(usedPercent: 28, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(snapshot, provider: .perplexity)
+        store._setErrorForTesting(nil, provider: .perplexity)
+
+        let window = controller.menuBarMetricWindow(for: .perplexity, snapshot: snapshot)
+
+        #expect(window?.usedPercent == 28)
+    }
+
+    @Test
+    func `menu bar percent tertiary preference uses api lane for cursor`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "StatusItemAnimationTests-cursor-tertiary-pref"),
+            zaiTokenStore: NoopZaiTokenStore())
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .cursor
+        settings.setMenuBarMetricPreference(.tertiary, for: .cursor)
+
+        let registry = ProviderRegistry.shared
+        if let cursorMeta = registry.metadata[.cursor] {
+            settings.setProviderEnabled(provider: .cursor, metadata: cursorMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 20, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            tertiary: RateWindow(usedPercent: 72, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(snapshot, provider: .cursor)
+        store._setErrorForTesting(nil, provider: .cursor)
+
+        let window = controller.menuBarMetricWindow(for: .cursor, snapshot: snapshot)
+
+        #expect(window?.usedPercent == 72)
+    }
+
+    @Test
+    func `menu bar tertiary preference falls back to automatic when cursor api lane is missing`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "StatusItemAnimationTests-cursor-tertiary-missing-api"),
+            zaiTokenStore: NoopZaiTokenStore())
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .cursor
+        settings.setMenuBarMetricPreference(.tertiary, for: .cursor)
+
+        let registry = ProviderRegistry.shared
+        if let cursorMeta = registry.metadata[.cursor] {
+            settings.setProviderEnabled(provider: .cursor, metadata: cursorMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 72, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            tertiary: nil,
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(snapshot, provider: .cursor)
+        store._setErrorForTesting(nil, provider: .cursor)
+
+        let window = controller.menuBarMetricWindow(for: .cursor, snapshot: snapshot)
+
+        #expect(window?.usedPercent == 72)
+    }
+
+    @Test
+    func `menu bar display text formats percent and pace`() {
         let now = Date(timeIntervalSince1970: 0)
         let percentWindow = RateWindow(usedPercent: 40, windowMinutes: nil, resetsAt: nil, resetDescription: nil)
         let paceWindow = RateWindow(
@@ -393,14 +936,49 @@ struct StatusItemAnimationTests {
     }
 
     @Test
-    func menuBarDisplayTextHidesWhenPaceUnavailable() {
-        let now = Date(timeIntervalSince1970: 0)
+    func `menu bar display text formats codex combined percent lanes`() {
+        let sessionWindow = RateWindow(usedPercent: 7, windowMinutes: 300, resetsAt: nil, resetDescription: nil)
+        let weeklyWindow = RateWindow(usedPercent: 18, windowMinutes: 10080, resetsAt: nil, resetDescription: nil)
+
+        let remaining = MenuBarDisplayText.codexCombinedPercentText(
+            sessionWindow: sessionWindow,
+            weeklyWindow: weeklyWindow,
+            showUsed: false)
+        let used = MenuBarDisplayText.codexCombinedPercentText(
+            sessionWindow: sessionWindow,
+            weeklyWindow: weeklyWindow,
+            showUsed: true)
+        let weeklyOnly = MenuBarDisplayText.codexCombinedPercentText(
+            sessionWindow: nil,
+            weeklyWindow: weeklyWindow,
+            showUsed: false)
+        let nineHour = MenuBarDisplayText.codexCombinedPercentText(
+            sessionWindow: RateWindow(
+                usedPercent: 7,
+                windowMinutes: 540,
+                resetsAt: nil,
+                resetDescription: nil),
+            weeklyWindow: weeklyWindow,
+            showUsed: false)
+        let unknownSessionDuration = MenuBarDisplayText.codexCombinedPercentText(
+            sessionWindow: RateWindow(
+                usedPercent: 7,
+                windowMinutes: nil,
+                resetsAt: nil,
+                resetDescription: nil),
+            weeklyWindow: weeklyWindow,
+            showUsed: false)
+
+        #expect(remaining == "5h 93% · W 82%")
+        #expect(used == "5h 7% · W 18%")
+        #expect(weeklyOnly == "W 82%")
+        #expect(nineHour == "9h 93% · W 82%")
+        #expect(unknownSessionDuration == "S 93% · W 82%")
+    }
+
+    @Test
+    func `menu bar display text falls back to percent when pace unavailable`() {
         let percentWindow = RateWindow(usedPercent: 40, windowMinutes: nil, resetsAt: nil, resetDescription: nil)
-        let paceWindow = RateWindow(
-            usedPercent: 30,
-            windowMinutes: 10080,
-            resetsAt: now.addingTimeInterval(60 * 60 * 24 * 6),
-            resetDescription: nil)
 
         let pace = MenuBarDisplayText.displayText(
             mode: .pace,
@@ -411,19 +989,13 @@ struct StatusItemAnimationTests {
             percentWindow: percentWindow,
             showUsed: true)
 
-        #expect(pace == nil)
-        #expect(both == nil)
+        #expect(pace == "40%")
+        #expect(both == "40%")
     }
 
     @Test
-    func menuBarDisplayTextRequiresProvidedPaceForCodex() {
-        let now = Date(timeIntervalSince1970: 0)
+    func `menu bar display text falls back to percent when pace nil for codex`() {
         let percentWindow = RateWindow(usedPercent: 40, windowMinutes: nil, resetsAt: nil, resetDescription: nil)
-        let paceWindow = RateWindow(
-            usedPercent: 30,
-            windowMinutes: 10080,
-            resetsAt: now.addingTimeInterval(60 * 60 * 24 * 6),
-            resetDescription: nil)
 
         let pace = MenuBarDisplayText.displayText(
             mode: .pace,
@@ -436,12 +1008,110 @@ struct StatusItemAnimationTests {
             pace: nil,
             showUsed: true)
 
-        #expect(pace == nil)
-        #expect(both == nil)
+        #expect(pace == "40%")
+        #expect(both == "40%")
+    }
+
+    @Test
+    func `claude primary menu bar metric computes pace from selected session window`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "StatusItemAnimationTests-claude-primary-pace"),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .claude
+        settings.menuBarDisplayMode = .both
+        settings.usageBarsShowUsed = false
+        settings.setMenuBarMetricPreference(.primary, for: .claude)
+
+        let registry = ProviderRegistry.shared
+        if let claudeMeta = registry.metadata[.claude] {
+            settings.setProviderEnabled(provider: .claude, metadata: claudeMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let now = Date()
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 80,
+                windowMinutes: 300,
+                resetsAt: now.addingTimeInterval(4 * 60 * 60),
+                resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: 20,
+                windowMinutes: 7 * 24 * 60,
+                resetsAt: now.addingTimeInterval(24 * 60 * 60),
+                resetDescription: nil),
+            updatedAt: now)
+        store._setSnapshotForTesting(snapshot, provider: .claude)
+        store._setErrorForTesting(nil, provider: .claude)
+
+        let displayText = controller.menuBarDisplayText(for: .claude, snapshot: snapshot)
+
+        #expect(displayText == "20% · +60%")
+    }
+
+    @Test
+    func `codex menu bar pace does not fall back to session when weekly projection is unavailable`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "StatusItemAnimationTests-codex-no-weekly-pace"),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        settings.menuBarDisplayMode = .both
+        settings.usageBarsShowUsed = false
+        settings.setMenuBarMetricPreference(.primary, for: .codex)
+
+        let registry = ProviderRegistry.shared
+        if let codexMeta = registry.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let now = Date()
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 80,
+                windowMinutes: 300,
+                resetsAt: now.addingTimeInterval(4 * 60 * 60),
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: now)
+        store._setSnapshotForTesting(snapshot, provider: .codex)
+        store._setErrorForTesting(nil, provider: .codex)
+
+        let displayText = controller.menuBarDisplayText(for: .codex, snapshot: snapshot)
+
+        #expect(displayText == "20%")
     }
 
     @Test
-    func menuBarDisplayTextUsesCreditsWhenCodexWeeklyIsExhausted() {
+    func `menu bar display text uses credits when codex weekly is exhausted`() {
         let settings = SettingsStore(
             configStore: testConfigStore(suiteName: "StatusItemAnimationTests-credits-fallback"),
             zaiTokenStore: NoopZaiTokenStore())
@@ -487,7 +1157,7 @@ struct StatusItemAnimationTests {
     }
 
     @Test
-    func menuBarDisplayTextUsesCreditsWhenCodexSessionIsExhausted() {
+    func `menu bar display text uses credits when codex session is exhausted`() {
         let settings = SettingsStore(
             configStore: testConfigStore(suiteName: "StatusItemAnimationTests-credits-fallback-session"),
             zaiTokenStore: NoopZaiTokenStore())
@@ -533,7 +1203,7 @@ struct StatusItemAnimationTests {
     }
 
     @Test
-    func menuBarDisplayTextShowsZeroPercentForKiloZeroTotalEdge() {
+    func `menu bar display text shows zero percent for kilo zero total edge`() {
         let settings = SettingsStore(
             configStore: testConfigStore(suiteName: "StatusItemAnimationTests-kilo-zero-edge"),
             zaiTokenStore: NoopZaiTokenStore(),
@@ -579,7 +1249,7 @@ struct StatusItemAnimationTests {
     }
 
     @Test
-    func brandImageWithStatusOverlayReturnsOriginalImageWhenNoIssue() {
+    func `brand image with status overlay returns original image when no issue`() {
         let brand = NSImage(size: NSSize(width: 16, height: 16))
         brand.isTemplate = true
 
@@ -589,7 +1259,7 @@ struct StatusItemAnimationTests {
     }
 
     @Test
-    func brandImageWithStatusOverlayDrawsIssueMark() throws {
+    func `brand image with status overlay draws issue mark`() throws {
         let size = NSSize(width: 16, height: 16)
         let brand = NSImage(size: size)
         brand.lockFocus()
diff --git a/Tests/CodexBarTests/StatusItemBalanceDisplayTests.swift b/Tests/CodexBarTests/StatusItemBalanceDisplayTests.swift
new file mode 100644
index 0000000000..2e0670ed6e
--- /dev/null
+++ b/Tests/CodexBarTests/StatusItemBalanceDisplayTests.swift
@@ -0,0 +1,647 @@
+import AppKit
+import CodexBarCore
+import Testing
+@testable import CodexBar
+
+@Suite(.serialized)
+@MainActor
+struct StatusItemBalanceDisplayTests {
+    @Test
+    func `menu bar display text uses open router balance`() {
+        let settings = self.makeSettings(
+            suiteName: "StatusItemBalanceDisplayTests-openrouter-balance",
+            provider: .openrouter)
+        settings.setMenuBarMetricPreference(.automatic, for: .openrouter)
+        let (store, controller) = self.makeStoreAndController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+        let snapshot = Self.openRouterSnapshot()
+
+        store._setSnapshotForTesting(snapshot, provider: .openrouter)
+        store._setErrorForTesting(nil, provider: .openrouter)
+
+        let displayText = controller.menuBarDisplayText(for: .openrouter, snapshot: snapshot)
+
+        #expect(displayText == "$12.34")
+    }
+
+    @Test
+    func `reset time mode preserves automatic open router balance`() {
+        let settings = self.makeSettings(
+            suiteName: "StatusItemBalanceDisplayTests-openrouter-reset-time",
+            provider: .openrouter)
+        settings.menuBarDisplayMode = .resetTime
+        settings.setMenuBarMetricPreference(.automatic, for: .openrouter)
+        let (store, controller) = self.makeStoreAndController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+        let snapshot = Self.openRouterSnapshot()
+
+        store._setSnapshotForTesting(snapshot, provider: .openrouter)
+        store._setErrorForTesting(nil, provider: .openrouter)
+
+        let displayText = controller.menuBarDisplayText(for: .openrouter, snapshot: snapshot)
+
+        #expect(displayText == "$12.34")
+    }
+
+    @Test
+    func `menu bar display text uses zen balance when open code has no subscription`() {
+        let settings = self.makeSettings(
+            suiteName: "StatusItemBalanceDisplayTests-opencodego-zen-only",
+            provider: .opencodego)
+        let (store, controller) = self.makeStoreAndController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            providerCost: ProviderCostSnapshot(
+                used: 23.75,
+                limit: 0,
+                currencyCode: "USD",
+                period: "Zen balance",
+                updatedAt: Date()),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(snapshot, provider: .opencodego)
+        store._setErrorForTesting(nil, provider: .opencodego)
+
+        let displayText = controller.menuBarDisplayText(for: .opencodego, snapshot: snapshot)
+
+        #expect(displayText == "$23.75")
+    }
+
+    @Test
+    func `menu bar display text uses negative zen balance when open code is in deficit`() {
+        let settings = self.makeSettings(
+            suiteName: "StatusItemBalanceDisplayTests-opencodego-zen-deficit",
+            provider: .opencodego)
+        let (store, controller) = self.makeStoreAndController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            providerCost: ProviderCostSnapshot(
+                used: -4.25,
+                limit: 0,
+                currencyCode: "USD",
+                period: "Zen balance",
+                updatedAt: Date()),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(snapshot, provider: .opencodego)
+        store._setErrorForTesting(nil, provider: .opencodego)
+
+        let displayText = controller.menuBarDisplayText(for: .opencodego, snapshot: snapshot)
+
+        #expect(displayText == "-$4.25")
+    }
+
+    @Test
+    func `menu bar display text keeps open code subscription percentage`() {
+        let settings = self.makeSettings(
+            suiteName: "StatusItemBalanceDisplayTests-opencodego-subscription",
+            provider: .opencodego)
+        let (store, controller) = self.makeStoreAndController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 12, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 34, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            providerCost: ProviderCostSnapshot(
+                used: 23.75,
+                limit: 0,
+                currencyCode: "USD",
+                period: "Zen balance",
+                updatedAt: Date()),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(snapshot, provider: .opencodego)
+        store._setErrorForTesting(nil, provider: .opencodego)
+
+        let displayText = controller.menuBarDisplayText(for: .opencodego, snapshot: snapshot)
+
+        #expect(displayText == "12%")
+    }
+
+    @Test
+    func `reset time mode preserves balance when provider has no quota window`() {
+        let settings = self.makeSettings(
+            suiteName: "StatusItemBalanceDisplayTests-moonshot-reset-time",
+            provider: .moonshot)
+        settings.menuBarDisplayMode = .resetTime
+        let (store, controller) = self.makeStoreAndController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .moonshot,
+                accountEmail: nil,
+                accountOrganization: nil,
+                loginMethod: "Balance: $49.58 · $0.42 in deficit"))
+
+        store._setSnapshotForTesting(snapshot, provider: .moonshot)
+        store._setErrorForTesting(nil, provider: .moonshot)
+
+        let displayText = controller.menuBarDisplayText(for: .moonshot, snapshot: snapshot)
+
+        #expect(displayText == "$49.58")
+    }
+
+    @Test
+    func `menu bar display text respects open router primary metric preference`() {
+        let settings = self.makeSettings(
+            suiteName: "StatusItemBalanceDisplayTests-openrouter-primary-metric",
+            provider: .openrouter)
+        settings.setMenuBarMetricPreference(.primary, for: .openrouter)
+        let (store, controller) = self.makeStoreAndController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+        let snapshot = Self.openRouterSnapshot()
+
+        store._setSnapshotForTesting(snapshot, provider: .openrouter)
+        store._setErrorForTesting(nil, provider: .openrouter)
+
+        let displayText = controller.menuBarDisplayText(for: .openrouter, snapshot: snapshot)
+
+        #expect(displayText == "25%")
+    }
+
+    @Test
+    func `menu bar display text skips exhausted cursor api subquota when total remains usable`() {
+        let settings = self.makeSettings(
+            suiteName: "StatusItemBalanceDisplayTests-cursor-exhausted-api",
+            provider: .cursor)
+        settings.usageBarsShowUsed = false
+        settings.setMenuBarMetricPreference(.automatic, for: .cursor)
+        let (store, controller) = self.makeStoreAndController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 67, windowMinutes: 30 * 24 * 60, resetsAt: nil, resetDescription: "Total"),
+            secondary: RateWindow(
+                usedPercent: 34,
+                windowMinutes: 30 * 24 * 60,
+                resetsAt: nil,
+                resetDescription: "Auto"),
+            tertiary: RateWindow(usedPercent: 100, windowMinutes: 30 * 24 * 60, resetsAt: nil, resetDescription: "API"),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(snapshot, provider: .cursor)
+        store._setErrorForTesting(nil, provider: .cursor)
+
+        let displayText = controller.menuBarDisplayText(for: .cursor, snapshot: snapshot)
+
+        #expect(displayText == "33%")
+    }
+
+    @Test
+    func `menu bar display text uses deepseek balance`() {
+        let settings = self.makeSettings(
+            suiteName: "StatusItemBalanceDisplayTests-deepseek-balance",
+            provider: .deepseek)
+        let (store, controller) = self.makeStoreAndController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 0,
+                windowMinutes: nil,
+                resetsAt: nil,
+                resetDescription: "$9.32 (Paid: $9.32 / Granted: $0.00)"),
+            secondary: nil,
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(snapshot, provider: .deepseek)
+        store._setErrorForTesting(nil, provider: .deepseek)
+
+        let displayText = controller.menuBarDisplayText(for: .deepseek, snapshot: snapshot)
+
+        #expect(displayText == "$9.32")
+    }
+
+    @Test
+    func `menu bar display text uses mimo balance without token plan`() {
+        let settings = self.makeSettings(
+            suiteName: "StatusItemBalanceDisplayTests-mimo-balance",
+            provider: .mimo)
+        let (store, controller) = self.makeStoreAndController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+        let snapshot = MiMoUsageSnapshot(
+            balance: 25.51,
+            currency: "USD",
+            cashBalance: 20,
+            giftBalance: 5.51,
+            updatedAt: Date())
+            .toUsageSnapshot()
+
+        store._setSnapshotForTesting(snapshot, provider: .mimo)
+        store._setErrorForTesting(nil, provider: .mimo)
+
+        let displayText = controller.menuBarDisplayText(for: .mimo, snapshot: snapshot)
+
+        #expect(displayText == "$25.51")
+    }
+
+    @Test
+    func `menu bar display text uses selected mimo balance with token plan`() {
+        let settings = self.makeSettings(
+            suiteName: "StatusItemBalanceDisplayTests-mimo-token-plan",
+            provider: .mimo)
+        settings.setMenuBarMetricPreference(.secondary, for: .mimo)
+        let (store, controller) = self.makeStoreAndController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+        let snapshot = MiMoUsageSnapshot(
+            balance: 25.51,
+            currency: "USD",
+            planCode: "standard",
+            tokenUsed: 10,
+            tokenLimit: 100,
+            tokenPercent: 0.1,
+            updatedAt: Date())
+            .toUsageSnapshot()
+
+        store._setSnapshotForTesting(snapshot, provider: .mimo)
+        store._setErrorForTesting(nil, provider: .mimo)
+
+        let displayText = controller.menuBarDisplayText(for: .mimo, snapshot: snapshot)
+
+        #expect(displayText == "$25.51")
+    }
+
+    @Test
+    func `menu bar display text uses moonshot balance`() {
+        let settings = self.makeSettings(
+            suiteName: "StatusItemBalanceDisplayTests-moonshot-balance",
+            provider: .moonshot)
+        let (store, controller) = self.makeStoreAndController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .moonshot,
+                accountEmail: nil,
+                accountOrganization: nil,
+                loginMethod: "Balance: $49.58 · $0.42 in deficit"))
+
+        store._setSnapshotForTesting(snapshot, provider: .moonshot)
+        store._setErrorForTesting(nil, provider: .moonshot)
+
+        let displayText = controller.menuBarDisplayText(for: .moonshot, snapshot: snapshot)
+
+        #expect(snapshot.primary == nil)
+        #expect(displayText == "$49.58")
+    }
+
+    @Test
+    func `menu bar display text uses mistral current month api spend`() {
+        let settings = self.makeSettings(
+            suiteName: "StatusItemBalanceDisplayTests-mistral-spend",
+            provider: .mistral)
+        let (store, controller) = self.makeStoreAndController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+        let snapshot = MistralUsageSnapshot(
+            totalCost: 1.2345,
+            currency: "EUR",
+            currencySymbol: "€",
+            totalInputTokens: 10000,
+            totalOutputTokens: 5000,
+            totalCachedTokens: 0,
+            modelCount: 2,
+            startDate: nil,
+            endDate: nil,
+            updatedAt: Date()).toUsageSnapshot()
+
+        store._setSnapshotForTesting(snapshot, provider: .mistral)
+        store._setErrorForTesting(nil, provider: .mistral)
+
+        let displayText = controller.menuBarDisplayText(for: .mistral, snapshot: snapshot)
+
+        #expect(snapshot.primary == nil)
+        #expect(snapshot.identity?.loginMethod == "API spend: €1.2345 this month")
+        #expect(displayText == "€1.2345")
+    }
+
+    @Test
+    func `menu bar display text uses kimi k2 api key credits`() {
+        let settings = self.makeSettings(
+            suiteName: "StatusItemBalanceDisplayTests-kimik2-credits",
+            provider: .kimik2)
+        let (store, controller) = self.makeStoreAndController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+        let snapshot = KimiK2UsageSummary(
+            consumed: 75,
+            remaining: 1234.5,
+            averageTokens: nil,
+            updatedAt: Date()).toUsageSnapshot()
+
+        store._setSnapshotForTesting(snapshot, provider: .kimik2)
+        store._setErrorForTesting(nil, provider: .kimik2)
+
+        let displayText = controller.menuBarDisplayText(for: .kimik2, snapshot: snapshot)
+
+        #expect(snapshot.primary == nil)
+        #expect(snapshot.identity?.loginMethod == "Credits: 1234.5 left")
+        #expect(displayText == "1234.5")
+    }
+
+    @Test
+    func `kiro menu bar automatic uses credits left`() {
+        let settings = self.makeSettings(
+            suiteName: "StatusItemBalanceDisplayTests-kiro-automatic",
+            provider: .kiro)
+        settings.kiroMenuBarDisplayMode = .automatic
+        let (store, controller) = self.makeStoreAndController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+        let snapshot = Self.kiroSnapshot()
+
+        store._setSnapshotForTesting(snapshot, provider: .kiro)
+        store._setErrorForTesting(nil, provider: .kiro)
+
+        let displayText = controller.menuBarDisplayText(for: .kiro, snapshot: snapshot)
+
+        #expect(displayText == "49.83")
+    }
+
+    @Test
+    func `kiro menu bar credits and percent combines values`() {
+        let settings = self.makeSettings(
+            suiteName: "StatusItemBalanceDisplayTests-kiro-both",
+            provider: .kiro)
+        settings.kiroMenuBarDisplayMode = .creditsAndPercent
+        let (store, controller) = self.makeStoreAndController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+        let snapshot = Self.kiroSnapshot()
+
+        store._setSnapshotForTesting(snapshot, provider: .kiro)
+        store._setErrorForTesting(nil, provider: .kiro)
+
+        let displayText = controller.menuBarDisplayText(for: .kiro, snapshot: snapshot)
+
+        #expect(displayText == "49.83 · 0%")
+    }
+
+    @Test
+    func `kiro menu bar hidden suppresses text value`() {
+        let settings = self.makeSettings(
+            suiteName: "StatusItemBalanceDisplayTests-kiro-hidden",
+            provider: .kiro)
+        settings.kiroMenuBarDisplayMode = .hidden
+        let (store, controller) = self.makeStoreAndController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+        let snapshot = Self.kiroSnapshot()
+
+        store._setSnapshotForTesting(snapshot, provider: .kiro)
+        store._setErrorForTesting(nil, provider: .kiro)
+
+        let displayText = controller.menuBarDisplayText(for: .kiro, snapshot: snapshot)
+
+        #expect(displayText == nil)
+    }
+
+    @Test
+    func `kiro menu bar used and total formats credits`() {
+        let settings = self.makeSettings(
+            suiteName: "StatusItemBalanceDisplayTests-kiro-used-total",
+            provider: .kiro)
+        settings.kiroMenuBarDisplayMode = .usedAndTotal
+        let (store, controller) = self.makeStoreAndController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+        let snapshot = Self.kiroSnapshot()
+
+        store._setSnapshotForTesting(snapshot, provider: .kiro)
+        store._setErrorForTesting(nil, provider: .kiro)
+
+        let displayText = controller.menuBarDisplayText(for: .kiro, snapshot: snapshot)
+
+        #expect(displayText == "0.17 / 50")
+    }
+
+    @Test
+    func `kiro menu bar overage credits mode shows overage credits when exhausted`() {
+        let settings = self.makeSettings(
+            suiteName: "StatusItemBalanceDisplayTests-kiro-overage-credits",
+            provider: .kiro)
+        settings.kiroMenuBarDisplayMode = .overageCreditsWhenExhausted
+        let (store, controller) = self.makeStoreAndController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+        let snapshot = Self.exhaustedKiroSnapshot()
+
+        store._setSnapshotForTesting(snapshot, provider: .kiro)
+        store._setErrorForTesting(nil, provider: .kiro)
+
+        let displayText = controller.menuBarDisplayText(for: .kiro, snapshot: snapshot)
+
+        #expect(displayText == "40.29 over")
+    }
+
+    @Test
+    func `kiro menu bar overage cost mode shows cost when exhausted`() {
+        let settings = self.makeSettings(
+            suiteName: "StatusItemBalanceDisplayTests-kiro-overage-cost",
+            provider: .kiro)
+        settings.kiroMenuBarDisplayMode = .overageCostWhenExhausted
+        let (store, controller) = self.makeStoreAndController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+        let snapshot = Self.exhaustedKiroSnapshot()
+
+        store._setSnapshotForTesting(snapshot, provider: .kiro)
+        store._setErrorForTesting(nil, provider: .kiro)
+
+        let displayText = controller.menuBarDisplayText(for: .kiro, snapshot: snapshot)
+
+        #expect(displayText == "$1.61 over")
+    }
+
+    @Test
+    func `kiro menu bar overage credits and cost mode shows both when exhausted`() {
+        let settings = self.makeSettings(
+            suiteName: "StatusItemBalanceDisplayTests-kiro-overage-both",
+            provider: .kiro)
+        settings.kiroMenuBarDisplayMode = .overageCreditsAndCostWhenExhausted
+        let (store, controller) = self.makeStoreAndController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+        let snapshot = Self.exhaustedKiroSnapshot()
+
+        store._setSnapshotForTesting(snapshot, provider: .kiro)
+        store._setErrorForTesting(nil, provider: .kiro)
+
+        let displayText = controller.menuBarDisplayText(for: .kiro, snapshot: snapshot)
+
+        #expect(displayText == "40.29 · $1.61")
+    }
+
+    @Test
+    func `kiro menu bar overage mode keeps credits left before exhaustion`() {
+        let settings = self.makeSettings(
+            suiteName: "StatusItemBalanceDisplayTests-kiro-overage-not-exhausted",
+            provider: .kiro)
+        settings.kiroMenuBarDisplayMode = .overageCreditsAndCostWhenExhausted
+        let (store, controller) = self.makeStoreAndController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+        let snapshot = Self.kiroSnapshot()
+
+        store._setSnapshotForTesting(snapshot, provider: .kiro)
+        store._setErrorForTesting(nil, provider: .kiro)
+
+        let displayText = controller.menuBarDisplayText(for: .kiro, snapshot: snapshot)
+
+        #expect(displayText == "49.83")
+    }
+
+    @Test
+    func `kiro menu bar overage mode ignores disabled overage values`() {
+        let settings = self.makeSettings(
+            suiteName: "StatusItemBalanceDisplayTests-kiro-overage-disabled",
+            provider: .kiro)
+        settings.kiroMenuBarDisplayMode = .overageCreditsAndCostWhenExhausted
+        let (store, controller) = self.makeStoreAndController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+        let snapshot = Self.exhaustedKiroSnapshot(overagesStatus: "Disabled")
+
+        store._setSnapshotForTesting(snapshot, provider: .kiro)
+        store._setErrorForTesting(nil, provider: .kiro)
+
+        let displayText = controller.menuBarDisplayText(for: .kiro, snapshot: snapshot)
+
+        #expect(displayText == "0")
+    }
+
+    @Test
+    func `kiro managed plan display falls back to percent`() {
+        let settings = self.makeSettings(
+            suiteName: "StatusItemBalanceDisplayTests-kiro-managed",
+            provider: .kiro)
+        settings.kiroMenuBarDisplayMode = .automatic
+        settings.usageBarsShowUsed = false
+        let (store, controller) = self.makeStoreAndController(settings: settings)
+        defer { controller.releaseStatusItemsForTesting() }
+        let snapshot = KiroUsageSnapshot(
+            planName: "Q Developer Pro",
+            creditsUsed: 0,
+            creditsTotal: 0,
+            creditsPercent: 0,
+            bonusCreditsUsed: nil,
+            bonusCreditsTotal: nil,
+            bonusExpiryDays: nil,
+            resetsAt: nil,
+            updatedAt: Date()).toUsageSnapshot()
+
+        store._setSnapshotForTesting(snapshot, provider: .kiro)
+        store._setErrorForTesting(nil, provider: .kiro)
+
+        let displayText = controller.menuBarDisplayText(for: .kiro, snapshot: snapshot)
+
+        #expect(displayText == "100%")
+    }
+
+    @Test
+    func `mistral primary window is nil even when billing end date is set`() {
+        let endDate = Date(timeIntervalSinceNow: 3600)
+        let snapshot = MistralUsageSnapshot(
+            totalCost: 0.5,
+            currency: "USD",
+            currencySymbol: "$",
+            totalInputTokens: 1000,
+            totalOutputTokens: 500,
+            totalCachedTokens: 0,
+            modelCount: 1,
+            startDate: nil,
+            endDate: endDate,
+            updatedAt: Date()).toUsageSnapshot()
+
+        // Mistral doesn't expose a reset time — primary is always nil.
+        #expect(snapshot.primary == nil)
+    }
+
+    @Test
+    func `button title spacing only applies when image is present`() {
+        #expect(StatusItemController.buttonTitle("42%", hasImage: true) == " 42%")
+        #expect(StatusItemController.buttonTitle("42%", hasImage: false) == "42%")
+        #expect(StatusItemController.buttonTitle(nil, hasImage: true).isEmpty)
+        #expect(StatusItemController.buttonTitle("", hasImage: true).isEmpty)
+    }
+
+    private func makeSettings(suiteName: String, provider: UsageProvider) -> SettingsStore {
+        let settings = testSettingsStore(suiteName: suiteName)
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = provider
+        settings.menuBarDisplayMode = .both
+        settings.usageBarsShowUsed = true
+
+        let registry = ProviderRegistry.shared
+        if let metadata = registry.metadata[provider] {
+            settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: true)
+        }
+        return settings
+    }
+
+    private func makeStoreAndController(settings: SettingsStore) -> (UsageStore, StatusItemController) {
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: testStatusBar())
+        return (store, controller)
+    }
+
+    private static func openRouterSnapshot() -> UsageSnapshot {
+        OpenRouterUsageSnapshot(
+            totalCredits: 50,
+            totalUsage: 37.66,
+            balance: 12.34,
+            usedPercent: 75.32,
+            keyLimit: 20,
+            keyUsage: 5,
+            rateLimit: nil,
+            updatedAt: Date()).toUsageSnapshot()
+    }
+
+    private static func kiroSnapshot() -> UsageSnapshot {
+        KiroUsageSnapshot(
+            planName: "KIRO FREE",
+            accountEmail: "person@example.com",
+            authMethod: "Google",
+            creditsUsed: 0.17,
+            creditsTotal: 50,
+            creditsPercent: 0,
+            bonusCreditsUsed: 45.53,
+            bonusCreditsTotal: 2000,
+            bonusExpiryDays: 19,
+            overagesStatus: "Disabled",
+            manageURL: "https://app.kiro.dev/account/usage",
+            contextUsage: KiroContextUsageSnapshot(
+                totalPercentUsed: 1.3,
+                contextFilesPercent: 0.5,
+                toolsPercent: 0.8,
+                kiroResponsesPercent: 0,
+                promptsPercent: 0),
+            resetsAt: Date(),
+            updatedAt: Date()).toUsageSnapshot()
+    }
+
+    private static func exhaustedKiroSnapshot(overagesStatus: String = "Enabled billed at $0.04 per request")
+        -> UsageSnapshot
+    {
+        KiroUsageSnapshot(
+            planName: "KIRO FREE",
+            accountEmail: "person@example.com",
+            authMethod: "Google",
+            creditsUsed: 50,
+            creditsTotal: 50,
+            creditsPercent: 100,
+            bonusCreditsUsed: nil,
+            bonusCreditsTotal: nil,
+            bonusExpiryDays: nil,
+            overagesStatus: overagesStatus,
+            overageCreditsUsed: 40.29,
+            estimatedOverageCostUSD: 1.61,
+            manageURL: "https://app.kiro.dev/account/usage",
+            resetsAt: Date(),
+            updatedAt: Date()).toUsageSnapshot()
+    }
+}
diff --git a/Tests/CodexBarTests/StatusItemControllerMenuTests.swift b/Tests/CodexBarTests/StatusItemControllerMenuTests.swift
index 976a0d9656..9e3f2d3de8 100644
--- a/Tests/CodexBarTests/StatusItemControllerMenuTests.swift
+++ b/Tests/CodexBarTests/StatusItemControllerMenuTests.swift
@@ -1,30 +1,66 @@
+import AppKit
 import CodexBarCore
 import Foundation
 import Testing
 @testable import CodexBar
 
-@Suite
 struct StatusItemControllerMenuTests {
-    private func makeSnapshot(primary: RateWindow?, secondary: RateWindow?) -> UsageSnapshot {
-        UsageSnapshot(primary: primary, secondary: secondary, updatedAt: Date())
+    @MainActor
+    private final class RecordingUpdater: UpdaterProviding {
+        var automaticallyChecksForUpdates = false
+        var automaticallyDownloadsUpdates = false
+        let isAvailable = true
+        let unavailableReason: String? = nil
+        let updateStatus = UpdateStatus(isUpdateReady: true)
+        var checkForUpdatesCount = 0
+        var installUpdateCount = 0
+
+        func checkForUpdates(_ sender: Any?) {
+            _ = sender
+            self.checkForUpdatesCount += 1
+        }
+
+        func installUpdate() {
+            self.installUpdateCount += 1
+        }
+    }
+
+    private func makeSnapshot(
+        primary: RateWindow?,
+        secondary: RateWindow?,
+        tertiary: RateWindow? = nil,
+        providerCost: ProviderCostSnapshot? = nil)
+        -> UsageSnapshot
+    {
+        UsageSnapshot(
+            primary: primary,
+            secondary: secondary,
+            tertiary: tertiary,
+            providerCost: providerCost,
+            updatedAt: Date())
     }
 
     @Test
-    func cursorSwitcherFallsBackToSecondaryWhenPlanExhaustedAndShowingRemaining() {
+    func `cursor switcher falls back to on demand budget when plan exhausted and showing remaining`() {
         let primary = RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil)
         let secondary = RateWindow(usedPercent: 36, windowMinutes: nil, resetsAt: nil, resetDescription: nil)
-        let snapshot = self.makeSnapshot(primary: primary, secondary: secondary)
+        let providerCost = ProviderCostSnapshot(
+            used: 12,
+            limit: 200,
+            currencyCode: "USD",
+            updatedAt: Date())
+        let snapshot = self.makeSnapshot(primary: primary, secondary: secondary, providerCost: providerCost)
 
         let percent = StatusItemController.switcherWeeklyMetricPercent(
             for: .cursor,
             snapshot: snapshot,
             showUsed: false)
 
-        #expect(percent == 64)
+        #expect(percent == 94)
     }
 
     @Test
-    func cursorSwitcherUsesPrimaryWhenShowingUsed() {
+    func `cursor switcher uses primary when showing used`() {
         let primary = RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil)
         let secondary = RateWindow(usedPercent: 36, windowMinutes: nil, resetsAt: nil, resetDescription: nil)
         let snapshot = self.makeSnapshot(primary: primary, secondary: secondary)
@@ -38,7 +74,7 @@ struct StatusItemControllerMenuTests {
     }
 
     @Test
-    func cursorSwitcherKeepsPrimaryWhenRemainingIsPositive() {
+    func `cursor switcher keeps primary when remaining is positive`() {
         let primary = RateWindow(usedPercent: 20, windowMinutes: nil, resetsAt: nil, resetDescription: nil)
         let secondary = RateWindow(usedPercent: 40, windowMinutes: nil, resetsAt: nil, resetDescription: nil)
         let snapshot = self.makeSnapshot(primary: primary, secondary: secondary)
@@ -52,57 +88,77 @@ struct StatusItemControllerMenuTests {
     }
 
     @Test
-    func openRouterBrandFallbackEnabledWhenNoKeyLimitConfigured() {
-        let snapshot = OpenRouterUsageSnapshot(
-            totalCredits: 50,
-            totalUsage: 45,
-            balance: 5,
-            usedPercent: 90,
-            keyDataFetched: true,
-            keyLimit: nil,
-            keyUsage: nil,
-            rateLimit: nil,
-            updatedAt: Date()).toUsageSnapshot()
-
-        #expect(StatusItemController.shouldUseOpenRouterBrandFallback(
-            provider: .openrouter,
-            snapshot: snapshot))
-        #expect(MenuBarDisplayText.percentText(window: snapshot.primary, showUsed: false) == nil)
+    func `cursor switcher does not treat auto lane as extra remaining quota`() {
+        let primary = RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil)
+        let secondary = RateWindow(usedPercent: 36, windowMinutes: nil, resetsAt: nil, resetDescription: nil)
+        let snapshot = self.makeSnapshot(primary: primary, secondary: secondary)
+
+        let percent = StatusItemController.switcherWeeklyMetricPercent(
+            for: .cursor,
+            snapshot: snapshot,
+            showUsed: false)
+
+        #expect(percent == 0)
+    }
+
+    @Test
+    func `perplexity switcher falls back after recurring credits are exhausted`() {
+        let primary = RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil)
+        let secondary = RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil)
+        let tertiary = RateWindow(usedPercent: 24, windowMinutes: nil, resetsAt: nil, resetDescription: nil)
+        let snapshot = self.makeSnapshot(primary: primary, secondary: secondary, tertiary: tertiary)
+
+        let percent = StatusItemController.switcherWeeklyMetricPercent(
+            for: .perplexity,
+            snapshot: snapshot,
+            showUsed: false)
+
+        #expect(percent == 76)
     }
 
     @Test
-    func openRouterBrandFallbackDisabledWhenKeyQuotaFetchUnavailable() {
-        let snapshot = OpenRouterUsageSnapshot(
-            totalCredits: 50,
-            totalUsage: 45,
-            balance: 5,
-            usedPercent: 90,
-            keyDataFetched: false,
-            keyLimit: nil,
-            keyUsage: nil,
-            rateLimit: nil,
-            updatedAt: Date()).toUsageSnapshot()
-
-        #expect(!StatusItemController.shouldUseOpenRouterBrandFallback(
-            provider: .openrouter,
-            snapshot: snapshot))
+    @MainActor
+    func `menu card width stays at base width when menu accessories are present`() {
+        let shortcutMenu = NSMenu()
+        let refreshItem = NSMenuItem(title: "Refresh", action: nil, keyEquivalent: "r")
+        shortcutMenu.addItem(refreshItem)
+        #expect(ceil(shortcutMenu.size.width) < 310)
+
+        let submenuMenu = NSMenu()
+        let parentItem = NSMenuItem(title: "Session", action: nil, keyEquivalent: "")
+        parentItem.submenu = NSMenu(title: "Session")
+        submenuMenu.addItem(parentItem)
+        #expect(ceil(submenuMenu.size.width) < 310)
     }
 
     @Test
-    func openRouterBrandFallbackDisabledWhenKeyQuotaAvailable() {
-        let snapshot = OpenRouterUsageSnapshot(
-            totalCredits: 50,
-            totalUsage: 45,
-            balance: 5,
-            usedPercent: 90,
-            keyLimit: 20,
-            keyUsage: 2,
-            rateLimit: nil,
-            updatedAt: Date()).toUsageSnapshot()
-
-        #expect(!StatusItemController.shouldUseOpenRouterBrandFallback(
-            provider: .openrouter,
-            snapshot: snapshot))
-        #expect(snapshot.primary?.usedPercent == 10)
+    @MainActor
+    func `update menu action installs prepared update instead of checking again`() throws {
+        let suite = "StatusItemControllerMenuTests-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let updater = RecordingUpdater()
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: updater,
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system)
+
+        controller.installUpdate()
+
+        #expect(updater.installUpdateCount == 1)
+        #expect(updater.checkForUpdatesCount == 0)
     }
 }
diff --git a/Tests/CodexBarTests/StatusItemControllerShutdownTests.swift b/Tests/CodexBarTests/StatusItemControllerShutdownTests.swift
new file mode 100644
index 0000000000..34e1ea0cd4
--- /dev/null
+++ b/Tests/CodexBarTests/StatusItemControllerShutdownTests.swift
@@ -0,0 +1,134 @@
+import AppKit
+import CodexBarCore
+import Testing
+@testable import CodexBar
+
+@MainActor
+@Suite(.serialized)
+struct StatusItemControllerShutdownTests {
+    @Test
+    func `app shutdown closes tracked menus and removes status items`() {
+        StatusItemController.menuCardRenderingEnabled = false
+        StatusItemController.setMenuRefreshEnabledForTesting(true)
+        defer {
+            StatusItemController.menuCardRenderingEnabled = !SettingsStore.isRunningTests
+            StatusItemController.resetMenuRefreshEnabledForTesting()
+        }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        let registry = ProviderRegistry.shared
+        if let codexMetadata = registry.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMetadata, enabled: true)
+        }
+        if let claudeMetadata = registry.metadata[.claude] {
+            settings.setProviderEnabled(provider: .claude, metadata: claudeMetadata, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system)
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        let key = ObjectIdentifier(menu)
+        controller.menuRefreshTasks[key] = Task { try? await Task.sleep(for: .seconds(30)) }
+        controller.menuReadinessSignatures[key] = "readiness"
+        controller.menuIdentitySignatures[key] = "identity"
+
+        #expect(controller.openMenus[key] === menu)
+        #expect(controller.mergedMenu != nil)
+        #expect(controller.statusItem.menu === controller.mergedMenu)
+
+        controller.prepareForAppShutdown()
+        controller.prepareForAppShutdown()
+
+        #expect(controller.hasPreparedForAppShutdown)
+        #expect(controller.openMenus.isEmpty)
+        #expect(controller.menuRefreshTasks.isEmpty)
+        #expect(controller.menuReadinessSignatures.isEmpty)
+        #expect(controller.menuIdentitySignatures.isEmpty)
+        #expect(controller.providerSwitcherShortcutEventMonitor == nil)
+        #expect(controller.statusItem.menu == nil)
+        #expect(controller.statusItems.isEmpty)
+        #expect(controller.providerMenus.isEmpty)
+        #expect(controller.mergedMenu == nil)
+    }
+
+    @Test
+    func `status menu quit defers shutdown until menu tracking can unwind`() {
+        let controller = self.makeController()
+        defer {
+            StatusItemController.menuCardRenderingEnabled = !SettingsStore.isRunningTests
+            StatusItemController.resetMenuRefreshEnabledForTesting()
+        }
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        let key = ObjectIdentifier(menu)
+
+        var scheduledTermination: (@MainActor () -> Void)?
+        var didTerminate = false
+        controller.scheduleQuitTermination = { operation in
+            scheduledTermination = operation
+        }
+        controller.terminateApplicationForQuit = {
+            didTerminate = true
+        }
+
+        controller.quit()
+
+        #expect(scheduledTermination != nil)
+        #expect(!controller.hasPreparedForAppShutdown)
+        #expect(!didTerminate)
+        #expect(controller.openMenus[key] === menu)
+
+        scheduledTermination?()
+
+        #expect(controller.hasPreparedForAppShutdown)
+        #expect(controller.openMenus.isEmpty)
+        #expect(controller.statusItem.menu == nil)
+        #expect(didTerminate)
+    }
+
+    private func makeController() -> StatusItemController {
+        StatusItemController.menuCardRenderingEnabled = false
+        StatusItemController.setMenuRefreshEnabledForTesting(true)
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        if let codexMetadata = ProviderRegistry.shared.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMetadata, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        return StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system)
+    }
+
+    private func makeSettings() -> SettingsStore {
+        let suite = "StatusItemControllerShutdownTests-\(UUID().uuidString)"
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        return SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+    }
+}
diff --git a/Tests/CodexBarTests/StatusItemControllerSplitLifecycleTests.swift b/Tests/CodexBarTests/StatusItemControllerSplitLifecycleTests.swift
new file mode 100644
index 0000000000..6d4f605390
--- /dev/null
+++ b/Tests/CodexBarTests/StatusItemControllerSplitLifecycleTests.swift
@@ -0,0 +1,503 @@
+import AppKit
+import CodexBarCore
+import Testing
+@testable import CodexBar
+
+@MainActor
+@Suite(.serialized)
+struct StatusItemControllerSplitLifecycleTests {
+    private func disableMenuCardsForTesting() {
+        StatusItemController.menuCardRenderingEnabled = false
+        StatusItemController.setMenuRefreshEnabledForTesting(false)
+    }
+
+    private func makeStatusBarForTesting() -> NSStatusBar {
+        .system
+    }
+
+    private func makeSettings() -> SettingsStore {
+        let suite = "StatusItemControllerSplitLifecycleTests-\(UUID().uuidString)"
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        return SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+    }
+
+    private func containsHostingView(_ view: NSView) -> Bool {
+        if String(describing: type(of: view)).contains("NSHostingView") {
+            return true
+        }
+        return view.subviews.contains { self.containsHostingView($0) }
+    }
+
+    private func makeSplitController() throws -> (SettingsStore, StatusItemController) {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.providerDetectionCompleted = true
+
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            if let metadata = registry.metadata[provider] {
+                settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: false)
+            }
+        }
+        try settings.setProviderEnabled(provider: .codex, metadata: #require(registry.metadata[.codex]), enabled: true)
+        try settings.setProviderEnabled(
+            provider: .claude,
+            metadata: #require(registry.metadata[.claude]),
+            enabled: true)
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        return (settings, controller)
+    }
+
+    @Test
+    func `merged mode removes split provider status items`() throws {
+        let (settings, controller) = try self.makeSplitController()
+        defer { controller.releaseStatusItemsForTesting() }
+
+        #expect(controller.statusItems[.codex] != nil)
+        #expect(controller.statusItems[.claude] != nil)
+
+        settings.mergeIcons = true
+        controller.handleProviderConfigChange(reason: "test")
+
+        #expect(controller.statusItem.isVisible == true)
+        #expect(controller.statusItems.isEmpty)
+    }
+
+    @Test
+    func `removing split provider status items clears all menu lifecycle state`() throws {
+        let (settings, controller) = try self.makeSplitController()
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menus = try [UsageProvider.codex, .claude].map { provider in
+            try #require(controller.providerMenus[provider])
+        }
+        let keys = menus.map(ObjectIdentifier.init)
+        for (menu, key) in zip(menus, keys) {
+            controller.menuProviders[key] = .codex
+            controller.menuReadinessSignatures[key] = "readiness"
+            controller.menuIdentitySignatures[key] = "identity"
+            controller.menuSession.markFresh(key)
+            controller.menuSession.deferUntilNextOpen(key)
+            controller.menuSession.deferParentRebuild(key)
+            controller.openMenus[key] = menu
+            controller.menuRefreshTasks[key] = Task {
+                try? await Task.sleep(for: .seconds(60))
+            }
+            controller.closedMenuRebuildTasks[key] = Task {
+                try? await Task.sleep(for: .seconds(60))
+            }
+            controller.openMenuRebuildTasks[key] = Task {
+                try? await Task.sleep(for: .seconds(60))
+            }
+            _ = controller.closedMenuRebuildRequests.replaceRequest(for: key)
+            _ = controller.openMenuRebuildRequests.replaceRequest(for: key)
+            controller.openMenuRebuildsClosingHostedSubviewMenus.insert(key)
+            controller.highlightedMenuItems[key] = NSMenuItem(title: "Highlighted", action: nil, keyEquivalent: "")
+        }
+
+        settings.mergeIcons = true
+        controller.handleProviderConfigChange(reason: "test")
+
+        for key in keys {
+            #expect(controller.menuProviders[key] == nil)
+            #expect(controller.menuReadinessSignatures[key] == nil)
+            #expect(controller.menuIdentitySignatures[key] == nil)
+            #expect(controller.menuSession.renderedVersion(for: key) == nil)
+            #expect(!controller.menuSession.isDeferredUntilNextOpen(key))
+            #expect(!controller.menuSession.isParentRebuildDeferred(key))
+            #expect(controller.openMenus[key] == nil)
+            #expect(controller.menuRefreshTasks[key] == nil)
+            #expect(controller.closedMenuRebuildTasks[key] == nil)
+            #expect(controller.openMenuRebuildTasks[key] == nil)
+            #expect(controller.closedMenuRebuildRequests.tokens[key] == nil)
+            #expect(controller.openMenuRebuildRequests.tokens[key] == nil)
+            #expect(!controller.openMenuRebuildsClosingHostedSubviewMenus.contains(key))
+            #expect(controller.highlightedMenuItems[key] == nil)
+        }
+    }
+
+    @Test
+    func `menu bar icons stay appkit hosted`() throws {
+        let (settings, controller) = try self.makeSplitController()
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let codexButton = try #require(controller.statusItems[.codex]?.button)
+        #expect(codexButton.image != nil)
+        #expect(!self.containsHostingView(codexButton))
+
+        settings.mergeIcons = true
+        controller.handleProviderConfigChange(reason: "test")
+
+        let mergedButton = try #require(controller.statusItem.button)
+        #expect(mergedButton.image != nil)
+        #expect(!self.containsHostingView(mergedButton))
+    }
+
+    @Test
+    func `status items publish stable manager identity`() throws {
+        let (_, controller) = try self.makeSplitController()
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let codexButton = try #require(controller.statusItems[.codex]?.button)
+        let claudeButton = try #require(controller.statusItems[.claude]?.button)
+
+        #expect(controller.statusItem.autosaveName == "codexbar-merged")
+        #expect(controller.statusItems[.codex]?.autosaveName == "codexbar-codex")
+        #expect(controller.statusItems[.claude]?.autosaveName == "codexbar-claude")
+        #expect(controller.statusItem.button?.accessibilityIdentifier() == "CodexBar.StatusItem")
+        #expect(codexButton.accessibilityIdentifier() == "CodexBar.StatusItem.codex")
+        #expect(claudeButton.accessibilityIdentifier() == "CodexBar.StatusItem.claude")
+        #expect(controller.statusItem.button?.accessibilityTitle() == "CodexBar")
+        #expect(codexButton.accessibilityTitle() == "CodexBar")
+        #expect(claudeButton.accessibilityTitle() == "CodexBar")
+    }
+
+    @Test
+    func `status item identity returns stable autosave names`() {
+        #expect(StatusItemController.StatusItemIdentity.merged.autosaveName == "codexbar-merged")
+        #expect(StatusItemController.StatusItemIdentity.provider(.codex).autosaveName == "codexbar-codex")
+        #expect(StatusItemController.StatusItemIdentity.provider(.claude).autosaveName == "codexbar-claude")
+    }
+
+    @Test
+    func `status item placement preflight leaves fresh install placement unset`() throws {
+        let suite = "StatusItemControllerSplitLifecycleTests-placement-missing-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        defer { defaults.removePersistentDomain(forName: suite) }
+
+        let key = MenuBarStatusItemPlacementPreflight.preferredPositionKey(autosaveName: "codexbar-merged")
+
+        #expect(!MenuBarStatusItemPlacementPreflight.prepare(defaults: defaults, autosaveName: "codexbar-merged"))
+        #expect(defaults.object(forKey: key) == nil)
+    }
+
+    @Test
+    func `status item placement preflight preserves missing new key when legacy item placement exists`() throws {
+        let suite = "StatusItemControllerSplitLifecycleTests-placement-legacy-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        defer { defaults.removePersistentDomain(forName: suite) }
+        defaults.set(42, forKey: "NSStatusItem Preferred Position Item-0")
+        let key = MenuBarStatusItemPlacementPreflight.preferredPositionKey(autosaveName: "codexbar-merged")
+
+        #expect(!MenuBarStatusItemPlacementPreflight.prepare(
+            defaults: defaults,
+            autosaveName: "codexbar-merged",
+            legacyDefaultItemIndex: 0))
+
+        #expect(defaults.object(forKey: key) == nil)
+        #expect(defaults.double(forKey: "NSStatusItem Preferred Position Item-0") == 42)
+    }
+
+    @Test
+    func `status item placement preflight clears suspicious matching legacy placement`() throws {
+        let suite = "StatusItemControllerSplitLifecycleTests-placement-legacy-high-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        defer { defaults.removePersistentDomain(forName: suite) }
+        defaults.set(11298, forKey: "NSStatusItem Preferred Position Item-0")
+        let key = MenuBarStatusItemPlacementPreflight.preferredPositionKey(autosaveName: "codexbar-merged")
+
+        #expect(MenuBarStatusItemPlacementPreflight.prepare(
+            defaults: defaults,
+            autosaveName: "codexbar-merged",
+            legacyDefaultItemIndex: 0,
+            maximumPreferredPosition: 3000))
+
+        #expect(defaults.object(forKey: key) == nil)
+        #expect(defaults.object(forKey: "NSStatusItem Preferred Position Item-0") == nil)
+    }
+
+    @Test
+    func `status item placement preflight preserves missing new key when mixed legacy placements exist`() throws {
+        let suite = "StatusItemControllerSplitLifecycleTests-placement-legacy-mixed-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        defer { defaults.removePersistentDomain(forName: suite) }
+        defaults.set(42, forKey: "NSStatusItem Preferred Position Item-0")
+        defaults.set(11298, forKey: "NSStatusItem Preferred Position Item-1")
+        let key = MenuBarStatusItemPlacementPreflight.preferredPositionKey(autosaveName: "codexbar-merged")
+
+        #expect(!MenuBarStatusItemPlacementPreflight.prepare(
+            defaults: defaults,
+            autosaveName: "codexbar-merged",
+            legacyDefaultItemIndex: 0))
+
+        #expect(defaults.object(forKey: key) == nil)
+        #expect(defaults.double(forKey: "NSStatusItem Preferred Position Item-0") == 42)
+        #expect(defaults.double(forKey: "NSStatusItem Preferred Position Item-1") == 11298)
+    }
+
+    @Test
+    func `status item placement preflight clears provider matching suspicious legacy placement`() throws {
+        let suite = "StatusItemControllerSplitLifecycleTests-placement-provider-mixed-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        defer { defaults.removePersistentDomain(forName: suite) }
+        defaults.set(42, forKey: "NSStatusItem Preferred Position Item-0")
+        defaults.set(11298, forKey: "NSStatusItem Preferred Position Item-1")
+        let key = MenuBarStatusItemPlacementPreflight.preferredPositionKey(autosaveName: "codexbar-codex")
+
+        #expect(MenuBarStatusItemPlacementPreflight.prepare(
+            defaults: defaults,
+            autosaveName: "codexbar-codex",
+            legacyDefaultItemIndex: 1,
+            maximumPreferredPosition: 3000))
+
+        #expect(defaults.object(forKey: key) == nil)
+        #expect(defaults.double(forKey: "NSStatusItem Preferred Position Item-0") == 42)
+        #expect(defaults.object(forKey: "NSStatusItem Preferred Position Item-1") == nil)
+    }
+
+    @Test
+    func `status item placement preflight leaves provider key unset when only merged legacy placement exists`() throws {
+        let suite = "StatusItemControllerSplitLifecycleTests-placement-provider-single-legacy-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        defer { defaults.removePersistentDomain(forName: suite) }
+        defaults.set(42, forKey: "NSStatusItem Preferred Position Item-0")
+        let key = MenuBarStatusItemPlacementPreflight.preferredPositionKey(autosaveName: "codexbar-codex")
+
+        #expect(!MenuBarStatusItemPlacementPreflight.prepare(
+            defaults: defaults,
+            autosaveName: "codexbar-codex",
+            legacyDefaultItemIndex: 1))
+
+        #expect(defaults.object(forKey: key) == nil)
+        #expect(defaults.double(forKey: "NSStatusItem Preferred Position Item-0") == 42)
+    }
+
+    @Test
+    func `status item placement preflight preserves provider key with matching legacy placement`() throws {
+        let suite = "StatusItemControllerSplitLifecycleTests-placement-provider-matching-legacy-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        defer { defaults.removePersistentDomain(forName: suite) }
+        defaults.set(42, forKey: "NSStatusItem Preferred Position Item-0")
+        defaults.set(58, forKey: "NSStatusItem Preferred Position Item-1")
+        let key = MenuBarStatusItemPlacementPreflight.preferredPositionKey(autosaveName: "codexbar-codex")
+
+        #expect(!MenuBarStatusItemPlacementPreflight.prepare(
+            defaults: defaults,
+            autosaveName: "codexbar-codex",
+            legacyDefaultItemIndex: 1))
+
+        #expect(defaults.object(forKey: key) == nil)
+        #expect(defaults.double(forKey: "NSStatusItem Preferred Position Item-0") == 42)
+        #expect(defaults.double(forKey: "NSStatusItem Preferred Position Item-1") == 58)
+    }
+
+    @Test
+    func `status item placement preflight clears suspicious high position`() throws {
+        let suite = "StatusItemControllerSplitLifecycleTests-placement-high-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        defer { defaults.removePersistentDomain(forName: suite) }
+        let key = MenuBarStatusItemPlacementPreflight.preferredPositionKey(autosaveName: "codexbar-merged")
+        defaults.set(11298, forKey: key)
+
+        #expect(MenuBarStatusItemPlacementPreflight.prepare(
+            defaults: defaults,
+            autosaveName: "codexbar-merged",
+            maximumPreferredPosition: 3000))
+
+        #expect(defaults.object(forKey: key) == nil)
+    }
+
+    @Test
+    func `status item placement preflight clears old forced zero position`() throws {
+        let suite = "StatusItemControllerSplitLifecycleTests-placement-zero-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        defer { defaults.removePersistentDomain(forName: suite) }
+        let key = MenuBarStatusItemPlacementPreflight.preferredPositionKey(autosaveName: "codexbar-merged")
+        defaults.set(0, forKey: key)
+
+        #expect(MenuBarStatusItemPlacementPreflight.prepare(defaults: defaults, autosaveName: "codexbar-merged"))
+
+        #expect(defaults.object(forKey: key) == nil)
+    }
+
+    @Test
+    func `status item placement preflight clears malformed position`() throws {
+        let suite = "StatusItemControllerSplitLifecycleTests-placement-malformed-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        defer { defaults.removePersistentDomain(forName: suite) }
+        let key = MenuBarStatusItemPlacementPreflight.preferredPositionKey(autosaveName: "codexbar-merged")
+        defaults.set("not-a-position", forKey: key)
+
+        #expect(MenuBarStatusItemPlacementPreflight.prepare(defaults: defaults, autosaveName: "codexbar-merged"))
+
+        #expect(defaults.object(forKey: key) == nil)
+    }
+
+    @Test
+    func `status item placement preflight preserves reasonable position`() throws {
+        let suite = "StatusItemControllerSplitLifecycleTests-placement-preserve-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        defer { defaults.removePersistentDomain(forName: suite) }
+        let key = MenuBarStatusItemPlacementPreflight.preferredPositionKey(autosaveName: "codexbar-merged")
+        defaults.set(42, forKey: key)
+
+        #expect(!MenuBarStatusItemPlacementPreflight.prepare(defaults: defaults, autosaveName: "codexbar-merged"))
+
+        #expect(defaults.double(forKey: key) == 42)
+    }
+
+    @Test
+    func `status item placement preflight preserves large display position`() throws {
+        let suite = "StatusItemControllerSplitLifecycleTests-placement-preserve-large-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        defer { defaults.removePersistentDomain(forName: suite) }
+        let key = MenuBarStatusItemPlacementPreflight.preferredPositionKey(autosaveName: "codexbar-merged")
+        defaults.set(2500, forKey: key)
+
+        #expect(!MenuBarStatusItemPlacementPreflight.prepare(
+            defaults: defaults,
+            autosaveName: "codexbar-merged",
+            maximumPreferredPosition: 2560))
+
+        #expect(defaults.double(forKey: key) == 2500)
+    }
+
+    @Test
+    func `status item defaults repair removes stale hidden Control Center keys once`() throws {
+        let suite = "StatusItemControllerSplitLifecycleTests-repair-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        defaults.set(false, forKey: "NSStatusItem VisibleCC Item-0")
+        defaults.set(0, forKey: "NSStatusItem VisibleCC Item-12")
+        defaults.set(false, forKey: "NSStatusItem VisibleCC codexbar-merged")
+        defaults.set(true, forKey: "NSStatusItem VisibleCC Item-1")
+        defaults.set(false, forKey: "NSStatusItem VisibleCC com.apple.clock")
+        defer {
+            defaults.removePersistentDomain(forName: suite)
+        }
+
+        let repairedKeys = MenuBarStatusItemDefaultsRepair.repairHiddenVisibilityDefaultsIfNeeded(defaults: defaults)
+
+        #expect(repairedKeys == [
+            "NSStatusItem VisibleCC Item-0",
+            "NSStatusItem VisibleCC Item-12",
+            "NSStatusItem VisibleCC codexbar-merged",
+        ])
+        #expect(defaults.object(forKey: "NSStatusItem VisibleCC Item-0") == nil)
+        #expect(defaults.object(forKey: "NSStatusItem VisibleCC Item-12") == nil)
+        #expect(defaults.object(forKey: "NSStatusItem VisibleCC codexbar-merged") == nil)
+        #expect(defaults.bool(forKey: "NSStatusItem VisibleCC Item-1"))
+        #expect(defaults.object(forKey: "NSStatusItem VisibleCC com.apple.clock") != nil)
+
+        defaults.set(false, forKey: "NSStatusItem VisibleCC Item-2")
+        #expect(MenuBarStatusItemDefaultsRepair.repairHiddenVisibilityDefaultsIfNeeded(defaults: defaults).isEmpty)
+        #expect(defaults.object(forKey: "NSStatusItem VisibleCC Item-2") != nil)
+    }
+
+    @Test
+    func `non destructive visibility refresh preserves split provider status items`() throws {
+        let (_, controller) = try self.makeSplitController()
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let oldCodexItem = try #require(controller.statusItems[.codex])
+        let oldClaudeItem = try #require(controller.statusItems[.claude])
+        let oldCodexButton = try #require(oldCodexItem.button)
+
+        controller.refreshExistingStatusItemsForVisibilityRecovery()
+
+        let newCodexItem = try #require(controller.statusItems[.codex])
+        let newClaudeItem = try #require(controller.statusItems[.claude])
+        #expect(newCodexItem === oldCodexItem)
+        #expect(newClaudeItem === oldClaudeItem)
+        #expect(newCodexItem.button === oldCodexButton)
+        #expect(newCodexItem.autosaveName == "codexbar-codex")
+        #expect(newCodexItem.button?.accessibilityIdentifier() == "CodexBar.StatusItem.codex")
+    }
+
+    @Test
+    func `non destructive visibility refresh preserves merged status item`() throws {
+        let (settings, controller) = try self.makeSplitController()
+        defer { controller.releaseStatusItemsForTesting() }
+
+        settings.mergeIcons = true
+        controller.handleProviderConfigChange(reason: "test")
+        let oldMergedItem = controller.statusItem
+        let oldMergedButton = try #require(controller.statusItem.button)
+
+        controller.refreshExistingStatusItemsForVisibilityRecovery()
+
+        #expect(controller.statusItem === oldMergedItem)
+        #expect(controller.statusItem.button === oldMergedButton)
+        #expect(controller.statusItem.autosaveName == "codexbar-merged")
+        #expect(controller.statusItem.button?.accessibilityIdentifier() == "CodexBar.StatusItem")
+    }
+
+    @Test
+    func `recreation produces immediately healthy snapshots for synchronous guidance check`() throws {
+        // verifyScreenChangeRecoveryIfNeeded does a synchronous re-check immediately after
+        // the single recreation to decide whether to show macOS 26 Allow-in-Menu-Bar guidance.
+        // AppKit must materialise the button and window before returning from
+        // recreateStatusItemsForVisibilityRecovery, so the item must not appear blocked at
+        // that point. Only a genuine system-level block would leave it blocked — which is
+        // exactly the case where guidance is useful.
+        let (_, controller) = try self.makeSplitController()
+        defer { controller.releaseStatusItemsForTesting() }
+
+        controller.recreateStatusItemsForVisibilityRecovery()
+
+        let allItems = [controller.statusItem] + Array(controller.statusItems.values)
+        let snapshots = MenuBarVisibilityWatcher.visibilitySnapshots(allItems)
+        #expect(!MenuBarVisibilityWatcher.hasAnyBlockedVisibleSnapshot(snapshots))
+    }
+
+    @Test
+    func `visibility recovery recreates split provider status items`() throws {
+        let (_, controller) = try self.makeSplitController()
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let oldCodexItem = try #require(controller.statusItems[.codex])
+        controller.recreateStatusItemsForVisibilityRecovery()
+
+        let newCodexItem = try #require(controller.statusItems[.codex])
+        #expect(newCodexItem !== oldCodexItem)
+        #expect(newCodexItem.autosaveName == "codexbar-codex")
+        #expect(newCodexItem.button?.accessibilityIdentifier() == "CodexBar.StatusItem.codex")
+    }
+
+    @Test
+    func `visibility recovery renders replacement merged status item`() throws {
+        let (settings, controller) = try self.makeSplitController()
+        defer { controller.releaseStatusItemsForTesting() }
+
+        settings.mergeIcons = true
+        controller.handleProviderConfigChange(reason: "test")
+        let renderedSignature = try #require(controller.lastAppliedMergedIconRenderSignature)
+
+        controller.lastAppliedMergedIconRenderSignature = renderedSignature
+        controller.recreateStatusItemsForVisibilityRecovery()
+
+        let mergedButton = try #require(controller.statusItem.button)
+        #expect(mergedButton.image != nil)
+        #expect(controller.statusItem.autosaveName == "codexbar-merged")
+        #expect(mergedButton.accessibilityIdentifier() == "CodexBar.StatusItem")
+    }
+}
diff --git a/Tests/CodexBarTests/StatusItemExtraUsageMetricTests.swift b/Tests/CodexBarTests/StatusItemExtraUsageMetricTests.swift
new file mode 100644
index 0000000000..28edeb6be4
--- /dev/null
+++ b/Tests/CodexBarTests/StatusItemExtraUsageMetricTests.swift
@@ -0,0 +1,269 @@
+import AppKit
+import CodexBarCore
+import Testing
+@testable import CodexBar
+
+@Suite(.serialized)
+@MainActor
+struct StatusItemExtraUsageMetricTests {
+    @Test
+    func `menu bar extra usage preference uses cursor on demand budget`() {
+        let (store, controller) = self.makeCursorController(suiteName: "StatusItemExtraUsageMetricTests-budget")
+        defer { controller.releaseStatusItemsForTesting() }
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 20, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            tertiary: RateWindow(usedPercent: 72, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            providerCost: ProviderCostSnapshot(
+                used: 15,
+                limit: 100,
+                currencyCode: "USD",
+                updatedAt: Date()),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(snapshot, provider: .cursor)
+        store._setErrorForTesting(nil, provider: .cursor)
+
+        let window = controller.menuBarMetricWindow(for: .cursor, snapshot: snapshot)
+
+        #expect(window?.usedPercent == 15)
+    }
+
+    @Test
+    func `menu bar extra usage preference falls back to automatic when cursor on demand budget is missing`() {
+        let (store, controller) = self.makeController(
+            suiteName: "StatusItemExtraUsageMetricTests-missing-budget",
+            provider: .cursor)
+        defer { controller.releaseStatusItemsForTesting() }
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 72, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            tertiary: nil,
+            providerCost: nil,
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(snapshot, provider: .cursor)
+        store._setErrorForTesting(nil, provider: .cursor)
+
+        let window = controller.menuBarMetricWindow(for: .cursor, snapshot: snapshot)
+
+        #expect(window?.usedPercent == 72)
+    }
+
+    @Test
+    func `menu bar extra usage preference honors percent used display for cursor`() {
+        let (store, controller) = self.makeController(
+            suiteName: "StatusItemExtraUsageMetricTests-cursor-spend-text",
+            provider: .cursor)
+        defer { controller.releaseStatusItemsForTesting() }
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 20, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            tertiary: RateWindow(usedPercent: 72, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            providerCost: ProviderCostSnapshot(
+                used: 12.34,
+                limit: 100,
+                currencyCode: "USD",
+                updatedAt: Date()),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(snapshot, provider: .cursor)
+        store._setErrorForTesting(nil, provider: .cursor)
+
+        let displayText = controller.menuBarDisplayText(for: .cursor, snapshot: snapshot)
+
+        #expect(displayText == "12%")
+    }
+
+    @Test
+    func `menu bar extra usage preference honors percent remaining display for cursor`() {
+        let (store, controller) = self.makeController(
+            suiteName: "StatusItemExtraUsageMetricTests-cursor-remaining-text",
+            provider: .cursor)
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.settings.usageBarsShowUsed = false
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 20, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            tertiary: RateWindow(usedPercent: 72, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            providerCost: ProviderCostSnapshot(
+                used: 12.34,
+                limit: 100,
+                currencyCode: "USD",
+                updatedAt: Date()),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(snapshot, provider: .cursor)
+        store._setErrorForTesting(nil, provider: .cursor)
+
+        let displayText = controller.menuBarDisplayText(for: .cursor, snapshot: snapshot)
+
+        #expect(displayText == "88%")
+    }
+
+    @Test
+    func `menu bar extra usage preference keeps cursor currency fallback in pace mode`() {
+        let (store, controller) = self.makeController(
+            suiteName: "StatusItemExtraUsageMetricTests-cursor-pace-spend-text",
+            provider: .cursor)
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.settings.menuBarDisplayMode = .pace
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 42, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            tertiary: nil,
+            providerCost: ProviderCostSnapshot(
+                used: 12.34,
+                limit: 100,
+                currencyCode: "USD",
+                updatedAt: Date()),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(snapshot, provider: .cursor)
+        store._setErrorForTesting(nil, provider: .cursor)
+
+        let displayText = controller.menuBarDisplayText(for: .cursor, snapshot: snapshot)
+
+        #expect(displayText == "$12.34")
+    }
+
+    @Test
+    func `menu bar extra usage preference uses percent in combined mode`() {
+        let (store, controller) = self.makeController(
+            suiteName: "StatusItemExtraUsageMetricTests-cursor-combined-text",
+            provider: .cursor)
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.settings.menuBarDisplayMode = .both
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            tertiary: nil,
+            providerCost: ProviderCostSnapshot(
+                used: 56,
+                limit: 100,
+                currencyCode: "USD",
+                updatedAt: Date()),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(snapshot, provider: .cursor)
+        store._setErrorForTesting(nil, provider: .cursor)
+
+        let displayText = controller.menuBarDisplayText(for: .cursor, snapshot: snapshot)
+
+        #expect(displayText == "56%")
+    }
+
+    @Test
+    func `menu bar extra usage preference preserves claude currency display`() {
+        let (store, controller) = self.makeController(
+            suiteName: "StatusItemExtraUsageMetricTests-claude-spend-text",
+            provider: .claude)
+        defer { controller.releaseStatusItemsForTesting() }
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 42, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            tertiary: nil,
+            providerCost: ProviderCostSnapshot(
+                used: 88.8,
+                limit: 200,
+                currencyCode: "USD",
+                period: "Monthly",
+                updatedAt: Date()),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(snapshot, provider: .claude)
+        store._setErrorForTesting(nil, provider: .claude)
+
+        let displayText = controller.menuBarDisplayText(for: .claude, snapshot: snapshot)
+
+        #expect(displayText == "$88.80")
+    }
+
+    @Test
+    func `menu bar extra usage preference falls back to existing percent text when provider cost is unavailable`() {
+        let (store, controller) = self.makeController(
+            suiteName: "StatusItemExtraUsageMetricTests-fallback-percent",
+            provider: .cursor)
+        defer { controller.releaseStatusItemsForTesting() }
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 72, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            tertiary: nil,
+            providerCost: nil,
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(snapshot, provider: .cursor)
+        store._setErrorForTesting(nil, provider: .cursor)
+
+        let displayText = controller.menuBarDisplayText(for: .cursor, snapshot: snapshot)
+
+        #expect(displayText == "72%")
+    }
+
+    @Test
+    func `reset time mode uses extra usage reset instead of spend`() {
+        let resetsAt = Date().addingTimeInterval(2 * 24 * 3600)
+        let (store, controller) = self.makeController(
+            suiteName: "StatusItemExtraUsageMetricTests-reset-time",
+            provider: .cursor,
+            displayMode: .resetTime,
+            resetTimesShowAbsolute: true)
+        defer { controller.releaseStatusItemsForTesting() }
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            tertiary: nil,
+            providerCost: ProviderCostSnapshot(
+                used: 12.34,
+                limit: 100,
+                currencyCode: "USD",
+                period: "Monthly",
+                resetsAt: resetsAt,
+                updatedAt: Date()),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(snapshot, provider: .cursor)
+        store._setErrorForTesting(nil, provider: .cursor)
+
+        let displayText = controller.menuBarDisplayText(for: .cursor, snapshot: snapshot)
+
+        #expect(displayText == "↻ \(UsageFormatter.resetDescription(from: resetsAt))")
+    }
+
+    private func makeCursorController(suiteName: String) -> (UsageStore, StatusItemController) {
+        self.makeController(suiteName: suiteName, provider: .cursor)
+    }
+
+    private func makeController(
+        suiteName: String,
+        provider: UsageProvider,
+        displayMode: MenuBarDisplayMode = .percent,
+        resetTimesShowAbsolute: Bool = false) -> (UsageStore, StatusItemController)
+    {
+        let settings = testSettingsStore(suiteName: suiteName)
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = provider
+        settings.menuBarDisplayMode = displayMode
+        settings.resetTimesShowAbsolute = resetTimesShowAbsolute
+        settings.usageBarsShowUsed = true
+        settings.setMenuBarMetricPreference(.extraUsage, for: provider)
+
+        let registry = ProviderRegistry.shared
+        if let metadata = registry.metadata[provider] {
+            settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: testStatusBar())
+        return (store, controller)
+    }
+}
diff --git a/Tests/CodexBarTests/StatusItemIconObservationSignatureTests.swift b/Tests/CodexBarTests/StatusItemIconObservationSignatureTests.swift
new file mode 100644
index 0000000000..d4210ac541
--- /dev/null
+++ b/Tests/CodexBarTests/StatusItemIconObservationSignatureTests.swift
@@ -0,0 +1,323 @@
+import AppKit
+import CodexBarCore
+import Testing
+@testable import CodexBar
+
+@MainActor
+@Suite(.serialized)
+struct StatusItemIconObservationSignatureTests {
+    private func makeController(suiteName: String) -> (SettingsStore, UsageStore, StatusItemController) {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: suiteName),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.statusChecksEnabled = true
+        settings.refreshFrequency = .manual
+        settings.menuBarShowsBrandIconWithPercent = false
+        settings.mergeIcons = true
+
+        let registry = ProviderRegistry.shared
+        if let codexMeta = registry.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+        if let claudeMeta = registry.metadata[.claude] {
+            settings.setProviderEnabled(provider: .claude, metadata: claudeMeta, enabled: false)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        store._setSnapshotForTesting(Self.makeSnapshot(provider: .codex, email: "icon@example.com"), provider: .codex)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system)
+        return (settings, store, controller)
+    }
+
+    @Test
+    func `store icon observation signature ignores refresh and status metadata churn`() {
+        let (_, store, controller) = self.makeController(
+            suiteName: "StatusItemIconObservationSignatureTests-refresh-metadata")
+        defer { controller.releaseStatusItemsForTesting() }
+
+        store.statuses[.codex] = ProviderStatus(
+            indicator: .none,
+            description: "initial",
+            updatedAt: Date(timeIntervalSince1970: 10))
+        let baseline = controller.storeIconObservationSignature()
+
+        store.isRefreshing = true
+        store.statuses[.codex] = ProviderStatus(
+            indicator: .none,
+            description: "same indicator, newer timestamp",
+            updatedAt: Date(timeIntervalSince1970: 20))
+
+        #expect(controller.storeIconObservationSignature() == baseline)
+    }
+
+    @Test
+    func `store icon observation signature ignores non visual snapshot churn`() {
+        let (_, store, controller) = self.makeController(
+            suiteName: "StatusItemIconObservationSignatureTests-snapshot-metadata")
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let baseline = controller.storeIconObservationSignature()
+
+        store._setSnapshotForTesting(
+            Self.makeSnapshot(
+                provider: .codex,
+                email: "rotated-account@example.com",
+                updatedAt: Date(timeIntervalSince1970: 200)),
+            provider: .codex)
+
+        let signature = controller.storeIconObservationSignature()
+
+        #expect(signature == baseline)
+        #expect(!signature.contains("rotated-account@example.com"))
+    }
+
+    @Test
+    func `merged store icon observation signature ignores non primary snapshot churn`() throws {
+        let (settings, store, controller) = self.makeController(
+            suiteName: "StatusItemIconObservationSignatureTests-merged-secondary-snapshot")
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let registry = ProviderRegistry.shared
+        let claudeMetadata = try #require(registry.metadata[.claude])
+        settings.setProviderEnabled(provider: .claude, metadata: claudeMetadata, enabled: true)
+        store._setSnapshotForTesting(
+            Self.makeSnapshot(provider: .claude, email: "claude@example.com"),
+            provider: .claude)
+        let baseline = controller.storeIconObservationSignature()
+
+        store._setSnapshotForTesting(
+            Self.makeSnapshot(
+                provider: .claude,
+                email: "changed@example.com",
+                primaryUsedPercent: 99,
+                secondaryUsedPercent: 88,
+                updatedAt: Date(timeIntervalSince1970: 300)),
+            provider: .claude)
+
+        #expect(controller.storeIconObservationSignature() == baseline)
+    }
+
+    @Test
+    func `store icon observation signature changes when icon percentages change`() {
+        let (_, store, controller) = self.makeController(
+            suiteName: "StatusItemIconObservationSignatureTests-percent-change")
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let baseline = controller.storeIconObservationSignature()
+
+        store._setSnapshotForTesting(
+            Self.makeSnapshot(
+                provider: .codex,
+                email: "icon@example.com",
+                primaryUsedPercent: 42,
+                secondaryUsedPercent: 63),
+            provider: .codex)
+
+        #expect(controller.storeIconObservationSignature() != baseline)
+    }
+
+    @Test
+    func `store icon observation signature tracks selected copilot budget`() throws {
+        let (settings, store, controller) = self.makeController(
+            suiteName: "StatusItemIconObservationSignatureTests-copilot-budget")
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let registry = ProviderRegistry.shared
+        let codexMetadata = try #require(registry.metadata[.codex])
+        let copilotMetadata = try #require(registry.metadata[.copilot])
+        settings.setProviderEnabled(provider: .codex, metadata: codexMetadata, enabled: false)
+        settings.setProviderEnabled(provider: .copilot, metadata: copilotMetadata, enabled: true)
+        settings.selectedMenuProvider = .copilot
+        settings.copilotBudgetExtrasEnabled = true
+        settings.copilotIconSecondaryWindowID = "copilot-budget-agent"
+
+        store._setSnapshotForTesting(
+            Self.makeCopilotSnapshot(budgetUsedPercent: 25),
+            provider: .copilot)
+        let baseline = controller.storeIconObservationSignature()
+
+        store._setSnapshotForTesting(
+            Self.makeCopilotSnapshot(budgetUsedPercent: 75),
+            provider: .copilot)
+
+        #expect(controller.storeIconObservationSignature() != baseline)
+    }
+
+    @Test
+    func `store icon observation signature changes when credit fallback changes`() {
+        let (_, store, controller) = self.makeController(
+            suiteName: "StatusItemIconObservationSignatureTests-credit-fallback")
+        defer { controller.releaseStatusItemsForTesting() }
+
+        store._setSnapshotForTesting(
+            Self.makeSnapshot(
+                provider: .codex,
+                email: "icon@example.com",
+                primaryUsedPercent: 100,
+                secondaryUsedPercent: 20),
+            provider: .codex)
+        store.credits = CreditsSnapshot(remaining: 80, events: [], updatedAt: Date(timeIntervalSince1970: 100))
+        let baseline = controller.storeIconObservationSignature()
+
+        store.credits = CreditsSnapshot(remaining: 42, events: [], updatedAt: Date(timeIntervalSince1970: 200))
+
+        #expect(controller.storeIconObservationSignature() != baseline)
+    }
+
+    @Test
+    func `store icon observation signature ignores unused credit balance`() {
+        let (_, store, controller) = self.makeController(
+            suiteName: "StatusItemIconObservationSignatureTests-unused-credits")
+        defer { controller.releaseStatusItemsForTesting() }
+
+        store.credits = CreditsSnapshot(remaining: 80, events: [], updatedAt: Date(timeIntervalSince1970: 100))
+        let baseline = controller.storeIconObservationSignature()
+
+        store.credits = CreditsSnapshot(remaining: 42, events: [], updatedAt: Date(timeIntervalSince1970: 200))
+
+        #expect(controller.storeIconObservationSignature() == baseline)
+    }
+
+    @Test
+    func `merged store icon observation signature ignores non primary status changes`() throws {
+        let (settings, store, controller) = self.makeController(
+            suiteName: "StatusItemIconObservationSignatureTests-merged-secondary-status")
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let registry = ProviderRegistry.shared
+        let claudeMetadata = try #require(registry.metadata[.claude])
+        settings.setProviderEnabled(provider: .claude, metadata: claudeMetadata, enabled: true)
+        let baseline = controller.storeIconObservationSignature()
+
+        store.statuses[.claude] = ProviderStatus(
+            indicator: .major,
+            description: "Claude status issue",
+            updatedAt: Date(timeIntervalSince1970: 20))
+
+        #expect(controller.storeIconObservationSignature() == baseline)
+    }
+
+    @Test
+    func `store icon observation signature changes when status indicator changes`() {
+        let (_, store, controller) = self.makeController(
+            suiteName: "StatusItemIconObservationSignatureTests-status-indicator")
+        defer { controller.releaseStatusItemsForTesting() }
+
+        store.statuses[.codex] = ProviderStatus(
+            indicator: .none,
+            description: "initial",
+            updatedAt: Date(timeIntervalSince1970: 10))
+        let baseline = controller.storeIconObservationSignature()
+
+        store.statuses[.codex] = ProviderStatus(
+            indicator: .major,
+            description: "major outage",
+            updatedAt: Date(timeIntervalSince1970: 20))
+
+        #expect(controller.storeIconObservationSignature() != baseline)
+    }
+
+    @Test
+    func `store icon observation signature changes when hide critters toggles`() {
+        let (settings, _, controller) = self.makeController(
+            suiteName: "StatusItemIconObservationSignatureTests-hide-critters")
+        defer { controller.releaseStatusItemsForTesting() }
+
+        settings.menuBarHidesCritters = false
+        let baseline = controller.storeIconObservationSignature()
+
+        settings.menuBarHidesCritters = true
+
+        #expect(controller.storeIconObservationSignature() != baseline)
+    }
+
+    @Test
+    func `updateIcons reuses a precomputed store icon signature instead of recomputing it`() {
+        let (_, _, controller) = self.makeController(
+            suiteName: "StatusItemIconObservationSignatureTests-precomputed-reuse")
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let precomputed = "precomputed-store-icon-signature-sentinel"
+        controller.updateIcons(precomputedStoreIconSignature: precomputed)
+
+        // A supplied signature must be stored verbatim; if updateIcons recomputed it, the gate would
+        // never equal the sentinel value.
+        #expect(controller.lastObservedStoreIconWorkSignature == precomputed)
+    }
+
+    @Test
+    func `updateIcons recomputes the store icon signature when none is provided`() {
+        let (_, _, controller) = self.makeController(
+            suiteName: "StatusItemIconObservationSignatureTests-recompute-default")
+        defer { controller.releaseStatusItemsForTesting() }
+
+        controller.updateIcons()
+
+        #expect(controller.lastObservedStoreIconWorkSignature == controller.storeIconObservationSignature())
+    }
+
+    private static func makeSnapshot(
+        provider: UsageProvider,
+        email: String,
+        primaryUsedPercent: Double = 10,
+        secondaryUsedPercent: Double = 20,
+        updatedAt: Date = Date(timeIntervalSince1970: 100))
+        -> UsageSnapshot
+    {
+        UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: primaryUsedPercent,
+                windowMinutes: 300,
+                resetsAt: nil,
+                resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: secondaryUsedPercent,
+                windowMinutes: 10080,
+                resetsAt: nil,
+                resetDescription: nil),
+            updatedAt: updatedAt,
+            identity: ProviderIdentitySnapshot(
+                providerID: provider,
+                accountEmail: email,
+                accountOrganization: nil,
+                loginMethod: "plus"))
+    }
+
+    private static func makeCopilotSnapshot(budgetUsedPercent: Double) -> UsageSnapshot {
+        UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 10,
+                windowMinutes: nil,
+                resetsAt: nil,
+                resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: 20,
+                windowMinutes: nil,
+                resetsAt: nil,
+                resetDescription: nil),
+            extraRateWindows: [
+                NamedRateWindow(
+                    id: "copilot-budget-agent",
+                    title: "Budget - Copilot Agent Premium Requests",
+                    window: RateWindow(
+                        usedPercent: budgetUsedPercent,
+                        windowMinutes: nil,
+                        resetsAt: nil,
+                        resetDescription: nil)),
+            ],
+            updatedAt: Date(timeIntervalSince1970: 100),
+            identity: ProviderIdentitySnapshot(
+                providerID: .copilot,
+                accountEmail: "copilot@example.com",
+                accountOrganization: nil,
+                loginMethod: "individual"))
+    }
+}
diff --git a/Tests/CodexBarTests/StatusItemPurchaseURLTests.swift b/Tests/CodexBarTests/StatusItemPurchaseURLTests.swift
new file mode 100644
index 0000000000..1f2069e7f4
--- /dev/null
+++ b/Tests/CodexBarTests/StatusItemPurchaseURLTests.swift
@@ -0,0 +1,63 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct StatusItemPurchaseURLTests {
+    @Test
+    @MainActor
+    func `purchase URL accepts ChatGPT hosts`() {
+        #expect(
+            StatusItemController.sanitizedCreditsPurchaseURL("https://chatgpt.com/settings/billing")
+                == "https://chatgpt.com/settings/billing")
+        #expect(
+            StatusItemController
+                .sanitizedCreditsPurchaseURL("https://chatgpt.com/usage/credits?token=secret#fragment")
+                == "https://chatgpt.com/usage/credits")
+        #expect(
+            StatusItemController.sanitizedCreditsPurchaseURL("https://team.chatgpt.com/settings/billing")
+                == "https://team.chatgpt.com/settings/billing")
+    }
+
+    @Test
+    @MainActor
+    func `purchase URL rejects lookalike hosts`() {
+        #expect(
+            StatusItemController
+                .sanitizedCreditsPurchaseURL("https://chatgpt.com.evil.example/settings/billing") == nil)
+        #expect(
+            StatusItemController.sanitizedCreditsPurchaseURL("https://evil-chatgpt.com/settings/billing")
+                == nil)
+        #expect(
+            StatusItemController.sanitizedCreditsPurchaseURL("https://notchatgpt.com/settings/billing")
+                == nil)
+    }
+
+    @Test
+    @MainActor
+    func `purchase URL rejects non HTTPS and unrelated paths`() {
+        #expect(
+            StatusItemController.sanitizedCreditsPurchaseURL("http://chatgpt.com/settings/billing")
+                == nil)
+        #expect(
+            StatusItemController.sanitizedCreditsPurchaseURL("https://chatgpt.com/backend-api/accounts")
+                == nil)
+        #expect(
+            StatusItemController.sanitizedCreditsPurchaseURL("https://chatgpt.com/backend-api/settings-token")
+                == nil)
+        #expect(StatusItemController.sanitizedCreditsPurchaseURL("not a url") == nil)
+    }
+
+    @Test
+    @MainActor
+    func `scoped purchase window requires an account email`() {
+        let scope = CookieHeaderCache.Scope.profileHome("/tmp/codex-profile")
+
+        #expect(!OpenAICreditsPurchaseWindowController.canOpenPurchaseWindow(accountEmail: nil, cacheScope: scope))
+        #expect(!OpenAICreditsPurchaseWindowController.canOpenPurchaseWindow(accountEmail: "  ", cacheScope: scope))
+        #expect(OpenAICreditsPurchaseWindowController.canOpenPurchaseWindow(
+            accountEmail: " owner@example.com ",
+            cacheScope: scope))
+        #expect(OpenAICreditsPurchaseWindowController.canOpenPurchaseWindow(accountEmail: nil, cacheScope: nil))
+    }
+}
diff --git a/Tests/CodexBarTests/StatusItemQuotaWarningFlashTests.swift b/Tests/CodexBarTests/StatusItemQuotaWarningFlashTests.swift
new file mode 100644
index 0000000000..abf10e6d43
--- /dev/null
+++ b/Tests/CodexBarTests/StatusItemQuotaWarningFlashTests.swift
@@ -0,0 +1,98 @@
+import AppKit
+import CodexBarCore
+import Testing
+@testable import CodexBar
+
+@MainActor
+@Suite(.serialized)
+struct StatusItemQuotaWarningFlashTests {
+    private func makeStatusBarForTesting() -> NSStatusBar {
+        NSStatusBar.system
+    }
+
+    @Test
+    func `quota warning flash state lasts for configured duration`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "StatusItemQuotaWarningFlashTests-duration"),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+
+        let now = Date()
+        controller.startQuotaWarningFlash(provider: .codex, postedAt: now)
+
+        #expect(controller.quotaWarningFlashActive(provider: .codex, now: now.addingTimeInterval(59)) == true)
+        #expect(controller.quotaWarningFlashActive(provider: .codex, now: now.addingTimeInterval(61)) == false)
+    }
+
+    @Test
+    func `quota warning flash image draws non template red overlay`() throws {
+        let size = NSSize(width: 16, height: 16)
+        let base = NSImage(size: size)
+        base.lockFocus()
+        NSColor.black.setFill()
+        NSBezierPath(rect: NSRect(origin: .zero, size: size)).fill()
+        base.unlockFocus()
+        base.isTemplate = true
+
+        let output = StatusItemController.quotaWarningFlashImage(base: base)
+        let outputData = try #require(output.tiffRepresentation)
+        let outputRep = try #require(NSBitmapImageRep(data: outputData))
+        let center = try #require(outputRep.colorAt(x: 8, y: 8))
+
+        #expect(output.isTemplate == false)
+        #expect(center.redComponent > center.blueComponent)
+    }
+
+    @Test
+    func `merged icon render signature includes quota warning flash for selected provider`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "StatusItemQuotaWarningFlashTests-merged"),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        settings.menuBarShowsBrandIconWithPercent = false
+
+        let registry = ProviderRegistry.shared
+        if let codexMeta = registry.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+        if let openRouterMeta = registry.metadata[.openrouter] {
+            settings.setProviderEnabled(provider: .openrouter, metadata: openRouterMeta, enabled: true)
+        }
+        settings.openRouterAPIToken = "or-token"
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 50, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())
+        store._setSnapshotForTesting(snapshot, provider: .codex)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+
+        controller.startQuotaWarningFlash(provider: .codex)
+
+        #expect(controller.lastAppliedMergedIconRenderSignature?.contains("warningFlash=1") == true)
+    }
+}
diff --git a/Tests/CodexBarTests/StatusMenuAppearanceTests.swift b/Tests/CodexBarTests/StatusMenuAppearanceTests.swift
new file mode 100644
index 0000000000..4cf96a17f8
--- /dev/null
+++ b/Tests/CodexBarTests/StatusMenuAppearanceTests.swift
@@ -0,0 +1,60 @@
+import AppKit
+import Testing
+@testable import CodexBar
+
+@MainActor
+struct StatusMenuAppearanceTests {
+    private final class AppearanceTrackingMenu: NSMenu {
+        var appearanceAssignmentCount = 0
+
+        override var appearance: NSAppearance? {
+            didSet {
+                self.appearanceAssignmentCount += 1
+            }
+        }
+    }
+
+    @Test
+    func `pin uses the exact application effective appearance`() {
+        let menu = NSMenu()
+        let effectiveAppearance = NSApplication.shared.effectiveAppearance
+
+        StatusMenuAppearance.pin(menu)
+
+        #expect(menu.appearance === effectiveAppearance)
+    }
+
+    @Test
+    func `pin reassigns an appearance even when its name is unchanged`() throws {
+        let menu = AppearanceTrackingMenu()
+        let appearance = try #require(NSAppearance(named: .aqua))
+        menu.appearance = appearance
+        let assignmentsBeforePin = menu.appearanceAssignmentCount
+
+        StatusMenuAppearance.pin(menu, to: appearance)
+
+        #expect(menu.appearance === appearance)
+        #expect(menu.appearanceAssignmentCount == assignmentsBeforePin + 1)
+    }
+
+    @Test
+    func `submenus inherit each refreshed root appearance`() throws {
+        let menu = NSMenu()
+        let submenu = NSMenu()
+        let item = NSMenuItem(title: "Details", action: nil, keyEquivalent: "")
+        item.submenu = submenu
+        menu.addItem(item)
+
+        let lightAppearance = try #require(NSAppearance(named: .aqua))
+        StatusMenuAppearance.pin(menu, to: lightAppearance)
+        #expect(menu.appearance === lightAppearance)
+        #expect(submenu.appearance == nil)
+        #expect(submenu.effectiveAppearance.bestMatch(from: [.aqua, .darkAqua]) == .aqua)
+
+        let darkAppearance = try #require(NSAppearance(named: .darkAqua))
+        StatusMenuAppearance.pin(menu, to: darkAppearance)
+        #expect(menu.appearance === darkAppearance)
+        #expect(submenu.appearance == nil)
+        #expect(submenu.effectiveAppearance.bestMatch(from: [.aqua, .darkAqua]) == .darkAqua)
+    }
+}
diff --git a/Tests/CodexBarTests/StatusMenuClosedPreparationTests.swift b/Tests/CodexBarTests/StatusMenuClosedPreparationTests.swift
new file mode 100644
index 0000000000..a3b528adef
--- /dev/null
+++ b/Tests/CodexBarTests/StatusMenuClosedPreparationTests.swift
@@ -0,0 +1,307 @@
+import AppKit
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@MainActor
+private final class ClosedMenuManualRefreshGate {
+    private var continuation: CheckedContinuation<Void, Never>?
+    private var isOpen = false
+
+    func wait() async {
+        if self.isOpen {
+            self.isOpen = false
+            return
+        }
+        await withCheckedContinuation { continuation in
+            self.continuation = continuation
+        }
+    }
+
+    func resume() {
+        if let continuation = self.continuation {
+            continuation.resume()
+            self.continuation = nil
+        } else {
+            self.isOpen = true
+        }
+    }
+}
+
+extension StatusMenuTests {
+    @Test
+    func `stale data refresh suppresses icon attached closed menu preparation`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            if let metadata = registry.metadata[provider] {
+                settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: provider == .codex)
+            }
+        }
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        StatusItemController.setClosedMenuPreparationDelayForTesting(.zero)
+        defer { StatusItemController.resetClosedMenuPreparationDelayForTesting() }
+
+        controller.menuRefreshEnabledOverrideForTesting = true
+        for _ in 0..<20 {
+            await Task.yield()
+        }
+        let menu = controller.makeMenu()
+        // Simulate a closed menu that was attached by an icon update but has never been opened.
+        controller.fallbackMenu = menu
+        controller.statusItem.menu = menu
+        let key = ObjectIdentifier(menu)
+
+        controller.invalidateMenus(allowStaleContentDuringDataRefresh: true)
+        controller.prepareAttachedClosedMenusIfNeeded()
+        for _ in 0..<40 {
+            await Task.yield()
+        }
+
+        #expect(controller.openMenus.isEmpty)
+        #expect(controller.menuVersions[key] == nil)
+
+        controller.menuWillOpen(menu)
+        defer { controller.menuDidClose(menu) }
+
+        #expect(controller.menuVersions[key] == controller.menuContentVersion)
+    }
+
+    @Test
+    func `stale refresh completion requeues required closed menu preparation blocked by refresh`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            if let metadata = registry.metadata[provider] {
+                settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: provider == .codex)
+            }
+        }
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        StatusItemController.setClosedMenuPreparationDelayForTesting(.zero)
+        defer { StatusItemController.resetClosedMenuPreparationDelayForTesting() }
+
+        controller.menuRefreshEnabledOverrideForTesting = true
+        for _ in 0..<20 {
+            await Task.yield()
+        }
+        let menu = controller.makeMenu()
+        controller.fallbackMenu = menu
+        controller.statusItem.menu = menu
+
+        controller.populateMenu(menu, provider: nil)
+        controller.markMenuFresh(menu)
+        let key = ObjectIdentifier(menu)
+        let openedVersion = controller.menuVersions[key]
+
+        controller.invalidateMenus()
+        let requiredVersion = controller.latestRequiredMenuRebuildVersion
+        store.isRefreshing = true
+        for _ in 0..<40 where controller.closedMenuRebuildTasks[key] != nil {
+            await Task.yield()
+        }
+
+        #expect(requiredVersion > (openedVersion ?? -1))
+        #expect(controller.closedMenuRebuildTasks[key] == nil)
+        #expect(controller.menuVersions[key] == openedVersion)
+
+        store.isRefreshing = false
+        controller.fallbackMenu = menu
+        controller.statusItem.menu = menu
+        controller.invalidateMenus(allowStaleContentDuringDataRefresh: true)
+        for _ in 0..<40 where controller.menuVersions[key] == openedVersion {
+            await Task.yield()
+        }
+
+        #expect(controller.openMenus.isEmpty)
+        #expect(controller.menuVersions[key] == controller.menuContentVersion)
+    }
+
+    @Test
+    func `manual refresh completion requeues required closed menu preparation`() async throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            if let metadata = registry.metadata[provider] {
+                settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: provider == .codex)
+            }
+        }
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        StatusItemController.setClosedMenuPreparationDelayForTesting(.zero)
+        defer { StatusItemController.resetClosedMenuPreparationDelayForTesting() }
+
+        controller.menuRefreshEnabledOverrideForTesting = true
+        let menu = controller.makeMenu()
+        controller.fallbackMenu = menu
+        controller.statusItem.menu = menu
+        controller.populateMenu(menu, provider: nil)
+        controller.markMenuFresh(menu)
+        let key = ObjectIdentifier(menu)
+        let initialVersion = controller.menuVersions[key]
+
+        let gate = ClosedMenuManualRefreshGate()
+        controller._test_manualRefreshOperation = { await gate.wait() }
+        defer {
+            gate.resume()
+            controller._test_manualRefreshOperation = nil
+        }
+        controller.refreshNow()
+        let task = try #require(controller.manualRefreshTask)
+
+        controller.invalidateMenus()
+        for _ in 0..<40 {
+            await Task.yield()
+        }
+
+        #expect(controller.menuVersions[key] == initialVersion)
+
+        gate.resume()
+        await task.value
+        for _ in 0..<40 where controller.menuVersions[key] == initialVersion {
+            await Task.yield()
+        }
+
+        #expect(controller.openMenus.isEmpty)
+        #expect(controller.menuVersions[key] == controller.menuContentVersion)
+    }
+
+    @Test
+    func `closed menu prewarm waits for other menu tracking to end`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        StatusItemController.setClosedMenuPreparationDelayForTesting(.milliseconds(50))
+        defer { StatusItemController.resetClosedMenuPreparationDelayForTesting() }
+
+        controller.menuRefreshEnabledOverrideForTesting = true
+        let closedMenu = controller.makeMenu(for: .claude)
+        controller.providerMenus[.claude] = closedMenu
+        controller.populateMenu(closedMenu, provider: .claude)
+        controller.markMenuFresh(closedMenu)
+        let closedKey = ObjectIdentifier(closedMenu)
+        let closedVersion = controller.menuVersions[closedKey]
+
+        controller.invalidateMenus()
+        controller.rebuildClosedMenuIfNeeded(closedMenu)
+        #expect(controller.closedMenuRebuildTasks[closedKey] != nil)
+
+        let visibleMenu = controller.makeMenu(for: .codex)
+        controller.menuWillOpen(visibleMenu)
+        try? await Task.sleep(for: .milliseconds(80))
+        for _ in 0..<20 where controller.closedMenuRebuildTasks[closedKey] != nil {
+            await Task.yield()
+        }
+
+        #expect(controller.menuVersions[closedKey] == closedVersion)
+        #expect(controller.openMenus[ObjectIdentifier(visibleMenu)] != nil)
+
+        controller.menuDidClose(visibleMenu)
+        try? await Task.sleep(for: .milliseconds(80))
+        for _ in 0..<20 where controller.menuVersions[closedKey] == closedVersion {
+            await Task.yield()
+        }
+
+        #expect(controller.openMenus.isEmpty)
+        #expect(controller.menuVersions[closedKey] == controller.menuContentVersion)
+    }
+
+    @Test
+    func `data refresh while persistent menu is open rebuilds on close`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            if let metadata = registry.metadata[provider] {
+                settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: provider == .codex)
+            }
+        }
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        StatusItemController.setClosedMenuPreparationDelayForTesting(.zero)
+        defer { StatusItemController.resetClosedMenuPreparationDelayForTesting() }
+
+        controller.menuRefreshEnabledOverrideForTesting = true
+        let menu = controller.makeMenu()
+        controller.fallbackMenu = menu
+        controller.statusItem.menu = menu
+
+        controller.menuWillOpen(menu)
+        let key = ObjectIdentifier(menu)
+        let openedVersion = controller.menuVersions[key]
+
+        controller.invalidateMenus(allowStaleContentDuringDataRefresh: true)
+        #expect(controller.menuContentVersion != openedVersion)
+        #expect(controller.menuVersions[key] == openedVersion)
+
+        controller.menuDidClose(menu)
+        for _ in 0..<40 where controller.menuVersions[key] == openedVersion {
+            await Task.yield()
+        }
+
+        #expect(controller.openMenus.isEmpty)
+        #expect(controller.menuVersions[key] == controller.menuContentVersion)
+        #expect(controller.menuVersions[key] != openedVersion)
+    }
+}
diff --git a/Tests/CodexBarTests/StatusMenuCodexSwitcherPresentationTests.swift b/Tests/CodexBarTests/StatusMenuCodexSwitcherPresentationTests.swift
new file mode 100644
index 0000000000..58352c341c
--- /dev/null
+++ b/Tests/CodexBarTests/StatusMenuCodexSwitcherPresentationTests.swift
@@ -0,0 +1,400 @@
+import AppKit
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@Suite(.serialized)
+@MainActor
+struct StatusMenuCodexSwitcherPresentationTests {
+    private func disableMenuCardsForTesting() {
+        StatusItemController.menuCardRenderingEnabled = false
+        StatusItemController.setMenuRefreshEnabledForTesting(false)
+    }
+
+    private func makeSettings() -> SettingsStore {
+        let suite = "StatusMenuCodexSwitcherPresentationTests-\(UUID().uuidString)"
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        return SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+    }
+
+    private func makeManagedAccountStoreURL(accounts: [ManagedCodexAccount]) throws -> URL {
+        let storeURL = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        let store = FileManagedCodexAccountStore(fileURL: storeURL)
+        try store.storeAccounts(ManagedCodexAccountSet(
+            version: FileManagedCodexAccountStore.currentVersion,
+            accounts: accounts))
+        return storeURL
+    }
+
+    private func enableOnlyCodex(_ settings: SettingsStore) {
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: provider == .codex)
+        }
+    }
+
+    private func representedIDs(in menu: NSMenu) -> [String] {
+        menu.items.compactMap { $0.representedObject as? String }
+    }
+
+    private func snapshot(email: String, percent: Double = 12) -> UsageSnapshot {
+        UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: percent,
+                windowMinutes: 300,
+                resetsAt: Date().addingTimeInterval(300),
+                resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: percent,
+                windowMinutes: 10080,
+                resetsAt: Date().addingTimeInterval(86400),
+                resetDescription: nil),
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: email,
+                accountOrganization: nil,
+                loginMethod: "Plus"))
+    }
+
+    @Test
+    func `codex account ordering keeps workspace groups contiguous`() {
+        let teamActive = CodexVisibleAccount(
+            id: "team-a-active",
+            email: "active@example.com",
+            workspaceLabel: "Team A",
+            workspaceAccountID: "team-a",
+            storedAccountID: UUID(),
+            selectionSource: .managedAccount(id: UUID()),
+            isActive: true,
+            isLive: false,
+            canReauthenticate: true,
+            canRemove: true)
+        let teamHighQuota = CodexVisibleAccount(
+            id: "team-b-high-quota",
+            email: "high@example.com",
+            workspaceLabel: "Team B",
+            workspaceAccountID: "team-b",
+            storedAccountID: UUID(),
+            selectionSource: .managedAccount(id: UUID()),
+            isActive: false,
+            isLive: false,
+            canReauthenticate: true,
+            canRemove: true)
+        let teamSibling = CodexVisibleAccount(
+            id: "team-a-sibling",
+            email: "sibling@example.com",
+            workspaceLabel: "Team A",
+            workspaceAccountID: "team-a",
+            storedAccountID: UUID(),
+            selectionSource: .managedAccount(id: UUID()),
+            isActive: false,
+            isLive: false,
+            canReauthenticate: true,
+            canRemove: true)
+        let accounts = [teamActive, teamHighQuota, teamSibling]
+        let snapshots = [
+            CodexAccountUsageSnapshot(
+                account: teamActive,
+                snapshot: self.snapshot(email: teamActive.email, percent: 95),
+                error: nil,
+                sourceLabel: "test"),
+            CodexAccountUsageSnapshot(
+                account: teamHighQuota,
+                snapshot: self.snapshot(email: teamHighQuota.email, percent: 10),
+                error: nil,
+                sourceLabel: "test"),
+            CodexAccountUsageSnapshot(
+                account: teamSibling,
+                snapshot: self.snapshot(email: teamSibling.email, percent: 20),
+                error: nil,
+                sourceLabel: "test"),
+        ]
+
+        let ordered = CodexAccountPresentationOrdering.orderedAccounts(
+            accounts,
+            snapshots: snapshots,
+            activeVisibleAccountID: teamActive.id)
+
+        #expect(ordered.map(\.id) == ["team-a-active", "team-a-sibling", "team-b-high-quota"])
+        #expect(ordered.codexWorkspaceSections().map(\.title) == ["Team A", "Team B"])
+        #expect(ordered.codexWorkspaceSections().first?.accounts.map(\.id) == ["team-a-active", "team-a-sibling"])
+    }
+
+    @Test
+    func `codex stacked menu orders by quota and groups workspaces`() throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.multiAccountMenuLayout = .stacked
+        self.enableOnlyCodex(settings)
+
+        let lowID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-111111111111"))
+        let highID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-222222222222"))
+        let low = ManagedCodexAccount(
+            id: lowID,
+            email: "low@example.com",
+            workspaceLabel: "Team Low",
+            workspaceAccountID: "team-low",
+            managedHomePath: "/tmp/low-home",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let high = ManagedCodexAccount(
+            id: highID,
+            email: "high@example.com",
+            workspaceLabel: "Team High",
+            workspaceAccountID: "team-high",
+            managedHomePath: "/tmp/high-home",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [low, high])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            settings._test_liveSystemCodexAccount = nil
+            try? FileManager.default.removeItem(at: storeURL)
+        }
+
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "active@example.com",
+            workspaceLabel: "Personal",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        settings.codexActiveSource = .liveSystem
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        store.codexAccountSnapshots = settings.codexVisibleAccountProjection.visibleAccounts.map { account in
+            let usedPercent = switch account.email {
+            case "high@example.com":
+                10.0
+            case "low@example.com":
+                80.0
+            default:
+                95.0
+            }
+            return CodexAccountUsageSnapshot(
+                account: account,
+                snapshot: self.snapshot(email: account.email, percent: usedPercent),
+                error: nil,
+                sourceLabel: "test")
+        }
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let display = try #require(controller.codexAccountMenuDisplay(for: .codex))
+        #expect(display.accounts.map(\.email) == ["active@example.com", "high@example.com", "low@example.com"])
+        #expect(display.workspaceSections.map(\.title) == ["Personal", "Team High", "Team Low"])
+
+        let menu = controller.makeMenu(for: .codex)
+        controller.menuWillOpen(menu)
+        #expect(self.representedIDs(in: menu).count(where: { $0.hasPrefix("codexWorkspace-") }) == 3)
+    }
+
+    @Test
+    func `codex stacked menu surfaces account health labels`() throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.multiAccountMenuLayout = .stacked
+        self.enableOnlyCodex(settings)
+
+        let managedAccountID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-111111111111"))
+        let managedAccount = ManagedCodexAccount(
+            id: managedAccountID,
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-home",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            settings._test_liveSystemCodexAccount = nil
+            try? FileManager.default.removeItem(at: storeURL)
+        }
+
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        settings.codexActiveSource = .liveSystem
+
+        let visibleAccount = try #require(settings.codexVisibleAccountProjection.visibleAccounts
+            .first { $0.email == "managed@example.com" })
+
+        #expect(CodexAccountHealth.status(for: visibleAccount, error: "401 Unauthorized")
+            .label == "Needs re-auth")
+    }
+
+    @Test
+    func `codex account snapshot store hydrates current visible accounts`() {
+        let fileURL = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        defer { try? FileManager.default.removeItem(at: fileURL) }
+
+        let account = CodexVisibleAccount(
+            id: "active@example.com",
+            email: "active@example.com",
+            storedAccountID: nil,
+            selectionSource: .liveSystem,
+            isActive: true,
+            isLive: true,
+            canReauthenticate: true,
+            canRemove: false)
+        let store = FileCodexAccountUsageSnapshotStore(fileURL: fileURL)
+        store.store([
+            CodexAccountUsageSnapshot(
+                account: account,
+                snapshot: self.snapshot(email: account.email, percent: 17),
+                error: nil,
+                sourceLabel: "test"),
+        ])
+
+        let hydrated = store.load(for: [account])
+
+        #expect(hydrated.map(\.id) == [account.id])
+        #expect(hydrated.first?.snapshot?.primary?.usedPercent == 17)
+        #expect(hydrated.first?.account.email == account.email)
+    }
+
+    @Test
+    func `codex account snapshot store rejects mismatched workspace records`() {
+        let fileURL = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        defer { try? FileManager.default.removeItem(at: fileURL) }
+
+        let oldAccountID = UUID()
+        let newAccountID = UUID()
+        let oldAccount = CodexVisibleAccount(
+            id: "workspace@example.com",
+            email: "workspace@example.com",
+            workspaceLabel: "Old Team",
+            workspaceAccountID: "acct-old",
+            storedAccountID: oldAccountID,
+            selectionSource: .managedAccount(id: oldAccountID),
+            isActive: false,
+            isLive: false,
+            canReauthenticate: true,
+            canRemove: true)
+        let newAccount = CodexVisibleAccount(
+            id: "workspace@example.com",
+            email: "workspace@example.com",
+            workspaceLabel: "New Team",
+            workspaceAccountID: "acct-new",
+            storedAccountID: newAccountID,
+            selectionSource: .managedAccount(id: newAccountID),
+            isActive: true,
+            isLive: false,
+            canReauthenticate: true,
+            canRemove: true)
+        let store = FileCodexAccountUsageSnapshotStore(fileURL: fileURL)
+        store.store([
+            CodexAccountUsageSnapshot(
+                account: oldAccount,
+                snapshot: self.snapshot(email: oldAccount.email, percent: 71),
+                error: nil,
+                sourceLabel: "test"),
+        ])
+
+        let hydrated = store.load(for: [newAccount])
+
+        #expect(hydrated.isEmpty)
+    }
+
+    @Test
+    func `codex account snapshot store rejects same stored account after auth fingerprint changes`() {
+        let fileURL = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        defer { try? FileManager.default.removeItem(at: fileURL) }
+
+        let accountID = UUID()
+        let oldAccount = CodexVisibleAccount(
+            id: "reauth@example.com",
+            email: "reauth@example.com",
+            authFingerprint: "old-auth-fingerprint",
+            storedAccountID: accountID,
+            selectionSource: .managedAccount(id: accountID),
+            isActive: false,
+            isLive: false,
+            canReauthenticate: true,
+            canRemove: true)
+        let newAccount = CodexVisibleAccount(
+            id: "reauth@example.com",
+            email: "reauth@example.com",
+            authFingerprint: "new-auth-fingerprint",
+            storedAccountID: accountID,
+            selectionSource: .managedAccount(id: accountID),
+            isActive: true,
+            isLive: false,
+            canReauthenticate: true,
+            canRemove: true)
+        let store = FileCodexAccountUsageSnapshotStore(fileURL: fileURL)
+        store.store([
+            CodexAccountUsageSnapshot(
+                account: oldAccount,
+                snapshot: self.snapshot(email: oldAccount.email, percent: 71),
+                error: nil,
+                sourceLabel: "test"),
+        ])
+
+        let hydrated = store.load(for: [newAccount])
+
+        #expect(hydrated.isEmpty)
+    }
+
+    @Test
+    func `codex account snapshot store rejects legacy workspace records without identity`() throws {
+        let fileURL = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        defer { try? FileManager.default.removeItem(at: fileURL) }
+        let payload = """
+        {
+          "records" : [
+            {
+              "error" : "cached",
+              "id" : "legacy@example.com",
+              "snapshot" : null,
+              "sourceLabel" : "legacy"
+            }
+          ],
+          "version" : 1
+        }
+        """
+        try Data(payload.utf8).write(to: fileURL)
+
+        let accountID = UUID()
+        let workspaceAccount = CodexVisibleAccount(
+            id: "legacy@example.com",
+            email: "legacy@example.com",
+            workspaceLabel: "New Team",
+            workspaceAccountID: "acct-new",
+            storedAccountID: accountID,
+            selectionSource: .managedAccount(id: accountID),
+            isActive: true,
+            isLive: false,
+            canReauthenticate: true,
+            canRemove: true)
+        let store = FileCodexAccountUsageSnapshotStore(fileURL: fileURL)
+
+        let hydrated = store.load(for: [workspaceAccount])
+
+        #expect(hydrated.isEmpty)
+    }
+}
diff --git a/Tests/CodexBarTests/StatusMenuCodexSwitcherTests.swift b/Tests/CodexBarTests/StatusMenuCodexSwitcherTests.swift
new file mode 100644
index 0000000000..ff16899eb1
--- /dev/null
+++ b/Tests/CodexBarTests/StatusMenuCodexSwitcherTests.swift
@@ -0,0 +1,1414 @@
+import AppKit
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@Suite(.serialized)
+@MainActor
+struct StatusMenuCodexSwitcherTests {
+    private func disableMenuCardsForTesting() {
+        StatusItemController.menuCardRenderingEnabled = false
+        StatusItemController.setMenuRefreshEnabledForTesting(false)
+    }
+
+    private func makeSettings() -> SettingsStore {
+        let suite = "StatusMenuCodexSwitcherTests-\(UUID().uuidString)"
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+        return SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+    }
+
+    private func makeStatusBarForTesting() -> NSStatusBar {
+        .system
+    }
+
+    private func enableOnlyCodex(_ settings: SettingsStore) {
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: provider == .codex)
+        }
+    }
+
+    private func makeManagedAccountStoreURL(accounts: [ManagedCodexAccount]) throws -> URL {
+        let storeURL = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        let store = FileManagedCodexAccountStore(fileURL: storeURL)
+        try store.storeAccounts(ManagedCodexAccountSet(
+            version: FileManagedCodexAccountStore.currentVersion,
+            accounts: accounts))
+        return storeURL
+    }
+
+    private func actionLabels(in descriptor: MenuDescriptor) -> [String] {
+        descriptor.sections.flatMap(\.entries).compactMap { entry in
+            guard case let .action(label, _) = entry else { return nil }
+            return label
+        }
+    }
+
+    private func representedIDs(in menu: NSMenu) -> [String] {
+        menu.items.compactMap { $0.representedObject as? String }
+    }
+
+    private func snapshot(email: String, percent: Double = 12) -> UsageSnapshot {
+        UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: percent,
+                windowMinutes: 300,
+                resetsAt: Date().addingTimeInterval(300),
+                resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: percent,
+                windowMinutes: 10080,
+                resetsAt: Date().addingTimeInterval(86400),
+                resetDescription: nil),
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: email,
+                accountOrganization: nil,
+                loginMethod: "Plus"))
+    }
+
+    private func selectCodexVisibleAccountForStatusMenu(
+        id: String,
+        settings: SettingsStore,
+        store: UsageStore) -> Task<Void, Never>?
+    {
+        guard settings.selectCodexVisibleAccount(id: id) else { return nil }
+        _ = store.prepareCodexAccountScopedRefreshIfNeeded()
+        return Task { @MainActor in
+            await store.refreshCodexAccountScopedState(allowDisabled: true)
+        }
+    }
+
+    private func installBlockingCodexProvider(on store: UsageStore, blocker: BlockingStatusMenuCodexFetchStrategy) {
+        let baseSpec = store.providerSpecs[.codex]!
+        store.providerSpecs[.codex] = Self.makeCodexProviderSpec(baseSpec: baseSpec) {
+            try await blocker.awaitResult()
+        }
+    }
+
+    private static func makeCodexProviderSpec(
+        baseSpec: ProviderSpec,
+        loader: @escaping @Sendable () async throws -> UsageSnapshot) -> ProviderSpec
+    {
+        let baseDescriptor = baseSpec.descriptor
+        let strategy = StatusMenuTestCodexFetchStrategy(loader: loader)
+        let descriptor = ProviderDescriptor(
+            id: .codex,
+            metadata: baseDescriptor.metadata,
+            branding: baseDescriptor.branding,
+            tokenCost: baseDescriptor.tokenCost,
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .cli, .oauth],
+                pipeline: ProviderFetchPipeline { _ in [strategy] }),
+            cli: baseDescriptor.cli)
+        return ProviderSpec(
+            style: baseSpec.style,
+            isEnabled: baseSpec.isEnabled,
+            descriptor: descriptor,
+            makeFetchContext: baseSpec.makeFetchContext)
+    }
+
+    @Test
+    func `codex menu shows account switcher and add account action for multiple visible accounts`() throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        self.enableOnlyCodex(settings)
+
+        let managedAccountID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-111111111111"))
+        let managedAccount = ManagedCodexAccount(
+            id: managedAccountID,
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-home",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            settings._test_liveSystemCodexAccount = nil
+            try? FileManager.default.removeItem(at: storeURL)
+        }
+
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        settings.codexActiveSource = .liveSystem
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let projection = settings.codexVisibleAccountProjection
+        let descriptor = MenuDescriptor.build(
+            provider: .codex,
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updateReady: false)
+
+        #expect(projection.visibleAccounts.map(\.email) == ["live@example.com", "managed@example.com"])
+        #expect(projection.activeVisibleAccountID == "live@example.com")
+        let actionLabels = self.actionLabels(in: descriptor)
+        #expect(actionLabels.contains("Add Account..."))
+        #expect(actionLabels.contains("Switch Account...") == false)
+    }
+
+    @Test
+    func `codex menu hides account switcher when only one visible account exists`() {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        self.enableOnlyCodex(settings)
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "solo@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        defer { settings._test_liveSystemCodexAccount = nil }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let descriptor = MenuDescriptor.build(
+            provider: .codex,
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updateReady: false)
+
+        #expect(settings.codexVisibleAccountProjection.visibleAccounts.map(\.email) == ["solo@example.com"])
+        #expect(self.actionLabels(in: descriptor).contains("Add Account..."))
+    }
+
+    @Test
+    func `codex segmented multi account layout shows account switcher`() throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.multiAccountMenuLayout = .segmented
+        self.enableOnlyCodex(settings)
+
+        let managedAccountID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-111111111111"))
+        let managedAccount = ManagedCodexAccount(
+            id: managedAccountID,
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-home",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            settings._test_liveSystemCodexAccount = nil
+            try? FileManager.default.removeItem(at: storeURL)
+        }
+
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        settings.codexActiveSource = .liveSystem
+        _ = settings.codexVisibleAccountProjection
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu(for: .codex)
+        controller.menuWillOpen(menu)
+
+        #expect(menu.items.compactMap { $0.view as? CodexAccountSwitcherView }.first != nil)
+        #expect(self.representedIDs(in: menu).filter { $0.hasPrefix("menuCard") } == ["menuCard"])
+    }
+
+    @Test
+    func `merged codex menu smart refresh keeps account switcher visible`() throws {
+        self.disableMenuCardsForTesting()
+        StatusItemController.setMenuRefreshEnabledForTesting(true)
+        defer { StatusItemController.setMenuRefreshEnabledForTesting(false) }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        settings.multiAccountMenuLayout = .segmented
+
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            settings.setProviderEnabled(
+                provider: provider,
+                metadata: metadata,
+                enabled: provider == .codex || provider == .claude)
+        }
+
+        let managedAccountID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-111111111111"))
+        let managedAccount = ManagedCodexAccount(
+            id: managedAccountID,
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-home",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            settings._test_liveSystemCodexAccount = nil
+            try? FileManager.default.removeItem(at: storeURL)
+        }
+
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        settings.codexActiveSource = .liveSystem
+        _ = settings.codexVisibleAccountProjection
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+
+        #expect(menu.items.count(where: { $0.view is CodexAccountSwitcherView }) == 1)
+
+        controller.menuContentVersion &+= 1
+        controller.refreshOpenMenusIfNeeded()
+
+        #expect(menu.items.count(where: { $0.view is CodexAccountSwitcherView }) == 1)
+
+        settings._test_liveSystemCodexAccount = nil
+        controller.menuContentVersion &+= 1
+        controller.refreshOpenMenusIfNeeded()
+
+        #expect(menu.items.count(where: { $0.view is CodexAccountSwitcherView }) == 1)
+
+        controller.menuDidClose(menu)
+        controller.menuContentVersion &+= 1
+        controller.menuWillOpen(menu)
+
+        #expect(menu.items.count(where: { $0.view is CodexAccountSwitcherView }) == 0)
+    }
+
+    @Test
+    func `codex menu can select preserved switcher row during transient account projection`() throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        self.enableOnlyCodex(settings)
+
+        let managedAccountID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-111111111111"))
+        let managedAccount = ManagedCodexAccount(
+            id: managedAccountID,
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-home",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            settings._test_liveSystemCodexAccount = nil
+            try? FileManager.default.removeItem(at: storeURL)
+        }
+
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        settings.codexActiveSource = .managedAccount(id: managedAccountID)
+
+        let liveAccount = try #require(settings.codexVisibleAccountProjection.visibleAccounts
+            .first { $0.selectionSource == .liveSystem })
+        settings._test_liveSystemCodexAccount = nil
+
+        #expect(settings.codexVisibleAccountProjection.visibleAccounts.map(\.email) == ["managed@example.com"])
+        settings.selectDisplayedCodexVisibleAccount(liveAccount)
+        #expect(settings.codexActiveSource == .liveSystem)
+    }
+
+    @Test
+    func `codex stacked multi account layout shows account cards`() throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.multiAccountMenuLayout = .stacked
+        self.enableOnlyCodex(settings)
+
+        let managedAccountID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-111111111111"))
+        let managedAccount = ManagedCodexAccount(
+            id: managedAccountID,
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-home",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            settings._test_liveSystemCodexAccount = nil
+            try? FileManager.default.removeItem(at: storeURL)
+        }
+
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        settings.codexActiveSource = .liveSystem
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let projection = settings.codexVisibleAccountProjection
+        store.codexAccountSnapshots = projection.visibleAccounts.enumerated().map { index, account in
+            CodexAccountUsageSnapshot(
+                account: account,
+                snapshot: self.snapshot(email: account.email, percent: Double(10 + index)),
+                error: nil,
+                sourceLabel: "test")
+        }
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu(for: .codex)
+        controller.menuWillOpen(menu)
+
+        #expect(menu.items.compactMap { $0.view as? CodexAccountSwitcherView }.first == nil)
+        #expect(self.representedIDs(in: menu).filter { $0.hasPrefix("menuCard") } == ["menuCard-0", "menuCard-1"])
+    }
+
+    @Test
+    func `codex stacked multi account layout shows account cards before per account snapshots load`() throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.multiAccountMenuLayout = .stacked
+        self.enableOnlyCodex(settings)
+
+        let managedAccountID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-111111111111"))
+        let managedAccount = ManagedCodexAccount(
+            id: managedAccountID,
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-home",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            settings._test_liveSystemCodexAccount = nil
+            try? FileManager.default.removeItem(at: storeURL)
+        }
+
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        settings.codexActiveSource = .liveSystem
+        _ = settings.codexVisibleAccountProjection
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        store._setSnapshotForTesting(self.snapshot(email: "live@example.com"), provider: .codex)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu(for: .codex)
+        controller.menuWillOpen(menu)
+
+        #expect(menu.items.compactMap { $0.view as? CodexAccountSwitcherView }.first == nil)
+        #expect(self.representedIDs(in: menu).filter { $0.hasPrefix("menuCard") } == ["menuCard-0", "menuCard-1"])
+    }
+
+    @Test
+    func `codex switcher suppresses personal labels while preserving team workspace tooltips`() {
+        let accounts = [
+            CodexVisibleAccount(
+                id: "live:provider:account-personal",
+                email: "pl.fr@yandex.com",
+                workspaceLabel: "Personal",
+                workspaceAccountID: "account-personal",
+                storedAccountID: nil,
+                selectionSource: .liveSystem,
+                isActive: true,
+                isLive: true,
+                canReauthenticate: true,
+                canRemove: false),
+            CodexVisibleAccount(
+                id: "managed:aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+                email: "pl.fr@yandex.com",
+                workspaceLabel: "IDconcepts",
+                workspaceAccountID: "account-team",
+                storedAccountID: UUID(),
+                selectionSource: .managedAccount(id: UUID()),
+                isActive: false,
+                isLive: false,
+                canReauthenticate: true,
+                canRemove: true),
+        ]
+
+        let view = CodexAccountSwitcherView(
+            accounts: accounts,
+            selectedAccountID: accounts.first?.id,
+            width: 220,
+            onSelect: { _ in })
+
+        let titles = view._test_buttonTitles()
+        let toolTips = view._test_buttonToolTips()
+
+        #expect(titles.count == 2)
+        #expect(titles[0] != titles[1])
+        #expect(titles.allSatisfy { $0.lowercased().contains("pl.") })
+        #expect(titles[0].contains("|") == false)
+        #expect(titles[0].lowercased().contains("pers") == false)
+        #expect(titles[1].lowercased().contains("id"))
+        #expect(toolTips == accounts.map(\.menuDisplayName))
+        #expect(accounts[0].displayName == "pl.fr@yandex.com — Personal")
+        #expect(accounts[0].menuDisplayName == "pl.fr@yandex.com")
+    }
+
+    @Test
+    func `codex switcher reports fixed menu width for long account labels`() {
+        let accounts = [
+            CodexVisibleAccount(
+                id: "live:provider:account-personal",
+                email: "managed-account-with-a-very-long-name@example.com",
+                workspaceLabel: nil,
+                workspaceAccountID: "account-managed",
+                storedAccountID: nil,
+                selectionSource: .liveSystem,
+                isActive: true,
+                isLive: true,
+                canReauthenticate: true,
+                canRemove: false),
+            CodexVisibleAccount(
+                id: "managed:aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+                email: "steipete-with-a-very-long-label@gmail.com",
+                workspaceLabel: nil,
+                workspaceAccountID: "account-gmail",
+                storedAccountID: UUID(),
+                selectionSource: .managedAccount(id: UUID()),
+                isActive: false,
+                isLive: false,
+                canReauthenticate: true,
+                canRemove: true),
+        ]
+
+        let view = CodexAccountSwitcherView(
+            accounts: accounts,
+            selectedAccountID: accounts.first?.id,
+            width: 310,
+            onSelect: { _ in })
+
+        #expect(view.frame.width == 310)
+        #expect(view.intrinsicContentSize.width == 310)
+        #expect(view.fittingSize.width == 310)
+    }
+
+    @Test
+    func `codex switcher middle truncates long account emails`() {
+        let accounts = [
+            CodexVisibleAccount(
+                id: "live:provider:account-personal",
+                email: "local-person-with-an-extremely-long-name@example.com",
+                workspaceLabel: nil,
+                workspaceAccountID: "account-managed",
+                storedAccountID: nil,
+                selectionSource: .liveSystem,
+                isActive: true,
+                isLive: true,
+                canReauthenticate: true,
+                canRemove: false),
+            CodexVisibleAccount(
+                id: "managed:aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+                email: "second-person-with-an-extremely-long-name@example.com",
+                workspaceLabel: nil,
+                workspaceAccountID: "account-gmail",
+                storedAccountID: UUID(),
+                selectionSource: .managedAccount(id: UUID()),
+                isActive: false,
+                isLive: false,
+                canReauthenticate: true,
+                canRemove: true),
+        ]
+
+        let view = CodexAccountSwitcherView(
+            accounts: accounts,
+            selectedAccountID: accounts.first?.id,
+            width: 220,
+            onSelect: { _ in })
+        let titles = view._test_buttonTitles()
+
+        #expect(titles.count == 2)
+        #expect(titles[0].hasPrefix("local"))
+        #expect(titles[0].contains("…"))
+        #expect(titles[0].hasSuffix(".com"))
+        #expect(titles[1].hasPrefix("second"))
+        #expect(titles[1].contains("…"))
+        #expect(titles[1].hasSuffix(".com"))
+    }
+
+    @Test
+    func `codex account switcher passes the selected displayed account`() throws {
+        let managedID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-111111111111"))
+        let accounts = [
+            CodexVisibleAccount(
+                id: "live@example.com",
+                email: "live@example.com",
+                storedAccountID: nil,
+                selectionSource: .liveSystem,
+                isActive: true,
+                isLive: true,
+                canReauthenticate: true,
+                canRemove: false),
+            CodexVisibleAccount(
+                id: "managed@example.com",
+                email: "managed@example.com",
+                storedAccountID: managedID,
+                selectionSource: .managedAccount(id: managedID),
+                isActive: false,
+                isLive: false,
+                canReauthenticate: true,
+                canRemove: true),
+        ]
+        var selectedAccount: CodexVisibleAccount?
+        let view = CodexAccountSwitcherView(
+            accounts: accounts,
+            selectedAccountID: accounts.first?.id,
+            width: 220,
+            onSelect: { selectedAccount = $0 })
+
+        view._test_selectAccount(id: "managed@example.com")
+
+        #expect(selectedAccount == accounts[1])
+    }
+
+    @Test
+    func `codex menu switcher selection activates the visible managed account`() throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        self.enableOnlyCodex(settings)
+
+        let managedAccountID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-111111111111"))
+        let managedAccount = ManagedCodexAccount(
+            id: managedAccountID,
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-home",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            settings._test_liveSystemCodexAccount = nil
+            try? FileManager.default.removeItem(at: storeURL)
+        }
+
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        settings.codexActiveSource = .liveSystem
+
+        #expect(settings.selectCodexVisibleAccount(id: "managed@example.com"))
+
+        #expect(settings.codexActiveSource == .managedAccount(id: managedAccountID))
+    }
+
+    @Test
+    func `codex menu switcher clears stale account state on the first click`() async throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.costUsageEnabled = false
+        settings.codexCookieSource = .off
+        self.enableOnlyCodex(settings)
+
+        let managedAccountID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-111111111111"))
+        let managedAccount = ManagedCodexAccount(
+            id: managedAccountID,
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-home",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            settings._test_liveSystemCodexAccount = nil
+            try? FileManager.default.removeItem(at: storeURL)
+        }
+
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        settings.codexActiveSource = .liveSystem
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        store._test_codexCreditsLoaderOverride = {
+            CreditsSnapshot(remaining: 0, events: [], updatedAt: Date())
+        }
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(usedPercent: 30, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date(),
+                identity: ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: "live@example.com",
+                    accountOrganization: nil,
+                    loginMethod: "Pro")),
+            provider: .codex)
+        store.lastCodexAccountScopedRefreshGuard = store
+            .currentCodexAccountScopedRefreshGuard(preferCurrentSnapshot: false)
+
+        let blocker = BlockingStatusMenuCodexFetchStrategy()
+        self.installBlockingCodexProvider(on: store, blocker: blocker)
+
+        let refreshTask = try #require(
+            self.selectCodexVisibleAccountForStatusMenu(
+                id: "managed@example.com",
+                settings: settings,
+                store: store))
+
+        await blocker.waitUntilStarted()
+        #expect(settings.codexActiveSource == .managedAccount(id: managedAccountID))
+        #expect(store.snapshots[.codex] == nil)
+
+        await blocker.resume(with: .success(
+            UsageSnapshot(
+                primary: RateWindow(usedPercent: 9, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date(),
+                identity: ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: "managed@example.com",
+                    accountOrganization: nil,
+                    loginMethod: "Pro"))))
+        for _ in 0..<10 where store.snapshots[.codex]?.accountEmail(for: .codex) != "managed@example.com" {
+            try? await Task.sleep(for: .milliseconds(20))
+        }
+        await refreshTask.value
+        #expect(store.snapshots[.codex]?.accountEmail(for: .codex) == "managed@example.com")
+    }
+
+    @Test
+    func `codex account state disables add account while managed authentication is in flight`() async throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        self.enableOnlyCodex(settings)
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        defer { settings._test_liveSystemCodexAccount = nil }
+
+        let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        let runner = BlockingManagedCodexLoginRunnerForStatusMenuTests()
+        let service = ManagedCodexAccountService(
+            store: InMemoryManagedCodexAccountStoreForStatusMenuTests(),
+            homeFactory: TestManagedCodexHomeFactoryForStatusMenuTests(root: root),
+            loginRunner: runner,
+            identityReader: StubManagedCodexIdentityReaderForStatusMenuTests(email: "managed@example.com"),
+            workspaceResolver: StubManagedCodexWorkspaceResolverForStatusMenuTests())
+        let coordinator = ManagedCodexAccountCoordinator(service: service)
+        let authTask = Task { try await coordinator.authenticateManagedAccount() }
+        await runner.waitUntilStarted()
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let pane = ProvidersPane(
+            settings: settings,
+            store: store,
+            managedCodexAccountCoordinator: coordinator)
+        let state = try #require(pane._test_codexAccountsSectionState())
+
+        #expect(state.canAddAccount == false)
+        #expect(state.isAuthenticatingManagedAccount)
+        #expect(state.addAccountTitle == "Adding Account…")
+
+        await runner.resume()
+        _ = try await authTask.value
+    }
+
+    @Test
+    func `codex account state disables add account when managed store is unreadable`() throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        self.enableOnlyCodex(settings)
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        settings._test_unreadableManagedCodexAccountStore = true
+        defer {
+            settings._test_liveSystemCodexAccount = nil
+            settings._test_unreadableManagedCodexAccountStore = false
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let pane = ProvidersPane(settings: settings, store: store)
+        let state = try #require(pane._test_codexAccountsSectionState())
+
+        #expect(state.hasUnreadableManagedAccountStore)
+        #expect(state.canAddAccount == false)
+    }
+
+    @Test
+    func `codex menu switcher can select managed row when same email rows split by identity`() throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        self.enableOnlyCodex(settings)
+
+        let managedHome = FileManager.default.temporaryDirectory.appendingPathComponent(
+            UUID().uuidString,
+            isDirectory: true)
+        let managedAccountID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-222222222222"))
+        let managedAccount = ManagedCodexAccount(
+            id: managedAccountID,
+            email: "same@example.com",
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        try Self.writeCodexAuthFile(
+            homeURL: managedHome,
+            email: "same@example.com",
+            plan: "pro",
+            accountID: "account-managed")
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            settings._test_liveSystemCodexAccount = nil
+            try? FileManager.default.removeItem(at: storeURL)
+            try? FileManager.default.removeItem(at: managedHome)
+        }
+
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "SAME@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .emailOnly(normalizedEmail: "same@example.com"))
+        settings.codexActiveSource = .liveSystem
+
+        let projection = settings.codexVisibleAccountProjection
+        #expect(projection.visibleAccounts.count == 2)
+        let managedVisibleAccount = try #require(projection.visibleAccounts
+            .first { $0.storedAccountID == managedAccountID })
+
+        #expect(settings.selectCodexVisibleAccount(id: managedVisibleAccount.id))
+        #expect(settings.codexActiveSource == .managedAccount(id: managedAccountID))
+    }
+}
+
+extension StatusMenuCodexSwitcherTests {
+    @Test
+    func `codex account switcher swallows child button hit testing for first click`() throws {
+        let managedID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-111111111111"))
+        let accounts = [
+            CodexVisibleAccount(
+                id: "live@example.com",
+                email: "live@example.com",
+                storedAccountID: nil,
+                selectionSource: .liveSystem,
+                isActive: true,
+                isLive: true,
+                canReauthenticate: true,
+                canRemove: false),
+            CodexVisibleAccount(
+                id: "managed@example.com",
+                email: "managed@example.com",
+                storedAccountID: managedID,
+                selectionSource: .managedAccount(id: managedID),
+                isActive: false,
+                isLive: false,
+                canReauthenticate: true,
+                canRemove: true),
+        ]
+        let view = CodexAccountSwitcherView(
+            accounts: accounts,
+            selectedAccountID: accounts.first?.id,
+            width: 220,
+            onSelect: { _ in })
+
+        #expect(view.acceptsFirstMouse(for: nil) == true)
+        #expect(view._test_hitTestSwallowsChildButton(id: "managed@example.com") == true)
+        #expect(view._test_toolTipAfterHitTest(id: "managed@example.com") == "managed@example.com")
+    }
+
+    @Test
+    func `codex account switcher routes runtime click path to selected account`() throws {
+        let managedID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-111111111111"))
+        let accounts = [
+            CodexVisibleAccount(
+                id: "live@example.com",
+                email: "live@example.com",
+                storedAccountID: nil,
+                selectionSource: .liveSystem,
+                isActive: true,
+                isLive: true,
+                canReauthenticate: true,
+                canRemove: false),
+            CodexVisibleAccount(
+                id: "managed@example.com",
+                email: "managed@example.com",
+                storedAccountID: managedID,
+                selectionSource: .managedAccount(id: managedID),
+                isActive: false,
+                isLive: false,
+                canReauthenticate: true,
+                canRemove: true),
+        ]
+        var selectedAccount: CodexVisibleAccount?
+        let view = CodexAccountSwitcherView(
+            accounts: accounts,
+            selectedAccountID: accounts.first?.id,
+            width: 220,
+            onSelect: { selectedAccount = $0 })
+
+        #expect(view._test_simulateRuntimeClick(id: "managed@example.com") == true)
+        #expect(selectedAccount == accounts[1])
+    }
+
+    @Test
+    func `codex account switcher runtime click resolves second row buttons`() throws {
+        let managedID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-111111111111"))
+        let secondManagedID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-222222222222"))
+        let accounts = [
+            CodexVisibleAccount(
+                id: "live@example.com",
+                email: "live@example.com",
+                storedAccountID: nil,
+                selectionSource: .liveSystem,
+                isActive: true,
+                isLive: true,
+                canReauthenticate: true,
+                canRemove: false),
+            CodexVisibleAccount(
+                id: "managed@example.com",
+                email: "managed@example.com",
+                storedAccountID: managedID,
+                selectionSource: .managedAccount(id: managedID),
+                isActive: false,
+                isLive: false,
+                canReauthenticate: true,
+                canRemove: true),
+            CodexVisibleAccount(
+                id: "team@example.com",
+                email: "team@example.com",
+                storedAccountID: secondManagedID,
+                selectionSource: .managedAccount(id: secondManagedID),
+                isActive: false,
+                isLive: false,
+                canReauthenticate: true,
+                canRemove: true),
+            CodexVisibleAccount(
+                id: "second-row@example.com",
+                email: "second-row@example.com",
+                storedAccountID: nil,
+                selectionSource: .liveSystem,
+                isActive: false,
+                isLive: true,
+                canReauthenticate: true,
+                canRemove: false),
+        ]
+        var selectedAccount: CodexVisibleAccount?
+        let view = CodexAccountSwitcherView(
+            accounts: accounts,
+            selectedAccountID: accounts.first?.id,
+            width: 220,
+            onSelect: { selectedAccount = $0 })
+
+        #expect(view._test_simulateRuntimeClick(id: "second-row@example.com") == true)
+        #expect(selectedAccount == accounts[3])
+    }
+}
+
+@MainActor
+extension StatusMenuCodexSwitcherTests {
+    @Test
+    func `codex account switch defers open menu rebuild until after switcher action`() async throws {
+        self.disableMenuCardsForTesting()
+        StatusItemController.setMenuRefreshEnabledForTesting(true)
+        defer { StatusItemController.setMenuRefreshEnabledForTesting(false) }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        settings.multiAccountMenuLayout = .segmented
+
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            settings.setProviderEnabled(
+                provider: provider,
+                metadata: metadata,
+                enabled: provider == .codex || provider == .claude)
+        }
+
+        let managedAccountID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-111111111111"))
+        let managedAccount = ManagedCodexAccount(
+            id: managedAccountID,
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-home",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            settings._test_liveSystemCodexAccount = nil
+            try? FileManager.default.removeItem(at: storeURL)
+        }
+
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        settings.codexActiveSource = .liveSystem
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        store._setSnapshotForTesting(self.snapshot(email: "live@example.com", percent: 11), provider: .codex)
+        store.lastCodexAccountScopedRefreshGuard = store.currentCodexAccountScopedRefreshGuard(
+            preferCurrentSnapshot: false)
+        let blocker = BlockingStatusMenuCodexFetchStrategy()
+        self.installBlockingCodexProvider(on: store, blocker: blocker)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        let switcher = try #require(menu.items.compactMap { $0.view as? CodexAccountSwitcherView }.first)
+        let managedVisibleAccount = try #require(settings.codexVisibleAccountProjection.visibleAccounts
+            .first { $0.storedAccountID == managedAccountID })
+
+        var rebuildCount = 0
+        controller._test_openMenuRebuildObserver = { _ in
+            rebuildCount += 1
+        }
+        defer { controller._test_openMenuRebuildObserver = nil }
+
+        switcher._test_selectAccount(id: managedVisibleAccount.id)
+
+        #expect(rebuildCount == 0)
+        for _ in 0..<20 where rebuildCount == 0 {
+            await Task.yield()
+        }
+        #expect(rebuildCount == 1)
+
+        await blocker.waitUntilStarted()
+        await blocker.resume(with: .success(self.snapshot(email: "managed@example.com", percent: 17)))
+    }
+
+    @Test
+    func `codex account scoped refresh does not retain status controller while in flight`() async throws {
+        self.disableMenuCardsForTesting()
+        StatusItemController.setMenuRefreshEnabledForTesting(true)
+        defer { StatusItemController.setMenuRefreshEnabledForTesting(false) }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        settings.multiAccountMenuLayout = .segmented
+
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            settings.setProviderEnabled(
+                provider: provider,
+                metadata: metadata,
+                enabled: provider == .codex || provider == .claude)
+        }
+
+        let managedAccountID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-111111111111"))
+        let managedAccount = ManagedCodexAccount(
+            id: managedAccountID,
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-home",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            settings._test_liveSystemCodexAccount = nil
+            try? FileManager.default.removeItem(at: storeURL)
+        }
+
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        settings.codexActiveSource = .liveSystem
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        store._setSnapshotForTesting(self.snapshot(email: "live@example.com", percent: 11), provider: .codex)
+        store.lastCodexAccountScopedRefreshGuard = store.currentCodexAccountScopedRefreshGuard(
+            preferCurrentSnapshot: false)
+        let blocker = BlockingStatusMenuCodexFetchStrategy()
+        self.installBlockingCodexProvider(on: store, blocker: blocker)
+
+        var controller: StatusItemController? = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        let releasedController = WeakStatusItemControllerReference(controller)
+
+        do {
+            let activeController = try #require(controller)
+            let menu = activeController.makeMenu()
+            activeController.menuWillOpen(menu)
+            let switcher = try #require(menu.items.compactMap { $0.view as? CodexAccountSwitcherView }.first)
+            let managedVisibleAccount = try #require(settings.codexVisibleAccountProjection.visibleAccounts
+                .first { $0.storedAccountID == managedAccountID })
+
+            switcher._test_selectAccount(id: managedVisibleAccount.id)
+        }
+
+        await blocker.waitUntilStarted()
+        controller?.releaseStatusItemsForTesting()
+        controller = nil
+        for _ in 0..<20 where releasedController.value != nil {
+            await Task.yield()
+        }
+        #expect(releasedController.value == nil)
+
+        await blocker.resume(with: .success(self.snapshot(email: "managed@example.com", percent: 17)))
+    }
+
+    @Test
+    func `codex stacked refresh discards selected outcome when visible selection changes mid flight`() throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.multiAccountMenuLayout = .stacked
+        self.enableOnlyCodex(settings)
+
+        let managedAccountID = try #require(UUID(uuidString: "AAAAAAAA-BBBB-CCCC-DDDD-111111111111"))
+        let managedAccount = ManagedCodexAccount(
+            id: managedAccountID,
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-home",
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let storeURL = try self.makeManagedAccountStoreURL(accounts: [managedAccount])
+        defer {
+            settings._test_managedCodexAccountStoreURL = nil
+            settings._test_liveSystemCodexAccount = nil
+            try? FileManager.default.removeItem(at: storeURL)
+        }
+
+        settings._test_managedCodexAccountStoreURL = storeURL
+        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date())
+        settings.codexActiveSource = .liveSystem
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        store._setSnapshotForTesting(self.snapshot(email: "managed@example.com", percent: 77), provider: .codex)
+
+        let projection = settings.codexVisibleAccountProjection
+        let originalVisibleAccountID = projection.activeVisibleAccountID
+        let originalSelectionSource = originalVisibleAccountID.flatMap {
+            projection.source(forVisibleAccountID: $0)
+        }
+        #expect(store.codexVisibleSelectionStillMatches(
+            originalVisibleAccountID: originalVisibleAccountID,
+            originalSelectionSource: originalSelectionSource))
+
+        #expect(settings.selectCodexVisibleAccount(id: "managed@example.com"))
+
+        #expect(settings.codexActiveSource == .managedAccount(id: managedAccountID))
+        #expect(store.codexVisibleSelectionStillMatches(
+            originalVisibleAccountID: originalVisibleAccountID,
+            originalSelectionSource: originalSelectionSource) == false)
+        #expect(store.snapshots[.codex]?.accountEmail(for: .codex) == "managed@example.com")
+        #expect(store.snapshots[.codex]?.primary?.usedPercent == 77)
+    }
+
+    private static func writeCodexAuthFile(
+        homeURL: URL,
+        email: String,
+        plan: String,
+        accountID: String? = nil) throws
+    {
+        try FileManager.default.createDirectory(at: homeURL, withIntermediateDirectories: true)
+        var tokens: [String: Any] = [
+            "accessToken": "access-token",
+            "refreshToken": "refresh-token",
+            "idToken": Self.fakeJWT(email: email, plan: plan, accountID: accountID),
+        ]
+        if let accountID {
+            tokens["account_id"] = accountID
+        }
+        let auth = ["tokens": tokens]
+        let data = try JSONSerialization.data(withJSONObject: auth)
+        try data.write(to: homeURL.appendingPathComponent("auth.json"))
+    }
+
+    private static func fakeJWT(email: String, plan: String, accountID: String? = nil) -> String {
+        let header = (try? JSONSerialization.data(withJSONObject: ["alg": "none"])) ?? Data()
+        var payloadObject: [String: Any] = [
+            "email": email,
+            "chatgpt_plan_type": plan,
+        ]
+        if let accountID {
+            payloadObject["https://api.openai.com/auth"] = [
+                "chatgpt_account_id": accountID,
+            ]
+        }
+        let payload = (try? JSONSerialization.data(withJSONObject: payloadObject)) ?? Data()
+
+        func base64URL(_ data: Data) -> String {
+            data.base64EncodedString()
+                .replacingOccurrences(of: "=", with: "")
+                .replacingOccurrences(of: "+", with: "-")
+                .replacingOccurrences(of: "/", with: "_")
+        }
+
+        return "\(base64URL(header)).\(base64URL(payload))."
+    }
+}
+
+private final class WeakStatusItemControllerReference {
+    weak var value: StatusItemController?
+
+    init(_ value: StatusItemController?) {
+        self.value = value
+    }
+}
+
+private struct StatusMenuTestCodexFetchStrategy: ProviderFetchStrategy {
+    let loader: @Sendable () async throws -> UsageSnapshot
+
+    var id: String {
+        "status-menu-test-codex"
+    }
+
+    var kind: ProviderFetchKind {
+        .cli
+    }
+
+    func isAvailable(_: ProviderFetchContext) async -> Bool {
+        true
+    }
+
+    func fetch(_: ProviderFetchContext) async throws -> ProviderFetchResult {
+        let snapshot = try await self.loader()
+        return self.makeResult(usage: snapshot, sourceLabel: "status-menu-test-codex")
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+}
+
+private actor BlockingStatusMenuCodexFetchStrategy {
+    private var waiters: [CheckedContinuation<Result<UsageSnapshot, Error>, Never>] = []
+    private var startedWaiters: [(count: Int, continuation: CheckedContinuation<Void, Never>)] = []
+    private var startCount = 0
+
+    func awaitResult() async throws -> UsageSnapshot {
+        let result = await withCheckedContinuation { continuation in
+            self.waiters.append(continuation)
+            self.startCount += 1
+            self.resumeStartedWaitersIfReady()
+        }
+        return try result.get()
+    }
+
+    func waitUntilStarted() async {
+        await self.waitForStartCount(1)
+    }
+
+    func waitForStartCount(_ count: Int) async {
+        if self.startCount >= count { return }
+        await withCheckedContinuation { continuation in
+            self.startedWaiters.append((count, continuation))
+        }
+    }
+
+    func resume(with result: Result<UsageSnapshot, Error>) {
+        self.waiters.forEach { $0.resume(returning: result) }
+        self.waiters.removeAll()
+    }
+
+    private func resumeStartedWaitersIfReady() {
+        let readyWaiters = self.startedWaiters.filter { self.startCount >= $0.count }
+        self.startedWaiters.removeAll { self.startCount >= $0.count }
+        readyWaiters.forEach { $0.continuation.resume() }
+    }
+}
+
+private actor BlockingManagedCodexLoginRunnerForStatusMenuTests: ManagedCodexLoginRunning {
+    private var waiters: [CheckedContinuation<CodexLoginRunner.Result, Never>] = []
+    private var startedWaiters: [CheckedContinuation<Void, Never>] = []
+    private var didStart = false
+
+    func run(homePath _: String, timeout _: TimeInterval) async -> CodexLoginRunner.Result {
+        await withCheckedContinuation { continuation in
+            self.waiters.append(continuation)
+            self.didStart = true
+            self.startedWaiters.forEach { $0.resume() }
+            self.startedWaiters.removeAll()
+        }
+    }
+
+    func waitUntilStarted() async {
+        if self.didStart { return }
+        await withCheckedContinuation { continuation in
+            self.startedWaiters.append(continuation)
+        }
+    }
+
+    func resume() {
+        let result = CodexLoginRunner.Result(outcome: .success, output: "ok")
+        self.waiters.forEach { $0.resume(returning: result) }
+        self.waiters.removeAll()
+    }
+}
+
+private final class InMemoryManagedCodexAccountStoreForStatusMenuTests: ManagedCodexAccountStoring,
+@unchecked Sendable {
+    private var snapshot = ManagedCodexAccountSet(version: 1, accounts: [])
+
+    func loadAccounts() throws -> ManagedCodexAccountSet {
+        self.snapshot
+    }
+
+    func storeAccounts(_ accounts: ManagedCodexAccountSet) throws {
+        self.snapshot = accounts
+    }
+
+    func ensureFileExists() throws -> URL {
+        FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+    }
+}
+
+private struct StubManagedCodexWorkspaceResolverForStatusMenuTests: ManagedCodexWorkspaceResolving {
+    func resolveWorkspaceIdentity(
+        homePath _: String,
+        providerAccountID _: String) async -> CodexOpenAIWorkspaceIdentity?
+    {
+        nil
+    }
+}
+
+private struct TestManagedCodexHomeFactoryForStatusMenuTests: ManagedCodexHomeProducing {
+    let root: URL
+
+    func makeHomeURL() -> URL {
+        self.root.appendingPathComponent(UUID().uuidString, isDirectory: true)
+    }
+
+    func validateManagedHomeForDeletion(_ url: URL) throws {
+        try ManagedCodexHomeFactory(root: self.root).validateManagedHomeForDeletion(url)
+    }
+}
+
+private struct StubManagedCodexIdentityReaderForStatusMenuTests: ManagedCodexIdentityReading {
+    let email: String
+
+    func loadAccountIdentity(homePath _: String) throws -> CodexAuthBackedAccount {
+        CodexAuthBackedAccount(
+            identity: CodexIdentityResolver.resolve(accountId: nil, email: self.email),
+            email: self.email,
+            plan: "Pro")
+    }
+}
diff --git a/Tests/CodexBarTests/StatusMenuCostMenuCardTests.swift b/Tests/CodexBarTests/StatusMenuCostMenuCardTests.swift
new file mode 100644
index 0000000000..67df6ad396
--- /dev/null
+++ b/Tests/CodexBarTests/StatusMenuCostMenuCardTests.swift
@@ -0,0 +1,181 @@
+import AppKit
+import CodexBarCore
+import SwiftUI
+import Testing
+@testable import CodexBar
+
+@MainActor
+@Suite(.serialized)
+struct StatusMenuCostMenuCardTests {
+    @Test
+    func `cost menu shows no detail lines`() {
+        let tokenUsage = UsageMenuCardView.Model.TokenUsageSection(
+            sessionLine: "Today: $74.83 - 87M tokens",
+            monthLine: "Last 30 days: $4,279.64 - 5.7B tokens",
+            hintLine: "Costs are estimated from local usage.",
+            errorLine: "Cost refresh failed.",
+            errorCopyText: nil)
+
+        let visibleLines = StatusItemController.costMenuVisibleDetailLines(
+            tokenUsage: tokenUsage,
+            hasSubmenu: true)
+        #expect(visibleLines == [])
+
+        let fallbackTitle = StatusItemController.costMenuFallbackAttributedTitle(visibleDetailLines: visibleLines)
+        #expect(fallbackTitle.string == "Cost")
+    }
+
+    @Test
+    func `cost menu preserves summary lines without history submenu`() {
+        let tokenUsage = UsageMenuCardView.Model.TokenUsageSection(
+            sessionLine: "Today: $74.83 - 87M tokens",
+            monthLine: "Last 30 days: $4,279.64 - 5.7B tokens",
+            hintLine: "Costs are estimated from local usage.",
+            errorLine: "Cost refresh failed.",
+            errorCopyText: nil)
+
+        let visibleLines = StatusItemController.costMenuVisibleDetailLines(
+            tokenUsage: tokenUsage,
+            hasSubmenu: false)
+        #expect(visibleLines == [
+            "Today: $74.83 - 87M tokens",
+            "Last 30 days: $4,279.64 - 5.7B tokens",
+            "Cost refresh failed.",
+        ])
+
+        let fallbackTitle = StatusItemController.costMenuFallbackAttributedTitle(visibleDetailLines: visibleLines)
+        #expect(fallbackTitle.string.contains("Today: $74.83 - 87M tokens"))
+        #expect(fallbackTitle.string.contains("Last 30 days: $4,279.64 - 5.7B tokens"))
+        #expect(fallbackTitle.string.contains("Cost refresh failed."))
+    }
+
+    @Test
+    func `cost menu tooltip preserves hint and error details`() {
+        let tokenUsage = UsageMenuCardView.Model.TokenUsageSection(
+            sessionLine: "Today: $1.00",
+            monthLine: "Last 30 days: $9.00",
+            hintLine: "Costs are estimated from local usage.",
+            errorLine: "Cost refresh failed.",
+            errorCopyText: nil)
+
+        #expect(StatusItemController.costMenuTooltipLines(tokenUsage: tokenUsage) == [
+            "Today: $1.00",
+            "Last 30 days: $9.00",
+            "Costs are estimated from local usage.",
+            "Cost refresh failed.",
+        ])
+    }
+
+    @Test
+    func `cost menu with history submenu omits native tooltip`() {
+        let settings = self.makeSettings()
+        let fetcher = UsageFetcher()
+        let store = UsageStore(
+            fetcher: fetcher,
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let tokenUsage = UsageMenuCardView.Model.TokenUsageSection(
+            sessionLine: "Today: $1.00",
+            monthLine: "Last 30 days: $9.00",
+            hintLine: "Costs are estimated from local usage.",
+            errorLine: nil,
+            errorCopyText: nil)
+        let submenu = NSMenu()
+
+        let item = controller.makeCostMenuCardItem(
+            model: self.makeModel(tokenUsage: tokenUsage),
+            submenu: submenu,
+            width: StatusItemController.menuCardBaseWidth)
+
+        #expect(item.submenu === submenu)
+        #expect(item.toolTip == nil)
+    }
+
+    @Test
+    func `rendered cost menu keeps long dynamic details inside fixed row width`() throws {
+        let previousRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = true
+        defer { StatusItemController.menuCardRenderingEnabled = previousRendering }
+
+        let settings = self.makeSettings()
+        let fetcher = UsageFetcher()
+        let store = UsageStore(
+            fetcher: fetcher,
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let width = StatusItemController.menuCardBaseWidth
+        let tokenUsage = UsageMenuCardView.Model.TokenUsageSection(
+            sessionLine: "Today: $227.42 - 267M tokens - " + String(repeating: "wide ", count: 20),
+            monthLine: "Last 30 days: $52,431.09 - 77B tokens - " + String(repeating: "wide ", count: 20),
+            hintLine: "Costs are estimated from local usage.",
+            errorLine: nil,
+            errorCopyText: nil)
+        let model = self.makeModel(tokenUsage: tokenUsage)
+
+        // No history submenu — detail lines are visible and must be clipped to the row width.
+        let item = controller.makeCostMenuCardItem(
+            model: model,
+            submenu: nil,
+            width: width)
+        let view = try #require(item.view)
+
+        #expect(view is any MenuCardMeasuring)
+        #expect(abs(view.frame.width - width) <= 0.5)
+        #expect(item.title == "Cost")
+        #expect(item.toolTip?.contains("$52,431.09") == true)
+        #expect(item.submenu == nil)
+    }
+
+    private func makeSettings() -> SettingsStore {
+        let suite = "StatusMenuCostMenuCardTests-\(UUID().uuidString)"
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        return SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+    }
+
+    private func makeModel(
+        tokenUsage: UsageMenuCardView.Model.TokenUsageSection) -> UsageMenuCardView.Model
+    {
+        UsageMenuCardView.Model(
+            provider: .codex,
+            providerName: "Codex",
+            email: "user@example.com",
+            subtitleText: "Updated now",
+            subtitleStyle: .info,
+            planText: "Pro",
+            metrics: [],
+            usageNotes: [],
+            openAIAPIUsage: nil,
+            inlineUsageDashboard: nil,
+            creditsText: nil,
+            creditsRemaining: nil,
+            creditsHintText: nil,
+            creditsHintCopyText: nil,
+            providerCost: nil,
+            tokenUsage: tokenUsage,
+            placeholder: nil,
+            progressColor: .blue)
+    }
+}
diff --git a/Tests/CodexBarTests/StatusMenuHeightCacheTests.swift b/Tests/CodexBarTests/StatusMenuHeightCacheTests.swift
new file mode 100644
index 0000000000..18f27e501d
--- /dev/null
+++ b/Tests/CodexBarTests/StatusMenuHeightCacheTests.swift
@@ -0,0 +1,302 @@
+import CodexBarCore
+import Foundation
+import SwiftUI
+import Testing
+@testable import CodexBar
+
+extension StatusMenuTests {
+    @Test
+    func `menu card sizing uses displayed hosting view`() throws {
+        let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = true
+        defer {
+            StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering
+        }
+
+        let controller = self.makeHeightCacheController()
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let counter = MenuCardRepresentableCounter()
+        let item = controller.makeMenuCardItem(
+            CountingMenuCardRepresentable(counter: counter),
+            id: "countingCard-\(UUID().uuidString)",
+            width: 320,
+            heightCacheScope: "counting",
+            heightCacheFingerprint: "counting-\(UUID().uuidString)")
+        let view = try #require(item.view)
+
+        view.layoutSubtreeIfNeeded()
+
+        #expect(counter.makeViewCount == 1)
+    }
+
+    @Test
+    func `menu card height cache is reused for stable card content`() {
+        let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = true
+        defer {
+            StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering
+        }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: provider == .codex)
+        }
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: AccountInfo(email: nil, plan: nil),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.populateMenu(menu, provider: .codex)
+        let firstKeys = Set(controller.menuCardHeightCache.keys)
+
+        #expect(!firstKeys.isEmpty)
+
+        controller.populateMenu(menu, provider: .codex)
+        #expect(Set(controller.menuCardHeightCache.keys) == firstKeys)
+
+        controller.invalidateMenus()
+        #expect(Set(controller.menuCardHeightCache.keys) == firstKeys)
+    }
+
+    @Test
+    func `standard menu width cache is reused for stable action rows`() {
+        let controller = self.makeHeightCacheController()
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.populateMenu(menu, provider: .codex)
+        let firstCache = controller.measuredStandardMenuWidthCache
+
+        #expect(!firstCache.isEmpty)
+        #expect(firstCache.keys.allSatisfy {
+            $0.contains("font=\(StatusItemController.menuCardHeightTextScaleToken())")
+        })
+
+        controller.populateMenu(menu, provider: .codex)
+        #expect(controller.measuredStandardMenuWidthCache == firstCache)
+    }
+
+    @Test
+    func `fingerprinted menu card height cache survives content version invalidation`() {
+        let controller = self.makeHeightCacheController()
+        defer { controller.releaseStatusItemsForTesting() }
+
+        var measureCount = 0
+        let first = controller.cachedMenuCardHeight(
+            for: "menuCard",
+            scope: UsageProvider.codex.rawValue,
+            width: 320,
+            fingerprint: "content:stable")
+        {
+            measureCount += 1
+            return 42
+        }
+
+        controller.invalidateMenus()
+
+        let second = controller.cachedMenuCardHeight(
+            for: "menuCard",
+            scope: UsageProvider.codex.rawValue,
+            width: 320,
+            fingerprint: "content:stable")
+        {
+            measureCount += 1
+            return 99
+        }
+
+        #expect(first == 42)
+        #expect(second == 42)
+        #expect(measureCount == 1)
+    }
+
+    @Test
+    func `fingerprinted menu card height cache remeasures when content changes`() {
+        let controller = self.makeHeightCacheController()
+        defer { controller.releaseStatusItemsForTesting() }
+
+        var measureCount = 0
+        let first = controller.cachedMenuCardHeight(
+            for: "menuCard",
+            scope: UsageProvider.codex.rawValue,
+            width: 320,
+            fingerprint: "content:a")
+        {
+            measureCount += 1
+            return 42
+        }
+        let second = controller.cachedMenuCardHeight(
+            for: "menuCard",
+            scope: UsageProvider.codex.rawValue,
+            width: 320,
+            fingerprint: "content:b")
+        {
+            measureCount += 1
+            return 99
+        }
+
+        #expect(first == 42)
+        #expect(second == 99)
+        #expect(measureCount == 2)
+    }
+
+    @Test
+    func `unfingerprinted menu card height cache remains content version scoped`() {
+        let controller = self.makeHeightCacheController()
+        defer { controller.releaseStatusItemsForTesting() }
+
+        var measureCount = 0
+        let first = controller.cachedMenuCardHeight(
+            for: "menuCard",
+            scope: UsageProvider.codex.rawValue,
+            width: 320)
+        {
+            measureCount += 1
+            return 42
+        }
+
+        controller.invalidateMenus()
+
+        let second = controller.cachedMenuCardHeight(
+            for: "menuCard",
+            scope: UsageProvider.codex.rawValue,
+            width: 320)
+        {
+            measureCount += 1
+            return 99
+        }
+
+        #expect(first == 42)
+        #expect(second == 99)
+        #expect(measureCount == 2)
+    }
+
+    @Test
+    func `menu invalidation prunes old version scoped height cache entries`() {
+        let controller = self.makeHeightCacheController()
+        defer { controller.releaseStatusItemsForTesting() }
+
+        _ = controller.cachedMenuCardHeight(
+            for: "versioned",
+            scope: UsageProvider.codex.rawValue,
+            width: 320)
+        {
+            42
+        }
+        _ = controller.cachedMenuCardHeight(
+            for: "fingerprinted",
+            scope: UsageProvider.codex.rawValue,
+            width: 320,
+            fingerprint: "content:stable")
+        {
+            99
+        }
+
+        controller.invalidateMenus()
+
+        #expect(controller.menuCardHeightCache.keys.allSatisfy { !$0.fingerprint.hasPrefix("version:") })
+        #expect(controller.menuCardHeightCache.keys.contains { $0.fingerprint == "content:stable" })
+    }
+
+    @Test
+    func `menu card height cache scopes same row ids by provider`() {
+        let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = true
+        defer {
+            StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering
+        }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            settings.setProviderEnabled(
+                provider: provider,
+                metadata: metadata,
+                enabled: provider == .codex || provider == .claude)
+        }
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 12,
+                    windowMinutes: 300,
+                    resetsAt: nil,
+                    resetDescription: nil),
+                secondary: nil,
+                tertiary: nil,
+                updatedAt: Date(),
+                identity: ProviderIdentitySnapshot(
+                    providerID: .claude,
+                    accountEmail: "claude@example.com",
+                    accountOrganization: nil,
+                    loginMethod: "Claude Pro")),
+            provider: .claude)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: AccountInfo(email: nil, plan: nil),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.populateMenu(menu, provider: .codex)
+        controller.populateMenu(menu, provider: .claude)
+
+        let scopes = Set(controller.menuCardHeightCache.keys.map(\.scope))
+        #expect(scopes.contains(UsageProvider.codex.rawValue))
+        #expect(scopes.contains(UsageProvider.claude.rawValue))
+    }
+
+    private func makeHeightCacheController() -> StatusItemController {
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        return StatusItemController(
+            store: store,
+            settings: settings,
+            account: AccountInfo(email: nil, plan: nil),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+    }
+}
+
+@MainActor
+private final class MenuCardRepresentableCounter {
+    var makeViewCount = 0
+}
+
+private struct CountingMenuCardRepresentable: NSViewRepresentable {
+    let counter: MenuCardRepresentableCounter
+
+    func makeNSView(context: Context) -> NSTextField {
+        self.counter.makeViewCount += 1
+        return NSTextField(labelWithString: "Counted")
+    }
+
+    func updateNSView(_ nsView: NSTextField, context: Context) {
+        _ = nsView
+        _ = context
+    }
+}
diff --git a/Tests/CodexBarTests/StatusMenuHighlightTests.swift b/Tests/CodexBarTests/StatusMenuHighlightTests.swift
new file mode 100644
index 0000000000..96fccbb561
--- /dev/null
+++ b/Tests/CodexBarTests/StatusMenuHighlightTests.swift
@@ -0,0 +1,55 @@
+import AppKit
+import CodexBarCore
+import Testing
+@testable import CodexBar
+
+@MainActor
+extension StatusMenuTests {
+    final class HighlightProbeView: NSView, MenuCardHighlighting {
+        private(set) var states: [Bool] = []
+
+        func setHighlighted(_ highlighted: Bool) {
+            self.states.append(highlighted)
+        }
+    }
+
+    @Test
+    func `menu highlight updates only previous and current custom rows`() {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = NSMenu()
+        let firstView = HighlightProbeView()
+        let secondView = HighlightProbeView()
+        let thirdView = HighlightProbeView()
+        let first = NSMenuItem()
+        first.view = firstView
+        first.isEnabled = true
+        let second = NSMenuItem()
+        second.view = secondView
+        second.isEnabled = true
+        let third = NSMenuItem()
+        third.view = thirdView
+        third.isEnabled = true
+        menu.addItem(first)
+        menu.addItem(second)
+        menu.addItem(third)
+
+        controller.menu(menu, willHighlight: first)
+        controller.menu(menu, willHighlight: second)
+        controller.menu(menu, willHighlight: second)
+
+        #expect(firstView.states == [true, false])
+        #expect(secondView.states == [true])
+        #expect(thirdView.states.isEmpty)
+    }
+}
diff --git a/Tests/CodexBarTests/StatusMenuHostedSubmenuRefreshTests.swift b/Tests/CodexBarTests/StatusMenuHostedSubmenuRefreshTests.swift
new file mode 100644
index 0000000000..6c4b91007e
--- /dev/null
+++ b/Tests/CodexBarTests/StatusMenuHostedSubmenuRefreshTests.swift
@@ -0,0 +1,569 @@
+import AppKit
+import CodexBarCore
+import Testing
+@testable import CodexBar
+
+@MainActor
+@Suite(.serialized)
+struct StatusMenuHostedSubmenuRefreshTests {
+    @Test
+    func `storage native row preserves its plain menu title`() throws {
+        let settings = Self.makeSettings()
+        settings.providerStorageFootprintsEnabled = true
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        Self.seedStorageFootprint(in: store)
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = NSMenu()
+        #expect(controller.addStorageMenuCardSection(
+            to: menu,
+            provider: .claude,
+            width: StatusItemController.menuCardBaseWidth))
+        let item = try #require(menu.items.first)
+        #expect(item.title.hasPrefix(L("Storage")))
+        #expect(item.title == item.attributedTitle?.string)
+        #expect(item.view == nil)
+        #expect(item.isEnabled)
+        #expect(item.submenu != nil)
+    }
+
+    @Test
+    func `open parent menu defers data rebuild until parent tracking ends`() async throws {
+        let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = true
+        defer {
+            StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering
+        }
+
+        let settings = Self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .claude
+        settings.costUsageEnabled = true
+        Self.enableOnlyClaude(settings)
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        Self.seedClaudeSnapshots(in: store)
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system)
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.menuRefreshEnabledOverrideForTesting = false
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        let parentKey = ObjectIdentifier(menu)
+        controller.openMenus[parentKey] = menu
+        controller.menuVersions[parentKey] = controller.menuContentVersion
+
+        let costItem = try #require(menu.items.first { ($0.representedObject as? String) == "menuCardCost" })
+        #expect(costItem.view == nil)
+        #expect(costItem.title == StatusItemController.costMenuTitle)
+        #expect(costItem.isEnabled)
+        let submenu = try #require(costItem.submenu)
+        #expect(submenu.items.first?.representedObject as? String == StatusItemController.costHistoryChartID)
+        #expect(submenu.minimumWidth >= StatusItemController.menuCardBaseWidth)
+        #expect(submenu.items.first?.view == nil)
+
+        controller.menuRefreshEnabledOverrideForTesting = true
+        controller.menuWillOpen(submenu)
+        let submenuKey = ObjectIdentifier(submenu)
+        #expect(controller.openMenus[submenuKey] === submenu)
+        #expect(submenu.items.first?.view != nil)
+
+        let oldParentVersion = try #require(controller.menuVersions[parentKey])
+        controller.invalidateMenus(
+            refreshOpenMenus: true,
+            deferOpenParentMenuRebuild: true)
+        #expect(controller.menuVersions[parentKey] == oldParentVersion)
+        controller.invalidateMenus(
+            refreshOpenMenus: true,
+            deferOpenParentMenuRebuild: true)
+        #expect(controller.menuVersions[parentKey] == oldParentVersion)
+
+        controller.menuDidClose(submenu)
+        #expect(controller.openMenus[submenuKey] == nil)
+
+        for _ in 0..<40 where controller.menuVersions[parentKey] != oldParentVersion {
+            await Task.yield()
+        }
+        #expect(controller.menuVersions[parentKey] == oldParentVersion)
+
+        controller.menuDidClose(menu)
+        for _ in 0..<40 where controller.menuVersions[parentKey] != controller.menuContentVersion {
+            await Task.yield()
+        }
+        if controller.menuVersions[parentKey] != controller.menuContentVersion {
+            controller.menuWillOpen(menu)
+        }
+        for _ in 0..<40 where controller.menuVersions[parentKey] != controller.menuContentVersion {
+            await Task.yield()
+        }
+        #expect(controller.menuVersions[parentKey] == controller.menuContentVersion)
+    }
+
+    @Test
+    func `open hosted submenu rebuilds from unavailable placeholder when data arrives`() async {
+        let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = true
+        defer {
+            StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering
+        }
+
+        let settings = Self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .claude
+        settings.costUsageEnabled = true
+        Self.enableOnlyClaude(settings)
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system)
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        let submenu = controller.makeHostedSubviewPlaceholderMenu(
+            chartID: StatusItemController.costHistoryChartID,
+            provider: .claude,
+            width: StatusItemController.menuCardBaseWidth)
+        controller.menuWillOpen(submenu)
+        let submenuKey = ObjectIdentifier(submenu)
+        #expect(controller.openMenus[submenuKey] === submenu)
+        #expect(submenu.items.first?.representedObject as? String == StatusItemController.costHistoryChartID)
+        #expect(submenu.items.first?.view == nil)
+        #expect(submenu.items.first?.title == "No data available")
+
+        let openedVersion = controller.menuContentVersion
+        store._setTokenSnapshotForTesting(Self.makeTokenSnapshot(), provider: .claude)
+        controller.invalidateMenus(refreshOpenMenus: true)
+
+        for _ in 0..<40 {
+            if controller.menuContentVersion != openedVersion,
+               submenu.items.first?.view != nil
+            {
+                break
+            }
+            await Task.yield()
+        }
+
+        #expect(controller.menuContentVersion != openedVersion)
+        #expect(submenu.items.first?.representedObject as? String == StatusItemController.costHistoryChartID)
+        #expect(submenu.items.first?.view != nil)
+        #expect(submenu.items.first?.title != "No data available")
+    }
+
+    @Test
+    func `open hydrated provider submenu preserves identity across refresh`() throws {
+        try self.assertHostedSubmenuPreservesIdentity(
+            chartID: StatusItemController.costHistoryChartID,
+            provider: .claude,
+            seed: Self.seedClaudeSnapshots)
+        try self.assertHostedSubmenuPreservesIdentity(
+            chartID: StatusItemController.costHistoryChartID,
+            provider: .openai,
+            seed: Self.seedOpenAICostSnapshot)
+        try self.assertHostedSubmenuPreservesIdentity(
+            chartID: StatusItemController.usageHistoryChartID,
+            provider: .claude,
+            seed: Self.seedPlanUtilizationHistory)
+        try self.assertHostedSubmenuPreservesIdentity(
+            chartID: StatusItemController.storageBreakdownID,
+            provider: .claude,
+            seed: Self.seedStorageFootprint)
+        try self.assertHostedSubmenuPreservesIdentity(
+            chartID: StatusItemController.zaiHourlyUsageChartID,
+            provider: .zai,
+            seed: Self.seedZaiHourlyUsage)
+    }
+
+    @Test
+    func `hosted chart items size to the displayed view without a throwaway controller`() throws {
+        try self.assertHostedChartItemHeightMatchesRefresh(
+            chartID: StatusItemController.costHistoryChartID,
+            provider: .claude,
+            seed: Self.seedClaudeSnapshots)
+        { controller, submenu, width in
+            controller.appendCostHistoryChartItem(to: submenu, provider: .claude, width: width)
+        }
+        try self.assertHostedChartItemHeightMatchesRefresh(
+            chartID: StatusItemController.usageHistoryChartID,
+            provider: .claude,
+            seed: Self.seedPlanUtilizationHistory)
+        { controller, submenu, width in
+            controller.appendUsageHistoryChartItem(to: submenu, provider: .claude, width: width)
+        }
+        try self.assertHostedChartItemHeightMatchesRefresh(
+            chartID: StatusItemController.storageBreakdownID,
+            provider: .claude,
+            seed: Self.seedStorageFootprint)
+        { controller, submenu, width in
+            controller.appendStorageBreakdownItem(to: submenu, provider: .claude, width: width)
+        }
+    }
+
+    @Test
+    func `zai chart render signature follows time range boundaries`() throws {
+        let formatter = DateFormatter()
+        formatter.dateFormat = "yyyy-MM-dd HH:mm"
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        let beforeMidnight = try #require(formatter.date(from: "2026-01-01 23:30"))
+        let afterMidnight = try #require(formatter.date(from: "2026-01-02 00:30"))
+        let modelUsage = ZaiModelUsageData(
+            xTime: ["2026-01-01 23:00"],
+            modelDataList: [
+                ZaiModelDataItem(modelName: "glm-4.5", tokensUsage: [100]),
+            ])
+
+        let before = StatusItemController.zaiHourlyUsageRenderSignature(
+            modelUsage: modelUsage,
+            now: beforeMidnight)
+        let after = StatusItemController.zaiHourlyUsageRenderSignature(
+            modelUsage: modelUsage,
+            now: afterMidnight)
+
+        #expect(before != after)
+    }
+
+    @Test
+    func `utilization chart invalidates when active account changes`() throws {
+        let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = true
+        defer { StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering }
+
+        let settings = Self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        Self.enableOnlyClaude(settings)
+        settings.addTokenAccount(provider: .claude, label: "Alice", token: "alice-token")
+        settings.addTokenAccount(provider: .claude, label: "Bob", token: "bob-token")
+        let accounts = settings.tokenAccounts(for: .claude)
+        let alice = try #require(accounts.first)
+        let bob = try #require(accounts.last)
+        let aliceKey = try #require(
+            UsageStore._planUtilizationTokenAccountKeyForTesting(provider: .claude, account: alice))
+        let bobKey = try #require(
+            UsageStore._planUtilizationTokenAccountKeyForTesting(provider: .claude, account: bob))
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        Self.seedClaudeSnapshots(in: store)
+        store.planUtilizationHistory[.claude] = PlanUtilizationHistoryBuckets(accounts: [
+            aliceKey: [Self.makePlanHistory(usedPercent: 20)],
+            bobKey: [Self.makePlanHistory(usedPercent: 50)],
+        ])
+        settings.setActiveTokenAccountIndex(0, for: .claude)
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let submenu = controller.makeHostedSubviewPlaceholderMenu(
+            chartID: StatusItemController.usageHistoryChartID,
+            provider: .claude,
+            width: StatusItemController.menuCardBaseWidth)
+        controller.menuWillOpen(submenu)
+        let aliceView = try #require(submenu.items.first?.view)
+
+        settings.setActiveTokenAccountIndex(1, for: .claude)
+        controller.refreshHostedSubviewMenu(submenu)
+
+        let bobView = try #require(submenu.items.first?.view)
+        #expect(bobView !== aliceView)
+    }
+
+    private func assertHostedChartItemHeightMatchesRefresh(
+        chartID: String,
+        provider: UsageProvider,
+        seed: (UsageStore) -> Void,
+        append: (StatusItemController, NSMenu, CGFloat) -> Bool) throws
+    {
+        let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = true
+        defer { StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering }
+
+        let settings = Self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.costUsageEnabled = true
+        settings.providerStorageFootprintsEnabled = true
+        Self.enableOnly(settings, provider: provider)
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        seed(store)
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let width = StatusItemController.menuCardBaseWidth
+        let submenu = NSMenu()
+        submenu.minimumWidth = width
+        #expect(append(controller, submenu, width))
+
+        let item = try #require(submenu.items.first)
+        let view = try #require(item.view)
+        let heightFromAppend = view.frame.height
+        // The height the append path assigns must match the authoritative re-measure pass; otherwise
+        // dropping the throwaway NSHostingController would have changed sizing behavior.
+        controller.refreshHostedSubviewHeights(in: submenu)
+        #expect(view.frame.height == heightFromAppend)
+        #expect(heightFromAppend > 1)
+    }
+
+    private func assertHostedSubmenuPreservesIdentity(
+        chartID: String,
+        provider: UsageProvider,
+        seed: (UsageStore) -> Void) throws
+    {
+        let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = true
+        defer {
+            StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering
+        }
+
+        let settings = Self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = provider
+        settings.costUsageEnabled = true
+        settings.providerStorageFootprintsEnabled = true
+        Self.enableOnly(settings, provider: provider)
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        seed(store)
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system)
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        let submenu = controller.makeHostedSubviewPlaceholderMenu(
+            chartID: chartID,
+            provider: provider,
+            width: StatusItemController.menuCardBaseWidth)
+        controller.menuWillOpen(submenu)
+
+        let hydratedItem = try #require(submenu.items.first)
+        #expect(hydratedItem.representedObject as? String == chartID)
+        #expect(hydratedItem.toolTip == provider.rawValue)
+        #expect(hydratedItem.view != nil)
+        #expect(hydratedItem.title != "No data available")
+        let hydratedView = hydratedItem.view
+        let inflatedHeight = hydratedView.map { view -> CGFloat in
+            let inflatedHeight = view.frame.height + 100
+            if chartID == StatusItemController.zaiHourlyUsageChartID {
+                view.frame.size.height = inflatedHeight
+            }
+            return inflatedHeight
+        }
+
+        controller.refreshHostedSubviewMenu(submenu)
+
+        let refreshedItem = try #require(submenu.items.first)
+        #expect(refreshedItem.representedObject as? String == chartID)
+        #expect(refreshedItem.toolTip == provider.rawValue)
+        #expect(refreshedItem.view != nil)
+        #expect(refreshedItem.title != "No data available")
+        #expect(refreshedItem.view === hydratedView)
+        if chartID == StatusItemController.zaiHourlyUsageChartID {
+            #expect(refreshedItem.view?.frame.height != inflatedHeight)
+        }
+
+        if chartID == StatusItemController.costHistoryChartID, provider == .claude {
+            store._setTokenSnapshotForTesting(Self.makeTokenSnapshot(dailyCost: 2.34), provider: .claude)
+            controller.refreshHostedSubviewMenu(submenu)
+
+            let changedItem = try #require(submenu.items.first)
+            #expect(changedItem.view != nil)
+            #expect(changedItem.view !== hydratedView)
+        }
+    }
+
+    private static func makeSettings() -> SettingsStore {
+        let suite = "StatusMenuHostedSubmenuRefreshTests-\(UUID().uuidString)"
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        return SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+    }
+
+    private static func enableOnlyClaude(_ settings: SettingsStore) {
+        self.enableOnly(settings, provider: .claude)
+    }
+
+    private static func enableOnly(_ settings: SettingsStore, provider enabledProvider: UsageProvider) {
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: provider == enabledProvider)
+        }
+    }
+
+    private static func seedClaudeSnapshots(in store: UsageStore) {
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .claude,
+                accountEmail: "user@example.com",
+                accountOrganization: nil,
+                loginMethod: "Team"))
+        store._setSnapshotForTesting(snapshot, provider: .claude)
+        store._setTokenSnapshotForTesting(Self.makeTokenSnapshot(), provider: .claude)
+    }
+
+    private static func seedOpenAICostSnapshot(in store: UsageStore) {
+        let day = Date(timeIntervalSince1970: 1_700_000_000)
+        let apiUsage = OpenAIAPIUsageSnapshot(
+            daily: [
+                OpenAIAPIUsageSnapshot.DailyBucket(
+                    day: "2025-12-23",
+                    startTime: day,
+                    endTime: day.addingTimeInterval(86400),
+                    costUSD: 1.23,
+                    requests: 12,
+                    inputTokens: 100,
+                    cachedInputTokens: 20,
+                    outputTokens: 40,
+                    totalTokens: 160,
+                    lineItems: [],
+                    models: []),
+            ],
+            updatedAt: Date(timeIntervalSince1970: 1_700_086_400))
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            tertiary: nil,
+            openAIAPIUsage: apiUsage,
+            updatedAt: Date(timeIntervalSince1970: 1_700_086_400),
+            identity: ProviderIdentitySnapshot(
+                providerID: .openai,
+                accountEmail: "openai@example.com",
+                accountOrganization: nil,
+                loginMethod: "API"))
+        store._setSnapshotForTesting(snapshot, provider: .openai)
+    }
+
+    private static func seedPlanUtilizationHistory(in store: UsageStore) {
+        self.seedClaudeSnapshots(in: store)
+        store.planUtilizationHistory[.claude] = PlanUtilizationHistoryBuckets(
+            unscoped: [
+                self.makePlanHistory(usedPercent: 24),
+            ])
+    }
+
+    private static func makePlanHistory(usedPercent: Double) -> PlanUtilizationSeriesHistory {
+        PlanUtilizationSeriesHistory(
+            name: .session,
+            windowMinutes: 300,
+            entries: [
+                PlanUtilizationHistoryEntry(
+                    capturedAt: Date(timeIntervalSince1970: 1_700_000_000),
+                    usedPercent: usedPercent,
+                    resetsAt: Date(timeIntervalSince1970: 1_700_018_000)),
+            ])
+    }
+
+    private static func seedStorageFootprint(in store: UsageStore) {
+        let root = "/Users/test/.claude"
+        store.providerStorageFootprints[.claude] = ProviderStorageFootprint(
+            provider: .claude,
+            totalBytes: 1024,
+            paths: [root],
+            missingPaths: [],
+            unreadablePaths: [],
+            components: [.init(path: "\(root)/projects", totalBytes: 1024)],
+            updatedAt: Date(timeIntervalSince1970: 1_700_000_000))
+    }
+
+    private static func seedZaiHourlyUsage(in store: UsageStore) {
+        let modelUsage = ZaiModelUsageData(
+            xTime: ["2026-05-26 00:00"],
+            modelDataList: [
+                ZaiModelDataItem(modelName: "glm-4.5", tokensUsage: [512]),
+            ])
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            tertiary: nil,
+            zaiUsage: ZaiUsageSnapshot(
+                tokenLimit: nil,
+                timeLimit: nil,
+                planName: "Pro",
+                modelUsage: modelUsage,
+                updatedAt: Date(timeIntervalSince1970: 1_700_000_000)),
+            updatedAt: Date(timeIntervalSince1970: 1_700_000_000),
+            identity: ProviderIdentitySnapshot(
+                providerID: .zai,
+                accountEmail: "zai@example.com",
+                accountOrganization: nil,
+                loginMethod: "OAuth"))
+        store._setSnapshotForTesting(snapshot, provider: .zai)
+    }
+
+    private static func makeTokenSnapshot(dailyCost: Double = 1.23) -> CostUsageTokenSnapshot {
+        CostUsageTokenSnapshot(
+            sessionTokens: 123,
+            sessionCostUSD: 0.12,
+            last30DaysTokens: 123,
+            last30DaysCostUSD: dailyCost,
+            daily: [
+                CostUsageDailyReport.Entry(
+                    date: "2025-12-23",
+                    inputTokens: nil,
+                    outputTokens: nil,
+                    totalTokens: 123,
+                    costUSD: dailyCost,
+                    modelsUsed: nil,
+                    modelBreakdowns: nil),
+            ],
+            updatedAt: Date())
+    }
+}
diff --git a/Tests/CodexBarTests/StatusMenuInstantOpenTests.swift b/Tests/CodexBarTests/StatusMenuInstantOpenTests.swift
new file mode 100644
index 0000000000..cc308f0e2a
--- /dev/null
+++ b/Tests/CodexBarTests/StatusMenuInstantOpenTests.swift
@@ -0,0 +1,1594 @@
+import AppKit
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+extension StatusMenuTests {
+    @Test
+    func `opening fresh menu does not schedule deferred refresh`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        self.enableOnlyCodexForInstantOpenTesting(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        var providerRefreshCount = 0
+        var refreshInteractions: [ProviderInteraction] = []
+        store._test_providerRefreshOverride = { provider in
+            guard provider == .codex else { return }
+            refreshInteractions.append(ProviderInteractionContext.current)
+            providerRefreshCount += 1
+        }
+        defer { store._test_providerRefreshOverride = nil }
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        StatusItemController.setClosedMenuPreparationDelayForTesting(.zero)
+        defer { StatusItemController.resetClosedMenuPreparationDelayForTesting() }
+
+        controller.menuRefreshEnabledOverrideForTesting = true
+        StatusItemController.setDeferredMenuInteractionRefreshDelayForTesting(.zero)
+        defer { StatusItemController.resetDeferredMenuInteractionRefreshDelayForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+
+        for _ in 0..<20 {
+            await Task.yield()
+        }
+        #expect(providerRefreshCount == 0)
+        #expect(!controller.deferredMenuInteractionRefreshPending)
+
+        controller.menuDidClose(menu)
+        for _ in 0..<40 {
+            await Task.yield()
+        }
+
+        #expect(providerRefreshCount == 0)
+        #expect(refreshInteractions.isEmpty)
+    }
+
+    @Test
+    func `delayed open refresh does not rebuild fresh menu after unrelated data invalidation`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        self.enableOnlyCodexForInstantOpenTesting(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        controller.menuRefreshEnabledOverrideForTesting = true
+        StatusItemController.setMenuOpenRefreshDelayForTesting(.milliseconds(50))
+        defer { StatusItemController.resetMenuOpenRefreshDelayForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        defer { controller.menuDidClose(menu) }
+
+        let key = ObjectIdentifier(menu)
+        let openedVersion = controller.menuVersions[key]
+        var rebuildCount = 0
+        controller._test_openMenuRebuildObserver = { _ in
+            rebuildCount += 1
+        }
+        defer { controller._test_openMenuRebuildObserver = nil }
+
+        // Models first-open storage-footprint publication: menu content becomes stale, but no
+        // displayed provider was missing or failed when this menu opened.
+        controller.invalidateMenus(allowStaleContentDuringDataRefresh: true)
+        try? await Task.sleep(for: .milliseconds(150))
+
+        #expect(controller.menuContentVersion != openedVersion)
+        #expect(controller.menuVersions[key] == openedVersion)
+        #expect(rebuildCount == 0)
+    }
+
+    @Test
+    func `menu open with missing data refreshes asynchronously while tracking`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        self.enableOnlyCodexForInstantOpenTesting(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store._setSnapshotForTesting(nil, provider: .codex)
+        var providerRefreshCount = 0
+        var refreshInteractions: [ProviderInteraction] = []
+        store._test_providerRefreshOverride = { provider in
+            guard provider == .codex else { return }
+            refreshInteractions.append(ProviderInteractionContext.current)
+            providerRefreshCount += 1
+            store._setSnapshotForTesting(
+                UsageSnapshot(
+                    primary: RateWindow(
+                        usedPercent: 25,
+                        windowMinutes: 300,
+                        resetsAt: Date().addingTimeInterval(3600),
+                        resetDescription: nil),
+                    secondary: nil,
+                    updatedAt: Date()),
+                provider: .codex)
+        }
+        defer { store._test_providerRefreshOverride = nil }
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        StatusItemController.setClosedMenuPreparationDelayForTesting(.zero)
+        defer { StatusItemController.resetClosedMenuPreparationDelayForTesting() }
+
+        controller.menuRefreshEnabledOverrideForTesting = true
+        StatusItemController.setDeferredMenuInteractionRefreshDelayForTesting(.zero)
+        defer { StatusItemController.resetDeferredMenuInteractionRefreshDelayForTesting() }
+        StatusItemController.setMenuOpenRefreshDelayForTesting(.zero)
+        defer { StatusItemController.resetMenuOpenRefreshDelayForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        #expect(controller.deferredMenuInteractionRefreshPending)
+
+        for _ in 0..<40 where providerRefreshCount == 0 {
+            await Task.yield()
+        }
+
+        #expect(providerRefreshCount == 1)
+        #expect(refreshInteractions == [.background])
+        for _ in 0..<40 where controller.deferredMenuInteractionRefreshPending {
+            await Task.yield()
+        }
+        #expect(!controller.deferredMenuInteractionRefreshPending)
+        controller.menuDidClose(menu)
+        #expect(!controller.deferredMenuInteractionRefreshPending)
+    }
+
+    @Test
+    func `menu open renders cached data immediately after data only invalidation`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        self.enableOnlyCodexForInstantOpenTesting(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        var providerRefreshCount = 0
+        store._test_providerRefreshOverride = { provider in
+            guard provider == .codex else { return }
+            providerRefreshCount += 1
+        }
+        defer { store._test_providerRefreshOverride = nil }
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        controller.menuRefreshEnabledOverrideForTesting = true
+        let menu = controller.makeMenu()
+        controller.mergedMenu = menu
+        controller.statusItem.menu = menu
+
+        controller.populateMenu(menu, provider: nil)
+        controller.markMenuFresh(menu)
+        let key = ObjectIdentifier(menu)
+        let cachedItemCount = menu.items.count
+        let cachedVersion = controller.menuVersions[key]
+        controller.lastMenuAdjunctReadinessSignature = "stale-baseline"
+
+        controller.invalidateMenus(allowStaleContentDuringDataRefresh: true)
+        let dataOnlyVersion = controller.menuContentVersion
+        var asyncRebuilds = 0
+        controller._test_openMenuRebuildObserver = { _ in
+            asyncRebuilds += 1
+        }
+        defer { controller._test_openMenuRebuildObserver = nil }
+
+        controller.menuWillOpen(menu)
+
+        #expect(cachedVersion != dataOnlyVersion)
+        #expect(menu.items.count == cachedItemCount)
+        #expect(controller.menuVersions[key] == cachedVersion)
+        #expect(asyncRebuilds == 0)
+        #expect(!controller.deferredMenuInteractionRefreshPending)
+
+        for _ in 0..<40 where asyncRebuilds == 0 {
+            await Task.yield()
+        }
+
+        #expect(asyncRebuilds == 1)
+        #expect(controller.menuVersions[key] == controller.menuContentVersion)
+        #expect(!controller.didMenuAdjunctReadinessChange())
+        controller.menuDidClose(menu)
+        for _ in 0..<40 {
+            await Task.yield()
+        }
+        #expect(providerRefreshCount == 0)
+    }
+
+    @Test
+    func `closing before cached menu rebuild keeps next open stale`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        self.enableOnlyCodexForInstantOpenTesting(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        let menu = controller.makeMenu()
+        controller.mergedMenu = menu
+        controller.statusItem.menu = menu
+        controller.populateMenu(menu, provider: nil)
+        controller.markMenuFresh(menu)
+        let key = ObjectIdentifier(menu)
+        let cachedVersion = controller.menuVersions[key]
+        controller.invalidateMenus(allowStaleContentDuringDataRefresh: true)
+
+        var rebuildGateEntries = 0
+        var rebuildGate: CheckedContinuation<Void, Never>?
+        controller._test_openMenuRefreshYieldOverride = {
+            rebuildGateEntries += 1
+            await withCheckedContinuation { continuation in
+                rebuildGate = continuation
+            }
+        }
+        defer {
+            rebuildGate?.resume()
+            controller._test_openMenuRefreshYieldOverride = nil
+        }
+
+        controller.menuWillOpen(menu)
+        for _ in 0..<40 where rebuildGateEntries == 0 {
+            await Task.yield()
+        }
+
+        #expect(rebuildGateEntries == 1)
+        #expect(controller.menuVersions[key] == cachedVersion)
+        controller.menuDidClose(menu)
+        #expect(controller.menuNeedsRefresh(menu))
+
+        rebuildGate?.resume()
+        rebuildGate = nil
+        controller._test_openMenuRefreshYieldOverride = nil
+        for _ in 0..<20 {
+            await Task.yield()
+        }
+
+        controller.menuWillOpen(menu)
+        for _ in 0..<40 where controller.menuNeedsRefresh(menu) {
+            await Task.yield()
+        }
+
+        #expect(!controller.menuNeedsRefresh(menu))
+        controller.menuDidClose(menu)
+    }
+
+    @Test
+    func `menu open rebuilds synchronously after provider identity changes`() {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        self.enableOnlyCodexForInstantOpenTesting(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store._setSnapshotForTesting(
+            self.instantOpenSnapshot(email: "old@example.com"),
+            provider: .codex)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        let menu = controller.makeMenu()
+        controller.mergedMenu = menu
+        controller.statusItem.menu = menu
+        controller.populateMenu(menu, provider: nil)
+        controller.markMenuFresh(menu)
+        let cachedVersion = controller.menuVersions[ObjectIdentifier(menu)]
+
+        store._setSnapshotForTesting(
+            self.instantOpenSnapshot(email: "new@example.com"),
+            provider: .codex)
+        controller.invalidateMenus(allowStaleContentDuringDataRefresh: true)
+        controller.menuWillOpen(menu)
+        defer { controller.menuDidClose(menu) }
+
+        #expect(controller.menuVersions[ObjectIdentifier(menu)] != cachedVersion)
+        #expect(controller.menuVersions[ObjectIdentifier(menu)] == controller.menuContentVersion)
+    }
+
+    @Test
+    func `overview menu rebuilds synchronously after secondary provider identity changes`() {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.mergedMenuLastSelectedWasOverview = true
+        self.enableProvidersForInstantOpenTesting([.codex, .claude], settings: settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store._setSnapshotForTesting(
+            self.instantOpenSnapshot(email: "codex@example.com"),
+            provider: .codex)
+        store._setSnapshotForTesting(
+            self.instantOpenSnapshot(email: "old@example.com", provider: .claude),
+            provider: .claude)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.menuRefreshEnabledOverrideForTesting = true
+        controller.selectedMenuProvider = .codex
+
+        let menu = controller.makeMenu()
+        controller.mergedMenu = menu
+        controller.statusItem.menu = menu
+        controller.populateMenu(menu, provider: nil)
+        controller.markMenuFresh(menu)
+        let cachedVersion = controller.menuVersions[ObjectIdentifier(menu)]
+
+        store._setSnapshotForTesting(
+            self.instantOpenSnapshot(email: "new@example.com", provider: .claude),
+            provider: .claude)
+        controller.invalidateMenus(allowStaleContentDuringDataRefresh: true)
+        controller.menuWillOpen(menu)
+        defer { controller.menuDidClose(menu) }
+
+        #expect(controller.menuVersions[ObjectIdentifier(menu)] != cachedVersion)
+        #expect(controller.menuVersions[ObjectIdentifier(menu)] == controller.menuContentVersion)
+    }
+
+    @Test
+    func `stacked Codex menu rebuilds synchronously after secondary account identity changes`() {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.multiAccountMenuLayout = .stacked
+        self.enableOnlyCodexForInstantOpenTesting(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store._setSnapshotForTesting(
+            self.instantOpenSnapshot(email: "selected@example.com"),
+            provider: .codex)
+        let selectedAccount = CodexVisibleAccount(
+            id: "selected",
+            email: "selected@example.com",
+            workspaceLabel: nil,
+            workspaceAccountID: nil,
+            authFingerprint: nil,
+            storedAccountID: nil,
+            selectionSource: .liveSystem,
+            isActive: true,
+            isLive: true,
+            canReauthenticate: false,
+            canRemove: false)
+        let secondaryAccount = CodexVisibleAccount(
+            id: "secondary",
+            email: "secondary@example.com",
+            workspaceLabel: nil,
+            workspaceAccountID: nil,
+            authFingerprint: nil,
+            storedAccountID: nil,
+            selectionSource: .liveSystem,
+            isActive: false,
+            isLive: false,
+            canReauthenticate: false,
+            canRemove: false)
+        store.codexAccountSnapshots = [
+            CodexAccountUsageSnapshot(
+                account: selectedAccount,
+                snapshot: self.instantOpenSnapshot(email: "selected@example.com"),
+                error: nil,
+                sourceLabel: "test"),
+            CodexAccountUsageSnapshot(
+                account: secondaryAccount,
+                snapshot: self.instantOpenSnapshot(email: "old@example.com"),
+                error: nil,
+                sourceLabel: "test"),
+        ]
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        let menu = controller.makeMenu()
+        controller.mergedMenu = menu
+        controller.statusItem.menu = menu
+        controller.populateMenu(menu, provider: nil)
+        controller.markMenuFresh(menu)
+        let cachedVersion = controller.menuVersions[ObjectIdentifier(menu)]
+
+        store.codexAccountSnapshots[1] = CodexAccountUsageSnapshot(
+            account: secondaryAccount,
+            snapshot: self.instantOpenSnapshot(email: "new@example.com"),
+            error: nil,
+            sourceLabel: "test")
+        controller.invalidateMenus(allowStaleContentDuringDataRefresh: true)
+        controller.menuWillOpen(menu)
+        defer { controller.menuDidClose(menu) }
+
+        #expect(controller.menuVersions[ObjectIdentifier(menu)] != cachedVersion)
+        #expect(controller.menuVersions[ObjectIdentifier(menu)] == controller.menuContentVersion)
+    }
+
+    @Test
+    func `cache preserving structural invalidation rebuilds synchronously on open`() {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        self.enableOnlyCodexForInstantOpenTesting(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        let menu = controller.makeMenu()
+        controller.mergedMenu = menu
+        controller.statusItem.menu = menu
+        controller.populateMenu(menu, provider: nil)
+        controller.markMenuFresh(menu)
+        let key = ObjectIdentifier(menu)
+        let cachedVersion = controller.menuVersions[key]
+
+        controller.preservingMergedSwitcherContentCachesDuringInvalidation {
+            controller.invalidateMenus()
+        }
+        #expect(controller.menuVersions[key] == cachedVersion)
+        #expect(controller.menuContentVersion != controller.latestDataOnlyMenuContentVersion)
+
+        controller.menuWillOpen(menu)
+        defer { controller.menuDidClose(menu) }
+
+        #expect(controller.menuVersions[key] == controller.menuContentVersion)
+        #expect(controller.openMenuRebuildTasks[key] == nil)
+    }
+
+    @Test
+    func `data invalidation after cache preserving structural invalidation still rebuilds synchronously`() {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        self.enableOnlyCodexForInstantOpenTesting(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        let menu = controller.makeMenu()
+        controller.mergedMenu = menu
+        controller.statusItem.menu = menu
+        controller.populateMenu(menu, provider: nil)
+        controller.markMenuFresh(menu)
+        let key = ObjectIdentifier(menu)
+        let cachedVersion = controller.menuVersions[key]
+
+        controller.preservingMergedSwitcherContentCachesDuringInvalidation {
+            controller.invalidateMenus()
+        }
+        let structuralVersion = controller.menuContentVersion
+        controller.invalidateMenus(allowStaleContentDuringDataRefresh: true)
+
+        #expect(controller.menuVersions[key] == cachedVersion)
+        #expect(controller.latestStructuralMenuContentVersion == structuralVersion)
+        #expect(controller.menuContentVersion == controller.latestDataOnlyMenuContentVersion)
+
+        controller.menuWillOpen(menu)
+        defer { controller.menuDidClose(menu) }
+
+        #expect(controller.menuVersions[key] == controller.menuContentVersion)
+        #expect(controller.openMenuRebuildTasks[key] == nil)
+    }
+
+    @Test
+    func `menu open does not overlap provider specific refresh`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        self.enableOnlyCodexForInstantOpenTesting(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store._setSnapshotForTesting(nil, provider: .codex)
+        let refreshGate = BlockingInstantOpenProviderRefresh()
+        store._test_providerRefreshOverride = { provider in
+            guard provider == .codex else { return }
+            await refreshGate.run()
+            store._setSnapshotForTesting(
+                UsageSnapshot(
+                    primary: RateWindow(
+                        usedPercent: 25,
+                        windowMinutes: 300,
+                        resetsAt: Date().addingTimeInterval(3600),
+                        resetDescription: nil),
+                    secondary: nil,
+                    updatedAt: Date()),
+                provider: .codex)
+        }
+        defer { store._test_providerRefreshOverride = nil }
+        let existingRefreshTask = Task {
+            await store.refreshProvider(.codex)
+        }
+        await refreshGate.waitUntilStarted(count: 1)
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.menuRefreshEnabledOverrideForTesting = true
+        StatusItemController.setMenuOpenRefreshDelayForTesting(.zero)
+        defer { StatusItemController.resetMenuOpenRefreshDelayForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        defer { controller.menuDidClose(menu) }
+        for _ in 0..<40 {
+            await Task.yield()
+        }
+
+        #expect(await refreshGate.startCount == 1)
+        #expect(store.refreshingProviders.contains(.codex))
+        await refreshGate.releaseFirst()
+        await existingRefreshTask.value
+        for _ in 0..<40 where controller.deferredMenuInteractionRefreshPending {
+            await Task.yield()
+        }
+        #expect(!store.isRefreshing)
+        #expect(!controller.deferredMenuInteractionRefreshPending)
+    }
+
+    @Test
+    func `cached menu rebuilds after active provider refresh completes`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        self.enableOnlyCodexForInstantOpenTesting(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store._setSnapshotForTesting(nil, provider: .codex)
+        let refreshGate = BlockingInstantOpenProviderRefresh()
+        store._test_providerRefreshOverride = { provider in
+            guard provider == .codex else { return }
+            await refreshGate.run()
+        }
+        defer { store._test_providerRefreshOverride = nil }
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.menuRefreshEnabledOverrideForTesting = true
+        StatusItemController.setMenuOpenRefreshDelayForTesting(.zero)
+        defer { StatusItemController.resetMenuOpenRefreshDelayForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.mergedMenu = menu
+        controller.statusItem.menu = menu
+        controller.populateMenu(menu, provider: nil)
+        controller.markMenuFresh(menu)
+        controller.invalidateMenus(allowStaleContentDuringDataRefresh: true)
+
+        let existingRefreshTask = Task {
+            await store.refreshProvider(.codex)
+        }
+        await refreshGate.waitUntilStarted(count: 1)
+        controller.menuWillOpen(menu)
+        defer { controller.menuDidClose(menu) }
+        #expect(controller.menuNeedsRefresh(menu))
+
+        await refreshGate.releaseFirst()
+        await existingRefreshTask.value
+        for _ in 0..<80 where controller.menuNeedsRefresh(menu) {
+            await Task.yield()
+        }
+
+        #expect(await refreshGate.startCount == 1)
+        #expect(!controller.menuNeedsRefresh(menu))
+    }
+
+    @Test
+    func `menu rebuilds after displayed provider completes while another provider refreshes`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        self.enableProvidersForInstantOpenTesting([.claude, .codex], settings: settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store._setSnapshotForTesting(
+            self.instantOpenSnapshot(email: "old@example.com"),
+            provider: .codex)
+        store.refreshingProviders = [.claude]
+        defer { store.refreshingProviders = [] }
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.menuRefreshEnabledOverrideForTesting = true
+        StatusItemController.setMenuOpenRefreshDelayForTesting(.zero)
+        defer { StatusItemController.resetMenuOpenRefreshDelayForTesting() }
+
+        let menu = controller.makeMenu(for: .codex)
+        controller.populateMenu(menu, provider: .codex)
+        controller.markMenuFresh(menu)
+        store._setSnapshotForTesting(
+            self.instantOpenSnapshot(email: "new@example.com"),
+            provider: .codex)
+        controller.invalidateMenus(allowStaleContentDuringDataRefresh: true)
+
+        controller.menuWillOpen(menu)
+        defer { controller.menuDidClose(menu) }
+        for _ in 0..<80 where controller.menuNeedsRefresh(menu) {
+            await Task.yield()
+        }
+
+        #expect(!controller.menuNeedsRefresh(menu))
+    }
+
+    @Test
+    func `user refresh supersedes background provider refresh`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        self.enableOnlyCodexForInstantOpenTesting(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let refreshGate = BlockingInstantOpenProviderRefresh()
+        var refreshInteractions: [ProviderInteraction] = []
+        store._test_providerRefreshOverride = { provider in
+            guard provider == .codex else { return }
+            refreshInteractions.append(ProviderInteractionContext.current)
+            await refreshGate.run()
+        }
+        defer { store._test_providerRefreshOverride = nil }
+
+        let backgroundRefreshTask = Task {
+            await ProviderInteractionContext.$current.withValue(.background) {
+                await store.refreshProvider(.codex, coalesceIfRefreshing: true)
+            }
+        }
+        await refreshGate.waitUntilStarted(count: 1)
+
+        let userRefreshTask = Task {
+            await ProviderInteractionContext.$current.withValue(.userInitiated) {
+                await store.refresh()
+            }
+        }
+        for _ in 0..<40 {
+            await Task.yield()
+        }
+        #expect(await refreshGate.startCount == 1)
+
+        await refreshGate.releaseFirst()
+        await refreshGate.waitUntilStarted(count: 2)
+        await userRefreshTask.value
+        await backgroundRefreshTask.value
+        #expect(await refreshGate.startCount == 2)
+        #expect(refreshInteractions == [.background, .userInitiated])
+    }
+
+    @Test
+    func `settings refresh supersedes background provider refresh without becoming user initiated`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        self.enableOnlyCodexForInstantOpenTesting(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let refreshGate = BlockingInstantOpenProviderRefresh()
+        var refreshInteractions: [ProviderInteraction] = []
+        store._test_providerRefreshOverride = { provider in
+            guard provider == .codex else { return }
+            refreshInteractions.append(ProviderInteractionContext.current)
+            await refreshGate.run()
+        }
+        defer { store._test_providerRefreshOverride = nil }
+
+        let backgroundRefreshTask = Task {
+            await store.refreshProvider(.codex, coalesceIfRefreshing: true)
+        }
+        await refreshGate.waitUntilStarted(count: 1)
+
+        let settingsRefreshTask = Task {
+            await store.refreshForSettingsChange()
+        }
+        for _ in 0..<40 {
+            await Task.yield()
+        }
+        #expect(await refreshGate.startCount == 1)
+
+        await refreshGate.releaseFirst()
+        await refreshGate.waitUntilStarted(count: 2)
+        await settingsRefreshTask.value
+        await backgroundRefreshTask.value
+        #expect(await refreshGate.startCount == 2)
+        #expect(refreshInteractions == [.background, .background])
+    }
+
+    @Test
+    func `superseded provider refresh drains before newer result`() async throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        self.enableProvidersForInstantOpenTesting([.claude], settings: settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let refreshes = OrderedInstantOpenProviderRefresh()
+        let baseSpec = try #require(store.providerSpecs[.claude])
+        let baseDescriptor = baseSpec.descriptor
+        let strategy = InstantOpenProviderFetchStrategy {
+            await refreshes.awaitSnapshot()
+        }
+        store.providerSpecs[.claude] = ProviderSpec(
+            style: baseSpec.style,
+            isEnabled: baseSpec.isEnabled,
+            descriptor: ProviderDescriptor(
+                id: .claude,
+                metadata: baseDescriptor.metadata,
+                branding: baseDescriptor.branding,
+                tokenCost: baseDescriptor.tokenCost,
+                fetchPlan: ProviderFetchPlan(
+                    sourceModes: [.auto, .cli, .oauth],
+                    pipeline: ProviderFetchPipeline { _ in [strategy] }),
+                cli: baseDescriptor.cli),
+            makeFetchContext: baseSpec.makeFetchContext)
+
+        let olderTask = Task {
+            await store.refreshProvider(.claude)
+        }
+        await refreshes.waitUntilStarted(count: 1)
+        let newerTask = Task {
+            await store.refreshProvider(.claude)
+        }
+        for _ in 0..<40 {
+            await Task.yield()
+        }
+        #expect(await refreshes.startCount == 1)
+
+        await refreshes.resume(
+            call: 1,
+            snapshot: self.instantOpenSnapshot(
+                email: "old@example.com",
+                provider: .claude,
+                percent: 10))
+        await refreshes.waitUntilStarted(count: 2)
+        await refreshes.resume(
+            call: 2,
+            snapshot: self.instantOpenSnapshot(
+                email: "new@example.com",
+                provider: .claude,
+                percent: 80))
+        await newerTask.value
+        await olderTask.value
+
+        #expect(store.snapshot(for: .claude)?.primary?.usedPercent == 80)
+        #expect(store.snapshot(for: .claude)?.accountEmail(for: .claude) == "new@example.com")
+    }
+
+    @Test
+    func `superseded provider refresh cannot overwrite manually changed token`() async throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        self.enableProvidersForInstantOpenTesting([.stepfun], settings: settings)
+        settings.stepfunToken = "initial-token"
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let refreshes = OrderedInstantOpenProviderMutation()
+        let baseSpec = try #require(store.providerSpecs[.stepfun])
+        let baseDescriptor = baseSpec.descriptor
+        let strategy = InstantOpenProviderMutationFetchStrategy(mutations: refreshes)
+        store.providerSpecs[.stepfun] = ProviderSpec(
+            style: baseSpec.style,
+            isEnabled: baseSpec.isEnabled,
+            descriptor: ProviderDescriptor(
+                id: .stepfun,
+                metadata: baseDescriptor.metadata,
+                branding: baseDescriptor.branding,
+                tokenCost: baseDescriptor.tokenCost,
+                fetchPlan: ProviderFetchPlan(
+                    sourceModes: [.auto, .web],
+                    pipeline: ProviderFetchPipeline { _ in [strategy] }),
+                cli: baseDescriptor.cli),
+            makeFetchContext: baseSpec.makeFetchContext)
+
+        let olderTask = Task {
+            await store.refreshProvider(.stepfun)
+        }
+        await refreshes.waitUntilStarted(count: 1)
+        let newerTask = Task {
+            await store.refreshProvider(.stepfun)
+        }
+        for _ in 0..<40 {
+            await Task.yield()
+        }
+        #expect(await refreshes.startCount == 1)
+
+        settings.stepfunToken = "user-token"
+        await refreshes.resume(call: 1, token: "old-token")
+        await refreshes.waitUntilStarted(count: 2)
+        #expect(settings.stepfunToken == "user-token")
+        await refreshes.resume(call: 2, token: "new-token")
+        await newerTask.value
+        await olderTask.value
+
+        #expect(settings.stepfunToken == "new-token")
+    }
+
+    @Test
+    func `superseded provider refresh preserves rotated token when credential is unchanged`() async throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        self.enableProvidersForInstantOpenTesting([.stepfun], settings: settings)
+        settings.stepfunToken = "initial-token"
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let refreshes = OrderedInstantOpenProviderMutation()
+        let baseSpec = try #require(store.providerSpecs[.stepfun])
+        let baseDescriptor = baseSpec.descriptor
+        let strategy = InstantOpenProviderMutationFetchStrategy(mutations: refreshes)
+        store.providerSpecs[.stepfun] = ProviderSpec(
+            style: baseSpec.style,
+            isEnabled: baseSpec.isEnabled,
+            descriptor: ProviderDescriptor(
+                id: .stepfun,
+                metadata: baseDescriptor.metadata,
+                branding: baseDescriptor.branding,
+                tokenCost: baseDescriptor.tokenCost,
+                fetchPlan: ProviderFetchPlan(
+                    sourceModes: [.auto, .web],
+                    pipeline: ProviderFetchPipeline { _ in [strategy] }),
+                cli: baseDescriptor.cli),
+            makeFetchContext: baseSpec.makeFetchContext)
+
+        let olderTask = Task {
+            await store.refreshProvider(.stepfun)
+        }
+        await refreshes.waitUntilStarted(count: 1)
+        let newerTask = Task {
+            await store.refreshProvider(.stepfun)
+        }
+
+        await refreshes.resume(call: 1, token: "rotated-token")
+        await refreshes.waitUntilStarted(count: 2)
+        #expect(settings.stepfunToken == "rotated-token")
+        await refreshes.resume(call: 2, token: "newer-token")
+        await newerTask.value
+        await olderTask.value
+
+        #expect(settings.stepfunToken == "newer-token")
+    }
+
+    @Test
+    func `canceling provider refresh cancels its owned probe task`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        self.enableOnlyCodexForInstantOpenTesting(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let refreshGate = BlockingInstantOpenProviderRefresh()
+        var refreshWasCancelled = false
+        store._test_providerRefreshOverride = { provider in
+            guard provider == .codex else { return }
+            await refreshGate.run()
+            refreshWasCancelled = Task.isCancelled
+        }
+        defer { store._test_providerRefreshOverride = nil }
+
+        let refreshTask = Task {
+            await store.refreshProvider(.codex)
+        }
+        await refreshGate.waitUntilStarted(count: 1)
+        refreshTask.cancel()
+        await refreshGate.releaseFirst()
+        await refreshTask.value
+
+        #expect(refreshWasCancelled)
+    }
+
+    @Test
+    func `canceling refresh owner keeps shared provider probe alive`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        self.enableOnlyCodexForInstantOpenTesting(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let refreshGate = BlockingInstantOpenProviderRefresh()
+        var refreshWasCancelled = false
+        store._test_providerRefreshOverride = { provider in
+            guard provider == .codex else { return }
+            await refreshGate.run()
+            refreshWasCancelled = Task.isCancelled
+        }
+        defer { store._test_providerRefreshOverride = nil }
+
+        let ownerTask = Task {
+            await store.refreshProvider(.codex)
+        }
+        await refreshGate.waitUntilStarted(count: 1)
+        let sharedWaiterTask = Task {
+            await store.refreshProvider(.codex, coalesceIfRefreshing: true)
+        }
+        for _ in 0..<40 {
+            await Task.yield()
+        }
+
+        ownerTask.cancel()
+        await refreshGate.releaseFirst()
+        await ownerTask.value
+        await sharedWaiterTask.value
+
+        #expect(!refreshWasCancelled)
+        #expect(await refreshGate.startCount == 1)
+    }
+
+    @Test
+    func `background refresh retries canceled provider probe with cached data`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        self.enableOnlyCodexForInstantOpenTesting(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store._setSnapshotForTesting(
+            self.instantOpenSnapshot(email: "cached@example.com"),
+            provider: .codex)
+        let refreshGate = BlockingInstantOpenProviderRefresh()
+        store._test_providerRefreshOverride = { provider in
+            guard provider == .codex else { return }
+            await refreshGate.run()
+        }
+        defer { store._test_providerRefreshOverride = nil }
+
+        let ownerTask = Task {
+            await store.refreshProvider(.codex)
+        }
+        await refreshGate.waitUntilStarted(count: 1)
+        ownerTask.cancel()
+        let backgroundTask = Task {
+            await store.refreshProvider(.codex, coalesceIfRefreshing: true)
+        }
+        for _ in 0..<40 {
+            await Task.yield()
+        }
+        await refreshGate.releaseFirst()
+        await ownerTask.value
+        await backgroundTask.value
+
+        #expect(await refreshGate.startCount == 2)
+    }
+
+    @Test
+    func `menu open refresh only retries the displayed provider`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        self.enableProvidersForInstantOpenTesting([.claude, .codex], settings: settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store._setSnapshotForTesting(nil, provider: .codex)
+        store.refreshingProviders.insert(.claude)
+        defer { store.refreshingProviders.remove(.claude) }
+        var refreshedProviders: [UsageProvider] = []
+        store._test_providerRefreshOverride = { provider in
+            refreshedProviders.append(provider)
+        }
+        defer { store._test_providerRefreshOverride = nil }
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.menuRefreshEnabledOverrideForTesting = true
+        StatusItemController.setMenuOpenRefreshDelayForTesting(.zero)
+        defer { StatusItemController.resetMenuOpenRefreshDelayForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuProviders[ObjectIdentifier(menu)] = .codex
+        controller.menuWillOpen(menu)
+        defer { controller.menuDidClose(menu) }
+        for _ in 0..<40 where refreshedProviders.isEmpty {
+            await Task.yield()
+        }
+
+        #expect(refreshedProviders == [.codex])
+    }
+
+    @Test
+    func `opening fresh split menu preserves another provider deferred retry`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        self.enableProvidersForInstantOpenTesting([.claude, .codex], settings: settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store._setSnapshotForTesting(nil, provider: .codex)
+        store._setSnapshotForTesting(
+            self.instantOpenSnapshot(email: "claude@example.com", provider: .claude),
+            provider: .claude)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.menuRefreshEnabledOverrideForTesting = true
+        StatusItemController.setMenuOpenRefreshDelayForTesting(.seconds(60))
+        StatusItemController.setDeferredMenuInteractionRefreshDelayForTesting(.seconds(60))
+        defer {
+            StatusItemController.resetMenuOpenRefreshDelayForTesting()
+            StatusItemController.resetDeferredMenuInteractionRefreshDelayForTesting()
+        }
+
+        let codexMenu = controller.makeMenu(for: .codex)
+        controller.menuWillOpen(codexMenu)
+        controller.menuDidClose(codexMenu)
+        #expect(controller.deferredMenuInteractionRefreshProviders == [.codex])
+
+        StatusItemController.setMenuOpenRefreshDelayForTesting(.zero)
+        let claudeMenu = controller.makeMenu(for: .claude)
+        controller.menuWillOpen(claudeMenu)
+        defer { controller.menuDidClose(claudeMenu) }
+        for _ in 0..<40 {
+            await Task.yield()
+        }
+
+        #expect(controller.deferredMenuInteractionRefreshProviders == [.codex])
+        #expect(controller.deferredMenuInteractionRefreshPending)
+    }
+
+    @Test
+    func `overview defers only providers that need retry`() {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.mergedMenuLastSelectedWasOverview = true
+        self.enableProvidersForInstantOpenTesting([.claude, .codex], settings: settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store._setSnapshotForTesting(nil, provider: .codex)
+        store._setSnapshotForTesting(
+            self.instantOpenSnapshot(email: "claude@example.com", provider: .claude),
+            provider: .claude)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.menuRefreshEnabledOverrideForTesting = true
+        StatusItemController.setMenuOpenRefreshDelayForTesting(.seconds(60))
+        defer { StatusItemController.resetMenuOpenRefreshDelayForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        defer { controller.menuDidClose(menu) }
+
+        #expect(controller.deferredMenuInteractionRefreshProviders == [.codex])
+    }
+
+    @Test
+    func `closing overview menu stops before refreshing another provider`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.mergedMenuLastSelectedWasOverview = true
+        self.enableProvidersForInstantOpenTesting([.codex, .openai], settings: settings)
+        settings.updateProviderConfig(provider: .openai) { config in
+            config.apiKey = "test-openai-key"
+        }
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store._setSnapshotForTesting(nil, provider: .codex)
+        store._setSnapshotForTesting(nil, provider: .openai)
+        let refreshGate = BlockingInstantOpenProviderRefresh()
+        store._test_providerRefreshOverride = { _ in
+            await refreshGate.run()
+        }
+        defer { store._test_providerRefreshOverride = nil }
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.menuRefreshEnabledOverrideForTesting = true
+        StatusItemController.setMenuOpenRefreshDelayForTesting(.zero)
+        defer { StatusItemController.resetMenuOpenRefreshDelayForTesting() }
+        StatusItemController.setDeferredMenuInteractionRefreshDelayForTesting(.seconds(60))
+        defer { StatusItemController.resetDeferredMenuInteractionRefreshDelayForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        await refreshGate.waitUntilStarted(count: 1)
+        controller.menuDidClose(menu)
+        await refreshGate.releaseFirst()
+        for _ in 0..<80 {
+            await Task.yield()
+        }
+
+        #expect(await refreshGate.startCount == 1)
+        #expect(controller.deferredMenuInteractionRefreshPending)
+    }
+
+    @Test
+    func `closing menu during missing data refresh preserves deferred retry`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        self.enableOnlyCodexForInstantOpenTesting(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store._setSnapshotForTesting(nil, provider: .codex)
+        let refreshGate = BlockingInstantOpenProviderRefresh()
+        var refreshInteractions: [ProviderInteraction] = []
+        store._test_providerRefreshOverride = { provider in
+            guard provider == .codex else { return }
+            refreshInteractions.append(ProviderInteractionContext.current)
+            await refreshGate.run()
+        }
+        defer { store._test_providerRefreshOverride = nil }
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.menuRefreshEnabledOverrideForTesting = true
+        StatusItemController.setDeferredMenuInteractionRefreshDelayForTesting(.zero)
+        defer { StatusItemController.resetDeferredMenuInteractionRefreshDelayForTesting() }
+        StatusItemController.setMenuOpenRefreshDelayForTesting(.zero)
+        defer { StatusItemController.resetMenuOpenRefreshDelayForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        await refreshGate.waitUntilStarted(count: 1)
+        #expect(controller.deferredMenuInteractionRefreshPending)
+        #expect(store.refreshingProviders.contains(.codex))
+
+        let periodicRefreshTask = Task {
+            await store.refresh()
+        }
+        for _ in 0..<40 {
+            await Task.yield()
+        }
+        #expect(await refreshGate.startCount == 1)
+
+        controller.menuDidClose(menu)
+        #expect(controller.deferredMenuInteractionRefreshPending)
+        await refreshGate.releaseFirst()
+        await periodicRefreshTask.value
+        for _ in 0..<40 where store.isRefreshing {
+            await Task.yield()
+        }
+        for _ in 0..<40 {
+            await Task.yield()
+        }
+        #expect(controller.deferredMenuInteractionRefreshPending)
+
+        controller.scheduleDeferredMenuInteractionRefreshIfNeeded(delay: .zero)
+        await refreshGate.waitUntilStarted(count: 2)
+        for _ in 0..<40 where controller.deferredMenuInteractionRefreshPending {
+            await Task.yield()
+        }
+
+        #expect(await refreshGate.startCount == 2)
+        #expect(refreshInteractions == [.background, .background])
+        #expect(!controller.deferredMenuInteractionRefreshPending)
+    }
+
+    @Test
+    func `closing menu during successful missing data refresh clears deferred retry`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        self.enableOnlyCodexForInstantOpenTesting(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store._setSnapshotForTesting(nil, provider: .codex)
+        let refreshGate = BlockingInstantOpenProviderRefresh()
+        store._test_providerRefreshOverride = { provider in
+            guard provider == .codex else { return }
+            await refreshGate.run()
+            store._setSnapshotForTesting(
+                UsageSnapshot(
+                    primary: RateWindow(
+                        usedPercent: 25,
+                        windowMinutes: 300,
+                        resetsAt: Date().addingTimeInterval(3600),
+                        resetDescription: nil),
+                    secondary: nil,
+                    updatedAt: Date()),
+                provider: .codex)
+        }
+        defer { store._test_providerRefreshOverride = nil }
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.menuRefreshEnabledOverrideForTesting = true
+        StatusItemController.setDeferredMenuInteractionRefreshDelayForTesting(.zero)
+        defer { StatusItemController.resetDeferredMenuInteractionRefreshDelayForTesting() }
+        StatusItemController.setMenuOpenRefreshDelayForTesting(.zero)
+        defer { StatusItemController.resetMenuOpenRefreshDelayForTesting() }
+        var deferredRefreshCount = 0
+        controller.onDeferredMenuInteractionRefreshForTesting = {
+            deferredRefreshCount += 1
+        }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        await refreshGate.waitUntilStarted(count: 1)
+        controller.menuDidClose(menu)
+        for _ in 0..<80 {
+            await Task.yield()
+        }
+        #expect(deferredRefreshCount == 0)
+        await refreshGate.releaseFirst()
+
+        for _ in 0..<80 where controller.deferredMenuInteractionRefreshPending {
+            await Task.yield()
+        }
+        for _ in 0..<40 {
+            await Task.yield()
+        }
+
+        #expect(await refreshGate.startCount == 1)
+        #expect(deferredRefreshCount == 0)
+        #expect(!controller.deferredMenuInteractionRefreshPending)
+    }
+
+    private func enableOnlyCodexForInstantOpenTesting(_ settings: SettingsStore) {
+        self.enableProvidersForInstantOpenTesting([.codex], settings: settings)
+    }
+
+    private func instantOpenSnapshot(
+        email: String,
+        provider: UsageProvider = .codex,
+        percent: Double = 25) -> UsageSnapshot
+    {
+        UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: percent,
+                windowMinutes: 300,
+                resetsAt: Date().addingTimeInterval(3600),
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: provider,
+                accountEmail: email,
+                accountOrganization: nil,
+                loginMethod: "ChatGPT"))
+    }
+
+    private func enableProvidersForInstantOpenTesting(
+        _ enabledProviders: Set<UsageProvider>,
+        settings: SettingsStore)
+    {
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            settings.setProviderEnabled(
+                provider: provider,
+                metadata: metadata,
+                enabled: enabledProviders.contains(provider))
+        }
+    }
+}
+
+private struct InstantOpenProviderFetchStrategy: ProviderFetchStrategy {
+    let loader: @Sendable () async -> UsageSnapshot
+
+    var id: String {
+        "instant-open-provider-refresh-test"
+    }
+
+    var kind: ProviderFetchKind {
+        .cli
+    }
+
+    func isAvailable(_: ProviderFetchContext) async -> Bool {
+        true
+    }
+
+    func fetch(_: ProviderFetchContext) async throws -> ProviderFetchResult {
+        let usage = await self.loader()
+        return self.makeResult(usage: usage, sourceLabel: self.id)
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+}
+
+private struct InstantOpenProviderMutationFetchStrategy: ProviderFetchStrategy {
+    let mutations: OrderedInstantOpenProviderMutation
+
+    let id = "instant-open-provider-mutation-test"
+    let kind: ProviderFetchKind = .web
+
+    func isAvailable(_: ProviderFetchContext) async -> Bool {
+        true
+    }
+
+    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
+        let token = await self.mutations.awaitToken()
+        await context.providerManualTokenUpdater?(.stepfun, token)
+        let usage = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 25,
+                windowMinutes: 300,
+                resetsAt: Date().addingTimeInterval(3600),
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())
+        return self.makeResult(usage: usage, sourceLabel: self.id)
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+}
+
+private actor OrderedInstantOpenProviderRefresh {
+    private var started = 0
+    private var startWaiters: [(count: Int, continuation: CheckedContinuation<Void, Never>)] = []
+    private var continuations: [Int: CheckedContinuation<UsageSnapshot, Never>] = [:]
+
+    var startCount: Int {
+        self.started
+    }
+
+    func awaitSnapshot() async -> UsageSnapshot {
+        self.started += 1
+        let call = self.started
+        self.resumeReadyStartWaiters()
+        return await withCheckedContinuation { continuation in
+            self.continuations[call] = continuation
+        }
+    }
+
+    func waitUntilStarted(count: Int) async {
+        if self.started >= count { return }
+        await withCheckedContinuation { continuation in
+            self.startWaiters.append((count: count, continuation: continuation))
+        }
+    }
+
+    func resume(call: Int, snapshot: UsageSnapshot) {
+        self.continuations.removeValue(forKey: call)?.resume(returning: snapshot)
+    }
+
+    private func resumeReadyStartWaiters() {
+        var remaining: [(count: Int, continuation: CheckedContinuation<Void, Never>)] = []
+        for waiter in self.startWaiters {
+            if self.started >= waiter.count {
+                waiter.continuation.resume()
+            } else {
+                remaining.append(waiter)
+            }
+        }
+        self.startWaiters = remaining
+    }
+}
+
+private actor OrderedInstantOpenProviderMutation {
+    private var started = 0
+    private var startWaiters: [(count: Int, continuation: CheckedContinuation<Void, Never>)] = []
+    private var continuations: [Int: CheckedContinuation<String, Never>] = [:]
+
+    var startCount: Int {
+        self.started
+    }
+
+    func awaitToken() async -> String {
+        self.started += 1
+        let call = self.started
+        self.resumeReadyStartWaiters()
+        return await withCheckedContinuation { continuation in
+            self.continuations[call] = continuation
+        }
+    }
+
+    func waitUntilStarted(count: Int) async {
+        if self.started >= count { return }
+        await withCheckedContinuation { continuation in
+            self.startWaiters.append((count: count, continuation: continuation))
+        }
+    }
+
+    func resume(call: Int, token: String) {
+        self.continuations.removeValue(forKey: call)?.resume(returning: token)
+    }
+
+    private func resumeReadyStartWaiters() {
+        var remaining: [(count: Int, continuation: CheckedContinuation<Void, Never>)] = []
+        for waiter in self.startWaiters {
+            if self.started >= waiter.count {
+                waiter.continuation.resume()
+            } else {
+                remaining.append(waiter)
+            }
+        }
+        self.startWaiters = remaining
+    }
+}
+
+private actor BlockingInstantOpenProviderRefresh {
+    private var started = 0
+    private var startWaiters: [(count: Int, continuation: CheckedContinuation<Void, Never>)] = []
+    private var firstReleaseWaiters: [CheckedContinuation<Void, Never>] = []
+    private var firstReleased = false
+
+    var startCount: Int {
+        self.started
+    }
+
+    func run() async {
+        self.started += 1
+        self.resumeReadyStartWaiters()
+        guard self.started == 1, !self.firstReleased else { return }
+        await withCheckedContinuation { continuation in
+            self.firstReleaseWaiters.append(continuation)
+        }
+    }
+
+    func waitUntilStarted(count: Int) async {
+        if self.started >= count { return }
+        await withCheckedContinuation { continuation in
+            self.startWaiters.append((count: count, continuation: continuation))
+        }
+    }
+
+    func releaseFirst() {
+        self.firstReleased = true
+        let waiters = self.firstReleaseWaiters
+        self.firstReleaseWaiters.removeAll()
+        waiters.forEach { $0.resume() }
+    }
+
+    private func resumeReadyStartWaiters() {
+        var remaining: [(count: Int, continuation: CheckedContinuation<Void, Never>)] = []
+        for waiter in self.startWaiters {
+            if self.started >= waiter.count {
+                waiter.continuation.resume()
+            } else {
+                remaining.append(waiter)
+            }
+        }
+        self.startWaiters = remaining
+    }
+}
diff --git a/Tests/CodexBarTests/StatusMenuLocalizationRefreshTests.swift b/Tests/CodexBarTests/StatusMenuLocalizationRefreshTests.swift
new file mode 100644
index 0000000000..ef8c1fc74d
--- /dev/null
+++ b/Tests/CodexBarTests/StatusMenuLocalizationRefreshTests.swift
@@ -0,0 +1,133 @@
+import AppKit
+import CodexBarCore
+import Testing
+@testable import CodexBar
+
+@MainActor
+@Suite(.serialized)
+struct StatusMenuLocalizationRefreshTests {
+    @Test
+    func `open merged menu refreshes localized switcher and cost title when language changes`() async {
+        let previousLanguage = UserDefaults.standard.object(forKey: "appLanguage")
+        let previousAppleLanguages = UserDefaults.standard.object(forKey: "AppleLanguages")
+        defer {
+            if let previousLanguage {
+                UserDefaults.standard.set(previousLanguage, forKey: "appLanguage")
+            } else {
+                UserDefaults.standard.removeObject(forKey: "appLanguage")
+            }
+            if let previousAppleLanguages {
+                UserDefaults.standard.set(previousAppleLanguages, forKey: "AppleLanguages")
+            } else {
+                UserDefaults.standard.removeObject(forKey: "AppleLanguages")
+            }
+        }
+
+        Self.disableMenuCardsForTesting()
+        let settings = Self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.switcherShowsIcons = false
+        settings.selectedMenuProvider = .codex
+        settings.costUsageEnabled = true
+
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            let shouldEnable = provider == .codex || provider == .claude
+            settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: shouldEnable)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        store._setTokenSnapshotForTesting(CostUsageTokenSnapshot(
+            sessionTokens: 123,
+            sessionCostUSD: 0.12,
+            last30DaysTokens: 123,
+            last30DaysCostUSD: 1.23,
+            daily: [
+                CostUsageDailyReport.Entry(
+                    date: "2025-12-23",
+                    inputTokens: nil,
+                    outputTokens: nil,
+                    totalTokens: 123,
+                    costUSD: 1.23,
+                    modelsUsed: nil,
+                    modelBreakdowns: nil),
+            ],
+            updatedAt: Date()), provider: .codex)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: Self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        CodexBarLocalizationOverride.$appLanguage.withValue("es") {
+            controller.menuWillOpen(menu)
+        }
+        controller.openMenus[ObjectIdentifier(menu)] = menu
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        #expect(Self.switcherButtons(in: menu).first?.title == "Resumen")
+        #expect(menu.items.first(where: { $0.representedObject as? String == "menuCardCost" })?.title == "Coste")
+
+        let initialSwitcher = menu.items.first?.view as? ProviderSwitcherView
+        let initialSwitcherID = initialSwitcher.map(ObjectIdentifier.init)
+        var rebuildCount = 0
+        controller._test_openMenuRebuildObserver = { _ in
+            rebuildCount += 1
+        }
+        defer { controller._test_openMenuRebuildObserver = nil }
+
+        CodexBarLocalizationOverride.$appLanguage.withValue("en") {
+            settings.appLanguage = "en"
+            controller.handleProviderConfigChange(reason: "appLanguage")
+        }
+
+        for _ in 0..<100 where rebuildCount == 0 {
+            await Task.yield()
+            try? await Task.sleep(for: .milliseconds(10))
+        }
+
+        #expect(rebuildCount == 1)
+        let updatedSwitcher = menu.items.first?.view as? ProviderSwitcherView
+        #expect(Self.switcherButtons(in: menu).first?.title == "Overview")
+        #expect(menu.items.first(where: { $0.representedObject as? String == "menuCardCost" })?.title == "Cost")
+        if let initialSwitcherID, let updatedSwitcher {
+            #expect(initialSwitcherID != ObjectIdentifier(updatedSwitcher))
+        }
+    }
+
+    private static func disableMenuCardsForTesting() {
+        StatusItemController.menuCardRenderingEnabled = false
+        StatusItemController.setMenuRefreshEnabledForTesting(false)
+    }
+
+    private static func makeStatusBarForTesting() -> NSStatusBar {
+        .system
+    }
+
+    private static func makeSettings() -> SettingsStore {
+        let suite = "StatusMenuLocalizationRefreshTests-\(UUID().uuidString)"
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+        return SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+    }
+
+    private static func switcherButtons(in menu: NSMenu) -> [NSButton] {
+        guard let switcherView = menu.items.first?.view as? ProviderSwitcherView else { return [] }
+        return switcherView.subviews
+            .compactMap { $0 as? NSButton }
+            .sorted { $0.tag < $1.tag }
+    }
+}
diff --git a/Tests/CodexBarTests/StatusMenuMergedOverviewRefreshTests.swift b/Tests/CodexBarTests/StatusMenuMergedOverviewRefreshTests.swift
new file mode 100644
index 0000000000..2bb35b2509
--- /dev/null
+++ b/Tests/CodexBarTests/StatusMenuMergedOverviewRefreshTests.swift
@@ -0,0 +1,92 @@
+import AppKit
+import CodexBarCore
+import Testing
+@testable import CodexBar
+
+@MainActor
+@Suite(.serialized)
+struct StatusMenuMergedOverviewRefreshTests {
+    @Test
+    func `overview stays busy for an omitted provider refresh`() async throws {
+        let settings = self.makeSettings()
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        let activeProviders: Set<UsageProvider> = [.claude, .codex, .cursor, .opencode]
+        self.enableOnly(activeProviders, settings: settings)
+        settings.mergedOverviewSelectedProviders = [.claude, .codex, .cursor]
+        settings.mergedMenuLastSelectedWasOverview = true
+
+        let controller = self.makeController(settings: settings)
+        let menu = try #require(controller.makeMenu() as? StatusItemMenu)
+        controller.mergedMenu = menu
+        controller.menuWillOpen(menu)
+        defer { controller.menuDidClose(menu) }
+
+        let visibleProviders = settings.resolvedMergedOverviewProviders(
+            activeProviders: controller.store.enabledProvidersForDisplay())
+        #expect(!visibleProviders.contains(.opencode))
+
+        controller.store.refreshingProviders.insert(.opencode)
+        controller.updatePersistentRefreshItemsEnabled()
+        #expect(controller.isRefreshActionInFlight(for: menu))
+        let refreshItem = try #require(menu.items.first { $0.title == "Refresh" })
+        #expect(controller.isPersistentRefreshItem(refreshItem))
+        #expect(!refreshItem.isEnabled)
+
+        var requestCount = 0
+        controller._test_manualRefreshOperation = { requestCount += 1 }
+        controller.performPersistentRefreshAction(in: ObjectIdentifier(menu))
+        #expect(try menu.performKeyEquivalent(with: self.keyEvent("r", keyCode: 15)))
+        for _ in 0..<20 {
+            await Task.yield()
+        }
+
+        #expect(requestCount == 0)
+        #expect(controller.manualRefreshTask == nil)
+        #expect(controller.manualRefreshProvider == nil)
+    }
+
+    private func makeSettings() -> SettingsStore {
+        let suite = "StatusMenuMergedOverviewRefreshTests-\(UUID().uuidString)"
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        return SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+    }
+
+    private func makeController(settings: SettingsStore) -> StatusItemController {
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        return StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system)
+    }
+
+    private func enableOnly(_ providers: Set<UsageProvider>, settings: SettingsStore) {
+        for provider in UsageProvider.allCases {
+            guard let metadata = ProviderRegistry.shared.metadata[provider] else { continue }
+            settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: providers.contains(provider))
+        }
+    }
+
+    private func keyEvent(_ characters: String, keyCode: UInt16) throws -> NSEvent {
+        try #require(NSEvent.keyEvent(
+            with: .keyDown,
+            location: .zero,
+            modifierFlags: [.command],
+            timestamp: 0,
+            windowNumber: 0,
+            context: nil,
+            characters: characters,
+            charactersIgnoringModifiers: characters,
+            isARepeat: false,
+            keyCode: keyCode))
+    }
+}
diff --git a/Tests/CodexBarTests/StatusMenuNativeSectionSpacingTests.swift b/Tests/CodexBarTests/StatusMenuNativeSectionSpacingTests.swift
new file mode 100644
index 0000000000..1a5cfba2f3
--- /dev/null
+++ b/Tests/CodexBarTests/StatusMenuNativeSectionSpacingTests.swift
@@ -0,0 +1,110 @@
+import AppKit
+import CodexBarCore
+import Testing
+@testable import CodexBar
+
+@MainActor
+@Suite(.serialized)
+struct StatusMenuNativeSectionSpacingTests {
+    @Test
+    func `storage credits and cost never create adjacent separators`() throws {
+        let previousRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = true
+        defer { StatusItemController.menuCardRenderingEnabled = previousRendering }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        settings.costUsageEnabled = true
+        settings.providerStorageFootprintsEnabled = true
+        self.enableOnlyCodex(settings)
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let storageRoot = "/Users/test/.codex"
+        store.providerStorageFootprints[.codex] = ProviderStorageFootprint(
+            provider: .codex,
+            totalBytes: 1024,
+            paths: [storageRoot],
+            missingPaths: [],
+            unreadablePaths: [],
+            components: [.init(path: storageRoot, totalBytes: 1024)],
+            updatedAt: Date())
+        store.credits = CreditsSnapshot(remaining: 100, events: [], updatedAt: Date())
+        store.openAIDashboard = OpenAIDashboardSnapshot(
+            signedInEmail: "user@example.com",
+            codeReviewRemainingPercent: 100,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            updatedAt: Date())
+        store.openAIDashboardAttachmentAuthorized = true
+        store.openAIDashboardRequiresLogin = false
+        store._setTokenSnapshotForTesting(CostUsageTokenSnapshot(
+            sessionTokens: 123,
+            sessionCostUSD: 0.12,
+            last30DaysTokens: 123,
+            last30DaysCostUSD: 1.23,
+            daily: [
+                CostUsageDailyReport.Entry(
+                    date: "2025-12-23",
+                    inputTokens: nil,
+                    outputTokens: nil,
+                    totalTokens: 123,
+                    costUSD: 1.23,
+                    modelsUsed: nil,
+                    modelBreakdowns: nil),
+            ],
+            updatedAt: Date()), provider: .codex)
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu(for: .codex)
+        controller.menuWillOpen(menu)
+        let storageIndex = try #require(menu.items.firstIndex {
+            ($0.representedObject as? String) == "menuCardStorage"
+        })
+        let creditsIndex = try #require(menu.items.firstIndex {
+            ($0.representedObject as? String) == "menuCardCredits"
+        })
+        let costIndex = try #require(menu.items.firstIndex {
+            ($0.representedObject as? String) == "menuCardCost"
+        })
+        #expect(storageIndex < creditsIndex)
+        #expect(creditsIndex < costIndex)
+        #expect(menu.items[costIndex + 1].isSeparatorItem)
+        #expect(!zip(menu.items, menu.items.dropFirst()).contains { first, second in
+            first.isSeparatorItem && second.isSeparatorItem
+        })
+    }
+
+    private func makeSettings() -> SettingsStore {
+        let suite = "StatusMenuNativeSectionSpacingTests-\(UUID().uuidString)"
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.providerDetectionCompleted = true
+        return settings
+    }
+
+    private func enableOnlyCodex(_ settings: SettingsStore) {
+        for provider in UsageProvider.allCases {
+            guard let metadata = ProviderRegistry.shared.metadata[provider] else { continue }
+            settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: provider == .codex)
+        }
+    }
+}
diff --git a/Tests/CodexBarTests/StatusMenuOpenRefreshTests.swift b/Tests/CodexBarTests/StatusMenuOpenRefreshTests.swift
new file mode 100644
index 0000000000..7f0f219313
--- /dev/null
+++ b/Tests/CodexBarTests/StatusMenuOpenRefreshTests.swift
@@ -0,0 +1,1710 @@
+import AppKit
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+extension StatusMenuTests {
+    @Test
+    func `store observation marks open menu stale without rebuilding during tracking`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        let key = ObjectIdentifier(menu)
+        controller.openMenus[key] = menu
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        let openedVersion = controller.menuVersions[key]
+        var rebuildCount = 0
+        controller._test_openMenuRebuildObserver = { _ in
+            rebuildCount += 1
+        }
+
+        let now = Date()
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 33,
+                    windowMinutes: 300,
+                    resetsAt: now.addingTimeInterval(1800),
+                    resetDescription: nil),
+                secondary: nil,
+                tertiary: nil,
+                updatedAt: now,
+                identity: ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: "codex@example.com",
+                    accountOrganization: nil,
+                    loginMethod: "Plus Plan")),
+            provider: .codex)
+
+        for _ in 0..<20 where controller.menuContentVersion == openedVersion {
+            await Task.yield()
+        }
+
+        #expect(controller.menuContentVersion != openedVersion)
+        #expect(controller.menuVersions[key] == openedVersion)
+        #expect(rebuildCount == 0)
+    }
+
+    @Test
+    func `closed merged menu defers rebuild until next open instead of pre-warming`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        self.enableOnlyCodex(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        StatusItemController.setClosedMenuPreparationDelayForTesting(.zero)
+        defer { StatusItemController.resetClosedMenuPreparationDelayForTesting() }
+
+        controller.menuRefreshEnabledOverrideForTesting = true
+        let menu = controller.makeMenu()
+        controller.mergedMenu = menu
+        controller.statusItem.menu = menu
+        for _ in 0..<20 {
+            await Task.yield()
+        }
+
+        controller.populateMenu(menu, provider: nil)
+        controller.markMenuFresh(menu)
+        let key = ObjectIdentifier(menu)
+        for _ in 0..<40 {
+            await Task.yield()
+        }
+        controller.populateMenu(menu, provider: nil)
+        controller.markMenuFresh(menu)
+        controller.cancelAllClosedMenuRebuilds()
+        controller.closedMenusDeferredUntilNextOpen.removeAll(keepingCapacity: false)
+        let openedVersion = controller.menuVersions[key]
+
+        // Background data-refresh tick (stale allowed): closed prep is skipped entirely, so
+        // the closed merged menu must not be pre-warmed or marked deferred.
+        controller.invalidateMenus(allowStaleContentDuringDataRefresh: true)
+        for _ in 0..<40 {
+            await Task.yield()
+        }
+        #expect(controller.openMenus.isEmpty)
+        #expect(controller.menuContentVersion != openedVersion)
+        #expect(controller.menuVersions[key] == openedVersion)
+        #expect(!controller.closedMenusDeferredUntilNextOpen.contains(key))
+
+        // A required (non-stale) invalidation must also leave the closed merged menu deferred.
+        controller.invalidateMenus()
+        for _ in 0..<40 {
+            await Task.yield()
+        }
+        #expect(controller.menuVersions[key] == openedVersion)
+        #expect(controller.closedMenusDeferredUntilNextOpen.contains(key))
+
+        // The deferred merged menu is repopulated synchronously on the next open.
+        controller.menuWillOpen(menu)
+        defer { controller.menuDidClose(menu) }
+        #expect(controller.menuVersions[key] == controller.menuContentVersion)
+        #expect(!controller.closedMenusDeferredUntilNextOpen.contains(key))
+    }
+
+    @Test
+    func `data refresh invalidation does not rebuild closed non merged attached menu`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        self.enableOnlyCodex(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        StatusItemController.setClosedMenuPreparationDelayForTesting(.zero)
+        defer { StatusItemController.resetClosedMenuPreparationDelayForTesting() }
+
+        controller.menuRefreshEnabledOverrideForTesting = true
+        let menu = controller.makeMenu()
+        // Use a non-merged attached menu: stale data-refresh invalidations should not pre-warm any
+        // closed attached menu, while required invalidations still may prepare non-merged menus.
+        controller.fallbackMenu = menu
+        controller.statusItem.menu = menu
+
+        controller.populateMenu(menu, provider: nil)
+        controller.markMenuFresh(menu)
+        let key = ObjectIdentifier(menu)
+        for _ in 0..<40 {
+            await Task.yield()
+        }
+        controller.populateMenu(menu, provider: nil)
+        controller.markMenuFresh(menu)
+        controller.cancelAllClosedMenuRebuilds()
+        let openedVersion = controller.menuVersions[key]
+
+        controller.invalidateMenus(allowStaleContentDuringDataRefresh: true)
+        for _ in 0..<40 {
+            await Task.yield()
+        }
+
+        #expect(controller.openMenus.isEmpty)
+        #expect(controller.menuContentVersion != openedVersion)
+        #expect(controller.menuVersions[key] == openedVersion)
+
+        controller.menuWillOpen(menu)
+        defer { controller.menuDidClose(menu) }
+
+        for _ in 0..<40 where controller.menuVersions[key] != controller.menuContentVersion {
+            await Task.yield()
+        }
+        #expect(controller.menuVersions[key] == controller.menuContentVersion)
+    }
+
+    @Test
+    func `required non merged closed menu preparation survives later data refresh invalidation`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        self.enableOnlyCodex(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        StatusItemController.setClosedMenuPreparationDelayForTesting(.zero)
+        defer { StatusItemController.resetClosedMenuPreparationDelayForTesting() }
+
+        controller.menuRefreshEnabledOverrideForTesting = true
+        let menu = controller.makeMenu()
+        // Use a non-merged attached menu so this covers the delayed closed-menu rebuild path. Merged
+        // menus are intentionally deferred until next open on current main (#1274).
+        controller.fallbackMenu = menu
+        controller.statusItem.menu = menu
+
+        controller.populateMenu(menu, provider: nil)
+        controller.markMenuFresh(menu)
+        let key = ObjectIdentifier(menu)
+        let openedVersion = controller.menuVersions[key]
+
+        controller.invalidateMenus()
+        let requiredVersion = controller.latestRequiredMenuRebuildVersion
+        controller.invalidateMenus(allowStaleContentDuringDataRefresh: true)
+        for _ in 0..<40 where controller.menuVersions[key] == openedVersion {
+            await Task.yield()
+        }
+
+        #expect(controller.openMenus.isEmpty)
+        #expect(requiredVersion > (openedVersion ?? -1))
+        #expect(controller.menuVersions[key] == controller.menuContentVersion)
+    }
+
+    @Test
+    func `closed attached menu preparation waits for store refresh to finish`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        self.enableOnlyCodex(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        StatusItemController.setClosedMenuPreparationDelayForTesting(.zero)
+        defer { StatusItemController.resetClosedMenuPreparationDelayForTesting() }
+
+        controller.menuRefreshEnabledOverrideForTesting = true
+        let menu = controller.makeMenu()
+        // Use a non-merged attached menu: the merged menu is intentionally never pre-warmed while
+        // closed (#1274), so the in-flight-refresh prep machinery is exercised via the fallback menu.
+        controller.fallbackMenu = menu
+        controller.statusItem.menu = menu
+
+        controller.populateMenu(menu, provider: nil)
+        controller.markMenuFresh(menu)
+        let key = ObjectIdentifier(menu)
+        let openedVersion = controller.menuVersions[key]
+
+        store.isRefreshing = true
+        controller.invalidateMenus()
+        for _ in 0..<40 {
+            await Task.yield()
+        }
+
+        #expect(controller.menuVersions[key] == openedVersion)
+
+        store.isRefreshing = false
+        controller.invalidateMenus()
+        for _ in 0..<40 where controller.menuVersions[key] == openedVersion {
+            await Task.yield()
+        }
+
+        #expect(controller.openMenus.isEmpty)
+        #expect(controller.menuVersions[key] == controller.menuContentVersion)
+    }
+
+    @Test
+    func `closed attached menu preparation waits for token refresh to finish`() async {
+        StatusItemController.setClosedMenuPreparationDelayForTesting(.zero)
+        defer { StatusItemController.resetClosedMenuPreparationDelayForTesting() }
+
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        self.enableOnlyCodex(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        controller.menuRefreshEnabledOverrideForTesting = true
+        let menu = controller.makeMenu()
+        // Use a non-merged attached menu: the merged menu is intentionally never pre-warmed while
+        // closed (#1274), so the in-flight-refresh prep machinery is exercised via the fallback menu.
+        controller.fallbackMenu = menu
+        controller.statusItem.menu = menu
+
+        controller.populateMenu(menu, provider: nil)
+        controller.markMenuFresh(menu)
+        let key = ObjectIdentifier(menu)
+        let openedVersion = controller.menuVersions[key]
+
+        store.tokenRefreshInFlight.insert(.codex)
+        controller.invalidateMenus()
+        for _ in 0..<40 {
+            await Task.yield()
+        }
+
+        #expect(controller.menuVersions[key] == openedVersion)
+
+        store.tokenRefreshInFlight.remove(.codex)
+        controller.invalidateMenus()
+        for _ in 0..<40 where controller.menuVersions[key] == openedVersion {
+            await Task.yield()
+        }
+
+        #expect(controller.openMenus.isEmpty)
+        #expect(controller.menuVersions[key] == controller.menuContentVersion)
+    }
+
+    @Test
+    func `closed menu rebuild cleanup runs when weak menu disappears`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        self.enableOnlyCodex(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        StatusItemController.setClosedMenuPreparationDelayForTesting(.zero)
+        defer { StatusItemController.resetClosedMenuPreparationDelayForTesting() }
+
+        let key: ObjectIdentifier
+        do {
+            let menu = NSMenu()
+            key = ObjectIdentifier(menu)
+            controller.rebuildClosedMenuIfNeeded(menu)
+            #expect(controller.closedMenuRebuildTasks[key] != nil)
+            #expect(controller.closedMenuRebuildTokens[key] != nil)
+        }
+
+        for _ in 0..<40 where controller.closedMenuRebuildTasks[key] != nil {
+            await Task.yield()
+        }
+
+        #expect(controller.closedMenuRebuildTasks[key] == nil)
+        #expect(controller.closedMenuRebuildTokens[key] == nil)
+    }
+
+    @Test
+    func `merged menu close defers stale rebuild until next open`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        self.enableOnlyCodex(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        StatusItemController.setClosedMenuPreparationDelayForTesting(.zero)
+        defer { StatusItemController.resetClosedMenuPreparationDelayForTesting() }
+
+        controller.menuRefreshEnabledOverrideForTesting = true
+        let menu = controller.makeMenu()
+        controller.mergedMenu = menu
+        controller.statusItem.menu = menu
+        controller.populateMenu(menu, provider: nil)
+        controller.markMenuFresh(menu)
+        controller.menuWillOpen(menu)
+
+        let key = ObjectIdentifier(menu)
+        let openedVersion = controller.menuVersions[key]
+        controller.invalidateMenus(refreshOpenMenus: false)
+        #expect(controller.menuNeedsRefresh(menu))
+
+        controller.menuDidClose(menu)
+        await self.waitUntilClosedMenuRebuildRemainsDeferred(controller, key: key, openedVersion: openedVersion)
+
+        #expect(controller.closedMenuRebuildTasks[key] == nil)
+        #expect(controller.menuVersions[key] == openedVersion)
+
+        controller.menuWillOpen(menu)
+        #expect(controller.menuVersions[key] == controller.menuContentVersion)
+    }
+
+    @Test
+    func `menu open keeps stale nonempty content while store refresh is active`() {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        self.enableOnlyCodex(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        controller.menuRefreshEnabledOverrideForTesting = true
+        let menu = controller.makeMenu()
+        controller.mergedMenu = menu
+        controller.statusItem.menu = menu
+
+        controller.populateMenu(menu, provider: nil)
+        controller.markMenuFresh(menu)
+        let key = ObjectIdentifier(menu)
+        let openedVersion = controller.menuVersions[key]
+        let openedItemCount = menu.items.count
+
+        store.isRefreshing = true
+        defer { store.isRefreshing = false }
+        controller.invalidateMenus(allowStaleContentDuringDataRefresh: true)
+        controller.menuWillOpen(menu)
+        defer { controller.menuDidClose(menu) }
+
+        #expect(controller.menuVersions[key] == openedVersion)
+        #expect(controller.menuContentVersion != openedVersion)
+        #expect(menu.items.count == openedItemCount)
+        #expect(controller.openMenus[key] === menu)
+    }
+
+    @Test
+    func `menu open rebuilds stale content after privacy setting changes during refresh`() {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        self.enableOnlyCodex(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        controller.menuRefreshEnabledOverrideForTesting = true
+        let menu = controller.makeMenu()
+        controller.mergedMenu = menu
+        controller.statusItem.menu = menu
+
+        controller.populateMenu(menu, provider: nil)
+        controller.markMenuFresh(menu)
+        let key = ObjectIdentifier(menu)
+        let openedVersion = controller.menuVersions[key]
+
+        store.isRefreshing = true
+        defer { store.isRefreshing = false }
+        controller.invalidateMenus(allowStaleContentDuringDataRefresh: true)
+        settings.hidePersonalInfo = true
+        controller.invalidateMenus()
+        controller.menuWillOpen(menu)
+        defer { controller.menuDidClose(menu) }
+
+        #expect(controller.menuVersions[key] == controller.menuContentVersion)
+        #expect(controller.menuVersions[key] != openedVersion)
+    }
+
+    @Test
+    func `menu open keeps stale nonempty content while token refresh is active`() {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        self.enableOnlyCodex(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        controller.menuRefreshEnabledOverrideForTesting = true
+        let menu = controller.makeMenu()
+        controller.mergedMenu = menu
+        controller.statusItem.menu = menu
+
+        controller.populateMenu(menu, provider: nil)
+        controller.markMenuFresh(menu)
+        let key = ObjectIdentifier(menu)
+        let openedVersion = controller.menuVersions[key]
+        let openedItemCount = menu.items.count
+
+        store.tokenRefreshInFlight.insert(.codex)
+        defer { store.tokenRefreshInFlight.remove(.codex) }
+        controller.invalidateMenus(allowStaleContentDuringDataRefresh: true)
+        controller.menuWillOpen(menu)
+        defer { controller.menuDidClose(menu) }
+
+        #expect(controller.menuVersions[key] == openedVersion)
+        #expect(controller.menuContentVersion != openedVersion)
+        #expect(menu.items.count == openedItemCount)
+        #expect(controller.openMenus[key] === menu)
+    }
+
+    @Test
+    func `explicit store actions defer visible parent menu rebuild`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        let key = ObjectIdentifier(menu)
+        controller.openMenus[key] = menu
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        let openedVersion = controller.menuVersions[key]
+        var rebuildCount = 0
+        controller._test_openMenuRebuildObserver = { _ in
+            rebuildCount += 1
+        }
+        defer { controller._test_openMenuRebuildObserver = nil }
+
+        controller.refreshOpenMenusAfterExplicitStoreAction()
+        for _ in 0..<20 {
+            await Task.yield()
+        }
+
+        #expect(controller.menuContentVersion != openedVersion)
+        #expect(rebuildCount == 0)
+        #expect(controller.menuVersions[key] == openedVersion)
+        #expect(controller.parentMenuRebuildsDeferredDuringTracking.contains(key))
+    }
+
+    @Test
+    func `repeated explicit store actions keep parent rebuild deferred`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        let key = ObjectIdentifier(menu)
+        controller.openMenus[key] = menu
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        var rebuildCount = 0
+        controller._test_openMenuRebuildObserver = { _ in
+            rebuildCount += 1
+        }
+        defer { controller._test_openMenuRebuildObserver = nil }
+
+        controller.refreshOpenMenusAfterExplicitStoreAction()
+        controller.refreshOpenMenusAfterExplicitStoreAction()
+        controller.refreshOpenMenusAfterExplicitStoreAction()
+
+        for _ in 0..<20 {
+            await Task.yield()
+        }
+
+        #expect(rebuildCount == 0)
+        #expect(controller.menuVersions[key] != controller.menuContentVersion)
+        #expect(controller.parentMenuRebuildsDeferredDuringTracking.contains(key))
+    }
+
+    @Test
+    func `explicit refresh rebuilds stale parent after hosted submenu closes`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        let menuKey = ObjectIdentifier(menu)
+        controller.openMenus[menuKey] = menu
+
+        let submenu = controller.makeHostedSubviewPlaceholderMenu(
+            chartID: StatusItemController.usageBreakdownChartID,
+            provider: .codex)
+        let submenuKey = ObjectIdentifier(submenu)
+        controller.openMenus[submenuKey] = submenu
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        let openedVersion = controller.menuVersions[menuKey]
+        var rebuildCount = 0
+        controller._test_openMenuRebuildObserver = { _ in
+            rebuildCount += 1
+        }
+        defer { controller._test_openMenuRebuildObserver = nil }
+
+        controller.refreshOpenMenusAfterExplicitStoreAction()
+        for _ in 0..<20 where controller.menuContentVersion == openedVersion {
+            await Task.yield()
+        }
+        #expect(controller.menuVersions[menuKey] == openedVersion)
+
+        controller.menuDidClose(submenu)
+        for _ in 0..<20 where rebuildCount == 0 {
+            await Task.yield()
+        }
+
+        #expect(controller.openMenus[submenuKey] == nil)
+        #expect(rebuildCount == 1)
+        #expect(controller.menuVersions[menuKey] == controller.menuContentVersion)
+        #expect(!controller.parentMenuRebuildsDeferredDuringTracking.contains(menuKey))
+    }
+
+    @Test
+    func `hosted submenu close waits for active refresh before rebuilding parent`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        let menuKey = ObjectIdentifier(menu)
+        controller.openMenus[menuKey] = menu
+
+        let submenu = controller.makeHostedSubviewPlaceholderMenu(
+            chartID: StatusItemController.usageBreakdownChartID,
+            provider: .codex)
+        let submenuKey = ObjectIdentifier(submenu)
+        controller.openMenus[submenuKey] = submenu
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        let openedVersion = controller.menuVersions[menuKey]
+        var rebuildCount = 0
+        controller._test_openMenuRebuildObserver = { _ in
+            rebuildCount += 1
+        }
+        defer { controller._test_openMenuRebuildObserver = nil }
+
+        store.isRefreshing = true
+        controller.refreshOpenMenusAfterExplicitStoreAction()
+        controller.menuDidClose(submenu)
+        for _ in 0..<20 {
+            await Task.yield()
+        }
+
+        #expect(controller.openMenus[submenuKey] == nil)
+        #expect(rebuildCount == 0)
+        #expect(controller.menuVersions[menuKey] == openedVersion)
+        #expect(controller.parentMenuRebuildPendingAfterHostedSubviewClose)
+
+        store.isRefreshing = false
+        controller.handleObservedStoreMenuChange()
+        for _ in 0..<20 where rebuildCount == 0 {
+            await Task.yield()
+        }
+
+        #expect(rebuildCount == 1)
+        #expect(controller.menuVersions[menuKey] == controller.menuContentVersion)
+        #expect(!controller.parentMenuRebuildPendingAfterHostedSubviewClose)
+        #expect(!controller.parentMenuRebuildsDeferredDuringTracking.contains(menuKey))
+    }
+
+    @Test
+    func `plain open menu refresh preserves pending switcher hosted submenu cleanup`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        let menuKey = ObjectIdentifier(menu)
+        controller.openMenus[menuKey] = menu
+
+        let submenu = controller.makeHostedSubviewPlaceholderMenu(
+            chartID: StatusItemController.usageBreakdownChartID,
+            provider: .codex)
+        let submenuKey = ObjectIdentifier(submenu)
+        controller.openMenus[submenuKey] = submenu
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        var rebuildCount = 0
+        controller._test_openMenuRebuildObserver = { _ in
+            rebuildCount += 1
+        }
+        defer { controller._test_openMenuRebuildObserver = nil }
+
+        controller.deferSwitcherMenuRebuildIfStillVisible(menu, provider: .codex)
+        controller.refreshOpenMenuIfStillVisible(menu, provider: .codex)
+
+        for _ in 0..<20 where rebuildCount == 0 {
+            await Task.yield()
+        }
+
+        #expect(controller.openMenus[submenuKey] == nil)
+        #expect(rebuildCount == 1)
+        #expect(controller.menuVersions[menuKey] == controller.menuContentVersion)
+    }
+
+    @Test
+    func `rapid switcher rebuild requests coalesce before populating open menu`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        let menuKey = ObjectIdentifier(menu)
+        controller.openMenus[menuKey] = menu
+        controller.menuRefreshEnabledOverrideForTesting = true
+        controller._test_providerSwitcherMenuRebuildDebounceNanoseconds = 0
+        defer { controller._test_providerSwitcherMenuRebuildDebounceNanoseconds = nil }
+
+        var rebuildCount = 0
+        controller._test_openMenuRebuildObserver = { _ in
+            rebuildCount += 1
+        }
+        defer { controller._test_openMenuRebuildObserver = nil }
+        var refreshGateEntries = 0
+        var pendingRefreshGates: [CheckedContinuation<Void, Never>] = []
+        func resumePendingRefreshGates() {
+            let gates = pendingRefreshGates
+            pendingRefreshGates.removeAll(keepingCapacity: true)
+            for gate in gates {
+                gate.resume()
+            }
+        }
+        controller._test_openMenuRefreshYieldOverride = {
+            refreshGateEntries += 1
+            await withCheckedContinuation { continuation in
+                pendingRefreshGates.append(continuation)
+            }
+        }
+        defer {
+            resumePendingRefreshGates()
+            controller._test_openMenuRefreshYieldOverride = nil
+        }
+
+        controller.deferSwitcherMenuRebuildIfStillVisible(menu, provider: .codex)
+        for _ in 0..<20 where refreshGateEntries == 0 {
+            await Task.yield()
+        }
+        #expect(refreshGateEntries == 1)
+        #expect(rebuildCount == 0)
+
+        controller.deferSwitcherMenuRebuildIfStillVisible(menu, provider: .codex)
+        resumePendingRefreshGates()
+        for _ in 0..<20 where refreshGateEntries < 2 {
+            await Task.yield()
+        }
+        #expect(refreshGateEntries == 2)
+        #expect(rebuildCount == 0)
+        resumePendingRefreshGates()
+
+        for _ in 0..<20 where rebuildCount == 0 {
+            await Task.yield()
+        }
+
+        #expect(rebuildCount == 1)
+        for _ in 0..<20 {
+            await Task.yield()
+        }
+        #expect(rebuildCount == 1)
+    }
+
+    @Test
+    func `codex parent menu open defers stale OpenAI web refresh until tracking ends`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.openAIWebAccessEnabled = true
+        settings.openAIWebBatterySaverEnabled = true
+        settings.codexCookieSource = .auto
+        self.enableOnlyCodex(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store.openAIDashboard = nil
+        store.lastOpenAIDashboardSnapshot = nil
+        store._test_providerRefreshOverride = { _ in }
+        defer { store._test_providerRefreshOverride = nil }
+        store._test_codexCreditsLoaderOverride = {
+            CreditsSnapshot(remaining: 25, events: [], updatedAt: Date())
+        }
+        defer { store._test_codexCreditsLoaderOverride = nil }
+        let blocker = BlockingManagedOpenAIDashboardLoader()
+        var refreshInteractions: [ProviderInteraction] = []
+        store._test_openAIDashboardLoaderOverride = { _, _, _, _ in
+            refreshInteractions.append(ProviderInteractionContext.current)
+            return try await blocker.awaitResult()
+        }
+        defer { store._test_openAIDashboardLoaderOverride = nil }
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        controller.menuRefreshEnabledOverrideForTesting = true
+        StatusItemController.setDeferredMenuInteractionRefreshDelayForTesting(.zero)
+        defer { StatusItemController.resetDeferredMenuInteractionRefreshDelayForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+
+        for _ in 0..<20 {
+            await Task.yield()
+        }
+        #expect(await blocker.startedCount() == 0)
+        #expect(controller.deferredOpenAIDashboardRefreshReason != nil)
+
+        controller.menuDidClose(menu)
+        await blocker.waitUntilStarted(count: 1)
+        #expect(await blocker.startedCount() == 1)
+        #expect(refreshInteractions == [.background])
+
+        await blocker.resumeNext(with: .success(self.makeOpenAIDashboard(
+            dailyBreakdown: [],
+            updatedAt: Date())))
+    }
+
+    @Test
+    func `programmatic parent menu close schedules deferred OpenAI web refresh`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.openAIWebAccessEnabled = true
+        settings.openAIWebBatterySaverEnabled = true
+        settings.codexCookieSource = .auto
+        self.enableOnlyCodex(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store.openAIDashboard = nil
+        store.lastOpenAIDashboardSnapshot = nil
+        store._test_codexCreditsLoaderOverride = {
+            CreditsSnapshot(remaining: 0, events: [], updatedAt: Date())
+        }
+        defer { store._test_codexCreditsLoaderOverride = nil }
+        let blocker = BlockingManagedOpenAIDashboardLoader()
+        store._test_openAIDashboardLoaderOverride = { _, _, _, _ in
+            try await blocker.awaitResult()
+        }
+        defer { store._test_openAIDashboardLoaderOverride = nil }
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        controller.menuRefreshEnabledOverrideForTesting = true
+        StatusItemController.setDeferredMenuInteractionRefreshDelayForTesting(.zero)
+        defer { StatusItemController.resetDeferredMenuInteractionRefreshDelayForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        #expect(controller.deferredOpenAIDashboardRefreshReason != nil)
+
+        controller.forgetClosedMenu(menu)
+        await blocker.waitUntilStarted(count: 1)
+        #expect(await blocker.startedCount() == 1)
+
+        await blocker.resumeNext(with: .success(self.makeOpenAIDashboard(
+            dailyBreakdown: [],
+            updatedAt: Date())))
+    }
+
+    @Test
+    func `deferred OpenAI web refresh retries after active store refresh completes`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.openAIWebAccessEnabled = true
+        settings.openAIWebBatterySaverEnabled = true
+        settings.codexCookieSource = .auto
+        self.enableOnlyCodex(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store.openAIDashboard = nil
+        store.lastOpenAIDashboardSnapshot = nil
+        store.isRefreshing = true
+        let blocker = BlockingManagedOpenAIDashboardLoader()
+        store._test_openAIDashboardLoaderOverride = { _, _, _, _ in
+            try await blocker.awaitResult()
+        }
+        defer { store._test_openAIDashboardLoaderOverride = nil }
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        StatusItemController.setDeferredMenuInteractionRefreshDelayForTesting(.zero)
+        defer { StatusItemController.resetDeferredMenuInteractionRefreshDelayForTesting() }
+
+        controller.deferOpenAIDashboardRefreshUntilMenuCloses(reason: "parent menu open")
+        controller.scheduleDeferredMenuInteractionRefreshIfNeeded()
+
+        try? await Task.sleep(for: .milliseconds(50))
+        #expect(await blocker.startedCount() == 0)
+        #expect(controller.deferredOpenAIDashboardRefreshReason != nil)
+
+        store.isRefreshing = false
+        await blocker.waitUntilStarted(count: 1)
+        #expect(await blocker.startedCount() == 1)
+
+        await blocker.resumeNext(with: .success(self.makeOpenAIDashboard(
+            dailyBreakdown: [],
+            updatedAt: Date())))
+    }
+
+    @Test
+    func `deferred OpenAI web refresh waits for deferred store refresh`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.openAIWebAccessEnabled = true
+        settings.openAIWebBatterySaverEnabled = true
+        settings.codexCookieSource = .auto
+        self.enableOnlyCodex(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store._setSnapshotForTesting(nil, provider: .codex)
+        store.openAIDashboard = nil
+        store.lastOpenAIDashboardSnapshot = nil
+        let providerBlocker = BlockingStatusMenuProviderRefresh()
+        store._test_providerRefreshOverride = { provider in
+            guard provider == .codex else { return }
+            await providerBlocker.awaitRelease()
+        }
+        defer { store._test_providerRefreshOverride = nil }
+        let dashboardBlocker = BlockingManagedOpenAIDashboardLoader()
+        store._test_openAIDashboardLoaderOverride = { _, _, _, _ in
+            try await dashboardBlocker.awaitResult()
+        }
+        defer { store._test_openAIDashboardLoaderOverride = nil }
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        controller.menuRefreshEnabledOverrideForTesting = true
+        StatusItemController.setDeferredMenuInteractionRefreshDelayForTesting(.zero)
+        defer { StatusItemController.resetDeferredMenuInteractionRefreshDelayForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        controller.menuDidClose(menu)
+
+        await providerBlocker.waitUntilStarted()
+        #expect(await dashboardBlocker.startedCount() == 0)
+
+        await providerBlocker.resumeNext()
+        await dashboardBlocker.waitUntilStarted(count: 1)
+        #expect(await dashboardBlocker.startedCount() == 1)
+
+        await dashboardBlocker.resumeNext(with: .success(self.makeOpenAIDashboard(
+            dailyBreakdown: [],
+            updatedAt: Date())))
+    }
+
+    @Test
+    func `reopened menu keeps dashboard refresh deferred after store refresh`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.openAIWebAccessEnabled = true
+        settings.openAIWebBatterySaverEnabled = true
+        settings.codexCookieSource = .auto
+        self.enableOnlyCodex(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store._setSnapshotForTesting(nil, provider: .codex)
+        store.openAIDashboard = nil
+        store.lastOpenAIDashboardSnapshot = nil
+        let providerBlocker = BlockingStatusMenuProviderRefresh()
+        store._test_providerRefreshOverride = { provider in
+            guard provider == .codex else { return }
+            await providerBlocker.awaitRelease()
+        }
+        defer { store._test_providerRefreshOverride = nil }
+        let dashboardBlocker = BlockingManagedOpenAIDashboardLoader()
+        store._test_openAIDashboardLoaderOverride = { _, _, _, _ in
+            try await dashboardBlocker.awaitResult()
+        }
+        defer { store._test_openAIDashboardLoaderOverride = nil }
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        controller.menuRefreshEnabledOverrideForTesting = true
+        StatusItemController.setDeferredMenuInteractionRefreshDelayForTesting(.zero)
+        defer { StatusItemController.resetDeferredMenuInteractionRefreshDelayForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        controller.menuDidClose(menu)
+        await providerBlocker.waitUntilStarted()
+
+        let reopenedMenu = controller.makeMenu()
+        controller.menuWillOpen(reopenedMenu)
+        await providerBlocker.resumeNext()
+        try? await Task.sleep(for: .milliseconds(50))
+        #expect(await dashboardBlocker.startedCount() == 0)
+        #expect(controller.deferredOpenAIDashboardRefreshReason != nil)
+
+        controller.menuDidClose(reopenedMenu)
+        await dashboardBlocker.waitUntilStarted(count: 1)
+        #expect(await dashboardBlocker.startedCount() == 1)
+
+        await dashboardBlocker.resumeNext(with: .success(self.makeOpenAIDashboard(
+            dailyBreakdown: [],
+            updatedAt: Date())))
+    }
+
+    @Test
+    func `codex parent menu close refreshes recent dashboard cache with no chart history`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.openAIWebAccessEnabled = true
+        settings.openAIWebBatterySaverEnabled = true
+        settings.codexCookieSource = .auto
+        self.enableOnlyCodex(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store.openAIDashboard = self.makeOpenAIDashboard(dailyBreakdown: [], updatedAt: Date())
+        store.lastOpenAIDashboardSnapshot = store.openAIDashboard
+        store._test_providerRefreshOverride = { _ in }
+        defer { store._test_providerRefreshOverride = nil }
+        let blocker = BlockingManagedOpenAIDashboardLoader()
+        store._test_openAIDashboardLoaderOverride = { _, _, _, _ in
+            try await blocker.awaitResult()
+        }
+        defer { store._test_openAIDashboardLoaderOverride = nil }
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        controller.menuRefreshEnabledOverrideForTesting = true
+        StatusItemController.setDeferredMenuInteractionRefreshDelayForTesting(.zero)
+        defer { StatusItemController.resetDeferredMenuInteractionRefreshDelayForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+
+        for _ in 0..<20 {
+            await Task.yield()
+        }
+        #expect(await blocker.startedCount() == 0)
+
+        controller.menuDidClose(menu)
+        await blocker.waitUntilStarted(count: 1)
+        #expect(await blocker.startedCount() == 1)
+
+        await blocker.resumeNext(with: .success(self.makeOpenAIDashboard(
+            dailyBreakdown: [
+                OpenAIDashboardDailyBreakdown(day: "2026-05-24", services: [], totalCreditsUsed: 12),
+            ],
+            updatedAt: Date())))
+    }
+
+    @Test
+    func `codex parent menu open throttles recent empty dashboard retry`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.openAIWebAccessEnabled = true
+        settings.openAIWebBatterySaverEnabled = true
+        settings.codexCookieSource = .auto
+        self.enableOnlyCodex(settings)
+
+        let now = Date()
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store.openAIDashboard = self.makeOpenAIDashboard(dailyBreakdown: [], updatedAt: now.addingTimeInterval(-120))
+        store.lastOpenAIDashboardSnapshot = store.openAIDashboard
+        store.lastOpenAIDashboardAttemptAt = now.addingTimeInterval(-60)
+        store._test_providerRefreshOverride = { _ in }
+        defer { store._test_providerRefreshOverride = nil }
+        let blocker = BlockingManagedOpenAIDashboardLoader()
+        store._test_openAIDashboardLoaderOverride = { _, _, _, _ in
+            try await blocker.awaitResult()
+        }
+        defer { store._test_openAIDashboardLoaderOverride = nil }
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        controller.menuDidClose(menu)
+
+        try? await Task.sleep(for: .milliseconds(150))
+        #expect(await blocker.startedCount() == 0)
+    }
+
+    @Test
+    func `credits history arriving after open rebuilds parent menu after tracking ends`() async throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.showOptionalCreditsAndExtraUsage = true
+        self.enableOnlyCodex(settings)
+
+        let now = Date()
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: true)
+        store.credits = CreditsSnapshot(remaining: 100, events: [], updatedAt: now)
+        store.openAIDashboard = self.makeOpenAIDashboard(dailyBreakdown: [], updatedAt: now)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        let key = ObjectIdentifier(menu)
+        controller.openMenus[key] = menu
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        let openedVersion = try #require(controller.menuVersions[key])
+        #expect(self.menuItem(in: menu, id: "menuCardCredits") == nil)
+
+        store.openAIDashboard = self.makeOpenAIDashboard(
+            dailyBreakdown: [
+                OpenAIDashboardDailyBreakdown(day: "2026-05-24", services: [], totalCreditsUsed: 12),
+            ],
+            updatedAt: now.addingTimeInterval(10))
+
+        await self.waitUntilOpenMenuStaysStale(controller, key: key, after: openedVersion)
+
+        #expect(controller.menuContentVersion != openedVersion)
+        #expect(controller.menuVersions[key] == openedVersion)
+
+        await self.closeMenuAndWaitUntilFresh(controller, menu: menu, key: key)
+
+        let creditsItem = try #require(self.menuItem(in: menu, id: "menuCardCredits"))
+        #expect(
+            creditsItem.submenu?.items.first?.representedObject as? String ==
+                StatusItemController.creditsHistoryChartID)
+        #expect(controller.menuVersions[key] == controller.menuContentVersion)
+    }
+
+    @Test
+    func `fresh dashboard history with same day count rebuilds parent menu after tracking ends`() async throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.showOptionalCreditsAndExtraUsage = true
+        self.enableOnlyCodex(settings)
+
+        let now = Date(timeIntervalSince1970: 100)
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: true)
+        store.credits = CreditsSnapshot(remaining: 100, events: [], updatedAt: now)
+        store.openAIDashboard = self.makeOpenAIDashboard(
+            dailyBreakdown: [
+                OpenAIDashboardDailyBreakdown(day: "2026-05-24", services: [], totalCreditsUsed: 12),
+            ],
+            updatedAt: now)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        let key = ObjectIdentifier(menu)
+        controller.openMenus[key] = menu
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        let openedVersion = try #require(controller.menuVersions[key])
+        _ = try #require(self.menuItem(in: menu, id: "menuCardCredits"))
+
+        store.openAIDashboard = self.makeOpenAIDashboard(
+            dailyBreakdown: [
+                OpenAIDashboardDailyBreakdown(day: "2026-05-24", services: [], totalCreditsUsed: 99),
+            ],
+            updatedAt: now.addingTimeInterval(10))
+
+        await self.waitUntilOpenMenuStaysStale(controller, key: key, after: openedVersion)
+
+        #expect(controller.menuContentVersion != openedVersion)
+        #expect(controller.menuVersions[key] == openedVersion)
+
+        await self.closeMenuAndWaitUntilFresh(controller, menu: menu, key: key)
+
+        let creditsItem = try #require(self.menuItem(in: menu, id: "menuCardCredits"))
+        #expect(creditsItem.submenu?.items.first?.representedObject as? String == StatusItemController
+            .creditsHistoryChartID)
+    }
+
+    @Test
+    func `token cost history arriving after open rebuilds parent menu after tracking ends`() async throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.costUsageEnabled = true
+        self.enableOnlyCodex(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        let key = ObjectIdentifier(menu)
+        controller.openMenus[key] = menu
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        let openedVersion = try #require(controller.menuVersions[key])
+        #expect(self.menuItem(in: menu, id: "menuCardCost") == nil)
+
+        store._setTokenSnapshotForTesting(self.makeCodexTokenCostSnapshot(), provider: .codex)
+
+        await self.waitUntilOpenMenuStaysStale(controller, key: key, after: openedVersion)
+
+        #expect(controller.menuContentVersion != openedVersion)
+        #expect(controller.menuVersions[key] == openedVersion)
+
+        await self.closeMenuAndWaitUntilFresh(controller, menu: menu, key: key)
+
+        let costItem = try #require(self.menuItem(in: menu, id: "menuCardCost"))
+        #expect(costItem.submenu?.items.first?.representedObject as? String == StatusItemController.costHistoryChartID)
+        #expect(controller.menuVersions[key] == controller.menuContentVersion)
+    }
+
+    @Test
+    func `fresh token cost history with same day count rebuilds parent menu after tracking ends`() async throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.costUsageEnabled = true
+        self.enableOnlyCodex(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store._setTokenSnapshotForTesting(
+            self.makeCodexTokenCostSnapshot(
+                sessionTokens: 123,
+                sessionCostUSD: 0.12,
+                last30DaysTokens: 456,
+                last30DaysCostUSD: 1.23,
+                updatedAt: Date(timeIntervalSince1970: 100)),
+            provider: .codex)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        let key = ObjectIdentifier(menu)
+        controller.openMenus[key] = menu
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        let openedVersion = try #require(controller.menuVersions[key])
+        _ = try #require(self.menuItem(in: menu, id: "menuCardCost"))
+
+        store._setTokenSnapshotForTesting(
+            self.makeCodexTokenCostSnapshot(
+                sessionTokens: 999,
+                sessionCostUSD: 0.99,
+                last30DaysTokens: 888,
+                last30DaysCostUSD: 8.88,
+                updatedAt: Date(timeIntervalSince1970: 200)),
+            provider: .codex)
+
+        await self.waitUntilOpenMenuStaysStale(controller, key: key, after: openedVersion)
+
+        #expect(controller.menuContentVersion != openedVersion)
+        #expect(controller.menuVersions[key] == openedVersion)
+
+        await self.closeMenuAndWaitUntilFresh(controller, menu: menu, key: key)
+
+        let costItem = try #require(self.menuItem(in: menu, id: "menuCardCost"))
+        #expect(costItem.submenu?.items.first?.representedObject as? String == StatusItemController.costHistoryChartID)
+    }
+
+    @Test
+    func `plan utilization history arriving after open rebuilds parent menu after tracking ends`() async throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        self.enableOnlyCodex(settings)
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        let key = ObjectIdentifier(menu)
+        controller.openMenus[key] = menu
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        let openedVersion = try #require(controller.menuVersions[key])
+        let usageHistoryItem = try #require(self.menuItem(in: menu, id: "usageHistorySubmenu"))
+        #expect(usageHistoryItem.submenu?.items.first?.representedObject as? String == StatusItemController
+            .usageHistoryChartID)
+        let openedRevision = store.planUtilizationHistoryRevision
+
+        await store.recordPlanUtilizationHistorySample(
+            provider: .codex,
+            snapshot: self.makeCodexPlanUtilizationSnapshot(),
+            now: Date())
+
+        await self.waitUntilOpenMenuStaysStale(controller, key: key, after: openedVersion)
+
+        #expect(store.planUtilizationHistoryRevision > openedRevision)
+        #expect(controller.menuContentVersion != openedVersion)
+        #expect(controller.menuVersions[key] == openedVersion)
+
+        await self.closeMenuAndWaitUntilFresh(controller, menu: menu, key: key)
+    }
+
+    @Test
+    func `dashboard attachment authorization arriving after open rebuilds parent menu after close`() async throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.openAIWebAccessEnabled = true
+        settings.codexCookieSource = .auto
+        self.enableOnlyCodex(settings)
+
+        let now = Date()
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store.openAIDashboard = self.makeOpenAIDashboard(
+            dailyBreakdown: [
+                OpenAIDashboardDailyBreakdown(day: "2026-05-24", services: [], totalCreditsUsed: 12),
+            ],
+            updatedAt: now)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        let key = ObjectIdentifier(menu)
+        controller.openMenus[key] = menu
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        let openedVersion = try #require(controller.menuVersions[key])
+        #expect(store.openAIDashboardAttachmentRevision == 0)
+
+        store.openAIDashboardAttachmentAuthorized = true
+
+        await self.waitUntilOpenMenuStaysStale(controller, key: key, after: openedVersion)
+
+        #expect(store.openAIDashboardAttachmentRevision == 1)
+        #expect(controller.menuContentVersion != openedVersion)
+        #expect(controller.menuVersions[key] == openedVersion)
+
+        await self.closeMenuAndWaitUntilFresh(controller, menu: menu, key: key)
+    }
+
+    private func enableOnlyCodex(_ settings: SettingsStore) {
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: provider == .codex)
+        }
+    }
+
+    private func menuItem(in menu: NSMenu, id: String) -> NSMenuItem? {
+        menu.items.first { ($0.representedObject as? String) == id }
+    }
+
+    private func waitUntilMenuVersionChanges(
+        _ controller: StatusItemController,
+        from version: Int?) async
+    {
+        for _ in 0..<20 where controller.menuContentVersion == version {
+            await Task.yield()
+        }
+    }
+
+    private func waitUntilOpenMenuStaysStale(
+        _ controller: StatusItemController,
+        key: ObjectIdentifier,
+        after version: Int?) async
+    {
+        for _ in 0..<40 {
+            guard controller.menuContentVersion != version else {
+                await Task.yield()
+                continue
+            }
+            guard controller.menuVersions[key] == version else {
+                await Task.yield()
+                continue
+            }
+            return
+        }
+    }
+
+    private func closeMenuAndWaitUntilFresh(
+        _ controller: StatusItemController,
+        menu: NSMenu,
+        key: ObjectIdentifier) async
+    {
+        controller.menuDidClose(menu)
+        for _ in 0..<40 where controller.menuVersions[key] != controller.menuContentVersion {
+            await Task.yield()
+        }
+        if controller.menuVersions[key] != controller.menuContentVersion {
+            controller.menuWillOpen(menu)
+        }
+        for _ in 0..<40 where controller.menuVersions[key] != controller.menuContentVersion {
+            await Task.yield()
+        }
+        #expect(controller.menuVersions[key] == controller.menuContentVersion)
+    }
+
+    private func waitUntilClosedMenuRebuildRemainsDeferred(
+        _ controller: StatusItemController,
+        key: ObjectIdentifier,
+        openedVersion: Int?) async
+    {
+        for _ in 0..<40
+            where controller.closedMenuRebuildTasks[key] != nil ||
+            controller.menuVersions[key] != openedVersion
+        {
+            await Task.yield()
+        }
+    }
+
+    private func makeOpenAIDashboard(
+        dailyBreakdown: [OpenAIDashboardDailyBreakdown],
+        updatedAt: Date) -> OpenAIDashboardSnapshot
+    {
+        OpenAIDashboardSnapshot(
+            signedInEmail: "codex@example.com",
+            codeReviewRemainingPercent: nil,
+            creditEvents: [],
+            dailyBreakdown: dailyBreakdown,
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            updatedAt: updatedAt)
+    }
+
+    private func makeCodexTokenCostSnapshot(
+        sessionTokens: Int = 123,
+        sessionCostUSD: Double = 0.12,
+        last30DaysTokens: Int = 456,
+        last30DaysCostUSD: Double = 1.23,
+        updatedAt: Date = Date()) -> CostUsageTokenSnapshot
+    {
+        CostUsageTokenSnapshot(
+            sessionTokens: sessionTokens,
+            sessionCostUSD: sessionCostUSD,
+            last30DaysTokens: last30DaysTokens,
+            last30DaysCostUSD: last30DaysCostUSD,
+            daily: [
+                CostUsageDailyReport.Entry(
+                    date: "2026-05-24",
+                    inputTokens: nil,
+                    outputTokens: nil,
+                    totalTokens: sessionTokens,
+                    costUSD: last30DaysCostUSD,
+                    modelsUsed: nil,
+                    modelBreakdowns: nil),
+            ],
+            updatedAt: updatedAt)
+    }
+
+    private func makeCodexPlanUtilizationSnapshot() -> UsageSnapshot {
+        UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 35,
+                windowMinutes: 300,
+                resetsAt: Date().addingTimeInterval(1800),
+                resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: 42,
+                windowMinutes: 10080,
+                resetsAt: Date().addingTimeInterval(86400),
+                resetDescription: nil),
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: "codex@example.com",
+                accountOrganization: nil,
+                loginMethod: "Plus Plan"))
+    }
+}
+
+private actor BlockingStatusMenuProviderRefresh {
+    private var continuations: [CheckedContinuation<Void, Never>] = []
+    private var startWaiters: [CheckedContinuation<Void, Never>] = []
+    private var started = 0
+
+    func awaitRelease() async {
+        self.started += 1
+        self.resumeStartWaiters()
+        await withCheckedContinuation { continuation in
+            self.continuations.append(continuation)
+        }
+    }
+
+    func waitUntilStarted() async {
+        if self.started > 0 { return }
+        await withCheckedContinuation { continuation in
+            self.startWaiters.append(continuation)
+        }
+    }
+
+    func resumeNext() {
+        guard !self.continuations.isEmpty else { return }
+        self.continuations.removeFirst().resume()
+    }
+
+    private func resumeStartWaiters() {
+        let waiters = self.startWaiters
+        self.startWaiters = []
+        for waiter in waiters {
+            waiter.resume()
+        }
+    }
+}
diff --git a/Tests/CodexBarTests/StatusMenuOverviewScrollTests.swift b/Tests/CodexBarTests/StatusMenuOverviewScrollTests.swift
new file mode 100644
index 0000000000..320cc1222c
--- /dev/null
+++ b/Tests/CodexBarTests/StatusMenuOverviewScrollTests.swift
@@ -0,0 +1,216 @@
+import AppKit
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@MainActor
+struct StatusMenuOverviewScrollTests {
+    private func makeController(suiteName: String) -> StatusItemController {
+        _ = NSApplication.shared
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: suiteName),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        let fetcher = UsageFetcher()
+        let store = UsageStore(
+            fetcher: fetcher,
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings)
+        return StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system)
+    }
+
+    private func makeOverviewMenu() -> NSMenu {
+        let menu = NSMenu()
+        for provider in ["claude", "codex"] {
+            let item = NSMenuItem()
+            item.representedObject = "\(StatusItemController.overviewRowIdentifierPrefix)\(provider)"
+            item.isEnabled = true
+            menu.addItem(item)
+        }
+        return menu
+    }
+
+    private func makeScrollEvent(deltaY: Double, precise: Bool) -> NSEvent? {
+        guard let cgEvent = CGEvent(
+            scrollWheelEvent2Source: nil,
+            units: precise ? .pixel : .line,
+            wheelCount: 1,
+            wheel1: Int32(deltaY),
+            wheel2: 0,
+            wheel3: 0)
+        else { return nil }
+        return NSEvent(cgEvent: cgEvent)
+    }
+
+    @Test
+    func `scroll steps move highlight and respect direction`() throws {
+        let controller = self.makeController(suiteName: "OverviewScroll-Direction")
+        defer { controller.releaseStatusItemsForTesting() }
+        let menu = self.makeOverviewMenu()
+
+        var steps: [OverviewScrollStep] = []
+        controller.overviewScrollNavigationHandlerForTesting = { steps.append($0) }
+
+        let scrollUp = try #require(self.makeScrollEvent(deltaY: 30, precise: true))
+        #expect(controller.handleOverviewScrollWheel(scrollUp, menu: menu))
+        #expect(steps == [.up])
+
+        steps = []
+        let scrollDown = try #require(self.makeScrollEvent(deltaY: -30, precise: true))
+        #expect(controller.handleOverviewScrollWheel(scrollDown, menu: menu))
+        #expect(steps == [.down])
+    }
+
+    @Test
+    func `navigation targets only overview rows`() {
+        let controller = self.makeController(suiteName: "OverviewScroll-Targets")
+        defer { controller.releaseStatusItemsForTesting() }
+        let menu = self.makeOverviewMenu()
+        let refresh = NSMenuItem(title: "Refresh", action: nil, keyEquivalent: "")
+        refresh.isEnabled = true
+        menu.addItem(refresh)
+        let rows = Array(menu.items.prefix(2))
+
+        #expect(controller.overviewScrollTargetItem(in: menu, step: .down) === rows[0])
+        #expect(controller.overviewScrollTargetItem(in: menu, step: .up) === rows[1])
+
+        controller.highlightedMenuItems[ObjectIdentifier(menu)] = rows[0]
+        #expect(controller.overviewScrollTargetItem(in: menu, step: .down) === rows[1])
+        #expect(controller.overviewScrollTargetItem(in: menu, step: .up) === rows[0])
+
+        controller.highlightedMenuItems[ObjectIdentifier(menu)] = rows[1]
+        #expect(controller.overviewScrollTargetItem(in: menu, step: .down) === rows[1])
+        #expect(controller.overviewScrollTargetItem(in: menu, step: .up) === rows[0])
+
+        controller.highlightedMenuItems[ObjectIdentifier(menu)] = refresh
+        #expect(controller.overviewScrollTargetItem(in: menu, step: .down) === rows[0])
+    }
+
+    @Test
+    func `small precise deltas accumulate before stepping`() throws {
+        let controller = self.makeController(suiteName: "OverviewScroll-Accumulate")
+        defer { controller.releaseStatusItemsForTesting() }
+        let menu = self.makeOverviewMenu()
+
+        var steps: [OverviewScrollStep] = []
+        controller.overviewScrollNavigationHandlerForTesting = { steps.append($0) }
+
+        let smallScroll = try #require(self.makeScrollEvent(deltaY: 10, precise: true))
+        #expect(controller.handleOverviewScrollWheel(smallScroll, menu: menu))
+        #expect(steps.isEmpty)
+        #expect(controller.handleOverviewScrollWheel(smallScroll, menu: menu))
+        #expect(steps.isEmpty)
+        #expect(controller.handleOverviewScrollWheel(smallScroll, menu: menu))
+        #expect(steps == [.up])
+    }
+
+    @Test
+    func `direction change resets accumulated distance`() throws {
+        let controller = self.makeController(suiteName: "OverviewScroll-Flip")
+        defer { controller.releaseStatusItemsForTesting() }
+        let menu = self.makeOverviewMenu()
+
+        var steps: [OverviewScrollStep] = []
+        controller.overviewScrollNavigationHandlerForTesting = { steps.append($0) }
+
+        let upBelowThreshold = try #require(self.makeScrollEvent(deltaY: 20, precise: true))
+        #expect(controller.handleOverviewScrollWheel(upBelowThreshold, menu: menu))
+        #expect(steps.isEmpty)
+
+        let downBelowThreshold = try #require(self.makeScrollEvent(deltaY: -20, precise: true))
+        #expect(controller.handleOverviewScrollWheel(downBelowThreshold, menu: menu))
+        #expect(steps.isEmpty)
+        #expect(controller.handleOverviewScrollWheel(downBelowThreshold, menu: menu))
+        #expect(steps == [.down])
+    }
+
+    @Test
+    func `coarse wheel lines step immediately`() throws {
+        let controller = self.makeController(suiteName: "OverviewScroll-Wheel")
+        defer { controller.releaseStatusItemsForTesting() }
+        let menu = self.makeOverviewMenu()
+
+        var steps: [OverviewScrollStep] = []
+        controller.overviewScrollNavigationHandlerForTesting = { steps.append($0) }
+
+        let wheelNotch = try #require(self.makeScrollEvent(deltaY: -1, precise: false))
+        #expect(controller.handleOverviewScrollWheel(wheelNotch, menu: menu))
+        #expect(steps == [.down])
+    }
+
+    @Test
+    func `fast flick is capped per event`() throws {
+        let controller = self.makeController(suiteName: "OverviewScroll-Cap")
+        defer { controller.releaseStatusItemsForTesting() }
+        let menu = self.makeOverviewMenu()
+
+        var steps: [OverviewScrollStep] = []
+        controller.overviewScrollNavigationHandlerForTesting = { steps.append($0) }
+
+        let flick = try #require(self.makeScrollEvent(deltaY: 500, precise: true))
+        #expect(controller.handleOverviewScrollWheel(flick, menu: menu))
+        #expect(steps == [.up, .up, .up])
+    }
+
+    @Test
+    func `capped flick discards leftover distance`() throws {
+        let controller = self.makeController(suiteName: "OverviewScroll-CapRemainder")
+        defer { controller.releaseStatusItemsForTesting() }
+        let menu = self.makeOverviewMenu()
+
+        var steps: [OverviewScrollStep] = []
+        controller.overviewScrollNavigationHandlerForTesting = { steps.append($0) }
+
+        let flick = try #require(self.makeScrollEvent(deltaY: 500, precise: true))
+        #expect(controller.handleOverviewScrollWheel(flick, menu: menu))
+        #expect(steps == [.up, .up, .up])
+
+        steps = []
+        let smallScroll = try #require(self.makeScrollEvent(deltaY: 10, precise: true))
+        #expect(controller.handleOverviewScrollWheel(smallScroll, menu: menu))
+        #expect(steps.isEmpty)
+    }
+
+    @Test
+    func `open submenu suspends scroll navigation`() throws {
+        let controller = self.makeController(suiteName: "OverviewScroll-Submenu")
+        defer { controller.releaseStatusItemsForTesting() }
+        let menu = self.makeOverviewMenu()
+        let submenu = NSMenu()
+        controller.openMenus[ObjectIdentifier(menu)] = menu
+        controller.openMenus[ObjectIdentifier(submenu)] = submenu
+        defer { controller.openMenus.removeAll() }
+
+        var steps: [OverviewScrollStep] = []
+        controller.overviewScrollNavigationHandlerForTesting = { steps.append($0) }
+
+        let scroll = try #require(self.makeScrollEvent(deltaY: 30, precise: true))
+        #expect(!controller.handleOverviewScrollWheel(scroll, menu: menu))
+        #expect(steps.isEmpty)
+    }
+
+    @Test
+    func `menus without overview rows ignore scrolling`() throws {
+        let controller = self.makeController(suiteName: "OverviewScroll-NonOverview")
+        defer { controller.releaseStatusItemsForTesting() }
+        let menu = NSMenu()
+        menu.addItem(NSMenuItem(title: "Refresh", action: nil, keyEquivalent: ""))
+
+        var steps: [OverviewScrollStep] = []
+        controller.overviewScrollNavigationHandlerForTesting = { steps.append($0) }
+
+        let scroll = try #require(self.makeScrollEvent(deltaY: 30, precise: true))
+        #expect(!controller.handleOverviewScrollWheel(scroll, menu: menu))
+        #expect(steps.isEmpty)
+        #expect(!menu.items.isEmpty)
+    }
+}
diff --git a/Tests/CodexBarTests/StatusMenuOverviewSubmenuTests.swift b/Tests/CodexBarTests/StatusMenuOverviewSubmenuTests.swift
new file mode 100644
index 0000000000..4311deaa57
--- /dev/null
+++ b/Tests/CodexBarTests/StatusMenuOverviewSubmenuTests.swift
@@ -0,0 +1,271 @@
+import AppKit
+import CodexBarCore
+import Testing
+@testable import CodexBar
+
+extension StatusMenuTests {
+    @Test
+    func `overview rows expose provider detail submenus`() throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .openai
+        settings.mergedMenuLastSelectedWasOverview = true
+
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            let shouldEnable = provider == .openai || provider == .codex
+            settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: shouldEnable)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let usage = OpenAIAPIUsageSnapshot(
+            daily: [
+                OpenAIAPIUsageSnapshot.DailyBucket(
+                    day: "2023-11-14",
+                    startTime: now,
+                    endTime: now.addingTimeInterval(86400),
+                    costUSD: 9,
+                    requests: 12,
+                    inputTokens: 100,
+                    cachedInputTokens: 0,
+                    outputTokens: 50,
+                    totalTokens: 150,
+                    lineItems: [],
+                    models: []),
+            ],
+            updatedAt: now)
+        store._setSnapshotForTesting(usage.toUsageSnapshot(), provider: .openai)
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+
+        let openAIRow = try #require(menu.items.first {
+            ($0.representedObject as? String) == "overviewRow-openai"
+        })
+        #expect(openAIRow.submenu?.items.contains {
+            ($0.representedObject as? String) == StatusItemController.costHistoryChartID
+        } == true)
+    }
+
+    @Test
+    func `overview row submenu action does not switch provider detail`() throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .claude
+        settings.mergedMenuLastSelectedWasOverview = true
+
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            let shouldEnable = provider == .zai || provider == .claude
+            settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: shouldEnable)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let usage = ZaiUsageSnapshot(
+            tokenLimit: nil,
+            timeLimit: ZaiLimitEntry(
+                type: .timeLimit,
+                unit: .minutes,
+                number: 1,
+                usage: 100,
+                currentValue: 50,
+                remaining: 50,
+                percentage: 50,
+                usageDetails: [ZaiUsageDetail(modelCode: "glm-4.5", usage: 512)],
+                nextResetTime: now.addingTimeInterval(3600)),
+            planName: "Pro",
+            updatedAt: now)
+        store._setSnapshotForTesting(usage.toUsageSnapshot(), provider: .zai)
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+
+        let zaiRow = try #require(menu.items.first {
+            ($0.representedObject as? String) == "overviewRow-zai"
+        })
+        #expect(zaiRow.submenu != nil)
+
+        let action = try #require(zaiRow.action)
+        let target = try #require(zaiRow.target as? StatusItemController)
+        _ = target.perform(action, with: zaiRow)
+
+        #expect(settings.mergedMenuLastSelectedWasOverview)
+        #expect(settings.selectedMenuProvider == .claude)
+        #expect(menu.items.contains {
+            ($0.representedObject as? String) == "overviewRow-zai"
+        })
+    }
+
+    @Test
+    func `selecting overview row defers provider detail rebuild`() async throws {
+        let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
+        let previousMenuRefresh = StatusItemController.menuRefreshEnabled
+        StatusItemController.menuCardRenderingEnabled = false
+        StatusItemController.setMenuRefreshEnabledForTesting(true)
+        defer {
+            StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering
+            StatusItemController.setMenuRefreshEnabledForTesting(previousMenuRefresh)
+        }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        settings.mergedMenuLastSelectedWasOverview = true
+
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            let shouldEnable = provider == .codex || provider == .cursor
+            settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: shouldEnable)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        defer { controller.menuDidClose(menu) }
+
+        let cursorRow = try #require(menu.items.first {
+            ($0.representedObject as? String) == "overviewRow-cursor"
+        })
+        var rebuildCount = 0
+        controller._test_openMenuRebuildObserver = { _ in
+            rebuildCount += 1
+        }
+        defer { controller._test_openMenuRebuildObserver = nil }
+
+        let action = try #require(cursorRow.action)
+        let target = try #require(cursorRow.target as? StatusItemController)
+        _ = target.perform(action, with: cursorRow)
+
+        #expect(settings.mergedMenuLastSelectedWasOverview == false)
+        #expect(settings.selectedMenuProvider == .cursor)
+        #expect(rebuildCount == 0)
+        #expect(menu.items.contains {
+            ($0.representedObject as? String)?.hasPrefix("overviewRow-") == true
+        })
+
+        for _ in 0..<100 where rebuildCount == 0 {
+            await Task.yield()
+            try? await Task.sleep(for: .milliseconds(10))
+        }
+
+        let representedIDs = menu.items.compactMap { $0.representedObject as? String }
+        let switcherButtons = (menu.items.first?.view as? ProviderSwitcherView)?.subviews
+            .compactMap { $0 as? NSButton } ?? []
+        #expect(rebuildCount == 1)
+        #expect(representedIDs.contains("menuCard"))
+        #expect(representedIDs.contains(where: { $0.hasPrefix("overviewRow-") }) == false)
+        #expect(switcherButtons.first(where: { $0.state == .on })?.tag == 2)
+    }
+
+    @Test
+    func `overview row action close renders selected provider on next open`() async throws {
+        let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
+        let previousMenuRefresh = StatusItemController.menuRefreshEnabled
+        StatusItemController.menuCardRenderingEnabled = false
+        StatusItemController.setMenuRefreshEnabledForTesting(true)
+        defer {
+            StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering
+            StatusItemController.setMenuRefreshEnabledForTesting(previousMenuRefresh)
+        }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        settings.mergedMenuLastSelectedWasOverview = true
+
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            let shouldEnable = provider == .codex || provider == .cursor
+            settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: shouldEnable)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+
+        let cursorRow = try #require(menu.items.first {
+            ($0.representedObject as? String) == "overviewRow-cursor"
+        })
+        var rebuildCount = 0
+        controller._test_openMenuRebuildObserver = { _ in
+            rebuildCount += 1
+        }
+        defer { controller._test_openMenuRebuildObserver = nil }
+
+        let action = try #require(cursorRow.action)
+        let target = try #require(cursorRow.target as? StatusItemController)
+        _ = target.perform(action, with: cursorRow)
+        controller.menuDidClose(menu)
+
+        await Task.yield()
+        await Task.yield()
+        #expect(rebuildCount == 0)
+        #expect(settings.selectedMenuProvider == .cursor)
+
+        controller.menuWillOpen(menu)
+        defer { controller.menuDidClose(menu) }
+
+        let representedIDs = menu.items.compactMap { $0.representedObject as? String }
+        let switcherButtons = (menu.items.first?.view as? ProviderSwitcherView)?.subviews
+            .compactMap { $0 as? NSButton } ?? []
+        #expect(representedIDs.contains("menuCard"))
+        #expect(representedIDs.contains(where: { $0.hasPrefix("overviewRow-") }) == false)
+        #expect(switcherButtons.first(where: { $0.state == .on })?.tag == 2)
+    }
+}
diff --git a/Tests/CodexBarTests/StatusMenuPersistentRefreshTests.swift b/Tests/CodexBarTests/StatusMenuPersistentRefreshTests.swift
new file mode 100644
index 0000000000..0644e270ce
--- /dev/null
+++ b/Tests/CodexBarTests/StatusMenuPersistentRefreshTests.swift
@@ -0,0 +1,949 @@
+import AppKit
+import CodexBarCore
+import SwiftUI
+import Testing
+@testable import CodexBar
+
+private final class RefreshShortcutRecorder: StatusItemMenuPersistentActionDelegate {
+    var refreshCount = 0
+    var refreshMenuIDs: [ObjectIdentifier] = []
+    var settingsCount = 0
+    var quitCount = 0
+    var navigationDirections: [StatusItemMenuProviderNavigationDirection] = []
+
+    func performPersistentRefreshAction(in menuID: ObjectIdentifier) {
+        self.refreshCount += 1
+        self.refreshMenuIDs.append(menuID)
+    }
+
+    func performPersistentSettingsAction() {
+        self.settingsCount += 1
+    }
+
+    func performPersistentQuitAction() {
+        self.quitCount += 1
+    }
+
+    func performProviderNavigation(_ direction: StatusItemMenuProviderNavigationDirection) {
+        self.navigationDirections.append(direction)
+    }
+}
+
+@MainActor
+private final class UpdateReadyUpdater: UpdaterProviding {
+    var automaticallyChecksForUpdates = false
+    var automaticallyDownloadsUpdates = false
+    let isAvailable = true
+    let unavailableReason: String? = nil
+    let updateStatus = UpdateStatus(isUpdateReady: true)
+
+    func checkForUpdates(_: Any?) {}
+    func installUpdate() {}
+}
+
+@MainActor
+private final class ManualRefreshGate {
+    private var continuation: CheckedContinuation<Void, Never>?
+    private var isOpen = false
+
+    func wait() async {
+        if self.isOpen {
+            self.isOpen = false
+            return
+        }
+        await withCheckedContinuation { continuation in
+            self.continuation = continuation
+        }
+    }
+
+    func resume() {
+        if let continuation = self.continuation {
+            continuation.resume()
+            self.continuation = nil
+        } else {
+            self.isOpen = true
+        }
+    }
+}
+
+@MainActor
+@Suite(.serialized)
+struct StatusMenuPersistentRefreshTests {
+    private func makeSettings() -> SettingsStore {
+        let suite = "StatusMenuPersistentRefreshTests-\(UUID().uuidString)"
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+        return SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+    }
+
+    private func makeController(
+        settings: SettingsStore,
+        updater: UpdaterProviding = DisabledUpdaterController(),
+        account: AccountInfo? = nil) -> StatusItemController
+    {
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        if let account {
+            store.accountInfoCache[.codex] = UsageStore.AccountInfoCacheEntry(
+                account: account,
+                configRevision: settings.configRevision,
+                expiresAt: .distantFuture)
+        }
+        return StatusItemController(
+            store: store,
+            settings: settings,
+            account: account ?? fetcher.loadAccountInfo(),
+            updater: updater,
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system)
+    }
+
+    private func enableOnly(_ providers: Set<UsageProvider>, settings: SettingsStore) {
+        for provider in UsageProvider.allCases {
+            guard let metadata = ProviderRegistry.shared.metadata[provider] else { continue }
+            settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: providers.contains(provider))
+        }
+    }
+
+    private static func makeTokenSnapshot() -> CostUsageTokenSnapshot {
+        CostUsageTokenSnapshot(
+            sessionTokens: 123,
+            sessionCostUSD: 0.12,
+            last30DaysTokens: 456,
+            last30DaysCostUSD: 1.23,
+            daily: [],
+            updatedAt: Date())
+    }
+
+    @Test
+    func `refresh row is custom and appears above settings`() throws {
+        let previousRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = true
+        defer { StatusItemController.menuCardRenderingEnabled = previousRendering }
+
+        let settings = self.makeSettings()
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+
+        let controller = self.makeController(settings: settings)
+
+        let menu = controller.makeMenu(for: .codex)
+        controller.menuWillOpen(menu)
+
+        let refreshItem = try #require(menu.items.first { $0.title == "Refresh" })
+        let settingsItem = try #require(menu.items.first { $0.title == "Settings..." })
+        let refreshIndex = try #require(menu.items.firstIndex(where: { $0 === refreshItem }))
+        let settingsIndex = try #require(menu.items.firstIndex(where: { $0 === settingsItem }))
+
+        #expect(refreshItem.action == nil)
+        #expect(refreshItem.target == nil)
+        #expect(refreshItem.view != nil)
+        #expect(controller.isPersistentRefreshItem(refreshItem))
+        #expect(refreshIndex < settingsIndex)
+    }
+
+    @Test
+    func `refresh row is custom while remaining persistent action items stay native`() throws {
+        let previousRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = true
+        defer { StatusItemController.menuCardRenderingEnabled = previousRendering }
+
+        let settings = self.makeSettings()
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+
+        let controller = self.makeController(settings: settings, updater: UpdateReadyUpdater())
+        let menu = controller.makeMenu(for: .codex)
+        controller.menuWillOpen(menu)
+
+        let updateItem = try #require(menu.items.first { $0.title == "Update ready, restart now?" })
+        let refreshItem = try #require(menu.items.first { $0.title == "Refresh" })
+        #expect(MenuDescriptor.MenuAction.installUpdate.systemImageName == "arrow.down.circle")
+        #expect(updateItem.image != nil)
+        #expect(refreshItem.view != nil)
+        #expect(refreshItem.action == nil)
+        #expect(controller.isPersistentRefreshItem(refreshItem))
+
+        for title in ["Update ready, restart now?", "Settings...", "About CodexBar", "Quit"] {
+            let item = try #require(menu.items.first { $0.title == title })
+            #expect(item.view == nil, "'\(title)' should be a native NSMenuItem with no custom view")
+            #expect(item.action != nil)
+            #expect(item.target === controller)
+        }
+    }
+
+    @Test
+    func `persistent refresh row reflects scoped global and manual refresh state`() throws {
+        let previousRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = true
+        defer { StatusItemController.menuCardRenderingEnabled = previousRendering }
+
+        let settings = self.makeSettings()
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+
+        let controller = self.makeController(settings: settings)
+        let menu = controller.makeMenu(for: .codex)
+        controller.menuWillOpen(menu)
+
+        let refreshItem = try #require(menu.items.first { $0.title == "Refresh" })
+        #expect(refreshItem.view != nil)
+        #expect(controller.isPersistentRefreshItem(refreshItem))
+        #expect(controller.persistentRefreshItems.allObjects.contains { $0 === refreshItem })
+        #expect(refreshItem.isEnabled)
+
+        controller.store.refreshingProviders.insert(.claude)
+        controller.updatePersistentRefreshItemsEnabled()
+        #expect(refreshItem.isEnabled)
+
+        controller.store.refreshingProviders.insert(.codex)
+        controller.updatePersistentRefreshItemsEnabled()
+        #expect(!refreshItem.isEnabled)
+
+        controller.store.refreshingProviders.removeAll()
+        controller.store.isRefreshing = true
+        controller.updatePersistentRefreshItemsEnabled()
+        #expect(!refreshItem.isEnabled)
+
+        controller.store.isRefreshing = false
+        controller.manualRefreshProvider = .claude
+        controller.manualRefreshTask = Task {}
+        controller.updatePersistentRefreshItemsEnabled()
+        #expect(!refreshItem.isEnabled)
+
+        controller.manualRefreshTask = nil
+        controller.manualRefreshProvider = nil
+        controller.updatePersistentRefreshItemsEnabled()
+        #expect(refreshItem.isEnabled)
+
+        refreshItem.representedObject = "notRefresh"
+        controller.manualRefreshTask = Task {}
+        controller.updatePersistentRefreshItemsEnabled()
+        #expect(refreshItem.isEnabled)
+        #expect(!controller.persistentRefreshItems.allObjects.contains { $0 === refreshItem })
+        controller.manualRefreshTask = nil
+    }
+
+    @Test
+    func `refresh monitor follows refresh success and failure`() {
+        let settings = self.makeSettings()
+        let controller = self.makeController(settings: settings)
+        let monitor = controller.menuCardRefreshMonitor
+        let fallback = MenuCardLiveSubtitle(text: "Fallback", style: .info)
+
+        #expect(monitor.subtitle(for: .codex, fallback: fallback).style == .info)
+
+        controller.store.isRefreshing = true
+        #expect(monitor.subtitle(for: .codex, fallback: fallback).style == .loading)
+
+        controller.store.isRefreshing = false
+        monitor.isManualRefreshInFlight = true
+        #expect(monitor.subtitle(for: .codex, fallback: fallback).style == .loading)
+        monitor.isManualRefreshInFlight = false
+
+        controller.store.isRefreshing = false
+        let now = Date()
+        controller.store.snapshots[.codex] = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 10,
+                windowMinutes: nil,
+                resetsAt: now.addingTimeInterval(3600),
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: now)
+        let success = monitor.subtitle(for: .codex, fallback: fallback)
+        #expect(success.style == .info)
+        #expect(success.text == UsageFormatter.updatedString(from: now, now: Date()))
+
+        controller.store.errors[.codex] = "Refresh failed"
+        let failure = monitor.subtitle(for: .codex, fallback: fallback)
+        #expect(failure.style == .error)
+        #expect(failure.text == "Refresh failed")
+
+        monitor.isManualRefreshInFlight = true
+        #expect(monitor.subtitle(for: .codex, fallback: fallback).style == .loading)
+    }
+
+    @Test
+    func `scoped refresh monitor leaves unrelated providers unchanged`() throws {
+        let settings = self.makeSettings()
+        let controller = self.makeController(settings: settings)
+        let monitor = controller.menuCardRefreshMonitor
+        let codexModel = try #require(controller.menuCardModel(for: .codex))
+        let fallback = MenuCardLiveSubtitle(text: "Claude idle", style: .info)
+        let expectedClaude = monitor.subtitle(for: .claude, fallback: fallback)
+
+        monitor.beginManualRefresh(frozenModels: [.codex: codexModel], provider: .codex)
+        defer { monitor.endManualRefresh() }
+
+        #expect(monitor.isManualRefreshInFlight(for: .codex))
+        #expect(!monitor.isManualRefreshInFlight(for: .claude))
+        #expect(monitor.subtitle(for: .codex, fallback: fallback).style == .loading)
+        let actualClaude = monitor.subtitle(for: .claude, fallback: fallback)
+        #expect(actualClaude.text == expectedClaude.text)
+        #expect(actualClaude.style == expectedClaude.style)
+    }
+
+    @Test
+    func `refresh monitor updates compatible usage values after manual refresh completes`() throws {
+        let settings = self.makeSettings()
+        let controller = self.makeController(settings: settings)
+        let now = Date()
+        controller.store.snapshots[.claude] = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 10,
+                windowMinutes: 300,
+                resetsAt: now.addingTimeInterval(3600),
+                resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: 20,
+                windowMinutes: 10080,
+                resetsAt: now.addingTimeInterval(7200),
+                resetDescription: nil),
+            updatedAt: now)
+        let fallback = try #require(controller.menuCardModel(for: .claude))
+        controller.menuCardRefreshMonitor.isManualRefreshInFlight = true
+
+        controller.store.snapshots[.claude] = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 65,
+                windowMinutes: 300,
+                resetsAt: now.addingTimeInterval(3600),
+                resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: 75,
+                windowMinutes: 10080,
+                resetsAt: now.addingTimeInterval(7200),
+                resetDescription: nil),
+            updatedAt: now.addingTimeInterval(1))
+
+        let inFlight = controller.menuCardRefreshMonitor.model(for: .claude, fallback: fallback)
+        #expect(inFlight.metrics.map(\.percent) == fallback.metrics.map(\.percent))
+
+        controller.menuCardRefreshMonitor.isManualRefreshInFlight = false
+        let refreshed = controller.menuCardRefreshMonitor.model(for: .claude, fallback: fallback)
+        let expected = try #require(controller.menuCardModel(for: .claude))
+
+        #expect(refreshed.metrics.map(\.percent) == expected.metrics.map(\.percent))
+        #expect(refreshed.metrics.map(\.percent) != fallback.metrics.map(\.percent))
+    }
+
+    @Test
+    func `manual refresh keeps frozen quota even if menu rebuilds before completion`() throws {
+        let settings = self.makeSettings()
+        let controller = self.makeController(settings: settings)
+        let now = Date()
+        for provider in [UsageProvider.claude, .codex] {
+            controller.store.snapshots[provider] = UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 21,
+                    windowMinutes: 300,
+                    resetsAt: now.addingTimeInterval(3600),
+                    resetDescription: nil),
+                secondary: nil,
+                updatedAt: now)
+            let frozen = try #require(controller.menuCardModel(for: provider))
+            controller.menuCardRefreshMonitor.beginManualRefresh(frozenModels: [provider: frozen])
+
+            controller.store.snapshots[provider] = UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 18,
+                    windowMinutes: 300,
+                    resetsAt: now.addingTimeInterval(3600),
+                    resetDescription: nil),
+                secondary: nil,
+                updatedAt: now.addingTimeInterval(1))
+            let rebuiltFallback = try #require(controller.menuCardModel(for: provider))
+            let inFlight = controller.menuCardRefreshMonitor.model(for: provider, fallback: rebuiltFallback)
+
+            #expect(frozen.metrics.first?.percentLabel == "79% left")
+            #expect(rebuiltFallback.metrics.first?.percentLabel == "82% left")
+            #expect(inFlight.metrics.first?.percentLabel == "79% left")
+
+            controller.menuCardRefreshMonitor.endManualRefresh()
+            let completed = controller.menuCardRefreshMonitor.model(for: provider, fallback: frozen)
+            #expect(completed.metrics.first?.percentLabel == "82% left")
+        }
+    }
+
+    @Test
+    func `manual refresh uses fallback when frozen quota layout is incompatible`() throws {
+        let settings = self.makeSettings()
+        let controller = self.makeController(settings: settings)
+        let now = Date()
+        controller.store.snapshots[.claude] = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 21,
+                windowMinutes: 300,
+                resetsAt: now.addingTimeInterval(3600),
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: now)
+        let frozen = try #require(controller.menuCardModel(for: .claude))
+        controller.menuCardRefreshMonitor.beginManualRefresh(frozenModels: [.claude: frozen])
+
+        controller.store.snapshots[.claude] = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 18,
+                windowMinutes: 300,
+                resetsAt: now.addingTimeInterval(3600),
+                resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: 12,
+                windowMinutes: 10080,
+                resetsAt: now.addingTimeInterval(7 * 24 * 60 * 60),
+                resetDescription: nil),
+            updatedAt: now.addingTimeInterval(1))
+        let rebuiltFallback = try #require(controller.menuCardModel(for: .claude))
+        let inFlight = controller.menuCardRefreshMonitor.model(for: .claude, fallback: rebuiltFallback)
+
+        #expect(frozen.metrics.count == 1)
+        #expect(rebuiltFallback.metrics.count == 2)
+        #expect(inFlight.metrics.count == 2)
+        #expect(inFlight.metrics.map(\.id) == rebuiltFallback.metrics.map(\.id))
+    }
+
+    @Test
+    func `manual refresh preserves frozen quota when supplemental metric remains`() throws {
+        let settings = self.makeSettings()
+        let controller = self.makeController(
+            settings: settings,
+            account: AccountInfo(email: "test@example.com", plan: "pro"))
+        let now = Date()
+        controller.store.openAIDashboard = OpenAIDashboardSnapshot(
+            signedInEmail: "test@example.com",
+            codeReviewRemainingPercent: 88,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            updatedAt: now)
+        controller.store.openAIDashboardAttachmentAuthorized = true
+        controller.store.openAIDashboardRequiresLogin = false
+        controller.store.snapshots[.codex] = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 21,
+                windowMinutes: 300,
+                resetsAt: now.addingTimeInterval(3600),
+                resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: 12,
+                windowMinutes: 10080,
+                resetsAt: now.addingTimeInterval(7 * 24 * 60 * 60),
+                resetDescription: nil),
+            updatedAt: now)
+        let frozen = try #require(controller.menuCardModel(for: .codex))
+        controller.menuCardRefreshMonitor.beginManualRefresh(frozenModels: [.codex: frozen])
+
+        controller.store.snapshots[.codex] = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            updatedAt: now.addingTimeInterval(1))
+        let fallback = try #require(controller.menuCardModel(for: .codex))
+        let inFlight = controller.menuCardRefreshMonitor.model(for: .codex, fallback: fallback)
+
+        #expect(frozen.metrics.count == 3)
+        #expect(fallback.metrics.map(\.id) == ["code-review"])
+        #expect(inFlight.metrics.map(\.id) == frozen.metrics.map(\.id))
+        #expect(inFlight.metrics.first?.percentLabel == "79% left")
+    }
+
+    @Test
+    func `manual refresh uses fallback when empty quota gains credit content`() throws {
+        let settings = self.makeSettings()
+        let controller = self.makeController(
+            settings: settings,
+            account: AccountInfo(email: "test@example.com", plan: "pro"))
+        let now = Date()
+        controller.store.snapshots[.codex] = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 21,
+                windowMinutes: 300,
+                resetsAt: now.addingTimeInterval(3600),
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: now)
+        let frozen = try #require(controller.menuCardModel(for: .codex))
+        controller.menuCardRefreshMonitor.beginManualRefresh(frozenModels: [.codex: frozen])
+
+        controller.store.snapshots[.codex] = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            updatedAt: now.addingTimeInterval(1))
+        controller.store.credits = CreditsSnapshot(
+            remaining: 42,
+            events: [],
+            updatedAt: now.addingTimeInterval(1))
+        let fallback = try #require(controller.menuCardModel(for: .codex))
+        let inFlight = controller.menuCardRefreshMonitor.model(for: .codex, fallback: fallback)
+
+        #expect(frozen.metrics.count == 1)
+        #expect(fallback.metrics.isEmpty)
+        #expect(fallback.creditsText != nil)
+        #expect(inFlight.metrics.isEmpty)
+        #expect(inFlight.creditsText == fallback.creditsText)
+    }
+
+    @Test
+    func `manual refresh uses fallback when empty quota gains a placeholder`() throws {
+        let settings = self.makeSettings()
+        let controller = self.makeController(settings: settings)
+        let now = Date()
+        controller.store.snapshots[.claude] = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 21,
+                windowMinutes: 300,
+                resetsAt: now.addingTimeInterval(3600),
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: now)
+        let frozen = try #require(controller.menuCardModel(for: .claude))
+        controller.menuCardRefreshMonitor.beginManualRefresh(frozenModels: [.claude: frozen])
+
+        controller.store.snapshots.removeValue(forKey: .claude)
+        let fallback = try #require(controller.menuCardModel(for: .claude))
+        let inFlight = controller.menuCardRefreshMonitor.model(for: .claude, fallback: fallback)
+
+        #expect(frozen.metrics.count == 1)
+        #expect(fallback.metrics.isEmpty)
+        #expect(fallback.placeholder != nil)
+        #expect(inFlight.metrics.isEmpty)
+        #expect(inFlight.placeholder == fallback.placeholder)
+    }
+
+    @Test
+    func `refresh monitor updates single line credit balances`() throws {
+        let settings = self.makeSettings()
+        let controller = self.makeController(
+            settings: settings,
+            account: AccountInfo(email: "test@example.com", plan: "pro"))
+        let now = Date()
+        controller.store.snapshots[.codex] = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 10,
+                windowMinutes: 300,
+                resetsAt: now.addingTimeInterval(3600),
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: now)
+        controller.store.credits = CreditsSnapshot(remaining: 80, events: [], updatedAt: now)
+        let fallback = try #require(controller.menuCardModel(for: .codex))
+
+        controller.store.credits = CreditsSnapshot(
+            remaining: 42,
+            events: [],
+            updatedAt: now.addingTimeInterval(1))
+        let refreshed = controller.menuCardRefreshMonitor.model(for: .codex, fallback: fallback)
+
+        #expect(refreshed.creditsRemaining == 42)
+        #expect(refreshed.creditsText != fallback.creditsText)
+    }
+
+    @Test
+    func `refresh monitor preserves multiline workspace credit text`() throws {
+        let settings = self.makeSettings()
+        let controller = self.makeController(settings: settings)
+        controller.store.snapshots[.amp] = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            ampUsage: AmpUsageDetails(
+                individualCredits: 12,
+                workspaceBalances: [AmpWorkspaceBalance(name: "Team", remaining: 7)]),
+            updatedAt: Date())
+        let fallback = try #require(controller.menuCardModel(for: .amp))
+
+        controller.store.snapshots[.amp] = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            ampUsage: AmpUsageDetails(
+                individualCredits: 10,
+                workspaceBalances: [AmpWorkspaceBalance(name: "Team", remaining: 3)]),
+            updatedAt: Date())
+        let refreshed = controller.menuCardRefreshMonitor.model(for: .amp, fallback: fallback)
+
+        #expect(refreshed.creditsText == fallback.creditsText)
+    }
+
+    @Test
+    func `refresh monitor preserves tracked layout when refresh adds usage sections`() throws {
+        let settings = self.makeSettings()
+        let controller = self.makeController(settings: settings)
+        let fallback = try #require(controller.menuCardModel(for: .claude))
+        #expect(fallback.metrics.isEmpty)
+
+        controller.store.snapshots[.claude] = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 25,
+                windowMinutes: 300,
+                resetsAt: Date().addingTimeInterval(3600),
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())
+
+        let refreshed = controller.menuCardRefreshMonitor.model(for: .claude, fallback: fallback)
+
+        #expect(refreshed.metrics.isEmpty)
+        #expect(refreshed.placeholder == fallback.placeholder)
+    }
+
+    @Test
+    func `refresh monitor preserves tracked layout when token error appears`() throws {
+        let settings = self.makeSettings()
+        settings.costUsageEnabled = true
+        let controller = self.makeController(settings: settings)
+        controller.store._setTokenSnapshotForTesting(Self.makeTokenSnapshot(), provider: .claude)
+        let fallback = try #require(controller.menuCardModel(for: .claude))
+        #expect(fallback.tokenUsage?.errorLine == nil)
+
+        controller.store._setTokenErrorForTesting("New token usage error", provider: .claude)
+        let refreshed = controller.menuCardRefreshMonitor.model(for: .claude, fallback: fallback)
+
+        #expect(refreshed.tokenUsage?.errorLine == nil)
+    }
+
+    @Test
+    func `refresh monitor preserves tracked layout when token error text changes`() throws {
+        let settings = self.makeSettings()
+        settings.costUsageEnabled = true
+        let controller = self.makeController(settings: settings)
+        controller.store._setTokenSnapshotForTesting(Self.makeTokenSnapshot(), provider: .claude)
+        controller.store._setTokenErrorForTesting("Old token usage error", provider: .claude)
+        let fallback = try #require(controller.menuCardModel(for: .claude))
+
+        controller.store._setTokenErrorForTesting(
+            "A longer replacement error that could occupy more lines",
+            provider: .claude)
+        let refreshed = controller.menuCardRefreshMonitor.model(for: .claude, fallback: fallback)
+
+        #expect(refreshed.tokenUsage?.errorLine == "Old token usage error")
+    }
+
+    @Test
+    func `live subtitle preserves canonical model error filtering`() throws {
+        let settings = self.makeSettings()
+        let controller = self.makeController(
+            settings: settings,
+            account: AccountInfo(email: "test@example.com", plan: "pro"))
+        controller.store.errors[.codex] = UsageError.noRateLimitsFound.errorDescription
+        let model = try #require(controller.menuCardModel(for: .codex))
+        let fallback = MenuCardLiveSubtitle(text: "Fallback", style: .error)
+
+        let liveSubtitle = controller.menuCardRefreshMonitor.subtitle(for: .codex, fallback: fallback)
+
+        #expect(liveSubtitle.text == model.subtitleText)
+        #expect(liveSubtitle.style == model.subtitleStyle)
+        #expect(liveSubtitle.text != UsageError.noRateLimitsFound.errorDescription)
+        #expect(liveSubtitle.style != .error)
+    }
+
+    @Test
+    func `override cards keep their own subtitle`() throws {
+        let settings = self.makeSettings()
+        let controller = self.makeController(settings: settings)
+        let liveModel = try #require(controller.menuCardModel(for: .codex))
+        let overrideModel = try #require(controller.menuCardModel(
+            for: .codex,
+            errorOverride: "Account unavailable",
+            forceOverrideCard: true))
+
+        #expect(liveModel.usesLiveSubtitle)
+        #expect(!overrideModel.usesLiveSubtitle)
+        #expect(overrideModel.subtitleText == "Account unavailable")
+    }
+
+    @Test
+    func `live failure keeps the measured card height`() throws {
+        let settings = self.makeSettings()
+        let controller = self.makeController(settings: settings)
+
+        func fittingHeight(for model: UsageMenuCardView.Model) -> CGFloat {
+            NSHostingView(rootView: UsageMenuCardView(model: model, width: 320)
+                .environment(\.menuCardRefreshMonitor, controller.menuCardRefreshMonitor))
+                .fittingSize.height
+        }
+
+        let idleModel = try #require(controller.menuCardModel(for: .codex))
+        let idleHeight = fittingHeight(for: idleModel)
+        controller.store.errors[.codex] = "Short error"
+        let failureHeight = fittingHeight(for: idleModel)
+
+        #expect(failureHeight == idleHeight)
+
+        let errorModel = try #require(controller.menuCardModel(for: .codex))
+        let errorHeight = fittingHeight(for: errorModel)
+        controller.store.errors[.codex] =
+            "Refresh failed with a much longer replacement message that must not resize the tracked menu"
+        let replacementErrorHeight = fittingHeight(for: errorModel)
+        controller.menuCardRefreshMonitor.isManualRefreshInFlight = true
+        let retryHeight = fittingHeight(for: errorModel)
+
+        #expect(replacementErrorHeight == errorHeight)
+        let fallback = MenuCardLiveSubtitle(text: errorModel.subtitleText, style: errorModel.subtitleStyle)
+        #expect(controller.menuCardRefreshMonitor.subtitle(for: .codex, fallback: fallback).style == .loading)
+        #expect(retryHeight == errorHeight)
+    }
+
+    @Test
+    func `manual refresh is suppressed after shutdown preparation`() {
+        let settings = self.makeSettings()
+        let controller = self.makeController(settings: settings)
+        var requestCount = 0
+        controller._test_manualRefreshOperation = {
+            requestCount += 1
+        }
+
+        controller.prepareForAppShutdown()
+        controller.refreshNow()
+
+        #expect(requestCount == 0)
+        #expect(controller.manualRefreshTask == nil)
+        #expect(!controller.menuCardRefreshMonitor.isManualRefreshInFlight)
+    }
+
+    @Test
+    func `repeated manual refresh clicks share one lifecycle`() async throws {
+        let settings = self.makeSettings()
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+
+        let controller = self.makeController(settings: settings)
+
+        let gate = ManualRefreshGate()
+        var requestCount = 0
+        controller._test_manualRefreshOperation = {
+            requestCount += 1
+            await gate.wait()
+        }
+
+        controller.refreshNow()
+        let task = try #require(controller.manualRefreshTask)
+        controller.refreshNow()
+        controller.refreshNow()
+        await Task.yield()
+
+        #expect(requestCount == 1)
+        #expect(controller.menuCardRefreshMonitor.isManualRefreshInFlight)
+
+        gate.resume()
+        await task.value
+
+        #expect(controller.manualRefreshTask == nil)
+        #expect(!controller.menuCardRefreshMonitor.isManualRefreshInFlight)
+    }
+
+    @Test
+    func `provider menu persistent refresh row and command R refresh only that provider`() async throws {
+        let settings = self.makeSettings()
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        self.enableOnly([.claude, .codex], settings: settings)
+
+        let controller = self.makeController(settings: settings)
+        let menu = try #require(controller.makeMenu(for: .claude) as? StatusItemMenu)
+        let codexMenu = try #require(controller.makeMenu(for: .codex) as? StatusItemMenu)
+        controller.menuWillOpen(menu)
+        controller.menuWillOpen(codexMenu)
+        defer {
+            controller.menuDidClose(codexMenu)
+            controller.menuDidClose(menu)
+        }
+
+        let mouseGate = ManualRefreshGate()
+        var requestCount = 0
+        controller._test_manualRefreshOperation = {
+            requestCount += 1
+            await mouseGate.wait()
+        }
+        let refreshItem = try #require(menu.items.first { $0.title == "Refresh" })
+        #expect(controller.isPersistentRefreshItem(refreshItem))
+        controller.performPersistentRefreshAction(in: ObjectIdentifier(menu))
+        for _ in 0..<20 where controller.manualRefreshTask == nil {
+            await Task.yield()
+        }
+        let mouseTask = try #require(controller.manualRefreshTask)
+        #expect(controller.manualRefreshProvider == .claude)
+        #expect(controller.isRefreshActionInFlight(for: codexMenu))
+        #expect(controller.isRefreshActionInFlight(for: NSMenu()))
+        let codexRefreshItem = try #require(codexMenu.items.first { $0.title == "Refresh" })
+        #expect(controller.isPersistentRefreshItem(codexRefreshItem))
+        controller.performPersistentRefreshAction(in: ObjectIdentifier(codexMenu))
+        await Task.yield()
+        #expect(requestCount == 1)
+        mouseGate.resume()
+        await mouseTask.value
+
+        let keyboardGate = ManualRefreshGate()
+        controller._test_manualRefreshOperation = { await keyboardGate.wait() }
+        #expect(try menu.performKeyEquivalent(with: self.keyEvent("r", keyCode: 15)))
+        for _ in 0..<20 where controller.manualRefreshTask == nil {
+            await Task.yield()
+        }
+        let keyboardTask = try #require(controller.manualRefreshTask)
+        #expect(controller.manualRefreshProvider == .claude)
+        keyboardGate.resume()
+        await keyboardTask.value
+    }
+
+    @Test
+    func `provider menu does not replace matching scoped refresh`() async throws {
+        let settings = self.makeSettings()
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        self.enableOnly([.claude, .codex], settings: settings)
+
+        let controller = self.makeController(settings: settings)
+        let menu = try #require(controller.makeMenu(for: .claude) as? StatusItemMenu)
+        controller.menuWillOpen(menu)
+        defer { controller.menuDidClose(menu) }
+
+        controller.store.refreshingProviders.insert(.claude)
+        var requestCount = 0
+        controller._test_manualRefreshOperation = { requestCount += 1 }
+
+        let refreshItem = try #require(menu.items.first { $0.title == "Refresh" })
+        #expect(controller.isPersistentRefreshItem(refreshItem))
+        controller.performPersistentRefreshAction(in: ObjectIdentifier(menu))
+        #expect(try menu.performKeyEquivalent(with: self.keyEvent("r", keyCode: 15)))
+        for _ in 0..<20 {
+            await Task.yield()
+        }
+
+        #expect(requestCount == 0)
+        #expect(controller.manualRefreshTask == nil)
+        #expect(controller.manualRefreshProvider == nil)
+    }
+
+    @Test
+    func `merged overview refreshes globally while selected provider stays scoped`() async throws {
+        let settings = self.makeSettings()
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        self.enableOnly([.claude, .codex], settings: settings)
+        settings.mergedMenuLastSelectedWasOverview = true
+
+        let controller = self.makeController(settings: settings)
+        let menu = try #require(controller.makeMenu() as? StatusItemMenu)
+        controller.mergedMenu = menu
+        controller.menuWillOpen(menu)
+        defer { controller.menuDidClose(menu) }
+
+        let overviewGate = ManualRefreshGate()
+        controller._test_manualRefreshOperation = { await overviewGate.wait() }
+        let refreshItem = try #require(menu.items.first { $0.title == "Refresh" })
+        #expect(controller.isPersistentRefreshItem(refreshItem))
+        controller.performPersistentRefreshAction(in: ObjectIdentifier(menu))
+        for _ in 0..<20 where controller.manualRefreshTask == nil {
+            await Task.yield()
+        }
+        let overviewTask = try #require(controller.manualRefreshTask)
+        #expect(controller.manualRefreshProvider == nil)
+        overviewGate.resume()
+        await overviewTask.value
+
+        settings.mergedMenuLastSelectedWasOverview = false
+        controller.selectedMenuProvider = .claude
+        let providerGate = ManualRefreshGate()
+        controller._test_manualRefreshOperation = { await providerGate.wait() }
+        #expect(try menu.performKeyEquivalent(with: self.keyEvent("r", keyCode: 15)))
+        for _ in 0..<20 where controller.manualRefreshTask == nil {
+            await Task.yield()
+        }
+        let providerTask = try #require(controller.manualRefreshTask)
+        #expect(controller.manualRefreshProvider == .claude)
+        providerGate.resume()
+        await providerTask.value
+    }
+
+    @Test
+    func `provider scoped refresh updates status and widget snapshot`() async {
+        let settings = self.makeSettings()
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = true
+        self.enableOnly([.synthetic], settings: settings)
+
+        let controller = self.makeController(settings: settings)
+        controller.store._test_providerRefreshOverride = { _ in }
+        controller.store._test_providerStatusFetchOverride = { provider in
+            #expect(provider == .synthetic)
+            return ProviderStatus(indicator: .none, description: "Operational", updatedAt: Date())
+        }
+        var savedSnapshots = 0
+        controller.store._test_widgetSnapshotSaveOverride = { _ in
+            savedSnapshots += 1
+        }
+
+        await controller.performStoreRefresh(
+            for: .synthetic,
+            refreshOpenMenusWhenComplete: false,
+            interaction: .userInitiated)
+        _ = await controller.store.widgetSnapshotPersistTask?.result
+
+        #expect(controller.store.statuses[.synthetic]?.description == "Operational")
+        #expect(savedSnapshots == 1)
+    }
+
+    @Test
+    func `failed manual refresh returns native item to enabled and surfaces error`() async throws {
+        let settings = self.makeSettings()
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+
+        let controller = self.makeController(settings: settings)
+        let menu = controller.makeMenu(for: .codex)
+        controller.menuWillOpen(menu)
+        let refreshItem = try #require(menu.items.first { $0.title == "Refresh" })
+        let gate = ManualRefreshGate()
+
+        controller._test_manualRefreshOperation = {
+            await gate.wait()
+            controller.store.errors[.codex] = "Refresh failed"
+        }
+
+        controller.refreshNow()
+        let task = try #require(controller.manualRefreshTask)
+        #expect(!refreshItem.isEnabled)
+
+        gate.resume()
+        await task.value
+
+        #expect(controller.manualRefreshTask == nil)
+        #expect(refreshItem.isEnabled)
+        let fallback = MenuCardLiveSubtitle(text: "Fallback", style: .info)
+        #expect(controller.menuCardRefreshMonitor.subtitle(for: .codex, fallback: fallback).style == .error)
+    }
+
+    @Test
+    func `status item menu intercepts persistent shortcuts without native item selection`() throws {
+        let menu = StatusItemMenu()
+        let recorder = RefreshShortcutRecorder()
+        menu.persistentActionDelegate = recorder
+
+        #expect(try menu.performKeyEquivalent(with: self.keyEvent("r", keyCode: 15)) == true)
+        #expect(try menu.performKeyEquivalent(with: self.keyEvent(",", keyCode: 43)) == true)
+        #expect(try menu.performKeyEquivalent(with: self.keyEvent("q", keyCode: 12)) == true)
+
+        #expect(recorder.refreshCount == 1)
+        #expect(recorder.refreshMenuIDs == [ObjectIdentifier(menu)])
+        #expect(recorder.settingsCount == 1)
+        #expect(recorder.quitCount == 1)
+    }
+
+    private func keyEvent(_ characters: String, keyCode: UInt16) throws -> NSEvent {
+        try #require(NSEvent.keyEvent(
+            with: .keyDown,
+            location: .zero,
+            modifierFlags: [.command],
+            timestamp: 0,
+            windowNumber: 0,
+            context: nil,
+            characters: characters,
+            charactersIgnoringModifiers: characters,
+            isARepeat: false,
+            keyCode: keyCode))
+    }
+}
diff --git a/Tests/CodexBarTests/StatusMenuReadinessBaselineTests.swift b/Tests/CodexBarTests/StatusMenuReadinessBaselineTests.swift
new file mode 100644
index 0000000000..f13add449f
--- /dev/null
+++ b/Tests/CodexBarTests/StatusMenuReadinessBaselineTests.swift
@@ -0,0 +1,645 @@
+import AppKit
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+extension StatusMenuTests {
+    @Test
+    func `reopening root menu resyncs readiness baseline so reverted store data still refreshes`() {
+        // Regression for the readiness-signature optimization (#1351): the baseline is no longer
+        // recomputed on every store change while menus are closed, so it must be re-anchored when a
+        // root menu opens. Otherwise a closed-then-reopened menu built from new data, followed by an
+        // open-menu change that reverts to the *previous* baseline value, would be treated as
+        // "unchanged" and skip the rebuild, leaving the visible menu showing stale content.
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.costUsageEnabled = true
+        self.enableOnlyCodexForReadinessBaseline(settings)
+
+        let snapshotA = self.makeReadinessBaselineTokenSnapshot(
+            sessionTokens: 111,
+            sessionCostUSD: 1.11,
+            last30DaysTokens: 1111,
+            last30DaysCostUSD: 11.11,
+            updatedAt: Date(timeIntervalSince1970: 100))
+        let snapshotB = self.makeReadinessBaselineTokenSnapshot(
+            sessionTokens: 222,
+            sessionCostUSD: 2.22,
+            last30DaysTokens: 2222,
+            last30DaysCostUSD: 22.22,
+            updatedAt: Date(timeIntervalSince1970: 200))
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store._setTokenSnapshotForTesting(snapshotA, provider: .codex)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        let menu = controller.makeMenu()
+
+        // Root open anchors the baseline to snapshot A. Normalize via an explicit comparison so the
+        // assertion below is independent of whatever the controller's initial baseline happened to be.
+        controller.menuWillOpen(menu)
+        _ = controller.didMenuAdjunctReadinessChange()
+        controller.menuDidClose(menu)
+
+        // Closed store change to B: the optimization intentionally skips recomputing the baseline here.
+        store._setTokenSnapshotForTesting(snapshotB, provider: .codex)
+
+        // Reopening the root menu rebuilds from B and must re-anchor the baseline to B.
+        controller.menuWillOpen(menu)
+        controller.menuDidClose(menu)
+
+        // Reverting to A (the value the *first* baseline held) must still register as a change.
+        store._setTokenSnapshotForTesting(snapshotA, provider: .codex)
+        #expect(controller.didMenuAdjunctReadinessChange())
+    }
+
+    @Test
+    func `root open during in flight refresh preserves stale content and does not resync baseline`() {
+        // When `refreshMenuForOpenIfNeeded` keeps existing menu content during an in-flight provider
+        // refresh, the readiness baseline must not be re-anchored to live store data. Otherwise the
+        // refresh-completion store mutation would compare equal against the prematurely resynced baseline
+        // and skip the rebuild, leaving stale content visible (#1351).
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.costUsageEnabled = true
+        self.enableOnlyCodexForReadinessBaseline(settings)
+
+        let snapshotA = self.makeReadinessBaselineTokenSnapshot(
+            sessionTokens: 111,
+            sessionCostUSD: 1.11,
+            last30DaysTokens: 1111,
+            last30DaysCostUSD: 11.11,
+            updatedAt: Date(timeIntervalSince1970: 100))
+        let snapshotB = self.makeReadinessBaselineTokenSnapshot(
+            sessionTokens: 222,
+            sessionCostUSD: 2.22,
+            last30DaysTokens: 2222,
+            last30DaysCostUSD: 22.22,
+            updatedAt: Date(timeIntervalSince1970: 200))
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store._setTokenSnapshotForTesting(snapshotA, provider: .codex)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        let menu = controller.makeMenu()
+        controller.populateMenu(menu, provider: .codex)
+        controller.markMenuFresh(menu)
+        let key = ObjectIdentifier(menu)
+        let openedVersion = controller.menuVersions[key]
+
+        store.isRefreshing = true
+        store._setTokenSnapshotForTesting(snapshotB, provider: .codex)
+        controller.invalidateMenus(allowStaleContentDuringDataRefresh: true)
+
+        #expect(controller.menuContentVersion != openedVersion)
+        #expect(controller.menuVersions[key] == openedVersion)
+
+        controller.menuWillOpen(menu)
+        defer { controller.menuDidClose(menu) }
+
+        // Stale content was preserved: the menu is still behind the current content version.
+        #expect(controller.menuNeedsRefresh(menu))
+
+        store.isRefreshing = false
+        // Refresh completion must still register as a readiness change so the open menu can rebuild.
+        #expect(controller.didMenuAdjunctReadinessChange())
+    }
+
+    @Test
+    func `native merged menu preparation during in flight refresh preserves stale menu freshness`() throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.costUsageEnabled = true
+        self.enableOnlyCodexForReadinessBaseline(settings)
+        if let claudeMetadata = ProviderRegistry.shared.metadata[.claude] {
+            settings.setProviderEnabled(provider: .claude, metadata: claudeMetadata, enabled: true)
+        }
+
+        let snapshotA = self.makeReadinessBaselineTokenSnapshot(
+            sessionTokens: 111,
+            sessionCostUSD: 1.11,
+            last30DaysTokens: 1111,
+            last30DaysCostUSD: 11.11,
+            updatedAt: Date(timeIntervalSince1970: 100))
+        let snapshotB = self.makeReadinessBaselineTokenSnapshot(
+            sessionTokens: 222,
+            sessionCostUSD: 2.22,
+            last30DaysTokens: 2222,
+            last30DaysCostUSD: 22.22,
+            updatedAt: Date(timeIntervalSince1970: 200))
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store._setTokenSnapshotForTesting(snapshotA, provider: .codex)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        let menu = try #require(controller.statusItem.menu)
+        #expect(menu === controller.mergedMenu)
+        controller.menuNeedsUpdate(menu)
+        let key = ObjectIdentifier(menu)
+        let preparedVersion = controller.menuVersions[key]
+
+        store.isRefreshing = true
+        store._setTokenSnapshotForTesting(snapshotB, provider: .codex)
+        controller.invalidateMenus(allowStaleContentDuringDataRefresh: true)
+
+        controller.menuNeedsUpdate(menu)
+
+        #expect(controller.menuVersions[key] == preparedVersion)
+        #expect(controller.menuNeedsRefresh(menu))
+    }
+
+    @Test
+    func `root open before deferred store observation rebuilds and refreshes matching observer`() {
+        // Store observation invalidates menus from a deferred main-actor task. If a closed menu opens after
+        // live data changes but before that task runs, it must rebuild from live data and let the matching
+        // observer invalidate any coalesced non-readiness menu state without losing the readiness baseline.
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.costUsageEnabled = true
+        self.enableOnlyCodexForReadinessBaseline(settings)
+
+        let snapshotA = self.makeReadinessBaselineTokenSnapshot(
+            sessionTokens: 111,
+            sessionCostUSD: 1.11,
+            last30DaysTokens: 1111,
+            last30DaysCostUSD: 11.11,
+            updatedAt: Date(timeIntervalSince1970: 100))
+        let snapshotB = self.makeReadinessBaselineTokenSnapshot(
+            sessionTokens: 222,
+            sessionCostUSD: 2.22,
+            last30DaysTokens: 2222,
+            last30DaysCostUSD: 22.22,
+            updatedAt: Date(timeIntervalSince1970: 200))
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store._setTokenSnapshotForTesting(snapshotA, provider: .codex)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        let menu = controller.makeMenu()
+        controller.populateMenu(menu, provider: .codex)
+        controller.markMenuFresh(menu)
+        controller.resyncMenuAdjunctReadinessBaseline()
+
+        // Simulate the live store mutation being visible before the observation task has invalidated menus.
+        store._setTokenSnapshotForTesting(snapshotB, provider: .codex)
+        controller.menuWillOpen(menu)
+        defer { controller.menuDidClose(menu) }
+
+        let key = ObjectIdentifier(menu)
+        let versionAfterOpen = controller.menuContentVersion
+        let menuVersionAfterOpen = controller.menuVersions[key]
+        #expect(!controller.menuNeedsRefresh(menu))
+
+        controller.handleObservedStoreMenuChange()
+
+        #expect(controller.menuContentVersion != versionAfterOpen)
+        #expect(controller.menuVersions[key] == menuVersionAfterOpen)
+        #expect(controller.menuNeedsRefresh(menu))
+        #expect(!controller.didMenuAdjunctReadinessChange())
+    }
+
+    @Test
+    func `root open before deferred store observation during refresh leaves observer pending`() {
+        // The pre-observer root-open repair must not bypass the in-flight refresh stale-content path.
+        // While data is refreshing, the deferred observer should still invalidate the open menu and defer
+        // parent rebuild instead of marking an intermediate snapshot fresh.
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.costUsageEnabled = true
+        self.enableOnlyCodexForReadinessBaseline(settings)
+
+        let snapshotA = self.makeReadinessBaselineTokenSnapshot(
+            sessionTokens: 111,
+            sessionCostUSD: 1.11,
+            last30DaysTokens: 1111,
+            last30DaysCostUSD: 11.11,
+            updatedAt: Date(timeIntervalSince1970: 100))
+        let snapshotB = self.makeReadinessBaselineTokenSnapshot(
+            sessionTokens: 222,
+            sessionCostUSD: 2.22,
+            last30DaysTokens: 2222,
+            last30DaysCostUSD: 22.22,
+            updatedAt: Date(timeIntervalSince1970: 200))
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store._setTokenSnapshotForTesting(snapshotA, provider: .codex)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        let menu = controller.makeMenu()
+        controller.populateMenu(menu, provider: .codex)
+        controller.markMenuFresh(menu)
+        controller.resyncMenuAdjunctReadinessBaseline()
+
+        store.isRefreshing = true
+        store._setTokenSnapshotForTesting(snapshotB, provider: .codex)
+        controller.menuWillOpen(menu)
+        defer { controller.menuDidClose(menu) }
+
+        let versionAfterOpen = controller.menuContentVersion
+        #expect(!controller.menuNeedsRefresh(menu))
+
+        controller.handleObservedStoreMenuChange()
+
+        #expect(controller.menuContentVersion != versionAfterOpen)
+        #expect(controller.menuNeedsRefresh(menu))
+        #expect(!controller.didMenuAdjunctReadinessChange())
+    }
+
+    @Test
+    func `fresh newer-version root open during unrelated refresh still reanchors baseline`() {
+        // An in-flight refresh elsewhere must not block re-anchoring when this menu was already rebuilt for
+        // a newer menuContentVersion. Otherwise the stale baseline can still hide a later reverted update.
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.costUsageEnabled = true
+        self.enableOnlyCodexForReadinessBaseline(settings)
+
+        let snapshotA = self.makeReadinessBaselineTokenSnapshot(
+            sessionTokens: 111,
+            sessionCostUSD: 1.11,
+            last30DaysTokens: 1111,
+            last30DaysCostUSD: 11.11,
+            updatedAt: Date(timeIntervalSince1970: 100))
+        let snapshotB = self.makeReadinessBaselineTokenSnapshot(
+            sessionTokens: 222,
+            sessionCostUSD: 2.22,
+            last30DaysTokens: 2222,
+            last30DaysCostUSD: 22.22,
+            updatedAt: Date(timeIntervalSince1970: 200))
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store._setTokenSnapshotForTesting(snapshotA, provider: .codex)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        let menu = controller.makeMenu()
+        controller.populateMenu(menu, provider: .codex)
+        controller.markMenuFresh(menu)
+        controller.resyncMenuAdjunctReadinessBaseline()
+
+        store._setTokenSnapshotForTesting(snapshotB, provider: .codex)
+        controller.invalidateMenus()
+        controller.populateMenu(menu, provider: .codex)
+        controller.markMenuFresh(menu)
+
+        store.isRefreshing = true
+        controller.menuWillOpen(menu)
+        defer { controller.menuDidClose(menu) }
+
+        store._setTokenSnapshotForTesting(snapshotA, provider: .codex)
+        #expect(controller.didMenuAdjunctReadinessChange())
+    }
+
+    @Test
+    func `equal-signature root open advances baseline version before next pre-observer change`() {
+        // A root open whose signature still equals the baseline can nevertheless confirm that the visible
+        // menu is fresh for a newer menuContentVersion. Record that version so a later live-data change before
+        // its deferred observer does not look like already-rendered data.
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.costUsageEnabled = true
+        self.enableOnlyCodexForReadinessBaseline(settings)
+
+        let snapshotA = self.makeReadinessBaselineTokenSnapshot(
+            sessionTokens: 111,
+            sessionCostUSD: 1.11,
+            last30DaysTokens: 1111,
+            last30DaysCostUSD: 11.11,
+            updatedAt: Date(timeIntervalSince1970: 100))
+        let snapshotB = self.makeReadinessBaselineTokenSnapshot(
+            sessionTokens: 222,
+            sessionCostUSD: 2.22,
+            last30DaysTokens: 2222,
+            last30DaysCostUSD: 22.22,
+            updatedAt: Date(timeIntervalSince1970: 200))
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store._setTokenSnapshotForTesting(snapshotA, provider: .codex)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        let menu = controller.makeMenu(for: .codex)
+        controller.providerMenus[.codex] = menu
+        controller.populateMenu(menu, provider: .codex)
+        controller.markMenuFresh(menu)
+        controller.resyncMenuAdjunctReadinessBaseline()
+
+        controller.invalidateMenus()
+        controller.populateMenu(menu, provider: .codex)
+        controller.markMenuFresh(menu)
+        controller.menuWillOpen(menu)
+        controller.menuDidClose(menu)
+
+        let versionBeforeChange = controller.menuContentVersion
+        store._setTokenSnapshotForTesting(snapshotB, provider: .codex)
+        controller.menuWillOpen(menu)
+        defer { controller.menuDidClose(menu) }
+
+        #expect(controller.menuContentVersion != versionBeforeChange)
+        #expect(!controller.menuNeedsRefresh(menu))
+        #expect(!controller.didMenuAdjunctReadinessChange())
+    }
+
+    @Test
+    func `newer-version root open rebuilds when rendered signature is older than live data`() {
+        // A menu can be fresh for the current menuContentVersion while still having rendered an older
+        // readiness signature than the current live store. Root open must rebuild in that pre-observer gap.
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.costUsageEnabled = true
+        self.enableOnlyCodexForReadinessBaseline(settings)
+
+        let snapshotA = self.makeReadinessBaselineTokenSnapshot(
+            sessionTokens: 111,
+            sessionCostUSD: 1.11,
+            last30DaysTokens: 1111,
+            last30DaysCostUSD: 11.11,
+            updatedAt: Date(timeIntervalSince1970: 100))
+        let snapshotB = self.makeReadinessBaselineTokenSnapshot(
+            sessionTokens: 222,
+            sessionCostUSD: 2.22,
+            last30DaysTokens: 2222,
+            last30DaysCostUSD: 22.22,
+            updatedAt: Date(timeIntervalSince1970: 200))
+        let snapshotC = self.makeReadinessBaselineTokenSnapshot(
+            sessionTokens: 333,
+            sessionCostUSD: 3.33,
+            last30DaysTokens: 3333,
+            last30DaysCostUSD: 33.33,
+            updatedAt: Date(timeIntervalSince1970: 300))
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store._setTokenSnapshotForTesting(snapshotA, provider: .codex)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        let menu = controller.makeMenu(for: .codex)
+        controller.providerMenus[.codex] = menu
+        controller.populateMenu(menu, provider: .codex)
+        controller.markMenuFresh(menu)
+        controller.resyncMenuAdjunctReadinessBaseline()
+
+        store._setTokenSnapshotForTesting(snapshotB, provider: .codex)
+        controller.invalidateMenus()
+        controller.populateMenu(menu, provider: .codex)
+        controller.markMenuFresh(menu)
+        controller.menuWillOpen(menu)
+        controller.menuDidClose(menu)
+
+        let versionBeforeChange = controller.menuContentVersion
+        store._setTokenSnapshotForTesting(snapshotC, provider: .codex)
+        controller.menuWillOpen(menu)
+        defer { controller.menuDidClose(menu) }
+
+        #expect(controller.menuContentVersion != versionBeforeChange)
+        #expect(!controller.menuNeedsRefresh(menu))
+        #expect(!controller.didMenuAdjunctReadinessChange())
+    }
+
+    @Test
+    func `equal-signature root open rebuilds when rendered signature reverted before observer`() {
+        // A closed provider menu can be rebuilt from B while the readiness baseline remains A. If live data
+        // reverts to A before the deferred observer runs, root open must still repair the B-rendered menu.
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.costUsageEnabled = true
+        self.enableOnlyCodexForReadinessBaseline(settings)
+
+        let snapshotA = self.makeReadinessBaselineTokenSnapshot(
+            sessionTokens: 111,
+            sessionCostUSD: 1.11,
+            last30DaysTokens: 1111,
+            last30DaysCostUSD: 11.11,
+            updatedAt: Date(timeIntervalSince1970: 100))
+        let snapshotB = self.makeReadinessBaselineTokenSnapshot(
+            sessionTokens: 222,
+            sessionCostUSD: 2.22,
+            last30DaysTokens: 2222,
+            last30DaysCostUSD: 22.22,
+            updatedAt: Date(timeIntervalSince1970: 200))
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store._setTokenSnapshotForTesting(snapshotA, provider: .codex)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        let menu = controller.makeMenu(for: .codex)
+        controller.providerMenus[.codex] = menu
+        let key = ObjectIdentifier(menu)
+        controller.populateMenu(menu, provider: .codex)
+        controller.markMenuFresh(menu)
+        controller.resyncMenuAdjunctReadinessBaseline()
+
+        store._setTokenSnapshotForTesting(snapshotB, provider: .codex)
+        controller.invalidateMenus()
+        controller.populateMenu(menu, provider: .codex)
+        controller.markMenuFresh(menu)
+
+        let renderedBSignature = controller.menuReadinessSignatures[key]
+        store._setTokenSnapshotForTesting(snapshotA, provider: .codex)
+        let versionBeforeOpen = controller.menuContentVersion
+        controller.menuWillOpen(menu)
+        defer { controller.menuDidClose(menu) }
+
+        #expect(controller.menuContentVersion != versionBeforeOpen)
+        #expect(controller.menuReadinessSignatures[key] != renderedBSignature)
+        #expect(controller.menuReadinessSignatures[key] == controller.menuAdjunctReadinessSignature())
+        #expect(!controller.didMenuAdjunctReadinessChange())
+    }
+
+    @Test
+    func `provider root open before deferred store observation leaves sibling provider menu stale`() {
+        // The readiness signature is global across enabled providers. In split-icon mode, opening one
+        // provider's menu must not consume a pending global observation while leaving sibling menus marked
+        // fresh even though their provider data changed.
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.costUsageEnabled = true
+        self.enableProvidersForReadinessBaseline(settings, providers: [.claude, .codex])
+
+        let snapshotA = self.makeReadinessBaselineTokenSnapshot(
+            sessionTokens: 111,
+            sessionCostUSD: 1.11,
+            last30DaysTokens: 1111,
+            last30DaysCostUSD: 11.11,
+            updatedAt: Date(timeIntervalSince1970: 100))
+        let snapshotB = self.makeReadinessBaselineTokenSnapshot(
+            sessionTokens: 222,
+            sessionCostUSD: 2.22,
+            last30DaysTokens: 2222,
+            last30DaysCostUSD: 22.22,
+            updatedAt: Date(timeIntervalSince1970: 200))
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        store._setTokenSnapshotForTesting(snapshotA, provider: .claude)
+        store._setTokenSnapshotForTesting(snapshotA, provider: .codex)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+        controller.menuRefreshEnabledOverrideForTesting = true
+
+        let claudeMenu = controller.makeMenu(for: .claude)
+        controller.populateMenu(claudeMenu, provider: .claude)
+        controller.markMenuFresh(claudeMenu)
+        let codexMenu = controller.makeMenu(for: .codex)
+        controller.populateMenu(codexMenu, provider: .codex)
+        controller.markMenuFresh(codexMenu)
+        controller.resyncMenuAdjunctReadinessBaseline()
+
+        store._setTokenSnapshotForTesting(snapshotB, provider: .claude)
+        controller.menuWillOpen(codexMenu)
+        defer { controller.menuDidClose(codexMenu) }
+
+        let versionAfterOpen = controller.menuContentVersion
+        #expect(!controller.menuNeedsRefresh(codexMenu))
+        #expect(controller.menuNeedsRefresh(claudeMenu))
+
+        controller.handleObservedStoreMenuChange()
+
+        #expect(controller.menuContentVersion != versionAfterOpen)
+        #expect(controller.menuNeedsRefresh(codexMenu))
+        #expect(controller.menuNeedsRefresh(claudeMenu))
+        #expect(!controller.didMenuAdjunctReadinessChange())
+    }
+
+    private func enableOnlyCodexForReadinessBaseline(_ settings: SettingsStore) {
+        self.enableProvidersForReadinessBaseline(settings, providers: [.codex])
+    }
+
+    private func enableProvidersForReadinessBaseline(_ settings: SettingsStore, providers: Set<UsageProvider>) {
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: providers.contains(provider))
+        }
+    }
+
+    private func makeReadinessBaselineTokenSnapshot(
+        sessionTokens: Int,
+        sessionCostUSD: Double,
+        last30DaysTokens: Int,
+        last30DaysCostUSD: Double,
+        updatedAt: Date) -> CostUsageTokenSnapshot
+    {
+        CostUsageTokenSnapshot(
+            sessionTokens: sessionTokens,
+            sessionCostUSD: sessionCostUSD,
+            last30DaysTokens: last30DaysTokens,
+            last30DaysCostUSD: last30DaysCostUSD,
+            daily: [
+                CostUsageDailyReport.Entry(
+                    date: "2026-05-24",
+                    inputTokens: nil,
+                    outputTokens: nil,
+                    totalTokens: sessionTokens,
+                    costUSD: last30DaysCostUSD,
+                    modelsUsed: nil,
+                    modelBreakdowns: nil),
+            ],
+            updatedAt: updatedAt)
+    }
+}
diff --git a/Tests/CodexBarTests/StatusMenuScopedCodexRefreshTests.swift b/Tests/CodexBarTests/StatusMenuScopedCodexRefreshTests.swift
new file mode 100644
index 0000000000..532ec780cd
--- /dev/null
+++ b/Tests/CodexBarTests/StatusMenuScopedCodexRefreshTests.swift
@@ -0,0 +1,79 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@MainActor
+@Suite(.serialized)
+struct StatusMenuScopedCodexRefreshTests {
+    @Test
+    func `scoped refresh reconciles usage after dashboard login expires`() async {
+        let settings = self.makeSettings()
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.openAIWebAccessEnabled = true
+        settings.codexCookieSource = .auto
+        self.enableOnlyCodex(settings)
+
+        let account = AccountInfo(email: "test@example.com", plan: "pro")
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        store.accountInfoCache[.codex] = UsageStore.AccountInfoCacheEntry(
+            account: account,
+            configRevision: settings.configRevision,
+            expiresAt: .distantFuture)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: account,
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system)
+
+        var providerRefreshes = 0
+        store._test_providerRefreshOverride = { provider in
+            #expect(provider == .codex)
+            providerRefreshes += 1
+        }
+        store._test_tokenUsageRefreshOverride = { _, _ in }
+        store._test_codexCreditsLoaderOverride = {
+            CreditsSnapshot(remaining: 25, events: [], updatedAt: Date())
+        }
+        store._test_openAIDashboardLoaderOverride = { _, _, _, _ in
+            throw OpenAIDashboardFetcher.FetchError.loginRequired
+        }
+        store._test_openAIDashboardCookieImportOverride = { targetEmail, _, _, _, _ in
+            OpenAIDashboardBrowserCookieImporter.ImportResult(
+                sourceLabel: "Chrome",
+                cookieCount: 2,
+                signedInEmail: targetEmail,
+                matchesCodexEmail: true)
+        }
+
+        await controller.performStoreRefresh(
+            for: .codex,
+            refreshOpenMenusWhenComplete: false,
+            interaction: .userInitiated)
+
+        #expect(store.openAIDashboardRequiresLogin)
+        #expect(providerRefreshes == 2)
+    }
+
+    private func makeSettings() -> SettingsStore {
+        let suite = "StatusMenuScopedCodexRefreshTests-\(UUID().uuidString)"
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        return SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+    }
+
+    private func enableOnlyCodex(_ settings: SettingsStore) {
+        for provider in UsageProvider.allCases {
+            guard let metadata = ProviderRegistry.shared.metadata[provider] else { continue }
+            settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: provider == .codex)
+        }
+    }
+}
diff --git a/Tests/CodexBarTests/StatusMenuSwitcherClickTests.swift b/Tests/CodexBarTests/StatusMenuSwitcherClickTests.swift
new file mode 100644
index 0000000000..a9f77216d8
--- /dev/null
+++ b/Tests/CodexBarTests/StatusMenuSwitcherClickTests.swift
@@ -0,0 +1,915 @@
+import AppKit
+import CodexBarCore
+import Testing
+@testable import CodexBar
+
+@MainActor
+@Suite(.serialized)
+struct StatusMenuSwitcherClickTests {
+    private func makeStatusBarForTesting() -> NSStatusBar {
+        // Use the real system status bar in tests. Creating standalone NSStatusBar instances
+        // has caused AppKit teardown crashes under swiftpm-testing-helper.
+        .system
+    }
+
+    private func makeSettings() -> SettingsStore {
+        let suite = "StatusMenuSwitcherClickTests-\(UUID().uuidString)"
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+        return SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+    }
+
+    private func makeInstalledSwitcherShortcutMonitor() -> (controller: StatusItemController, menu: StatusItemMenu) {
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            let shouldEnable = provider == .codex || provider == .claude
+            settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: shouldEnable)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+
+        let menu = StatusItemMenu()
+        let switcher = ProviderSwitcherView(
+            providers: [.codex, .claude],
+            selected: .provider(.codex),
+            includesOverview: true,
+            width: 320,
+            showsIcons: false,
+            iconProvider: { _ in NSImage() },
+            weeklyRemainingProvider: { _ in nil },
+            onSelect: { _ in })
+        let switcherItem = NSMenuItem()
+        switcherItem.view = switcher
+        menu.addItem(switcherItem)
+        menu.addItem(.separator())
+
+        controller.installProviderSwitcherShortcutMonitorIfNeeded(for: menu)
+        return (controller, menu)
+    }
+
+    @Test
+    func `merged switcher routes runtime clicks after overview round-trip`() throws {
+        // Regression test for #867: after Provider → Overview, subsequent runtime clicks on a
+        // sub-provider tab dropped through NSButton's tracking and never updated state.
+        let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
+        let previousMenuRefresh = StatusItemController.menuRefreshEnabled
+        StatusItemController.menuCardRenderingEnabled = false
+        StatusItemController.setMenuRefreshEnabledForTesting(false)
+        defer {
+            StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering
+            StatusItemController.setMenuRefreshEnabledForTesting(previousMenuRefresh)
+        }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .claude
+        settings.mergedMenuLastSelectedWasOverview = false
+
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            let shouldEnable = provider == .codex || provider == .claude
+            settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: shouldEnable)
+        }
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+
+        // Step 1: provider → Overview via the runtime click path.
+        let switcher1 = try #require(menu.items.first?.view as? ProviderSwitcherView)
+        #expect(switcher1._test_simulateRuntimeClick(buttonTag: 0))
+        #expect(settings.mergedMenuLastSelectedWasOverview == true)
+
+        // Step 2: Overview → provider via the runtime click path. Tag 2 is the second provider
+        // (claude) since tag 0 is Overview and tag 1 is the first provider.
+        let switcher2 = try #require(menu.items.first?.view as? ProviderSwitcherView)
+        #expect(switcher2._test_simulateRuntimeClick(buttonTag: 2))
+        #expect(settings.mergedMenuLastSelectedWasOverview == false)
+        #expect(settings.selectedMenuProvider == .claude)
+
+        // Step 3: provider → Overview again.
+        let switcher3 = try #require(menu.items.first?.view as? ProviderSwitcherView)
+        #expect(switcher3._test_simulateRuntimeClick(buttonTag: 0))
+        #expect(settings.mergedMenuLastSelectedWasOverview == true)
+
+        // Step 4: Overview → other provider. This is the click that previously got dropped.
+        let switcher4 = try #require(menu.items.first?.view as? ProviderSwitcherView)
+        #expect(switcher4._test_simulateRuntimeClick(buttonTag: 1))
+        #expect(settings.mergedMenuLastSelectedWasOverview == false)
+        #expect(settings.selectedMenuProvider == .codex)
+    }
+
+    @Test
+    func `merged switcher commits selection on matching mouse up`() throws {
+        var selections: [ProviderSwitcherSelection] = []
+        let switcher = ProviderSwitcherView(
+            providers: [.codex, .claude],
+            selected: .provider(.codex),
+            includesOverview: true,
+            width: 320,
+            showsIcons: false,
+            iconProvider: { _ in NSImage() },
+            weeklyRemainingProvider: { _ in nil },
+            onSelect: { selections.append($0) })
+
+        #expect(switcher._test_simulateMouseDown(buttonTag: 0))
+        #expect(selections.isEmpty)
+        let mouseUp = try #require(switcher._test_mouseUpEvent(buttonTag: 0))
+        #expect(switcher.handleMenuTrackingMouseUp(mouseUp))
+        #expect(selections == [.overview])
+    }
+
+    @Test
+    func `menu tracking routes switcher pointer sequence before AppKit menu dispatch`() throws {
+        var selected: ProviderSwitcherSelection?
+        let switcher = ProviderSwitcherView(
+            providers: [.codex, .claude],
+            selected: .provider(.codex),
+            includesOverview: true,
+            width: 320,
+            showsIcons: false,
+            iconProvider: { _ in NSImage() },
+            weeklyRemainingProvider: { _ in nil },
+            onSelect: { selected = $0 })
+        let menu = StatusItemMenu()
+        let item = NSMenuItem()
+        item.view = switcher
+        item.isEnabled = false
+        menu.addItem(item)
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        let fetcher = UsageFetcher()
+        let controller = StatusItemController(
+            store: UsageStore(
+                fetcher: fetcher,
+                browserDetection: BrowserDetection(cacheTTL: 0),
+                settings: settings),
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let mouseDown = try #require(switcher._test_mouseDownEvent(buttonTag: 0))
+        let mouseUp = try #require(switcher._test_mouseUpEvent(buttonTag: 0))
+        #expect(controller.handleProviderSwitcherTrackingEvent(mouseDown, menu: menu))
+        #expect(selected == nil)
+        #expect(controller.handleProviderSwitcherTrackingEvent(mouseUp, menu: menu))
+        #expect(selected == .overview)
+    }
+
+    @Test
+    func `merged switcher runtime click defers icon rendering until after event handling`() async throws {
+        let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
+        let previousMenuRefresh = StatusItemController.menuRefreshEnabled
+        StatusItemController.menuCardRenderingEnabled = false
+        StatusItemController.setMenuRefreshEnabledForTesting(false)
+        defer {
+            StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering
+            StatusItemController.setMenuRefreshEnabledForTesting(previousMenuRefresh)
+        }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        settings.mergedMenuLastSelectedWasOverview = false
+
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            let shouldEnable = provider == .codex || provider == .claude
+            settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: shouldEnable)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        controller.applyIcon(phase: nil)
+        #expect(controller.lastAppliedMergedIconRenderSignature?.contains("provider=codex") == true)
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+
+        let switcher = try #require(menu.items.first?.view as? ProviderSwitcherView)
+        #expect(switcher._test_simulateRuntimeClick(buttonTag: 2))
+
+        #expect(settings.selectedMenuProvider == .claude)
+        #expect(controller.lastAppliedMergedIconRenderSignature?.contains("provider=codex") == true)
+        await controller.providerSelectionUIRefreshTask?.value
+        #expect(controller.lastAppliedMergedIconRenderSignature?.contains("provider=claude") == true)
+    }
+
+    @Test
+    func `merged switcher click marks menu stale before deferred rebuild`() throws {
+        let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
+        let previousMenuRefresh = StatusItemController.menuRefreshEnabled
+        StatusItemController.menuCardRenderingEnabled = false
+        StatusItemController.setMenuRefreshEnabledForTesting(true)
+        defer {
+            StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering
+            StatusItemController.setMenuRefreshEnabledForTesting(previousMenuRefresh)
+        }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        settings.mergedMenuLastSelectedWasOverview = false
+
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            let shouldEnable = provider == .codex || provider == .claude
+            settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: shouldEnable)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        controller._test_providerSwitcherMenuRebuildDebounceNanoseconds = UInt64.max
+        defer { controller._test_providerSwitcherMenuRebuildDebounceNanoseconds = nil }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        let key = ObjectIdentifier(menu)
+        #expect(controller.menuVersions[key] == controller.menuContentVersion)
+
+        let openedVersion = controller.menuContentVersion
+        let switcher = try #require(menu.items.first?.view as? ProviderSwitcherView)
+        #expect(switcher._test_simulateRuntimeClick(buttonTag: 2))
+
+        #expect(settings.selectedMenuProvider == .claude)
+        #expect(controller.menuContentVersion != openedVersion)
+        #expect(controller.menuVersions[key] != controller.menuContentVersion)
+
+        controller.menuDidClose(menu)
+        #expect(controller.menuVersions[key] != controller.menuContentVersion)
+        #expect(controller.openMenuRebuildTasks[key] == nil)
+    }
+
+    @Test
+    func `merged switcher runtime click updates loading animation state after event handling`() async throws {
+        let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
+        let previousMenuRefresh = StatusItemController.menuRefreshEnabled
+        StatusItemController.menuCardRenderingEnabled = false
+        StatusItemController.setMenuRefreshEnabledForTesting(false)
+        defer {
+            StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering
+            StatusItemController.setMenuRefreshEnabledForTesting(previousMenuRefresh)
+        }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        settings.mergedMenuLastSelectedWasOverview = false
+
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            let shouldEnable = provider == .codex || provider == .claude
+            settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: shouldEnable)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(usedPercent: 25, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date()),
+            provider: .codex)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        controller.applyIcon(phase: nil)
+        #expect(controller.needsMenuBarIconAnimation() == false)
+        #expect(controller.animationDriver == nil)
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+
+        let switcher = try #require(menu.items.first?.view as? ProviderSwitcherView)
+        #expect(switcher._test_simulateRuntimeClick(buttonTag: 2))
+        #expect(settings.selectedMenuProvider == .claude)
+        await controller.providerSelectionUIRefreshTask?.value
+        #expect(controller.needsMenuBarIconAnimation() == true)
+        #expect(controller.animationDriver != nil)
+        #expect(controller.lastAppliedMergedIconRenderSignature?.contains("provider=claude") == true)
+
+        #expect(switcher._test_simulateRuntimeClick(buttonTag: 1))
+        #expect(settings.selectedMenuProvider == .codex)
+        await controller.providerSelectionUIRefreshTask?.value
+        #expect(controller.needsMenuBarIconAnimation() == false)
+        #expect(controller.animationDriver == nil)
+        #expect(controller.lastAppliedMergedIconRenderSignature?.contains("provider=codex") == true)
+    }
+
+    @Test
+    func `merged switcher switches provider while overview chart submenu is open`() async throws {
+        let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
+        let previousMenuRefresh = StatusItemController.menuRefreshEnabled
+        StatusItemController.menuCardRenderingEnabled = false
+        StatusItemController.setMenuRefreshEnabledForTesting(false)
+        defer {
+            StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering
+            StatusItemController.setMenuRefreshEnabledForTesting(previousMenuRefresh)
+        }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .openai
+        settings.mergedMenuLastSelectedWasOverview = true
+
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            let shouldEnable = provider == .openai || provider == .claude
+            settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: shouldEnable)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let usage = OpenAIAPIUsageSnapshot(
+            daily: [
+                OpenAIAPIUsageSnapshot.DailyBucket(
+                    day: "2023-11-14",
+                    startTime: now,
+                    endTime: now.addingTimeInterval(86400),
+                    costUSD: 9,
+                    requests: 12,
+                    inputTokens: 100,
+                    cachedInputTokens: 0,
+                    outputTokens: 50,
+                    totalTokens: 150,
+                    lineItems: [],
+                    models: []),
+            ],
+            updatedAt: now)
+        store._setSnapshotForTesting(usage.toUsageSnapshot(), provider: .openai)
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        controller.openMenus[ObjectIdentifier(menu)] = menu
+
+        let openAIRow = try #require(menu.items.first {
+            ($0.representedObject as? String) == "overviewRow-openai"
+        })
+        let submenu = try #require(openAIRow.submenu)
+        controller.openMenus[ObjectIdentifier(submenu)] = submenu
+
+        var rebuildCount = 0
+        controller._test_openMenuRebuildObserver = { _ in
+            rebuildCount += 1
+        }
+        defer { controller._test_openMenuRebuildObserver = nil }
+
+        let switcher = try #require(menu.items.first?.view as? ProviderSwitcherView)
+        #expect(switcher._test_simulateRuntimeClick(buttonTag: 2))
+        for _ in 0..<100 where rebuildCount == 0 {
+            await Task.yield()
+            try? await Task.sleep(for: .milliseconds(10))
+        }
+
+        #expect(settings.mergedMenuLastSelectedWasOverview == false)
+        #expect(settings.selectedMenuProvider == .claude)
+        #expect(rebuildCount == 1)
+        #expect(controller.openMenus[ObjectIdentifier(submenu)] == nil)
+
+        let ids = menu.items.compactMap { $0.representedObject as? String }
+        #expect(ids.contains("menuCard"))
+        #expect(ids.contains(where: { $0.hasPrefix("overviewRow-") }) == false)
+    }
+
+    @Test
+    func `merged switcher handles left and right arrow keyboard navigation`() async throws {
+        let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
+        let previousMenuRefresh = StatusItemController.menuRefreshEnabled
+        StatusItemController.menuCardRenderingEnabled = false
+        StatusItemController.setMenuRefreshEnabledForTesting(false)
+        defer {
+            StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering
+            StatusItemController.setMenuRefreshEnabledForTesting(previousMenuRefresh)
+        }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        settings.mergedMenuLastSelectedWasOverview = false
+
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            let shouldEnable = provider == .codex || provider == .claude
+            settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: shouldEnable)
+        }
+        settings.setMergedOverviewProviderSelection(
+            provider: .codex,
+            isSelected: false,
+            activeProviders: [.codex, .claude])
+        settings.setMergedOverviewProviderSelection(
+            provider: .claude,
+            isSelected: false,
+            activeProviders: [.codex, .claude])
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        controller.menuRefreshEnabledOverrideForTesting = true
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = try #require(controller.makeMenu() as? StatusItemMenu)
+        controller.menuWillOpen(menu)
+        #expect(menu.items.first?.view is ProviderSwitcherView)
+        store.tokenRefreshInFlight.insert(.codex)
+        defer { store.tokenRefreshInFlight.remove(.codex) }
+        var rebuildCount = 0
+        controller._test_openMenuRebuildObserver = { _ in
+            rebuildCount += 1
+        }
+        defer { controller._test_openMenuRebuildObserver = nil }
+
+        #expect(try menu.performKeyEquivalent(with: Self.arrowKeyEvent(keyCode: 124)) == true)
+        for _ in 0..<100 where rebuildCount == 0 {
+            await Task.yield()
+            try? await Task.sleep(for: .milliseconds(5))
+        }
+        #expect(settings.mergedMenuLastSelectedWasOverview == false)
+        #expect(settings.selectedMenuProvider == .claude)
+        #expect(rebuildCount == 1)
+
+        #expect(try menu.performKeyEquivalent(with: Self.arrowKeyEvent(keyCode: 123)) == true)
+        for _ in 0..<100 where rebuildCount == 1 {
+            await Task.yield()
+            try? await Task.sleep(for: .milliseconds(5))
+        }
+        #expect(settings.mergedMenuLastSelectedWasOverview == false)
+        #expect(settings.selectedMenuProvider == .codex)
+        #expect(rebuildCount == 2)
+    }
+
+    @Test
+    func `merged switcher handles command number shortcuts in visible order`() async throws {
+        let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
+        let previousMenuRefresh = StatusItemController.menuRefreshEnabled
+        StatusItemController.menuCardRenderingEnabled = false
+        StatusItemController.setMenuRefreshEnabledForTesting(false)
+        defer {
+            StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering
+            StatusItemController.setMenuRefreshEnabledForTesting(previousMenuRefresh)
+        }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        settings.mergedMenuLastSelectedWasOverview = false
+
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            let shouldEnable = provider == .codex || provider == .claude || provider == .cursor
+            settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: shouldEnable)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = try #require(controller.makeMenu() as? StatusItemMenu)
+        controller.menuWillOpen(menu)
+        #expect(menu.items.first?.view is ProviderSwitcherView)
+
+        #expect(try controller.handleProviderSwitcherShortcut(Self.commandKeyEvent("3", keyCode: 20), menu: menu))
+        await Task.yield()
+        #expect(settings.mergedMenuLastSelectedWasOverview == false)
+        #expect(settings.selectedMenuProvider == .claude)
+
+        #expect(try controller.handleProviderSwitcherShortcut(Self.commandKeyEvent("1", keyCode: 18), menu: menu))
+        await Task.yield()
+        #expect(settings.mergedMenuLastSelectedWasOverview == true)
+        #expect(settings.selectedMenuProvider == .claude)
+
+        #expect(try !controller.handleProviderSwitcherShortcut(Self.commandKeyEvent("9", keyCode: 25), menu: menu))
+        await Task.yield()
+        #expect(settings.mergedMenuLastSelectedWasOverview == true)
+        #expect(settings.selectedMenuProvider == .claude)
+    }
+
+    @Test
+    func `provider shortcut monitor is removed when tracked menu closes after switcher rebuild`() {
+        let previousMenuRefresh = StatusItemController.menuRefreshEnabled
+        StatusItemController.setMenuRefreshEnabledForTesting(true)
+        defer {
+            StatusItemController.setMenuRefreshEnabledForTesting(previousMenuRefresh)
+        }
+
+        let (controller, menu) = self.makeInstalledSwitcherShortcutMonitor()
+        defer { controller.releaseStatusItemsForTesting() }
+
+        #expect(controller.providerSwitcherShortcutEventMonitor != nil)
+        #expect(controller.providerSwitcherShortcutMenuID == ObjectIdentifier(menu))
+
+        menu.removeAllItems()
+        controller.menuDidClose(menu)
+
+        #expect(controller.providerSwitcherShortcutEventMonitor == nil)
+        #expect(controller.providerSwitcherShortcutMenuID == nil)
+    }
+
+    @Test
+    func `switcher shortcut monitor is removed from direct close cleanup`() {
+        let previousMenuRefresh = StatusItemController.menuRefreshEnabled
+        StatusItemController.setMenuRefreshEnabledForTesting(true)
+        defer {
+            StatusItemController.setMenuRefreshEnabledForTesting(previousMenuRefresh)
+        }
+
+        let (controller, menu) = self.makeInstalledSwitcherShortcutMonitor()
+        defer { controller.releaseStatusItemsForTesting() }
+
+        #expect(controller.providerSwitcherShortcutEventMonitor != nil)
+        #expect(controller.providerSwitcherShortcutMenuID == ObjectIdentifier(menu))
+
+        controller.forgetClosedMenu(menu)
+
+        #expect(controller.providerSwitcherShortcutEventMonitor == nil)
+        #expect(controller.providerSwitcherShortcutMenuID == nil)
+    }
+
+    @Test
+    func `switcher hover styling keeps layout stable`() {
+        let view = ProviderSwitcherView(
+            providers: [.codex, .claude, .cursor, .factory, .zai, .minimax, .alibaba],
+            selected: .provider(.codex),
+            includesOverview: true,
+            width: 300,
+            showsIcons: true,
+            iconProvider: { _ in NSImage(size: NSSize(width: 16, height: 16)) },
+            weeklyRemainingProvider: { _ in nil },
+            onSelect: { _ in })
+
+        let initialSize = view.intrinsicContentSize
+        let initialFrames = view._test_buttonFrames()
+
+        view._test_setHoveredButtonTag(3)
+        view._test_setHoveredButtonTag(6)
+        view._test_setHoveredButtonTag(nil as Int?)
+
+        #expect(view.intrinsicContentSize == initialSize)
+        #expect(view._test_buttonFrames() == initialFrames)
+    }
+
+    @Test
+    func `switcher quota indicator preserves remaining percentage`() throws {
+        let view = ProviderSwitcherView(
+            providers: [.claude, .grok],
+            selected: .provider(.claude),
+            includesOverview: false,
+            width: 180,
+            showsIcons: true,
+            iconProvider: { _ in NSImage(size: NSSize(width: 16, height: 16)) },
+            weeklyRemainingProvider: { provider in
+                switch provider {
+                case .claude:
+                    5
+                case .grok:
+                    95
+                default:
+                    nil
+                }
+            },
+            onSelect: { _ in })
+
+        let fillRatios = view._test_quotaIndicatorFillRatios()
+        #expect(fillRatios.count == 2)
+        let lowRemainingRatio = try #require(fillRatios.first)
+        let highRemainingRatio = try #require(fillRatios.last)
+        #expect(lowRemainingRatio < highRemainingRatio)
+    }
+
+    @Test
+    func `switcher quota indicator refresh updates fill ratios`() throws {
+        var claudeRemaining = 5.0
+        var grokRemaining = 95.0
+        let view = ProviderSwitcherView(
+            providers: [.claude, .grok],
+            selected: .provider(.claude),
+            includesOverview: false,
+            width: 180,
+            showsIcons: true,
+            iconProvider: { _ in NSImage(size: NSSize(width: 16, height: 16)) },
+            weeklyRemainingProvider: { provider in
+                switch provider {
+                case .claude:
+                    claudeRemaining
+                case .grok:
+                    grokRemaining
+                default:
+                    nil
+                }
+            },
+            onSelect: { _ in })
+
+        let initialRatios = view._test_quotaIndicatorFillRatios()
+        let initialLow = try #require(initialRatios.first)
+        let initialHigh = try #require(initialRatios.last)
+
+        claudeRemaining = 80
+        grokRemaining = 12
+        view.updateQuotaIndicators()
+
+        let updatedRatios = view._test_quotaIndicatorFillRatios()
+        let updatedLow = try #require(updatedRatios.first)
+        let updatedHigh = try #require(updatedRatios.last)
+        #expect(updatedLow > initialLow)
+        #expect(updatedHigh < initialHigh)
+    }
+
+    @Test
+    func `switcher quota indicator renders zero remaining empty`() {
+        var grokRemaining = 50.0
+        let view = ProviderSwitcherView(
+            providers: [.claude, .grok],
+            selected: .provider(.claude),
+            includesOverview: false,
+            width: 180,
+            showsIcons: true,
+            iconProvider: { _ in NSImage(size: NSSize(width: 16, height: 16)) },
+            weeklyRemainingProvider: { provider in
+                switch provider {
+                case .claude:
+                    100
+                case .grok:
+                    grokRemaining
+                default:
+                    nil
+                }
+            },
+            onSelect: { _ in })
+
+        grokRemaining = 0
+        view.updateQuotaIndicators()
+        view.updateConstraintsForSubtreeIfNeeded()
+        view.layoutSubtreeIfNeeded()
+
+        let fillRatios = view._test_quotaIndicatorFillRatios()
+        let fillFrames = view._test_quotaIndicatorFillFrames()
+        #expect(fillRatios.last == 0)
+        #expect(fillFrames.last?.width == 0)
+    }
+
+    @Test
+    func `switcher keeps stable height when remaining becomes unavailable`() throws {
+        var grokRemaining: Double? = 50
+        let noQuotaView = ProviderSwitcherView(
+            providers: [.claude, .grok],
+            selected: .provider(.claude),
+            includesOverview: false,
+            width: 180,
+            showsIcons: true,
+            iconProvider: { _ in NSImage(size: NSSize(width: 16, height: 16)) },
+            weeklyRemainingProvider: { _ in nil },
+            onSelect: { _ in })
+        let view = ProviderSwitcherView(
+            providers: [.claude, .grok],
+            selected: .provider(.claude),
+            includesOverview: false,
+            width: 180,
+            showsIcons: true,
+            iconProvider: { _ in NSImage(size: NSSize(width: 16, height: 16)) },
+            weeklyRemainingProvider: { provider in
+                switch provider {
+                case .claude:
+                    100
+                case .grok:
+                    grokRemaining
+                default:
+                    nil
+                }
+            },
+            onSelect: { _ in })
+        #expect(view._test_quotaIndicatorFillRatios().count == 2)
+        let noQuotaHeight = try #require(noQuotaView._test_buttonFittingSizes().last?.height)
+        let quotaHeight = try #require(view._test_buttonFittingSizes().last?.height)
+        #expect(quotaHeight == noQuotaHeight)
+
+        grokRemaining = nil
+        view.updateQuotaIndicators()
+
+        #expect(view._test_quotaIndicatorFillRatios().count == 1)
+        let removedQuotaHeight = try #require(view._test_buttonFittingSizes().last?.height)
+        #expect(removedQuotaHeight == noQuotaHeight)
+    }
+
+    @Test
+    func `text only switcher keeps stable height with quota bars`() throws {
+        let providers: [UsageProvider] = [.claude, .grok]
+        let textOnlyWithoutQuota = ProviderSwitcherView(
+            providers: providers,
+            selected: .provider(.claude),
+            includesOverview: false,
+            width: 180,
+            showsIcons: false,
+            iconProvider: { _ in NSImage(size: NSSize(width: 16, height: 16)) },
+            weeklyRemainingProvider: { _ in nil },
+            onSelect: { _ in })
+        let textOnlyWithQuota = ProviderSwitcherView(
+            providers: providers,
+            selected: .provider(.claude),
+            includesOverview: false,
+            width: 180,
+            showsIcons: false,
+            iconProvider: { _ in NSImage(size: NSSize(width: 16, height: 16)) },
+            weeklyRemainingProvider: { _ in 50 },
+            onSelect: { _ in })
+
+        let withoutQuotaHeight = try #require(textOnlyWithoutQuota._test_buttonFittingSizes().first?.height)
+        let withQuotaHeight = try #require(textOnlyWithQuota._test_buttonFittingSizes().first?.height)
+        #expect(withQuotaHeight == withoutQuotaHeight)
+    }
+
+    @Test
+    func `multi row switcher quota bars stay inside bounds`() {
+        let view = ProviderSwitcherView(
+            providers: [.codex, .claude, .cursor, .factory, .zai, .minimax, .alibaba],
+            selected: .provider(.codex),
+            includesOverview: true,
+            width: 300,
+            showsIcons: true,
+            iconProvider: { _ in NSImage(size: NSSize(width: 16, height: 16)) },
+            weeklyRemainingProvider: { _ in 50 },
+            onSelect: { _ in })
+        view.updateConstraintsForSubtreeIfNeeded()
+        view.layoutSubtreeIfNeeded()
+
+        for frame in view._test_buttonFrames() {
+            #expect(frame.minY >= 0)
+            #expect(frame.maxY <= view.bounds.maxY)
+        }
+    }
+
+    private static func arrowKeyEvent(keyCode: UInt16) throws -> NSEvent {
+        try #require(NSEvent.keyEvent(
+            with: .keyDown,
+            location: .zero,
+            modifierFlags: [],
+            timestamp: 0,
+            windowNumber: 0,
+            context: nil,
+            characters: "",
+            charactersIgnoringModifiers: "",
+            isARepeat: false,
+            keyCode: keyCode))
+    }
+
+    private static func commandKeyEvent(_ characters: String, keyCode: UInt16) throws -> NSEvent {
+        try #require(NSEvent.keyEvent(
+            with: .keyDown,
+            location: .zero,
+            modifierFlags: [.command],
+            timestamp: 0,
+            windowNumber: 0,
+            context: nil,
+            characters: characters,
+            charactersIgnoringModifiers: characters,
+            isARepeat: false,
+            keyCode: keyCode))
+    }
+
+    @Test
+    func `multi-row switcher uses compact height and stays inside bounds`() {
+        // 14 providers + Overview forces the four-row path and includes multi-word titles.
+        let view = ProviderSwitcherView(
+            providers: [
+                .codex,
+                .claude,
+                .cursor,
+                .factory,
+                .zai,
+                .minimax,
+                .alibaba,
+                .opencodego,
+                .grok,
+                .groq,
+                .gemini,
+                .openrouter,
+                .perplexity,
+                .kiro,
+            ],
+            selected: .provider(.codex),
+            includesOverview: true,
+            width: 300,
+            showsIcons: true,
+            iconProvider: { _ in NSImage(size: NSSize(width: 16, height: 16)) },
+            weeklyRemainingProvider: { _ in 50 },
+            onSelect: { _ in })
+        view.updateConstraintsForSubtreeIfNeeded()
+        view.layoutSubtreeIfNeeded()
+
+        // All buttons must stay within switcher bounds (no vertical overflow).
+        let buttonFrames = view._test_buttonFrames()
+        let contentFrames = view._test_buttonContentFrames()
+        let trackFrames = view._test_quotaIndicatorTrackFrames()
+        for (frame, contentFrame) in zip(buttonFrames, contentFrames) {
+            #expect(frame.minY >= 0)
+            #expect(frame.maxY <= view.bounds.maxY)
+            #expect(abs((contentFrame?.midY ?? -1) - frame.height / 2) <= 0.5)
+        }
+        for (buttonFrame, trackFrame) in zip(buttonFrames.dropFirst(), trackFrames) {
+            #expect(trackFrame.minY >= buttonFrame.minY)
+            #expect(trackFrame.maxY <= buttonFrame.maxY)
+        }
+
+        #expect(view._test_rowCount() == 4)
+        #expect(view._test_rowHeight() == 39)
+        #expect(view.bounds.height == 168)
+    }
+}
diff --git a/Tests/CodexBarTests/StatusMenuSwitcherLayoutTests.swift b/Tests/CodexBarTests/StatusMenuSwitcherLayoutTests.swift
new file mode 100644
index 0000000000..1e2883c4a5
--- /dev/null
+++ b/Tests/CodexBarTests/StatusMenuSwitcherLayoutTests.swift
@@ -0,0 +1,129 @@
+import AppKit
+import Testing
+@testable import CodexBar
+
+@MainActor
+@Suite(.serialized)
+struct StatusMenuSwitcherLayoutTests {
+    @Test
+    func `overview switcher segment matches provider segment height when quota bars are present`() throws {
+        let view = ProviderSwitcherView(
+            providers: [.claude, .grok, .cursor],
+            selected: .overview,
+            includesOverview: true,
+            width: 300,
+            showsIcons: true,
+            iconProvider: { _ in NSImage(size: NSSize(width: 16, height: 16)) },
+            weeklyRemainingProvider: { _ in 50 },
+            onSelect: { _ in })
+        view.updateConstraintsForSubtreeIfNeeded()
+        view.layoutSubtreeIfNeeded()
+
+        let frames = view._test_buttonFrames()
+        #expect(frames.count == 4)
+        let overviewFrame = try #require(frames.first)
+
+        for frame in frames.dropFirst() {
+            #expect(frame.height == overviewFrame.height)
+            #expect(frame.minY == overviewFrame.minY)
+            #expect(frame.maxY == overviewFrame.maxY)
+        }
+
+        #expect(view._test_rowHeight() == 36)
+    }
+
+    @Test
+    func `quota bars do not offset inline switcher content`() throws {
+        let view = ProviderSwitcherView(
+            providers: [.codex, .devin],
+            selected: .provider(.codex),
+            includesOverview: true,
+            width: 300,
+            showsIcons: true,
+            iconProvider: { _ in NSImage(size: NSSize(width: 16, height: 16)) },
+            weeklyRemainingProvider: { provider in
+                provider == .devin ? 50 : nil
+            },
+            onSelect: { _ in })
+        view.updateConstraintsForSubtreeIfNeeded()
+        view.layoutSubtreeIfNeeded()
+
+        let buttonFrames = view._test_buttonFrames()
+        let contentFrames = view._test_buttonContentFrames()
+        let trackFrames = view._test_quotaIndicatorTrackFrames()
+        #expect(buttonFrames.count == 3)
+        #expect(contentFrames.count == 3)
+        #expect(trackFrames.count == 1)
+        #expect(view._test_rowHeight() == 30)
+
+        let overviewFrame = try #require(buttonFrames.first)
+        for (buttonFrame, contentFrame) in zip(buttonFrames, contentFrames) {
+            let contentFrame = try #require(contentFrame)
+            #expect(buttonFrame.minY == overviewFrame.minY)
+            #expect(buttonFrame.maxY == overviewFrame.maxY)
+            #expect(abs(contentFrame.midY - buttonFrame.height / 2) < 0.01)
+        }
+
+        let devinButtonFrame = try #require(buttonFrames.last)
+        let devinTrackFrame = try #require(trackFrames.first)
+        #expect(devinButtonFrame.height == 30)
+        #expect(devinTrackFrame.minY >= devinButtonFrame.minY)
+        #expect(devinTrackFrame.maxY <= devinButtonFrame.maxY)
+    }
+
+    @Test
+    func `integrated quota indicator selects its provider`() {
+        let view = ProviderSwitcherView(
+            providers: [.codex, .devin],
+            selected: .provider(.codex),
+            includesOverview: true,
+            width: 300,
+            showsIcons: true,
+            iconProvider: { _ in NSImage(size: NSSize(width: 16, height: 16)) },
+            weeklyRemainingProvider: { $0 == .devin ? 50 : nil },
+            onSelect: { _ in })
+
+        #expect(view._test_simulateRuntimeClickOnQuotaIndicator(buttonTag: 2))
+    }
+
+    @Test
+    func `localized inline switcher titles fit without losing equal sizing`() throws {
+        try CodexBarLocalizationOverride.$appLanguage.withValue("tr") {
+            for width in stride(from: CGFloat(280), through: CGFloat(330), by: 1) {
+                let view = ProviderSwitcherView(
+                    providers: [.codex, .devin],
+                    selected: .overview,
+                    includesOverview: true,
+                    width: width,
+                    showsIcons: true,
+                    iconProvider: { _ in NSImage(size: NSSize(width: 16, height: 16)) },
+                    weeklyRemainingProvider: { _ in nil },
+                    onSelect: { _ in })
+                view.updateConstraintsForSubtreeIfNeeded()
+                view.layoutSubtreeIfNeeded()
+
+                let frames = view._test_buttonFrames()
+                let desiredWidths = view._test_buttonDesiredWidths()
+                #expect(frames.count == 3)
+                #expect(desiredWidths.count == frames.count)
+                let firstWidth = try #require(frames.first?.width)
+
+                for (frame, desiredWidth) in zip(frames, desiredWidths) {
+                    #expect(frame.width == firstWidth)
+                    let minimalInsetAllowedWidth = floor((width - 12 - 2) / 3)
+                    let evenMinimalInsetAllowedWidth = minimalInsetAllowedWidth
+                        .truncatingRemainder(dividingBy: 2) == 0
+                        ? minimalInsetAllowedWidth
+                        : minimalInsetAllowedWidth - 1
+                    let roundedDesiredWidth = ceil(desiredWidth)
+                    let evenDesiredWidth = roundedDesiredWidth.truncatingRemainder(dividingBy: 2) == 0
+                        ? roundedDesiredWidth
+                        : roundedDesiredWidth + 1
+                    if evenMinimalInsetAllowedWidth >= evenDesiredWidth {
+                        #expect(frame.width >= desiredWidth)
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/Tests/CodexBarTests/StatusMenuSwitcherRefreshTests.swift b/Tests/CodexBarTests/StatusMenuSwitcherRefreshTests.swift
new file mode 100644
index 0000000000..da4ce6c915
--- /dev/null
+++ b/Tests/CodexBarTests/StatusMenuSwitcherRefreshTests.swift
@@ -0,0 +1,714 @@
+import AppKit
+import CodexBarCore
+import Testing
+@testable import CodexBar
+
+@MainActor
+private final class SwitcherRefreshManualGate {
+    private var continuation: CheckedContinuation<Void, Never>?
+    private var isOpen = false
+
+    func wait() async {
+        if self.isOpen {
+            self.isOpen = false
+            return
+        }
+        await withCheckedContinuation { continuation in
+            self.continuation = continuation
+        }
+    }
+
+    func resume() {
+        if let continuation = self.continuation {
+            continuation.resume()
+            self.continuation = nil
+        } else {
+            self.isOpen = true
+        }
+    }
+}
+
+@MainActor
+@Suite(.serialized)
+struct StatusMenuSwitcherRefreshTests {
+    @Test
+    func `native switcher action preserves off tab switches after button state toggles`() {
+        var selections: [ProviderSwitcherSelection] = []
+        let switcher = ProviderSwitcherView(
+            providers: [.codex, .claude],
+            selected: .provider(.codex),
+            includesOverview: false,
+            width: 310,
+            showsIcons: false,
+            iconProvider: { _ in NSImage() },
+            weeklyRemainingProvider: { _ in nil },
+            onSelect: { selections.append($0) })
+
+        #expect(switcher._test_simulateNativeAction(buttonTag: 1, state: .on))
+        #expect(selections == [.provider(.claude)])
+    }
+
+    @Test
+    func `native switcher action restores active tab after native toggle`() {
+        var selections: [ProviderSwitcherSelection] = []
+        let switcher = ProviderSwitcherView(
+            providers: [.codex, .claude],
+            selected: .provider(.codex),
+            includesOverview: false,
+            width: 310,
+            showsIcons: false,
+            iconProvider: { _ in NSImage() },
+            weeklyRemainingProvider: { _ in nil },
+            onSelect: { selections.append($0) })
+
+        #expect(switcher._test_simulateNativeAction(buttonTag: 0, state: .off))
+        #expect(selections.isEmpty)
+        #expect(Self.switcherButtons(in: switcher).first { $0.tag == 0 }?.state == .on)
+    }
+
+    @Test
+    func `merged provider switch rebuilds stale width switcher rows`() async throws {
+        let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = false
+        StatusItemController.setMenuRefreshEnabledForTesting(true)
+        defer {
+            StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering
+            StatusItemController.resetMenuRefreshEnabledForTesting()
+        }
+
+        let settings = Self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        Self.enableCodexAndClaude(settings)
+
+        let activeProviders: [UsageProvider] = [.codex, .claude]
+        _ = settings.setMergedOverviewProviderSelection(
+            provider: .codex,
+            isSelected: false,
+            activeProviders: activeProviders)
+        _ = settings.setMergedOverviewProviderSelection(
+            provider: .claude,
+            isSelected: false,
+            activeProviders: activeProviders)
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        store.isRefreshing = true
+        defer { store.isRefreshing = false }
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        #expect(controller.openMenus[ObjectIdentifier(menu)] === menu)
+
+        let initialSwitcher = try #require(menu.items.first?.view as? ProviderSwitcherView)
+        initialSwitcher.frame.size.width = 250
+
+        var rebuildCount = 0
+        controller._test_openMenuRebuildObserver = { _ in
+            rebuildCount += 1
+        }
+        defer { controller._test_openMenuRebuildObserver = nil }
+
+        let nextProviderButton = try #require(Self.switcherButtons(in: menu).first { $0.state == .off })
+        #expect(initialSwitcher._test_simulateRuntimeClick(buttonTag: nextProviderButton.tag) == true)
+
+        for _ in 0..<100 where rebuildCount == 0 {
+            await Task.yield()
+            try? await Task.sleep(for: .milliseconds(10))
+        }
+
+        #expect(rebuildCount == 1)
+        let updatedSwitcher = try #require(menu.items.first?.view as? ProviderSwitcherView)
+        #expect(updatedSwitcher.frame.width == 310)
+        #expect(Self.switcherButtons(in: menu).first { $0.tag == nextProviderButton.tag }?.state == .on)
+    }
+
+    @Test
+    func `selected provider tab click does not rebuild open menu`() async throws {
+        let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = false
+        StatusItemController.setMenuRefreshEnabledForTesting(true)
+        defer {
+            StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering
+            StatusItemController.resetMenuRefreshEnabledForTesting()
+        }
+
+        let settings = Self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        settings.openAIWebAccessEnabled = true
+        Self.enableCodexAndClaude(settings)
+        Self.disableOverview(settings)
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        let switcher = try #require(menu.items.first?.view as? ProviderSwitcherView)
+        let selectedButton = try #require(Self.switcherButtons(in: menu).first { $0.state == .on })
+
+        var rebuildCount = 0
+        controller._test_openMenuRebuildObserver = { _ in
+            rebuildCount += 1
+        }
+        defer { controller._test_openMenuRebuildObserver = nil }
+
+        #expect(switcher._test_simulateRuntimeClick(buttonTag: selectedButton.tag))
+        try? await Task.sleep(for: .milliseconds(40))
+
+        #expect(rebuildCount == 0)
+        #expect(Self.switcherButtons(in: menu).first { $0.tag == selectedButton.tag }?.state == .on)
+    }
+
+    @Test
+    func `merged provider switch updates live tab rows in place`() async throws {
+        let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = false
+        StatusItemController.setMenuRefreshEnabledForTesting(true)
+        defer {
+            StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering
+            StatusItemController.resetMenuRefreshEnabledForTesting()
+        }
+
+        let settings = Self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        Self.enableCodexAndClaude(settings)
+        Self.disableOverview(settings)
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        let contentStartIndex = controller.providerSwitcherContentStartIndex(in: menu)
+        #expect(menu.items.indices.contains(contentStartIndex))
+        let originalContentID = ObjectIdentifier(menu.items[contentStartIndex])
+        let selectedButton = try #require(Self.switcherButtons(in: menu).first { $0.state == .on })
+        let alternateButton = try #require(Self.switcherButtons(in: menu).first { $0.state == .off })
+
+        var rebuildCount = 0
+        controller._test_openMenuRebuildObserver = { _ in
+            rebuildCount += 1
+        }
+        defer { controller._test_openMenuRebuildObserver = nil }
+
+        // Provider switches now reconcile matching rows in place instead of parking and
+        // restoring distinct item sets per tab: the same NSMenuItem objects carry each
+        // tab's freshly built content, so AppKit never relayouts the open menu per insert.
+        let initialSwitcher = try #require(menu.items.first?.view as? ProviderSwitcherView)
+        #expect(initialSwitcher._test_simulateRuntimeClick(buttonTag: alternateButton.tag))
+        await Self.waitForRebuildCount(1, rebuildCount: { rebuildCount })
+        #expect(menu.items.indices.contains(contentStartIndex))
+        #expect(ObjectIdentifier(menu.items[contentStartIndex]) == originalContentID)
+
+        let alternateSwitcher = try #require(menu.items.first?.view as? ProviderSwitcherView)
+        #expect(alternateSwitcher._test_simulateRuntimeClick(buttonTag: selectedButton.tag))
+        await Self.waitForRebuildCount(2, rebuildCount: { rebuildCount })
+        #expect(menu.items.indices.contains(contentStartIndex))
+        #expect(ObjectIdentifier(menu.items[contentStartIndex]) == originalContentID)
+
+        let restoredSwitcher = try #require(menu.items.first?.view as? ProviderSwitcherView)
+        #expect(restoredSwitcher._test_simulateRuntimeClick(buttonTag: alternateButton.tag))
+        await Self.waitForRebuildCount(3, rebuildCount: { rebuildCount })
+        #expect(menu.items.indices.contains(contentStartIndex))
+        #expect(ObjectIdentifier(menu.items[contentStartIndex]) == originalContentID)
+
+        controller.invalidateMenus()
+        #expect(controller.mergedSwitcherContentCaches.isEmpty)
+    }
+
+    @Test
+    func `manual refresh keeps codex quota visible after switching away and back`() async throws {
+        let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = false
+        StatusItemController.setMenuRefreshEnabledForTesting(true)
+        defer {
+            StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering
+            StatusItemController.resetMenuRefreshEnabledForTesting()
+        }
+
+        let settings = Self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        Self.enableCodexAndClaude(settings)
+        Self.disableOverview(settings)
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let now = Date(timeIntervalSince1970: 1_800_000_000)
+        store._setSnapshotForTesting(Self.quotaSnapshot(usedPercent: 21, updatedAt: now), provider: .codex)
+        store._setSnapshotForTesting(Self.quotaSnapshot(usedPercent: 44, updatedAt: now), provider: .claude)
+        let event = CreditEvent(date: now, service: "CLI", creditsUsed: 1)
+        let breakdown = OpenAIDashboardSnapshot.makeDailyBreakdown(from: [event], maxDays: 30)
+        store.openAIDashboard = OpenAIDashboardSnapshot(
+            signedInEmail: "test@example.com",
+            codeReviewRemainingPercent: nil,
+            creditEvents: [event],
+            dailyBreakdown: breakdown,
+            usageBreakdown: breakdown,
+            creditsPurchaseURL: nil,
+            updatedAt: now)
+        store.openAIDashboardAttachmentAuthorized = true
+        store.openAIDashboardRequiresLogin = false
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: AccountInfo(email: "test@example.com", plan: "pro"),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system)
+        defer {
+            controller.manualRefreshTask?.cancel()
+            controller.releaseStatusItemsForTesting()
+        }
+
+        let gate = SwitcherRefreshManualGate()
+        controller._test_manualRefreshOperation = {
+            await gate.wait()
+        }
+        defer { controller._test_manualRefreshOperation = nil }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        let selectedButton = try #require(Self.switcherButtons(in: menu).first { $0.state == .on })
+        let alternateButton = try #require(Self.switcherButtons(in: menu).first { $0.state == .off })
+
+        controller.refreshNow()
+        #expect(controller.menuCardRefreshMonitor.isManualRefreshInFlight)
+
+        store._setSnapshotForTesting(
+            UsageSnapshot(primary: nil, secondary: nil, updatedAt: now.addingTimeInterval(1)),
+            provider: .codex)
+
+        var rebuildCount = 0
+        controller._test_openMenuRebuildObserver = { _ in
+            rebuildCount += 1
+        }
+        defer { controller._test_openMenuRebuildObserver = nil }
+
+        let initialSwitcher = try #require(menu.items.first?.view as? ProviderSwitcherView)
+        #expect(initialSwitcher._test_simulateRuntimeClick(buttonTag: alternateButton.tag))
+        await Self.waitForRebuildCount(1, rebuildCount: { rebuildCount })
+
+        let alternateSwitcher = try #require(menu.items.first?.view as? ProviderSwitcherView)
+        #expect(alternateSwitcher._test_simulateRuntimeClick(buttonTag: selectedButton.tag))
+        await Self.waitForRebuildCount(2, rebuildCount: { rebuildCount })
+        #expect(settings.selectedMenuProvider == .codex)
+
+        let usageItem = menu.items.first { ($0.representedObject as? String) == "menuCardUsage" }
+        #expect(usageItem != nil)
+        #expect(menu.items.contains { ($0.representedObject as? String) == "menuCardHeader" } == false)
+
+        let emptyFallback = try #require(controller.menuCardModel(for: .codex))
+        let inFlight = controller.menuCardRefreshMonitor.model(for: .codex, fallback: emptyFallback)
+        let subtitle = controller.menuCardRefreshMonitor.subtitle(
+            for: .codex,
+            fallback: MenuCardLiveSubtitle(text: emptyFallback.subtitleText, style: emptyFallback.subtitleStyle))
+
+        #expect(emptyFallback.metrics.isEmpty)
+        #expect(subtitle.text == "Refreshing…")
+        #expect(inFlight.metrics.first?.percentLabel == "79% left")
+
+        gate.resume()
+        await controller.manualRefreshTask?.value
+        #expect(!controller.menuCardRefreshMonitor.isManualRefreshInFlight)
+        let completed = controller.menuCardRefreshMonitor.model(for: .codex, fallback: emptyFallback)
+        #expect(completed.metrics.isEmpty)
+    }
+
+    @Test
+    func `completed refresh re-enables cached item when switching back`() async throws {
+        let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = false
+        StatusItemController.setMenuRefreshEnabledForTesting(true)
+        defer {
+            StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering
+            StatusItemController.resetMenuRefreshEnabledForTesting()
+        }
+
+        let settings = Self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        Self.enableCodexAndClaude(settings)
+        Self.disableOverview(settings)
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system)
+        defer {
+            controller.manualRefreshTask?.cancel()
+            controller.releaseStatusItemsForTesting()
+        }
+
+        let gate = SwitcherRefreshManualGate()
+        controller._test_manualRefreshOperation = { await gate.wait() }
+        defer { controller._test_manualRefreshOperation = nil }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        let selectedButton = try #require(Self.switcherButtons(in: menu).first { $0.state == .on })
+        let alternateButton = try #require(Self.switcherButtons(in: menu).first { $0.state == .off })
+        let initialRefreshItem = try #require(menu.items.first { $0.title == "Refresh" })
+
+        controller.refreshNow()
+        let refreshTask = try #require(controller.manualRefreshTask)
+        #expect(!initialRefreshItem.isEnabled)
+
+        var rebuildCount = 0
+        controller._test_openMenuRebuildObserver = { _ in rebuildCount += 1 }
+        defer { controller._test_openMenuRebuildObserver = nil }
+
+        let initialSwitcher = try #require(menu.items.first?.view as? ProviderSwitcherView)
+        #expect(initialSwitcher._test_simulateRuntimeClick(buttonTag: alternateButton.tag))
+        await Self.waitForRebuildCount(1, rebuildCount: { rebuildCount })
+
+        gate.resume()
+        await refreshTask.value
+        #expect(controller.manualRefreshTask == nil)
+
+        let alternateSwitcher = try #require(menu.items.first?.view as? ProviderSwitcherView)
+        #expect(alternateSwitcher._test_simulateRuntimeClick(buttonTag: selectedButton.tag))
+        await Self.waitForRebuildCount(2, rebuildCount: { rebuildCount })
+
+        let restoredRefreshItem = try #require(menu.items.first { $0.title == "Refresh" })
+        #expect(restoredRefreshItem.isEnabled)
+    }
+
+    @Test
+    func `full cached reattachment resynchronizes detached refresh item`() throws {
+        let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = false
+        defer { StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering }
+
+        let settings = Self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        Self.enableCodexAndClaude(settings)
+        Self.disableOverview(settings)
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system)
+        defer {
+            controller.manualRefreshTask?.cancel()
+            controller.releaseStatusItemsForTesting()
+        }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        let cache = try #require(
+            controller.mergedSwitcherContentCaches[ObjectIdentifier(menu)]?[.provider(.codex)])
+        let refreshItem = try #require(cache.items.first { $0.title == "Refresh" })
+
+        controller.manualRefreshTask = Task {}
+        controller.updatePersistentRefreshItemsEnabled()
+        #expect(!refreshItem.isEnabled)
+
+        menu.removeAllItems()
+        #expect(refreshItem.menu == nil)
+        controller.manualRefreshTask = nil
+        controller.updatePersistentRefreshItemsEnabled()
+        #expect(!refreshItem.isEnabled)
+
+        #expect(controller.addCachedMergedSwitcherContent(
+            for: .provider(.codex),
+            to: menu,
+            menuWidth: cache.menuWidth,
+            codexAccountDisplay: cache.codexAccountDisplay,
+            tokenAccountDisplay: cache.tokenAccountDisplay))
+        #expect(refreshItem.menu === menu)
+        #expect(refreshItem.isEnabled)
+    }
+
+    @Test
+    func `native image menu rows are replaced during reconciliation`() {
+        let settings = Self.makeSettings()
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = NSMenu()
+        let liveItem = Self.nativeImageItem(title: "Status Page")
+        menu.addItem(liveItem)
+        let shapes = controller.menuContentShapes(in: menu, fromIndex: 0)
+
+        let scratch = NSMenu()
+        let freshItem = Self.nativeImageItem(title: "Status Page")
+        scratch.addItem(freshItem)
+
+        controller.reconcileMenuContent(menu, fromIndex: 0, shapes: shapes, with: scratch)
+
+        #expect(menu.items.count == 1)
+        #expect(ObjectIdentifier(menu.items[0]) == ObjectIdentifier(freshItem))
+        #expect(ObjectIdentifier(menu.items[0]) != ObjectIdentifier(liveItem))
+    }
+
+    @Test
+    func `native image submenu rows reconcile in place`() {
+        let settings = Self.makeSettings()
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = NSMenu()
+        let liveItem = Self.nativeImageItem(title: "System Account")
+        liveItem.submenu = NSMenu(title: "System Account")
+        menu.addItem(liveItem)
+        let shapes = controller.menuContentShapes(in: menu, fromIndex: 0)
+
+        let scratch = NSMenu()
+        let freshItem = Self.nativeImageItem(title: "System Account")
+        freshItem.submenu = NSMenu(title: "System Account")
+        scratch.addItem(freshItem)
+
+        controller.reconcileMenuContent(menu, fromIndex: 0, shapes: shapes, with: scratch)
+
+        #expect(menu.items.count == 1)
+        #expect(ObjectIdentifier(menu.items[0]) == ObjectIdentifier(liveItem))
+        #expect(ObjectIdentifier(menu.items[0]) != ObjectIdentifier(freshItem))
+    }
+
+    @Test
+    func `provider switch does not cache stale rows after required invalidation`() async throws {
+        let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
+        StatusItemController.menuCardRenderingEnabled = false
+        StatusItemController.setMenuRefreshEnabledForTesting(true)
+        defer {
+            StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering
+            StatusItemController.resetMenuRefreshEnabledForTesting()
+        }
+
+        let settings = Self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        Self.enableCodexAndClaude(settings)
+        Self.disableOverview(settings)
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        let contentStartIndex = controller.providerSwitcherContentStartIndex(in: menu)
+        #expect(menu.items.indices.contains(contentStartIndex))
+        let selectedButton = try #require(Self.switcherButtons(in: menu).first { $0.state == .on })
+        let alternateButton = try #require(Self.switcherButtons(in: menu).first { $0.state == .off })
+
+        var rebuildCount = 0
+        controller._test_openMenuRebuildObserver = { _ in
+            rebuildCount += 1
+        }
+        defer { controller._test_openMenuRebuildObserver = nil }
+
+        controller.invalidateMenus()
+        #expect(controller.mergedSwitcherContentCaches.isEmpty)
+        let initialSwitcher = try #require(menu.items.first?.view as? ProviderSwitcherView)
+        #expect(initialSwitcher._test_simulateRuntimeClick(buttonTag: alternateButton.tag))
+        await Self.waitForRebuildCount(1, rebuildCount: { rebuildCount })
+
+        let alternateSwitcher = try #require(menu.items.first?.view as? ProviderSwitcherView)
+        #expect(alternateSwitcher._test_simulateRuntimeClick(buttonTag: selectedButton.tag))
+        await Self.waitForRebuildCount(2, rebuildCount: { rebuildCount })
+
+        // Rows are reconciled in place, so freshness is guaranteed by rebuilding content
+        // from current data rather than by minting new items: the live menu must be marked
+        // fresh and no cached entry may predate the required invalidation. (In-place item
+        // identity itself is covered deterministically in MenuCardViewRecyclingTests; here
+        // async gate state may legitimately route a populate through the full rebuild.)
+        #expect(menu.items.indices.contains(contentStartIndex))
+        let menuKey = ObjectIdentifier(menu)
+        #expect(controller.menuVersions[menuKey] == controller.menuContentVersion)
+        for entry in controller.mergedSwitcherContentCaches[menuKey]?.values ?? [:].values {
+            #expect(entry.requiredMenuContentVersion >= controller.latestRequiredMenuRebuildVersion)
+        }
+    }
+
+    @Test
+    func `tab switch does not replace quota indicator constraints`() {
+        let switcher = ProviderSwitcherView(
+            providers: [.codex, .claude],
+            selected: .provider(.codex),
+            includesOverview: false,
+            width: 310,
+            showsIcons: false,
+            iconProvider: { _ in NSImage() },
+            weeklyRemainingProvider: { _ in 75.0 },
+            onSelect: { _ in })
+
+        let initialConstraints = switcher._test_quotaIndicatorConstraintIdentifiers()
+        #expect(initialConstraints.count == 2, "both providers should have quota indicators")
+
+        switcher.updateQuotaIndicators()
+
+        let afterFirstCall = switcher._test_quotaIndicatorConstraintIdentifiers()
+        #expect(afterFirstCall == initialConstraints, "same ratio: constraints must not be replaced")
+    }
+
+    @Test
+    func `quota indicator constraints are replaced when ratio changes`() {
+        var currentRemaining = 75.0
+        let switcher = ProviderSwitcherView(
+            providers: [.codex, .claude],
+            selected: .provider(.codex),
+            includesOverview: false,
+            width: 310,
+            showsIcons: false,
+            iconProvider: { _ in NSImage() },
+            weeklyRemainingProvider: { _ in currentRemaining },
+            onSelect: { _ in })
+
+        let initialConstraints = switcher._test_quotaIndicatorConstraintIdentifiers()
+        #expect(initialConstraints.count == 2)
+
+        currentRemaining = 40.0
+        switcher.updateQuotaIndicators()
+
+        let afterDataChange = switcher._test_quotaIndicatorConstraintIdentifiers()
+        #expect(afterDataChange != initialConstraints, "changed ratio: constraints should be replaced")
+    }
+
+    private static func makeSettings() -> SettingsStore {
+        let suite = "StatusMenuSwitcherRefreshTests-\(UUID().uuidString)"
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        defaults.set(true, forKey: "providerDetectionCompleted")
+        return SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+    }
+
+    private static func enableCodexAndClaude(_ settings: SettingsStore) {
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            let shouldEnable = provider == .codex || provider == .claude
+            settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: shouldEnable)
+        }
+    }
+
+    private static func disableOverview(_ settings: SettingsStore) {
+        let activeProviders: [UsageProvider] = [.codex, .claude]
+        _ = settings.setMergedOverviewProviderSelection(
+            provider: .codex,
+            isSelected: false,
+            activeProviders: activeProviders)
+        _ = settings.setMergedOverviewProviderSelection(
+            provider: .claude,
+            isSelected: false,
+            activeProviders: activeProviders)
+    }
+
+    private static func quotaSnapshot(usedPercent: Double, updatedAt: Date) -> UsageSnapshot {
+        UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: usedPercent,
+                windowMinutes: 300,
+                resetsAt: updatedAt.addingTimeInterval(3600),
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: updatedAt)
+    }
+
+    private static func waitForRebuildCount(
+        _ expectedCount: Int,
+        rebuildCount: () -> Int) async
+    {
+        for _ in 0..<100 where rebuildCount() < expectedCount {
+            await Task.yield()
+            try? await Task.sleep(for: .milliseconds(10))
+        }
+    }
+
+    private static func switcherButtons(in menu: NSMenu) -> [NSButton] {
+        guard let switcherView = menu.items.first?.view as? ProviderSwitcherView else { return [] }
+        return self.switcherButtons(in: switcherView)
+    }
+
+    private static func switcherButtons(in switcherView: ProviderSwitcherView) -> [NSButton] {
+        switcherView.subviews
+            .compactMap { $0 as? NSButton }
+            .sorted { $0.tag < $1.tag }
+    }
+
+    private static func nativeImageItem(title: String) -> NSMenuItem {
+        let item = NSMenuItem(title: title, action: nil, keyEquivalent: "")
+        item.image = NSImage(size: NSSize(width: 16, height: 16))
+        return item
+    }
+}
diff --git a/Tests/CodexBarTests/StatusMenuSwitcherTrackingTests.swift b/Tests/CodexBarTests/StatusMenuSwitcherTrackingTests.swift
new file mode 100644
index 0000000000..d93630f812
--- /dev/null
+++ b/Tests/CodexBarTests/StatusMenuSwitcherTrackingTests.swift
@@ -0,0 +1,209 @@
+import AppKit
+import CodexBarCore
+import Testing
+@testable import CodexBar
+
+@MainActor
+@Suite(.serialized)
+struct StatusMenuSwitcherTrackingTests {
+    @Test
+    func `switcher rebuild scheduler runs during menu tracking exactly once`() {
+        var runCount = 0
+        ProviderSwitcherTrackingRunLoopScheduler.schedule {
+            runCount += 1
+        }
+
+        CFRunLoopRunInMode(
+            CFRunLoopMode(RunLoop.Mode.eventTracking.rawValue as CFString),
+            0.1,
+            true)
+        #expect(runCount == 1)
+
+        CFRunLoopRunInMode(.defaultMode, 0.1, true)
+        #expect(runCount == 1)
+    }
+
+    @Test
+    func `pointer switch defers structural menu rebuild until mouse up`() async throws {
+        let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
+        let previousMenuRefresh = StatusItemController.menuRefreshEnabled
+        StatusItemController.menuCardRenderingEnabled = false
+        StatusItemController.setMenuRefreshEnabledForTesting(true)
+        defer {
+            StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering
+            StatusItemController.setMenuRefreshEnabledForTesting(previousMenuRefresh)
+        }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        settings.mergedMenuLastSelectedWasOverview = false
+
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            settings.setProviderEnabled(
+                provider: provider,
+                metadata: metadata,
+                enabled: provider == .codex || provider == .claude)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system,
+            menuRefreshEnabled: false)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        controller.menuRefreshEnabledOverrideForTesting = true
+        controller.openMenus[ObjectIdentifier(menu)] = menu
+        let switcher = try #require(menu.items.first?.view as? ProviderSwitcherView)
+        let mouseDown = try #require(switcher._test_mouseDownEvent(buttonTag: 2))
+        let mouseUp = try #require(switcher._test_mouseUpEvent(buttonTag: 2))
+
+        var rebuildCount = 0
+        controller._test_openMenuRebuildObserver = { _ in
+            rebuildCount += 1
+        }
+        defer { controller._test_openMenuRebuildObserver = nil }
+
+        #expect(controller.handleProviderSwitcherTrackingEvent(mouseDown, menu: menu))
+        #expect(settings.selectedMenuProvider == .codex)
+        #expect(controller.providerSwitcherPointerInteractionMenuID == ObjectIdentifier(menu))
+        #expect(controller.pendingProviderSwitcherPointerRebuild == nil)
+
+        for _ in 0..<20 {
+            await Task.yield()
+        }
+        #expect(rebuildCount == 0)
+
+        #expect(controller.handleProviderSwitcherTrackingEvent(mouseUp, menu: menu))
+        #expect(settings.selectedMenuProvider == .claude)
+        for _ in 0..<100 where rebuildCount == 0 {
+            await Task.yield()
+            try? await Task.sleep(for: .milliseconds(5))
+        }
+        #expect(rebuildCount == 1)
+        #expect(controller.providerSwitcherPointerInteractionMenuID == nil)
+        #expect(controller.pendingProviderSwitcherPointerRebuild == nil)
+    }
+
+    @Test
+    func `pointer switch cancels when mouse up leaves pressed segment`() throws {
+        let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
+        let previousMenuRefresh = StatusItemController.menuRefreshEnabled
+        StatusItemController.menuCardRenderingEnabled = false
+        StatusItemController.setMenuRefreshEnabledForTesting(true)
+        defer {
+            StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering
+            StatusItemController.setMenuRefreshEnabledForTesting(previousMenuRefresh)
+        }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        settings.mergedMenuLastSelectedWasOverview = false
+
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            settings.setProviderEnabled(
+                provider: provider,
+                metadata: metadata,
+                enabled: provider == .codex || provider == .claude)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system,
+            menuRefreshEnabled: false)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        controller.menuRefreshEnabledOverrideForTesting = true
+        controller.openMenus[ObjectIdentifier(menu)] = menu
+        let switcher = try #require(menu.items.first?.view as? ProviderSwitcherView)
+        let mouseDown = try #require(switcher._test_mouseDownEvent(buttonTag: 2))
+        let mouseUpElsewhere = try #require(switcher._test_mouseUpEvent(buttonTag: 1))
+
+        var rebuildCount = 0
+        controller._test_openMenuRebuildObserver = { _ in
+            rebuildCount += 1
+        }
+        defer { controller._test_openMenuRebuildObserver = nil }
+
+        #expect(controller.handleProviderSwitcherTrackingEvent(mouseDown, menu: menu))
+        #expect(controller.handleProviderSwitcherTrackingEvent(mouseUpElsewhere, menu: menu))
+        #expect(settings.selectedMenuProvider == .codex)
+        #expect(rebuildCount == 0)
+        #expect(controller.providerSwitcherPointerInteractionMenuID == nil)
+        #expect(controller.pendingProviderSwitcherPointerRebuild == nil)
+    }
+
+    @Test
+    func `unrelated mouse up remains available to normal menu items`() throws {
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+
+        let fetcher = UsageFetcher()
+        let controller = StatusItemController(
+            store: UsageStore(
+                fetcher: fetcher,
+                browserDetection: BrowserDetection(cacheTTL: 0),
+                settings: settings),
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: .system)
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = NSMenu()
+        let switcher = ProviderSwitcherView(
+            providers: [.codex, .claude],
+            selected: .provider(.codex),
+            includesOverview: true,
+            width: 320,
+            showsIcons: false,
+            iconProvider: { _ in NSImage() },
+            weeklyRemainingProvider: { _ in nil },
+            onSelect: { _ in })
+        let item = NSMenuItem()
+        item.view = switcher
+        menu.addItem(item)
+        let unrelatedMouseUp = try #require(switcher._test_mouseUpEvent(buttonTag: 1))
+
+        #expect(!controller.handleProviderSwitcherTrackingEvent(unrelatedMouseUp, menu: menu))
+    }
+
+    private func makeSettings() -> SettingsStore {
+        let suite = "StatusMenuSwitcherTrackingTests-\(UUID().uuidString)"
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        return SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+    }
+}
diff --git a/Tests/CodexBarTests/StatusMenuTests.swift b/Tests/CodexBarTests/StatusMenuTests.swift
index 3f04c3ff79..cbef9132f2 100644
--- a/Tests/CodexBarTests/StatusMenuTests.swift
+++ b/Tests/CodexBarTests/StatusMenuTests.swift
@@ -4,31 +4,69 @@ import Testing
 @testable import CodexBar
 
 @MainActor
-@Suite
+@Suite(.serialized)
 struct StatusMenuTests {
-    private func disableMenuCardsForTesting() {
+    func disableMenuCardsForTesting() {
         StatusItemController.menuCardRenderingEnabled = false
-        StatusItemController.menuRefreshEnabled = false
+        StatusItemController.setMenuRefreshEnabledForTesting(false)
     }
 
-    private func makeStatusBarForTesting() -> NSStatusBar {
-        let env = ProcessInfo.processInfo.environment
-        if env["GITHUB_ACTIONS"] == "true" || env["CI"] == "true" {
-            return .system
-        }
-        return NSStatusBar()
+    func makeStatusBarForTesting() -> NSStatusBar {
+        // Use the real system status bar in tests. Creating standalone NSStatusBar instances
+        // has caused AppKit teardown crashes under swiftpm-testing-helper.
+        .system
     }
 
-    private func makeSettings() -> SettingsStore {
+    func makeSettings() -> SettingsStore {
         let suite = "StatusMenuTests-\(UUID().uuidString)"
         let defaults = UserDefaults(suiteName: suite)!
         defaults.removePersistentDomain(forName: suite)
         let configStore = testConfigStore(suiteName: suite)
-        return SettingsStore(
+        let settings = SettingsStore(
             userDefaults: defaults,
             configStore: configStore,
             zaiTokenStore: NoopZaiTokenStore(),
             syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.providerDetectionCompleted = true
+        return settings
+    }
+
+    func makeCodexStore(settings: SettingsStore, dashboardAuthorized: Bool) -> UsageStore {
+        let now = Date()
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 22,
+                    windowMinutes: 300,
+                    resetsAt: now.addingTimeInterval(1800),
+                    resetDescription: nil),
+                secondary: nil,
+                tertiary: nil,
+                updatedAt: now,
+                identity: ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: "codex@example.com",
+                    accountOrganization: nil,
+                    loginMethod: "Plus Plan")),
+            provider: .codex)
+        store.openAIDashboard = OpenAIDashboardSnapshot(
+            signedInEmail: "other@example.com",
+            codeReviewRemainingPercent: 88,
+            codeReviewLimit: RateWindow(
+                usedPercent: 12,
+                windowMinutes: nil,
+                resetsAt: now.addingTimeInterval(3600),
+                resetDescription: nil),
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            updatedAt: now)
+        store.openAIDashboardAttachmentAuthorized = dashboardAuthorized
+        store.openAIDashboardRequiresLogin = false
+        return store
     }
 
     private func switcherButtons(in menu: NSMenu) -> [NSButton] {
@@ -43,7 +81,126 @@ struct StatusMenuTests {
     }
 
     @Test
-    func remembersProviderWhenMenuOpens() {
+    func `alibaba dashboard action follows selected region`() {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.alibabaCodingPlanAPIRegion = .chinaMainland
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+
+        #expect(controller.dashboardURL(for: .alibaba) == AlibabaCodingPlanAPIRegion.chinaMainland.dashboardURL)
+    }
+
+    @Test
+    func `zai dashboard action follows selected region`() {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+
+        settings.zaiAPIRegion = .global
+        #expect(controller.dashboardURL(for: .zai) == ZaiAPIRegion.global.dashboardURL)
+        #expect(
+            controller.dashboardURL(for: .zai)?.absoluteString ==
+                "https://z.ai/manage-apikey/coding-plan/personal/my-plan")
+        #expect(
+            controller.dashboardURL(
+                for: .zai,
+                environment: [ZaiSettingsReader.apiHostKey: "open.bigmodel.cn"]) ==
+                ZaiAPIRegion.bigmodelCN.dashboardURL)
+
+        settings.zaiAPIRegion = .bigmodelCN
+        #expect(controller.dashboardURL(for: .zai) == ZaiAPIRegion.bigmodelCN.dashboardURL)
+        #expect(controller.dashboardURL(for: .zai)?.absoluteString == "https://bigmodel.cn/coding-plan/personal/usage")
+    }
+
+    @Test
+    func `opencode go dashboard action follows configured workspace`() {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.opencodegoWorkspaceID = "https://opencode.ai/workspace/wrk_abc123/go"
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+
+        #expect(controller.dashboardURL(for: .opencodego)?
+            .absoluteString == "https://opencode.ai/workspace/wrk_abc123/go")
+    }
+
+    @Test
+    func `claude subscription dashboard action opens usage page`() {
+        for plan in ["Claude Pro", "Claude Team"] {
+            self.disableMenuCardsForTesting()
+            let settings = self.makeSettings()
+            settings.statusChecksEnabled = false
+            settings.refreshFrequency = .manual
+
+            let fetcher = UsageFetcher()
+            let store = UsageStore(
+                fetcher: fetcher,
+                browserDetection: BrowserDetection(cacheTTL: 0),
+                settings: settings)
+            store._setSnapshotForTesting(
+                UsageSnapshot(
+                    primary: RateWindow(
+                        usedPercent: 12,
+                        windowMinutes: 300,
+                        resetsAt: nil,
+                        resetDescription: nil),
+                    secondary: nil,
+                    tertiary: nil,
+                    updatedAt: Date(),
+                    identity: ProviderIdentitySnapshot(
+                        providerID: .claude,
+                        accountEmail: nil,
+                        accountOrganization: nil,
+                        loginMethod: plan)),
+                provider: .claude)
+            let controller = StatusItemController(
+                store: store,
+                settings: settings,
+                account: fetcher.loadAccountInfo(),
+                updater: DisabledUpdaterController(),
+                preferencesSelection: PreferencesSelection(),
+                statusBar: self.makeStatusBarForTesting())
+
+            #expect(controller.dashboardURL(for: .claude)?.absoluteString == "https://claude.ai/settings/usage")
+        }
+    }
+
+    @Test
+    func `remembers provider when menu opens`() {
         self.disableMenuCardsForTesting()
         let settings = self.makeSettings()
         settings.statusChecksEnabled = false
@@ -70,6 +227,7 @@ struct StatusMenuTests {
             updater: DisabledUpdaterController(),
             preferencesSelection: PreferencesSelection(),
             statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
 
         let claudeMenu = controller.makeMenu()
         controller.menuWillOpen(claudeMenu)
@@ -87,7 +245,7 @@ struct StatusMenuTests {
     }
 
     @Test
-    func mergedMenuOpenDoesNotPersistResolvedProviderWhenSelectionIsNil() {
+    func `merged menu open does not persist resolved provider when selection is nil`() {
         self.disableMenuCardsForTesting()
         let settings = self.makeSettings()
         settings.statusChecksEnabled = false
@@ -96,16 +254,12 @@ struct StatusMenuTests {
         settings.selectedMenuProvider = nil
 
         let registry = ProviderRegistry.shared
-        var enabledProviders: [UsageProvider] = []
+        let selectedProviders: Set<UsageProvider> = [.codex, .claude]
         for provider in UsageProvider.allCases {
             guard let metadata = registry.metadata[provider] else { continue }
-            let shouldEnable = enabledProviders.count < 2
+            let shouldEnable = selectedProviders.contains(provider)
             settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: shouldEnable)
-            if shouldEnable {
-                enabledProviders.append(provider)
-            }
         }
-        #expect(enabledProviders.count == 2)
 
         let fetcher = UsageFetcher()
         let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
@@ -116,6 +270,7 @@ struct StatusMenuTests {
             updater: DisabledUpdaterController(),
             preferencesSelection: PreferencesSelection(),
             statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
 
         let expectedResolved = store.enabledProviders().first ?? .codex
         #expect(store.enabledProviders().count > 1)
@@ -128,13 +283,102 @@ struct StatusMenuTests {
     }
 
     @Test
-    func mergedMenuRefreshUsesResolvedEnabledProviderWhenPersistedSelectionIsDisabled() {
+    func `shortcut closes tracked menu instead of queueing another open`() {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        let key = ObjectIdentifier(menu)
+        controller.openMenus[key] = menu
+        #expect(controller.openMenus[key] != nil)
+
+        #expect(controller.closeOpenMenusFromShortcutIfNeeded() == true)
+        #expect(controller.openMenus.isEmpty)
+        #expect(controller.menuRefreshTasks.isEmpty)
+        #expect(controller.closeOpenMenusFromShortcutIfNeeded() == false)
+    }
+
+    @Test
+    func `open menu defers store data refresh until next open`() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: UsageFetcher().loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        let key = ObjectIdentifier(menu)
+        controller.openMenus[key] = menu
+        StatusItemController.setMenuRefreshEnabledForTesting(true)
+        defer { StatusItemController.resetMenuRefreshEnabledForTesting() }
+        let openedVersion = controller.menuVersions[key]
+
+        let now = Date()
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 11,
+                    windowMinutes: 300,
+                    resetsAt: now.addingTimeInterval(1800),
+                    resetDescription: nil),
+                secondary: nil,
+                tertiary: nil,
+                updatedAt: now,
+                identity: ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: "codex@example.com",
+                    accountOrganization: nil,
+                    loginMethod: "Plus Plan")),
+            provider: .codex)
+
+        for _ in 0..<50 where controller.menuContentVersion == openedVersion {
+            await Task.yield()
+        }
+
+        let staleVersion = controller.menuContentVersion
+        controller.refreshOpenMenusIfNeeded()
+
+        #expect(controller.menuContentVersion != openedVersion)
+        #expect(controller.menuVersions[key] == openedVersion)
+
+        controller.menuDidClose(menu)
+        controller.menuWillOpen(menu)
+        #expect(controller.menuVersions[key] == staleVersion)
+    }
+
+    @Test
+    func `merged menu refresh uses resolved enabled provider when selection is cleared`() {
         self.disableMenuCardsForTesting()
         let settings = self.makeSettings()
         settings.statusChecksEnabled = false
         settings.refreshFrequency = .manual
         settings.mergeIcons = true
         settings.selectedMenuProvider = .codex
+        settings.openAIWebAccessEnabled = true
 
         let registry = ProviderRegistry.shared
         if let codexMeta = registry.metadata[.codex] {
@@ -166,6 +410,7 @@ struct StatusMenuTests {
             updater: DisabledUpdaterController(),
             preferencesSelection: PreferencesSelection(),
             statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
 
         let expectedResolved = store.enabledProviders().first ?? .codex
         #expect(store.enabledProviders().count > 1)
@@ -185,7 +430,7 @@ struct StatusMenuTests {
         controller.menuWillOpen(menu)
 
         #expect(controller.lastMenuProvider == expectedResolved)
-        #expect(settings.selectedMenuProvider == .codex)
+        #expect(settings.selectedMenuProvider == nil)
         #expect(hasOpenAIWebSubmenus(menu) == false)
 
         controller.menuContentVersion &+= 1
@@ -195,7 +440,123 @@ struct StatusMenuTests {
     }
 
     @Test
-    func openMergedMenuRebuildsSwitcherWhenUsageBarsModeChanges() {
+    func `delayed menu refresh skips when refresh disabled during delay`() async {
+        StatusItemController.menuCardRenderingEnabled = false
+        StatusItemController.setMenuRefreshEnabledForTesting(true)
+        StatusItemController.setMenuOpenRefreshDelayForTesting(.milliseconds(50))
+        defer {
+            StatusItemController.resetMenuOpenRefreshDelayForTesting()
+            StatusItemController.resetMenuRefreshEnabledForTesting()
+        }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        var delayedRefreshWakeCount = 0
+
+        await withStatusItemControllerForTesting(
+            store: store,
+            settings: settings,
+            fetcher: fetcher,
+            statusBar: self.makeStatusBarForTesting())
+        { controller in
+            controller.onDelayedMenuRefreshAttemptForTesting = {
+                delayedRefreshWakeCount += 1
+            }
+            let menu = controller.makeMenu()
+            controller.menuWillOpen(menu)
+            controller.menuRefreshEnabledOverrideForTesting = false
+            try? await Task.sleep(for: .milliseconds(180))
+        }
+
+        #expect(delayedRefreshWakeCount == 0)
+    }
+
+    @Test
+    func `login state callbacks do not attach menus after release`() {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+
+        controller.releaseStatusItemsForTesting()
+        #expect(controller.statusItem.menu == nil)
+        #expect(controller.statusItems.isEmpty)
+
+        controller.activeLoginProvider = .codex
+        let loginTask = Task<Void, Never> {}
+        controller.loginTask = loginTask
+        loginTask.cancel()
+        controller.loginTask = nil
+        controller.activeLoginProvider = nil
+
+        #expect(controller.statusItem.menu == nil)
+        #expect(controller.statusItems.isEmpty)
+    }
+
+    @Test
+    func `display only dashboard does not show code review in status menu card`() throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+
+        let fetcher = UsageFetcher()
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+
+        let model = try #require(controller.menuCardModel(for: .codex))
+        #expect(model.metrics.contains { $0.id == "code-review" } == false)
+    }
+
+    @Test
+    func `display only dashboard does not show code review in providers pane`() {
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false)
+        let pane = ProvidersPane(settings: settings, store: store)
+
+        let model = pane._test_menuCardModel(for: .codex)
+        #expect(model.metrics.contains { $0.id == "code-review" } == false)
+    }
+
+    @Test
+    func `attached dashboard still shows code review in providers pane`() {
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+
+        let store = self.makeCodexStore(settings: settings, dashboardAuthorized: true)
+        let pane = ProvidersPane(settings: settings, store: store)
+
+        let model = pane._test_menuCardModel(for: .codex)
+        #expect(model.metrics.contains { $0.id == "code-review" && $0.percent == 88 })
+    }
+
+    @Test
+    func `open merged menu rebuilds switcher when usage bars mode changes`() async {
         self.disableMenuCardsForTesting()
         let settings = self.makeSettings()
         settings.statusChecksEnabled = false
@@ -226,6 +587,8 @@ struct StatusMenuTests {
 
         let menu = controller.makeMenu()
         controller.menuWillOpen(menu)
+        controller.openMenus[ObjectIdentifier(menu)] = menu
+        controller.menuRefreshEnabledOverrideForTesting = true
 
         let initialSwitcher = menu.items.first?.view as? ProviderSwitcherView
         #expect(initialSwitcher != nil)
@@ -233,6 +596,18 @@ struct StatusMenuTests {
 
         settings.usageBarsShowUsed = true
         controller.handleProviderConfigChange(reason: "usageBarsShowUsed")
+        for _ in 0..<20 {
+            await Task.yield()
+        }
+
+        #expect(controller.parentMenuRebuildsDeferredDuringTracking.contains(ObjectIdentifier(menu)))
+        if let initialSwitcherID, let currentSwitcher = menu.items.first?.view as? ProviderSwitcherView {
+            #expect(initialSwitcherID == ObjectIdentifier(currentSwitcher))
+        }
+
+        controller.menuDidClose(menu)
+        controller.menuWillOpen(menu)
+        defer { controller.menuDidClose(menu) }
 
         let updatedSwitcher = menu.items.first?.view as? ProviderSwitcherView
         #expect(updatedSwitcher != nil)
@@ -242,7 +617,7 @@ struct StatusMenuTests {
     }
 
     @Test
-    func mergedSwitcherIncludesOverviewTabWhenMultipleProvidersEnabled() {
+    func `merged switcher includes overview tab when multiple providers enabled`() {
         self.disableMenuCardsForTesting()
         let settings = self.makeSettings()
         settings.statusChecksEnabled = false
@@ -272,13 +647,13 @@ struct StatusMenuTests {
         controller.menuWillOpen(menu)
 
         let buttons = self.switcherButtons(in: menu)
-        #expect(buttons.count == store.enabledProviders().count + 1)
+        #expect(buttons.count == store.enabledProvidersForDisplay().count + 1)
         #expect(buttons.contains(where: { $0.tag == 0 }))
         #expect(buttons.first(where: { $0.state == .on })?.tag == 2)
     }
 
     @Test
-    func mergedSwitcherOverviewSelectionPersistsWithoutOverwritingProviderSelection() {
+    func `merged switcher overview selection persists without overwriting provider selection`() {
         self.disableMenuCardsForTesting()
         let settings = self.makeSettings()
         settings.statusChecksEnabled = false
@@ -323,7 +698,7 @@ struct StatusMenuTests {
     }
 
     @Test
-    func openMenuRebuildsSwitcherWhenOverviewAvailabilityChanges() {
+    func `open menu rebuilds switcher when overview availability changes`() {
         self.disableMenuCardsForTesting()
         let settings = self.makeSettings()
         settings.statusChecksEnabled = false
@@ -361,6 +736,8 @@ struct StatusMenuTests {
 
         let menu = controller.makeMenu()
         controller.menuWillOpen(menu)
+        controller.openMenus[ObjectIdentifier(menu)] = menu
+        controller.menuRefreshEnabledOverrideForTesting = true
 
         let initialButtons = self.switcherButtons(in: menu)
         #expect(initialButtons.count == activeProviders.count)
@@ -370,14 +747,15 @@ struct StatusMenuTests {
             isSelected: true,
             activeProviders: activeProviders)
         controller.menuContentVersion &+= 1
-        controller.refreshOpenMenusIfNeeded()
+        controller.menuDidClose(menu)
+        controller.menuWillOpen(menu)
 
         let updatedButtons = self.switcherButtons(in: menu)
         #expect(updatedButtons.count == activeProviders.count + 1)
     }
 
     @Test
-    func overviewTabOmitsContextualProviderActions() {
+    func `overview tab omits contextual provider actions`() throws {
         self.disableMenuCardsForTesting()
         let settings = self.makeSettings()
         settings.statusChecksEnabled = false
@@ -411,19 +789,76 @@ struct StatusMenuTests {
         #expect(!titles.contains("Switch Account..."))
         #expect(!titles.contains("Usage Dashboard"))
         #expect(!titles.contains("Status Page"))
+        #expect(titles.contains("Refresh"))
         #expect(titles.contains("Settings..."))
         #expect(titles.contains("About CodexBar"))
         #expect(titles.contains("Quit"))
+
+        let refreshItem = try #require(menu.items.first { $0.title == "Refresh" })
+        #expect(controller.isPersistentRefreshItem(refreshItem))
+        #expect(refreshItem.keyEquivalent.isEmpty)
+
+        let settingsItem = menu.items.first { $0.title == "Settings..." }
+        #expect(settingsItem != nil)
+        #expect(settingsItem?.keyEquivalent == ",")
+        #expect(settingsItem?.keyEquivalentModifierMask == [.command])
+
+        let quitItem = menu.items.first { $0.title == "Quit" }
+        #expect(quitItem != nil)
+        #expect(quitItem?.keyEquivalent == "q")
+        #expect(quitItem?.keyEquivalentModifierMask == [.command])
+    }
+}
+
+@MainActor
+extension StatusMenuTests {
+    @Test
+    func `status blurb uses wrapped view-backed menu item`() {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = true
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: provider == .codex)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let statusText = "An SSL error has occurred and a secure connection to the server cannot be made."
+        store.statuses[.codex] = ProviderStatus(
+            indicator: .critical,
+            description: statusText,
+            updatedAt: nil)
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+
+        let menu = controller.makeMenu(for: .codex)
+        controller.menuWillOpen(menu)
+
+        let statusItem = menu.items.first(where: { $0.toolTip == statusText })
+        #expect(statusItem != nil)
+        #expect(statusItem?.view != nil)
+        #expect(statusItem?.title.isEmpty == true)
+        #expect(statusItem?.view?.frame.width == 310)
     }
 
     @Test
-    func providerToggleUpdatesStatusItemVisibility() {
+    func `provider toggle updates status item visibility`() {
         self.disableMenuCardsForTesting()
         let settings = self.makeSettings()
         settings.statusChecksEnabled = false
         settings.refreshFrequency = .manual
         settings.mergeIcons = false
-        settings.providerDetectionCompleted = true
 
         let registry = ProviderRegistry.shared
         if let codexMeta = registry.metadata[.codex] {
@@ -445,6 +880,7 @@ struct StatusMenuTests {
             updater: DisabledUpdaterController(),
             preferencesSelection: PreferencesSelection(),
             statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
 
         #expect(controller.statusItems[.claude]?.isVisible == true)
 
@@ -452,11 +888,55 @@ struct StatusMenuTests {
             settings.setProviderEnabled(provider: .claude, metadata: claudeMeta, enabled: false)
         }
         controller.handleProviderConfigChange(reason: "test")
-        #expect(controller.statusItems[.claude]?.isVisible == false)
+        #expect(controller.statusItems[.claude] == nil)
     }
 
     @Test
-    func hidesOpenAIWebSubmenusWhenNoHistory() {
+    func `provider config changes preserve status item instances`() throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+
+        let registry = ProviderRegistry.shared
+        try settings.setProviderEnabled(provider: .codex, metadata: #require(registry.metadata[.codex]), enabled: true)
+        try settings.setProviderEnabled(
+            provider: .claude,
+            metadata: #require(registry.metadata[.claude]),
+            enabled: true)
+        try settings.setProviderEnabled(
+            provider: .gemini,
+            metadata: #require(registry.metadata[.gemini]),
+            enabled: false)
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+
+        let codexItem = try #require(controller.statusItems[.codex])
+        #expect(controller.statusItem.autosaveName == "codexbar-merged")
+        #expect(codexItem.autosaveName == "codexbar-codex")
+
+        try settings.setProviderEnabled(
+            provider: .gemini,
+            metadata: #require(registry.metadata[.gemini]),
+            enabled: true)
+        controller.handleProviderConfigChange(reason: "test")
+
+        #expect(controller.statusItems[.codex] === codexItem)
+        #expect(controller.statusItems[.codex]?.autosaveName == "codexbar-codex")
+        #expect(controller.statusItems[.gemini]?.autosaveName == "codexbar-gemini")
+    }
+
+    @Test
+    func `hides open AI web submenus when no history`() {
         self.disableMenuCardsForTesting()
         let settings = self.makeSettings()
         settings.statusChecksEnabled = false
@@ -493,6 +973,7 @@ struct StatusMenuTests {
             updater: DisabledUpdaterController(),
             preferencesSelection: PreferencesSelection(),
             statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
 
         let menu = controller.makeMenu()
         controller.menuWillOpen(menu)
@@ -502,7 +983,169 @@ struct StatusMenuTests {
     }
 
     @Test
-    func showsOpenAIWebSubmenusWhenHistoryExists() throws {
+    func `hides open AI web submenus when open AI web extras disabled`() {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .codex
+        settings.openAIWebAccessEnabled = false
+
+        let registry = ProviderRegistry.shared
+        if let codexMeta = registry.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+        if let claudeMeta = registry.metadata[.claude] {
+            settings.setProviderEnabled(provider: .claude, metadata: claudeMeta, enabled: false)
+        }
+        if let geminiMeta = registry.metadata[.gemini] {
+            settings.setProviderEnabled(provider: .gemini, metadata: geminiMeta, enabled: false)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let event = CreditEvent(date: Date(), service: "CLI", creditsUsed: 1)
+        let breakdown = OpenAIDashboardSnapshot.makeDailyBreakdown(from: [event], maxDays: 30)
+        store.openAIDashboard = OpenAIDashboardSnapshot(
+            signedInEmail: "user@example.com",
+            codeReviewRemainingPercent: 100,
+            creditEvents: [event],
+            dailyBreakdown: breakdown,
+            usageBreakdown: breakdown,
+            creditsPurchaseURL: nil,
+            updatedAt: Date())
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        let titles = Set(menu.items.map(\.title))
+        #expect(!titles.contains("Credits history"))
+        #expect(!titles.contains("Usage breakdown"))
+    }
+
+    @Test
+    func `hosted chart submenu matches widened parent menu width`() {
+        let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
+        let previousMenuRefresh = StatusItemController.menuRefreshEnabled
+        StatusItemController.menuCardRenderingEnabled = true
+        StatusItemController.setMenuRefreshEnabledForTesting(false)
+        defer {
+            StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering
+            StatusItemController.setMenuRefreshEnabledForTesting(previousMenuRefresh)
+        }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let event = CreditEvent(date: Date(), service: "CLI", creditsUsed: 1)
+        let breakdown = OpenAIDashboardSnapshot.makeDailyBreakdown(from: [event], maxDays: 30)
+        store.openAIDashboard = OpenAIDashboardSnapshot(
+            signedInEmail: "user@example.com",
+            codeReviewRemainingPercent: 100,
+            creditEvents: [event],
+            dailyBreakdown: breakdown,
+            usageBreakdown: breakdown,
+            creditsPurchaseURL: nil,
+            updatedAt: Date())
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+
+        let parentMenu = NSMenu()
+        parentMenu.autoenablesItems = false
+        let wideItem = NSMenuItem(title: String(repeating: "W", count: 60), action: nil, keyEquivalent: "")
+        parentMenu.addItem(wideItem)
+
+        let submenu = controller.makeHostedSubviewPlaceholderMenu(chartID: StatusItemController.usageBreakdownChartID)
+        let submenuItem = NSMenuItem(title: "Usage breakdown", action: nil, keyEquivalent: "")
+        submenuItem.submenu = submenu
+        parentMenu.addItem(submenuItem)
+
+        let parentWidth = ceil(parentMenu.size.width)
+        #expect(parentWidth > 310)
+
+        controller.hydrateHostedSubviewMenuIfNeeded(submenu)
+
+        let chartItem = submenu.items.first
+        #expect(chartItem?.representedObject as? String == StatusItemController.usageBreakdownChartID)
+        #expect(chartItem?.view != nil)
+        #expect(abs((chartItem?.view?.frame.width ?? 0) - parentWidth) <= 0.5)
+    }
+
+    @Test
+    func `hosted storage submenu is height capped and scroll enabled`() {
+        let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
+        let previousMenuRefresh = StatusItemController.menuRefreshEnabled
+        StatusItemController.menuCardRenderingEnabled = true
+        StatusItemController.setMenuRefreshEnabledForTesting(false)
+        defer {
+            StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering
+            StatusItemController.setMenuRefreshEnabledForTesting(previousMenuRefresh)
+        }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.providerStorageFootprintsEnabled = true
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let root = "/Users/test/.claude"
+        store.providerStorageFootprints[.claude] = ProviderStorageFootprint(
+            provider: .claude,
+            totalBytes: 1_756_000_000,
+            paths: [root],
+            missingPaths: [],
+            unreadablePaths: [],
+            components: [
+                .init(path: "\(root)/projects", totalBytes: 1_500_000_000),
+                .init(path: "\(root)/file-history", totalBytes: 103_000_000),
+                .init(path: "\(root)/telemetry", totalBytes: 51_000_000),
+                .init(path: "\(root)/plugins", totalBytes: 33_000_000),
+                .init(path: "\(root)/history.jsonl", totalBytes: 3_800_000),
+                .init(path: "\(root)/shell-snapshots", totalBytes: 1_500_000),
+                .init(path: "\(root)/plans", totalBytes: 1_100_000),
+                .init(path: "\(root)/paste-cache", totalBytes: 541_000),
+                .init(path: "\(root)/session-env", totalBytes: 208_000),
+                .init(path: "\(root)/todos", totalBytes: 6700),
+            ],
+            updatedAt: Date(timeIntervalSince1970: 0))
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+
+        let submenu = NSMenu()
+        let didAppend = controller.appendStorageBreakdownItem(to: submenu, provider: .claude, width: 310)
+
+        #expect(didAppend)
+        let item = submenu.items.first
+        #expect(item?.isEnabled == true)
+        #expect((item?.view?.frame.height ?? 0) <= 620)
+    }
+
+    @Test
+    func `shows open AI web submenus when history exists`() throws {
         self.disableMenuCardsForTesting()
         let settings = SettingsStore(
             configStore: testConfigStore(suiteName: "StatusMenuTests-history"),
@@ -512,6 +1155,7 @@ struct StatusMenuTests {
         settings.refreshFrequency = .manual
         settings.mergeIcons = true
         settings.selectedMenuProvider = .codex
+        settings.openAIWebAccessEnabled = true
 
         let registry = ProviderRegistry.shared
         if let codexMeta = registry.metadata[.codex] {
@@ -546,6 +1190,8 @@ struct StatusMenuTests {
             usageBreakdown: breakdown,
             creditsPurchaseURL: nil,
             updatedAt: Date())
+        store.openAIDashboardAttachmentAuthorized = true
+        store.openAIDashboardRequiresLogin = false
 
         let controller = StatusItemController(
             store: store,
@@ -554,6 +1200,7 @@ struct StatusMenuTests {
             updater: DisabledUpdaterController(),
             preferencesSelection: PreferencesSelection(),
             statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
 
         let menu = controller.makeMenu()
         controller.menuWillOpen(menu)
@@ -568,7 +1215,60 @@ struct StatusMenuTests {
     }
 
     @Test
-    func showsCreditsBeforeCostInCodexMenuCardSections() throws {
+    func `shows open AI API usage chart submenu without codex web history`() throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.selectedMenuProvider = .openai
+
+        let registry = ProviderRegistry.shared
+        let metadata = try #require(registry.metadata[.openai])
+        settings.setProviderEnabled(provider: .openai, metadata: metadata, enabled: true)
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let usage = OpenAIAPIUsageSnapshot(
+            daily: [
+                OpenAIAPIUsageSnapshot.DailyBucket(
+                    day: "2023-11-14",
+                    startTime: now,
+                    endTime: now.addingTimeInterval(86400),
+                    costUSD: 9,
+                    requests: 12,
+                    inputTokens: 100,
+                    cachedInputTokens: 0,
+                    outputTokens: 50,
+                    totalTokens: 150,
+                    lineItems: [],
+                    models: []),
+            ],
+            updatedAt: now)
+        store._setSnapshotForTesting(usage.toUsageSnapshot(), provider: .openai)
+
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu(for: .openai)
+        controller.menuWillOpen(menu)
+        let usageItem = menu.items.first { ($0.representedObject as? String) == "menuCardUsage" }
+
+        #expect(usageItem?.submenu?.items
+            .contains { ($0.representedObject as? String) == StatusItemController.costHistoryChartID } == true)
+        #expect(menu.items.contains { ($0.representedObject as? String) == "menuCardHeader" } == false)
+        #expect(menu.items.contains { ($0.representedObject as? String) == "menuCardExtraUsage" } == false)
+    }
+
+    @Test
+    func `shows credits before cost in codex menu card sections`() throws {
         self.disableMenuCardsForTesting()
         let settings = self.makeSettings()
         settings.statusChecksEnabled = false
@@ -599,6 +1299,8 @@ struct StatusMenuTests {
             usageBreakdown: [],
             creditsPurchaseURL: nil,
             updatedAt: Date())
+        store.openAIDashboardAttachmentAuthorized = true
+        store.openAIDashboardRequiresLogin = false
         store._setTokenSnapshotForTesting(CostUsageTokenSnapshot(
             sessionTokens: 123,
             sessionCostUSD: 0.12,
@@ -623,6 +1325,7 @@ struct StatusMenuTests {
             updater: DisabledUpdaterController(),
             preferencesSelection: PreferencesSelection(),
             statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
 
         let menu = controller.makeMenu()
         controller.menuWillOpen(menu)
@@ -635,7 +1338,66 @@ struct StatusMenuTests {
     }
 
     @Test
-    func showsExtraUsageForClaudeWhenUsingMenuCardSections() {
+    func `hosted cost submenu preserves provider context after empty hydration`() {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.costUsageEnabled = true
+
+        let registry = ProviderRegistry.shared
+        if let codexMeta = registry.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: self.makeStatusBarForTesting())
+
+        let submenu = controller.makeHostedSubviewPlaceholderMenu(
+            chartID: StatusItemController.costHistoryChartID,
+            provider: .codex)
+        #expect(submenu.autoenablesItems == false)
+        #expect(submenu.items.first?.isEnabled == true)
+
+        controller.hydrateHostedSubviewMenuIfNeeded(submenu)
+        #expect(submenu.items.count == 1)
+        #expect(submenu.items.first?.title == "No data available")
+        #expect(submenu.items.first?.toolTip == UsageProvider.codex.rawValue)
+
+        store._setTokenSnapshotForTesting(CostUsageTokenSnapshot(
+            sessionTokens: 123,
+            sessionCostUSD: 0.12,
+            last30DaysTokens: 123,
+            last30DaysCostUSD: 1.23,
+            daily: [
+                CostUsageDailyReport.Entry(
+                    date: "2025-12-23",
+                    inputTokens: nil,
+                    outputTokens: nil,
+                    totalTokens: 123,
+                    costUSD: 1.23,
+                    modelsUsed: nil,
+                    modelBreakdowns: nil),
+            ],
+            updatedAt: Date()), provider: .codex)
+
+        controller.hydrateHostedSubviewMenuIfNeeded(submenu)
+        #expect(submenu.items.count == 1)
+        #expect(submenu.items.first?.title != "No data available")
+        #expect(submenu.items.first?.representedObject as? String == StatusItemController.costHistoryChartID)
+        #expect(submenu.items.first?.isEnabled == true)
+    }
+
+    @Test
+    func `shows extra usage for claude when using menu card sections`() {
         self.disableMenuCardsForTesting()
         let settings = self.makeSettings()
         settings.statusChecksEnabled = false
@@ -701,6 +1463,7 @@ struct StatusMenuTests {
             updater: DisabledUpdaterController(),
             preferencesSelection: PreferencesSelection(),
             statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
 
         let menu = controller.makeMenu()
         controller.menuWillOpen(menu)
@@ -709,7 +1472,7 @@ struct StatusMenuTests {
     }
 
     @Test
-    func showsVertexCostWhenUsageErrorPresent() {
+    func `shows vertex cost when usage error present`() {
         self.disableMenuCardsForTesting()
         let settings = self.makeSettings()
         settings.statusChecksEnabled = false
@@ -756,6 +1519,7 @@ struct StatusMenuTests {
             updater: DisabledUpdaterController(),
             preferencesSelection: PreferencesSelection(),
             statusBar: self.makeStatusBarForTesting())
+        defer { controller.releaseStatusItemsForTesting() }
 
         let menu = controller.makeMenu()
         controller.menuWillOpen(menu)
@@ -766,7 +1530,7 @@ struct StatusMenuTests {
 
 extension StatusMenuTests {
     @Test
-    func overviewTabRendersOverviewRowsForAllActiveProvidersWhenThreeOrFewer() {
+    func `overview tab renders overview rows for all active providers when three or fewer`() {
         self.disableMenuCardsForTesting()
         let settings = self.makeSettings()
         settings.statusChecksEnabled = false
@@ -805,7 +1569,7 @@ extension StatusMenuTests {
     }
 
     @Test
-    func overviewTabHonorsStoredSubsetWhenThreeOrFewer() {
+    func `overview tab honors stored subset when three or fewer`() {
         self.disableMenuCardsForTesting()
         let settings = self.makeSettings()
         settings.statusChecksEnabled = false
@@ -848,7 +1612,7 @@ extension StatusMenuTests {
     }
 
     @Test
-    func overviewTabWithExplicitEmptySelectionIsHiddenAndShowsProviderDetail() {
+    func `overview tab with explicit empty selection is hidden and shows provider detail`() {
         self.disableMenuCardsForTesting()
         let settings = self.makeSettings()
         settings.statusChecksEnabled = false
@@ -883,7 +1647,7 @@ extension StatusMenuTests {
 
         let ids = self.representedIDs(in: menu)
         let switcherButtons = self.switcherButtons(in: menu)
-        #expect(switcherButtons.count == store.enabledProviders().count)
+        #expect(switcherButtons.count == store.enabledProvidersForDisplay().count)
         #expect(switcherButtons.contains(where: { $0.title == "Overview" }) == false)
         #expect(switcherButtons.contains(where: { $0.state == .on && $0.tag == 0 }))
         #expect(ids.contains("menuCard"))
@@ -893,9 +1657,9 @@ extension StatusMenuTests {
     }
 
     @Test
-    func overviewRowsKeepMenuItemActionInRenderedMode() throws {
+    func `overview rows keep menu item action in rendered mode`() throws {
         StatusItemController.menuCardRenderingEnabled = true
-        StatusItemController.menuRefreshEnabled = false
+        StatusItemController.setMenuRefreshEnabledForTesting(false)
         defer { self.disableMenuCardsForTesting() }
 
         let settings = self.makeSettings()
@@ -931,50 +1695,4 @@ extension StatusMenuTests {
         #expect(claudeRow.action != nil)
         #expect(claudeRow.target is StatusItemController)
     }
-
-    @Test
-    func selectingOverviewRowSwitchesToProviderDetail() throws {
-        self.disableMenuCardsForTesting()
-        let settings = self.makeSettings()
-        settings.statusChecksEnabled = false
-        settings.refreshFrequency = .manual
-        settings.mergeIcons = true
-        settings.selectedMenuProvider = .codex
-        settings.mergedMenuLastSelectedWasOverview = true
-
-        let registry = ProviderRegistry.shared
-        for provider in UsageProvider.allCases {
-            guard let metadata = registry.metadata[provider] else { continue }
-            let shouldEnable = provider == .codex || provider == .claude
-            settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: shouldEnable)
-        }
-
-        let fetcher = UsageFetcher()
-        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
-        let controller = StatusItemController(
-            store: store,
-            settings: settings,
-            account: fetcher.loadAccountInfo(),
-            updater: DisabledUpdaterController(),
-            preferencesSelection: PreferencesSelection(),
-            statusBar: self.makeStatusBarForTesting())
-
-        let menu = controller.makeMenu()
-        controller.menuWillOpen(menu)
-
-        let claudeRow = try #require(menu.items.first {
-            ($0.representedObject as? String) == "overviewRow-claude"
-        })
-        let action = try #require(claudeRow.action)
-        let target = try #require(claudeRow.target as? StatusItemController)
-        _ = target.perform(action, with: claudeRow)
-
-        #expect(settings.mergedMenuLastSelectedWasOverview == false)
-        #expect(settings.selectedMenuProvider == .claude)
-
-        let ids = self.representedIDs(in: menu)
-        #expect(ids.contains("menuCard"))
-        #expect(ids.contains(where: { $0.hasPrefix("overviewRow-") }) == false)
-        #expect(self.switcherButtons(in: menu).first(where: { $0.state == .on })?.tag == 2)
-    }
 }
diff --git a/Tests/CodexBarTests/StatusMenuTokenAccountSwitcherTests.swift b/Tests/CodexBarTests/StatusMenuTokenAccountSwitcherTests.swift
new file mode 100644
index 0000000000..fbe2bfb830
--- /dev/null
+++ b/Tests/CodexBarTests/StatusMenuTokenAccountSwitcherTests.swift
@@ -0,0 +1,532 @@
+import AppKit
+import CodexBarCore
+import Foundation
+import XCTest
+@testable import CodexBar
+
+@MainActor
+final class StatusMenuTokenAccountSwitcherTests: XCTestCase {
+    private func disableMenuCardsForTesting() {
+        StatusItemController.menuCardRenderingEnabled = false
+        StatusItemController.setMenuRefreshEnabledForTesting(false)
+    }
+
+    private func makeSettings() -> SettingsStore {
+        let settings = testSettingsStore(
+            suiteName: "StatusMenuTokenAccountSwitcherTests",
+            tokenAccountStore: InMemoryTokenAccountStore())
+        settings.providerDetectionCompleted = true
+        return settings
+    }
+
+    private func enableOnlyClaude(_ settings: SettingsStore) {
+        self.enableOnly(.claude, settings)
+    }
+
+    private func enableOnly(_ enabledProvider: UsageProvider, _ settings: SettingsStore) {
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: provider == enabledProvider)
+        }
+    }
+
+    private func representedIDs(in menu: NSMenu) -> [String] {
+        menu.items.compactMap { $0.representedObject as? String }
+    }
+
+    private func installBlockingClaudeProvider(on store: UsageStore, blocker: BlockingTokenAccountFetchStrategy) {
+        let baseSpec = store.providerSpecs[.claude]!
+        store.providerSpecs[.claude] = Self.makeClaudeProviderSpec(baseSpec: baseSpec) {
+            try await blocker.awaitResult()
+        }
+    }
+
+    private static func makeClaudeProviderSpec(
+        baseSpec: ProviderSpec,
+        loader: @escaping @Sendable () async throws -> UsageSnapshot) -> ProviderSpec
+    {
+        let baseDescriptor = baseSpec.descriptor
+        let strategy = StatusMenuTokenAccountFetchStrategy(loader: loader)
+        let descriptor = ProviderDescriptor(
+            id: .claude,
+            metadata: baseDescriptor.metadata,
+            branding: baseDescriptor.branding,
+            tokenCost: baseDescriptor.tokenCost,
+            fetchPlan: ProviderFetchPlan(
+                sourceModes: [.auto, .cli, .oauth],
+                pipeline: ProviderFetchPipeline { _ in [strategy] }),
+            cli: baseDescriptor.cli)
+        return ProviderSpec(
+            style: baseSpec.style,
+            isEnabled: baseSpec.isEnabled,
+            descriptor: descriptor,
+            makeFetchContext: baseSpec.makeFetchContext)
+    }
+
+    private func snapshot(percent: Double = 12) -> UsageSnapshot {
+        UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: percent,
+                windowMinutes: 300,
+                resetsAt: Date().addingTimeInterval(300),
+                resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .claude,
+                accountEmail: "claude@example.com",
+                accountOrganization: nil,
+                loginMethod: "OAuth"))
+    }
+
+    func test_tokenAccountMenuSelectionRefreshesProviderWhileGlobalRefreshIsActive() async throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        self.enableOnlyClaude(settings)
+        settings.addTokenAccount(provider: .claude, label: "Primary", token: "Bearer sk-ant-oat-primary")
+        settings.addTokenAccount(provider: .claude, label: "Secondary", token: "Bearer sk-ant-oat-secondary")
+        settings.setActiveTokenAccountIndex(0, for: .claude)
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let blocker = BlockingTokenAccountFetchStrategy()
+        self.installBlockingClaudeProvider(on: store, blocker: blocker)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: testStatusBar())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let refreshTask = Task { @MainActor in
+            await store.refresh()
+        }
+        await blocker.waitUntilStarted(count: 1)
+        XCTAssertTrue(store.isRefreshing)
+
+        let menu = controller.makeMenu()
+        defer { withExtendedLifetime(menu) {} }
+        controller.menuWillOpen(menu)
+        let switcher = try XCTUnwrap(menu.items.compactMap { $0.view as? TokenAccountSwitcherView }.first)
+
+        let selectionTask = try XCTUnwrap(switcher._test_select(index: 1))
+        XCTAssertEqual(settings.tokenAccountsData(for: .claude)?.clampedActiveIndex(), 1)
+        for _ in 0..<40 {
+            await Task.yield()
+        }
+        let startedBeforeDrain = await blocker.startedCallCount()
+        XCTAssertEqual(startedBeforeDrain, 1)
+
+        await blocker.resumeAll(with: .success(self.snapshot(percent: 17)))
+        await blocker.waitUntilStarted(count: 2)
+        await selectionTask.value
+        await refreshTask.value
+        let startedCallCount = await blocker.startedCallCount()
+        XCTAssertGreaterThanOrEqual(startedCallCount, 2)
+    }
+
+    func test_multiAccountSegmentedLayoutShowsCopilotSwitcher() throws {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.multiAccountMenuLayout = .segmented
+        self.enableOnly(.copilot, settings)
+        settings.addTokenAccount(provider: .copilot, label: "Primary", token: "gh_primary")
+        settings.addTokenAccount(provider: .copilot, label: "Secondary", token: "gh_secondary")
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: testStatusBar())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu(for: .copilot)
+        controller.menuWillOpen(menu)
+
+        _ = try XCTUnwrap(menu.items.compactMap { $0.view as? TokenAccountSwitcherView }.first)
+        XCTAssertEqual(self.representedIDs(in: menu).filter { $0.hasPrefix("menuCard") }, ["menuCard"])
+    }
+
+    func test_multiAccountStackedLayoutShowsCopilotCards() {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.multiAccountMenuLayout = .stacked
+        self.enableOnly(.copilot, settings)
+        settings.addTokenAccount(provider: .copilot, label: "Primary", token: "gh_primary")
+        settings.addTokenAccount(provider: .copilot, label: "Secondary", token: "gh_secondary")
+        let accounts = settings.tokenAccounts(for: .copilot)
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        store.accountSnapshots[.copilot] = accounts.enumerated().map { index, account in
+            TokenAccountUsageSnapshot(
+                account: account,
+                snapshot: self.snapshot(percent: Double(10 + index)),
+                error: nil,
+                sourceLabel: "test")
+        }
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: testStatusBar())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu(for: .copilot)
+        controller.menuWillOpen(menu)
+
+        XCTAssertNil(menu.items.compactMap { $0.view as? TokenAccountSwitcherView }.first)
+        XCTAssertEqual(self.representedIDs(in: menu).filter { $0.hasPrefix("menuCard") }, ["menuCard-0", "menuCard-1"])
+    }
+
+    func test_multiAccountStackedRefreshStartsAccountFetchesConcurrently() async {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.multiAccountMenuLayout = .stacked
+        self.enableOnlyClaude(settings)
+        settings.addTokenAccount(provider: .claude, label: "Primary", token: "Bearer sk-ant-oat-primary")
+        settings.addTokenAccount(provider: .claude, label: "Secondary", token: "Bearer sk-ant-oat-secondary")
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let blocker = BlockingTokenAccountFetchStrategy()
+        self.installBlockingClaudeProvider(on: store, blocker: blocker)
+
+        let refreshTask = Task { @MainActor in
+            await store.refreshProvider(.claude)
+        }
+
+        await blocker.waitUntilStarted(count: 2)
+        let startedBeforeResume = await blocker.startedCallCount()
+        XCTAssertEqual(startedBeforeResume, 2)
+
+        await blocker.resumeAll(with: .success(self.snapshot(percent: 17)))
+        await refreshTask.value
+        XCTAssertEqual(store.accountSnapshots[.claude]?.count, 2)
+    }
+
+    func test_multiAccountStackedLayoutIgnoresStaleSnapshotsAndKeepsMenuCapped() {
+        self.disableMenuCardsForTesting()
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.multiAccountMenuLayout = .stacked
+        self.enableOnly(.copilot, settings)
+        for index in 0..<8 {
+            settings.addTokenAccount(provider: .copilot, label: "Account \(index)", token: "gh_\(index)")
+        }
+        settings.setActiveTokenAccountIndex(7, for: .copilot)
+        let accounts = settings.tokenAccounts(for: .copilot)
+        let staleAccounts = (0..<2).map { index in
+            ProviderTokenAccount(
+                id: UUID(),
+                label: "Removed \(index)",
+                token: "stale_\(index)",
+                addedAt: TimeInterval(index),
+                lastUsed: nil)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let staleSnapshots = staleAccounts.enumerated().map { index, account in
+            TokenAccountUsageSnapshot(
+                account: account,
+                snapshot: self.snapshot(percent: Double(70 + index)),
+                error: nil,
+                sourceLabel: "stale")
+        }
+        let currentSnapshots = accounts.enumerated().map { index, account in
+            TokenAccountUsageSnapshot(
+                account: account,
+                snapshot: self.snapshot(percent: Double(10 + index)),
+                error: nil,
+                sourceLabel: "current")
+        }
+        store.accountSnapshots[.copilot] = staleSnapshots + currentSnapshots
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: testStatusBar())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu(for: .copilot)
+        controller.menuWillOpen(menu)
+
+        XCTAssertNil(menu.items.compactMap { $0.view as? TokenAccountSwitcherView }.first)
+        XCTAssertEqual(
+            self.representedIDs(in: menu).filter { $0.hasPrefix("menuCard") },
+            ["menuCard-0", "menuCard-1", "menuCard-2", "menuCard-3", "menuCard-4", "menuCard-5"])
+    }
+
+    func test_tokenAccountSwitchDefersOpenMenuRebuildUntilAfterSwitcherAction() async throws {
+        self.disableMenuCardsForTesting()
+        StatusItemController.setMenuRefreshEnabledForTesting(true)
+        defer { StatusItemController.setMenuRefreshEnabledForTesting(false) }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        settings.selectedMenuProvider = .claude
+        settings.multiAccountMenuLayout = .segmented
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            settings.setProviderEnabled(
+                provider: provider,
+                metadata: metadata,
+                enabled: provider == .claude || provider == .codex)
+        }
+        settings.addTokenAccount(provider: .claude, label: "Primary", token: "Bearer sk-ant-oat-primary")
+        settings.addTokenAccount(provider: .claude, label: "Secondary", token: "Bearer sk-ant-oat-secondary")
+        settings.setActiveTokenAccountIndex(0, for: .claude)
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        let blocker = BlockingTokenAccountFetchStrategy()
+        self.installBlockingClaudeProvider(on: store, blocker: blocker)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: testStatusBar())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu()
+        controller.menuWillOpen(menu)
+        let switcher = try XCTUnwrap(menu.items.compactMap { $0.view as? TokenAccountSwitcherView }.first)
+
+        var rebuildCount = 0
+        controller._test_openMenuRebuildObserver = { _ in
+            rebuildCount += 1
+        }
+        defer { controller._test_openMenuRebuildObserver = nil }
+
+        let selectionTask = try XCTUnwrap(switcher._test_select(index: 1))
+
+        XCTAssertEqual(rebuildCount, 0)
+        for _ in 0..<20 where rebuildCount == 0 {
+            await Task.yield()
+        }
+        XCTAssertEqual(rebuildCount, 1)
+
+        await blocker.waitUntilStarted(count: 1)
+        await blocker.resumeAll(with: .success(self.snapshot(percent: 17)))
+        await selectionTask.value
+        for _ in 0..<20 where rebuildCount < 2 {
+            await Task.yield()
+        }
+        XCTAssertEqual(rebuildCount, 2)
+    }
+
+    func test_tokenAccountSwitchUsesSelectedAccountCacheWhileRefreshIsInFlight() async throws {
+        self.disableMenuCardsForTesting()
+        StatusItemController.setMenuRefreshEnabledForTesting(true)
+        defer { StatusItemController.setMenuRefreshEnabledForTesting(false) }
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.multiAccountMenuLayout = .segmented
+        self.enableOnlyClaude(settings)
+        settings.addTokenAccount(provider: .claude, label: "Primary", token: "Bearer sk-ant-oat-primary")
+        settings.addTokenAccount(provider: .claude, label: "Secondary", token: "Bearer sk-ant-oat-secondary")
+        settings.setActiveTokenAccountIndex(0, for: .claude)
+        let accounts = settings.tokenAccounts(for: .claude)
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        store.snapshots[.claude] = self.snapshot(percent: 11)
+        store.lastKnownResetSnapshots[.claude] = self.snapshot(percent: 11)
+        store.errors[.claude] = "primary-error"
+        store.lastSourceLabels[.claude] = "primary-cache"
+        store.accountSnapshots[.claude] = [
+            TokenAccountUsageSnapshot(
+                account: accounts[0],
+                snapshot: self.snapshot(percent: 11),
+                error: nil,
+                sourceLabel: "primary-cache"),
+            TokenAccountUsageSnapshot(
+                account: accounts[1],
+                snapshot: self.snapshot(percent: 72),
+                error: nil,
+                sourceLabel: "secondary-cache"),
+        ]
+        let blocker = BlockingTokenAccountFetchStrategy()
+        self.installBlockingClaudeProvider(on: store, blocker: blocker)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: testStatusBar())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu(for: .claude)
+        controller.menuWillOpen(menu)
+        let switcher = try XCTUnwrap(menu.items.compactMap { $0.view as? TokenAccountSwitcherView }.first)
+
+        let selectionTask = try XCTUnwrap(switcher._test_select(index: 1))
+
+        XCTAssertEqual(store.snapshot(for: .claude)?.primary?.usedPercent, 72)
+        XCTAssertEqual(store.lastKnownResetSnapshots[.claude]?.primary?.usedPercent, 72)
+        XCTAssertNil(store.errors[.claude])
+        XCTAssertEqual(store.sourceLabel(for: .claude), "secondary-cache")
+
+        await blocker.waitUntilStarted(count: 1)
+        await blocker.resumeAll(with: .success(self.snapshot(percent: 45)))
+        await selectionTask.value
+    }
+
+    func test_tokenAccountSwitchClearsPreviousAccountSnapshotWithoutSelectedCache() async throws {
+        self.disableMenuCardsForTesting()
+
+        let settings = self.makeSettings()
+        settings.statusChecksEnabled = false
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = false
+        settings.multiAccountMenuLayout = .segmented
+        self.enableOnlyClaude(settings)
+        settings.addTokenAccount(provider: .claude, label: "Primary", token: "Bearer sk-ant-oat-primary")
+        settings.addTokenAccount(provider: .claude, label: "Secondary", token: "Bearer sk-ant-oat-secondary")
+        settings.setActiveTokenAccountIndex(0, for: .claude)
+        let accounts = settings.tokenAccounts(for: .claude)
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+        store.snapshots[.claude] = self.snapshot(percent: 11)
+        store.lastKnownResetSnapshots[.claude] = self.snapshot(percent: 11)
+        store.errors[.claude] = "primary-error"
+        store.lastSourceLabels[.claude] = "primary-cache"
+        store.accountSnapshots[.claude] = [
+            TokenAccountUsageSnapshot(
+                account: accounts[0],
+                snapshot: self.snapshot(percent: 11),
+                error: nil,
+                sourceLabel: "primary-cache"),
+        ]
+        let blocker = BlockingTokenAccountFetchStrategy()
+        self.installBlockingClaudeProvider(on: store, blocker: blocker)
+        let controller = StatusItemController(
+            store: store,
+            settings: settings,
+            account: fetcher.loadAccountInfo(),
+            updater: DisabledUpdaterController(),
+            preferencesSelection: PreferencesSelection(),
+            statusBar: testStatusBar())
+        defer { controller.releaseStatusItemsForTesting() }
+
+        let menu = controller.makeMenu(for: .claude)
+        controller.menuWillOpen(menu)
+        let switcher = try XCTUnwrap(menu.items.compactMap { $0.view as? TokenAccountSwitcherView }.first)
+
+        let selectionTask = try XCTUnwrap(switcher._test_select(index: 1))
+
+        XCTAssertNil(store.snapshot(for: .claude))
+        XCTAssertNil(store.lastKnownResetSnapshots[.claude])
+        XCTAssertNil(store.errors[.claude])
+        XCTAssertNil(store.lastSourceLabels[.claude])
+
+        await blocker.waitUntilStarted(count: 1)
+        await blocker.resumeAll(with: .success(self.snapshot(percent: 45)))
+        await selectionTask.value
+    }
+}
+
+private struct StatusMenuTokenAccountFetchStrategy: ProviderFetchStrategy {
+    let loader: @Sendable () async throws -> UsageSnapshot
+
+    var id: String {
+        "status-menu-token-account-test"
+    }
+
+    var kind: ProviderFetchKind {
+        .cli
+    }
+
+    func isAvailable(_: ProviderFetchContext) async -> Bool {
+        true
+    }
+
+    func fetch(_: ProviderFetchContext) async throws -> ProviderFetchResult {
+        let snapshot = try await self.loader()
+        return self.makeResult(usage: snapshot, sourceLabel: "status-menu-token-account-test")
+    }
+
+    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
+        false
+    }
+}
+
+private actor BlockingTokenAccountFetchStrategy {
+    private var waiters: [CheckedContinuation<Result<UsageSnapshot, Error>, Never>] = []
+    private var startedWaiters: [(count: Int, continuation: CheckedContinuation<Void, Never>)] = []
+    private var resolvedResult: Result<UsageSnapshot, Error>?
+    private var startedCount = 0
+
+    func awaitResult() async throws -> UsageSnapshot {
+        if let resolvedResult {
+            self.startedCount += 1
+            self.resumeStartedWaiters()
+            return try resolvedResult.get()
+        }
+        let result = await withCheckedContinuation { continuation in
+            self.waiters.append(continuation)
+            self.startedCount += 1
+            self.resumeStartedWaiters()
+        }
+        return try result.get()
+    }
+
+    func waitUntilStarted(count: Int) async {
+        if self.startedCount >= count { return }
+        await withCheckedContinuation { continuation in
+            self.startedWaiters.append((count: count, continuation: continuation))
+        }
+    }
+
+    func startedCallCount() -> Int {
+        self.startedCount
+    }
+
+    func resumeAll(with result: Result<UsageSnapshot, Error>) {
+        self.resolvedResult = result
+        self.waiters.forEach { $0.resume(returning: result) }
+        self.waiters.removeAll()
+    }
+
+    private func resumeStartedWaiters() {
+        let ready = self.startedWaiters.filter { self.startedCount >= $0.count }
+        self.startedWaiters.removeAll { self.startedCount >= $0.count }
+        ready.forEach { $0.continuation.resume() }
+    }
+}
diff --git a/Tests/CodexBarTests/StatusProbeTests.swift b/Tests/CodexBarTests/StatusProbeTests.swift
index b999019e45..dde1026a4b 100644
--- a/Tests/CodexBarTests/StatusProbeTests.swift
+++ b/Tests/CodexBarTests/StatusProbeTests.swift
@@ -3,10 +3,9 @@ import Foundation
 import Testing
 @testable import CodexBar
 
-@Suite
 struct StatusProbeTests {
     @Test
-    func parseCodexStatus() throws {
+    func `parse codex status`() throws {
         let sample = """
         Model: gpt
         Credits: 980 credits
@@ -20,20 +19,55 @@ struct StatusProbeTests {
     }
 
     @Test
-    func parseCodexStatusWithAnsiAndResets() throws {
+    func `parse codex status with ansi and resets`() throws {
+        let now = try #require(
+            Calendar(identifier: .gregorian).date(from: DateComponents(
+                timeZone: TimeZone.current,
+                year: 2026,
+                month: 11,
+                day: 26,
+                hour: 8,
+                minute: 0)))
         let sample = """
         \u{001B}[38;5;245mCredits:\u{001B}[0m 557 credits
         5h limit: [█████     ] 50% left (resets 09:01)
         Weekly limit: [███████   ] 85% left (resets 04:01 on 27 Nov)
         """
-        let snap = try CodexStatusProbe.parse(text: sample)
+        let snap = try CodexStatusProbe.parse(text: sample, now: now)
         #expect(snap.credits == 557)
         #expect(snap.fiveHourPercentLeft == 50)
         #expect(snap.weeklyPercentLeft == 85)
+        #expect(snap.fiveHourResetsAt == Calendar(identifier: .gregorian).date(from: DateComponents(
+            timeZone: TimeZone.current,
+            year: 2026,
+            month: 11,
+            day: 26,
+            hour: 9,
+            minute: 1)))
+        #expect(snap.weeklyResetsAt == Calendar(identifier: .gregorian).date(from: DateComponents(
+            timeZone: TimeZone.current,
+            year: 2026,
+            month: 11,
+            day: 27,
+            hour: 4,
+            minute: 1)))
+    }
+
+    @Test
+    func `parse codex status with weekly only line`() throws {
+        let sample = """
+        Model: gpt
+        Credits: 980 credits
+        Weekly limit: [##] 25% left
+        """
+        let snap = try CodexStatusProbe.parse(text: sample)
+        #expect(snap.credits == 980)
+        #expect(snap.fiveHourPercentLeft == nil)
+        #expect(snap.weeklyPercentLeft == 25)
     }
 
     @Test
-    func parseClaudeStatus() throws {
+    func `parse claude status`() throws {
         let sample = """
         Settings: Status   Config   Usage (tab to cycle)
 
@@ -64,7 +98,7 @@ struct StatusProbeTests {
     }
 
     @Test
-    func parseClaudeStatusWithANSI() throws {
+    func `parse claude status with ANSI`() throws {
         let sample = """
         \u{001B}[35mCurrent session\u{001B}[0m
         40% used  (Resets 11am)
@@ -86,7 +120,7 @@ struct StatusProbeTests {
     }
 
     @Test
-    func parseClaudeStatusLegacyOpusLabel() throws {
+    func `parse claude status legacy opus label`() throws {
         let sample = """
         Current session
         12% used  (Resets 11am)
@@ -107,7 +141,7 @@ struct StatusProbeTests {
     }
 
     @Test
-    func parseClaudeStatusRemainingKeyword() throws {
+    func `parse claude status remaining keyword`() throws {
         let sample = """
         Current session
         12% remaining (Resets 11am)
@@ -120,7 +154,7 @@ struct StatusProbeTests {
     }
 
     @Test
-    func parseClaudeStatusEnterpriseSessionOnly() throws {
+    func `parse claude status enterprise session only`() throws {
         let sample = """
         Current session
         █                                                  2% used
@@ -134,7 +168,7 @@ struct StatusProbeTests {
     }
 
     @Test
-    func parseClaudeStatusResetMappings_withCRLineEndings() throws {
+    func `parse claude status reset mappings with CR line endings`() throws {
         let sample =
             "Current  session\r" +
             "██████████████████████████████████████████████████  17% used\r" +
@@ -156,7 +190,7 @@ struct StatusProbeTests {
     }
 
     @Test
-    func parseClaudeStatusResetMappings_doesNotPromoteWeeklyResetToSession() throws {
+    func `parse claude status reset mappings does not promote weekly reset to session`() throws {
         let sample = """
         Current session
         ██████████████████████████████████████████████████  17% used
@@ -172,7 +206,7 @@ struct StatusProbeTests {
     }
 
     @Test
-    func parseClaudeStatusWithPlanAndAnsiNoise() throws {
+    func `parse claude status with plan and ansi noise`() throws {
         let sample = """
         Settings: Status   Config   Usage
 
@@ -197,7 +231,7 @@ struct StatusProbeTests {
     }
 
     @Test
-    func parseClaudeStatusWithExtraUsageSection() throws {
+    func `parse claude status with extra usage section`() throws {
         let sample = """
         Settings:  Status   Config   Usage  (tab to cycle)
 
@@ -225,7 +259,7 @@ struct StatusProbeTests {
     }
 
     @Test
-    func parseClaudeStatus_ignoresStatusBarContextPercent() throws {
+    func `parse claude status ignores status bar context percent`() throws {
         let sample = """
         Claude Code v2.1.29
         22:47 |  | Opus 4.5 | default | ░░░░░░░░░░ 0%  ◯ /ide for Visual Studio Code
@@ -254,7 +288,7 @@ struct StatusProbeTests {
     }
 
     @Test
-    func parseClaudeStatus_loadingPanelDoesNotReportZeroPercent() {
+    func `parse claude status loading panel surfaces loading stall`() {
         let sample = """
         Claude Code v2.1.29
         22:47 |  | Opus 4.5 | default | ░░░░░░░░░░ 0%  ◯ /ide for Visual Studio Code
@@ -267,7 +301,8 @@ struct StatusProbeTests {
         do {
             _ = try ClaudeStatusProbe.parse(text: sample)
             #expect(Bool(false), "Parsing should fail while /usage is still loading")
-        } catch ClaudeStatusProbeError.parseFailed {
+        } catch let ClaudeStatusProbeError.parseFailed(message) {
+            #expect(message.lowercased().contains("loading"))
             return
         } catch ClaudeStatusProbeError.timedOut {
             return
@@ -277,7 +312,34 @@ struct StatusProbeTests {
     }
 
     @Test
-    func parseClaudeStatus_statusOnlyOutputDoesNotFallbackToZero() {
+    func `parse claude retained usage panel classifies latest loading panel`() {
+        let sample = """
+        Settings:  Status   Config   Usage  (tab to cycle)
+        Current session
+        ███████▌15%used
+        Resets 11:30pm (Asia/Calcutta)
+
+        Current week (all models)
+        █▌ 3% used
+        Resets Feb 12 at 1:30pm (Asia/Calcutta)
+
+        Settings:  Status   Config   Usage  (tab to cycle)
+        Loading usage data…
+        Esc to cancel
+        """
+
+        do {
+            _ = try ClaudeStatusProbe.parse(text: sample)
+            #expect(Bool(false), "Parsing should fail while the latest /usage panel is still loading")
+        } catch let ClaudeStatusProbeError.parseFailed(message) {
+            #expect(message.lowercased().contains("loading"))
+        } catch {
+            #expect(Bool(false), "Unexpected error: \(error)")
+        }
+    }
+
+    @Test
+    func `parse claude status status only output does not fallback to zero`() {
         let sample = """
         Claude Code v2.1.32
         01:07 |  | Opus 4.6 | default | ░░░░░░░░░░ 0% left
@@ -298,7 +360,7 @@ struct StatusProbeTests {
     }
 
     @Test
-    func parseClaudeStatus_placeholderUsageWindowDoesNotUseStatusBarPercent() {
+    func `parse claude status placeholder usage window does not use status bar percent`() {
         let sample = """
         Claude Code v2.1.32
         01:07 |  | Opus 4.6 | default | ░░░░░░░░░░ 0% left
@@ -321,7 +383,7 @@ struct StatusProbeTests {
     }
 
     @Test
-    func parseClaudeStatus_compactMarkersStillParse() throws {
+    func `parse claude status compact markers still parse`() throws {
         let sample = """
         Settings:StatusConfigUsage(←/→ortabtocycle)
         Loadingusagedata…
@@ -340,10 +402,12 @@ struct StatusProbeTests {
         #expect(snap.sessionPercentLeft == 94)
         #expect(snap.weeklyPercentLeft == 96)
         #expect(snap.opusPercentLeft == 99)
+        #expect(snap.secondaryResetDescription == "ResetsFeb12at1:29pm(Asia/Calcutta)")
+        #expect(snap.opusResetDescription == "ResetsFeb12at1:29pm(Asia/Calcutta)")
     }
 
     @Test
-    func parseClaudeStatusWithBracketPlanNoiseNoEsc() throws {
+    func `parse claude status with bracket plan noise no esc`() throws {
         let sample = """
         Login method: [22m Claude Max Account
         Account: user@example.com
@@ -362,7 +426,7 @@ struct StatusProbeTests {
     }
 
     @Test
-    func surfacesClaudeTokenExpired() {
+    func `surfaces claude token expired`() {
         let sample = """
         Settings:  Status   Config   Usage
 
@@ -385,7 +449,7 @@ struct StatusProbeTests {
     }
 
     @Test
-    func surfacesClaudeRateLimited_compactUsageError() {
+    func `surfaces claude rate limited compact usage error`() {
         let sample = """
         Settings:StatusConfigUsage(←/→ortabtocycle)
         Error:Failedtoloadusagedata:{"error":{"message":"Ratelimited.Pleasetryagainlater.","type":"rate_limit_error"}}
@@ -404,7 +468,7 @@ struct StatusProbeTests {
     }
 
     @Test
-    func surfacesClaudeFolderTrustPrompt() {
+    func `surfaces claude folder trust prompt`() {
         let sample = """
         Do you trust the files in this folder?
 
@@ -424,7 +488,7 @@ struct StatusProbeTests {
     }
 
     @Test
-    func surfacesClaudeFolderTrustPrompt_withCRLFAndSpaces() {
+    func `surfaces claude folder trust prompt with CRLF and spaces`() {
         let sample = "Do you trust the files in this folder?\r\n\r\n/Users/example/My Project\r\n"
 
         do {
@@ -439,7 +503,7 @@ struct StatusProbeTests {
     }
 
     @Test
-    func surfacesClaudeFolderTrustPrompt_withoutFolderPath() {
+    func `surfaces claude folder trust prompt without folder path`() {
         let sample = """
         Do you trust the files in this folder?
         """
@@ -457,7 +521,78 @@ struct StatusProbeTests {
     }
 
     @Test
-    func parsesClaudeResetTimeOnly() throws {
+    func `surfaces claude subscription notice without quota data`() {
+        let sample = """
+        You are currently using your subscription to power your Claude Code usage
+        """
+
+        do {
+            _ = try ClaudeStatusProbe.parse(text: sample)
+            #expect(Bool(false), "Parsing should fail for subscription notice without quota data")
+        } catch let ClaudeStatusProbeError.parseFailed(message) {
+            let lower = message.lowercased()
+            #expect(lower.contains("subscription"))
+            #expect(!lower.contains("still loading"))
+        } catch {
+            #expect(Bool(false), "Unexpected error: \(error)")
+        }
+    }
+
+    @Test
+    func `parse claude status subscription notice is distinct from loading stall`() {
+        let subscriptionOnly = "You are currently using your subscription to power your Claude Code usage"
+        let loadingOnly = """
+        Settings:  Status   Config   Usage  (tab to cycle)
+        Loading usage data…
+        Esc to cancel
+        """
+
+        do {
+            _ = try ClaudeStatusProbe.parse(text: subscriptionOnly)
+            #expect(Bool(false), "Subscription notice should fail parsing")
+        } catch let ClaudeStatusProbeError.parseFailed(subMessage) {
+            #expect(!subMessage.lowercased().contains("still loading"))
+        } catch {
+            #expect(Bool(false), "Unexpected error for subscription: \(error)")
+        }
+
+        do {
+            _ = try ClaudeStatusProbe.parse(text: loadingOnly)
+            #expect(Bool(false), "Loading panel should fail parsing")
+        } catch let ClaudeStatusProbeError.parseFailed(loadMessage) {
+            #expect(loadMessage.lowercased().contains("loading"))
+        } catch {
+            #expect(Bool(false), "Unexpected error for loading: \(error)")
+        }
+    }
+
+    @Test
+    func `parse claude status mixed loading and subscription notice surfaces subscription error`() {
+        // PTY capture containing both an intermediate "Loading usage data…" panel and the final
+        // Claude CLI 2.1.148 subscription notice. The subscription error must be surfaced, not
+        // the still-loading stall, so the UI shows the precise subscription message.
+        let mixedCapture = """
+        Settings:  Status   Config   Usage  (tab to cycle)
+        Loading usage data…
+        Esc to cancel
+
+        You are currently using your subscription to power your Claude Code usage
+        """
+
+        do {
+            _ = try ClaudeStatusProbe.parse(text: mixedCapture)
+            #expect(Bool(false), "Parsing should fail for mixed loading+subscription capture")
+        } catch let ClaudeStatusProbeError.parseFailed(message) {
+            let lower = message.lowercased()
+            #expect(lower.contains("subscription"))
+            #expect(!lower.contains("still loading"))
+        } catch {
+            #expect(Bool(false), "Unexpected error for mixed capture: \(error)")
+        }
+    }
+
+    @Test
+    func `parses claude reset time only`() throws {
         let now = Date(timeIntervalSince1970: 1_733_690_000)
         let parsed = ClaudeStatusProbe.parseResetDate(from: "Resets 12:59pm (Europe/Helsinki)", now: now)
         let tz = try #require(TimeZone(identifier: "Europe/Helsinki"))
@@ -471,7 +606,7 @@ struct StatusProbeTests {
     }
 
     @Test
-    func parsesClaudeResetDateAndTime() throws {
+    func `parses claude reset date and time`() throws {
         let now = Date(timeIntervalSince1970: 1_733_690_000)
         let parsed = ClaudeStatusProbe.parseResetDate(from: "Resets Dec 9, 8:59am (Europe/Helsinki)", now: now)
         var calendar = Calendar(identifier: .gregorian)
@@ -487,7 +622,7 @@ struct StatusProbeTests {
     }
 
     @Test
-    func parsesClaudeResetWithDotSeparatedTime() throws {
+    func `parses claude reset with dot separated time`() throws {
         let now = Date(timeIntervalSince1970: 1_733_690_000)
         let parsed = ClaudeStatusProbe.parseResetDate(from: "Resets Dec 9 at 5.27am (UTC)", now: now)
         var calendar = Calendar(identifier: .gregorian)
@@ -497,7 +632,7 @@ struct StatusProbeTests {
     }
 
     @Test
-    func parsesClaudeResetWithCompactTimes() throws {
+    func `parses claude reset with compact times`() throws {
         let now = Date(timeIntervalSince1970: 1_733_690_000)
         let parsedTimeOnly = ClaudeStatusProbe.parseResetDate(from: "Resets 1pm (UTC)", now: now)
         var calendar = Calendar(identifier: .gregorian)
@@ -521,7 +656,17 @@ struct StatusProbeTests {
     }
 
     @Test
-    func liveCodexStatus() async throws {
+    func `parses claude reset with compact date and time no spaces`() throws {
+        let now = Date(timeIntervalSince1970: 1_773_097_200) // Mar 10, 2026 12:00:00 UTC
+        let parsed = ClaudeStatusProbe.parseResetDate(from: "ResetsMar13at12:30pm(Asia/Calcutta)", now: now)
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = try #require(TimeZone(identifier: "Asia/Calcutta"))
+        let expected = calendar.date(from: DateComponents(year: 2026, month: 3, day: 13, hour: 12, minute: 30))
+        #expect(parsed == expected)
+    }
+
+    @Test
+    func `live codex status`() async throws {
         guard ProcessInfo.processInfo.environment["LIVE_CODEX_STATUS"] == "1" else { return }
 
         let probe = CodexStatusProbe()
diff --git a/Tests/CodexBarTests/StepFunUsageFetcherTests.swift b/Tests/CodexBarTests/StepFunUsageFetcherTests.swift
new file mode 100644
index 0000000000..2c1ee8503a
--- /dev/null
+++ b/Tests/CodexBarTests/StepFunUsageFetcherTests.swift
@@ -0,0 +1,799 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct StepFunSettingsReaderTests {
+    @Test
+    func `reads STEPFUN_TOKEN`() {
+        let env = ["STEPFUN_TOKEN": "some-oasis-token-value"]
+        #expect(StepFunSettingsReader.token(environment: env) == "some-oasis-token-value")
+    }
+
+    @Test
+    func `reads STEPFUN_USERNAME`() {
+        let env = ["STEPFUN_USERNAME": "user@example.com"]
+        #expect(StepFunSettingsReader.username(environment: env) == "user@example.com")
+    }
+
+    @Test
+    func `reads STEPFUN_PASSWORD`() {
+        let env = ["STEPFUN_PASSWORD": "secret123"]
+        #expect(StepFunSettingsReader.password(environment: env) == "secret123")
+    }
+
+    @Test
+    func `trims whitespace from token`() {
+        let env = ["STEPFUN_TOKEN": "  some-token  "]
+        #expect(StepFunSettingsReader.token(environment: env) == "some-token")
+    }
+
+    @Test
+    func `strips double quotes from token`() {
+        let env = ["STEPFUN_TOKEN": "\"some-token\""]
+        #expect(StepFunSettingsReader.token(environment: env) == "some-token")
+    }
+
+    @Test
+    func `strips single quotes from token`() {
+        let env = ["STEPFUN_TOKEN": "'some-token'"]
+        #expect(StepFunSettingsReader.token(environment: env) == "some-token")
+    }
+
+    @Test
+    func `returns nil when no env vars present`() {
+        #expect(StepFunSettingsReader.token(environment: [:]) == nil)
+        #expect(StepFunSettingsReader.username(environment: [:]) == nil)
+        #expect(StepFunSettingsReader.password(environment: [:]) == nil)
+    }
+
+    @Test
+    func `returns nil for empty values`() {
+        let env = ["STEPFUN_TOKEN": "", "STEPFUN_USERNAME": "", "STEPFUN_PASSWORD": ""]
+        #expect(StepFunSettingsReader.token(environment: env) == nil)
+        #expect(StepFunSettingsReader.username(environment: env) == nil)
+        #expect(StepFunSettingsReader.password(environment: env) == nil)
+    }
+
+    @Test
+    func `returns nil for whitespace-only values`() {
+        let env = ["STEPFUN_TOKEN": "   "]
+        #expect(StepFunSettingsReader.token(environment: env) == nil)
+    }
+}
+
+struct StepFunProviderTokenResolverTests {
+    @Test
+    func `resolves token from environment`() {
+        let env = ["STEPFUN_TOKEN": "my-test-token"]
+        let resolution = ProviderTokenResolver.stepfunResolution(environment: env)
+        #expect(resolution?.token == "my-test-token")
+        #expect(resolution?.source == .environment)
+    }
+
+    @Test
+    func `returns nil when token absent`() {
+        let resolution = ProviderTokenResolver.stepfunResolution(environment: [:])
+        #expect(resolution == nil)
+    }
+}
+
+struct StepFunUsageFetcherParsingTests {
+    @Test
+    func `parses real API response format with string timestamps and integer rates`() throws {
+        // This matches the actual StepFun API response format:
+        // - timestamps as strings (e.g. "1777528800")
+        // - rates can be integers (e.g. 1) or floats (e.g. 0.99781543)
+        let json = """
+        {
+            "status": 1,
+            "desc": "",
+            "five_hour_usage_left_rate": 1,
+            "five_hour_usage_reset_time": "1777528800",
+            "weekly_usage_left_rate": 0.99781543,
+            "weekly_usage_reset_time": "1777899600"
+        }
+        """
+        let data = Data(json.utf8)
+        let snapshot = try StepFunUsageFetcher._parseSnapshotForTesting(data)
+
+        #expect(snapshot.fiveHourUsageLeftRate == 1.0)
+        #expect(snapshot.weeklyUsageLeftRate > 0.997 && snapshot.weeklyUsageLeftRate < 0.998)
+    }
+
+    @Test
+    func `parses response with float rates and integer timestamps`() throws {
+        let json = """
+        {
+            "status": 1,
+            "five_hour_usage_left_rate": 0.75,
+            "weekly_usage_left_rate": 0.5,
+            "five_hour_usage_reset_time": 1746000000,
+            "weekly_usage_reset_time": 1746500000
+        }
+        """
+        let data = Data(json.utf8)
+        let snapshot = try StepFunUsageFetcher._parseSnapshotForTesting(data)
+
+        #expect(snapshot.fiveHourUsageLeftRate == 0.75)
+        #expect(snapshot.weeklyUsageLeftRate == 0.5)
+    }
+
+    @Test
+    func `throws on failed API status`() {
+        let json = """
+        {
+            "status": 0,
+            "message": "Unauthorized",
+            "five_hour_usage_left_rate": 0.75,
+            "weekly_usage_left_rate": 0.5,
+            "five_hour_usage_reset_time": "1746000000",
+            "weekly_usage_reset_time": "1746500000"
+        }
+        """
+        let data = Data(json.utf8)
+        #expect(throws: StepFunUsageError.self) {
+            try StepFunUsageFetcher._parseSnapshotForTesting(data)
+        }
+    }
+
+    @Test
+    func `throws on missing fields`() {
+        let json = """
+        {
+            "status": 1
+        }
+        """
+        let data = Data(json.utf8)
+        #expect(throws: StepFunUsageError.self) {
+            try StepFunUsageFetcher._parseSnapshotForTesting(data)
+        }
+    }
+
+    @Test
+    func `throws on invalid JSON`() {
+        let data = Data("not json".utf8)
+        #expect(throws: StepFunUsageError.self) {
+            try StepFunUsageFetcher._parseSnapshotForTesting(data)
+        }
+    }
+
+    @Test
+    func `snapshot maps to UsageSnapshot correctly`() throws {
+        let json = """
+        {
+            "status": 1,
+            "five_hour_usage_left_rate": 0.8,
+            "weekly_usage_left_rate": 0.6,
+            "five_hour_usage_reset_time": "1746000000",
+            "weekly_usage_reset_time": "1746500000"
+        }
+        """
+        let data = Data(json.utf8)
+        let snapshot = try StepFunUsageFetcher._parseSnapshotForTesting(data)
+        let usage = snapshot.toUsageSnapshot()
+
+        // Five-hour window: 20% used (1.0 - 0.8)
+        let primaryUsed = usage.primary?.usedPercent ?? 0
+        #expect(primaryUsed > 19.9 && primaryUsed < 20.1)
+
+        // Weekly window: 40% used (1.0 - 0.6)
+        let secondaryUsed = usage.secondary?.usedPercent ?? 0
+        #expect(secondaryUsed > 39.9 && secondaryUsed < 40.1)
+        #expect(usage.secondary?.windowMinutes == 10080)
+
+        // Identity
+        #expect(usage.identity?.providerID == .stepfun)
+        #expect(usage.identity?.loginMethod == "password")
+    }
+
+    @Test
+    func `clamps used percent to 0-100 range`() throws {
+        let json = """
+        {
+            "status": 1,
+            "five_hour_usage_left_rate": 0.0,
+            "weekly_usage_left_rate": 1,
+            "five_hour_usage_reset_time": "1746000000",
+            "weekly_usage_reset_time": "1746500000"
+        }
+        """
+        let data = Data(json.utf8)
+        let snapshot = try StepFunUsageFetcher._parseSnapshotForTesting(data)
+        let usage = snapshot.toUsageSnapshot()
+
+        // 0% remaining → 100% used
+        #expect(usage.primary?.usedPercent == 100.0)
+        // 100% remaining → 0% used (integer 1 parsed as 1.0)
+        #expect(usage.secondary?.usedPercent == 0.0)
+    }
+}
+
+struct StepFunTokenNormalizerTests {
+    @Test
+    func `extracts Oasis-Token from cookie header`() {
+        let input = "Oasis-Token=abc123...def456; Oasis-Webid=someid"
+        #expect(StepFunTokenNormalizer.normalize(input) == "abc123...def456")
+    }
+
+    @Test
+    func `returns raw value when not a cookie header`() {
+        let input = "abc123...def456"
+        #expect(StepFunTokenNormalizer.normalize(input) == "abc123...def456")
+    }
+
+    @Test
+    func `returns empty for empty string`() {
+        #expect(StepFunTokenNormalizer.normalize("").isEmpty)
+    }
+
+    @Test
+    func `trims whitespace`() {
+        #expect(StepFunTokenNormalizer.normalize("  token123  ") == "token123")
+    }
+}
+
+@Suite(.serialized)
+struct StepFunTokenRefreshTests {
+    private struct StubClaudeFetcher: ClaudeUsageFetching {
+        func loadLatestUsage(model _: String) async throws -> ClaudeUsageSnapshot {
+            throw ClaudeUsageError.parseFailed("stub")
+        }
+
+        func debugRawProbe(model _: String) async -> String {
+            "stub"
+        }
+
+        func detectVersion() -> String? {
+            nil
+        }
+    }
+
+    @Test
+    func `refresh token returns combined token pair`() async throws {
+        try await self.withStubProtocol { recorder in
+            StepFunStubURLProtocol.handler = { request in
+                #expect(request.url?.path.contains("RefreshToken") == true)
+                #expect(request.value(forHTTPHeaderField: "Oasis-Token") == "old-access...old-refresh")
+                #expect(request.value(forHTTPHeaderField: "Cookie")?.contains("old-access...old-refresh") == true)
+                recorder.recordRefreshCall()
+                return Self.jsonResponse(
+                    for: request,
+                    body: """
+                    {
+                        "accessToken": {"raw": "new-access"},
+                        "refreshToken": {"raw": "new-refresh"}
+                    }
+                    """)
+            }
+
+            let token = try await StepFunUsageFetcher.refreshToken(token: "old-access...old-refresh")
+            #expect(token == "new-access...new-refresh")
+            #expect(recorder.refreshCallCount == 1)
+        }
+    }
+
+    @Test
+    func `manual token auth failure refreshes token account and retries usage`() async throws {
+        let accountID = UUID()
+        let updateRecorder = StepFunTokenUpdateRecorder()
+
+        try await self.withStubProtocol { recorder in
+            StepFunStubURLProtocol.handler = { request in
+                let path = request.url?.path ?? ""
+                if path.contains("QueryStepPlanRateLimit") {
+                    let call = recorder.recordUsageCall()
+                    if call == 1 {
+                        #expect(request.value(forHTTPHeaderField: "Cookie")?
+                            .contains("old-access...old-refresh") == true)
+                        return Self.jsonResponse(for: request, statusCode: 401, body: #"{"error":"unauthorized"}"#)
+                    }
+
+                    #expect(request.value(forHTTPHeaderField: "Cookie")?.contains("new-access...new-refresh") == true)
+                    return Self.usageResponse(for: request)
+                }
+
+                if path.contains("RefreshToken") {
+                    recorder.recordRefreshCall()
+                    #expect(request.value(forHTTPHeaderField: "Oasis-Token") == "old-access...old-refresh")
+                    return Self.jsonResponse(
+                        for: request,
+                        body: """
+                        {
+                            "accessToken": {"raw": "new-access"},
+                            "refreshToken": {"raw": "new-refresh"}
+                        }
+                        """)
+                }
+
+                if path.contains("GetStepPlanStatus") {
+                    return Self.jsonResponse(
+                        for: request,
+                        body: #"{"status":1,"subscription":{"name":"Plus","plan_type":1,"status":1}}"#)
+                }
+
+                return Self.jsonResponse(for: request, statusCode: 404, body: #"{"error":"unexpected"}"#)
+            }
+
+            let settings = ProviderSettingsSnapshot.make(
+                stepfun: ProviderSettingsSnapshot.StepFunProviderSettings(
+                    cookieSource: .manual,
+                    manualToken: "old-access...old-refresh"))
+            let context = self.makeContext(
+                settings: settings,
+                selectedTokenAccountID: accountID,
+                tokenUpdater: { provider, updatedAccountID, token in
+                    #expect(provider == .stepfun)
+                    #expect(updatedAccountID == accountID)
+                    await updateRecorder.record(token)
+                })
+
+            let result = try await StepFunWebFetchStrategy().fetch(context)
+
+            #expect(result.usage.identity?.loginMethod == "Plus")
+            #expect(recorder.usageCallCount == 2)
+            #expect(recorder.refreshCallCount == 1)
+            let updatedToken = await updateRecorder.recordedToken()
+            #expect(updatedToken == "new-access...new-refresh")
+        }
+    }
+
+    @Test
+    func `manual token auth failure refreshes settings token and retries usage`() async throws {
+        let updateRecorder = StepFunTokenUpdateRecorder()
+
+        try await self.withStubProtocol { recorder in
+            StepFunStubURLProtocol.handler = { request in
+                let path = request.url?.path ?? ""
+                if path.contains("QueryStepPlanRateLimit") {
+                    let call = recorder.recordUsageCall()
+                    if call == 1 {
+                        return Self.jsonResponse(for: request, statusCode: 401, body: #"{"error":"unauthorized"}"#)
+                    }
+
+                    #expect(request.value(forHTTPHeaderField: "Cookie")?.contains("new-access...new-refresh") == true)
+                    return Self.usageResponse(for: request)
+                }
+
+                if path.contains("RefreshToken") {
+                    recorder.recordRefreshCall()
+                    return Self.jsonResponse(
+                        for: request,
+                        body: """
+                        {
+                            "accessToken": {"raw": "new-access"},
+                            "refreshToken": {"raw": "new-refresh"}
+                        }
+                        """)
+                }
+
+                if path.contains("GetStepPlanStatus") {
+                    return Self.jsonResponse(
+                        for: request,
+                        body: #"{"status":1,"subscription":{"name":"Plus","plan_type":1,"status":1}}"#)
+                }
+
+                return Self.jsonResponse(for: request, statusCode: 404, body: #"{"error":"unexpected"}"#)
+            }
+
+            let settings = ProviderSettingsSnapshot.make(
+                stepfun: ProviderSettingsSnapshot.StepFunProviderSettings(
+                    cookieSource: .manual,
+                    manualToken: "old-access...old-refresh"))
+            let context = self.makeContext(
+                settings: settings,
+                manualTokenUpdater: { provider, token in
+                    #expect(provider == .stepfun)
+                    await updateRecorder.record(token)
+                })
+
+            _ = try await StepFunWebFetchStrategy().fetch(context)
+
+            #expect(recorder.usageCallCount == 2)
+            #expect(recorder.refreshCallCount == 1)
+            let updatedToken = await updateRecorder.recordedToken()
+            #expect(updatedToken == "new-access...new-refresh")
+        }
+    }
+
+    @Test
+    func `stale cached token falls back to configured env token`() async throws {
+        CookieHeaderCache.store(provider: .stepfun, cookieHeader: "stale-access...stale-refresh", sourceLabel: "test")
+        defer { CookieHeaderCache.clear(provider: .stepfun) }
+
+        try await self.withStubProtocol { recorder in
+            StepFunStubURLProtocol.handler = { request in
+                let path = request.url?.path ?? ""
+                if path.contains("QueryStepPlanRateLimit") {
+                    let call = recorder.recordUsageCall()
+                    if call == 1 {
+                        #expect(request.value(forHTTPHeaderField: "Cookie")?
+                            .contains("stale-access...stale-refresh") == true)
+                        return Self.jsonResponse(for: request, statusCode: 401, body: #"{"error":"unauthorized"}"#)
+                    }
+
+                    #expect(request.value(forHTTPHeaderField: "Cookie")?.contains("env-access...env-refresh") == true)
+                    return Self.usageResponse(for: request)
+                }
+
+                if path.contains("RefreshToken") {
+                    recorder.recordRefreshCall()
+                    return Self.jsonResponse(for: request, statusCode: 401, body: #"{"error":"expired"}"#)
+                }
+
+                if path.contains("GetStepPlanStatus") {
+                    return Self.jsonResponse(
+                        for: request,
+                        body: #"{"status":1,"subscription":{"name":"Plus","plan_type":1,"status":1}}"#)
+                }
+
+                return Self.jsonResponse(for: request, statusCode: 404, body: #"{"error":"unexpected"}"#)
+            }
+
+            let settings = ProviderSettingsSnapshot.make(
+                stepfun: ProviderSettingsSnapshot.StepFunProviderSettings(cookieSource: .auto))
+            let context = self.makeContext(
+                settings: settings,
+                env: ["STEPFUN_TOKEN": "env-access...env-refresh"])
+
+            _ = try await StepFunWebFetchStrategy().fetch(context)
+
+            #expect(recorder.usageCallCount == 2)
+            #expect(recorder.refreshCallCount == 1)
+            #expect(CookieHeaderCache.load(provider: .stepfun) == nil)
+        }
+    }
+
+    @Test
+    func `stale cached and env tokens fall back to env login credentials`() async throws {
+        CookieHeaderCache.store(provider: .stepfun, cookieHeader: "stale-access...stale-refresh", sourceLabel: "test")
+        defer { CookieHeaderCache.clear(provider: .stepfun) }
+
+        try await self.withStubProtocol { recorder in
+            StepFunStubURLProtocol.handler = { request in
+                let path = request.url?.path ?? ""
+                if path.isEmpty || path == "/" {
+                    return Self.jsonResponse(
+                        for: request,
+                        body: "{}",
+                        headers: ["Set-Cookie": "INGRESSCOOKIE=ingress-cookie; Path=/"])
+                }
+
+                if path.contains("RegisterDevice") {
+                    return Self.jsonResponse(
+                        for: request,
+                        body: """
+                        {
+                            "accessToken": {"raw": "anon-access"},
+                            "refreshToken": {"raw": "anon-refresh"}
+                        }
+                        """)
+                }
+
+                if path.contains("SignInByPassword") {
+                    return Self.jsonResponse(
+                        for: request,
+                        body: """
+                        {
+                            "accessToken": {"raw": "login-access"},
+                            "refreshToken": {"raw": "login-refresh"}
+                        }
+                        """)
+                }
+
+                if path.contains("QueryStepPlanRateLimit") {
+                    let call = recorder.recordUsageCall()
+                    if call == 1 {
+                        #expect(request.value(forHTTPHeaderField: "Cookie")?
+                            .contains("stale-access...stale-refresh") == true)
+                        return Self.jsonResponse(for: request, statusCode: 401, body: #"{"error":"unauthorized"}"#)
+                    }
+                    if call == 2 {
+                        #expect(request.value(forHTTPHeaderField: "Cookie")?
+                            .contains("env-access...env-refresh") == true)
+                        return Self.jsonResponse(for: request, statusCode: 401, body: #"{"error":"unauthorized"}"#)
+                    }
+
+                    #expect(request.value(forHTTPHeaderField: "Cookie")?
+                        .contains("login-access...login-refresh") == true)
+                    return Self.usageResponse(for: request)
+                }
+
+                if path.contains("RefreshToken") {
+                    recorder.recordRefreshCall()
+                    return Self.jsonResponse(for: request, statusCode: 401, body: #"{"error":"expired"}"#)
+                }
+
+                if path.contains("GetStepPlanStatus") {
+                    return Self.jsonResponse(
+                        for: request,
+                        body: #"{"status":1,"subscription":{"name":"Plus","plan_type":1,"status":1}}"#)
+                }
+
+                return Self.jsonResponse(for: request, statusCode: 404, body: #"{"error":"unexpected"}"#)
+            }
+
+            let settings = ProviderSettingsSnapshot.make(
+                stepfun: ProviderSettingsSnapshot.StepFunProviderSettings(cookieSource: .auto))
+            let context = self.makeContext(
+                settings: settings,
+                env: [
+                    "STEPFUN_TOKEN": "env-access...env-refresh",
+                    "STEPFUN_USERNAME": "user@example.com",
+                    "STEPFUN_PASSWORD": "password",
+                ])
+
+            _ = try await StepFunWebFetchStrategy().fetch(context)
+
+            #expect(recorder.usageCallCount == 3)
+            #expect(recorder.refreshCallCount == 1)
+            #expect(CookieHeaderCache.load(provider: .stepfun)?.cookieHeader == "login-access...login-refresh")
+        }
+    }
+
+    @Test
+    func `post refresh non auth usage failure is not rewritten as auth guidance`() async throws {
+        try await self.withStubProtocol { recorder in
+            StepFunStubURLProtocol.handler = { request in
+                let path = request.url?.path ?? ""
+                if path.contains("QueryStepPlanRateLimit") {
+                    let call = recorder.recordUsageCall()
+                    if call == 1 {
+                        return Self.jsonResponse(for: request, statusCode: 401, body: #"{"error":"unauthorized"}"#)
+                    }
+                    return Self.jsonResponse(for: request, statusCode: 500, body: #"{"error":"temporary"}"#)
+                }
+
+                if path.contains("RefreshToken") {
+                    recorder.recordRefreshCall()
+                    return Self.jsonResponse(
+                        for: request,
+                        body: """
+                        {
+                            "accessToken": {"raw": "new-access"},
+                            "refreshToken": {"raw": "new-refresh"}
+                        }
+                        """)
+                }
+
+                return Self.jsonResponse(for: request, statusCode: 404, body: #"{"error":"unexpected"}"#)
+            }
+
+            let settings = ProviderSettingsSnapshot.make(
+                stepfun: ProviderSettingsSnapshot.StepFunProviderSettings(
+                    cookieSource: .manual,
+                    manualToken: "old-access...old-refresh"))
+            let context = self.makeContext(settings: settings)
+
+            do {
+                _ = try await StepFunWebFetchStrategy().fetch(context)
+                Issue.record("Expected post-refresh usage failure")
+            } catch let StepFunUsageError.apiError(message) {
+                #expect(message == "HTTP 500")
+            } catch {
+                Issue.record("Expected StepFunUsageError.apiError, got \(error)")
+            }
+
+            #expect(recorder.usageCallCount == 2)
+            #expect(recorder.refreshCallCount == 1)
+        }
+    }
+
+    @Test
+    func `manual token refresh failure does not fall back to ambient env credentials`() async throws {
+        try await self.withStubProtocol { recorder in
+            StepFunStubURLProtocol.handler = { request in
+                let path = request.url?.path ?? ""
+                if path.contains("QueryStepPlanRateLimit") {
+                    _ = recorder.recordUsageCall()
+                    return Self.jsonResponse(for: request, statusCode: 401, body: #"{"error":"unauthorized"}"#)
+                }
+
+                if path.contains("RefreshToken") {
+                    recorder.recordRefreshCall()
+                    return Self.jsonResponse(for: request, statusCode: 401, body: #"{"error":"expired"}"#)
+                }
+
+                Issue.record("Manual token recovery should not call login endpoint: \(path)")
+                return Self.jsonResponse(for: request, statusCode: 404, body: #"{"error":"unexpected"}"#)
+            }
+
+            let settings = ProviderSettingsSnapshot.make(
+                stepfun: ProviderSettingsSnapshot.StepFunProviderSettings(
+                    cookieSource: .manual,
+                    manualToken: "old-access...old-refresh"))
+            let context = self.makeContext(
+                settings: settings,
+                env: [
+                    "STEPFUN_USERNAME": "someone@example.com",
+                    "STEPFUN_PASSWORD": "secret",
+                ])
+
+            do {
+                _ = try await StepFunWebFetchStrategy().fetch(context)
+                Issue.record("Expected manual token auth failure")
+            } catch let StepFunUsageError.apiError(message) {
+                #expect(message.contains("Refresh the Oasis-Token"))
+            } catch {
+                Issue.record("Expected StepFunUsageError.apiError, got \(error)")
+            }
+
+            #expect(recorder.usageCallCount == 1)
+            #expect(recorder.refreshCallCount == 1)
+        }
+    }
+
+    @Test
+    func `non auth token wording does not trigger refresh recovery`() async throws {
+        try await self.withStubProtocol { recorder in
+            StepFunStubURLProtocol.handler = { request in
+                let path = request.url?.path ?? ""
+                if path.contains("QueryStepPlanRateLimit") {
+                    _ = recorder.recordUsageCall()
+                    return Self.jsonResponse(
+                        for: request,
+                        body: #"{"status":0,"message":"token plan status temporarily unavailable"}"#)
+                }
+
+                Issue.record("Non-auth usage error should not call recovery endpoint: \(path)")
+                return Self.jsonResponse(for: request, statusCode: 404, body: #"{"error":"unexpected"}"#)
+            }
+
+            let settings = ProviderSettingsSnapshot.make(
+                stepfun: ProviderSettingsSnapshot.StepFunProviderSettings(
+                    cookieSource: .manual,
+                    manualToken: "old-access...old-refresh"))
+            let context = self.makeContext(settings: settings)
+
+            do {
+                _ = try await StepFunWebFetchStrategy().fetch(context)
+                Issue.record("Expected provider API error")
+            } catch let StepFunUsageError.apiError(message) {
+                #expect(message == "token plan status temporarily unavailable")
+            } catch {
+                Issue.record("Expected StepFunUsageError.apiError, got \(error)")
+            }
+
+            #expect(recorder.usageCallCount == 1)
+            #expect(recorder.refreshCallCount == 0)
+        }
+    }
+
+    private func makeContext(
+        settings: ProviderSettingsSnapshot?,
+        env: [String: String] = [:],
+        selectedTokenAccountID: UUID? = nil,
+        tokenUpdater: ProviderFetchContext.TokenAccountTokenUpdater? = nil,
+        manualTokenUpdater: ProviderFetchContext.ProviderManualTokenUpdater? = nil) -> ProviderFetchContext
+    {
+        ProviderFetchContext(
+            runtime: .app,
+            sourceMode: .auto,
+            includeCredits: false,
+            webTimeout: 1,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: env,
+            settings: settings,
+            fetcher: UsageFetcher(environment: [:]),
+            claudeFetcher: StubClaudeFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            selectedTokenAccountID: selectedTokenAccountID,
+            tokenAccountTokenUpdater: tokenUpdater,
+            providerManualTokenUpdater: manualTokenUpdater)
+    }
+
+    private func withStubProtocol(
+        _ body: (StepFunRequestRecorder) async throws -> Void) async throws
+    {
+        let recorder = StepFunRequestRecorder()
+        let registered = URLProtocol.registerClass(StepFunStubURLProtocol.self)
+        defer {
+            if registered {
+                URLProtocol.unregisterClass(StepFunStubURLProtocol.self)
+            }
+            StepFunStubURLProtocol.handler = nil
+        }
+        try await body(recorder)
+    }
+
+    private static func usageResponse(for request: URLRequest) -> (HTTPURLResponse, Data) {
+        self.jsonResponse(
+            for: request,
+            body: """
+            {
+                "status": 1,
+                "five_hour_usage_left_rate": 0.8,
+                "weekly_usage_left_rate": 0.6,
+                "five_hour_usage_reset_time": "1777528800",
+                "weekly_usage_reset_time": "1777899600"
+            }
+            """)
+    }
+
+    private static func jsonResponse(
+        for request: URLRequest,
+        statusCode: Int = 200,
+        body: String,
+        headers: [String: String] = ["Content-Type": "application/json"]) -> (HTTPURLResponse, Data)
+    {
+        let response = HTTPURLResponse(
+            url: request.url!,
+            statusCode: statusCode,
+            httpVersion: nil,
+            headerFields: headers)!
+        return (response, Data(body.utf8))
+    }
+}
+
+private actor StepFunTokenUpdateRecorder {
+    private var token: String?
+
+    func record(_ token: String) {
+        self.token = token
+    }
+
+    func recordedToken() -> String? {
+        self.token
+    }
+}
+
+private final class StepFunRequestRecorder: @unchecked Sendable {
+    private let lock = NSLock()
+    private var usageCalls = 0
+    private var refreshCalls = 0
+
+    var usageCallCount: Int {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        return self.usageCalls
+    }
+
+    var refreshCallCount: Int {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        return self.refreshCalls
+    }
+
+    func recordUsageCall() -> Int {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        self.usageCalls += 1
+        return self.usageCalls
+    }
+
+    func recordRefreshCall() {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        self.refreshCalls += 1
+    }
+}
+
+private final class StepFunStubURLProtocol: URLProtocol {
+    nonisolated(unsafe) static var handler: (@Sendable (URLRequest) throws -> (HTTPURLResponse, Data))?
+
+    override static func canInit(with request: URLRequest) -> Bool {
+        request.url?.host == "platform.stepfun.com"
+    }
+
+    override static func canonicalRequest(for request: URLRequest) -> URLRequest {
+        request
+    }
+
+    override func startLoading() {
+        guard let handler = Self.handler else {
+            self.client?.urlProtocol(self, didFailWithError: URLError(.badServerResponse))
+            return
+        }
+
+        do {
+            let (response, data) = try handler(self.request)
+            self.client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
+            self.client?.urlProtocol(self, didLoad: data)
+            self.client?.urlProtocolDidFinishLoading(self)
+        } catch {
+            self.client?.urlProtocol(self, didFailWithError: error)
+        }
+    }
+
+    override func stopLoading() {}
+}
diff --git a/Tests/CodexBarTests/StorageBreakdownSegmentTests.swift b/Tests/CodexBarTests/StorageBreakdownSegmentTests.swift
new file mode 100644
index 0000000000..3198b53a64
--- /dev/null
+++ b/Tests/CodexBarTests/StorageBreakdownSegmentTests.swift
@@ -0,0 +1,112 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct StorageBreakdownSegmentTests {
+    @Test @MainActor
+    func `folds overflow into eighth segment without losing paths`() {
+        let components = (1...10).map { index in
+            ProviderStorageFootprint.Component(path: "/tmp/item-\(index)", totalBytes: Int64(index))
+        }
+        let view = StorageBreakdownMenuView(
+            footprint: Self.footprint(components: components),
+            width: 310)
+
+        #expect(view._segmentNamesForTesting == [
+            "item-1", "item-2", "item-3", "item-4", "item-5", "item-6", "item-7", "Other (3 items)",
+        ])
+        #expect(view._segmentBytesForTesting == [1, 2, 3, 4, 5, 6, 7, 27])
+        #expect(view._overflowNamesForTesting == ["item-8", "item-9", "item-10"])
+        #expect(view._overflowExpansionHeightForTesting == 68)
+        #expect(view.copyablePaths == components.map(\.path))
+    }
+
+    @Test @MainActor
+    func `segment widths fill bar and keep tiny values visible`() {
+        let components = [
+            ProviderStorageFootprint.Component(path: "/tmp/large", totalBytes: 1_000_000),
+            ProviderStorageFootprint.Component(path: "/tmp/tiny", totalBytes: 1),
+            ProviderStorageFootprint.Component(path: "/tmp/zero", totalBytes: 0),
+        ]
+        let view = StorageBreakdownMenuView(
+            footprint: Self.footprint(components: components),
+            width: 310)
+        let widths = view._segmentWidthsForTesting(barWidth: 100)
+
+        #expect(widths.count == 3)
+        #expect(abs(widths.reduce(0, +) - 100) < 0.001)
+        #expect(widths.allSatisfy { $0 >= 2 })
+    }
+
+    @Test @MainActor
+    func `narrow bar divides width without overflow`() {
+        let components = (1...8).map { index in
+            ProviderStorageFootprint.Component(path: "/tmp/item-\(index)", totalBytes: 1)
+        }
+        let view = StorageBreakdownMenuView(
+            footprint: Self.footprint(components: components),
+            width: 310)
+        let widths = view._segmentWidthsForTesting(barWidth: 8)
+
+        #expect(widths == Array(repeating: 1, count: 8))
+        #expect(widths.reduce(0, +) == 8)
+    }
+
+    @Test @MainActor
+    func `zero byte components evenly fill bar`() {
+        let components = (1...4).map { index in
+            ProviderStorageFootprint.Component(path: "/tmp/item-\(index)", totalBytes: 0)
+        }
+        let view = StorageBreakdownMenuView(
+            footprint: Self.footprint(components: components),
+            width: 310)
+
+        #expect(view._segmentWidthsForTesting(barWidth: 100) == [25, 25, 25, 25])
+    }
+
+    @Test @MainActor
+    func `negative component sizes clamp to zero`() {
+        let components = [
+            ProviderStorageFootprint.Component(path: "/tmp/negative", totalBytes: -10),
+            ProviderStorageFootprint.Component(path: "/tmp/positive", totalBytes: 10),
+        ]
+        let view = StorageBreakdownMenuView(
+            footprint: Self.footprint(components: components),
+            width: 310)
+
+        #expect(view._segmentBytesForTesting == [0, 10])
+        #expect(view._segmentWidthsForTesting(barWidth: 100).allSatisfy { $0 >= 2 })
+    }
+
+    @Test @MainActor
+    func `extreme component sizes still fill exactly one bar`() {
+        let components = [
+            ProviderStorageFootprint.Component(path: "/tmp/first", totalBytes: .max),
+            ProviderStorageFootprint.Component(path: "/tmp/second", totalBytes: .max),
+        ]
+        let view = StorageBreakdownMenuView(
+            footprint: Self.footprint(components: components),
+            width: 310)
+        let widths = view._segmentWidthsForTesting(barWidth: 100)
+
+        #expect(abs(widths.reduce(0, +) - 100) < 0.001)
+        #expect(widths == [50, 50])
+    }
+
+    private static func footprint(
+        components: [ProviderStorageFootprint.Component]) -> ProviderStorageFootprint
+    {
+        ProviderStorageFootprint(
+            provider: .claude,
+            totalBytes: components.reduce(Int64(0)) { partial, component in
+                let (sum, overflowed) = partial.addingReportingOverflow(max(component.totalBytes, 0))
+                return overflowed ? .max : sum
+            },
+            paths: components.map(\.path),
+            missingPaths: [],
+            unreadablePaths: [],
+            components: components,
+            updatedAt: Date(timeIntervalSince1970: 0))
+    }
+}
diff --git a/Tests/CodexBarTests/SubprocessRunnerTests.swift b/Tests/CodexBarTests/SubprocessRunnerTests.swift
index 116d5da5d8..ae85d8bec2 100644
--- a/Tests/CodexBarTests/SubprocessRunnerTests.swift
+++ b/Tests/CodexBarTests/SubprocessRunnerTests.swift
@@ -2,18 +2,332 @@ import Foundation
 import Testing
 @testable import CodexBarCore
 
-@Suite
+#if canImport(Darwin)
+import Darwin
+#else
+import Glibc
+#endif
+
 struct SubprocessRunnerTests {
     @Test
-    func readsLargeStdoutWithoutDeadlock() async throws {
+    func `reads large stdout without deadlock`() async throws {
         let result = try await SubprocessRunner.run(
             binary: "/usr/bin/python3",
             arguments: ["-c", "print('x' * 1_000_000)"],
             environment: ProcessInfo.processInfo.environment,
-            timeout: 5,
+            timeout: 15,
             label: "python large stdout")
 
         #expect(result.stdout.count >= 1_000_000)
         #expect(result.stderr.isEmpty)
     }
+
+    @Test
+    func `bounds oversized stdout while continuing to drain`() async throws {
+        let result = try await SubprocessRunner.run(
+            binary: "/usr/bin/python3",
+            arguments: ["-c", "print('x' * 2_000_000)"],
+            environment: ProcessInfo.processInfo.environment,
+            timeout: 5,
+            label: "python oversized stdout")
+
+        #expect(result.stdout.utf8.count == ProcessPipeCapture.defaultMaxBytes)
+        #expect(result.stderr.isEmpty)
+    }
+
+    @Test
+    func `preserves captured prefix when limit splits three byte scalar`() async throws {
+        let asciiCount = ProcessPipeCapture.defaultMaxBytes - 1
+        let script = "import sys; sys.stdout.buffer.write(b'x' * \(asciiCount) + bytes([0xe2, 0x82, 0xac]) + b'tail')"
+        let result = try await SubprocessRunner.run(
+            binary: "/usr/bin/python3",
+            arguments: ["-c", script],
+            environment: ProcessInfo.processInfo.environment,
+            timeout: 5,
+            label: "python split utf8 stdout")
+
+        #expect(result.stdout.count == ProcessPipeCapture.defaultMaxBytes)
+        #expect(result.stdout.first == "x")
+        #expect(result.stdout.last == "\u{FFFD}")
+        #expect(result.stdout.utf8.count == ProcessPipeCapture.defaultMaxBytes + 2)
+    }
+
+    @Test
+    func `bounds simultaneous oversized stdout and stderr while draining`() async throws {
+        let script = """
+        import sys
+        chunk = 2048
+        for _ in range(2000):
+            sys.stdout.write('o' * chunk)
+            sys.stdout.flush()
+            sys.stderr.write('e' * chunk)
+            sys.stderr.flush()
+        """
+        let result = try await SubprocessRunner.run(
+            binary: "/usr/bin/python3",
+            arguments: ["-c", script],
+            environment: ProcessInfo.processInfo.environment,
+            timeout: 10,
+            label: "python simultaneous oversized output")
+
+        #expect(result.stdout.utf8.count == ProcessPipeCapture.defaultMaxBytes)
+        #expect(result.stderr.utf8.count == ProcessPipeCapture.defaultMaxBytes)
+    }
+
+    @Test
+    func `bounds oversized stderr on failure`() async throws {
+        do {
+            _ = try await SubprocessRunner.run(
+                binary: "/usr/bin/python3",
+                arguments: ["-c", "import sys; sys.stderr.write('e' * 2_000_000); sys.exit(7)"],
+                environment: ProcessInfo.processInfo.environment,
+                timeout: 5,
+                label: "python oversized stderr")
+            Issue.record("Expected non-zero exit")
+        } catch let error as SubprocessRunnerError {
+            guard case let .nonZeroExit(code, stderr) = error else {
+                Issue.record("Expected non-zero exit, got \(error)")
+                return
+            }
+            #expect(code == 7)
+            #expect(stderr.utf8.count == ProcessPipeCapture.defaultMaxBytes)
+        } catch {
+            Issue.record("Expected SubprocessRunnerError, got \(error)")
+        }
+    }
+
+    @Test
+    func `returns partial output when detached child keeps pipes open`() async throws {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-subprocess-drain-\(UUID().uuidString)", isDirectory: true)
+        let childPIDFile = root.appendingPathComponent("child.pid")
+        try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+        defer {
+            if let text = try? String(contentsOf: childPIDFile, encoding: .utf8),
+               let childPID = pid_t(text.trimmingCharacters(in: .whitespacesAndNewlines))
+            {
+                _ = kill(childPID, SIGKILL)
+            }
+        }
+
+        var environment = ProcessInfo.processInfo.environment
+        environment["CODEXBAR_TEST_CHILD_PID_FILE"] = childPIDFile.path
+        let script = """
+        import os
+        import subprocess
+        import sys
+
+        child = subprocess.Popen(
+            [sys.executable, "-c", "import time; time.sleep(5)"],
+            start_new_session=True,
+        )
+        with open(os.environ["CODEXBAR_TEST_CHILD_PID_FILE"], "w") as handle:
+            handle.write(str(child.pid))
+        print("parent-output", flush=True)
+        """
+
+        let start = Date()
+        let result = try await SubprocessRunner.run(
+            binary: "/usr/bin/python3",
+            arguments: ["-c", script],
+            environment: environment,
+            timeout: 5,
+            label: "detached-output-holder")
+        let elapsed = Date().timeIntervalSince(start)
+
+        #expect(result.stdout.contains("parent-output"))
+        #expect(elapsed < 3, "Output drain should not wait for the detached child, took \(elapsed)s")
+    }
+
+    /// Regression test for #474: a hung subprocess must be killed and throw `.timedOut`
+    /// instead of blocking indefinitely.
+    ///
+    /// This test was previously deleted (commit 3961770) because `waitUntilExit()` blocked
+    /// the cooperative thread pool, starving the timeout task. The fix moves blocking calls
+    /// to `DispatchQueue.global()`, making this test reliable.
+    @Test
+    func `throws timed out when process hangs`() async throws {
+        let start = Date()
+        do {
+            _ = try await SubprocessRunner.run(
+                binary: "/bin/sleep",
+                arguments: ["5"],
+                environment: ProcessInfo.processInfo.environment,
+                timeout: 1,
+                label: "hung-process-test")
+            Issue.record("Expected SubprocessRunnerError.timedOut but no error was thrown")
+        } catch let error as SubprocessRunnerError {
+            guard case let .timedOut(label) = error else {
+                Issue.record("Expected .timedOut, got \(error)")
+                return
+            }
+            #expect(label == "hung-process-test")
+        } catch {
+            Issue.record("Expected SubprocessRunnerError.timedOut, got unexpected error: \(error)")
+        }
+
+        let elapsed = Date().timeIntervalSince(start)
+        // Must complete in well under 5s (the sleep duration). Allow generous bound for CI.
+        #expect(elapsed < 3, "Timeout should fire in ~1s, not wait for process to exit naturally")
+    }
+
+    @Test
+    func `timeout kills descendants that escape the process group`() async throws {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-subprocess-tree-\(UUID().uuidString)", isDirectory: true)
+        let childPIDFile = root.appendingPathComponent("child.pid")
+        try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+
+        var environment = ProcessInfo.processInfo.environment
+        environment["CODEXBAR_TEST_CHILD_PID_FILE"] = childPIDFile.path
+        let script = """
+        import os
+        import subprocess
+        import sys
+        import time
+
+        child = subprocess.Popen(
+            [sys.executable, "-c", "import time; time.sleep(30)"],
+            start_new_session=True,
+        )
+        with open(os.environ["CODEXBAR_TEST_CHILD_PID_FILE"], "w") as handle:
+            handle.write(str(child.pid))
+        time.sleep(30)
+        """
+
+        await #expect(throws: SubprocessRunnerError.self) {
+            try await SubprocessRunner.run(
+                binary: "/usr/bin/python3",
+                arguments: ["-c", script],
+                environment: environment,
+                timeout: 0.5,
+                label: "escaped-descendant")
+        }
+
+        let text = try String(contentsOf: childPIDFile, encoding: .utf8)
+        let childPID = try #require(pid_t(text.trimmingCharacters(in: .whitespacesAndNewlines)))
+        defer { _ = kill(childPID, SIGKILL) }
+
+        let deadline = Date().addingTimeInterval(1)
+        while kill(childPID, 0) == 0, Date() < deadline {
+            try await Task.sleep(for: .milliseconds(20))
+        }
+        #expect(kill(childPID, 0) == -1)
+    }
+
+    /// Multiple concurrent hung subprocesses must all time out independently, proving that
+    /// one blocked subprocess does not starve the timeout mechanism of others.
+    /// This is the core scenario that caused the original permanent-refresh-stall bug.
+    @Test
+    func `concurrent hung processes all time out`() async {
+        let start = Date()
+        let count = 8
+
+        await withTaskGroup(of: Void.self) { group in
+            for i in 0..<count {
+                group.addTask {
+                    do {
+                        _ = try await SubprocessRunner.run(
+                            binary: "/bin/sleep",
+                            arguments: ["30"],
+                            environment: ProcessInfo.processInfo.environment,
+                            timeout: 2,
+                            label: "concurrent-hung-\(i)")
+                        Issue.record("Expected .timedOut for concurrent-hung-\(i)")
+                    } catch let error as SubprocessRunnerError {
+                        guard case .timedOut = error else {
+                            Issue.record("Expected .timedOut for concurrent-hung-\(i), got \(error)")
+                            return
+                        }
+                    } catch {
+                        Issue.record("Unexpected error for concurrent-hung-\(i): \(error)")
+                    }
+                }
+            }
+        }
+
+        let elapsed = Date().timeIntervalSince(start)
+        // Under release-load parallel tests the runner can be CPU-starved, but it should still finish far before
+        // the natural sleep exit and below a serial 8 * 2s timeout chain.
+        #expect(
+            elapsed < 15,
+            "All \(count) concurrent timeouts should fire in ~2s, took \(elapsed)s")
+    }
+
+    /// Stress-test the timeout race guard: with very short timeouts, the exit-code task
+    /// and the timeout task race tightly, exercising the KillFlag synchronization path.
+    @Test
+    func `timeout race stress`() async {
+        for i in 0..<20 {
+            do {
+                _ = try await SubprocessRunner.run(
+                    binary: "/bin/sleep",
+                    arguments: ["1"],
+                    environment: ProcessInfo.processInfo.environment,
+                    timeout: 0.1,
+                    label: "race-stress-\(i)")
+                Issue.record("Expected .timedOut for iteration \(i)")
+            } catch let error as SubprocessRunnerError {
+                guard case .timedOut = error else {
+                    Issue.record("Expected .timedOut, got \(error) at iteration \(i)")
+                    continue
+                }
+            } catch {
+                Issue.record("Unexpected error at iteration \(i): \(error)")
+            }
+        }
+    }
+
+    @Test
+    func `cancellation terminates hung process promptly`() async throws {
+        let start = Date()
+        let task = Task {
+            try await SubprocessRunner.run(
+                binary: "/bin/sleep",
+                arguments: ["10"],
+                environment: ProcessInfo.processInfo.environment,
+                timeout: 30,
+                label: "cancelled-hung-process")
+        }
+
+        try await Task.sleep(for: .milliseconds(100))
+        task.cancel()
+
+        do {
+            _ = try await task.value
+            Issue.record("Expected CancellationError but subprocess completed")
+        } catch is CancellationError {
+            // Expected: cancellation should tear down the child process immediately.
+        } catch {
+            Issue.record("Expected CancellationError, got \(error)")
+        }
+
+        let elapsed = Date().timeIntervalSince(start)
+        #expect(elapsed < 5, "Cancelled subprocess should not wait for timeout or natural exit")
+    }
+
+    /// Verify that many concurrent SubprocessRunner calls complete without starving each other.
+    @Test
+    func `concurrent calls do not starve`() async throws {
+        try await withThrowingTaskGroup(of: SubprocessResult.self) { group in
+            for i in 0..<20 {
+                group.addTask {
+                    try await SubprocessRunner.run(
+                        binary: "/bin/sleep",
+                        arguments: ["0.2"],
+                        environment: ProcessInfo.processInfo.environment,
+                        timeout: 10,
+                        label: "concurrent-\(i)")
+                }
+            }
+
+            var count = 0
+            for try await _ in group {
+                count += 1
+            }
+            #expect(count == 20, "All 20 concurrent calls should complete")
+        }
+    }
 }
diff --git a/Tests/CodexBarTests/SubscriptionDetectionTests.swift b/Tests/CodexBarTests/SubscriptionDetectionTests.swift
index f08821b8f8..1a0a5afa9b 100644
--- a/Tests/CodexBarTests/SubscriptionDetectionTests.swift
+++ b/Tests/CodexBarTests/SubscriptionDetectionTests.swift
@@ -2,12 +2,11 @@ import Foundation
 import Testing
 @testable import CodexBar
 
-@Suite
 struct SubscriptionDetectionTests {
     // MARK: - Subscription plans should be detected
 
     @Test
-    func detectsMaxPlan() {
+    func `detects max plan`() {
         #expect(UsageStore.isSubscriptionPlan("Claude Max") == true)
         #expect(UsageStore.isSubscriptionPlan("Max") == true)
         #expect(UsageStore.isSubscriptionPlan("claude max") == true)
@@ -15,41 +14,47 @@ struct SubscriptionDetectionTests {
     }
 
     @Test
-    func detectsProPlan() {
+    func `detects pro plan`() {
         #expect(UsageStore.isSubscriptionPlan("Claude Pro") == true)
         #expect(UsageStore.isSubscriptionPlan("Pro") == true)
         #expect(UsageStore.isSubscriptionPlan("pro") == true)
     }
 
     @Test
-    func detectsUltraPlan() {
+    func `detects ultra plan`() {
         #expect(UsageStore.isSubscriptionPlan("Claude Ultra") == true)
         #expect(UsageStore.isSubscriptionPlan("Ultra") == true)
         #expect(UsageStore.isSubscriptionPlan("ultra") == true)
     }
 
     @Test
-    func detectsTeamPlan() {
+    func `detects team plan`() {
         #expect(UsageStore.isSubscriptionPlan("Claude Team") == true)
         #expect(UsageStore.isSubscriptionPlan("Team") == true)
         #expect(UsageStore.isSubscriptionPlan("team") == true)
     }
 
+    @Test
+    func `enterprise plan does not count as subscription`() {
+        #expect(UsageStore.isSubscriptionPlan("Claude Enterprise") == false)
+        #expect(UsageStore.isSubscriptionPlan("Enterprise") == false)
+    }
+
     // MARK: - Non-subscription plans should return false
 
     @Test
-    func nilLoginMethodReturnsFalse() {
+    func `nil login method returns false`() {
         #expect(UsageStore.isSubscriptionPlan(nil) == false)
     }
 
     @Test
-    func emptyLoginMethodReturnsFalse() {
+    func `empty login method returns false`() {
         #expect(UsageStore.isSubscriptionPlan("") == false)
         #expect(UsageStore.isSubscriptionPlan("   ") == false)
     }
 
     @Test
-    func unknownPlanReturnsFalse() {
+    func `unknown plan returns false`() {
         #expect(UsageStore.isSubscriptionPlan("API") == false)
         #expect(UsageStore.isSubscriptionPlan("Free") == false)
         #expect(UsageStore.isSubscriptionPlan("Unknown") == false)
@@ -57,7 +62,7 @@ struct SubscriptionDetectionTests {
     }
 
     @Test
-    func apiKeyUsersReturnFalse() {
+    func `api key users return false`() {
         // API users typically don't have a login method or have non-subscription identifiers
         #expect(UsageStore.isSubscriptionPlan("api_key") == false)
         #expect(UsageStore.isSubscriptionPlan("console") == false)
diff --git a/Tests/CodexBarTests/SyntheticMenuCardTests.swift b/Tests/CodexBarTests/SyntheticMenuCardTests.swift
new file mode 100644
index 0000000000..df7d00951a
--- /dev/null
+++ b/Tests/CodexBarTests/SyntheticMenuCardTests.swift
@@ -0,0 +1,107 @@
+import CodexBarCore
+import Foundation
+import SwiftUI
+import Testing
+@testable import CodexBar
+
+struct SyntheticMenuCardTests {
+    private static func makeModel(
+        primary: RateWindow?,
+        secondary: RateWindow? = nil,
+        providerCost: ProviderCostSnapshot? = nil,
+        now: Date) throws -> UsageMenuCardView.Model
+    {
+        let identity = ProviderIdentitySnapshot(
+            providerID: .synthetic,
+            accountEmail: nil,
+            accountOrganization: nil,
+            loginMethod: nil)
+        let snapshot = UsageSnapshot(
+            primary: primary,
+            secondary: secondary,
+            tertiary: nil,
+            providerCost: providerCost,
+            updatedAt: now,
+            identity: identity)
+        let metadata = try #require(ProviderDefaults.metadata[.synthetic])
+        return UsageMenuCardView.Model.make(.init(
+            provider: .synthetic,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+    }
+
+    @Test
+    func `rolling regen text uses parsed tickPercent not hardcoded fallback`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let primary = RateWindow(
+            usedPercent: 50,
+            windowMinutes: 300,
+            resetsAt: now.addingTimeInterval(900),
+            resetDescription: nil,
+            nextRegenPercent: 2)
+        let model = try Self.makeModel(primary: primary, now: now)
+        let metric = try #require(model.metrics.first)
+        // 50% used / 2% per tick = 25 ticks to full.
+        #expect(metric.detailRightText == "Full in ~25 regens")
+        #expect(metric.detailLeftText == "52% after next regen")
+    }
+
+    @Test
+    func `rolling regen omits Synthetic-specific text when tickPercent is missing`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let primary = RateWindow(
+            usedPercent: 50,
+            windowMinutes: 300,
+            resetsAt: now.addingTimeInterval(900),
+            resetDescription: nil,
+            nextRegenPercent: nil)
+        let model = try Self.makeModel(primary: primary, now: now)
+        let metric = try #require(model.metrics.first)
+        // Without nextRegenPercent we no longer assert a regen-specific label;
+        // the renderer must not fabricate ticks-to-full from a guessed rate.
+        #expect(metric.detailRightText?.contains("regen") != true)
+    }
+
+    @Test
+    func `weekly regen text near full reports both labels consistently`() throws {
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let secondary = RateWindow(
+            usedPercent: 1,
+            windowMinutes: 10080,
+            resetsAt: now.addingTimeInterval(3600),
+            resetDescription: nil)
+        let cost = ProviderCostSnapshot(
+            used: 0.36,
+            limit: 36,
+            currencyCode: "USD",
+            period: "Weekly",
+            resetsAt: now.addingTimeInterval(3600),
+            nextRegenAmount: 0.72,
+            updatedAt: now)
+        let model = try Self.makeModel(
+            primary: nil,
+            secondary: secondary,
+            providerCost: cost,
+            now: now)
+        let weekly = try #require(model.metrics.first(where: { $0.id == "secondary" }))
+        // used=$0.36 / nextRegen=$0.72 = 0.5 ticks → between 0.1 and 1.5 → "Full in ~1 regen".
+        #expect(weekly.detailRightText == "Full in ~1 regen")
+        // remaining 99% + 2% next regen caps at 100% → "100% after next regen".
+        #expect(weekly.detailLeftText == "100% after next regen")
+    }
+}
diff --git a/Tests/CodexBarTests/SyntheticProviderTests.swift b/Tests/CodexBarTests/SyntheticProviderTests.swift
index aad33712b7..abe9765b05 100644
--- a/Tests/CodexBarTests/SyntheticProviderTests.swift
+++ b/Tests/CodexBarTests/SyntheticProviderTests.swift
@@ -2,25 +2,23 @@ import Foundation
 import Testing
 @testable import CodexBarCore
 
-@Suite
 struct SyntheticSettingsReaderTests {
     @Test
-    func apiKeyReadsFromEnvironment() {
+    func `api key reads from environment`() {
         let token = SyntheticSettingsReader.apiKey(environment: ["SYNTHETIC_API_KEY": "abc123"])
         #expect(token == "abc123")
     }
 
     @Test
-    func apiKeyStripsQuotes() {
+    func `api key strips quotes`() {
         let token = SyntheticSettingsReader.apiKey(environment: ["SYNTHETIC_API_KEY": "\"token-xyz\""])
         #expect(token == "token-xyz")
     }
 }
 
-@Suite
 struct SyntheticUsageSnapshotTests {
     @Test
-    func mapsUsageSnapshotWindows() throws {
+    func `maps usage snapshot windows`() throws {
         let json = """
         {
           "plan": "Starter",
@@ -41,7 +39,7 @@ struct SyntheticUsageSnapshotTests {
     }
 
     @Test
-    func parsesSubscriptionQuota() throws {
+    func `parses subscription quota`() throws {
         let json = """
         {
           "subscription": {
@@ -63,4 +61,167 @@ struct SyntheticUsageSnapshotTests {
         #expect(usage.primary?.resetsAt == expectedReset)
         #expect(usage.loginMethod(for: .synthetic) == nil)
     }
+
+    @Test
+    func `parses nested subscription pack quota`() throws {
+        let json = """
+        {
+          "subscription": {
+            "packs": 2,
+            "rateLimit": {
+              "messages": 1000,
+              "requests": 250,
+              "period": "5hr",
+              "resetsAt": "2026-04-16T18:00:00Z"
+            }
+          }
+        }
+        """
+        let data = try #require(json.data(using: .utf8))
+        let snapshot = try SyntheticUsageParser.parse(data: data, now: Date(timeIntervalSince1970: 123))
+        let usage = snapshot.toUsageSnapshot()
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime]
+        let expectedReset = try #require(formatter.date(from: "2026-04-16T18:00:00Z"))
+
+        #expect(usage.primary?.usedPercent == 25)
+        #expect(usage.primary?.windowMinutes == 300)
+        #expect(usage.primary?.resetsAt == expectedReset)
+    }
+
+    @Test
+    func `parses live root level rolling and weekly quotas`() throws {
+        let json = """
+        {
+          "subscription": {
+            "limit": 750,
+            "requests": 0,
+            "renewsAt": "2026-04-17T08:35:49.493Z"
+          },
+          "weeklyTokenLimit": {
+            "nextRegenAt": "2026-04-17T05:19:30.000Z",
+            "percentRemaining": 98.05884722222223,
+            "maxCredits": "$36.00",
+            "remainingCredits": "$35.30",
+            "nextRegenCredits": "$0.72"
+          },
+          "rollingFiveHourLimit": {
+            "nextTickAt": "2026-04-17T03:44:11.000Z",
+            "tickPercent": 0.05,
+            "remaining": 750,
+            "max": 750,
+            "limited": false
+          },
+          "search": {
+            "hourly": {
+              "limit": 250,
+              "requests": 2,
+              "renewsAt": "2026-04-17T04:30:01.494Z"
+            }
+          }
+        }
+        """
+        let data = try #require(json.data(using: .utf8))
+        let snapshot = try SyntheticUsageParser.parse(data: data, now: Date(timeIntervalSince1970: 123))
+        let usage = snapshot.toUsageSnapshot()
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime]
+        let fractionalFormatter = ISO8601DateFormatter()
+        fractionalFormatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        let expectedPrimaryReset = try #require(formatter.date(from: "2026-04-17T03:44:11Z"))
+        let expectedSecondaryReset = try #require(formatter.date(from: "2026-04-17T05:19:30Z"))
+        let expectedTertiaryReset = try #require(fractionalFormatter.date(from: "2026-04-17T04:30:01.494Z"))
+
+        #expect(usage.primary?.usedPercent == 0)
+        #expect(usage.primary?.resetsAt == expectedPrimaryReset)
+        #expect(usage.primary?.resetDescription == nil)
+        #expect(abs((usage.secondary?.usedPercent ?? 0) - 1.9411527777777715) < 0.001)
+        #expect(usage.secondary?.resetsAt == expectedSecondaryReset)
+        #expect(usage.secondary?.resetDescription == nil)
+        #expect(usage.tertiary?.usedPercent == 0.8)
+        #expect(usage.tertiary?.resetsAt == expectedTertiaryReset)
+        #expect(usage.providerCost?.limit == 36)
+        #expect(abs((usage.providerCost?.used ?? 0) - 0.7) < 0.0001)
+        #expect(usage.providerCost?.nextRegenAmount == 0.72)
+    }
+
+    @Test
+    func `parses rolling lane tickPercent into primary nextRegenPercent`() throws {
+        let json = """
+        {
+          "rollingFiveHourLimit": {
+            "nextTickAt": "2026-04-17T03:44:11.000Z",
+            "tickPercent": 0.05,
+            "remaining": 750,
+            "max": 750,
+            "limited": false
+          }
+        }
+        """
+        let data = try #require(json.data(using: .utf8))
+        let snapshot = try SyntheticUsageParser.parse(data: data, now: Date(timeIntervalSince1970: 123))
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary?.nextRegenPercent == 5.0)
+    }
+
+    @Test
+    func `omits nextRegenPercent when rolling lane lacks tickPercent`() throws {
+        let json = """
+        {
+          "rollingFiveHourLimit": {
+            "nextTickAt": "2026-04-17T03:44:11.000Z",
+            "remaining": 750,
+            "max": 750
+          }
+        }
+        """
+        let data = try #require(json.data(using: .utf8))
+        let snapshot = try SyntheticUsageParser.parse(data: data, now: Date(timeIntervalSince1970: 123))
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary?.nextRegenPercent == nil)
+    }
+
+    @Test
+    func `parses time string suffixes covering minutes hours and days`() {
+        #expect(SyntheticUsageParser.windowMinutes(fromText: "5min") == 5)
+        #expect(SyntheticUsageParser.windowMinutes(fromText: "5m") == 5)
+        #expect(SyntheticUsageParser.windowMinutes(fromText: "5hr") == 300)
+        #expect(SyntheticUsageParser.windowMinutes(fromText: "5h") == 300)
+        #expect(SyntheticUsageParser.windowMinutes(fromText: "5hours") == 300)
+        #expect(SyntheticUsageParser.windowMinutes(fromText: "2days") == 2880)
+        #expect(SyntheticUsageParser.windowMinutes(fromText: "2d") == 2880)
+        #expect(SyntheticUsageParser.windowMinutes(fromText: "1 hour") == 60)
+        #expect(SyntheticUsageParser.windowMinutes(fromText: "junk") == nil)
+        #expect(SyntheticUsageParser.windowMinutes(fromText: "") == nil)
+    }
+
+    @Test
+    func `preserves slot identity when rolling lane is missing`() throws {
+        let json = """
+        {
+          "weeklyTokenLimit": {
+            "nextRegenAt": "2026-04-17T05:19:30.000Z",
+            "percentRemaining": 98.0,
+            "maxCredits": "$36.00",
+            "remainingCredits": "$35.30",
+            "nextRegenCredits": "$0.72"
+          },
+          "search": {
+            "hourly": {
+              "limit": 250,
+              "requests": 2,
+              "renewsAt": "2026-04-17T04:30:01.494Z"
+            }
+          }
+        }
+        """
+        let data = try #require(json.data(using: .utf8))
+        let snapshot = try SyntheticUsageParser.parse(data: data, now: Date(timeIntervalSince1970: 123))
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(usage.primary == nil)
+        #expect(abs((usage.secondary?.usedPercent ?? 0) - 2.0) < 0.001)
+        #expect(usage.tertiary?.usedPercent == 0.8)
+        #expect(usage.providerCost?.limit == 36)
+    }
 }
diff --git a/Tests/CodexBarTests/T3ChatUsageFetcherTests.swift b/Tests/CodexBarTests/T3ChatUsageFetcherTests.swift
new file mode 100644
index 0000000000..83e69ef33c
--- /dev/null
+++ b/Tests/CodexBarTests/T3ChatUsageFetcherTests.swift
@@ -0,0 +1,295 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct T3ChatUsageFetcherTests {
+    private struct StubClaudeFetcher: ClaudeUsageFetching {
+        func loadLatestUsage(model _: String) async throws -> ClaudeUsageSnapshot {
+            throw ClaudeUsageError.parseFailed("stub")
+        }
+
+        func debugRawProbe(model _: String) async -> String {
+            "stub"
+        }
+
+        func detectVersion() -> String? {
+            nil
+        }
+    }
+
+    private static let now = Date(timeIntervalSince1970: 1_778_000_000)
+    // 2026-05-21T12:23:36Z, the usage-window reset that must not drive overage reset display.
+    private static let billingNextResetMilliseconds = 1_779_366_216_920
+    // 2026-06-06T16:23:29Z, the subscription period end used for overage reset display.
+    private static let subscriptionPeriodEndSeconds = 1_780_763_009
+    private static let subscriptionPeriodEndMilliseconds = Self.subscriptionPeriodEndSeconds * 1000
+
+    private static let sampleResponse = [
+        #"{"json":{"0":[[0],[null,0,0]]}}"#,
+        #"{"json":[0,0,[[{"result":0}],["result",0,1]]]}"#,
+        #"{"json":[1,0,[[{"data":0}],["data",0,2]]]}"#,
+        #"{"json":[2,0,[[{"subTier":"pro","subscription":{"# +
+            #""productId":"pro","productName":"pro","status":"active","# +
+            #""currentPeriodStart":1778084609000,"currentPeriodEnd":1780763009000,"# +
+            #""canceledAt":null,"trialEndsAt":null},"lifetimeBalance":0,"usageBand":"max","# +
+            #""billingNextResetAt":1779366216920,"usageFourHourPercentage":12.5,"# +
+            #""usageMonthPercentage":34.25,"usageFourHourNextResetAt":1779366216920,"# +
+            #""usagePeriodPercentage":44,"usageWindowNextResetAt":1779366216920}]]]}"#,
+    ].joined(separator: "\n")
+
+    @Test
+    func `parses customer data from json lines response`() throws {
+        let snapshot = try T3ChatUsageParser.parseJSONLines(Self.sampleResponse, now: Self.now)
+
+        #expect(snapshot.customerData.subTier == "pro")
+        #expect(snapshot.customerData.usageBand == "max")
+        #expect(snapshot.customerData.usageFourHourPercentage == 12.5)
+        #expect(snapshot.customerData.usageMonthPercentage == 34.25)
+        #expect(snapshot.customerData.subscription?.status == "active")
+    }
+
+    @Test
+    func `maps customer data to base and overage windows`() throws {
+        let usage = try T3ChatUsageParser.parseJSONLines(Self.sampleResponse, now: Self.now)
+            .toUsageSnapshot()
+
+        #expect(usage.primary?.usedPercent == 12.5)
+        #expect(usage.primary?.windowMinutes == 240)
+        #expect(usage.primary?.resetDescription == "Base - max")
+        #expect(usage.secondary?.usedPercent == 34.25)
+        #expect(usage.secondary?.resetDescription == "Overage")
+        #expect(usage.secondary?.resetsAt.map { Int($0.timeIntervalSince1970) } == Self.subscriptionPeriodEndSeconds)
+        #expect(usage.identity?.providerID == .t3chat)
+        #expect(usage.identity?.loginMethod == "Pro")
+    }
+
+    @Test
+    func `falls back to usage period percentage when month percentage is absent`() throws {
+        let response = """
+        {"json":[2,0,[[{"subTier":"free","usageFourHourPercentage":5,"usagePeriodPercentage":65}]]]}
+        """
+        let usage = try T3ChatUsageParser.parseJSONLines(response, now: Self.now)
+            .toUsageSnapshot()
+
+        #expect(usage.primary?.usedPercent == 5)
+        #expect(usage.secondary?.usedPercent == 65)
+    }
+
+    @Test
+    func `overage reset ignores billing next reset`() throws {
+        let response = Self.customerDataResponse(
+            #"{"usageMonthPercentage":20,"billingNextResetAt":\#(Self.billingNextResetMilliseconds)}"#)
+        let usage = try T3ChatUsageParser.parseJSONLines(response, now: Self.now)
+            .toUsageSnapshot()
+
+        #expect(usage.secondary?.usedPercent == 20)
+        #expect(usage.secondary?.resetsAt == nil)
+    }
+
+    @Test
+    func `overage reset uses subscription current period end`() throws {
+        let currentPeriodEnd = Self.subscriptionPeriodEndMilliseconds
+        let response = Self.customerDataResponse(
+            #"{"usageMonthPercentage":20,"subscription":{"currentPeriodEnd":\#(currentPeriodEnd)}}"#)
+        let usage = try T3ChatUsageParser.parseJSONLines(response, now: Self.now)
+            .toUsageSnapshot()
+
+        #expect(usage.secondary?.usedPercent == 20)
+        #expect(usage.secondary?.resetsAt.map { Int($0.timeIntervalSince1970) } == Self.subscriptionPeriodEndSeconds)
+    }
+
+    @Test
+    func `fetch sends trpc headers and cookie`() async throws {
+        let stub = ProviderHTTPTransportStub { request in
+            #expect(request.url?.host == "t3.chat")
+            #expect(request.url?.path == "/api/trpc/getCustomerData")
+            #expect(request.value(forHTTPHeaderField: "Cookie") == "session=abc")
+            #expect(request.value(forHTTPHeaderField: "trpc-accept") == "application/jsonl")
+            #expect(request.value(forHTTPHeaderField: "x-trpc-source") == "web-client")
+            #expect(request.value(forHTTPHeaderField: "Sec-Fetch-Site") == "same-origin")
+            #expect(request.url?.query?.contains("batch=1") == true)
+            let response = HTTPURLResponse(
+                url: request.url!,
+                statusCode: 200,
+                httpVersion: nil,
+                headerFields: nil)!
+            return (Data(Self.sampleResponse.utf8), response)
+        }
+
+        let snapshot = try await T3ChatUsageFetcher.fetchCustomerData(
+            cookieHeader: "session=abc",
+            now: Self.now,
+            transport: stub)
+
+        #expect(snapshot.customerData.planName == "Pro")
+    }
+
+    @Test
+    func `full curl capture forwards browser fingerprint headers`() async throws {
+        let curl = """
+        curl 'https://t3.chat/api/trpc/getCustomerData?batch=1&input=ignored' \\
+          -H 'User-Agent: Mozilla/5.0 Firefox/151.0' \\
+          --header "Referer: https://t3.chat/settings/customization" \\
+          -H 'trpc-accept: application/jsonl' \\
+          -H 'x-trpc-source: web-client' \\
+          -H 'x-trpc-batch: true' \\
+          -H 'X-Deployment-Id: dpl_test' \\
+          -H 'x-client-context: eyJjbGllbnQiOnsidmVyc2lvbiI6IjEuMTIuNCJ9fQ==' \\
+          -H 'Cookie: session=abc'
+        """
+        let stub = ProviderHTTPTransportStub { request in
+            #expect(request.value(forHTTPHeaderField: "Cookie") == "session=abc")
+            #expect(request.value(forHTTPHeaderField: "User-Agent") == "Mozilla/5.0 Firefox/151.0")
+            #expect(request.value(forHTTPHeaderField: "Referer") == "https://t3.chat/settings/customization")
+            #expect(request.value(forHTTPHeaderField: "X-Deployment-Id") == "dpl_test")
+            #expect(request.value(forHTTPHeaderField: "x-client-context") ==
+                "eyJjbGllbnQiOnsidmVyc2lvbiI6IjEuMTIuNCJ9fQ==")
+            let response = HTTPURLResponse(
+                url: request.url!,
+                statusCode: 200,
+                httpVersion: nil,
+                headerFields: nil)!
+            return (Data(Self.sampleResponse.utf8), response)
+        }
+
+        let fetcher = T3ChatUsageFetcher(browserDetection: BrowserDetection(cacheTTL: 0))
+        _ = try await fetcher.fetch(
+            cookieHeaderOverride: curl,
+            now: Self.now,
+            transport: stub)
+    }
+
+    @Test
+    func `curl capture forwards ansi quoted and equals header forms`() async throws {
+        let curl = """
+        curl 'https://t3.chat/api/trpc/getCustomerData?batch=1&input=ignored' \\
+          --header=$'User-Agent: Browser\\'s Agent' \\
+          --header 'X-Deployment-Id: dpl_test' \\
+          -H 'Cookie: session=abc'
+        """
+        let stub = ProviderHTTPTransportStub { request in
+            #expect(request.value(forHTTPHeaderField: "Cookie") == "session=abc")
+            #expect(request.value(forHTTPHeaderField: "User-Agent") == "Browser's Agent")
+            #expect(request.value(forHTTPHeaderField: "X-Deployment-Id") == "dpl_test")
+            let response = HTTPURLResponse(
+                url: request.url!,
+                statusCode: 200,
+                httpVersion: nil,
+                headerFields: nil)!
+            return (Data(Self.sampleResponse.utf8), response)
+        }
+
+        let fetcher = T3ChatUsageFetcher(browserDetection: BrowserDetection(cacheTTL: 0))
+        _ = try await fetcher.fetch(
+            cookieHeaderOverride: curl,
+            now: Self.now,
+            transport: stub)
+    }
+
+    @Test
+    func `full curl capture extracts cookie from long header form`() async throws {
+        let curl = """
+        curl 'https://t3.chat/api/trpc/getCustomerData?batch=1&input=ignored' \\
+          --compressed \\
+          --header "Referer: https://t3.chat/settings/customization" \\
+          --header "Cookie: session=abc; cf_clearance=token" \\
+          --header "X-Deployment-Id: dpl_test"
+        """
+        let stub = ProviderHTTPTransportStub { request in
+            #expect(request.value(forHTTPHeaderField: "Cookie") == "session=abc; cf_clearance=token")
+            #expect(request.value(forHTTPHeaderField: "Referer") == "https://t3.chat/settings/customization")
+            #expect(request.value(forHTTPHeaderField: "X-Deployment-Id") == "dpl_test")
+            let response = HTTPURLResponse(
+                url: request.url!,
+                statusCode: 200,
+                httpVersion: nil,
+                headerFields: nil)!
+            return (Data(Self.sampleResponse.utf8), response)
+        }
+
+        let fetcher = T3ChatUsageFetcher(browserDetection: BrowserDetection(cacheTTL: 0))
+        _ = try await fetcher.fetch(
+            cookieHeaderOverride: curl,
+            now: Self.now,
+            transport: stub)
+    }
+
+    @Test
+    func `manual strategy accepts full curl capture`() async {
+        let curl = """
+        curl 'https://t3.chat/api/trpc/getCustomerData?batch=1&input=ignored' \\
+          --header "Referer: https://t3.chat/settings/customization" \\
+          --header "Cookie: session=abc; cf_clearance=token" \\
+          --header "X-Deployment-Id: dpl_test"
+        """
+        let settings = ProviderSettingsSnapshot.make(
+            t3chat: ProviderSettingsSnapshot.T3ChatProviderSettings(
+                cookieSource: .manual,
+                manualCookieHeader: curl))
+
+        #expect(await T3ChatWebFetchStrategy().isAvailable(Self.makeContext(settings: settings)))
+    }
+
+    @Test
+    func `unauthorized response is invalid credentials`() async throws {
+        let stub = ProviderHTTPTransportStub { request in
+            let response = HTTPURLResponse(
+                url: request.url!,
+                statusCode: 401,
+                httpVersion: nil,
+                headerFields: nil)!
+            return (Data("unauthorized".utf8), response)
+        }
+
+        await #expect {
+            _ = try await T3ChatUsageFetcher.fetchCustomerData(
+                cookieHeader: "session=abc",
+                now: Self.now,
+                transport: stub)
+        } throws: { error in
+            guard case T3ChatUsageError.invalidCredentials = error else { return false }
+            return true
+        }
+    }
+
+    @Test
+    func `vercel challenge response asks for full curl capture`() async throws {
+        let stub = ProviderHTTPTransportStub { request in
+            let response = HTTPURLResponse(
+                url: request.url!,
+                statusCode: 429,
+                httpVersion: nil,
+                headerFields: ["x-vercel-mitigated": "challenge"])!
+            return (Data("checkpoint".utf8), response)
+        }
+
+        await #expect {
+            _ = try await T3ChatUsageFetcher.fetchCustomerData(
+                cookieHeader: "session=abc",
+                now: Self.now,
+                transport: stub)
+        } throws: { error in
+            guard case T3ChatUsageError.vercelChallenge = error else { return false }
+            return true
+        }
+    }
+
+    private static func customerDataResponse(_ customerDataJSON: String) -> String {
+        #"{"json":[2,0,[[\#(customerDataJSON)]]]}"# + "\n"
+    }
+
+    private static func makeContext(settings: ProviderSettingsSnapshot) -> ProviderFetchContext {
+        ProviderFetchContext(
+            runtime: .app,
+            sourceMode: .auto,
+            includeCredits: false,
+            webTimeout: 1,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: [:],
+            settings: settings,
+            fetcher: UsageFetcher(environment: [:]),
+            claudeFetcher: StubClaudeFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0))
+    }
+}
diff --git a/Tests/CodexBarTests/TTYCommandRunnerTests.swift b/Tests/CodexBarTests/TTYCommandRunnerTests.swift
index be4bc19584..fdd2a0ae1f 100644
--- a/Tests/CodexBarTests/TTYCommandRunnerTests.swift
+++ b/Tests/CodexBarTests/TTYCommandRunnerTests.swift
@@ -4,8 +4,27 @@ import Testing
 
 @Suite(.serialized)
 struct TTYCommandRunnerEnvTests {
+    private static let harnessPTYTimeout: TimeInterval = 10
+
+    private final class CallbackCounter: @unchecked Sendable {
+        private let lock = NSLock()
+        private var count = 0
+
+        func increment() {
+            self.lock.lock()
+            self.count += 1
+            self.lock.unlock()
+        }
+
+        func value() -> Int {
+            self.lock.lock()
+            defer { self.lock.unlock() }
+            return self.count
+        }
+    }
+
     @Test
-    func shutdownFenceDrainsTrackedTTYProcesses() {
+    func `shutdown fence drains tracked TTY processes`() {
         TTYCommandRunner._test_resetTrackedProcesses()
         defer { TTYCommandRunner._test_resetTrackedProcesses() }
 
@@ -19,7 +38,20 @@ struct TTYCommandRunnerEnvTests {
     }
 
     @Test
-    func trackedProcessHelpersIgnoreInvalidPID() {
+    func `cached CLI sessions share shutdown tracking`() {
+        TTYCommandRunner._test_resetTrackedProcesses()
+        defer { TTYCommandRunner._test_resetTrackedProcesses() }
+
+        #expect(TTYCommandRunner.registerActiveProcessForAppShutdown(pid: 3001, binary: "codex"))
+        TTYCommandRunner.updateActiveProcessGroupForAppShutdown(pid: 3001, processGroup: 3001)
+        #expect(TTYCommandRunner._test_trackedProcessCount() == 1)
+
+        TTYCommandRunner.unregisterActiveProcessForAppShutdown(pid: 3001)
+        #expect(TTYCommandRunner._test_trackedProcessCount() == 0)
+    }
+
+    @Test
+    func `tracked process helpers ignore invalid PID`() {
         TTYCommandRunner._test_resetTrackedProcesses()
         defer { TTYCommandRunner._test_resetTrackedProcesses() }
 
@@ -28,7 +60,7 @@ struct TTYCommandRunnerEnvTests {
     }
 
     @Test
-    func shutdownFenceRejectsNewRegistrations() {
+    func `shutdown fence rejects new registrations`() {
         TTYCommandRunner._test_resetTrackedProcesses()
         defer { TTYCommandRunner._test_resetTrackedProcesses() }
 
@@ -41,7 +73,29 @@ struct TTYCommandRunnerEnvTests {
     }
 
     @Test
-    func shutdownResolverSkipsHostProcessGroupFallback() {
+    func `shutdown waits for launch cleanup before draining`() {
+        TTYCommandRunner._test_resetTrackedProcesses()
+        defer { TTYCommandRunner._test_resetTrackedProcesses() }
+
+        #expect(TTYCommandRunner._test_beginTrackedProcessLaunch())
+        let fenceSet = DispatchSemaphore(value: 0)
+        let completed = DispatchSemaphore(value: 0)
+        Thread.detachNewThread {
+            _ = TTYCommandRunner._test_drainTrackedProcessesForShutdown {
+                fenceSet.signal()
+            }
+            completed.signal()
+        }
+
+        #expect(fenceSet.wait(timeout: .now() + 1) == .success)
+        #expect(completed.wait(timeout: .now() + 0.05) == .timedOut)
+        #expect(!TTYCommandRunner._test_registerTrackedProcess(pid: 2002, binary: "codex"))
+        TTYCommandRunner._test_endTrackedProcessLaunch()
+        #expect(completed.wait(timeout: .now() + 1) == .success)
+    }
+
+    @Test
+    func `shutdown resolver skips host process group fallback`() {
         let hostGroup: pid_t = 4242
         let targets: [(pid: pid_t, binary: String, processGroup: pid_t?)] = [
             (pid: 100, binary: "codex", processGroup: nil),
@@ -63,7 +117,44 @@ struct TTYCommandRunnerEnvTests {
     }
 
     @Test
-    func preservesEnvironmentAndSetsTerm() {
+    func `descendant resolver walks process tree once`() {
+        let children: [pid_t: [pid_t]] = [
+            100: [101, 102],
+            101: [103],
+            102: [103],
+            103: [100],
+        ]
+
+        let descendants = TTYProcessTreeTerminator.descendantPIDs(of: 100) { children[$0] ?? [] }
+
+        #expect(Set(descendants) == Set([101, 102, 103]))
+        #expect(descendants.count == 3)
+    }
+
+    @Test
+    func `process tree termination signals escaped descendants`() {
+        let children: [pid_t: [pid_t]] = [
+            100: [101, 102],
+            102: [103],
+        ]
+        var signaled: [(pid: pid_t, signal: Int32)] = []
+
+        TTYProcessTreeTerminator.terminateProcessTree(
+            rootPID: 100,
+            processGroup: 200,
+            signal: 15,
+            childResolver: { children[$0] ?? [] },
+            signalSender: { pid, signal in
+                signaled.append((pid: pid, signal: signal))
+            })
+
+        #expect(Set(signaled.map(\.pid)) == Set([100, 101, 102, 103, -200]))
+        #expect(signaled.allSatisfy { $0.signal == 15 })
+        #expect(signaled.last?.pid == 100)
+    }
+
+    @Test
+    func `preserves environment and sets term`() {
         let baseEnv: [String: String] = [
             "PATH": "/custom/bin",
             "HOME": "/Users/tester",
@@ -83,7 +174,7 @@ struct TTYCommandRunnerEnvTests {
     }
 
     @Test
-    func backfillsHomeWhenMissing() {
+    func `backfills home when missing`() {
         let merged = TTYCommandRunner.enrichedEnvironment(
             baseEnv: ["PATH": "/custom/bin"],
             loginPATH: nil,
@@ -93,7 +184,7 @@ struct TTYCommandRunnerEnvTests {
     }
 
     @Test
-    func preservesExistingTermAndCustomVars() {
+    func `preserves existing term and custom vars`() {
         let merged = TTYCommandRunner.enrichedEnvironment(
             baseEnv: [
                 "PATH": "/custom/bin",
@@ -111,19 +202,89 @@ struct TTYCommandRunnerEnvTests {
     }
 
     @Test
-    func setsWorkingDirectoryWhenProvided() throws {
+    func `codex status probe uses non persistent thread storage`() {
+        let stateHome = URL(fileURLWithPath: "/tmp/codexbar status \"state\"", isDirectory: true)
+        let args = CodexStatusProbeIsolation.codexArguments(stateHome: stateHome)
+
+        #expect(args.starts(with: ["-s", "read-only", "-a", "untrusted"]))
+        #expect(args.contains("history.persistence=\"none\""))
+        #expect(args.contains("experimental_thread_store={type=\"in_memory\",id=\"codexbar-status\"}"))
+        #expect(args.contains("sqlite_home=\"/tmp/codexbar status \\\"state\\\"\""))
+    }
+
+    @Test
+    func `codex status probe avoids root working directory when home exists`() {
+        let home = "/Users/tester"
+        let workingDirectory = CodexStatusProbeIsolation.workingDirectory(environment: ["HOME": home])
+        #expect(workingDirectory?.path == home)
+    }
+
+    @Test
+    func `sets working directory when provided`() throws {
         let fm = FileManager.default
         let dir = fm.temporaryDirectory.appendingPathComponent("codexbar-tty-\(UUID().uuidString)", isDirectory: true)
         try fm.createDirectory(at: dir, withIntermediateDirectories: true)
 
         let runner = TTYCommandRunner()
-        let result = try runner.run(binary: "/bin/pwd", send: "", options: .init(timeout: 3, workingDirectory: dir))
+        let result = try runner.run(
+            binary: "/bin/pwd",
+            send: "",
+            options: .init(timeout: Self.harnessPTYTimeout, workingDirectory: dir))
         let clean = result.text.replacingOccurrences(of: "\r", with: "")
         #expect(clean.contains(dir.path))
     }
 
     @Test
-    func autoRespondsToTrustPrompt() throws {
+    func `claude runner keeps normal working directory by default`() throws {
+        let runner = TTYCommandRunner()
+        let fakeClaude = try Self.makeFakeClaudeCLI()
+        let result = try runner.run(
+            binary: fakeClaude.path,
+            send: "",
+            options: .init(timeout: Self.harnessPTYTimeout, stopOnSubstrings: ["deep-link-enabled"]))
+        let clean = result.text.replacingOccurrences(of: "\r", with: "")
+
+        #expect(clean.contains("deep-link-enabled"))
+    }
+
+    @Test
+    func `claude runner uses probe directory with deep link registration disabled when requested`() throws {
+        let runner = TTYCommandRunner()
+        let fakeClaude = try Self.makeFakeClaudeCLI()
+        let result = try runner.run(
+            binary: fakeClaude.path,
+            send: "",
+            options: .init(
+                timeout: Self.harnessPTYTimeout,
+                stopOnSubstrings: ["deep-link-disabled"],
+                useClaudeProbeWorkingDirectory: true))
+        let clean = result.text.replacingOccurrences(of: "\r", with: "")
+
+        #expect(clean.contains("deep-link-disabled"))
+    }
+
+    @Test
+    func `claude runner uses probe directory for versioned CLI override`() throws {
+        let runner = TTYCommandRunner()
+        let fakeClaude = try Self.makeFakeClaudeCLI(fileName: "2.1.114")
+        var env = ProcessInfo.processInfo.environment
+        env["CLAUDE_CLI_PATH"] = fakeClaude.path
+
+        let result = try runner.run(
+            binary: fakeClaude.path,
+            send: "",
+            options: .init(
+                timeout: Self.harnessPTYTimeout,
+                baseEnvironment: env,
+                stopOnSubstrings: ["deep-link-disabled"],
+                useClaudeProbeWorkingDirectory: true))
+        let clean = result.text.replacingOccurrences(of: "\r", with: "")
+
+        #expect(clean.contains("deep-link-disabled"))
+    }
+
+    @Test
+    func `auto responds to trust prompt`() throws {
         let fm = FileManager.default
         let dir = fm.temporaryDirectory.appendingPathComponent("codexbar-tty-\(UUID().uuidString)", isDirectory: true)
         try fm.createDirectory(at: dir, withIntermediateDirectories: true)
@@ -150,7 +311,7 @@ struct TTYCommandRunnerEnvTests {
             binary: scriptURL.path,
             send: "",
             options: .init(
-                timeout: 6,
+                timeout: 15,
                 // Use LF for portability: some PTY/termios setups do not translate CR → NL for shell reads.
                 sendOnSubstrings: ["trust the files in this folder?": "y\n"],
                 stopOnSubstrings: ["accepted", "rejected"],
@@ -159,8 +320,118 @@ struct TTYCommandRunnerEnvTests {
         #expect(result.text.contains("accepted"))
     }
 
+    private static func makeFakeClaudeCLI(fileName: String = "claude") throws -> URL {
+        let fm = FileManager.default
+        let dir = fm.temporaryDirectory.appendingPathComponent("codexbar-tty-\(UUID().uuidString)", isDirectory: true)
+        try fm.createDirectory(at: dir, withIntermediateDirectories: true)
+        let scriptURL = dir.appendingPathComponent(fileName)
+        let script = """
+        #!/bin/sh
+        settings="$PWD/.claude/settings.local.json"
+        if [ -f "$settings" ] \
+          && grep -q '"disableDeepLinkRegistration"' "$settings" \
+          && grep -q '"disable"' "$settings"; then
+          echo "deep-link-disabled"
+        else
+          echo "deep-link-enabled"
+        fi
+        """
+        try script.write(to: scriptURL, atomically: true, encoding: .utf8)
+        try fm.setAttributes([.posixPermissions: 0o755], ofItemAtPath: scriptURL.path)
+        return scriptURL
+    }
+
+    @Test
+    func `post-exit drain processes trailing chunk through callback path`() {
+        let callbackCounter = CallbackCounter()
+        var reads: [TTYCommandRunner.DrainReadResult] = [
+            .wouldBlock,
+            .wouldBlock,
+            .data(Data("https://example.com/auth".utf8)),
+            .closed,
+        ]
+
+        TTYCommandRunner.drainRemainingOutput(
+            until: Date().addingTimeInterval(1),
+            readChunk: {
+                if reads.isEmpty { return .closed }
+                return reads.removeFirst()
+            },
+            processChunk: { data in
+                if data.range(of: Data("https://".utf8)) != nil {
+                    callbackCounter.increment()
+                }
+            },
+            sleep: { _ in })
+
+        #expect(callbackCounter.value() == 1)
+    }
+
+    @Test
+    func `post-exit drain keeps harvesting after late success marker`() {
+        var readCount = 0
+        var processedChunks: [String] = []
+        var reads: [TTYCommandRunner.DrainReadResult] = [
+            .data(Data("accepted".utf8)),
+            .wouldBlock,
+            .data(Data(" trailing".utf8)),
+            .closed,
+        ]
+
+        TTYCommandRunner.drainRemainingOutput(
+            until: Date().addingTimeInterval(1),
+            readChunk: {
+                readCount += 1
+                if reads.isEmpty { return .closed }
+                return reads.removeFirst()
+            },
+            processChunk: { data in
+                processedChunks.append(String(bytes: data, encoding: .utf8) ?? "")
+            },
+            sleep: { _ in })
+
+        #expect(readCount == 4)
+        #expect(processedChunks == ["accepted", " trailing"])
+    }
+
+    @Test
+    func `post-exit drain stops once the PTY reports closure`() {
+        var readCount = 0
+
+        TTYCommandRunner.drainRemainingOutput(
+            until: Date().addingTimeInterval(1),
+            readChunk: {
+                readCount += 1
+                return .closed
+            },
+            processChunk: { _ in },
+            sleep: { _ in })
+
+        #expect(readCount == 1)
+    }
+
+    @Test
+    func `interrupted drain reads are treated as retryable`() {
+        let result = TTYCommandRunner.drainReadResult(for: Data(), terminalRead: -1, errno: EINTR)
+        if case .wouldBlock = result {
+            #expect(Bool(true))
+        } else {
+            Issue.record("Expected interrupted read to remain retryable during drain")
+        }
+    }
+
+    @Test
+    func `EOF beats stale would-block errno during drain classification`() {
+        let result = TTYCommandRunner.drainReadResult(for: Data(), terminalRead: 0, errno: EAGAIN)
+        if case .closed = result {
+            #expect(Bool(true))
+        } else {
+            Issue.record("Expected EOF reads to stop draining even if errno still holds EAGAIN")
+        }
+    }
+
     @Test
-    func stopsWhenOutputIsIdle() throws {
+    func `stops when output is idle`() throws {
         let fm = FileManager.default
         let dir = fm.temporaryDirectory.appendingPathComponent("codexbar-tty-\(UUID().uuidString)", isDirectory: true)
         try fm.createDirectory(at: dir, withIntermediateDirectories: true)
@@ -195,7 +466,7 @@ struct TTYCommandRunnerEnvTests {
     }
 
     @Test
-    func rollingBufferDetectsNeedleAcrossBoundary() {
+    func `rolling buffer detects needle across boundary`() {
         var scanner = TTYCommandRunner.RollingBuffer(maxNeedle: 6)
         let needle = Data("hello".utf8)
         let first = scanner.append(Data("he".utf8))
@@ -205,7 +476,7 @@ struct TTYCommandRunnerEnvTests {
     }
 
     @Test
-    func lowercasedASCIIOnlyTouchesAscii() {
+    func `lowercased ASCII only touches ascii`() {
         let data = Data("UpDaTe".utf8)
         let lowered = TTYCommandRunner.lowercasedASCII(data)
         #expect(String(data: lowered, encoding: .utf8) == "update")
diff --git a/Tests/CodexBarTests/TTYIntegrationTests.swift b/Tests/CodexBarTests/TTYIntegrationTests.swift
index adf59bccb8..a17e3c3f9b 100644
--- a/Tests/CodexBarTests/TTYIntegrationTests.swift
+++ b/Tests/CodexBarTests/TTYIntegrationTests.swift
@@ -6,7 +6,10 @@ import Testing
 @Suite(.serialized)
 struct TTYIntegrationTests {
     @Test
-    func codexRPCUsageLive() async throws {
+    func `codex RPC usage live`() async throws {
+        guard ProcessInfo.processInfo.environment["LIVE_CODEX_TTY"] == "1" else {
+            return
+        }
         let fetcher = UsageFetcher()
         do {
             let snapshot = try await fetcher.loadLatestUsage()
@@ -23,7 +26,7 @@ struct TTYIntegrationTests {
     }
 
     @Test
-    func claudeTTYUsageProbeLive() async throws {
+    func `claude TTY usage probe live`() async throws {
         guard ProcessInfo.processInfo.environment["LIVE_CLAUDE_TTY"] == "1" else {
             return
         }
@@ -55,4 +58,85 @@ struct TTYIntegrationTests {
 
         if !shouldAssert { return }
     }
+
+    @Test
+    func `claude pty usage waits for values after session label`() async throws {
+        let cli = try Self.makeSlowUsageClaudeCLI()
+        defer { Task { await ClaudeCLISession.shared.reset() } }
+
+        let snapshot = try await ClaudeCLISession.withIsolatedSessionForTesting {
+            try await ClaudeStatusProbe(claudeBinary: cli.path, timeout: 10).fetch()
+        }
+
+        #expect(snapshot.sessionPercentLeft == 93)
+        #expect(snapshot.weeklyPercentLeft == 79)
+    }
+
+    @Test
+    func `claude pty usage stops on subscription notice`() async throws {
+        let cli = try Self.makeSubscriptionNoticeClaudeCLI()
+        defer { Task { await ClaudeCLISession.shared.reset() } }
+
+        do {
+            try await ClaudeCLISession.withIsolatedSessionForTesting {
+                _ = try await ClaudeStatusProbe(claudeBinary: cli.path, timeout: 3).fetch()
+            }
+            #expect(Bool(false), "Subscription notice should fail parsing")
+        } catch let ClaudeStatusProbeError.parseFailed(message) {
+            #expect(message.lowercased().contains("subscription"))
+        } catch {
+            #expect(Bool(false), "Unexpected error: \(error)")
+        }
+    }
+
+    private static func makeSlowUsageClaudeCLI() throws -> URL {
+        let dir = FileManager.default.temporaryDirectory
+            .appendingPathComponent("CodexBarTTYTests-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+        let url = dir.appendingPathComponent("claude")
+        let script = """
+        #!/bin/sh
+        while IFS= read -r line; do
+          case "$line" in
+            *"/usage"*)
+              printf '%s\\n' 'Settings  Status  Config  Usage'
+              printf '%s\\n' 'Current session'
+              sleep 2
+              printf '%s\\n' '93% left'
+              printf '%s\\n' 'Current week (all models)'
+              printf '%s\\n' '79% left'
+              ;;
+            *"/status"*)
+              printf '%s\\n' 'Account: slow-usage@example.com'
+              ;;
+          esac
+        done
+        """
+        try script.write(to: url, atomically: true, encoding: .utf8)
+        try FileManager.default.setAttributes([.posixPermissions: 0o755], ofItemAtPath: url.path)
+        return url
+    }
+
+    private static func makeSubscriptionNoticeClaudeCLI() throws -> URL {
+        let dir = FileManager.default.temporaryDirectory
+            .appendingPathComponent("CodexBarTTYTests-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+        let url = dir.appendingPathComponent("claude")
+        let script = """
+        #!/bin/sh
+        while IFS= read -r line; do
+          case "$line" in
+            *"/usage"*)
+              printf '%s\\n' 'You are currently using your subscription to power your Claude Code usage'
+              ;;
+            *"/status"*)
+              printf '%s\\n' 'Account: subscription@example.com'
+              ;;
+          esac
+        done
+        """
+        try script.write(to: url, atomically: true, encoding: .utf8)
+        try FileManager.default.setAttributes([.posixPermissions: 0o755], ofItemAtPath: url.path)
+        return url
+    }
 }
diff --git a/Tests/CodexBarTests/TerminalAppTests.swift b/Tests/CodexBarTests/TerminalAppTests.swift
new file mode 100644
index 0000000000..97a6b491ea
--- /dev/null
+++ b/Tests/CodexBarTests/TerminalAppTests.swift
@@ -0,0 +1,94 @@
+import Foundation
+import Testing
+@testable import CodexBar
+
+@Suite("TerminalApp")
+struct TerminalAppTests {
+    @Test
+    @MainActor
+    func `default is terminal`() throws {
+        let suite = "TerminalAppTests-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let store = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        #expect(store.terminalApp == .terminal)
+    }
+
+    @Test
+    @MainActor
+    func `setting terminal app persists it`() throws {
+        let suite = "TerminalAppTests-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let store = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        store.terminalApp = .iTerm
+        #expect(store.terminalApp == .iTerm)
+        #expect(defaults.string(forKey: "terminalApp") == "iTerm")
+    }
+
+    @Test
+    @MainActor
+    func `invalid stored value falls back to terminal`() throws {
+        let suite = "TerminalAppTests-\(UUID().uuidString)"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.set("nonexistent", forKey: "terminalApp")
+        let store = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        #expect(store.terminalApp == .terminal)
+    }
+
+    @Test
+    func `only two cases exist`() {
+        #expect(TerminalApp.allCases.count == 2)
+    }
+
+    @Test
+    func `all cases have unique bundle identifiers`() {
+        let ids = TerminalApp.allCases.map(\.bundleIdentifier)
+        #expect(Set(ids).count == TerminalApp.allCases.count)
+    }
+
+    @Test
+    func `all cases have non-empty labels`() {
+        for app in TerminalApp.allCases {
+            #expect(!app.label.isEmpty)
+        }
+    }
+
+    @Test
+    func `round-trip all cases through raw value`() {
+        for app in TerminalApp.allCases {
+            #expect(TerminalApp(rawValue: app.rawValue) == app)
+        }
+    }
+
+    @Test
+    func `escapes commands embedded in AppleScript strings`() {
+        let escaped = TerminalApp.escapeForAppleScript(#"echo "C:\tmp""#)
+
+        #expect(escaped == #"echo \"C:\\tmp\""#)
+    }
+
+    @Test
+    func `builds terminal-specific launch scripts`() {
+        let command = #"echo "hello""#
+        let terminalScript = TerminalApp.terminal.appleScript(command: command)
+        let iTermScript = TerminalApp.iTerm.appleScript(command: command)
+
+        #expect(terminalScript.contains(#"tell application "Terminal""#))
+        #expect(terminalScript.contains(#"do script "echo \"hello\"""#))
+        #expect(iTermScript.contains(#"tell application "iTerm""#))
+        #expect(iTermScript.contains(#"write text "echo \"hello\"""#))
+    }
+}
diff --git a/Tests/CodexBarTests/TestProcessCleanup.swift b/Tests/CodexBarTests/TestProcessCleanup.swift
index dbc3a1b767..af9d6f0b0c 100644
--- a/Tests/CodexBarTests/TestProcessCleanup.swift
+++ b/Tests/CodexBarTests/TestProcessCleanup.swift
@@ -7,12 +7,19 @@ import Glibc
 #endif
 
 enum TestProcessCleanup {
+    static let codexTestStubCommandRegex = [
+        #"codex-(stub|fallback-stub|plan-only-stub|credits-only-stub|hung-stub)-"#,
+        #"[[:xdigit:]]{8}-[[:xdigit:]]{4}-[[:xdigit:]]{4}-[[:xdigit:]]{4}-[[:xdigit:]]{12}"#,
+        #"[[:space:]]+app-server([[:space:]]|$)"#,
+    ].joined()
+
     static func register() {
         atexit(_testProcessCleanupAtExit)
     }
 
-    fileprivate static func terminateLeakedCodexAppServers() {
-        let pids = Self.pids(matchingFullCommandRegex: "codex.*app-server")
+    fileprivate static func terminateLeakedCodexTestStubs() {
+        // Never target an installed Codex process. These UUID-named executables are created only by this test target.
+        let pids = Self.pids(matchingFullCommandRegex: Self.codexTestStubCommandRegex)
             .filter { $0 > 0 && $0 != getpid() }
         guard !pids.isEmpty else { return }
 
@@ -65,5 +72,5 @@ private let _registerTestProcessCleanup: Void = TestProcessCleanup.register()
 
 @_cdecl("codexbar_test_cleanup_atexit")
 private func _testProcessCleanupAtExit() {
-    TestProcessCleanup.terminateLeakedCodexAppServers()
+    TestProcessCleanup.terminateLeakedCodexTestStubs()
 }
diff --git a/Tests/CodexBarTests/TestProcessCleanupTests.swift b/Tests/CodexBarTests/TestProcessCleanupTests.swift
new file mode 100644
index 0000000000..5fed8db627
--- /dev/null
+++ b/Tests/CodexBarTests/TestProcessCleanupTests.swift
@@ -0,0 +1,37 @@
+import Foundation
+import Testing
+
+struct TestProcessCleanupTests {
+    @Test
+    func `cleanup pattern matches only CodexBar test stub app servers`() throws {
+        let regex = try NSRegularExpression(pattern: TestProcessCleanup.codexTestStubCommandRegex)
+        let testStubCommands = [
+            "/usr/bin/python3 -S /tmp/codex-stub-01234567-89AB-CDEF-0123-456789ABCDEF app-server",
+            "/bin/sh /tmp/codex-fallback-stub-01234567-89AB-CDEF-0123-456789ABCDEF app-server",
+            "/bin/sh /tmp/codex-plan-only-stub-01234567-89AB-CDEF-0123-456789ABCDEF app-server",
+            "/bin/sh /tmp/codex-credits-only-stub-01234567-89AB-CDEF-0123-456789ABCDEF app-server",
+            "/bin/sh /tmp/codex-hung-stub-01234567-89AB-CDEF-0123-456789ABCDEF app-server",
+        ]
+        let userCommands = [
+            "/Applications/Codex.app/Contents/Resources/codex app-server --listen stdio://",
+            "/opt/homebrew/bin/codex app-server",
+            "node /Users/test/node_modules/.bin/codex app-server --listen stdio://",
+            "/tmp/codex-stub-cache app-server",
+            "/tmp/codex-stub-01234567-89AB-CDEF-0123 app-server",
+            "/tmp/codex-stub-01234567-89AB-CDEF-0123-456789ABCDEF app-server-helper",
+        ]
+
+        for command in testStubCommands {
+            #expect(Self.matches(regex, command))
+        }
+        for command in userCommands {
+            #expect(!Self.matches(regex, command))
+        }
+    }
+
+    private static func matches(_ regex: NSRegularExpression, _ command: String) -> Bool {
+        regex.firstMatch(
+            in: command,
+            range: NSRange(command.startIndex..., in: command)) != nil
+    }
+}
diff --git a/Tests/CodexBarTests/TestStores.swift b/Tests/CodexBarTests/TestStores.swift
index 7d8e274915..c42b6f854b 100644
--- a/Tests/CodexBarTests/TestStores.swift
+++ b/Tests/CodexBarTests/TestStores.swift
@@ -1,6 +1,9 @@
 import CodexBarCore
 import Foundation
 @testable import CodexBar
+#if os(macOS)
+import AppKit
+#endif
 
 final class InMemoryCookieHeaderStore: CookieHeaderStoring, @unchecked Sendable {
     var value: String?
@@ -132,3 +135,93 @@ func testConfigStore(suiteName: String, reset: Bool = true) -> CodexBarConfigSto
     }
     return CodexBarConfigStore(fileURL: url)
 }
+
+@MainActor
+func testSettingsStore(
+    suiteName: String,
+    tokenAccountStore: any ProviderTokenAccountStoring = InMemoryTokenAccountStore()) -> SettingsStore
+{
+    let isolatedSuiteName = "\(suiteName)-\(UUID().uuidString)"
+    guard let defaults = UserDefaults(suiteName: isolatedSuiteName) else {
+        preconditionFailure("Could not create test defaults suite")
+    }
+    defaults.removePersistentDomain(forName: isolatedSuiteName)
+    return SettingsStore(
+        userDefaults: defaults,
+        configStore: testConfigStore(suiteName: isolatedSuiteName),
+        zaiTokenStore: NoopZaiTokenStore(),
+        syntheticTokenStore: NoopSyntheticTokenStore(),
+        codexCookieStore: InMemoryCookieHeaderStore(),
+        claudeCookieStore: InMemoryCookieHeaderStore(),
+        cursorCookieStore: InMemoryCookieHeaderStore(),
+        opencodeCookieStore: InMemoryCookieHeaderStore(),
+        factoryCookieStore: InMemoryCookieHeaderStore(),
+        minimaxCookieStore: InMemoryMiniMaxCookieStore(),
+        minimaxAPITokenStore: InMemoryMiniMaxAPITokenStore(),
+        kimiTokenStore: InMemoryKimiTokenStore(),
+        kimiK2TokenStore: InMemoryKimiK2TokenStore(),
+        augmentCookieStore: InMemoryCookieHeaderStore(),
+        ampCookieStore: InMemoryCookieHeaderStore(),
+        copilotTokenStore: InMemoryCopilotTokenStore(),
+        tokenAccountStore: tokenAccountStore)
+}
+
+#if os(macOS)
+@MainActor
+func testStatusBar() -> NSStatusBar {
+    // Standalone NSStatusBar instances can crash during swiftpm-testing-helper teardown.
+    .system
+}
+
+@MainActor
+@discardableResult
+func withStatusItemControllerForTesting<T>(
+    store: UsageStore,
+    settings: SettingsStore,
+    fetcher: UsageFetcher,
+    statusBar: NSStatusBar = .system,
+    operation: (StatusItemController) throws -> T) rethrows -> T
+{
+    let controller = StatusItemController(
+        store: store,
+        settings: settings,
+        account: fetcher.loadAccountInfo(),
+        updater: DisabledUpdaterController(),
+        preferencesSelection: PreferencesSelection(),
+        statusBar: statusBar)
+    defer { controller.releaseStatusItemsForTesting() }
+    return try operation(controller)
+}
+
+@MainActor
+@discardableResult
+func withStatusItemControllerForTesting<T>(
+    store: UsageStore,
+    settings: SettingsStore,
+    fetcher: UsageFetcher,
+    statusBar: NSStatusBar = .system,
+    operation: (StatusItemController) async throws -> T) async rethrows -> T
+{
+    let controller = StatusItemController(
+        store: store,
+        settings: settings,
+        account: fetcher.loadAccountInfo(),
+        updater: DisabledUpdaterController(),
+        preferencesSelection: PreferencesSelection(),
+        statusBar: statusBar)
+    defer { controller.releaseStatusItemsForTesting() }
+    return try await operation(controller)
+}
+#endif
+
+func testPlanUtilizationHistoryStore(suiteName: String, reset: Bool = true) -> PlanUtilizationHistoryStore {
+    let sanitized = suiteName.replacingOccurrences(of: "/", with: "-")
+    let base = FileManager.default.temporaryDirectory
+        .appendingPathComponent("codexbar-tests", isDirectory: true)
+        .appendingPathComponent(sanitized, isDirectory: true)
+    let url = base.appendingPathComponent("history", isDirectory: true)
+    if reset {
+        try? FileManager.default.removeItem(at: url)
+    }
+    return PlanUtilizationHistoryStore(directoryURL: url)
+}
diff --git a/Tests/CodexBarTests/TextParsingTests.swift b/Tests/CodexBarTests/TextParsingTests.swift
index 812adbe026..ad4d07d25e 100644
--- a/Tests/CodexBarTests/TextParsingTests.swift
+++ b/Tests/CodexBarTests/TextParsingTests.swift
@@ -1,17 +1,16 @@
 import CodexBarCore
 import Testing
 
-@Suite
 struct TextParsingTests {
     @Test
-    func stripANSICodesRemovesCursorVisibilityCSI() {
+    func `strip ANSI codes removes cursor visibility CSI`() {
         let input = "\u{001B}[?25hhello\u{001B}[0m"
         let stripped = TextParsing.stripANSICodes(input)
         #expect(stripped == "hello")
     }
 
     @Test
-    func firstNumberParsesDecimalSeparators() {
+    func `first number parses decimal separators`() {
         let dotDecimal = TextParsing.firstNumber(pattern: #"Credits:\s*([0-9][0-9., ]*)"#, text: "Credits: 54.72")
         #expect(dotDecimal == 54.72)
 
diff --git a/Tests/CodexBarTests/TokenAccountEnvironmentPrecedenceTests.swift b/Tests/CodexBarTests/TokenAccountEnvironmentPrecedenceTests.swift
index cb36b24ae8..12172c24f2 100644
--- a/Tests/CodexBarTests/TokenAccountEnvironmentPrecedenceTests.swift
+++ b/Tests/CodexBarTests/TokenAccountEnvironmentPrecedenceTests.swift
@@ -4,11 +4,11 @@ import Testing
 @testable import CodexBar
 @testable import CodexBarCLI
 
+@Suite(.serialized)
 @MainActor
-@Suite
 struct TokenAccountEnvironmentPrecedenceTests {
     @Test
-    func tokenAccountEnvironmentOverridesConfigAPIKey_inAppEnvironmentBuilder() {
+    func `token account environment overrides config API key in app environment builder`() {
         let settings = Self.makeSettingsStore(suite: "TokenAccountEnvironmentPrecedenceTests-app")
         settings.zaiAPIToken = "config-token"
         settings.addTokenAccount(provider: .zai, label: "Account 1", token: "account-token")
@@ -25,7 +25,22 @@ struct TokenAccountEnvironmentPrecedenceTests {
     }
 
     @Test
-    func tokenAccountEnvironmentOverridesConfigAPIKey_inCLIEnvironmentBuilder() throws {
+    func `deepseek token account injects environment in app environment builder`() {
+        let settings = Self.makeSettingsStore(suite: "TokenAccountEnvironmentPrecedenceTests-deepseek-app")
+        settings.addTokenAccount(provider: .deepseek, label: "Account 1", token: "account-token")
+
+        let env = ProviderRegistry.makeEnvironment(
+            base: ["FOO": "bar"],
+            provider: .deepseek,
+            settings: settings,
+            tokenOverride: nil)
+
+        #expect(env["FOO"] == "bar")
+        #expect(env[DeepSeekSettingsReader.apiKeyEnvironmentKey] == "account-token")
+    }
+
+    @Test
+    func `token account environment overrides config API key in CLI environment builder`() throws {
         let config = CodexBarConfig(
             providers: [
                 ProviderConfig(id: .zai, apiKey: "config-token"),
@@ -46,7 +61,24 @@ struct TokenAccountEnvironmentPrecedenceTests {
     }
 
     @Test
-    func ollamaTokenAccountSelectionForcesManualCookieSourceInCLISettingsSnapshot() throws {
+    func `deepseek token account injects environment in CLI environment builder`() throws {
+        let config = CodexBarConfig(providers: [])
+        let selection = TokenAccountCLISelection(label: nil, index: nil, allAccounts: false)
+        let tokenContext = try TokenAccountCLIContext(selection: selection, config: config, verbose: false)
+        let account = ProviderTokenAccount(
+            id: UUID(),
+            label: "Account 1",
+            token: "account-token",
+            addedAt: Date().timeIntervalSince1970,
+            lastUsed: nil)
+
+        let env = tokenContext.environment(base: [:], provider: .deepseek, account: account)
+
+        #expect(env[DeepSeekSettingsReader.apiKeyEnvironmentKey] == "account-token")
+    }
+
+    @Test
+    func `ollama token account selection forces manual cookie source in CLI settings snapshot`() throws {
         let accounts = ProviderTokenAccountData(
             version: 1,
             accounts: [
@@ -76,7 +108,620 @@ struct TokenAccountEnvironmentPrecedenceTests {
     }
 
     @Test
-    func applyAccountLabelInAppPreservesSnapshotFields() {
+    func `command code config cookie is carried into CLI settings snapshot`() throws {
+        let config = CodexBarConfig(providers: [
+            ProviderConfig(
+                id: .commandcode,
+                cookieHeader: "better-auth.session_token=manual-token",
+                cookieSource: .manual),
+        ])
+        let selection = TokenAccountCLISelection(label: nil, index: nil, allAccounts: false)
+        let tokenContext = try TokenAccountCLIContext(selection: selection, config: config, verbose: false)
+        let snapshot = try #require(tokenContext.settingsSnapshot(for: .commandcode, account: nil))
+        let commandCodeSettings = try #require(snapshot.commandcode)
+
+        #expect(commandCodeSettings.cookieSource == .manual)
+        #expect(commandCodeSettings.manualCookieHeader == "better-auth.session_token=manual-token")
+    }
+
+    @Test
+    func `app snapshot override resolves cookie account without mutating stored selection`() throws {
+        let settings = Self.makeSettingsStore(suite: "TokenAccountEnvironmentPrecedenceTests-cookie-override-app")
+        settings.cursorCookieSource = .auto
+        settings.cursorCookieHeader = "configured=true"
+        let account = ProviderTokenAccount(
+            id: UUID(),
+            label: "Override",
+            token: "account=true",
+            addedAt: 0,
+            lastUsed: nil)
+
+        let snapshot = ProviderRegistry.makeSettingsSnapshot(
+            settings: settings,
+            tokenOverride: TokenAccountOverride(provider: .cursor, account: account))
+        let cursorSettings = try #require(snapshot.cursor)
+
+        #expect(cursorSettings.cookieSource == .manual)
+        #expect(cursorSettings.manualCookieHeader == "account=true")
+        #expect(settings.tokenAccounts(for: .cursor).isEmpty)
+    }
+
+    @Test
+    func `stepfun CLI snapshot reads manual token from region field`() throws {
+        let config = CodexBarConfig(
+            providers: [
+                ProviderConfig(
+                    id: .stepfun,
+                    region: "Oasis-Token=manual-token; Oasis-Webid=web"),
+            ])
+        let selection = TokenAccountCLISelection(label: nil, index: nil, allAccounts: false)
+        let tokenContext = try TokenAccountCLIContext(selection: selection, config: config, verbose: false)
+        let snapshot = try #require(tokenContext.settingsSnapshot(for: .stepfun, account: nil))
+        let stepfunSettings = try #require(snapshot.stepfun)
+
+        #expect(stepfunSettings.cookieSource == .manual)
+        #expect(stepfunSettings.manualToken == "Oasis-Token=manual-token; Oasis-Webid=web")
+    }
+
+    @Test
+    func `stepfun CLI token account overrides region manual token`() throws {
+        let account = ProviderTokenAccount(
+            id: UUID(),
+            label: "StepFun",
+            token: "account-token",
+            addedAt: Date().timeIntervalSince1970,
+            lastUsed: nil)
+        let config = CodexBarConfig(
+            providers: [
+                ProviderConfig(
+                    id: .stepfun,
+                    region: "manual-token",
+                    tokenAccounts: ProviderTokenAccountData(
+                        version: 1,
+                        accounts: [account],
+                        activeIndex: 0)),
+            ])
+        let selection = TokenAccountCLISelection(label: nil, index: nil, allAccounts: false)
+        let tokenContext = try TokenAccountCLIContext(selection: selection, config: config, verbose: false)
+        let resolvedAccount = try #require(tokenContext.resolvedAccounts(for: .stepfun).first)
+        let snapshot = try #require(tokenContext.settingsSnapshot(for: .stepfun, account: resolvedAccount))
+        let stepfunSettings = try #require(snapshot.stepfun)
+
+        #expect(stepfunSettings.cookieSource == .manual)
+        #expect(stepfunSettings.manualToken == "account-token")
+    }
+
+    @Test
+    func `claude OAuth token account overrides environment in app environment builder`() {
+        let settings = Self.makeSettingsStore(suite: "TokenAccountEnvironmentPrecedenceTests-claude-app")
+        settings.addTokenAccount(provider: .claude, label: "OAuth", token: "Bearer sk-ant-oat-account-token")
+
+        let env = ProviderRegistry.makeEnvironment(
+            base: ["FOO": "bar"],
+            provider: .claude,
+            settings: settings,
+            tokenOverride: nil)
+
+        #expect(env["FOO"] == "bar")
+        #expect(env[ClaudeOAuthCredentialsStore.environmentTokenKey] == "sk-ant-oat-account-token")
+    }
+
+    @Test
+    func `claude session account strips ambient admin api credentials in app environment builder`() {
+        let settings = Self.makeSettingsStore(suite: "TokenAccountEnvironmentPrecedenceTests-claude-admin-strip-app")
+        settings.claudeAdminAPIKey = "sk-ant-admin-config"
+        settings.addTokenAccount(provider: .claude, label: "Session", token: "sk-ant-session-token")
+
+        let env = ProviderRegistry.makeEnvironment(
+            base: [
+                "FOO": "bar",
+                ClaudeAdminAPISettingsReader.alternateAdminAPIKeyEnvironmentKey: "sk-ant-admin-base",
+                ClaudeOAuthCredentialsStore.environmentTokenKey: "sk-ant-oat-base",
+            ],
+            provider: .claude,
+            settings: settings,
+            tokenOverride: nil)
+
+        #expect(env["FOO"] == "bar")
+        #expect(env[ClaudeAdminAPISettingsReader.adminAPIKeyEnvironmentKey] == nil)
+        #expect(env[ClaudeAdminAPISettingsReader.alternateAdminAPIKeyEnvironmentKey] == nil)
+        #expect(env[ClaudeOAuthCredentialsStore.environmentTokenKey] == nil)
+    }
+
+    @Test
+    func `claude session key selection carries organization id in app settings snapshot`() throws {
+        let settings = Self.makeSettingsStore(suite: "TokenAccountEnvironmentPrecedenceTests-claude-org-app")
+        settings.addTokenAccount(
+            provider: .claude,
+            label: "Team",
+            token: "sk-ant-session-token",
+            organizationID: " org-team ")
+
+        let snapshot = ProviderRegistry.makeSettingsSnapshot(settings: settings, tokenOverride: nil)
+        let claudeSettings = try #require(snapshot.claude)
+
+        #expect(claudeSettings.manualCookieHeader == "sessionKey=sk-ant-session-token")
+        #expect(claudeSettings.organizationID == "org-team")
+    }
+
+    @Test
+    func `claude OAuth token selection forces OAuth in CLI settings snapshot`() throws {
+        let accounts = ProviderTokenAccountData(
+            version: 1,
+            accounts: [
+                ProviderTokenAccount(
+                    id: UUID(),
+                    label: "Primary",
+                    token: "Bearer sk-ant-oat-account-token",
+                    addedAt: 0,
+                    lastUsed: nil),
+            ],
+            activeIndex: 0)
+        let config = CodexBarConfig(
+            providers: [
+                ProviderConfig(
+                    id: .claude,
+                    cookieSource: .auto,
+                    tokenAccounts: accounts),
+            ])
+        let selection = TokenAccountCLISelection(label: nil, index: nil, allAccounts: false)
+        let tokenContext = try TokenAccountCLIContext(selection: selection, config: config, verbose: false)
+        let account = try #require(tokenContext.resolvedAccounts(for: .claude).first)
+        let snapshot = try #require(tokenContext.settingsSnapshot(for: .claude, account: account))
+        let claudeSettings = try #require(snapshot.claude)
+
+        #expect(claudeSettings.usageDataSource == .oauth)
+        #expect(claudeSettings.cookieSource == .off)
+        #expect(claudeSettings.manualCookieHeader == nil)
+    }
+
+    @Test
+    func `claude OAuth token selection injects environment override in CLI`() throws {
+        let accounts = ProviderTokenAccountData(
+            version: 1,
+            accounts: [
+                ProviderTokenAccount(
+                    id: UUID(),
+                    label: "Primary",
+                    token: "Bearer sk-ant-oat-account-token",
+                    addedAt: 0,
+                    lastUsed: nil),
+            ],
+            activeIndex: 0)
+        let config = CodexBarConfig(
+            providers: [
+                ProviderConfig(id: .claude, tokenAccounts: accounts),
+            ])
+        let selection = TokenAccountCLISelection(label: nil, index: nil, allAccounts: false)
+        let tokenContext = try TokenAccountCLIContext(selection: selection, config: config, verbose: false)
+        let account = try #require(tokenContext.resolvedAccounts(for: .claude).first)
+
+        let env = tokenContext.environment(base: ["FOO": "bar"], provider: .claude, account: account)
+
+        #expect(env["FOO"] == "bar")
+        #expect(env[ClaudeOAuthCredentialsStore.environmentTokenKey] == "sk-ant-oat-account-token")
+    }
+
+    @Test
+    func `claude session account strips ambient admin api credentials in CLI environment builder`() throws {
+        let accounts = ProviderTokenAccountData(
+            version: 1,
+            accounts: [
+                ProviderTokenAccount(
+                    id: UUID(),
+                    label: "Primary",
+                    token: "sk-ant-session-token",
+                    addedAt: 0,
+                    lastUsed: nil),
+            ],
+            activeIndex: 0)
+        let config = CodexBarConfig(
+            providers: [
+                ProviderConfig(
+                    id: .claude,
+                    apiKey: "sk-ant-admin-config",
+                    tokenAccounts: accounts),
+            ])
+        let selection = TokenAccountCLISelection(label: nil, index: nil, allAccounts: false)
+        let tokenContext = try TokenAccountCLIContext(selection: selection, config: config, verbose: false)
+        let account = try #require(tokenContext.resolvedAccounts(for: .claude).first)
+
+        let env = tokenContext.environment(
+            base: [
+                "FOO": "bar",
+                ClaudeAdminAPISettingsReader.alternateAdminAPIKeyEnvironmentKey: "sk-ant-admin-base",
+                ClaudeOAuthCredentialsStore.environmentTokenKey: "sk-ant-oat-base",
+            ],
+            provider: .claude,
+            account: account)
+
+        #expect(env["FOO"] == "bar")
+        #expect(env[ClaudeAdminAPISettingsReader.adminAPIKeyEnvironmentKey] == nil)
+        #expect(env[ClaudeAdminAPISettingsReader.alternateAdminAPIKeyEnvironmentKey] == nil)
+        #expect(env[ClaudeOAuthCredentialsStore.environmentTokenKey] == nil)
+    }
+
+    @Test
+    func `claude OAuth token selection promotes auto source mode in CLI`() throws {
+        let account = ProviderTokenAccount(
+            id: UUID(),
+            label: "Primary",
+            token: "Bearer sk-ant-oat-account-token",
+            addedAt: 0,
+            lastUsed: nil)
+        let config = CodexBarConfig(providers: [ProviderConfig(id: .claude)])
+        let tokenContext = try TokenAccountCLIContext(
+            selection: TokenAccountCLISelection(label: nil, index: nil, allAccounts: false),
+            config: config,
+            verbose: false)
+
+        let effectiveSourceMode = tokenContext.effectiveSourceMode(
+            base: .auto,
+            provider: .claude,
+            account: account)
+
+        #expect(effectiveSourceMode == .oauth)
+    }
+
+    @Test
+    func `claude OAuth token selection reroutes explicit CLI source to OAuth in CLI`() throws {
+        let account = ProviderTokenAccount(
+            id: UUID(),
+            label: "Primary",
+            token: "Bearer sk-ant-oat-account-token",
+            addedAt: 0,
+            lastUsed: nil)
+        let config = CodexBarConfig(providers: [ProviderConfig(id: .claude)])
+        let tokenContext = try TokenAccountCLIContext(
+            selection: TokenAccountCLISelection(label: nil, index: nil, allAccounts: false),
+            config: config,
+            verbose: false)
+
+        let effectiveSourceMode = tokenContext.effectiveSourceMode(
+            base: .cli,
+            provider: .claude,
+            account: account)
+
+        #expect(effectiveSourceMode == .oauth)
+    }
+
+    @Test
+    func `claude session key selection reroutes explicit CLI source to Web in CLI`() throws {
+        let account = ProviderTokenAccount(
+            id: UUID(),
+            label: "Primary",
+            token: "sk-ant-session-token",
+            addedAt: 0,
+            lastUsed: nil)
+        let config = CodexBarConfig(providers: [ProviderConfig(id: .claude)])
+        let tokenContext = try TokenAccountCLIContext(
+            selection: TokenAccountCLISelection(label: nil, index: nil, allAccounts: false),
+            config: config,
+            verbose: false)
+
+        let effectiveSourceMode = tokenContext.effectiveSourceMode(
+            base: .cli,
+            provider: .claude,
+            account: account)
+
+        #expect(effectiveSourceMode == .web)
+    }
+
+    @Test
+    func `claude all accounts reroutes explicit CLI source per selected credential in CLI`() throws {
+        let accounts = ProviderTokenAccountData(
+            version: 1,
+            accounts: [
+                ProviderTokenAccount(
+                    id: UUID(),
+                    label: "OAuth",
+                    token: "Bearer sk-ant-oat-account-token",
+                    addedAt: 0,
+                    lastUsed: nil),
+                ProviderTokenAccount(
+                    id: UUID(),
+                    label: "Session",
+                    token: "sk-ant-session-token",
+                    addedAt: 0,
+                    lastUsed: nil),
+            ],
+            activeIndex: 0)
+        let config = CodexBarConfig(
+            providers: [
+                ProviderConfig(id: .claude, tokenAccounts: accounts),
+            ])
+        let tokenContext = try TokenAccountCLIContext(
+            selection: TokenAccountCLISelection(label: nil, index: nil, allAccounts: true),
+            config: config,
+            verbose: false)
+
+        let resolved = try tokenContext.resolvedAccounts(for: .claude)
+        #expect(resolved.map(\.label) == ["OAuth", "Session"])
+
+        let oauth = try #require(resolved.first)
+        let oauthSnapshot = try #require(tokenContext.settingsSnapshot(for: .claude, account: oauth)?.claude)
+        #expect(tokenContext.effectiveSourceMode(base: .cli, provider: .claude, account: oauth) == .oauth)
+        #expect(oauthSnapshot.usageDataSource == .oauth)
+        #expect(tokenContext.environment(base: [:], provider: .claude, account: oauth)[
+            ClaudeOAuthCredentialsStore.environmentTokenKey,
+        ] == "sk-ant-oat-account-token")
+
+        let session = try #require(resolved.dropFirst().first)
+        let sessionSnapshot = try #require(tokenContext.settingsSnapshot(for: .claude, account: session)?.claude)
+        #expect(tokenContext.effectiveSourceMode(base: .cli, provider: .claude, account: session) == .web)
+        #expect(sessionSnapshot.cookieSource == .manual)
+        #expect(sessionSnapshot.manualCookieHeader == "sessionKey=sk-ant-session-token")
+    }
+
+    @Test
+    func `codex all accounts selection exposes configured accounts and scopes CLI homes`() throws {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-cli-all-accounts-\(UUID().uuidString)", isDirectory: true)
+        let ambientHome = root.appendingPathComponent("ambient", isDirectory: true)
+        let firstHome = root.appendingPathComponent("first", isDirectory: true)
+        let secondHome = root.appendingPathComponent("second", isDirectory: true)
+        let profileHome = root.appendingPathComponent("profile", isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+        try FileManager.default.createDirectory(at: ambientHome, withIntermediateDirectories: true)
+        try FileManager.default.createDirectory(at: firstHome, withIntermediateDirectories: true)
+        try FileManager.default.createDirectory(at: secondHome, withIntermediateDirectories: true)
+        try Self.writeCodexAuthFile(
+            homeURL: profileHome,
+            email: "profile@example.com",
+            accountID: "acct_profile")
+        let storeURL = root.appendingPathComponent("managed-codex-accounts.json")
+        let firstID = UUID()
+        let secondID = UUID()
+        let accounts = ManagedCodexAccountSet(version: FileManagedCodexAccountStore.currentVersion, accounts: [
+            ManagedCodexAccount(
+                id: firstID,
+                email: "FIRST@EXAMPLE.COM",
+                workspaceLabel: "Team",
+                managedHomePath: firstHome.path,
+                createdAt: 0,
+                updatedAt: 0,
+                lastAuthenticatedAt: nil),
+            ManagedCodexAccount(
+                id: secondID,
+                email: "second@example.com",
+                workspaceLabel: "Personal",
+                managedHomePath: secondHome.path,
+                createdAt: 0,
+                updatedAt: 0,
+                lastAuthenticatedAt: nil),
+        ])
+        try FileManagedCodexAccountStore(fileURL: storeURL).storeAccounts(accounts)
+        let config = CodexBarConfig(providers: [
+            ProviderConfig(
+                id: .codex,
+                codexActiveSource: .managedAccount(id: secondID),
+                codexProfileHomePaths: [profileHome.path]),
+        ])
+        let context = try TokenAccountCLIContext(
+            selection: TokenAccountCLISelection(label: nil, index: nil, allAccounts: true),
+            config: config,
+            verbose: false,
+            baseEnvironment: ["CODEX_HOME": ambientHome.path],
+            managedCodexAccountStoreURL: storeURL)
+
+        let projection = context.visibleCodexAccounts()
+        #expect(projection.visibleAccounts.map(\.menuDisplayName) == [
+            "first@example.com — Team",
+            "profile@example.com",
+            "second@example.com",
+        ])
+        #expect(projection.visibleAccounts.map(\.selectionSource) == [
+            .managedAccount(id: firstID),
+            .profileHome(path: profileHome.path),
+            .managedAccount(id: secondID),
+        ])
+        #expect(projection.visibleAccounts.first { $0.email == "second@example.com" }?.isActive == true)
+
+        let firstEnv = context.environment(
+            base: ["CODEX_HOME": ambientHome.path],
+            provider: .codex,
+            account: nil,
+            codexActiveSourceOverride: .managedAccount(id: firstID))
+        #expect(firstEnv["CODEX_HOME"] == firstHome.path)
+
+        let profileEnv = context.environment(
+            base: ["CODEX_HOME": ambientHome.path],
+            provider: .codex,
+            account: nil,
+            codexActiveSourceOverride: .profileHome(path: profileHome.path))
+        #expect(profileEnv["CODEX_HOME"] == profileHome.path)
+        #expect(context.settingsSnapshot(
+            for: .codex,
+            account: nil,
+            codexActiveSourceOverride: .profileHome(path: profileHome.path))?.codex?.openAIWebCacheScope
+            == .profileHome(profileHome.path))
+
+        let liveEnv = context.environment(
+            base: ["CODEX_HOME": ambientHome.path],
+            provider: .codex,
+            account: nil,
+            codexActiveSourceOverride: .liveSystem)
+        #expect(liveEnv["CODEX_HOME"] == ambientHome.path)
+
+        let firstFetcher = context.fetcher(
+            base: UsageFetcher(environment: ["CODEX_HOME": ambientHome.path]),
+            provider: .codex,
+            env: firstEnv)
+        #expect(Self.codexHomePath(from: firstFetcher) == firstHome.path)
+
+        let nonCodexBaseFetcher = UsageFetcher(environment: ["CODEX_HOME": ambientHome.path])
+        let nonCodexFetcher = context.fetcher(base: nonCodexBaseFetcher, provider: .claude, env: firstEnv)
+        #expect(Self.codexHomePath(from: nonCodexFetcher) == ambientHome.path)
+
+        let labeled = try context.applyCodexVisibleAccountLabel(
+            UsageSnapshot(primary: nil, secondary: nil, updatedAt: Date()),
+            account: #require(projection.visibleAccounts.first))
+        let identity = try #require(labeled.identity(for: .codex))
+        #expect(identity.accountEmail == "first@example.com")
+        #expect(identity.accountOrganization == "Team")
+    }
+
+    @Test
+    func `codex CLI ignores relative profile homes`() throws {
+        let config = CodexBarConfig(providers: [
+            ProviderConfig(
+                id: .codex,
+                codexActiveSource: .profileHome(path: "relative-codex-home"),
+                codexProfileHomePaths: ["relative-codex-home"]),
+        ])
+        let context = try TokenAccountCLIContext(
+            selection: TokenAccountCLISelection(label: nil, index: nil, allAccounts: false),
+            config: config,
+            verbose: false,
+            baseEnvironment: ["CODEX_HOME": "/tmp/ambient-codex"])
+
+        let environment = context.environment(
+            base: ["CODEX_HOME": "/tmp/ambient-codex"],
+            provider: .codex,
+            account: nil,
+            codexActiveSourceOverride: .profileHome(path: "relative-codex-home"))
+
+        #expect(context.visibleCodexAccounts().visibleAccounts.isEmpty)
+        #expect(environment["CODEX_HOME"] == "/tmp/ambient-codex")
+    }
+
+    @Test
+    func `claude ambient explicit CLI source remains CLI in CLI`() throws {
+        let config = CodexBarConfig(providers: [ProviderConfig(id: .claude)])
+        let tokenContext = try TokenAccountCLIContext(
+            selection: TokenAccountCLISelection(label: nil, index: nil, allAccounts: false),
+            config: config,
+            verbose: false)
+
+        let effectiveSourceMode = tokenContext.effectiveSourceMode(
+            base: .cli,
+            provider: .claude,
+            account: nil)
+
+        #expect(effectiveSourceMode == .cli)
+    }
+
+    @Test
+    func `claude session key selection stays in manual cookie mode in CLI settings snapshot`() throws {
+        let accounts = ProviderTokenAccountData(
+            version: 1,
+            accounts: [
+                ProviderTokenAccount(
+                    id: UUID(),
+                    label: "Primary",
+                    token: "sk-ant-session-token",
+                    addedAt: 0,
+                    lastUsed: nil),
+            ],
+            activeIndex: 0)
+        let config = CodexBarConfig(
+            providers: [
+                ProviderConfig(
+                    id: .claude,
+                    cookieSource: .auto,
+                    tokenAccounts: accounts),
+            ])
+        let selection = TokenAccountCLISelection(label: nil, index: nil, allAccounts: false)
+        let tokenContext = try TokenAccountCLIContext(selection: selection, config: config, verbose: false)
+        let account = try #require(tokenContext.resolvedAccounts(for: .claude).first)
+        let snapshot = try #require(tokenContext.settingsSnapshot(for: .claude, account: account))
+        let claudeSettings = try #require(snapshot.claude)
+
+        #expect(claudeSettings.usageDataSource == .auto)
+        #expect(claudeSettings.cookieSource == .manual)
+        #expect(claudeSettings.manualCookieHeader == "sessionKey=sk-ant-session-token")
+    }
+
+    @Test
+    func `claude session key selection carries organization id in CLI settings snapshot`() throws {
+        let accounts = ProviderTokenAccountData(
+            version: 1,
+            accounts: [
+                ProviderTokenAccount(
+                    id: UUID(),
+                    label: "Team",
+                    token: "sk-ant-session-token",
+                    addedAt: 0,
+                    lastUsed: nil,
+                    organizationID: " org-team "),
+            ],
+            activeIndex: 0)
+        let config = CodexBarConfig(
+            providers: [
+                ProviderConfig(
+                    id: .claude,
+                    tokenAccounts: accounts),
+            ])
+        let selection = TokenAccountCLISelection(label: nil, index: nil, allAccounts: false)
+        let tokenContext = try TokenAccountCLIContext(selection: selection, config: config, verbose: false)
+        let account = try #require(tokenContext.resolvedAccounts(for: .claude).first)
+        let snapshot = try #require(tokenContext.settingsSnapshot(for: .claude, account: account))
+        let claudeSettings = try #require(snapshot.claude)
+
+        #expect(claudeSettings.organizationID == "org-team")
+    }
+
+    @Test
+    func `claude token account organization id uses organizationId JSON key`() throws {
+        let json = """
+        {
+          "id": "00000000-0000-0000-0000-000000000001",
+          "label": "Team",
+          "token": "sk-ant-session-token",
+          "addedAt": 0,
+          "lastUsed": null,
+          "organizationId": "org-team"
+        }
+        """
+        let account = try JSONDecoder().decode(ProviderTokenAccount.self, from: Data(json.utf8))
+        let encoded = try JSONSerialization.jsonObject(with: JSONEncoder().encode(account)) as? [String: Any]
+
+        #expect(account.organizationID == "org-team")
+        #expect(encoded?["organizationId"] as? String == "org-team")
+        #expect(encoded?["organizationID"] == nil)
+    }
+
+    @Test
+    func `claude config manual cookie uses shared route in CLI settings snapshot`() throws {
+        let config = CodexBarConfig(
+            providers: [
+                ProviderConfig(
+                    id: .claude,
+                    cookieHeader: "Cookie: sessionKey=sk-ant-session-token; foo=bar"),
+            ])
+        let selection = TokenAccountCLISelection(label: nil, index: nil, allAccounts: false)
+        let tokenContext = try TokenAccountCLIContext(selection: selection, config: config, verbose: false)
+        let snapshot = try #require(tokenContext.settingsSnapshot(for: .claude, account: nil))
+        let claudeSettings = try #require(snapshot.claude)
+
+        #expect(claudeSettings.usageDataSource == .auto)
+        #expect(claudeSettings.cookieSource == .manual)
+        #expect(claudeSettings.manualCookieHeader == "sessionKey=sk-ant-session-token; foo=bar")
+    }
+
+    @Test
+    func `claude config manual cookie does not promote auto source mode in CLI`() throws {
+        let config = CodexBarConfig(
+            providers: [
+                ProviderConfig(
+                    id: .claude,
+                    cookieHeader: "Cookie: sessionKey=sk-ant-session-token"),
+            ])
+        let tokenContext = try TokenAccountCLIContext(
+            selection: TokenAccountCLISelection(label: nil, index: nil, allAccounts: false),
+            config: config,
+            verbose: false)
+
+        let effectiveSourceMode = tokenContext.effectiveSourceMode(
+            base: .auto,
+            provider: .claude,
+            account: nil)
+
+        #expect(effectiveSourceMode == .auto)
+    }
+
+    @Test
+    func `apply account label in app preserves snapshot fields`() {
         let settings = Self.makeSettingsStore(suite: "TokenAccountEnvironmentPrecedenceTests-apply-app")
         let store = Self.makeUsageStore(settings: settings)
         let snapshot = Self.makeSnapshotWithAllFields(provider: .zai)
@@ -95,7 +740,7 @@ struct TokenAccountEnvironmentPrecedenceTests {
     }
 
     @Test
-    func applyAccountLabelInCLIPreservesSnapshotFields() throws {
+    func `apply account label in CLI preserves snapshot fields`() throws {
         let context = try TokenAccountCLIContext(
             selection: TokenAccountCLISelection(label: nil, index: nil, allAccounts: false),
             config: CodexBarConfig(providers: []),
@@ -115,7 +760,139 @@ struct TokenAccountEnvironmentPrecedenceTests {
         #expect(labeled.identity?.accountEmail == "CLI Account")
     }
 
-    private static func makeSettingsStore(suite: String) -> SettingsStore {
+    @Test
+    func `codex known owners match between app and CLI for live system only`() throws {
+        let ambientHome = Self.makeTempCodexHome(
+            email: "live@example.com",
+            plan: "pro",
+            accountId: "acct-live")
+        defer { try? FileManager.default.removeItem(at: ambientHome) }
+
+        let appSettings = Self.makeSettingsStore(suite: "TokenAccountEnvironmentPrecedenceTests-codex-live-only")
+        appSettings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: ambientHome.path,
+            observedAt: Date(),
+            identity: .providerAccount(id: "acct-live"))
+        defer { appSettings._test_liveSystemCodexAccount = nil }
+        let appStore = Self.makeUsageStore(settings: appSettings)
+
+        try Self.withCLIKnownOwnerFixtures(
+            ambientHome: ambientHome,
+            managedAccounts: [])
+        { managedStoreURL in
+            let rawCLIOwners = try Self.codexCLIKnownOwners(
+                ambientHome: ambientHome,
+                managedStoreURL: managedStoreURL)
+            let cliOwners = try #require(rawCLIOwners)
+            let appOwners = appStore.codexDashboardKnownOwnerCandidates()
+
+            #expect(Self.knownOwnerMultiset(appOwners) == Self.knownOwnerMultiset(cliOwners))
+        }
+    }
+
+    @Test
+    func `codex known owners match between app and CLI when managed and live identities are the same`() throws {
+        let ambientHome = Self.makeTempCodexHome(
+            email: "shared@example.com",
+            plan: "pro",
+            accountId: "acct-shared")
+        let managedHome = Self.makeTempCodexHome(
+            email: "shared@example.com",
+            plan: "pro",
+            accountId: "acct-shared")
+        defer {
+            try? FileManager.default.removeItem(at: ambientHome)
+            try? FileManager.default.removeItem(at: managedHome)
+        }
+
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "shared@example.com",
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 3)
+        let appSettings = Self.makeSettingsStore(suite: "TokenAccountEnvironmentPrecedenceTests-codex-same-identity")
+        appSettings._test_activeManagedCodexAccount = managedAccount
+        appSettings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "shared@example.com",
+            codexHomePath: ambientHome.path,
+            observedAt: Date(),
+            identity: .providerAccount(id: "acct-shared"))
+        defer {
+            appSettings._test_activeManagedCodexAccount = nil
+            appSettings._test_liveSystemCodexAccount = nil
+        }
+        let appStore = Self.makeUsageStore(settings: appSettings)
+
+        try Self.withCLIKnownOwnerFixtures(
+            ambientHome: ambientHome,
+            managedAccounts: [managedAccount])
+        { managedStoreURL in
+            let rawCLIOwners = try Self.codexCLIKnownOwners(
+                ambientHome: ambientHome,
+                managedStoreURL: managedStoreURL)
+            let cliOwners = try #require(rawCLIOwners)
+            let appOwners = appStore.codexDashboardKnownOwnerCandidates()
+
+            #expect(Self.knownOwnerMultiset(appOwners) == Self.knownOwnerMultiset(cliOwners))
+        }
+    }
+
+    @Test
+    func `codex known owners match between app and CLI when managed and live identities differ`() throws {
+        let ambientHome = Self.makeTempCodexHome(
+            email: "live@example.com",
+            plan: "pro",
+            accountId: "acct-live")
+        let managedHome = Self.makeTempCodexHome(
+            email: "managed@example.com",
+            plan: "pro",
+            accountId: "acct-managed")
+        defer {
+            try? FileManager.default.removeItem(at: ambientHome)
+            try? FileManager.default.removeItem(at: managedHome)
+        }
+
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: managedHome.path,
+            createdAt: 1,
+            updatedAt: 2,
+            lastAuthenticatedAt: 3)
+        let appSettings = Self
+            .makeSettingsStore(suite: "TokenAccountEnvironmentPrecedenceTests-codex-different-identities")
+        appSettings._test_activeManagedCodexAccount = managedAccount
+        appSettings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: ambientHome.path,
+            observedAt: Date(),
+            identity: .providerAccount(id: "acct-live"))
+        defer {
+            appSettings._test_activeManagedCodexAccount = nil
+            appSettings._test_liveSystemCodexAccount = nil
+        }
+        let appStore = Self.makeUsageStore(settings: appSettings)
+
+        try Self.withCLIKnownOwnerFixtures(
+            ambientHome: ambientHome,
+            managedAccounts: [managedAccount])
+        { managedStoreURL in
+            let rawCLIOwners = try Self.codexCLIKnownOwners(
+                ambientHome: ambientHome,
+                managedStoreURL: managedStoreURL)
+            let cliOwners = try #require(rawCLIOwners)
+            let appOwners = appStore.codexDashboardKnownOwnerCandidates()
+
+            #expect(Self.knownOwnerMultiset(appOwners) == Self.knownOwnerMultiset(cliOwners))
+        }
+    }
+}
+
+extension TokenAccountEnvironmentPrecedenceTests {
+    fileprivate static func makeSettingsStore(suite: String) -> SettingsStore {
         let defaults = UserDefaults(suiteName: suite)!
         defaults.removePersistentDomain(forName: suite)
         let configStore = testConfigStore(suiteName: suite)
@@ -140,14 +917,112 @@ struct TokenAccountEnvironmentPrecedenceTests {
             tokenAccountStore: InMemoryTokenAccountStore())
     }
 
-    private static func makeUsageStore(settings: SettingsStore) -> UsageStore {
+    fileprivate static func makeUsageStore(settings: SettingsStore) -> UsageStore {
         UsageStore(
             fetcher: UsageFetcher(environment: [:]),
             browserDetection: BrowserDetection(cacheTTL: 0),
             settings: settings)
     }
 
-    private static func makeSnapshotWithAllFields(provider: UsageProvider) -> UsageSnapshot {
+    fileprivate static func codexCLIKnownOwners(
+        ambientHome: URL,
+        managedStoreURL: URL) throws -> [CodexDashboardKnownOwnerCandidate]?
+    {
+        let context = try TokenAccountCLIContext(
+            selection: TokenAccountCLISelection(label: nil, index: nil, allAccounts: false),
+            config: CodexBarConfig(providers: [ProviderConfig(id: .codex)]),
+            verbose: false,
+            baseEnvironment: ["CODEX_HOME": ambientHome.path],
+            managedCodexAccountStoreURL: managedStoreURL)
+        return context.settingsSnapshot(for: .codex, account: nil)?.codex?.dashboardAuthorityKnownOwners
+    }
+
+    fileprivate static func codexHomePath(from fetcher: UsageFetcher) -> String? {
+        guard let environment = Mirror(reflecting: fetcher).children.first(where: { $0.label == "environment" })?
+            .value as? [String: String]
+        else {
+            return nil
+        }
+        return environment["CODEX_HOME"]
+    }
+
+    fileprivate static func writeCodexAuthFile(homeURL: URL, email: String, accountID: String) throws {
+        try FileManager.default.createDirectory(at: homeURL, withIntermediateDirectories: true)
+        let auth: [String: Any] = [
+            "tokens": [
+                "accessToken": "access-token",
+                "refreshToken": "refresh-token",
+                "idToken": self.fakeJWT(email: email, plan: "pro", accountId: accountID),
+                "account_id": accountID,
+            ],
+        ]
+        let data = try JSONSerialization.data(withJSONObject: auth)
+        try data.write(to: homeURL.appendingPathComponent("auth.json"))
+    }
+
+    fileprivate static func knownOwnerMultiset(
+        _ owners: [CodexDashboardKnownOwnerCandidate]) -> [CodexDashboardKnownOwnerCandidate: Int]
+    {
+        owners.reduce(into: [:]) { counts, owner in
+            counts[owner, default: 0] += 1
+        }
+    }
+
+    fileprivate static func makeTempCodexHome(email: String, plan: String, accountId: String) -> URL {
+        let home = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-known-owner-\(UUID().uuidString)", isDirectory: true)
+        try? FileManager.default.createDirectory(at: home, withIntermediateDirectories: true)
+        let credentials = CodexOAuthCredentials(
+            accessToken: "access-token",
+            refreshToken: "refresh-token",
+            idToken: self.fakeJWT(email: email, plan: plan, accountId: accountId),
+            accountId: accountId,
+            lastRefresh: Date())
+        try? CodexOAuthCredentialsStore.save(credentials, env: ["CODEX_HOME": home.path])
+        return home
+    }
+
+    fileprivate static func fakeJWT(email: String, plan: String, accountId: String) -> String {
+        let header = (try? JSONSerialization.data(withJSONObject: ["alg": "none"])) ?? Data()
+        let payload = (try? JSONSerialization.data(withJSONObject: [
+            "email": email,
+            "chatgpt_plan_type": plan,
+            "https://api.openai.com/auth": [
+                "chatgpt_plan_type": plan,
+                "chatgpt_account_id": accountId,
+            ],
+        ])) ?? Data()
+
+        func base64URL(_ data: Data) -> String {
+            data.base64EncodedString()
+                .replacingOccurrences(of: "=", with: "")
+                .replacingOccurrences(of: "+", with: "-")
+                .replacingOccurrences(of: "/", with: "_")
+        }
+
+        return "\(base64URL(header)).\(base64URL(payload))."
+    }
+
+    fileprivate static func withCLIKnownOwnerFixtures<T>(
+        ambientHome: URL,
+        managedAccounts: [ManagedCodexAccount],
+        operation: (URL) throws -> T) throws -> T
+    {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-known-owner-store-\(UUID().uuidString)", isDirectory: true)
+        let managedStoreURL = root.appendingPathComponent("managed-codex-accounts.json", isDirectory: false)
+        let fileManager = FileManager.default
+        defer { try? fileManager.removeItem(at: root) }
+
+        let managedStore = FileManagedCodexAccountStore(fileURL: managedStoreURL)
+        try managedStore.storeAccounts(ManagedCodexAccountSet(
+            version: FileManagedCodexAccountStore.currentVersion,
+            accounts: managedAccounts))
+
+        return try operation(managedStoreURL)
+    }
+
+    fileprivate static func makeSnapshotWithAllFields(provider: UsageProvider) -> UsageSnapshot {
         let now = Date(timeIntervalSince1970: 1_700_000_000)
         let reset = Date(timeIntervalSince1970: 1_700_003_600)
         let tokenLimit = ZaiLimitEntry(
@@ -199,11 +1074,13 @@ struct TokenAccountEnvironmentPrecedenceTests {
                 rateLimit: nil,
                 updatedAt: now),
             cursorRequests: CursorRequestUsage(used: 7, limit: 70),
+            subscriptionExpiresAt: reset.addingTimeInterval(86400),
+            subscriptionRenewsAt: reset.addingTimeInterval(43200),
             updatedAt: now,
             identity: identity)
     }
 
-    private static func expectSnapshotFieldsPreserved(before: UsageSnapshot, after: UsageSnapshot) {
+    fileprivate static func expectSnapshotFieldsPreserved(before: UsageSnapshot, after: UsageSnapshot) {
         #expect(after.primary?.usedPercent == before.primary?.usedPercent)
         #expect(after.secondary?.usedPercent == before.secondary?.usedPercent)
         #expect(after.tertiary?.usedPercent == before.tertiary?.usedPercent)
@@ -218,6 +1095,8 @@ struct TokenAccountEnvironmentPrecedenceTests {
         #expect(after.openRouterUsage?.rateLimit?.requests == before.openRouterUsage?.rateLimit?.requests)
         #expect(after.cursorRequests?.used == before.cursorRequests?.used)
         #expect(after.cursorRequests?.limit == before.cursorRequests?.limit)
+        #expect(after.subscriptionExpiresAt == before.subscriptionExpiresAt)
+        #expect(after.subscriptionRenewsAt == before.subscriptionRenewsAt)
         #expect(after.updatedAt == before.updatedAt)
     }
 }
diff --git a/Tests/CodexBarTests/TokenAccountStoreTests.swift b/Tests/CodexBarTests/TokenAccountStoreTests.swift
index e1cbbce240..9a252219fa 100644
--- a/Tests/CodexBarTests/TokenAccountStoreTests.swift
+++ b/Tests/CodexBarTests/TokenAccountStoreTests.swift
@@ -3,8 +3,8 @@ import Foundation
 import Testing
 @testable import CodexBar
 
-@Test("ProviderTokenAccountData encoding")
-func providerTokenAccountDataEncoding() throws {
+@Test
+func `ProviderTokenAccountData encoding`() throws {
     let now = Date().timeIntervalSince1970
     let account = ProviderTokenAccount(
         id: UUID(),
@@ -26,8 +26,8 @@ func providerTokenAccountDataEncoding() throws {
     #expect(decoded.activeIndex == 0)
 }
 
-@Test("FileTokenAccountStore round trip")
-func fileTokenAccountStoreRoundTrip() throws {
+@Test
+func `FileTokenAccountStore round trip`() throws {
     let tempDir = FileManager.default.temporaryDirectory
     let fileURL = tempDir.appendingPathComponent("codexbar-token-accounts-test.json")
     defer { try? FileManager.default.removeItem(at: fileURL) }
diff --git a/Tests/CodexBarTests/UpdateChannelTests.swift b/Tests/CodexBarTests/UpdateChannelTests.swift
index c5ee1f9c9c..c93ed23985 100644
--- a/Tests/CodexBarTests/UpdateChannelTests.swift
+++ b/Tests/CodexBarTests/UpdateChannelTests.swift
@@ -1,22 +1,21 @@
 import Testing
 @testable import CodexBar
 
-@Suite
 struct UpdateChannelTests {
     @Test
-    func defaultChannelFromStableVersion() {
+    func `default channel from stable version`() {
         #expect(UpdateChannel.defaultChannel(for: "1.2.3") == .stable)
     }
 
     @Test
-    func defaultChannelFromPrereleaseVersion() {
+    func `default channel from prerelease version`() {
         #expect(UpdateChannel.defaultChannel(for: "1.2.3-beta.1") == .beta)
         #expect(UpdateChannel.defaultChannel(for: "1.2.3-rc.1") == .beta)
         #expect(UpdateChannel.defaultChannel(for: "1.2.3-alpha") == .beta)
     }
 
     @Test
-    func allowedSparkleChannels() {
+    func `allowed sparkle channels`() {
         #expect(UpdateChannel.stable.allowedSparkleChannels == [""])
         #expect(UpdateChannel.beta.allowedSparkleChannels == ["", UpdateChannel.sparkleBetaChannel])
     }
diff --git a/Tests/CodexBarTests/UsageFormatterTests.swift b/Tests/CodexBarTests/UsageFormatterTests.swift
index 072b299df6..e973891236 100644
--- a/Tests/CodexBarTests/UsageFormatterTests.swift
+++ b/Tests/CodexBarTests/UsageFormatterTests.swift
@@ -3,32 +3,152 @@ import Foundation
 import Testing
 @testable import CodexBar
 
-@Suite
+@Suite(.serialized)
 struct UsageFormatterTests {
+    private static let usageFormatterLocalizationKeys: [String] = [
+        "%@ left",
+        "Resets %@",
+        "Resets in %@",
+        "Resets now",
+        "reset_tomorrow_format",
+        "Updated %@",
+        "Updated %@h ago",
+        "Updated %@m ago",
+        "Updated just now",
+        "usage_percent_suffix_left",
+        "usage_percent_suffix_used",
+        "byte_unit_byte",
+        "byte_unit_bytes",
+        "byte_unit_kilobyte",
+        "byte_unit_kilobytes",
+        "byte_unit_megabyte",
+        "byte_unit_megabytes",
+        "byte_unit_gigabyte",
+        "byte_unit_gigabytes",
+    ]
+
     @Test
-    func formatsUsageLine() {
+    func `formats usage line`() {
+        UsageFormatter.clearLocalizationProvider()
+        UsageFormatter.clearLocaleProvider()
         let line = UsageFormatter.usageLine(remaining: 25, used: 75, showUsed: false)
         #expect(line == "25% left")
     }
 
     @Test
-    func formatsUsageLineShowUsed() {
+    func `formats usage line show used`() {
+        UsageFormatter.clearLocalizationProvider()
+        UsageFormatter.clearLocaleProvider()
         let line = UsageFormatter.usageLine(remaining: 25, used: 75, showUsed: true)
         #expect(line == "75% used")
     }
 
     @Test
-    func relativeUpdatedRecent() {
+    func `usage line respects injected localization provider`() {
+        UsageFormatter.setLocalizationProvider { key in
+            switch key {
+            case "usage_percent_suffix_left": "剩余"
+            case "usage_percent_suffix_used": "已使用"
+            default: key
+            }
+        }
+        defer { UsageFormatter.clearLocalizationProvider() }
+
+        #expect(UsageFormatter.usageLine(remaining: 22, used: 78, showUsed: false) == "22% 剩余")
+        #expect(UsageFormatter.usageLine(remaining: 22, used: 78, showUsed: true) == "78% 已使用")
+    }
+
+    @Test
+    func `default locale fallback matches stable en US POSIX behavior`() {
+        UsageFormatter.clearLocalizationProvider()
+        UsageFormatter.clearLocaleProvider()
+
+        let now = Date(timeIntervalSince1970: 1_710_048_000)
+        let old = now.addingTimeInterval(-(26 * 3600))
+
+        let defaultOutput = UsageFormatter.updatedString(from: old, now: now)
+        UsageFormatter.setLocaleProvider { Locale(identifier: "en_US_POSIX") }
+        let injectedStableOutput = UsageFormatter.updatedString(from: old, now: now)
+        UsageFormatter.clearLocaleProvider()
+
+        #expect(defaultOutput == injectedStableOutput)
+    }
+
+    @Test
+    func `injected zh Hans locale applies app language formatting`() {
+        UsageFormatter.setLocalizationProvider { key in
+            switch key {
+            case "Updated %@":
+                "更新于 %@"
+            default:
+                key
+            }
+        }
+        UsageFormatter.setLocaleProvider { Locale(identifier: "zh-Hans") }
+        defer {
+            UsageFormatter.clearLocalizationProvider()
+            UsageFormatter.clearLocaleProvider()
+        }
+
+        let now = Date(timeIntervalSince1970: 1_710_048_000)
+        let old = now.addingTimeInterval(-(26 * 3600))
+        let output = UsageFormatter.updatedString(from: old, now: now)
+
+        #expect(output.hasPrefix("更新于 "))
+    }
+
+    @Test
+    func `clearing locale provider returns to stable default behavior`() {
+        UsageFormatter.clearLocalizationProvider()
+        UsageFormatter.clearLocaleProvider()
+
+        let now = Date(timeIntervalSince1970: 1_710_048_000)
+        let old = now.addingTimeInterval(-(26 * 3600))
+        let baseline = UsageFormatter.updatedString(from: old, now: now)
+
+        UsageFormatter.setLocaleProvider { Locale(identifier: "fr_FR") }
+        _ = UsageFormatter.updatedString(from: old, now: now)
+        UsageFormatter.clearLocaleProvider()
+
+        let restored = UsageFormatter.updatedString(from: old, now: now)
+        #expect(restored == baseline)
+    }
+
+    @Test
+    func `tomorrow reset description uses localized format`() throws {
+        UsageFormatter.setLocalizationProvider { key in
+            key == "reset_tomorrow_format" ? "明日 %@" : key
+        }
+        UsageFormatter.setLocaleProvider { Locale(identifier: "ja_JP") }
+        defer {
+            UsageFormatter.clearLocalizationProvider()
+            UsageFormatter.clearLocaleProvider()
+        }
+
+        let calendar = Calendar.current
+        let today = calendar.startOfDay(for: Date(timeIntervalSince1970: 1_750_000_000))
+        let now = try #require(calendar.date(byAdding: .hour, value: 12, to: today))
+        let tomorrow = try #require(calendar.date(byAdding: .day, value: 1, to: today))
+        let reset = try #require(calendar.date(byAdding: .minute, value: 10 * 60 + 50, to: tomorrow))
+
+        let output = UsageFormatter.resetDescription(from: reset, now: now)
+        #expect(output.hasPrefix("明日 "))
+        #expect(!output.contains("tomorrow"))
+        #expect(!output.contains("%@"))
+    }
+
+    @Test
+    func `relative updated recent`() {
         let now = Date()
         let fiveHoursAgo = now.addingTimeInterval(-5 * 3600)
         let text = UsageFormatter.updatedString(from: fiveHoursAgo, now: now)
-        #expect(text.contains("Updated"))
-        // Check for relative time format (varies by locale: "ago" in English, "전" in Korean, etc.)
-        #expect(text.contains("5") || text.lowercased().contains("hour") || text.contains("시간"))
+        #expect(text.hasPrefix("Updated ") || text.hasPrefix("更新"))
+        #expect(text.contains("5"))
+        #expect(text.lowercased().contains("ago") || text.contains("前"))
     }
 
     @Test
-    func absoluteUpdatedOld() {
+    func `absolute updated old`() {
         let now = Date()
         let dayAgo = now.addingTimeInterval(-26 * 3600)
         let text = UsageFormatter.updatedString(from: dayAgo, now: now)
@@ -37,42 +157,42 @@ struct UsageFormatterTests {
     }
 
     @Test
-    func resetCountdown_minutes() {
+    func `reset countdown minutes`() {
         let now = Date(timeIntervalSince1970: 1_000_000)
         let reset = now.addingTimeInterval(10 * 60 + 1)
         #expect(UsageFormatter.resetCountdownDescription(from: reset, now: now) == "in 11m")
     }
 
     @Test
-    func resetCountdown_hoursAndMinutes() {
+    func `reset countdown hours and minutes`() {
         let now = Date(timeIntervalSince1970: 1_000_000)
         let reset = now.addingTimeInterval(3 * 3600 + 31 * 60)
         #expect(UsageFormatter.resetCountdownDescription(from: reset, now: now) == "in 3h 31m")
     }
 
     @Test
-    func resetCountdown_daysAndHours() {
+    func `reset countdown days and hours`() {
         let now = Date(timeIntervalSince1970: 1_000_000)
         let reset = now.addingTimeInterval((26 * 3600) + 10)
         #expect(UsageFormatter.resetCountdownDescription(from: reset, now: now) == "in 1d 2h")
     }
 
     @Test
-    func resetCountdown_exactHour() {
+    func `reset countdown exact hour`() {
         let now = Date(timeIntervalSince1970: 1_000_000)
         let reset = now.addingTimeInterval(60 * 60)
         #expect(UsageFormatter.resetCountdownDescription(from: reset, now: now) == "in 1h")
     }
 
     @Test
-    func resetCountdown_pastDate() {
+    func `reset countdown past date`() {
         let now = Date(timeIntervalSince1970: 1_000_000)
         let reset = now.addingTimeInterval(-10)
         #expect(UsageFormatter.resetCountdownDescription(from: reset, now: now) == "now")
     }
 
     @Test
-    func resetLineUsesCountdownWhenResetsAtIsAvailable() {
+    func `reset line uses countdown when resets at is available`() {
         let now = Date(timeIntervalSince1970: 1_000_000)
         let reset = now.addingTimeInterval(10 * 60 + 1)
         let window = RateWindow(usedPercent: 0, windowMinutes: nil, resetsAt: reset, resetDescription: "Resets soon")
@@ -81,7 +201,7 @@ struct UsageFormatterTests {
     }
 
     @Test
-    func resetLineFallsBackToProvidedDescription() {
+    func `reset line falls back to provided description`() {
         let window = RateWindow(
             usedPercent: 0,
             windowMinutes: nil,
@@ -94,22 +214,46 @@ struct UsageFormatterTests {
     }
 
     @Test
-    func modelDisplayNameStripsTrailingDates() {
+    func `model display name strips trailing dates`() {
         #expect(UsageFormatter.modelDisplayName("claude-opus-4-5-20251101") == "claude-opus-4-5")
         #expect(UsageFormatter.modelDisplayName("gpt-4o-2024-08-06") == "gpt-4o")
         #expect(UsageFormatter.modelDisplayName("Claude Opus 4.5 2025 1101") == "Claude Opus 4.5")
         #expect(UsageFormatter.modelDisplayName("claude-sonnet-4-5") == "claude-sonnet-4-5")
+        #expect(UsageFormatter.modelDisplayName("gpt-5.3-codex-spark") == "gpt-5.3-codex-spark")
     }
 
     @Test
-    func cleanPlanMapsOAuthToOllama() {
+    func `model cost detail uses research preview label`() {
+        #expect(
+            UsageFormatter.modelCostDetail("gpt-5.3-codex-spark", costUSD: 0, totalTokens: nil) == "Research Preview")
+        #expect(UsageFormatter.modelCostDetail("gpt-5.2-codex", costUSD: 0.42, totalTokens: nil) == "$0.42")
+    }
+
+    @Test
+    func `model cost detail includes token counts when present`() {
+        #expect(UsageFormatter.modelCostDetail("gpt-5.2-codex", costUSD: 0.42, totalTokens: 1200) == "$0.42 · 1.2K")
+        #expect(
+            UsageFormatter.modelCostDetail("gpt-5.3-codex-spark", costUSD: 0, totalTokens: 1500)
+                == "Research Preview · 1.5K")
+        #expect(UsageFormatter.modelCostDetail("custom-model", costUSD: nil, totalTokens: 987) == "987")
+    }
+
+    @Test
+    func `token count string formats small values without grouping`() {
+        #expect(UsageFormatter.tokenCountString(0) == "0")
+        #expect(UsageFormatter.tokenCountString(987) == "987")
+        #expect(UsageFormatter.tokenCountString(-42) == "-42")
+    }
+
+    @Test
+    func `clean plan maps O auth to ollama`() {
         #expect(UsageFormatter.cleanPlanName("oauth") == "Ollama")
     }
 
     // MARK: - Currency Formatting
 
     @Test
-    func currencyStringFormatsUSDCorrectly() {
+    func `currency string formats USD correctly`() {
         // Should produce "$54.72" without space after symbol
         let result = UsageFormatter.currencyString(54.72, currencyCode: "USD")
         #expect(result == "$54.72")
@@ -117,7 +261,7 @@ struct UsageFormatterTests {
     }
 
     @Test
-    func currencyStringHandlesLargeValues() {
+    func `currency string handles large values`() {
         let result = UsageFormatter.currencyString(1234.56, currencyCode: "USD")
         // For USD, we use direct string formatting with thousand separators
         #expect(result == "$1,234.56")
@@ -125,26 +269,26 @@ struct UsageFormatterTests {
     }
 
     @Test
-    func currencyStringHandlesVeryLargeValues() {
+    func `currency string handles very large values`() {
         let result = UsageFormatter.currencyString(1_234_567.89, currencyCode: "USD")
         #expect(result == "$1,234,567.89")
     }
 
     @Test
-    func currencyStringHandlesNegativeValues() {
+    func `currency string handles negative values`() {
         // Negative sign should come before the dollar sign: -$54.72 (not $-54.72)
         let result = UsageFormatter.currencyString(-54.72, currencyCode: "USD")
         #expect(result == "-$54.72")
     }
 
     @Test
-    func currencyStringHandlesNegativeLargeValues() {
+    func `currency string handles negative large values`() {
         let result = UsageFormatter.currencyString(-1234.56, currencyCode: "USD")
         #expect(result == "-$1,234.56")
     }
 
     @Test
-    func usdStringMatchesCurrencyString() {
+    func `usd string matches currency string`() {
         // usdString should produce identical output to currencyString for USD
         #expect(UsageFormatter.usdString(54.72) == UsageFormatter.currencyString(54.72, currencyCode: "USD"))
         #expect(UsageFormatter.usdString(-1234.56) == UsageFormatter.currencyString(-1234.56, currencyCode: "USD"))
@@ -152,13 +296,13 @@ struct UsageFormatterTests {
     }
 
     @Test
-    func currencyStringHandlesZero() {
+    func `currency string handles zero`() {
         let result = UsageFormatter.currencyString(0, currencyCode: "USD")
         #expect(result == "$0.00")
     }
 
     @Test
-    func currencyStringHandlesNonUSDCurrencies() {
+    func `currency string handles non USD currencies`() {
         // FormatStyle handles all currencies with proper symbols
         let eur = UsageFormatter.currencyString(54.72, currencyCode: "EUR")
         #expect(eur == "€54.72")
@@ -172,7 +316,7 @@ struct UsageFormatterTests {
     }
 
     @Test
-    func currencyStringHandlesSmallValues() {
+    func `currency string handles small values`() {
         // Values smaller than 0.01 should round to $0.00
         let tiny = UsageFormatter.currencyString(0.001, currencyCode: "USD")
         #expect(tiny == "$0.00")
@@ -187,7 +331,7 @@ struct UsageFormatterTests {
     }
 
     @Test
-    func currencyStringHandlesBoundaryValues() {
+    func `currency string handles boundary values`() {
         // Just under 1000 (no comma)
         let under1k = UsageFormatter.currencyString(999.99, currencyCode: "USD")
         #expect(under1k == "$999.99")
@@ -202,8 +346,77 @@ struct UsageFormatterTests {
     }
 
     @Test
-    func creditsStringFormatsCorrectly() {
+    func `credits string formats correctly`() {
         let result = UsageFormatter.creditsString(from: 42.5)
         #expect(result == "42.5 left")
     }
+
+    @Test
+    func `byte count string formats binary units`() {
+        #expect(UsageFormatter.byteCountString(0) == "0 B")
+        #expect(UsageFormatter.byteCountString(512) == "512 B")
+        #expect(UsageFormatter.byteCountString(1536) == "1.5 KB")
+        #expect(UsageFormatter.byteCountString(10 * 1024) == "10 KB")
+        #expect(UsageFormatter.byteCountString(5 * 1024 * 1024) == "5 MB")
+        #expect(UsageFormatter.byteCountString(Int64(1536 * 1024 * 1024)) == "1.5 GB")
+        #expect(UsageFormatter.byteCountString(.min) == "-8589934592 GB")
+    }
+
+    @Test
+    func `long byte count string localizes units and handles boundaries`() {
+        UsageFormatter.clearLocalizationProvider()
+        #expect(UsageFormatter.byteCountStringLong(1024 * 1024) == "1 megabyte")
+
+        UsageFormatter.setLocalizationProvider { "[\($0)]" }
+        defer { UsageFormatter.clearLocalizationProvider() }
+
+        #expect(UsageFormatter.byteCountStringLong(1) == "1 [byte_unit_byte]")
+        #expect(UsageFormatter.byteCountStringLong(2) == "2 [byte_unit_bytes]")
+        #expect(UsageFormatter.byteCountStringLong(1536) == "1.5 [byte_unit_kilobytes]")
+        #expect(UsageFormatter.byteCountStringLong(1024 * 1024) == "1 [byte_unit_megabyte]")
+        #expect(UsageFormatter.byteCountStringLong(1024 * 1024 + 1) == "1.0 [byte_unit_megabyte]")
+        #expect(UsageFormatter.byteCountStringLong(.min) == "-8589934592 [byte_unit_gigabytes]")
+    }
+
+    @Test
+    func `usage formatter localization keys exist in en and zh Hans with matching placeholders`() throws {
+        let root = URL(fileURLWithPath: #filePath)
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+
+        let enURL = root.appendingPathComponent("Sources/CodexBar/Resources/en.lproj/Localizable.strings")
+        let zhURL = root.appendingPathComponent("Sources/CodexBar/Resources/zh-Hans.lproj/Localizable.strings")
+
+        let en = try Self.readStringsTable(at: enURL)
+        let zh = try Self.readStringsTable(at: zhURL)
+
+        for key in Self.usageFormatterLocalizationKeys {
+            let enValue = try #require(en[key], "Missing en key: \(key)")
+            let zhValue = try #require(zh[key], "Missing zh-Hans key: \(key)")
+            #expect(
+                Self.placeholderTokens(in: enValue) == Self.placeholderTokens(in: zhValue),
+                "Placeholder mismatch for key '\(key)': en='\(enValue)' zh='\(zhValue)'")
+        }
+    }
+
+    private static func readStringsTable(at url: URL) throws -> [String: String] {
+        guard let dict = NSDictionary(contentsOf: url) as? [String: String] else {
+            throw NSError(
+                domain: "UsageFormatterTests",
+                code: 1,
+                userInfo: [NSLocalizedDescriptionKey: "Failed to parse strings file at \(url.path)"])
+        }
+        return dict
+    }
+
+    private static func placeholderTokens(in value: String) -> [String] {
+        guard let regex = try? NSRegularExpression(pattern: "%(?:\\d+\\$)?[@dDuUxXfFeEgGcCsSpaA]") else {
+            return []
+        }
+        let nsRange = NSRange(value.startIndex..<value.endIndex, in: value)
+        return regex
+            .matches(in: value, options: [], range: nsRange)
+            .compactMap { Range($0.range, in: value).map { String(value[$0]) } }
+    }
 }
diff --git a/Tests/CodexBarTests/UsageMenuCardLayoutTests.swift b/Tests/CodexBarTests/UsageMenuCardLayoutTests.swift
new file mode 100644
index 0000000000..cdc58326ec
--- /dev/null
+++ b/Tests/CodexBarTests/UsageMenuCardLayoutTests.swift
@@ -0,0 +1,114 @@
+import AppKit
+import CodexBarCore
+import SwiftUI
+import Testing
+@testable import CodexBar
+
+@MainActor
+struct UsageMenuCardLayoutTests {
+    private static let heightTolerance: CGFloat = 1
+
+    @Test
+    func `header only menu card keeps comfortable padding`() {
+        let model = Self.model()
+        let width: CGFloat = 296
+
+        let headerSize = NSHostingController(rootView: UsageMenuCardHeaderSectionView(
+            model: model,
+            showDivider: false,
+            width: width))
+            .sizeThatFits(in: CGSize(width: width, height: .greatestFiniteMagnitude))
+        let cardSize = NSHostingController(rootView: UsageMenuCardView(model: model, width: width))
+            .sizeThatFits(in: CGSize(width: width, height: .greatestFiniteMagnitude))
+
+        #expect(headerSize.height > 0)
+        #expect(abs(cardSize.height - headerSize.height) < Self.heightTolerance)
+    }
+
+    @Test
+    func `full provider card matches overview height`() {
+        let model = Self.model(metrics: [
+            UsageMenuCardView.Model.Metric(
+                id: "session",
+                title: "Session",
+                percent: 37,
+                percentStyle: .left,
+                resetText: "Resets in 41m",
+                detailText: nil,
+                detailLeftText: "24% in reserve",
+                detailRightText: "Lasts until reset",
+                pacePercent: nil,
+                paceOnTop: true),
+        ])
+        let width: CGFloat = 296
+
+        let fullCardSize = NSHostingController(rootView: UsageMenuCardView(model: model, width: width))
+            .sizeThatFits(in: CGSize(width: width, height: .greatestFiniteMagnitude))
+        let overviewStyleSize = NSHostingController(rootView: UsageMenuCardHeaderAndUsageSectionView(
+            model: model,
+            layoutModel: model,
+            bottomPadding: UsageMenuCardLayout.sectionBottomPadding,
+            width: width))
+            .sizeThatFits(in: CGSize(width: width, height: .greatestFiniteMagnitude))
+
+        #expect(UsageMenuCardLayout.postHeaderDividerContentSpacing == 16)
+        #expect(UsageMenuCardLayout.headerOnlyVerticalPadding == 6)
+        #expect(UsageMenuCardLayout.sectionTopPadding == 6)
+        #expect(UsageMenuCardLayout.sectionBottomPadding == 6)
+
+        #expect(abs(fullCardSize.height - overviewStyleSize.height) < Self.heightTolerance)
+    }
+
+    @Test
+    func `detail card keeps compact divider gap without usage section`() {
+        let metricsModel = Self.model(metrics: [
+            UsageMenuCardView.Model.Metric(
+                id: "session",
+                title: "Session",
+                percent: 37,
+                percentStyle: .left,
+                resetText: "Resets in 41m",
+                detailText: nil,
+                detailLeftText: "24% in reserve",
+                detailRightText: "Lasts until reset",
+                pacePercent: nil,
+                paceOnTop: true),
+        ])
+
+        #expect(UsageMenuCardView.dividerBottomPadding(for: metricsModel) ==
+            UsageMenuCardLayout.postHeaderDividerContentSpacing)
+        #expect(UsageMenuCardView.dividerBottomPadding(for: Self.model(creditsText: "$12.34 remaining")) ==
+            UsageMenuCardLayout.sectionBottomPadding)
+        #expect(UsageMenuCardView.dividerBottomPadding(for: Self.model(usageNotes: ["Waiting for data"])) ==
+            UsageMenuCardLayout.sectionBottomPadding)
+        #expect(UsageMenuCardView.dividerBottomPadding(for: Self.model(placeholder: "No usage yet")) ==
+            UsageMenuCardLayout.sectionBottomPadding)
+    }
+
+    private static func model(
+        metrics: [UsageMenuCardView.Model.Metric] = [],
+        usageNotes: [String] = [],
+        creditsText: String? = nil,
+        placeholder: String? = nil) -> UsageMenuCardView.Model
+    {
+        UsageMenuCardView.Model(
+            provider: .codex,
+            providerName: "Codex",
+            email: "steipete@gmail.com",
+            subtitleText: "Not fetched yet",
+            subtitleStyle: .info,
+            planText: "Pro 20x",
+            metrics: metrics,
+            usageNotes: usageNotes,
+            openAIAPIUsage: nil,
+            inlineUsageDashboard: nil,
+            creditsText: creditsText,
+            creditsRemaining: nil,
+            creditsHintText: nil,
+            creditsHintCopyText: nil,
+            providerCost: nil,
+            tokenUsage: nil,
+            placeholder: placeholder,
+            progressColor: .blue)
+    }
+}
diff --git a/Tests/CodexBarTests/UsagePaceTests.swift b/Tests/CodexBarTests/UsagePaceTests.swift
index b00ed51923..c162bf868c 100644
--- a/Tests/CodexBarTests/UsagePaceTests.swift
+++ b/Tests/CodexBarTests/UsagePaceTests.swift
@@ -2,10 +2,9 @@ import CodexBarCore
 import Foundation
 import Testing
 
-@Suite
 struct UsagePaceTests {
     @Test
-    func weeklyPace_computesDeltaAndEta() {
+    func `weekly pace computes delta and eta`() {
         let now = Date(timeIntervalSince1970: 0)
         let window = RateWindow(
             usedPercent: 50,
@@ -27,7 +26,7 @@ struct UsagePaceTests {
     }
 
     @Test
-    func weeklyPace_marksLastsToResetWhenUsageIsLow() {
+    func `weekly pace marks lasts to reset when usage is low`() {
         let now = Date(timeIntervalSince1970: 0)
         let window = RateWindow(
             usedPercent: 5,
@@ -46,7 +45,7 @@ struct UsagePaceTests {
     }
 
     @Test
-    func weeklyPace_hidesWhenResetMissingOrOutsideWindow() {
+    func `weekly pace hides when reset missing or outside window`() {
         let now = Date(timeIntervalSince1970: 0)
         let missing = RateWindow(
             usedPercent: 10,
@@ -64,7 +63,7 @@ struct UsagePaceTests {
     }
 
     @Test
-    func weeklyPace_hidesWhenUsageExistsButNoElapsed() {
+    func `weekly pace hides when usage exists but no elapsed`() {
         let now = Date(timeIntervalSince1970: 0)
         let window = RateWindow(
             usedPercent: 12,
@@ -76,4 +75,488 @@ struct UsagePaceTests {
 
         #expect(pace == nil)
     }
+
+    // MARK: - Workday-aware pace
+
+    @Test
+    func `workday aware pace shows on track for five day user on friday`() throws {
+        // Window: Sun Jun 7 00:00 → Sun Jun 14 00:00 (7 days).
+        // "now" is Friday Jun 12 18:00 → elapsed = 5.75 days.
+        // 7-day linear: expected ≈ 82.1%, actual = 100% → ~18% deficit.
+        // 5-day workday: Mon-Thu plus 18 hours Friday → expected = 95%.
+        let calendar = Self.utcCalendar
+
+        // Reset on Sunday Jun 14 00:00
+        var resetComponents = DateComponents()
+        resetComponents.calendar = calendar
+        resetComponents.timeZone = calendar.timeZone
+        resetComponents.year = 2026
+        resetComponents.month = 6
+        resetComponents.day = 14 // Sunday
+        resetComponents.hour = 0
+        resetComponents.minute = 0
+        let resetsAt = try #require(calendar.date(from: resetComponents))
+
+        // "now" is Friday Jun 12 18:00 (30 hours before reset)
+        let now = resetsAt.addingTimeInterval(-30 * 3600)
+
+        let window = RateWindow(
+            usedPercent: 100,
+            windowMinutes: 10080,
+            resetsAt: resetsAt,
+            resetDescription: nil)
+
+        let pace7 = try #require(UsagePace.weekly(window: window, now: now, workDays: nil))
+        let pace5 = try #require(UsagePace.weekly(
+            window: window,
+            now: now,
+            workDays: 5,
+            calendar: calendar))
+
+        // 7-day linear: expected ≈ 82%, actual = 100% → ~18% deficit
+        #expect(pace7.deltaPercent > 15)
+
+        // 5-day workday: expected = 95%, so 100% actual remains within the on-pace threshold.
+        #expect(abs(pace5.expectedUsedPercent - 95) < 0.01)
+        #expect(abs(pace5.deltaPercent) <= 5)
+    }
+
+    @Test
+    func `workday aware pace shows on track midweek`() throws {
+        // Window: Sun Jun 7 00:00 → Sun Jun 14 00:00.
+        // "now" is Thu Jun 11 00:00 → 3 full workdays (Mon-Wed) elapsed of 5.
+        // 5-day model: expected ≈ 60%.
+        let calendar = Self.utcCalendar
+
+        // Reset on Sunday Jun 14 00:00
+        var resetComponents = DateComponents()
+        resetComponents.calendar = calendar
+        resetComponents.timeZone = calendar.timeZone
+        resetComponents.year = 2026
+        resetComponents.month = 6
+        resetComponents.day = 14 // Sunday
+        resetComponents.hour = 0
+        resetComponents.minute = 0
+        let resetsAt = try #require(calendar.date(from: resetComponents))
+
+        // Thu Jun 11 00:00 (3 days before reset).
+        let now = resetsAt.addingTimeInterval(-72 * 3600)
+
+        let window = RateWindow(
+            usedPercent: 60,
+            windowMinutes: 10080,
+            resetsAt: resetsAt,
+            resetDescription: nil)
+
+        let pace5 = try #require(UsagePace.weekly(
+            window: window,
+            now: now,
+            workDays: 5,
+            calendar: calendar))
+
+        // 3 full workdays elapsed out of 5 → expected ≈ 60%
+        #expect(abs(pace5.expectedUsedPercent - 60) < 0.01)
+        #expect(abs(pace5.deltaPercent) < 0.01)
+    }
+
+    @Test
+    func `workday aware exhausted quota does not last through weekend`() throws {
+        let calendar = Self.utcCalendar
+
+        let resetsAt = try #require(calendar.date(from: DateComponents(
+            calendar: calendar,
+            timeZone: calendar.timeZone,
+            year: 2026,
+            month: 6,
+            day: 14)))
+        let now = try #require(calendar.date(from: DateComponents(
+            calendar: calendar,
+            timeZone: calendar.timeZone,
+            year: 2026,
+            month: 6,
+            day: 13,
+            hour: 12)))
+        let window = RateWindow(
+            usedPercent: 100,
+            windowMinutes: 10080,
+            resetsAt: resetsAt,
+            resetDescription: nil)
+
+        let pace = try #require(UsagePace.weekly(
+            window: window,
+            now: now,
+            workDays: 5,
+            calendar: calendar))
+
+        #expect(pace.willLastToReset == false)
+        #expect(pace.etaSeconds == 0)
+    }
+
+    @Test
+    func `workday aware eta excludes non workday elapsed time`() throws {
+        let calendar = Self.utcCalendar
+
+        let resetsAt = try #require(calendar.date(from: DateComponents(
+            calendar: calendar,
+            timeZone: calendar.timeZone,
+            year: 2026,
+            month: 6,
+            day: 14)))
+        let now = try #require(calendar.date(from: DateComponents(
+            calendar: calendar,
+            timeZone: calendar.timeZone,
+            year: 2026,
+            month: 6,
+            day: 8,
+            hour: 12)))
+        let window = RateWindow(
+            usedPercent: 20,
+            windowMinutes: 10080,
+            resetsAt: resetsAt,
+            resetDescription: nil)
+
+        let pace = try #require(UsagePace.weekly(
+            window: window,
+            now: now,
+            workDays: 5,
+            calendar: calendar))
+
+        #expect(pace.willLastToReset == false)
+        #expect(abs((pace.etaSeconds ?? 0) - (48 * 3600)) < 1)
+    }
+
+    @Test
+    func `workday aware eta maps work time across a weekend`() throws {
+        let calendar = Self.utcCalendar
+        let resetsAt = try Self.date(
+            year: 2026,
+            month: 6,
+            day: 17,
+            hour: 0,
+            calendar: calendar)
+        let now = try Self.date(
+            year: 2026,
+            month: 6,
+            day: 12,
+            hour: 12,
+            calendar: calendar)
+        let window = RateWindow(
+            usedPercent: 60,
+            windowMinutes: 10080,
+            resetsAt: resetsAt,
+            resetDescription: nil)
+
+        let pace = try #require(UsagePace.weekly(
+            window: window,
+            now: now,
+            workDays: 5,
+            calendar: calendar))
+
+        // 40 work hours remain at the observed rate: 12 hours Friday, all Monday, then 4 hours Tuesday.
+        #expect(pace.willLastToReset == false)
+        #expect(abs((pace.etaSeconds ?? 0) - (88 * 3600)) < 1)
+    }
+
+    @Test
+    func `workday aware pace stays flat on non workdays`() throws {
+        let calendar = Self.utcCalendar
+        let resetsAt = try Self.date(
+            year: 2026,
+            month: 6,
+            day: 17,
+            hour: 0,
+            calendar: calendar)
+        let saturday = try Self.date(
+            year: 2026,
+            month: 6,
+            day: 13,
+            hour: 12,
+            calendar: calendar)
+        let sunday = try Self.date(
+            year: 2026,
+            month: 6,
+            day: 14,
+            hour: 12,
+            calendar: calendar)
+        let window = RateWindow(
+            usedPercent: 60,
+            windowMinutes: 10080,
+            resetsAt: resetsAt,
+            resetDescription: nil)
+
+        let saturdayPace = try #require(UsagePace.weekly(
+            window: window,
+            now: saturday,
+            workDays: 5,
+            calendar: calendar))
+        let sundayPace = try #require(UsagePace.weekly(
+            window: window,
+            now: sunday,
+            workDays: 5,
+            calendar: calendar))
+
+        #expect(abs(saturdayPace.expectedUsedPercent - 60) < 0.01)
+        #expect(sundayPace.expectedUsedPercent == saturdayPace.expectedUsedPercent)
+    }
+
+    @Test
+    func `zero usage becomes safe only after the first configured workday begins`() throws {
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = try #require(TimeZone(identifier: "America/Los_Angeles"))
+        let resetsAt = try Self.date(
+            year: 2026,
+            month: 6,
+            day: 14,
+            hour: 0,
+            calendar: calendar)
+        let firstWorkday = try Self.date(
+            year: 2026,
+            month: 6,
+            day: 8,
+            hour: 0,
+            calendar: calendar)
+        let window = RateWindow(
+            usedPercent: 0,
+            windowMinutes: 10080,
+            resetsAt: resetsAt,
+            resetDescription: nil)
+
+        let before = try #require(UsagePace.weekly(
+            window: window,
+            now: firstWorkday.addingTimeInterval(-1),
+            workDays: 5,
+            calendar: calendar))
+        let boundary = try #require(UsagePace.weekly(
+            window: window,
+            now: firstWorkday,
+            workDays: 5,
+            calendar: calendar))
+        let after = try #require(UsagePace.weekly(
+            window: window,
+            now: firstWorkday.addingTimeInterval(3600),
+            workDays: 5,
+            calendar: calendar))
+
+        #expect(before.expectedUsedPercent == 0)
+        #expect(before.willLastToReset == false)
+        #expect(boundary.expectedUsedPercent == 0)
+        #expect(boundary.willLastToReset == false)
+        #expect(after.expectedUsedPercent > 0)
+        #expect(after.willLastToReset == true)
+    }
+
+    @Test
+    func `workday aware pace does not declare zero usage safe before first workday`() throws {
+        let calendar = Self.utcCalendar
+
+        let resetsAt = try #require(calendar.date(from: DateComponents(
+            calendar: calendar,
+            timeZone: calendar.timeZone,
+            year: 2026,
+            month: 6,
+            day: 14)))
+        let now = try #require(calendar.date(from: DateComponents(
+            calendar: calendar,
+            timeZone: calendar.timeZone,
+            year: 2026,
+            month: 6,
+            day: 7,
+            hour: 12)))
+        let window = RateWindow(
+            usedPercent: 0,
+            windowMinutes: 10080,
+            resetsAt: resetsAt,
+            resetDescription: nil)
+
+        let pace = try #require(UsagePace.weekly(
+            window: window,
+            now: now,
+            workDays: 5,
+            calendar: calendar))
+
+        #expect(pace.expectedUsedPercent == 0)
+        #expect(pace.willLastToReset == false)
+        #expect(pace.etaSeconds == nil)
+    }
+
+    @Test
+    func `workday aware exhausted quota stays exhausted before first workday`() throws {
+        let calendar = Self.utcCalendar
+
+        let resetsAt = try #require(calendar.date(from: DateComponents(
+            calendar: calendar,
+            timeZone: calendar.timeZone,
+            year: 2026,
+            month: 6,
+            day: 14)))
+        let now = try #require(calendar.date(from: DateComponents(
+            calendar: calendar,
+            timeZone: calendar.timeZone,
+            year: 2026,
+            month: 6,
+            day: 7,
+            hour: 12)))
+        let window = RateWindow(
+            usedPercent: 100,
+            windowMinutes: 10080,
+            resetsAt: resetsAt,
+            resetDescription: nil)
+
+        let pace = try #require(UsagePace.weekly(
+            window: window,
+            now: now,
+            workDays: 5,
+            calendar: calendar))
+
+        #expect(pace.willLastToReset == false)
+        #expect(pace.etaSeconds == 0)
+    }
+
+    @Test
+    func `workday aware pace splits a non midnight reset at local day boundaries`() throws {
+        let calendar = Self.utcCalendar
+
+        let resetsAt = try #require(calendar.date(from: DateComponents(
+            calendar: calendar,
+            timeZone: calendar.timeZone,
+            year: 2026,
+            month: 6,
+            day: 14,
+            hour: 20)))
+        let now = try #require(calendar.date(from: DateComponents(
+            calendar: calendar,
+            timeZone: calendar.timeZone,
+            year: 2026,
+            month: 6,
+            day: 8,
+            hour: 12)))
+        let window = RateWindow(
+            usedPercent: 10,
+            windowMinutes: 10080,
+            resetsAt: resetsAt,
+            resetDescription: nil)
+
+        let pace = try #require(UsagePace.weekly(
+            window: window,
+            now: now,
+            workDays: 5,
+            calendar: calendar))
+
+        // The weekly window starts Sunday at 20:00. Monday 00:00-12:00 is 12 of
+        // the week's 120 work hours, so it must contribute 10% despite the reset offset.
+        #expect(abs(pace.expectedUsedPercent - 10) < 0.01)
+        #expect(abs(pace.deltaPercent) < 0.01)
+    }
+
+    @Test
+    func `workday aware pace falls back to linear when workDays is nil or 7`() throws {
+        let now = Date(timeIntervalSince1970: 0)
+        let window = RateWindow(
+            usedPercent: 50,
+            windowMinutes: 10080,
+            resetsAt: now.addingTimeInterval(4 * 24 * 3600),
+            resetDescription: nil)
+
+        let paceNil = try #require(UsagePace.weekly(window: window, now: now, workDays: nil))
+        let pace7 = try #require(UsagePace.weekly(window: window, now: now, workDays: 7))
+        let paceDefault = try #require(UsagePace.weekly(window: window, now: now))
+
+        // All should produce identical expected values (linear)
+        #expect(abs(paceNil.expectedUsedPercent - paceDefault.expectedUsedPercent) < 0.01)
+        #expect(abs(pace7.expectedUsedPercent - paceDefault.expectedUsedPercent) < 0.01)
+    }
+
+    @Test
+    func `workdays off linear weekly pace keeps deficit sign`() throws {
+        let now = Date(timeIntervalSince1970: 0)
+        let window = RateWindow(
+            usedPercent: 88,
+            windowMinutes: 10080,
+            resetsAt: now.addingTimeInterval(2 * 24 * 3600 + 19 * 3600),
+            resetDescription: nil)
+
+        let pace = try #require(UsagePace.weekly(window: window, now: now, workDays: nil))
+
+        #expect(abs(pace.expectedUsedPercent - (101.0 / 168.0 * 100.0)) < 0.01)
+        #expect(pace.deltaPercent > 25)
+        #expect(pace.stage == .farAhead)
+        #expect(pace.willLastToReset == false)
+    }
+
+    @Test
+    func `workday aware pace ignores non weekly windows`() throws {
+        let now = Date(timeIntervalSince1970: 0)
+        // 300-minute session window — workDays should have no effect
+        let window = RateWindow(
+            usedPercent: 50,
+            windowMinutes: 300,
+            resetsAt: now.addingTimeInterval(2 * 3600),
+            resetDescription: nil)
+
+        let paceNoWork = try #require(
+            UsagePace.weekly(window: window, now: now, defaultWindowMinutes: 300, workDays: nil))
+        let paceWork5 = try #require(
+            UsagePace.weekly(window: window, now: now, defaultWindowMinutes: 300, workDays: 5))
+
+        #expect(abs(paceNoWork.expectedUsedPercent - paceWork5.expectedUsedPercent) < 0.01)
+    }
+
+    @Test
+    func `session pace computes delta and eta for five hour window`() {
+        let now = Date(timeIntervalSince1970: 0)
+        let window = RateWindow(
+            usedPercent: 50,
+            windowMinutes: 300,
+            resetsAt: now.addingTimeInterval(2 * 3600),
+            resetDescription: nil)
+
+        let pace = UsagePace.weekly(window: window, now: now, defaultWindowMinutes: 300)
+
+        #expect(pace != nil)
+        guard let pace else { return }
+        #expect(abs(pace.expectedUsedPercent - 60.0) < 0.01)
+        #expect(abs(pace.deltaPercent - -10.0) < 0.01)
+        #expect(pace.stage == .behind)
+        #expect(pace.willLastToReset == true)
+    }
+
+    @Test
+    func `one work day falls back to linear pace`() throws {
+        let now = Date(timeIntervalSince1970: 0)
+        let window = RateWindow(
+            usedPercent: 50,
+            windowMinutes: 10080,
+            resetsAt: now.addingTimeInterval(4 * 24 * 3600),
+            resetDescription: nil)
+
+        let paceOne = try #require(UsagePace.weekly(window: window, now: now, workDays: 1))
+        let paceNil = try #require(UsagePace.weekly(window: window, now: now))
+
+        // workDays == 1 should fall back to linear pace, identical to workDays: nil
+        #expect(abs(paceOne.expectedUsedPercent - paceNil.expectedUsedPercent) < 0.01)
+    }
+
+    private static var utcCalendar: Calendar {
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = TimeZone(secondsFromGMT: 0)!
+        return calendar
+    }
+
+    private static func date(
+        year: Int,
+        month: Int,
+        day: Int,
+        hour: Int,
+        minute: Int = 0,
+        calendar: Calendar) throws -> Date
+    {
+        try #require(calendar.date(from: DateComponents(
+            calendar: calendar,
+            timeZone: calendar.timeZone,
+            year: year,
+            month: month,
+            day: day,
+            hour: hour,
+            minute: minute)))
+    }
 }
diff --git a/Tests/CodexBarTests/UsagePaceTextTests.swift b/Tests/CodexBarTests/UsagePaceTextTests.swift
index 6f6fddac3d..8eec85007b 100644
--- a/Tests/CodexBarTests/UsagePaceTextTests.swift
+++ b/Tests/CodexBarTests/UsagePaceTextTests.swift
@@ -3,10 +3,24 @@ import Foundation
 import Testing
 @testable import CodexBar
 
-@Suite
 struct UsagePaceTextTests {
+    private static let localizedKeys: [String] = [
+        "Pace: %@",
+        "Pace: %@ · %@",
+        "On pace",
+        "%d%% in deficit",
+        "%d%% in reserve",
+        "Lasts until reset",
+        "Projected empty now",
+        "Projected empty in %@",
+        "Runs out now",
+        "Runs out in %@",
+        "≈ %d%% run-out risk",
+        "%@ · %@",
+    ]
+
     @Test
-    func weeklyPaceDetail_providesLeftRightLabels() throws {
+    func `weekly pace detail provides left right labels`() throws {
         let now = Date(timeIntervalSince1970: 0)
         let window = RateWindow(
             usedPercent: 50,
@@ -22,7 +36,7 @@ struct UsagePaceTextTests {
     }
 
     @Test
-    func weeklyPaceDetail_reportsLastsUntilReset() throws {
+    func `weekly pace detail reports lasts until reset`() throws {
         let now = Date(timeIntervalSince1970: 0)
         let window = RateWindow(
             usedPercent: 10,
@@ -38,7 +52,7 @@ struct UsagePaceTextTests {
     }
 
     @Test
-    func weeklyPaceSummary_formatsSingleLineText() throws {
+    func `weekly pace summary formats single line text`() throws {
         let now = Date(timeIntervalSince1970: 0)
         let window = RateWindow(
             usedPercent: 50,
@@ -53,7 +67,24 @@ struct UsagePaceTextTests {
     }
 
     @Test
-    func weeklyPaceDetail_formatsRoundedRiskWhenAvailable() {
+    func `reported weekly state renders deficit and run out headline`() throws {
+        let now = Date(timeIntervalSince1970: 0)
+        let window = RateWindow(
+            usedPercent: 88,
+            windowMinutes: 10080,
+            resetsAt: now.addingTimeInterval((2 * 24 + 19) * 3600),
+            resetDescription: nil)
+        let pace = try #require(UsagePace.weekly(window: window, now: now, workDays: nil))
+
+        let detail = UsagePaceText.weeklyDetail(pace: pace, now: now)
+
+        #expect(detail.leftLabel == "28% in deficit")
+        #expect(detail.rightLabel == "Runs out in 13h 47m")
+        #expect(detail.rightLabel?.contains("Lasts until reset") == false)
+    }
+
+    @Test
+    func `weekly pace detail formats rounded risk when available`() {
         let now = Date(timeIntervalSince1970: 0)
         let pace = UsagePace(
             stage: .ahead,
@@ -68,4 +99,208 @@ struct UsagePaceTextTests {
 
         #expect(detail.rightLabel == "Runs out in 2d · ≈ 70% run-out risk")
     }
+
+    @Test
+    func `weekly pace detail does not combine lasts until reset with run out risk`() {
+        let now = Date(timeIntervalSince1970: 0)
+        let pace = UsagePace(
+            stage: .slightlyBehind,
+            deltaPercent: -9,
+            expectedUsedPercent: 21,
+            actualUsedPercent: 12,
+            etaSeconds: nil,
+            willLastToReset: true,
+            runOutProbability: 0.45)
+
+        let detail = UsagePaceText.weeklyDetail(pace: pace, now: now)
+
+        #expect(detail.leftLabel == "9% in reserve")
+        #expect(detail.rightLabel == "≈ 45% run-out risk")
+    }
+
+    @Test
+    func `weekly pace detail keeps lasts until reset only when rounded risk is zero`() {
+        let now = Date(timeIntervalSince1970: 0)
+        let pace = UsagePace(
+            stage: .farBehind,
+            deltaPercent: -30,
+            expectedUsedPercent: 40,
+            actualUsedPercent: 10,
+            etaSeconds: nil,
+            willLastToReset: true,
+            runOutProbability: 0.02)
+
+        let detail = UsagePaceText.weeklyDetail(pace: pace, now: now)
+
+        #expect(detail.rightLabel == "Lasts until reset · ≈ 0% run-out risk")
+    }
+
+    @Test
+    func `weekly pace detail prefers risk over lasts until reset when rounded risk is material`() {
+        let now = Date(timeIntervalSince1970: 0)
+        let pace = UsagePace(
+            stage: .slightlyBehind,
+            deltaPercent: -9,
+            expectedUsedPercent: 21,
+            actualUsedPercent: 12,
+            etaSeconds: nil,
+            willLastToReset: true,
+            runOutProbability: 0.03)
+
+        let detail = UsagePaceText.weeklyDetail(pace: pace, now: now)
+
+        #expect(detail.rightLabel == "≈ 5% run-out risk")
+    }
+
+    // MARK: - Session pace (5-hour window)
+
+    @Test
+    func `session pace detail provides left right labels`() {
+        let now = Date(timeIntervalSince1970: 0)
+        // 300-minute window, 2h remaining => 3h elapsed out of 5h
+        // expected = 60%, actual = 80% => 20% ahead (in deficit)
+        let window = RateWindow(
+            usedPercent: 80,
+            windowMinutes: 300,
+            resetsAt: now.addingTimeInterval(2 * 3600),
+            resetDescription: nil)
+
+        let detail = UsagePaceText.sessionDetail(provider: .claude, window: window, now: now)
+
+        #expect(detail != nil)
+        #expect(detail?.leftLabel == "20% in deficit")
+        #expect(detail?.rightLabel == "Projected empty in 45m")
+        #expect(detail?.stage == .farAhead)
+    }
+
+    @Test
+    func `session pace detail reports lasts until reset`() {
+        let now = Date(timeIntervalSince1970: 0)
+        // 300-minute window, 2h remaining => 3h elapsed
+        // expected = 60%, actual = 10% => far behind (in reserve)
+        let window = RateWindow(
+            usedPercent: 10,
+            windowMinutes: 300,
+            resetsAt: now.addingTimeInterval(2 * 3600),
+            resetDescription: nil)
+
+        let detail = UsagePaceText.sessionDetail(provider: .claude, window: window, now: now)
+
+        #expect(detail != nil)
+        #expect(detail?.leftLabel == "50% in reserve")
+        #expect(detail?.rightLabel == "Lasts until reset")
+    }
+
+    @Test
+    func `session pace summary formats single line text`() {
+        let now = Date(timeIntervalSince1970: 0)
+        let window = RateWindow(
+            usedPercent: 80,
+            windowMinutes: 300,
+            resetsAt: now.addingTimeInterval(2 * 3600),
+            resetDescription: nil)
+
+        let summary = UsagePaceText.sessionSummary(provider: .claude, window: window, now: now)
+
+        #expect(summary == "Pace: 20% in deficit · Projected empty in 45m")
+    }
+
+    @Test
+    func `session pace detail supports Ollama five hour window`() {
+        let now = Date(timeIntervalSince1970: 0)
+        let window = RateWindow(
+            usedPercent: 80,
+            windowMinutes: 300,
+            resetsAt: now.addingTimeInterval(2 * 3600),
+            resetDescription: nil)
+
+        let detail = UsagePaceText.sessionDetail(provider: .ollama, window: window, now: now)
+
+        #expect(detail?.leftLabel == "20% in deficit")
+        #expect(detail?.rightLabel == "Projected empty in 45m")
+    }
+
+    @Test
+    func `session pace detail hides Ollama window without explicit duration`() {
+        let now = Date(timeIntervalSince1970: 0)
+        let window = RateWindow(
+            usedPercent: 80,
+            windowMinutes: nil,
+            resetsAt: now.addingTimeInterval(2 * 3600),
+            resetDescription: nil)
+
+        let detail = UsagePaceText.sessionDetail(provider: .ollama, window: window, now: now)
+
+        #expect(detail == nil)
+    }
+
+    @Test
+    func `session pace detail hides for unsupported provider`() {
+        let now = Date(timeIntervalSince1970: 0)
+        let window = RateWindow(
+            usedPercent: 50,
+            windowMinutes: 300,
+            resetsAt: now.addingTimeInterval(2 * 3600),
+            resetDescription: nil)
+
+        let detail = UsagePaceText.sessionDetail(provider: .zai, window: window, now: now)
+
+        #expect(detail == nil)
+    }
+
+    @Test
+    func `session pace detail hides when reset is missing`() {
+        let now = Date(timeIntervalSince1970: 0)
+        let window = RateWindow(
+            usedPercent: 50,
+            windowMinutes: 300,
+            resetsAt: nil,
+            resetDescription: nil)
+
+        let detail = UsagePaceText.sessionDetail(provider: .claude, window: window, now: now)
+
+        #expect(detail == nil)
+    }
+
+    @Test
+    func `usage pace text localization keys exist in en and zh Hans with matching placeholders`() throws {
+        let root = URL(fileURLWithPath: #filePath)
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+
+        let enURL = root.appendingPathComponent("Sources/CodexBar/Resources/en.lproj/Localizable.strings")
+        let zhURL = root.appendingPathComponent("Sources/CodexBar/Resources/zh-Hans.lproj/Localizable.strings")
+
+        let en = try Self.readStringsTable(at: enURL)
+        let zh = try Self.readStringsTable(at: zhURL)
+
+        for key in Self.localizedKeys {
+            let enValue = try #require(en[key], "Missing en key: \(key)")
+            let zhValue = try #require(zh[key], "Missing zh-Hans key: \(key)")
+            #expect(
+                Self.placeholderTokens(in: enValue) == Self.placeholderTokens(in: zhValue),
+                "Placeholder mismatch for key '\(key)': en='\(enValue)' zh='\(zhValue)'")
+        }
+    }
+
+    private static func readStringsTable(at url: URL) throws -> [String: String] {
+        guard let dict = NSDictionary(contentsOf: url) as? [String: String] else {
+            throw NSError(
+                domain: "UsagePaceTextTests",
+                code: 1,
+                userInfo: [NSLocalizedDescriptionKey: "Failed to parse strings file at \(url.path)"])
+        }
+        return dict
+    }
+
+    private static func placeholderTokens(in value: String) -> [String] {
+        guard let regex = try? NSRegularExpression(pattern: "%(?:\\d+\\$)?[@dDuUxXfFeEgGcCsSpaA]") else {
+            return []
+        }
+        let nsRange = NSRange(value.startIndex..<value.endIndex, in: value)
+        return regex
+            .matches(in: value, options: [], range: nsRange)
+            .compactMap { Range($0.range, in: value).map { String(value[$0]) } }
+    }
 }
diff --git a/Tests/CodexBarTests/UsageStoreCachedTokenHydrationTests.swift b/Tests/CodexBarTests/UsageStoreCachedTokenHydrationTests.swift
new file mode 100644
index 0000000000..5b0fb6590e
--- /dev/null
+++ b/Tests/CodexBarTests/UsageStoreCachedTokenHydrationTests.swift
@@ -0,0 +1,166 @@
+import Foundation
+import Testing
+@testable import CodexBar
+@testable import CodexBarCore
+
+@MainActor
+@Suite(.serialized)
+struct UsageStoreCachedTokenHydrationTests {
+    @Test
+    func `cached codex token hydration populates startup token snapshot`() async throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 4, day: 8)
+        try Self.writeCodexSessionFile(
+            homeRoot: env.codexHomeRoot,
+            env: env,
+            day: day,
+            filename: "cached.jsonl",
+            tokens: 42)
+
+        let options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            cacheRoot: env.cacheRoot)
+        _ = try await CostUsageFetcher.loadTokenSnapshot(
+            provider: .codex,
+            now: day,
+            historyDays: 1,
+            scannerOptions: options)
+
+        let settings = Self.makeCodexOnlySettings(historyDays: 1)
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            costUsageFetcher: CostUsageFetcher(scannerOptions: options),
+            settings: settings,
+            startupBehavior: .testing,
+            environmentBase: [:])
+
+        store.hydrateCachedTokenSnapshots(now: day)
+
+        for _ in 0..<100 where store.tokenSnapshot(for: .codex) == nil {
+            try await Task.sleep(for: .milliseconds(10))
+        }
+
+        #expect(store.tokenSnapshot(for: .codex)?.sessionTokens == 42)
+        #expect(store.tokenSnapshot(for: .codex)?.daily.map(\.date) == ["2026-04-08"])
+        #expect(store.tokenError(for: .codex) == nil)
+    }
+
+    @Test
+    func `cached codex token hydration skips managed codex homes`() async throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 4, day: 8)
+        try Self.writeCodexSessionFile(
+            homeRoot: env.codexHomeRoot,
+            env: env,
+            day: day,
+            filename: "cached.jsonl",
+            tokens: 42)
+
+        let options = CostUsageScanner.Options(
+            codexSessionsRoot: env.codexSessionsRoot,
+            cacheRoot: env.cacheRoot)
+        _ = try await CostUsageFetcher.loadTokenSnapshot(
+            provider: .codex,
+            now: day,
+            historyDays: 1,
+            scannerOptions: options)
+
+        let settings = Self.makeCodexOnlySettings(historyDays: 1)
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: env.codexHomeRoot.path,
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        settings._test_activeManagedCodexAccount = managedAccount
+        settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+        defer { settings._test_activeManagedCodexAccount = nil }
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            costUsageFetcher: CostUsageFetcher(scannerOptions: options),
+            settings: settings,
+            startupBehavior: .testing,
+            environmentBase: [:])
+
+        store.hydrateCachedTokenSnapshots(now: day)
+
+        for _ in 0..<20 {
+            try await Task.sleep(for: .milliseconds(10))
+        }
+
+        #expect(store.tokenSnapshot(for: .codex) == nil)
+    }
+
+    private static func makeCodexOnlySettings(historyDays: Int) -> SettingsStore {
+        let suite = "UsageStoreCachedTokenHydrationTests-\(UUID().uuidString)"
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.costUsageEnabled = true
+        settings.costUsageHistoryDays = historyDays
+        settings.openAIWebAccessEnabled = false
+        settings.codexCookieSource = .off
+        settings.providerDetectionCompleted = true
+
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: provider == .codex)
+        }
+        return settings
+    }
+
+    private static func writeCodexSessionFile(
+        homeRoot: URL,
+        env: CostUsageTestEnvironment,
+        day: Date,
+        filename: String,
+        tokens: Int) throws
+    {
+        let comps = Calendar.current.dateComponents([.year, .month, .day], from: day)
+        let dir = homeRoot
+            .appendingPathComponent("sessions", isDirectory: true)
+            .appendingPathComponent(String(format: "%04d", comps.year ?? 1970), isDirectory: true)
+            .appendingPathComponent(String(format: "%02d", comps.month ?? 1), isDirectory: true)
+            .appendingPathComponent(String(format: "%02d", comps.day ?? 1), isDirectory: true)
+        try FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+
+        let model = "openai/gpt-5.4"
+        let url = dir.appendingPathComponent(filename, isDirectory: false)
+        try env.jsonl([
+            [
+                "type": "turn_context",
+                "timestamp": env.isoString(for: day),
+                "payload": ["model": model],
+            ],
+            [
+                "type": "event_msg",
+                "timestamp": env.isoString(for: day.addingTimeInterval(1)),
+                "payload": [
+                    "type": "token_count",
+                    "info": [
+                        "last_token_usage": [
+                            "input_tokens": tokens,
+                            "cached_input_tokens": 0,
+                            "output_tokens": 0,
+                        ],
+                        "model": model,
+                    ],
+                ],
+            ],
+        ]).write(to: url, atomically: true, encoding: .utf8)
+    }
+}
diff --git a/Tests/CodexBarTests/UsageStoreCoverageTests.swift b/Tests/CodexBarTests/UsageStoreCoverageTests.swift
index 037a7180cb..680aab05af 100644
--- a/Tests/CodexBarTests/UsageStoreCoverageTests.swift
+++ b/Tests/CodexBarTests/UsageStoreCoverageTests.swift
@@ -1,13 +1,30 @@
 import CodexBarCore
 import Foundation
+import Observation
 import Testing
 @testable import CodexBar
 
 @MainActor
-@Suite
 struct UsageStoreCoverageTests {
+    private final class ObservationFlag: @unchecked Sendable {
+        private let lock = NSLock()
+        private var value = false
+
+        func set() {
+            self.lock.lock()
+            self.value = true
+            self.lock.unlock()
+        }
+
+        func get() -> Bool {
+            self.lock.lock()
+            defer { self.lock.unlock() }
+            return self.value
+        }
+    }
+
     @Test
-    func providerWithHighestUsageAndIconStyle() throws {
+    func `provider with highest usage and icon style`() throws {
         let settings = Self.makeSettingsStore(suite: "UsageStoreCoverageTests-highest")
         let store = Self.makeUsageStore(settings: settings)
         let metadata = ProviderRegistry.shared.metadata
@@ -50,7 +67,7 @@ struct UsageStoreCoverageTests {
     }
 
     @Test
-    func sourceLabelAddsOpenAIWeb() {
+    func `source label adds open AI web`() {
         let settings = Self.makeSettingsStore(suite: "UsageStoreCoverageTests-source")
         settings.debugDisableKeychainAccess = false
         settings.codexUsageDataSource = .oauth
@@ -72,7 +89,66 @@ struct UsageStoreCoverageTests {
     }
 
     @Test
-    func sourceLabelUsesConfiguredKiloSource() {
+    func `amp balances are rendered in provider cards`() {
+        let settings = Self.makeSettingsStore(suite: "UsageStoreCoverageTests-amp-credits")
+        let store = Self.makeUsageStore(settings: settings)
+        let now = Date()
+
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(
+                    usedPercent: 51.4,
+                    windowMinutes: 1440,
+                    resetsAt: now.addingTimeInterval(12 * 3600),
+                    resetDescription: nil),
+                secondary: nil,
+                ampUsage: AmpUsageDetails(
+                    individualCredits: 25.64,
+                    workspaceBalances: [AmpWorkspaceBalance(name: "billing@example.test", remaining: 10.22)]),
+                updatedAt: now),
+            provider: .amp)
+        let model = ProvidersPane(settings: settings, store: store)._test_menuCardModel(for: .amp)
+
+        #expect(model.creditsText == "Individual credits: $25.64\nWorkspace billing@example.test: $10.22")
+        #expect(model.creditsRemaining == nil)
+
+        settings.hidePersonalInfo = true
+        let redactedModel = ProvidersPane(settings: settings, store: store)._test_menuCardModel(for: .amp)
+        #expect(redactedModel.creditsText == "Individual credits: $25.64\nWorkspace Hidden: $10.22")
+    }
+
+    @Test
+    func `account info caches codex auth parsing until config revision changes`() throws {
+        let settings = Self.makeSettingsStore(suite: "UsageStoreCoverageTests-account-info-cache")
+        let home = FileManager.default.temporaryDirectory.appendingPathComponent(
+            "usage-store-account-info-\(UUID().uuidString)",
+            isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: home) }
+
+        try Self.writeCodexAuthFile(homeURL: home, email: "first@example.com", plan: "plus")
+        let env = ["CODEX_HOME": home.path]
+        settings._test_codexReconciliationEnvironment = env
+        defer { settings._test_codexReconciliationEnvironment = nil }
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: env),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing,
+            environmentBase: env)
+
+        let first = store.accountInfo(for: .codex)
+        try Self.writeCodexAuthFile(homeURL: home, email: "second@example.com", plan: "pro")
+        let cached = store.accountInfo(for: .codex)
+        settings.configRevision &+= 1
+        let refreshed = store.accountInfo(for: .codex)
+
+        #expect(first.email == "first@example.com")
+        #expect(cached.email == "first@example.com")
+        #expect(refreshed.email == "second@example.com")
+    }
+
+    @Test
+    func `source label uses configured kilo source`() {
         let settings = Self.makeSettingsStore(suite: "UsageStoreCoverageTests-kilo-source")
         settings.kiloUsageDataSource = .api
 
@@ -81,7 +157,55 @@ struct UsageStoreCoverageTests {
     }
 
     @Test
-    func providerWithHighestUsagePrefersKimiRateLimitWindow() throws {
+    func `clearing copilot budget extras syncs reset baseline`() {
+        let settings = Self.makeSettingsStore(suite: "UsageStoreCoverageTests-copilot-budget-clear")
+        let store = Self.makeUsageStore(settings: settings)
+        let live = Self.makeCopilotSnapshot(usedPercent: 20, extraRateWindows: [Self.makeCopilotBudgetWindow()])
+        let resetBaseline = Self.makeCopilotSnapshot(usedPercent: 10, extraRateWindows: nil)
+        store._setSnapshotForTesting(live, provider: .copilot)
+        store.lastKnownResetSnapshots[.copilot] = resetBaseline
+
+        store.clearCopilotBudgetExtras()
+
+        #expect(store.snapshot(for: .copilot)?.extraRateWindows == nil)
+        #expect(store.lastKnownResetSnapshots[.copilot]?.extraRateWindows == nil)
+        #expect(store.lastKnownResetSnapshots[.copilot]?.primary?.usedPercent == 20)
+    }
+
+    @Test
+    func `clearing copilot budget extras also clears stale reset baseline`() {
+        let settings = Self.makeSettingsStore(suite: "UsageStoreCoverageTests-copilot-budget-reset-clear")
+        let store = Self.makeUsageStore(settings: settings)
+        let live = Self.makeCopilotSnapshot(usedPercent: 20, extraRateWindows: nil)
+        let resetBaseline = Self.makeCopilotSnapshot(
+            usedPercent: 10,
+            extraRateWindows: [Self.makeCopilotBudgetWindow()])
+        store._setSnapshotForTesting(live, provider: .copilot)
+        store.lastKnownResetSnapshots[.copilot] = resetBaseline
+
+        store.clearCopilotBudgetExtras()
+
+        #expect(store.snapshot(for: .copilot)?.extraRateWindows == nil)
+        #expect(store.snapshot(for: .copilot)?.primary?.usedPercent == 20)
+        #expect(store.lastKnownResetSnapshots[.copilot]?.extraRateWindows == nil)
+        #expect(store.lastKnownResetSnapshots[.copilot]?.primary?.usedPercent == 10)
+    }
+
+    @Test
+    func `permission prompt errors are detected for notifications`() {
+        let errors: [LocalizedTestError] = [
+            LocalizedTestError("Waiting for folder trust prompt"),
+            LocalizedTestError("Permission prompt is waiting in the CLI"),
+        ]
+
+        for error in errors {
+            #expect(UsageStore.isPermissionPromptWaiting(error))
+        }
+        #expect(!UsageStore.isPermissionPromptWaiting(LocalizedTestError("network timeout")))
+    }
+
+    @Test
+    func `provider with highest usage prefers kimi rate limit window`() throws {
         let settings = Self.makeSettingsStore(suite: "UsageStoreCoverageTests-kimi-highest")
         let store = Self.makeUsageStore(settings: settings)
         let metadata = ProviderRegistry.shared.metadata
@@ -109,7 +233,7 @@ struct UsageStoreCoverageTests {
     }
 
     @Test
-    func providerAvailabilityAndSubscriptionDetection() {
+    func `provider availability and subscription detection`() {
         let zaiStore = InMemoryZaiTokenStore(value: "zai-token")
         let syntheticStore = InMemorySyntheticTokenStore(value: "synthetic-token")
         let settings = Self.makeSettingsStore(
@@ -135,10 +259,288 @@ struct UsageStoreCoverageTests {
     }
 
     @Test
-    func statusIndicatorsAndFailureGate() {
+    func `background refresh only tracks enabled providers`() throws {
+        let settings = Self.makeSettingsStore(suite: "UsageStoreCoverageTests-background-refresh")
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+
+        let metadata = ProviderRegistry.shared.metadata
+        for provider in UsageProvider.allCases {
+            try settings.setProviderEnabled(
+                provider: provider,
+                metadata: #require(metadata[provider]),
+                enabled: false)
+        }
+        try settings.setProviderEnabled(provider: .codex, metadata: #require(metadata[.codex]), enabled: true)
+
+        let store = Self.makeUsageStore(settings: settings)
+        let staleSnapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 25, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())
+        store._setSnapshotForTesting(staleSnapshot, provider: .claude)
+        store._setErrorForTesting("stale", provider: .claude)
+        store.statuses[.claude] = ProviderStatus(indicator: .major, description: "Outage", updatedAt: Date())
+
+        #expect(store.enabledProviders() == [.codex])
+
+        store.clearDisabledProviderState(enabledProviders: Set(store.enabledProvidersForDisplay()))
+
+        #expect(store.snapshot(for: .claude) == nil)
+        #expect(store.errors[.claude] == nil)
+        #expect(store.statuses[.claude] == nil)
+    }
+
+    @Test
+    func `cleanup preserves enabled but unavailable provider state`() throws {
+        let settings = Self.makeSettingsStore(suite: "UsageStoreCoverageTests-preserve-unavailable")
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+
+        let metadata = ProviderRegistry.shared.metadata
+        for provider in UsageProvider.allCases {
+            try settings.setProviderEnabled(
+                provider: provider,
+                metadata: #require(metadata[provider]),
+                enabled: false)
+        }
+        try settings.setProviderEnabled(
+            provider: .synthetic,
+            metadata: #require(metadata[.synthetic]),
+            enabled: true)
+
+        let store = Self.makeUsageStore(settings: settings)
+        let staleSnapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 25, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())
+        store._setSnapshotForTesting(staleSnapshot, provider: .synthetic)
+        store._setErrorForTesting("stale", provider: .synthetic)
+        store.statuses[.synthetic] = ProviderStatus(indicator: .major, description: "Outage", updatedAt: Date())
+
+        #expect(store.enabledProviders().isEmpty)
+        #expect(store.enabledProvidersForDisplay() == [.synthetic])
+
+        store.clearDisabledProviderState(enabledProviders: Set(store.enabledProvidersForDisplay()))
+
+        #expect(store.snapshot(for: .synthetic) != nil)
+        #expect(store.errors[.synthetic] == "stale")
+        #expect(store.statuses[.synthetic]?.indicator == .major)
+    }
+
+    @Test
+    func `background work excludes enabled but unavailable providers`() throws {
+        let settings = Self.makeSettingsStore(suite: "UsageStoreCoverageTests-background-unavailable")
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+
+        let metadata = ProviderRegistry.shared.metadata
+        for provider in UsageProvider.allCases {
+            try settings.setProviderEnabled(
+                provider: provider,
+                metadata: #require(metadata[provider]),
+                enabled: false)
+        }
+        try settings.setProviderEnabled(
+            provider: .synthetic,
+            metadata: #require(metadata[.synthetic]),
+            enabled: true)
+
+        let store = Self.makeUsageStore(settings: settings)
+
+        #expect(store.enabledProvidersForDisplay() == [.synthetic])
+        #expect(store.enabledProviders().isEmpty)
+        #expect(store.enabledProvidersForBackgroundWork().isEmpty)
+    }
+
+    @Test
+    func `visible unavailable provider gets explicit user facing state`() throws {
+        let settings = Self.makeSettingsStore(suite: "UsageStoreCoverageTests-unavailable-message")
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+
+        let metadata = ProviderRegistry.shared.metadata
+        for provider in UsageProvider.allCases {
+            try settings.setProviderEnabled(
+                provider: provider,
+                metadata: #require(metadata[provider]),
+                enabled: false)
+        }
+        try settings.setProviderEnabled(
+            provider: .synthetic,
+            metadata: #require(metadata[.synthetic]),
+            enabled: true)
+
+        let store = Self.makeUsageStore(settings: settings)
+
+        #expect(store.errors[.synthetic] == nil)
+        #expect(store.enabledProvidersForDisplay() == [.synthetic])
+        #expect(store.isProviderAvailable(.synthetic) == false)
+        #expect(store.userFacingError(for: .synthetic) == SyntheticSettingsError.missingToken.errorDescription)
+        #expect(store.unavailableMessage(for: .synthetic) == SyntheticSettingsError.missingToken.errorDescription)
+    }
+
+    @Test
+    func `refresh clears enabled but unavailable cached state`() async throws {
+        let settings = Self.makeSettingsStore(suite: "UsageStoreCoverageTests-background-cleanup")
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+
+        let metadata = ProviderRegistry.shared.metadata
+        for provider in UsageProvider.allCases {
+            try settings.setProviderEnabled(
+                provider: provider,
+                metadata: #require(metadata[provider]),
+                enabled: false)
+        }
+        try settings.setProviderEnabled(
+            provider: .synthetic,
+            metadata: #require(metadata[.synthetic]),
+            enabled: true)
+
+        let store = Self.makeUsageStore(settings: settings)
+        let cachedSnapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 25, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())
+        store._setSnapshotForTesting(cachedSnapshot, provider: .synthetic)
+        let account = ProviderTokenAccount(id: UUID(), label: "Account", token: "token", addedAt: 0, lastUsed: nil)
+        store.accountSnapshots[.synthetic] = [
+            TokenAccountUsageSnapshot(account: account, snapshot: cachedSnapshot, error: nil, sourceLabel: "api"),
+        ]
+        store._setTokenSnapshotForTesting(
+            CostUsageTokenSnapshot(
+                sessionTokens: 10,
+                sessionCostUSD: 1.23,
+                last30DaysTokens: 100,
+                last30DaysCostUSD: 4.56,
+                daily: [],
+                updatedAt: Date()),
+            provider: .synthetic)
+
+        #expect(store.enabledProvidersForDisplay() == [.synthetic])
+        #expect(store.enabledProviders().isEmpty)
+        #expect(store.enabledProvidersForBackgroundWork().isEmpty)
+
+        await store.refresh()
+        #expect(store.snapshot(for: .synthetic) == nil)
+        #expect((store.accountSnapshots[.synthetic] ?? []).isEmpty)
+        #expect(store.tokenSnapshots[.synthetic] == nil)
+        #expect(store.enabledProvidersForBackgroundWork().isEmpty)
+    }
+
+    @Test
+    func `refresh clears enabled but unavailable failure state`() async throws {
+        let settings = Self.makeSettingsStore(suite: "UsageStoreCoverageTests-background-failure-cleanup")
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+
+        let metadata = ProviderRegistry.shared.metadata
+        for provider in UsageProvider.allCases {
+            try settings.setProviderEnabled(
+                provider: provider,
+                metadata: #require(metadata[provider]),
+                enabled: false)
+        }
+        try settings.setProviderEnabled(
+            provider: .synthetic,
+            metadata: #require(metadata[.synthetic]),
+            enabled: true)
+
+        let store = Self.makeUsageStore(settings: settings)
+        store._setErrorForTesting("stale", provider: .synthetic)
+        store.statuses[.synthetic] = ProviderStatus(indicator: .major, description: "Outage", updatedAt: Date())
+        store.tokenErrors[.synthetic] = "token stale"
+
+        #expect(store.enabledProvidersForDisplay() == [.synthetic])
+        #expect(store.enabledProviders().isEmpty)
+        #expect(store.enabledProvidersForBackgroundWork().isEmpty)
+
+        await store.refresh()
+
+        #expect(store.errors[.synthetic] == nil)
+        #expect(store.tokenErrors[.synthetic] == nil)
+        #expect(store.statuses[.synthetic] == nil)
+        #expect(store.enabledProvidersForBackgroundWork().isEmpty)
+    }
+
+    @Test
+    func `widget snapshot projects provider derived token usage`() async throws {
+        let settings = Self.makeSettingsStore(suite: "UsageStoreCoverageTests-widget-provider-cost")
+        let store = Self.makeUsageStore(settings: settings)
+        let day = MistralDailyUsageBucket(
+            day: "2026-05-26",
+            cost: 1.2,
+            inputTokens: 10,
+            cachedTokens: 0,
+            outputTokens: 5,
+            models: [])
+        store._setSnapshotForTesting(MistralUsageSnapshot(
+            totalCost: 9,
+            currency: "eur",
+            currencySymbol: "€",
+            totalInputTokens: 10,
+            totalOutputTokens: 5,
+            totalCachedTokens: 0,
+            modelCount: 1,
+            daily: [day],
+            startDate: nil,
+            endDate: nil,
+            updatedAt: Date()).toUsageSnapshot(), provider: .mistral)
+
+        var widgetSnapshots: [WidgetSnapshot] = []
+        store._test_widgetSnapshotSaveOverride = { widgetSnapshots.append($0) }
+        defer { store._test_widgetSnapshotSaveOverride = nil }
+
+        store.persistWidgetSnapshot(reason: "provider-cost")
+        await store.widgetSnapshotPersistTask?.value
+
+        let mistralEntry = try #require(widgetSnapshots.last?.entries.first { $0.provider == .mistral })
+        #expect(mistralEntry.tokenUsage?.currencyCode == "EUR")
+        #expect(mistralEntry.tokenUsage?.sessionLabel == "Latest billing day")
+        #expect(mistralEntry.tokenUsage?.last30DaysLabel == "This month")
+        #expect(mistralEntry.tokenUsage?.last30DaysCostUSD == 9)
+    }
+
+    @Test
+    func `unavailable provider with only cached status gets single cleanup pass`() async throws {
+        let settings = Self.makeSettingsStore(suite: "UsageStoreCoverageTests-background-status-cleanup")
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = true
+
+        let metadata = ProviderRegistry.shared.metadata
+
+        for provider in UsageProvider.allCases {
+            try settings.setProviderEnabled(
+                provider: provider,
+                metadata: #require(metadata[provider]),
+                enabled: false)
+        }
+        try settings.setProviderEnabled(
+            provider: .synthetic,
+            metadata: #require(metadata[.synthetic]),
+            enabled: true)
+
+        let store = Self.makeUsageStore(settings: settings)
+        store.statuses[.synthetic] = ProviderStatus(indicator: .major, description: "Outage", updatedAt: Date())
+
+        #expect(store.enabledProvidersForDisplay() == [.synthetic])
+        #expect(store.enabledProviders().isEmpty)
+        #expect(store.enabledProvidersForBackgroundWork().isEmpty)
+
+        await store.refresh()
+
+        #expect(store.statuses[.synthetic] == nil)
+        #expect(store.enabledProvidersForBackgroundWork().isEmpty)
+    }
+
+    @Test
+    func `status indicators and failure gate`() {
         #expect(!ProviderStatusIndicator.none.hasIssue)
         #expect(ProviderStatusIndicator.maintenance.hasIssue)
-        #expect(ProviderStatusIndicator.unknown.label == "Status unknown")
+        CodexBarLocalizationOverride.$appLanguage.withValue("en") {
+            #expect(ProviderStatusIndicator.unknown.label == "Status unknown")
+        }
 
         var gate = ConsecutiveFailureGate()
         let first = gate.shouldSurfaceError(onFailureWithPriorData: true)
@@ -152,6 +554,151 @@ struct UsageStoreCoverageTests {
         #expect(gate.streak == 0)
     }
 
+    @Test
+    func `token account error message ignores cancellation`() {
+        let settings = Self.makeSettingsStore(suite: "UsageStoreCoverageTests-token-account-cancel")
+        let store = Self.makeUsageStore(settings: settings)
+
+        #expect(store.tokenAccountErrorMessage(CancellationError()) == nil)
+        #expect(store.tokenAccountErrorMessage(ProviderFetchError.noAvailableStrategy(.copilot)) != nil)
+    }
+
+    @Test
+    func `isPreservableNetworkTransportError classifies transport failures correctly`() {
+        #expect(UsageStore.isPreservableNetworkTransportError(
+            NSError(domain: NSURLErrorDomain, code: NSURLErrorCannotFindHost)))
+        #expect(UsageStore.isPreservableNetworkTransportError(
+            NSError(domain: NSURLErrorDomain, code: NSURLErrorCannotConnectToHost)))
+        #expect(UsageStore.isPreservableNetworkTransportError(
+            NSError(domain: NSURLErrorDomain, code: NSURLErrorDNSLookupFailed)))
+        #expect(UsageStore.isPreservableNetworkTransportError(
+            NSError(domain: NSURLErrorDomain, code: NSURLErrorTimedOut)))
+        #expect(UsageStore.isPreservableNetworkTransportError(
+            NSError(domain: NSURLErrorDomain, code: NSURLErrorNotConnectedToInternet)))
+        #expect(UsageStore.isPreservableNetworkTransportError(
+            NSError(domain: NSURLErrorDomain, code: NSURLErrorNetworkConnectionLost)))
+        #expect(UsageStore.isPreservableNetworkTransportError(
+            NSError(domain: NSURLErrorDomain, code: NSURLErrorCancelled)))
+        #expect(!UsageStore.isPreservableNetworkTransportError(
+            NSError(domain: NSCocoaErrorDomain, code: 0)))
+    }
+
+    @Test
+    func `background work settings observation ignores menu provider selection churn`() async throws {
+        let settings = Self.makeSettingsStore(suite: "UsageStoreCoverageTests-switcher-selection-observation")
+        settings.refreshFrequency = .manual
+        settings.mergeIcons = true
+        try Self.enableOnly(.codex, settings: settings)
+
+        let store = Self.makeUsageStore(settings: settings)
+        let didChange = ObservationFlag()
+
+        withObservationTracking {
+            _ = store.backgroundWorkSettingsObservationToken
+        } onChange: {
+            didChange.set()
+        }
+
+        settings.selectedMenuProvider = .codex
+        try? await Task.sleep(nanoseconds: 50_000_000)
+        #expect(didChange.get() == false)
+
+        let refreshDidChange = ObservationFlag()
+        withObservationTracking {
+            _ = store.backgroundWorkSettingsObservationToken
+        } onChange: {
+            refreshDidChange.set()
+        }
+
+        settings.refreshFrequency = .oneMinute
+        try? await Task.sleep(nanoseconds: 50_000_000)
+        #expect(refreshDidChange.get() == true)
+    }
+
+    @Test
+    func `startup status network failure schedules bounded retry`() async throws {
+        let settings = Self.makeSettingsStore(suite: "UsageStoreCoverageTests-startup-status-retry")
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = true
+        try Self.enableOnly(.codex, settings: settings)
+
+        let store = Self.makeUsageStore(settings: settings)
+        store._test_providerRefreshOverride = { _ in }
+        defer { store._test_providerRefreshOverride = nil }
+        store._test_providerStatusFetchOverride = { _ in
+            throw URLError(.notConnectedToInternet)
+        }
+        defer { store._test_providerStatusFetchOverride = nil }
+
+        var scheduled: [(attempt: Int, delay: TimeInterval)] = []
+        store._test_startupConnectivityRetryScheduled = { attempt, delay in
+            scheduled.append((attempt, delay))
+        }
+        defer { store._test_startupConnectivityRetryScheduled = nil }
+
+        await store.refresh()
+        defer {
+            store.startupConnectivityRetryTask?.cancel()
+            store.startupConnectivityRetryTask = nil
+        }
+
+        #expect(scheduled.map(\.attempt) == [1])
+        #expect(scheduled.map(\.delay) == [15])
+        #expect(store.statuses[.codex]?.indicator == .unknown)
+        #expect(store.statuses[.codex]?.description?.isEmpty == false)
+    }
+
+    @Test
+    func `startup connectivity retry refreshes status and clears retry task after recovery`() async throws {
+        let settings = Self.makeSettingsStore(suite: "UsageStoreCoverageTests-startup-status-recovery")
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = true
+        try Self.enableOnly(.codex, settings: settings)
+
+        let store = Self.makeUsageStore(settings: settings)
+        store._test_providerRefreshOverride = { _ in }
+        defer { store._test_providerRefreshOverride = nil }
+
+        var statusAttempts = 0
+        store._test_providerStatusFetchOverride = { _ in
+            statusAttempts += 1
+            if statusAttempts == 1 {
+                throw URLError(.cannotFindHost)
+            }
+            return ProviderStatus(indicator: .none, description: "Operational", updatedAt: Date())
+        }
+        defer { store._test_providerStatusFetchOverride = nil }
+
+        let sleepGate = StartupConnectivityRetrySleepGate()
+        store._test_startupConnectivityRetrySleepOverride = { delay in
+            try await sleepGate.sleep(delay)
+        }
+        defer { store._test_startupConnectivityRetrySleepOverride = nil }
+
+        await store.refresh()
+        await sleepGate.waitUntilSleeping()
+        let retryTask = try #require(store.startupConnectivityRetryTask)
+
+        await sleepGate.resume()
+        await retryTask.value
+
+        #expect(statusAttempts == 2)
+        #expect(store.statuses[.codex]?.indicator == ProviderStatusIndicator.none)
+        #expect(store.statuses[.codex]?.description == "Operational")
+        #expect(store.startupConnectivityRetryTask == nil)
+    }
+
+    @Test
+    func `startup connectivity retry classification is bounded and excludes cancellation`() {
+        #expect(UsageStore.startupConnectivityRetryDelay(forAttempt: 1) == 15)
+        #expect(UsageStore.startupConnectivityRetryDelay(forAttempt: 4) == 300)
+        #expect(UsageStore.startupConnectivityRetryDelay(forAttempt: 5) == nil)
+        #expect(UsageStore.isStartupConnectivityRetryableError(URLError(.timedOut)))
+        #expect(UsageStore.isStartupConnectivityRetryableError(URLError(.notConnectedToInternet)))
+        #expect(!UsageStore.isStartupConnectivityRetryableError(URLError(.cancelled)))
+        #expect(!UsageStore.isStartupConnectivityRetryableError(CancellationError()))
+    }
+
     private static func makeSettingsStore(
         suite: String,
         zaiTokenStore: any ZaiTokenStoring = NoopZaiTokenStore(),
@@ -162,7 +709,7 @@ struct UsageStoreCoverageTests {
         defaults.removePersistentDomain(forName: suite)
         let configStore = testConfigStore(suiteName: suite)
 
-        return SettingsStore(
+        let settings = SettingsStore(
             userDefaults: defaults,
             configStore: configStore,
             zaiTokenStore: zaiTokenStore,
@@ -180,13 +727,109 @@ struct UsageStoreCoverageTests {
             ampCookieStore: InMemoryCookieHeaderStore(),
             copilotTokenStore: InMemoryCopilotTokenStore(),
             tokenAccountStore: InMemoryTokenAccountStore())
+        settings.providerDetectionCompleted = true
+        return settings
     }
 
     private static func makeUsageStore(settings: SettingsStore) -> UsageStore {
         UsageStore(
             fetcher: UsageFetcher(environment: [:]),
             browserDetection: BrowserDetection(cacheTTL: 0),
-            settings: settings)
+            settings: settings,
+            environmentBase: [:])
+    }
+
+    private static func writeCodexAuthFile(homeURL: URL, email: String, plan: String) throws {
+        try FileManager.default.createDirectory(at: homeURL, withIntermediateDirectories: true)
+        let auth = try [
+            "tokens": [
+                "accessToken": "access-token",
+                "refreshToken": "refresh-token",
+                "idToken": Self.fakeCodexJWT(email: email, plan: plan),
+            ],
+        ]
+        let data = try JSONSerialization.data(withJSONObject: auth)
+        try data.write(to: homeURL.appendingPathComponent("auth.json"), options: .atomic)
+    }
+
+    private static func fakeCodexJWT(email: String, plan: String) throws -> String {
+        let header = try JSONSerialization.data(withJSONObject: ["alg": "none"])
+        let payload = try JSONSerialization.data(withJSONObject: [
+            "email": email,
+            "chatgpt_plan_type": plan,
+            "https://api.openai.com/auth": [
+                "chatgpt_plan_type": plan,
+            ],
+        ])
+        return "\(Self.base64URL(header)).\(Self.base64URL(payload))."
+    }
+
+    private static func base64URL(_ data: Data) -> String {
+        data.base64EncodedString()
+            .replacingOccurrences(of: "=", with: "")
+            .replacingOccurrences(of: "+", with: "-")
+            .replacingOccurrences(of: "/", with: "_")
+    }
+
+    private static func makeCopilotSnapshot(
+        usedPercent: Double,
+        extraRateWindows: [NamedRateWindow]?) -> UsageSnapshot
+    {
+        UsageSnapshot(
+            primary: RateWindow(usedPercent: usedPercent, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            extraRateWindows: extraRateWindows,
+            updatedAt: Date(timeIntervalSince1970: 1_780_358_400))
+    }
+
+    private static func makeCopilotBudgetWindow() -> NamedRateWindow {
+        NamedRateWindow(
+            id: "copilot-budget-test",
+            title: "Budget - Copilot",
+            window: RateWindow(usedPercent: 50, windowMinutes: nil, resetsAt: nil, resetDescription: nil))
+    }
+
+    private static func enableOnly(_ enabledProvider: UsageProvider, settings: SettingsStore) throws {
+        let metadata = ProviderRegistry.shared.metadata
+        for provider in UsageProvider.allCases {
+            try settings.setProviderEnabled(
+                provider: provider,
+                metadata: #require(metadata[provider]),
+                enabled: provider == enabledProvider)
+        }
+    }
+}
+
+private actor StartupConnectivityRetrySleepGate {
+    private var continuation: CheckedContinuation<Void, Error>?
+    private var waiters: [CheckedContinuation<Void, Never>] = []
+
+    func sleep(_ delay: TimeInterval) async throws {
+        #expect(delay == 15)
+        try await withCheckedThrowingContinuation { continuation in
+            self.continuation = continuation
+            self.resumeWaiters()
+        }
+    }
+
+    func waitUntilSleeping() async {
+        if self.continuation != nil { return }
+        await withCheckedContinuation { continuation in
+            self.waiters.append(continuation)
+        }
+    }
+
+    func resume() {
+        self.continuation?.resume()
+        self.continuation = nil
+    }
+
+    private func resumeWaiters() {
+        let waiters = self.waiters
+        self.waiters.removeAll()
+        for waiter in waiters {
+            waiter.resume()
+        }
     }
 }
 
@@ -221,3 +864,15 @@ private final class InMemorySyntheticTokenStore: SyntheticTokenStoring, @uncheck
         self.value = token
     }
 }
+
+private struct LocalizedTestError: LocalizedError {
+    let message: String
+
+    init(_ message: String) {
+        self.message = message
+    }
+
+    var errorDescription: String? {
+        self.message
+    }
+}
diff --git a/Tests/CodexBarTests/UsageStoreHighestUsageTests.swift b/Tests/CodexBarTests/UsageStoreHighestUsageTests.swift
index c75944d635..3c781ca022 100644
--- a/Tests/CodexBarTests/UsageStoreHighestUsageTests.swift
+++ b/Tests/CodexBarTests/UsageStoreHighestUsageTests.swift
@@ -4,10 +4,9 @@ import Testing
 @testable import CodexBar
 
 @MainActor
-@Suite
 struct UsageStoreHighestUsageTests {
     @Test
-    func selectsHighestUsageAmongEnabledProviders() {
+    func `selects highest usage among enabled providers`() {
         let settings = SettingsStore(
             configStore: testConfigStore(suiteName: "UsageStoreHighestUsageTests-selects"),
             zaiTokenStore: NoopZaiTokenStore(),
@@ -44,7 +43,7 @@ struct UsageStoreHighestUsageTests {
     }
 
     @Test
-    func skipsFullyUsedProviders() {
+    func `skips fully used providers`() {
         let settings = SettingsStore(
             configStore: testConfigStore(suiteName: "UsageStoreHighestUsageTests-skips"),
             zaiTokenStore: NoopZaiTokenStore(),
@@ -81,7 +80,7 @@ struct UsageStoreHighestUsageTests {
     }
 
     @Test
-    func automaticMetricUsesSecondaryForKimiWhenRankingHighestUsage() {
+    func `automatic metric uses secondary for kimi when ranking highest usage`() {
         let settings = SettingsStore(
             configStore: testConfigStore(suiteName: "UsageStoreHighestUsageTests-kimi-automatic"),
             zaiTokenStore: NoopZaiTokenStore(),
@@ -119,7 +118,377 @@ struct UsageStoreHighestUsageTests {
     }
 
     @Test
-    func automaticMetricKeepsCopilotMostConstrainedRanking() {
+    func `automatic metric ignores antigravity tertiary when compact icon has no quota summary`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "UsageStoreHighestUsageTests-antigravity-tertiary"),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.setMenuBarMetricPreference(.automatic, for: .antigravity)
+
+        let registry = ProviderRegistry.shared
+        if let codexMeta = registry.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+        if let antigravityMeta = registry.metadata[.antigravity] {
+            settings.setProviderEnabled(provider: .antigravity, metadata: antigravityMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+
+        let codexSnapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 70, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())
+        let antigravitySnapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            tertiary: RateWindow(usedPercent: 85, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(codexSnapshot, provider: .codex)
+        store._setSnapshotForTesting(antigravitySnapshot, provider: .antigravity)
+
+        let highest = store.providerWithHighestUsage()
+        #expect(highest?.provider == .codex)
+        #expect(highest?.usedPercent == 70)
+    }
+
+    @Test
+    func `automatic metric ignores unclassified antigravity compact fallback`() throws {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "UsageStoreHighestUsageTests-antigravity-unclassified"),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.setMenuBarMetricPreference(.automatic, for: .antigravity)
+
+        let registry = ProviderRegistry.shared
+        if let codexMeta = registry.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+        if let antigravityMeta = registry.metadata[.antigravity] {
+            settings.setProviderEnabled(provider: .antigravity, metadata: antigravityMeta, enabled: true)
+        }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings)
+        let codexSnapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 50, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())
+        let antigravitySnapshot = try AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "Experimental Model",
+                    modelId: "MODEL_PLACEHOLDER_NEW",
+                    remainingFraction: 0.36,
+                    resetTime: nil,
+                    resetDescription: nil),
+            ],
+            accountEmail: nil,
+            accountPlan: nil,
+            source: .local)
+            .toUsageSnapshot()
+
+        store._setSnapshotForTesting(codexSnapshot, provider: .codex)
+        store._setSnapshotForTesting(antigravitySnapshot, provider: .antigravity)
+
+        let highest = store.providerWithHighestUsage()
+        #expect(highest?.provider == .codex)
+        #expect(highest?.usedPercent == 50)
+    }
+
+    @Test
+    func `automatic metric ignores legacy antigravity family lanes without quota summary`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "UsageStoreHighestUsageTests-antigravity-constrained-gemini"),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.setMenuBarMetricPreference(.automatic, for: .antigravity)
+
+        let registry = ProviderRegistry.shared
+        if let codexMeta = registry.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+        if let antigravityMeta = registry.metadata[.antigravity] {
+            settings.setProviderEnabled(provider: .antigravity, metadata: antigravityMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+
+        let codexSnapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 70, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())
+        let antigravitySnapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 0, windowMinutes: nil, resetsAt: nil, resetDescription: "Claude"),
+            secondary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: "Gemini Pro"),
+            tertiary: RateWindow(usedPercent: 40, windowMinutes: nil, resetsAt: nil, resetDescription: "Gemini Flash"),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(codexSnapshot, provider: .codex)
+        store._setSnapshotForTesting(antigravitySnapshot, provider: .antigravity)
+
+        let highest = store.providerWithHighestUsage()
+        #expect(highest?.provider == .codex)
+        #expect(highest?.usedPercent == 70)
+    }
+
+    @Test
+    func `automatic metric ranks antigravity by rendered gemini quota summary lanes`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "UsageStoreHighestUsageTests-antigravity-rendered-gemini"),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.setMenuBarMetricPreference(.automatic, for: .antigravity)
+
+        let registry = ProviderRegistry.shared
+        if let codexMeta = registry.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+        if let antigravityMeta = registry.metadata[.antigravity] {
+            settings.setProviderEnabled(provider: .antigravity, metadata: antigravityMeta, enabled: true)
+        }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings)
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(usedPercent: 80, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date()),
+            provider: .codex)
+        store._setSnapshotForTesting(
+            self.antigravityQuotaSummarySnapshot(
+                geminiSessionUsed: 10,
+                geminiWeeklyUsed: 20,
+                otherSessionUsed: 95,
+                otherWeeklyUsed: 90),
+            provider: .antigravity)
+
+        var highest = store.providerWithHighestUsage()
+        #expect(highest?.provider == .codex)
+        #expect(highest?.usedPercent == 80)
+
+        store._setSnapshotForTesting(
+            self.antigravityQuotaSummarySnapshot(
+                geminiSessionUsed: 95,
+                geminiWeeklyUsed: 20,
+                otherSessionUsed: 10,
+                otherWeeklyUsed: 10),
+            provider: .antigravity)
+        highest = store.providerWithHighestUsage()
+        #expect(highest?.provider == .antigravity)
+        #expect(highest?.usedPercent == 95)
+
+        store._setSnapshotForTesting(
+            self.antigravityQuotaSummarySnapshot(
+                geminiSessionUsed: 100,
+                geminiWeeklyUsed: 100,
+                otherSessionUsed: 50,
+                otherWeeklyUsed: 50),
+            provider: .antigravity)
+        highest = store.providerWithHighestUsage()
+        #expect(highest?.provider == .codex)
+    }
+
+    @Test
+    func `automatic metric keeps antigravity when one rendered lane has quota`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "UsageStoreHighestUsageTests-antigravity-all-100"),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.setMenuBarMetricPreference(.automatic, for: .antigravity)
+
+        let registry = ProviderRegistry.shared
+        if let codexMeta = registry.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+        if let antigravityMeta = registry.metadata[.antigravity] {
+            settings.setProviderEnabled(provider: .antigravity, metadata: antigravityMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+
+        let codexSnapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 80, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())
+        let antigravitySnapshot = self.antigravityQuotaSummarySnapshot(
+            geminiSessionUsed: 100,
+            geminiWeeklyUsed: 40,
+            otherSessionUsed: 100,
+            otherWeeklyUsed: 100)
+
+        store._setSnapshotForTesting(codexSnapshot, provider: .codex)
+        store._setSnapshotForTesting(antigravitySnapshot, provider: .antigravity)
+
+        let highest = store.providerWithHighestUsage()
+        #expect(highest?.provider == .antigravity)
+        #expect(highest?.usedPercent == 100)
+    }
+
+    @Test
+    func `automatic metric ignores antigravity legacy detail rows`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "UsageStoreHighestUsageTests-antigravity-fallback-detail"),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.setMenuBarMetricPreference(.automatic, for: .antigravity)
+
+        let registry = ProviderRegistry.shared
+        if let codexMeta = registry.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+        if let antigravityMeta = registry.metadata[.antigravity] {
+            settings.setProviderEnabled(provider: .antigravity, metadata: antigravityMeta, enabled: true)
+        }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings)
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(usedPercent: 80, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date()),
+            provider: .codex)
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: nil,
+                secondary: nil,
+                tertiary: nil,
+                extraRateWindows: [
+                    NamedRateWindow(
+                        id: "antigravity-compact-fallback-model-a",
+                        title: "Model A",
+                        window: RateWindow(
+                            usedPercent: 100,
+                            windowMinutes: nil,
+                            resetsAt: nil,
+                            resetDescription: nil)),
+                    NamedRateWindow(
+                        id: "model-b",
+                        title: "Model B",
+                        window: RateWindow(
+                            usedPercent: 50,
+                            windowMinutes: nil,
+                            resetsAt: nil,
+                            resetDescription: nil)),
+                ],
+                updatedAt: Date()),
+            provider: .antigravity)
+
+        let highest = store.providerWithHighestUsage()
+        #expect(highest?.provider == .codex)
+        #expect(highest?.usedPercent == 80)
+    }
+
+    @Test
+    func `automatic metric skips antigravity with no quota lanes`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "UsageStoreHighestUsageTests-antigravity-empty"),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.setMenuBarMetricPreference(.automatic, for: .antigravity)
+
+        let registry = ProviderRegistry.shared
+        if let codexMeta = registry.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+        if let antigravityMeta = registry.metadata[.antigravity] {
+            settings.setProviderEnabled(provider: .antigravity, metadata: antigravityMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+
+        let codexSnapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 80, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())
+        let antigravitySnapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            tertiary: nil,
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .antigravity,
+                accountEmail: "user@example.com",
+                accountOrganization: nil,
+                loginMethod: "Pro"))
+
+        store._setSnapshotForTesting(codexSnapshot, provider: .codex)
+        store._setSnapshotForTesting(antigravitySnapshot, provider: .antigravity)
+
+        let highest = store.providerWithHighestUsage()
+        #expect(highest?.provider == .codex)
+        #expect(highest?.usedPercent == 80)
+    }
+
+    @Test
+    func `automatic metric uses zai 5-hour token lane when ranking highest usage`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "UsageStoreHighestUsageTests-zai-automatic-tertiary"),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.setMenuBarMetricPreference(.automatic, for: .zai)
+        settings.addTokenAccount(provider: .zai, label: "Primary", token: "zai-token")
+
+        let registry = ProviderRegistry.shared
+        if let codexMeta = registry.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+        if let zaiMeta = registry.metadata[.zai] {
+            settings.setProviderEnabled(provider: .zai, metadata: zaiMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+
+        let codexSnapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 70, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())
+        let zaiSnapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 15, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 10, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            tertiary: RateWindow(usedPercent: 90, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(codexSnapshot, provider: .codex)
+        store._setSnapshotForTesting(zaiSnapshot, provider: .zai)
+
+        let highest = store.providerWithHighestUsage()
+        #expect(highest?.provider == .zai)
+        #expect(highest?.usedPercent == 90)
+    }
+
+    @Test
+    func `automatic metric keeps copilot most constrained ranking`() {
         let settings = SettingsStore(
             configStore: testConfigStore(suiteName: "UsageStoreHighestUsageTests-copilot-automatic"),
             zaiTokenStore: NoopZaiTokenStore(),
@@ -157,7 +526,7 @@ struct UsageStoreHighestUsageTests {
     }
 
     @Test
-    func automaticMetricDoesNotExcludePartiallyAvailableCopilotAtHundredPercent() {
+    func `automatic metric does not exclude partially available copilot at hundred percent`() {
         let settings = SettingsStore(
             configStore: testConfigStore(suiteName: "UsageStoreHighestUsageTests-copilot-partial-100"),
             zaiTokenStore: NoopZaiTokenStore(),
@@ -195,7 +564,7 @@ struct UsageStoreHighestUsageTests {
     }
 
     @Test
-    func automaticMetricExcludesCopilotWhenBothLanesAreExhausted() {
+    func `automatic metric excludes copilot when both lanes are exhausted`() {
         let settings = SettingsStore(
             configStore: testConfigStore(suiteName: "UsageStoreHighestUsageTests-copilot-both-100"),
             zaiTokenStore: NoopZaiTokenStore(),
@@ -231,4 +600,377 @@ struct UsageStoreHighestUsageTests {
         #expect(highest?.provider == .codex)
         #expect(highest?.usedPercent == 80)
     }
+
+    @Test
+    func `automatic metric uses tertiary when it is most constrained for cursor`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "UsageStoreHighestUsageTests-cursor-tertiary"),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.setMenuBarMetricPreference(.automatic, for: .cursor)
+
+        let registry = ProviderRegistry.shared
+        if let codexMeta = registry.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+        if let cursorMeta = registry.metadata[.cursor] {
+            settings.setProviderEnabled(provider: .cursor, metadata: cursorMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+
+        let codexSnapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 50, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())
+        let cursorSnapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 20, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            tertiary: RateWindow(usedPercent: 95, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(codexSnapshot, provider: .codex)
+        store._setSnapshotForTesting(cursorSnapshot, provider: .cursor)
+
+        let highest = store.providerWithHighestUsage()
+        #expect(highest?.provider == .cursor)
+        #expect(highest?.usedPercent == 95)
+    }
+
+    @Test
+    func `automatic metric keeps perplexity in highest usage when purchased credits remain`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "UsageStoreHighestUsageTests-perplexity-purchased"),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.setMenuBarMetricPreference(.automatic, for: .perplexity)
+
+        let registry = ProviderRegistry.shared
+        if let codexMeta = registry.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+        if let perplexityMeta = registry.metadata[.perplexity] {
+            settings.setProviderEnabled(provider: .perplexity, metadata: perplexityMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+
+        let codexSnapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 15, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())
+        let perplexitySnapshot = UsageSnapshot(
+            primary: nil,
+            secondary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            tertiary: RateWindow(usedPercent: 45, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(codexSnapshot, provider: .codex)
+        store._setSnapshotForTesting(perplexitySnapshot, provider: .perplexity)
+
+        let highest = store.providerWithHighestUsage()
+        #expect(highest?.provider == .perplexity)
+        #expect(highest?.usedPercent == 45)
+    }
+
+    @Test
+    func `automatic metric ignores exhausted recurring perplexity lane when fallback remains`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "UsageStoreHighestUsageTests-perplexity-recurring-exhausted"),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.setMenuBarMetricPreference(.automatic, for: .perplexity)
+
+        let registry = ProviderRegistry.shared
+        if let codexMeta = registry.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+        if let perplexityMeta = registry.metadata[.perplexity] {
+            settings.setProviderEnabled(provider: .perplexity, metadata: perplexityMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+
+        let codexSnapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 25, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())
+        let perplexitySnapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            tertiary: RateWindow(usedPercent: 40, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(codexSnapshot, provider: .codex)
+        store._setSnapshotForTesting(perplexitySnapshot, provider: .perplexity)
+
+        let highest = store.providerWithHighestUsage()
+        #expect(highest?.provider == .perplexity)
+        #expect(highest?.usedPercent == 40)
+    }
+
+    @Test
+    func `automatic metric prefers purchased perplexity credits before bonus in highest usage`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "UsageStoreHighestUsageTests-perplexity-purchased-before-bonus"),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.setMenuBarMetricPreference(.automatic, for: .perplexity)
+
+        let registry = ProviderRegistry.shared
+        if let codexMeta = registry.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+        if let perplexityMeta = registry.metadata[.perplexity] {
+            settings.setProviderEnabled(provider: .perplexity, metadata: perplexityMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+
+        let codexSnapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 30, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())
+        let perplexitySnapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 20, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            tertiary: RateWindow(usedPercent: 45, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(codexSnapshot, provider: .codex)
+        store._setSnapshotForTesting(perplexitySnapshot, provider: .perplexity)
+
+        let highest = store.providerWithHighestUsage()
+        #expect(highest?.provider == .perplexity)
+        #expect(highest?.usedPercent == 45)
+    }
+
+    @Test
+    func `primary metric keeps exhausted recurring perplexity lane in highest usage selection`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "UsageStoreHighestUsageTests-perplexity-primary-exhausted"),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.setMenuBarMetricPreference(.primary, for: .perplexity)
+
+        let registry = ProviderRegistry.shared
+        if let codexMeta = registry.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+        if let perplexityMeta = registry.metadata[.perplexity] {
+            settings.setProviderEnabled(provider: .perplexity, metadata: perplexityMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+
+        let codexSnapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 25, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())
+        let perplexitySnapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            tertiary: RateWindow(usedPercent: 40, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(codexSnapshot, provider: .codex)
+        store._setSnapshotForTesting(perplexitySnapshot, provider: .perplexity)
+
+        let highest = store.providerWithHighestUsage()
+        #expect(highest?.provider == .codex)
+        #expect(highest?.usedPercent == 25)
+    }
+
+    @Test
+    func `automatic metric excludes cursor when all opus lanes are exhausted`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "UsageStoreHighestUsageTests-cursor-all-100"),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.setMenuBarMetricPreference(.automatic, for: .cursor)
+
+        let registry = ProviderRegistry.shared
+        if let codexMeta = registry.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+        if let cursorMeta = registry.metadata[.cursor] {
+            settings.setProviderEnabled(provider: .cursor, metadata: cursorMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+
+        let codexSnapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 80, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())
+        let cursorSnapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            tertiary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(codexSnapshot, provider: .codex)
+        store._setSnapshotForTesting(cursorSnapshot, provider: .cursor)
+
+        let highest = store.providerWithHighestUsage()
+        #expect(highest?.provider == .codex)
+        #expect(highest?.usedPercent == 80)
+    }
+
+    @Test
+    func `cursor highest usage keeps provider when saved tertiary falls back to automatic`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "UsageStoreHighestUsageTests-cursor-missing-tertiary"),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.setMenuBarMetricPreference(.tertiary, for: .cursor)
+
+        let registry = ProviderRegistry.shared
+        if let codexMeta = registry.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+        if let cursorMeta = registry.metadata[.cursor] {
+            settings.setProviderEnabled(provider: .cursor, metadata: cursorMeta, enabled: true)
+        }
+
+        let fetcher = UsageFetcher()
+        let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
+
+        let codexSnapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 40, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())
+        let cursorSnapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 60, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            tertiary: nil,
+            updatedAt: Date())
+
+        store._setSnapshotForTesting(codexSnapshot, provider: .codex)
+        store._setSnapshotForTesting(cursorSnapshot, provider: .cursor)
+
+        let highest = store.providerWithHighestUsage()
+        #expect(highest?.provider == .cursor)
+        #expect(highest?.usedPercent == 100)
+    }
+
+    private func antigravityQuotaSummarySnapshot(
+        geminiSessionUsed: Double,
+        geminiWeeklyUsed: Double,
+        otherSessionUsed: Double,
+        otherWeeklyUsed: Double) -> UsageSnapshot
+    {
+        UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            tertiary: nil,
+            extraRateWindows: [
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-gemini-5h",
+                    title: "Gemini Session",
+                    window: RateWindow(
+                        usedPercent: geminiSessionUsed,
+                        windowMinutes: 5 * 60,
+                        resetsAt: nil,
+                        resetDescription: nil)),
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-gemini-weekly",
+                    title: "Gemini Weekly",
+                    window: RateWindow(
+                        usedPercent: geminiWeeklyUsed,
+                        windowMinutes: 7 * 24 * 60,
+                        resetsAt: nil,
+                        resetDescription: nil)),
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-3p-5h",
+                    title: "Claude + GPT Session",
+                    window: RateWindow(
+                        usedPercent: otherSessionUsed,
+                        windowMinutes: 5 * 60,
+                        resetsAt: nil,
+                        resetDescription: nil)),
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-3p-weekly",
+                    title: "Claude + GPT Weekly",
+                    window: RateWindow(
+                        usedPercent: otherWeeklyUsed,
+                        windowMinutes: 7 * 24 * 60,
+                        resetsAt: nil,
+                        resetDescription: nil)),
+            ],
+            updatedAt: Date())
+    }
+}
+
+extension UsageStoreHighestUsageTests {
+    @Test
+    func `explicit antigravity metric remains authoritative for highest usage`() {
+        let settings = SettingsStore(
+            configStore: testConfigStore(suiteName: "UsageStoreHighestUsageTests-antigravity-explicit"),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.setMenuBarMetricPreference(.secondary, for: .antigravity)
+
+        let registry = ProviderRegistry.shared
+        if let codexMeta = registry.metadata[.codex] {
+            settings.setProviderEnabled(provider: .codex, metadata: codexMeta, enabled: true)
+        }
+        if let antigravityMeta = registry.metadata[.antigravity] {
+            settings.setProviderEnabled(provider: .antigravity, metadata: antigravityMeta, enabled: true)
+        }
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings)
+        store._setSnapshotForTesting(
+            UsageSnapshot(
+                primary: RateWindow(usedPercent: 80, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date()),
+            provider: .codex)
+        let antigravity = self.antigravityQuotaSummarySnapshot(
+            geminiSessionUsed: 10,
+            geminiWeeklyUsed: 20,
+            otherSessionUsed: 95,
+            otherWeeklyUsed: 90)
+            .with(
+                primary: RateWindow(usedPercent: 10, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                secondary: RateWindow(usedPercent: 95, windowMinutes: nil, resetsAt: nil, resetDescription: nil))
+        store._setSnapshotForTesting(antigravity, provider: .antigravity)
+
+        var highest = store.providerWithHighestUsage()
+        #expect(highest?.provider == .antigravity)
+        #expect(highest?.usedPercent == 95)
+
+        store._setSnapshotForTesting(
+            antigravity.with(
+                primary: antigravity.primary,
+                secondary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil)),
+            provider: .antigravity)
+        highest = store.providerWithHighestUsage()
+        #expect(highest?.provider == .codex)
+    }
 }
diff --git a/Tests/CodexBarTests/UsageStoreManualTokenRefreshTests.swift b/Tests/CodexBarTests/UsageStoreManualTokenRefreshTests.swift
new file mode 100644
index 0000000000..2268cc3431
--- /dev/null
+++ b/Tests/CodexBarTests/UsageStoreManualTokenRefreshTests.swift
@@ -0,0 +1,308 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+private actor TokenRefreshGate {
+    private var didStart = false
+    private var didFinish = false
+    private var released = false
+    private var startWaiters: [CheckedContinuation<Void, Never>] = []
+    private var releaseWaiters: [CheckedContinuation<Void, Never>] = []
+    private var finishWaiters: [CheckedContinuation<Void, Never>] = []
+    private(set) var calls: [(provider: UsageProvider, force: Bool)] = []
+
+    func start(provider: UsageProvider, force: Bool) {
+        self.didStart = true
+        self.calls.append((provider, force))
+        let waiters = self.startWaiters
+        self.startWaiters.removeAll()
+        waiters.forEach { $0.resume() }
+    }
+
+    func waitForStart() async {
+        if self.didStart { return }
+        await withCheckedContinuation { continuation in
+            self.startWaiters.append(continuation)
+        }
+    }
+
+    func waitForRelease() async {
+        if self.released { return }
+        await withCheckedContinuation { continuation in
+            self.releaseWaiters.append(continuation)
+        }
+    }
+
+    func release() {
+        self.released = true
+        let waiters = self.releaseWaiters
+        self.releaseWaiters.removeAll()
+        waiters.forEach { $0.resume() }
+    }
+
+    func finish() {
+        self.didFinish = true
+        let waiters = self.finishWaiters
+        self.finishWaiters.removeAll()
+        waiters.forEach { $0.resume() }
+    }
+
+    func hasFinished() -> Bool {
+        self.didFinish
+    }
+
+    func waitForFinish() async {
+        if self.didFinish { return }
+        await withCheckedContinuation { continuation in
+            self.finishWaiters.append(continuation)
+        }
+    }
+}
+
+private actor CompletionFlag {
+    private var completed = false
+
+    func markCompleted() {
+        self.completed = true
+    }
+
+    func isCompleted() -> Bool {
+        self.completed
+    }
+}
+
+private actor TokenRefreshRecorder {
+    private(set) var calls: [(provider: UsageProvider, force: Bool)] = []
+
+    func record(provider: UsageProvider, force: Bool) {
+        self.calls.append((provider, force))
+    }
+}
+
+@MainActor
+@Suite(.serialized)
+struct UsageStoreManualTokenRefreshTests {
+    @Test
+    func `manual refresh waits for token-cost refresh before completing`() async {
+        let store = Self.makeStore()
+        let gate = TokenRefreshGate()
+        let completion = CompletionFlag()
+        store._test_providerRefreshOverride = { _ in }
+        store._test_tokenUsageRefreshOverride = { provider, force in
+            await gate.start(provider: provider, force: force)
+            await gate.waitForRelease()
+            await gate.finish()
+        }
+
+        let task = Task { @MainActor in
+            await store.refresh(forceTokenUsage: true)
+            await completion.markCompleted()
+        }
+
+        await gate.waitForStart()
+        #expect(await completion.isCompleted() == false)
+        #expect(await gate.hasFinished() == false)
+
+        await gate.release()
+        await task.value
+
+        #expect(await completion.isCompleted())
+        #expect(await gate.hasFinished())
+        #expect(await gate.calls.map(\.provider) == [.codex])
+        #expect(await gate.calls.map(\.force) == [true])
+    }
+
+    @Test
+    func `manual refresh drains scheduled token-cost refresh before forced pass`() async {
+        let store = Self.makeStore()
+        let scheduledGate = TokenRefreshGate()
+        let forcedGate = TokenRefreshGate()
+        let recorder = TokenRefreshRecorder()
+        let completion = CompletionFlag()
+        store._test_providerRefreshOverride = { _ in }
+        store._test_tokenUsageRefreshOverride = { provider, force in
+            await recorder.record(provider: provider, force: force)
+            if force {
+                await forcedGate.start(provider: provider, force: force)
+                await forcedGate.waitForRelease()
+                await forcedGate.finish()
+            } else {
+                await scheduledGate.start(provider: provider, force: force)
+                await scheduledGate.waitForRelease()
+                await scheduledGate.finish()
+            }
+        }
+
+        await store.refresh(forceTokenUsage: false)
+        await scheduledGate.waitForStart()
+
+        let task = Task { @MainActor in
+            await store.refresh(forceTokenUsage: true)
+            await completion.markCompleted()
+        }
+
+        try? await Task.sleep(for: .milliseconds(50))
+        #expect(await completion.isCompleted() == false)
+
+        await scheduledGate.release()
+        await forcedGate.waitForStart()
+        #expect(await completion.isCompleted() == false)
+
+        await forcedGate.release()
+        await task.value
+
+        #expect(await completion.isCompleted())
+        #expect(await scheduledGate.hasFinished())
+        #expect(await forcedGate.hasFinished())
+        #expect(await recorder.calls.map(\.provider) == [.codex, .codex])
+        #expect(await recorder.calls.map(\.force) == [false, true])
+    }
+
+    @Test
+    func `scoped manual refresh drains scheduled token-cost refresh before forced pass`() async {
+        let store = Self.makeStore()
+        let scheduledGate = TokenRefreshGate()
+        let forcedGate = TokenRefreshGate()
+        let recorder = TokenRefreshRecorder()
+        let completion = CompletionFlag()
+        store._test_providerRefreshOverride = { _ in }
+        store._test_tokenUsageRefreshOverride = { provider, force in
+            await recorder.record(provider: provider, force: force)
+            if force {
+                await forcedGate.start(provider: provider, force: force)
+                await forcedGate.waitForRelease()
+                await forcedGate.finish()
+            } else {
+                await scheduledGate.start(provider: provider, force: force)
+                await scheduledGate.waitForRelease()
+                await scheduledGate.finish()
+            }
+        }
+
+        await store.refresh(forceTokenUsage: false)
+        await scheduledGate.waitForStart()
+
+        let task = Task { @MainActor in
+            await store.refreshTokenUsageNow(for: .codex, force: true)
+            await completion.markCompleted()
+        }
+
+        try? await Task.sleep(for: .milliseconds(50))
+        #expect(await completion.isCompleted() == false)
+
+        await scheduledGate.release()
+        await forcedGate.waitForStart()
+        #expect(await completion.isCompleted() == false)
+
+        await forcedGate.release()
+        await task.value
+
+        #expect(await completion.isCompleted())
+        #expect(await scheduledGate.hasFinished())
+        #expect(await forcedGate.hasFinished())
+        #expect(await recorder.calls.map(\.provider) == [.codex, .codex])
+        #expect(await recorder.calls.map(\.force) == [false, true])
+    }
+
+    @Test
+    func `scoped manual refresh leaves unrelated scheduled token-cost refresh running`() async {
+        let store = Self.makeStore(enabledProviders: [.claude, .codex])
+        let scheduledGate = TokenRefreshGate()
+        let forcedGate = TokenRefreshGate()
+        let recorder = TokenRefreshRecorder()
+        let completion = CompletionFlag()
+        store._test_providerRefreshOverride = { _ in }
+        store._test_tokenUsageRefreshOverride = { provider, force in
+            await recorder.record(provider: provider, force: force)
+            if force {
+                await forcedGate.start(provider: provider, force: force)
+                await forcedGate.waitForRelease()
+                await forcedGate.finish()
+            } else {
+                await scheduledGate.start(provider: provider, force: force)
+                await scheduledGate.waitForRelease()
+                await scheduledGate.finish()
+            }
+        }
+
+        await store.refresh(forceTokenUsage: false)
+        await scheduledGate.waitForStart()
+
+        let task = Task { @MainActor in
+            await store.refreshTokenUsageNow(for: .claude, force: true)
+            await completion.markCompleted()
+        }
+
+        await forcedGate.waitForStart()
+        #expect(await scheduledGate.hasFinished() == false)
+        #expect(await completion.isCompleted() == false)
+        #expect(await recorder.calls.map(\.provider) == [.codex, .claude])
+        #expect(await recorder.calls.map(\.force) == [false, true])
+
+        await forcedGate.release()
+        await task.value
+        #expect(await completion.isCompleted())
+        #expect(await scheduledGate.hasFinished() == false)
+
+        await scheduledGate.release()
+        await scheduledGate.waitForFinish()
+    }
+
+    @Test
+    func `regular refresh schedules token-cost refresh without waiting`() async {
+        let store = Self.makeStore()
+        let gate = TokenRefreshGate()
+        store._test_providerRefreshOverride = { _ in }
+        store._test_tokenUsageRefreshOverride = { provider, force in
+            await gate.start(provider: provider, force: force)
+            await gate.waitForRelease()
+            await gate.finish()
+        }
+
+        await store.refresh(forceTokenUsage: false)
+        #expect(await gate.hasFinished() == false)
+
+        await gate.release()
+        try? await Task.sleep(for: .milliseconds(50))
+        let calls = await gate.calls
+        if !calls.isEmpty {
+            #expect(calls.map(\.provider) == [.codex])
+            #expect(calls.map(\.force) == [false])
+            #expect(await gate.hasFinished())
+        }
+    }
+
+    private static func makeStore(enabledProviders: Set<UsageProvider> = [.codex]) -> UsageStore {
+        let suite = "UsageStoreManualTokenRefreshTests-\(UUID().uuidString)"
+        let defaults = UserDefaults(suiteName: suite)!
+        defaults.removePersistentDomain(forName: suite)
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.costUsageEnabled = true
+        settings.openAIWebAccessEnabled = false
+        settings.codexCookieSource = .off
+        settings.providerDetectionCompleted = true
+
+        let registry = ProviderRegistry.shared
+        for provider in UsageProvider.allCases {
+            guard let metadata = registry.metadata[provider] else { continue }
+            settings.setProviderEnabled(
+                provider: provider,
+                metadata: metadata,
+                enabled: enabledProviders.contains(provider))
+        }
+
+        return UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing,
+            environmentBase: [:])
+    }
+}
diff --git a/Tests/CodexBarTests/UsageStorePathDebugTests.swift b/Tests/CodexBarTests/UsageStorePathDebugTests.swift
index a73a8b3ebf..856fc178cb 100644
--- a/Tests/CodexBarTests/UsageStorePathDebugTests.swift
+++ b/Tests/CodexBarTests/UsageStorePathDebugTests.swift
@@ -4,10 +4,9 @@ import Testing
 @testable import CodexBar
 
 @MainActor
-@Suite
 struct UsageStorePathDebugTests {
     @Test
-    func refreshPathDebugInfoPopulatesSnapshot() async throws {
+    func `refresh path debug info populates snapshot`() async throws {
         let suite = "UsageStorePathDebugTests-path"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -30,4 +29,27 @@ struct UsageStorePathDebugTests {
         #expect(store.pathDebugInfo != .empty)
         #expect(store.pathDebugInfo.effectivePATH.isEmpty == false)
     }
+
+    @Test
+    func `deepseek debug log includes selected token account`() async throws {
+        let suite = "UsageStorePathDebugTests-deepseek-debug-token-account"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+        let configStore = testConfigStore(suiteName: suite)
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            zaiTokenStore: NoopZaiTokenStore())
+        settings.addTokenAccount(provider: .deepseek, label: "Primary", token: "sk-deepseek-test")
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            startupBehavior: .testing,
+            environmentBase: [:])
+
+        let debugLog = await store.debugLog(for: UsageProvider.deepseek)
+
+        #expect(debugLog == "DEEPSEEK_API_KEY=present source=settings-token-account")
+    }
 }
diff --git a/Tests/CodexBarTests/UsageStorePlanUtilizationClaudeIdentityTests.swift b/Tests/CodexBarTests/UsageStorePlanUtilizationClaudeIdentityTests.swift
new file mode 100644
index 0000000000..2ccc89a236
--- /dev/null
+++ b/Tests/CodexBarTests/UsageStorePlanUtilizationClaudeIdentityTests.swift
@@ -0,0 +1,244 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct UsageStorePlanUtilizationClaudeIdentityTests {
+    @MainActor
+    @Test
+    func `selected token account chooses matching bucket`() throws {
+        let store = UsageStorePlanUtilizationTests.makeStore()
+        store.settings.addTokenAccount(provider: .claude, label: "Alice", token: "alice-token")
+        store.settings.addTokenAccount(provider: .claude, label: "Bob", token: "bob-token")
+        let accounts = store.settings.tokenAccounts(for: .claude)
+        let alice = try #require(accounts.first)
+        let bob = try #require(accounts.last)
+        let aliceKey = try #require(
+            UsageStore._planUtilizationTokenAccountKeyForTesting(provider: .claude, account: alice))
+        let bobKey = try #require(
+            UsageStore._planUtilizationTokenAccountKeyForTesting(provider: .claude, account: bob))
+
+        store.settings.setActiveTokenAccountIndex(0, for: .claude)
+        store.planUtilizationHistory[.claude] = PlanUtilizationHistoryBuckets(accounts: [
+            aliceKey: [planSeries(name: .weekly, windowMinutes: 10080, entries: [
+                planEntry(at: Date(timeIntervalSince1970: 1_700_000_000), usedPercent: 20),
+            ])],
+            bobKey: [planSeries(name: .weekly, windowMinutes: 10080, entries: [
+                planEntry(at: Date(timeIntervalSince1970: 1_700_086_400), usedPercent: 50),
+            ])],
+        ])
+
+        #expect(store.planUtilizationHistory(for: .claude) == [
+            planSeries(name: .weekly, windowMinutes: 10080, entries: [
+                planEntry(at: Date(timeIntervalSince1970: 1_700_000_000), usedPercent: 20),
+            ]),
+        ])
+
+        store.settings.setActiveTokenAccountIndex(1, for: .claude)
+        #expect(store.planUtilizationHistory(for: .claude) == [
+            planSeries(name: .weekly, windowMinutes: 10080, entries: [
+                planEntry(at: Date(timeIntervalSince1970: 1_700_086_400), usedPercent: 50),
+            ]),
+        ])
+    }
+
+    @MainActor
+    @Test
+    func `fetched non selected accounts persist into separate claude buckets`() async throws {
+        let store = UsageStorePlanUtilizationTests.makeStore()
+        store.settings.addTokenAccount(provider: .claude, label: "Alice", token: "alice-token")
+        store.settings.addTokenAccount(provider: .claude, label: "Bob", token: "bob-token")
+        let accounts = store.settings.tokenAccounts(for: .claude)
+        let alice = try #require(accounts.first)
+        let bob = try #require(accounts.last)
+        let bobKey = try #require(
+            UsageStore._planUtilizationTokenAccountKeyForTesting(provider: .claude, account: bob))
+
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 20, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            tertiary: RateWindow(usedPercent: 30, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .claude,
+                accountEmail: "bob@example.com",
+                accountOrganization: nil,
+                loginMethod: "max"))
+
+        await store.recordFetchedTokenAccountPlanUtilizationHistory(
+            provider: .claude,
+            samples: [(account: bob, snapshot: snapshot)],
+            selectedAccount: alice)
+
+        let buckets = try #require(store.planUtilizationHistory[.claude])
+        let histories = try #require(buckets.accounts[bobKey])
+        #expect(findSeries(histories, name: .session, windowMinutes: 300)?.entries.last?.usedPercent == 10)
+        #expect(findSeries(histories, name: .weekly, windowMinutes: 10080)?.entries.last?.usedPercent == 20)
+        #expect(findSeries(histories, name: .opus, windowMinutes: 10080)?.entries.last?.usedPercent == 30)
+    }
+
+    @MainActor
+    @Test
+    func `first resolved claude token account adopts unscoped history`() throws {
+        let store = UsageStorePlanUtilizationTests.makeStore()
+        store.settings.addTokenAccount(provider: .claude, label: "Alice", token: "alice-token")
+        let alice = try #require(store.settings.tokenAccounts(for: .claude).first)
+        let aliceKey = try #require(
+            UsageStore._planUtilizationTokenAccountKeyForTesting(provider: .claude, account: alice))
+        let bootstrap = planSeries(name: .session, windowMinutes: 300, entries: [
+            planEntry(at: Date(timeIntervalSince1970: 1_700_000_000), usedPercent: 15),
+        ])
+        store.planUtilizationHistory[.claude] = PlanUtilizationHistoryBuckets(unscoped: [bootstrap])
+        store.settings.setActiveTokenAccountIndex(0, for: .claude)
+
+        let history = store.planUtilizationHistory(for: .claude)
+        let buckets = try #require(store.planUtilizationHistory[.claude])
+
+        #expect(history == [bootstrap])
+        #expect(buckets.unscoped.isEmpty)
+        #expect(buckets.accounts[aliceKey] == [bootstrap])
+    }
+
+    @MainActor
+    @Test
+    func `claude history without identity falls back to last resolved account`() async {
+        let store = UsageStorePlanUtilizationTests.makeStore()
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 20, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .claude,
+                accountEmail: "alice@example.com",
+                accountOrganization: nil,
+                loginMethod: "max"))
+        store._setSnapshotForTesting(snapshot, provider: .claude)
+
+        await store.recordPlanUtilizationHistorySample(
+            provider: .claude,
+            snapshot: snapshot,
+            now: Date(timeIntervalSince1970: 1_700_000_000))
+
+        let identitylessSnapshot = UsageSnapshot(
+            primary: snapshot.primary,
+            secondary: snapshot.secondary,
+            updatedAt: snapshot.updatedAt)
+        store._setSnapshotForTesting(identitylessSnapshot, provider: .claude)
+
+        let history = store.planUtilizationHistory(for: .claude)
+        #expect(findSeries(history, name: .session, windowMinutes: 300)?.entries.last?.usedPercent == 10)
+        #expect(findSeries(history, name: .weekly, windowMinutes: 10080)?.entries.last?.usedPercent == 20)
+    }
+
+    @Test
+    func `same claude email separates team and personal plan history keys`() throws {
+        let team = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .claude,
+                accountEmail: "person@example.com",
+                accountOrganization: "Team Org",
+                loginMethod: "Claude Team"))
+        let max = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .claude,
+                accountEmail: "person@example.com",
+                accountOrganization: nil,
+                loginMethod: "Claude Max"))
+
+        let teamKey = try #require(UsageStore._planUtilizationAccountKeyForTesting(provider: .claude, snapshot: team))
+        let maxKey = try #require(UsageStore._planUtilizationAccountKeyForTesting(provider: .claude, snapshot: max))
+
+        #expect(teamKey != maxKey)
+    }
+
+    @Test
+    func `claude email only identity keeps legacy history key`() throws {
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .claude,
+                accountEmail: "person@example.com",
+                accountOrganization: nil,
+                loginMethod: nil))
+
+        let identityKey = try #require(
+            UsageStore._planUtilizationAccountKeyForTesting(provider: .claude, snapshot: snapshot))
+        let legacyKey = try #require(
+            UsageStore._legacyClaudePlanUtilizationEmailAccountKeyForTesting(snapshot: snapshot))
+
+        #expect(identityKey == legacyKey)
+    }
+
+    @Test
+    func `claude compact and branded plan labels share history key`() throws {
+        let compact = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .claude,
+                accountEmail: "person@example.com",
+                accountOrganization: nil,
+                loginMethod: "Max"))
+        let branded = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .claude,
+                accountEmail: "person@example.com",
+                accountOrganization: nil,
+                loginMethod: "Claude Max"))
+
+        let compactKey = try #require(
+            UsageStore._planUtilizationAccountKeyForTesting(provider: .claude, snapshot: compact))
+        let brandedKey = try #require(
+            UsageStore._planUtilizationAccountKeyForTesting(provider: .claude, snapshot: branded))
+
+        #expect(compactKey == brandedKey)
+    }
+
+    @MainActor
+    @Test
+    func `new claude email discriminator adopts legacy email history`() throws {
+        let store = UsageStorePlanUtilizationTests.makeStore()
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .claude,
+                accountEmail: "person@example.com",
+                accountOrganization: "Team Org",
+                loginMethod: "Claude Team"))
+        let legacyKey = try #require(
+            UsageStore._legacyClaudePlanUtilizationEmailAccountKeyForTesting(snapshot: snapshot))
+        let accountKey = try #require(
+            UsageStore._planUtilizationAccountKeyForTesting(provider: .claude, snapshot: snapshot))
+        let legacyWeekly = planSeries(name: .weekly, windowMinutes: 10080, entries: [
+            planEntry(at: Date(timeIntervalSince1970: 1_700_000_000), usedPercent: 42),
+        ])
+        store.planUtilizationHistory[.claude] = PlanUtilizationHistoryBuckets(
+            preferredAccountKey: legacyKey,
+            accounts: [
+                legacyKey: [legacyWeekly],
+            ])
+        store._setSnapshotForTesting(snapshot, provider: .claude)
+
+        let history = store.planUtilizationHistory(for: .claude)
+        let buckets = try #require(store.planUtilizationHistory[.claude])
+
+        #expect(history == [legacyWeekly])
+        #expect(buckets.accounts[legacyKey] == nil)
+        #expect(buckets.accounts[accountKey] == [legacyWeekly])
+        #expect(buckets.preferredAccountKey == accountKey)
+    }
+}
diff --git a/Tests/CodexBarTests/UsageStorePlanUtilizationCodexOwnershipTests.swift b/Tests/CodexBarTests/UsageStorePlanUtilizationCodexOwnershipTests.swift
new file mode 100644
index 0000000000..cdd97b835a
--- /dev/null
+++ b/Tests/CodexBarTests/UsageStorePlanUtilizationCodexOwnershipTests.swift
@@ -0,0 +1,582 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct UsageStorePlanUtilizationCodexOwnershipTests {
+    @MainActor
+    @Test
+    func `codex plan history aliases pre-upgrade codex email hash bucket into canonical email hash`() throws {
+        let store = UsageStorePlanUtilizationTests.makeStore()
+        let snapshot = UsageStorePlanUtilizationTests.makeSnapshot(provider: .codex, email: "alice@example.com")
+        let canonicalKey = try #require(
+            UsageStore._planUtilizationAccountKeyForTesting(
+                provider: .codex,
+                snapshot: snapshot))
+        let legacyEmailHash = UsageStore._codexLegacyPlanUtilizationEmailHashKeyForTesting(
+            normalizedEmail: "alice@example.com")
+        let weekly = planSeries(name: .weekly, windowMinutes: 10080, entries: [
+            planEntry(at: Date(timeIntervalSince1970: 1_700_000_000), usedPercent: 20),
+        ])
+
+        store.planUtilizationHistory[.codex] = PlanUtilizationHistoryBuckets(accounts: [
+            legacyEmailHash: [weekly],
+        ])
+        store._setSnapshotForTesting(snapshot, provider: .codex)
+
+        let history = store.planUtilizationHistory(for: .codex)
+        let buckets = try #require(store.planUtilizationHistory[.codex])
+
+        #expect(buckets.preferredAccountKey == canonicalKey)
+        #expect(history == [weekly])
+        #expect(buckets.accounts[canonicalKey] == [weekly])
+        #expect(buckets.accounts[legacyEmailHash] == nil)
+    }
+
+    @MainActor
+    @Test
+    func `codex strict continuity adopts unscoped only when there is one owner`() throws {
+        let store = UsageStorePlanUtilizationTests.makeStore()
+        let snapshot = UsageStorePlanUtilizationTests.makeSnapshot(provider: .codex, email: "alice@example.com")
+        let canonicalKey = try #require(
+            UsageStore._planUtilizationAccountKeyForTesting(
+                provider: .codex,
+                snapshot: snapshot))
+        let legacyEmailHash = UsageStore._codexLegacyPlanUtilizationEmailHashKeyForTesting(
+            normalizedEmail: "alice@example.com")
+        let bootstrap = planSeries(name: .session, windowMinutes: 300, entries: [
+            planEntry(at: Date(timeIntervalSince1970: 1_699_913_600), usedPercent: 15),
+        ])
+        let weekly = planSeries(name: .weekly, windowMinutes: 10080, entries: [
+            planEntry(at: Date(timeIntervalSince1970: 1_700_000_000), usedPercent: 20),
+        ])
+
+        store.planUtilizationHistory[.codex] = PlanUtilizationHistoryBuckets(
+            unscoped: [bootstrap],
+            accounts: [
+                legacyEmailHash: [weekly],
+            ])
+        store._setSnapshotForTesting(snapshot, provider: .codex)
+
+        let history = store.planUtilizationHistory(for: .codex)
+        let buckets = try #require(store.planUtilizationHistory[.codex])
+
+        #expect(buckets.preferredAccountKey == canonicalKey)
+        #expect(history == [bootstrap, weekly])
+        #expect(buckets.unscoped.isEmpty)
+        #expect(buckets.accounts[canonicalKey] == [bootstrap, weekly])
+        #expect(buckets.accounts[legacyEmailHash] == nil)
+    }
+
+    @MainActor
+    @Test
+    func `codex strict continuity ignores later unrelated owners outside the unscoped period`() throws {
+        let store = UsageStorePlanUtilizationTests.makeStore()
+        let snapshot = UsageStorePlanUtilizationTests.makeSnapshot(provider: .codex, email: "alice@example.com")
+        let canonicalKey = try #require(
+            UsageStore._planUtilizationAccountKeyForTesting(
+                provider: .codex,
+                snapshot: snapshot))
+        let legacyEmailHash = UsageStore._codexLegacyPlanUtilizationEmailHashKeyForTesting(
+            normalizedEmail: "alice@example.com")
+        let laterOtherKey = "codex:v1:provider-account:acct-later"
+        let bootstrap = planSeries(name: .session, windowMinutes: 300, entries: [
+            planEntry(at: Date(timeIntervalSince1970: 1_699_913_600), usedPercent: 15),
+        ])
+        let weekly = planSeries(name: .weekly, windowMinutes: 10080, entries: [
+            planEntry(at: Date(timeIntervalSince1970: 1_700_000_000), usedPercent: 20),
+        ])
+        let laterWeekly = planSeries(name: .weekly, windowMinutes: 10080, entries: [
+            planEntry(at: Date(timeIntervalSince1970: 1_701_900_000), usedPercent: 35),
+        ])
+
+        store.planUtilizationHistory[.codex] = PlanUtilizationHistoryBuckets(
+            unscoped: [bootstrap],
+            accounts: [
+                legacyEmailHash: [weekly],
+                laterOtherKey: [laterWeekly],
+            ])
+        store._setSnapshotForTesting(snapshot, provider: .codex)
+
+        let history = store.planUtilizationHistory(for: .codex)
+        let buckets = try #require(store.planUtilizationHistory[.codex])
+
+        #expect(buckets.preferredAccountKey == canonicalKey)
+        #expect(history == [bootstrap, weekly])
+        #expect(buckets.unscoped.isEmpty)
+        #expect(buckets.accounts[canonicalKey] == [bootstrap, weekly])
+        #expect(buckets.accounts[laterOtherKey] == [laterWeekly])
+    }
+
+    @MainActor
+    @Test
+    func `codex real fixture carries local opaque weekly continuity into provider account`() throws {
+        let store = UsageStorePlanUtilizationTests.makeStore()
+        let formatter = ISO8601DateFormatter()
+        let providerAccountKey = try #require(CodexHistoryOwnership.canonicalKey(for: .providerAccount(
+            id: "0c2a5eef-a612-45bb-9796-9aa83ce1bed7")))
+        let legacyEmailHash = UsageStore._codexLegacyPlanUtilizationEmailHashKeyForTesting(
+            normalizedEmail: "ratulsarna@gmail.com")
+        let canonicalEmailHashKey = CodexHistoryOwnership.canonicalEmailHashKey(for: "ratulsarna@gmail.com")
+        let opaqueKey = "3e31a7fdc57ea26c62fd7061d25dcab74a91b0da2d8f514b07e99aad800ee897"
+        let weeklyResetAt = try #require(ISO8601DateFormatter().date(from: "2026-04-08T07:57:12Z"))
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: 12,
+                windowMinutes: 10080,
+                resetsAt: weeklyResetAt,
+                resetDescription: nil),
+            updatedAt: weeklyResetAt,
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: "ratulsarna@gmail.com",
+                accountOrganization: nil,
+                loginMethod: "plus"))
+
+        store.planUtilizationHistory[.codex] = try UsageStorePlanUtilizationTests.loadPlanUtilizationFixture(
+            named: "codex-plan-utilization-real-migration.json")
+        store.settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "ratulsarna@gmail.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: weeklyResetAt,
+            identity: .providerAccount(id: "0c2a5eef-a612-45bb-9796-9aa83ce1bed7"))
+        defer { store.settings._test_liveSystemCodexAccount = nil }
+        store._setSnapshotForTesting(snapshot, provider: .codex)
+
+        let history = store.planUtilizationHistory(for: .codex)
+        let buckets = try #require(store.planUtilizationHistory[.codex])
+        let weekly = try #require(findSeries(history, name: .weekly, windowMinutes: 10080))
+        let session = try #require(findSeries(history, name: .session, windowMinutes: 300))
+        let expectedOldestWeekly = try #require(formatter.date(from: "2026-03-23T09:55:44Z"))
+        let expectedNewestWeekly = try #require(formatter.date(from: "2026-04-01T20:33:41Z"))
+
+        #expect(buckets.preferredAccountKey == providerAccountKey)
+        #expect(weekly.entries.first?.capturedAt == expectedOldestWeekly)
+        #expect(weekly.entries.last?.capturedAt == expectedNewestWeekly)
+        #expect(session.entries.first?.capturedAt == expectedOldestWeekly)
+        #expect(buckets.accounts[providerAccountKey] == history)
+        #expect(buckets.accounts[opaqueKey] == nil)
+        #expect(buckets.accounts[legacyEmailHash] == nil)
+        #expect(buckets.accounts[canonicalEmailHashKey] == nil)
+    }
+
+    @MainActor
+    @Test
+    func `codex real fixture keeps opaque history separate when multiple opaque candidates could match`() throws {
+        let store = UsageStorePlanUtilizationTests.makeStore()
+        let formatter = ISO8601DateFormatter()
+        let providerAccountKey = try #require(CodexHistoryOwnership.canonicalKey(for: .providerAccount(
+            id: "0c2a5eef-a612-45bb-9796-9aa83ce1bed7")))
+        let originalOpaqueKey = "3e31a7fdc57ea26c62fd7061d25dcab74a91b0da2d8f514b07e99aad800ee897"
+        let duplicateOpaqueKey = "legacy-codex-opaque-duplicate"
+        let weeklyResetAt = try #require(ISO8601DateFormatter().date(from: "2026-04-08T07:57:12Z"))
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: 12,
+                windowMinutes: 10080,
+                resetsAt: weeklyResetAt,
+                resetDescription: nil),
+            updatedAt: weeklyResetAt,
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: "ratulsarna@gmail.com",
+                accountOrganization: nil,
+                loginMethod: "plus"))
+
+        var fixture = try UsageStorePlanUtilizationTests.loadPlanUtilizationFixture(
+            named: "codex-plan-utilization-real-migration.json")
+        fixture.accounts[duplicateOpaqueKey] = fixture.accounts[originalOpaqueKey]
+        store.planUtilizationHistory[.codex] = fixture
+        store.settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "ratulsarna@gmail.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: weeklyResetAt,
+            identity: .providerAccount(id: "0c2a5eef-a612-45bb-9796-9aa83ce1bed7"))
+        defer { store.settings._test_liveSystemCodexAccount = nil }
+        store._setSnapshotForTesting(snapshot, provider: .codex)
+
+        let history = store.planUtilizationHistory(for: .codex)
+        let buckets = try #require(store.planUtilizationHistory[.codex])
+        let weekly = try #require(findSeries(history, name: .weekly, windowMinutes: 10080))
+        let expectedNonOpaqueStart = try #require(formatter.date(from: "2026-03-28T06:50:16Z"))
+
+        #expect(buckets.preferredAccountKey == providerAccountKey)
+        #expect(weekly.entries.first?.capturedAt == expectedNonOpaqueStart)
+        #expect(buckets.accounts[originalOpaqueKey] != nil)
+        #expect(buckets.accounts[duplicateOpaqueKey] != nil)
+    }
+
+    @MainActor
+    @Test
+    func `codex real fixture keeps opaque history separate when overlapping non target owner exists`() throws {
+        let store = UsageStorePlanUtilizationTests.makeStore()
+        let formatter = ISO8601DateFormatter()
+        let providerAccountKey = try #require(CodexHistoryOwnership.canonicalKey(for: .providerAccount(
+            id: "0c2a5eef-a612-45bb-9796-9aa83ce1bed7")))
+        let opaqueKey = "3e31a7fdc57ea26c62fd7061d25dcab74a91b0da2d8f514b07e99aad800ee897"
+        let overlappingOtherKey = "codex:v1:provider-account:acct-other"
+        let weeklyResetAt = try #require(formatter.date(from: "2026-04-08T07:57:12Z"))
+        let expectedNonOpaqueStart = try #require(formatter.date(from: "2026-03-28T06:50:16Z"))
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: 12,
+                windowMinutes: 10080,
+                resetsAt: weeklyResetAt,
+                resetDescription: nil),
+            updatedAt: weeklyResetAt,
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: "ratulsarna@gmail.com",
+                accountOrganization: nil,
+                loginMethod: "plus"))
+
+        let overlappingCapturedAt = try #require(formatter.date(from: "2026-03-30T12:00:00Z"))
+        var fixture = try UsageStorePlanUtilizationTests.loadPlanUtilizationFixture(
+            named: "codex-plan-utilization-real-migration.json")
+        fixture.accounts[overlappingOtherKey] = [
+            planSeries(name: .weekly, windowMinutes: 10080, entries: [
+                planEntry(
+                    at: overlappingCapturedAt,
+                    usedPercent: 35,
+                    resetsAt: weeklyResetAt),
+            ]),
+        ]
+        store.planUtilizationHistory[.codex] = fixture
+        store.settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "ratulsarna@gmail.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: weeklyResetAt,
+            identity: .providerAccount(id: "0c2a5eef-a612-45bb-9796-9aa83ce1bed7"))
+        defer { store.settings._test_liveSystemCodexAccount = nil }
+        store._setSnapshotForTesting(snapshot, provider: .codex)
+
+        let history = store.planUtilizationHistory(for: .codex)
+        let buckets = try #require(store.planUtilizationHistory[.codex])
+        let weekly = try #require(findSeries(history, name: .weekly, windowMinutes: 10080))
+
+        #expect(buckets.preferredAccountKey == providerAccountKey)
+        #expect(weekly.entries.first?.capturedAt == expectedNonOpaqueStart)
+        #expect(buckets.accounts[opaqueKey] != nil)
+        #expect(buckets.accounts[overlappingOtherKey] != nil)
+    }
+
+    @MainActor
+    @Test
+    func `codex opaque recovery uses normalized dashboard weekly reset when snapshot has only session window`() throws {
+        let store = UsageStorePlanUtilizationTests.makeStore()
+        let formatter = ISO8601DateFormatter()
+        let providerAccountKey = try #require(CodexHistoryOwnership.canonicalKey(for: .providerAccount(
+            id: "0c2a5eef-a612-45bb-9796-9aa83ce1bed7")))
+        let opaqueKey = "3e31a7fdc57ea26c62fd7061d25dcab74a91b0da2d8f514b07e99aad800ee897"
+        let weeklyResetAt = try #require(formatter.date(from: "2026-04-08T07:57:12Z"))
+        let expectedOpaqueStart = try #require(formatter.date(from: "2026-03-23T09:55:44Z"))
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: weeklyResetAt,
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: "ratulsarna@gmail.com",
+                accountOrganization: nil,
+                loginMethod: "plus"))
+
+        store.planUtilizationHistory[.codex] = try UsageStorePlanUtilizationTests.loadPlanUtilizationFixture(
+            named: "codex-plan-utilization-real-migration.json")
+        store.openAIDashboard = OpenAIDashboardSnapshot(
+            signedInEmail: "ratulsarna@gmail.com",
+            codeReviewRemainingPercent: nil,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            primaryLimit: RateWindow(
+                usedPercent: 12,
+                windowMinutes: 10080,
+                resetsAt: weeklyResetAt,
+                resetDescription: nil),
+            secondaryLimit: nil,
+            creditsRemaining: nil,
+            accountPlan: "plus",
+            updatedAt: weeklyResetAt)
+        store.openAIDashboardAttachmentAuthorized = true
+        store.settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "ratulsarna@gmail.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: weeklyResetAt,
+            identity: .providerAccount(id: "0c2a5eef-a612-45bb-9796-9aa83ce1bed7"))
+        defer { store.settings._test_liveSystemCodexAccount = nil }
+        store._setSnapshotForTesting(snapshot, provider: .codex)
+
+        let history = store.planUtilizationHistory(for: .codex)
+        let buckets = try #require(store.planUtilizationHistory[.codex])
+        let weekly = try #require(findSeries(history, name: .weekly, windowMinutes: 10080))
+
+        #expect(buckets.preferredAccountKey == providerAccountKey)
+        #expect(weekly.entries.first?.capturedAt == expectedOpaqueStart)
+        #expect(buckets.accounts[opaqueKey] == nil)
+    }
+
+    @MainActor
+    @Test
+    func `codex display only dashboard does not drive opaque recovery when snapshot has only session window`() throws {
+        let store = UsageStorePlanUtilizationTests.makeStore()
+        let formatter = ISO8601DateFormatter()
+        let providerAccountKey = try #require(CodexHistoryOwnership.canonicalKey(for: .providerAccount(
+            id: "0c2a5eef-a612-45bb-9796-9aa83ce1bed7")))
+        let opaqueKey = "3e31a7fdc57ea26c62fd7061d25dcab74a91b0da2d8f514b07e99aad800ee897"
+        let weeklyResetAt = try #require(formatter.date(from: "2026-04-08T07:57:12Z"))
+        let expectedNonOpaqueStart = try #require(formatter.date(from: "2026-03-28T06:50:16Z"))
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: weeklyResetAt,
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: "ratulsarna@gmail.com",
+                accountOrganization: nil,
+                loginMethod: "plus"))
+
+        store.planUtilizationHistory[.codex] = try UsageStorePlanUtilizationTests.loadPlanUtilizationFixture(
+            named: "codex-plan-utilization-real-migration.json")
+        store.openAIDashboard = OpenAIDashboardSnapshot(
+            signedInEmail: "ratulsarna@gmail.com",
+            codeReviewRemainingPercent: nil,
+            creditEvents: [],
+            dailyBreakdown: [],
+            usageBreakdown: [],
+            creditsPurchaseURL: nil,
+            primaryLimit: RateWindow(
+                usedPercent: 12,
+                windowMinutes: 10080,
+                resetsAt: weeklyResetAt,
+                resetDescription: nil),
+            secondaryLimit: nil,
+            creditsRemaining: nil,
+            accountPlan: "plus",
+            updatedAt: weeklyResetAt)
+        store.openAIDashboardAttachmentAuthorized = false
+        store.settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "ratulsarna@gmail.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: weeklyResetAt,
+            identity: .providerAccount(id: "0c2a5eef-a612-45bb-9796-9aa83ce1bed7"))
+        defer { store.settings._test_liveSystemCodexAccount = nil }
+        store._setSnapshotForTesting(snapshot, provider: .codex)
+
+        let history = store.planUtilizationHistory(for: .codex)
+        let buckets = try #require(store.planUtilizationHistory[.codex])
+        let weekly = try #require(findSeries(history, name: .weekly, windowMinutes: 10080))
+
+        #expect(buckets.preferredAccountKey == providerAccountKey)
+        #expect(weekly.entries.first?.capturedAt == expectedNonOpaqueStart)
+        #expect(buckets.accounts[opaqueKey] != nil)
+    }
+
+    @MainActor
+    @Test
+    func `codex adjacent managed and live accounts veto unscoped adoption`() throws {
+        let store = UsageStorePlanUtilizationTests.makeStore()
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-codex-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let snapshot = UsageStorePlanUtilizationTests.makeSnapshot(provider: .codex, email: managedAccount.email)
+        let canonicalKey = try #require(
+            UsageStore._planUtilizationAccountKeyForTesting(
+                provider: .codex,
+                snapshot: snapshot))
+        let legacyEmailHash = UsageStore._codexLegacyPlanUtilizationEmailHashKeyForTesting(
+            normalizedEmail: managedAccount.email)
+        let bootstrap = planSeries(name: .session, windowMinutes: 300, entries: [
+            planEntry(at: Date(timeIntervalSince1970: 1_699_913_600), usedPercent: 15),
+        ])
+        let weekly = planSeries(name: .weekly, windowMinutes: 10080, entries: [
+            planEntry(at: Date(timeIntervalSince1970: 1_700_000_000), usedPercent: 20),
+        ])
+
+        store.planUtilizationHistory[.codex] = PlanUtilizationHistoryBuckets(
+            unscoped: [bootstrap],
+            accounts: [
+                legacyEmailHash: [weekly],
+            ])
+        store.settings._test_activeManagedCodexAccount = managedAccount
+        store.settings.codexActiveSource = .managedAccount(id: managedAccount.id)
+        store.settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "live@example.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .providerAccount(id: "live-acct"))
+        defer {
+            store.settings._test_activeManagedCodexAccount = nil
+            store.settings._test_liveSystemCodexAccount = nil
+            store.settings.codexActiveSource = .liveSystem
+        }
+        store._setSnapshotForTesting(snapshot, provider: .codex)
+
+        let history = store.planUtilizationHistory(for: .codex)
+        let buckets = try #require(store.planUtilizationHistory[.codex])
+
+        #expect(history == [weekly])
+        #expect(buckets.unscoped == [bootstrap])
+        #expect(buckets.accounts[canonicalKey] == [weekly])
+    }
+
+    @MainActor
+    @Test
+    func `codex extra saved managed accounts do not veto active account adoption`() throws {
+        let store = UsageStorePlanUtilizationTests.makeStore()
+        let activeManagedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-codex-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let inactiveManagedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "other@example.com",
+            managedHomePath: "/tmp/other-codex-home",
+            createdAt: 2,
+            updatedAt: 2,
+            lastAuthenticatedAt: 2)
+        let managedStoreURL = try #require(store.settings._test_managedCodexAccountStoreURL)
+        let managedStore = FileManagedCodexAccountStore(fileURL: managedStoreURL)
+        try managedStore.storeAccounts(ManagedCodexAccountSet(
+            version: FileManagedCodexAccountStore.currentVersion,
+            accounts: [activeManagedAccount, inactiveManagedAccount]))
+        let snapshot = UsageStorePlanUtilizationTests.makeSnapshot(provider: .codex, email: activeManagedAccount.email)
+        let canonicalKey = try #require(
+            UsageStore._planUtilizationAccountKeyForTesting(
+                provider: .codex,
+                snapshot: snapshot))
+        let legacyEmailHash = UsageStore._codexLegacyPlanUtilizationEmailHashKeyForTesting(
+            normalizedEmail: activeManagedAccount.email)
+        let bootstrap = planSeries(name: .session, windowMinutes: 300, entries: [
+            planEntry(at: Date(timeIntervalSince1970: 1_699_913_600), usedPercent: 15),
+        ])
+        let weekly = planSeries(name: .weekly, windowMinutes: 10080, entries: [
+            planEntry(at: Date(timeIntervalSince1970: 1_700_000_000), usedPercent: 20),
+        ])
+
+        store.planUtilizationHistory[.codex] = PlanUtilizationHistoryBuckets(
+            unscoped: [bootstrap],
+            accounts: [
+                legacyEmailHash: [weekly],
+            ])
+        store.settings._test_activeManagedCodexAccount = activeManagedAccount
+        store.settings.codexActiveSource = .managedAccount(id: activeManagedAccount.id)
+        defer {
+            store.settings._test_activeManagedCodexAccount = nil
+            store.settings.codexActiveSource = .liveSystem
+        }
+        store._setSnapshotForTesting(snapshot, provider: .codex)
+
+        let history = store.planUtilizationHistory(for: .codex)
+        let buckets = try #require(store.planUtilizationHistory[.codex])
+
+        #expect(history == [bootstrap, weekly])
+        #expect(buckets.unscoped.isEmpty)
+        #expect(buckets.accounts[canonicalKey] == [bootstrap, weekly])
+    }
+
+    @MainActor
+    @Test
+    func `codex inactive managed accounts do not veto live opaque recovery`() throws {
+        let store = UsageStorePlanUtilizationTests.makeStore()
+        let formatter = ISO8601DateFormatter()
+        let providerAccountKey = try #require(CodexHistoryOwnership.canonicalKey(for: .providerAccount(
+            id: "0c2a5eef-a612-45bb-9796-9aa83ce1bed7")))
+        let managedAccount = ManagedCodexAccount(
+            id: UUID(),
+            email: "managed@example.com",
+            managedHomePath: "/tmp/managed-codex-home",
+            createdAt: 1,
+            updatedAt: 1,
+            lastAuthenticatedAt: 1)
+        let opaqueKey = "3e31a7fdc57ea26c62fd7061d25dcab74a91b0da2d8f514b07e99aad800ee897"
+        let weeklyResetAt = try #require(formatter.date(from: "2026-04-08T07:57:12Z"))
+        let expectedOpaqueStart = try #require(formatter.date(from: "2026-03-23T09:55:44Z"))
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: 12,
+                windowMinutes: 10080,
+                resetsAt: weeklyResetAt,
+                resetDescription: nil),
+            updatedAt: weeklyResetAt,
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: "ratulsarna@gmail.com",
+                accountOrganization: nil,
+                loginMethod: "plus"))
+
+        store.planUtilizationHistory[.codex] = try UsageStorePlanUtilizationTests.loadPlanUtilizationFixture(
+            named: "codex-plan-utilization-real-migration.json")
+        store.settings._test_activeManagedCodexAccount = managedAccount
+        store.settings.codexActiveSource = .liveSystem
+        store.settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: "ratulsarna@gmail.com",
+            codexHomePath: "/Users/test/.codex",
+            observedAt: weeklyResetAt,
+            identity: .providerAccount(id: "0c2a5eef-a612-45bb-9796-9aa83ce1bed7"))
+        defer {
+            store.settings._test_activeManagedCodexAccount = nil
+            store.settings._test_liveSystemCodexAccount = nil
+        }
+        store._setSnapshotForTesting(snapshot, provider: .codex)
+
+        let history = store.planUtilizationHistory(for: .codex)
+        let buckets = try #require(store.planUtilizationHistory[.codex])
+        let weekly = try #require(findSeries(history, name: .weekly, windowMinutes: 10080))
+
+        #expect(buckets.preferredAccountKey == providerAccountKey)
+        #expect(weekly.entries.first?.capturedAt == expectedOpaqueStart)
+        #expect(buckets.accounts[opaqueKey] == nil)
+    }
+
+    @MainActor
+    @Test
+    func `codex provider account continuity absorbs matching email scoped history`() throws {
+        let store = UsageStorePlanUtilizationTests.makeStore()
+        let normalizedEmail = "alice@example.com"
+        let snapshot = UsageStorePlanUtilizationTests.makeSnapshot(provider: .codex, email: normalizedEmail)
+        let providerAccountKey = try #require(
+            CodexHistoryOwnership.canonicalKey(for: .providerAccount(id: "live-acct")))
+        let canonicalEmailHashKey = CodexHistoryOwnership.canonicalEmailHashKey(for: normalizedEmail)
+        let legacyEmailHash = UsageStore._codexLegacyPlanUtilizationEmailHashKeyForTesting(
+            normalizedEmail: normalizedEmail)
+        let session = planSeries(name: .session, windowMinutes: 300, entries: [
+            planEntry(at: Date(timeIntervalSince1970: 1_699_913_600), usedPercent: 15),
+        ])
+        let weekly = planSeries(name: .weekly, windowMinutes: 10080, entries: [
+            planEntry(at: Date(timeIntervalSince1970: 1_700_000_000), usedPercent: 20),
+        ])
+
+        store.planUtilizationHistory[.codex] = PlanUtilizationHistoryBuckets(accounts: [
+            canonicalEmailHashKey: [session],
+            legacyEmailHash: [weekly],
+        ])
+        store.settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(
+            email: normalizedEmail,
+            codexHomePath: "/Users/test/.codex",
+            observedAt: Date(),
+            identity: .providerAccount(id: "live-acct"))
+        defer { store.settings._test_liveSystemCodexAccount = nil }
+        store._setSnapshotForTesting(snapshot, provider: .codex)
+
+        let history = store.planUtilizationHistory(for: .codex)
+        let buckets = try #require(store.planUtilizationHistory[.codex])
+
+        #expect(buckets.preferredAccountKey == providerAccountKey)
+        #expect(history == [session, weekly])
+        #expect(buckets.accounts[providerAccountKey] == [session, weekly])
+        #expect(buckets.accounts[canonicalEmailHashKey] == nil)
+        #expect(buckets.accounts[legacyEmailHash] == nil)
+    }
+}
diff --git a/Tests/CodexBarTests/UsageStorePlanUtilizationDerivedChartTests.swift b/Tests/CodexBarTests/UsageStorePlanUtilizationDerivedChartTests.swift
new file mode 100644
index 0000000000..96327c78a2
--- /dev/null
+++ b/Tests/CodexBarTests/UsageStorePlanUtilizationDerivedChartTests.swift
@@ -0,0 +1,55 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct UsageStorePlanUtilizationDerivedChartTests {
+    @MainActor
+    @Test
+    func `chart uses requested native series without cross series selection`() {
+        let firstBoundary = Date(timeIntervalSince1970: 1_710_000_000)
+        let secondBoundary = firstBoundary.addingTimeInterval(7 * 24 * 60 * 60)
+        let histories = [
+            planSeries(name: .session, windowMinutes: 300, entries: [
+                planEntry(at: firstBoundary.addingTimeInterval(-30 * 60), usedPercent: 20, resetsAt: firstBoundary),
+            ]),
+            planSeries(name: .weekly, windowMinutes: 10080, entries: [
+                planEntry(at: firstBoundary.addingTimeInterval(-30 * 60), usedPercent: 62, resetsAt: firstBoundary),
+                planEntry(at: secondBoundary.addingTimeInterval(-30 * 60), usedPercent: 48, resetsAt: secondBoundary),
+            ]),
+        ]
+
+        let model = PlanUtilizationHistoryChartMenuView._modelSnapshotForTesting(
+            selectedSeriesRawValue: "weekly:10080",
+            histories: histories,
+            provider: .codex,
+            referenceDate: secondBoundary)
+
+        #expect(model.selectedSeries == "weekly:10080")
+        #expect(model.usedPercents == [62, 48])
+    }
+
+    @MainActor
+    @Test
+    func `chart exposes claude opus as separate native tab`() {
+        let boundary = Date(timeIntervalSince1970: 1_710_000_000)
+        let histories = [
+            planSeries(name: .session, windowMinutes: 300, entries: [
+                planEntry(at: boundary.addingTimeInterval(-30 * 60), usedPercent: 10, resetsAt: boundary),
+            ]),
+            planSeries(name: .weekly, windowMinutes: 10080, entries: [
+                planEntry(at: boundary.addingTimeInterval(-30 * 60), usedPercent: 20, resetsAt: boundary),
+            ]),
+            planSeries(name: .opus, windowMinutes: 10080, entries: [
+                planEntry(at: boundary.addingTimeInterval(-30 * 60), usedPercent: 30, resetsAt: boundary),
+            ]),
+        ]
+
+        let model = PlanUtilizationHistoryChartMenuView._modelSnapshotForTesting(
+            histories: histories,
+            provider: .claude,
+            referenceDate: boundary)
+
+        #expect(model.visibleSeries == ["session:300", "weekly:10080", "opus:10080"])
+    }
+}
diff --git a/Tests/CodexBarTests/UsageStorePlanUtilizationExactFitResetTests.swift b/Tests/CodexBarTests/UsageStorePlanUtilizationExactFitResetTests.swift
new file mode 100644
index 0000000000..ac6d69f3f3
--- /dev/null
+++ b/Tests/CodexBarTests/UsageStorePlanUtilizationExactFitResetTests.swift
@@ -0,0 +1,227 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct UsageStorePlanUtilizationExactFitResetTests {
+    @MainActor
+    @Test
+    func `weekly chart uses reset date as bar date`() {
+        let firstBoundary = Date(timeIntervalSince1970: 1_710_000_000)
+        let secondBoundary = firstBoundary.addingTimeInterval(7 * 24 * 60 * 60)
+        let thirdBoundary = secondBoundary.addingTimeInterval(7 * 24 * 60 * 60)
+        let histories = [
+            planSeries(name: .weekly, windowMinutes: 10080, entries: [
+                planEntry(at: firstBoundary.addingTimeInterval(-30 * 60), usedPercent: 62, resetsAt: firstBoundary),
+                planEntry(at: secondBoundary.addingTimeInterval(-30 * 60), usedPercent: 48, resetsAt: secondBoundary),
+                planEntry(at: thirdBoundary.addingTimeInterval(-30 * 60), usedPercent: 20, resetsAt: thirdBoundary),
+            ]),
+        ]
+
+        let model = PlanUtilizationHistoryChartMenuView._modelSnapshotForTesting(
+            selectedSeriesRawValue: "weekly:10080",
+            histories: histories,
+            provider: .codex,
+            referenceDate: thirdBoundary)
+
+        #expect(model.usedPercents == [62, 48, 20])
+        #expect(model.pointDates == [
+            formattedBoundary(firstBoundary),
+            formattedBoundary(secondBoundary),
+            formattedBoundary(thirdBoundary),
+        ])
+    }
+
+    @MainActor
+    @Test
+    func `chart keeps maximum usage for each effective period`() {
+        let firstBoundary = Date(timeIntervalSince1970: 1_710_000_000)
+        let secondBoundary = firstBoundary.addingTimeInterval(5 * 60 * 60)
+        let histories = [
+            planSeries(name: .session, windowMinutes: 300, entries: [
+                planEntry(at: firstBoundary.addingTimeInterval(-50 * 60), usedPercent: 22, resetsAt: firstBoundary),
+                planEntry(
+                    at: firstBoundary.addingTimeInterval(-20 * 60),
+                    usedPercent: 61,
+                    resetsAt: firstBoundary.addingTimeInterval(75)),
+                planEntry(at: secondBoundary.addingTimeInterval(-30 * 60), usedPercent: 18, resetsAt: secondBoundary),
+            ]),
+        ]
+
+        let model = PlanUtilizationHistoryChartMenuView._modelSnapshotForTesting(
+            selectedSeriesRawValue: "session:300",
+            histories: histories,
+            provider: .codex,
+            referenceDate: secondBoundary)
+
+        #expect(model.usedPercents == [61, 18])
+        #expect(model.pointDates == [
+            formattedBoundary(firstBoundary.addingTimeInterval(75)),
+            formattedBoundary(secondBoundary),
+        ])
+    }
+
+    @MainActor
+    @Test
+    func `chart prefers reset backed entry when usage ties within period`() {
+        let boundary = Date(timeIntervalSince1970: 1_710_000_000)
+        let histories = [
+            planSeries(name: .session, windowMinutes: 300, entries: [
+                planEntry(at: boundary.addingTimeInterval(-55 * 60), usedPercent: 48),
+                planEntry(at: boundary.addingTimeInterval(-20 * 60), usedPercent: 48, resetsAt: boundary),
+            ]),
+        ]
+
+        let model = PlanUtilizationHistoryChartMenuView._modelSnapshotForTesting(
+            selectedSeriesRawValue: "session:300",
+            histories: histories,
+            provider: .codex,
+            referenceDate: boundary)
+
+        #expect(model.usedPercents == [48])
+        #expect(model.pointDates == [formattedBoundary(boundary)])
+    }
+
+    @MainActor
+    @Test
+    func `chart adds synthetic current bar when current period has no observation`() {
+        let firstBoundary = Date(timeIntervalSince1970: 1_710_000_000)
+        let currentBoundary = firstBoundary.addingTimeInterval(10 * 60 * 60)
+        let referenceDate = currentBoundary.addingTimeInterval(-30 * 60)
+        let histories = [
+            planSeries(name: .session, windowMinutes: 300, entries: [
+                planEntry(at: firstBoundary.addingTimeInterval(-30 * 60), usedPercent: 62, resetsAt: firstBoundary),
+            ]),
+        ]
+
+        let model = PlanUtilizationHistoryChartMenuView._modelSnapshotForTesting(
+            selectedSeriesRawValue: "session:300",
+            histories: histories,
+            provider: .codex,
+            referenceDate: referenceDate)
+
+        #expect(model.usedPercents == [62, 0, 0])
+        #expect(model.pointDates == [
+            formattedBoundary(firstBoundary),
+            formattedBoundary(firstBoundary.addingTimeInterval(5 * 60 * 60)),
+            formattedBoundary(currentBoundary),
+        ])
+    }
+
+    @MainActor
+    @Test
+    func `weekly chart shows zero bars for missing reset periods`() {
+        let firstBoundary = Date(timeIntervalSince1970: 1_710_000_000)
+        let secondBoundary = firstBoundary.addingTimeInterval(7 * 24 * 60 * 60)
+        let fourthBoundary = secondBoundary.addingTimeInterval(14 * 24 * 60 * 60)
+        let histories = [
+            planSeries(name: .weekly, windowMinutes: 10080, entries: [
+                planEntry(at: firstBoundary.addingTimeInterval(-30 * 60), usedPercent: 62, resetsAt: firstBoundary),
+                planEntry(at: secondBoundary.addingTimeInterval(-30 * 60), usedPercent: 48, resetsAt: secondBoundary),
+                planEntry(at: fourthBoundary.addingTimeInterval(-30 * 60), usedPercent: 20, resetsAt: fourthBoundary),
+            ]),
+        ]
+
+        let model = PlanUtilizationHistoryChartMenuView._modelSnapshotForTesting(
+            selectedSeriesRawValue: "weekly:10080",
+            histories: histories,
+            provider: .codex,
+            referenceDate: fourthBoundary)
+
+        #expect(model.usedPercents == [62, 48, 0, 20])
+    }
+
+    @MainActor
+    @Test
+    func `weekly chart starts axis labels from first bar`() {
+        let firstBoundary = Date(timeIntervalSince1970: 1_710_000_000)
+        let secondBoundary = firstBoundary.addingTimeInterval(7 * 24 * 60 * 60)
+        let thirdBoundary = secondBoundary.addingTimeInterval(7 * 24 * 60 * 60)
+        let fourthBoundary = thirdBoundary.addingTimeInterval(7 * 24 * 60 * 60)
+        let histories = [
+            planSeries(name: .weekly, windowMinutes: 10080, entries: [
+                planEntry(at: firstBoundary.addingTimeInterval(-30 * 60), usedPercent: 62, resetsAt: firstBoundary),
+                planEntry(at: secondBoundary.addingTimeInterval(-30 * 60), usedPercent: 48, resetsAt: secondBoundary),
+                planEntry(at: thirdBoundary.addingTimeInterval(-30 * 60), usedPercent: 20, resetsAt: thirdBoundary),
+                planEntry(at: fourthBoundary.addingTimeInterval(-30 * 60), usedPercent: 15, resetsAt: fourthBoundary),
+            ]),
+        ]
+
+        let model = PlanUtilizationHistoryChartMenuView._modelSnapshotForTesting(
+            selectedSeriesRawValue: "weekly:10080",
+            histories: histories,
+            provider: .codex,
+            referenceDate: fourthBoundary)
+
+        #expect(model.axisIndexes == [0])
+    }
+
+    @MainActor
+    @Test
+    func `weekly chart keeps observed current boundary when reset times drift slightly`() {
+        let firstBoundary = Date(timeIntervalSince1970: 1_710_000_055)
+        let secondBoundary = firstBoundary.addingTimeInterval(7 * 24 * 60 * 60 + 88)
+        let histories = [
+            planSeries(name: .weekly, windowMinutes: 10080, entries: [
+                planEntry(at: firstBoundary.addingTimeInterval(-30 * 60), usedPercent: 62, resetsAt: firstBoundary),
+                planEntry(at: secondBoundary.addingTimeInterval(-30 * 60), usedPercent: 33, resetsAt: secondBoundary),
+            ]),
+        ]
+
+        let model = PlanUtilizationHistoryChartMenuView._modelSnapshotForTesting(
+            selectedSeriesRawValue: "weekly:10080",
+            histories: histories,
+            provider: .codex,
+            referenceDate: secondBoundary.addingTimeInterval(-60))
+
+        #expect(model.usedPercents == [62, 33])
+    }
+
+    @MainActor
+    @Test
+    func `weekly chart prefers reset backed history over legacy synthetic points`() {
+        let legacyCapturedAt = Date(timeIntervalSince1970: 1_742_100_000)
+        let firstBoundary = Date(timeIntervalSince1970: 1_742_356_855) // 2026-03-18T17:00:55Z
+        let secondBoundary = Date(timeIntervalSince1970: 1_742_961_343) // 2026-03-25T17:02:23Z
+        let histories = [
+            planSeries(name: .weekly, windowMinutes: 10080, entries: [
+                planEntry(at: legacyCapturedAt, usedPercent: 57),
+                planEntry(at: firstBoundary.addingTimeInterval(-60 * 60), usedPercent: 73, resetsAt: firstBoundary),
+                planEntry(at: secondBoundary.addingTimeInterval(-60 * 60), usedPercent: 35, resetsAt: secondBoundary),
+            ]),
+        ]
+
+        let model = PlanUtilizationHistoryChartMenuView._modelSnapshotForTesting(
+            selectedSeriesRawValue: "weekly:10080",
+            histories: histories,
+            provider: .codex,
+            referenceDate: secondBoundary.addingTimeInterval(-60))
+
+        #expect(model.usedPercents == [73, 35])
+    }
+
+    @MainActor
+    @Test
+    func `chart keeps legacy history before first reset backed boundary`() {
+        let firstLegacyCapturedAt = Date(timeIntervalSince1970: 1_739_692_800) // 2026-02-23T07:00:00Z
+        let secondLegacyCapturedAt = firstLegacyCapturedAt.addingTimeInterval(7 * 24 * 60 * 60)
+        let firstBoundary = secondLegacyCapturedAt.addingTimeInterval(7 * 24 * 60 * 60 + 55)
+        let secondBoundary = firstBoundary.addingTimeInterval(7 * 24 * 60 * 60)
+        let histories = [
+            planSeries(name: .weekly, windowMinutes: 10080, entries: [
+                planEntry(at: firstLegacyCapturedAt, usedPercent: 20),
+                planEntry(at: secondLegacyCapturedAt, usedPercent: 40),
+                planEntry(at: firstBoundary.addingTimeInterval(-60 * 60), usedPercent: 73, resetsAt: firstBoundary),
+                planEntry(at: secondBoundary.addingTimeInterval(-60 * 60), usedPercent: 35, resetsAt: secondBoundary),
+            ]),
+        ]
+
+        let model = PlanUtilizationHistoryChartMenuView._modelSnapshotForTesting(
+            selectedSeriesRawValue: "weekly:10080",
+            histories: histories,
+            provider: .claude,
+            referenceDate: secondBoundary.addingTimeInterval(-60))
+
+        #expect(model.usedPercents == [20, 40, 73, 35])
+    }
+}
diff --git a/Tests/CodexBarTests/UsageStorePlanUtilizationResetCoalescingTests.swift b/Tests/CodexBarTests/UsageStorePlanUtilizationResetCoalescingTests.swift
new file mode 100644
index 0000000000..076f20b5f0
--- /dev/null
+++ b/Tests/CodexBarTests/UsageStorePlanUtilizationResetCoalescingTests.swift
@@ -0,0 +1,279 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct UsageStorePlanUtilizationResetCoalescingTests {
+    @Test
+    func `near canonical codex windows merge into canonical history series`() throws {
+        let base = Date(timeIntervalSince1970: 1_700_000_000)
+        let existing = [
+            planSeries(name: .session, windowMinutes: 300, entries: [
+                planEntry(at: base, usedPercent: 20),
+            ]),
+            planSeries(name: .weekly, windowMinutes: 10080, entries: [
+                planEntry(at: base, usedPercent: 40),
+            ]),
+        ]
+        let incoming = [
+            planSeries(name: .session, windowMinutes: 299, entries: [
+                planEntry(at: base.addingTimeInterval(3600), usedPercent: 30),
+            ]),
+            planSeries(name: .weekly, windowMinutes: 10079, entries: [
+                planEntry(at: base.addingTimeInterval(3600), usedPercent: 50),
+            ]),
+        ]
+
+        let updated = try #require(
+            UsageStore._updatedPlanUtilizationHistoriesForTesting(
+                existingHistories: existing,
+                samples: incoming))
+
+        #expect(updated.map { "\($0.name.rawValue):\($0.windowMinutes)" } == ["session:300", "weekly:10080"])
+        #expect(findSeries(updated, name: .session, windowMinutes: 300)?.entries.map(\.usedPercent) == [20, 30])
+        #expect(findSeries(updated, name: .weekly, windowMinutes: 10080)?.entries.map(\.usedPercent) == [40, 50])
+    }
+
+    @Test
+    func `same hour entry backfills missing reset metadata`() throws {
+        let calendar = Calendar(identifier: .gregorian)
+        let hourStart = try #require(calendar.date(from: DateComponents(
+            timeZone: TimeZone(secondsFromGMT: 0),
+            year: 2026,
+            month: 3,
+            day: 17,
+            hour: 9)))
+        let existing = planEntry(
+            at: hourStart.addingTimeInterval(10 * 60),
+            usedPercent: 20)
+        let incoming = planEntry(
+            at: hourStart.addingTimeInterval(45 * 60),
+            usedPercent: 30,
+            resetsAt: hourStart.addingTimeInterval(30 * 60))
+
+        let updated = try #require(
+            UsageStore._updatedPlanUtilizationEntriesForTesting(
+                existingEntries: [existing],
+                entry: incoming))
+
+        #expect(updated.count == 1)
+        #expect(updated[0].capturedAt == incoming.capturedAt)
+        #expect(updated[0].usedPercent == 30)
+        #expect(updated[0].resetsAt == incoming.resetsAt)
+    }
+
+    @Test
+    func `same hour later higher usage without reset metadata keeps promoted reset boundary`() throws {
+        let calendar = Calendar(identifier: .gregorian)
+        let hourStart = try #require(calendar.date(from: DateComponents(
+            timeZone: TimeZone(secondsFromGMT: 0),
+            year: 2026,
+            month: 3,
+            day: 17,
+            hour: 9)))
+        let first = planEntry(
+            at: hourStart.addingTimeInterval(10 * 60),
+            usedPercent: 40)
+        let second = planEntry(
+            at: hourStart.addingTimeInterval(25 * 60),
+            usedPercent: 8,
+            resetsAt: hourStart.addingTimeInterval(30 * 60))
+        let third = planEntry(
+            at: hourStart.addingTimeInterval(50 * 60),
+            usedPercent: 22)
+
+        let initial = try #require(
+            UsageStore._updatedPlanUtilizationEntriesForTesting(
+                existingEntries: [],
+                entry: first))
+        let promoted = try #require(
+            UsageStore._updatedPlanUtilizationEntriesForTesting(
+                existingEntries: initial,
+                entry: second))
+        let updated = try #require(
+            UsageStore._updatedPlanUtilizationEntriesForTesting(
+                existingEntries: promoted,
+                entry: third))
+
+        #expect(updated.count == 1)
+        #expect(updated[0].capturedAt == third.capturedAt)
+        #expect(updated[0].usedPercent == third.usedPercent)
+        #expect(updated[0].resetsAt == second.resetsAt)
+    }
+
+    @Test
+    func `same hour zero usage with drifting reset coalesces to latest entry`() throws {
+        let calendar = Calendar(identifier: .gregorian)
+        let hourStart = try #require(calendar.date(from: DateComponents(
+            timeZone: TimeZone(secondsFromGMT: 0),
+            year: 2026,
+            month: 3,
+            day: 20,
+            hour: 0)))
+        let existing = planEntry(
+            at: hourStart.addingTimeInterval(14 * 60),
+            usedPercent: 0,
+            resetsAt: hourStart.addingTimeInterval(5 * 60 * 60 + 14 * 60 + 2))
+        let incoming = planEntry(
+            at: hourStart.addingTimeInterval(23 * 60),
+            usedPercent: 0,
+            resetsAt: hourStart.addingTimeInterval(5 * 60 * 60 + 14 * 60 + 3))
+
+        let updated = try #require(
+            UsageStore._updatedPlanUtilizationEntriesForTesting(
+                existingEntries: [existing],
+                entry: incoming))
+
+        #expect(updated.count == 1)
+        #expect(updated[0] == incoming)
+    }
+
+    @Test
+    func `same hour reset times within two minutes still keep single hourly peak`() throws {
+        let calendar = Calendar(identifier: .gregorian)
+        let hourStart = try #require(calendar.date(from: DateComponents(
+            timeZone: TimeZone(secondsFromGMT: 0),
+            year: 2026,
+            month: 3,
+            day: 20,
+            hour: 0)))
+        let existing = planEntry(
+            at: hourStart.addingTimeInterval(21 * 60),
+            usedPercent: 10,
+            resetsAt: hourStart.addingTimeInterval(3 * 60 * 60))
+        let incoming = planEntry(
+            at: hourStart.addingTimeInterval(55 * 60),
+            usedPercent: 10,
+            resetsAt: hourStart.addingTimeInterval(3 * 60 * 60 + 1))
+
+        let updated = try #require(
+            UsageStore._updatedPlanUtilizationEntriesForTesting(
+                existingEntries: [existing],
+                entry: incoming))
+
+        #expect(updated.count == 1)
+        #expect(updated[0].capturedAt == incoming.capturedAt)
+        #expect(updated[0].usedPercent == 10)
+        #expect(updated[0].resetsAt == incoming.resetsAt)
+    }
+
+    @Test
+    func `same hour usage drop without meaningful reset still keeps single hourly peak`() throws {
+        let calendar = Calendar(identifier: .gregorian)
+        let hourStart = try #require(calendar.date(from: DateComponents(
+            timeZone: TimeZone(secondsFromGMT: 0),
+            year: 2026,
+            month: 3,
+            day: 20,
+            hour: 0)))
+        let existing = planEntry(
+            at: hourStart.addingTimeInterval(15 * 60),
+            usedPercent: 40,
+            resetsAt: hourStart.addingTimeInterval(3 * 60 * 60))
+        let incoming = planEntry(
+            at: hourStart.addingTimeInterval(45 * 60),
+            usedPercent: 5,
+            resetsAt: hourStart.addingTimeInterval(3 * 60 * 60 + 30))
+
+        let updated = try #require(
+            UsageStore._updatedPlanUtilizationEntriesForTesting(
+                existingEntries: [existing],
+                entry: incoming))
+
+        #expect(updated.count == 1)
+        #expect(updated[0].capturedAt == existing.capturedAt)
+        #expect(updated[0].usedPercent == existing.usedPercent)
+        #expect(updated[0].resetsAt == incoming.resetsAt)
+    }
+
+    @Test
+    func `same hour reset keeps peak before reset and latest peak after reset`() throws {
+        let calendar = Calendar(identifier: .gregorian)
+        let hourStart = try #require(calendar.date(from: DateComponents(
+            timeZone: TimeZone(secondsFromGMT: 0),
+            year: 2026,
+            month: 3,
+            day: 20,
+            hour: 0)))
+        let initial = [
+            planEntry(
+                at: hourStart.addingTimeInterval(5 * 60),
+                usedPercent: 40,
+                resetsAt: hourStart.addingTimeInterval(3 * 60 * 60)),
+            planEntry(
+                at: hourStart.addingTimeInterval(20 * 60),
+                usedPercent: 12,
+                resetsAt: hourStart.addingTimeInterval(8 * 60 * 60)),
+        ]
+        let incoming = planEntry(
+            at: hourStart.addingTimeInterval(45 * 60),
+            usedPercent: 18,
+            resetsAt: hourStart.addingTimeInterval(8 * 60 * 60))
+
+        let updated = try #require(
+            UsageStore._updatedPlanUtilizationEntriesForTesting(
+                existingEntries: initial,
+                entry: incoming))
+
+        #expect(updated.count == 2)
+        #expect(updated[0].usedPercent == 40)
+        #expect(updated[1].usedPercent == 18)
+        #expect(updated[1].resetsAt == incoming.resetsAt)
+    }
+
+    @Test
+    func `newer reset within hour replaces earlier post reset record`() throws {
+        let calendar = Calendar(identifier: .gregorian)
+        let hourStart = try #require(calendar.date(from: DateComponents(
+            timeZone: TimeZone(secondsFromGMT: 0),
+            year: 2026,
+            month: 3,
+            day: 20,
+            hour: 0)))
+        let initial = [
+            planEntry(
+                at: hourStart.addingTimeInterval(5 * 60),
+                usedPercent: 40,
+                resetsAt: hourStart.addingTimeInterval(3 * 60 * 60)),
+            planEntry(
+                at: hourStart.addingTimeInterval(20 * 60),
+                usedPercent: 12,
+                resetsAt: hourStart.addingTimeInterval(8 * 60 * 60)),
+        ]
+        let incoming = planEntry(
+            at: hourStart.addingTimeInterval(50 * 60),
+            usedPercent: 3,
+            resetsAt: hourStart.addingTimeInterval(10 * 60 * 60))
+
+        let updated = try #require(
+            UsageStore._updatedPlanUtilizationEntriesForTesting(
+                existingEntries: initial,
+                entry: incoming))
+
+        #expect(updated.count == 2)
+        #expect(updated[0].usedPercent == 40)
+        #expect(updated[1] == incoming)
+    }
+
+    @Test
+    func `merged histories keep series separated by stable name`() throws {
+        let existing = [
+            planSeries(name: .session, windowMinutes: 300, entries: [
+                planEntry(at: Date(timeIntervalSince1970: 1_700_000_000), usedPercent: 20),
+            ]),
+        ]
+        let incoming = [
+            planSeries(name: .weekly, windowMinutes: 10080, entries: [
+                planEntry(at: Date(timeIntervalSince1970: 1_700_000_000), usedPercent: 40),
+            ]),
+        ]
+
+        let updated = try #require(
+            UsageStore._updatedPlanUtilizationHistoriesForTesting(
+                existingHistories: existing,
+                samples: incoming))
+
+        #expect(findSeries(updated, name: .session, windowMinutes: 300) != nil)
+        #expect(findSeries(updated, name: .weekly, windowMinutes: 10080) != nil)
+    }
+}
diff --git a/Tests/CodexBarTests/UsageStorePlanUtilizationTests.swift b/Tests/CodexBarTests/UsageStorePlanUtilizationTests.swift
new file mode 100644
index 0000000000..3e88039c00
--- /dev/null
+++ b/Tests/CodexBarTests/UsageStorePlanUtilizationTests.swift
@@ -0,0 +1,1532 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+// swiftlint:disable:next type_body_length
+struct UsageStorePlanUtilizationTests {
+    @Test
+    func `coalesces changed usage within hour into single entry`() throws {
+        let calendar = Calendar(identifier: .gregorian)
+        let hourStart = try #require(calendar.date(from: DateComponents(
+            timeZone: TimeZone(secondsFromGMT: 0),
+            year: 2026,
+            month: 3,
+            day: 17,
+            hour: 10)))
+        let first = planEntry(at: hourStart, usedPercent: 10)
+        let second = planEntry(at: hourStart.addingTimeInterval(25 * 60), usedPercent: 35)
+
+        let initial = try #require(
+            UsageStore._updatedPlanUtilizationEntriesForTesting(
+                existingEntries: [],
+                entry: first))
+        let updated = try #require(
+            UsageStore._updatedPlanUtilizationEntriesForTesting(
+                existingEntries: initial,
+                entry: second))
+
+        #expect(updated.count == 1)
+        #expect(updated.last == second)
+    }
+
+    @Test
+    func `changed reset boundary within hour appends new entry`() throws {
+        let calendar = Calendar(identifier: .gregorian)
+        let hourStart = try #require(calendar.date(from: DateComponents(
+            timeZone: TimeZone(secondsFromGMT: 0),
+            year: 2026,
+            month: 3,
+            day: 17,
+            hour: 10)))
+        let first = planEntry(
+            at: hourStart.addingTimeInterval(5 * 60),
+            usedPercent: 82,
+            resetsAt: hourStart.addingTimeInterval(30 * 60))
+        let second = planEntry(
+            at: hourStart.addingTimeInterval(35 * 60),
+            usedPercent: 4,
+            resetsAt: hourStart.addingTimeInterval(5 * 60 * 60))
+
+        let initial = try #require(
+            UsageStore._updatedPlanUtilizationEntriesForTesting(
+                existingEntries: [],
+                entry: first))
+        let updated = try #require(
+            UsageStore._updatedPlanUtilizationEntriesForTesting(
+                existingEntries: initial,
+                entry: second))
+
+        #expect(updated.count == 2)
+        #expect(updated[0] == first)
+        #expect(updated[1] == second)
+    }
+
+    @Test
+    func `first known reset boundary within hour replaces earlier provisional peak even when usage drops`() throws {
+        let calendar = Calendar(identifier: .gregorian)
+        let hourStart = try #require(calendar.date(from: DateComponents(
+            timeZone: TimeZone(secondsFromGMT: 0),
+            year: 2026,
+            month: 3,
+            day: 17,
+            hour: 10)))
+        let first = planEntry(
+            at: hourStart.addingTimeInterval(5 * 60),
+            usedPercent: 82,
+            resetsAt: nil)
+        let second = planEntry(
+            at: hourStart.addingTimeInterval(35 * 60),
+            usedPercent: 4,
+            resetsAt: hourStart.addingTimeInterval(5 * 60 * 60))
+
+        let initial = try #require(
+            UsageStore._updatedPlanUtilizationEntriesForTesting(
+                existingEntries: [],
+                entry: first))
+        let updated = try #require(
+            UsageStore._updatedPlanUtilizationEntriesForTesting(
+                existingEntries: initial,
+                entry: second))
+
+        #expect(updated.count == 1)
+        #expect(updated[0] == second)
+    }
+
+    @Test
+    func `trims entry history to retention limit`() throws {
+        let maxSamples = UsageStore._planUtilizationMaxSamplesForTesting
+        let base = Date(timeIntervalSince1970: 1_700_000_000)
+        var entries: [PlanUtilizationHistoryEntry] = []
+
+        for offset in 0..<maxSamples {
+            entries.append(planEntry(
+                at: base.addingTimeInterval(Double(offset) * 3600),
+                usedPercent: Double(offset % 100)))
+        }
+
+        let appended = planEntry(
+            at: base.addingTimeInterval(Double(maxSamples) * 3600),
+            usedPercent: 50)
+
+        let updated = try #require(
+            UsageStore._updatedPlanUtilizationEntriesForTesting(
+                existingEntries: entries,
+                entry: appended))
+
+        #expect(updated.count == maxSamples)
+        #expect(updated.first?.capturedAt == entries[1].capturedAt)
+        #expect(updated.last == appended)
+    }
+
+    @MainActor
+    @Test
+    func `native chart shows visible series tabs only`() {
+        let histories = [
+            planSeries(name: .session, windowMinutes: 0, entries: [
+                planEntry(at: Date(timeIntervalSince1970: 1_700_000_000), usedPercent: 90),
+            ]),
+            planSeries(name: .session, windowMinutes: 300, entries: [
+                planEntry(at: Date(timeIntervalSince1970: 1_700_000_000), usedPercent: 20),
+            ]),
+            planSeries(name: .weekly, windowMinutes: 10080, entries: [
+                planEntry(at: Date(timeIntervalSince1970: 1_700_086_400), usedPercent: 48),
+            ]),
+        ]
+
+        let model = PlanUtilizationHistoryChartMenuView._modelSnapshotForTesting(
+            histories: histories,
+            provider: .codex)
+
+        #expect(model.visibleSeries == ["session:300", "weekly:10080"])
+        #expect(model.selectedSeries == "session:300")
+    }
+
+    @MainActor
+    @Test
+    func `native chart folds near canonical codex windows into single tabs`() {
+        let histories = [
+            planSeries(name: .session, windowMinutes: 299, entries: [
+                planEntry(at: Date(timeIntervalSince1970: 1_700_000_000), usedPercent: 20),
+            ]),
+            planSeries(name: .session, windowMinutes: 300, entries: [
+                planEntry(at: Date(timeIntervalSince1970: 1_700_003_600), usedPercent: 30),
+            ]),
+            planSeries(name: .weekly, windowMinutes: 10079, entries: [
+                planEntry(at: Date(timeIntervalSince1970: 1_700_086_400), usedPercent: 40),
+            ]),
+            planSeries(name: .weekly, windowMinutes: 10080, entries: [
+                planEntry(at: Date(timeIntervalSince1970: 1_700_172_800), usedPercent: 50),
+            ]),
+        ]
+
+        let model = PlanUtilizationHistoryChartMenuView._modelSnapshotForTesting(
+            histories: histories,
+            provider: .codex)
+
+        #expect(model.visibleSeries == ["session:300", "weekly:10080"])
+        #expect(model.selectedSeries == "session:300")
+    }
+
+    @MainActor
+    @Test
+    func `claude history tabs match current snapshot bars`() {
+        let histories = [
+            planSeries(name: .session, windowMinutes: 300, entries: [
+                planEntry(at: Date(timeIntervalSince1970: 1_700_000_000), usedPercent: 20),
+            ]),
+            planSeries(name: .weekly, windowMinutes: 10080, entries: [
+                planEntry(at: Date(timeIntervalSince1970: 1_700_086_400), usedPercent: 48),
+            ]),
+            planSeries(name: .opus, windowMinutes: 10080, entries: [
+                planEntry(at: Date(timeIntervalSince1970: 1_700_086_400), usedPercent: 12),
+            ]),
+        ]
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 3, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 10, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            tertiary: nil,
+            updatedAt: Date(timeIntervalSince1970: 1_700_086_400),
+            identity: nil)
+
+        let model = PlanUtilizationHistoryChartMenuView._modelSnapshotForTesting(
+            histories: histories,
+            provider: .claude,
+            snapshot: snapshot)
+
+        #expect(model.visibleSeries == ["session:300", "weekly:10080"])
+        #expect(model.selectedSeries == "session:300")
+    }
+
+    @MainActor
+    @Test
+    func `session chart uses native reset boundaries and fills missing windows`() throws {
+        let calendar = Calendar(identifier: .gregorian)
+        let firstBoundary = try #require(calendar.date(from: DateComponents(
+            timeZone: TimeZone.current,
+            year: 2026,
+            month: 3,
+            day: 4,
+            hour: 10)))
+        let thirdBoundary = try #require(calendar.date(from: DateComponents(
+            timeZone: TimeZone.current,
+            year: 2026,
+            month: 3,
+            day: 4,
+            hour: 20)))
+        let histories = [
+            planSeries(name: .session, windowMinutes: 300, entries: [
+                planEntry(at: firstBoundary.addingTimeInterval(-30 * 60), usedPercent: 62, resetsAt: firstBoundary),
+                planEntry(at: thirdBoundary.addingTimeInterval(-30 * 60), usedPercent: 20, resetsAt: thirdBoundary),
+            ]),
+        ]
+
+        let model = PlanUtilizationHistoryChartMenuView._modelSnapshotForTesting(
+            selectedSeriesRawValue: "session:300",
+            histories: histories,
+            provider: .codex,
+            referenceDate: thirdBoundary)
+
+        #expect(model.pointCount == 3)
+        #expect(model.usedPercents == [62, 0, 20])
+        #expect(model.pointDates == [
+            formattedBoundary(firstBoundary),
+            formattedBoundary(firstBoundary.addingTimeInterval(5 * 60 * 60)),
+            formattedBoundary(thirdBoundary),
+        ])
+    }
+
+    @MainActor
+    @Test
+    func `session chart labels only day changes`() throws {
+        let calendar = Calendar(identifier: .gregorian)
+        let firstBoundary = try #require(calendar.date(from: DateComponents(
+            timeZone: TimeZone.current,
+            year: 2026,
+            month: 3,
+            day: 4,
+            hour: 20)))
+        let thirdBoundary = try #require(calendar.date(from: DateComponents(
+            timeZone: TimeZone.current,
+            year: 2026,
+            month: 3,
+            day: 5,
+            hour: 6)))
+        let histories = [
+            planSeries(name: .session, windowMinutes: 300, entries: [
+                planEntry(at: firstBoundary.addingTimeInterval(-30 * 60), usedPercent: 62, resetsAt: firstBoundary),
+                planEntry(at: thirdBoundary.addingTimeInterval(-30 * 60), usedPercent: 20, resetsAt: thirdBoundary),
+            ]),
+        ]
+
+        let model = PlanUtilizationHistoryChartMenuView._modelSnapshotForTesting(
+            selectedSeriesRawValue: "session:300",
+            histories: histories,
+            provider: .codex,
+            referenceDate: thirdBoundary)
+
+        #expect(model.axisIndexes == [0])
+    }
+
+    @MainActor
+    @Test
+    func `session chart labels every second day change`() throws {
+        let calendar = Calendar(identifier: .gregorian)
+        let firstBoundary = try #require(calendar.date(from: DateComponents(
+            timeZone: TimeZone.current,
+            year: 2026,
+            month: 3,
+            day: 4,
+            hour: 20)))
+        let secondBoundary = try #require(calendar.date(from: DateComponents(
+            timeZone: TimeZone.current,
+            year: 2026,
+            month: 3,
+            day: 5,
+            hour: 6)))
+        let thirdBoundary = try #require(calendar.date(from: DateComponents(
+            timeZone: TimeZone.current,
+            year: 2026,
+            month: 3,
+            day: 6,
+            hour: 6)))
+        let fourthBoundary = try #require(calendar.date(from: DateComponents(
+            timeZone: TimeZone.current,
+            year: 2026,
+            month: 3,
+            day: 7,
+            hour: 6)))
+        let histories = [
+            planSeries(name: .session, windowMinutes: 300, entries: [
+                planEntry(at: firstBoundary.addingTimeInterval(-30 * 60), usedPercent: 62, resetsAt: firstBoundary),
+                planEntry(at: secondBoundary.addingTimeInterval(-30 * 60), usedPercent: 20, resetsAt: secondBoundary),
+                planEntry(at: thirdBoundary.addingTimeInterval(-30 * 60), usedPercent: 35, resetsAt: thirdBoundary),
+                planEntry(at: fourthBoundary.addingTimeInterval(-30 * 60), usedPercent: 18, resetsAt: fourthBoundary),
+            ]),
+        ]
+
+        let model = PlanUtilizationHistoryChartMenuView._modelSnapshotForTesting(
+            selectedSeriesRawValue: "session:300",
+            histories: histories,
+            provider: .codex,
+            referenceDate: fourthBoundary)
+
+        #expect(model.axisIndexes == [0])
+    }
+
+    @MainActor
+    @Test
+    func `session chart drops trailing day label when it would clip at chart edge`() throws {
+        let calendar = Calendar(identifier: .gregorian)
+        let firstBoundary = try #require(calendar.date(from: DateComponents(
+            timeZone: TimeZone.current,
+            year: 2026,
+            month: 3,
+            day: 4,
+            hour: 20)))
+        let secondBoundary = try #require(calendar.date(from: DateComponents(
+            timeZone: TimeZone.current,
+            year: 2026,
+            month: 3,
+            day: 5,
+            hour: 6)))
+        let thirdBoundary = try #require(calendar.date(from: DateComponents(
+            timeZone: TimeZone.current,
+            year: 2026,
+            month: 3,
+            day: 6,
+            hour: 6)))
+        let fourthBoundary = try #require(calendar.date(from: DateComponents(
+            timeZone: TimeZone.current,
+            year: 2026,
+            month: 3,
+            day: 7,
+            hour: 20)))
+        let histories = [
+            planSeries(name: .session, windowMinutes: 300, entries: [
+                planEntry(at: firstBoundary.addingTimeInterval(-30 * 60), usedPercent: 62, resetsAt: firstBoundary),
+                planEntry(at: secondBoundary.addingTimeInterval(-30 * 60), usedPercent: 20, resetsAt: secondBoundary),
+                planEntry(at: thirdBoundary.addingTimeInterval(-30 * 60), usedPercent: 35, resetsAt: thirdBoundary),
+                planEntry(at: fourthBoundary.addingTimeInterval(-30 * 60), usedPercent: 18, resetsAt: fourthBoundary),
+            ]),
+        ]
+
+        let model = PlanUtilizationHistoryChartMenuView._modelSnapshotForTesting(
+            selectedSeriesRawValue: "session:300",
+            histories: histories,
+            provider: .codex,
+            referenceDate: fourthBoundary)
+
+        #expect(model.axisIndexes == [0, 10])
+    }
+
+    @MainActor
+    @Test
+    func `detail line shows used and wasted without provenance copy`() {
+        let boundary = Date(timeIntervalSince1970: 1_710_000_000)
+        let histories = [
+            planSeries(name: .session, windowMinutes: 300, entries: [
+                planEntry(at: boundary.addingTimeInterval(-30 * 60), usedPercent: 48, resetsAt: boundary),
+            ]),
+        ]
+
+        let detail = PlanUtilizationHistoryChartMenuView._detailLineForTesting(
+            selectedSeriesRawValue: "session:300",
+            histories: histories,
+            provider: .codex,
+            referenceDate: boundary.addingTimeInterval(-1))
+
+        #expect(detail.contains("48% used"))
+        #expect(!detail.contains("Provider-reported"))
+        #expect(!detail.contains("Estimated"))
+        #expect(!detail.contains("wasted"))
+    }
+
+    @MainActor
+    @Test
+    func `detail line shows dash for missing window`() {
+        let boundary = Date(timeIntervalSince1970: 1_710_000_000)
+        let histories = [
+            planSeries(name: .session, windowMinutes: 300, entries: [
+                planEntry(at: boundary.addingTimeInterval(-30 * 60), usedPercent: 48, resetsAt: boundary),
+            ]),
+        ]
+
+        let detail = PlanUtilizationHistoryChartMenuView._detailLineForTesting(
+            selectedSeriesRawValue: "session:300",
+            histories: histories,
+            provider: .codex,
+            referenceDate: boundary.addingTimeInterval(5 * 60 * 60))
+
+        #expect(detail.contains(": -"))
+    }
+
+    @MainActor
+    @Test
+    func `detail line keeps zero percent for observed zero usage`() {
+        let boundary = Date(timeIntervalSince1970: 1_710_000_000)
+        let histories = [
+            planSeries(name: .session, windowMinutes: 300, entries: [
+                planEntry(at: boundary.addingTimeInterval(-30 * 60), usedPercent: 0, resetsAt: boundary),
+            ]),
+        ]
+
+        let detail = PlanUtilizationHistoryChartMenuView._detailLineForTesting(
+            selectedSeriesRawValue: "session:300",
+            histories: histories,
+            provider: .codex,
+            referenceDate: boundary.addingTimeInterval(-1))
+
+        #expect(detail.contains("0% used"))
+        #expect(!detail.contains(": -"))
+    }
+
+    @MainActor
+    @Test
+    func `detail line uses lowercase am pm for session hover`() {
+        let previousLanguage = UserDefaults.standard.object(forKey: "appLanguage")
+        UserDefaults.standard.set("en", forKey: "appLanguage")
+        defer {
+            if let previousLanguage {
+                UserDefaults.standard.set(previousLanguage, forKey: "appLanguage")
+            } else {
+                UserDefaults.standard.removeObject(forKey: "appLanguage")
+            }
+        }
+
+        let boundary = Date(timeIntervalSince1970: 1_710_048_000) // Mar 11, 2024 1:20 pm UTC
+        let histories = [
+            planSeries(name: .session, windowMinutes: 300, entries: [
+                planEntry(at: boundary.addingTimeInterval(-30 * 60), usedPercent: 48, resetsAt: boundary),
+            ]),
+        ]
+
+        let detail = PlanUtilizationHistoryChartMenuView._detailLineForTesting(
+            selectedSeriesRawValue: "session:300",
+            histories: histories,
+            provider: .codex,
+            referenceDate: boundary.addingTimeInterval(-1))
+
+        #expect(detail.contains(" am") || detail.contains(" pm"))
+        #expect(!detail.contains("PM"))
+        #expect(!detail.contains("AM"))
+    }
+
+    @MainActor
+    @Test
+    func `detail line uses lowercase am pm for weekly hover`() {
+        let previousLanguage = UserDefaults.standard.object(forKey: "appLanguage")
+        UserDefaults.standard.set("en", forKey: "appLanguage")
+        defer {
+            if let previousLanguage {
+                UserDefaults.standard.set(previousLanguage, forKey: "appLanguage")
+            } else {
+                UserDefaults.standard.removeObject(forKey: "appLanguage")
+            }
+        }
+
+        let boundary = Date(timeIntervalSince1970: 1_710_048_000) // Mar 11, 2024 1:20 pm UTC
+        let histories = [
+            planSeries(name: .weekly, windowMinutes: 10080, entries: [
+                planEntry(at: boundary.addingTimeInterval(-30 * 60), usedPercent: 48, resetsAt: boundary),
+            ]),
+        ]
+
+        let detail = PlanUtilizationHistoryChartMenuView._detailLineForTesting(
+            selectedSeriesRawValue: "weekly:10080",
+            histories: histories,
+            provider: .codex,
+            referenceDate: boundary.addingTimeInterval(-1))
+
+        #expect(detail.contains(" am") || detail.contains(" pm"))
+        #expect(!detail.contains("PM"))
+        #expect(!detail.contains("AM"))
+    }
+
+    @Test
+    func `chart empty state shows series specific message`() {
+        let text = PlanUtilizationHistoryChartMenuView._emptyStateTextForTesting(title: "Session")
+        #expect(text == "No session utilization data yet.")
+    }
+
+    @Test
+    func `chart empty state shows series specific message when not refreshing`() {
+        let text = PlanUtilizationHistoryChartMenuView._emptyStateTextForTesting(title: "Weekly")
+        #expect(text == "No weekly utilization data yet.")
+    }
+
+    @MainActor
+    @Test
+    func `plan history selects current account bucket`() throws {
+        let store = Self.makeStore()
+        let aliceSnapshot = Self.makeSnapshot(provider: .codex, email: "alice@example.com")
+        let bobSnapshot = Self.makeSnapshot(provider: .codex, email: "bob@example.com")
+        let aliceKey = try #require(
+            UsageStore._planUtilizationAccountKeyForTesting(
+                provider: .codex,
+                snapshot: aliceSnapshot))
+        let bobKey = try #require(
+            UsageStore._planUtilizationAccountKeyForTesting(
+                provider: .codex,
+                snapshot: bobSnapshot))
+
+        let bootstrap = planSeries(name: .session, windowMinutes: 300, entries: [
+            planEntry(at: Date(timeIntervalSince1970: 1_699_913_600), usedPercent: 90),
+        ])
+        let aliceWeekly = planSeries(name: .weekly, windowMinutes: 10080, entries: [
+            planEntry(at: Date(timeIntervalSince1970: 1_700_000_000), usedPercent: 20),
+        ])
+        let bobWeekly = planSeries(name: .weekly, windowMinutes: 10080, entries: [
+            planEntry(at: Date(timeIntervalSince1970: 1_700_086_400), usedPercent: 50),
+        ])
+
+        store.planUtilizationHistory[.codex] = PlanUtilizationHistoryBuckets(
+            unscoped: [bootstrap],
+            accounts: [
+                aliceKey: [aliceWeekly],
+                bobKey: [bobWeekly],
+            ])
+
+        store._setSnapshotForTesting(aliceSnapshot, provider: .codex)
+        let aliceHistory = store.planUtilizationHistory(for: .codex)
+        #expect(store.planUtilizationHistory[.codex]?.preferredAccountKey == aliceKey)
+        #expect(aliceHistory == [aliceWeekly])
+        #expect(store.planUtilizationHistory[.codex]?.unscoped == [bootstrap])
+
+        store._setSnapshotForTesting(bobSnapshot, provider: .codex)
+        let bobHistory = store.planUtilizationHistory(for: .codex)
+        #expect(store.planUtilizationHistory[.codex]?.preferredAccountKey == bobKey)
+        #expect(bobHistory == [bobWeekly])
+    }
+
+    @MainActor
+    @Test
+    func `plan utilization menu hides while refreshing without current snapshot`() throws {
+        let store = Self.makeStore()
+        let claudeKey = try #require(
+            UsageStore._planUtilizationAccountKeyForTesting(
+                provider: .claude,
+                snapshot: Self.makeSnapshot(provider: .claude, email: "alice@example.com")))
+        let weekly = planSeries(name: .weekly, windowMinutes: 10080, entries: [
+            planEntry(at: Date(timeIntervalSince1970: 1_700_000_000), usedPercent: 64),
+        ])
+        store.planUtilizationHistory[.claude] = PlanUtilizationHistoryBuckets(
+            preferredAccountKey: claudeKey,
+            accounts: [
+                claudeKey: [weekly],
+            ])
+        store.refreshingProviders.insert(.claude)
+        store._setSnapshotForTesting(nil, provider: .claude)
+
+        #expect(store.shouldShowRefreshingMenuCard(for: .claude))
+        #expect(store.shouldHidePlanUtilizationMenuItem(for: .claude))
+    }
+
+    @MainActor
+    @Test
+    func `plan utilization menu stays visible with stored snapshot even during refresh`() throws {
+        let store = Self.makeStore()
+        let codexSnapshot = Self.makeSnapshot(provider: .codex, email: "alice@example.com")
+        let codexKey = try #require(
+            UsageStore._planUtilizationAccountKeyForTesting(
+                provider: .codex,
+                snapshot: codexSnapshot))
+        let weekly = planSeries(name: .weekly, windowMinutes: 10080, entries: [
+            planEntry(at: Date(timeIntervalSince1970: 1_700_000_000), usedPercent: 64),
+        ])
+        store.planUtilizationHistory[.codex] = PlanUtilizationHistoryBuckets(
+            preferredAccountKey: codexKey,
+            accounts: [
+                codexKey: [weekly],
+            ])
+        store.refreshingProviders.insert(.codex)
+        store._setSnapshotForTesting(codexSnapshot, provider: .codex)
+
+        #expect(!store.shouldShowRefreshingMenuCard(for: .codex))
+        #expect(!store.shouldHidePlanUtilizationMenuItem(for: .codex))
+        let histories = store.planUtilizationHistory(for: .codex)
+        #expect(store.planUtilizationHistory[.codex]?.preferredAccountKey == codexKey)
+        #expect(histories == [weekly])
+    }
+
+    @MainActor
+    @Test
+    func `codex plan utilization menu hides during provider only refresh without snapshot`() {
+        let store = Self.makeStore()
+        store.refreshingProviders.insert(.codex)
+        store._setSnapshotForTesting(nil, provider: .codex)
+
+        #expect(store.shouldShowRefreshingMenuCard(for: .codex))
+        #expect(store.shouldHidePlanUtilizationMenuItem(for: .codex))
+    }
+
+    @MainActor
+    @Test
+    func `record plan history persists named series from snapshot`() async {
+        let store = Self.makeStore()
+        let primaryReset = Date(timeIntervalSince1970: 1_710_000_000)
+        let secondaryReset = Date(timeIntervalSince1970: 1_710_086_400)
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 110,
+                windowMinutes: 300,
+                resetsAt: primaryReset,
+                resetDescription: "5h"),
+            secondary: RateWindow(
+                usedPercent: -20,
+                windowMinutes: 10080,
+                resetsAt: secondaryReset,
+                resetDescription: "7d"),
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: "alice@example.com",
+                accountOrganization: nil,
+                loginMethod: "plus"))
+        store._setSnapshotForTesting(snapshot, provider: .codex)
+
+        await store.recordPlanUtilizationHistorySample(
+            provider: .codex,
+            snapshot: snapshot,
+            now: Date(timeIntervalSince1970: 1_700_000_000))
+
+        let histories = store.planUtilizationHistory(for: .codex)
+        #expect(findSeries(histories, name: .session, windowMinutes: 300)?.entries.last?.usedPercent == 100)
+        #expect(findSeries(histories, name: .session, windowMinutes: 300)?.entries.last?.resetsAt == primaryReset)
+        #expect(findSeries(histories, name: .weekly, windowMinutes: 10080)?.entries.last?.usedPercent == 0)
+        #expect(findSeries(histories, name: .weekly, windowMinutes: 10080)?.entries.last?.resetsAt == secondaryReset)
+    }
+
+    @MainActor
+    @Test
+    func `record plan history skips invalid zero minute windows`() async {
+        let store = Self.makeStore()
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 25,
+                windowMinutes: 0,
+                resetsAt: Date(timeIntervalSince1970: 1_710_000_000),
+                resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: 44,
+                windowMinutes: 10080,
+                resetsAt: Date(timeIntervalSince1970: 1_710_086_400),
+                resetDescription: nil),
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: "alice@example.com",
+                accountOrganization: nil,
+                loginMethod: "plus"))
+        store._setSnapshotForTesting(snapshot, provider: .codex)
+
+        await store.recordPlanUtilizationHistorySample(
+            provider: .codex,
+            snapshot: snapshot,
+            now: Date(timeIntervalSince1970: 1_700_000_000))
+
+        let histories = store.planUtilizationHistory(for: .codex)
+        #expect(findSeries(histories, name: .session, windowMinutes: 0) == nil)
+        #expect(findSeries(histories, name: .weekly, windowMinutes: 10080)?.entries.last?.usedPercent == 44)
+    }
+
+    @MainActor
+    @Test
+    func `record plan history keeps semantic codex lanes when durations drift`() async {
+        let store = Self.makeStore()
+        let primaryReset = Date(timeIntervalSince1970: 1_710_000_000)
+        let secondaryReset = Date(timeIntervalSince1970: 1_710_086_400)
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: 18,
+                windowMinutes: 360,
+                resetsAt: primaryReset,
+                resetDescription: "6h"),
+            secondary: RateWindow(
+                usedPercent: 42,
+                windowMinutes: 11040,
+                resetsAt: secondaryReset,
+                resetDescription: "7.67d"),
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .codex,
+                accountEmail: "alice@example.com",
+                accountOrganization: nil,
+                loginMethod: "plus"))
+        store._setSnapshotForTesting(snapshot, provider: .codex)
+
+        await store.recordPlanUtilizationHistorySample(
+            provider: .codex,
+            snapshot: snapshot,
+            now: Date(timeIntervalSince1970: 1_700_000_000))
+
+        let histories = store.planUtilizationHistory(for: .codex)
+        #expect(findSeries(histories, name: .session, windowMinutes: 360)?.entries.last?.usedPercent == 18)
+        #expect(findSeries(histories, name: .session, windowMinutes: 360)?.entries.last?.resetsAt == primaryReset)
+        #expect(findSeries(histories, name: .weekly, windowMinutes: 11040)?.entries.last?.usedPercent == 42)
+        #expect(findSeries(histories, name: .weekly, windowMinutes: 11040)?.entries.last?.resetsAt == secondaryReset)
+    }
+
+    @MainActor
+    @Test
+    func `record plan history stores claude opus as separate series`() async {
+        let store = Self.makeStore()
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 20, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            tertiary: RateWindow(usedPercent: 30, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .claude,
+                accountEmail: "alice@example.com",
+                accountOrganization: nil,
+                loginMethod: "max"))
+        store._setSnapshotForTesting(snapshot, provider: .claude)
+
+        await store.recordPlanUtilizationHistorySample(
+            provider: .claude,
+            snapshot: snapshot,
+            now: Date(timeIntervalSince1970: 1_700_000_000))
+
+        let histories = store.planUtilizationHistory(for: .claude)
+        #expect(findSeries(histories, name: .session, windowMinutes: 300)?.entries.last?.usedPercent == 10)
+        #expect(findSeries(histories, name: .weekly, windowMinutes: 10080)?.entries.last?.usedPercent == 20)
+        #expect(findSeries(histories, name: .opus, windowMinutes: 10080)?.entries.last?.usedPercent == 30)
+    }
+
+    @MainActor
+    @Test
+    func `weekly quota celebration posts when weekly usage resets to zero`() async {
+        let store = Self.makeStore()
+        let accountLabel = "reset-zero@example.com"
+        let recorder = WeeklyLimitResetEventRecorder(provider: .claude, accountLabel: accountLabel)
+        defer { recorder.invalidate() }
+
+        let before = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 99, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date(timeIntervalSince1970: 1_700_000_000),
+            identity: ProviderIdentitySnapshot(
+                providerID: .claude,
+                accountEmail: accountLabel,
+                accountOrganization: nil,
+                loginMethod: "max"))
+        let after = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 0, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date(timeIntervalSince1970: 1_700_003_600),
+            identity: ProviderIdentitySnapshot(
+                providerID: .claude,
+                accountEmail: accountLabel,
+                accountOrganization: nil,
+                loginMethod: "max"))
+
+        await store.recordPlanUtilizationHistorySample(provider: .claude, snapshot: before, now: before.updatedAt)
+        await store.recordPlanUtilizationHistorySample(provider: .claude, snapshot: after, now: after.updatedAt)
+
+        let events = recorder.events
+        #expect(events.count == 1)
+        #expect(events[0].provider == .claude)
+        #expect(events[0].accountLabel == accountLabel)
+        #expect(events[0].usedPercent == 0)
+    }
+
+    @MainActor
+    @Test
+    func `weekly quota celebration posts when reset lands mid hour without history split`() async {
+        let store = Self.makeStore()
+        let accountLabel = "mid-hour-reset@example.com"
+        let recorder = WeeklyLimitResetEventRecorder(provider: .claude, accountLabel: accountLabel)
+        defer { recorder.invalidate() }
+
+        let before = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: 40,
+                windowMinutes: 10080,
+                resetsAt: Date(timeIntervalSince1970: 1_700_100_000),
+                resetDescription: nil),
+            updatedAt: Date(timeIntervalSince1970: 1_700_000_000),
+            identity: ProviderIdentitySnapshot(
+                providerID: .claude,
+                accountEmail: accountLabel,
+                accountOrganization: nil,
+                loginMethod: "max"))
+        let after = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: 0,
+                windowMinutes: 10080,
+                resetsAt: Date(timeIntervalSince1970: 1_700_100_030),
+                resetDescription: nil),
+            updatedAt: Date(timeIntervalSince1970: 1_700_001_800),
+            identity: ProviderIdentitySnapshot(
+                providerID: .claude,
+                accountEmail: accountLabel,
+                accountOrganization: nil,
+                loginMethod: "max"))
+
+        await store.recordPlanUtilizationHistorySample(provider: .claude, snapshot: before, now: before.updatedAt)
+        await store.recordPlanUtilizationHistorySample(provider: .claude, snapshot: after, now: after.updatedAt)
+
+        let histories = store.planUtilizationHistory(for: .claude)
+        #expect(findSeries(histories, name: .weekly, windowMinutes: 10080)?.entries.count == 1)
+        #expect(findSeries(histories, name: .weekly, windowMinutes: 10080)?.entries.last?.usedPercent == 40)
+        let events = recorder.events
+        #expect(events.count == 1)
+        #expect(events[0].usedPercent == 0)
+    }
+
+    @MainActor
+    @Test
+    func `weekly quota celebration ignores first seen reset sample`() async {
+        let store = Self.makeStore()
+        let accountLabel = "first-seen-reset@example.com"
+        let recorder = WeeklyLimitResetEventRecorder(provider: .claude, accountLabel: accountLabel)
+        defer { recorder.invalidate() }
+
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 0, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date(timeIntervalSince1970: 1_700_000_000),
+            identity: ProviderIdentitySnapshot(
+                providerID: .claude,
+                accountEmail: accountLabel,
+                accountOrganization: nil,
+                loginMethod: "max"))
+
+        await store.recordPlanUtilizationHistorySample(provider: .claude, snapshot: snapshot, now: snapshot.updatedAt)
+
+        #expect(recorder.events.isEmpty)
+    }
+
+    @MainActor
+    @Test
+    func `antigravity weekly celebration samples stable named bucket maximum`() async {
+        let store = Self.makeStore()
+        let recorder = WeeklyLimitResetEventRecorder(provider: .antigravity, accountLabel: nil)
+        defer { recorder.invalidate() }
+
+        func snapshot(
+            primary: RateWindow,
+            secondary: RateWindow,
+            geminiWeeklyUsed: Double,
+            thirdPartyWeeklyUsed: Double,
+            updatedAt: Date) -> UsageSnapshot
+        {
+            UsageSnapshot(
+                primary: primary,
+                secondary: secondary,
+                tertiary: nil,
+                extraRateWindows: [
+                    NamedRateWindow(
+                        id: "antigravity-quota-summary-gemini-weekly",
+                        title: "Gemini Models Weekly Limit",
+                        window: RateWindow(
+                            usedPercent: geminiWeeklyUsed,
+                            windowMinutes: 10080,
+                            resetsAt: nil,
+                            resetDescription: nil)),
+                    NamedRateWindow(
+                        id: "antigravity-quota-summary-3p-weekly",
+                        title: "Claude and GPT models Weekly Limit",
+                        window: RateWindow(
+                            usedPercent: thirdPartyWeeklyUsed,
+                            windowMinutes: 10080,
+                            resetsAt: nil,
+                            resetDescription: nil)),
+                ],
+                updatedAt: updatedAt)
+        }
+
+        let firstDate = Date(timeIntervalSince1970: 1_700_000_000)
+        let before = snapshot(
+            primary: RateWindow(
+                usedPercent: 80,
+                windowMinutes: 10080,
+                resetsAt: nil,
+                resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: 20,
+                windowMinutes: 300,
+                resetsAt: nil,
+                resetDescription: nil),
+            geminiWeeklyUsed: 80,
+            thirdPartyWeeklyUsed: 0,
+            updatedAt: firstDate)
+        let representativeChanged = snapshot(
+            primary: RateWindow(
+                usedPercent: 20,
+                windowMinutes: 300,
+                resetsAt: nil,
+                resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: 0,
+                windowMinutes: 10080,
+                resetsAt: nil,
+                resetDescription: nil),
+            geminiWeeklyUsed: 0,
+            thirdPartyWeeklyUsed: 80,
+            updatedAt: firstDate.addingTimeInterval(3600))
+        let reset = snapshot(
+            primary: RateWindow(
+                usedPercent: 20,
+                windowMinutes: 300,
+                resetsAt: nil,
+                resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: 0,
+                windowMinutes: 10080,
+                resetsAt: nil,
+                resetDescription: nil),
+            geminiWeeklyUsed: 0,
+            thirdPartyWeeklyUsed: 0,
+            updatedAt: firstDate.addingTimeInterval(7200))
+
+        await store.recordPlanUtilizationHistorySample(
+            provider: .antigravity,
+            snapshot: before,
+            now: before.updatedAt)
+        await store.recordPlanUtilizationHistorySample(
+            provider: .antigravity,
+            snapshot: representativeChanged,
+            now: representativeChanged.updatedAt)
+        #expect(recorder.events.isEmpty)
+
+        await store.recordPlanUtilizationHistorySample(
+            provider: .antigravity,
+            snapshot: reset,
+            now: reset.updatedAt)
+        #expect(recorder.events.count == 1)
+        #expect(recorder.events.first?.usedPercent == 0)
+    }
+
+    @MainActor
+    @Test
+    func `weekly quota celebration fires once across repeated low samples`() async {
+        let store = Self.makeStore()
+        let accountLabel = "repeated-low@example.com"
+        let recorder = WeeklyLimitResetEventRecorder(provider: .claude, accountLabel: accountLabel)
+        defer { recorder.invalidate() }
+
+        let before = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 60, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date(timeIntervalSince1970: 1_700_000_000),
+            identity: ProviderIdentitySnapshot(
+                providerID: .claude,
+                accountEmail: accountLabel,
+                accountOrganization: nil,
+                loginMethod: "max"))
+        let firstLow = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 1, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date(timeIntervalSince1970: 1_700_001_800),
+            identity: ProviderIdentitySnapshot(
+                providerID: .claude,
+                accountEmail: accountLabel,
+                accountOrganization: nil,
+                loginMethod: "max"))
+        let secondLow = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 0, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date(timeIntervalSince1970: 1_700_002_100),
+            identity: ProviderIdentitySnapshot(
+                providerID: .claude,
+                accountEmail: accountLabel,
+                accountOrganization: nil,
+                loginMethod: "max"))
+
+        await store.recordPlanUtilizationHistorySample(provider: .claude, snapshot: before, now: before.updatedAt)
+        await store.recordPlanUtilizationHistorySample(provider: .claude, snapshot: firstLow, now: firstLow.updatedAt)
+        await store.recordPlanUtilizationHistorySample(provider: .claude, snapshot: secondLow, now: secondLow.updatedAt)
+
+        let events = recorder.events
+        #expect(events.count == 1)
+        #expect(events[0].usedPercent == 1)
+    }
+
+    @MainActor
+    @Test
+    func `weekly quota celebration posts for generic provider weekly lane`() async {
+        let store = Self.makeStore()
+        let accountLabel = "zai-reset-org"
+        let recorder = WeeklyLimitResetEventRecorder(provider: .zai, accountLabel: accountLabel)
+        defer { recorder.invalidate() }
+
+        let before = UsageSnapshot(
+            primary: RateWindow(usedPercent: 92, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 15, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date(timeIntervalSince1970: 1_700_000_000),
+            identity: ProviderIdentitySnapshot(
+                providerID: .zai,
+                accountEmail: nil,
+                accountOrganization: accountLabel,
+                loginMethod: "pro"))
+        let after = UsageSnapshot(
+            primary: RateWindow(usedPercent: 0, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 15, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date(timeIntervalSince1970: 1_700_003_600),
+            identity: ProviderIdentitySnapshot(
+                providerID: .zai,
+                accountEmail: nil,
+                accountOrganization: accountLabel,
+                loginMethod: "pro"))
+
+        await store.recordPlanUtilizationHistorySample(provider: .zai, snapshot: before, now: before.updatedAt)
+        await store.recordPlanUtilizationHistorySample(provider: .zai, snapshot: after, now: after.updatedAt)
+
+        let events = recorder.events
+        #expect(events.count == 1)
+        #expect(events[0].provider == .zai)
+        #expect(events[0].accountLabel == accountLabel)
+        #expect(events[0].usedPercent == 0)
+    }
+
+    @MainActor
+    @Test
+    func `generic provider weekly lane is persisted to provider history json`() async throws {
+        let store = Self.makeStore()
+        store.settings.historicalTrackingEnabled = true
+        let accountLabel = "zai-history-org"
+        let firstDate = Date(timeIntervalSince1970: 1_700_000_000)
+        let before = UsageSnapshot(
+            primary: RateWindow(usedPercent: 42, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 15, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            updatedAt: firstDate,
+            identity: ProviderIdentitySnapshot(
+                providerID: .zai,
+                accountEmail: nil,
+                accountOrganization: accountLabel,
+                loginMethod: "pro"))
+        let after = UsageSnapshot(
+            primary: RateWindow(usedPercent: 58, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 25, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            updatedAt: firstDate.addingTimeInterval(3600),
+            identity: ProviderIdentitySnapshot(
+                providerID: .zai,
+                accountEmail: nil,
+                accountOrganization: accountLabel,
+                loginMethod: "pro"))
+
+        await store.recordPlanUtilizationHistorySample(provider: .zai, snapshot: before, now: before.updatedAt)
+        await store.recordPlanUtilizationHistorySample(provider: .zai, snapshot: after, now: after.updatedAt)
+
+        let histories = store.planUtilizationHistory(for: .zai)
+        #expect(findSeries(histories, name: .weekly, windowMinutes: 10080)?.entries.map(\.usedPercent) == [42, 58])
+
+        let providerURL = try #require(store.planUtilizationHistoryStore.directoryURL?
+            .appendingPathComponent("zai.json", isDirectory: false))
+        var persistedBuckets: PlanUtilizationHistoryBuckets?
+        for _ in 0..<20 {
+            persistedBuckets = store.planUtilizationHistoryStore.load()[.zai]
+            if persistedBuckets?.histories(for: persistedBuckets?.preferredAccountKey).flatMap(\.entries).count == 2 {
+                break
+            }
+            try await Task.sleep(nanoseconds: 50_000_000)
+        }
+        #expect(FileManager.default.fileExists(atPath: providerURL.path))
+        let persisted = try #require(persistedBuckets)
+        #expect(persisted.histories(for: persisted.preferredAccountKey)
+            .flatMap(\.entries)
+            .map(\.usedPercent) == [42, 58])
+    }
+
+    @MainActor
+    @Test
+    func `generic history opt in controls recording while saved history stays visible`() async throws {
+        let store = Self.makeStore()
+        let firstDate = Date(timeIntervalSince1970: 1_700_000_000)
+        let before = UsageSnapshot(
+            primary: RateWindow(usedPercent: 42, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: firstDate)
+        store._setSnapshotForTesting(before, provider: .zai)
+        let providerURL = try #require(store.planUtilizationHistoryStore.directoryURL?
+            .appendingPathComponent("zai.json", isDirectory: false))
+
+        #expect(store.settings.historicalTrackingEnabled == false)
+        #expect(store.supportsPlanUtilizationHistory(for: .zai) == false)
+        await store.recordPlanUtilizationHistorySample(provider: .zai, snapshot: before, now: before.updatedAt)
+        #expect(store.planUtilizationHistory(for: .zai).isEmpty)
+        #expect(FileManager.default.fileExists(atPath: providerURL.path) == false)
+
+        store.settings.historicalTrackingEnabled = true
+        #expect(store.supportsPlanUtilizationHistory(for: .zai))
+        await store.recordPlanUtilizationHistorySample(provider: .zai, snapshot: before, now: before.updatedAt)
+        #expect(findSeries(store.planUtilizationHistory(for: .zai), name: .weekly, windowMinutes: 10080)?
+            .entries.map(\.usedPercent) == [42])
+
+        store.settings.historicalTrackingEnabled = false
+        #expect(store.supportsPlanUtilizationHistory(for: .zai))
+        let after = UsageSnapshot(
+            primary: RateWindow(usedPercent: 58, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: firstDate.addingTimeInterval(3600))
+        await store.recordPlanUtilizationHistorySample(provider: .zai, snapshot: after, now: after.updatedAt)
+        #expect(findSeries(store.planUtilizationHistory(for: .zai), name: .weekly, windowMinutes: 10080)?
+            .entries.map(\.usedPercent) == [42])
+
+        for _ in 0..<20 where !FileManager.default.fileExists(atPath: providerURL.path) {
+            try await Task.sleep(nanoseconds: 50_000_000)
+        }
+        #expect(FileManager.default.fileExists(atPath: providerURL.path))
+    }
+
+    @MainActor
+    @Test
+    func `generic provider persists weekly extra window`() async {
+        let store = Self.makeStore()
+        store.settings.historicalTrackingEnabled = true
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            extraRateWindows: [
+                NamedRateWindow(
+                    id: "weekly-budget",
+                    title: "Weekly budget",
+                    window: RateWindow(
+                        usedPercent: 42,
+                        windowMinutes: 10080,
+                        resetsAt: nil,
+                        resetDescription: nil)),
+            ],
+            updatedAt: now)
+
+        await store.recordPlanUtilizationHistorySample(provider: .zai, snapshot: snapshot, now: now)
+
+        #expect(findSeries(store.planUtilizationHistory(for: .zai), name: .weekly, windowMinutes: 10080)?
+            .entries.map(\.usedPercent) == [42])
+    }
+
+    @MainActor
+    @Test
+    func `generic provider ignores unknown weekly extra window`() async {
+        let store = Self.makeStore()
+        store.settings.historicalTrackingEnabled = true
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: nil,
+            extraRateWindows: [
+                NamedRateWindow(
+                    id: "weekly-reset-only",
+                    title: "Weekly reset",
+                    window: RateWindow(
+                        usedPercent: 0,
+                        windowMinutes: 10080,
+                        resetsAt: now.addingTimeInterval(3600),
+                        resetDescription: nil),
+                    usageKnown: false),
+            ],
+            updatedAt: now)
+
+        await store.recordPlanUtilizationHistorySample(provider: .zed, snapshot: snapshot, now: now)
+
+        #expect(store.planUtilizationHistory(for: .zed).isEmpty)
+    }
+
+    @MainActor
+    @Test
+    func `generic provider prefers standard weekly window over extra window`() async {
+        let store = Self.makeStore()
+        store.settings.historicalTrackingEnabled = true
+        let now = Date(timeIntervalSince1970: 1_700_000_000)
+        let snapshot = UsageSnapshot(
+            primary: nil,
+            secondary: RateWindow(
+                usedPercent: 42,
+                windowMinutes: 10080,
+                resetsAt: nil,
+                resetDescription: nil),
+            extraRateWindows: [
+                NamedRateWindow(
+                    id: "extra-weekly-budget",
+                    title: "Extra weekly budget",
+                    window: RateWindow(
+                        usedPercent: 84,
+                        windowMinutes: 10080,
+                        resetsAt: nil,
+                        resetDescription: nil)),
+            ],
+            updatedAt: now)
+
+        await store.recordPlanUtilizationHistorySample(provider: .factory, snapshot: snapshot, now: now)
+
+        #expect(findSeries(store.planUtilizationHistory(for: .factory), name: .weekly, windowMinutes: 10080)?
+            .entries.map(\.usedPercent) == [42])
+    }
+
+    @MainActor
+    @Test
+    func `concurrent plan history writes coalesce within single hour bucket per series`() async throws {
+        let store = Self.makeStore()
+        let snapshot = Self.makeSnapshot(provider: .codex, email: "alice@example.com")
+        store._setSnapshotForTesting(snapshot, provider: .codex)
+        let calendar = Calendar(identifier: .gregorian)
+        let hourStart = try #require(calendar.date(from: DateComponents(
+            timeZone: TimeZone(secondsFromGMT: 0),
+            year: 2026,
+            month: 3,
+            day: 17,
+            hour: 10)))
+        let writeTimes = [
+            hourStart.addingTimeInterval(5 * 60),
+            hourStart.addingTimeInterval(25 * 60),
+            hourStart.addingTimeInterval(45 * 60),
+        ]
+
+        await withTaskGroup(of: Void.self) { group in
+            for writeTime in writeTimes {
+                group.addTask {
+                    await store.recordPlanUtilizationHistorySample(
+                        provider: .codex,
+                        snapshot: snapshot,
+                        now: writeTime)
+                }
+            }
+        }
+
+        let histories = try #require(store.planUtilizationHistory[.codex]?.accounts.values.first)
+        #expect(findSeries(histories, name: .session, windowMinutes: 300)?.entries.count == 1)
+        #expect(findSeries(histories, name: .weekly, windowMinutes: 10080)?.entries.count == 1)
+    }
+
+    @Test
+    func `runtime does not load unsupported plan history file`() throws {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        let directoryURL = root
+            .appendingPathComponent("com.steipete.codexbar", isDirectory: true)
+            .appendingPathComponent("history", isDirectory: true)
+        let providerURL = directoryURL.appendingPathComponent("codex.json")
+        let store = PlanUtilizationHistoryStore(directoryURL: directoryURL)
+        try FileManager.default.createDirectory(
+            at: directoryURL,
+            withIntermediateDirectories: true)
+
+        let unsupportedJSON = """
+        {
+          "version": 999,
+          "unscoped": [],
+          "accounts": {}
+        }
+        """
+        try Data(unsupportedJSON.utf8).write(to: providerURL, options: Data.WritingOptions.atomic)
+
+        let loaded = store.load()
+        #expect(loaded.isEmpty)
+    }
+
+    @Test
+    func `store drops invalid zero minute and empty histories when loading and saving`() throws {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        let directoryURL = root
+            .appendingPathComponent("com.steipete.codexbar", isDirectory: true)
+            .appendingPathComponent("history", isDirectory: true)
+        let providerURL = directoryURL.appendingPathComponent("codex.json")
+        let store = PlanUtilizationHistoryStore(directoryURL: directoryURL)
+        try FileManager.default.createDirectory(
+            at: directoryURL,
+            withIntermediateDirectories: true)
+
+        let validUnscoped = planSeries(name: .session, windowMinutes: 300, entries: [
+            planEntry(at: Date(timeIntervalSince1970: 1_700_000_000), usedPercent: 12),
+        ])
+        let validAccount = planSeries(name: .weekly, windowMinutes: 10080, entries: [
+            planEntry(at: Date(timeIntervalSince1970: 1_700_086_400), usedPercent: 64),
+        ])
+        let document = PersistedFixtureDocument(
+            version: 1,
+            preferredAccountKey: "alice",
+            unscoped: [
+                planSeries(name: .session, windowMinutes: 0, entries: [
+                    planEntry(at: Date(timeIntervalSince1970: 1_700_000_000), usedPercent: 99),
+                ]),
+                planSeries(name: .weekly, windowMinutes: 10080, entries: []),
+                validUnscoped,
+            ],
+            accounts: [
+                "alice": [
+                    planSeries(name: .session, windowMinutes: 0, entries: [
+                        planEntry(at: Date(timeIntervalSince1970: 1_700_000_000), usedPercent: 88),
+                    ]),
+                    validAccount,
+                ],
+                "empty": [
+                    planSeries(name: .weekly, windowMinutes: 10080, entries: []),
+                ],
+            ])
+        let encoder = JSONEncoder()
+        encoder.dateEncodingStrategy = .iso8601
+        try encoder.encode(document).write(to: providerURL, options: Data.WritingOptions.atomic)
+
+        let loaded = store.load()
+        let loadedBuckets = try #require(loaded[.codex])
+        #expect(loadedBuckets.unscoped == [validUnscoped])
+        #expect(loadedBuckets.accounts == ["alice": [validAccount]])
+
+        store.save(loaded)
+
+        let decoder = JSONDecoder()
+        decoder.dateDecodingStrategy = .iso8601
+        let rewritten = try decoder.decode(PersistedFixtureDocument.self, from: Data(contentsOf: providerURL))
+        #expect(rewritten.unscoped == [validUnscoped])
+        #expect(rewritten.accounts == ["alice": [validAccount]])
+    }
+
+    @Test
+    func `store round trips account buckets with series entries`() {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        let directoryURL = root
+            .appendingPathComponent("com.steipete.codexbar", isDirectory: true)
+            .appendingPathComponent("history", isDirectory: true)
+        let store = PlanUtilizationHistoryStore(directoryURL: directoryURL)
+        let buckets = PlanUtilizationHistoryBuckets(
+            preferredAccountKey: "alice",
+            unscoped: [
+                planSeries(name: .session, windowMinutes: 300, entries: [
+                    planEntry(at: Date(timeIntervalSince1970: 1_699_913_600), usedPercent: 50),
+                ]),
+            ],
+            accounts: [
+                "alice": [
+                    planSeries(name: .session, windowMinutes: 300, entries: [
+                        planEntry(at: Date(timeIntervalSince1970: 1_700_000_000), usedPercent: 10),
+                    ]),
+                    planSeries(name: .weekly, windowMinutes: 10080, entries: [
+                        planEntry(at: Date(timeIntervalSince1970: 1_700_000_000), usedPercent: 20),
+                    ]),
+                ],
+            ])
+
+        store.save([.codex: buckets])
+        let loaded = store.load()
+
+        #expect(loaded == [.codex: buckets])
+    }
+}
+
+extension UsageStorePlanUtilizationTests {
+    private struct PersistedFixtureDocument: Codable {
+        let version: Int
+        let preferredAccountKey: String?
+        let unscoped: [PlanUtilizationSeriesHistory]
+        let accounts: [String: [PlanUtilizationSeriesHistory]]
+    }
+
+    private struct FixtureDocument: Decodable {
+        let preferredAccountKey: String?
+        let unscoped: [PlanUtilizationSeriesHistory]
+        let accounts: [String: [PlanUtilizationSeriesHistory]]
+    }
+
+    @MainActor
+    static func makeStore() -> UsageStore {
+        let suiteName = "UsageStorePlanUtilizationTests-\(UUID().uuidString)"
+        guard let defaults = UserDefaults(suiteName: suiteName) else {
+            fatalError("Failed to create isolated UserDefaults suite for tests")
+        }
+        defaults.removePersistentDomain(forName: suiteName)
+        let configStore = testConfigStore(suiteName: suiteName)
+        let planHistoryStore = testPlanUtilizationHistoryStore(suiteName: suiteName)
+        let temporaryRoot = FileManager.default.temporaryDirectory.standardizedFileURL.path
+        let managedStoreURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent("\(suiteName)-managed-codex-accounts.json")
+        precondition(configStore.fileURL.standardizedFileURL.path.hasPrefix(temporaryRoot))
+        precondition(configStore.fileURL.standardizedFileURL != CodexBarConfigStore.defaultURL().standardizedFileURL)
+        if let historyURL = planHistoryStore.directoryURL?.standardizedFileURL {
+            precondition(historyURL.path.hasPrefix(temporaryRoot))
+        }
+        let managedStore = FileManagedCodexAccountStore(fileURL: managedStoreURL)
+        try? FileManager.default.removeItem(at: managedStoreURL)
+        do {
+            try managedStore.storeAccounts(ManagedCodexAccountSet(
+                version: FileManagedCodexAccountStore.currentVersion,
+                accounts: []))
+        } catch {
+            fatalError("Failed to seed isolated managed Codex account store: \(error)")
+        }
+        let isolatedSettings = SettingsStore(
+            userDefaults: defaults,
+            configStore: configStore,
+            tokenAccountStore: InMemoryTokenAccountStore())
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: isolatedSettings,
+            planUtilizationHistoryStore: planHistoryStore,
+            startupBehavior: .testing)
+        isolatedSettings._test_managedCodexAccountStoreURL = managedStoreURL
+        isolatedSettings.codexActiveSource = .liveSystem
+        store.planUtilizationHistory = [:]
+        return store
+    }
+
+    static func makeSnapshot(provider: UsageProvider, email: String) -> UsageSnapshot {
+        UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 20, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: provider,
+                accountEmail: email,
+                accountOrganization: nil,
+                loginMethod: "plus"))
+    }
+
+    static func loadPlanUtilizationFixture(named name: String) throws -> PlanUtilizationHistoryBuckets {
+        let fixtureURL = URL(fileURLWithPath: #filePath)
+            .deletingLastPathComponent()
+            .appendingPathComponent("Fixtures", isDirectory: true)
+            .appendingPathComponent(name, isDirectory: false)
+        let data = try Data(contentsOf: fixtureURL)
+        let decoder = JSONDecoder()
+        decoder.dateDecodingStrategy = .iso8601
+        let document = try decoder.decode(FixtureDocument.self, from: data)
+        return PlanUtilizationHistoryBuckets(
+            preferredAccountKey: document.preferredAccountKey,
+            unscoped: document.unscoped,
+            accounts: document.accounts)
+    }
+}
+
+func planEntry(at capturedAt: Date, usedPercent: Double, resetsAt: Date? = nil) -> PlanUtilizationHistoryEntry {
+    PlanUtilizationHistoryEntry(capturedAt: capturedAt, usedPercent: usedPercent, resetsAt: resetsAt)
+}
+
+func planSeries(
+    name: PlanUtilizationSeriesName,
+    windowMinutes: Int,
+    entries: [PlanUtilizationHistoryEntry]) -> PlanUtilizationSeriesHistory
+{
+    PlanUtilizationSeriesHistory(name: name, windowMinutes: windowMinutes, entries: entries)
+}
+
+func findSeries(
+    _ histories: [PlanUtilizationSeriesHistory],
+    name: PlanUtilizationSeriesName,
+    windowMinutes: Int) -> PlanUtilizationSeriesHistory?
+{
+    histories.first { $0.name == name && $0.windowMinutes == windowMinutes }
+}
+
+private final class WeeklyLimitResetEventRecorder: @unchecked Sendable {
+    struct Event {
+        let provider: UsageProvider
+        let accountLabel: String?
+        let usedPercent: Double
+    }
+
+    private let provider: UsageProvider
+    private let accountLabel: String?
+    private let lock = NSLock()
+    private var observedEvents: [Event] = []
+    private var token: NSObjectProtocol?
+
+    init(provider: UsageProvider, accountLabel: String?) {
+        self.provider = provider
+        self.accountLabel = accountLabel
+        self.token = NotificationCenter.default.addObserver(
+            forName: .codexbarWeeklyLimitReset,
+            object: nil,
+            queue: nil)
+        { [weak self] notification in
+            guard let self,
+                  let event = notification.object as? WeeklyLimitResetEvent
+            else {
+                return
+            }
+
+            let recorded = MainActor.assumeIsolated { () -> Event? in
+                guard event.provider == self.provider,
+                      event.accountLabel == self.accountLabel
+                else {
+                    return nil
+                }
+                return Event(
+                    provider: event.provider,
+                    accountLabel: event.accountLabel,
+                    usedPercent: event.usedPercent)
+            }
+            guard let recorded else { return }
+
+            self.lock.lock()
+            self.observedEvents.append(recorded)
+            self.lock.unlock()
+        }
+    }
+
+    var events: [Event] {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        return self.observedEvents
+    }
+
+    var count: Int {
+        self.lock.lock()
+        defer { self.lock.unlock() }
+        return self.observedEvents.count
+    }
+
+    func invalidate() {
+        guard let token else { return }
+        NotificationCenter.default.removeObserver(token)
+        self.token = nil
+    }
+
+    deinit {
+        self.invalidate()
+    }
+}
+
+func formattedBoundary(_ date: Date) -> String {
+    let formatter = DateFormatter()
+    formatter.locale = Locale(identifier: "en_US_POSIX")
+    formatter.timeZone = TimeZone.current
+    formatter.dateFormat = "yyyy-MM-dd HH:mm"
+    return formatter.string(from: date)
+}
diff --git a/Tests/CodexBarTests/UsageStoreSessionQuotaTransitionTests.swift b/Tests/CodexBarTests/UsageStoreSessionQuotaTransitionTests.swift
index 73af6fca3c..f6edec7618 100644
--- a/Tests/CodexBarTests/UsageStoreSessionQuotaTransitionTests.swift
+++ b/Tests/CodexBarTests/UsageStoreSessionQuotaTransitionTests.swift
@@ -1,26 +1,40 @@
-import CodexBarCore
 import Foundation
 import Testing
 @testable import CodexBar
+@testable import CodexBarCore
 
 @MainActor
-@Suite
 struct UsageStoreSessionQuotaTransitionTests {
+    private func makeSettings(suiteName: String) -> SettingsStore {
+        let defaults = UserDefaults(suiteName: suiteName)!
+        defaults.removePersistentDomain(forName: suiteName)
+        return SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suiteName),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+    }
+
     @MainActor
     final class SessionQuotaNotifierSpy: SessionQuotaNotifying {
         private(set) var posts: [(transition: SessionQuotaTransition, provider: UsageProvider)] = []
+        private(set) var quotaWarningPosts: [(
+            event: QuotaWarningEvent,
+            provider: UsageProvider,
+            soundEnabled: Bool)] = []
 
         func post(transition: SessionQuotaTransition, provider: UsageProvider, badge _: NSNumber?) {
             self.posts.append((transition: transition, provider: provider))
         }
+
+        func postQuotaWarning(event: QuotaWarningEvent, provider: UsageProvider, soundEnabled: Bool) {
+            self.quotaWarningPosts.append((event: event, provider: provider, soundEnabled: soundEnabled))
+        }
     }
 
     @Test
-    func copilotSwitchFromPrimaryToSecondaryResetsBaseline() {
-        let settings = SettingsStore(
-            configStore: testConfigStore(suiteName: "UsageStoreSessionQuotaTransitionTests-primary-secondary"),
-            zaiTokenStore: NoopZaiTokenStore(),
-            syntheticTokenStore: NoopSyntheticTokenStore())
+    func `copilot switch from primary to secondary resets baseline`() {
+        let settings = self.makeSettings(suiteName: "UsageStoreSessionQuotaTransitionTests-primary-secondary")
         settings.refreshFrequency = .manual
         settings.statusChecksEnabled = false
         settings.sessionQuotaNotificationsEnabled = true
@@ -48,11 +62,8 @@ struct UsageStoreSessionQuotaTransitionTests {
     }
 
     @Test
-    func copilotSwitchFromSecondaryToPrimaryResetsBaseline() {
-        let settings = SettingsStore(
-            configStore: testConfigStore(suiteName: "UsageStoreSessionQuotaTransitionTests-secondary-primary"),
-            zaiTokenStore: NoopZaiTokenStore(),
-            syntheticTokenStore: NoopSyntheticTokenStore())
+    func `copilot switch from secondary to primary resets baseline`() {
+        let settings = self.makeSettings(suiteName: "UsageStoreSessionQuotaTransitionTests-secondary-primary")
         settings.refreshFrequency = .manual
         settings.statusChecksEnabled = false
         settings.sessionQuotaNotificationsEnabled = true
@@ -78,4 +89,775 @@ struct UsageStoreSessionQuotaTransitionTests {
 
         #expect(notifier.posts.isEmpty)
     }
+
+    @Test
+    func `claude weekly primary fallback does not emit session quota notifications`() {
+        let settings = self.makeSettings(suiteName: "UsageStoreSessionQuotaTransitionTests-claude-weekly")
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.sessionQuotaNotificationsEnabled = true
+
+        let notifier = SessionQuotaNotifierSpy()
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            sessionQuotaNotifier: notifier)
+
+        let baseline = UsageSnapshot(
+            primary: RateWindow(usedPercent: 20, windowMinutes: 7 * 24 * 60, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())
+        store.handleSessionQuotaTransition(provider: .claude, snapshot: baseline)
+
+        let depleted = UsageSnapshot(
+            primary: RateWindow(usedPercent: 100, windowMinutes: 7 * 24 * 60, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())
+        store.handleSessionQuotaTransition(provider: .claude, snapshot: depleted)
+
+        #expect(notifier.posts.isEmpty)
+    }
+
+    @Test
+    func `claude spend limit fallback does not emit session or quota warning notifications`() throws {
+        let settings = self.makeSettings(suiteName: "UsageStoreSessionQuotaTransitionTests-claude-spend-limit")
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.sessionQuotaNotificationsEnabled = true
+        settings.quotaWarningNotificationsEnabled = true
+        settings.quotaWarningThresholds = [50, 20]
+
+        let notifier = SessionQuotaNotifierSpy()
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            sessionQuotaNotifier: notifier)
+        let json = """
+        {
+          "extra_usage": {
+            "is_enabled": true,
+            "monthly_limit": 600,
+            "used_credits": 434.43,
+            "utilization": 72,
+            "currency": "USD"
+          }
+        }
+        """
+        let claude = try ClaudeUsageFetcher._mapOAuthUsageForTesting(
+            Data(json.utf8),
+            subscriptionType: "enterprise")
+        let snapshot = ClaudeOAuthFetchStrategy._snapshotForTesting(from: claude)
+
+        store.handleSessionQuotaTransition(provider: .claude, snapshot: snapshot)
+        store.handleQuotaWarningTransitions(provider: .claude, snapshot: snapshot)
+
+        #expect(snapshot.primary == nil)
+        #expect(snapshot.providerCost?.period == "Spend limit")
+        #expect(notifier.posts.isEmpty)
+        #expect(notifier.quotaWarningPosts.isEmpty)
+    }
+
+    @Test
+    func `mimo balance and monthly credits do not emit quota notifications`() {
+        let settings = self.makeSettings(suiteName: "UsageStoreSessionQuotaTransitionTests-mimo-balance")
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.sessionQuotaNotificationsEnabled = true
+        settings.quotaWarningNotificationsEnabled = true
+        settings.quotaWarningThresholds = [50, 20]
+
+        let notifier = SessionQuotaNotifierSpy()
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            sessionQuotaNotifier: notifier)
+        let balanceSnapshot = MiMoUsageSnapshot(
+            balance: 0,
+            currency: "USD",
+            updatedAt: Date())
+            .toUsageSnapshot()
+        let tokenPlanSnapshot = MiMoUsageSnapshot(
+            balance: 25.51,
+            currency: "USD",
+            planCode: "standard",
+            tokenUsed: 100,
+            tokenLimit: 100,
+            tokenPercent: 1,
+            updatedAt: Date())
+            .toUsageSnapshot()
+
+        for snapshot in [balanceSnapshot, tokenPlanSnapshot] {
+            store.handleSessionQuotaTransition(provider: .mimo, snapshot: snapshot)
+            store.handleQuotaWarningTransitions(provider: .mimo, snapshot: snapshot)
+        }
+
+        #expect(notifier.posts.isEmpty)
+        #expect(notifier.quotaWarningPosts.isEmpty)
+    }
+
+    @Test
+    func `claude five hour primary still emits session quota notifications`() {
+        let settings = self.makeSettings(suiteName: "UsageStoreSessionQuotaTransitionTests-claude-session")
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.sessionQuotaNotificationsEnabled = true
+
+        let notifier = SessionQuotaNotifierSpy()
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            sessionQuotaNotifier: notifier)
+
+        let baseline = UsageSnapshot(
+            primary: RateWindow(usedPercent: 20, windowMinutes: 5 * 60, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())
+        store.handleSessionQuotaTransition(provider: .claude, snapshot: baseline)
+
+        let depleted = UsageSnapshot(
+            primary: RateWindow(usedPercent: 100, windowMinutes: 5 * 60, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())
+        store.handleSessionQuotaTransition(provider: .claude, snapshot: depleted)
+
+        #expect(notifier.posts.map(\.provider) == [.claude])
+    }
+
+    @Test
+    func `antigravity session notification uses quota summary duration instead of family representative`() {
+        let settings = self.makeSettings(suiteName: "UsageStoreSessionQuotaTransitionTests-antigravity-session")
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.sessionQuotaNotificationsEnabled = true
+
+        let notifier = SessionQuotaNotifierSpy()
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            sessionQuotaNotifier: notifier)
+
+        store.handleSessionQuotaTransition(
+            provider: .antigravity,
+            snapshot: self.antigravityQuotaSummarySnapshot(sessionUsed: 20, weeklyUsed: 100))
+        store.handleSessionQuotaTransition(
+            provider: .antigravity,
+            snapshot: self.antigravityQuotaSummarySnapshot(sessionUsed: 100, weeklyUsed: 100))
+
+        #expect(notifier.posts.map(\.provider) == [.antigravity])
+        #expect(notifier.posts.map(\.transition) == [.depleted])
+    }
+
+    @Test
+    func `antigravity preserves session notifications for durationless legacy family lanes`() {
+        let settings = self.makeSettings(suiteName: "UsageStoreSessionQuotaTransitionTests-antigravity-legacy-session")
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.sessionQuotaNotificationsEnabled = true
+
+        let notifier = SessionQuotaNotifierSpy()
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            sessionQuotaNotifier: notifier)
+
+        store.handleSessionQuotaTransition(
+            provider: .antigravity,
+            snapshot: self.antigravityLegacySnapshot(geminiUsed: 20, claudeUsed: 20))
+        store.handleSessionQuotaTransition(
+            provider: .antigravity,
+            snapshot: self.antigravityLegacySnapshot(geminiUsed: 20, claudeUsed: 100))
+
+        #expect(notifier.posts.map(\.provider) == [.antigravity])
+        #expect(notifier.posts.map(\.transition) == [.depleted])
+    }
+
+    @Test
+    func `antigravity snapshot mode change resets session notification baseline`() {
+        let settings = self.makeSettings(suiteName: "UsageStoreSessionQuotaTransitionTests-antigravity-mode-change")
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.sessionQuotaNotificationsEnabled = true
+
+        let notifier = SessionQuotaNotifierSpy()
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            sessionQuotaNotifier: notifier)
+
+        store.handleSessionQuotaTransition(
+            provider: .antigravity,
+            snapshot: self.antigravityQuotaSummarySnapshot(sessionUsed: 20, weeklyUsed: 20))
+        store.handleSessionQuotaTransition(
+            provider: .antigravity,
+            snapshot: self.antigravityLegacySnapshot(geminiUsed: 100, claudeUsed: 100))
+
+        #expect(notifier.posts.isEmpty)
+    }
+
+    @Test
+    func `quota warning disabled does not post`() {
+        let settings = self.makeSettings(suiteName: "UsageStoreSessionQuotaTransitionTests-warning-disabled")
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.quotaWarningNotificationsEnabled = false
+
+        let notifier = SessionQuotaNotifierSpy()
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            sessionQuotaNotifier: notifier)
+
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 90, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            updatedAt: Date())
+        store.handleQuotaWarningTransitions(provider: .codex, snapshot: snapshot)
+
+        #expect(notifier.quotaWarningPosts.isEmpty)
+    }
+
+    @Test
+    func `quota warning posts once per downward threshold crossing`() {
+        let settings = self.makeSettings(suiteName: "UsageStoreSessionQuotaTransitionTests-warning-once")
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.quotaWarningNotificationsEnabled = true
+        settings.quotaWarningThresholds = [50, 20]
+        settings.setQuotaWarningWindowEnabled(.session, enabled: true)
+        settings.setQuotaWarningWindowEnabled(.weekly, enabled: true)
+
+        let notifier = SessionQuotaNotifierSpy()
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            sessionQuotaNotifier: notifier)
+
+        store.handleQuotaWarningTransitions(
+            provider: .codex,
+            snapshot: UsageSnapshot(
+                primary: RateWindow(usedPercent: 40, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date(),
+                identity: ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: "person@example.com",
+                    accountOrganization: nil,
+                    loginMethod: nil)))
+        store.handleQuotaWarningTransitions(
+            provider: .codex,
+            snapshot: UsageSnapshot(
+                primary: RateWindow(usedPercent: 55, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date(),
+                identity: ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: "person@example.com",
+                    accountOrganization: nil,
+                    loginMethod: nil)))
+        store.handleQuotaWarningTransitions(
+            provider: .codex,
+            snapshot: UsageSnapshot(
+                primary: RateWindow(usedPercent: 60, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date(),
+                identity: ProviderIdentitySnapshot(
+                    providerID: .codex,
+                    accountEmail: "person@example.com",
+                    accountOrganization: nil,
+                    loginMethod: nil)))
+
+        #expect(notifier.quotaWarningPosts.count == 1)
+        #expect(notifier.quotaWarningPosts.first?.event.window == .session)
+        #expect(notifier.quotaWarningPosts.first?.event.threshold == 50)
+        #expect(notifier.quotaWarningPosts.first?.event.accountDisplayName == "person@example.com")
+    }
+
+    @Test
+    func `quota warning omits account when personal info is hidden`() {
+        let settings = self.makeSettings(suiteName: "UsageStoreSessionQuotaTransitionTests-warning-account-hidden")
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.hidePersonalInfo = true
+        settings.quotaWarningNotificationsEnabled = true
+        settings.quotaWarningThresholds = [50]
+        settings.setQuotaWarningWindowEnabled(.session, enabled: true)
+
+        let notifier = SessionQuotaNotifierSpy()
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            sessionQuotaNotifier: notifier)
+        let identity = ProviderIdentitySnapshot(
+            providerID: .codex,
+            accountEmail: "person@example.com",
+            accountOrganization: nil,
+            loginMethod: nil)
+
+        store.handleQuotaWarningTransitions(
+            provider: .codex,
+            snapshot: UsageSnapshot(
+                primary: RateWindow(usedPercent: 40, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date(),
+                identity: identity))
+        store.handleQuotaWarningTransitions(
+            provider: .codex,
+            snapshot: UsageSnapshot(
+                primary: RateWindow(usedPercent: 55, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date(),
+                identity: identity))
+
+        #expect(notifier.quotaWarningPosts.count == 1)
+        #expect(notifier.quotaWarningPosts.first?.event.accountDisplayName == nil)
+    }
+
+    @Test
+    func `hidden quota warning markers do not disable warning notifications`() {
+        let settings = self.makeSettings(suiteName: "UsageStoreSessionQuotaTransitionTests-warning-markers-hidden")
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.quotaWarningNotificationsEnabled = true
+        settings.quotaWarningMarkersVisible = false
+        settings.quotaWarningThresholds = [50, 20]
+        settings.setQuotaWarningWindowEnabled(.session, enabled: true)
+        settings.setQuotaWarningWindowEnabled(.weekly, enabled: true)
+
+        let notifier = SessionQuotaNotifierSpy()
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            sessionQuotaNotifier: notifier)
+
+        store.handleQuotaWarningTransitions(
+            provider: .codex,
+            snapshot: UsageSnapshot(
+                primary: RateWindow(usedPercent: 40, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date()))
+        store.handleQuotaWarningTransitions(
+            provider: .codex,
+            snapshot: UsageSnapshot(
+                primary: RateWindow(usedPercent: 55, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date()))
+
+        #expect(notifier.quotaWarningPosts.count == 1)
+        #expect(notifier.quotaWarningPosts.first?.event.threshold == 50)
+    }
+
+    @Test
+    func `quota warning crossing multiple thresholds posts most severe only`() {
+        let settings = self.makeSettings(suiteName: "UsageStoreSessionQuotaTransitionTests-warning-severe")
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.quotaWarningNotificationsEnabled = true
+        settings.quotaWarningThresholds = [50, 20]
+        settings.setQuotaWarningWindowEnabled(.session, enabled: true)
+        settings.setQuotaWarningWindowEnabled(.weekly, enabled: true)
+
+        let notifier = SessionQuotaNotifierSpy()
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            sessionQuotaNotifier: notifier)
+
+        store.handleQuotaWarningTransitions(
+            provider: .codex,
+            snapshot: UsageSnapshot(
+                primary: RateWindow(usedPercent: 10, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date()))
+        store.handleQuotaWarningTransitions(
+            provider: .codex,
+            snapshot: UsageSnapshot(
+                primary: RateWindow(usedPercent: 85, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date()))
+
+        #expect(notifier.quotaWarningPosts.map(\.event.threshold) == [20])
+    }
+
+    @Test
+    func `quota warning recovers and can fire again`() {
+        let settings = self.makeSettings(suiteName: "UsageStoreSessionQuotaTransitionTests-warning-recover")
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.quotaWarningNotificationsEnabled = true
+        settings.quotaWarningThresholds = [50]
+        settings.setQuotaWarningWindowEnabled(.session, enabled: true)
+        settings.setQuotaWarningWindowEnabled(.weekly, enabled: true)
+
+        let notifier = SessionQuotaNotifierSpy()
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            sessionQuotaNotifier: notifier)
+
+        for used in [40, 55, 10, 55] {
+            store.handleQuotaWarningTransitions(
+                provider: .codex,
+                snapshot: UsageSnapshot(
+                    primary: RateWindow(
+                        usedPercent: Double(used),
+                        windowMinutes: nil,
+                        resetsAt: nil,
+                        resetDescription: nil),
+                    secondary: nil,
+                    updatedAt: Date()))
+        }
+
+        #expect(notifier.quotaWarningPosts.map(\.event.threshold) == [50, 50])
+    }
+
+    @Test
+    func `quota warning provider override beats global thresholds`() {
+        let settings = self.makeSettings(suiteName: "UsageStoreSessionQuotaTransitionTests-warning-override")
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.quotaWarningNotificationsEnabled = true
+        settings.quotaWarningThresholds = [50]
+        settings.setQuotaWarningWindowEnabled(.session, enabled: true)
+        settings.setQuotaWarningWindowEnabled(.weekly, enabled: true)
+        settings.setQuotaWarningThresholds(provider: .codex, window: .session, thresholds: [10])
+
+        let notifier = SessionQuotaNotifierSpy()
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            sessionQuotaNotifier: notifier)
+
+        store.handleQuotaWarningTransitions(
+            provider: .codex,
+            snapshot: UsageSnapshot(
+                primary: RateWindow(usedPercent: 40, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date()))
+        store.handleQuotaWarningTransitions(
+            provider: .codex,
+            snapshot: UsageSnapshot(
+                primary: RateWindow(usedPercent: 95, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date()))
+
+        #expect(notifier.quotaWarningPosts.map(\.event.threshold) == [10])
+    }
+
+    @Test
+    func `quota warning session only config ignores weekly crossings`() {
+        let settings = self.makeSettings(suiteName: "UsageStoreSessionQuotaTransitionTests-warning-session-only")
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.quotaWarningNotificationsEnabled = true
+        settings.quotaWarningThresholds = [50]
+        settings.setQuotaWarningWindowEnabled(.session, enabled: true)
+        settings.setQuotaWarningWindowEnabled(.weekly, enabled: false)
+
+        let notifier = SessionQuotaNotifierSpy()
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            sessionQuotaNotifier: notifier)
+
+        store.handleQuotaWarningTransitions(
+            provider: .codex,
+            snapshot: UsageSnapshot(
+                primary: RateWindow(usedPercent: 40, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                secondary: RateWindow(usedPercent: 40, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                updatedAt: Date()))
+        store.handleQuotaWarningTransitions(
+            provider: .codex,
+            snapshot: UsageSnapshot(
+                primary: RateWindow(usedPercent: 60, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                secondary: RateWindow(usedPercent: 60, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                updatedAt: Date()))
+
+        #expect(notifier.quotaWarningPosts.map(\.event.window) == [.session])
+    }
+
+    @Test
+    func `quota warning weekly only config ignores session crossings`() {
+        let settings = self.makeSettings(suiteName: "UsageStoreSessionQuotaTransitionTests-warning-weekly-only")
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.quotaWarningNotificationsEnabled = true
+        settings.quotaWarningThresholds = [50]
+        settings.setQuotaWarningWindowEnabled(.session, enabled: false)
+        settings.setQuotaWarningWindowEnabled(.weekly, enabled: true)
+
+        let notifier = SessionQuotaNotifierSpy()
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            sessionQuotaNotifier: notifier)
+
+        store.handleQuotaWarningTransitions(
+            provider: .codex,
+            snapshot: UsageSnapshot(
+                primary: RateWindow(usedPercent: 40, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                secondary: RateWindow(usedPercent: 40, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                updatedAt: Date()))
+        store.handleQuotaWarningTransitions(
+            provider: .codex,
+            snapshot: UsageSnapshot(
+                primary: RateWindow(usedPercent: 60, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                secondary: RateWindow(usedPercent: 60, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                updatedAt: Date()))
+
+        #expect(notifier.quotaWarningPosts.map(\.event.window) == [.weekly])
+    }
+
+    @Test
+    func `minimax quota warning posts for session and weekly windows`() {
+        let settings = self.makeSettings(suiteName: "UsageStoreSessionQuotaTransitionTests-warning-minimax")
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.quotaWarningNotificationsEnabled = true
+        settings.quotaWarningThresholds = [50, 20]
+        settings.setQuotaWarningWindowEnabled(.session, enabled: true)
+        settings.setQuotaWarningWindowEnabled(.weekly, enabled: true)
+
+        let notifier = SessionQuotaNotifierSpy()
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            sessionQuotaNotifier: notifier)
+
+        store.handleQuotaWarningTransitions(
+            provider: .minimax,
+            snapshot: self.minimaxSnapshot(sessionUsed: 40, weeklyUsed: 40))
+        store.handleQuotaWarningTransitions(
+            provider: .minimax,
+            snapshot: self.minimaxSnapshot(sessionUsed: 55, weeklyUsed: 55))
+
+        #expect(notifier.quotaWarningPosts.map(\.provider) == [.minimax, .minimax])
+        #expect(notifier.quotaWarningPosts.map(\.event.window) == [.session, .weekly])
+        #expect(notifier.quotaWarningPosts.map(\.event.threshold) == [50, 50])
+    }
+
+    @Test
+    func `antigravity quota warnings use named session and weekly durations`() {
+        let settings = self.makeSettings(suiteName: "UsageStoreSessionQuotaTransitionTests-warning-antigravity")
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.quotaWarningNotificationsEnabled = true
+        settings.quotaWarningThresholds = [50]
+        settings.setQuotaWarningWindowEnabled(.session, enabled: true)
+        settings.setQuotaWarningWindowEnabled(.weekly, enabled: true)
+
+        let notifier = SessionQuotaNotifierSpy()
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            sessionQuotaNotifier: notifier)
+
+        store.handleQuotaWarningTransitions(
+            provider: .antigravity,
+            snapshot: self.antigravityQuotaSummarySnapshot(sessionUsed: 40, weeklyUsed: 40))
+        store.handleQuotaWarningTransitions(
+            provider: .antigravity,
+            snapshot: self.antigravityQuotaSummarySnapshot(sessionUsed: 60, weeklyUsed: 60))
+
+        #expect(notifier.quotaWarningPosts.map(\.provider) == [.antigravity, .antigravity])
+        #expect(notifier.quotaWarningPosts.map(\.event.window) == [.session, .weekly])
+        #expect(notifier.quotaWarningPosts.map(\.event.threshold) == [50, 50])
+    }
+
+    @Test
+    func `antigravity legacy quota warnings do not infer weekly from family slots`() {
+        let settings = self.makeSettings(suiteName: "UsageStoreSessionQuotaTransitionTests-warning-antigravity-legacy")
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.quotaWarningNotificationsEnabled = true
+        settings.quotaWarningThresholds = [50]
+        settings.setQuotaWarningWindowEnabled(.session, enabled: true)
+        settings.setQuotaWarningWindowEnabled(.weekly, enabled: true)
+
+        let notifier = SessionQuotaNotifierSpy()
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            sessionQuotaNotifier: notifier)
+
+        store.handleQuotaWarningTransitions(
+            provider: .antigravity,
+            snapshot: self.antigravityLegacySnapshot(geminiUsed: 40, claudeUsed: 40))
+        store.handleQuotaWarningTransitions(
+            provider: .antigravity,
+            snapshot: self.antigravityLegacySnapshot(geminiUsed: 60, claudeUsed: 60))
+
+        #expect(notifier.quotaWarningPosts.map(\.event.window) == [.session])
+    }
+
+    @Test
+    func `antigravity quota warning mode change resets warning baseline`() {
+        let settings = self.makeSettings(suiteName: "UsageStoreSessionQuotaTransitionTests-warning-antigravity-mode")
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.quotaWarningNotificationsEnabled = true
+        settings.quotaWarningThresholds = [50]
+        settings.setQuotaWarningWindowEnabled(.session, enabled: true)
+        settings.setQuotaWarningWindowEnabled(.weekly, enabled: true)
+
+        let notifier = SessionQuotaNotifierSpy()
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            sessionQuotaNotifier: notifier)
+
+        store.handleQuotaWarningTransitions(
+            provider: .antigravity,
+            snapshot: self.antigravityQuotaSummarySnapshot(sessionUsed: 20, weeklyUsed: 20))
+        store.handleQuotaWarningTransitions(
+            provider: .antigravity,
+            snapshot: self.antigravityLegacySnapshot(geminiUsed: 80, claudeUsed: 40))
+
+        #expect(notifier.quotaWarningPosts.isEmpty)
+        let key = UsageStore.QuotaWarningStateKey(provider: .antigravity, window: .session)
+        #expect(store.quotaWarningState[key]?.lastRemaining == 20)
+        #expect(store.quotaWarningState[key]?.source == .antigravityLegacy)
+    }
+
+    @Test
+    func `disabling quota warning window clears fired state`() {
+        let settings = self
+            .makeSettings(suiteName: "UsageStoreSessionQuotaTransitionTests-warning-disabled-clears-state")
+        settings.refreshFrequency = .manual
+        settings.statusChecksEnabled = false
+        settings.quotaWarningNotificationsEnabled = true
+        settings.quotaWarningThresholds = [50]
+
+        let notifier = SessionQuotaNotifierSpy()
+        let store = UsageStore(
+            fetcher: UsageFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings,
+            sessionQuotaNotifier: notifier)
+
+        store.handleQuotaWarningTransitions(
+            provider: .codex,
+            snapshot: UsageSnapshot(
+                primary: RateWindow(usedPercent: 40, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date()))
+        store.handleQuotaWarningTransitions(
+            provider: .codex,
+            snapshot: UsageSnapshot(
+                primary: RateWindow(usedPercent: 60, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date()))
+
+        settings.setQuotaWarningWindowEnabled(.session, enabled: false)
+        store.handleQuotaWarningTransitions(
+            provider: .codex,
+            snapshot: UsageSnapshot(
+                primary: RateWindow(usedPercent: 60, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+                secondary: nil,
+                updatedAt: Date()))
+
+        #expect(notifier.quotaWarningPosts.count == 1)
+        #expect(store.quotaWarningState[UsageStore.QuotaWarningStateKey(provider: .codex, window: .session)] == nil)
+    }
+
+    private func minimaxSnapshot(sessionUsed: Double, weeklyUsed: Double) -> UsageSnapshot {
+        let now = Date()
+        return MiniMaxUsageSnapshot(
+            planName: "Plus",
+            availablePrompts: nil,
+            currentPrompts: nil,
+            remainingPrompts: nil,
+            windowMinutes: nil,
+            usedPercent: nil,
+            resetsAt: nil,
+            updatedAt: now,
+            services: [
+                MiniMaxServiceUsage(
+                    serviceType: "text-generation",
+                    windowType: "5 hours",
+                    timeRange: "15:00-20:00(UTC+8)",
+                    usage: Int(sessionUsed),
+                    limit: 100,
+                    percent: sessionUsed,
+                    resetsAt: now.addingTimeInterval(3600),
+                    resetDescription: "Resets in 1 hour"),
+                MiniMaxServiceUsage(
+                    serviceType: "text-generation",
+                    windowType: "Weekly",
+                    timeRange: "06/01 00:00 - 06/08 00:00(UTC+8)",
+                    usage: Int(weeklyUsed),
+                    limit: 100,
+                    percent: weeklyUsed,
+                    resetsAt: now.addingTimeInterval(6 * 24 * 3600),
+                    resetDescription: "Resets in 6 days"),
+            ]).toUsageSnapshot()
+    }
+
+    private func antigravityQuotaSummarySnapshot(sessionUsed: Double, weeklyUsed: Double) -> UsageSnapshot {
+        UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: weeklyUsed,
+                windowMinutes: 7 * 24 * 60,
+                resetsAt: nil,
+                resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: sessionUsed,
+                windowMinutes: 5 * 60,
+                resetsAt: nil,
+                resetDescription: nil),
+            tertiary: nil,
+            extraRateWindows: [
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-gemini-5h",
+                    title: "Gemini Models Five Hour Limit",
+                    window: RateWindow(
+                        usedPercent: sessionUsed,
+                        windowMinutes: 5 * 60,
+                        resetsAt: nil,
+                        resetDescription: nil)),
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-gemini-weekly",
+                    title: "Gemini Models Weekly Limit",
+                    window: RateWindow(
+                        usedPercent: weeklyUsed,
+                        windowMinutes: 7 * 24 * 60,
+                        resetsAt: nil,
+                        resetDescription: nil)),
+            ],
+            updatedAt: Date())
+    }
+
+    private func antigravityLegacySnapshot(geminiUsed: Double, claudeUsed: Double) -> UsageSnapshot {
+        UsageSnapshot(
+            primary: RateWindow(
+                usedPercent: geminiUsed,
+                windowMinutes: nil,
+                resetsAt: nil,
+                resetDescription: nil),
+            secondary: RateWindow(
+                usedPercent: claudeUsed,
+                windowMinutes: nil,
+                resetsAt: nil,
+                resetDescription: nil),
+            updatedAt: Date())
+    }
 }
diff --git a/Tests/CodexBarTests/UsageStoreTimeoutTests.swift b/Tests/CodexBarTests/UsageStoreTimeoutTests.swift
new file mode 100644
index 0000000000..0b3a8e60de
--- /dev/null
+++ b/Tests/CodexBarTests/UsageStoreTimeoutTests.swift
@@ -0,0 +1,61 @@
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct UsageStoreTimeoutTests {
+    private final class ProbeGate: @unchecked Sendable {
+        private let lock = NSLock()
+        private var continuation: CheckedContinuation<Void, Never>?
+        private var released = false
+
+        func wait() async {
+            await withCheckedContinuation { continuation in
+                let shouldResume = self.lock.withLock {
+                    guard !self.released else { return true }
+                    self.continuation = continuation
+                    return false
+                }
+                if shouldResume {
+                    continuation.resume()
+                }
+            }
+        }
+
+        func release() {
+            let continuation = self.lock.withLock {
+                self.released = true
+                let continuation = self.continuation
+                self.continuation = nil
+                return continuation
+            }
+            continuation?.resume()
+        }
+
+        var isReleased: Bool {
+            self.lock.withLock { self.released }
+        }
+    }
+
+    @Test
+    func `timeout does not wait for a cancellation ignoring probe`() async {
+        let gate = ProbeGate()
+        defer { gate.release() }
+
+        let result = await UsageStore.runWithTimeout(seconds: 0.03) {
+            await gate.wait()
+            return "late result"
+        }
+
+        #expect(result == "Probe timed out after 0s")
+        #expect(!gate.isReleased)
+    }
+
+    @Test
+    func `completed probe wins timeout race`() async {
+        let result = await UsageStore.runWithTimeout(seconds: 10) {
+            "probe result"
+        }
+
+        #expect(result == "probe result")
+    }
+}
diff --git a/Tests/CodexBarTests/UsageStoreWidgetSnapshotTests.swift b/Tests/CodexBarTests/UsageStoreWidgetSnapshotTests.swift
new file mode 100644
index 0000000000..53170ec374
--- /dev/null
+++ b/Tests/CodexBarTests/UsageStoreWidgetSnapshotTests.swift
@@ -0,0 +1,198 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+@MainActor
+struct UsageStoreWidgetSnapshotTests {
+    @Test
+    func `widget snapshot includes antigravity grouped usage rows`() async throws {
+        let suite = "UsageStoreWidgetSnapshotTests-antigravity-grouped"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.statusChecksEnabled = false
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings)
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 10, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            secondary: RateWindow(usedPercent: 20, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            tertiary: RateWindow(usedPercent: 30, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .antigravity,
+                accountEmail: nil,
+                accountOrganization: nil,
+                loginMethod: "Pro"))
+
+        store._setSnapshotForTesting(snapshot, provider: .antigravity)
+
+        var widgetSnapshots: [WidgetSnapshot] = []
+        store._test_widgetSnapshotSaveOverride = { widgetSnapshots.append($0) }
+        defer { store._test_widgetSnapshotSaveOverride = nil }
+
+        store.persistWidgetSnapshot(reason: "antigravity-grouped-test")
+        await store.widgetSnapshotPersistTask?.value
+
+        let entry = try #require(widgetSnapshots.last?.entries.first { $0.provider == .antigravity })
+        #expect(entry.usageRows?.map(\.id) == ["primary", "secondary"])
+        #expect(entry.usageRows?.map(\.title) == ["Gemini Models", "Claude and GPT"])
+        #expect(entry.usageRows?.compactMap(\.percentLeft) == [90, 80])
+    }
+
+    @Test
+    func `widget snapshot includes antigravity quota summary rows`() async throws {
+        let suite = "UsageStoreWidgetSnapshotTests-antigravity-quota-summary"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.statusChecksEnabled = false
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings)
+        let snapshot = UsageSnapshot(
+            primary: RateWindow(usedPercent: 27, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
+            secondary: nil,
+            tertiary: nil,
+            extraRateWindows: [
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-gemini-5h",
+                    title: "Gemini Models Five Hour Limit",
+                    window: RateWindow(usedPercent: 9, windowMinutes: 300, resetsAt: nil, resetDescription: nil)),
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-gemini-weekly",
+                    title: "Gemini Models Weekly Limit",
+                    window: RateWindow(usedPercent: 18, windowMinutes: 10080, resetsAt: nil, resetDescription: nil)),
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-3p-5h",
+                    title: "Claude and GPT models Five Hour Limit",
+                    window: RateWindow(usedPercent: 27, windowMinutes: 300, resetsAt: nil, resetDescription: nil)),
+                NamedRateWindow(
+                    id: "antigravity-quota-summary-3p-weekly",
+                    title: "Claude and GPT models Weekly Limit",
+                    window: RateWindow(usedPercent: 36, windowMinutes: 10080, resetsAt: nil, resetDescription: nil)),
+            ],
+            updatedAt: Date(),
+            identity: ProviderIdentitySnapshot(
+                providerID: .antigravity,
+                accountEmail: nil,
+                accountOrganization: nil,
+                loginMethod: "Pro"))
+
+        store._setSnapshotForTesting(snapshot, provider: .antigravity)
+
+        var widgetSnapshots: [WidgetSnapshot] = []
+        store._test_widgetSnapshotSaveOverride = { widgetSnapshots.append($0) }
+        defer { store._test_widgetSnapshotSaveOverride = nil }
+
+        store.persistWidgetSnapshot(reason: "antigravity-quota-summary-test")
+        await store.widgetSnapshotPersistTask?.value
+
+        let entry = try #require(widgetSnapshots.last?.entries.first { $0.provider == .antigravity })
+        #expect(entry.usageRows?.map(\.title) == [
+            "Gemini Models Five Hour Limit",
+            "Gemini Models Weekly Limit",
+            "Claude and GPT models Five Hour Limit",
+            "Claude and GPT models Weekly Limit",
+        ])
+        #expect(entry.usageRows?.compactMap(\.percentLeft) == [91, 82, 73, 64])
+    }
+
+    @Test
+    func `widget snapshot labels antigravity compact fallback with model name`() async throws {
+        let suite = "UsageStoreWidgetSnapshotTests-antigravity-compact-fallback"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.statusChecksEnabled = false
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings)
+        let snapshot = try AntigravityStatusSnapshot(
+            modelQuotas: [
+                AntigravityModelQuota(
+                    label: "Experimental Model",
+                    modelId: "MODEL_PLACEHOLDER_NEW",
+                    remainingFraction: 0.36,
+                    resetTime: nil,
+                    resetDescription: nil),
+            ],
+            accountEmail: nil,
+            accountPlan: nil,
+            source: .local)
+            .toUsageSnapshot()
+        store._setSnapshotForTesting(snapshot, provider: .antigravity)
+
+        var widgetSnapshots: [WidgetSnapshot] = []
+        store._test_widgetSnapshotSaveOverride = { widgetSnapshots.append($0) }
+        defer { store._test_widgetSnapshotSaveOverride = nil }
+
+        store.persistWidgetSnapshot(reason: "antigravity-compact-fallback-test")
+        await store.widgetSnapshotPersistTask?.value
+
+        let entry = try #require(widgetSnapshots.last?.entries.first { $0.provider == .antigravity })
+        #expect(entry.primary == nil)
+        #expect(entry.usageRows?.map(\.id) == ["antigravity-compact-fallback-MODEL_PLACEHOLDER_NEW"])
+        #expect(entry.usageRows?.map(\.title) == ["Experimental Model"])
+        #expect(entry.usageRows?.compactMap(\.percentLeft) == [36])
+    }
+
+    @Test
+    func `widget snapshot excludes mimo balance from quota rows`() async throws {
+        let suite = "UsageStoreWidgetSnapshotTests-mimo-balance"
+        let defaults = try #require(UserDefaults(suiteName: suite))
+        defaults.removePersistentDomain(forName: suite)
+
+        let settings = SettingsStore(
+            userDefaults: defaults,
+            configStore: testConfigStore(suiteName: suite),
+            zaiTokenStore: NoopZaiTokenStore(),
+            syntheticTokenStore: NoopSyntheticTokenStore())
+        settings.statusChecksEnabled = false
+
+        let store = UsageStore(
+            fetcher: UsageFetcher(environment: [:]),
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            settings: settings)
+        let snapshot = MiMoUsageSnapshot(
+            balance: 25.51,
+            currency: "USD",
+            updatedAt: Date())
+            .toUsageSnapshot()
+        store._setSnapshotForTesting(snapshot, provider: .mimo)
+
+        var widgetSnapshots: [WidgetSnapshot] = []
+        store._test_widgetSnapshotSaveOverride = { widgetSnapshots.append($0) }
+        defer { store._test_widgetSnapshotSaveOverride = nil }
+
+        store.persistWidgetSnapshot(reason: "mimo-balance-test")
+        await store.widgetSnapshotPersistTask?.value
+
+        let entry = try #require(widgetSnapshots.last?.entries.first { $0.provider == .mimo })
+        #expect(entry.primary == nil)
+        #expect(entry.secondary == nil)
+        #expect(entry.usageRows?.isEmpty == true)
+    }
+}
diff --git a/Tests/CodexBarTests/UserFacingLocalizationCoverageTests.swift b/Tests/CodexBarTests/UserFacingLocalizationCoverageTests.swift
new file mode 100644
index 0000000000..b6545f0743
--- /dev/null
+++ b/Tests/CodexBarTests/UserFacingLocalizationCoverageTests.swift
@@ -0,0 +1,112 @@
+import Foundation
+import Testing
+
+struct UserFacingLocalizationCoverageTests {
+    @Test
+    func `selected user-facing UI surfaces avoid raw English literals`() throws {
+        let root = URL(fileURLWithPath: #filePath)
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+            .deletingLastPathComponent()
+
+        let forbiddenMarkersByFile: [String: [String]] = [
+            "Sources/CodexBar/CostHistoryChartMenuView.swift": [
+                ".value(\"Day\"",
+                ".value(\"Cost\"",
+                ".value(\"Cap start\"",
+                ".value(\"Cap end\"",
+            ],
+            "Sources/CodexBar/CreditsHistoryChartMenuView.swift": [
+                ".value(\"Day\"",
+                ".value(\"Credits used\"",
+                ".value(\"Cap start\"",
+                ".value(\"Cap end\"",
+                "Text(\"Total (30d):",
+                "\\(total) credits",
+                "\\(used) credits",
+            ],
+            "Sources/CodexBar/PlanUtilizationHistoryChartMenuView.swift": [
+                ".value(\"Series\"",
+                ".value(\"Capacity Start\"",
+                ".value(\"Capacity End\"",
+                ".value(\"Utilization Start\"",
+                ".value(\"Utilization End\"",
+            ],
+            "Sources/CodexBar/PreferencesCodexAccountsSection.swift": [
+                "?? \"No system account\"",
+                "return \"Adding Account…\"",
+                "return \"Add Account\"",
+                "return \"Re-authenticating…\"",
+                "return \"Re-auth\"",
+                "ProviderSettingsSection(title: \"Accounts\")",
+                "Text(\"Active\")",
+                "Text(\"Choose which Codex account CodexBar should follow.\")",
+                "Text(\"Account\")",
+                "Text(\"No Codex accounts detected yet.\")",
+                "Text(\"System\")",
+                "Text(\"The default Codex account on this Mac.\")",
+                "Text(\"(System)\")",
+                "Button(\"Remove\")",
+            ],
+            "Sources/CodexBar/PreferencesProviderDetailView.swift": [
+                ".help(\"Refresh\")",
+                "accessibilityLabel: \"Usage used\"",
+            ],
+            "Sources/CodexBar/PreferencesProviderErrorView.swift": [
+                ".help(\"Copy error\")",
+            ],
+            "Sources/CodexBar/PreferencesProviderSettingsRows.swift": [
+                "Text(self.title)",
+                "Text(self.toggle.title)",
+                "Text(self.toggle.subtitle)",
+                "Button(action.title)",
+                "Text(self.picker.title)",
+                "Text(option.title)",
+                "Text(trimmedTitle)",
+                "Text(trimmedSubtitle)",
+                "Text(self.descriptor.title)",
+                "Text(self.descriptor.subtitle)",
+                "Text(\"No token accounts yet.\")",
+                "Button(\"Remove\")",
+                "TextField(\"Label\"",
+                "Button(\"Add\")",
+                "TextField(\"Org ID (optional)\"",
+                ".help(\"Optional organization ID for accounts linked to multiple Anthropic organizations.\")",
+                "Button(\"Open token file\")",
+                "Button(\"Reload\")",
+                "Text(\"No organizations loaded. Click Refresh after setting your API key.\")",
+                "Button(\"Refresh organizations\")",
+            ],
+            "Sources/CodexBar/PreferencesProviderSidebarView.swift": [
+                ".help(\"Drag to reorder\")",
+                "\"Disabled —",
+                ".accessibilityLabel(\"Reorder\")",
+            ],
+            "Sources/CodexBar/StatusItemController+UsageHistoryMenu.swift": [
+                "Text(\"Subscription Utilization\")",
+            ],
+            "Sources/CodexBar/StatusItemController+CostMenuCard.swift": [
+                "static let costMenuTitle",
+            ],
+            "Sources/CodexBar/UsageBreakdownChartMenuView.swift": [
+                ".value(\"Day\"",
+                ".value(\"Credits used\"",
+                ".value(\"Service\"",
+                ".value(\"Cap start\"",
+                ".value(\"Cap end\"",
+            ],
+        ]
+
+        var violations: [String] = []
+        for (relativePath, markers) in forbiddenMarkersByFile.sorted(by: { $0.key < $1.key }) {
+            let source = try String(contentsOf: root.appendingPathComponent(relativePath), encoding: .utf8)
+            for marker in markers where source.contains(marker) {
+                violations.append("\(relativePath): \(marker)")
+            }
+        }
+
+        #expect(
+            violations.isEmpty,
+            "Raw user-facing localization markers remain:\n\(violations.joined(separator: "\n"))")
+    }
+}
diff --git a/Tests/CodexBarTests/VeniceSettingsReaderTests.swift b/Tests/CodexBarTests/VeniceSettingsReaderTests.swift
new file mode 100644
index 0000000000..bc44a0645b
--- /dev/null
+++ b/Tests/CodexBarTests/VeniceSettingsReaderTests.swift
@@ -0,0 +1,73 @@
+import CodexBarCore
+import Testing
+
+struct VeniceSettingsReaderTests {
+    @Test
+    func `reads VENICE_API_KEY`() {
+        let env = ["VENICE_API_KEY": "ven-abc123"]
+        #expect(VeniceSettingsReader.apiKey(environment: env) == "ven-abc123")
+    }
+
+    @Test
+    func `falls back to VENICE_KEY`() {
+        let env = ["VENICE_KEY": "ven-fallback"]
+        #expect(VeniceSettingsReader.apiKey(environment: env) == "ven-fallback")
+    }
+
+    @Test
+    func `VENICE_API_KEY takes priority over VENICE_KEY`() {
+        let env = ["VENICE_API_KEY": "ven-primary", "VENICE_KEY": "ven-secondary"]
+        #expect(VeniceSettingsReader.apiKey(environment: env) == "ven-primary")
+    }
+
+    @Test
+    func `trims whitespace`() {
+        let env = ["VENICE_API_KEY": "  ven-trimmed  "]
+        #expect(VeniceSettingsReader.apiKey(environment: env) == "ven-trimmed")
+    }
+
+    @Test
+    func `strips double quotes`() {
+        let env = ["VENICE_API_KEY": "\"ven-quoted\""]
+        #expect(VeniceSettingsReader.apiKey(environment: env) == "ven-quoted")
+    }
+
+    @Test
+    func `strips single quotes`() {
+        let env = ["VENICE_KEY": "'ven-single'"]
+        #expect(VeniceSettingsReader.apiKey(environment: env) == "ven-single")
+    }
+
+    @Test
+    func `returns nil when no key present`() {
+        #expect(VeniceSettingsReader.apiKey(environment: [:]) == nil)
+    }
+
+    @Test
+    func `returns nil for empty key`() {
+        let env = ["VENICE_API_KEY": ""]
+        #expect(VeniceSettingsReader.apiKey(environment: env) == nil)
+    }
+
+    @Test
+    func `returns nil for whitespace-only key`() {
+        let env = ["VENICE_API_KEY": "   "]
+        #expect(VeniceSettingsReader.apiKey(environment: env) == nil)
+    }
+}
+
+struct VeniceProviderTokenResolverTests {
+    @Test
+    func `resolves from environment`() {
+        let env = ["VENICE_API_KEY": "ven-resolve-test"]
+        let resolution = ProviderTokenResolver.veniceResolution(environment: env)
+        #expect(resolution?.token == "ven-resolve-test")
+        #expect(resolution?.source == .environment)
+    }
+
+    @Test
+    func `returns nil when key absent`() {
+        let resolution = ProviderTokenResolver.veniceResolution(environment: [:])
+        #expect(resolution == nil)
+    }
+}
diff --git a/Tests/CodexBarTests/VeniceUsageFetcherTests.swift b/Tests/CodexBarTests/VeniceUsageFetcherTests.swift
new file mode 100644
index 0000000000..fc226997ca
--- /dev/null
+++ b/Tests/CodexBarTests/VeniceUsageFetcherTests.swift
@@ -0,0 +1,297 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct VeniceUsageFetcherTests {
+    @Test
+    func `parses DIEM balance response`() throws {
+        let json = """
+        {
+          "canConsume": true,
+          "consumptionCurrency": "DIEM",
+          "balances": {
+            "diem": 90.50,
+            "usd": null
+          },
+          "diemEpochAllocation": 100.0
+        }
+        """
+        let snapshot = try VeniceUsageFetcher._parseSnapshotForTesting(Data(json.utf8))
+        #expect(snapshot.canConsume == true)
+        #expect(snapshot.consumptionCurrency == "DIEM")
+        #expect(snapshot.diemBalance == 90.50)
+        #expect(snapshot.usdBalance == nil)
+        #expect(snapshot.diemEpochAllocation == 100.0)
+    }
+
+    @Test
+    func `parses USD balance response`() throws {
+        let json = """
+        {
+          "canConsume": true,
+          "consumptionCurrency": "USD",
+          "balances": {
+            "diem": null,
+            "usd": 25.75
+          },
+          "diemEpochAllocation": null
+        }
+        """
+        let snapshot = try VeniceUsageFetcher._parseSnapshotForTesting(Data(json.utf8))
+        #expect(snapshot.canConsume == true)
+        #expect(snapshot.consumptionCurrency == "USD")
+        #expect(snapshot.diemBalance == nil)
+        #expect(snapshot.usdBalance == 25.75)
+        #expect(snapshot.diemEpochAllocation == nil)
+    }
+
+    @Test
+    func `parses string-encoded balances and allocation`() throws {
+        let json = """
+        {
+          "canConsume": true,
+          "consumptionCurrency": "DIEM",
+          "balances": {
+            "diem": "90.50",
+            "usd": "25.75"
+          },
+          "diemEpochAllocation": "100.0"
+        }
+        """
+        let snapshot = try VeniceUsageFetcher._parseSnapshotForTesting(Data(json.utf8))
+        #expect(snapshot.diemBalance == 90.50)
+        #expect(snapshot.usdBalance == 25.75)
+        #expect(snapshot.diemEpochAllocation == 100.0)
+    }
+
+    @Test
+    func `parses both DIEM and USD present`() throws {
+        let json = """
+        {
+          "canConsume": true,
+          "consumptionCurrency": "BUNDLED_CREDITS",
+          "balances": {
+            "diem": 50.0,
+            "usd": 10.0
+          },
+          "diemEpochAllocation": 100.0
+        }
+        """
+        let snapshot = try VeniceUsageFetcher._parseSnapshotForTesting(Data(json.utf8))
+        #expect(snapshot.diemBalance == 50.0)
+        #expect(snapshot.usdBalance == 10.0)
+    }
+
+    @Test
+    func `uses DIEM allocation progress for bundled credits currency`() throws {
+        let json = """
+        {
+          "canConsume": true,
+          "consumptionCurrency": "BUNDLED_CREDITS",
+          "balances": {
+            "diem": 50.0,
+            "usd": 10.0
+          },
+          "diemEpochAllocation": 100.0
+        }
+        """
+        let snapshot = try VeniceUsageFetcher._parseSnapshotForTesting(Data(json.utf8))
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary?.resetDescription?.contains("DIEM 50.00 / 100.00") == true)
+        #expect(usage.primary?.usedPercent == 50.0)
+    }
+
+    @Test
+    func `uses USD display when consumptionCurrency is USD and both balances exist`() throws {
+        let json = """
+        {
+          "canConsume": true,
+          "consumptionCurrency": "USD",
+          "balances": {
+            "diem": 50.0,
+            "usd": 12.34
+          },
+          "diemEpochAllocation": 100.0
+        }
+        """
+        let snapshot = try VeniceUsageFetcher._parseSnapshotForTesting(Data(json.utf8))
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary?.resetDescription == "$12.34 USD remaining")
+        #expect(usage.primary?.usedPercent == 0)
+    }
+
+    @Test
+    func `handles canConsume=false`() throws {
+        let json = """
+        {
+          "canConsume": false,
+          "consumptionCurrency": "USD",
+          "balances": {
+            "diem": null,
+            "usd": 100.0
+          },
+          "diemEpochAllocation": null
+        }
+        """
+        let snapshot = try VeniceUsageFetcher._parseSnapshotForTesting(Data(json.utf8))
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary?.usedPercent == 100)
+        #expect(usage.primary?.resetDescription == "Balance unavailable for API calls")
+    }
+
+    @Test
+    func `displays DIEM with epoch allocation`() throws {
+        let json = """
+        {
+          "canConsume": true,
+          "consumptionCurrency": "DIEM",
+          "balances": {
+            "diem": 75.0,
+            "usd": null
+          },
+          "diemEpochAllocation": 100.0
+        }
+        """
+        let snapshot = try VeniceUsageFetcher._parseSnapshotForTesting(Data(json.utf8))
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary?.resetDescription?.contains("DIEM 75.00 / 100.00") == true)
+        #expect(usage.primary?.usedPercent == 25.0)
+    }
+
+    @Test
+    func `displays DIEM without allocation`() throws {
+        let json = """
+        {
+          "canConsume": true,
+          "consumptionCurrency": "DIEM",
+          "balances": {
+            "diem": 50.0,
+            "usd": null
+          },
+          "diemEpochAllocation": null
+        }
+        """
+        let snapshot = try VeniceUsageFetcher._parseSnapshotForTesting(Data(json.utf8))
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary?.resetDescription?.contains("DIEM 50.00 remaining") == true)
+        #expect(usage.primary?.usedPercent == 0)
+    }
+
+    @Test
+    func `displays USD balance`() throws {
+        let json = """
+        {
+          "canConsume": true,
+          "consumptionCurrency": "USD",
+          "balances": {
+            "diem": null,
+            "usd": 15.50
+          },
+          "diemEpochAllocation": null
+        }
+        """
+        let snapshot = try VeniceUsageFetcher._parseSnapshotForTesting(Data(json.utf8))
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary?.resetDescription?.contains("$15.50") == true)
+        #expect(usage.primary?.usedPercent == 0)
+    }
+
+    @Test
+    func `handles zero balances`() throws {
+        let json = """
+        {
+          "canConsume": true,
+          "consumptionCurrency": "USD",
+          "balances": {
+            "diem": 0.0,
+            "usd": 0.0
+          },
+          "diemEpochAllocation": null
+        }
+        """
+        let snapshot = try VeniceUsageFetcher._parseSnapshotForTesting(Data(json.utf8))
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary?.resetDescription == "No Venice API balance available")
+        #expect(usage.primary?.usedPercent == 100)
+    }
+
+    @Test
+    func `handles null balances with canConsume=true`() throws {
+        let json = """
+        {
+          "canConsume": true,
+          "consumptionCurrency": null,
+          "balances": {
+            "diem": null,
+            "usd": null
+          },
+          "diemEpochAllocation": null
+        }
+        """
+        let snapshot = try VeniceUsageFetcher._parseSnapshotForTesting(Data(json.utf8))
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary?.resetDescription == "No Venice API balance available")
+        #expect(usage.primary?.usedPercent == 100)
+    }
+
+    @Test
+    func `identity uses venice provider ID`() throws {
+        let json = """
+        {
+          "canConsume": true,
+          "consumptionCurrency": "DIEM",
+          "balances": {
+            "diem": 90.0,
+            "usd": null
+          },
+          "diemEpochAllocation": 100.0
+        }
+        """
+        let snapshot = try VeniceUsageFetcher._parseSnapshotForTesting(Data(json.utf8))
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.identity?.providerID == .venice)
+        #expect(usage.identity?.accountEmail == nil)
+        #expect(usage.identity?.accountOrganization == nil)
+    }
+
+    @Test
+    func `throws on malformed JSON`() {
+        let json = "[{ \"canConsume\": true }]"
+        #expect {
+            _ = try VeniceUsageFetcher._parseSnapshotForTesting(Data(json.utf8))
+        } throws: { error in
+            guard case VeniceUsageError.parseFailed = error else { return false }
+            return true
+        }
+    }
+
+    @Test
+    func `throws on invalid JSON`() {
+        let json = "{ invalid json }"
+        #expect {
+            _ = try VeniceUsageFetcher._parseSnapshotForTesting(Data(json.utf8))
+        } throws: { error in
+            guard case VeniceUsageError.parseFailed = error else { return false }
+            return true
+        }
+    }
+
+    @Test
+    func `clamps used percent to 0-100 range`() throws {
+        // Negative used percent should be clamped to 0
+        let json = """
+        {
+          "canConsume": true,
+          "consumptionCurrency": "DIEM",
+          "balances": {
+            "diem": 150.0,
+            "usd": null
+          },
+          "diemEpochAllocation": 100.0
+        }
+        """
+        let snapshot = try VeniceUsageFetcher._parseSnapshotForTesting(Data(json.utf8))
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary?.usedPercent == 0)
+    }
+}
diff --git a/Tests/CodexBarTests/VertexAIOAuthCredentialsTests.swift b/Tests/CodexBarTests/VertexAIOAuthCredentialsTests.swift
new file mode 100644
index 0000000000..9527fdb3c4
--- /dev/null
+++ b/Tests/CodexBarTests/VertexAIOAuthCredentialsTests.swift
@@ -0,0 +1,82 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct VertexAIOAuthCredentialsTests {
+    @Test
+    func `service account credentials from GOOGLE_APPLICATION_CREDENTIALS use gcloud token`() async throws {
+        let fileURL = try Self.writeServiceAccountCredentials()
+        defer { try? FileManager.default.removeItem(at: fileURL.deletingLastPathComponent()) }
+        let env = ["GOOGLE_APPLICATION_CREDENTIALS": fileURL.path]
+
+        #expect(VertexAIOAuthCredentialsStore.hasCredentials(environment: env))
+
+        let override: @Sendable ([String: String]) async throws -> String = { environment in
+            #expect(environment["GOOGLE_APPLICATION_CREDENTIALS"] == fileURL.path)
+            return "ya29.service-account\n"
+        }
+        let credentials = try await VertexAIOAuthCredentialsStore.$gcloudAccessTokenOverrideForTesting.withValue(
+            override)
+        {
+            try await VertexAIOAuthCredentialsStore.loadForFetch(environment: env)
+        }
+
+        #expect(credentials.accessToken == "ya29.service-account")
+        #expect(credentials.projectId == "service-project")
+        #expect(credentials.email == "codexbar@test.iam.gserviceaccount.com")
+        #expect(!credentials.needsRefresh)
+    }
+
+    @Test
+    func `user ADC credentials still parse from CLOUDSDK_CONFIG`() throws {
+        let configDir = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-vertex-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: configDir, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: configDir) }
+
+        let credentialsURL = configDir.appendingPathComponent("application_default_credentials.json")
+        let credentialsJSON = """
+        {
+          "client_id": "client-id",
+          "client_secret": "client-secret",
+          "refresh_token": "refresh-token"
+        }
+        """
+        try credentialsJSON.write(to: credentialsURL, atomically: true, encoding: .utf8)
+
+        let configurationsDir = configDir
+            .appendingPathComponent("configurations", isDirectory: true)
+        try FileManager.default.createDirectory(at: configurationsDir, withIntermediateDirectories: true)
+        try "project = configured-project\n".write(
+            to: configurationsDir.appendingPathComponent("config_default"),
+            atomically: true,
+            encoding: .utf8)
+
+        let env = ["CLOUDSDK_CONFIG": configDir.path]
+        let credentials = try VertexAIOAuthCredentialsStore.load(environment: env)
+
+        #expect(credentials.refreshToken == "refresh-token")
+        #expect(credentials.projectId == "configured-project")
+    }
+
+    private static func writeServiceAccountCredentials() throws -> URL {
+        let directory = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-vertex-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+        let fileURL = directory.appendingPathComponent("service-account.json")
+        let json = """
+        {
+          "type": "service_account",
+          "project_id": "service-project",
+          "private_key_id": "key-id",
+          "private_key": "-----BEGIN PRIVATE KEY-----\\nabc\\n-----END PRIVATE KEY-----\\n",
+          "client_email": "codexbar@test.iam.gserviceaccount.com",
+          "client_id": "1234567890",
+          "token_uri": "https://oauth2.googleapis.com/token"
+        }
+        """
+        try json.write(to: fileURL, atomically: true, encoding: .utf8)
+        return fileURL
+    }
+}
diff --git a/Tests/CodexBarTests/WarpUsageFetcherTests.swift b/Tests/CodexBarTests/WarpUsageFetcherTests.swift
index 9fb74999c3..7d9bf1fc5d 100644
--- a/Tests/CodexBarTests/WarpUsageFetcherTests.swift
+++ b/Tests/CodexBarTests/WarpUsageFetcherTests.swift
@@ -2,10 +2,9 @@ import Foundation
 import Testing
 @testable import CodexBarCore
 
-@Suite
 struct WarpUsageFetcherTests {
     @Test
-    func parsesSnapshotAndAggregatesBonusCredits() throws {
+    func `parses snapshot and aggregates bonus credits`() throws {
         let json = """
         {
           "data": {
@@ -66,7 +65,7 @@ struct WarpUsageFetcherTests {
     }
 
     @Test
-    func graphQLErrorsThrowAPIError() {
+    func `graph QL errors throw API error`() {
         let json = """
         {
           "errors": [
@@ -84,7 +83,7 @@ struct WarpUsageFetcherTests {
     }
 
     @Test
-    func nullUnlimitedAndStringNumericsParseSafely() throws {
+    func `null unlimited and string numerics parse safely`() throws {
         let json = """
         {
           "data": {
@@ -112,7 +111,7 @@ struct WarpUsageFetcherTests {
     }
 
     @Test
-    func unexpectedTypenameReturnsParseError() {
+    func `unexpected typename returns parse error`() {
         let json = """
         {
           "data": {
@@ -132,7 +131,7 @@ struct WarpUsageFetcherTests {
     }
 
     @Test
-    func missingRequestLimitInfoReturnsParseError() {
+    func `missing request limit info returns parse error`() {
         let json = """
         {
           "data": {
@@ -153,7 +152,7 @@ struct WarpUsageFetcherTests {
     }
 
     @Test
-    func invalidRootReturnsParseError() {
+    func `invalid root returns parse error`() {
         let json = """
         [{ "data": {} }]
         """
@@ -167,7 +166,7 @@ struct WarpUsageFetcherTests {
     }
 
     @Test
-    func toUsageSnapshotOmitsSecondaryWhenNoBonusCredits() {
+    func `to usage snapshot omits secondary when no bonus credits`() {
         let source = WarpUsageSnapshot(
             requestLimit: 100,
             requestsUsed: 10,
@@ -184,7 +183,7 @@ struct WarpUsageFetcherTests {
     }
 
     @Test
-    func toUsageSnapshotKeepsBonusWindowWhenBonusExists() throws {
+    func `to usage snapshot keeps bonus window when bonus exists`() throws {
         let source = WarpUsageSnapshot(
             requestLimit: 100,
             requestsUsed: 10,
@@ -202,7 +201,7 @@ struct WarpUsageFetcherTests {
     }
 
     @Test
-    func toUsageSnapshotUnlimitedPrimaryDoesNotShowResetDate() throws {
+    func `to usage snapshot unlimited primary does not show reset date`() throws {
         let source = WarpUsageSnapshot(
             requestLimit: 0,
             requestsUsed: 0,
@@ -221,7 +220,7 @@ struct WarpUsageFetcherTests {
     }
 
     @Test
-    func apiErrorSummaryIncludesPlainTextBodies() {
+    func `api error summary includes plain text bodies`() {
         // Regression: Warp edge returns 429 with a non-JSON body ("Rate exceeded.") when User-Agent is missing/wrong.
         let summary = WarpUsageFetcher._apiErrorSummaryForTesting(
             statusCode: 429,
diff --git a/Tests/CodexBarTests/WebKitTeardownTests.swift b/Tests/CodexBarTests/WebKitTeardownTests.swift
index f824620bc0..b3d4dac15d 100644
--- a/Tests/CodexBarTests/WebKitTeardownTests.swift
+++ b/Tests/CodexBarTests/WebKitTeardownTests.swift
@@ -3,13 +3,12 @@ import AppKit
 import Testing
 @testable import CodexBarCore
 
-@Suite
 @MainActor
 struct WebKitTeardownTests {
     final class Owner {}
 
     @Test
-    func scheduleCleanupRegistersOwner() {
+    func `schedule cleanup registers owner`() {
         let owner = Owner()
         WebKitTeardown.resetForTesting()
         WebKitTeardown.scheduleCleanup(owner: owner, window: nil, webView: nil)
diff --git a/Tests/CodexBarTests/WidgetSnapshotTests.swift b/Tests/CodexBarTests/WidgetSnapshotTests.swift
index 6be63f89e5..d431e7eb6b 100644
--- a/Tests/CodexBarTests/WidgetSnapshotTests.swift
+++ b/Tests/CodexBarTests/WidgetSnapshotTests.swift
@@ -2,23 +2,29 @@ import Foundation
 import Testing
 @testable import CodexBarCore
 
-@Suite
 struct WidgetSnapshotTests {
     @Test
-    func widgetSnapshotRoundTrip() throws {
+    func `widget snapshot round trip`() throws {
         let entry = WidgetSnapshot.ProviderEntry(
             provider: .codex,
             updatedAt: Date(),
             primary: RateWindow(usedPercent: 10, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
             secondary: RateWindow(usedPercent: 20, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
             tertiary: nil,
+            usageRows: [
+                WidgetSnapshot.WidgetUsageRowSnapshot(id: "session", title: "Session", percentLeft: 90),
+                WidgetSnapshot.WidgetUsageRowSnapshot(id: "weekly", title: "Weekly", percentLeft: 80),
+            ],
             creditsRemaining: 123.4,
             codeReviewRemainingPercent: 80,
             tokenUsage: WidgetSnapshot.TokenUsageSummary(
                 sessionCostUSD: 12.3,
                 sessionTokens: 1200,
                 last30DaysCostUSD: 456.7,
-                last30DaysTokens: 9800),
+                last30DaysTokens: 9800,
+                currencyCode: "eur",
+                sessionLabel: "Latest billing day",
+                last30DaysLabel: "This month"),
             dailyUsage: [
                 WidgetSnapshot.DailyUsagePoint(dayKey: "2025-12-20", totalTokens: 1200, costUSD: 12.3),
             ])
@@ -39,11 +45,15 @@ struct WidgetSnapshotTests {
         #expect(decoded.entries.count == 1)
         #expect(decoded.entries.first?.provider == .codex)
         #expect(decoded.entries.first?.tokenUsage?.sessionTokens == 1200)
+        #expect(decoded.entries.first?.tokenUsage?.currencyCode == "EUR")
+        #expect(decoded.entries.first?.tokenUsage?.sessionLabel == "Latest billing day")
+        #expect(decoded.entries.first?.tokenUsage?.last30DaysLabel == "This month")
+        #expect(decoded.entries.first?.usageRows?.map(\.id) == ["session", "weekly"])
         #expect(decoded.enabledProviders == [.codex, .claude])
     }
 
     @Test
-    func widgetSnapshotRoundTripPreservesKiloProvider() throws {
+    func `widget snapshot round trip preserves kilo provider`() throws {
         let entry = WidgetSnapshot.ProviderEntry(
             provider: .kilo,
             updatedAt: Date(),
@@ -80,7 +90,7 @@ struct WidgetSnapshotTests {
     }
 
     @Test
-    func widgetSnapshotRoundTripPreservesKiloZeroTotalEdgeState() throws {
+    func `widget snapshot round trip preserves kilo zero total edge state`() throws {
         let now = Date()
         let kiloSnapshot = KiloUsageSnapshot(
             creditsUsed: 0,
@@ -121,4 +131,76 @@ struct WidgetSnapshotTests {
         #expect(decoded.entries.first?.primary?.resetDescription == "0/0 credits")
         #expect(decoded.enabledProviders == [.kilo])
     }
+
+    @Test
+    func `widget snapshot decodes legacy payload without usage rows`() throws {
+        let json = """
+        {
+          "entries": [
+            {
+              "provider": "codex",
+              "updatedAt": "2026-04-04T06:30:00Z",
+              "primary": null,
+              "secondary": {
+                "usedPercent": 25,
+                "windowMinutes": 10080,
+                "resetsAt": null,
+                "resetDescription": null
+              },
+              "tertiary": null,
+              "creditsRemaining": null,
+              "codeReviewRemainingPercent": null,
+              "tokenUsage": null,
+              "dailyUsage": []
+            }
+          ],
+          "enabledProviders": ["codex"],
+          "generatedAt": "2026-04-04T06:30:00Z"
+        }
+        """
+
+        let decoder = JSONDecoder()
+        decoder.dateDecodingStrategy = .iso8601
+        let decoded = try decoder.decode(WidgetSnapshot.self, from: Data(json.utf8))
+
+        #expect(decoded.entries.count == 1)
+        #expect(decoded.entries.first?.usageRows == nil)
+        #expect(decoded.entries.first?.secondary?.usedPercent == 25)
+    }
+
+    @Test
+    func `widget snapshot decodes legacy token usage as usd`() throws {
+        let json = """
+        {
+          "entries": [
+            {
+              "provider": "codex",
+              "updatedAt": "2026-04-04T06:30:00Z",
+              "primary": null,
+              "secondary": null,
+              "tertiary": null,
+              "creditsRemaining": null,
+              "codeReviewRemainingPercent": null,
+              "tokenUsage": {
+                "sessionCostUSD": 1.25,
+                "sessionTokens": 1200,
+                "last30DaysCostUSD": 9.50,
+                "last30DaysTokens": 4200
+              },
+              "dailyUsage": []
+            }
+          ],
+          "generatedAt": "2026-04-04T06:30:00Z"
+        }
+        """
+
+        let decoder = JSONDecoder()
+        decoder.dateDecodingStrategy = .iso8601
+        let decoded = try decoder.decode(WidgetSnapshot.self, from: Data(json.utf8))
+
+        #expect(decoded.entries.first?.tokenUsage?.currencyCode == "USD")
+        #expect(decoded.entries.first?.tokenUsage?.sessionLabel == "Today")
+        #expect(decoded.entries.first?.tokenUsage?.last30DaysLabel == "30d")
+        #expect(decoded.enabledProviders == [.codex])
+    }
 }
diff --git a/Tests/CodexBarTests/WindsurfDevinSessionImporterTests.swift b/Tests/CodexBarTests/WindsurfDevinSessionImporterTests.swift
new file mode 100644
index 0000000000..3579ba4fd9
--- /dev/null
+++ b/Tests/CodexBarTests/WindsurfDevinSessionImporterTests.swift
@@ -0,0 +1,169 @@
+import Foundation
+import SweetCookieKit
+import Testing
+@testable import CodexBarCore
+
+struct WindsurfDevinSessionImporterTests {
+    @Test
+    func `defaults to Chrome before fallback Chromium browsers`() {
+        #expect(WindsurfDevinSessionImporter.defaultPreferredBrowsers == [.chrome])
+        #expect(!WindsurfDevinSessionImporter.fallbackBrowsers.contains(.chrome))
+        #expect(WindsurfDevinSessionImporter.fallbackBrowsersExcluding([.chrome, .edge]).first == .chromeBeta)
+        #expect(!WindsurfDevinSessionImporter.fallbackBrowsersExcluding([.chrome, .edge]).contains(.edge))
+    }
+
+    @Test
+    func `reads Devin app storage before legacy Windsurf origin`() {
+        #expect(WindsurfDevinSessionImporter.localStorageOrigins.map(\.absoluteString) == [
+            "https://app.devin.ai",
+            "https://windsurf.com",
+        ])
+    }
+
+    @Test
+    func `decodes quoted local storage strings`() {
+        #expect(WindsurfDevinSessionImporter
+            .decodedStorageValue(#""devin-session-token$abc""#) == "devin-session-token$abc")
+        #expect(WindsurfDevinSessionImporter.decodedStorageValue("auth1_xyz") == "auth1_xyz")
+    }
+
+    @Test
+    func `builds session only when all local storage keys exist`() {
+        let storage = [
+            "devin_session_token": "devin-session-token$abc",
+            "devin_auth1_token": "auth1_xyz",
+            "devin_account_id": "account-123",
+            "devin_primary_org_id": "org-456",
+        ]
+
+        let session = WindsurfDevinSessionImporter.session(from: storage, sourceLabel: "Chrome Default")
+
+        #expect(session?.session.sessionToken == "devin-session-token$abc")
+        #expect(session?.session.auth1Token == "auth1_xyz")
+        #expect(session?.session.accountID == "account-123")
+        #expect(session?.session.primaryOrgID == "org-456")
+        #expect(session?.sourceLabel == "Chrome Default")
+    }
+
+    @Test
+    func `keeps partial app origin separate from complete legacy origin`() throws {
+        let appOrigin = try #require(URL(string: "https://app.devin.ai"))
+        let legacyOrigin = try #require(URL(string: "https://windsurf.com"))
+
+        let snapshots = WindsurfDevinSessionImporter.localStorageSnapshots(from: [
+            (
+                origin: appOrigin,
+                entries: [
+                    Self.entry(origin: appOrigin, key: "devin_session_token", value: "app-session"),
+                    Self.entry(origin: appOrigin, key: "devin_auth1_token", value: "app-auth1"),
+                ]),
+            (
+                origin: legacyOrigin,
+                entries: [
+                    Self.entry(origin: legacyOrigin, key: "devin_session_token", value: "legacy-session"),
+                    Self.entry(origin: legacyOrigin, key: "devin_auth1_token", value: "legacy-auth1"),
+                    Self.entry(origin: legacyOrigin, key: "devin_account_id", value: "legacy-account"),
+                    Self.entry(origin: legacyOrigin, key: "devin_primary_org_id", value: "legacy-org"),
+                ]),
+        ])
+
+        #expect(snapshots == [
+            WindsurfDevinSessionImporter.LocalStorageSnapshot(
+                storage: [
+                    "devin_session_token": "legacy-session",
+                    "devin_auth1_token": "legacy-auth1",
+                    "devin_account_id": "legacy-account",
+                    "devin_primary_org_id": "legacy-org",
+                ],
+                sourceSuffix: "windsurf.com"),
+        ])
+    }
+
+    @Test
+    func `keeps text entry fallback after structured origin snapshots`() throws {
+        let appOrigin = try #require(URL(string: "https://app.devin.ai"))
+
+        let snapshots = WindsurfDevinSessionImporter.localStorageSnapshots(
+            from: [
+                (
+                    origin: appOrigin,
+                    entries: [
+                        Self.entry(origin: appOrigin, key: "devin_session_token", value: "stale-app-session"),
+                        Self.entry(origin: appOrigin, key: "devin_auth1_token", value: "stale-app-auth1"),
+                        Self.entry(origin: appOrigin, key: "devin_account_id", value: "stale-app-account"),
+                        Self.entry(origin: appOrigin, key: "devin_primary_org_id", value: "stale-app-org"),
+                    ]),
+            ],
+            textEntries: [
+                Self.textEntry(key: "devin_session_token", value: "legacy-text-session"),
+                Self.textEntry(key: "devin_auth1_token", value: "legacy-text-auth1"),
+                Self.textEntry(key: "devin_account_id", value: "legacy-text-account"),
+                Self.textEntry(key: "devin_primary_org_id", value: "legacy-text-org"),
+            ])
+
+        #expect(snapshots == [
+            WindsurfDevinSessionImporter.LocalStorageSnapshot(
+                storage: [
+                    "devin_session_token": "stale-app-session",
+                    "devin_auth1_token": "stale-app-auth1",
+                    "devin_account_id": "stale-app-account",
+                    "devin_primary_org_id": "stale-app-org",
+                ],
+                sourceSuffix: "app.devin.ai"),
+            WindsurfDevinSessionImporter.LocalStorageSnapshot(
+                storage: [
+                    "devin_session_token": "legacy-text-session",
+                    "devin_auth1_token": "legacy-text-auth1",
+                    "devin_account_id": "legacy-text-account",
+                    "devin_primary_org_id": "legacy-text-org",
+                ],
+                sourceSuffix: nil),
+        ])
+    }
+
+    @Test
+    func `deduplicates repeated session tokens while preserving first source`() {
+        let sessions = [
+            WindsurfDevinSessionImporter.SessionInfo(
+                session: WindsurfDevinSessionAuth(
+                    sessionToken: "devin-session-token$abc",
+                    auth1Token: "auth1_xyz",
+                    accountID: "account-123",
+                    primaryOrgID: "org-456"),
+                sourceLabel: "Chrome Default"),
+            WindsurfDevinSessionImporter.SessionInfo(
+                session: WindsurfDevinSessionAuth(
+                    sessionToken: "devin-session-token$abc",
+                    auth1Token: "auth1_other",
+                    accountID: "account-999",
+                    primaryOrgID: "org-999"),
+                sourceLabel: "Chrome Profile 1"),
+            WindsurfDevinSessionImporter.SessionInfo(
+                session: WindsurfDevinSessionAuth(
+                    sessionToken: "devin-session-token$def",
+                    auth1Token: "auth1_def",
+                    accountID: "account-456",
+                    primaryOrgID: "org-789"),
+                sourceLabel: "Chrome Profile 2"),
+        ]
+
+        let deduplicated = WindsurfDevinSessionImporter.deduplicateSessions(sessions)
+
+        #expect(deduplicated.count == 2)
+        #expect(deduplicated[0].sourceLabel == "Chrome Default")
+        #expect(deduplicated[0].session.sessionToken == "devin-session-token$abc")
+        #expect(deduplicated[1].session.sessionToken == "devin-session-token$def")
+    }
+
+    private static func entry(origin: URL, key: String, value: String) -> ChromiumLocalStorageEntry {
+        ChromiumLocalStorageEntry(
+            origin: origin.absoluteString,
+            key: key,
+            value: value,
+            rawValueLength: value.utf8.count)
+    }
+
+    private static func textEntry(key: String, value: String) -> ChromiumLevelDBTextEntry {
+        ChromiumLevelDBTextEntry(key: key, value: value)
+    }
+}
diff --git a/Tests/CodexBarTests/WindsurfProviderTests.swift b/Tests/CodexBarTests/WindsurfProviderTests.swift
new file mode 100644
index 0000000000..c0b9dd54c5
--- /dev/null
+++ b/Tests/CodexBarTests/WindsurfProviderTests.swift
@@ -0,0 +1,55 @@
+import Testing
+@testable import CodexBarCore
+
+struct WindsurfProviderTests {
+    private func makeContext(
+        sourceMode: ProviderSourceMode,
+        settings: ProviderSettingsSnapshot? = nil) -> ProviderFetchContext
+    {
+        let browserDetection = BrowserDetection(cacheTTL: 0)
+        return ProviderFetchContext(
+            runtime: .app,
+            sourceMode: sourceMode,
+            includeCredits: false,
+            webTimeout: 1,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: [:],
+            settings: settings,
+            fetcher: UsageFetcher(),
+            claudeFetcher: ClaudeUsageFetcher(browserDetection: browserDetection),
+            browserDetection: browserDetection)
+    }
+
+    @Test
+    func `local probe is unavailable in explicit web mode`() async {
+        let strategy = WindsurfLocalFetchStrategy()
+
+        #expect(await strategy.isAvailable(self.makeContext(sourceMode: .web)) == false)
+        #expect(await strategy.isAvailable(self.makeContext(sourceMode: .auto)))
+        #expect(await strategy.isAvailable(self.makeContext(sourceMode: .cli)))
+    }
+
+    @Test
+    func `web mode with cookies off does not fall back to local probe`() async {
+        let settings = ProviderSettingsSnapshot.make(
+            windsurf: .init(
+                usageDataSource: .web,
+                cookieSource: .off,
+                manualCookieHeader: nil))
+        let context = self.makeContext(sourceMode: .web, settings: settings)
+
+        let outcome = await WindsurfProviderDescriptor.descriptor.fetchPlan.fetchOutcome(
+            context: context,
+            provider: .windsurf)
+
+        guard case let .failure(error) = outcome.result else {
+            Issue.record("Expected web-only Windsurf fetch to fail when cookies are off")
+            return
+        }
+
+        #expect(error is ProviderFetchError)
+        #expect(outcome.attempts.map(\.strategyID) == ["windsurf.web", "windsurf.local"])
+        #expect(outcome.attempts.map(\.wasAvailable) == [false, false])
+    }
+}
diff --git a/Tests/CodexBarTests/WindsurfStatusProbeTests.swift b/Tests/CodexBarTests/WindsurfStatusProbeTests.swift
new file mode 100644
index 0000000000..42524a9e7c
--- /dev/null
+++ b/Tests/CodexBarTests/WindsurfStatusProbeTests.swift
@@ -0,0 +1,330 @@
+import CodexBarCore
+import Foundation
+import SQLite3
+import Testing
+
+struct WindsurfStatusProbeTests {
+    // MARK: - Helper
+
+    private static func decode(_ json: String) throws -> WindsurfCachedPlanInfo {
+        try JSONDecoder().decode(WindsurfCachedPlanInfo.self, from: Data(json.utf8))
+    }
+
+    // MARK: - JSON Decoding
+
+    @Test
+    func `decodes full plan info`() throws {
+        let info = try Self.decode("""
+        {
+          "planName": "Pro",
+          "startTimestamp": 1771610750000,
+          "endTimestamp": 1774029950000,
+          "usage": {
+            "messages": 50000,
+            "usedMessages": 35650,
+            "remainingMessages": 14350,
+            "flowActions": 150000,
+            "usedFlowActions": 0,
+            "remainingFlowActions": 150000
+          },
+          "quotaUsage": {
+            "dailyRemainingPercent": 9,
+            "weeklyRemainingPercent": 54,
+            "dailyResetAtUnix": 1774080000,
+            "weeklyResetAtUnix": 1774166400
+          }
+        }
+        """)
+
+        #expect(info.planName == "Pro")
+        #expect(info.startTimestamp == 1_771_610_750_000)
+        #expect(info.endTimestamp == 1_774_029_950_000)
+        #expect(info.usage?.messages == 50000)
+        #expect(info.usage?.usedMessages == 35650)
+        #expect(info.usage?.remainingMessages == 14350)
+        #expect(info.usage?.flowActions == 150_000)
+        #expect(info.usage?.usedFlowActions == 0)
+        #expect(info.usage?.remainingFlowActions == 150_000)
+        #expect(info.quotaUsage?.dailyRemainingPercent == 9)
+        #expect(info.quotaUsage?.weeklyRemainingPercent == 54)
+        #expect(info.quotaUsage?.dailyResetAtUnix == 1_774_080_000)
+        #expect(info.quotaUsage?.weeklyResetAtUnix == 1_774_166_400)
+    }
+
+    @Test
+    func `decodes minimal plan info`() throws {
+        let info = try Self.decode("""
+        {"planName": "Free"}
+        """)
+
+        #expect(info.planName == "Free")
+        #expect(info.usage == nil)
+        #expect(info.quotaUsage == nil)
+        #expect(info.endTimestamp == nil)
+    }
+
+    @Test
+    func `decodes empty object`() throws {
+        let info = try Self.decode("{}")
+
+        #expect(info.planName == nil)
+        #expect(info.usage == nil)
+        #expect(info.quotaUsage == nil)
+    }
+
+    // MARK: - toUsageSnapshot Conversion
+
+    @Test
+    func `converts full plan to usage snapshot`() throws {
+        let info = try Self.decode("""
+        {
+          "planName": "Pro",
+          "startTimestamp": 1771610750000,
+          "endTimestamp": 1774029950000,
+          "usage": {
+            "messages": 50000, "usedMessages": 35650, "remainingMessages": 14350,
+            "flowActions": 150000, "usedFlowActions": 0, "remainingFlowActions": 150000
+          },
+          "quotaUsage": {
+            "dailyRemainingPercent": 9, "weeklyRemainingPercent": 54,
+            "dailyResetAtUnix": 1774080000, "weeklyResetAtUnix": 1774166400
+          }
+        }
+        """)
+
+        let snapshot = info.toUsageSnapshot()
+
+        // Primary = daily: usedPercent = 100 - 9 = 91
+        #expect(snapshot.primary?.usedPercent == 91)
+        #expect(snapshot.primary?.resetsAt != nil)
+
+        // Secondary = weekly: usedPercent = 100 - 54 = 46
+        #expect(snapshot.secondary?.usedPercent == 46)
+        #expect(snapshot.secondary?.resetsAt != nil)
+
+        // Identity
+        #expect(snapshot.identity?.providerID == .windsurf)
+        #expect(snapshot.identity?.loginMethod == "Pro")
+        #expect(snapshot.identity?.accountOrganization != nil)
+    }
+
+    @Test
+    func `converts minimal plan to usage snapshot`() throws {
+        let info = try Self.decode("""
+        {"planName": "Free"}
+        """)
+
+        let snapshot = info.toUsageSnapshot()
+
+        // Without quotaUsage, primary and secondary should be nil
+        #expect(snapshot.primary == nil)
+        #expect(snapshot.secondary == nil)
+        #expect(snapshot.identity?.loginMethod == "Free")
+        #expect(snapshot.identity?.accountOrganization == nil)
+    }
+
+    @Test
+    func `converts usage counts when quota usage is absent`() throws {
+        let info = try Self.decode("""
+        {
+          "planName": "Pro",
+          "usage": {
+            "messages": 50000,
+            "usedMessages": 1200,
+            "remainingMessages": 48800,
+            "flowActions": 150000,
+            "usedFlowActions": 0,
+            "remainingFlowActions": 150000,
+            "flexCredits": 123700,
+            "usedFlexCredits": 0,
+            "remainingFlexCredits": 123700
+          }
+        }
+        """)
+
+        let snapshot = info.toUsageSnapshot()
+
+        #expect(snapshot.primary?.usedPercent == 2.4)
+        #expect(snapshot.primary?.resetDescription == "1200 / 50000 messages")
+        #expect(snapshot.secondary?.usedPercent == 0)
+        #expect(snapshot.secondary?.resetDescription == "0 / 150000 flow actions")
+    }
+
+    @Test
+    func `usage counts infer used amount from remaining`() throws {
+        let info = try Self.decode("""
+        {
+          "planName": "Pro",
+          "usage": {
+            "messages": 100,
+            "remainingMessages": 25
+          }
+        }
+        """)
+
+        let snapshot = info.toUsageSnapshot()
+
+        #expect(snapshot.primary?.usedPercent == 75)
+        #expect(snapshot.primary?.resetDescription == "75 / 100 messages")
+        #expect(snapshot.secondary == nil)
+    }
+
+    @Test
+    func `daily at zero remaining shows 100 percent used`() throws {
+        let info = try Self.decode("""
+        {
+          "planName": "Pro",
+          "quotaUsage": {"dailyRemainingPercent": 0, "weeklyRemainingPercent": 100}
+        }
+        """)
+
+        let snapshot = info.toUsageSnapshot()
+
+        #expect(snapshot.primary?.usedPercent == 100)
+        #expect(snapshot.secondary?.usedPercent == 0)
+    }
+
+    @Test
+    func `weekly at full remaining shows 0 percent used`() throws {
+        let info = try Self.decode("""
+        {
+          "planName": "Pro",
+          "quotaUsage": {"dailyRemainingPercent": 100, "weeklyRemainingPercent": 100}
+        }
+        """)
+
+        let snapshot = info.toUsageSnapshot()
+
+        #expect(snapshot.primary?.usedPercent == 0)
+        #expect(snapshot.secondary?.usedPercent == 0)
+    }
+
+    @Test
+    func `reset dates are correctly converted from unix timestamps`() throws {
+        let info = try Self.decode("""
+        {
+          "planName": "Pro",
+          "quotaUsage": {
+            "dailyRemainingPercent": 50, "weeklyRemainingPercent": 50,
+            "dailyResetAtUnix": 1774080000, "weeklyResetAtUnix": 1774166400
+          }
+        }
+        """)
+
+        let snapshot = info.toUsageSnapshot()
+
+        #expect(snapshot.primary?.resetsAt == Date(timeIntervalSince1970: 1_774_080_000))
+        #expect(snapshot.secondary?.resetsAt == Date(timeIntervalSince1970: 1_774_166_400))
+    }
+
+    @Test
+    func `end timestamp converts to expiry description`() throws {
+        let futureMs = Int64(Date().addingTimeInterval(86400 * 30).timeIntervalSince1970 * 1000)
+        let info = try Self.decode("""
+        {"planName": "Pro", "endTimestamp": \(futureMs)}
+        """)
+
+        let snapshot = info.toUsageSnapshot()
+
+        #expect(snapshot.identity?.accountOrganization?.hasPrefix("Expires ") == true)
+    }
+
+    // MARK: - Probe Database Decoding
+
+    @Test
+    func `probe decodes UTF-8 JSON blob`() throws {
+        let dbURL = try Self.makeTemporaryDatabase(
+            jsonData: Data(#"{"planName":"UTF-8 Pro"}"#.utf8))
+        defer { try? FileManager.default.removeItem(at: dbURL.deletingLastPathComponent()) }
+
+        let info = try WindsurfStatusProbe(dbPath: dbURL.path).fetch()
+
+        #expect(info.planName == "UTF-8 Pro")
+    }
+
+    @Test
+    func `probe decodes UTF-16LE JSON blob`() throws {
+        let jsonData = try #require(#"{"planName":"UTF-16 Pro"}"#.data(using: .utf16LittleEndian))
+        let dbURL = try Self.makeTemporaryDatabase(jsonData: jsonData)
+        defer { try? FileManager.default.removeItem(at: dbURL.deletingLastPathComponent()) }
+
+        let info = try WindsurfStatusProbe(dbPath: dbURL.path).fetch()
+
+        #expect(info.planName == "UTF-16 Pro")
+    }
+
+    // MARK: - Probe Error Cases
+
+    @Test
+    func `probe throws dbNotFound for missing file`() {
+        let probe = WindsurfStatusProbe(dbPath: "/nonexistent/path/state.vscdb")
+
+        #expect(throws: WindsurfStatusProbeError.self) {
+            _ = try probe.fetch()
+        }
+    }
+
+    private static func makeTemporaryDatabase(jsonData: Data) throws -> URL {
+        let directory = FileManager.default.temporaryDirectory
+            .appendingPathComponent("windsurf-status-probe-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+        let dbURL = directory.appendingPathComponent("state.vscdb")
+
+        var db: OpaquePointer?
+        guard sqlite3_open(dbURL.path, &db) == SQLITE_OK else {
+            throw TestSQLiteError.openFailed(String(cString: sqlite3_errmsg(db)))
+        }
+        defer { sqlite3_close(db) }
+
+        try self.execute(
+            """
+            CREATE TABLE ItemTable(
+                key TEXT PRIMARY KEY,
+                value BLOB
+            );
+            """,
+            db: db)
+
+        var stmt: OpaquePointer?
+        guard sqlite3_prepare_v2(
+            db,
+            "INSERT INTO ItemTable(key, value) VALUES('windsurf.settings.cachedPlanInfo', ?);",
+            -1,
+            &stmt,
+            nil) == SQLITE_OK
+        else {
+            throw TestSQLiteError.prepareFailed(String(cString: sqlite3_errmsg(db)))
+        }
+        defer { sqlite3_finalize(stmt) }
+
+        let transient = unsafeBitCast(-1, to: sqlite3_destructor_type.self)
+        let bindResult = jsonData.withUnsafeBytes { buffer in
+            sqlite3_bind_blob(stmt, 1, buffer.baseAddress, Int32(jsonData.count), transient)
+        }
+        guard bindResult == SQLITE_OK else {
+            throw TestSQLiteError.bindFailed(String(cString: sqlite3_errmsg(db)))
+        }
+        guard sqlite3_step(stmt) == SQLITE_DONE else {
+            throw TestSQLiteError.stepFailed(String(cString: sqlite3_errmsg(db)))
+        }
+
+        return dbURL
+    }
+
+    private static func execute(_ sql: String, db: OpaquePointer?) throws {
+        var errorMessage: UnsafeMutablePointer<CChar>?
+        guard sqlite3_exec(db, sql, nil, nil, &errorMessage) == SQLITE_OK else {
+            defer { sqlite3_free(errorMessage) }
+            let message = errorMessage.map { String(cString: $0) } ?? "unknown error"
+            throw TestSQLiteError.execFailed(message)
+        }
+    }
+
+    private enum TestSQLiteError: Error {
+        case openFailed(String)
+        case execFailed(String)
+        case prepareFailed(String)
+        case bindFailed(String)
+        case stepFailed(String)
+    }
+}
diff --git a/Tests/CodexBarTests/WindsurfWebFetcherTests.swift b/Tests/CodexBarTests/WindsurfWebFetcherTests.swift
new file mode 100644
index 0000000000..2ce34f8c22
--- /dev/null
+++ b/Tests/CodexBarTests/WindsurfWebFetcherTests.swift
@@ -0,0 +1,565 @@
+import Foundation
+import SweetCookieKit
+import Testing
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct WindsurfWebFetcherTests {
+    @Test
+    func `missing session guidance names current and legacy origins`() {
+        let message = WindsurfWebFetcherError.noSessionData.errorDescription
+
+        #expect(message?.contains("app.devin.ai") == true)
+        #expect(message?.contains("windsurf.com") == true)
+    }
+
+    private struct ResponseFixture {
+        let planName: String
+        let dailyRemaining: Int
+        let weeklyRemaining: Int
+        let planEndUnix: Int64
+        let dailyResetUnix: Int64
+        let weeklyResetUnix: Int64
+    }
+
+    private func makeSession() -> URLSession {
+        let config = URLSessionConfiguration.ephemeral
+        config.protocolClasses = [WindsurfWebFetcherStubURLProtocol.self]
+        return URLSession(configuration: config)
+    }
+
+    @Test
+    func `manual devin session sends protobuf request and auth headers`() async throws {
+        defer {
+            WindsurfWebFetcherStubURLProtocol.requests = []
+            WindsurfWebFetcherStubURLProtocol.handler = nil
+        }
+
+        WindsurfWebFetcherStubURLProtocol.requests = []
+        WindsurfWebFetcherStubURLProtocol.handler = { request in
+            let url = try #require(request.url)
+            #expect(url.host == "windsurf.com")
+            #expect(request.httpMethod == "POST")
+            #expect(request.value(forHTTPHeaderField: "Content-Type") == "application/proto")
+            #expect(request.value(forHTTPHeaderField: "Connect-Protocol-Version") == "1")
+            #expect(request.value(forHTTPHeaderField: "Origin") == "https://windsurf.com")
+            #expect(request.value(forHTTPHeaderField: "Referer") == "https://windsurf.com/profile")
+            #expect(request.value(forHTTPHeaderField: "x-auth-token") == "devin-session-token$abc")
+            #expect(request.value(forHTTPHeaderField: "x-devin-session-token") == "devin-session-token$abc")
+            #expect(request.value(forHTTPHeaderField: "x-devin-auth1-token") == "auth1_xyz")
+            #expect(request.value(forHTTPHeaderField: "x-devin-account-id") == "account-123")
+            #expect(request.value(forHTTPHeaderField: "x-devin-primary-org-id") == "org-456")
+
+            let body = try WindsurfPlanStatusProtoCodec.decodeRequest(Self.requestBodyData(from: request))
+            #expect(body.authToken == "devin-session-token$abc")
+            #expect(body.includeTopUpStatus == true)
+
+            return Self.makeResponse(
+                url: url,
+                body: Self.makePlanStatusResponse(ResponseFixture(
+                    planName: "Pro",
+                    dailyRemaining: 68,
+                    weeklyRemaining: 84,
+                    planEndUnix: 1_777_888_000,
+                    dailyResetUnix: 1_777_900_000,
+                    weeklyResetUnix: 1_778_000_000)),
+                contentType: "application/proto",
+                statusCode: 200)
+        }
+
+        let manualSession = """
+        {
+          "devin_session_token": "devin-session-token$abc",
+          "devin_auth1_token": "auth1_xyz",
+          "devin_account_id": "account-123",
+          "devin_primary_org_id": "org-456"
+        }
+        """
+
+        let snapshot = try await WindsurfWebFetcher.fetchUsage(
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            cookieSource: .manual,
+            manualSessionInput: manualSession,
+            timeout: 2,
+            session: self.makeSession())
+
+        #expect(WindsurfWebFetcherStubURLProtocol.requests.count == 1)
+        #expect(snapshot.identity?.providerID == .windsurf)
+        #expect(snapshot.identity?.loginMethod == "Pro")
+        #expect(snapshot.primary?.usedPercent == 32)
+        #expect(snapshot.secondary?.usedPercent == 16)
+    }
+
+    @Test
+    func `auto session import retries next profile after auth failure`() async throws {
+        defer {
+            WindsurfDevinSessionImporter.importSessionsOverrideForTesting = nil
+            WindsurfDevinSessionImporter.importPreferredSessionsOverrideForTesting = nil
+            WindsurfDevinSessionImporter.importFallbackSessionsOverrideForTesting = nil
+            WindsurfWebFetcherStubURLProtocol.requests = []
+            WindsurfWebFetcherStubURLProtocol.handler = nil
+        }
+
+        WindsurfDevinSessionImporter.importPreferredSessionsOverrideForTesting = { _, _ in
+            [
+                WindsurfDevinSessionImporter.SessionInfo(
+                    session: WindsurfDevinSessionAuth(
+                        sessionToken: "stale-token",
+                        auth1Token: "stale-auth1",
+                        accountID: "stale-account",
+                        primaryOrgID: "stale-org"),
+                    sourceLabel: "Chrome Default"),
+                WindsurfDevinSessionImporter.SessionInfo(
+                    session: WindsurfDevinSessionAuth(
+                        sessionToken: "fresh-token",
+                        auth1Token: "fresh-auth1",
+                        accountID: "fresh-account",
+                        primaryOrgID: "fresh-org"),
+                    sourceLabel: "Chrome Profile 1"),
+            ]
+        }
+
+        WindsurfWebFetcherStubURLProtocol.requests = []
+        WindsurfWebFetcherStubURLProtocol.handler = { request in
+            let url = try #require(request.url)
+            let token = request.value(forHTTPHeaderField: "x-devin-session-token")
+
+            if token == "stale-token" {
+                return Self.makeResponse(
+                    url: url,
+                    body: Data("unauthorized".utf8),
+                    contentType: "text/plain",
+                    statusCode: 401)
+            }
+
+            #expect(token == "fresh-token")
+            return Self.makeResponse(
+                url: url,
+                body: Self.makePlanStatusResponse(ResponseFixture(
+                    planName: "Teams",
+                    dailyRemaining: 75,
+                    weeklyRemaining: 90,
+                    planEndUnix: 1_777_888_000,
+                    dailyResetUnix: 1_777_900_000,
+                    weeklyResetUnix: 1_778_000_000)),
+                contentType: "application/proto",
+                statusCode: 200)
+        }
+
+        let snapshot = try await WindsurfWebFetcher.fetchUsage(
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            cookieSource: .auto,
+            timeout: 2,
+            session: self.makeSession())
+
+        #expect(WindsurfWebFetcherStubURLProtocol.requests.count == 2)
+        #expect(snapshot.identity?.loginMethod == "Teams")
+        #expect(snapshot.primary?.usedPercent == 25)
+        #expect(snapshot.secondary?.usedPercent == 10)
+    }
+
+    @Test
+    func `auto session import tries fallback browsers after preferred sessions fail`() async throws {
+        defer {
+            WindsurfDevinSessionImporter.importSessionsOverrideForTesting = nil
+            WindsurfDevinSessionImporter.importPreferredSessionsOverrideForTesting = nil
+            WindsurfDevinSessionImporter.importFallbackSessionsOverrideForTesting = nil
+            WindsurfWebFetcherStubURLProtocol.requests = []
+            WindsurfWebFetcherStubURLProtocol.handler = nil
+        }
+
+        WindsurfDevinSessionImporter.importPreferredSessionsOverrideForTesting = { _, _ in
+            [
+                WindsurfDevinSessionImporter.SessionInfo(
+                    session: WindsurfDevinSessionAuth(
+                        sessionToken: "stale-chrome-token",
+                        auth1Token: "stale-auth1",
+                        accountID: "stale-account",
+                        primaryOrgID: "stale-org"),
+                    sourceLabel: "Chrome Default"),
+            ]
+        }
+        WindsurfDevinSessionImporter.importFallbackSessionsOverrideForTesting = { _, _ in
+            [
+                WindsurfDevinSessionImporter.SessionInfo(
+                    session: WindsurfDevinSessionAuth(
+                        sessionToken: "fresh-edge-token",
+                        auth1Token: "fresh-auth1",
+                        accountID: "fresh-account",
+                        primaryOrgID: "fresh-org"),
+                    sourceLabel: "Microsoft Edge Default"),
+            ]
+        }
+
+        WindsurfWebFetcherStubURLProtocol.requests = []
+        WindsurfWebFetcherStubURLProtocol.handler = { request in
+            let url = try #require(request.url)
+            let token = request.value(forHTTPHeaderField: "x-devin-session-token")
+
+            if token == "stale-chrome-token" {
+                return Self.makeResponse(
+                    url: url,
+                    body: Data("unauthorized".utf8),
+                    contentType: "text/plain",
+                    statusCode: 401)
+            }
+
+            #expect(token == "fresh-edge-token")
+            return Self.makeResponse(
+                url: url,
+                body: Self.makePlanStatusResponse(ResponseFixture(
+                    planName: "Teams",
+                    dailyRemaining: 64,
+                    weeklyRemaining: 80,
+                    planEndUnix: 1_777_888_000,
+                    dailyResetUnix: 1_777_900_000,
+                    weeklyResetUnix: 1_778_000_000)),
+                contentType: "application/proto",
+                statusCode: 200)
+        }
+
+        let snapshot = try await WindsurfWebFetcher.fetchUsage(
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            cookieSource: .auto,
+            timeout: 2,
+            session: self.makeSession())
+
+        #expect(WindsurfWebFetcherStubURLProtocol.requests.count == 2)
+        #expect(snapshot.identity?.loginMethod == "Teams")
+        #expect(snapshot.primary?.usedPercent == 36)
+        #expect(snapshot.secondary?.usedPercent == 20)
+    }
+
+    @Test
+    func `auto import uses complete legacy origin when app origin is partial`() async throws {
+        defer {
+            WindsurfDevinSessionImporter.importSessionsOverrideForTesting = nil
+            WindsurfDevinSessionImporter.importPreferredSessionsOverrideForTesting = nil
+            WindsurfDevinSessionImporter.importFallbackSessionsOverrideForTesting = nil
+            WindsurfWebFetcherStubURLProtocol.requests = []
+            WindsurfWebFetcherStubURLProtocol.handler = nil
+        }
+
+        let appOrigin = try #require(URL(string: "https://app.devin.ai"))
+        let legacyOrigin = try #require(URL(string: "https://windsurf.com"))
+        let snapshots = WindsurfDevinSessionImporter.localStorageSnapshots(from: [
+            (
+                origin: appOrigin,
+                entries: [
+                    Self.localStorageEntry(origin: appOrigin, key: "devin_session_token", value: "app-session"),
+                    Self.localStorageEntry(origin: appOrigin, key: "devin_auth1_token", value: "app-auth1"),
+                ]),
+            (
+                origin: legacyOrigin,
+                entries: [
+                    Self.localStorageEntry(origin: legacyOrigin, key: "devin_session_token", value: "legacy-session"),
+                    Self.localStorageEntry(origin: legacyOrigin, key: "devin_auth1_token", value: "legacy-auth1"),
+                    Self.localStorageEntry(origin: legacyOrigin, key: "devin_account_id", value: "legacy-account"),
+                    Self.localStorageEntry(origin: legacyOrigin, key: "devin_primary_org_id", value: "legacy-org"),
+                ]),
+        ])
+
+        let sessionInfos = snapshots.compactMap { snapshot in
+            WindsurfDevinSessionImporter.session(
+                from: snapshot.storage,
+                sourceLabel: "Chrome Default (\(snapshot.sourceSuffix ?? "unknown"))")
+        }
+        WindsurfDevinSessionImporter.importPreferredSessionsOverrideForTesting = { _, _ in sessionInfos }
+
+        WindsurfWebFetcherStubURLProtocol.requests = []
+        WindsurfWebFetcherStubURLProtocol.handler = { request in
+            let url = try #require(request.url)
+            #expect(request.value(forHTTPHeaderField: "x-devin-session-token") == "legacy-session")
+            #expect(request.value(forHTTPHeaderField: "x-devin-auth1-token") == "legacy-auth1")
+            #expect(request.value(forHTTPHeaderField: "x-devin-account-id") == "legacy-account")
+            #expect(request.value(forHTTPHeaderField: "x-devin-primary-org-id") == "legacy-org")
+
+            let body = try WindsurfPlanStatusProtoCodec.decodeRequest(Self.requestBodyData(from: request))
+            #expect(body.authToken == "legacy-session")
+
+            return Self.makeResponse(
+                url: url,
+                body: Self.makePlanStatusResponse(ResponseFixture(
+                    planName: "Pro",
+                    dailyRemaining: 70,
+                    weeklyRemaining: 85,
+                    planEndUnix: 1_777_888_000,
+                    dailyResetUnix: 1_777_900_000,
+                    weeklyResetUnix: 1_778_000_000)),
+                contentType: "application/proto",
+                statusCode: 200)
+        }
+
+        let snapshot = try await WindsurfWebFetcher.fetchUsage(
+            browserDetection: BrowserDetection(cacheTTL: 0),
+            cookieSource: .auto,
+            timeout: 2,
+            session: self.makeSession())
+
+        #expect(snapshots.count == 1)
+        #expect(sessionInfos.map(\.sourceLabel) == ["Chrome Default (windsurf.com)"])
+        #expect(WindsurfWebFetcherStubURLProtocol.requests.count == 1)
+        #expect(snapshot.identity?.loginMethod == "Pro")
+        #expect(snapshot.primary?.usedPercent == 30)
+        #expect(snapshot.secondary?.usedPercent == 15)
+    }
+
+    @Test
+    func `manual mode with empty session does not fall back to imported session`() async {
+        defer {
+            WindsurfDevinSessionImporter.importSessionsOverrideForTesting = nil
+            WindsurfDevinSessionImporter.importPreferredSessionsOverrideForTesting = nil
+            WindsurfDevinSessionImporter.importFallbackSessionsOverrideForTesting = nil
+            WindsurfWebFetcherStubURLProtocol.requests = []
+            WindsurfWebFetcherStubURLProtocol.handler = nil
+        }
+
+        WindsurfDevinSessionImporter.importSessionsOverrideForTesting = { _, _ in
+            [
+                WindsurfDevinSessionImporter.SessionInfo(
+                    session: WindsurfDevinSessionAuth(
+                        sessionToken: "auto-token",
+                        auth1Token: "auto-auth1",
+                        accountID: "auto-account",
+                        primaryOrgID: "auto-org"),
+                    sourceLabel: "Chrome Default"),
+            ]
+        }
+        WindsurfWebFetcherStubURLProtocol.requests = []
+
+        await #expect {
+            _ = try await WindsurfWebFetcher.fetchUsage(
+                browserDetection: BrowserDetection(cacheTTL: 0),
+                cookieSource: .manual,
+                manualSessionInput: "   \n",
+                timeout: 2,
+                session: self.makeSession())
+        } throws: { error in
+            guard case let WindsurfWebFetcherError.invalidManualSession(message) = error else { return false }
+            return message == "empty input"
+        }
+        #expect(WindsurfWebFetcherStubURLProtocol.requests.isEmpty)
+    }
+
+    @Test
+    func `manual key value session input is accepted`() throws {
+        let parsed = try WindsurfWebFetcher.parseManualSessionInput(
+            """
+            devin_session_token=devin-session-token$abc
+            devin_auth1_token=auth1_xyz
+            devin_account_id=account-123
+            devin_primary_org_id=org-456
+            """)
+
+        #expect(parsed.sessionToken == "devin-session-token$abc")
+        #expect(parsed.auth1Token == "auth1_xyz")
+        #expect(parsed.accountID == "account-123")
+        #expect(parsed.primaryOrgID == "org-456")
+    }
+
+    @Test
+    func `manual JSON camelCase aliases are accepted`() throws {
+        let parsed = try WindsurfWebFetcher.parseManualSessionInput(
+            """
+            {
+              "devinSessionToken": "devin-session-token$abc",
+              "devinAuth1Token": "auth1_xyz",
+              "devinAccountId": "account-123",
+              "devinPrimaryOrgId": "org-456"
+            }
+            """)
+
+        #expect(parsed.sessionToken == "devin-session-token$abc")
+        #expect(parsed.auth1Token == "auth1_xyz")
+        #expect(parsed.accountID == "account-123")
+        #expect(parsed.primaryOrgID == "org-456")
+    }
+
+    @Test
+    func `manual session input rejects empty string`() {
+        #expect {
+            try WindsurfWebFetcher.parseManualSessionInput("   \n")
+        } throws: { error in
+            guard case let WindsurfWebFetcherError.invalidManualSession(message) = error else { return false }
+            return message == "empty input"
+        }
+    }
+
+    @Test
+    func `manual session input rejects invalid text`() {
+        #expect {
+            try WindsurfWebFetcher.parseManualSessionInput("not a valid session bundle")
+        } throws: { error in
+            guard case let WindsurfWebFetcherError.invalidManualSession(message) = error else { return false }
+            return message.contains("expected JSON")
+        }
+    }
+
+    @Test
+    func `manual session input rejects missing required fields`() {
+        #expect {
+            try WindsurfWebFetcher.parseManualSessionInput(
+                """
+                {
+                  "devin_session_token": "devin-session-token$abc",
+                  "devin_auth1_token": "auth1_xyz",
+                  "devin_account_id": "account-123"
+                }
+                """)
+        } throws: { error in
+            guard case let WindsurfWebFetcherError.invalidManualSession(message) = error else { return false }
+            return message.contains("expected JSON")
+        }
+    }
+
+    private static func makeResponse(
+        url: URL,
+        body: Data,
+        contentType: String,
+        statusCode: Int) -> (HTTPURLResponse, Data)
+    {
+        let response = HTTPURLResponse(
+            url: url,
+            statusCode: statusCode,
+            httpVersion: "HTTP/1.1",
+            headerFields: ["Content-Type": contentType])!
+        return (response, body)
+    }
+
+    private static func requestBodyData(from request: URLRequest) -> Data {
+        if let data = request.httpBody {
+            return data
+        }
+
+        guard let stream = request.httpBodyStream else {
+            return Data()
+        }
+
+        stream.open()
+        defer { stream.close() }
+
+        var data = Data()
+        let bufferSize = 4096
+        let buffer = UnsafeMutablePointer<UInt8>.allocate(capacity: bufferSize)
+        defer { buffer.deallocate() }
+
+        while stream.hasBytesAvailable {
+            let count = stream.read(buffer, maxLength: bufferSize)
+            if count <= 0 {
+                break
+            }
+            data.append(buffer, count: count)
+        }
+
+        return data
+    }
+
+    private static func makePlanStatusResponse(_ fixture: ResponseFixture) -> Data {
+        let planInfo = self.message([
+            self.stringField(2, fixture.planName),
+        ])
+
+        let planStatus = self.message([
+            self.messageField(1, planInfo),
+            self.messageField(3, self.timestamp(seconds: fixture.planEndUnix)),
+            self.varintField(14, UInt64(fixture.dailyRemaining)),
+            self.varintField(15, UInt64(fixture.weeklyRemaining)),
+            self.varintField(17, UInt64(fixture.dailyResetUnix)),
+            self.varintField(18, UInt64(fixture.weeklyResetUnix)),
+        ])
+
+        return self.message([
+            self.messageField(1, planStatus),
+        ])
+    }
+
+    private static func timestamp(seconds: Int64) -> Data {
+        self.message([
+            self.varintField(1, UInt64(seconds)),
+        ])
+    }
+
+    private static func message(_ fields: [Data]) -> Data {
+        fields.reduce(into: Data()) { partialResult, field in
+            partialResult.append(field)
+        }
+    }
+
+    private static func stringField(_ number: Int, _ value: String) -> Data {
+        self.lengthDelimitedField(number, Data(value.utf8))
+    }
+
+    private static func messageField(_ number: Int, _ value: Data) -> Data {
+        self.lengthDelimitedField(number, value)
+    }
+
+    private static func lengthDelimitedField(_ number: Int, _ value: Data) -> Data {
+        var data = Data()
+        data.append(self.fieldKey(number, wireType: 2))
+        data.append(self.varint(UInt64(value.count)))
+        data.append(value)
+        return data
+    }
+
+    private static func varintField(_ number: Int, _ value: UInt64) -> Data {
+        var data = Data()
+        data.append(self.fieldKey(number, wireType: 0))
+        data.append(self.varint(value))
+        return data
+    }
+
+    private static func fieldKey(_ number: Int, wireType: UInt64) -> Data {
+        self.varint(UInt64((number << 3) | Int(wireType)))
+    }
+
+    private static func varint(_ value: UInt64) -> Data {
+        var remaining = value
+        var data = Data()
+        while remaining >= 0x80 {
+            data.append(UInt8((remaining & 0x7F) | 0x80))
+            remaining >>= 7
+        }
+        data.append(UInt8(remaining))
+        return data
+    }
+
+    private static func localStorageEntry(origin: URL, key: String, value: String) -> ChromiumLocalStorageEntry {
+        ChromiumLocalStorageEntry(
+            origin: origin.absoluteString,
+            key: key,
+            value: value,
+            rawValueLength: value.utf8.count)
+    }
+}
+
+final class WindsurfWebFetcherStubURLProtocol: URLProtocol {
+    nonisolated(unsafe) static var requests: [URLRequest] = []
+    nonisolated(unsafe) static var handler: (@Sendable (URLRequest) throws -> (HTTPURLResponse, Data))?
+
+    override static func canInit(with _: URLRequest) -> Bool {
+        true
+    }
+
+    override static func canonicalRequest(for request: URLRequest) -> URLRequest {
+        request
+    }
+
+    override func startLoading() {
+        Self.requests.append(self.request)
+        guard let handler = Self.handler else {
+            self.client?.urlProtocol(self, didFailWithError: URLError(.badServerResponse))
+            return
+        }
+
+        do {
+            let (response, data) = try handler(self.request)
+            self.client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
+            self.client?.urlProtocol(self, didLoad: data)
+            self.client?.urlProtocolDidFinishLoading(self)
+        } catch {
+            self.client?.urlProtocol(self, didFailWithError: error)
+        }
+    }
+
+    override func stopLoading() {}
+}
diff --git a/Tests/CodexBarTests/ZaiAvailabilityTests.swift b/Tests/CodexBarTests/ZaiAvailabilityTests.swift
index 6ce2295892..4083171211 100644
--- a/Tests/CodexBarTests/ZaiAvailabilityTests.swift
+++ b/Tests/CodexBarTests/ZaiAvailabilityTests.swift
@@ -4,10 +4,9 @@ import Testing
 @testable import CodexBar
 
 @MainActor
-@Suite
 struct ZaiAvailabilityTests {
     @Test
-    func enablesZaiWhenTokenExistsInStore() throws {
+    func `enables zai when token exists in store`() throws {
         let suite = "ZaiAvailabilityTests-token"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
@@ -31,7 +30,7 @@ struct ZaiAvailabilityTests {
     }
 
     @Test
-    func enablesZaiWhenTokenExistsInTokenAccounts() throws {
+    func `enables zai when token exists in token accounts`() throws {
         let suite = "ZaiAvailabilityTests-token-accounts"
         let defaults = try #require(UserDefaults(suiteName: suite))
         defaults.removePersistentDomain(forName: suite)
diff --git a/Tests/CodexBarTests/ZaiMenuCardTests.swift b/Tests/CodexBarTests/ZaiMenuCardTests.swift
new file mode 100644
index 0000000000..4433fdf9f5
--- /dev/null
+++ b/Tests/CodexBarTests/ZaiMenuCardTests.swift
@@ -0,0 +1,70 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBar
+
+struct ZaiMenuCardTests {
+    @Test
+    func `zai metrics titles are Tokens MCP and 5-hour when session token limit present`() throws {
+        let now = Date()
+        let zai = ZaiUsageSnapshot(
+            tokenLimit: ZaiLimitEntry(
+                type: .tokensLimit,
+                unit: .weeks,
+                number: 1,
+                usage: nil,
+                currentValue: nil,
+                remaining: nil,
+                percentage: 9,
+                usageDetails: [],
+                nextResetTime: nil),
+            sessionTokenLimit: ZaiLimitEntry(
+                type: .tokensLimit,
+                unit: .hours,
+                number: 5,
+                usage: 1000,
+                currentValue: 750,
+                remaining: 250,
+                percentage: 25,
+                usageDetails: [],
+                nextResetTime: nil),
+            timeLimit: ZaiLimitEntry(
+                type: .timeLimit,
+                unit: .minutes,
+                number: 1,
+                usage: 100,
+                currentValue: 50,
+                remaining: 50,
+                percentage: 50,
+                usageDetails: [],
+                nextResetTime: nil),
+            planName: "pro",
+            updatedAt: now)
+        let snapshot = zai.toUsageSnapshot()
+        let metadata = try #require(ProviderDefaults.metadata[.zai])
+
+        let model = UsageMenuCardView.Model.make(.init(
+            provider: .zai,
+            metadata: metadata,
+            snapshot: snapshot,
+            credits: nil,
+            creditsError: nil,
+            dashboard: nil,
+            dashboardError: nil,
+            tokenSnapshot: nil,
+            tokenError: nil,
+            account: AccountInfo(email: nil, plan: nil),
+            isRefreshing: false,
+            lastError: nil,
+            usageBarsShowUsed: false,
+            resetTimeDisplayStyle: .countdown,
+            tokenCostUsageEnabled: false,
+            showOptionalCreditsAndExtraUsage: true,
+            hidePersonalInfo: false,
+            now: now))
+
+        #expect(model.metrics.map(\.title) == ["Tokens", "MCP", "5-hour"])
+        let tertiary = try #require(model.metrics.first(where: { $0.title == "5-hour" }))
+        #expect(tertiary.detailText == "750 / 1K (250 remaining)")
+    }
+}
diff --git a/Tests/CodexBarTests/ZaiProviderTests.swift b/Tests/CodexBarTests/ZaiProviderTests.swift
index c4184396ac..e541c9f888 100644
--- a/Tests/CodexBarTests/ZaiProviderTests.swift
+++ b/Tests/CodexBarTests/ZaiProviderTests.swift
@@ -2,38 +2,36 @@ import Foundation
 import Testing
 @testable import CodexBarCore
 
-@Suite
 struct ZaiSettingsReaderTests {
     @Test
-    func apiTokenReadsFromEnvironment() {
+    func `api token reads from environment`() {
         let token = ZaiSettingsReader.apiToken(environment: ["Z_AI_API_KEY": "abc123"])
         #expect(token == "abc123")
     }
 
     @Test
-    func apiTokenStripsQuotes() {
+    func `api token strips quotes`() {
         let token = ZaiSettingsReader.apiToken(environment: ["Z_AI_API_KEY": "\"token-xyz\""])
         #expect(token == "token-xyz")
     }
 
     @Test
-    func apiHostReadsFromEnvironment() {
+    func `api host reads from environment`() {
         let host = ZaiSettingsReader.apiHost(environment: [ZaiSettingsReader.apiHostKey: " open.bigmodel.cn "])
         #expect(host == "open.bigmodel.cn")
     }
 
     @Test
-    func quotaURLInfersScheme() {
+    func `quota URL infers scheme`() {
         let url = ZaiSettingsReader
             .quotaURL(environment: [ZaiSettingsReader.quotaURLKey: "open.bigmodel.cn/api/coding"])
         #expect(url?.absoluteString == "https://open.bigmodel.cn/api/coding")
     }
 }
 
-@Suite
 struct ZaiUsageSnapshotTests {
     @Test
-    func mapsUsageSnapshotWindows() {
+    func `maps usage snapshot windows`() {
         let reset = Date(timeIntervalSince1970: 123)
         let tokenLimit = ZaiLimitEntry(
             type: .tokensLimit,
@@ -69,11 +67,13 @@ struct ZaiUsageSnapshotTests {
         #expect(usage.primary?.resetDescription == "5 hours window")
         #expect(usage.secondary?.usedPercent == 20)
         #expect(usage.secondary?.resetDescription == "30 days window")
+        #expect(usage.tertiary == nil)
         #expect(usage.zaiUsage?.tokenLimit?.usage == 100)
+        #expect(usage.zaiUsage?.sessionTokenLimit == nil)
     }
 
     @Test
-    func mapsUsageSnapshotWindowsWithMissingFields() {
+    func `maps usage snapshot windows with missing fields`() {
         let reset = Date(timeIntervalSince1970: 123)
         let tokenLimit = ZaiLimitEntry(
             type: .tokensLimit,
@@ -101,7 +101,7 @@ struct ZaiUsageSnapshotTests {
     }
 
     @Test
-    func mapsUsageSnapshotWindowsWithMissingRemainingUsesCurrentValue() {
+    func `maps usage snapshot windows with missing remaining uses current value`() {
         let reset = Date(timeIntervalSince1970: 123)
         let tokenLimit = ZaiLimitEntry(
             type: .tokensLimit,
@@ -125,7 +125,7 @@ struct ZaiUsageSnapshotTests {
     }
 
     @Test
-    func mapsUsageSnapshotWindowsWithMissingCurrentValueUsesRemaining() {
+    func `maps usage snapshot windows with missing current value uses remaining`() {
         let reset = Date(timeIntervalSince1970: 123)
         let tokenLimit = ZaiLimitEntry(
             type: .tokensLimit,
@@ -149,7 +149,7 @@ struct ZaiUsageSnapshotTests {
     }
 
     @Test
-    func mapsUsageSnapshotWindowsWithMissingRemainingAndCurrentValueFallsBackToPercentage() {
+    func `maps usage snapshot windows with missing remaining and current value falls back to percentage`() {
         let reset = Date(timeIntervalSince1970: 123)
         let tokenLimit = ZaiLimitEntry(
             type: .tokensLimit,
@@ -173,10 +173,9 @@ struct ZaiUsageSnapshotTests {
     }
 }
 
-@Suite
 struct ZaiUsageParsingTests {
     @Test
-    func emptyBodyReturnsParseFailed() {
+    func `empty body returns parse failed`() {
         #expect {
             _ = try ZaiUsageFetcher.parseUsageSnapshot(from: Data())
         } throws: { error in
@@ -186,7 +185,7 @@ struct ZaiUsageParsingTests {
     }
 
     @Test
-    func parsesUsageResponse() throws {
+    func `parses usage response`() throws {
         let json = """
         {
           "code": 200,
@@ -228,10 +227,53 @@ struct ZaiUsageParsingTests {
         #expect(snapshot.tokenLimit?.usage == 40_000_000)
         #expect(snapshot.timeLimit?.usageDetails.first?.modelCode == "search-prime")
         #expect(snapshot.tokenLimit?.percentage == 34.0)
+
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.secondary?.windowMinutes == nil)
+        #expect(usage.secondary?.resetDescription == "Monthly")
     }
 
     @Test
-    func missingDataReturnsApiError() {
+    func `zai mcp time limit displays monthly instead of one minute window`() throws {
+        let json = """
+        {
+          "code": 200,
+          "msg": "Operation successful",
+          "data": {
+            "limits": [
+              {
+                "type": "TIME_LIMIT",
+                "unit": 5,
+                "number": 1,
+                "usage": 100,
+                "currentValue": 50,
+                "remaining": 50,
+                "percentage": 50,
+                "usageDetails": []
+              },
+              {
+                "type": "TOKENS_LIMIT",
+                "unit": 3,
+                "number": 5,
+                "percentage": 34,
+                "nextResetTime": 1768507567547
+              }
+            ]
+          },
+          "success": true
+        }
+        """
+
+        let snapshot = try ZaiUsageFetcher.parseUsageSnapshot(from: Data(json.utf8))
+        let usage = snapshot.toUsageSnapshot()
+
+        #expect(snapshot.timeLimit?.windowDescription == "1 minute")
+        #expect(usage.secondary?.windowMinutes == nil)
+        #expect(usage.secondary?.resetDescription == "Monthly")
+    }
+
+    @Test
+    func `missing data returns api error`() {
         let json = """
         { "code": 1001, "msg": "Authorization Token Missing", "success": false }
         """
@@ -245,7 +287,7 @@ struct ZaiUsageParsingTests {
     }
 
     @Test
-    func successWithoutDataReturnsParseFailed() {
+    func `success without data returns parse failed`() {
         let json = """
         { "code": 200, "msg": "Operation successful", "success": true }
         """
@@ -259,7 +301,7 @@ struct ZaiUsageParsingTests {
     }
 
     @Test
-    func successWithoutLimitsParsesEmptyUsage() throws {
+    func `success without limits parses empty usage`() throws {
         let json = """
         {
           "code": 200,
@@ -277,7 +319,7 @@ struct ZaiUsageParsingTests {
     }
 
     @Test
-    func parsesNewSchemaWithMissingTokenLimitFields() throws {
+    func `parses new schema with missing token limit fields`() throws {
         let json = """
         {
           "code": 200,
@@ -323,31 +365,285 @@ struct ZaiUsageParsingTests {
     }
 }
 
-@Suite
+struct ZaiHourlyUsageTests {
+    @Test
+    func `model usage parser decodes hourly model payload`() throws {
+        let json = """
+        {
+          "code": 200,
+          "msg": "success",
+          "success": true,
+          "data": {
+            "x_time": ["2026-05-14 08:00", "2026-05-14 09:00"],
+            "modelDataList": [
+              { "modelName": "glm-4.6", "tokensUsage": [100, null] },
+              { "modelName": "glm-4.5", "tokensUsage": [50, 25] }
+            ]
+          }
+        }
+        """
+
+        let usage = try ZaiUsageFetcher.parseModelUsage(from: Data(json.utf8))
+
+        #expect(usage.xTime == ["2026-05-14 08:00", "2026-05-14 09:00"])
+        #expect(usage.modelNames == ["glm-4.6", "glm-4.5"])
+        #expect(usage.modelDataList[0].tokensUsage == [100, nil])
+        #expect(usage.modelDataList[1].tokensUsage == [50, 25])
+    }
+
+    @Test
+    func `today hourly bars filter earlier days and skip empty hours`() {
+        let reference = Self.localDate(year: 2026, month: 5, day: 14, hour: 12)
+        let yesterday = Calendar.current.date(byAdding: .day, value: -1, to: reference) ?? reference
+        let modelData = ZaiModelUsageData(
+            xTime: [
+                Self.hourString(yesterday),
+                "2026-05-14 08:00",
+                "2026-05-14 09:00",
+            ],
+            modelDataList: [
+                ZaiModelDataItem(modelName: "glm-4.6", tokensUsage: [999, 100, 0]),
+                ZaiModelDataItem(modelName: "glm-4.5", tokensUsage: [0, 50, nil]),
+            ])
+
+        let bars = ZaiHourlyBars.from(modelData: modelData, range: .today(referenceDate: reference), now: reference)
+
+        #expect(bars.map(\.label) == ["08"])
+        #expect(bars.first?.totalTokens == 150)
+        #expect(bars.first?.segments.count == 2)
+    }
+
+    @Test
+    func `last 24 hour bars filter data outside trailing window`() {
+        let reference = Self.localDate(year: 2026, month: 5, day: 14, hour: 12)
+        let old = Calendar.current.date(byAdding: .hour, value: -25, to: reference) ?? reference
+        let inWindow = Calendar.current.date(byAdding: .hour, value: -23, to: reference) ?? reference
+        let modelData = ZaiModelUsageData(
+            xTime: [
+                Self.hourString(old),
+                Self.hourString(inWindow),
+                Self.hourString(reference),
+            ],
+            modelDataList: [
+                ZaiModelDataItem(modelName: "glm-4.6", tokensUsage: [10, 20, 30]),
+            ])
+
+        let bars = ZaiHourlyBars.from(modelData: modelData, range: .last24h, now: reference)
+
+        #expect(bars.map(\.label) == [Self.hourLabel(inWindow), Self.hourLabel(reference)])
+        #expect(bars.map(\.totalTokens) == [20, 30])
+    }
+
+    private static func localDate(year: Int, month: Int, day: Int, hour: Int) -> Date {
+        Calendar.current.date(from: DateComponents(year: year, month: month, day: day, hour: hour)) ?? Date()
+    }
+
+    private static func hourString(_ date: Date) -> String {
+        let formatter = DateFormatter()
+        formatter.dateFormat = "yyyy-MM-dd HH:mm"
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        return formatter.string(from: date)
+    }
+
+    private static func hourLabel(_ date: Date) -> String {
+        let formatter = DateFormatter()
+        formatter.dateFormat = "HH"
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        return formatter.string(from: date)
+    }
+}
+
+struct ZaiThreeLimitTests {
+    @Test
+    func `parses three limit entries into session weekly and mcp slots`() throws {
+        let json = """
+        {
+          "code": 200,
+          "msg": "操作成功",
+          "data": {
+            "limits": [
+              {
+                "type": "TOKENS_LIMIT",
+                "unit": 3,
+                "number": 5,
+                "percentage": 25,
+                "nextResetTime": 1775020168897
+              },
+              {
+                "type": "TOKENS_LIMIT",
+                "unit": 6,
+                "number": 1,
+                "percentage": 9,
+                "nextResetTime": 1775588029998
+              },
+              {
+                "type": "TIME_LIMIT",
+                "unit": 5,
+                "number": 1,
+                "usage": 1000,
+                "currentValue": 224,
+                "remaining": 776,
+                "percentage": 22,
+                "nextResetTime": 1777575229998,
+                "usageDetails": [
+                  { "modelCode": "search-prime", "usage": 210 },
+                  { "modelCode": "web-reader", "usage": 14 }
+                ]
+              }
+            ],
+            "level": "pro"
+          },
+          "success": true
+        }
+        """
+
+        let snapshot = try ZaiUsageFetcher.parseUsageSnapshot(from: Data(json.utf8))
+
+        // Weekly token limit (unit:6=weeks, longer window) → tokenLimit (primary)
+        #expect(snapshot.tokenLimit?.unit == .weeks)
+        #expect(snapshot.tokenLimit?.number == 1)
+        #expect(snapshot.tokenLimit?.percentage == 9.0)
+        #expect(snapshot.tokenLimit?.windowMinutes == 10080)
+
+        // 5-hour token limit (unit:3=hours, number:5 → 300 min) → sessionTokenLimit (tertiary)
+        #expect(snapshot.sessionTokenLimit?.unit == .hours)
+        #expect(snapshot.sessionTokenLimit?.number == 5)
+        #expect(snapshot.sessionTokenLimit?.percentage == 25.0)
+        #expect(snapshot.sessionTokenLimit?.windowMinutes == 300)
+
+        // MCP time limit → timeLimit (secondary)
+        #expect(snapshot.timeLimit?.usage == 1000)
+        #expect(snapshot.timeLimit?.usageDetails.first?.modelCode == "search-prime")
+
+        // UsageSnapshot slot mapping
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary?.usedPercent == 9.0)
+        #expect(usage.primary?.windowMinutes == 10080)
+        #expect(usage.secondary != nil) // MCP
+        #expect(usage.tertiary?.usedPercent == 25.0)
+        #expect(usage.tertiary?.windowMinutes == 300)
+    }
+
+    @Test
+    func `unit 6 maps to weeks with correct window minutes`() {
+        let entry = ZaiLimitEntry(
+            type: .tokensLimit,
+            unit: .weeks,
+            number: 1,
+            usage: nil,
+            currentValue: nil,
+            remaining: nil,
+            percentage: 9,
+            usageDetails: [],
+            nextResetTime: nil)
+        #expect(entry.windowMinutes == 10080)
+        #expect(entry.windowDescription == "1 week")
+        #expect(entry.windowLabel == "1 week window")
+    }
+
+    @Test
+    func `two limit entries remain backward compatible`() throws {
+        let json = """
+        {
+          "code": 200,
+          "msg": "Operation successful",
+          "data": {
+            "limits": [
+              {
+                "type": "TIME_LIMIT",
+                "unit": 5,
+                "number": 1,
+                "usage": 100,
+                "currentValue": 50,
+                "remaining": 50,
+                "percentage": 50,
+                "usageDetails": []
+              },
+              {
+                "type": "TOKENS_LIMIT",
+                "unit": 3,
+                "number": 5,
+                "percentage": 34,
+                "nextResetTime": 1768507567547
+              }
+            ]
+          },
+          "success": true
+        }
+        """
+
+        let snapshot = try ZaiUsageFetcher.parseUsageSnapshot(from: Data(json.utf8))
+
+        #expect(snapshot.tokenLimit != nil)
+        #expect(snapshot.sessionTokenLimit == nil)
+        #expect(snapshot.timeLimit != nil)
+
+        let usage = snapshot.toUsageSnapshot()
+        #expect(usage.primary != nil)
+        #expect(usage.secondary != nil)
+        #expect(usage.tertiary == nil)
+    }
+}
+
 struct ZaiAPIRegionTests {
     @Test
-    func defaultsToGlobalEndpoint() {
+    func `dashboard URLs follow selected region`() {
+        #expect(
+            ZaiAPIRegion.global.dashboardURL.absoluteString ==
+                "https://z.ai/manage-apikey/coding-plan/personal/my-plan")
+        #expect(
+            ZaiAPIRegion.bigmodelCN.dashboardURL.absoluteString ==
+                "https://bigmodel.cn/coding-plan/personal/usage")
+        #expect(
+            ZaiProviderDescriptor.descriptor.metadata.dashboardURL ==
+                ZaiAPIRegion.global.dashboardURL.absoluteString)
+    }
+
+    @Test
+    func `defaults to global endpoint`() {
         let url = ZaiUsageFetcher.resolveQuotaURL(region: .global, environment: [:])
         #expect(url.absoluteString == "https://api.z.ai/api/monitor/usage/quota/limit")
     }
 
     @Test
-    func usesBigModelRegionWhenSelected() {
+    func `uses big model region when selected`() {
         let url = ZaiUsageFetcher.resolveQuotaURL(region: .bigmodelCN, environment: [:])
         #expect(url.absoluteString == "https://open.bigmodel.cn/api/monitor/usage/quota/limit")
     }
 
     @Test
-    func quotaUrlEnvironmentOverrideWins() {
+    func `quota url environment override wins`() {
         let env = [ZaiSettingsReader.quotaURLKey: "https://open.bigmodel.cn/api/coding/paas/v4"]
         let url = ZaiUsageFetcher.resolveQuotaURL(region: .global, environment: env)
         #expect(url.absoluteString == "https://open.bigmodel.cn/api/coding/paas/v4")
     }
 
     @Test
-    func apiHostEnvironmentAppendsQuotaPath() {
+    func `api host environment appends quota path`() {
         let env = [ZaiSettingsReader.apiHostKey: "open.bigmodel.cn"]
         let url = ZaiUsageFetcher.resolveQuotaURL(region: .global, environment: env)
         #expect(url.absoluteString == "https://open.bigmodel.cn/api/monitor/usage/quota/limit")
     }
+
+    @Test
+    func `dashboard follows known endpoint overrides`() {
+        let china = ZaiUsageFetcher.resolveDashboardURL(
+            region: .global,
+            environment: [ZaiSettingsReader.apiHostKey: "open.bigmodel.cn"])
+        #expect(china == ZaiAPIRegion.bigmodelCN.dashboardURL)
+
+        let global = ZaiUsageFetcher.resolveDashboardURL(
+            region: .bigmodelCN,
+            environment: [ZaiSettingsReader.apiHostKey: "api.z.ai"])
+        #expect(global == ZaiAPIRegion.global.dashboardURL)
+    }
+
+    @Test
+    func `dashboard keeps selected region for custom endpoint override`() {
+        let dashboard = ZaiUsageFetcher.resolveDashboardURL(
+            region: .bigmodelCN,
+            environment: [ZaiSettingsReader.apiHostKey: "zai.internal.example"])
+
+        #expect(dashboard == ZaiAPIRegion.bigmodelCN.dashboardURL)
+    }
 }
diff --git a/Tests/CodexBarTests/ZedStatusProbeTests.swift b/Tests/CodexBarTests/ZedStatusProbeTests.swift
new file mode 100644
index 0000000000..148faef701
--- /dev/null
+++ b/Tests/CodexBarTests/ZedStatusProbeTests.swift
@@ -0,0 +1,314 @@
+import CodexBarCore
+import Foundation
+import Testing
+
+struct ZedStatusProbeTests {
+    private struct StubCredentialsReader: ZedCredentialsReading {
+        let credentials: ZedCredentials?
+
+        func loadCredentials(serviceURL _: String) throws -> ZedCredentials? {
+            self.credentials
+        }
+    }
+
+    private static let subscriptionPeriod = """
+    "subscription_period": {
+      "started_at": "2026-05-13T00:00:00.000Z",
+      "ended_at": "2026-06-13T00:00:00.000Z"
+    }
+    """
+
+    private static func fixture(plan: String, used: Int, limit: String, overdue: Bool = false) -> Data {
+        Data(
+            """
+            {
+              "user": {
+                "id": 4242,
+                "github_login": "octocat",
+                "name": "The Octocat"
+              },
+              "feature_flags": [],
+              "plan": {
+                "plan_v3": "\(plan)",
+                \(self.subscriptionPeriod),
+                "usage": {
+                  "edit_predictions": {
+                    "used": \(used),
+                    "limit": \(limit)
+                  }
+                },
+                "has_overdue_invoices": \(overdue)
+              }
+            }
+            """.utf8)
+    }
+
+    private static func httpResponse(data: Data, statusCode: Int) -> (Data, URLResponse) {
+        let response = HTTPURLResponse(
+            url: URL(string: "https://cloud.zed.dev/client/users/me")!,
+            statusCode: statusCode,
+            httpVersion: nil,
+            headerFields: nil)!
+        return (data, response)
+    }
+
+    @Test
+    func `decodes free plan with limited edit predictions`() throws {
+        let response = try ZedStatusProbe.parseResponse(Self.fixture(plan: "zed_free", used: 12, limit: "50"))
+        #expect(response.plan.planV3 == "zed_free")
+        #expect(response.plan.usage.editPredictions.used == 12)
+        #expect(response.plan.usage.editPredictions.limit == .limited(50))
+        #expect(response.user.githubLogin == "octocat")
+    }
+
+    @Test
+    func `decodes pro plan with unlimited edit predictions`() throws {
+        let response = try ZedStatusProbe.parseResponse(Self.fixture(plan: "zed_pro", used: 0, limit: "\"unlimited\""))
+        #expect(response.plan.planV3 == "zed_pro")
+        #expect(response.plan.usage.editPredictions.limit == .unlimited)
+    }
+
+    @Test
+    func `decodes pro trial student and business plans`() throws {
+        let trial = try ZedStatusProbe.parseResponse(Self.fixture(
+            plan: "zed_pro_trial",
+            used: 3,
+            limit: "\"unlimited\""))
+        let student = try ZedStatusProbe.parseResponse(Self.fixture(plan: "zed_student", used: 1, limit: "25"))
+        let business = try ZedStatusProbe.parseResponse(Self.fixture(
+            plan: "zed_business",
+            used: 0,
+            limit: "\"unlimited\""))
+
+        #expect(trial.plan.planV3 == "zed_pro_trial")
+        #expect(student.plan.planV3 == "zed_student")
+        #expect(business.plan.planV3 == "zed_business")
+    }
+
+    @Test
+    func `maps free plan to usage snapshot`() throws {
+        let response = try ZedStatusProbe.parseResponse(Self.fixture(plan: "zed_free", used: 10, limit: "20"))
+        let snapshot = ZedUsageSnapshot(response: response).toUsageSnapshot()
+
+        #expect(snapshot.identity?.loginMethod == "Zed Free")
+        #expect(snapshot.identity?.accountEmail == "octocat")
+        #expect(snapshot.primary?.resetDescription == "10 / 20 predictions")
+        #expect(snapshot.primary?.usedPercent == 50)
+        #expect(snapshot.secondary?.resetsAt != nil)
+        #expect(snapshot.extraRateWindows == nil)
+    }
+
+    @Test
+    func `maps pro plan with unlimited edit predictions`() throws {
+        let response = try ZedStatusProbe.parseResponse(Self.fixture(plan: "zed_pro", used: 0, limit: "\"unlimited\""))
+        let snapshot = ZedUsageSnapshot(response: response).toUsageSnapshot()
+
+        #expect(snapshot.identity?.loginMethod == "Zed Pro")
+        #expect(snapshot.primary?.resetDescription == "Unlimited")
+        #expect(snapshot.extraRateWindows == nil)
+    }
+
+    @Test
+    func `maps overdue invoices warning window`() throws {
+        let response = try ZedStatusProbe.parseResponse(
+            Self.fixture(plan: "zed_pro", used: 0, limit: "\"unlimited\"", overdue: true))
+        let snapshot = ZedUsageSnapshot(response: response).toUsageSnapshot()
+
+        #expect(snapshot.extraRateWindows?.contains(where: { $0.id == "zed.overdue-invoices" }) == true)
+    }
+
+    @Test
+    func `reads credentials url from settings`() {
+        let settings = ZedClientSettings(
+            credentialsURL: "https://preview.zed.dev",
+            serverURL: "https://zed.dev")
+        #expect(settings.keychainServiceURL == "https://preview.zed.dev")
+
+        let fallback = ZedClientSettings(credentialsURL: nil, serverURL: "https://custom.zed.dev")
+        #expect(fallback.keychainServiceURL == "https://custom.zed.dev")
+
+        let defaultSettings = ZedClientSettings(credentialsURL: nil, serverURL: nil)
+        #expect(defaultSettings.keychainServiceURL == ZedStatusProbe.defaultKeychainServiceURL)
+    }
+
+    @Test
+    func `uses documented zed settings path`() {
+        let expected = FileManager.default.homeDirectoryForCurrentUser
+            .appendingPathComponent(".config/zed/settings.json")
+        #expect(ZedStatusProbe.defaultSettingsURL == expected)
+    }
+
+    @Test
+    func `loads client settings from json`() throws {
+        let directory = FileManager.default.temporaryDirectory
+            .appendingPathComponent("CodexBar-ZedSettings-\(UUID().uuidString)")
+        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: directory) }
+
+        let settingsURL = directory.appendingPathComponent("settings.json")
+        try Data(
+            """
+            {
+              "credentials_url": "zed-preview-key",
+              "server_url": "https://staging.zed.dev"
+            }
+            """.utf8)
+            .write(to: settingsURL)
+
+        let settings = try #require(ZedClientSettings.load(from: settingsURL))
+        #expect(settings.credentialsURL == "zed-preview-key")
+        #expect(settings.serverURL == "https://staging.zed.dev")
+    }
+
+    @Test
+    func `maps server url independently from keychain identifier`() {
+        let production = ZedClientSettings(credentialsURL: "zed-preview-key", serverURL: "https://zed.dev")
+        let staging = ZedClientSettings(credentialsURL: nil, serverURL: "https://staging.zed.dev")
+        let localhost = ZedClientSettings(credentialsURL: nil, serverURL: "http://localhost:3000")
+        let custom = ZedClientSettings(credentialsURL: nil, serverURL: "https://zed.example.com")
+        let untrustedOverride = ZedClientSettings(
+            credentialsURL: "https://zed.dev",
+            serverURL: "https://zed.example.com")
+        let invalid = ZedClientSettings(credentialsURL: nil, serverURL: "file:///tmp/zed")
+
+        #expect(production.keychainServiceURL == "zed-preview-key")
+        #expect(production.cloudAPIURL?.absoluteString == "https://cloud.zed.dev/client/users/me")
+        #expect(staging.cloudAPIURL?.absoluteString == "https://cloud.zed.dev/client/users/me")
+        #expect(localhost.cloudAPIURL == nil)
+        #expect(custom.cloudAPIURL?.absoluteString == "https://zed.example.com/client/users/me")
+        #expect(untrustedOverride.cloudAPIURL == nil)
+        #expect(invalid.cloudAPIURL == nil)
+    }
+
+    @Test
+    func `display plan names normalize zed enums`() {
+        #expect(ZedUsageSnapshot.displayPlanName("zed_pro") == "Zed Pro")
+        #expect(ZedUsageSnapshot.displayPlanName("zed_pro_trial") == "Zed Pro Trial")
+        #expect(ZedUsageSnapshot.displayPlanName("zed_student") == "Zed Student")
+    }
+
+    @Test
+    func `fetch uses authorization header from keychain credentials`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            #expect(request.url?.absoluteString == "https://cloud.zed.dev/client/users/me")
+            #expect(request.value(forHTTPHeaderField: "Authorization") == "4242 test-token")
+            return Self.httpResponse(
+                data: Self.fixture(plan: "zed_pro", used: 0, limit: "\"unlimited\""),
+                statusCode: 200)
+        }
+
+        let probe = ZedStatusProbe(
+            credentialsReader: StubCredentialsReader(
+                credentials: ZedCredentials(userID: "4242", accessToken: "test-token")),
+            transport: transport,
+            settingsLoader: { ZedClientSettings(credentialsURL: nil, serverURL: nil) })
+
+        let snapshot = try await probe.fetch()
+        #expect(snapshot.response.plan.planV3 == "zed_pro")
+    }
+
+    @Test
+    func `fetch sends credentials only to configured server`() async throws {
+        let transport = ProviderHTTPTransportStub { request in
+            #expect(request.url?.absoluteString == "https://zed.example.com/client/users/me")
+            #expect(request.value(forHTTPHeaderField: "Authorization") == "4242 custom-token")
+            return Self.httpResponse(
+                data: Self.fixture(plan: "zed_pro", used: 0, limit: "\"unlimited\""),
+                statusCode: 200)
+        }
+        let probe = ZedStatusProbe(
+            credentialsReader: StubCredentialsReader(
+                credentials: ZedCredentials(userID: "4242", accessToken: "custom-token")),
+            transport: transport,
+            settingsLoader: {
+                ZedClientSettings(
+                    credentialsURL: "https://zed.example.com",
+                    serverURL: "https://zed.example.com")
+            })
+
+        _ = try await probe.fetch()
+    }
+
+    @Test
+    func `fetch rejects invalid server before reading credentials`() async {
+        let probe = ZedStatusProbe(
+            credentialsReader: StubCredentialsReader(
+                credentials: ZedCredentials(userID: "4242", accessToken: "must-not-send")),
+            transport: ProviderHTTPTransportStub { _ in
+                Issue.record("Should not send credentials to an invalid server URL")
+                return Self.httpResponse(data: Data(), statusCode: 500)
+            },
+            settingsLoader: {
+                ZedClientSettings(credentialsURL: "custom-keychain-id", serverURL: "file:///tmp/zed")
+            })
+
+        await #expect(throws: ZedStatusProbeError.invalidServerURL("file:///tmp/zed")) {
+            _ = try await probe.fetch()
+        }
+    }
+
+    @Test
+    func `fetch rejects cross-origin credential override`() async {
+        let probe = ZedStatusProbe(
+            credentialsReader: StubCredentialsReader(
+                credentials: ZedCredentials(userID: "4242", accessToken: "must-not-send")),
+            transport: ProviderHTTPTransportStub { _ in
+                Issue.record("Should not send credentials to an untrusted custom server")
+                return Self.httpResponse(data: Data(), statusCode: 500)
+            },
+            settingsLoader: {
+                ZedClientSettings(
+                    credentialsURL: "https://zed.dev",
+                    serverURL: "https://attacker.example.com")
+            })
+
+        await #expect(throws: ZedStatusProbeError.untrustedServerConfiguration) {
+            _ = try await probe.fetch()
+        }
+    }
+
+    @Test
+    func `fetch surfaces not signed in when keychain is empty`() async {
+        let probe = ZedStatusProbe(
+            credentialsReader: StubCredentialsReader(credentials: nil),
+            transport: ProviderHTTPTransportStub { _ in
+                Issue.record("Should not call cloud API without credentials")
+                return Self.httpResponse(data: Data(), statusCode: 500)
+            },
+            settingsLoader: { nil })
+
+        await #expect(throws: ZedStatusProbeError.notSignedIn) {
+            _ = try await probe.fetch()
+        }
+    }
+
+    @Test
+    func `fetch surfaces unauthorized responses`() async {
+        let probe = ZedStatusProbe(
+            credentialsReader: StubCredentialsReader(
+                credentials: ZedCredentials(userID: "1", accessToken: "bad")),
+            transport: ProviderHTTPTransportStub { _ in
+                Self.httpResponse(data: Data("{}".utf8), statusCode: 401)
+            },
+            settingsLoader: { nil })
+
+        await #expect(throws: ZedStatusProbeError.unauthorized) {
+            _ = try await probe.fetch()
+        }
+    }
+
+    @Test
+    func `fetch preserves transport cancellation`() async {
+        let probe = ZedStatusProbe(
+            credentialsReader: StubCredentialsReader(
+                credentials: ZedCredentials(userID: "1", accessToken: "cancelled")),
+            transport: ProviderHTTPTransportStub { _ in
+                throw URLError(.cancelled)
+            },
+            settingsLoader: { nil })
+
+        await #expect(throws: CancellationError.self) {
+            _ = try await probe.fetch()
+        }
+    }
+}
diff --git a/TestsLinux/AntigravityCLIStrategyLinuxTests.swift b/TestsLinux/AntigravityCLIStrategyLinuxTests.swift
new file mode 100644
index 0000000000..fcc8195e52
--- /dev/null
+++ b/TestsLinux/AntigravityCLIStrategyLinuxTests.swift
@@ -0,0 +1,86 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+#if os(Linux)
+struct AntigravityCLIStrategyLinuxTests {
+    @Test
+    func `cli local strategy is available with HTTP fallback`() async throws {
+        let binaryURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codexbar-antigravity-\(UUID().uuidString)")
+        try Data("#!/bin/sh\n".utf8).write(to: binaryURL)
+        try FileManager.default.setAttributes(
+            [.posixPermissions: 0o755],
+            ofItemAtPath: binaryURL.path)
+        defer { try? FileManager.default.removeItem(at: binaryURL) }
+
+        let context = ProviderFetchContext(
+            runtime: .cli,
+            sourceMode: .cli,
+            includeCredits: false,
+            webTimeout: 1,
+            webDebugDumpHTML: false,
+            verbose: false,
+            env: ["ANTIGRAVITY_CLI_PATH": binaryURL.path],
+            settings: nil,
+            fetcher: UsageFetcher(environment: [:]),
+            claudeFetcher: StubClaudeFetcher(),
+            browserDetection: BrowserDetection(cacheTTL: 0))
+        let isAvailable = await AntigravityCLIHTTPSFetchStrategy().isAvailable(context)
+
+        #expect(isAvailable)
+    }
+
+    @Test
+    func `cli local endpoints include Linux HTTP fallback`() {
+        #expect(
+            AntigravityStatusProbe.cliEndpoints(ports: [55624]) == [
+                AntigravityStatusProbe.AntigravityConnectionEndpoint(
+                    scheme: "https",
+                    port: 55624,
+                    csrfToken: "",
+                    source: .cliHTTPS),
+                AntigravityStatusProbe.AntigravityConnectionEndpoint(
+                    scheme: "http",
+                    port: 55624,
+                    csrfToken: "",
+                    source: .cliHTTPS),
+            ])
+    }
+
+    @Test
+    func `language server endpoints include Linux HTTP fallback`() {
+        #expect(
+            AntigravityStatusProbe.connectionCandidates(
+                listeningPorts: [64440],
+                languageServerCSRFToken: "language-token",
+                extensionServerPort: nil,
+                extensionServerCSRFToken: nil) == [
+                AntigravityStatusProbe.AntigravityConnectionEndpoint(
+                    scheme: "https",
+                    port: 64440,
+                    csrfToken: "language-token",
+                    source: .languageServer),
+                AntigravityStatusProbe.AntigravityConnectionEndpoint(
+                    scheme: "http",
+                    port: 64440,
+                    csrfToken: "language-token",
+                    source: .languageServer),
+            ])
+    }
+
+    private struct StubClaudeFetcher: ClaudeUsageFetching {
+        func loadLatestUsage(model _: String) async throws -> ClaudeUsageSnapshot {
+            throw ClaudeUsageError.parseFailed("stub")
+        }
+
+        func debugRawProbe(model _: String) async -> String {
+            "stub"
+        }
+
+        func detectVersion() -> String? {
+            nil
+        }
+    }
+}
+#endif
diff --git a/TestsLinux/AntigravityProcessLauncherLinuxTests.swift b/TestsLinux/AntigravityProcessLauncherLinuxTests.swift
new file mode 100644
index 0000000000..49c0e3378d
--- /dev/null
+++ b/TestsLinux/AntigravityProcessLauncherLinuxTests.swift
@@ -0,0 +1,64 @@
+#if canImport(Glibc) || canImport(Musl)
+import Foundation
+#if canImport(Glibc)
+import Glibc
+#elseif canImport(Musl)
+import Musl
+#endif
+import Testing
+@testable import CodexBarCore
+
+struct AntigravityProcessLauncherLinuxTests {
+    @Test
+    func `pty launcher uses home and closes unrelated descriptors`() throws {
+        let tempDirectory = FileManager.default.temporaryDirectory
+            .appendingPathComponent("antigravity-spawn-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: tempDirectory, withIntermediateDirectories: true)
+        defer { try? FileManager.default.removeItem(at: tempDirectory) }
+
+        let inheritedSourceFD = open("/dev/null", O_RDONLY)
+        guard inheritedSourceFD >= 0 else {
+            Issue.record("Failed to open descriptor fixture")
+            return
+        }
+        defer { close(inheritedSourceFD) }
+        let inheritedFD = fcntl(inheritedSourceFD, F_DUPFD, 200)
+        guard inheritedFD >= 200 else {
+            Issue.record("Failed to duplicate descriptor fixture")
+            return
+        }
+        defer { close(inheritedFD) }
+
+        let outputURL = tempDirectory.appendingPathComponent("result.txt")
+        let scriptURL = tempDirectory.appendingPathComponent("probe.sh")
+        let script = """
+        #!/bin/sh
+        pwd > \(outputURL.path)
+        if [ -e /proc/self/fd/\(inheritedFD) ]; then
+          echo inherited >> \(outputURL.path)
+        else
+          echo closed >> \(outputURL.path)
+        fi
+        """
+        // Direct writes close the executable before spawn; atomic replacement can race with exec on overlay
+        // filesystems.
+        try Data(script.utf8).write(to: scriptURL)
+        #expect(chmod(scriptURL.path, 0o700) == 0)
+
+        let handle = try AntigravityPTYProcessLauncher().launch(binary: scriptURL.path)
+        defer {
+            handle.killRoot()
+            handle.terminateTree(signal: SIGKILL, knownDescendants: [])
+            handle.closePTY()
+        }
+
+        for _ in 0..<200 where !FileManager.default.fileExists(atPath: outputURL.path) {
+            Thread.sleep(forTimeInterval: 0.01)
+        }
+        let lines = try String(contentsOf: outputURL, encoding: .utf8)
+            .split(separator: "\n")
+            .map(String.init)
+        #expect(lines == [NSHomeDirectory(), "closed"])
+    }
+}
+#endif
diff --git a/TestsLinux/AzureEndpointOverrideSecurityTests.swift b/TestsLinux/AzureEndpointOverrideSecurityTests.swift
new file mode 100644
index 0000000000..4ba9684257
--- /dev/null
+++ b/TestsLinux/AzureEndpointOverrideSecurityTests.swift
@@ -0,0 +1,71 @@
+import CodexBarCore
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+import Testing
+
+@Suite
+struct AzureEndpointOverrideSecurityTests {
+    @Test
+    func azureOpenAIEndpointOverrideMustBeHTTPSOrBareHost() throws {
+        let httpsURL = try #require(AzureOpenAISettingsReader.endpointURL(from: "https://proxy.example.com/base"))
+        #expect(httpsURL.absoluteString == "https://proxy.example.com/base")
+
+        let bareURL = try #require(AzureOpenAISettingsReader.endpointURL(from: "resource.openai.azure.com"))
+        #expect(bareURL.absoluteString == "https://resource.openai.azure.com")
+
+        let hostPortURL = try #require(AzureOpenAISettingsReader.endpointURL(from: "localhost:8443/openai"))
+        #expect(hostPortURL.absoluteString == "https://localhost:8443/openai")
+
+        let trimmedURL = try #require(AzureOpenAISettingsReader.endpointURL(from: " https://trimmed.example.com/base "))
+        #expect(trimmedURL.absoluteString == "https://trimmed.example.com/base")
+
+        #expect(AzureOpenAISettingsReader.endpointURL(from: "http://attacker.test") == nil)
+        #expect(AzureOpenAISettingsReader.endpointURL(from: "https://user:pass@proxy.example.com") == nil)
+        #expect(AzureOpenAISettingsReader.endpointURL(from: "https://proxy.example.com%2f.attacker.test") == nil)
+
+        #expect(throws: AzureOpenAISettingsError.invalidEndpointOverride(
+            AzureOpenAISettingsReader.endpointEnvironmentKey))
+        {
+            try AzureOpenAISettingsReader.validateEndpointOverrides(environment: [
+                AzureOpenAISettingsReader.endpointEnvironmentKey: "http://attacker.test",
+            ])
+        }
+    }
+
+    @Test
+    func azureOpenAIHTTPOverrideIsRejectedBeforeAPIKeyRequest() async throws {
+        let endpoint = try #require(URL(string: "http://127.0.0.1:31337"))
+        let transport = CapturingTransport { request in
+            Issue.record("Azure OpenAI should reject insecure endpoint overrides before sending api-key headers")
+            #expect(request.value(forHTTPHeaderField: "api-key") == nil)
+            throw CapturingTransportError.unexpectedRequest
+        }
+
+        do {
+            _ = try await AzureOpenAIUsageFetcher.fetchUsage(
+                apiKey: "AZURE_CANARY_KEY",
+                endpoint: endpoint,
+                deploymentName: "canary-deployment",
+                transport: transport,
+                updatedAt: Date(timeIntervalSince1970: 1_800_000_000))
+            Issue.record("Expected AzureOpenAIUsageError.invalidEndpointOverride")
+        } catch {
+            #expect(error as? AzureOpenAIUsageError == .invalidEndpointOverride(
+                AzureOpenAISettingsReader.endpointEnvironmentKey))
+        }
+    }
+}
+
+private enum CapturingTransportError: Error {
+    case unexpectedRequest
+}
+
+private struct CapturingTransport: ProviderHTTPTransport {
+    let handler: @Sendable (URLRequest) async throws -> (Data, URLResponse)
+
+    func data(for request: URLRequest) async throws -> (Data, URLResponse) {
+        try await self.handler(request)
+    }
+}
diff --git a/TestsLinux/CodexBarLoggingPerformanceTests.swift b/TestsLinux/CodexBarLoggingPerformanceTests.swift
new file mode 100644
index 0000000000..1b2e202b9e
--- /dev/null
+++ b/TestsLinux/CodexBarLoggingPerformanceTests.swift
@@ -0,0 +1,82 @@
+import Logging
+import Testing
+@testable import CodexBarCore
+
+@Suite(.serialized)
+struct CodexBarLoggingPerformanceTests {
+    @Test
+    func `filtered log messages are not evaluated`() {
+        let probe = LogEvaluationProbe()
+        let logger = CodexBarLogger(minimumLevel: .info) { _, message, _ in
+            probe.loggedMessages.append(message)
+        }
+
+        logger.debug(probe.expensiveMessage())
+
+        #expect(probe.evaluations == 0)
+        #expect(probe.loggedMessages.isEmpty)
+
+        logger.info(probe.expensiveMessage())
+
+        #expect(probe.evaluations == 1)
+        #expect(probe.loggedMessages == ["evaluated"])
+    }
+
+    @Test
+    func `disabled file logging does not format metadata`() {
+        let sink = FileLogSink()
+        var handler = FileLogHandler(label: "test", sink: sink)
+        let probe = LogEvaluationProbe()
+        handler[metadataKey: "expensive"] = .stringConvertible(ExpensiveMetadataValue {
+            probe.evaluations += 1
+        })
+
+        handler.log(event: LogEvent(
+            level: .info,
+            message: "hello",
+            metadata: nil,
+            source: "test",
+            file: #filePath,
+            function: #function,
+            line: #line))
+
+        #expect(probe.evaluations == 0)
+    }
+
+    @Test
+    func `redactor leaves ordinary log lines unchanged`() {
+        let line = "CodexBar starting version=1.2.3 build=456"
+
+        #expect(LogRedactor.redact(line) == line)
+    }
+
+    @Test
+    func `redactor still redacts sensitive log lines`() {
+        let line = "Authorization: Bearer secret-token\nContact: user@example.com"
+        let redacted = LogRedactor.redact(line)
+
+        #expect(redacted.contains("secret-token") == false)
+        #expect(redacted.contains("user@example.com") == false)
+        #expect(redacted.contains("Authorization: <redacted>"))
+        #expect(redacted.contains("<redacted-email>"))
+    }
+}
+
+private final class LogEvaluationProbe: @unchecked Sendable {
+    var evaluations = 0
+    var loggedMessages: [String] = []
+
+    func expensiveMessage() -> String {
+        self.evaluations += 1
+        return "evaluated"
+    }
+}
+
+private struct ExpensiveMetadataValue: CustomStringConvertible, Sendable {
+    let onRender: @Sendable () -> Void
+
+    var description: String {
+        self.onRender()
+        return "rendered"
+    }
+}
diff --git a/TestsLinux/CodexOAuthCredentialsStoreLinuxTests.swift b/TestsLinux/CodexOAuthCredentialsStoreLinuxTests.swift
new file mode 100644
index 0000000000..01853c49f1
--- /dev/null
+++ b/TestsLinux/CodexOAuthCredentialsStoreLinuxTests.swift
@@ -0,0 +1,31 @@
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+@Suite
+struct CodexOAuthCredentialsStoreLinuxTests {
+    @Test
+    func saveKeepsAuthJSONPrivate() throws {
+        #if os(macOS) || os(Linux)
+        let codexHome = FileManager.default.temporaryDirectory
+            .appendingPathComponent("codex-oauth-permissions-\(UUID().uuidString)", isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: codexHome) }
+
+        let credentials = CodexOAuthCredentials(
+            accessToken: "access-token",
+            refreshToken: "refresh-token",
+            idToken: "id-token",
+            accountId: "account-123",
+            lastRefresh: Date())
+
+        try CodexOAuthCredentialsStore.save(credentials, env: ["CODEX_HOME": codexHome.path])
+
+        let authURL = codexHome.appendingPathComponent("auth.json")
+        let attributes = try FileManager.default.attributesOfItem(atPath: authURL.path)
+        let permissions = try #require(attributes[.posixPermissions] as? NSNumber)
+        #expect(permissions.intValue & 0o777 == 0o600)
+        #else
+        #expect(Bool(true))
+        #endif
+    }
+}
diff --git a/TestsLinux/CostUsageScanExecutorLinuxTests.swift b/TestsLinux/CostUsageScanExecutorLinuxTests.swift
new file mode 100644
index 0000000000..e286e535c1
--- /dev/null
+++ b/TestsLinux/CostUsageScanExecutorLinuxTests.swift
@@ -0,0 +1,29 @@
+import CodexBarCore
+import Foundation
+import Testing
+
+@Suite
+struct CostUsageScanExecutorLinuxTests {
+    @Test
+    func returnsWorkValue() async throws {
+        let value = try await CostUsageScanExecutor.run { _ in 42 }
+        #expect(value == 42)
+    }
+
+    @Test
+    func cancelledTaskThrowsCancellationError() async {
+        let task = Task {
+            try await CostUsageScanExecutor.run { checkCancellation in
+                while true {
+                    try checkCancellation()
+                    Thread.sleep(forTimeInterval: 0.005)
+                }
+            }
+        }
+        task.cancel()
+
+        await #expect(throws: CancellationError.self) {
+            try await task.value
+        }
+    }
+}
diff --git a/TestsLinux/OpenAIDashboardParserLinuxTests.swift b/TestsLinux/OpenAIDashboardParserLinuxTests.swift
new file mode 100644
index 0000000000..06f7417bde
--- /dev/null
+++ b/TestsLinux/OpenAIDashboardParserLinuxTests.swift
@@ -0,0 +1,60 @@
+import CodexBarCore
+import Foundation
+import Testing
+
+/// Cross-platform tests for the OpenAI dashboard text parser.
+///
+/// The dashboard renders reset countdowns like "Resets Wednesday at 3pm". The parser
+/// converts a textual weekday into the next occurrence of that weekday so it can be
+/// formatted into a concrete `Date`. These tests pin down full-weekday-name coverage
+/// because the underlying regex previously missed "Wednesday" and "Saturday" (their
+/// abbreviations were not long enough to combine with the optional "day" suffix).
+@Suite
+struct OpenAIDashboardParserLinuxTests {
+    private static func fixedNow() -> Date {
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = TimeZone(secondsFromGMT: 0)!
+        // 2026-05-21 is a Thursday in the Gregorian calendar; using a fixed anchor keeps
+        // the test deterministic regardless of when it executes.
+        return calendar.date(from: DateComponents(year: 2026, month: 5, day: 21))!
+    }
+
+    private static func body(forWeekday weekday: String) -> String {
+        """
+        5h limit
+        50% remaining
+        Resets \(weekday)
+        """
+    }
+
+    @Test
+    func parsesResetLineForEveryFullWeekdayName() {
+        let now = Self.fixedNow()
+        for weekday in ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"] {
+            let result = OpenAIDashboardParser.parseRateLimits(
+                bodyText: Self.body(forWeekday: weekday),
+                now: now)
+            #expect(
+                result.primary?.resetsAt != nil,
+                "Expected a parsed resetsAt for weekday \(weekday)")
+        }
+    }
+
+    @Test
+    func parsesResetLineForLowercaseWednesday() {
+        let now = Self.fixedNow()
+        let result = OpenAIDashboardParser.parseRateLimits(
+            bodyText: Self.body(forWeekday: "wednesday"),
+            now: now)
+        #expect(result.primary?.resetsAt != nil)
+    }
+
+    @Test
+    func parsesResetLineForLowercaseSaturday() {
+        let now = Self.fixedNow()
+        let result = OpenAIDashboardParser.parseRateLimits(
+            bodyText: Self.body(forWeekday: "saturday"),
+            now: now)
+        #expect(result.primary?.resetsAt != nil)
+    }
+}
diff --git a/TestsLinux/OpenCodeGoLinuxTests.swift b/TestsLinux/OpenCodeGoLinuxTests.swift
new file mode 100644
index 0000000000..dd85a8d50f
--- /dev/null
+++ b/TestsLinux/OpenCodeGoLinuxTests.swift
@@ -0,0 +1,74 @@
+import CodexBarCore
+import Foundation
+import Testing
+@testable import CodexBarCLI
+
+#if canImport(SQLite3)
+import SQLite3
+#elseif canImport(CSQLite3)
+import CSQLite3
+#endif
+
+#if canImport(SQLite3) || canImport(CSQLite3)
+@Suite
+struct OpenCodeGoLinuxTests {
+    @Test
+    func autoSourceDoesNotRequireWebSupport() {
+        #expect(!CodexBarCLI.sourceModeRequiresWebSupport(.auto, provider: .opencodego))
+        #expect(CodexBarCLI.sourceModeRequiresWebSupport(.web, provider: .opencodego))
+    }
+
+    @Test
+    func commandCodeManualCookieDoesNotRequireMacOSWebSupport() {
+        let settings = ProviderSettingsSnapshot.make(
+            commandcode: .init(cookieSource: .manual, manualCookieHeader: "session=manual"))
+
+        #expect(!CodexBarCLI.sourceModeRequiresWebSupport(
+            .auto,
+            provider: .commandcode,
+            settings: settings))
+        #expect(!CodexBarCLI.sourceModeRequiresWebSupport(
+            .web,
+            provider: .commandcode,
+            settings: settings))
+    }
+
+    @Test
+    func localReaderLoadsOpenCodeDatabase() throws {
+        let root = FileManager.default.temporaryDirectory
+            .appendingPathComponent("OpenCodeGoLinuxTests-\(UUID().uuidString)", isDirectory: true)
+        defer { try? FileManager.default.removeItem(at: root) }
+        try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
+
+        let databaseURL = root.appendingPathComponent("opencode.db")
+        let authURL = root.appendingPathComponent("auth.json")
+        let now = Date(timeIntervalSince1970: 1_800_000_000)
+        let createdMs = Int64((now.timeIntervalSince1970 - 60) * 1000)
+        try Self.createDatabase(at: databaseURL, createdMs: createdMs)
+
+        let snapshot = try OpenCodeGoLocalUsageReader(authURL: authURL, databaseURL: databaseURL).fetch(now: now)
+
+        #expect(snapshot.rollingUsagePercent == 50)
+        #expect(snapshot.weeklyUsagePercent == 20)
+        #expect(snapshot.monthlyUsagePercent == 10)
+    }
+
+    private static func createDatabase(at url: URL, createdMs: Int64) throws {
+        var database: OpaquePointer?
+        guard sqlite3_open(url.path, &database) == SQLITE_OK else {
+            sqlite3_close(database)
+            throw OpenCodeGoLocalUsageError.sqliteFailed("open failed")
+        }
+        defer { sqlite3_close(database) }
+
+        let data = "{\"time\":{\"created\":\(createdMs)},\"cost\":6,\"providerID\":\"opencode-go\",\"role\":\"assistant\"}"
+        let sql = """
+            CREATE TABLE message (id TEXT PRIMARY KEY, time_created INTEGER NOT NULL, data TEXT NOT NULL);
+            INSERT INTO message (id, time_created, data) VALUES ('message-1', \(createdMs), '\(data)');
+            """
+        guard sqlite3_exec(database, sql, nil, nil, nil) == SQLITE_OK else {
+            throw OpenCodeGoLocalUsageError.sqliteFailed("fixture creation failed")
+        }
+    }
+}
+#endif
diff --git a/TestsLinux/PlatformGatingTests.swift b/TestsLinux/PlatformGatingTests.swift
index 61bb5bcf25..82171c6176 100644
--- a/TestsLinux/PlatformGatingTests.swift
+++ b/TestsLinux/PlatformGatingTests.swift
@@ -1,8 +1,14 @@
 import CodexBarCore
 import Testing
+@testable import CodexBarCLI
 
 @Suite
 struct PlatformGatingTests {
+    @Test
+    func ampAutoSource_doesNotRequireWebSupport() {
+        #expect(!CodexBarCLI.sourceModeRequiresWebSupport(.auto, provider: .amp))
+    }
+
     @Test
     func claudeWebFetcher_isNotSupportedOnLinux() async {
         #if os(Linux)
diff --git a/TestsLinux/ProviderEndpointOverrideSecurityLinuxTests.swift b/TestsLinux/ProviderEndpointOverrideSecurityLinuxTests.swift
new file mode 100644
index 0000000000..713637f11b
--- /dev/null
+++ b/TestsLinux/ProviderEndpointOverrideSecurityLinuxTests.swift
@@ -0,0 +1,137 @@
+@testable import CodexBarCore
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+import Testing
+
+@Suite
+struct ProviderEndpointOverrideSecurityLinuxTests {
+    @Test
+    func mimoInvalidEndpointOverrideDoesNotFallbackToLocalCache() {
+        #expect(MiMoWebFetchStrategy.shouldFallbackToLocal(
+            error: MiMoSettingsError.invalidEndpointOverride(MiMoSettingsReader.apiURLKey)) == false)
+        #expect(MiMoWebFetchStrategy.shouldFallbackToLocal(error: MiMoSettingsError.missingCookie()) == true)
+        #expect(MiMoWebFetchStrategy.shouldFallbackToLocal(error: MiMoSettingsError.invalidCookie) == true)
+    }
+
+    @Test
+    func deepgramRejectsInsecureOverrideBeforeSendingToken() async {
+        let transport = FailingTransport()
+        do {
+            _ = try await DeepgramUsageFetcher.fetchUsage(
+                apiKey: "dg-test-token",
+                environment: [DeepgramUsageFetcher.apiURLKey: "http://attacker.test/v1"],
+                transport: transport)
+            Issue.record("Expected DeepgramUsageError.invalidEndpointOverride")
+        } catch DeepgramUsageError.invalidEndpointOverride(DeepgramUsageFetcher.apiURLKey) {
+            // Expected.
+        } catch {
+            Issue.record("Expected DeepgramUsageError.invalidEndpointOverride, got \(error)")
+        }
+    }
+
+    @Test
+    func zaiRejectsInsecureQuotaOverrideBeforeSendingToken() async {
+        do {
+            _ = try await ZaiUsageFetcher.fetchUsage(
+                apiKey: "zai-test-token",
+                environment: [ZaiSettingsReader.quotaURLKey: "http://attacker.test/quota"])
+            Issue.record("Expected ZaiSettingsError.invalidEndpointOverride")
+        } catch ZaiSettingsError.invalidEndpointOverride(ZaiSettingsReader.quotaURLKey) {
+            // Expected.
+        } catch {
+            Issue.record("Expected ZaiSettingsError.invalidEndpointOverride, got \(error)")
+        }
+    }
+
+    @Test
+    func zaiRejectsInsecureAPIHostOverrideWhenQuotaURLIsAbsent() {
+        #expect(throws: ZaiSettingsError.invalidEndpointOverride(ZaiSettingsReader.apiHostKey)) {
+            try ZaiSettingsReader.validateEndpointOverrides(
+                environment: [ZaiSettingsReader.apiHostKey: "http://attacker.test"])
+        }
+    }
+
+    @Test
+    func zaiQuotaResolutionIgnoresInvalidLowerPriorityAPIHost() throws {
+        let environment = [
+            ZaiSettingsReader.quotaURLKey: "https://zai-proxy.test/quota",
+            ZaiSettingsReader.apiHostKey: "http://attacker.test",
+        ]
+
+        try ZaiSettingsReader.validateQuotaEndpointOverride(environment: environment)
+        #expect(ZaiUsageFetcher.resolveQuotaURL(region: .global, environment: environment).absoluteString ==
+            "https://zai-proxy.test/quota")
+    }
+
+    @Test
+    func zaiCombinedFetchRejectsInvalidAPIHostBeforeQuotaRequest() async {
+        let environment = [
+            ZaiSettingsReader.quotaURLKey: "https://127.0.0.1:31337/quota",
+            ZaiSettingsReader.apiHostKey: "http://127.0.0.1:31337",
+        ]
+
+        await #expect(throws: ZaiSettingsError.invalidEndpointOverride(ZaiSettingsReader.apiHostKey)) {
+            try await ZaiUsageFetcher.fetchUsageWithModelUsage(
+                apiKey: "ZAI_CANARY_KEY",
+                environment: environment)
+        }
+    }
+
+    @Test
+    func zaiModelUsageRejectsInsecureAPIHostOverride() async {
+        do {
+            _ = try await ZaiUsageFetcher.fetchModelUsage(
+                apiKey: "zai-test-token",
+                environment: [ZaiSettingsReader.apiHostKey: "http://attacker.test"])
+            Issue.record("Expected ZaiSettingsError.invalidEndpointOverride")
+        } catch ZaiSettingsError.invalidEndpointOverride(ZaiSettingsReader.apiHostKey) {
+            // Expected.
+        } catch {
+            Issue.record("Expected ZaiSettingsError.invalidEndpointOverride, got \(error)")
+        }
+    }
+
+    @Test
+    func mimoRejectsInsecureOverrideBeforeSendingCookie() async {
+        let transport = FailingTransport()
+        do {
+            _ = try await MiMoUsageFetcher.fetchUsage(
+                cookieHeader: "api-platform_serviceToken=session-token; userId=user-1",
+                environment: [MiMoSettingsReader.apiURLKey: "http://attacker.test/api/v1"],
+                session: transport)
+            Issue.record("Expected MiMoSettingsError.invalidEndpointOverride")
+        } catch MiMoSettingsError.invalidEndpointOverride(MiMoSettingsReader.apiURLKey) {
+            // Expected.
+        } catch {
+            Issue.record("Expected MiMoSettingsError.invalidEndpointOverride, got \(error)")
+        }
+    }
+
+    @Test
+    func affectedProviderOverridesAcceptHTTPSAndBareHosts() throws {
+        try DeepgramUsageFetcher.validateEndpointOverrides(environment: [
+            DeepgramUsageFetcher.apiURLKey: "deepgram-proxy.test/v1",
+        ])
+        try ZaiSettingsReader
+            .validateEndpointOverrides(environment: [ZaiSettingsReader.quotaURLKey: "https://zai-proxy.test/quota"])
+        try ZaiSettingsReader.validateEndpointOverrides(environment: [ZaiSettingsReader.apiHostKey: "localhost:9443"])
+        try MiMoSettingsReader
+            .validateEndpointOverrides(environment: [MiMoSettingsReader.apiURLKey: "mimo-proxy.test/api/v1"])
+
+        #expect(ZaiSettingsReader.quotaURL(environment: [ZaiSettingsReader.quotaURLKey: "zai-proxy.test/quota"])?
+            .absoluteString == "https://zai-proxy.test/quota")
+        #expect(MiMoSettingsReader.apiURL(environment: [MiMoSettingsReader.apiURLKey: "mimo-proxy.test/api/v1"])
+            .absoluteString == "https://mimo-proxy.test/api/v1")
+    }
+}
+
+private struct FailingTransport: ProviderHTTPTransport {
+    func data(for request: URLRequest) async throws -> (Data, URLResponse) {
+        Issue
+            .record(
+                "Endpoint override validation should fail before any request is sent to \(request.url?.absoluteString ?? "<nil>")")
+        throw URLError(.badURL)
+    }
+}
diff --git a/TestsLinux/SettingsReaderQuoteUnwrapTrapTests.swift b/TestsLinux/SettingsReaderQuoteUnwrapTrapTests.swift
new file mode 100644
index 0000000000..91c0e1e7a9
--- /dev/null
+++ b/TestsLinux/SettingsReaderQuoteUnwrapTrapTests.swift
@@ -0,0 +1,75 @@
+import CodexBarCore
+import Foundation
+import Testing
+
+/// Regression tests for a copy-pasted quote-unwrap helper that traps on length-1 input.
+///
+/// 32 provider settings readers (plus `CodexBarConfig` and `CLIConfigCommand`) share a
+/// `cleaned(_:)` helper of the form:
+///
+///     if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
+///         (value.hasPrefix("'") && value.hasSuffix("'"))
+///     {
+///         value.removeFirst()
+///         value.removeLast()
+///     }
+///
+/// For a value of length 1 (the single character `"` or `'`), both `hasPrefix` and
+/// `hasSuffix` return true, `removeFirst()` empties the string, and `removeLast()` then
+/// traps with "Can't remove last element from empty collection." This is reachable from
+/// a misconfigured env var (e.g. `ALIBABA_TOKEN_PLAN_COOKIE='"'`) and from quoted JSON
+/// values in `~/.codexbar/config.json`, both of which are user-controllable.
+///
+/// These tests exercise two representative public readers — Alibaba Token Plan (the
+/// newest addition in #1098) and the Ollama API key reader (added in #1087) — by
+/// passing the trap-inducing single-quote inputs and asserting the readers return nil
+/// instead of crashing. The patch swaps `removeFirst()/removeLast()` for
+/// `String(value.dropFirst().dropLast())`, which is empty-safe.
+@Suite
+struct SettingsReaderQuoteUnwrapTrapTests {
+    @Test
+    func alibabaTokenPlanCookieHeader_returnsNilForLoneDoubleQuoteValue() {
+        let env = [AlibabaTokenPlanSettingsReader.cookieHeaderKey: "\""]
+        #expect(AlibabaTokenPlanSettingsReader.cookieHeader(environment: env) == nil)
+    }
+
+    @Test
+    func alibabaTokenPlanCookieHeader_returnsNilForLoneApostropheValue() {
+        let env = [AlibabaTokenPlanSettingsReader.cookieHeaderKey: "'"]
+        #expect(AlibabaTokenPlanSettingsReader.cookieHeader(environment: env) == nil)
+    }
+
+    @Test
+    func alibabaTokenPlanCookieHeader_unwrapsProperlyDoubleQuotedValue() {
+        let env = [AlibabaTokenPlanSettingsReader.cookieHeaderKey: "\"abc=def\""]
+        #expect(AlibabaTokenPlanSettingsReader.cookieHeader(environment: env) == "abc=def")
+    }
+
+    @Test
+    func alibabaTokenPlanCookieHeader_unwrapsProperlySingleQuotedValue() {
+        let env = [AlibabaTokenPlanSettingsReader.cookieHeaderKey: "'abc=def'"]
+        #expect(AlibabaTokenPlanSettingsReader.cookieHeader(environment: env) == "abc=def")
+    }
+
+    @Test
+    func ollamaAPIKey_returnsNilForLoneDoubleQuoteValue() {
+        for key in OllamaAPISettingsReader.apiKeyEnvironmentKeys {
+            let env = [key: "\""]
+            #expect(OllamaAPISettingsReader.apiKey(environment: env) == nil)
+        }
+    }
+
+    @Test
+    func ollamaAPIKey_returnsNilForLoneApostropheValue() {
+        for key in OllamaAPISettingsReader.apiKeyEnvironmentKeys {
+            let env = [key: "'"]
+            #expect(OllamaAPISettingsReader.apiKey(environment: env) == nil)
+        }
+    }
+
+    @Test
+    func ollamaAPIKey_unwrapsProperlyQuotedValue() {
+        let env = [OllamaAPISettingsReader.apiKeyEnvironmentKeys[0]: "\"sk-token\""]
+        #expect(OllamaAPISettingsReader.apiKey(environment: env) == "sk-token")
+    }
+}
diff --git a/VISION.md b/VISION.md
new file mode 100644
index 0000000000..ec6c5ec89c
--- /dev/null
+++ b/VISION.md
@@ -0,0 +1,20 @@
+# Vision
+
+CodexBar is the menu bar control surface for AI provider limits, credits, spend, status, and reset windows. It should keep adding useful provider coverage while preserving fast refreshes, privacy-first local data handling, and shared provider-driven UI instead of one-off surfaces.
+
+## Merge by Default
+
+- Performance improvements, unless they add too much complexity.
+- Bug fixes with clear cause and bounded risk.
+- New model/provider support that follows existing descriptor, strategy, settings, and test patterns.
+- Small UI or UX tweaks.
+- Documentation fixes.
+
+## Needs Sign-Off
+
+- New features.
+- Package, dependency, or toolchain changes.
+- Broad refactors or architecture changes.
+- Changes that add meaningful maintenance complexity.
+- Behavior changes that affect provider auth, data storage, releases, or user privacy.
+- Provider additions that need new host APIs, bespoke UI, broad filesystem access, or unclear auth/privacy behavior.
diff --git a/WidgetExtension/CodexBarWidgetExtension.xcodeproj/project.pbxproj b/WidgetExtension/CodexBarWidgetExtension.xcodeproj/project.pbxproj
new file mode 100644
index 0000000000..f6e6a2fc27
--- /dev/null
+++ b/WidgetExtension/CodexBarWidgetExtension.xcodeproj/project.pbxproj
@@ -0,0 +1,364 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 77;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		0972D036B563954337344F35 /* CodexBarWidgetBundle.swift in Sources */ = {isa = PBXBuildFile; fileRef = 50E5C7D39315A8DA5DC9D18A /* CodexBarWidgetBundle.swift */; };
+		49DB3749D8E8748409CDC4FE /* CodexBarWidgetProvider.swift in Sources */ = {isa = PBXBuildFile; fileRef = 549C61629C144C190B18EAD9 /* CodexBarWidgetProvider.swift */; };
+		6F12082A467310EEDD1F3439 /* WidgetKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = E430B27E4F28973A5E77EA3F /* WidgetKit.framework */; };
+		7A3A654DC5A5B85C9C41EA02 /* CodexBarCore in Frameworks */ = {isa = PBXBuildFile; productRef = 140C60DAC1DE9A8AE19E58FE /* CodexBarCore */; };
+		7F0E34471853E41206F690FB /* SwiftUI.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 02F15F392AF9D502F0503F8F /* SwiftUI.framework */; };
+		882A41814588292DD631F525 /* CodexBarWidgetViews.swift in Sources */ = {isa = PBXBuildFile; fileRef = 84672F595D2C0B83323E2C54 /* CodexBarWidgetViews.swift */; };
+		B2C3D4E5F6071829A3B4C5D6 /* BurnDownWidgetViews.swift in Sources */ = {isa = PBXBuildFile; fileRef = B2C3D4E5F6071829A3B4C5D7 /* BurnDownWidgetViews.swift */; };
+		C3D4E5F607182930B4C5D6E7 /* CombinedBurnDownWidgetViews.swift in Sources */ = {isa = PBXBuildFile; fileRef = C3D4E5F607182930B4C5D6E8 /* CombinedBurnDownWidgetViews.swift */; };
+		D4E5F60718293041C5D6E7F8 /* BurnDownWidgetProvider.swift in Sources */ = {isa = PBXBuildFile; fileRef = D4E5F60718293041C5D6E7F9 /* BurnDownWidgetProvider.swift */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXFileReference section */
+		02F15F392AF9D502F0503F8F /* SwiftUI.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = SwiftUI.framework; path = System/Library/Frameworks/SwiftUI.framework; sourceTree = SDKROOT; };
+		50E5C7D39315A8DA5DC9D18A /* CodexBarWidgetBundle.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CodexBarWidgetBundle.swift; sourceTree = "<group>"; };
+		549C61629C144C190B18EAD9 /* CodexBarWidgetProvider.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CodexBarWidgetProvider.swift; sourceTree = "<group>"; };
+		84672F595D2C0B83323E2C54 /* CodexBarWidgetViews.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CodexBarWidgetViews.swift; sourceTree = "<group>"; };
+		B2C3D4E5F6071829A3B4C5D7 /* BurnDownWidgetViews.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = BurnDownWidgetViews.swift; sourceTree = "<group>"; };
+		C3D4E5F607182930B4C5D6E8 /* CombinedBurnDownWidgetViews.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CombinedBurnDownWidgetViews.swift; sourceTree = "<group>"; };
+		D4E5F60718293041C5D6E7F9 /* BurnDownWidgetProvider.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = BurnDownWidgetProvider.swift; sourceTree = "<group>"; };
+		E430B27E4F28973A5E77EA3F /* WidgetKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = WidgetKit.framework; path = System/Library/Frameworks/WidgetKit.framework; sourceTree = SDKROOT; };
+		E7789C4095C40CF60759F2B7 /* CodexBarWidgetExtension.appex */ = {isa = PBXFileReference; explicitFileType = "wrapper.app-extension"; includeInIndex = 0; path = CodexBarWidgetExtension.appex; sourceTree = BUILT_PRODUCTS_DIR; };
+		EFBE36CB6481E7133E2A5CF3 /* CodexBar */ = {isa = PBXFileReference; lastKnownFileType = folder; name = CodexBar; path = ..; sourceTree = SOURCE_ROOT; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		F5F0F061CD72D02EB841D35C /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				7A3A654DC5A5B85C9C41EA02 /* CodexBarCore in Frameworks */,
+				7F0E34471853E41206F690FB /* SwiftUI.framework in Frameworks */,
+				6F12082A467310EEDD1F3439 /* WidgetKit.framework in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		4FAD1E2FCD6C4AC65D308ABC /* Packages */ = {
+			isa = PBXGroup;
+			children = (
+				EFBE36CB6481E7133E2A5CF3 /* CodexBar */,
+			);
+			name = Packages;
+			sourceTree = "<group>";
+		};
+		74E0E4CB8C1E1700BE59E54D = {
+			isa = PBXGroup;
+			children = (
+				B37422CB8DFAAFC8B3B8C1B6 /* CodexBarWidget */,
+				4FAD1E2FCD6C4AC65D308ABC /* Packages */,
+				CEE79B6AB070A55FA0FB7E12 /* Frameworks */,
+				B7E03090CEF29F6B74205FAE /* Products */,
+			);
+			sourceTree = "<group>";
+		};
+		B37422CB8DFAAFC8B3B8C1B6 /* CodexBarWidget */ = {
+			isa = PBXGroup;
+			children = (
+				50E5C7D39315A8DA5DC9D18A /* CodexBarWidgetBundle.swift */,
+				549C61629C144C190B18EAD9 /* CodexBarWidgetProvider.swift */,
+				84672F595D2C0B83323E2C54 /* CodexBarWidgetViews.swift */,
+				B2C3D4E5F6071829A3B4C5D7 /* BurnDownWidgetViews.swift */,
+				C3D4E5F607182930B4C5D6E8 /* CombinedBurnDownWidgetViews.swift */,
+				D4E5F60718293041C5D6E7F9 /* BurnDownWidgetProvider.swift */,
+			);
+			name = CodexBarWidget;
+			path = ../Sources/CodexBarWidget;
+			sourceTree = "<group>";
+		};
+		B7E03090CEF29F6B74205FAE /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				E7789C4095C40CF60759F2B7 /* CodexBarWidgetExtension.appex */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		CEE79B6AB070A55FA0FB7E12 /* Frameworks */ = {
+			isa = PBXGroup;
+			children = (
+				02F15F392AF9D502F0503F8F /* SwiftUI.framework */,
+				E430B27E4F28973A5E77EA3F /* WidgetKit.framework */,
+			);
+			name = Frameworks;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		E9AFBF11687E131ED1AD113A /* CodexBarWidgetExtension */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 0BDFA2A2ECD62489A63741CF /* Build configuration list for PBXNativeTarget "CodexBarWidgetExtension" */;
+			buildPhases = (
+				7FB8FE18C057D477EA90DD38 /* Sources */,
+				F5F0F061CD72D02EB841D35C /* Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = CodexBarWidgetExtension;
+			packageProductDependencies = (
+				140C60DAC1DE9A8AE19E58FE /* CodexBarCore */,
+			);
+			productName = CodexBarWidgetExtension;
+			productReference = E7789C4095C40CF60759F2B7 /* CodexBarWidgetExtension.appex */;
+			productType = "com.apple.product-type.app-extension";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		31A080B4D7A0849832821889 /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				BuildIndependentTargetsInParallel = YES;
+				LastUpgradeCheck = 1430;
+				TargetAttributes = {
+				};
+			};
+			buildConfigurationList = A17A8A4315AD7DBD4D417FCA /* Build configuration list for PBXProject "CodexBarWidgetExtension" */;
+			developmentRegion = en;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				Base,
+				en,
+			);
+			mainGroup = 74E0E4CB8C1E1700BE59E54D;
+			minimizedProjectReferenceProxies = 1;
+			packageReferences = (
+				B0BE8F0E2917CB6B2EDF1826 /* XCLocalSwiftPackageReference ".." */,
+			);
+			preferredProjectObjectVersion = 77;
+			productRefGroup = B7E03090CEF29F6B74205FAE /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				E9AFBF11687E131ED1AD113A /* CodexBarWidgetExtension */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXSourcesBuildPhase section */
+		7FB8FE18C057D477EA90DD38 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				0972D036B563954337344F35 /* CodexBarWidgetBundle.swift in Sources */,
+				49DB3749D8E8748409CDC4FE /* CodexBarWidgetProvider.swift in Sources */,
+				882A41814588292DD631F525 /* CodexBarWidgetViews.swift in Sources */,
+				B2C3D4E5F6071829A3B4C5D6 /* BurnDownWidgetViews.swift in Sources */,
+				C3D4E5F607182930B4C5D6E7 /* CombinedBurnDownWidgetViews.swift in Sources */,
+				D4E5F60718293041C5D6E7F8 /* BurnDownWidgetProvider.swift in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin XCBuildConfiguration section */
+		4A864C1BFFF710E1A519CCF5 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_ENABLE_OBJC_WEAK = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = dwarf;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				ENABLE_TESTABILITY = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu11;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"$(inherited)",
+					"DEBUG=1",
+				);
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				MACOSX_DEPLOYMENT_TARGET = 14.0;
+				MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
+				MTL_FAST_MATH = YES;
+				ONLY_ACTIVE_ARCH = YES;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SDKROOT = macosx;
+				SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG;
+				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
+				SWIFT_VERSION = 5.0;
+			};
+			name = Debug;
+		};
+		76EC15BB9FE2307D815E380E /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_ENABLE_OBJC_WEAK = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				ENABLE_NS_ASSERTIONS = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu11;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				MACOSX_DEPLOYMENT_TARGET = 14.0;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				MTL_FAST_MATH = YES;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SDKROOT = macosx;
+				SWIFT_COMPILATION_MODE = wholemodule;
+				SWIFT_OPTIMIZATION_LEVEL = "-O";
+				SWIFT_VERSION = 5.0;
+			};
+			name = Release;
+		};
+		7B3A3941F0FAA0B4ADAB8760 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				APPLICATION_EXTENSION_API_ONLY = YES;
+				CODE_SIGNING_ALLOWED = NO;
+				COMBINE_HIDPI_IMAGES = YES;
+				ENABLE_APP_SANDBOX = YES;
+				ENABLE_DEBUG_DYLIB = NO;
+				INFOPLIST_FILE = Info.plist;
+				INFOPLIST_KEY_CodexBarTeamID = "$(CODEXBAR_TEAM_ID)";
+				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/../Frameworks @executable_path/../../../../Frameworks";
+				MACOSX_DEPLOYMENT_TARGET = 14.0;
+				PRODUCT_BUNDLE_IDENTIFIER = "$(CODEXBAR_WIDGET_BUNDLE_ID)";
+				PRODUCT_NAME = CodexBarWidget;
+				SDKROOT = macosx;
+				SWIFT_VERSION = 6.0;
+			};
+			name = Debug;
+		};
+		88E6F58603FDA13ED00BF91D /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				APPLICATION_EXTENSION_API_ONLY = YES;
+				CODE_SIGNING_ALLOWED = NO;
+				COMBINE_HIDPI_IMAGES = YES;
+				ENABLE_APP_SANDBOX = YES;
+				ENABLE_DEBUG_DYLIB = NO;
+				INFOPLIST_FILE = Info.plist;
+				INFOPLIST_KEY_CodexBarTeamID = "$(CODEXBAR_TEAM_ID)";
+				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/../Frameworks @executable_path/../../../../Frameworks";
+				MACOSX_DEPLOYMENT_TARGET = 14.0;
+				PRODUCT_BUNDLE_IDENTIFIER = "$(CODEXBAR_WIDGET_BUNDLE_ID)";
+				PRODUCT_NAME = CodexBarWidget;
+				SDKROOT = macosx;
+				SWIFT_VERSION = 6.0;
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		0BDFA2A2ECD62489A63741CF /* Build configuration list for PBXNativeTarget "CodexBarWidgetExtension" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				7B3A3941F0FAA0B4ADAB8760 /* Debug */,
+				88E6F58603FDA13ED00BF91D /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Debug;
+		};
+		A17A8A4315AD7DBD4D417FCA /* Build configuration list for PBXProject "CodexBarWidgetExtension" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				4A864C1BFFF710E1A519CCF5 /* Debug */,
+				76EC15BB9FE2307D815E380E /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Debug;
+		};
+/* End XCConfigurationList section */
+
+/* Begin XCLocalSwiftPackageReference section */
+		B0BE8F0E2917CB6B2EDF1826 /* XCLocalSwiftPackageReference ".." */ = {
+			isa = XCLocalSwiftPackageReference;
+			relativePath = ..;
+		};
+/* End XCLocalSwiftPackageReference section */
+
+/* Begin XCSwiftPackageProductDependency section */
+		140C60DAC1DE9A8AE19E58FE /* CodexBarCore */ = {
+			isa = XCSwiftPackageProductDependency;
+			productName = CodexBarCore;
+		};
+/* End XCSwiftPackageProductDependency section */
+	};
+	rootObject = 31A080B4D7A0849832821889 /* Project object */;
+}
diff --git a/WidgetExtension/CodexBarWidgetExtension.xcodeproj/project.xcworkspace/contents.xcworkspacedata b/WidgetExtension/CodexBarWidgetExtension.xcodeproj/project.xcworkspace/contents.xcworkspacedata
new file mode 100644
index 0000000000..919434a625
--- /dev/null
+++ b/WidgetExtension/CodexBarWidgetExtension.xcodeproj/project.xcworkspace/contents.xcworkspacedata
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+   <FileRef
+      location = "self:">
+   </FileRef>
+</Workspace>
diff --git a/WidgetExtension/Info.plist b/WidgetExtension/Info.plist
new file mode 100644
index 0000000000..bf7636ef98
--- /dev/null
+++ b/WidgetExtension/Info.plist
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>$(DEVELOPMENT_LANGUAGE)</string>
+	<key>CFBundleDisplayName</key>
+	<string>CodexBar</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>CodexBarWidget</string>
+	<key>CFBundlePackageType</key>
+	<string>XPC!</string>
+	<key>CFBundleShortVersionString</key>
+	<string>$(MARKETING_VERSION)</string>
+	<key>CFBundleVersion</key>
+	<string>$(CURRENT_PROJECT_VERSION)</string>
+	<key>CodexBarTeamID</key>
+	<string>$(CODEXBAR_TEAM_ID)</string>
+	<key>LSMinimumSystemVersion</key>
+	<string>14.0</string>
+	<key>NSExtension</key>
+	<dict>
+		<key>NSExtensionPointIdentifier</key>
+		<string>com.apple.widgetkit-extension</string>
+	</dict>
+</dict>
+</plist>
diff --git a/WidgetExtension/project.yml b/WidgetExtension/project.yml
new file mode 100644
index 0000000000..269c830c37
--- /dev/null
+++ b/WidgetExtension/project.yml
@@ -0,0 +1,42 @@
+name: CodexBarWidgetExtension
+options:
+  deploymentTarget:
+    macOS: "14.0"
+packages:
+  CodexBar:
+    path: ..
+targets:
+  CodexBarWidgetExtension:
+    type: app-extension
+    platform: macOS
+    deploymentTarget: "14.0"
+    sources:
+      - path: ../Sources/CodexBarWidget
+    dependencies:
+      - package: CodexBar
+        product: CodexBarCore
+      - sdk: SwiftUI.framework
+      - sdk: WidgetKit.framework
+    info:
+      path: Info.plist
+      properties:
+        CFBundleDisplayName: CodexBar
+        CFBundleName: CodexBarWidget
+        CFBundlePackageType: XPC!
+        CFBundleShortVersionString: "$(MARKETING_VERSION)"
+        CFBundleVersion: "$(CURRENT_PROJECT_VERSION)"
+        CodexBarTeamID: "$(CODEXBAR_TEAM_ID)"
+        LSMinimumSystemVersion: "14.0"
+        NSExtension:
+          NSExtensionPointIdentifier: com.apple.widgetkit-extension
+    settings:
+      base:
+        APPLICATION_EXTENSION_API_ONLY: true
+        CODE_SIGNING_ALLOWED: false
+        ENABLE_DEBUG_DYLIB: false
+        ENABLE_APP_SANDBOX: true
+        INFOPLIST_KEY_CodexBarTeamID: "$(CODEXBAR_TEAM_ID)"
+        LD_RUNPATH_SEARCH_PATHS: "$(inherited) @executable_path/../Frameworks @executable_path/../../../../Frameworks"
+        PRODUCT_BUNDLE_IDENTIFIER: "$(CODEXBAR_WIDGET_BUNDLE_ID)"
+        PRODUCT_NAME: CodexBarWidget
+        SWIFT_VERSION: "6.0"
diff --git a/appcast.xml b/appcast.xml
index c7bc8f030a..d086d9d5ed 100644
--- a/appcast.xml
+++ b/appcast.xml
@@ -2,234 +2,138 @@
 <rss xmlns:sparkle="http://www.andymatuschak.org/xml-namespaces/sparkle" version="2.0">
     <channel>
         <title>CodexBar</title>
-        <item sparkle:channel="beta">
-            <title>0.18.0-beta.3</title>
-            <pubDate>Fri, 13 Feb 2026 18:57:54 +0100</pubDate>
-            <link>https://raw.githubusercontent.com/steipete/CodexBar/main/appcast.xml</link>
-            <sparkle:version>51</sparkle:version>
-            <sparkle:shortVersionString>0.18.0-beta.3</sparkle:shortVersionString>
-            <sparkle:minimumSystemVersion>14.0</sparkle:minimumSystemVersion>
-            <description><![CDATA[<h2>CodexBar 0.18.0-beta.3</h2>
-<h3>Highlights</h3>
-<ul>
-<li>Claude OAuth/keychain flows were reworked across a series of follow-up PRs to reduce prompt storms, stabilize background behavior, surface a setting to control prompt policy and make failure modes deterministic (#245, #305, #308, #309, #364). Thanks @manikv12!</li>
-<li>Claude: harden Claude Code PTY capture for <code>/usage</code> and <code>/status</code> (prompt automation, safer command palette confirmation, partial UTF-8 handling, and parsing guards against status-bar context meters) (#320).</li>
-<li>New provider: Warp (credits + add-on credits) (#352). Thanks @Kathie-yu!</li>
-<li>Provider correctness fixes landed for Cursor plan parsing and MiniMax region routing (#240, #234, #344). Thanks @robinebers and @theglove44!</li>
-<li>Menu bar animation behavior was hardened in merged mode and fallback mode (#283, #291). Thanks @vignesh07 and @Ilakiancs!</li>
-<li>CI/tooling reliability improved via pinned lint tools, deterministic macOS test execution, and PTY timing test stabilization plus Node 24-ready GitHub Actions upgrades (#292, #312, #290).</li>
-</ul>
-<h3>Claude OAuth & Keychain</h3>
-<ul>
-<li>Claude OAuth creds are cached in CodexBar Keychain to reduce repeated prompts.</li>
-<li>Prompts can still appear when Claude OAuth credentials are expired, invalid, or missing and re-auth is required.</li>
-<li>In Auto mode, background refresh keeps prompts suppressed; interactive prompts are limited to user actions (menu open or manual refresh).</li>
-<li>OAuth-only mode remains strict (no silent Web/CLI fallback); Auto mode may do one delegated CLI refresh + one OAuth retry before falling back.</li>
-<li>Preferences now expose a Claude Keychain prompt policy (Never / Only on user action / Always allow prompts) under Providers → Claude; if global Keychain access is disabled in Advanced, this control remains visible but inactive.</li>
-</ul>
-<h3>Provider & Usage Fixes</h3>
-<ul>
-<li>Warp: add Warp provider support (credits + add-on credits), configurable via Settings or <code>WARP_API_KEY</code>/<code>WARP_TOKEN</code> (#352). Thanks @Kathie-yu!</li>
-<li>Cursor: compute usage against <code>plan.limit</code> rather than <code>breakdown.total</code> to avoid incorrect limit interpretation (#240). Thanks @robinebers!</li>
-<li>MiniMax: correct API region URL selection to route requests to the expected regional endpoint (#234). Thanks @theglove44!</li>
-<li>MiniMax: always show the API region picker and retry the China endpoint when the global host rejects the token to avoid upgrade regressions for users without a persisted region (#344). Thanks @apoorvdarshan!</li>
-<li>Claude: add Opus 4.6 pricing so token cost scanning tracks USD consumed correctly (#348). Thanks @arandaschimpf!</li>
-<li>z.ai: handle quota responses with missing token-limit fields, avoid incorrect used-percent calculations, and harden empty-response behavior with safer logging (#346). Thanks @MohamedMohana and @halilertekin!</li>
-<li>z.ai: fix provider visibility in the menu when enabled with token-account credentials (availability now considers the effective fetch environment).</li>
-<li>Amp: detect login redirects during usage fetch and fail fast when the session is invalid (#339). Thanks @JosephDoUrden!</li>
-<li>Resource loading: fix app bundle lookup path to avoid "could not load resource bundle" startup failures (#223). Thanks @validatedev!</li>
-<li>OpenAI Web dashboard: keep WebView instances cached for reuse to reduce repeated network fetch overhead; tests were updated to avoid network-dependent flakes (#284). Thanks @vignesh07!</li>
-<li>Token-account precedence: selected token account env injection now correctly overrides provider config <code>apiKey</code> values in app and CLI environments. Thanks @arvindcr4!</li>
-<li>Claude: make Claude CLI probing more resilient by scoping auto-input to the active subcommand and trimming to the latest Usage panel before parsing to avoid false matches from earlier screen fragments (#320).</li>
-</ul>
-<h3>Menu Bar & UI Behavior</h3>
-<ul>
-<li>Prevent fallback-provider loading animation loops (battery/CPU drain when no providers are enabled) (#283). Thanks @vignesh07!</li>
-<li>Prevent status overlay rendering for disabled providers while in merged mode (#291). Thanks @Ilakiancs!</li>
-</ul>
-<h3>CI, Tooling & Test Stability</h3>
-<ul>
-<li>Pin SwiftFormat/SwiftLint versions and harden lint installer behavior (version drift + temp-file leak fixes) (#292).</li>
-<li>Use more deterministic macOS CI test settings (including non-parallel paths where needed) and align runner/toolchain behavior for stability (#292).</li>
-<li>Stabilize PTY command timing tests to reduce CI flakiness (#312).</li>
-<li>Upgrade <code>actions/checkout</code> to v6 and <code>actions/github-script</code> to v8 for Node 24 compatibility in <code>upstream-monitor.yml</code> (#290). Thanks @salmanmkc!</li>
-<li>Tests: add TaskLocal-based keychain/cache overrides so keychain gating and KeychainCacheStore test stores do not leak across concurrent test execution (#320).</li>
-</ul>
-<h3>Docs & Maintenance</h3>
-<ul>
-<li>Update docs for Claude data fetch behavior and keychain troubleshooting notes.</li>
-<li>Update MIT license year.</li>
-</ul>
-<p><a href="https://github.com/steipete/CodexBar/blob/main/CHANGELOG.md">View full changelog</a></p>
-]]></description>
-            <enclosure url="https://github.com/steipete/CodexBar/releases/download/v0.18.0-beta.3/CodexBar-0.18.0-beta.3.zip" length="23436028" type="application/octet-stream" sparkle:edSignature="mb72DHg5xz+AY/DrCDPhpkWaRa24NwcYXnW5lKuYBzlF5kMAsqTZGaG82KWPY8su8J5bJ5wtOMjVdzPCJWjvAw=="/>
-        </item>
-        <item sparkle:channel="beta">
-            <title>0.18.0-beta.2</title>
-            <pubDate>Wed, 21 Jan 2026 08:42:37 +0000</pubDate>
+        <item>
+            <title>0.37.2</title>
+            <pubDate>Mon, 22 Jun 2026 10:42:03 +0100</pubDate>
             <link>https://raw.githubusercontent.com/steipete/CodexBar/main/appcast.xml</link>
-            <sparkle:version>50</sparkle:version>
-            <sparkle:shortVersionString>0.18.0-beta.2</sparkle:shortVersionString>
+            <sparkle:version>92</sparkle:version>
+            <sparkle:shortVersionString>0.37.2</sparkle:shortVersionString>
             <sparkle:minimumSystemVersion>14.0</sparkle:minimumSystemVersion>
-            <description><![CDATA[<h2>CodexBar 0.18.0-beta.2</h2>
-<h3>Highlights</h3>
-<ul>
-<li>OpenAI web dashboard refresh cadence now follows 5× the base refresh interval.</li>
-<li>OpenAI web dashboard WebView is torn down after each scrape to reduce idle CPU.</li>
-<li>Codex settings now include a toggle to disable OpenAI web extras.</li>
-</ul>
-<h3>Providers</h3>
+            <description><![CDATA[<h2>CodexBar 0.37.2</h2>
+<h3>Added</h3>
 <ul>
-<li>Providers: add Dia browser support across cookie import and profile detection (#209). Thanks @validatedev!</li>
-<li>Codex: include archived session logs in local token cost scanning and dedupe by session id.</li>
-<li>Claude: harden CLI /usage parsing and avoid ANTHROPIC_* env interference during probes.</li>
+<li>Diagnostics: write redacted provider reports to a file with platform and app-version context. Thanks @Yuxin-Qiao!</li>
+<li>CLI server: report the startup build version from <code>/health</code> so clients can detect stale helper processes after updates. Thanks @enieuwy!</li>
 </ul>
-<h3>Menu & Menu Bar</h3>
+<h3>Fixed</h3>
 <ul>
-<li>Menu: opening OpenAI web submenus triggers a refresh when the data is stale.</li>
-<li>Menu: fix usage line labels to honor “Show usage as used”.</li>
-<li>Debug: add a toggle to keep Codex/Claude CLI sessions alive between probes.</li>
-<li>Debug: add a button to reset CLI probe sessions.</li>
-<li>App icon: use the classic icon on macOS 15 and earlier while keeping Liquid Glass for macOS 26+ (#178). Thanks @zerone0x!</li>
+<li>Claude: pause background CLI usage probes briefly after rate limiting while keeping manual refresh available. Thanks @kiranmagic7!</li>
+<li>Codex OAuth: publish refreshed <code>auth.json</code> credentials with private file permissions already applied. Thanks @Hinotoi-agent!</li>
+<li>Provider endpoints: reject unsafe Deepgram, z.ai, and Xiaomi MiMo overrides before attaching credentials. Thanks @Hinotoi-agent!</li>
+<li>Azure OpenAI: reject unsafe endpoint overrides before attaching API keys while keeping invalid configurations visible with an actionable error. Thanks @Hinotoi-agent!</li>
 </ul>
 <p><a href="https://github.com/steipete/CodexBar/blob/main/CHANGELOG.md">View full changelog</a></p>
 ]]></description>
-            <enclosure url="https://github.com/steipete/CodexBar/releases/download/v0.18.0-beta.2/CodexBar-0.18.0-beta.2.zip" length="22498811" type="application/octet-stream" sparkle:edSignature="Zcy1PnvfyNQnpFvuydwnIQ+lUh1wGF46p92MyVeVAa/z441erCIHZ9bKH4QDlc9cB/QsTkYfk3CvE0lHTu5CCA=="/>
+            <enclosure url="https://github.com/steipete/CodexBar/releases/download/v0.37.2/CodexBar-macos-universal-0.37.2.zip" length="41869351" type="application/octet-stream" sparkle:edSignature="R3cjc1hHRfLmvefG7/vueDXPPMGEWztAcu8MWU56wzFTisA18y4XvZV2qokxM/F47qiJUr3TseAgDevafnbPBQ=="/>
         </item>
-        <item sparkle:channel="beta">
-            <title>0.18.0-beta.1</title>
-            <pubDate>Sun, 18 Jan 2026 23:09:38 +0000</pubDate>
+        <item>
+            <title>0.37.1</title>
+            <pubDate>Mon, 22 Jun 2026 00:16:24 +0100</pubDate>
             <link>https://raw.githubusercontent.com/steipete/CodexBar/main/appcast.xml</link>
-            <sparkle:version>49</sparkle:version>
-            <sparkle:shortVersionString>0.18.0-beta.1</sparkle:shortVersionString>
+            <sparkle:version>91</sparkle:version>
+            <sparkle:shortVersionString>0.37.1</sparkle:shortVersionString>
             <sparkle:minimumSystemVersion>14.0</sparkle:minimumSystemVersion>
-            <description><![CDATA[<h2>CodexBar 0.18.0-beta.1</h2>
-<h3>Highlights</h3>
+            <description><![CDATA[<h2>CodexBar 0.37.1</h2>
+<h3>Fixed</h3>
 <ul>
-<li>New providers: OpenCode (web usage), Vertex AI, Kiro, Kimi, Kimi K2, Augment, Amp, Synthetic.</li>
-<li>Provider source controls: usage source pickers for Codex/Claude, manual cookie headers, cookie caching with source/timestamp.</li>
-<li>Menu bar upgrades: display mode picker (percent/pace/both), auto-select near limit, absolute reset times, pace summary line.</li>
-<li>CLI/config revamp: config-backed provider settings, JSON-only errors, config validate/dump.</li>
-</ul>
-<h3>Providers</h3>
-<ul>
-<li>OpenCode: add web usage provider with workspace override + Chrome-first cookie import (#188). Thanks @anthnykr!</li>
-<li>OpenCode: refresh provider logo (#190). Thanks @anthnykr!</li>
-<li>Vertex AI: add provider with quota-based usage from gcloud ADC. Thanks @bahag-chaurasiak!</li>
-<li>Vertex AI: token costs are shown via the Claude provider (same local logs).</li>
-<li>Vertex AI: harden quota usage parsing for edge-case responses.</li>
-<li>Kiro: add CLI-based usage provider via kiro-cli. Thanks @neror!</li>
-<li>Kiro: clean up provider wiring and show plan name in the menu.</li>
-<li>Kiro: harden CLI idle handling to avoid partial usage snapshots (#145). Thanks @chadneal!</li>
-<li>Kimi: add usage provider with cookie-based API token stored in Keychain (#146). Thanks @rehanchrl!</li>
-<li>Kimi K2: add API-key usage provider for credit totals (#147). Thanks @0-CYBERDYNE-SYSTEMS-0!</li>
-<li>Augment: add provider with browser-cookie usage tracking.</li>
-<li>Augment: prefer Auggie CLI usage with web fallback, plus session refresh + recovery tools (#142). Thanks @bcharleson!</li>
-<li>Amp: add provider with Amp Free usage tracking (#167). Thanks @duailibe!</li>
-<li>Synthetic: add API-key usage provider with quota snapshots (#171). Thanks @monotykamary!</li>
-<li>JetBrains AI: include IDEs missing quota files, expand custom paths, and add Android Studio base paths (#194). Thanks @steipete!</li>
-<li>Cursor: support legacy request-based plans and show individual on-demand usage (#125) — thanks @vltansky</li>
-<li>Cursor: avoid Intel crash when opening login and harden WebKit teardown. Thanks @meghanto!</li>
-<li>Cursor: load stored session cookies before reads to make relaunches deterministic.</li>
-<li>z.ai: add BigModel CN region option for API endpoint selection (#140). Thanks @nailuoGG!</li>
-<li>MiniMax: add China mainland region option + host overrides (#143). Thanks @nailuoGG!</li>
-<li>MiniMax: support API token or cookie auth; API token takes precedence and hides cookie UI (#149). Thanks @aonsyed!</li>
-<li>Gemini: prefer loadCodeAssist project IDs for quota fetches (#172). Thanks @lolwierd!</li>
-<li>Gemini: honor loadCodeAssist project IDs for quota + support Nix CLI layout (#184). Thanks @HaukeSchnau!</li>
-<li>Claude: fix OAuth “Extra usage” spend/limit units when the API returns minor currency units (#97).</li>
-<li>Claude: rescale extra usage costs when plan hints are missing and prefer web plan hints for extras (#181). Thanks @jorda0mega!</li>
-<li>Usage formatting: fix currency parsing/formatting on non-US locales (e.g., pt-BR). Thanks @mneves75!</li>
-</ul>
-<h3>Provider Sources & Security</h3>
-<ul>
-<li>Providers: cache browser cookies in Keychain (per provider) and show cached source/time in settings.</li>
-<li>Codex/Claude/Cursor/Factory/MiniMax: cookie sources now include Manual (paste a Cookie header) in addition to Automatic.</li>
-<li>Codex/Claude/Cursor/Factory/MiniMax: skip cookie imports from browsers without usable cookie stores (profile/cookie DB) to avoid unnecessary Keychain prompts.</li>
-<li>Providers: suppress repeated Chromium Keychain prompts after access denied and honor disabled Keychain access.</li>
-</ul>
-<h3>Preferences & Settings</h3>
-<ul>
-<li>Preferences: swap provider refresh button and enable toggle order.</li>
-<li>Preferences: animate settings width and widen Providers on selection.</li>
-<li>Preferences: shrink default settings size and reduce overall height.</li>
-<li>Preferences: move “Hide personal information” to Advanced.</li>
-<li>Providers: shorten fetch subtitle to relative time only.</li>
-<li>Preferences: soften provider sidebar background and stabilize drag reordering.</li>
-<li>Preferences: restrict provider drag handle to handle-only.</li>
-<li>Preferences: move provider refresh timing to a dedicated second line.</li>
-<li>Preferences: tighten provider usage metrics spacing.</li>
-<li>Preferences: show refresh timing inline in provider detail subtitle.</li>
-<li>Preferences: move “Access OpenAI via web” into Providers → Codex.</li>
-<li>Preferences: add usage source pickers for Codex + Claude with auto fallback.</li>
-<li>Preferences: add cookie source pickers with contextual helper text for the selected mode.</li>
-<li>Preferences: move “Disable Keychain access” to Advanced and require manual cookies when enabled.</li>
-<li>Preferences: add per-provider menu bar metric picker (#185) — thanks @HaukeSchnau</li>
-<li>Preferences: tighten provider rows (inline pickers, compact layout, inline refresh + auto-source status).</li>
-<li>Preferences: remove the “experimental” label from Antigravity.</li>
-</ul>
-<h3>Menu & Menu Bar</h3>
-<ul>
-<li>Menu: add a toggle to show reset times as absolute clock values (instead of countdowns).</li>
-<li>Menu: show an “Open Terminal” action when Claude OAuth fails.</li>
-<li>Menu: add “Hide personal information” toggle and redact emails in menu UI (#137). Thanks @t3dotgg!</li>
-<li>Menu: keep a pace summary line alongside the visual marker (#155). Thanks @antons!</li>
-<li>Menu: reduce provider-switch flicker and avoid redundant menu card sizing for faster opens (#132). Thanks @ibehnam!</li>
-<li>Menu: keep background refresh on open without forcing token usage (#158). Thanks @weequan93!</li>
-<li>Menu: Cursor switcher shows On-Demand remaining when Plan is exhausted in show-remaining mode (#193). Thanks @vltansky!</li>
-<li>Menu: avoid single-letter wraps in provider switcher titles.</li>
-<li>Menu: widen provider switcher buttons to avoid clipped titles.</li>
-<li>Menu bar: rebuild provider status items on reorder so icons update correctly.</li>
-<li>Menu bar: optional auto-select provider closest to its rate limit and keep switcher progress visible (#159). Thanks @phillco!</li>
-<li>Menu bar: add display mode picker for percent/pace/both in the menu bar icon (#169). Thanks @PhilETaylor!</li>
-<li>Menu bar: fix combined loading indicator flicker during loading animation (incl. debug replay).</li>
-<li>Menu bar: prevent blink updates from clobbering the loading animation.</li>
-</ul>
-<h3>CLI & Config</h3>
-<ul>
-<li>CLI: respect the reset time display setting.</li>
-<li>CLI: add pink accents, usage bars, and weekly pace lines to text output.</li>
-<li>CLI: add config-backed provider settings, <code>--json-only</code>, and <code>--source api</code> for key-based providers.</li>
-<li>CLI: add <code>config validate</code>/<code>config dump</code> commands and per-provider JSON error payloads.</li>
-<li>CLI/App: move provider secrets + ordering to <code>~/.codexbar/config.json</code> (no Keychain persistence).</li>
-<li>Providers: resolve API tokens from config/env only (no Keychain fallback).</li>
-</ul>
-<h3>Dev & Tests</h3>
-<ul>
-<li>Dev: move Chromium profile discovery into SweetCookieKit (adds Helium net.imput.helium). Thanks @hhushhas!</li>
-<li>Dev: bump SweetCookieKit to 0.2.0.</li>
-<li>Dev: migrate stored Keychain items to reduce rebuild prompts.</li>
-<li>Dev: move path debug snapshot off the main thread and debounce refreshes to avoid startup hitches (#131). Thanks @ibehnam!</li>
-<li>Tests: expand Kiro CLI coverage.</li>
-<li>Tests: stabilize Claude PTY integration cleanup and reset CLI sessions after probes.</li>
-<li>Tests: kill leaked codex app-server after tests.</li>
-<li>Tests: add regression coverage for merged loading icon layout stability.</li>
-<li>Tests: cover config validation and JSON-only CLI errors.</li>
-<li>Build: stabilize Swift test runtime.</li>
+<li>MiniMax: recover detailed token-plan windows from the remains API when the coding-plan page only exposes coarse usage. Thanks @Yuxin-Qiao!</li>
+<li>Cost history: remove the redundant tooltip from submenu-backed Cost rows. Thanks @Zihao-Qi!</li>
+<li>Menu refresh: keep the menu open and show in-place progress when Refresh is clicked. Thanks @elijahfriedman!</li>
+<li>Menu: align provider usage-card spacing with the Overview layout. Thanks @Zihao-Qi!</li>
+<li>Memory pressure: avoid actor-isolation crashes when system callbacks arrive on a utility queue. Thanks @Zihao-Qi!</li>
+<li>Menu: remove extra separators and spacing around Storage, Cost, and Subscription Utilization rows. Thanks @elijahfriedman!</li>
+<li>Antigravity: show limits as unavailable when OAuth identifies the account but quota endpoints deny access. Thanks @Yuxin-Qiao!</li>
 </ul>
 <p><a href="https://github.com/steipete/CodexBar/blob/main/CHANGELOG.md">View full changelog</a></p>
 ]]></description>
-            <enclosure url="https://github.com/steipete/CodexBar/releases/download/v0.18.0-beta.1/CodexBar-0.18.0-beta.1.zip" length="18538687" type="application/octet-stream" sparkle:edSignature="gXM4bz3B7CNXqWKpISJIWkZTCIGN98xowWYB5Qzgi0KL8UdhreIxdqthJ+Q/+ZbC9LG9ubNgth4y10zDfUPGBQ=="/>
+            <enclosure url="https://github.com/steipete/CodexBar/releases/download/v0.37.1/CodexBar-macos-universal-0.37.1.zip" length="41812121" type="application/octet-stream" sparkle:edSignature="cqlgE5GH+COZUsrNAeman3SDRxrzog4zVELTwlf7JDdZAUHkZbT6nerREbCVK9J1D1sLg1YUgcT0QdvCIhKZAA=="/>
         </item>
         <item>
-            <title>0.17.0</title>
-            <pubDate>Wed, 31 Dec 2025 23:12:24 +0100</pubDate>
+            <title>0.37.0</title>
+            <pubDate>Sat, 20 Jun 2026 03:07:41 +0100</pubDate>
             <link>https://raw.githubusercontent.com/steipete/CodexBar/main/appcast.xml</link>
-            <sparkle:version>48</sparkle:version>
-            <sparkle:shortVersionString>0.17.0</sparkle:shortVersionString>
+            <sparkle:version>90</sparkle:version>
+            <sparkle:shortVersionString>0.37.0</sparkle:shortVersionString>
             <sparkle:minimumSystemVersion>14.0</sparkle:minimumSystemVersion>
-            <description><![CDATA[<h2>CodexBar 0.17.0</h2>
-<ul>
-<li>New providers: MiniMax.</li>
-<li>Keychain: show a preflight explanation before macOS prompts for OAuth tokens or cookie decryption.</li>
-<li>Providers: defer z.ai + Copilot Keychain reads until the user interacts with the token field.</li>
-<li>Menu bar: avoid status item menu reattachment and layout flips during refresh to reduce icon flicker.</li>
-<li>Dev: align SweetCookieKit local-storage tests with Swift Testing.</li>
-<li>Charts: align hover selection bands with visible bars in credits + usage breakdown history.</li>
-<li>About: fix website link in the About panel. Thanks @felipeorlando!</li>
+            <description><![CDATA[<h2>CodexBar 0.37.0</h2>
+<h3>Added</h3>
+<ul>
+<li>Widgets: add single-window and combined burn-down charts for Codex and Claude session/weekly limits. Thanks @jamesjlopez!</li>
+<li>AWS Bedrock: show optional rolling 14-day Claude token and request totals from CloudWatch. Thanks @zyaiire!</li>
+<li>Codex: optionally show both session-window and weekly percentages in the compact menu bar label. Thanks @thepraggyverse!</li>
+<li>Cursor: show personal on-demand spend alongside the shared team pool. Thanks @yashiels!</li>
+<li>Documentation: link the community KDE Plasma panel integration. Thanks @tylxr59!</li>
+<li>Codex: expose explicitly configured profile homes as switchable accounts without copying their credentials. Thanks @kiranmagic7!</li>
+<li>Codex: show available manual rate-limit reset credits and their next expiry for signed-in OAuth accounts. Thanks @rogdex24!</li>
+<li>Mistral: add Vibe monthly-plan usage and menu bar metric selection. Thanks @lfmundim!</li>
+<li>Storage: show a compact segmented provider breakdown with an expandable Other group. Thanks @elijahfriedman!</li>
+<li>Settings: add an optional enabled-first alphabetical sort for the Providers sidebar without changing custom order. Thanks @elijahfriedman!</li>
+<li>Linux CLI: publish static musl release tarballs for x86_64 and aarch64. Thanks @Yuxin-Qiao!</li>
+<li>Documentation: add safe troubleshooting for browser Keychain prompts that persist after uninstall. Thanks @Yuxin-Qiao!</li>
+<li>Diagnostics: report provider-neutral usage confidence and mark fully decoded Codex OAuth windows exact. Thanks @Yuxin-Qiao!</li>
+<li>Codex agents: add a read-only <code>codexbar</code> skill for bounded, redacted provider usage JSON. Thanks @coygeek!</li>
+<li>Display: add a Hide critters option for plain menu bar quota capsules. Thanks @elijahfriedman!</li>
+</ul>
+<h3>Changed</h3>
+<ul>
+<li>Packaging: strip local symbols from release executables to reduce the installed app and download size. Thanks @jieshu666!</li>
+<li>Logging: skip message, metadata, and redaction work for filtered or disabled log destinations. Thanks @ProspectOre!</li>
+<li>Cost history: cache date parsers per thread to reduce repeated report-decoding overhead. Thanks @ProspectOre!</li>
+<li>Linux CLI: accept an opt-in static SQLite library directory for musl builds. Thanks @Yuxin-Qiao!</li>
+<li>Linux CLI: add musl source compatibility for static Linux SDK builds. Thanks @Yuxin-Qiao!</li>
+<li>Cost history: resize the chart details to the hovered day&#x27;s model breakdown instead of reserving the tallest day. Thanks @elijahfriedman!</li>
+<li>Antigravity: use current backend quota labels in menus and widgets while preferring a usable quota lane over an exhausted one. Thanks @Yuxin-Qiao!</li>
+<li>Pi: cache session filename and timestamp parsers to reduce cost-history refresh overhead. Thanks @ProspectOre!</li>
+<li>Menu bar: reuse the icon-observation signature during provider refreshes instead of computing it twice. Thanks @abe238!</li>
+<li>LiteLLM: show personal and team spend amounts directly on budget rows while suppressing duplicate budget sections. Thanks @hololee!</li>
+</ul>
+<h3>Fixed</h3>
+<ul>
+<li>Menu: align cost and utilization rows with provider content and use native bottom action items. Thanks @elijahfriedman!</li>
+<li>Charts: keep hover selection on bar widths, preserve single-day details, and remove redundant cost-menu detail lines. Thanks @elijahfriedman!</li>
+<li>Cost history: keep chart date labels aligned with their bars and visible without clipping. Thanks @elijahfriedman!</li>
+<li>Claude settings: dim and disable Avoid Keychain prompts while global Keychain access is disabled. Thanks @Zihao-Qi!</li>
+<li>Linux CLI: read OpenCode Go local SQLite usage in automatic mode and allow Command Code billing with a configured manual cookie.</li>
+<li>MiniMax diagnostics: include safe per-service usage and boosted quota limits for mismatch reports. Thanks @sagelga!</li>
+<li>Xiaomi MiMo: retry another imported browser session when a stale session redirects API requests to login. Thanks @Yuxin-Qiao!</li>
+<li>MiniMax: retry the China API region when the global token endpoint reports a structured invalid-key response.</li>
+<li>Menu refresh: scope manual refreshes to the visible provider, keep Command-R consistent with mouse refresh, and avoid animated refresh-row compositing. Thanks @jangisaac-dev!</li>
+<li>Localization: improve Catalan app and website translations. Thanks @pmontp19!</li>
+<li>Claude web: persist renewed session cookies after successful usage requests so imported sessions stay current. Thanks @ProspectOre!</li>
+<li>Kiro: keep parsed usage available when the optional account probe times out or fails. Thanks @Yuxin-Qiao!</li>
+<li>Cursor: ignore an exhausted Auto or API subquota only when another independent quota remains usable, while preserving the overall cap. Thanks @Yuxin-Qiao!</li>
+<li>Memory: release idle OpenAI WebViews under system pressure without blocking the main thread. Thanks @ProspectOre!</li>
+<li>Memory: trim rebuildable menu and OpenAI debug caches under system pressure. Thanks @ProspectOre!</li>
+<li>Provider plans: keep Claude and Kiro plan matching on one rendered line to avoid bogus labels from adjacent usage hints. Thanks @elijahfriedman!</li>
+<li>Antigravity: use current Gemini 5-hour and weekly quota-summary lanes for the compact menu bar icon and merged highest-usage selection. Thanks @Zihao-Qi!</li>
+<li>Usage bars: render values rounded to 0% or 100% as fully empty or full. Thanks @Zihao-Qi!</li>
+<li>Codex web: keep cookie-import deadlines responsive when browser cookie work blocks the shared worker pool.</li>
+<li>z.ai: open the usage dashboard for the configured global or China API region. Thanks @renbaoshuo!</li>
+<li>Usage dashboards: tint inline history bars with each provider&#x27;s branding color. Thanks @elijahfriedman!</li>
+<li>Command Code: avoid repeated depleted notifications when subscription lookup intermittently fails. Thanks @LPFchan!</li>
+<li>Codex pace: extrapolate historically exhausted weeks for run-out forecasts and avoid contradictory reset headlines. Thanks @Yuxin-Qiao!</li>
+<li>Localization: correct the German in-progress refresh label. Thanks @ChrisLauinger77!</li>
+<li>Localization: correct misleading literal German UI translations. Thanks @madebyjulz!</li>
+<li>Install docs: describe the official Homebrew cask as universal on Intel and Apple silicon. Thanks @ChrisGVE!</li>
+<li>Settings: switch tabs immediately before animated window resizing and reduce Providers sidebar work. Thanks @elijahfriedman!</li>
+<li>Windsurf: import complete Devin sessions from the current app origin before legacy browser storage. Thanks @kiranmagic7!</li>
+<li>Antigravity: humanize raw model identifiers while preserving server-provided quota labels. Thanks @bcharleson!</li>
+<li>Menu bar: show provider status markers only for the provider rendered in each icon. Thanks @Zihao-Qi!</li>
+<li>Codex CLI: make automatic usage reads prefer OAuth and CLI sources instead of blocking on the optional web dashboard.</li>
+<li>Codex web: apply <code>--web-timeout</code> to the full cookie import, account verification, retry, and dashboard fetch path.</li>
+<li>OpenCode Go: allow configured manual cookies in the Linux CLI while keeping browser-cookie import gated to macOS. Thanks @Yuxin-Qiao!</li>
+<li>Provider probes: cap captured subprocess output at 1 MiB per stream without dropping valid text at a truncated UTF-8 boundary. Thanks @ProspectOre!</li>
+<li>Provider switcher: keep Codex quota rows visible when switching away and back during a manual refresh, including menus with usage-history sections. Thanks @Yuxin-Qiao!</li>
+<li>Bedrock: ignore invalid billing dates when selecting the latest usage values. Thanks @ProspectOre!</li>
+<li>Usage history: let opted-in providers persist weekly utilization and keep saved charts visible. Thanks @kiranmagic7!</li>
+<li>Localization: improve Japanese terminology consistency and localize next-day reset times across all 21 app languages. Thanks @tukuyomil032!</li>
+<li>Menu bar: keep visible quota values stable while a manual refresh is in flight without rewinding background-refresh countdowns. Thanks @Zihao-Qi!</li>
+<li>Menu bar: stop informational usage-card rows from highlighting like clickable actions. Thanks @elijahfriedman!</li>
+<li>Localization: validate placeholder integrity across every app language and repair malformed Vietnamese interpolation tokens. Thanks @Yuxin-Qiao!</li>
 </ul>
 <p><a href="https://github.com/steipete/CodexBar/blob/main/CHANGELOG.md">View full changelog</a></p>
 ]]></description>
-            <enclosure url="https://github.com/steipete/CodexBar/releases/download/v0.17.0/CodexBar-0.17.0.zip" length="14296774" type="application/octet-stream" sparkle:edSignature="8n//nfQb9cz3hyoc/4+eitFvGl/FJrruUS99aIfqHwgtXhi1V4he9dKh7zKNt78mcP6raJGg+Ha5yHgglfSTDQ=="/>
+            <enclosure url="https://github.com/steipete/CodexBar/releases/download/v0.37.0/CodexBar-macos-universal-0.37.0.zip" length="41769771" type="application/octet-stream" sparkle:edSignature="xAjgJ8Pxk52Tyq/n5VBkHmnvsofbKtXb58RAcNZuUo84adBGg988OWuB0O/fbZd9u7qXI0/X5kSXgKwq5/YvAA=="/>
         </item>
         <item>
             <title>0.14.0</title>
@@ -272,4 +176,4 @@
             <enclosure url="https://github.com/steipete/CodexBar/releases/download/v0.12.0/CodexBar-0.12.0.zip" length="4888386" type="application/octet-stream" sparkle:edSignature="tQMHO/RNAbvwRHXYnLAkNV2ksiV722qR8fEYzcbipgetacfPnwnLJ0Pe/lAiZ03PBmj3BkisHb74GosUlSV+DQ=="/>
         </item>
     </channel>
-</rss>
+</rss>
\ No newline at end of file
diff --git a/bin/install-codexbar-cli.sh b/bin/install-codexbar-cli.sh
index 50fb953377..742a974e2f 100755
--- a/bin/install-codexbar-cli.sh
+++ b/bin/install-codexbar-cli.sh
@@ -10,23 +10,20 @@ if [[ ! -x "$HELPER" ]]; then
   exit 1
 fi
 
-install_script=$(mktemp)
-cat > "$install_script" <<'EOF'
-#!/usr/bin/env bash
-set -euo pipefail
-HELPER="__HELPER__"
-TARGETS=("/usr/local/bin/codexbar" "/opt/homebrew/bin/codexbar")
-
-for t in "${TARGETS[@]}"; do
-  mkdir -p "$(dirname "$t")"
-  ln -sf "$HELPER" "$t"
-  echo "Linked $t -> $HELPER"
-done
-EOF
-
-perl -pi -e "s#__HELPER__#$HELPER#g" "$install_script"
+osascript - "$HELPER" <<'APPLESCRIPT'
+on run argv
+  set helperPath to item 1 of argv
+  set installCommand to "set -euo pipefail" & linefeed & ¬
+    "HELPER=" & quoted form of helperPath & linefeed & ¬
+    "TARGETS=(\"/usr/local/bin/codexbar\" \"/opt/homebrew/bin/codexbar\")" & linefeed & ¬
+    "for t in \"${TARGETS[@]}\"; do" & linefeed & ¬
+    "  mkdir -p \"$(dirname \"$t\")\"" & linefeed & ¬
+    "  ln -sf \"$HELPER\" \"$t\"" & linefeed & ¬
+    "  echo \"Linked $t -> $HELPER\"" & linefeed & ¬
+    "done"
 
-osascript -e "do shell script \"bash '$install_script'\" with administrator privileges"
-rm -f "$install_script"
+  do shell script "bash -c " & quoted form of installCommand with administrator privileges
+end run
+APPLESCRIPT
 
 echo "CodexBar CLI installed. Try: codexbar usage"
diff --git a/docs/DEVELOPMENT.md b/docs/DEVELOPMENT.md
index 072cd9e7f6..b8f2d80cb1 100644
--- a/docs/DEVELOPMENT.md
+++ b/docs/DEVELOPMENT.md
@@ -13,9 +13,12 @@ read_when:
 ### Building and Running
 
 ```bash
-# Full build, test, package, and launch (recommended)
+# Full build, package, and launch (recommended)
 ./Scripts/compile_and_run.sh
 
+# Also run the sharded test suite before packaging/relaunching
+./Scripts/compile_and_run.sh --test
+
 # Just build and package (no tests)
 ./Scripts/package_app.sh
 
@@ -26,7 +29,7 @@ read_when:
 ### Development Workflow
 
 1. **Make code changes** in `Sources/CodexBar/`
-2. **Run** `./Scripts/compile_and_run.sh` to rebuild and launch
+2. **Run** `./Scripts/compile_and_run.sh --test` to test, rebuild, and launch
 3. **Check logs** in Console.app (filter by "codexbar")
 4. **Optional file log**: enable Debug → Logging → "Enable file logging" to write
    `~/Library/Logs/CodexBar/CodexBar.log` (verbosity defaults to "Verbose")
@@ -37,7 +40,9 @@ read_when:
 You'll see **one keychain prompt per stored credential** on the first launch. This is a **one-time migration** that converts existing keychain items to use `kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly`.
 
 ### Subsequent Rebuilds
-**Zero prompts!** The migration flag is stored in UserDefaults, so future rebuilds won't prompt.
+The migration flag is stored in UserDefaults, so migrated CodexBar-owned items should not prompt again. Ad-hoc
+signing can still prompt for other keychain surfaces; use `./Scripts/compile_and_run.sh --clear-adhoc-keychain`
+when you intentionally want to reset ad-hoc keychain state.
 
 ### Why This Happens
 - Ad-hoc signed development builds change code signature on every rebuild
@@ -50,28 +55,20 @@ You'll see **one keychain prompt per stored credential** on the first launch. Th
 defaults delete com.steipete.codexbar KeychainMigrationV1Completed
 ```
 
-## Auto-Refresh for Augment Cookies
+## Augment Cookie Refresh
 
 ### How It Works
-CodexBar automatically refreshes Augment cookies from your browser:
-
-1. **Automatic Import**: On every usage refresh, CodexBar imports fresh cookies from your browser
-2. **Browser Priority**: Chrome → Arc → Safari → Firefox → Brave (configurable)
-3. **Session Detection**: Looks for Auth0/NextAuth session cookies
-4. **Fallback**: If import fails, uses last known good cookies from keychain
+CodexBar checks Augment through the provider fetch pipeline. Auto mode tries the Augment CLI first, then the
+browser-cookie web path. The web path reuses cached cookies when possible and imports from supported browsers when
+the cache is missing or rejected.
 
 ### Refresh Frequency
 - Default: Every 5 minutes (configurable in Preferences → General)
-- Minimum: 30 seconds
-- Cookie import happens automatically on each refresh
+- Minimum: 1 minute
+- Cookie import happens automatically when cached cookies need refresh
 
 ### Supported Browsers
-- Chrome
-- Arc
-- Safari
-- Firefox
-- Brave
-- Edge
+- Safari, Chrome variants, Edge variants, Brave, Arc variants, Dia, and Firefox.
 
 ### Manual Cookie Override
 If automatic import fails:
@@ -102,24 +99,23 @@ CodexBar/
 ## Common Tasks
 
 ### Add a New Provider
-1. Create `Sources/CodexBar/Providers/YourProvider/`
-2. Implement `ProviderImplementation` protocol
-3. Add to `ProviderRegistry.swift`
-4. Add icon to `Resources/ProviderIcon-yourprovider.svg`
+1. Add a `UsageProvider` case in `Sources/CodexBarCore/Providers/Providers.swift`
+2. Add core descriptor/fetcher wiring under `Sources/CodexBarCore/Providers/YourProvider/`
+3. Add app-side implementation under `Sources/CodexBar/Providers/YourProvider/`
+4. Register the descriptor in `ProviderDescriptorRegistry`
+5. Register the implementation in `ProviderImplementationRegistry`
+6. Add icon assets such as `Resources/ProviderIcon-yourprovider.svg`
 
 ### Debug Cookie Issues
-```bash
-# Enable verbose logging
-export CODEXBAR_LOG_LEVEL=debug
-./Scripts/compile_and_run.sh
-
-# Check logs in Console.app
-# Filter: subsystem:com.steipete.codexbar category:augment-cookie
-```
+1. Enable Debug → Logging → "Enable file logging" or raise verbosity in the app settings.
+2. Reproduce with `./Scripts/compile_and_run.sh`.
+3. Check logs in Console.app:
+   - Filter: `subsystem:com.steipete.codexbar category:augment`
+   - Importer messages include the `[augment-cookie]` prefix
 
 ### Run Tests Only
 ```bash
-swift test
+make test
 ```
 
 ### Format Code
@@ -133,13 +129,13 @@ swiftlint --strict
 ### Local Development Build
 ```bash
 ./Scripts/package_app.sh
-# Creates: CodexBar.app (ad-hoc signed)
+# Creates: CodexBar.app (Developer ID by default; set CODEXBAR_SIGNING=adhoc for ad-hoc signing)
 ```
 
 ### Release Build (Notarized)
 ```bash
 ./Scripts/sign-and-notarize.sh
-# Creates: CodexBar-arm64.zip (notarized for distribution)
+# Creates: CodexBar-<version>.zip and CodexBar-<version>.dSYM.zip
 ```
 
 See `docs/RELEASING.md` for full release process.
@@ -162,15 +158,31 @@ defaults read com.steipete.codexbar KeychainMigrationV1Completed
 # Should output: 1
 
 # Check migration logs
-log show --predicate 'category == "KeychainMigration"' --last 5m
+log show --predicate 'category == "keychain-migration"' --last 5m
 ```
 
 ### Cookies Not Refreshing
-1. Check browser is supported (Chrome, Arc, Safari, Firefox, Brave)
+1. Check the browser is supported by the Augment provider metadata
 2. Verify you're logged into Augment in that browser
 3. Check Preferences → Providers → Augment → Cookie source is "Automatic"
 4. Enable debug logging and check Console.app
 
+### Main-Thread Hangs
+
+Debug builds start the hang watchdog automatically. To diagnose a release build,
+enable it explicitly and restart CodexBar:
+
+```bash
+defaults write com.steipete.codexbar debugMainThreadHangWatchdog -bool true
+```
+
+Hangs are written to the app log. Hangs over two seconds also request a process
+sample under `~/Library/Logs/CodexBar/`. Disable the release opt-in with:
+
+```bash
+defaults delete com.steipete.codexbar debugMainThreadHangWatchdog
+```
+
 ## Architecture Notes
 
 ### Menu Bar App Pattern
@@ -181,12 +193,13 @@ log show --predicate 'category == "KeychainMigration"' --last 5m
 
 ### Cookie Management
 - Automatic browser import via SweetCookieKit
-- Keychain storage for persistence
+- Keychain cache for some imported browser cookies and OAuth/device-flow credentials
+- `~/.codexbar/config.json` for provider settings, manual cookies, and stored API keys
 - Manual override for debugging
-- Auto-refresh on every usage poll
+- Browser-cookie import when cached sessions need refresh
 
 ### Usage Polling
 - Background timer (configurable frequency)
 - Parallel provider fetches
-- Exponential backoff on errors
-- Widget snapshot for iOS widget
+- First failure can be suppressed when prior data exists
+- WidgetKit snapshot for macOS widgets
diff --git a/docs/DEVELOPMENT_SETUP.md b/docs/DEVELOPMENT_SETUP.md
index a32098e4ea..ba7b47bc07 100644
--- a/docs/DEVELOPMENT_SETUP.md
+++ b/docs/DEVELOPMENT_SETUP.md
@@ -15,6 +15,9 @@ When developing CodexBar, you may see frequent keychain permission prompts like:
 > **CodexBar wants to access key "Claude Code-credentials" in your keychain.**
 
 This happens because each rebuild creates a new code signature, and macOS treats it as a "different" app.
+That can affect both CodexBar-owned entries (`com.steipete.CodexBar`, `com.steipete.codexbar.cache`) and
+third-party items such as `Claude Code-credentials`, so an ad-hoc-signed rebuild can keep re-triggering
+password/keychain approval dialogs even after you previously chose **Always Allow**.
 
 ### Quick Fix (Temporary)
 
@@ -96,11 +99,23 @@ The build script creates `CodexBar.app` in the project root. Old numbered builds
 This script:
 1. Kills existing CodexBar instances
 2. Runs `swift build` (release mode)
-3. Runs `swift test` (all tests)
+3. Runs the sharded full test suite when `--test` is passed
 4. Packages the app with `./Scripts/package_app.sh`
 5. Launches `CodexBar.app`
 6. Verifies it stays running
 
+Launching an unbundled `CodexBar` executable, including SwiftPM builds using `.build` or a custom scratch path, disables
+Keychain access for that process to avoid repeated password prompts. Use the packaged `CodexBar.app` when local
+validation needs browser cookies or stored credentials; packaged app bundles keep their normal Keychain behavior
+regardless of signing mode.
+
+When the script falls back to ad-hoc signing, it preserves CodexBar-owned keychain state by default.
+That means you may still see keychain prompts for existing CodexBar cache entries, but allowing those prompts keeps the
+cached browser/OAuth state available across normal rebuilds.
+If you want a clean reset of CodexBar-owned keychain state for an ad-hoc build, run
+`./Scripts/compile_and_run.sh --clear-adhoc-keychain` before relaunching.
+Third-party keychain items still need stable signing if you want macOS to remember **Always Allow** across rebuilds.
+
 ### Quick Build (No Tests)
 
 ```bash
@@ -111,7 +126,7 @@ swift build -c release
 ### Run Tests Only
 
 ```bash
-swift test
+make test
 ```
 
 ### Debug Build
diff --git a/docs/FORK_QUICK_START.md b/docs/FORK_QUICK_START.md
index 3f60c9f87d..9168d37536 100644
--- a/docs/FORK_QUICK_START.md
+++ b/docs/FORK_QUICK_START.md
@@ -41,7 +41,7 @@ read_when:
 swift build
 
 # Run tests
-swift test
+make test
 
 # Format code
 swiftformat Sources Tests
@@ -57,11 +57,9 @@ cd /Users/steipete/Projects/codexbar && open -n /Users/steipete/Projects/codexba
 
 ### Release
 ```bash
-# Sign and notarize (keep in foreground!)
-./Scripts/sign-and-notarize.sh
-
-# Create appcast
-./Scripts/make_appcast.sh <zip> <feed-url>
+# Edit .mac-release.env first: MAC_RELEASE_REPO, feed URL, download URL,
+# bundle id, and Sparkle public/signing key must point at your fork.
+./Scripts/release.sh
 
 # See full release process
 cat docs/RELEASING.md
@@ -130,13 +128,13 @@ git push origin feature/my-feature
 ### Testing Changes
 ```bash
 # Run all tests
-swift test
+make test
 
 # Run specific test
 swift test --filter AugmentTests
 
 # Build and test together
-./Scripts/compile_and_run.sh
+./Scripts/compile_and_run.sh --test
 ```
 
 ### Updating Documentation
diff --git a/docs/FORK_ROADMAP.md b/docs/FORK_ROADMAP.md
index 0c73db9762..bf52353de0 100644
--- a/docs/FORK_ROADMAP.md
+++ b/docs/FORK_ROADMAP.md
@@ -118,7 +118,7 @@ This document outlines the development roadmap for the CodexBar fork maintained
 
 **Files to Create:**
 - `Scripts/sync_upstream.sh`
-- `docs/UPSTREAM_SYNC.md`
+- `docs/UPSTREAM_STRATEGY.md`
 - `.github/workflows/upstream-sync-check.yml`
 
 ---
@@ -228,5 +228,5 @@ This document outlines the development roadmap for the CodexBar fork maintained
 - [Augment Provider](augment.md) - Augment-specific documentation
 - [Development Guide](DEVELOPMENT.md) - Build and test instructions
 - [Provider Authoring](provider.md) - How to create new providers
-- [Upstream Sync](UPSTREAM_SYNC.md) - Syncing with original repository (TBD)
+- [Upstream Strategy](UPSTREAM_STRATEGY.md) - Syncing with original repository
 - [Quotio Analysis](QUOTIO_ANALYSIS.md) - Feature comparison (TBD)
diff --git a/docs/FORK_SETUP.md b/docs/FORK_SETUP.md
index d2b732a2ee..a40b64daa0 100644
--- a/docs/FORK_SETUP.md
+++ b/docs/FORK_SETUP.md
@@ -255,7 +255,7 @@ git cherry-pick <your-commit-hash>
 git diff upstream/main
 
 # 4. Test
-swift test
+make test
 
 # 5. Push to your fork
 git push origin upstream-pr/fix-cursor-bonus
diff --git a/docs/ISSUE_LABELING.md b/docs/ISSUE_LABELING.md
new file mode 100644
index 0000000000..8e0ba964a6
--- /dev/null
+++ b/docs/ISSUE_LABELING.md
@@ -0,0 +1,199 @@
+---
+summary: "Issue labeling policy for triage, prioritization, and backlog hygiene."
+read_when:
+  - Triageing GitHub issues
+  - Adding or updating issue labels
+  - Organizing the backlog
+---
+
+# Issue labeling guide
+
+This repo uses labels to make the issue tracker easier to scan by:
+
+- **type** — what kind of issue is this?
+- **priority** — how urgent is it?
+- **area** — what subsystem is affected?
+- **provider** — which provider/service is involved?
+- **workflow state** — what kind of follow-up is needed?
+
+The goal is not to perfectly label everything. The goal is to make open issues easy to sort into:
+
+- what is broken now,
+- what needs maintainer attention,
+- what is accepted backlog,
+- and what belongs to a specific provider or subsystem.
+
+## Labeling rules
+
+For most open issues, aim to apply:
+
+- **1 type label**
+- **1 priority label**
+- **1 workflow label**
+- **1 area label**
+- **0–1 provider labels**
+
+That means most issues should end up with **3–5 labels max**.
+
+## Type labels
+
+Use the existing GitHub-style labels:
+
+- `bug` — broken behavior, crash, mismatch, false negative, bad parsing, auth failure
+- `enhancement` — feature request, UX improvement, support for a new workflow
+- `documentation` — docs, onboarding, missing setup guidance
+- `question` — only for issues that are primarily asking for clarification or support
+
+Avoid using `question` as a generic fallback when the issue is actually a bug or feature request.
+
+## Priority labels
+
+- `priority:high` — crashes, install failures, auth/account breakage, provider unusable, severe resource issues
+- `priority:medium` — real issue or good feature request, but not urgent
+- `priority:low` — minor polish, optional UX improvements, long-tail backlog
+
+## Workflow labels
+
+- `needs-triage` — new issue that has not been categorized yet
+- `needs-repro` — needs logs, screenshots, exact steps, or a current repro
+- `needs-design` — valid request, but needs a product/UX decision before implementation
+- `blocked-upstream` — likely caused or limited by upstream provider behavior
+- `accepted` — intentionally kept open as part of the backlog/roadmap
+
+## Area labels
+
+- `area:auth-keychain` — keychain prompts, login state, token refresh, account switching
+- `area:install-distribution` — Homebrew, packaging, launch/install failures, binary detection
+- `area:usage-accuracy` — usage %, reset windows, plan parsing, cost/token math
+- `area:performance` — CPU, battery, memory, background sessions/process churn
+- `area:ui-ux` — menu bar behavior, settings, copy, visual layout, interaction polish
+- `area:widget` — widget registration, app groups, widget gallery visibility
+- `area:docs-onboarding` — setup docs, onboarding docs, missing instructions
+- `area:notifications` — threshold alerts, prompt waiting, quota notifications
+- `area:export-integration` — Prometheus, HTTP server mode, external integrations
+- `area:accounts` — multiple accounts, account discovery, account switching UX
+
+## Provider labels
+
+Only apply one when a provider is clearly the main subject:
+
+- `provider:claude`
+- `provider:codex`
+- `provider:cursor`
+- `provider:copilot`
+- `provider:gemini`
+- `provider:alibaba`
+- `provider:factory`
+- `provider:antigravity`
+- `provider:opencode`
+- `provider:zai`
+- `provider:openrouter`
+
+Not every issue needs a provider label.
+
+## Close-time labels
+
+These are mostly useful when resolving issues, not as backlog-organizing labels:
+
+- `duplicate`
+- `invalid`
+- `wontfix`
+- `stale`
+
+## Recommended minimum viable label set
+
+If starting from a sparse tracker, add these first:
+
+### Priority
+- `priority:high`
+- `priority:medium`
+- `priority:low`
+
+### Workflow
+- `needs-triage`
+- `needs-repro`
+- `needs-design`
+- `accepted`
+
+### Area
+- `area:auth-keychain`
+- `area:install-distribution`
+- `area:usage-accuracy`
+- `area:performance`
+- `area:ui-ux`
+- `area:widget`
+- `area:docs-onboarding`
+
+### Provider
+- `provider:claude`
+- `provider:codex`
+- `provider:cursor`
+- `provider:copilot`
+
+This smaller set already gives most of the value.
+
+## Examples
+
+### Example 1 — severe Claude keychain issue
+Issue: repeated Claude keychain prompts, user can’t keep the app running normally.
+
+Suggested labels:
+- `bug`
+- `priority:high`
+- `area:auth-keychain`
+- `provider:claude`
+
+### Example 2 — roadmap feature
+Issue: multiple account support.
+
+Suggested labels:
+- `enhancement`
+- `priority:high`
+- `area:accounts`
+- `needs-design`
+
+### Example 3 — needs better repro
+Issue: generic usage mismatch with unclear screenshots and no exact values.
+
+Suggested labels:
+- `bug`
+- `priority:medium`
+- `area:usage-accuracy`
+- `needs-repro`
+
+### Example 4 — accepted backlog UI request
+Issue: show burn rate / pacing indicators.
+
+Suggested labels:
+- `enhancement`
+- `priority:medium`
+- `area:usage-accuracy`
+- `accepted`
+
+## Suggested rollout
+
+1. **Create the new labels**
+2. **Backfill the top-priority open issues first**
+   - all `priority:high` bugs
+   - major roadmap items
+   - maintainer-triage issues
+3. **Apply labels to new issues at intake**
+4. **Backfill older backlog issues gradually**
+
+## Practical guidance
+
+- Prefer **fewer, clearer labels** over many vague labels.
+- Do not label everything `question`.
+- Do not use both `needs-repro` and `accepted` on the same issue unless there is a strong reason.
+- If an issue is provider-specific, add the provider label early.
+- If an issue is obviously real and intended to stay open, add `accepted` so it doesn’t look abandoned.
+
+## Current workflow-specific labels
+
+These already exist and should stay scoped to their current purpose:
+
+- `upstream-sync`
+- `needs-review`
+- `changes requested`
+
+They should not replace the general issue triage labels above.
diff --git a/docs/KEYCHAIN_FIX.md b/docs/KEYCHAIN_FIX.md
index 61deda6bcf..3c96f05efc 100644
--- a/docs/KEYCHAIN_FIX.md
+++ b/docs/KEYCHAIN_FIX.md
@@ -48,7 +48,7 @@ Load order for credentials:
 5. Claude CLI keychain service: `Claude Code-credentials` (promptable fallback).
 
 Prompt mitigation:
-- Non-interactive keychain probes use `KeychainNoUIQuery` (`LAContext.interactionNotAllowed` + `kSecUseAuthenticationUIFail`).
+- Non-interactive keychain probes use `KeychainNoUIQuery` with `LAContext.interactionNotAllowed`.
 - Pre-alert is shown only when preflight suggests interaction may be required.
 - Denials are cooled down in the background via `claudeOAuthKeychainDeniedUntil`
   (`ClaudeOAuthKeychainAccessGate`). User actions (menu open / manual refresh) clear this cooldown.
@@ -80,6 +80,9 @@ This is OS/keychain ACL behavior, not a `ThisDeviceOnly` migration issue.
 - Browser-imported Claude session cookies are cached in keychain service `com.steipete.codexbar.cache`.
 - Account key is `cookie.claude`.
 - Cache writes use `kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly`.
+- Users can clear browser-cookie cache entries from **Preferences → Debug → Caches** or with
+  `codexbar cache clear --cookies`. `--provider <id>` scopes cookie clearing to one provider and includes scoped
+  Codex managed-account cookie keys.
 
 ## What still uses `ThisDeviceOnly`
 
diff --git a/docs/RELEASING.md b/docs/RELEASING.md
index 0fdf6585f7..e4b08bd581 100644
--- a/docs/RELEASING.md
+++ b/docs/RELEASING.md
@@ -21,14 +21,15 @@ SwiftPM-only; package/sign/notarize manually (no Xcode project). Sparkle feed is
 - Sparkle key probe runs up front; appcast entry + signature verified automatically after generation.
 - Release notes are extracted directly from the current changelog section and passed to the GitHub release (no manual notes flag needed).
 - Sparkle appcast notes are generated as HTML from the same changelog section and embedded into the appcast entry.
-- Requires tools/env on PATH: `swiftformat`, `swiftlint`, `swift`, `sign_update`, `generate_appcast`, `gh`, `python3`, `zip`, `curl`, plus `APP_STORE_CONNECT_*` and `SPARKLE_PRIVATE_KEY_FILE`.
+- Requires tools/env on PATH: `swiftformat`, `swiftlint`, `swift`, `sign_update`, `generate_keys`, `generate_appcast`, `gh`, `python3`, `zip`, `curl`, plus `APP_STORE_CONNECT_*`. `SPARKLE_PRIVATE_KEY_FILE` is only needed when overriding the default Keychain Sparkle key.
 
 ## Prereqs
 - Xcode 26+ installed at `/Applications/Xcode.app` (for ictool/iconutil and SDKs).
 - Developer ID Application cert installed: `Developer ID Application: Peter Steinberger (Y5PE65HELJ)`.
 - ASC API creds in env: `APP_STORE_CONNECT_API_KEY_P8`, `APP_STORE_CONNECT_KEY_ID`, `APP_STORE_CONNECT_ISSUER_ID`.
-- Sparkle keys: public key already in Info.plist; private key path set via `SPARKLE_PRIVATE_KEY_FILE` when generating appcast.
+- Sparkle keys: public key expectation is in `.mac-release.env`; CodexBar still uses the older shared AGCY key, so the manifest includes the local Dropbox fallback path. `SPARKLE_PRIVATE_KEY_FILE` overrides it.
 - Ensure shell has release env vars loaded (usually `source ~/.profile`) before running `Scripts/release.sh`.
+- Shared release helper: `Scripts/mac-release` resolves `MAC_RELEASE_TOOL`, sibling `../agent-scripts`, or `~/Projects/agent-scripts`.
 
 ## Icon (glass .icon → .icns)
 ```
@@ -45,7 +46,7 @@ What it does:
 - Packages `CodexBar.app` with Info.plist and Icon.icns
 - Embeds Sparkle.framework, Updater, Autoupdate, XPCs
 - Codesigns **everything** with runtime + timestamp (deep) and adds rpath
-- Zips to `CodexBar-<version>.zip`
+- Zips to `CodexBar-macos-universal-<version>.zip`
 - Submits to notarytool, waits, staples, validates
 
 Gotchas fixed:
@@ -55,44 +56,41 @@ Gotchas fixed:
 - Manual sanity check before uploading: `find CodexBar.app -name '._*'` should return nothing; then `spctl --assess --type execute --verbose CodexBar.app` and `codesign --verify --deep --strict --verbose CodexBar.app` should both pass on the packaged bundle.
 
 ## Appcast (Sparkle)
-After notarization:
+After notarization, or let `Scripts/release.sh` do this:
 ```
-SPARKLE_PRIVATE_KEY_FILE=/path/to/ed25519-priv.key \
-./Scripts/make_appcast.sh CodexBar-0.1.0.zip \
+./Scripts/make_appcast.sh CodexBar-macos-universal-0.1.0.zip \
   https://raw.githubusercontent.com/steipete/CodexBar/main/appcast.xml
-Generates HTML release notes from `CHANGELOG.md` (via `Scripts/changelog-to-html.sh`) and embeds them into the appcast entry.
 ```
+Generates HTML release notes from `CHANGELOG.md` (via `Scripts/changelog-to-html.sh`) and embeds them into the appcast entry.
 Uploads not handled automatically—commit/publish appcast + zip to the feed location (GitHub Releases/raw URL).
 
 ## Tag & release
 ```
-git tag v<version>
-./Scripts/make_appcast.sh ...
-# upload zip + appcast to Releases
-# then create GitHub release (gh release create v<version> ...)
+./Scripts/release.sh
 ```
 
 ## Homebrew (Cask)
 CodexBar ships a Homebrew **Cask** in `../homebrew-tap`. When installed via Homebrew, CodexBar disables Sparkle and the app
 must be updated via `brew`.
 
-After publishing the GitHub release, update the tap cask + Linux CLI formula (see `docs/releasing-homebrew.md`).
+After publishing the GitHub release, `.github/workflows/release-cli.yml` builds the macOS, glibc Linux, and static musl Linux CLI tarballs for arm64 and x86_64, uploads them plus checksums, then dispatches the Homebrew tap update for both the CLI formula and app cask. Homebrew continues to use the glibc Linux assets. If the final dispatch is rate-limited, the tarballs and app zip may still be present; rerun or manually update the tap formula/cask from the published assets.
 
 ## Checklist (quick)
 - [ ] Read both this file and `~/Projects/agent-scripts/docs/RELEASING-MAC.md`; resolve any conflicts toward CodexBar’s specifics.
 - [ ] Update versions (scripts/Info.plist, CHANGELOG, About text) — changelog top section must be finalized; release script pulls notes from it automatically.
-- [ ] `swiftformat`, `swiftlint`, `swift test` (zero warnings/errors)
+- [ ] `swiftformat`, `swiftlint`, `make test` (zero warnings/errors)
 - [ ] `./Scripts/build_icon.sh` if icon changed
 - [ ] `./Scripts/sign-and-notarize.sh`
-- [ ] Generate Sparkle appcast with private key
-  - Sparkle ed25519 private key path: `/Users/steipete/Library/CloudStorage/Dropbox/Backup/Sparkle/sparkle-private-key-KEEP-SECURE.txt` (primary) and `/Users/steipete/Library/CloudStorage/Dropbox/Backup/Sparkle-VibeTunnel/sparkle-private-key-KEEP-SECURE.txt` (older backup)
+- [ ] Generate Sparkle appcast via `Scripts/release.sh` or `Scripts/make_appcast.sh`; use `SPARKLE_PRIVATE_KEY_FILE` only if overriding Keychain signing.
   - Upload the dSYM archive alongside the app zip on the GitHub release; the release script now automates this and will fail if it’s missing.
-  - After publishing the release, run `Scripts/check-release-assets.sh <tag>` to confirm both the app zip and dSYM zip are present on GitHub.
-  - Generate the appcast + HTML release notes: `./Scripts/make_appcast.sh CodexBar-<ver>.zip https://raw.githubusercontent.com/steipete/CodexBar/main/appcast.xml`
+  - After publishing the release and the Release CLI workflow finishes, run `Scripts/check-release-assets.sh <tag>` to confirm the app zip, dSYM zip, CLI tarballs, and CLI checksums are present on GitHub.
+  - Generate the appcast + HTML release notes: `./Scripts/make_appcast.sh CodexBar-macos-universal-<ver>.zip https://raw.githubusercontent.com/steipete/CodexBar/main/appcast.xml`
   - Beta channel: prefix the command with `SPARKLE_CHANNEL=beta` to tag the entry.
-  - Verify the enclosure signature + size: `SPARKLE_PRIVATE_KEY_FILE=... ./Scripts/verify_appcast.sh <ver>`
+  - Verify the enclosure signature + size: `./Scripts/verify_appcast.sh <ver>`
 - [ ] Upload zip + appcast to feed; publish tag + GitHub release so Sparkle URL is live (avoid 404)
-- [ ] Homebrew tap: update `../homebrew-tap/Casks/codexbar.rb` (url + sha256) and `../homebrew-tap/Formula/codexbar.rb` (Linux CLI tarball urls + sha256), then verify:
+- [ ] Homebrew tap: wait for the Release CLI workflow to update `../homebrew-tap/Casks/codexbar.rb` (app zip url + sha256) and `../homebrew-tap/Formula/codexbar.rb` (CLI tarball urls + sha256), then verify:
+  - `gh run watch <release-cli-run-id> --exit-status`
+  - `Scripts/check-release-assets.sh v<version>`
   - `brew uninstall --cask codexbar || true`
   - `brew untap steipete/tap || true; brew tap steipete/tap`
   - `brew install --cask steipete/tap/codexbar && open -a CodexBar`
@@ -100,7 +98,7 @@ After publishing the GitHub release, update the tap cask + Linux CLI formula (se
 - [ ] Changelog sanity: single top-level title, no duplicate version sections, versions strictly descending with no repeats
 - [ ] Release pages: title format `CodexBar <version>`, notes as Markdown list (no stray blank lines)
 - [ ] Changelog/release notes are user-facing: avoid internal-only bullets (build numbers, script bumps) and keep entries concise
-- [ ] Download uploaded `CodexBar-<ver>.zip`, unzip via `ditto`, run, and verify signature (`spctl -a -t exec -vv CodexBar.app` + `stapler validate`)
+- [ ] Download uploaded `CodexBar-macos-universal-<ver>.zip`, unzip via `ditto`, run, and verify signature (`spctl -a -t exec -vv CodexBar.app` + `stapler validate`)
 - [ ] Confirm `appcast.xml` points to the new zip/version and renders the HTML release notes (not escaped tags)
 - [ ] Verify on GitHub Releases: assets present (zip, appcast), release notes match changelog, version/tag correct
 - [ ] Open the appcast URL in browser to confirm the new entry is visible and enclosure URL is reachable
diff --git a/docs/abacus.md b/docs/abacus.md
new file mode 100644
index 0000000000..c4f9893aec
--- /dev/null
+++ b/docs/abacus.md
@@ -0,0 +1,67 @@
+---
+summary: "Abacus AI provider: browser cookie auth for ChatLLM/RouteLLM compute credit tracking."
+read_when:
+  - Adding or modifying the Abacus AI provider
+  - Debugging Abacus cookie imports or API responses
+  - Adjusting Abacus usage display or credit formatting
+---
+
+# Abacus AI Provider
+
+The Abacus AI provider tracks ChatLLM/RouteLLM compute credit usage via browser cookie authentication.
+
+## Features
+
+- **Monthly credit gauge**: Shows credits used vs. plan total with pace tick indicator.
+- **Reserve/deficit estimate**: Projected credit usage through the billing cycle.
+- **Reset timing**: Displays the next billing date from the Abacus billing API.
+- **Subscription tiers**: Detects Basic and Pro plans.
+- **Cookie auth**: Automatic browser cookie import (Safari, Chrome, Firefox) or manual cookie header.
+
+## Setup
+
+1. Open **Settings → Providers**
+2. Enable **Abacus AI**
+3. Log in to [apps.abacus.ai](https://apps.abacus.ai) in your browser
+4. Cookie import happens automatically on the next refresh
+
+### Manual cookie mode
+
+1. In **Settings → Providers → Abacus AI**, set Cookie source to **Manual**
+2. Open your browser DevTools on `apps.abacus.ai`, copy the `Cookie:` header from any API request
+3. Paste the header into the cookie field in CodexBar
+
+## How it works
+
+Two API endpoints are fetched concurrently using browser session cookies:
+
+- `GET https://apps.abacus.ai/api/_getOrganizationComputePoints` — returns `totalComputePoints` and `computePointsLeft` (values are in credit units, no conversion needed).
+- `POST https://apps.abacus.ai/api/_getBillingInfo` — returns `nextBillingDate` (ISO 8601) and `currentTier` (plan name).
+
+Cookie domains: `abacus.ai`, `apps.abacus.ai`. Session cookies are validated before use (anonymous/marketing-only cookie sets are skipped). Valid cookies are cached in Keychain and reused until the session expires.
+
+The billing cycle window is set to 30 days for pace calculation.
+
+## CLI
+
+```bash
+codexbar usage --provider abacusai --verbose
+```
+
+## Troubleshooting
+
+### "No Abacus AI session found"
+
+Log in to [apps.abacus.ai](https://apps.abacus.ai) in a supported browser (Safari, Chrome, Firefox), then refresh CodexBar.
+
+### "Abacus AI session expired"
+
+Re-login to Abacus AI. The cached cookie will be cleared automatically and a fresh one imported on the next refresh.
+
+### "Unauthorized"
+
+Your session cookies may be invalid. Log out and back in to Abacus AI, or paste a fresh `Cookie:` header in manual mode.
+
+### Credits show 0
+
+Verify that your Abacus AI account has an active subscription with compute credits allocated.
diff --git a/docs/alibaba-coding-plan.md b/docs/alibaba-coding-plan.md
new file mode 100644
index 0000000000..834e62e385
--- /dev/null
+++ b/docs/alibaba-coding-plan.md
@@ -0,0 +1,75 @@
+---
+summary: "Alibaba Coding Plan provider data sources: browser-session baseline, secondary API mode, and honest quota fallback behavior."
+read_when:
+  - Debugging Alibaba Coding Plan API key handling or quota parsing
+  - Updating Alibaba Coding Plan endpoints or region behavior
+  - Adjusting Alibaba Coding Plan provider UI/menu behavior
+---
+
+# Alibaba Coding Plan provider
+
+Alibaba Coding Plan supports both browser-session and API-key paths, but the supported baseline is browser-session fetching from the Model Studio/Bailian console. API mode remains secondary and may still be limited by account/region behavior.
+
+## Cookie sources (web mode)
+1) Automatic browser import (Model Studio/Bailian cookies).
+2) Manual cookie header from Settings.
+3) Environment variable `ALIBABA_CODING_PLAN_COOKIE`.
+
+When the RPC endpoint returns `ConsoleNeedLogin`, CodexBar treats that as a console-session requirement. In API mode it is surfaced as an explicit API-path limitation; in `auto` mode fallback remains observable through the fetch-attempt chain.
+
+## Token sources (fallback order)
+1) Config token (`~/.codexbar/config.json` -> `providers[].apiKey` for provider `alibaba`).
+2) Environment variables, checked in order:
+   - `ALIBABA_CODING_PLAN_API_KEY`
+   - `ALIBABA_QWEN_API_KEY`
+   - `DASHSCOPE_API_KEY`
+
+## Region + endpoint behavior
+- International host: `https://modelstudio.console.alibabacloud.com`
+- China mainland host: `https://bailian.console.aliyun.com`
+- Quota request path:
+  - `POST /data/api.json?action=zeldaEasy.broadscope-bailian.codingPlan.queryCodingPlanInstanceInfoV2&product=broadscope-bailian&api=queryCodingPlanInstanceInfoV2`
+- Region is selected in Preferences -> Providers -> Alibaba Coding Plan -> Gateway region.
+- Auto fallback behavior:
+  - If International fails with credential/host-style API errors, CodexBar retries China mainland once.
+
+### CN API-key limitation (known)
+- In some China mainland accounts/environments, the current Alibaba `/data/api.json` coding-plan endpoint can still return console-login-required responses (`ConsoleNeedLogin`) even when an API key is configured.
+- In that case, API-key mode may not be functionally available for that account/endpoint, and web session mode is required.
+- CodexBar now surfaces this as an API error in API mode (instead of a cookie-login-required message) so the limitation is explicit.
+
+## Overrides
+- Override host base: `ALIBABA_CODING_PLAN_HOST`
+  - Example: `ALIBABA_CODING_PLAN_HOST=modelstudio.console.alibabacloud.com`
+- Override full quota URL: `ALIBABA_CODING_PLAN_QUOTA_URL`
+  - Example: `ALIBABA_CODING_PLAN_QUOTA_URL=https://modelstudio.console.alibabacloud.com/data/api.json?action=...`
+- Security policy: endpoint overrides are only accepted when they use `https://`, omit userinfo, and do not contain encoded host delimiters. Custom HTTPS proxy/test domains continue to work for compatibility, but `http://` endpoints are rejected so cookies and API credentials are not sent in cleartext.
+- Strict provider-host mode: set `ALIBABA_CODING_PLAN_REQUIRE_PROVIDER_ENDPOINT_OVERRIDES=true` to additionally reject custom proxy/test domains and only accept the known Alibaba Coding Plan console and RPC hosts.
+
+## Request headers
+- `Authorization: Bearer <api_key>`
+- `x-api-key: <api_key>`
+- `X-DashScope-API-Key: <api_key>`
+- `Content-Type: application/json`
+- `Accept: application/json`
+
+## Parsing + mapping
+- Plan name (best effort):
+  - `codingPlanInstanceInfos[].planName` / `instanceName` / `packageName`
+- Quota windows (from `codingPlanQuotaInfo`):
+  - `per5HourUsedQuota` + `per5HourTotalQuota` + `per5HourQuotaNextRefreshTime` -> primary (5-hour)
+  - `perWeekUsedQuota` + `perWeekTotalQuota` + `perWeekQuotaNextRefreshTime` -> secondary (weekly)
+  - `perBillMonthUsedQuota` + `perBillMonthTotalQuota` + `perBillMonthQuotaNextRefreshTime` -> tertiary (monthly)
+- Each window maps to `usedPercent = used / total * 100` (bounded to valid range).
+- If the payload proves the plan is active but does not expose defensible quota counters, CodexBar preserves the visible plan state without manufacturing a normal quantitative quota window.
+- If neither real counters nor a defensible active-plan fallback signal exist, parsing fails explicitly instead of degrading to fake `0%` usage.
+
+## Dashboard links
+- International console: `https://modelstudio.console.alibabacloud.com/ap-southeast-1/?tab=globalset#/efm/coding_plan`
+- China mainland console: `https://bailian.console.aliyun.com/cn-beijing/?tab=model#/efm/coding_plan`
+
+## Key files
+- `Sources/CodexBarCore/Providers/Alibaba/AlibabaCodingPlanProviderDescriptor.swift`
+- `Sources/CodexBarCore/Providers/Alibaba/AlibabaCodingPlanUsageFetcher.swift`
+- `Sources/CodexBarCore/Providers/Alibaba/AlibabaCodingPlanUsageSnapshot.swift`
+- `Sources/CodexBar/Providers/Alibaba/AlibabaCodingPlanProviderImplementation.swift`
diff --git a/docs/alibaba-token-plan.md b/docs/alibaba-token-plan.md
new file mode 100644
index 0000000000..1d8884605e
--- /dev/null
+++ b/docs/alibaba-token-plan.md
@@ -0,0 +1,61 @@
+---
+summary: "Alibaba Token Plan provider notes: Bailian cookie auth, subscription summary endpoint, and setup."
+read_when:
+  - Adding or modifying the Alibaba Token Plan provider
+  - Debugging Alibaba Token Plan cookie import or subscription summary fetching
+  - Explaining Alibaba Token Plan setup and limitations to users
+---
+
+# Alibaba Token Plan Provider
+
+The Alibaba Token Plan provider tracks Bailian token-plan credits from the Alibaba Cloud console.
+
+## Features
+
+- **Token-plan usage display**: Shows used, total, and remaining token-plan credits when Bailian returns quota totals.
+- **Cookie-based auth**: Uses browser cookies or a pasted `Cookie:` header.
+- **Expiry awareness**: Shows the nearest token-plan expiration date as the reset time when the subscription summary includes it.
+
+## Setup
+
+1. Open **Settings -> Providers**
+2. Enable **Alibaba Token Plan**
+3. Leave **Cookie source** on **Auto** (recommended)
+
+### Manual cookie import (optional)
+
+1. Open `https://bailian.console.aliyun.com/cn-beijing?tab=plan#/efm/subscription/token-plan`
+2. Copy a `Cookie:` header from your browser's Network tab
+3. Paste it into **Alibaba Token Plan -> Cookie source -> Manual**
+
+## How it works
+
+- Fetches `POST https://bailian.console.aliyun.com/data/api.json?action=GetSubscriptionSummary&product=BssOpenAPI-V3&_tag=`
+- Sends form-encoded fields for `product=BssOpenAPI-V3`, `action=GetSubscriptionSummary`, `region=cn-beijing`, and `params={"ProductCode":"sfm_tokenplanteams_dp_cn"}`
+- Uses Alibaba/Bailian login cookies, with `sec_token` added when it can be resolved from the dashboard page
+- Parses `TotalValue`, `TotalSurplusValue`, `TotalCount`, and `NearestExpireDate` from the subscription summary response
+- Supports `ALIBABA_TOKEN_PLAN_HOST` and `ALIBABA_TOKEN_PLAN_QUOTA_URL` for testing endpoint overrides
+
+## Limitations
+
+- Alibaba Token Plan currently supports the Bailian web-cookie path only
+- API-key auth, token cost summaries, and automatic status polling are not supported
+- The default endpoint is the China mainland Bailian token-plan subscription summary
+
+## Troubleshooting
+
+### "No Alibaba Token Plan session cookies found in browsers"
+
+Log in at `https://bailian.console.aliyun.com/cn-beijing?tab=plan#/efm/subscription/token-plan` in Chrome, then refresh CodexBar.
+
+### "Alibaba Token Plan cookie header is invalid"
+
+The pasted header is empty or not a valid Cookie header. Re-copy the request from the Token Plan page after logging in again.
+
+### "Alibaba Token Plan login required"
+
+Your Bailian session is stale. Sign out and back in on the Bailian console, then refresh CodexBar.
+
+### Empty subscription summary
+
+If Bailian returns `TotalCount: 0`, CodexBar keeps the provider visible but does not show a quota window because the account has no active token-plan subscription summary to graph.
diff --git a/docs/amp.md b/docs/amp.md
index 9856abf1d7..dacdf04c69 100644
--- a/docs/amp.md
+++ b/docs/amp.md
@@ -1,5 +1,5 @@
 ---
-summary: "Amp provider notes: settings scrape, cookie auth, and free-tier usage."
+summary: "Amp provider notes: CLI usage, web fallback, cookie auth, and credits."
 read_when:
   - Adding or modifying the Amp provider
   - Debugging Amp cookie import or settings parsing
@@ -8,19 +8,28 @@ read_when:
 
 # Amp Provider
 
-The Amp provider tracks your Amp Free usage by scraping the Amp settings page with browser cookies.
+The Amp provider tracks Amp Free usage plus individual and workspace credits. It prefers the local Amp CLI, then an Amp
+access token, and finally browser cookies.
 
 ## Features
 
 - **Amp Free meter**: Shows how much daily free usage remains.
 - **Time-to-full reset**: “Resets in …” indicates when free usage replenishes to full.
-- **Browser cookie auth**: No API keys needed.
+- **Individual credits**: Shows the remaining paid credit balance when Amp reports one.
+- **Workspace credits**: Shows each workspace's remaining paid credit balance separately.
+- **CLI-first fetch**: Uses `amp usage` when the Amp CLI is installed and signed in.
+- **Access token support**: Uses `AMP_API_KEY` or the access token saved in CodexBar settings.
+- **Browser cookie fallback**: Reads the legacy settings-page payload when the CLI and access token are unavailable.
 
 ## Setup
 
 1. Open **Settings → Providers**
 2. Enable **Amp**
-3. Leave **Cookie source** on **Auto** (recommended)
+3. Install and sign in to the Amp CLI, add an Amp access token, or leave **Cookie source** on **Auto** for web fallback
+
+### Access token (optional)
+
+Create an access token in Amp settings, then paste it into **Amp → Access token** or set `AMP_API_KEY`.
 
 ### Manual cookie import (optional)
 
@@ -30,10 +39,16 @@ The Amp provider tracks your Amp Free usage by scraping the Amp settings page wi
 
 ## How it works
 
-- Fetches `https://ampcode.com/settings`
-- Parses the embedded `freeTierUsage` payload
+- Runs `amp usage` first in automatic mode
+- Calls `POST https://ampcode.com/api/internal?userDisplayBalanceInfo` with an Amp access token
+- Falls back to the settings page with browser cookies
+- Parses the same usage display format returned to the CLI
 - Computes time-to-full from the hourly replenishment rate
 
+### “Amp access token is invalid or expired”
+
+Create a new access token in Amp settings, update `AMP_API_KEY` or CodexBar settings, then refresh.
+
 ## Troubleshooting
 
 ### “No Amp session cookie found”
diff --git a/docs/antigravity.md b/docs/antigravity.md
index ab99af30f3..827cb10ed4 100644
--- a/docs/antigravity.md
+++ b/docs/antigravity.md
@@ -1,43 +1,168 @@
 ---
-summary: "Antigravity provider notes: local LSP probing, port discovery, quota parsing, and UI mapping."
+summary: "Antigravity provider notes: OAuth usage, multi-account switching, local LSP probing, and quota parsing."
 read_when:
   - Adding or modifying the Antigravity provider
   - Debugging Antigravity port detection or quota parsing
   - Adjusting Antigravity menu labels or model mapping
+  - Working with Antigravity OAuth or account switching
 ---
 
 # Antigravity provider
 
-Antigravity is a local-only provider. We talk directly to the Antigravity language server running on the same machine.
+Antigravity supports four usage data sources:
+
+1. The Antigravity 2.0 app's local `language_server` (preferred when the app is open).
+2. The `agy` CLI's embedded HTTPS localhost server (preferred over the IDE because it exposes richer quota data).
+3. The Antigravity IDE extension `language_server` (used after `agy` CLI because current IDE local payloads only expose session/model quota data).
+4. Google OAuth-backed remote usage (explicit OAuth mode, and the account-scoped fallback used for multi-account switching). The OAuth path can store multiple Google accounts through the shared token-account switcher.
+
+The local and CLI paths both prefer Antigravity's internal `RetrieveUserQuotaSummary` quota payload and may fall back to
+`GetUserStatus`, then `GetCommandModelConfigs`; CodexBar never scrapes the desktop UI or the `agy` TUI.
+
+As of Antigravity 2.x, the Antigravity app and `agy` CLI payloads can be richer than Google OAuth and IDE payloads.
+`RetrieveUserQuotaSummary` exposes the same two groups shown by Antigravity's Model Quota UI:
+
+- `Gemini Models`: weekly limit and five-hour limit.
+- `Claude and GPT models`: weekly limit and five-hour limit.
+
+Older local payloads may only include raw Claude, GPT-OSS, Gemini tiers, account plan, and session reset timestamps.
+Current Antigravity IDE local endpoints return `GetUserStatus`, `GetAvailableModels`, and `GetCascadeModelConfigData`
+with five-hour/session reset data, but not the app/CLI `RetrieveUserQuotaSummary` weekly/session grouping. OAuth
+payloads can be less complete and may only prove model availability. Treat `auto` as the authoritative user-facing mode:
+it accepts the first account-matching source in Antigravity app -> `agy` CLI -> Antigravity IDE order, and adds OAuth
+when CodexBar has a selected/injected Google account or an existing shared credentials file. An all-100%
+`fetchAvailableModels` payload is only accepted after `retrieveUserQuota` echoes bucket fractions; this can be an
+availability-style fallback rather than the full Antigravity quota summary.
+When OAuth identifies the account but quota endpoints deny access, CodexBar shows `Limits not available` instead of an
+empty quota card.
+
+## OAuth account switching
+
+- Login still uses Antigravity's Google OAuth client, discovered from `Antigravity.app` or overridden with `ANTIGRAVITY_OAUTH_CLIENT_ID` and `ANTIGRAVITY_OAUTH_CLIENT_SECRET`.
+- A successful login writes the latest shared credentials to `~/.codexbar/antigravity/oauth_creds.json` and upserts a token-account entry for the Google account.
+- Each token-account entry stores serialized `AntigravityOAuthCredentials` and is injected into remote fetches through `ANTIGRAVITY_OAUTH_CREDENTIALS_JSON`.
+- When a token account is selected, the OAuth fetcher uses that account before falling back to the shared credentials file.
+  In `auto` mode the ambient Antigravity app, `agy` CLI, and IDE probes still run first, but a snapshot whose account
+  does not match the selected account is rejected so the pipeline falls through to the account-scoped OAuth fetch (see
+  `AntigravitySelectedAccountGuard`). If no account is selected/injected, `auto` includes OAuth only when the legacy
+  shared credentials file already exists. Explicit `cli`/`oauth` source modes stay authoritative and are not re-checked.
+- Removing the last saved token account that matches `~/.codexbar/antigravity/oauth_creds.json` deletes that shared file,
+  so a removed CodexBar account does not silently continue refreshing through the legacy shared cache.
+- The menu action is labeled `Add Account...`; switching between saved accounts scopes Google OAuth fetches.
+
+## Remote OAuth data sources
+
+- `POST https://cloudcode-pa.googleapis.com/v1internal:loadCodeAssist`
+- `POST https://cloudcode-pa.googleapis.com/v1internal:onboardUser`
+- `POST https://cloudcode-pa.googleapis.com/v1internal:fetchAvailableModels`
+- `POST https://cloudcode-pa.googleapis.com/v1internal:retrieveUserQuota`
+- `POST https://cloudcode-pa.googleapis.com/v1internal:retrieveUserQuotaSummary` (available, but current observed OAuth
+  responses are model-bucket shaped rather than Antigravity 2.0's two quota groups)
 
 ## Data sources + fallback order
 
-1) **Process detection**
+### 1) Antigravity app local probe
+
+When the Antigravity 2.0 app is running:
+
+1. **Process detection**
    - Command: `ps -ax -o pid=,command=`.
-   - Match process name: `language_server_macos` plus Antigravity markers:
-     - `--app_data_dir antigravity` OR path contains `/antigravity/`.
+   - The app local strategy scopes detection to the **Antigravity app** language server only
+     (`AntigravityStatusProbe(processScope: .appOnly)`). It deliberately does **not**
+     attach to an IDE or `agy` CLI process: a lower-information IDE payload should not mask
+     `agy`'s richer quota summary, and a stale or still-initializing `agy` can accept the
+     connection before it is ready. `agy` is owned exclusively by the CLI HTTPS source below,
+     which waits for real API readiness. The probe still classifies all kinds
+     (`processInfo(scope: .ideAndCLI)` is used by `isRunning()` for status reporting):
+     - the **Antigravity app** language server: process names such as `language_server`, `language_server_macos`,
+       `language_server_macos_arm`, or `language-server` plus
+       Antigravity markers (`--app_data_dir antigravity`, an Antigravity app bundle path,
+       or a path containing `/antigravity/`); or
+     - the **IDE** language server: the Antigravity IDE extension language server, usually under
+       `Antigravity IDE.app/.../extensions/antigravity/bin/` with `--app_data_dir antigravity-ide`; or
+     - the **CLI**: an `antigravity-cli` / `antigravity_cli` path segment, or the
+       `agy` binary (path-anchored so unrelated arguments/binaries do not match).
+   - CodexBar collects all valid local app language-server candidates and probes each reachable one. If multiple
+     app processes are open, it prefers the richer quota-summary snapshot over the legacy `GetUserStatus`
+     two-pool fallback.
    - Extract CLI flags:
-     - `--csrf_token <token>` (required).
-     - `--extension_server_port <port>` (HTTP fallback).
+     - `--csrf_token <token>`. Requirement depends on the match kind:
+       - **App/IDE** matches still require it - a tokenless desktop language-server match is
+         skipped so a later valid server can be found, otherwise `missingCSRFToken`
+         is reported (unchanged behavior).
+       - **CLI** matches accept an empty token, because the CLI's language server
+         exposes no `--csrf_token` flag and requires none.
+     - `--extension_server_port <port>` (HTTP fallback; app/IDE only).
+     - `--extension_server_csrf_token <token>` (preferred HTTP fallback token when present).
 
-2) **Port discovery**
-   - Command: `lsof -nP -iTCP -sTCP:LISTEN -p <pid>`.
+2. **Port discovery**
+   - Command: `lsof -nP -iTCP -sTCP:LISTEN -a -p <pid>`.
    - All listening ports are probed.
 
-3) **Connect port probe (HTTPS)**
+3. **Connect port probe (HTTPS)**
    - `POST https://127.0.0.1:<port>/exa.language_server_pb.LanguageServerService/GetUnleashData`
    - Headers:
      - `X-Codeium-Csrf-Token: <token>`
      - `Connect-Protocol-Version: 1`
    - First 200 OK response selects the connect port.
 
-4) **Quota fetch**
+4. **Quota fetch**
    - Primary:
+     - `POST https://127.0.0.1:<connectPort>/exa.language_server_pb.LanguageServerService/RetrieveUserQuotaSummary`
+   - Fallback 1:
      - `POST https://127.0.0.1:<connectPort>/exa.language_server_pb.LanguageServerService/GetUserStatus`
-   - Fallback:
+   - Fallback 2:
      - `POST https://127.0.0.1:<connectPort>/exa.language_server_pb.LanguageServerService/GetCommandModelConfigs`
    - If HTTPS fails, retry over HTTP on `extension_server_port`.
 
+### 2) `agy` CLI HTTPS source
+
+When source mode is `auto` or `cli` and the desktop local probe fails, CodexBar resolves `agy` via:
+
+- `ANTIGRAVITY_CLI_PATH`
+- `PATH` / login-shell path lookup
+- Well-known paths:
+  - `~/.local/bin/agy`
+  - `/opt/homebrew/bin/agy`
+  - `/usr/local/bin/agy`
+
+CodexBar launches `agy` in a PTY because the CLI exposes its quota server only while the interactive process is alive.
+The implementation still does **not** scrape terminal output; it only keeps the process alive, drains discarded PTY
+rendering, discovers listening ports with `lsof`, and probes the local HTTPS server:
+
+- First: `POST https://127.0.0.1:<port>/exa.language_server_pb.LanguageServerService/RetrieveUserQuotaSummary`
+- Fallback 1: `POST https://127.0.0.1:<port>/exa.language_server_pb.LanguageServerService/GetUserStatus`
+- Fallback 2: `POST https://127.0.0.1:<port>/exa.language_server_pb.LanguageServerService/GetCommandModelConfigs`
+
+The fallback can return quota without the account email or plan fields from `GetUserStatus`.
+
+Differences from the desktop local probe:
+
+- The CLI HTTPS endpoint does **not** require `X-Codeium-Csrf-Token`.
+- Readiness is endpoint-based: CodexBar retries until one of the quota endpoints parses, because fresh `agy`
+  processes can bind a port before the quota service is initialized.
+- App runtime uses a bounded warm session: `agy` is kept alive briefly after a refresh, then stopped on idle. CLI runtime
+  tears it down immediately after the one-shot fetch.
+- Repeated endpoint failures force a relaunch instead of reusing a wedged process forever.
+- CodexBar records the launched pid + executable identity and conservatively reaps only its own matching stale `agy`
+  process on the next launch. It never blind-kills a user-launched `agy`.
+
+### 3) Antigravity IDE local probe
+
+When the Antigravity 2.0 app and `agy` CLI are unavailable, CodexBar probes Antigravity IDE language servers with
+`AntigravityStatusProbe(processScope: .ideOnly)`. Current observed IDE payloads return model-level/session quota data
+through `GetUserStatus`, `GetAvailableModels`, and `GetCascadeModelConfigData`; `RetrieveUserQuotaSummary` returns 404
+from the IDE local server. This means the IDE fallback can show session bars, but should not be expected to provide the
+weekly limit shown by Antigravity 2.0.
+
+### 4) OAuth remote fallback
+
+When source mode is `auto`, OAuth is used after app, `agy` CLI, and IDE paths fail if CodexBar has a selected/injected
+Google account or an existing shared credentials file. The app, `agy` CLI, and IDE probes still run first, but in
+`auto` mode their snapshots are accepted only when the reported account matches the selected account; otherwise the
+pipeline falls through to this account-scoped OAuth fetch. When source mode is `oauth`, only OAuth is used and the
+shared OAuth file can still be used as a fallback credential source.
+
 ## Request body (summary)
 - Minimal metadata payload:
   - `ideName: antigravity`
@@ -46,14 +171,27 @@ Antigravity is a local-only provider. We talk directly to the Antigravity langua
   - `ideVersion: unknown`
 
 ## Parsing and model mapping
-- Source fields:
+- Preferred source fields:
+  - `response.groups[].displayName`
+  - `response.groups[].buckets[].bucketId`
+  - `response.groups[].buckets[].displayName`
+  - `response.groups[].buckets[].remaining.remainingFraction`
+  - `response.groups[].buckets[].description`
+- Legacy source fields:
   - `userStatus.cascadeModelConfigData.clientModelConfigs[].quotaInfo.remainingFraction`
   - `userStatus.cascadeModelConfigData.clientModelConfigs[].quotaInfo.resetTime`
-- Mapping priority:
-  1) Claude (label contains `claude` but not `thinking`)
-  2) Gemini Pro Low (label contains `pro` + `low`)
-  3) Gemini Flash (label contains `gemini` + `flash`)
-  4) Fallback: lowest remaining percent
+- Preferred quota summary UI:
+  - Render `Gemini Session`, `Gemini Weekly`, `Claude + GPT Session`, and `Claude + GPT Weekly` as named windows.
+  - Keep Antigravity's bucket description as reset prose; infer `windowMinutes` from the bucket ID/display name.
+  - Use the most constrained known bucket as the compact/menu-bar metric.
+- Legacy user-facing quota groups:
+  - `Gemini` groups Gemini Pro and Gemini Flash text models.
+  - `Claude + GPT` groups Claude text models and GPT/GPT-OSS text models.
+- Representative selection:
+  - Hidden model rows such as Lite, autocomplete, and image variants do not drive summary bars.
+  - For each group, CodexBar uses the lowest remaining known quota row and preserves that row's reset metadata.
+  - Rows with reset metadata but no remaining fraction stay visible as unavailable reset context only when their group
+    has no known usage row.
 - `resetTime` parsing:
   - ISO-8601 preferred; numeric epoch seconds as fallback.
 - Identity:
@@ -62,14 +200,22 @@ Antigravity is a local-only provider. We talk directly to the Antigravity langua
 ## UI mapping
 - Provider metadata:
   - Display: `Antigravity`
-  - Labels: `Claude` (primary), `Gemini Pro` (secondary), `Gemini Flash` (tertiary)
+  - Labels: `Gemini` (primary), `Claude + GPT` (secondary)
 - Status badge: Google Workspace incidents for the Gemini product.
+- Antigravity exposes many model rows, but current local payloads show them collapsing into two real usage pools:
+  Gemini and Claude/GPT. Detailed usage should not list every raw Gemini tier unless a future source exposes a genuinely
+  distinct unknown or consumed quota window.
+- Some Antigravity local/CLI model config entries include reset metadata but omit `remainingFraction`. Those windows stay
+  in `extraRateWindows` for reset context and are marked with `usageKnown: false`; clients should not render their
+  `usedPercent` as a real exhausted quota.
 
 ## Constraints
 - Internal protocol; fields may change.
-- Requires `lsof` for port detection.
-- Local HTTPS uses a self-signed cert; the probe allows insecure TLS.
+- Requires `lsof` for local/CLI port detection.
+- Local HTTPS uses a self-signed cert; the probe allows insecure TLS only for loopback hosts.
 
 ## Key files
+- `Sources/CodexBarCore/Providers/Antigravity/AntigravityCLISession.swift`
+- `Sources/CodexBarCore/Providers/Antigravity/AntigravityProviderDescriptor.swift`
 - `Sources/CodexBarCore/Providers/Antigravity/AntigravityStatusProbe.swift`
 - `Sources/CodexBar/Providers/Antigravity/AntigravityProviderImplementation.swift`
diff --git a/docs/architecture.md b/docs/architecture.md
index 0162b3e395..f3dc337bde 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -12,8 +12,6 @@ read_when:
 - `Sources/CodexBar`: state + UI (UsageStore, SettingsStore, StatusItemController, menus, icon rendering).
 - `Sources/CodexBarWidget`: WidgetKit extension wired to the shared snapshot.
 - `Sources/CodexBarCLI`: bundled CLI for `codexbar` usage/status output.
-- `Sources/CodexBarMacros`: SwiftSyntax macros for provider registration.
-- `Sources/CodexBarMacroSupport`: shared macro support used by app/core/CLI targets.
 - `Sources/CodexBarClaudeWatchdog`: helper process for stable Claude CLI PTY sessions.
 - `Sources/CodexBarClaudeWebProbe`: CLI helper to diagnose Claude web fetches.
 
diff --git a/docs/augment.md b/docs/augment.md
index b7f5fcdc94..0790ebdd6e 100644
--- a/docs/augment.md
+++ b/docs/augment.md
@@ -79,9 +79,9 @@ When the CLI is unavailable or not authenticated, CodexBar falls back to browser
 
 The provider includes an automatic session keepalive system:
 
-- **Check Interval**: Every 5 minutes
+- **Check Interval**: Every 1 minute
 - **Refresh Buffer**: Refreshes 5 minutes before cookie expiration
-- **Rate Limiting**: Minimum 2 minutes between refresh attempts
+- **Rate Limiting**: Minimum 1 minute between refresh attempts
 - **Session Cookies**: Refreshed every 30 minutes (no expiration date)
 
 This ensures your session stays active without manual intervention.
@@ -170,7 +170,7 @@ This prevents cookies from other subdomains being sent to the API.
 
 ### Session Refresh Mechanism
 
-1. Keepalive checks cookie expiration every 5 minutes
+1. Keepalive checks cookie expiration every 1 minute
 2. If expiration is within 5 minutes, triggers refresh
 3. Pings `/api/auth/session` to trigger cookie update
 4. Waits 1 second for browser to update cookies
diff --git a/docs/bedrock.md b/docs/bedrock.md
new file mode 100644
index 0000000000..aed954d40d
--- /dev/null
+++ b/docs/bedrock.md
@@ -0,0 +1,121 @@
+---
+summary: "AWS Bedrock provider: Cost Explorer spend, CloudWatch Claude activity, credentials, and budgets."
+read_when:
+  - Setting up AWS Bedrock usage tracking
+  - Debugging Bedrock Cost Explorer or CloudWatch fetches
+  - Updating Bedrock credentials, region, budget, or activity handling
+---
+
+# AWS Bedrock provider
+
+CodexBar reads AWS Cost Explorer for Bedrock spend and can compare the current month against an optional budget. When
+permitted, it also reads CloudWatch for rolling 14-day Claude token and request totals in the configured region.
+
+## Authentication
+
+CodexBar supports two authentication modes, selected in Preferences → Providers → AWS Bedrock → Authentication.
+
+### Access keys (default)
+
+Provide static AWS credentials through Settings or the environment inherited by CodexBar/the CLI:
+
+```bash
+export AWS_ACCESS_KEY_ID="..."
+export AWS_SECRET_ACCESS_KEY="..."
+export AWS_REGION="us-east-1"
+```
+
+Optional:
+
+```bash
+export AWS_SESSION_TOKEN="..."
+export CODEXBAR_BEDROCK_BUDGET="250"
+```
+
+### AWS profile
+
+Resolve credentials from a named profile in `~/.aws/config` / `~/.aws/credentials` instead of pasting keys. Set the
+profile name in Settings (or via `AWS_PROFILE`). CodexBar shells out to the AWS CLI
+(`aws configure export-credentials --profile <name>`), so this works with **SSO**, **assume-role**,
+`credential_process`, and MFA-cached profiles — not just static credentials.
+
+Requirements:
+
+- AWS CLI v2 on your `PATH` (CodexBar also checks `/opt/homebrew/bin/aws`, `/usr/local/bin/aws`, and `~/.local/bin/aws`).
+  Override the location with `AWS_CLI_PATH` if it lives elsewhere.
+- For SSO profiles, an active session (`aws sso login --profile <name>`). Credentials are resolved fresh on each
+  refresh; the AWS CLI caches the SSO token, so this does not re-prompt unless the session has expired.
+
+The profile's region is read automatically (`aws configure get region`); leave the Region field blank to use it, or set
+`AWS_REGION` / the Region field to override.
+
+Relevant environment variables:
+
+```bash
+export CODEXBAR_BEDROCK_AUTH_MODE="profile"   # set automatically by Settings; "keys" or "profile"
+export AWS_PROFILE="work"
+export AWS_CLI_PATH="/opt/homebrew/bin/aws"   # optional override
+```
+
+The AWS identity (from either mode) must have permission to call Cost Explorer APIs, including `ce:GetCostAndUsage`.
+Grant `cloudwatch:GetMetricData` to add the optional Claude activity totals. Without that permission, cost and budget
+tracking continue unchanged.
+
+## Data source
+
+- Service: AWS Cost Explorer.
+- Region: `AWS_REGION` or `AWS_DEFAULT_REGION`, defaulting to `us-east-1`.
+- Usage: current-month Bedrock spend and historical daily cost buckets.
+- Claude activity: rolling 14-day input tokens, output tokens, and requests from the configured region's `AWS/Bedrock`
+  CloudWatch metrics. Other model families are excluded.
+- Budget: `CODEXBAR_BEDROCK_BUDGET`, when set to a positive dollar amount.
+- Test override: `CODEXBAR_BEDROCK_API_URL` replaces the Cost Explorer endpoint; use HTTPS or loopback HTTP.
+- Test override: `CODEXBAR_BEDROCK_CLOUDWATCH_API_URL` replaces the CloudWatch endpoint; use HTTPS or loopback HTTP.
+
+## Display
+
+- Shows month-to-date Bedrock spend.
+- Shows budget progress when a budget is configured.
+- Shows rolling 14-day Claude tokens and requests when CloudWatch access is available.
+- Reuses the shared inline dashboard for daily cost history when enough buckets are available.
+
+## CLI
+
+```bash
+codexbar --provider bedrock --source api
+codexbar --provider bedrock --format json --pretty
+```
+
+## Troubleshooting
+
+### "No AWS Bedrock cost data available"
+
+- Confirm the credentials are visible to CodexBar.
+- Confirm the AWS account has Cost Explorer enabled.
+- Confirm the IAM principal can call `ce:GetCostAndUsage`.
+- To include Claude token/request totals, confirm the principal can call `cloudwatch:GetMetricData` in the configured
+  region.
+- If using temporary credentials, include `AWS_SESSION_TOKEN`.
+- In profile mode, confirm the AWS CLI is installed (or set `AWS_CLI_PATH`) and that the profile name is correct.
+
+### "AWS profile session expired"
+
+The profile's SSO/temporary session has expired. Run `aws sso login --profile <name>` (or refresh the underlying
+credentials) and retry.
+
+### "AWS CLI not found"
+
+Profile mode requires AWS CLI v2. Install it (e.g. `brew install awscli`) or point CodexBar at the binary with
+`AWS_CLI_PATH`.
+
+### Wrong region
+
+Set `AWS_REGION` or `AWS_DEFAULT_REGION`. Bedrock usage is regional, but Cost Explorer itself is account-level; CodexBar still needs a signing region for the request.
+
+## Key files
+
+- `Sources/CodexBarCore/Providers/Bedrock/BedrockProviderDescriptor.swift`
+- `Sources/CodexBarCore/Providers/Bedrock/BedrockSettingsReader.swift`
+- `Sources/CodexBarCore/Providers/Bedrock/BedrockProfileCredentialProvider.swift`
+- `Sources/CodexBarCore/Providers/Bedrock/BedrockUsageStats.swift`
+- `Sources/CodexBarCore/Providers/Bedrock/BedrockAWSSigner.swift`
diff --git a/docs/chutes.md b/docs/chutes.md
new file mode 100644
index 0000000000..162b611078
--- /dev/null
+++ b/docs/chutes.md
@@ -0,0 +1,52 @@
+---
+summary: "Chutes provider: API key setup, subscription usage, and quota windows."
+read_when:
+  - Configuring Chutes usage
+  - Debugging Chutes subscription or quota requests
+---
+
+# Chutes Provider
+
+CodexBar reads subscription and quota usage from Chutes' management API with a manually configured API key.
+
+## Authentication
+
+Create a Chutes API key using the [official authentication guide](https://chutes.ai/docs/getting-started/authentication), then add it in CodexBar Settings → Providers → Chutes.
+
+You can also set the environment variable:
+
+```bash
+export CHUTES_API_KEY="cpk_..."
+```
+
+Or configure it through the CLI:
+
+```bash
+printf '%s' "$CHUTES_API_KEY" | codexbar config set-api-key --provider chutes --stdin
+```
+
+## Data Source
+
+CodexBar requests:
+
+- `GET https://api.chutes.ai/users/me/subscription_usage`
+- `GET https://api.chutes.ai/users/me/quotas` when subscription data does not contain every usage window
+- `GET https://api.chutes.ai/users/me/quota_usage/{chute_id}` for quota details when available
+
+All requests use `Authorization: Bearer cpk_...`. Subscription usage is required; quota-detail requests are best-effort.
+
+## Display
+
+The provider prefers the rolling four-hour window as the primary meter and monthly subscription usage as the secondary meter. Accounts without a subscription can still show available pay-as-you-go quota data.
+
+## CLI Usage
+
+```bash
+codexbar --provider chutes
+```
+
+## Troubleshooting
+
+- Confirm the key can read `https://api.chutes.ai/users/me/subscription_usage`.
+- A `401` or `403` means Chutes rejected the key.
+- `CHUTES_API_URL` can override the management API base URL, but CodexBar accepts HTTPS endpoints only.
diff --git a/docs/claude-comparison-since-0.18.0beta2.md b/docs/claude-comparison-since-0.18.0beta2.md
index b2797a7fa0..dece49f234 100644
--- a/docs/claude-comparison-since-0.18.0beta2.md
+++ b/docs/claude-comparison-since-0.18.0beta2.md
@@ -1,3 +1,11 @@
+---
+summary: "Claude fetch behavior comparison covering OAuth, web, CLI, and Keychain prompt changes."
+read_when:
+  - Reviewing Claude fetch regressions since 0.18.0 beta 2
+  - Changing Claude OAuth, web, CLI, or Keychain prompt behavior
+  - Comparing old and current Claude credential flows
+---
+
 # Claude Fetch Comparison (`7b79b2d` vs `HEAD`)
 
 This document compares Claude data fetching behavior between:
@@ -14,7 +22,7 @@ Focus areas:
 ## High-level Changes
 
 - OAuth moved from "load token and fail if expired" to "auto-refresh when expired".
-- Claude keychain reads now use stricter non-interactive probes (`kSecUseAuthenticationUIFail`) before any promptable path.
+- Claude keychain reads now use stricter non-interactive probes (`LAContext.interactionNotAllowed`) before any promptable path.
 - New Claude keychain prompt cooldown gate: 6-hour suppression after denial.
 - New OAuth refresh failure gate:
   - `invalid_grant` => terminal block until auth fingerprint changes.
diff --git a/docs/claude.md b/docs/claude.md
index 22737efd92..7aa34287db 100644
--- a/docs/claude.md
+++ b/docs/claude.md
@@ -9,18 +9,43 @@ read_when:
 
 # Claude provider
 
-Claude supports three usage data paths plus local cost usage. Source selection is automatic unless debug override is set.
+Claude supports three usage data paths plus local cost usage. The main provider pipeline uses runtime-specific
+automatic selection, but the codebase still has multiple active Claude `.auto` decision sites while the refactor is
+pending. For the exact current-state parity contract, see
+[docs/refactor/claude-current-baseline.md](refactor/claude-current-baseline.md).
+
+When an Anthropic Admin API key is configured, Claude can also show organization-level spend/messages/tokens in the
+same inline dashboard pattern used by the OpenAI API provider.
 
 ## Data sources + selection order
 
 ### Default selection (debug menu disabled)
-1) OAuth API (if Claude CLI credentials include `user:profile` scope).
-2) CLI PTY (`claude`), if OAuth is unavailable or fails.
-3) Web API (browser cookies, `sessionKey`), if OAuth + CLI are unavailable or fail.
+- If an Admin API key is configured, the Admin API strategy is used for Claude API spend/usage.
+- App runtime main pipeline: OAuth API → CLI PTY → Web API.
+- CLI runtime main pipeline: Web API → CLI PTY.
+- Explicit picker modes (OAuth/Web/CLI) bypass automatic fallback.
+- A lower-level direct Claude fetcher still contains a separate `.auto` order. That inconsistency is tracked in
+  [docs/refactor/claude-current-baseline.md](refactor/claude-current-baseline.md).
 
 Usage source picker:
 - Preferences → Providers → Claude → Usage source (Auto/OAuth/Web/CLI).
 
+Admin API key setup:
+- Preferences → Providers → Claude → Admin API key, stored in `~/.codexbar/config.json`.
+- CLI/env: `printf '%s' "$ANTHROPIC_ADMIN_KEY" | codexbar config set-api-key --provider claude --stdin`.
+- Token accounts can also hold `sk-ant-admin...` keys; they route to the Admin API instead of cookie/OAuth usage.
+- Environment fallback: `ANTHROPIC_ADMIN_KEY`.
+
+## Admin API
+- Key prefix: `sk-ant-admin...`.
+- Endpoints:
+  - `/v1/organizations/cost_report`
+  - `/v1/organizations/usage_report/messages`
+- Output:
+  - Today/7d/30d spend and message/token summaries.
+  - Inline 30-day dashboard chart when daily buckets are present.
+  - Identity login method: `Admin API`.
+
 ## Keychain prompt policy (Claude OAuth)
 - Preferences → Providers → Claude → Keychain prompt policy.
 - Options:
@@ -37,8 +62,9 @@ Usage source picker:
 
 ## OAuth API (preferred)
 - Credentials:
-  - Keychain service: `Claude Code-credentials` (primary on macOS).
+  - CodexBar OAuth cache when available.
   - File fallback: `~/.claude/.credentials.json`.
+  - Claude CLI Keychain bootstrap/repair fallback: `Claude Code-credentials`.
 - Requires `user:profile` scope (CLI tokens with only `user:inference` cannot call usage).
 - Endpoint:
   - `GET https://api.anthropic.com/api/oauth/usage`
@@ -47,18 +73,24 @@ Usage source picker:
   - `anthropic-beta: oauth-2025-04-20`
 - Mapping:
   - `five_hour` → session window.
-  - `seven_day` → weekly window.
+  - `seven_day` → weekly window; also becomes the primary fallback when `five_hour` is absent or has no utilization.
   - `seven_day_sonnet` / `seven_day_opus` → model-specific weekly window.
+  - `seven_day_routines` / `seven_day_cowork` → Daily Routines extra window.
+  - Claude Design/Omelette keys are ignored because Claude Design shares the main Claude usage limit.
   - `extra_usage` → Extra usage cost (monthly spend/limit).
-- Plan inference: `rate_limit_tier` from credentials maps to Max/Pro/Team/Enterprise.
+- Successful OAuth login enables Claude and selects OAuth as the usage source.
+- Plan inference: `subscriptionType` is preferred when present; `rate_limit_tier` falls back to
+  Max/Pro/Team/Enterprise.
 
 ## Web API (cookies)
 - Preferences → Providers → Claude → Cookie source (Automatic or Manual).
 - Manual mode accepts a `Cookie:` header from a claude.ai request.
 - Multi-account manual tokens: add entries to `~/.codexbar/config.json` (`tokenAccounts`) and set Claude cookies to
   Manual. The menu can show all accounts stacked or a switcher bar (Preferences → Advanced → Display).
-- Claude token accounts accept either `sessionKey` cookies or OAuth access tokens (`sk-ant-oat...`). OAuth tokens use
-  the Anthropic OAuth usage endpoint; to force cookie mode, paste `sessionKey=<value>` or a full `Cookie:` header.
+- Claude token accounts accept either `sessionKey` cookies or OAuth access tokens (`sk-ant-oat...`). OAuth-token
+  accounts route to the OAuth path and disable cookie mode; session-key or cookie-header accounts stay in manual
+  cookie mode. The exact edge-routing rules are documented in
+  [docs/refactor/claude-current-baseline.md](refactor/claude-current-baseline.md).
 - Cookie source order:
   1) Safari: `~/Library/Cookies/Cookies.binarycookies`
   2) Chrome/Chromium forks: `~/Library/Application Support/Google/Chrome/*/Cookies`
@@ -75,12 +107,17 @@ Usage source picker:
   - `GET https://claude.ai/api/account` → email + plan hints.
 - Outputs:
   - Session + weekly + model-specific percent used.
+  - Daily Routines extra window when returned by the usage API.
   - Extra usage spend/limit (if enabled).
   - Account email + inferred plan.
 
 ## CLI PTY (fallback)
 - Runs `claude` in a PTY session (`ClaudeCLISession`).
 - Default behavior: exit after each probe; Debug → "Keep CLI sessions alive" keeps it running between probes.
+- Probe working directory: `~/Library/Application Support/CodexBar/ClaudeProbe` with local Claude settings that disable
+  deep-link URL handler registration during headless probes.
+- After transient probes exit, CodexBar removes Claude Code `.jsonl` session artifacts for that dedicated
+  `ClaudeProbe` project directory so background `/usage` polling does not clutter the user's Claude project history.
 - Command flow:
   1) Start CLI with `--allowed-tools ""` (no tools).
   2) Auto-respond to first-run prompts (trust files, workspace, telemetry).
@@ -94,17 +131,23 @@ Usage source picker:
 
 ## Cost usage (local log scan)
 - Source roots:
-  - `$CLAUDE_CONFIG_DIR` (comma-separated), each root uses `<root>/projects`.
-  - Fallback roots:
-    - `~/.config/claude/projects`
-    - `~/.claude/projects`
-- Files: `**/*.jsonl` under the project roots.
+  - Native Claude logs:
+    - `$CLAUDE_CONFIG_DIR` (comma-separated), each root uses `<root>/projects`.
+    - Fallback roots:
+      - `~/.config/claude/projects`
+      - `~/.claude/projects`
+  - Supported pi sessions:
+    - `~/.pi/agent/sessions/**/*.jsonl`
+- Files: `**/*.jsonl` under the native project roots plus supported pi session files.
 - Parsing:
-  - Lines with `type: "assistant"` and `message.usage`.
+  - Native Claude logs parse lines with `type: "assistant"` and `message.usage`.
   - Uses per-model token counts (input, cache read/create, output).
   - Deduplicates streaming chunks by `message.id + requestId` (usage is cumulative per chunk).
+  - pi sessions attribute `anthropic` assistant usage to Claude and bucket it by assistant-turn timestamp, so a single pi
+    session can contribute to multiple models/days.
 - Cache:
-  - `~/Library/Caches/CodexBar/cost-usage/claude-v1.json`
+  - Native + merged provider cache: `~/Library/Caches/CodexBar/cost-usage/claude-v2.json`
+  - pi session cache: `~/Library/Caches/CodexBar/cost-usage/pi-sessions-v1.json`
 
 ## Key files
 - OAuth: `Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/*`
@@ -112,4 +155,6 @@ Usage source picker:
 - CLI PTY: `Sources/CodexBarCore/Providers/Claude/ClaudeStatusProbe.swift`,
   `Sources/CodexBarCore/Providers/Claude/ClaudeCLISession.swift`
 - Cost usage: `Sources/CodexBarCore/CostUsageFetcher.swift`,
+  `Sources/CodexBarCore/PiSessionCostScanner.swift`,
+  `Sources/CodexBarCore/PiSessionCostCache.swift`,
   `Sources/CodexBarCore/Vendored/CostUsage/*`
diff --git a/docs/cli-configuration.md b/docs/cli-configuration.md
new file mode 100644
index 0000000000..a13ab6883a
--- /dev/null
+++ b/docs/cli-configuration.md
@@ -0,0 +1,103 @@
+---
+summary: "CodexBar CLI configuration commands for provider toggles, API keys, and isolated config files."
+read_when:
+  - Using codexbar config from scripts or CI
+  - Enabling or disabling providers without opening Settings
+  - Storing provider API keys from the command line
+---
+
+# CLI configuration
+
+`codexbar config` edits the same resolved config file used by the app's Settings → Providers pane.
+New installs use `~/.config/codexbar/config.json`; absolute `XDG_CONFIG_HOME` paths and `CODEXBAR_CONFIG` are
+supported, and existing `~/.codexbar/config.json` installs keep using the legacy file when no XDG config exists.
+The CLI writes the file with `0600` permissions.
+
+## Providers
+
+List persistent provider toggles:
+
+```bash
+codexbar config providers
+codexbar config providers --json --pretty
+```
+
+Enable or disable a provider:
+
+```bash
+codexbar config enable --provider grok
+codexbar config disable --provider cursor
+```
+
+These are persistent app/CLI settings. They are different from `codexbar usage --provider grok`, which is a one-shot
+command override and does not edit config.
+
+If every provider is disabled, `codexbar usage` with no `--provider` prints no text output, and
+`codexbar usage --json` prints `[]`. Passing `--provider <name>` still fetches that provider for the one command.
+
+## API keys
+
+API keys are stored under the provider entry in config:
+
+```bash
+printf '%s' "$ELEVENLABS_API_KEY" | codexbar config set-api-key --provider elevenlabs --stdin
+```
+
+`set-api-key` enables the provider by default. Add `--no-enable` when you only want to save the key:
+
+```bash
+printf '%s' "$OPENROUTER_API_KEY" | codexbar config set-api-key --provider openrouter --stdin --no-enable
+```
+
+Useful examples:
+
+```bash
+printf '%s' "$OPENAI_ADMIN_KEY" | codexbar config set-api-key --provider openai --stdin
+printf '%s' "$ANTHROPIC_ADMIN_KEY" | codexbar config set-api-key --provider claude --stdin
+printf '%s' "$DEEPGRAM_API_KEY" | codexbar config set-api-key --provider deepgram --stdin
+printf '%s' "$GROQ_API_KEY" | codexbar config set-api-key --provider groq --stdin
+printf '%s' "$LLM_PROXY_API_KEY" | codexbar config set-api-key --provider llmproxy --stdin
+printf '%s' "$Z_AI_API_KEY" | codexbar config set-api-key --provider zai --stdin
+```
+
+Only providers that consume config-backed API keys accept this command. Admin API providers may require a key with
+organization/usage permissions, not a normal inference key. Browser/OAuth providers such as Grok use their own provider
+sessions instead of an xAI API key for CodexBar's billing view, so enable them with
+`codexbar config enable --provider grok`.
+
+LLM Proxy also needs a base URL. Use `LLM_PROXY_BASE_URL` for CLI runs, or add `"enterpriseHost"` to the provider entry
+in the CodexBar config file.
+
+## Isolated config files
+
+For tests, demos, and CI, point CodexBar at a temporary config file:
+
+```bash
+export CODEXBAR_CONFIG=/tmp/codexbar-config.json
+codexbar config enable --provider grok
+codexbar config providers --json --pretty
+```
+
+The override applies to both reads and writes for the current process environment.
+
+## Cost history window
+
+The app setting controls the menu's local cost-history window. For one-off CLI reports, pass `--days`:
+
+```bash
+codexbar cost --provider codex --days 90
+codexbar cost --provider claude --days 180 --format json --pretty
+```
+
+The accepted range is 1...365 days.
+
+## Validation
+
+After hand-editing config:
+
+```bash
+codexbar config validate
+codexbar config dump --pretty
+```
+
+`dump` prints normalized config, including providers omitted from a hand-written file.
diff --git a/docs/cli.md b/docs/cli.md
index a13c8f830c..7c4c5e9e0f 100644
--- a/docs/cli.md
+++ b/docs/cli.md
@@ -8,21 +8,24 @@ read_when:
 
 # CodexBar CLI
 
-A lightweight Commander-based CLI that mirrors the menubar app’s data paths (Codex web/RPC → PTY fallback; Claude web by default with CLI fallback and OAuth debug).
+A lightweight Commander-based CLI that mirrors the menu bar app’s provider fetchers and config file.
 Use it when you need usage numbers in scripts, CI, or dashboards without UI.
 
 ## Install
 - In the app: **Preferences → Advanced → Install CLI**. This symlinks `CodexBarCLI` to `/usr/local/bin/codexbar` and `/opt/homebrew/bin/codexbar`.
-- From the repo: `./bin/install-codexbar-cli.sh` (same symlink targets).
+- From the repo, after installing `CodexBar.app` in `/Applications`: `./bin/install-codexbar-cli.sh` (same symlink targets).
 - Manual: `ln -sf "/Applications/CodexBar.app/Contents/Helpers/CodexBarCLI" /usr/local/bin/codexbar`.
 
-### Linux install
-- Homebrew (Linuxbrew, Linux only): `brew install steipete/tap/codexbar`.
-- Download `CodexBarCLI-v<tag>-linux-<arch>.tar.gz` from GitHub Releases (x86_64 + aarch64).
-- Extract; run `./codexbar` (symlink) or `./CodexBarCLI`.
+### Release tarball install (macOS/Linux)
+- Homebrew formula (Linux today): `brew install steipete/tap/codexbar`.
+- Download release tarballs from GitHub Releases:
+  - macOS: `CodexBarCLI-v<tag>-macos-arm64.tar.gz`, `CodexBarCLI-v<tag>-macos-x86_64.tar.gz`
+  - Linux (glibc): `CodexBarCLI-v<tag>-linux-aarch64.tar.gz`, `CodexBarCLI-v<tag>-linux-x86_64.tar.gz`
+  - Linux (static musl): `CodexBarCLI-v<tag>-linux-musl-aarch64.tar.gz`, `CodexBarCLI-v<tag>-linux-musl-x86_64.tar.gz`
+- Extract and run `./codexbar` (symlink) or `./CodexBarCLI`.
 
 ```
-tar -xzf CodexBarCLI-v0.17.0-linux-x86_64.tar.gz
+tar -xzf CodexBarCLI-v0.17.0-macos-x86_64.tar.gz
 ./codexbar --version
 ./codexbar usage --format json --pretty
 ```
@@ -33,45 +36,66 @@ tar -xzf CodexBarCLI-v0.17.0-linux-x86_64.tar.gz
 - Dependencies: Swift 6.2+, Commander package (`https://github.com/steipete/Commander`).
 
 ## Configuration
-CodexBar reads `~/.codexbar/config.json` for provider settings, secrets, and ordering.
+CodexBar reads the resolved config file for provider settings, secrets, and ordering. New installs use
+`~/.config/codexbar/config.json`; absolute `XDG_CONFIG_HOME` paths and `CODEXBAR_CONFIG` are supported, and existing
+`~/.codexbar/config.json` installs keep using the legacy file when no XDG config exists.
 See `docs/configuration.md` for the schema.
 
 ## Command
 - `codexbar` defaults to the `usage` command.
   - `--format text|json` (default: text).
-- `codexbar cost` prints local token cost usage (Claude + Codex) without web/CLI access.
+- `codexbar cost` prints local token cost usage for Claude + Codex without web/CLI access.
   - `--format text|json` (default: text).
   - `--refresh` ignores cached scans.
+- `codexbar serve` starts a foreground localhost-only HTTP server for usage and cost JSON.
+  - `--port <port>` defaults to `8080`.
+  - `--refresh-interval <seconds>` defaults to `60` and controls the in-memory response cache TTL.
+  - `--request-timeout <seconds>` defaults to `30` and bounds each request before returning `504 Gateway Timeout`; use `0` to keep waiting indefinitely.
+  - Provider config is reloaded for each usage/cost request; cache entries are keyed by the loaded config so provider toggles and source changes do not require restarting `serve`.
+  - Transient refresh failures fall back to the last good response for up to ten refresh intervals (minimum five minutes) so polling clients do not flicker between data and errors; disabled when `--refresh-interval 0`.
+  - v1 binds to `127.0.0.1` only and rejects non-loopback `Host` headers. It does not expose remote bind, auth, CORS, TLS, or daemon mode.
+  - Endpoints: `GET /health`, `GET /usage`, `GET /usage?provider=<id|both|all>`, `GET /cost`, `GET /cost?provider=<id|both|all>`.
+  - `GET /health` returns `{"status":"ok"}` plus a `version` field with the running build (e.g. `"0.37.2"`) when resolvable; clients can compare it against `codexbar --version` to detect a `serve` process still running an older binary after an update.
+  - Codex usage responses include every visible Codex account, matching the menu bar switcher.
+- `codexbar cache clear` clears local CodexBar caches.
+  - `--cookies` removes cached browser-cookie headers from the CodexBar Keychain cache.
+  - `--cookies --provider <id>` removes browser-cookie cache entries for that provider, including managed Codex account scopes.
+  - `--cost` removes local cost-usage scan caches.
+  - `--all` clears both cookies and cost caches. `--provider` is cookie-only and cannot be combined with `--cost` or `--all`.
 - `--provider <id|both|all>` (default: enabled providers in config; falls back to defaults when missing).
   - Provider IDs live in the config file (see `docs/configuration.md`).
-  - `--account <label>` / `--account-index <n>` / `--all-accounts` (token accounts from config; requires a single provider).
+  - With three or more providers enabled, the default stays scoped to enabled providers; use `--provider all` to query
+    every registered provider.
+  - `--account <label>` / `--account-index <n>` / `--all-accounts` (token accounts from config, or all visible Codex accounts for Codex; requires a single provider).
   - `--no-credits` (hide Codex credits in text output).
   - `--pretty` (pretty-print JSON).
   - `--status` (fetch provider status pages and include them in output).
   - `--antigravity-plan-debug` (debug: print Antigravity planInfo fields to stderr).
 - `--source <auto|web|cli|oauth|api>` (default: `auto`).
-    - `auto` (macOS only): uses browser cookies for Codex + Claude, with CLI fallback only when cookies are missing.
-    - `web` (macOS only): web-only; no CLI fallback.
-    - `cli`: CLI-only (Codex RPC → PTY fallback; Claude PTY).
-    - `oauth`: Claude OAuth only (debug); no fallback. Not supported for Codex.
-    - `api`: API key flow when the provider supports it (z.ai, Gemini, Copilot, Kilo, Kimi K2, MiniMax, Warp, OpenRouter, Synthetic).
-    - Output `source` reflects the strategy actually used (`openai-web`, `web`, `oauth`, `api`, `local`, or provider CLI label).
+    - `auto`: provider-specific fallback order from `docs/providers.md`.
+    - `web`: web-only where that provider exposes an explicit web source; no CLI/API fallback. Browser import is macOS-only, while supported providers can use configured manual cookies on Linux.
+    - `cli`: CLI/local-helper source where the provider exposes one (for example Codex RPC/PTy, Claude PTY, Kilo CLI fallback, Kiro CLI, local probes).
+    - `oauth`: OAuth-backed source where supported (Codex, Claude, Vertex AI).
+    - `api`: API-key/token flow when the provider supports it (OpenAI, Claude Admin API, z.ai, Gemini, Alibaba, Copilot, Kilo, Kimi, Kimi K2, MiniMax, Ollama, Warp, OpenRouter, ElevenLabs, Deepgram, Synthetic, DeepSeek, Moonshot, Doubao, Codebuff, Crof, Venice, AWS Bedrock).
+    - Output `source` reflects the strategy actually used (`openai-web`, `web`, `oauth`, `api`, `local`, `cli`, or provider CLI label).
     - Codex web: OpenAI web dashboard (usage limits, credits remaining, code review remaining, usage breakdown).
         - `--web-timeout <seconds>` (default: 60)
         - `--web-debug-dump-html` (writes HTML snapshots to `/tmp` when data is missing)
     - Claude web: claude.ai API (session + weekly usage, plus account metadata when available).
+    - Command Code web: commandcode.ai browser session cookies on macOS, or a configured manual cookie on Linux, for monthly credit usage.
+    - OpenCode Go auto: local SQLite usage on macOS and Linux, with optional manual-cookie web enrichment.
     - Kilo auto: app.kilo.ai API first, then CLI auth fallback (`~/.local/share/kilo/auth.json`) on missing/unauthorized API credentials.
-    - Linux: `web/auto` are not supported; CLI prints an error and exits non-zero.
+    - Linux: browser-backed `auto`/`web` modes are not supported; local sources and configured manual-cookie paths remain available where documented.
 - Global flags: `-h/--help`, `-V/--version`, `-v/--verbose`, `--no-color`, `--log-level <trace|verbose|debug|info|warning|error|critical>`, `--json-output`, `--json-only`.
   - `--json-output`: JSONL logs on stderr (machine-readable).
   - `--json-only`: suppress non-JSON output; errors become JSON payloads.
-- `codexbar config validate` checks `~/.codexbar/config.json` for invalid fields.
+- `codexbar config validate` checks the resolved config file for invalid fields.
   - `--format text|json`, `--pretty`, and `--json-only` are supported.
   - Warnings keep exit code 0; errors exit non-zero.
 - `codexbar config dump` prints the normalized config JSON.
 
 ### Token accounts
-The CLI reads multi-account tokens from `~/.codexbar/config.json` (same file as the app).
+The CLI reads multi-account tokens from the same resolved config file as the app.
 - Select a specific account: `--account <label>` (matches the label/email in the file).
 - Select by index (1-based): `--account-index <n>`.
 - Fetch all accounts for the provider: `--all-accounts`.
@@ -79,6 +103,12 @@ Account selection flags require a single provider (`--provider claude`, etc.).
 For Claude, token accounts accept either `sessionKey` cookies or OAuth access tokens (`sk-ant-oat...`).
 OAuth usage requires the `user:profile` scope; inference-only tokens will return an error.
 
+### Codex accounts
+For Codex, `--all-accounts` and `codexbar serve` enumerate the same visible accounts as the app switcher:
+managed Codex accounts from `managed-codex-accounts.json` plus the live system account when present.
+Each fetch is scoped to that account's Codex home before the normal Codex web/OAuth/CLI strategy runs, and JSON
+payloads include the visible account label in `account`.
+
 ### Cost JSON payload
 `codexbar cost --format json` emits an array of payloads (one per provider).
 - `provider`, `source`, `updatedAt`
@@ -91,21 +121,32 @@ OAuth usage requires the `user:profile` scope; inference-only tokens will return
 ```
 codexbar                          # text, respects app toggles
 codexbar --provider claude        # force Claude
-codexbar --provider all           # query all providers (honors your logins/toggles)
+codexbar --provider all           # query all registered providers
 codexbar --format json --pretty   # machine output
 codexbar --format json --provider both
-codexbar cost                     # local cost usage (last 30 days + today)
+codexbar cost                     # local cost usage (default 30-day window + today)
+codexbar cost --days 90           # choose a 1...365 day cost window
 codexbar cost --provider claude --format json --pretty
+codexbar serve --port 8080        # localhost HTTP JSON server
+codexbar serve --request-timeout 0 # disable serve request deadlines
 COPILOT_API_TOKEN=... codexbar --provider copilot --format json --pretty
 codexbar --status                 # include status page indicator/description
+codexbar --provider codex --source oauth --format json --pretty
 codexbar --provider codex --source web --format json --pretty
+codexbar --provider codex --all-accounts --format json --pretty
 codexbar --provider claude --account steipete@gmail.com
 codexbar --provider claude --all-accounts --format json --pretty
 codexbar --json-only --format json --pretty
 codexbar --provider gemini --source api --format json --pretty
 KILO_API_KEY=... codexbar --provider kilo --source api --format json --pretty
+MOONSHOT_API_KEY=... codexbar --provider moonshot --source api --format json --pretty
 codexbar config validate --format json --pretty
 codexbar config dump --pretty
+printf '%s' "$OPENAI_ADMIN_KEY" | codexbar config set-api-key --provider openai --stdin
+codexbar config enable --provider grok
+codexbar cache clear --cookies
+codexbar cache clear --cookies --provider claude
+codexbar cache clear --all --format json --pretty
 ```
 
 ### Sample output (text)
@@ -187,14 +228,18 @@ Note: Using CLI fallback
 
 ## Notes
 - CLI uses the config file for enabled providers, ordering, and secrets.
+- CLI binary discovery checks explicit overrides, captured login PATH, inherited PATH, and known install paths before falling back to an interactive shell probe.
 - Reset lines follow the in-app reset time display setting when available (default: countdown).
 - Text output uses ANSI colors when stdout is a rich TTY; disable with `--no-color` or `NO_COLOR`/`TERM=dumb`.
 - Copilot CLI queries require an API token via config `apiKey` or `COPILOT_API_TOKEN`.
-- Prefer Codex RPC first, then PTY fallback; Claude defaults to web with CLI fallback when cookies are missing.
+- OpenAI API charts require an Admin API key for organization costs/usage. Normal API keys can only use the legacy balance fallback.
+- Claude Admin API charts require an Anthropic Admin API key (`sk-ant-admin...` or `ANTHROPIC_ADMIN_KEY`).
+- Codex CLI `auto` tries the OpenAI web dashboard, then Codex CLI RPC/PTy; the app’s Codex `auto` path prefers OAuth when credentials are present, then CLI.
+- Claude CLI `auto` tries web, then CLI PTY; the app’s Claude `auto` path prefers OAuth, then CLI, then web.
 - Kilo text output splits identity into `Plan:` and `Activity:` lines; in `--source auto`, resolved CLI fetches add
   `Note: Using CLI fallback`.
 - Kilo auto-mode failures include a fallback-attempt summary line in text mode (API attempt then CLI attempt).
-- OpenAI web requires a signed-in `chatgpt.com` session in Safari, Chrome, or Firefox. No passwords are stored; CodexBar reuses cookies.
+- OpenAI web requires a signed-in `chatgpt.com` session in a supported browser or a manual cookie header. No passwords are stored; CodexBar reuses cookies.
 - Safari cookie import may require granting CodexBar Full Disk Access (System Settings → Privacy & Security → Full Disk Access).
 - The `openaiDashboard` JSON field is normally sourced from the app’s cached dashboard snapshot; `--source auto|web` refreshes it live via WebKit using a per-account cookie store.
 - Future: optional `--from-cache` flag to read the menubar app’s persisted snapshot (if/when that file lands).
diff --git a/docs/codebuff.md b/docs/codebuff.md
new file mode 100644
index 0000000000..a1737024f9
--- /dev/null
+++ b/docs/codebuff.md
@@ -0,0 +1,72 @@
+---
+summary: "Codebuff provider data sources: API token, CLI credentials file, credit balance, and weekly rate limits."
+read_when:
+  - Debugging Codebuff credential resolution or usage parsing
+  - Updating Codebuff credit balance or weekly rate-limit display
+  - Adjusting Codebuff provider UI/menu behavior
+---
+
+# Codebuff
+
+CodexBar surfaces [Codebuff](https://www.codebuff.com) credit balance and
+weekly rate limits next to your other AI providers.
+
+## Data sources
+
+- `POST https://www.codebuff.com/api/v1/usage` — current credit usage,
+  remaining balance, auto top-up state, and the next quota reset date.
+- `GET  https://www.codebuff.com/api/user/subscription` — subscription tier,
+  billing period end, and the weekly rate-limit window (`weeklyUsed` /
+  `weeklyLimit`) when CodexBar is using the CLI credentials-file session token.
+
+Both endpoints use a Bearer token. Codebuff credentials come from the
+environment, the normal CodexBar config file, or the official CLI credentials
+file; the Codebuff provider does not write a separate Keychain credential.
+
+## Authentication
+
+CodexBar resolves the Codebuff API token in this order:
+
+1. `CODEBUFF_API_KEY` environment variable (takes precedence so CI overrides
+   work). API-key tokens fetch credit balance only.
+2. The per-provider API key stored in Settings → Providers → Codebuff (saved
+   in `~/.codexbar/config.json` via the normal CodexBar config flow). API-key
+   tokens fetch credit balance only.
+3. `~/.config/manicode/credentials.json` — the file the official `codebuff`
+   CLI (formerly `manicode`) writes after `codebuff login`. CodexBar reads
+   `default.authToken`, falling back to top-level `authToken`, and uses that
+   session token for both credit balance and subscription metadata.
+
+If none of those is available, Codebuff shows the “missing token” error.
+
+## Credit window mapping
+
+- **Primary row** — credit balance (`usage / quota`), with the "next quota
+  reset" date if provided.
+- **Secondary row** — weekly rate-limit window (`weeklyUsed / weeklyLimit`)
+  shown with a 7-day window.
+
+The account panel shows the Codebuff tier (e.g. "Pro"), remaining balance,
+and whether auto top-up is enabled.
+
+## Troubleshooting
+
+- Run `codebuff login` to refresh `~/.config/manicode/credentials.json`.
+- Override the API base with `CODEBUFF_API_URL` for staging environments.
+- Verify your token works manually:
+
+  ```sh
+  curl -s -X POST -H "Authorization: Bearer $CODEBUFF_API_KEY" \
+    -H 'Content-Type: application/json' -d '{"fingerprintId":"codexbar-usage"}' \
+    https://www.codebuff.com/api/v1/usage
+  ```
+
+## Related files
+
+- `Sources/CodexBarCore/Providers/Codebuff/` — descriptor, fetcher, snapshot,
+  settings reader, error types.
+- `Sources/CodexBar/Providers/Codebuff/` — settings store bridge + macOS
+  settings pane implementation.
+- `Tests/CodexBarTests/CodebuffSettingsReaderTests.swift`,
+  `CodebuffUsageFetcherTests.swift`, and the Codebuff extensions in
+  `ProviderTokenResolverTests.swift`.
diff --git a/docs/codex.md b/docs/codex.md
index c7250939a3..54826f58f9 100644
--- a/docs/codex.md
+++ b/docs/codex.md
@@ -1,38 +1,68 @@
 ---
-summary: "Codex provider data sources: OpenAI web dashboard, Codex CLI RPC/PTY, credits, and local cost usage."
+summary: "Codex provider data sources: OpenAI web dashboard, Codex CLI RPC, credits, and local cost usage."
 read_when:
   - Debugging Codex usage/credits parsing
   - Updating OpenAI dashboard scraping or cookie import
-  - Changing Codex CLI RPC/PTY behavior
+  - Changing Codex CLI RPC or diagnostic PTY behavior
   - Reviewing local cost usage scanning
 ---
 
 # Codex provider
 
-Codex has four usage data paths (OAuth API, web dashboard, CLI RPC, CLI PTY) plus a local cost-usage scanner.
+Codex has three automatic usage data paths (OAuth API, web dashboard, CLI RPC) plus a manual CLI PTY diagnostic parser and a local cost-usage scanner.
 The OAuth API is the default app source when credentials are available; web access is optional for dashboard extras.
 
 ## Data sources + fallback order
 
 ### App default selection (debug menu disabled)
 1) OAuth API (auth.json credentials).
-2) CLI RPC, with CLI PTY fallback when needed.
-3) If OpenAI cookies are enabled (Automatic or Manual), dashboard extras load in parallel and the source label becomes
-   `primary + openai-web`.
+2) CLI RPC through `codex app-server`.
+3) If OpenAI web extras are enabled and a matching OpenAI web session is available (Automatic or Manual cookies),
+   dashboard extras load as a separate follow-up refresh and the source label becomes `primary + openai-web`.
 
 Usage source picker:
 - Preferences → Providers → Codex → Usage source (Auto/OAuth/CLI).
 
 ### CLI default selection (`--source auto`)
 1) OpenAI web dashboard (when available).
-2) Codex CLI RPC, with CLI PTY fallback when needed.
+2) Codex CLI RPC through `codex app-server`.
 
 ### OAuth API (preferred for the app)
 - Reads OAuth tokens from `~/.codex/auth.json` (or `$CODEX_HOME/auth.json`).
 - Refreshes access tokens when `last_refresh` is older than 8 days.
 - Calls `GET https://chatgpt.com/backend-api/wham/usage` (default) with `Authorization: Bearer <token>`.
+- `rate_limit.primary_window` / `secondary_window` map to the session/weekly lanes.
+- `additional_rate_limits[]` (model-specific limits such as GPT-5.3-Codex-Spark) map to named
+  `UsageSnapshot.extraRateWindows` entries (Spark uses a stable `codex-spark` id / `Codex Spark` title).
+  When the field is absent, the snapshot is unchanged.
 
-### OpenAI web dashboard (optional)
+### Advanced profile-home accounts
+- Managed Codex accounts remain the default multi-account path.
+- Advanced users can add existing Codex homes to `~/.codexbar/config.json` with
+  `providers[].codexProfileHomePaths`.
+- Each configured path must be absolute or start with `~/`, and point at a Codex home that contains `auth.json`.
+- CodexBar reads identity from the configured home, exposes it in the Codex account switcher, and scopes
+  remote Codex fetches with `CODEX_HOME`.
+- Profile homes are not copied, reauthenticated, or removed by CodexBar.
+
+Example:
+
+```json
+{
+  "id": "codex",
+  "codexProfileHomePaths": [
+    "~/.codex-work",
+    "~/.codex-personal"
+  ]
+}
+```
+
+### OpenAI web dashboard (optional, off by default)
+- Enable it in Preferences -> Providers -> Codex -> OpenAI web extras.
+- It exists for dashboard-only extras such as code review remaining, usage breakdown, and credits history.
+- It is intentionally opt-in because it loads `chatgpt.com` in a hidden WebView and can materially increase battery or network usage.
+- OpenAI web battery saver is a separate toggle. When enabled, routine background/settings-driven refreshes are reduced, but explicit manual refreshes still run.
+- OpenAI web battery saver currently defaults to off.
 - Preferences → Providers → Codex → OpenAI cookies (Automatic or Manual).
 - URL: `https://chatgpt.com/codex/settings/usage`.
 - Uses an off-screen `WKWebView` with a per-account `WKWebsiteDataStore`.
@@ -62,26 +92,33 @@ Usage source picker:
 - Errors surfaced:
   - Login required or Cloudflare interstitial.
 
-### Codex CLI RPC (default CLI fallback)
+### Codex CLI RPC (automatic CLI source)
 - Launches local RPC server: `codex -s read-only -a untrusted app-server`.
 - JSON-RPC over stdin/stdout:
   - `initialize` (client name/version)
   - `account/read`
   - `account/rateLimits/read`
+- RPC reads are bounded: initialization has a longer startup budget, and normal requests have a shorter per-method
+  timeout. On timeout, CodexBar terminates the child `codex app-server` process so the stdout reader unwinds instead
+  of leaving refresh stuck indefinitely.
 - Provides:
   - Usage windows (primary + secondary) with reset timestamps.
   - Credits snapshot (balance, hasCredits, unlimited).
   - Account identity (email + plan type) when available.
+- App-server errors are terminal for the CLI strategy, except when Codex includes a recoverable `wham/usage` JSON body in the error text.
+- If macOS blocks or quarantines the `codex` executable, CodexBar records the launch failure and skips background CLI
+  launches for 30 minutes. Use a manual refresh after reinstalling or unblocking `codex` to retry immediately.
+- If managed Codex account login fails after macOS moved `codex` to Trash, first confirm `codex --version` works in
+  Terminal. Check `which -a codex` for stale duplicate installs, then run
+  `npm install -g --include=optional @openai/codex@latest` before retrying Add Account.
 
-### Codex CLI PTY fallback (`/status`)
-- Runs `codex` in a PTY via `TTYCommandRunner`.
-- Default behavior: exit after each probe; Debug → "Keep CLI sessions alive" keeps it running between probes.
-- Sends `/status`, parses the rendered screen:
+### Codex CLI PTY diagnostics (`/status`)
+- Manual/debug parser only; automatic background refresh and `CodexBarCLI usage --source cli` do not launch bare Codex TUI.
+- Kept for explicit diagnostics/parser coverage because bare `codex` TUI can start interactive auth and open browser tabs.
+- Parses rendered `/status` output:
   - `Credits:` line
   - `5h limit` line → percent + reset text
   - `Weekly limit` line → percent + reset text
-- Retry once with a larger terminal size on parse failure (short retry window).
-- Do not retry on timeout; timed-out probes fail fast and wait for the next refresh cycle.
 - Detects update prompts and surfaces a "CLI update needed" error.
 
 ## Account identity resolution (for web matching)
@@ -93,23 +130,32 @@ Usage source picker:
 ## Credits
 - Web dashboard fills credits only when OAuth/CLI do not provide them.
 - CLI RPC: `account/rateLimits/read` → credits balance.
-- CLI PTY fallback: parse `Credits:` from `/status`.
+- CLI PTY diagnostics can still parse `Credits:` from saved/manual `/status` output.
 
 ## Cost usage (local log scan)
 - Source files:
-  - `~/.codex/sessions/YYYY/MM/DD/*.jsonl`
-  - `~/.codex/archived_sessions/*.jsonl` (flat; date inferred from filename when present)
-  - Or `$CODEX_HOME/sessions/...` + `$CODEX_HOME/archived_sessions/...` if `CODEX_HOME` is set.
+  - Native Codex logs:
+    - `~/.codex/sessions/YYYY/MM/DD/*.jsonl`
+    - `~/.codex/archived_sessions/*.jsonl` (flat; date inferred from filename when present)
+    - Or `$CODEX_HOME/sessions/...` + `$CODEX_HOME/archived_sessions/...` if `CODEX_HOME` is set.
+  - Supported pi sessions:
+    - `~/.pi/agent/sessions/**/*.jsonl`
 - Scanner:
-  - Parses `event_msg` token_count entries and `turn_context` model markers.
-  - Computes input/cached/output token deltas and per-model cost.
+  - Native Codex logs parse `event_msg` token_count entries and `turn_context` model markers; when both are present,
+    `turn_context` is authoritative for the model bucket.
+  - pi sessions count assistant-message usage rows and attribute `openai-codex` assistant usage to Codex.
+  - pi assistant usage is bucketed by assistant-turn timestamp, so mixed-model pi sessions can contribute to multiple
+    days/models correctly.
 - Cache:
-  - `~/Library/Caches/CodexBar/cost-usage/codex-v1.json`
-- Window: last 30 days (rolling), with a 60s minimum refresh interval.
+  - Native + merged provider cache: `~/Library/Caches/CodexBar/cost-usage/codex-v2.json`
+  - pi session cache: `~/Library/Caches/CodexBar/cost-usage/pi-sessions-v1.json`
+- Window: configurable 1-365 day rolling history, with a 60s minimum refresh interval.
 
 ## Key files
 - Web: `Sources/CodexBarCore/OpenAIWeb/*`
-- CLI RPC + PTY: `Sources/CodexBarCore/UsageFetcher.swift`,
+- CLI RPC + diagnostic PTY parser: `Sources/CodexBarCore/UsageFetcher.swift`,
   `Sources/CodexBarCore/Providers/Codex/CodexStatusProbe.swift`
 - Cost usage: `Sources/CodexBarCore/CostUsageFetcher.swift`,
+  `Sources/CodexBarCore/PiSessionCostScanner.swift`,
+  `Sources/CodexBarCore/PiSessionCostCache.swift`,
   `Sources/CodexBarCore/Vendored/CostUsage/*`
diff --git a/docs/command-code.md b/docs/command-code.md
new file mode 100644
index 0000000000..e7bd5c500f
--- /dev/null
+++ b/docs/command-code.md
@@ -0,0 +1,51 @@
+---
+summary: "Command Code provider notes: cookie authentication and monthly credit parsing."
+read_when:
+  - Debugging Command Code cookie import or usage parsing
+  - Updating Command Code billing or credit display
+  - Adjusting Command Code provider UI/menu behavior
+---
+
+# Command Code
+
+CodexBar surfaces [Command Code](https://commandcode.ai) monthly USD credits next
+to your other AI coding providers.
+
+## Data source
+
+- `https://api.commandcode.ai` billing endpoints, authenticated with the
+  signed-in Command Code web session.
+- The provider reads monthly credit usage, plan allowance, remaining credits,
+  and billing-cycle reset timing when the account data is available.
+
+## Authentication
+
+Command Code support uses browser cookies or a manually pasted cookie header.
+
+1. Sign in to `https://commandcode.ai` in a supported browser.
+2. Open Settings -> Providers -> Command Code.
+3. Enable Command Code and leave Cookie source on Automatic, or switch to Manual
+   and paste a `Cookie:` header/cURL capture from Command Code.
+
+Automatic import looks for better-auth session cookies from `commandcode.ai`
+and `www.commandcode.ai`. If automatic import cannot find a session, use the
+manual cookie field.
+
+On Linux, browser import is unavailable. Set `cookieSource` to `manual` and
+provide the Command Code `Cookie` header in `cookieHeader`; both `auto` and
+`web` CLI source modes then use the billing API.
+
+## Display
+
+- The menu bar item and provider card use the Command Code icon and label.
+- The primary row shows monthly credits used/remaining.
+- Widgets do not expose Command Code in the provider picker yet.
+
+## Related files
+
+- `Sources/CodexBarCore/Providers/CommandCode/` - descriptor, cookie import,
+  billing fetcher, snapshot mapping, and plan catalog.
+- `Sources/CodexBar/Providers/CommandCode/` - settings store bridge and
+  provider settings UI.
+- `Tests/CodexBarTests/CommandCode*Tests.swift` - parser, cookie, settings,
+  and icon coverage.
diff --git a/docs/configuration.md b/docs/configuration.md
index fecfd198a8..6a75774965 100644
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -8,13 +8,17 @@ read_when:
 
 # Configuration
 
-CodexBar reads a single JSON config file for CLI and app settings.
-Secrets (API keys, cookies, tokens) live here; Keychain is not used.
+CodexBar reads a single JSON config file for CLI and app provider settings.
+API keys, manual cookie headers, source selection, ordering, and token accounts live here. Keychain is still used for runtime cookie caches, browser Safe Storage access, and provider OAuth/device-flow credentials where those flows require it.
 
 ## Location
-- `~/.codexbar/config.json`
+- `CODEXBAR_CONFIG=/path/to/config.json` when set.
+- `$XDG_CONFIG_HOME/codexbar/config.json` when `XDG_CONFIG_HOME` is set to an absolute path. Relative values are
+  ignored.
+- `~/.config/codexbar/config.json` by default for new installs.
+- `~/.codexbar/config.json` for existing legacy installs when no XDG config exists.
 - The directory is created if missing.
-- Permissions are forced to `0600` on macOS and Linux.
+- Permissions are set to `0600` whenever CodexBar writes the file on macOS and Linux.
 
 ## Root shape
 ```json
@@ -28,6 +32,7 @@ Secrets (API keys, cookies, tokens) live here; Keychain is not used.
       "cookieSource": "auto",
       "cookieHeader": null,
       "apiKey": null,
+      "enterpriseHost": null,
       "region": null,
       "workspaceID": null,
       "tokenAccounts": null
@@ -44,14 +49,104 @@ All provider fields are optional unless noted.
 - `source`: preferred source mode.
   - `auto|web|cli|oauth|api`
   - `auto` uses provider-specific fallback order (see `docs/providers.md`).
-  - `api` uses provider API key flow (when supported).
-- `apiKey`: raw API token for providers that support direct API usage.
+  - `api` uses the provider's API-backed mode; only some providers consume the `apiKey` field.
+- `apiKey`: raw API token for providers that support config-backed direct API usage.
+- `enterpriseHost`: provider-specific API host/base URL override. Today this is used by Azure OpenAI, Copilot, and LLM Proxy.
 - `cookieSource`: cookie selection policy.
   - `auto` (browser import), `manual` (use `cookieHeader`), `off` (disable cookies)
 - `cookieHeader`: raw cookie header value (e.g. `key=value; other=...`).
 - `region`: provider-specific region (e.g. `zai`, `minimax`).
-- `workspaceID`: provider-specific workspace ID (e.g. `opencode`).
-- `tokenAccounts`: multi-account tokens for a provider.
+- `workspaceID`: provider-specific workspace/deployment/project ID (e.g. Azure OpenAI deployment, OpenAI API project,
+  `opencode`).
+- `tokenAccounts`: multi-account tokens for providers in `TokenAccountSupportCatalog`.
+
+## Manual cookies
+Use manual cookies when automatic browser import is unavailable, disabled, or too noisy for your setup.
+The app and CLI both read the same resolved config file, so a manual cookie saved in the UI is also used by
+`codexbar`, and a cookie written by tooling is shown in the app after reload.
+
+`cookieHeader` expects the HTTP `Cookie:` request header value for the provider origin, not a raw Netscape cookie
+export. In browser DevTools, open the Network tab, select a request for the provider site, and copy the request
+header named `Cookie`. You can paste either the full `Cookie: name=value; other=value` string or just
+`name=value; other=value`.
+
+If you have a Netscape export, convert each non-comment row to `name=value` and join values with `; `. Do not paste
+the raw `# Netscape HTTP Cookie File` text into `cookieHeader`.
+
+Example placeholder config:
+
+```json
+{
+  "version": 1,
+  "providers": [
+    {
+      "id": "example-provider",
+      "enabled": true,
+      "cookieSource": "manual",
+      "cookieHeader": "session=<REDACTED>; other=<REDACTED>"
+    }
+  ]
+}
+```
+
+Validate after editing:
+
+```bash
+codexbar config validate
+codexbar usage --provider example-provider --verbose
+```
+
+CLI shortcuts:
+
+```bash
+codexbar config providers
+codexbar config enable --provider grok
+codexbar config disable --provider cursor
+printf '%s' "$ELEVENLABS_API_KEY" | codexbar config set-api-key --provider elevenlabs --stdin
+printf '%s' "$OPENAI_ADMIN_KEY" | codexbar config set-api-key --provider openai --stdin
+printf '%s' "$GROQ_API_KEY" | codexbar config set-api-key --provider groq --stdin
+printf '%s' "$LLM_PROXY_API_KEY" | codexbar config set-api-key --provider llmproxy --stdin
+printf '%s' "$LITELLM_API_KEY" | codexbar config set-api-key --provider litellm --stdin
+```
+
+OpenAI API project scoping uses `workspaceID` in config. This maps to `OPENAI_PROJECT_ID` for Admin API usage and is
+only applied to the configured OpenAI key, not to selected OpenAI token accounts:
+
+```json
+{
+  "id": "openai",
+  "enabled": true,
+  "apiKey": "<OPENAI_ADMIN_KEY>",
+  "workspaceID": "proj_..."
+}
+```
+
+LLM Proxy also needs a base URL. Set `enterpriseHost` in config or `LLM_PROXY_BASE_URL` in the process environment:
+
+```json
+{
+  "id": "llmproxy",
+  "enabled": true,
+  "apiKey": "<REDACTED>",
+  "enterpriseHost": "https://proxy.example.com"
+}
+```
+
+LiteLLM also needs a base URL. Set `enterpriseHost` in config or `LITELLM_BASE_URL` in the process environment:
+
+```json
+{
+  "id": "litellm",
+  "enabled": true,
+  "apiKey": "<REDACTED>",
+  "enterpriseHost": "https://litellm.example.com"
+}
+```
+
+See [CLI configuration](cli-configuration.md) for scripting examples and output formats.
+
+Manual cookies are secrets. Keep the CodexBar config file private, leave its permissions at `0600`, never commit it,
+and never paste real cookie values or readable DevTools screenshots into public issues.
 
 ### tokenAccounts
 ```json
@@ -72,7 +167,7 @@ All provider fields are optional unless noted.
 
 ## Provider IDs
 Current IDs (see `Sources/CodexBarCore/Providers/Providers.swift`):
-`codex`, `claude`, `cursor`, `opencode`, `factory`, `gemini`, `antigravity`, `copilot`, `zai`, `minimax`, `kimi`, `kilo`, `kiro`, `vertexai`, `augment`, `jetbrains`, `kimik2`, `amp`, `ollama`, `synthetic`, `warp`, `openrouter`.
+`codex`, `openai`, `azureopenai`, `claude`, `cursor`, `opencode`, `opencodego`, `alibaba`, `alibabatokenplan`, `factory`, `gemini`, `antigravity`, `copilot`, `devin`, `zai`, `minimax`, `manus`, `kimi`, `kilo`, `kiro`, `vertexai`, `augment`, `jetbrains`, `kimik2`, `moonshot`, `amp`, `t3chat`, `ollama`, `synthetic`, `warp`, `openrouter`, `elevenlabs`, `windsurf`, `zed`, `perplexity`, `mimo`, `doubao`, `abacus`, `mistral`, `deepseek`, `codebuff`, `crof`, `venice`, `commandcode`, `stepfun`, `bedrock`, `grok`, `groq`, `llmproxy`, `litellm`, `deepgram`, `poe`, `chutes`.
 
 ## Ordering
 The order of `providers` controls display/order in the app and CLI. Reorder the array to change ordering.
diff --git a/docs/copilot.md b/docs/copilot.md
index f6e44f95a0..9643cc234f 100644
--- a/docs/copilot.md
+++ b/docs/copilot.md
@@ -1,5 +1,5 @@
 ---
-summary: "Copilot provider data sources: GitHub device flow + Copilot internal usage API."
+summary: "Copilot provider data sources: GitHub device flow, Copilot internal usage API, and optional GitHub web budgets."
 read_when:
   - Debugging Copilot login or usage parsing
   - Updating GitHub OAuth device flow behavior
@@ -7,7 +7,7 @@ read_when:
 
 # Copilot provider
 
-Copilot uses GitHub OAuth device flow and the Copilot internal usage API. No browser cookies.
+Copilot uses GitHub OAuth device flow and the Copilot internal usage API for primary usage. Optional budget extras use GitHub web cookies only when enabled.
 
 ## Data sources + fallback order
 
@@ -16,12 +16,18 @@ Copilot uses GitHub OAuth device flow and the Copilot internal usage API. No bro
      - `POST https://github.com/login/device/code`
    - Token polling:
      - `POST https://github.com/login/oauth/access_token`
+   - Optional enterprise host:
+     - set Copilot `enterpriseHost` in `~/.codexbar/config.json` or the provider settings UI
+     - CodexBar normalizes values such as `https://octocorp.ghe.com/login` to `octocorp.ghe.com`
+     - device flow uses `https://<enterpriseHost>/login/...`
    - Scope: `read:user`.
    - Token stored in config:
      - `~/.codexbar/config.json` → `providers[].apiKey` for `copilot`
+     - token accounts use `providers[].tokenAccounts`
 
 2) **Usage fetch**
    - `GET https://api.github.com/copilot_internal/user`
+   - With an enterprise host, the API host is `api.<enterpriseHost>`.
    - Headers:
      - `Authorization: token <github_oauth_token>`
      - `Accept: application/json`
@@ -30,9 +36,29 @@ Copilot uses GitHub OAuth device flow and the Copilot internal usage API. No bro
      - `User-Agent: GitHubCopilotChat/0.26.7`
      - `X-Github-Api-Version: 2025-04-01`
 
+3) **Budget fetch** (optional GitHub web endpoint, best-effort)
+   - Disabled by default. The Copilot provider's "Budget extras" setting must be enabled before CodexBar imports
+     github.com cookies or renders budget bars.
+   - CodexBar asks the logged-in GitHub web endpoint for customer-scope budgets:
+     - `GET https://github.com/settings/billing/budgets?page=<page>&page_size=10&scope=customer`
+   - Headers:
+     - `Cookie: <github.com browser cookies>`
+     - `Accept: application/json`
+     - `X-Requested-With: XMLHttpRequest`
+     - `GitHub-Verified-Fetch: true`
+     - `X-Fetch-Nonce: <fresh nonce when available>`
+   - CodexBar first tries to read a fresh nonce from `https://github.com/settings/billing/budgets`, then calls the JSON
+     endpoint. If GitHub rejects the web request, CodexBar keeps the normal Copilot quota bars and omits budget bars.
+   - This is intentionally not the public GitHub REST billing API. The REST API did not expose the personal budget list
+     for the tested individual account.
+
 ## Snapshot mapping
 - Primary: `quotaSnapshots.premiumInteractions` percent remaining → used percent.
 - Secondary: `quotaSnapshots.chat` percent remaining → used percent.
+- Extra: positive Copilot billing budgets from the GitHub web endpoint → `extraRateWindows`, only when "Budget extras"
+  is enabled.
+  - Product budget: `copilot`
+  - SKU budgets: `copilot_premium_request`, `copilot_agent_premium_request`, `spark_premium_request`
 - Reset dates are not provided by the API.
 - Plan label from `copilotPlan`.
 
diff --git a/docs/crof.md b/docs/crof.md
new file mode 100644
index 0000000000..59fd9b72ff
--- /dev/null
+++ b/docs/crof.md
@@ -0,0 +1,42 @@
+---
+summary: "Crof provider data source: API key + usage_api request quota."
+read_when:
+  - Adding or tweaking Crof usage parsing
+  - Updating Crof API key handling
+  - Documenting Crof reset behavior
+---
+
+# Crof provider
+
+Crof is API-only. CodexBar reads `GET https://crof.ai/usage_api/` with a
+Bearer token and displays the returned request quota and dollar credit balance.
+
+## Data sources
+
+1. **API key** supplied via `CROF_API_KEY`, `CROFAI_API_KEY`, or Settings →
+   Providers → Crof. Settings values are stored in `~/.codexbar/config.json`.
+2. **Usage endpoint**
+   - `GET https://crof.ai/usage_api/`
+   - Request headers: `Authorization: Bearer <api key>`, `Accept: application/json`
+   - Response fields: `credits`, `requests_plan`, `usable_requests`
+
+## Usage details
+
+- The primary row shows request quota with the exact usable request count on the right.
+  The visible remaining percent is floored so partially used quotas like `998/1000`
+  do not round up to `100% left`.
+- Crof support said quota reset is around midnight Central time; CodexBar models this
+  as the next `America/Chicago` midnight so daylight saving time maps to GMT-5 when
+  appropriate.
+- The secondary row shows the current Crof dollar balance, floored to cents so tiny
+  microcent-level burns never overstate the remaining balance.
+- Reset timing is inferred until Crof exposes reset metadata in the usage API.
+- The provider icon is SVG and CodexBar renders it as a template image so it
+  matches the other monochrome provider icons.
+- Dashboard: `https://crof.ai/dashboard`.
+
+## Related files
+
+- `Sources/CodexBarCore/Providers/Crof/`
+- `Sources/CodexBar/Providers/Crof/`
+- `Tests/CodexBarTests/CrofUsageFetcherTests.swift`
diff --git a/docs/cursor.md b/docs/cursor.md
index 2b4ae271e4..d303fdfe96 100644
--- a/docs/cursor.md
+++ b/docs/cursor.md
@@ -8,7 +8,7 @@ read_when:
 
 # Cursor provider
 
-Cursor is web-only. Usage is fetched via browser cookies or a stored WebKit session.
+Cursor is primarily web-backed. Usage is fetched via browser cookies or a stored WebKit session, with Cursor.app local auth as a final fallback.
 
 ## Data sources + fallback order
 
@@ -29,6 +29,13 @@ Cursor is web-only. Usage is fetched via browser cookies or a stored WebKit sess
    - Login teardown uses `WebKitTeardown` to avoid Intel WebKit crashes.
    - Stored at: `~/Library/Application Support/CodexBar/cursor-session.json`.
 
+4) **Cursor.app local auth** (last fallback)
+   - Reads Cursor.app's VS Code-style global state DB for the local app bearer token.
+   - File: `~/Library/Application Support/Cursor/User/globalStorage/state.vscdb`.
+   - Used only after cookie/session sources fail so existing account-selection precedence stays stable.
+   - Derives Cursor's first-party web-session cookie, then uses the same usage and account endpoints as browser sessions.
+   - Account identity comes from that authenticated session; cached app profile fields are not mixed across accounts.
+
 Manual option:
 - Preferences → Providers → Cursor → Cookie source → Manual.
 - Paste the `Cookie:` header from a cursor.com request.
@@ -46,10 +53,24 @@ Manual option:
 - Chrome/Chromium forks: `~/Library/Application Support/Google/Chrome/*/Cookies`
 - Firefox: `~/Library/Application Support/Firefox/Profiles/*/cookies.sqlite`
 
+## Local storage footprint
+When **Settings → Advanced → Track provider local storage** is enabled, CodexBar measures:
+- `~/Library/Application Support/Cursor`
+- `~/Library/Application Support/Caches/cursor-updater`
+- `~/.cursor`
+- `~/Library/Caches/Cursor`
+- `~/Library/Caches/com.todesktop.230313mzl4w4u92`
+- `~/Library/Caches/com.todesktop.230313mzl4w4u92.ShipIt`
+- `~/Library/Caches/cursor-compile-cache`
+- `~/Library/HTTPStorages/com.todesktop.230313mzl4w4u92`
+
+The storage detail lists measured paths and their sizes. CodexBar does not delete Cursor data.
+
 ## Snapshot mapping
 - Primary: plan usage percent (included plan).
-- Secondary: on-demand usage percent (individual usage).
-- Provider cost: on-demand usage USD (limit when known).
+- Secondary: Auto + Composer usage percent.
+- Tertiary: API (named model) usage percent.
+- Provider cost: Extra usage USD. A capped individual budget wins; team accounts without a user cap use the shared team on-demand budget.
 - Reset: billing cycle end date.
 
 ## Key files
diff --git a/docs/deepgram.md b/docs/deepgram.md
new file mode 100644
index 0000000000..bda08e7168
--- /dev/null
+++ b/docs/deepgram.md
@@ -0,0 +1,111 @@
+---
+summary: "Deepgram provider: API key setup, project discovery, and usage-breakdown metrics."
+read_when:
+  - Debugging Deepgram API key or project selection
+  - Updating Deepgram usage parsing or menu display
+  - Explaining Deepgram setup to users
+---
+
+# Deepgram Provider
+
+[Deepgram](https://deepgram.com) is a speech AI platform that provides APIs for speech-to-text, text-to-speech, audio intelligence, and related voice features.
+
+## Authentication
+
+Deepgram uses API key authentication. Get your API key from the [Deepgram Console](https://console.deepgram.com).
+
+The API key must have access to the project you want to query. For usage data, the key also needs the `usage:read` scope for that project.
+
+### Environment Variables
+
+Set the `DEEPGRAM_API_KEY` environment variable:
+
+```bash
+export DEEPGRAM_API_KEY="dg_..."
+```
+
+Optionally set a Deepgram project ID:
+
+```bash
+export DEEPGRAM_PROJECT_ID="your-project-uuid"
+```
+
+If `DEEPGRAM_PROJECT_ID` is omitted, CodexBar calls Deepgram's project list endpoint and aggregates usage across all projects visible to the API key.
+
+### Settings
+
+You can also configure the API key and optional project ID in CodexBar Settings → Providers → Deepgram.
+
+### CLI config
+
+```bash
+printf '%s' "$DEEPGRAM_API_KEY" | codexbar config set-api-key --provider deepgram --stdin
+```
+
+## Data Source
+
+The Deepgram provider fetches summarized usage data from the Deepgram Management API.
+
+1. **Projects API** (`/v1/projects`): Lists projects visible to the API key when no project ID is configured.
+2. **Usage Breakdown API** (`/v1/projects/{PROJECT_ID}/usage/breakdown`): Returns summarized project usage over a date range. The response includes fields such as `start`, `end`, `resolution`, and `results`.
+
+Each usage result may include:
+
+* `start`
+* `end`
+* `hours`
+* `total_hours`
+* `agent_hours`
+* `tokens_in`
+* `tokens_out`
+* `tts_characters`
+* `requests`
+
+Deepgram's usage breakdown endpoint supports querying with `start` and `end` date parameters. The response includes summarized usage results for the selected period.
+
+## Display
+
+The Deepgram menu card shows:
+
+* **Usage notes**: Request count, total audio hours, total billable hours, agent hours, token totals, and TTS characters when returned by Deepgram
+* **Identity**: Project name, project ID, or aggregated project count
+
+Deepgram does not currently provide a credit balance through this provider. The provider displays usage, not remaining credits.
+
+## CLI Usage
+
+```bash
+codexbar --provider deepgram
+codexbar -p dg  # alias
+```
+
+## Environment Variables
+
+* **DEEPGRAM_API_KEY**: Your Deepgram API key. Required.
+* **DEEPGRAM_PROJECT_ID**: Optional Deepgram project UUID. Leave unset to aggregate all visible projects.
+* **DEEPGRAM_API_URL**: Override the base API URL. Optional, defaults to `https://api.deepgram.com/v1`.
+  Override values must be explicit HTTPS URLs or bare hosts/paths that CodexBar normalizes to HTTPS. Explicit
+  `http://` URLs fail closed before the Deepgram API key is attached to a request. For local proxy testing, use an
+  HTTPS listener or omit the scheme and let CodexBar normalize the override to HTTPS.
+
+## Permissions
+
+The API key must have permission to read usage data for the configured project.
+
+If the key is valid but lacks the correct scope, Deepgram may return an error like:
+
+```text
+INSUFFICIENT_PERMISSIONS
+Your account does not have the required scope to perform that action for this project.
+Check that your account has the 'usage:read' scope for this project.
+```
+
+In that case, create or update a Deepgram API key with the `usage:read` scope for the target project.
+
+## Notes
+
+* Deepgram usage data is project-scoped.
+* The project ID should be the project UUID, not just the project display name.
+* The provider uses `Authorization: Token <API_KEY>` for requests.
+* This provider currently reports usage metrics, not credit balance or per-request cost.
+* Summarized usage data is not limited to 90 days, while console logs are limited to 90 days.
diff --git a/docs/deepseek.md b/docs/deepseek.md
new file mode 100644
index 0000000000..1db239ed36
--- /dev/null
+++ b/docs/deepseek.md
@@ -0,0 +1,39 @@
+---
+summary: "DeepSeek provider data sources: API key + balance endpoint."
+read_when:
+  - Adding or tweaking DeepSeek balance parsing
+  - Updating API key handling
+  - Documenting new provider behavior
+---
+
+# DeepSeek provider
+
+DeepSeek is API-only. Balance is reported by `GET https://api.deepseek.com/user/balance`,
+so CodexBar only needs a valid API key to show your remaining credit balance.
+
+## Data sources
+
+1. **API key** supplied via `DEEPSEEK_API_KEY` / `DEEPSEEK_KEY`, or selected from DeepSeek token accounts in `~/.codexbar/config.json`.
+2. **Balance endpoint**
+   - `GET https://api.deepseek.com/user/balance`
+   - Request headers: `Authorization: Bearer <api key>`, `Accept: application/json`
+   - Response contains `is_available`, and a `balance_infos` array with per-currency entries
+     (`total_balance`, `granted_balance`, `topped_up_balance`).
+
+## Usage details
+
+- The menu card shows total balance with the paid vs. granted breakdown:
+  e.g. `$50.00 (Paid: $40.00 / Granted: $10.00)`.
+- The API separates granted balance from topped-up balance; CodexBar labels these as granted vs. paid credit.
+- When multiple currencies are present, USD is shown preferentially.
+- If total balance is zero, CodexBar shows an add-credits message. If balance is nonzero but `is_available` is false, it shows "Balance unavailable for API calls".
+- There is no session or weekly window — DeepSeek does not expose per-window quota via API.
+- Token-account selection injects the selected key into the fetch environment; otherwise CodexBar reads `DEEPSEEK_API_KEY` / `DEEPSEEK_KEY`.
+
+## Key files
+
+- `Sources/CodexBarCore/Providers/DeepSeek/DeepSeekProviderDescriptor.swift` (descriptor + fetch strategy)
+- `Sources/CodexBarCore/Providers/DeepSeek/DeepSeekUsageFetcher.swift` (HTTP client + JSON parser)
+- `Sources/CodexBarCore/Providers/DeepSeek/DeepSeekSettingsReader.swift` (env var resolution)
+- `Sources/CodexBar/Providers/DeepSeek/DeepSeekProviderImplementation.swift` (provider activation and token-account visibility)
+- `Sources/CodexBarCore/TokenAccountSupportCatalog+Data.swift` (DeepSeek token-account injection)
diff --git a/docs/devin.md b/docs/devin.md
new file mode 100644
index 0000000000..df4f146960
--- /dev/null
+++ b/docs/devin.md
@@ -0,0 +1,43 @@
+---
+summary: "Devin provider auth, quota endpoint, and setup."
+read_when:
+  - Adding or modifying the Devin provider
+  - Debugging Devin localStorage import or quota parsing
+  - Explaining Devin setup
+---
+
+# Devin Provider
+
+The Devin provider tracks included daily and weekly usage quotas from
+[app.devin.ai](https://app.devin.ai).
+
+## Setup
+
+1. Sign in to Devin in Google Chrome.
+2. Open the organization Usage & Limits page once.
+3. Enable **Devin** in **Settings → Providers**.
+
+Automatic mode reads only the Devin session and organization metadata from Chrome localStorage. It does not scan other
+browsers. CodexBar sends the session token only to `https://app.devin.ai`.
+
+## Manual Auth
+
+Set **Auth source** to **Manual**, then paste either the bare token or the full `Authorization: Bearer ...` header value
+from an app.devin.ai API request. The optional organization field accepts a slug, an internal `org_...` ID, or the full
+organization URL.
+
+Environment overrides:
+
+- `DEVIN_BEARER_TOKEN` or `DEVIN_AUTHORIZATION`
+- `DEVIN_ORGANIZATION` or `DEVIN_ORG`
+
+## Data Source
+
+CodexBar requests:
+
+```text
+GET https://app.devin.ai/api/<internal-org-id>/billing/quota/usage
+```
+
+The response supplies daily and weekly usage percentages plus reset timestamps. If Devin changes or expires the browser
+session, sign in again and refresh CodexBar.
diff --git a/docs/doubao.md b/docs/doubao.md
new file mode 100644
index 0000000000..40c7cfa2d4
--- /dev/null
+++ b/docs/doubao.md
@@ -0,0 +1,22 @@
+---
+summary: "Doubao provider notes: API-key auth and Volcengine Ark request-limit tracking."
+read_when:
+  - Adding or modifying the Doubao provider
+  - Debugging Doubao API-key setup
+  - Explaining Doubao usage display
+---
+
+# Doubao Provider
+
+Doubao tracks Volcengine Ark request-limit headers by probing the chat-completions endpoint with a configured API key.
+
+## Setup
+1. Enable **Doubao** in Settings → Providers.
+2. Paste an API key in the provider settings, or set `ARK_API_KEY`, `VOLCENGINE_API_KEY`, or `DOUBAO_API_KEY`.
+3. Refresh provider usage.
+
+## Behavior
+- Endpoint: `POST https://ark.cn-beijing.volces.com/api/coding/v3/chat/completions`
+- Probe models: `doubao-seed-2.0-code`, `doubao-1.5-pro-32k`, `doubao-lite-32k`
+- Reads `x-ratelimit-remaining-requests`, `x-ratelimit-limit-requests`, and `x-ratelimit-reset-requests` when returned.
+- If the key is valid but rate-limit headers are missing, CodexBar shows the key as active and links to the dashboard for details.
diff --git a/docs/elevenlabs.md b/docs/elevenlabs.md
new file mode 100644
index 0000000000..dae8b14b4d
--- /dev/null
+++ b/docs/elevenlabs.md
@@ -0,0 +1,63 @@
+---
+summary: "ElevenLabs provider notes: API key setup and subscription usage fields."
+read_when:
+  - Adding or modifying the ElevenLabs provider
+  - Debugging ElevenLabs API keys or subscription usage parsing
+  - Adjusting ElevenLabs credit or voice-slot labels
+---
+
+# ElevenLabs Provider
+
+The ElevenLabs provider reads subscription usage from the ElevenLabs API using an API key.
+
+## Features
+
+- Character credit usage from the current subscription period.
+- Reset timing when the API returns `next_character_count_reset_unix`.
+- Voice slot and professional voice slot usage when those fields are present.
+- Plan/status text from the subscription response.
+
+## Setup
+
+### CLI
+
+Store the API key without opening Settings:
+
+```bash
+printf '%s' "$ELEVENLABS_API_KEY" | codexbar config set-api-key --provider elevenlabs --stdin
+```
+
+This trims the piped key, writes it to `~/.codexbar/config.json` with restrictive permissions, and enables ElevenLabs by default. Use `--no-enable` to save the key without enabling the provider.
+
+### Settings
+
+1. Open **Settings -> Providers**
+2. Enable **ElevenLabs**
+3. Open `https://elevenlabs.io/app/settings/api-keys`
+4. Create or copy an API key
+5. Paste the key into CodexBar's ElevenLabs provider settings
+
+### Environment Variables
+
+CodexBar also accepts these environment variables:
+
+- `ELEVENLABS_API_KEY`
+- `XI_API_KEY`
+
+For tests or self-hosted/proxy setups, override the API base URL with `ELEVENLABS_API_URL`.
+
+## How It Works
+
+- Endpoint: `GET https://api.elevenlabs.io/v1/user/subscription`
+- Auth header: `xi-api-key`
+- Fields used: `character_count`, `character_limit`, `voice_slots_used`, `voice_limit`, `professional_voice_slots_used`, `professional_voice_limit`, `tier`, `status`, `next_character_count_reset_unix`
+
+## Troubleshooting
+
+### "Missing ElevenLabs API key"
+
+Set the key with `codexbar config set-api-key --provider elevenlabs --stdin`, add it in **Settings -> Providers -> ElevenLabs**, set `ELEVENLABS_API_KEY`, or configure an ElevenLabs token account.
+
+### "ElevenLabs API error"
+
+Confirm the API key is valid and that the current network can reach `api.elevenlabs.io`.
diff --git a/docs/grok.md b/docs/grok.md
new file mode 100644
index 0000000000..452102be59
--- /dev/null
+++ b/docs/grok.md
@@ -0,0 +1,151 @@
+---
+summary: "Grok provider data sources: ACP JSON-RPC, grok.com billing fallback, OAuth credentials, and local session signals."
+read_when:
+  - Debugging Grok billing/usage parsing
+  - Updating `grok agent stdio` JSON-RPC integration
+  - Adjusting `~/.grok/auth.json` credential reading
+---
+
+# Grok provider
+
+Grok uses xAI's official Grok Build CLI (`grok`, released 2026-05-14). Usage data is
+fetched via the ACP JSON-RPC `x.ai/billing` extension method over `grok agent stdio`
+when available, then via grok.com's billing gRPC-web endpoint using the signed-in
+browser session when the CLI surface does not expose billing.
+
+## Data sources + fallback order
+
+1) **`~/.grok/auth.json` (primary; always works for SuperGrok subscribers)**
+   - Reads `email`, `team_id`, `first_name`/`last_name`, plan-hint (`auth_mode`)
+     for the identity row in the menu.
+2) **`grok agent stdio` ACP JSON-RPC** (best-effort, currently disabled in grok 0.1.210)
+   - We spawn `grok agent stdio` and call `initialize` + `x.ai/billing` (no params).
+   - **Known limitation:** in grok 0.1.210 the `x.ai/billing` extension method
+     is only wired in the interactive TUI; the agent-stdio surface returns
+     `-32601 Method not found`. The provider degrades silently to identity-only
+     when this happens. When xAI exposes billing on the agent protocol, no
+     code change is required.
+   - One non-obvious quirk: grok's ACP parser does not unescape `\/` in method
+     names. `Foundation.JSONSerialization.data` defaults to escaping forward
+     slashes, so payloads must be re-encoded with `\/` → `/` before being
+     written to stdin or grok will silently drop them (12s client-side
+     timeout instead of the expected error response).
+3) **grok.com billing gRPC-web fallback** (best-effort)
+   - POSTs an empty gRPC-web protobuf request to
+     `https://grok.com/grok_api_v2.GrokBuildBilling/GetGrokCreditsConfig`.
+   - Uses grok.com browser session cookies. When a non-expired
+     `~/.grok/auth.json` token is available, CodexBar first sends it with each
+     browser session, then retries that session with cookies only.
+   - CodexBar imports Chrome only by default to avoid unrelated browser
+     Keychain prompts.
+   - CLI/test runtime does not import browser cookies unless
+     `CODEXBAR_ALLOW_BROWSER_COOKIE_IMPORT=1` is set.
+   - `~/.grok/auth.json` is still used for identity and as a last best-effort
+     bearer-only probe after browser sessions fail. Expired tokens are not sent.
+   - Parses the returned protobuf enough to recover used percent and
+     reset timestamp, accepting both gRPC-web frames and the raw protobuf form
+     returned by some successful requests. A current billing period with an
+     omitted proto3 `credit_usage_percent` is treated as zero usage. This keeps
+     billing visible when `grok agent stdio` returns `Method not found`.
+4) **Local session signals** (informational fallback)
+   - Walks `~/.grok/sessions/<encoded-cwd>/<session-id>/signals.json` files (last 30 days).
+   - Aggregates `totalTokensBeforeCompaction`, `contextTokensUsed`, `modelsUsed`,
+     and the most recent session timestamp.
+
+## OAuth credentials
+
+- File: `~/.grok/auth.json` (path overridable via `GROK_HOME`).
+- Top-level keys are OIDC scope URLs. CodexBar prefers entries under
+  `https://auth.x.ai::<client-id>` (SuperGrok), falling back to
+  `https://accounts.x.ai/sign-in` (legacy session).
+- Required fields per entry: `key` (bearer token), `refresh_token`, `expires_at`,
+  `auth_mode`, `email`, `team_id`, `user_id`, `first_name`/`last_name`.
+- Tokens are issued by `grok login` and expire after ~7 days; refresh is handled by
+  the CLI itself (CodexBar does not refresh; it just reads the cached credential).
+
+## JSON-RPC contract
+
+- Transport: stdin/stdout, newline-delimited JSON-RPC 2.0 (no Content-Length framing).
+- `initialize` params:
+  ```json
+  {
+    "protocolVersion": "1",
+    "clientCapabilities": {
+      "fs": { "readTextFile": false, "writeTextFile": false },
+      "terminal": false
+    }
+  }
+  ```
+- `x.ai/billing` result shape (all monetary values are `{ val: <cents> }`):
+  ```json
+  {
+    "billingCycle": {
+      "billingPeriodStart": "2026-05-01T00:00:00Z",
+      "billingPeriodEnd": "2026-06-01T00:00:00Z"
+    },
+    "monthlyLimit": { "val": 99900 },
+    "onDemandCap": { "val": 0 },
+    "on_demand_enabled": false,
+    "disabledByConfig": false,
+    "usage": {
+      "includedUsed": { "val": 12345 },
+      "onDemandUsed": { "val": 0 },
+      "totalUsed": { "val": 12345 }
+    }
+  }
+  ```
+- Auth errors surface as JSON-RPC errors with the message
+  `"Authentication required to fetch billing data. Run 'grok login' to authenticate."`.
+- Timeouts: 8s for `initialize`, 12s for `x.ai/billing`. CodexBar terminates the
+  child `grok` process on timeout to avoid leaking subprocesses.
+
+## Mapping to `UsageSnapshot`
+
+- **Primary window** = credit usage (against the subscription/included limit):
+  - CLI RPC: `usedPercent` = `usage.totalUsed.val / monthlyLimit.val * 100`;
+    `resetsAt` = `billingCycle.billingPeriodEnd`.
+  - grok.com fallback: `usedPercent` and `resetsAt` parsed from the gRPC-web
+    billing protobuf.
+  - The UI label for the live usage bar is dynamic: "Weekly" or "Monthly"
+    when `resetsAt` matches a common cycle, falling back to the registered
+    "Credits" label otherwise. Settings and history views continue to use
+    "Credits" as the stable metric name.
+- **Identity**:
+  - `accountEmail` from credential `email`.
+  - `accountOrganization` from credential `team_id`.
+  - `loginMethod` = "SuperGrok" for OIDC, otherwise the raw `auth_mode`.
+
+## Local fallback (`~/.grok/sessions/`)
+
+Each session directory contains `signals.json` with fields like:
+
+```json
+{
+  "turnCount": 1,
+  "contextTokensUsed": 2968,
+  "contextWindowTokens": 512000,
+  "totalTokensBeforeCompaction": 0,
+  "modelsUsed": ["grok-build"],
+  "primaryModelId": "grok-build",
+  "sessionDurationSeconds": 47
+}
+```
+
+CodexBar aggregates these into a `GrokLocalSessionSummary` (session count, total
+tokens, last session time, primary model) and exposes it for diagnostics even when
+the RPC path is unavailable.
+
+## Status
+
+xAI has not exposed a Statuspage-style status feed yet. The "View Status" link
+points to `https://status.x.ai`.
+
+## Key files
+
+- `Sources/CodexBarCore/Providers/Grok/GrokProviderDescriptor.swift`
+- `Sources/CodexBarCore/Providers/Grok/GrokAuth.swift`
+- `Sources/CodexBarCore/Providers/Grok/GrokRPCClient.swift`
+- `Sources/CodexBarCore/Providers/Grok/GrokWebBillingFetcher.swift`
+- `Sources/CodexBarCore/Providers/Grok/GrokStatusProbe.swift`
+- `Sources/CodexBarCore/Providers/Grok/GrokLocalSessionScanner.swift`
+- `Sources/CodexBar/Providers/Grok/GrokProviderImplementation.swift`
diff --git a/docs/groqcloud.md b/docs/groqcloud.md
new file mode 100644
index 0000000000..fd5a875c24
--- /dev/null
+++ b/docs/groqcloud.md
@@ -0,0 +1,31 @@
+---
+summary: "GroqCloud provider setup and Prometheus metrics usage source."
+read_when:
+  - Configuring GroqCloud usage tracking
+  - Debugging GroqCloud request or token-rate display
+---
+
+# GroqCloud
+
+CodexBar's GroqCloud provider is separate from the xAI Grok provider. It uses a GroqCloud API key and the Enterprise
+Prometheus metrics API.
+
+## Setup
+
+Store the key in the shared app/CLI config:
+
+```bash
+printf '%s' "$GROQ_API_KEY" | codexbar config set-api-key --provider groq --stdin
+```
+
+Or set `GROQ_API_KEY` in the process environment. `GROQ_API_URL` can override the default `https://api.groq.com/v1`
+base URL for private gateways.
+
+## Menu display
+
+- Primary: requests per minute.
+- Secondary: tokens per minute.
+- Tertiary: prompt cache hits per minute when the metric exists.
+- Dashboard link: GroqCloud metrics dashboard.
+
+If the key lacks Prometheus metrics access, CodexBar shows the API error instead of guessing from unrelated endpoints.
diff --git a/docs/index.html b/docs/index.html
index 5c662d2ab5..46a36047bf 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -3,174 +3,354 @@
   <head>
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>CodexBar</title>
+    <title>CodexBar — every AI coding limit in your menu bar</title>
     <meta
       name="description"
-      content="Tiny macOS menu bar app that keeps your Codex, Claude Code, Cursor, Gemini, Antigravity, Droid (Factory), Copilot, and z.ai limits visible."
+      content="A tiny macOS menu bar app that tracks AI coding-provider usage windows, credits, costs, and resets across 53 providers — Codex, OpenAI, Claude, Cursor, Gemini, Copilot, LiteLLM, and more."
     />
-    <meta name="theme-color" content="#0b1016" />
+    <meta name="theme-color" content="#0a0a0c" />
     <link rel="canonical" href="https://codexbar.app/" />
+    <link rel="alternate" hreflang="x-default" href="https://codexbar.app/" />
+    <link rel="alternate" hreflang="en" href="https://codexbar.app/?lang=en" />
+    <link rel="alternate" hreflang="zh-CN" href="https://codexbar.app/?lang=zh-CN" />
+    <link rel="alternate" hreflang="zh-TW" href="https://codexbar.app/?lang=zh-TW" />
+    <link rel="alternate" hreflang="ja" href="https://codexbar.app/?lang=ja-JP" />
+    <link rel="alternate" hreflang="es" href="https://codexbar.app/?lang=es" />
+    <link rel="alternate" hreflang="pt-BR" href="https://codexbar.app/?lang=pt-BR" />
+    <link rel="alternate" hreflang="ko" href="https://codexbar.app/?lang=ko" />
+    <link rel="alternate" hreflang="de" href="https://codexbar.app/?lang=de" />
+    <link rel="alternate" hreflang="fr" href="https://codexbar.app/?lang=fr" />
+    <link rel="alternate" hreflang="ar" href="https://codexbar.app/?lang=ar" />
+    <link rel="alternate" hreflang="it" href="https://codexbar.app/?lang=it" />
+    <link rel="alternate" hreflang="vi" href="https://codexbar.app/?lang=vi" />
+    <link rel="alternate" hreflang="nl" href="https://codexbar.app/?lang=nl" />
+    <link rel="alternate" hreflang="tr" href="https://codexbar.app/?lang=tr" />
+    <link rel="alternate" hreflang="uk" href="https://codexbar.app/?lang=uk" />
+    <link rel="alternate" hreflang="id" href="https://codexbar.app/?lang=id" />
+    <link rel="alternate" hreflang="pl" href="https://codexbar.app/?lang=pl" />
+    <link rel="alternate" hreflang="fa" href="https://codexbar.app/?lang=fa" />
+    <link rel="alternate" hreflang="th" href="https://codexbar.app/?lang=th" />
+    <link rel="alternate" hreflang="ca" href="https://codexbar.app/?lang=ca" />
+    <link rel="alternate" hreflang="sv" href="https://codexbar.app/?lang=sv" />
 
     <meta property="og:title" content="CodexBar" />
     <meta
       property="og:description"
-      content="Tiny macOS menu bar app that keeps your Codex, Claude Code, Cursor, Gemini, Antigravity, Droid (Factory), Copilot, and z.ai limits visible."
+      content="Track usage windows, credits, and resets across 53 AI coding providers from your macOS menu bar."
     />
     <meta property="og:type" content="website" />
     <meta property="og:url" content="https://codexbar.app/" />
-    <meta property="og:image" content="https://codexbar.app/codexbar.png" />
+    <meta property="og:image" content="https://codexbar.app/social.png" />
+    <meta property="og:image:width" content="1200" />
+    <meta property="og:image:height" content="630" />
+    <meta name="twitter:image" content="https://codexbar.app/social.png" />
     <meta name="twitter:card" content="summary_large_image" />
 
     <link rel="icon" href="./icon.png" type="image/png" />
     <link rel="apple-touch-icon" href="./icon.png" />
-    <link rel="stylesheet" href="./site.css?v=a1b2c3d" />
+    <script>
+      (function () {
+        try {
+          var supported = ['en', 'zh-CN', 'zh-TW', 'ja-JP', 'es', 'pt-BR', 'ko', 'de', 'fr', 'ar', 'it', 'vi', 'nl', 'tr', 'uk', 'id', 'pl', 'fa', 'th', 'ca', 'sv'];
+          var aliases = { 'zh-hans': 'zh-CN', 'zh-cn': 'zh-CN', 'zh-hant': 'zh-TW', 'zh-tw': 'zh-TW', 'zh-hk': 'zh-TW', ja: 'ja-JP', pt: 'pt-BR', 'pt-br': 'pt-BR' };
+          function normalizeLocale(value) {
+            if (!value) return null;
+            var lower = value.toLowerCase();
+            if (aliases[lower]) return aliases[lower];
+            for (var i = 0; i < supported.length; i += 1) {
+              if (supported[i].toLowerCase() === lower || lower.indexOf(supported[i].toLowerCase() + '-') === 0) return supported[i];
+            }
+            return null;
+          }
+          var queryLocale = normalizeLocale(new URLSearchParams(location.search).get('lang'));
+          var storedLocale = normalizeLocale(localStorage.getItem('codexbar-language'));
+          var browserLocale = null;
+          var browserLanguages = navigator.languages || [navigator.language];
+          for (var i = 0; i < browserLanguages.length && !browserLocale; i += 1) browserLocale = normalizeLocale(browserLanguages[i]);
+          var locale = queryLocale || storedLocale || browserLocale || 'en';
+          document.documentElement.lang = locale;
+          document.documentElement.dir = locale === 'ar' || locale === 'fa' ? 'rtl' : 'ltr';
+          document.documentElement.dataset.locale = locale;
+
+          var queryTheme = new URLSearchParams(location.search).get('theme');
+          var theme = queryTheme === 'light' || queryTheme === 'dark'
+            ? queryTheme
+            : localStorage.getItem('codexbar-theme');
+          if (theme === 'light' || theme === 'dark') document.documentElement.dataset.theme = theme;
+        } catch (_) {}
+      })();
+    </script>
+    <link rel="stylesheet" href="./site.css?v=10" />
   </head>
   <body>
-    <main class="wrap">
-      <header class="top" data-animate="1">
-        <a class="brand" href="https://github.com/steipete/CodexBar" aria-label="CodexBar on GitHub">
-          <span class="name">
-            <h1 class="title">CodexBar</h1>
-            <p class="tagline">Codex, Claude Code, Cursor, Gemini, Antigravity, Droid, Copilot, z.ai limits.</p>
-          </span>
-        </a>
-        <nav class="links" aria-label="Links">
-          <a class="btn primary" href="https://github.com/steipete/CodexBar/releases/latest">Download</a>
-          <a class="btn ghost" href="https://github.com/steipete/CodexBar">Source</a>
-        </nav>
-      </header>
+    <div class="backdrop" aria-hidden="true">
+      <span class="plane p1"></span>
+      <span class="plane p2"></span>
+      <span class="trace t1"></span>
+      <span class="trace t2"></span>
+      <span class="trace t3"></span>
+      <span class="trace t4"></span>
+    </div>
+    <header class="masthead">
+      <a class="brand" href="./" aria-label="CodexBar">
+        <img class="mark" src="./icon.png" alt="" width="28" height="28" />
+        <span class="wordmark">CodexBar</span>
+      </a>
+      <nav class="nav" aria-label="Primary" data-i18n-aria-label="nav.primary">
+        <a class="nav-link" href="https://github.com/steipete/CodexBar/blob/main/docs/providers.md" data-i18n="nav.docs">Docs</a>
+        <a class="nav-link" href="https://github.com/steipete/CodexBar" data-i18n="nav.source">Source</a>
+        <label class="language-control" for="language-select">
+          <span class="sr-only" data-i18n="nav.language">Language</span>
+          <select id="language-select" name="language" class="language-select" aria-label="Language" data-i18n-aria-label="nav.language">
+            <option value="en">English</option>
+            <option value="zh-CN">简体中文</option>
+            <option value="zh-TW">繁體中文</option>
+            <option value="ja-JP">日本語</option>
+            <option value="es">Español</option>
+            <option value="pt-BR">Português (BR)</option>
+            <option value="ko">한국어</option>
+            <option value="de">Deutsch</option>
+            <option value="fr">Français</option>
+            <option value="ar">العربية</option>
+            <option value="it">Italiano</option>
+            <option value="vi">Tiếng Việt</option>
+            <option value="nl">Nederlands</option>
+            <option value="tr">Türkçe</option>
+            <option value="uk">Українська</option>
+            <option value="id">Bahasa Indonesia</option>
+            <option value="pl">Polski</option>
+            <option value="fa">فارسی</option>
+            <option value="th">ไทย</option>
+            <option value="ca">Català</option>
+            <option value="sv">Svenska</option>
+          </select>
+          <svg width="12" height="12" viewBox="0 0 12 12" fill="none" stroke="currentColor" stroke-width="1.5" aria-hidden="true">
+            <path d="m3 4.5 3 3 3-3" />
+          </svg>
+        </label>
+        <button class="theme-toggle" type="button" aria-label="Switch color theme" aria-pressed="false" title="Switch color theme">
+          <svg class="sun" width="16" height="16" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" aria-hidden="true">
+            <circle cx="8" cy="8" r="2.75" />
+            <path d="M8 1.5v1.25M8 13.25v1.25M1.5 8h1.25M13.25 8h1.25M3.4 3.4l.9.9M11.7 11.7l.9.9M12.6 3.4l-.9.9M4.3 11.7l-.9.9" />
+          </svg>
+          <svg class="moon" width="16" height="16" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+            <path d="M13.2 10.1A5.8 5.8 0 0 1 5.9 2.8a6 6 0 1 0 7.3 7.3Z" />
+          </svg>
+        </button>
+        <a class="btn primary" href="https://github.com/steipete/CodexBar/releases/latest" data-i18n="nav.download">Download</a>
+      </nav>
+    </header>
 
-      <section class="hero" aria-label="Overview">
-        <div class="copy" data-animate="2">
-          <div class="badges" aria-label="Highlights">
-            <span class="badge">macOS 14+</span>
-            <span class="badge">Apple Silicon + Intel</span>
-            <span class="badge">Free &amp; open source</span>
-            <span class="badge">No passwords stored</span>
-          </div>
-          <div class="hero-heading">
-            <img class="hero-icon" src="./icon.png" alt="" aria-hidden="true" width="40" height="40" />
-            <div>
-              <h2>Stay ahead of resets.</h2>
-              <p>
-                CodexBar keeps session + weekly limits (and credits) in the menu bar, so you know when you're safe to ship.
-              </p>
-            </div>
-          </div>
-          <p class="requirement">Requirements: macOS 14+ (Apple Silicon + Intel).</p>
-          <div class="cta">
-            <a class="btn primary" href="https://github.com/steipete/CodexBar/releases/latest">Download latest</a>
-            <a class="btn" href="https://github.com/steipete/CodexBar">View on GitHub</a>
-          </div>
-          <p class="brew-line">
-            Homebrew: <code id="brew-cmd">brew install --cask steipete/tap/codexbar</code>
-            <button class="copy-btn" onclick="copyBrew()" aria-label="Copy to clipboard" title="Copy to clipboard">
-              <svg class="icon-copy" width="16" height="16" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
-                <rect x="5" y="5" width="9" height="9" rx="1.5"/>
-                <path d="M5 11H3.5A1.5 1.5 0 012 9.5v-7A1.5 1.5 0 013.5 1h7A1.5 1.5 0 0112 2.5V5"/>
+    <main>
+      <section class="lede">
+        <h1><span data-i18n="hero.prefix">Every AI coding limit,</span> <span class="grad" data-i18n="hero.accent">in your menu bar.</span></h1>
+        <p class="dek" data-i18n="hero.description">
+          CodexBar tracks usage windows, credit balances, and reset countdowns across the providers you actually pay for —
+          one status item each, or merge them into one.
+        </p>
+        <div class="actions">
+          <a class="btn primary lg" href="https://github.com/steipete/CodexBar/releases/latest" data-i18n="hero.download">Download for macOS</a>
+          <div class="brew" role="group" aria-label="Homebrew install command">
+            <code id="brew-cmd">brew install --cask steipete/tap/codexbar</code>
+            <button class="brew-copy" type="button" aria-label="Copy to clipboard" title="Copy" data-i18n-aria-label="clipboard.copy" data-i18n-title="clipboard.copy">
+              <svg class="ic" width="14" height="14" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+                <rect x="5" y="5" width="9" height="9" rx="1.5" />
+                <path d="M5 11H3.5A1.5 1.5 0 0 1 2 9.5v-7A1.5 1.5 0 0 1 3.5 1h7A1.5 1.5 0 0 1 12 2.5V5" />
               </svg>
-              <svg class="icon-check" width="16" height="16" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-                <polyline points="3 8 6 11 13 4"/>
+              <svg class="ok" width="14" height="14" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+                <polyline points="3 8 6 11 13 4" />
               </svg>
             </button>
-          </p>
-          <p class="brew-line">Linuxbrew (CLI only): <code>brew install steipete/tap/codexbar</code></p>
-          <p class="note">
-            GitHub Releases builds update via Sparkle. Homebrew installs update via <code>brew upgrade</code>.
-          </p>
-          <script>
-            function copyBrew() {
-              const cmd = document.getElementById('brew-cmd').textContent;
-              navigator.clipboard.writeText(cmd).then(() => {
-                document.querySelector('.copy-btn').classList.add('copied');
-                setTimeout(() => document.querySelector('.copy-btn').classList.remove('copied'), 1500);
-              });
-            }
-          </script>
-          <ul class="bullets" aria-label="What it does">
-            <li>One status item per provider (Codex, Claude, Cursor, Gemini, Antigravity, Droid, Copilot, z.ai, Kilo).</li>
-            <li>Session + weekly bars with reset times and optional credits.</li>
-            <li>Web-backed limits via browser cookies (Codex, Claude, Cursor, Droid).</li>
-            <li>Two-bar icon: session on top, weekly on bottom, dimmed on errors.</li>
-            <li>Minimal UI, no Dock icon.</li>
-          </ul>
+          </div>
         </div>
-        <figure class="shot hero-shot" data-animate="3">
-          <img src="./codexbar.png" alt="CodexBar menu bar popover showing session and weekly usage." />
-          <figcaption>Menu card shows session + weekly usage, resets, and credits when available.</figcaption>
-        </figure>
+        <p class="fineprint" data-i18n="hero.fineprint">Free &amp; open source · macOS 14+ · Universal via GitHub Releases and Homebrew</p>
       </section>
 
-      <section class="details" aria-label="Details" data-animate="4">
-        <div class="card">
-          <h3>Install &amp; updates</h3>
-          <p>
-            Download from GitHub Releases or install via Homebrew. Sparkle updates are enabled on GitHub builds only.
-          </p>
-        </div>
-        <div class="card">
-          <h3>Providers</h3>
-          <p>
-            Codex · Claude Code · Cursor · Gemini · Antigravity · Droid · Copilot · z.ai · Kilo<br />
-            Open to new providers — see the <a href="https://github.com/steipete/CodexBar/blob/main/docs/provider.md">provider guide</a>.
-          </p>
-        </div>
-        <div class="card">
-          <h3>Privacy</h3>
-          <p>
-            Reuses existing browser cookies (Safari/Chrome/Firefox) for dashboard access — no passwords stored. When cookies
-            are missing, CodexBar falls back to local CLI output. Audit notes in
-            <a href="https://github.com/steipete/CodexBar/issues/12">issue #12</a>.
-          </p>
-        </div>
+      <section class="providers" aria-labelledby="providers-h">
+        <header class="section-head">
+          <h2 id="providers-h" data-i18n="providers.title">53 providers, one menu bar</h2>
+          <p data-i18n="providers.description">Popular providers become status items with their own usage windows, reset countdowns, charts, and provider menus.</p>
+        </header>
+        <ul class="grid">
+        <li><a class="provider" style="--brand:#49A3B0" href="https://github.com/steipete/CodexBar/blob/main/docs/codex.md">
+          <img class="chip-logo no-bg" src="./logos/codex.svg" data-dark-src="./logos/codex-dark.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">Codex</span><span class="auth">OAuth</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#CC7C5E" href="https://github.com/steipete/CodexBar/blob/main/docs/claude.md">
+          <img class="chip-logo" src="./logos/claude.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">Claude</span><span class="auth">OAuth</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#1A1A1A" href="https://github.com/steipete/CodexBar/blob/main/docs/cursor.md">
+          <img class="chip-logo" src="./logos/cursor.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">Cursor</span><span class="auth" data-i18n="auth.cookies">Cookies</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#3B82F6" href="https://github.com/steipete/CodexBar/blob/main/docs/opencode.md">
+          <img class="chip-logo preserve-color" src="./logos/opencode.svg" data-dark-src="./logos/opencode-dark.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">OpenCode</span><span class="auth" data-i18n="auth.cookiesGo">Cookies + Go</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#FF6A00" href="https://github.com/steipete/CodexBar/blob/main/docs/alibaba-coding-plan.md">
+          <img class="chip-logo" src="./logos/alibaba.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">Alibaba</span><span class="auth" data-i18n="auth.cookies">Cookies</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#FF6A00" href="https://github.com/steipete/CodexBar/blob/main/docs/alibaba-token-plan.md">
+          <img class="chip-logo" src="./logos/alibaba.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">Alibaba Token</span><span class="auth" data-i18n="auth.cookies">Cookies</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#AB87EA" href="https://github.com/steipete/CodexBar/blob/main/docs/gemini.md">
+          <img class="chip-logo" src="./logos/gemini.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">Gemini</span><span class="auth">OAuth</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#60BA7E" href="https://github.com/steipete/CodexBar/blob/main/docs/antigravity.md">
+          <img class="chip-logo" src="./logos/antigravity.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">Antigravity</span><span class="auth" data-i18n="auth.local">Local</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#FF6B35" href="https://github.com/steipete/CodexBar/blob/main/docs/factory.md">
+          <img class="chip-logo no-bg" src="./logos/droid.svg" data-dark-src="./logos/droid-dark.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">Droid</span><span class="auth" data-i18n="auth.cookies">Cookies</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#A855F7" href="https://github.com/steipete/CodexBar/blob/main/docs/copilot.md">
+          <img class="chip-logo" src="./logos/copilot.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">Copilot</span><span class="auth" data-i18n="auth.deviceFlow">Device flow</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#0F172A" href="https://github.com/steipete/CodexBar/blob/main/docs/devin.md">
+          <img class="chip-logo" src="./logos/devin.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">Devin</span><span class="auth" data-i18n="auth.bearerLocal">Bearer / Local</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#E85A6A" href="https://github.com/steipete/CodexBar/blob/main/docs/zai.md">
+          <img class="chip-logo no-bg" src="./logos/zai.svg" data-dark-src="./logos/zai-dark.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">z.ai</span><span class="auth" data-i18n="auth.apiKey">API key</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#FE6060" href="https://github.com/steipete/CodexBar/blob/main/docs/minimax.md">
+          <img class="chip-logo" src="./logos/minimax.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">MiniMax</span><span class="auth" data-i18n="auth.apiKey">API key</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#FE603C" href="https://github.com/steipete/CodexBar/blob/main/docs/kimi.md">
+          <img class="chip-logo" src="./logos/kimi.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">Kimi</span><span class="auth" data-i18n="auth.token">Token</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#4C00FF" href="https://github.com/steipete/CodexBar/blob/main/docs/kimi-k2.md">
+          <img class="chip-logo" src="./logos/kimi-k2.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">Kimi K2</span><span class="auth" data-i18n="auth.legacyApi">Legacy API</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#f8f676" href="https://github.com/steipete/CodexBar/blob/main/docs/kilo.md">
+          <img class="chip-logo no-bg" src="./logos/kilo.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">Kilo</span><span class="auth" data-i18n="auth.apiKey">API key</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#FF9900;--ink:#0a0a0c" href="https://github.com/steipete/CodexBar/blob/main/docs/kiro.md">
+          <img class="chip-logo no-bg" src="./logos/kiro.svg" data-dark-src="./logos/kiro-dark.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">Kiro</span><span class="auth">CLI</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#4285F4" href="https://github.com/steipete/CodexBar/blob/main/docs/vertexai.md">
+          <img class="chip-logo" src="./logos/vertex-ai.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">Vertex AI</span><span class="auth">gcloud</span></span>
+        </a></li>
+        <li><a class="provider logo-dark" style="--brand:#6366F1" href="https://github.com/steipete/CodexBar/blob/main/docs/augment.md">
+          <img class="chip-logo" src="./logos/augment.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">Augment</span><span class="auth">CLI</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#DC2626" href="https://github.com/steipete/CodexBar/blob/main/docs/amp.md">
+          <img class="chip-logo" src="./logos/amp.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">Amp</span><span class="auth" data-i18n="auth.cookies">Cookies</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#888888" href="https://github.com/steipete/CodexBar/blob/main/docs/ollama.md">
+          <img class="chip-logo" src="./logos/ollama.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">Ollama</span><span class="auth" data-i18n="auth.apiKeyCookies">API key + Cookies</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#141414" href="https://github.com/steipete/CodexBar/blob/main/docs/providers.md#fetch-strategies-current">
+          <img class="chip-logo" src="./logos/synthetic.svg" data-dark-src="./logos/synthetic-dark.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">Synthetic</span><span class="auth" data-i18n="auth.apiKey">API key</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#FF3399" href="https://github.com/steipete/CodexBar/blob/main/docs/jetbrains.md">
+          <img class="chip-logo" src="./logos/jetbrains-ai.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">JetBrains AI</span><span class="auth" data-i18n="auth.local">Local</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#7B68EE" href="https://github.com/steipete/CodexBar/blob/main/docs/warp.md">
+          <img class="chip-logo" src="./logos/warp.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">Warp</span><span class="auth" data-i18n="auth.apiKey">API key</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#EAEAE6;--ink:#0a0a0c" href="https://github.com/steipete/CodexBar/blob/main/docs/elevenlabs.md">
+          <img class="chip-logo" src="./logos/elevenlabs.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">ElevenLabs</span><span class="auth" data-i18n="auth.apiKey">API key</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#6467F2" href="https://github.com/steipete/CodexBar/blob/main/docs/openrouter.md">
+          <img class="chip-logo" src="./logos/openrouter.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">OpenRouter</span><span class="auth" data-i18n="auth.apiKey">API key</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#4C89F0" href="https://github.com/steipete/CodexBar/blob/main/docs/litellm.md">
+          <img class="chip-logo" src="./logos/litellm.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">LiteLLM</span><span class="auth" data-i18n="auth.virtualKey">Virtual key</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#20B2AA" href="https://github.com/steipete/CodexBar/blob/main/docs/providers.md#fetch-strategies-current">
+          <img class="chip-logo" src="./logos/perplexity.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">Perplexity</span><span class="auth" data-i18n="auth.cookies">Cookies</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#38BDF8" href="https://github.com/steipete/CodexBar/blob/main/docs/abacus.md">
+          <img class="chip-logo no-bg" src="./logos/abacus-ai.png" data-dark-src="./logos/abacus-ai-dark.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">Abacus AI</span><span class="auth" data-i18n="auth.cookies">Cookies</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#FF500F" href="https://github.com/steipete/CodexBar/blob/main/docs/providers.md#fetch-strategies-current">
+          <img class="chip-logo" src="./logos/mistral.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">Mistral</span><span class="auth" data-i18n="auth.cookies">Cookies</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#527DF0" href="https://github.com/steipete/CodexBar/blob/main/docs/deepseek.md">
+          <img class="chip-logo" src="./logos/deepseek.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">DeepSeek</span><span class="auth" data-i18n="auth.apiKey">API key</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#2563EB" href="https://github.com/steipete/CodexBar/blob/main/docs/providers.md#t3-chat">
+          <img class="chip-logo" src="./logos/t3chat.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">T3 Chat</span><span class="auth" data-i18n="auth.cookies">Cookies</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#44C800;--ink:#0a0a0c" href="https://github.com/steipete/CodexBar/blob/main/docs/codebuff.md">
+          <img class="chip-logo no-bg" src="./logos/codebuff.png" data-dark-src="./logos/codebuff-dark.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">Codebuff</span><span class="auth" data-i18n="auth.apiKey">API key</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#26AD61" href="https://github.com/steipete/CodexBar/blob/main/docs/poe.md">
+          <img class="chip-logo" src="./logos/poe.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">Poe</span><span class="auth" data-i18n="auth.apiKey">API key</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#3184FF" href="https://github.com/steipete/CodexBar/blob/main/docs/chutes.md">
+          <img class="chip-logo" src="./logos/chutes.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">Chutes</span><span class="auth" data-i18n="auth.apiKey">API key</span></span>
+        </a></li>
+        <li><a class="provider" style="--brand:#084EFF" href="https://github.com/steipete/CodexBar/blob/main/docs/zed.md">
+          <img class="chip-logo" src="./logos/zed.svg" alt="" width="20" height="20" /><span class="meta"><span class="name">Zed</span><span class="auth" data-i18n="auth.local">Local</span></span>
+        </a></li>
+        <li><a class="provider add" href="https://github.com/steipete/CodexBar/blob/main/docs/provider.md">
+          <span class="chip">+</span><span class="meta"><span class="name" data-i18n="providers.yourProvider">Your provider</span><span class="auth" data-i18n="providers.authoringGuide">Authoring guide</span></span>
+        </a></li>
+        </ul>
       </section>
 
-      <section class="details" aria-label="Features" data-animate="5">
-        <div class="card">
-          <h3>Usage tracking</h3>
-          <p>
-            Session + weekly meters with reset countdowns, plus optional credits and code review limits.
-          </p>
-        </div>
-        <div class="card">
-          <h3>Status + widgets</h3>
-          <p>
-            Provider status polling with incident badges, plus a WidgetKit snapshot that mirrors the menu card.
-          </p>
-        </div>
-        <div class="card">
-          <h3>CLI + automation</h3>
-          <p>
-            Bundled <code>codexbar</code> CLI for scripts and CI, with Linux CLI builds on GitHub Releases.
-          </p>
-        </div>
+      <section class="showcase">
+      <figure class="shot">
+        <img src="./codexbar.png" alt="CodexBar menu bar popover showing provider tiles with usage bars, reset countdowns, and credit details." data-i18n-alt="showcase.alt" />
+      </figure>
+      <div class="features">
+        <article>
+          <h3 data-i18n="features.resetsTitle">Resets you can plan around</h3>
+          <p data-i18n="features.resetsBody">Per-provider session, weekly, and monthly windows with countdowns to the next reset — no more guessing whether to start a long task.</p>
+        </article>
+        <article>
+          <h3 data-i18n="features.spendTitle">Credits, spend, and cost scans</h3>
+          <p data-i18n="features.spendBody">Credit balances and monthly spend where the provider exposes them, plus configurable local cost scans for Codex and Claude.</p>
+        </article>
+        <article>
+          <h3 data-i18n="features.statusTitle">Status &amp; incidents</h3>
+          <p data-i18n="features.statusBody">Provider status polling surfaces incident badges in the menu and an indicator overlay on the bar icon.</p>
+        </article>
+        <article>
+          <h3 data-i18n="features.cliTitle">CLI &amp; widgets</h3>
+          <p data-i18n-rich="features.cliBody">WidgetKit widgets for supported providers and a bundled <code>codexbar</code> CLI for scripts and CI — macOS and Linux builds on every release.</p>
+        </article>
+      </div>
       </section>
 
-      <section class="details permissions" aria-label="Permissions" data-animate="6">
-        <div class="card">
-          <h3>macOS permissions</h3>
-          <p>
-            Full Disk Access only for Safari cookies, Keychain access for tokens, and Files &amp; Folders prompts when
-            provider CLIs access project directories.
-          </p>
-        </div>
+      <section class="detail">
+      <article class="block">
+        <h3 data-i18n="detail.installTitle">Install &amp; updates</h3>
+        <p data-i18n-rich="detail.installBody">
+          Universal app via <a href="https://github.com/steipete/CodexBar/releases/latest">GitHub Releases</a> with Sparkle auto-updates, or via
+          <code>brew install --cask steipete/tap/codexbar</code> (updates via <code>brew upgrade</code>).
+        </p>
+      </article>
+      <article class="block">
+        <h3 data-i18n="detail.cliTitle">CLI</h3>
+        <p data-i18n-rich="detail.cliBody">
+          A bundled <code>codexbar</code> binary plus standalone tarballs for macOS and Linux on each release. On Linux:
+          <code>brew install steipete/tap/codexbar</code>.
+        </p>
+      </article>
+      <article class="block">
+        <h3 data-i18n="detail.privacyTitle">Privacy</h3>
+        <p data-i18n-rich="detail.privacyBody">
+          Reuses existing provider sessions — OAuth, device flow, API keys, browser cookies, local files — so no passwords are stored.
+          Audit notes in <a href="https://github.com/steipete/CodexBar/issues/12">issue #12</a>.
+        </p>
+      </article>
+      <article class="block">
+        <h3 data-i18n="detail.permissionsTitle">macOS permissions</h3>
+        <p data-i18n="detail.permissionsBody">
+          Full Disk Access for Safari cookies, Keychain access for cookie decryption and OAuth flows, and Files &amp; Folders prompts
+          when provider helpers read project directories.
+        </p>
+      </article>
       </section>
+    </main>
 
-      <section class="links-row" aria-label="Docs links" data-animate="7">
-        <a class="link-pill" href="https://github.com/steipete/CodexBar/blob/main/docs/providers.md">Docs</a>
-        <a class="link-pill" href="https://github.com/steipete/CodexBar/blob/main/docs/cli.md">CLI</a>
-        <a class="link-pill" href="https://github.com/steipete/CodexBar/blob/main/docs/provider.md">Provider guide</a>
-      </section>
+    <footer class="foot">
+      <p>
+        <span data-i18n="footer.builtBy">Built by</span> <a href="https://steipete.me">Peter Steinberger</a> ·
+        <a href="https://github.com/steipete/CodexBar/blob/main/CHANGELOG.md" data-i18n="footer.changelog">Changelog</a> ·
+        <a href="https://github.com/steipete/CodexBar/blob/main/LICENSE">MIT</a> ·
+        <a href="https://trimmy.app">trimmy.app</a>
+      </p>
+    </footer>
 
-      <footer class="foot" data-animate="8">
-        <p>
-          Built by <a href="https://steipete.me">Peter Steinberger</a> •
-          <a href="https://github.com/steipete/CodexBar/blob/main/CHANGELOG.md">Changelog</a> •
-          <a href="https://github.com/steipete/CodexBar/blob/main/LICENSE">MIT</a> •
-          <a href="https://codexbar.app">codexbar.app</a> •
-          <a href="https://trimmy.app">trimmy.app</a>
-        </p>
-      </footer>
-    </main>
+    <script type="module" src="./site.js?v=1"></script>
   </body>
 </html>
diff --git a/docs/keychain-prompts.md b/docs/keychain-prompts.md
new file mode 100644
index 0000000000..ae9ee040f3
--- /dev/null
+++ b/docs/keychain-prompts.md
@@ -0,0 +1,87 @@
+---
+summary: "Safe troubleshooting for macOS Keychain and browser Safe Storage prompts."
+read_when:
+  - Investigating Chrome Safe Storage or browser Safe Storage prompts
+  - Explaining prompts that appear after uninstalling CodexBar
+  - Collecting safe support details without exposing secrets
+---
+
+# Keychain prompts
+
+CodexBar can trigger macOS Keychain prompts when an enabled provider imports browser cookies, reads a provider-owned
+OAuth item, or uses a CodexBar-owned cache entry. Chromium browser cookie import commonly asks for the browser's
+Safe Storage item, such as "Chrome Safe Storage", "Brave Safe Storage", or "Microsoft Edge Safe Storage".
+
+CodexBar does not need your browser password. macOS owns the prompt, and the prompt should identify the app or binary
+that is requesting access. For support reports, include that requesting app/path when possible and do not paste
+passwords, cookie headers, OAuth tokens, API keys, or Keychain item values.
+
+## If the prompt appears after uninstalling CodexBar
+
+Deleting `CodexBar.app` prevents a new process from launching from that bundle, but it does not terminate a process
+that is already running from it. That process can continue to request Keychain access until it quits. If macOS still
+shows a prompt such as "CodexBar wants to use your confidential information stored in 'Chrome Safe Storage'", the
+usual causes are:
+
+- A CodexBar process or bundled helper is still running.
+- CodexBar is still enabled in Login Items and relaunched from an existing install.
+- Another copy of `CodexBar.app` exists elsewhere on the machine.
+- The uninstall path did not remove the same copy that launched the process. Finder, Homebrew cask, Sparkle updates,
+  and manually copied apps can leave different install paths in play.
+- The prompt is naming the requesting binary, not proving that the copy you deleted is the one still running.
+
+Safe checks:
+
+```bash
+pgrep -fl 'CodexBar|CodexBarCLI'
+ls -ld /Applications/CodexBar.app
+brew info --cask codexbar
+mdfind 'kMDItemCFBundleIdentifier == "com.steipete.codexbar"'
+```
+
+Also check:
+
+- **Activity Monitor**: search for `CodexBar` and `CodexBarCLI`.
+- **System Settings -> General -> Login Items**: remove CodexBar if it remains listed.
+- **Keychain prompt screenshot**: capture the full prompt, especially any requesting app/path details. Redact user
+  names or unrelated window contents if needed, but do not include secrets.
+
+If you find a still-running process, quit CodexBar from the menu if possible, or quit it from Activity Monitor. If you
+find another installed copy, confirm whether that copy is the one macOS names in the prompt before changing anything
+else.
+
+## Stop CodexBar from using Keychain
+
+If CodexBar is still installed and you want it to stop all Keychain access:
+
+1. Open **CodexBar -> Settings -> Advanced**.
+2. In **Keychain access**, enable **Disable Keychain access**.
+3. Relaunch CodexBar.
+
+This disables Keychain reads and writes from CodexBar. Browser-cookie-based providers will be skipped because
+CodexBar can no longer decrypt browser cookies. Manual cookie headers, API keys, and CLI/OAuth flows that do not rely
+on Keychain can still work where the provider supports them.
+
+## Browser Safe Storage prompts
+
+For normal browser-cookie import prompts, either allow CodexBar in the Keychain item's Access Control list or disable
+Keychain access:
+
+1. Open **Keychain Access.app**.
+2. Select the `login` keychain.
+3. Search for the item named in the prompt, for example `Chrome Safe Storage`.
+4. Open the item, choose **Access Control**, and add `CodexBar.app` under "Always allow access by these applications".
+5. Relaunch CodexBar.
+
+Avoid "Allow all applications" unless you intentionally want every app to access that item. Do not paste or share the
+item's secret value when asking for help.
+
+## What to include in a support issue
+
+- CodexBar version and install source: GitHub release, Homebrew cask, Sparkle update, or another source.
+- macOS version.
+- The uninstall method if this happened after uninstalling.
+- Whether Activity Monitor or `pgrep` still shows CodexBar.
+- Whether System Settings -> General -> Login Items still lists CodexBar.
+- Whether `/Applications/CodexBar.app`, Homebrew cask metadata, or Spotlight finds another copy.
+- A screenshot of the Keychain prompt showing the requested item and requesting app/path, with secrets redacted.
diff --git a/docs/kilo.md b/docs/kilo.md
index b8a6fa2b0c..6425bedecd 100644
--- a/docs/kilo.md
+++ b/docs/kilo.md
@@ -35,3 +35,20 @@ Kilo supports API and CLI-backed auth. Source mode can be `auto`, `api`, or `cli
 - Missing API token: set `KILO_API_KEY` or provider `apiKey`.
 - Missing CLI session file: run `kilo login` to create `~/.local/share/kilo/auth.json`.
 - Unauthorized API token (401/403): refresh `KILO_API_KEY` or rerun `kilo login`.
+
+## Organizations
+
+CodexBar can show usage for any Kilo organization the API key belongs to.
+
+- Open Preferences → Providers → Kilo, set the API key, then click **Refresh
+  organizations**.
+- Toggle the organizations you want to display alongside Personal. Personal is
+  always shown.
+- When at least one organization is enabled, the menu renders one Kilo card per
+  enabled scope.
+- The CodexBar fetcher sends the standard `X-KILOCODE-ORGANIZATIONID` header on
+  every usage call to scope the response to that organization.
+- CLI source mode (`auth.json`): the header is applied to CLI-resolved tokens
+  as well. If a CLI token isn't authorized for the chosen organization, that
+  card surfaces an unauthorized error while Personal and other enabled scopes
+  continue to render normally.
diff --git a/docs/kimi-k2.md b/docs/kimi-k2.md
index a40aa35669..a94beb777e 100644
--- a/docs/kimi-k2.md
+++ b/docs/kimi-k2.md
@@ -8,13 +8,18 @@ read_when:
 
 # Kimi K2 provider
 
-Kimi K2 is API-only. Usage is reported by the credit counter behind `GET https://kimi-k2.ai/api/user/credits`,
-so CodexBar only needs a valid API key to pull your remaining balance and usage.
+> This is a legacy, unofficial provider for the `kimi-k2.ai` credit endpoint.
+> For the official Kimi API account and billing surface, use the Moonshot / Kimi
+> API provider instead.
+
+Kimi K2 is API-only. Usage is reported by the credit counter behind
+`GET https://kimi-k2.ai/api/user/credits`, so CodexBar only needs a valid API
+key for that legacy endpoint to pull your remaining balance and usage.
 
 ## Data sources + fallback order
 
 1) **API key** stored in `~/.codexbar/config.json` or supplied via `KIMI_K2_API_KEY` / `KIMI_API_KEY` / `KIMI_KEY`.
-   CodexBar stores the key in config after you paste it in Preferences → Providers → Kimi K2.
+   CodexBar stores the key in config after you paste it in Preferences → Providers → Kimi K2 (unofficial).
 2) **Credit endpoint**
    - `GET https://kimi-k2.ai/api/user/credits`
    - Request headers: `Authorization: Bearer <api key>`, `Accept: application/json`
diff --git a/docs/kimi.md b/docs/kimi.md
index 4a3650e4c3..612949c5d2 100644
--- a/docs/kimi.md
+++ b/docs/kimi.md
@@ -14,14 +14,31 @@ Tracks usage for [Kimi For Coding](https://www.kimi.com/code) in CodexBar.
 
 - Displays weekly request quota (from membership tier)
 - Shows current 5-hour rate limit usage
-- Automatic and manual authentication methods
+- API-key, automatic cookie, and manual cookie authentication methods
 - Automatic refresh countdown
 
 ## Setup
 
-Choose one of two authentication methods:
+Choose one of three authentication methods:
 
-### Method 1: Automatic Browser Import (Recommended)
+### Method 1: Kimi Code API Key (Recommended)
+
+Create an API key in the [Kimi Code Console](https://www.kimi.com/code/console), then save it in CodexBar:
+
+```bash
+codexbar config set-api-key --provider kimi --api-key "kimi-api-key-here"
+```
+
+Or provide it through the environment:
+
+```bash
+export KIMI_CODE_API_KEY="kimi-code-api-key-here"
+```
+
+CodexBar calls `GET https://api.kimi.com/coding/v1/usages` with the API key. Set
+`KIMI_CODE_BASE_URL` only when testing a compatible HTTPS proxy or alternate host.
+
+### Method 2: Automatic Browser Import
 
 **No setup needed!** If you're already logged in to Kimi in Arc, Chrome, Safari, Edge, Brave, or Chromium:
 
@@ -32,7 +49,7 @@ Choose one of two authentication methods:
 
 **Note**: Requires Full Disk Access to read browser cookies (System Settings → Privacy & Security → Full Disk Access → CodexBar).
 
-### Method 2: Manual Token Entry
+### Method 3: Manual Token Entry
 
 For advanced users or when automatic import fails:
 
@@ -44,7 +61,7 @@ For advanced users or when automatic import fails:
 6. Copy the `kimi-auth` cookie value (JWT token)
 7. Paste it into the "Auth Token" field in CodexBar
 
-### Method 3: Environment Variable
+### Cookie Environment Variable
 
 Alternatively, set the `KIMI_AUTH_TOKEN` environment variable:
 
@@ -56,14 +73,44 @@ export KIMI_AUTH_TOKEN="jwt-token-here"
 
 When multiple sources are available, CodexBar uses this order:
 
-1. Manual token (from Settings UI)
-2. Environment variable (`KIMI_AUTH_TOKEN`)
-3. Browser cookies (Arc → Chrome → Safari → Edge → Brave → Chromium)
+1. API key (`providers[].apiKey` or `KIMI_CODE_API_KEY`) in Auto mode
+2. Manual cookie/token (from Settings UI) when web fallback is used
+3. Cookie environment variable (`KIMI_AUTH_TOKEN`)
+4. Browser cookies (Arc → Chrome → Safari → Edge → Brave → Chromium)
 
 **Note**: Browser cookie import requires Full Disk Access permission.
 
 ## API Details
 
+### Kimi Code API key
+
+**Endpoint**: `GET https://api.kimi.com/coding/v1/usages`
+
+**Authentication**: Bearer token (from `providers[].apiKey` or `KIMI_CODE_API_KEY`)
+
+**Response**:
+```json
+{
+  "usage": {
+    "limit": "2048",
+    "used": "214",
+    "remaining": "1834",
+    "resetTime": "2026-01-09T15:23:13.716839300Z"
+  },
+  "limits": [{
+    "window": {"duration": 300, "timeUnit": "TIME_UNIT_MINUTE"},
+    "detail": {
+      "limit": "200",
+      "used": "139",
+      "remaining": "61",
+      "resetTime": "2026-01-06T13:33:02.717479433Z"
+    }
+  }]
+}
+```
+
+### Kimi web cookie fallback
+
 **Endpoint**: `POST https://www.kimi.com/apiv2/kimi.gateway.billing.v1.BillingService/GetUsages`
 
 **Authentication**: Bearer token (from `kimi-auth` cookie)
diff --git a/docs/litellm.md b/docs/litellm.md
new file mode 100644
index 0000000000..edd5953511
--- /dev/null
+++ b/docs/litellm.md
@@ -0,0 +1,54 @@
+---
+summary: "LiteLLM provider setup and usage data shape."
+read_when:
+  - Configuring LiteLLM usage tracking
+  - Troubleshooting LiteLLM API-key usage in CodexBar
+---
+
+# LiteLLM
+
+LiteLLM uses a virtual key plus the proxy base URL. The key reads its own identity and budget data through LiteLLM's
+authenticated information endpoints.
+
+Configure it in Settings -> Providers -> LiteLLM, or in `~/.codexbar/config.json`:
+
+```json
+{
+  "id": "litellm",
+  "enabled": true,
+  "apiKey": "<LITELLM_API_KEY>",
+  "enterpriseHost": "https://litellm.example.com"
+}
+```
+
+Equivalent environment variables:
+
+```bash
+export LITELLM_API_KEY=sk-...
+export LITELLM_BASE_URL=https://litellm.example.com
+```
+
+`LITELLM_BASE_URL` may include `/v1`; CodexBar strips that suffix before calling LiteLLM management endpoints.
+
+## Data Source
+
+The provider calls:
+
+1. `GET /key/info` to discover the authenticated key's `user_id` and `team_id`.
+2. `GET /user/info?user_id=<user_id>` to read personal spend, budget, and teams.
+3. For team-only keys without a `user_id`, `GET /team/info?team_id=<team_id>` to read team spend and budget.
+
+All requests use `Authorization: Bearer <apiKey>`. CodexBar does not request or store a LiteLLM master key.
+
+For user-bound keys, personal usage is shown as the primary window. If the key has a team, its exact matching team
+budget is shown as the secondary window and becomes the automatic menu bar metric because that budget is enforced for
+the key. Team-only keys show that team budget as their sole usage window. Spend remains visible as an API-spend row
+when LiteLLM does not configure a budget.
+
+The virtual key must be allowed to read its own `/key/info` data and the corresponding user or team information
+endpoint. CodexBar validates returned user and team IDs against `/key/info` before displaying usage.
+
+## Security
+
+Treat LiteLLM keys as secrets. CodexBar stores configured keys only in provider config or token-account storage and
+sends them only to the configured LiteLLM base URL.
diff --git a/docs/llm-proxy.md b/docs/llm-proxy.md
new file mode 100644
index 0000000000..49ce39eaf7
--- /dev/null
+++ b/docs/llm-proxy.md
@@ -0,0 +1,41 @@
+---
+summary: "LLM Proxy provider setup and quota-stats usage source."
+read_when:
+  - Configuring LLM Proxy usage tracking
+  - Debugging aggregate proxy quota or provider breakdown display
+---
+
+# LLM Proxy
+
+CodexBar reads aggregate usage from an LLM-API-Key-Proxy compatible `/v1/quota-stats` endpoint.
+
+## Setup
+
+Store the API key:
+
+```bash
+printf '%s' "$LLM_PROXY_API_KEY" | codexbar config set-api-key --provider llmproxy --stdin
+```
+
+Set the base URL with `LLM_PROXY_BASE_URL`, or add `enterpriseHost` to the provider config:
+
+```json
+{
+  "id": "llmproxy",
+  "enabled": true,
+  "apiKey": "<REDACTED>",
+  "enterpriseHost": "https://proxy.example.com"
+}
+```
+
+The base URL may point at either the service root or `/v1`; CodexBar normalizes both to `/v1/quota-stats`.
+
+## Menu display
+
+- Primary: lowest remaining quota group, rendered as percent used.
+- Secondary: total requests.
+- Tertiary: total tokens.
+- Extra rows: top provider summaries by request count.
+- Cost: approximate spend when the proxy reports `approx_cost`.
+
+`quota_groups` may be either an array or a keyed object; CodexBar accepts both shapes.
diff --git a/docs/llms.txt b/docs/llms.txt
new file mode 100644
index 0000000000..84fade7223
--- /dev/null
+++ b/docs/llms.txt
@@ -0,0 +1,12 @@
+# CodexBar
+
+A tiny macOS menu bar app that tracks AI coding-provider usage windows, credits, costs, and resets across 53 providers — Codex, OpenAI, Claude, Cursor, Gemini, Copilot, LiteLLM, and more.
+
+Canonical documentation:
+- CodexBar — every AI coding limit in your menu bar: https://codexbar.app/ - A tiny macOS menu bar app that tracks AI coding-provider usage windows, credits, costs, and resets across 53 providers — Codex, OpenAI, Claude, Cursor, Gemini, Copilot, LiteLLM, and more.
+
+Source: https://github.com/steipete/CodexBar
+
+Guidance for agents:
+- Prefer the canonical documentation URLs above over README excerpts or package metadata.
+- Fetch only the pages needed for the current task; this is an index, not a full-site corpus.
diff --git a/docs/logos/abacus-ai-dark.svg b/docs/logos/abacus-ai-dark.svg
new file mode 100644
index 0000000000..468bb3dfe4
--- /dev/null
+++ b/docs/logos/abacus-ai-dark.svg
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="100" height="100" viewBox="0 0 100 100" fill="none" xmlns="http://www.w3.org/2000/svg">
+    <!-- Abacus AI logo: stylized vertical lines with dots -->
+    <g transform="translate(15, 10)">
+        <!-- Vertical lines -->
+        <rect x="0" y="0" width="4" height="80" rx="2" fill="white"/>
+        <rect x="17.5" y="0" width="4" height="80" rx="2" fill="white"/>
+        <rect x="35" y="0" width="4" height="80" rx="2" fill="white"/>
+        <rect x="52.5" y="0" width="4" height="80" rx="2" fill="white"/>
+        <rect x="66" y="0" width="4" height="80" rx="2" fill="white"/>
+        <!-- Dots on the lines (beads on an abacus) -->
+        <circle cx="2" cy="20" r="7" fill="white"/>
+        <circle cx="19.5" cy="45" r="7" fill="white"/>
+        <circle cx="37" cy="30" r="7" fill="white"/>
+        <circle cx="54.5" cy="60" r="7" fill="white"/>
+        <circle cx="68" cy="40" r="7" fill="white"/>
+    </g>
+</svg>
diff --git a/docs/logos/abacus-ai.png b/docs/logos/abacus-ai.png
new file mode 100644
index 0000000000..46572923b9
Binary files /dev/null and b/docs/logos/abacus-ai.png differ
diff --git a/docs/logos/alibaba.svg b/docs/logos/alibaba.svg
new file mode 100644
index 0000000000..bb458d7ed0
--- /dev/null
+++ b/docs/logos/alibaba.svg
@@ -0,0 +1 @@
+<svg height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>Alibaba</title><path d="M24 14.014c-2.8 1.512-5.62 2.896-8.759 3.524-.7.139-1.476.139-2.187.043-.678-.085-1.017-.682-.776-1.31.23-.585.536-1.181.93-1.671.852-1.065 1.814-2.034 2.678-3.088a15.75 15.75 0 001.422-2.054c.306-.511.164-1.129-.372-1.384-.897-.437-1.859-.745-2.81-1.075-.11-.043-.274.074-.492.149.273.244.47.425.743.67-2.821.48-5.49 1.16-8.08 2.098-.012.053-.033.095-.023.117.383.585.208 1.032-.35 1.394a2.365 2.365 0 00-.568.522c1.706.5 3.226.213 4.68-.735-.087-.127-.175-.244-.262-.372.546.096.874.394.918.862.011.107-.054.213-.087.32-.077-.086-.175-.17-.24-.267-.045-.064-.056-.138-.088-.245-1.728 1.15-3.587 1.438-5.632.842 0 .404-.022.745.011 1.075.022.287-.098.415-.36.564-.591.362-1.204.735-1.696 1.214-.59.585-.371 1.299.427 1.597.907.34 1.859.35 2.81.234 1.126-.139 2.23-.32 3.456-.49-1.433.67-2.844 1.14-4.33 1.33-1.04.14-2.078.214-3.106-.084-1.476-.415-2.133-1.501-1.75-2.96.361-1.363 1.236-2.449 2.176-3.45 3.139-3.332 7.108-5.024 11.7-5.365 1.072-.074 2.155.064 3.16.511 1.411.639 2.002 1.99 1.313 3.354-.448.905-1.072 1.735-1.695 2.555-.612.809-1.301 1.554-1.946 2.331-.186.234-.361.48-.503.745-.274.5-.088.83.492.778 1.213-.118 2.45-.213 3.62-.511 1.716-.437 3.389-1.054 5.084-1.597.175-.043.339-.107.492-.17z" fill="#FF6003" fill-rule="evenodd"></path></svg>
\ No newline at end of file
diff --git a/docs/logos/amp.svg b/docs/logos/amp.svg
new file mode 100644
index 0000000000..f8f9d31c0c
--- /dev/null
+++ b/docs/logos/amp.svg
@@ -0,0 +1 @@
+<svg viewBox="0 0 281 124" fill="#1A1A1A" xmlns="http://www.w3.org/2000/svg"><path d="M236.014 0C260.431 9.71106e-05 280.602 17.4115 280.603 44.7432C280.602 73.5337 260.065 94.1657 233.52 94.166C224.158 94.166 215.639 92.4222 208.63 88.4902C202.886 85.2698 198.203 80.6054 194.919 74.3379L188.115 121.822L187.946 123.016H174.214L174.448 121.423L191.772 2.49414H205.372L203.937 11.3369C212.143 3.86078 223.2 0.000153635 236.014 0ZM47.082 0.154297C56.4435 0.154297 65.0012 1.8991 72.0488 5.84863C77.8222 9.08305 82.5323 13.7713 85.8271 20.085L88.1201 3.69238L88.2861 2.49316H101.863L89.1611 90.6328L88.9873 91.8262H75.4092L76.7227 82.8555C68.5854 90.4564 57.3981 94.3231 44.5889 94.3232C20.1709 94.3232 0.000167223 76.9087 0 49.5771C0.000149745 20.7854 20.54 0.154871 47.082 0.154297ZM116.234 90.6357L116.061 91.8271H102.485L115.351 3.68555L115.521 2.49414H129.083L116.234 90.6357ZM140.673 90.6357L140.499 91.8271H126.924L139.789 3.68555L139.96 2.49414H153.521L140.673 90.6357ZM177.958 2.49414L165.108 90.6357L164.935 91.8271H151.36L164.225 3.68555L164.396 2.49414H177.958ZM48.4854 11.9844C27.8638 11.985 14.0133 28.3799 14.0127 48.9521C14.0127 57.7907 16.8094 66.1771 22.3145 72.334C27.7973 78.4657 36.0631 82.4932 47.2402 82.4932C67.8534 82.4925 81.7122 65.9487 81.7129 45.3682C81.7129 35.4076 78.2493 27.0792 72.4131 21.2441C66.5794 15.4088 58.2871 11.9844 48.4854 11.9844ZM233.362 11.8291C212.749 11.8297 198.89 28.3716 198.89 48.9521C198.89 58.9123 202.356 67.2403 208.189 73.0742C214.023 78.9107 222.315 82.3358 232.116 82.3359C252.738 82.3355 266.589 65.9407 266.59 45.3682C266.59 36.5296 263.795 28.1424 258.29 21.9863C252.807 15.8551 244.542 11.8291 233.362 11.8291Z"/></svg>
\ No newline at end of file
diff --git a/docs/logos/antigravity.svg b/docs/logos/antigravity.svg
new file mode 100644
index 0000000000..3ed10ab651
--- /dev/null
+++ b/docs/logos/antigravity.svg
@@ -0,0 +1 @@
+<svg height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>Antigravity</title><mask height="23" id="lobe-icons-antigravity-0-_R_0_" maskUnits="userSpaceOnUse" width="24" x="0" y="1"><path d="M21.751 22.607c1.34 1.005 3.35.335 1.508-1.508C17.73 15.74 18.904 1 12.037 1 5.17 1 6.342 15.74.815 21.1c-2.01 2.009.167 2.511 1.507 1.506 5.192-3.517 4.857-9.714 9.715-9.714 4.857 0 4.522 6.197 9.714 9.715z" fill="#fff"></path></mask><g mask="url(#lobe-icons-antigravity-0-_R_0_)"><g filter="url(#lobe-icons-antigravity-1-_R_0_)"><path d="M-1.018-3.992c-.408 3.591 2.686 6.89 6.91 7.37 4.225.48 7.98-2.043 8.387-5.633.408-3.59-2.686-6.89-6.91-7.37-4.225-.479-7.98 2.043-8.387 5.633z" fill="#FFE432"></path></g><g filter="url(#lobe-icons-antigravity-2-_R_0_)"><path d="M15.269 7.747c1.058 4.557 5.691 7.374 10.348 6.293 4.657-1.082 7.575-5.653 6.516-10.21-1.058-4.556-5.691-7.374-10.348-6.292-4.657 1.082-7.575 5.653-6.516 10.21z" fill="#FC413D"></path></g><g filter="url(#lobe-icons-antigravity-3-_R_0_)"><path d="M-12.443 10.804c1.338 4.703 7.36 7.11 13.453 5.378 6.092-1.733 9.947-6.95 8.61-11.652C8.282-.173 2.26-2.58-3.833-.848-9.925.884-13.78 6.1-12.443 10.804z" fill="#00B95C"></path></g><g filter="url(#lobe-icons-antigravity-4-_R_0_)"><path d="M-12.443 10.804c1.338 4.703 7.36 7.11 13.453 5.378 6.092-1.733 9.947-6.95 8.61-11.652C8.282-.173 2.26-2.58-3.833-.848-9.925.884-13.78 6.1-12.443 10.804z" fill="#00B95C"></path></g><g filter="url(#lobe-icons-antigravity-5-_R_0_)"><path d="M-7.608 14.703c3.352 3.424 9.126 3.208 12.896-.483 3.77-3.69 4.108-9.459.756-12.883C2.69-2.087-3.083-1.871-6.853 1.82c-3.77 3.69-4.108 9.458-.755 12.883z" fill="#00B95C"></path></g><g filter="url(#lobe-icons-antigravity-6-_R_0_)"><path d="M9.932 27.617c1.04 4.482 5.384 7.303 9.7 6.3 4.316-1.002 6.971-5.448 5.93-9.93-1.04-4.483-5.384-7.304-9.7-6.301-4.316 1.002-6.971 5.448-5.93 9.93z" fill="#3186FF"></path></g><g filter="url(#lobe-icons-antigravity-7-_R_0_)"><path d="M2.572-8.185C.392-3.329 2.778 2.472 7.9 4.771c5.122 2.3 11.042.227 13.222-4.63 2.18-4.855-.205-10.656-5.327-12.955-5.122-2.3-11.042-.227-13.222 4.63z" fill="#FBBC04"></path></g><g filter="url(#lobe-icons-antigravity-8-_R_0_)"><path d="M-3.267 38.686c-5.277-2.072 3.742-19.117 5.984-24.83 2.243-5.712 8.34-8.664 13.616-6.592 5.278 2.071 11.533 13.482 9.29 19.195-2.242 5.713-23.613 14.298-28.89 12.227z" fill="#3186FF"></path></g><g filter="url(#lobe-icons-antigravity-9-_R_0_)"><path d="M28.71 17.471c-1.413 1.649-5.1.808-8.236-1.878-3.135-2.687-4.531-6.201-3.118-7.85 1.412-1.649 5.1-.808 8.235 1.878s4.532 6.2 3.119 7.85z" fill="#749BFF"></path></g><g filter="url(#lobe-icons-antigravity-10-_R_0_)"><path d="M18.163 9.077c5.81 3.93 12.502 4.19 14.946.577 2.443-3.612-.287-9.727-6.098-13.658-5.81-3.931-12.502-4.19-14.946-.577-2.443 3.612.287 9.727 6.098 13.658z" fill="#FC413D"></path></g><g filter="url(#lobe-icons-antigravity-11-_R_0_)"><path d="M-.915 2.684c-1.44 3.473-.97 6.967 1.05 7.804 2.02.837 4.824-1.3 6.264-4.772 1.44-3.473.97-6.967-1.05-7.804-2.02-.837-4.824 1.3-6.264 4.772z" fill="#FFEE48"></path></g></g><defs><filter color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse" height="17.587" id="lobe-icons-antigravity-1-_R_0_" width="19.838" x="-3.288" y="-11.917"><feFlood flood-opacity="0" result="BackgroundImageFix"></feFlood><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"></feBlend><feGaussianBlur result="effect1_foregroundBlur_977_115" stdDeviation="1.117"></feGaussianBlur></filter><filter color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse" height="38.565" id="lobe-icons-antigravity-2-_R_0_" width="38.9" x="4.251" y="-13.493"><feFlood flood-opacity="0" result="BackgroundImageFix"></feFlood><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"></feBlend><feGaussianBlur result="effect1_foregroundBlur_977_115" stdDeviation="5.4"></feGaussianBlur></filter><filter color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse" height="36.517" id="lobe-icons-antigravity-3-_R_0_" width="40.955" x="-21.889" y="-10.592"><feFlood flood-opacity="0" result="BackgroundImageFix"></feFlood><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"></feBlend><feGaussianBlur result="effect1_foregroundBlur_977_115" stdDeviation="4.591"></feGaussianBlur></filter><filter color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse" height="36.517" id="lobe-icons-antigravity-4-_R_0_" width="40.955" x="-21.889" y="-10.592"><feFlood flood-opacity="0" result="BackgroundImageFix"></feFlood><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"></feBlend><feGaussianBlur result="effect1_foregroundBlur_977_115" stdDeviation="4.591"></feGaussianBlur></filter><filter color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse" height="36.595" id="lobe-icons-antigravity-5-_R_0_" width="36.632" x="-19.099" y="-10.278"><feFlood flood-opacity="0" result="BackgroundImageFix"></feFlood><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"></feBlend><feGaussianBlur result="effect1_foregroundBlur_977_115" stdDeviation="4.591"></feGaussianBlur></filter><filter color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse" height="34.087" id="lobe-icons-antigravity-6-_R_0_" width="33.533" x=".981" y="8.758"><feFlood flood-opacity="0" result="BackgroundImageFix"></feFlood><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"></feBlend><feGaussianBlur result="effect1_foregroundBlur_977_115" stdDeviation="4.363"></feGaussianBlur></filter><filter color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse" height="35.276" id="lobe-icons-antigravity-7-_R_0_" width="35.978" x="-6.143" y="-21.659"><feFlood flood-opacity="0" result="BackgroundImageFix"></feFlood><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"></feBlend><feGaussianBlur result="effect1_foregroundBlur_977_115" stdDeviation="3.954"></feGaussianBlur></filter><filter color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse" height="46.523" id="lobe-icons-antigravity-8-_R_0_" width="45.114" x="-11.96" y="-.46"><feFlood flood-opacity="0" result="BackgroundImageFix"></feFlood><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"></feBlend><feGaussianBlur result="effect1_foregroundBlur_977_115" stdDeviation="3.531"></feGaussianBlur></filter><filter color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse" height="24.054" id="lobe-icons-antigravity-9-_R_0_" width="25.094" x="10.485" y=".58"><feFlood flood-opacity="0" result="BackgroundImageFix"></feFlood><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"></feBlend><feGaussianBlur result="effect1_foregroundBlur_977_115" stdDeviation="3.159"></feGaussianBlur></filter><filter color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse" height="30.007" id="lobe-icons-antigravity-10-_R_0_" width="33.508" x="5.833" y="-12.467"><feFlood flood-opacity="0" result="BackgroundImageFix"></feFlood><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"></feBlend><feGaussianBlur result="effect1_foregroundBlur_977_115" stdDeviation="2.669"></feGaussianBlur></filter><filter color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse" height="26.151" id="lobe-icons-antigravity-11-_R_0_" width="22.194" x="-8.355" y="-8.876"><feFlood flood-opacity="0" result="BackgroundImageFix"></feFlood><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"></feBlend><feGaussianBlur result="effect1_foregroundBlur_977_115" stdDeviation="3.303"></feGaussianBlur></filter></defs></svg>
\ No newline at end of file
diff --git a/docs/logos/augment.svg b/docs/logos/augment.svg
new file mode 100644
index 0000000000..5e81dd27bd
--- /dev/null
+++ b/docs/logos/augment.svg
@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="512" height="512" fill="none">
+  <path fill="#ffffff" d="M78.844 464.762c-8.453 0-15.573-1.451-21.359-4.339-5.77-2.888-10.144-7.289-13.076-13.095-2.932-5.807-4.436-12.912-4.436-21.255v-86.028c0-10.605-2.125-18.321-6.329-23.135-4.234-4.798-11.742-7.334-22.507-7.579-3.35 0-6.034-1.253-8.066-3.804C1.008 303.005 0 300.087 0 296.832c0-3.53 1.008-6.448 3.071-8.725 2.048-2.277 4.762-3.53 8.066-3.774 10.765-.26 18.273-2.781 22.507-7.579 4.235-4.798 6.329-12.392 6.329-22.752v-86.028c0-12.637 3.35-22.249 10.005-28.804 6.654-6.555 16.287-9.856 28.866-9.856H181.5c3.862 0 7.042 1.146 9.617 3.408 2.559 2.277 3.862 5.195 3.862 8.694 0 3.301-1.086 6.128-3.257 8.542-2.172 2.414-5.057 3.622-8.671 3.622H87.732c-5.413 0-9.508 1.39-12.316 4.171-2.823 2.781-4.234 7.075-4.234 12.912v86.425c0 7.579-1.551 14.455-4.623 20.644-3.07 6.204-7.181 11.063-12.316 14.623-5.134 3.53-11.137 5.302-18.07 5.302v-1.528c6.933 0 12.936 1.773 18.07 5.303 5.135 3.529 9.245 8.404 12.316 14.623 3.072 6.188 4.623 13.064 4.623 20.643v86.808c0 5.837 1.411 10.115 4.234 12.911 2.823 2.812 6.934 4.172 12.316 4.172h95.318c3.583 0 6.468 1.207 8.671 3.606 2.202 2.414 3.257 5.257 3.257 8.542s-1.272 6.097-3.862 8.511c-2.575 2.414-5.771 3.606-9.617 3.606H78.844v-.092ZM330.501 464.768c-3.862 0-7.042-1.207-9.617-3.606-2.575-2.414-3.863-5.256-3.863-8.511 0-3.255 1.086-6.128 3.258-8.542 2.171-2.414 5.057-3.606 8.671-3.606h95.317c5.414 0 9.509-1.36 12.316-4.171 2.823-2.781 4.235-7.075 4.235-12.912v-86.808c0-7.579 1.551-14.455 4.622-20.643 3.071-6.204 7.182-11.063 12.316-14.623 5.134-3.53 11.137-5.303 18.071-5.303v1.528c-6.934 0-12.937-1.772-18.071-5.302-5.134-3.53-9.245-8.404-12.316-14.623-3.071-6.189-4.622-13.065-4.622-20.644v-86.425c0-5.807-1.412-10.1-4.235-12.912-2.823-2.781-6.933-4.171-12.316-4.171H328.95c-3.583 0-6.469-1.208-8.671-3.622-2.172-2.384-3.258-5.241-3.258-8.542 0-3.529 1.272-6.417 3.863-8.694 2.559-2.277 5.755-3.407 9.617-3.407h102.654c12.58 0 22.181 3.3 28.867 9.855 6.685 6.556 10.005 16.167 10.005 28.804v86.028c0 10.36 2.125 17.969 6.328 22.752 4.235 4.798 11.742 7.334 22.507 7.579 3.351.244 6.034 1.497 8.066 3.774 2.063 2.277 3.071 5.195 3.071 8.725 0 3.301-1.008 6.189-3.071 8.695-2.032 2.521-4.762 3.804-8.066 3.804-10.765.245-18.257 2.781-22.507 7.579-4.234 4.798-6.328 12.5-6.328 23.135v86.028c0 8.358-1.474 15.418-4.437 21.255-2.962 5.837-7.305 10.176-13.076 13.095-5.785 2.888-12.905 4.339-21.359 4.339H330.501v.092Z"/>
+  <path fill="#ffffff" d="M356.885 329.738c18.691 0 33.846-14.929 33.846-33.342 0-18.412-15.155-33.341-33.846-33.341-18.691 0-33.846 14.929-33.846 33.341 0 18.413 15.155 33.342 33.846 33.342ZM167.305 329.738c18.691 0 33.846-14.929 33.846-33.342 0-18.412-15.155-33.341-33.846-33.341-18.691 0-33.846 14.929-33.846 33.341 0 18.413 15.155 33.342 33.846 33.342ZM244.477 32.846l-2.59 68.135c0 3.82-3.661 5.73-10.983 5.73-7.321 0-10.982-1.91-10.982-5.73-.651-16.976-1.178-30.148-1.613-39.484-.217-9.55-.434-16.35-.651-20.384-.217-4.034-.326-6.479-.326-7.32v-1.268c0-4.874 4.529-7.319 13.572-7.319 9.044 0 13.573 2.552 13.573 7.64Zm54.941 0-2.59 68.135c0 3.82-3.661 5.73-10.982 5.73-7.322 0-10.982-1.91-10.982-5.73-.652-16.976-1.179-30.148-1.613-39.484-.218-9.55-.435-16.35-.652-20.384-.217-4.034-.326-6.479-.326-7.32v-1.268c0-4.874 4.53-7.319 13.573-7.319s13.572 2.552 13.572 7.64Z"/>
+</svg>
\ No newline at end of file
diff --git a/docs/logos/chutes.svg b/docs/logos/chutes.svg
new file mode 100644
index 0000000000..ff752b4554
--- /dev/null
+++ b/docs/logos/chutes.svg
@@ -0,0 +1,7 @@
+<svg viewBox="0 0 32 32" fill="#3184FF" xmlns="http://www.w3.org/2000/svg">
+  <title>Chutes</title>
+  <path d="M16 3c-6.1 0-11 4.9-11 11h5c0-3.3 2.7-6 6-6s6 2.7 6 6h5c0-6.1-4.9-11-11-11Z"/>
+  <path d="M11 14h10l-5 8-5-8Z"/>
+  <path d="M15 21h2v5h-2v-5Z"/>
+  <path d="M11 26h10v3H11v-3Z"/>
+</svg>
diff --git a/docs/logos/claude.svg b/docs/logos/claude.svg
new file mode 100644
index 0000000000..62dc0db12d
--- /dev/null
+++ b/docs/logos/claude.svg
@@ -0,0 +1 @@
+<svg height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>Claude</title><path d="M4.709 15.955l4.72-2.647.08-.23-.08-.128H9.2l-.79-.048-2.698-.073-2.339-.097-2.266-.122-.571-.121L0 11.784l.055-.352.48-.321.686.06 1.52.103 2.278.158 1.652.097 2.449.255h.389l.055-.157-.134-.098-.103-.097-2.358-1.596-2.552-1.688-1.336-.972-.724-.491-.364-.462-.158-1.008.656-.722.881.06.225.061.893.686 1.908 1.476 2.491 1.833.365.304.145-.103.019-.073-.164-.274-1.355-2.446-1.446-2.49-.644-1.032-.17-.619a2.97 2.97 0 01-.104-.729L6.283.134 6.696 0l.996.134.42.364.62 1.414 1.002 2.229 1.555 3.03.456.898.243.832.091.255h.158V9.01l.128-1.706.237-2.095.23-2.695.08-.76.376-.91.747-.492.584.28.48.685-.067.444-.286 1.851-.559 2.903-.364 1.942h.212l.243-.242.985-1.306 1.652-2.064.73-.82.85-.904.547-.431h1.033l.76 1.129-.34 1.166-1.064 1.347-.881 1.142-1.264 1.7-.79 1.36.073.11.188-.02 2.856-.606 1.543-.28 1.841-.315.833.388.091.395-.328.807-1.969.486-2.309.462-3.439.813-.042.03.049.061 1.549.146.662.036h1.622l3.02.225.79.522.474.638-.079.485-1.215.62-1.64-.389-3.829-.91-1.312-.329h-.182v.11l1.093 1.068 2.006 1.81 2.509 2.33.127.578-.322.455-.34-.049-2.205-1.657-.851-.747-1.926-1.62h-.128v.17l.444.649 2.345 3.521.122 1.08-.17.353-.608.213-.668-.122-1.374-1.925-1.415-2.167-1.143-1.943-.14.08-.674 7.254-.316.37-.729.28-.607-.461-.322-.747.322-1.476.389-1.924.315-1.53.286-1.9.17-.632-.012-.042-.14.018-1.434 1.967-2.18 2.945-1.726 1.845-.414.164-.717-.37.067-.662.401-.589 2.388-3.036 1.44-1.882.93-1.086-.006-.158h-.055L4.132 18.56l-1.13.146-.487-.456.061-.746.231-.243 1.908-1.312-.006.006z" fill="#D97757" fill-rule="nonzero"></path></svg>
\ No newline at end of file
diff --git a/docs/logos/codebuff-dark.svg b/docs/logos/codebuff-dark.svg
new file mode 100644
index 0000000000..6d5f9e4550
--- /dev/null
+++ b/docs/logos/codebuff-dark.svg
@@ -0,0 +1,4 @@
+<svg width="100" height="100" viewBox="0 0 100 100" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path fill-rule="evenodd" clip-rule="evenodd" d="M50 8L12 28V72L50 92L88 72V28L50 8ZM50 22.5L74 35.25V64.75L50 77.5L26 64.75V35.25L50 22.5Z" fill="#44FF00"/>
+  <path d="M50 40L61 46V54L50 60L39 54V46L50 40Z" fill="#44FF00"/>
+</svg>
diff --git a/docs/logos/codebuff.png b/docs/logos/codebuff.png
new file mode 100644
index 0000000000..47b4b7beea
Binary files /dev/null and b/docs/logos/codebuff.png differ
diff --git a/docs/logos/codebuff.svg b/docs/logos/codebuff.svg
new file mode 100644
index 0000000000..5791738f47
--- /dev/null
+++ b/docs/logos/codebuff.svg
@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">
+  <rect width="24" height="24" rx="4" fill="#44C800"/>
+  <path d="M7 8l-3 4 3 4M17 8l3 4-3 4M14 6l-4 12" stroke="#fff" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>
diff --git a/docs/logos/codex-dark.svg b/docs/logos/codex-dark.svg
new file mode 100644
index 0000000000..0d789fb754
--- /dev/null
+++ b/docs/logos/codex-dark.svg
@@ -0,0 +1,3 @@
+<svg width="100" height="100" viewBox="0 0 100 100" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M83.7733 42.8087C84.6678 40.1149 84.9771 37.2613 84.6807 34.4385C84.3843 31.6156 83.489 28.8885 82.0544 26.4394C77.6908 18.8436 68.9203 14.9365 60.3548 16.7725C57.9831 14.1344 54.9591 12.1668 51.5864 11.0673C48.2137 9.96772 44.611 9.77498 41.1402 10.5084C37.6694 11.2418 34.4527 12.8755 31.8132 15.2455C29.1736 17.6155 27.204 20.6383 26.1024 24.0103C23.3212 24.5806 20.6938 25.738 18.3958 27.405C16.0977 29.0721 14.1819 31.2104 12.7765 33.6772C8.36538 41.2609 9.3669 50.8267 15.2527 57.3327C14.3549 60.0251 14.0424 62.8782 14.3361 65.7012C14.6298 68.5241 15.523 71.2518 16.9558 73.7017C21.325 81.3002 30.1011 85.207 38.6712 83.3686C40.5554 85.4904 42.8707 87.1858 45.4623 88.3416C48.0539 89.4975 50.8622 90.0871 53.6999 90.0713C62.4793 90.079 70.2575 84.4114 72.9393 76.0515C75.7201 75.4802 78.347 74.3225 80.6449 72.6555C82.9427 70.9886 84.8587 68.8507 86.2649 66.3846C90.6227 58.8145 89.6172 49.3005 83.7733 42.8087ZM53.6999 84.8356C50.1955 84.8411 46.801 83.6129 44.1116 81.3661L44.5848 81.098L60.5123 71.9043C60.9087 71.6718 61.2379 71.3402 61.4674 70.942C61.6969 70.5439 61.8189 70.0929 61.8215 69.6333V47.1769L68.5553 51.072C68.6225 51.1063 68.6694 51.1707 68.6814 51.2456V69.854C68.6641 78.1208 61.9667 84.8183 53.6999 84.8356ZM21.4977 71.0843C19.7402 68.0497 19.1092 64.4925 19.7156 61.0386L20.1885 61.3225L36.1321 70.5165C36.5266 70.748 36.9757 70.87 37.4331 70.87C37.8905 70.87 38.3396 70.748 38.7341 70.5165L58.21 59.2883V67.0628C58.2081 67.1031 58.1973 67.1424 58.1782 67.1779C58.1591 67.2134 58.1322 67.2441 58.0996 67.2678L41.9671 76.5722C34.798 80.7022 25.6388 78.2463 21.4977 71.0843ZM17.3026 36.3898C19.0723 33.3357 21.8655 31.0062 25.1878 29.8138V48.7376C25.1818 49.1949 25.2986 49.6453 25.5261 50.042C25.7535 50.4387 26.0833 50.7671 26.4809 50.9928L45.8622 62.1739L39.1283 66.069C39.0919 66.0883 39.0513 66.0984 39.0101 66.0984C38.9689 66.0984 38.9283 66.0883 38.8919 66.069L22.7908 56.7809C15.6359 52.6337 13.1822 43.4816 17.3026 36.3112V36.3898ZM72.624 49.2426L53.1792 37.9512L59.8976 34.0718C59.9341 34.0524 59.9747 34.0423 60.016 34.0423C60.0573 34.0423 60.0979 34.0524 60.1344 34.0718L76.2355 43.3761C78.6973 44.7966 80.7043 46.8882 82.0221 49.4065C83.3398 51.9249 83.914 54.7661 83.6775 57.5985C83.4411 60.431 82.4038 63.1377 80.6867 65.4027C78.9696 67.6677 76.6436 69.3975 73.9803 70.3901V51.466C73.9663 51.0096 73.834 50.5647 73.5962 50.1749C73.3584 49.7851 73.0234 49.4638 72.624 49.2426ZM79.3261 39.1657L78.8529 38.8815L62.9411 29.6089C62.5442 29.376 62.0924 29.2532 61.6322 29.2532C61.172 29.2532 60.7202 29.376 60.3233 29.6089L40.8629 40.8374V33.0628C40.8587 33.0233 40.8654 32.9834 40.882 32.9473C40.8987 32.9113 40.9248 32.8803 40.9575 32.8579L57.0586 23.5692C59.5263 22.1476 62.3478 21.458 65.193 21.5811C68.0382 21.7042 70.7896 22.6348 73.1253 24.2642C75.461 25.8936 77.2845 28.1543 78.3825 30.782C79.4806 33.4097 79.8077 36.2957 79.3257 39.1025V39.1657H79.3261ZM37.1888 52.9484L30.455 49.069C30.4213 49.0487 30.3925 49.0212 30.3707 48.9884C30.3488 48.9557 30.3345 48.9186 30.3286 48.8797V30.3188C30.3323 27.4714 31.1466 24.6839 32.6761 22.2822C34.2057 19.8805 36.3874 17.9639 38.9661 16.7564C41.5448 15.549 44.4139 15.1005 47.2381 15.4636C50.0622 15.8267 52.7247 16.9862 54.9141 18.8067L54.4409 19.0748L38.5134 28.2686C38.117 28.5011 37.7879 28.8327 37.5584 29.2308C37.329 29.629 37.207 30.0799 37.2045 30.5395L37.1888 52.9487V52.9484ZM40.8472 45.0632L49.5209 40.0643L58.21 45.0635V55.0615L49.5523 60.0608L40.8632 55.0615L40.8472 45.0632Z" fill="white"/>
+</svg>
diff --git a/docs/logos/codex.svg b/docs/logos/codex.svg
new file mode 100644
index 0000000000..c77ccfdd90
--- /dev/null
+++ b/docs/logos/codex.svg
@@ -0,0 +1 @@
+<svg height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>Codex</title><path d="M19.503 0H4.496A4.496 4.496 0 000 4.496v15.007A4.496 4.496 0 004.496 24h15.007A4.496 4.496 0 0024 19.503V4.496A4.496 4.496 0 0019.503 0z" fill="#fff"></path><path d="M9.064 3.344a4.578 4.578 0 012.285-.312c1 .115 1.891.54 2.673 1.275.01.01.024.017.037.021a.09.09 0 00.043 0 4.55 4.55 0 013.046.275l.047.022.116.057a4.581 4.581 0 012.188 2.399c.209.51.313 1.041.315 1.595a4.24 4.24 0 01-.134 1.223.123.123 0 00.03.115c.594.607.988 1.33 1.183 2.17.289 1.425-.007 2.71-.887 3.854l-.136.166a4.548 4.548 0 01-2.201 1.388.123.123 0 00-.081.076c-.191.551-.383 1.023-.74 1.494-.9 1.187-2.222 1.846-3.711 1.838-1.187-.006-2.239-.44-3.157-1.302a.107.107 0 00-.105-.024c-.388.125-.78.143-1.204.138a4.441 4.441 0 01-1.945-.466 4.544 4.544 0 01-1.61-1.335c-.152-.202-.303-.392-.414-.617a5.81 5.81 0 01-.37-.961 4.582 4.582 0 01-.014-2.298.124.124 0 00.006-.056.085.085 0 00-.027-.048 4.467 4.467 0 01-1.034-1.651 3.896 3.896 0 01-.251-1.192 5.189 5.189 0 01.141-1.6c.337-1.112.982-1.985 1.933-2.618.212-.141.413-.251.601-.33.215-.089.43-.164.646-.227a.098.098 0 00.065-.066 4.51 4.51 0 01.829-1.615 4.535 4.535 0 011.837-1.388zm3.482 10.565a.637.637 0 000 1.272h3.636a.637.637 0 100-1.272h-3.636zM8.462 9.23a.637.637 0 00-1.106.631l1.272 2.224-1.266 2.136a.636.636 0 101.095.649l1.454-2.455a.636.636 0 00.005-.64L8.462 9.23z" fill="url(#lobe-icons-codex-_R_0_)"></path><defs><linearGradient gradientUnits="userSpaceOnUse" id="lobe-icons-codex-_R_0_" x1="12" x2="12" y1="3" y2="21"><stop stop-color="#B1A7FF"></stop><stop offset=".5" stop-color="#7A9DFF"></stop><stop offset="1" stop-color="#3941FF"></stop></linearGradient></defs></svg>
\ No newline at end of file
diff --git a/docs/logos/copilot.svg b/docs/logos/copilot.svg
new file mode 100644
index 0000000000..dd11956e04
--- /dev/null
+++ b/docs/logos/copilot.svg
@@ -0,0 +1 @@
+<svg fill="#1F2328" fill-rule="evenodd" height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>GithubCopilot</title><path d="M19.245 5.364c1.322 1.36 1.877 3.216 2.11 5.817.622 0 1.2.135 1.592.654l.73.964c.21.278.323.61.323.955v2.62c0 .339-.173.669-.453.868C20.239 19.602 16.157 21.5 12 21.5c-4.6 0-9.205-2.583-11.547-4.258-.28-.2-.452-.53-.453-.868v-2.62c0-.345.113-.679.321-.956l.73-.963c.392-.517.974-.654 1.593-.654l.029-.297c.25-2.446.81-4.213 2.082-5.52 2.461-2.54 5.71-2.851 7.146-2.864h.198c1.436.013 4.685.323 7.146 2.864zm-7.244 4.328c-.284 0-.613.016-.962.05-.123.447-.305.85-.57 1.108-1.05 1.023-2.316 1.18-2.994 1.18-.638 0-1.306-.13-1.851-.464-.516.165-1.012.403-1.044.996a65.882 65.882 0 00-.063 2.884l-.002.48c-.002.563-.005 1.126-.013 1.69.002.326.204.63.51.765 2.482 1.102 4.83 1.657 6.99 1.657 2.156 0 4.504-.555 6.985-1.657a.854.854 0 00.51-.766c.03-1.682.006-3.372-.076-5.053-.031-.596-.528-.83-1.046-.996-.546.333-1.212.464-1.85.464-.677 0-1.942-.157-2.993-1.18-.266-.258-.447-.661-.57-1.108-.32-.032-.64-.049-.96-.05zm-2.525 4.013c.539 0 .976.426.976.95v1.753c0 .525-.437.95-.976.95a.964.964 0 01-.976-.95v-1.752c0-.525.437-.951.976-.951zm5 0c.539 0 .976.426.976.95v1.753c0 .525-.437.95-.976.95a.964.964 0 01-.976-.95v-1.752c0-.525.437-.951.976-.951zM7.635 5.087c-1.05.102-1.935.438-2.385.906-.975 1.037-.765 3.668-.21 4.224.405.394 1.17.657 1.995.657h.09c.649-.013 1.785-.176 2.73-1.11.435-.41.705-1.433.675-2.47-.03-.834-.27-1.52-.63-1.813-.39-.336-1.275-.482-2.265-.394zm6.465.394c-.36.292-.6.98-.63 1.813-.03 1.037.24 2.06.675 2.47.968.957 2.136 1.104 2.776 1.11h.044c.825 0 1.59-.263 1.995-.657.555-.556.765-3.187-.21-4.224-.45-.468-1.335-.804-2.385-.906-.99-.088-1.875.058-2.265.394zM12 7.615c-.24 0-.525.015-.84.044.03.16.045.336.06.526l-.001.159a2.94 2.94 0 01-.014.25c.225-.022.425-.027.612-.028h.366c.187 0 .387.006.612.028-.015-.146-.015-.277-.015-.409.015-.19.03-.365.06-.526a9.29 9.29 0 00-.84-.044z"></path></svg>
\ No newline at end of file
diff --git a/docs/logos/cursor.svg b/docs/logos/cursor.svg
new file mode 100644
index 0000000000..e4135e124b
--- /dev/null
+++ b/docs/logos/cursor.svg
@@ -0,0 +1 @@
+<svg fill="#1A1A1A" fill-rule="evenodd" height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>Cursor</title><path d="M22.106 5.68L12.5.135a.998.998 0 00-.998 0L1.893 5.68a.84.84 0 00-.419.726v11.186c0 .3.16.577.42.727l9.607 5.547a.999.999 0 00.998 0l9.608-5.547a.84.84 0 00.42-.727V6.407a.84.84 0 00-.42-.726zm-.603 1.176L12.228 22.92c-.063.108-.228.064-.228-.061V12.34a.59.59 0 00-.295-.51l-9.11-5.26c-.107-.062-.063-.228.062-.228h18.55c.264 0 .428.286.296.514z"></path></svg>
\ No newline at end of file
diff --git a/docs/logos/deepseek.svg b/docs/logos/deepseek.svg
new file mode 100644
index 0000000000..185c108b45
--- /dev/null
+++ b/docs/logos/deepseek.svg
@@ -0,0 +1 @@
+<svg fill="#5786FE" role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><title>DeepSeek</title><path d="M23.748 4.651c-.254-.124-.364.113-.512.233-.051.04-.094.09-.137.137-.372.397-.806.657-1.373.626-.829-.046-1.537.214-2.163.848-.133-.782-.575-1.248-1.247-1.548-.352-.155-.708-.311-.955-.65-.172-.24-.219-.509-.305-.774-.055-.16-.11-.323-.293-.35-.2-.031-.278.136-.356.276-.313.572-.434 1.202-.422 1.84.027 1.436.633 2.58 1.838 3.393.137.094.172.187.129.323-.082.28-.18.553-.266.833-.055.179-.137.218-.328.14a5.5 5.5 0 0 1-1.737-1.179c-.857-.828-1.631-1.743-2.597-2.46a12 12 0 0 0-.689-.47c-.985-.957.13-1.743.387-1.836.27-.098.094-.433-.778-.428-.872.003-1.67.295-2.687.685a3 3 0 0 1-.465.136 9.6 9.6 0 0 0-2.883-.101c-1.885.21-3.39 1.1-4.497 2.622C.082 8.776-.231 10.854.152 13.02c.403 2.284 1.568 4.175 3.36 5.653 1.857 1.533 3.997 2.284 6.438 2.14 1.482-.085 3.132-.284 4.994-1.86.47.234.962.328 1.78.398.629.058 1.235-.031 1.705-.129.735-.155.684-.836.418-.961-2.155-1.004-1.682-.595-2.112-.926 1.095-1.295 2.768-3.598 3.284-6.733.05-.346.115-.834.108-1.114-.004-.171.035-.238.23-.257a4.2 4.2 0 0 0 1.545-.475c1.397-.763 1.96-2.016 2.093-3.517.02-.23-.004-.467-.247-.588M11.58 18.168c-2.088-1.642-3.101-2.183-3.52-2.16-.39.024-.32.472-.234.763.09.288.207.487.371.74.114.167.192.416-.113.603-.673.416-1.842-.14-1.897-.168-1.361-.801-2.5-1.86-3.301-3.306-.775-1.393-1.225-2.888-1.299-4.482-.02-.385.094-.522.477-.592a4.7 4.7 0 0 1 1.53-.038c2.131.311 3.946 1.264 5.467 2.774.868.86 1.525 1.887 2.202 2.89.72 1.066 1.494 2.082 2.48 2.915.348.291.626.513.892.677-.802.09-2.14.109-3.055-.615zm1.001-6.44a.306.306 0 0 1 .415-.287.3.3 0 0 1 .113.074.3.3 0 0 1 .086.214c0 .17-.136.307-.308.307a.303.303 0 0 1-.306-.307m3.11 1.596c-.2.081-.4.151-.591.16a1.25 1.25 0 0 1-.798-.254c-.274-.23-.47-.358-.551-.758a1.7 1.7 0 0 1 .015-.588c.07-.327-.007-.537-.238-.727-.188-.156-.426-.199-.689-.199a.6.6 0 0 1-.254-.078.253.253 0 0 1-.114-.358 1 1 0 0 1 .192-.21c.356-.202.767-.136 1.146.016.352.144.618.408 1.001.782.392.451.462.576.685.915.176.264.336.536.446.848.066.194-.02.353-.25.45"/></svg>
\ No newline at end of file
diff --git a/docs/logos/devin.svg b/docs/logos/devin.svg
new file mode 100644
index 0000000000..e2b1cd5f67
--- /dev/null
+++ b/docs/logos/devin.svg
@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
+  <path fill="currentColor" d="M12 2.25c1.18 0 2.18.76 2.54 1.82a8.1 8.1 0 0 1 2.04.85 2.68 2.68 0 0 1 3.08.5 2.68 2.68 0 0 1 .5 3.08c.4.64.69 1.33.85 2.04A2.68 2.68 0 0 1 22.75 13c0 1.18-.76 2.18-1.82 2.54a8.1 8.1 0 0 1-.85 2.04 2.68 2.68 0 0 1-.5 3.08 2.68 2.68 0 0 1-3.08.5 8.1 8.1 0 0 1-2.04.85A2.68 2.68 0 0 1 12 23.75a2.68 2.68 0 0 1-2.54-1.82 8.1 8.1 0 0 1-2.04-.85 2.68 2.68 0 0 1-3.08-.5 2.68 2.68 0 0 1-.5-3.08 8.1 8.1 0 0 1-.85-2.04A2.68 2.68 0 0 1 1.25 13c0-1.18.76-2.18 1.82-2.54.16-.71.45-1.4.85-2.04a2.68 2.68 0 0 1 .5-3.08 2.68 2.68 0 0 1 3.08-.5c.64-.4 1.33-.69 2.04-.85A2.68 2.68 0 0 1 12 2.25Zm0 3.5a6.25 6.25 0 1 0 0 12.5 6.25 6.25 0 0 0 0-12.5Zm0 3.25a3 3 0 1 1 0 6 3 3 0 0 1 0-6Z"/>
+</svg>
diff --git a/docs/logos/droid-dark.svg b/docs/logos/droid-dark.svg
new file mode 100644
index 0000000000..f7807d8abe
--- /dev/null
+++ b/docs/logos/droid-dark.svg
@@ -0,0 +1,3 @@
+<svg width="100" height="100" viewBox="0 0 100 100" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M67.8515 23.9286C67.6213 23.8754 67.4147 23.7483 67.2635 23.5667C67.1123 23.385 67.0247 23.1589 67.0141 22.9227C67.0083 22.7678 67.0368 22.6135 67.0978 22.471C69.2044 17.4703 70.1341 13.4692 68.6328 11.7944C64.6604 7.35158 48.7249 16.1873 43.643 19.1813C43.507 19.2603 43.3558 19.3098 43.1993 19.3266C43.0429 19.3435 42.8846 19.3272 42.7348 19.279C42.585 19.2308 42.4471 19.1516 42.3298 19.0466C42.2126 18.9416 42.1188 18.8132 42.0544 18.6696C39.919 13.6801 37.6739 10.2082 35.3976 10.0585C29.366 9.65537 24.5026 26.8938 23.0799 32.5123C23.0423 32.6645 22.9714 32.8064 22.8723 32.9279C22.7733 33.0494 22.6486 33.1474 22.5071 33.2149C22.3649 33.2852 22.2094 33.3245 22.0508 33.3303C21.8923 33.3361 21.7343 33.3083 21.5873 33.2486C16.4593 31.1932 12.3547 30.2871 10.6387 31.751C6.0823 35.6248 15.1427 51.166 18.2115 56.1218C18.3338 56.3213 18.3866 56.5557 18.3618 56.7885C18.3369 57.0212 18.2359 57.2392 18.0742 57.4084C17.9651 57.522 17.8333 57.6112 17.6874 57.6705C12.5718 59.7534 9.01383 61.9424 8.85658 64.1626C8.446 70.0443 26.1213 74.7867 31.8845 76.1745C32.0392 76.2127 32.1794 76.2805 32.3051 76.3779C32.4275 76.4739 32.5279 76.5952 32.5994 76.7334C32.6709 76.8717 32.7118 77.0236 32.7194 77.1791C32.7253 77.334 32.6967 77.4883 32.6358 77.6309C30.5292 82.6316 29.5994 86.6339 31.1007 88.3074C35.0731 92.7515 51.0112 83.9157 56.0917 80.9231C56.2975 80.8022 56.5364 80.75 56.7738 80.774C57.0112 80.798 57.2347 80.897 57.4121 81.0566C57.5267 81.1622 57.6181 81.2906 57.6804 81.4335C59.8157 86.4217 62.0596 89.8936 64.3372 90.0446C70.3687 90.4465 75.2322 73.2092 76.6524 67.5895C76.6911 67.4385 76.7627 67.2979 76.862 67.1777C76.9619 67.0551 77.0871 66.9554 77.229 66.8856C77.371 66.8159 77.5263 66.7775 77.6845 66.7733C77.8429 66.7678 78.0007 66.7959 78.1475 66.8557C83.2754 68.9112 87.3788 69.816 89.0961 68.3533C93.6525 64.4783 84.5908 48.9358 81.5208 43.9801C81.399 43.7805 81.3465 43.5463 81.3716 43.3138C81.3966 43.0814 81.4978 42.8637 81.6593 42.6946C81.7685 42.5811 81.9003 42.4918 82.0462 42.4326C87.1629 40.3484 90.7222 38.1594 90.8757 35.9393C91.2888 30.0575 73.6123 25.3151 67.8503 23.9299M60.9289 18.2915C62.0896 20.3182 56.1142 33.8239 51.6689 43.27C51.593 43.4283 51.4712 43.56 51.3194 43.6481C51.1655 43.7368 50.9885 43.7772 50.8114 43.7641C50.6343 43.751 50.4652 43.6849 50.326 43.5745C50.1899 43.4646 50.0899 43.3163 50.039 43.1489C48.2431 37.0076 46.1927 29.7904 43.9975 23.6653C43.9112 23.4249 43.9156 23.1613 44.01 22.924C44.1055 22.685 44.2829 22.4877 44.5104 22.3674C49.9916 19.4471 59.3715 15.5708 60.9289 18.2915ZM34.6613 19.9638C36.9488 20.5965 42.5161 34.2657 46.2226 44.01C46.2845 44.1733 46.2937 44.3518 46.2489 44.5206C46.2041 44.6893 46.1077 44.8399 45.973 44.951C45.8369 45.065 45.6696 45.1355 45.4929 45.1533C45.3163 45.1711 45.1383 45.1354 44.9821 45.0508C39.2551 41.9496 32.5771 38.2568 26.583 35.4388C26.3498 35.3293 26.1631 35.1404 26.0564 34.9059C25.9507 34.6743 25.933 34.4121 26.0065 34.1684C27.7711 28.329 31.5862 19.1151 34.6613 19.9638ZM17.2992 39.2577C19.3759 38.127 33.2261 43.9539 42.9105 48.2869C43.0727 48.3593 43.2087 48.4791 43.2986 48.6288C43.3885 48.778 43.4296 48.9514 43.4162 49.125C43.4028 49.2987 43.3355 49.4637 43.2237 49.5973C43.1099 49.733 42.9576 49.8309 42.7869 49.8781C36.4908 51.629 29.089 53.6295 22.8066 55.7698C22.5603 55.8535 22.2925 55.8491 22.0491 55.7573C21.808 55.6665 21.6066 55.4937 21.48 55.2694C18.4911 49.923 14.5087 40.7765 17.2992 39.2577ZM19.014 64.8752C19.6617 62.6438 33.6803 57.2125 43.6717 53.5996C43.8386 53.5406 44.0192 53.5323 44.1909 53.5755C44.3625 53.6188 44.5175 53.7119 44.6364 53.8429C44.7518 53.9734 44.8235 54.1366 44.8416 54.3097C44.8597 54.4829 44.8233 54.6574 44.7375 54.8089C41.5577 60.3936 37.7713 66.9069 34.8809 72.7512C34.7662 72.9824 34.5728 73.1651 34.3355 73.2666C34.0963 73.3703 33.8285 73.3875 33.578 73.3153C27.5914 71.6056 18.1404 67.8741 19.014 64.8752ZM38.8008 81.8079C37.6402 79.7824 43.6168 66.2754 48.0609 56.8306C48.1368 56.6723 48.2585 56.5406 48.4104 56.4525C48.5645 56.3646 48.7413 56.3247 48.9183 56.3378C49.0952 56.3509 49.2643 56.4165 49.4038 56.5261C49.5397 56.6357 49.6397 56.7835 49.6908 56.9504C51.4867 63.0905 53.5384 70.3102 55.7323 76.4353C55.8183 76.6753 55.8138 76.9384 55.7198 77.1753C55.6237 77.4141 55.4459 77.6109 55.2181 77.7307C49.7382 80.6448 40.3571 84.5285 38.8071 81.8079H38.8008ZM65.0698 80.1356C62.7785 79.5041 57.2112 65.8324 53.5059 56.0881C53.4438 55.9246 53.4344 55.7458 53.4792 55.5768C53.524 55.4078 53.6206 55.2571 53.7555 55.1458C53.892 55.0319 54.0596 54.9618 54.2366 54.9444C54.4135 54.927 54.5916 54.9633 54.7477 55.0485C60.4722 58.1485 67.1527 61.8438 73.1455 64.6618C73.3814 64.7716 73.5686 64.9613 73.6734 65.1934C73.779 65.4255 73.7963 65.6882 73.7221 65.9322C71.9587 71.7803 68.1436 80.9867 65.0698 80.1356ZM82.4318 60.8392C80.3539 61.9711 66.505 56.143 56.8193 51.8087C56.6586 51.7369 56.5233 51.6181 56.4312 51.468C56.341 51.3188 56.2997 51.145 56.3131 50.9712C56.3266 50.7973 56.394 50.632 56.5061 50.4983C56.6198 50.3626 56.7722 50.2647 56.9429 50.2175C63.2402 48.4678 70.6396 46.4673 76.9219 44.327C77.169 44.2427 77.4378 44.2471 77.682 44.3395C77.9237 44.4304 78.1256 44.6036 78.2523 44.8287C81.2387 50.1726 85.2211 59.3216 82.4318 60.8392ZM80.7183 35.2229C80.0681 37.4568 66.0507 42.8856 56.0593 46.4998C55.8922 46.559 55.7114 46.5675 55.5395 46.5242C55.3676 46.4809 55.2124 46.3877 55.0933 46.2564C54.9777 46.1256 54.9059 45.9619 54.8879 45.7882C54.87 45.6145 54.907 45.4396 54.9935 45.288C58.1721 39.7045 61.9585 33.19 64.8489 27.3456C64.9639 27.1149 65.1572 26.9327 65.3943 26.8314C65.6336 26.7282 65.9014 26.7114 66.1518 26.784C72.1384 28.5025 81.5894 32.224 80.7183 35.2229Z" fill="white"/>
+</svg>
diff --git a/docs/logos/droid.svg b/docs/logos/droid.svg
new file mode 100644
index 0000000000..38aad643a7
--- /dev/null
+++ b/docs/logos/droid.svg
@@ -0,0 +1,8 @@
+<svg xmlns="http://www.w3.org/2000/svg" version="1.1" xmlns:xlink="http://www.w3.org/1999/xlink" width="508" height="508"><svg width="508" height="508" viewBox="0 0 508 508" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_7026_10735)">
+<rect width="508" height="508" fill="#020202"></rect>
+<path d="M321.997 150.712C321.401 150.568 320.844 150.299 320.363 149.925C319.883 149.551 319.491 149.08 319.215 148.544C318.938 148.008 318.783 147.42 318.76 146.821C318.738 146.22 318.848 145.624 319.084 145.07C327.226 125.716 330.819 110.23 325.021 103.747C309.666 86.5471 248.085 120.749 228.451 132.333C227.925 132.642 227.337 132.837 226.728 132.903C226.118 132.969 225.501 132.906 224.918 132.719C224.336 132.531 223.801 132.223 223.351 131.815C222.902 131.407 222.548 130.909 222.313 130.356C214.06 111.043 205.384 97.6094 196.589 97.0268C173.279 95.4688 154.491 162.187 148.991 183.932C148.844 184.515 148.57 185.06 148.188 185.528C147.805 185.998 147.323 186.381 146.775 186.651C146.227 186.921 145.626 187.072 145.012 187.094C144.399 187.116 143.788 187.009 143.221 186.778C123.406 178.825 107.545 175.316 100.914 180.98C83.305 195.978 118.315 256.126 130.175 275.304C130.492 275.816 130.692 276.391 130.76 276.987C130.829 277.582 130.765 278.186 130.573 278.755C130.381 279.325 130.065 279.847 129.647 280.286C129.228 280.725 128.718 281.07 128.15 281.298C108.384 289.359 94.6306 297.834 94.0272 306.424C92.439 329.192 160.74 347.544 183.01 352.916C183.605 353.061 184.16 353.33 184.64 353.704C185.118 354.077 185.509 354.548 185.785 355.083C186.061 355.618 186.215 356.205 186.237 356.803C186.26 357.402 186.151 357.998 185.916 358.551C177.773 377.905 174.181 393.398 179.979 399.874C195.334 417.074 256.921 382.877 276.556 371.293C277.081 370.984 277.67 370.789 278.28 370.722C278.889 370.655 279.507 370.717 280.09 370.905C280.673 371.093 281.207 371.402 281.657 371.81C282.106 372.219 282.46 372.717 282.694 373.271C290.947 392.578 299.616 406.012 308.417 406.601C331.728 408.153 350.516 341.44 356.009 319.688C356.157 319.106 356.432 318.562 356.816 318.094C357.2 317.625 357.682 317.243 358.231 316.974C358.779 316.705 359.381 316.554 359.995 316.533C360.608 316.511 361.219 316.619 361.786 316.85C381.601 324.803 397.455 328.304 404.093 322.648C421.702 307.65 386.684 247.495 374.825 228.317C374.51 227.804 374.312 227.229 374.245 226.634C374.177 226.039 374.242 225.436 374.434 224.868C374.626 224.299 374.941 223.777 375.358 223.338C375.775 222.899 376.284 222.552 376.85 222.323C396.623 214.261 410.376 205.786 410.973 197.196C412.568 174.428 344.26 156.078 321.997 150.712ZM295.254 128.885C299.734 136.73 276.646 189 259.474 225.561C259.186 226.172 258.715 226.682 258.121 227.024C257.528 227.365 256.842 227.521 256.155 227.47C255.468 227.419 254.814 227.164 254.28 226.739C253.746 226.314 253.358 225.739 253.169 225.093C246.234 201.322 238.306 173.392 229.824 149.683C229.491 148.752 229.508 147.736 229.871 146.817C230.235 145.897 230.921 145.133 231.808 144.662C252.989 133.363 289.234 118.358 295.254 128.885ZM193.746 135.355C202.589 137.807 224.103 190.714 238.424 228.426C238.664 229.056 238.699 229.742 238.527 230.393C238.354 231.044 237.983 231.627 237.461 232.065C236.939 232.503 236.292 232.775 235.608 232.844C234.923 232.913 234.234 232.775 233.632 232.45C211.501 220.453 185.694 206.159 162.529 195.253C161.622 194.823 160.901 194.093 160.493 193.192C160.085 192.292 160.018 191.279 160.303 190.335C167.12 167.736 181.865 132.069 193.746 135.355ZM126.652 210.04C134.676 205.664 188.197 228.216 225.621 244.989C226.248 245.269 226.771 245.73 227.12 246.31C227.47 246.889 227.629 247.56 227.577 248.23C227.524 248.901 227.264 249.54 226.828 250.062C226.393 250.582 225.805 250.962 225.143 251.147C200.813 257.921 172.211 265.664 147.937 273.949C146.985 274.272 145.946 274.255 145.007 273.9C144.067 273.545 143.286 272.876 142.805 272.011C131.257 251.322 115.867 215.92 126.652 210.04ZM133.275 309.188C135.779 300.551 189.952 279.537 228.562 265.548C229.207 265.315 229.91 265.28 230.576 265.448C231.243 265.617 231.84 265.98 232.288 266.49C232.736 266.999 233.015 267.631 233.085 268.299C233.155 268.968 233.015 269.641 232.682 270.23C220.392 291.846 205.758 317.053 194.592 339.672C194.156 340.561 193.409 341.269 192.486 341.668C191.563 342.068 190.525 342.134 189.557 341.853C166.42 335.235 129.905 320.792 133.275 309.188ZM209.739 374.722C205.252 366.884 228.347 314.608 245.519 278.054C245.806 277.442 246.279 276.931 246.872 276.59C247.465 276.249 248.151 276.093 248.838 276.144C249.525 276.194 250.179 276.45 250.713 276.875C251.247 277.3 251.634 277.874 251.824 278.521C258.759 302.285 266.686 330.222 275.169 353.932C275.499 354.862 275.481 355.877 275.117 356.795C274.752 357.713 274.064 358.475 273.178 358.945C252.004 370.223 215.752 385.256 209.76 374.722H209.739ZM311.247 368.252C302.397 365.807 280.883 312.894 266.562 275.182C266.322 274.55 266.285 273.862 266.458 273.21C266.63 272.559 267.003 271.974 267.526 271.536C268.049 271.097 268.697 270.826 269.382 270.758C270.068 270.69 270.759 270.83 271.361 271.157C293.485 283.154 319.299 297.455 342.457 308.362C343.366 308.789 344.089 309.519 344.497 310.42C344.905 311.321 344.971 312.335 344.683 313.28C337.872 335.912 323.128 371.544 311.247 368.252ZM378.341 293.566C370.31 297.949 316.795 275.391 279.365 258.618C278.738 258.338 278.215 257.877 277.866 257.297C277.516 256.718 277.357 256.047 277.409 255.377C277.461 254.706 277.722 254.067 278.158 253.546C278.593 253.025 279.181 252.646 279.843 252.461C304.18 245.687 332.775 237.943 357.049 229.658C358.003 229.335 359.043 229.353 359.984 229.709C360.925 230.065 361.706 230.737 362.188 231.603C373.729 252.285 389.119 287.693 378.341 293.566ZM371.718 194.419C369.207 203.063 315.041 224.077 276.431 238.066C275.784 238.3 275.08 238.335 274.413 238.167C273.746 237.999 273.148 237.635 272.698 237.124C272.249 236.613 271.972 235.98 271.903 235.31C271.833 234.641 271.975 233.966 272.311 233.377C284.594 211.768 299.228 186.554 310.394 163.935C310.833 163.048 311.58 162.343 312.502 161.945C313.425 161.546 314.462 161.481 315.429 161.76C338.566 168.413 375.081 182.815 371.718 194.419Z" fill="#FAFAFA"></path>
+</g>
+</svg><style>@media (prefers-color-scheme: light) { :root { filter: none; } }
+@media (prefers-color-scheme: dark) { :root { filter: none; } }
+</style></svg>
\ No newline at end of file
diff --git a/docs/logos/elevenlabs.svg b/docs/logos/elevenlabs.svg
new file mode 100644
index 0000000000..ce9145e074
--- /dev/null
+++ b/docs/logos/elevenlabs.svg
@@ -0,0 +1,4 @@
+<svg viewBox="0 0 32 32" fill="#0a0a0c" xmlns="http://www.w3.org/2000/svg">
+  <path d="M7 6h4v20H7V6Zm7 0h4v20h-4V6Zm7 0h4v20h-4V6Z"/>
+  <path d="M3.5 15h25v2h-25v-2Z" opacity=".35"/>
+</svg>
diff --git a/docs/logos/gemini.svg b/docs/logos/gemini.svg
new file mode 100644
index 0000000000..62681dfa7c
--- /dev/null
+++ b/docs/logos/gemini.svg
@@ -0,0 +1 @@
+<svg height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>Gemini</title><path d="M20.616 10.835a14.147 14.147 0 01-4.45-3.001 14.111 14.111 0 01-3.678-6.452.503.503 0 00-.975 0 14.134 14.134 0 01-3.679 6.452 14.155 14.155 0 01-4.45 3.001c-.65.28-1.318.505-2.002.678a.502.502 0 000 .975c.684.172 1.35.397 2.002.677a14.147 14.147 0 014.45 3.001 14.112 14.112 0 013.679 6.453.502.502 0 00.975 0c.172-.685.397-1.351.677-2.003a14.145 14.145 0 013.001-4.45 14.113 14.113 0 016.453-3.678.503.503 0 000-.975 13.245 13.245 0 01-2.003-.678z" fill="#3186FF"></path><path d="M20.616 10.835a14.147 14.147 0 01-4.45-3.001 14.111 14.111 0 01-3.678-6.452.503.503 0 00-.975 0 14.134 14.134 0 01-3.679 6.452 14.155 14.155 0 01-4.45 3.001c-.65.28-1.318.505-2.002.678a.502.502 0 000 .975c.684.172 1.35.397 2.002.677a14.147 14.147 0 014.45 3.001 14.112 14.112 0 013.679 6.453.502.502 0 00.975 0c.172-.685.397-1.351.677-2.003a14.145 14.145 0 013.001-4.45 14.113 14.113 0 016.453-3.678.503.503 0 000-.975 13.245 13.245 0 01-2.003-.678z" fill="url(#lobe-icons-gemini-0-_R_0_)"></path><path d="M20.616 10.835a14.147 14.147 0 01-4.45-3.001 14.111 14.111 0 01-3.678-6.452.503.503 0 00-.975 0 14.134 14.134 0 01-3.679 6.452 14.155 14.155 0 01-4.45 3.001c-.65.28-1.318.505-2.002.678a.502.502 0 000 .975c.684.172 1.35.397 2.002.677a14.147 14.147 0 014.45 3.001 14.112 14.112 0 013.679 6.453.502.502 0 00.975 0c.172-.685.397-1.351.677-2.003a14.145 14.145 0 013.001-4.45 14.113 14.113 0 016.453-3.678.503.503 0 000-.975 13.245 13.245 0 01-2.003-.678z" fill="url(#lobe-icons-gemini-1-_R_0_)"></path><path d="M20.616 10.835a14.147 14.147 0 01-4.45-3.001 14.111 14.111 0 01-3.678-6.452.503.503 0 00-.975 0 14.134 14.134 0 01-3.679 6.452 14.155 14.155 0 01-4.45 3.001c-.65.28-1.318.505-2.002.678a.502.502 0 000 .975c.684.172 1.35.397 2.002.677a14.147 14.147 0 014.45 3.001 14.112 14.112 0 013.679 6.453.502.502 0 00.975 0c.172-.685.397-1.351.677-2.003a14.145 14.145 0 013.001-4.45 14.113 14.113 0 016.453-3.678.503.503 0 000-.975 13.245 13.245 0 01-2.003-.678z" fill="url(#lobe-icons-gemini-2-_R_0_)"></path><defs><linearGradient gradientUnits="userSpaceOnUse" id="lobe-icons-gemini-0-_R_0_" x1="7" x2="11" y1="15.5" y2="12"><stop stop-color="#08B962"></stop><stop offset="1" stop-color="#08B962" stop-opacity="0"></stop></linearGradient><linearGradient gradientUnits="userSpaceOnUse" id="lobe-icons-gemini-1-_R_0_" x1="8" x2="11.5" y1="5.5" y2="11"><stop stop-color="#F94543"></stop><stop offset="1" stop-color="#F94543" stop-opacity="0"></stop></linearGradient><linearGradient gradientUnits="userSpaceOnUse" id="lobe-icons-gemini-2-_R_0_" x1="3.5" x2="17.5" y1="13.5" y2="12"><stop stop-color="#FABC12"></stop><stop offset=".46" stop-color="#FABC12" stop-opacity="0"></stop></linearGradient></defs></svg>
\ No newline at end of file
diff --git a/docs/logos/jetbrains-ai.svg b/docs/logos/jetbrains-ai.svg
new file mode 100644
index 0000000000..8734b4987e
--- /dev/null
+++ b/docs/logos/jetbrains-ai.svg
@@ -0,0 +1 @@
+<svg viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><defs><linearGradient id="g" x1="0.5" y1="0" x2="0.5" y2="1"><stop offset="0%" stop-color="#B97AF7"/><stop offset="100%" stop-color="#6B4FD8"/></linearGradient></defs><path fill="url(#g)" d="M11.64 18c1.48 0 3.12-.3 4.58-.88.54-.22.78-.42.78-.88 0-.38-.4-.84-1.18-.52-1.28.54-2.82.78-4.18.78-4.98 0-8.14-2.32-8.14-5.46 0-2.5 2.18-4.28 5.08-4.28 2.4 0 4.08 1 4.08 2.24 0 1.08-1.1 1.6-2.64 1l.34-1.02C7.96 8 5.98 9.12 5.98 11c0 2.1 2.32 3.5 5.52 3.5 3.76 0 6.5-2.32 6.5-5.54C18 4.94 14.2 2 8.36 2c-1.48 0-3.12.26-4.58.88-.52.22-.78.48-.78.86 0 .46.46.84 1.18.54C5.46 3.74 7 3.5 8.36 3.5c4.98 0 8.14 2.32 8.14 5.46 0 2.5-2.18 4.28-5.08 4.28-2.4 0-4.08-1-4.08-2.24 0-1.08 1.1-1.6 2.64-1l-.34 1.02c2.4.98 4.38-.14 4.38-2.02 0-2.1-2.32-3.5-5.52-3.5C4.74 5.5 2 7.82 2 11.04 2 15.06 5.8 18 11.64 18"/></svg>
\ No newline at end of file
diff --git a/docs/logos/kilo.svg b/docs/logos/kilo.svg
new file mode 100644
index 0000000000..74c381b1d8
--- /dev/null
+++ b/docs/logos/kilo.svg
@@ -0,0 +1 @@
+<svg fill="#f8f676" fill-rule="evenodd" height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>Kilo Code</title><path d="M0 0v24h24V0H0zm22.222 22.222H1.778V1.778h20.444v20.444zm-7.555-4.964h2.222v1.778h-2.794L12.89 17.83v-2.794h1.778v2.222zm4 0h-1.778v-2.222h-2.222v-1.778h2.793l1.207 1.207v2.793zm-7.556-2.591H9.333v-1.778h1.778v1.778zm-5.778-1.778h1.778v4h4v1.778H6.54L5.333 17.46V12.89zm13.334-3.556v1.778h-5.778V9.333h1.987V7.111h-1.987V5.333h2.558l1.206 1.207v2.793h2.014zm-11.556-2h2.222l1.778 1.778v2H9.333v-2H7.111v2H5.333V5.333h1.778v2zm4 0H9.333v-2h1.778v2z"></path></svg>
\ No newline at end of file
diff --git a/docs/logos/kimi-k2.svg b/docs/logos/kimi-k2.svg
new file mode 100644
index 0000000000..45b894ba54
--- /dev/null
+++ b/docs/logos/kimi-k2.svg
@@ -0,0 +1 @@
+<svg fill="#FE603C" fill-rule="evenodd" role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><title>Kimi</title><path d="M21.846 0a1.923 1.923 0 110 3.846H20.15a.226.226 0 01-.227-.226V1.923C19.923.861 20.784 0 21.846 0z"></path><path d="M11.065 11.199l7.257-7.2c.137-.136.06-.41-.116-.41H14.3a.164.164 0 00-.117.051l-7.82 7.756c-.122.12-.302.013-.302-.179V3.82c0-.127-.083-.23-.185-.23H3.186c-.103 0-.186.103-.186.23V19.77c0 .128.083.23.186.23h2.69c.103 0 .186-.102.186-.23v-3.25c0-.069.025-.135.069-.178l2.424-2.406a.158.158 0 01.205-.023l6.484 4.772a7.677 7.677 0 003.453 1.283c.108.012.2-.095.2-.23v-3.06c0-.117-.07-.212-.164-.227a5.028 5.028 0 01-2.027-.807l-5.613-4.064c-.117-.078-.132-.279-.028-.381z"></path></svg>
diff --git a/docs/logos/kimi.svg b/docs/logos/kimi.svg
new file mode 100644
index 0000000000..45b894ba54
--- /dev/null
+++ b/docs/logos/kimi.svg
@@ -0,0 +1 @@
+<svg fill="#FE603C" fill-rule="evenodd" role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><title>Kimi</title><path d="M21.846 0a1.923 1.923 0 110 3.846H20.15a.226.226 0 01-.227-.226V1.923C19.923.861 20.784 0 21.846 0z"></path><path d="M11.065 11.199l7.257-7.2c.137-.136.06-.41-.116-.41H14.3a.164.164 0 00-.117.051l-7.82 7.756c-.122.12-.302.013-.302-.179V3.82c0-.127-.083-.23-.185-.23H3.186c-.103 0-.186.103-.186.23V19.77c0 .128.083.23.186.23h2.69c.103 0 .186-.102.186-.23v-3.25c0-.069.025-.135.069-.178l2.424-2.406a.158.158 0 01.205-.023l6.484 4.772a7.677 7.677 0 003.453 1.283c.108.012.2-.095.2-.23v-3.06c0-.117-.07-.212-.164-.227a5.028 5.028 0 01-2.027-.807l-5.613-4.064c-.117-.078-.132-.279-.028-.381z"></path></svg>
diff --git a/docs/logos/kiro-dark.svg b/docs/logos/kiro-dark.svg
new file mode 100644
index 0000000000..6dfa798ded
--- /dev/null
+++ b/docs/logos/kiro-dark.svg
@@ -0,0 +1,19 @@
+<?xml version="1.0" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 20010904//EN"
+ "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">
+<svg version="1.0" xmlns="http://www.w3.org/2000/svg"
+ width="48.000000pt" height="48.000000pt" viewBox="0 0 48.000000 48.000000"
+ preserveAspectRatio="xMidYMid meet">
+<metadata>
+Created by potrace 1.16, written by Peter Selinger 2001-2019
+</metadata>
+<g transform="translate(0.000000,48.000000) scale(0.100000,-0.100000)"
+fill="#ffffff" stroke="none">
+<path d="M175 367 c-25 -25 -35 -45 -40 -83 -3 -27 -10 -59 -16 -72 -15 -37
+-11 -63 10 -69 12 -3 21 -15 23 -32 2 -20 9 -27 30 -29 15 -2 36 2 48 8 13 7
+20 7 20 0 0 -13 36 -13 62 1 32 17 58 86 58 157 0 103 -38 152 -118 152 -36 0
+-50 -6 -77 -33z m93 -86 c3 -16 -1 -22 -10 -19 -7 3 -15 15 -16 27 -3 16 1 22
+10 19 7 -3 15 -15 16 -27z m52 4 c0 -26 -14 -33 -25 -15 -9 14 1 40 15 40 5 0
+10 -11 10 -25z"/>
+</g>
+</svg>
diff --git a/docs/logos/kiro.svg b/docs/logos/kiro.svg
new file mode 100644
index 0000000000..5fe3cf6847
--- /dev/null
+++ b/docs/logos/kiro.svg
@@ -0,0 +1,11 @@
+<svg width="1200" height="1200" viewBox="0 0 1200 1200" fill="none" xmlns="http://www.w3.org/2000/svg">
+<rect width="1200" height="1200" rx="260" fill="#9046FF"/>
+<mask id="mask0_1106_4856" style="mask-type:luminance" maskUnits="userSpaceOnUse" x="272" y="202" width="655" height="796">
+<path d="M926.578 202.793H272.637V997.857H926.578V202.793Z" fill="white"/>
+</mask>
+<g mask="url(#mask0_1106_4856)">
+<path d="M398.554 818.914C316.315 1001.03 491.477 1046.74 620.672 940.156C658.687 1059.66 801.052 970.473 852.234 877.795C964.787 673.567 919.318 465.357 907.64 422.374C827.637 129.443 427.623 128.946 358.8 423.865C342.651 475.544 342.402 534.18 333.458 595.051C328.986 625.86 325.507 645.488 313.83 677.785C306.873 696.424 297.68 712.819 282.773 740.645C259.915 783.881 269.604 867.113 387.87 823.883L399.051 818.914H398.554Z" fill="white"/>
+<path d="M636.123 549.353C603.328 549.353 598.359 510.097 598.359 486.742C598.359 465.623 602.086 448.977 609.293 438.293C615.504 428.852 624.697 424.131 636.123 424.131C647.555 424.131 657.492 428.852 664.447 438.541C672.398 449.474 676.623 466.12 676.623 486.742C676.623 525.998 661.471 549.353 636.375 549.353H636.123Z" fill="black"/>
+<path d="M771.24 549.353C738.445 549.353 733.477 510.097 733.477 486.742C733.477 465.623 737.203 448.977 744.41 438.293C750.621 428.852 759.814 424.131 771.24 424.131C782.672 424.131 792.609 428.852 799.564 438.541C807.516 449.474 811.74 466.12 811.74 486.742C811.74 525.998 796.588 549.353 771.492 549.353H771.24Z" fill="black"/>
+</g>
+</svg>
diff --git a/docs/logos/litellm.svg b/docs/logos/litellm.svg
new file mode 100644
index 0000000000..3a6c20b880
--- /dev/null
+++ b/docs/logos/litellm.svg
@@ -0,0 +1,16 @@
+<svg viewBox="0 0 32 32" xmlns="http://www.w3.org/2000/svg">
+  <g fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M8.1 12.4C12.5 8.8 17.7 6.3 22.4 5.7c0-.5.5-.7 1-.8 1.8-.4 4.1-.5 5.8-.5.6 0 1 .4 1 1v19c0 .6-.4 1-1 1H10c-.7 0-1.3 0-1.9-.1V12.4Z" stroke-width="1.35"/>
+    <path d="M8.1 12.4C5 14.8 3 17 2.8 19.2c-.2 1.9 1.8 3.5 5.3 4.5V12.4Z" fill="currentColor" stroke-width="1.35"/>
+    <path d="M10.6 19.5h3.7" stroke-width="1.35"/>
+    <path d="M20.6 25.5l-1.3 2.6c.5.3 1.1.4 1.7.2.9-.2 1.6-1.2 1.7-2.8" stroke-width="1.2"/>
+    <path d="M25.3 25.5c.1 1.8 1.2 3 2.6 3s2.5-1.2 2.6-3" stroke-width="1.2"/>
+    <path d="M25.3 15.5h2.9c.5 0 .9.4.9.9v6.9c0 .5-.4.9-.9.9h-2.9c-.5 0-.9-.4-.9-.9v-6.9c0-.5.4-.9.9-.9Z" stroke-width="1.2"/>
+    <path d="M17.3 22.6h7.1m4.7 0h1.1" stroke-width="1.05"/>
+  </g>
+  <path d="M12.9 13.1c4.2-2.3 8.3-3.5 12.7-3.6.8.2 1.8 1.5 2.4 3.1-5.3.2-10.3.8-15.2 2.6-1.2.4-1.5-1.2.1-2.1Z" fill="currentColor"/>
+  <path d="M20.4 16.5h4v5.4h-6.6l2.6-5.4Z" fill="currentColor"/>
+  <path d="M29.1 16.5h1.1v5.4h-1.1v-5.4Z" fill="currentColor"/>
+  <path d="M10.9 25.5h9.5l-1.6 2.3H10c-.8 0-1.1-.7-.7-1.3l1.6-1Z" fill="currentColor"/>
+  <path d="M25.8 25.5h4c-.1 1.2-.9 2.1-2 2.1s-1.9-.9-2-2.1Z" fill="currentColor"/>
+</svg>
diff --git a/docs/logos/minimax.svg b/docs/logos/minimax.svg
new file mode 100644
index 0000000000..b1b0a6a2df
--- /dev/null
+++ b/docs/logos/minimax.svg
@@ -0,0 +1 @@
+<svg fill="#E73562" role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><title>MiniMax</title><path d="M11.43 3.92a.86.86 0 1 0-1.718 0v14.236a1.999 1.999 0 0 1-3.997 0V9.022a.86.86 0 1 0-1.718 0v3.87a1.999 1.999 0 0 1-3.997 0V11.49a.57.57 0 0 1 1.139 0v1.404a.86.86 0 0 0 1.719 0V9.022a1.999 1.999 0 0 1 3.997 0v9.134a.86.86 0 0 0 1.719 0V3.92a1.998 1.998 0 1 1 3.996 0v11.788a.57.57 0 1 1-1.139 0zm10.572 3.105a2 2 0 0 0-1.999 1.997v7.63a.86.86 0 0 1-1.718 0V3.923a1.999 1.999 0 0 0-3.997 0v16.16a.86.86 0 0 1-1.719 0V18.08a.57.57 0 1 0-1.138 0v2a1.998 1.998 0 0 0 3.996 0V3.92a.86.86 0 0 1 1.719 0v12.73a1.999 1.999 0 0 0 3.996 0V9.023a.86.86 0 1 1 1.72 0v6.686a.57.57 0 0 0 1.138 0V9.022a2 2 0 0 0-1.998-1.997"/></svg>
\ No newline at end of file
diff --git a/docs/logos/mistral.svg b/docs/logos/mistral.svg
new file mode 100644
index 0000000000..00ee1b9e51
--- /dev/null
+++ b/docs/logos/mistral.svg
@@ -0,0 +1 @@
+<svg fill="#FA520F" role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><title>Mistral AI</title><path d="M17.143 3.429v3.428h-3.429v3.429h-3.428V6.857H6.857V3.43H3.43v13.714H0v3.428h10.286v-3.428H6.857v-3.429h3.429v3.429h3.429v-3.429h3.428v3.429h-3.428v3.428H24v-3.428h-3.43V3.429z"/></svg>
\ No newline at end of file
diff --git a/docs/logos/ollama.svg b/docs/logos/ollama.svg
new file mode 100644
index 0000000000..432f73e738
--- /dev/null
+++ b/docs/logos/ollama.svg
@@ -0,0 +1 @@
+<svg fill="#000000" role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><title>Ollama</title><path d="M16.361 10.26a.894.894 0 0 0-.558.47l-.072.148.001.207c0 .193.004.217.059.353.076.193.152.312.291.448.24.238.51.3.872.205a.86.86 0 0 0 .517-.436.752.752 0 0 0 .08-.498c-.064-.453-.33-.782-.724-.897a1.06 1.06 0 0 0-.466 0zm-9.203.005c-.305.096-.533.32-.65.639a1.187 1.187 0 0 0-.06.52c.057.309.31.59.598.667.362.095.632.033.872-.205.14-.136.215-.255.291-.448.055-.136.059-.16.059-.353l.001-.207-.072-.148a.894.894 0 0 0-.565-.472 1.02 1.02 0 0 0-.474.007Zm4.184 2c-.131.071-.223.25-.195.383.031.143.157.288.353.407.105.063.112.072.117.136.004.038-.01.146-.029.243-.02.094-.036.194-.036.222.002.074.07.195.143.253.064.052.076.054.255.059.164.005.198.001.264-.03.169-.082.212-.234.15-.525-.052-.243-.042-.28.087-.355.137-.08.281-.219.324-.314a.365.365 0 0 0-.175-.48.394.394 0 0 0-.181-.033c-.126 0-.207.03-.355.124l-.085.053-.053-.032c-.219-.13-.259-.145-.391-.143a.396.396 0 0 0-.193.032zm.39-2.195c-.373.036-.475.05-.654.086-.291.06-.68.195-.951.328-.94.46-1.589 1.226-1.787 2.114-.04.176-.045.234-.045.53 0 .294.005.357.043.524.264 1.16 1.332 2.017 2.714 2.173.3.033 1.596.033 1.896 0 1.11-.125 2.064-.727 2.493-1.571.114-.226.169-.372.22-.602.039-.167.044-.23.044-.523 0-.297-.005-.355-.045-.531-.288-1.29-1.539-2.304-3.072-2.497a6.873 6.873 0 0 0-.855-.031zm.645.937a3.283 3.283 0 0 1 1.44.514c.223.148.537.458.671.662.166.251.26.508.303.82.02.143.01.251-.043.482-.08.345-.332.705-.672.957a3.115 3.115 0 0 1-.689.348c-.382.122-.632.144-1.525.138-.582-.006-.686-.01-.853-.042-.57-.107-1.022-.334-1.35-.68-.264-.28-.385-.535-.45-.946-.03-.192.025-.509.137-.776.136-.326.488-.73.836-.963.403-.269.934-.46 1.422-.512.187-.02.586-.02.773-.002zm-5.503-11a1.653 1.653 0 0 0-.683.298C5.617.74 5.173 1.666 4.985 2.819c-.07.436-.119 1.04-.119 1.503 0 .544.064 1.24.155 1.721.02.107.031.202.023.208a8.12 8.12 0 0 1-.187.152 5.324 5.324 0 0 0-.949 1.02 5.49 5.49 0 0 0-.94 2.339 6.625 6.625 0 0 0-.023 1.357c.091.78.325 1.438.727 2.04l.13.195-.037.064c-.269.452-.498 1.105-.605 1.732-.084.496-.095.629-.095 1.294 0 .67.009.803.088 1.266.095.555.288 1.143.503 1.534.071.128.243.393.264.407.007.003-.014.067-.046.141a7.405 7.405 0 0 0-.548 1.873c-.062.417-.071.552-.071.991 0 .56.031.832.148 1.279L3.42 24h1.478l-.05-.091c-.297-.552-.325-1.575-.068-2.597.117-.472.25-.819.498-1.296l.148-.29v-.177c0-.165-.003-.184-.057-.293a.915.915 0 0 0-.194-.25 1.74 1.74 0 0 1-.385-.543c-.424-.92-.506-2.286-.208-3.451.124-.486.329-.918.544-1.154a.787.787 0 0 0 .223-.531c0-.195-.07-.355-.224-.522a3.136 3.136 0 0 1-.817-1.729c-.14-.96.114-2.005.69-2.834.563-.814 1.353-1.336 2.237-1.475.199-.033.57-.028.776.01.226.04.367.028.512-.041.179-.085.268-.19.374-.431.093-.215.165-.333.36-.576.234-.29.46-.489.822-.729.413-.27.884-.467 1.352-.561.17-.035.25-.04.569-.04.319 0 .398.005.569.04a4.07 4.07 0 0 1 1.914.997c.117.109.398.457.488.602.034.057.095.177.132.267.105.241.195.346.374.43.14.068.286.082.503.045.343-.058.607-.053.943.016 1.144.23 2.14 1.173 2.581 2.437.385 1.108.276 2.267-.296 3.153-.097.15-.193.27-.333.419-.301.322-.301.722-.001 1.053.493.539.801 1.866.708 3.036-.062.772-.26 1.463-.533 1.854a2.096 2.096 0 0 1-.224.258.916.916 0 0 0-.194.25c-.054.109-.057.128-.057.293v.178l.148.29c.248.476.38.823.498 1.295.253 1.008.231 2.01-.059 2.581a.845.845 0 0 0-.044.098c0 .006.329.009.732.009h.73l.02-.074.036-.134c.019-.076.057-.3.088-.516.029-.217.029-1.016 0-1.258-.11-.875-.295-1.57-.597-2.226-.032-.074-.053-.138-.046-.141.008-.005.057-.074.108-.152.376-.569.607-1.284.724-2.228.031-.26.031-1.378 0-1.628-.083-.645-.182-1.082-.348-1.525a6.083 6.083 0 0 0-.329-.7l-.038-.064.131-.194c.402-.604.636-1.262.727-2.04a6.625 6.625 0 0 0-.024-1.358 5.512 5.512 0 0 0-.939-2.339 5.325 5.325 0 0 0-.95-1.02 8.097 8.097 0 0 1-.186-.152.692.692 0 0 1 .023-.208c.208-1.087.201-2.443-.017-3.503-.19-.924-.535-1.658-.98-2.082-.354-.338-.716-.482-1.15-.455-.996.059-1.8 1.205-2.116 3.01a6.805 6.805 0 0 0-.097.726c0 .036-.007.066-.015.066a.96.96 0 0 1-.149-.078A4.857 4.857 0 0 0 12 3.03c-.832 0-1.687.243-2.456.698a.958.958 0 0 1-.148.078c-.008 0-.015-.03-.015-.066a6.71 6.71 0 0 0-.097-.725C8.997 1.392 8.337.319 7.46.048a2.096 2.096 0 0 0-.585-.041Zm.293 1.402c.248.197.523.759.682 1.388.03.113.06.244.069.292.007.047.026.152.041.233.067.365.098.76.102 1.24l.002.475-.12.175-.118.178h-.278c-.324 0-.646.041-.954.124l-.238.06c-.033.007-.038-.003-.057-.144a8.438 8.438 0 0 1 .016-2.323c.124-.788.413-1.501.696-1.711.067-.05.079-.049.157.013zm9.825-.012c.17.126.358.46.498.888.28.854.36 2.028.212 3.145-.019.14-.024.151-.057.144l-.238-.06a3.693 3.693 0 0 0-.954-.124h-.278l-.119-.178-.119-.175.002-.474c.004-.669.066-1.19.214-1.772.157-.623.434-1.185.68-1.382.078-.062.09-.063.159-.012z"/></svg>
\ No newline at end of file
diff --git a/docs/logos/opencode-dark.svg b/docs/logos/opencode-dark.svg
new file mode 100644
index 0000000000..ff40ad7928
--- /dev/null
+++ b/docs/logos/opencode-dark.svg
@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 54 42" fill="none">
+  <path d="M18 30H6V18H18V30Z" fill="#4B4646"/>
+  <path d="M18 12H6V30H18V12ZM24 36H0V6H24V36Z" fill="#F1ECEC"/>
+  <path d="M54 30H36V18H54V30Z" fill="#4B4646"/>
+  <path d="M54 12H36V30H54V36H30V6H54V12Z" fill="#F1ECEC"/>
+</svg>
diff --git a/docs/logos/opencode.svg b/docs/logos/opencode.svg
new file mode 100644
index 0000000000..e215d428c7
--- /dev/null
+++ b/docs/logos/opencode.svg
@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 54 42" fill="none">
+  <path d="M18 30H6V18H18V30Z" fill="#CFCECD"/>
+  <path d="M18 12H6V30H18V12ZM24 36H0V6H24V36Z" fill="#211E1E"/>
+  <path d="M54 30H36V18H54V30Z" fill="#CFCECD"/>
+  <path d="M54 12H36V30H54V36H30V6H54V12Z" fill="#211E1E"/>
+</svg>
diff --git a/docs/logos/openrouter.svg b/docs/logos/openrouter.svg
new file mode 100644
index 0000000000..c3ce7aab31
--- /dev/null
+++ b/docs/logos/openrouter.svg
@@ -0,0 +1 @@
+<svg fill="#94A3B8" role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><title>OpenRouter</title><path d="M16.778 1.844v1.919q-.569-.026-1.138-.032-.708-.008-1.415.037c-1.93.126-4.023.728-6.149 2.237-2.911 2.066-2.731 1.95-4.14 2.75-.396.223-1.342.574-2.185.798-.841.225-1.753.333-1.751.333v4.229s.768.108 1.61.333c.842.224 1.789.575 2.185.799 1.41.798 1.228.683 4.14 2.75 2.126 1.509 4.22 2.11 6.148 2.236.88.058 1.716.041 2.555.005v1.918l7.222-4.168-7.222-4.17v2.176c-.86.038-1.611.065-2.278.021-1.364-.09-2.417-.357-3.979-1.465-2.244-1.593-2.866-2.027-3.68-2.508.889-.518 1.449-.906 3.822-2.59 1.56-1.109 2.614-1.377 3.978-1.466.667-.044 1.418-.017 2.278.02v2.176L24 6.014Z"/></svg>
\ No newline at end of file
diff --git a/docs/logos/perplexity.svg b/docs/logos/perplexity.svg
new file mode 100644
index 0000000000..42968a82ec
--- /dev/null
+++ b/docs/logos/perplexity.svg
@@ -0,0 +1 @@
+<svg fill="#1FB8CD" role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><title>Perplexity</title><path d="M22.3977 7.0896h-2.3106V.0676l-7.5094 6.3542V.1577h-1.1554v6.1966L4.4904 0v7.0896H1.6023v10.3976h2.8882V24l6.932-6.3591v6.2005h1.1554v-6.0469l6.9318 6.1807v-6.4879h2.8882V7.0896zm-3.4657-4.531v4.531h-5.355l5.355-4.531zm-13.2862.0676 4.8691 4.4634H5.6458V2.6262zM2.7576 16.332V8.245h7.8476l-6.1149 6.1147v1.9723H2.7576zm2.8882 5.0404v-3.8852h.0001v-2.6488l5.7763-5.7764v7.0111l-5.7764 5.2993zm12.7086.0248-5.7766-5.1509V9.0618l5.7766 5.7766v6.5588zm2.8882-5.0652h-1.733v-1.9723L13.3948 8.245h7.8478v8.087z"/></svg>
\ No newline at end of file
diff --git a/docs/logos/poe.svg b/docs/logos/poe.svg
new file mode 100644
index 0000000000..757be15421
--- /dev/null
+++ b/docs/logos/poe.svg
@@ -0,0 +1 @@
+<svg fill="#26AD61" fill-rule="evenodd" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><title>Poe</title><path d="M12.003 2C6.48 2 2 6.48 2 12s4.48 10 10.003 10 10.003-4.48 10.003-10S17.526 2 12.003 2zm4.45 13.897c-.397.6-.968.963-1.71.963-.742 0-1.313-.363-1.71-.963-.445-.668-.58-1.457-.41-2.347.172-.892.628-1.605 1.25-2.07.624-.462 1.34-.65 2.124-.65.79 0 1.53.216 2.13.65.64.494 1.11 1.232 1.29 2.14.18.91.04 1.72-.43 2.43-.42.64-1.05 1.03-1.88 1.03-.74 0-1.34-.36-1.75-1.03v2.85H12.003v-3.01l1.67.002c.59.002 1.01.27 1.25.8.26.57.21 1.23-.18 1.95-.4.71-1.07 1.07-2.06 1.07-1 0-1.69-.36-2.1-1.07-.4-.72-.51-1.52-.31-2.39.19-.87.64-1.54 1.34-2.01.7-.47 1.55-.7 2.52-.7.84 0 1.63.18 2.32.52.7.34 1.24.8 1.61 1.34l-1.24.8c-.56-.8-1.5-1.2-2.82-1.2-1.1 0-1.91.35-2.4 1.05-.49.7-.58 1.55-.27 2.57.32 1 .95 1.5 1.88 1.5.93 0 1.61-.4 2.05-1.2.27-.47.37-.97.3-1.5h-3.14v-1.2h4.45z"/></svg>
diff --git a/docs/logos/synthetic-dark.svg b/docs/logos/synthetic-dark.svg
new file mode 100644
index 0000000000..b50f4da2cc
--- /dev/null
+++ b/docs/logos/synthetic-dark.svg
@@ -0,0 +1,14 @@
+<svg width="100" height="100" viewBox="0 0 54 54" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M27.8517 26.3314C27.8439 26.1451 27.8371 25.9303 27.8337 25.692C27.8203 24.7571 27.8545 23.4581 28.0457 22.0052C28.4322 19.0688 29.4394 15.6521 31.8222 13.2693C34.205 10.8867 37.6212 9.87992 40.5575 9.49344C42.0107 9.30219 43.3101 9.26734 44.245 9.28076C44.4829 9.28417 44.6968 9.29231 44.883 9.30009C44.8908 9.48595 44.8975 9.69933 44.901 9.93676C44.9144 10.8716 44.8795 12.171 44.6883 13.6242C44.3018 16.5605 43.2958 19.9773 40.9131 22.3602C38.5303 24.743 35.1129 25.7495 32.1765 26.136C30.7234 26.3272 29.4246 26.3614 28.4897 26.348C28.2518 26.3446 28.0378 26.3392 27.8517 26.3314Z" stroke="white" stroke-width="2.5"/>
+<path d="M27.8916 27.1592C28.0179 27.0219 28.165 26.8653 28.3311 26.6943C28.9826 26.0238 29.9253 25.1295 31.0879 24.2373C33.4375 22.4342 36.5658 20.7305 39.9355 20.7305C43.3051 20.7306 46.4327 22.4343 48.7822 24.2373C49.945 25.1296 50.8885 26.0238 51.54 26.6943C51.7059 26.865 51.8514 27.022 51.9775 27.1592C51.8516 27.2961 51.7055 27.4518 51.54 27.6221C50.8885 28.2926 49.945 29.1868 48.7822 30.0791C46.4327 31.8821 43.3052 33.5868 39.9355 33.5869C36.5657 33.5869 33.4375 31.8822 31.0879 30.0791C29.9252 29.1868 28.9826 28.2926 28.3311 27.6221C28.1652 27.4514 28.0177 27.2963 27.8916 27.1592Z" stroke="white" stroke-width="2.5"/>
+<path d="M27.4459 27.6915C27.6323 27.6837 27.8471 27.677 28.0854 27.6736C29.0202 27.6602 30.3192 27.6943 31.7721 27.8856C34.7085 28.272 38.1253 29.2793 40.5081 31.6621C42.8906 34.0448 43.8974 37.4611 44.2839 40.3973C44.4752 41.8505 44.51 43.1499 44.4966 44.0848C44.4932 44.3228 44.485 44.5367 44.4773 44.7229C44.2914 44.7306 44.078 44.7374 43.8406 44.7408C42.9057 44.7542 41.6063 44.7194 40.1531 44.5281C37.2168 44.1417 33.8 43.1356 31.4172 40.753C29.0343 38.3701 28.0278 34.9528 27.6413 32.0163C27.4501 30.5633 27.4159 29.2644 27.4294 28.3296C27.4328 28.0916 27.4381 27.8777 27.4459 27.6915Z" stroke="white" stroke-width="2.5"/>
+<path d="M26.916 28.1289C27.0533 28.2552 27.2099 28.4023 27.3809 28.5684C28.0514 29.2199 28.9457 30.1626 29.8379 31.3252C31.641 33.6748 33.3447 36.8031 33.3447 40.1728C33.3446 43.5424 31.6409 46.67 29.8379 49.0195C28.9456 50.1823 28.0514 51.1258 27.3809 51.7773C27.2102 51.9432 27.0532 52.0887 26.916 52.2148C26.7791 52.0889 26.6234 51.9428 26.4531 51.7773C25.7826 51.1258 24.8884 50.1823 23.9961 49.0195C22.1931 46.67 20.4884 43.5426 20.4883 40.1728C20.4883 36.803 22.193 33.6748 23.9961 31.3252C24.8884 30.1625 25.7826 29.2199 26.4531 28.5684C26.6238 28.4025 26.7789 28.255 26.916 28.1289Z" stroke="white" stroke-width="2.5"/>
+<path d="M26.2147 27.691C26.2225 27.8774 26.2293 28.0922 26.2327 28.3305C26.2461 29.2653 26.2119 30.5643 26.0207 32.0172C25.6342 34.9536 24.627 38.3704 22.2442 40.7532C19.8614 43.1357 16.4452 44.1425 13.5089 44.529C12.0557 44.7203 10.7563 44.7551 9.82145 44.7417C9.58349 44.7383 9.36957 44.7301 9.1834 44.7224C9.17564 44.5365 9.16886 44.3231 9.16545 44.0857C9.15203 43.1508 9.18689 41.8514 9.37813 40.3982C9.76458 37.4619 10.7706 34.0451 13.1533 31.6623C15.5361 29.2795 18.9535 28.2729 21.8899 27.8865C23.343 27.6952 24.6419 27.6611 25.5767 27.6745C25.8146 27.6779 26.0286 27.6833 26.2147 27.691Z" stroke="white" stroke-width="2.5"/>
+<path d="M25.7021 27.1602C25.5759 27.2974 25.4288 27.4541 25.2627 27.625C24.6111 28.2955 23.6684 29.1899 22.5059 30.082C20.1562 31.8851 17.028 33.5889 13.6582 33.5889C10.2886 33.5887 7.16105 31.885 4.81153 30.082C3.64873 29.1897 2.70529 28.2955 2.05372 27.625C1.88786 27.4543 1.74236 27.2973 1.61622 27.1602C1.74215 27.0232 1.88824 26.8676 2.05372 26.6973C2.70527 26.0267 3.64874 25.1326 4.81153 24.2402C7.16108 22.4372 10.2885 20.7326 13.6582 20.7324C17.0281 20.7324 20.1562 22.4371 22.5059 24.2402C23.6686 25.1325 24.6112 26.0268 25.2627 26.6973C25.4285 26.8679 25.576 27.023 25.7021 27.1602Z" stroke="white" stroke-width="2.5"/>
+<path d="M25.7338 25.9813C25.5474 25.9891 25.3326 25.9959 25.0943 25.9993C24.1595 26.0127 22.8605 25.9785 21.4076 25.7873C18.4712 25.4008 15.0544 24.3936 12.6716 22.0108C10.2891 19.628 9.28226 16.2118 8.89579 13.2755C8.70453 11.8223 8.66969 10.5229 8.6831 9.58806C8.68652 9.35009 8.69466 9.13618 8.70244 8.95C8.8883 8.94224 9.10168 8.93546 9.33911 8.93205C10.274 8.91863 11.5734 8.95349 13.0266 9.14473C15.9629 9.53118 19.3797 10.5372 21.7625 12.9199C24.1454 15.3027 25.1519 18.7201 25.5383 21.6565C25.7296 23.1096 25.7638 24.4085 25.7503 25.3433C25.7469 25.5812 25.7415 25.7952 25.7338 25.9813Z" stroke="white" stroke-width="2.5"/>
+<path d="M26.9121 25.7031C26.7748 25.5769 26.6182 25.4298 26.4473 25.2637C25.7768 24.6121 24.8824 23.6694 23.9902 22.5068C22.1872 20.1572 20.4834 17.029 20.4834 13.6592C20.4835 10.2896 22.1873 7.16203 23.9902 4.8125C24.8826 3.6497 25.7767 2.70627 26.4473 2.05469C26.618 1.88883 26.775 1.74333 26.9121 1.61719C27.049 1.74312 27.2047 1.88921 27.375 2.05469C28.0455 2.70624 28.9397 3.64971 29.832 4.8125C31.6351 7.16206 33.3397 10.2895 33.3398 13.6592C33.3398 17.029 31.6351 20.1572 29.832 22.5068C28.9398 23.6695 28.0455 24.6121 27.375 25.2637C27.2043 25.4295 27.0492 25.577 26.9121 25.7031Z" stroke="white" stroke-width="2.5"/>
+<g transform="translate(21.7222 21.7222) scale(0.5555556)">
+<path d="M8.56067 1.3799L10.4618 1.34671C10.5492 1.34522 10.6286 1.38935 10.6747 1.45923L10.7093 1.53774L11.045 2.92076C11.1559 3.37707 11.4798 3.75232 11.9152 3.92819C12.3419 4.10041 12.8251 4.0605 13.2183 3.82145L14.3036 3.16178C14.3771 3.11703 14.4662 3.1144 14.5407 3.14983L14.6099 3.19745L15.9965 4.57385C16.0577 4.63461 16.0825 4.72126 16.0659 4.80217L16.035 4.88085L15.4788 5.80573C15.2386 6.20505 15.1867 6.68631 15.3299 7.12299L15.4034 7.30728C15.5966 7.71593 15.9524 8.02086 16.3793 8.15073L16.5666 8.19532L17.4238 8.34639C17.5414 8.36729 17.628 8.46852 17.6302 8.58794L17.6642 10.533C17.6662 10.6479 17.5891 10.7499 17.478 10.7794L16.3785 11.0721C15.9508 11.1859 15.5956 11.4767 15.399 11.8666L15.3249 12.0398C15.1648 12.4858 15.2187 12.9804 15.4714 13.3812L16.0028 14.2246C16.0497 14.2991 16.0532 14.3908 16.0168 14.4666L15.9672 14.5358L14.5394 15.9448C14.4825 16.0008 14.4038 16.025 14.3277 16.0139L14.2531 15.9908L13.2136 15.4747C12.8594 15.2989 12.4528 15.2697 12.0801 15.388L11.9219 15.4474C11.5639 15.6067 11.2838 15.8977 11.1361 16.2562L11.0812 16.4134L10.7617 17.5217C10.7312 17.6271 10.6352 17.7006 10.5255 17.7026L8.58735 17.7364C8.46855 17.7385 8.36456 17.6565 8.33878 17.5405L8.08316 16.3817L8.03422 16.2078C7.91462 15.8694 7.67485 15.5859 7.36105 15.4118L7.19756 15.3345L7.04329 15.2815C6.73077 15.1941 6.39776 15.2128 6.0968 15.3342L5.94955 15.4032L4.77293 16.0371C4.6979 16.0774 4.60969 16.0756 4.53755 16.0373L4.47222 15.9877L3.13752 14.5596C3.0776 14.4954 3.05736 14.4064 3.07873 14.3252L3.11353 14.2484L3.7373 13.3331C3.98342 12.9717 4.04895 12.5208 3.923 12.109L3.85746 11.9353L3.78169 11.7911C3.61486 11.5129 3.35814 11.2998 3.05423 11.1865L2.89807 11.1374L1.49728 10.7907C1.38749 10.7635 1.30969 10.6659 1.30755 10.5528L1.27503 8.6898C1.27334 8.58474 1.33722 8.49154 1.43207 8.45363L1.47385 8.44118L2.69615 8.18641C3.14512 8.09283 3.52318 7.80066 3.72943 7.39873L3.80738 7.2196C3.94662 6.83155 3.92084 6.40585 3.73992 6.04091L3.6523 5.8891L3.04806 4.9581C2.98255 4.85725 2.99751 4.72403 3.08453 4.64101L4.58516 3.20932C4.67146 3.12699 4.80459 3.11666 4.90217 3.18523L5.71797 3.75897C6.12951 4.04818 6.65895 4.11193 7.1274 3.92874C7.53749 3.76829 7.85309 3.43752 7.99657 3.02769L8.04812 2.84707L8.32092 1.57747C8.34533 1.46387 8.44449 1.38193 8.56067 1.3799Z" fill="white" stroke="white" stroke-width="1.5"/>
+<circle cx="9.46694" cy="9.5416" r="2.53895" transform="rotate(-1 9.46694 9.5416)" fill="white" stroke="white" stroke-width="1.5"/>
+</g>
+</svg>
diff --git a/docs/logos/synthetic.svg b/docs/logos/synthetic.svg
new file mode 100644
index 0000000000..87dfcb7383
--- /dev/null
+++ b/docs/logos/synthetic.svg
@@ -0,0 +1,12 @@
+<svg xmlns="http://www.w3.org/2000/svg" version="1.1" xmlns:xlink="http://www.w3.org/1999/xlink" width="1000" height="1000"><g clip-path="url(#SvgjsClipPath1024)"><rect width="1000" height="1000" fill="#ffffff"></rect><g transform="matrix(14.814814814814815,0,0,14.814814814814815,100,100)"><svg xmlns="http://www.w3.org/2000/svg" version="1.1" xmlns:xlink="http://www.w3.org/1999/xlink" width="54" height="54"><svg width="54" height="54" viewBox="0 0 54 54" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M27.8517 26.3314C27.8439 26.1451 27.8371 25.9303 27.8337 25.692C27.8203 24.7571 27.8545 23.4581 28.0457 22.0052C28.4322 19.0688 29.4394 15.6521 31.8222 13.2693C34.205 10.8867 37.6212 9.87992 40.5575 9.49344C42.0107 9.30219 43.3101 9.26734 44.245 9.28076C44.4829 9.28417 44.6968 9.29231 44.883 9.30009C44.8908 9.48595 44.8975 9.69933 44.901 9.93676C44.9144 10.8716 44.8795 12.171 44.6883 13.6242C44.3018 16.5605 43.2958 19.9773 40.9131 22.3602C38.5303 24.743 35.1129 25.7495 32.1765 26.136C30.7234 26.3272 29.4246 26.3614 28.4897 26.348C28.2518 26.3446 28.0378 26.3392 27.8517 26.3314Z" stroke="black" stroke-width="2"></path>
+<path d="M27.8916 27.1592C28.0179 27.0219 28.165 26.8653 28.3311 26.6943C28.9826 26.0238 29.9253 25.1295 31.0879 24.2373C33.4375 22.4342 36.5658 20.7305 39.9355 20.7305C43.3051 20.7306 46.4327 22.4343 48.7822 24.2373C49.945 25.1296 50.8885 26.0238 51.54 26.6943C51.7059 26.865 51.8514 27.022 51.9775 27.1592C51.8516 27.2961 51.7055 27.4518 51.54 27.6221C50.8885 28.2926 49.945 29.1868 48.7822 30.0791C46.4327 31.8821 43.3052 33.5868 39.9355 33.5869C36.5657 33.5869 33.4375 31.8822 31.0879 30.0791C29.9252 29.1868 28.9826 28.2926 28.3311 27.6221C28.1652 27.4514 28.0177 27.2963 27.8916 27.1592Z" stroke="black" stroke-width="2"></path>
+<path d="M27.4459 27.6915C27.6323 27.6837 27.8471 27.677 28.0854 27.6736C29.0202 27.6602 30.3192 27.6943 31.7721 27.8856C34.7085 28.272 38.1253 29.2793 40.5081 31.6621C42.8906 34.0448 43.8974 37.4611 44.2839 40.3973C44.4752 41.8505 44.51 43.1499 44.4966 44.0848C44.4932 44.3228 44.485 44.5367 44.4773 44.7229C44.2914 44.7306 44.078 44.7374 43.8406 44.7408C42.9057 44.7542 41.6063 44.7194 40.1531 44.5281C37.2168 44.1417 33.8 43.1356 31.4172 40.753C29.0343 38.3701 28.0278 34.9528 27.6413 32.0163C27.4501 30.5633 27.4159 29.2644 27.4294 28.3296C27.4328 28.0916 27.4381 27.8777 27.4459 27.6915Z" stroke="black" stroke-width="2"></path>
+<path d="M26.916 28.1289C27.0533 28.2552 27.2099 28.4023 27.3809 28.5684C28.0514 29.2199 28.9457 30.1626 29.8379 31.3252C31.641 33.6748 33.3447 36.8031 33.3447 40.1728C33.3446 43.5424 31.6409 46.67 29.8379 49.0195C28.9456 50.1823 28.0514 51.1258 27.3809 51.7773C27.2102 51.9432 27.0532 52.0887 26.916 52.2148C26.7791 52.0889 26.6234 51.9428 26.4531 51.7773C25.7826 51.1258 24.8884 50.1823 23.9961 49.0195C22.1931 46.67 20.4884 43.5426 20.4883 40.1728C20.4883 36.803 22.193 33.6748 23.9961 31.3252C24.8884 30.1625 25.7826 29.2199 26.4531 28.5684C26.6238 28.4025 26.7789 28.255 26.916 28.1289Z" stroke="black" stroke-width="2"></path>
+<path d="M26.2147 27.691C26.2225 27.8774 26.2293 28.0922 26.2327 28.3305C26.2461 29.2653 26.2119 30.5643 26.0207 32.0172C25.6342 34.9536 24.627 38.3704 22.2442 40.7532C19.8614 43.1357 16.4452 44.1425 13.5089 44.529C12.0557 44.7203 10.7563 44.7551 9.82145 44.7417C9.58349 44.7383 9.36957 44.7301 9.1834 44.7224C9.17564 44.5365 9.16886 44.3231 9.16545 44.0857C9.15203 43.1508 9.18689 41.8514 9.37813 40.3982C9.76458 37.4619 10.7706 34.0451 13.1533 31.6623C15.5361 29.2795 18.9535 28.2729 21.8899 27.8865C23.343 27.6952 24.6419 27.6611 25.5767 27.6745C25.8146 27.6779 26.0286 27.6833 26.2147 27.691Z" stroke="black" stroke-width="2"></path>
+<path d="M25.7021 27.1602C25.5759 27.2974 25.4288 27.4541 25.2627 27.625C24.6111 28.2955 23.6684 29.1899 22.5059 30.082C20.1562 31.8851 17.028 33.5889 13.6582 33.5889C10.2886 33.5887 7.16105 31.885 4.81153 30.082C3.64873 29.1897 2.70529 28.2955 2.05372 27.625C1.88786 27.4543 1.74236 27.2973 1.61622 27.1602C1.74215 27.0232 1.88824 26.8676 2.05372 26.6973C2.70527 26.0267 3.64874 25.1326 4.81153 24.2402C7.16108 22.4372 10.2885 20.7326 13.6582 20.7324C17.0281 20.7324 20.1562 22.4371 22.5059 24.2402C23.6686 25.1325 24.6112 26.0268 25.2627 26.6973C25.4285 26.8679 25.576 27.023 25.7021 27.1602Z" stroke="black" stroke-width="2"></path>
+<path d="M25.7338 25.9813C25.5474 25.9891 25.3326 25.9959 25.0943 25.9993C24.1595 26.0127 22.8605 25.9785 21.4076 25.7873C18.4712 25.4008 15.0544 24.3936 12.6716 22.0108C10.2891 19.628 9.28226 16.2118 8.89579 13.2755C8.70453 11.8223 8.66969 10.5229 8.6831 9.58806C8.68652 9.35009 8.69466 9.13618 8.70244 8.95C8.8883 8.94224 9.10168 8.93546 9.33911 8.93205C10.274 8.91863 11.5734 8.95349 13.0266 9.14473C15.9629 9.53118 19.3797 10.5372 21.7625 12.9199C24.1454 15.3027 25.1519 18.7201 25.5383 21.6565C25.7296 23.1096 25.7638 24.4085 25.7503 25.3433C25.7469 25.5812 25.7415 25.7952 25.7338 25.9813Z" stroke="black" stroke-width="2"></path>
+<path d="M26.9121 25.7031C26.7748 25.5769 26.6182 25.4298 26.4473 25.2637C25.7768 24.6121 24.8824 23.6694 23.9902 22.5068C22.1872 20.1572 20.4834 17.029 20.4834 13.6592C20.4835 10.2896 22.1873 7.16203 23.9902 4.8125C24.8826 3.6497 25.7767 2.70627 26.4473 2.05469C26.618 1.88883 26.775 1.74333 26.9121 1.61719C27.049 1.74312 27.2047 1.88921 27.375 2.05469C28.0455 2.70624 28.9397 3.64971 29.832 4.8125C31.6351 7.16206 33.3397 10.2895 33.3398 13.6592C33.3398 17.029 31.6351 20.1572 29.832 22.5068C28.9398 23.6695 28.0455 24.6121 27.375 25.2637C27.2043 25.4295 27.0492 25.577 26.9121 25.7031Z" stroke="black" stroke-width="2"></path>
+<path d="M25.5607 19.3789L27.4618 19.3457C27.5492 19.3442 27.6286 19.3884 27.6747 19.4583L27.7093 19.5368L28.045 20.9198C28.1559 21.3761 28.4798 21.7513 28.9152 21.9272C29.3419 22.0994 29.8251 22.0595 30.2183 21.8205L31.3036 21.1608C31.3771 21.116 31.4662 21.1134 31.5407 21.1488L31.6099 21.1965L32.9965 22.5729C33.0577 22.6336 33.0825 22.7203 33.0659 22.8012L33.035 22.8799L32.4788 23.8048C32.2386 24.2041 32.1867 24.6853 32.3299 25.122L32.4034 25.3063C32.5966 25.715 32.9524 26.0199 33.3793 26.1498L33.5666 26.1943L34.4238 26.3454C34.5414 26.3663 34.628 26.4675 34.6302 26.587L34.6642 28.532C34.6662 28.6469 34.5891 28.7489 34.478 28.7784L33.3785 29.0711C32.9508 29.1849 32.5956 29.4757 32.399 29.8657L32.3249 30.0389C32.1648 30.4848 32.2187 30.9794 32.4714 31.3803L33.0028 32.2237C33.0497 32.2981 33.0532 32.3898 33.0168 32.4656L32.9672 32.5349L31.5394 33.9438C31.4825 33.9998 31.4038 34.0241 31.3277 34.0129L31.2531 33.9898L30.2136 33.4737C29.8594 33.298 29.4528 33.2687 29.0801 33.387L28.9219 33.4464C28.5639 33.6057 28.2838 33.8968 28.1361 34.2552L28.0812 34.4124L27.7617 35.5207C27.7312 35.6261 27.6352 35.6996 27.5255 35.7016L25.5874 35.7354C25.4685 35.7375 25.3646 35.6555 25.3388 35.5396L25.0832 34.3808L25.0342 34.2068C24.9146 33.8684 24.6748 33.5849 24.361 33.4108L24.1976 33.3335L24.0433 33.2806C23.7308 33.1931 23.3978 33.2118 23.0968 33.3332L22.9495 33.4022L21.7729 34.0361C21.6979 34.0764 21.6097 34.0746 21.5375 34.0363L21.4722 33.9867L20.1375 32.5586C20.0776 32.4944 20.0574 32.4054 20.0787 32.3242L20.1135 32.2474L20.7373 31.3321C20.9834 30.9707 21.049 30.5199 20.923 30.108L20.8575 29.9343L20.7817 29.7901C20.6149 29.5119 20.3581 29.2988 20.0542 29.1855L19.8981 29.1365L18.4973 28.7898C18.3875 28.7625 18.3097 28.6649 18.3075 28.5518L18.275 26.6888C18.2733 26.5838 18.3372 26.4906 18.4321 26.4527L18.4738 26.4402L19.6961 26.1854C20.1451 26.0918 20.5232 25.7997 20.7294 25.3977L20.8074 25.2186C20.9466 24.8306 20.9208 24.4049 20.7399 24.0399L20.6523 23.8881L20.0481 22.9571C19.9825 22.8563 19.9975 22.723 20.0845 22.64L21.5852 21.2083C21.6715 21.126 21.8046 21.1157 21.9022 21.1843L22.718 21.758C23.1295 22.0472 23.659 22.111 24.1274 21.9278C24.5375 21.7673 24.8531 21.4365 24.9966 21.0267L25.0481 20.8461L25.3209 19.5765C25.3453 19.4629 25.4445 19.3809 25.5607 19.3789Z" fill="white" stroke="black" stroke-width="1.5"></path>
+<circle cx="26.4669" cy="27.5406" r="2.53895" transform="rotate(-1 26.4669 27.5406)" fill="white" stroke="black" stroke-width="1.5"></circle>
+</svg></svg></g></g><defs><clipPath id="SvgjsClipPath1024"><rect width="1000" height="1000" x="0" y="0" rx="250" ry="250"></rect></clipPath></defs></svg>
\ No newline at end of file
diff --git a/docs/logos/t3chat.svg b/docs/logos/t3chat.svg
new file mode 100644
index 0000000000..68a174a697
--- /dev/null
+++ b/docs/logos/t3chat.svg
@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512">
+  <g transform="translate(0 512) scale(0.1 -0.1)" fill="currentColor" stroke="none">
+    <path d="M1010 5110 c-364 -19 -535 -83 -726 -274 -157 -157 -226 -303 -262 -550 -16 -111 -17 -252 -17 -1721 0 -1691 0 -1707 46 -1889 38 -148 129 -297 253 -414 182 -170 345 -231 671 -252 207 -13 2966 -13 3170 0 179 12 297 32 385 67 256 102 475 345 539 600 45 178 46 200 46 1888 0 1469 -1 1610 -17 1721 -36 247 -105 393 -262 550 -159 158 -317 232 -571 265 -104 14 -3011 22 -3255 9z m1746 -1000 c518 -42 1026 -285 1302 -623 195 -238 285 -474 286 -747 0 -189 -35 -335 -121 -505 -227 -450 -721 -765 -1348 -861 -161 -24 -479 -22 -649 4 l-128 21 -322 -130 c-176 -72 -383 -155 -459 -186 -134 -54 -162 -58 -173 -29 -3 8 17 173 45 367 44 314 48 357 36 385 -7 18 -23 37 -34 43 -30 17 -163 171 -217 254 -134 202 -194 401 -194 638 0 190 36 336 126 509 209 406 656 711 1206 824 206 43 415 54 644 36z"/>
+  </g>
+</svg>
diff --git a/docs/logos/vertex-ai.svg b/docs/logos/vertex-ai.svg
new file mode 100644
index 0000000000..1a6a483ab5
--- /dev/null
+++ b/docs/logos/vertex-ai.svg
@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg id="Standard_product_Icon" data-name="Standard product Icon" xmlns="http://www.w3.org/2000/svg" version="1.1" viewBox="0 0 512 512">
+  <defs>
+    <style>
+      .cls-1 {
+        fill: none;
+      }
+
+      .cls-1, .cls-2, .cls-3, .cls-4, .cls-5 {
+        stroke-width: 0px;
+      }
+
+      .cls-2 {
+        fill: #34a853;
+      }
+
+      .cls-3 {
+        fill: #4285f4;
+      }
+
+      .cls-4 {
+        fill: #ea4335;
+      }
+
+      .cls-5 {
+        fill: #fbbc04;
+      }
+    </style>
+  </defs>
+  <g id="bounding_box" data-name="bounding box">
+    <rect id="bounding_box-2" data-name="bounding box-2" class="cls-1" width="512" height="512"/>
+  </g>
+  <g id="art_layer" data-name="art layer">
+    <path class="cls-4" d="M128,249c-8.8,0-16-7.2-16-16v-105c0-8.8,7.2-16,16-16s16,7.2,16,16v105c0,8.8-7.2,16-16,16Z"/>
+    <path class="cls-5" d="M256,464c-3,0-6-.8-8.6-2.5l-176-112c-7.5-4.7-9.7-14.6-4.9-22.1,4.8-7.5,14.6-9.6,22.1-4.9l167.4,106.5,167.4-106.5c7.5-4.7,17.3-2.5,22.1,4.9,4.7,7.5,2.5,17.3-4.9,22.1l-176,112c-2.6,1.7-5.6,2.5-8.6,2.5h0Z"/>
+    <path class="cls-2" d="M256,394c-8.8,0-16-7.2-16-16v-73.1c0-8.8,7.2-16,16-16s16,7.2,16,16v73.1c0,8.8-7.2,16-16,16Z"/>
+    <circle class="cls-4" cx="128" cy="64" r="16"/>
+    <circle class="cls-4" cx="128" cy="297" r="16"/>
+    <path class="cls-3" d="M384.2,314c-8.8,0-16-7.1-16-16l-.2-106c0-8.8,7.1-16,16-16h0c8.8,0,16,7.1,16,16l.2,106c0,8.8-7.1,16-16,16h0Z"/>
+    <circle class="cls-3" cx="384" cy="64" r="16"/>
+    <circle class="cls-3" cx="384" cy="128" r="16"/>
+    <path class="cls-5" d="M320,225c-8.8,0-16-7.2-16-16v-103c0-8.8,7.2-16,16-16s16,7.2,16,16v103c0,8.8-7.2,16-16,16Z"/>
+    <circle class="cls-2" cx="256" cy="177" r="16"/>
+    <circle class="cls-2" cx="256" cy="241" r="16"/>
+    <circle class="cls-5" cx="320" cy="273" r="16"/>
+    <circle class="cls-5" cx="320" cy="337" r="16"/>
+    <path class="cls-5" d="M192,225c-8.8,0-16-7.2-16-16v-103c0-8.8,7.2-16,16-16s16,7.2,16,16v103c0,8.8-7.2,16-16,16Z"/>
+    <circle class="cls-5" cx="192" cy="273" r="16"/>
+    <circle class="cls-5" cx="192" cy="337" r="16"/>
+  </g>
+</svg>
\ No newline at end of file
diff --git a/docs/logos/warp.svg b/docs/logos/warp.svg
new file mode 100644
index 0000000000..8b12c83411
--- /dev/null
+++ b/docs/logos/warp.svg
@@ -0,0 +1 @@
+<svg fill="#01A4FF" role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><title>Warp</title><path d="M12.035 2.723h9.253A2.712 2.712 0 0 1 24 5.435v10.529a2.712 2.712 0 0 1-2.712 2.713H8.047Zm-1.681 2.6L6.766 19.677h5.598l-.399 1.6H2.712A2.712 2.712 0 0 1 0 18.565V8.036a2.712 2.712 0 0 1 2.712-2.712Z"/></svg>
\ No newline at end of file
diff --git a/docs/logos/zai-dark.svg b/docs/logos/zai-dark.svg
new file mode 100644
index 0000000000..9026552086
--- /dev/null
+++ b/docs/logos/zai-dark.svg
@@ -0,0 +1,5 @@
+<svg width="100" height="100" viewBox="0 0 100 100" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M52.3767 10.0721L45.8028 19.4273C44.7914 20.8938 43.072 21.804 41.2516 21.804H5.34765V10.0215C5.29708 10.0721 52.3767 10.0721 52.3767 10.0721Z" fill="white"/>
+<path d="M97.0291 10.0722L40.5942 90.0216H2.97095L59.4058 10.0722H97.0291Z" fill="white"/>
+<path d="M47.6233 90.0215L54.2478 80.6157C55.2592 79.1492 56.9785 78.2389 58.799 78.2389H94.6524V90.0215H47.6233Z" fill="white"/>
+</svg>
diff --git a/docs/logos/zai.svg b/docs/logos/zai.svg
new file mode 100644
index 0000000000..4f511bd72f
--- /dev/null
+++ b/docs/logos/zai.svg
@@ -0,0 +1,219 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 25.3.1, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 30 30" style="enable-background:new 0 0 30 30;" xml:space="preserve">
+<style type="text/css">
+	.st0{opacity:0.3;fill:#E2E4E7;}
+	.st1{opacity:0.8;fill:#E2E4E7;stroke:#FFFFFF;stroke-width:5;stroke-miterlimit:10;}
+	.st2{fill:url(#SVGID_1_);}
+	.st3{fill:none;stroke:#E0E4E9;stroke-width:0.25;stroke-miterlimit:10;}
+	.st4{fill:none;}
+	.st5{fill:#9DA1A5;}
+	.st6{fill-rule:evenodd;clip-rule:evenodd;fill:none;}
+	.st7{fill-rule:evenodd;clip-rule:evenodd;fill:#DFE2E7;}
+	.st8{fill-rule:evenodd;clip-rule:evenodd;fill:#CDD4DA;}
+	.st9{fill-rule:evenodd;clip-rule:evenodd;fill:#B3BCC7;}
+	.st10{fill-rule:evenodd;clip-rule:evenodd;fill:#9DAAB7;}
+	.st11{fill-rule:evenodd;clip-rule:evenodd;fill:#8698A8;}
+	.st12{fill-rule:evenodd;clip-rule:evenodd;fill:url(#SVGID_2_);}
+	.st13{fill-rule:evenodd;clip-rule:evenodd;fill:url(#SVGID_3_);}
+	.st14{fill:#1F63EC;}
+	.st15{fill:#2D2D2D;}
+	.st16{fill:none;stroke:#E0E4E9;stroke-width:0.5;stroke-miterlimit:10;}
+	.st17{fill-rule:evenodd;clip-rule:evenodd;fill:url(#SVGID_4_);}
+	.st18{fill-rule:evenodd;clip-rule:evenodd;fill:url(#SVGID_5_);}
+	.st19{fill:none;stroke:#677380;stroke-width:0.5;stroke-miterlimit:10;}
+	.st20{fill:none;stroke:url(#SVGID_6_);stroke-width:2;stroke-miterlimit:10;}
+	.st21{fill-rule:evenodd;clip-rule:evenodd;fill:url(#SVGID_7_);}
+	.st22{fill-rule:evenodd;clip-rule:evenodd;fill:url(#SVGID_8_);}
+	.st23{fill:#FFFFFF;}
+	.st24{fill-rule:evenodd;clip-rule:evenodd;fill:#2D2D2D;}
+	.st25{clip-path:url(#SVGID_10_);}
+	.st26{clip-path:url(#SVGID_12_);}
+	.st27{fill:url(#SVGID_13_);}
+	.st28{fill-rule:evenodd;clip-rule:evenodd;fill:url(#SVGID_14_);}
+	.st29{fill-rule:evenodd;clip-rule:evenodd;fill:url(#SVGID_15_);}
+	.st30{clip-path:url(#SVGID_17_);}
+	.st31{clip-path:url(#SVGID_19_);}
+	.st32{fill:url(#SVGID_20_);}
+	.st33{fill:none;stroke:url(#SVGID_21_);stroke-width:2;stroke-miterlimit:10;}
+	.st34{fill-rule:evenodd;clip-rule:evenodd;fill:url(#SVGID_22_);}
+	.st35{fill-rule:evenodd;clip-rule:evenodd;fill:url(#SVGID_23_);}
+	.st36{clip-path:url(#SVGID_25_);}
+	.st37{clip-path:url(#SVGID_27_);}
+	.st38{fill:url(#SVGID_28_);}
+	.st39{clip-path:url(#SVGID_30_);}
+	.st40{clip-path:url(#SVGID_32_);}
+	.st41{fill:url(#SVGID_33_);}
+	.st42{fill-rule:evenodd;clip-rule:evenodd;fill:#126EF6;}
+	.st43{fill-rule:evenodd;clip-rule:evenodd;fill:#FFFFFF;}
+	.st44{clip-path:url(#SVGID_35_);}
+	.st45{clip-path:url(#SVGID_37_);}
+	.st46{fill:url(#SVGID_38_);}
+	.st47{fill-rule:evenodd;clip-rule:evenodd;fill:#9DA1A5;}
+	.st48{fill-rule:evenodd;clip-rule:evenodd;fill:url(#SVGID_39_);}
+	.st49{fill-rule:evenodd;clip-rule:evenodd;fill:url(#SVGID_40_);}
+	.st50{fill-rule:evenodd;clip-rule:evenodd;fill:url(#SVGID_41_);}
+	.st51{fill-rule:evenodd;clip-rule:evenodd;fill:url(#SVGID_42_);}
+	.st52{fill:none;stroke:url(#SVGID_43_);stroke-width:2;stroke-miterlimit:10;}
+	.st53{fill-rule:evenodd;clip-rule:evenodd;fill:none;stroke:#E0E4E9;stroke-width:0.5;stroke-miterlimit:10;}
+	.st54{fill-rule:evenodd;clip-rule:evenodd;fill:url(#SVGID_44_);}
+	.st55{fill-rule:evenodd;clip-rule:evenodd;fill:url(#SVGID_45_);}
+	.st56{fill-rule:evenodd;clip-rule:evenodd;fill:url(#SVGID_46_);}
+	.st57{fill-rule:evenodd;clip-rule:evenodd;fill:url(#SVGID_47_);}
+	.st58{fill-rule:evenodd;clip-rule:evenodd;fill:url(#SVGID_48_);}
+	.st59{fill-rule:evenodd;clip-rule:evenodd;fill:url(#SVGID_49_);}
+	.st60{fill-rule:evenodd;clip-rule:evenodd;fill:url(#SVGID_50_);}
+	.st61{fill-rule:evenodd;clip-rule:evenodd;fill:url(#SVGID_51_);}
+	.st62{fill-rule:evenodd;clip-rule:evenodd;fill:url(#SVGID_52_);}
+	.st63{fill-rule:evenodd;clip-rule:evenodd;fill:url(#SVGID_53_);}
+	.st64{clip-path:url(#SVGID_55_);}
+	.st65{clip-path:url(#SVGID_57_);}
+	.st66{fill:url(#SVGID_58_);}
+	.st67{clip-path:url(#SVGID_60_);}
+	.st68{clip-path:url(#SVGID_62_);}
+	.st69{fill:url(#SVGID_63_);}
+	.st70{fill:none;stroke:url(#SVGID_64_);stroke-width:2;stroke-miterlimit:10;}
+	.st71{clip-path:url(#SVGID_66_);}
+	.st72{clip-path:url(#SVGID_68_);}
+	.st73{fill:url(#SVGID_69_);}
+	.st74{clip-path:url(#SVGID_71_);}
+	.st75{clip-path:url(#SVGID_73_);}
+	.st76{fill:url(#SVGID_74_);}
+	.st77{clip-path:url(#SVGID_76_);}
+	.st78{clip-path:url(#SVGID_78_);}
+	.st79{fill:url(#SVGID_79_);}
+	.st80{fill-rule:evenodd;clip-rule:evenodd;fill:url(#SVGID_80_);}
+	.st81{fill-rule:evenodd;clip-rule:evenodd;fill:url(#SVGID_81_);}
+	.st82{clip-path:url(#SVGID_83_);}
+	.st83{clip-path:url(#SVGID_85_);}
+	.st84{fill:url(#SVGID_86_);}
+	.st85{fill-rule:evenodd;clip-rule:evenodd;fill:url(#SVGID_87_);}
+	.st86{fill-rule:evenodd;clip-rule:evenodd;fill:url(#SVGID_88_);}
+	.st87{clip-path:url(#SVGID_90_);}
+	.st88{clip-path:url(#SVGID_92_);}
+	.st89{fill:url(#SVGID_93_);}
+	.st90{fill:none;stroke:url(#SVGID_94_);stroke-width:2;stroke-miterlimit:10;}
+	.st91{fill-rule:evenodd;clip-rule:evenodd;fill:url(#SVGID_95_);}
+	.st92{fill-rule:evenodd;clip-rule:evenodd;fill:url(#SVGID_96_);}
+	.st93{clip-path:url(#SVGID_98_);}
+	.st94{clip-path:url(#SVGID_100_);}
+	.st95{fill:url(#SVGID_101_);}
+	.st96{clip-path:url(#SVGID_103_);}
+	.st97{clip-path:url(#SVGID_105_);}
+	.st98{fill:url(#SVGID_106_);}
+	.st99{clip-path:url(#SVGID_108_);}
+	.st100{clip-path:url(#SVGID_110_);}
+	.st101{fill:url(#SVGID_111_);}
+	.st102{fill:#FFFFFF;stroke:#B3BCC7;stroke-width:0.275;stroke-miterlimit:10;}
+	.st103{clip-path:url(#SVGID_113_);}
+	.st104{fill:#FDD138;}
+	.st105{fill:#FCA62F;}
+	.st106{fill:#FB7927;}
+	.st107{fill:#F44B22;}
+	.st108{fill:#D81915;}
+	.st109{fill:#2D2D2D;stroke:#FFFFFF;stroke-width:0.3354;stroke-miterlimit:10;}
+	.st110{fill:none;stroke:#65727F;stroke-width:2;stroke-miterlimit:10;}
+	.st111{fill:none;stroke:#65727F;stroke-width:0.75;stroke-miterlimit:10;}
+	.st112{fill:url(#SVGID_114_);}
+	.st113{fill:#D06C50;}
+	.st114{fill:#2D2D2D;stroke:#B3BCC7;stroke-width:0.275;stroke-miterlimit:10;}
+	.st115{opacity:0.2;}
+	.st116{fill:none;stroke:#677380;stroke-width:0.3564;stroke-miterlimit:10;}
+	.st117{fill:none;stroke:#677380;stroke-width:0.3564;stroke-miterlimit:10;stroke-dasharray:1.0212,1.0212;}
+	.st118{fill:none;stroke:#677380;stroke-width:0.3564;stroke-miterlimit:10;stroke-dasharray:1.0205,1.0205;}
+	.st119{opacity:0.2;fill:none;}
+	.st120{fill:none;stroke:#677380;stroke-width:0.3689;stroke-miterlimit:10;}
+	.st121{fill:none;stroke:#677380;stroke-width:0.3689;stroke-miterlimit:10;stroke-dasharray:1.0509,1.0509;}
+	.st122{opacity:0.3;fill:#1F63EC;}
+	.st123{fill:#2D2D2D;stroke:#FFFFFF;stroke-width:0.3162;stroke-miterlimit:10;}
+	.st124{fill:#FFFFFF;stroke:#B3BCC7;stroke-width:0.3162;stroke-miterlimit:10;}
+	.st125{clip-path:url(#SVGID_118_);}
+	.st126{fill:url(#SVGID_119_);}
+	.st127{fill:none;stroke:#DFE2E7;stroke-width:0.75;stroke-miterlimit:10;}
+	.st128{fill:#9DA1A5;stroke:#FFFFFF;stroke-miterlimit:10;}
+	.st129{fill:url(#SVGID_120_);}
+	.st130{fill:none;stroke:#677380;stroke-width:0.75;stroke-miterlimit:10;}
+	.st131{opacity:0.4;}
+	.st132{clip-path:url(#SVGID_122_);}
+	.st133{clip-path:url(#SVGID_124_);}
+	.st134{fill:url(#SVGID_125_);}
+	.st135{fill:none;stroke:#8392A3;stroke-width:0.35;stroke-miterlimit:10;}
+	.st136{fill:none;stroke:#8392A3;stroke-width:0.35;stroke-miterlimit:10;stroke-dasharray:0.9951,0.9951;}
+	.st137{fill:none;stroke:#8392A3;stroke-width:0.35;stroke-miterlimit:10;stroke-dasharray:1.004,1.004;}
+	.st138{fill:none;stroke:url(#SVGID_126_);stroke-width:1.5;stroke-miterlimit:10;}
+	.st139{fill:url(#SVGID_127_);}
+	.st140{fill:none;stroke:#DDE0E4;stroke-width:0.35;stroke-miterlimit:10;}
+	.st141{fill:#2D2D2D;stroke:#A9B3BE;stroke-width:0.275;stroke-miterlimit:10;}
+	.st142{fill-rule:evenodd;clip-rule:evenodd;fill:#126EF4;}
+	.st143{fill:#FFFFFF;stroke:#B1BAC4;stroke-width:0.275;stroke-miterlimit:10;}
+	.st144{fill:#CE6C50;}
+	.st145{fill:#5B5B5B;}
+	.st146{fill:#8392A3;}
+	.st147{fill:none;stroke:url(#SVGID_128_);stroke-width:1.5;stroke-miterlimit:10;}
+	.st148{fill:url(#SVGID_129_);}
+	.st149{fill:none;stroke:#B5BDC4;stroke-width:0.7;stroke-miterlimit:10;}
+	.st150{opacity:0.6;fill:none;stroke:#78838E;stroke-width:0.35;stroke-miterlimit:10;}
+	.st151{opacity:0.2;fill:none;stroke:#8392A3;stroke-width:0.35;stroke-miterlimit:10;stroke-dasharray:1,1;}
+	.st152{fill:none;stroke:#DDE0E4;stroke-width:0.75;stroke-miterlimit:10;}
+	.st153{fill:none;stroke:#8392A3;stroke-width:0.5;stroke-miterlimit:10;}
+	.st154{opacity:0.2;fill:none;stroke:#677380;stroke-width:0.3564;stroke-miterlimit:10;stroke-dasharray:1.0182,1.0182;}
+	.st155{fill:none;stroke:#DDE0E4;stroke-width:0.765;stroke-miterlimit:10;}
+	.st156{fill:url(#SVGID_130_);}
+	.st157{fill:url(#SVGID_131_);}
+	.st158{fill:#B1BAC4;}
+	.st159{fill:#CBD1D8;}
+	.st160{fill:#0B1B2B;}
+	.st161{fill:#91D119;}
+	.st162{opacity:0.7;}
+	.st163{fill:#FFFFFF;stroke:#000000;stroke-width:0.4418;stroke-miterlimit:10;}
+	.st164{fill:none;stroke:#939CAA;stroke-width:0.2209;stroke-miterlimit:10;}
+	.st165{fill:none;stroke:#FFFFFF;stroke-width:3.0924;stroke-miterlimit:10;}
+	.st166{fill:url(#SVGID_132_);}
+	.st167{fill:none;stroke:url(#SVGID_133_);stroke-width:1.714;stroke-miterlimit:10;}
+	.st168{fill:url(#SVGID_134_);}
+	.st169{fill:url(#SVGID_135_);}
+	.st170{fill:url(#SVGID_136_);}
+	.st171{fill:url(#SVGID_137_);}
+	.st172{fill:url(#SVGID_138_);}
+	.st173{fill:url(#SVGID_139_);}
+	.st174{fill:url(#SVGID_140_);}
+	.st175{fill:url(#SVGID_141_);}
+	.st176{fill:url(#SVGID_142_);}
+	.st177{fill:url(#SVGID_143_);}
+	.st178{fill:url(#SVGID_144_);}
+	.st179{fill:none;stroke:#1F63EC;stroke-width:4;stroke-miterlimit:10;}
+	.st180{fill:none;stroke:#0B1B2B;stroke-width:4;stroke-miterlimit:10;}
+	.st181{fill:none;stroke:#677380;stroke-width:0.3989;stroke-miterlimit:10;}
+	.st182{fill:none;stroke:#677380;stroke-width:0.3989;stroke-miterlimit:10;stroke-dasharray:1.14,1.14;}
+	.st183{fill:#257AF1;}
+	.st184{opacity:0.3;fill:#FFFFFF;}
+	.st185{fill:none;stroke:#98A5B2;stroke-width:4;stroke-miterlimit:10;}
+	.st186{fill:none;stroke:#65727F;stroke-width:0.3989;stroke-miterlimit:10;}
+	.st187{fill:none;stroke:#65727F;stroke-width:0.3989;stroke-miterlimit:10;stroke-dasharray:1.14,1.14;}
+	.st188{fill:none;stroke:#DDDFE4;stroke-width:0.75;stroke-miterlimit:10;}
+	.st189{fill:#9A9EA2;}
+	.st190{fill-rule:evenodd;clip-rule:evenodd;fill:#3267AC;}
+	.st191{fill:#FFFFFF;stroke:#AFB8C3;stroke-width:0.275;stroke-miterlimit:10;}
+	.st192{fill:#C5694E;}
+	.st193{fill:#8192A2;}
+	.st194{fill:#2D2D2D;stroke:#FFFFFF;stroke-width:0.6317;stroke-miterlimit:10;}
+</style>
+<g id="图层_2">
+</g>
+<g id="图层_1">
+	<path class="st194" d="M24.51,28.51H5.49c-2.21,0-4-1.79-4-4V5.49c0-2.21,1.79-4,4-4h19.03c2.21,0,4,1.79,4,4v19.03
+		C28.51,26.72,26.72,28.51,24.51,28.51z"/>
+	<g>
+		<g>
+			<g>
+				<g>
+					<path class="st23" d="M15.47,7.1l-1.3,1.85c-0.2,0.29-0.54,0.47-0.9,0.47h-7.1V7.09C6.16,7.1,15.47,7.1,15.47,7.1z"/>
+					<polygon class="st23" points="24.3,7.1 13.14,22.91 5.7,22.91 16.86,7.1 					"/>
+					<path class="st23" d="M14.53,22.91l1.31-1.86c0.2-0.29,0.54-0.47,0.9-0.47h7.09v2.33H14.53z"/>
+				</g>
+			</g>
+		</g>
+	</g>
+</g>
+</svg>
diff --git a/docs/logos/zed.svg b/docs/logos/zed.svg
new file mode 100644
index 0000000000..fb03bda231
--- /dev/null
+++ b/docs/logos/zed.svg
@@ -0,0 +1,4 @@
+<svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <title>Zed</title>
+  <path fill="#084EFF" d="M2.25 1.5a.75.75 0 0 0-.75.75v16.5H0V2.25A2.25 2.25 0 0 1 2.25 0h20.095c1.002 0 1.504 1.212.795 1.92L10.764 14.298h3.486V12.75h1.5v1.922a1.125 1.125 0 0 1-1.125 1.125H9.264l-2.578 2.578h11.689V9h1.5v9.375a1.5 1.5 0 0 1-1.5 1.5H5.185L2.562 22.5H21.75a.75.75 0 0 0 .75-.75V5.25H24v16.5A2.25 2.25 0 0 1 21.75 24H1.655C.653 24 .151 22.788.86 22.08L13.19 9.75H9.75v1.5h-1.5V9.375A1.125 1.125 0 0 1 9.375 8.25h5.314l2.625-2.625H5.625V15h-1.5V5.625a1.5 1.5 0 0 1 1.5-1.5h13.19L21.438 1.5z"/>
+</svg>
diff --git a/docs/manus.md b/docs/manus.md
new file mode 100644
index 0000000000..7ee9198463
--- /dev/null
+++ b/docs/manus.md
@@ -0,0 +1,73 @@
+---
+summary: "Manus provider: browser session_id cookie auth for credit balance, monthly credits, and daily refresh tracking."
+read_when:
+  - Adding or modifying the Manus provider
+  - Debugging Manus cookie imports or API responses
+  - Adjusting Manus usage display or credit formatting
+---
+
+# Manus Provider
+
+The Manus provider tracks credit usage on [manus.im](https://manus.im) via browser `session_id` cookie authentication.
+
+## Features
+
+- **Monthly credit gauge**: Shows Pro monthly credits used vs. plan total (`proMonthlyCredits` − `periodicCredits`).
+- **Daily refresh gauge**: Shows daily refresh credits used vs. max refresh allotment, with reset timing.
+- **Balance display**: Total credits available, shown in the menu identity line.
+- **Cookie auth**: Automatic browser cookie import (Safari, Chrome, Firefox) or manual cookie header.
+- **Env var support**: `MANUS_SESSION_TOKEN` (raw token) or `MANUS_COOKIE` (full cookie header) for CLI/headless usage.
+
+## Setup
+
+1. Open **Settings → Providers**
+2. Enable **Manus**
+3. Log in to [manus.im](https://manus.im) in your browser
+4. Cookie import happens automatically on the next refresh
+
+### Manual cookie mode
+
+1. In **Settings → Providers → Manus**, set Cookie source to **Manual**
+2. Open your browser DevTools on `manus.im`, copy the `Cookie:` header from any API request (must contain `session_id=...`)
+3. Paste the header into the cookie field in CodexBar
+
+### Environment variables (CLI / headless)
+
+- `MANUS_SESSION_TOKEN`: the raw `session_id` value.
+- `MANUS_COOKIE`: a full cookie header; the provider extracts `session_id` from it.
+
+Either works; raw-token form is preferred when only one value is needed.
+
+## How it works
+
+A single API endpoint is fetched with a bearer token derived from the `session_id` cookie value:
+
+- `POST https://api.manus.im/user.v1.UserService/GetAvailableCredits` — returns credit fields including `totalCredits`, `freeCredits`, `periodicCredits`, `proMonthlyCredits`, `refreshCredits`, `maxRefreshCredits`, `nextRefreshTime`, and `refreshInterval`.
+
+Cookie domain: `manus.im`. Valid `session_id` cookies are cached in Keychain and reused until the session expires.
+
+The response parser tolerates both a direct object and common envelope shapes (`data` / `result` / `response` / `availableCredits`). Payloads missing all expected credit fields are rejected as a parse error rather than surfacing a misleading zero-credit snapshot.
+
+## Token accounts
+
+Manus supports multiple accounts via the standard token-account mechanism. Add entries to `~/.codexbar/config.json` (`tokenAccounts`) with the full `Cookie:` header (containing `session_id=...`), then switch between accounts from the menu.
+
+## CLI
+
+```bash
+codexbar usage --provider manus --verbose
+```
+
+## Troubleshooting
+
+### "No Manus session token provided"
+
+Log in to [manus.im](https://manus.im) in a supported browser (Safari, Chrome, Firefox), then refresh CodexBar. Alternatively, set `MANUS_SESSION_TOKEN` or `MANUS_COOKIE`, or paste a cookie header in manual mode.
+
+### "Invalid Manus session token"
+
+Your session has expired or been revoked. Log out and back in to Manus, or paste a fresh `Cookie:` header in manual mode.
+
+### "Response missing expected credits fields"
+
+The API returned a 200 response that doesn't look like a credits payload (often an error object). Re-login to Manus; if it persists, the upstream response schema may have changed.
diff --git a/docs/mimo.md b/docs/mimo.md
new file mode 100644
index 0000000000..ff8a4f95c9
--- /dev/null
+++ b/docs/mimo.md
@@ -0,0 +1,99 @@
+---
+summary: "Xiaomi MiMo provider notes: cookie auth, balance endpoint, and setup."
+read_when:
+  - Adding or modifying the Xiaomi MiMo provider
+  - Debugging MiMo cookie import or balance fetching
+  - Explaining MiMo setup and limitations to users
+---
+
+# Xiaomi MiMo Provider
+
+The Xiaomi MiMo provider tracks your current balance from the Xiaomi MiMo console.
+
+## Features
+
+- **Balance display**: Shows total balance plus paid and granted components when MiMo returns them.
+- **Token plan usage**: Shows current token-plan credits while retaining balance as a second metric.
+- **Cookie-based auth**: Uses browser cookies or a pasted `Cookie:` header.
+- **Near-real-time updates**: Balance usually reflects within a few minutes.
+
+## Setup
+
+1. Open **Settings → Providers**
+2. Enable **Xiaomi MiMo**
+3. Leave **Cookie source** on **Auto** (recommended)
+
+CodexBar imports cookies from these browsers in order: **Safari**, **Chrome** / **Chrome Beta** / **Chrome Canary**, **Firefox**, and **Microsoft Edge**. Switch to **Manual** and paste a `Cookie:` header if your active MiMo session lives in Arc, Brave, or another browser profile CodexBar does not auto-detect.
+
+Safari cookie import may require granting CodexBar Full Disk Access in **System Settings → Privacy & Security**.
+
+### Manual cookie import (optional)
+
+1. Open `https://platform.xiaomimimo.com/#/console/balance`
+2. Copy a `Cookie:` header from your browser’s Network tab
+3. Paste it into **Xiaomi MiMo → Cookie source → Manual**
+
+## How it works
+
+- Fetches balance and token-plan detail/usage endpoints under `https://platform.xiaomimimo.com/api/v1`
+- Requires the `api-platform_serviceToken` and `userId` cookies
+- Accepts optional MiMo cookies like `api-platform_ph` and `api-platform_slh` when present
+- Supports `MIMO_API_URL` to override the base API URL for testing. Override values must be explicit HTTPS URLs or
+  bare hosts/paths that CodexBar normalizes to HTTPS. Explicit `http://` values fail closed before MiMo cookies are
+  attached to a request, and invalid endpoint overrides do not fall back to local MiMo usage accounting.
+
+## Limitations
+
+- Token cost, status polling, and debug log output are not supported yet
+- Widgets do not support Xiaomi MiMo yet
+- Auto import covers Safari, Chrome variants, Firefox, and Edge only; other browsers use **Manual** mode
+
+## Troubleshooting
+
+### “No Xiaomi MiMo browser session found”
+
+Log in at `https://platform.xiaomimimo.com/#/console/balance` in Safari, Chrome, Firefox, or Edge, then refresh CodexBar. If your session lives in another browser, switch the MiMo provider to **Cookie source → Manual** and paste the `Cookie:` header instead.
+
+### “Xiaomi MiMo requires the api-platform_serviceToken and userId cookies”
+
+The pasted header or imported browser session is missing required cookies. Re-copy the request from the balance page after logging in again.
+
+### “Xiaomi MiMo browser session expired”
+
+Your MiMo login is stale. Sign out and back in on the MiMo site, then refresh CodexBar.
+
+## Local fallback (opt-in)
+
+When the platform.xiaomimimo.com cookie path is unavailable — Chrome session cookies expire on Chrome relaunch, Chrome Safe Storage keychain access blocked, no SSO login from this machine, etc. — and you drive MiMo inference through a local wrapper such as `cc-mimo` (Claude Code CLI with `ANTHROPIC_BASE_URL=https://token-plan-sgp.xiaomimimo.com/anthropic`), CodexBar can surface **local token accounting** from that wrapper’s session jsonl as graceful degradation — the MiMo card shows lifetime/weekly token sums instead of `login required`.
+
+This fallback is **implicit opt-in**: it only activates when `~/.codexbar/mimo-local-usage.json` exists. Users who do not run a local wrapper see no change.
+
+### Setup (optional)
+
+1. Drop `Scripts/mimo-usage.py` (shipped with this repo) into your `PATH`:
+
+   ```bash
+   ln -sf "$(pwd)/Scripts/mimo-usage.py" ~/.local/bin/mimo-usage
+   chmod +x ~/.local/bin/mimo-usage
+   ```
+
+2. Run `mimo-usage --update` once to populate `~/.codexbar/mimo-local-usage.json`. The tracker scans `~/.claude-envs/mimo/.claude/projects/**/*.jsonl` (default path for a `cc-mimo`-style wrapper) and aggregates input, output, cache-read, and cache-creation tokens per time window (today / this week / all time).
+
+3. Trigger updates either on each wrapper invocation (recommended — call `mimo-usage --update` post-exec from your MiMo CLI launcher) or via a `launchd` / `cron` job every 5 minutes.
+
+4. CodexBar picks up the file on its next refresh. The MiMo card displays `Xiaomi MiMo (local)` with a `Local · <today> · <week> · <lifetime> · <sessions>` summary and the cache's actual update time. Local activity is not rendered as a quota percentage. The `Balance updates / Daily billing finalizes` footer is suppressed for `local` source since neither applies.
+
+### Wrapper integration example
+
+```bash
+"$CLAUDE_CLI" "$@"
+_exit=$?
+mimo-usage --update 2>/dev/null || true
+exit $_exit
+```
+
+### Limitations
+
+- **Local accounting only** — this is not real platform quota. The Xiaomi platform may rate-limit your account before your local counter reflects it.
+- Override the session root with `MIMO_CLAUDE_HOME` and the cache path with `MIMO_LOCAL_USAGE_PATH` when a wrapper uses non-default locations.
+- Cache schema (`~/.codexbar/mimo-local-usage.json`) is internal; do not rely on the JSON shape for external tooling.
diff --git a/docs/minimax.md b/docs/minimax.md
index 6b7b7d647a..82ae1d1108 100644
--- a/docs/minimax.md
+++ b/docs/minimax.md
@@ -1,5 +1,5 @@
 ---
-summary: "MiniMax provider data sources: API token or browser cookies + coding plan remains API."
+summary: "MiniMax provider data sources: Coding Plan tokens, browser cookies, and web-session parsing."
 read_when:
   - Debugging MiniMax usage parsing
   - Updating MiniMax cookie handling or coding plan scraping
@@ -8,53 +8,39 @@ read_when:
 
 # MiniMax provider
 
-MiniMax supports API tokens or web sessions. Usage is fetched from the Coding Plan remains API using
-either a Bearer API token or a session cookie header.
+MiniMax supports Coding Plan API tokens or web sessions. Web-session mode uses MiniMax browser/session state and
+falls back across the provider's supported web requests when needed.
 
-## Data sources + fallback order
+## Data sources
 
-1) **API token** (preferred)
-   - Set in Preferences → Providers → MiniMax (stored in `~/.codexbar/config.json`) or `MINIMAX_API_KEY`.
-   - When present, MiniMax uses the API token and ignores cookies entirely.
+1) **Coding Plan API token**
+   - Set in Preferences → Providers → MiniMax (stored in `~/.codexbar/config.json`), `MINIMAX_CODING_API_KEY`,
+     or `MINIMAX_API_KEY`.
+   - When both environment variables are present, `MINIMAX_CODING_API_KEY` wins so a standard `sk-api-*` key does
+     not mask a coding-plan `sk-cp-*` key.
+   - Auto mode can fall back to the web/cookie path when API-token credentials are rejected or the global endpoint
+     returns 404.
 
-2) **Cached cookie header** (automatic, only when no API token)
-   - Keychain cache: `com.steipete.codexbar.cache` (account `cookie.minimax`).
+2) **Cached/imported browser session** (automatic web path)
+   - Uses CodexBar's standard cookie cache and browser import flow.
 
 3) **Browser cookie import** (automatic)
-   - Cookie order from provider metadata (default: Safari → Chrome → Firefox).
-   - Merges Chromium profile cookies across the primary + Network stores before attempting a request.
-   - Tries each browser source until the Coding Plan API accepts the cookies.
-   - Domain filters: `platform.minimax.io`, `minimax.io`.
-
-4) **Browser local storage access token** (Chromium-based)
-   - Reads `access_token` (and related tokens) from Chromium local storage (LevelDB) to authorize the remains API.
-   - If decoding fails, falls back to a text-entry scan for `minimax.io` keys/values and filters for MiniMax JWT claims.
-   - Used automatically; no UI field.
-   - Also extracts `GroupId` when present (appends query param).
-
-5) **Manual session cookie header** (optional override)
+   - Uses provider metadata for browser order and MiniMax domain filters.
+   - Chromium browser storage can supplement imported cookies with access-token context when available.
+
+4) **Manual session cookie header** (optional web-path override)
    - Stored in `~/.codexbar/config.json` via Preferences → Providers → MiniMax (Cookie source → Manual).
    - Accepts a raw `Cookie:` header or a full "Copy as cURL" string.
-   - When a cURL string is pasted, MiniMax extracts the cookie header plus `Authorization: Bearer …` and
-     `GroupId=…` for the remains API.
-   - CLI/runtime env: `MINIMAX_COOKIE` or `MINIMAX_COOKIE_HEADER`.
-
-## Endpoints
-- API token endpoint: `https://api.minimax.io/v1/coding_plan/remains`
-  - Requires `Authorization: Bearer <api_token>`.
-- Global host (cookies): `https://platform.minimax.io`
-- China mainland host: `https://platform.minimaxi.com`
-- `GET {host}/user-center/payment/coding-plan`
-  - HTML parse for "Available usage" and plan name.
-- `GET {host}/v1/api/openplatform/coding_plan/remains`
-  - Fallback when HTML parsing fails.
-  - Sent with a `Referer` to the Coding Plan page.
-  - Adds `Authorization: Bearer <access_token>` when available.
-  - Adds `GroupId` query param when known.
+   - Low-level no-settings runtime can read `MINIMAX_COOKIE` or `MINIMAX_COOKIE_HEADER`.
+
+## Requests
+- Web sessions use the global host or China mainland host.
 - Region picker in Providers settings toggles the host; environment overrides:
   - `MINIMAX_HOST=platform.minimaxi.com`
   - `MINIMAX_CODING_PLAN_URL=...` (full URL override)
   - `MINIMAX_REMAINS_URL=...` (full URL override)
+- Security policy: endpoint overrides are only accepted when they use `https://`, omit userinfo, and do not contain encoded host delimiters. Custom HTTPS proxy/test domains continue to work for compatibility, but `http://` endpoints are rejected so cookies and authorization headers are not sent in cleartext.
+- Strict provider-host mode: set `MINIMAX_REQUIRE_PROVIDER_ENDPOINT_OVERRIDES=true` to additionally reject custom proxy/test domains and only accept MiniMax-owned hosts under `minimax.io` or `minimaxi.com`.
 
 ## Cookie capture (optional override)
 - Open the Coding Plan page and DevTools → Network.
@@ -62,25 +48,48 @@ either a Bearer API token or a session cookie header.
 - Copy the `Cookie` request header (or use “Copy as cURL” and paste the whole line).
 - Paste into Preferences → Providers → MiniMax only if automatic import fails.
 
-## Notes
-- Cookies alone often return status 1004 (“cookie is missing, log in again”); the remains API expects a Bearer token.
-- MiniMax stores `access_token` in Chromium local storage (LevelDB). Some entries serialize the storage key without a scheme
-  (ex: `minimax.io`), so origin matching must account for host-only keys.
-- Raw JWT scan fallback remains as a safety net if Chromium key formats change.
-- If local storage keys don’t decode (some Chrome builds), the MiniMax-specific text scan avoids a full raw-byte scan.
-
-## Cookie file paths
-- Safari: `~/Library/Cookies/Cookies.binarycookies`
-- Chrome/Chromium forks: `~/Library/Application Support/Google/Chrome/*/Cookies`
-- Firefox: `~/Library/Application Support/Firefox/Profiles/*/cookies.sqlite`
-
 ## Snapshot mapping
-- Primary: percent used from `model_remains` (used/total) or HTML "Available usage".
-- Window: derived from `start_time`/`end_time` or HTML duration text.
-- Reset: derived from `remains_time` (fallback to `end_time`) or HTML "Resets in …".
-- Plan/tier: best-effort from response fields or HTML title.
+- Primary usage, reset timing, and plan/tier are derived from Coding Plan response fields or page text.
+- Web-session billing history, when available, is mapped into the shared inline usage dashboard:
+  - 30-day token trend.
+  - Top model and top method breakdowns.
+  - Summary rows for recent billing-history totals.
+
+If the billing-history endpoint is unavailable but normal Coding Plan quota data is present, CodexBar still shows the
+quota card and omits the chart instead of treating the whole provider as failed.
 
 ## Key files
 - `Sources/CodexBarCore/Providers/MiniMax/MiniMaxUsageFetcher.swift`
 - `Sources/CodexBarCore/Providers/MiniMax/MiniMaxProviderDescriptor.swift`
 - `Sources/CodexBar/Providers/MiniMax/MiniMaxProviderImplementation.swift`
+
+## CLI diagnose command
+
+The generic `diagnose` command performs a real provider diagnostic invocation and emits a safe, redacted JSON export
+for issue reporting and verification. MiniMax adds a provider-specific `details` block with safe usage metadata.
+
+### Usage
+```
+codexbar diagnose --provider minimax --format json --pretty
+```
+
+### Output
+- Structural diagnostic JSON with provider, source/source mode, auth summary, usage summary, fetch attempts, and error categories.
+- Per-service quota percentages, used values, limits, remaining values, reset metadata, and unlimited state. These are
+  the same non-secret values shown in the menu and help diagnose boosted quota denominators.
+- All sensitive fields (API tokens, cookies, emails, auth headers) are redacted via `LogRedactor`.
+- Errors are mapped to safe categories (`network`, `auth`, `api`, `parse`) with user-friendly descriptions.
+- No raw API responses, raw error messages, tokens, cookies, emails, account IDs, org IDs, or billing history.
+
+### What is excluded from output
+- Raw API tokens (`sk-cp-*`, `sk-api-*`) and authorization headers
+- Cookie header values
+- Email addresses
+- Account IDs, org IDs
+- Raw error messages (replaced with safe category-based descriptions)
+- Raw HTTP responses or request bodies
+- Billing history details
+
+### Exit codes
+- `0`: Diagnostic completed successfully (even if provider auth is not configured)
+- `1`: Unknown error or invalid arguments
diff --git a/docs/model-pricing.md b/docs/model-pricing.md
new file mode 100644
index 0000000000..1b4b2f01a2
--- /dev/null
+++ b/docs/model-pricing.md
@@ -0,0 +1,42 @@
+---
+summary: "models.dev pricing metadata pipeline, cache, lookup rules, and token-cost units."
+read_when:
+  - Updating models.dev pricing metadata support
+  - Debugging model-pricing cache refresh or lookup behavior
+  - Routing provider cost calculations through shared pricing metadata
+---
+
+# Model pricing metadata
+
+CodexBar has an additive models.dev pricing pipeline for future cost lookup work. Existing hardcoded pricing remains unchanged for now.
+
+## Source and cache
+
+- Source API: `https://models.dev/api.json`
+- No API key is required.
+- Local cache: `~/Library/Caches/CodexBar/model-pricing/models-dev-v1.json`
+- TTL: 24 hours
+
+The pipeline lets future scanner code read the last valid cache synchronously with `ModelsDevPricingPipeline.lookup` and refresh stale metadata separately with `ModelsDevPricingPipeline.refreshIfNeeded`. If a refresh fails, the last valid cache remains usable.
+
+## Lookup rules
+
+Pricing is scoped by provider id and model id. This prevents two providers with the same model id or display name from sharing pricing accidentally.
+
+Planned local source mapping:
+
+- Codex/OpenAI logs: models.dev provider id `openai`
+- Claude logs: models.dev provider id `anthropic`
+- Vertex AI Claude logs: models.dev provider id `google-vertex-anthropic`
+
+The first integration PR only adds the parser, client, cache, provider-scoped lookup, and tests. It does not route live cost calculations through models.dev yet.
+
+## Units
+
+models.dev publishes costs as USD per 1M tokens. CodexBar converts those to USD per token in the metadata layer:
+
+```text
+perToken = modelsDevCost / 1_000_000
+```
+
+When models.dev includes `cost.context_over_200k`, CodexBar parses those values as the above-200k-token pricing lane and converts them with the same per-1M-token rule.
diff --git a/docs/moonshot.md b/docs/moonshot.md
new file mode 100644
index 0000000000..b57ce8a933
--- /dev/null
+++ b/docs/moonshot.md
@@ -0,0 +1,50 @@
+---
+summary: "Moonshot / Kimi API provider data sources: API key + balance endpoint."
+read_when:
+  - Adding or tweaking Moonshot balance parsing
+  - Updating Moonshot / Kimi API key handling
+  - Documenting Moonshot / Kimi API provider behavior
+---
+
+# Moonshot / Kimi API provider
+
+Moonshot / Kimi API is API-only. Balance is reported by `GET /v1/users/me/balance`,
+so CodexBar only needs a valid API key to show the current account balance.
+
+## Rationale
+
+Kimi API docs use the Moonshot API surface for current Kimi models: examples read
+`MOONSHOT_API_KEY` and call `https://api.moonshot.ai/v1`, including the Kimi K2.6
+quickstart. This provider is therefore named after the account and billing surface,
+not a specific Kimi model version.
+
+The existing `Kimi K2` provider remains separate because it targets the legacy
+`kimi-k2.ai` credit endpoint. Migrating or deprecating that provider should be a
+separate cleanup so existing user settings are not silently repointed.
+
+## Data sources
+
+1. **API key** stored in `~/.codexbar/config.json` or supplied via `MOONSHOT_API_KEY` / `MOONSHOT_KEY`.
+   CodexBar stores the key in config after you paste it in Settings → Providers → Moonshot / Kimi API.
+2. **Region**
+   - International: `https://api.moonshot.ai/v1/users/me/balance`
+   - China mainland: `https://api.moonshot.cn/v1/users/me/balance`
+   - Configure with Settings → Providers → Moonshot → API region or `MOONSHOT_REGION`.
+3. **Balance endpoint**
+   - Request headers: `Authorization: Bearer <api key>`, `Accept: application/json`
+   - Response contains `available_balance`, `voucher_balance`, and `cash_balance`.
+
+## Usage details
+
+- The menu card shows the available balance.
+- If `cash_balance` is negative, the card also surfaces the deficit.
+- There is no session or weekly window — Moonshot / Kimi API does not expose per-window quota via API.
+- Settings config takes precedence over environment variables when both are present.
+
+## Key files
+
+- `Sources/CodexBarCore/Providers/Moonshot/MoonshotProviderDescriptor.swift` (descriptor + fetch strategy)
+- `Sources/CodexBarCore/Providers/Moonshot/MoonshotUsageFetcher.swift` (HTTP client + JSON parser)
+- `Sources/CodexBarCore/Providers/Moonshot/MoonshotSettingsReader.swift` (env var resolution)
+- `Sources/CodexBar/Providers/Moonshot/MoonshotProviderImplementation.swift` (settings field + activation logic)
+- `Sources/CodexBar/Providers/Moonshot/MoonshotSettingsStore.swift` (SettingsStore extension)
diff --git a/docs/ollama.md b/docs/ollama.md
index 5be1127468..aec630650b 100644
--- a/docs/ollama.md
+++ b/docs/ollama.md
@@ -1,5 +1,5 @@
 ---
-summary: "Ollama provider notes: settings scrape, cookie auth, and Cloud Usage parsing."
+summary: "Ollama provider notes: API key auth, settings scrape, cookie auth, and Cloud Usage parsing."
 read_when:
   - Adding or modifying the Ollama provider
   - Debugging Ollama cookie import or settings parsing
@@ -8,20 +8,24 @@ read_when:
 
 # Ollama Provider
 
-The Ollama provider scrapes the **Plan & Billing** page to extract Cloud Usage limits for session and weekly windows.
+The Ollama provider can verify Ollama Cloud API-key access and scrape the **Plan & Billing** page to extract Cloud
+Usage limits for session and weekly windows.
 
 ## Features
 
 - **Plan badge**: Reads the plan tier (Free/Pro/Max) from the Cloud Usage header.
 - **Session + weekly usage**: Parses the percent-used values shown in the usage bars.
 - **Reset timestamps**: Uses the `data-time` attribute on the “Resets in …” elements.
-- **Browser cookie auth**: No API keys required.
+- **API key auth**: Verifies direct `https://ollama.com/api` access with `OLLAMA_API_KEY` or a configured key.
+- **Browser cookie auth**: Required for Cloud Usage quota windows because Ollama does not expose those limits through
+  the documented API.
 
 ## Setup
 
 1. Open **Settings → Providers**.
 2. Enable **Ollama**.
-3. Leave **Cookie source** on **Auto** (recommended, imports Chrome cookies by default).
+3. For API-key mode, paste an API key from `https://ollama.com/settings/keys` or set `OLLAMA_API_KEY`.
+4. For quota bars, leave **Cookie source** on **Auto** (recommended, imports Chrome cookies by default).
 
 ### Manual cookie import (optional)
 
@@ -31,7 +35,8 @@ The Ollama provider scrapes the **Plan & Billing** page to extract Cloud Usage l
 
 ## How it works
 
-- Fetches `https://ollama.com/settings` using browser cookies.
+- API-key mode fetches `https://ollama.com/api/tags` with `Authorization: Bearer <key>` to verify Cloud API access.
+- Cookie mode fetches `https://ollama.com/settings` using browser cookies.
 - Parses:
   - Plan badge under **Cloud Usage**.
   - **Session usage** and **Weekly usage** percentages.
diff --git a/docs/openai.md b/docs/openai.md
new file mode 100644
index 0000000000..6db22965db
--- /dev/null
+++ b/docs/openai.md
@@ -0,0 +1,61 @@
+---
+summary: "OpenAI API provider: Admin API key usage/cost graphs and legacy balance fallback."
+read_when:
+  - Updating OpenAI API Platform usage or cost display
+  - Debugging OPENAI_ADMIN_KEY or OPENAI_API_KEY behavior
+---
+
+# OpenAI API provider
+
+CodexBar's OpenAI API provider targets the API Platform organization dashboard, not ChatGPT/Codex subscription limits.
+
+## Data sources
+
+1. Preferred: `OPENAI_ADMIN_KEY` or configured key with Admin API access.
+   - `GET https://api.openai.com/v1/organization/costs`
+   - `GET https://api.openai.com/v1/organization/usage/completions`
+   - Daily buckets use `bucket_width=1d`, costs are grouped by `line_item`, and completion usage is grouped by `model`.
+   - Optional project scoping comes from `OPENAI_PROJECT_ID` or `providers[].workspaceID` for `openai`.
+     Project-scoped requests add `project_ids=<project>` to both Admin API endpoints.
+2. Fallback: legacy `GET https://api.openai.com/v1/dashboard/billing/credit_grants` for normal API keys that cannot access organization usage.
+
+## Setup
+
+Store a key in the shared app/CLI config:
+
+```bash
+printf '%s' "$OPENAI_ADMIN_KEY" | codexbar config set-api-key --provider openai --stdin
+```
+
+Settings → Providers → OpenAI writes the same `~/.codexbar/config.json` field. `OPENAI_ADMIN_KEY` is preferred over
+`OPENAI_API_KEY` because it unlocks organization costs and usage; a normal API key only supports the legacy balance
+fallback.
+
+To scope Admin API usage to a project, set the OpenAI Project ID field in Settings or add `workspaceID` to the `openai`
+provider config:
+
+```json
+{
+  "id": "openai",
+  "apiKey": "<OPENAI_ADMIN_KEY>",
+  "workspaceID": "proj_..."
+}
+```
+
+Project scoping is tied to the configured Admin API key. Selected OpenAI token accounts intentionally scrub
+`OPENAI_PROJECT_ID`/`workspaceID` so one account cannot inherit another account's project filter. Project-scoped Admin
+API failures do not fall back to the legacy billing endpoint, because that endpoint is not project-filtered.
+
+## Menu display
+
+- Admin API data renders inline Today/7d/configured-window KPIs plus a compact spend chart.
+- The inline usage card opens a hosted chart submenu with daily spend, token, and request trends plus selected-day detail.
+- Top model and top spend labels come from the configured completion/cost buckets when the Admin API returns them.
+- Legacy balance data keeps the older available/used credit summary and does not show organization graphs.
+- Project-scoped Admin API data labels the account as `Admin API: <project>` and the organization line as
+  `Project: <project>`.
+
+## Notes
+
+- Costs are the source of truth for financial totals. Token usage and cost buckets can differ slightly from dashboard billing reconciliation.
+- Admin API keys are organization-scoped and cannot be used for normal model inference.
diff --git a/docs/opencode.md b/docs/opencode.md
index f4927c5f1a..a40f3cfe3f 100644
--- a/docs/opencode.md
+++ b/docs/opencode.md
@@ -1,5 +1,5 @@
 ---
-summary: "OpenCode provider notes: browser cookie import, _server endpoints, and usage parsing."
+summary: "OpenCode provider notes: browser cookies, local SQLite usage, and parsing."
 read_when:
   - Adding or modifying the OpenCode provider
   - Debugging OpenCode usage parsing or cookie import
@@ -9,6 +9,7 @@ read_when:
 
 ## Data sources
 - Browser cookies from `opencode.ai`.
+- OpenCode Go local history from `~/.local/share/opencode/opencode.db` on macOS and Linux.
 - `POST https://opencode.ai/_server` with server function IDs:
   - `workspaces` (`def39973159c7f0483d8793a822b8dbb10d067e12c65455fcb4608459ba0234f`)
   - `subscription.get` (`7abeebee372f304e050aaaf92be863f4a86490e382f8c79db68fd94040d691b4`)
@@ -26,3 +27,4 @@ read_when:
 - Workspace override accepts a raw `wrk_…` ID or a full `https://opencode.ai/workspace/...` URL.
 - Cached cookies: Keychain cache `com.steipete.codexbar.cache` (account `cookie.opencode`, source + timestamp). Browser
   import only runs when the cached cookie fails.
+- OpenCode Go auto mode tries web usage first, then derives quota windows from local `opencode-go` assistant costs.
diff --git a/docs/openrouter.md b/docs/openrouter.md
index a0d7985e3a..38a023c18e 100644
--- a/docs/openrouter.md
+++ b/docs/openrouter.md
@@ -1,3 +1,11 @@
+---
+summary: "OpenRouter provider: API key credits, rate limits, and daily/weekly/monthly spend."
+read_when:
+  - Debugging OpenRouter API key usage or spend parsing
+  - Updating OpenRouter credits or key-limit display
+  - Explaining OpenRouter setup and environment variables
+---
+
 # OpenRouter Provider
 
 [OpenRouter](https://openrouter.ai) is a unified API that provides access to multiple AI models from different providers (OpenAI, Anthropic, Google, Meta, and more) through a single endpoint.
@@ -18,19 +26,27 @@ export OPENROUTER_API_KEY="sk-or-v1-..."
 
 You can also configure the API key in CodexBar Settings → Providers → OpenRouter.
 
+### CLI config
+
+```bash
+printf '%s' "$OPENROUTER_API_KEY" | codexbar config set-api-key --provider openrouter --stdin
+```
+
 ## Data Source
 
 The OpenRouter provider fetches usage data from two API endpoints:
 
 1. **Credits API** (`/api/v1/credits`): Returns total credits purchased and total usage. The balance is calculated as `total_credits - total_usage`.
 
-2. **Key API** (`/api/v1/key`): Returns rate limit information for your API key.
+2. **Key API** (`/api/v1/key`): Returns rate limit information plus current daily, weekly, and monthly spend for your API key.
 
 ## Display
 
 The OpenRouter menu card shows:
 
-- **Primary meter**: Credit usage percentage (how much of your purchased credits have been used)
+- **Primary meter**: API key limit usage when the key has a configured limit
+- **Spend notes**: Daily, weekly, and monthly API key spend when OpenRouter returns those fields
+- **Spend chart**: Day/week/month spend can reuse the shared inline dashboard when enough history is available
 - **Balance**: Displayed in the identity section as "Balance: $X.XX"
 
 ## CLI Usage
diff --git a/docs/packaging.md b/docs/packaging.md
index ec058fcda5..16e998152b 100644
--- a/docs/packaging.md
+++ b/docs/packaging.md
@@ -11,11 +11,11 @@ read_when:
 - `Scripts/package_app.sh`: builds host arch by default; set `ARCHES="arm64 x86_64"` for universal. Verifies slices.
 - `Scripts/compile_and_run.sh`: uses host arch; pass `--release-universal` or `--release-arches="arm64 x86_64"` for release packaging.
 - `Scripts/sign-and-notarize.sh`: signs, notarizes, staples, zips (accepts `ARCHES` for universal).
-- `Scripts/make_appcast.sh`: generates Sparkle appcast and embeds HTML release notes.
+- `Scripts/make_appcast.sh`: wrapper around the shared `mac-release make-appcast` helper; app metadata comes from `.mac-release.env`.
 - `Scripts/changelog-to-html.sh`: converts the per-version changelog section to HTML for Sparkle.
 
 ## Bundle contents
-- `CodexBarWidget.appex` bundled with app-group entitlements.
+- `CodexBarWidget.appex` is built by `WidgetExtension/CodexBarWidgetExtension.xcodeproj` as a real macOS app extension, then bundled with app-group entitlements.
 - `CodexBarCLI` copied to `CodexBar.app/Contents/Helpers/` for symlinking.
 - SwiftPM resource bundles (e.g. `KeyboardShortcuts_KeyboardShortcuts.bundle`) copied into `Contents/Resources` (required for `KeyboardShortcuts.Recorder`).
 
diff --git a/docs/perf-energy-issue-139-main-fix-validation-2026-02-19.md b/docs/perf-energy-issue-139-main-fix-validation-2026-02-19.md
index 682e3fb7a9..1be0844d9c 100644
--- a/docs/perf-energy-issue-139-main-fix-validation-2026-02-19.md
+++ b/docs/perf-energy-issue-139-main-fix-validation-2026-02-19.md
@@ -1,3 +1,11 @@
+---
+summary: "Post-fix validation for issue #139 Codex CLI timeout and energy improvements."
+read_when:
+  - Validating Codex CLI timeout or retry changes
+  - Reviewing post-fix evidence for issue 139
+  - Investigating CodexBar CPU exposure under failed CLI probes
+---
+
 # CodexBar Issue #139 Main Fix Validation (Post-Fix vs Pre-Fix)
 
 Date: 2026-02-19
diff --git a/docs/perf-energy-issue-139-simulation-report-2026-02-19.md b/docs/perf-energy-issue-139-simulation-report-2026-02-19.md
index 3ad413bf1f..0b04a57d88 100644
--- a/docs/perf-energy-issue-139-simulation-report-2026-02-19.md
+++ b/docs/perf-energy-issue-139-simulation-report-2026-02-19.md
@@ -1,3 +1,11 @@
+---
+summary: "Issue #139 performance and energy simulation report for Codex CLI subprocess failure paths."
+read_when:
+  - Investigating CodexBar CPU or energy regressions
+  - Changing Codex CLI PTY probe timing or retry behavior
+  - Reviewing issue 139 performance evidence
+---
+
 # CodexBar Issue #139 Performance/Energy Simulation Report
 
 Date: 2026-02-19
diff --git a/docs/poe.md b/docs/poe.md
new file mode 100644
index 0000000000..097cda9fbe
--- /dev/null
+++ b/docs/poe.md
@@ -0,0 +1,45 @@
+---
+summary: "Poe provider: API key setup, point balance, and recent usage history."
+read_when:
+  - Configuring Poe usage
+  - Debugging Poe balance or history requests
+---
+
+# Poe Provider
+
+CodexBar reads Poe's official usage API with a manually configured API key. It does not perform OAuth login or import browser cookies.
+
+## Authentication
+
+Create or copy an API key from [Poe API Keys](https://poe.com/api/keys), then add it in CodexBar Settings → Providers → Poe.
+
+You can also set the environment variable:
+
+```bash
+export POE_API_KEY="..."
+```
+
+Or configure it through the CLI:
+
+```bash
+printf '%s' "$POE_API_KEY" | codexbar config set-api-key --provider poe --stdin
+```
+
+## Data Source
+
+CodexBar requests:
+
+- `GET https://api.poe.com/usage/current_balance`
+- `GET https://api.poe.com/usage/points_history`
+
+The current balance request is required. Recent points history is best-effort, so a history error does not hide a valid balance.
+
+## Display
+
+The provider shows the current point balance in the menu and menu bar. When available, recent history is grouped by day and shown in the usage detail.
+
+## CLI Usage
+
+```bash
+codexbar --provider poe
+```
diff --git a/docs/provider.md b/docs/provider.md
index d259274100..9b191e353a 100644
--- a/docs/provider.md
+++ b/docs/provider.md
@@ -14,7 +14,7 @@ Goal: adding a provider should feel like:
 - add one implementation (UI hooks only)
 - done (tests + docs)
 
-This doc describes the **current provider architecture** (post-macro registry) and the exact steps to add a new provider.
+This doc describes the **current provider architecture** and the exact steps to add a new provider.
 
 ## Terms
 - **Provider**: a source of usage/quota/status data (Codex, Claude, Gemini, Antigravity, Cursor, …).
@@ -39,7 +39,8 @@ Common building blocks already exist:
 - OpenAI dashboard web scrape: `OpenAIDashboardFetcher` (WKWebView + JS)
 - cost usage: local log scanner (Codex + Claude)
 
-The old “switch provider” wiring is gone. Everything should be driven by the descriptor and its strategies.
+Provider behavior is descriptor-driven. Two explicit, exhaustive registries form the bootstrap boundary:
+`ProviderDescriptorRegistry` owns core descriptors and `ProviderImplementationRegistry` owns app implementations.
 
 ## Provider descriptor (source of truth)
 
@@ -93,12 +94,11 @@ Rule: providers do not talk to `FileManager`, `Security`, or “browser internal
 ## Minimal provider example (copy-paste)
 
 ```swift
-import CodexBarMacroSupport
 import Foundation
 
-@ProviderDescriptorRegistration
-@ProviderDescriptorDefinition
 public enum ExampleProviderDescriptor {
+    public static let descriptor: ProviderDescriptor = Self.makeDescriptor()
+
     static func makeDescriptor() -> ProviderDescriptor {
         ProviderDescriptor(
             id: .example,
@@ -169,12 +169,11 @@ Checklist:
   - `<ProviderID>Probe.swift` / `<ProviderID>Fetcher.swift`: concrete fetcher logic.
   - `<ProviderID>Models.swift`: snapshot structs.
   - `<ProviderID>Parser.swift` (if needed).
-- Attach `@ProviderDescriptorRegistration` + `@ProviderDescriptorDefinition` to the descriptor type.
-  Implement `static func makeDescriptor() -> ProviderDescriptor`.
-- Attach `@ProviderImplementationRegistration` to the implementation type (macros auto-register).
-  - No manual list edits.
+- Define a cached `public static let descriptor` and `static func makeDescriptor() -> ProviderDescriptor`.
+- Add the descriptor to `ProviderDescriptorRegistry.descriptorsByID`.
 - Add `Sources/CodexBar/Providers/<ProviderID>/<ProviderID>ProviderImplementation.swift`:
   - `ProviderImplementation` only for settings/login UI hooks.
+- Add an exhaustive case to `ProviderImplementationRegistry.makeImplementation(for:)`.
 - Add icons + color in descriptor:
   - `iconName` must match `ProviderIcon-<id>` asset.
   - Color used in menu cards + switcher.
diff --git a/docs/providers.md b/docs/providers.md
index 99da2542de..5e0c85b773 100644
--- a/docs/providers.md
+++ b/docs/providers.md
@@ -1,5 +1,5 @@
 ---
-summary: "Provider data sources and parsing overview (Codex, Claude, Gemini, Antigravity, Cursor, Droid/Factory, z.ai, Copilot, Kimi, Kilo, Kimi K2, Kiro, Warp, Vertex AI, Augment, Amp, Ollama, JetBrains AI, OpenRouter)."
+summary: "Provider data sources and parsing overview for every registered CodexBar provider."
 read_when:
   - Adding or modifying provider fetch/parsing
   - Adjusting provider labels, toggles, or metadata
@@ -8,68 +8,135 @@ read_when:
 
 # Providers
 
+CodexBar currently registers 53 provider IDs. Some companies expose multiple surfaces, such as Codex vs OpenAI API or
+OpenCode vs OpenCode Go, because the auth source and quota shape differ.
+
 ## Fetch strategies (current)
-Legend: web (browser cookies/WebView), cli (RPC/PTy), oauth (API), api token, local probe, web dashboard.
-Source labels (CLI/header): `openai-web`, `web`, `oauth`, `api`, `local`, plus provider-specific CLI labels (e.g. `codex-cli`, `claude`).
+Legend: web (browser cookies/WebView), cli (RPC/PTy or provider CLI), oauth (provider OAuth), api token, local probe, web dashboard.
+Source labels (CLI/header): `openai-web`, `web`, `oauth`, `api`, `local`, `cli`, plus provider-specific CLI labels (e.g. `codex-cli`, `claude`).
 
 Cookie-based providers expose a Cookie source picker (Automatic or Manual) in Settings → Providers.
-Browser cookie imports are cached in Keychain (`com.steipete.codexbar.cache`, account `cookie.<provider>`) and reused
-until the session is invalid, to avoid repeated Keychain prompts.
+Some browser cookie imports are cached in Keychain and reused until the session is invalid. API keys, manual cookie
+headers, source selection, provider ordering, and token accounts are stored in `~/.codexbar/config.json`.
 
 | Provider | Strategies (ordered for auto) |
 | --- | --- |
-| Codex | Web dashboard (`openai-web`) → CLI RPC/PTy (`codex-cli`); app uses CLI usage + optional dashboard scrape. |
-| Claude | App Auto: OAuth API (`oauth`) → CLI PTY (`claude`) → Web API (`web`). CLI Auto: Web API (`web`) → CLI PTY (`claude`). |
-| Gemini | OAuth API via Gemini CLI credentials (`api`). |
+| Codex | App Auto: OAuth API (`oauth`) → CLI RPC/PTy (`codex-cli`). CLI Auto: Web dashboard (`openai-web`) → CLI RPC/PTy (`codex-cli`). |
+| OpenAI | Admin API key (`api`) for organization spend/usage; legacy API-key balance fallback. |
+| Azure OpenAI | API key + endpoint + deployment probe (`api`) for deployment status validation. |
+| Claude | Admin API key (`api`) when configured; otherwise App Auto: OAuth API (`oauth`) → CLI PTY (`claude`) → Web API (`web`). CLI Auto: Web API (`web`) → CLI PTY (`claude`). |
+| Gemini | OAuth-backed API via Gemini CLI credentials (`api`). |
 | Antigravity | Local LSP/HTTP probe (`local`). |
 | Cursor | Web API via cookies → stored WebKit session (`web`). |
 | OpenCode | Web dashboard via cookies (`web`). |
+| OpenCode Go | Web dashboard via cookies (`web`) -> local SQLite usage (`local`) in auto mode; optional workspace ID. |
+| Alibaba Coding Plan | Console RPC via web cookies (auto/manual) with API key fallback (`web`, `api`). |
+| Alibaba Token Plan | Bailian subscription summary API via browser or manual cookies (`web`). |
 | Droid/Factory | Web cookies → stored tokens → local storage → WorkOS cookies (`web`). |
-| z.ai | API token (Keychain/env) → quota API (`api`). |
-| MiniMax | Manual cookie header (Keychain/env) → browser cookies (+ local storage access token) → coding plan page (HTML) with remains API fallback (`web`). |
-| Kimi | API token (JWT from `kimi-auth` cookie) → usage API (`api`). |
-| Kilo | API token (`KILO_API_KEY`) → usage API (`api`); auto falls back to CLI session auth (`cli`). |
-| Copilot | API token (device flow/env) → copilot_internal API (`api`). |
-| Kimi K2 | API key (Keychain/env) → credit endpoint (`api`). |
+| Devin | Chrome localStorage session or manual Bearer token → daily and weekly quota API (`web`). |
+| z.ai | API token from config/env → quota API (`api`). |
+| Manus | Browser `session_id` cookie (auto/manual/env) → credits API (`web`). |
+| MiniMax | Manual/browser session via Coding Plan web path (`web`), or Coding Plan API token (`api`). |
+| Kimi | Kimi Code API key (`api`), then `kimi-auth` cookie/manual token/env fallback (`web`). |
+| Kilo | API token from config/env → usage API (`api`); auto falls back to CLI session auth (`cli`). |
+| Copilot | Device-flow/env/config token → `copilot_internal` API (`api`). |
+| Kimi K2 (unofficial) | API key from config/env → legacy credit endpoint (`api`). |
 | Kiro | CLI command via `kiro-cli chat --no-interactive "/usage"` (`cli`). |
 | Vertex AI | Google ADC OAuth (gcloud) → Cloud Monitoring quota usage (`oauth`). |
+| Augment | `auggie` CLI first, then browser-cookie web fallback (`cli`, `web`). |
 | JetBrains AI | Local XML quota file (`local`). |
-| Amp | Web settings page via browser cookies (`web`). |
+| Amp | Local `amp usage` CLI, access-token API, then browser-cookie legacy fallback (`cli`, `api`, `web`). |
+| T3 Chat | Web tRPC customer-data endpoint via browser cookies (`web`). |
 | Warp | API token (config/env) → GraphQL request limits (`api`). |
-| Ollama | Web settings page via browser cookies (`web`). |
+| ElevenLabs | API key from config/env → subscription usage API (`api`). |
+| Windsurf | Web session bundle from browser localStorage (`web`) → local SQLite cache (`local`). |
+| Ollama | API key verifies Cloud API access (`api`); browser cookies expose Cloud quota windows (`web`). |
+| Synthetic | API key from config/env → quota API (`api`). |
 | OpenRouter | API token (config, overrides env) → credits API (`api`). |
+| Perplexity | Browser cookies/manual cookie/env session token → credits API (`web`). |
+| Xiaomi MiMo | Browser cookies → balance/token plan endpoints (`web`). |
+| Doubao | API key from config/env → Volcengine Ark chat-completions probe (`api`). |
+| Abacus AI | Browser cookies → compute points + billing API (`web`). |
+| Mistral | Console billing and Vibe subscription usage via browser cookies (`web`). |
+| DeepSeek | API key from env or token accounts → balance endpoint (`api`). |
+| Moonshot | API key from config/env → balance endpoint (`api`). |
+| Codebuff | API token from config/env or `codebuff login` credentials → usage API (`api`). |
+| Crof | API key from config/env → credit balance + requests quota API (`api`). |
+| Venice | API key from config/env → DIEM/USD balance API (`api`). |
+| Command Code | Web billing API via Command Code session cookies (`web`). |
+| StepFun | Username/password login or manual Oasis token (`web`). |
+| AWS Bedrock | AWS credentials → Cost Explorer spend/budgets and optional CloudWatch Claude activity (`api`). |
+| Grok | `grok agent stdio` JSON-RPC `x.ai/billing` (`cli`) → grok.com billing gRPC-web via Chrome session cookies (`web`); local `~/.grok/sessions` signals as fallback. |
+| GroqCloud | API key → Prometheus metrics API for request/token/cache-hit rates (`api`). |
+| LLM Proxy | API key + base URL → `/v1/quota-stats` aggregate proxy usage (`api`). |
+| LiteLLM | API key + base URL → `/key/info`, then `/user/info` or `/team/info` budget usage (`api`). |
+| Deepgram | API key → project discovery and usage breakdown API (`api`). |
+| Chutes | API key from config/env → subscription usage and quota API (`api`). |
+| Zed | Zed editor Keychain session → `cloud.zed.dev/client/users/me` for plan and quota data (`local`). |
 
 ## Codex
-- Web dashboard (when enabled): `https://chatgpt.com/codex/settings/usage` via WebView + browser cookies.
+- App Auto: OAuth API first; falls back to CLI only when OAuth credentials are missing or auth/refresh is invalid.
+- Web dashboard (optional, off by default): `https://chatgpt.com/codex/settings/usage` via WebView + browser cookies.
+- Battery saver toggle (currently off by default): reduces routine OpenAI web refreshes but still allows explicit manual refreshes.
 - CLI RPC default: `codex ... app-server` JSON-RPC (`account/read`, `account/rateLimits/read`).
-- CLI PTY fallback: `/status` scrape.
-- Local cost usage: scans `~/.codex/sessions/**/*.jsonl` (last 30 days).
+- CLI PTY: manual diagnostics/parser coverage only; automatic refresh does not launch bare Codex TUI.
+- Local cost usage: scans `CODEX_HOME` (or `~/.codex`) `sessions` and sibling `archived_sessions` JSONL files for the configured history window.
 - Status: Statuspage.io (OpenAI).
 - Details: `docs/codex.md`.
 
+## OpenAI
+- API key from `~/.codexbar/config.json`, `OPENAI_ADMIN_KEY`, or `OPENAI_API_KEY`.
+- Admin API keys are preferred and fetch organization costs plus completion usage for inline Today/7d/configured-window dashboards.
+- Normal API keys fall back to the legacy credit-grants balance endpoint when organization usage is unavailable.
+- Details: `docs/openai.md`.
+
+## Azure OpenAI
+- API key, endpoint, and deployment from `~/.codexbar/config.json` or `AZURE_OPENAI_API_KEY`, `AZURE_OPENAI_ENDPOINT`, and `AZURE_OPENAI_DEPLOYMENT_NAME`.
+- `AZURE_OPENAI_ENDPOINT` and configured endpoint overrides must be HTTPS URLs or bare hosts normalized to HTTPS; explicit `http://` URLs, user info, and encoded host-delimiter tricks fail closed before `api-key` headers are attached.
+- Validates the configured deployment with a minimal chat-completions request; it does not expose Azure spend or quota history.
+- Use `AZURE_OPENAI_API_VERSION` to override the API version. Set it to `v1` for Azure's OpenAI-compatible v1 API path.
+- Status: Azure status page link.
+
 ## Claude
+- Admin API: `sk-ant-admin...` key in Settings/config, token accounts, or `ANTHROPIC_ADMIN_KEY`.
+- Admin API shows organization spend/messages summaries with the same inline dashboard pattern as OpenAI API.
 - App Auto: OAuth API (`oauth`) → CLI PTY (`claude`) → Web API (`web`).
 - CLI Auto: Web API (`web`) → CLI PTY (`claude`).
-- Local cost usage: scans `~/.config/claude/projects/**/*.jsonl` (last 30 days).
+- Local cost usage: scans `CLAUDE_CONFIG_DIR` when set, otherwise `~/.config/claude/projects` and `~/.claude/projects` JSONL files for the configured history window.
 - Status: Statuspage.io (Anthropic).
 - Details: `docs/claude.md`.
 
 ## z.ai
-- API token from Keychain or `Z_AI_API_KEY` env var.
-- Quota endpoint: `https://api.z.ai/api/monitor/usage/quota/limit` (global) or `https://open.bigmodel.cn/api/monitor/usage/quota/limit` (BigModel CN); override with `Z_AI_API_HOST` or `Z_AI_QUOTA_URL`.
+- API token from `~/.codexbar/config.json` (`providers[].apiKey`) or `Z_AI_API_KEY` env var.
+- Supports global and BigModel CN quota hosts; override with `Z_AI_API_HOST` or `Z_AI_QUOTA_URL`.
+- z.ai endpoint overrides must be HTTPS or bare hosts normalized to HTTPS. `Z_AI_QUOTA_URL` takes precedence for
+  quota resolution; combined usage validates both configured endpoints before sending bearer auth.
 - Status: none yet.
 - Details: `docs/zai.md`.
 
+## Devin
+- Automatic auth reads the current `auth1_session` token and organization metadata from Chrome localStorage.
+- Manual auth accepts the `Authorization: Bearer ...` value from an app.devin.ai request.
+- Usage endpoint: `GET /api/<internal-org-id>/billing/quota/usage`.
+- Shows daily and weekly quota percentages with their reset timestamps.
+- Details: `docs/devin.md`.
+
+## Manus
+- Session token via browser `session_id` cookie, manual Settings entry, `MANUS_SESSION_TOKEN`, or `MANUS_COOKIE`.
+- Credits endpoint: `POST https://api.manus.im/user.v1.UserService/GetAvailableCredits`.
+- Auto mode prefers cached/browser cookies before env fallback; manual mode accepts either a bare `session_id` value or a full Cookie header.
+- Status: none yet.
+
 ## MiniMax
-- Session cookie header from Keychain or `MINIMAX_COOKIE`/`MINIMAX_COOKIE_HEADER` env var.
-- Hosts: `platform.minimax.io` (global) or `platform.minimaxi.com` (China mainland) via region picker or `MINIMAX_HOST`; full overrides via `MINIMAX_CODING_PLAN_URL` / `MINIMAX_REMAINS_URL`.
-- `GET {host}/v1/api/openplatform/coding_plan/remains`.
+- Coding Plan API token or web session from configured/manual/browser sources.
+- Supports global and China mainland hosts via provider region settings and environment overrides.
+- Web-session billing history can render 30-day token charts plus top model/method breakdowns when MiniMax exposes it.
 - Status: none yet.
 - Details: `docs/minimax.md`.
 
 ## Kimi
-- Auth token (JWT from `kimi-auth` cookie) via manual entry or `KIMI_AUTH_TOKEN` env var.
-- `POST https://www.kimi.com/apiv2/kimi.gateway.billing.v1.BillingService/GetUsages`.
+- Kimi Code API key via `~/.codexbar/config.json` or `KIMI_CODE_API_KEY`.
+- Web fallback uses the JWT from `kimi-auth` cookie via manual entry or `KIMI_AUTH_TOKEN` env var.
 - Shows weekly quota and 5-hour rate limit (300 minutes).
 - Status: none yet.
 - Details: `docs/kimi.md`.
@@ -78,14 +145,13 @@ until the session is invalid, to avoid repeated Keychain prompts.
 - API token from `~/.codexbar/config.json` (`providers[].apiKey`) or `KILO_API_KEY`.
 - Auto mode tries API first and falls back to CLI auth when API credentials are missing or unauthorized.
 - CLI auth source: `~/.local/share/kilo/auth.json` (`kilo.access`), typically created by `kilo login`.
-- Usage endpoint: `https://app.kilo.ai/api/trpc`.
 - Status: none yet.
 - Details: `docs/kilo.md`.
 
-## Kimi K2
-- API key via Settings (Keychain) or `KIMI_K2_API_KEY`/`KIMI_API_KEY` env var.
-- `GET https://kimi-k2.ai/api/user/credits`.
-- Shows credit usage based on consumed/remaining totals.
+## Kimi K2 (unofficial)
+- API key via `~/.codexbar/config.json` or `KIMI_K2_API_KEY`/`KIMI_API_KEY` env var.
+- Shows credit usage from the legacy `kimi-k2.ai` consumed/remaining totals.
+- Use Moonshot / Kimi API for the official Kimi API account and billing surface.
 - Status: none yet.
 - Details: `docs/kimi-k2.md`.
 
@@ -110,10 +176,34 @@ until the session is invalid, to avoid repeated Keychain prompts.
 
 ## OpenCode
 - Web dashboard via browser cookies (`opencode.ai`).
-- `POST https://opencode.ai/_server` (workspaces + subscription usage).
 - Status: none yet.
 - Details: `docs/opencode.md`.
 
+## OpenCode Go
+- Web dashboard via browser or manual cookies (`opencode.ai`).
+- Auto mode falls back to local usage from `~/.local/share/opencode/opencode.db` on macOS and Linux.
+- Uses the workspace Go page/server data for rolling 5-hour, weekly, and optional monthly usage windows.
+- Optional workspace ID comes from `~/.codexbar/config.json` (`providers[].workspaceID`) or `CODEXBAR_OPENCODEGO_WORKSPACE_ID`.
+- Status: none yet.
+- Details: `docs/opencode.md`.
+
+## Alibaba Coding Plan
+- Web mode uses Alibaba console RPC with form payload + `sec_token`.
+- Cookie sources: browser import (`auto`) or manual header (`cookieSource: manual`).
+- API key fallback from Settings (`providers[].apiKey`) or `ALIBABA_CODING_PLAN_API_KEY` env var.
+- Region hosts: international (`ap-southeast-1`) and China mainland (`cn-beijing`).
+- Host overrides: `ALIBABA_CODING_PLAN_HOST` or `ALIBABA_CODING_PLAN_QUOTA_URL`.
+- Status: `https://status.aliyun.com` (link only, no auto-polling).
+- Details: `docs/alibaba-coding-plan.md`.
+
+## Alibaba Token Plan
+- Web mode posts to the Bailian `GetSubscriptionSummary` endpoint with form-encoded params and optional `sec_token`.
+- Cookie sources: browser import (`auto`), manual Cookie header, or `ALIBABA_TOKEN_PLAN_COOKIE`.
+- Default quota URL: `https://bailian.console.aliyun.com/data/api.json?action=GetSubscriptionSummary&product=BssOpenAPI-V3`.
+- Host overrides: `ALIBABA_TOKEN_PLAN_HOST` or `ALIBABA_TOKEN_PLAN_QUOTA_URL`.
+- Status: `https://status.aliyun.com` (link only, no auto-polling).
+- Details: `docs/alibaba-token-plan.md`.
+
 ## Droid (Factory)
 - Web API via Factory cookies, bearer tokens, and WorkOS refresh tokens.
 - Multiple fallback strategies (cookies → stored tokens → local storage → WorkOS cookies).
@@ -122,6 +212,7 @@ until the session is invalid, to avoid repeated Keychain prompts.
 
 ## Copilot
 - GitHub device flow OAuth token + `api.github.com/copilot_internal/user`.
+- Supports multiple token accounts and account switching from provider settings/menu surfaces.
 - Status: Statuspage.io (GitHub).
 - Details: `docs/copilot.md`.
 
@@ -134,17 +225,25 @@ until the session is invalid, to avoid repeated Keychain prompts.
 
 ## Warp
 - API token from Settings or `WARP_API_KEY` / `WARP_TOKEN` env var.
-- GraphQL credit limits: `https://app.warp.dev/graphql/v2?op=GetRequestLimitInfo`.
 - Shows monthly credits usage and next refresh time.
 - Status: none yet.
 - Details: `docs/warp.md`.
 
+## ElevenLabs
+- API key from Settings, token accounts, `ELEVENLABS_API_KEY`, or `XI_API_KEY`.
+- Reads `GET /v1/user/subscription` from `api.elevenlabs.io`.
+- Shows character credit usage, reset timing, and voice slot usage when available.
+- Override the API base URL with `ELEVENLABS_API_URL`.
+- Status: `https://status.elevenlabs.io` (link only, no auto-polling).
+- Details: `docs/elevenlabs.md`.
+
 ## Vertex AI
 - OAuth credentials from `gcloud auth application-default login` (ADC).
 - Quota usage via Cloud Monitoring `consumer_quota` metrics for `aiplatform.googleapis.com`.
-- Token cost: scans `~/.claude/projects/` logs filtered to Vertex AI-tagged entries.
+- Token cost: uses the Claude local-log scanner filtered to Vertex AI-tagged entries.
 - Requires Cloud Monitoring API access in the current project.
 - Details: `docs/vertexai.md`.
+
 ## JetBrains AI
 - Local XML quota file from IDE configuration directory.
 - Auto-detects installed JetBrains IDEs; uses most recently used.
@@ -152,24 +251,188 @@ until the session is invalid, to avoid repeated Keychain prompts.
 - Status: none (no status page).
 - Details: `docs/jetbrains.md`.
 
+## Zed
+- Reads the signed-in Zed editor session from the macOS Keychain (`credentials_url` / `https://zed.dev`).
+- Calls `GET https://cloud.zed.dev/client/users/me` for plan, billing cycle, Edit Predictions quota, and overdue invoice flag.
+- Sign in to the Zed editor first.
+- Details: `docs/zed.md`.
+
+## Augment
+- Auto mode tries the `auggie` CLI first.
+- Web fallback uses browser cookies, with manual cookie header support.
+- Tracks credit usage and account/subscription data where available.
+- Status: none yet.
+- Details: `docs/augment.md`.
+
 ## Amp
-- Web settings page (`https://ampcode.com/settings`) via browser cookies.
-- Parses Amp Free usage from the settings HTML.
+- Auto mode tries the local `amp usage` command first.
+- API mode calls Amp's balance endpoint with an access token.
+- Web fallback reads the legacy settings page with browser cookies.
+- Tracks Amp Free usage, account identity, and individual and workspace credit balances.
 - Status: none yet.
 - Details: `docs/amp.md`.
 
+## T3 Chat
+- Web tRPC endpoint (`https://t3.chat/api/trpc/getCustomerData`) via browser cookies.
+- Parses JSONL response lines and extracts customer data from the embedded tRPC payload.
+- Shows the 4-hour Base bucket and monthly Overage bucket documented in the T3 Chat FAQ.
+- Status: none yet.
+
 ## Ollama
 - Web settings page (`https://ollama.com/settings`) via browser cookies.
 - Parses Cloud Usage plan badge, session/weekly usage, and reset timestamps.
 - Status: none yet.
 - Details: `docs/ollama.md`.
 
+## Synthetic
+- API key from `~/.codexbar/config.json` (`providers[].apiKey`) or `SYNTHETIC_API_KEY`.
+- Shows rolling five-hour, weekly token, search-hourly, and cost/credit quota lanes when present.
+- Status: none yet.
+
 ## OpenRouter
-- API token from `~/.codexbar/config.json` (`providerConfig.openrouter.apiKey`) or `OPENROUTER_API_KEY` env var.
-- Credits endpoint: `https://openrouter.ai/api/v1/credits` (returns total credits purchased and usage).
-- Key info endpoint: `https://openrouter.ai/api/v1/key` (returns rate limit info).
+- API token from `~/.codexbar/config.json` (`providers[].apiKey`) or `OPENROUTER_API_KEY` env var.
+- Reads credits and key rate-limit info from OpenRouter APIs.
+- Shows daily, weekly, and monthly API-key spend when `/api/v1/key` returns those fields.
 - Override base URL with `OPENROUTER_API_URL` env var.
 - Status: `https://status.openrouter.ai` (link only, no auto-polling yet).
 - Details: `docs/openrouter.md`.
 
+## Perplexity
+- Browser session cookie from automatic import, manual header/token, or `PERPLEXITY_SESSION_TOKEN` / `PERPLEXITY_COOKIE`.
+- Tracks recurring credits, bonus/promotional credits, purchased credits, and renewal date when present.
+- Status: `https://status.perplexity.com/` (link only, no auto-polling).
+
+## Xiaomi MiMo
+- Browser cookies from automatic import or manual `Cookie:` header.
+- Reads balance and token-plan usage from `platform.xiaomimimo.com`.
+- Status: none yet.
+- Details: `docs/mimo.md`.
+
+## Doubao
+- API key via `ARK_API_KEY`, `VOLCENGINE_API_KEY`, `DOUBAO_API_KEY`, or provider config.
+- Probes Volcengine Ark chat completions and reads request rate-limit headers when present.
+- Status: none yet.
+- Details: `docs/doubao.md`.
+
+## Abacus AI
+- Browser cookies (`abacus.ai`, `apps.abacus.ai`) via automatic import or manual header.
+- Reads organization compute points and billing data.
+- Shows monthly credit gauge with pace tick and reserve/deficit estimate.
+- Status: none yet.
+- Details: `docs/abacus.md`.
+
+## Mistral
+- Session cookie (`ory_session_*`) from browser auto-import or manual `Cookie:` header.
+- CSRF token (`csrftoken` cookie) sent as `X-CSRFTOKEN` for billing and Vibe usage requests.
+- Domains: `admin.mistral.ai` for API billing and `console.mistral.ai` for optional Vibe subscription usage. Admin Ory cookies are never forwarded to the console origin.
+- Reads monthly usage and pricing from the Mistral billing API.
+- Cost is computed client-side from token counts and response pricing.
+- Reads Vibe monthly-plan usage percentage and reset time when the console endpoint is available.
+- The menu bar metric can show either pay-as-you-go API spend or monthly-plan usage.
+- Resets at end of calendar month.
+- Status: `https://status.mistral.ai` (link only, no auto-polling).
+
+## DeepSeek
+- API key via `DEEPSEEK_API_KEY` / `DEEPSEEK_KEY` env var or DeepSeek token accounts.
+- Shows total balance with paid vs. granted breakdown; USD preferred when multiple currencies present.
+- Status: `https://status.deepseek.com` (link only, no auto-polling).
+- Details: `docs/deepseek.md`.
+
+## Moonshot / Kimi API
+- API key via `MOONSHOT_API_KEY` / `MOONSHOT_KEY` env var or provider config.
+- Reads `GET /v1/users/me/balance` from the selected Moonshot region.
+- Region: international (`api.moonshot.ai`) or China mainland (`api.moonshot.cn`), configurable in Settings or `MOONSHOT_REGION`.
+- Shows available balance; negative cash balance is surfaced as a deficit.
+- Status: none yet.
+- Details: `docs/moonshot.md`.
+
+## Venice
+- API key via `VENICE_API_KEY` / `VENICE_KEY` env var or Venice token accounts.
+- Shows current DIEM or USD balance; DIEM epoch allocation progress when available.
+- Status: none yet.
+- Details: `docs/venice.md`.
+
+## Codebuff
+- API token from `~/.codexbar/config.json`, `CODEBUFF_API_KEY`, or `~/.config/manicode/credentials.json` created by `codebuff login`.
+- Reads usage and subscription data from Codebuff APIs.
+- Shows credit balance, weekly rate limit, reset timing, subscription status, and auto-top-up flag when present.
+- Override base URL with `CODEBUFF_API_URL`.
+- Status: none yet.
+- Details: `docs/codebuff.md`.
+
+## Crof
+- API key from `~/.codexbar/config.json`, `CROF_API_KEY`, or `CROFAI_API_KEY`.
+- Reads `credits`, `requests_plan`, and `usable_requests` from `GET https://crof.ai/usage_api/`.
+- Shows request quota as the primary usage window and dollar credits as the secondary row.
+- Infers the daily request reset from midnight America/Chicago until the usage API exposes reset metadata.
+- Status: none yet.
+- Details: `docs/crof.md`.
+
+## Command Code
+- Browser session cookies from automatic import or manual `Cookie:` header.
+- Linux CLI supports configured manual cookies; automatic browser import remains macOS-only.
+- Reads monthly USD credits and billing-cycle usage from `api.commandcode.ai`.
+- Automatic import looks for better-auth session cookies from `commandcode.ai` / `www.commandcode.ai`.
+- Status: none yet.
+- Details: `docs/command-code.md`.
+
+## Grok
+- `grok agent stdio` (ACP) JSON-RPC `x.ai/billing` method; requires `grok login` (SuperGrok OAuth/OIDC).
+- Reads cached credentials from `~/.grok/auth.json` for identity (email, team).
+- Falls back to grok.com's billing gRPC-web endpoint via Chrome session cookies when the CLI does not expose billing.
+- CLI/test runs do not import browser cookies unless `CODEXBAR_ALLOW_BROWSER_COOKIE_IMPORT=1` is set.
+- Local fallback aggregates `~/.grok/sessions/**/signals.json` token counts when the RPC is unavailable.
+- Status: link only to `https://status.x.ai` (no auto-polling yet).
+- Details: `docs/grok.md`.
+
+## AWS Bedrock
+- AWS credentials from `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, and optional `AWS_SESSION_TOKEN`.
+- Region from `AWS_REGION` / `AWS_DEFAULT_REGION`, defaulting to `us-east-1`.
+- Reads AWS Cost Explorer for Bedrock spend and can compare usage against `CODEXBAR_BEDROCK_BUDGET`.
+- Optionally reads rolling 14-day Claude token and request totals from CloudWatch with `cloudwatch:GetMetricData`.
+- Override Cost Explorer base URL with `CODEXBAR_BEDROCK_API_URL` for tests.
+- Details: `docs/bedrock.md`.
+
+## Deepgram
+- API key from config or `DEEPGRAM_API_KEY`.
+- Optional project ID from provider settings or `DEEPGRAM_PROJECT_ID`; otherwise aggregates all visible projects.
+- Optional API base URL override via `DEEPGRAM_API_URL`; overrides must be HTTPS or bare hosts normalized to HTTPS.
+- Reads Deepgram usage breakdowns for audio hours, agent hours, token totals, TTS characters, and requests.
+- Details: `docs/deepgram.md`.
+
+## Xiaomi MiMo
+- Browser cookies or manual Cookie header for `platform.xiaomimimo.com` balance and token-plan endpoints.
+- Optional testing override via `MIMO_API_URL`; overrides must be HTTPS or bare hosts normalized to HTTPS, and invalid
+  overrides fail closed instead of falling back to local MiMo usage accounting.
+- Local MiMo token accounting is available only when the opt-in cache file exists.
+- Details: `docs/mimo.md`.
+
+## LiteLLM
+- API key from config or `LITELLM_API_KEY`; base URL from config `enterpriseHost` or `LITELLM_BASE_URL`.
+- Reads `/key/info` first, then `/user/info?user_id=...` for user-bound keys or `/team/info?team_id=...` for team-only keys.
+- User-bound keys show personal budget usage as the primary window and the key's exact matching team as the secondary window.
+- Team-only keys show the team budget as their sole usage window. Automatic menu-bar selection prefers the enforced team budget.
+- Spend remains visible in the API-spend row when LiteLLM has no budget limit configured.
+- Accepts base URLs with or without a `/v1` suffix; management requests are sent to the proxy root.
+- Details: `docs/litellm.md`.
+
+## Poe
+- API key from config or `POE_API_KEY`.
+- Reads the current point balance and recent points history from Poe's official usage API.
+- History failures are non-fatal; the current balance remains available.
+- Details: `docs/poe.md`.
+
+## Chutes
+- API key from config or `CHUTES_API_KEY`.
+- Reads subscription usage first, then fills missing rolling, monthly, or pay-as-you-go quota data from the quota APIs.
+- Uses Chutes' management API at `https://api.chutes.ai`; `CHUTES_API_URL` can override it with an HTTPS endpoint.
+- Details: `docs/chutes.md`.
+
+## StepFun
+- Username/password login or manual Oasis-Token.
+- Reads Step Plan 5-hour and weekly rate-limit windows from `platform.stepfun.com`.
+- Shows subscription plan name when the Step Plan status API returns one.
+- Status: none yet.
+- Details: `docs/stepfun.md`.
+
 See also: `docs/provider.md` for architecture notes.
diff --git a/docs/quotio-comparison.md b/docs/quotio-comparison.md
index ea96ab3fce..78fee8d278 100644
--- a/docs/quotio-comparison.md
+++ b/docs/quotio-comparison.md
@@ -1,3 +1,11 @@
+---
+summary: "Quotio comparison notes and possible CodexBar enhancement ideas."
+read_when:
+  - Evaluating Quotio-inspired UX or architecture ideas
+  - Planning provider quota-tracking roadmap items
+  - Comparing CodexBar scope against proxy-based quota tools
+---
+
 # Quotio Comparison & Enhancement Opportunities
 
 **Date:** 2026-01-04  
diff --git a/docs/refactor/claude-current-baseline.md b/docs/refactor/claude-current-baseline.md
new file mode 100644
index 0000000000..bedeca3860
--- /dev/null
+++ b/docs/refactor/claude-current-baseline.md
@@ -0,0 +1,155 @@
+---
+summary: "Current Claude behavior baseline before vNext refactor work."
+read_when:
+  - Planning Claude refactor tickets
+  - Changing Claude runtime/source selection
+  - Changing Claude OAuth prompt or cooldown behavior
+  - Changing Claude token-account routing
+---
+
+# Claude current baseline
+
+This document is the current-state parity reference for Claude behavior in CodexBar.
+
+Use it when later tickets need to preserve or intentionally change Claude behavior. When the refactor plan,
+summary docs, and running code disagree, treat current code plus characterization coverage as authoritative, and use
+this document as the human-readable summary of that current state.
+
+## Scope of this baseline
+
+This baseline captures the current behavior surface that later refactor work must preserve unless a future ticket
+changes it intentionally:
+
+- runtime/source-mode selection,
+- prompt and cooldown behavior that affects Claude OAuth repair flows,
+- token-account routing at the app and CLI edges,
+- provider siloing and web-enrichment rules,
+- the current relationship between the public Claude doc and the vNext refactor plan.
+
+## Active behavior owners
+
+Current Claude behavior is defined by several active owners, not one central planner:
+
+- `Sources/CodexBarCore/Providers/Claude/ClaudeProviderDescriptor.swift`
+  owns the main provider-pipeline strategy order and fallback rules.
+- `Sources/CodexBarCore/Providers/Claude/ClaudeUsageFetcher.swift`
+  still owns a separate direct `.auto` path, delegated refresh, prompt/cooldown handling, and web-extra enrichment.
+- `Sources/CodexBar/Providers/Claude/ClaudeSettingsStore.swift`
+  owns app-side token-account routing into cookie or OAuth behavior.
+- `Sources/CodexBarCLI/TokenAccountCLI.swift`
+  owns CLI-side token-account routing and effective source-mode overrides.
+- `Sources/CodexBarCore/TokenAccountSupport.swift`
+  owns the current string heuristics that distinguish Claude OAuth access tokens from cookie/session-key inputs.
+
+## Current runtime and source-mode behavior
+
+### Main provider pipeline
+
+The generic provider pipeline currently resolves Claude strategies in this order:
+
+| Runtime | Selected mode | Ordered strategies | Fallback behavior |
+| --- | --- | --- | --- |
+| app | auto | `oauth -> cli -> web` | OAuth can fall through to CLI/Web. CLI can fall through to Web only when Web is available. Web is terminal. |
+| app | oauth | `oauth` | No fallback. |
+| app | cli | `cli` | No fallback. |
+| app | web | `web` | No fallback. |
+| cli | auto | `web -> cli` | Web can fall through to CLI. CLI is terminal. |
+| cli | oauth | `oauth` | No fallback. |
+| cli | cli | `cli` | No fallback. |
+| cli | web | `web` | No fallback. |
+
+This behavior is owned by `Sources/CodexBarCore/Providers/Claude/ClaudeProviderDescriptor.swift`
+through `ProviderFetchPlan` and `ProviderFetchPipeline`.
+
+### Other active `.auto` decision sites
+
+The codebase still contains multiple active `.auto` decision sites:
+
+| Owner | Current behavior |
+| --- | --- |
+| `ClaudeProviderDescriptor.resolveUsageStrategy(...)` | Chooses `oauth`, then `cli`, then `web`, with final `cli` fallback when none are available. |
+| `ClaudeUsageFetcher.loadLatestUsage(.auto)` | Chooses `oauth`, then `web`, then `cli`, with final `oauth` fallback. |
+
+This inconsistency is intentional to record here. RAT-107 directly characterizes the active direct-fetcher branches it
+can reach cleanly in tests and records the remaining current-state behavior without reconciling it.
+
+## Prompt and cooldown baseline
+
+Current behavior that later refactor work must preserve:
+
+- The default Claude keychain prompt mode is `onlyOnUserAction`.
+- Prompt policy is only applicable when the Claude OAuth read strategy is `securityFramework`.
+- User-initiated interaction clears a prior Claude keychain cooldown denial before retrying availability or repair.
+- Startup bootstrap prompting is allowed only when all of these are true:
+  - runtime is app,
+  - interaction is background,
+  - refresh phase is startup,
+  - prompt mode is `onlyOnUserAction`,
+  - no cached Claude credentials exist.
+- Background delegated refresh is blocked when prompt policy is `onlyOnUserAction` and the caller did not explicitly
+  allow background delegated refresh.
+- Prompt mode `never` blocks delegated refresh attempts.
+- Expired credential owner behavior remains owner-specific:
+  - `.claudeCLI`: delegated refresh path,
+  - `.codexbar`: direct refresh path,
+  - `.environment`: no auto-refresh.
+
+## Token-account routing baseline
+
+Accepted Claude token-account input shapes today:
+
+- raw OAuth access token with `sk-ant-oat...` prefix,
+- `Bearer sk-ant-oat...` input,
+- raw session key,
+- full cookie header.
+
+Current routing rules:
+
+- OAuth-token-shaped inputs are not treated as cookies.
+- Cookie/header-shaped inputs are any value that already contains `Cookie:` or `=`.
+- App-side Claude snapshot behavior:
+  - OAuth token account keeps the usage source setting as-is, disables cookie mode (`.off`), clears the manual cookie
+    header, and relies on environment-token injection.
+  - Session-key or cookie-header account keeps the usage source setting as-is, forces manual cookie mode, and
+    normalizes raw session keys into `sessionKey=<value>`.
+- CLI-side Claude token-account behavior:
+  - OAuth token account changes the effective source mode from `auto` to `oauth`, disables cookie mode, omits a
+    manual cookie header, and injects `CODEXBAR_CLAUDE_OAUTH_TOKEN`.
+  - Session-key or cookie-header account stays in cookie/manual mode.
+
+## Siloing and web-enrichment baseline
+
+Claude Web enrichment is cost-only when the primary source is OAuth or CLI:
+
+- Web extras may populate `providerCost` when it is missing.
+- Web extras must not replace `accountEmail`, `accountOrganization`, or `loginMethod` from the primary source.
+- Snapshot identity remains provider-scoped to Claude.
+
+This behavior is implemented in `Sources/CodexBarCore/Providers/Claude/ClaudeUsageFetcher.swift`
+inside `applyWebExtrasIfNeeded`.
+
+## Documentation contract
+
+- [docs/claude.md](../claude.md) is the summary doc for contributors who want an overview.
+- This file is the exact current-state baseline for contributor and refactor parity work.
+- [claude-provider-vnext-locked.md](claude-provider-vnext-locked.md)
+  is the future refactor plan and should cite this file for present behavior.
+
+## Characterization coverage
+
+Stable automated coverage for this baseline lives in:
+
+- `Tests/CodexBarTests/ClaudeBaselineCharacterizationTests.swift`
+- `Tests/CodexBarTests/ClaudeOAuthFetchStrategyAvailabilityTests.swift`
+- `Tests/CodexBarTests/ClaudeUsageTests.swift`
+- `Tests/CodexBarTests/TokenAccountEnvironmentPrecedenceTests.swift`
+- `Tests/CodexBarTests/SettingsStoreCoverageTests.swift`
+
+`ClaudeUsageTests.swift` now directly characterizes the reachable `ClaudeUsageFetcher(.auto)` branches for:
+
+- OAuth when OAuth, Web, and CLI all appear available,
+- Web before CLI when OAuth is unavailable,
+
+The successful CLI-selected branch and the CLI-failure-to-OAuth fallback remain documented from code inspection plus
+surrounding Claude probe/regression coverage, because the current CLI-availability decision is sourced from process-wide
+binary discovery with no stable test seam that would keep RAT-107 in scope.
diff --git a/docs/refactor/claude-provider-vnext-locked.md b/docs/refactor/claude-provider-vnext-locked.md
new file mode 100644
index 0000000000..8576cf8ba6
--- /dev/null
+++ b/docs/refactor/claude-provider-vnext-locked.md
@@ -0,0 +1,356 @@
+---
+summary: "Locked implementation plan for Claude provider vNext: resolved source-selection contracts, typed credential rules, siloing guarantees, and phase gates."
+supersedes: "Initial vNext draft (removed)"
+created: "2026-02-18"
+status: "Locked for implementation"
+---
+
+# Claude provider vNext (locked plan)
+
+This is the implementation-locked vNext plan.
+
+It preserves the original architecture direction, but removes ambiguity in behavior-critical areas before refactor work starts.
+
+Current-state parity reference for present behavior:
+
+- [docs/refactor/claude-current-baseline.md](claude-current-baseline.md)
+
+Use the baseline doc for present behavior. This vNext plan defines what the refactor should preserve and how it should
+be staged; it is not the sole source of truth for current implementation details, and RAT-107 does not re-approve the
+rest of the future architecture below.
+
+## Assessment snapshot
+
+- **Approach score:** `8.4/10`.
+- **Why not 9+ yet:** the original plan left runtime ordering, token-account credential typing behavior, and compatibility mapping under-specified.
+- **How this doc closes the gap:** explicit contracts + resolved decisions + phase exit gates + risk checklist.
+- **Validated gap coverage in this version:** explicit `.auto` inconsistency handling, `ClaudeUsageFetcher` decomposition, stronger parity gates, TaskLocal-to-DI migration, and OAuth decomposition sub-phases.
+
+## Locked behavioral contracts
+
+These behaviors are **non-negotiable** during refactor unless this doc is explicitly updated.
+
+### 1) Runtime + source-mode contract
+
+`ClaudeSourcePlanner` must reproduce this matrix exactly:
+
+| Runtime | Selected mode | Ordered attempts | Fallback rules |
+| --- | --- | --- | --- |
+| app | auto | oauth -> cli -> web | oauth fallback allowed; cli fallback to web only when web available; web terminal |
+| app | oauth | oauth | no fallback |
+| app | cli | cli | no fallback |
+| app | web | web | no fallback |
+| cli | auto | web -> cli | web fallback allowed to cli; cli terminal |
+| cli | oauth | oauth | no fallback |
+| cli | cli | cli | no fallback |
+| cli | web | web | no fallback |
+
+Notes:
+- `sourceLabel` remains the final step label for successful fetch output.
+- Planner diagnostics must include ordered steps and inclusion reasons.
+- Planner output must feed the existing generic provider fetch pipeline; do not introduce a second Claude-only
+  execution stack alongside `ProviderFetchPlan` / `ProviderFetchPipeline`.
+
+### 1a) `.auto` inconsistency characterization contract (must-do before reconciliation)
+
+Current code has three `.auto` decision sites with inconsistent app ordering:
+
+- Strategy pipeline resolve order (app): `oauth -> cli -> web`.
+- `resolveUsageStrategy` helper order: `oauth -> cli -> web -> cli fallback`.
+- `ClaudeUsageFetcher.loadLatestUsage(.auto)` order: `oauth -> web -> cli -> oauth fallback`.
+
+Phase 0 must characterize these paths with tests where they are reachable through stable seams, and otherwise defer to
+the baseline doc before deleting any path.
+Phase 2 must reconcile this into planner-only source selection.
+
+### 2) Prompt/cooldown contract
+
+The planner must use one explicit `ClaudePromptDecision` equivalent, but outcome parity with current behavior is required:
+
+- User-initiated actions can clear prior keychain cooldown denial.
+- Startup bootstrap prompt is only allowed when all are true:
+  - runtime is app
+  - interaction is background
+  - refresh phase is startup
+  - prompt mode is `onlyOnUserAction`
+  - no cached credentials
+- Background delegated refresh is blocked when:
+  - prompt policy is `onlyOnUserAction`
+  - caller does not explicitly allow background delegated refresh
+- Prompt mode `never` blocks delegated refresh attempts.
+
+### 3) Credential typing + routing contract
+
+Typed credentials must be introduced at the settings snapshot edge, with behavior parity:
+
+- `ClaudeManualCredential.sessionKey`
+- `ClaudeManualCredential.cookieHeader`
+- `ClaudeManualCredential.oauthAccessToken`
+
+Accepted Claude token-account inputs must continue to work:
+
+- Raw OAuth token (including `Bearer ...` input)
+- Raw session key
+- Full cookie header
+
+Routing parity requirements:
+
+- OAuth token account values must route to OAuth path (not cookie mode).
+- Cookie/session-key account values must route to web cookie path.
+- CLI token-account behavior must remain consistent in both app and `CodexBarCLI`.
+- Scope note: current string heuristics are mostly edge-routing logic, not deep OAuth credential decoding internals.
+
+### 4) Ownership and refresh contract
+
+Credential owner behavior must remain identical:
+
+- `.claudeCLI` expired credentials: delegated refresh path.
+- `.codexbar` expired credentials: direct refresh endpoint path.
+- `.environment` expired credentials: no auto-refresh.
+
+Refresh failure-gate semantics must remain unchanged.
+
+### 5) Provider siloing + enrichment contract
+
+Hard invariant:
+
+- Never merge Claude Web identity into OAuth/CLI snapshots.
+- Web extras may enrich **cost only**.
+- Snapshot identity must always remain provider-scoped to `.claude` when persisted/displayed.
+
+### 6) Plan inference compatibility contract
+
+Canonical plan inference can live behind the existing `loginMethod` compatibility surface, but outward
+compatibility must be preserved:
+
+- Existing detectable plans continue mapping to display strings:
+  - `Claude Max`
+  - `Claude Pro`
+  - `Claude Team`
+  - `Claude Enterprise`
+- Subscription detection behavior must remain compatible with current UI logic, including existing `Ultra` detection
+  semantics until that behavior is explicitly changed.
+
+### 7) Documentation + diagnostics contract
+
+- During refactor, characterization coverage plus
+  [docs/refactor/claude-current-baseline.md](claude-current-baseline.md)
+  are the source of truth when docs and code disagree.
+- `docs/claude.md` must be updated as part of Phase 0 after characterization lands so it no longer presents divergent
+  runtime ordering as settled behavior.
+- Debug surfaces must consume planner-derived diagnostics instead of recomputing Claude source decisions separately.
+
+## Resolved decisions (from open questions)
+
+### Web identity fill-ins
+
+- **Decision:** do not use Web identity to fill missing OAuth/CLI identity fields.
+- **Allowed:** Web cost enrichment only.
+
+### CLI runtime fallback ordering
+
+- **Decision:** keep current CLI ordering in `auto`: `web -> cli`.
+- Planner must encode this explicitly and not rely on incidental strategy ordering.
+
+### Startup bootstrap prompt in `onlyOnUserAction`
+
+- **Decision:** keep support exactly under the startup bootstrap constraints listed above.
+- Any expansion/restriction requires explicit doc update and tests.
+
+### Runtime policy unification timing
+
+- **Decision:** do not unify app and CLI `auto` ordering before this refactor.
+- First consolidate to one planner implementation with current runtime-specific behavior preserved.
+- Any runtime-policy unification is a separate, explicit behavior-change follow-up.
+
+### Planner integration timing
+
+- **Decision:** `ClaudeSourcePlanner` must be integrated into the existing provider descriptor / fetch pipeline rather
+  than added as a parallel orchestration layer.
+- Reuse current `ProviderFetchContext` / `ProviderFetchPlan` plumbing where possible.
+
+### Dependency seam timing
+
+- **Decision:** introduce dependency-container seams for newly extracted planner/executor components as they are
+  created.
+- Full TaskLocal cleanup can remain later, but new components should not deepen TaskLocal coupling.
+
+## Locked migration plan with exit gates
+
+### Phase 0: Baseline lock
+
+Deliverables:
+- Add `docs/refactor/claude-current-baseline.md` as the current-state behavior reference.
+- Add/refresh characterization tests for runtime/source matrix and prompt-decision parity.
+- Add explicit characterization tests for existing `.auto` decision paths where they are reachable through stable seams,
+  and defer remaining current-state details to the baseline doc until later reconciliation.
+- Update `docs/claude.md` after tests land so documented ordering matches characterized behavior.
+
+Exit gate:
+- Behavior matrix tests pass for app and cli runtimes.
+- `.auto` characterization coverage plus the baseline doc record current divergence explicitly without forcing new
+  production seams in Phase 0.
+- `docs/claude.md` no longer contradicts characterized runtime/source behavior.
+
+### Phase 1: Canonical plan resolver
+
+Deliverables:
+- Introduce `ClaudePlan` + one resolver used by OAuth/Web/CLI mapping and downstream UI consumers.
+
+Exit gate:
+- Plan mapping tests cover tier/billing/status-derived hints, compatibility display strings, and current UI subscription
+  detection compatibility.
+
+### Phase 1b: Typed credentials at the snapshot edge
+
+Deliverables:
+- Parse manual Claude credentials once at the app + CLI snapshot edges into a typed model.
+- Remove duplicated edge-routing heuristics for OAuth-vs-cookie decisions across settings snapshots and token-account
+  CLI code.
+
+Exit gate:
+- Token account parity tests pass for app + CLI.
+- Snapshot-edge routing no longer duplicates Claude OAuth-token detection logic in multiple call sites.
+
+### Phase 2: Single source planner
+
+Deliverables:
+- Introduce `ClaudeSourcePlanner` + explicit `ClaudeFetchPlan`.
+- Integrate planner outputs into the existing provider pipeline / descriptor flow.
+- Remove duplicate `.auto` policy branches from lower layers.
+- Reconcile and remove `ClaudeUsageFetcher` internal `.auto` source selection.
+- Move debug/diagnostic surfaces to planner-derived attempt ordering instead of helper-specific recomputation.
+
+Exit gate:
+- One authoritative planner path for mode/runtime ordering.
+- Fallback attempt logs still show expected sequence and source labels.
+- No surviving `.auto` source-order logic outside planner.
+- No surviving debug-only source-order recomputation outside planner diagnostics.
+- Old-vs-new planner parity tests pass before old branches are removed.
+
+### Phase 2b: `ClaudeUsageFetcher` decomposition
+
+Deliverables:
+- Split `ClaudeUsageFetcher` into smaller executor-focused components.
+- Extract delegated OAuth retry/recovery flow into dedicated units.
+- Remove embedded prompt-policy/source-selection ownership from fetcher; keep it execution-only.
+
+Exit gate:
+- Fetcher no longer owns source-selection policy.
+- Delegated OAuth retry behavior is covered by dedicated tests and remains parity-compatible.
+
+### Phase 3: Test injection cleanup
+
+Deliverables:
+- Prefer dependency seams on extracted units instead of adding new TaskLocal-only override points.
+ - Avoid expanding TaskLocal-only test hooks while decomposition work lands.
+
+Exit gate:
+- New fetcher tests rely on explicit dependency seams where practical.
+
+### Phase 4: OAuth decomposition
+
+Deliverables (sub-phases):
+
+- **Phase 4a (repository extraction):**
+  - Extract IO + caching + owner/source loading into repository surface.
+  - Keep prompt-gate semantics unchanged.
+- **Phase 4b (refresher extraction):**
+  - Extract network refresh + failure gating to refresher component.
+  - Keep owner-based refresh behavior unchanged.
+- **Phase 4c (delegated controller extraction):**
+  - Extract delegated CLI touch + keychain-change observation + cooldown behavior.
+  - Keep delegated retry outcomes unchanged.
+
+Exit gate:
+- Existing OAuth delegated refresh / prompt policy / cooldown suites pass without behavior deltas at each sub-phase.
+- Owner semantics parity remains intact across all sub-phases (`claudeCLI`, `codexbar`, `environment`).
+
+### Phase 5: Test injection migration (TaskLocal -> DI)
+
+Deliverables:
+- Move test injection from TaskLocal-heavy overrides to `ClaudeFetchDependencies` and explicit protocol stubs.
+- Keep compatibility shims temporarily where needed, then remove them.
+
+Exit gate:
+- Core planner/executor tests run without TaskLocal injection dependencies.
+- Legacy TaskLocal-only override surfaces are either removed or isolated to compatibility adapters with deletion TODOs.
+
+### Phase 6: Web decomposition (optional)
+
+Deliverables:
+- Separate cookie acquisition from web usage client.
+- Keep probe tooling isolated behind debug/tool surface.
+
+Exit gate:
+- Web parsing and account mapping tests remain green.
+
+## Implementation PR plan (stacked)
+
+Use this sequence to keep each PR reviewable without turning the rollout into unnecessary PR overhead.
+
+| PR | Title | Scope | Primary risks | Must-pass gate before merge |
+| --- | --- | --- | --- | --- |
+| PR-01 | Baseline characterization + doc correction | Lock current matrix behavior, characterize `.auto` paths through stable seams, defer remaining lower-level current-state details to the baseline doc, characterize prompt bootstrap/cooldown and token-account routing, then update docs to match reality. | R1, R2, R5, R6, R10 | No production behavior changes; characterization suites green; docs no longer contradict tests or the baseline. |
+| PR-02 | Canonical plan resolver | Introduce `ClaudePlan` and central resolver; map OAuth/Web/CLI/UI compatibility through one model while preserving current `loginMethod` projections. | R8 | Plan compatibility tests green (`Max/Pro/Team/Enterprise` + current subscription compatibility). |
+| PR-03 | Typed credentials at the edge | Parse manual credentials once (`sessionKey`, `cookieHeader`, `oauthAccessToken`) in app + CLI snapshot shaping. | R6 | Token-account routing parity tests green in app + CLI contexts. |
+| PR-04 | Source planner introduction + cutover | Add `ClaudeSourcePlanner`, prove parity against old path, then remove duplicate `.auto` selection branches once parity is proven. | R1, R5, R10 | One `.auto` authority remains; attempt/source-label diagnostics remain parity-compatible. |
+| PR-05 | `ClaudeUsageFetcher` decomposition | Split fetcher into execution/retry-focused units; remove embedded source-selection ownership. | R2, R10 | Delegated OAuth retry/recovery tests green with no behavior deltas. |
+| PR-06 | OAuth decomposition | Extract repository, refresher, and delegated-controller seams from `ClaudeOAuthCredentialsStore` while preserving owner semantics. | R3, R4, R7, R9 | Cache/fingerprint/prompt/owner suites green (`claudeCLI`, `codexbar`, `environment`). |
+| PR-07 (optional) | TaskLocal -> DI migration | Move remaining tests and seams to `ClaudeFetchDependencies`, keep temporary compat adapters, then remove. | R9 | Core planner/executor tests run without TaskLocal globals. |
+| PR-08 (optional) | Web decomposition | Split cookie acquisition from web usage client and keep tooling isolated. | R8, R10 | Web parsing/account mapping suites remain green. |
+
+Stacking rules:
+
+1. Keep each PR scoped to one risk cluster and one merge gate.
+2. Do not remove old branches until a prior PR has old-vs-new parity tests in CI.
+3. If a PR intentionally changes behavior, update this locked doc in the same PR and call it out in summary.
+4. Prefer 6 core PRs unless parity risk forces a temporary split; do not fragment the rollout further without a
+   concrete rollback or reviewability reason.
+
+## Mandatory test additions
+
+Add these test groups before or during Phases 1-3, then extend for later phases:
+
+1. Planner matrix tests:
+   - `(runtime x selected mode x interaction x refresh phase x availability)` -> exact step order + fallback.
+2. `.auto` divergence characterization tests:
+   - Lock current behavior of strategy pipeline vs `resolveUsageStrategy` helper vs fetcher-direct `.auto`.
+   - Use as guardrails while consolidating to planner-only logic.
+3. Typed credential parsing tests:
+   - OAuth token, bearer token, session key, cookie header, malformed strings.
+4. Cross-provider identity isolation tests:
+   - Ensure `.claude` identity does not leak via snapshot scoping/merging.
+5. Source-label and attempt diagnostics tests:
+   - Validate final source label and attempt list parity.
+6. CLI token-account parity tests:
+   - `TokenAccountCLIContext` and app settings snapshot behavior match for OAuth-vs-cookie routing.
+7. Old-vs-new parity tests:
+   - Compare old path and planner path outputs before branch removals in Phase 2 and Phase 2b.
+8. DI migration tests:
+   - Ensure new dependency container can drive planner/executor tests without TaskLocal globals.
+
+## Risk checklist (implementation review)
+
+Use these risk IDs in refactor PR checklists/reviews.
+
+| Risk ID | Severity | Risk | Detail |
+| --- | --- | --- | --- |
+| R1 | Critical | Auto-ordering reconciliation | Three `.auto` paths are inconsistent today. Characterize strategy pipeline vs `resolveUsageStrategy` helper vs fetcher-direct `.auto` before deleting any path. |
+| R2 | High | Prompt policy consolidation | Prompt policy exists across strategy availability, fetcher flow, and credentials store gates. Preserve startup bootstrap constraints exactly to avoid prompt storms or silent OAuth suppression. |
+| R3 | High | `ClaudeOAuthCredentialsStore` decomposition | Large lock-protected state + layered caches + fingerprint invalidation + security calls. Splits can break cache coherence, invalidation timing, or prompt gating order. |
+| R4 | High | Owner semantics drift | Preserve exact owner-to-refresh mapping: `.claudeCLI` delegated, `.codexbar` direct refresh, `.environment` no refresh. |
+| R5 | Medium | CLI runtime parity | Preserve runtime-specific policy: CLI `auto` remains `web -> cli`; OAuth is available only when explicitly selected as `sourceMode=.oauth`. Do not accidentally default CLI runtime to app ordering. |
+| R6 | Medium | Token-account OAuth-vs-cookie misrouting | Keep routing parity for OAuth token vs session key vs full cookie header, including `Bearer sk-ant-oat...` normalization. |
+| R7 | Medium | Cache invalidation regressions | Preserve credentials file/keychain fingerprint semantics and stale-cache guards during repository extraction. |
+| R8 | Low-Medium | Plan inference heuristic drift | Preserve web-specific plan inference fallback (`billing_type` + `rate_limit_tier`) when unifying plan resolution. |
+| R9 | Medium | Strict concurrency / `@Sendable` regressions | Maintain thread-safe behavior from current NSLock-based state while moving to DI/decomposed components under Swift 6 strict concurrency. |
+| R10 | Low | Debug/diagnostic drift | Keep source labels, attempt sequences, and debug output aligned with real planner decisions after consolidation. |
+
+## Change-control rule
+
+Any refactor PR that intentionally changes one of the locked contracts above must:
+
+1. Update this document.
+2. Add/adjust tests proving the new behavior.
+3. Call out the behavior change explicitly in the PR summary.
diff --git a/docs/refactor/cli.md b/docs/refactor/cli.md
index 0eadaa7021..1e9ea37b86 100644
--- a/docs/refactor/cli.md
+++ b/docs/refactor/cli.md
@@ -73,7 +73,6 @@ read_when:
    - Config validation (bad region/source/apiKey field).
    - SettingsStore order/toggle invariants still pass.
 8. **Verification**
-   - `swift test`, `swiftformat Sources Tests`, `swiftlint --strict`, `pnpm check`.
+   - `make test`, `swiftformat Sources Tests`, `swiftlint --strict`, `make check`.
    - `./Scripts/compile_and_run.sh`.
    - CLI e2e: `codexbar --json-only ...`, `codexbar config validate`.
-
diff --git a/docs/refactor/macros.md b/docs/refactor/macros.md
deleted file mode 100644
index ce1a8439e4..0000000000
--- a/docs/refactor/macros.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-summary: "Provider macro refactor ideas and follow-ups."
-read_when:
-  - Reviewing provider macro ergonomics
-  - Planning provider/descriptor refactors
----
-
-# Macro refactor ideas
-
-1. Macro ergonomics + errors
-- Emit compile-time errors when a macro is attached to the wrong target or missing `descriptor`/`init`.
-- Add a member macro to generate `static let descriptor` from `makeDescriptor()` to remove boilerplate.
-
-2. Descriptor/data shape
-- Split ProviderDescriptor into Descriptor + FetchPlan + Branding + CLI files for cleaner deps.
-- Move source label into fetch results (strategy-specific).
-
-3. Fetching pipeline
-- Return all attempted strategies + errors for debug UI and CLI `--verbose`.
-
-4. Registry order & stability
-- Use ProviderDescriptorRegistry registration order for `all`; no sorting by rawValue.
-- Use metadata flags (e.g. `isPrimaryProvider`) instead of hard-coded Codex/Claude.
-
-5. Account/identity
-- Replace Codex UI special casing with a descriptor flag (e.g. `usesAccountFallback`).
-- Enforce provider-keyed identity in snapshots to avoid cross-provider display.
-
-6. Settings + tokens
-- Move Zai/Copilot token lookup into strategy-local resolvers (Keychain/env).
-- Add optional per-provider settings fields in ProviderSettingsSnapshot.
-
-7. Docs + tests
-- Add a minimal provider example in docs/provider.md.
-- Add registry completeness + deterministic-order test.
diff --git a/docs/refresh-loop.md b/docs/refresh-loop.md
index 58cb7c5454..1426ce2425 100644
--- a/docs/refresh-loop.md
+++ b/docs/refresh-loop.md
@@ -15,6 +15,9 @@ read_when:
 - Background refresh runs off-main and updates `UsageStore` (usage + credits + optional web scrape).
 - Manual “Refresh now” always available in the menu.
 - Stale/error states dim the icon and surface status in-menu.
+- Optional provider-storage scans run only when “Show provider storage usage” is enabled. They are scheduled in the
+  background, coalesced/throttled during automatic refreshes, and forced by manual refresh without blocking the usage
+  refresh path.
 
 ## Optional future
 - Auto-seed a log if none exists via `codex exec --skip-git-repo-check --json "ping"` (currently not executed).
diff --git a/docs/releasing-homebrew.md b/docs/releasing-homebrew.md
index 4bbfaf69c3..7aa73cbfdc 100644
--- a/docs/releasing-homebrew.md
+++ b/docs/releasing-homebrew.md
@@ -14,20 +14,30 @@ Homebrew is for the UI app via Cask. When installed via Homebrew, CodexBar disab
 - Access to the tap repo: `../homebrew-tap`.
 
 ## 1) Release CodexBar normally
-Follow `docs/RELEASING.md` to publish `CodexBar-<version>.zip` to GitHub Releases.
+Follow `docs/RELEASING.md` to publish `CodexBar-macos-universal-<version>.zip` to GitHub Releases.
 
-## 2) Update the Homebrew tap cask
-In `../homebrew-tap`, add/update the cask at `Casks/codexbar.rb`:
-- `url` points at the GitHub release asset: `.../releases/download/v<version>/CodexBar-<version>.zip`
+## 2) Let the Release CLI workflow update the tap
+After the GitHub release is published, `.github/workflows/release-cli.yml` builds the standalone CLI assets and dispatches `steipete/homebrew-tap`'s `update-formula.yml`. That tap workflow updates both:
+- `Casks/codexbar.rb` for the app zip.
+- `Formula/codexbar.rb` for the standalone CLI tarballs.
+
+If dispatch fails or is rate-limited, update the files manually.
+
+## 2a) Manual cask update
+In `../homebrew-tap`, update the cask at `Casks/codexbar.rb`:
+- `url` points at the GitHub release asset: `.../releases/download/v<version>/CodexBar-macos-universal-<version>.zip`
 - Update `sha256` to match that zip.
-- Keep `depends_on arch: :arm64` and `depends_on macos: ">= :sonoma"` (CodexBar is macOS 14+).
+- Keep `depends_on macos: ">= :sonoma"` (CodexBar is macOS 14+). Do not add an architecture restriction; the app zip is universal.
 
-## 2b) Update the Homebrew tap formula (Linux CLI)
-In `../homebrew-tap`, add/update the formula at `Formula/codexbar.rb`:
+## 2b) Manual formula update
+In `../homebrew-tap`, update the formula at `Formula/codexbar.rb`:
 - `url` points at the GitHub release assets:
-  - `.../releases/download/v<version>/CodexBarCLI-v<version>-linux-aarch64.tar.gz`
-  - `.../releases/download/v<version>/CodexBarCLI-v<version>-linux-x86_64.tar.gz`
-- Update both `sha256` values to match those tarballs.
+  - macOS: `.../releases/download/v<version>/CodexBarCLI-v<version>-macos-arm64.tar.gz`
+  - macOS: `.../releases/download/v<version>/CodexBarCLI-v<version>-macos-x86_64.tar.gz`
+  - Linux: `.../releases/download/v<version>/CodexBarCLI-v<version>-linux-aarch64.tar.gz`
+  - Linux: `.../releases/download/v<version>/CodexBarCLI-v<version>-linux-x86_64.tar.gz`
+- Static musl tarballs are also published for manual Linux installs as `linux-musl-aarch64` and `linux-musl-x86_64`; keep the formula on the glibc assets unless intentionally changing its runtime contract.
+- Update all `sha256` values to match those tarballs.
 
 ## 3) Verify install
 ```sh
diff --git a/docs/session-keepalive-design.md b/docs/session-keepalive-design.md
index c2f7d9d12f..545fb2beaf 100644
--- a/docs/session-keepalive-design.md
+++ b/docs/session-keepalive-design.md
@@ -1,3 +1,11 @@
+---
+summary: "Design notes for unified provider session keepalive scheduling and refresh control."
+read_when:
+  - Planning provider session keepalive work
+  - Refactoring Augment keepalive behavior
+  - Designing background session refresh scheduling
+---
+
 # Session Keepalive Enhancement Design
 
 **Date:** 2026-01-04  
diff --git a/docs/site-locales.mjs b/docs/site-locales.mjs
new file mode 100644
index 0000000000..9964d07e2b
--- /dev/null
+++ b/docs/site-locales.mjs
@@ -0,0 +1,1183 @@
+export const localeCatalog = [
+  {
+    "code": "en",
+    "name": "English"
+  },
+  {
+    "code": "zh-CN",
+    "name": "简体中文"
+  },
+  {
+    "code": "zh-TW",
+    "name": "繁體中文"
+  },
+  {
+    "code": "ja-JP",
+    "name": "日本語"
+  },
+  {
+    "code": "es",
+    "name": "Español"
+  },
+  {
+    "code": "pt-BR",
+    "name": "Português (BR)"
+  },
+  {
+    "code": "ko",
+    "name": "한국어"
+  },
+  {
+    "code": "de",
+    "name": "Deutsch"
+  },
+  {
+    "code": "fr",
+    "name": "Français"
+  },
+  {
+    "code": "ar",
+    "name": "العربية",
+    "direction": "rtl"
+  },
+  {
+    "code": "it",
+    "name": "Italiano"
+  },
+  {
+    "code": "vi",
+    "name": "Tiếng Việt"
+  },
+  {
+    "code": "nl",
+    "name": "Nederlands"
+  },
+  {
+    "code": "tr",
+    "name": "Türkçe"
+  },
+  {
+    "code": "uk",
+    "name": "Українська"
+  },
+  {
+    "code": "id",
+    "name": "Bahasa Indonesia"
+  },
+  {
+    "code": "pl",
+    "name": "Polski"
+  },
+  {
+    "code": "fa",
+    "name": "فارسی",
+    "direction": "rtl"
+  },
+  {
+    "code": "th",
+    "name": "ไทย"
+  },
+  {
+    "code": "ca",
+    "name": "Català"
+  },
+  {
+    "code": "sv",
+    "name": "Svenska"
+  }
+];
+
+export const localeMessages = {
+  "en": {
+    "meta.title": "CodexBar — every AI coding limit in your menu bar",
+    "meta.description": "A tiny macOS menu bar app that tracks AI coding-provider usage windows, credits, costs, and resets across 53 providers — Codex, OpenAI, Claude, Cursor, Gemini, Copilot, LiteLLM, and more.",
+    "meta.ogDescription": "Track usage windows, credits, and resets across 53 AI coding providers from your macOS menu bar.",
+    "nav.primary": "Primary",
+    "nav.language": "Language",
+    "nav.docs": "Docs",
+    "nav.source": "Source",
+    "nav.download": "Download",
+    "theme.toLight": "Switch to light theme",
+    "theme.toDark": "Switch to dark theme",
+    "hero.prefix": "Every AI coding limit,",
+    "hero.accent": "in your menu bar.",
+    "hero.description": "CodexBar tracks usage windows, credit balances, and reset countdowns across the providers you actually pay for — one status item each, or merge them into one.",
+    "hero.download": "Download for macOS",
+    "hero.fineprint": "Free & open source · macOS 14+ · Universal via GitHub Releases and Homebrew",
+    "providers.title": "53 providers, one menu bar",
+    "providers.description": "Popular providers become status items with their own usage windows, reset countdowns, charts, and provider menus.",
+    "providers.yourProvider": "Your provider",
+    "providers.authoringGuide": "Authoring guide",
+    "auth.cookies": "Cookies",
+    "auth.cookiesGo": "Cookies + Go",
+    "auth.deviceFlow": "Device flow",
+    "auth.bearerLocal": "Bearer / Local",
+    "auth.apiKey": "API key",
+    "auth.token": "Token",
+    "auth.legacyApi": "Legacy API",
+    "auth.local": "Local",
+    "auth.apiKeyCookies": "API key + Cookies",
+    "auth.virtualKey": "Virtual key",
+    "showcase.alt": "CodexBar menu bar popover showing provider tiles with usage bars, reset countdowns, and credit details.",
+    "features.resetsTitle": "Resets you can plan around",
+    "features.resetsBody": "Per-provider session, weekly, and monthly windows with countdowns to the next reset — no more guessing whether to start a long task.",
+    "features.spendTitle": "Credits, spend, and cost scans",
+    "features.spendBody": "Credit balances and monthly spend where the provider exposes them, plus configurable local cost scans for Codex and Claude.",
+    "features.statusTitle": "Status & incidents",
+    "features.statusBody": "Provider status polling surfaces incident badges in the menu and an indicator overlay on the bar icon.",
+    "features.cliTitle": "CLI & widgets",
+    "features.cliBody": "WidgetKit widgets for supported providers and a bundled {codexbar} CLI for scripts and CI — macOS and Linux builds on every release.",
+    "detail.installTitle": "Install & updates",
+    "detail.installBody": "Universal app via {releases} with Sparkle auto-updates, or via {cask} (updates via {upgrade}).",
+    "detail.cliTitle": "CLI",
+    "detail.cliBody": "A bundled {codexbar} binary plus standalone tarballs for macOS and Linux on each release. On Linux: {linuxCommand}.",
+    "detail.privacyTitle": "Privacy",
+    "detail.privacyBody": "Reuses existing provider sessions — OAuth, device flow, API keys, browser cookies, local files — so no passwords are stored. Audit notes in {issue}.",
+    "detail.permissionsTitle": "macOS permissions",
+    "detail.permissionsBody": "Full Disk Access for Safari cookies, Keychain access for cookie decryption and OAuth flows, and Files & Folders prompts when provider helpers read project directories.",
+    "footer.builtBy": "Built by",
+    "footer.changelog": "Changelog",
+    "clipboard.copy": "Copy to clipboard",
+    "clipboard.copied": "Copied"
+  },
+  "zh-CN": {
+    "meta.title": "CodexBar — 菜单栏中的每个 AI 编码限制",
+    "meta.description": "一个微小的 macOS 菜单栏应用程序，可跟踪 53 个提供商（Codex、OpenAI、Claude、Cursor、Gemini、Copilot、LiteLLM 等）的 AI 编码提供商使用窗口、积分、成本和重置。",
+    "meta.ogDescription": "从您的 macOS 菜单栏跟踪 53 个 AI 编码提供商的使用窗口、积分和重置。",
+    "nav.primary": "基本的",
+    "nav.language": "语言",
+    "nav.docs": "文档",
+    "nav.source": "来源",
+    "nav.download": "下载",
+    "theme.toLight": "切换到浅色主题",
+    "theme.toDark": "切换到深色主题",
+    "hero.prefix": "每个AI编码限制，",
+    "hero.accent": "在你的菜单栏中。",
+    "hero.description": "CodexBar 跟踪您实际付费的提供商的使用窗口、信用余额和重置倒计时 - 每个状态项一项，或将它们合并为一项。",
+    "hero.download": "下载macOS",
+    "hero.fineprint": "免费开源 · macOS 14+ · GitHub Releases 和 Homebrew 均提供通用版本",
+    "providers.title": "53 个提供商，一个菜单栏",
+    "providers.description": "受欢迎的提供商成为状态项目，具有自己的使用窗口、重置倒计时、图表和提供商菜单。",
+    "providers.yourProvider": "您的提供商",
+    "providers.authoringGuide": "创作指南",
+    "auth.cookies": "Cookies",
+    "auth.cookiesGo": "Cookies + Go",
+    "auth.deviceFlow": "Device flow",
+    "auth.bearerLocal": "Bearer / Local",
+    "auth.apiKey": "API key",
+    "auth.token": "Token",
+    "auth.legacyApi": "Legacy API",
+    "auth.local": "Local",
+    "auth.apiKeyCookies": "API key + Cookies",
+    "auth.virtualKey": "Virtual key",
+    "showcase.alt": "CodexBar 菜单栏弹出窗口显示提供商图块，其中包含使用栏、重置倒计时和信用详细信息。",
+    "features.resetsTitle": "您可以计划重置",
+    "features.resetsBody": "每个提供商的会话、每周和每月窗口，以及下一次重置的倒计时 - 不再猜测是否开始一项长期任务。",
+    "features.spendTitle": "积分、支出和成本扫描",
+    "features.spendBody": "提供商公开的信用余额和每月支出，以及 Codex 和 Claude 的可配置本地成本扫描。",
+    "features.statusTitle": "状态和事件",
+    "features.statusBody": "提供商状态轮询会在菜单中显示事件徽章，并在栏图标上覆盖一个指示器。",
+    "features.cliTitle": "CLI 和小部件",
+    "features.cliBody": "用于支持的提供程序的 WidgetKit 小部件以及用于脚本的捆绑 {codexbar} CLI 和 CI - macOS 和 Linux 构建在每个版本上。",
+    "detail.installTitle": "安装和更新",
+    "detail.installBody": "通过 {releases} 获取支持 Sparkle 自动更新的通用应用，或通过 {cask} 安装（使用 {upgrade} 更新）。",
+    "detail.cliTitle": "CLI",
+    "detail.cliBody": "每个版本的 {codexbar} 二进制文件以及 macOS 和 Linux 的独立 tarball。在 Linux 上：{linuxCommand}。",
+    "detail.privacyTitle": "隐私",
+    "detail.privacyBody": "重用现有的提供程序会话 - OAuth、设备流、API 密钥、浏览器 cookie、本地文件 - 因此不存储密码。 {issue} 中的审计注释。",
+    "detail.permissionsTitle": "macOS 权限",
+    "detail.permissionsBody": "Safari cookie 的完整磁盘访问权限、Cookie 解密和 OAuth 流的 Keychain 访问权限以及提供程序帮助程序读取项目目录时的文件和文件夹提示。",
+    "footer.builtBy": "建造者",
+    "footer.changelog": "变更日志",
+    "clipboard.copy": "复制到剪贴板",
+    "clipboard.copied": "已复制"
+  },
+  "zh-TW": {
+    "meta.title": "CodexBar — 功能表列中的每個 AI 編碼限制",
+    "meta.description": "一個微小的 macOS 功能表列應用程序，可追蹤 53 個提供者（Codex、OpenAI、Claude、Cursor、Gemini、Copilot、LiteLLM 等）的 AI 編碼提供者使用視窗、積分、成本和重設。",
+    "meta.ogDescription": "從您的 macOS 功能表列追蹤 53 個 AI 編碼提供者的使用視窗、積分和重設。",
+    "nav.primary": "基本的",
+    "nav.language": "語言",
+    "nav.docs": "文件",
+    "nav.source": "來源",
+    "nav.download": "下載",
+    "theme.toLight": "切換到淺色主題",
+    "theme.toDark": "切換到深色主題",
+    "hero.prefix": "每個AI編碼限制，",
+    "hero.accent": "在你的選單列中。",
+    "hero.description": "CodexBar 追蹤您實際付費的提供者的使用視窗、信用餘額和重設倒數計時 - 每個狀態項一項，或將它們合併為一項。",
+    "hero.download": "下載macOS",
+    "hero.fineprint": "免費開源 · macOS 14+ · GitHub Releases 和 Homebrew 均提供通用版本",
+    "providers.title": "53 個提供者，一個選單欄",
+    "providers.description": "受歡迎的提供者成為狀態項目，具有自己的使用視窗、重置倒數計時、圖表和提供者選單。",
+    "providers.yourProvider": "您的提供者",
+    "providers.authoringGuide": "創作指南",
+    "auth.cookies": "Cookies",
+    "auth.cookiesGo": "Cookies + Go",
+    "auth.deviceFlow": "Device flow",
+    "auth.bearerLocal": "Bearer / Local",
+    "auth.apiKey": "API key",
+    "auth.token": "Token",
+    "auth.legacyApi": "Legacy API",
+    "auth.local": "Local",
+    "auth.apiKeyCookies": "API key + Cookies",
+    "auth.virtualKey": "Virtual key",
+    "showcase.alt": "CodexBar 功能表列彈出視窗顯示提供者圖塊，其中包含使用列、重設倒數計時和信用詳細資料。",
+    "features.resetsTitle": "您可以計劃重置",
+    "features.resetsBody": "每個提供者的會話、每周和每月窗口，以及下一次重置的倒數計時 - 不再猜測是否開始一項長期任務。",
+    "features.spendTitle": "積分、支出和成本掃描",
+    "features.spendBody": "提供者公開的信用餘額和每月支出，以及 Codex 和 Claude 的可設定本地成本掃描。",
+    "features.statusTitle": "狀態和事件",
+    "features.statusBody": "提供者狀態輪詢會在選單中顯示事件徽章，並在列圖示上覆蓋一個指示器。",
+    "features.cliTitle": "CLI 和小部件",
+    "features.cliBody": "用於支援的提供者的 WidgetKit 小部件以及用於腳本的捆綁 {codexbar} CLI 和 CI - macOS 和 Linux 建構在每個版本上。",
+    "detail.installTitle": "安裝和更新",
+    "detail.installBody": "透過 {releases} 取得支援 Sparkle 自動更新的通用應用程式，或透過 {cask} 安裝（使用 {upgrade} 更新）。",
+    "detail.cliTitle": "CLI",
+    "detail.cliBody": "每個版本的 {codexbar} 二進位檔案以及 macOS 和 Linux 的獨立 tarball。在 Linux 上：{linuxCommand}。",
+    "detail.privacyTitle": "隱私",
+    "detail.privacyBody": "重複使用現有的提供者會話 - OAuth、裝置流、API 金鑰、瀏覽器 cookie、本機檔案 - 因此不儲存密碼。 {issue} 中的審計註釋。",
+    "detail.permissionsTitle": "macOS 權限",
+    "detail.permissionsBody": "Safari cookie 的完整磁碟存取權限、Cookie 解密和 OAuth 流的 Keychain 存取權限以及提供者幫助程式讀取專案目錄時的檔案和資料夾提示。",
+    "footer.builtBy": "建造者",
+    "footer.changelog": "變更日誌",
+    "clipboard.copy": "複製到剪貼簿",
+    "clipboard.copied": "已複製"
+  },
+  "ja-JP": {
+    "meta.title": "CodexBar — メニュー バーのすべての AI コーディング制限",
+    "meta.description": "小さな macOS メニュー バー アプリ。Codex、OpenAI、Claude、Cursor、Gemini、Copilot、LiteLLM など、53 のプロバイダーにわたる AI コーディング プロバイダーの使用期間、クレジット、コスト、リセットを追跡します。",
+    "meta.ogDescription": "macOS メニュー バーから、53 の AI コーディング プロバイダーにわたる使用期間、クレジット、リセットを追跡します。",
+    "nav.primary": "主要な",
+    "nav.language": "言語",
+    "nav.docs": "ドキュメント",
+    "nav.source": "ソース",
+    "nav.download": "ダウンロード",
+    "theme.toLight": "ライトテーマに切り替える",
+    "theme.toDark": "ダークテーマに切り替える",
+    "hero.prefix": "AI コーディングのあらゆる制限、",
+    "hero.accent": "メニューバーにあります。",
+    "hero.description": "CodexBar は、実際に料金を支払っているプロバイダー全体の使用期間、クレジット残高、リセット カウントダウンを追跡します。ステータス項目を 1 つずつ、または 1 つに統合します。",
+    "hero.download": "macOS のダウンロード",
+    "hero.fineprint": "無料・オープンソース · macOS 14+ · GitHub Releases と Homebrew でユニバーサル版を提供",
+    "providers.title": "53 プロバイダー、1 つのメニュー バー",
+    "providers.description": "人気のあるプロバイダーは、独自の使用期間、リセット カウントダウン、グラフ、プロバイダー メニューを備えたステータス アイテムになります。",
+    "providers.yourProvider": "あなたのプロバイダー",
+    "providers.authoringGuide": "オーサリングガイド",
+    "auth.cookies": "Cookies",
+    "auth.cookiesGo": "Cookies + Go",
+    "auth.deviceFlow": "Device flow",
+    "auth.bearerLocal": "Bearer / Local",
+    "auth.apiKey": "API key",
+    "auth.token": "Token",
+    "auth.legacyApi": "Legacy API",
+    "auth.local": "Local",
+    "auth.apiKeyCookies": "API key + Cookies",
+    "auth.virtualKey": "Virtual key",
+    "showcase.alt": "CodexBar メニュー バーのポップオーバー。使用量バー、リセット カウントダウン、クレジットの詳細を含むプロバイダー タイルが表示されます。",
+    "features.resetsTitle": "計画的にリセットできる",
+    "features.resetsBody": "プロバイダーごとのセッション、週次、月次のウィンドウに次のリセットまでのカウントダウンが表示されます。長いタスクを開始するかどうかを推測する必要はもうありません。",
+    "features.spendTitle": "クレジット、支出、コストのスキャン",
+    "features.spendBody": "プロバイダーが公開しているクレジット残高と毎月の支出に加え、Codex と Claude の構成可能なローカル コスト スキャン。",
+    "features.statusTitle": "ステータスとインシデント",
+    "features.statusBody": "プロバイダー ステータスのポーリングでは、メニューにインシデント バッジが表示され、バー アイコンにインジケーターがオーバーレイされます。",
+    "features.cliTitle": "CLI とウィジェット",
+    "features.cliBody": "サポートされているプロバイダー用の WidgetKit ウィジェットと、スクリプト用のバンドルされた {codexbar} CLI、および CI — macOS および Linux は各リリースでビルドされます。",
+    "detail.installTitle": "インストールとアップデート",
+    "detail.installBody": "Sparkle 自動更新を備えたユニバーサルアプリを {releases} から入手するか、{cask} でインストールできます（{upgrade} で更新）。",
+    "detail.cliTitle": "CLI",
+    "detail.cliBody": "各リリースのバンドルされた {codexbar} バイナリと、macOS および Linux 用のスタンドアロン tarball。 Linux: {linuxCommand}。",
+    "detail.privacyTitle": "プライバシー",
+    "detail.privacyBody": "既存のプロバイダー セッション (OAuth、デバイス フロー、API キー、ブラウザー Cookie、ローカル ファイル) を再利用するため、パスワードは保存されません。 {issue} の監査メモ。",
+    "detail.permissionsTitle": "macOS 権限",
+    "detail.permissionsBody": "Safari Cookie に対するフルディスク アクセス、Cookie 復号化と OAuth フローに対する Keychain アクセス、プロバイダー ヘルパーがプロジェクト ディレクトリを読み取るときにファイルとフォルダーのプロンプトが表示されます。",
+    "footer.builtBy": "によって建てられました",
+    "footer.changelog": "変更履歴",
+    "clipboard.copy": "クリップボードにコピー",
+    "clipboard.copied": "コピーされました"
+  },
+  "es": {
+    "meta.title": "CodexBar: cada límite de codificación de IA en tu barra de menú",
+    "meta.description": "Una pequeña aplicación de barra de menú macOS que rastrea las ventanas de uso, los créditos, los costos y los restablecimientos de los proveedores de codificación de IA en 53 proveedores: Codex, OpenAI, Claude, Cursor, Gemini, Copilot, LiteLLM y más.",
+    "meta.ogDescription": "Realice un seguimiento de las ventanas de uso, los créditos y los restablecimientos en 53 proveedores de codificación de IA desde su barra de menú macOS.",
+    "nav.primary": "Primario",
+    "nav.language": "Idioma",
+    "nav.docs": "Documentos",
+    "nav.source": "Fuente",
+    "nav.download": "Descargar",
+    "theme.toLight": "Cambiar al tema claro",
+    "theme.toDark": "Cambiar al tema oscuro",
+    "hero.prefix": "Cada límite de codificación de IA,",
+    "hero.accent": "en su barra de menú.",
+    "hero.description": "CodexBar realiza un seguimiento de los períodos de uso, los saldos de crédito y restablece las cuentas regresivas de los proveedores por los que realmente paga: un elemento de estado para cada uno o los fusiona en uno solo.",
+    "hero.download": "Descargar para macOS",
+    "hero.fineprint": "Gratis y de código abierto · macOS 14+ · Universal mediante GitHub Releases y Homebrew",
+    "providers.title": "53 proveedores, una barra de menú",
+    "providers.description": "Los proveedores populares se convierten en elementos de estado con sus propias ventanas de uso, restablecen cuentas regresivas, gráficos y menús de proveedores.",
+    "providers.yourProvider": "Tu proveedor",
+    "providers.authoringGuide": "guía de autoría",
+    "auth.cookies": "Cookies",
+    "auth.cookiesGo": "Cookies + Go",
+    "auth.deviceFlow": "Device flow",
+    "auth.bearerLocal": "Bearer / Local",
+    "auth.apiKey": "API key",
+    "auth.token": "Token",
+    "auth.legacyApi": "Legacy API",
+    "auth.local": "Local",
+    "auth.apiKeyCookies": "API key + Cookies",
+    "auth.virtualKey": "Virtual key",
+    "showcase.alt": "Ventana emergente de la barra de menú CodexBar que muestra mosaicos de proveedores con barras de uso, restablecimiento de cuentas regresivas y detalles de crédito.",
+    "features.resetsTitle": "Restablecimientos que puedes planificar",
+    "features.resetsBody": "Sesión por proveedor, períodos semanales y mensuales con cuentas regresivas para el siguiente reinicio: ya no tendrá que adivinar si iniciar una tarea larga.",
+    "features.spendTitle": "Escaneos de créditos, gastos y costos",
+    "features.spendBody": "Saldos de crédito y gastos mensuales donde el proveedor los expone, además de escaneos de costos locales configurables para Codex y Claude.",
+    "features.statusTitle": "Estado e incidencias",
+    "features.statusBody": "El sondeo del estado del proveedor muestra insignias de incidentes en el menú y un indicador superpuesto en el ícono de la barra.",
+    "features.cliTitle": "CLI y widgets",
+    "features.cliBody": "Widgets WidgetKit para proveedores compatibles y {codexbar} CLI incluido para scripts y CI: macOS y Linux compilaciones en cada versión.",
+    "detail.installTitle": "Instalar y actualizar",
+    "detail.installBody": "Aplicación universal mediante {releases} con actualizaciones automáticas de Sparkle, o mediante {cask} (actualizaciones con {upgrade}).",
+    "detail.cliTitle": "CLI",
+    "detail.cliBody": "Un paquete binario {codexbar} más archivos comprimidos independientes para macOS y Linux en cada versión. En Linux: {linuxCommand}.",
+    "detail.privacyTitle": "Privacidad",
+    "detail.privacyBody": "Reutiliza sesiones de proveedores existentes (OAuth, flujo de dispositivos, claves API, cookies del navegador, archivos locales) para que no se almacenen contraseñas. Notas de auditoría en {issue}.",
+    "detail.permissionsTitle": "permisos macOS",
+    "detail.permissionsBody": "Acceso total al disco para cookies Safari, acceso Keychain para descifrado de cookies y flujos OAuth, y avisos de Archivos y carpetas cuando los ayudantes del proveedor leen los directorios del proyecto.",
+    "footer.builtBy": "Construido por",
+    "footer.changelog": "Registro de cambios",
+    "clipboard.copy": "Copiar al portapapeles",
+    "clipboard.copied": "Copiado"
+  },
+  "pt-BR": {
+    "meta.title": "CodexBar — todos os limites de codificação de IA na sua barra de menu",
+    "meta.description": "Um pequeno aplicativo de barra de menu macOS que rastreia janelas de uso, créditos, custos e redefinições do provedor de codificação de IA em 53 provedores — Codex, OpenAI, Claude, Cursor, Gemini, Copilot, LiteLLM e muito mais.",
+    "meta.ogDescription": "Rastreie janelas de uso, créditos e redefinições em 53 provedores de codificação de IA na barra de menu macOS.",
+    "nav.primary": "Primário",
+    "nav.language": "Linguagem",
+    "nav.docs": "Documentos",
+    "nav.source": "Fonte",
+    "nav.download": "Download",
+    "theme.toLight": "Mudar para tema claro",
+    "theme.toDark": "Mudar para tema escuro",
+    "hero.prefix": "Cada limite de codificação de IA,",
+    "hero.accent": "na sua barra de menu.",
+    "hero.description": "CodexBar rastreia janelas de uso, saldos de crédito e reinicia contagens regressivas nos provedores pelos quais você realmente paga - um item de status cada, ou mescla-os em um.",
+    "hero.download": "Baixar para macOS",
+    "hero.fineprint": "Gratuito e de código aberto · macOS 14+ · Universal via GitHub Releases e Homebrew",
+    "providers.title": "53 provedores, uma barra de menu",
+    "providers.description": "Provedores populares tornam-se itens de status com suas próprias janelas de uso, reiniciam contagens regressivas, gráficos e menus de provedores.",
+    "providers.yourProvider": "Seu provedor",
+    "providers.authoringGuide": "Guia de autoria",
+    "auth.cookies": "Cookies",
+    "auth.cookiesGo": "Cookies + Go",
+    "auth.deviceFlow": "Device flow",
+    "auth.bearerLocal": "Bearer / Local",
+    "auth.apiKey": "API key",
+    "auth.token": "Token",
+    "auth.legacyApi": "Legacy API",
+    "auth.local": "Local",
+    "auth.apiKeyCookies": "API key + Cookies",
+    "auth.virtualKey": "Virtual key",
+    "showcase.alt": "Popover da barra de menu CodexBar mostrando blocos de provedores com barras de uso, contagens regressivas de redefinição e detalhes de crédito.",
+    "features.resetsTitle": "Redefinições que você pode planejar",
+    "features.resetsBody": "Sessão por provedor, janelas semanais e mensais com contagem regressiva para a próxima redefinição — chega de ficar adivinhando se deve iniciar uma tarefa longa.",
+    "features.spendTitle": "Créditos, gastos e verificações de custos",
+    "features.spendBody": "Saldos de crédito e gastos mensais onde o provedor os expõe, além de verificações de custos locais configuráveis ​​para Codex e Claude.",
+    "features.statusTitle": "Status e incidentes",
+    "features.statusBody": "A pesquisa de status do provedor apresenta emblemas de incidentes no menu e uma sobreposição de indicador no ícone da barra.",
+    "features.cliTitle": "CLI e widgets",
+    "features.cliBody": "Widgets WidgetKit para provedores suportados e um pacote {codexbar} CLI para scripts e compilações CI — macOS e Linux em cada versão.",
+    "detail.installTitle": "Instalar e atualizações",
+    "detail.installBody": "Aplicativo universal via {releases} com atualizações automáticas do Sparkle ou via {cask} (atualizações com {upgrade}).",
+    "detail.cliTitle": "CLI",
+    "detail.cliBody": "Um pacote binário {codexbar} mais tarballs independentes para macOS e Linux em cada versão. Em Linux: {linuxCommand}.",
+    "detail.privacyTitle": "Privacidade",
+    "detail.privacyBody": "Reutiliza sessões existentes do provedor — OAuth, fluxo do dispositivo, chaves API, cookies do navegador, arquivos locais — para que nenhuma senha seja armazenada. Notas de auditoria em {issue}.",
+    "detail.permissionsTitle": "macOS permissões",
+    "detail.permissionsBody": "Acesso total ao disco para cookies Safari, acesso Keychain para descriptografia de cookies e fluxos OAuth e prompts de arquivos e pastas quando ajudantes do provedor leem diretórios de projetos.",
+    "footer.builtBy": "Construído por",
+    "footer.changelog": "Registro de alterações",
+    "clipboard.copy": "Copiar para a área de transferência",
+    "clipboard.copied": "Copiado"
+  },
+  "ko": {
+    "meta.title": "CodexBar — 메뉴 표시줄의 모든 AI 코딩 제한",
+    "meta.description": "Codex, OpenAI, Claude, Cursor, Gemini, Copilot, LiteLLM 등 53개 제공자 전체에서 AI 코딩 제공자 사용 창, 크레딧, 비용 및 재설정을 추적하는 작은 macOS 메뉴 표시줄 앱입니다.",
+    "meta.ogDescription": "macOS 메뉴 표시줄에서 53개 AI 코딩 제공업체의 사용 기간, 크레딧 및 재설정을 추적하세요.",
+    "nav.primary": "주요한",
+    "nav.language": "언어",
+    "nav.docs": "문서",
+    "nav.source": "원천",
+    "nav.download": "다운로드",
+    "theme.toLight": "밝은 테마로 전환",
+    "theme.toDark": "어두운 테마로 전환",
+    "hero.prefix": "모든 AI 코딩의 한계,",
+    "hero.accent": "메뉴 표시줄에",
+    "hero.description": "CodexBar는 귀하가 실제로 비용을 지불한 제공업체 전반에 걸쳐 사용 기간, 크레딧 잔액 및 재설정 카운트다운을 추적합니다. 즉, 각각 하나의 상태 항목 또는 하나로 병합됩니다.",
+    "hero.download": "macOS 동안 다운로드",
+    "hero.fineprint": "무료 오픈 소스 · macOS 14+ · GitHub Releases와 Homebrew에서 유니버설 제공",
+    "providers.title": "공급자 53개, 메뉴 표시줄 1개",
+    "providers.description": "인기 있는 제공업체는 자체 사용 창, 재설정 카운트다운, 차트 및 제공업체 메뉴를 갖춘 상태 항목이 됩니다.",
+    "providers.yourProvider": "귀하의 제공자",
+    "providers.authoringGuide": "저작 가이드",
+    "auth.cookies": "Cookies",
+    "auth.cookiesGo": "Cookies + Go",
+    "auth.deviceFlow": "Device flow",
+    "auth.bearerLocal": "Bearer / Local",
+    "auth.apiKey": "API key",
+    "auth.token": "Token",
+    "auth.legacyApi": "Legacy API",
+    "auth.local": "Local",
+    "auth.apiKeyCookies": "API key + Cookies",
+    "auth.virtualKey": "Virtual key",
+    "showcase.alt": "CodexBar 사용량 표시줄, 재설정 카운트다운 및 신용 세부정보가 포함된 제공업체 타일을 표시하는 메뉴 표시줄 팝오버입니다.",
+    "features.resetsTitle": "계획할 수 있는 재설정",
+    "features.resetsBody": "다음 재설정까지 카운트다운이 가능한 공급자별 세션, 주간 및 월간 기간으로 더 이상 긴 작업을 시작할지 여부를 추측할 필요가 없습니다.",
+    "features.spendTitle": "크레딧, 지출, 비용 스캔",
+    "features.spendBody": "공급자가 노출하는 신용 ​​잔액 및 월별 지출과 Codex 및 Claude에 대한 구성 가능한 지역 비용 스캔.",
+    "features.statusTitle": "현황 및 사건",
+    "features.statusBody": "공급자 상태 폴링은 메뉴에 사건 배지를 표시하고 막대 아이콘에 표시기 오버레이를 표시합니다.",
+    "features.cliTitle": "CLI 및 위젯",
+    "features.cliBody": "지원되는 공급자를 위한 WidgetKit 위젯과 스크립트 및 CI용 번들 {codexbar} CLI — macOS 및 Linux는 모든 릴리스에서 빌드됩니다.",
+    "detail.installTitle": "설치 및 업데이트",
+    "detail.installBody": "Sparkle 자동 업데이트가 포함된 유니버설 앱은 {releases}에서, 또는 {cask}로 설치할 수 있습니다({upgrade}로 업데이트).",
+    "detail.cliTitle": "CLI",
+    "detail.cliBody": "각 릴리스의 macOS 및 Linux에 대한 번들 {codexbar} 바이너리와 독립 실행형 tarball입니다. Linux에: {linuxCommand}.",
+    "detail.privacyTitle": "은둔",
+    "detail.privacyBody": "기존 공급자 세션(OAuth, 장치 흐름, API 키, 브라우저 쿠키, 로컬 파일)을 재사용하므로 비밀번호가 저장되지 않습니다. {issue}의 감사 메모입니다.",
+    "detail.permissionsTitle": "macOS 권한",
+    "detail.permissionsBody": "Safari 쿠키에 대한 전체 디스크 액세스, 쿠키 암호 해독 및 OAuth 흐름에 대한 Keychain 액세스, 공급자 도우미가 프로젝트 디렉터리를 읽을 때 파일 및 폴더 메시지가 표시됩니다.",
+    "footer.builtBy": "제작사",
+    "footer.changelog": "변경 내역",
+    "clipboard.copy": "클립보드에 복사",
+    "clipboard.copied": "복사됨"
+  },
+  "de": {
+    "meta.title": "CodexBar – alle Limits Ihrer KI-Coding-Tools in der Menüleiste",
+    "meta.description": "Eine kleine macOS-Menüleisten-App, die Nutzungslimits, Guthaben, Kosten und Resets von 53 KI-Coding-Anbietern im Blick behält – Codex, OpenAI, Claude, Cursor, Gemini, Copilot, LiteLLM und mehr.",
+    "meta.ogDescription": "Nutzungslimits, Guthaben und Resets von 53 KI-Coding-Anbietern direkt in Ihrer macOS-Menüleiste.",
+    "nav.primary": "Primär",
+    "nav.language": "Sprache",
+    "nav.docs": "Dokumente",
+    "nav.source": "Quelle",
+    "nav.download": "Herunterladen",
+    "theme.toLight": "Wechseln Sie zum Lichtthema",
+    "theme.toDark": "Wechseln Sie zum dunklen Thema",
+    "hero.prefix": "Alle Limits Ihrer KI-Coding-Tools –",
+    "hero.accent": "direkt in Ihrer Menüleiste.",
+    "hero.description": "CodexBar verfolgt Nutzungsfenster, Guthaben und Reset-Countdowns bei den Anbietern, für die Sie tatsächlich bezahlen – jeweils ein Statuselement oder sie werden zu einem zusammengeführt.",
+    "hero.download": "Herunterladen für macOS",
+    "hero.fineprint": "Kostenlos und Open Source · macOS 14+ · Universal über GitHub Releases und Homebrew",
+    "providers.title": "53 Anbieter, eine Menüleiste",
+    "providers.description": "Beliebte Anbieter werden zu Statuselementen mit eigenen Nutzungsfenstern, Reset-Countdowns, Diagrammen und Anbietermenüs.",
+    "providers.yourProvider": "Ihr Anbieter",
+    "providers.authoringGuide": "Autorenleitfaden",
+    "auth.cookies": "Cookies",
+    "auth.cookiesGo": "Cookies + Go",
+    "auth.deviceFlow": "Device flow",
+    "auth.bearerLocal": "Bearer / Local",
+    "auth.apiKey": "API key",
+    "auth.token": "Token",
+    "auth.legacyApi": "Legacy API",
+    "auth.local": "Local",
+    "auth.apiKeyCookies": "API key + Cookies",
+    "auth.virtualKey": "Virtual key",
+    "showcase.alt": "CodexBar-Menüleisten-Popover mit Anbieterkacheln mit Nutzungsbalken, Reset-Countdowns und Kreditdetails.",
+    "features.resetsTitle": "Resets, die Sie planen können",
+    "features.resetsBody": "Sitzung pro Anbieter, wöchentliche und monatliche Fenster mit Countdowns bis zum nächsten Zurücksetzen – kein Raten mehr, ob eine lange Aufgabe gestartet werden soll.",
+    "features.spendTitle": "Gutschriften-, Ausgaben- und Kostenscans",
+    "features.spendBody": "Guthaben und monatliche Ausgaben dort, wo der Anbieter sie offenlegt, plus konfigurierbare lokale Kostenscans für Codex und Claude.",
+    "features.statusTitle": "Status und Vorfälle",
+    "features.statusBody": "Bei der Abfrage des Anbieterstatus werden Vorfall-Badges im Menü und ein Indikator-Overlay auf dem Balkensymbol angezeigt.",
+    "features.cliTitle": "CLI und Widgets",
+    "features.cliBody": "WidgetKit-Widgets für unterstützte Anbieter und eine gebündelte {codexbar} CLI für Skripte und CI – macOS und Linux bauen auf jeder Version auf.",
+    "detail.installTitle": "Installieren und aktualisieren",
+    "detail.installBody": "Universelle App über {releases} mit automatischen Sparkle-Updates oder über {cask} (Updates mit {upgrade}).",
+    "detail.cliTitle": "CLI",
+    "detail.cliBody": "Eine gebündelte {codexbar}-Binärdatei plus eigenständige Tarballs für macOS und Linux in jeder Version. Auf Linux: {linuxCommand}.",
+    "detail.privacyTitle": "Privatsphäre",
+    "detail.privacyBody": "Verwendet vorhandene Anbietersitzungen – OAuth, Gerätefluss, API-Schlüssel, Browser-Cookies, lokale Dateien – wieder, sodass keine Passwörter gespeichert werden. Prüfnotizen in {issue}.",
+    "detail.permissionsTitle": "macOS-Berechtigungen",
+    "detail.permissionsBody": "Vollständiger Festplattenzugriff für Safari-Cookies, Keychain-Zugriff für Cookie-Entschlüsselung und OAuth-Abläufe sowie Eingabeaufforderungen für Dateien und Ordner, wenn Anbieterhelfer Projektverzeichnisse lesen.",
+    "footer.builtBy": "Gebaut von",
+    "footer.changelog": "Änderungsprotokoll",
+    "clipboard.copy": "In die Zwischenablage kopieren",
+    "clipboard.copied": "Kopiert"
+  },
+  "fr": {
+    "meta.title": "CodexBar — chaque limite de codage IA dans votre barre de menus",
+    "meta.description": "Une petite application de barre de menus macOS qui suit les fenêtres d'utilisation, les crédits, les coûts et les réinitialisations des fournisseurs de codage d'IA sur 53 fournisseurs : Codex, OpenAI, Claude, Cursor, Gemini, Copilot, LiteLLM, et plus encore.",
+    "meta.ogDescription": "Suivez les fenêtres d'utilisation, les crédits et les réinitialisations auprès de 53 fournisseurs de codage d'IA à partir de votre barre de menus macOS.",
+    "nav.primary": "Primaire",
+    "nav.language": "Langue",
+    "nav.docs": "Documents",
+    "nav.source": "Source",
+    "nav.download": "Télécharger",
+    "theme.toLight": "Passer au thème clair",
+    "theme.toDark": "Passer au thème sombre",
+    "hero.prefix": "Chaque limite de codage AI,",
+    "hero.accent": "dans votre barre de menu.",
+    "hero.description": "CodexBar suit les fenêtres d'utilisation, les soldes créditeurs et réinitialise les comptes à rebours pour les fournisseurs pour lesquels vous payez réellement - un élément de statut chacun, ou les fusionne en un seul.",
+    "hero.download": "Télécharger pour macOS",
+    "hero.fineprint": "Gratuit et open source · macOS 14+ · Universel via GitHub Releases et Homebrew",
+    "providers.title": "53 fournisseurs, une barre de menu",
+    "providers.description": "Les fournisseurs populaires deviennent des éléments de statut avec leurs propres fenêtres d'utilisation, réinitialisent les comptes à rebours, les graphiques et les menus des fournisseurs.",
+    "providers.yourProvider": "Votre fournisseur",
+    "providers.authoringGuide": "Guide de création",
+    "auth.cookies": "Cookies",
+    "auth.cookiesGo": "Cookies + Go",
+    "auth.deviceFlow": "Device flow",
+    "auth.bearerLocal": "Bearer / Local",
+    "auth.apiKey": "API key",
+    "auth.token": "Token",
+    "auth.legacyApi": "Legacy API",
+    "auth.local": "Local",
+    "auth.apiKeyCookies": "API key + Cookies",
+    "auth.virtualKey": "Virtual key",
+    "showcase.alt": "Fenêtre contextuelle de la barre de menu CodexBar affichant les vignettes du fournisseur avec des barres d'utilisation, des comptes à rebours de réinitialisation et des détails de crédit.",
+    "features.resetsTitle": "Des réinitialisations que vous pouvez planifier",
+    "features.resetsBody": "Session par fournisseur, fenêtres hebdomadaires et mensuelles avec comptes à rebours jusqu'à la prochaine réinitialisation : plus besoin de deviner s'il faut démarrer une longue tâche.",
+    "features.spendTitle": "Analyses des crédits, des dépenses et des coûts",
+    "features.spendBody": "Soldes créditeurs et dépenses mensuelles là où le fournisseur les expose, ainsi que des analyses de coûts locales configurables pour Codex et Claude.",
+    "features.statusTitle": "Statut et incidents",
+    "features.statusBody": "L'interrogation de l'état du fournisseur fait apparaître des badges d'incident dans le menu et un indicateur superposé sur l'icône de la barre.",
+    "features.cliTitle": "CLI et widgets",
+    "features.cliBody": "Des widgets WidgetKit pour les fournisseurs pris en charge et un {codexbar} CLI fourni pour les scripts et CI — macOS et Linux s'appuient sur chaque version.",
+    "detail.installTitle": "Installation et mises à jour",
+    "detail.installBody": "Application universelle via {releases} avec mises à jour automatiques Sparkle, ou via {cask} (mises à jour avec {upgrade}).",
+    "detail.cliTitle": "CLI",
+    "detail.cliBody": "Un binaire {codexbar} fourni ainsi que des archives tar autonomes pour macOS et Linux sur chaque version. Sur Linux : {linuxCommand}.",
+    "detail.privacyTitle": "Confidentialité",
+    "detail.privacyBody": "Réutilise les sessions du fournisseur existantes (OAuth, flux de périphérique, clés API, cookies du navigateur, fichiers locaux) afin qu'aucun mot de passe ne soit stocké. Notes d'audit dans {issue}.",
+    "detail.permissionsTitle": "autorisations macOS",
+    "detail.permissionsBody": "Accès complet au disque pour les cookies Safari, accès Keychain pour le décryptage des cookies et les flux OAuth, et fichiers et dossiers vous invitent lorsque les assistants du fournisseur lisent les répertoires du projet.",
+    "footer.builtBy": "Construit par",
+    "footer.changelog": "Journal des modifications",
+    "clipboard.copy": "Copier dans le presse-papier",
+    "clipboard.copied": "Copié"
+  },
+  "ar": {
+    "meta.title": "CodexBar — كل حد لترميز الذكاء الاصطناعي في شريط القائمة",
+    "meta.description": "تطبيق شريط قوائم macOS صغير الحجم يتتبع نوافذ استخدام موفر ترميز الذكاء الاصطناعي، والائتمانات، والتكاليف، وعمليات إعادة التعيين عبر 53 موفرًا - Codex، وOpenAI، وClaude، وCursor، وGemini، وCopilot، وLiteLLM، والمزيد.",
+    "meta.ogDescription": "تتبع نوافذ الاستخدام والأرصدة وعمليات إعادة التعيين عبر 53 موفرًا لترميز الذكاء الاصطناعي من شريط القائمة macOS.",
+    "nav.primary": "أساسي",
+    "nav.language": "لغة",
+    "nav.docs": "المستندات",
+    "nav.source": "مصدر",
+    "nav.download": "تحميل",
+    "theme.toLight": "التبديل إلى موضوع الضوء",
+    "theme.toDark": "التبديل إلى المظهر الداكن",
+    "hero.prefix": "كل حدود ترميز الذكاء الاصطناعي،",
+    "hero.accent": "في شريط القائمة الخاص بك.",
+    "hero.description": "يتتبع CodexBar فترات الاستخدام والأرصدة الائتمانية وإعادة تعيين العد التنازلي عبر مقدمي الخدمة الذين تدفع مقابلهم فعليًا — عنصر حالة واحد لكل منهم، أو دمجهم في عنصر واحد.",
+    "hero.download": "التنزيل لمدة macOS",
+    "hero.fineprint": "مجاني ومفتوح المصدر · macOS 14+ · إصدار شامل عبر GitHub Releases وHomebrew",
+    "providers.title": "53 مزودًا، وشريط قوائم واحد",
+    "providers.description": "يصبح الموفرون المشهورون عناصر حالة مع نوافذ الاستخدام الخاصة بهم، وعمليات إعادة تعيين العد التنازلي، والمخططات، وقوائم الموفر.",
+    "providers.yourProvider": "المزود الخاص بك",
+    "providers.authoringGuide": "دليل التأليف",
+    "auth.cookies": "Cookies",
+    "auth.cookiesGo": "Cookies + Go",
+    "auth.deviceFlow": "Device flow",
+    "auth.bearerLocal": "Bearer / Local",
+    "auth.apiKey": "API key",
+    "auth.token": "Token",
+    "auth.legacyApi": "Legacy API",
+    "auth.local": "Local",
+    "auth.apiKeyCookies": "API key + Cookies",
+    "auth.virtualKey": "Virtual key",
+    "showcase.alt": "CodexBar القائمة المنبثقة لشريط القائمة تعرض مربعات الموفر مع أشرطة الاستخدام، وعمليات إعادة التعيين التنازلية، وتفاصيل الائتمان.",
+    "features.resetsTitle": "إعادة تعيين يمكنك التخطيط حولها",
+    "features.resetsBody": "جلسة لكل مزود، ونوافذ أسبوعية وشهرية مع العد التنازلي لإعادة التعيين التالية - لم تعد هناك حاجة للتخمين بشأن بدء مهمة طويلة.",
+    "features.spendTitle": "عمليات فحص الاعتمادات والإنفاق والتكلفة",
+    "features.spendBody": "الأرصدة الدائنة والإنفاق الشهري حيث يعرضها مقدم الخدمة، بالإضافة إلى عمليات فحص التكلفة المحلية القابلة للتكوين لـ Codex وClaude.",
+    "features.statusTitle": "الحالة والحوادث",
+    "features.statusBody": "يعرض استقصاء حالة الموفر شارات الحوادث في القائمة وتراكب المؤشر على أيقونة الشريط.",
+    "features.cliTitle": "CLI والحاجيات",
+    "features.cliBody": "أدوات WidgetKit للموفرين المدعومين و{codexbar} CLI المجمعة للنصوص البرمجية وCI - يعتمد macOS وLinux على كل إصدار.",
+    "detail.installTitle": "التثبيت والتحديثات",
+    "detail.installBody": "تطبيق شامل عبر {releases} مع تحديثات تلقائية لـ Sparkle، أو عبر {cask} (التحديثات باستخدام {upgrade}).",
+    "detail.cliTitle": "CLI",
+    "detail.cliBody": "ملف ثنائي {codexbar} مجمع بالإضافة إلى كرات قطران مستقلة لـ macOS وLinux في كل إصدار. في Linux: {linuxCommand}.",
+    "detail.privacyTitle": "خصوصية",
+    "detail.privacyBody": "يعيد استخدام جلسات الموفر الحالية - OAuth، وتدفق الجهاز، ومفاتيح API، وملفات تعريف الارتباط للمتصفح، والملفات المحلية - لذلك لا يتم تخزين كلمات المرور. ملاحظات التدقيق في {issue}.",
+    "detail.permissionsTitle": "أذونات macOS.",
+    "detail.permissionsBody": "الوصول الكامل إلى القرص لملفات تعريف الارتباط Safari، والوصول Keychain لفك تشفير ملفات تعريف الارتباط وتدفقات OAuth، ومطالبة الملفات والمجلدات عندما يقرأ مساعدو الموفر أدلة المشروع.",
+    "footer.builtBy": "بنيت من قبل",
+    "footer.changelog": "سجل التغيير",
+    "clipboard.copy": "نسخ إلى الحافظة",
+    "clipboard.copied": "منقول"
+  },
+  "it": {
+    "meta.title": "CodexBar: ogni limite di codifica AI nella barra dei menu",
+    "meta.description": "Una piccola app della barra dei menu macOS che tiene traccia delle finestre di utilizzo, dei crediti, dei costi e dei ripristini del fornitore di codifica AI tra 53 fornitori: Codex, OpenAI, Claude, Cursor, Gemini, Copilot, LiteLLM e altri.",
+    "meta.ogDescription": "Tieni traccia delle finestre di utilizzo, dei crediti e dei ripristini tra 53 fornitori di codifica AI dalla barra dei menu macOS.",
+    "nav.primary": "Primario",
+    "nav.language": "Lingua",
+    "nav.docs": "Documenti",
+    "nav.source": "Fonte",
+    "nav.download": "Scaricamento",
+    "theme.toLight": "Passa al tema chiaro",
+    "theme.toDark": "Passa al tema scuro",
+    "hero.prefix": "Ogni limite di codifica AI,",
+    "hero.accent": "nella barra dei menu.",
+    "hero.description": "CodexBar tiene traccia delle finestre di utilizzo, dei saldi del credito e reimposta i conti alla rovescia tra i fornitori per cui paghi effettivamente: un elemento di stato ciascuno o uniscili in uno solo.",
+    "hero.download": "Scarica per macOS",
+    "hero.fineprint": "Gratuito e open source · macOS 14+ · Universale tramite GitHub Releases e Homebrew",
+    "providers.title": "53 fornitori, una barra dei menu",
+    "providers.description": "I fornitori più popolari diventano elementi di stato con le proprie finestre di utilizzo, reimpostano i conti alla rovescia, i grafici e i menu dei fornitori.",
+    "providers.yourProvider": "Il tuo fornitore",
+    "providers.authoringGuide": "Guida all'autore",
+    "auth.cookies": "Cookies",
+    "auth.cookiesGo": "Cookies + Go",
+    "auth.deviceFlow": "Device flow",
+    "auth.bearerLocal": "Bearer / Local",
+    "auth.apiKey": "API key",
+    "auth.token": "Token",
+    "auth.legacyApi": "Legacy API",
+    "auth.local": "Local",
+    "auth.apiKeyCookies": "API key + Cookies",
+    "auth.virtualKey": "Virtual key",
+    "showcase.alt": "Popover della barra dei menu CodexBar che mostra i riquadri del fornitore con barre di utilizzo, reimpostazione del conto alla rovescia e dettagli del credito.",
+    "features.resetsTitle": "Ripristini che puoi pianificare",
+    "features.resetsBody": "Sessione per fornitore, finestre settimanali e mensili con conto alla rovescia fino al ripristino successivo: non dovrai più indovinare se avviare un'attività lunga.",
+    "features.spendTitle": "Crediti, spesa e scansioni dei costi",
+    "features.spendBody": "Saldi dei crediti e spesa mensile laddove il fornitore li espone, oltre a scansioni dei costi locali configurabili per Codex e Claude.",
+    "features.statusTitle": "Stato e incidenti",
+    "features.statusBody": "Il sondaggio sullo stato del fornitore mostra i badge degli incidenti nel menu e un indicatore in sovrapposizione sull'icona della barra.",
+    "features.cliTitle": "CLI e widget",
+    "features.cliBody": "Widget WidgetKit per i provider supportati e un {codexbar} CLI in bundle per gli script e CI: macOS e Linux si basano su ogni versione.",
+    "detail.installTitle": "Installa e aggiorna",
+    "detail.installBody": "App universale tramite {releases} con aggiornamenti automatici di Sparkle o tramite {cask} (aggiornamenti con {upgrade}).",
+    "detail.cliTitle": "CLI",
+    "detail.cliBody": "Un pacchetto binario {codexbar} più tarball indipendenti per macOS e Linux su ogni versione. Su Linux: {linuxCommand}.",
+    "detail.privacyTitle": "Privacy",
+    "detail.privacyBody": "Riutilizza le sessioni del provider esistenti (OAuth, flusso del dispositivo, chiavi API, cookie del browser, file locali), quindi non viene memorizzata alcuna password. Note di controllo in {issue}.",
+    "detail.permissionsTitle": "macOS autorizzazioni",
+    "detail.permissionsBody": "Accesso completo al disco per cookie Safari, accesso Keychain per la decrittografia dei cookie e flussi OAuth e richieste di File e cartelle quando gli aiutanti del provider leggono le directory del progetto.",
+    "footer.builtBy": "Costruito da",
+    "footer.changelog": "Registro delle modifiche",
+    "clipboard.copy": "Copia negli appunti",
+    "clipboard.copied": "Copiato"
+  },
+  "vi": {
+    "meta.title": "CodexBar — mọi giới hạn mã hóa AI trong thanh menu của bạn",
+    "meta.description": "Một ứng dụng thanh menu macOS nhỏ theo dõi khoảng thời gian sử dụng, tín dụng, chi phí và đặt lại của nhà cung cấp mã hóa AI trên 53 nhà cung cấp — Codex, OpenAI, Claude, Cursor, Gemini, Copilot, LiteLLM, v.v.",
+    "meta.ogDescription": "Theo dõi khoảng thời gian sử dụng, tín dụng và đặt lại trên 53 nhà cung cấp mã hóa AI từ thanh menu macOS của bạn.",
+    "nav.primary": "Sơ đẳng",
+    "nav.language": "Ngôn ngữ",
+    "nav.docs": "Tài liệu",
+    "nav.source": "Nguồn",
+    "nav.download": "Tải xuống",
+    "theme.toLight": "Chuyển sang giao diện nhẹ nhàng",
+    "theme.toDark": "Chuyển sang chủ đề tối",
+    "hero.prefix": "Mọi giới hạn mã hóa AI,",
+    "hero.accent": "trong thanh menu của bạn.",
+    "hero.description": "CodexBar theo dõi khoảng thời gian sử dụng, số dư tín dụng và đếm ngược đặt lại trên các nhà cung cấp mà bạn thực sự thanh toán — mỗi mục một trạng thái hoặc hợp nhất chúng thành một.",
+    "hero.download": "Tải xuống cho macOS",
+    "hero.fineprint": "Miễn phí và nguồn mở · macOS 14+ · Bản universal qua GitHub Releases và Homebrew",
+    "providers.title": "53 nhà cung cấp, một thanh menu",
+    "providers.description": "Các nhà cung cấp phổ biến trở thành các mục trạng thái với cửa sổ sử dụng của riêng họ, đặt lại bộ đếm ngược, biểu đồ và menu nhà cung cấp.",
+    "providers.yourProvider": "Nhà cung cấp của bạn",
+    "providers.authoringGuide": "Hướng dẫn soạn thảo",
+    "auth.cookies": "Cookies",
+    "auth.cookiesGo": "Cookies + Go",
+    "auth.deviceFlow": "Device flow",
+    "auth.bearerLocal": "Bearer / Local",
+    "auth.apiKey": "API key",
+    "auth.token": "Token",
+    "auth.legacyApi": "Legacy API",
+    "auth.local": "Local",
+    "auth.apiKeyCookies": "API key + Cookies",
+    "auth.virtualKey": "Virtual key",
+    "showcase.alt": "Cửa sổ bật lên thanh menu CodexBar hiển thị các ô nhà cung cấp có thanh sử dụng, đặt lại đếm ngược và chi tiết tín dụng.",
+    "features.resetsTitle": "Đặt lại bạn có thể lập kế hoạch xung quanh",
+    "features.resetsBody": "Phiên dành cho mỗi nhà cung cấp, khoảng thời gian hàng tuần và hàng tháng có đếm ngược đến lần đặt lại tiếp theo — không cần phải đoán xem có nên bắt đầu một nhiệm vụ dài hay không.",
+    "features.spendTitle": "Tín dụng, chi tiêu và quét chi phí",
+    "features.spendBody": "Số dư tín dụng và chi tiêu hàng tháng mà nhà cung cấp hiển thị, cùng với tính năng quét chi phí địa phương có thể định cấu hình cho Codex và Claude.",
+    "features.statusTitle": "Tình trạng & sự cố",
+    "features.statusBody": "Cuộc thăm dò trạng thái nhà cung cấp hiển thị các huy hiệu sự cố trong menu và lớp phủ chỉ báo trên biểu tượng thanh.",
+    "features.cliTitle": "CLI & tiện ích",
+    "features.cliBody": "Tiện ích WidgetKit dành cho các nhà cung cấp được hỗ trợ và một gói {codexbar} CLI dành cho tập lệnh và CI — macOS và Linux được xây dựng trên mỗi bản phát hành.",
+    "detail.installTitle": "Cài đặt và cập nhật",
+    "detail.installBody": "Ứng dụng universal qua {releases} với cập nhật Sparkle tự động, hoặc qua {cask} (cập nhật bằng {upgrade}).",
+    "detail.cliTitle": "CLI",
+    "detail.cliBody": "Một gói nhị phân {codexbar} cộng với các tarball độc lập dành cho macOS và Linux trên mỗi bản phát hành. Trên Linux: {linuxCommand}.",
+    "detail.privacyTitle": "Sự riêng tư",
+    "detail.privacyBody": "Sử dụng lại các phiên nhà cung cấp hiện có — OAuth, luồng thiết bị, khóa API, cookie trình duyệt, tệp cục bộ — nên không có mật khẩu nào được lưu trữ. Ghi chú kiểm tra trong {issue}.",
+    "detail.permissionsTitle": "quyền macOS",
+    "detail.permissionsBody": "Quyền truy cập toàn bộ ổ đĩa cho cookie Safari, quyền truy cập Keychain để giải mã cookie và luồng OAuth cũng như lời nhắc về Tệp & Thư mục khi người trợ giúp nhà cung cấp đọc thư mục dự án.",
+    "footer.builtBy": "Được xây dựng bởi",
+    "footer.changelog": "Nhật ký thay đổi",
+    "clipboard.copy": "Sao chép vào bảng nhớ tạm",
+    "clipboard.copied": "Đã sao chép"
+  },
+  "nl": {
+    "meta.title": "CodexBar — elke AI-coderingslimiet in uw menubalk",
+    "meta.description": "Een kleine macOS menubalk-app die gebruiksperioden, tegoeden, kosten en resets van AI-coderingsproviders bijhoudt bij 53 providers: Codex, OpenAI, Claude, Cursor, Gemini, Copilot, LiteLLM en meer.",
+    "meta.ogDescription": "Houd gebruiksvensters, tegoeden en resets bij van 53 leveranciers van AI-codering via uw macOS-menubalk.",
+    "nav.primary": "Primair",
+    "nav.language": "Taal",
+    "nav.docs": "Documenten",
+    "nav.source": "Bron",
+    "nav.download": "Downloaden",
+    "theme.toLight": "Schakel over naar het lichtthema",
+    "theme.toDark": "Schakel over naar een donker thema",
+    "hero.prefix": "Elke AI-coderingslimiet,",
+    "hero.accent": "in uw menubalk.",
+    "hero.description": "CodexBar houdt gebruiksperioden, tegoeden en reset-countdowns bij voor de providers waarvoor u daadwerkelijk betaalt: elk één statusitem, of u kunt ze samenvoegen tot één statusitem.",
+    "hero.download": "Downloaden voor macOS",
+    "hero.fineprint": "Gratis en open source · macOS 14+ · Universeel via GitHub Releases en Homebrew",
+    "providers.title": "53 aanbieders, één menubalk",
+    "providers.description": "Populaire providers worden statusitems met hun eigen gebruiksvensters, resetcountdowns, grafieken en providermenu's.",
+    "providers.yourProvider": "Uw aanbieder",
+    "providers.authoringGuide": "Handleiding voor het schrijven",
+    "auth.cookies": "Cookies",
+    "auth.cookiesGo": "Cookies + Go",
+    "auth.deviceFlow": "Device flow",
+    "auth.bearerLocal": "Bearer / Local",
+    "auth.apiKey": "API key",
+    "auth.token": "Token",
+    "auth.legacyApi": "Legacy API",
+    "auth.local": "Local",
+    "auth.apiKeyCookies": "API key + Cookies",
+    "auth.virtualKey": "Virtual key",
+    "showcase.alt": "CodexBar menubalkpopover met providertegels met gebruiksbalken, aftellingen voor resetten en kredietgegevens.",
+    "features.resetsTitle": "Resets die u kunt plannen",
+    "features.resetsBody": "Per sessie, wekelijkse en maandelijkse vensters per provider met aftelling naar de volgende reset - u hoeft niet meer te raden of u aan een lange taak moet beginnen.",
+    "features.spendTitle": "Credits, uitgaven en kostenscans",
+    "features.spendBody": "Tegoeden en maandelijkse uitgaven waar de provider deze openbaar maakt, plus configureerbare lokale kostenscans voor Codex en Claude.",
+    "features.statusTitle": "Status & incidenten",
+    "features.statusBody": "Bij het peilen van de providerstatus worden incidentbadges in het menu en een indicator-overlay op het balkpictogram weergegeven.",
+    "features.cliTitle": "CLI en widgets",
+    "features.cliBody": "WidgetKit widgets voor ondersteunde providers en een gebundelde {codexbar} CLI voor scripts en CI — macOS en Linux bouwt voort op elke release.",
+    "detail.installTitle": "Installeren en bijwerken",
+    "detail.installBody": "Universele app via {releases} met automatische Sparkle-updates, of via {cask} (updates met {upgrade}).",
+    "detail.cliTitle": "CLI",
+    "detail.cliBody": "Een gebundeld binair {codexbar}-bestand plus zelfstandige tarballs voor macOS en Linux bij elke release. Op Linux: {linuxCommand}.",
+    "detail.privacyTitle": "Privacy",
+    "detail.privacyBody": "Hergebruik bestaande providersessies (OAuth, apparaatstroom, API-sleutels, browsercookies, lokale bestanden) zodat er geen wachtwoorden worden opgeslagen. Controlenotities in {issue}.",
+    "detail.permissionsTitle": "macOS rechten",
+    "detail.permissionsBody": "Volledige schijftoegang voor Safari-cookies, Keychain-toegang voor het decoderen van cookies en OAuth-stromen, en aanwijzingen voor Bestanden en mappen wanneer helpers van de provider projectmappen lezen.",
+    "footer.builtBy": "Gebouwd door",
+    "footer.changelog": "Wijzigingslog",
+    "clipboard.copy": "Kopiëren naar klembord",
+    "clipboard.copied": "Gekopieerd"
+  },
+  "tr": {
+    "meta.title": "CodexBar — menü çubuğunuzdaki tüm AI kodlama limitleri",
+    "meta.description": "AI kodlama sağlayıcısı kullanım pencerelerini, kredilerini, maliyetlerini izleyen ve Codex, OpenAI, Claude, Cursor, Gemini, Copilot, LiteLLM ve daha fazlası olmak üzere 53 sağlayıcı genelinde sıfırlamaları izleyen küçük bir macOS menü çubuğu uygulaması.",
+    "meta.ogDescription": "macOS menü çubuğunu kullanarak 53 AI kodlama sağlayıcısındaki kullanım pencerelerini, kredileri ve sıfırlamaları izleyin.",
+    "nav.primary": "Öncelik",
+    "nav.language": "Dil",
+    "nav.docs": "Dokümanlar",
+    "nav.source": "Kaynak",
+    "nav.download": "İndirmek",
+    "theme.toLight": "Açık temaya geç",
+    "theme.toDark": "Koyu temaya geç",
+    "hero.prefix": "Her AI kodlama sınırı,",
+    "hero.accent": "Menü çubuğunuzda.",
+    "hero.description": "CodexBar, gerçekte ödeme yaptığınız sağlayıcılar genelinde kullanım pencerelerini, kredi bakiyelerini ve geri sayımları sıfırlar (her biri bir durum öğesi olacak şekilde) izler veya bunları tek bir öğede birleştirir.",
+    "hero.download": "macOS için indirin",
+    "hero.fineprint": "Ücretsiz ve açık kaynak · macOS 14+ · GitHub Releases ve Homebrew ile evrensel sürüm",
+    "providers.title": "53 sağlayıcı, bir menü çubuğu",
+    "providers.description": "Popüler sağlayıcılar, kendi kullanım pencereleri, sıfırlama geri sayımları, çizelgeleri ve sağlayıcı menüleriyle durum öğeleri haline gelir.",
+    "providers.yourProvider": "Sağlayıcınız",
+    "providers.authoringGuide": "Yazma kılavuzu",
+    "auth.cookies": "Cookies",
+    "auth.cookiesGo": "Cookies + Go",
+    "auth.deviceFlow": "Device flow",
+    "auth.bearerLocal": "Bearer / Local",
+    "auth.apiKey": "API key",
+    "auth.token": "Token",
+    "auth.legacyApi": "Legacy API",
+    "auth.local": "Local",
+    "auth.apiKeyCookies": "API key + Cookies",
+    "auth.virtualKey": "Virtual key",
+    "showcase.alt": "Kullanım çubukları, sıfırlama geri sayımları ve kredi ayrıntılarını içeren sağlayıcı kutucuklarını gösteren CodexBar menü çubuğu açılır penceresi.",
+    "features.resetsTitle": "Planlayabileceğiniz sıfırlamalar",
+    "features.resetsBody": "Sağlayıcı başına oturum, haftalık ve aylık pencereler ile bir sonraki sıfırlama için geri sayımlar; artık uzun bir göreve başlayıp başlamayacağınızı tahmin etmenize gerek yok.",
+    "features.spendTitle": "Krediler, harcama ve maliyet taramaları",
+    "features.spendBody": "Sağlayıcının sunduğu kredi bakiyeleri ve aylık harcamaların yanı sıra Codex ve Claude için yapılandırılabilir yerel maliyet taramaları.",
+    "features.statusTitle": "Durum ve olaylar",
+    "features.statusBody": "Sağlayıcı durum anketi, menüdeki olay rozetlerini ve çubuk simgesinin üzerinde bir gösterge katmanını gösterir.",
+    "features.cliTitle": "CLI ve widget'lar",
+    "features.cliBody": "Desteklenen sağlayıcılar için WidgetKit widget'ları ve komut dosyaları için paket halinde bir {codexbar} CLI ve her sürümde CI — macOS ve Linux derlemeleri.",
+    "detail.installTitle": "Yükleme ve güncellemeler",
+    "detail.installBody": "Sparkle otomatik güncellemeli evrensel uygulamayı {releases} üzerinden veya {cask} ile kurun ({upgrade} ile güncellenir).",
+    "detail.cliTitle": "CLI",
+    "detail.cliBody": "Her sürümde macOS ve Linux için paketlenmiş bir {codexbar} ikili programı ve bağımsız tarball'lar. Linux üzerinde: {linuxCommand}.",
+    "detail.privacyTitle": "Mahremiyet",
+    "detail.privacyBody": "Mevcut sağlayıcı oturumlarını (OAuth, cihaz akışı, API anahtarları, tarayıcı çerezleri, yerel dosyalar) yeniden kullanır, böylece hiçbir şifre saklanmaz. {issue} içindeki denetim notları.",
+    "detail.permissionsTitle": "macOS izinleri",
+    "detail.permissionsBody": "Safari çerezleri için Tam Disk Erişimi, çerez şifre çözme ve OAuth akışları için Keychain erişimi ve Dosyalar ve Klasörler, sağlayıcı yardımcıları proje dizinlerini okuduğunda istemde bulunur.",
+    "footer.builtBy": "Tarafından inşa edildi",
+    "footer.changelog": "Değişiklik günlüğü",
+    "clipboard.copy": "Panoya kopyala",
+    "clipboard.copied": "Kopyalandı"
+  },
+  "uk": {
+    "meta.title": "CodexBar — кожне обмеження кодування AI у вашій панелі меню",
+    "meta.description": "Маленький додаток macOS на панелі меню, який відстежує вікна використання постачальників кодування штучного інтелекту, кредити, витрати та скидання 53 постачальників — Codex, OpenAI, Claude, Cursor, Gemini, Copilot, LiteLLM тощо.",
+    "meta.ogDescription": "Відстежуйте вікна використання, кредити та скидання 53 постачальників кодування ШІ за допомогою панелі меню macOS.",
+    "nav.primary": "Первинний",
+    "nav.language": "Мова",
+    "nav.docs": "документи",
+    "nav.source": "Джерело",
+    "nav.download": "Завантажити",
+    "theme.toLight": "Переключитися на світлу тему",
+    "theme.toDark": "Переключитися на темну тему",
+    "hero.prefix": "Кожен ліміт кодування ШІ,",
+    "hero.accent": "у панелі меню.",
+    "hero.description": "CodexBar відстежує вікна використання, кредитні баланси та скидає зворотний відлік для постачальників, за яких ви фактично платите, — по одному статусу для кожного або об’єднує їх в один.",
+    "hero.download": "Завантажити для macOS",
+    "hero.fineprint": "Безкоштовний і відкритий код · macOS 14+ · Універсальна версія через GitHub Releases і Homebrew",
+    "providers.title": "53 провайдерів, одна панель меню",
+    "providers.description": "Популярні постачальники стають елементами статусу з власними вікнами використання, скиданням зворотного відліку, діаграмами та меню постачальників.",
+    "providers.yourProvider": "Ваш провайдер",
+    "providers.authoringGuide": "Авторський посібник",
+    "auth.cookies": "Cookies",
+    "auth.cookiesGo": "Cookies + Go",
+    "auth.deviceFlow": "Device flow",
+    "auth.bearerLocal": "Bearer / Local",
+    "auth.apiKey": "API key",
+    "auth.token": "Token",
+    "auth.legacyApi": "Legacy API",
+    "auth.local": "Local",
+    "auth.apiKeyCookies": "API key + Cookies",
+    "auth.virtualKey": "Virtual key",
+    "showcase.alt": "CodexBar спливаюче вікно панелі меню, що показує плитки постачальника зі смужками використання, зворотним відліком скидання та деталями кредиту.",
+    "features.resetsTitle": "Скидання, які ви можете планувати",
+    "features.resetsBody": "Сеанси для кожного постачальника, тижневі та місячні вікна зі зворотним відліком до наступного скидання — більше не потрібно гадати, чи починати довге завдання.",
+    "features.spendTitle": "Сканування кредитів, витрат і витрат",
+    "features.spendBody": "Кредитні баланси та щомісячні витрати там, де їх показує постачальник, а також настроювані локальні сканування витрат для Codex і Claude.",
+    "features.statusTitle": "Статус та інциденти",
+    "features.statusBody": "Поверхні для опитування статусу постачальника показують значки в меню та накладення індикатора на піктограму панелі.",
+    "features.cliTitle": "CLI і віджети",
+    "features.cliBody": "Віджети WidgetKit для підтримуваних постачальників і пакет {codexbar} CLI для сценаріїв і CI — macOS і Linux будуються на кожному випуску.",
+    "detail.installTitle": "Встановлення та оновлення",
+    "detail.installBody": "Універсальний додаток через {releases} з автоматичними оновленнями Sparkle або через {cask} (оновлення за допомогою {upgrade}).",
+    "detail.cliTitle": "CLI",
+    "detail.cliBody": "Двійковий файл {codexbar} у комплекті, а також окремі архіви для macOS і Linux у кожному випуску. На Linux: {linuxCommand}.",
+    "detail.privacyTitle": "Конфіденційність",
+    "detail.privacyBody": "Повторно використовує існуючі сеанси постачальника — OAuth, потік пристрою, ключі API, файли cookie браузера, локальні файли — тому паролі не зберігаються. Аудиторські примітки в {issue}.",
+    "detail.permissionsTitle": "macOS дозволи",
+    "detail.permissionsBody": "Повний доступ до диска для файлів cookie Safari, доступ Keychain для розшифровки файлів cookie та потоків OAuth, а також підказки щодо файлів і папок, коли помічники постачальника читають каталоги проекту.",
+    "footer.builtBy": "Побудовано",
+    "footer.changelog": "Журнал змін",
+    "clipboard.copy": "Копіювати в буфер обміну",
+    "clipboard.copied": "Скопійовано"
+  },
+  "id": {
+    "meta.title": "CodexBar — setiap batas pengkodean AI di bilah menu Anda",
+    "meta.description": "Aplikasi bilah menu macOS kecil yang melacak periode penggunaan, kredit, biaya, dan penyetelan ulang penyedia pengkodean AI di 53 penyedia — Codex, OpenAI, Claude, Cursor, Gemini, Copilot, LiteLLM, dan banyak lagi.",
+    "meta.ogDescription": "Lacak jangka waktu penggunaan, kredit, dan penyetelan ulang di 53 penyedia pengkodean AI dari bilah menu macOS Anda.",
+    "nav.primary": "Utama",
+    "nav.language": "Bahasa",
+    "nav.docs": "dokumen",
+    "nav.source": "Sumber",
+    "nav.download": "Unduh",
+    "theme.toLight": "Beralih ke tema terang",
+    "theme.toDark": "Beralih ke tema gelap",
+    "hero.prefix": "Setiap batas pengkodean AI,",
+    "hero.accent": "di bilah menu Anda.",
+    "hero.description": "CodexBar melacak jangka waktu penggunaan, saldo kredit, dan hitungan mundur penyetelan ulang di seluruh penyedia yang sebenarnya Anda bayar — masing-masing satu item status, atau gabungkan menjadi satu.",
+    "hero.download": "Unduh untuk macOS",
+    "hero.fineprint": "Gratis dan sumber terbuka · macOS 14+ · Universal melalui GitHub Releases dan Homebrew",
+    "providers.title": "53 penyedia, satu bilah menu",
+    "providers.description": "Penyedia populer menjadi item status dengan jendela penggunaannya sendiri, hitung mundur pengaturan ulang, bagan, dan menu penyedia.",
+    "providers.yourProvider": "Penyedia Anda",
+    "providers.authoringGuide": "Panduan penulisan",
+    "auth.cookies": "Cookies",
+    "auth.cookiesGo": "Cookies + Go",
+    "auth.deviceFlow": "Device flow",
+    "auth.bearerLocal": "Bearer / Local",
+    "auth.apiKey": "API key",
+    "auth.token": "Token",
+    "auth.legacyApi": "Legacy API",
+    "auth.local": "Local",
+    "auth.apiKeyCookies": "API key + Cookies",
+    "auth.virtualKey": "Virtual key",
+    "showcase.alt": "CodexBar popover bilah menu menampilkan ubin penyedia dengan bilah penggunaan, hitungan mundur penyetelan ulang, dan detail kredit.",
+    "features.resetsTitle": "Penyetelan ulang dapat Anda rencanakan",
+    "features.resetsBody": "Sesi per penyedia, jendela mingguan, dan bulanan dengan hitungan mundur ke pengaturan ulang berikutnya — tidak perlu lagi menebak-nebak apakah akan memulai tugas yang panjang.",
+    "features.spendTitle": "Pemindaian kredit, pembelanjaan, dan biaya",
+    "features.spendBody": "Saldo kredit dan pembelanjaan bulanan di mana penyedia memaparkannya, ditambah pemindaian biaya lokal yang dapat dikonfigurasi untuk Codex dan Claude.",
+    "features.statusTitle": "Status & insiden",
+    "features.statusBody": "Jajak pendapat status penyedia menampilkan lencana insiden di menu dan hamparan indikator pada ikon bilah.",
+    "features.cliTitle": "CLI & widget",
+    "features.cliBody": "Widget WidgetKit untuk penyedia yang didukung dan paket {codexbar} CLI untuk skrip dan CI — macOS dan Linux dibuat pada setiap rilis.",
+    "detail.installTitle": "Instal & perbarui",
+    "detail.installBody": "Aplikasi universal melalui {releases} dengan pembaruan otomatis Sparkle, atau melalui {cask} (pembaruan dengan {upgrade}).",
+    "detail.cliTitle": "CLI",
+    "detail.cliBody": "Biner {codexbar} yang dibundel ditambah tarbal mandiri untuk macOS dan Linux pada setiap rilis. Pada Linux: {linuxCommand}.",
+    "detail.privacyTitle": "Pribadi",
+    "detail.privacyBody": "Menggunakan kembali sesi penyedia yang ada — OAuth, alur perangkat, kunci API, cookie browser, file lokal — sehingga tidak ada kata sandi yang disimpan. Catatan audit di {issue}.",
+    "detail.permissionsTitle": "izin macOS",
+    "detail.permissionsBody": "Akses Disk Penuh untuk cookie Safari, akses Keychain untuk dekripsi cookie dan alur OAuth, serta permintaan File & Folder saat pembantu penyedia membaca direktori proyek.",
+    "footer.builtBy": "Dibangun oleh",
+    "footer.changelog": "log perubahan",
+    "clipboard.copy": "Salin ke papan klip",
+    "clipboard.copied": "Disalin"
+  },
+  "pl": {
+    "meta.title": "CodexBar — każdy limit kodowania AI na pasku menu",
+    "meta.description": "Mała aplikacja z paskiem menu macOS, która śledzi okna użycia dostawcy kodowania AI, kredyty, koszty i resety u 53 dostawców — Codex, OpenAI, Claude, Cursor, Gemini, Copilot, LiteLLM i nie tylko.",
+    "meta.ogDescription": "Śledź okresy użytkowania, kredyty i resety u 53 dostawców kodowania AI za pomocą paska menu macOS.",
+    "nav.primary": "Podstawowy",
+    "nav.language": "Język",
+    "nav.docs": "Dokumenty",
+    "nav.source": "Źródło",
+    "nav.download": "Pobierać",
+    "theme.toLight": "Przełącz na jasny motyw",
+    "theme.toDark": "Przełącz na ciemny motyw",
+    "hero.prefix": "Każdy limit kodowania AI,",
+    "hero.accent": "na pasku menu.",
+    "hero.description": "CodexBar śledzi okna użytkowania, salda kredytów i resetuje odliczanie u dostawców, za których faktycznie płacisz — po jednym statusie dla każdego lub połącz je w jeden.",
+    "hero.download": "Pobierz dla macOS",
+    "hero.fineprint": "Darmowe i otwarte oprogramowanie · macOS 14+ · Wersja uniwersalna przez GitHub Releases i Homebrew",
+    "providers.title": "53 dostawców, jeden pasek menu",
+    "providers.description": "Popularni dostawcy stają się elementami statusu z własnymi oknami użytkowania, resetowaniem odliczania, wykresami i menu dostawców.",
+    "providers.yourProvider": "Twój dostawca",
+    "providers.authoringGuide": "Przewodnik autorski",
+    "auth.cookies": "Cookies",
+    "auth.cookiesGo": "Cookies + Go",
+    "auth.deviceFlow": "Device flow",
+    "auth.bearerLocal": "Bearer / Local",
+    "auth.apiKey": "API key",
+    "auth.token": "Token",
+    "auth.legacyApi": "Legacy API",
+    "auth.local": "Local",
+    "auth.apiKeyCookies": "API key + Cookies",
+    "auth.virtualKey": "Virtual key",
+    "showcase.alt": "Wyskakujący pasek menu CodexBar pokazujący kafelki dostawców z paskami użytkowania, resetowaniem odliczania i szczegółami kredytu.",
+    "features.resetsTitle": "Resety, które możesz zaplanować",
+    "features.resetsBody": "Sesja dla każdego dostawcy, okna tygodniowe i miesięczne z odliczaniem do następnego resetu — koniec z zastanawianiem się, czy rozpocząć długie zadanie.",
+    "features.spendTitle": "Skanowanie kredytów, wydatków i kosztów",
+    "features.spendBody": "Salda kredytowe i miesięczne wydatki tam, gdzie dostawca je udostępnia, a także konfigurowalne lokalne skanowanie kosztów dla Codexu i Claude.",
+    "features.statusTitle": "Stan i zdarzenia",
+    "features.statusBody": "Odpytywanie stanu dostawcy wyświetla w menu plakietki zdarzeń oraz nakładkę wskaźnika na ikonie paska.",
+    "features.cliTitle": "CLI i widżety",
+    "features.cliBody": "Widżety WidgetKit dla obsługiwanych dostawców oraz pakiet {codexbar} CLI dla skryptów i kompilacji CI — macOS i Linux w każdej wersji.",
+    "detail.installTitle": "Zainstaluj i aktualizuj",
+    "detail.installBody": "Aplikacja uniwersalna przez {releases} z automatycznymi aktualizacjami Sparkle lub przez {cask} (aktualizacje za pomocą {upgrade}).",
+    "detail.cliTitle": "CLI",
+    "detail.cliBody": "Dołączony plik binarny {codexbar} oraz samodzielne archiwum tar dla macOS i Linux w każdym wydaniu. W Linux: {linuxCommand}.",
+    "detail.privacyTitle": "Prywatność",
+    "detail.privacyBody": "Wykorzystuje ponownie istniejące sesje dostawcy — OAuth, przepływ urządzenia, klucze API, pliki cookie przeglądarki, pliki lokalne — dzięki czemu nie są przechowywane żadne hasła. Notatki z audytu w {issue}.",
+    "detail.permissionsTitle": "uprawnienia macOS",
+    "detail.permissionsBody": "Pełny dostęp do dysku dla plików cookie Safari, dostęp Keychain do odszyfrowywania plików cookie i przepływów OAuth oraz monit o pliki i foldery, gdy pomocnicy dostawcy czytają katalogi projektu.",
+    "footer.builtBy": "Zbudowany przez",
+    "footer.changelog": "Dziennik zmian",
+    "clipboard.copy": "Skopiuj do schowka",
+    "clipboard.copied": "Skopiowano"
+  },
+  "fa": {
+    "meta.title": "CodexBar - هر محدودیت کدنویسی هوش مصنوعی در نوار منو شما",
+    "meta.description": "یک برنامه نوار منو کوچک macOS که پنجره‌های استفاده از ارائه‌دهنده کدنویسی هوش مصنوعی، اعتبارات، هزینه‌ها، و بازنشانی را در بین 53 ارائه‌دهنده - Codex، OpenAI، Claude، Cursor، Gemini، Copilot، LiteLLM و موارد دیگر بازنشانی می‌کند.",
+    "meta.ogDescription": "پنجره‌های استفاده، اعتبارات و بازنشانی‌ها را در بین 53 ارائه‌دهنده کدنویسی هوش مصنوعی از نوار منوی macOS خود ردیابی کنید.",
+    "nav.primary": "اولیه",
+    "nav.language": "زبان",
+    "nav.docs": "اسناد",
+    "nav.source": "منبع",
+    "nav.download": "دانلود کنید",
+    "theme.toLight": "به طرح زمینه روشن تغییر دهید",
+    "theme.toDark": "به طرح زمینه تیره بروید",
+    "hero.prefix": "هر محدودیت کدنویسی هوش مصنوعی،",
+    "hero.accent": "در نوار منوی شما",
+    "hero.description": "CodexBar پنجره‌های استفاده، مانده اعتبار و بازنشانی شمارش معکوس را در سراسر ارائه‌دهندگانی که واقعاً برایشان پول پرداخت می‌کنید ردیابی می‌کند - هر کدام یک مورد وضعیت، یا آنها را در یکی ادغام کنید.",
+    "hero.download": "دانلود برای macOS",
+    "hero.fineprint": "رایگان و متن‌باز · macOS 14+ · نسخهٔ یونیورسال از GitHub Releases و Homebrew",
+    "providers.title": "53 ارائه دهنده، یک نوار منو",
+    "providers.description": "ارائه‌دهندگان محبوب با پنجره‌های استفاده خاص خود، شمارش معکوس، نمودارها و منوهای ارائه‌دهنده را بازنشانی می‌کنند.",
+    "providers.yourProvider": "ارائه دهنده شما",
+    "providers.authoringGuide": "راهنمای نگارش",
+    "auth.cookies": "Cookies",
+    "auth.cookiesGo": "Cookies + Go",
+    "auth.deviceFlow": "Device flow",
+    "auth.bearerLocal": "Bearer / Local",
+    "auth.apiKey": "API key",
+    "auth.token": "Token",
+    "auth.legacyApi": "Legacy API",
+    "auth.local": "Local",
+    "auth.apiKeyCookies": "API key + Cookies",
+    "auth.virtualKey": "Virtual key",
+    "showcase.alt": "پاپاور نوار منو CodexBar که کاشی‌های ارائه‌دهنده را با نوارهای استفاده، شمارش معکوس بازنشانی، و جزئیات اعتبار نشان می‌دهد.",
+    "features.resetsTitle": "بازنشانی می کند که می توانید برای آن برنامه ریزی کنید",
+    "features.resetsBody": "هر جلسه ارائه دهنده، پنجره های هفتگی و ماهانه با شمارش معکوس برای تنظیم مجدد بعدی - دیگر حدس نمی زنید که آیا یک کار طولانی را شروع کنید یا خیر.",
+    "features.spendTitle": "اسکن اعتبار، هزینه و هزینه",
+    "features.spendBody": "موجودی اعتبار و هزینه‌های ماهانه در جایی که ارائه‌دهنده آن‌ها را نشان می‌دهد، به‌علاوه اسکن‌های هزینه محلی قابل تنظیم برای Codex و Claude.",
+    "features.statusTitle": "وضعیت و حوادث",
+    "features.statusBody": "نشان‌های برخورد سطوح نظرسنجی وضعیت ارائه‌دهنده در منو و یک پوشش نشانگر روی نماد نوار.",
+    "features.cliTitle": "CLI و ویجت‌ها",
+    "features.cliBody": "ویجت‌های WidgetKit برای ارائه‌دهندگان پشتیبانی‌شده و یک {codexbar} CLI برای اسکریپت‌ها و CI — macOS و Linux در هر نسخه ساخته می‌شود.",
+    "detail.installTitle": "نصب و به روز رسانی",
+    "detail.installBody": "برنامهٔ یونیورسال از طریق {releases} با به‌روزرسانی خودکار Sparkle، یا از طریق {cask} (به‌روزرسانی با {upgrade}).",
+    "detail.cliTitle": "CLI",
+    "detail.cliBody": "یک {codexbar} باینری به همراه تاربال‌های مستقل برای macOS و Linux در هر نسخه. در Linux: {linuxCommand}.",
+    "detail.privacyTitle": "حریم خصوصی",
+    "detail.privacyBody": "از جلسات ارائه‌دهنده موجود - OAuth، جریان دستگاه، کلیدهای API، کوکی‌های مرورگر، فایل‌های محلی - مجدداً استفاده می‌کند - بنابراین هیچ گذرواژه‌ای ذخیره نمی‌شود. یادداشت های حسابرسی در {issue}.",
+    "detail.permissionsTitle": "مجوزهای macOS",
+    "detail.permissionsBody": "دسترسی کامل به دیسک برای کوکی‌های Safari، دسترسی Keychain برای رمزگشایی کوکی‌ها و جریان‌های OAuth، و هنگامی که کمک‌کنندگان ارائه‌دهنده دایرکتوری‌های پروژه را می‌خوانند، از Files & Folders درخواست می‌کند.",
+    "footer.builtBy": "ساخته شده توسط",
+    "footer.changelog": "تغییرات",
+    "clipboard.copy": "در کلیپ بورد کپی کنید",
+    "clipboard.copied": "کپی شده"
+  },
+  "th": {
+    "meta.title": "CodexBar — ทุกขีดจำกัดการเข้ารหัส AI ในแถบเมนูของคุณ",
+    "meta.description": "แอปแถบเมนู macOS ขนาดเล็กที่ติดตามกรอบเวลาการใช้งานของผู้ให้บริการเข้ารหัส AI เครดิต ต้นทุน และการรีเซ็ตในผู้ให้บริการ 53 ราย — Codex, OpenAI, Claude, Cursor, Gemini, Copilot, LiteLLM และอีกมากมาย",
+    "meta.ogDescription": "ติดตามกรอบเวลาการใช้งาน เครดิต และการรีเซ็ตในผู้ให้บริการการเข้ารหัส AI 53 รายจากแถบเมนู macOS",
+    "nav.primary": "หลัก",
+    "nav.language": "ภาษา",
+    "nav.docs": "เอกสาร",
+    "nav.source": "แหล่งที่มา",
+    "nav.download": "ดาวน์โหลด",
+    "theme.toLight": "เปลี่ยนเป็นธีมสว่าง",
+    "theme.toDark": "เปลี่ยนเป็นธีมสีเข้ม",
+    "hero.prefix": "ทุกขีดจำกัดการเข้ารหัส AI",
+    "hero.accent": "ในแถบเมนูของคุณ",
+    "hero.description": "CodexBar ติดตามกรอบเวลาการใช้งาน ยอดเครดิต และรีเซ็ตการนับถอยหลังของผู้ให้บริการที่คุณชำระเงินจริง — รายการสถานะแต่ละรายการ หรือรวมรายการเหล่านั้นเป็นรายการเดียว",
+    "hero.download": "ดาวน์โหลดสำหรับ macOS",
+    "hero.fineprint": "ฟรีและโอเพ่นซอร์ส · macOS 14+ · รุ่น Universal ผ่าน GitHub Releases และ Homebrew",
+    "providers.title": "ผู้ให้บริการ 53 ราย หนึ่งแถบเมนู",
+    "providers.description": "ผู้ให้บริการยอดนิยมจะกลายเป็นรายการสถานะที่มีหน้าต่างการใช้งานของตนเอง รีเซ็ตการนับถอยหลัง แผนภูมิ และเมนูของผู้ให้บริการ",
+    "providers.yourProvider": "ผู้ให้บริการของคุณ",
+    "providers.authoringGuide": "คู่มือการเขียน",
+    "auth.cookies": "Cookies",
+    "auth.cookiesGo": "Cookies + Go",
+    "auth.deviceFlow": "Device flow",
+    "auth.bearerLocal": "Bearer / Local",
+    "auth.apiKey": "API key",
+    "auth.token": "Token",
+    "auth.legacyApi": "Legacy API",
+    "auth.local": "Local",
+    "auth.apiKeyCookies": "API key + Cookies",
+    "auth.virtualKey": "Virtual key",
+    "showcase.alt": "ป๊อปโอเวอร์แถบเมนู CodexBar แสดงไทล์ผู้ให้บริการพร้อมแถบการใช้งาน การรีเซ็ตการนับถอยหลัง และรายละเอียดเครดิต",
+    "features.resetsTitle": "รีเซ็ตคุณสามารถวางแผนได้",
+    "features.resetsBody": "เซสชันต่อผู้ให้บริการ รายสัปดาห์และรายเดือนพร้อมการนับถอยหลังสู่การรีเซ็ตครั้งถัดไป — ไม่ต้องเดาอีกต่อไปว่าจะเริ่มงานที่ยาวนานหรือไม่",
+    "features.spendTitle": "เครดิต การใช้จ่าย และการสแกนต้นทุน",
+    "features.spendBody": "ยอดเครดิตและการใช้จ่ายรายเดือนที่ผู้ให้บริการเปิดเผย รวมถึงการสแกนต้นทุนในท้องถิ่นที่กำหนดค่าได้สำหรับ Codex และ Claude",
+    "features.statusTitle": "สถานะและเหตุการณ์ที่เกิดขึ้น",
+    "features.statusBody": "การสำรวจสถานะผู้ให้บริการจะแสดงป้ายเหตุการณ์ในเมนูและมีตัวบ่งชี้ซ้อนทับบนไอคอนแถบ",
+    "features.cliTitle": "CLI & วิดเจ็ต",
+    "features.cliBody": "วิดเจ็ต WidgetKit สำหรับผู้ให้บริการที่รองรับและ {codexbar} CLI แบบรวมสำหรับสคริปต์และ CI — macOS และ Linux บิวด์ในทุกรีลีส",
+    "detail.installTitle": "ติดตั้งและอัพเดต",
+    "detail.installBody": "แอป Universal ผ่าน {releases} พร้อมการอัปเดตอัตโนมัติ Sparkle หรือผ่าน {cask} (อัปเดตด้วย {upgrade})",
+    "detail.cliTitle": "CLI",
+    "detail.cliBody": "ไบนารี {codexbar} ที่รวมเข้าด้วยกันพร้อม tarball แบบสแตนด์อโลนสำหรับ macOS และ Linux ในแต่ละรุ่น ใน Linux: {linuxCommand}",
+    "detail.privacyTitle": "ความเป็นส่วนตัว",
+    "detail.privacyBody": "ใช้เซสชันของผู้ให้บริการที่มีอยู่ซ้ำ — OAuth, การไหลเวียนของอุปกรณ์, คีย์ API, คุกกี้ของเบราว์เซอร์, ไฟล์ในเครื่อง — ดังนั้นจึงไม่มีการจัดเก็บรหัสผ่าน บันทึกการตรวจสอบใน {issue}",
+    "detail.permissionsTitle": "สิทธิ์ macOS",
+    "detail.permissionsBody": "การเข้าถึงดิสก์โดยสมบูรณ์สำหรับคุกกี้ Safari, การเข้าถึง Keychain สำหรับการถอดรหัสคุกกี้และโฟลว์ OAuth และไฟล์และโฟลเดอร์แจ้งเตือนเมื่อผู้ช่วยผู้ให้บริการอ่านไดเรกทอรีโปรเจ็กต์",
+    "footer.builtBy": "สร้างโดย",
+    "footer.changelog": "บันทึกการเปลี่ยนแปลง",
+    "clipboard.copy": "คัดลอกไปยังคลิปบอร์ด",
+    "clipboard.copied": "คัดลอกแล้ว"
+  },
+  "ca": {
+    "meta.title": "CodexBar: tots els límits de la programació amb IA a la barra de menús",
+    "meta.description": "Una petita aplicació de barra de menús per a macOS que fa un seguiment de les finestres d'ús, els crèdits, els costos i els restabliments dels proveïdors de programació amb IA: 53 proveïdors, entre els quals Codex, OpenAI, Claude, Cursor, Gemini, Copilot, LiteLLM i més.",
+    "meta.ogDescription": "Feu el seguiment de les finestres d'ús, els crèdits i els restabliments de 53 proveïdors de programació amb IA des de la barra de menús del macOS.",
+    "nav.primary": "Navegació principal",
+    "nav.language": "Llengua",
+    "nav.docs": "Documentació",
+    "nav.source": "Codi font",
+    "nav.download": "Baixeu",
+    "theme.toLight": "Canvia al tema clar",
+    "theme.toDark": "Canvia al tema fosc",
+    "hero.prefix": "Cada límit de la programació amb IA,",
+    "hero.accent": "a la barra de menús.",
+    "hero.description": "El CodexBar fa el seguiment de les finestres d'ús, els saldos de crèdit i els comptes enrere fins al restabliment dels proveïdors pels quals realment pagueu: un element d'estat per a cadascun, o combineu-los tots en un de sol.",
+    "hero.download": "Baixeu per al macOS",
+    "hero.fineprint": "Gratuït i de codi obert · macOS 14+ · Universal mitjançant GitHub Releases i Homebrew",
+    "providers.title": "53 proveïdors, una barra de menús",
+    "providers.description": "Els proveïdors populars es converteixen en elements d'estat amb les seves pròpies finestres d'ús, comptes enrere de restabliment, gràfics i menús de proveïdor.",
+    "providers.yourProvider": "El vostre proveïdor",
+    "providers.authoringGuide": "Guia de creació",
+    "auth.cookies": "Galetes",
+    "auth.cookiesGo": "Galetes + Go",
+    "auth.deviceFlow": "Flux de dispositiu",
+    "auth.bearerLocal": "Bearer / Local",
+    "auth.apiKey": "Clau d'API",
+    "auth.token": "Token",
+    "auth.legacyApi": "API antiga",
+    "auth.local": "Local",
+    "auth.apiKeyCookies": "Clau d'API + galetes",
+    "auth.virtualKey": "Clau virtual",
+    "showcase.alt": "Finestra emergent del CodexBar a la barra de menús que mostra les targetes dels proveïdors amb barres d'ús, comptes enrere de restabliment i detalls de crèdit.",
+    "features.resetsTitle": "Restabliments que podeu planificar",
+    "features.resetsBody": "Sessió per proveïdor, finestres setmanals i mensuals amb comptes enrere fins al restabliment següent; sense haver d'endevinar si podeu iniciar una tasca llarga.",
+    "features.spendTitle": "Crèdits, despesa i anàlisis de costos",
+    "features.spendBody": "Saldos de crèdit i despesa mensual allà on el proveïdor els exposa, més anàlisis de costos locals configurables per a Codex i Claude.",
+    "features.statusTitle": "Estat i incidències",
+    "features.statusBody": "El sondeig d'estat dels proveïdors mostra insígnies d'incidències al menú i una superposició d'indicadors a la icona de la barra.",
+    "features.cliTitle": "CLI i ginys",
+    "features.cliBody": "Ginys de WidgetKit per als proveïdors compatibles i una CLI {codexbar} inclosa per a scripts i CI: el macOS i el Linux es publiquen a cada versió.",
+    "detail.installTitle": "Instal·lació i actualitzacions",
+    "detail.installBody": "Aplicació universal mitjançant {releases} amb actualitzacions automàtiques de Sparkle o mitjançant {cask} (actualitzacions amb {upgrade}).",
+    "detail.cliTitle": "CLI",
+    "detail.cliBody": "Un binari {codexbar} inclòs, més tarballs autònoms per al macOS i el Linux a cada versió. Al Linux: {linuxCommand}.",
+    "detail.privacyTitle": "Privadesa",
+    "detail.privacyBody": "Reutilitza les sessions existents dels proveïdors (OAuth, flux de dispositiu, claus d'API, galetes del navegador, fitxers locals), de manera que no s'emmagatzema cap contrasenya. Notes d'auditoria a {issue}.",
+    "detail.permissionsTitle": "Permisos del macOS",
+    "detail.permissionsBody": "Accés complet al disc per a les galetes de Safari, accés al Clauer per desxifrar les galetes i gestionar els fluxos OAuth, i sol·licituds d'accés a Fitxers i carpetes quan els processos auxiliars dels proveïdors llegeixen els directoris dels projectes.",
+    "footer.builtBy": "Creat per",
+    "footer.changelog": "Registre de canvis",
+    "clipboard.copy": "Copia al porta-retalls",
+    "clipboard.copied": "Copiat"
+  },
+  "sv": {
+    "meta.title": "CodexBar — varje AI-kodningsgräns i din menyrad",
+    "meta.description": "En liten macOS menyradsapp som spårar AI-kodningsleverantörers användningsfönster, krediter, kostnader och återställningar hos 53 leverantörer – Codex, OpenAI, Claude, Cursor, Gemini, Copilot, LiteLLM och mer.",
+    "meta.ogDescription": "Spåra användningsfönster, krediter och återställningar hos 53 AI-kodningsleverantörer från din macOS-menyrad.",
+    "nav.primary": "Primär",
+    "nav.language": "Språk",
+    "nav.docs": "Dokument",
+    "nav.source": "Källa",
+    "nav.download": "Ladda ner",
+    "theme.toLight": "Byt till ljustema",
+    "theme.toDark": "Byt till mörkt tema",
+    "hero.prefix": "Varje AI-kodningsgräns,",
+    "hero.accent": "i din menyrad.",
+    "hero.description": "CodexBar spårar användningsfönster, kreditsaldon och återställningsnedräkningar för de leverantörer du faktiskt betalar för – en statuspost var, eller slå samman dem till en.",
+    "hero.download": "Ladda ner för macOS",
+    "hero.fineprint": "Gratis och öppen källkod · macOS 14+ · Universal via GitHub Releases och Homebrew",
+    "providers.title": "53 leverantörer, en menyrad",
+    "providers.description": "Populära leverantörer blir statusobjekt med sina egna användningsfönster, återställer nedräkningar, diagram och leverantörsmenyer.",
+    "providers.yourProvider": "Din leverantör",
+    "providers.authoringGuide": "Författarguide",
+    "auth.cookies": "Cookies",
+    "auth.cookiesGo": "Cookies + Go",
+    "auth.deviceFlow": "Device flow",
+    "auth.bearerLocal": "Bearer / Local",
+    "auth.apiKey": "API key",
+    "auth.token": "Token",
+    "auth.legacyApi": "Legacy API",
+    "auth.local": "Local",
+    "auth.apiKeyCookies": "API key + Cookies",
+    "auth.virtualKey": "Virtual key",
+    "showcase.alt": "CodexBar menyrad popover som visar leverantörsrutor med användningsfält, återställda nedräkningar och kreditinformation.",
+    "features.resetsTitle": "Återställningar du kan planera runt",
+    "features.resetsBody": "Session per leverantör, vecko- och månadsfönster med nedräkningar till nästa återställning – du slipper gissa om du ska påbörja en lång uppgift.",
+    "features.spendTitle": "Krediter, utgifter och kostnadsskanningar",
+    "features.spendBody": "Kreditsaldon och månatliga utgifter där leverantören exponerar dem, plus konfigurerbara lokala kostnadsskanningar för Codex och Claude.",
+    "features.statusTitle": "Status & incidenter",
+    "features.statusBody": "Leverantörsstatusundersökning visar incidentmärken i menyn och en indikatoröverlagring på fältikonen.",
+    "features.cliTitle": "CLI och widgets",
+    "features.cliBody": "WidgetKit-widgets för leverantörer som stöds och en medföljande {codexbar} CLI för skript och CI — macOS och Linux bygger på varje version.",
+    "detail.installTitle": "Installera och uppdatera",
+    "detail.installBody": "Universell app via {releases} med automatiska Sparkle-uppdateringar, eller via {cask} (uppdateringar med {upgrade}).",
+    "detail.cliTitle": "CLI",
+    "detail.cliBody": "En medföljande binär {codexbar} plus fristående tarballs för macOS och Linux på varje version. På Linux: {linuxCommand}.",
+    "detail.privacyTitle": "Privatliv",
+    "detail.privacyBody": "Återanvänder befintliga leverantörssessioner – OAuth, enhetsflöde, API-nycklar, webbläsarcookies, lokala filer – så inga lösenord lagras. Granskningsanteckningar i {issue}.",
+    "detail.permissionsTitle": "macOS behörigheter",
+    "detail.permissionsBody": "Full diskåtkomst för Safari-cookies, Keychain-åtkomst för cookie-dekryptering och OAuth-flöden och filer och mappar när leverantörshjälpare läser projektkataloger.",
+    "footer.builtBy": "Byggd av",
+    "footer.changelog": "Ändringslogg",
+    "clipboard.copy": "Kopiera till urklipp",
+    "clipboard.copied": "Kopierade"
+  }
+};
diff --git a/docs/site.css b/docs/site.css
index bf335d072a..f76fdf1e18 100644
--- a/docs/site.css
+++ b/docs/site.css
@@ -1,505 +1,1010 @@
 :root {
-  color-scheme: light dark;
-  --bg: #070b12;
-  --panel: rgba(14, 18, 28, 0.78);
-  --panel-solid: #0e121c;
-  --text: rgba(241, 246, 255, 0.92);
-  --muted: rgba(187, 198, 218, 0.78);
-  --line: rgba(255, 255, 255, 0.1);
-  --accent: #3ff0d6;
-  --accent2: #2d5bff;
-  --shadow: rgba(0, 0, 0, 0.42);
-  --radius: 18px;
-  --radius-sm: 14px;
-}
-
-@media (prefers-color-scheme: light) {
-  :root {
-    --bg: #f8fbff;
-    --panel: rgba(255, 255, 255, 0.74);
-    --panel-solid: #ffffff;
-    --text: rgba(11, 16, 22, 0.92);
-    --muted: rgba(56, 70, 88, 0.75);
-    --line: rgba(11, 16, 22, 0.1);
-    --shadow: rgba(11, 16, 22, 0.12);
+  color-scheme: light;
+  --bg: #fbfbfc;
+  --bg-elev: #ffffff;
+  --bg-elev-2: #f3f4f6;
+  --ink-1: #0a0a0c;
+  --ink-2: #5b6068;
+  --ink-3: #8a8f97;
+  --line: rgba(0, 0, 0, 0.08);
+  --line-strong: rgba(0, 0, 0, 0.18);
+  --link: #0066cc;
+  --structure-line: rgba(10, 10, 12, 0.045);
+  --structure-line-strong: rgba(10, 10, 12, 0.1);
+  --structure-accent-hot: rgba(255, 106, 0, 0.12);
+  --structure-accent-cool: rgba(0, 191, 165, 0.1);
+  --logo-chip-bg: #ffffff;
+  --logo-chip-line: rgba(0, 0, 0, 0.08);
+  --logo-image-filter: none;
+  --logo-chip-shadow: 0 1px 0 rgba(255, 255, 255, 0.34), inset 0 0 0 1px rgba(0, 0, 0, 0.04);
+  --theme-toggle-bg: #101116;
+  --theme-toggle-ink: #ffffff;
+  --radius: 8px;
+  --radius-sm: 7px;
+}
+
+@media (prefers-color-scheme: dark) {
+  :root:not([data-theme]) {
+    --bg: #0a0a0c;
+    --bg-elev: #131418;
+    --bg-elev-2: #1c1d22;
+    --ink-1: #f0f0f3;
+    --ink-2: #97a0aa;
+    --ink-3: #6b7280;
+    --line: rgba(255, 255, 255, 0.09);
+    --line-strong: rgba(255, 255, 255, 0.2);
+    --link: #6ea8ff;
+    --structure-line: rgba(255, 255, 255, 0.035);
+    --structure-line-strong: rgba(255, 255, 255, 0.095);
+    --structure-accent-hot: rgba(255, 106, 0, 0.14);
+    --structure-accent-cool: rgba(0, 191, 165, 0.12);
+    --logo-chip-bg: #101116;
+    --logo-chip-line: rgba(255, 255, 255, 0.14);
+    --logo-image-filter: brightness(0) invert(1) saturate(0.86) contrast(1.12);
+    --logo-chip-shadow: 0 1px 0 rgba(255, 255, 255, 0.08), inset 0 0 0 1px rgba(255, 255, 255, 0.08);
+    --theme-toggle-bg: #ffffff;
+    --theme-toggle-ink: #0a0a0c;
   }
 }
 
+:root[data-theme="dark"] {
+  color-scheme: dark;
+  --bg: #0a0a0c;
+  --bg-elev: #131418;
+  --bg-elev-2: #1c1d22;
+  --ink-1: #f0f0f3;
+  --ink-2: #97a0aa;
+  --ink-3: #6b7280;
+  --line: rgba(255, 255, 255, 0.09);
+  --line-strong: rgba(255, 255, 255, 0.2);
+  --link: #6ea8ff;
+  --structure-line: rgba(255, 255, 255, 0.035);
+  --structure-line-strong: rgba(255, 255, 255, 0.095);
+  --structure-accent-hot: rgba(255, 106, 0, 0.14);
+  --structure-accent-cool: rgba(0, 191, 165, 0.12);
+  --logo-chip-bg: #101116;
+  --logo-chip-line: rgba(255, 255, 255, 0.14);
+  --logo-image-filter: brightness(0) invert(1) saturate(0.86) contrast(1.12);
+  --logo-chip-shadow: 0 1px 0 rgba(255, 255, 255, 0.08), inset 0 0 0 1px rgba(255, 255, 255, 0.08);
+  --theme-toggle-bg: #ffffff;
+  --theme-toggle-ink: #0a0a0c;
+}
+
+:root[data-theme="light"] {
+  color-scheme: light;
+}
+
 * {
   box-sizing: border-box;
 }
 
+.sr-only {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  padding: 0;
+  margin: -1px;
+  overflow: hidden;
+  clip: rect(0, 0, 0, 0);
+  white-space: nowrap;
+  border: 0;
+}
+
 html,
 body {
   min-height: 100%;
 }
 
+html {
+  background: var(--bg);
+}
+
 body {
   margin: 0;
-  font: 16px/1.55 ui-sans-serif, "Avenir Next", Avenir, "Segoe UI", "Helvetica Neue", sans-serif;
-  color: var(--text);
+  font-family: -apple-system, BlinkMacSystemFont, "SF Pro Text", "Segoe UI", "Helvetica Neue", sans-serif;
+  font-size: 16px;
+  line-height: 1.5;
+  color: var(--ink-1);
+  background: var(--bg);
+  -webkit-font-smoothing: antialiased;
+  text-rendering: optimizeLegibility;
+  position: relative;
+  overflow-x: hidden;
+}
+
+h1,
+h2,
+h3,
+p {
+  overflow-wrap: break-word;
+}
+
+.backdrop {
+  position: fixed;
+  inset: 0;
+  z-index: 0;
+  overflow: hidden;
+  pointer-events: none;
+  contain: strict;
+}
+
+.backdrop::before {
+  content: "";
+  position: absolute;
+  inset: -20% -10%;
   background:
-    radial-gradient(1100px 800px at 15% 10%, rgba(63, 240, 214, 0.18), transparent 58%),
-    radial-gradient(950px 780px at 85% 20%, rgba(45, 91, 255, 0.18), transparent 60%),
-    radial-gradient(900px 700px at 40% 95%, rgba(63, 240, 214, 0.06), transparent 60%),
-    repeating-linear-gradient(90deg, rgba(255, 255, 255, 0.04), rgba(255, 255, 255, 0.04) 1px, transparent 1px, transparent 72px),
-    var(--bg);
+    linear-gradient(115deg, transparent 0 42%, var(--structure-accent-hot) 42% 42.35%, transparent 42.35% 100%),
+    linear-gradient(115deg, transparent 0 58%, var(--structure-accent-cool) 58% 58.3%, transparent 58.3% 100%);
+  opacity: 0.42;
+  transform: skewY(-4deg);
 }
 
-html {
+.backdrop .plane,
+.backdrop .trace {
+  position: absolute;
+  display: block;
+}
+
+.backdrop .plane {
+  border: 1px solid var(--structure-line-strong);
+  border-radius: 18px;
+  box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.06);
+  opacity: 0.32;
+}
+
+.backdrop .p1 {
+  width: 780px;
+  height: 300px;
+  left: max(24px, calc(50% - 720px));
+  top: 128px;
+  transform: rotate(-2deg);
+}
+
+.backdrop .p2 {
+  width: 580px;
+  height: 360px;
+  right: max(24px, calc(50% - 760px));
+  top: 460px;
+  transform: rotate(3deg);
+}
+
+.backdrop .trace {
+  height: 1px;
+  background: linear-gradient(90deg, transparent, var(--structure-line-strong), transparent);
+  opacity: 0.36;
+}
+
+.backdrop .trace::before,
+.backdrop .trace::after {
+  content: "";
+  position: absolute;
+  top: -3px;
+  width: 7px;
+  height: 7px;
+  border: 1px solid var(--structure-line-strong);
+  border-radius: 2px;
   background: var(--bg);
 }
 
-a,
-a:visited {
-  color: inherit;
+.backdrop .trace::before {
+  left: 18%;
+}
+
+.backdrop .trace::after {
+  right: 12%;
+}
+
+.backdrop .t1 {
+  width: 58vw;
+  left: -6vw;
+  top: 260px;
+  transform: rotate(-12deg);
+}
+
+.backdrop .t2 {
+  width: 44vw;
+  right: -4vw;
+  top: 210px;
+  transform: rotate(14deg);
+}
+
+.backdrop .t3 {
+  width: 52vw;
+  left: 10vw;
+  top: 660px;
+  transform: rotate(7deg);
+}
+
+.backdrop .t4 {
+  width: 38vw;
+  right: 10vw;
+  top: 910px;
+  transform: rotate(-9deg);
+}
+
+body::before {
+  content: "";
+  position: fixed;
+  inset: 0;
+  z-index: 0;
+  pointer-events: none;
+  background-image:
+    linear-gradient(var(--structure-line) 1px, transparent 1px),
+    linear-gradient(90deg, var(--structure-line) 1px, transparent 1px),
+    linear-gradient(var(--structure-line-strong) 1px, transparent 1px),
+    linear-gradient(90deg, var(--structure-line-strong) 1px, transparent 1px);
+  background-size: 32px 32px, 32px 32px, 128px 128px, 128px 128px;
+  background-position: 50% 0, 50% 0, 50% 0, 50% 0;
+  -webkit-mask-image: linear-gradient(180deg, rgba(0, 0, 0, 1), rgba(0, 0, 0, 0.7) 70%, rgba(0, 0, 0, 0.45));
+          mask-image: linear-gradient(180deg, rgba(0, 0, 0, 1), rgba(0, 0, 0, 0.7) 70%, rgba(0, 0, 0, 0.45));
+}
+
+body::after {
+  content: "";
+  position: fixed;
+  inset: 0;
+  z-index: 0;
+  pointer-events: none;
+  background-image:
+    repeating-linear-gradient(135deg, transparent 0 56px, var(--structure-line) 56px 57px, transparent 57px 112px),
+    radial-gradient(circle at center, var(--structure-line-strong) 1px, transparent 1.6px);
+  background-size: auto, 96px 96px;
+  background-position: 0 0, 50% 0;
+  -webkit-mask-image: linear-gradient(180deg, rgba(0, 0, 0, 0.48), rgba(0, 0, 0, 0.24) 78%, transparent);
+          mask-image: linear-gradient(180deg, rgba(0, 0, 0, 0.48), rgba(0, 0, 0, 0.24) 78%, transparent);
 }
 
 a {
+  color: inherit;
   text-decoration: none;
 }
 
 a:hover {
   text-decoration: underline;
+  text-decoration-thickness: 1px;
+  text-underline-offset: 3px;
 }
 
 code {
-  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", monospace;
-  font-size: 0.95em;
+  font-family: ui-monospace, "SF Mono", Menlo, Consolas, monospace;
+  font-size: 0.92em;
 }
 
-.wrap {
-  max-width: 1020px;
-  margin: 0 auto;
-  padding: 46px 22px 34px;
+.masthead,
+.lede,
+.providers,
+.showcase,
+.detail,
+.foot {
+  position: relative;
+  z-index: 1;
+  width: 100%;
+  max-width: 1080px;
+  margin-left: auto;
+  margin-right: auto;
+  padding-left: 24px;
+  padding-right: 24px;
 }
 
-.top {
+.masthead {
   display: flex;
   align-items: center;
   justify-content: space-between;
-  gap: 18px;
-  margin-bottom: 28px;
+  padding-top: 22px;
+  padding-bottom: 22px;
 }
 
 .brand {
-  display: flex;
+  display: inline-flex;
   align-items: center;
-  gap: 14px;
-  min-width: 240px;
+  gap: 10px;
+  font-weight: 600;
+  font-size: 16px;
+  letter-spacing: 0;
+}
+
+.brand:hover {
+  text-decoration: none;
+}
+
+.mark {
+  width: 28px;
+  height: 28px;
+  border-radius: 7px;
 }
 
-.name {
+.nav {
   display: flex;
-  flex-direction: column;
-  gap: 2px;
+  align-items: center;
+  gap: 22px;
+  font-size: 14px;
 }
 
-.title {
-  margin: 0;
-  font-family: ui-serif, "New York", "Iowan Old Style", Palatino, serif;
-  font-size: 22px;
-  letter-spacing: 0.1px;
+.nav a {
+  color: var(--ink-2);
 }
 
-.tagline {
-  margin: 0;
-  color: var(--muted);
-  font-size: 13.5px;
+.nav a:hover {
+  color: var(--ink-1);
+  text-decoration: none;
 }
 
-.mark {
-  width: 44px;
-  height: 44px;
-  border-radius: 13px;
-  border: 0;
-  box-shadow: none;
-  background: transparent;
-  object-fit: cover;
-  filter: drop-shadow(0 12px 24px rgba(0, 0, 0, 0.35));
+.language-control {
+  position: relative;
+  display: inline-flex;
+  align-items: center;
+  color: var(--ink-2);
 }
 
-.brand:hover .mark {
-  filter: drop-shadow(0 16px 34px rgba(0, 0, 0, 0.42));
+.language-control svg {
+  position: absolute;
+  right: 10px;
+  pointer-events: none;
 }
 
-.links {
-  display: flex;
-  gap: 10px;
+.language-select {
+  max-width: 136px;
+  height: 36px;
+  padding: 0 30px 0 12px;
+  border: 1px solid var(--line-strong);
+  border-radius: 999px;
+  color: var(--ink-1);
+  background: var(--bg-elev);
+  font: inherit;
+  font-size: 13px;
+  cursor: pointer;
+  appearance: none;
+  transition: border-color 140ms ease, background 140ms ease;
 }
 
-.btn {
-  padding: 10px 14px;
-  border-radius: 13px;
-  border: 0;
-  background: color-mix(in srgb, var(--panel-solid) 32%, transparent);
-  box-shadow: 0 10px 28px var(--shadow);
-  transition: transform 160ms ease, background 160ms ease, box-shadow 160ms ease;
-  white-space: nowrap;
+.language-select:hover,
+.language-select:focus-visible {
+  border-color: var(--ink-2);
+  outline: none;
 }
 
-.btn:hover {
+[dir="rtl"] .language-control svg {
+  right: auto;
+  left: 10px;
+}
+
+[dir="rtl"] .language-select {
+  padding-right: 12px;
+  padding-left: 30px;
+}
+
+.theme-toggle {
+  width: 36px;
+  height: 36px;
+  padding: 0;
+  border: 1px solid var(--line-strong);
+  border-radius: 999px;
+  display: inline-grid;
+  place-items: center;
+  color: var(--theme-toggle-ink);
+  background: var(--theme-toggle-bg);
+  cursor: pointer;
+  transition: transform 140ms ease, border-color 140ms ease, background 140ms ease, color 140ms ease;
+}
+
+.theme-toggle:hover {
   transform: translateY(-1px);
-  text-decoration: none;
-  background: color-mix(in srgb, var(--panel-solid) 52%, transparent);
-  box-shadow: 0 14px 34px var(--shadow);
+  border-color: var(--ink-2);
 }
 
-.btn.primary {
-  background: linear-gradient(135deg, rgba(63, 240, 214, 0.65), rgba(45, 91, 255, 0.62));
-  background-clip: padding-box;
-  box-shadow: 0 12px 30px color-mix(in srgb, var(--accent) 25%, var(--shadow));
+.theme-toggle .sun,
+.theme-toggle .moon {
+  grid-area: 1 / 1;
+  transition: opacity 140ms ease, transform 140ms ease;
 }
 
-.btn.ghost {
-  background: transparent;
-  box-shadow: none;
-  color: color-mix(in srgb, var(--text) 86%, var(--muted));
+.theme-toggle .sun {
+  opacity: 1;
+  transform: scale(1);
+}
+
+.theme-toggle .moon {
+  opacity: 0;
+  transform: scale(0.72) rotate(-12deg);
 }
 
-.btn.ghost:hover {
-  background: color-mix(in srgb, var(--panel-solid) 28%, transparent);
-  box-shadow: 0 10px 24px var(--shadow);
+:root[data-theme="dark"] .theme-toggle .sun,
+:root:not([data-theme]) .theme-toggle[aria-pressed="true"] .sun {
+  opacity: 0;
+  transform: scale(0.72) rotate(12deg);
 }
 
-.hero {
-  display: grid;
-  grid-template-columns: minmax(0, 1.05fr) minmax(0, 0.9fr);
-  gap: 26px;
+:root[data-theme="dark"] .theme-toggle .moon,
+:root:not([data-theme]) .theme-toggle[aria-pressed="true"] .moon {
+  opacity: 1;
+  transform: scale(1);
+}
+
+.btn {
+  display: inline-flex;
   align-items: center;
-  padding: 24px 26px;
-  border: 1px solid var(--line);
-  border-radius: var(--radius);
-  background: var(--panel);
-  backdrop-filter: blur(12px);
-  box-shadow: 0 18px 60px var(--shadow);
-  position: relative;
-  overflow: hidden;
+  justify-content: center;
+  gap: 8px;
+  padding: 8px 14px;
+  border-radius: 999px;
+  border: 1px solid var(--line-strong);
+  background: var(--bg-elev);
+  font-size: 14px;
+  font-weight: 500;
+  color: var(--ink-1);
+  white-space: nowrap;
+  transition: background 140ms ease, border-color 140ms ease, transform 140ms ease, color 140ms ease;
 }
 
-.copy {
-  position: relative;
-  z-index: 1;
+.btn:hover {
+  background: var(--bg-elev-2);
+  border-color: var(--ink-2);
+  text-decoration: none;
 }
 
-.hero-heading {
-  display: flex;
-  gap: 14px;
-  align-items: flex-start;
+.btn.primary {
+  background: var(--ink-1);
+  color: var(--bg);
+  border-color: var(--ink-1);
 }
 
-.hero-icon {
-  width: 40px;
-  height: 40px;
-  border-radius: 12px;
-  filter: drop-shadow(0 12px 24px rgba(0, 0, 0, 0.35));
+.btn.primary:hover {
+  background: color-mix(in srgb, var(--ink-1) 86%, transparent);
+  border-color: var(--ink-1);
+  color: var(--bg);
 }
 
-.hero::before {
-  content: "";
-  position: absolute;
-  inset: -1px;
-  background:
-    radial-gradient(600px 320px at 10% 15%, rgba(63, 240, 214, 0.18), transparent 55%),
-    radial-gradient(520px 300px at 92% 18%, rgba(45, 91, 255, 0.18), transparent 55%);
-  pointer-events: none;
-  opacity: 0.9;
+.btn.lg {
+  padding: 11px 20px;
+  font-size: 15px;
 }
 
-.copy h2 {
-  margin: 0 0 8px;
-  font-family: ui-serif, "New York", "Iowan Old Style", Palatino, serif;
-  font-size: 34px;
-  letter-spacing: -0.3px;
-  line-height: 1.12;
-  position: relative;
+.lede {
+  padding-top: 56px;
+  padding-bottom: 64px;
 }
 
-.copy p {
-  margin: 0 0 10px;
-  color: var(--muted);
+.lede h1 {
+  margin: 0 0 18px;
+  font-size: 60px;
+  line-height: 1.04;
+  letter-spacing: -0.01em;
+  font-weight: 600;
+  max-width: 18ch;
 }
 
-.requirement {
-  margin: 6px 0 0;
-  color: color-mix(in srgb, var(--text) 92%, var(--muted));
-  font-size: 13.5px;
+.lede h1 .grad {
+  background-image: linear-gradient(100deg, #ff6a00 0%, #ff3399 32%, #6e5aff 62%, #00bfa5 100%);
+  -webkit-background-clip: text;
+  background-clip: text;
+  color: transparent;
+  background-size: 200% 100%;
+  animation: hue-slide 14s ease-in-out infinite;
 }
 
-.badges {
-  display: flex;
-  flex-wrap: wrap;
-  gap: 8px;
-  margin-bottom: 10px;
-  position: relative;
+@keyframes hue-slide {
+  0%, 100% { background-position: 0% 50%; }
+  50% { background-position: 100% 50%; }
 }
 
-.badge {
-  font-size: 12px;
-  padding: 6px 10px;
-  border-radius: 999px;
-  border: 1px solid var(--line);
-  background: color-mix(in srgb, var(--panel-solid) 14%, transparent);
-  color: color-mix(in srgb, var(--text) 86%, var(--muted));
-  letter-spacing: 0.2px;
+.lede .dek {
+  margin: 0;
+  font-size: 19px;
+  line-height: 1.5;
+  color: var(--ink-2);
+  max-width: 60ch;
 }
 
-.cta {
+.lede .actions {
   display: flex;
-  gap: 10px;
   flex-wrap: wrap;
-  margin-top: 14px;
-  position: relative;
+  gap: 12px;
+  margin: 28px 0 14px;
+  align-items: center;
 }
 
-.brew-line {
-  display: flex;
+.brew {
+  display: inline-flex;
   align-items: center;
-  gap: 8px;
-  flex-wrap: wrap;
+  gap: 4px;
+  padding: 6px 6px 6px 14px;
+  border: 1px solid var(--line-strong);
+  border-radius: 999px;
+  background: var(--bg-elev);
+  font-size: 13.5px;
+  max-width: 100%;
+  overflow: hidden;
 }
 
-.brew-line code {
-  background: color-mix(in srgb, var(--panel-solid) 40%, transparent);
-  padding: 4px 8px;
-  border-radius: 6px;
-  border: 1px solid var(--line);
+.brew code {
+  background: none;
+  padding: 0;
+  direction: ltr;
+  min-width: 0;
+  text-align: left;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  unicode-bidi: isolate;
 }
 
-.copy-btn {
+.brew-copy {
   display: inline-flex;
   align-items: center;
   justify-content: center;
   width: 28px;
   height: 28px;
   padding: 0;
-  border: 1px solid var(--line);
-  border-radius: 6px;
-  background: color-mix(in srgb, var(--panel-solid) 30%, transparent);
-  color: var(--muted);
+  margin: 0;
+  border: 0;
+  background: transparent;
+  border-radius: 999px;
+  color: var(--ink-2);
   cursor: pointer;
-  transition: background 160ms ease, color 160ms ease, border-color 160ms ease;
+  flex-shrink: 0;
+  transition: background 140ms ease, color 140ms ease;
 }
 
-.copy-btn:hover {
-  background: color-mix(in srgb, var(--panel-solid) 60%, transparent);
-  color: var(--text);
-  border-color: color-mix(in srgb, var(--accent) 32%, var(--line));
+.brew-copy:hover {
+  background: var(--bg-elev-2);
+  color: var(--ink-1);
 }
 
-.copy-btn .icon-check {
+.brew-copy .ok {
   display: none;
-  color: var(--accent);
 }
 
-.copy-btn.copied .icon-copy {
+.brew-copy.copied .ic {
   display: none;
 }
 
-.copy-btn.copied .icon-check {
-  display: block;
+.brew-copy.copied .ok {
+  display: inline;
+  color: #16a34a;
 }
 
-.copy-btn.copied {
-  border-color: var(--accent);
-  color: var(--accent);
+.fineprint {
+  margin: 6px 0 0;
+  font-size: 13px;
+  color: var(--ink-3);
 }
 
-.bullets {
-  margin: 14px 0 0;
-  padding: 0 0 0 18px;
-  color: var(--muted);
-  font-size: 13.5px;
-  position: relative;
+.section-head {
+  margin: 0 0 22px;
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 18px;
+  flex-wrap: wrap;
 }
 
-.bullets li {
-  margin: 6px 0;
+.section-head h2 {
+  margin: 0;
+  font-size: 28px;
+  font-weight: 600;
+  letter-spacing: 0;
 }
 
-.note {
-  margin: 10px 0 0;
-  color: var(--muted);
-  font-size: 13px;
+.section-head p {
+  margin: 0;
+  color: var(--ink-2);
+  font-size: 14.5px;
+  max-width: 48ch;
+}
+
+.providers {
+  padding-bottom: 64px;
 }
 
-.shot {
+.grid {
+  list-style: none;
   margin: 0;
-  position: relative;
-  z-index: 1;
+  padding: 0;
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(190px, 1fr));
+  gap: 8px;
 }
 
-.shot img {
-  width: 100%;
-  height: auto;
-  border-radius: var(--radius-sm);
+.grid > li {
+  margin: 0;
+}
+
+.provider {
+  --ink: #ffffff;
+  position: relative;
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  padding: 12px;
   border: 1px solid var(--line);
-  box-shadow: 0 18px 60px var(--shadow);
-  background: color-mix(in srgb, var(--panel-solid) 92%, transparent);
-  transform: perspective(900px) rotateY(-6deg) rotateX(2deg);
-  transition: transform 220ms ease, box-shadow 220ms ease;
+  border-radius: var(--radius);
+  background: color-mix(in srgb, var(--bg-elev) 82%, transparent);
+  backdrop-filter: blur(8px) saturate(140%);
+  -webkit-backdrop-filter: blur(8px) saturate(140%);
+  text-decoration: none;
+  color: var(--ink-1);
+  min-height: 64px;
+  transition: transform 140ms ease, border-color 140ms ease, box-shadow 140ms ease, background 140ms ease;
 }
 
-.hero-shot {
-  margin: 0;
-  justify-self: end;
+.provider:hover {
+  text-decoration: none;
+  transform: translateY(-1px);
+  border-color: color-mix(in srgb, var(--brand, var(--line-strong)) 55%, var(--line-strong));
+  box-shadow: 0 6px 18px color-mix(in srgb, var(--brand, transparent) 18%, transparent);
 }
 
-.hero-shot img {
-  max-width: 300px;
-  margin-left: auto;
+.provider:has(.chip-logo)::before {
+  content: "";
+  width: 38px;
+  height: 38px;
+  border-radius: var(--radius-sm);
+  flex: 0 0 38px;
+  background: var(--logo-chip-bg);
+  border: 1px solid var(--logo-chip-line);
+  box-shadow: var(--logo-chip-shadow);
+  transition: background 140ms ease, border-color 140ms ease, box-shadow 140ms ease;
 }
 
-.hero-shot figcaption {
-  max-width: 300px;
-  text-align: center;
-  margin-left: auto;
+.provider.logo-dark::before {
+  background: #101116;
+  border-color: rgba(0, 0, 0, 0.14);
 }
 
-.shot figcaption {
-  margin-top: 8px;
-  color: var(--muted);
-  font-size: 12.5px;
-  text-align: center;
+:root[data-theme="dark"] .provider.logo-dark::before {
+  background: var(--logo-chip-bg);
+  border-color: var(--logo-chip-line);
 }
 
-.shot img:hover {
-  transform: perspective(900px) rotateY(-2deg) rotateX(0deg) translateY(-2px);
-  box-shadow: 0 24px 80px var(--shadow);
+@media (prefers-color-scheme: dark) {
+  :root:not([data-theme]) .provider.logo-dark::before {
+    background: var(--logo-chip-bg);
+    border-color: var(--logo-chip-line);
+  }
 }
 
-.details {
+.provider .chip {
+  width: 38px;
+  height: 38px;
+  border-radius: var(--radius-sm);
   display: grid;
-  grid-template-columns: repeat(3, 1fr);
-  gap: 14px;
-  margin-top: 14px;
+  place-items: center;
+  background: var(--brand, var(--bg-elev-2));
+  color: var(--ink, #fff);
+  font-weight: 700;
+  font-size: 17px;
+  letter-spacing: 0;
+  flex-shrink: 0;
+  box-shadow:
+    inset 0 1px 0 rgba(255, 255, 255, 0.18),
+    inset 0 -1px 0 rgba(0, 0, 0, 0.12);
+}
+
+.provider .chip-logo {
+  position: absolute;
+  left: 18px;
+  top: 50%;
+  width: 26px;
+  height: 26px;
+  transform: translateY(-50%);
+  border-radius: var(--radius-sm);
+  flex-shrink: 0;
+  object-fit: contain;
+  background: transparent;
+  border: 0;
+  filter: var(--logo-image-filter);
+  padding: 0;
+  box-shadow: none;
+  transition: filter 140ms ease;
 }
 
-.details.permissions {
-  grid-template-columns: 1fr;
+.provider .chip-logo.no-bg {
+  background: transparent;
+  padding: 0;
 }
 
-.card {
-  border: 1px solid var(--line);
-  border-radius: var(--radius);
-  padding: 14px 14px 12px;
-  background: var(--panel);
-  backdrop-filter: blur(10px);
-  box-shadow: 0 14px 40px var(--shadow);
+.provider .chip-logo.preserve-color {
+  filter: none;
 }
 
-.card h3 {
-  margin: 0 0 6px;
-  font-size: 13px;
-  letter-spacing: 0.2px;
-  text-transform: uppercase;
-  color: color-mix(in srgb, var(--text) 88%, var(--muted));
+.provider .meta {
+  display: flex;
+  flex-direction: column;
+  min-width: 0;
 }
 
-.card p {
-  margin: 0;
-  color: var(--muted);
-  font-size: 13.5px;
+.provider .name {
+  font-size: 14px;
+  font-weight: 500;
+  line-height: 1.2;
+  color: var(--ink-1);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
 }
 
-.foot {
-  margin-top: 22px;
-  text-align: center;
-  color: var(--muted);
-  font-size: 13px;
+.provider .auth {
+  font-size: 12px;
+  color: var(--ink-2);
+  margin-top: 3px;
+  letter-spacing: 0;
 }
 
-.links-row {
-  margin-top: 14px;
-  display: flex;
-  gap: 10px;
-  flex-wrap: wrap;
-  justify-content: center;
+[dir="rtl"] .provider .chip-logo {
+  left: auto;
+  right: 18px;
 }
 
-.link-pill {
-  padding: 8px 12px;
-  border-radius: 999px;
+.provider.add {
+  border-style: dashed;
+  background: transparent;
+}
+
+.provider.add:hover {
+  border-color: var(--ink-2);
+  box-shadow: none;
+}
+
+.provider.add .chip {
+  background: transparent;
+  color: var(--ink-2);
+  box-shadow: inset 0 0 0 1px var(--line-strong);
+  font-weight: 400;
+  font-size: 22px;
+}
+
+.showcase {
+  display: grid;
+  grid-template-columns: 1.05fr 1fr;
+  gap: 48px;
+  align-items: center;
+  padding-top: 8px;
+  padding-bottom: 64px;
+}
+
+.showcase .shot {
+  margin: 0;
+}
+
+.showcase .shot img {
+  width: 100%;
+  height: auto;
+  border-radius: var(--radius);
   border: 1px solid var(--line);
-  background: color-mix(in srgb, var(--panel-solid) 24%, transparent);
-  font-size: 13px;
+  box-shadow: 0 18px 50px rgba(0, 0, 0, 0.18);
+  background: var(--bg-elev);
 }
 
-.foot a {
-  text-decoration: underline;
-  text-decoration-color: color-mix(in srgb, var(--muted) 45%, transparent);
+.showcase .features {
+  display: grid;
+  grid-template-columns: 1fr;
+  gap: 20px;
 }
 
-[data-animate] {
-  opacity: 0;
-  transform: translateY(10px);
-  animation: rise 680ms cubic-bezier(0.2, 0.9, 0.2, 1) forwards;
-  animation-delay: calc(var(--d, 0) * 90ms);
+.showcase .features article {
+  padding-left: 14px;
+  border-left: 2px solid var(--line);
 }
 
-[data-animate="1"] {
-  --d: 1;
+[dir="rtl"] .showcase .features article {
+  padding-right: 14px;
+  padding-left: 0;
+  border-right: 2px solid var(--line);
+  border-left: 0;
 }
 
-[data-animate="2"] {
-  --d: 2;
+.showcase .features article h3 {
+  margin: 0 0 4px;
+  font-size: 15px;
+  font-weight: 600;
 }
 
-[data-animate="3"] {
-  --d: 3;
+.showcase .features article p {
+  margin: 0;
+  color: var(--ink-2);
+  font-size: 14.5px;
+  line-height: 1.5;
 }
 
-[data-animate="4"] {
-  --d: 4;
+.detail {
+  display: grid;
+  grid-template-columns: repeat(2, 1fr);
+  gap: 12px;
+  padding-bottom: 56px;
 }
 
-[data-animate="5"] {
-  --d: 5;
+.detail .block {
+  border: 1px solid var(--line);
+  border-radius: var(--radius);
+  padding: 18px;
+  background: color-mix(in srgb, var(--bg-elev) 82%, transparent);
+  backdrop-filter: blur(8px) saturate(140%);
+  -webkit-backdrop-filter: blur(8px) saturate(140%);
 }
 
-[data-animate="6"] {
-  --d: 6;
+.detail .block h3 {
+  margin: 0 0 6px;
+  font-size: 14px;
+  font-weight: 600;
 }
 
-[data-animate="7"] {
-  --d: 7;
+.detail .block p {
+  margin: 0;
+  color: var(--ink-2);
+  font-size: 14px;
+  line-height: 1.5;
 }
 
-[data-animate="8"] {
-  --d: 8;
+.detail .block code,
+.lede .brew code {
+  background: var(--bg-elev-2);
+  padding: 2px 6px;
+  border-radius: 5px;
 }
 
-@keyframes rise {
-  to {
-    opacity: 1;
-    transform: translateY(0);
-  }
+.lede .brew code {
+  background: none;
+  padding: 0;
 }
 
-@media (prefers-reduced-motion: reduce) {
-  [data-animate] {
-    animation: none;
-    opacity: 1;
-    transform: none;
-  }
-  .btn,
-  .shot img {
-    transition: none;
-  }
+.lede a,
+.showcase a,
+.detail a,
+.foot a {
+  color: var(--link);
+  text-decoration: underline;
+  text-decoration-color: color-mix(in srgb, var(--link) 35%, transparent);
+  text-underline-offset: 2px;
+}
+
+.lede a:hover,
+.showcase a:hover,
+.detail a:hover,
+.foot a:hover {
+  text-decoration-color: var(--link);
+}
+
+.foot {
+  padding-top: 22px;
+  padding-bottom: 36px;
+  margin-top: 8px;
+  border-top: 1px solid var(--line);
+  text-align: center;
+  color: var(--ink-3);
+  font-size: 13px;
+}
+
+.foot p {
+  margin: 0;
 }
 
-@media (max-width: 860px) {
-  .top {
+@media (max-width: 720px) {
+  .masthead,
+  .lede,
+  .providers,
+  .showcase,
+  .detail,
+  .foot {
+    padding-left: 18px;
+    padding-right: 18px;
+  }
+  .masthead {
+    padding-top: 16px;
+    padding-bottom: 16px;
+  }
+  .nav {
+    gap: 8px;
+  }
+  .language-select {
+    width: 44px;
+    padding-left: 12px;
+    color: transparent;
+  }
+  .language-control::before {
+    content: "Aa";
+    position: absolute;
+    left: 12px;
+    z-index: 1;
+    color: var(--ink-1);
+    font-size: 13px;
+    pointer-events: none;
+  }
+  [dir="rtl"] .language-select {
+    padding-right: 12px;
+    padding-left: 12px;
+  }
+  [dir="rtl"] .language-control::before {
+    right: 12px;
+    left: auto;
+  }
+  .language-control svg {
+    display: none;
+  }
+  .nav-link {
+    display: none;
+  }
+  .theme-toggle {
+    width: 34px;
+    height: 34px;
+  }
+  .nav .btn {
+    padding-left: 12px;
+    padding-right: 12px;
+  }
+  .lede {
+    padding-top: 28px;
+    padding-bottom: 40px;
+  }
+  .lede h1 {
+    font-size: 32px;
+    max-width: 11ch;
+  }
+  .lede .dek {
+    font-size: 16px;
+    max-width: 30ch;
+  }
+  .section-head h2 {
+    font-size: 23px;
+  }
+  .section-head p {
+    max-width: 30ch;
+  }
+  .lede .actions {
     flex-direction: column;
-    align-items: flex-start;
+    align-items: stretch;
+    min-width: 0;
+    width: 100%;
+  }
+  .lede .actions .btn {
+    max-width: 100%;
+    min-width: 0;
+    width: 100%;
+  }
+  .brew {
+    min-width: 0;
+    width: 100%;
+  }
+  .brew code {
+    flex: 1 1 auto;
+  }
+  .brew-copy {
+    flex: 0 0 28px;
   }
-  .hero {
+  .grid {
     grid-template-columns: 1fr;
   }
-  .details {
+  .showcase {
     grid-template-columns: 1fr;
+    gap: 28px;
+  }
+  .detail {
+    grid-template-columns: 1fr;
+  }
+}
+
+@media (max-width: 480px) {
+  .masthead {
+    gap: 12px;
   }
-  .shot img {
+  .nav {
+    flex: 0 1 auto;
+    min-width: 0;
+  }
+  .nav .btn {
+    display: none;
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .btn,
+  .provider {
+    transition: none;
+  }
+  .provider:hover,
+  .btn:hover {
     transform: none;
   }
+  .lede h1 .grad {
+    animation: none;
+  }
 }
diff --git a/docs/site.js b/docs/site.js
new file mode 100644
index 0000000000..6887ab3375
--- /dev/null
+++ b/docs/site.js
@@ -0,0 +1,208 @@
+import { localeCatalog, localeMessages } from "./site-locales.mjs";
+
+const root = document.documentElement;
+const toggle = document.querySelector(".theme-toggle");
+const languageSelect = document.querySelector(".language-select");
+const metaTheme = document.querySelector('meta[name="theme-color"]');
+const metaDescription = document.querySelector('meta[name="description"]');
+const metaOgDescription = document.querySelector('meta[property="og:description"]');
+const media = window.matchMedia("(prefers-color-scheme: dark)");
+const supportedLocales = new Set(localeCatalog.map((locale) => locale.code));
+const rtlLocales = new Set(localeCatalog.filter((locale) => locale.direction === "rtl").map((locale) => locale.code));
+let activeMessages = localeMessages.en;
+
+function normalizeLocale(value) {
+  if (!value) return null;
+
+  const lower = value.toLowerCase();
+  const aliases = {
+    "zh-cn": "zh-CN",
+    "zh-hans": "zh-CN",
+    "zh-hant": "zh-TW",
+    "zh-hk": "zh-TW",
+    "zh-tw": "zh-TW",
+    ja: "ja-JP",
+    pt: "pt-BR",
+    "pt-br": "pt-BR",
+  };
+  if (aliases[lower]) return aliases[lower];
+
+  return localeCatalog.find((locale) =>
+    locale.code.toLowerCase() === lower || lower.startsWith(`${locale.code.toLowerCase()}-`))?.code ?? null;
+}
+
+function selectedLocale() {
+  const fromDocument = normalizeLocale(root.dataset.locale);
+  if (fromDocument) return fromDocument;
+
+  try {
+    const queryLocale = normalizeLocale(new URLSearchParams(location.search).get("lang"));
+    if (queryLocale) return queryLocale;
+    const storedLocale = normalizeLocale(localStorage.getItem("codexbar-language"));
+    if (storedLocale) return storedLocale;
+  } catch (_) {}
+
+  for (const language of navigator.languages || [navigator.language]) {
+    const locale = normalizeLocale(language);
+    if (locale) return locale;
+  }
+  return "en";
+}
+
+function message(key) {
+  return activeMessages[key] || localeMessages.en[key] || key;
+}
+
+function applyLocale(locale) {
+  const resolved = supportedLocales.has(locale) ? locale : "en";
+  activeMessages = { ...localeMessages.en, ...localeMessages[resolved] };
+
+  root.lang = resolved;
+  root.dir = rtlLocales.has(resolved) ? "rtl" : "ltr";
+  root.dataset.locale = resolved;
+  if (languageSelect) languageSelect.value = resolved;
+
+  document.title = message("meta.title");
+  metaDescription?.setAttribute("content", message("meta.description"));
+  metaOgDescription?.setAttribute("content", message("meta.ogDescription"));
+
+  document.querySelectorAll("[data-i18n]").forEach((element) => {
+    element.textContent = message(element.dataset.i18n);
+  });
+  document.querySelectorAll("[data-i18n-rich]").forEach((element) => {
+    renderRichMessage(element, message(element.dataset.i18nRich));
+  });
+  applyAttributeMessages("data-i18n-aria-label", "aria-label");
+  applyAttributeMessages("data-i18n-title", "title");
+  applyAttributeMessages("data-i18n-alt", "alt");
+  updateThemeUI();
+}
+
+function applyAttributeMessages(dataAttribute, targetAttribute) {
+  document.querySelectorAll(`[${dataAttribute}]`).forEach((element) => {
+    element.setAttribute(targetAttribute, message(element.getAttribute(dataAttribute)));
+  });
+}
+
+function renderRichMessage(element, value) {
+  const fragment = document.createDocumentFragment();
+  const tokenPattern = /\{([a-zA-Z][a-zA-Z0-9]*)\}/g;
+  let cursor = 0;
+  let match;
+
+  while ((match = tokenPattern.exec(value)) !== null) {
+    fragment.append(document.createTextNode(value.slice(cursor, match.index)));
+    fragment.append(richToken(match[1]));
+    cursor = match.index + match[0].length;
+  }
+  fragment.append(document.createTextNode(value.slice(cursor)));
+  element.replaceChildren(fragment);
+}
+
+function richToken(name) {
+  const codeTokens = {
+    cask: "brew install --cask steipete/tap/codexbar",
+    codexbar: "codexbar",
+    linuxCommand: "brew install steipete/tap/codexbar",
+    upgrade: "brew upgrade",
+  };
+  if (codeTokens[name]) {
+    const code = document.createElement("code");
+    code.textContent = codeTokens[name];
+    return code;
+  }
+  if (name === "releases") {
+    const link = document.createElement("a");
+    link.href = "https://github.com/steipete/CodexBar/releases/latest";
+    link.textContent = "GitHub Releases";
+    return link;
+  }
+  if (name === "issue") {
+    const link = document.createElement("a");
+    link.href = "https://github.com/steipete/CodexBar/issues/12";
+    link.textContent = "issue #12";
+    return link;
+  }
+
+  return document.createTextNode(`{${name}}`);
+}
+
+function queryTheme() {
+  try {
+    const value = new URLSearchParams(location.search).get("theme");
+    return value === "light" || value === "dark" ? value : null;
+  } catch (_) {
+    return null;
+  }
+}
+
+function storedTheme() {
+  try {
+    return localStorage.getItem("codexbar-theme");
+  } catch (_) {
+    return null;
+  }
+}
+
+function effectiveTheme() {
+  return root.dataset.theme || (media.matches ? "dark" : "light");
+}
+
+function updateThemeImages(theme) {
+  document.querySelectorAll("img[data-dark-src]").forEach((image) => {
+    if (!image.dataset.lightSrc) image.dataset.lightSrc = image.getAttribute("src");
+    image.setAttribute("src", theme === "dark" ? image.dataset.darkSrc : image.dataset.lightSrc);
+  });
+}
+
+function updateThemeUI() {
+  const theme = effectiveTheme();
+  updateThemeImages(theme);
+  if (toggle) {
+    const label = message(theme === "dark" ? "theme.toLight" : "theme.toDark");
+    toggle.setAttribute("aria-pressed", theme === "dark" ? "true" : "false");
+    toggle.setAttribute("aria-label", label);
+    toggle.title = label;
+  }
+  metaTheme?.setAttribute("content", theme === "dark" ? "#0a0a0c" : "#fbfbfc");
+}
+
+toggle?.addEventListener("click", () => {
+  const next = effectiveTheme() === "dark" ? "light" : "dark";
+  root.dataset.theme = next;
+  try {
+    localStorage.setItem("codexbar-theme", next);
+  } catch (_) {}
+  updateThemeUI();
+});
+
+media.addEventListener?.("change", () => {
+  if (!queryTheme() && !storedTheme()) updateThemeUI();
+});
+
+languageSelect?.addEventListener("change", () => {
+  const locale = normalizeLocale(languageSelect.value) || "en";
+  try {
+    localStorage.setItem("codexbar-language", locale);
+    const url = new URL(location.href);
+    url.searchParams.set("lang", locale);
+    history.replaceState(null, "", url);
+  } catch (_) {}
+  applyLocale(locale);
+});
+
+const copyButton = document.querySelector(".brew-copy");
+copyButton?.addEventListener("click", () => {
+  const text = document.getElementById("brew-cmd")?.textContent;
+  if (!text || !navigator.clipboard) return;
+  navigator.clipboard.writeText(text).then(() => {
+    copyButton.classList.add("copied");
+    copyButton.setAttribute("aria-label", message("clipboard.copied"));
+    setTimeout(() => {
+      copyButton.classList.remove("copied");
+      copyButton.setAttribute("aria-label", message("clipboard.copy"));
+    }, 1500);
+  });
+});
+
+applyLocale(selectedLocale());
diff --git a/docs/social.html b/docs/social.html
new file mode 100644
index 0000000000..27ff60a245
--- /dev/null
+++ b/docs/social.html
@@ -0,0 +1,242 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>CodexBar social card</title>
+    <style>
+      html, body { margin: 0; padding: 0; }
+      body {
+        width: 1200px;
+        height: 630px;
+        font-family: -apple-system, BlinkMacSystemFont, "SF Pro Text", "Inter", sans-serif;
+        background: #0a0a0c;
+        color: #f0f0f3;
+        overflow: hidden;
+        position: relative;
+        -webkit-font-smoothing: antialiased;
+      }
+
+      /* Aurora layer — static radial blobs matching the site */
+      .aurora {
+        position: absolute;
+        inset: 0;
+        z-index: 0;
+        overflow: hidden;
+      }
+      .blob {
+        position: absolute;
+        border-radius: 50%;
+        filter: blur(70px);
+      }
+      .b1 { width: 640px; height: 640px; left: -120px; top: -160px;
+            background: radial-gradient(circle at 50% 50%, #ff7a1a 0%, rgba(255,122,26,0) 60%);
+            opacity: 0.85; }
+      .b2 { width: 620px; height: 620px; right: -120px; top: -120px;
+            background: radial-gradient(circle at 50% 50%, #6e5aff 0%, rgba(110,90,255,0) 60%);
+            opacity: 0.85; }
+      .b3 { width: 520px; height: 520px; left: 380px; top: 240px;
+            background: radial-gradient(circle at 50% 50%, #16d3b4 0%, rgba(22,211,180,0) 60%);
+            opacity: 0.55; }
+      .b4 { width: 460px; height: 460px; right: 80px; top: 320px;
+            background: radial-gradient(circle at 50% 50%, #ff3d8b 0%, rgba(255,61,139,0) 60%);
+            opacity: 0.55; }
+
+      /* Dot grid with radial mask */
+      .grid-bg {
+        position: absolute;
+        inset: 0;
+        z-index: 1;
+        pointer-events: none;
+        background-image:
+          linear-gradient(rgba(255, 255, 255, 0.05) 1px, transparent 1px),
+          linear-gradient(90deg, rgba(255, 255, 255, 0.05) 1px, transparent 1px);
+        background-size: 28px 28px;
+        background-position: -1px -1px;
+        -webkit-mask-image: radial-gradient(ellipse 90% 80% at 50% 0%, black, transparent 78%);
+                mask-image: radial-gradient(ellipse 90% 80% at 50% 0%, black, transparent 78%);
+      }
+
+      /* Subtle noise texture */
+      .noise {
+        position: absolute;
+        inset: 0;
+        z-index: 2;
+        pointer-events: none;
+        opacity: 0.35;
+        mix-blend-mode: soft-light;
+        background-image: url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='160' height='160'><filter id='n'><feTurbulence type='fractalNoise' baseFrequency='0.9' numOctaves='2' stitchTiles='stitch'/><feColorMatrix values='0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.55 0'/></filter><rect width='100%25' height='100%25' filter='url(%23n)'/></svg>");
+      }
+
+      .frame {
+        position: relative;
+        z-index: 3;
+        padding: 44px 56px 40px;
+        height: 100%;
+        display: flex;
+        flex-direction: column;
+        gap: 20px;
+        box-sizing: border-box;
+      }
+
+      .top {
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+      }
+      .brand {
+        display: flex;
+        align-items: center;
+        gap: 12px;
+        font-size: 19px;
+        font-weight: 600;
+        letter-spacing: 0;
+      }
+      .brand img { width: 32px; height: 32px; border-radius: 8px; }
+      .url {
+        font-size: 15px;
+        color: #b6bdc6;
+        letter-spacing: 0.04em;
+        text-transform: lowercase;
+        padding: 6px 14px;
+        border: 1px solid rgba(255, 255, 255, 0.14);
+        border-radius: 999px;
+        background: rgba(255, 255, 255, 0.04);
+      }
+
+      h1 {
+        margin: 0;
+        font-size: 60px;
+        line-height: 1.02;
+        letter-spacing: -0.028em;
+        font-weight: 600;
+        max-width: 22ch;
+      }
+      h1 .grad {
+        background-image: linear-gradient(100deg, #ff7a1a 0%, #ff3d8b 32%, #6e5aff 62%, #16d3b4 100%);
+        -webkit-background-clip: text;
+                background-clip: text;
+        color: transparent;
+      }
+      .sub {
+        margin: 12px 0 0;
+        font-size: 20px;
+        color: #b6bdc6;
+        letter-spacing: -0.005em;
+      }
+      .sub strong { color: #f0f0f3; font-weight: 600; }
+      .sub .dot { color: #5b6068; padding: 0 10px; }
+
+      .grid {
+        list-style: none;
+        margin: 0;
+        padding: 0;
+        display: grid;
+        grid-template-columns: repeat(8, 1fr);
+        gap: 8px;
+        align-content: end;
+      }
+      .grid li { margin: 0; }
+
+      .tile {
+        --ink: #fff;
+        display: flex;
+        align-items: center;
+        gap: 8px;
+        padding: 7px 9px;
+        border: 1px solid rgba(255, 255, 255, 0.08);
+        border-radius: 10px;
+        background: rgba(19, 20, 24, 0.72);
+        height: 50px;
+        backdrop-filter: blur(6px) saturate(140%);
+        -webkit-backdrop-filter: blur(6px) saturate(140%);
+        box-shadow: 0 1px 0 rgba(255, 255, 255, 0.04) inset;
+      }
+      .chip {
+        width: 34px;
+        height: 34px;
+        border-radius: 8px;
+        display: grid;
+        place-items: center;
+        background: var(--brand);
+        color: var(--ink);
+        font-weight: 700;
+        font-size: 17px;
+        letter-spacing: -0.02em;
+        flex-shrink: 0;
+        box-shadow:
+          inset 0 1px 0 rgba(255, 255, 255, 0.22),
+          inset 0 -1px 0 rgba(0, 0, 0, 0.18);
+      }
+      .name {
+        font-size: 13px;
+        font-weight: 500;
+        line-height: 1.15;
+        color: #f0f0f3;
+        white-space: nowrap;
+        overflow: hidden;
+        text-overflow: ellipsis;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="aurora">
+      <span class="blob b1"></span>
+      <span class="blob b2"></span>
+      <span class="blob b3"></span>
+      <span class="blob b4"></span>
+    </div>
+    <div class="grid-bg"></div>
+    <div class="noise"></div>
+
+    <div class="frame">
+      <div class="top">
+        <div class="brand">
+          <img src="./icon.png" alt="" />
+          <span>CodexBar</span>
+        </div>
+        <div class="url">codexbar.app</div>
+      </div>
+
+      <div>
+        <h1>Every AI coding limit, <span class="grad">in your menu&nbsp;bar.</span></h1>
+        <p class="sub"><strong>53 providers</strong><span class="dot">·</span>usage windows, credits, resets<span class="dot">·</span>one status item each, or merged.</p>
+      </div>
+
+      <ul class="grid">
+        <li><div class="tile" style="--brand:#49A3B0"><div class="chip">C</div><div class="name">Codex</div></div></li>
+        <li><div class="tile" style="--brand:#CC7C5E"><div class="chip">C</div><div class="name">Claude</div></div></li>
+        <li><div class="tile" style="--brand:#1A1A1A"><div class="chip">C</div><div class="name">Cursor</div></div></li>
+        <li><div class="tile" style="--brand:#3B82F6"><div class="chip">O</div><div class="name">OpenCode</div></div></li>
+        <li><div class="tile" style="--brand:#FF6A00"><div class="chip">A</div><div class="name">Alibaba</div></div></li>
+        <li><div class="tile" style="--brand:#AB87EA"><div class="chip">G</div><div class="name">Gemini</div></div></li>
+        <li><div class="tile" style="--brand:#60BA7E"><div class="chip">A</div><div class="name">Antigravity</div></div></li>
+
+        <li><div class="tile" style="--brand:#FF6B35"><div class="chip">D</div><div class="name">Droid</div></div></li>
+        <li><div class="tile" style="--brand:#A855F7"><div class="chip">C</div><div class="name">Copilot</div></div></li>
+        <li><div class="tile" style="--brand:#E85A6A"><div class="chip">z</div><div class="name">z.ai</div></div></li>
+        <li><div class="tile" style="--brand:#FE6060"><div class="chip">M</div><div class="name">MiniMax</div></div></li>
+        <li><div class="tile" style="--brand:#FE603C"><div class="chip">K</div><div class="name">Kimi</div></div></li>
+        <li><div class="tile" style="--brand:#4C00FF"><div class="chip">K</div><div class="name">Kimi K2 Legacy</div></div></li>
+        <li><div class="tile" style="--brand:#F27027"><div class="chip">K</div><div class="name">Kilo</div></div></li>
+        <li><div class="tile" style="--brand:#FF9900;--ink:#0a0a0c"><div class="chip">K</div><div class="name">Kiro</div></div></li>
+
+        <li><div class="tile" style="--brand:#4285F4"><div class="chip">V</div><div class="name">Vertex AI</div></div></li>
+        <li><div class="tile" style="--brand:#6366F1"><div class="chip">A</div><div class="name">Augment</div></div></li>
+        <li><div class="tile" style="--brand:#DC2626"><div class="chip">A</div><div class="name">Amp</div></div></li>
+        <li><div class="tile" style="--brand:#888888"><div class="chip">O</div><div class="name">Ollama</div></div></li>
+        <li><div class="tile" style="--brand:#141414"><div class="chip">S</div><div class="name">Synthetic</div></div></li>
+        <li><div class="tile" style="--brand:#FF3399"><div class="chip">J</div><div class="name">JetBrains AI</div></div></li>
+        <li><div class="tile" style="--brand:#7B68EE"><div class="chip">W</div><div class="name">Warp</div></div></li>
+        <li><div class="tile" style="--brand:#EAEAE6;--ink:#0a0a0c"><div class="chip">E</div><div class="name">ElevenLabs</div></div></li>
+        <li><div class="tile" style="--brand:#6467F2"><div class="chip">O</div><div class="name">OpenRouter</div></div></li>
+
+        <li><div class="tile" style="--brand:#20B2AA"><div class="chip">P</div><div class="name">Perplexity</div></div></li>
+        <li><div class="tile" style="--brand:#38BDF8"><div class="chip">A</div><div class="name">Abacus AI</div></div></li>
+        <li><div class="tile" style="--brand:#FF500F"><div class="chip">M</div><div class="name">Mistral</div></div></li>
+        <li><div class="tile" style="--brand:#527DF0"><div class="chip">D</div><div class="name">DeepSeek</div></div></li>
+        <li><div class="tile" style="--brand:#44C800;--ink:#0a0a0c"><div class="chip">C</div><div class="name">Codebuff</div></div></li>
+        <li><div class="tile" style="--brand:#4C89F0"><div class="chip">LL</div><div class="name">LiteLLM</div></div></li>
+      </ul>
+    </div>
+  </body>
+</html>
diff --git a/docs/social.png b/docs/social.png
new file mode 100644
index 0000000000..01032c364c
Binary files /dev/null and b/docs/social.png differ
diff --git a/docs/solutions/performance-issues/openai-web-extras-default-off-codexbar-20260307.md b/docs/solutions/performance-issues/openai-web-extras-default-off-codexbar-20260307.md
new file mode 100644
index 0000000000..bba17d53f3
--- /dev/null
+++ b/docs/solutions/performance-issues/openai-web-extras-default-off-codexbar-20260307.md
@@ -0,0 +1,72 @@
+---
+module: CodexBar
+date: 2026-03-07
+summary: "OpenAI web extras battery-drain fix: default optional hidden WebView work off."
+read_when:
+  - Investigating OpenAI web extras battery or energy impact
+  - Changing Codex OpenAI web extras defaults
+  - Reviewing hidden WebView performance safeguards
+problem_type: performance_issue
+component: tooling
+symptoms:
+  - "Hidden chatgpt.com web content could spike to extremely high Energy Impact values in Activity Monitor"
+  - "CodexBar battery usage stayed abnormally high even when the app appeared idle"
+  - "Users did not realize optional OpenAI web extras were enabled by default"
+root_cause: wrong_api
+resolution_type: config_change
+severity: high
+tags: [codexbar, battery-drain, openai-web, webview, chatgpt, defaults]
+---
+
+# Troubleshooting: Default OpenAI Web Extras Off
+
+## Problem
+CodexBar exposed optional OpenAI dashboard extras through a hidden `chatgpt.com` WebView, but the feature was enabled by default. That created a mismatch between user expectations for a lightweight menu bar app and the real cost of running a hidden single-page web app in the background.
+
+## Environment
+- Module: CodexBar
+- Affected component: Codex OpenAI web extras
+- Date: 2026-03-07
+
+## Symptoms
+- Activity Monitor showed extreme energy usage attributed to `https://chatgpt.com` under the CodexBar process tree.
+- Users observed battery drain that was out of proportion to the visible work the app was doing.
+- The optional setting existed, but it was easy to miss, so affected users often did not know they could disable it.
+
+## What Didn't Work
+
+**Attempted solution 1:** Throttle failed OpenAI dashboard refresh attempts and evict cached WebViews more aggressively.
+- **Why it failed:** This reduced the runaway failure loop, but it did not change the product default. Users could still pay the cost of a hidden ChatGPT dashboard without explicitly opting into it.
+
+**Attempted solution 2:** Keep the feature enabled by default and rely on a visible opt-out toggle.
+- **Why it failed:** The battery and network cost was too high for a background utility. An opt-out-only design still left many users exposed to behavior they did not expect or understand.
+
+## Solution
+Change OpenAI web extras to be off by default for new installs while preserving existing explicit configurations.
+
+**Code changes**
+- `SettingsStore` now defaults `openAIWebAccessEnabled` to `false` when no prior preference exists.
+- `SettingsStore` now defaults `openAIWebBatterySaverEnabled` to `false`; users can still opt into reduced routine OpenAI web refreshes separately.
+- Existing users with an explicit Codex cookie configuration are inferred as enabled so upgrades do not silently break working setups.
+- The Codex settings copy now describes the feature as optional and warns about battery and network cost.
+- Documentation now labels the OpenAI web dashboard path as optional and off by default.
+
+## Why This Works
+The root problem was not that the app had a toggle. The root problem was that an optional feature with heavyweight implementation details was enabled by default.
+
+The OpenAI web extras path uses a hidden `WKWebView` against `chatgpt.com` to gather dashboard-only data. That mechanism is fundamentally more expensive than the main Codex data paths, which already provide the normal information users expect from the app: session usage, weekly usage, reset timers, account identity, plan label, and normal credits remaining.
+
+Making the feature opt-in aligns the default behavior with the actual technical cost:
+1. The normal Codex card continues to work without the hidden ChatGPT dashboard.
+2. Users only incur the WebView cost if they deliberately choose the extra dashboard data.
+3. Existing users with a configured Codex web setup keep their behavior on upgrade instead of being silently broken.
+
+## Prevention
+- Do not default-enable optional features that load heavyweight hidden web content in a background utility.
+- If a feature depends on a hidden SPA or WebView, require explicit user opt-in unless it is essential to core functionality.
+- Prefer direct API or cookie-backed HTTP requests over hidden browser automation for background data collection.
+- Surface the operational cost of optional features in the settings copy, not only in debug notes or issue threads.
+
+## Related Issues
+- See also: [perf-energy-issue-139-simulation-report-2026-02-19.md](../../perf-energy-issue-139-simulation-report-2026-02-19.md)
+- See also: [perf-energy-issue-139-main-fix-validation-2026-02-19.md](../../perf-energy-issue-139-main-fix-validation-2026-02-19.md)
diff --git a/docs/sparkle.md b/docs/sparkle.md
index 5aeed10d1e..3f43c0bc33 100644
--- a/docs/sparkle.md
+++ b/docs/sparkle.md
@@ -17,7 +17,7 @@ read_when:
 - Channels: stable vs beta are served from the same appcast. Beta items are tagged with `sparkle:channel="beta"`; About → Update Channel controls `allowedChannels`.
 
 ## Release flow
-1) Build & notarize as usual (`./Scripts/sign-and-notarize.sh`), producing notarized `CodexBar-<ver>.zip`.
+1) Build & notarize as usual (`./Scripts/sign-and-notarize.sh`), producing notarized `CodexBar-macos-universal-<ver>.zip`.
 2) Generate appcast entry with Sparkle `generate_appcast` using the Ed25519 private key; HTML release notes come from `CHANGELOG.md` via `Scripts/changelog-to-html.sh`. For beta releases: set `SPARKLE_CHANNEL=beta` to tag the entry.
 3) Upload `appcast.xml` + zip to GitHub Releases (feed URL stays stable).
 4) Tag/release.
diff --git a/docs/stepfun.md b/docs/stepfun.md
new file mode 100644
index 0000000000..cba78d33d2
--- /dev/null
+++ b/docs/stepfun.md
@@ -0,0 +1,57 @@
+---
+summary: "StepFun provider data sources: username + password login for Step Plan rate limits and subscription plan name."
+read_when:
+  - Adding or tweaking StepFun rate limit parsing
+  - Updating StepFun login flow
+  - Documenting new provider behavior
+---
+
+# StepFun provider
+
+StepFun (阶跃星辰) is a web-based provider. Usage data comes from the Step Plan rate limit API,
+authenticated via an Oasis-Token obtained through a username + password login flow.
+
+## Data sources
+
+1. **Authentication** — Three methods (in priority order):
+   - **Auto mode**: Username + password entered in Settings → Providers → StepFun.
+     CodexBar performs a 3-step login flow to obtain an Oasis-Token:
+       1. `GET https://platform.stepfun.com` → `INGRESSCOOKIE`
+       2. `POST …/RegisterDevice` → anonymous token
+       3. `POST …/SignInByPassword` → authenticated Oasis-Token
+     The token is cached in Keychain-backed `CookieHeaderCache` and reused until it expires.
+   - **Manual mode**: Paste an Oasis-Token directly in Settings → Providers → StepFun.
+   - **Environment variables**: `STEPFUN_USERNAME` + `STEPFUN_PASSWORD`, or `STEPFUN_TOKEN`.
+
+2. **Rate limit endpoint**
+   - `POST https://platform.stepfun.com/api/step.openapi.devcenter.Dashboard/QueryStepPlanRateLimit`
+   - Request headers: `Cookie: Oasis-Token=<token>`, `Content-Type: application/json`
+   - Response fields:
+     - `five_hour_usage_left_rate` — remaining fraction for the 5-hour window (e.g. `0.99781543`)
+     - `weekly_usage_left_rate` — remaining fraction for the weekly window
+     - `five_hour_usage_reset_time` — reset timestamp (string or integer)
+     - `weekly_usage_reset_time` — reset timestamp (string or integer)
+
+3. **Plan status endpoint**
+   - `POST https://platform.stepfun.com/api/step.openapi.devcenter.Dashboard/GetStepPlanStatus`
+   - Same auth headers as above
+   - Response → `subscription.name` → plan name (e.g. "Plus", "Mini")
+   - If this request fails, usage data is still displayed without a plan name.
+
+## Usage details
+
+- **Primary window** (top bar): 5-hour rate limit (300 minutes).
+- **Secondary window** (bottom bar): weekly rate limit (10 080 minutes).
+- `usedPercent` is computed as `(1.0 - left_rate) × 100`.
+- Plan name is shown as the `loginMethod` label in the menu card (e.g. "Plus").
+- When auth source is set to **Off**, no background refreshes occur.
+- Token expiry triggers automatic re-login (cache is cleared and the 3-step flow runs again).
+
+## Key files
+
+- `Sources/CodexBarCore/Providers/StepFun/StepFunProviderDescriptor.swift` (descriptor + web fetch strategy)
+- `Sources/CodexBarCore/Providers/StepFun/StepFunUsageFetcher.swift` (login flow + HTTP client + JSON parser)
+- `Sources/CodexBarCore/Providers/StepFun/StepFunSettingsReader.swift` (env var resolution)
+- `Sources/CodexBar/Providers/StepFun/StepFunProviderImplementation.swift` (settings fields + activation logic)
+- `Sources/CodexBar/Providers/StepFun/StepFunSettingsStore.swift` (SettingsStore extension)
+- `Tests/CodexBarTests/StepFunUsageFetcherTests.swift` (22 test cases)
diff --git a/docs/superpowers/plans/2026-05-11-kilo-organization-selection.md b/docs/superpowers/plans/2026-05-11-kilo-organization-selection.md
new file mode 100644
index 0000000000..96542a6ff2
--- /dev/null
+++ b/docs/superpowers/plans/2026-05-11-kilo-organization-selection.md
@@ -0,0 +1,1490 @@
+---
+summary: "Implementation plan for Kilo organization selection and stacked organization usage cards."
+read_when:
+  - Implementing Kilo organization selection
+  - Updating Kilo organization-scoped usage fetching
+  - Planning stacked Kilo personal and organization menu cards
+---
+
+# Kilo Organization Selection Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Let CodexBar users opt in to one or more Kilo organizations from Preferences → Providers → Kilo. Enabled orgs render as stacked cards alongside their personal account in the Kilo menu.
+
+**Architecture:** Add `KiloUsageScope` and `KiloOrganization` types in `CodexBarCore`. Inject `X-KILOCODE-ORGANIZATIONID` header in `KiloUsageFetcher` when a scope is `.organization`. Persist known orgs and enabled-ids in `ProviderConfig` JSON. Mirror the existing tokenAccounts pattern in `UsageStore` to fan out a fetch per enabled scope and store stacked snapshots. Render via the existing stacked-snapshot menu pipeline by surfacing a Kilo-scoped accounts adapter.
+
+**Tech Stack:** Swift 6, SwiftUI, Swift Testing (`@Test`), `swift build` / `swift test` / `make check`, GitHub CLI for PR.
+
+**Spec:** `docs/superpowers/specs/2026-05-11-kilo-organization-selection-design.md`
+
+---
+
+## Pre-flight (lead-only — do BEFORE dispatching tasks)
+
+- [ ] **Step 0.1: Confirm clean working tree on `main`**
+
+```bash
+git status
+```
+
+Expected output: `nothing to commit, working tree clean` on branch `main` (the spec commit `c24e58a4` is already in).
+
+- [ ] **Step 0.2: Create feature branch**
+
+```bash
+git switch -c feat/kilo-organization-selection
+```
+
+- [ ] **Step 0.3: Verify Swift toolchain and tests baseline**
+
+```bash
+swift build 2>&1 | tail -5
+swift test --filter KiloUsageFetcherTests 2>&1 | tail -10
+```
+
+Expected: build succeeds, KiloUsageFetcher tests pass.
+
+---
+
+## Task 1: Add `KiloOrganization` data type
+
+**Files:**
+- Create: `Sources/CodexBarCore/Providers/Kilo/KiloOrganization.swift`
+- Create: `Tests/CodexBarTests/KiloOrganizationTests.swift`
+
+- [ ] **Step 1.1: Write the failing test**
+
+Create `Tests/CodexBarTests/KiloOrganizationTests.swift`:
+
+```swift
+import Foundation
+import Testing
+@testable import CodexBarCore
+
+struct KiloOrganizationTests {
+    @Test
+    func `decodes from canonical Kilo profile payload`() throws {
+        let json = #"""
+        { "id": "org_123", "name": "Acme Corp", "role": "owner" }
+        """#
+        let data = Data(json.utf8)
+        let org = try JSONDecoder().decode(KiloOrganization.self, from: data)
+        #expect(org.id == "org_123")
+        #expect(org.name == "Acme Corp")
+        #expect(org.role == "owner")
+    }
+
+    @Test
+    func `decodes when role missing`() throws {
+        let json = #"""
+        { "id": "org_xyz", "name": "No Role Org" }
+        """#
+        let data = Data(json.utf8)
+        let org = try JSONDecoder().decode(KiloOrganization.self, from: data)
+        #expect(org.role == nil)
+    }
+
+    @Test
+    func `equality covers all stored fields`() {
+        let a = KiloOrganization(id: "org_1", name: "A", role: "member")
+        let b = KiloOrganization(id: "org_1", name: "A", role: "member")
+        let differentRole = KiloOrganization(id: "org_1", name: "A", role: "owner")
+        #expect(a == b)
+        #expect(a != differentRole)
+    }
+}
+```
+
+- [ ] **Step 1.2: Run test to verify it fails**
+
+```bash
+swift test --filter KiloOrganizationTests 2>&1 | tail -10
+```
+
+Expected: compile error "cannot find 'KiloOrganization' in scope".
+
+- [ ] **Step 1.3: Create the type**
+
+Create `Sources/CodexBarCore/Providers/Kilo/KiloOrganization.swift`:
+
+```swift
+import Foundation
+
+public struct KiloOrganization: Codable, Sendable, Equatable, Hashable, Identifiable {
+    public let id: String
+    public let name: String
+    public let role: String?
+
+    public init(id: String, name: String, role: String? = nil) {
+        self.id = id
+        self.name = name
+        self.role = role
+    }
+}
+```
+
+- [ ] **Step 1.4: Run tests, verify pass**
+
+```bash
+swift test --filter KiloOrganizationTests 2>&1 | tail -10
+```
+
+Expected: all 3 tests pass.
+
+- [ ] **Step 1.5: Commit**
+
+```bash
+git add Sources/CodexBarCore/Providers/Kilo/KiloOrganization.swift \
+        Tests/CodexBarTests/KiloOrganizationTests.swift
+git commit -m "feat(kilo): add KiloOrganization model"
+```
+
+---
+
+## Task 2: Add `KiloUsageScope` enum
+
+**Files:**
+- Create: `Sources/CodexBarCore/Providers/Kilo/KiloUsageScope.swift`
+- Modify: `Tests/CodexBarTests/KiloOrganizationTests.swift`
+
+- [ ] **Step 2.1: Append failing tests**
+
+Append to `Tests/CodexBarTests/KiloOrganizationTests.swift`:
+
+```swift
+struct KiloUsageScopeTests {
+    @Test
+    func `personal scope identifier is stable`() {
+        let scope: KiloUsageScope = .personal
+        #expect(scope.scopeIdentifier == "personal")
+    }
+
+    @Test
+    func `organization scope identifier prefixes id`() {
+        let scope: KiloUsageScope = .organization(id: "org_42", name: "Acme")
+        #expect(scope.scopeIdentifier == "org:org_42")
+    }
+
+    @Test
+    func `organizationID is nil for personal`() {
+        #expect(KiloUsageScope.personal.organizationID == nil)
+    }
+
+    @Test
+    func `organizationID returns id for organization`() {
+        let scope: KiloUsageScope = .organization(id: "org_42", name: "Acme")
+        #expect(scope.organizationID == "org_42")
+    }
+
+    @Test
+    func `displayName falls back to Personal for personal`() {
+        #expect(KiloUsageScope.personal.displayName == "Personal")
+    }
+
+    @Test
+    func `displayName uses org name for organization`() {
+        let scope: KiloUsageScope = .organization(id: "org_42", name: "Acme")
+        #expect(scope.displayName == "Acme")
+    }
+}
+```
+
+- [ ] **Step 2.2: Run test, verify it fails**
+
+```bash
+swift test --filter KiloUsageScopeTests 2>&1 | tail -10
+```
+
+Expected: compile error "cannot find 'KiloUsageScope' in scope".
+
+- [ ] **Step 2.3: Create the type**
+
+Create `Sources/CodexBarCore/Providers/Kilo/KiloUsageScope.swift`:
+
+```swift
+import Foundation
+
+public enum KiloUsageScope: Sendable, Hashable, Equatable {
+    case personal
+    case organization(id: String, name: String)
+
+    public var scopeIdentifier: String {
+        switch self {
+        case .personal:
+            "personal"
+        case let .organization(id, _):
+            "org:\(id)"
+        }
+    }
+
+    public var organizationID: String? {
+        switch self {
+        case .personal:
+            nil
+        case let .organization(id, _):
+            id
+        }
+    }
+
+    public var displayName: String {
+        switch self {
+        case .personal:
+            "Personal"
+        case let .organization(_, name):
+            name
+        }
+    }
+}
+```
+
+- [ ] **Step 2.4: Run tests, verify pass**
+
+```bash
+swift test --filter KiloUsageScopeTests 2>&1 | tail -10
+```
+
+Expected: all 6 tests pass.
+
+- [ ] **Step 2.5: Commit**
+
+```bash
+git add Sources/CodexBarCore/Providers/Kilo/KiloUsageScope.swift \
+        Tests/CodexBarTests/KiloOrganizationTests.swift
+git commit -m "feat(kilo): add KiloUsageScope enum"
+```
+
+---
+
+## Task 3: Inject org header in `KiloUsageFetcher.fetchUsage`
+
+**Files:**
+- Modify: `Sources/CodexBarCore/Providers/Kilo/KiloUsageFetcher.swift`
+- Modify: `Tests/CodexBarTests/KiloUsageFetcherTests.swift`
+
+- [ ] **Step 3.1: Append failing test for header injection**
+
+Append the following inside `struct KiloUsageFetcherTests` in `Tests/CodexBarTests/KiloUsageFetcherTests.swift`:
+
+```swift
+    @Test
+    func `request builder adds org header for organization scope`() throws {
+        let baseURL = try #require(URL(string: "https://kilo.example/trpc"))
+        let request = try KiloUsageFetcher._buildRequestForTesting(
+            baseURL: baseURL,
+            apiKey: "test-token",
+            scope: .organization(id: "org_42", name: "Acme"))
+        #expect(request.value(forHTTPHeaderField: "X-KILOCODE-ORGANIZATIONID") == "org_42")
+        #expect(request.value(forHTTPHeaderField: "Authorization") == "Bearer test-token")
+    }
+
+    @Test
+    func `request builder omits org header for personal scope`() throws {
+        let baseURL = try #require(URL(string: "https://kilo.example/trpc"))
+        let request = try KiloUsageFetcher._buildRequestForTesting(
+            baseURL: baseURL,
+            apiKey: "test-token",
+            scope: .personal)
+        #expect(request.value(forHTTPHeaderField: "X-KILOCODE-ORGANIZATIONID") == nil)
+        #expect(request.value(forHTTPHeaderField: "Authorization") == "Bearer test-token")
+    }
+```
+
+- [ ] **Step 3.2: Run test, verify it fails**
+
+```bash
+swift test --filter KiloUsageFetcherTests 2>&1 | tail -15
+```
+
+Expected: compile error — `_buildRequestForTesting` not found.
+
+- [ ] **Step 3.3: Refactor `KiloUsageFetcher` to accept scope and extract request builder**
+
+In `Sources/CodexBarCore/Providers/Kilo/KiloUsageFetcher.swift`:
+
+Replace the existing `public static func fetchUsage(apiKey:environment:)` signature (around line 258) with the scoped version, and extract the request building into a testable helper. The new code:
+
+```swift
+    public static func fetchUsage(
+        apiKey: String,
+        scope: KiloUsageScope = .personal,
+        environment: [String: String] = ProcessInfo.processInfo.environment) async throws -> KiloUsageSnapshot
+    {
+        guard !apiKey.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+            throw KiloUsageError.missingCredentials
+        }
+
+        let baseURL = KiloSettingsReader.apiURL(environment: environment)
+        let request = try self.makeRequest(baseURL: baseURL, apiKey: apiKey, scope: scope)
+
+        let data: Data
+        let response: URLResponse
+        do {
+            (data, response) = try await URLSession.shared.data(for: request)
+        } catch {
+            throw KiloUsageError.networkError(error.localizedDescription)
+        }
+
+        guard let httpResponse = response as? HTTPURLResponse else {
+            throw KiloUsageError.networkError("Invalid response")
+        }
+
+        if let mapped = self.statusError(for: httpResponse.statusCode) {
+            throw mapped
+        }
+
+        guard httpResponse.statusCode == 200 else {
+            throw KiloUsageError.apiError(httpResponse.statusCode)
+        }
+
+        return try self.parseSnapshot(data: data)
+    }
+
+    static func _buildRequestForTesting(
+        baseURL: URL,
+        apiKey: String,
+        scope: KiloUsageScope) throws -> URLRequest
+    {
+        try self.makeRequest(baseURL: baseURL, apiKey: apiKey, scope: scope)
+    }
+
+    private static func makeRequest(
+        baseURL: URL,
+        apiKey: String,
+        scope: KiloUsageScope) throws -> URLRequest
+    {
+        let batchURL = try self.makeBatchURL(baseURL: baseURL)
+        var request = URLRequest(url: batchURL)
+        request.httpMethod = "GET"
+        request.timeoutInterval = 15
+        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        if let orgId = scope.organizationID {
+            request.setValue(orgId, forHTTPHeaderField: "X-KILOCODE-ORGANIZATIONID")
+        }
+        return request
+    }
+```
+
+Then delete the old inline `var request = URLRequest(url: batchURL)` setup that lived in `fetchUsage` (it's now in `makeRequest`).
+
+- [ ] **Step 3.4: Run tests, verify pass**
+
+```bash
+swift test --filter KiloUsageFetcherTests 2>&1 | tail -15
+```
+
+Expected: all KiloUsageFetcher tests pass (existing + 2 new).
+
+- [ ] **Step 3.5: Commit**
+
+```bash
+git add Sources/CodexBarCore/Providers/Kilo/KiloUsageFetcher.swift \
+        Tests/CodexBarTests/KiloUsageFetcherTests.swift
+git commit -m "feat(kilo): scope KiloUsageFetcher.fetchUsage with org header"
+```
+
+---
+
+## Task 4: Add `fetchOrganizations` to `KiloUsageFetcher`
+
+**Files:**
+- Modify: `Sources/CodexBarCore/Providers/Kilo/KiloUsageFetcher.swift`
+- Modify: `Tests/CodexBarTests/KiloUsageFetcherTests.swift`
+
+- [ ] **Step 4.1: Append failing parse tests**
+
+Append inside `struct KiloUsageFetcherTests`:
+
+```swift
+    @Test
+    func `parseOrganizations decodes tRPC array shape`() throws {
+        let json = #"""
+        [
+          {
+            "result": {
+              "data": {
+                "json": [
+                  { "id": "org_1", "name": "Alpha", "role": "owner" },
+                  { "id": "org_2", "name": "Beta", "role": "member" }
+                ]
+              }
+            }
+          }
+        ]
+        """#
+        let orgs = try KiloUsageFetcher._parseOrganizationsForTesting(Data(json.utf8))
+        #expect(orgs.count == 2)
+        #expect(orgs[0].id == "org_1")
+        #expect(orgs[0].name == "Alpha")
+        #expect(orgs[0].role == "owner")
+        #expect(orgs[1].id == "org_2")
+        #expect(orgs[1].role == "member")
+    }
+
+    @Test
+    func `parseOrganizations decodes profile REST shape`() throws {
+        let json = #"""
+        {
+          "user": { "email": "test@example.com" },
+          "organizations": [
+            { "id": "org_42", "name": "Gamma" }
+          ]
+        }
+        """#
+        let orgs = try KiloUsageFetcher._parseOrganizationsForTesting(Data(json.utf8))
+        #expect(orgs.count == 1)
+        #expect(orgs[0].id == "org_42")
+        #expect(orgs[0].role == nil)
+    }
+
+    @Test
+    func `parseOrganizations returns empty for no orgs`() throws {
+        let json = #"""
+        { "user": { "email": "x@y" }, "organizations": [] }
+        """#
+        let orgs = try KiloUsageFetcher._parseOrganizationsForTesting(Data(json.utf8))
+        #expect(orgs.isEmpty)
+    }
+```
+
+- [ ] **Step 4.2: Run, verify fail**
+
+```bash
+swift test --filter KiloUsageFetcherTests 2>&1 | tail -10
+```
+
+Expected: compile error — `_parseOrganizationsForTesting` undefined.
+
+- [ ] **Step 4.3: Add organization fetching logic**
+
+Append to `Sources/CodexBarCore/Providers/Kilo/KiloUsageFetcher.swift` (inside the `KiloUsageFetcher` struct):
+
+```swift
+    public static func fetchOrganizations(
+        apiKey: String,
+        environment: [String: String] = ProcessInfo.processInfo.environment) async throws -> [KiloOrganization]
+    {
+        guard !apiKey.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+            throw KiloUsageError.missingCredentials
+        }
+
+        let baseURL = KiloSettingsReader.apiURL(environment: environment)
+        let trpcRequest = try self.makeOrgListTRPCRequest(baseURL: baseURL, apiKey: apiKey)
+
+        do {
+            let (data, response) = try await URLSession.shared.data(for: trpcRequest)
+            guard let httpResponse = response as? HTTPURLResponse else {
+                throw KiloUsageError.networkError("Invalid response")
+            }
+            if httpResponse.statusCode == 404 {
+                return try await self.fetchOrganizationsRESTFallback(apiKey: apiKey)
+            }
+            if let mapped = self.statusError(for: httpResponse.statusCode) {
+                throw mapped
+            }
+            return try self.parseOrganizations(data: data)
+        } catch let error as KiloUsageError {
+            throw error
+        } catch {
+            throw KiloUsageError.networkError(error.localizedDescription)
+        }
+    }
+
+    static func _parseOrganizationsForTesting(_ data: Data) throws -> [KiloOrganization] {
+        try self.parseOrganizations(data: data)
+    }
+
+    private static func makeOrgListTRPCRequest(
+        baseURL: URL,
+        apiKey: String) throws -> URLRequest
+    {
+        let endpoint = baseURL.appendingPathComponent("user.getOrganizations")
+        let inputData = try JSONSerialization.data(
+            withJSONObject: ["0": ["json": NSNull()]] as [String: Any])
+        guard let inputString = String(data: inputData, encoding: .utf8),
+              var components = URLComponents(url: endpoint, resolvingAgainstBaseURL: false) else {
+            throw KiloUsageError.parseFailed("Invalid org list endpoint")
+        }
+        components.queryItems = [
+            URLQueryItem(name: "batch", value: "1"),
+            URLQueryItem(name: "input", value: inputString),
+        ]
+        guard let url = components.url else {
+            throw KiloUsageError.parseFailed("Invalid org list endpoint")
+        }
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.timeoutInterval = 15
+        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        return request
+    }
+
+    private static func fetchOrganizationsRESTFallback(apiKey: String) async throws -> [KiloOrganization] {
+        guard let url = URL(string: "https://api.kilo.ai/api/profile") else {
+            throw KiloUsageError.parseFailed("Invalid REST fallback URL")
+        }
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.timeoutInterval = 15
+        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+
+        let (data, response) = try await URLSession.shared.data(for: request)
+        guard let httpResponse = response as? HTTPURLResponse else {
+            throw KiloUsageError.networkError("Invalid response")
+        }
+        if let mapped = self.statusError(for: httpResponse.statusCode) {
+            throw mapped
+        }
+        guard httpResponse.statusCode == 200 else {
+            throw KiloUsageError.apiError(httpResponse.statusCode)
+        }
+        return try self.parseOrganizations(data: data)
+    }
+
+    private static func parseOrganizations(data: Data) throws -> [KiloOrganization] {
+        guard let root = try? JSONSerialization.jsonObject(with: data) else {
+            throw KiloUsageError.parseFailed("Invalid JSON")
+        }
+
+        // tRPC batch shape: [ { result: { data: { json: [orgs] } } } ]
+        if let entries = root as? [[String: Any]],
+           let first = entries.first,
+           let resultObject = first["result"] as? [String: Any]
+        {
+            if let dataObject = resultObject["data"] as? [String: Any],
+               let payload = dataObject["json"] as? [[String: Any]]
+            {
+                return self.decodeOrganizations(payload)
+            }
+            if let payload = resultObject["data"] as? [[String: Any]] {
+                return self.decodeOrganizations(payload)
+            }
+        }
+
+        // REST profile shape: { user: ..., organizations: [orgs] }
+        if let dictionary = root as? [String: Any] {
+            if let orgs = dictionary["organizations"] as? [[String: Any]] {
+                return self.decodeOrganizations(orgs)
+            }
+            // Some single-procedure tRPC shapes flatten to { result: { data: { json: { organizations: [...] }}}}
+            if let resultObject = dictionary["result"] as? [String: Any],
+               let dataObject = resultObject["data"] as? [String: Any]
+            {
+                if let payload = dataObject["json"] as? [[String: Any]] {
+                    return self.decodeOrganizations(payload)
+                }
+                if let payload = dataObject["json"] as? [String: Any],
+                   let orgs = payload["organizations"] as? [[String: Any]]
+                {
+                    return self.decodeOrganizations(orgs)
+                }
+            }
+        }
+
+        return []
+    }
+
+    private static func decodeOrganizations(_ raw: [[String: Any]]) -> [KiloOrganization] {
+        raw.compactMap { item -> KiloOrganization? in
+            guard let id = item["id"] as? String, !id.isEmpty else { return nil }
+            let name = (item["name"] as? String).map {
+                $0.trimmingCharacters(in: .whitespacesAndNewlines)
+            } ?? id
+            let role = (item["role"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines)
+            let normalizedRole = (role?.isEmpty ?? true) ? nil : role
+            return KiloOrganization(id: id, name: name.isEmpty ? id : name, role: normalizedRole)
+        }
+    }
+```
+
+- [ ] **Step 4.4: Run tests, verify pass**
+
+```bash
+swift test --filter KiloUsageFetcherTests 2>&1 | tail -15
+```
+
+Expected: all 3 new parse tests pass plus prior tests.
+
+- [ ] **Step 4.5: Commit**
+
+```bash
+git add Sources/CodexBarCore/Providers/Kilo/KiloUsageFetcher.swift \
+        Tests/CodexBarTests/KiloUsageFetcherTests.swift
+git commit -m "feat(kilo): add fetchOrganizations with REST fallback"
+```
+
+---
+
+## Task 5: Extend `ProviderConfig` with `kiloOrganizations`
+
+**Files:**
+- Modify: `Sources/CodexBarCore/Config/CodexBarConfig.swift`
+- Tests: covered indirectly via Task 6 SettingsStore tests.
+
+- [ ] **Step 5.1: Add fields to `ProviderConfig`**
+
+In `Sources/CodexBarCore/Config/CodexBarConfig.swift`, inside `public struct ProviderConfig`:
+
+After the existing `public var quotaWarnings: QuotaWarningConfig?` line, add:
+
+```swift
+    public var kiloKnownOrganizations: [KiloOrganization]?
+    public var kiloEnabledOrganizationIDs: [String]?
+```
+
+Then extend the `init` signature with these matching parameters (defaulted to `nil`) and assign them in the body. Match the existing init ordering pattern — add the two new parameters at the bottom of the init parameter list:
+
+```swift
+    public init(
+        id: UsageProvider,
+        enabled: Bool? = nil,
+        source: ProviderSourceMode? = nil,
+        extrasEnabled: Bool? = nil,
+        apiKey: String? = nil,
+        cookieHeader: String? = nil,
+        cookieSource: ProviderCookieSource? = nil,
+        region: String? = nil,
+        workspaceID: String? = nil,
+        enterpriseHost: String? = nil,
+        tokenAccounts: ProviderTokenAccountData? = nil,
+        codexActiveSource: CodexActiveSource? = nil,
+        quotaWarnings: QuotaWarningConfig? = nil,
+        kiloKnownOrganizations: [KiloOrganization]? = nil,
+        kiloEnabledOrganizationIDs: [String]? = nil)
+    {
+        self.id = id
+        self.enabled = enabled
+        self.source = source
+        self.extrasEnabled = extrasEnabled
+        self.apiKey = apiKey
+        self.cookieHeader = cookieHeader
+        self.cookieSource = cookieSource
+        self.region = region
+        self.workspaceID = workspaceID
+        self.enterpriseHost = enterpriseHost
+        self.tokenAccounts = tokenAccounts
+        self.codexActiveSource = codexActiveSource
+        self.quotaWarnings = quotaWarnings
+        self.kiloKnownOrganizations = kiloKnownOrganizations
+        self.kiloEnabledOrganizationIDs = kiloEnabledOrganizationIDs
+    }
+```
+
+The implicit `Codable` conformance will pick up the new optional fields automatically.
+
+- [ ] **Step 5.2: Build to verify schema compiles**
+
+```bash
+swift build 2>&1 | tail -5
+```
+
+Expected: build succeeds.
+
+- [ ] **Step 5.3: Commit**
+
+```bash
+git add Sources/CodexBarCore/Config/CodexBarConfig.swift
+git commit -m "feat(kilo): persist kilo organizations in ProviderConfig"
+```
+
+---
+
+## Task 6: Extend `SettingsStore` with Kilo orgs accessors
+
+**Files:**
+- Modify: `Sources/CodexBar/Providers/Kilo/KiloSettingsStore.swift`
+- Create: `Tests/CodexBarTests/KiloSettingsStoreTests.swift`
+
+- [ ] **Step 6.1: Write failing tests**
+
+Create `Tests/CodexBarTests/KiloSettingsStoreTests.swift`:
+
+```swift
+import Foundation
+import Testing
+@testable import CodexBar
+@testable import CodexBarCore
+
+@MainActor
+struct KiloSettingsStoreTests {
+    private func makeSettings() -> SettingsStore {
+        let env = ProviderConfigEnvironment(
+            configFileURL: FileManager.default.temporaryDirectory.appendingPathComponent(
+                "kilo-org-settings-test-\(UUID().uuidString).json"),
+            environment: [:])
+        return SettingsStore(providerConfigEnvironment: env)
+    }
+
+    @Test
+    func `defaults to empty known organizations and empty enabled ids`() {
+        let settings = self.makeSettings()
+        #expect(settings.kiloKnownOrganizations.isEmpty)
+        #expect(settings.kiloEnabledOrganizationIDs.isEmpty)
+    }
+
+    @Test
+    func `setting known organizations persists them`() {
+        let settings = self.makeSettings()
+        let orgs = [
+            KiloOrganization(id: "org_1", name: "Alpha", role: "owner"),
+            KiloOrganization(id: "org_2", name: "Beta", role: "member"),
+        ]
+        settings.kiloKnownOrganizations = orgs
+        #expect(settings.kiloKnownOrganizations == orgs)
+    }
+
+    @Test
+    func `setting enabled org ids persists them`() {
+        let settings = self.makeSettings()
+        settings.kiloEnabledOrganizationIDs = ["org_1", "org_2"]
+        #expect(settings.kiloEnabledOrganizationIDs == ["org_1", "org_2"])
+    }
+
+    @Test
+    func `setKiloKnownOrganizations prunes stale enabled ids`() {
+        let settings = self.makeSettings()
+        settings.kiloKnownOrganizations = [
+            KiloOrganization(id: "org_1", name: "Alpha", role: nil),
+            KiloOrganization(id: "org_2", name: "Beta", role: nil),
+        ]
+        settings.kiloEnabledOrganizationIDs = ["org_1", "org_2"]
+        settings.setKiloKnownOrganizationsPruningEnabled(
+            [KiloOrganization(id: "org_2", name: "Beta", role: nil)])
+        #expect(settings.kiloKnownOrganizations.map(\.id) == ["org_2"])
+        #expect(settings.kiloEnabledOrganizationIDs == ["org_2"])
+    }
+}
+```
+
+- [ ] **Step 6.2: Run, verify fail**
+
+```bash
+swift test --filter KiloSettingsStoreTests 2>&1 | tail -10
+```
+
+Expected: compile error — missing properties.
+
+- [ ] **Step 6.3: Add accessors to `KiloSettingsStore`**
+
+Append to `Sources/CodexBar/Providers/Kilo/KiloSettingsStore.swift`:
+
+```swift
+extension SettingsStore {
+    var kiloKnownOrganizations: [KiloOrganization] {
+        get { self.configSnapshot.providerConfig(for: .kilo)?.kiloKnownOrganizations ?? [] }
+        set {
+            self.updateProviderConfig(provider: .kilo) { entry in
+                entry.kiloKnownOrganizations = newValue.isEmpty ? nil : newValue
+            }
+        }
+    }
+
+    var kiloEnabledOrganizationIDs: [String] {
+        get { self.configSnapshot.providerConfig(for: .kilo)?.kiloEnabledOrganizationIDs ?? [] }
+        set {
+            let cleaned = Array(LinkedHashSet(newValue
+                .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
+                .filter { !$0.isEmpty }))
+            self.updateProviderConfig(provider: .kilo) { entry in
+                entry.kiloEnabledOrganizationIDs = cleaned.isEmpty ? nil : cleaned
+            }
+            self.logProviderModeChange(
+                provider: .kilo,
+                field: "enabledOrganizations",
+                value: cleaned.joined(separator: ","))
+        }
+    }
+
+    func setKiloKnownOrganizationsPruningEnabled(_ orgs: [KiloOrganization]) {
+        self.kiloKnownOrganizations = orgs
+        let validIDs = Set(orgs.map(\.id))
+        let pruned = self.kiloEnabledOrganizationIDs.filter { validIDs.contains($0) }
+        if pruned != self.kiloEnabledOrganizationIDs {
+            self.kiloEnabledOrganizationIDs = pruned
+        }
+    }
+
+    func kiloIsOrganizationEnabled(_ orgID: String) -> Bool {
+        self.kiloEnabledOrganizationIDs.contains(orgID)
+    }
+
+    func setKiloOrganization(_ orgID: String, enabled: Bool) {
+        var current = self.kiloEnabledOrganizationIDs
+        if enabled {
+            guard !current.contains(orgID) else { return }
+            current.append(orgID)
+        } else {
+            current.removeAll { $0 == orgID }
+        }
+        self.kiloEnabledOrganizationIDs = current
+    }
+}
+
+// Small order-preserving set used to dedupe enabled IDs without sorting.
+private struct LinkedHashSet<Element: Hashable>: Sequence {
+    private var seen: Set<Element> = []
+    private var ordered: [Element] = []
+
+    init<S: Sequence>(_ sequence: S) where S.Element == Element {
+        for element in sequence where self.seen.insert(element).inserted {
+            self.ordered.append(element)
+        }
+    }
+
+    func makeIterator() -> IndexingIterator<[Element]> {
+        self.ordered.makeIterator()
+    }
+}
+```
+
+- [ ] **Step 6.4: Run tests, verify pass**
+
+```bash
+swift test --filter KiloSettingsStoreTests 2>&1 | tail -10
+```
+
+Expected: all 4 tests pass.
+
+- [ ] **Step 6.5: Commit**
+
+```bash
+git add Sources/CodexBar/Providers/Kilo/KiloSettingsStore.swift \
+        Tests/CodexBarTests/KiloSettingsStoreTests.swift
+git commit -m "feat(kilo): settings accessors for known + enabled organizations"
+```
+
+---
+
+## Task 7: Wire scoped fetching into Kilo strategies
+
+**Files:**
+- Modify: `Sources/CodexBarCore/Providers/Kilo/KiloProviderDescriptor.swift`
+- Modify: `Sources/CodexBar/UsageStore+Refresh.swift`
+- Create: `Sources/CodexBar/Providers/Kilo/UsageStore+KiloOrgRefresh.swift`
+
+The `ProviderFetchStrategy` returns one `UsageSnapshot`, so we keep the existing strategy returning the personal scope. Org snapshots are fanned out at the UsageStore layer, mirroring `refreshTokenAccounts`.
+
+- [ ] **Step 7.1: Add scope-aware overload to the AP strategies (no-op call path so they still build)**
+
+This task does NOT change `KiloAPIFetchStrategy.fetch`. The strategy continues to fetch the personal scope. The fan-out is added at the UsageStore layer below. Skip directly to step 7.2.
+
+- [ ] **Step 7.2: Add a Kilo scope account adapter**
+
+The codebase already has `TokenAccountUsageSnapshot` for stacked rendering. We mirror that for Kilo scopes.
+
+Create `Sources/CodexBar/Providers/Kilo/UsageStore+KiloOrgRefresh.swift`:
+
+```swift
+import CodexBarCore
+import Foundation
+
+struct KiloScopeSnapshot: Identifiable, Equatable {
+    let id: String // KiloUsageScope.scopeIdentifier
+    let scope: KiloUsageScope
+    let snapshot: UsageSnapshot?
+    let errorMessage: String?
+    let sourceLabel: String?
+
+    static func == (lhs: KiloScopeSnapshot, rhs: KiloScopeSnapshot) -> Bool {
+        lhs.id == rhs.id
+            && lhs.snapshot?.updatedAt == rhs.snapshot?.updatedAt
+            && lhs.errorMessage == rhs.errorMessage
+            && lhs.sourceLabel == rhs.sourceLabel
+    }
+}
+
+extension UsageStore {
+    var kiloEnabledScopes: [KiloUsageScope] {
+        var scopes: [KiloUsageScope] = [.personal]
+        let enabled = self.settings.kiloEnabledOrganizationIDs
+        guard !enabled.isEmpty else { return scopes }
+        let knownByID = Dictionary(
+            uniqueKeysWithValues: self.settings.kiloKnownOrganizations.map { ($0.id, $0) })
+        for id in enabled {
+            if let org = knownByID[id] {
+                scopes.append(.organization(id: org.id, name: org.name))
+            }
+        }
+        return scopes
+    }
+
+    func shouldFanOutKiloScopes() -> Bool {
+        self.kiloEnabledScopes.count > 1
+    }
+
+    func refreshKiloScopes() async {
+        let scopes = self.kiloEnabledScopes
+        guard scopes.count > 1 else {
+            await MainActor.run { self.kiloScopeSnapshots = [] }
+            return
+        }
+        let apiKey = self.settings.configSnapshot.providerConfig(for: .kilo)?.sanitizedAPIKey
+            ?? ProcessInfo.processInfo.environment[KiloSettingsReader.apiTokenKey]
+        guard let resolvedKey = apiKey, !resolvedKey.isEmpty else {
+            await MainActor.run {
+                self.kiloScopeSnapshots = scopes.map {
+                    KiloScopeSnapshot(
+                        id: $0.scopeIdentifier,
+                        scope: $0,
+                        snapshot: nil,
+                        errorMessage: "Kilo API credentials missing.",
+                        sourceLabel: nil)
+                }
+            }
+            return
+        }
+
+        let env = ProcessInfo.processInfo.environment
+        let results: [KiloScopeSnapshot] = await withTaskGroup(of: KiloScopeSnapshot.self) { group in
+            for scope in scopes {
+                group.addTask {
+                    do {
+                        let raw = try await KiloUsageFetcher.fetchUsage(
+                            apiKey: resolvedKey,
+                            scope: scope,
+                            environment: env)
+                        var snapshot = raw.toUsageSnapshot()
+                        snapshot = snapshot.replacingIdentityOrganization(scope.displayName)
+                        return KiloScopeSnapshot(
+                            id: scope.scopeIdentifier,
+                            scope: scope,
+                            snapshot: snapshot,
+                            errorMessage: nil,
+                            sourceLabel: "api")
+                    } catch {
+                        return KiloScopeSnapshot(
+                            id: scope.scopeIdentifier,
+                            scope: scope,
+                            snapshot: nil,
+                            errorMessage: (error as? LocalizedError)?.errorDescription
+                                ?? error.localizedDescription,
+                            sourceLabel: nil)
+                    }
+                }
+            }
+            var collected: [KiloScopeSnapshot] = []
+            for await result in group {
+                collected.append(result)
+            }
+            return collected
+        }
+
+        // Preserve the order from `scopes` (personal first, then enabled orgs in order).
+        let resultByID = Dictionary(uniqueKeysWithValues: results.map { ($0.id, $0) })
+        let ordered = scopes.compactMap { resultByID[$0.scopeIdentifier] }
+
+        await MainActor.run {
+            self.kiloScopeSnapshots = ordered
+        }
+    }
+}
+
+extension UsageSnapshot {
+    fileprivate func replacingIdentityOrganization(_ org: String) -> UsageSnapshot {
+        let baseIdentity = self.identity
+        let newIdentity = ProviderIdentitySnapshot(
+            providerID: baseIdentity?.providerID ?? .kilo,
+            accountEmail: baseIdentity?.accountEmail,
+            accountOrganization: org,
+            loginMethod: baseIdentity?.loginMethod)
+        return UsageSnapshot(
+            primary: self.primary,
+            secondary: self.secondary,
+            tertiary: self.tertiary,
+            providerCost: self.providerCost,
+            updatedAt: self.updatedAt,
+            identity: newIdentity)
+    }
+}
+```
+
+- [ ] **Step 7.3: Add the `kiloScopeSnapshots` stored property to `UsageStore`**
+
+In `Sources/CodexBar/UsageStore.swift`, find the closest place where Codex-related published properties live (e.g. near `codexAccountSnapshots`) and add:
+
+```swift
+    @Published var kiloScopeSnapshots: [KiloScopeSnapshot] = []
+```
+
+Choose a location adjacent to existing per-provider stacked snapshot arrays. The exact line is around `codexAccountSnapshots: [CodexAccountUsageSnapshot] = []` — add directly below it.
+
+- [ ] **Step 7.4: Invoke fan-out from `refreshProvider`**
+
+In `Sources/CodexBar/UsageStore+Refresh.swift`, find the existing `tokenAccounts` fan-out block in `refreshProvider`:
+
+```swift
+        let tokenAccounts = self.tokenAccounts(for: provider)
+        if self.shouldFetchAllTokenAccounts(provider: provider, accounts: tokenAccounts) {
+            await self.refreshTokenAccounts(provider: provider, accounts: tokenAccounts)
+            return
+        }
+```
+
+Insert directly above it (before line 55):
+
+```swift
+        if provider == .kilo, self.shouldFanOutKiloScopes() {
+            await self.refreshKiloScopes()
+            // Continue to also fetch the personal snapshot through the regular path
+            // so the existing single-card render keeps working when only personal is shown.
+            // The presence of multi-element kiloScopeSnapshots triggers stacked rendering.
+        }
+```
+
+- [ ] **Step 7.5: Reset `kiloScopeSnapshots` when Kilo is disabled or single-scope**
+
+Inside the existing disabled-provider branch of `refreshProvider` (the block that runs when `!spec.isEnabled()`), add inside the `MainActor.run`:
+
+```swift
+                if provider == .kilo {
+                    self.kiloScopeSnapshots = []
+                }
+```
+
+Also at the start of the regular fetch path (just before `let fetchContext = spec.makeFetchContext()`), add:
+
+```swift
+        if provider == .kilo, !self.shouldFanOutKiloScopes() {
+            await MainActor.run { self.kiloScopeSnapshots = [] }
+        }
+```
+
+- [ ] **Step 7.6: Build to confirm wiring compiles**
+
+```bash
+swift build 2>&1 | tail -15
+```
+
+Expected: succeeds. If `UsageSnapshot.replacingIdentityOrganization` clashes with an existing extension, rename to `withAccountOrganization` and update the call site.
+
+- [ ] **Step 7.7: Commit**
+
+```bash
+git add Sources/CodexBar/UsageStore.swift \
+        Sources/CodexBar/UsageStore+Refresh.swift \
+        Sources/CodexBar/Providers/Kilo/UsageStore+KiloOrgRefresh.swift
+git commit -m "feat(kilo): fan out usage fetch per enabled scope"
+```
+
+---
+
+## Task 8: Surface scope snapshots in menu rendering
+
+**Files:**
+- Modify: `Sources/CodexBar/StatusItemController+MenuCardModel.swift` (or the file that produces Kilo menu rows)
+- Modify: `Sources/CodexBar/MenuDescriptor.swift` if needed
+
+The menu currently renders one Kilo card. Add a branch: when `kiloScopeSnapshots` has 2+ entries, render one card per scope.
+
+- [ ] **Step 8.1: Locate the Kilo menu-row producer**
+
+```bash
+grep -n "case \\.kilo" Sources/CodexBar/StatusItemController*.swift Sources/CodexBar/Menu*.swift 2>&1 | head -15
+```
+
+This points at the rendering site. Open whichever file produces the per-provider row group for Kilo.
+
+- [ ] **Step 8.2: Insert scope-fan-out in the Kilo row builder**
+
+At the location that produces the Kilo `MenuCardModel` (or the equivalent NSMenu items), guard:
+
+```swift
+if !self.kiloScopeSnapshots.isEmpty, self.kiloScopeSnapshots.count > 1 {
+    return self.kiloScopeSnapshots.map { scope -> MenuCardModel in
+        self.makeKiloMenuCard(
+            snapshot: scope.snapshot,
+            errorMessage: scope.errorMessage,
+            sourceLabel: scope.sourceLabel,
+            scopeName: scope.scope.displayName)
+    }
+}
+```
+
+If a helper named `makeKiloMenuCard(...)` does not exist, factor the existing inline Kilo card construction into one, taking the four parameters above. Reuse the same code path used by Claude's stacked tokenAccount rendering as a structural reference.
+
+- [ ] **Step 8.3: Verify visually using CLI snapshot test (no UI required)**
+
+```bash
+swift test --filter CLIRendererTests 2>&1 | tail -15
+swift test --filter MenuCardModelTests 2>&1 | tail -15
+```
+
+Existing tests must continue to pass.
+
+- [ ] **Step 8.4: Build**
+
+```bash
+swift build 2>&1 | tail -5
+```
+
+Expected: success.
+
+- [ ] **Step 8.5: Commit**
+
+```bash
+git add Sources/CodexBar/StatusItemController+MenuCardModel.swift \
+        Sources/CodexBar/MenuDescriptor.swift
+git commit -m "feat(kilo): render one menu card per enabled scope"
+```
+
+---
+
+## Task 9: Preferences pane — Organizations section
+
+**Files:**
+- Modify: `Sources/CodexBar/Providers/Kilo/KiloProviderImplementation.swift`
+- Possibly modify: `Sources/CodexBar/PreferencesProviderDetailView.swift` and `Sources/CodexBarCore/Providers/ProviderDescriptor.swift` if a new descriptor variant is needed.
+
+If a multi-toggle descriptor is not yet supported, surface the org list using a `ProviderSettingsFieldDescriptor.kind = .info`-style wrapper combined with action buttons, OR add a new descriptor variant. Pick the minimum needed.
+
+- [ ] **Step 9.1: Add an org-section descriptor type**
+
+Search first to see whether the existing `ProviderSettingsFieldDescriptor` already has a list/toggle kind:
+
+```bash
+grep -n "enum Kind\|case info\|case toggleList\|case checkboxList" \
+    Sources/CodexBarCore/Providers/ProviderDescriptor.swift \
+    Sources/CodexBar/PreferencesProviderDetailView.swift 2>&1 | head -20
+```
+
+If a toggle-list kind exists, reuse it. Otherwise, add a new `ProviderSettingsOrganizationsDescriptor` in `Sources/CodexBarCore/Providers/ProviderDescriptor.swift`:
+
+```swift
+public struct ProviderSettingsOrganizationsDescriptor: Sendable {
+    public let id: String
+    public let title: String
+    public let subtitle: String?
+    public let entries: () -> [Entry]
+    public let onToggle: @MainActor (String, Bool) -> Void
+    public let onRefresh: @MainActor () async -> RefreshOutcome
+    public let canRefresh: () -> Bool
+
+    public struct Entry: Sendable, Identifiable {
+        public let id: String
+        public let title: String
+        public let subtitle: String?
+        public let isEnabled: Bool
+        public let isLocked: Bool
+
+        public init(id: String, title: String, subtitle: String?, isEnabled: Bool, isLocked: Bool) {
+            self.id = id
+            self.title = title
+            self.subtitle = subtitle
+            self.isEnabled = isEnabled
+            self.isLocked = isLocked
+        }
+    }
+
+    public struct RefreshOutcome: Sendable {
+        public let success: Bool
+        public let errorMessage: String?
+
+        public init(success: Bool, errorMessage: String? = nil) {
+            self.success = success
+            self.errorMessage = errorMessage
+        }
+    }
+
+    public init(
+        id: String,
+        title: String,
+        subtitle: String?,
+        entries: @escaping () -> [Entry],
+        onToggle: @escaping @MainActor (String, Bool) -> Void,
+        onRefresh: @escaping @MainActor () async -> RefreshOutcome,
+        canRefresh: @escaping () -> Bool)
+    {
+        self.id = id
+        self.title = title
+        self.subtitle = subtitle
+        self.entries = entries
+        self.onToggle = onToggle
+        self.onRefresh = onRefresh
+        self.canRefresh = canRefresh
+    }
+}
+```
+
+Then add an optional `settingsOrganizations:` slot to whatever protocol `ProviderImplementation` exposes (e.g. add `func settingsOrganizations(context: ProviderSettingsContext) -> ProviderSettingsOrganizationsDescriptor?`). Default the protocol method to `nil`.
+
+- [ ] **Step 9.2: Implement `settingsOrganizations` in `KiloProviderImplementation`**
+
+In `Sources/CodexBar/Providers/Kilo/KiloProviderImplementation.swift`:
+
+```swift
+    @MainActor
+    func settingsOrganizations(
+        context: ProviderSettingsContext) -> ProviderSettingsOrganizationsDescriptor?
+    {
+        ProviderSettingsOrganizationsDescriptor(
+            id: "kilo-organizations",
+            title: "Organizations",
+            subtitle: "Show usage for organizations you belong to. Personal account is always shown.",
+            entries: {
+                var entries: [ProviderSettingsOrganizationsDescriptor.Entry] = [
+                    .init(
+                        id: "personal",
+                        title: "Personal account",
+                        subtitle: nil,
+                        isEnabled: true,
+                        isLocked: true),
+                ]
+                for org in context.settings.kiloKnownOrganizations {
+                    entries.append(
+                        .init(
+                            id: org.id,
+                            title: org.name,
+                            subtitle: org.role,
+                            isEnabled: context.settings.kiloIsOrganizationEnabled(org.id),
+                            isLocked: false))
+                }
+                return entries
+            },
+            onToggle: { orgID, enabled in
+                guard orgID != "personal" else { return }
+                context.settings.setKiloOrganization(orgID, enabled: enabled)
+            },
+            onRefresh: {
+                let apiKey = context.settings.kiloAPIToken.isEmpty
+                    ? ProcessInfo.processInfo.environment[KiloSettingsReader.apiTokenKey] ?? ""
+                    : context.settings.kiloAPIToken
+                guard !apiKey.isEmpty else {
+                    return .init(success: false,
+                        errorMessage: "Set the Kilo API key first.")
+                }
+                do {
+                    let orgs = try await KiloUsageFetcher.fetchOrganizations(apiKey: apiKey)
+                    context.settings.setKiloKnownOrganizationsPruningEnabled(orgs)
+                    return .init(success: true)
+                } catch let error as LocalizedError {
+                    return .init(success: false,
+                        errorMessage: error.errorDescription ?? "Failed to load organizations.")
+                } catch {
+                    return .init(success: false,
+                        errorMessage: error.localizedDescription)
+                }
+            },
+            canRefresh: {
+                !context.settings.kiloAPIToken.isEmpty
+                    || !(ProcessInfo.processInfo.environment[KiloSettingsReader.apiTokenKey] ?? "").isEmpty
+            })
+    }
+```
+
+- [ ] **Step 9.3: Render the new descriptor in `PreferencesProviderDetailView`**
+
+In `Sources/CodexBar/PreferencesProviderDetailView.swift`, follow the existing pattern used by `settingsTokenAccounts`. Add a stored property `settingsOrganizations: ProviderSettingsOrganizationsDescriptor?`, source it from the provider implementation, and render it as a SwiftUI section under the API key:
+
+```swift
+if let descriptor = self.settingsOrganizations {
+    Section(descriptor.title) {
+        if let subtitle = descriptor.subtitle {
+            Text(subtitle).font(.caption).foregroundStyle(.secondary)
+        }
+        ForEach(descriptor.entries(), id: \.id) { entry in
+            Toggle(isOn: Binding(
+                get: { entry.isEnabled },
+                set: { newValue in descriptor.onToggle(entry.id, newValue) }))
+            {
+                VStack(alignment: .leading, spacing: 2) {
+                    Text(entry.title)
+                    if let subtitle = entry.subtitle {
+                        Text(subtitle).font(.caption).foregroundStyle(.secondary)
+                    }
+                }
+            }
+            .disabled(entry.isLocked)
+        }
+        HStack {
+            Button("Refresh organizations") {
+                Task {
+                    let result = await descriptor.onRefresh()
+                    if !result.success, let message = result.errorMessage {
+                        self.kiloOrganizationsErrorMessage = message
+                    } else {
+                        self.kiloOrganizationsErrorMessage = nil
+                    }
+                }
+            }
+            .disabled(!descriptor.canRefresh())
+            Spacer()
+            if let message = self.kiloOrganizationsErrorMessage {
+                Text(message).font(.caption).foregroundStyle(.red)
+            }
+        }
+    }
+}
+```
+
+Add `@State private var kiloOrganizationsErrorMessage: String?` near other `@State` properties in the view.
+
+- [ ] **Step 9.4: Build and verify**
+
+```bash
+swift build 2>&1 | tail -10
+```
+
+Expected: success. If type mismatches arise, follow them and align signatures.
+
+- [ ] **Step 9.5: Commit**
+
+```bash
+git add Sources/CodexBarCore/Providers/ProviderDescriptor.swift \
+        Sources/CodexBar/Providers/Kilo/KiloProviderImplementation.swift \
+        Sources/CodexBar/PreferencesProviderDetailView.swift
+git commit -m "feat(kilo): Preferences organizations section with refresh + toggles"
+```
+
+---
+
+## Task 10: Update Kilo docs
+
+**Files:**
+- Modify: `docs/kilo.md`
+
+- [ ] **Step 10.1: Add a "Organizations" section**
+
+Append to `docs/kilo.md`:
+
+```markdown
+## Organizations
+
+CodexBar can show usage for any Kilo organization the API key belongs to.
+
+- Open Preferences → Providers → Kilo, set the API key, then click **Refresh
+  organizations**.
+- Toggle the organizations you want to display alongside Personal. Personal is
+  always shown.
+- When at least one organization is enabled, the menu renders one Kilo card per
+  enabled scope.
+- The CodexBar fetcher sends the standard `X-KILOCODE-ORGANIZATIONID` header on
+  every usage call to scope the response to that organization.
+- CLI source mode (`auth.json`): the header is applied to CLI-resolved tokens
+  as well. If a CLI token isn't authorized for the chosen organization, that
+  card surfaces an unauthorized error while Personal and other enabled scopes
+  continue to render normally.
+```
+
+- [ ] **Step 10.2: Commit**
+
+```bash
+git add docs/kilo.md
+git commit -m "docs(kilo): document organization selection"
+```
+
+---
+
+## Task 11: Repo-wide validation
+
+- [ ] **Step 11.1: Run the full unit test suite**
+
+```bash
+swift test 2>&1 | tail -30
+```
+
+Expected: all tests pass. If new failures appear in unrelated tests (network-flaky, etc.), record and rerun.
+
+- [ ] **Step 11.2: Run `make check`**
+
+```bash
+make check 2>&1 | tail -30
+```
+
+Expected: swiftformat + swiftlint clean. Fix any reported issues by applying suggestions inline and re-running.
+
+- [ ] **Step 11.3: Build release config to ensure no debug-only types leaked**
+
+```bash
+swift build -c release 2>&1 | tail -10
+```
+
+Expected: success.
+
+- [ ] **Step 11.4: Commit any lint/format fixups**
+
+```bash
+git status
+git diff --stat
+git add -A
+git commit -m "chore: swiftformat/swiftlint fixups for kilo orgs work"
+```
+
+(Skip if no diff.)
+
+---
+
+## Task 12: Open the PR (lead-only — runs after all build tasks land)
+
+- [ ] **Step 12.1: Ensure a fork exists for `noefabris`**
+
+```bash
+gh repo view noefabris/CodexBar --json url 2>&1 | head -5
+```
+
+If 404, fork:
+
+```bash
+gh repo fork steipete/CodexBar --remote=false --clone=false
+```
+
+- [ ] **Step 12.2: Add fork as a remote (if missing) and push**
+
+```bash
+git remote get-url fork 2>/dev/null || git remote add fork https://github.com/noefabris/CodexBar.git
+git push -u fork feat/kilo-organization-selection
+```
+
+- [ ] **Step 12.3: Create the PR**
+
+```bash
+gh pr create \
+  --repo steipete/CodexBar \
+  --base main \
+  --head noefabris:feat/kilo-organization-selection \
+  --title "Add Kilo organization selection (usage stacking)" \
+  --body "$(cat <<'EOF'
+## Summary
+- Adds Kilo organization selection to Preferences → Providers → Kilo.
+- Refresh button fetches `user.getOrganizations` (with `/api/profile` REST fallback).
+- Each enabled organization is fetched in parallel with the personal account using the standard `X-KILOCODE-ORGANIZATIONID` header.
+- The Kilo menu now stacks one card per enabled scope (Personal + each chosen org), reusing the existing multi-snapshot rendering pattern.
+
+## Design doc
+- `docs/superpowers/specs/2026-05-11-kilo-organization-selection-design.md`
+- `docs/superpowers/plans/2026-05-11-kilo-organization-selection.md`
+
+## Test plan
+- [x] `swift test` passes
+- [x] `make check` clean
+- [x] `swift build -c release` succeeds
+- [ ] Manual: launch app, set Kilo API key, hit Refresh organizations, toggle orgs, observe stacked menu cards
+- [ ] Manual: revoke org permission and confirm only that scope errors out
+
+🤖 Generated with [Claude Code](https://claude.com/claude-code)
+EOF
+)"
+```
+
+Capture the printed PR URL.
+
+- [ ] **Step 12.4: Report the PR URL back to the user**
+
+---
+
+## Self-review checklist
+
+- [x] Each spec section has at least one task implementing it.
+- [x] Task 4 covers both tRPC and REST org-discovery shapes (spec §2).
+- [x] Task 7 fan-out covers both API and CLI source modes — the strategy resolves the token, then `refreshKiloScopes` reuses the same API key transport.
+- [x] Persistence covered by Task 5 + 6.
+- [x] UI section covered by Task 9.
+- [x] Menu rendering covered by Task 8.
+- [x] Tests written before implementation per TDD in Tasks 1–6.
+- [x] No placeholders ("TBD", "fill in later", etc.).
+- [x] Types stay consistent: `KiloOrganization`, `KiloUsageScope`, `KiloScopeSnapshot` referenced consistently across tasks.
+- [x] Out-of-scope items from spec (menu switcher, multi-key auth, widget) intentionally absent.
+
+If during execution any task uncovers an actual gap not covered above (e.g. existing tests that mock `KiloUsageFetcher.fetchUsage(apiKey:environment:)` without `scope`), update them to use `scope: .personal` explicitly — keep the default-parameter migration path even though tests typically pass it explicitly.
diff --git a/docs/superpowers/specs/2026-05-11-kilo-organization-selection-design.md b/docs/superpowers/specs/2026-05-11-kilo-organization-selection-design.md
new file mode 100644
index 0000000000..0483236c9e
--- /dev/null
+++ b/docs/superpowers/specs/2026-05-11-kilo-organization-selection-design.md
@@ -0,0 +1,156 @@
+---
+summary: "Design spec for Kilo organization-scoped usage fetching, settings, and menu rendering."
+read_when:
+  - Designing or implementing Kilo organization support
+  - Changing Kilo scoped usage request headers
+  - Updating Kilo organization settings persistence
+---
+
+# Kilo Organization Selection & Usage — Design
+
+**Status:** approved
+**Date:** 2026-05-11
+**Owner:** noefabris
+
+## Problem
+
+The Kilo provider in CodexBar always queries the personal account. Users who belong to one or more Kilo organizations cannot see organization-level credits, KiloPass usage, or plan info. Kilo's own clients (VS Code extension, CLI) let users pick "Personal" or any organization they belong to and route requests with an `X-KILOCODE-ORGANIZATIONID` header.
+
+Goal: let CodexBar users opt in to seeing one or more Kilo organizations alongside their personal account.
+
+## Non-goals
+
+- Menu-bar org switcher. Selection lives in Preferences only.
+- Editing org membership from CodexBar (read-only consumer of Kilo's org list).
+- Per-org auth (CodexBar reuses the same API key/CLI session; Kilo's gateway scopes via header).
+- Replacing the existing single-account `Personal` flow when no orgs are configured.
+
+## Constraints / context
+
+- Kilo gateway accepts `X-KILOCODE-ORGANIZATIONID: <orgId>` to scope any authenticated request. Documented at `kilo.ai/docs/gateway/authentication`.
+- Profile endpoint shape (from `Kilo-Org/kilocode` `packages/kilo-gateway/src/api/profile.ts`):
+  `GET /api/profile` → `{ user: { email, name }, organizations: [{ id, name, role }] }`.
+- CodexBar's Kilo provider currently calls `https://app.kilo.ai/api/trpc` with procedures `user.getCreditBlocks`, `kiloPass.getState`, `user.getAutoTopUpPaymentMethod`. The `X-KILOCODE-ORGANIZATIONID` header is transport-level and must work for the same procedures.
+- Existing CodexBar patterns to reuse:
+  - `ProviderIdentitySnapshot.accountOrganization` for rendering the org name in a card.
+  - Stacked multi-snapshot rendering used by Claude tokenAccounts (Preferences → Advanced → Display).
+  - `~/.codexbar/config.json` per-provider entry for persisted state.
+
+## User stories
+
+1. **As a user with no orgs**, the Kilo card looks exactly as it does today. No new UI noise.
+2. **As a user with one or more orgs**, I can open Preferences → Providers → Kilo, hit "Refresh organizations", see my org list, and tick the orgs I want to monitor. Each enabled org appears as its own card stacked with Personal in the menu.
+3. **As a user whose API key isn't set**, the Organizations section explains I need the key first and the Refresh button is disabled.
+4. **As a user using CLI source mode**, org selection still works — the header is sent on every fetch regardless of where the bearer token came from.
+
+## Architecture
+
+### Data model
+
+- `KiloOrganization` (Sendable, Codable, Equatable) in `Sources/CodexBarCore/Providers/Kilo/`:
+  - `id: String`
+  - `name: String`
+  - `role: String?` (optional; treated as display-only)
+- `KiloUsageScope` (Sendable, Hashable) in same module:
+  - `.personal`
+  - `.organization(id: String, name: String)`
+  - A `scopeIdentifier` computed property: `"personal"` or `"org:<id>"` used as the snapshot map key.
+- `KiloUsageSnapshot` gains `scope: KiloUsageScope` (default `.personal` keeps existing call sites compiling).
+
+### API layer (`KiloUsageFetcher`)
+
+- Existing `fetchUsage(apiKey:environment:)` becomes:
+  `fetchUsage(apiKey:scope:environment:)` with `scope: KiloUsageScope = .personal`.
+  - When `.organization(id, _)`: set request header `X-KILOCODE-ORGANIZATIONID: id` on the existing tRPC batch URLRequest. Everything else unchanged.
+- New `fetchOrganizations(apiKey:environment:)` → `[KiloOrganization]`:
+  - Primary: tRPC batch call to `user.getOrganizations` against `https://app.kilo.ai/api/trpc`. Parse the same payload-context shape as other procedures (defensive against schema drift).
+  - Fallback: if tRPC returns 404 / endpoint not found, fall back to `GET https://api.kilo.ai/api/profile` and read `data.organizations`. Both endpoints are part of the documented Kilo Gateway.
+  - Returns `[]` (not error) when the user has no orgs.
+  - Maps `401/403 → KiloUsageError.unauthorized`, `404 → endpointNotFound`, etc., using the existing `statusError(for:)`.
+
+### Settings
+
+`SettingsStore` extension (new file `SettingsStore+Kilo.swift` or extend `KiloSettingsStore.swift`):
+
+- `kiloKnownOrganizations: [KiloOrganization]` — cache of organizations last fetched. Survives restart.
+- `kiloEnabledOrganizationIDs: Set<String>` — which orgs the user wants to fetch + render.
+- Personal scope is implicit: always enabled, can't be toggled off.
+
+Persistence:
+- Add `organizations: [KiloOrganization]?` and `enabledOrganizationIds: [String]?` to the Kilo provider's entry in `~/.codexbar/config.json`.
+- Mutators write through `updateProviderConfig(provider: .kilo)`.
+
+### Refresh / UsageStore
+
+- `UsageStore`'s Kilo refresh path computes the active scope list: `[.personal] + enabled orgs from kiloKnownOrganizations`.
+- Fan-out using a `TaskGroup`, one child per scope, each calling `KiloUsageFetcher.fetchUsage(apiKey:scope:)`.
+- Per-scope failures isolated: a 403 on one org sets that scope's error state but does not affect personal or other orgs.
+- Snapshots stored in a new dictionary `kiloScopedSnapshots: [String: KiloUsageSnapshot]` keyed by `scope.scopeIdentifier`, alongside the existing single-snapshot field. When `kiloScopedSnapshots` has more than one entry the menu uses stacked rendering; otherwise existing single-card rendering.
+
+### UI — Preferences → Providers → Kilo
+
+- New section header "Organizations" placed below the API key field.
+- Row 1 (always): `Personal account` with a disabled-on checkbox.
+- Rows 2..N: each known organization with a togglable checkbox `[✓] <Org name> — <role>`.
+- Empty state when `kiloKnownOrganizations` is empty: "No organizations loaded. Click Refresh after setting your API key."
+- "Refresh organizations" button:
+  - Disabled when API key is empty.
+  - Calls `KiloUsageFetcher.fetchOrganizations(apiKey:)` on a background task.
+  - On success: writes to `kiloKnownOrganizations`, prunes `kiloEnabledOrganizationIDs` entries that no longer exist.
+  - On 401/403: surface inline error "API key unauthorized. Refresh or update it."
+  - On network error: surface inline error.
+
+### Menu rendering
+
+- The Kilo card renderer reads `kiloScopedSnapshots`. When count > 1, render each as a stacked card using the same vertical layout already used by Claude's stacked tokenAccount snapshots.
+- Each scope's card sets `ProviderIdentitySnapshot.accountOrganization`:
+  - `.personal` → `"Personal"`
+  - `.organization(_, name)` → `name`
+- Existing credit/pass/plan rows render unchanged inside each card.
+
+### Errors / edge cases
+
+| Case | Behavior |
+| --- | --- |
+| User has no orgs | Personal scope only. Org section shows empty state. No fan-out. |
+| API key missing | Refresh button disabled. Existing missing-credentials error still surfaces on usage fetch. |
+| Org refresh fails (401/403) | Inline error in Preferences; keep cached list. |
+| Org usage fetch returns 403 | That org's card shows a small error label; personal + other orgs render normally. |
+| Org removed on Kilo side | Next Refresh drops it from `kiloKnownOrganizations`; if it was in `kiloEnabledOrganizationIDs` it is silently pruned. |
+| CLI source mode | Header sent same way. If the resolved CLI bearer can't scope to that org, it 403s — handled by the per-scope error case above. |
+| Source = `auto` | Org scope follows the same auto fallback; failures inside the scope respect the fallback chain. |
+| Multiple orgs enabled | Concurrent fetch; per-scope timeouts isolated. |
+
+## Testing
+
+- Unit tests (in `Tests/CodexBarTests`):
+  - `KiloUsageFetcherTests`:
+    - Header injection: `.organization(id, _)` → request contains `X-KILOCODE-ORGANIZATIONID: id`. `.personal` → no header.
+    - `fetchOrganizations` parses both tRPC shape and `/api/profile` REST shape.
+    - 401/403 → `.unauthorized`.
+  - `KiloSettingsStoreTests`:
+    - Round-trip of `kiloKnownOrganizations` and `kiloEnabledOrganizationIDs` through config.json.
+    - Pruning of stale IDs when known list shrinks.
+  - `UsageStore+KiloRefreshTests`:
+    - Fan-out runs N scopes, per-scope error isolation.
+    - Single-scope path unchanged when no orgs enabled.
+- CLI snapshot test (`Tests/CodexBarTests/CLIRendererTests` or similar): `codexbar-cli kilo` shows one section per active scope when orgs are enabled.
+- Run `make check` and `swift test` before handoff.
+
+## Migration / compatibility
+
+- `KiloUsageSnapshot.scope` defaults to `.personal` — all existing call sites compile unchanged.
+- Config additions are optional — old configs continue to load as personal-only.
+- No new dependencies.
+
+## Open items (verify during build)
+
+- Confirm `https://app.kilo.ai/api/trpc/user.getOrganizations` exists. If not, the REST fallback to `https://api.kilo.ai/api/profile` is the path of record.
+- Confirm the tRPC procedures honor `X-KILOCODE-ORGANIZATIONID`. Documented for gateway; spot-check during integration.
+
+## Out of scope
+
+- Menu-bar org switcher UI.
+- Per-org token storage / multiple API keys for the same provider.
+- CLI command for org switching (`codexbar-cli` consumes the same settings).
+- Widget rendering changes for multi-scope (widget continues to show personal scope).
diff --git a/docs/ui.md b/docs/ui.md
index 3c9c7c3bf2..e5d5e085cb 100644
--- a/docs/ui.md
+++ b/docs/ui.md
@@ -10,25 +10,36 @@ read_when:
 ## Menu bar
 - LSUIElement app: no Dock icon; status item uses custom NSImage.
 - Merge Icons toggle combines providers into one status item with a switcher.
+- Provider status items use stable autosave names and are reused across provider toggles so macOS can preserve icon
+  positions.
 - When Overview has selected providers, the switcher includes an Overview tab that renders up to 3 provider rows.
 - Overview row order follows provider order; selecting a row jumps to that provider detail card.
+- The global open-menu keyboard shortcut toggles the currently tracked menu closed before opening a new one.
 
 ## Icon rendering
 - 18×18 template image.
-- Top bar = 5-hour window; bottom hairline = weekly window.
+- Bar windows are provider/style-specific primary and secondary windows.
 - Fill represents percent remaining by default; “Show usage as used” flips to percent used.
-- Dimmed when last refresh failed; status overlays render incident indicators.
-- Advanced: menu bar can show provider branding icons with a percent label instead of critter bars.
+- Renderer/critter icons dim when last refresh failed and can render incident indicators; brand display mode uses provider branding plus title text.
+- Loading animation runs at a bounded frame rate and has a hard continuous-duration ceiling so provider hangs cannot keep
+  the menu bar redrawing forever.
+- Display → Menu bar: menu bar can show provider branding icons with a percent label instead of critter bars.
+- Providers → Codex → Menu bar metric can combine the session-window and weekly percentages in one compact label.
 
 ## Menu card
-- Session + weekly rows with resets (countdown by default; optional absolute clock display).
-- Codex-only: Credits + “Buy Credits…” in-card action.
-- Web-only rows (when OpenAI cookies are enabled): code review remaining, usage breakdown submenu.
+- Provider-specific rows with resets (countdown by default; optional absolute clock display). Primary, secondary,
+  tertiary, and extra windows render when the provider snapshot has data for them.
+- Manual refresh updates the open card subtitle and persistent Refresh-row spinner in place. Repeated clicks share the
+  active request, and the existing row geometry remains fixed through success or failure.
+- Codex credits can add a separate “Buy Credits…” menu action.
+- Codex OpenAI web extras: code review remaining and usage breakdown render when dashboard data is attached.
 - Token accounts: optional account switcher bar or stacked account cards (up to 6) when multiple manual tokens exist.
+- Provider storage usage is opt-in from Advanced settings. When enabled, overview rows and provider detail cards can show
+  local provider-owned storage totals, with a submenu for path breakdowns and copyable paths.
 
 ## Pace tracking
 
-Pace compares your actual usage against an even-consumption budget that would spread your allowance evenly across the reset window.
+Pace compares your actual usage against the expected consumption rate for the current window. Most providers use an even-consumption budget; Codex can use historical pace data when historical tracking is available.
 
 - **On pace** – usage matches the expected rate.
 - **X% in deficit** – you're consuming faster than the even rate; at this pace you'll run out before the window resets.
@@ -36,18 +47,20 @@ Pace compares your actual usage against an even-consumption budget that would sp
 
 When usage is in deficit, the right-hand label shows an estimated "Runs out in …" countdown. When usage will last until the reset, it shows "Lasts until reset".
 
-Pace is calculated for Codex and Claude weekly windows only and is hidden when less than 3% of the window has elapsed.
+Pace is calculated for any provider window with enough reset timing data and is hidden when less than 3% of the
+window has elapsed.
 
 ## Preferences notes
 - Advanced: “Disable Keychain access” turns off browser cookie import; paste Cookie headers manually in Providers.
+- Advanced: “Show provider storage usage” enables background scans of known provider-owned local paths; CodexBar only
+  reports sizes and cleanup ideas, it does not delete files.
 - Display: “Overview tab providers” controls which providers appear in Merge Icons → Overview (up to 3).
 - If no providers are selected for Overview, the Overview tab is hidden.
-- Providers → Claude: “Keychain prompt policy” controls Claude OAuth prompt behavior (Never / Only on user action /
-  Always allow prompts).
-- When “Disable Keychain access” is enabled in Advanced, the Claude keychain prompt policy remains visible but is
-  inactive.
+- Providers → Claude: “Avoid Keychain prompts” uses the prompt-free Security CLI reader when available.
+- The lower-level “Keychain prompt policy” picker only appears when the Security.framework reader is active.
 
 ## Widgets (high level)
-- Widget entries mirror the menu card; detailed pipeline in `docs/widgets.md`.
+- Widgets render shared usage snapshots for the supported widget families and
+  provider picker; detailed pipeline in `docs/widgets.md`.
 
 See also: `docs/widgets.md`.
diff --git a/docs/venice.md b/docs/venice.md
new file mode 100644
index 0000000000..e0e8db4e48
--- /dev/null
+++ b/docs/venice.md
@@ -0,0 +1,48 @@
+---
+summary: "Venice provider setup, API-key balance query, and DIEM/USD balance display."
+read_when:
+  - Adding or modifying the Venice provider
+  - Debugging Venice API-key balance fetching
+  - Explaining Venice setup or balance display
+---
+
+# Venice
+
+[Venice](https://venice.ai) is an AI inference platform that provides API access to various language models.
+
+## Setup
+
+1. Sign up or log in at https://venice.ai
+2. Navigate to your API settings at https://venice.ai/settings/api
+3. Create or retrieve your API key
+4. In CodexBar, add your Venice API key via:
+   - Preferences > Providers > Venice, OR
+   - Set the environment variable `VENICE_API_KEY` or `VENICE_KEY`
+
+## Balance Query
+
+CodexBar fetches your current Venice API balance using the `/api/v1/billing/balance` endpoint.
+
+### Balance Types
+
+- **DIEM**: Venice's native credits (if epoch allocation is configured)
+- **USD**: Dollar balance if available
+- **Consumption Currency**: Indicates which currency is active for current billing
+
+### Display
+
+CodexBar shows:
+- Current remaining balance (DIEM or USD)
+- Epoch allocation progress (if applicable)
+- "Balance unavailable" if consumption is temporarily disabled
+
+## Troubleshooting
+
+**No balance showing?**
+- Verify your API key is correct
+- Check network connectivity
+- Ensure your Venice account has an active balance
+
+**API rate limiting?**
+- CodexBar caches balance data and updates every 30 seconds
+- If you hit rate limits, wait a moment before refreshing
diff --git a/docs/widgets.md b/docs/widgets.md
index 8fbff0f27d..adc749b1e8 100644
--- a/docs/widgets.md
+++ b/docs/widgets.md
@@ -11,11 +11,30 @@ read_when:
 ## Snapshot pipeline
 - `WidgetSnapshotStore` writes compact JSON snapshots to the app-group container.
 - Widgets read the snapshot and render usage/credits/history states.
+- The app writes snapshots after the main refresh pipeline and token-usage refreshes; narrow single-provider refresh paths may wait for the next snapshot write.
+- If no snapshot is available, widgets fall back to preview/empty data.
 
 ## Extension
 - `Sources/CodexBarWidget` contains timeline + views.
+- `WidgetExtension/CodexBarWidgetExtension.xcodeproj` builds those sources as the packaged macOS WidgetKit app extension.
 - Keep data shape in sync with `WidgetSnapshot` in the main app.
 
+## Widget types
+- **CodexBar Switcher** (`CodexBarSwitcherWidget`): static provider switcher widget, small/medium/large.
+- **CodexBar Usage** (`CodexBarUsageWidget`): configurable provider usage widget, small/medium/large.
+- **CodexBar History** (`CodexBarHistoryWidget`): configurable usage-history chart, medium/large.
+- **CodexBar Metric** (`CodexBarCompactWidget`): compact credits/today-cost/30-day-cost widget, small only.
+- **CodexBar Burn Down** (`CodexBarBurnDownWidget`): configurable session or weekly burn-down chart, medium only.
+- **CodexBar Burn Down (Combined)** (`CodexBarCombinedBurnDownWidget`): session and weekly burn-down charts, medium only.
+
+## Provider picker support
+The configurable provider widgets currently expose:
+Codex, Claude, Gemini, Alibaba, Antigravity, z.ai, Copilot, MiniMax, Kilo, OpenCode, and OpenCode Go.
+
+Providers without a `ProviderChoice` case can still be present in the app snapshot, but they are not selectable from the widget configuration UI yet.
+
+Burn-down widgets currently support Codex and Claude. Their dedicated configuration intents keep existing Usage and History widget configurations unchanged.
+
 ## Visibility troubleshooting (macOS 14+)
 When widgets do not appear in the gallery at all, the issue is almost always
 registration, signing, or daemon caching (not SwiftUI code).
@@ -24,6 +43,7 @@ registration, signing, or daemon caching (not SwiftUI code).
 ```
 APP="/Applications/CodexBar.app"
 WAPPEX="$APP/Contents/PlugIns/CodexBarWidget.appex"
+WIDGET_ID="com.steipete.codexbar.widget" # debug builds use com.steipete.codexbar.debug.widget
 
 ls -la "$WAPPEX" "$WAPPEX/Contents" "$WAPPEX/Contents/MacOS"
 ```
@@ -31,18 +51,18 @@ ls -la "$WAPPEX" "$WAPPEX/Contents" "$WAPPEX/Contents/MacOS"
 ### 2) PlugInKit registration (pkd)
 ```
 pluginkit -m -p com.apple.widgetkit-extension -v | grep -i codexbar || true
-pluginkit -m -p com.apple.widgetkit-extension -i com.steipete.codexbar.widget -vv
+pluginkit -m -p com.apple.widgetkit-extension -i "$WIDGET_ID" -vv
 ```
 Notes:
 - `+` = elected to use, `-` = ignored (PlugInKit elections).
 - If missing or ignored, force-add and re-elect:
 ```
 pluginkit -a "$WAPPEX"
-pluginkit -e use -p com.apple.widgetkit-extension -i com.steipete.codexbar.widget
+pluginkit -e use -p com.apple.widgetkit-extension -i "$WIDGET_ID"
 ```
 - Check for duplicates (old installs or version precedence):
 ```
-pluginkit -m -D -p com.apple.widgetkit-extension -i com.steipete.codexbar.widget -vv
+pluginkit -m -D -p com.apple.widgetkit-extension -i "$WIDGET_ID" -vv
 ```
 If multiple paths appear, delete older installs and bump `CFBundleVersion`.
 
@@ -68,7 +88,7 @@ log stream --style compact --predicate '(process == "pkd" OR process == "chronod
 ```
 
 ### 6) Packaging sanity checks
-- Widget bundle id should be `com.steipete.codexbar.widget`.
+- Widget bundle id should be `com.steipete.codexbar.widget` for release and `com.steipete.codexbar.debug.widget` for debug.
 - `NSExtensionPointIdentifier` must be `com.apple.widgetkit-extension`.
 - Bundle folder name should match: `CodexBarWidget.appex`.
 
diff --git a/docs/windsurf.md b/docs/windsurf.md
new file mode 100644
index 0000000000..dcbb19ed4a
--- /dev/null
+++ b/docs/windsurf.md
@@ -0,0 +1,172 @@
+---
+summary: "Windsurf provider data sources: browser localStorage session import, local SQLite cache, and GetPlanStatus protobuf API."
+read_when:
+  - Debugging Windsurf usage fetch
+  - Updating Windsurf web session import or API handling
+  - Adjusting Windsurf provider UI/menu behavior
+---
+
+# Windsurf provider
+
+Windsurf supports two data sources: a web API backed by the current website session, and a local SQLite cache.
+
+## Data sources + fallback order
+
+Usage source picker:
+- Preferences → Providers → Windsurf → Usage source (Auto / Web API / Local).
+
+### Auto mode (default)
+1) **Web API** (preferred) — real-time data from windsurf.com.
+2) **Local SQLite cache** (fallback) — reads from Windsurf's `state.vscdb`.
+
+### Web API fetch order
+1) **Manual session bundle** (when Cookie source = Manual).
+2) **Browser localStorage import** — extracts complete `devin_*` session bundles from Chromium browsers, checking
+   `app.devin.ai` before the legacy `windsurf.com` origin.
+
+### Local SQLite cache
+- File: `~/Library/Application Support/Windsurf/User/globalStorage/state.vscdb`.
+- Key: `windsurf.settings.cachedPlanInfo` in `ItemTable`.
+- Newer cache shapes may omit `quotaUsage` but include `usage` counters. In that case CodexBar derives
+  usage windows from `usedMessages/messages` and `usedFlowActions/flowActions`.
+- Limitation: only updates when Windsurf is launched; can be significantly stale.
+
+## Cookie source settings
+
+Preferences → Providers → Windsurf → Cookie source:
+
+- **Automatic** (default): imports the active Windsurf session bundle from Chromium browser localStorage.
+- **Manual**: paste a JSON bundle with `devin_session_token`, `devin_auth1_token`, `devin_account_id`, and `devin_primary_org_id`.
+- **Off**: disables web API access entirely; only local SQLite cache is used.
+
+### How to get a manual session bundle
+
+1. Open [windsurf.com/profile](https://windsurf.com/profile) in Chrome or Edge and sign in.
+2. Open Developer Tools (`F12` or `Cmd+Option+I`).
+3. Go to the **Console** tab.
+4. Paste the following JavaScript and press Enter:
+
+```javascript
+(() => {
+  const keys = [
+    "devin_session_token",
+    "devin_auth1_token",
+    "devin_account_id",
+    "devin_primary_org_id",
+  ];
+
+  const read = (key) => {
+    const value = localStorage.getItem(key);
+    if (!value) return null;
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  };
+
+  const payload = Object.fromEntries(keys.map((key) => [key, read(key)]));
+  const missing = keys.filter((key) => !payload[key]);
+
+  if (missing.length > 0) {
+    console.log("Missing Windsurf session keys:", missing.join(", "));
+    return;
+  }
+
+  const json = JSON.stringify(payload, null, 2);
+  console.log(json);
+  if (typeof copy === "function") {
+    copy(json);
+    console.log("Copied Windsurf session bundle to clipboard.");
+  }
+})();
+```
+
+5. Copy the JSON output.
+6. In CodexBar: Providers → Windsurf → Cookie source → Manual → paste the JSON bundle.
+
+## Authentication flow (Automatic mode)
+
+```text
+Browser localStorage (leveldb on disk)
+    ↓ extract devin_session_token / devin_auth1_token / devin_account_id / devin_primary_org_id
+POST https://windsurf.com/_backend/.../GetPlanStatus
+    ↓ headers: x-auth-token + x-devin-*
+    ↓ protobuf body: { auth_token, include_top_up_status: true }
+UsageSnapshot (daily/weekly quota %)
+```
+
+## Browser session extraction
+
+- **Browsers scanned**: Chrome, Edge, Brave, Arc, Vivaldi, Chromium, and compatible Chromium forks.
+- **Local storage path**: `~/Library/Application Support/<Browser>/<Profile>/Local Storage/leveldb/`
+- **Origins**: `https://app.devin.ai`, then legacy `https://windsurf.com`
+- Values from different structured origins are never combined. A partial app-origin bundle cannot contaminate a
+  complete legacy-origin fallback.
+- **Required keys**:
+  - `devin_session_token`
+  - `devin_auth1_token`
+  - `devin_account_id`
+  - `devin_primary_org_id`
+
+## API endpoint
+
+### GetPlanStatus (ConnectRPC over protobuf)
+- `POST https://windsurf.com/_backend/exa.seat_management_pb.SeatManagementService/GetPlanStatus`
+- Headers:
+  - `Content-Type: application/proto`
+  - `Connect-Protocol-Version: 1`
+  - `Origin: https://windsurf.com`
+  - `Referer: https://windsurf.com/profile`
+  - `x-auth-token: <devin_session_token>`
+  - `x-devin-session-token: <devin_session_token>`
+  - `x-devin-auth1-token: <devin_auth1_token>`
+  - `x-devin-account-id: <devin_account_id>`
+  - `x-devin-primary-org-id: <devin_primary_org_id>`
+- Protobuf request fields:
+  - `1 auth_token: string`
+  - `2 include_top_up_status: bool`
+- Parsed response fields used by CodexBar:
+  - `plan_status.plan_info.plan_name`
+  - `plan_status.plan_end`
+  - `plan_status.daily_quota_remaining_percent`
+  - `plan_status.weekly_quota_remaining_percent`
+  - `plan_status.daily_quota_reset_at_unix`
+  - `plan_status.weekly_quota_reset_at_unix`
+
+## Snapshot mapping
+- Web primary: daily usage percent (`100 - daily_quota_remaining_percent`).
+- Web secondary: weekly usage percent (`100 - weekly_quota_remaining_percent`).
+- Local primary: daily quota percent when present; otherwise message usage (`usedMessages/messages`).
+- Local secondary: weekly quota percent when present; otherwise flow-action usage (`usedFlowActions/flowActions`).
+- Reset: daily/weekly reset timestamps (Unix seconds), when available.
+- Plan: `plan_status.plan_info.plan_name`.
+- Expiry: `plan_status.plan_end`.
+
+## Troubleshooting
+
+### "No Windsurf web session found in Chromium localStorage"
+- Sign in to [app.devin.ai](https://app.devin.ai) or [windsurf.com](https://windsurf.com) in Chrome, Edge, or another
+  Chromium browser.
+- Grant Full Disk Access to CodexBar (System Settings → Privacy & Security → Full Disk Access).
+- Try Manual mode and paste the JSON session bundle directly.
+
+### "Invalid Windsurf session payload"
+- The manual value must include all four keys: `devin_session_token`, `devin_auth1_token`, `devin_account_id`, and `devin_primary_org_id`.
+- Re-run the console snippet on a logged-in `windsurf.com` page.
+
+### "Windsurf API call failed: HTTP 401"
+- The imported browser session is stale or invalid.
+- Refresh the Windsurf page in your browser and try again.
+- If using Manual mode, paste a fresh JSON bundle.
+
+### Stale data with Local mode
+- The local SQLite cache only updates when Windsurf is launched. Switch to Auto or Web API mode for real-time data.
+
+## Key files
+- `Sources/CodexBarCore/Providers/Windsurf/WindsurfStatusProbe.swift` (local SQLite)
+- `Sources/CodexBarCore/Providers/Windsurf/WindsurfDevinSessionImporter.swift` (Chromium localStorage extraction)
+- `Sources/CodexBarCore/Providers/Windsurf/WindsurfWebFetcher.swift` (protobuf request + response parsing)
+- `Sources/CodexBarCore/Providers/Windsurf/WindsurfProviderDescriptor.swift` (fetch strategies)
+- `Sources/CodexBar/Providers/Windsurf/WindsurfProviderImplementation.swift` (settings UI)
+- `Sources/CodexBar/Providers/Windsurf/WindsurfSettingsStore.swift` (settings persistence)
diff --git a/docs/zai.md b/docs/zai.md
index 8cf044e29e..7c4c2c2bbf 100644
--- a/docs/zai.md
+++ b/docs/zai.md
@@ -21,10 +21,19 @@ z.ai is API-token based. No browser cookies.
 - BigModel (China mainland) host: `https://open.bigmodel.cn`
 - Override host via Providers → z.ai → *API region* or `Z_AI_API_HOST=open.bigmodel.cn`.
 - Override the full quota URL (e.g. coding plan endpoint) via `Z_AI_QUOTA_URL=https://open.bigmodel.cn/api/coding/paas/v4`.
+- Endpoint overrides must be explicit HTTPS URLs or bare hosts/paths that CodexBar normalizes to HTTPS. Explicit
+  `http://` overrides fail closed before the bearer token is attached to a request. If both z.ai overrides are set,
+  `Z_AI_QUOTA_URL` has priority for quota requests; a stale lower-priority `Z_AI_API_HOST` is ignored for that quota
+  path, but direct model-usage requests still validate `Z_AI_API_HOST` before sending bearer auth.
 - Headers:
   - `authorization: Bearer <token>`
   - `accept: application/json`
 
+## Usage dashboard
+- Global: `https://z.ai/manage-apikey/coding-plan/personal/my-plan`
+- BigModel China: `https://bigmodel.cn/coding-plan/personal/usage`
+- CodexBar's Usage Dashboard action follows the configured API region.
+
 ## Parsing + mapping
 - Response fields:
   - `data.limits[]` → each limit entry.
diff --git a/docs/zed.md b/docs/zed.md
new file mode 100644
index 0000000000..b60994164c
--- /dev/null
+++ b/docs/zed.md
@@ -0,0 +1,76 @@
+---
+summary: "Zed provider data source: editor Keychain session and Zed cloud API."
+read_when:
+  - Debugging Zed usage fetch
+  - Updating Zed Keychain or cloud API handling
+  - Adjusting Zed provider UI/menu behavior
+---
+
+# Zed provider
+
+CodexBar monitors Zed plan status, billing cycle dates, edit-prediction quota, and overdue invoices via Zed's cloud API.
+
+## Data source
+
+**Local probe (Keychain + cloud API)** — reads the same credentials Zed stores after GitHub sign-in, then calls:
+
+```text
+GET https://cloud.zed.dev/client/users/me
+Authorization: {user_id} {access_token}
+```
+
+### Keychain credentials
+
+| Item | Value |
+| --- | --- |
+| Service URL | `https://zed.dev` by default, or the configured HTTPS `server_url` for a custom server |
+| Keychain class | **Internet password** (`kSecClassInternetPassword`, server = service URL). Generic-password fallback is supported for older layouts. |
+| Account | Zed user ID (string) |
+| Secret | Access token (UTF-8 bytes) |
+
+CodexBar requests a non-interactive Keychain read. Existing Zed items can still carry an access-control list that makes
+macOS show a SecurityAgent prompt the first time CodexBar reads them. Choose **Always Allow** to avoid repeat prompts. If
+Zed has never been signed in, or access is denied, the provider reports **Not signed in to Zed**.
+
+### Settings override
+
+CodexBar reads Zed’s user settings from `~/.config/zed/settings.json`. The `credentials_url` setting (falls back to
+`server_url`) selects which Keychain entry to read. For the trusted
+`https://zed.dev` and `https://staging.zed.dev` servers, Zed may use a separate credential identifier. Custom servers
+must use HTTPS and store credentials under the exact same `server_url`; CodexBar rejects cross-origin overrides so a
+settings-file change cannot forward a Keychain token to another host.
+
+## Snapshot mapping
+
+| Zed field | CodexBar display |
+| --- | --- |
+| `plan.plan_v3` | Plan label (Free / Pro / Trial / Student / Business) |
+| `plan.usage.edit_predictions` | Primary bar: used/limit or “Unlimited” on Pro+ |
+| `plan.subscription_period.ended_at` | Billing cycle reset / secondary window |
+| `plan.has_overdue_invoices` | Warning note + billing window marker |
+
+## Limitations
+
+### Not tracked as “Zed”
+
+Per [LLM Providers](https://zed.dev/docs/ai/llm-providers.html) and [External Agents](https://zed.dev/docs/ai/external-agents.html):
+
+- BYOK models → track via OpenAI, Claude, Gemini, etc.
+- External agents (Claude Agent, Codex ACP) → bill through those providers
+
+## Troubleshooting
+
+### “Not signed in to Zed”
+- Sign in from the **Zed editor app** (Command Palette → `client: sign in`).
+- Confirm a Keychain internet-password entry exists for server `https://zed.dev` (or your custom `credentials_url`).
+
+### “Could not read Zed credentials from the Keychain”
+- macOS may block Keychain access until you allow CodexBar (same class of issue as other IDE probes).
+- Re-sign in to Zed after changing `credentials_url`.
+
+## Key files
+
+- `Sources/CodexBarCore/Providers/Zed/ZedStatusProbe.swift` - Keychain read, cloud API, snapshot mapping
+- `Sources/CodexBarCore/Providers/Zed/ZedProviderDescriptor.swift` - provider metadata and local fetch strategy
+- `Sources/CodexBar/Providers/Zed/ZedProviderImplementation.swift` - app registration
+- `Tests/CodexBarTests/ZedStatusProbeTests.swift` - cloud API and routing tests
diff --git a/package.json b/package.json
deleted file mode 100644
index f7a9875067..0000000000
--- a/package.json
+++ /dev/null
@@ -1,20 +0,0 @@
-{
-  "name": "codexbar",
-  "private": true,
-  "scripts": {
-    "start": "./Scripts/compile_and_run.sh",
-    "start:debug": "./Scripts/compile_and_run.sh",
-    "start:release": "sh -c './Scripts/package_app.sh release && (pkill -x CodexBar || pkill -f CodexBar.app || true) && cd /Users/steipete/Projects/codexbar && open -n /Users/steipete/Projects/codexbar/CodexBar.app'",
-    "lint": "./Scripts/lint.sh lint",
-    "format": "./Scripts/lint.sh format",
-    "check": "./Scripts/lint.sh lint",
-    "docs:list": "node Scripts/docs-list.mjs",
-    "build": "swift build",
-    "test": "swift test",
-    "test:tty": "swift test --filter TTYIntegrationTests",
-    "test:live": "LIVE_TEST=1 swift test --filter LiveAccountTests",
-    "release": "./Scripts/package_app.sh release",
-    "restart": "pnpm start",
-    "stop": "pkill -x CodexBar || pkill -f CodexBar.app || true"
-  }
-}
diff --git a/version.env b/version.env
index ec4258206f..33d5c45642 100644
--- a/version.env
+++ b/version.env
@@ -1,2 +1,2 @@
-MARKETING_VERSION=0.18.0-beta.3
-BUILD_NUMBER=51
+MARKETING_VERSION=0.37.3
+BUILD_NUMBER=93